Documents Packages The Project Help Blog

The Go Programming Language

Source file src/pkg/cmd/compile/internal/ssa/rewriteS390X.go

     1	// Code generated from gen/S390X.rules; DO NOT EDIT.
     2	// generated with: cd gen; go run *.go
     3	
     4	package ssa
     5	
     6	import "fmt"
     7	import "math"
     8	import "cmd/internal/obj"
     9	import "cmd/internal/objabi"
    10	import "cmd/compile/internal/types"
    11	
    12	var _ = fmt.Println   // in case not otherwise used
    13	var _ = math.MinInt8  // in case not otherwise used
    14	var _ = obj.ANOP      // in case not otherwise used
    15	var _ = objabi.GOROOT // in case not otherwise used
    16	var _ = types.TypeMem // in case not otherwise used
    17	
    18	func rewriteValueS390X(v *Value) bool {
    19		switch v.Op {
    20		case OpAdd16:
    21			return rewriteValueS390X_OpAdd16_0(v)
    22		case OpAdd32:
    23			return rewriteValueS390X_OpAdd32_0(v)
    24		case OpAdd32F:
    25			return rewriteValueS390X_OpAdd32F_0(v)
    26		case OpAdd64:
    27			return rewriteValueS390X_OpAdd64_0(v)
    28		case OpAdd64F:
    29			return rewriteValueS390X_OpAdd64F_0(v)
    30		case OpAdd8:
    31			return rewriteValueS390X_OpAdd8_0(v)
    32		case OpAddPtr:
    33			return rewriteValueS390X_OpAddPtr_0(v)
    34		case OpAddr:
    35			return rewriteValueS390X_OpAddr_0(v)
    36		case OpAnd16:
    37			return rewriteValueS390X_OpAnd16_0(v)
    38		case OpAnd32:
    39			return rewriteValueS390X_OpAnd32_0(v)
    40		case OpAnd64:
    41			return rewriteValueS390X_OpAnd64_0(v)
    42		case OpAnd8:
    43			return rewriteValueS390X_OpAnd8_0(v)
    44		case OpAndB:
    45			return rewriteValueS390X_OpAndB_0(v)
    46		case OpAtomicAdd32:
    47			return rewriteValueS390X_OpAtomicAdd32_0(v)
    48		case OpAtomicAdd64:
    49			return rewriteValueS390X_OpAtomicAdd64_0(v)
    50		case OpAtomicCompareAndSwap32:
    51			return rewriteValueS390X_OpAtomicCompareAndSwap32_0(v)
    52		case OpAtomicCompareAndSwap64:
    53			return rewriteValueS390X_OpAtomicCompareAndSwap64_0(v)
    54		case OpAtomicExchange32:
    55			return rewriteValueS390X_OpAtomicExchange32_0(v)
    56		case OpAtomicExchange64:
    57			return rewriteValueS390X_OpAtomicExchange64_0(v)
    58		case OpAtomicLoad32:
    59			return rewriteValueS390X_OpAtomicLoad32_0(v)
    60		case OpAtomicLoad64:
    61			return rewriteValueS390X_OpAtomicLoad64_0(v)
    62		case OpAtomicLoad8:
    63			return rewriteValueS390X_OpAtomicLoad8_0(v)
    64		case OpAtomicLoadAcq32:
    65			return rewriteValueS390X_OpAtomicLoadAcq32_0(v)
    66		case OpAtomicLoadPtr:
    67			return rewriteValueS390X_OpAtomicLoadPtr_0(v)
    68		case OpAtomicStore32:
    69			return rewriteValueS390X_OpAtomicStore32_0(v)
    70		case OpAtomicStore64:
    71			return rewriteValueS390X_OpAtomicStore64_0(v)
    72		case OpAtomicStorePtrNoWB:
    73			return rewriteValueS390X_OpAtomicStorePtrNoWB_0(v)
    74		case OpAtomicStoreRel32:
    75			return rewriteValueS390X_OpAtomicStoreRel32_0(v)
    76		case OpAvg64u:
    77			return rewriteValueS390X_OpAvg64u_0(v)
    78		case OpBitLen64:
    79			return rewriteValueS390X_OpBitLen64_0(v)
    80		case OpBswap32:
    81			return rewriteValueS390X_OpBswap32_0(v)
    82		case OpBswap64:
    83			return rewriteValueS390X_OpBswap64_0(v)
    84		case OpCeil:
    85			return rewriteValueS390X_OpCeil_0(v)
    86		case OpClosureCall:
    87			return rewriteValueS390X_OpClosureCall_0(v)
    88		case OpCom16:
    89			return rewriteValueS390X_OpCom16_0(v)
    90		case OpCom32:
    91			return rewriteValueS390X_OpCom32_0(v)
    92		case OpCom64:
    93			return rewriteValueS390X_OpCom64_0(v)
    94		case OpCom8:
    95			return rewriteValueS390X_OpCom8_0(v)
    96		case OpConst16:
    97			return rewriteValueS390X_OpConst16_0(v)
    98		case OpConst32:
    99			return rewriteValueS390X_OpConst32_0(v)
   100		case OpConst32F:
   101			return rewriteValueS390X_OpConst32F_0(v)
   102		case OpConst64:
   103			return rewriteValueS390X_OpConst64_0(v)
   104		case OpConst64F:
   105			return rewriteValueS390X_OpConst64F_0(v)
   106		case OpConst8:
   107			return rewriteValueS390X_OpConst8_0(v)
   108		case OpConstBool:
   109			return rewriteValueS390X_OpConstBool_0(v)
   110		case OpConstNil:
   111			return rewriteValueS390X_OpConstNil_0(v)
   112		case OpCtz32:
   113			return rewriteValueS390X_OpCtz32_0(v)
   114		case OpCtz32NonZero:
   115			return rewriteValueS390X_OpCtz32NonZero_0(v)
   116		case OpCtz64:
   117			return rewriteValueS390X_OpCtz64_0(v)
   118		case OpCtz64NonZero:
   119			return rewriteValueS390X_OpCtz64NonZero_0(v)
   120		case OpCvt32Fto32:
   121			return rewriteValueS390X_OpCvt32Fto32_0(v)
   122		case OpCvt32Fto64:
   123			return rewriteValueS390X_OpCvt32Fto64_0(v)
   124		case OpCvt32Fto64F:
   125			return rewriteValueS390X_OpCvt32Fto64F_0(v)
   126		case OpCvt32to32F:
   127			return rewriteValueS390X_OpCvt32to32F_0(v)
   128		case OpCvt32to64F:
   129			return rewriteValueS390X_OpCvt32to64F_0(v)
   130		case OpCvt64Fto32:
   131			return rewriteValueS390X_OpCvt64Fto32_0(v)
   132		case OpCvt64Fto32F:
   133			return rewriteValueS390X_OpCvt64Fto32F_0(v)
   134		case OpCvt64Fto64:
   135			return rewriteValueS390X_OpCvt64Fto64_0(v)
   136		case OpCvt64to32F:
   137			return rewriteValueS390X_OpCvt64to32F_0(v)
   138		case OpCvt64to64F:
   139			return rewriteValueS390X_OpCvt64to64F_0(v)
   140		case OpDiv16:
   141			return rewriteValueS390X_OpDiv16_0(v)
   142		case OpDiv16u:
   143			return rewriteValueS390X_OpDiv16u_0(v)
   144		case OpDiv32:
   145			return rewriteValueS390X_OpDiv32_0(v)
   146		case OpDiv32F:
   147			return rewriteValueS390X_OpDiv32F_0(v)
   148		case OpDiv32u:
   149			return rewriteValueS390X_OpDiv32u_0(v)
   150		case OpDiv64:
   151			return rewriteValueS390X_OpDiv64_0(v)
   152		case OpDiv64F:
   153			return rewriteValueS390X_OpDiv64F_0(v)
   154		case OpDiv64u:
   155			return rewriteValueS390X_OpDiv64u_0(v)
   156		case OpDiv8:
   157			return rewriteValueS390X_OpDiv8_0(v)
   158		case OpDiv8u:
   159			return rewriteValueS390X_OpDiv8u_0(v)
   160		case OpEq16:
   161			return rewriteValueS390X_OpEq16_0(v)
   162		case OpEq32:
   163			return rewriteValueS390X_OpEq32_0(v)
   164		case OpEq32F:
   165			return rewriteValueS390X_OpEq32F_0(v)
   166		case OpEq64:
   167			return rewriteValueS390X_OpEq64_0(v)
   168		case OpEq64F:
   169			return rewriteValueS390X_OpEq64F_0(v)
   170		case OpEq8:
   171			return rewriteValueS390X_OpEq8_0(v)
   172		case OpEqB:
   173			return rewriteValueS390X_OpEqB_0(v)
   174		case OpEqPtr:
   175			return rewriteValueS390X_OpEqPtr_0(v)
   176		case OpFloor:
   177			return rewriteValueS390X_OpFloor_0(v)
   178		case OpGeq16:
   179			return rewriteValueS390X_OpGeq16_0(v)
   180		case OpGeq16U:
   181			return rewriteValueS390X_OpGeq16U_0(v)
   182		case OpGeq32:
   183			return rewriteValueS390X_OpGeq32_0(v)
   184		case OpGeq32F:
   185			return rewriteValueS390X_OpGeq32F_0(v)
   186		case OpGeq32U:
   187			return rewriteValueS390X_OpGeq32U_0(v)
   188		case OpGeq64:
   189			return rewriteValueS390X_OpGeq64_0(v)
   190		case OpGeq64F:
   191			return rewriteValueS390X_OpGeq64F_0(v)
   192		case OpGeq64U:
   193			return rewriteValueS390X_OpGeq64U_0(v)
   194		case OpGeq8:
   195			return rewriteValueS390X_OpGeq8_0(v)
   196		case OpGeq8U:
   197			return rewriteValueS390X_OpGeq8U_0(v)
   198		case OpGetCallerPC:
   199			return rewriteValueS390X_OpGetCallerPC_0(v)
   200		case OpGetCallerSP:
   201			return rewriteValueS390X_OpGetCallerSP_0(v)
   202		case OpGetClosurePtr:
   203			return rewriteValueS390X_OpGetClosurePtr_0(v)
   204		case OpGetG:
   205			return rewriteValueS390X_OpGetG_0(v)
   206		case OpGreater16:
   207			return rewriteValueS390X_OpGreater16_0(v)
   208		case OpGreater16U:
   209			return rewriteValueS390X_OpGreater16U_0(v)
   210		case OpGreater32:
   211			return rewriteValueS390X_OpGreater32_0(v)
   212		case OpGreater32F:
   213			return rewriteValueS390X_OpGreater32F_0(v)
   214		case OpGreater32U:
   215			return rewriteValueS390X_OpGreater32U_0(v)
   216		case OpGreater64:
   217			return rewriteValueS390X_OpGreater64_0(v)
   218		case OpGreater64F:
   219			return rewriteValueS390X_OpGreater64F_0(v)
   220		case OpGreater64U:
   221			return rewriteValueS390X_OpGreater64U_0(v)
   222		case OpGreater8:
   223			return rewriteValueS390X_OpGreater8_0(v)
   224		case OpGreater8U:
   225			return rewriteValueS390X_OpGreater8U_0(v)
   226		case OpHmul32:
   227			return rewriteValueS390X_OpHmul32_0(v)
   228		case OpHmul32u:
   229			return rewriteValueS390X_OpHmul32u_0(v)
   230		case OpHmul64:
   231			return rewriteValueS390X_OpHmul64_0(v)
   232		case OpHmul64u:
   233			return rewriteValueS390X_OpHmul64u_0(v)
   234		case OpITab:
   235			return rewriteValueS390X_OpITab_0(v)
   236		case OpInterCall:
   237			return rewriteValueS390X_OpInterCall_0(v)
   238		case OpIsInBounds:
   239			return rewriteValueS390X_OpIsInBounds_0(v)
   240		case OpIsNonNil:
   241			return rewriteValueS390X_OpIsNonNil_0(v)
   242		case OpIsSliceInBounds:
   243			return rewriteValueS390X_OpIsSliceInBounds_0(v)
   244		case OpLeq16:
   245			return rewriteValueS390X_OpLeq16_0(v)
   246		case OpLeq16U:
   247			return rewriteValueS390X_OpLeq16U_0(v)
   248		case OpLeq32:
   249			return rewriteValueS390X_OpLeq32_0(v)
   250		case OpLeq32F:
   251			return rewriteValueS390X_OpLeq32F_0(v)
   252		case OpLeq32U:
   253			return rewriteValueS390X_OpLeq32U_0(v)
   254		case OpLeq64:
   255			return rewriteValueS390X_OpLeq64_0(v)
   256		case OpLeq64F:
   257			return rewriteValueS390X_OpLeq64F_0(v)
   258		case OpLeq64U:
   259			return rewriteValueS390X_OpLeq64U_0(v)
   260		case OpLeq8:
   261			return rewriteValueS390X_OpLeq8_0(v)
   262		case OpLeq8U:
   263			return rewriteValueS390X_OpLeq8U_0(v)
   264		case OpLess16:
   265			return rewriteValueS390X_OpLess16_0(v)
   266		case OpLess16U:
   267			return rewriteValueS390X_OpLess16U_0(v)
   268		case OpLess32:
   269			return rewriteValueS390X_OpLess32_0(v)
   270		case OpLess32F:
   271			return rewriteValueS390X_OpLess32F_0(v)
   272		case OpLess32U:
   273			return rewriteValueS390X_OpLess32U_0(v)
   274		case OpLess64:
   275			return rewriteValueS390X_OpLess64_0(v)
   276		case OpLess64F:
   277			return rewriteValueS390X_OpLess64F_0(v)
   278		case OpLess64U:
   279			return rewriteValueS390X_OpLess64U_0(v)
   280		case OpLess8:
   281			return rewriteValueS390X_OpLess8_0(v)
   282		case OpLess8U:
   283			return rewriteValueS390X_OpLess8U_0(v)
   284		case OpLoad:
   285			return rewriteValueS390X_OpLoad_0(v)
   286		case OpLocalAddr:
   287			return rewriteValueS390X_OpLocalAddr_0(v)
   288		case OpLsh16x16:
   289			return rewriteValueS390X_OpLsh16x16_0(v)
   290		case OpLsh16x32:
   291			return rewriteValueS390X_OpLsh16x32_0(v)
   292		case OpLsh16x64:
   293			return rewriteValueS390X_OpLsh16x64_0(v)
   294		case OpLsh16x8:
   295			return rewriteValueS390X_OpLsh16x8_0(v)
   296		case OpLsh32x16:
   297			return rewriteValueS390X_OpLsh32x16_0(v)
   298		case OpLsh32x32:
   299			return rewriteValueS390X_OpLsh32x32_0(v)
   300		case OpLsh32x64:
   301			return rewriteValueS390X_OpLsh32x64_0(v)
   302		case OpLsh32x8:
   303			return rewriteValueS390X_OpLsh32x8_0(v)
   304		case OpLsh64x16:
   305			return rewriteValueS390X_OpLsh64x16_0(v)
   306		case OpLsh64x32:
   307			return rewriteValueS390X_OpLsh64x32_0(v)
   308		case OpLsh64x64:
   309			return rewriteValueS390X_OpLsh64x64_0(v)
   310		case OpLsh64x8:
   311			return rewriteValueS390X_OpLsh64x8_0(v)
   312		case OpLsh8x16:
   313			return rewriteValueS390X_OpLsh8x16_0(v)
   314		case OpLsh8x32:
   315			return rewriteValueS390X_OpLsh8x32_0(v)
   316		case OpLsh8x64:
   317			return rewriteValueS390X_OpLsh8x64_0(v)
   318		case OpLsh8x8:
   319			return rewriteValueS390X_OpLsh8x8_0(v)
   320		case OpMod16:
   321			return rewriteValueS390X_OpMod16_0(v)
   322		case OpMod16u:
   323			return rewriteValueS390X_OpMod16u_0(v)
   324		case OpMod32:
   325			return rewriteValueS390X_OpMod32_0(v)
   326		case OpMod32u:
   327			return rewriteValueS390X_OpMod32u_0(v)
   328		case OpMod64:
   329			return rewriteValueS390X_OpMod64_0(v)
   330		case OpMod64u:
   331			return rewriteValueS390X_OpMod64u_0(v)
   332		case OpMod8:
   333			return rewriteValueS390X_OpMod8_0(v)
   334		case OpMod8u:
   335			return rewriteValueS390X_OpMod8u_0(v)
   336		case OpMove:
   337			return rewriteValueS390X_OpMove_0(v) || rewriteValueS390X_OpMove_10(v)
   338		case OpMul16:
   339			return rewriteValueS390X_OpMul16_0(v)
   340		case OpMul32:
   341			return rewriteValueS390X_OpMul32_0(v)
   342		case OpMul32F:
   343			return rewriteValueS390X_OpMul32F_0(v)
   344		case OpMul64:
   345			return rewriteValueS390X_OpMul64_0(v)
   346		case OpMul64F:
   347			return rewriteValueS390X_OpMul64F_0(v)
   348		case OpMul8:
   349			return rewriteValueS390X_OpMul8_0(v)
   350		case OpNeg16:
   351			return rewriteValueS390X_OpNeg16_0(v)
   352		case OpNeg32:
   353			return rewriteValueS390X_OpNeg32_0(v)
   354		case OpNeg32F:
   355			return rewriteValueS390X_OpNeg32F_0(v)
   356		case OpNeg64:
   357			return rewriteValueS390X_OpNeg64_0(v)
   358		case OpNeg64F:
   359			return rewriteValueS390X_OpNeg64F_0(v)
   360		case OpNeg8:
   361			return rewriteValueS390X_OpNeg8_0(v)
   362		case OpNeq16:
   363			return rewriteValueS390X_OpNeq16_0(v)
   364		case OpNeq32:
   365			return rewriteValueS390X_OpNeq32_0(v)
   366		case OpNeq32F:
   367			return rewriteValueS390X_OpNeq32F_0(v)
   368		case OpNeq64:
   369			return rewriteValueS390X_OpNeq64_0(v)
   370		case OpNeq64F:
   371			return rewriteValueS390X_OpNeq64F_0(v)
   372		case OpNeq8:
   373			return rewriteValueS390X_OpNeq8_0(v)
   374		case OpNeqB:
   375			return rewriteValueS390X_OpNeqB_0(v)
   376		case OpNeqPtr:
   377			return rewriteValueS390X_OpNeqPtr_0(v)
   378		case OpNilCheck:
   379			return rewriteValueS390X_OpNilCheck_0(v)
   380		case OpNot:
   381			return rewriteValueS390X_OpNot_0(v)
   382		case OpOffPtr:
   383			return rewriteValueS390X_OpOffPtr_0(v)
   384		case OpOr16:
   385			return rewriteValueS390X_OpOr16_0(v)
   386		case OpOr32:
   387			return rewriteValueS390X_OpOr32_0(v)
   388		case OpOr64:
   389			return rewriteValueS390X_OpOr64_0(v)
   390		case OpOr8:
   391			return rewriteValueS390X_OpOr8_0(v)
   392		case OpOrB:
   393			return rewriteValueS390X_OpOrB_0(v)
   394		case OpPanicBounds:
   395			return rewriteValueS390X_OpPanicBounds_0(v)
   396		case OpPopCount16:
   397			return rewriteValueS390X_OpPopCount16_0(v)
   398		case OpPopCount32:
   399			return rewriteValueS390X_OpPopCount32_0(v)
   400		case OpPopCount64:
   401			return rewriteValueS390X_OpPopCount64_0(v)
   402		case OpPopCount8:
   403			return rewriteValueS390X_OpPopCount8_0(v)
   404		case OpRotateLeft16:
   405			return rewriteValueS390X_OpRotateLeft16_0(v)
   406		case OpRotateLeft32:
   407			return rewriteValueS390X_OpRotateLeft32_0(v)
   408		case OpRotateLeft64:
   409			return rewriteValueS390X_OpRotateLeft64_0(v)
   410		case OpRotateLeft8:
   411			return rewriteValueS390X_OpRotateLeft8_0(v)
   412		case OpRound:
   413			return rewriteValueS390X_OpRound_0(v)
   414		case OpRound32F:
   415			return rewriteValueS390X_OpRound32F_0(v)
   416		case OpRound64F:
   417			return rewriteValueS390X_OpRound64F_0(v)
   418		case OpRoundToEven:
   419			return rewriteValueS390X_OpRoundToEven_0(v)
   420		case OpRsh16Ux16:
   421			return rewriteValueS390X_OpRsh16Ux16_0(v)
   422		case OpRsh16Ux32:
   423			return rewriteValueS390X_OpRsh16Ux32_0(v)
   424		case OpRsh16Ux64:
   425			return rewriteValueS390X_OpRsh16Ux64_0(v)
   426		case OpRsh16Ux8:
   427			return rewriteValueS390X_OpRsh16Ux8_0(v)
   428		case OpRsh16x16:
   429			return rewriteValueS390X_OpRsh16x16_0(v)
   430		case OpRsh16x32:
   431			return rewriteValueS390X_OpRsh16x32_0(v)
   432		case OpRsh16x64:
   433			return rewriteValueS390X_OpRsh16x64_0(v)
   434		case OpRsh16x8:
   435			return rewriteValueS390X_OpRsh16x8_0(v)
   436		case OpRsh32Ux16:
   437			return rewriteValueS390X_OpRsh32Ux16_0(v)
   438		case OpRsh32Ux32:
   439			return rewriteValueS390X_OpRsh32Ux32_0(v)
   440		case OpRsh32Ux64:
   441			return rewriteValueS390X_OpRsh32Ux64_0(v)
   442		case OpRsh32Ux8:
   443			return rewriteValueS390X_OpRsh32Ux8_0(v)
   444		case OpRsh32x16:
   445			return rewriteValueS390X_OpRsh32x16_0(v)
   446		case OpRsh32x32:
   447			return rewriteValueS390X_OpRsh32x32_0(v)
   448		case OpRsh32x64:
   449			return rewriteValueS390X_OpRsh32x64_0(v)
   450		case OpRsh32x8:
   451			return rewriteValueS390X_OpRsh32x8_0(v)
   452		case OpRsh64Ux16:
   453			return rewriteValueS390X_OpRsh64Ux16_0(v)
   454		case OpRsh64Ux32:
   455			return rewriteValueS390X_OpRsh64Ux32_0(v)
   456		case OpRsh64Ux64:
   457			return rewriteValueS390X_OpRsh64Ux64_0(v)
   458		case OpRsh64Ux8:
   459			return rewriteValueS390X_OpRsh64Ux8_0(v)
   460		case OpRsh64x16:
   461			return rewriteValueS390X_OpRsh64x16_0(v)
   462		case OpRsh64x32:
   463			return rewriteValueS390X_OpRsh64x32_0(v)
   464		case OpRsh64x64:
   465			return rewriteValueS390X_OpRsh64x64_0(v)
   466		case OpRsh64x8:
   467			return rewriteValueS390X_OpRsh64x8_0(v)
   468		case OpRsh8Ux16:
   469			return rewriteValueS390X_OpRsh8Ux16_0(v)
   470		case OpRsh8Ux32:
   471			return rewriteValueS390X_OpRsh8Ux32_0(v)
   472		case OpRsh8Ux64:
   473			return rewriteValueS390X_OpRsh8Ux64_0(v)
   474		case OpRsh8Ux8:
   475			return rewriteValueS390X_OpRsh8Ux8_0(v)
   476		case OpRsh8x16:
   477			return rewriteValueS390X_OpRsh8x16_0(v)
   478		case OpRsh8x32:
   479			return rewriteValueS390X_OpRsh8x32_0(v)
   480		case OpRsh8x64:
   481			return rewriteValueS390X_OpRsh8x64_0(v)
   482		case OpRsh8x8:
   483			return rewriteValueS390X_OpRsh8x8_0(v)
   484		case OpS390XADD:
   485			return rewriteValueS390X_OpS390XADD_0(v) || rewriteValueS390X_OpS390XADD_10(v)
   486		case OpS390XADDC:
   487			return rewriteValueS390X_OpS390XADDC_0(v)
   488		case OpS390XADDE:
   489			return rewriteValueS390X_OpS390XADDE_0(v)
   490		case OpS390XADDW:
   491			return rewriteValueS390X_OpS390XADDW_0(v) || rewriteValueS390X_OpS390XADDW_10(v)
   492		case OpS390XADDWconst:
   493			return rewriteValueS390X_OpS390XADDWconst_0(v)
   494		case OpS390XADDWload:
   495			return rewriteValueS390X_OpS390XADDWload_0(v)
   496		case OpS390XADDconst:
   497			return rewriteValueS390X_OpS390XADDconst_0(v)
   498		case OpS390XADDload:
   499			return rewriteValueS390X_OpS390XADDload_0(v)
   500		case OpS390XAND:
   501			return rewriteValueS390X_OpS390XAND_0(v) || rewriteValueS390X_OpS390XAND_10(v)
   502		case OpS390XANDW:
   503			return rewriteValueS390X_OpS390XANDW_0(v) || rewriteValueS390X_OpS390XANDW_10(v)
   504		case OpS390XANDWconst:
   505			return rewriteValueS390X_OpS390XANDWconst_0(v)
   506		case OpS390XANDWload:
   507			return rewriteValueS390X_OpS390XANDWload_0(v)
   508		case OpS390XANDconst:
   509			return rewriteValueS390X_OpS390XANDconst_0(v)
   510		case OpS390XANDload:
   511			return rewriteValueS390X_OpS390XANDload_0(v)
   512		case OpS390XCMP:
   513			return rewriteValueS390X_OpS390XCMP_0(v)
   514		case OpS390XCMPU:
   515			return rewriteValueS390X_OpS390XCMPU_0(v)
   516		case OpS390XCMPUconst:
   517			return rewriteValueS390X_OpS390XCMPUconst_0(v) || rewriteValueS390X_OpS390XCMPUconst_10(v)
   518		case OpS390XCMPW:
   519			return rewriteValueS390X_OpS390XCMPW_0(v)
   520		case OpS390XCMPWU:
   521			return rewriteValueS390X_OpS390XCMPWU_0(v)
   522		case OpS390XCMPWUconst:
   523			return rewriteValueS390X_OpS390XCMPWUconst_0(v)
   524		case OpS390XCMPWconst:
   525			return rewriteValueS390X_OpS390XCMPWconst_0(v)
   526		case OpS390XCMPconst:
   527			return rewriteValueS390X_OpS390XCMPconst_0(v) || rewriteValueS390X_OpS390XCMPconst_10(v)
   528		case OpS390XCPSDR:
   529			return rewriteValueS390X_OpS390XCPSDR_0(v)
   530		case OpS390XFADD:
   531			return rewriteValueS390X_OpS390XFADD_0(v)
   532		case OpS390XFADDS:
   533			return rewriteValueS390X_OpS390XFADDS_0(v)
   534		case OpS390XFMOVDload:
   535			return rewriteValueS390X_OpS390XFMOVDload_0(v)
   536		case OpS390XFMOVDloadidx:
   537			return rewriteValueS390X_OpS390XFMOVDloadidx_0(v)
   538		case OpS390XFMOVDstore:
   539			return rewriteValueS390X_OpS390XFMOVDstore_0(v)
   540		case OpS390XFMOVDstoreidx:
   541			return rewriteValueS390X_OpS390XFMOVDstoreidx_0(v)
   542		case OpS390XFMOVSload:
   543			return rewriteValueS390X_OpS390XFMOVSload_0(v)
   544		case OpS390XFMOVSloadidx:
   545			return rewriteValueS390X_OpS390XFMOVSloadidx_0(v)
   546		case OpS390XFMOVSstore:
   547			return rewriteValueS390X_OpS390XFMOVSstore_0(v)
   548		case OpS390XFMOVSstoreidx:
   549			return rewriteValueS390X_OpS390XFMOVSstoreidx_0(v)
   550		case OpS390XFNEG:
   551			return rewriteValueS390X_OpS390XFNEG_0(v)
   552		case OpS390XFNEGS:
   553			return rewriteValueS390X_OpS390XFNEGS_0(v)
   554		case OpS390XFSUB:
   555			return rewriteValueS390X_OpS390XFSUB_0(v)
   556		case OpS390XFSUBS:
   557			return rewriteValueS390X_OpS390XFSUBS_0(v)
   558		case OpS390XLDGR:
   559			return rewriteValueS390X_OpS390XLDGR_0(v)
   560		case OpS390XLEDBR:
   561			return rewriteValueS390X_OpS390XLEDBR_0(v)
   562		case OpS390XLGDR:
   563			return rewriteValueS390X_OpS390XLGDR_0(v)
   564		case OpS390XLoweredRound32F:
   565			return rewriteValueS390X_OpS390XLoweredRound32F_0(v)
   566		case OpS390XLoweredRound64F:
   567			return rewriteValueS390X_OpS390XLoweredRound64F_0(v)
   568		case OpS390XMOVBZload:
   569			return rewriteValueS390X_OpS390XMOVBZload_0(v)
   570		case OpS390XMOVBZloadidx:
   571			return rewriteValueS390X_OpS390XMOVBZloadidx_0(v)
   572		case OpS390XMOVBZreg:
   573			return rewriteValueS390X_OpS390XMOVBZreg_0(v) || rewriteValueS390X_OpS390XMOVBZreg_10(v)
   574		case OpS390XMOVBload:
   575			return rewriteValueS390X_OpS390XMOVBload_0(v)
   576		case OpS390XMOVBloadidx:
   577			return rewriteValueS390X_OpS390XMOVBloadidx_0(v)
   578		case OpS390XMOVBreg:
   579			return rewriteValueS390X_OpS390XMOVBreg_0(v)
   580		case OpS390XMOVBstore:
   581			return rewriteValueS390X_OpS390XMOVBstore_0(v) || rewriteValueS390X_OpS390XMOVBstore_10(v)
   582		case OpS390XMOVBstoreconst:
   583			return rewriteValueS390X_OpS390XMOVBstoreconst_0(v)
   584		case OpS390XMOVBstoreidx:
   585			return rewriteValueS390X_OpS390XMOVBstoreidx_0(v) || rewriteValueS390X_OpS390XMOVBstoreidx_10(v) || rewriteValueS390X_OpS390XMOVBstoreidx_20(v) || rewriteValueS390X_OpS390XMOVBstoreidx_30(v)
   586		case OpS390XMOVDEQ:
   587			return rewriteValueS390X_OpS390XMOVDEQ_0(v)
   588		case OpS390XMOVDGE:
   589			return rewriteValueS390X_OpS390XMOVDGE_0(v)
   590		case OpS390XMOVDGT:
   591			return rewriteValueS390X_OpS390XMOVDGT_0(v)
   592		case OpS390XMOVDLE:
   593			return rewriteValueS390X_OpS390XMOVDLE_0(v)
   594		case OpS390XMOVDLT:
   595			return rewriteValueS390X_OpS390XMOVDLT_0(v)
   596		case OpS390XMOVDNE:
   597			return rewriteValueS390X_OpS390XMOVDNE_0(v)
   598		case OpS390XMOVDaddridx:
   599			return rewriteValueS390X_OpS390XMOVDaddridx_0(v)
   600		case OpS390XMOVDload:
   601			return rewriteValueS390X_OpS390XMOVDload_0(v)
   602		case OpS390XMOVDloadidx:
   603			return rewriteValueS390X_OpS390XMOVDloadidx_0(v)
   604		case OpS390XMOVDnop:
   605			return rewriteValueS390X_OpS390XMOVDnop_0(v) || rewriteValueS390X_OpS390XMOVDnop_10(v)
   606		case OpS390XMOVDreg:
   607			return rewriteValueS390X_OpS390XMOVDreg_0(v) || rewriteValueS390X_OpS390XMOVDreg_10(v)
   608		case OpS390XMOVDstore:
   609			return rewriteValueS390X_OpS390XMOVDstore_0(v)
   610		case OpS390XMOVDstoreconst:
   611			return rewriteValueS390X_OpS390XMOVDstoreconst_0(v)
   612		case OpS390XMOVDstoreidx:
   613			return rewriteValueS390X_OpS390XMOVDstoreidx_0(v)
   614		case OpS390XMOVHBRstore:
   615			return rewriteValueS390X_OpS390XMOVHBRstore_0(v)
   616		case OpS390XMOVHBRstoreidx:
   617			return rewriteValueS390X_OpS390XMOVHBRstoreidx_0(v) || rewriteValueS390X_OpS390XMOVHBRstoreidx_10(v)
   618		case OpS390XMOVHZload:
   619			return rewriteValueS390X_OpS390XMOVHZload_0(v)
   620		case OpS390XMOVHZloadidx:
   621			return rewriteValueS390X_OpS390XMOVHZloadidx_0(v)
   622		case OpS390XMOVHZreg:
   623			return rewriteValueS390X_OpS390XMOVHZreg_0(v) || rewriteValueS390X_OpS390XMOVHZreg_10(v)
   624		case OpS390XMOVHload:
   625			return rewriteValueS390X_OpS390XMOVHload_0(v)
   626		case OpS390XMOVHloadidx:
   627			return rewriteValueS390X_OpS390XMOVHloadidx_0(v)
   628		case OpS390XMOVHreg:
   629			return rewriteValueS390X_OpS390XMOVHreg_0(v) || rewriteValueS390X_OpS390XMOVHreg_10(v)
   630		case OpS390XMOVHstore:
   631			return rewriteValueS390X_OpS390XMOVHstore_0(v) || rewriteValueS390X_OpS390XMOVHstore_10(v)
   632		case OpS390XMOVHstoreconst:
   633			return rewriteValueS390X_OpS390XMOVHstoreconst_0(v)
   634		case OpS390XMOVHstoreidx:
   635			return rewriteValueS390X_OpS390XMOVHstoreidx_0(v) || rewriteValueS390X_OpS390XMOVHstoreidx_10(v)
   636		case OpS390XMOVWBRstore:
   637			return rewriteValueS390X_OpS390XMOVWBRstore_0(v)
   638		case OpS390XMOVWBRstoreidx:
   639			return rewriteValueS390X_OpS390XMOVWBRstoreidx_0(v)
   640		case OpS390XMOVWZload:
   641			return rewriteValueS390X_OpS390XMOVWZload_0(v)
   642		case OpS390XMOVWZloadidx:
   643			return rewriteValueS390X_OpS390XMOVWZloadidx_0(v)
   644		case OpS390XMOVWZreg:
   645			return rewriteValueS390X_OpS390XMOVWZreg_0(v) || rewriteValueS390X_OpS390XMOVWZreg_10(v)
   646		case OpS390XMOVWload:
   647			return rewriteValueS390X_OpS390XMOVWload_0(v)
   648		case OpS390XMOVWloadidx:
   649			return rewriteValueS390X_OpS390XMOVWloadidx_0(v)
   650		case OpS390XMOVWreg:
   651			return rewriteValueS390X_OpS390XMOVWreg_0(v) || rewriteValueS390X_OpS390XMOVWreg_10(v)
   652		case OpS390XMOVWstore:
   653			return rewriteValueS390X_OpS390XMOVWstore_0(v) || rewriteValueS390X_OpS390XMOVWstore_10(v)
   654		case OpS390XMOVWstoreconst:
   655			return rewriteValueS390X_OpS390XMOVWstoreconst_0(v)
   656		case OpS390XMOVWstoreidx:
   657			return rewriteValueS390X_OpS390XMOVWstoreidx_0(v) || rewriteValueS390X_OpS390XMOVWstoreidx_10(v)
   658		case OpS390XMULLD:
   659			return rewriteValueS390X_OpS390XMULLD_0(v)
   660		case OpS390XMULLDconst:
   661			return rewriteValueS390X_OpS390XMULLDconst_0(v)
   662		case OpS390XMULLDload:
   663			return rewriteValueS390X_OpS390XMULLDload_0(v)
   664		case OpS390XMULLW:
   665			return rewriteValueS390X_OpS390XMULLW_0(v)
   666		case OpS390XMULLWconst:
   667			return rewriteValueS390X_OpS390XMULLWconst_0(v)
   668		case OpS390XMULLWload:
   669			return rewriteValueS390X_OpS390XMULLWload_0(v)
   670		case OpS390XNEG:
   671			return rewriteValueS390X_OpS390XNEG_0(v)
   672		case OpS390XNEGW:
   673			return rewriteValueS390X_OpS390XNEGW_0(v)
   674		case OpS390XNOT:
   675			return rewriteValueS390X_OpS390XNOT_0(v)
   676		case OpS390XNOTW:
   677			return rewriteValueS390X_OpS390XNOTW_0(v)
   678		case OpS390XOR:
   679			return rewriteValueS390X_OpS390XOR_0(v) || rewriteValueS390X_OpS390XOR_10(v) || rewriteValueS390X_OpS390XOR_20(v) || rewriteValueS390X_OpS390XOR_30(v) || rewriteValueS390X_OpS390XOR_40(v) || rewriteValueS390X_OpS390XOR_50(v) || rewriteValueS390X_OpS390XOR_60(v) || rewriteValueS390X_OpS390XOR_70(v) || rewriteValueS390X_OpS390XOR_80(v) || rewriteValueS390X_OpS390XOR_90(v) || rewriteValueS390X_OpS390XOR_100(v) || rewriteValueS390X_OpS390XOR_110(v) || rewriteValueS390X_OpS390XOR_120(v) || rewriteValueS390X_OpS390XOR_130(v) || rewriteValueS390X_OpS390XOR_140(v) || rewriteValueS390X_OpS390XOR_150(v)
   680		case OpS390XORW:
   681			return rewriteValueS390X_OpS390XORW_0(v) || rewriteValueS390X_OpS390XORW_10(v) || rewriteValueS390X_OpS390XORW_20(v) || rewriteValueS390X_OpS390XORW_30(v) || rewriteValueS390X_OpS390XORW_40(v) || rewriteValueS390X_OpS390XORW_50(v) || rewriteValueS390X_OpS390XORW_60(v) || rewriteValueS390X_OpS390XORW_70(v) || rewriteValueS390X_OpS390XORW_80(v) || rewriteValueS390X_OpS390XORW_90(v)
   682		case OpS390XORWconst:
   683			return rewriteValueS390X_OpS390XORWconst_0(v)
   684		case OpS390XORWload:
   685			return rewriteValueS390X_OpS390XORWload_0(v)
   686		case OpS390XORconst:
   687			return rewriteValueS390X_OpS390XORconst_0(v)
   688		case OpS390XORload:
   689			return rewriteValueS390X_OpS390XORload_0(v)
   690		case OpS390XRLL:
   691			return rewriteValueS390X_OpS390XRLL_0(v)
   692		case OpS390XRLLG:
   693			return rewriteValueS390X_OpS390XRLLG_0(v)
   694		case OpS390XSLD:
   695			return rewriteValueS390X_OpS390XSLD_0(v) || rewriteValueS390X_OpS390XSLD_10(v)
   696		case OpS390XSLW:
   697			return rewriteValueS390X_OpS390XSLW_0(v) || rewriteValueS390X_OpS390XSLW_10(v)
   698		case OpS390XSRAD:
   699			return rewriteValueS390X_OpS390XSRAD_0(v) || rewriteValueS390X_OpS390XSRAD_10(v)
   700		case OpS390XSRADconst:
   701			return rewriteValueS390X_OpS390XSRADconst_0(v)
   702		case OpS390XSRAW:
   703			return rewriteValueS390X_OpS390XSRAW_0(v) || rewriteValueS390X_OpS390XSRAW_10(v)
   704		case OpS390XSRAWconst:
   705			return rewriteValueS390X_OpS390XSRAWconst_0(v)
   706		case OpS390XSRD:
   707			return rewriteValueS390X_OpS390XSRD_0(v) || rewriteValueS390X_OpS390XSRD_10(v)
   708		case OpS390XSRDconst:
   709			return rewriteValueS390X_OpS390XSRDconst_0(v)
   710		case OpS390XSRW:
   711			return rewriteValueS390X_OpS390XSRW_0(v) || rewriteValueS390X_OpS390XSRW_10(v)
   712		case OpS390XSTM2:
   713			return rewriteValueS390X_OpS390XSTM2_0(v)
   714		case OpS390XSTMG2:
   715			return rewriteValueS390X_OpS390XSTMG2_0(v)
   716		case OpS390XSUB:
   717			return rewriteValueS390X_OpS390XSUB_0(v)
   718		case OpS390XSUBE:
   719			return rewriteValueS390X_OpS390XSUBE_0(v)
   720		case OpS390XSUBW:
   721			return rewriteValueS390X_OpS390XSUBW_0(v)
   722		case OpS390XSUBWconst:
   723			return rewriteValueS390X_OpS390XSUBWconst_0(v)
   724		case OpS390XSUBWload:
   725			return rewriteValueS390X_OpS390XSUBWload_0(v)
   726		case OpS390XSUBconst:
   727			return rewriteValueS390X_OpS390XSUBconst_0(v)
   728		case OpS390XSUBload:
   729			return rewriteValueS390X_OpS390XSUBload_0(v)
   730		case OpS390XSumBytes2:
   731			return rewriteValueS390X_OpS390XSumBytes2_0(v)
   732		case OpS390XSumBytes4:
   733			return rewriteValueS390X_OpS390XSumBytes4_0(v)
   734		case OpS390XSumBytes8:
   735			return rewriteValueS390X_OpS390XSumBytes8_0(v)
   736		case OpS390XXOR:
   737			return rewriteValueS390X_OpS390XXOR_0(v) || rewriteValueS390X_OpS390XXOR_10(v)
   738		case OpS390XXORW:
   739			return rewriteValueS390X_OpS390XXORW_0(v) || rewriteValueS390X_OpS390XXORW_10(v)
   740		case OpS390XXORWconst:
   741			return rewriteValueS390X_OpS390XXORWconst_0(v)
   742		case OpS390XXORWload:
   743			return rewriteValueS390X_OpS390XXORWload_0(v)
   744		case OpS390XXORconst:
   745			return rewriteValueS390X_OpS390XXORconst_0(v)
   746		case OpS390XXORload:
   747			return rewriteValueS390X_OpS390XXORload_0(v)
   748		case OpSelect0:
   749			return rewriteValueS390X_OpSelect0_0(v)
   750		case OpSelect1:
   751			return rewriteValueS390X_OpSelect1_0(v)
   752		case OpSignExt16to32:
   753			return rewriteValueS390X_OpSignExt16to32_0(v)
   754		case OpSignExt16to64:
   755			return rewriteValueS390X_OpSignExt16to64_0(v)
   756		case OpSignExt32to64:
   757			return rewriteValueS390X_OpSignExt32to64_0(v)
   758		case OpSignExt8to16:
   759			return rewriteValueS390X_OpSignExt8to16_0(v)
   760		case OpSignExt8to32:
   761			return rewriteValueS390X_OpSignExt8to32_0(v)
   762		case OpSignExt8to64:
   763			return rewriteValueS390X_OpSignExt8to64_0(v)
   764		case OpSlicemask:
   765			return rewriteValueS390X_OpSlicemask_0(v)
   766		case OpSqrt:
   767			return rewriteValueS390X_OpSqrt_0(v)
   768		case OpStaticCall:
   769			return rewriteValueS390X_OpStaticCall_0(v)
   770		case OpStore:
   771			return rewriteValueS390X_OpStore_0(v)
   772		case OpSub16:
   773			return rewriteValueS390X_OpSub16_0(v)
   774		case OpSub32:
   775			return rewriteValueS390X_OpSub32_0(v)
   776		case OpSub32F:
   777			return rewriteValueS390X_OpSub32F_0(v)
   778		case OpSub64:
   779			return rewriteValueS390X_OpSub64_0(v)
   780		case OpSub64F:
   781			return rewriteValueS390X_OpSub64F_0(v)
   782		case OpSub8:
   783			return rewriteValueS390X_OpSub8_0(v)
   784		case OpSubPtr:
   785			return rewriteValueS390X_OpSubPtr_0(v)
   786		case OpTrunc:
   787			return rewriteValueS390X_OpTrunc_0(v)
   788		case OpTrunc16to8:
   789			return rewriteValueS390X_OpTrunc16to8_0(v)
   790		case OpTrunc32to16:
   791			return rewriteValueS390X_OpTrunc32to16_0(v)
   792		case OpTrunc32to8:
   793			return rewriteValueS390X_OpTrunc32to8_0(v)
   794		case OpTrunc64to16:
   795			return rewriteValueS390X_OpTrunc64to16_0(v)
   796		case OpTrunc64to32:
   797			return rewriteValueS390X_OpTrunc64to32_0(v)
   798		case OpTrunc64to8:
   799			return rewriteValueS390X_OpTrunc64to8_0(v)
   800		case OpWB:
   801			return rewriteValueS390X_OpWB_0(v)
   802		case OpXor16:
   803			return rewriteValueS390X_OpXor16_0(v)
   804		case OpXor32:
   805			return rewriteValueS390X_OpXor32_0(v)
   806		case OpXor64:
   807			return rewriteValueS390X_OpXor64_0(v)
   808		case OpXor8:
   809			return rewriteValueS390X_OpXor8_0(v)
   810		case OpZero:
   811			return rewriteValueS390X_OpZero_0(v) || rewriteValueS390X_OpZero_10(v)
   812		case OpZeroExt16to32:
   813			return rewriteValueS390X_OpZeroExt16to32_0(v)
   814		case OpZeroExt16to64:
   815			return rewriteValueS390X_OpZeroExt16to64_0(v)
   816		case OpZeroExt32to64:
   817			return rewriteValueS390X_OpZeroExt32to64_0(v)
   818		case OpZeroExt8to16:
   819			return rewriteValueS390X_OpZeroExt8to16_0(v)
   820		case OpZeroExt8to32:
   821			return rewriteValueS390X_OpZeroExt8to32_0(v)
   822		case OpZeroExt8to64:
   823			return rewriteValueS390X_OpZeroExt8to64_0(v)
   824		}
   825		return false
   826	}
   827	func rewriteValueS390X_OpAdd16_0(v *Value) bool {
   828		// match: (Add16 x y)
   829		// cond:
   830		// result: (ADDW x y)
   831		for {
   832			y := v.Args[1]
   833			x := v.Args[0]
   834			v.reset(OpS390XADDW)
   835			v.AddArg(x)
   836			v.AddArg(y)
   837			return true
   838		}
   839	}
   840	func rewriteValueS390X_OpAdd32_0(v *Value) bool {
   841		// match: (Add32 x y)
   842		// cond:
   843		// result: (ADDW x y)
   844		for {
   845			y := v.Args[1]
   846			x := v.Args[0]
   847			v.reset(OpS390XADDW)
   848			v.AddArg(x)
   849			v.AddArg(y)
   850			return true
   851		}
   852	}
   853	func rewriteValueS390X_OpAdd32F_0(v *Value) bool {
   854		// match: (Add32F x y)
   855		// cond:
   856		// result: (FADDS x y)
   857		for {
   858			y := v.Args[1]
   859			x := v.Args[0]
   860			v.reset(OpS390XFADDS)
   861			v.AddArg(x)
   862			v.AddArg(y)
   863			return true
   864		}
   865	}
   866	func rewriteValueS390X_OpAdd64_0(v *Value) bool {
   867		// match: (Add64 x y)
   868		// cond:
   869		// result: (ADD x y)
   870		for {
   871			y := v.Args[1]
   872			x := v.Args[0]
   873			v.reset(OpS390XADD)
   874			v.AddArg(x)
   875			v.AddArg(y)
   876			return true
   877		}
   878	}
   879	func rewriteValueS390X_OpAdd64F_0(v *Value) bool {
   880		// match: (Add64F x y)
   881		// cond:
   882		// result: (FADD x y)
   883		for {
   884			y := v.Args[1]
   885			x := v.Args[0]
   886			v.reset(OpS390XFADD)
   887			v.AddArg(x)
   888			v.AddArg(y)
   889			return true
   890		}
   891	}
   892	func rewriteValueS390X_OpAdd8_0(v *Value) bool {
   893		// match: (Add8 x y)
   894		// cond:
   895		// result: (ADDW x y)
   896		for {
   897			y := v.Args[1]
   898			x := v.Args[0]
   899			v.reset(OpS390XADDW)
   900			v.AddArg(x)
   901			v.AddArg(y)
   902			return true
   903		}
   904	}
   905	func rewriteValueS390X_OpAddPtr_0(v *Value) bool {
   906		// match: (AddPtr x y)
   907		// cond:
   908		// result: (ADD x y)
   909		for {
   910			y := v.Args[1]
   911			x := v.Args[0]
   912			v.reset(OpS390XADD)
   913			v.AddArg(x)
   914			v.AddArg(y)
   915			return true
   916		}
   917	}
   918	func rewriteValueS390X_OpAddr_0(v *Value) bool {
   919		// match: (Addr {sym} base)
   920		// cond:
   921		// result: (MOVDaddr {sym} base)
   922		for {
   923			sym := v.Aux
   924			base := v.Args[0]
   925			v.reset(OpS390XMOVDaddr)
   926			v.Aux = sym
   927			v.AddArg(base)
   928			return true
   929		}
   930	}
   931	func rewriteValueS390X_OpAnd16_0(v *Value) bool {
   932		// match: (And16 x y)
   933		// cond:
   934		// result: (ANDW x y)
   935		for {
   936			y := v.Args[1]
   937			x := v.Args[0]
   938			v.reset(OpS390XANDW)
   939			v.AddArg(x)
   940			v.AddArg(y)
   941			return true
   942		}
   943	}
   944	func rewriteValueS390X_OpAnd32_0(v *Value) bool {
   945		// match: (And32 x y)
   946		// cond:
   947		// result: (ANDW x y)
   948		for {
   949			y := v.Args[1]
   950			x := v.Args[0]
   951			v.reset(OpS390XANDW)
   952			v.AddArg(x)
   953			v.AddArg(y)
   954			return true
   955		}
   956	}
   957	func rewriteValueS390X_OpAnd64_0(v *Value) bool {
   958		// match: (And64 x y)
   959		// cond:
   960		// result: (AND x y)
   961		for {
   962			y := v.Args[1]
   963			x := v.Args[0]
   964			v.reset(OpS390XAND)
   965			v.AddArg(x)
   966			v.AddArg(y)
   967			return true
   968		}
   969	}
   970	func rewriteValueS390X_OpAnd8_0(v *Value) bool {
   971		// match: (And8 x y)
   972		// cond:
   973		// result: (ANDW x y)
   974		for {
   975			y := v.Args[1]
   976			x := v.Args[0]
   977			v.reset(OpS390XANDW)
   978			v.AddArg(x)
   979			v.AddArg(y)
   980			return true
   981		}
   982	}
   983	func rewriteValueS390X_OpAndB_0(v *Value) bool {
   984		// match: (AndB x y)
   985		// cond:
   986		// result: (ANDW x y)
   987		for {
   988			y := v.Args[1]
   989			x := v.Args[0]
   990			v.reset(OpS390XANDW)
   991			v.AddArg(x)
   992			v.AddArg(y)
   993			return true
   994		}
   995	}
   996	func rewriteValueS390X_OpAtomicAdd32_0(v *Value) bool {
   997		b := v.Block
   998		typ := &b.Func.Config.Types
   999		// match: (AtomicAdd32 ptr val mem)
  1000		// cond:
  1001		// result: (AddTupleFirst32 val (LAA ptr val mem))
  1002		for {
  1003			mem := v.Args[2]
  1004			ptr := v.Args[0]
  1005			val := v.Args[1]
  1006			v.reset(OpS390XAddTupleFirst32)
  1007			v.AddArg(val)
  1008			v0 := b.NewValue0(v.Pos, OpS390XLAA, types.NewTuple(typ.UInt32, types.TypeMem))
  1009			v0.AddArg(ptr)
  1010			v0.AddArg(val)
  1011			v0.AddArg(mem)
  1012			v.AddArg(v0)
  1013			return true
  1014		}
  1015	}
  1016	func rewriteValueS390X_OpAtomicAdd64_0(v *Value) bool {
  1017		b := v.Block
  1018		typ := &b.Func.Config.Types
  1019		// match: (AtomicAdd64 ptr val mem)
  1020		// cond:
  1021		// result: (AddTupleFirst64 val (LAAG ptr val mem))
  1022		for {
  1023			mem := v.Args[2]
  1024			ptr := v.Args[0]
  1025			val := v.Args[1]
  1026			v.reset(OpS390XAddTupleFirst64)
  1027			v.AddArg(val)
  1028			v0 := b.NewValue0(v.Pos, OpS390XLAAG, types.NewTuple(typ.UInt64, types.TypeMem))
  1029			v0.AddArg(ptr)
  1030			v0.AddArg(val)
  1031			v0.AddArg(mem)
  1032			v.AddArg(v0)
  1033			return true
  1034		}
  1035	}
  1036	func rewriteValueS390X_OpAtomicCompareAndSwap32_0(v *Value) bool {
  1037		// match: (AtomicCompareAndSwap32 ptr old new_ mem)
  1038		// cond:
  1039		// result: (LoweredAtomicCas32 ptr old new_ mem)
  1040		for {
  1041			mem := v.Args[3]
  1042			ptr := v.Args[0]
  1043			old := v.Args[1]
  1044			new_ := v.Args[2]
  1045			v.reset(OpS390XLoweredAtomicCas32)
  1046			v.AddArg(ptr)
  1047			v.AddArg(old)
  1048			v.AddArg(new_)
  1049			v.AddArg(mem)
  1050			return true
  1051		}
  1052	}
  1053	func rewriteValueS390X_OpAtomicCompareAndSwap64_0(v *Value) bool {
  1054		// match: (AtomicCompareAndSwap64 ptr old new_ mem)
  1055		// cond:
  1056		// result: (LoweredAtomicCas64 ptr old new_ mem)
  1057		for {
  1058			mem := v.Args[3]
  1059			ptr := v.Args[0]
  1060			old := v.Args[1]
  1061			new_ := v.Args[2]
  1062			v.reset(OpS390XLoweredAtomicCas64)
  1063			v.AddArg(ptr)
  1064			v.AddArg(old)
  1065			v.AddArg(new_)
  1066			v.AddArg(mem)
  1067			return true
  1068		}
  1069	}
  1070	func rewriteValueS390X_OpAtomicExchange32_0(v *Value) bool {
  1071		// match: (AtomicExchange32 ptr val mem)
  1072		// cond:
  1073		// result: (LoweredAtomicExchange32 ptr val mem)
  1074		for {
  1075			mem := v.Args[2]
  1076			ptr := v.Args[0]
  1077			val := v.Args[1]
  1078			v.reset(OpS390XLoweredAtomicExchange32)
  1079			v.AddArg(ptr)
  1080			v.AddArg(val)
  1081			v.AddArg(mem)
  1082			return true
  1083		}
  1084	}
  1085	func rewriteValueS390X_OpAtomicExchange64_0(v *Value) bool {
  1086		// match: (AtomicExchange64 ptr val mem)
  1087		// cond:
  1088		// result: (LoweredAtomicExchange64 ptr val mem)
  1089		for {
  1090			mem := v.Args[2]
  1091			ptr := v.Args[0]
  1092			val := v.Args[1]
  1093			v.reset(OpS390XLoweredAtomicExchange64)
  1094			v.AddArg(ptr)
  1095			v.AddArg(val)
  1096			v.AddArg(mem)
  1097			return true
  1098		}
  1099	}
  1100	func rewriteValueS390X_OpAtomicLoad32_0(v *Value) bool {
  1101		// match: (AtomicLoad32 ptr mem)
  1102		// cond:
  1103		// result: (MOVWZatomicload ptr mem)
  1104		for {
  1105			mem := v.Args[1]
  1106			ptr := v.Args[0]
  1107			v.reset(OpS390XMOVWZatomicload)
  1108			v.AddArg(ptr)
  1109			v.AddArg(mem)
  1110			return true
  1111		}
  1112	}
  1113	func rewriteValueS390X_OpAtomicLoad64_0(v *Value) bool {
  1114		// match: (AtomicLoad64 ptr mem)
  1115		// cond:
  1116		// result: (MOVDatomicload ptr mem)
  1117		for {
  1118			mem := v.Args[1]
  1119			ptr := v.Args[0]
  1120			v.reset(OpS390XMOVDatomicload)
  1121			v.AddArg(ptr)
  1122			v.AddArg(mem)
  1123			return true
  1124		}
  1125	}
  1126	func rewriteValueS390X_OpAtomicLoad8_0(v *Value) bool {
  1127		// match: (AtomicLoad8 ptr mem)
  1128		// cond:
  1129		// result: (MOVBZatomicload ptr mem)
  1130		for {
  1131			mem := v.Args[1]
  1132			ptr := v.Args[0]
  1133			v.reset(OpS390XMOVBZatomicload)
  1134			v.AddArg(ptr)
  1135			v.AddArg(mem)
  1136			return true
  1137		}
  1138	}
  1139	func rewriteValueS390X_OpAtomicLoadAcq32_0(v *Value) bool {
  1140		// match: (AtomicLoadAcq32 ptr mem)
  1141		// cond:
  1142		// result: (MOVWZatomicload ptr mem)
  1143		for {
  1144			mem := v.Args[1]
  1145			ptr := v.Args[0]
  1146			v.reset(OpS390XMOVWZatomicload)
  1147			v.AddArg(ptr)
  1148			v.AddArg(mem)
  1149			return true
  1150		}
  1151	}
  1152	func rewriteValueS390X_OpAtomicLoadPtr_0(v *Value) bool {
  1153		// match: (AtomicLoadPtr ptr mem)
  1154		// cond:
  1155		// result: (MOVDatomicload ptr mem)
  1156		for {
  1157			mem := v.Args[1]
  1158			ptr := v.Args[0]
  1159			v.reset(OpS390XMOVDatomicload)
  1160			v.AddArg(ptr)
  1161			v.AddArg(mem)
  1162			return true
  1163		}
  1164	}
  1165	func rewriteValueS390X_OpAtomicStore32_0(v *Value) bool {
  1166		b := v.Block
  1167		// match: (AtomicStore32 ptr val mem)
  1168		// cond:
  1169		// result: (SYNC (MOVWatomicstore ptr val mem))
  1170		for {
  1171			mem := v.Args[2]
  1172			ptr := v.Args[0]
  1173			val := v.Args[1]
  1174			v.reset(OpS390XSYNC)
  1175			v0 := b.NewValue0(v.Pos, OpS390XMOVWatomicstore, types.TypeMem)
  1176			v0.AddArg(ptr)
  1177			v0.AddArg(val)
  1178			v0.AddArg(mem)
  1179			v.AddArg(v0)
  1180			return true
  1181		}
  1182	}
  1183	func rewriteValueS390X_OpAtomicStore64_0(v *Value) bool {
  1184		b := v.Block
  1185		// match: (AtomicStore64 ptr val mem)
  1186		// cond:
  1187		// result: (SYNC (MOVDatomicstore ptr val mem))
  1188		for {
  1189			mem := v.Args[2]
  1190			ptr := v.Args[0]
  1191			val := v.Args[1]
  1192			v.reset(OpS390XSYNC)
  1193			v0 := b.NewValue0(v.Pos, OpS390XMOVDatomicstore, types.TypeMem)
  1194			v0.AddArg(ptr)
  1195			v0.AddArg(val)
  1196			v0.AddArg(mem)
  1197			v.AddArg(v0)
  1198			return true
  1199		}
  1200	}
  1201	func rewriteValueS390X_OpAtomicStorePtrNoWB_0(v *Value) bool {
  1202		b := v.Block
  1203		// match: (AtomicStorePtrNoWB ptr val mem)
  1204		// cond:
  1205		// result: (SYNC (MOVDatomicstore ptr val mem))
  1206		for {
  1207			mem := v.Args[2]
  1208			ptr := v.Args[0]
  1209			val := v.Args[1]
  1210			v.reset(OpS390XSYNC)
  1211			v0 := b.NewValue0(v.Pos, OpS390XMOVDatomicstore, types.TypeMem)
  1212			v0.AddArg(ptr)
  1213			v0.AddArg(val)
  1214			v0.AddArg(mem)
  1215			v.AddArg(v0)
  1216			return true
  1217		}
  1218	}
  1219	func rewriteValueS390X_OpAtomicStoreRel32_0(v *Value) bool {
  1220		// match: (AtomicStoreRel32 ptr val mem)
  1221		// cond:
  1222		// result: (MOVWatomicstore ptr val mem)
  1223		for {
  1224			mem := v.Args[2]
  1225			ptr := v.Args[0]
  1226			val := v.Args[1]
  1227			v.reset(OpS390XMOVWatomicstore)
  1228			v.AddArg(ptr)
  1229			v.AddArg(val)
  1230			v.AddArg(mem)
  1231			return true
  1232		}
  1233	}
  1234	func rewriteValueS390X_OpAvg64u_0(v *Value) bool {
  1235		b := v.Block
  1236		// match: (Avg64u <t> x y)
  1237		// cond:
  1238		// result: (ADD (SRDconst <t> (SUB <t> x y) [1]) y)
  1239		for {
  1240			t := v.Type
  1241			y := v.Args[1]
  1242			x := v.Args[0]
  1243			v.reset(OpS390XADD)
  1244			v0 := b.NewValue0(v.Pos, OpS390XSRDconst, t)
  1245			v0.AuxInt = 1
  1246			v1 := b.NewValue0(v.Pos, OpS390XSUB, t)
  1247			v1.AddArg(x)
  1248			v1.AddArg(y)
  1249			v0.AddArg(v1)
  1250			v.AddArg(v0)
  1251			v.AddArg(y)
  1252			return true
  1253		}
  1254	}
  1255	func rewriteValueS390X_OpBitLen64_0(v *Value) bool {
  1256		b := v.Block
  1257		typ := &b.Func.Config.Types
  1258		// match: (BitLen64 x)
  1259		// cond:
  1260		// result: (SUB (MOVDconst [64]) (FLOGR x))
  1261		for {
  1262			x := v.Args[0]
  1263			v.reset(OpS390XSUB)
  1264			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1265			v0.AuxInt = 64
  1266			v.AddArg(v0)
  1267			v1 := b.NewValue0(v.Pos, OpS390XFLOGR, typ.UInt64)
  1268			v1.AddArg(x)
  1269			v.AddArg(v1)
  1270			return true
  1271		}
  1272	}
  1273	func rewriteValueS390X_OpBswap32_0(v *Value) bool {
  1274		// match: (Bswap32 x)
  1275		// cond:
  1276		// result: (MOVWBR x)
  1277		for {
  1278			x := v.Args[0]
  1279			v.reset(OpS390XMOVWBR)
  1280			v.AddArg(x)
  1281			return true
  1282		}
  1283	}
  1284	func rewriteValueS390X_OpBswap64_0(v *Value) bool {
  1285		// match: (Bswap64 x)
  1286		// cond:
  1287		// result: (MOVDBR x)
  1288		for {
  1289			x := v.Args[0]
  1290			v.reset(OpS390XMOVDBR)
  1291			v.AddArg(x)
  1292			return true
  1293		}
  1294	}
  1295	func rewriteValueS390X_OpCeil_0(v *Value) bool {
  1296		// match: (Ceil x)
  1297		// cond:
  1298		// result: (FIDBR [6] x)
  1299		for {
  1300			x := v.Args[0]
  1301			v.reset(OpS390XFIDBR)
  1302			v.AuxInt = 6
  1303			v.AddArg(x)
  1304			return true
  1305		}
  1306	}
  1307	func rewriteValueS390X_OpClosureCall_0(v *Value) bool {
  1308		// match: (ClosureCall [argwid] entry closure mem)
  1309		// cond:
  1310		// result: (CALLclosure [argwid] entry closure mem)
  1311		for {
  1312			argwid := v.AuxInt
  1313			mem := v.Args[2]
  1314			entry := v.Args[0]
  1315			closure := v.Args[1]
  1316			v.reset(OpS390XCALLclosure)
  1317			v.AuxInt = argwid
  1318			v.AddArg(entry)
  1319			v.AddArg(closure)
  1320			v.AddArg(mem)
  1321			return true
  1322		}
  1323	}
  1324	func rewriteValueS390X_OpCom16_0(v *Value) bool {
  1325		// match: (Com16 x)
  1326		// cond:
  1327		// result: (NOTW x)
  1328		for {
  1329			x := v.Args[0]
  1330			v.reset(OpS390XNOTW)
  1331			v.AddArg(x)
  1332			return true
  1333		}
  1334	}
  1335	func rewriteValueS390X_OpCom32_0(v *Value) bool {
  1336		// match: (Com32 x)
  1337		// cond:
  1338		// result: (NOTW x)
  1339		for {
  1340			x := v.Args[0]
  1341			v.reset(OpS390XNOTW)
  1342			v.AddArg(x)
  1343			return true
  1344		}
  1345	}
  1346	func rewriteValueS390X_OpCom64_0(v *Value) bool {
  1347		// match: (Com64 x)
  1348		// cond:
  1349		// result: (NOT x)
  1350		for {
  1351			x := v.Args[0]
  1352			v.reset(OpS390XNOT)
  1353			v.AddArg(x)
  1354			return true
  1355		}
  1356	}
  1357	func rewriteValueS390X_OpCom8_0(v *Value) bool {
  1358		// match: (Com8 x)
  1359		// cond:
  1360		// result: (NOTW x)
  1361		for {
  1362			x := v.Args[0]
  1363			v.reset(OpS390XNOTW)
  1364			v.AddArg(x)
  1365			return true
  1366		}
  1367	}
  1368	func rewriteValueS390X_OpConst16_0(v *Value) bool {
  1369		// match: (Const16 [val])
  1370		// cond:
  1371		// result: (MOVDconst [val])
  1372		for {
  1373			val := v.AuxInt
  1374			v.reset(OpS390XMOVDconst)
  1375			v.AuxInt = val
  1376			return true
  1377		}
  1378	}
  1379	func rewriteValueS390X_OpConst32_0(v *Value) bool {
  1380		// match: (Const32 [val])
  1381		// cond:
  1382		// result: (MOVDconst [val])
  1383		for {
  1384			val := v.AuxInt
  1385			v.reset(OpS390XMOVDconst)
  1386			v.AuxInt = val
  1387			return true
  1388		}
  1389	}
  1390	func rewriteValueS390X_OpConst32F_0(v *Value) bool {
  1391		// match: (Const32F [val])
  1392		// cond:
  1393		// result: (FMOVSconst [val])
  1394		for {
  1395			val := v.AuxInt
  1396			v.reset(OpS390XFMOVSconst)
  1397			v.AuxInt = val
  1398			return true
  1399		}
  1400	}
  1401	func rewriteValueS390X_OpConst64_0(v *Value) bool {
  1402		// match: (Const64 [val])
  1403		// cond:
  1404		// result: (MOVDconst [val])
  1405		for {
  1406			val := v.AuxInt
  1407			v.reset(OpS390XMOVDconst)
  1408			v.AuxInt = val
  1409			return true
  1410		}
  1411	}
  1412	func rewriteValueS390X_OpConst64F_0(v *Value) bool {
  1413		// match: (Const64F [val])
  1414		// cond:
  1415		// result: (FMOVDconst [val])
  1416		for {
  1417			val := v.AuxInt
  1418			v.reset(OpS390XFMOVDconst)
  1419			v.AuxInt = val
  1420			return true
  1421		}
  1422	}
  1423	func rewriteValueS390X_OpConst8_0(v *Value) bool {
  1424		// match: (Const8 [val])
  1425		// cond:
  1426		// result: (MOVDconst [val])
  1427		for {
  1428			val := v.AuxInt
  1429			v.reset(OpS390XMOVDconst)
  1430			v.AuxInt = val
  1431			return true
  1432		}
  1433	}
  1434	func rewriteValueS390X_OpConstBool_0(v *Value) bool {
  1435		// match: (ConstBool [b])
  1436		// cond:
  1437		// result: (MOVDconst [b])
  1438		for {
  1439			b := v.AuxInt
  1440			v.reset(OpS390XMOVDconst)
  1441			v.AuxInt = b
  1442			return true
  1443		}
  1444	}
  1445	func rewriteValueS390X_OpConstNil_0(v *Value) bool {
  1446		// match: (ConstNil)
  1447		// cond:
  1448		// result: (MOVDconst [0])
  1449		for {
  1450			v.reset(OpS390XMOVDconst)
  1451			v.AuxInt = 0
  1452			return true
  1453		}
  1454	}
  1455	func rewriteValueS390X_OpCtz32_0(v *Value) bool {
  1456		b := v.Block
  1457		typ := &b.Func.Config.Types
  1458		// match: (Ctz32 <t> x)
  1459		// cond:
  1460		// result: (SUB (MOVDconst [64]) (FLOGR (MOVWZreg (ANDW <t> (SUBWconst <t> [1] x) (NOTW <t> x)))))
  1461		for {
  1462			t := v.Type
  1463			x := v.Args[0]
  1464			v.reset(OpS390XSUB)
  1465			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1466			v0.AuxInt = 64
  1467			v.AddArg(v0)
  1468			v1 := b.NewValue0(v.Pos, OpS390XFLOGR, typ.UInt64)
  1469			v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
  1470			v3 := b.NewValue0(v.Pos, OpS390XANDW, t)
  1471			v4 := b.NewValue0(v.Pos, OpS390XSUBWconst, t)
  1472			v4.AuxInt = 1
  1473			v4.AddArg(x)
  1474			v3.AddArg(v4)
  1475			v5 := b.NewValue0(v.Pos, OpS390XNOTW, t)
  1476			v5.AddArg(x)
  1477			v3.AddArg(v5)
  1478			v2.AddArg(v3)
  1479			v1.AddArg(v2)
  1480			v.AddArg(v1)
  1481			return true
  1482		}
  1483	}
  1484	func rewriteValueS390X_OpCtz32NonZero_0(v *Value) bool {
  1485		// match: (Ctz32NonZero x)
  1486		// cond:
  1487		// result: (Ctz32 x)
  1488		for {
  1489			x := v.Args[0]
  1490			v.reset(OpCtz32)
  1491			v.AddArg(x)
  1492			return true
  1493		}
  1494	}
  1495	func rewriteValueS390X_OpCtz64_0(v *Value) bool {
  1496		b := v.Block
  1497		typ := &b.Func.Config.Types
  1498		// match: (Ctz64 <t> x)
  1499		// cond:
  1500		// result: (SUB (MOVDconst [64]) (FLOGR (AND <t> (SUBconst <t> [1] x) (NOT <t> x))))
  1501		for {
  1502			t := v.Type
  1503			x := v.Args[0]
  1504			v.reset(OpS390XSUB)
  1505			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1506			v0.AuxInt = 64
  1507			v.AddArg(v0)
  1508			v1 := b.NewValue0(v.Pos, OpS390XFLOGR, typ.UInt64)
  1509			v2 := b.NewValue0(v.Pos, OpS390XAND, t)
  1510			v3 := b.NewValue0(v.Pos, OpS390XSUBconst, t)
  1511			v3.AuxInt = 1
  1512			v3.AddArg(x)
  1513			v2.AddArg(v3)
  1514			v4 := b.NewValue0(v.Pos, OpS390XNOT, t)
  1515			v4.AddArg(x)
  1516			v2.AddArg(v4)
  1517			v1.AddArg(v2)
  1518			v.AddArg(v1)
  1519			return true
  1520		}
  1521	}
  1522	func rewriteValueS390X_OpCtz64NonZero_0(v *Value) bool {
  1523		// match: (Ctz64NonZero x)
  1524		// cond:
  1525		// result: (Ctz64 x)
  1526		for {
  1527			x := v.Args[0]
  1528			v.reset(OpCtz64)
  1529			v.AddArg(x)
  1530			return true
  1531		}
  1532	}
  1533	func rewriteValueS390X_OpCvt32Fto32_0(v *Value) bool {
  1534		// match: (Cvt32Fto32 x)
  1535		// cond:
  1536		// result: (CFEBRA x)
  1537		for {
  1538			x := v.Args[0]
  1539			v.reset(OpS390XCFEBRA)
  1540			v.AddArg(x)
  1541			return true
  1542		}
  1543	}
  1544	func rewriteValueS390X_OpCvt32Fto64_0(v *Value) bool {
  1545		// match: (Cvt32Fto64 x)
  1546		// cond:
  1547		// result: (CGEBRA x)
  1548		for {
  1549			x := v.Args[0]
  1550			v.reset(OpS390XCGEBRA)
  1551			v.AddArg(x)
  1552			return true
  1553		}
  1554	}
  1555	func rewriteValueS390X_OpCvt32Fto64F_0(v *Value) bool {
  1556		// match: (Cvt32Fto64F x)
  1557		// cond:
  1558		// result: (LDEBR x)
  1559		for {
  1560			x := v.Args[0]
  1561			v.reset(OpS390XLDEBR)
  1562			v.AddArg(x)
  1563			return true
  1564		}
  1565	}
  1566	func rewriteValueS390X_OpCvt32to32F_0(v *Value) bool {
  1567		// match: (Cvt32to32F x)
  1568		// cond:
  1569		// result: (CEFBRA x)
  1570		for {
  1571			x := v.Args[0]
  1572			v.reset(OpS390XCEFBRA)
  1573			v.AddArg(x)
  1574			return true
  1575		}
  1576	}
  1577	func rewriteValueS390X_OpCvt32to64F_0(v *Value) bool {
  1578		// match: (Cvt32to64F x)
  1579		// cond:
  1580		// result: (CDFBRA x)
  1581		for {
  1582			x := v.Args[0]
  1583			v.reset(OpS390XCDFBRA)
  1584			v.AddArg(x)
  1585			return true
  1586		}
  1587	}
  1588	func rewriteValueS390X_OpCvt64Fto32_0(v *Value) bool {
  1589		// match: (Cvt64Fto32 x)
  1590		// cond:
  1591		// result: (CFDBRA x)
  1592		for {
  1593			x := v.Args[0]
  1594			v.reset(OpS390XCFDBRA)
  1595			v.AddArg(x)
  1596			return true
  1597		}
  1598	}
  1599	func rewriteValueS390X_OpCvt64Fto32F_0(v *Value) bool {
  1600		// match: (Cvt64Fto32F x)
  1601		// cond:
  1602		// result: (LEDBR x)
  1603		for {
  1604			x := v.Args[0]
  1605			v.reset(OpS390XLEDBR)
  1606			v.AddArg(x)
  1607			return true
  1608		}
  1609	}
  1610	func rewriteValueS390X_OpCvt64Fto64_0(v *Value) bool {
  1611		// match: (Cvt64Fto64 x)
  1612		// cond:
  1613		// result: (CGDBRA x)
  1614		for {
  1615			x := v.Args[0]
  1616			v.reset(OpS390XCGDBRA)
  1617			v.AddArg(x)
  1618			return true
  1619		}
  1620	}
  1621	func rewriteValueS390X_OpCvt64to32F_0(v *Value) bool {
  1622		// match: (Cvt64to32F x)
  1623		// cond:
  1624		// result: (CEGBRA x)
  1625		for {
  1626			x := v.Args[0]
  1627			v.reset(OpS390XCEGBRA)
  1628			v.AddArg(x)
  1629			return true
  1630		}
  1631	}
  1632	func rewriteValueS390X_OpCvt64to64F_0(v *Value) bool {
  1633		// match: (Cvt64to64F x)
  1634		// cond:
  1635		// result: (CDGBRA x)
  1636		for {
  1637			x := v.Args[0]
  1638			v.reset(OpS390XCDGBRA)
  1639			v.AddArg(x)
  1640			return true
  1641		}
  1642	}
  1643	func rewriteValueS390X_OpDiv16_0(v *Value) bool {
  1644		b := v.Block
  1645		typ := &b.Func.Config.Types
  1646		// match: (Div16 x y)
  1647		// cond:
  1648		// result: (DIVW (MOVHreg x) (MOVHreg y))
  1649		for {
  1650			y := v.Args[1]
  1651			x := v.Args[0]
  1652			v.reset(OpS390XDIVW)
  1653			v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  1654			v0.AddArg(x)
  1655			v.AddArg(v0)
  1656			v1 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  1657			v1.AddArg(y)
  1658			v.AddArg(v1)
  1659			return true
  1660		}
  1661	}
  1662	func rewriteValueS390X_OpDiv16u_0(v *Value) bool {
  1663		b := v.Block
  1664		typ := &b.Func.Config.Types
  1665		// match: (Div16u x y)
  1666		// cond:
  1667		// result: (DIVWU (MOVHZreg x) (MOVHZreg y))
  1668		for {
  1669			y := v.Args[1]
  1670			x := v.Args[0]
  1671			v.reset(OpS390XDIVWU)
  1672			v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  1673			v0.AddArg(x)
  1674			v.AddArg(v0)
  1675			v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  1676			v1.AddArg(y)
  1677			v.AddArg(v1)
  1678			return true
  1679		}
  1680	}
  1681	func rewriteValueS390X_OpDiv32_0(v *Value) bool {
  1682		b := v.Block
  1683		typ := &b.Func.Config.Types
  1684		// match: (Div32 x y)
  1685		// cond:
  1686		// result: (DIVW (MOVWreg x) y)
  1687		for {
  1688			y := v.Args[1]
  1689			x := v.Args[0]
  1690			v.reset(OpS390XDIVW)
  1691			v0 := b.NewValue0(v.Pos, OpS390XMOVWreg, typ.Int64)
  1692			v0.AddArg(x)
  1693			v.AddArg(v0)
  1694			v.AddArg(y)
  1695			return true
  1696		}
  1697	}
  1698	func rewriteValueS390X_OpDiv32F_0(v *Value) bool {
  1699		// match: (Div32F x y)
  1700		// cond:
  1701		// result: (FDIVS x y)
  1702		for {
  1703			y := v.Args[1]
  1704			x := v.Args[0]
  1705			v.reset(OpS390XFDIVS)
  1706			v.AddArg(x)
  1707			v.AddArg(y)
  1708			return true
  1709		}
  1710	}
  1711	func rewriteValueS390X_OpDiv32u_0(v *Value) bool {
  1712		b := v.Block
  1713		typ := &b.Func.Config.Types
  1714		// match: (Div32u x y)
  1715		// cond:
  1716		// result: (DIVWU (MOVWZreg x) y)
  1717		for {
  1718			y := v.Args[1]
  1719			x := v.Args[0]
  1720			v.reset(OpS390XDIVWU)
  1721			v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
  1722			v0.AddArg(x)
  1723			v.AddArg(v0)
  1724			v.AddArg(y)
  1725			return true
  1726		}
  1727	}
  1728	func rewriteValueS390X_OpDiv64_0(v *Value) bool {
  1729		// match: (Div64 x y)
  1730		// cond:
  1731		// result: (DIVD x y)
  1732		for {
  1733			y := v.Args[1]
  1734			x := v.Args[0]
  1735			v.reset(OpS390XDIVD)
  1736			v.AddArg(x)
  1737			v.AddArg(y)
  1738			return true
  1739		}
  1740	}
  1741	func rewriteValueS390X_OpDiv64F_0(v *Value) bool {
  1742		// match: (Div64F x y)
  1743		// cond:
  1744		// result: (FDIV x y)
  1745		for {
  1746			y := v.Args[1]
  1747			x := v.Args[0]
  1748			v.reset(OpS390XFDIV)
  1749			v.AddArg(x)
  1750			v.AddArg(y)
  1751			return true
  1752		}
  1753	}
  1754	func rewriteValueS390X_OpDiv64u_0(v *Value) bool {
  1755		// match: (Div64u x y)
  1756		// cond:
  1757		// result: (DIVDU x y)
  1758		for {
  1759			y := v.Args[1]
  1760			x := v.Args[0]
  1761			v.reset(OpS390XDIVDU)
  1762			v.AddArg(x)
  1763			v.AddArg(y)
  1764			return true
  1765		}
  1766	}
  1767	func rewriteValueS390X_OpDiv8_0(v *Value) bool {
  1768		b := v.Block
  1769		typ := &b.Func.Config.Types
  1770		// match: (Div8 x y)
  1771		// cond:
  1772		// result: (DIVW (MOVBreg x) (MOVBreg y))
  1773		for {
  1774			y := v.Args[1]
  1775			x := v.Args[0]
  1776			v.reset(OpS390XDIVW)
  1777			v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  1778			v0.AddArg(x)
  1779			v.AddArg(v0)
  1780			v1 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  1781			v1.AddArg(y)
  1782			v.AddArg(v1)
  1783			return true
  1784		}
  1785	}
  1786	func rewriteValueS390X_OpDiv8u_0(v *Value) bool {
  1787		b := v.Block
  1788		typ := &b.Func.Config.Types
  1789		// match: (Div8u x y)
  1790		// cond:
  1791		// result: (DIVWU (MOVBZreg x) (MOVBZreg y))
  1792		for {
  1793			y := v.Args[1]
  1794			x := v.Args[0]
  1795			v.reset(OpS390XDIVWU)
  1796			v0 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  1797			v0.AddArg(x)
  1798			v.AddArg(v0)
  1799			v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  1800			v1.AddArg(y)
  1801			v.AddArg(v1)
  1802			return true
  1803		}
  1804	}
  1805	func rewriteValueS390X_OpEq16_0(v *Value) bool {
  1806		b := v.Block
  1807		typ := &b.Func.Config.Types
  1808		// match: (Eq16 x y)
  1809		// cond:
  1810		// result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (CMPW (MOVHreg x) (MOVHreg y)))
  1811		for {
  1812			y := v.Args[1]
  1813			x := v.Args[0]
  1814			v.reset(OpS390XMOVDEQ)
  1815			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1816			v0.AuxInt = 0
  1817			v.AddArg(v0)
  1818			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1819			v1.AuxInt = 1
  1820			v.AddArg(v1)
  1821			v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  1822			v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  1823			v3.AddArg(x)
  1824			v2.AddArg(v3)
  1825			v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  1826			v4.AddArg(y)
  1827			v2.AddArg(v4)
  1828			v.AddArg(v2)
  1829			return true
  1830		}
  1831	}
  1832	func rewriteValueS390X_OpEq32_0(v *Value) bool {
  1833		b := v.Block
  1834		typ := &b.Func.Config.Types
  1835		// match: (Eq32 x y)
  1836		// cond:
  1837		// result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (CMPW x y))
  1838		for {
  1839			y := v.Args[1]
  1840			x := v.Args[0]
  1841			v.reset(OpS390XMOVDEQ)
  1842			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1843			v0.AuxInt = 0
  1844			v.AddArg(v0)
  1845			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1846			v1.AuxInt = 1
  1847			v.AddArg(v1)
  1848			v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  1849			v2.AddArg(x)
  1850			v2.AddArg(y)
  1851			v.AddArg(v2)
  1852			return true
  1853		}
  1854	}
  1855	func rewriteValueS390X_OpEq32F_0(v *Value) bool {
  1856		b := v.Block
  1857		typ := &b.Func.Config.Types
  1858		// match: (Eq32F x y)
  1859		// cond:
  1860		// result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (FCMPS x y))
  1861		for {
  1862			y := v.Args[1]
  1863			x := v.Args[0]
  1864			v.reset(OpS390XMOVDEQ)
  1865			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1866			v0.AuxInt = 0
  1867			v.AddArg(v0)
  1868			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1869			v1.AuxInt = 1
  1870			v.AddArg(v1)
  1871			v2 := b.NewValue0(v.Pos, OpS390XFCMPS, types.TypeFlags)
  1872			v2.AddArg(x)
  1873			v2.AddArg(y)
  1874			v.AddArg(v2)
  1875			return true
  1876		}
  1877	}
  1878	func rewriteValueS390X_OpEq64_0(v *Value) bool {
  1879		b := v.Block
  1880		typ := &b.Func.Config.Types
  1881		// match: (Eq64 x y)
  1882		// cond:
  1883		// result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (CMP x y))
  1884		for {
  1885			y := v.Args[1]
  1886			x := v.Args[0]
  1887			v.reset(OpS390XMOVDEQ)
  1888			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1889			v0.AuxInt = 0
  1890			v.AddArg(v0)
  1891			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1892			v1.AuxInt = 1
  1893			v.AddArg(v1)
  1894			v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
  1895			v2.AddArg(x)
  1896			v2.AddArg(y)
  1897			v.AddArg(v2)
  1898			return true
  1899		}
  1900	}
  1901	func rewriteValueS390X_OpEq64F_0(v *Value) bool {
  1902		b := v.Block
  1903		typ := &b.Func.Config.Types
  1904		// match: (Eq64F x y)
  1905		// cond:
  1906		// result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (FCMP x y))
  1907		for {
  1908			y := v.Args[1]
  1909			x := v.Args[0]
  1910			v.reset(OpS390XMOVDEQ)
  1911			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1912			v0.AuxInt = 0
  1913			v.AddArg(v0)
  1914			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1915			v1.AuxInt = 1
  1916			v.AddArg(v1)
  1917			v2 := b.NewValue0(v.Pos, OpS390XFCMP, types.TypeFlags)
  1918			v2.AddArg(x)
  1919			v2.AddArg(y)
  1920			v.AddArg(v2)
  1921			return true
  1922		}
  1923	}
  1924	func rewriteValueS390X_OpEq8_0(v *Value) bool {
  1925		b := v.Block
  1926		typ := &b.Func.Config.Types
  1927		// match: (Eq8 x y)
  1928		// cond:
  1929		// result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (CMPW (MOVBreg x) (MOVBreg y)))
  1930		for {
  1931			y := v.Args[1]
  1932			x := v.Args[0]
  1933			v.reset(OpS390XMOVDEQ)
  1934			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1935			v0.AuxInt = 0
  1936			v.AddArg(v0)
  1937			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1938			v1.AuxInt = 1
  1939			v.AddArg(v1)
  1940			v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  1941			v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  1942			v3.AddArg(x)
  1943			v2.AddArg(v3)
  1944			v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  1945			v4.AddArg(y)
  1946			v2.AddArg(v4)
  1947			v.AddArg(v2)
  1948			return true
  1949		}
  1950	}
  1951	func rewriteValueS390X_OpEqB_0(v *Value) bool {
  1952		b := v.Block
  1953		typ := &b.Func.Config.Types
  1954		// match: (EqB x y)
  1955		// cond:
  1956		// result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (CMPW (MOVBreg x) (MOVBreg y)))
  1957		for {
  1958			y := v.Args[1]
  1959			x := v.Args[0]
  1960			v.reset(OpS390XMOVDEQ)
  1961			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1962			v0.AuxInt = 0
  1963			v.AddArg(v0)
  1964			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1965			v1.AuxInt = 1
  1966			v.AddArg(v1)
  1967			v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  1968			v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  1969			v3.AddArg(x)
  1970			v2.AddArg(v3)
  1971			v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  1972			v4.AddArg(y)
  1973			v2.AddArg(v4)
  1974			v.AddArg(v2)
  1975			return true
  1976		}
  1977	}
  1978	func rewriteValueS390X_OpEqPtr_0(v *Value) bool {
  1979		b := v.Block
  1980		typ := &b.Func.Config.Types
  1981		// match: (EqPtr x y)
  1982		// cond:
  1983		// result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (CMP x y))
  1984		for {
  1985			y := v.Args[1]
  1986			x := v.Args[0]
  1987			v.reset(OpS390XMOVDEQ)
  1988			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1989			v0.AuxInt = 0
  1990			v.AddArg(v0)
  1991			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1992			v1.AuxInt = 1
  1993			v.AddArg(v1)
  1994			v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
  1995			v2.AddArg(x)
  1996			v2.AddArg(y)
  1997			v.AddArg(v2)
  1998			return true
  1999		}
  2000	}
  2001	func rewriteValueS390X_OpFloor_0(v *Value) bool {
  2002		// match: (Floor x)
  2003		// cond:
  2004		// result: (FIDBR [7] x)
  2005		for {
  2006			x := v.Args[0]
  2007			v.reset(OpS390XFIDBR)
  2008			v.AuxInt = 7
  2009			v.AddArg(x)
  2010			return true
  2011		}
  2012	}
  2013	func rewriteValueS390X_OpGeq16_0(v *Value) bool {
  2014		b := v.Block
  2015		typ := &b.Func.Config.Types
  2016		// match: (Geq16 x y)
  2017		// cond:
  2018		// result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMPW (MOVHreg x) (MOVHreg y)))
  2019		for {
  2020			y := v.Args[1]
  2021			x := v.Args[0]
  2022			v.reset(OpS390XMOVDGE)
  2023			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2024			v0.AuxInt = 0
  2025			v.AddArg(v0)
  2026			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2027			v1.AuxInt = 1
  2028			v.AddArg(v1)
  2029			v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  2030			v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  2031			v3.AddArg(x)
  2032			v2.AddArg(v3)
  2033			v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  2034			v4.AddArg(y)
  2035			v2.AddArg(v4)
  2036			v.AddArg(v2)
  2037			return true
  2038		}
  2039	}
  2040	func rewriteValueS390X_OpGeq16U_0(v *Value) bool {
  2041		b := v.Block
  2042		typ := &b.Func.Config.Types
  2043		// match: (Geq16U x y)
  2044		// cond:
  2045		// result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMPWU (MOVHZreg x) (MOVHZreg y)))
  2046		for {
  2047			y := v.Args[1]
  2048			x := v.Args[0]
  2049			v.reset(OpS390XMOVDGE)
  2050			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2051			v0.AuxInt = 0
  2052			v.AddArg(v0)
  2053			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2054			v1.AuxInt = 1
  2055			v.AddArg(v1)
  2056			v2 := b.NewValue0(v.Pos, OpS390XCMPWU, types.TypeFlags)
  2057			v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  2058			v3.AddArg(x)
  2059			v2.AddArg(v3)
  2060			v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  2061			v4.AddArg(y)
  2062			v2.AddArg(v4)
  2063			v.AddArg(v2)
  2064			return true
  2065		}
  2066	}
  2067	func rewriteValueS390X_OpGeq32_0(v *Value) bool {
  2068		b := v.Block
  2069		typ := &b.Func.Config.Types
  2070		// match: (Geq32 x y)
  2071		// cond:
  2072		// result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMPW x y))
  2073		for {
  2074			y := v.Args[1]
  2075			x := v.Args[0]
  2076			v.reset(OpS390XMOVDGE)
  2077			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2078			v0.AuxInt = 0
  2079			v.AddArg(v0)
  2080			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2081			v1.AuxInt = 1
  2082			v.AddArg(v1)
  2083			v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  2084			v2.AddArg(x)
  2085			v2.AddArg(y)
  2086			v.AddArg(v2)
  2087			return true
  2088		}
  2089	}
  2090	func rewriteValueS390X_OpGeq32F_0(v *Value) bool {
  2091		b := v.Block
  2092		typ := &b.Func.Config.Types
  2093		// match: (Geq32F x y)
  2094		// cond:
  2095		// result: (MOVDGEnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMPS x y))
  2096		for {
  2097			y := v.Args[1]
  2098			x := v.Args[0]
  2099			v.reset(OpS390XMOVDGEnoinv)
  2100			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2101			v0.AuxInt = 0
  2102			v.AddArg(v0)
  2103			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2104			v1.AuxInt = 1
  2105			v.AddArg(v1)
  2106			v2 := b.NewValue0(v.Pos, OpS390XFCMPS, types.TypeFlags)
  2107			v2.AddArg(x)
  2108			v2.AddArg(y)
  2109			v.AddArg(v2)
  2110			return true
  2111		}
  2112	}
  2113	func rewriteValueS390X_OpGeq32U_0(v *Value) bool {
  2114		b := v.Block
  2115		typ := &b.Func.Config.Types
  2116		// match: (Geq32U x y)
  2117		// cond:
  2118		// result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMPWU x y))
  2119		for {
  2120			y := v.Args[1]
  2121			x := v.Args[0]
  2122			v.reset(OpS390XMOVDGE)
  2123			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2124			v0.AuxInt = 0
  2125			v.AddArg(v0)
  2126			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2127			v1.AuxInt = 1
  2128			v.AddArg(v1)
  2129			v2 := b.NewValue0(v.Pos, OpS390XCMPWU, types.TypeFlags)
  2130			v2.AddArg(x)
  2131			v2.AddArg(y)
  2132			v.AddArg(v2)
  2133			return true
  2134		}
  2135	}
  2136	func rewriteValueS390X_OpGeq64_0(v *Value) bool {
  2137		b := v.Block
  2138		typ := &b.Func.Config.Types
  2139		// match: (Geq64 x y)
  2140		// cond:
  2141		// result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMP x y))
  2142		for {
  2143			y := v.Args[1]
  2144			x := v.Args[0]
  2145			v.reset(OpS390XMOVDGE)
  2146			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2147			v0.AuxInt = 0
  2148			v.AddArg(v0)
  2149			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2150			v1.AuxInt = 1
  2151			v.AddArg(v1)
  2152			v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
  2153			v2.AddArg(x)
  2154			v2.AddArg(y)
  2155			v.AddArg(v2)
  2156			return true
  2157		}
  2158	}
  2159	func rewriteValueS390X_OpGeq64F_0(v *Value) bool {
  2160		b := v.Block
  2161		typ := &b.Func.Config.Types
  2162		// match: (Geq64F x y)
  2163		// cond:
  2164		// result: (MOVDGEnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMP x y))
  2165		for {
  2166			y := v.Args[1]
  2167			x := v.Args[0]
  2168			v.reset(OpS390XMOVDGEnoinv)
  2169			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2170			v0.AuxInt = 0
  2171			v.AddArg(v0)
  2172			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2173			v1.AuxInt = 1
  2174			v.AddArg(v1)
  2175			v2 := b.NewValue0(v.Pos, OpS390XFCMP, types.TypeFlags)
  2176			v2.AddArg(x)
  2177			v2.AddArg(y)
  2178			v.AddArg(v2)
  2179			return true
  2180		}
  2181	}
  2182	func rewriteValueS390X_OpGeq64U_0(v *Value) bool {
  2183		b := v.Block
  2184		typ := &b.Func.Config.Types
  2185		// match: (Geq64U x y)
  2186		// cond:
  2187		// result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMPU x y))
  2188		for {
  2189			y := v.Args[1]
  2190			x := v.Args[0]
  2191			v.reset(OpS390XMOVDGE)
  2192			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2193			v0.AuxInt = 0
  2194			v.AddArg(v0)
  2195			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2196			v1.AuxInt = 1
  2197			v.AddArg(v1)
  2198			v2 := b.NewValue0(v.Pos, OpS390XCMPU, types.TypeFlags)
  2199			v2.AddArg(x)
  2200			v2.AddArg(y)
  2201			v.AddArg(v2)
  2202			return true
  2203		}
  2204	}
  2205	func rewriteValueS390X_OpGeq8_0(v *Value) bool {
  2206		b := v.Block
  2207		typ := &b.Func.Config.Types
  2208		// match: (Geq8 x y)
  2209		// cond:
  2210		// result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMPW (MOVBreg x) (MOVBreg y)))
  2211		for {
  2212			y := v.Args[1]
  2213			x := v.Args[0]
  2214			v.reset(OpS390XMOVDGE)
  2215			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2216			v0.AuxInt = 0
  2217			v.AddArg(v0)
  2218			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2219			v1.AuxInt = 1
  2220			v.AddArg(v1)
  2221			v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  2222			v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  2223			v3.AddArg(x)
  2224			v2.AddArg(v3)
  2225			v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  2226			v4.AddArg(y)
  2227			v2.AddArg(v4)
  2228			v.AddArg(v2)
  2229			return true
  2230		}
  2231	}
  2232	func rewriteValueS390X_OpGeq8U_0(v *Value) bool {
  2233		b := v.Block
  2234		typ := &b.Func.Config.Types
  2235		// match: (Geq8U x y)
  2236		// cond:
  2237		// result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMPWU (MOVBZreg x) (MOVBZreg y)))
  2238		for {
  2239			y := v.Args[1]
  2240			x := v.Args[0]
  2241			v.reset(OpS390XMOVDGE)
  2242			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2243			v0.AuxInt = 0
  2244			v.AddArg(v0)
  2245			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2246			v1.AuxInt = 1
  2247			v.AddArg(v1)
  2248			v2 := b.NewValue0(v.Pos, OpS390XCMPWU, types.TypeFlags)
  2249			v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  2250			v3.AddArg(x)
  2251			v2.AddArg(v3)
  2252			v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  2253			v4.AddArg(y)
  2254			v2.AddArg(v4)
  2255			v.AddArg(v2)
  2256			return true
  2257		}
  2258	}
  2259	func rewriteValueS390X_OpGetCallerPC_0(v *Value) bool {
  2260		// match: (GetCallerPC)
  2261		// cond:
  2262		// result: (LoweredGetCallerPC)
  2263		for {
  2264			v.reset(OpS390XLoweredGetCallerPC)
  2265			return true
  2266		}
  2267	}
  2268	func rewriteValueS390X_OpGetCallerSP_0(v *Value) bool {
  2269		// match: (GetCallerSP)
  2270		// cond:
  2271		// result: (LoweredGetCallerSP)
  2272		for {
  2273			v.reset(OpS390XLoweredGetCallerSP)
  2274			return true
  2275		}
  2276	}
  2277	func rewriteValueS390X_OpGetClosurePtr_0(v *Value) bool {
  2278		// match: (GetClosurePtr)
  2279		// cond:
  2280		// result: (LoweredGetClosurePtr)
  2281		for {
  2282			v.reset(OpS390XLoweredGetClosurePtr)
  2283			return true
  2284		}
  2285	}
  2286	func rewriteValueS390X_OpGetG_0(v *Value) bool {
  2287		// match: (GetG mem)
  2288		// cond:
  2289		// result: (LoweredGetG mem)
  2290		for {
  2291			mem := v.Args[0]
  2292			v.reset(OpS390XLoweredGetG)
  2293			v.AddArg(mem)
  2294			return true
  2295		}
  2296	}
  2297	func rewriteValueS390X_OpGreater16_0(v *Value) bool {
  2298		b := v.Block
  2299		typ := &b.Func.Config.Types
  2300		// match: (Greater16 x y)
  2301		// cond:
  2302		// result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMPW (MOVHreg x) (MOVHreg y)))
  2303		for {
  2304			y := v.Args[1]
  2305			x := v.Args[0]
  2306			v.reset(OpS390XMOVDGT)
  2307			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2308			v0.AuxInt = 0
  2309			v.AddArg(v0)
  2310			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2311			v1.AuxInt = 1
  2312			v.AddArg(v1)
  2313			v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  2314			v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  2315			v3.AddArg(x)
  2316			v2.AddArg(v3)
  2317			v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  2318			v4.AddArg(y)
  2319			v2.AddArg(v4)
  2320			v.AddArg(v2)
  2321			return true
  2322		}
  2323	}
  2324	func rewriteValueS390X_OpGreater16U_0(v *Value) bool {
  2325		b := v.Block
  2326		typ := &b.Func.Config.Types
  2327		// match: (Greater16U x y)
  2328		// cond:
  2329		// result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMPWU (MOVHZreg x) (MOVHZreg y)))
  2330		for {
  2331			y := v.Args[1]
  2332			x := v.Args[0]
  2333			v.reset(OpS390XMOVDGT)
  2334			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2335			v0.AuxInt = 0
  2336			v.AddArg(v0)
  2337			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2338			v1.AuxInt = 1
  2339			v.AddArg(v1)
  2340			v2 := b.NewValue0(v.Pos, OpS390XCMPWU, types.TypeFlags)
  2341			v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  2342			v3.AddArg(x)
  2343			v2.AddArg(v3)
  2344			v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  2345			v4.AddArg(y)
  2346			v2.AddArg(v4)
  2347			v.AddArg(v2)
  2348			return true
  2349		}
  2350	}
  2351	func rewriteValueS390X_OpGreater32_0(v *Value) bool {
  2352		b := v.Block
  2353		typ := &b.Func.Config.Types
  2354		// match: (Greater32 x y)
  2355		// cond:
  2356		// result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMPW x y))
  2357		for {
  2358			y := v.Args[1]
  2359			x := v.Args[0]
  2360			v.reset(OpS390XMOVDGT)
  2361			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2362			v0.AuxInt = 0
  2363			v.AddArg(v0)
  2364			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2365			v1.AuxInt = 1
  2366			v.AddArg(v1)
  2367			v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  2368			v2.AddArg(x)
  2369			v2.AddArg(y)
  2370			v.AddArg(v2)
  2371			return true
  2372		}
  2373	}
  2374	func rewriteValueS390X_OpGreater32F_0(v *Value) bool {
  2375		b := v.Block
  2376		typ := &b.Func.Config.Types
  2377		// match: (Greater32F x y)
  2378		// cond:
  2379		// result: (MOVDGTnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMPS x y))
  2380		for {
  2381			y := v.Args[1]
  2382			x := v.Args[0]
  2383			v.reset(OpS390XMOVDGTnoinv)
  2384			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2385			v0.AuxInt = 0
  2386			v.AddArg(v0)
  2387			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2388			v1.AuxInt = 1
  2389			v.AddArg(v1)
  2390			v2 := b.NewValue0(v.Pos, OpS390XFCMPS, types.TypeFlags)
  2391			v2.AddArg(x)
  2392			v2.AddArg(y)
  2393			v.AddArg(v2)
  2394			return true
  2395		}
  2396	}
  2397	func rewriteValueS390X_OpGreater32U_0(v *Value) bool {
  2398		b := v.Block
  2399		typ := &b.Func.Config.Types
  2400		// match: (Greater32U x y)
  2401		// cond:
  2402		// result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMPWU x y))
  2403		for {
  2404			y := v.Args[1]
  2405			x := v.Args[0]
  2406			v.reset(OpS390XMOVDGT)
  2407			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2408			v0.AuxInt = 0
  2409			v.AddArg(v0)
  2410			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2411			v1.AuxInt = 1
  2412			v.AddArg(v1)
  2413			v2 := b.NewValue0(v.Pos, OpS390XCMPWU, types.TypeFlags)
  2414			v2.AddArg(x)
  2415			v2.AddArg(y)
  2416			v.AddArg(v2)
  2417			return true
  2418		}
  2419	}
  2420	func rewriteValueS390X_OpGreater64_0(v *Value) bool {
  2421		b := v.Block
  2422		typ := &b.Func.Config.Types
  2423		// match: (Greater64 x y)
  2424		// cond:
  2425		// result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMP x y))
  2426		for {
  2427			y := v.Args[1]
  2428			x := v.Args[0]
  2429			v.reset(OpS390XMOVDGT)
  2430			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2431			v0.AuxInt = 0
  2432			v.AddArg(v0)
  2433			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2434			v1.AuxInt = 1
  2435			v.AddArg(v1)
  2436			v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
  2437			v2.AddArg(x)
  2438			v2.AddArg(y)
  2439			v.AddArg(v2)
  2440			return true
  2441		}
  2442	}
  2443	func rewriteValueS390X_OpGreater64F_0(v *Value) bool {
  2444		b := v.Block
  2445		typ := &b.Func.Config.Types
  2446		// match: (Greater64F x y)
  2447		// cond:
  2448		// result: (MOVDGTnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMP x y))
  2449		for {
  2450			y := v.Args[1]
  2451			x := v.Args[0]
  2452			v.reset(OpS390XMOVDGTnoinv)
  2453			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2454			v0.AuxInt = 0
  2455			v.AddArg(v0)
  2456			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2457			v1.AuxInt = 1
  2458			v.AddArg(v1)
  2459			v2 := b.NewValue0(v.Pos, OpS390XFCMP, types.TypeFlags)
  2460			v2.AddArg(x)
  2461			v2.AddArg(y)
  2462			v.AddArg(v2)
  2463			return true
  2464		}
  2465	}
  2466	func rewriteValueS390X_OpGreater64U_0(v *Value) bool {
  2467		b := v.Block
  2468		typ := &b.Func.Config.Types
  2469		// match: (Greater64U x y)
  2470		// cond:
  2471		// result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMPU x y))
  2472		for {
  2473			y := v.Args[1]
  2474			x := v.Args[0]
  2475			v.reset(OpS390XMOVDGT)
  2476			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2477			v0.AuxInt = 0
  2478			v.AddArg(v0)
  2479			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2480			v1.AuxInt = 1
  2481			v.AddArg(v1)
  2482			v2 := b.NewValue0(v.Pos, OpS390XCMPU, types.TypeFlags)
  2483			v2.AddArg(x)
  2484			v2.AddArg(y)
  2485			v.AddArg(v2)
  2486			return true
  2487		}
  2488	}
  2489	func rewriteValueS390X_OpGreater8_0(v *Value) bool {
  2490		b := v.Block
  2491		typ := &b.Func.Config.Types
  2492		// match: (Greater8 x y)
  2493		// cond:
  2494		// result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMPW (MOVBreg x) (MOVBreg y)))
  2495		for {
  2496			y := v.Args[1]
  2497			x := v.Args[0]
  2498			v.reset(OpS390XMOVDGT)
  2499			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2500			v0.AuxInt = 0
  2501			v.AddArg(v0)
  2502			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2503			v1.AuxInt = 1
  2504			v.AddArg(v1)
  2505			v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  2506			v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  2507			v3.AddArg(x)
  2508			v2.AddArg(v3)
  2509			v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  2510			v4.AddArg(y)
  2511			v2.AddArg(v4)
  2512			v.AddArg(v2)
  2513			return true
  2514		}
  2515	}
  2516	func rewriteValueS390X_OpGreater8U_0(v *Value) bool {
  2517		b := v.Block
  2518		typ := &b.Func.Config.Types
  2519		// match: (Greater8U x y)
  2520		// cond:
  2521		// result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMPWU (MOVBZreg x) (MOVBZreg y)))
  2522		for {
  2523			y := v.Args[1]
  2524			x := v.Args[0]
  2525			v.reset(OpS390XMOVDGT)
  2526			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2527			v0.AuxInt = 0
  2528			v.AddArg(v0)
  2529			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2530			v1.AuxInt = 1
  2531			v.AddArg(v1)
  2532			v2 := b.NewValue0(v.Pos, OpS390XCMPWU, types.TypeFlags)
  2533			v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  2534			v3.AddArg(x)
  2535			v2.AddArg(v3)
  2536			v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  2537			v4.AddArg(y)
  2538			v2.AddArg(v4)
  2539			v.AddArg(v2)
  2540			return true
  2541		}
  2542	}
  2543	func rewriteValueS390X_OpHmul32_0(v *Value) bool {
  2544		b := v.Block
  2545		typ := &b.Func.Config.Types
  2546		// match: (Hmul32 x y)
  2547		// cond:
  2548		// result: (SRDconst [32] (MULLD (MOVWreg x) (MOVWreg y)))
  2549		for {
  2550			y := v.Args[1]
  2551			x := v.Args[0]
  2552			v.reset(OpS390XSRDconst)
  2553			v.AuxInt = 32
  2554			v0 := b.NewValue0(v.Pos, OpS390XMULLD, typ.Int64)
  2555			v1 := b.NewValue0(v.Pos, OpS390XMOVWreg, typ.Int64)
  2556			v1.AddArg(x)
  2557			v0.AddArg(v1)
  2558			v2 := b.NewValue0(v.Pos, OpS390XMOVWreg, typ.Int64)
  2559			v2.AddArg(y)
  2560			v0.AddArg(v2)
  2561			v.AddArg(v0)
  2562			return true
  2563		}
  2564	}
  2565	func rewriteValueS390X_OpHmul32u_0(v *Value) bool {
  2566		b := v.Block
  2567		typ := &b.Func.Config.Types
  2568		// match: (Hmul32u x y)
  2569		// cond:
  2570		// result: (SRDconst [32] (MULLD (MOVWZreg x) (MOVWZreg y)))
  2571		for {
  2572			y := v.Args[1]
  2573			x := v.Args[0]
  2574			v.reset(OpS390XSRDconst)
  2575			v.AuxInt = 32
  2576			v0 := b.NewValue0(v.Pos, OpS390XMULLD, typ.Int64)
  2577			v1 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
  2578			v1.AddArg(x)
  2579			v0.AddArg(v1)
  2580			v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
  2581			v2.AddArg(y)
  2582			v0.AddArg(v2)
  2583			v.AddArg(v0)
  2584			return true
  2585		}
  2586	}
  2587	func rewriteValueS390X_OpHmul64_0(v *Value) bool {
  2588		// match: (Hmul64 x y)
  2589		// cond:
  2590		// result: (MULHD x y)
  2591		for {
  2592			y := v.Args[1]
  2593			x := v.Args[0]
  2594			v.reset(OpS390XMULHD)
  2595			v.AddArg(x)
  2596			v.AddArg(y)
  2597			return true
  2598		}
  2599	}
  2600	func rewriteValueS390X_OpHmul64u_0(v *Value) bool {
  2601		// match: (Hmul64u x y)
  2602		// cond:
  2603		// result: (MULHDU x y)
  2604		for {
  2605			y := v.Args[1]
  2606			x := v.Args[0]
  2607			v.reset(OpS390XMULHDU)
  2608			v.AddArg(x)
  2609			v.AddArg(y)
  2610			return true
  2611		}
  2612	}
  2613	func rewriteValueS390X_OpITab_0(v *Value) bool {
  2614		// match: (ITab (Load ptr mem))
  2615		// cond:
  2616		// result: (MOVDload ptr mem)
  2617		for {
  2618			v_0 := v.Args[0]
  2619			if v_0.Op != OpLoad {
  2620				break
  2621			}
  2622			mem := v_0.Args[1]
  2623			ptr := v_0.Args[0]
  2624			v.reset(OpS390XMOVDload)
  2625			v.AddArg(ptr)
  2626			v.AddArg(mem)
  2627			return true
  2628		}
  2629		return false
  2630	}
  2631	func rewriteValueS390X_OpInterCall_0(v *Value) bool {
  2632		// match: (InterCall [argwid] entry mem)
  2633		// cond:
  2634		// result: (CALLinter [argwid] entry mem)
  2635		for {
  2636			argwid := v.AuxInt
  2637			mem := v.Args[1]
  2638			entry := v.Args[0]
  2639			v.reset(OpS390XCALLinter)
  2640			v.AuxInt = argwid
  2641			v.AddArg(entry)
  2642			v.AddArg(mem)
  2643			return true
  2644		}
  2645	}
  2646	func rewriteValueS390X_OpIsInBounds_0(v *Value) bool {
  2647		b := v.Block
  2648		typ := &b.Func.Config.Types
  2649		// match: (IsInBounds idx len)
  2650		// cond:
  2651		// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMPU idx len))
  2652		for {
  2653			len := v.Args[1]
  2654			idx := v.Args[0]
  2655			v.reset(OpS390XMOVDLT)
  2656			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2657			v0.AuxInt = 0
  2658			v.AddArg(v0)
  2659			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2660			v1.AuxInt = 1
  2661			v.AddArg(v1)
  2662			v2 := b.NewValue0(v.Pos, OpS390XCMPU, types.TypeFlags)
  2663			v2.AddArg(idx)
  2664			v2.AddArg(len)
  2665			v.AddArg(v2)
  2666			return true
  2667		}
  2668	}
  2669	func rewriteValueS390X_OpIsNonNil_0(v *Value) bool {
  2670		b := v.Block
  2671		typ := &b.Func.Config.Types
  2672		// match: (IsNonNil p)
  2673		// cond:
  2674		// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (CMPconst p [0]))
  2675		for {
  2676			p := v.Args[0]
  2677			v.reset(OpS390XMOVDNE)
  2678			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2679			v0.AuxInt = 0
  2680			v.AddArg(v0)
  2681			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2682			v1.AuxInt = 1
  2683			v.AddArg(v1)
  2684			v2 := b.NewValue0(v.Pos, OpS390XCMPconst, types.TypeFlags)
  2685			v2.AuxInt = 0
  2686			v2.AddArg(p)
  2687			v.AddArg(v2)
  2688			return true
  2689		}
  2690	}
  2691	func rewriteValueS390X_OpIsSliceInBounds_0(v *Value) bool {
  2692		b := v.Block
  2693		typ := &b.Func.Config.Types
  2694		// match: (IsSliceInBounds idx len)
  2695		// cond:
  2696		// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMPU idx len))
  2697		for {
  2698			len := v.Args[1]
  2699			idx := v.Args[0]
  2700			v.reset(OpS390XMOVDLE)
  2701			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2702			v0.AuxInt = 0
  2703			v.AddArg(v0)
  2704			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2705			v1.AuxInt = 1
  2706			v.AddArg(v1)
  2707			v2 := b.NewValue0(v.Pos, OpS390XCMPU, types.TypeFlags)
  2708			v2.AddArg(idx)
  2709			v2.AddArg(len)
  2710			v.AddArg(v2)
  2711			return true
  2712		}
  2713	}
  2714	func rewriteValueS390X_OpLeq16_0(v *Value) bool {
  2715		b := v.Block
  2716		typ := &b.Func.Config.Types
  2717		// match: (Leq16 x y)
  2718		// cond:
  2719		// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMPW (MOVHreg x) (MOVHreg y)))
  2720		for {
  2721			y := v.Args[1]
  2722			x := v.Args[0]
  2723			v.reset(OpS390XMOVDLE)
  2724			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2725			v0.AuxInt = 0
  2726			v.AddArg(v0)
  2727			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2728			v1.AuxInt = 1
  2729			v.AddArg(v1)
  2730			v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  2731			v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  2732			v3.AddArg(x)
  2733			v2.AddArg(v3)
  2734			v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  2735			v4.AddArg(y)
  2736			v2.AddArg(v4)
  2737			v.AddArg(v2)
  2738			return true
  2739		}
  2740	}
  2741	func rewriteValueS390X_OpLeq16U_0(v *Value) bool {
  2742		b := v.Block
  2743		typ := &b.Func.Config.Types
  2744		// match: (Leq16U x y)
  2745		// cond:
  2746		// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMPWU (MOVHZreg x) (MOVHZreg y)))
  2747		for {
  2748			y := v.Args[1]
  2749			x := v.Args[0]
  2750			v.reset(OpS390XMOVDLE)
  2751			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2752			v0.AuxInt = 0
  2753			v.AddArg(v0)
  2754			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2755			v1.AuxInt = 1
  2756			v.AddArg(v1)
  2757			v2 := b.NewValue0(v.Pos, OpS390XCMPWU, types.TypeFlags)
  2758			v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  2759			v3.AddArg(x)
  2760			v2.AddArg(v3)
  2761			v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  2762			v4.AddArg(y)
  2763			v2.AddArg(v4)
  2764			v.AddArg(v2)
  2765			return true
  2766		}
  2767	}
  2768	func rewriteValueS390X_OpLeq32_0(v *Value) bool {
  2769		b := v.Block
  2770		typ := &b.Func.Config.Types
  2771		// match: (Leq32 x y)
  2772		// cond:
  2773		// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMPW x y))
  2774		for {
  2775			y := v.Args[1]
  2776			x := v.Args[0]
  2777			v.reset(OpS390XMOVDLE)
  2778			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2779			v0.AuxInt = 0
  2780			v.AddArg(v0)
  2781			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2782			v1.AuxInt = 1
  2783			v.AddArg(v1)
  2784			v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  2785			v2.AddArg(x)
  2786			v2.AddArg(y)
  2787			v.AddArg(v2)
  2788			return true
  2789		}
  2790	}
  2791	func rewriteValueS390X_OpLeq32F_0(v *Value) bool {
  2792		b := v.Block
  2793		typ := &b.Func.Config.Types
  2794		// match: (Leq32F x y)
  2795		// cond:
  2796		// result: (MOVDGEnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMPS y x))
  2797		for {
  2798			y := v.Args[1]
  2799			x := v.Args[0]
  2800			v.reset(OpS390XMOVDGEnoinv)
  2801			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2802			v0.AuxInt = 0
  2803			v.AddArg(v0)
  2804			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2805			v1.AuxInt = 1
  2806			v.AddArg(v1)
  2807			v2 := b.NewValue0(v.Pos, OpS390XFCMPS, types.TypeFlags)
  2808			v2.AddArg(y)
  2809			v2.AddArg(x)
  2810			v.AddArg(v2)
  2811			return true
  2812		}
  2813	}
  2814	func rewriteValueS390X_OpLeq32U_0(v *Value) bool {
  2815		b := v.Block
  2816		typ := &b.Func.Config.Types
  2817		// match: (Leq32U x y)
  2818		// cond:
  2819		// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMPWU x y))
  2820		for {
  2821			y := v.Args[1]
  2822			x := v.Args[0]
  2823			v.reset(OpS390XMOVDLE)
  2824			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2825			v0.AuxInt = 0
  2826			v.AddArg(v0)
  2827			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2828			v1.AuxInt = 1
  2829			v.AddArg(v1)
  2830			v2 := b.NewValue0(v.Pos, OpS390XCMPWU, types.TypeFlags)
  2831			v2.AddArg(x)
  2832			v2.AddArg(y)
  2833			v.AddArg(v2)
  2834			return true
  2835		}
  2836	}
  2837	func rewriteValueS390X_OpLeq64_0(v *Value) bool {
  2838		b := v.Block
  2839		typ := &b.Func.Config.Types
  2840		// match: (Leq64 x y)
  2841		// cond:
  2842		// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMP x y))
  2843		for {
  2844			y := v.Args[1]
  2845			x := v.Args[0]
  2846			v.reset(OpS390XMOVDLE)
  2847			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2848			v0.AuxInt = 0
  2849			v.AddArg(v0)
  2850			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2851			v1.AuxInt = 1
  2852			v.AddArg(v1)
  2853			v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
  2854			v2.AddArg(x)
  2855			v2.AddArg(y)
  2856			v.AddArg(v2)
  2857			return true
  2858		}
  2859	}
  2860	func rewriteValueS390X_OpLeq64F_0(v *Value) bool {
  2861		b := v.Block
  2862		typ := &b.Func.Config.Types
  2863		// match: (Leq64F x y)
  2864		// cond:
  2865		// result: (MOVDGEnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMP y x))
  2866		for {
  2867			y := v.Args[1]
  2868			x := v.Args[0]
  2869			v.reset(OpS390XMOVDGEnoinv)
  2870			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2871			v0.AuxInt = 0
  2872			v.AddArg(v0)
  2873			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2874			v1.AuxInt = 1
  2875			v.AddArg(v1)
  2876			v2 := b.NewValue0(v.Pos, OpS390XFCMP, types.TypeFlags)
  2877			v2.AddArg(y)
  2878			v2.AddArg(x)
  2879			v.AddArg(v2)
  2880			return true
  2881		}
  2882	}
  2883	func rewriteValueS390X_OpLeq64U_0(v *Value) bool {
  2884		b := v.Block
  2885		typ := &b.Func.Config.Types
  2886		// match: (Leq64U x y)
  2887		// cond:
  2888		// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMPU x y))
  2889		for {
  2890			y := v.Args[1]
  2891			x := v.Args[0]
  2892			v.reset(OpS390XMOVDLE)
  2893			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2894			v0.AuxInt = 0
  2895			v.AddArg(v0)
  2896			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2897			v1.AuxInt = 1
  2898			v.AddArg(v1)
  2899			v2 := b.NewValue0(v.Pos, OpS390XCMPU, types.TypeFlags)
  2900			v2.AddArg(x)
  2901			v2.AddArg(y)
  2902			v.AddArg(v2)
  2903			return true
  2904		}
  2905	}
  2906	func rewriteValueS390X_OpLeq8_0(v *Value) bool {
  2907		b := v.Block
  2908		typ := &b.Func.Config.Types
  2909		// match: (Leq8 x y)
  2910		// cond:
  2911		// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMPW (MOVBreg x) (MOVBreg y)))
  2912		for {
  2913			y := v.Args[1]
  2914			x := v.Args[0]
  2915			v.reset(OpS390XMOVDLE)
  2916			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2917			v0.AuxInt = 0
  2918			v.AddArg(v0)
  2919			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2920			v1.AuxInt = 1
  2921			v.AddArg(v1)
  2922			v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  2923			v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  2924			v3.AddArg(x)
  2925			v2.AddArg(v3)
  2926			v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  2927			v4.AddArg(y)
  2928			v2.AddArg(v4)
  2929			v.AddArg(v2)
  2930			return true
  2931		}
  2932	}
  2933	func rewriteValueS390X_OpLeq8U_0(v *Value) bool {
  2934		b := v.Block
  2935		typ := &b.Func.Config.Types
  2936		// match: (Leq8U x y)
  2937		// cond:
  2938		// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMPWU (MOVBZreg x) (MOVBZreg y)))
  2939		for {
  2940			y := v.Args[1]
  2941			x := v.Args[0]
  2942			v.reset(OpS390XMOVDLE)
  2943			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2944			v0.AuxInt = 0
  2945			v.AddArg(v0)
  2946			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2947			v1.AuxInt = 1
  2948			v.AddArg(v1)
  2949			v2 := b.NewValue0(v.Pos, OpS390XCMPWU, types.TypeFlags)
  2950			v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  2951			v3.AddArg(x)
  2952			v2.AddArg(v3)
  2953			v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  2954			v4.AddArg(y)
  2955			v2.AddArg(v4)
  2956			v.AddArg(v2)
  2957			return true
  2958		}
  2959	}
  2960	func rewriteValueS390X_OpLess16_0(v *Value) bool {
  2961		b := v.Block
  2962		typ := &b.Func.Config.Types
  2963		// match: (Less16 x y)
  2964		// cond:
  2965		// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMPW (MOVHreg x) (MOVHreg y)))
  2966		for {
  2967			y := v.Args[1]
  2968			x := v.Args[0]
  2969			v.reset(OpS390XMOVDLT)
  2970			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2971			v0.AuxInt = 0
  2972			v.AddArg(v0)
  2973			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2974			v1.AuxInt = 1
  2975			v.AddArg(v1)
  2976			v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  2977			v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  2978			v3.AddArg(x)
  2979			v2.AddArg(v3)
  2980			v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  2981			v4.AddArg(y)
  2982			v2.AddArg(v4)
  2983			v.AddArg(v2)
  2984			return true
  2985		}
  2986	}
  2987	func rewriteValueS390X_OpLess16U_0(v *Value) bool {
  2988		b := v.Block
  2989		typ := &b.Func.Config.Types
  2990		// match: (Less16U x y)
  2991		// cond:
  2992		// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMPWU (MOVHZreg x) (MOVHZreg y)))
  2993		for {
  2994			y := v.Args[1]
  2995			x := v.Args[0]
  2996			v.reset(OpS390XMOVDLT)
  2997			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2998			v0.AuxInt = 0
  2999			v.AddArg(v0)
  3000			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3001			v1.AuxInt = 1
  3002			v.AddArg(v1)
  3003			v2 := b.NewValue0(v.Pos, OpS390XCMPWU, types.TypeFlags)
  3004			v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  3005			v3.AddArg(x)
  3006			v2.AddArg(v3)
  3007			v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  3008			v4.AddArg(y)
  3009			v2.AddArg(v4)
  3010			v.AddArg(v2)
  3011			return true
  3012		}
  3013	}
  3014	func rewriteValueS390X_OpLess32_0(v *Value) bool {
  3015		b := v.Block
  3016		typ := &b.Func.Config.Types
  3017		// match: (Less32 x y)
  3018		// cond:
  3019		// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMPW x y))
  3020		for {
  3021			y := v.Args[1]
  3022			x := v.Args[0]
  3023			v.reset(OpS390XMOVDLT)
  3024			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3025			v0.AuxInt = 0
  3026			v.AddArg(v0)
  3027			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3028			v1.AuxInt = 1
  3029			v.AddArg(v1)
  3030			v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  3031			v2.AddArg(x)
  3032			v2.AddArg(y)
  3033			v.AddArg(v2)
  3034			return true
  3035		}
  3036	}
  3037	func rewriteValueS390X_OpLess32F_0(v *Value) bool {
  3038		b := v.Block
  3039		typ := &b.Func.Config.Types
  3040		// match: (Less32F x y)
  3041		// cond:
  3042		// result: (MOVDGTnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMPS y x))
  3043		for {
  3044			y := v.Args[1]
  3045			x := v.Args[0]
  3046			v.reset(OpS390XMOVDGTnoinv)
  3047			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3048			v0.AuxInt = 0
  3049			v.AddArg(v0)
  3050			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3051			v1.AuxInt = 1
  3052			v.AddArg(v1)
  3053			v2 := b.NewValue0(v.Pos, OpS390XFCMPS, types.TypeFlags)
  3054			v2.AddArg(y)
  3055			v2.AddArg(x)
  3056			v.AddArg(v2)
  3057			return true
  3058		}
  3059	}
  3060	func rewriteValueS390X_OpLess32U_0(v *Value) bool {
  3061		b := v.Block
  3062		typ := &b.Func.Config.Types
  3063		// match: (Less32U x y)
  3064		// cond:
  3065		// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMPWU x y))
  3066		for {
  3067			y := v.Args[1]
  3068			x := v.Args[0]
  3069			v.reset(OpS390XMOVDLT)
  3070			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3071			v0.AuxInt = 0
  3072			v.AddArg(v0)
  3073			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3074			v1.AuxInt = 1
  3075			v.AddArg(v1)
  3076			v2 := b.NewValue0(v.Pos, OpS390XCMPWU, types.TypeFlags)
  3077			v2.AddArg(x)
  3078			v2.AddArg(y)
  3079			v.AddArg(v2)
  3080			return true
  3081		}
  3082	}
  3083	func rewriteValueS390X_OpLess64_0(v *Value) bool {
  3084		b := v.Block
  3085		typ := &b.Func.Config.Types
  3086		// match: (Less64 x y)
  3087		// cond:
  3088		// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMP x y))
  3089		for {
  3090			y := v.Args[1]
  3091			x := v.Args[0]
  3092			v.reset(OpS390XMOVDLT)
  3093			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3094			v0.AuxInt = 0
  3095			v.AddArg(v0)
  3096			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3097			v1.AuxInt = 1
  3098			v.AddArg(v1)
  3099			v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
  3100			v2.AddArg(x)
  3101			v2.AddArg(y)
  3102			v.AddArg(v2)
  3103			return true
  3104		}
  3105	}
  3106	func rewriteValueS390X_OpLess64F_0(v *Value) bool {
  3107		b := v.Block
  3108		typ := &b.Func.Config.Types
  3109		// match: (Less64F x y)
  3110		// cond:
  3111		// result: (MOVDGTnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMP y x))
  3112		for {
  3113			y := v.Args[1]
  3114			x := v.Args[0]
  3115			v.reset(OpS390XMOVDGTnoinv)
  3116			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3117			v0.AuxInt = 0
  3118			v.AddArg(v0)
  3119			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3120			v1.AuxInt = 1
  3121			v.AddArg(v1)
  3122			v2 := b.NewValue0(v.Pos, OpS390XFCMP, types.TypeFlags)
  3123			v2.AddArg(y)
  3124			v2.AddArg(x)
  3125			v.AddArg(v2)
  3126			return true
  3127		}
  3128	}
  3129	func rewriteValueS390X_OpLess64U_0(v *Value) bool {
  3130		b := v.Block
  3131		typ := &b.Func.Config.Types
  3132		// match: (Less64U x y)
  3133		// cond:
  3134		// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMPU x y))
  3135		for {
  3136			y := v.Args[1]
  3137			x := v.Args[0]
  3138			v.reset(OpS390XMOVDLT)
  3139			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3140			v0.AuxInt = 0
  3141			v.AddArg(v0)
  3142			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3143			v1.AuxInt = 1
  3144			v.AddArg(v1)
  3145			v2 := b.NewValue0(v.Pos, OpS390XCMPU, types.TypeFlags)
  3146			v2.AddArg(x)
  3147			v2.AddArg(y)
  3148			v.AddArg(v2)
  3149			return true
  3150		}
  3151	}
  3152	func rewriteValueS390X_OpLess8_0(v *Value) bool {
  3153		b := v.Block
  3154		typ := &b.Func.Config.Types
  3155		// match: (Less8 x y)
  3156		// cond:
  3157		// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMPW (MOVBreg x) (MOVBreg y)))
  3158		for {
  3159			y := v.Args[1]
  3160			x := v.Args[0]
  3161			v.reset(OpS390XMOVDLT)
  3162			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3163			v0.AuxInt = 0
  3164			v.AddArg(v0)
  3165			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3166			v1.AuxInt = 1
  3167			v.AddArg(v1)
  3168			v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  3169			v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  3170			v3.AddArg(x)
  3171			v2.AddArg(v3)
  3172			v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  3173			v4.AddArg(y)
  3174			v2.AddArg(v4)
  3175			v.AddArg(v2)
  3176			return true
  3177		}
  3178	}
  3179	func rewriteValueS390X_OpLess8U_0(v *Value) bool {
  3180		b := v.Block
  3181		typ := &b.Func.Config.Types
  3182		// match: (Less8U x y)
  3183		// cond:
  3184		// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMPWU (MOVBZreg x) (MOVBZreg y)))
  3185		for {
  3186			y := v.Args[1]
  3187			x := v.Args[0]
  3188			v.reset(OpS390XMOVDLT)
  3189			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3190			v0.AuxInt = 0
  3191			v.AddArg(v0)
  3192			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3193			v1.AuxInt = 1
  3194			v.AddArg(v1)
  3195			v2 := b.NewValue0(v.Pos, OpS390XCMPWU, types.TypeFlags)
  3196			v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  3197			v3.AddArg(x)
  3198			v2.AddArg(v3)
  3199			v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  3200			v4.AddArg(y)
  3201			v2.AddArg(v4)
  3202			v.AddArg(v2)
  3203			return true
  3204		}
  3205	}
  3206	func rewriteValueS390X_OpLoad_0(v *Value) bool {
  3207		// match: (Load <t> ptr mem)
  3208		// cond: (is64BitInt(t) || isPtr(t))
  3209		// result: (MOVDload ptr mem)
  3210		for {
  3211			t := v.Type
  3212			mem := v.Args[1]
  3213			ptr := v.Args[0]
  3214			if !(is64BitInt(t) || isPtr(t)) {
  3215				break
  3216			}
  3217			v.reset(OpS390XMOVDload)
  3218			v.AddArg(ptr)
  3219			v.AddArg(mem)
  3220			return true
  3221		}
  3222		// match: (Load <t> ptr mem)
  3223		// cond: is32BitInt(t) && isSigned(t)
  3224		// result: (MOVWload ptr mem)
  3225		for {
  3226			t := v.Type
  3227			mem := v.Args[1]
  3228			ptr := v.Args[0]
  3229			if !(is32BitInt(t) && isSigned(t)) {
  3230				break
  3231			}
  3232			v.reset(OpS390XMOVWload)
  3233			v.AddArg(ptr)
  3234			v.AddArg(mem)
  3235			return true
  3236		}
  3237		// match: (Load <t> ptr mem)
  3238		// cond: is32BitInt(t) && !isSigned(t)
  3239		// result: (MOVWZload ptr mem)
  3240		for {
  3241			t := v.Type
  3242			mem := v.Args[1]
  3243			ptr := v.Args[0]
  3244			if !(is32BitInt(t) && !isSigned(t)) {
  3245				break
  3246			}
  3247			v.reset(OpS390XMOVWZload)
  3248			v.AddArg(ptr)
  3249			v.AddArg(mem)
  3250			return true
  3251		}
  3252		// match: (Load <t> ptr mem)
  3253		// cond: is16BitInt(t) && isSigned(t)
  3254		// result: (MOVHload ptr mem)
  3255		for {
  3256			t := v.Type
  3257			mem := v.Args[1]
  3258			ptr := v.Args[0]
  3259			if !(is16BitInt(t) && isSigned(t)) {
  3260				break
  3261			}
  3262			v.reset(OpS390XMOVHload)
  3263			v.AddArg(ptr)
  3264			v.AddArg(mem)
  3265			return true
  3266		}
  3267		// match: (Load <t> ptr mem)
  3268		// cond: is16BitInt(t) && !isSigned(t)
  3269		// result: (MOVHZload ptr mem)
  3270		for {
  3271			t := v.Type
  3272			mem := v.Args[1]
  3273			ptr := v.Args[0]
  3274			if !(is16BitInt(t) && !isSigned(t)) {
  3275				break
  3276			}
  3277			v.reset(OpS390XMOVHZload)
  3278			v.AddArg(ptr)
  3279			v.AddArg(mem)
  3280			return true
  3281		}
  3282		// match: (Load <t> ptr mem)
  3283		// cond: is8BitInt(t) && isSigned(t)
  3284		// result: (MOVBload ptr mem)
  3285		for {
  3286			t := v.Type
  3287			mem := v.Args[1]
  3288			ptr := v.Args[0]
  3289			if !(is8BitInt(t) && isSigned(t)) {
  3290				break
  3291			}
  3292			v.reset(OpS390XMOVBload)
  3293			v.AddArg(ptr)
  3294			v.AddArg(mem)
  3295			return true
  3296		}
  3297		// match: (Load <t> ptr mem)
  3298		// cond: (t.IsBoolean() || (is8BitInt(t) && !isSigned(t)))
  3299		// result: (MOVBZload ptr mem)
  3300		for {
  3301			t := v.Type
  3302			mem := v.Args[1]
  3303			ptr := v.Args[0]
  3304			if !(t.IsBoolean() || (is8BitInt(t) && !isSigned(t))) {
  3305				break
  3306			}
  3307			v.reset(OpS390XMOVBZload)
  3308			v.AddArg(ptr)
  3309			v.AddArg(mem)
  3310			return true
  3311		}
  3312		// match: (Load <t> ptr mem)
  3313		// cond: is32BitFloat(t)
  3314		// result: (FMOVSload ptr mem)
  3315		for {
  3316			t := v.Type
  3317			mem := v.Args[1]
  3318			ptr := v.Args[0]
  3319			if !(is32BitFloat(t)) {
  3320				break
  3321			}
  3322			v.reset(OpS390XFMOVSload)
  3323			v.AddArg(ptr)
  3324			v.AddArg(mem)
  3325			return true
  3326		}
  3327		// match: (Load <t> ptr mem)
  3328		// cond: is64BitFloat(t)
  3329		// result: (FMOVDload ptr mem)
  3330		for {
  3331			t := v.Type
  3332			mem := v.Args[1]
  3333			ptr := v.Args[0]
  3334			if !(is64BitFloat(t)) {
  3335				break
  3336			}
  3337			v.reset(OpS390XFMOVDload)
  3338			v.AddArg(ptr)
  3339			v.AddArg(mem)
  3340			return true
  3341		}
  3342		return false
  3343	}
  3344	func rewriteValueS390X_OpLocalAddr_0(v *Value) bool {
  3345		// match: (LocalAddr {sym} base _)
  3346		// cond:
  3347		// result: (MOVDaddr {sym} base)
  3348		for {
  3349			sym := v.Aux
  3350			_ = v.Args[1]
  3351			base := v.Args[0]
  3352			v.reset(OpS390XMOVDaddr)
  3353			v.Aux = sym
  3354			v.AddArg(base)
  3355			return true
  3356		}
  3357	}
  3358	func rewriteValueS390X_OpLsh16x16_0(v *Value) bool {
  3359		b := v.Block
  3360		typ := &b.Func.Config.Types
  3361		// match: (Lsh16x16 x y)
  3362		// cond: shiftIsBounded(v)
  3363		// result: (SLW x y)
  3364		for {
  3365			y := v.Args[1]
  3366			x := v.Args[0]
  3367			if !(shiftIsBounded(v)) {
  3368				break
  3369			}
  3370			v.reset(OpS390XSLW)
  3371			v.AddArg(x)
  3372			v.AddArg(y)
  3373			return true
  3374		}
  3375		// match: (Lsh16x16 <t> x y)
  3376		// cond:
  3377		// result: (MOVDGE <t> (SLW <t> x y) (MOVDconst [0]) (CMPWUconst (MOVHZreg y) [64]))
  3378		for {
  3379			t := v.Type
  3380			y := v.Args[1]
  3381			x := v.Args[0]
  3382			v.reset(OpS390XMOVDGE)
  3383			v.Type = t
  3384			v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
  3385			v0.AddArg(x)
  3386			v0.AddArg(y)
  3387			v.AddArg(v0)
  3388			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3389			v1.AuxInt = 0
  3390			v.AddArg(v1)
  3391			v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  3392			v2.AuxInt = 64
  3393			v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  3394			v3.AddArg(y)
  3395			v2.AddArg(v3)
  3396			v.AddArg(v2)
  3397			return true
  3398		}
  3399	}
  3400	func rewriteValueS390X_OpLsh16x32_0(v *Value) bool {
  3401		b := v.Block
  3402		typ := &b.Func.Config.Types
  3403		// match: (Lsh16x32 x y)
  3404		// cond: shiftIsBounded(v)
  3405		// result: (SLW x y)
  3406		for {
  3407			y := v.Args[1]
  3408			x := v.Args[0]
  3409			if !(shiftIsBounded(v)) {
  3410				break
  3411			}
  3412			v.reset(OpS390XSLW)
  3413			v.AddArg(x)
  3414			v.AddArg(y)
  3415			return true
  3416		}
  3417		// match: (Lsh16x32 <t> x y)
  3418		// cond:
  3419		// result: (MOVDGE <t> (SLW <t> x y) (MOVDconst [0]) (CMPWUconst y [64]))
  3420		for {
  3421			t := v.Type
  3422			y := v.Args[1]
  3423			x := v.Args[0]
  3424			v.reset(OpS390XMOVDGE)
  3425			v.Type = t
  3426			v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
  3427			v0.AddArg(x)
  3428			v0.AddArg(y)
  3429			v.AddArg(v0)
  3430			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3431			v1.AuxInt = 0
  3432			v.AddArg(v1)
  3433			v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  3434			v2.AuxInt = 64
  3435			v2.AddArg(y)
  3436			v.AddArg(v2)
  3437			return true
  3438		}
  3439	}
  3440	func rewriteValueS390X_OpLsh16x64_0(v *Value) bool {
  3441		b := v.Block
  3442		typ := &b.Func.Config.Types
  3443		// match: (Lsh16x64 x y)
  3444		// cond: shiftIsBounded(v)
  3445		// result: (SLW x y)
  3446		for {
  3447			y := v.Args[1]
  3448			x := v.Args[0]
  3449			if !(shiftIsBounded(v)) {
  3450				break
  3451			}
  3452			v.reset(OpS390XSLW)
  3453			v.AddArg(x)
  3454			v.AddArg(y)
  3455			return true
  3456		}
  3457		// match: (Lsh16x64 <t> x y)
  3458		// cond:
  3459		// result: (MOVDGE <t> (SLW <t> x y) (MOVDconst [0]) (CMPUconst y [64]))
  3460		for {
  3461			t := v.Type
  3462			y := v.Args[1]
  3463			x := v.Args[0]
  3464			v.reset(OpS390XMOVDGE)
  3465			v.Type = t
  3466			v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
  3467			v0.AddArg(x)
  3468			v0.AddArg(y)
  3469			v.AddArg(v0)
  3470			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3471			v1.AuxInt = 0
  3472			v.AddArg(v1)
  3473			v2 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
  3474			v2.AuxInt = 64
  3475			v2.AddArg(y)
  3476			v.AddArg(v2)
  3477			return true
  3478		}
  3479	}
  3480	func rewriteValueS390X_OpLsh16x8_0(v *Value) bool {
  3481		b := v.Block
  3482		typ := &b.Func.Config.Types
  3483		// match: (Lsh16x8 x y)
  3484		// cond: shiftIsBounded(v)
  3485		// result: (SLW x y)
  3486		for {
  3487			y := v.Args[1]
  3488			x := v.Args[0]
  3489			if !(shiftIsBounded(v)) {
  3490				break
  3491			}
  3492			v.reset(OpS390XSLW)
  3493			v.AddArg(x)
  3494			v.AddArg(y)
  3495			return true
  3496		}
  3497		// match: (Lsh16x8 <t> x y)
  3498		// cond:
  3499		// result: (MOVDGE <t> (SLW <t> x y) (MOVDconst [0]) (CMPWUconst (MOVBZreg y) [64]))
  3500		for {
  3501			t := v.Type
  3502			y := v.Args[1]
  3503			x := v.Args[0]
  3504			v.reset(OpS390XMOVDGE)
  3505			v.Type = t
  3506			v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
  3507			v0.AddArg(x)
  3508			v0.AddArg(y)
  3509			v.AddArg(v0)
  3510			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3511			v1.AuxInt = 0
  3512			v.AddArg(v1)
  3513			v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  3514			v2.AuxInt = 64
  3515			v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  3516			v3.AddArg(y)
  3517			v2.AddArg(v3)
  3518			v.AddArg(v2)
  3519			return true
  3520		}
  3521	}
  3522	func rewriteValueS390X_OpLsh32x16_0(v *Value) bool {
  3523		b := v.Block
  3524		typ := &b.Func.Config.Types
  3525		// match: (Lsh32x16 x y)
  3526		// cond: shiftIsBounded(v)
  3527		// result: (SLW x y)
  3528		for {
  3529			y := v.Args[1]
  3530			x := v.Args[0]
  3531			if !(shiftIsBounded(v)) {
  3532				break
  3533			}
  3534			v.reset(OpS390XSLW)
  3535			v.AddArg(x)
  3536			v.AddArg(y)
  3537			return true
  3538		}
  3539		// match: (Lsh32x16 <t> x y)
  3540		// cond:
  3541		// result: (MOVDGE <t> (SLW <t> x y) (MOVDconst [0]) (CMPWUconst (MOVHZreg y) [64]))
  3542		for {
  3543			t := v.Type
  3544			y := v.Args[1]
  3545			x := v.Args[0]
  3546			v.reset(OpS390XMOVDGE)
  3547			v.Type = t
  3548			v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
  3549			v0.AddArg(x)
  3550			v0.AddArg(y)
  3551			v.AddArg(v0)
  3552			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3553			v1.AuxInt = 0
  3554			v.AddArg(v1)
  3555			v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  3556			v2.AuxInt = 64
  3557			v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  3558			v3.AddArg(y)
  3559			v2.AddArg(v3)
  3560			v.AddArg(v2)
  3561			return true
  3562		}
  3563	}
  3564	func rewriteValueS390X_OpLsh32x32_0(v *Value) bool {
  3565		b := v.Block
  3566		typ := &b.Func.Config.Types
  3567		// match: (Lsh32x32 x y)
  3568		// cond: shiftIsBounded(v)
  3569		// result: (SLW x y)
  3570		for {
  3571			y := v.Args[1]
  3572			x := v.Args[0]
  3573			if !(shiftIsBounded(v)) {
  3574				break
  3575			}
  3576			v.reset(OpS390XSLW)
  3577			v.AddArg(x)
  3578			v.AddArg(y)
  3579			return true
  3580		}
  3581		// match: (Lsh32x32 <t> x y)
  3582		// cond:
  3583		// result: (MOVDGE <t> (SLW <t> x y) (MOVDconst [0]) (CMPWUconst y [64]))
  3584		for {
  3585			t := v.Type
  3586			y := v.Args[1]
  3587			x := v.Args[0]
  3588			v.reset(OpS390XMOVDGE)
  3589			v.Type = t
  3590			v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
  3591			v0.AddArg(x)
  3592			v0.AddArg(y)
  3593			v.AddArg(v0)
  3594			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3595			v1.AuxInt = 0
  3596			v.AddArg(v1)
  3597			v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  3598			v2.AuxInt = 64
  3599			v2.AddArg(y)
  3600			v.AddArg(v2)
  3601			return true
  3602		}
  3603	}
  3604	func rewriteValueS390X_OpLsh32x64_0(v *Value) bool {
  3605		b := v.Block
  3606		typ := &b.Func.Config.Types
  3607		// match: (Lsh32x64 x y)
  3608		// cond: shiftIsBounded(v)
  3609		// result: (SLW x y)
  3610		for {
  3611			y := v.Args[1]
  3612			x := v.Args[0]
  3613			if !(shiftIsBounded(v)) {
  3614				break
  3615			}
  3616			v.reset(OpS390XSLW)
  3617			v.AddArg(x)
  3618			v.AddArg(y)
  3619			return true
  3620		}
  3621		// match: (Lsh32x64 <t> x y)
  3622		// cond:
  3623		// result: (MOVDGE <t> (SLW <t> x y) (MOVDconst [0]) (CMPUconst y [64]))
  3624		for {
  3625			t := v.Type
  3626			y := v.Args[1]
  3627			x := v.Args[0]
  3628			v.reset(OpS390XMOVDGE)
  3629			v.Type = t
  3630			v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
  3631			v0.AddArg(x)
  3632			v0.AddArg(y)
  3633			v.AddArg(v0)
  3634			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3635			v1.AuxInt = 0
  3636			v.AddArg(v1)
  3637			v2 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
  3638			v2.AuxInt = 64
  3639			v2.AddArg(y)
  3640			v.AddArg(v2)
  3641			return true
  3642		}
  3643	}
  3644	func rewriteValueS390X_OpLsh32x8_0(v *Value) bool {
  3645		b := v.Block
  3646		typ := &b.Func.Config.Types
  3647		// match: (Lsh32x8 x y)
  3648		// cond: shiftIsBounded(v)
  3649		// result: (SLW x y)
  3650		for {
  3651			y := v.Args[1]
  3652			x := v.Args[0]
  3653			if !(shiftIsBounded(v)) {
  3654				break
  3655			}
  3656			v.reset(OpS390XSLW)
  3657			v.AddArg(x)
  3658			v.AddArg(y)
  3659			return true
  3660		}
  3661		// match: (Lsh32x8 <t> x y)
  3662		// cond:
  3663		// result: (MOVDGE <t> (SLW <t> x y) (MOVDconst [0]) (CMPWUconst (MOVBZreg y) [64]))
  3664		for {
  3665			t := v.Type
  3666			y := v.Args[1]
  3667			x := v.Args[0]
  3668			v.reset(OpS390XMOVDGE)
  3669			v.Type = t
  3670			v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
  3671			v0.AddArg(x)
  3672			v0.AddArg(y)
  3673			v.AddArg(v0)
  3674			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3675			v1.AuxInt = 0
  3676			v.AddArg(v1)
  3677			v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  3678			v2.AuxInt = 64
  3679			v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  3680			v3.AddArg(y)
  3681			v2.AddArg(v3)
  3682			v.AddArg(v2)
  3683			return true
  3684		}
  3685	}
  3686	func rewriteValueS390X_OpLsh64x16_0(v *Value) bool {
  3687		b := v.Block
  3688		typ := &b.Func.Config.Types
  3689		// match: (Lsh64x16 x y)
  3690		// cond: shiftIsBounded(v)
  3691		// result: (SLD x y)
  3692		for {
  3693			y := v.Args[1]
  3694			x := v.Args[0]
  3695			if !(shiftIsBounded(v)) {
  3696				break
  3697			}
  3698			v.reset(OpS390XSLD)
  3699			v.AddArg(x)
  3700			v.AddArg(y)
  3701			return true
  3702		}
  3703		// match: (Lsh64x16 <t> x y)
  3704		// cond:
  3705		// result: (MOVDGE <t> (SLD <t> x y) (MOVDconst [0]) (CMPWUconst (MOVHZreg y) [64]))
  3706		for {
  3707			t := v.Type
  3708			y := v.Args[1]
  3709			x := v.Args[0]
  3710			v.reset(OpS390XMOVDGE)
  3711			v.Type = t
  3712			v0 := b.NewValue0(v.Pos, OpS390XSLD, t)
  3713			v0.AddArg(x)
  3714			v0.AddArg(y)
  3715			v.AddArg(v0)
  3716			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3717			v1.AuxInt = 0
  3718			v.AddArg(v1)
  3719			v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  3720			v2.AuxInt = 64
  3721			v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  3722			v3.AddArg(y)
  3723			v2.AddArg(v3)
  3724			v.AddArg(v2)
  3725			return true
  3726		}
  3727	}
  3728	func rewriteValueS390X_OpLsh64x32_0(v *Value) bool {
  3729		b := v.Block
  3730		typ := &b.Func.Config.Types
  3731		// match: (Lsh64x32 x y)
  3732		// cond: shiftIsBounded(v)
  3733		// result: (SLD x y)
  3734		for {
  3735			y := v.Args[1]
  3736			x := v.Args[0]
  3737			if !(shiftIsBounded(v)) {
  3738				break
  3739			}
  3740			v.reset(OpS390XSLD)
  3741			v.AddArg(x)
  3742			v.AddArg(y)
  3743			return true
  3744		}
  3745		// match: (Lsh64x32 <t> x y)
  3746		// cond:
  3747		// result: (MOVDGE <t> (SLD <t> x y) (MOVDconst [0]) (CMPWUconst y [64]))
  3748		for {
  3749			t := v.Type
  3750			y := v.Args[1]
  3751			x := v.Args[0]
  3752			v.reset(OpS390XMOVDGE)
  3753			v.Type = t
  3754			v0 := b.NewValue0(v.Pos, OpS390XSLD, t)
  3755			v0.AddArg(x)
  3756			v0.AddArg(y)
  3757			v.AddArg(v0)
  3758			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3759			v1.AuxInt = 0
  3760			v.AddArg(v1)
  3761			v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  3762			v2.AuxInt = 64
  3763			v2.AddArg(y)
  3764			v.AddArg(v2)
  3765			return true
  3766		}
  3767	}
  3768	func rewriteValueS390X_OpLsh64x64_0(v *Value) bool {
  3769		b := v.Block
  3770		typ := &b.Func.Config.Types
  3771		// match: (Lsh64x64 x y)
  3772		// cond: shiftIsBounded(v)
  3773		// result: (SLD x y)
  3774		for {
  3775			y := v.Args[1]
  3776			x := v.Args[0]
  3777			if !(shiftIsBounded(v)) {
  3778				break
  3779			}
  3780			v.reset(OpS390XSLD)
  3781			v.AddArg(x)
  3782			v.AddArg(y)
  3783			return true
  3784		}
  3785		// match: (Lsh64x64 <t> x y)
  3786		// cond:
  3787		// result: (MOVDGE <t> (SLD <t> x y) (MOVDconst [0]) (CMPUconst y [64]))
  3788		for {
  3789			t := v.Type
  3790			y := v.Args[1]
  3791			x := v.Args[0]
  3792			v.reset(OpS390XMOVDGE)
  3793			v.Type = t
  3794			v0 := b.NewValue0(v.Pos, OpS390XSLD, t)
  3795			v0.AddArg(x)
  3796			v0.AddArg(y)
  3797			v.AddArg(v0)
  3798			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3799			v1.AuxInt = 0
  3800			v.AddArg(v1)
  3801			v2 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
  3802			v2.AuxInt = 64
  3803			v2.AddArg(y)
  3804			v.AddArg(v2)
  3805			return true
  3806		}
  3807	}
  3808	func rewriteValueS390X_OpLsh64x8_0(v *Value) bool {
  3809		b := v.Block
  3810		typ := &b.Func.Config.Types
  3811		// match: (Lsh64x8 x y)
  3812		// cond: shiftIsBounded(v)
  3813		// result: (SLD x y)
  3814		for {
  3815			y := v.Args[1]
  3816			x := v.Args[0]
  3817			if !(shiftIsBounded(v)) {
  3818				break
  3819			}
  3820			v.reset(OpS390XSLD)
  3821			v.AddArg(x)
  3822			v.AddArg(y)
  3823			return true
  3824		}
  3825		// match: (Lsh64x8 <t> x y)
  3826		// cond:
  3827		// result: (MOVDGE <t> (SLD <t> x y) (MOVDconst [0]) (CMPWUconst (MOVBZreg y) [64]))
  3828		for {
  3829			t := v.Type
  3830			y := v.Args[1]
  3831			x := v.Args[0]
  3832			v.reset(OpS390XMOVDGE)
  3833			v.Type = t
  3834			v0 := b.NewValue0(v.Pos, OpS390XSLD, t)
  3835			v0.AddArg(x)
  3836			v0.AddArg(y)
  3837			v.AddArg(v0)
  3838			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3839			v1.AuxInt = 0
  3840			v.AddArg(v1)
  3841			v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  3842			v2.AuxInt = 64
  3843			v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  3844			v3.AddArg(y)
  3845			v2.AddArg(v3)
  3846			v.AddArg(v2)
  3847			return true
  3848		}
  3849	}
  3850	func rewriteValueS390X_OpLsh8x16_0(v *Value) bool {
  3851		b := v.Block
  3852		typ := &b.Func.Config.Types
  3853		// match: (Lsh8x16 x y)
  3854		// cond: shiftIsBounded(v)
  3855		// result: (SLW x y)
  3856		for {
  3857			y := v.Args[1]
  3858			x := v.Args[0]
  3859			if !(shiftIsBounded(v)) {
  3860				break
  3861			}
  3862			v.reset(OpS390XSLW)
  3863			v.AddArg(x)
  3864			v.AddArg(y)
  3865			return true
  3866		}
  3867		// match: (Lsh8x16 <t> x y)
  3868		// cond:
  3869		// result: (MOVDGE <t> (SLW <t> x y) (MOVDconst [0]) (CMPWUconst (MOVHZreg y) [64]))
  3870		for {
  3871			t := v.Type
  3872			y := v.Args[1]
  3873			x := v.Args[0]
  3874			v.reset(OpS390XMOVDGE)
  3875			v.Type = t
  3876			v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
  3877			v0.AddArg(x)
  3878			v0.AddArg(y)
  3879			v.AddArg(v0)
  3880			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3881			v1.AuxInt = 0
  3882			v.AddArg(v1)
  3883			v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  3884			v2.AuxInt = 64
  3885			v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  3886			v3.AddArg(y)
  3887			v2.AddArg(v3)
  3888			v.AddArg(v2)
  3889			return true
  3890		}
  3891	}
  3892	func rewriteValueS390X_OpLsh8x32_0(v *Value) bool {
  3893		b := v.Block
  3894		typ := &b.Func.Config.Types
  3895		// match: (Lsh8x32 x y)
  3896		// cond: shiftIsBounded(v)
  3897		// result: (SLW x y)
  3898		for {
  3899			y := v.Args[1]
  3900			x := v.Args[0]
  3901			if !(shiftIsBounded(v)) {
  3902				break
  3903			}
  3904			v.reset(OpS390XSLW)
  3905			v.AddArg(x)
  3906			v.AddArg(y)
  3907			return true
  3908		}
  3909		// match: (Lsh8x32 <t> x y)
  3910		// cond:
  3911		// result: (MOVDGE <t> (SLW <t> x y) (MOVDconst [0]) (CMPWUconst y [64]))
  3912		for {
  3913			t := v.Type
  3914			y := v.Args[1]
  3915			x := v.Args[0]
  3916			v.reset(OpS390XMOVDGE)
  3917			v.Type = t
  3918			v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
  3919			v0.AddArg(x)
  3920			v0.AddArg(y)
  3921			v.AddArg(v0)
  3922			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3923			v1.AuxInt = 0
  3924			v.AddArg(v1)
  3925			v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  3926			v2.AuxInt = 64
  3927			v2.AddArg(y)
  3928			v.AddArg(v2)
  3929			return true
  3930		}
  3931	}
  3932	func rewriteValueS390X_OpLsh8x64_0(v *Value) bool {
  3933		b := v.Block
  3934		typ := &b.Func.Config.Types
  3935		// match: (Lsh8x64 x y)
  3936		// cond: shiftIsBounded(v)
  3937		// result: (SLW x y)
  3938		for {
  3939			y := v.Args[1]
  3940			x := v.Args[0]
  3941			if !(shiftIsBounded(v)) {
  3942				break
  3943			}
  3944			v.reset(OpS390XSLW)
  3945			v.AddArg(x)
  3946			v.AddArg(y)
  3947			return true
  3948		}
  3949		// match: (Lsh8x64 <t> x y)
  3950		// cond:
  3951		// result: (MOVDGE <t> (SLW <t> x y) (MOVDconst [0]) (CMPUconst y [64]))
  3952		for {
  3953			t := v.Type
  3954			y := v.Args[1]
  3955			x := v.Args[0]
  3956			v.reset(OpS390XMOVDGE)
  3957			v.Type = t
  3958			v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
  3959			v0.AddArg(x)
  3960			v0.AddArg(y)
  3961			v.AddArg(v0)
  3962			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3963			v1.AuxInt = 0
  3964			v.AddArg(v1)
  3965			v2 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
  3966			v2.AuxInt = 64
  3967			v2.AddArg(y)
  3968			v.AddArg(v2)
  3969			return true
  3970		}
  3971	}
  3972	func rewriteValueS390X_OpLsh8x8_0(v *Value) bool {
  3973		b := v.Block
  3974		typ := &b.Func.Config.Types
  3975		// match: (Lsh8x8 x y)
  3976		// cond: shiftIsBounded(v)
  3977		// result: (SLW x y)
  3978		for {
  3979			y := v.Args[1]
  3980			x := v.Args[0]
  3981			if !(shiftIsBounded(v)) {
  3982				break
  3983			}
  3984			v.reset(OpS390XSLW)
  3985			v.AddArg(x)
  3986			v.AddArg(y)
  3987			return true
  3988		}
  3989		// match: (Lsh8x8 <t> x y)
  3990		// cond:
  3991		// result: (MOVDGE <t> (SLW <t> x y) (MOVDconst [0]) (CMPWUconst (MOVBZreg y) [64]))
  3992		for {
  3993			t := v.Type
  3994			y := v.Args[1]
  3995			x := v.Args[0]
  3996			v.reset(OpS390XMOVDGE)
  3997			v.Type = t
  3998			v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
  3999			v0.AddArg(x)
  4000			v0.AddArg(y)
  4001			v.AddArg(v0)
  4002			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  4003			v1.AuxInt = 0
  4004			v.AddArg(v1)
  4005			v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  4006			v2.AuxInt = 64
  4007			v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  4008			v3.AddArg(y)
  4009			v2.AddArg(v3)
  4010			v.AddArg(v2)
  4011			return true
  4012		}
  4013	}
  4014	func rewriteValueS390X_OpMod16_0(v *Value) bool {
  4015		b := v.Block
  4016		typ := &b.Func.Config.Types
  4017		// match: (Mod16 x y)
  4018		// cond:
  4019		// result: (MODW (MOVHreg x) (MOVHreg y))
  4020		for {
  4021			y := v.Args[1]
  4022			x := v.Args[0]
  4023			v.reset(OpS390XMODW)
  4024			v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  4025			v0.AddArg(x)
  4026			v.AddArg(v0)
  4027			v1 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  4028			v1.AddArg(y)
  4029			v.AddArg(v1)
  4030			return true
  4031		}
  4032	}
  4033	func rewriteValueS390X_OpMod16u_0(v *Value) bool {
  4034		b := v.Block
  4035		typ := &b.Func.Config.Types
  4036		// match: (Mod16u x y)
  4037		// cond:
  4038		// result: (MODWU (MOVHZreg x) (MOVHZreg y))
  4039		for {
  4040			y := v.Args[1]
  4041			x := v.Args[0]
  4042			v.reset(OpS390XMODWU)
  4043			v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  4044			v0.AddArg(x)
  4045			v.AddArg(v0)
  4046			v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  4047			v1.AddArg(y)
  4048			v.AddArg(v1)
  4049			return true
  4050		}
  4051	}
  4052	func rewriteValueS390X_OpMod32_0(v *Value) bool {
  4053		b := v.Block
  4054		typ := &b.Func.Config.Types
  4055		// match: (Mod32 x y)
  4056		// cond:
  4057		// result: (MODW (MOVWreg x) y)
  4058		for {
  4059			y := v.Args[1]
  4060			x := v.Args[0]
  4061			v.reset(OpS390XMODW)
  4062			v0 := b.NewValue0(v.Pos, OpS390XMOVWreg, typ.Int64)
  4063			v0.AddArg(x)
  4064			v.AddArg(v0)
  4065			v.AddArg(y)
  4066			return true
  4067		}
  4068	}
  4069	func rewriteValueS390X_OpMod32u_0(v *Value) bool {
  4070		b := v.Block
  4071		typ := &b.Func.Config.Types
  4072		// match: (Mod32u x y)
  4073		// cond:
  4074		// result: (MODWU (MOVWZreg x) y)
  4075		for {
  4076			y := v.Args[1]
  4077			x := v.Args[0]
  4078			v.reset(OpS390XMODWU)
  4079			v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
  4080			v0.AddArg(x)
  4081			v.AddArg(v0)
  4082			v.AddArg(y)
  4083			return true
  4084		}
  4085	}
  4086	func rewriteValueS390X_OpMod64_0(v *Value) bool {
  4087		// match: (Mod64 x y)
  4088		// cond:
  4089		// result: (MODD x y)
  4090		for {
  4091			y := v.Args[1]
  4092			x := v.Args[0]
  4093			v.reset(OpS390XMODD)
  4094			v.AddArg(x)
  4095			v.AddArg(y)
  4096			return true
  4097		}
  4098	}
  4099	func rewriteValueS390X_OpMod64u_0(v *Value) bool {
  4100		// match: (Mod64u x y)
  4101		// cond:
  4102		// result: (MODDU x y)
  4103		for {
  4104			y := v.Args[1]
  4105			x := v.Args[0]
  4106			v.reset(OpS390XMODDU)
  4107			v.AddArg(x)
  4108			v.AddArg(y)
  4109			return true
  4110		}
  4111	}
  4112	func rewriteValueS390X_OpMod8_0(v *Value) bool {
  4113		b := v.Block
  4114		typ := &b.Func.Config.Types
  4115		// match: (Mod8 x y)
  4116		// cond:
  4117		// result: (MODW (MOVBreg x) (MOVBreg y))
  4118		for {
  4119			y := v.Args[1]
  4120			x := v.Args[0]
  4121			v.reset(OpS390XMODW)
  4122			v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  4123			v0.AddArg(x)
  4124			v.AddArg(v0)
  4125			v1 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  4126			v1.AddArg(y)
  4127			v.AddArg(v1)
  4128			return true
  4129		}
  4130	}
  4131	func rewriteValueS390X_OpMod8u_0(v *Value) bool {
  4132		b := v.Block
  4133		typ := &b.Func.Config.Types
  4134		// match: (Mod8u x y)
  4135		// cond:
  4136		// result: (MODWU (MOVBZreg x) (MOVBZreg y))
  4137		for {
  4138			y := v.Args[1]
  4139			x := v.Args[0]
  4140			v.reset(OpS390XMODWU)
  4141			v0 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  4142			v0.AddArg(x)
  4143			v.AddArg(v0)
  4144			v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  4145			v1.AddArg(y)
  4146			v.AddArg(v1)
  4147			return true
  4148		}
  4149	}
  4150	func rewriteValueS390X_OpMove_0(v *Value) bool {
  4151		b := v.Block
  4152		typ := &b.Func.Config.Types
  4153		// match: (Move [0] _ _ mem)
  4154		// cond:
  4155		// result: mem
  4156		for {
  4157			if v.AuxInt != 0 {
  4158				break
  4159			}
  4160			mem := v.Args[2]
  4161			v.reset(OpCopy)
  4162			v.Type = mem.Type
  4163			v.AddArg(mem)
  4164			return true
  4165		}
  4166		// match: (Move [1] dst src mem)
  4167		// cond:
  4168		// result: (MOVBstore dst (MOVBZload src mem) mem)
  4169		for {
  4170			if v.AuxInt != 1 {
  4171				break
  4172			}
  4173			mem := v.Args[2]
  4174			dst := v.Args[0]
  4175			src := v.Args[1]
  4176			v.reset(OpS390XMOVBstore)
  4177			v.AddArg(dst)
  4178			v0 := b.NewValue0(v.Pos, OpS390XMOVBZload, typ.UInt8)
  4179			v0.AddArg(src)
  4180			v0.AddArg(mem)
  4181			v.AddArg(v0)
  4182			v.AddArg(mem)
  4183			return true
  4184		}
  4185		// match: (Move [2] dst src mem)
  4186		// cond:
  4187		// result: (MOVHstore dst (MOVHZload src mem) mem)
  4188		for {
  4189			if v.AuxInt != 2 {
  4190				break
  4191			}
  4192			mem := v.Args[2]
  4193			dst := v.Args[0]
  4194			src := v.Args[1]
  4195			v.reset(OpS390XMOVHstore)
  4196			v.AddArg(dst)
  4197			v0 := b.NewValue0(v.Pos, OpS390XMOVHZload, typ.UInt16)
  4198			v0.AddArg(src)
  4199			v0.AddArg(mem)
  4200			v.AddArg(v0)
  4201			v.AddArg(mem)
  4202			return true
  4203		}
  4204		// match: (Move [4] dst src mem)
  4205		// cond:
  4206		// result: (MOVWstore dst (MOVWZload src mem) mem)
  4207		for {
  4208			if v.AuxInt != 4 {
  4209				break
  4210			}
  4211			mem := v.Args[2]
  4212			dst := v.Args[0]
  4213			src := v.Args[1]
  4214			v.reset(OpS390XMOVWstore)
  4215			v.AddArg(dst)
  4216			v0 := b.NewValue0(v.Pos, OpS390XMOVWZload, typ.UInt32)
  4217			v0.AddArg(src)
  4218			v0.AddArg(mem)
  4219			v.AddArg(v0)
  4220			v.AddArg(mem)
  4221			return true
  4222		}
  4223		// match: (Move [8] dst src mem)
  4224		// cond:
  4225		// result: (MOVDstore dst (MOVDload src mem) mem)
  4226		for {
  4227			if v.AuxInt != 8 {
  4228				break
  4229			}
  4230			mem := v.Args[2]
  4231			dst := v.Args[0]
  4232			src := v.Args[1]
  4233			v.reset(OpS390XMOVDstore)
  4234			v.AddArg(dst)
  4235			v0 := b.NewValue0(v.Pos, OpS390XMOVDload, typ.UInt64)
  4236			v0.AddArg(src)
  4237			v0.AddArg(mem)
  4238			v.AddArg(v0)
  4239			v.AddArg(mem)
  4240			return true
  4241		}
  4242		// match: (Move [16] dst src mem)
  4243		// cond:
  4244		// result: (MOVDstore [8] dst (MOVDload [8] src mem) (MOVDstore dst (MOVDload src mem) mem))
  4245		for {
  4246			if v.AuxInt != 16 {
  4247				break
  4248			}
  4249			mem := v.Args[2]
  4250			dst := v.Args[0]
  4251			src := v.Args[1]
  4252			v.reset(OpS390XMOVDstore)
  4253			v.AuxInt = 8
  4254			v.AddArg(dst)
  4255			v0 := b.NewValue0(v.Pos, OpS390XMOVDload, typ.UInt64)
  4256			v0.AuxInt = 8
  4257			v0.AddArg(src)
  4258			v0.AddArg(mem)
  4259			v.AddArg(v0)
  4260			v1 := b.NewValue0(v.Pos, OpS390XMOVDstore, types.TypeMem)
  4261			v1.AddArg(dst)
  4262			v2 := b.NewValue0(v.Pos, OpS390XMOVDload, typ.UInt64)
  4263			v2.AddArg(src)
  4264			v2.AddArg(mem)
  4265			v1.AddArg(v2)
  4266			v1.AddArg(mem)
  4267			v.AddArg(v1)
  4268			return true
  4269		}
  4270		// match: (Move [24] dst src mem)
  4271		// cond:
  4272		// result: (MOVDstore [16] dst (MOVDload [16] src mem) (MOVDstore [8] dst (MOVDload [8] src mem) (MOVDstore dst (MOVDload src mem) mem)))
  4273		for {
  4274			if v.AuxInt != 24 {
  4275				break
  4276			}
  4277			mem := v.Args[2]
  4278			dst := v.Args[0]
  4279			src := v.Args[1]
  4280			v.reset(OpS390XMOVDstore)
  4281			v.AuxInt = 16
  4282			v.AddArg(dst)
  4283			v0 := b.NewValue0(v.Pos, OpS390XMOVDload, typ.UInt64)
  4284			v0.AuxInt = 16
  4285			v0.AddArg(src)
  4286			v0.AddArg(mem)
  4287			v.AddArg(v0)
  4288			v1 := b.NewValue0(v.Pos, OpS390XMOVDstore, types.TypeMem)
  4289			v1.AuxInt = 8
  4290			v1.AddArg(dst)
  4291			v2 := b.NewValue0(v.Pos, OpS390XMOVDload, typ.UInt64)
  4292			v2.AuxInt = 8
  4293			v2.AddArg(src)
  4294			v2.AddArg(mem)
  4295			v1.AddArg(v2)
  4296			v3 := b.NewValue0(v.Pos, OpS390XMOVDstore, types.TypeMem)
  4297			v3.AddArg(dst)
  4298			v4 := b.NewValue0(v.Pos, OpS390XMOVDload, typ.UInt64)
  4299			v4.AddArg(src)
  4300			v4.AddArg(mem)
  4301			v3.AddArg(v4)
  4302			v3.AddArg(mem)
  4303			v1.AddArg(v3)
  4304			v.AddArg(v1)
  4305			return true
  4306		}
  4307		// match: (Move [3] dst src mem)
  4308		// cond:
  4309		// result: (MOVBstore [2] dst (MOVBZload [2] src mem) (MOVHstore dst (MOVHZload src mem) mem))
  4310		for {
  4311			if v.AuxInt != 3 {
  4312				break
  4313			}
  4314			mem := v.Args[2]
  4315			dst := v.Args[0]
  4316			src := v.Args[1]
  4317			v.reset(OpS390XMOVBstore)
  4318			v.AuxInt = 2
  4319			v.AddArg(dst)
  4320			v0 := b.NewValue0(v.Pos, OpS390XMOVBZload, typ.UInt8)
  4321			v0.AuxInt = 2
  4322			v0.AddArg(src)
  4323			v0.AddArg(mem)
  4324			v.AddArg(v0)
  4325			v1 := b.NewValue0(v.Pos, OpS390XMOVHstore, types.TypeMem)
  4326			v1.AddArg(dst)
  4327			v2 := b.NewValue0(v.Pos, OpS390XMOVHZload, typ.UInt16)
  4328			v2.AddArg(src)
  4329			v2.AddArg(mem)
  4330			v1.AddArg(v2)
  4331			v1.AddArg(mem)
  4332			v.AddArg(v1)
  4333			return true
  4334		}
  4335		// match: (Move [5] dst src mem)
  4336		// cond:
  4337		// result: (MOVBstore [4] dst (MOVBZload [4] src mem) (MOVWstore dst (MOVWZload src mem) mem))
  4338		for {
  4339			if v.AuxInt != 5 {
  4340				break
  4341			}
  4342			mem := v.Args[2]
  4343			dst := v.Args[0]
  4344			src := v.Args[1]
  4345			v.reset(OpS390XMOVBstore)
  4346			v.AuxInt = 4
  4347			v.AddArg(dst)
  4348			v0 := b.NewValue0(v.Pos, OpS390XMOVBZload, typ.UInt8)
  4349			v0.AuxInt = 4
  4350			v0.AddArg(src)
  4351			v0.AddArg(mem)
  4352			v.AddArg(v0)
  4353			v1 := b.NewValue0(v.Pos, OpS390XMOVWstore, types.TypeMem)
  4354			v1.AddArg(dst)
  4355			v2 := b.NewValue0(v.Pos, OpS390XMOVWZload, typ.UInt32)
  4356			v2.AddArg(src)
  4357			v2.AddArg(mem)
  4358			v1.AddArg(v2)
  4359			v1.AddArg(mem)
  4360			v.AddArg(v1)
  4361			return true
  4362		}
  4363		// match: (Move [6] dst src mem)
  4364		// cond:
  4365		// result: (MOVHstore [4] dst (MOVHZload [4] src mem) (MOVWstore dst (MOVWZload src mem) mem))
  4366		for {
  4367			if v.AuxInt != 6 {
  4368				break
  4369			}
  4370			mem := v.Args[2]
  4371			dst := v.Args[0]
  4372			src := v.Args[1]
  4373			v.reset(OpS390XMOVHstore)
  4374			v.AuxInt = 4
  4375			v.AddArg(dst)
  4376			v0 := b.NewValue0(v.Pos, OpS390XMOVHZload, typ.UInt16)
  4377			v0.AuxInt = 4
  4378			v0.AddArg(src)
  4379			v0.AddArg(mem)
  4380			v.AddArg(v0)
  4381			v1 := b.NewValue0(v.Pos, OpS390XMOVWstore, types.TypeMem)
  4382			v1.AddArg(dst)
  4383			v2 := b.NewValue0(v.Pos, OpS390XMOVWZload, typ.UInt32)
  4384			v2.AddArg(src)
  4385			v2.AddArg(mem)
  4386			v1.AddArg(v2)
  4387			v1.AddArg(mem)
  4388			v.AddArg(v1)
  4389			return true
  4390		}
  4391		return false
  4392	}
  4393	func rewriteValueS390X_OpMove_10(v *Value) bool {
  4394		b := v.Block
  4395		typ := &b.Func.Config.Types
  4396		// match: (Move [7] dst src mem)
  4397		// cond:
  4398		// result: (MOVBstore [6] dst (MOVBZload [6] src mem) (MOVHstore [4] dst (MOVHZload [4] src mem) (MOVWstore dst (MOVWZload src mem) mem)))
  4399		for {
  4400			if v.AuxInt != 7 {
  4401				break
  4402			}
  4403			mem := v.Args[2]
  4404			dst := v.Args[0]
  4405			src := v.Args[1]
  4406			v.reset(OpS390XMOVBstore)
  4407			v.AuxInt = 6
  4408			v.AddArg(dst)
  4409			v0 := b.NewValue0(v.Pos, OpS390XMOVBZload, typ.UInt8)
  4410			v0.AuxInt = 6
  4411			v0.AddArg(src)
  4412			v0.AddArg(mem)
  4413			v.AddArg(v0)
  4414			v1 := b.NewValue0(v.Pos, OpS390XMOVHstore, types.TypeMem)
  4415			v1.AuxInt = 4
  4416			v1.AddArg(dst)
  4417			v2 := b.NewValue0(v.Pos, OpS390XMOVHZload, typ.UInt16)
  4418			v2.AuxInt = 4
  4419			v2.AddArg(src)
  4420			v2.AddArg(mem)
  4421			v1.AddArg(v2)
  4422			v3 := b.NewValue0(v.Pos, OpS390XMOVWstore, types.TypeMem)
  4423			v3.AddArg(dst)
  4424			v4 := b.NewValue0(v.Pos, OpS390XMOVWZload, typ.UInt32)
  4425			v4.AddArg(src)
  4426			v4.AddArg(mem)
  4427			v3.AddArg(v4)
  4428			v3.AddArg(mem)
  4429			v1.AddArg(v3)
  4430			v.AddArg(v1)
  4431			return true
  4432		}
  4433		// match: (Move [s] dst src mem)
  4434		// cond: s > 0 && s <= 256
  4435		// result: (MVC [makeValAndOff(s, 0)] dst src mem)
  4436		for {
  4437			s := v.AuxInt
  4438			mem := v.Args[2]
  4439			dst := v.Args[0]
  4440			src := v.Args[1]
  4441			if !(s > 0 && s <= 256) {
  4442				break
  4443			}
  4444			v.reset(OpS390XMVC)
  4445			v.AuxInt = makeValAndOff(s, 0)
  4446			v.AddArg(dst)
  4447			v.AddArg(src)
  4448			v.AddArg(mem)
  4449			return true
  4450		}
  4451		// match: (Move [s] dst src mem)
  4452		// cond: s > 256 && s <= 512
  4453		// result: (MVC [makeValAndOff(s-256, 256)] dst src (MVC [makeValAndOff(256, 0)] dst src mem))
  4454		for {
  4455			s := v.AuxInt
  4456			mem := v.Args[2]
  4457			dst := v.Args[0]
  4458			src := v.Args[1]
  4459			if !(s > 256 && s <= 512) {
  4460				break
  4461			}
  4462			v.reset(OpS390XMVC)
  4463			v.AuxInt = makeValAndOff(s-256, 256)
  4464			v.AddArg(dst)
  4465			v.AddArg(src)
  4466			v0 := b.NewValue0(v.Pos, OpS390XMVC, types.TypeMem)
  4467			v0.AuxInt = makeValAndOff(256, 0)
  4468			v0.AddArg(dst)
  4469			v0.AddArg(src)
  4470			v0.AddArg(mem)
  4471			v.AddArg(v0)
  4472			return true
  4473		}
  4474		// match: (Move [s] dst src mem)
  4475		// cond: s > 512 && s <= 768
  4476		// result: (MVC [makeValAndOff(s-512, 512)] dst src (MVC [makeValAndOff(256, 256)] dst src (MVC [makeValAndOff(256, 0)] dst src mem)))
  4477		for {
  4478			s := v.AuxInt
  4479			mem := v.Args[2]
  4480			dst := v.Args[0]
  4481			src := v.Args[1]
  4482			if !(s > 512 && s <= 768) {
  4483				break
  4484			}
  4485			v.reset(OpS390XMVC)
  4486			v.AuxInt = makeValAndOff(s-512, 512)
  4487			v.AddArg(dst)
  4488			v.AddArg(src)
  4489			v0 := b.NewValue0(v.Pos, OpS390XMVC, types.TypeMem)
  4490			v0.AuxInt = makeValAndOff(256, 256)
  4491			v0.AddArg(dst)
  4492			v0.AddArg(src)
  4493			v1 := b.NewValue0(v.Pos, OpS390XMVC, types.TypeMem)
  4494			v1.AuxInt = makeValAndOff(256, 0)
  4495			v1.AddArg(dst)
  4496			v1.AddArg(src)
  4497			v1.AddArg(mem)
  4498			v0.AddArg(v1)
  4499			v.AddArg(v0)
  4500			return true
  4501		}
  4502		// match: (Move [s] dst src mem)
  4503		// cond: s > 768 && s <= 1024
  4504		// result: (MVC [makeValAndOff(s-768, 768)] dst src (MVC [makeValAndOff(256, 512)] dst src (MVC [makeValAndOff(256, 256)] dst src (MVC [makeValAndOff(256, 0)] dst src mem))))
  4505		for {
  4506			s := v.AuxInt
  4507			mem := v.Args[2]
  4508			dst := v.Args[0]
  4509			src := v.Args[1]
  4510			if !(s > 768 && s <= 1024) {
  4511				break
  4512			}
  4513			v.reset(OpS390XMVC)
  4514			v.AuxInt = makeValAndOff(s-768, 768)
  4515			v.AddArg(dst)
  4516			v.AddArg(src)
  4517			v0 := b.NewValue0(v.Pos, OpS390XMVC, types.TypeMem)
  4518			v0.AuxInt = makeValAndOff(256, 512)
  4519			v0.AddArg(dst)
  4520			v0.AddArg(src)
  4521			v1 := b.NewValue0(v.Pos, OpS390XMVC, types.TypeMem)
  4522			v1.AuxInt = makeValAndOff(256, 256)
  4523			v1.AddArg(dst)
  4524			v1.AddArg(src)
  4525			v2 := b.NewValue0(v.Pos, OpS390XMVC, types.TypeMem)
  4526			v2.AuxInt = makeValAndOff(256, 0)
  4527			v2.AddArg(dst)
  4528			v2.AddArg(src)
  4529			v2.AddArg(mem)
  4530			v1.AddArg(v2)
  4531			v0.AddArg(v1)
  4532			v.AddArg(v0)
  4533			return true
  4534		}
  4535		// match: (Move [s] dst src mem)
  4536		// cond: s > 1024
  4537		// result: (LoweredMove [s%256] dst src (ADD <src.Type> src (MOVDconst [(s/256)*256])) mem)
  4538		for {
  4539			s := v.AuxInt
  4540			mem := v.Args[2]
  4541			dst := v.Args[0]
  4542			src := v.Args[1]
  4543			if !(s > 1024) {
  4544				break
  4545			}
  4546			v.reset(OpS390XLoweredMove)
  4547			v.AuxInt = s % 256
  4548			v.AddArg(dst)
  4549			v.AddArg(src)
  4550			v0 := b.NewValue0(v.Pos, OpS390XADD, src.Type)
  4551			v0.AddArg(src)
  4552			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  4553			v1.AuxInt = (s / 256) * 256
  4554			v0.AddArg(v1)
  4555			v.AddArg(v0)
  4556			v.AddArg(mem)
  4557			return true
  4558		}
  4559		return false
  4560	}
  4561	func rewriteValueS390X_OpMul16_0(v *Value) bool {
  4562		// match: (Mul16 x y)
  4563		// cond:
  4564		// result: (MULLW x y)
  4565		for {
  4566			y := v.Args[1]
  4567			x := v.Args[0]
  4568			v.reset(OpS390XMULLW)
  4569			v.AddArg(x)
  4570			v.AddArg(y)
  4571			return true
  4572		}
  4573	}
  4574	func rewriteValueS390X_OpMul32_0(v *Value) bool {
  4575		// match: (Mul32 x y)
  4576		// cond:
  4577		// result: (MULLW x y)
  4578		for {
  4579			y := v.Args[1]
  4580			x := v.Args[0]
  4581			v.reset(OpS390XMULLW)
  4582			v.AddArg(x)
  4583			v.AddArg(y)
  4584			return true
  4585		}
  4586	}
  4587	func rewriteValueS390X_OpMul32F_0(v *Value) bool {
  4588		// match: (Mul32F x y)
  4589		// cond:
  4590		// result: (FMULS x y)
  4591		for {
  4592			y := v.Args[1]
  4593			x := v.Args[0]
  4594			v.reset(OpS390XFMULS)
  4595			v.AddArg(x)
  4596			v.AddArg(y)
  4597			return true
  4598		}
  4599	}
  4600	func rewriteValueS390X_OpMul64_0(v *Value) bool {
  4601		// match: (Mul64 x y)
  4602		// cond:
  4603		// result: (MULLD x y)
  4604		for {
  4605			y := v.Args[1]
  4606			x := v.Args[0]
  4607			v.reset(OpS390XMULLD)
  4608			v.AddArg(x)
  4609			v.AddArg(y)
  4610			return true
  4611		}
  4612	}
  4613	func rewriteValueS390X_OpMul64F_0(v *Value) bool {
  4614		// match: (Mul64F x y)
  4615		// cond:
  4616		// result: (FMUL x y)
  4617		for {
  4618			y := v.Args[1]
  4619			x := v.Args[0]
  4620			v.reset(OpS390XFMUL)
  4621			v.AddArg(x)
  4622			v.AddArg(y)
  4623			return true
  4624		}
  4625	}
  4626	func rewriteValueS390X_OpMul8_0(v *Value) bool {
  4627		// match: (Mul8 x y)
  4628		// cond:
  4629		// result: (MULLW x y)
  4630		for {
  4631			y := v.Args[1]
  4632			x := v.Args[0]
  4633			v.reset(OpS390XMULLW)
  4634			v.AddArg(x)
  4635			v.AddArg(y)
  4636			return true
  4637		}
  4638	}
  4639	func rewriteValueS390X_OpNeg16_0(v *Value) bool {
  4640		// match: (Neg16 x)
  4641		// cond:
  4642		// result: (NEGW x)
  4643		for {
  4644			x := v.Args[0]
  4645			v.reset(OpS390XNEGW)
  4646			v.AddArg(x)
  4647			return true
  4648		}
  4649	}
  4650	func rewriteValueS390X_OpNeg32_0(v *Value) bool {
  4651		// match: (Neg32 x)
  4652		// cond:
  4653		// result: (NEGW x)
  4654		for {
  4655			x := v.Args[0]
  4656			v.reset(OpS390XNEGW)
  4657			v.AddArg(x)
  4658			return true
  4659		}
  4660	}
  4661	func rewriteValueS390X_OpNeg32F_0(v *Value) bool {
  4662		// match: (Neg32F x)
  4663		// cond:
  4664		// result: (FNEGS x)
  4665		for {
  4666			x := v.Args[0]
  4667			v.reset(OpS390XFNEGS)
  4668			v.AddArg(x)
  4669			return true
  4670		}
  4671	}
  4672	func rewriteValueS390X_OpNeg64_0(v *Value) bool {
  4673		// match: (Neg64 x)
  4674		// cond:
  4675		// result: (NEG x)
  4676		for {
  4677			x := v.Args[0]
  4678			v.reset(OpS390XNEG)
  4679			v.AddArg(x)
  4680			return true
  4681		}
  4682	}
  4683	func rewriteValueS390X_OpNeg64F_0(v *Value) bool {
  4684		// match: (Neg64F x)
  4685		// cond:
  4686		// result: (FNEG x)
  4687		for {
  4688			x := v.Args[0]
  4689			v.reset(OpS390XFNEG)
  4690			v.AddArg(x)
  4691			return true
  4692		}
  4693	}
  4694	func rewriteValueS390X_OpNeg8_0(v *Value) bool {
  4695		// match: (Neg8 x)
  4696		// cond:
  4697		// result: (NEGW x)
  4698		for {
  4699			x := v.Args[0]
  4700			v.reset(OpS390XNEGW)
  4701			v.AddArg(x)
  4702			return true
  4703		}
  4704	}
  4705	func rewriteValueS390X_OpNeq16_0(v *Value) bool {
  4706		b := v.Block
  4707		typ := &b.Func.Config.Types
  4708		// match: (Neq16 x y)
  4709		// cond:
  4710		// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (CMPW (MOVHreg x) (MOVHreg y)))
  4711		for {
  4712			y := v.Args[1]
  4713			x := v.Args[0]
  4714			v.reset(OpS390XMOVDNE)
  4715			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  4716			v0.AuxInt = 0
  4717			v.AddArg(v0)
  4718			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  4719			v1.AuxInt = 1
  4720			v.AddArg(v1)
  4721			v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  4722			v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  4723			v3.AddArg(x)
  4724			v2.AddArg(v3)
  4725			v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  4726			v4.AddArg(y)
  4727			v2.AddArg(v4)
  4728			v.AddArg(v2)
  4729			return true
  4730		}
  4731	}
  4732	func rewriteValueS390X_OpNeq32_0(v *Value) bool {
  4733		b := v.Block
  4734		typ := &b.Func.Config.Types
  4735		// match: (Neq32 x y)
  4736		// cond:
  4737		// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (CMPW x y))
  4738		for {
  4739			y := v.Args[1]
  4740			x := v.Args[0]
  4741			v.reset(OpS390XMOVDNE)
  4742			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  4743			v0.AuxInt = 0
  4744			v.AddArg(v0)
  4745			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  4746			v1.AuxInt = 1
  4747			v.AddArg(v1)
  4748			v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  4749			v2.AddArg(x)
  4750			v2.AddArg(y)
  4751			v.AddArg(v2)
  4752			return true
  4753		}
  4754	}
  4755	func rewriteValueS390X_OpNeq32F_0(v *Value) bool {
  4756		b := v.Block
  4757		typ := &b.Func.Config.Types
  4758		// match: (Neq32F x y)
  4759		// cond:
  4760		// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (FCMPS x y))
  4761		for {
  4762			y := v.Args[1]
  4763			x := v.Args[0]
  4764			v.reset(OpS390XMOVDNE)
  4765			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  4766			v0.AuxInt = 0
  4767			v.AddArg(v0)
  4768			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  4769			v1.AuxInt = 1
  4770			v.AddArg(v1)
  4771			v2 := b.NewValue0(v.Pos, OpS390XFCMPS, types.TypeFlags)
  4772			v2.AddArg(x)
  4773			v2.AddArg(y)
  4774			v.AddArg(v2)
  4775			return true
  4776		}
  4777	}
  4778	func rewriteValueS390X_OpNeq64_0(v *Value) bool {
  4779		b := v.Block
  4780		typ := &b.Func.Config.Types
  4781		// match: (Neq64 x y)
  4782		// cond:
  4783		// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (CMP x y))
  4784		for {
  4785			y := v.Args[1]
  4786			x := v.Args[0]
  4787			v.reset(OpS390XMOVDNE)
  4788			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  4789			v0.AuxInt = 0
  4790			v.AddArg(v0)
  4791			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  4792			v1.AuxInt = 1
  4793			v.AddArg(v1)
  4794			v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
  4795			v2.AddArg(x)
  4796			v2.AddArg(y)
  4797			v.AddArg(v2)
  4798			return true
  4799		}
  4800	}
  4801	func rewriteValueS390X_OpNeq64F_0(v *Value) bool {
  4802		b := v.Block
  4803		typ := &b.Func.Config.Types
  4804		// match: (Neq64F x y)
  4805		// cond:
  4806		// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (FCMP x y))
  4807		for {
  4808			y := v.Args[1]
  4809			x := v.Args[0]
  4810			v.reset(OpS390XMOVDNE)
  4811			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  4812			v0.AuxInt = 0
  4813			v.AddArg(v0)
  4814			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  4815			v1.AuxInt = 1
  4816			v.AddArg(v1)
  4817			v2 := b.NewValue0(v.Pos, OpS390XFCMP, types.TypeFlags)
  4818			v2.AddArg(x)
  4819			v2.AddArg(y)
  4820			v.AddArg(v2)
  4821			return true
  4822		}
  4823	}
  4824	func rewriteValueS390X_OpNeq8_0(v *Value) bool {
  4825		b := v.Block
  4826		typ := &b.Func.Config.Types
  4827		// match: (Neq8 x y)
  4828		// cond:
  4829		// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (CMPW (MOVBreg x) (MOVBreg y)))
  4830		for {
  4831			y := v.Args[1]
  4832			x := v.Args[0]
  4833			v.reset(OpS390XMOVDNE)
  4834			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  4835			v0.AuxInt = 0
  4836			v.AddArg(v0)
  4837			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  4838			v1.AuxInt = 1
  4839			v.AddArg(v1)
  4840			v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  4841			v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  4842			v3.AddArg(x)
  4843			v2.AddArg(v3)
  4844			v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  4845			v4.AddArg(y)
  4846			v2.AddArg(v4)
  4847			v.AddArg(v2)
  4848			return true
  4849		}
  4850	}
  4851	func rewriteValueS390X_OpNeqB_0(v *Value) bool {
  4852		b := v.Block
  4853		typ := &b.Func.Config.Types
  4854		// match: (NeqB x y)
  4855		// cond:
  4856		// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (CMPW (MOVBreg x) (MOVBreg y)))
  4857		for {
  4858			y := v.Args[1]
  4859			x := v.Args[0]
  4860			v.reset(OpS390XMOVDNE)
  4861			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  4862			v0.AuxInt = 0
  4863			v.AddArg(v0)
  4864			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  4865			v1.AuxInt = 1
  4866			v.AddArg(v1)
  4867			v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  4868			v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  4869			v3.AddArg(x)
  4870			v2.AddArg(v3)
  4871			v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  4872			v4.AddArg(y)
  4873			v2.AddArg(v4)
  4874			v.AddArg(v2)
  4875			return true
  4876		}
  4877	}
  4878	func rewriteValueS390X_OpNeqPtr_0(v *Value) bool {
  4879		b := v.Block
  4880		typ := &b.Func.Config.Types
  4881		// match: (NeqPtr x y)
  4882		// cond:
  4883		// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (CMP x y))
  4884		for {
  4885			y := v.Args[1]
  4886			x := v.Args[0]
  4887			v.reset(OpS390XMOVDNE)
  4888			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  4889			v0.AuxInt = 0
  4890			v.AddArg(v0)
  4891			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  4892			v1.AuxInt = 1
  4893			v.AddArg(v1)
  4894			v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
  4895			v2.AddArg(x)
  4896			v2.AddArg(y)
  4897			v.AddArg(v2)
  4898			return true
  4899		}
  4900	}
  4901	func rewriteValueS390X_OpNilCheck_0(v *Value) bool {
  4902		// match: (NilCheck ptr mem)
  4903		// cond:
  4904		// result: (LoweredNilCheck ptr mem)
  4905		for {
  4906			mem := v.Args[1]
  4907			ptr := v.Args[0]
  4908			v.reset(OpS390XLoweredNilCheck)
  4909			v.AddArg(ptr)
  4910			v.AddArg(mem)
  4911			return true
  4912		}
  4913	}
  4914	func rewriteValueS390X_OpNot_0(v *Value) bool {
  4915		// match: (Not x)
  4916		// cond:
  4917		// result: (XORWconst [1] x)
  4918		for {
  4919			x := v.Args[0]
  4920			v.reset(OpS390XXORWconst)
  4921			v.AuxInt = 1
  4922			v.AddArg(x)
  4923			return true
  4924		}
  4925	}
  4926	func rewriteValueS390X_OpOffPtr_0(v *Value) bool {
  4927		b := v.Block
  4928		typ := &b.Func.Config.Types
  4929		// match: (OffPtr [off] ptr:(SP))
  4930		// cond:
  4931		// result: (MOVDaddr [off] ptr)
  4932		for {
  4933			off := v.AuxInt
  4934			ptr := v.Args[0]
  4935			if ptr.Op != OpSP {
  4936				break
  4937			}
  4938			v.reset(OpS390XMOVDaddr)
  4939			v.AuxInt = off
  4940			v.AddArg(ptr)
  4941			return true
  4942		}
  4943		// match: (OffPtr [off] ptr)
  4944		// cond: is32Bit(off)
  4945		// result: (ADDconst [off] ptr)
  4946		for {
  4947			off := v.AuxInt
  4948			ptr := v.Args[0]
  4949			if !(is32Bit(off)) {
  4950				break
  4951			}
  4952			v.reset(OpS390XADDconst)
  4953			v.AuxInt = off
  4954			v.AddArg(ptr)
  4955			return true
  4956		}
  4957		// match: (OffPtr [off] ptr)
  4958		// cond:
  4959		// result: (ADD (MOVDconst [off]) ptr)
  4960		for {
  4961			off := v.AuxInt
  4962			ptr := v.Args[0]
  4963			v.reset(OpS390XADD)
  4964			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  4965			v0.AuxInt = off
  4966			v.AddArg(v0)
  4967			v.AddArg(ptr)
  4968			return true
  4969		}
  4970	}
  4971	func rewriteValueS390X_OpOr16_0(v *Value) bool {
  4972		// match: (Or16 x y)
  4973		// cond:
  4974		// result: (ORW x y)
  4975		for {
  4976			y := v.Args[1]
  4977			x := v.Args[0]
  4978			v.reset(OpS390XORW)
  4979			v.AddArg(x)
  4980			v.AddArg(y)
  4981			return true
  4982		}
  4983	}
  4984	func rewriteValueS390X_OpOr32_0(v *Value) bool {
  4985		// match: (Or32 x y)
  4986		// cond:
  4987		// result: (ORW x y)
  4988		for {
  4989			y := v.Args[1]
  4990			x := v.Args[0]
  4991			v.reset(OpS390XORW)
  4992			v.AddArg(x)
  4993			v.AddArg(y)
  4994			return true
  4995		}
  4996	}
  4997	func rewriteValueS390X_OpOr64_0(v *Value) bool {
  4998		// match: (Or64 x y)
  4999		// cond:
  5000		// result: (OR x y)
  5001		for {
  5002			y := v.Args[1]
  5003			x := v.Args[0]
  5004			v.reset(OpS390XOR)
  5005			v.AddArg(x)
  5006			v.AddArg(y)
  5007			return true
  5008		}
  5009	}
  5010	func rewriteValueS390X_OpOr8_0(v *Value) bool {
  5011		// match: (Or8 x y)
  5012		// cond:
  5013		// result: (ORW x y)
  5014		for {
  5015			y := v.Args[1]
  5016			x := v.Args[0]
  5017			v.reset(OpS390XORW)
  5018			v.AddArg(x)
  5019			v.AddArg(y)
  5020			return true
  5021		}
  5022	}
  5023	func rewriteValueS390X_OpOrB_0(v *Value) bool {
  5024		// match: (OrB x y)
  5025		// cond:
  5026		// result: (ORW x y)
  5027		for {
  5028			y := v.Args[1]
  5029			x := v.Args[0]
  5030			v.reset(OpS390XORW)
  5031			v.AddArg(x)
  5032			v.AddArg(y)
  5033			return true
  5034		}
  5035	}
  5036	func rewriteValueS390X_OpPanicBounds_0(v *Value) bool {
  5037		// match: (PanicBounds [kind] x y mem)
  5038		// cond: boundsABI(kind) == 0
  5039		// result: (LoweredPanicBoundsA [kind] x y mem)
  5040		for {
  5041			kind := v.AuxInt
  5042			mem := v.Args[2]
  5043			x := v.Args[0]
  5044			y := v.Args[1]
  5045			if !(boundsABI(kind) == 0) {
  5046				break
  5047			}
  5048			v.reset(OpS390XLoweredPanicBoundsA)
  5049			v.AuxInt = kind
  5050			v.AddArg(x)
  5051			v.AddArg(y)
  5052			v.AddArg(mem)
  5053			return true
  5054		}
  5055		// match: (PanicBounds [kind] x y mem)
  5056		// cond: boundsABI(kind) == 1
  5057		// result: (LoweredPanicBoundsB [kind] x y mem)
  5058		for {
  5059			kind := v.AuxInt
  5060			mem := v.Args[2]
  5061			x := v.Args[0]
  5062			y := v.Args[1]
  5063			if !(boundsABI(kind) == 1) {
  5064				break
  5065			}
  5066			v.reset(OpS390XLoweredPanicBoundsB)
  5067			v.AuxInt = kind
  5068			v.AddArg(x)
  5069			v.AddArg(y)
  5070			v.AddArg(mem)
  5071			return true
  5072		}
  5073		// match: (PanicBounds [kind] x y mem)
  5074		// cond: boundsABI(kind) == 2
  5075		// result: (LoweredPanicBoundsC [kind] x y mem)
  5076		for {
  5077			kind := v.AuxInt
  5078			mem := v.Args[2]
  5079			x := v.Args[0]
  5080			y := v.Args[1]
  5081			if !(boundsABI(kind) == 2) {
  5082				break
  5083			}
  5084			v.reset(OpS390XLoweredPanicBoundsC)
  5085			v.AuxInt = kind
  5086			v.AddArg(x)
  5087			v.AddArg(y)
  5088			v.AddArg(mem)
  5089			return true
  5090		}
  5091		return false
  5092	}
  5093	func rewriteValueS390X_OpPopCount16_0(v *Value) bool {
  5094		b := v.Block
  5095		typ := &b.Func.Config.Types
  5096		// match: (PopCount16 x)
  5097		// cond:
  5098		// result: (MOVBZreg (SumBytes2 (POPCNT <typ.UInt16> x)))
  5099		for {
  5100			x := v.Args[0]
  5101			v.reset(OpS390XMOVBZreg)
  5102			v0 := b.NewValue0(v.Pos, OpS390XSumBytes2, typ.UInt8)
  5103			v1 := b.NewValue0(v.Pos, OpS390XPOPCNT, typ.UInt16)
  5104			v1.AddArg(x)
  5105			v0.AddArg(v1)
  5106			v.AddArg(v0)
  5107			return true
  5108		}
  5109	}
  5110	func rewriteValueS390X_OpPopCount32_0(v *Value) bool {
  5111		b := v.Block
  5112		typ := &b.Func.Config.Types
  5113		// match: (PopCount32 x)
  5114		// cond:
  5115		// result: (MOVBZreg (SumBytes4 (POPCNT <typ.UInt32> x)))
  5116		for {
  5117			x := v.Args[0]
  5118			v.reset(OpS390XMOVBZreg)
  5119			v0 := b.NewValue0(v.Pos, OpS390XSumBytes4, typ.UInt8)
  5120			v1 := b.NewValue0(v.Pos, OpS390XPOPCNT, typ.UInt32)
  5121			v1.AddArg(x)
  5122			v0.AddArg(v1)
  5123			v.AddArg(v0)
  5124			return true
  5125		}
  5126	}
  5127	func rewriteValueS390X_OpPopCount64_0(v *Value) bool {
  5128		b := v.Block
  5129		typ := &b.Func.Config.Types
  5130		// match: (PopCount64 x)
  5131		// cond:
  5132		// result: (MOVBZreg (SumBytes8 (POPCNT <typ.UInt64> x)))
  5133		for {
  5134			x := v.Args[0]
  5135			v.reset(OpS390XMOVBZreg)
  5136			v0 := b.NewValue0(v.Pos, OpS390XSumBytes8, typ.UInt8)
  5137			v1 := b.NewValue0(v.Pos, OpS390XPOPCNT, typ.UInt64)
  5138			v1.AddArg(x)
  5139			v0.AddArg(v1)
  5140			v.AddArg(v0)
  5141			return true
  5142		}
  5143	}
  5144	func rewriteValueS390X_OpPopCount8_0(v *Value) bool {
  5145		b := v.Block
  5146		typ := &b.Func.Config.Types
  5147		// match: (PopCount8 x)
  5148		// cond:
  5149		// result: (POPCNT (MOVBZreg x))
  5150		for {
  5151			x := v.Args[0]
  5152			v.reset(OpS390XPOPCNT)
  5153			v0 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  5154			v0.AddArg(x)
  5155			v.AddArg(v0)
  5156			return true
  5157		}
  5158	}
  5159	func rewriteValueS390X_OpRotateLeft16_0(v *Value) bool {
  5160		b := v.Block
  5161		typ := &b.Func.Config.Types
  5162		// match: (RotateLeft16 <t> x (MOVDconst [c]))
  5163		// cond:
  5164		// result: (Or16 (Lsh16x64 <t> x (MOVDconst [c&15])) (Rsh16Ux64 <t> x (MOVDconst [-c&15])))
  5165		for {
  5166			t := v.Type
  5167			_ = v.Args[1]
  5168			x := v.Args[0]
  5169			v_1 := v.Args[1]
  5170			if v_1.Op != OpS390XMOVDconst {
  5171				break
  5172			}
  5173			c := v_1.AuxInt
  5174			v.reset(OpOr16)
  5175			v0 := b.NewValue0(v.Pos, OpLsh16x64, t)
  5176			v0.AddArg(x)
  5177			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  5178			v1.AuxInt = c & 15
  5179			v0.AddArg(v1)
  5180			v.AddArg(v0)
  5181			v2 := b.NewValue0(v.Pos, OpRsh16Ux64, t)
  5182			v2.AddArg(x)
  5183			v3 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  5184			v3.AuxInt = -c & 15
  5185			v2.AddArg(v3)
  5186			v.AddArg(v2)
  5187			return true
  5188		}
  5189		return false
  5190	}
  5191	func rewriteValueS390X_OpRotateLeft32_0(v *Value) bool {
  5192		// match: (RotateLeft32 x y)
  5193		// cond:
  5194		// result: (RLL x y)
  5195		for {
  5196			y := v.Args[1]
  5197			x := v.Args[0]
  5198			v.reset(OpS390XRLL)
  5199			v.AddArg(x)
  5200			v.AddArg(y)
  5201			return true
  5202		}
  5203	}
  5204	func rewriteValueS390X_OpRotateLeft64_0(v *Value) bool {
  5205		// match: (RotateLeft64 x y)
  5206		// cond:
  5207		// result: (RLLG x y)
  5208		for {
  5209			y := v.Args[1]
  5210			x := v.Args[0]
  5211			v.reset(OpS390XRLLG)
  5212			v.AddArg(x)
  5213			v.AddArg(y)
  5214			return true
  5215		}
  5216	}
  5217	func rewriteValueS390X_OpRotateLeft8_0(v *Value) bool {
  5218		b := v.Block
  5219		typ := &b.Func.Config.Types
  5220		// match: (RotateLeft8 <t> x (MOVDconst [c]))
  5221		// cond:
  5222		// result: (Or8 (Lsh8x64 <t> x (MOVDconst [c&7])) (Rsh8Ux64 <t> x (MOVDconst [-c&7])))
  5223		for {
  5224			t := v.Type
  5225			_ = v.Args[1]
  5226			x := v.Args[0]
  5227			v_1 := v.Args[1]
  5228			if v_1.Op != OpS390XMOVDconst {
  5229				break
  5230			}
  5231			c := v_1.AuxInt
  5232			v.reset(OpOr8)
  5233			v0 := b.NewValue0(v.Pos, OpLsh8x64, t)
  5234			v0.AddArg(x)
  5235			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  5236			v1.AuxInt = c & 7
  5237			v0.AddArg(v1)
  5238			v.AddArg(v0)
  5239			v2 := b.NewValue0(v.Pos, OpRsh8Ux64, t)
  5240			v2.AddArg(x)
  5241			v3 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  5242			v3.AuxInt = -c & 7
  5243			v2.AddArg(v3)
  5244			v.AddArg(v2)
  5245			return true
  5246		}
  5247		return false
  5248	}
  5249	func rewriteValueS390X_OpRound_0(v *Value) bool {
  5250		// match: (Round x)
  5251		// cond:
  5252		// result: (FIDBR [1] x)
  5253		for {
  5254			x := v.Args[0]
  5255			v.reset(OpS390XFIDBR)
  5256			v.AuxInt = 1
  5257			v.AddArg(x)
  5258			return true
  5259		}
  5260	}
  5261	func rewriteValueS390X_OpRound32F_0(v *Value) bool {
  5262		// match: (Round32F x)
  5263		// cond:
  5264		// result: (LoweredRound32F x)
  5265		for {
  5266			x := v.Args[0]
  5267			v.reset(OpS390XLoweredRound32F)
  5268			v.AddArg(x)
  5269			return true
  5270		}
  5271	}
  5272	func rewriteValueS390X_OpRound64F_0(v *Value) bool {
  5273		// match: (Round64F x)
  5274		// cond:
  5275		// result: (LoweredRound64F x)
  5276		for {
  5277			x := v.Args[0]
  5278			v.reset(OpS390XLoweredRound64F)
  5279			v.AddArg(x)
  5280			return true
  5281		}
  5282	}
  5283	func rewriteValueS390X_OpRoundToEven_0(v *Value) bool {
  5284		// match: (RoundToEven x)
  5285		// cond:
  5286		// result: (FIDBR [4] x)
  5287		for {
  5288			x := v.Args[0]
  5289			v.reset(OpS390XFIDBR)
  5290			v.AuxInt = 4
  5291			v.AddArg(x)
  5292			return true
  5293		}
  5294	}
  5295	func rewriteValueS390X_OpRsh16Ux16_0(v *Value) bool {
  5296		b := v.Block
  5297		typ := &b.Func.Config.Types
  5298		// match: (Rsh16Ux16 x y)
  5299		// cond: shiftIsBounded(v)
  5300		// result: (SRW (MOVHZreg x) y)
  5301		for {
  5302			y := v.Args[1]
  5303			x := v.Args[0]
  5304			if !(shiftIsBounded(v)) {
  5305				break
  5306			}
  5307			v.reset(OpS390XSRW)
  5308			v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  5309			v0.AddArg(x)
  5310			v.AddArg(v0)
  5311			v.AddArg(y)
  5312			return true
  5313		}
  5314		// match: (Rsh16Ux16 <t> x y)
  5315		// cond:
  5316		// result: (MOVDGE <t> (SRW <t> (MOVHZreg x) y) (MOVDconst [0]) (CMPWUconst (MOVHZreg y) [64]))
  5317		for {
  5318			t := v.Type
  5319			y := v.Args[1]
  5320			x := v.Args[0]
  5321			v.reset(OpS390XMOVDGE)
  5322			v.Type = t
  5323			v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
  5324			v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  5325			v1.AddArg(x)
  5326			v0.AddArg(v1)
  5327			v0.AddArg(y)
  5328			v.AddArg(v0)
  5329			v2 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  5330			v2.AuxInt = 0
  5331			v.AddArg(v2)
  5332			v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  5333			v3.AuxInt = 64
  5334			v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  5335			v4.AddArg(y)
  5336			v3.AddArg(v4)
  5337			v.AddArg(v3)
  5338			return true
  5339		}
  5340	}
  5341	func rewriteValueS390X_OpRsh16Ux32_0(v *Value) bool {
  5342		b := v.Block
  5343		typ := &b.Func.Config.Types
  5344		// match: (Rsh16Ux32 x y)
  5345		// cond: shiftIsBounded(v)
  5346		// result: (SRW (MOVHZreg x) y)
  5347		for {
  5348			y := v.Args[1]
  5349			x := v.Args[0]
  5350			if !(shiftIsBounded(v)) {
  5351				break
  5352			}
  5353			v.reset(OpS390XSRW)
  5354			v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  5355			v0.AddArg(x)
  5356			v.AddArg(v0)
  5357			v.AddArg(y)
  5358			return true
  5359		}
  5360		// match: (Rsh16Ux32 <t> x y)
  5361		// cond:
  5362		// result: (MOVDGE <t> (SRW <t> (MOVHZreg x) y) (MOVDconst [0]) (CMPWUconst y [64]))
  5363		for {
  5364			t := v.Type
  5365			y := v.Args[1]
  5366			x := v.Args[0]
  5367			v.reset(OpS390XMOVDGE)
  5368			v.Type = t
  5369			v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
  5370			v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  5371			v1.AddArg(x)
  5372			v0.AddArg(v1)
  5373			v0.AddArg(y)
  5374			v.AddArg(v0)
  5375			v2 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  5376			v2.AuxInt = 0
  5377			v.AddArg(v2)
  5378			v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  5379			v3.AuxInt = 64
  5380			v3.AddArg(y)
  5381			v.AddArg(v3)
  5382			return true
  5383		}
  5384	}
  5385	func rewriteValueS390X_OpRsh16Ux64_0(v *Value) bool {
  5386		b := v.Block
  5387		typ := &b.Func.Config.Types
  5388		// match: (Rsh16Ux64 x y)
  5389		// cond: shiftIsBounded(v)
  5390		// result: (SRW (MOVHZreg x) y)
  5391		for {
  5392			y := v.Args[1]
  5393			x := v.Args[0]
  5394			if !(shiftIsBounded(v)) {
  5395				break
  5396			}
  5397			v.reset(OpS390XSRW)
  5398			v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  5399			v0.AddArg(x)
  5400			v.AddArg(v0)
  5401			v.AddArg(y)
  5402			return true
  5403		}
  5404		// match: (Rsh16Ux64 <t> x y)
  5405		// cond:
  5406		// result: (MOVDGE <t> (SRW <t> (MOVHZreg x) y) (MOVDconst [0]) (CMPUconst y [64]))
  5407		for {
  5408			t := v.Type
  5409			y := v.Args[1]
  5410			x := v.Args[0]
  5411			v.reset(OpS390XMOVDGE)
  5412			v.Type = t
  5413			v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
  5414			v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  5415			v1.AddArg(x)
  5416			v0.AddArg(v1)
  5417			v0.AddArg(y)
  5418			v.AddArg(v0)
  5419			v2 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  5420			v2.AuxInt = 0
  5421			v.AddArg(v2)
  5422			v3 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
  5423			v3.AuxInt = 64
  5424			v3.AddArg(y)
  5425			v.AddArg(v3)
  5426			return true
  5427		}
  5428	}
  5429	func rewriteValueS390X_OpRsh16Ux8_0(v *Value) bool {
  5430		b := v.Block
  5431		typ := &b.Func.Config.Types
  5432		// match: (Rsh16Ux8 x y)
  5433		// cond: shiftIsBounded(v)
  5434		// result: (SRW (MOVHZreg x) y)
  5435		for {
  5436			y := v.Args[1]
  5437			x := v.Args[0]
  5438			if !(shiftIsBounded(v)) {
  5439				break
  5440			}
  5441			v.reset(OpS390XSRW)
  5442			v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  5443			v0.AddArg(x)
  5444			v.AddArg(v0)
  5445			v.AddArg(y)
  5446			return true
  5447		}
  5448		// match: (Rsh16Ux8 <t> x y)
  5449		// cond:
  5450		// result: (MOVDGE <t> (SRW <t> (MOVHZreg x) y) (MOVDconst [0]) (CMPWUconst (MOVBZreg y) [64]))
  5451		for {
  5452			t := v.Type
  5453			y := v.Args[1]
  5454			x := v.Args[0]
  5455			v.reset(OpS390XMOVDGE)
  5456			v.Type = t
  5457			v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
  5458			v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  5459			v1.AddArg(x)
  5460			v0.AddArg(v1)
  5461			v0.AddArg(y)
  5462			v.AddArg(v0)
  5463			v2 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  5464			v2.AuxInt = 0
  5465			v.AddArg(v2)
  5466			v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  5467			v3.AuxInt = 64
  5468			v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  5469			v4.AddArg(y)
  5470			v3.AddArg(v4)
  5471			v.AddArg(v3)
  5472			return true
  5473		}
  5474	}
  5475	func rewriteValueS390X_OpRsh16x16_0(v *Value) bool {
  5476		b := v.Block
  5477		typ := &b.Func.Config.Types
  5478		// match: (Rsh16x16 x y)
  5479		// cond: shiftIsBounded(v)
  5480		// result: (SRAW (MOVHreg x) y)
  5481		for {
  5482			y := v.Args[1]
  5483			x := v.Args[0]
  5484			if !(shiftIsBounded(v)) {
  5485				break
  5486			}
  5487			v.reset(OpS390XSRAW)
  5488			v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  5489			v0.AddArg(x)
  5490			v.AddArg(v0)
  5491			v.AddArg(y)
  5492			return true
  5493		}
  5494		// match: (Rsh16x16 x y)
  5495		// cond:
  5496		// result: (SRAW (MOVHreg x) (MOVDGE <y.Type> y (MOVDconst <y.Type> [63]) (CMPWUconst (MOVHZreg y) [64])))
  5497		for {
  5498			y := v.Args[1]
  5499			x := v.Args[0]
  5500			v.reset(OpS390XSRAW)
  5501			v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  5502			v0.AddArg(x)
  5503			v.AddArg(v0)
  5504			v1 := b.NewValue0(v.Pos, OpS390XMOVDGE, y.Type)
  5505			v1.AddArg(y)
  5506			v2 := b.NewValue0(v.Pos, OpS390XMOVDconst, y.Type)
  5507			v2.AuxInt = 63
  5508			v1.AddArg(v2)
  5509			v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  5510			v3.AuxInt = 64
  5511			v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  5512			v4.AddArg(y)
  5513			v3.AddArg(v4)
  5514			v1.AddArg(v3)
  5515			v.AddArg(v1)
  5516			return true
  5517		}
  5518	}
  5519	func rewriteValueS390X_OpRsh16x32_0(v *Value) bool {
  5520		b := v.Block
  5521		typ := &b.Func.Config.Types
  5522		// match: (Rsh16x32 x y)
  5523		// cond: shiftIsBounded(v)
  5524		// result: (SRAW (MOVHreg x) y)
  5525		for {
  5526			y := v.Args[1]
  5527			x := v.Args[0]
  5528			if !(shiftIsBounded(v)) {
  5529				break
  5530			}
  5531			v.reset(OpS390XSRAW)
  5532			v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  5533			v0.AddArg(x)
  5534			v.AddArg(v0)
  5535			v.AddArg(y)
  5536			return true
  5537		}
  5538		// match: (Rsh16x32 x y)
  5539		// cond:
  5540		// result: (SRAW (MOVHreg x) (MOVDGE <y.Type> y (MOVDconst <y.Type> [63]) (CMPWUconst y [64])))
  5541		for {
  5542			y := v.Args[1]
  5543			x := v.Args[0]
  5544			v.reset(OpS390XSRAW)
  5545			v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  5546			v0.AddArg(x)
  5547			v.AddArg(v0)
  5548			v1 := b.NewValue0(v.Pos, OpS390XMOVDGE, y.Type)
  5549			v1.AddArg(y)
  5550			v2 := b.NewValue0(v.Pos, OpS390XMOVDconst, y.Type)
  5551			v2.AuxInt = 63
  5552			v1.AddArg(v2)
  5553			v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  5554			v3.AuxInt = 64
  5555			v3.AddArg(y)
  5556			v1.AddArg(v3)
  5557			v.AddArg(v1)
  5558			return true
  5559		}
  5560	}
  5561	func rewriteValueS390X_OpRsh16x64_0(v *Value) bool {
  5562		b := v.Block
  5563		typ := &b.Func.Config.Types
  5564		// match: (Rsh16x64 x y)
  5565		// cond: shiftIsBounded(v)
  5566		// result: (SRAW (MOVHreg x) y)
  5567		for {
  5568			y := v.Args[1]
  5569			x := v.Args[0]
  5570			if !(shiftIsBounded(v)) {
  5571				break
  5572			}
  5573			v.reset(OpS390XSRAW)
  5574			v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  5575			v0.AddArg(x)
  5576			v.AddArg(v0)
  5577			v.AddArg(y)
  5578			return true
  5579		}
  5580		// match: (Rsh16x64 x y)
  5581		// cond:
  5582		// result: (SRAW (MOVHreg x) (MOVDGE <y.Type> y (MOVDconst <y.Type> [63]) (CMPUconst y [64])))
  5583		for {
  5584			y := v.Args[1]
  5585			x := v.Args[0]
  5586			v.reset(OpS390XSRAW)
  5587			v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  5588			v0.AddArg(x)
  5589			v.AddArg(v0)
  5590			v1 := b.NewValue0(v.Pos, OpS390XMOVDGE, y.Type)
  5591			v1.AddArg(y)
  5592			v2 := b.NewValue0(v.Pos, OpS390XMOVDconst, y.Type)
  5593			v2.AuxInt = 63
  5594			v1.AddArg(v2)
  5595			v3 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
  5596			v3.AuxInt = 64
  5597			v3.AddArg(y)
  5598			v1.AddArg(v3)
  5599			v.AddArg(v1)
  5600			return true
  5601		}
  5602	}
  5603	func rewriteValueS390X_OpRsh16x8_0(v *Value) bool {
  5604		b := v.Block
  5605		typ := &b.Func.Config.Types
  5606		// match: (Rsh16x8 x y)
  5607		// cond: shiftIsBounded(v)
  5608		// result: (SRAW (MOVHreg x) y)
  5609		for {
  5610			y := v.Args[1]
  5611			x := v.Args[0]
  5612			if !(shiftIsBounded(v)) {
  5613				break
  5614			}
  5615			v.reset(OpS390XSRAW)
  5616			v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  5617			v0.AddArg(x)
  5618			v.AddArg(v0)
  5619			v.AddArg(y)
  5620			return true
  5621		}
  5622		// match: (Rsh16x8 x y)
  5623		// cond:
  5624		// result: (SRAW (MOVHreg x) (MOVDGE <y.Type> y (MOVDconst <y.Type> [63]) (CMPWUconst (MOVBZreg y) [64])))
  5625		for {
  5626			y := v.Args[1]
  5627			x := v.Args[0]
  5628			v.reset(OpS390XSRAW)
  5629			v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  5630			v0.AddArg(x)
  5631			v.AddArg(v0)
  5632			v1 := b.NewValue0(v.Pos, OpS390XMOVDGE, y.Type)
  5633			v1.AddArg(y)
  5634			v2 := b.NewValue0(v.Pos, OpS390XMOVDconst, y.Type)
  5635			v2.AuxInt = 63
  5636			v1.AddArg(v2)
  5637			v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  5638			v3.AuxInt = 64
  5639			v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  5640			v4.AddArg(y)
  5641			v3.AddArg(v4)
  5642			v1.AddArg(v3)
  5643			v.AddArg(v1)
  5644			return true
  5645		}
  5646	}
  5647	func rewriteValueS390X_OpRsh32Ux16_0(v *Value) bool {
  5648		b := v.Block
  5649		typ := &b.Func.Config.Types
  5650		// match: (Rsh32Ux16 x y)
  5651		// cond: shiftIsBounded(v)
  5652		// result: (SRW x y)
  5653		for {
  5654			y := v.Args[1]
  5655			x := v.Args[0]
  5656			if !(shiftIsBounded(v)) {
  5657				break
  5658			}
  5659			v.reset(OpS390XSRW)
  5660			v.AddArg(x)
  5661			v.AddArg(y)
  5662			return true
  5663		}
  5664		// match: (Rsh32Ux16 <t> x y)
  5665		// cond:
  5666		// result: (MOVDGE <t> (SRW <t> x y) (MOVDconst [0]) (CMPWUconst (MOVHZreg y) [64]))
  5667		for {
  5668			t := v.Type
  5669			y := v.Args[1]
  5670			x := v.Args[0]
  5671			v.reset(OpS390XMOVDGE)
  5672			v.Type = t
  5673			v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
  5674			v0.AddArg(x)
  5675			v0.AddArg(y)
  5676			v.AddArg(v0)
  5677			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  5678			v1.AuxInt = 0
  5679			v.AddArg(v1)
  5680			v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  5681			v2.AuxInt = 64
  5682			v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  5683			v3.AddArg(y)
  5684			v2.AddArg(v3)
  5685			v.AddArg(v2)
  5686			return true
  5687		}
  5688	}
  5689	func rewriteValueS390X_OpRsh32Ux32_0(v *Value) bool {
  5690		b := v.Block
  5691		typ := &b.Func.Config.Types
  5692		// match: (Rsh32Ux32 x y)
  5693		// cond: shiftIsBounded(v)
  5694		// result: (SRW x y)
  5695		for {
  5696			y := v.Args[1]
  5697			x := v.Args[0]
  5698			if !(shiftIsBounded(v)) {
  5699				break
  5700			}
  5701			v.reset(OpS390XSRW)
  5702			v.AddArg(x)
  5703			v.AddArg(y)
  5704			return true
  5705		}
  5706		// match: (Rsh32Ux32 <t> x y)
  5707		// cond:
  5708		// result: (MOVDGE <t> (SRW <t> x y) (MOVDconst [0]) (CMPWUconst y [64]))
  5709		for {
  5710			t := v.Type
  5711			y := v.Args[1]
  5712			x := v.Args[0]
  5713			v.reset(OpS390XMOVDGE)
  5714			v.Type = t
  5715			v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
  5716			v0.AddArg(x)
  5717			v0.AddArg(y)
  5718			v.AddArg(v0)
  5719			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  5720			v1.AuxInt = 0
  5721			v.AddArg(v1)
  5722			v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  5723			v2.AuxInt = 64
  5724			v2.AddArg(y)
  5725			v.AddArg(v2)
  5726			return true
  5727		}
  5728	}
  5729	func rewriteValueS390X_OpRsh32Ux64_0(v *Value) bool {
  5730		b := v.Block
  5731		typ := &b.Func.Config.Types
  5732		// match: (Rsh32Ux64 x y)
  5733		// cond: shiftIsBounded(v)
  5734		// result: (SRW x y)
  5735		for {
  5736			y := v.Args[1]
  5737			x := v.Args[0]
  5738			if !(shiftIsBounded(v)) {
  5739				break
  5740			}
  5741			v.reset(OpS390XSRW)
  5742			v.AddArg(x)
  5743			v.AddArg(y)
  5744			return true
  5745		}
  5746		// match: (Rsh32Ux64 <t> x y)
  5747		// cond:
  5748		// result: (MOVDGE <t> (SRW <t> x y) (MOVDconst [0]) (CMPUconst y [64]))
  5749		for {
  5750			t := v.Type
  5751			y := v.Args[1]
  5752			x := v.Args[0]
  5753			v.reset(OpS390XMOVDGE)
  5754			v.Type = t
  5755			v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
  5756			v0.AddArg(x)
  5757			v0.AddArg(y)
  5758			v.AddArg(v0)
  5759			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  5760			v1.AuxInt = 0
  5761			v.AddArg(v1)
  5762			v2 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
  5763			v2.AuxInt = 64
  5764			v2.AddArg(y)
  5765			v.AddArg(v2)
  5766			return true
  5767		}
  5768	}
  5769	func rewriteValueS390X_OpRsh32Ux8_0(v *Value) bool {
  5770		b := v.Block
  5771		typ := &b.Func.Config.Types
  5772		// match: (Rsh32Ux8 x y)
  5773		// cond: shiftIsBounded(v)
  5774		// result: (SRW x y)
  5775		for {
  5776			y := v.Args[1]
  5777			x := v.Args[0]
  5778			if !(shiftIsBounded(v)) {
  5779				break
  5780			}
  5781			v.reset(OpS390XSRW)
  5782			v.AddArg(x)
  5783			v.AddArg(y)
  5784			return true
  5785		}
  5786		// match: (Rsh32Ux8 <t> x y)
  5787		// cond:
  5788		// result: (MOVDGE <t> (SRW <t> x y) (MOVDconst [0]) (CMPWUconst (MOVBZreg y) [64]))
  5789		for {
  5790			t := v.Type
  5791			y := v.Args[1]
  5792			x := v.Args[0]
  5793			v.reset(OpS390XMOVDGE)
  5794			v.Type = t
  5795			v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
  5796			v0.AddArg(x)
  5797			v0.AddArg(y)
  5798			v.AddArg(v0)
  5799			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  5800			v1.AuxInt = 0
  5801			v.AddArg(v1)
  5802			v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  5803			v2.AuxInt = 64
  5804			v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  5805			v3.AddArg(y)
  5806			v2.AddArg(v3)
  5807			v.AddArg(v2)
  5808			return true
  5809		}
  5810	}
  5811	func rewriteValueS390X_OpRsh32x16_0(v *Value) bool {
  5812		b := v.Block
  5813		typ := &b.Func.Config.Types
  5814		// match: (Rsh32x16 x y)
  5815		// cond: shiftIsBounded(v)
  5816		// result: (SRAW x y)
  5817		for {
  5818			y := v.Args[1]
  5819			x := v.Args[0]
  5820			if !(shiftIsBounded(v)) {
  5821				break
  5822			}
  5823			v.reset(OpS390XSRAW)
  5824			v.AddArg(x)
  5825			v.AddArg(y)
  5826			return true
  5827		}
  5828		// match: (Rsh32x16 x y)
  5829		// cond:
  5830		// result: (SRAW x (MOVDGE <y.Type> y (MOVDconst <y.Type> [63]) (CMPWUconst (MOVHZreg y) [64])))
  5831		for {
  5832			y := v.Args[1]
  5833			x := v.Args[0]
  5834			v.reset(OpS390XSRAW)
  5835			v.AddArg(x)
  5836			v0 := b.NewValue0(v.Pos, OpS390XMOVDGE, y.Type)
  5837			v0.AddArg(y)
  5838			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, y.Type)
  5839			v1.AuxInt = 63
  5840			v0.AddArg(v1)
  5841			v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  5842			v2.AuxInt = 64
  5843			v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  5844			v3.AddArg(y)
  5845			v2.AddArg(v3)
  5846			v0.AddArg(v2)
  5847			v.AddArg(v0)
  5848			return true
  5849		}
  5850	}
  5851	func rewriteValueS390X_OpRsh32x32_0(v *Value) bool {
  5852		b := v.Block
  5853		// match: (Rsh32x32 x y)
  5854		// cond: shiftIsBounded(v)
  5855		// result: (SRAW x y)
  5856		for {
  5857			y := v.Args[1]
  5858			x := v.Args[0]
  5859			if !(shiftIsBounded(v)) {
  5860				break
  5861			}
  5862			v.reset(OpS390XSRAW)
  5863			v.AddArg(x)
  5864			v.AddArg(y)
  5865			return true
  5866		}
  5867		// match: (Rsh32x32 x y)
  5868		// cond:
  5869		// result: (SRAW x (MOVDGE <y.Type> y (MOVDconst <y.Type> [63]) (CMPWUconst y [64])))
  5870		for {
  5871			y := v.Args[1]
  5872			x := v.Args[0]
  5873			v.reset(OpS390XSRAW)
  5874			v.AddArg(x)
  5875			v0 := b.NewValue0(v.Pos, OpS390XMOVDGE, y.Type)
  5876			v0.AddArg(y)
  5877			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, y.Type)
  5878			v1.AuxInt = 63
  5879			v0.AddArg(v1)
  5880			v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  5881			v2.AuxInt = 64
  5882			v2.AddArg(y)
  5883			v0.AddArg(v2)
  5884			v.AddArg(v0)
  5885			return true
  5886		}
  5887	}
  5888	func rewriteValueS390X_OpRsh32x64_0(v *Value) bool {
  5889		b := v.Block
  5890		// match: (Rsh32x64 x y)
  5891		// cond: shiftIsBounded(v)
  5892		// result: (SRAW x y)
  5893		for {
  5894			y := v.Args[1]
  5895			x := v.Args[0]
  5896			if !(shiftIsBounded(v)) {
  5897				break
  5898			}
  5899			v.reset(OpS390XSRAW)
  5900			v.AddArg(x)
  5901			v.AddArg(y)
  5902			return true
  5903		}
  5904		// match: (Rsh32x64 x y)
  5905		// cond:
  5906		// result: (SRAW x (MOVDGE <y.Type> y (MOVDconst <y.Type> [63]) (CMPUconst y [64])))
  5907		for {
  5908			y := v.Args[1]
  5909			x := v.Args[0]
  5910			v.reset(OpS390XSRAW)
  5911			v.AddArg(x)
  5912			v0 := b.NewValue0(v.Pos, OpS390XMOVDGE, y.Type)
  5913			v0.AddArg(y)
  5914			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, y.Type)
  5915			v1.AuxInt = 63
  5916			v0.AddArg(v1)
  5917			v2 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
  5918			v2.AuxInt = 64
  5919			v2.AddArg(y)
  5920			v0.AddArg(v2)
  5921			v.AddArg(v0)
  5922			return true
  5923		}
  5924	}
  5925	func rewriteValueS390X_OpRsh32x8_0(v *Value) bool {
  5926		b := v.Block
  5927		typ := &b.Func.Config.Types
  5928		// match: (Rsh32x8 x y)
  5929		// cond: shiftIsBounded(v)
  5930		// result: (SRAW x y)
  5931		for {
  5932			y := v.Args[1]
  5933			x := v.Args[0]
  5934			if !(shiftIsBounded(v)) {
  5935				break
  5936			}
  5937			v.reset(OpS390XSRAW)
  5938			v.AddArg(x)
  5939			v.AddArg(y)
  5940			return true
  5941		}
  5942		// match: (Rsh32x8 x y)
  5943		// cond:
  5944		// result: (SRAW x (MOVDGE <y.Type> y (MOVDconst <y.Type> [63]) (CMPWUconst (MOVBZreg y) [64])))
  5945		for {
  5946			y := v.Args[1]
  5947			x := v.Args[0]
  5948			v.reset(OpS390XSRAW)
  5949			v.AddArg(x)
  5950			v0 := b.NewValue0(v.Pos, OpS390XMOVDGE, y.Type)
  5951			v0.AddArg(y)
  5952			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, y.Type)
  5953			v1.AuxInt = 63
  5954			v0.AddArg(v1)
  5955			v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  5956			v2.AuxInt = 64
  5957			v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  5958			v3.AddArg(y)
  5959			v2.AddArg(v3)
  5960			v0.AddArg(v2)
  5961			v.AddArg(v0)
  5962			return true
  5963		}
  5964	}
  5965	func rewriteValueS390X_OpRsh64Ux16_0(v *Value) bool {
  5966		b := v.Block
  5967		typ := &b.Func.Config.Types
  5968		// match: (Rsh64Ux16 x y)
  5969		// cond: shiftIsBounded(v)
  5970		// result: (SRD x y)
  5971		for {
  5972			y := v.Args[1]
  5973			x := v.Args[0]
  5974			if !(shiftIsBounded(v)) {
  5975				break
  5976			}
  5977			v.reset(OpS390XSRD)
  5978			v.AddArg(x)
  5979			v.AddArg(y)
  5980			return true
  5981		}
  5982		// match: (Rsh64Ux16 <t> x y)
  5983		// cond:
  5984		// result: (MOVDGE <t> (SRD <t> x y) (MOVDconst [0]) (CMPWUconst (MOVHZreg y) [64]))
  5985		for {
  5986			t := v.Type
  5987			y := v.Args[1]
  5988			x := v.Args[0]
  5989			v.reset(OpS390XMOVDGE)
  5990			v.Type = t
  5991			v0 := b.NewValue0(v.Pos, OpS390XSRD, t)
  5992			v0.AddArg(x)
  5993			v0.AddArg(y)
  5994			v.AddArg(v0)
  5995			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  5996			v1.AuxInt = 0
  5997			v.AddArg(v1)
  5998			v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  5999			v2.AuxInt = 64
  6000			v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  6001			v3.AddArg(y)
  6002			v2.AddArg(v3)
  6003			v.AddArg(v2)
  6004			return true
  6005		}
  6006	}
  6007	func rewriteValueS390X_OpRsh64Ux32_0(v *Value) bool {
  6008		b := v.Block
  6009		typ := &b.Func.Config.Types
  6010		// match: (Rsh64Ux32 x y)
  6011		// cond: shiftIsBounded(v)
  6012		// result: (SRD x y)
  6013		for {
  6014			y := v.Args[1]
  6015			x := v.Args[0]
  6016			if !(shiftIsBounded(v)) {
  6017				break
  6018			}
  6019			v.reset(OpS390XSRD)
  6020			v.AddArg(x)
  6021			v.AddArg(y)
  6022			return true
  6023		}
  6024		// match: (Rsh64Ux32 <t> x y)
  6025		// cond:
  6026		// result: (MOVDGE <t> (SRD <t> x y) (MOVDconst [0]) (CMPWUconst y [64]))
  6027		for {
  6028			t := v.Type
  6029			y := v.Args[1]
  6030			x := v.Args[0]
  6031			v.reset(OpS390XMOVDGE)
  6032			v.Type = t
  6033			v0 := b.NewValue0(v.Pos, OpS390XSRD, t)
  6034			v0.AddArg(x)
  6035			v0.AddArg(y)
  6036			v.AddArg(v0)
  6037			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  6038			v1.AuxInt = 0
  6039			v.AddArg(v1)
  6040			v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  6041			v2.AuxInt = 64
  6042			v2.AddArg(y)
  6043			v.AddArg(v2)
  6044			return true
  6045		}
  6046	}
  6047	func rewriteValueS390X_OpRsh64Ux64_0(v *Value) bool {
  6048		b := v.Block
  6049		typ := &b.Func.Config.Types
  6050		// match: (Rsh64Ux64 x y)
  6051		// cond: shiftIsBounded(v)
  6052		// result: (SRD x y)
  6053		for {
  6054			y := v.Args[1]
  6055			x := v.Args[0]
  6056			if !(shiftIsBounded(v)) {
  6057				break
  6058			}
  6059			v.reset(OpS390XSRD)
  6060			v.AddArg(x)
  6061			v.AddArg(y)
  6062			return true
  6063		}
  6064		// match: (Rsh64Ux64 <t> x y)
  6065		// cond:
  6066		// result: (MOVDGE <t> (SRD <t> x y) (MOVDconst [0]) (CMPUconst y [64]))
  6067		for {
  6068			t := v.Type
  6069			y := v.Args[1]
  6070			x := v.Args[0]
  6071			v.reset(OpS390XMOVDGE)
  6072			v.Type = t
  6073			v0 := b.NewValue0(v.Pos, OpS390XSRD, t)
  6074			v0.AddArg(x)
  6075			v0.AddArg(y)
  6076			v.AddArg(v0)
  6077			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  6078			v1.AuxInt = 0
  6079			v.AddArg(v1)
  6080			v2 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
  6081			v2.AuxInt = 64
  6082			v2.AddArg(y)
  6083			v.AddArg(v2)
  6084			return true
  6085		}
  6086	}
  6087	func rewriteValueS390X_OpRsh64Ux8_0(v *Value) bool {
  6088		b := v.Block
  6089		typ := &b.Func.Config.Types
  6090		// match: (Rsh64Ux8 x y)
  6091		// cond: shiftIsBounded(v)
  6092		// result: (SRD x y)
  6093		for {
  6094			y := v.Args[1]
  6095			x := v.Args[0]
  6096			if !(shiftIsBounded(v)) {
  6097				break
  6098			}
  6099			v.reset(OpS390XSRD)
  6100			v.AddArg(x)
  6101			v.AddArg(y)
  6102			return true
  6103		}
  6104		// match: (Rsh64Ux8 <t> x y)
  6105		// cond:
  6106		// result: (MOVDGE <t> (SRD <t> x y) (MOVDconst [0]) (CMPWUconst (MOVBZreg y) [64]))
  6107		for {
  6108			t := v.Type
  6109			y := v.Args[1]
  6110			x := v.Args[0]
  6111			v.reset(OpS390XMOVDGE)
  6112			v.Type = t
  6113			v0 := b.NewValue0(v.Pos, OpS390XSRD, t)
  6114			v0.AddArg(x)
  6115			v0.AddArg(y)
  6116			v.AddArg(v0)
  6117			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  6118			v1.AuxInt = 0
  6119			v.AddArg(v1)
  6120			v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  6121			v2.AuxInt = 64
  6122			v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  6123			v3.AddArg(y)
  6124			v2.AddArg(v3)
  6125			v.AddArg(v2)
  6126			return true
  6127		}
  6128	}
  6129	func rewriteValueS390X_OpRsh64x16_0(v *Value) bool {
  6130		b := v.Block
  6131		typ := &b.Func.Config.Types
  6132		// match: (Rsh64x16 x y)
  6133		// cond: shiftIsBounded(v)
  6134		// result: (SRAD x y)
  6135		for {
  6136			y := v.Args[1]
  6137			x := v.Args[0]
  6138			if !(shiftIsBounded(v)) {
  6139				break
  6140			}
  6141			v.reset(OpS390XSRAD)
  6142			v.AddArg(x)
  6143			v.AddArg(y)
  6144			return true
  6145		}
  6146		// match: (Rsh64x16 x y)
  6147		// cond:
  6148		// result: (SRAD x (MOVDGE <y.Type> y (MOVDconst <y.Type> [63]) (CMPWUconst (MOVHZreg y) [64])))
  6149		for {
  6150			y := v.Args[1]
  6151			x := v.Args[0]
  6152			v.reset(OpS390XSRAD)
  6153			v.AddArg(x)
  6154			v0 := b.NewValue0(v.Pos, OpS390XMOVDGE, y.Type)
  6155			v0.AddArg(y)
  6156			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, y.Type)
  6157			v1.AuxInt = 63
  6158			v0.AddArg(v1)
  6159			v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  6160			v2.AuxInt = 64
  6161			v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  6162			v3.AddArg(y)
  6163			v2.AddArg(v3)
  6164			v0.AddArg(v2)
  6165			v.AddArg(v0)
  6166			return true
  6167		}
  6168	}
  6169	func rewriteValueS390X_OpRsh64x32_0(v *Value) bool {
  6170		b := v.Block
  6171		// match: (Rsh64x32 x y)
  6172		// cond: shiftIsBounded(v)
  6173		// result: (SRAD x y)
  6174		for {
  6175			y := v.Args[1]
  6176			x := v.Args[0]
  6177			if !(shiftIsBounded(v)) {
  6178				break
  6179			}
  6180			v.reset(OpS390XSRAD)
  6181			v.AddArg(x)
  6182			v.AddArg(y)
  6183			return true
  6184		}
  6185		// match: (Rsh64x32 x y)
  6186		// cond:
  6187		// result: (SRAD x (MOVDGE <y.Type> y (MOVDconst <y.Type> [63]) (CMPWUconst y [64])))
  6188		for {
  6189			y := v.Args[1]
  6190			x := v.Args[0]
  6191			v.reset(OpS390XSRAD)
  6192			v.AddArg(x)
  6193			v0 := b.NewValue0(v.Pos, OpS390XMOVDGE, y.Type)
  6194			v0.AddArg(y)
  6195			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, y.Type)
  6196			v1.AuxInt = 63
  6197			v0.AddArg(v1)
  6198			v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  6199			v2.AuxInt = 64
  6200			v2.AddArg(y)
  6201			v0.AddArg(v2)
  6202			v.AddArg(v0)
  6203			return true
  6204		}
  6205	}
  6206	func rewriteValueS390X_OpRsh64x64_0(v *Value) bool {
  6207		b := v.Block
  6208		// match: (Rsh64x64 x y)
  6209		// cond: shiftIsBounded(v)
  6210		// result: (SRAD x y)
  6211		for {
  6212			y := v.Args[1]
  6213			x := v.Args[0]
  6214			if !(shiftIsBounded(v)) {
  6215				break
  6216			}
  6217			v.reset(OpS390XSRAD)
  6218			v.AddArg(x)
  6219			v.AddArg(y)
  6220			return true
  6221		}
  6222		// match: (Rsh64x64 x y)
  6223		// cond:
  6224		// result: (SRAD x (MOVDGE <y.Type> y (MOVDconst <y.Type> [63]) (CMPUconst y [64])))
  6225		for {
  6226			y := v.Args[1]
  6227			x := v.Args[0]
  6228			v.reset(OpS390XSRAD)
  6229			v.AddArg(x)
  6230			v0 := b.NewValue0(v.Pos, OpS390XMOVDGE, y.Type)
  6231			v0.AddArg(y)
  6232			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, y.Type)
  6233			v1.AuxInt = 63
  6234			v0.AddArg(v1)
  6235			v2 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
  6236			v2.AuxInt = 64
  6237			v2.AddArg(y)
  6238			v0.AddArg(v2)
  6239			v.AddArg(v0)
  6240			return true
  6241		}
  6242	}
  6243	func rewriteValueS390X_OpRsh64x8_0(v *Value) bool {
  6244		b := v.Block
  6245		typ := &b.Func.Config.Types
  6246		// match: (Rsh64x8 x y)
  6247		// cond: shiftIsBounded(v)
  6248		// result: (SRAD x y)
  6249		for {
  6250			y := v.Args[1]
  6251			x := v.Args[0]
  6252			if !(shiftIsBounded(v)) {
  6253				break
  6254			}
  6255			v.reset(OpS390XSRAD)
  6256			v.AddArg(x)
  6257			v.AddArg(y)
  6258			return true
  6259		}
  6260		// match: (Rsh64x8 x y)
  6261		// cond:
  6262		// result: (SRAD x (MOVDGE <y.Type> y (MOVDconst <y.Type> [63]) (CMPWUconst (MOVBZreg y) [64])))
  6263		for {
  6264			y := v.Args[1]
  6265			x := v.Args[0]
  6266			v.reset(OpS390XSRAD)
  6267			v.AddArg(x)
  6268			v0 := b.NewValue0(v.Pos, OpS390XMOVDGE, y.Type)
  6269			v0.AddArg(y)
  6270			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, y.Type)
  6271			v1.AuxInt = 63
  6272			v0.AddArg(v1)
  6273			v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  6274			v2.AuxInt = 64
  6275			v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  6276			v3.AddArg(y)
  6277			v2.AddArg(v3)
  6278			v0.AddArg(v2)
  6279			v.AddArg(v0)
  6280			return true
  6281		}
  6282	}
  6283	func rewriteValueS390X_OpRsh8Ux16_0(v *Value) bool {
  6284		b := v.Block
  6285		typ := &b.Func.Config.Types
  6286		// match: (Rsh8Ux16 x y)
  6287		// cond: shiftIsBounded(v)
  6288		// result: (SRW (MOVBZreg x) y)
  6289		for {
  6290			y := v.Args[1]
  6291			x := v.Args[0]
  6292			if !(shiftIsBounded(v)) {
  6293				break
  6294			}
  6295			v.reset(OpS390XSRW)
  6296			v0 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  6297			v0.AddArg(x)
  6298			v.AddArg(v0)
  6299			v.AddArg(y)
  6300			return true
  6301		}
  6302		// match: (Rsh8Ux16 <t> x y)
  6303		// cond:
  6304		// result: (MOVDGE <t> (SRW <t> (MOVBZreg x) y) (MOVDconst [0]) (CMPWUconst (MOVHZreg y) [64]))
  6305		for {
  6306			t := v.Type
  6307			y := v.Args[1]
  6308			x := v.Args[0]
  6309			v.reset(OpS390XMOVDGE)
  6310			v.Type = t
  6311			v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
  6312			v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  6313			v1.AddArg(x)
  6314			v0.AddArg(v1)
  6315			v0.AddArg(y)
  6316			v.AddArg(v0)
  6317			v2 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  6318			v2.AuxInt = 0
  6319			v.AddArg(v2)
  6320			v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  6321			v3.AuxInt = 64
  6322			v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  6323			v4.AddArg(y)
  6324			v3.AddArg(v4)
  6325			v.AddArg(v3)
  6326			return true
  6327		}
  6328	}
  6329	func rewriteValueS390X_OpRsh8Ux32_0(v *Value) bool {
  6330		b := v.Block
  6331		typ := &b.Func.Config.Types
  6332		// match: (Rsh8Ux32 x y)
  6333		// cond: shiftIsBounded(v)
  6334		// result: (SRW (MOVBZreg x) y)
  6335		for {
  6336			y := v.Args[1]
  6337			x := v.Args[0]
  6338			if !(shiftIsBounded(v)) {
  6339				break
  6340			}
  6341			v.reset(OpS390XSRW)
  6342			v0 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  6343			v0.AddArg(x)
  6344			v.AddArg(v0)
  6345			v.AddArg(y)
  6346			return true
  6347		}
  6348		// match: (Rsh8Ux32 <t> x y)
  6349		// cond:
  6350		// result: (MOVDGE <t> (SRW <t> (MOVBZreg x) y) (MOVDconst [0]) (CMPWUconst y [64]))
  6351		for {
  6352			t := v.Type
  6353			y := v.Args[1]
  6354			x := v.Args[0]
  6355			v.reset(OpS390XMOVDGE)
  6356			v.Type = t
  6357			v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
  6358			v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  6359			v1.AddArg(x)
  6360			v0.AddArg(v1)
  6361			v0.AddArg(y)
  6362			v.AddArg(v0)
  6363			v2 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  6364			v2.AuxInt = 0
  6365			v.AddArg(v2)
  6366			v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  6367			v3.AuxInt = 64
  6368			v3.AddArg(y)
  6369			v.AddArg(v3)
  6370			return true
  6371		}
  6372	}
  6373	func rewriteValueS390X_OpRsh8Ux64_0(v *Value) bool {
  6374		b := v.Block
  6375		typ := &b.Func.Config.Types
  6376		// match: (Rsh8Ux64 x y)
  6377		// cond: shiftIsBounded(v)
  6378		// result: (SRW (MOVBZreg x) y)
  6379		for {
  6380			y := v.Args[1]
  6381			x := v.Args[0]
  6382			if !(shiftIsBounded(v)) {
  6383				break
  6384			}
  6385			v.reset(OpS390XSRW)
  6386			v0 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  6387			v0.AddArg(x)
  6388			v.AddArg(v0)
  6389			v.AddArg(y)
  6390			return true
  6391		}
  6392		// match: (Rsh8Ux64 <t> x y)
  6393		// cond:
  6394		// result: (MOVDGE <t> (SRW <t> (MOVBZreg x) y) (MOVDconst [0]) (CMPUconst y [64]))
  6395		for {
  6396			t := v.Type
  6397			y := v.Args[1]
  6398			x := v.Args[0]
  6399			v.reset(OpS390XMOVDGE)
  6400			v.Type = t
  6401			v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
  6402			v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  6403			v1.AddArg(x)
  6404			v0.AddArg(v1)
  6405			v0.AddArg(y)
  6406			v.AddArg(v0)
  6407			v2 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  6408			v2.AuxInt = 0
  6409			v.AddArg(v2)
  6410			v3 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
  6411			v3.AuxInt = 64
  6412			v3.AddArg(y)
  6413			v.AddArg(v3)
  6414			return true
  6415		}
  6416	}
  6417	func rewriteValueS390X_OpRsh8Ux8_0(v *Value) bool {
  6418		b := v.Block
  6419		typ := &b.Func.Config.Types
  6420		// match: (Rsh8Ux8 x y)
  6421		// cond: shiftIsBounded(v)
  6422		// result: (SRW (MOVBZreg x) y)
  6423		for {
  6424			y := v.Args[1]
  6425			x := v.Args[0]
  6426			if !(shiftIsBounded(v)) {
  6427				break
  6428			}
  6429			v.reset(OpS390XSRW)
  6430			v0 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  6431			v0.AddArg(x)
  6432			v.AddArg(v0)
  6433			v.AddArg(y)
  6434			return true
  6435		}
  6436		// match: (Rsh8Ux8 <t> x y)
  6437		// cond:
  6438		// result: (MOVDGE <t> (SRW <t> (MOVBZreg x) y) (MOVDconst [0]) (CMPWUconst (MOVBZreg y) [64]))
  6439		for {
  6440			t := v.Type
  6441			y := v.Args[1]
  6442			x := v.Args[0]
  6443			v.reset(OpS390XMOVDGE)
  6444			v.Type = t
  6445			v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
  6446			v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  6447			v1.AddArg(x)
  6448			v0.AddArg(v1)
  6449			v0.AddArg(y)
  6450			v.AddArg(v0)
  6451			v2 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  6452			v2.AuxInt = 0
  6453			v.AddArg(v2)
  6454			v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  6455			v3.AuxInt = 64
  6456			v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  6457			v4.AddArg(y)
  6458			v3.AddArg(v4)
  6459			v.AddArg(v3)
  6460			return true
  6461		}
  6462	}
  6463	func rewriteValueS390X_OpRsh8x16_0(v *Value) bool {
  6464		b := v.Block
  6465		typ := &b.Func.Config.Types
  6466		// match: (Rsh8x16 x y)
  6467		// cond: shiftIsBounded(v)
  6468		// result: (SRAW (MOVBreg x) y)
  6469		for {
  6470			y := v.Args[1]
  6471			x := v.Args[0]
  6472			if !(shiftIsBounded(v)) {
  6473				break
  6474			}
  6475			v.reset(OpS390XSRAW)
  6476			v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  6477			v0.AddArg(x)
  6478			v.AddArg(v0)
  6479			v.AddArg(y)
  6480			return true
  6481		}
  6482		// match: (Rsh8x16 x y)
  6483		// cond:
  6484		// result: (SRAW (MOVBreg x) (MOVDGE <y.Type> y (MOVDconst <y.Type> [63]) (CMPWUconst (MOVHZreg y) [64])))
  6485		for {
  6486			y := v.Args[1]
  6487			x := v.Args[0]
  6488			v.reset(OpS390XSRAW)
  6489			v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  6490			v0.AddArg(x)
  6491			v.AddArg(v0)
  6492			v1 := b.NewValue0(v.Pos, OpS390XMOVDGE, y.Type)
  6493			v1.AddArg(y)
  6494			v2 := b.NewValue0(v.Pos, OpS390XMOVDconst, y.Type)
  6495			v2.AuxInt = 63
  6496			v1.AddArg(v2)
  6497			v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  6498			v3.AuxInt = 64
  6499			v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  6500			v4.AddArg(y)
  6501			v3.AddArg(v4)
  6502			v1.AddArg(v3)
  6503			v.AddArg(v1)
  6504			return true
  6505		}
  6506	}
  6507	func rewriteValueS390X_OpRsh8x32_0(v *Value) bool {
  6508		b := v.Block
  6509		typ := &b.Func.Config.Types
  6510		// match: (Rsh8x32 x y)
  6511		// cond: shiftIsBounded(v)
  6512		// result: (SRAW (MOVBreg x) y)
  6513		for {
  6514			y := v.Args[1]
  6515			x := v.Args[0]
  6516			if !(shiftIsBounded(v)) {
  6517				break
  6518			}
  6519			v.reset(OpS390XSRAW)
  6520			v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  6521			v0.AddArg(x)
  6522			v.AddArg(v0)
  6523			v.AddArg(y)
  6524			return true
  6525		}
  6526		// match: (Rsh8x32 x y)
  6527		// cond:
  6528		// result: (SRAW (MOVBreg x) (MOVDGE <y.Type> y (MOVDconst <y.Type> [63]) (CMPWUconst y [64])))
  6529		for {
  6530			y := v.Args[1]
  6531			x := v.Args[0]
  6532			v.reset(OpS390XSRAW)
  6533			v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  6534			v0.AddArg(x)
  6535			v.AddArg(v0)
  6536			v1 := b.NewValue0(v.Pos, OpS390XMOVDGE, y.Type)
  6537			v1.AddArg(y)
  6538			v2 := b.NewValue0(v.Pos, OpS390XMOVDconst, y.Type)
  6539			v2.AuxInt = 63
  6540			v1.AddArg(v2)
  6541			v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  6542			v3.AuxInt = 64
  6543			v3.AddArg(y)
  6544			v1.AddArg(v3)
  6545			v.AddArg(v1)
  6546			return true
  6547		}
  6548	}
  6549	func rewriteValueS390X_OpRsh8x64_0(v *Value) bool {
  6550		b := v.Block
  6551		typ := &b.Func.Config.Types
  6552		// match: (Rsh8x64 x y)
  6553		// cond: shiftIsBounded(v)
  6554		// result: (SRAW (MOVBreg x) y)
  6555		for {
  6556			y := v.Args[1]
  6557			x := v.Args[0]
  6558			if !(shiftIsBounded(v)) {
  6559				break
  6560			}
  6561			v.reset(OpS390XSRAW)
  6562			v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  6563			v0.AddArg(x)
  6564			v.AddArg(v0)
  6565			v.AddArg(y)
  6566			return true
  6567		}
  6568		// match: (Rsh8x64 x y)
  6569		// cond:
  6570		// result: (SRAW (MOVBreg x) (MOVDGE <y.Type> y (MOVDconst <y.Type> [63]) (CMPUconst y [64])))
  6571		for {
  6572			y := v.Args[1]
  6573			x := v.Args[0]
  6574			v.reset(OpS390XSRAW)
  6575			v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  6576			v0.AddArg(x)
  6577			v.AddArg(v0)
  6578			v1 := b.NewValue0(v.Pos, OpS390XMOVDGE, y.Type)
  6579			v1.AddArg(y)
  6580			v2 := b.NewValue0(v.Pos, OpS390XMOVDconst, y.Type)
  6581			v2.AuxInt = 63
  6582			v1.AddArg(v2)
  6583			v3 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
  6584			v3.AuxInt = 64
  6585			v3.AddArg(y)
  6586			v1.AddArg(v3)
  6587			v.AddArg(v1)
  6588			return true
  6589		}
  6590	}
  6591	func rewriteValueS390X_OpRsh8x8_0(v *Value) bool {
  6592		b := v.Block
  6593		typ := &b.Func.Config.Types
  6594		// match: (Rsh8x8 x y)
  6595		// cond: shiftIsBounded(v)
  6596		// result: (SRAW (MOVBreg x) y)
  6597		for {
  6598			y := v.Args[1]
  6599			x := v.Args[0]
  6600			if !(shiftIsBounded(v)) {
  6601				break
  6602			}
  6603			v.reset(OpS390XSRAW)
  6604			v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  6605			v0.AddArg(x)
  6606			v.AddArg(v0)
  6607			v.AddArg(y)
  6608			return true
  6609		}
  6610		// match: (Rsh8x8 x y)
  6611		// cond:
  6612		// result: (SRAW (MOVBreg x) (MOVDGE <y.Type> y (MOVDconst <y.Type> [63]) (CMPWUconst (MOVBZreg y) [64])))
  6613		for {
  6614			y := v.Args[1]
  6615			x := v.Args[0]
  6616			v.reset(OpS390XSRAW)
  6617			v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  6618			v0.AddArg(x)
  6619			v.AddArg(v0)
  6620			v1 := b.NewValue0(v.Pos, OpS390XMOVDGE, y.Type)
  6621			v1.AddArg(y)
  6622			v2 := b.NewValue0(v.Pos, OpS390XMOVDconst, y.Type)
  6623			v2.AuxInt = 63
  6624			v1.AddArg(v2)
  6625			v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  6626			v3.AuxInt = 64
  6627			v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  6628			v4.AddArg(y)
  6629			v3.AddArg(v4)
  6630			v1.AddArg(v3)
  6631			v.AddArg(v1)
  6632			return true
  6633		}
  6634	}
  6635	func rewriteValueS390X_OpS390XADD_0(v *Value) bool {
  6636		// match: (ADD x (MOVDconst [c]))
  6637		// cond: is32Bit(c)
  6638		// result: (ADDconst [c] x)
  6639		for {
  6640			_ = v.Args[1]
  6641			x := v.Args[0]
  6642			v_1 := v.Args[1]
  6643			if v_1.Op != OpS390XMOVDconst {
  6644				break
  6645			}
  6646			c := v_1.AuxInt
  6647			if !(is32Bit(c)) {
  6648				break
  6649			}
  6650			v.reset(OpS390XADDconst)
  6651			v.AuxInt = c
  6652			v.AddArg(x)
  6653			return true
  6654		}
  6655		// match: (ADD (MOVDconst [c]) x)
  6656		// cond: is32Bit(c)
  6657		// result: (ADDconst [c] x)
  6658		for {
  6659			x := v.Args[1]
  6660			v_0 := v.Args[0]
  6661			if v_0.Op != OpS390XMOVDconst {
  6662				break
  6663			}
  6664			c := v_0.AuxInt
  6665			if !(is32Bit(c)) {
  6666				break
  6667			}
  6668			v.reset(OpS390XADDconst)
  6669			v.AuxInt = c
  6670			v.AddArg(x)
  6671			return true
  6672		}
  6673		// match: (ADD (SLDconst x [c]) (SRDconst x [d]))
  6674		// cond: d == 64-c
  6675		// result: (RLLGconst [c] x)
  6676		for {
  6677			_ = v.Args[1]
  6678			v_0 := v.Args[0]
  6679			if v_0.Op != OpS390XSLDconst {
  6680				break
  6681			}
  6682			c := v_0.AuxInt
  6683			x := v_0.Args[0]
  6684			v_1 := v.Args[1]
  6685			if v_1.Op != OpS390XSRDconst {
  6686				break
  6687			}
  6688			d := v_1.AuxInt
  6689			if x != v_1.Args[0] {
  6690				break
  6691			}
  6692			if !(d == 64-c) {
  6693				break
  6694			}
  6695			v.reset(OpS390XRLLGconst)
  6696			v.AuxInt = c
  6697			v.AddArg(x)
  6698			return true
  6699		}
  6700		// match: (ADD (SRDconst x [d]) (SLDconst x [c]))
  6701		// cond: d == 64-c
  6702		// result: (RLLGconst [c] x)
  6703		for {
  6704			_ = v.Args[1]
  6705			v_0 := v.Args[0]
  6706			if v_0.Op != OpS390XSRDconst {
  6707				break
  6708			}
  6709			d := v_0.AuxInt
  6710			x := v_0.Args[0]
  6711			v_1 := v.Args[1]
  6712			if v_1.Op != OpS390XSLDconst {
  6713				break
  6714			}
  6715			c := v_1.AuxInt
  6716			if x != v_1.Args[0] {
  6717				break
  6718			}
  6719			if !(d == 64-c) {
  6720				break
  6721			}
  6722			v.reset(OpS390XRLLGconst)
  6723			v.AuxInt = c
  6724			v.AddArg(x)
  6725			return true
  6726		}
  6727		// match: (ADD idx (MOVDaddr [c] {s} ptr))
  6728		// cond: ptr.Op != OpSB && idx.Op != OpSB
  6729		// result: (MOVDaddridx [c] {s} ptr idx)
  6730		for {
  6731			_ = v.Args[1]
  6732			idx := v.Args[0]
  6733			v_1 := v.Args[1]
  6734			if v_1.Op != OpS390XMOVDaddr {
  6735				break
  6736			}
  6737			c := v_1.AuxInt
  6738			s := v_1.Aux
  6739			ptr := v_1.Args[0]
  6740			if !(ptr.Op != OpSB && idx.Op != OpSB) {
  6741				break
  6742			}
  6743			v.reset(OpS390XMOVDaddridx)
  6744			v.AuxInt = c
  6745			v.Aux = s
  6746			v.AddArg(ptr)
  6747			v.AddArg(idx)
  6748			return true
  6749		}
  6750		// match: (ADD (MOVDaddr [c] {s} ptr) idx)
  6751		// cond: ptr.Op != OpSB && idx.Op != OpSB
  6752		// result: (MOVDaddridx [c] {s} ptr idx)
  6753		for {
  6754			idx := v.Args[1]
  6755			v_0 := v.Args[0]
  6756			if v_0.Op != OpS390XMOVDaddr {
  6757				break
  6758			}
  6759			c := v_0.AuxInt
  6760			s := v_0.Aux
  6761			ptr := v_0.Args[0]
  6762			if !(ptr.Op != OpSB && idx.Op != OpSB) {
  6763				break
  6764			}
  6765			v.reset(OpS390XMOVDaddridx)
  6766			v.AuxInt = c
  6767			v.Aux = s
  6768			v.AddArg(ptr)
  6769			v.AddArg(idx)
  6770			return true
  6771		}
  6772		// match: (ADD x (NEG y))
  6773		// cond:
  6774		// result: (SUB x y)
  6775		for {
  6776			_ = v.Args[1]
  6777			x := v.Args[0]
  6778			v_1 := v.Args[1]
  6779			if v_1.Op != OpS390XNEG {
  6780				break
  6781			}
  6782			y := v_1.Args[0]
  6783			v.reset(OpS390XSUB)
  6784			v.AddArg(x)
  6785			v.AddArg(y)
  6786			return true
  6787		}
  6788		// match: (ADD (NEG y) x)
  6789		// cond:
  6790		// result: (SUB x y)
  6791		for {
  6792			x := v.Args[1]
  6793			v_0 := v.Args[0]
  6794			if v_0.Op != OpS390XNEG {
  6795				break
  6796			}
  6797			y := v_0.Args[0]
  6798			v.reset(OpS390XSUB)
  6799			v.AddArg(x)
  6800			v.AddArg(y)
  6801			return true
  6802		}
  6803		// match: (ADD <t> x g:(MOVDload [off] {sym} ptr mem))
  6804		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  6805		// result: (ADDload <t> [off] {sym} x ptr mem)
  6806		for {
  6807			t := v.Type
  6808			_ = v.Args[1]
  6809			x := v.Args[0]
  6810			g := v.Args[1]
  6811			if g.Op != OpS390XMOVDload {
  6812				break
  6813			}
  6814			off := g.AuxInt
  6815			sym := g.Aux
  6816			mem := g.Args[1]
  6817			ptr := g.Args[0]
  6818			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  6819				break
  6820			}
  6821			v.reset(OpS390XADDload)
  6822			v.Type = t
  6823			v.AuxInt = off
  6824			v.Aux = sym
  6825			v.AddArg(x)
  6826			v.AddArg(ptr)
  6827			v.AddArg(mem)
  6828			return true
  6829		}
  6830		// match: (ADD <t> g:(MOVDload [off] {sym} ptr mem) x)
  6831		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  6832		// result: (ADDload <t> [off] {sym} x ptr mem)
  6833		for {
  6834			t := v.Type
  6835			x := v.Args[1]
  6836			g := v.Args[0]
  6837			if g.Op != OpS390XMOVDload {
  6838				break
  6839			}
  6840			off := g.AuxInt
  6841			sym := g.Aux
  6842			mem := g.Args[1]
  6843			ptr := g.Args[0]
  6844			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  6845				break
  6846			}
  6847			v.reset(OpS390XADDload)
  6848			v.Type = t
  6849			v.AuxInt = off
  6850			v.Aux = sym
  6851			v.AddArg(x)
  6852			v.AddArg(ptr)
  6853			v.AddArg(mem)
  6854			return true
  6855		}
  6856		return false
  6857	}
  6858	func rewriteValueS390X_OpS390XADD_10(v *Value) bool {
  6859		// match: (ADD <t> g:(MOVDload [off] {sym} ptr mem) x)
  6860		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  6861		// result: (ADDload <t> [off] {sym} x ptr mem)
  6862		for {
  6863			t := v.Type
  6864			x := v.Args[1]
  6865			g := v.Args[0]
  6866			if g.Op != OpS390XMOVDload {
  6867				break
  6868			}
  6869			off := g.AuxInt
  6870			sym := g.Aux
  6871			mem := g.Args[1]
  6872			ptr := g.Args[0]
  6873			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  6874				break
  6875			}
  6876			v.reset(OpS390XADDload)
  6877			v.Type = t
  6878			v.AuxInt = off
  6879			v.Aux = sym
  6880			v.AddArg(x)
  6881			v.AddArg(ptr)
  6882			v.AddArg(mem)
  6883			return true
  6884		}
  6885		// match: (ADD <t> x g:(MOVDload [off] {sym} ptr mem))
  6886		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  6887		// result: (ADDload <t> [off] {sym} x ptr mem)
  6888		for {
  6889			t := v.Type
  6890			_ = v.Args[1]
  6891			x := v.Args[0]
  6892			g := v.Args[1]
  6893			if g.Op != OpS390XMOVDload {
  6894				break
  6895			}
  6896			off := g.AuxInt
  6897			sym := g.Aux
  6898			mem := g.Args[1]
  6899			ptr := g.Args[0]
  6900			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  6901				break
  6902			}
  6903			v.reset(OpS390XADDload)
  6904			v.Type = t
  6905			v.AuxInt = off
  6906			v.Aux = sym
  6907			v.AddArg(x)
  6908			v.AddArg(ptr)
  6909			v.AddArg(mem)
  6910			return true
  6911		}
  6912		return false
  6913	}
  6914	func rewriteValueS390X_OpS390XADDC_0(v *Value) bool {
  6915		// match: (ADDC x (MOVDconst [c]))
  6916		// cond: is16Bit(c)
  6917		// result: (ADDCconst x [c])
  6918		for {
  6919			_ = v.Args[1]
  6920			x := v.Args[0]
  6921			v_1 := v.Args[1]
  6922			if v_1.Op != OpS390XMOVDconst {
  6923				break
  6924			}
  6925			c := v_1.AuxInt
  6926			if !(is16Bit(c)) {
  6927				break
  6928			}
  6929			v.reset(OpS390XADDCconst)
  6930			v.AuxInt = c
  6931			v.AddArg(x)
  6932			return true
  6933		}
  6934		// match: (ADDC (MOVDconst [c]) x)
  6935		// cond: is16Bit(c)
  6936		// result: (ADDCconst x [c])
  6937		for {
  6938			x := v.Args[1]
  6939			v_0 := v.Args[0]
  6940			if v_0.Op != OpS390XMOVDconst {
  6941				break
  6942			}
  6943			c := v_0.AuxInt
  6944			if !(is16Bit(c)) {
  6945				break
  6946			}
  6947			v.reset(OpS390XADDCconst)
  6948			v.AuxInt = c
  6949			v.AddArg(x)
  6950			return true
  6951		}
  6952		return false
  6953	}
  6954	func rewriteValueS390X_OpS390XADDE_0(v *Value) bool {
  6955		// match: (ADDE x y (FlagEQ))
  6956		// cond:
  6957		// result: (ADDC x y)
  6958		for {
  6959			_ = v.Args[2]
  6960			x := v.Args[0]
  6961			y := v.Args[1]
  6962			v_2 := v.Args[2]
  6963			if v_2.Op != OpS390XFlagEQ {
  6964				break
  6965			}
  6966			v.reset(OpS390XADDC)
  6967			v.AddArg(x)
  6968			v.AddArg(y)
  6969			return true
  6970		}
  6971		// match: (ADDE x y (FlagLT))
  6972		// cond:
  6973		// result: (ADDC x y)
  6974		for {
  6975			_ = v.Args[2]
  6976			x := v.Args[0]
  6977			y := v.Args[1]
  6978			v_2 := v.Args[2]
  6979			if v_2.Op != OpS390XFlagLT {
  6980				break
  6981			}
  6982			v.reset(OpS390XADDC)
  6983			v.AddArg(x)
  6984			v.AddArg(y)
  6985			return true
  6986		}
  6987		// match: (ADDE x y (Select1 (ADDCconst [-1] (Select0 (ADDE (MOVDconst [0]) (MOVDconst [0]) c)))))
  6988		// cond:
  6989		// result: (ADDE x y c)
  6990		for {
  6991			_ = v.Args[2]
  6992			x := v.Args[0]
  6993			y := v.Args[1]
  6994			v_2 := v.Args[2]
  6995			if v_2.Op != OpSelect1 {
  6996				break
  6997			}
  6998			v_2_0 := v_2.Args[0]
  6999			if v_2_0.Op != OpS390XADDCconst {
  7000				break
  7001			}
  7002			if v_2_0.AuxInt != -1 {
  7003				break
  7004			}
  7005			v_2_0_0 := v_2_0.Args[0]
  7006			if v_2_0_0.Op != OpSelect0 {
  7007				break
  7008			}
  7009			v_2_0_0_0 := v_2_0_0.Args[0]
  7010			if v_2_0_0_0.Op != OpS390XADDE {
  7011				break
  7012			}
  7013			c := v_2_0_0_0.Args[2]
  7014			v_2_0_0_0_0 := v_2_0_0_0.Args[0]
  7015			if v_2_0_0_0_0.Op != OpS390XMOVDconst {
  7016				break
  7017			}
  7018			if v_2_0_0_0_0.AuxInt != 0 {
  7019				break
  7020			}
  7021			v_2_0_0_0_1 := v_2_0_0_0.Args[1]
  7022			if v_2_0_0_0_1.Op != OpS390XMOVDconst {
  7023				break
  7024			}
  7025			if v_2_0_0_0_1.AuxInt != 0 {
  7026				break
  7027			}
  7028			v.reset(OpS390XADDE)
  7029			v.AddArg(x)
  7030			v.AddArg(y)
  7031			v.AddArg(c)
  7032			return true
  7033		}
  7034		// match: (ADDE x y (Select1 (ADDCconst [-1] (Select0 (ADDE (MOVDconst [0]) (MOVDconst [0]) c)))))
  7035		// cond:
  7036		// result: (ADDE x y c)
  7037		for {
  7038			_ = v.Args[2]
  7039			x := v.Args[0]
  7040			y := v.Args[1]
  7041			v_2 := v.Args[2]
  7042			if v_2.Op != OpSelect1 {
  7043				break
  7044			}
  7045			v_2_0 := v_2.Args[0]
  7046			if v_2_0.Op != OpS390XADDCconst {
  7047				break
  7048			}
  7049			if v_2_0.AuxInt != -1 {
  7050				break
  7051			}
  7052			v_2_0_0 := v_2_0.Args[0]
  7053			if v_2_0_0.Op != OpSelect0 {
  7054				break
  7055			}
  7056			v_2_0_0_0 := v_2_0_0.Args[0]
  7057			if v_2_0_0_0.Op != OpS390XADDE {
  7058				break
  7059			}
  7060			c := v_2_0_0_0.Args[2]
  7061			v_2_0_0_0_0 := v_2_0_0_0.Args[0]
  7062			if v_2_0_0_0_0.Op != OpS390XMOVDconst {
  7063				break
  7064			}
  7065			if v_2_0_0_0_0.AuxInt != 0 {
  7066				break
  7067			}
  7068			v_2_0_0_0_1 := v_2_0_0_0.Args[1]
  7069			if v_2_0_0_0_1.Op != OpS390XMOVDconst {
  7070				break
  7071			}
  7072			if v_2_0_0_0_1.AuxInt != 0 {
  7073				break
  7074			}
  7075			v.reset(OpS390XADDE)
  7076			v.AddArg(x)
  7077			v.AddArg(y)
  7078			v.AddArg(c)
  7079			return true
  7080		}
  7081		return false
  7082	}
  7083	func rewriteValueS390X_OpS390XADDW_0(v *Value) bool {
  7084		// match: (ADDW x (MOVDconst [c]))
  7085		// cond:
  7086		// result: (ADDWconst [int64(int32(c))] x)
  7087		for {
  7088			_ = v.Args[1]
  7089			x := v.Args[0]
  7090			v_1 := v.Args[1]
  7091			if v_1.Op != OpS390XMOVDconst {
  7092				break
  7093			}
  7094			c := v_1.AuxInt
  7095			v.reset(OpS390XADDWconst)
  7096			v.AuxInt = int64(int32(c))
  7097			v.AddArg(x)
  7098			return true
  7099		}
  7100		// match: (ADDW (MOVDconst [c]) x)
  7101		// cond:
  7102		// result: (ADDWconst [int64(int32(c))] x)
  7103		for {
  7104			x := v.Args[1]
  7105			v_0 := v.Args[0]
  7106			if v_0.Op != OpS390XMOVDconst {
  7107				break
  7108			}
  7109			c := v_0.AuxInt
  7110			v.reset(OpS390XADDWconst)
  7111			v.AuxInt = int64(int32(c))
  7112			v.AddArg(x)
  7113			return true
  7114		}
  7115		// match: (ADDW (SLWconst x [c]) (SRWconst x [d]))
  7116		// cond: d == 32-c
  7117		// result: (RLLconst [c] x)
  7118		for {
  7119			_ = v.Args[1]
  7120			v_0 := v.Args[0]
  7121			if v_0.Op != OpS390XSLWconst {
  7122				break
  7123			}
  7124			c := v_0.AuxInt
  7125			x := v_0.Args[0]
  7126			v_1 := v.Args[1]
  7127			if v_1.Op != OpS390XSRWconst {
  7128				break
  7129			}
  7130			d := v_1.AuxInt
  7131			if x != v_1.Args[0] {
  7132				break
  7133			}
  7134			if !(d == 32-c) {
  7135				break
  7136			}
  7137			v.reset(OpS390XRLLconst)
  7138			v.AuxInt = c
  7139			v.AddArg(x)
  7140			return true
  7141		}
  7142		// match: (ADDW (SRWconst x [d]) (SLWconst x [c]))
  7143		// cond: d == 32-c
  7144		// result: (RLLconst [c] x)
  7145		for {
  7146			_ = v.Args[1]
  7147			v_0 := v.Args[0]
  7148			if v_0.Op != OpS390XSRWconst {
  7149				break
  7150			}
  7151			d := v_0.AuxInt
  7152			x := v_0.Args[0]
  7153			v_1 := v.Args[1]
  7154			if v_1.Op != OpS390XSLWconst {
  7155				break
  7156			}
  7157			c := v_1.AuxInt
  7158			if x != v_1.Args[0] {
  7159				break
  7160			}
  7161			if !(d == 32-c) {
  7162				break
  7163			}
  7164			v.reset(OpS390XRLLconst)
  7165			v.AuxInt = c
  7166			v.AddArg(x)
  7167			return true
  7168		}
  7169		// match: (ADDW x (NEGW y))
  7170		// cond:
  7171		// result: (SUBW x y)
  7172		for {
  7173			_ = v.Args[1]
  7174			x := v.Args[0]
  7175			v_1 := v.Args[1]
  7176			if v_1.Op != OpS390XNEGW {
  7177				break
  7178			}
  7179			y := v_1.Args[0]
  7180			v.reset(OpS390XSUBW)
  7181			v.AddArg(x)
  7182			v.AddArg(y)
  7183			return true
  7184		}
  7185		// match: (ADDW (NEGW y) x)
  7186		// cond:
  7187		// result: (SUBW x y)
  7188		for {
  7189			x := v.Args[1]
  7190			v_0 := v.Args[0]
  7191			if v_0.Op != OpS390XNEGW {
  7192				break
  7193			}
  7194			y := v_0.Args[0]
  7195			v.reset(OpS390XSUBW)
  7196			v.AddArg(x)
  7197			v.AddArg(y)
  7198			return true
  7199		}
  7200		// match: (ADDW <t> x g:(MOVWload [off] {sym} ptr mem))
  7201		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  7202		// result: (ADDWload <t> [off] {sym} x ptr mem)
  7203		for {
  7204			t := v.Type
  7205			_ = v.Args[1]
  7206			x := v.Args[0]
  7207			g := v.Args[1]
  7208			if g.Op != OpS390XMOVWload {
  7209				break
  7210			}
  7211			off := g.AuxInt
  7212			sym := g.Aux
  7213			mem := g.Args[1]
  7214			ptr := g.Args[0]
  7215			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  7216				break
  7217			}
  7218			v.reset(OpS390XADDWload)
  7219			v.Type = t
  7220			v.AuxInt = off
  7221			v.Aux = sym
  7222			v.AddArg(x)
  7223			v.AddArg(ptr)
  7224			v.AddArg(mem)
  7225			return true
  7226		}
  7227		// match: (ADDW <t> g:(MOVWload [off] {sym} ptr mem) x)
  7228		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  7229		// result: (ADDWload <t> [off] {sym} x ptr mem)
  7230		for {
  7231			t := v.Type
  7232			x := v.Args[1]
  7233			g := v.Args[0]
  7234			if g.Op != OpS390XMOVWload {
  7235				break
  7236			}
  7237			off := g.AuxInt
  7238			sym := g.Aux
  7239			mem := g.Args[1]
  7240			ptr := g.Args[0]
  7241			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  7242				break
  7243			}
  7244			v.reset(OpS390XADDWload)
  7245			v.Type = t
  7246			v.AuxInt = off
  7247			v.Aux = sym
  7248			v.AddArg(x)
  7249			v.AddArg(ptr)
  7250			v.AddArg(mem)
  7251			return true
  7252		}
  7253		// match: (ADDW <t> g:(MOVWload [off] {sym} ptr mem) x)
  7254		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  7255		// result: (ADDWload <t> [off] {sym} x ptr mem)
  7256		for {
  7257			t := v.Type
  7258			x := v.Args[1]
  7259			g := v.Args[0]
  7260			if g.Op != OpS390XMOVWload {
  7261				break
  7262			}
  7263			off := g.AuxInt
  7264			sym := g.Aux
  7265			mem := g.Args[1]
  7266			ptr := g.Args[0]
  7267			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  7268				break
  7269			}
  7270			v.reset(OpS390XADDWload)
  7271			v.Type = t
  7272			v.AuxInt = off
  7273			v.Aux = sym
  7274			v.AddArg(x)
  7275			v.AddArg(ptr)
  7276			v.AddArg(mem)
  7277			return true
  7278		}
  7279		// match: (ADDW <t> x g:(MOVWload [off] {sym} ptr mem))
  7280		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  7281		// result: (ADDWload <t> [off] {sym} x ptr mem)
  7282		for {
  7283			t := v.Type
  7284			_ = v.Args[1]
  7285			x := v.Args[0]
  7286			g := v.Args[1]
  7287			if g.Op != OpS390XMOVWload {
  7288				break
  7289			}
  7290			off := g.AuxInt
  7291			sym := g.Aux
  7292			mem := g.Args[1]
  7293			ptr := g.Args[0]
  7294			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  7295				break
  7296			}
  7297			v.reset(OpS390XADDWload)
  7298			v.Type = t
  7299			v.AuxInt = off
  7300			v.Aux = sym
  7301			v.AddArg(x)
  7302			v.AddArg(ptr)
  7303			v.AddArg(mem)
  7304			return true
  7305		}
  7306		return false
  7307	}
  7308	func rewriteValueS390X_OpS390XADDW_10(v *Value) bool {
  7309		// match: (ADDW <t> x g:(MOVWZload [off] {sym} ptr mem))
  7310		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  7311		// result: (ADDWload <t> [off] {sym} x ptr mem)
  7312		for {
  7313			t := v.Type
  7314			_ = v.Args[1]
  7315			x := v.Args[0]
  7316			g := v.Args[1]
  7317			if g.Op != OpS390XMOVWZload {
  7318				break
  7319			}
  7320			off := g.AuxInt
  7321			sym := g.Aux
  7322			mem := g.Args[1]
  7323			ptr := g.Args[0]
  7324			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  7325				break
  7326			}
  7327			v.reset(OpS390XADDWload)
  7328			v.Type = t
  7329			v.AuxInt = off
  7330			v.Aux = sym
  7331			v.AddArg(x)
  7332			v.AddArg(ptr)
  7333			v.AddArg(mem)
  7334			return true
  7335		}
  7336		// match: (ADDW <t> g:(MOVWZload [off] {sym} ptr mem) x)
  7337		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  7338		// result: (ADDWload <t> [off] {sym} x ptr mem)
  7339		for {
  7340			t := v.Type
  7341			x := v.Args[1]
  7342			g := v.Args[0]
  7343			if g.Op != OpS390XMOVWZload {
  7344				break
  7345			}
  7346			off := g.AuxInt
  7347			sym := g.Aux
  7348			mem := g.Args[1]
  7349			ptr := g.Args[0]
  7350			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  7351				break
  7352			}
  7353			v.reset(OpS390XADDWload)
  7354			v.Type = t
  7355			v.AuxInt = off
  7356			v.Aux = sym
  7357			v.AddArg(x)
  7358			v.AddArg(ptr)
  7359			v.AddArg(mem)
  7360			return true
  7361		}
  7362		// match: (ADDW <t> g:(MOVWZload [off] {sym} ptr mem) x)
  7363		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  7364		// result: (ADDWload <t> [off] {sym} x ptr mem)
  7365		for {
  7366			t := v.Type
  7367			x := v.Args[1]
  7368			g := v.Args[0]
  7369			if g.Op != OpS390XMOVWZload {
  7370				break
  7371			}
  7372			off := g.AuxInt
  7373			sym := g.Aux
  7374			mem := g.Args[1]
  7375			ptr := g.Args[0]
  7376			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  7377				break
  7378			}
  7379			v.reset(OpS390XADDWload)
  7380			v.Type = t
  7381			v.AuxInt = off
  7382			v.Aux = sym
  7383			v.AddArg(x)
  7384			v.AddArg(ptr)
  7385			v.AddArg(mem)
  7386			return true
  7387		}
  7388		// match: (ADDW <t> x g:(MOVWZload [off] {sym} ptr mem))
  7389		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  7390		// result: (ADDWload <t> [off] {sym} x ptr mem)
  7391		for {
  7392			t := v.Type
  7393			_ = v.Args[1]
  7394			x := v.Args[0]
  7395			g := v.Args[1]
  7396			if g.Op != OpS390XMOVWZload {
  7397				break
  7398			}
  7399			off := g.AuxInt
  7400			sym := g.Aux
  7401			mem := g.Args[1]
  7402			ptr := g.Args[0]
  7403			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  7404				break
  7405			}
  7406			v.reset(OpS390XADDWload)
  7407			v.Type = t
  7408			v.AuxInt = off
  7409			v.Aux = sym
  7410			v.AddArg(x)
  7411			v.AddArg(ptr)
  7412			v.AddArg(mem)
  7413			return true
  7414		}
  7415		return false
  7416	}
  7417	func rewriteValueS390X_OpS390XADDWconst_0(v *Value) bool {
  7418		// match: (ADDWconst [c] x)
  7419		// cond: int32(c)==0
  7420		// result: x
  7421		for {
  7422			c := v.AuxInt
  7423			x := v.Args[0]
  7424			if !(int32(c) == 0) {
  7425				break
  7426			}
  7427			v.reset(OpCopy)
  7428			v.Type = x.Type
  7429			v.AddArg(x)
  7430			return true
  7431		}
  7432		// match: (ADDWconst [c] (MOVDconst [d]))
  7433		// cond:
  7434		// result: (MOVDconst [int64(int32(c+d))])
  7435		for {
  7436			c := v.AuxInt
  7437			v_0 := v.Args[0]
  7438			if v_0.Op != OpS390XMOVDconst {
  7439				break
  7440			}
  7441			d := v_0.AuxInt
  7442			v.reset(OpS390XMOVDconst)
  7443			v.AuxInt = int64(int32(c + d))
  7444			return true
  7445		}
  7446		// match: (ADDWconst [c] (ADDWconst [d] x))
  7447		// cond:
  7448		// result: (ADDWconst [int64(int32(c+d))] x)
  7449		for {
  7450			c := v.AuxInt
  7451			v_0 := v.Args[0]
  7452			if v_0.Op != OpS390XADDWconst {
  7453				break
  7454			}
  7455			d := v_0.AuxInt
  7456			x := v_0.Args[0]
  7457			v.reset(OpS390XADDWconst)
  7458			v.AuxInt = int64(int32(c + d))
  7459			v.AddArg(x)
  7460			return true
  7461		}
  7462		return false
  7463	}
  7464	func rewriteValueS390X_OpS390XADDWload_0(v *Value) bool {
  7465		// match: (ADDWload [off1] {sym} x (ADDconst [off2] ptr) mem)
  7466		// cond: ptr.Op != OpSB && is20Bit(off1+off2)
  7467		// result: (ADDWload [off1+off2] {sym} x ptr mem)
  7468		for {
  7469			off1 := v.AuxInt
  7470			sym := v.Aux
  7471			mem := v.Args[2]
  7472			x := v.Args[0]
  7473			v_1 := v.Args[1]
  7474			if v_1.Op != OpS390XADDconst {
  7475				break
  7476			}
  7477			off2 := v_1.AuxInt
  7478			ptr := v_1.Args[0]
  7479			if !(ptr.Op != OpSB && is20Bit(off1+off2)) {
  7480				break
  7481			}
  7482			v.reset(OpS390XADDWload)
  7483			v.AuxInt = off1 + off2
  7484			v.Aux = sym
  7485			v.AddArg(x)
  7486			v.AddArg(ptr)
  7487			v.AddArg(mem)
  7488			return true
  7489		}
  7490		// match: (ADDWload [o1] {s1} x (MOVDaddr [o2] {s2} ptr) mem)
  7491		// cond: ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)
  7492		// result: (ADDWload [o1+o2] {mergeSym(s1, s2)} x ptr mem)
  7493		for {
  7494			o1 := v.AuxInt
  7495			s1 := v.Aux
  7496			mem := v.Args[2]
  7497			x := v.Args[0]
  7498			v_1 := v.Args[1]
  7499			if v_1.Op != OpS390XMOVDaddr {
  7500				break
  7501			}
  7502			o2 := v_1.AuxInt
  7503			s2 := v_1.Aux
  7504			ptr := v_1.Args[0]
  7505			if !(ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)) {
  7506				break
  7507			}
  7508			v.reset(OpS390XADDWload)
  7509			v.AuxInt = o1 + o2
  7510			v.Aux = mergeSym(s1, s2)
  7511			v.AddArg(x)
  7512			v.AddArg(ptr)
  7513			v.AddArg(mem)
  7514			return true
  7515		}
  7516		return false
  7517	}
  7518	func rewriteValueS390X_OpS390XADDconst_0(v *Value) bool {
  7519		// match: (ADDconst [c] (MOVDaddr [d] {s} x:(SB)))
  7520		// cond: ((c+d)&1 == 0) && is32Bit(c+d)
  7521		// result: (MOVDaddr [c+d] {s} x)
  7522		for {
  7523			c := v.AuxInt
  7524			v_0 := v.Args[0]
  7525			if v_0.Op != OpS390XMOVDaddr {
  7526				break
  7527			}
  7528			d := v_0.AuxInt
  7529			s := v_0.Aux
  7530			x := v_0.Args[0]
  7531			if x.Op != OpSB {
  7532				break
  7533			}
  7534			if !(((c+d)&1 == 0) && is32Bit(c+d)) {
  7535				break
  7536			}
  7537			v.reset(OpS390XMOVDaddr)
  7538			v.AuxInt = c + d
  7539			v.Aux = s
  7540			v.AddArg(x)
  7541			return true
  7542		}
  7543		// match: (ADDconst [c] (MOVDaddr [d] {s} x))
  7544		// cond: x.Op != OpSB && is20Bit(c+d)
  7545		// result: (MOVDaddr [c+d] {s} x)
  7546		for {
  7547			c := v.AuxInt
  7548			v_0 := v.Args[0]
  7549			if v_0.Op != OpS390XMOVDaddr {
  7550				break
  7551			}
  7552			d := v_0.AuxInt
  7553			s := v_0.Aux
  7554			x := v_0.Args[0]
  7555			if !(x.Op != OpSB && is20Bit(c+d)) {
  7556				break
  7557			}
  7558			v.reset(OpS390XMOVDaddr)
  7559			v.AuxInt = c + d
  7560			v.Aux = s
  7561			v.AddArg(x)
  7562			return true
  7563		}
  7564		// match: (ADDconst [c] (MOVDaddridx [d] {s} x y))
  7565		// cond: is20Bit(c+d)
  7566		// result: (MOVDaddridx [c+d] {s} x y)
  7567		for {
  7568			c := v.AuxInt
  7569			v_0 := v.Args[0]
  7570			if v_0.Op != OpS390XMOVDaddridx {
  7571				break
  7572			}
  7573			d := v_0.AuxInt
  7574			s := v_0.Aux
  7575			y := v_0.Args[1]
  7576			x := v_0.Args[0]
  7577			if !(is20Bit(c + d)) {
  7578				break
  7579			}
  7580			v.reset(OpS390XMOVDaddridx)
  7581			v.AuxInt = c + d
  7582			v.Aux = s
  7583			v.AddArg(x)
  7584			v.AddArg(y)
  7585			return true
  7586		}
  7587		// match: (ADDconst [0] x)
  7588		// cond:
  7589		// result: x
  7590		for {
  7591			if v.AuxInt != 0 {
  7592				break
  7593			}
  7594			x := v.Args[0]
  7595			v.reset(OpCopy)
  7596			v.Type = x.Type
  7597			v.AddArg(x)
  7598			return true
  7599		}
  7600		// match: (ADDconst [c] (MOVDconst [d]))
  7601		// cond:
  7602		// result: (MOVDconst [c+d])
  7603		for {
  7604			c := v.AuxInt
  7605			v_0 := v.Args[0]
  7606			if v_0.Op != OpS390XMOVDconst {
  7607				break
  7608			}
  7609			d := v_0.AuxInt
  7610			v.reset(OpS390XMOVDconst)
  7611			v.AuxInt = c + d
  7612			return true
  7613		}
  7614		// match: (ADDconst [c] (ADDconst [d] x))
  7615		// cond: is32Bit(c+d)
  7616		// result: (ADDconst [c+d] x)
  7617		for {
  7618			c := v.AuxInt
  7619			v_0 := v.Args[0]
  7620			if v_0.Op != OpS390XADDconst {
  7621				break
  7622			}
  7623			d := v_0.AuxInt
  7624			x := v_0.Args[0]
  7625			if !(is32Bit(c + d)) {
  7626				break
  7627			}
  7628			v.reset(OpS390XADDconst)
  7629			v.AuxInt = c + d
  7630			v.AddArg(x)
  7631			return true
  7632		}
  7633		return false
  7634	}
  7635	func rewriteValueS390X_OpS390XADDload_0(v *Value) bool {
  7636		b := v.Block
  7637		// match: (ADDload <t> [off] {sym} x ptr1 (FMOVDstore [off] {sym} ptr2 y _))
  7638		// cond: isSamePtr(ptr1, ptr2)
  7639		// result: (ADD x (LGDR <t> y))
  7640		for {
  7641			t := v.Type
  7642			off := v.AuxInt
  7643			sym := v.Aux
  7644			_ = v.Args[2]
  7645			x := v.Args[0]
  7646			ptr1 := v.Args[1]
  7647			v_2 := v.Args[2]
  7648			if v_2.Op != OpS390XFMOVDstore {
  7649				break
  7650			}
  7651			if v_2.AuxInt != off {
  7652				break
  7653			}
  7654			if v_2.Aux != sym {
  7655				break
  7656			}
  7657			_ = v_2.Args[2]
  7658			ptr2 := v_2.Args[0]
  7659			y := v_2.Args[1]
  7660			if !(isSamePtr(ptr1, ptr2)) {
  7661				break
  7662			}
  7663			v.reset(OpS390XADD)
  7664			v.AddArg(x)
  7665			v0 := b.NewValue0(v_2.Pos, OpS390XLGDR, t)
  7666			v0.AddArg(y)
  7667			v.AddArg(v0)
  7668			return true
  7669		}
  7670		// match: (ADDload [off1] {sym} x (ADDconst [off2] ptr) mem)
  7671		// cond: ptr.Op != OpSB && is20Bit(off1+off2)
  7672		// result: (ADDload [off1+off2] {sym} x ptr mem)
  7673		for {
  7674			off1 := v.AuxInt
  7675			sym := v.Aux
  7676			mem := v.Args[2]
  7677			x := v.Args[0]
  7678			v_1 := v.Args[1]
  7679			if v_1.Op != OpS390XADDconst {
  7680				break
  7681			}
  7682			off2 := v_1.AuxInt
  7683			ptr := v_1.Args[0]
  7684			if !(ptr.Op != OpSB && is20Bit(off1+off2)) {
  7685				break
  7686			}
  7687			v.reset(OpS390XADDload)
  7688			v.AuxInt = off1 + off2
  7689			v.Aux = sym
  7690			v.AddArg(x)
  7691			v.AddArg(ptr)
  7692			v.AddArg(mem)
  7693			return true
  7694		}
  7695		// match: (ADDload [o1] {s1} x (MOVDaddr [o2] {s2} ptr) mem)
  7696		// cond: ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)
  7697		// result: (ADDload [o1+o2] {mergeSym(s1, s2)} x ptr mem)
  7698		for {
  7699			o1 := v.AuxInt
  7700			s1 := v.Aux
  7701			mem := v.Args[2]
  7702			x := v.Args[0]
  7703			v_1 := v.Args[1]
  7704			if v_1.Op != OpS390XMOVDaddr {
  7705				break
  7706			}
  7707			o2 := v_1.AuxInt
  7708			s2 := v_1.Aux
  7709			ptr := v_1.Args[0]
  7710			if !(ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)) {
  7711				break
  7712			}
  7713			v.reset(OpS390XADDload)
  7714			v.AuxInt = o1 + o2
  7715			v.Aux = mergeSym(s1, s2)
  7716			v.AddArg(x)
  7717			v.AddArg(ptr)
  7718			v.AddArg(mem)
  7719			return true
  7720		}
  7721		return false
  7722	}
  7723	func rewriteValueS390X_OpS390XAND_0(v *Value) bool {
  7724		b := v.Block
  7725		typ := &b.Func.Config.Types
  7726		// match: (AND x (MOVDconst [c]))
  7727		// cond: is32Bit(c) && c < 0
  7728		// result: (ANDconst [c] x)
  7729		for {
  7730			_ = v.Args[1]
  7731			x := v.Args[0]
  7732			v_1 := v.Args[1]
  7733			if v_1.Op != OpS390XMOVDconst {
  7734				break
  7735			}
  7736			c := v_1.AuxInt
  7737			if !(is32Bit(c) && c < 0) {
  7738				break
  7739			}
  7740			v.reset(OpS390XANDconst)
  7741			v.AuxInt = c
  7742			v.AddArg(x)
  7743			return true
  7744		}
  7745		// match: (AND (MOVDconst [c]) x)
  7746		// cond: is32Bit(c) && c < 0
  7747		// result: (ANDconst [c] x)
  7748		for {
  7749			x := v.Args[1]
  7750			v_0 := v.Args[0]
  7751			if v_0.Op != OpS390XMOVDconst {
  7752				break
  7753			}
  7754			c := v_0.AuxInt
  7755			if !(is32Bit(c) && c < 0) {
  7756				break
  7757			}
  7758			v.reset(OpS390XANDconst)
  7759			v.AuxInt = c
  7760			v.AddArg(x)
  7761			return true
  7762		}
  7763		// match: (AND x (MOVDconst [c]))
  7764		// cond: is32Bit(c) && c >= 0
  7765		// result: (MOVWZreg (ANDWconst <typ.UInt32> [int64(int32(c))] x))
  7766		for {
  7767			_ = v.Args[1]
  7768			x := v.Args[0]
  7769			v_1 := v.Args[1]
  7770			if v_1.Op != OpS390XMOVDconst {
  7771				break
  7772			}
  7773			c := v_1.AuxInt
  7774			if !(is32Bit(c) && c >= 0) {
  7775				break
  7776			}
  7777			v.reset(OpS390XMOVWZreg)
  7778			v0 := b.NewValue0(v.Pos, OpS390XANDWconst, typ.UInt32)
  7779			v0.AuxInt = int64(int32(c))
  7780			v0.AddArg(x)
  7781			v.AddArg(v0)
  7782			return true
  7783		}
  7784		// match: (AND (MOVDconst [c]) x)
  7785		// cond: is32Bit(c) && c >= 0
  7786		// result: (MOVWZreg (ANDWconst <typ.UInt32> [int64(int32(c))] x))
  7787		for {
  7788			x := v.Args[1]
  7789			v_0 := v.Args[0]
  7790			if v_0.Op != OpS390XMOVDconst {
  7791				break
  7792			}
  7793			c := v_0.AuxInt
  7794			if !(is32Bit(c) && c >= 0) {
  7795				break
  7796			}
  7797			v.reset(OpS390XMOVWZreg)
  7798			v0 := b.NewValue0(v.Pos, OpS390XANDWconst, typ.UInt32)
  7799			v0.AuxInt = int64(int32(c))
  7800			v0.AddArg(x)
  7801			v.AddArg(v0)
  7802			return true
  7803		}
  7804		// match: (AND x (MOVDconst [0xFF]))
  7805		// cond:
  7806		// result: (MOVBZreg x)
  7807		for {
  7808			_ = v.Args[1]
  7809			x := v.Args[0]
  7810			v_1 := v.Args[1]
  7811			if v_1.Op != OpS390XMOVDconst {
  7812				break
  7813			}
  7814			if v_1.AuxInt != 0xFF {
  7815				break
  7816			}
  7817			v.reset(OpS390XMOVBZreg)
  7818			v.AddArg(x)
  7819			return true
  7820		}
  7821		// match: (AND (MOVDconst [0xFF]) x)
  7822		// cond:
  7823		// result: (MOVBZreg x)
  7824		for {
  7825			x := v.Args[1]
  7826			v_0 := v.Args[0]
  7827			if v_0.Op != OpS390XMOVDconst {
  7828				break
  7829			}
  7830			if v_0.AuxInt != 0xFF {
  7831				break
  7832			}
  7833			v.reset(OpS390XMOVBZreg)
  7834			v.AddArg(x)
  7835			return true
  7836		}
  7837		// match: (AND x (MOVDconst [0xFFFF]))
  7838		// cond:
  7839		// result: (MOVHZreg x)
  7840		for {
  7841			_ = v.Args[1]
  7842			x := v.Args[0]
  7843			v_1 := v.Args[1]
  7844			if v_1.Op != OpS390XMOVDconst {
  7845				break
  7846			}
  7847			if v_1.AuxInt != 0xFFFF {
  7848				break
  7849			}
  7850			v.reset(OpS390XMOVHZreg)
  7851			v.AddArg(x)
  7852			return true
  7853		}
  7854		// match: (AND (MOVDconst [0xFFFF]) x)
  7855		// cond:
  7856		// result: (MOVHZreg x)
  7857		for {
  7858			x := v.Args[1]
  7859			v_0 := v.Args[0]
  7860			if v_0.Op != OpS390XMOVDconst {
  7861				break
  7862			}
  7863			if v_0.AuxInt != 0xFFFF {
  7864				break
  7865			}
  7866			v.reset(OpS390XMOVHZreg)
  7867			v.AddArg(x)
  7868			return true
  7869		}
  7870		// match: (AND x (MOVDconst [0xFFFFFFFF]))
  7871		// cond:
  7872		// result: (MOVWZreg x)
  7873		for {
  7874			_ = v.Args[1]
  7875			x := v.Args[0]
  7876			v_1 := v.Args[1]
  7877			if v_1.Op != OpS390XMOVDconst {
  7878				break
  7879			}
  7880			if v_1.AuxInt != 0xFFFFFFFF {
  7881				break
  7882			}
  7883			v.reset(OpS390XMOVWZreg)
  7884			v.AddArg(x)
  7885			return true
  7886		}
  7887		// match: (AND (MOVDconst [0xFFFFFFFF]) x)
  7888		// cond:
  7889		// result: (MOVWZreg x)
  7890		for {
  7891			x := v.Args[1]
  7892			v_0 := v.Args[0]
  7893			if v_0.Op != OpS390XMOVDconst {
  7894				break
  7895			}
  7896			if v_0.AuxInt != 0xFFFFFFFF {
  7897				break
  7898			}
  7899			v.reset(OpS390XMOVWZreg)
  7900			v.AddArg(x)
  7901			return true
  7902		}
  7903		return false
  7904	}
  7905	func rewriteValueS390X_OpS390XAND_10(v *Value) bool {
  7906		// match: (AND (MOVDconst [c]) (MOVDconst [d]))
  7907		// cond:
  7908		// result: (MOVDconst [c&d])
  7909		for {
  7910			_ = v.Args[1]
  7911			v_0 := v.Args[0]
  7912			if v_0.Op != OpS390XMOVDconst {
  7913				break
  7914			}
  7915			c := v_0.AuxInt
  7916			v_1 := v.Args[1]
  7917			if v_1.Op != OpS390XMOVDconst {
  7918				break
  7919			}
  7920			d := v_1.AuxInt
  7921			v.reset(OpS390XMOVDconst)
  7922			v.AuxInt = c & d
  7923			return true
  7924		}
  7925		// match: (AND (MOVDconst [d]) (MOVDconst [c]))
  7926		// cond:
  7927		// result: (MOVDconst [c&d])
  7928		for {
  7929			_ = v.Args[1]
  7930			v_0 := v.Args[0]
  7931			if v_0.Op != OpS390XMOVDconst {
  7932				break
  7933			}
  7934			d := v_0.AuxInt
  7935			v_1 := v.Args[1]
  7936			if v_1.Op != OpS390XMOVDconst {
  7937				break
  7938			}
  7939			c := v_1.AuxInt
  7940			v.reset(OpS390XMOVDconst)
  7941			v.AuxInt = c & d
  7942			return true
  7943		}
  7944		// match: (AND x x)
  7945		// cond:
  7946		// result: x
  7947		for {
  7948			x := v.Args[1]
  7949			if x != v.Args[0] {
  7950				break
  7951			}
  7952			v.reset(OpCopy)
  7953			v.Type = x.Type
  7954			v.AddArg(x)
  7955			return true
  7956		}
  7957		// match: (AND <t> x g:(MOVDload [off] {sym} ptr mem))
  7958		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  7959		// result: (ANDload <t> [off] {sym} x ptr mem)
  7960		for {
  7961			t := v.Type
  7962			_ = v.Args[1]
  7963			x := v.Args[0]
  7964			g := v.Args[1]
  7965			if g.Op != OpS390XMOVDload {
  7966				break
  7967			}
  7968			off := g.AuxInt
  7969			sym := g.Aux
  7970			mem := g.Args[1]
  7971			ptr := g.Args[0]
  7972			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  7973				break
  7974			}
  7975			v.reset(OpS390XANDload)
  7976			v.Type = t
  7977			v.AuxInt = off
  7978			v.Aux = sym
  7979			v.AddArg(x)
  7980			v.AddArg(ptr)
  7981			v.AddArg(mem)
  7982			return true
  7983		}
  7984		// match: (AND <t> g:(MOVDload [off] {sym} ptr mem) x)
  7985		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  7986		// result: (ANDload <t> [off] {sym} x ptr mem)
  7987		for {
  7988			t := v.Type
  7989			x := v.Args[1]
  7990			g := v.Args[0]
  7991			if g.Op != OpS390XMOVDload {
  7992				break
  7993			}
  7994			off := g.AuxInt
  7995			sym := g.Aux
  7996			mem := g.Args[1]
  7997			ptr := g.Args[0]
  7998			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  7999				break
  8000			}
  8001			v.reset(OpS390XANDload)
  8002			v.Type = t
  8003			v.AuxInt = off
  8004			v.Aux = sym
  8005			v.AddArg(x)
  8006			v.AddArg(ptr)
  8007			v.AddArg(mem)
  8008			return true
  8009		}
  8010		// match: (AND <t> g:(MOVDload [off] {sym} ptr mem) x)
  8011		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  8012		// result: (ANDload <t> [off] {sym} x ptr mem)
  8013		for {
  8014			t := v.Type
  8015			x := v.Args[1]
  8016			g := v.Args[0]
  8017			if g.Op != OpS390XMOVDload {
  8018				break
  8019			}
  8020			off := g.AuxInt
  8021			sym := g.Aux
  8022			mem := g.Args[1]
  8023			ptr := g.Args[0]
  8024			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  8025				break
  8026			}
  8027			v.reset(OpS390XANDload)
  8028			v.Type = t
  8029			v.AuxInt = off
  8030			v.Aux = sym
  8031			v.AddArg(x)
  8032			v.AddArg(ptr)
  8033			v.AddArg(mem)
  8034			return true
  8035		}
  8036		// match: (AND <t> x g:(MOVDload [off] {sym} ptr mem))
  8037		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  8038		// result: (ANDload <t> [off] {sym} x ptr mem)
  8039		for {
  8040			t := v.Type
  8041			_ = v.Args[1]
  8042			x := v.Args[0]
  8043			g := v.Args[1]
  8044			if g.Op != OpS390XMOVDload {
  8045				break
  8046			}
  8047			off := g.AuxInt
  8048			sym := g.Aux
  8049			mem := g.Args[1]
  8050			ptr := g.Args[0]
  8051			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  8052				break
  8053			}
  8054			v.reset(OpS390XANDload)
  8055			v.Type = t
  8056			v.AuxInt = off
  8057			v.Aux = sym
  8058			v.AddArg(x)
  8059			v.AddArg(ptr)
  8060			v.AddArg(mem)
  8061			return true
  8062		}
  8063		return false
  8064	}
  8065	func rewriteValueS390X_OpS390XANDW_0(v *Value) bool {
  8066		// match: (ANDW x (MOVDconst [c]))
  8067		// cond:
  8068		// result: (ANDWconst [int64(int32(c))] x)
  8069		for {
  8070			_ = v.Args[1]
  8071			x := v.Args[0]
  8072			v_1 := v.Args[1]
  8073			if v_1.Op != OpS390XMOVDconst {
  8074				break
  8075			}
  8076			c := v_1.AuxInt
  8077			v.reset(OpS390XANDWconst)
  8078			v.AuxInt = int64(int32(c))
  8079			v.AddArg(x)
  8080			return true
  8081		}
  8082		// match: (ANDW (MOVDconst [c]) x)
  8083		// cond:
  8084		// result: (ANDWconst [int64(int32(c))] x)
  8085		for {
  8086			x := v.Args[1]
  8087			v_0 := v.Args[0]
  8088			if v_0.Op != OpS390XMOVDconst {
  8089				break
  8090			}
  8091			c := v_0.AuxInt
  8092			v.reset(OpS390XANDWconst)
  8093			v.AuxInt = int64(int32(c))
  8094			v.AddArg(x)
  8095			return true
  8096		}
  8097		// match: (ANDW x x)
  8098		// cond:
  8099		// result: x
  8100		for {
  8101			x := v.Args[1]
  8102			if x != v.Args[0] {
  8103				break
  8104			}
  8105			v.reset(OpCopy)
  8106			v.Type = x.Type
  8107			v.AddArg(x)
  8108			return true
  8109		}
  8110		// match: (ANDW <t> x g:(MOVWload [off] {sym} ptr mem))
  8111		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  8112		// result: (ANDWload <t> [off] {sym} x ptr mem)
  8113		for {
  8114			t := v.Type
  8115			_ = v.Args[1]
  8116			x := v.Args[0]
  8117			g := v.Args[1]
  8118			if g.Op != OpS390XMOVWload {
  8119				break
  8120			}
  8121			off := g.AuxInt
  8122			sym := g.Aux
  8123			mem := g.Args[1]
  8124			ptr := g.Args[0]
  8125			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  8126				break
  8127			}
  8128			v.reset(OpS390XANDWload)
  8129			v.Type = t
  8130			v.AuxInt = off
  8131			v.Aux = sym
  8132			v.AddArg(x)
  8133			v.AddArg(ptr)
  8134			v.AddArg(mem)
  8135			return true
  8136		}
  8137		// match: (ANDW <t> g:(MOVWload [off] {sym} ptr mem) x)
  8138		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  8139		// result: (ANDWload <t> [off] {sym} x ptr mem)
  8140		for {
  8141			t := v.Type
  8142			x := v.Args[1]
  8143			g := v.Args[0]
  8144			if g.Op != OpS390XMOVWload {
  8145				break
  8146			}
  8147			off := g.AuxInt
  8148			sym := g.Aux
  8149			mem := g.Args[1]
  8150			ptr := g.Args[0]
  8151			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  8152				break
  8153			}
  8154			v.reset(OpS390XANDWload)
  8155			v.Type = t
  8156			v.AuxInt = off
  8157			v.Aux = sym
  8158			v.AddArg(x)
  8159			v.AddArg(ptr)
  8160			v.AddArg(mem)
  8161			return true
  8162		}
  8163		// match: (ANDW <t> g:(MOVWload [off] {sym} ptr mem) x)
  8164		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  8165		// result: (ANDWload <t> [off] {sym} x ptr mem)
  8166		for {
  8167			t := v.Type
  8168			x := v.Args[1]
  8169			g := v.Args[0]
  8170			if g.Op != OpS390XMOVWload {
  8171				break
  8172			}
  8173			off := g.AuxInt
  8174			sym := g.Aux
  8175			mem := g.Args[1]
  8176			ptr := g.Args[0]
  8177			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  8178				break
  8179			}
  8180			v.reset(OpS390XANDWload)
  8181			v.Type = t
  8182			v.AuxInt = off
  8183			v.Aux = sym
  8184			v.AddArg(x)
  8185			v.AddArg(ptr)
  8186			v.AddArg(mem)
  8187			return true
  8188		}
  8189		// match: (ANDW <t> x g:(MOVWload [off] {sym} ptr mem))
  8190		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  8191		// result: (ANDWload <t> [off] {sym} x ptr mem)
  8192		for {
  8193			t := v.Type
  8194			_ = v.Args[1]
  8195			x := v.Args[0]
  8196			g := v.Args[1]
  8197			if g.Op != OpS390XMOVWload {
  8198				break
  8199			}
  8200			off := g.AuxInt
  8201			sym := g.Aux
  8202			mem := g.Args[1]
  8203			ptr := g.Args[0]
  8204			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  8205				break
  8206			}
  8207			v.reset(OpS390XANDWload)
  8208			v.Type = t
  8209			v.AuxInt = off
  8210			v.Aux = sym
  8211			v.AddArg(x)
  8212			v.AddArg(ptr)
  8213			v.AddArg(mem)
  8214			return true
  8215		}
  8216		// match: (ANDW <t> x g:(MOVWZload [off] {sym} ptr mem))
  8217		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  8218		// result: (ANDWload <t> [off] {sym} x ptr mem)
  8219		for {
  8220			t := v.Type
  8221			_ = v.Args[1]
  8222			x := v.Args[0]
  8223			g := v.Args[1]
  8224			if g.Op != OpS390XMOVWZload {
  8225				break
  8226			}
  8227			off := g.AuxInt
  8228			sym := g.Aux
  8229			mem := g.Args[1]
  8230			ptr := g.Args[0]
  8231			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  8232				break
  8233			}
  8234			v.reset(OpS390XANDWload)
  8235			v.Type = t
  8236			v.AuxInt = off
  8237			v.Aux = sym
  8238			v.AddArg(x)
  8239			v.AddArg(ptr)
  8240			v.AddArg(mem)
  8241			return true
  8242		}
  8243		// match: (ANDW <t> g:(MOVWZload [off] {sym} ptr mem) x)
  8244		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  8245		// result: (ANDWload <t> [off] {sym} x ptr mem)
  8246		for {
  8247			t := v.Type
  8248			x := v.Args[1]
  8249			g := v.Args[0]
  8250			if g.Op != OpS390XMOVWZload {
  8251				break
  8252			}
  8253			off := g.AuxInt
  8254			sym := g.Aux
  8255			mem := g.Args[1]
  8256			ptr := g.Args[0]
  8257			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  8258				break
  8259			}
  8260			v.reset(OpS390XANDWload)
  8261			v.Type = t
  8262			v.AuxInt = off
  8263			v.Aux = sym
  8264			v.AddArg(x)
  8265			v.AddArg(ptr)
  8266			v.AddArg(mem)
  8267			return true
  8268		}
  8269		// match: (ANDW <t> g:(MOVWZload [off] {sym} ptr mem) x)
  8270		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  8271		// result: (ANDWload <t> [off] {sym} x ptr mem)
  8272		for {
  8273			t := v.Type
  8274			x := v.Args[1]
  8275			g := v.Args[0]
  8276			if g.Op != OpS390XMOVWZload {
  8277				break
  8278			}
  8279			off := g.AuxInt
  8280			sym := g.Aux
  8281			mem := g.Args[1]
  8282			ptr := g.Args[0]
  8283			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  8284				break
  8285			}
  8286			v.reset(OpS390XANDWload)
  8287			v.Type = t
  8288			v.AuxInt = off
  8289			v.Aux = sym
  8290			v.AddArg(x)
  8291			v.AddArg(ptr)
  8292			v.AddArg(mem)
  8293			return true
  8294		}
  8295		return false
  8296	}
  8297	func rewriteValueS390X_OpS390XANDW_10(v *Value) bool {
  8298		// match: (ANDW <t> x g:(MOVWZload [off] {sym} ptr mem))
  8299		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  8300		// result: (ANDWload <t> [off] {sym} x ptr mem)
  8301		for {
  8302			t := v.Type
  8303			_ = v.Args[1]
  8304			x := v.Args[0]
  8305			g := v.Args[1]
  8306			if g.Op != OpS390XMOVWZload {
  8307				break
  8308			}
  8309			off := g.AuxInt
  8310			sym := g.Aux
  8311			mem := g.Args[1]
  8312			ptr := g.Args[0]
  8313			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  8314				break
  8315			}
  8316			v.reset(OpS390XANDWload)
  8317			v.Type = t
  8318			v.AuxInt = off
  8319			v.Aux = sym
  8320			v.AddArg(x)
  8321			v.AddArg(ptr)
  8322			v.AddArg(mem)
  8323			return true
  8324		}
  8325		return false
  8326	}
  8327	func rewriteValueS390X_OpS390XANDWconst_0(v *Value) bool {
  8328		// match: (ANDWconst [c] (ANDWconst [d] x))
  8329		// cond:
  8330		// result: (ANDWconst [c & d] x)
  8331		for {
  8332			c := v.AuxInt
  8333			v_0 := v.Args[0]
  8334			if v_0.Op != OpS390XANDWconst {
  8335				break
  8336			}
  8337			d := v_0.AuxInt
  8338			x := v_0.Args[0]
  8339			v.reset(OpS390XANDWconst)
  8340			v.AuxInt = c & d
  8341			v.AddArg(x)
  8342			return true
  8343		}
  8344		// match: (ANDWconst [0xFF] x)
  8345		// cond:
  8346		// result: (MOVBZreg x)
  8347		for {
  8348			if v.AuxInt != 0xFF {
  8349				break
  8350			}
  8351			x := v.Args[0]
  8352			v.reset(OpS390XMOVBZreg)
  8353			v.AddArg(x)
  8354			return true
  8355		}
  8356		// match: (ANDWconst [0xFFFF] x)
  8357		// cond:
  8358		// result: (MOVHZreg x)
  8359		for {
  8360			if v.AuxInt != 0xFFFF {
  8361				break
  8362			}
  8363			x := v.Args[0]
  8364			v.reset(OpS390XMOVHZreg)
  8365			v.AddArg(x)
  8366			return true
  8367		}
  8368		// match: (ANDWconst [c] _)
  8369		// cond: int32(c)==0
  8370		// result: (MOVDconst [0])
  8371		for {
  8372			c := v.AuxInt
  8373			if !(int32(c) == 0) {
  8374				break
  8375			}
  8376			v.reset(OpS390XMOVDconst)
  8377			v.AuxInt = 0
  8378			return true
  8379		}
  8380		// match: (ANDWconst [c] x)
  8381		// cond: int32(c)==-1
  8382		// result: x
  8383		for {
  8384			c := v.AuxInt
  8385			x := v.Args[0]
  8386			if !(int32(c) == -1) {
  8387				break
  8388			}
  8389			v.reset(OpCopy)
  8390			v.Type = x.Type
  8391			v.AddArg(x)
  8392			return true
  8393		}
  8394		// match: (ANDWconst [c] (MOVDconst [d]))
  8395		// cond:
  8396		// result: (MOVDconst [c&d])
  8397		for {
  8398			c := v.AuxInt
  8399			v_0 := v.Args[0]
  8400			if v_0.Op != OpS390XMOVDconst {
  8401				break
  8402			}
  8403			d := v_0.AuxInt
  8404			v.reset(OpS390XMOVDconst)
  8405			v.AuxInt = c & d
  8406			return true
  8407		}
  8408		return false
  8409	}
  8410	func rewriteValueS390X_OpS390XANDWload_0(v *Value) bool {
  8411		// match: (ANDWload [off1] {sym} x (ADDconst [off2] ptr) mem)
  8412		// cond: ptr.Op != OpSB && is20Bit(off1+off2)
  8413		// result: (ANDWload [off1+off2] {sym} x ptr mem)
  8414		for {
  8415			off1 := v.AuxInt
  8416			sym := v.Aux
  8417			mem := v.Args[2]
  8418			x := v.Args[0]
  8419			v_1 := v.Args[1]
  8420			if v_1.Op != OpS390XADDconst {
  8421				break
  8422			}
  8423			off2 := v_1.AuxInt
  8424			ptr := v_1.Args[0]
  8425			if !(ptr.Op != OpSB && is20Bit(off1+off2)) {
  8426				break
  8427			}
  8428			v.reset(OpS390XANDWload)
  8429			v.AuxInt = off1 + off2
  8430			v.Aux = sym
  8431			v.AddArg(x)
  8432			v.AddArg(ptr)
  8433			v.AddArg(mem)
  8434			return true
  8435		}
  8436		// match: (ANDWload [o1] {s1} x (MOVDaddr [o2] {s2} ptr) mem)
  8437		// cond: ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)
  8438		// result: (ANDWload [o1+o2] {mergeSym(s1, s2)} x ptr mem)
  8439		for {
  8440			o1 := v.AuxInt
  8441			s1 := v.Aux
  8442			mem := v.Args[2]
  8443			x := v.Args[0]
  8444			v_1 := v.Args[1]
  8445			if v_1.Op != OpS390XMOVDaddr {
  8446				break
  8447			}
  8448			o2 := v_1.AuxInt
  8449			s2 := v_1.Aux
  8450			ptr := v_1.Args[0]
  8451			if !(ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)) {
  8452				break
  8453			}
  8454			v.reset(OpS390XANDWload)
  8455			v.AuxInt = o1 + o2
  8456			v.Aux = mergeSym(s1, s2)
  8457			v.AddArg(x)
  8458			v.AddArg(ptr)
  8459			v.AddArg(mem)
  8460			return true
  8461		}
  8462		return false
  8463	}
  8464	func rewriteValueS390X_OpS390XANDconst_0(v *Value) bool {
  8465		// match: (ANDconst [c] (ANDconst [d] x))
  8466		// cond:
  8467		// result: (ANDconst [c & d] x)
  8468		for {
  8469			c := v.AuxInt
  8470			v_0 := v.Args[0]
  8471			if v_0.Op != OpS390XANDconst {
  8472				break
  8473			}
  8474			d := v_0.AuxInt
  8475			x := v_0.Args[0]
  8476			v.reset(OpS390XANDconst)
  8477			v.AuxInt = c & d
  8478			v.AddArg(x)
  8479			return true
  8480		}
  8481		// match: (ANDconst [0] _)
  8482		// cond:
  8483		// result: (MOVDconst [0])
  8484		for {
  8485			if v.AuxInt != 0 {
  8486				break
  8487			}
  8488			v.reset(OpS390XMOVDconst)
  8489			v.AuxInt = 0
  8490			return true
  8491		}
  8492		// match: (ANDconst [-1] x)
  8493		// cond:
  8494		// result: x
  8495		for {
  8496			if v.AuxInt != -1 {
  8497				break
  8498			}
  8499			x := v.Args[0]
  8500			v.reset(OpCopy)
  8501			v.Type = x.Type
  8502			v.AddArg(x)
  8503			return true
  8504		}
  8505		// match: (ANDconst [c] (MOVDconst [d]))
  8506		// cond:
  8507		// result: (MOVDconst [c&d])
  8508		for {
  8509			c := v.AuxInt
  8510			v_0 := v.Args[0]
  8511			if v_0.Op != OpS390XMOVDconst {
  8512				break
  8513			}
  8514			d := v_0.AuxInt
  8515			v.reset(OpS390XMOVDconst)
  8516			v.AuxInt = c & d
  8517			return true
  8518		}
  8519		return false
  8520	}
  8521	func rewriteValueS390X_OpS390XANDload_0(v *Value) bool {
  8522		b := v.Block
  8523		// match: (ANDload <t> [off] {sym} x ptr1 (FMOVDstore [off] {sym} ptr2 y _))
  8524		// cond: isSamePtr(ptr1, ptr2)
  8525		// result: (AND x (LGDR <t> y))
  8526		for {
  8527			t := v.Type
  8528			off := v.AuxInt
  8529			sym := v.Aux
  8530			_ = v.Args[2]
  8531			x := v.Args[0]
  8532			ptr1 := v.Args[1]
  8533			v_2 := v.Args[2]
  8534			if v_2.Op != OpS390XFMOVDstore {
  8535				break
  8536			}
  8537			if v_2.AuxInt != off {
  8538				break
  8539			}
  8540			if v_2.Aux != sym {
  8541				break
  8542			}
  8543			_ = v_2.Args[2]
  8544			ptr2 := v_2.Args[0]
  8545			y := v_2.Args[1]
  8546			if !(isSamePtr(ptr1, ptr2)) {
  8547				break
  8548			}
  8549			v.reset(OpS390XAND)
  8550			v.AddArg(x)
  8551			v0 := b.NewValue0(v_2.Pos, OpS390XLGDR, t)
  8552			v0.AddArg(y)
  8553			v.AddArg(v0)
  8554			return true
  8555		}
  8556		// match: (ANDload [off1] {sym} x (ADDconst [off2] ptr) mem)
  8557		// cond: ptr.Op != OpSB && is20Bit(off1+off2)
  8558		// result: (ANDload [off1+off2] {sym} x ptr mem)
  8559		for {
  8560			off1 := v.AuxInt
  8561			sym := v.Aux
  8562			mem := v.Args[2]
  8563			x := v.Args[0]
  8564			v_1 := v.Args[1]
  8565			if v_1.Op != OpS390XADDconst {
  8566				break
  8567			}
  8568			off2 := v_1.AuxInt
  8569			ptr := v_1.Args[0]
  8570			if !(ptr.Op != OpSB && is20Bit(off1+off2)) {
  8571				break
  8572			}
  8573			v.reset(OpS390XANDload)
  8574			v.AuxInt = off1 + off2
  8575			v.Aux = sym
  8576			v.AddArg(x)
  8577			v.AddArg(ptr)
  8578			v.AddArg(mem)
  8579			return true
  8580		}
  8581		// match: (ANDload [o1] {s1} x (MOVDaddr [o2] {s2} ptr) mem)
  8582		// cond: ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)
  8583		// result: (ANDload [o1+o2] {mergeSym(s1, s2)} x ptr mem)
  8584		for {
  8585			o1 := v.AuxInt
  8586			s1 := v.Aux
  8587			mem := v.Args[2]
  8588			x := v.Args[0]
  8589			v_1 := v.Args[1]
  8590			if v_1.Op != OpS390XMOVDaddr {
  8591				break
  8592			}
  8593			o2 := v_1.AuxInt
  8594			s2 := v_1.Aux
  8595			ptr := v_1.Args[0]
  8596			if !(ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)) {
  8597				break
  8598			}
  8599			v.reset(OpS390XANDload)
  8600			v.AuxInt = o1 + o2
  8601			v.Aux = mergeSym(s1, s2)
  8602			v.AddArg(x)
  8603			v.AddArg(ptr)
  8604			v.AddArg(mem)
  8605			return true
  8606		}
  8607		return false
  8608	}
  8609	func rewriteValueS390X_OpS390XCMP_0(v *Value) bool {
  8610		b := v.Block
  8611		// match: (CMP x (MOVDconst [c]))
  8612		// cond: is32Bit(c)
  8613		// result: (CMPconst x [c])
  8614		for {
  8615			_ = v.Args[1]
  8616			x := v.Args[0]
  8617			v_1 := v.Args[1]
  8618			if v_1.Op != OpS390XMOVDconst {
  8619				break
  8620			}
  8621			c := v_1.AuxInt
  8622			if !(is32Bit(c)) {
  8623				break
  8624			}
  8625			v.reset(OpS390XCMPconst)
  8626			v.AuxInt = c
  8627			v.AddArg(x)
  8628			return true
  8629		}
  8630		// match: (CMP (MOVDconst [c]) x)
  8631		// cond: is32Bit(c)
  8632		// result: (InvertFlags (CMPconst x [c]))
  8633		for {
  8634			x := v.Args[1]
  8635			v_0 := v.Args[0]
  8636			if v_0.Op != OpS390XMOVDconst {
  8637				break
  8638			}
  8639			c := v_0.AuxInt
  8640			if !(is32Bit(c)) {
  8641				break
  8642			}
  8643			v.reset(OpS390XInvertFlags)
  8644			v0 := b.NewValue0(v.Pos, OpS390XCMPconst, types.TypeFlags)
  8645			v0.AuxInt = c
  8646			v0.AddArg(x)
  8647			v.AddArg(v0)
  8648			return true
  8649		}
  8650		return false
  8651	}
  8652	func rewriteValueS390X_OpS390XCMPU_0(v *Value) bool {
  8653		b := v.Block
  8654		// match: (CMPU x (MOVDconst [c]))
  8655		// cond: isU32Bit(c)
  8656		// result: (CMPUconst x [int64(int32(c))])
  8657		for {
  8658			_ = v.Args[1]
  8659			x := v.Args[0]
  8660			v_1 := v.Args[1]
  8661			if v_1.Op != OpS390XMOVDconst {
  8662				break
  8663			}
  8664			c := v_1.AuxInt
  8665			if !(isU32Bit(c)) {
  8666				break
  8667			}
  8668			v.reset(OpS390XCMPUconst)
  8669			v.AuxInt = int64(int32(c))
  8670			v.AddArg(x)
  8671			return true
  8672		}
  8673		// match: (CMPU (MOVDconst [c]) x)
  8674		// cond: isU32Bit(c)
  8675		// result: (InvertFlags (CMPUconst x [int64(int32(c))]))
  8676		for {
  8677			x := v.Args[1]
  8678			v_0 := v.Args[0]
  8679			if v_0.Op != OpS390XMOVDconst {
  8680				break
  8681			}
  8682			c := v_0.AuxInt
  8683			if !(isU32Bit(c)) {
  8684				break
  8685			}
  8686			v.reset(OpS390XInvertFlags)
  8687			v0 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
  8688			v0.AuxInt = int64(int32(c))
  8689			v0.AddArg(x)
  8690			v.AddArg(v0)
  8691			return true
  8692		}
  8693		return false
  8694	}
  8695	func rewriteValueS390X_OpS390XCMPUconst_0(v *Value) bool {
  8696		// match: (CMPUconst (MOVDconst [x]) [y])
  8697		// cond: uint64(x)==uint64(y)
  8698		// result: (FlagEQ)
  8699		for {
  8700			y := v.AuxInt
  8701			v_0 := v.Args[0]
  8702			if v_0.Op != OpS390XMOVDconst {
  8703				break
  8704			}
  8705			x := v_0.AuxInt
  8706			if !(uint64(x) == uint64(y)) {
  8707				break
  8708			}
  8709			v.reset(OpS390XFlagEQ)
  8710			return true
  8711		}
  8712		// match: (CMPUconst (MOVDconst [x]) [y])
  8713		// cond: uint64(x)<uint64(y)
  8714		// result: (FlagLT)
  8715		for {
  8716			y := v.AuxInt
  8717			v_0 := v.Args[0]
  8718			if v_0.Op != OpS390XMOVDconst {
  8719				break
  8720			}
  8721			x := v_0.AuxInt
  8722			if !(uint64(x) < uint64(y)) {
  8723				break
  8724			}
  8725			v.reset(OpS390XFlagLT)
  8726			return true
  8727		}
  8728		// match: (CMPUconst (MOVDconst [x]) [y])
  8729		// cond: uint64(x)>uint64(y)
  8730		// result: (FlagGT)
  8731		for {
  8732			y := v.AuxInt
  8733			v_0 := v.Args[0]
  8734			if v_0.Op != OpS390XMOVDconst {
  8735				break
  8736			}
  8737			x := v_0.AuxInt
  8738			if !(uint64(x) > uint64(y)) {
  8739				break
  8740			}
  8741			v.reset(OpS390XFlagGT)
  8742			return true
  8743		}
  8744		// match: (CMPUconst (SRDconst _ [c]) [n])
  8745		// cond: c > 0 && c < 64 && (1<<uint(64-c)) <= uint64(n)
  8746		// result: (FlagLT)
  8747		for {
  8748			n := v.AuxInt
  8749			v_0 := v.Args[0]
  8750			if v_0.Op != OpS390XSRDconst {
  8751				break
  8752			}
  8753			c := v_0.AuxInt
  8754			if !(c > 0 && c < 64 && (1<<uint(64-c)) <= uint64(n)) {
  8755				break
  8756			}
  8757			v.reset(OpS390XFlagLT)
  8758			return true
  8759		}
  8760		// match: (CMPUconst (MOVWZreg x) [c])
  8761		// cond:
  8762		// result: (CMPWUconst x [c])
  8763		for {
  8764			c := v.AuxInt
  8765			v_0 := v.Args[0]
  8766			if v_0.Op != OpS390XMOVWZreg {
  8767				break
  8768			}
  8769			x := v_0.Args[0]
  8770			v.reset(OpS390XCMPWUconst)
  8771			v.AuxInt = c
  8772			v.AddArg(x)
  8773			return true
  8774		}
  8775		// match: (CMPUconst x:(MOVHreg _) [c])
  8776		// cond:
  8777		// result: (CMPWUconst x [c])
  8778		for {
  8779			c := v.AuxInt
  8780			x := v.Args[0]
  8781			if x.Op != OpS390XMOVHreg {
  8782				break
  8783			}
  8784			v.reset(OpS390XCMPWUconst)
  8785			v.AuxInt = c
  8786			v.AddArg(x)
  8787			return true
  8788		}
  8789		// match: (CMPUconst x:(MOVHZreg _) [c])
  8790		// cond:
  8791		// result: (CMPWUconst x [c])
  8792		for {
  8793			c := v.AuxInt
  8794			x := v.Args[0]
  8795			if x.Op != OpS390XMOVHZreg {
  8796				break
  8797			}
  8798			v.reset(OpS390XCMPWUconst)
  8799			v.AuxInt = c
  8800			v.AddArg(x)
  8801			return true
  8802		}
  8803		// match: (CMPUconst x:(MOVBreg _) [c])
  8804		// cond:
  8805		// result: (CMPWUconst x [c])
  8806		for {
  8807			c := v.AuxInt
  8808			x := v.Args[0]
  8809			if x.Op != OpS390XMOVBreg {
  8810				break
  8811			}
  8812			v.reset(OpS390XCMPWUconst)
  8813			v.AuxInt = c
  8814			v.AddArg(x)
  8815			return true
  8816		}
  8817		// match: (CMPUconst x:(MOVBZreg _) [c])
  8818		// cond:
  8819		// result: (CMPWUconst x [c])
  8820		for {
  8821			c := v.AuxInt
  8822			x := v.Args[0]
  8823			if x.Op != OpS390XMOVBZreg {
  8824				break
  8825			}
  8826			v.reset(OpS390XCMPWUconst)
  8827			v.AuxInt = c
  8828			v.AddArg(x)
  8829			return true
  8830		}
  8831		// match: (CMPUconst (MOVWZreg x:(ANDWconst [m] _)) [c])
  8832		// cond: int32(m) >= 0
  8833		// result: (CMPWUconst x [c])
  8834		for {
  8835			c := v.AuxInt
  8836			v_0 := v.Args[0]
  8837			if v_0.Op != OpS390XMOVWZreg {
  8838				break
  8839			}
  8840			x := v_0.Args[0]
  8841			if x.Op != OpS390XANDWconst {
  8842				break
  8843			}
  8844			m := x.AuxInt
  8845			if !(int32(m) >= 0) {
  8846				break
  8847			}
  8848			v.reset(OpS390XCMPWUconst)
  8849			v.AuxInt = c
  8850			v.AddArg(x)
  8851			return true
  8852		}
  8853		return false
  8854	}
  8855	func rewriteValueS390X_OpS390XCMPUconst_10(v *Value) bool {
  8856		// match: (CMPUconst (MOVWreg x:(ANDWconst [m] _)) [c])
  8857		// cond: int32(m) >= 0
  8858		// result: (CMPWUconst x [c])
  8859		for {
  8860			c := v.AuxInt
  8861			v_0 := v.Args[0]
  8862			if v_0.Op != OpS390XMOVWreg {
  8863				break
  8864			}
  8865			x := v_0.Args[0]
  8866			if x.Op != OpS390XANDWconst {
  8867				break
  8868			}
  8869			m := x.AuxInt
  8870			if !(int32(m) >= 0) {
  8871				break
  8872			}
  8873			v.reset(OpS390XCMPWUconst)
  8874			v.AuxInt = c
  8875			v.AddArg(x)
  8876			return true
  8877		}
  8878		return false
  8879	}
  8880	func rewriteValueS390X_OpS390XCMPW_0(v *Value) bool {
  8881		b := v.Block
  8882		// match: (CMPW x (MOVDconst [c]))
  8883		// cond:
  8884		// result: (CMPWconst x [int64(int32(c))])
  8885		for {
  8886			_ = v.Args[1]
  8887			x := v.Args[0]
  8888			v_1 := v.Args[1]
  8889			if v_1.Op != OpS390XMOVDconst {
  8890				break
  8891			}
  8892			c := v_1.AuxInt
  8893			v.reset(OpS390XCMPWconst)
  8894			v.AuxInt = int64(int32(c))
  8895			v.AddArg(x)
  8896			return true
  8897		}
  8898		// match: (CMPW (MOVDconst [c]) x)
  8899		// cond:
  8900		// result: (InvertFlags (CMPWconst x [int64(int32(c))]))
  8901		for {
  8902			x := v.Args[1]
  8903			v_0 := v.Args[0]
  8904			if v_0.Op != OpS390XMOVDconst {
  8905				break
  8906			}
  8907			c := v_0.AuxInt
  8908			v.reset(OpS390XInvertFlags)
  8909			v0 := b.NewValue0(v.Pos, OpS390XCMPWconst, types.TypeFlags)
  8910			v0.AuxInt = int64(int32(c))
  8911			v0.AddArg(x)
  8912			v.AddArg(v0)
  8913			return true
  8914		}
  8915		// match: (CMPW x (MOVWreg y))
  8916		// cond:
  8917		// result: (CMPW x y)
  8918		for {
  8919			_ = v.Args[1]
  8920			x := v.Args[0]
  8921			v_1 := v.Args[1]
  8922			if v_1.Op != OpS390XMOVWreg {
  8923				break
  8924			}
  8925			y := v_1.Args[0]
  8926			v.reset(OpS390XCMPW)
  8927			v.AddArg(x)
  8928			v.AddArg(y)
  8929			return true
  8930		}
  8931		// match: (CMPW x (MOVWZreg y))
  8932		// cond:
  8933		// result: (CMPW x y)
  8934		for {
  8935			_ = v.Args[1]
  8936			x := v.Args[0]
  8937			v_1 := v.Args[1]
  8938			if v_1.Op != OpS390XMOVWZreg {
  8939				break
  8940			}
  8941			y := v_1.Args[0]
  8942			v.reset(OpS390XCMPW)
  8943			v.AddArg(x)
  8944			v.AddArg(y)
  8945			return true
  8946		}
  8947		// match: (CMPW (MOVWreg x) y)
  8948		// cond:
  8949		// result: (CMPW x y)
  8950		for {
  8951			y := v.Args[1]
  8952			v_0 := v.Args[0]
  8953			if v_0.Op != OpS390XMOVWreg {
  8954				break
  8955			}
  8956			x := v_0.Args[0]
  8957			v.reset(OpS390XCMPW)
  8958			v.AddArg(x)
  8959			v.AddArg(y)
  8960			return true
  8961		}
  8962		// match: (CMPW (MOVWZreg x) y)
  8963		// cond:
  8964		// result: (CMPW x y)
  8965		for {
  8966			y := v.Args[1]
  8967			v_0 := v.Args[0]
  8968			if v_0.Op != OpS390XMOVWZreg {
  8969				break
  8970			}
  8971			x := v_0.Args[0]
  8972			v.reset(OpS390XCMPW)
  8973			v.AddArg(x)
  8974			v.AddArg(y)
  8975			return true
  8976		}
  8977		return false
  8978	}
  8979	func rewriteValueS390X_OpS390XCMPWU_0(v *Value) bool {
  8980		b := v.Block
  8981		// match: (CMPWU x (MOVDconst [c]))
  8982		// cond:
  8983		// result: (CMPWUconst x [int64(int32(c))])
  8984		for {
  8985			_ = v.Args[1]
  8986			x := v.Args[0]
  8987			v_1 := v.Args[1]
  8988			if v_1.Op != OpS390XMOVDconst {
  8989				break
  8990			}
  8991			c := v_1.AuxInt
  8992			v.reset(OpS390XCMPWUconst)
  8993			v.AuxInt = int64(int32(c))
  8994			v.AddArg(x)
  8995			return true
  8996		}
  8997		// match: (CMPWU (MOVDconst [c]) x)
  8998		// cond:
  8999		// result: (InvertFlags (CMPWUconst x [int64(int32(c))]))
  9000		for {
  9001			x := v.Args[1]
  9002			v_0 := v.Args[0]
  9003			if v_0.Op != OpS390XMOVDconst {
  9004				break
  9005			}
  9006			c := v_0.AuxInt
  9007			v.reset(OpS390XInvertFlags)
  9008			v0 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  9009			v0.AuxInt = int64(int32(c))
  9010			v0.AddArg(x)
  9011			v.AddArg(v0)
  9012			return true
  9013		}
  9014		// match: (CMPWU x (MOVWreg y))
  9015		// cond:
  9016		// result: (CMPWU x y)
  9017		for {
  9018			_ = v.Args[1]
  9019			x := v.Args[0]
  9020			v_1 := v.Args[1]
  9021			if v_1.Op != OpS390XMOVWreg {
  9022				break
  9023			}
  9024			y := v_1.Args[0]
  9025			v.reset(OpS390XCMPWU)
  9026			v.AddArg(x)
  9027			v.AddArg(y)
  9028			return true
  9029		}
  9030		// match: (CMPWU x (MOVWZreg y))
  9031		// cond:
  9032		// result: (CMPWU x y)
  9033		for {
  9034			_ = v.Args[1]
  9035			x := v.Args[0]
  9036			v_1 := v.Args[1]
  9037			if v_1.Op != OpS390XMOVWZreg {
  9038				break
  9039			}
  9040			y := v_1.Args[0]
  9041			v.reset(OpS390XCMPWU)
  9042			v.AddArg(x)
  9043			v.AddArg(y)
  9044			return true
  9045		}
  9046		// match: (CMPWU (MOVWreg x) y)
  9047		// cond:
  9048		// result: (CMPWU x y)
  9049		for {
  9050			y := v.Args[1]
  9051			v_0 := v.Args[0]
  9052			if v_0.Op != OpS390XMOVWreg {
  9053				break
  9054			}
  9055			x := v_0.Args[0]
  9056			v.reset(OpS390XCMPWU)
  9057			v.AddArg(x)
  9058			v.AddArg(y)
  9059			return true
  9060		}
  9061		// match: (CMPWU (MOVWZreg x) y)
  9062		// cond:
  9063		// result: (CMPWU x y)
  9064		for {
  9065			y := v.Args[1]
  9066			v_0 := v.Args[0]
  9067			if v_0.Op != OpS390XMOVWZreg {
  9068				break
  9069			}
  9070			x := v_0.Args[0]
  9071			v.reset(OpS390XCMPWU)
  9072			v.AddArg(x)
  9073			v.AddArg(y)
  9074			return true
  9075		}
  9076		return false
  9077	}
  9078	func rewriteValueS390X_OpS390XCMPWUconst_0(v *Value) bool {
  9079		// match: (CMPWUconst (MOVDconst [x]) [y])
  9080		// cond: uint32(x)==uint32(y)
  9081		// result: (FlagEQ)
  9082		for {
  9083			y := v.AuxInt
  9084			v_0 := v.Args[0]
  9085			if v_0.Op != OpS390XMOVDconst {
  9086				break
  9087			}
  9088			x := v_0.AuxInt
  9089			if !(uint32(x) == uint32(y)) {
  9090				break
  9091			}
  9092			v.reset(OpS390XFlagEQ)
  9093			return true
  9094		}
  9095		// match: (CMPWUconst (MOVDconst [x]) [y])
  9096		// cond: uint32(x)<uint32(y)
  9097		// result: (FlagLT)
  9098		for {
  9099			y := v.AuxInt
  9100			v_0 := v.Args[0]
  9101			if v_0.Op != OpS390XMOVDconst {
  9102				break
  9103			}
  9104			x := v_0.AuxInt
  9105			if !(uint32(x) < uint32(y)) {
  9106				break
  9107			}
  9108			v.reset(OpS390XFlagLT)
  9109			return true
  9110		}
  9111		// match: (CMPWUconst (MOVDconst [x]) [y])
  9112		// cond: uint32(x)>uint32(y)
  9113		// result: (FlagGT)
  9114		for {
  9115			y := v.AuxInt
  9116			v_0 := v.Args[0]
  9117			if v_0.Op != OpS390XMOVDconst {
  9118				break
  9119			}
  9120			x := v_0.AuxInt
  9121			if !(uint32(x) > uint32(y)) {
  9122				break
  9123			}
  9124			v.reset(OpS390XFlagGT)
  9125			return true
  9126		}
  9127		// match: (CMPWUconst (MOVBZreg _) [c])
  9128		// cond: 0xff < c
  9129		// result: (FlagLT)
  9130		for {
  9131			c := v.AuxInt
  9132			v_0 := v.Args[0]
  9133			if v_0.Op != OpS390XMOVBZreg {
  9134				break
  9135			}
  9136			if !(0xff < c) {
  9137				break
  9138			}
  9139			v.reset(OpS390XFlagLT)
  9140			return true
  9141		}
  9142		// match: (CMPWUconst (MOVHZreg _) [c])
  9143		// cond: 0xffff < c
  9144		// result: (FlagLT)
  9145		for {
  9146			c := v.AuxInt
  9147			v_0 := v.Args[0]
  9148			if v_0.Op != OpS390XMOVHZreg {
  9149				break
  9150			}
  9151			if !(0xffff < c) {
  9152				break
  9153			}
  9154			v.reset(OpS390XFlagLT)
  9155			return true
  9156		}
  9157		// match: (CMPWUconst (SRWconst _ [c]) [n])
  9158		// cond: c > 0 && c < 32 && (1<<uint(32-c)) <= uint32(n)
  9159		// result: (FlagLT)
  9160		for {
  9161			n := v.AuxInt
  9162			v_0 := v.Args[0]
  9163			if v_0.Op != OpS390XSRWconst {
  9164				break
  9165			}
  9166			c := v_0.AuxInt
  9167			if !(c > 0 && c < 32 && (1<<uint(32-c)) <= uint32(n)) {
  9168				break
  9169			}
  9170			v.reset(OpS390XFlagLT)
  9171			return true
  9172		}
  9173		// match: (CMPWUconst (ANDWconst _ [m]) [n])
  9174		// cond: uint32(m) < uint32(n)
  9175		// result: (FlagLT)
  9176		for {
  9177			n := v.AuxInt
  9178			v_0 := v.Args[0]
  9179			if v_0.Op != OpS390XANDWconst {
  9180				break
  9181			}
  9182			m := v_0.AuxInt
  9183			if !(uint32(m) < uint32(n)) {
  9184				break
  9185			}
  9186			v.reset(OpS390XFlagLT)
  9187			return true
  9188		}
  9189		// match: (CMPWUconst (MOVWreg x) [c])
  9190		// cond:
  9191		// result: (CMPWUconst x [c])
  9192		for {
  9193			c := v.AuxInt
  9194			v_0 := v.Args[0]
  9195			if v_0.Op != OpS390XMOVWreg {
  9196				break
  9197			}
  9198			x := v_0.Args[0]
  9199			v.reset(OpS390XCMPWUconst)
  9200			v.AuxInt = c
  9201			v.AddArg(x)
  9202			return true
  9203		}
  9204		// match: (CMPWUconst (MOVWZreg x) [c])
  9205		// cond:
  9206		// result: (CMPWUconst x [c])
  9207		for {
  9208			c := v.AuxInt
  9209			v_0 := v.Args[0]
  9210			if v_0.Op != OpS390XMOVWZreg {
  9211				break
  9212			}
  9213			x := v_0.Args[0]
  9214			v.reset(OpS390XCMPWUconst)
  9215			v.AuxInt = c
  9216			v.AddArg(x)
  9217			return true
  9218		}
  9219		return false
  9220	}
  9221	func rewriteValueS390X_OpS390XCMPWconst_0(v *Value) bool {
  9222		// match: (CMPWconst (MOVDconst [x]) [y])
  9223		// cond: int32(x)==int32(y)
  9224		// result: (FlagEQ)
  9225		for {
  9226			y := v.AuxInt
  9227			v_0 := v.Args[0]
  9228			if v_0.Op != OpS390XMOVDconst {
  9229				break
  9230			}
  9231			x := v_0.AuxInt
  9232			if !(int32(x) == int32(y)) {
  9233				break
  9234			}
  9235			v.reset(OpS390XFlagEQ)
  9236			return true
  9237		}
  9238		// match: (CMPWconst (MOVDconst [x]) [y])
  9239		// cond: int32(x)<int32(y)
  9240		// result: (FlagLT)
  9241		for {
  9242			y := v.AuxInt
  9243			v_0 := v.Args[0]
  9244			if v_0.Op != OpS390XMOVDconst {
  9245				break
  9246			}
  9247			x := v_0.AuxInt
  9248			if !(int32(x) < int32(y)) {
  9249				break
  9250			}
  9251			v.reset(OpS390XFlagLT)
  9252			return true
  9253		}
  9254		// match: (CMPWconst (MOVDconst [x]) [y])
  9255		// cond: int32(x)>int32(y)
  9256		// result: (FlagGT)
  9257		for {
  9258			y := v.AuxInt
  9259			v_0 := v.Args[0]
  9260			if v_0.Op != OpS390XMOVDconst {
  9261				break
  9262			}
  9263			x := v_0.AuxInt
  9264			if !(int32(x) > int32(y)) {
  9265				break
  9266			}
  9267			v.reset(OpS390XFlagGT)
  9268			return true
  9269		}
  9270		// match: (CMPWconst (MOVBZreg _) [c])
  9271		// cond: 0xff < c
  9272		// result: (FlagLT)
  9273		for {
  9274			c := v.AuxInt
  9275			v_0 := v.Args[0]
  9276			if v_0.Op != OpS390XMOVBZreg {
  9277				break
  9278			}
  9279			if !(0xff < c) {
  9280				break
  9281			}
  9282			v.reset(OpS390XFlagLT)
  9283			return true
  9284		}
  9285		// match: (CMPWconst (MOVHZreg _) [c])
  9286		// cond: 0xffff < c
  9287		// result: (FlagLT)
  9288		for {
  9289			c := v.AuxInt
  9290			v_0 := v.Args[0]
  9291			if v_0.Op != OpS390XMOVHZreg {
  9292				break
  9293			}
  9294			if !(0xffff < c) {
  9295				break
  9296			}
  9297			v.reset(OpS390XFlagLT)
  9298			return true
  9299		}
  9300		// match: (CMPWconst (SRWconst _ [c]) [n])
  9301		// cond: c > 0 && n < 0
  9302		// result: (FlagGT)
  9303		for {
  9304			n := v.AuxInt
  9305			v_0 := v.Args[0]
  9306			if v_0.Op != OpS390XSRWconst {
  9307				break
  9308			}
  9309			c := v_0.AuxInt
  9310			if !(c > 0 && n < 0) {
  9311				break
  9312			}
  9313			v.reset(OpS390XFlagGT)
  9314			return true
  9315		}
  9316		// match: (CMPWconst (ANDWconst _ [m]) [n])
  9317		// cond: int32(m) >= 0 && int32(m) < int32(n)
  9318		// result: (FlagLT)
  9319		for {
  9320			n := v.AuxInt
  9321			v_0 := v.Args[0]
  9322			if v_0.Op != OpS390XANDWconst {
  9323				break
  9324			}
  9325			m := v_0.AuxInt
  9326			if !(int32(m) >= 0 && int32(m) < int32(n)) {
  9327				break
  9328			}
  9329			v.reset(OpS390XFlagLT)
  9330			return true
  9331		}
  9332		// match: (CMPWconst x:(SRWconst _ [c]) [n])
  9333		// cond: c > 0 && n >= 0
  9334		// result: (CMPWUconst x [n])
  9335		for {
  9336			n := v.AuxInt
  9337			x := v.Args[0]
  9338			if x.Op != OpS390XSRWconst {
  9339				break
  9340			}
  9341			c := x.AuxInt
  9342			if !(c > 0 && n >= 0) {
  9343				break
  9344			}
  9345			v.reset(OpS390XCMPWUconst)
  9346			v.AuxInt = n
  9347			v.AddArg(x)
  9348			return true
  9349		}
  9350		// match: (CMPWconst (MOVWreg x) [c])
  9351		// cond:
  9352		// result: (CMPWconst x [c])
  9353		for {
  9354			c := v.AuxInt
  9355			v_0 := v.Args[0]
  9356			if v_0.Op != OpS390XMOVWreg {
  9357				break
  9358			}
  9359			x := v_0.Args[0]
  9360			v.reset(OpS390XCMPWconst)
  9361			v.AuxInt = c
  9362			v.AddArg(x)
  9363			return true
  9364		}
  9365		// match: (CMPWconst (MOVWZreg x) [c])
  9366		// cond:
  9367		// result: (CMPWconst x [c])
  9368		for {
  9369			c := v.AuxInt
  9370			v_0 := v.Args[0]
  9371			if v_0.Op != OpS390XMOVWZreg {
  9372				break
  9373			}
  9374			x := v_0.Args[0]
  9375			v.reset(OpS390XCMPWconst)
  9376			v.AuxInt = c
  9377			v.AddArg(x)
  9378			return true
  9379		}
  9380		return false
  9381	}
  9382	func rewriteValueS390X_OpS390XCMPconst_0(v *Value) bool {
  9383		// match: (CMPconst (MOVDconst [x]) [y])
  9384		// cond: x==y
  9385		// result: (FlagEQ)
  9386		for {
  9387			y := v.AuxInt
  9388			v_0 := v.Args[0]
  9389			if v_0.Op != OpS390XMOVDconst {
  9390				break
  9391			}
  9392			x := v_0.AuxInt
  9393			if !(x == y) {
  9394				break
  9395			}
  9396			v.reset(OpS390XFlagEQ)
  9397			return true
  9398		}
  9399		// match: (CMPconst (MOVDconst [x]) [y])
  9400		// cond: x<y
  9401		// result: (FlagLT)
  9402		for {
  9403			y := v.AuxInt
  9404			v_0 := v.Args[0]
  9405			if v_0.Op != OpS390XMOVDconst {
  9406				break
  9407			}
  9408			x := v_0.AuxInt
  9409			if !(x < y) {
  9410				break
  9411			}
  9412			v.reset(OpS390XFlagLT)
  9413			return true
  9414		}
  9415		// match: (CMPconst (MOVDconst [x]) [y])
  9416		// cond: x>y
  9417		// result: (FlagGT)
  9418		for {
  9419			y := v.AuxInt
  9420			v_0 := v.Args[0]
  9421			if v_0.Op != OpS390XMOVDconst {
  9422				break
  9423			}
  9424			x := v_0.AuxInt
  9425			if !(x > y) {
  9426				break
  9427			}
  9428			v.reset(OpS390XFlagGT)
  9429			return true
  9430		}
  9431		// match: (CMPconst (SRDconst _ [c]) [n])
  9432		// cond: c > 0 && n < 0
  9433		// result: (FlagGT)
  9434		for {
  9435			n := v.AuxInt
  9436			v_0 := v.Args[0]
  9437			if v_0.Op != OpS390XSRDconst {
  9438				break
  9439			}
  9440			c := v_0.AuxInt
  9441			if !(c > 0 && n < 0) {
  9442				break
  9443			}
  9444			v.reset(OpS390XFlagGT)
  9445			return true
  9446		}
  9447		// match: (CMPconst (MOVWreg x) [c])
  9448		// cond:
  9449		// result: (CMPWconst x [c])
  9450		for {
  9451			c := v.AuxInt
  9452			v_0 := v.Args[0]
  9453			if v_0.Op != OpS390XMOVWreg {
  9454				break
  9455			}
  9456			x := v_0.Args[0]
  9457			v.reset(OpS390XCMPWconst)
  9458			v.AuxInt = c
  9459			v.AddArg(x)
  9460			return true
  9461		}
  9462		// match: (CMPconst x:(MOVHreg _) [c])
  9463		// cond:
  9464		// result: (CMPWconst x [c])
  9465		for {
  9466			c := v.AuxInt
  9467			x := v.Args[0]
  9468			if x.Op != OpS390XMOVHreg {
  9469				break
  9470			}
  9471			v.reset(OpS390XCMPWconst)
  9472			v.AuxInt = c
  9473			v.AddArg(x)
  9474			return true
  9475		}
  9476		// match: (CMPconst x:(MOVHZreg _) [c])
  9477		// cond:
  9478		// result: (CMPWconst x [c])
  9479		for {
  9480			c := v.AuxInt
  9481			x := v.Args[0]
  9482			if x.Op != OpS390XMOVHZreg {
  9483				break
  9484			}
  9485			v.reset(OpS390XCMPWconst)
  9486			v.AuxInt = c
  9487			v.AddArg(x)
  9488			return true
  9489		}
  9490		// match: (CMPconst x:(MOVBreg _) [c])
  9491		// cond:
  9492		// result: (CMPWconst x [c])
  9493		for {
  9494			c := v.AuxInt
  9495			x := v.Args[0]
  9496			if x.Op != OpS390XMOVBreg {
  9497				break
  9498			}
  9499			v.reset(OpS390XCMPWconst)
  9500			v.AuxInt = c
  9501			v.AddArg(x)
  9502			return true
  9503		}
  9504		// match: (CMPconst x:(MOVBZreg _) [c])
  9505		// cond:
  9506		// result: (CMPWconst x [c])
  9507		for {
  9508			c := v.AuxInt
  9509			x := v.Args[0]
  9510			if x.Op != OpS390XMOVBZreg {
  9511				break
  9512			}
  9513			v.reset(OpS390XCMPWconst)
  9514			v.AuxInt = c
  9515			v.AddArg(x)
  9516			return true
  9517		}
  9518		// match: (CMPconst (MOVWZreg x:(ANDWconst [m] _)) [c])
  9519		// cond: int32(m) >= 0 && c >= 0
  9520		// result: (CMPWUconst x [c])
  9521		for {
  9522			c := v.AuxInt
  9523			v_0 := v.Args[0]
  9524			if v_0.Op != OpS390XMOVWZreg {
  9525				break
  9526			}
  9527			x := v_0.Args[0]
  9528			if x.Op != OpS390XANDWconst {
  9529				break
  9530			}
  9531			m := x.AuxInt
  9532			if !(int32(m) >= 0 && c >= 0) {
  9533				break
  9534			}
  9535			v.reset(OpS390XCMPWUconst)
  9536			v.AuxInt = c
  9537			v.AddArg(x)
  9538			return true
  9539		}
  9540		return false
  9541	}
  9542	func rewriteValueS390X_OpS390XCMPconst_10(v *Value) bool {
  9543		// match: (CMPconst (MOVWreg x:(ANDWconst [m] _)) [c])
  9544		// cond: int32(m) >= 0 && c >= 0
  9545		// result: (CMPWUconst x [c])
  9546		for {
  9547			c := v.AuxInt
  9548			v_0 := v.Args[0]
  9549			if v_0.Op != OpS390XMOVWreg {
  9550				break
  9551			}
  9552			x := v_0.Args[0]
  9553			if x.Op != OpS390XANDWconst {
  9554				break
  9555			}
  9556			m := x.AuxInt
  9557			if !(int32(m) >= 0 && c >= 0) {
  9558				break
  9559			}
  9560			v.reset(OpS390XCMPWUconst)
  9561			v.AuxInt = c
  9562			v.AddArg(x)
  9563			return true
  9564		}
  9565		// match: (CMPconst x:(SRDconst _ [c]) [n])
  9566		// cond: c > 0 && n >= 0
  9567		// result: (CMPUconst x [n])
  9568		for {
  9569			n := v.AuxInt
  9570			x := v.Args[0]
  9571			if x.Op != OpS390XSRDconst {
  9572				break
  9573			}
  9574			c := x.AuxInt
  9575			if !(c > 0 && n >= 0) {
  9576				break
  9577			}
  9578			v.reset(OpS390XCMPUconst)
  9579			v.AuxInt = n
  9580			v.AddArg(x)
  9581			return true
  9582		}
  9583		return false
  9584	}
  9585	func rewriteValueS390X_OpS390XCPSDR_0(v *Value) bool {
  9586		// match: (CPSDR y (FMOVDconst [c]))
  9587		// cond: c & -1<<63 == 0
  9588		// result: (LPDFR y)
  9589		for {
  9590			_ = v.Args[1]
  9591			y := v.Args[0]
  9592			v_1 := v.Args[1]
  9593			if v_1.Op != OpS390XFMOVDconst {
  9594				break
  9595			}
  9596			c := v_1.AuxInt
  9597			if !(c&-1<<63 == 0) {
  9598				break
  9599			}
  9600			v.reset(OpS390XLPDFR)
  9601			v.AddArg(y)
  9602			return true
  9603		}
  9604		// match: (CPSDR y (FMOVDconst [c]))
  9605		// cond: c & -1<<63 != 0
  9606		// result: (LNDFR y)
  9607		for {
  9608			_ = v.Args[1]
  9609			y := v.Args[0]
  9610			v_1 := v.Args[1]
  9611			if v_1.Op != OpS390XFMOVDconst {
  9612				break
  9613			}
  9614			c := v_1.AuxInt
  9615			if !(c&-1<<63 != 0) {
  9616				break
  9617			}
  9618			v.reset(OpS390XLNDFR)
  9619			v.AddArg(y)
  9620			return true
  9621		}
  9622		return false
  9623	}
  9624	func rewriteValueS390X_OpS390XFADD_0(v *Value) bool {
  9625		// match: (FADD (FMUL y z) x)
  9626		// cond:
  9627		// result: (FMADD x y z)
  9628		for {
  9629			x := v.Args[1]
  9630			v_0 := v.Args[0]
  9631			if v_0.Op != OpS390XFMUL {
  9632				break
  9633			}
  9634			z := v_0.Args[1]
  9635			y := v_0.Args[0]
  9636			v.reset(OpS390XFMADD)
  9637			v.AddArg(x)
  9638			v.AddArg(y)
  9639			v.AddArg(z)
  9640			return true
  9641		}
  9642		// match: (FADD x (FMUL y z))
  9643		// cond:
  9644		// result: (FMADD x y z)
  9645		for {
  9646			_ = v.Args[1]
  9647			x := v.Args[0]
  9648			v_1 := v.Args[1]
  9649			if v_1.Op != OpS390XFMUL {
  9650				break
  9651			}
  9652			z := v_1.Args[1]
  9653			y := v_1.Args[0]
  9654			v.reset(OpS390XFMADD)
  9655			v.AddArg(x)
  9656			v.AddArg(y)
  9657			v.AddArg(z)
  9658			return true
  9659		}
  9660		return false
  9661	}
  9662	func rewriteValueS390X_OpS390XFADDS_0(v *Value) bool {
  9663		// match: (FADDS (FMULS y z) x)
  9664		// cond:
  9665		// result: (FMADDS x y z)
  9666		for {
  9667			x := v.Args[1]
  9668			v_0 := v.Args[0]
  9669			if v_0.Op != OpS390XFMULS {
  9670				break
  9671			}
  9672			z := v_0.Args[1]
  9673			y := v_0.Args[0]
  9674			v.reset(OpS390XFMADDS)
  9675			v.AddArg(x)
  9676			v.AddArg(y)
  9677			v.AddArg(z)
  9678			return true
  9679		}
  9680		// match: (FADDS x (FMULS y z))
  9681		// cond:
  9682		// result: (FMADDS x y z)
  9683		for {
  9684			_ = v.Args[1]
  9685			x := v.Args[0]
  9686			v_1 := v.Args[1]
  9687			if v_1.Op != OpS390XFMULS {
  9688				break
  9689			}
  9690			z := v_1.Args[1]
  9691			y := v_1.Args[0]
  9692			v.reset(OpS390XFMADDS)
  9693			v.AddArg(x)
  9694			v.AddArg(y)
  9695			v.AddArg(z)
  9696			return true
  9697		}
  9698		return false
  9699	}
  9700	func rewriteValueS390X_OpS390XFMOVDload_0(v *Value) bool {
  9701		// match: (FMOVDload [off] {sym} ptr1 (MOVDstore [off] {sym} ptr2 x _))
  9702		// cond: isSamePtr(ptr1, ptr2)
  9703		// result: (LDGR x)
  9704		for {
  9705			off := v.AuxInt
  9706			sym := v.Aux
  9707			_ = v.Args[1]
  9708			ptr1 := v.Args[0]
  9709			v_1 := v.Args[1]
  9710			if v_1.Op != OpS390XMOVDstore {
  9711				break
  9712			}
  9713			if v_1.AuxInt != off {
  9714				break
  9715			}
  9716			if v_1.Aux != sym {
  9717				break
  9718			}
  9719			_ = v_1.Args[2]
  9720			ptr2 := v_1.Args[0]
  9721			x := v_1.Args[1]
  9722			if !(isSamePtr(ptr1, ptr2)) {
  9723				break
  9724			}
  9725			v.reset(OpS390XLDGR)
  9726			v.AddArg(x)
  9727			return true
  9728		}
  9729		// match: (FMOVDload [off] {sym} ptr1 (FMOVDstore [off] {sym} ptr2 x _))
  9730		// cond: isSamePtr(ptr1, ptr2)
  9731		// result: x
  9732		for {
  9733			off := v.AuxInt
  9734			sym := v.Aux
  9735			_ = v.Args[1]
  9736			ptr1 := v.Args[0]
  9737			v_1 := v.Args[1]
  9738			if v_1.Op != OpS390XFMOVDstore {
  9739				break
  9740			}
  9741			if v_1.AuxInt != off {
  9742				break
  9743			}
  9744			if v_1.Aux != sym {
  9745				break
  9746			}
  9747			_ = v_1.Args[2]
  9748			ptr2 := v_1.Args[0]
  9749			x := v_1.Args[1]
  9750			if !(isSamePtr(ptr1, ptr2)) {
  9751				break
  9752			}
  9753			v.reset(OpCopy)
  9754			v.Type = x.Type
  9755			v.AddArg(x)
  9756			return true
  9757		}
  9758		// match: (FMOVDload [off1] {sym} (ADDconst [off2] ptr) mem)
  9759		// cond: is20Bit(off1+off2)
  9760		// result: (FMOVDload [off1+off2] {sym} ptr mem)
  9761		for {
  9762			off1 := v.AuxInt
  9763			sym := v.Aux
  9764			mem := v.Args[1]
  9765			v_0 := v.Args[0]
  9766			if v_0.Op != OpS390XADDconst {
  9767				break
  9768			}
  9769			off2 := v_0.AuxInt
  9770			ptr := v_0.Args[0]
  9771			if !(is20Bit(off1 + off2)) {
  9772				break
  9773			}
  9774			v.reset(OpS390XFMOVDload)
  9775			v.AuxInt = off1 + off2
  9776			v.Aux = sym
  9777			v.AddArg(ptr)
  9778			v.AddArg(mem)
  9779			return true
  9780		}
  9781		// match: (FMOVDload [off1] {sym1} (MOVDaddr [off2] {sym2} base) mem)
  9782		// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
  9783		// result: (FMOVDload [off1+off2] {mergeSym(sym1,sym2)} base mem)
  9784		for {
  9785			off1 := v.AuxInt
  9786			sym1 := v.Aux
  9787			mem := v.Args[1]
  9788			v_0 := v.Args[0]
  9789			if v_0.Op != OpS390XMOVDaddr {
  9790				break
  9791			}
  9792			off2 := v_0.AuxInt
  9793			sym2 := v_0.Aux
  9794			base := v_0.Args[0]
  9795			if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
  9796				break
  9797			}
  9798			v.reset(OpS390XFMOVDload)
  9799			v.AuxInt = off1 + off2
  9800			v.Aux = mergeSym(sym1, sym2)
  9801			v.AddArg(base)
  9802			v.AddArg(mem)
  9803			return true
  9804		}
  9805		// match: (FMOVDload [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) mem)
  9806		// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
  9807		// result: (FMOVDloadidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem)
  9808		for {
  9809			off1 := v.AuxInt
  9810			sym1 := v.Aux
  9811			mem := v.Args[1]
  9812			v_0 := v.Args[0]
  9813			if v_0.Op != OpS390XMOVDaddridx {
  9814				break
  9815			}
  9816			off2 := v_0.AuxInt
  9817			sym2 := v_0.Aux
  9818			idx := v_0.Args[1]
  9819			ptr := v_0.Args[0]
  9820			if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
  9821				break
  9822			}
  9823			v.reset(OpS390XFMOVDloadidx)
  9824			v.AuxInt = off1 + off2
  9825			v.Aux = mergeSym(sym1, sym2)
  9826			v.AddArg(ptr)
  9827			v.AddArg(idx)
  9828			v.AddArg(mem)
  9829			return true
  9830		}
  9831		// match: (FMOVDload [off] {sym} (ADD ptr idx) mem)
  9832		// cond: ptr.Op != OpSB
  9833		// result: (FMOVDloadidx [off] {sym} ptr idx mem)
  9834		for {
  9835			off := v.AuxInt
  9836			sym := v.Aux
  9837			mem := v.Args[1]
  9838			v_0 := v.Args[0]
  9839			if v_0.Op != OpS390XADD {
  9840				break
  9841			}
  9842			idx := v_0.Args[1]
  9843			ptr := v_0.Args[0]
  9844			if !(ptr.Op != OpSB) {
  9845				break
  9846			}
  9847			v.reset(OpS390XFMOVDloadidx)
  9848			v.AuxInt = off
  9849			v.Aux = sym
  9850			v.AddArg(ptr)
  9851			v.AddArg(idx)
  9852			v.AddArg(mem)
  9853			return true
  9854		}
  9855		return false
  9856	}
  9857	func rewriteValueS390X_OpS390XFMOVDloadidx_0(v *Value) bool {
  9858		// match: (FMOVDloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
  9859		// cond: is20Bit(c+d)
  9860		// result: (FMOVDloadidx [c+d] {sym} ptr idx mem)
  9861		for {
  9862			c := v.AuxInt
  9863			sym := v.Aux
  9864			mem := v.Args[2]
  9865			v_0 := v.Args[0]
  9866			if v_0.Op != OpS390XADDconst {
  9867				break
  9868			}
  9869			d := v_0.AuxInt
  9870			ptr := v_0.Args[0]
  9871			idx := v.Args[1]
  9872			if !(is20Bit(c + d)) {
  9873				break
  9874			}
  9875			v.reset(OpS390XFMOVDloadidx)
  9876			v.AuxInt = c + d
  9877			v.Aux = sym
  9878			v.AddArg(ptr)
  9879			v.AddArg(idx)
  9880			v.AddArg(mem)
  9881			return true
  9882		}
  9883		// match: (FMOVDloadidx [c] {sym} ptr (ADDconst [d] idx) mem)
  9884		// cond: is20Bit(c+d)
  9885		// result: (FMOVDloadidx [c+d] {sym} ptr idx mem)
  9886		for {
  9887			c := v.AuxInt
  9888			sym := v.Aux
  9889			mem := v.Args[2]
  9890			ptr := v.Args[0]
  9891			v_1 := v.Args[1]
  9892			if v_1.Op != OpS390XADDconst {
  9893				break
  9894			}
  9895			d := v_1.AuxInt
  9896			idx := v_1.Args[0]
  9897			if !(is20Bit(c + d)) {
  9898				break
  9899			}
  9900			v.reset(OpS390XFMOVDloadidx)
  9901			v.AuxInt = c + d
  9902			v.Aux = sym
  9903			v.AddArg(ptr)
  9904			v.AddArg(idx)
  9905			v.AddArg(mem)
  9906			return true
  9907		}
  9908		return false
  9909	}
  9910	func rewriteValueS390X_OpS390XFMOVDstore_0(v *Value) bool {
  9911		// match: (FMOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem)
  9912		// cond: is20Bit(off1+off2)
  9913		// result: (FMOVDstore [off1+off2] {sym} ptr val mem)
  9914		for {
  9915			off1 := v.AuxInt
  9916			sym := v.Aux
  9917			mem := v.Args[2]
  9918			v_0 := v.Args[0]
  9919			if v_0.Op != OpS390XADDconst {
  9920				break
  9921			}
  9922			off2 := v_0.AuxInt
  9923			ptr := v_0.Args[0]
  9924			val := v.Args[1]
  9925			if !(is20Bit(off1 + off2)) {
  9926				break
  9927			}
  9928			v.reset(OpS390XFMOVDstore)
  9929			v.AuxInt = off1 + off2
  9930			v.Aux = sym
  9931			v.AddArg(ptr)
  9932			v.AddArg(val)
  9933			v.AddArg(mem)
  9934			return true
  9935		}
  9936		// match: (FMOVDstore [off1] {sym1} (MOVDaddr [off2] {sym2} base) val mem)
  9937		// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
  9938		// result: (FMOVDstore [off1+off2] {mergeSym(sym1,sym2)} base val mem)
  9939		for {
  9940			off1 := v.AuxInt
  9941			sym1 := v.Aux
  9942			mem := v.Args[2]
  9943			v_0 := v.Args[0]
  9944			if v_0.Op != OpS390XMOVDaddr {
  9945				break
  9946			}
  9947			off2 := v_0.AuxInt
  9948			sym2 := v_0.Aux
  9949			base := v_0.Args[0]
  9950			val := v.Args[1]
  9951			if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
  9952				break
  9953			}
  9954			v.reset(OpS390XFMOVDstore)
  9955			v.AuxInt = off1 + off2
  9956			v.Aux = mergeSym(sym1, sym2)
  9957			v.AddArg(base)
  9958			v.AddArg(val)
  9959			v.AddArg(mem)
  9960			return true
  9961		}
  9962		// match: (FMOVDstore [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) val mem)
  9963		// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
  9964		// result: (FMOVDstoreidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx val mem)
  9965		for {
  9966			off1 := v.AuxInt
  9967			sym1 := v.Aux
  9968			mem := v.Args[2]
  9969			v_0 := v.Args[0]
  9970			if v_0.Op != OpS390XMOVDaddridx {
  9971				break
  9972			}
  9973			off2 := v_0.AuxInt
  9974			sym2 := v_0.Aux
  9975			idx := v_0.Args[1]
  9976			ptr := v_0.Args[0]
  9977			val := v.Args[1]
  9978			if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
  9979				break
  9980			}
  9981			v.reset(OpS390XFMOVDstoreidx)
  9982			v.AuxInt = off1 + off2
  9983			v.Aux = mergeSym(sym1, sym2)
  9984			v.AddArg(ptr)
  9985			v.AddArg(idx)
  9986			v.AddArg(val)
  9987			v.AddArg(mem)
  9988			return true
  9989		}
  9990		// match: (FMOVDstore [off] {sym} (ADD ptr idx) val mem)
  9991		// cond: ptr.Op != OpSB
  9992		// result: (FMOVDstoreidx [off] {sym} ptr idx val mem)
  9993		for {
  9994			off := v.AuxInt
  9995			sym := v.Aux
  9996			mem := v.Args[2]
  9997			v_0 := v.Args[0]
  9998			if v_0.Op != OpS390XADD {
  9999				break
 10000			}
 10001			idx := v_0.Args[1]
 10002			ptr := v_0.Args[0]
 10003			val := v.Args[1]
 10004			if !(ptr.Op != OpSB) {
 10005				break
 10006			}
 10007			v.reset(OpS390XFMOVDstoreidx)
 10008			v.AuxInt = off
 10009			v.Aux = sym
 10010			v.AddArg(ptr)
 10011			v.AddArg(idx)
 10012			v.AddArg(val)
 10013			v.AddArg(mem)
 10014			return true
 10015		}
 10016		return false
 10017	}
 10018	func rewriteValueS390X_OpS390XFMOVDstoreidx_0(v *Value) bool {
 10019		// match: (FMOVDstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem)
 10020		// cond: is20Bit(c+d)
 10021		// result: (FMOVDstoreidx [c+d] {sym} ptr idx val mem)
 10022		for {
 10023			c := v.AuxInt
 10024			sym := v.Aux
 10025			mem := v.Args[3]
 10026			v_0 := v.Args[0]
 10027			if v_0.Op != OpS390XADDconst {
 10028				break
 10029			}
 10030			d := v_0.AuxInt
 10031			ptr := v_0.Args[0]
 10032			idx := v.Args[1]
 10033			val := v.Args[2]
 10034			if !(is20Bit(c + d)) {
 10035				break
 10036			}
 10037			v.reset(OpS390XFMOVDstoreidx)
 10038			v.AuxInt = c + d
 10039			v.Aux = sym
 10040			v.AddArg(ptr)
 10041			v.AddArg(idx)
 10042			v.AddArg(val)
 10043			v.AddArg(mem)
 10044			return true
 10045		}
 10046		// match: (FMOVDstoreidx [c] {sym} ptr (ADDconst [d] idx) val mem)
 10047		// cond: is20Bit(c+d)
 10048		// result: (FMOVDstoreidx [c+d] {sym} ptr idx val mem)
 10049		for {
 10050			c := v.AuxInt
 10051			sym := v.Aux
 10052			mem := v.Args[3]
 10053			ptr := v.Args[0]
 10054			v_1 := v.Args[1]
 10055			if v_1.Op != OpS390XADDconst {
 10056				break
 10057			}
 10058			d := v_1.AuxInt
 10059			idx := v_1.Args[0]
 10060			val := v.Args[2]
 10061			if !(is20Bit(c + d)) {
 10062				break
 10063			}
 10064			v.reset(OpS390XFMOVDstoreidx)
 10065			v.AuxInt = c + d
 10066			v.Aux = sym
 10067			v.AddArg(ptr)
 10068			v.AddArg(idx)
 10069			v.AddArg(val)
 10070			v.AddArg(mem)
 10071			return true
 10072		}
 10073		return false
 10074	}
 10075	func rewriteValueS390X_OpS390XFMOVSload_0(v *Value) bool {
 10076		// match: (FMOVSload [off] {sym} ptr1 (FMOVSstore [off] {sym} ptr2 x _))
 10077		// cond: isSamePtr(ptr1, ptr2)
 10078		// result: x
 10079		for {
 10080			off := v.AuxInt
 10081			sym := v.Aux
 10082			_ = v.Args[1]
 10083			ptr1 := v.Args[0]
 10084			v_1 := v.Args[1]
 10085			if v_1.Op != OpS390XFMOVSstore {
 10086				break
 10087			}
 10088			if v_1.AuxInt != off {
 10089				break
 10090			}
 10091			if v_1.Aux != sym {
 10092				break
 10093			}
 10094			_ = v_1.Args[2]
 10095			ptr2 := v_1.Args[0]
 10096			x := v_1.Args[1]
 10097			if !(isSamePtr(ptr1, ptr2)) {
 10098				break
 10099			}
 10100			v.reset(OpCopy)
 10101			v.Type = x.Type
 10102			v.AddArg(x)
 10103			return true
 10104		}
 10105		// match: (FMOVSload [off1] {sym} (ADDconst [off2] ptr) mem)
 10106		// cond: is20Bit(off1+off2)
 10107		// result: (FMOVSload [off1+off2] {sym} ptr mem)
 10108		for {
 10109			off1 := v.AuxInt
 10110			sym := v.Aux
 10111			mem := v.Args[1]
 10112			v_0 := v.Args[0]
 10113			if v_0.Op != OpS390XADDconst {
 10114				break
 10115			}
 10116			off2 := v_0.AuxInt
 10117			ptr := v_0.Args[0]
 10118			if !(is20Bit(off1 + off2)) {
 10119				break
 10120			}
 10121			v.reset(OpS390XFMOVSload)
 10122			v.AuxInt = off1 + off2
 10123			v.Aux = sym
 10124			v.AddArg(ptr)
 10125			v.AddArg(mem)
 10126			return true
 10127		}
 10128		// match: (FMOVSload [off1] {sym1} (MOVDaddr [off2] {sym2} base) mem)
 10129		// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
 10130		// result: (FMOVSload [off1+off2] {mergeSym(sym1,sym2)} base mem)
 10131		for {
 10132			off1 := v.AuxInt
 10133			sym1 := v.Aux
 10134			mem := v.Args[1]
 10135			v_0 := v.Args[0]
 10136			if v_0.Op != OpS390XMOVDaddr {
 10137				break
 10138			}
 10139			off2 := v_0.AuxInt
 10140			sym2 := v_0.Aux
 10141			base := v_0.Args[0]
 10142			if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
 10143				break
 10144			}
 10145			v.reset(OpS390XFMOVSload)
 10146			v.AuxInt = off1 + off2
 10147			v.Aux = mergeSym(sym1, sym2)
 10148			v.AddArg(base)
 10149			v.AddArg(mem)
 10150			return true
 10151		}
 10152		// match: (FMOVSload [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) mem)
 10153		// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
 10154		// result: (FMOVSloadidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem)
 10155		for {
 10156			off1 := v.AuxInt
 10157			sym1 := v.Aux
 10158			mem := v.Args[1]
 10159			v_0 := v.Args[0]
 10160			if v_0.Op != OpS390XMOVDaddridx {
 10161				break
 10162			}
 10163			off2 := v_0.AuxInt
 10164			sym2 := v_0.Aux
 10165			idx := v_0.Args[1]
 10166			ptr := v_0.Args[0]
 10167			if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
 10168				break
 10169			}
 10170			v.reset(OpS390XFMOVSloadidx)
 10171			v.AuxInt = off1 + off2
 10172			v.Aux = mergeSym(sym1, sym2)
 10173			v.AddArg(ptr)
 10174			v.AddArg(idx)
 10175			v.AddArg(mem)
 10176			return true
 10177		}
 10178		// match: (FMOVSload [off] {sym} (ADD ptr idx) mem)
 10179		// cond: ptr.Op != OpSB
 10180		// result: (FMOVSloadidx [off] {sym} ptr idx mem)
 10181		for {
 10182			off := v.AuxInt
 10183			sym := v.Aux
 10184			mem := v.Args[1]
 10185			v_0 := v.Args[0]
 10186			if v_0.Op != OpS390XADD {
 10187				break
 10188			}
 10189			idx := v_0.Args[1]
 10190			ptr := v_0.Args[0]
 10191			if !(ptr.Op != OpSB) {
 10192				break
 10193			}
 10194			v.reset(OpS390XFMOVSloadidx)
 10195			v.AuxInt = off
 10196			v.Aux = sym
 10197			v.AddArg(ptr)
 10198			v.AddArg(idx)
 10199			v.AddArg(mem)
 10200			return true
 10201		}
 10202		return false
 10203	}
 10204	func rewriteValueS390X_OpS390XFMOVSloadidx_0(v *Value) bool {
 10205		// match: (FMOVSloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
 10206		// cond: is20Bit(c+d)
 10207		// result: (FMOVSloadidx [c+d] {sym} ptr idx mem)
 10208		for {
 10209			c := v.AuxInt
 10210			sym := v.Aux
 10211			mem := v.Args[2]
 10212			v_0 := v.Args[0]
 10213			if v_0.Op != OpS390XADDconst {
 10214				break
 10215			}
 10216			d := v_0.AuxInt
 10217			ptr := v_0.Args[0]
 10218			idx := v.Args[1]
 10219			if !(is20Bit(c + d)) {
 10220				break
 10221			}
 10222			v.reset(OpS390XFMOVSloadidx)
 10223			v.AuxInt = c + d
 10224			v.Aux = sym
 10225			v.AddArg(ptr)
 10226			v.AddArg(idx)
 10227			v.AddArg(mem)
 10228			return true
 10229		}
 10230		// match: (FMOVSloadidx [c] {sym} ptr (ADDconst [d] idx) mem)
 10231		// cond: is20Bit(c+d)
 10232		// result: (FMOVSloadidx [c+d] {sym} ptr idx mem)
 10233		for {
 10234			c := v.AuxInt
 10235			sym := v.Aux
 10236			mem := v.Args[2]
 10237			ptr := v.Args[0]
 10238			v_1 := v.Args[1]
 10239			if v_1.Op != OpS390XADDconst {
 10240				break
 10241			}
 10242			d := v_1.AuxInt
 10243			idx := v_1.Args[0]
 10244			if !(is20Bit(c + d)) {
 10245				break
 10246			}
 10247			v.reset(OpS390XFMOVSloadidx)
 10248			v.AuxInt = c + d
 10249			v.Aux = sym
 10250			v.AddArg(ptr)
 10251			v.AddArg(idx)
 10252			v.AddArg(mem)
 10253			return true
 10254		}
 10255		return false
 10256	}
 10257	func rewriteValueS390X_OpS390XFMOVSstore_0(v *Value) bool {
 10258		// match: (FMOVSstore [off1] {sym} (ADDconst [off2] ptr) val mem)
 10259		// cond: is20Bit(off1+off2)
 10260		// result: (FMOVSstore [off1+off2] {sym} ptr val mem)
 10261		for {
 10262			off1 := v.AuxInt
 10263			sym := v.Aux
 10264			mem := v.Args[2]
 10265			v_0 := v.Args[0]
 10266			if v_0.Op != OpS390XADDconst {
 10267				break
 10268			}
 10269			off2 := v_0.AuxInt
 10270			ptr := v_0.Args[0]
 10271			val := v.Args[1]
 10272			if !(is20Bit(off1 + off2)) {
 10273				break
 10274			}
 10275			v.reset(OpS390XFMOVSstore)
 10276			v.AuxInt = off1 + off2
 10277			v.Aux = sym
 10278			v.AddArg(ptr)
 10279			v.AddArg(val)
 10280			v.AddArg(mem)
 10281			return true
 10282		}
 10283		// match: (FMOVSstore [off1] {sym1} (MOVDaddr [off2] {sym2} base) val mem)
 10284		// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
 10285		// result: (FMOVSstore [off1+off2] {mergeSym(sym1,sym2)} base val mem)
 10286		for {
 10287			off1 := v.AuxInt
 10288			sym1 := v.Aux
 10289			mem := v.Args[2]
 10290			v_0 := v.Args[0]
 10291			if v_0.Op != OpS390XMOVDaddr {
 10292				break
 10293			}
 10294			off2 := v_0.AuxInt
 10295			sym2 := v_0.Aux
 10296			base := v_0.Args[0]
 10297			val := v.Args[1]
 10298			if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
 10299				break
 10300			}
 10301			v.reset(OpS390XFMOVSstore)
 10302			v.AuxInt = off1 + off2
 10303			v.Aux = mergeSym(sym1, sym2)
 10304			v.AddArg(base)
 10305			v.AddArg(val)
 10306			v.AddArg(mem)
 10307			return true
 10308		}
 10309		// match: (FMOVSstore [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) val mem)
 10310		// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
 10311		// result: (FMOVSstoreidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx val mem)
 10312		for {
 10313			off1 := v.AuxInt
 10314			sym1 := v.Aux
 10315			mem := v.Args[2]
 10316			v_0 := v.Args[0]
 10317			if v_0.Op != OpS390XMOVDaddridx {
 10318				break
 10319			}
 10320			off2 := v_0.AuxInt
 10321			sym2 := v_0.Aux
 10322			idx := v_0.Args[1]
 10323			ptr := v_0.Args[0]
 10324			val := v.Args[1]
 10325			if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
 10326				break
 10327			}
 10328			v.reset(OpS390XFMOVSstoreidx)
 10329			v.AuxInt = off1 + off2
 10330			v.Aux = mergeSym(sym1, sym2)
 10331			v.AddArg(ptr)
 10332			v.AddArg(idx)
 10333			v.AddArg(val)
 10334			v.AddArg(mem)
 10335			return true
 10336		}
 10337		// match: (FMOVSstore [off] {sym} (ADD ptr idx) val mem)
 10338		// cond: ptr.Op != OpSB
 10339		// result: (FMOVSstoreidx [off] {sym} ptr idx val mem)
 10340		for {
 10341			off := v.AuxInt
 10342			sym := v.Aux
 10343			mem := v.Args[2]
 10344			v_0 := v.Args[0]
 10345			if v_0.Op != OpS390XADD {
 10346				break
 10347			}
 10348			idx := v_0.Args[1]
 10349			ptr := v_0.Args[0]
 10350			val := v.Args[1]
 10351			if !(ptr.Op != OpSB) {
 10352				break
 10353			}
 10354			v.reset(OpS390XFMOVSstoreidx)
 10355			v.AuxInt = off
 10356			v.Aux = sym
 10357			v.AddArg(ptr)
 10358			v.AddArg(idx)
 10359			v.AddArg(val)
 10360			v.AddArg(mem)
 10361			return true
 10362		}
 10363		return false
 10364	}
 10365	func rewriteValueS390X_OpS390XFMOVSstoreidx_0(v *Value) bool {
 10366		// match: (FMOVSstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem)
 10367		// cond: is20Bit(c+d)
 10368		// result: (FMOVSstoreidx [c+d] {sym} ptr idx val mem)
 10369		for {
 10370			c := v.AuxInt
 10371			sym := v.Aux
 10372			mem := v.Args[3]
 10373			v_0 := v.Args[0]
 10374			if v_0.Op != OpS390XADDconst {
 10375				break
 10376			}
 10377			d := v_0.AuxInt
 10378			ptr := v_0.Args[0]
 10379			idx := v.Args[1]
 10380			val := v.Args[2]
 10381			if !(is20Bit(c + d)) {
 10382				break
 10383			}
 10384			v.reset(OpS390XFMOVSstoreidx)
 10385			v.AuxInt = c + d
 10386			v.Aux = sym
 10387			v.AddArg(ptr)
 10388			v.AddArg(idx)
 10389			v.AddArg(val)
 10390			v.AddArg(mem)
 10391			return true
 10392		}
 10393		// match: (FMOVSstoreidx [c] {sym} ptr (ADDconst [d] idx) val mem)
 10394		// cond: is20Bit(c+d)
 10395		// result: (FMOVSstoreidx [c+d] {sym} ptr idx val mem)
 10396		for {
 10397			c := v.AuxInt
 10398			sym := v.Aux
 10399			mem := v.Args[3]
 10400			ptr := v.Args[0]
 10401			v_1 := v.Args[1]
 10402			if v_1.Op != OpS390XADDconst {
 10403				break
 10404			}
 10405			d := v_1.AuxInt
 10406			idx := v_1.Args[0]
 10407			val := v.Args[2]
 10408			if !(is20Bit(c + d)) {
 10409				break
 10410			}
 10411			v.reset(OpS390XFMOVSstoreidx)
 10412			v.AuxInt = c + d
 10413			v.Aux = sym
 10414			v.AddArg(ptr)
 10415			v.AddArg(idx)
 10416			v.AddArg(val)
 10417			v.AddArg(mem)
 10418			return true
 10419		}
 10420		return false
 10421	}
 10422	func rewriteValueS390X_OpS390XFNEG_0(v *Value) bool {
 10423		// match: (FNEG (LPDFR x))
 10424		// cond:
 10425		// result: (LNDFR x)
 10426		for {
 10427			v_0 := v.Args[0]
 10428			if v_0.Op != OpS390XLPDFR {
 10429				break
 10430			}
 10431			x := v_0.Args[0]
 10432			v.reset(OpS390XLNDFR)
 10433			v.AddArg(x)
 10434			return true
 10435		}
 10436		// match: (FNEG (LNDFR x))
 10437		// cond:
 10438		// result: (LPDFR x)
 10439		for {
 10440			v_0 := v.Args[0]
 10441			if v_0.Op != OpS390XLNDFR {
 10442				break
 10443			}
 10444			x := v_0.Args[0]
 10445			v.reset(OpS390XLPDFR)
 10446			v.AddArg(x)
 10447			return true
 10448		}
 10449		return false
 10450	}
 10451	func rewriteValueS390X_OpS390XFNEGS_0(v *Value) bool {
 10452		// match: (FNEGS (LPDFR x))
 10453		// cond:
 10454		// result: (LNDFR x)
 10455		for {
 10456			v_0 := v.Args[0]
 10457			if v_0.Op != OpS390XLPDFR {
 10458				break
 10459			}
 10460			x := v_0.Args[0]
 10461			v.reset(OpS390XLNDFR)
 10462			v.AddArg(x)
 10463			return true
 10464		}
 10465		// match: (FNEGS (LNDFR x))
 10466		// cond:
 10467		// result: (LPDFR x)
 10468		for {
 10469			v_0 := v.Args[0]
 10470			if v_0.Op != OpS390XLNDFR {
 10471				break
 10472			}
 10473			x := v_0.Args[0]
 10474			v.reset(OpS390XLPDFR)
 10475			v.AddArg(x)
 10476			return true
 10477		}
 10478		return false
 10479	}
 10480	func rewriteValueS390X_OpS390XFSUB_0(v *Value) bool {
 10481		// match: (FSUB (FMUL y z) x)
 10482		// cond:
 10483		// result: (FMSUB x y z)
 10484		for {
 10485			x := v.Args[1]
 10486			v_0 := v.Args[0]
 10487			if v_0.Op != OpS390XFMUL {
 10488				break
 10489			}
 10490			z := v_0.Args[1]
 10491			y := v_0.Args[0]
 10492			v.reset(OpS390XFMSUB)
 10493			v.AddArg(x)
 10494			v.AddArg(y)
 10495			v.AddArg(z)
 10496			return true
 10497		}
 10498		return false
 10499	}
 10500	func rewriteValueS390X_OpS390XFSUBS_0(v *Value) bool {
 10501		// match: (FSUBS (FMULS y z) x)
 10502		// cond:
 10503		// result: (FMSUBS x y z)
 10504		for {
 10505			x := v.Args[1]
 10506			v_0 := v.Args[0]
 10507			if v_0.Op != OpS390XFMULS {
 10508				break
 10509			}
 10510			z := v_0.Args[1]
 10511			y := v_0.Args[0]
 10512			v.reset(OpS390XFMSUBS)
 10513			v.AddArg(x)
 10514			v.AddArg(y)
 10515			v.AddArg(z)
 10516			return true
 10517		}
 10518		return false
 10519	}
 10520	func rewriteValueS390X_OpS390XLDGR_0(v *Value) bool {
 10521		b := v.Block
 10522		// match: (LDGR <t> (SRDconst [1] (SLDconst [1] x)))
 10523		// cond:
 10524		// result: (LPDFR (LDGR <t> x))
 10525		for {
 10526			t := v.Type
 10527			v_0 := v.Args[0]
 10528			if v_0.Op != OpS390XSRDconst {
 10529				break
 10530			}
 10531			if v_0.AuxInt != 1 {
 10532				break
 10533			}
 10534			v_0_0 := v_0.Args[0]
 10535			if v_0_0.Op != OpS390XSLDconst {
 10536				break
 10537			}
 10538			if v_0_0.AuxInt != 1 {
 10539				break
 10540			}
 10541			x := v_0_0.Args[0]
 10542			v.reset(OpS390XLPDFR)
 10543			v0 := b.NewValue0(v.Pos, OpS390XLDGR, t)
 10544			v0.AddArg(x)
 10545			v.AddArg(v0)
 10546			return true
 10547		}
 10548		// match: (LDGR <t> (OR (MOVDconst [-1<<63]) x))
 10549		// cond:
 10550		// result: (LNDFR (LDGR <t> x))
 10551		for {
 10552			t := v.Type
 10553			v_0 := v.Args[0]
 10554			if v_0.Op != OpS390XOR {
 10555				break
 10556			}
 10557			x := v_0.Args[1]
 10558			v_0_0 := v_0.Args[0]
 10559			if v_0_0.Op != OpS390XMOVDconst {
 10560				break
 10561			}
 10562			if v_0_0.AuxInt != -1<<63 {
 10563				break
 10564			}
 10565			v.reset(OpS390XLNDFR)
 10566			v0 := b.NewValue0(v.Pos, OpS390XLDGR, t)
 10567			v0.AddArg(x)
 10568			v.AddArg(v0)
 10569			return true
 10570		}
 10571		// match: (LDGR <t> (OR x (MOVDconst [-1<<63])))
 10572		// cond:
 10573		// result: (LNDFR (LDGR <t> x))
 10574		for {
 10575			t := v.Type
 10576			v_0 := v.Args[0]
 10577			if v_0.Op != OpS390XOR {
 10578				break
 10579			}
 10580			_ = v_0.Args[1]
 10581			x := v_0.Args[0]
 10582			v_0_1 := v_0.Args[1]
 10583			if v_0_1.Op != OpS390XMOVDconst {
 10584				break
 10585			}
 10586			if v_0_1.AuxInt != -1<<63 {
 10587				break
 10588			}
 10589			v.reset(OpS390XLNDFR)
 10590			v0 := b.NewValue0(v.Pos, OpS390XLDGR, t)
 10591			v0.AddArg(x)
 10592			v.AddArg(v0)
 10593			return true
 10594		}
 10595		// match: (LDGR <t> x:(ORload <t1> [off] {sym} (MOVDconst [-1<<63]) ptr mem))
 10596		// cond: x.Uses == 1 && clobber(x)
 10597		// result: @x.Block (LNDFR <t> (LDGR <t> (MOVDload <t1> [off] {sym} ptr mem)))
 10598		for {
 10599			t := v.Type
 10600			x := v.Args[0]
 10601			if x.Op != OpS390XORload {
 10602				break
 10603			}
 10604			t1 := x.Type
 10605			off := x.AuxInt
 10606			sym := x.Aux
 10607			mem := x.Args[2]
 10608			x_0 := x.Args[0]
 10609			if x_0.Op != OpS390XMOVDconst {
 10610				break
 10611			}
 10612			if x_0.AuxInt != -1<<63 {
 10613				break
 10614			}
 10615			ptr := x.Args[1]
 10616			if !(x.Uses == 1 && clobber(x)) {
 10617				break
 10618			}
 10619			b = x.Block
 10620			v0 := b.NewValue0(x.Pos, OpS390XLNDFR, t)
 10621			v.reset(OpCopy)
 10622			v.AddArg(v0)
 10623			v1 := b.NewValue0(x.Pos, OpS390XLDGR, t)
 10624			v2 := b.NewValue0(x.Pos, OpS390XMOVDload, t1)
 10625			v2.AuxInt = off
 10626			v2.Aux = sym
 10627			v2.AddArg(ptr)
 10628			v2.AddArg(mem)
 10629			v1.AddArg(v2)
 10630			v0.AddArg(v1)
 10631			return true
 10632		}
 10633		// match: (LDGR (LGDR x))
 10634		// cond:
 10635		// result: x
 10636		for {
 10637			v_0 := v.Args[0]
 10638			if v_0.Op != OpS390XLGDR {
 10639				break
 10640			}
 10641			x := v_0.Args[0]
 10642			v.reset(OpCopy)
 10643			v.Type = x.Type
 10644			v.AddArg(x)
 10645			return true
 10646		}
 10647		return false
 10648	}
 10649	func rewriteValueS390X_OpS390XLEDBR_0(v *Value) bool {
 10650		// match: (LEDBR (LPDFR (LDEBR x)))
 10651		// cond:
 10652		// result: (LPDFR x)
 10653		for {
 10654			v_0 := v.Args[0]
 10655			if v_0.Op != OpS390XLPDFR {
 10656				break
 10657			}
 10658			v_0_0 := v_0.Args[0]
 10659			if v_0_0.Op != OpS390XLDEBR {
 10660				break
 10661			}
 10662			x := v_0_0.Args[0]
 10663			v.reset(OpS390XLPDFR)
 10664			v.AddArg(x)
 10665			return true
 10666		}
 10667		// match: (LEDBR (LNDFR (LDEBR x)))
 10668		// cond:
 10669		// result: (LNDFR x)
 10670		for {
 10671			v_0 := v.Args[0]
 10672			if v_0.Op != OpS390XLNDFR {
 10673				break
 10674			}
 10675			v_0_0 := v_0.Args[0]
 10676			if v_0_0.Op != OpS390XLDEBR {
 10677				break
 10678			}
 10679			x := v_0_0.Args[0]
 10680			v.reset(OpS390XLNDFR)
 10681			v.AddArg(x)
 10682			return true
 10683		}
 10684		return false
 10685	}
 10686	func rewriteValueS390X_OpS390XLGDR_0(v *Value) bool {
 10687		// match: (LGDR (LDGR x))
 10688		// cond:
 10689		// result: (MOVDreg x)
 10690		for {
 10691			v_0 := v.Args[0]
 10692			if v_0.Op != OpS390XLDGR {
 10693				break
 10694			}
 10695			x := v_0.Args[0]
 10696			v.reset(OpS390XMOVDreg)
 10697			v.AddArg(x)
 10698			return true
 10699		}
 10700		return false
 10701	}
 10702	func rewriteValueS390X_OpS390XLoweredRound32F_0(v *Value) bool {
 10703		// match: (LoweredRound32F x:(FMOVSconst))
 10704		// cond:
 10705		// result: x
 10706		for {
 10707			x := v.Args[0]
 10708			if x.Op != OpS390XFMOVSconst {
 10709				break
 10710			}
 10711			v.reset(OpCopy)
 10712			v.Type = x.Type
 10713			v.AddArg(x)
 10714			return true
 10715		}
 10716		return false
 10717	}
 10718	func rewriteValueS390X_OpS390XLoweredRound64F_0(v *Value) bool {
 10719		// match: (LoweredRound64F x:(FMOVDconst))
 10720		// cond:
 10721		// result: x
 10722		for {
 10723			x := v.Args[0]
 10724			if x.Op != OpS390XFMOVDconst {
 10725				break
 10726			}
 10727			v.reset(OpCopy)
 10728			v.Type = x.Type
 10729			v.AddArg(x)
 10730			return true
 10731		}
 10732		return false
 10733	}
 10734	func rewriteValueS390X_OpS390XMOVBZload_0(v *Value) bool {
 10735		// match: (MOVBZload [off] {sym} ptr1 (MOVBstore [off] {sym} ptr2 x _))
 10736		// cond: isSamePtr(ptr1, ptr2)
 10737		// result: (MOVBZreg x)
 10738		for {
 10739			off := v.AuxInt
 10740			sym := v.Aux
 10741			_ = v.Args[1]
 10742			ptr1 := v.Args[0]
 10743			v_1 := v.Args[1]
 10744			if v_1.Op != OpS390XMOVBstore {
 10745				break
 10746			}
 10747			if v_1.AuxInt != off {
 10748				break
 10749			}
 10750			if v_1.Aux != sym {
 10751				break
 10752			}
 10753			_ = v_1.Args[2]
 10754			ptr2 := v_1.Args[0]
 10755			x := v_1.Args[1]
 10756			if !(isSamePtr(ptr1, ptr2)) {
 10757				break
 10758			}
 10759			v.reset(OpS390XMOVBZreg)
 10760			v.AddArg(x)
 10761			return true
 10762		}
 10763		// match: (MOVBZload [off1] {sym} (ADDconst [off2] ptr) mem)
 10764		// cond: is20Bit(off1+off2)
 10765		// result: (MOVBZload [off1+off2] {sym} ptr mem)
 10766		for {
 10767			off1 := v.AuxInt
 10768			sym := v.Aux
 10769			mem := v.Args[1]
 10770			v_0 := v.Args[0]
 10771			if v_0.Op != OpS390XADDconst {
 10772				break
 10773			}
 10774			off2 := v_0.AuxInt
 10775			ptr := v_0.Args[0]
 10776			if !(is20Bit(off1 + off2)) {
 10777				break
 10778			}
 10779			v.reset(OpS390XMOVBZload)
 10780			v.AuxInt = off1 + off2
 10781			v.Aux = sym
 10782			v.AddArg(ptr)
 10783			v.AddArg(mem)
 10784			return true
 10785		}
 10786		// match: (MOVBZload [off1] {sym1} (MOVDaddr [off2] {sym2} base) mem)
 10787		// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
 10788		// result: (MOVBZload [off1+off2] {mergeSym(sym1,sym2)} base mem)
 10789		for {
 10790			off1 := v.AuxInt
 10791			sym1 := v.Aux
 10792			mem := v.Args[1]
 10793			v_0 := v.Args[0]
 10794			if v_0.Op != OpS390XMOVDaddr {
 10795				break
 10796			}
 10797			off2 := v_0.AuxInt
 10798			sym2 := v_0.Aux
 10799			base := v_0.Args[0]
 10800			if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
 10801				break
 10802			}
 10803			v.reset(OpS390XMOVBZload)
 10804			v.AuxInt = off1 + off2
 10805			v.Aux = mergeSym(sym1, sym2)
 10806			v.AddArg(base)
 10807			v.AddArg(mem)
 10808			return true
 10809		}
 10810		// match: (MOVBZload [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) mem)
 10811		// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
 10812		// result: (MOVBZloadidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem)
 10813		for {
 10814			off1 := v.AuxInt
 10815			sym1 := v.Aux
 10816			mem := v.Args[1]
 10817			v_0 := v.Args[0]
 10818			if v_0.Op != OpS390XMOVDaddridx {
 10819				break
 10820			}
 10821			off2 := v_0.AuxInt
 10822			sym2 := v_0.Aux
 10823			idx := v_0.Args[1]
 10824			ptr := v_0.Args[0]
 10825			if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
 10826				break
 10827			}
 10828			v.reset(OpS390XMOVBZloadidx)
 10829			v.AuxInt = off1 + off2
 10830			v.Aux = mergeSym(sym1, sym2)
 10831			v.AddArg(ptr)
 10832			v.AddArg(idx)
 10833			v.AddArg(mem)
 10834			return true
 10835		}
 10836		// match: (MOVBZload [off] {sym} (ADD ptr idx) mem)
 10837		// cond: ptr.Op != OpSB
 10838		// result: (MOVBZloadidx [off] {sym} ptr idx mem)
 10839		for {
 10840			off := v.AuxInt
 10841			sym := v.Aux
 10842			mem := v.Args[1]
 10843			v_0 := v.Args[0]
 10844			if v_0.Op != OpS390XADD {
 10845				break
 10846			}
 10847			idx := v_0.Args[1]
 10848			ptr := v_0.Args[0]
 10849			if !(ptr.Op != OpSB) {
 10850				break
 10851			}
 10852			v.reset(OpS390XMOVBZloadidx)
 10853			v.AuxInt = off
 10854			v.Aux = sym
 10855			v.AddArg(ptr)
 10856			v.AddArg(idx)
 10857			v.AddArg(mem)
 10858			return true
 10859		}
 10860		return false
 10861	}
 10862	func rewriteValueS390X_OpS390XMOVBZloadidx_0(v *Value) bool {
 10863		// match: (MOVBZloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
 10864		// cond: is20Bit(c+d)
 10865		// result: (MOVBZloadidx [c+d] {sym} ptr idx mem)
 10866		for {
 10867			c := v.AuxInt
 10868			sym := v.Aux
 10869			mem := v.Args[2]
 10870			v_0 := v.Args[0]
 10871			if v_0.Op != OpS390XADDconst {
 10872				break
 10873			}
 10874			d := v_0.AuxInt
 10875			ptr := v_0.Args[0]
 10876			idx := v.Args[1]
 10877			if !(is20Bit(c + d)) {
 10878				break
 10879			}
 10880			v.reset(OpS390XMOVBZloadidx)
 10881			v.AuxInt = c + d
 10882			v.Aux = sym
 10883			v.AddArg(ptr)
 10884			v.AddArg(idx)
 10885			v.AddArg(mem)
 10886			return true
 10887		}
 10888		// match: (MOVBZloadidx [c] {sym} idx (ADDconst [d] ptr) mem)
 10889		// cond: is20Bit(c+d)
 10890		// result: (MOVBZloadidx [c+d] {sym} ptr idx mem)
 10891		for {
 10892			c := v.AuxInt
 10893			sym := v.Aux
 10894			mem := v.Args[2]
 10895			idx := v.Args[0]
 10896			v_1 := v.Args[1]
 10897			if v_1.Op != OpS390XADDconst {
 10898				break
 10899			}
 10900			d := v_1.AuxInt
 10901			ptr := v_1.Args[0]
 10902			if !(is20Bit(c + d)) {
 10903				break
 10904			}
 10905			v.reset(OpS390XMOVBZloadidx)
 10906			v.AuxInt = c + d
 10907			v.Aux = sym
 10908			v.AddArg(ptr)
 10909			v.AddArg(idx)
 10910			v.AddArg(mem)
 10911			return true
 10912		}
 10913		// match: (MOVBZloadidx [c] {sym} ptr (ADDconst [d] idx) mem)
 10914		// cond: is20Bit(c+d)
 10915		// result: (MOVBZloadidx [c+d] {sym} ptr idx mem)
 10916		for {
 10917			c := v.AuxInt
 10918			sym := v.Aux
 10919			mem := v.Args[2]
 10920			ptr := v.Args[0]
 10921			v_1 := v.Args[1]
 10922			if v_1.Op != OpS390XADDconst {
 10923				break
 10924			}
 10925			d := v_1.AuxInt
 10926			idx := v_1.Args[0]
 10927			if !(is20Bit(c + d)) {
 10928				break
 10929			}
 10930			v.reset(OpS390XMOVBZloadidx)
 10931			v.AuxInt = c + d
 10932			v.Aux = sym
 10933			v.AddArg(ptr)
 10934			v.AddArg(idx)
 10935			v.AddArg(mem)
 10936			return true
 10937		}
 10938		// match: (MOVBZloadidx [c] {sym} (ADDconst [d] idx) ptr mem)
 10939		// cond: is20Bit(c+d)
 10940		// result: (MOVBZloadidx [c+d] {sym} ptr idx mem)
 10941		for {
 10942			c := v.AuxInt
 10943			sym := v.Aux
 10944			mem := v.Args[2]
 10945			v_0 := v.Args[0]
 10946			if v_0.Op != OpS390XADDconst {
 10947				break
 10948			}
 10949			d := v_0.AuxInt
 10950			idx := v_0.Args[0]
 10951			ptr := v.Args[1]
 10952			if !(is20Bit(c + d)) {
 10953				break
 10954			}
 10955			v.reset(OpS390XMOVBZloadidx)
 10956			v.AuxInt = c + d
 10957			v.Aux = sym
 10958			v.AddArg(ptr)
 10959			v.AddArg(idx)
 10960			v.AddArg(mem)
 10961			return true
 10962		}
 10963		return false
 10964	}
 10965	func rewriteValueS390X_OpS390XMOVBZreg_0(v *Value) bool {
 10966		// match: (MOVBZreg x:(MOVDLT (MOVDconst [c]) (MOVDconst [d]) _))
 10967		// cond: int64(uint8(c)) == c && int64(uint8(d)) == d
 10968		// result: (MOVDreg x)
 10969		for {
 10970			x := v.Args[0]
 10971			if x.Op != OpS390XMOVDLT {
 10972				break
 10973			}
 10974			_ = x.Args[2]
 10975			x_0 := x.Args[0]
 10976			if x_0.Op != OpS390XMOVDconst {
 10977				break
 10978			}
 10979			c := x_0.AuxInt
 10980			x_1 := x.Args[1]
 10981			if x_1.Op != OpS390XMOVDconst {
 10982				break
 10983			}
 10984			d := x_1.AuxInt
 10985			if !(int64(uint8(c)) == c && int64(uint8(d)) == d) {
 10986				break
 10987			}
 10988			v.reset(OpS390XMOVDreg)
 10989			v.AddArg(x)
 10990			return true
 10991		}
 10992		// match: (MOVBZreg x:(MOVDLE (MOVDconst [c]) (MOVDconst [d]) _))
 10993		// cond: int64(uint8(c)) == c && int64(uint8(d)) == d
 10994		// result: (MOVDreg x)
 10995		for {
 10996			x := v.Args[0]
 10997			if x.Op != OpS390XMOVDLE {
 10998				break
 10999			}
 11000			_ = x.Args[2]
 11001			x_0 := x.Args[0]
 11002			if x_0.Op != OpS390XMOVDconst {
 11003				break
 11004			}
 11005			c := x_0.AuxInt
 11006			x_1 := x.Args[1]
 11007			if x_1.Op != OpS390XMOVDconst {
 11008				break
 11009			}
 11010			d := x_1.AuxInt
 11011			if !(int64(uint8(c)) == c && int64(uint8(d)) == d) {
 11012				break
 11013			}
 11014			v.reset(OpS390XMOVDreg)
 11015			v.AddArg(x)
 11016			return true
 11017		}
 11018		// match: (MOVBZreg x:(MOVDGT (MOVDconst [c]) (MOVDconst [d]) _))
 11019		// cond: int64(uint8(c)) == c && int64(uint8(d)) == d
 11020		// result: (MOVDreg x)
 11021		for {
 11022			x := v.Args[0]
 11023			if x.Op != OpS390XMOVDGT {
 11024				break
 11025			}
 11026			_ = x.Args[2]
 11027			x_0 := x.Args[0]
 11028			if x_0.Op != OpS390XMOVDconst {
 11029				break
 11030			}
 11031			c := x_0.AuxInt
 11032			x_1 := x.Args[1]
 11033			if x_1.Op != OpS390XMOVDconst {
 11034				break
 11035			}
 11036			d := x_1.AuxInt
 11037			if !(int64(uint8(c)) == c && int64(uint8(d)) == d) {
 11038				break
 11039			}
 11040			v.reset(OpS390XMOVDreg)
 11041			v.AddArg(x)
 11042			return true
 11043		}
 11044		// match: (MOVBZreg x:(MOVDGE (MOVDconst [c]) (MOVDconst [d]) _))
 11045		// cond: int64(uint8(c)) == c && int64(uint8(d)) == d
 11046		// result: (MOVDreg x)
 11047		for {
 11048			x := v.Args[0]
 11049			if x.Op != OpS390XMOVDGE {
 11050				break
 11051			}
 11052			_ = x.Args[2]
 11053			x_0 := x.Args[0]
 11054			if x_0.Op != OpS390XMOVDconst {
 11055				break
 11056			}
 11057			c := x_0.AuxInt
 11058			x_1 := x.Args[1]
 11059			if x_1.Op != OpS390XMOVDconst {
 11060				break
 11061			}
 11062			d := x_1.AuxInt
 11063			if !(int64(uint8(c)) == c && int64(uint8(d)) == d) {
 11064				break
 11065			}
 11066			v.reset(OpS390XMOVDreg)
 11067			v.AddArg(x)
 11068			return true
 11069		}
 11070		// match: (MOVBZreg x:(MOVDEQ (MOVDconst [c]) (MOVDconst [d]) _))
 11071		// cond: int64(uint8(c)) == c && int64(uint8(d)) == d
 11072		// result: (MOVDreg x)
 11073		for {
 11074			x := v.Args[0]
 11075			if x.Op != OpS390XMOVDEQ {
 11076				break
 11077			}
 11078			_ = x.Args[2]
 11079			x_0 := x.Args[0]
 11080			if x_0.Op != OpS390XMOVDconst {
 11081				break
 11082			}
 11083			c := x_0.AuxInt
 11084			x_1 := x.Args[1]
 11085			if x_1.Op != OpS390XMOVDconst {
 11086				break
 11087			}
 11088			d := x_1.AuxInt
 11089			if !(int64(uint8(c)) == c && int64(uint8(d)) == d) {
 11090				break
 11091			}
 11092			v.reset(OpS390XMOVDreg)
 11093			v.AddArg(x)
 11094			return true
 11095		}
 11096		// match: (MOVBZreg x:(MOVDNE (MOVDconst [c]) (MOVDconst [d]) _))
 11097		// cond: int64(uint8(c)) == c && int64(uint8(d)) == d
 11098		// result: (MOVDreg x)
 11099		for {
 11100			x := v.Args[0]
 11101			if x.Op != OpS390XMOVDNE {
 11102				break
 11103			}
 11104			_ = x.Args[2]
 11105			x_0 := x.Args[0]
 11106			if x_0.Op != OpS390XMOVDconst {
 11107				break
 11108			}
 11109			c := x_0.AuxInt
 11110			x_1 := x.Args[1]
 11111			if x_1.Op != OpS390XMOVDconst {
 11112				break
 11113			}
 11114			d := x_1.AuxInt
 11115			if !(int64(uint8(c)) == c && int64(uint8(d)) == d) {
 11116				break
 11117			}
 11118			v.reset(OpS390XMOVDreg)
 11119			v.AddArg(x)
 11120			return true
 11121		}
 11122		// match: (MOVBZreg x:(MOVDGTnoinv (MOVDconst [c]) (MOVDconst [d]) _))
 11123		// cond: int64(uint8(c)) == c && int64(uint8(d)) == d
 11124		// result: (MOVDreg x)
 11125		for {
 11126			x := v.Args[0]
 11127			if x.Op != OpS390XMOVDGTnoinv {
 11128				break
 11129			}
 11130			_ = x.Args[2]
 11131			x_0 := x.Args[0]
 11132			if x_0.Op != OpS390XMOVDconst {
 11133				break
 11134			}
 11135			c := x_0.AuxInt
 11136			x_1 := x.Args[1]
 11137			if x_1.Op != OpS390XMOVDconst {
 11138				break
 11139			}
 11140			d := x_1.AuxInt
 11141			if !(int64(uint8(c)) == c && int64(uint8(d)) == d) {
 11142				break
 11143			}
 11144			v.reset(OpS390XMOVDreg)
 11145			v.AddArg(x)
 11146			return true
 11147		}
 11148		// match: (MOVBZreg x:(MOVDGEnoinv (MOVDconst [c]) (MOVDconst [d]) _))
 11149		// cond: int64(uint8(c)) == c && int64(uint8(d)) == d
 11150		// result: (MOVDreg x)
 11151		for {
 11152			x := v.Args[0]
 11153			if x.Op != OpS390XMOVDGEnoinv {
 11154				break
 11155			}
 11156			_ = x.Args[2]
 11157			x_0 := x.Args[0]
 11158			if x_0.Op != OpS390XMOVDconst {
 11159				break
 11160			}
 11161			c := x_0.AuxInt
 11162			x_1 := x.Args[1]
 11163			if x_1.Op != OpS390XMOVDconst {
 11164				break
 11165			}
 11166			d := x_1.AuxInt
 11167			if !(int64(uint8(c)) == c && int64(uint8(d)) == d) {
 11168				break
 11169			}
 11170			v.reset(OpS390XMOVDreg)
 11171			v.AddArg(x)
 11172			return true
 11173		}
 11174		// match: (MOVBZreg x:(MOVBZload _ _))
 11175		// cond:
 11176		// result: (MOVDreg x)
 11177		for {
 11178			x := v.Args[0]
 11179			if x.Op != OpS390XMOVBZload {
 11180				break
 11181			}
 11182			_ = x.Args[1]
 11183			v.reset(OpS390XMOVDreg)
 11184			v.AddArg(x)
 11185			return true
 11186		}
 11187		// match: (MOVBZreg x:(Arg <t>))
 11188		// cond: is8BitInt(t) && !isSigned(t)
 11189		// result: (MOVDreg x)
 11190		for {
 11191			x := v.Args[0]
 11192			if x.Op != OpArg {
 11193				break
 11194			}
 11195			t := x.Type
 11196			if !(is8BitInt(t) && !isSigned(t)) {
 11197				break
 11198			}
 11199			v.reset(OpS390XMOVDreg)
 11200			v.AddArg(x)
 11201			return true
 11202		}
 11203		return false
 11204	}
 11205	func rewriteValueS390X_OpS390XMOVBZreg_10(v *Value) bool {
 11206		b := v.Block
 11207		typ := &b.Func.Config.Types
 11208		// match: (MOVBZreg x:(MOVBZreg _))
 11209		// cond:
 11210		// result: (MOVDreg x)
 11211		for {
 11212			x := v.Args[0]
 11213			if x.Op != OpS390XMOVBZreg {
 11214				break
 11215			}
 11216			v.reset(OpS390XMOVDreg)
 11217			v.AddArg(x)
 11218			return true
 11219		}
 11220		// match: (MOVBZreg (MOVBreg x))
 11221		// cond:
 11222		// result: (MOVBZreg x)
 11223		for {
 11224			v_0 := v.Args[0]
 11225			if v_0.Op != OpS390XMOVBreg {
 11226				break
 11227			}
 11228			x := v_0.Args[0]
 11229			v.reset(OpS390XMOVBZreg)
 11230			v.AddArg(x)
 11231			return true
 11232		}
 11233		// match: (MOVBZreg (MOVDconst [c]))
 11234		// cond:
 11235		// result: (MOVDconst [int64(uint8(c))])
 11236		for {
 11237			v_0 := v.Args[0]
 11238			if v_0.Op != OpS390XMOVDconst {
 11239				break
 11240			}
 11241			c := v_0.AuxInt
 11242			v.reset(OpS390XMOVDconst)
 11243			v.AuxInt = int64(uint8(c))
 11244			return true
 11245		}
 11246		// match: (MOVBZreg x:(MOVBZload [off] {sym} ptr mem))
 11247		// cond: x.Uses == 1 && clobber(x)
 11248		// result: @x.Block (MOVBZload <v.Type> [off] {sym} ptr mem)
 11249		for {
 11250			x := v.Args[0]
 11251			if x.Op != OpS390XMOVBZload {
 11252				break
 11253			}
 11254			off := x.AuxInt
 11255			sym := x.Aux
 11256			mem := x.Args[1]
 11257			ptr := x.Args[0]
 11258			if !(x.Uses == 1 && clobber(x)) {
 11259				break
 11260			}
 11261			b = x.Block
 11262			v0 := b.NewValue0(x.Pos, OpS390XMOVBZload, v.Type)
 11263			v.reset(OpCopy)
 11264			v.AddArg(v0)
 11265			v0.AuxInt = off
 11266			v0.Aux = sym
 11267			v0.AddArg(ptr)
 11268			v0.AddArg(mem)
 11269			return true
 11270		}
 11271		// match: (MOVBZreg x:(MOVBload [off] {sym} ptr mem))
 11272		// cond: x.Uses == 1 && clobber(x)
 11273		// result: @x.Block (MOVBZload <v.Type> [off] {sym} ptr mem)
 11274		for {
 11275			x := v.Args[0]
 11276			if x.Op != OpS390XMOVBload {
 11277				break
 11278			}
 11279			off := x.AuxInt
 11280			sym := x.Aux
 11281			mem := x.Args[1]
 11282			ptr := x.Args[0]
 11283			if !(x.Uses == 1 && clobber(x)) {
 11284				break
 11285			}
 11286			b = x.Block
 11287			v0 := b.NewValue0(x.Pos, OpS390XMOVBZload, v.Type)
 11288			v.reset(OpCopy)
 11289			v.AddArg(v0)
 11290			v0.AuxInt = off
 11291			v0.Aux = sym
 11292			v0.AddArg(ptr)
 11293			v0.AddArg(mem)
 11294			return true
 11295		}
 11296		// match: (MOVBZreg x:(MOVBZloadidx [off] {sym} ptr idx mem))
 11297		// cond: x.Uses == 1 && clobber(x)
 11298		// result: @x.Block (MOVBZloadidx <v.Type> [off] {sym} ptr idx mem)
 11299		for {
 11300			x := v.Args[0]
 11301			if x.Op != OpS390XMOVBZloadidx {
 11302				break
 11303			}
 11304			off := x.AuxInt
 11305			sym := x.Aux
 11306			mem := x.Args[2]
 11307			ptr := x.Args[0]
 11308			idx := x.Args[1]
 11309			if !(x.Uses == 1 && clobber(x)) {
 11310				break
 11311			}
 11312			b = x.Block
 11313			v0 := b.NewValue0(v.Pos, OpS390XMOVBZloadidx, v.Type)
 11314			v.reset(OpCopy)
 11315			v.AddArg(v0)
 11316			v0.AuxInt = off
 11317			v0.Aux = sym
 11318			v0.AddArg(ptr)
 11319			v0.AddArg(idx)
 11320			v0.AddArg(mem)
 11321			return true
 11322		}
 11323		// match: (MOVBZreg x:(MOVBloadidx [off] {sym} ptr idx mem))
 11324		// cond: x.Uses == 1 && clobber(x)
 11325		// result: @x.Block (MOVBZloadidx <v.Type> [off] {sym} ptr idx mem)
 11326		for {
 11327			x := v.Args[0]
 11328			if x.Op != OpS390XMOVBloadidx {
 11329				break
 11330			}
 11331			off := x.AuxInt
 11332			sym := x.Aux
 11333			mem := x.Args[2]
 11334			ptr := x.Args[0]
 11335			idx := x.Args[1]
 11336			if !(x.Uses == 1 && clobber(x)) {
 11337				break
 11338			}
 11339			b = x.Block
 11340			v0 := b.NewValue0(v.Pos, OpS390XMOVBZloadidx, v.Type)
 11341			v.reset(OpCopy)
 11342			v.AddArg(v0)
 11343			v0.AuxInt = off
 11344			v0.Aux = sym
 11345			v0.AddArg(ptr)
 11346			v0.AddArg(idx)
 11347			v0.AddArg(mem)
 11348			return true
 11349		}
 11350		// match: (MOVBZreg (ANDWconst [m] x))
 11351		// cond:
 11352		// result: (MOVWZreg (ANDWconst <typ.UInt32> [int64( uint8(m))] x))
 11353		for {
 11354			v_0 := v.Args[0]
 11355			if v_0.Op != OpS390XANDWconst {
 11356				break
 11357			}
 11358			m := v_0.AuxInt
 11359			x := v_0.Args[0]
 11360			v.reset(OpS390XMOVWZreg)
 11361			v0 := b.NewValue0(v.Pos, OpS390XANDWconst, typ.UInt32)
 11362			v0.AuxInt = int64(uint8(m))
 11363			v0.AddArg(x)
 11364			v.AddArg(v0)
 11365			return true
 11366		}
 11367		return false
 11368	}
 11369	func rewriteValueS390X_OpS390XMOVBload_0(v *Value) bool {
 11370		// match: (MOVBload [off] {sym} ptr1 (MOVBstore [off] {sym} ptr2 x _))
 11371		// cond: isSamePtr(ptr1, ptr2)
 11372		// result: (MOVBreg x)
 11373		for {
 11374			off := v.AuxInt
 11375			sym := v.Aux
 11376			_ = v.Args[1]
 11377			ptr1 := v.Args[0]
 11378			v_1 := v.Args[1]
 11379			if v_1.Op != OpS390XMOVBstore {
 11380				break
 11381			}
 11382			if v_1.AuxInt != off {
 11383				break
 11384			}
 11385			if v_1.Aux != sym {
 11386				break
 11387			}
 11388			_ = v_1.Args[2]
 11389			ptr2 := v_1.Args[0]
 11390			x := v_1.Args[1]
 11391			if !(isSamePtr(ptr1, ptr2)) {
 11392				break
 11393			}
 11394			v.reset(OpS390XMOVBreg)
 11395			v.AddArg(x)
 11396			return true
 11397		}
 11398		// match: (MOVBload [off1] {sym} (ADDconst [off2] ptr) mem)
 11399		// cond: is20Bit(off1+off2)
 11400		// result: (MOVBload [off1+off2] {sym} ptr mem)
 11401		for {
 11402			off1 := v.AuxInt
 11403			sym := v.Aux
 11404			mem := v.Args[1]
 11405			v_0 := v.Args[0]
 11406			if v_0.Op != OpS390XADDconst {
 11407				break
 11408			}
 11409			off2 := v_0.AuxInt
 11410			ptr := v_0.Args[0]
 11411			if !(is20Bit(off1 + off2)) {
 11412				break
 11413			}
 11414			v.reset(OpS390XMOVBload)
 11415			v.AuxInt = off1 + off2
 11416			v.Aux = sym
 11417			v.AddArg(ptr)
 11418			v.AddArg(mem)
 11419			return true
 11420		}
 11421		// match: (MOVBload [off1] {sym1} (MOVDaddr [off2] {sym2} base) mem)
 11422		// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
 11423		// result: (MOVBload [off1+off2] {mergeSym(sym1,sym2)} base mem)
 11424		for {
 11425			off1 := v.AuxInt
 11426			sym1 := v.Aux
 11427			mem := v.Args[1]
 11428			v_0 := v.Args[0]
 11429			if v_0.Op != OpS390XMOVDaddr {
 11430				break
 11431			}
 11432			off2 := v_0.AuxInt
 11433			sym2 := v_0.Aux
 11434			base := v_0.Args[0]
 11435			if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
 11436				break
 11437			}
 11438			v.reset(OpS390XMOVBload)
 11439			v.AuxInt = off1 + off2
 11440			v.Aux = mergeSym(sym1, sym2)
 11441			v.AddArg(base)
 11442			v.AddArg(mem)
 11443			return true
 11444		}
 11445		// match: (MOVBload [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) mem)
 11446		// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
 11447		// result: (MOVBloadidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem)
 11448		for {
 11449			off1 := v.AuxInt
 11450			sym1 := v.Aux
 11451			mem := v.Args[1]
 11452			v_0 := v.Args[0]
 11453			if v_0.Op != OpS390XMOVDaddridx {
 11454				break
 11455			}
 11456			off2 := v_0.AuxInt
 11457			sym2 := v_0.Aux
 11458			idx := v_0.Args[1]
 11459			ptr := v_0.Args[0]
 11460			if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
 11461				break
 11462			}
 11463			v.reset(OpS390XMOVBloadidx)
 11464			v.AuxInt = off1 + off2
 11465			v.Aux = mergeSym(sym1, sym2)
 11466			v.AddArg(ptr)
 11467			v.AddArg(idx)
 11468			v.AddArg(mem)
 11469			return true
 11470		}
 11471		// match: (MOVBload [off] {sym} (ADD ptr idx) mem)
 11472		// cond: ptr.Op != OpSB
 11473		// result: (MOVBloadidx [off] {sym} ptr idx mem)
 11474		for {
 11475			off := v.AuxInt
 11476			sym := v.Aux
 11477			mem := v.Args[1]
 11478			v_0 := v.Args[0]
 11479			if v_0.Op != OpS390XADD {
 11480				break
 11481			}
 11482			idx := v_0.Args[1]
 11483			ptr := v_0.Args[0]
 11484			if !(ptr.Op != OpSB) {
 11485				break
 11486			}
 11487			v.reset(OpS390XMOVBloadidx)
 11488			v.AuxInt = off
 11489			v.Aux = sym
 11490			v.AddArg(ptr)
 11491			v.AddArg(idx)
 11492			v.AddArg(mem)
 11493			return true
 11494		}
 11495		return false
 11496	}
 11497	func rewriteValueS390X_OpS390XMOVBloadidx_0(v *Value) bool {
 11498		// match: (MOVBloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
 11499		// cond: is20Bit(c+d)
 11500		// result: (MOVBloadidx [c+d] {sym} ptr idx mem)
 11501		for {
 11502			c := v.AuxInt
 11503			sym := v.Aux
 11504			mem := v.Args[2]
 11505			v_0 := v.Args[0]
 11506			if v_0.Op != OpS390XADDconst {
 11507				break
 11508			}
 11509			d := v_0.AuxInt
 11510			ptr := v_0.Args[0]
 11511			idx := v.Args[1]
 11512			if !(is20Bit(c + d)) {
 11513				break
 11514			}
 11515			v.reset(OpS390XMOVBloadidx)
 11516			v.AuxInt = c + d
 11517			v.Aux = sym
 11518			v.AddArg(ptr)
 11519			v.AddArg(idx)
 11520			v.AddArg(mem)
 11521			return true
 11522		}
 11523		// match: (MOVBloadidx [c] {sym} idx (ADDconst [d] ptr) mem)
 11524		// cond: is20Bit(c+d)
 11525		// result: (MOVBloadidx [c+d] {sym} ptr idx mem)
 11526		for {
 11527			c := v.AuxInt
 11528			sym := v.Aux
 11529			mem := v.Args[2]
 11530			idx := v.Args[0]
 11531			v_1 := v.Args[1]
 11532			if v_1.Op != OpS390XADDconst {
 11533				break
 11534			}
 11535			d := v_1.AuxInt
 11536			ptr := v_1.Args[0]
 11537			if !(is20Bit(c + d)) {
 11538				break
 11539			}
 11540			v.reset(OpS390XMOVBloadidx)
 11541			v.AuxInt = c + d
 11542			v.Aux = sym
 11543			v.AddArg(ptr)
 11544			v.AddArg(idx)
 11545			v.AddArg(mem)
 11546			return true
 11547		}
 11548		// match: (MOVBloadidx [c] {sym} ptr (ADDconst [d] idx) mem)
 11549		// cond: is20Bit(c+d)
 11550		// result: (MOVBloadidx [c+d] {sym} ptr idx mem)
 11551		for {
 11552			c := v.AuxInt
 11553			sym := v.Aux
 11554			mem := v.Args[2]
 11555			ptr := v.Args[0]
 11556			v_1 := v.Args[1]
 11557			if v_1.Op != OpS390XADDconst {
 11558				break
 11559			}
 11560			d := v_1.AuxInt
 11561			idx := v_1.Args[0]
 11562			if !(is20Bit(c + d)) {
 11563				break
 11564			}
 11565			v.reset(OpS390XMOVBloadidx)
 11566			v.AuxInt = c + d
 11567			v.Aux = sym
 11568			v.AddArg(ptr)
 11569			v.AddArg(idx)
 11570			v.AddArg(mem)
 11571			return true
 11572		}
 11573		// match: (MOVBloadidx [c] {sym} (ADDconst [d] idx) ptr mem)
 11574		// cond: is20Bit(c+d)
 11575		// result: (MOVBloadidx [c+d] {sym} ptr idx mem)
 11576		for {
 11577			c := v.AuxInt
 11578			sym := v.Aux
 11579			mem := v.Args[2]
 11580			v_0 := v.Args[0]
 11581			if v_0.Op != OpS390XADDconst {
 11582				break
 11583			}
 11584			d := v_0.AuxInt
 11585			idx := v_0.Args[0]
 11586			ptr := v.Args[1]
 11587			if !(is20Bit(c + d)) {
 11588				break
 11589			}
 11590			v.reset(OpS390XMOVBloadidx)
 11591			v.AuxInt = c + d
 11592			v.Aux = sym
 11593			v.AddArg(ptr)
 11594			v.AddArg(idx)
 11595			v.AddArg(mem)
 11596			return true
 11597		}
 11598		return false
 11599	}
 11600	func rewriteValueS390X_OpS390XMOVBreg_0(v *Value) bool {
 11601		b := v.Block
 11602		typ := &b.Func.Config.Types
 11603		// match: (MOVBreg x:(MOVBload _ _))
 11604		// cond:
 11605		// result: (MOVDreg x)
 11606		for {
 11607			x := v.Args[0]
 11608			if x.Op != OpS390XMOVBload {
 11609				break
 11610			}
 11611			_ = x.Args[1]
 11612			v.reset(OpS390XMOVDreg)
 11613			v.AddArg(x)
 11614			return true
 11615		}
 11616		// match: (MOVBreg x:(Arg <t>))
 11617		// cond: is8BitInt(t) && isSigned(t)
 11618		// result: (MOVDreg x)
 11619		for {
 11620			x := v.Args[0]
 11621			if x.Op != OpArg {
 11622				break
 11623			}
 11624			t := x.Type
 11625			if !(is8BitInt(t) && isSigned(t)) {
 11626				break
 11627			}
 11628			v.reset(OpS390XMOVDreg)
 11629			v.AddArg(x)
 11630			return true
 11631		}
 11632		// match: (MOVBreg x:(MOVBreg _))
 11633		// cond:
 11634		// result: (MOVDreg x)
 11635		for {
 11636			x := v.Args[0]
 11637			if x.Op != OpS390XMOVBreg {
 11638				break
 11639			}
 11640			v.reset(OpS390XMOVDreg)
 11641			v.AddArg(x)
 11642			return true
 11643		}
 11644		// match: (MOVBreg (MOVBZreg x))
 11645		// cond:
 11646		// result: (MOVBreg x)
 11647		for {
 11648			v_0 := v.Args[0]
 11649			if v_0.Op != OpS390XMOVBZreg {
 11650				break
 11651			}
 11652			x := v_0.Args[0]
 11653			v.reset(OpS390XMOVBreg)
 11654			v.AddArg(x)
 11655			return true
 11656		}
 11657		// match: (MOVBreg (MOVDconst [c]))
 11658		// cond:
 11659		// result: (MOVDconst [int64(int8(c))])
 11660		for {
 11661			v_0 := v.Args[0]
 11662			if v_0.Op != OpS390XMOVDconst {
 11663				break
 11664			}
 11665			c := v_0.AuxInt
 11666			v.reset(OpS390XMOVDconst)
 11667			v.AuxInt = int64(int8(c))
 11668			return true
 11669		}
 11670		// match: (MOVBreg x:(MOVBZload [off] {sym} ptr mem))
 11671		// cond: x.Uses == 1 && clobber(x)
 11672		// result: @x.Block (MOVBload <v.Type> [off] {sym} ptr mem)
 11673		for {
 11674			x := v.Args[0]
 11675			if x.Op != OpS390XMOVBZload {
 11676				break
 11677			}
 11678			off := x.AuxInt
 11679			sym := x.Aux
 11680			mem := x.Args[1]
 11681			ptr := x.Args[0]
 11682			if !(x.Uses == 1 && clobber(x)) {
 11683				break
 11684			}
 11685			b = x.Block
 11686			v0 := b.NewValue0(x.Pos, OpS390XMOVBload, v.Type)
 11687			v.reset(OpCopy)
 11688			v.AddArg(v0)
 11689			v0.AuxInt = off
 11690			v0.Aux = sym
 11691			v0.AddArg(ptr)
 11692			v0.AddArg(mem)
 11693			return true
 11694		}
 11695		// match: (MOVBreg x:(MOVBload [off] {sym} ptr mem))
 11696		// cond: x.Uses == 1 && clobber(x)
 11697		// result: @x.Block (MOVBload <v.Type> [off] {sym} ptr mem)
 11698		for {
 11699			x := v.Args[0]
 11700			if x.Op != OpS390XMOVBload {
 11701				break
 11702			}
 11703			off := x.AuxInt
 11704			sym := x.Aux
 11705			mem := x.Args[1]
 11706			ptr := x.Args[0]
 11707			if !(x.Uses == 1 && clobber(x)) {
 11708				break
 11709			}
 11710			b = x.Block
 11711			v0 := b.NewValue0(x.Pos, OpS390XMOVBload, v.Type)
 11712			v.reset(OpCopy)
 11713			v.AddArg(v0)
 11714			v0.AuxInt = off
 11715			v0.Aux = sym
 11716			v0.AddArg(ptr)
 11717			v0.AddArg(mem)
 11718			return true
 11719		}
 11720		// match: (MOVBreg x:(MOVBZloadidx [off] {sym} ptr idx mem))
 11721		// cond: x.Uses == 1 && clobber(x)
 11722		// result: @x.Block (MOVBloadidx <v.Type> [off] {sym} ptr idx mem)
 11723		for {
 11724			x := v.Args[0]
 11725			if x.Op != OpS390XMOVBZloadidx {
 11726				break
 11727			}
 11728			off := x.AuxInt
 11729			sym := x.Aux
 11730			mem := x.Args[2]
 11731			ptr := x.Args[0]
 11732			idx := x.Args[1]
 11733			if !(x.Uses == 1 && clobber(x)) {
 11734				break
 11735			}
 11736			b = x.Block
 11737			v0 := b.NewValue0(v.Pos, OpS390XMOVBloadidx, v.Type)
 11738			v.reset(OpCopy)
 11739			v.AddArg(v0)
 11740			v0.AuxInt = off
 11741			v0.Aux = sym
 11742			v0.AddArg(ptr)
 11743			v0.AddArg(idx)
 11744			v0.AddArg(mem)
 11745			return true
 11746		}
 11747		// match: (MOVBreg x:(MOVBloadidx [off] {sym} ptr idx mem))
 11748		// cond: x.Uses == 1 && clobber(x)
 11749		// result: @x.Block (MOVBloadidx <v.Type> [off] {sym} ptr idx mem)
 11750		for {
 11751			x := v.Args[0]
 11752			if x.Op != OpS390XMOVBloadidx {
 11753				break
 11754			}
 11755			off := x.AuxInt
 11756			sym := x.Aux
 11757			mem := x.Args[2]
 11758			ptr := x.Args[0]
 11759			idx := x.Args[1]
 11760			if !(x.Uses == 1 && clobber(x)) {
 11761				break
 11762			}
 11763			b = x.Block
 11764			v0 := b.NewValue0(v.Pos, OpS390XMOVBloadidx, v.Type)
 11765			v.reset(OpCopy)
 11766			v.AddArg(v0)
 11767			v0.AuxInt = off
 11768			v0.Aux = sym
 11769			v0.AddArg(ptr)
 11770			v0.AddArg(idx)
 11771			v0.AddArg(mem)
 11772			return true
 11773		}
 11774		// match: (MOVBreg (ANDWconst [m] x))
 11775		// cond: int8(m) >= 0
 11776		// result: (MOVWZreg (ANDWconst <typ.UInt32> [int64( uint8(m))] x))
 11777		for {
 11778			v_0 := v.Args[0]
 11779			if v_0.Op != OpS390XANDWconst {
 11780				break
 11781			}
 11782			m := v_0.AuxInt
 11783			x := v_0.Args[0]
 11784			if !(int8(m) >= 0) {
 11785				break
 11786			}
 11787			v.reset(OpS390XMOVWZreg)
 11788			v0 := b.NewValue0(v.Pos, OpS390XANDWconst, typ.UInt32)
 11789			v0.AuxInt = int64(uint8(m))
 11790			v0.AddArg(x)
 11791			v.AddArg(v0)
 11792			return true
 11793		}
 11794		return false
 11795	}
 11796	func rewriteValueS390X_OpS390XMOVBstore_0(v *Value) bool {
 11797		// match: (MOVBstore [off] {sym} ptr (MOVBreg x) mem)
 11798		// cond:
 11799		// result: (MOVBstore [off] {sym} ptr x mem)
 11800		for {
 11801			off := v.AuxInt
 11802			sym := v.Aux
 11803			mem := v.Args[2]
 11804			ptr := v.Args[0]
 11805			v_1 := v.Args[1]
 11806			if v_1.Op != OpS390XMOVBreg {
 11807				break
 11808			}
 11809			x := v_1.Args[0]
 11810			v.reset(OpS390XMOVBstore)
 11811			v.AuxInt = off
 11812			v.Aux = sym
 11813			v.AddArg(ptr)
 11814			v.AddArg(x)
 11815			v.AddArg(mem)
 11816			return true
 11817		}
 11818		// match: (MOVBstore [off] {sym} ptr (MOVBZreg x) mem)
 11819		// cond:
 11820		// result: (MOVBstore [off] {sym} ptr x mem)
 11821		for {
 11822			off := v.AuxInt
 11823			sym := v.Aux
 11824			mem := v.Args[2]
 11825			ptr := v.Args[0]
 11826			v_1 := v.Args[1]
 11827			if v_1.Op != OpS390XMOVBZreg {
 11828				break
 11829			}
 11830			x := v_1.Args[0]
 11831			v.reset(OpS390XMOVBstore)
 11832			v.AuxInt = off
 11833			v.Aux = sym
 11834			v.AddArg(ptr)
 11835			v.AddArg(x)
 11836			v.AddArg(mem)
 11837			return true
 11838		}
 11839		// match: (MOVBstore [off1] {sym} (ADDconst [off2] ptr) val mem)
 11840		// cond: is20Bit(off1+off2)
 11841		// result: (MOVBstore [off1+off2] {sym} ptr val mem)
 11842		for {
 11843			off1 := v.AuxInt
 11844			sym := v.Aux
 11845			mem := v.Args[2]
 11846			v_0 := v.Args[0]
 11847			if v_0.Op != OpS390XADDconst {
 11848				break
 11849			}
 11850			off2 := v_0.AuxInt
 11851			ptr := v_0.Args[0]
 11852			val := v.Args[1]
 11853			if !(is20Bit(off1 + off2)) {
 11854				break
 11855			}
 11856			v.reset(OpS390XMOVBstore)
 11857			v.AuxInt = off1 + off2
 11858			v.Aux = sym
 11859			v.AddArg(ptr)
 11860			v.AddArg(val)
 11861			v.AddArg(mem)
 11862			return true
 11863		}
 11864		// match: (MOVBstore [off] {sym} ptr (MOVDconst [c]) mem)
 11865		// cond: is20Bit(off) && ptr.Op != OpSB
 11866		// result: (MOVBstoreconst [makeValAndOff(int64(int8(c)),off)] {sym} ptr mem)
 11867		for {
 11868			off := v.AuxInt
 11869			sym := v.Aux
 11870			mem := v.Args[2]
 11871			ptr := v.Args[0]
 11872			v_1 := v.Args[1]
 11873			if v_1.Op != OpS390XMOVDconst {
 11874				break
 11875			}
 11876			c := v_1.AuxInt
 11877			if !(is20Bit(off) && ptr.Op != OpSB) {
 11878				break
 11879			}
 11880			v.reset(OpS390XMOVBstoreconst)
 11881			v.AuxInt = makeValAndOff(int64(int8(c)), off)
 11882			v.Aux = sym
 11883			v.AddArg(ptr)
 11884			v.AddArg(mem)
 11885			return true
 11886		}
 11887		// match: (MOVBstore [off1] {sym1} (MOVDaddr [off2] {sym2} base) val mem)
 11888		// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
 11889		// result: (MOVBstore [off1+off2] {mergeSym(sym1,sym2)} base val mem)
 11890		for {
 11891			off1 := v.AuxInt
 11892			sym1 := v.Aux
 11893			mem := v.Args[2]
 11894			v_0 := v.Args[0]
 11895			if v_0.Op != OpS390XMOVDaddr {
 11896				break
 11897			}
 11898			off2 := v_0.AuxInt
 11899			sym2 := v_0.Aux
 11900			base := v_0.Args[0]
 11901			val := v.Args[1]
 11902			if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
 11903				break
 11904			}
 11905			v.reset(OpS390XMOVBstore)
 11906			v.AuxInt = off1 + off2
 11907			v.Aux = mergeSym(sym1, sym2)
 11908			v.AddArg(base)
 11909			v.AddArg(val)
 11910			v.AddArg(mem)
 11911			return true
 11912		}
 11913		// match: (MOVBstore [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) val mem)
 11914		// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
 11915		// result: (MOVBstoreidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx val mem)
 11916		for {
 11917			off1 := v.AuxInt
 11918			sym1 := v.Aux
 11919			mem := v.Args[2]
 11920			v_0 := v.Args[0]
 11921			if v_0.Op != OpS390XMOVDaddridx {
 11922				break
 11923			}
 11924			off2 := v_0.AuxInt
 11925			sym2 := v_0.Aux
 11926			idx := v_0.Args[1]
 11927			ptr := v_0.Args[0]
 11928			val := v.Args[1]
 11929			if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
 11930				break
 11931			}
 11932			v.reset(OpS390XMOVBstoreidx)
 11933			v.AuxInt = off1 + off2
 11934			v.Aux = mergeSym(sym1, sym2)
 11935			v.AddArg(ptr)
 11936			v.AddArg(idx)
 11937			v.AddArg(val)
 11938			v.AddArg(mem)
 11939			return true
 11940		}
 11941		// match: (MOVBstore [off] {sym} (ADD ptr idx) val mem)
 11942		// cond: ptr.Op != OpSB
 11943		// result: (MOVBstoreidx [off] {sym} ptr idx val mem)
 11944		for {
 11945			off := v.AuxInt
 11946			sym := v.Aux
 11947			mem := v.Args[2]
 11948			v_0 := v.Args[0]
 11949			if v_0.Op != OpS390XADD {
 11950				break
 11951			}
 11952			idx := v_0.Args[1]
 11953			ptr := v_0.Args[0]
 11954			val := v.Args[1]
 11955			if !(ptr.Op != OpSB) {
 11956				break
 11957			}
 11958			v.reset(OpS390XMOVBstoreidx)
 11959			v.AuxInt = off
 11960			v.Aux = sym
 11961			v.AddArg(ptr)
 11962			v.AddArg(idx)
 11963			v.AddArg(val)
 11964			v.AddArg(mem)
 11965			return true
 11966		}
 11967		// match: (MOVBstore [i] {s} p w x:(MOVBstore [i-1] {s} p (SRDconst [8] w) mem))
 11968		// cond: p.Op != OpSB && x.Uses == 1 && clobber(x)
 11969		// result: (MOVHstore [i-1] {s} p w mem)
 11970		for {
 11971			i := v.AuxInt
 11972			s := v.Aux
 11973			_ = v.Args[2]
 11974			p := v.Args[0]
 11975			w := v.Args[1]
 11976			x := v.Args[2]
 11977			if x.Op != OpS390XMOVBstore {
 11978				break
 11979			}
 11980			if x.AuxInt != i-1 {
 11981				break
 11982			}
 11983			if x.Aux != s {
 11984				break
 11985			}
 11986			mem := x.Args[2]
 11987			if p != x.Args[0] {
 11988				break
 11989			}
 11990			x_1 := x.Args[1]
 11991			if x_1.Op != OpS390XSRDconst {
 11992				break
 11993			}
 11994			if x_1.AuxInt != 8 {
 11995				break
 11996			}
 11997			if w != x_1.Args[0] {
 11998				break
 11999			}
 12000			if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
 12001				break
 12002			}
 12003			v.reset(OpS390XMOVHstore)
 12004			v.AuxInt = i - 1
 12005			v.Aux = s
 12006			v.AddArg(p)
 12007			v.AddArg(w)
 12008			v.AddArg(mem)
 12009			return true
 12010		}
 12011		// match: (MOVBstore [i] {s} p w0:(SRDconst [j] w) x:(MOVBstore [i-1] {s} p (SRDconst [j+8] w) mem))
 12012		// cond: p.Op != OpSB && x.Uses == 1 && clobber(x)
 12013		// result: (MOVHstore [i-1] {s} p w0 mem)
 12014		for {
 12015			i := v.AuxInt
 12016			s := v.Aux
 12017			_ = v.Args[2]
 12018			p := v.Args[0]
 12019			w0 := v.Args[1]
 12020			if w0.Op != OpS390XSRDconst {
 12021				break
 12022			}
 12023			j := w0.AuxInt
 12024			w := w0.Args[0]
 12025			x := v.Args[2]
 12026			if x.Op != OpS390XMOVBstore {
 12027				break
 12028			}
 12029			if x.AuxInt != i-1 {
 12030				break
 12031			}
 12032			if x.Aux != s {
 12033				break
 12034			}
 12035			mem := x.Args[2]
 12036			if p != x.Args[0] {
 12037				break
 12038			}
 12039			x_1 := x.Args[1]
 12040			if x_1.Op != OpS390XSRDconst {
 12041				break
 12042			}
 12043			if x_1.AuxInt != j+8 {
 12044				break
 12045			}
 12046			if w != x_1.Args[0] {
 12047				break
 12048			}
 12049			if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
 12050				break
 12051			}
 12052			v.reset(OpS390XMOVHstore)
 12053			v.AuxInt = i - 1
 12054			v.Aux = s
 12055			v.AddArg(p)
 12056			v.AddArg(w0)
 12057			v.AddArg(mem)
 12058			return true
 12059		}
 12060		// match: (MOVBstore [i] {s} p w x:(MOVBstore [i-1] {s} p (SRWconst [8] w) mem))
 12061		// cond: p.Op != OpSB && x.Uses == 1 && clobber(x)
 12062		// result: (MOVHstore [i-1] {s} p w mem)
 12063		for {
 12064			i := v.AuxInt
 12065			s := v.Aux
 12066			_ = v.Args[2]
 12067			p := v.Args[0]
 12068			w := v.Args[1]
 12069			x := v.Args[2]
 12070			if x.Op != OpS390XMOVBstore {
 12071				break
 12072			}
 12073			if x.AuxInt != i-1 {
 12074				break
 12075			}
 12076			if x.Aux != s {
 12077				break
 12078			}
 12079			mem := x.Args[2]
 12080			if p != x.Args[0] {
 12081				break
 12082			}
 12083			x_1 := x.Args[1]
 12084			if x_1.Op != OpS390XSRWconst {
 12085				break
 12086			}
 12087			if x_1.AuxInt != 8 {
 12088				break
 12089			}
 12090			if w != x_1.Args[0] {
 12091				break
 12092			}
 12093			if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
 12094				break
 12095			}
 12096			v.reset(OpS390XMOVHstore)
 12097			v.AuxInt = i - 1
 12098			v.Aux = s
 12099			v.AddArg(p)
 12100			v.AddArg(w)
 12101			v.AddArg(mem)
 12102			return true
 12103		}
 12104		return false
 12105	}
 12106	func rewriteValueS390X_OpS390XMOVBstore_10(v *Value) bool {
 12107		// match: (MOVBstore [i] {s} p w0:(SRWconst [j] w) x:(MOVBstore [i-1] {s} p (SRWconst [j+8] w) mem))
 12108		// cond: p.Op != OpSB && x.Uses == 1 && clobber(x)
 12109		// result: (MOVHstore [i-1] {s} p w0 mem)
 12110		for {
 12111			i := v.AuxInt
 12112			s := v.Aux
 12113			_ = v.Args[2]
 12114			p := v.Args[0]
 12115			w0 := v.Args[1]
 12116			if w0.Op != OpS390XSRWconst {
 12117				break
 12118			}
 12119			j := w0.AuxInt
 12120			w := w0.Args[0]
 12121			x := v.Args[2]
 12122			if x.Op != OpS390XMOVBstore {
 12123				break
 12124			}
 12125			if x.AuxInt != i-1 {
 12126				break
 12127			}
 12128			if x.Aux != s {
 12129				break
 12130			}
 12131			mem := x.Args[2]
 12132			if p != x.Args[0] {
 12133				break
 12134			}
 12135			x_1 := x.Args[1]
 12136			if x_1.Op != OpS390XSRWconst {
 12137				break
 12138			}
 12139			if x_1.AuxInt != j+8 {
 12140				break
 12141			}
 12142			if w != x_1.Args[0] {
 12143				break
 12144			}
 12145			if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
 12146				break
 12147			}
 12148			v.reset(OpS390XMOVHstore)
 12149			v.AuxInt = i - 1
 12150			v.Aux = s
 12151			v.AddArg(p)
 12152			v.AddArg(w0)
 12153			v.AddArg(mem)
 12154			return true
 12155		}
 12156		// match: (MOVBstore [i] {s} p (SRDconst [8] w) x:(MOVBstore [i-1] {s} p w mem))
 12157		// cond: p.Op != OpSB && x.Uses == 1 && clobber(x)
 12158		// result: (MOVHBRstore [i-1] {s} p w mem)
 12159		for {
 12160			i := v.AuxInt
 12161			s := v.Aux
 12162			_ = v.Args[2]
 12163			p := v.Args[0]
 12164			v_1 := v.Args[1]
 12165			if v_1.Op != OpS390XSRDconst {
 12166				break
 12167			}
 12168			if v_1.AuxInt != 8 {
 12169				break
 12170			}
 12171			w := v_1.Args[0]
 12172			x := v.Args[2]
 12173			if x.Op != OpS390XMOVBstore {
 12174				break
 12175			}
 12176			if x.AuxInt != i-1 {
 12177				break
 12178			}
 12179			if x.Aux != s {
 12180				break
 12181			}
 12182			mem := x.Args[2]
 12183			if p != x.Args[0] {
 12184				break
 12185			}
 12186			if w != x.Args[1] {
 12187				break
 12188			}
 12189			if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
 12190				break
 12191			}
 12192			v.reset(OpS390XMOVHBRstore)
 12193			v.AuxInt = i - 1
 12194			v.Aux = s
 12195			v.AddArg(p)
 12196			v.AddArg(w)
 12197			v.AddArg(mem)
 12198			return true
 12199		}
 12200		// match: (MOVBstore [i] {s} p (SRDconst [j] w) x:(MOVBstore [i-1] {s} p w0:(SRDconst [j-8] w) mem))
 12201		// cond: p.Op != OpSB && x.Uses == 1 && clobber(x)
 12202		// result: (MOVHBRstore [i-1] {s} p w0 mem)
 12203		for {
 12204			i := v.AuxInt
 12205			s := v.Aux
 12206			_ = v.Args[2]
 12207			p := v.Args[0]
 12208			v_1 := v.Args[1]
 12209			if v_1.Op != OpS390XSRDconst {
 12210				break
 12211			}
 12212			j := v_1.AuxInt
 12213			w := v_1.Args[0]
 12214			x := v.Args[2]
 12215			if x.Op != OpS390XMOVBstore {
 12216				break
 12217			}
 12218			if x.AuxInt != i-1 {
 12219				break
 12220			}
 12221			if x.Aux != s {
 12222				break
 12223			}
 12224			mem := x.Args[2]
 12225			if p != x.Args[0] {
 12226				break
 12227			}
 12228			w0 := x.Args[1]
 12229			if w0.Op != OpS390XSRDconst {
 12230				break
 12231			}
 12232			if w0.AuxInt != j-8 {
 12233				break
 12234			}
 12235			if w != w0.Args[0] {
 12236				break
 12237			}
 12238			if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
 12239				break
 12240			}
 12241			v.reset(OpS390XMOVHBRstore)
 12242			v.AuxInt = i - 1
 12243			v.Aux = s
 12244			v.AddArg(p)
 12245			v.AddArg(w0)
 12246			v.AddArg(mem)
 12247			return true
 12248		}
 12249		// match: (MOVBstore [i] {s} p (SRWconst [8] w) x:(MOVBstore [i-1] {s} p w mem))
 12250		// cond: p.Op != OpSB && x.Uses == 1 && clobber(x)
 12251		// result: (MOVHBRstore [i-1] {s} p w mem)
 12252		for {
 12253			i := v.AuxInt
 12254			s := v.Aux
 12255			_ = v.Args[2]
 12256			p := v.Args[0]
 12257			v_1 := v.Args[1]
 12258			if v_1.Op != OpS390XSRWconst {
 12259				break
 12260			}
 12261			if v_1.AuxInt != 8 {
 12262				break
 12263			}
 12264			w := v_1.Args[0]
 12265			x := v.Args[2]
 12266			if x.Op != OpS390XMOVBstore {
 12267				break
 12268			}
 12269			if x.AuxInt != i-1 {
 12270				break
 12271			}
 12272			if x.Aux != s {
 12273				break
 12274			}
 12275			mem := x.Args[2]
 12276			if p != x.Args[0] {
 12277				break
 12278			}
 12279			if w != x.Args[1] {
 12280				break
 12281			}
 12282			if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
 12283				break
 12284			}
 12285			v.reset(OpS390XMOVHBRstore)
 12286			v.AuxInt = i - 1
 12287			v.Aux = s
 12288			v.AddArg(p)
 12289			v.AddArg(w)
 12290			v.AddArg(mem)
 12291			return true
 12292		}
 12293		// match: (MOVBstore [i] {s} p (SRWconst [j] w) x:(MOVBstore [i-1] {s} p w0:(SRWconst [j-8] w) mem))
 12294		// cond: p.Op != OpSB && x.Uses == 1 && clobber(x)
 12295		// result: (MOVHBRstore [i-1] {s} p w0 mem)
 12296		for {
 12297			i := v.AuxInt
 12298			s := v.Aux
 12299			_ = v.Args[2]
 12300			p := v.Args[0]
 12301			v_1 := v.Args[1]
 12302			if v_1.Op != OpS390XSRWconst {
 12303				break
 12304			}
 12305			j := v_1.AuxInt
 12306			w := v_1.Args[0]
 12307			x := v.Args[2]
 12308			if x.Op != OpS390XMOVBstore {
 12309				break
 12310			}
 12311			if x.AuxInt != i-1 {
 12312				break
 12313			}
 12314			if x.Aux != s {
 12315				break
 12316			}
 12317			mem := x.Args[2]
 12318			if p != x.Args[0] {
 12319				break
 12320			}
 12321			w0 := x.Args[1]
 12322			if w0.Op != OpS390XSRWconst {
 12323				break
 12324			}
 12325			if w0.AuxInt != j-8 {
 12326				break
 12327			}
 12328			if w != w0.Args[0] {
 12329				break
 12330			}
 12331			if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
 12332				break
 12333			}
 12334			v.reset(OpS390XMOVHBRstore)
 12335			v.AuxInt = i - 1
 12336			v.Aux = s
 12337			v.AddArg(p)
 12338			v.AddArg(w0)
 12339			v.AddArg(mem)
 12340			return true
 12341		}
 12342		return false
 12343	}
 12344	func rewriteValueS390X_OpS390XMOVBstoreconst_0(v *Value) bool {
 12345		// match: (MOVBstoreconst [sc] {s} (ADDconst [off] ptr) mem)
 12346		// cond: is20Bit(ValAndOff(sc).Off()+off)
 12347		// result: (MOVBstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
 12348		for {
 12349			sc := v.AuxInt
 12350			s := v.Aux
 12351			mem := v.Args[1]
 12352			v_0 := v.Args[0]
 12353			if v_0.Op != OpS390XADDconst {
 12354				break
 12355			}
 12356			off := v_0.AuxInt
 12357			ptr := v_0.Args[0]
 12358			if !(is20Bit(ValAndOff(sc).Off() + off)) {
 12359				break
 12360			}
 12361			v.reset(OpS390XMOVBstoreconst)
 12362			v.AuxInt = ValAndOff(sc).add(off)
 12363			v.Aux = s
 12364			v.AddArg(ptr)
 12365			v.AddArg(mem)
 12366			return true
 12367		}
 12368		// match: (MOVBstoreconst [sc] {sym1} (MOVDaddr [off] {sym2} ptr) mem)
 12369		// cond: ptr.Op != OpSB && canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)
 12370		// result: (MOVBstoreconst [ValAndOff(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem)
 12371		for {
 12372			sc := v.AuxInt
 12373			sym1 := v.Aux
 12374			mem := v.Args[1]
 12375			v_0 := v.Args[0]
 12376			if v_0.Op != OpS390XMOVDaddr {
 12377				break
 12378			}
 12379			off := v_0.AuxInt
 12380			sym2 := v_0.Aux
 12381			ptr := v_0.Args[0]
 12382			if !(ptr.Op != OpSB && canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)) {
 12383				break
 12384			}
 12385			v.reset(OpS390XMOVBstoreconst)
 12386			v.AuxInt = ValAndOff(sc).add(off)
 12387			v.Aux = mergeSym(sym1, sym2)
 12388			v.AddArg(ptr)
 12389			v.AddArg(mem)
 12390			return true
 12391		}
 12392		// match: (MOVBstoreconst [c] {s} p x:(MOVBstoreconst [a] {s} p mem))
 12393		// cond: p.Op != OpSB && x.Uses == 1 && ValAndOff(a).Off() + 1 == ValAndOff(c).Off() && clobber(x)
 12394		// result: (MOVHstoreconst [makeValAndOff(ValAndOff(c).Val()&0xff | ValAndOff(a).Val()<<8, ValAndOff(a).Off())] {s} p mem)
 12395		for {
 12396			c := v.AuxInt
 12397			s := v.Aux
 12398			_ = v.Args[1]
 12399			p := v.Args[0]
 12400			x := v.Args[1]
 12401			if x.Op != OpS390XMOVBstoreconst {
 12402				break
 12403			}
 12404			a := x.AuxInt
 12405			if x.Aux != s {
 12406				break
 12407			}
 12408			mem := x.Args[1]
 12409			if p != x.Args[0] {
 12410				break
 12411			}
 12412			if !(p.Op != OpSB && x.Uses == 1 && ValAndOff(a).Off()+1 == ValAndOff(c).Off() && clobber(x)) {
 12413				break
 12414			}
 12415			v.reset(OpS390XMOVHstoreconst)
 12416			v.AuxInt = makeValAndOff(ValAndOff(c).Val()&0xff|ValAndOff(a).Val()<<8, ValAndOff(a).Off())
 12417			v.Aux = s
 12418			v.AddArg(p)
 12419			v.AddArg(mem)
 12420			return true
 12421		}
 12422		return false
 12423	}
 12424	func rewriteValueS390X_OpS390XMOVBstoreidx_0(v *Value) bool {
 12425		// match: (MOVBstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem)
 12426		// cond: is20Bit(c+d)
 12427		// result: (MOVBstoreidx [c+d] {sym} ptr idx val mem)
 12428		for {
 12429			c := v.AuxInt
 12430			sym := v.Aux
 12431			mem := v.Args[3]
 12432			v_0 := v.Args[0]
 12433			if v_0.Op != OpS390XADDconst {
 12434				break
 12435			}
 12436			d := v_0.AuxInt
 12437			ptr := v_0.Args[0]
 12438			idx := v.Args[1]
 12439			val := v.Args[2]
 12440			if !(is20Bit(c + d)) {
 12441				break
 12442			}
 12443			v.reset(OpS390XMOVBstoreidx)
 12444			v.AuxInt = c + d
 12445			v.Aux = sym
 12446			v.AddArg(ptr)
 12447			v.AddArg(idx)
 12448			v.AddArg(val)
 12449			v.AddArg(mem)
 12450			return true
 12451		}
 12452		// match: (MOVBstoreidx [c] {sym} idx (ADDconst [d] ptr) val mem)
 12453		// cond: is20Bit(c+d)
 12454		// result: (MOVBstoreidx [c+d] {sym} ptr idx val mem)
 12455		for {
 12456			c := v.AuxInt
 12457			sym := v.Aux
 12458			mem := v.Args[3]
 12459			idx := v.Args[0]
 12460			v_1 := v.Args[1]
 12461			if v_1.Op != OpS390XADDconst {
 12462				break
 12463			}
 12464			d := v_1.AuxInt
 12465			ptr := v_1.Args[0]
 12466			val := v.Args[2]
 12467			if !(is20Bit(c + d)) {
 12468				break
 12469			}
 12470			v.reset(OpS390XMOVBstoreidx)
 12471			v.AuxInt = c + d
 12472			v.Aux = sym
 12473			v.AddArg(ptr)
 12474			v.AddArg(idx)
 12475			v.AddArg(val)
 12476			v.AddArg(mem)
 12477			return true
 12478		}
 12479		// match: (MOVBstoreidx [c] {sym} ptr (ADDconst [d] idx) val mem)
 12480		// cond: is20Bit(c+d)
 12481		// result: (MOVBstoreidx [c+d] {sym} ptr idx val mem)
 12482		for {
 12483			c := v.AuxInt
 12484			sym := v.Aux
 12485			mem := v.Args[3]
 12486			ptr := v.Args[0]
 12487			v_1 := v.Args[1]
 12488			if v_1.Op != OpS390XADDconst {
 12489				break
 12490			}
 12491			d := v_1.AuxInt
 12492			idx := v_1.Args[0]
 12493			val := v.Args[2]
 12494			if !(is20Bit(c + d)) {
 12495				break
 12496			}
 12497			v.reset(OpS390XMOVBstoreidx)
 12498			v.AuxInt = c + d
 12499			v.Aux = sym
 12500			v.AddArg(ptr)
 12501			v.AddArg(idx)
 12502			v.AddArg(val)
 12503			v.AddArg(mem)
 12504			return true
 12505		}
 12506		// match: (MOVBstoreidx [c] {sym} (ADDconst [d] idx) ptr val mem)
 12507		// cond: is20Bit(c+d)
 12508		// result: (MOVBstoreidx [c+d] {sym} ptr idx val mem)
 12509		for {
 12510			c := v.AuxInt
 12511			sym := v.Aux
 12512			mem := v.Args[3]
 12513			v_0 := v.Args[0]
 12514			if v_0.Op != OpS390XADDconst {
 12515				break
 12516			}
 12517			d := v_0.AuxInt
 12518			idx := v_0.Args[0]
 12519			ptr := v.Args[1]
 12520			val := v.Args[2]
 12521			if !(is20Bit(c + d)) {
 12522				break
 12523			}
 12524			v.reset(OpS390XMOVBstoreidx)
 12525			v.AuxInt = c + d
 12526			v.Aux = sym
 12527			v.AddArg(ptr)
 12528			v.AddArg(idx)
 12529			v.AddArg(val)
 12530			v.AddArg(mem)
 12531			return true
 12532		}
 12533		// match: (MOVBstoreidx [i] {s} p idx w x:(MOVBstoreidx [i-1] {s} p idx (SRDconst [8] w) mem))
 12534		// cond: x.Uses == 1 && clobber(x)
 12535		// result: (MOVHstoreidx [i-1] {s} p idx w mem)
 12536		for {
 12537			i := v.AuxInt
 12538			s := v.Aux
 12539			_ = v.Args[3]
 12540			p := v.Args[0]
 12541			idx := v.Args[1]
 12542			w := v.Args[2]
 12543			x := v.Args[3]
 12544			if x.Op != OpS390XMOVBstoreidx {
 12545				break
 12546			}
 12547			if x.AuxInt != i-1 {
 12548				break
 12549			}
 12550			if x.Aux != s {
 12551				break
 12552			}
 12553			mem := x.Args[3]
 12554			if p != x.Args[0] {
 12555				break
 12556			}
 12557			if idx != x.Args[1] {
 12558				break
 12559			}
 12560			x_2 := x.Args[2]
 12561			if x_2.Op != OpS390XSRDconst {
 12562				break
 12563			}
 12564			if x_2.AuxInt != 8 {
 12565				break
 12566			}
 12567			if w != x_2.Args[0] {
 12568				break
 12569			}
 12570			if !(x.Uses == 1 && clobber(x)) {
 12571				break
 12572			}
 12573			v.reset(OpS390XMOVHstoreidx)
 12574			v.AuxInt = i - 1
 12575			v.Aux = s
 12576			v.AddArg(p)
 12577			v.AddArg(idx)
 12578			v.AddArg(w)
 12579			v.AddArg(mem)
 12580			return true
 12581		}
 12582		// match: (MOVBstoreidx [i] {s} p idx w x:(MOVBstoreidx [i-1] {s} idx p (SRDconst [8] w) mem))
 12583		// cond: x.Uses == 1 && clobber(x)
 12584		// result: (MOVHstoreidx [i-1] {s} p idx w mem)
 12585		for {
 12586			i := v.AuxInt
 12587			s := v.Aux
 12588			_ = v.Args[3]
 12589			p := v.Args[0]
 12590			idx := v.Args[1]
 12591			w := v.Args[2]
 12592			x := v.Args[3]
 12593			if x.Op != OpS390XMOVBstoreidx {
 12594				break
 12595			}
 12596			if x.AuxInt != i-1 {
 12597				break
 12598			}
 12599			if x.Aux != s {
 12600				break
 12601			}
 12602			mem := x.Args[3]
 12603			if idx != x.Args[0] {
 12604				break
 12605			}
 12606			if p != x.Args[1] {
 12607				break
 12608			}
 12609			x_2 := x.Args[2]
 12610			if x_2.Op != OpS390XSRDconst {
 12611				break
 12612			}
 12613			if x_2.AuxInt != 8 {
 12614				break
 12615			}
 12616			if w != x_2.Args[0] {
 12617				break
 12618			}
 12619			if !(x.Uses == 1 && clobber(x)) {
 12620				break
 12621			}
 12622			v.reset(OpS390XMOVHstoreidx)
 12623			v.AuxInt = i - 1
 12624			v.Aux = s
 12625			v.AddArg(p)
 12626			v.AddArg(idx)
 12627			v.AddArg(w)
 12628			v.AddArg(mem)
 12629			return true
 12630		}
 12631		// match: (MOVBstoreidx [i] {s} idx p w x:(MOVBstoreidx [i-1] {s} p idx (SRDconst [8] w) mem))
 12632		// cond: x.Uses == 1 && clobber(x)
 12633		// result: (MOVHstoreidx [i-1] {s} p idx w mem)
 12634		for {
 12635			i := v.AuxInt
 12636			s := v.Aux
 12637			_ = v.Args[3]
 12638			idx := v.Args[0]
 12639			p := v.Args[1]
 12640			w := v.Args[2]
 12641			x := v.Args[3]
 12642			if x.Op != OpS390XMOVBstoreidx {
 12643				break
 12644			}
 12645			if x.AuxInt != i-1 {
 12646				break
 12647			}
 12648			if x.Aux != s {
 12649				break
 12650			}
 12651			mem := x.Args[3]
 12652			if p != x.Args[0] {
 12653				break
 12654			}
 12655			if idx != x.Args[1] {
 12656				break
 12657			}
 12658			x_2 := x.Args[2]
 12659			if x_2.Op != OpS390XSRDconst {
 12660				break
 12661			}
 12662			if x_2.AuxInt != 8 {
 12663				break
 12664			}
 12665			if w != x_2.Args[0] {
 12666				break
 12667			}
 12668			if !(x.Uses == 1 && clobber(x)) {
 12669				break
 12670			}
 12671			v.reset(OpS390XMOVHstoreidx)
 12672			v.AuxInt = i - 1
 12673			v.Aux = s
 12674			v.AddArg(p)
 12675			v.AddArg(idx)
 12676			v.AddArg(w)
 12677			v.AddArg(mem)
 12678			return true
 12679		}
 12680		// match: (MOVBstoreidx [i] {s} idx p w x:(MOVBstoreidx [i-1] {s} idx p (SRDconst [8] w) mem))
 12681		// cond: x.Uses == 1 && clobber(x)
 12682		// result: (MOVHstoreidx [i-1] {s} p idx w mem)
 12683		for {
 12684			i := v.AuxInt
 12685			s := v.Aux
 12686			_ = v.Args[3]
 12687			idx := v.Args[0]
 12688			p := v.Args[1]
 12689			w := v.Args[2]
 12690			x := v.Args[3]
 12691			if x.Op != OpS390XMOVBstoreidx {
 12692				break
 12693			}
 12694			if x.AuxInt != i-1 {
 12695				break
 12696			}
 12697			if x.Aux != s {
 12698				break
 12699			}
 12700			mem := x.Args[3]
 12701			if idx != x.Args[0] {
 12702				break
 12703			}
 12704			if p != x.Args[1] {
 12705				break
 12706			}
 12707			x_2 := x.Args[2]
 12708			if x_2.Op != OpS390XSRDconst {
 12709				break
 12710			}
 12711			if x_2.AuxInt != 8 {
 12712				break
 12713			}
 12714			if w != x_2.Args[0] {
 12715				break
 12716			}
 12717			if !(x.Uses == 1 && clobber(x)) {
 12718				break
 12719			}
 12720			v.reset(OpS390XMOVHstoreidx)
 12721			v.AuxInt = i - 1
 12722			v.Aux = s
 12723			v.AddArg(p)
 12724			v.AddArg(idx)
 12725			v.AddArg(w)
 12726			v.AddArg(mem)
 12727			return true
 12728		}
 12729		// match: (MOVBstoreidx [i] {s} p idx w0:(SRDconst [j] w) x:(MOVBstoreidx [i-1] {s} p idx (SRDconst [j+8] w) mem))
 12730		// cond: x.Uses == 1 && clobber(x)
 12731		// result: (MOVHstoreidx [i-1] {s} p idx w0 mem)
 12732		for {
 12733			i := v.AuxInt
 12734			s := v.Aux
 12735			_ = v.Args[3]
 12736			p := v.Args[0]
 12737			idx := v.Args[1]
 12738			w0 := v.Args[2]
 12739			if w0.Op != OpS390XSRDconst {
 12740				break
 12741			}
 12742			j := w0.AuxInt
 12743			w := w0.Args[0]
 12744			x := v.Args[3]
 12745			if x.Op != OpS390XMOVBstoreidx {
 12746				break
 12747			}
 12748			if x.AuxInt != i-1 {
 12749				break
 12750			}
 12751			if x.Aux != s {
 12752				break
 12753			}
 12754			mem := x.Args[3]
 12755			if p != x.Args[0] {
 12756				break
 12757			}
 12758			if idx != x.Args[1] {
 12759				break
 12760			}
 12761			x_2 := x.Args[2]
 12762			if x_2.Op != OpS390XSRDconst {
 12763				break
 12764			}
 12765			if x_2.AuxInt != j+8 {
 12766				break
 12767			}
 12768			if w != x_2.Args[0] {
 12769				break
 12770			}
 12771			if !(x.Uses == 1 && clobber(x)) {
 12772				break
 12773			}
 12774			v.reset(OpS390XMOVHstoreidx)
 12775			v.AuxInt = i - 1
 12776			v.Aux = s
 12777			v.AddArg(p)
 12778			v.AddArg(idx)
 12779			v.AddArg(w0)
 12780			v.AddArg(mem)
 12781			return true
 12782		}
 12783		// match: (MOVBstoreidx [i] {s} p idx w0:(SRDconst [j] w) x:(MOVBstoreidx [i-1] {s} idx p (SRDconst [j+8] w) mem))
 12784		// cond: x.Uses == 1 && clobber(x)
 12785		// result: (MOVHstoreidx [i-1] {s} p idx w0 mem)
 12786		for {
 12787			i := v.AuxInt
 12788			s := v.Aux
 12789			_ = v.Args[3]
 12790			p := v.Args[0]
 12791			idx := v.Args[1]
 12792			w0 := v.Args[2]
 12793			if w0.Op != OpS390XSRDconst {
 12794				break
 12795			}
 12796			j := w0.AuxInt
 12797			w := w0.Args[0]
 12798			x := v.Args[3]
 12799			if x.Op != OpS390XMOVBstoreidx {
 12800				break
 12801			}
 12802			if x.AuxInt != i-1 {
 12803				break
 12804			}
 12805			if x.Aux != s {
 12806				break
 12807			}
 12808			mem := x.Args[3]
 12809			if idx != x.Args[0] {
 12810				break
 12811			}
 12812			if p != x.Args[1] {
 12813				break
 12814			}
 12815			x_2 := x.Args[2]
 12816			if x_2.Op != OpS390XSRDconst {
 12817				break
 12818			}
 12819			if x_2.AuxInt != j+8 {
 12820				break
 12821			}
 12822			if w != x_2.Args[0] {
 12823				break
 12824			}
 12825			if !(x.Uses == 1 && clobber(x)) {
 12826				break
 12827			}
 12828			v.reset(OpS390XMOVHstoreidx)
 12829			v.AuxInt = i - 1
 12830			v.Aux = s
 12831			v.AddArg(p)
 12832			v.AddArg(idx)
 12833			v.AddArg(w0)
 12834			v.AddArg(mem)
 12835			return true
 12836		}
 12837		return false
 12838	}
 12839	func rewriteValueS390X_OpS390XMOVBstoreidx_10(v *Value) bool {
 12840		// match: (MOVBstoreidx [i] {s} idx p w0:(SRDconst [j] w) x:(MOVBstoreidx [i-1] {s} p idx (SRDconst [j+8] w) mem))
 12841		// cond: x.Uses == 1 && clobber(x)
 12842		// result: (MOVHstoreidx [i-1] {s} p idx w0 mem)
 12843		for {
 12844			i := v.AuxInt
 12845			s := v.Aux
 12846			_ = v.Args[3]
 12847			idx := v.Args[0]
 12848			p := v.Args[1]
 12849			w0 := v.Args[2]
 12850			if w0.Op != OpS390XSRDconst {
 12851				break
 12852			}
 12853			j := w0.AuxInt
 12854			w := w0.Args[0]
 12855			x := v.Args[3]
 12856			if x.Op != OpS390XMOVBstoreidx {
 12857				break
 12858			}
 12859			if x.AuxInt != i-1 {
 12860				break
 12861			}
 12862			if x.Aux != s {
 12863				break
 12864			}
 12865			mem := x.Args[3]
 12866			if p != x.Args[0] {
 12867				break
 12868			}
 12869			if idx != x.Args[1] {
 12870				break
 12871			}
 12872			x_2 := x.Args[2]
 12873			if x_2.Op != OpS390XSRDconst {
 12874				break
 12875			}
 12876			if x_2.AuxInt != j+8 {
 12877				break
 12878			}
 12879			if w != x_2.Args[0] {
 12880				break
 12881			}
 12882			if !(x.Uses == 1 && clobber(x)) {
 12883				break
 12884			}
 12885			v.reset(OpS390XMOVHstoreidx)
 12886			v.AuxInt = i - 1
 12887			v.Aux = s
 12888			v.AddArg(p)
 12889			v.AddArg(idx)
 12890			v.AddArg(w0)
 12891			v.AddArg(mem)
 12892			return true
 12893		}
 12894		// match: (MOVBstoreidx [i] {s} idx p w0:(SRDconst [j] w) x:(MOVBstoreidx [i-1] {s} idx p (SRDconst [j+8] w) mem))
 12895		// cond: x.Uses == 1 && clobber(x)
 12896		// result: (MOVHstoreidx [i-1] {s} p idx w0 mem)
 12897		for {
 12898			i := v.AuxInt
 12899			s := v.Aux
 12900			_ = v.Args[3]
 12901			idx := v.Args[0]
 12902			p := v.Args[1]
 12903			w0 := v.Args[2]
 12904			if w0.Op != OpS390XSRDconst {
 12905				break
 12906			}
 12907			j := w0.AuxInt
 12908			w := w0.Args[0]
 12909			x := v.Args[3]
 12910			if x.Op != OpS390XMOVBstoreidx {
 12911				break
 12912			}
 12913			if x.AuxInt != i-1 {
 12914				break
 12915			}
 12916			if x.Aux != s {
 12917				break
 12918			}
 12919			mem := x.Args[3]
 12920			if idx != x.Args[0] {
 12921				break
 12922			}
 12923			if p != x.Args[1] {
 12924				break
 12925			}
 12926			x_2 := x.Args[2]
 12927			if x_2.Op != OpS390XSRDconst {
 12928				break
 12929			}
 12930			if x_2.AuxInt != j+8 {
 12931				break
 12932			}
 12933			if w != x_2.Args[0] {
 12934				break
 12935			}
 12936			if !(x.Uses == 1 && clobber(x)) {
 12937				break
 12938			}
 12939			v.reset(OpS390XMOVHstoreidx)
 12940			v.AuxInt = i - 1
 12941			v.Aux = s
 12942			v.AddArg(p)
 12943			v.AddArg(idx)
 12944			v.AddArg(w0)
 12945			v.AddArg(mem)
 12946			return true
 12947		}
 12948		// match: (MOVBstoreidx [i] {s} p idx w x:(MOVBstoreidx [i-1] {s} p idx (SRWconst [8] w) mem))
 12949		// cond: x.Uses == 1 && clobber(x)
 12950		// result: (MOVHstoreidx [i-1] {s} p idx w mem)
 12951		for {
 12952			i := v.AuxInt
 12953			s := v.Aux
 12954			_ = v.Args[3]
 12955			p := v.Args[0]
 12956			idx := v.Args[1]
 12957			w := v.Args[2]
 12958			x := v.Args[3]
 12959			if x.Op != OpS390XMOVBstoreidx {
 12960				break
 12961			}
 12962			if x.AuxInt != i-1 {
 12963				break
 12964			}
 12965			if x.Aux != s {
 12966				break
 12967			}
 12968			mem := x.Args[3]
 12969			if p != x.Args[0] {
 12970				break
 12971			}
 12972			if idx != x.Args[1] {
 12973				break
 12974			}
 12975			x_2 := x.Args[2]
 12976			if x_2.Op != OpS390XSRWconst {
 12977				break
 12978			}
 12979			if x_2.AuxInt != 8 {
 12980				break
 12981			}
 12982			if w != x_2.Args[0] {
 12983				break
 12984			}
 12985			if !(x.Uses == 1 && clobber(x)) {
 12986				break
 12987			}
 12988			v.reset(OpS390XMOVHstoreidx)
 12989			v.AuxInt = i - 1
 12990			v.Aux = s
 12991			v.AddArg(p)
 12992			v.AddArg(idx)
 12993			v.AddArg(w)
 12994			v.AddArg(mem)
 12995			return true
 12996		}
 12997		// match: (MOVBstoreidx [i] {s} p idx w x:(MOVBstoreidx [i-1] {s} idx p (SRWconst [8] w) mem))
 12998		// cond: x.Uses == 1 && clobber(x)
 12999		// result: (MOVHstoreidx [i-1] {s} p idx w mem)
 13000		for {
 13001			i := v.AuxInt
 13002			s := v.Aux
 13003			_ = v.Args[3]
 13004			p := v.Args[0]
 13005			idx := v.Args[1]
 13006			w := v.Args[2]
 13007			x := v.Args[3]
 13008			if x.Op != OpS390XMOVBstoreidx {
 13009				break
 13010			}
 13011			if x.AuxInt != i-1 {
 13012				break
 13013			}
 13014			if x.Aux != s {
 13015				break
 13016			}
 13017			mem := x.Args[3]
 13018			if idx != x.Args[0] {
 13019				break
 13020			}
 13021			if p != x.Args[1] {
 13022				break
 13023			}
 13024			x_2 := x.Args[2]
 13025			if x_2.Op != OpS390XSRWconst {
 13026				break
 13027			}
 13028			if x_2.AuxInt != 8 {
 13029				break
 13030			}
 13031			if w != x_2.Args[0] {
 13032				break
 13033			}
 13034			if !(x.Uses == 1 && clobber(x)) {
 13035				break
 13036			}
 13037			v.reset(OpS390XMOVHstoreidx)
 13038			v.AuxInt = i - 1
 13039			v.Aux = s
 13040			v.AddArg(p)
 13041			v.AddArg(idx)
 13042			v.AddArg(w)
 13043			v.AddArg(mem)
 13044			return true
 13045		}
 13046		// match: (MOVBstoreidx [i] {s} idx p w x:(MOVBstoreidx [i-1] {s} p idx (SRWconst [8] w) mem))
 13047		// cond: x.Uses == 1 && clobber(x)
 13048		// result: (MOVHstoreidx [i-1] {s} p idx w mem)
 13049		for {
 13050			i := v.AuxInt
 13051			s := v.Aux
 13052			_ = v.Args[3]
 13053			idx := v.Args[0]
 13054			p := v.Args[1]
 13055			w := v.Args[2]
 13056			x := v.Args[3]
 13057			if x.Op != OpS390XMOVBstoreidx {
 13058				break
 13059			}
 13060			if x.AuxInt != i-1 {
 13061				break
 13062			}
 13063			if x.Aux != s {
 13064				break
 13065			}
 13066			mem := x.Args[3]
 13067			if p != x.Args[0] {
 13068				break
 13069			}
 13070			if idx != x.Args[1] {
 13071				break
 13072			}
 13073			x_2 := x.Args[2]
 13074			if x_2.Op != OpS390XSRWconst {
 13075				break
 13076			}
 13077			if x_2.AuxInt != 8 {
 13078				break
 13079			}
 13080			if w != x_2.Args[0] {
 13081				break
 13082			}
 13083			if !(x.Uses == 1 && clobber(x)) {
 13084				break
 13085			}
 13086			v.reset(OpS390XMOVHstoreidx)
 13087			v.AuxInt = i - 1
 13088			v.Aux = s
 13089			v.AddArg(p)
 13090			v.AddArg(idx)
 13091			v.AddArg(w)
 13092			v.AddArg(mem)
 13093			return true
 13094		}
 13095		// match: (MOVBstoreidx [i] {s} idx p w x:(MOVBstoreidx [i-1] {s} idx p (SRWconst [8] w) mem))
 13096		// cond: x.Uses == 1 && clobber(x)
 13097		// result: (MOVHstoreidx [i-1] {s} p idx w mem)
 13098		for {
 13099			i := v.AuxInt
 13100			s := v.Aux
 13101			_ = v.Args[3]
 13102			idx := v.Args[0]
 13103			p := v.Args[1]
 13104			w := v.Args[2]
 13105			x := v.Args[3]
 13106			if x.Op != OpS390XMOVBstoreidx {
 13107				break
 13108			}
 13109			if x.AuxInt != i-1 {
 13110				break
 13111			}
 13112			if x.Aux != s {
 13113				break
 13114			}
 13115			mem := x.Args[3]
 13116			if idx != x.Args[0] {
 13117				break
 13118			}
 13119			if p != x.Args[1] {
 13120				break
 13121			}
 13122			x_2 := x.Args[2]
 13123			if x_2.Op != OpS390XSRWconst {
 13124				break
 13125			}
 13126			if x_2.AuxInt != 8 {
 13127				break
 13128			}
 13129			if w != x_2.Args[0] {
 13130				break
 13131			}
 13132			if !(x.Uses == 1 && clobber(x)) {
 13133				break
 13134			}
 13135			v.reset(OpS390XMOVHstoreidx)
 13136			v.AuxInt = i - 1
 13137			v.Aux = s
 13138			v.AddArg(p)
 13139			v.AddArg(idx)
 13140			v.AddArg(w)
 13141			v.AddArg(mem)
 13142			return true
 13143		}
 13144		// match: (MOVBstoreidx [i] {s} p idx w0:(SRWconst [j] w) x:(MOVBstoreidx [i-1] {s} p idx (SRWconst [j+8] w) mem))
 13145		// cond: x.Uses == 1 && clobber(x)
 13146		// result: (MOVHstoreidx [i-1] {s} p idx w0 mem)
 13147		for {
 13148			i := v.AuxInt
 13149			s := v.Aux
 13150			_ = v.Args[3]
 13151			p := v.Args[0]
 13152			idx := v.Args[1]
 13153			w0 := v.Args[2]
 13154			if w0.Op != OpS390XSRWconst {
 13155				break
 13156			}
 13157			j := w0.AuxInt
 13158			w := w0.Args[0]
 13159			x := v.Args[3]
 13160			if x.Op != OpS390XMOVBstoreidx {
 13161				break
 13162			}
 13163			if x.AuxInt != i-1 {
 13164				break
 13165			}
 13166			if x.Aux != s {
 13167				break
 13168			}
 13169			mem := x.Args[3]
 13170			if p != x.Args[0] {
 13171				break
 13172			}
 13173			if idx != x.Args[1] {
 13174				break
 13175			}
 13176			x_2 := x.Args[2]
 13177			if x_2.Op != OpS390XSRWconst {
 13178				break
 13179			}
 13180			if x_2.AuxInt != j+8 {
 13181				break
 13182			}
 13183			if w != x_2.Args[0] {
 13184				break
 13185			}
 13186			if !(x.Uses == 1 && clobber(x)) {
 13187				break
 13188			}
 13189			v.reset(OpS390XMOVHstoreidx)
 13190			v.AuxInt = i - 1
 13191			v.Aux = s
 13192			v.AddArg(p)
 13193			v.AddArg(idx)
 13194			v.AddArg(w0)
 13195			v.AddArg(mem)
 13196			return true
 13197		}
 13198		// match: (MOVBstoreidx [i] {s} p idx w0:(SRWconst [j] w) x:(MOVBstoreidx [i-1] {s} idx p (SRWconst [j+8] w) mem))
 13199		// cond: x.Uses == 1 && clobber(x)
 13200		// result: (MOVHstoreidx [i-1] {s} p idx w0 mem)
 13201		for {
 13202			i := v.AuxInt
 13203			s := v.Aux
 13204			_ = v.Args[3]
 13205			p := v.Args[0]
 13206			idx := v.Args[1]
 13207			w0 := v.Args[2]
 13208			if w0.Op != OpS390XSRWconst {
 13209				break
 13210			}
 13211			j := w0.AuxInt
 13212			w := w0.Args[0]
 13213			x := v.Args[3]
 13214			if x.Op != OpS390XMOVBstoreidx {
 13215				break
 13216			}
 13217			if x.AuxInt != i-1 {
 13218				break
 13219			}
 13220			if x.Aux != s {
 13221				break
 13222			}
 13223			mem := x.Args[3]
 13224			if idx != x.Args[0] {
 13225				break
 13226			}
 13227			if p != x.Args[1] {
 13228				break
 13229			}
 13230			x_2 := x.Args[2]
 13231			if x_2.Op != OpS390XSRWconst {
 13232				break
 13233			}
 13234			if x_2.AuxInt != j+8 {
 13235				break
 13236			}
 13237			if w != x_2.Args[0] {
 13238				break
 13239			}
 13240			if !(x.Uses == 1 && clobber(x)) {
 13241				break
 13242			}
 13243			v.reset(OpS390XMOVHstoreidx)
 13244			v.AuxInt = i - 1
 13245			v.Aux = s
 13246			v.AddArg(p)
 13247			v.AddArg(idx)
 13248			v.AddArg(w0)
 13249			v.AddArg(mem)
 13250			return true
 13251		}
 13252		// match: (MOVBstoreidx [i] {s} idx p w0:(SRWconst [j] w) x:(MOVBstoreidx [i-1] {s} p idx (SRWconst [j+8] w) mem))
 13253		// cond: x.Uses == 1 && clobber(x)
 13254		// result: (MOVHstoreidx [i-1] {s} p idx w0 mem)
 13255		for {
 13256			i := v.AuxInt
 13257			s := v.Aux
 13258			_ = v.Args[3]
 13259			idx := v.Args[0]
 13260			p := v.Args[1]
 13261			w0 := v.Args[2]
 13262			if w0.Op != OpS390XSRWconst {
 13263				break
 13264			}
 13265			j := w0.AuxInt
 13266			w := w0.Args[0]
 13267			x := v.Args[3]
 13268			if x.Op != OpS390XMOVBstoreidx {
 13269				break
 13270			}
 13271			if x.AuxInt != i-1 {
 13272				break
 13273			}
 13274			if x.Aux != s {
 13275				break
 13276			}
 13277			mem := x.Args[3]
 13278			if p != x.Args[0] {
 13279				break
 13280			}
 13281			if idx != x.Args[1] {
 13282				break
 13283			}
 13284			x_2 := x.Args[2]
 13285			if x_2.Op != OpS390XSRWconst {
 13286				break
 13287			}
 13288			if x_2.AuxInt != j+8 {
 13289				break
 13290			}
 13291			if w != x_2.Args[0] {
 13292				break
 13293			}
 13294			if !(x.Uses == 1 && clobber(x)) {
 13295				break
 13296			}
 13297			v.reset(OpS390XMOVHstoreidx)
 13298			v.AuxInt = i - 1
 13299			v.Aux = s
 13300			v.AddArg(p)
 13301			v.AddArg(idx)
 13302			v.AddArg(w0)
 13303			v.AddArg(mem)
 13304			return true
 13305		}
 13306		// match: (MOVBstoreidx [i] {s} idx p w0:(SRWconst [j] w) x:(MOVBstoreidx [i-1] {s} idx p (SRWconst [j+8] w) mem))
 13307		// cond: x.Uses == 1 && clobber(x)
 13308		// result: (MOVHstoreidx [i-1] {s} p idx w0 mem)
 13309		for {
 13310			i := v.AuxInt
 13311			s := v.Aux
 13312			_ = v.Args[3]
 13313			idx := v.Args[0]
 13314			p := v.Args[1]
 13315			w0 := v.Args[2]
 13316			if w0.Op != OpS390XSRWconst {
 13317				break
 13318			}
 13319			j := w0.AuxInt
 13320			w := w0.Args[0]
 13321			x := v.Args[3]
 13322			if x.Op != OpS390XMOVBstoreidx {
 13323				break
 13324			}
 13325			if x.AuxInt != i-1 {
 13326				break
 13327			}
 13328			if x.Aux != s {
 13329				break
 13330			}
 13331			mem := x.Args[3]
 13332			if idx != x.Args[0] {
 13333				break
 13334			}
 13335			if p != x.Args[1] {
 13336				break
 13337			}
 13338			x_2 := x.Args[2]
 13339			if x_2.Op != OpS390XSRWconst {
 13340				break
 13341			}
 13342			if x_2.AuxInt != j+8 {
 13343				break
 13344			}
 13345			if w != x_2.Args[0] {
 13346				break
 13347			}
 13348			if !(x.Uses == 1 && clobber(x)) {
 13349				break
 13350			}
 13351			v.reset(OpS390XMOVHstoreidx)
 13352			v.AuxInt = i - 1
 13353			v.Aux = s
 13354			v.AddArg(p)
 13355			v.AddArg(idx)
 13356			v.AddArg(w0)
 13357			v.AddArg(mem)
 13358			return true
 13359		}
 13360		return false
 13361	}
 13362	func rewriteValueS390X_OpS390XMOVBstoreidx_20(v *Value) bool {
 13363		// match: (MOVBstoreidx [i] {s} p idx (SRDconst [8] w) x:(MOVBstoreidx [i-1] {s} p idx w mem))
 13364		// cond: x.Uses == 1 && clobber(x)
 13365		// result: (MOVHBRstoreidx [i-1] {s} p idx w mem)
 13366		for {
 13367			i := v.AuxInt
 13368			s := v.Aux
 13369			_ = v.Args[3]
 13370			p := v.Args[0]
 13371			idx := v.Args[1]
 13372			v_2 := v.Args[2]
 13373			if v_2.Op != OpS390XSRDconst {
 13374				break
 13375			}
 13376			if v_2.AuxInt != 8 {
 13377				break
 13378			}
 13379			w := v_2.Args[0]
 13380			x := v.Args[3]
 13381			if x.Op != OpS390XMOVBstoreidx {
 13382				break
 13383			}
 13384			if x.AuxInt != i-1 {
 13385				break
 13386			}
 13387			if x.Aux != s {
 13388				break
 13389			}
 13390			mem := x.Args[3]
 13391			if p != x.Args[0] {
 13392				break
 13393			}
 13394			if idx != x.Args[1] {
 13395				break
 13396			}
 13397			if w != x.Args[2] {
 13398				break
 13399			}
 13400			if !(x.Uses == 1 && clobber(x)) {
 13401				break
 13402			}
 13403			v.reset(OpS390XMOVHBRstoreidx)
 13404			v.AuxInt = i - 1
 13405			v.Aux = s
 13406			v.AddArg(p)
 13407			v.AddArg(idx)
 13408			v.AddArg(w)
 13409			v.AddArg(mem)
 13410			return true
 13411		}
 13412		// match: (MOVBstoreidx [i] {s} p idx (SRDconst [8] w) x:(MOVBstoreidx [i-1] {s} idx p w mem))
 13413		// cond: x.Uses == 1 && clobber(x)
 13414		// result: (MOVHBRstoreidx [i-1] {s} p idx w mem)
 13415		for {
 13416			i := v.AuxInt
 13417			s := v.Aux
 13418			_ = v.Args[3]
 13419			p := v.Args[0]
 13420			idx := v.Args[1]
 13421			v_2 := v.Args[2]
 13422			if v_2.Op != OpS390XSRDconst {
 13423				break
 13424			}
 13425			if v_2.AuxInt != 8 {
 13426				break
 13427			}
 13428			w := v_2.Args[0]
 13429			x := v.Args[3]
 13430			if x.Op != OpS390XMOVBstoreidx {
 13431				break
 13432			}
 13433			if x.AuxInt != i-1 {
 13434				break
 13435			}
 13436			if x.Aux != s {
 13437				break
 13438			}
 13439			mem := x.Args[3]
 13440			if idx != x.Args[0] {
 13441				break
 13442			}
 13443			if p != x.Args[1] {
 13444				break
 13445			}
 13446			if w != x.Args[2] {
 13447				break
 13448			}
 13449			if !(x.Uses == 1 && clobber(x)) {
 13450				break
 13451			}
 13452			v.reset(OpS390XMOVHBRstoreidx)
 13453			v.AuxInt = i - 1
 13454			v.Aux = s
 13455			v.AddArg(p)
 13456			v.AddArg(idx)
 13457			v.AddArg(w)
 13458			v.AddArg(mem)
 13459			return true
 13460		}
 13461		// match: (MOVBstoreidx [i] {s} idx p (SRDconst [8] w) x:(MOVBstoreidx [i-1] {s} p idx w mem))
 13462		// cond: x.Uses == 1 && clobber(x)
 13463		// result: (MOVHBRstoreidx [i-1] {s} p idx w mem)
 13464		for {
 13465			i := v.AuxInt
 13466			s := v.Aux
 13467			_ = v.Args[3]
 13468			idx := v.Args[0]
 13469			p := v.Args[1]
 13470			v_2 := v.Args[2]
 13471			if v_2.Op != OpS390XSRDconst {
 13472				break
 13473			}
 13474			if v_2.AuxInt != 8 {
 13475				break
 13476			}
 13477			w := v_2.Args[0]
 13478			x := v.Args[3]
 13479			if x.Op != OpS390XMOVBstoreidx {
 13480				break
 13481			}
 13482			if x.AuxInt != i-1 {
 13483				break
 13484			}
 13485			if x.Aux != s {
 13486				break
 13487			}
 13488			mem := x.Args[3]
 13489			if p != x.Args[0] {
 13490				break
 13491			}
 13492			if idx != x.Args[1] {
 13493				break
 13494			}
 13495			if w != x.Args[2] {
 13496				break
 13497			}
 13498			if !(x.Uses == 1 && clobber(x)) {
 13499				break
 13500			}
 13501			v.reset(OpS390XMOVHBRstoreidx)
 13502			v.AuxInt = i - 1
 13503			v.Aux = s
 13504			v.AddArg(p)
 13505			v.AddArg(idx)
 13506			v.AddArg(w)
 13507			v.AddArg(mem)
 13508			return true
 13509		}
 13510		// match: (MOVBstoreidx [i] {s} idx p (SRDconst [8] w) x:(MOVBstoreidx [i-1] {s} idx p w mem))
 13511		// cond: x.Uses == 1 && clobber(x)
 13512		// result: (MOVHBRstoreidx [i-1] {s} p idx w mem)
 13513		for {
 13514			i := v.AuxInt
 13515			s := v.Aux
 13516			_ = v.Args[3]
 13517			idx := v.Args[0]
 13518			p := v.Args[1]
 13519			v_2 := v.Args[2]
 13520			if v_2.Op != OpS390XSRDconst {
 13521				break
 13522			}
 13523			if v_2.AuxInt != 8 {
 13524				break
 13525			}
 13526			w := v_2.Args[0]
 13527			x := v.Args[3]
 13528			if x.Op != OpS390XMOVBstoreidx {
 13529				break
 13530			}
 13531			if x.AuxInt != i-1 {
 13532				break
 13533			}
 13534			if x.Aux != s {
 13535				break
 13536			}
 13537			mem := x.Args[3]
 13538			if idx != x.Args[0] {
 13539				break
 13540			}
 13541			if p != x.Args[1] {
 13542				break
 13543			}
 13544			if w != x.Args[2] {
 13545				break
 13546			}
 13547			if !(x.Uses == 1 && clobber(x)) {
 13548				break
 13549			}
 13550			v.reset(OpS390XMOVHBRstoreidx)
 13551			v.AuxInt = i - 1
 13552			v.Aux = s
 13553			v.AddArg(p)
 13554			v.AddArg(idx)
 13555			v.AddArg(w)
 13556			v.AddArg(mem)
 13557			return true
 13558		}
 13559		// match: (MOVBstoreidx [i] {s} p idx (SRDconst [j] w) x:(MOVBstoreidx [i-1] {s} p idx w0:(SRDconst [j-8] w) mem))
 13560		// cond: x.Uses == 1 && clobber(x)
 13561		// result: (MOVHBRstoreidx [i-1] {s} p idx w0 mem)
 13562		for {
 13563			i := v.AuxInt
 13564			s := v.Aux
 13565			_ = v.Args[3]
 13566			p := v.Args[0]
 13567			idx := v.Args[1]
 13568			v_2 := v.Args[2]
 13569			if v_2.Op != OpS390XSRDconst {
 13570				break
 13571			}
 13572			j := v_2.AuxInt
 13573			w := v_2.Args[0]
 13574			x := v.Args[3]
 13575			if x.Op != OpS390XMOVBstoreidx {
 13576				break
 13577			}
 13578			if x.AuxInt != i-1 {
 13579				break
 13580			}
 13581			if x.Aux != s {
 13582				break
 13583			}
 13584			mem := x.Args[3]
 13585			if p != x.Args[0] {
 13586				break
 13587			}
 13588			if idx != x.Args[1] {
 13589				break
 13590			}
 13591			w0 := x.Args[2]
 13592			if w0.Op != OpS390XSRDconst {
 13593				break
 13594			}
 13595			if w0.AuxInt != j-8 {
 13596				break
 13597			}
 13598			if w != w0.Args[0] {
 13599				break
 13600			}
 13601			if !(x.Uses == 1 && clobber(x)) {
 13602				break
 13603			}
 13604			v.reset(OpS390XMOVHBRstoreidx)
 13605			v.AuxInt = i - 1
 13606			v.Aux = s
 13607			v.AddArg(p)
 13608			v.AddArg(idx)
 13609			v.AddArg(w0)
 13610			v.AddArg(mem)
 13611			return true
 13612		}
 13613		// match: (MOVBstoreidx [i] {s} p idx (SRDconst [j] w) x:(MOVBstoreidx [i-1] {s} idx p w0:(SRDconst [j-8] w) mem))
 13614		// cond: x.Uses == 1 && clobber(x)
 13615		// result: (MOVHBRstoreidx [i-1] {s} p idx w0 mem)
 13616		for {
 13617			i := v.AuxInt
 13618			s := v.Aux
 13619			_ = v.Args[3]
 13620			p := v.Args[0]
 13621			idx := v.Args[1]
 13622			v_2 := v.Args[2]
 13623			if v_2.Op != OpS390XSRDconst {
 13624				break
 13625			}
 13626			j := v_2.AuxInt
 13627			w := v_2.Args[0]
 13628			x := v.Args[3]
 13629			if x.Op != OpS390XMOVBstoreidx {
 13630				break
 13631			}
 13632			if x.AuxInt != i-1 {
 13633				break
 13634			}
 13635			if x.Aux != s {
 13636				break
 13637			}
 13638			mem := x.Args[3]
 13639			if idx != x.Args[0] {
 13640				break
 13641			}
 13642			if p != x.Args[1] {
 13643				break
 13644			}
 13645			w0 := x.Args[2]
 13646			if w0.Op != OpS390XSRDconst {
 13647				break
 13648			}
 13649			if w0.AuxInt != j-8 {
 13650				break
 13651			}
 13652			if w != w0.Args[0] {
 13653				break
 13654			}
 13655			if !(x.Uses == 1 && clobber(x)) {
 13656				break
 13657			}
 13658			v.reset(OpS390XMOVHBRstoreidx)
 13659			v.AuxInt = i - 1
 13660			v.Aux = s
 13661			v.AddArg(p)
 13662			v.AddArg(idx)
 13663			v.AddArg(w0)
 13664			v.AddArg(mem)
 13665			return true
 13666		}
 13667		// match: (MOVBstoreidx [i] {s} idx p (SRDconst [j] w) x:(MOVBstoreidx [i-1] {s} p idx w0:(SRDconst [j-8] w) mem))
 13668		// cond: x.Uses == 1 && clobber(x)
 13669		// result: (MOVHBRstoreidx [i-1] {s} p idx w0 mem)
 13670		for {
 13671			i := v.AuxInt
 13672			s := v.Aux
 13673			_ = v.Args[3]
 13674			idx := v.Args[0]
 13675			p := v.Args[1]
 13676			v_2 := v.Args[2]
 13677			if v_2.Op != OpS390XSRDconst {
 13678				break
 13679			}
 13680			j := v_2.AuxInt
 13681			w := v_2.Args[0]
 13682			x := v.Args[3]
 13683			if x.Op != OpS390XMOVBstoreidx {
 13684				break
 13685			}
 13686			if x.AuxInt != i-1 {
 13687				break
 13688			}
 13689			if x.Aux != s {
 13690				break
 13691			}
 13692			mem := x.Args[3]
 13693			if p != x.Args[0] {
 13694				break
 13695			}
 13696			if idx != x.Args[1] {
 13697				break
 13698			}
 13699			w0 := x.Args[2]
 13700			if w0.Op != OpS390XSRDconst {
 13701				break
 13702			}
 13703			if w0.AuxInt != j-8 {
 13704				break
 13705			}
 13706			if w != w0.Args[0] {
 13707				break
 13708			}
 13709			if !(x.Uses == 1 && clobber(x)) {
 13710				break
 13711			}
 13712			v.reset(OpS390XMOVHBRstoreidx)
 13713			v.AuxInt = i - 1
 13714			v.Aux = s
 13715			v.AddArg(p)
 13716			v.AddArg(idx)
 13717			v.AddArg(w0)
 13718			v.AddArg(mem)
 13719			return true
 13720		}
 13721		// match: (MOVBstoreidx [i] {s} idx p (SRDconst [j] w) x:(MOVBstoreidx [i-1] {s} idx p w0:(SRDconst [j-8] w) mem))
 13722		// cond: x.Uses == 1 && clobber(x)
 13723		// result: (MOVHBRstoreidx [i-1] {s} p idx w0 mem)
 13724		for {
 13725			i := v.AuxInt
 13726			s := v.Aux
 13727			_ = v.Args[3]
 13728			idx := v.Args[0]
 13729			p := v.Args[1]
 13730			v_2 := v.Args[2]
 13731			if v_2.Op != OpS390XSRDconst {
 13732				break
 13733			}
 13734			j := v_2.AuxInt
 13735			w := v_2.Args[0]
 13736			x := v.Args[3]
 13737			if x.Op != OpS390XMOVBstoreidx {
 13738				break
 13739			}
 13740			if x.AuxInt != i-1 {
 13741				break
 13742			}
 13743			if x.Aux != s {
 13744				break
 13745			}
 13746			mem := x.Args[3]
 13747			if idx != x.Args[0] {
 13748				break
 13749			}
 13750			if p != x.Args[1] {
 13751				break
 13752			}
 13753			w0 := x.Args[2]
 13754			if w0.Op != OpS390XSRDconst {
 13755				break
 13756			}
 13757			if w0.AuxInt != j-8 {
 13758				break
 13759			}
 13760			if w != w0.Args[0] {
 13761				break
 13762			}
 13763			if !(x.Uses == 1 && clobber(x)) {
 13764				break
 13765			}
 13766			v.reset(OpS390XMOVHBRstoreidx)
 13767			v.AuxInt = i - 1
 13768			v.Aux = s
 13769			v.AddArg(p)
 13770			v.AddArg(idx)
 13771			v.AddArg(w0)
 13772			v.AddArg(mem)
 13773			return true
 13774		}
 13775		// match: (MOVBstoreidx [i] {s} p idx (SRWconst [8] w) x:(MOVBstoreidx [i-1] {s} p idx w mem))
 13776		// cond: x.Uses == 1 && clobber(x)
 13777		// result: (MOVHBRstoreidx [i-1] {s} p idx w mem)
 13778		for {
 13779			i := v.AuxInt
 13780			s := v.Aux
 13781			_ = v.Args[3]
 13782			p := v.Args[0]
 13783			idx := v.Args[1]
 13784			v_2 := v.Args[2]
 13785			if v_2.Op != OpS390XSRWconst {
 13786				break
 13787			}
 13788			if v_2.AuxInt != 8 {
 13789				break
 13790			}
 13791			w := v_2.Args[0]
 13792			x := v.Args[3]
 13793			if x.Op != OpS390XMOVBstoreidx {
 13794				break
 13795			}
 13796			if x.AuxInt != i-1 {
 13797				break
 13798			}
 13799			if x.Aux != s {
 13800				break
 13801			}
 13802			mem := x.Args[3]
 13803			if p != x.Args[0] {
 13804				break
 13805			}
 13806			if idx != x.Args[1] {
 13807				break
 13808			}
 13809			if w != x.Args[2] {
 13810				break
 13811			}
 13812			if !(x.Uses == 1 && clobber(x)) {
 13813				break
 13814			}
 13815			v.reset(OpS390XMOVHBRstoreidx)
 13816			v.AuxInt = i - 1
 13817			v.Aux = s
 13818			v.AddArg(p)
 13819			v.AddArg(idx)
 13820			v.AddArg(w)
 13821			v.AddArg(mem)
 13822			return true
 13823		}
 13824		// match: (MOVBstoreidx [i] {s} p idx (SRWconst [8] w) x:(MOVBstoreidx [i-1] {s} idx p w mem))
 13825		// cond: x.Uses == 1 && clobber(x)
 13826		// result: (MOVHBRstoreidx [i-1] {s} p idx w mem)
 13827		for {
 13828			i := v.AuxInt
 13829			s := v.Aux
 13830			_ = v.Args[3]
 13831			p := v.Args[0]
 13832			idx := v.Args[1]
 13833			v_2 := v.Args[2]
 13834			if v_2.Op != OpS390XSRWconst {
 13835				break
 13836			}
 13837			if v_2.AuxInt != 8 {
 13838				break
 13839			}
 13840			w := v_2.Args[0]
 13841			x := v.Args[3]
 13842			if x.Op != OpS390XMOVBstoreidx {
 13843				break
 13844			}
 13845			if x.AuxInt != i-1 {
 13846				break
 13847			}
 13848			if x.Aux != s {
 13849				break
 13850			}
 13851			mem := x.Args[3]
 13852			if idx != x.Args[0] {
 13853				break
 13854			}
 13855			if p != x.Args[1] {
 13856				break
 13857			}
 13858			if w != x.Args[2] {
 13859				break
 13860			}
 13861			if !(x.Uses == 1 && clobber(x)) {
 13862				break
 13863			}
 13864			v.reset(OpS390XMOVHBRstoreidx)
 13865			v.AuxInt = i - 1
 13866			v.Aux = s
 13867			v.AddArg(p)
 13868			v.AddArg(idx)
 13869			v.AddArg(w)
 13870			v.AddArg(mem)
 13871			return true
 13872		}
 13873		return false
 13874	}
 13875	func rewriteValueS390X_OpS390XMOVBstoreidx_30(v *Value) bool {
 13876		// match: (MOVBstoreidx [i] {s} idx p (SRWconst [8] w) x:(MOVBstoreidx [i-1] {s} p idx w mem))
 13877		// cond: x.Uses == 1 && clobber(x)
 13878		// result: (MOVHBRstoreidx [i-1] {s} p idx w mem)
 13879		for {
 13880			i := v.AuxInt
 13881			s := v.Aux
 13882			_ = v.Args[3]
 13883			idx := v.Args[0]
 13884			p := v.Args[1]
 13885			v_2 := v.Args[2]
 13886			if v_2.Op != OpS390XSRWconst {
 13887				break
 13888			}
 13889			if v_2.AuxInt != 8 {
 13890				break
 13891			}
 13892			w := v_2.Args[0]
 13893			x := v.Args[3]
 13894			if x.Op != OpS390XMOVBstoreidx {
 13895				break
 13896			}
 13897			if x.AuxInt != i-1 {
 13898				break
 13899			}
 13900			if x.Aux != s {
 13901				break
 13902			}
 13903			mem := x.Args[3]
 13904			if p != x.Args[0] {
 13905				break
 13906			}
 13907			if idx != x.Args[1] {
 13908				break
 13909			}
 13910			if w != x.Args[2] {
 13911				break
 13912			}
 13913			if !(x.Uses == 1 && clobber(x)) {
 13914				break
 13915			}
 13916			v.reset(OpS390XMOVHBRstoreidx)
 13917			v.AuxInt = i - 1
 13918			v.Aux = s
 13919			v.AddArg(p)
 13920			v.AddArg(idx)
 13921			v.AddArg(w)
 13922			v.AddArg(mem)
 13923			return true
 13924		}
 13925		// match: (MOVBstoreidx [i] {s} idx p (SRWconst [8] w) x:(MOVBstoreidx [i-1] {s} idx p w mem))
 13926		// cond: x.Uses == 1 && clobber(x)
 13927		// result: (MOVHBRstoreidx [i-1] {s} p idx w mem)
 13928		for {
 13929			i := v.AuxInt
 13930			s := v.Aux
 13931			_ = v.Args[3]
 13932			idx := v.Args[0]
 13933			p := v.Args[1]
 13934			v_2 := v.Args[2]
 13935			if v_2.Op != OpS390XSRWconst {
 13936				break
 13937			}
 13938			if v_2.AuxInt != 8 {
 13939				break
 13940			}
 13941			w := v_2.Args[0]
 13942			x := v.Args[3]
 13943			if x.Op != OpS390XMOVBstoreidx {
 13944				break
 13945			}
 13946			if x.AuxInt != i-1 {
 13947				break
 13948			}
 13949			if x.Aux != s {
 13950				break
 13951			}
 13952			mem := x.Args[3]
 13953			if idx != x.Args[0] {
 13954				break
 13955			}
 13956			if p != x.Args[1] {
 13957				break
 13958			}
 13959			if w != x.Args[2] {
 13960				break
 13961			}
 13962			if !(x.Uses == 1 && clobber(x)) {
 13963				break
 13964			}
 13965			v.reset(OpS390XMOVHBRstoreidx)
 13966			v.AuxInt = i - 1
 13967			v.Aux = s
 13968			v.AddArg(p)
 13969			v.AddArg(idx)
 13970			v.AddArg(w)
 13971			v.AddArg(mem)
 13972			return true
 13973		}
 13974		// match: (MOVBstoreidx [i] {s} p idx (SRWconst [j] w) x:(MOVBstoreidx [i-1] {s} p idx w0:(SRWconst [j-8] w) mem))
 13975		// cond: x.Uses == 1 && clobber(x)
 13976		// result: (MOVHBRstoreidx [i-1] {s} p idx w0 mem)
 13977		for {
 13978			i := v.AuxInt
 13979			s := v.Aux
 13980			_ = v.Args[3]
 13981			p := v.Args[0]
 13982			idx := v.Args[1]
 13983			v_2 := v.Args[2]
 13984			if v_2.Op != OpS390XSRWconst {
 13985				break
 13986			}
 13987			j := v_2.AuxInt
 13988			w := v_2.Args[0]
 13989			x := v.Args[3]
 13990			if x.Op != OpS390XMOVBstoreidx {
 13991				break
 13992			}
 13993			if x.AuxInt != i-1 {
 13994				break
 13995			}
 13996			if x.Aux != s {
 13997				break
 13998			}
 13999			mem := x.Args[3]
 14000			if p != x.Args[0] {
 14001				break
 14002			}
 14003			if idx != x.Args[1] {
 14004				break
 14005			}
 14006			w0 := x.Args[2]
 14007			if w0.Op != OpS390XSRWconst {
 14008				break
 14009			}
 14010			if w0.AuxInt != j-8 {
 14011				break
 14012			}
 14013			if w != w0.Args[0] {
 14014				break
 14015			}
 14016			if !(x.Uses == 1 && clobber(x)) {
 14017				break
 14018			}
 14019			v.reset(OpS390XMOVHBRstoreidx)
 14020			v.AuxInt = i - 1
 14021			v.Aux = s
 14022			v.AddArg(p)
 14023			v.AddArg(idx)
 14024			v.AddArg(w0)
 14025			v.AddArg(mem)
 14026			return true
 14027		}
 14028		// match: (MOVBstoreidx [i] {s} p idx (SRWconst [j] w) x:(MOVBstoreidx [i-1] {s} idx p w0:(SRWconst [j-8] w) mem))
 14029		// cond: x.Uses == 1 && clobber(x)
 14030		// result: (MOVHBRstoreidx [i-1] {s} p idx w0 mem)
 14031		for {
 14032			i := v.AuxInt
 14033			s := v.Aux
 14034			_ = v.Args[3]
 14035			p := v.Args[0]
 14036			idx := v.Args[1]
 14037			v_2 := v.Args[2]
 14038			if v_2.Op != OpS390XSRWconst {
 14039				break
 14040			}
 14041			j := v_2.AuxInt
 14042			w := v_2.Args[0]
 14043			x := v.Args[3]
 14044			if x.Op != OpS390XMOVBstoreidx {
 14045				break
 14046			}
 14047			if x.AuxInt != i-1 {
 14048				break
 14049			}
 14050			if x.Aux != s {
 14051				break
 14052			}
 14053			mem := x.Args[3]
 14054			if idx != x.Args[0] {
 14055				break
 14056			}
 14057			if p != x.Args[1] {
 14058				break
 14059			}
 14060			w0 := x.Args[2]
 14061			if w0.Op != OpS390XSRWconst {
 14062				break
 14063			}
 14064			if w0.AuxInt != j-8 {
 14065				break
 14066			}
 14067			if w != w0.Args[0] {
 14068				break
 14069			}
 14070			if !(x.Uses == 1 && clobber(x)) {
 14071				break
 14072			}
 14073			v.reset(OpS390XMOVHBRstoreidx)
 14074			v.AuxInt = i - 1
 14075			v.Aux = s
 14076			v.AddArg(p)
 14077			v.AddArg(idx)
 14078			v.AddArg(w0)
 14079			v.AddArg(mem)
 14080			return true
 14081		}
 14082		// match: (MOVBstoreidx [i] {s} idx p (SRWconst [j] w) x:(MOVBstoreidx [i-1] {s} p idx w0:(SRWconst [j-8] w) mem))
 14083		// cond: x.Uses == 1 && clobber(x)
 14084		// result: (MOVHBRstoreidx [i-1] {s} p idx w0 mem)
 14085		for {
 14086			i := v.AuxInt
 14087			s := v.Aux
 14088			_ = v.Args[3]
 14089			idx := v.Args[0]
 14090			p := v.Args[1]
 14091			v_2 := v.Args[2]
 14092			if v_2.Op != OpS390XSRWconst {
 14093				break
 14094			}
 14095			j := v_2.AuxInt
 14096			w := v_2.Args[0]
 14097			x := v.Args[3]
 14098			if x.Op != OpS390XMOVBstoreidx {
 14099				break
 14100			}
 14101			if x.AuxInt != i-1 {
 14102				break
 14103			}
 14104			if x.Aux != s {
 14105				break
 14106			}
 14107			mem := x.Args[3]
 14108			if p != x.Args[0] {
 14109				break
 14110			}
 14111			if idx != x.Args[1] {
 14112				break
 14113			}
 14114			w0 := x.Args[2]
 14115			if w0.Op != OpS390XSRWconst {
 14116				break
 14117			}
 14118			if w0.AuxInt != j-8 {
 14119				break
 14120			}
 14121			if w != w0.Args[0] {
 14122				break
 14123			}
 14124			if !(x.Uses == 1 && clobber(x)) {
 14125				break
 14126			}
 14127			v.reset(OpS390XMOVHBRstoreidx)
 14128			v.AuxInt = i - 1
 14129			v.Aux = s
 14130			v.AddArg(p)
 14131			v.AddArg(idx)
 14132			v.AddArg(w0)
 14133			v.AddArg(mem)
 14134			return true
 14135		}
 14136		// match: (MOVBstoreidx [i] {s} idx p (SRWconst [j] w) x:(MOVBstoreidx [i-1] {s} idx p w0:(SRWconst [j-8] w) mem))
 14137		// cond: x.Uses == 1 && clobber(x)
 14138		// result: (MOVHBRstoreidx [i-1] {s} p idx w0 mem)
 14139		for {
 14140			i := v.AuxInt
 14141			s := v.Aux
 14142			_ = v.Args[3]
 14143			idx := v.Args[0]
 14144			p := v.Args[1]
 14145			v_2 := v.Args[2]
 14146			if v_2.Op != OpS390XSRWconst {
 14147				break
 14148			}
 14149			j := v_2.AuxInt
 14150			w := v_2.Args[0]
 14151			x := v.Args[3]
 14152			if x.Op != OpS390XMOVBstoreidx {
 14153				break
 14154			}
 14155			if x.AuxInt != i-1 {
 14156				break
 14157			}
 14158			if x.Aux != s {
 14159				break
 14160			}
 14161			mem := x.Args[3]
 14162			if idx != x.Args[0] {
 14163				break
 14164			}
 14165			if p != x.Args[1] {
 14166				break
 14167			}
 14168			w0 := x.Args[2]
 14169			if w0.Op != OpS390XSRWconst {
 14170				break
 14171			}
 14172			if w0.AuxInt != j-8 {
 14173				break
 14174			}
 14175			if w != w0.Args[0] {
 14176				break
 14177			}
 14178			if !(x.Uses == 1 && clobber(x)) {
 14179				break
 14180			}
 14181			v.reset(OpS390XMOVHBRstoreidx)
 14182			v.AuxInt = i - 1
 14183			v.Aux = s
 14184			v.AddArg(p)
 14185			v.AddArg(idx)
 14186			v.AddArg(w0)
 14187			v.AddArg(mem)
 14188			return true
 14189		}
 14190		return false
 14191	}
 14192	func rewriteValueS390X_OpS390XMOVDEQ_0(v *Value) bool {
 14193		// match: (MOVDEQ x y (InvertFlags cmp))
 14194		// cond:
 14195		// result: (MOVDEQ x y cmp)
 14196		for {
 14197			_ = v.Args[2]
 14198			x := v.Args[0]
 14199			y := v.Args[1]
 14200			v_2 := v.Args[2]
 14201			if v_2.Op != OpS390XInvertFlags {
 14202				break
 14203			}
 14204			cmp := v_2.Args[0]
 14205			v.reset(OpS390XMOVDEQ)
 14206			v.AddArg(x)
 14207			v.AddArg(y)
 14208			v.AddArg(cmp)
 14209			return true
 14210		}
 14211		// match: (MOVDEQ _ x (FlagEQ))
 14212		// cond:
 14213		// result: x
 14214		for {
 14215			_ = v.Args[2]
 14216			x := v.Args[1]
 14217			v_2 := v.Args[2]
 14218			if v_2.Op != OpS390XFlagEQ {
 14219				break
 14220			}
 14221			v.reset(OpCopy)
 14222			v.Type = x.Type
 14223			v.AddArg(x)
 14224			return true
 14225		}
 14226		// match: (MOVDEQ y _ (FlagLT))
 14227		// cond:
 14228		// result: y
 14229		for {
 14230			_ = v.Args[2]
 14231			y := v.Args[0]
 14232			v_2 := v.Args[2]
 14233			if v_2.Op != OpS390XFlagLT {
 14234				break
 14235			}
 14236			v.reset(OpCopy)
 14237			v.Type = y.Type
 14238			v.AddArg(y)
 14239			return true
 14240		}
 14241		// match: (MOVDEQ y _ (FlagGT))
 14242		// cond:
 14243		// result: y
 14244		for {
 14245			_ = v.Args[2]
 14246			y := v.Args[0]
 14247			v_2 := v.Args[2]
 14248			if v_2.Op != OpS390XFlagGT {
 14249				break
 14250			}
 14251			v.reset(OpCopy)
 14252			v.Type = y.Type
 14253			v.AddArg(y)
 14254			return true
 14255		}
 14256		return false
 14257	}
 14258	func rewriteValueS390X_OpS390XMOVDGE_0(v *Value) bool {
 14259		// match: (MOVDGE x y (InvertFlags cmp))
 14260		// cond:
 14261		// result: (MOVDLE x y cmp)
 14262		for {
 14263			_ = v.Args[2]
 14264			x := v.Args[0]
 14265			y := v.Args[1]
 14266			v_2 := v.Args[2]
 14267			if v_2.Op != OpS390XInvertFlags {
 14268				break
 14269			}
 14270			cmp := v_2.Args[0]
 14271			v.reset(OpS390XMOVDLE)
 14272			v.AddArg(x)
 14273			v.AddArg(y)
 14274			v.AddArg(cmp)
 14275			return true
 14276		}
 14277		// match: (MOVDGE _ x (FlagEQ))
 14278		// cond:
 14279		// result: x
 14280		for {
 14281			_ = v.Args[2]
 14282			x := v.Args[1]
 14283			v_2 := v.Args[2]
 14284			if v_2.Op != OpS390XFlagEQ {
 14285				break
 14286			}
 14287			v.reset(OpCopy)
 14288			v.Type = x.Type
 14289			v.AddArg(x)
 14290			return true
 14291		}
 14292		// match: (MOVDGE y _ (FlagLT))
 14293		// cond:
 14294		// result: y
 14295		for {
 14296			_ = v.Args[2]
 14297			y := v.Args[0]
 14298			v_2 := v.Args[2]
 14299			if v_2.Op != OpS390XFlagLT {
 14300				break
 14301			}
 14302			v.reset(OpCopy)
 14303			v.Type = y.Type
 14304			v.AddArg(y)
 14305			return true
 14306		}
 14307		// match: (MOVDGE _ x (FlagGT))
 14308		// cond:
 14309		// result: x
 14310		for {
 14311			_ = v.Args[2]
 14312			x := v.Args[1]
 14313			v_2 := v.Args[2]
 14314			if v_2.Op != OpS390XFlagGT {
 14315				break
 14316			}
 14317			v.reset(OpCopy)
 14318			v.Type = x.Type
 14319			v.AddArg(x)
 14320			return true
 14321		}
 14322		return false
 14323	}
 14324	func rewriteValueS390X_OpS390XMOVDGT_0(v *Value) bool {
 14325		// match: (MOVDGT x y (InvertFlags cmp))
 14326		// cond:
 14327		// result: (MOVDLT x y cmp)
 14328		for {
 14329			_ = v.Args[2]
 14330			x := v.Args[0]
 14331			y := v.Args[1]
 14332			v_2 := v.Args[2]
 14333			if v_2.Op != OpS390XInvertFlags {
 14334				break
 14335			}
 14336			cmp := v_2.Args[0]
 14337			v.reset(OpS390XMOVDLT)
 14338			v.AddArg(x)
 14339			v.AddArg(y)
 14340			v.AddArg(cmp)
 14341			return true
 14342		}
 14343		// match: (MOVDGT y _ (FlagEQ))
 14344		// cond:
 14345		// result: y
 14346		for {
 14347			_ = v.Args[2]
 14348			y := v.Args[0]
 14349			v_2 := v.Args[2]
 14350			if v_2.Op != OpS390XFlagEQ {
 14351				break
 14352			}
 14353			v.reset(OpCopy)
 14354			v.Type = y.Type
 14355			v.AddArg(y)
 14356			return true
 14357		}
 14358		// match: (MOVDGT y _ (FlagLT))
 14359		// cond:
 14360		// result: y
 14361		for {
 14362			_ = v.Args[2]
 14363			y := v.Args[0]
 14364			v_2 := v.Args[2]
 14365			if v_2.Op != OpS390XFlagLT {
 14366				break
 14367			}
 14368			v.reset(OpCopy)
 14369			v.Type = y.Type
 14370			v.AddArg(y)
 14371			return true
 14372		}
 14373		// match: (MOVDGT _ x (FlagGT))
 14374		// cond:
 14375		// result: x
 14376		for {
 14377			_ = v.Args[2]
 14378			x := v.Args[1]
 14379			v_2 := v.Args[2]
 14380			if v_2.Op != OpS390XFlagGT {
 14381				break
 14382			}
 14383			v.reset(OpCopy)
 14384			v.Type = x.Type
 14385			v.AddArg(x)
 14386			return true
 14387		}
 14388		return false
 14389	}
 14390	func rewriteValueS390X_OpS390XMOVDLE_0(v *Value) bool {
 14391		// match: (MOVDLE x y (InvertFlags cmp))
 14392		// cond:
 14393		// result: (MOVDGE x y cmp)
 14394		for {
 14395			_ = v.Args[2]
 14396			x := v.Args[0]
 14397			y := v.Args[1]
 14398			v_2 := v.Args[2]
 14399			if v_2.Op != OpS390XInvertFlags {
 14400				break
 14401			}
 14402			cmp := v_2.Args[0]
 14403			v.reset(OpS390XMOVDGE)
 14404			v.AddArg(x)
 14405			v.AddArg(y)
 14406			v.AddArg(cmp)
 14407			return true
 14408		}
 14409		// match: (MOVDLE _ x (FlagEQ))
 14410		// cond:
 14411		// result: x
 14412		for {
 14413			_ = v.Args[2]
 14414			x := v.Args[1]
 14415			v_2 := v.Args[2]
 14416			if v_2.Op != OpS390XFlagEQ {
 14417				break
 14418			}
 14419			v.reset(OpCopy)
 14420			v.Type = x.Type
 14421			v.AddArg(x)
 14422			return true
 14423		}
 14424		// match: (MOVDLE _ x (FlagLT))
 14425		// cond:
 14426		// result: x
 14427		for {
 14428			_ = v.Args[2]
 14429			x := v.Args[1]
 14430			v_2 := v.Args[2]
 14431			if v_2.Op != OpS390XFlagLT {
 14432				break
 14433			}
 14434			v.reset(OpCopy)
 14435			v.Type = x.Type
 14436			v.AddArg(x)
 14437			return true
 14438		}
 14439		// match: (MOVDLE y _ (FlagGT))
 14440		// cond:
 14441		// result: y
 14442		for {
 14443			_ = v.Args[2]
 14444			y := v.Args[0]
 14445			v_2 := v.Args[2]
 14446			if v_2.Op != OpS390XFlagGT {
 14447				break
 14448			}
 14449			v.reset(OpCopy)
 14450			v.Type = y.Type
 14451			v.AddArg(y)
 14452			return true
 14453		}
 14454		return false
 14455	}
 14456	func rewriteValueS390X_OpS390XMOVDLT_0(v *Value) bool {
 14457		// match: (MOVDLT x y (InvertFlags cmp))
 14458		// cond:
 14459		// result: (MOVDGT x y cmp)
 14460		for {
 14461			_ = v.Args[2]
 14462			x := v.Args[0]
 14463			y := v.Args[1]
 14464			v_2 := v.Args[2]
 14465			if v_2.Op != OpS390XInvertFlags {
 14466				break
 14467			}
 14468			cmp := v_2.Args[0]
 14469			v.reset(OpS390XMOVDGT)
 14470			v.AddArg(x)
 14471			v.AddArg(y)
 14472			v.AddArg(cmp)
 14473			return true
 14474		}
 14475		// match: (MOVDLT y _ (FlagEQ))
 14476		// cond:
 14477		// result: y
 14478		for {
 14479			_ = v.Args[2]
 14480			y := v.Args[0]
 14481			v_2 := v.Args[2]
 14482			if v_2.Op != OpS390XFlagEQ {
 14483				break
 14484			}
 14485			v.reset(OpCopy)
 14486			v.Type = y.Type
 14487			v.AddArg(y)
 14488			return true
 14489		}
 14490		// match: (MOVDLT _ x (FlagLT))
 14491		// cond:
 14492		// result: x
 14493		for {
 14494			_ = v.Args[2]
 14495			x := v.Args[1]
 14496			v_2 := v.Args[2]
 14497			if v_2.Op != OpS390XFlagLT {
 14498				break
 14499			}
 14500			v.reset(OpCopy)
 14501			v.Type = x.Type
 14502			v.AddArg(x)
 14503			return true
 14504		}
 14505		// match: (MOVDLT y _ (FlagGT))
 14506		// cond:
 14507		// result: y
 14508		for {
 14509			_ = v.Args[2]
 14510			y := v.Args[0]
 14511			v_2 := v.Args[2]
 14512			if v_2.Op != OpS390XFlagGT {
 14513				break
 14514			}
 14515			v.reset(OpCopy)
 14516			v.Type = y.Type
 14517			v.AddArg(y)
 14518			return true
 14519		}
 14520		return false
 14521	}
 14522	func rewriteValueS390X_OpS390XMOVDNE_0(v *Value) bool {
 14523		// match: (MOVDNE x y (InvertFlags cmp))
 14524		// cond:
 14525		// result: (MOVDNE x y cmp)
 14526		for {
 14527			_ = v.Args[2]
 14528			x := v.Args[0]
 14529			y := v.Args[1]
 14530			v_2 := v.Args[2]
 14531			if v_2.Op != OpS390XInvertFlags {
 14532				break
 14533			}
 14534			cmp := v_2.Args[0]
 14535			v.reset(OpS390XMOVDNE)
 14536			v.AddArg(x)
 14537			v.AddArg(y)
 14538			v.AddArg(cmp)
 14539			return true
 14540		}
 14541		// match: (MOVDNE y _ (FlagEQ))
 14542		// cond:
 14543		// result: y
 14544		for {
 14545			_ = v.Args[2]
 14546			y := v.Args[0]
 14547			v_2 := v.Args[2]
 14548			if v_2.Op != OpS390XFlagEQ {
 14549				break
 14550			}
 14551			v.reset(OpCopy)
 14552			v.Type = y.Type
 14553			v.AddArg(y)
 14554			return true
 14555		}
 14556		// match: (MOVDNE _ x (FlagLT))
 14557		// cond:
 14558		// result: x
 14559		for {
 14560			_ = v.Args[2]
 14561			x := v.Args[1]
 14562			v_2 := v.Args[2]
 14563			if v_2.Op != OpS390XFlagLT {
 14564				break
 14565			}
 14566			v.reset(OpCopy)
 14567			v.Type = x.Type
 14568			v.AddArg(x)
 14569			return true
 14570		}
 14571		// match: (MOVDNE _ x (FlagGT))
 14572		// cond:
 14573		// result: x
 14574		for {
 14575			_ = v.Args[2]
 14576			x := v.Args[1]
 14577			v_2 := v.Args[2]
 14578			if v_2.Op != OpS390XFlagGT {
 14579				break
 14580			}
 14581			v.reset(OpCopy)
 14582			v.Type = x.Type
 14583			v.AddArg(x)
 14584			return true
 14585		}
 14586		return false
 14587	}
 14588	func rewriteValueS390X_OpS390XMOVDaddridx_0(v *Value) bool {
 14589		// match: (MOVDaddridx [c] {s} (ADDconst [d] x) y)
 14590		// cond: is20Bit(c+d) && x.Op != OpSB
 14591		// result: (MOVDaddridx [c+d] {s} x y)
 14592		for {
 14593			c := v.AuxInt
 14594			s := v.Aux
 14595			y := v.Args[1]
 14596			v_0 := v.Args[0]
 14597			if v_0.Op != OpS390XADDconst {
 14598				break
 14599			}
 14600			d := v_0.AuxInt
 14601			x := v_0.Args[0]
 14602			if !(is20Bit(c+d) && x.Op != OpSB) {
 14603				break
 14604			}
 14605			v.reset(OpS390XMOVDaddridx)
 14606			v.AuxInt = c + d
 14607			v.Aux = s
 14608			v.AddArg(x)
 14609			v.AddArg(y)
 14610			return true
 14611		}
 14612		// match: (MOVDaddridx [c] {s} x (ADDconst [d] y))
 14613		// cond: is20Bit(c+d) && y.Op != OpSB
 14614		// result: (MOVDaddridx [c+d] {s} x y)
 14615		for {
 14616			c := v.AuxInt
 14617			s := v.Aux
 14618			_ = v.Args[1]
 14619			x := v.Args[0]
 14620			v_1 := v.Args[1]
 14621			if v_1.Op != OpS390XADDconst {
 14622				break
 14623			}
 14624			d := v_1.AuxInt
 14625			y := v_1.Args[0]
 14626			if !(is20Bit(c+d) && y.Op != OpSB) {
 14627				break
 14628			}
 14629			v.reset(OpS390XMOVDaddridx)
 14630			v.AuxInt = c + d
 14631			v.Aux = s
 14632			v.AddArg(x)
 14633			v.AddArg(y)
 14634			return true
 14635		}
 14636		// match: (MOVDaddridx [off1] {sym1} (MOVDaddr [off2] {sym2} x) y)
 14637		// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && x.Op != OpSB
 14638		// result: (MOVDaddridx [off1+off2] {mergeSym(sym1,sym2)} x y)
 14639		for {
 14640			off1 := v.AuxInt
 14641			sym1 := v.Aux
 14642			y := v.Args[1]
 14643			v_0 := v.Args[0]
 14644			if v_0.Op != OpS390XMOVDaddr {
 14645				break
 14646			}
 14647			off2 := v_0.AuxInt
 14648			sym2 := v_0.Aux
 14649			x := v_0.Args[0]
 14650			if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && x.Op != OpSB) {
 14651				break
 14652			}
 14653			v.reset(OpS390XMOVDaddridx)
 14654			v.AuxInt = off1 + off2
 14655			v.Aux = mergeSym(sym1, sym2)
 14656			v.AddArg(x)
 14657			v.AddArg(y)
 14658			return true
 14659		}
 14660		// match: (MOVDaddridx [off1] {sym1} x (MOVDaddr [off2] {sym2} y))
 14661		// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && y.Op != OpSB
 14662		// result: (MOVDaddridx [off1+off2] {mergeSym(sym1,sym2)} x y)
 14663		for {
 14664			off1 := v.AuxInt
 14665			sym1 := v.Aux
 14666			_ = v.Args[1]
 14667			x := v.Args[0]
 14668			v_1 := v.Args[1]
 14669			if v_1.Op != OpS390XMOVDaddr {
 14670				break
 14671			}
 14672			off2 := v_1.AuxInt
 14673			sym2 := v_1.Aux
 14674			y := v_1.Args[0]
 14675			if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && y.Op != OpSB) {
 14676				break
 14677			}
 14678			v.reset(OpS390XMOVDaddridx)
 14679			v.AuxInt = off1 + off2
 14680			v.Aux = mergeSym(sym1, sym2)
 14681			v.AddArg(x)
 14682			v.AddArg(y)
 14683			return true
 14684		}
 14685		return false
 14686	}
 14687	func rewriteValueS390X_OpS390XMOVDload_0(v *Value) bool {
 14688		// match: (MOVDload [off] {sym} ptr1 (MOVDstore [off] {sym} ptr2 x _))
 14689		// cond: isSamePtr(ptr1, ptr2)
 14690		// result: (MOVDreg x)
 14691		for {
 14692			off := v.AuxInt
 14693			sym := v.Aux
 14694			_ = v.Args[1]
 14695			ptr1 := v.Args[0]
 14696			v_1 := v.Args[1]
 14697			if v_1.Op != OpS390XMOVDstore {
 14698				break
 14699			}
 14700			if v_1.AuxInt != off {
 14701				break
 14702			}
 14703			if v_1.Aux != sym {
 14704				break
 14705			}
 14706			_ = v_1.Args[2]
 14707			ptr2 := v_1.Args[0]
 14708			x := v_1.Args[1]
 14709			if !(isSamePtr(ptr1, ptr2)) {
 14710				break
 14711			}
 14712			v.reset(OpS390XMOVDreg)
 14713			v.AddArg(x)
 14714			return true
 14715		}
 14716		// match: (MOVDload [off] {sym} ptr1 (FMOVDstore [off] {sym} ptr2 x _))
 14717		// cond: isSamePtr(ptr1, ptr2)
 14718		// result: (LGDR x)
 14719		for {
 14720			off := v.AuxInt
 14721			sym := v.Aux
 14722			_ = v.Args[1]
 14723			ptr1 := v.Args[0]
 14724			v_1 := v.Args[1]
 14725			if v_1.Op != OpS390XFMOVDstore {
 14726				break
 14727			}
 14728			if v_1.AuxInt != off {
 14729				break
 14730			}
 14731			if v_1.Aux != sym {
 14732				break
 14733			}
 14734			_ = v_1.Args[2]
 14735			ptr2 := v_1.Args[0]
 14736			x := v_1.Args[1]
 14737			if !(isSamePtr(ptr1, ptr2)) {
 14738				break
 14739			}
 14740			v.reset(OpS390XLGDR)
 14741			v.AddArg(x)
 14742			return true
 14743		}
 14744		// match: (MOVDload [off1] {sym} (ADDconst [off2] ptr) mem)
 14745		// cond: is20Bit(off1+off2)
 14746		// result: (MOVDload [off1+off2] {sym} ptr mem)
 14747		for {
 14748			off1 := v.AuxInt
 14749			sym := v.Aux
 14750			mem := v.Args[1]
 14751			v_0 := v.Args[0]
 14752			if v_0.Op != OpS390XADDconst {
 14753				break
 14754			}
 14755			off2 := v_0.AuxInt
 14756			ptr := v_0.Args[0]
 14757			if !(is20Bit(off1 + off2)) {
 14758				break
 14759			}
 14760			v.reset(OpS390XMOVDload)
 14761			v.AuxInt = off1 + off2
 14762			v.Aux = sym
 14763			v.AddArg(ptr)
 14764			v.AddArg(mem)
 14765			return true
 14766		}
 14767		// match: (MOVDload [off1] {sym1} (MOVDaddr <t> [off2] {sym2} base) mem)
 14768		// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || (t.IsPtr() && t.Elem().Alignment()%8 == 0 && (off1+off2)%8 == 0))
 14769		// result: (MOVDload [off1+off2] {mergeSym(sym1,sym2)} base mem)
 14770		for {
 14771			off1 := v.AuxInt
 14772			sym1 := v.Aux
 14773			mem := v.Args[1]
 14774			v_0 := v.Args[0]
 14775			if v_0.Op != OpS390XMOVDaddr {
 14776				break
 14777			}
 14778			t := v_0.Type
 14779			off2 := v_0.AuxInt
 14780			sym2 := v_0.Aux
 14781			base := v_0.Args[0]
 14782			if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || (t.IsPtr() && t.Elem().Alignment()%8 == 0 && (off1+off2)%8 == 0))) {
 14783				break
 14784			}
 14785			v.reset(OpS390XMOVDload)
 14786			v.AuxInt = off1 + off2
 14787			v.Aux = mergeSym(sym1, sym2)
 14788			v.AddArg(base)
 14789			v.AddArg(mem)
 14790			return true
 14791		}
 14792		// match: (MOVDload [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) mem)
 14793		// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
 14794		// result: (MOVDloadidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem)
 14795		for {
 14796			off1 := v.AuxInt
 14797			sym1 := v.Aux
 14798			mem := v.Args[1]
 14799			v_0 := v.Args[0]
 14800			if v_0.Op != OpS390XMOVDaddridx {
 14801				break
 14802			}
 14803			off2 := v_0.AuxInt
 14804			sym2 := v_0.Aux
 14805			idx := v_0.Args[1]
 14806			ptr := v_0.Args[0]
 14807			if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
 14808				break
 14809			}
 14810			v.reset(OpS390XMOVDloadidx)
 14811			v.AuxInt = off1 + off2
 14812			v.Aux = mergeSym(sym1, sym2)
 14813			v.AddArg(ptr)
 14814			v.AddArg(idx)
 14815			v.AddArg(mem)
 14816			return true
 14817		}
 14818		// match: (MOVDload [off] {sym} (ADD ptr idx) mem)
 14819		// cond: ptr.Op != OpSB
 14820		// result: (MOVDloadidx [off] {sym} ptr idx mem)
 14821		for {
 14822			off := v.AuxInt
 14823			sym := v.Aux
 14824			mem := v.Args[1]
 14825			v_0 := v.Args[0]
 14826			if v_0.Op != OpS390XADD {
 14827				break
 14828			}
 14829			idx := v_0.Args[1]
 14830			ptr := v_0.Args[0]
 14831			if !(ptr.Op != OpSB) {
 14832				break
 14833			}
 14834			v.reset(OpS390XMOVDloadidx)
 14835			v.AuxInt = off
 14836			v.Aux = sym
 14837			v.AddArg(ptr)
 14838			v.AddArg(idx)
 14839			v.AddArg(mem)
 14840			return true
 14841		}
 14842		return false
 14843	}
 14844	func rewriteValueS390X_OpS390XMOVDloadidx_0(v *Value) bool {
 14845		// match: (MOVDloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
 14846		// cond: is20Bit(c+d)
 14847		// result: (MOVDloadidx [c+d] {sym} ptr idx mem)
 14848		for {
 14849			c := v.AuxInt
 14850			sym := v.Aux
 14851			mem := v.Args[2]
 14852			v_0 := v.Args[0]
 14853			if v_0.Op != OpS390XADDconst {
 14854				break
 14855			}
 14856			d := v_0.AuxInt
 14857			ptr := v_0.Args[0]
 14858			idx := v.Args[1]
 14859			if !(is20Bit(c + d)) {
 14860				break
 14861			}
 14862			v.reset(OpS390XMOVDloadidx)
 14863			v.AuxInt = c + d
 14864			v.Aux = sym
 14865			v.AddArg(ptr)
 14866			v.AddArg(idx)
 14867			v.AddArg(mem)
 14868			return true
 14869		}
 14870		// match: (MOVDloadidx [c] {sym} idx (ADDconst [d] ptr) mem)
 14871		// cond: is20Bit(c+d)
 14872		// result: (MOVDloadidx [c+d] {sym} ptr idx mem)
 14873		for {
 14874			c := v.AuxInt
 14875			sym := v.Aux
 14876			mem := v.Args[2]
 14877			idx := v.Args[0]
 14878			v_1 := v.Args[1]
 14879			if v_1.Op != OpS390XADDconst {
 14880				break
 14881			}
 14882			d := v_1.AuxInt
 14883			ptr := v_1.Args[0]
 14884			if !(is20Bit(c + d)) {
 14885				break
 14886			}
 14887			v.reset(OpS390XMOVDloadidx)
 14888			v.AuxInt = c + d
 14889			v.Aux = sym
 14890			v.AddArg(ptr)
 14891			v.AddArg(idx)
 14892			v.AddArg(mem)
 14893			return true
 14894		}
 14895		// match: (MOVDloadidx [c] {sym} ptr (ADDconst [d] idx) mem)
 14896		// cond: is20Bit(c+d)
 14897		// result: (MOVDloadidx [c+d] {sym} ptr idx mem)
 14898		for {
 14899			c := v.AuxInt
 14900			sym := v.Aux
 14901			mem := v.Args[2]
 14902			ptr := v.Args[0]
 14903			v_1 := v.Args[1]
 14904			if v_1.Op != OpS390XADDconst {
 14905				break
 14906			}
 14907			d := v_1.AuxInt
 14908			idx := v_1.Args[0]
 14909			if !(is20Bit(c + d)) {
 14910				break
 14911			}
 14912			v.reset(OpS390XMOVDloadidx)
 14913			v.AuxInt = c + d
 14914			v.Aux = sym
 14915			v.AddArg(ptr)
 14916			v.AddArg(idx)
 14917			v.AddArg(mem)
 14918			return true
 14919		}
 14920		// match: (MOVDloadidx [c] {sym} (ADDconst [d] idx) ptr mem)
 14921		// cond: is20Bit(c+d)
 14922		// result: (MOVDloadidx [c+d] {sym} ptr idx mem)
 14923		for {
 14924			c := v.AuxInt
 14925			sym := v.Aux
 14926			mem := v.Args[2]
 14927			v_0 := v.Args[0]
 14928			if v_0.Op != OpS390XADDconst {
 14929				break
 14930			}
 14931			d := v_0.AuxInt
 14932			idx := v_0.Args[0]
 14933			ptr := v.Args[1]
 14934			if !(is20Bit(c + d)) {
 14935				break
 14936			}
 14937			v.reset(OpS390XMOVDloadidx)
 14938			v.AuxInt = c + d
 14939			v.Aux = sym
 14940			v.AddArg(ptr)
 14941			v.AddArg(idx)
 14942			v.AddArg(mem)
 14943			return true
 14944		}
 14945		return false
 14946	}
 14947	func rewriteValueS390X_OpS390XMOVDnop_0(v *Value) bool {
 14948		b := v.Block
 14949		// match: (MOVDnop <t> x)
 14950		// cond: t.Compare(x.Type) == types.CMPeq
 14951		// result: x
 14952		for {
 14953			t := v.Type
 14954			x := v.Args[0]
 14955			if !(t.Compare(x.Type) == types.CMPeq) {
 14956				break
 14957			}
 14958			v.reset(OpCopy)
 14959			v.Type = x.Type
 14960			v.AddArg(x)
 14961			return true
 14962		}
 14963		// match: (MOVDnop (MOVDconst [c]))
 14964		// cond:
 14965		// result: (MOVDconst [c])
 14966		for {
 14967			v_0 := v.Args[0]
 14968			if v_0.Op != OpS390XMOVDconst {
 14969				break
 14970			}
 14971			c := v_0.AuxInt
 14972			v.reset(OpS390XMOVDconst)
 14973			v.AuxInt = c
 14974			return true
 14975		}
 14976		// match: (MOVDnop <t> x:(MOVBZload [off] {sym} ptr mem))
 14977		// cond: x.Uses == 1 && clobber(x)
 14978		// result: @x.Block (MOVBZload <t> [off] {sym} ptr mem)
 14979		for {
 14980			t := v.Type
 14981			x := v.Args[0]
 14982			if x.Op != OpS390XMOVBZload {
 14983				break
 14984			}
 14985			off := x.AuxInt
 14986			sym := x.Aux
 14987			mem := x.Args[1]
 14988			ptr := x.Args[0]
 14989			if !(x.Uses == 1 && clobber(x)) {
 14990				break
 14991			}
 14992			b = x.Block
 14993			v0 := b.NewValue0(x.Pos, OpS390XMOVBZload, t)
 14994			v.reset(OpCopy)
 14995			v.AddArg(v0)
 14996			v0.AuxInt = off
 14997			v0.Aux = sym
 14998			v0.AddArg(ptr)
 14999			v0.AddArg(mem)
 15000			return true
 15001		}
 15002		// match: (MOVDnop <t> x:(MOVBload [off] {sym} ptr mem))
 15003		// cond: x.Uses == 1 && clobber(x)
 15004		// result: @x.Block (MOVBload <t> [off] {sym} ptr mem)
 15005		for {
 15006			t := v.Type
 15007			x := v.Args[0]
 15008			if x.Op != OpS390XMOVBload {
 15009				break
 15010			}
 15011			off := x.AuxInt
 15012			sym := x.Aux
 15013			mem := x.Args[1]
 15014			ptr := x.Args[0]
 15015			if !(x.Uses == 1 && clobber(x)) {
 15016				break
 15017			}
 15018			b = x.Block
 15019			v0 := b.NewValue0(x.Pos, OpS390XMOVBload, t)
 15020			v.reset(OpCopy)
 15021			v.AddArg(v0)
 15022			v0.AuxInt = off
 15023			v0.Aux = sym
 15024			v0.AddArg(ptr)
 15025			v0.AddArg(mem)
 15026			return true
 15027		}
 15028		// match: (MOVDnop <t> x:(MOVHZload [off] {sym} ptr mem))
 15029		// cond: x.Uses == 1 && clobber(x)
 15030		// result: @x.Block (MOVHZload <t> [off] {sym} ptr mem)
 15031		for {
 15032			t := v.Type
 15033			x := v.Args[0]
 15034			if x.Op != OpS390XMOVHZload {
 15035				break
 15036			}
 15037			off := x.AuxInt
 15038			sym := x.Aux
 15039			mem := x.Args[1]
 15040			ptr := x.Args[0]
 15041			if !(x.Uses == 1 && clobber(x)) {
 15042				break
 15043			}
 15044			b = x.Block
 15045			v0 := b.NewValue0(x.Pos, OpS390XMOVHZload, t)
 15046			v.reset(OpCopy)
 15047			v.AddArg(v0)
 15048			v0.AuxInt = off
 15049			v0.Aux = sym
 15050			v0.AddArg(ptr)
 15051			v0.AddArg(mem)
 15052			return true
 15053		}
 15054		// match: (MOVDnop <t> x:(MOVHload [off] {sym} ptr mem))
 15055		// cond: x.Uses == 1 && clobber(x)
 15056		// result: @x.Block (MOVHload <t> [off] {sym} ptr mem)
 15057		for {
 15058			t := v.Type
 15059			x := v.Args[0]
 15060			if x.Op != OpS390XMOVHload {
 15061				break
 15062			}
 15063			off := x.AuxInt
 15064			sym := x.Aux
 15065			mem := x.Args[1]
 15066			ptr := x.Args[0]
 15067			if !(x.Uses == 1 && clobber(x)) {
 15068				break
 15069			}
 15070			b = x.Block
 15071			v0 := b.NewValue0(x.Pos, OpS390XMOVHload, t)
 15072			v.reset(OpCopy)
 15073			v.AddArg(v0)
 15074			v0.AuxInt = off
 15075			v0.Aux = sym
 15076			v0.AddArg(ptr)
 15077			v0.AddArg(mem)
 15078			return true
 15079		}
 15080		// match: (MOVDnop <t> x:(MOVWZload [off] {sym} ptr mem))
 15081		// cond: x.Uses == 1 && clobber(x)
 15082		// result: @x.Block (MOVWZload <t> [off] {sym} ptr mem)
 15083		for {
 15084			t := v.Type
 15085			x := v.Args[0]
 15086			if x.Op != OpS390XMOVWZload {
 15087				break
 15088			}
 15089			off := x.AuxInt
 15090			sym := x.Aux
 15091			mem := x.Args[1]
 15092			ptr := x.Args[0]
 15093			if !(x.Uses == 1 && clobber(x)) {
 15094				break
 15095			}
 15096			b = x.Block
 15097			v0 := b.NewValue0(x.Pos, OpS390XMOVWZload, t)
 15098			v.reset(OpCopy)
 15099			v.AddArg(v0)
 15100			v0.AuxInt = off
 15101			v0.Aux = sym
 15102			v0.AddArg(ptr)
 15103			v0.AddArg(mem)
 15104			return true
 15105		}
 15106		// match: (MOVDnop <t> x:(MOVWload [off] {sym} ptr mem))
 15107		// cond: x.Uses == 1 && clobber(x)
 15108		// result: @x.Block (MOVWload <t> [off] {sym} ptr mem)
 15109		for {
 15110			t := v.Type
 15111			x := v.Args[0]
 15112			if x.Op != OpS390XMOVWload {
 15113				break
 15114			}
 15115			off := x.AuxInt
 15116			sym := x.Aux
 15117			mem := x.Args[1]
 15118			ptr := x.Args[0]
 15119			if !(x.Uses == 1 && clobber(x)) {
 15120				break
 15121			}
 15122			b = x.Block
 15123			v0 := b.NewValue0(x.Pos, OpS390XMOVWload, t)
 15124			v.reset(OpCopy)
 15125			v.AddArg(v0)
 15126			v0.AuxInt = off
 15127			v0.Aux = sym
 15128			v0.AddArg(ptr)
 15129			v0.AddArg(mem)
 15130			return true
 15131		}
 15132		// match: (MOVDnop <t> x:(MOVDload [off] {sym} ptr mem))
 15133		// cond: x.Uses == 1 && clobber(x)
 15134		// result: @x.Block (MOVDload <t> [off] {sym} ptr mem)
 15135		for {
 15136			t := v.Type
 15137			x := v.Args[0]
 15138			if x.Op != OpS390XMOVDload {
 15139				break
 15140			}
 15141			off := x.AuxInt
 15142			sym := x.Aux
 15143			mem := x.Args[1]
 15144			ptr := x.Args[0]
 15145			if !(x.Uses == 1 && clobber(x)) {
 15146				break
 15147			}
 15148			b = x.Block
 15149			v0 := b.NewValue0(x.Pos, OpS390XMOVDload, t)
 15150			v.reset(OpCopy)
 15151			v.AddArg(v0)
 15152			v0.AuxInt = off
 15153			v0.Aux = sym
 15154			v0.AddArg(ptr)
 15155			v0.AddArg(mem)
 15156			return true
 15157		}
 15158		// match: (MOVDnop <t> x:(MOVBZloadidx [off] {sym} ptr idx mem))
 15159		// cond: x.Uses == 1 && clobber(x)
 15160		// result: @x.Block (MOVBZloadidx <t> [off] {sym} ptr idx mem)
 15161		for {
 15162			t := v.Type
 15163			x := v.Args[0]
 15164			if x.Op != OpS390XMOVBZloadidx {
 15165				break
 15166			}
 15167			off := x.AuxInt
 15168			sym := x.Aux
 15169			mem := x.Args[2]
 15170			ptr := x.Args[0]
 15171			idx := x.Args[1]
 15172			if !(x.Uses == 1 && clobber(x)) {
 15173				break
 15174			}
 15175			b = x.Block
 15176			v0 := b.NewValue0(v.Pos, OpS390XMOVBZloadidx, t)
 15177			v.reset(OpCopy)
 15178			v.AddArg(v0)
 15179			v0.AuxInt = off
 15180			v0.Aux = sym
 15181			v0.AddArg(ptr)
 15182			v0.AddArg(idx)
 15183			v0.AddArg(mem)
 15184			return true
 15185		}
 15186		return false
 15187	}
 15188	func rewriteValueS390X_OpS390XMOVDnop_10(v *Value) bool {
 15189		b := v.Block
 15190		// match: (MOVDnop <t> x:(MOVBloadidx [off] {sym} ptr idx mem))
 15191		// cond: x.Uses == 1 && clobber(x)
 15192		// result: @x.Block (MOVBloadidx <t> [off] {sym} ptr idx mem)
 15193		for {
 15194			t := v.Type
 15195			x := v.Args[0]
 15196			if x.Op != OpS390XMOVBloadidx {
 15197				break
 15198			}
 15199			off := x.AuxInt
 15200			sym := x.Aux
 15201			mem := x.Args[2]
 15202			ptr := x.Args[0]
 15203			idx := x.Args[1]
 15204			if !(x.Uses == 1 && clobber(x)) {
 15205				break
 15206			}
 15207			b = x.Block
 15208			v0 := b.NewValue0(v.Pos, OpS390XMOVBloadidx, t)
 15209			v.reset(OpCopy)
 15210			v.AddArg(v0)
 15211			v0.AuxInt = off
 15212			v0.Aux = sym
 15213			v0.AddArg(ptr)
 15214			v0.AddArg(idx)
 15215			v0.AddArg(mem)
 15216			return true
 15217		}
 15218		// match: (MOVDnop <t> x:(MOVHZloadidx [off] {sym} ptr idx mem))
 15219		// cond: x.Uses == 1 && clobber(x)
 15220		// result: @x.Block (MOVHZloadidx <t> [off] {sym} ptr idx mem)
 15221		for {
 15222			t := v.Type
 15223			x := v.Args[0]
 15224			if x.Op != OpS390XMOVHZloadidx {
 15225				break
 15226			}
 15227			off := x.AuxInt
 15228			sym := x.Aux
 15229			mem := x.Args[2]
 15230			ptr := x.Args[0]
 15231			idx := x.Args[1]
 15232			if !(x.Uses == 1 && clobber(x)) {
 15233				break
 15234			}
 15235			b = x.Block
 15236			v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, t)
 15237			v.reset(OpCopy)
 15238			v.AddArg(v0)
 15239			v0.AuxInt = off
 15240			v0.Aux = sym
 15241			v0.AddArg(ptr)
 15242			v0.AddArg(idx)
 15243			v0.AddArg(mem)
 15244			return true
 15245		}
 15246		// match: (MOVDnop <t> x:(MOVHloadidx [off] {sym} ptr idx mem))
 15247		// cond: x.Uses == 1 && clobber(x)
 15248		// result: @x.Block (MOVHloadidx <t> [off] {sym} ptr idx mem)
 15249		for {
 15250			t := v.Type
 15251			x := v.Args[0]
 15252			if x.Op != OpS390XMOVHloadidx {
 15253				break
 15254			}
 15255			off := x.AuxInt
 15256			sym := x.Aux
 15257			mem := x.Args[2]
 15258			ptr := x.Args[0]
 15259			idx := x.Args[1]
 15260			if !(x.Uses == 1 && clobber(x)) {
 15261				break
 15262			}
 15263			b = x.Block
 15264			v0 := b.NewValue0(v.Pos, OpS390XMOVHloadidx, t)
 15265			v.reset(OpCopy)
 15266			v.AddArg(v0)
 15267			v0.AuxInt = off
 15268			v0.Aux = sym
 15269			v0.AddArg(ptr)
 15270			v0.AddArg(idx)
 15271			v0.AddArg(mem)
 15272			return true
 15273		}
 15274		// match: (MOVDnop <t> x:(MOVWZloadidx [off] {sym} ptr idx mem))
 15275		// cond: x.Uses == 1 && clobber(x)
 15276		// result: @x.Block (MOVWZloadidx <t> [off] {sym} ptr idx mem)
 15277		for {
 15278			t := v.Type
 15279			x := v.Args[0]
 15280			if x.Op != OpS390XMOVWZloadidx {
 15281				break
 15282			}
 15283			off := x.AuxInt
 15284			sym := x.Aux
 15285			mem := x.Args[2]
 15286			ptr := x.Args[0]
 15287			idx := x.Args[1]
 15288			if !(x.Uses == 1 && clobber(x)) {
 15289				break
 15290			}
 15291			b = x.Block
 15292			v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, t)
 15293			v.reset(OpCopy)
 15294			v.AddArg(v0)
 15295			v0.AuxInt = off
 15296			v0.Aux = sym
 15297			v0.AddArg(ptr)
 15298			v0.AddArg(idx)
 15299			v0.AddArg(mem)
 15300			return true
 15301		}
 15302		// match: (MOVDnop <t> x:(MOVWloadidx [off] {sym} ptr idx mem))
 15303		// cond: x.Uses == 1 && clobber(x)
 15304		// result: @x.Block (MOVWloadidx <t> [off] {sym} ptr idx mem)
 15305		for {
 15306			t := v.Type
 15307			x := v.Args[0]
 15308			if x.Op != OpS390XMOVWloadidx {
 15309				break
 15310			}
 15311			off := x.AuxInt
 15312			sym := x.Aux
 15313			mem := x.Args[2]
 15314			ptr := x.Args[0]
 15315			idx := x.Args[1]
 15316			if !(x.Uses == 1 && clobber(x)) {
 15317				break
 15318			}
 15319			b = x.Block
 15320			v0 := b.NewValue0(v.Pos, OpS390XMOVWloadidx, t)
 15321			v.reset(OpCopy)
 15322			v.AddArg(v0)
 15323			v0.AuxInt = off
 15324			v0.Aux = sym
 15325			v0.AddArg(ptr)
 15326			v0.AddArg(idx)
 15327			v0.AddArg(mem)
 15328			return true
 15329		}
 15330		// match: (MOVDnop <t> x:(MOVDloadidx [off] {sym} ptr idx mem))
 15331		// cond: x.Uses == 1 && clobber(x)
 15332		// result: @x.Block (MOVDloadidx <t> [off] {sym} ptr idx mem)
 15333		for {
 15334			t := v.Type
 15335			x := v.Args[0]
 15336			if x.Op != OpS390XMOVDloadidx {
 15337				break
 15338			}
 15339			off := x.AuxInt
 15340			sym := x.Aux
 15341			mem := x.Args[2]
 15342			ptr := x.Args[0]
 15343			idx := x.Args[1]
 15344			if !(x.Uses == 1 && clobber(x)) {
 15345				break
 15346			}
 15347			b = x.Block
 15348			v0 := b.NewValue0(v.Pos, OpS390XMOVDloadidx, t)
 15349			v.reset(OpCopy)
 15350			v.AddArg(v0)
 15351			v0.AuxInt = off
 15352			v0.Aux = sym
 15353			v0.AddArg(ptr)
 15354			v0.AddArg(idx)
 15355			v0.AddArg(mem)
 15356			return true
 15357		}
 15358		return false
 15359	}
 15360	func rewriteValueS390X_OpS390XMOVDreg_0(v *Value) bool {
 15361		b := v.Block
 15362		// match: (MOVDreg <t> x)
 15363		// cond: t.Compare(x.Type) == types.CMPeq
 15364		// result: x
 15365		for {
 15366			t := v.Type
 15367			x := v.Args[0]
 15368			if !(t.Compare(x.Type) == types.CMPeq) {
 15369				break
 15370			}
 15371			v.reset(OpCopy)
 15372			v.Type = x.Type
 15373			v.AddArg(x)
 15374			return true
 15375		}
 15376		// match: (MOVDreg (MOVDconst [c]))
 15377		// cond:
 15378		// result: (MOVDconst [c])
 15379		for {
 15380			v_0 := v.Args[0]
 15381			if v_0.Op != OpS390XMOVDconst {
 15382				break
 15383			}
 15384			c := v_0.AuxInt
 15385			v.reset(OpS390XMOVDconst)
 15386			v.AuxInt = c
 15387			return true
 15388		}
 15389		// match: (MOVDreg x)
 15390		// cond: x.Uses == 1
 15391		// result: (MOVDnop x)
 15392		for {
 15393			x := v.Args[0]
 15394			if !(x.Uses == 1) {
 15395				break
 15396			}
 15397			v.reset(OpS390XMOVDnop)
 15398			v.AddArg(x)
 15399			return true
 15400		}
 15401		// match: (MOVDreg <t> x:(MOVBZload [off] {sym} ptr mem))
 15402		// cond: x.Uses == 1 && clobber(x)
 15403		// result: @x.Block (MOVBZload <t> [off] {sym} ptr mem)
 15404		for {
 15405			t := v.Type
 15406			x := v.Args[0]
 15407			if x.Op != OpS390XMOVBZload {
 15408				break
 15409			}
 15410			off := x.AuxInt
 15411			sym := x.Aux
 15412			mem := x.Args[1]
 15413			ptr := x.Args[0]
 15414			if !(x.Uses == 1 && clobber(x)) {
 15415				break
 15416			}
 15417			b = x.Block
 15418			v0 := b.NewValue0(x.Pos, OpS390XMOVBZload, t)
 15419			v.reset(OpCopy)
 15420			v.AddArg(v0)
 15421			v0.AuxInt = off
 15422			v0.Aux = sym
 15423			v0.AddArg(ptr)
 15424			v0.AddArg(mem)
 15425			return true
 15426		}
 15427		// match: (MOVDreg <t> x:(MOVBload [off] {sym} ptr mem))
 15428		// cond: x.Uses == 1 && clobber(x)
 15429		// result: @x.Block (MOVBload <t> [off] {sym} ptr mem)
 15430		for {
 15431			t := v.Type
 15432			x := v.Args[0]
 15433			if x.Op != OpS390XMOVBload {
 15434				break
 15435			}
 15436			off := x.AuxInt
 15437			sym := x.Aux
 15438			mem := x.Args[1]
 15439			ptr := x.Args[0]
 15440			if !(x.Uses == 1 && clobber(x)) {
 15441				break
 15442			}
 15443			b = x.Block
 15444			v0 := b.NewValue0(x.Pos, OpS390XMOVBload, t)
 15445			v.reset(OpCopy)
 15446			v.AddArg(v0)
 15447			v0.AuxInt = off
 15448			v0.Aux = sym
 15449			v0.AddArg(ptr)
 15450			v0.AddArg(mem)
 15451			return true
 15452		}
 15453		// match: (MOVDreg <t> x:(MOVHZload [off] {sym} ptr mem))
 15454		// cond: x.Uses == 1 && clobber(x)
 15455		// result: @x.Block (MOVHZload <t> [off] {sym} ptr mem)
 15456		for {
 15457			t := v.Type
 15458			x := v.Args[0]
 15459			if x.Op != OpS390XMOVHZload {
 15460				break
 15461			}
 15462			off := x.AuxInt
 15463			sym := x.Aux
 15464			mem := x.Args[1]
 15465			ptr := x.Args[0]
 15466			if !(x.Uses == 1 && clobber(x)) {
 15467				break
 15468			}
 15469			b = x.Block
 15470			v0 := b.NewValue0(x.Pos, OpS390XMOVHZload, t)
 15471			v.reset(OpCopy)
 15472			v.AddArg(v0)
 15473			v0.AuxInt = off
 15474			v0.Aux = sym
 15475			v0.AddArg(ptr)
 15476			v0.AddArg(mem)
 15477			return true
 15478		}
 15479		// match: (MOVDreg <t> x:(MOVHload [off] {sym} ptr mem))
 15480		// cond: x.Uses == 1 && clobber(x)
 15481		// result: @x.Block (MOVHload <t> [off] {sym} ptr mem)
 15482		for {
 15483			t := v.Type
 15484			x := v.Args[0]
 15485			if x.Op != OpS390XMOVHload {
 15486				break
 15487			}
 15488			off := x.AuxInt
 15489			sym := x.Aux
 15490			mem := x.Args[1]
 15491			ptr := x.Args[0]
 15492			if !(x.Uses == 1 && clobber(x)) {
 15493				break
 15494			}
 15495			b = x.Block
 15496			v0 := b.NewValue0(x.Pos, OpS390XMOVHload, t)
 15497			v.reset(OpCopy)
 15498			v.AddArg(v0)
 15499			v0.AuxInt = off
 15500			v0.Aux = sym
 15501			v0.AddArg(ptr)
 15502			v0.AddArg(mem)
 15503			return true
 15504		}
 15505		// match: (MOVDreg <t> x:(MOVWZload [off] {sym} ptr mem))
 15506		// cond: x.Uses == 1 && clobber(x)
 15507		// result: @x.Block (MOVWZload <t> [off] {sym} ptr mem)
 15508		for {
 15509			t := v.Type
 15510			x := v.Args[0]
 15511			if x.Op != OpS390XMOVWZload {
 15512				break
 15513			}
 15514			off := x.AuxInt
 15515			sym := x.Aux
 15516			mem := x.Args[1]
 15517			ptr := x.Args[0]
 15518			if !(x.Uses == 1 && clobber(x)) {
 15519				break
 15520			}
 15521			b = x.Block
 15522			v0 := b.NewValue0(x.Pos, OpS390XMOVWZload, t)
 15523			v.reset(OpCopy)
 15524			v.AddArg(v0)
 15525			v0.AuxInt = off
 15526			v0.Aux = sym
 15527			v0.AddArg(ptr)
 15528			v0.AddArg(mem)
 15529			return true
 15530		}
 15531		// match: (MOVDreg <t> x:(MOVWload [off] {sym} ptr mem))
 15532		// cond: x.Uses == 1 && clobber(x)
 15533		// result: @x.Block (MOVWload <t> [off] {sym} ptr mem)
 15534		for {
 15535			t := v.Type
 15536			x := v.Args[0]
 15537			if x.Op != OpS390XMOVWload {
 15538				break
 15539			}
 15540			off := x.AuxInt
 15541			sym := x.Aux
 15542			mem := x.Args[1]
 15543			ptr := x.Args[0]
 15544			if !(x.Uses == 1 && clobber(x)) {
 15545				break
 15546			}
 15547			b = x.Block
 15548			v0 := b.NewValue0(x.Pos, OpS390XMOVWload, t)
 15549			v.reset(OpCopy)
 15550			v.AddArg(v0)
 15551			v0.AuxInt = off
 15552			v0.Aux = sym
 15553			v0.AddArg(ptr)
 15554			v0.AddArg(mem)
 15555			return true
 15556		}
 15557		// match: (MOVDreg <t> x:(MOVDload [off] {sym} ptr mem))
 15558		// cond: x.Uses == 1 && clobber(x)
 15559		// result: @x.Block (MOVDload <t> [off] {sym} ptr mem)
 15560		for {
 15561			t := v.Type
 15562			x := v.Args[0]
 15563			if x.Op != OpS390XMOVDload {
 15564				break
 15565			}
 15566			off := x.AuxInt
 15567			sym := x.Aux
 15568			mem := x.Args[1]
 15569			ptr := x.Args[0]
 15570			if !(x.Uses == 1 && clobber(x)) {
 15571				break
 15572			}
 15573			b = x.Block
 15574			v0 := b.NewValue0(x.Pos, OpS390XMOVDload, t)
 15575			v.reset(OpCopy)
 15576			v.AddArg(v0)
 15577			v0.AuxInt = off
 15578			v0.Aux = sym
 15579			v0.AddArg(ptr)
 15580			v0.AddArg(mem)
 15581			return true
 15582		}
 15583		return false
 15584	}
 15585	func rewriteValueS390X_OpS390XMOVDreg_10(v *Value) bool {
 15586		b := v.Block
 15587		// match: (MOVDreg <t> x:(MOVBZloadidx [off] {sym} ptr idx mem))
 15588		// cond: x.Uses == 1 && clobber(x)
 15589		// result: @x.Block (MOVBZloadidx <t> [off] {sym} ptr idx mem)
 15590		for {
 15591			t := v.Type
 15592			x := v.Args[0]
 15593			if x.Op != OpS390XMOVBZloadidx {
 15594				break
 15595			}
 15596			off := x.AuxInt
 15597			sym := x.Aux
 15598			mem := x.Args[2]
 15599			ptr := x.Args[0]
 15600			idx := x.Args[1]
 15601			if !(x.Uses == 1 && clobber(x)) {
 15602				break
 15603			}
 15604			b = x.Block
 15605			v0 := b.NewValue0(v.Pos, OpS390XMOVBZloadidx, t)
 15606			v.reset(OpCopy)
 15607			v.AddArg(v0)
 15608			v0.AuxInt = off
 15609			v0.Aux = sym
 15610			v0.AddArg(ptr)
 15611			v0.AddArg(idx)
 15612			v0.AddArg(mem)
 15613			return true
 15614		}
 15615		// match: (MOVDreg <t> x:(MOVBloadidx [off] {sym} ptr idx mem))
 15616		// cond: x.Uses == 1 && clobber(x)
 15617		// result: @x.Block (MOVBloadidx <t> [off] {sym} ptr idx mem)
 15618		for {
 15619			t := v.Type
 15620			x := v.Args[0]
 15621			if x.Op != OpS390XMOVBloadidx {
 15622				break
 15623			}
 15624			off := x.AuxInt
 15625			sym := x.Aux
 15626			mem := x.Args[2]
 15627			ptr := x.Args[0]
 15628			idx := x.Args[1]
 15629			if !(x.Uses == 1 && clobber(x)) {
 15630				break
 15631			}
 15632			b = x.Block
 15633			v0 := b.NewValue0(v.Pos, OpS390XMOVBloadidx, t)
 15634			v.reset(OpCopy)
 15635			v.AddArg(v0)
 15636			v0.AuxInt = off
 15637			v0.Aux = sym
 15638			v0.AddArg(ptr)
 15639			v0.AddArg(idx)
 15640			v0.AddArg(mem)
 15641			return true
 15642		}
 15643		// match: (MOVDreg <t> x:(MOVHZloadidx [off] {sym} ptr idx mem))
 15644		// cond: x.Uses == 1 && clobber(x)
 15645		// result: @x.Block (MOVHZloadidx <t> [off] {sym} ptr idx mem)
 15646		for {
 15647			t := v.Type
 15648			x := v.Args[0]
 15649			if x.Op != OpS390XMOVHZloadidx {
 15650				break
 15651			}
 15652			off := x.AuxInt
 15653			sym := x.Aux
 15654			mem := x.Args[2]
 15655			ptr := x.Args[0]
 15656			idx := x.Args[1]
 15657			if !(x.Uses == 1 && clobber(x)) {
 15658				break
 15659			}
 15660			b = x.Block
 15661			v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, t)
 15662			v.reset(OpCopy)
 15663			v.AddArg(v0)
 15664			v0.AuxInt = off
 15665			v0.Aux = sym
 15666			v0.AddArg(ptr)
 15667			v0.AddArg(idx)
 15668			v0.AddArg(mem)
 15669			return true
 15670		}
 15671		// match: (MOVDreg <t> x:(MOVHloadidx [off] {sym} ptr idx mem))
 15672		// cond: x.Uses == 1 && clobber(x)
 15673		// result: @x.Block (MOVHloadidx <t> [off] {sym} ptr idx mem)
 15674		for {
 15675			t := v.Type
 15676			x := v.Args[0]
 15677			if x.Op != OpS390XMOVHloadidx {
 15678				break
 15679			}
 15680			off := x.AuxInt
 15681			sym := x.Aux
 15682			mem := x.Args[2]
 15683			ptr := x.Args[0]
 15684			idx := x.Args[1]
 15685			if !(x.Uses == 1 && clobber(x)) {
 15686				break
 15687			}
 15688			b = x.Block
 15689			v0 := b.NewValue0(v.Pos, OpS390XMOVHloadidx, t)
 15690			v.reset(OpCopy)
 15691			v.AddArg(v0)
 15692			v0.AuxInt = off
 15693			v0.Aux = sym
 15694			v0.AddArg(ptr)
 15695			v0.AddArg(idx)
 15696			v0.AddArg(mem)
 15697			return true
 15698		}
 15699		// match: (MOVDreg <t> x:(MOVWZloadidx [off] {sym} ptr idx mem))
 15700		// cond: x.Uses == 1 && clobber(x)
 15701		// result: @x.Block (MOVWZloadidx <t> [off] {sym} ptr idx mem)
 15702		for {
 15703			t := v.Type
 15704			x := v.Args[0]
 15705			if x.Op != OpS390XMOVWZloadidx {
 15706				break
 15707			}
 15708			off := x.AuxInt
 15709			sym := x.Aux
 15710			mem := x.Args[2]
 15711			ptr := x.Args[0]
 15712			idx := x.Args[1]
 15713			if !(x.Uses == 1 && clobber(x)) {
 15714				break
 15715			}
 15716			b = x.Block
 15717			v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, t)
 15718			v.reset(OpCopy)
 15719			v.AddArg(v0)
 15720			v0.AuxInt = off
 15721			v0.Aux = sym
 15722			v0.AddArg(ptr)
 15723			v0.AddArg(idx)
 15724			v0.AddArg(mem)
 15725			return true
 15726		}
 15727		// match: (MOVDreg <t> x:(MOVWloadidx [off] {sym} ptr idx mem))
 15728		// cond: x.Uses == 1 && clobber(x)
 15729		// result: @x.Block (MOVWloadidx <t> [off] {sym} ptr idx mem)
 15730		for {
 15731			t := v.Type
 15732			x := v.Args[0]
 15733			if x.Op != OpS390XMOVWloadidx {
 15734				break
 15735			}
 15736			off := x.AuxInt
 15737			sym := x.Aux
 15738			mem := x.Args[2]
 15739			ptr := x.Args[0]
 15740			idx := x.Args[1]
 15741			if !(x.Uses == 1 && clobber(x)) {
 15742				break
 15743			}
 15744			b = x.Block
 15745			v0 := b.NewValue0(v.Pos, OpS390XMOVWloadidx, t)
 15746			v.reset(OpCopy)
 15747			v.AddArg(v0)
 15748			v0.AuxInt = off
 15749			v0.Aux = sym
 15750			v0.AddArg(ptr)
 15751			v0.AddArg(idx)
 15752			v0.AddArg(mem)
 15753			return true
 15754		}
 15755		// match: (MOVDreg <t> x:(MOVDloadidx [off] {sym} ptr idx mem))
 15756		// cond: x.Uses == 1 && clobber(x)
 15757		// result: @x.Block (MOVDloadidx <t> [off] {sym} ptr idx mem)
 15758		for {
 15759			t := v.Type
 15760			x := v.Args[0]
 15761			if x.Op != OpS390XMOVDloadidx {
 15762				break
 15763			}
 15764			off := x.AuxInt
 15765			sym := x.Aux
 15766			mem := x.Args[2]
 15767			ptr := x.Args[0]
 15768			idx := x.Args[1]
 15769			if !(x.Uses == 1 && clobber(x)) {
 15770				break
 15771			}
 15772			b = x.Block
 15773			v0 := b.NewValue0(v.Pos, OpS390XMOVDloadidx, t)
 15774			v.reset(OpCopy)
 15775			v.AddArg(v0)
 15776			v0.AuxInt = off
 15777			v0.Aux = sym
 15778			v0.AddArg(ptr)
 15779			v0.AddArg(idx)
 15780			v0.AddArg(mem)
 15781			return true
 15782		}
 15783		return false
 15784	}
 15785	func rewriteValueS390X_OpS390XMOVDstore_0(v *Value) bool {
 15786		// match: (MOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem)
 15787		// cond: is20Bit(off1+off2)
 15788		// result: (MOVDstore [off1+off2] {sym} ptr val mem)
 15789		for {
 15790			off1 := v.AuxInt
 15791			sym := v.Aux
 15792			mem := v.Args[2]
 15793			v_0 := v.Args[0]
 15794			if v_0.Op != OpS390XADDconst {
 15795				break
 15796			}
 15797			off2 := v_0.AuxInt
 15798			ptr := v_0.Args[0]
 15799			val := v.Args[1]
 15800			if !(is20Bit(off1 + off2)) {
 15801				break
 15802			}
 15803			v.reset(OpS390XMOVDstore)
 15804			v.AuxInt = off1 + off2
 15805			v.Aux = sym
 15806			v.AddArg(ptr)
 15807			v.AddArg(val)
 15808			v.AddArg(mem)
 15809			return true
 15810		}
 15811		// match: (MOVDstore [off] {sym} ptr (MOVDconst [c]) mem)
 15812		// cond: is16Bit(c) && isU12Bit(off) && ptr.Op != OpSB
 15813		// result: (MOVDstoreconst [makeValAndOff(c,off)] {sym} ptr mem)
 15814		for {
 15815			off := v.AuxInt
 15816			sym := v.Aux
 15817			mem := v.Args[2]
 15818			ptr := v.Args[0]
 15819			v_1 := v.Args[1]
 15820			if v_1.Op != OpS390XMOVDconst {
 15821				break
 15822			}
 15823			c := v_1.AuxInt
 15824			if !(is16Bit(c) && isU12Bit(off) && ptr.Op != OpSB) {
 15825				break
 15826			}
 15827			v.reset(OpS390XMOVDstoreconst)
 15828			v.AuxInt = makeValAndOff(c, off)
 15829			v.Aux = sym
 15830			v.AddArg(ptr)
 15831			v.AddArg(mem)
 15832			return true
 15833		}
 15834		// match: (MOVDstore [off1] {sym1} (MOVDaddr <t> [off2] {sym2} base) val mem)
 15835		// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || (t.IsPtr() && t.Elem().Alignment()%8 == 0 && (off1+off2)%8 == 0))
 15836		// result: (MOVDstore [off1+off2] {mergeSym(sym1,sym2)} base val mem)
 15837		for {
 15838			off1 := v.AuxInt
 15839			sym1 := v.Aux
 15840			mem := v.Args[2]
 15841			v_0 := v.Args[0]
 15842			if v_0.Op != OpS390XMOVDaddr {
 15843				break
 15844			}
 15845			t := v_0.Type
 15846			off2 := v_0.AuxInt
 15847			sym2 := v_0.Aux
 15848			base := v_0.Args[0]
 15849			val := v.Args[1]
 15850			if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || (t.IsPtr() && t.Elem().Alignment()%8 == 0 && (off1+off2)%8 == 0))) {
 15851				break
 15852			}
 15853			v.reset(OpS390XMOVDstore)
 15854			v.AuxInt = off1 + off2
 15855			v.Aux = mergeSym(sym1, sym2)
 15856			v.AddArg(base)
 15857			v.AddArg(val)
 15858			v.AddArg(mem)
 15859			return true
 15860		}
 15861		// match: (MOVDstore [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) val mem)
 15862		// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
 15863		// result: (MOVDstoreidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx val mem)
 15864		for {
 15865			off1 := v.AuxInt
 15866			sym1 := v.Aux
 15867			mem := v.Args[2]
 15868			v_0 := v.Args[0]
 15869			if v_0.Op != OpS390XMOVDaddridx {
 15870				break
 15871			}
 15872			off2 := v_0.AuxInt
 15873			sym2 := v_0.Aux
 15874			idx := v_0.Args[1]
 15875			ptr := v_0.Args[0]
 15876			val := v.Args[1]
 15877			if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
 15878				break
 15879			}
 15880			v.reset(OpS390XMOVDstoreidx)
 15881			v.AuxInt = off1 + off2
 15882			v.Aux = mergeSym(sym1, sym2)
 15883			v.AddArg(ptr)
 15884			v.AddArg(idx)
 15885			v.AddArg(val)
 15886			v.AddArg(mem)
 15887			return true
 15888		}
 15889		// match: (MOVDstore [off] {sym} (ADD ptr idx) val mem)
 15890		// cond: ptr.Op != OpSB
 15891		// result: (MOVDstoreidx [off] {sym} ptr idx val mem)
 15892		for {
 15893			off := v.AuxInt
 15894			sym := v.Aux
 15895			mem := v.Args[2]
 15896			v_0 := v.Args[0]
 15897			if v_0.Op != OpS390XADD {
 15898				break
 15899			}
 15900			idx := v_0.Args[1]
 15901			ptr := v_0.Args[0]
 15902			val := v.Args[1]
 15903			if !(ptr.Op != OpSB) {
 15904				break
 15905			}
 15906			v.reset(OpS390XMOVDstoreidx)
 15907			v.AuxInt = off
 15908			v.Aux = sym
 15909			v.AddArg(ptr)
 15910			v.AddArg(idx)
 15911			v.AddArg(val)
 15912			v.AddArg(mem)
 15913			return true
 15914		}
 15915		// match: (MOVDstore [i] {s} p w1 x:(MOVDstore [i-8] {s} p w0 mem))
 15916		// cond: p.Op != OpSB && x.Uses == 1 && is20Bit(i-8) && clobber(x)
 15917		// result: (STMG2 [i-8] {s} p w0 w1 mem)
 15918		for {
 15919			i := v.AuxInt
 15920			s := v.Aux
 15921			_ = v.Args[2]
 15922			p := v.Args[0]
 15923			w1 := v.Args[1]
 15924			x := v.Args[2]
 15925			if x.Op != OpS390XMOVDstore {
 15926				break
 15927			}
 15928			if x.AuxInt != i-8 {
 15929				break
 15930			}
 15931			if x.Aux != s {
 15932				break
 15933			}
 15934			mem := x.Args[2]
 15935			if p != x.Args[0] {
 15936				break
 15937			}
 15938			w0 := x.Args[1]
 15939			if !(p.Op != OpSB && x.Uses == 1 && is20Bit(i-8) && clobber(x)) {
 15940				break
 15941			}
 15942			v.reset(OpS390XSTMG2)
 15943			v.AuxInt = i - 8
 15944			v.Aux = s
 15945			v.AddArg(p)
 15946			v.AddArg(w0)
 15947			v.AddArg(w1)
 15948			v.AddArg(mem)
 15949			return true
 15950		}
 15951		// match: (MOVDstore [i] {s} p w2 x:(STMG2 [i-16] {s} p w0 w1 mem))
 15952		// cond: x.Uses == 1 && is20Bit(i-16) && clobber(x)
 15953		// result: (STMG3 [i-16] {s} p w0 w1 w2 mem)
 15954		for {
 15955			i := v.AuxInt
 15956			s := v.Aux
 15957			_ = v.Args[2]
 15958			p := v.Args[0]
 15959			w2 := v.Args[1]
 15960			x := v.Args[2]
 15961			if x.Op != OpS390XSTMG2 {
 15962				break
 15963			}
 15964			if x.AuxInt != i-16 {
 15965				break
 15966			}
 15967			if x.Aux != s {
 15968				break
 15969			}
 15970			mem := x.Args[3]
 15971			if p != x.Args[0] {
 15972				break
 15973			}
 15974			w0 := x.Args[1]
 15975			w1 := x.Args[2]
 15976			if !(x.Uses == 1 && is20Bit(i-16) && clobber(x)) {
 15977				break
 15978			}
 15979			v.reset(OpS390XSTMG3)
 15980			v.AuxInt = i - 16
 15981			v.Aux = s
 15982			v.AddArg(p)
 15983			v.AddArg(w0)
 15984			v.AddArg(w1)
 15985			v.AddArg(w2)
 15986			v.AddArg(mem)
 15987			return true
 15988		}
 15989		// match: (MOVDstore [i] {s} p w3 x:(STMG3 [i-24] {s} p w0 w1 w2 mem))
 15990		// cond: x.Uses == 1 && is20Bit(i-24) && clobber(x)
 15991		// result: (STMG4 [i-24] {s} p w0 w1 w2 w3 mem)
 15992		for {
 15993			i := v.AuxInt
 15994			s := v.Aux
 15995			_ = v.Args[2]
 15996			p := v.Args[0]
 15997			w3 := v.Args[1]
 15998			x := v.Args[2]
 15999			if x.Op != OpS390XSTMG3 {
 16000				break
 16001			}
 16002			if x.AuxInt != i-24 {
 16003				break
 16004			}
 16005			if x.Aux != s {
 16006				break
 16007			}
 16008			mem := x.Args[4]
 16009			if p != x.Args[0] {
 16010				break
 16011			}
 16012			w0 := x.Args[1]
 16013			w1 := x.Args[2]
 16014			w2 := x.Args[3]
 16015			if !(x.Uses == 1 && is20Bit(i-24) && clobber(x)) {
 16016				break
 16017			}
 16018			v.reset(OpS390XSTMG4)
 16019			v.AuxInt = i - 24
 16020			v.Aux = s
 16021			v.AddArg(p)
 16022			v.AddArg(w0)
 16023			v.AddArg(w1)
 16024			v.AddArg(w2)
 16025			v.AddArg(w3)
 16026			v.AddArg(mem)
 16027			return true
 16028		}
 16029		return false
 16030	}
 16031	func rewriteValueS390X_OpS390XMOVDstoreconst_0(v *Value) bool {
 16032		// match: (MOVDstoreconst [sc] {s} (ADDconst [off] ptr) mem)
 16033		// cond: isU12Bit(ValAndOff(sc).Off()+off)
 16034		// result: (MOVDstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
 16035		for {
 16036			sc := v.AuxInt
 16037			s := v.Aux
 16038			mem := v.Args[1]
 16039			v_0 := v.Args[0]
 16040			if v_0.Op != OpS390XADDconst {
 16041				break
 16042			}
 16043			off := v_0.AuxInt
 16044			ptr := v_0.Args[0]
 16045			if !(isU12Bit(ValAndOff(sc).Off() + off)) {
 16046				break
 16047			}
 16048			v.reset(OpS390XMOVDstoreconst)
 16049			v.AuxInt = ValAndOff(sc).add(off)
 16050			v.Aux = s
 16051			v.AddArg(ptr)
 16052			v.AddArg(mem)
 16053			return true
 16054		}
 16055		// match: (MOVDstoreconst [sc] {sym1} (MOVDaddr [off] {sym2} ptr) mem)
 16056		// cond: ptr.Op != OpSB && canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)
 16057		// result: (MOVDstoreconst [ValAndOff(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem)
 16058		for {
 16059			sc := v.AuxInt
 16060			sym1 := v.Aux
 16061			mem := v.Args[1]
 16062			v_0 := v.Args[0]
 16063			if v_0.Op != OpS390XMOVDaddr {
 16064				break
 16065			}
 16066			off := v_0.AuxInt
 16067			sym2 := v_0.Aux
 16068			ptr := v_0.Args[0]
 16069			if !(ptr.Op != OpSB && canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)) {
 16070				break
 16071			}
 16072			v.reset(OpS390XMOVDstoreconst)
 16073			v.AuxInt = ValAndOff(sc).add(off)
 16074			v.Aux = mergeSym(sym1, sym2)
 16075			v.AddArg(ptr)
 16076			v.AddArg(mem)
 16077			return true
 16078		}
 16079		return false
 16080	}
 16081	func rewriteValueS390X_OpS390XMOVDstoreidx_0(v *Value) bool {
 16082		// match: (MOVDstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem)
 16083		// cond: is20Bit(c+d)
 16084		// result: (MOVDstoreidx [c+d] {sym} ptr idx val mem)
 16085		for {
 16086			c := v.AuxInt
 16087			sym := v.Aux
 16088			mem := v.Args[3]
 16089			v_0 := v.Args[0]
 16090			if v_0.Op != OpS390XADDconst {
 16091				break
 16092			}
 16093			d := v_0.AuxInt
 16094			ptr := v_0.Args[0]
 16095			idx := v.Args[1]
 16096			val := v.Args[2]
 16097			if !(is20Bit(c + d)) {
 16098				break
 16099			}
 16100			v.reset(OpS390XMOVDstoreidx)
 16101			v.AuxInt = c + d
 16102			v.Aux = sym
 16103			v.AddArg(ptr)
 16104			v.AddArg(idx)
 16105			v.AddArg(val)
 16106			v.AddArg(mem)
 16107			return true
 16108		}
 16109		// match: (MOVDstoreidx [c] {sym} idx (ADDconst [d] ptr) val mem)
 16110		// cond: is20Bit(c+d)
 16111		// result: (MOVDstoreidx [c+d] {sym} ptr idx val mem)
 16112		for {
 16113			c := v.AuxInt
 16114			sym := v.Aux
 16115			mem := v.Args[3]
 16116			idx := v.Args[0]
 16117			v_1 := v.Args[1]
 16118			if v_1.Op != OpS390XADDconst {
 16119				break
 16120			}
 16121			d := v_1.AuxInt
 16122			ptr := v_1.Args[0]
 16123			val := v.Args[2]
 16124			if !(is20Bit(c + d)) {
 16125				break
 16126			}
 16127			v.reset(OpS390XMOVDstoreidx)
 16128			v.AuxInt = c + d
 16129			v.Aux = sym
 16130			v.AddArg(ptr)
 16131			v.AddArg(idx)
 16132			v.AddArg(val)
 16133			v.AddArg(mem)
 16134			return true
 16135		}
 16136		// match: (MOVDstoreidx [c] {sym} ptr (ADDconst [d] idx) val mem)
 16137		// cond: is20Bit(c+d)
 16138		// result: (MOVDstoreidx [c+d] {sym} ptr idx val mem)
 16139		for {
 16140			c := v.AuxInt
 16141			sym := v.Aux
 16142			mem := v.Args[3]
 16143			ptr := v.Args[0]
 16144			v_1 := v.Args[1]
 16145			if v_1.Op != OpS390XADDconst {
 16146				break
 16147			}
 16148			d := v_1.AuxInt
 16149			idx := v_1.Args[0]
 16150			val := v.Args[2]
 16151			if !(is20Bit(c + d)) {
 16152				break
 16153			}
 16154			v.reset(OpS390XMOVDstoreidx)
 16155			v.AuxInt = c + d
 16156			v.Aux = sym
 16157			v.AddArg(ptr)
 16158			v.AddArg(idx)
 16159			v.AddArg(val)
 16160			v.AddArg(mem)
 16161			return true
 16162		}
 16163		// match: (MOVDstoreidx [c] {sym} (ADDconst [d] idx) ptr val mem)
 16164		// cond: is20Bit(c+d)
 16165		// result: (MOVDstoreidx [c+d] {sym} ptr idx val mem)
 16166		for {
 16167			c := v.AuxInt
 16168			sym := v.Aux
 16169			mem := v.Args[3]
 16170			v_0 := v.Args[0]
 16171			if v_0.Op != OpS390XADDconst {
 16172				break
 16173			}
 16174			d := v_0.AuxInt
 16175			idx := v_0.Args[0]
 16176			ptr := v.Args[1]
 16177			val := v.Args[2]
 16178			if !(is20Bit(c + d)) {
 16179				break
 16180			}
 16181			v.reset(OpS390XMOVDstoreidx)
 16182			v.AuxInt = c + d
 16183			v.Aux = sym
 16184			v.AddArg(ptr)
 16185			v.AddArg(idx)
 16186			v.AddArg(val)
 16187			v.AddArg(mem)
 16188			return true
 16189		}
 16190		return false
 16191	}
 16192	func rewriteValueS390X_OpS390XMOVHBRstore_0(v *Value) bool {
 16193		// match: (MOVHBRstore [i] {s} p (SRDconst [16] w) x:(MOVHBRstore [i-2] {s} p w mem))
 16194		// cond: x.Uses == 1 && clobber(x)
 16195		// result: (MOVWBRstore [i-2] {s} p w mem)
 16196		for {
 16197			i := v.AuxInt
 16198			s := v.Aux
 16199			_ = v.Args[2]
 16200			p := v.Args[0]
 16201			v_1 := v.Args[1]
 16202			if v_1.Op != OpS390XSRDconst {
 16203				break
 16204			}
 16205			if v_1.AuxInt != 16 {
 16206				break
 16207			}
 16208			w := v_1.Args[0]
 16209			x := v.Args[2]
 16210			if x.Op != OpS390XMOVHBRstore {
 16211				break
 16212			}
 16213			if x.AuxInt != i-2 {
 16214				break
 16215			}
 16216			if x.Aux != s {
 16217				break
 16218			}
 16219			mem := x.Args[2]
 16220			if p != x.Args[0] {
 16221				break
 16222			}
 16223			if w != x.Args[1] {
 16224				break
 16225			}
 16226			if !(x.Uses == 1 && clobber(x)) {
 16227				break
 16228			}
 16229			v.reset(OpS390XMOVWBRstore)
 16230			v.AuxInt = i - 2
 16231			v.Aux = s
 16232			v.AddArg(p)
 16233			v.AddArg(w)
 16234			v.AddArg(mem)
 16235			return true
 16236		}
 16237		// match: (MOVHBRstore [i] {s} p (SRDconst [j] w) x:(MOVHBRstore [i-2] {s} p w0:(SRDconst [j-16] w) mem))
 16238		// cond: x.Uses == 1 && clobber(x)
 16239		// result: (MOVWBRstore [i-2] {s} p w0 mem)
 16240		for {
 16241			i := v.AuxInt
 16242			s := v.Aux
 16243			_ = v.Args[2]
 16244			p := v.Args[0]
 16245			v_1 := v.Args[1]
 16246			if v_1.Op != OpS390XSRDconst {
 16247				break
 16248			}
 16249			j := v_1.AuxInt
 16250			w := v_1.Args[0]
 16251			x := v.Args[2]
 16252			if x.Op != OpS390XMOVHBRstore {
 16253				break
 16254			}
 16255			if x.AuxInt != i-2 {
 16256				break
 16257			}
 16258			if x.Aux != s {
 16259				break
 16260			}
 16261			mem := x.Args[2]
 16262			if p != x.Args[0] {
 16263				break
 16264			}
 16265			w0 := x.Args[1]
 16266			if w0.Op != OpS390XSRDconst {
 16267				break
 16268			}
 16269			if w0.AuxInt != j-16 {
 16270				break
 16271			}
 16272			if w != w0.Args[0] {
 16273				break
 16274			}
 16275			if !(x.Uses == 1 && clobber(x)) {
 16276				break
 16277			}
 16278			v.reset(OpS390XMOVWBRstore)
 16279			v.AuxInt = i - 2
 16280			v.Aux = s
 16281			v.AddArg(p)
 16282			v.AddArg(w0)
 16283			v.AddArg(mem)
 16284			return true
 16285		}
 16286		// match: (MOVHBRstore [i] {s} p (SRWconst [16] w) x:(MOVHBRstore [i-2] {s} p w mem))
 16287		// cond: x.Uses == 1 && clobber(x)
 16288		// result: (MOVWBRstore [i-2] {s} p w mem)
 16289		for {
 16290			i := v.AuxInt
 16291			s := v.Aux
 16292			_ = v.Args[2]
 16293			p := v.Args[0]
 16294			v_1 := v.Args[1]
 16295			if v_1.Op != OpS390XSRWconst {
 16296				break
 16297			}
 16298			if v_1.AuxInt != 16 {
 16299				break
 16300			}
 16301			w := v_1.Args[0]
 16302			x := v.Args[2]
 16303			if x.Op != OpS390XMOVHBRstore {
 16304				break
 16305			}
 16306			if x.AuxInt != i-2 {
 16307				break
 16308			}
 16309			if x.Aux != s {
 16310				break
 16311			}
 16312			mem := x.Args[2]
 16313			if p != x.Args[0] {
 16314				break
 16315			}
 16316			if w != x.Args[1] {
 16317				break
 16318			}
 16319			if !(x.Uses == 1 && clobber(x)) {
 16320				break
 16321			}
 16322			v.reset(OpS390XMOVWBRstore)
 16323			v.AuxInt = i - 2
 16324			v.Aux = s
 16325			v.AddArg(p)
 16326			v.AddArg(w)
 16327			v.AddArg(mem)
 16328			return true
 16329		}
 16330		// match: (MOVHBRstore [i] {s} p (SRWconst [j] w) x:(MOVHBRstore [i-2] {s} p w0:(SRWconst [j-16] w) mem))
 16331		// cond: x.Uses == 1 && clobber(x)
 16332		// result: (MOVWBRstore [i-2] {s} p w0 mem)
 16333		for {
 16334			i := v.AuxInt
 16335			s := v.Aux
 16336			_ = v.Args[2]
 16337			p := v.Args[0]
 16338			v_1 := v.Args[1]
 16339			if v_1.Op != OpS390XSRWconst {
 16340				break
 16341			}
 16342			j := v_1.AuxInt
 16343			w := v_1.Args[0]
 16344			x := v.Args[2]
 16345			if x.Op != OpS390XMOVHBRstore {
 16346				break
 16347			}
 16348			if x.AuxInt != i-2 {
 16349				break
 16350			}
 16351			if x.Aux != s {
 16352				break
 16353			}
 16354			mem := x.Args[2]
 16355			if p != x.Args[0] {
 16356				break
 16357			}
 16358			w0 := x.Args[1]
 16359			if w0.Op != OpS390XSRWconst {
 16360				break
 16361			}
 16362			if w0.AuxInt != j-16 {
 16363				break
 16364			}
 16365			if w != w0.Args[0] {
 16366				break
 16367			}
 16368			if !(x.Uses == 1 && clobber(x)) {
 16369				break
 16370			}
 16371			v.reset(OpS390XMOVWBRstore)
 16372			v.AuxInt = i - 2
 16373			v.Aux = s
 16374			v.AddArg(p)
 16375			v.AddArg(w0)
 16376			v.AddArg(mem)
 16377			return true
 16378		}
 16379		return false
 16380	}
 16381	func rewriteValueS390X_OpS390XMOVHBRstoreidx_0(v *Value) bool {
 16382		// match: (MOVHBRstoreidx [i] {s} p idx (SRDconst [16] w) x:(MOVHBRstoreidx [i-2] {s} p idx w mem))
 16383		// cond: x.Uses == 1 && clobber(x)
 16384		// result: (MOVWBRstoreidx [i-2] {s} p idx w mem)
 16385		for {
 16386			i := v.AuxInt
 16387			s := v.Aux
 16388			_ = v.Args[3]
 16389			p := v.Args[0]
 16390			idx := v.Args[1]
 16391			v_2 := v.Args[2]
 16392			if v_2.Op != OpS390XSRDconst {
 16393				break
 16394			}
 16395			if v_2.AuxInt != 16 {
 16396				break
 16397			}
 16398			w := v_2.Args[0]
 16399			x := v.Args[3]
 16400			if x.Op != OpS390XMOVHBRstoreidx {
 16401				break
 16402			}
 16403			if x.AuxInt != i-2 {
 16404				break
 16405			}
 16406			if x.Aux != s {
 16407				break
 16408			}
 16409			mem := x.Args[3]
 16410			if p != x.Args[0] {
 16411				break
 16412			}
 16413			if idx != x.Args[1] {
 16414				break
 16415			}
 16416			if w != x.Args[2] {
 16417				break
 16418			}
 16419			if !(x.Uses == 1 && clobber(x)) {
 16420				break
 16421			}
 16422			v.reset(OpS390XMOVWBRstoreidx)
 16423			v.AuxInt = i - 2
 16424			v.Aux = s
 16425			v.AddArg(p)
 16426			v.AddArg(idx)
 16427			v.AddArg(w)
 16428			v.AddArg(mem)
 16429			return true
 16430		}
 16431		// match: (MOVHBRstoreidx [i] {s} p idx (SRDconst [16] w) x:(MOVHBRstoreidx [i-2] {s} idx p w mem))
 16432		// cond: x.Uses == 1 && clobber(x)
 16433		// result: (MOVWBRstoreidx [i-2] {s} p idx w mem)
 16434		for {
 16435			i := v.AuxInt
 16436			s := v.Aux
 16437			_ = v.Args[3]
 16438			p := v.Args[0]
 16439			idx := v.Args[1]
 16440			v_2 := v.Args[2]
 16441			if v_2.Op != OpS390XSRDconst {
 16442				break
 16443			}
 16444			if v_2.AuxInt != 16 {
 16445				break
 16446			}
 16447			w := v_2.Args[0]
 16448			x := v.Args[3]
 16449			if x.Op != OpS390XMOVHBRstoreidx {
 16450				break
 16451			}
 16452			if x.AuxInt != i-2 {
 16453				break
 16454			}
 16455			if x.Aux != s {
 16456				break
 16457			}
 16458			mem := x.Args[3]
 16459			if idx != x.Args[0] {
 16460				break
 16461			}
 16462			if p != x.Args[1] {
 16463				break
 16464			}
 16465			if w != x.Args[2] {
 16466				break
 16467			}
 16468			if !(x.Uses == 1 && clobber(x)) {
 16469				break
 16470			}
 16471			v.reset(OpS390XMOVWBRstoreidx)
 16472			v.AuxInt = i - 2
 16473			v.Aux = s
 16474			v.AddArg(p)
 16475			v.AddArg(idx)
 16476			v.AddArg(w)
 16477			v.AddArg(mem)
 16478			return true
 16479		}
 16480		// match: (MOVHBRstoreidx [i] {s} idx p (SRDconst [16] w) x:(MOVHBRstoreidx [i-2] {s} p idx w mem))
 16481		// cond: x.Uses == 1 && clobber(x)
 16482		// result: (MOVWBRstoreidx [i-2] {s} p idx w mem)
 16483		for {
 16484			i := v.AuxInt
 16485			s := v.Aux
 16486			_ = v.Args[3]
 16487			idx := v.Args[0]
 16488			p := v.Args[1]
 16489			v_2 := v.Args[2]
 16490			if v_2.Op != OpS390XSRDconst {
 16491				break
 16492			}
 16493			if v_2.AuxInt != 16 {
 16494				break
 16495			}
 16496			w := v_2.Args[0]
 16497			x := v.Args[3]
 16498			if x.Op != OpS390XMOVHBRstoreidx {
 16499				break
 16500			}
 16501			if x.AuxInt != i-2 {
 16502				break
 16503			}
 16504			if x.Aux != s {
 16505				break
 16506			}
 16507			mem := x.Args[3]
 16508			if p != x.Args[0] {
 16509				break
 16510			}
 16511			if idx != x.Args[1] {
 16512				break
 16513			}
 16514			if w != x.Args[2] {
 16515				break
 16516			}
 16517			if !(x.Uses == 1 && clobber(x)) {
 16518				break
 16519			}
 16520			v.reset(OpS390XMOVWBRstoreidx)
 16521			v.AuxInt = i - 2
 16522			v.Aux = s
 16523			v.AddArg(p)
 16524			v.AddArg(idx)
 16525			v.AddArg(w)
 16526			v.AddArg(mem)
 16527			return true
 16528		}
 16529		// match: (MOVHBRstoreidx [i] {s} idx p (SRDconst [16] w) x:(MOVHBRstoreidx [i-2] {s} idx p w mem))
 16530		// cond: x.Uses == 1 && clobber(x)
 16531		// result: (MOVWBRstoreidx [i-2] {s} p idx w mem)
 16532		for {
 16533			i := v.AuxInt
 16534			s := v.Aux
 16535			_ = v.Args[3]
 16536			idx := v.Args[0]
 16537			p := v.Args[1]
 16538			v_2 := v.Args[2]
 16539			if v_2.Op != OpS390XSRDconst {
 16540				break
 16541			}
 16542			if v_2.AuxInt != 16 {
 16543				break
 16544			}
 16545			w := v_2.Args[0]
 16546			x := v.Args[3]
 16547			if x.Op != OpS390XMOVHBRstoreidx {
 16548				break
 16549			}
 16550			if x.AuxInt != i-2 {
 16551				break
 16552			}
 16553			if x.Aux != s {
 16554				break
 16555			}
 16556			mem := x.Args[3]
 16557			if idx != x.Args[0] {
 16558				break
 16559			}
 16560			if p != x.Args[1] {
 16561				break
 16562			}
 16563			if w != x.Args[2] {
 16564				break
 16565			}
 16566			if !(x.Uses == 1 && clobber(x)) {
 16567				break
 16568			}
 16569			v.reset(OpS390XMOVWBRstoreidx)
 16570			v.AuxInt = i - 2
 16571			v.Aux = s
 16572			v.AddArg(p)
 16573			v.AddArg(idx)
 16574			v.AddArg(w)
 16575			v.AddArg(mem)
 16576			return true
 16577		}
 16578		// match: (MOVHBRstoreidx [i] {s} p idx (SRDconst [j] w) x:(MOVHBRstoreidx [i-2] {s} p idx w0:(SRDconst [j-16] w) mem))
 16579		// cond: x.Uses == 1 && clobber(x)
 16580		// result: (MOVWBRstoreidx [i-2] {s} p idx w0 mem)
 16581		for {
 16582			i := v.AuxInt
 16583			s := v.Aux
 16584			_ = v.Args[3]
 16585			p := v.Args[0]
 16586			idx := v.Args[1]
 16587			v_2 := v.Args[2]
 16588			if v_2.Op != OpS390XSRDconst {
 16589				break
 16590			}
 16591			j := v_2.AuxInt
 16592			w := v_2.Args[0]
 16593			x := v.Args[3]
 16594			if x.Op != OpS390XMOVHBRstoreidx {
 16595				break
 16596			}
 16597			if x.AuxInt != i-2 {
 16598				break
 16599			}
 16600			if x.Aux != s {
 16601				break
 16602			}
 16603			mem := x.Args[3]
 16604			if p != x.Args[0] {
 16605				break
 16606			}
 16607			if idx != x.Args[1] {
 16608				break
 16609			}
 16610			w0 := x.Args[2]
 16611			if w0.Op != OpS390XSRDconst {
 16612				break
 16613			}
 16614			if w0.AuxInt != j-16 {
 16615				break
 16616			}
 16617			if w != w0.Args[0] {
 16618				break
 16619			}
 16620			if !(x.Uses == 1 && clobber(x)) {
 16621				break
 16622			}
 16623			v.reset(OpS390XMOVWBRstoreidx)
 16624			v.AuxInt = i - 2
 16625			v.Aux = s
 16626			v.AddArg(p)
 16627			v.AddArg(idx)
 16628			v.AddArg(w0)
 16629			v.AddArg(mem)
 16630			return true
 16631		}
 16632		// match: (MOVHBRstoreidx [i] {s} p idx (SRDconst [j] w) x:(MOVHBRstoreidx [i-2] {s} idx p w0:(SRDconst [j-16] w) mem))
 16633		// cond: x.Uses == 1 && clobber(x)
 16634		// result: (MOVWBRstoreidx [i-2] {s} p idx w0 mem)
 16635		for {
 16636			i := v.AuxInt
 16637			s := v.Aux
 16638			_ = v.Args[3]
 16639			p := v.Args[0]
 16640			idx := v.Args[1]
 16641			v_2 := v.Args[2]
 16642			if v_2.Op != OpS390XSRDconst {
 16643				break
 16644			}
 16645			j := v_2.AuxInt
 16646			w := v_2.Args[0]
 16647			x := v.Args[3]
 16648			if x.Op != OpS390XMOVHBRstoreidx {
 16649				break
 16650			}
 16651			if x.AuxInt != i-2 {
 16652				break
 16653			}
 16654			if x.Aux != s {
 16655				break
 16656			}
 16657			mem := x.Args[3]
 16658			if idx != x.Args[0] {
 16659				break
 16660			}
 16661			if p != x.Args[1] {
 16662				break
 16663			}
 16664			w0 := x.Args[2]
 16665			if w0.Op != OpS390XSRDconst {
 16666				break
 16667			}
 16668			if w0.AuxInt != j-16 {
 16669				break
 16670			}
 16671			if w != w0.Args[0] {
 16672				break
 16673			}
 16674			if !(x.Uses == 1 && clobber(x)) {
 16675				break
 16676			}
 16677			v.reset(OpS390XMOVWBRstoreidx)
 16678			v.AuxInt = i - 2
 16679			v.Aux = s
 16680			v.AddArg(p)
 16681			v.AddArg(idx)
 16682			v.AddArg(w0)
 16683			v.AddArg(mem)
 16684			return true
 16685		}
 16686		// match: (MOVHBRstoreidx [i] {s} idx p (SRDconst [j] w) x:(MOVHBRstoreidx [i-2] {s} p idx w0:(SRDconst [j-16] w) mem))
 16687		// cond: x.Uses == 1 && clobber(x)
 16688		// result: (MOVWBRstoreidx [i-2] {s} p idx w0 mem)
 16689		for {
 16690			i := v.AuxInt
 16691			s := v.Aux
 16692			_ = v.Args[3]
 16693			idx := v.Args[0]
 16694			p := v.Args[1]
 16695			v_2 := v.Args[2]
 16696			if v_2.Op != OpS390XSRDconst {
 16697				break
 16698			}
 16699			j := v_2.AuxInt
 16700			w := v_2.Args[0]
 16701			x := v.Args[3]
 16702			if x.Op != OpS390XMOVHBRstoreidx {
 16703				break
 16704			}
 16705			if x.AuxInt != i-2 {
 16706				break
 16707			}
 16708			if x.Aux != s {
 16709				break
 16710			}
 16711			mem := x.Args[3]
 16712			if p != x.Args[0] {
 16713				break
 16714			}
 16715			if idx != x.Args[1] {
 16716				break
 16717			}
 16718			w0 := x.Args[2]
 16719			if w0.Op != OpS390XSRDconst {
 16720				break
 16721			}
 16722			if w0.AuxInt != j-16 {
 16723				break
 16724			}
 16725			if w != w0.Args[0] {
 16726				break
 16727			}
 16728			if !(x.Uses == 1 && clobber(x)) {
 16729				break
 16730			}
 16731			v.reset(OpS390XMOVWBRstoreidx)
 16732			v.AuxInt = i - 2
 16733			v.Aux = s
 16734			v.AddArg(p)
 16735			v.AddArg(idx)
 16736			v.AddArg(w0)
 16737			v.AddArg(mem)
 16738			return true
 16739		}
 16740		// match: (MOVHBRstoreidx [i] {s} idx p (SRDconst [j] w) x:(MOVHBRstoreidx [i-2] {s} idx p w0:(SRDconst [j-16] w) mem))
 16741		// cond: x.Uses == 1 && clobber(x)
 16742		// result: (MOVWBRstoreidx [i-2] {s} p idx w0 mem)
 16743		for {
 16744			i := v.AuxInt
 16745			s := v.Aux
 16746			_ = v.Args[3]
 16747			idx := v.Args[0]
 16748			p := v.Args[1]
 16749			v_2 := v.Args[2]
 16750			if v_2.Op != OpS390XSRDconst {
 16751				break
 16752			}
 16753			j := v_2.AuxInt
 16754			w := v_2.Args[0]
 16755			x := v.Args[3]
 16756			if x.Op != OpS390XMOVHBRstoreidx {
 16757				break
 16758			}
 16759			if x.AuxInt != i-2 {
 16760				break
 16761			}
 16762			if x.Aux != s {
 16763				break
 16764			}
 16765			mem := x.Args[3]
 16766			if idx != x.Args[0] {
 16767				break
 16768			}
 16769			if p != x.Args[1] {
 16770				break
 16771			}
 16772			w0 := x.Args[2]
 16773			if w0.Op != OpS390XSRDconst {
 16774				break
 16775			}
 16776			if w0.AuxInt != j-16 {
 16777				break
 16778			}
 16779			if w != w0.Args[0] {
 16780				break
 16781			}
 16782			if !(x.Uses == 1 && clobber(x)) {
 16783				break
 16784			}
 16785			v.reset(OpS390XMOVWBRstoreidx)
 16786			v.AuxInt = i - 2
 16787			v.Aux = s
 16788			v.AddArg(p)
 16789			v.AddArg(idx)
 16790			v.AddArg(w0)
 16791			v.AddArg(mem)
 16792			return true
 16793		}
 16794		// match: (MOVHBRstoreidx [i] {s} p idx (SRWconst [16] w) x:(MOVHBRstoreidx [i-2] {s} p idx w mem))
 16795		// cond: x.Uses == 1 && clobber(x)
 16796		// result: (MOVWBRstoreidx [i-2] {s} p idx w mem)
 16797		for {
 16798			i := v.AuxInt
 16799			s := v.Aux
 16800			_ = v.Args[3]
 16801			p := v.Args[0]
 16802			idx := v.Args[1]
 16803			v_2 := v.Args[2]
 16804			if v_2.Op != OpS390XSRWconst {
 16805				break
 16806			}
 16807			if v_2.AuxInt != 16 {
 16808				break
 16809			}
 16810			w := v_2.Args[0]
 16811			x := v.Args[3]
 16812			if x.Op != OpS390XMOVHBRstoreidx {
 16813				break
 16814			}
 16815			if x.AuxInt != i-2 {
 16816				break
 16817			}
 16818			if x.Aux != s {
 16819				break
 16820			}
 16821			mem := x.Args[3]
 16822			if p != x.Args[0] {
 16823				break
 16824			}
 16825			if idx != x.Args[1] {
 16826				break
 16827			}
 16828			if w != x.Args[2] {
 16829				break
 16830			}
 16831			if !(x.Uses == 1 && clobber(x)) {
 16832				break
 16833			}
 16834			v.reset(OpS390XMOVWBRstoreidx)
 16835			v.AuxInt = i - 2
 16836			v.Aux = s
 16837			v.AddArg(p)
 16838			v.AddArg(idx)
 16839			v.AddArg(w)
 16840			v.AddArg(mem)
 16841			return true
 16842		}
 16843		// match: (MOVHBRstoreidx [i] {s} p idx (SRWconst [16] w) x:(MOVHBRstoreidx [i-2] {s} idx p w mem))
 16844		// cond: x.Uses == 1 && clobber(x)
 16845		// result: (MOVWBRstoreidx [i-2] {s} p idx w mem)
 16846		for {
 16847			i := v.AuxInt
 16848			s := v.Aux
 16849			_ = v.Args[3]
 16850			p := v.Args[0]
 16851			idx := v.Args[1]
 16852			v_2 := v.Args[2]
 16853			if v_2.Op != OpS390XSRWconst {
 16854				break
 16855			}
 16856			if v_2.AuxInt != 16 {
 16857				break
 16858			}
 16859			w := v_2.Args[0]
 16860			x := v.Args[3]
 16861			if x.Op != OpS390XMOVHBRstoreidx {
 16862				break
 16863			}
 16864			if x.AuxInt != i-2 {
 16865				break
 16866			}
 16867			if x.Aux != s {
 16868				break
 16869			}
 16870			mem := x.Args[3]
 16871			if idx != x.Args[0] {
 16872				break
 16873			}
 16874			if p != x.Args[1] {
 16875				break
 16876			}
 16877			if w != x.Args[2] {
 16878				break
 16879			}
 16880			if !(x.Uses == 1 && clobber(x)) {
 16881				break
 16882			}
 16883			v.reset(OpS390XMOVWBRstoreidx)
 16884			v.AuxInt = i - 2
 16885			v.Aux = s
 16886			v.AddArg(p)
 16887			v.AddArg(idx)
 16888			v.AddArg(w)
 16889			v.AddArg(mem)
 16890			return true
 16891		}
 16892		return false
 16893	}
 16894	func rewriteValueS390X_OpS390XMOVHBRstoreidx_10(v *Value) bool {
 16895		// match: (MOVHBRstoreidx [i] {s} idx p (SRWconst [16] w) x:(MOVHBRstoreidx [i-2] {s} p idx w mem))
 16896		// cond: x.Uses == 1 && clobber(x)
 16897		// result: (MOVWBRstoreidx [i-2] {s} p idx w mem)
 16898		for {
 16899			i := v.AuxInt
 16900			s := v.Aux
 16901			_ = v.Args[3]
 16902			idx := v.Args[0]
 16903			p := v.Args[1]
 16904			v_2 := v.Args[2]
 16905			if v_2.Op != OpS390XSRWconst {
 16906				break
 16907			}
 16908			if v_2.AuxInt != 16 {
 16909				break
 16910			}
 16911			w := v_2.Args[0]
 16912			x := v.Args[3]
 16913			if x.Op != OpS390XMOVHBRstoreidx {
 16914				break
 16915			}
 16916			if x.AuxInt != i-2 {
 16917				break
 16918			}
 16919			if x.Aux != s {
 16920				break
 16921			}
 16922			mem := x.Args[3]
 16923			if p != x.Args[0] {
 16924				break
 16925			}
 16926			if idx != x.Args[1] {
 16927				break
 16928			}
 16929			if w != x.Args[2] {
 16930				break
 16931			}
 16932			if !(x.Uses == 1 && clobber(x)) {
 16933				break
 16934			}
 16935			v.reset(OpS390XMOVWBRstoreidx)
 16936			v.AuxInt = i - 2
 16937			v.Aux = s
 16938			v.AddArg(p)
 16939			v.AddArg(idx)
 16940			v.AddArg(w)
 16941			v.AddArg(mem)
 16942			return true
 16943		}
 16944		// match: (MOVHBRstoreidx [i] {s} idx p (SRWconst [16] w) x:(MOVHBRstoreidx [i-2] {s} idx p w mem))
 16945		// cond: x.Uses == 1 && clobber(x)
 16946		// result: (MOVWBRstoreidx [i-2] {s} p idx w mem)
 16947		for {
 16948			i := v.AuxInt
 16949			s := v.Aux
 16950			_ = v.Args[3]
 16951			idx := v.Args[0]
 16952			p := v.Args[1]
 16953			v_2 := v.Args[2]
 16954			if v_2.Op != OpS390XSRWconst {
 16955				break
 16956			}
 16957			if v_2.AuxInt != 16 {
 16958				break
 16959			}
 16960			w := v_2.Args[0]
 16961			x := v.Args[3]
 16962			if x.Op != OpS390XMOVHBRstoreidx {
 16963				break
 16964			}
 16965			if x.AuxInt != i-2 {
 16966				break
 16967			}
 16968			if x.Aux != s {
 16969				break
 16970			}
 16971			mem := x.Args[3]
 16972			if idx != x.Args[0] {
 16973				break
 16974			}
 16975			if p != x.Args[1] {
 16976				break
 16977			}
 16978			if w != x.Args[2] {
 16979				break
 16980			}
 16981			if !(x.Uses == 1 && clobber(x)) {
 16982				break
 16983			}
 16984			v.reset(OpS390XMOVWBRstoreidx)
 16985			v.AuxInt = i - 2
 16986			v.Aux = s
 16987			v.AddArg(p)
 16988			v.AddArg(idx)
 16989			v.AddArg(w)
 16990			v.AddArg(mem)
 16991			return true
 16992		}
 16993		// match: (MOVHBRstoreidx [i] {s} p idx (SRWconst [j] w) x:(MOVHBRstoreidx [i-2] {s} p idx w0:(SRWconst [j-16] w) mem))
 16994		// cond: x.Uses == 1 && clobber(x)
 16995		// result: (MOVWBRstoreidx [i-2] {s} p idx w0 mem)
 16996		for {
 16997			i := v.AuxInt
 16998			s := v.Aux
 16999			_ = v.Args[3]
 17000			p := v.Args[0]
 17001			idx := v.Args[1]
 17002			v_2 := v.Args[2]
 17003			if v_2.Op != OpS390XSRWconst {
 17004				break
 17005			}
 17006			j := v_2.AuxInt
 17007			w := v_2.Args[0]
 17008			x := v.Args[3]
 17009			if x.Op != OpS390XMOVHBRstoreidx {
 17010				break
 17011			}
 17012			if x.AuxInt != i-2 {
 17013				break
 17014			}
 17015			if x.Aux != s {
 17016				break
 17017			}
 17018			mem := x.Args[3]
 17019			if p != x.Args[0] {
 17020				break
 17021			}
 17022			if idx != x.Args[1] {
 17023				break
 17024			}
 17025			w0 := x.Args[2]
 17026			if w0.Op != OpS390XSRWconst {
 17027				break
 17028			}
 17029			if w0.AuxInt != j-16 {
 17030				break
 17031			}
 17032			if w != w0.Args[0] {
 17033				break
 17034			}
 17035			if !(x.Uses == 1 && clobber(x)) {
 17036				break
 17037			}
 17038			v.reset(OpS390XMOVWBRstoreidx)
 17039			v.AuxInt = i - 2
 17040			v.Aux = s
 17041			v.AddArg(p)
 17042			v.AddArg(idx)
 17043			v.AddArg(w0)
 17044			v.AddArg(mem)
 17045			return true
 17046		}
 17047		// match: (MOVHBRstoreidx [i] {s} p idx (SRWconst [j] w) x:(MOVHBRstoreidx [i-2] {s} idx p w0:(SRWconst [j-16] w) mem))
 17048		// cond: x.Uses == 1 && clobber(x)
 17049		// result: (MOVWBRstoreidx [i-2] {s} p idx w0 mem)
 17050		for {
 17051			i := v.AuxInt
 17052			s := v.Aux
 17053			_ = v.Args[3]
 17054			p := v.Args[0]
 17055			idx := v.Args[1]
 17056			v_2 := v.Args[2]
 17057			if v_2.Op != OpS390XSRWconst {
 17058				break
 17059			}
 17060			j := v_2.AuxInt
 17061			w := v_2.Args[0]
 17062			x := v.Args[3]
 17063			if x.Op != OpS390XMOVHBRstoreidx {
 17064				break
 17065			}
 17066			if x.AuxInt != i-2 {
 17067				break
 17068			}
 17069			if x.Aux != s {
 17070				break
 17071			}
 17072			mem := x.Args[3]
 17073			if idx != x.Args[0] {
 17074				break
 17075			}
 17076			if p != x.Args[1] {
 17077				break
 17078			}
 17079			w0 := x.Args[2]
 17080			if w0.Op != OpS390XSRWconst {
 17081				break
 17082			}
 17083			if w0.AuxInt != j-16 {
 17084				break
 17085			}
 17086			if w != w0.Args[0] {
 17087				break
 17088			}
 17089			if !(x.Uses == 1 && clobber(x)) {
 17090				break
 17091			}
 17092			v.reset(OpS390XMOVWBRstoreidx)
 17093			v.AuxInt = i - 2
 17094			v.Aux = s
 17095			v.AddArg(p)
 17096			v.AddArg(idx)
 17097			v.AddArg(w0)
 17098			v.AddArg(mem)
 17099			return true
 17100		}
 17101		// match: (MOVHBRstoreidx [i] {s} idx p (SRWconst [j] w) x:(MOVHBRstoreidx [i-2] {s} p idx w0:(SRWconst [j-16] w) mem))
 17102		// cond: x.Uses == 1 && clobber(x)
 17103		// result: (MOVWBRstoreidx [i-2] {s} p idx w0 mem)
 17104		for {
 17105			i := v.AuxInt
 17106			s := v.Aux
 17107			_ = v.Args[3]
 17108			idx := v.Args[0]
 17109			p := v.Args[1]
 17110			v_2 := v.Args[2]
 17111			if v_2.Op != OpS390XSRWconst {
 17112				break
 17113			}
 17114			j := v_2.AuxInt
 17115			w := v_2.Args[0]
 17116			x := v.Args[3]
 17117			if x.Op != OpS390XMOVHBRstoreidx {
 17118				break
 17119			}
 17120			if x.AuxInt != i-2 {
 17121				break
 17122			}
 17123			if x.Aux != s {
 17124				break
 17125			}
 17126			mem := x.Args[3]
 17127			if p != x.Args[0] {
 17128				break
 17129			}
 17130			if idx != x.Args[1] {
 17131				break
 17132			}
 17133			w0 := x.Args[2]
 17134			if w0.Op != OpS390XSRWconst {
 17135				break
 17136			}
 17137			if w0.AuxInt != j-16 {
 17138				break
 17139			}
 17140			if w != w0.Args[0] {
 17141				break
 17142			}
 17143			if !(x.Uses == 1 && clobber(x)) {
 17144				break
 17145			}
 17146			v.reset(OpS390XMOVWBRstoreidx)
 17147			v.AuxInt = i - 2
 17148			v.Aux = s
 17149			v.AddArg(p)
 17150			v.AddArg(idx)
 17151			v.AddArg(w0)
 17152			v.AddArg(mem)
 17153			return true
 17154		}
 17155		// match: (MOVHBRstoreidx [i] {s} idx p (SRWconst [j] w) x:(MOVHBRstoreidx [i-2] {s} idx p w0:(SRWconst [j-16] w) mem))
 17156		// cond: x.Uses == 1 && clobber(x)
 17157		// result: (MOVWBRstoreidx [i-2] {s} p idx w0 mem)
 17158		for {
 17159			i := v.AuxInt
 17160			s := v.Aux
 17161			_ = v.Args[3]
 17162			idx := v.Args[0]
 17163			p := v.Args[1]
 17164			v_2 := v.Args[2]
 17165			if v_2.Op != OpS390XSRWconst {
 17166				break
 17167			}
 17168			j := v_2.AuxInt
 17169			w := v_2.Args[0]
 17170			x := v.Args[3]
 17171			if x.Op != OpS390XMOVHBRstoreidx {
 17172				break
 17173			}
 17174			if x.AuxInt != i-2 {
 17175				break
 17176			}
 17177			if x.Aux != s {
 17178				break
 17179			}
 17180			mem := x.Args[3]
 17181			if idx != x.Args[0] {
 17182				break
 17183			}
 17184			if p != x.Args[1] {
 17185				break
 17186			}
 17187			w0 := x.Args[2]
 17188			if w0.Op != OpS390XSRWconst {
 17189				break
 17190			}
 17191			if w0.AuxInt != j-16 {
 17192				break
 17193			}
 17194			if w != w0.Args[0] {
 17195				break
 17196			}
 17197			if !(x.Uses == 1 && clobber(x)) {
 17198				break
 17199			}
 17200			v.reset(OpS390XMOVWBRstoreidx)
 17201			v.AuxInt = i - 2
 17202			v.Aux = s
 17203			v.AddArg(p)
 17204			v.AddArg(idx)
 17205			v.AddArg(w0)
 17206			v.AddArg(mem)
 17207			return true
 17208		}
 17209		return false
 17210	}
 17211	func rewriteValueS390X_OpS390XMOVHZload_0(v *Value) bool {
 17212		// match: (MOVHZload [off] {sym} ptr1 (MOVHstore [off] {sym} ptr2 x _))
 17213		// cond: isSamePtr(ptr1, ptr2)
 17214		// result: (MOVHZreg x)
 17215		for {
 17216			off := v.AuxInt
 17217			sym := v.Aux
 17218			_ = v.Args[1]
 17219			ptr1 := v.Args[0]
 17220			v_1 := v.Args[1]
 17221			if v_1.Op != OpS390XMOVHstore {
 17222				break
 17223			}
 17224			if v_1.AuxInt != off {
 17225				break
 17226			}
 17227			if v_1.Aux != sym {
 17228				break
 17229			}
 17230			_ = v_1.Args[2]
 17231			ptr2 := v_1.Args[0]
 17232			x := v_1.Args[1]
 17233			if !(isSamePtr(ptr1, ptr2)) {
 17234				break
 17235			}
 17236			v.reset(OpS390XMOVHZreg)
 17237			v.AddArg(x)
 17238			return true
 17239		}
 17240		// match: (MOVHZload [off1] {sym} (ADDconst [off2] ptr) mem)
 17241		// cond: is20Bit(off1+off2)
 17242		// result: (MOVHZload [off1+off2] {sym} ptr mem)
 17243		for {
 17244			off1 := v.AuxInt
 17245			sym := v.Aux
 17246			mem := v.Args[1]
 17247			v_0 := v.Args[0]
 17248			if v_0.Op != OpS390XADDconst {
 17249				break
 17250			}
 17251			off2 := v_0.AuxInt
 17252			ptr := v_0.Args[0]
 17253			if !(is20Bit(off1 + off2)) {
 17254				break
 17255			}
 17256			v.reset(OpS390XMOVHZload)
 17257			v.AuxInt = off1 + off2
 17258			v.Aux = sym
 17259			v.AddArg(ptr)
 17260			v.AddArg(mem)
 17261			return true
 17262		}
 17263		// match: (MOVHZload [off1] {sym1} (MOVDaddr <t> [off2] {sym2} base) mem)
 17264		// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || (t.IsPtr() && t.Elem().Alignment()%2 == 0 && (off1+off2)%2 == 0))
 17265		// result: (MOVHZload [off1+off2] {mergeSym(sym1,sym2)} base mem)
 17266		for {
 17267			off1 := v.AuxInt
 17268			sym1 := v.Aux
 17269			mem := v.Args[1]
 17270			v_0 := v.Args[0]
 17271			if v_0.Op != OpS390XMOVDaddr {
 17272				break
 17273			}
 17274			t := v_0.Type
 17275			off2 := v_0.AuxInt
 17276			sym2 := v_0.Aux
 17277			base := v_0.Args[0]
 17278			if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || (t.IsPtr() && t.Elem().Alignment()%2 == 0 && (off1+off2)%2 == 0))) {
 17279				break
 17280			}
 17281			v.reset(OpS390XMOVHZload)
 17282			v.AuxInt = off1 + off2
 17283			v.Aux = mergeSym(sym1, sym2)
 17284			v.AddArg(base)
 17285			v.AddArg(mem)
 17286			return true
 17287		}
 17288		// match: (MOVHZload [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) mem)
 17289		// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
 17290		// result: (MOVHZloadidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem)
 17291		for {
 17292			off1 := v.AuxInt
 17293			sym1 := v.Aux
 17294			mem := v.Args[1]
 17295			v_0 := v.Args[0]
 17296			if v_0.Op != OpS390XMOVDaddridx {
 17297				break
 17298			}
 17299			off2 := v_0.AuxInt
 17300			sym2 := v_0.Aux
 17301			idx := v_0.Args[1]
 17302			ptr := v_0.Args[0]
 17303			if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
 17304				break
 17305			}
 17306			v.reset(OpS390XMOVHZloadidx)
 17307			v.AuxInt = off1 + off2
 17308			v.Aux = mergeSym(sym1, sym2)
 17309			v.AddArg(ptr)
 17310			v.AddArg(idx)
 17311			v.AddArg(mem)
 17312			return true
 17313		}
 17314		// match: (MOVHZload [off] {sym} (ADD ptr idx) mem)
 17315		// cond: ptr.Op != OpSB
 17316		// result: (MOVHZloadidx [off] {sym} ptr idx mem)
 17317		for {
 17318			off := v.AuxInt
 17319			sym := v.Aux
 17320			mem := v.Args[1]
 17321			v_0 := v.Args[0]
 17322			if v_0.Op != OpS390XADD {
 17323				break
 17324			}
 17325			idx := v_0.Args[1]
 17326			ptr := v_0.Args[0]
 17327			if !(ptr.Op != OpSB) {
 17328				break
 17329			}
 17330			v.reset(OpS390XMOVHZloadidx)
 17331			v.AuxInt = off
 17332			v.Aux = sym
 17333			v.AddArg(ptr)
 17334			v.AddArg(idx)
 17335			v.AddArg(mem)
 17336			return true
 17337		}
 17338		return false
 17339	}
 17340	func rewriteValueS390X_OpS390XMOVHZloadidx_0(v *Value) bool {
 17341		// match: (MOVHZloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
 17342		// cond: is20Bit(c+d)
 17343		// result: (MOVHZloadidx [c+d] {sym} ptr idx mem)
 17344		for {
 17345			c := v.AuxInt
 17346			sym := v.Aux
 17347			mem := v.Args[2]
 17348			v_0 := v.Args[0]
 17349			if v_0.Op != OpS390XADDconst {
 17350				break
 17351			}
 17352			d := v_0.AuxInt
 17353			ptr := v_0.Args[0]
 17354			idx := v.Args[1]
 17355			if !(is20Bit(c + d)) {
 17356				break
 17357			}
 17358			v.reset(OpS390XMOVHZloadidx)
 17359			v.AuxInt = c + d
 17360			v.Aux = sym
 17361			v.AddArg(ptr)
 17362			v.AddArg(idx)
 17363			v.AddArg(mem)
 17364			return true
 17365		}
 17366		// match: (MOVHZloadidx [c] {sym} idx (ADDconst [d] ptr) mem)
 17367		// cond: is20Bit(c+d)
 17368		// result: (MOVHZloadidx [c+d] {sym} ptr idx mem)
 17369		for {
 17370			c := v.AuxInt
 17371			sym := v.Aux
 17372			mem := v.Args[2]
 17373			idx := v.Args[0]
 17374			v_1 := v.Args[1]
 17375			if v_1.Op != OpS390XADDconst {
 17376				break
 17377			}
 17378			d := v_1.AuxInt
 17379			ptr := v_1.Args[0]
 17380			if !(is20Bit(c + d)) {
 17381				break
 17382			}
 17383			v.reset(OpS390XMOVHZloadidx)
 17384			v.AuxInt = c + d
 17385			v.Aux = sym
 17386			v.AddArg(ptr)
 17387			v.AddArg(idx)
 17388			v.AddArg(mem)
 17389			return true
 17390		}
 17391		// match: (MOVHZloadidx [c] {sym} ptr (ADDconst [d] idx) mem)
 17392		// cond: is20Bit(c+d)
 17393		// result: (MOVHZloadidx [c+d] {sym} ptr idx mem)
 17394		for {
 17395			c := v.AuxInt
 17396			sym := v.Aux
 17397			mem := v.Args[2]
 17398			ptr := v.Args[0]
 17399			v_1 := v.Args[1]
 17400			if v_1.Op != OpS390XADDconst {
 17401				break
 17402			}
 17403			d := v_1.AuxInt
 17404			idx := v_1.Args[0]
 17405			if !(is20Bit(c + d)) {
 17406				break
 17407			}
 17408			v.reset(OpS390XMOVHZloadidx)
 17409			v.AuxInt = c + d
 17410			v.Aux = sym
 17411			v.AddArg(ptr)
 17412			v.AddArg(idx)
 17413			v.AddArg(mem)
 17414			return true
 17415		}
 17416		// match: (MOVHZloadidx [c] {sym} (ADDconst [d] idx) ptr mem)
 17417		// cond: is20Bit(c+d)
 17418		// result: (MOVHZloadidx [c+d] {sym} ptr idx mem)
 17419		for {
 17420			c := v.AuxInt
 17421			sym := v.Aux
 17422			mem := v.Args[2]
 17423			v_0 := v.Args[0]
 17424			if v_0.Op != OpS390XADDconst {
 17425				break
 17426			}
 17427			d := v_0.AuxInt
 17428			idx := v_0.Args[0]
 17429			ptr := v.Args[1]
 17430			if !(is20Bit(c + d)) {
 17431				break
 17432			}
 17433			v.reset(OpS390XMOVHZloadidx)
 17434			v.AuxInt = c + d
 17435			v.Aux = sym
 17436			v.AddArg(ptr)
 17437			v.AddArg(idx)
 17438			v.AddArg(mem)
 17439			return true
 17440		}
 17441		return false
 17442	}
 17443	func rewriteValueS390X_OpS390XMOVHZreg_0(v *Value) bool {
 17444		b := v.Block
 17445		// match: (MOVHZreg x:(MOVBZload _ _))
 17446		// cond:
 17447		// result: (MOVDreg x)
 17448		for {
 17449			x := v.Args[0]
 17450			if x.Op != OpS390XMOVBZload {
 17451				break
 17452			}
 17453			_ = x.Args[1]
 17454			v.reset(OpS390XMOVDreg)
 17455			v.AddArg(x)
 17456			return true
 17457		}
 17458		// match: (MOVHZreg x:(MOVHZload _ _))
 17459		// cond:
 17460		// result: (MOVDreg x)
 17461		for {
 17462			x := v.Args[0]
 17463			if x.Op != OpS390XMOVHZload {
 17464				break
 17465			}
 17466			_ = x.Args[1]
 17467			v.reset(OpS390XMOVDreg)
 17468			v.AddArg(x)
 17469			return true
 17470		}
 17471		// match: (MOVHZreg x:(Arg <t>))
 17472		// cond: (is8BitInt(t) || is16BitInt(t)) && !isSigned(t)
 17473		// result: (MOVDreg x)
 17474		for {
 17475			x := v.Args[0]
 17476			if x.Op != OpArg {
 17477				break
 17478			}
 17479			t := x.Type
 17480			if !((is8BitInt(t) || is16BitInt(t)) && !isSigned(t)) {
 17481				break
 17482			}
 17483			v.reset(OpS390XMOVDreg)
 17484			v.AddArg(x)
 17485			return true
 17486		}
 17487		// match: (MOVHZreg x:(MOVBZreg _))
 17488		// cond:
 17489		// result: (MOVDreg x)
 17490		for {
 17491			x := v.Args[0]
 17492			if x.Op != OpS390XMOVBZreg {
 17493				break
 17494			}
 17495			v.reset(OpS390XMOVDreg)
 17496			v.AddArg(x)
 17497			return true
 17498		}
 17499		// match: (MOVHZreg x:(MOVHZreg _))
 17500		// cond:
 17501		// result: (MOVDreg x)
 17502		for {
 17503			x := v.Args[0]
 17504			if x.Op != OpS390XMOVHZreg {
 17505				break
 17506			}
 17507			v.reset(OpS390XMOVDreg)
 17508			v.AddArg(x)
 17509			return true
 17510		}
 17511		// match: (MOVHZreg (MOVHreg x))
 17512		// cond:
 17513		// result: (MOVHZreg x)
 17514		for {
 17515			v_0 := v.Args[0]
 17516			if v_0.Op != OpS390XMOVHreg {
 17517				break
 17518			}
 17519			x := v_0.Args[0]
 17520			v.reset(OpS390XMOVHZreg)
 17521			v.AddArg(x)
 17522			return true
 17523		}
 17524		// match: (MOVHZreg (MOVDconst [c]))
 17525		// cond:
 17526		// result: (MOVDconst [int64(uint16(c))])
 17527		for {
 17528			v_0 := v.Args[0]
 17529			if v_0.Op != OpS390XMOVDconst {
 17530				break
 17531			}
 17532			c := v_0.AuxInt
 17533			v.reset(OpS390XMOVDconst)
 17534			v.AuxInt = int64(uint16(c))
 17535			return true
 17536		}
 17537		// match: (MOVHZreg x:(MOVHZload [off] {sym} ptr mem))
 17538		// cond: x.Uses == 1 && clobber(x)
 17539		// result: @x.Block (MOVHZload <v.Type> [off] {sym} ptr mem)
 17540		for {
 17541			x := v.Args[0]
 17542			if x.Op != OpS390XMOVHZload {
 17543				break
 17544			}
 17545			off := x.AuxInt
 17546			sym := x.Aux
 17547			mem := x.Args[1]
 17548			ptr := x.Args[0]
 17549			if !(x.Uses == 1 && clobber(x)) {
 17550				break
 17551			}
 17552			b = x.Block
 17553			v0 := b.NewValue0(x.Pos, OpS390XMOVHZload, v.Type)
 17554			v.reset(OpCopy)
 17555			v.AddArg(v0)
 17556			v0.AuxInt = off
 17557			v0.Aux = sym
 17558			v0.AddArg(ptr)
 17559			v0.AddArg(mem)
 17560			return true
 17561		}
 17562		// match: (MOVHZreg x:(MOVHload [off] {sym} ptr mem))
 17563		// cond: x.Uses == 1 && clobber(x)
 17564		// result: @x.Block (MOVHZload <v.Type> [off] {sym} ptr mem)
 17565		for {
 17566			x := v.Args[0]
 17567			if x.Op != OpS390XMOVHload {
 17568				break
 17569			}
 17570			off := x.AuxInt
 17571			sym := x.Aux
 17572			mem := x.Args[1]
 17573			ptr := x.Args[0]
 17574			if !(x.Uses == 1 && clobber(x)) {
 17575				break
 17576			}
 17577			b = x.Block
 17578			v0 := b.NewValue0(x.Pos, OpS390XMOVHZload, v.Type)
 17579			v.reset(OpCopy)
 17580			v.AddArg(v0)
 17581			v0.AuxInt = off
 17582			v0.Aux = sym
 17583			v0.AddArg(ptr)
 17584			v0.AddArg(mem)
 17585			return true
 17586		}
 17587		// match: (MOVHZreg x:(MOVHZloadidx [off] {sym} ptr idx mem))
 17588		// cond: x.Uses == 1 && clobber(x)
 17589		// result: @x.Block (MOVHZloadidx <v.Type> [off] {sym} ptr idx mem)
 17590		for {
 17591			x := v.Args[0]
 17592			if x.Op != OpS390XMOVHZloadidx {
 17593				break
 17594			}
 17595			off := x.AuxInt
 17596			sym := x.Aux
 17597			mem := x.Args[2]
 17598			ptr := x.Args[0]
 17599			idx := x.Args[1]
 17600			if !(x.Uses == 1 && clobber(x)) {
 17601				break
 17602			}
 17603			b = x.Block
 17604			v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, v.Type)
 17605			v.reset(OpCopy)
 17606			v.AddArg(v0)
 17607			v0.AuxInt = off
 17608			v0.Aux = sym
 17609			v0.AddArg(ptr)
 17610			v0.AddArg(idx)
 17611			v0.AddArg(mem)
 17612			return true
 17613		}
 17614		return false
 17615	}
 17616	func rewriteValueS390X_OpS390XMOVHZreg_10(v *Value) bool {
 17617		b := v.Block
 17618		typ := &b.Func.Config.Types
 17619		// match: (MOVHZreg x:(MOVHloadidx [off] {sym} ptr idx mem))
 17620		// cond: x.Uses == 1 && clobber(x)
 17621		// result: @x.Block (MOVHZloadidx <v.Type> [off] {sym} ptr idx mem)
 17622		for {
 17623			x := v.Args[0]
 17624			if x.Op != OpS390XMOVHloadidx {
 17625				break
 17626			}
 17627			off := x.AuxInt
 17628			sym := x.Aux
 17629			mem := x.Args[2]
 17630			ptr := x.Args[0]
 17631			idx := x.Args[1]
 17632			if !(x.Uses == 1 && clobber(x)) {
 17633				break
 17634			}
 17635			b = x.Block
 17636			v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, v.Type)
 17637			v.reset(OpCopy)
 17638			v.AddArg(v0)
 17639			v0.AuxInt = off
 17640			v0.Aux = sym
 17641			v0.AddArg(ptr)
 17642			v0.AddArg(idx)
 17643			v0.AddArg(mem)
 17644			return true
 17645		}
 17646		// match: (MOVHZreg (ANDWconst [m] x))
 17647		// cond:
 17648		// result: (MOVWZreg (ANDWconst <typ.UInt32> [int64(uint16(m))] x))
 17649		for {
 17650			v_0 := v.Args[0]
 17651			if v_0.Op != OpS390XANDWconst {
 17652				break
 17653			}
 17654			m := v_0.AuxInt
 17655			x := v_0.Args[0]
 17656			v.reset(OpS390XMOVWZreg)
 17657			v0 := b.NewValue0(v.Pos, OpS390XANDWconst, typ.UInt32)
 17658			v0.AuxInt = int64(uint16(m))
 17659			v0.AddArg(x)
 17660			v.AddArg(v0)
 17661			return true
 17662		}
 17663		return false
 17664	}
 17665	func rewriteValueS390X_OpS390XMOVHload_0(v *Value) bool {
 17666		// match: (MOVHload [off] {sym} ptr1 (MOVHstore [off] {sym} ptr2 x _))
 17667		// cond: isSamePtr(ptr1, ptr2)
 17668		// result: (MOVHreg x)
 17669		for {
 17670			off := v.AuxInt
 17671			sym := v.Aux
 17672			_ = v.Args[1]
 17673			ptr1 := v.Args[0]
 17674			v_1 := v.Args[1]
 17675			if v_1.Op != OpS390XMOVHstore {
 17676				break
 17677			}
 17678			if v_1.AuxInt != off {
 17679				break
 17680			}
 17681			if v_1.Aux != sym {
 17682				break
 17683			}
 17684			_ = v_1.Args[2]
 17685			ptr2 := v_1.Args[0]
 17686			x := v_1.Args[1]
 17687			if !(isSamePtr(ptr1, ptr2)) {
 17688				break
 17689			}
 17690			v.reset(OpS390XMOVHreg)
 17691			v.AddArg(x)
 17692			return true
 17693		}
 17694		// match: (MOVHload [off1] {sym} (ADDconst [off2] ptr) mem)
 17695		// cond: is20Bit(off1+off2)
 17696		// result: (MOVHload [off1+off2] {sym} ptr mem)
 17697		for {
 17698			off1 := v.AuxInt
 17699			sym := v.Aux
 17700			mem := v.Args[1]
 17701			v_0 := v.Args[0]
 17702			if v_0.Op != OpS390XADDconst {
 17703				break
 17704			}
 17705			off2 := v_0.AuxInt
 17706			ptr := v_0.Args[0]
 17707			if !(is20Bit(off1 + off2)) {
 17708				break
 17709			}
 17710			v.reset(OpS390XMOVHload)
 17711			v.AuxInt = off1 + off2
 17712			v.Aux = sym
 17713			v.AddArg(ptr)
 17714			v.AddArg(mem)
 17715			return true
 17716		}
 17717		// match: (MOVHload [off1] {sym1} (MOVDaddr <t> [off2] {sym2} base) mem)
 17718		// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || (t.IsPtr() && t.Elem().Alignment()%2 == 0 && (off1+off2)%2 == 0))
 17719		// result: (MOVHload [off1+off2] {mergeSym(sym1,sym2)} base mem)
 17720		for {
 17721			off1 := v.AuxInt
 17722			sym1 := v.Aux
 17723			mem := v.Args[1]
 17724			v_0 := v.Args[0]
 17725			if v_0.Op != OpS390XMOVDaddr {
 17726				break
 17727			}
 17728			t := v_0.Type
 17729			off2 := v_0.AuxInt
 17730			sym2 := v_0.Aux
 17731			base := v_0.Args[0]
 17732			if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || (t.IsPtr() && t.Elem().Alignment()%2 == 0 && (off1+off2)%2 == 0))) {
 17733				break
 17734			}
 17735			v.reset(OpS390XMOVHload)
 17736			v.AuxInt = off1 + off2
 17737			v.Aux = mergeSym(sym1, sym2)
 17738			v.AddArg(base)
 17739			v.AddArg(mem)
 17740			return true
 17741		}
 17742		// match: (MOVHload [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) mem)
 17743		// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
 17744		// result: (MOVHloadidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem)
 17745		for {
 17746			off1 := v.AuxInt
 17747			sym1 := v.Aux
 17748			mem := v.Args[1]
 17749			v_0 := v.Args[0]
 17750			if v_0.Op != OpS390XMOVDaddridx {
 17751				break
 17752			}
 17753			off2 := v_0.AuxInt
 17754			sym2 := v_0.Aux
 17755			idx := v_0.Args[1]
 17756			ptr := v_0.Args[0]
 17757			if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
 17758				break
 17759			}
 17760			v.reset(OpS390XMOVHloadidx)
 17761			v.AuxInt = off1 + off2
 17762			v.Aux = mergeSym(sym1, sym2)
 17763			v.AddArg(ptr)
 17764			v.AddArg(idx)
 17765			v.AddArg(mem)
 17766			return true
 17767		}
 17768		// match: (MOVHload [off] {sym} (ADD ptr idx) mem)
 17769		// cond: ptr.Op != OpSB
 17770		// result: (MOVHloadidx [off] {sym} ptr idx mem)
 17771		for {
 17772			off := v.AuxInt
 17773			sym := v.Aux
 17774			mem := v.Args[1]
 17775			v_0 := v.Args[0]
 17776			if v_0.Op != OpS390XADD {
 17777				break
 17778			}
 17779			idx := v_0.Args[1]
 17780			ptr := v_0.Args[0]
 17781			if !(ptr.Op != OpSB) {
 17782				break
 17783			}
 17784			v.reset(OpS390XMOVHloadidx)
 17785			v.AuxInt = off
 17786			v.Aux = sym
 17787			v.AddArg(ptr)
 17788			v.AddArg(idx)
 17789			v.AddArg(mem)
 17790			return true
 17791		}
 17792		return false
 17793	}
 17794	func rewriteValueS390X_OpS390XMOVHloadidx_0(v *Value) bool {
 17795		// match: (MOVHloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
 17796		// cond: is20Bit(c+d)
 17797		// result: (MOVHloadidx [c+d] {sym} ptr idx mem)
 17798		for {
 17799			c := v.AuxInt
 17800			sym := v.Aux
 17801			mem := v.Args[2]
 17802			v_0 := v.Args[0]
 17803			if v_0.Op != OpS390XADDconst {
 17804				break
 17805			}
 17806			d := v_0.AuxInt
 17807			ptr := v_0.Args[0]
 17808			idx := v.Args[1]
 17809			if !(is20Bit(c + d)) {
 17810				break
 17811			}
 17812			v.reset(OpS390XMOVHloadidx)
 17813			v.AuxInt = c + d
 17814			v.Aux = sym
 17815			v.AddArg(ptr)
 17816			v.AddArg(idx)
 17817			v.AddArg(mem)
 17818			return true
 17819		}
 17820		// match: (MOVHloadidx [c] {sym} idx (ADDconst [d] ptr) mem)
 17821		// cond: is20Bit(c+d)
 17822		// result: (MOVHloadidx [c+d] {sym} ptr idx mem)
 17823		for {
 17824			c := v.AuxInt
 17825			sym := v.Aux
 17826			mem := v.Args[2]
 17827			idx := v.Args[0]
 17828			v_1 := v.Args[1]
 17829			if v_1.Op != OpS390XADDconst {
 17830				break
 17831			}
 17832			d := v_1.AuxInt
 17833			ptr := v_1.Args[0]
 17834			if !(is20Bit(c + d)) {
 17835				break
 17836			}
 17837			v.reset(OpS390XMOVHloadidx)
 17838			v.AuxInt = c + d
 17839			v.Aux = sym
 17840			v.AddArg(ptr)
 17841			v.AddArg(idx)
 17842			v.AddArg(mem)
 17843			return true
 17844		}
 17845		// match: (MOVHloadidx [c] {sym} ptr (ADDconst [d] idx) mem)
 17846		// cond: is20Bit(c+d)
 17847		// result: (MOVHloadidx [c+d] {sym} ptr idx mem)
 17848		for {
 17849			c := v.AuxInt
 17850			sym := v.Aux
 17851			mem := v.Args[2]
 17852			ptr := v.Args[0]
 17853			v_1 := v.Args[1]
 17854			if v_1.Op != OpS390XADDconst {
 17855				break
 17856			}
 17857			d := v_1.AuxInt
 17858			idx := v_1.Args[0]
 17859			if !(is20Bit(c + d)) {
 17860				break
 17861			}
 17862			v.reset(OpS390XMOVHloadidx)
 17863			v.AuxInt = c + d
 17864			v.Aux = sym
 17865			v.AddArg(ptr)
 17866			v.AddArg(idx)
 17867			v.AddArg(mem)
 17868			return true
 17869		}
 17870		// match: (MOVHloadidx [c] {sym} (ADDconst [d] idx) ptr mem)
 17871		// cond: is20Bit(c+d)
 17872		// result: (MOVHloadidx [c+d] {sym} ptr idx mem)
 17873		for {
 17874			c := v.AuxInt
 17875			sym := v.Aux
 17876			mem := v.Args[2]
 17877			v_0 := v.Args[0]
 17878			if v_0.Op != OpS390XADDconst {
 17879				break
 17880			}
 17881			d := v_0.AuxInt
 17882			idx := v_0.Args[0]
 17883			ptr := v.Args[1]
 17884			if !(is20Bit(c + d)) {
 17885				break
 17886			}
 17887			v.reset(OpS390XMOVHloadidx)
 17888			v.AuxInt = c + d
 17889			v.Aux = sym
 17890			v.AddArg(ptr)
 17891			v.AddArg(idx)
 17892			v.AddArg(mem)
 17893			return true
 17894		}
 17895		return false
 17896	}
 17897	func rewriteValueS390X_OpS390XMOVHreg_0(v *Value) bool {
 17898		b := v.Block
 17899		// match: (MOVHreg x:(MOVBload _ _))
 17900		// cond:
 17901		// result: (MOVDreg x)
 17902		for {
 17903			x := v.Args[0]
 17904			if x.Op != OpS390XMOVBload {
 17905				break
 17906			}
 17907			_ = x.Args[1]
 17908			v.reset(OpS390XMOVDreg)
 17909			v.AddArg(x)
 17910			return true
 17911		}
 17912		// match: (MOVHreg x:(MOVBZload _ _))
 17913		// cond:
 17914		// result: (MOVDreg x)
 17915		for {
 17916			x := v.Args[0]
 17917			if x.Op != OpS390XMOVBZload {
 17918				break
 17919			}
 17920			_ = x.Args[1]
 17921			v.reset(OpS390XMOVDreg)
 17922			v.AddArg(x)
 17923			return true
 17924		}
 17925		// match: (MOVHreg x:(MOVHload _ _))
 17926		// cond:
 17927		// result: (MOVDreg x)
 17928		for {
 17929			x := v.Args[0]
 17930			if x.Op != OpS390XMOVHload {
 17931				break
 17932			}
 17933			_ = x.Args[1]
 17934			v.reset(OpS390XMOVDreg)
 17935			v.AddArg(x)
 17936			return true
 17937		}
 17938		// match: (MOVHreg x:(Arg <t>))
 17939		// cond: (is8BitInt(t) || is16BitInt(t)) && isSigned(t)
 17940		// result: (MOVDreg x)
 17941		for {
 17942			x := v.Args[0]
 17943			if x.Op != OpArg {
 17944				break
 17945			}
 17946			t := x.Type
 17947			if !((is8BitInt(t) || is16BitInt(t)) && isSigned(t)) {
 17948				break
 17949			}
 17950			v.reset(OpS390XMOVDreg)
 17951			v.AddArg(x)
 17952			return true
 17953		}
 17954		// match: (MOVHreg x:(MOVBreg _))
 17955		// cond:
 17956		// result: (MOVDreg x)
 17957		for {
 17958			x := v.Args[0]
 17959			if x.Op != OpS390XMOVBreg {
 17960				break
 17961			}
 17962			v.reset(OpS390XMOVDreg)
 17963			v.AddArg(x)
 17964			return true
 17965		}
 17966		// match: (MOVHreg x:(MOVBZreg _))
 17967		// cond:
 17968		// result: (MOVDreg x)
 17969		for {
 17970			x := v.Args[0]
 17971			if x.Op != OpS390XMOVBZreg {
 17972				break
 17973			}
 17974			v.reset(OpS390XMOVDreg)
 17975			v.AddArg(x)
 17976			return true
 17977		}
 17978		// match: (MOVHreg x:(MOVHreg _))
 17979		// cond:
 17980		// result: (MOVDreg x)
 17981		for {
 17982			x := v.Args[0]
 17983			if x.Op != OpS390XMOVHreg {
 17984				break
 17985			}
 17986			v.reset(OpS390XMOVDreg)
 17987			v.AddArg(x)
 17988			return true
 17989		}
 17990		// match: (MOVHreg (MOVHZreg x))
 17991		// cond:
 17992		// result: (MOVHreg x)
 17993		for {
 17994			v_0 := v.Args[0]
 17995			if v_0.Op != OpS390XMOVHZreg {
 17996				break
 17997			}
 17998			x := v_0.Args[0]
 17999			v.reset(OpS390XMOVHreg)
 18000			v.AddArg(x)
 18001			return true
 18002		}
 18003		// match: (MOVHreg (MOVDconst [c]))
 18004		// cond:
 18005		// result: (MOVDconst [int64(int16(c))])
 18006		for {
 18007			v_0 := v.Args[0]
 18008			if v_0.Op != OpS390XMOVDconst {
 18009				break
 18010			}
 18011			c := v_0.AuxInt
 18012			v.reset(OpS390XMOVDconst)
 18013			v.AuxInt = int64(int16(c))
 18014			return true
 18015		}
 18016		// match: (MOVHreg x:(MOVHZload [off] {sym} ptr mem))
 18017		// cond: x.Uses == 1 && clobber(x)
 18018		// result: @x.Block (MOVHload <v.Type> [off] {sym} ptr mem)
 18019		for {
 18020			x := v.Args[0]
 18021			if x.Op != OpS390XMOVHZload {
 18022				break
 18023			}
 18024			off := x.AuxInt
 18025			sym := x.Aux
 18026			mem := x.Args[1]
 18027			ptr := x.Args[0]
 18028			if !(x.Uses == 1 && clobber(x)) {
 18029				break
 18030			}
 18031			b = x.Block
 18032			v0 := b.NewValue0(x.Pos, OpS390XMOVHload, v.Type)
 18033			v.reset(OpCopy)
 18034			v.AddArg(v0)
 18035			v0.AuxInt = off
 18036			v0.Aux = sym
 18037			v0.AddArg(ptr)
 18038			v0.AddArg(mem)
 18039			return true
 18040		}
 18041		return false
 18042	}
 18043	func rewriteValueS390X_OpS390XMOVHreg_10(v *Value) bool {
 18044		b := v.Block
 18045		typ := &b.Func.Config.Types
 18046		// match: (MOVHreg x:(MOVHload [off] {sym} ptr mem))
 18047		// cond: x.Uses == 1 && clobber(x)
 18048		// result: @x.Block (MOVHload <v.Type> [off] {sym} ptr mem)
 18049		for {
 18050			x := v.Args[0]
 18051			if x.Op != OpS390XMOVHload {
 18052				break
 18053			}
 18054			off := x.AuxInt
 18055			sym := x.Aux
 18056			mem := x.Args[1]
 18057			ptr := x.Args[0]
 18058			if !(x.Uses == 1 && clobber(x)) {
 18059				break
 18060			}
 18061			b = x.Block
 18062			v0 := b.NewValue0(x.Pos, OpS390XMOVHload, v.Type)
 18063			v.reset(OpCopy)
 18064			v.AddArg(v0)
 18065			v0.AuxInt = off
 18066			v0.Aux = sym
 18067			v0.AddArg(ptr)
 18068			v0.AddArg(mem)
 18069			return true
 18070		}
 18071		// match: (MOVHreg x:(MOVHZloadidx [off] {sym} ptr idx mem))
 18072		// cond: x.Uses == 1 && clobber(x)
 18073		// result: @x.Block (MOVHloadidx <v.Type> [off] {sym} ptr idx mem)
 18074		for {
 18075			x := v.Args[0]
 18076			if x.Op != OpS390XMOVHZloadidx {
 18077				break
 18078			}
 18079			off := x.AuxInt
 18080			sym := x.Aux
 18081			mem := x.Args[2]
 18082			ptr := x.Args[0]
 18083			idx := x.Args[1]
 18084			if !(x.Uses == 1 && clobber(x)) {
 18085				break
 18086			}
 18087			b = x.Block
 18088			v0 := b.NewValue0(v.Pos, OpS390XMOVHloadidx, v.Type)
 18089			v.reset(OpCopy)
 18090			v.AddArg(v0)
 18091			v0.AuxInt = off
 18092			v0.Aux = sym
 18093			v0.AddArg(ptr)
 18094			v0.AddArg(idx)
 18095			v0.AddArg(mem)
 18096			return true
 18097		}
 18098		// match: (MOVHreg x:(MOVHloadidx [off] {sym} ptr idx mem))
 18099		// cond: x.Uses == 1 && clobber(x)
 18100		// result: @x.Block (MOVHloadidx <v.Type> [off] {sym} ptr idx mem)
 18101		for {
 18102			x := v.Args[0]
 18103			if x.Op != OpS390XMOVHloadidx {
 18104				break
 18105			}
 18106			off := x.AuxInt
 18107			sym := x.Aux
 18108			mem := x.Args[2]
 18109			ptr := x.Args[0]
 18110			idx := x.Args[1]
 18111			if !(x.Uses == 1 && clobber(x)) {
 18112				break
 18113			}
 18114			b = x.Block
 18115			v0 := b.NewValue0(v.Pos, OpS390XMOVHloadidx, v.Type)
 18116			v.reset(OpCopy)
 18117			v.AddArg(v0)
 18118			v0.AuxInt = off
 18119			v0.Aux = sym
 18120			v0.AddArg(ptr)
 18121			v0.AddArg(idx)
 18122			v0.AddArg(mem)
 18123			return true
 18124		}
 18125		// match: (MOVHreg (ANDWconst [m] x))
 18126		// cond: int16(m) >= 0
 18127		// result: (MOVWZreg (ANDWconst <typ.UInt32> [int64(uint16(m))] x))
 18128		for {
 18129			v_0 := v.Args[0]
 18130			if v_0.Op != OpS390XANDWconst {
 18131				break
 18132			}
 18133			m := v_0.AuxInt
 18134			x := v_0.Args[0]
 18135			if !(int16(m) >= 0) {
 18136				break
 18137			}
 18138			v.reset(OpS390XMOVWZreg)
 18139			v0 := b.NewValue0(v.Pos, OpS390XANDWconst, typ.UInt32)
 18140			v0.AuxInt = int64(uint16(m))
 18141			v0.AddArg(x)
 18142			v.AddArg(v0)
 18143			return true
 18144		}
 18145		return false
 18146	}
 18147	func rewriteValueS390X_OpS390XMOVHstore_0(v *Value) bool {
 18148		// match: (MOVHstore [off] {sym} ptr (MOVHreg x) mem)
 18149		// cond:
 18150		// result: (MOVHstore [off] {sym} ptr x mem)
 18151		for {
 18152			off := v.AuxInt
 18153			sym := v.Aux
 18154			mem := v.Args[2]
 18155			ptr := v.Args[0]
 18156			v_1 := v.Args[1]
 18157			if v_1.Op != OpS390XMOVHreg {
 18158				break
 18159			}
 18160			x := v_1.Args[0]
 18161			v.reset(OpS390XMOVHstore)
 18162			v.AuxInt = off
 18163			v.Aux = sym
 18164			v.AddArg(ptr)
 18165			v.AddArg(x)
 18166			v.AddArg(mem)
 18167			return true
 18168		}
 18169		// match: (MOVHstore [off] {sym} ptr (MOVHZreg x) mem)
 18170		// cond:
 18171		// result: (MOVHstore [off] {sym} ptr x mem)
 18172		for {
 18173			off := v.AuxInt
 18174			sym := v.Aux
 18175			mem := v.Args[2]
 18176			ptr := v.Args[0]
 18177			v_1 := v.Args[1]
 18178			if v_1.Op != OpS390XMOVHZreg {
 18179				break
 18180			}
 18181			x := v_1.Args[0]
 18182			v.reset(OpS390XMOVHstore)
 18183			v.AuxInt = off
 18184			v.Aux = sym
 18185			v.AddArg(ptr)
 18186			v.AddArg(x)
 18187			v.AddArg(mem)
 18188			return true
 18189		}
 18190		// match: (MOVHstore [off1] {sym} (ADDconst [off2] ptr) val mem)
 18191		// cond: is20Bit(off1+off2)
 18192		// result: (MOVHstore [off1+off2] {sym} ptr val mem)
 18193		for {
 18194			off1 := v.AuxInt
 18195			sym := v.Aux
 18196			mem := v.Args[2]
 18197			v_0 := v.Args[0]
 18198			if v_0.Op != OpS390XADDconst {
 18199				break
 18200			}
 18201			off2 := v_0.AuxInt
 18202			ptr := v_0.Args[0]
 18203			val := v.Args[1]
 18204			if !(is20Bit(off1 + off2)) {
 18205				break
 18206			}
 18207			v.reset(OpS390XMOVHstore)
 18208			v.AuxInt = off1 + off2
 18209			v.Aux = sym
 18210			v.AddArg(ptr)
 18211			v.AddArg(val)
 18212			v.AddArg(mem)
 18213			return true
 18214		}
 18215		// match: (MOVHstore [off] {sym} ptr (MOVDconst [c]) mem)
 18216		// cond: isU12Bit(off) && ptr.Op != OpSB
 18217		// result: (MOVHstoreconst [makeValAndOff(int64(int16(c)),off)] {sym} ptr mem)
 18218		for {
 18219			off := v.AuxInt
 18220			sym := v.Aux
 18221			mem := v.Args[2]
 18222			ptr := v.Args[0]
 18223			v_1 := v.Args[1]
 18224			if v_1.Op != OpS390XMOVDconst {
 18225				break
 18226			}
 18227			c := v_1.AuxInt
 18228			if !(isU12Bit(off) && ptr.Op != OpSB) {
 18229				break
 18230			}
 18231			v.reset(OpS390XMOVHstoreconst)
 18232			v.AuxInt = makeValAndOff(int64(int16(c)), off)
 18233			v.Aux = sym
 18234			v.AddArg(ptr)
 18235			v.AddArg(mem)
 18236			return true
 18237		}
 18238		// match: (MOVHstore [off1] {sym1} (MOVDaddr <t> [off2] {sym2} base) val mem)
 18239		// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || (t.IsPtr() && t.Elem().Alignment()%2 == 0 && (off1+off2)%2 == 0))
 18240		// result: (MOVHstore [off1+off2] {mergeSym(sym1,sym2)} base val mem)
 18241		for {
 18242			off1 := v.AuxInt
 18243			sym1 := v.Aux
 18244			mem := v.Args[2]
 18245			v_0 := v.Args[0]
 18246			if v_0.Op != OpS390XMOVDaddr {
 18247				break
 18248			}
 18249			t := v_0.Type
 18250			off2 := v_0.AuxInt
 18251			sym2 := v_0.Aux
 18252			base := v_0.Args[0]
 18253			val := v.Args[1]
 18254			if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || (t.IsPtr() && t.Elem().Alignment()%2 == 0 && (off1+off2)%2 == 0))) {
 18255				break
 18256			}
 18257			v.reset(OpS390XMOVHstore)
 18258			v.AuxInt = off1 + off2
 18259			v.Aux = mergeSym(sym1, sym2)
 18260			v.AddArg(base)
 18261			v.AddArg(val)
 18262			v.AddArg(mem)
 18263			return true
 18264		}
 18265		// match: (MOVHstore [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) val mem)
 18266		// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
 18267		// result: (MOVHstoreidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx val mem)
 18268		for {
 18269			off1 := v.AuxInt
 18270			sym1 := v.Aux
 18271			mem := v.Args[2]
 18272			v_0 := v.Args[0]
 18273			if v_0.Op != OpS390XMOVDaddridx {
 18274				break
 18275			}
 18276			off2 := v_0.AuxInt
 18277			sym2 := v_0.Aux
 18278			idx := v_0.Args[1]
 18279			ptr := v_0.Args[0]
 18280			val := v.Args[1]
 18281			if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
 18282				break
 18283			}
 18284			v.reset(OpS390XMOVHstoreidx)
 18285			v.AuxInt = off1 + off2
 18286			v.Aux = mergeSym(sym1, sym2)
 18287			v.AddArg(ptr)
 18288			v.AddArg(idx)
 18289			v.AddArg(val)
 18290			v.AddArg(mem)
 18291			return true
 18292		}
 18293		// match: (MOVHstore [off] {sym} (ADD ptr idx) val mem)
 18294		// cond: ptr.Op != OpSB
 18295		// result: (MOVHstoreidx [off] {sym} ptr idx val mem)
 18296		for {
 18297			off := v.AuxInt
 18298			sym := v.Aux
 18299			mem := v.Args[2]
 18300			v_0 := v.Args[0]
 18301			if v_0.Op != OpS390XADD {
 18302				break
 18303			}
 18304			idx := v_0.Args[1]
 18305			ptr := v_0.Args[0]
 18306			val := v.Args[1]
 18307			if !(ptr.Op != OpSB) {
 18308				break
 18309			}
 18310			v.reset(OpS390XMOVHstoreidx)
 18311			v.AuxInt = off
 18312			v.Aux = sym
 18313			v.AddArg(ptr)
 18314			v.AddArg(idx)
 18315			v.AddArg(val)
 18316			v.AddArg(mem)
 18317			return true
 18318		}
 18319		// match: (MOVHstore [i] {s} p w x:(MOVHstore [i-2] {s} p (SRDconst [16] w) mem))
 18320		// cond: p.Op != OpSB && x.Uses == 1 && clobber(x)
 18321		// result: (MOVWstore [i-2] {s} p w mem)
 18322		for {
 18323			i := v.AuxInt
 18324			s := v.Aux
 18325			_ = v.Args[2]
 18326			p := v.Args[0]
 18327			w := v.Args[1]
 18328			x := v.Args[2]
 18329			if x.Op != OpS390XMOVHstore {
 18330				break
 18331			}
 18332			if x.AuxInt != i-2 {
 18333				break
 18334			}
 18335			if x.Aux != s {
 18336				break
 18337			}
 18338			mem := x.Args[2]
 18339			if p != x.Args[0] {
 18340				break
 18341			}
 18342			x_1 := x.Args[1]
 18343			if x_1.Op != OpS390XSRDconst {
 18344				break
 18345			}
 18346			if x_1.AuxInt != 16 {
 18347				break
 18348			}
 18349			if w != x_1.Args[0] {
 18350				break
 18351			}
 18352			if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
 18353				break
 18354			}
 18355			v.reset(OpS390XMOVWstore)
 18356			v.AuxInt = i - 2
 18357			v.Aux = s
 18358			v.AddArg(p)
 18359			v.AddArg(w)
 18360			v.AddArg(mem)
 18361			return true
 18362		}
 18363		// match: (MOVHstore [i] {s} p w0:(SRDconst [j] w) x:(MOVHstore [i-2] {s} p (SRDconst [j+16] w) mem))
 18364		// cond: p.Op != OpSB && x.Uses == 1 && clobber(x)
 18365		// result: (MOVWstore [i-2] {s} p w0 mem)
 18366		for {
 18367			i := v.AuxInt
 18368			s := v.Aux
 18369			_ = v.Args[2]
 18370			p := v.Args[0]
 18371			w0 := v.Args[1]
 18372			if w0.Op != OpS390XSRDconst {
 18373				break
 18374			}
 18375			j := w0.AuxInt
 18376			w := w0.Args[0]
 18377			x := v.Args[2]
 18378			if x.Op != OpS390XMOVHstore {
 18379				break
 18380			}
 18381			if x.AuxInt != i-2 {
 18382				break
 18383			}
 18384			if x.Aux != s {
 18385				break
 18386			}
 18387			mem := x.Args[2]
 18388			if p != x.Args[0] {
 18389				break
 18390			}
 18391			x_1 := x.Args[1]
 18392			if x_1.Op != OpS390XSRDconst {
 18393				break
 18394			}
 18395			if x_1.AuxInt != j+16 {
 18396				break
 18397			}
 18398			if w != x_1.Args[0] {
 18399				break
 18400			}
 18401			if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
 18402				break
 18403			}
 18404			v.reset(OpS390XMOVWstore)
 18405			v.AuxInt = i - 2
 18406			v.Aux = s
 18407			v.AddArg(p)
 18408			v.AddArg(w0)
 18409			v.AddArg(mem)
 18410			return true
 18411		}
 18412		// match: (MOVHstore [i] {s} p w x:(MOVHstore [i-2] {s} p (SRWconst [16] w) mem))
 18413		// cond: p.Op != OpSB && x.Uses == 1 && clobber(x)
 18414		// result: (MOVWstore [i-2] {s} p w mem)
 18415		for {
 18416			i := v.AuxInt
 18417			s := v.Aux
 18418			_ = v.Args[2]
 18419			p := v.Args[0]
 18420			w := v.Args[1]
 18421			x := v.Args[2]
 18422			if x.Op != OpS390XMOVHstore {
 18423				break
 18424			}
 18425			if x.AuxInt != i-2 {
 18426				break
 18427			}
 18428			if x.Aux != s {
 18429				break
 18430			}
 18431			mem := x.Args[2]
 18432			if p != x.Args[0] {
 18433				break
 18434			}
 18435			x_1 := x.Args[1]
 18436			if x_1.Op != OpS390XSRWconst {
 18437				break
 18438			}
 18439			if x_1.AuxInt != 16 {
 18440				break
 18441			}
 18442			if w != x_1.Args[0] {
 18443				break
 18444			}
 18445			if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
 18446				break
 18447			}
 18448			v.reset(OpS390XMOVWstore)
 18449			v.AuxInt = i - 2
 18450			v.Aux = s
 18451			v.AddArg(p)
 18452			v.AddArg(w)
 18453			v.AddArg(mem)
 18454			return true
 18455		}
 18456		return false
 18457	}
 18458	func rewriteValueS390X_OpS390XMOVHstore_10(v *Value) bool {
 18459		// match: (MOVHstore [i] {s} p w0:(SRWconst [j] w) x:(MOVHstore [i-2] {s} p (SRWconst [j+16] w) mem))
 18460		// cond: p.Op != OpSB && x.Uses == 1 && clobber(x)
 18461		// result: (MOVWstore [i-2] {s} p w0 mem)
 18462		for {
 18463			i := v.AuxInt
 18464			s := v.Aux
 18465			_ = v.Args[2]
 18466			p := v.Args[0]
 18467			w0 := v.Args[1]
 18468			if w0.Op != OpS390XSRWconst {
 18469				break
 18470			}
 18471			j := w0.AuxInt
 18472			w := w0.Args[0]
 18473			x := v.Args[2]
 18474			if x.Op != OpS390XMOVHstore {
 18475				break
 18476			}
 18477			if x.AuxInt != i-2 {
 18478				break
 18479			}
 18480			if x.Aux != s {
 18481				break
 18482			}
 18483			mem := x.Args[2]
 18484			if p != x.Args[0] {
 18485				break
 18486			}
 18487			x_1 := x.Args[1]
 18488			if x_1.Op != OpS390XSRWconst {
 18489				break
 18490			}
 18491			if x_1.AuxInt != j+16 {
 18492				break
 18493			}
 18494			if w != x_1.Args[0] {
 18495				break
 18496			}
 18497			if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
 18498				break
 18499			}
 18500			v.reset(OpS390XMOVWstore)
 18501			v.AuxInt = i - 2
 18502			v.Aux = s
 18503			v.AddArg(p)
 18504			v.AddArg(w0)
 18505			v.AddArg(mem)
 18506			return true
 18507		}
 18508		return false
 18509	}
 18510	func rewriteValueS390X_OpS390XMOVHstoreconst_0(v *Value) bool {
 18511		b := v.Block
 18512		typ := &b.Func.Config.Types
 18513		// match: (MOVHstoreconst [sc] {s} (ADDconst [off] ptr) mem)
 18514		// cond: isU12Bit(ValAndOff(sc).Off()+off)
 18515		// result: (MOVHstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
 18516		for {
 18517			sc := v.AuxInt
 18518			s := v.Aux
 18519			mem := v.Args[1]
 18520			v_0 := v.Args[0]
 18521			if v_0.Op != OpS390XADDconst {
 18522				break
 18523			}
 18524			off := v_0.AuxInt
 18525			ptr := v_0.Args[0]
 18526			if !(isU12Bit(ValAndOff(sc).Off() + off)) {
 18527				break
 18528			}
 18529			v.reset(OpS390XMOVHstoreconst)
 18530			v.AuxInt = ValAndOff(sc).add(off)
 18531			v.Aux = s
 18532			v.AddArg(ptr)
 18533			v.AddArg(mem)
 18534			return true
 18535		}
 18536		// match: (MOVHstoreconst [sc] {sym1} (MOVDaddr [off] {sym2} ptr) mem)
 18537		// cond: ptr.Op != OpSB && canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)
 18538		// result: (MOVHstoreconst [ValAndOff(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem)
 18539		for {
 18540			sc := v.AuxInt
 18541			sym1 := v.Aux
 18542			mem := v.Args[1]
 18543			v_0 := v.Args[0]
 18544			if v_0.Op != OpS390XMOVDaddr {
 18545				break
 18546			}
 18547			off := v_0.AuxInt
 18548			sym2 := v_0.Aux
 18549			ptr := v_0.Args[0]
 18550			if !(ptr.Op != OpSB && canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)) {
 18551				break
 18552			}
 18553			v.reset(OpS390XMOVHstoreconst)
 18554			v.AuxInt = ValAndOff(sc).add(off)
 18555			v.Aux = mergeSym(sym1, sym2)
 18556			v.AddArg(ptr)
 18557			v.AddArg(mem)
 18558			return true
 18559		}
 18560		// match: (MOVHstoreconst [c] {s} p x:(MOVHstoreconst [a] {s} p mem))
 18561		// cond: p.Op != OpSB && x.Uses == 1 && ValAndOff(a).Off() + 2 == ValAndOff(c).Off() && clobber(x)
 18562		// result: (MOVWstore [ValAndOff(a).Off()] {s} p (MOVDconst [int64(int32(ValAndOff(c).Val()&0xffff | ValAndOff(a).Val()<<16))]) mem)
 18563		for {
 18564			c := v.AuxInt
 18565			s := v.Aux
 18566			_ = v.Args[1]
 18567			p := v.Args[0]
 18568			x := v.Args[1]
 18569			if x.Op != OpS390XMOVHstoreconst {
 18570				break
 18571			}
 18572			a := x.AuxInt
 18573			if x.Aux != s {
 18574				break
 18575			}
 18576			mem := x.Args[1]
 18577			if p != x.Args[0] {
 18578				break
 18579			}
 18580			if !(p.Op != OpSB && x.Uses == 1 && ValAndOff(a).Off()+2 == ValAndOff(c).Off() && clobber(x)) {
 18581				break
 18582			}
 18583			v.reset(OpS390XMOVWstore)
 18584			v.AuxInt = ValAndOff(a).Off()
 18585			v.Aux = s
 18586			v.AddArg(p)
 18587			v0 := b.NewValue0(x.Pos, OpS390XMOVDconst, typ.UInt64)
 18588			v0.AuxInt = int64(int32(ValAndOff(c).Val()&0xffff | ValAndOff(a).Val()<<16))
 18589			v.AddArg(v0)
 18590			v.AddArg(mem)
 18591			return true
 18592		}
 18593		return false
 18594	}
 18595	func rewriteValueS390X_OpS390XMOVHstoreidx_0(v *Value) bool {
 18596		// match: (MOVHstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem)
 18597		// cond: is20Bit(c+d)
 18598		// result: (MOVHstoreidx [c+d] {sym} ptr idx val mem)
 18599		for {
 18600			c := v.AuxInt
 18601			sym := v.Aux
 18602			mem := v.Args[3]
 18603			v_0 := v.Args[0]
 18604			if v_0.Op != OpS390XADDconst {
 18605				break
 18606			}
 18607			d := v_0.AuxInt
 18608			ptr := v_0.Args[0]
 18609			idx := v.Args[1]
 18610			val := v.Args[2]
 18611			if !(is20Bit(c + d)) {
 18612				break
 18613			}
 18614			v.reset(OpS390XMOVHstoreidx)
 18615			v.AuxInt = c + d
 18616			v.Aux = sym
 18617			v.AddArg(ptr)
 18618			v.AddArg(idx)
 18619			v.AddArg(val)
 18620			v.AddArg(mem)
 18621			return true
 18622		}
 18623		// match: (MOVHstoreidx [c] {sym} idx (ADDconst [d] ptr) val mem)
 18624		// cond: is20Bit(c+d)
 18625		// result: (MOVHstoreidx [c+d] {sym} ptr idx val mem)
 18626		for {
 18627			c := v.AuxInt
 18628			sym := v.Aux
 18629			mem := v.Args[3]
 18630			idx := v.Args[0]
 18631			v_1 := v.Args[1]
 18632			if v_1.Op != OpS390XADDconst {
 18633				break
 18634			}
 18635			d := v_1.AuxInt
 18636			ptr := v_1.Args[0]
 18637			val := v.Args[2]
 18638			if !(is20Bit(c + d)) {
 18639				break
 18640			}
 18641			v.reset(OpS390XMOVHstoreidx)
 18642			v.AuxInt = c + d
 18643			v.Aux = sym
 18644			v.AddArg(ptr)
 18645			v.AddArg(idx)
 18646			v.AddArg(val)
 18647			v.AddArg(mem)
 18648			return true
 18649		}
 18650		// match: (MOVHstoreidx [c] {sym} ptr (ADDconst [d] idx) val mem)
 18651		// cond: is20Bit(c+d)
 18652		// result: (MOVHstoreidx [c+d] {sym} ptr idx val mem)
 18653		for {
 18654			c := v.AuxInt
 18655			sym := v.Aux
 18656			mem := v.Args[3]
 18657			ptr := v.Args[0]
 18658			v_1 := v.Args[1]
 18659			if v_1.Op != OpS390XADDconst {
 18660				break
 18661			}
 18662			d := v_1.AuxInt
 18663			idx := v_1.Args[0]
 18664			val := v.Args[2]
 18665			if !(is20Bit(c + d)) {
 18666				break
 18667			}
 18668			v.reset(OpS390XMOVHstoreidx)
 18669			v.AuxInt = c + d
 18670			v.Aux = sym
 18671			v.AddArg(ptr)
 18672			v.AddArg(idx)
 18673			v.AddArg(val)
 18674			v.AddArg(mem)
 18675			return true
 18676		}
 18677		// match: (MOVHstoreidx [c] {sym} (ADDconst [d] idx) ptr val mem)
 18678		// cond: is20Bit(c+d)
 18679		// result: (MOVHstoreidx [c+d] {sym} ptr idx val mem)
 18680		for {
 18681			c := v.AuxInt
 18682			sym := v.Aux
 18683			mem := v.Args[3]
 18684			v_0 := v.Args[0]
 18685			if v_0.Op != OpS390XADDconst {
 18686				break
 18687			}
 18688			d := v_0.AuxInt
 18689			idx := v_0.Args[0]
 18690			ptr := v.Args[1]
 18691			val := v.Args[2]
 18692			if !(is20Bit(c + d)) {
 18693				break
 18694			}
 18695			v.reset(OpS390XMOVHstoreidx)
 18696			v.AuxInt = c + d
 18697			v.Aux = sym
 18698			v.AddArg(ptr)
 18699			v.AddArg(idx)
 18700			v.AddArg(val)
 18701			v.AddArg(mem)
 18702			return true
 18703		}
 18704		// match: (MOVHstoreidx [i] {s} p idx w x:(MOVHstoreidx [i-2] {s} p idx (SRDconst [16] w) mem))
 18705		// cond: x.Uses == 1 && clobber(x)
 18706		// result: (MOVWstoreidx [i-2] {s} p idx w mem)
 18707		for {
 18708			i := v.AuxInt
 18709			s := v.Aux
 18710			_ = v.Args[3]
 18711			p := v.Args[0]
 18712			idx := v.Args[1]
 18713			w := v.Args[2]
 18714			x := v.Args[3]
 18715			if x.Op != OpS390XMOVHstoreidx {
 18716				break
 18717			}
 18718			if x.AuxInt != i-2 {
 18719				break
 18720			}
 18721			if x.Aux != s {
 18722				break
 18723			}
 18724			mem := x.Args[3]
 18725			if p != x.Args[0] {
 18726				break
 18727			}
 18728			if idx != x.Args[1] {
 18729				break
 18730			}
 18731			x_2 := x.Args[2]
 18732			if x_2.Op != OpS390XSRDconst {
 18733				break
 18734			}
 18735			if x_2.AuxInt != 16 {
 18736				break
 18737			}
 18738			if w != x_2.Args[0] {
 18739				break
 18740			}
 18741			if !(x.Uses == 1 && clobber(x)) {
 18742				break
 18743			}
 18744			v.reset(OpS390XMOVWstoreidx)
 18745			v.AuxInt = i - 2
 18746			v.Aux = s
 18747			v.AddArg(p)
 18748			v.AddArg(idx)
 18749			v.AddArg(w)
 18750			v.AddArg(mem)
 18751			return true
 18752		}
 18753		// match: (MOVHstoreidx [i] {s} p idx w x:(MOVHstoreidx [i-2] {s} idx p (SRDconst [16] w) mem))
 18754		// cond: x.Uses == 1 && clobber(x)
 18755		// result: (MOVWstoreidx [i-2] {s} p idx w mem)
 18756		for {
 18757			i := v.AuxInt
 18758			s := v.Aux
 18759			_ = v.Args[3]
 18760			p := v.Args[0]
 18761			idx := v.Args[1]
 18762			w := v.Args[2]
 18763			x := v.Args[3]
 18764			if x.Op != OpS390XMOVHstoreidx {
 18765				break
 18766			}
 18767			if x.AuxInt != i-2 {
 18768				break
 18769			}
 18770			if x.Aux != s {
 18771				break
 18772			}
 18773			mem := x.Args[3]
 18774			if idx != x.Args[0] {
 18775				break
 18776			}
 18777			if p != x.Args[1] {
 18778				break
 18779			}
 18780			x_2 := x.Args[2]
 18781			if x_2.Op != OpS390XSRDconst {
 18782				break
 18783			}
 18784			if x_2.AuxInt != 16 {
 18785				break
 18786			}
 18787			if w != x_2.Args[0] {
 18788				break
 18789			}
 18790			if !(x.Uses == 1 && clobber(x)) {
 18791				break
 18792			}
 18793			v.reset(OpS390XMOVWstoreidx)
 18794			v.AuxInt = i - 2
 18795			v.Aux = s
 18796			v.AddArg(p)
 18797			v.AddArg(idx)
 18798			v.AddArg(w)
 18799			v.AddArg(mem)
 18800			return true
 18801		}
 18802		// match: (MOVHstoreidx [i] {s} idx p w x:(MOVHstoreidx [i-2] {s} p idx (SRDconst [16] w) mem))
 18803		// cond: x.Uses == 1 && clobber(x)
 18804		// result: (MOVWstoreidx [i-2] {s} p idx w mem)
 18805		for {
 18806			i := v.AuxInt
 18807			s := v.Aux
 18808			_ = v.Args[3]
 18809			idx := v.Args[0]
 18810			p := v.Args[1]
 18811			w := v.Args[2]
 18812			x := v.Args[3]
 18813			if x.Op != OpS390XMOVHstoreidx {
 18814				break
 18815			}
 18816			if x.AuxInt != i-2 {
 18817				break
 18818			}
 18819			if x.Aux != s {
 18820				break
 18821			}
 18822			mem := x.Args[3]
 18823			if p != x.Args[0] {
 18824				break
 18825			}
 18826			if idx != x.Args[1] {
 18827				break
 18828			}
 18829			x_2 := x.Args[2]
 18830			if x_2.Op != OpS390XSRDconst {
 18831				break
 18832			}
 18833			if x_2.AuxInt != 16 {
 18834				break
 18835			}
 18836			if w != x_2.Args[0] {
 18837				break
 18838			}
 18839			if !(x.Uses == 1 && clobber(x)) {
 18840				break
 18841			}
 18842			v.reset(OpS390XMOVWstoreidx)
 18843			v.AuxInt = i - 2
 18844			v.Aux = s
 18845			v.AddArg(p)
 18846			v.AddArg(idx)
 18847			v.AddArg(w)
 18848			v.AddArg(mem)
 18849			return true
 18850		}
 18851		// match: (MOVHstoreidx [i] {s} idx p w x:(MOVHstoreidx [i-2] {s} idx p (SRDconst [16] w) mem))
 18852		// cond: x.Uses == 1 && clobber(x)
 18853		// result: (MOVWstoreidx [i-2] {s} p idx w mem)
 18854		for {
 18855			i := v.AuxInt
 18856			s := v.Aux
 18857			_ = v.Args[3]
 18858			idx := v.Args[0]
 18859			p := v.Args[1]
 18860			w := v.Args[2]
 18861			x := v.Args[3]
 18862			if x.Op != OpS390XMOVHstoreidx {
 18863				break
 18864			}
 18865			if x.AuxInt != i-2 {
 18866				break
 18867			}
 18868			if x.Aux != s {
 18869				break
 18870			}
 18871			mem := x.Args[3]
 18872			if idx != x.Args[0] {
 18873				break
 18874			}
 18875			if p != x.Args[1] {
 18876				break
 18877			}
 18878			x_2 := x.Args[2]
 18879			if x_2.Op != OpS390XSRDconst {
 18880				break
 18881			}
 18882			if x_2.AuxInt != 16 {
 18883				break
 18884			}
 18885			if w != x_2.Args[0] {
 18886				break
 18887			}
 18888			if !(x.Uses == 1 && clobber(x)) {
 18889				break
 18890			}
 18891			v.reset(OpS390XMOVWstoreidx)
 18892			v.AuxInt = i - 2
 18893			v.Aux = s
 18894			v.AddArg(p)
 18895			v.AddArg(idx)
 18896			v.AddArg(w)
 18897			v.AddArg(mem)
 18898			return true
 18899		}
 18900		// match: (MOVHstoreidx [i] {s} p idx w0:(SRDconst [j] w) x:(MOVHstoreidx [i-2] {s} p idx (SRDconst [j+16] w) mem))
 18901		// cond: x.Uses == 1 && clobber(x)
 18902		// result: (MOVWstoreidx [i-2] {s} p idx w0 mem)
 18903		for {
 18904			i := v.AuxInt
 18905			s := v.Aux
 18906			_ = v.Args[3]
 18907			p := v.Args[0]
 18908			idx := v.Args[1]
 18909			w0 := v.Args[2]
 18910			if w0.Op != OpS390XSRDconst {
 18911				break
 18912			}
 18913			j := w0.AuxInt
 18914			w := w0.Args[0]
 18915			x := v.Args[3]
 18916			if x.Op != OpS390XMOVHstoreidx {
 18917				break
 18918			}
 18919			if x.AuxInt != i-2 {
 18920				break
 18921			}
 18922			if x.Aux != s {
 18923				break
 18924			}
 18925			mem := x.Args[3]
 18926			if p != x.Args[0] {
 18927				break
 18928			}
 18929			if idx != x.Args[1] {
 18930				break
 18931			}
 18932			x_2 := x.Args[2]
 18933			if x_2.Op != OpS390XSRDconst {
 18934				break
 18935			}
 18936			if x_2.AuxInt != j+16 {
 18937				break
 18938			}
 18939			if w != x_2.Args[0] {
 18940				break
 18941			}
 18942			if !(x.Uses == 1 && clobber(x)) {
 18943				break
 18944			}
 18945			v.reset(OpS390XMOVWstoreidx)
 18946			v.AuxInt = i - 2
 18947			v.Aux = s
 18948			v.AddArg(p)
 18949			v.AddArg(idx)
 18950			v.AddArg(w0)
 18951			v.AddArg(mem)
 18952			return true
 18953		}
 18954		// match: (MOVHstoreidx [i] {s} p idx w0:(SRDconst [j] w) x:(MOVHstoreidx [i-2] {s} idx p (SRDconst [j+16] w) mem))
 18955		// cond: x.Uses == 1 && clobber(x)
 18956		// result: (MOVWstoreidx [i-2] {s} p idx w0 mem)
 18957		for {
 18958			i := v.AuxInt
 18959			s := v.Aux
 18960			_ = v.Args[3]
 18961			p := v.Args[0]
 18962			idx := v.Args[1]
 18963			w0 := v.Args[2]
 18964			if w0.Op != OpS390XSRDconst {
 18965				break
 18966			}
 18967			j := w0.AuxInt
 18968			w := w0.Args[0]
 18969			x := v.Args[3]
 18970			if x.Op != OpS390XMOVHstoreidx {
 18971				break
 18972			}
 18973			if x.AuxInt != i-2 {
 18974				break
 18975			}
 18976			if x.Aux != s {
 18977				break
 18978			}
 18979			mem := x.Args[3]
 18980			if idx != x.Args[0] {
 18981				break
 18982			}
 18983			if p != x.Args[1] {
 18984				break
 18985			}
 18986			x_2 := x.Args[2]
 18987			if x_2.Op != OpS390XSRDconst {
 18988				break
 18989			}
 18990			if x_2.AuxInt != j+16 {
 18991				break
 18992			}
 18993			if w != x_2.Args[0] {
 18994				break
 18995			}
 18996			if !(x.Uses == 1 && clobber(x)) {
 18997				break
 18998			}
 18999			v.reset(OpS390XMOVWstoreidx)
 19000			v.AuxInt = i - 2
 19001			v.Aux = s
 19002			v.AddArg(p)
 19003			v.AddArg(idx)
 19004			v.AddArg(w0)
 19005			v.AddArg(mem)
 19006			return true
 19007		}
 19008		return false
 19009	}
 19010	func rewriteValueS390X_OpS390XMOVHstoreidx_10(v *Value) bool {
 19011		// match: (MOVHstoreidx [i] {s} idx p w0:(SRDconst [j] w) x:(MOVHstoreidx [i-2] {s} p idx (SRDconst [j+16] w) mem))
 19012		// cond: x.Uses == 1 && clobber(x)
 19013		// result: (MOVWstoreidx [i-2] {s} p idx w0 mem)
 19014		for {
 19015			i := v.AuxInt
 19016			s := v.Aux
 19017			_ = v.Args[3]
 19018			idx := v.Args[0]
 19019			p := v.Args[1]
 19020			w0 := v.Args[2]
 19021			if w0.Op != OpS390XSRDconst {
 19022				break
 19023			}
 19024			j := w0.AuxInt
 19025			w := w0.Args[0]
 19026			x := v.Args[3]
 19027			if x.Op != OpS390XMOVHstoreidx {
 19028				break
 19029			}
 19030			if x.AuxInt != i-2 {
 19031				break
 19032			}
 19033			if x.Aux != s {
 19034				break
 19035			}
 19036			mem := x.Args[3]
 19037			if p != x.Args[0] {
 19038				break
 19039			}
 19040			if idx != x.Args[1] {
 19041				break
 19042			}
 19043			x_2 := x.Args[2]
 19044			if x_2.Op != OpS390XSRDconst {
 19045				break
 19046			}
 19047			if x_2.AuxInt != j+16 {
 19048				break
 19049			}
 19050			if w != x_2.Args[0] {
 19051				break
 19052			}
 19053			if !(x.Uses == 1 && clobber(x)) {
 19054				break
 19055			}
 19056			v.reset(OpS390XMOVWstoreidx)
 19057			v.AuxInt = i - 2
 19058			v.Aux = s
 19059			v.AddArg(p)
 19060			v.AddArg(idx)
 19061			v.AddArg(w0)
 19062			v.AddArg(mem)
 19063			return true
 19064		}
 19065		// match: (MOVHstoreidx [i] {s} idx p w0:(SRDconst [j] w) x:(MOVHstoreidx [i-2] {s} idx p (SRDconst [j+16] w) mem))
 19066		// cond: x.Uses == 1 && clobber(x)
 19067		// result: (MOVWstoreidx [i-2] {s} p idx w0 mem)
 19068		for {
 19069			i := v.AuxInt
 19070			s := v.Aux
 19071			_ = v.Args[3]
 19072			idx := v.Args[0]
 19073			p := v.Args[1]
 19074			w0 := v.Args[2]
 19075			if w0.Op != OpS390XSRDconst {
 19076				break
 19077			}
 19078			j := w0.AuxInt
 19079			w := w0.Args[0]
 19080			x := v.Args[3]
 19081			if x.Op != OpS390XMOVHstoreidx {
 19082				break
 19083			}
 19084			if x.AuxInt != i-2 {
 19085				break
 19086			}
 19087			if x.Aux != s {
 19088				break
 19089			}
 19090			mem := x.Args[3]
 19091			if idx != x.Args[0] {
 19092				break
 19093			}
 19094			if p != x.Args[1] {
 19095				break
 19096			}
 19097			x_2 := x.Args[2]
 19098			if x_2.Op != OpS390XSRDconst {
 19099				break
 19100			}
 19101			if x_2.AuxInt != j+16 {
 19102				break
 19103			}
 19104			if w != x_2.Args[0] {
 19105				break
 19106			}
 19107			if !(x.Uses == 1 && clobber(x)) {
 19108				break
 19109			}
 19110			v.reset(OpS390XMOVWstoreidx)
 19111			v.AuxInt = i - 2
 19112			v.Aux = s
 19113			v.AddArg(p)
 19114			v.AddArg(idx)
 19115			v.AddArg(w0)
 19116			v.AddArg(mem)
 19117			return true
 19118		}
 19119		// match: (MOVHstoreidx [i] {s} p idx w x:(MOVHstoreidx [i-2] {s} p idx (SRWconst [16] w) mem))
 19120		// cond: x.Uses == 1 && clobber(x)
 19121		// result: (MOVWstoreidx [i-2] {s} p idx w mem)
 19122		for {
 19123			i := v.AuxInt
 19124			s := v.Aux
 19125			_ = v.Args[3]
 19126			p := v.Args[0]
 19127			idx := v.Args[1]
 19128			w := v.Args[2]
 19129			x := v.Args[3]
 19130			if x.Op != OpS390XMOVHstoreidx {
 19131				break
 19132			}
 19133			if x.AuxInt != i-2 {
 19134				break
 19135			}
 19136			if x.Aux != s {
 19137				break
 19138			}
 19139			mem := x.Args[3]
 19140			if p != x.Args[0] {
 19141				break
 19142			}
 19143			if idx != x.Args[1] {
 19144				break
 19145			}
 19146			x_2 := x.Args[2]
 19147			if x_2.Op != OpS390XSRWconst {
 19148				break
 19149			}
 19150			if x_2.AuxInt != 16 {
 19151				break
 19152			}
 19153			if w != x_2.Args[0] {
 19154				break
 19155			}
 19156			if !(x.Uses == 1 && clobber(x)) {
 19157				break
 19158			}
 19159			v.reset(OpS390XMOVWstoreidx)
 19160			v.AuxInt = i - 2
 19161			v.Aux = s
 19162			v.AddArg(p)
 19163			v.AddArg(idx)
 19164			v.AddArg(w)
 19165			v.AddArg(mem)
 19166			return true
 19167		}
 19168		// match: (MOVHstoreidx [i] {s} p idx w x:(MOVHstoreidx [i-2] {s} idx p (SRWconst [16] w) mem))
 19169		// cond: x.Uses == 1 && clobber(x)
 19170		// result: (MOVWstoreidx [i-2] {s} p idx w mem)
 19171		for {
 19172			i := v.AuxInt
 19173			s := v.Aux
 19174			_ = v.Args[3]
 19175			p := v.Args[0]
 19176			idx := v.Args[1]
 19177			w := v.Args[2]
 19178			x := v.Args[3]
 19179			if x.Op != OpS390XMOVHstoreidx {
 19180				break
 19181			}
 19182			if x.AuxInt != i-2 {
 19183				break
 19184			}
 19185			if x.Aux != s {
 19186				break
 19187			}
 19188			mem := x.Args[3]
 19189			if idx != x.Args[0] {
 19190				break
 19191			}
 19192			if p != x.Args[1] {
 19193				break
 19194			}
 19195			x_2 := x.Args[2]
 19196			if x_2.Op != OpS390XSRWconst {
 19197				break
 19198			}
 19199			if x_2.AuxInt != 16 {
 19200				break
 19201			}
 19202			if w != x_2.Args[0] {
 19203				break
 19204			}
 19205			if !(x.Uses == 1 && clobber(x)) {
 19206				break
 19207			}
 19208			v.reset(OpS390XMOVWstoreidx)
 19209			v.AuxInt = i - 2
 19210			v.Aux = s
 19211			v.AddArg(p)
 19212			v.AddArg(idx)
 19213			v.AddArg(w)
 19214			v.AddArg(mem)
 19215			return true
 19216		}
 19217		// match: (MOVHstoreidx [i] {s} idx p w x:(MOVHstoreidx [i-2] {s} p idx (SRWconst [16] w) mem))
 19218		// cond: x.Uses == 1 && clobber(x)
 19219		// result: (MOVWstoreidx [i-2] {s} p idx w mem)
 19220		for {
 19221			i := v.AuxInt
 19222			s := v.Aux
 19223			_ = v.Args[3]
 19224			idx := v.Args[0]
 19225			p := v.Args[1]
 19226			w := v.Args[2]
 19227			x := v.Args[3]
 19228			if x.Op != OpS390XMOVHstoreidx {
 19229				break
 19230			}
 19231			if x.AuxInt != i-2 {
 19232				break
 19233			}
 19234			if x.Aux != s {
 19235				break
 19236			}
 19237			mem := x.Args[3]
 19238			if p != x.Args[0] {
 19239				break
 19240			}
 19241			if idx != x.Args[1] {
 19242				break
 19243			}
 19244			x_2 := x.Args[2]
 19245			if x_2.Op != OpS390XSRWconst {
 19246				break
 19247			}
 19248			if x_2.AuxInt != 16 {
 19249				break
 19250			}
 19251			if w != x_2.Args[0] {
 19252				break
 19253			}
 19254			if !(x.Uses == 1 && clobber(x)) {
 19255				break
 19256			}
 19257			v.reset(OpS390XMOVWstoreidx)
 19258			v.AuxInt = i - 2
 19259			v.Aux = s
 19260			v.AddArg(p)
 19261			v.AddArg(idx)
 19262			v.AddArg(w)
 19263			v.AddArg(mem)
 19264			return true
 19265		}
 19266		// match: (MOVHstoreidx [i] {s} idx p w x:(MOVHstoreidx [i-2] {s} idx p (SRWconst [16] w) mem))
 19267		// cond: x.Uses == 1 && clobber(x)
 19268		// result: (MOVWstoreidx [i-2] {s} p idx w mem)
 19269		for {
 19270			i := v.AuxInt
 19271			s := v.Aux
 19272			_ = v.Args[3]
 19273			idx := v.Args[0]
 19274			p := v.Args[1]
 19275			w := v.Args[2]
 19276			x := v.Args[3]
 19277			if x.Op != OpS390XMOVHstoreidx {
 19278				break
 19279			}
 19280			if x.AuxInt != i-2 {
 19281				break
 19282			}
 19283			if x.Aux != s {
 19284				break
 19285			}
 19286			mem := x.Args[3]
 19287			if idx != x.Args[0] {
 19288				break
 19289			}
 19290			if p != x.Args[1] {
 19291				break
 19292			}
 19293			x_2 := x.Args[2]
 19294			if x_2.Op != OpS390XSRWconst {
 19295				break
 19296			}
 19297			if x_2.AuxInt != 16 {
 19298				break
 19299			}
 19300			if w != x_2.Args[0] {
 19301				break
 19302			}
 19303			if !(x.Uses == 1 && clobber(x)) {
 19304				break
 19305			}
 19306			v.reset(OpS390XMOVWstoreidx)
 19307			v.AuxInt = i - 2
 19308			v.Aux = s
 19309			v.AddArg(p)
 19310			v.AddArg(idx)
 19311			v.AddArg(w)
 19312			v.AddArg(mem)
 19313			return true
 19314		}
 19315		// match: (MOVHstoreidx [i] {s} p idx w0:(SRWconst [j] w) x:(MOVHstoreidx [i-2] {s} p idx (SRWconst [j+16] w) mem))
 19316		// cond: x.Uses == 1 && clobber(x)
 19317		// result: (MOVWstoreidx [i-2] {s} p idx w0 mem)
 19318		for {
 19319			i := v.AuxInt
 19320			s := v.Aux
 19321			_ = v.Args[3]
 19322			p := v.Args[0]
 19323			idx := v.Args[1]
 19324			w0 := v.Args[2]
 19325			if w0.Op != OpS390XSRWconst {
 19326				break
 19327			}
 19328			j := w0.AuxInt
 19329			w := w0.Args[0]
 19330			x := v.Args[3]
 19331			if x.Op != OpS390XMOVHstoreidx {
 19332				break
 19333			}
 19334			if x.AuxInt != i-2 {
 19335				break
 19336			}
 19337			if x.Aux != s {
 19338				break
 19339			}
 19340			mem := x.Args[3]
 19341			if p != x.Args[0] {
 19342				break
 19343			}
 19344			if idx != x.Args[1] {
 19345				break
 19346			}
 19347			x_2 := x.Args[2]
 19348			if x_2.Op != OpS390XSRWconst {
 19349				break
 19350			}
 19351			if x_2.AuxInt != j+16 {
 19352				break
 19353			}
 19354			if w != x_2.Args[0] {
 19355				break
 19356			}
 19357			if !(x.Uses == 1 && clobber(x)) {
 19358				break
 19359			}
 19360			v.reset(OpS390XMOVWstoreidx)
 19361			v.AuxInt = i - 2
 19362			v.Aux = s
 19363			v.AddArg(p)
 19364			v.AddArg(idx)
 19365			v.AddArg(w0)
 19366			v.AddArg(mem)
 19367			return true
 19368		}
 19369		// match: (MOVHstoreidx [i] {s} p idx w0:(SRWconst [j] w) x:(MOVHstoreidx [i-2] {s} idx p (SRWconst [j+16] w) mem))
 19370		// cond: x.Uses == 1 && clobber(x)
 19371		// result: (MOVWstoreidx [i-2] {s} p idx w0 mem)
 19372		for {
 19373			i := v.AuxInt
 19374			s := v.Aux
 19375			_ = v.Args[3]
 19376			p := v.Args[0]
 19377			idx := v.Args[1]
 19378			w0 := v.Args[2]
 19379			if w0.Op != OpS390XSRWconst {
 19380				break
 19381			}
 19382			j := w0.AuxInt
 19383			w := w0.Args[0]
 19384			x := v.Args[3]
 19385			if x.Op != OpS390XMOVHstoreidx {
 19386				break
 19387			}
 19388			if x.AuxInt != i-2 {
 19389				break
 19390			}
 19391			if x.Aux != s {
 19392				break
 19393			}
 19394			mem := x.Args[3]
 19395			if idx != x.Args[0] {
 19396				break
 19397			}
 19398			if p != x.Args[1] {
 19399				break
 19400			}
 19401			x_2 := x.Args[2]
 19402			if x_2.Op != OpS390XSRWconst {
 19403				break
 19404			}
 19405			if x_2.AuxInt != j+16 {
 19406				break
 19407			}
 19408			if w != x_2.Args[0] {
 19409				break
 19410			}
 19411			if !(x.Uses == 1 && clobber(x)) {
 19412				break
 19413			}
 19414			v.reset(OpS390XMOVWstoreidx)
 19415			v.AuxInt = i - 2
 19416			v.Aux = s
 19417			v.AddArg(p)
 19418			v.AddArg(idx)
 19419			v.AddArg(w0)
 19420			v.AddArg(mem)
 19421			return true
 19422		}
 19423		// match: (MOVHstoreidx [i] {s} idx p w0:(SRWconst [j] w) x:(MOVHstoreidx [i-2] {s} p idx (SRWconst [j+16] w) mem))
 19424		// cond: x.Uses == 1 && clobber(x)
 19425		// result: (MOVWstoreidx [i-2] {s} p idx w0 mem)
 19426		for {
 19427			i := v.AuxInt
 19428			s := v.Aux
 19429			_ = v.Args[3]
 19430			idx := v.Args[0]
 19431			p := v.Args[1]
 19432			w0 := v.Args[2]
 19433			if w0.Op != OpS390XSRWconst {
 19434				break
 19435			}
 19436			j := w0.AuxInt
 19437			w := w0.Args[0]
 19438			x := v.Args[3]
 19439			if x.Op != OpS390XMOVHstoreidx {
 19440				break
 19441			}
 19442			if x.AuxInt != i-2 {
 19443				break
 19444			}
 19445			if x.Aux != s {
 19446				break
 19447			}
 19448			mem := x.Args[3]
 19449			if p != x.Args[0] {
 19450				break
 19451			}
 19452			if idx != x.Args[1] {
 19453				break
 19454			}
 19455			x_2 := x.Args[2]
 19456			if x_2.Op != OpS390XSRWconst {
 19457				break
 19458			}
 19459			if x_2.AuxInt != j+16 {
 19460				break
 19461			}
 19462			if w != x_2.Args[0] {
 19463				break
 19464			}
 19465			if !(x.Uses == 1 && clobber(x)) {
 19466				break
 19467			}
 19468			v.reset(OpS390XMOVWstoreidx)
 19469			v.AuxInt = i - 2
 19470			v.Aux = s
 19471			v.AddArg(p)
 19472			v.AddArg(idx)
 19473			v.AddArg(w0)
 19474			v.AddArg(mem)
 19475			return true
 19476		}
 19477		// match: (MOVHstoreidx [i] {s} idx p w0:(SRWconst [j] w) x:(MOVHstoreidx [i-2] {s} idx p (SRWconst [j+16] w) mem))
 19478		// cond: x.Uses == 1 && clobber(x)
 19479		// result: (MOVWstoreidx [i-2] {s} p idx w0 mem)
 19480		for {
 19481			i := v.AuxInt
 19482			s := v.Aux
 19483			_ = v.Args[3]
 19484			idx := v.Args[0]
 19485			p := v.Args[1]
 19486			w0 := v.Args[2]
 19487			if w0.Op != OpS390XSRWconst {
 19488				break
 19489			}
 19490			j := w0.AuxInt
 19491			w := w0.Args[0]
 19492			x := v.Args[3]
 19493			if x.Op != OpS390XMOVHstoreidx {
 19494				break
 19495			}
 19496			if x.AuxInt != i-2 {
 19497				break
 19498			}
 19499			if x.Aux != s {
 19500				break
 19501			}
 19502			mem := x.Args[3]
 19503			if idx != x.Args[0] {
 19504				break
 19505			}
 19506			if p != x.Args[1] {
 19507				break
 19508			}
 19509			x_2 := x.Args[2]
 19510			if x_2.Op != OpS390XSRWconst {
 19511				break
 19512			}
 19513			if x_2.AuxInt != j+16 {
 19514				break
 19515			}
 19516			if w != x_2.Args[0] {
 19517				break
 19518			}
 19519			if !(x.Uses == 1 && clobber(x)) {
 19520				break
 19521			}
 19522			v.reset(OpS390XMOVWstoreidx)
 19523			v.AuxInt = i - 2
 19524			v.Aux = s
 19525			v.AddArg(p)
 19526			v.AddArg(idx)
 19527			v.AddArg(w0)
 19528			v.AddArg(mem)
 19529			return true
 19530		}
 19531		return false
 19532	}
 19533	func rewriteValueS390X_OpS390XMOVWBRstore_0(v *Value) bool {
 19534		// match: (MOVWBRstore [i] {s} p (SRDconst [32] w) x:(MOVWBRstore [i-4] {s} p w mem))
 19535		// cond: x.Uses == 1 && clobber(x)
 19536		// result: (MOVDBRstore [i-4] {s} p w mem)
 19537		for {
 19538			i := v.AuxInt
 19539			s := v.Aux
 19540			_ = v.Args[2]
 19541			p := v.Args[0]
 19542			v_1 := v.Args[1]
 19543			if v_1.Op != OpS390XSRDconst {
 19544				break
 19545			}
 19546			if v_1.AuxInt != 32 {
 19547				break
 19548			}
 19549			w := v_1.Args[0]
 19550			x := v.Args[2]
 19551			if x.Op != OpS390XMOVWBRstore {
 19552				break
 19553			}
 19554			if x.AuxInt != i-4 {
 19555				break
 19556			}
 19557			if x.Aux != s {
 19558				break
 19559			}
 19560			mem := x.Args[2]
 19561			if p != x.Args[0] {
 19562				break
 19563			}
 19564			if w != x.Args[1] {
 19565				break
 19566			}
 19567			if !(x.Uses == 1 && clobber(x)) {
 19568				break
 19569			}
 19570			v.reset(OpS390XMOVDBRstore)
 19571			v.AuxInt = i - 4
 19572			v.Aux = s
 19573			v.AddArg(p)
 19574			v.AddArg(w)
 19575			v.AddArg(mem)
 19576			return true
 19577		}
 19578		// match: (MOVWBRstore [i] {s} p (SRDconst [j] w) x:(MOVWBRstore [i-4] {s} p w0:(SRDconst [j-32] w) mem))
 19579		// cond: x.Uses == 1 && clobber(x)
 19580		// result: (MOVDBRstore [i-4] {s} p w0 mem)
 19581		for {
 19582			i := v.AuxInt
 19583			s := v.Aux
 19584			_ = v.Args[2]
 19585			p := v.Args[0]
 19586			v_1 := v.Args[1]
 19587			if v_1.Op != OpS390XSRDconst {
 19588				break
 19589			}
 19590			j := v_1.AuxInt
 19591			w := v_1.Args[0]
 19592			x := v.Args[2]
 19593			if x.Op != OpS390XMOVWBRstore {
 19594				break
 19595			}
 19596			if x.AuxInt != i-4 {
 19597				break
 19598			}
 19599			if x.Aux != s {
 19600				break
 19601			}
 19602			mem := x.Args[2]
 19603			if p != x.Args[0] {
 19604				break
 19605			}
 19606			w0 := x.Args[1]
 19607			if w0.Op != OpS390XSRDconst {
 19608				break
 19609			}
 19610			if w0.AuxInt != j-32 {
 19611				break
 19612			}
 19613			if w != w0.Args[0] {
 19614				break
 19615			}
 19616			if !(x.Uses == 1 && clobber(x)) {
 19617				break
 19618			}
 19619			v.reset(OpS390XMOVDBRstore)
 19620			v.AuxInt = i - 4
 19621			v.Aux = s
 19622			v.AddArg(p)
 19623			v.AddArg(w0)
 19624			v.AddArg(mem)
 19625			return true
 19626		}
 19627		return false
 19628	}
 19629	func rewriteValueS390X_OpS390XMOVWBRstoreidx_0(v *Value) bool {
 19630		// match: (MOVWBRstoreidx [i] {s} p idx (SRDconst [32] w) x:(MOVWBRstoreidx [i-4] {s} p idx w mem))
 19631		// cond: x.Uses == 1 && clobber(x)
 19632		// result: (MOVDBRstoreidx [i-4] {s} p idx w mem)
 19633		for {
 19634			i := v.AuxInt
 19635			s := v.Aux
 19636			_ = v.Args[3]
 19637			p := v.Args[0]
 19638			idx := v.Args[1]
 19639			v_2 := v.Args[2]
 19640			if v_2.Op != OpS390XSRDconst {
 19641				break
 19642			}
 19643			if v_2.AuxInt != 32 {
 19644				break
 19645			}
 19646			w := v_2.Args[0]
 19647			x := v.Args[3]
 19648			if x.Op != OpS390XMOVWBRstoreidx {
 19649				break
 19650			}
 19651			if x.AuxInt != i-4 {
 19652				break
 19653			}
 19654			if x.Aux != s {
 19655				break
 19656			}
 19657			mem := x.Args[3]
 19658			if p != x.Args[0] {
 19659				break
 19660			}
 19661			if idx != x.Args[1] {
 19662				break
 19663			}
 19664			if w != x.Args[2] {
 19665				break
 19666			}
 19667			if !(x.Uses == 1 && clobber(x)) {
 19668				break
 19669			}
 19670			v.reset(OpS390XMOVDBRstoreidx)
 19671			v.AuxInt = i - 4
 19672			v.Aux = s
 19673			v.AddArg(p)
 19674			v.AddArg(idx)
 19675			v.AddArg(w)
 19676			v.AddArg(mem)
 19677			return true
 19678		}
 19679		// match: (MOVWBRstoreidx [i] {s} p idx (SRDconst [32] w) x:(MOVWBRstoreidx [i-4] {s} idx p w mem))
 19680		// cond: x.Uses == 1 && clobber(x)
 19681		// result: (MOVDBRstoreidx [i-4] {s} p idx w mem)
 19682		for {
 19683			i := v.AuxInt
 19684			s := v.Aux
 19685			_ = v.Args[3]
 19686			p := v.Args[0]
 19687			idx := v.Args[1]
 19688			v_2 := v.Args[2]
 19689			if v_2.Op != OpS390XSRDconst {
 19690				break
 19691			}
 19692			if v_2.AuxInt != 32 {
 19693				break
 19694			}
 19695			w := v_2.Args[0]
 19696			x := v.Args[3]
 19697			if x.Op != OpS390XMOVWBRstoreidx {
 19698				break
 19699			}
 19700			if x.AuxInt != i-4 {
 19701				break
 19702			}
 19703			if x.Aux != s {
 19704				break
 19705			}
 19706			mem := x.Args[3]
 19707			if idx != x.Args[0] {
 19708				break
 19709			}
 19710			if p != x.Args[1] {
 19711				break
 19712			}
 19713			if w != x.Args[2] {
 19714				break
 19715			}
 19716			if !(x.Uses == 1 && clobber(x)) {
 19717				break
 19718			}
 19719			v.reset(OpS390XMOVDBRstoreidx)
 19720			v.AuxInt = i - 4
 19721			v.Aux = s
 19722			v.AddArg(p)
 19723			v.AddArg(idx)
 19724			v.AddArg(w)
 19725			v.AddArg(mem)
 19726			return true
 19727		}
 19728		// match: (MOVWBRstoreidx [i] {s} idx p (SRDconst [32] w) x:(MOVWBRstoreidx [i-4] {s} p idx w mem))
 19729		// cond: x.Uses == 1 && clobber(x)
 19730		// result: (MOVDBRstoreidx [i-4] {s} p idx w mem)
 19731		for {
 19732			i := v.AuxInt
 19733			s := v.Aux
 19734			_ = v.Args[3]
 19735			idx := v.Args[0]
 19736			p := v.Args[1]
 19737			v_2 := v.Args[2]
 19738			if v_2.Op != OpS390XSRDconst {
 19739				break
 19740			}
 19741			if v_2.AuxInt != 32 {
 19742				break
 19743			}
 19744			w := v_2.Args[0]
 19745			x := v.Args[3]
 19746			if x.Op != OpS390XMOVWBRstoreidx {
 19747				break
 19748			}
 19749			if x.AuxInt != i-4 {
 19750				break
 19751			}
 19752			if x.Aux != s {
 19753				break
 19754			}
 19755			mem := x.Args[3]
 19756			if p != x.Args[0] {
 19757				break
 19758			}
 19759			if idx != x.Args[1] {
 19760				break
 19761			}
 19762			if w != x.Args[2] {
 19763				break
 19764			}
 19765			if !(x.Uses == 1 && clobber(x)) {
 19766				break
 19767			}
 19768			v.reset(OpS390XMOVDBRstoreidx)
 19769			v.AuxInt = i - 4
 19770			v.Aux = s
 19771			v.AddArg(p)
 19772			v.AddArg(idx)
 19773			v.AddArg(w)
 19774			v.AddArg(mem)
 19775			return true
 19776		}
 19777		// match: (MOVWBRstoreidx [i] {s} idx p (SRDconst [32] w) x:(MOVWBRstoreidx [i-4] {s} idx p w mem))
 19778		// cond: x.Uses == 1 && clobber(x)
 19779		// result: (MOVDBRstoreidx [i-4] {s} p idx w mem)
 19780		for {
 19781			i := v.AuxInt
 19782			s := v.Aux
 19783			_ = v.Args[3]
 19784			idx := v.Args[0]
 19785			p := v.Args[1]
 19786			v_2 := v.Args[2]
 19787			if v_2.Op != OpS390XSRDconst {
 19788				break
 19789			}
 19790			if v_2.AuxInt != 32 {
 19791				break
 19792			}
 19793			w := v_2.Args[0]
 19794			x := v.Args[3]
 19795			if x.Op != OpS390XMOVWBRstoreidx {
 19796				break
 19797			}
 19798			if x.AuxInt != i-4 {
 19799				break
 19800			}
 19801			if x.Aux != s {
 19802				break
 19803			}
 19804			mem := x.Args[3]
 19805			if idx != x.Args[0] {
 19806				break
 19807			}
 19808			if p != x.Args[1] {
 19809				break
 19810			}
 19811			if w != x.Args[2] {
 19812				break
 19813			}
 19814			if !(x.Uses == 1 && clobber(x)) {
 19815				break
 19816			}
 19817			v.reset(OpS390XMOVDBRstoreidx)
 19818			v.AuxInt = i - 4
 19819			v.Aux = s
 19820			v.AddArg(p)
 19821			v.AddArg(idx)
 19822			v.AddArg(w)
 19823			v.AddArg(mem)
 19824			return true
 19825		}
 19826		// match: (MOVWBRstoreidx [i] {s} p idx (SRDconst [j] w) x:(MOVWBRstoreidx [i-4] {s} p idx w0:(SRDconst [j-32] w) mem))
 19827		// cond: x.Uses == 1 && clobber(x)
 19828		// result: (MOVDBRstoreidx [i-4] {s} p idx w0 mem)
 19829		for {
 19830			i := v.AuxInt
 19831			s := v.Aux
 19832			_ = v.Args[3]
 19833			p := v.Args[0]
 19834			idx := v.Args[1]
 19835			v_2 := v.Args[2]
 19836			if v_2.Op != OpS390XSRDconst {
 19837				break
 19838			}
 19839			j := v_2.AuxInt
 19840			w := v_2.Args[0]
 19841			x := v.Args[3]
 19842			if x.Op != OpS390XMOVWBRstoreidx {
 19843				break
 19844			}
 19845			if x.AuxInt != i-4 {
 19846				break
 19847			}
 19848			if x.Aux != s {
 19849				break
 19850			}
 19851			mem := x.Args[3]
 19852			if p != x.Args[0] {
 19853				break
 19854			}
 19855			if idx != x.Args[1] {
 19856				break
 19857			}
 19858			w0 := x.Args[2]
 19859			if w0.Op != OpS390XSRDconst {
 19860				break
 19861			}
 19862			if w0.AuxInt != j-32 {
 19863				break
 19864			}
 19865			if w != w0.Args[0] {
 19866				break
 19867			}
 19868			if !(x.Uses == 1 && clobber(x)) {
 19869				break
 19870			}
 19871			v.reset(OpS390XMOVDBRstoreidx)
 19872			v.AuxInt = i - 4
 19873			v.Aux = s
 19874			v.AddArg(p)
 19875			v.AddArg(idx)
 19876			v.AddArg(w0)
 19877			v.AddArg(mem)
 19878			return true
 19879		}
 19880		// match: (MOVWBRstoreidx [i] {s} p idx (SRDconst [j] w) x:(MOVWBRstoreidx [i-4] {s} idx p w0:(SRDconst [j-32] w) mem))
 19881		// cond: x.Uses == 1 && clobber(x)
 19882		// result: (MOVDBRstoreidx [i-4] {s} p idx w0 mem)
 19883		for {
 19884			i := v.AuxInt
 19885			s := v.Aux
 19886			_ = v.Args[3]
 19887			p := v.Args[0]
 19888			idx := v.Args[1]
 19889			v_2 := v.Args[2]
 19890			if v_2.Op != OpS390XSRDconst {
 19891				break
 19892			}
 19893			j := v_2.AuxInt
 19894			w := v_2.Args[0]
 19895			x := v.Args[3]
 19896			if x.Op != OpS390XMOVWBRstoreidx {
 19897				break
 19898			}
 19899			if x.AuxInt != i-4 {
 19900				break
 19901			}
 19902			if x.Aux != s {
 19903				break
 19904			}
 19905			mem := x.Args[3]
 19906			if idx != x.Args[0] {
 19907				break
 19908			}
 19909			if p != x.Args[1] {
 19910				break
 19911			}
 19912			w0 := x.Args[2]
 19913			if w0.Op != OpS390XSRDconst {
 19914				break
 19915			}
 19916			if w0.AuxInt != j-32 {
 19917				break
 19918			}
 19919			if w != w0.Args[0] {
 19920				break
 19921			}
 19922			if !(x.Uses == 1 && clobber(x)) {
 19923				break
 19924			}
 19925			v.reset(OpS390XMOVDBRstoreidx)
 19926			v.AuxInt = i - 4
 19927			v.Aux = s
 19928			v.AddArg(p)
 19929			v.AddArg(idx)
 19930			v.AddArg(w0)
 19931			v.AddArg(mem)
 19932			return true
 19933		}
 19934		// match: (MOVWBRstoreidx [i] {s} idx p (SRDconst [j] w) x:(MOVWBRstoreidx [i-4] {s} p idx w0:(SRDconst [j-32] w) mem))
 19935		// cond: x.Uses == 1 && clobber(x)
 19936		// result: (MOVDBRstoreidx [i-4] {s} p idx w0 mem)
 19937		for {
 19938			i := v.AuxInt
 19939			s := v.Aux
 19940			_ = v.Args[3]
 19941			idx := v.Args[0]
 19942			p := v.Args[1]
 19943			v_2 := v.Args[2]
 19944			if v_2.Op != OpS390XSRDconst {
 19945				break
 19946			}
 19947			j := v_2.AuxInt
 19948			w := v_2.Args[0]
 19949			x := v.Args[3]
 19950			if x.Op != OpS390XMOVWBRstoreidx {
 19951				break
 19952			}
 19953			if x.AuxInt != i-4 {
 19954				break
 19955			}
 19956			if x.Aux != s {
 19957				break
 19958			}
 19959			mem := x.Args[3]
 19960			if p != x.Args[0] {
 19961				break
 19962			}
 19963			if idx != x.Args[1] {
 19964				break
 19965			}
 19966			w0 := x.Args[2]
 19967			if w0.Op != OpS390XSRDconst {
 19968				break
 19969			}
 19970			if w0.AuxInt != j-32 {
 19971				break
 19972			}
 19973			if w != w0.Args[0] {
 19974				break
 19975			}
 19976			if !(x.Uses == 1 && clobber(x)) {
 19977				break
 19978			}
 19979			v.reset(OpS390XMOVDBRstoreidx)
 19980			v.AuxInt = i - 4
 19981			v.Aux = s
 19982			v.AddArg(p)
 19983			v.AddArg(idx)
 19984			v.AddArg(w0)
 19985			v.AddArg(mem)
 19986			return true
 19987		}
 19988		// match: (MOVWBRstoreidx [i] {s} idx p (SRDconst [j] w) x:(MOVWBRstoreidx [i-4] {s} idx p w0:(SRDconst [j-32] w) mem))
 19989		// cond: x.Uses == 1 && clobber(x)
 19990		// result: (MOVDBRstoreidx [i-4] {s} p idx w0 mem)
 19991		for {
 19992			i := v.AuxInt
 19993			s := v.Aux
 19994			_ = v.Args[3]
 19995			idx := v.Args[0]
 19996			p := v.Args[1]
 19997			v_2 := v.Args[2]
 19998			if v_2.Op != OpS390XSRDconst {
 19999				break
 20000			}
 20001			j := v_2.AuxInt
 20002			w := v_2.Args[0]
 20003			x := v.Args[3]
 20004			if x.Op != OpS390XMOVWBRstoreidx {
 20005				break
 20006			}
 20007			if x.AuxInt != i-4 {
 20008				break
 20009			}
 20010			if x.Aux != s {
 20011				break
 20012			}
 20013			mem := x.Args[3]
 20014			if idx != x.Args[0] {
 20015				break
 20016			}
 20017			if p != x.Args[1] {
 20018				break
 20019			}
 20020			w0 := x.Args[2]
 20021			if w0.Op != OpS390XSRDconst {
 20022				break
 20023			}
 20024			if w0.AuxInt != j-32 {
 20025				break
 20026			}
 20027			if w != w0.Args[0] {
 20028				break
 20029			}
 20030			if !(x.Uses == 1 && clobber(x)) {
 20031				break
 20032			}
 20033			v.reset(OpS390XMOVDBRstoreidx)
 20034			v.AuxInt = i - 4
 20035			v.Aux = s
 20036			v.AddArg(p)
 20037			v.AddArg(idx)
 20038			v.AddArg(w0)
 20039			v.AddArg(mem)
 20040			return true
 20041		}
 20042		return false
 20043	}
 20044	func rewriteValueS390X_OpS390XMOVWZload_0(v *Value) bool {
 20045		// match: (MOVWZload [off] {sym} ptr1 (MOVWstore [off] {sym} ptr2 x _))
 20046		// cond: isSamePtr(ptr1, ptr2)
 20047		// result: (MOVWZreg x)
 20048		for {
 20049			off := v.AuxInt
 20050			sym := v.Aux
 20051			_ = v.Args[1]
 20052			ptr1 := v.Args[0]
 20053			v_1 := v.Args[1]
 20054			if v_1.Op != OpS390XMOVWstore {
 20055				break
 20056			}
 20057			if v_1.AuxInt != off {
 20058				break
 20059			}
 20060			if v_1.Aux != sym {
 20061				break
 20062			}
 20063			_ = v_1.Args[2]
 20064			ptr2 := v_1.Args[0]
 20065			x := v_1.Args[1]
 20066			if !(isSamePtr(ptr1, ptr2)) {
 20067				break
 20068			}
 20069			v.reset(OpS390XMOVWZreg)
 20070			v.AddArg(x)
 20071			return true
 20072		}
 20073		// match: (MOVWZload [off1] {sym} (ADDconst [off2] ptr) mem)
 20074		// cond: is20Bit(off1+off2)
 20075		// result: (MOVWZload [off1+off2] {sym} ptr mem)
 20076		for {
 20077			off1 := v.AuxInt
 20078			sym := v.Aux
 20079			mem := v.Args[1]
 20080			v_0 := v.Args[0]
 20081			if v_0.Op != OpS390XADDconst {
 20082				break
 20083			}
 20084			off2 := v_0.AuxInt
 20085			ptr := v_0.Args[0]
 20086			if !(is20Bit(off1 + off2)) {
 20087				break
 20088			}
 20089			v.reset(OpS390XMOVWZload)
 20090			v.AuxInt = off1 + off2
 20091			v.Aux = sym
 20092			v.AddArg(ptr)
 20093			v.AddArg(mem)
 20094			return true
 20095		}
 20096		// match: (MOVWZload [off1] {sym1} (MOVDaddr <t> [off2] {sym2} base) mem)
 20097		// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || (t.IsPtr() && t.Elem().Alignment()%4 == 0 && (off1+off2)%4 == 0))
 20098		// result: (MOVWZload [off1+off2] {mergeSym(sym1,sym2)} base mem)
 20099		for {
 20100			off1 := v.AuxInt
 20101			sym1 := v.Aux
 20102			mem := v.Args[1]
 20103			v_0 := v.Args[0]
 20104			if v_0.Op != OpS390XMOVDaddr {
 20105				break
 20106			}
 20107			t := v_0.Type
 20108			off2 := v_0.AuxInt
 20109			sym2 := v_0.Aux
 20110			base := v_0.Args[0]
 20111			if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || (t.IsPtr() && t.Elem().Alignment()%4 == 0 && (off1+off2)%4 == 0))) {
 20112				break
 20113			}
 20114			v.reset(OpS390XMOVWZload)
 20115			v.AuxInt = off1 + off2
 20116			v.Aux = mergeSym(sym1, sym2)
 20117			v.AddArg(base)
 20118			v.AddArg(mem)
 20119			return true
 20120		}
 20121		// match: (MOVWZload [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) mem)
 20122		// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
 20123		// result: (MOVWZloadidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem)
 20124		for {
 20125			off1 := v.AuxInt
 20126			sym1 := v.Aux
 20127			mem := v.Args[1]
 20128			v_0 := v.Args[0]
 20129			if v_0.Op != OpS390XMOVDaddridx {
 20130				break
 20131			}
 20132			off2 := v_0.AuxInt
 20133			sym2 := v_0.Aux
 20134			idx := v_0.Args[1]
 20135			ptr := v_0.Args[0]
 20136			if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
 20137				break
 20138			}
 20139			v.reset(OpS390XMOVWZloadidx)
 20140			v.AuxInt = off1 + off2
 20141			v.Aux = mergeSym(sym1, sym2)
 20142			v.AddArg(ptr)
 20143			v.AddArg(idx)
 20144			v.AddArg(mem)
 20145			return true
 20146		}
 20147		// match: (MOVWZload [off] {sym} (ADD ptr idx) mem)
 20148		// cond: ptr.Op != OpSB
 20149		// result: (MOVWZloadidx [off] {sym} ptr idx mem)
 20150		for {
 20151			off := v.AuxInt
 20152			sym := v.Aux
 20153			mem := v.Args[1]
 20154			v_0 := v.Args[0]
 20155			if v_0.Op != OpS390XADD {
 20156				break
 20157			}
 20158			idx := v_0.Args[1]
 20159			ptr := v_0.Args[0]
 20160			if !(ptr.Op != OpSB) {
 20161				break
 20162			}
 20163			v.reset(OpS390XMOVWZloadidx)
 20164			v.AuxInt = off
 20165			v.Aux = sym
 20166			v.AddArg(ptr)
 20167			v.AddArg(idx)
 20168			v.AddArg(mem)
 20169			return true
 20170		}
 20171		return false
 20172	}
 20173	func rewriteValueS390X_OpS390XMOVWZloadidx_0(v *Value) bool {
 20174		// match: (MOVWZloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
 20175		// cond: is20Bit(c+d)
 20176		// result: (MOVWZloadidx [c+d] {sym} ptr idx mem)
 20177		for {
 20178			c := v.AuxInt
 20179			sym := v.Aux
 20180			mem := v.Args[2]
 20181			v_0 := v.Args[0]
 20182			if v_0.Op != OpS390XADDconst {
 20183				break
 20184			}
 20185			d := v_0.AuxInt
 20186			ptr := v_0.Args[0]
 20187			idx := v.Args[1]
 20188			if !(is20Bit(c + d)) {
 20189				break
 20190			}
 20191			v.reset(OpS390XMOVWZloadidx)
 20192			v.AuxInt = c + d
 20193			v.Aux = sym
 20194			v.AddArg(ptr)
 20195			v.AddArg(idx)
 20196			v.AddArg(mem)
 20197			return true
 20198		}
 20199		// match: (MOVWZloadidx [c] {sym} idx (ADDconst [d] ptr) mem)
 20200		// cond: is20Bit(c+d)
 20201		// result: (MOVWZloadidx [c+d] {sym} ptr idx mem)
 20202		for {
 20203			c := v.AuxInt
 20204			sym := v.Aux
 20205			mem := v.Args[2]
 20206			idx := v.Args[0]
 20207			v_1 := v.Args[1]
 20208			if v_1.Op != OpS390XADDconst {
 20209				break
 20210			}
 20211			d := v_1.AuxInt
 20212			ptr := v_1.Args[0]
 20213			if !(is20Bit(c + d)) {
 20214				break
 20215			}
 20216			v.reset(OpS390XMOVWZloadidx)
 20217			v.AuxInt = c + d
 20218			v.Aux = sym
 20219			v.AddArg(ptr)
 20220			v.AddArg(idx)
 20221			v.AddArg(mem)
 20222			return true
 20223		}
 20224		// match: (MOVWZloadidx [c] {sym} ptr (ADDconst [d] idx) mem)
 20225		// cond: is20Bit(c+d)
 20226		// result: (MOVWZloadidx [c+d] {sym} ptr idx mem)
 20227		for {
 20228			c := v.AuxInt
 20229			sym := v.Aux
 20230			mem := v.Args[2]
 20231			ptr := v.Args[0]
 20232			v_1 := v.Args[1]
 20233			if v_1.Op != OpS390XADDconst {
 20234				break
 20235			}
 20236			d := v_1.AuxInt
 20237			idx := v_1.Args[0]
 20238			if !(is20Bit(c + d)) {
 20239				break
 20240			}
 20241			v.reset(OpS390XMOVWZloadidx)
 20242			v.AuxInt = c + d
 20243			v.Aux = sym
 20244			v.AddArg(ptr)
 20245			v.AddArg(idx)
 20246			v.AddArg(mem)
 20247			return true
 20248		}
 20249		// match: (MOVWZloadidx [c] {sym} (ADDconst [d] idx) ptr mem)
 20250		// cond: is20Bit(c+d)
 20251		// result: (MOVWZloadidx [c+d] {sym} ptr idx mem)
 20252		for {
 20253			c := v.AuxInt
 20254			sym := v.Aux
 20255			mem := v.Args[2]
 20256			v_0 := v.Args[0]
 20257			if v_0.Op != OpS390XADDconst {
 20258				break
 20259			}
 20260			d := v_0.AuxInt
 20261			idx := v_0.Args[0]
 20262			ptr := v.Args[1]
 20263			if !(is20Bit(c + d)) {
 20264				break
 20265			}
 20266			v.reset(OpS390XMOVWZloadidx)
 20267			v.AuxInt = c + d
 20268			v.Aux = sym
 20269			v.AddArg(ptr)
 20270			v.AddArg(idx)
 20271			v.AddArg(mem)
 20272			return true
 20273		}
 20274		return false
 20275	}
 20276	func rewriteValueS390X_OpS390XMOVWZreg_0(v *Value) bool {
 20277		b := v.Block
 20278		// match: (MOVWZreg x:(MOVBZload _ _))
 20279		// cond:
 20280		// result: (MOVDreg x)
 20281		for {
 20282			x := v.Args[0]
 20283			if x.Op != OpS390XMOVBZload {
 20284				break
 20285			}
 20286			_ = x.Args[1]
 20287			v.reset(OpS390XMOVDreg)
 20288			v.AddArg(x)
 20289			return true
 20290		}
 20291		// match: (MOVWZreg x:(MOVHZload _ _))
 20292		// cond:
 20293		// result: (MOVDreg x)
 20294		for {
 20295			x := v.Args[0]
 20296			if x.Op != OpS390XMOVHZload {
 20297				break
 20298			}
 20299			_ = x.Args[1]
 20300			v.reset(OpS390XMOVDreg)
 20301			v.AddArg(x)
 20302			return true
 20303		}
 20304		// match: (MOVWZreg x:(MOVWZload _ _))
 20305		// cond:
 20306		// result: (MOVDreg x)
 20307		for {
 20308			x := v.Args[0]
 20309			if x.Op != OpS390XMOVWZload {
 20310				break
 20311			}
 20312			_ = x.Args[1]
 20313			v.reset(OpS390XMOVDreg)
 20314			v.AddArg(x)
 20315			return true
 20316		}
 20317		// match: (MOVWZreg x:(Arg <t>))
 20318		// cond: (is8BitInt(t) || is16BitInt(t) || is32BitInt(t)) && !isSigned(t)
 20319		// result: (MOVDreg x)
 20320		for {
 20321			x := v.Args[0]
 20322			if x.Op != OpArg {
 20323				break
 20324			}
 20325			t := x.Type
 20326			if !((is8BitInt(t) || is16BitInt(t) || is32BitInt(t)) && !isSigned(t)) {
 20327				break
 20328			}
 20329			v.reset(OpS390XMOVDreg)
 20330			v.AddArg(x)
 20331			return true
 20332		}
 20333		// match: (MOVWZreg x:(MOVBZreg _))
 20334		// cond:
 20335		// result: (MOVDreg x)
 20336		for {
 20337			x := v.Args[0]
 20338			if x.Op != OpS390XMOVBZreg {
 20339				break
 20340			}
 20341			v.reset(OpS390XMOVDreg)
 20342			v.AddArg(x)
 20343			return true
 20344		}
 20345		// match: (MOVWZreg x:(MOVHZreg _))
 20346		// cond:
 20347		// result: (MOVDreg x)
 20348		for {
 20349			x := v.Args[0]
 20350			if x.Op != OpS390XMOVHZreg {
 20351				break
 20352			}
 20353			v.reset(OpS390XMOVDreg)
 20354			v.AddArg(x)
 20355			return true
 20356		}
 20357		// match: (MOVWZreg x:(MOVWZreg _))
 20358		// cond:
 20359		// result: (MOVDreg x)
 20360		for {
 20361			x := v.Args[0]
 20362			if x.Op != OpS390XMOVWZreg {
 20363				break
 20364			}
 20365			v.reset(OpS390XMOVDreg)
 20366			v.AddArg(x)
 20367			return true
 20368		}
 20369		// match: (MOVWZreg (MOVWreg x))
 20370		// cond:
 20371		// result: (MOVWZreg x)
 20372		for {
 20373			v_0 := v.Args[0]
 20374			if v_0.Op != OpS390XMOVWreg {
 20375				break
 20376			}
 20377			x := v_0.Args[0]
 20378			v.reset(OpS390XMOVWZreg)
 20379			v.AddArg(x)
 20380			return true
 20381		}
 20382		// match: (MOVWZreg (MOVDconst [c]))
 20383		// cond:
 20384		// result: (MOVDconst [int64(uint32(c))])
 20385		for {
 20386			v_0 := v.Args[0]
 20387			if v_0.Op != OpS390XMOVDconst {
 20388				break
 20389			}
 20390			c := v_0.AuxInt
 20391			v.reset(OpS390XMOVDconst)
 20392			v.AuxInt = int64(uint32(c))
 20393			return true
 20394		}
 20395		// match: (MOVWZreg x:(MOVWZload [off] {sym} ptr mem))
 20396		// cond: x.Uses == 1 && clobber(x)
 20397		// result: @x.Block (MOVWZload <v.Type> [off] {sym} ptr mem)
 20398		for {
 20399			x := v.Args[0]
 20400			if x.Op != OpS390XMOVWZload {
 20401				break
 20402			}
 20403			off := x.AuxInt
 20404			sym := x.Aux
 20405			mem := x.Args[1]
 20406			ptr := x.Args[0]
 20407			if !(x.Uses == 1 && clobber(x)) {
 20408				break
 20409			}
 20410			b = x.Block
 20411			v0 := b.NewValue0(x.Pos, OpS390XMOVWZload, v.Type)
 20412			v.reset(OpCopy)
 20413			v.AddArg(v0)
 20414			v0.AuxInt = off
 20415			v0.Aux = sym
 20416			v0.AddArg(ptr)
 20417			v0.AddArg(mem)
 20418			return true
 20419		}
 20420		return false
 20421	}
 20422	func rewriteValueS390X_OpS390XMOVWZreg_10(v *Value) bool {
 20423		b := v.Block
 20424		// match: (MOVWZreg x:(MOVWload [off] {sym} ptr mem))
 20425		// cond: x.Uses == 1 && clobber(x)
 20426		// result: @x.Block (MOVWZload <v.Type> [off] {sym} ptr mem)
 20427		for {
 20428			x := v.Args[0]
 20429			if x.Op != OpS390XMOVWload {
 20430				break
 20431			}
 20432			off := x.AuxInt
 20433			sym := x.Aux
 20434			mem := x.Args[1]
 20435			ptr := x.Args[0]
 20436			if !(x.Uses == 1 && clobber(x)) {
 20437				break
 20438			}
 20439			b = x.Block
 20440			v0 := b.NewValue0(x.Pos, OpS390XMOVWZload, v.Type)
 20441			v.reset(OpCopy)
 20442			v.AddArg(v0)
 20443			v0.AuxInt = off
 20444			v0.Aux = sym
 20445			v0.AddArg(ptr)
 20446			v0.AddArg(mem)
 20447			return true
 20448		}
 20449		// match: (MOVWZreg x:(MOVWZloadidx [off] {sym} ptr idx mem))
 20450		// cond: x.Uses == 1 && clobber(x)
 20451		// result: @x.Block (MOVWZloadidx <v.Type> [off] {sym} ptr idx mem)
 20452		for {
 20453			x := v.Args[0]
 20454			if x.Op != OpS390XMOVWZloadidx {
 20455				break
 20456			}
 20457			off := x.AuxInt
 20458			sym := x.Aux
 20459			mem := x.Args[2]
 20460			ptr := x.Args[0]
 20461			idx := x.Args[1]
 20462			if !(x.Uses == 1 && clobber(x)) {
 20463				break
 20464			}
 20465			b = x.Block
 20466			v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, v.Type)
 20467			v.reset(OpCopy)
 20468			v.AddArg(v0)
 20469			v0.AuxInt = off
 20470			v0.Aux = sym
 20471			v0.AddArg(ptr)
 20472			v0.AddArg(idx)
 20473			v0.AddArg(mem)
 20474			return true
 20475		}
 20476		// match: (MOVWZreg x:(MOVWloadidx [off] {sym} ptr idx mem))
 20477		// cond: x.Uses == 1 && clobber(x)
 20478		// result: @x.Block (MOVWZloadidx <v.Type> [off] {sym} ptr idx mem)
 20479		for {
 20480			x := v.Args[0]
 20481			if x.Op != OpS390XMOVWloadidx {
 20482				break
 20483			}
 20484			off := x.AuxInt
 20485			sym := x.Aux
 20486			mem := x.Args[2]
 20487			ptr := x.Args[0]
 20488			idx := x.Args[1]
 20489			if !(x.Uses == 1 && clobber(x)) {
 20490				break
 20491			}
 20492			b = x.Block
 20493			v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, v.Type)
 20494			v.reset(OpCopy)
 20495			v.AddArg(v0)
 20496			v0.AuxInt = off
 20497			v0.Aux = sym
 20498			v0.AddArg(ptr)
 20499			v0.AddArg(idx)
 20500			v0.AddArg(mem)
 20501			return true
 20502		}
 20503		return false
 20504	}
 20505	func rewriteValueS390X_OpS390XMOVWload_0(v *Value) bool {
 20506		// match: (MOVWload [off] {sym} ptr1 (MOVWstore [off] {sym} ptr2 x _))
 20507		// cond: isSamePtr(ptr1, ptr2)
 20508		// result: (MOVWreg x)
 20509		for {
 20510			off := v.AuxInt
 20511			sym := v.Aux
 20512			_ = v.Args[1]
 20513			ptr1 := v.Args[0]
 20514			v_1 := v.Args[1]
 20515			if v_1.Op != OpS390XMOVWstore {
 20516				break
 20517			}
 20518			if v_1.AuxInt != off {
 20519				break
 20520			}
 20521			if v_1.Aux != sym {
 20522				break
 20523			}
 20524			_ = v_1.Args[2]
 20525			ptr2 := v_1.Args[0]
 20526			x := v_1.Args[1]
 20527			if !(isSamePtr(ptr1, ptr2)) {
 20528				break
 20529			}
 20530			v.reset(OpS390XMOVWreg)
 20531			v.AddArg(x)
 20532			return true
 20533		}
 20534		// match: (MOVWload [off1] {sym} (ADDconst [off2] ptr) mem)
 20535		// cond: is20Bit(off1+off2)
 20536		// result: (MOVWload [off1+off2] {sym} ptr mem)
 20537		for {
 20538			off1 := v.AuxInt
 20539			sym := v.Aux
 20540			mem := v.Args[1]
 20541			v_0 := v.Args[0]
 20542			if v_0.Op != OpS390XADDconst {
 20543				break
 20544			}
 20545			off2 := v_0.AuxInt
 20546			ptr := v_0.Args[0]
 20547			if !(is20Bit(off1 + off2)) {
 20548				break
 20549			}
 20550			v.reset(OpS390XMOVWload)
 20551			v.AuxInt = off1 + off2
 20552			v.Aux = sym
 20553			v.AddArg(ptr)
 20554			v.AddArg(mem)
 20555			return true
 20556		}
 20557		// match: (MOVWload [off1] {sym1} (MOVDaddr <t> [off2] {sym2} base) mem)
 20558		// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || (t.IsPtr() && t.Elem().Alignment()%4 == 0 && (off1+off2)%4 == 0))
 20559		// result: (MOVWload [off1+off2] {mergeSym(sym1,sym2)} base mem)
 20560		for {
 20561			off1 := v.AuxInt
 20562			sym1 := v.Aux
 20563			mem := v.Args[1]
 20564			v_0 := v.Args[0]
 20565			if v_0.Op != OpS390XMOVDaddr {
 20566				break
 20567			}
 20568			t := v_0.Type
 20569			off2 := v_0.AuxInt
 20570			sym2 := v_0.Aux
 20571			base := v_0.Args[0]
 20572			if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || (t.IsPtr() && t.Elem().Alignment()%4 == 0 && (off1+off2)%4 == 0))) {
 20573				break
 20574			}
 20575			v.reset(OpS390XMOVWload)
 20576			v.AuxInt = off1 + off2
 20577			v.Aux = mergeSym(sym1, sym2)
 20578			v.AddArg(base)
 20579			v.AddArg(mem)
 20580			return true
 20581		}
 20582		// match: (MOVWload [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) mem)
 20583		// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
 20584		// result: (MOVWloadidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem)
 20585		for {
 20586			off1 := v.AuxInt
 20587			sym1 := v.Aux
 20588			mem := v.Args[1]
 20589			v_0 := v.Args[0]
 20590			if v_0.Op != OpS390XMOVDaddridx {
 20591				break
 20592			}
 20593			off2 := v_0.AuxInt
 20594			sym2 := v_0.Aux
 20595			idx := v_0.Args[1]
 20596			ptr := v_0.Args[0]
 20597			if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
 20598				break
 20599			}
 20600			v.reset(OpS390XMOVWloadidx)
 20601			v.AuxInt = off1 + off2
 20602			v.Aux = mergeSym(sym1, sym2)
 20603			v.AddArg(ptr)
 20604			v.AddArg(idx)
 20605			v.AddArg(mem)
 20606			return true
 20607		}
 20608		// match: (MOVWload [off] {sym} (ADD ptr idx) mem)
 20609		// cond: ptr.Op != OpSB
 20610		// result: (MOVWloadidx [off] {sym} ptr idx mem)
 20611		for {
 20612			off := v.AuxInt
 20613			sym := v.Aux
 20614			mem := v.Args[1]
 20615			v_0 := v.Args[0]
 20616			if v_0.Op != OpS390XADD {
 20617				break
 20618			}
 20619			idx := v_0.Args[1]
 20620			ptr := v_0.Args[0]
 20621			if !(ptr.Op != OpSB) {
 20622				break
 20623			}
 20624			v.reset(OpS390XMOVWloadidx)
 20625			v.AuxInt = off
 20626			v.Aux = sym
 20627			v.AddArg(ptr)
 20628			v.AddArg(idx)
 20629			v.AddArg(mem)
 20630			return true
 20631		}
 20632		return false
 20633	}
 20634	func rewriteValueS390X_OpS390XMOVWloadidx_0(v *Value) bool {
 20635		// match: (MOVWloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
 20636		// cond: is20Bit(c+d)
 20637		// result: (MOVWloadidx [c+d] {sym} ptr idx mem)
 20638		for {
 20639			c := v.AuxInt
 20640			sym := v.Aux
 20641			mem := v.Args[2]
 20642			v_0 := v.Args[0]
 20643			if v_0.Op != OpS390XADDconst {
 20644				break
 20645			}
 20646			d := v_0.AuxInt
 20647			ptr := v_0.Args[0]
 20648			idx := v.Args[1]
 20649			if !(is20Bit(c + d)) {
 20650				break
 20651			}
 20652			v.reset(OpS390XMOVWloadidx)
 20653			v.AuxInt = c + d
 20654			v.Aux = sym
 20655			v.AddArg(ptr)
 20656			v.AddArg(idx)
 20657			v.AddArg(mem)
 20658			return true
 20659		}
 20660		// match: (MOVWloadidx [c] {sym} idx (ADDconst [d] ptr) mem)
 20661		// cond: is20Bit(c+d)
 20662		// result: (MOVWloadidx [c+d] {sym} ptr idx mem)
 20663		for {
 20664			c := v.AuxInt
 20665			sym := v.Aux
 20666			mem := v.Args[2]
 20667			idx := v.Args[0]
 20668			v_1 := v.Args[1]
 20669			if v_1.Op != OpS390XADDconst {
 20670				break
 20671			}
 20672			d := v_1.AuxInt
 20673			ptr := v_1.Args[0]
 20674			if !(is20Bit(c + d)) {
 20675				break
 20676			}
 20677			v.reset(OpS390XMOVWloadidx)
 20678			v.AuxInt = c + d
 20679			v.Aux = sym
 20680			v.AddArg(ptr)
 20681			v.AddArg(idx)
 20682			v.AddArg(mem)
 20683			return true
 20684		}
 20685		// match: (MOVWloadidx [c] {sym} ptr (ADDconst [d] idx) mem)
 20686		// cond: is20Bit(c+d)
 20687		// result: (MOVWloadidx [c+d] {sym} ptr idx mem)
 20688		for {
 20689			c := v.AuxInt
 20690			sym := v.Aux
 20691			mem := v.Args[2]
 20692			ptr := v.Args[0]
 20693			v_1 := v.Args[1]
 20694			if v_1.Op != OpS390XADDconst {
 20695				break
 20696			}
 20697			d := v_1.AuxInt
 20698			idx := v_1.Args[0]
 20699			if !(is20Bit(c + d)) {
 20700				break
 20701			}
 20702			v.reset(OpS390XMOVWloadidx)
 20703			v.AuxInt = c + d
 20704			v.Aux = sym
 20705			v.AddArg(ptr)
 20706			v.AddArg(idx)
 20707			v.AddArg(mem)
 20708			return true
 20709		}
 20710		// match: (MOVWloadidx [c] {sym} (ADDconst [d] idx) ptr mem)
 20711		// cond: is20Bit(c+d)
 20712		// result: (MOVWloadidx [c+d] {sym} ptr idx mem)
 20713		for {
 20714			c := v.AuxInt
 20715			sym := v.Aux
 20716			mem := v.Args[2]
 20717			v_0 := v.Args[0]
 20718			if v_0.Op != OpS390XADDconst {
 20719				break
 20720			}
 20721			d := v_0.AuxInt
 20722			idx := v_0.Args[0]
 20723			ptr := v.Args[1]
 20724			if !(is20Bit(c + d)) {
 20725				break
 20726			}
 20727			v.reset(OpS390XMOVWloadidx)
 20728			v.AuxInt = c + d
 20729			v.Aux = sym
 20730			v.AddArg(ptr)
 20731			v.AddArg(idx)
 20732			v.AddArg(mem)
 20733			return true
 20734		}
 20735		return false
 20736	}
 20737	func rewriteValueS390X_OpS390XMOVWreg_0(v *Value) bool {
 20738		// match: (MOVWreg x:(MOVBload _ _))
 20739		// cond:
 20740		// result: (MOVDreg x)
 20741		for {
 20742			x := v.Args[0]
 20743			if x.Op != OpS390XMOVBload {
 20744				break
 20745			}
 20746			_ = x.Args[1]
 20747			v.reset(OpS390XMOVDreg)
 20748			v.AddArg(x)
 20749			return true
 20750		}
 20751		// match: (MOVWreg x:(MOVBZload _ _))
 20752		// cond:
 20753		// result: (MOVDreg x)
 20754		for {
 20755			x := v.Args[0]
 20756			if x.Op != OpS390XMOVBZload {
 20757				break
 20758			}
 20759			_ = x.Args[1]
 20760			v.reset(OpS390XMOVDreg)
 20761			v.AddArg(x)
 20762			return true
 20763		}
 20764		// match: (MOVWreg x:(MOVHload _ _))
 20765		// cond:
 20766		// result: (MOVDreg x)
 20767		for {
 20768			x := v.Args[0]
 20769			if x.Op != OpS390XMOVHload {
 20770				break
 20771			}
 20772			_ = x.Args[1]
 20773			v.reset(OpS390XMOVDreg)
 20774			v.AddArg(x)
 20775			return true
 20776		}
 20777		// match: (MOVWreg x:(MOVHZload _ _))
 20778		// cond:
 20779		// result: (MOVDreg x)
 20780		for {
 20781			x := v.Args[0]
 20782			if x.Op != OpS390XMOVHZload {
 20783				break
 20784			}
 20785			_ = x.Args[1]
 20786			v.reset(OpS390XMOVDreg)
 20787			v.AddArg(x)
 20788			return true
 20789		}
 20790		// match: (MOVWreg x:(MOVWload _ _))
 20791		// cond:
 20792		// result: (MOVDreg x)
 20793		for {
 20794			x := v.Args[0]
 20795			if x.Op != OpS390XMOVWload {
 20796				break
 20797			}
 20798			_ = x.Args[1]
 20799			v.reset(OpS390XMOVDreg)
 20800			v.AddArg(x)
 20801			return true
 20802		}
 20803		// match: (MOVWreg x:(Arg <t>))
 20804		// cond: (is8BitInt(t) || is16BitInt(t) || is32BitInt(t)) && isSigned(t)
 20805		// result: (MOVDreg x)
 20806		for {
 20807			x := v.Args[0]
 20808			if x.Op != OpArg {
 20809				break
 20810			}
 20811			t := x.Type
 20812			if !((is8BitInt(t) || is16BitInt(t) || is32BitInt(t)) && isSigned(t)) {
 20813				break
 20814			}
 20815			v.reset(OpS390XMOVDreg)
 20816			v.AddArg(x)
 20817			return true
 20818		}
 20819		// match: (MOVWreg x:(MOVBreg _))
 20820		// cond:
 20821		// result: (MOVDreg x)
 20822		for {
 20823			x := v.Args[0]
 20824			if x.Op != OpS390XMOVBreg {
 20825				break
 20826			}
 20827			v.reset(OpS390XMOVDreg)
 20828			v.AddArg(x)
 20829			return true
 20830		}
 20831		// match: (MOVWreg x:(MOVBZreg _))
 20832		// cond:
 20833		// result: (MOVDreg x)
 20834		for {
 20835			x := v.Args[0]
 20836			if x.Op != OpS390XMOVBZreg {
 20837				break
 20838			}
 20839			v.reset(OpS390XMOVDreg)
 20840			v.AddArg(x)
 20841			return true
 20842		}
 20843		// match: (MOVWreg x:(MOVHreg _))
 20844		// cond:
 20845		// result: (MOVDreg x)
 20846		for {
 20847			x := v.Args[0]
 20848			if x.Op != OpS390XMOVHreg {
 20849				break
 20850			}
 20851			v.reset(OpS390XMOVDreg)
 20852			v.AddArg(x)
 20853			return true
 20854		}
 20855		// match: (MOVWreg x:(MOVHZreg _))
 20856		// cond:
 20857		// result: (MOVDreg x)
 20858		for {
 20859			x := v.Args[0]
 20860			if x.Op != OpS390XMOVHZreg {
 20861				break
 20862			}
 20863			v.reset(OpS390XMOVDreg)
 20864			v.AddArg(x)
 20865			return true
 20866		}
 20867		return false
 20868	}
 20869	func rewriteValueS390X_OpS390XMOVWreg_10(v *Value) bool {
 20870		b := v.Block
 20871		// match: (MOVWreg x:(MOVWreg _))
 20872		// cond:
 20873		// result: (MOVDreg x)
 20874		for {
 20875			x := v.Args[0]
 20876			if x.Op != OpS390XMOVWreg {
 20877				break
 20878			}
 20879			v.reset(OpS390XMOVDreg)
 20880			v.AddArg(x)
 20881			return true
 20882		}
 20883		// match: (MOVWreg (MOVWZreg x))
 20884		// cond:
 20885		// result: (MOVWreg x)
 20886		for {
 20887			v_0 := v.Args[0]
 20888			if v_0.Op != OpS390XMOVWZreg {
 20889				break
 20890			}
 20891			x := v_0.Args[0]
 20892			v.reset(OpS390XMOVWreg)
 20893			v.AddArg(x)
 20894			return true
 20895		}
 20896		// match: (MOVWreg (MOVDconst [c]))
 20897		// cond:
 20898		// result: (MOVDconst [int64(int32(c))])
 20899		for {
 20900			v_0 := v.Args[0]
 20901			if v_0.Op != OpS390XMOVDconst {
 20902				break
 20903			}
 20904			c := v_0.AuxInt
 20905			v.reset(OpS390XMOVDconst)
 20906			v.AuxInt = int64(int32(c))
 20907			return true
 20908		}
 20909		// match: (MOVWreg x:(MOVWZload [off] {sym} ptr mem))
 20910		// cond: x.Uses == 1 && clobber(x)
 20911		// result: @x.Block (MOVWload <v.Type> [off] {sym} ptr mem)
 20912		for {
 20913			x := v.Args[0]
 20914			if x.Op != OpS390XMOVWZload {
 20915				break
 20916			}
 20917			off := x.AuxInt
 20918			sym := x.Aux
 20919			mem := x.Args[1]
 20920			ptr := x.Args[0]
 20921			if !(x.Uses == 1 && clobber(x)) {
 20922				break
 20923			}
 20924			b = x.Block
 20925			v0 := b.NewValue0(x.Pos, OpS390XMOVWload, v.Type)
 20926			v.reset(OpCopy)
 20927			v.AddArg(v0)
 20928			v0.AuxInt = off
 20929			v0.Aux = sym
 20930			v0.AddArg(ptr)
 20931			v0.AddArg(mem)
 20932			return true
 20933		}
 20934		// match: (MOVWreg x:(MOVWload [off] {sym} ptr mem))
 20935		// cond: x.Uses == 1 && clobber(x)
 20936		// result: @x.Block (MOVWload <v.Type> [off] {sym} ptr mem)
 20937		for {
 20938			x := v.Args[0]
 20939			if x.Op != OpS390XMOVWload {
 20940				break
 20941			}
 20942			off := x.AuxInt
 20943			sym := x.Aux
 20944			mem := x.Args[1]
 20945			ptr := x.Args[0]
 20946			if !(x.Uses == 1 && clobber(x)) {
 20947				break
 20948			}
 20949			b = x.Block
 20950			v0 := b.NewValue0(x.Pos, OpS390XMOVWload, v.Type)
 20951			v.reset(OpCopy)
 20952			v.AddArg(v0)
 20953			v0.AuxInt = off
 20954			v0.Aux = sym
 20955			v0.AddArg(ptr)
 20956			v0.AddArg(mem)
 20957			return true
 20958		}
 20959		// match: (MOVWreg x:(MOVWZloadidx [off] {sym} ptr idx mem))
 20960		// cond: x.Uses == 1 && clobber(x)
 20961		// result: @x.Block (MOVWloadidx <v.Type> [off] {sym} ptr idx mem)
 20962		for {
 20963			x := v.Args[0]
 20964			if x.Op != OpS390XMOVWZloadidx {
 20965				break
 20966			}
 20967			off := x.AuxInt
 20968			sym := x.Aux
 20969			mem := x.Args[2]
 20970			ptr := x.Args[0]
 20971			idx := x.Args[1]
 20972			if !(x.Uses == 1 && clobber(x)) {
 20973				break
 20974			}
 20975			b = x.Block
 20976			v0 := b.NewValue0(v.Pos, OpS390XMOVWloadidx, v.Type)
 20977			v.reset(OpCopy)
 20978			v.AddArg(v0)
 20979			v0.AuxInt = off
 20980			v0.Aux = sym
 20981			v0.AddArg(ptr)
 20982			v0.AddArg(idx)
 20983			v0.AddArg(mem)
 20984			return true
 20985		}
 20986		// match: (MOVWreg x:(MOVWloadidx [off] {sym} ptr idx mem))
 20987		// cond: x.Uses == 1 && clobber(x)
 20988		// result: @x.Block (MOVWloadidx <v.Type> [off] {sym} ptr idx mem)
 20989		for {
 20990			x := v.Args[0]
 20991			if x.Op != OpS390XMOVWloadidx {
 20992				break
 20993			}
 20994			off := x.AuxInt
 20995			sym := x.Aux
 20996			mem := x.Args[2]
 20997			ptr := x.Args[0]
 20998			idx := x.Args[1]
 20999			if !(x.Uses == 1 && clobber(x)) {
 21000				break
 21001			}
 21002			b = x.Block
 21003			v0 := b.NewValue0(v.Pos, OpS390XMOVWloadidx, v.Type)
 21004			v.reset(OpCopy)
 21005			v.AddArg(v0)
 21006			v0.AuxInt = off
 21007			v0.Aux = sym
 21008			v0.AddArg(ptr)
 21009			v0.AddArg(idx)
 21010			v0.AddArg(mem)
 21011			return true
 21012		}
 21013		return false
 21014	}
 21015	func rewriteValueS390X_OpS390XMOVWstore_0(v *Value) bool {
 21016		// match: (MOVWstore [off] {sym} ptr (MOVWreg x) mem)
 21017		// cond:
 21018		// result: (MOVWstore [off] {sym} ptr x mem)
 21019		for {
 21020			off := v.AuxInt
 21021			sym := v.Aux
 21022			mem := v.Args[2]
 21023			ptr := v.Args[0]
 21024			v_1 := v.Args[1]
 21025			if v_1.Op != OpS390XMOVWreg {
 21026				break
 21027			}
 21028			x := v_1.Args[0]
 21029			v.reset(OpS390XMOVWstore)
 21030			v.AuxInt = off
 21031			v.Aux = sym
 21032			v.AddArg(ptr)
 21033			v.AddArg(x)
 21034			v.AddArg(mem)
 21035			return true
 21036		}
 21037		// match: (MOVWstore [off] {sym} ptr (MOVWZreg x) mem)
 21038		// cond:
 21039		// result: (MOVWstore [off] {sym} ptr x mem)
 21040		for {
 21041			off := v.AuxInt
 21042			sym := v.Aux
 21043			mem := v.Args[2]
 21044			ptr := v.Args[0]
 21045			v_1 := v.Args[1]
 21046			if v_1.Op != OpS390XMOVWZreg {
 21047				break
 21048			}
 21049			x := v_1.Args[0]
 21050			v.reset(OpS390XMOVWstore)
 21051			v.AuxInt = off
 21052			v.Aux = sym
 21053			v.AddArg(ptr)
 21054			v.AddArg(x)
 21055			v.AddArg(mem)
 21056			return true
 21057		}
 21058		// match: (MOVWstore [off1] {sym} (ADDconst [off2] ptr) val mem)
 21059		// cond: is20Bit(off1+off2)
 21060		// result: (MOVWstore [off1+off2] {sym} ptr val mem)
 21061		for {
 21062			off1 := v.AuxInt
 21063			sym := v.Aux
 21064			mem := v.Args[2]
 21065			v_0 := v.Args[0]
 21066			if v_0.Op != OpS390XADDconst {
 21067				break
 21068			}
 21069			off2 := v_0.AuxInt
 21070			ptr := v_0.Args[0]
 21071			val := v.Args[1]
 21072			if !(is20Bit(off1 + off2)) {
 21073				break
 21074			}
 21075			v.reset(OpS390XMOVWstore)
 21076			v.AuxInt = off1 + off2
 21077			v.Aux = sym
 21078			v.AddArg(ptr)
 21079			v.AddArg(val)
 21080			v.AddArg(mem)
 21081			return true
 21082		}
 21083		// match: (MOVWstore [off] {sym} ptr (MOVDconst [c]) mem)
 21084		// cond: is16Bit(c) && isU12Bit(off) && ptr.Op != OpSB
 21085		// result: (MOVWstoreconst [makeValAndOff(int64(int32(c)),off)] {sym} ptr mem)
 21086		for {
 21087			off := v.AuxInt
 21088			sym := v.Aux
 21089			mem := v.Args[2]
 21090			ptr := v.Args[0]
 21091			v_1 := v.Args[1]
 21092			if v_1.Op != OpS390XMOVDconst {
 21093				break
 21094			}
 21095			c := v_1.AuxInt
 21096			if !(is16Bit(c) && isU12Bit(off) && ptr.Op != OpSB) {
 21097				break
 21098			}
 21099			v.reset(OpS390XMOVWstoreconst)
 21100			v.AuxInt = makeValAndOff(int64(int32(c)), off)
 21101			v.Aux = sym
 21102			v.AddArg(ptr)
 21103			v.AddArg(mem)
 21104			return true
 21105		}
 21106		// match: (MOVWstore [off1] {sym1} (MOVDaddr <t> [off2] {sym2} base) val mem)
 21107		// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || (t.IsPtr() && t.Elem().Alignment()%4 == 0 && (off1+off2)%4 == 0))
 21108		// result: (MOVWstore [off1+off2] {mergeSym(sym1,sym2)} base val mem)
 21109		for {
 21110			off1 := v.AuxInt
 21111			sym1 := v.Aux
 21112			mem := v.Args[2]
 21113			v_0 := v.Args[0]
 21114			if v_0.Op != OpS390XMOVDaddr {
 21115				break
 21116			}
 21117			t := v_0.Type
 21118			off2 := v_0.AuxInt
 21119			sym2 := v_0.Aux
 21120			base := v_0.Args[0]
 21121			val := v.Args[1]
 21122			if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || (t.IsPtr() && t.Elem().Alignment()%4 == 0 && (off1+off2)%4 == 0))) {
 21123				break
 21124			}
 21125			v.reset(OpS390XMOVWstore)
 21126			v.AuxInt = off1 + off2
 21127			v.Aux = mergeSym(sym1, sym2)
 21128			v.AddArg(base)
 21129			v.AddArg(val)
 21130			v.AddArg(mem)
 21131			return true
 21132		}
 21133		// match: (MOVWstore [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) val mem)
 21134		// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
 21135		// result: (MOVWstoreidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx val mem)
 21136		for {
 21137			off1 := v.AuxInt
 21138			sym1 := v.Aux
 21139			mem := v.Args[2]
 21140			v_0 := v.Args[0]
 21141			if v_0.Op != OpS390XMOVDaddridx {
 21142				break
 21143			}
 21144			off2 := v_0.AuxInt
 21145			sym2 := v_0.Aux
 21146			idx := v_0.Args[1]
 21147			ptr := v_0.Args[0]
 21148			val := v.Args[1]
 21149			if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
 21150				break
 21151			}
 21152			v.reset(OpS390XMOVWstoreidx)
 21153			v.AuxInt = off1 + off2
 21154			v.Aux = mergeSym(sym1, sym2)
 21155			v.AddArg(ptr)
 21156			v.AddArg(idx)
 21157			v.AddArg(val)
 21158			v.AddArg(mem)
 21159			return true
 21160		}
 21161		// match: (MOVWstore [off] {sym} (ADD ptr idx) val mem)
 21162		// cond: ptr.Op != OpSB
 21163		// result: (MOVWstoreidx [off] {sym} ptr idx val mem)
 21164		for {
 21165			off := v.AuxInt
 21166			sym := v.Aux
 21167			mem := v.Args[2]
 21168			v_0 := v.Args[0]
 21169			if v_0.Op != OpS390XADD {
 21170				break
 21171			}
 21172			idx := v_0.Args[1]
 21173			ptr := v_0.Args[0]
 21174			val := v.Args[1]
 21175			if !(ptr.Op != OpSB) {
 21176				break
 21177			}
 21178			v.reset(OpS390XMOVWstoreidx)
 21179			v.AuxInt = off
 21180			v.Aux = sym
 21181			v.AddArg(ptr)
 21182			v.AddArg(idx)
 21183			v.AddArg(val)
 21184			v.AddArg(mem)
 21185			return true
 21186		}
 21187		// match: (MOVWstore [i] {s} p (SRDconst [32] w) x:(MOVWstore [i-4] {s} p w mem))
 21188		// cond: p.Op != OpSB && x.Uses == 1 && clobber(x)
 21189		// result: (MOVDstore [i-4] {s} p w mem)
 21190		for {
 21191			i := v.AuxInt
 21192			s := v.Aux
 21193			_ = v.Args[2]
 21194			p := v.Args[0]
 21195			v_1 := v.Args[1]
 21196			if v_1.Op != OpS390XSRDconst {
 21197				break
 21198			}
 21199			if v_1.AuxInt != 32 {
 21200				break
 21201			}
 21202			w := v_1.Args[0]
 21203			x := v.Args[2]
 21204			if x.Op != OpS390XMOVWstore {
 21205				break
 21206			}
 21207			if x.AuxInt != i-4 {
 21208				break
 21209			}
 21210			if x.Aux != s {
 21211				break
 21212			}
 21213			mem := x.Args[2]
 21214			if p != x.Args[0] {
 21215				break
 21216			}
 21217			if w != x.Args[1] {
 21218				break
 21219			}
 21220			if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
 21221				break
 21222			}
 21223			v.reset(OpS390XMOVDstore)
 21224			v.AuxInt = i - 4
 21225			v.Aux = s
 21226			v.AddArg(p)
 21227			v.AddArg(w)
 21228			v.AddArg(mem)
 21229			return true
 21230		}
 21231		// match: (MOVWstore [i] {s} p w0:(SRDconst [j] w) x:(MOVWstore [i-4] {s} p (SRDconst [j+32] w) mem))
 21232		// cond: p.Op != OpSB && x.Uses == 1 && clobber(x)
 21233		// result: (MOVDstore [i-4] {s} p w0 mem)
 21234		for {
 21235			i := v.AuxInt
 21236			s := v.Aux
 21237			_ = v.Args[2]
 21238			p := v.Args[0]
 21239			w0 := v.Args[1]
 21240			if w0.Op != OpS390XSRDconst {
 21241				break
 21242			}
 21243			j := w0.AuxInt
 21244			w := w0.Args[0]
 21245			x := v.Args[2]
 21246			if x.Op != OpS390XMOVWstore {
 21247				break
 21248			}
 21249			if x.AuxInt != i-4 {
 21250				break
 21251			}
 21252			if x.Aux != s {
 21253				break
 21254			}
 21255			mem := x.Args[2]
 21256			if p != x.Args[0] {
 21257				break
 21258			}
 21259			x_1 := x.Args[1]
 21260			if x_1.Op != OpS390XSRDconst {
 21261				break
 21262			}
 21263			if x_1.AuxInt != j+32 {
 21264				break
 21265			}
 21266			if w != x_1.Args[0] {
 21267				break
 21268			}
 21269			if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
 21270				break
 21271			}
 21272			v.reset(OpS390XMOVDstore)
 21273			v.AuxInt = i - 4
 21274			v.Aux = s
 21275			v.AddArg(p)
 21276			v.AddArg(w0)
 21277			v.AddArg(mem)
 21278			return true
 21279		}
 21280		// match: (MOVWstore [i] {s} p w1 x:(MOVWstore [i-4] {s} p w0 mem))
 21281		// cond: p.Op != OpSB && x.Uses == 1 && is20Bit(i-4) && clobber(x)
 21282		// result: (STM2 [i-4] {s} p w0 w1 mem)
 21283		for {
 21284			i := v.AuxInt
 21285			s := v.Aux
 21286			_ = v.Args[2]
 21287			p := v.Args[0]
 21288			w1 := v.Args[1]
 21289			x := v.Args[2]
 21290			if x.Op != OpS390XMOVWstore {
 21291				break
 21292			}
 21293			if x.AuxInt != i-4 {
 21294				break
 21295			}
 21296			if x.Aux != s {
 21297				break
 21298			}
 21299			mem := x.Args[2]
 21300			if p != x.Args[0] {
 21301				break
 21302			}
 21303			w0 := x.Args[1]
 21304			if !(p.Op != OpSB && x.Uses == 1 && is20Bit(i-4) && clobber(x)) {
 21305				break
 21306			}
 21307			v.reset(OpS390XSTM2)
 21308			v.AuxInt = i - 4
 21309			v.Aux = s
 21310			v.AddArg(p)
 21311			v.AddArg(w0)
 21312			v.AddArg(w1)
 21313			v.AddArg(mem)
 21314			return true
 21315		}
 21316		return false
 21317	}
 21318	func rewriteValueS390X_OpS390XMOVWstore_10(v *Value) bool {
 21319		// match: (MOVWstore [i] {s} p w2 x:(STM2 [i-8] {s} p w0 w1 mem))
 21320		// cond: x.Uses == 1 && is20Bit(i-8) && clobber(x)
 21321		// result: (STM3 [i-8] {s} p w0 w1 w2 mem)
 21322		for {
 21323			i := v.AuxInt
 21324			s := v.Aux
 21325			_ = v.Args[2]
 21326			p := v.Args[0]
 21327			w2 := v.Args[1]
 21328			x := v.Args[2]
 21329			if x.Op != OpS390XSTM2 {
 21330				break
 21331			}
 21332			if x.AuxInt != i-8 {
 21333				break
 21334			}
 21335			if x.Aux != s {
 21336				break
 21337			}
 21338			mem := x.Args[3]
 21339			if p != x.Args[0] {
 21340				break
 21341			}
 21342			w0 := x.Args[1]
 21343			w1 := x.Args[2]
 21344			if !(x.Uses == 1 && is20Bit(i-8) && clobber(x)) {
 21345				break
 21346			}
 21347			v.reset(OpS390XSTM3)
 21348			v.AuxInt = i - 8
 21349			v.Aux = s
 21350			v.AddArg(p)
 21351			v.AddArg(w0)
 21352			v.AddArg(w1)
 21353			v.AddArg(w2)
 21354			v.AddArg(mem)
 21355			return true
 21356		}
 21357		// match: (MOVWstore [i] {s} p w3 x:(STM3 [i-12] {s} p w0 w1 w2 mem))
 21358		// cond: x.Uses == 1 && is20Bit(i-12) && clobber(x)
 21359		// result: (STM4 [i-12] {s} p w0 w1 w2 w3 mem)
 21360		for {
 21361			i := v.AuxInt
 21362			s := v.Aux
 21363			_ = v.Args[2]
 21364			p := v.Args[0]
 21365			w3 := v.Args[1]
 21366			x := v.Args[2]
 21367			if x.Op != OpS390XSTM3 {
 21368				break
 21369			}
 21370			if x.AuxInt != i-12 {
 21371				break
 21372			}
 21373			if x.Aux != s {
 21374				break
 21375			}
 21376			mem := x.Args[4]
 21377			if p != x.Args[0] {
 21378				break
 21379			}
 21380			w0 := x.Args[1]
 21381			w1 := x.Args[2]
 21382			w2 := x.Args[3]
 21383			if !(x.Uses == 1 && is20Bit(i-12) && clobber(x)) {
 21384				break
 21385			}
 21386			v.reset(OpS390XSTM4)
 21387			v.AuxInt = i - 12
 21388			v.Aux = s
 21389			v.AddArg(p)
 21390			v.AddArg(w0)
 21391			v.AddArg(w1)
 21392			v.AddArg(w2)
 21393			v.AddArg(w3)
 21394			v.AddArg(mem)
 21395			return true
 21396		}
 21397		return false
 21398	}
 21399	func rewriteValueS390X_OpS390XMOVWstoreconst_0(v *Value) bool {
 21400		b := v.Block
 21401		typ := &b.Func.Config.Types
 21402		// match: (MOVWstoreconst [sc] {s} (ADDconst [off] ptr) mem)
 21403		// cond: isU12Bit(ValAndOff(sc).Off()+off)
 21404		// result: (MOVWstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
 21405		for {
 21406			sc := v.AuxInt
 21407			s := v.Aux
 21408			mem := v.Args[1]
 21409			v_0 := v.Args[0]
 21410			if v_0.Op != OpS390XADDconst {
 21411				break
 21412			}
 21413			off := v_0.AuxInt
 21414			ptr := v_0.Args[0]
 21415			if !(isU12Bit(ValAndOff(sc).Off() + off)) {
 21416				break
 21417			}
 21418			v.reset(OpS390XMOVWstoreconst)
 21419			v.AuxInt = ValAndOff(sc).add(off)
 21420			v.Aux = s
 21421			v.AddArg(ptr)
 21422			v.AddArg(mem)
 21423			return true
 21424		}
 21425		// match: (MOVWstoreconst [sc] {sym1} (MOVDaddr [off] {sym2} ptr) mem)
 21426		// cond: ptr.Op != OpSB && canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)
 21427		// result: (MOVWstoreconst [ValAndOff(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem)
 21428		for {
 21429			sc := v.AuxInt
 21430			sym1 := v.Aux
 21431			mem := v.Args[1]
 21432			v_0 := v.Args[0]
 21433			if v_0.Op != OpS390XMOVDaddr {
 21434				break
 21435			}
 21436			off := v_0.AuxInt
 21437			sym2 := v_0.Aux
 21438			ptr := v_0.Args[0]
 21439			if !(ptr.Op != OpSB && canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)) {
 21440				break
 21441			}
 21442			v.reset(OpS390XMOVWstoreconst)
 21443			v.AuxInt = ValAndOff(sc).add(off)
 21444			v.Aux = mergeSym(sym1, sym2)
 21445			v.AddArg(ptr)
 21446			v.AddArg(mem)
 21447			return true
 21448		}
 21449		// match: (MOVWstoreconst [c] {s} p x:(MOVWstoreconst [a] {s} p mem))
 21450		// cond: p.Op != OpSB && x.Uses == 1 && ValAndOff(a).Off() + 4 == ValAndOff(c).Off() && clobber(x)
 21451		// result: (MOVDstore [ValAndOff(a).Off()] {s} p (MOVDconst [ValAndOff(c).Val()&0xffffffff | ValAndOff(a).Val()<<32]) mem)
 21452		for {
 21453			c := v.AuxInt
 21454			s := v.Aux
 21455			_ = v.Args[1]
 21456			p := v.Args[0]
 21457			x := v.Args[1]
 21458			if x.Op != OpS390XMOVWstoreconst {
 21459				break
 21460			}
 21461			a := x.AuxInt
 21462			if x.Aux != s {
 21463				break
 21464			}
 21465			mem := x.Args[1]
 21466			if p != x.Args[0] {
 21467				break
 21468			}
 21469			if !(p.Op != OpSB && x.Uses == 1 && ValAndOff(a).Off()+4 == ValAndOff(c).Off() && clobber(x)) {
 21470				break
 21471			}
 21472			v.reset(OpS390XMOVDstore)
 21473			v.AuxInt = ValAndOff(a).Off()
 21474			v.Aux = s
 21475			v.AddArg(p)
 21476			v0 := b.NewValue0(x.Pos, OpS390XMOVDconst, typ.UInt64)
 21477			v0.AuxInt = ValAndOff(c).Val()&0xffffffff | ValAndOff(a).Val()<<32
 21478			v.AddArg(v0)
 21479			v.AddArg(mem)
 21480			return true
 21481		}
 21482		return false
 21483	}
 21484	func rewriteValueS390X_OpS390XMOVWstoreidx_0(v *Value) bool {
 21485		// match: (MOVWstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem)
 21486		// cond: is20Bit(c+d)
 21487		// result: (MOVWstoreidx [c+d] {sym} ptr idx val mem)
 21488		for {
 21489			c := v.AuxInt
 21490			sym := v.Aux
 21491			mem := v.Args[3]
 21492			v_0 := v.Args[0]
 21493			if v_0.Op != OpS390XADDconst {
 21494				break
 21495			}
 21496			d := v_0.AuxInt
 21497			ptr := v_0.Args[0]
 21498			idx := v.Args[1]
 21499			val := v.Args[2]
 21500			if !(is20Bit(c + d)) {
 21501				break
 21502			}
 21503			v.reset(OpS390XMOVWstoreidx)
 21504			v.AuxInt = c + d
 21505			v.Aux = sym
 21506			v.AddArg(ptr)
 21507			v.AddArg(idx)
 21508			v.AddArg(val)
 21509			v.AddArg(mem)
 21510			return true
 21511		}
 21512		// match: (MOVWstoreidx [c] {sym} idx (ADDconst [d] ptr) val mem)
 21513		// cond: is20Bit(c+d)
 21514		// result: (MOVWstoreidx [c+d] {sym} ptr idx val mem)
 21515		for {
 21516			c := v.AuxInt
 21517			sym := v.Aux
 21518			mem := v.Args[3]
 21519			idx := v.Args[0]
 21520			v_1 := v.Args[1]
 21521			if v_1.Op != OpS390XADDconst {
 21522				break
 21523			}
 21524			d := v_1.AuxInt
 21525			ptr := v_1.Args[0]
 21526			val := v.Args[2]
 21527			if !(is20Bit(c + d)) {
 21528				break
 21529			}
 21530			v.reset(OpS390XMOVWstoreidx)
 21531			v.AuxInt = c + d
 21532			v.Aux = sym
 21533			v.AddArg(ptr)
 21534			v.AddArg(idx)
 21535			v.AddArg(val)
 21536			v.AddArg(mem)
 21537			return true
 21538		}
 21539		// match: (MOVWstoreidx [c] {sym} ptr (ADDconst [d] idx) val mem)
 21540		// cond: is20Bit(c+d)
 21541		// result: (MOVWstoreidx [c+d] {sym} ptr idx val mem)
 21542		for {
 21543			c := v.AuxInt
 21544			sym := v.Aux
 21545			mem := v.Args[3]
 21546			ptr := v.Args[0]
 21547			v_1 := v.Args[1]
 21548			if v_1.Op != OpS390XADDconst {
 21549				break
 21550			}
 21551			d := v_1.AuxInt
 21552			idx := v_1.Args[0]
 21553			val := v.Args[2]
 21554			if !(is20Bit(c + d)) {
 21555				break
 21556			}
 21557			v.reset(OpS390XMOVWstoreidx)
 21558			v.AuxInt = c + d
 21559			v.Aux = sym
 21560			v.AddArg(ptr)
 21561			v.AddArg(idx)
 21562			v.AddArg(val)
 21563			v.AddArg(mem)
 21564			return true
 21565		}
 21566		// match: (MOVWstoreidx [c] {sym} (ADDconst [d] idx) ptr val mem)
 21567		// cond: is20Bit(c+d)
 21568		// result: (MOVWstoreidx [c+d] {sym} ptr idx val mem)
 21569		for {
 21570			c := v.AuxInt
 21571			sym := v.Aux
 21572			mem := v.Args[3]
 21573			v_0 := v.Args[0]
 21574			if v_0.Op != OpS390XADDconst {
 21575				break
 21576			}
 21577			d := v_0.AuxInt
 21578			idx := v_0.Args[0]
 21579			ptr := v.Args[1]
 21580			val := v.Args[2]
 21581			if !(is20Bit(c + d)) {
 21582				break
 21583			}
 21584			v.reset(OpS390XMOVWstoreidx)
 21585			v.AuxInt = c + d
 21586			v.Aux = sym
 21587			v.AddArg(ptr)
 21588			v.AddArg(idx)
 21589			v.AddArg(val)
 21590			v.AddArg(mem)
 21591			return true
 21592		}
 21593		// match: (MOVWstoreidx [i] {s} p idx w x:(MOVWstoreidx [i-4] {s} p idx (SRDconst [32] w) mem))
 21594		// cond: x.Uses == 1 && clobber(x)
 21595		// result: (MOVDstoreidx [i-4] {s} p idx w mem)
 21596		for {
 21597			i := v.AuxInt
 21598			s := v.Aux
 21599			_ = v.Args[3]
 21600			p := v.Args[0]
 21601			idx := v.Args[1]
 21602			w := v.Args[2]
 21603			x := v.Args[3]
 21604			if x.Op != OpS390XMOVWstoreidx {
 21605				break
 21606			}
 21607			if x.AuxInt != i-4 {
 21608				break
 21609			}
 21610			if x.Aux != s {
 21611				break
 21612			}
 21613			mem := x.Args[3]
 21614			if p != x.Args[0] {
 21615				break
 21616			}
 21617			if idx != x.Args[1] {
 21618				break
 21619			}
 21620			x_2 := x.Args[2]
 21621			if x_2.Op != OpS390XSRDconst {
 21622				break
 21623			}
 21624			if x_2.AuxInt != 32 {
 21625				break
 21626			}
 21627			if w != x_2.Args[0] {
 21628				break
 21629			}
 21630			if !(x.Uses == 1 && clobber(x)) {
 21631				break
 21632			}
 21633			v.reset(OpS390XMOVDstoreidx)
 21634			v.AuxInt = i - 4
 21635			v.Aux = s
 21636			v.AddArg(p)
 21637			v.AddArg(idx)
 21638			v.AddArg(w)
 21639			v.AddArg(mem)
 21640			return true
 21641		}
 21642		// match: (MOVWstoreidx [i] {s} p idx w x:(MOVWstoreidx [i-4] {s} idx p (SRDconst [32] w) mem))
 21643		// cond: x.Uses == 1 && clobber(x)
 21644		// result: (MOVDstoreidx [i-4] {s} p idx w mem)
 21645		for {
 21646			i := v.AuxInt
 21647			s := v.Aux
 21648			_ = v.Args[3]
 21649			p := v.Args[0]
 21650			idx := v.Args[1]
 21651			w := v.Args[2]
 21652			x := v.Args[3]
 21653			if x.Op != OpS390XMOVWstoreidx {
 21654				break
 21655			}
 21656			if x.AuxInt != i-4 {
 21657				break
 21658			}
 21659			if x.Aux != s {
 21660				break
 21661			}
 21662			mem := x.Args[3]
 21663			if idx != x.Args[0] {
 21664				break
 21665			}
 21666			if p != x.Args[1] {
 21667				break
 21668			}
 21669			x_2 := x.Args[2]
 21670			if x_2.Op != OpS390XSRDconst {
 21671				break
 21672			}
 21673			if x_2.AuxInt != 32 {
 21674				break
 21675			}
 21676			if w != x_2.Args[0] {
 21677				break
 21678			}
 21679			if !(x.Uses == 1 && clobber(x)) {
 21680				break
 21681			}
 21682			v.reset(OpS390XMOVDstoreidx)
 21683			v.AuxInt = i - 4
 21684			v.Aux = s
 21685			v.AddArg(p)
 21686			v.AddArg(idx)
 21687			v.AddArg(w)
 21688			v.AddArg(mem)
 21689			return true
 21690		}
 21691		// match: (MOVWstoreidx [i] {s} idx p w x:(MOVWstoreidx [i-4] {s} p idx (SRDconst [32] w) mem))
 21692		// cond: x.Uses == 1 && clobber(x)
 21693		// result: (MOVDstoreidx [i-4] {s} p idx w mem)
 21694		for {
 21695			i := v.AuxInt
 21696			s := v.Aux
 21697			_ = v.Args[3]
 21698			idx := v.Args[0]
 21699			p := v.Args[1]
 21700			w := v.Args[2]
 21701			x := v.Args[3]
 21702			if x.Op != OpS390XMOVWstoreidx {
 21703				break
 21704			}
 21705			if x.AuxInt != i-4 {
 21706				break
 21707			}
 21708			if x.Aux != s {
 21709				break
 21710			}
 21711			mem := x.Args[3]
 21712			if p != x.Args[0] {
 21713				break
 21714			}
 21715			if idx != x.Args[1] {
 21716				break
 21717			}
 21718			x_2 := x.Args[2]
 21719			if x_2.Op != OpS390XSRDconst {
 21720				break
 21721			}
 21722			if x_2.AuxInt != 32 {
 21723				break
 21724			}
 21725			if w != x_2.Args[0] {
 21726				break
 21727			}
 21728			if !(x.Uses == 1 && clobber(x)) {
 21729				break
 21730			}
 21731			v.reset(OpS390XMOVDstoreidx)
 21732			v.AuxInt = i - 4
 21733			v.Aux = s
 21734			v.AddArg(p)
 21735			v.AddArg(idx)
 21736			v.AddArg(w)
 21737			v.AddArg(mem)
 21738			return true
 21739		}
 21740		// match: (MOVWstoreidx [i] {s} idx p w x:(MOVWstoreidx [i-4] {s} idx p (SRDconst [32] w) mem))
 21741		// cond: x.Uses == 1 && clobber(x)
 21742		// result: (MOVDstoreidx [i-4] {s} p idx w mem)
 21743		for {
 21744			i := v.AuxInt
 21745			s := v.Aux
 21746			_ = v.Args[3]
 21747			idx := v.Args[0]
 21748			p := v.Args[1]
 21749			w := v.Args[2]
 21750			x := v.Args[3]
 21751			if x.Op != OpS390XMOVWstoreidx {
 21752				break
 21753			}
 21754			if x.AuxInt != i-4 {
 21755				break
 21756			}
 21757			if x.Aux != s {
 21758				break
 21759			}
 21760			mem := x.Args[3]
 21761			if idx != x.Args[0] {
 21762				break
 21763			}
 21764			if p != x.Args[1] {
 21765				break
 21766			}
 21767			x_2 := x.Args[2]
 21768			if x_2.Op != OpS390XSRDconst {
 21769				break
 21770			}
 21771			if x_2.AuxInt != 32 {
 21772				break
 21773			}
 21774			if w != x_2.Args[0] {
 21775				break
 21776			}
 21777			if !(x.Uses == 1 && clobber(x)) {
 21778				break
 21779			}
 21780			v.reset(OpS390XMOVDstoreidx)
 21781			v.AuxInt = i - 4
 21782			v.Aux = s
 21783			v.AddArg(p)
 21784			v.AddArg(idx)
 21785			v.AddArg(w)
 21786			v.AddArg(mem)
 21787			return true
 21788		}
 21789		// match: (MOVWstoreidx [i] {s} p idx w0:(SRDconst [j] w) x:(MOVWstoreidx [i-4] {s} p idx (SRDconst [j+32] w) mem))
 21790		// cond: x.Uses == 1 && clobber(x)
 21791		// result: (MOVDstoreidx [i-4] {s} p idx w0 mem)
 21792		for {
 21793			i := v.AuxInt
 21794			s := v.Aux
 21795			_ = v.Args[3]
 21796			p := v.Args[0]
 21797			idx := v.Args[1]
 21798			w0 := v.Args[2]
 21799			if w0.Op != OpS390XSRDconst {
 21800				break
 21801			}
 21802			j := w0.AuxInt
 21803			w := w0.Args[0]
 21804			x := v.Args[3]
 21805			if x.Op != OpS390XMOVWstoreidx {
 21806				break
 21807			}
 21808			if x.AuxInt != i-4 {
 21809				break
 21810			}
 21811			if x.Aux != s {
 21812				break
 21813			}
 21814			mem := x.Args[3]
 21815			if p != x.Args[0] {
 21816				break
 21817			}
 21818			if idx != x.Args[1] {
 21819				break
 21820			}
 21821			x_2 := x.Args[2]
 21822			if x_2.Op != OpS390XSRDconst {
 21823				break
 21824			}
 21825			if x_2.AuxInt != j+32 {
 21826				break
 21827			}
 21828			if w != x_2.Args[0] {
 21829				break
 21830			}
 21831			if !(x.Uses == 1 && clobber(x)) {
 21832				break
 21833			}
 21834			v.reset(OpS390XMOVDstoreidx)
 21835			v.AuxInt = i - 4
 21836			v.Aux = s
 21837			v.AddArg(p)
 21838			v.AddArg(idx)
 21839			v.AddArg(w0)
 21840			v.AddArg(mem)
 21841			return true
 21842		}
 21843		// match: (MOVWstoreidx [i] {s} p idx w0:(SRDconst [j] w) x:(MOVWstoreidx [i-4] {s} idx p (SRDconst [j+32] w) mem))
 21844		// cond: x.Uses == 1 && clobber(x)
 21845		// result: (MOVDstoreidx [i-4] {s} p idx w0 mem)
 21846		for {
 21847			i := v.AuxInt
 21848			s := v.Aux
 21849			_ = v.Args[3]
 21850			p := v.Args[0]
 21851			idx := v.Args[1]
 21852			w0 := v.Args[2]
 21853			if w0.Op != OpS390XSRDconst {
 21854				break
 21855			}
 21856			j := w0.AuxInt
 21857			w := w0.Args[0]
 21858			x := v.Args[3]
 21859			if x.Op != OpS390XMOVWstoreidx {
 21860				break
 21861			}
 21862			if x.AuxInt != i-4 {
 21863				break
 21864			}
 21865			if x.Aux != s {
 21866				break
 21867			}
 21868			mem := x.Args[3]
 21869			if idx != x.Args[0] {
 21870				break
 21871			}
 21872			if p != x.Args[1] {
 21873				break
 21874			}
 21875			x_2 := x.Args[2]
 21876			if x_2.Op != OpS390XSRDconst {
 21877				break
 21878			}
 21879			if x_2.AuxInt != j+32 {
 21880				break
 21881			}
 21882			if w != x_2.Args[0] {
 21883				break
 21884			}
 21885			if !(x.Uses == 1 && clobber(x)) {
 21886				break
 21887			}
 21888			v.reset(OpS390XMOVDstoreidx)
 21889			v.AuxInt = i - 4
 21890			v.Aux = s
 21891			v.AddArg(p)
 21892			v.AddArg(idx)
 21893			v.AddArg(w0)
 21894			v.AddArg(mem)
 21895			return true
 21896		}
 21897		return false
 21898	}
 21899	func rewriteValueS390X_OpS390XMOVWstoreidx_10(v *Value) bool {
 21900		// match: (MOVWstoreidx [i] {s} idx p w0:(SRDconst [j] w) x:(MOVWstoreidx [i-4] {s} p idx (SRDconst [j+32] w) mem))
 21901		// cond: x.Uses == 1 && clobber(x)
 21902		// result: (MOVDstoreidx [i-4] {s} p idx w0 mem)
 21903		for {
 21904			i := v.AuxInt
 21905			s := v.Aux
 21906			_ = v.Args[3]
 21907			idx := v.Args[0]
 21908			p := v.Args[1]
 21909			w0 := v.Args[2]
 21910			if w0.Op != OpS390XSRDconst {
 21911				break
 21912			}
 21913			j := w0.AuxInt
 21914			w := w0.Args[0]
 21915			x := v.Args[3]
 21916			if x.Op != OpS390XMOVWstoreidx {
 21917				break
 21918			}
 21919			if x.AuxInt != i-4 {
 21920				break
 21921			}
 21922			if x.Aux != s {
 21923				break
 21924			}
 21925			mem := x.Args[3]
 21926			if p != x.Args[0] {
 21927				break
 21928			}
 21929			if idx != x.Args[1] {
 21930				break
 21931			}
 21932			x_2 := x.Args[2]
 21933			if x_2.Op != OpS390XSRDconst {
 21934				break
 21935			}
 21936			if x_2.AuxInt != j+32 {
 21937				break
 21938			}
 21939			if w != x_2.Args[0] {
 21940				break
 21941			}
 21942			if !(x.Uses == 1 && clobber(x)) {
 21943				break
 21944			}
 21945			v.reset(OpS390XMOVDstoreidx)
 21946			v.AuxInt = i - 4
 21947			v.Aux = s
 21948			v.AddArg(p)
 21949			v.AddArg(idx)
 21950			v.AddArg(w0)
 21951			v.AddArg(mem)
 21952			return true
 21953		}
 21954		// match: (MOVWstoreidx [i] {s} idx p w0:(SRDconst [j] w) x:(MOVWstoreidx [i-4] {s} idx p (SRDconst [j+32] w) mem))
 21955		// cond: x.Uses == 1 && clobber(x)
 21956		// result: (MOVDstoreidx [i-4] {s} p idx w0 mem)
 21957		for {
 21958			i := v.AuxInt
 21959			s := v.Aux
 21960			_ = v.Args[3]
 21961			idx := v.Args[0]
 21962			p := v.Args[1]
 21963			w0 := v.Args[2]
 21964			if w0.Op != OpS390XSRDconst {
 21965				break
 21966			}
 21967			j := w0.AuxInt
 21968			w := w0.Args[0]
 21969			x := v.Args[3]
 21970			if x.Op != OpS390XMOVWstoreidx {
 21971				break
 21972			}
 21973			if x.AuxInt != i-4 {
 21974				break
 21975			}
 21976			if x.Aux != s {
 21977				break
 21978			}
 21979			mem := x.Args[3]
 21980			if idx != x.Args[0] {
 21981				break
 21982			}
 21983			if p != x.Args[1] {
 21984				break
 21985			}
 21986			x_2 := x.Args[2]
 21987			if x_2.Op != OpS390XSRDconst {
 21988				break
 21989			}
 21990			if x_2.AuxInt != j+32 {
 21991				break
 21992			}
 21993			if w != x_2.Args[0] {
 21994				break
 21995			}
 21996			if !(x.Uses == 1 && clobber(x)) {
 21997				break
 21998			}
 21999			v.reset(OpS390XMOVDstoreidx)
 22000			v.AuxInt = i - 4
 22001			v.Aux = s
 22002			v.AddArg(p)
 22003			v.AddArg(idx)
 22004			v.AddArg(w0)
 22005			v.AddArg(mem)
 22006			return true
 22007		}
 22008		return false
 22009	}
 22010	func rewriteValueS390X_OpS390XMULLD_0(v *Value) bool {
 22011		// match: (MULLD x (MOVDconst [c]))
 22012		// cond: is32Bit(c)
 22013		// result: (MULLDconst [c] x)
 22014		for {
 22015			_ = v.Args[1]
 22016			x := v.Args[0]
 22017			v_1 := v.Args[1]
 22018			if v_1.Op != OpS390XMOVDconst {
 22019				break
 22020			}
 22021			c := v_1.AuxInt
 22022			if !(is32Bit(c)) {
 22023				break
 22024			}
 22025			v.reset(OpS390XMULLDconst)
 22026			v.AuxInt = c
 22027			v.AddArg(x)
 22028			return true
 22029		}
 22030		// match: (MULLD (MOVDconst [c]) x)
 22031		// cond: is32Bit(c)
 22032		// result: (MULLDconst [c] x)
 22033		for {
 22034			x := v.Args[1]
 22035			v_0 := v.Args[0]
 22036			if v_0.Op != OpS390XMOVDconst {
 22037				break
 22038			}
 22039			c := v_0.AuxInt
 22040			if !(is32Bit(c)) {
 22041				break
 22042			}
 22043			v.reset(OpS390XMULLDconst)
 22044			v.AuxInt = c
 22045			v.AddArg(x)
 22046			return true
 22047		}
 22048		// match: (MULLD <t> x g:(MOVDload [off] {sym} ptr mem))
 22049		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 22050		// result: (MULLDload <t> [off] {sym} x ptr mem)
 22051		for {
 22052			t := v.Type
 22053			_ = v.Args[1]
 22054			x := v.Args[0]
 22055			g := v.Args[1]
 22056			if g.Op != OpS390XMOVDload {
 22057				break
 22058			}
 22059			off := g.AuxInt
 22060			sym := g.Aux
 22061			mem := g.Args[1]
 22062			ptr := g.Args[0]
 22063			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 22064				break
 22065			}
 22066			v.reset(OpS390XMULLDload)
 22067			v.Type = t
 22068			v.AuxInt = off
 22069			v.Aux = sym
 22070			v.AddArg(x)
 22071			v.AddArg(ptr)
 22072			v.AddArg(mem)
 22073			return true
 22074		}
 22075		// match: (MULLD <t> g:(MOVDload [off] {sym} ptr mem) x)
 22076		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 22077		// result: (MULLDload <t> [off] {sym} x ptr mem)
 22078		for {
 22079			t := v.Type
 22080			x := v.Args[1]
 22081			g := v.Args[0]
 22082			if g.Op != OpS390XMOVDload {
 22083				break
 22084			}
 22085			off := g.AuxInt
 22086			sym := g.Aux
 22087			mem := g.Args[1]
 22088			ptr := g.Args[0]
 22089			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 22090				break
 22091			}
 22092			v.reset(OpS390XMULLDload)
 22093			v.Type = t
 22094			v.AuxInt = off
 22095			v.Aux = sym
 22096			v.AddArg(x)
 22097			v.AddArg(ptr)
 22098			v.AddArg(mem)
 22099			return true
 22100		}
 22101		// match: (MULLD <t> g:(MOVDload [off] {sym} ptr mem) x)
 22102		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 22103		// result: (MULLDload <t> [off] {sym} x ptr mem)
 22104		for {
 22105			t := v.Type
 22106			x := v.Args[1]
 22107			g := v.Args[0]
 22108			if g.Op != OpS390XMOVDload {
 22109				break
 22110			}
 22111			off := g.AuxInt
 22112			sym := g.Aux
 22113			mem := g.Args[1]
 22114			ptr := g.Args[0]
 22115			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 22116				break
 22117			}
 22118			v.reset(OpS390XMULLDload)
 22119			v.Type = t
 22120			v.AuxInt = off
 22121			v.Aux = sym
 22122			v.AddArg(x)
 22123			v.AddArg(ptr)
 22124			v.AddArg(mem)
 22125			return true
 22126		}
 22127		// match: (MULLD <t> x g:(MOVDload [off] {sym} ptr mem))
 22128		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 22129		// result: (MULLDload <t> [off] {sym} x ptr mem)
 22130		for {
 22131			t := v.Type
 22132			_ = v.Args[1]
 22133			x := v.Args[0]
 22134			g := v.Args[1]
 22135			if g.Op != OpS390XMOVDload {
 22136				break
 22137			}
 22138			off := g.AuxInt
 22139			sym := g.Aux
 22140			mem := g.Args[1]
 22141			ptr := g.Args[0]
 22142			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 22143				break
 22144			}
 22145			v.reset(OpS390XMULLDload)
 22146			v.Type = t
 22147			v.AuxInt = off
 22148			v.Aux = sym
 22149			v.AddArg(x)
 22150			v.AddArg(ptr)
 22151			v.AddArg(mem)
 22152			return true
 22153		}
 22154		return false
 22155	}
 22156	func rewriteValueS390X_OpS390XMULLDconst_0(v *Value) bool {
 22157		b := v.Block
 22158		// match: (MULLDconst [-1] x)
 22159		// cond:
 22160		// result: (NEG x)
 22161		for {
 22162			if v.AuxInt != -1 {
 22163				break
 22164			}
 22165			x := v.Args[0]
 22166			v.reset(OpS390XNEG)
 22167			v.AddArg(x)
 22168			return true
 22169		}
 22170		// match: (MULLDconst [0] _)
 22171		// cond:
 22172		// result: (MOVDconst [0])
 22173		for {
 22174			if v.AuxInt != 0 {
 22175				break
 22176			}
 22177			v.reset(OpS390XMOVDconst)
 22178			v.AuxInt = 0
 22179			return true
 22180		}
 22181		// match: (MULLDconst [1] x)
 22182		// cond:
 22183		// result: x
 22184		for {
 22185			if v.AuxInt != 1 {
 22186				break
 22187			}
 22188			x := v.Args[0]
 22189			v.reset(OpCopy)
 22190			v.Type = x.Type
 22191			v.AddArg(x)
 22192			return true
 22193		}
 22194		// match: (MULLDconst [c] x)
 22195		// cond: isPowerOfTwo(c)
 22196		// result: (SLDconst [log2(c)] x)
 22197		for {
 22198			c := v.AuxInt
 22199			x := v.Args[0]
 22200			if !(isPowerOfTwo(c)) {
 22201				break
 22202			}
 22203			v.reset(OpS390XSLDconst)
 22204			v.AuxInt = log2(c)
 22205			v.AddArg(x)
 22206			return true
 22207		}
 22208		// match: (MULLDconst [c] x)
 22209		// cond: isPowerOfTwo(c+1) && c >= 15
 22210		// result: (SUB (SLDconst <v.Type> [log2(c+1)] x) x)
 22211		for {
 22212			c := v.AuxInt
 22213			x := v.Args[0]
 22214			if !(isPowerOfTwo(c+1) && c >= 15) {
 22215				break
 22216			}
 22217			v.reset(OpS390XSUB)
 22218			v0 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 22219			v0.AuxInt = log2(c + 1)
 22220			v0.AddArg(x)
 22221			v.AddArg(v0)
 22222			v.AddArg(x)
 22223			return true
 22224		}
 22225		// match: (MULLDconst [c] x)
 22226		// cond: isPowerOfTwo(c-1) && c >= 17
 22227		// result: (ADD (SLDconst <v.Type> [log2(c-1)] x) x)
 22228		for {
 22229			c := v.AuxInt
 22230			x := v.Args[0]
 22231			if !(isPowerOfTwo(c-1) && c >= 17) {
 22232				break
 22233			}
 22234			v.reset(OpS390XADD)
 22235			v0 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 22236			v0.AuxInt = log2(c - 1)
 22237			v0.AddArg(x)
 22238			v.AddArg(v0)
 22239			v.AddArg(x)
 22240			return true
 22241		}
 22242		// match: (MULLDconst [c] (MOVDconst [d]))
 22243		// cond:
 22244		// result: (MOVDconst [c*d])
 22245		for {
 22246			c := v.AuxInt
 22247			v_0 := v.Args[0]
 22248			if v_0.Op != OpS390XMOVDconst {
 22249				break
 22250			}
 22251			d := v_0.AuxInt
 22252			v.reset(OpS390XMOVDconst)
 22253			v.AuxInt = c * d
 22254			return true
 22255		}
 22256		return false
 22257	}
 22258	func rewriteValueS390X_OpS390XMULLDload_0(v *Value) bool {
 22259		b := v.Block
 22260		// match: (MULLDload <t> [off] {sym} x ptr1 (FMOVDstore [off] {sym} ptr2 y _))
 22261		// cond: isSamePtr(ptr1, ptr2)
 22262		// result: (MULLD x (LGDR <t> y))
 22263		for {
 22264			t := v.Type
 22265			off := v.AuxInt
 22266			sym := v.Aux
 22267			_ = v.Args[2]
 22268			x := v.Args[0]
 22269			ptr1 := v.Args[1]
 22270			v_2 := v.Args[2]
 22271			if v_2.Op != OpS390XFMOVDstore {
 22272				break
 22273			}
 22274			if v_2.AuxInt != off {
 22275				break
 22276			}
 22277			if v_2.Aux != sym {
 22278				break
 22279			}
 22280			_ = v_2.Args[2]
 22281			ptr2 := v_2.Args[0]
 22282			y := v_2.Args[1]
 22283			if !(isSamePtr(ptr1, ptr2)) {
 22284				break
 22285			}
 22286			v.reset(OpS390XMULLD)
 22287			v.AddArg(x)
 22288			v0 := b.NewValue0(v_2.Pos, OpS390XLGDR, t)
 22289			v0.AddArg(y)
 22290			v.AddArg(v0)
 22291			return true
 22292		}
 22293		// match: (MULLDload [off1] {sym} x (ADDconst [off2] ptr) mem)
 22294		// cond: ptr.Op != OpSB && is20Bit(off1+off2)
 22295		// result: (MULLDload [off1+off2] {sym} x ptr mem)
 22296		for {
 22297			off1 := v.AuxInt
 22298			sym := v.Aux
 22299			mem := v.Args[2]
 22300			x := v.Args[0]
 22301			v_1 := v.Args[1]
 22302			if v_1.Op != OpS390XADDconst {
 22303				break
 22304			}
 22305			off2 := v_1.AuxInt
 22306			ptr := v_1.Args[0]
 22307			if !(ptr.Op != OpSB && is20Bit(off1+off2)) {
 22308				break
 22309			}
 22310			v.reset(OpS390XMULLDload)
 22311			v.AuxInt = off1 + off2
 22312			v.Aux = sym
 22313			v.AddArg(x)
 22314			v.AddArg(ptr)
 22315			v.AddArg(mem)
 22316			return true
 22317		}
 22318		// match: (MULLDload [o1] {s1} x (MOVDaddr [o2] {s2} ptr) mem)
 22319		// cond: ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)
 22320		// result: (MULLDload [o1+o2] {mergeSym(s1, s2)} x ptr mem)
 22321		for {
 22322			o1 := v.AuxInt
 22323			s1 := v.Aux
 22324			mem := v.Args[2]
 22325			x := v.Args[0]
 22326			v_1 := v.Args[1]
 22327			if v_1.Op != OpS390XMOVDaddr {
 22328				break
 22329			}
 22330			o2 := v_1.AuxInt
 22331			s2 := v_1.Aux
 22332			ptr := v_1.Args[0]
 22333			if !(ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)) {
 22334				break
 22335			}
 22336			v.reset(OpS390XMULLDload)
 22337			v.AuxInt = o1 + o2
 22338			v.Aux = mergeSym(s1, s2)
 22339			v.AddArg(x)
 22340			v.AddArg(ptr)
 22341			v.AddArg(mem)
 22342			return true
 22343		}
 22344		return false
 22345	}
 22346	func rewriteValueS390X_OpS390XMULLW_0(v *Value) bool {
 22347		// match: (MULLW x (MOVDconst [c]))
 22348		// cond:
 22349		// result: (MULLWconst [int64(int32(c))] x)
 22350		for {
 22351			_ = v.Args[1]
 22352			x := v.Args[0]
 22353			v_1 := v.Args[1]
 22354			if v_1.Op != OpS390XMOVDconst {
 22355				break
 22356			}
 22357			c := v_1.AuxInt
 22358			v.reset(OpS390XMULLWconst)
 22359			v.AuxInt = int64(int32(c))
 22360			v.AddArg(x)
 22361			return true
 22362		}
 22363		// match: (MULLW (MOVDconst [c]) x)
 22364		// cond:
 22365		// result: (MULLWconst [int64(int32(c))] x)
 22366		for {
 22367			x := v.Args[1]
 22368			v_0 := v.Args[0]
 22369			if v_0.Op != OpS390XMOVDconst {
 22370				break
 22371			}
 22372			c := v_0.AuxInt
 22373			v.reset(OpS390XMULLWconst)
 22374			v.AuxInt = int64(int32(c))
 22375			v.AddArg(x)
 22376			return true
 22377		}
 22378		// match: (MULLW <t> x g:(MOVWload [off] {sym} ptr mem))
 22379		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 22380		// result: (MULLWload <t> [off] {sym} x ptr mem)
 22381		for {
 22382			t := v.Type
 22383			_ = v.Args[1]
 22384			x := v.Args[0]
 22385			g := v.Args[1]
 22386			if g.Op != OpS390XMOVWload {
 22387				break
 22388			}
 22389			off := g.AuxInt
 22390			sym := g.Aux
 22391			mem := g.Args[1]
 22392			ptr := g.Args[0]
 22393			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 22394				break
 22395			}
 22396			v.reset(OpS390XMULLWload)
 22397			v.Type = t
 22398			v.AuxInt = off
 22399			v.Aux = sym
 22400			v.AddArg(x)
 22401			v.AddArg(ptr)
 22402			v.AddArg(mem)
 22403			return true
 22404		}
 22405		// match: (MULLW <t> g:(MOVWload [off] {sym} ptr mem) x)
 22406		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 22407		// result: (MULLWload <t> [off] {sym} x ptr mem)
 22408		for {
 22409			t := v.Type
 22410			x := v.Args[1]
 22411			g := v.Args[0]
 22412			if g.Op != OpS390XMOVWload {
 22413				break
 22414			}
 22415			off := g.AuxInt
 22416			sym := g.Aux
 22417			mem := g.Args[1]
 22418			ptr := g.Args[0]
 22419			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 22420				break
 22421			}
 22422			v.reset(OpS390XMULLWload)
 22423			v.Type = t
 22424			v.AuxInt = off
 22425			v.Aux = sym
 22426			v.AddArg(x)
 22427			v.AddArg(ptr)
 22428			v.AddArg(mem)
 22429			return true
 22430		}
 22431		// match: (MULLW <t> g:(MOVWload [off] {sym} ptr mem) x)
 22432		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 22433		// result: (MULLWload <t> [off] {sym} x ptr mem)
 22434		for {
 22435			t := v.Type
 22436			x := v.Args[1]
 22437			g := v.Args[0]
 22438			if g.Op != OpS390XMOVWload {
 22439				break
 22440			}
 22441			off := g.AuxInt
 22442			sym := g.Aux
 22443			mem := g.Args[1]
 22444			ptr := g.Args[0]
 22445			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 22446				break
 22447			}
 22448			v.reset(OpS390XMULLWload)
 22449			v.Type = t
 22450			v.AuxInt = off
 22451			v.Aux = sym
 22452			v.AddArg(x)
 22453			v.AddArg(ptr)
 22454			v.AddArg(mem)
 22455			return true
 22456		}
 22457		// match: (MULLW <t> x g:(MOVWload [off] {sym} ptr mem))
 22458		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 22459		// result: (MULLWload <t> [off] {sym} x ptr mem)
 22460		for {
 22461			t := v.Type
 22462			_ = v.Args[1]
 22463			x := v.Args[0]
 22464			g := v.Args[1]
 22465			if g.Op != OpS390XMOVWload {
 22466				break
 22467			}
 22468			off := g.AuxInt
 22469			sym := g.Aux
 22470			mem := g.Args[1]
 22471			ptr := g.Args[0]
 22472			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 22473				break
 22474			}
 22475			v.reset(OpS390XMULLWload)
 22476			v.Type = t
 22477			v.AuxInt = off
 22478			v.Aux = sym
 22479			v.AddArg(x)
 22480			v.AddArg(ptr)
 22481			v.AddArg(mem)
 22482			return true
 22483		}
 22484		// match: (MULLW <t> x g:(MOVWZload [off] {sym} ptr mem))
 22485		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 22486		// result: (MULLWload <t> [off] {sym} x ptr mem)
 22487		for {
 22488			t := v.Type
 22489			_ = v.Args[1]
 22490			x := v.Args[0]
 22491			g := v.Args[1]
 22492			if g.Op != OpS390XMOVWZload {
 22493				break
 22494			}
 22495			off := g.AuxInt
 22496			sym := g.Aux
 22497			mem := g.Args[1]
 22498			ptr := g.Args[0]
 22499			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 22500				break
 22501			}
 22502			v.reset(OpS390XMULLWload)
 22503			v.Type = t
 22504			v.AuxInt = off
 22505			v.Aux = sym
 22506			v.AddArg(x)
 22507			v.AddArg(ptr)
 22508			v.AddArg(mem)
 22509			return true
 22510		}
 22511		// match: (MULLW <t> g:(MOVWZload [off] {sym} ptr mem) x)
 22512		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 22513		// result: (MULLWload <t> [off] {sym} x ptr mem)
 22514		for {
 22515			t := v.Type
 22516			x := v.Args[1]
 22517			g := v.Args[0]
 22518			if g.Op != OpS390XMOVWZload {
 22519				break
 22520			}
 22521			off := g.AuxInt
 22522			sym := g.Aux
 22523			mem := g.Args[1]
 22524			ptr := g.Args[0]
 22525			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 22526				break
 22527			}
 22528			v.reset(OpS390XMULLWload)
 22529			v.Type = t
 22530			v.AuxInt = off
 22531			v.Aux = sym
 22532			v.AddArg(x)
 22533			v.AddArg(ptr)
 22534			v.AddArg(mem)
 22535			return true
 22536		}
 22537		// match: (MULLW <t> g:(MOVWZload [off] {sym} ptr mem) x)
 22538		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 22539		// result: (MULLWload <t> [off] {sym} x ptr mem)
 22540		for {
 22541			t := v.Type
 22542			x := v.Args[1]
 22543			g := v.Args[0]
 22544			if g.Op != OpS390XMOVWZload {
 22545				break
 22546			}
 22547			off := g.AuxInt
 22548			sym := g.Aux
 22549			mem := g.Args[1]
 22550			ptr := g.Args[0]
 22551			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 22552				break
 22553			}
 22554			v.reset(OpS390XMULLWload)
 22555			v.Type = t
 22556			v.AuxInt = off
 22557			v.Aux = sym
 22558			v.AddArg(x)
 22559			v.AddArg(ptr)
 22560			v.AddArg(mem)
 22561			return true
 22562		}
 22563		// match: (MULLW <t> x g:(MOVWZload [off] {sym} ptr mem))
 22564		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 22565		// result: (MULLWload <t> [off] {sym} x ptr mem)
 22566		for {
 22567			t := v.Type
 22568			_ = v.Args[1]
 22569			x := v.Args[0]
 22570			g := v.Args[1]
 22571			if g.Op != OpS390XMOVWZload {
 22572				break
 22573			}
 22574			off := g.AuxInt
 22575			sym := g.Aux
 22576			mem := g.Args[1]
 22577			ptr := g.Args[0]
 22578			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 22579				break
 22580			}
 22581			v.reset(OpS390XMULLWload)
 22582			v.Type = t
 22583			v.AuxInt = off
 22584			v.Aux = sym
 22585			v.AddArg(x)
 22586			v.AddArg(ptr)
 22587			v.AddArg(mem)
 22588			return true
 22589		}
 22590		return false
 22591	}
 22592	func rewriteValueS390X_OpS390XMULLWconst_0(v *Value) bool {
 22593		b := v.Block
 22594		// match: (MULLWconst [-1] x)
 22595		// cond:
 22596		// result: (NEGW x)
 22597		for {
 22598			if v.AuxInt != -1 {
 22599				break
 22600			}
 22601			x := v.Args[0]
 22602			v.reset(OpS390XNEGW)
 22603			v.AddArg(x)
 22604			return true
 22605		}
 22606		// match: (MULLWconst [0] _)
 22607		// cond:
 22608		// result: (MOVDconst [0])
 22609		for {
 22610			if v.AuxInt != 0 {
 22611				break
 22612			}
 22613			v.reset(OpS390XMOVDconst)
 22614			v.AuxInt = 0
 22615			return true
 22616		}
 22617		// match: (MULLWconst [1] x)
 22618		// cond:
 22619		// result: x
 22620		for {
 22621			if v.AuxInt != 1 {
 22622				break
 22623			}
 22624			x := v.Args[0]
 22625			v.reset(OpCopy)
 22626			v.Type = x.Type
 22627			v.AddArg(x)
 22628			return true
 22629		}
 22630		// match: (MULLWconst [c] x)
 22631		// cond: isPowerOfTwo(c)
 22632		// result: (SLWconst [log2(c)] x)
 22633		for {
 22634			c := v.AuxInt
 22635			x := v.Args[0]
 22636			if !(isPowerOfTwo(c)) {
 22637				break
 22638			}
 22639			v.reset(OpS390XSLWconst)
 22640			v.AuxInt = log2(c)
 22641			v.AddArg(x)
 22642			return true
 22643		}
 22644		// match: (MULLWconst [c] x)
 22645		// cond: isPowerOfTwo(c+1) && c >= 15
 22646		// result: (SUBW (SLWconst <v.Type> [log2(c+1)] x) x)
 22647		for {
 22648			c := v.AuxInt
 22649			x := v.Args[0]
 22650			if !(isPowerOfTwo(c+1) && c >= 15) {
 22651				break
 22652			}
 22653			v.reset(OpS390XSUBW)
 22654			v0 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
 22655			v0.AuxInt = log2(c + 1)
 22656			v0.AddArg(x)
 22657			v.AddArg(v0)
 22658			v.AddArg(x)
 22659			return true
 22660		}
 22661		// match: (MULLWconst [c] x)
 22662		// cond: isPowerOfTwo(c-1) && c >= 17
 22663		// result: (ADDW (SLWconst <v.Type> [log2(c-1)] x) x)
 22664		for {
 22665			c := v.AuxInt
 22666			x := v.Args[0]
 22667			if !(isPowerOfTwo(c-1) && c >= 17) {
 22668				break
 22669			}
 22670			v.reset(OpS390XADDW)
 22671			v0 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
 22672			v0.AuxInt = log2(c - 1)
 22673			v0.AddArg(x)
 22674			v.AddArg(v0)
 22675			v.AddArg(x)
 22676			return true
 22677		}
 22678		// match: (MULLWconst [c] (MOVDconst [d]))
 22679		// cond:
 22680		// result: (MOVDconst [int64(int32(c*d))])
 22681		for {
 22682			c := v.AuxInt
 22683			v_0 := v.Args[0]
 22684			if v_0.Op != OpS390XMOVDconst {
 22685				break
 22686			}
 22687			d := v_0.AuxInt
 22688			v.reset(OpS390XMOVDconst)
 22689			v.AuxInt = int64(int32(c * d))
 22690			return true
 22691		}
 22692		return false
 22693	}
 22694	func rewriteValueS390X_OpS390XMULLWload_0(v *Value) bool {
 22695		// match: (MULLWload [off1] {sym} x (ADDconst [off2] ptr) mem)
 22696		// cond: ptr.Op != OpSB && is20Bit(off1+off2)
 22697		// result: (MULLWload [off1+off2] {sym} x ptr mem)
 22698		for {
 22699			off1 := v.AuxInt
 22700			sym := v.Aux
 22701			mem := v.Args[2]
 22702			x := v.Args[0]
 22703			v_1 := v.Args[1]
 22704			if v_1.Op != OpS390XADDconst {
 22705				break
 22706			}
 22707			off2 := v_1.AuxInt
 22708			ptr := v_1.Args[0]
 22709			if !(ptr.Op != OpSB && is20Bit(off1+off2)) {
 22710				break
 22711			}
 22712			v.reset(OpS390XMULLWload)
 22713			v.AuxInt = off1 + off2
 22714			v.Aux = sym
 22715			v.AddArg(x)
 22716			v.AddArg(ptr)
 22717			v.AddArg(mem)
 22718			return true
 22719		}
 22720		// match: (MULLWload [o1] {s1} x (MOVDaddr [o2] {s2} ptr) mem)
 22721		// cond: ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)
 22722		// result: (MULLWload [o1+o2] {mergeSym(s1, s2)} x ptr mem)
 22723		for {
 22724			o1 := v.AuxInt
 22725			s1 := v.Aux
 22726			mem := v.Args[2]
 22727			x := v.Args[0]
 22728			v_1 := v.Args[1]
 22729			if v_1.Op != OpS390XMOVDaddr {
 22730				break
 22731			}
 22732			o2 := v_1.AuxInt
 22733			s2 := v_1.Aux
 22734			ptr := v_1.Args[0]
 22735			if !(ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)) {
 22736				break
 22737			}
 22738			v.reset(OpS390XMULLWload)
 22739			v.AuxInt = o1 + o2
 22740			v.Aux = mergeSym(s1, s2)
 22741			v.AddArg(x)
 22742			v.AddArg(ptr)
 22743			v.AddArg(mem)
 22744			return true
 22745		}
 22746		return false
 22747	}
 22748	func rewriteValueS390X_OpS390XNEG_0(v *Value) bool {
 22749		// match: (NEG (MOVDconst [c]))
 22750		// cond:
 22751		// result: (MOVDconst [-c])
 22752		for {
 22753			v_0 := v.Args[0]
 22754			if v_0.Op != OpS390XMOVDconst {
 22755				break
 22756			}
 22757			c := v_0.AuxInt
 22758			v.reset(OpS390XMOVDconst)
 22759			v.AuxInt = -c
 22760			return true
 22761		}
 22762		// match: (NEG (ADDconst [c] (NEG x)))
 22763		// cond: c != -(1<<31)
 22764		// result: (ADDconst [-c] x)
 22765		for {
 22766			v_0 := v.Args[0]
 22767			if v_0.Op != OpS390XADDconst {
 22768				break
 22769			}
 22770			c := v_0.AuxInt
 22771			v_0_0 := v_0.Args[0]
 22772			if v_0_0.Op != OpS390XNEG {
 22773				break
 22774			}
 22775			x := v_0_0.Args[0]
 22776			if !(c != -(1 << 31)) {
 22777				break
 22778			}
 22779			v.reset(OpS390XADDconst)
 22780			v.AuxInt = -c
 22781			v.AddArg(x)
 22782			return true
 22783		}
 22784		return false
 22785	}
 22786	func rewriteValueS390X_OpS390XNEGW_0(v *Value) bool {
 22787		// match: (NEGW (MOVDconst [c]))
 22788		// cond:
 22789		// result: (MOVDconst [int64(int32(-c))])
 22790		for {
 22791			v_0 := v.Args[0]
 22792			if v_0.Op != OpS390XMOVDconst {
 22793				break
 22794			}
 22795			c := v_0.AuxInt
 22796			v.reset(OpS390XMOVDconst)
 22797			v.AuxInt = int64(int32(-c))
 22798			return true
 22799		}
 22800		return false
 22801	}
 22802	func rewriteValueS390X_OpS390XNOT_0(v *Value) bool {
 22803		b := v.Block
 22804		typ := &b.Func.Config.Types
 22805		// match: (NOT x)
 22806		// cond: true
 22807		// result: (XOR (MOVDconst [-1]) x)
 22808		for {
 22809			x := v.Args[0]
 22810			if !(true) {
 22811				break
 22812			}
 22813			v.reset(OpS390XXOR)
 22814			v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
 22815			v0.AuxInt = -1
 22816			v.AddArg(v0)
 22817			v.AddArg(x)
 22818			return true
 22819		}
 22820		return false
 22821	}
 22822	func rewriteValueS390X_OpS390XNOTW_0(v *Value) bool {
 22823		// match: (NOTW x)
 22824		// cond: true
 22825		// result: (XORWconst [-1] x)
 22826		for {
 22827			x := v.Args[0]
 22828			if !(true) {
 22829				break
 22830			}
 22831			v.reset(OpS390XXORWconst)
 22832			v.AuxInt = -1
 22833			v.AddArg(x)
 22834			return true
 22835		}
 22836		return false
 22837	}
 22838	func rewriteValueS390X_OpS390XOR_0(v *Value) bool {
 22839		b := v.Block
 22840		// match: (OR x (MOVDconst [c]))
 22841		// cond: isU32Bit(c)
 22842		// result: (ORconst [c] x)
 22843		for {
 22844			_ = v.Args[1]
 22845			x := v.Args[0]
 22846			v_1 := v.Args[1]
 22847			if v_1.Op != OpS390XMOVDconst {
 22848				break
 22849			}
 22850			c := v_1.AuxInt
 22851			if !(isU32Bit(c)) {
 22852				break
 22853			}
 22854			v.reset(OpS390XORconst)
 22855			v.AuxInt = c
 22856			v.AddArg(x)
 22857			return true
 22858		}
 22859		// match: (OR (MOVDconst [c]) x)
 22860		// cond: isU32Bit(c)
 22861		// result: (ORconst [c] x)
 22862		for {
 22863			x := v.Args[1]
 22864			v_0 := v.Args[0]
 22865			if v_0.Op != OpS390XMOVDconst {
 22866				break
 22867			}
 22868			c := v_0.AuxInt
 22869			if !(isU32Bit(c)) {
 22870				break
 22871			}
 22872			v.reset(OpS390XORconst)
 22873			v.AuxInt = c
 22874			v.AddArg(x)
 22875			return true
 22876		}
 22877		// match: (OR (SLDconst x [c]) (SRDconst x [d]))
 22878		// cond: d == 64-c
 22879		// result: (RLLGconst [c] x)
 22880		for {
 22881			_ = v.Args[1]
 22882			v_0 := v.Args[0]
 22883			if v_0.Op != OpS390XSLDconst {
 22884				break
 22885			}
 22886			c := v_0.AuxInt
 22887			x := v_0.Args[0]
 22888			v_1 := v.Args[1]
 22889			if v_1.Op != OpS390XSRDconst {
 22890				break
 22891			}
 22892			d := v_1.AuxInt
 22893			if x != v_1.Args[0] {
 22894				break
 22895			}
 22896			if !(d == 64-c) {
 22897				break
 22898			}
 22899			v.reset(OpS390XRLLGconst)
 22900			v.AuxInt = c
 22901			v.AddArg(x)
 22902			return true
 22903		}
 22904		// match: (OR (SRDconst x [d]) (SLDconst x [c]))
 22905		// cond: d == 64-c
 22906		// result: (RLLGconst [c] x)
 22907		for {
 22908			_ = v.Args[1]
 22909			v_0 := v.Args[0]
 22910			if v_0.Op != OpS390XSRDconst {
 22911				break
 22912			}
 22913			d := v_0.AuxInt
 22914			x := v_0.Args[0]
 22915			v_1 := v.Args[1]
 22916			if v_1.Op != OpS390XSLDconst {
 22917				break
 22918			}
 22919			c := v_1.AuxInt
 22920			if x != v_1.Args[0] {
 22921				break
 22922			}
 22923			if !(d == 64-c) {
 22924				break
 22925			}
 22926			v.reset(OpS390XRLLGconst)
 22927			v.AuxInt = c
 22928			v.AddArg(x)
 22929			return true
 22930		}
 22931		// match: (OR (MOVDconst [-1<<63]) (LGDR <t> x))
 22932		// cond:
 22933		// result: (LGDR <t> (LNDFR <x.Type> x))
 22934		for {
 22935			_ = v.Args[1]
 22936			v_0 := v.Args[0]
 22937			if v_0.Op != OpS390XMOVDconst {
 22938				break
 22939			}
 22940			if v_0.AuxInt != -1<<63 {
 22941				break
 22942			}
 22943			v_1 := v.Args[1]
 22944			if v_1.Op != OpS390XLGDR {
 22945				break
 22946			}
 22947			t := v_1.Type
 22948			x := v_1.Args[0]
 22949			v.reset(OpS390XLGDR)
 22950			v.Type = t
 22951			v0 := b.NewValue0(v.Pos, OpS390XLNDFR, x.Type)
 22952			v0.AddArg(x)
 22953			v.AddArg(v0)
 22954			return true
 22955		}
 22956		// match: (OR (LGDR <t> x) (MOVDconst [-1<<63]))
 22957		// cond:
 22958		// result: (LGDR <t> (LNDFR <x.Type> x))
 22959		for {
 22960			_ = v.Args[1]
 22961			v_0 := v.Args[0]
 22962			if v_0.Op != OpS390XLGDR {
 22963				break
 22964			}
 22965			t := v_0.Type
 22966			x := v_0.Args[0]
 22967			v_1 := v.Args[1]
 22968			if v_1.Op != OpS390XMOVDconst {
 22969				break
 22970			}
 22971			if v_1.AuxInt != -1<<63 {
 22972				break
 22973			}
 22974			v.reset(OpS390XLGDR)
 22975			v.Type = t
 22976			v0 := b.NewValue0(v.Pos, OpS390XLNDFR, x.Type)
 22977			v0.AddArg(x)
 22978			v.AddArg(v0)
 22979			return true
 22980		}
 22981		// match: (OR (SLDconst [63] (SRDconst [63] (LGDR x))) (LGDR (LPDFR <t> y)))
 22982		// cond:
 22983		// result: (LGDR (CPSDR <t> y x))
 22984		for {
 22985			_ = v.Args[1]
 22986			v_0 := v.Args[0]
 22987			if v_0.Op != OpS390XSLDconst {
 22988				break
 22989			}
 22990			if v_0.AuxInt != 63 {
 22991				break
 22992			}
 22993			v_0_0 := v_0.Args[0]
 22994			if v_0_0.Op != OpS390XSRDconst {
 22995				break
 22996			}
 22997			if v_0_0.AuxInt != 63 {
 22998				break
 22999			}
 23000			v_0_0_0 := v_0_0.Args[0]
 23001			if v_0_0_0.Op != OpS390XLGDR {
 23002				break
 23003			}
 23004			x := v_0_0_0.Args[0]
 23005			v_1 := v.Args[1]
 23006			if v_1.Op != OpS390XLGDR {
 23007				break
 23008			}
 23009			v_1_0 := v_1.Args[0]
 23010			if v_1_0.Op != OpS390XLPDFR {
 23011				break
 23012			}
 23013			t := v_1_0.Type
 23014			y := v_1_0.Args[0]
 23015			v.reset(OpS390XLGDR)
 23016			v0 := b.NewValue0(v.Pos, OpS390XCPSDR, t)
 23017			v0.AddArg(y)
 23018			v0.AddArg(x)
 23019			v.AddArg(v0)
 23020			return true
 23021		}
 23022		// match: (OR (LGDR (LPDFR <t> y)) (SLDconst [63] (SRDconst [63] (LGDR x))))
 23023		// cond:
 23024		// result: (LGDR (CPSDR <t> y x))
 23025		for {
 23026			_ = v.Args[1]
 23027			v_0 := v.Args[0]
 23028			if v_0.Op != OpS390XLGDR {
 23029				break
 23030			}
 23031			v_0_0 := v_0.Args[0]
 23032			if v_0_0.Op != OpS390XLPDFR {
 23033				break
 23034			}
 23035			t := v_0_0.Type
 23036			y := v_0_0.Args[0]
 23037			v_1 := v.Args[1]
 23038			if v_1.Op != OpS390XSLDconst {
 23039				break
 23040			}
 23041			if v_1.AuxInt != 63 {
 23042				break
 23043			}
 23044			v_1_0 := v_1.Args[0]
 23045			if v_1_0.Op != OpS390XSRDconst {
 23046				break
 23047			}
 23048			if v_1_0.AuxInt != 63 {
 23049				break
 23050			}
 23051			v_1_0_0 := v_1_0.Args[0]
 23052			if v_1_0_0.Op != OpS390XLGDR {
 23053				break
 23054			}
 23055			x := v_1_0_0.Args[0]
 23056			v.reset(OpS390XLGDR)
 23057			v0 := b.NewValue0(v.Pos, OpS390XCPSDR, t)
 23058			v0.AddArg(y)
 23059			v0.AddArg(x)
 23060			v.AddArg(v0)
 23061			return true
 23062		}
 23063		// match: (OR (SLDconst [63] (SRDconst [63] (LGDR x))) (MOVDconst [c]))
 23064		// cond: c & -1<<63 == 0
 23065		// result: (LGDR (CPSDR <x.Type> (FMOVDconst <x.Type> [c]) x))
 23066		for {
 23067			_ = v.Args[1]
 23068			v_0 := v.Args[0]
 23069			if v_0.Op != OpS390XSLDconst {
 23070				break
 23071			}
 23072			if v_0.AuxInt != 63 {
 23073				break
 23074			}
 23075			v_0_0 := v_0.Args[0]
 23076			if v_0_0.Op != OpS390XSRDconst {
 23077				break
 23078			}
 23079			if v_0_0.AuxInt != 63 {
 23080				break
 23081			}
 23082			v_0_0_0 := v_0_0.Args[0]
 23083			if v_0_0_0.Op != OpS390XLGDR {
 23084				break
 23085			}
 23086			x := v_0_0_0.Args[0]
 23087			v_1 := v.Args[1]
 23088			if v_1.Op != OpS390XMOVDconst {
 23089				break
 23090			}
 23091			c := v_1.AuxInt
 23092			if !(c&-1<<63 == 0) {
 23093				break
 23094			}
 23095			v.reset(OpS390XLGDR)
 23096			v0 := b.NewValue0(v.Pos, OpS390XCPSDR, x.Type)
 23097			v1 := b.NewValue0(v.Pos, OpS390XFMOVDconst, x.Type)
 23098			v1.AuxInt = c
 23099			v0.AddArg(v1)
 23100			v0.AddArg(x)
 23101			v.AddArg(v0)
 23102			return true
 23103		}
 23104		// match: (OR (MOVDconst [c]) (SLDconst [63] (SRDconst [63] (LGDR x))))
 23105		// cond: c & -1<<63 == 0
 23106		// result: (LGDR (CPSDR <x.Type> (FMOVDconst <x.Type> [c]) x))
 23107		for {
 23108			_ = v.Args[1]
 23109			v_0 := v.Args[0]
 23110			if v_0.Op != OpS390XMOVDconst {
 23111				break
 23112			}
 23113			c := v_0.AuxInt
 23114			v_1 := v.Args[1]
 23115			if v_1.Op != OpS390XSLDconst {
 23116				break
 23117			}
 23118			if v_1.AuxInt != 63 {
 23119				break
 23120			}
 23121			v_1_0 := v_1.Args[0]
 23122			if v_1_0.Op != OpS390XSRDconst {
 23123				break
 23124			}
 23125			if v_1_0.AuxInt != 63 {
 23126				break
 23127			}
 23128			v_1_0_0 := v_1_0.Args[0]
 23129			if v_1_0_0.Op != OpS390XLGDR {
 23130				break
 23131			}
 23132			x := v_1_0_0.Args[0]
 23133			if !(c&-1<<63 == 0) {
 23134				break
 23135			}
 23136			v.reset(OpS390XLGDR)
 23137			v0 := b.NewValue0(v.Pos, OpS390XCPSDR, x.Type)
 23138			v1 := b.NewValue0(v.Pos, OpS390XFMOVDconst, x.Type)
 23139			v1.AuxInt = c
 23140			v0.AddArg(v1)
 23141			v0.AddArg(x)
 23142			v.AddArg(v0)
 23143			return true
 23144		}
 23145		return false
 23146	}
 23147	func rewriteValueS390X_OpS390XOR_10(v *Value) bool {
 23148		b := v.Block
 23149		typ := &b.Func.Config.Types
 23150		// match: (OR (MOVDconst [c]) (MOVDconst [d]))
 23151		// cond:
 23152		// result: (MOVDconst [c|d])
 23153		for {
 23154			_ = v.Args[1]
 23155			v_0 := v.Args[0]
 23156			if v_0.Op != OpS390XMOVDconst {
 23157				break
 23158			}
 23159			c := v_0.AuxInt
 23160			v_1 := v.Args[1]
 23161			if v_1.Op != OpS390XMOVDconst {
 23162				break
 23163			}
 23164			d := v_1.AuxInt
 23165			v.reset(OpS390XMOVDconst)
 23166			v.AuxInt = c | d
 23167			return true
 23168		}
 23169		// match: (OR (MOVDconst [d]) (MOVDconst [c]))
 23170		// cond:
 23171		// result: (MOVDconst [c|d])
 23172		for {
 23173			_ = v.Args[1]
 23174			v_0 := v.Args[0]
 23175			if v_0.Op != OpS390XMOVDconst {
 23176				break
 23177			}
 23178			d := v_0.AuxInt
 23179			v_1 := v.Args[1]
 23180			if v_1.Op != OpS390XMOVDconst {
 23181				break
 23182			}
 23183			c := v_1.AuxInt
 23184			v.reset(OpS390XMOVDconst)
 23185			v.AuxInt = c | d
 23186			return true
 23187		}
 23188		// match: (OR x x)
 23189		// cond:
 23190		// result: x
 23191		for {
 23192			x := v.Args[1]
 23193			if x != v.Args[0] {
 23194				break
 23195			}
 23196			v.reset(OpCopy)
 23197			v.Type = x.Type
 23198			v.AddArg(x)
 23199			return true
 23200		}
 23201		// match: (OR <t> x g:(MOVDload [off] {sym} ptr mem))
 23202		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 23203		// result: (ORload <t> [off] {sym} x ptr mem)
 23204		for {
 23205			t := v.Type
 23206			_ = v.Args[1]
 23207			x := v.Args[0]
 23208			g := v.Args[1]
 23209			if g.Op != OpS390XMOVDload {
 23210				break
 23211			}
 23212			off := g.AuxInt
 23213			sym := g.Aux
 23214			mem := g.Args[1]
 23215			ptr := g.Args[0]
 23216			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 23217				break
 23218			}
 23219			v.reset(OpS390XORload)
 23220			v.Type = t
 23221			v.AuxInt = off
 23222			v.Aux = sym
 23223			v.AddArg(x)
 23224			v.AddArg(ptr)
 23225			v.AddArg(mem)
 23226			return true
 23227		}
 23228		// match: (OR <t> g:(MOVDload [off] {sym} ptr mem) x)
 23229		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 23230		// result: (ORload <t> [off] {sym} x ptr mem)
 23231		for {
 23232			t := v.Type
 23233			x := v.Args[1]
 23234			g := v.Args[0]
 23235			if g.Op != OpS390XMOVDload {
 23236				break
 23237			}
 23238			off := g.AuxInt
 23239			sym := g.Aux
 23240			mem := g.Args[1]
 23241			ptr := g.Args[0]
 23242			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 23243				break
 23244			}
 23245			v.reset(OpS390XORload)
 23246			v.Type = t
 23247			v.AuxInt = off
 23248			v.Aux = sym
 23249			v.AddArg(x)
 23250			v.AddArg(ptr)
 23251			v.AddArg(mem)
 23252			return true
 23253		}
 23254		// match: (OR <t> g:(MOVDload [off] {sym} ptr mem) x)
 23255		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 23256		// result: (ORload <t> [off] {sym} x ptr mem)
 23257		for {
 23258			t := v.Type
 23259			x := v.Args[1]
 23260			g := v.Args[0]
 23261			if g.Op != OpS390XMOVDload {
 23262				break
 23263			}
 23264			off := g.AuxInt
 23265			sym := g.Aux
 23266			mem := g.Args[1]
 23267			ptr := g.Args[0]
 23268			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 23269				break
 23270			}
 23271			v.reset(OpS390XORload)
 23272			v.Type = t
 23273			v.AuxInt = off
 23274			v.Aux = sym
 23275			v.AddArg(x)
 23276			v.AddArg(ptr)
 23277			v.AddArg(mem)
 23278			return true
 23279		}
 23280		// match: (OR <t> x g:(MOVDload [off] {sym} ptr mem))
 23281		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 23282		// result: (ORload <t> [off] {sym} x ptr mem)
 23283		for {
 23284			t := v.Type
 23285			_ = v.Args[1]
 23286			x := v.Args[0]
 23287			g := v.Args[1]
 23288			if g.Op != OpS390XMOVDload {
 23289				break
 23290			}
 23291			off := g.AuxInt
 23292			sym := g.Aux
 23293			mem := g.Args[1]
 23294			ptr := g.Args[0]
 23295			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 23296				break
 23297			}
 23298			v.reset(OpS390XORload)
 23299			v.Type = t
 23300			v.AuxInt = off
 23301			v.Aux = sym
 23302			v.AddArg(x)
 23303			v.AddArg(ptr)
 23304			v.AddArg(mem)
 23305			return true
 23306		}
 23307		// match: (OR x1:(MOVBZload [i1] {s} p mem) sh:(SLDconst [8] x0:(MOVBZload [i0] {s} p mem)))
 23308		// cond: i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 23309		// result: @mergePoint(b,x0,x1) (MOVHZload [i0] {s} p mem)
 23310		for {
 23311			_ = v.Args[1]
 23312			x1 := v.Args[0]
 23313			if x1.Op != OpS390XMOVBZload {
 23314				break
 23315			}
 23316			i1 := x1.AuxInt
 23317			s := x1.Aux
 23318			mem := x1.Args[1]
 23319			p := x1.Args[0]
 23320			sh := v.Args[1]
 23321			if sh.Op != OpS390XSLDconst {
 23322				break
 23323			}
 23324			if sh.AuxInt != 8 {
 23325				break
 23326			}
 23327			x0 := sh.Args[0]
 23328			if x0.Op != OpS390XMOVBZload {
 23329				break
 23330			}
 23331			i0 := x0.AuxInt
 23332			if x0.Aux != s {
 23333				break
 23334			}
 23335			_ = x0.Args[1]
 23336			if p != x0.Args[0] {
 23337				break
 23338			}
 23339			if mem != x0.Args[1] {
 23340				break
 23341			}
 23342			if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 23343				break
 23344			}
 23345			b = mergePoint(b, x0, x1)
 23346			v0 := b.NewValue0(x0.Pos, OpS390XMOVHZload, typ.UInt16)
 23347			v.reset(OpCopy)
 23348			v.AddArg(v0)
 23349			v0.AuxInt = i0
 23350			v0.Aux = s
 23351			v0.AddArg(p)
 23352			v0.AddArg(mem)
 23353			return true
 23354		}
 23355		// match: (OR sh:(SLDconst [8] x0:(MOVBZload [i0] {s} p mem)) x1:(MOVBZload [i1] {s} p mem))
 23356		// cond: i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 23357		// result: @mergePoint(b,x0,x1) (MOVHZload [i0] {s} p mem)
 23358		for {
 23359			_ = v.Args[1]
 23360			sh := v.Args[0]
 23361			if sh.Op != OpS390XSLDconst {
 23362				break
 23363			}
 23364			if sh.AuxInt != 8 {
 23365				break
 23366			}
 23367			x0 := sh.Args[0]
 23368			if x0.Op != OpS390XMOVBZload {
 23369				break
 23370			}
 23371			i0 := x0.AuxInt
 23372			s := x0.Aux
 23373			mem := x0.Args[1]
 23374			p := x0.Args[0]
 23375			x1 := v.Args[1]
 23376			if x1.Op != OpS390XMOVBZload {
 23377				break
 23378			}
 23379			i1 := x1.AuxInt
 23380			if x1.Aux != s {
 23381				break
 23382			}
 23383			_ = x1.Args[1]
 23384			if p != x1.Args[0] {
 23385				break
 23386			}
 23387			if mem != x1.Args[1] {
 23388				break
 23389			}
 23390			if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 23391				break
 23392			}
 23393			b = mergePoint(b, x0, x1)
 23394			v0 := b.NewValue0(x1.Pos, OpS390XMOVHZload, typ.UInt16)
 23395			v.reset(OpCopy)
 23396			v.AddArg(v0)
 23397			v0.AuxInt = i0
 23398			v0.Aux = s
 23399			v0.AddArg(p)
 23400			v0.AddArg(mem)
 23401			return true
 23402		}
 23403		// match: (OR x1:(MOVHZload [i1] {s} p mem) sh:(SLDconst [16] x0:(MOVHZload [i0] {s} p mem)))
 23404		// cond: i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 23405		// result: @mergePoint(b,x0,x1) (MOVWZload [i0] {s} p mem)
 23406		for {
 23407			_ = v.Args[1]
 23408			x1 := v.Args[0]
 23409			if x1.Op != OpS390XMOVHZload {
 23410				break
 23411			}
 23412			i1 := x1.AuxInt
 23413			s := x1.Aux
 23414			mem := x1.Args[1]
 23415			p := x1.Args[0]
 23416			sh := v.Args[1]
 23417			if sh.Op != OpS390XSLDconst {
 23418				break
 23419			}
 23420			if sh.AuxInt != 16 {
 23421				break
 23422			}
 23423			x0 := sh.Args[0]
 23424			if x0.Op != OpS390XMOVHZload {
 23425				break
 23426			}
 23427			i0 := x0.AuxInt
 23428			if x0.Aux != s {
 23429				break
 23430			}
 23431			_ = x0.Args[1]
 23432			if p != x0.Args[0] {
 23433				break
 23434			}
 23435			if mem != x0.Args[1] {
 23436				break
 23437			}
 23438			if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 23439				break
 23440			}
 23441			b = mergePoint(b, x0, x1)
 23442			v0 := b.NewValue0(x0.Pos, OpS390XMOVWZload, typ.UInt32)
 23443			v.reset(OpCopy)
 23444			v.AddArg(v0)
 23445			v0.AuxInt = i0
 23446			v0.Aux = s
 23447			v0.AddArg(p)
 23448			v0.AddArg(mem)
 23449			return true
 23450		}
 23451		return false
 23452	}
 23453	func rewriteValueS390X_OpS390XOR_20(v *Value) bool {
 23454		b := v.Block
 23455		typ := &b.Func.Config.Types
 23456		// match: (OR sh:(SLDconst [16] x0:(MOVHZload [i0] {s} p mem)) x1:(MOVHZload [i1] {s} p mem))
 23457		// cond: i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 23458		// result: @mergePoint(b,x0,x1) (MOVWZload [i0] {s} p mem)
 23459		for {
 23460			_ = v.Args[1]
 23461			sh := v.Args[0]
 23462			if sh.Op != OpS390XSLDconst {
 23463				break
 23464			}
 23465			if sh.AuxInt != 16 {
 23466				break
 23467			}
 23468			x0 := sh.Args[0]
 23469			if x0.Op != OpS390XMOVHZload {
 23470				break
 23471			}
 23472			i0 := x0.AuxInt
 23473			s := x0.Aux
 23474			mem := x0.Args[1]
 23475			p := x0.Args[0]
 23476			x1 := v.Args[1]
 23477			if x1.Op != OpS390XMOVHZload {
 23478				break
 23479			}
 23480			i1 := x1.AuxInt
 23481			if x1.Aux != s {
 23482				break
 23483			}
 23484			_ = x1.Args[1]
 23485			if p != x1.Args[0] {
 23486				break
 23487			}
 23488			if mem != x1.Args[1] {
 23489				break
 23490			}
 23491			if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 23492				break
 23493			}
 23494			b = mergePoint(b, x0, x1)
 23495			v0 := b.NewValue0(x1.Pos, OpS390XMOVWZload, typ.UInt32)
 23496			v.reset(OpCopy)
 23497			v.AddArg(v0)
 23498			v0.AuxInt = i0
 23499			v0.Aux = s
 23500			v0.AddArg(p)
 23501			v0.AddArg(mem)
 23502			return true
 23503		}
 23504		// match: (OR x1:(MOVWZload [i1] {s} p mem) sh:(SLDconst [32] x0:(MOVWZload [i0] {s} p mem)))
 23505		// cond: i1 == i0+4 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 23506		// result: @mergePoint(b,x0,x1) (MOVDload [i0] {s} p mem)
 23507		for {
 23508			_ = v.Args[1]
 23509			x1 := v.Args[0]
 23510			if x1.Op != OpS390XMOVWZload {
 23511				break
 23512			}
 23513			i1 := x1.AuxInt
 23514			s := x1.Aux
 23515			mem := x1.Args[1]
 23516			p := x1.Args[0]
 23517			sh := v.Args[1]
 23518			if sh.Op != OpS390XSLDconst {
 23519				break
 23520			}
 23521			if sh.AuxInt != 32 {
 23522				break
 23523			}
 23524			x0 := sh.Args[0]
 23525			if x0.Op != OpS390XMOVWZload {
 23526				break
 23527			}
 23528			i0 := x0.AuxInt
 23529			if x0.Aux != s {
 23530				break
 23531			}
 23532			_ = x0.Args[1]
 23533			if p != x0.Args[0] {
 23534				break
 23535			}
 23536			if mem != x0.Args[1] {
 23537				break
 23538			}
 23539			if !(i1 == i0+4 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 23540				break
 23541			}
 23542			b = mergePoint(b, x0, x1)
 23543			v0 := b.NewValue0(x0.Pos, OpS390XMOVDload, typ.UInt64)
 23544			v.reset(OpCopy)
 23545			v.AddArg(v0)
 23546			v0.AuxInt = i0
 23547			v0.Aux = s
 23548			v0.AddArg(p)
 23549			v0.AddArg(mem)
 23550			return true
 23551		}
 23552		// match: (OR sh:(SLDconst [32] x0:(MOVWZload [i0] {s} p mem)) x1:(MOVWZload [i1] {s} p mem))
 23553		// cond: i1 == i0+4 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 23554		// result: @mergePoint(b,x0,x1) (MOVDload [i0] {s} p mem)
 23555		for {
 23556			_ = v.Args[1]
 23557			sh := v.Args[0]
 23558			if sh.Op != OpS390XSLDconst {
 23559				break
 23560			}
 23561			if sh.AuxInt != 32 {
 23562				break
 23563			}
 23564			x0 := sh.Args[0]
 23565			if x0.Op != OpS390XMOVWZload {
 23566				break
 23567			}
 23568			i0 := x0.AuxInt
 23569			s := x0.Aux
 23570			mem := x0.Args[1]
 23571			p := x0.Args[0]
 23572			x1 := v.Args[1]
 23573			if x1.Op != OpS390XMOVWZload {
 23574				break
 23575			}
 23576			i1 := x1.AuxInt
 23577			if x1.Aux != s {
 23578				break
 23579			}
 23580			_ = x1.Args[1]
 23581			if p != x1.Args[0] {
 23582				break
 23583			}
 23584			if mem != x1.Args[1] {
 23585				break
 23586			}
 23587			if !(i1 == i0+4 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 23588				break
 23589			}
 23590			b = mergePoint(b, x0, x1)
 23591			v0 := b.NewValue0(x1.Pos, OpS390XMOVDload, typ.UInt64)
 23592			v.reset(OpCopy)
 23593			v.AddArg(v0)
 23594			v0.AuxInt = i0
 23595			v0.Aux = s
 23596			v0.AddArg(p)
 23597			v0.AddArg(mem)
 23598			return true
 23599		}
 23600		// match: (OR s0:(SLDconst [j0] x0:(MOVBZload [i0] {s} p mem)) or:(OR s1:(SLDconst [j1] x1:(MOVBZload [i1] {s} p mem)) y))
 23601		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 23602		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZload [i0] {s} p mem)) y)
 23603		for {
 23604			_ = v.Args[1]
 23605			s0 := v.Args[0]
 23606			if s0.Op != OpS390XSLDconst {
 23607				break
 23608			}
 23609			j0 := s0.AuxInt
 23610			x0 := s0.Args[0]
 23611			if x0.Op != OpS390XMOVBZload {
 23612				break
 23613			}
 23614			i0 := x0.AuxInt
 23615			s := x0.Aux
 23616			mem := x0.Args[1]
 23617			p := x0.Args[0]
 23618			or := v.Args[1]
 23619			if or.Op != OpS390XOR {
 23620				break
 23621			}
 23622			y := or.Args[1]
 23623			s1 := or.Args[0]
 23624			if s1.Op != OpS390XSLDconst {
 23625				break
 23626			}
 23627			j1 := s1.AuxInt
 23628			x1 := s1.Args[0]
 23629			if x1.Op != OpS390XMOVBZload {
 23630				break
 23631			}
 23632			i1 := x1.AuxInt
 23633			if x1.Aux != s {
 23634				break
 23635			}
 23636			_ = x1.Args[1]
 23637			if p != x1.Args[0] {
 23638				break
 23639			}
 23640			if mem != x1.Args[1] {
 23641				break
 23642			}
 23643			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 23644				break
 23645			}
 23646			b = mergePoint(b, x0, x1, y)
 23647			v0 := b.NewValue0(x1.Pos, OpS390XOR, v.Type)
 23648			v.reset(OpCopy)
 23649			v.AddArg(v0)
 23650			v1 := b.NewValue0(x1.Pos, OpS390XSLDconst, v.Type)
 23651			v1.AuxInt = j1
 23652			v2 := b.NewValue0(x1.Pos, OpS390XMOVHZload, typ.UInt16)
 23653			v2.AuxInt = i0
 23654			v2.Aux = s
 23655			v2.AddArg(p)
 23656			v2.AddArg(mem)
 23657			v1.AddArg(v2)
 23658			v0.AddArg(v1)
 23659			v0.AddArg(y)
 23660			return true
 23661		}
 23662		// match: (OR s0:(SLDconst [j0] x0:(MOVBZload [i0] {s} p mem)) or:(OR y s1:(SLDconst [j1] x1:(MOVBZload [i1] {s} p mem))))
 23663		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 23664		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZload [i0] {s} p mem)) y)
 23665		for {
 23666			_ = v.Args[1]
 23667			s0 := v.Args[0]
 23668			if s0.Op != OpS390XSLDconst {
 23669				break
 23670			}
 23671			j0 := s0.AuxInt
 23672			x0 := s0.Args[0]
 23673			if x0.Op != OpS390XMOVBZload {
 23674				break
 23675			}
 23676			i0 := x0.AuxInt
 23677			s := x0.Aux
 23678			mem := x0.Args[1]
 23679			p := x0.Args[0]
 23680			or := v.Args[1]
 23681			if or.Op != OpS390XOR {
 23682				break
 23683			}
 23684			_ = or.Args[1]
 23685			y := or.Args[0]
 23686			s1 := or.Args[1]
 23687			if s1.Op != OpS390XSLDconst {
 23688				break
 23689			}
 23690			j1 := s1.AuxInt
 23691			x1 := s1.Args[0]
 23692			if x1.Op != OpS390XMOVBZload {
 23693				break
 23694			}
 23695			i1 := x1.AuxInt
 23696			if x1.Aux != s {
 23697				break
 23698			}
 23699			_ = x1.Args[1]
 23700			if p != x1.Args[0] {
 23701				break
 23702			}
 23703			if mem != x1.Args[1] {
 23704				break
 23705			}
 23706			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 23707				break
 23708			}
 23709			b = mergePoint(b, x0, x1, y)
 23710			v0 := b.NewValue0(x1.Pos, OpS390XOR, v.Type)
 23711			v.reset(OpCopy)
 23712			v.AddArg(v0)
 23713			v1 := b.NewValue0(x1.Pos, OpS390XSLDconst, v.Type)
 23714			v1.AuxInt = j1
 23715			v2 := b.NewValue0(x1.Pos, OpS390XMOVHZload, typ.UInt16)
 23716			v2.AuxInt = i0
 23717			v2.Aux = s
 23718			v2.AddArg(p)
 23719			v2.AddArg(mem)
 23720			v1.AddArg(v2)
 23721			v0.AddArg(v1)
 23722			v0.AddArg(y)
 23723			return true
 23724		}
 23725		// match: (OR or:(OR s1:(SLDconst [j1] x1:(MOVBZload [i1] {s} p mem)) y) s0:(SLDconst [j0] x0:(MOVBZload [i0] {s} p mem)))
 23726		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 23727		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZload [i0] {s} p mem)) y)
 23728		for {
 23729			_ = v.Args[1]
 23730			or := v.Args[0]
 23731			if or.Op != OpS390XOR {
 23732				break
 23733			}
 23734			y := or.Args[1]
 23735			s1 := or.Args[0]
 23736			if s1.Op != OpS390XSLDconst {
 23737				break
 23738			}
 23739			j1 := s1.AuxInt
 23740			x1 := s1.Args[0]
 23741			if x1.Op != OpS390XMOVBZload {
 23742				break
 23743			}
 23744			i1 := x1.AuxInt
 23745			s := x1.Aux
 23746			mem := x1.Args[1]
 23747			p := x1.Args[0]
 23748			s0 := v.Args[1]
 23749			if s0.Op != OpS390XSLDconst {
 23750				break
 23751			}
 23752			j0 := s0.AuxInt
 23753			x0 := s0.Args[0]
 23754			if x0.Op != OpS390XMOVBZload {
 23755				break
 23756			}
 23757			i0 := x0.AuxInt
 23758			if x0.Aux != s {
 23759				break
 23760			}
 23761			_ = x0.Args[1]
 23762			if p != x0.Args[0] {
 23763				break
 23764			}
 23765			if mem != x0.Args[1] {
 23766				break
 23767			}
 23768			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 23769				break
 23770			}
 23771			b = mergePoint(b, x0, x1, y)
 23772			v0 := b.NewValue0(x0.Pos, OpS390XOR, v.Type)
 23773			v.reset(OpCopy)
 23774			v.AddArg(v0)
 23775			v1 := b.NewValue0(x0.Pos, OpS390XSLDconst, v.Type)
 23776			v1.AuxInt = j1
 23777			v2 := b.NewValue0(x0.Pos, OpS390XMOVHZload, typ.UInt16)
 23778			v2.AuxInt = i0
 23779			v2.Aux = s
 23780			v2.AddArg(p)
 23781			v2.AddArg(mem)
 23782			v1.AddArg(v2)
 23783			v0.AddArg(v1)
 23784			v0.AddArg(y)
 23785			return true
 23786		}
 23787		// match: (OR or:(OR y s1:(SLDconst [j1] x1:(MOVBZload [i1] {s} p mem))) s0:(SLDconst [j0] x0:(MOVBZload [i0] {s} p mem)))
 23788		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 23789		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZload [i0] {s} p mem)) y)
 23790		for {
 23791			_ = v.Args[1]
 23792			or := v.Args[0]
 23793			if or.Op != OpS390XOR {
 23794				break
 23795			}
 23796			_ = or.Args[1]
 23797			y := or.Args[0]
 23798			s1 := or.Args[1]
 23799			if s1.Op != OpS390XSLDconst {
 23800				break
 23801			}
 23802			j1 := s1.AuxInt
 23803			x1 := s1.Args[0]
 23804			if x1.Op != OpS390XMOVBZload {
 23805				break
 23806			}
 23807			i1 := x1.AuxInt
 23808			s := x1.Aux
 23809			mem := x1.Args[1]
 23810			p := x1.Args[0]
 23811			s0 := v.Args[1]
 23812			if s0.Op != OpS390XSLDconst {
 23813				break
 23814			}
 23815			j0 := s0.AuxInt
 23816			x0 := s0.Args[0]
 23817			if x0.Op != OpS390XMOVBZload {
 23818				break
 23819			}
 23820			i0 := x0.AuxInt
 23821			if x0.Aux != s {
 23822				break
 23823			}
 23824			_ = x0.Args[1]
 23825			if p != x0.Args[0] {
 23826				break
 23827			}
 23828			if mem != x0.Args[1] {
 23829				break
 23830			}
 23831			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 23832				break
 23833			}
 23834			b = mergePoint(b, x0, x1, y)
 23835			v0 := b.NewValue0(x0.Pos, OpS390XOR, v.Type)
 23836			v.reset(OpCopy)
 23837			v.AddArg(v0)
 23838			v1 := b.NewValue0(x0.Pos, OpS390XSLDconst, v.Type)
 23839			v1.AuxInt = j1
 23840			v2 := b.NewValue0(x0.Pos, OpS390XMOVHZload, typ.UInt16)
 23841			v2.AuxInt = i0
 23842			v2.Aux = s
 23843			v2.AddArg(p)
 23844			v2.AddArg(mem)
 23845			v1.AddArg(v2)
 23846			v0.AddArg(v1)
 23847			v0.AddArg(y)
 23848			return true
 23849		}
 23850		// match: (OR s0:(SLDconst [j0] x0:(MOVHZload [i0] {s} p mem)) or:(OR s1:(SLDconst [j1] x1:(MOVHZload [i1] {s} p mem)) y))
 23851		// cond: i1 == i0+2 && j1 == j0-16 && j1 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 23852		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZload [i0] {s} p mem)) y)
 23853		for {
 23854			_ = v.Args[1]
 23855			s0 := v.Args[0]
 23856			if s0.Op != OpS390XSLDconst {
 23857				break
 23858			}
 23859			j0 := s0.AuxInt
 23860			x0 := s0.Args[0]
 23861			if x0.Op != OpS390XMOVHZload {
 23862				break
 23863			}
 23864			i0 := x0.AuxInt
 23865			s := x0.Aux
 23866			mem := x0.Args[1]
 23867			p := x0.Args[0]
 23868			or := v.Args[1]
 23869			if or.Op != OpS390XOR {
 23870				break
 23871			}
 23872			y := or.Args[1]
 23873			s1 := or.Args[0]
 23874			if s1.Op != OpS390XSLDconst {
 23875				break
 23876			}
 23877			j1 := s1.AuxInt
 23878			x1 := s1.Args[0]
 23879			if x1.Op != OpS390XMOVHZload {
 23880				break
 23881			}
 23882			i1 := x1.AuxInt
 23883			if x1.Aux != s {
 23884				break
 23885			}
 23886			_ = x1.Args[1]
 23887			if p != x1.Args[0] {
 23888				break
 23889			}
 23890			if mem != x1.Args[1] {
 23891				break
 23892			}
 23893			if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 23894				break
 23895			}
 23896			b = mergePoint(b, x0, x1, y)
 23897			v0 := b.NewValue0(x1.Pos, OpS390XOR, v.Type)
 23898			v.reset(OpCopy)
 23899			v.AddArg(v0)
 23900			v1 := b.NewValue0(x1.Pos, OpS390XSLDconst, v.Type)
 23901			v1.AuxInt = j1
 23902			v2 := b.NewValue0(x1.Pos, OpS390XMOVWZload, typ.UInt32)
 23903			v2.AuxInt = i0
 23904			v2.Aux = s
 23905			v2.AddArg(p)
 23906			v2.AddArg(mem)
 23907			v1.AddArg(v2)
 23908			v0.AddArg(v1)
 23909			v0.AddArg(y)
 23910			return true
 23911		}
 23912		// match: (OR s0:(SLDconst [j0] x0:(MOVHZload [i0] {s} p mem)) or:(OR y s1:(SLDconst [j1] x1:(MOVHZload [i1] {s} p mem))))
 23913		// cond: i1 == i0+2 && j1 == j0-16 && j1 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 23914		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZload [i0] {s} p mem)) y)
 23915		for {
 23916			_ = v.Args[1]
 23917			s0 := v.Args[0]
 23918			if s0.Op != OpS390XSLDconst {
 23919				break
 23920			}
 23921			j0 := s0.AuxInt
 23922			x0 := s0.Args[0]
 23923			if x0.Op != OpS390XMOVHZload {
 23924				break
 23925			}
 23926			i0 := x0.AuxInt
 23927			s := x0.Aux
 23928			mem := x0.Args[1]
 23929			p := x0.Args[0]
 23930			or := v.Args[1]
 23931			if or.Op != OpS390XOR {
 23932				break
 23933			}
 23934			_ = or.Args[1]
 23935			y := or.Args[0]
 23936			s1 := or.Args[1]
 23937			if s1.Op != OpS390XSLDconst {
 23938				break
 23939			}
 23940			j1 := s1.AuxInt
 23941			x1 := s1.Args[0]
 23942			if x1.Op != OpS390XMOVHZload {
 23943				break
 23944			}
 23945			i1 := x1.AuxInt
 23946			if x1.Aux != s {
 23947				break
 23948			}
 23949			_ = x1.Args[1]
 23950			if p != x1.Args[0] {
 23951				break
 23952			}
 23953			if mem != x1.Args[1] {
 23954				break
 23955			}
 23956			if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 23957				break
 23958			}
 23959			b = mergePoint(b, x0, x1, y)
 23960			v0 := b.NewValue0(x1.Pos, OpS390XOR, v.Type)
 23961			v.reset(OpCopy)
 23962			v.AddArg(v0)
 23963			v1 := b.NewValue0(x1.Pos, OpS390XSLDconst, v.Type)
 23964			v1.AuxInt = j1
 23965			v2 := b.NewValue0(x1.Pos, OpS390XMOVWZload, typ.UInt32)
 23966			v2.AuxInt = i0
 23967			v2.Aux = s
 23968			v2.AddArg(p)
 23969			v2.AddArg(mem)
 23970			v1.AddArg(v2)
 23971			v0.AddArg(v1)
 23972			v0.AddArg(y)
 23973			return true
 23974		}
 23975		// match: (OR or:(OR s1:(SLDconst [j1] x1:(MOVHZload [i1] {s} p mem)) y) s0:(SLDconst [j0] x0:(MOVHZload [i0] {s} p mem)))
 23976		// cond: i1 == i0+2 && j1 == j0-16 && j1 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 23977		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZload [i0] {s} p mem)) y)
 23978		for {
 23979			_ = v.Args[1]
 23980			or := v.Args[0]
 23981			if or.Op != OpS390XOR {
 23982				break
 23983			}
 23984			y := or.Args[1]
 23985			s1 := or.Args[0]
 23986			if s1.Op != OpS390XSLDconst {
 23987				break
 23988			}
 23989			j1 := s1.AuxInt
 23990			x1 := s1.Args[0]
 23991			if x1.Op != OpS390XMOVHZload {
 23992				break
 23993			}
 23994			i1 := x1.AuxInt
 23995			s := x1.Aux
 23996			mem := x1.Args[1]
 23997			p := x1.Args[0]
 23998			s0 := v.Args[1]
 23999			if s0.Op != OpS390XSLDconst {
 24000				break
 24001			}
 24002			j0 := s0.AuxInt
 24003			x0 := s0.Args[0]
 24004			if x0.Op != OpS390XMOVHZload {
 24005				break
 24006			}
 24007			i0 := x0.AuxInt
 24008			if x0.Aux != s {
 24009				break
 24010			}
 24011			_ = x0.Args[1]
 24012			if p != x0.Args[0] {
 24013				break
 24014			}
 24015			if mem != x0.Args[1] {
 24016				break
 24017			}
 24018			if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 24019				break
 24020			}
 24021			b = mergePoint(b, x0, x1, y)
 24022			v0 := b.NewValue0(x0.Pos, OpS390XOR, v.Type)
 24023			v.reset(OpCopy)
 24024			v.AddArg(v0)
 24025			v1 := b.NewValue0(x0.Pos, OpS390XSLDconst, v.Type)
 24026			v1.AuxInt = j1
 24027			v2 := b.NewValue0(x0.Pos, OpS390XMOVWZload, typ.UInt32)
 24028			v2.AuxInt = i0
 24029			v2.Aux = s
 24030			v2.AddArg(p)
 24031			v2.AddArg(mem)
 24032			v1.AddArg(v2)
 24033			v0.AddArg(v1)
 24034			v0.AddArg(y)
 24035			return true
 24036		}
 24037		return false
 24038	}
 24039	func rewriteValueS390X_OpS390XOR_30(v *Value) bool {
 24040		b := v.Block
 24041		typ := &b.Func.Config.Types
 24042		// match: (OR or:(OR y s1:(SLDconst [j1] x1:(MOVHZload [i1] {s} p mem))) s0:(SLDconst [j0] x0:(MOVHZload [i0] {s} p mem)))
 24043		// cond: i1 == i0+2 && j1 == j0-16 && j1 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 24044		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZload [i0] {s} p mem)) y)
 24045		for {
 24046			_ = v.Args[1]
 24047			or := v.Args[0]
 24048			if or.Op != OpS390XOR {
 24049				break
 24050			}
 24051			_ = or.Args[1]
 24052			y := or.Args[0]
 24053			s1 := or.Args[1]
 24054			if s1.Op != OpS390XSLDconst {
 24055				break
 24056			}
 24057			j1 := s1.AuxInt
 24058			x1 := s1.Args[0]
 24059			if x1.Op != OpS390XMOVHZload {
 24060				break
 24061			}
 24062			i1 := x1.AuxInt
 24063			s := x1.Aux
 24064			mem := x1.Args[1]
 24065			p := x1.Args[0]
 24066			s0 := v.Args[1]
 24067			if s0.Op != OpS390XSLDconst {
 24068				break
 24069			}
 24070			j0 := s0.AuxInt
 24071			x0 := s0.Args[0]
 24072			if x0.Op != OpS390XMOVHZload {
 24073				break
 24074			}
 24075			i0 := x0.AuxInt
 24076			if x0.Aux != s {
 24077				break
 24078			}
 24079			_ = x0.Args[1]
 24080			if p != x0.Args[0] {
 24081				break
 24082			}
 24083			if mem != x0.Args[1] {
 24084				break
 24085			}
 24086			if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 24087				break
 24088			}
 24089			b = mergePoint(b, x0, x1, y)
 24090			v0 := b.NewValue0(x0.Pos, OpS390XOR, v.Type)
 24091			v.reset(OpCopy)
 24092			v.AddArg(v0)
 24093			v1 := b.NewValue0(x0.Pos, OpS390XSLDconst, v.Type)
 24094			v1.AuxInt = j1
 24095			v2 := b.NewValue0(x0.Pos, OpS390XMOVWZload, typ.UInt32)
 24096			v2.AuxInt = i0
 24097			v2.Aux = s
 24098			v2.AddArg(p)
 24099			v2.AddArg(mem)
 24100			v1.AddArg(v2)
 24101			v0.AddArg(v1)
 24102			v0.AddArg(y)
 24103			return true
 24104		}
 24105		// match: (OR x1:(MOVBZloadidx [i1] {s} p idx mem) sh:(SLDconst [8] x0:(MOVBZloadidx [i0] {s} p idx mem)))
 24106		// cond: i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 24107		// result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem)
 24108		for {
 24109			_ = v.Args[1]
 24110			x1 := v.Args[0]
 24111			if x1.Op != OpS390XMOVBZloadidx {
 24112				break
 24113			}
 24114			i1 := x1.AuxInt
 24115			s := x1.Aux
 24116			mem := x1.Args[2]
 24117			p := x1.Args[0]
 24118			idx := x1.Args[1]
 24119			sh := v.Args[1]
 24120			if sh.Op != OpS390XSLDconst {
 24121				break
 24122			}
 24123			if sh.AuxInt != 8 {
 24124				break
 24125			}
 24126			x0 := sh.Args[0]
 24127			if x0.Op != OpS390XMOVBZloadidx {
 24128				break
 24129			}
 24130			i0 := x0.AuxInt
 24131			if x0.Aux != s {
 24132				break
 24133			}
 24134			_ = x0.Args[2]
 24135			if p != x0.Args[0] {
 24136				break
 24137			}
 24138			if idx != x0.Args[1] {
 24139				break
 24140			}
 24141			if mem != x0.Args[2] {
 24142				break
 24143			}
 24144			if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 24145				break
 24146			}
 24147			b = mergePoint(b, x0, x1)
 24148			v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 24149			v.reset(OpCopy)
 24150			v.AddArg(v0)
 24151			v0.AuxInt = i0
 24152			v0.Aux = s
 24153			v0.AddArg(p)
 24154			v0.AddArg(idx)
 24155			v0.AddArg(mem)
 24156			return true
 24157		}
 24158		// match: (OR x1:(MOVBZloadidx [i1] {s} idx p mem) sh:(SLDconst [8] x0:(MOVBZloadidx [i0] {s} p idx mem)))
 24159		// cond: i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 24160		// result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem)
 24161		for {
 24162			_ = v.Args[1]
 24163			x1 := v.Args[0]
 24164			if x1.Op != OpS390XMOVBZloadidx {
 24165				break
 24166			}
 24167			i1 := x1.AuxInt
 24168			s := x1.Aux
 24169			mem := x1.Args[2]
 24170			idx := x1.Args[0]
 24171			p := x1.Args[1]
 24172			sh := v.Args[1]
 24173			if sh.Op != OpS390XSLDconst {
 24174				break
 24175			}
 24176			if sh.AuxInt != 8 {
 24177				break
 24178			}
 24179			x0 := sh.Args[0]
 24180			if x0.Op != OpS390XMOVBZloadidx {
 24181				break
 24182			}
 24183			i0 := x0.AuxInt
 24184			if x0.Aux != s {
 24185				break
 24186			}
 24187			_ = x0.Args[2]
 24188			if p != x0.Args[0] {
 24189				break
 24190			}
 24191			if idx != x0.Args[1] {
 24192				break
 24193			}
 24194			if mem != x0.Args[2] {
 24195				break
 24196			}
 24197			if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 24198				break
 24199			}
 24200			b = mergePoint(b, x0, x1)
 24201			v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 24202			v.reset(OpCopy)
 24203			v.AddArg(v0)
 24204			v0.AuxInt = i0
 24205			v0.Aux = s
 24206			v0.AddArg(p)
 24207			v0.AddArg(idx)
 24208			v0.AddArg(mem)
 24209			return true
 24210		}
 24211		// match: (OR x1:(MOVBZloadidx [i1] {s} p idx mem) sh:(SLDconst [8] x0:(MOVBZloadidx [i0] {s} idx p mem)))
 24212		// cond: i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 24213		// result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem)
 24214		for {
 24215			_ = v.Args[1]
 24216			x1 := v.Args[0]
 24217			if x1.Op != OpS390XMOVBZloadidx {
 24218				break
 24219			}
 24220			i1 := x1.AuxInt
 24221			s := x1.Aux
 24222			mem := x1.Args[2]
 24223			p := x1.Args[0]
 24224			idx := x1.Args[1]
 24225			sh := v.Args[1]
 24226			if sh.Op != OpS390XSLDconst {
 24227				break
 24228			}
 24229			if sh.AuxInt != 8 {
 24230				break
 24231			}
 24232			x0 := sh.Args[0]
 24233			if x0.Op != OpS390XMOVBZloadidx {
 24234				break
 24235			}
 24236			i0 := x0.AuxInt
 24237			if x0.Aux != s {
 24238				break
 24239			}
 24240			_ = x0.Args[2]
 24241			if idx != x0.Args[0] {
 24242				break
 24243			}
 24244			if p != x0.Args[1] {
 24245				break
 24246			}
 24247			if mem != x0.Args[2] {
 24248				break
 24249			}
 24250			if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 24251				break
 24252			}
 24253			b = mergePoint(b, x0, x1)
 24254			v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 24255			v.reset(OpCopy)
 24256			v.AddArg(v0)
 24257			v0.AuxInt = i0
 24258			v0.Aux = s
 24259			v0.AddArg(p)
 24260			v0.AddArg(idx)
 24261			v0.AddArg(mem)
 24262			return true
 24263		}
 24264		// match: (OR x1:(MOVBZloadidx [i1] {s} idx p mem) sh:(SLDconst [8] x0:(MOVBZloadidx [i0] {s} idx p mem)))
 24265		// cond: i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 24266		// result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem)
 24267		for {
 24268			_ = v.Args[1]
 24269			x1 := v.Args[0]
 24270			if x1.Op != OpS390XMOVBZloadidx {
 24271				break
 24272			}
 24273			i1 := x1.AuxInt
 24274			s := x1.Aux
 24275			mem := x1.Args[2]
 24276			idx := x1.Args[0]
 24277			p := x1.Args[1]
 24278			sh := v.Args[1]
 24279			if sh.Op != OpS390XSLDconst {
 24280				break
 24281			}
 24282			if sh.AuxInt != 8 {
 24283				break
 24284			}
 24285			x0 := sh.Args[0]
 24286			if x0.Op != OpS390XMOVBZloadidx {
 24287				break
 24288			}
 24289			i0 := x0.AuxInt
 24290			if x0.Aux != s {
 24291				break
 24292			}
 24293			_ = x0.Args[2]
 24294			if idx != x0.Args[0] {
 24295				break
 24296			}
 24297			if p != x0.Args[1] {
 24298				break
 24299			}
 24300			if mem != x0.Args[2] {
 24301				break
 24302			}
 24303			if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 24304				break
 24305			}
 24306			b = mergePoint(b, x0, x1)
 24307			v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 24308			v.reset(OpCopy)
 24309			v.AddArg(v0)
 24310			v0.AuxInt = i0
 24311			v0.Aux = s
 24312			v0.AddArg(p)
 24313			v0.AddArg(idx)
 24314			v0.AddArg(mem)
 24315			return true
 24316		}
 24317		// match: (OR sh:(SLDconst [8] x0:(MOVBZloadidx [i0] {s} p idx mem)) x1:(MOVBZloadidx [i1] {s} p idx mem))
 24318		// cond: i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 24319		// result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem)
 24320		for {
 24321			_ = v.Args[1]
 24322			sh := v.Args[0]
 24323			if sh.Op != OpS390XSLDconst {
 24324				break
 24325			}
 24326			if sh.AuxInt != 8 {
 24327				break
 24328			}
 24329			x0 := sh.Args[0]
 24330			if x0.Op != OpS390XMOVBZloadidx {
 24331				break
 24332			}
 24333			i0 := x0.AuxInt
 24334			s := x0.Aux
 24335			mem := x0.Args[2]
 24336			p := x0.Args[0]
 24337			idx := x0.Args[1]
 24338			x1 := v.Args[1]
 24339			if x1.Op != OpS390XMOVBZloadidx {
 24340				break
 24341			}
 24342			i1 := x1.AuxInt
 24343			if x1.Aux != s {
 24344				break
 24345			}
 24346			_ = x1.Args[2]
 24347			if p != x1.Args[0] {
 24348				break
 24349			}
 24350			if idx != x1.Args[1] {
 24351				break
 24352			}
 24353			if mem != x1.Args[2] {
 24354				break
 24355			}
 24356			if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 24357				break
 24358			}
 24359			b = mergePoint(b, x0, x1)
 24360			v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 24361			v.reset(OpCopy)
 24362			v.AddArg(v0)
 24363			v0.AuxInt = i0
 24364			v0.Aux = s
 24365			v0.AddArg(p)
 24366			v0.AddArg(idx)
 24367			v0.AddArg(mem)
 24368			return true
 24369		}
 24370		// match: (OR sh:(SLDconst [8] x0:(MOVBZloadidx [i0] {s} idx p mem)) x1:(MOVBZloadidx [i1] {s} p idx mem))
 24371		// cond: i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 24372		// result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem)
 24373		for {
 24374			_ = v.Args[1]
 24375			sh := v.Args[0]
 24376			if sh.Op != OpS390XSLDconst {
 24377				break
 24378			}
 24379			if sh.AuxInt != 8 {
 24380				break
 24381			}
 24382			x0 := sh.Args[0]
 24383			if x0.Op != OpS390XMOVBZloadidx {
 24384				break
 24385			}
 24386			i0 := x0.AuxInt
 24387			s := x0.Aux
 24388			mem := x0.Args[2]
 24389			idx := x0.Args[0]
 24390			p := x0.Args[1]
 24391			x1 := v.Args[1]
 24392			if x1.Op != OpS390XMOVBZloadidx {
 24393				break
 24394			}
 24395			i1 := x1.AuxInt
 24396			if x1.Aux != s {
 24397				break
 24398			}
 24399			_ = x1.Args[2]
 24400			if p != x1.Args[0] {
 24401				break
 24402			}
 24403			if idx != x1.Args[1] {
 24404				break
 24405			}
 24406			if mem != x1.Args[2] {
 24407				break
 24408			}
 24409			if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 24410				break
 24411			}
 24412			b = mergePoint(b, x0, x1)
 24413			v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 24414			v.reset(OpCopy)
 24415			v.AddArg(v0)
 24416			v0.AuxInt = i0
 24417			v0.Aux = s
 24418			v0.AddArg(p)
 24419			v0.AddArg(idx)
 24420			v0.AddArg(mem)
 24421			return true
 24422		}
 24423		// match: (OR sh:(SLDconst [8] x0:(MOVBZloadidx [i0] {s} p idx mem)) x1:(MOVBZloadidx [i1] {s} idx p mem))
 24424		// cond: i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 24425		// result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem)
 24426		for {
 24427			_ = v.Args[1]
 24428			sh := v.Args[0]
 24429			if sh.Op != OpS390XSLDconst {
 24430				break
 24431			}
 24432			if sh.AuxInt != 8 {
 24433				break
 24434			}
 24435			x0 := sh.Args[0]
 24436			if x0.Op != OpS390XMOVBZloadidx {
 24437				break
 24438			}
 24439			i0 := x0.AuxInt
 24440			s := x0.Aux
 24441			mem := x0.Args[2]
 24442			p := x0.Args[0]
 24443			idx := x0.Args[1]
 24444			x1 := v.Args[1]
 24445			if x1.Op != OpS390XMOVBZloadidx {
 24446				break
 24447			}
 24448			i1 := x1.AuxInt
 24449			if x1.Aux != s {
 24450				break
 24451			}
 24452			_ = x1.Args[2]
 24453			if idx != x1.Args[0] {
 24454				break
 24455			}
 24456			if p != x1.Args[1] {
 24457				break
 24458			}
 24459			if mem != x1.Args[2] {
 24460				break
 24461			}
 24462			if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 24463				break
 24464			}
 24465			b = mergePoint(b, x0, x1)
 24466			v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 24467			v.reset(OpCopy)
 24468			v.AddArg(v0)
 24469			v0.AuxInt = i0
 24470			v0.Aux = s
 24471			v0.AddArg(p)
 24472			v0.AddArg(idx)
 24473			v0.AddArg(mem)
 24474			return true
 24475		}
 24476		// match: (OR sh:(SLDconst [8] x0:(MOVBZloadidx [i0] {s} idx p mem)) x1:(MOVBZloadidx [i1] {s} idx p mem))
 24477		// cond: i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 24478		// result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem)
 24479		for {
 24480			_ = v.Args[1]
 24481			sh := v.Args[0]
 24482			if sh.Op != OpS390XSLDconst {
 24483				break
 24484			}
 24485			if sh.AuxInt != 8 {
 24486				break
 24487			}
 24488			x0 := sh.Args[0]
 24489			if x0.Op != OpS390XMOVBZloadidx {
 24490				break
 24491			}
 24492			i0 := x0.AuxInt
 24493			s := x0.Aux
 24494			mem := x0.Args[2]
 24495			idx := x0.Args[0]
 24496			p := x0.Args[1]
 24497			x1 := v.Args[1]
 24498			if x1.Op != OpS390XMOVBZloadidx {
 24499				break
 24500			}
 24501			i1 := x1.AuxInt
 24502			if x1.Aux != s {
 24503				break
 24504			}
 24505			_ = x1.Args[2]
 24506			if idx != x1.Args[0] {
 24507				break
 24508			}
 24509			if p != x1.Args[1] {
 24510				break
 24511			}
 24512			if mem != x1.Args[2] {
 24513				break
 24514			}
 24515			if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 24516				break
 24517			}
 24518			b = mergePoint(b, x0, x1)
 24519			v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 24520			v.reset(OpCopy)
 24521			v.AddArg(v0)
 24522			v0.AuxInt = i0
 24523			v0.Aux = s
 24524			v0.AddArg(p)
 24525			v0.AddArg(idx)
 24526			v0.AddArg(mem)
 24527			return true
 24528		}
 24529		// match: (OR x1:(MOVHZloadidx [i1] {s} p idx mem) sh:(SLDconst [16] x0:(MOVHZloadidx [i0] {s} p idx mem)))
 24530		// cond: i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 24531		// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
 24532		for {
 24533			_ = v.Args[1]
 24534			x1 := v.Args[0]
 24535			if x1.Op != OpS390XMOVHZloadidx {
 24536				break
 24537			}
 24538			i1 := x1.AuxInt
 24539			s := x1.Aux
 24540			mem := x1.Args[2]
 24541			p := x1.Args[0]
 24542			idx := x1.Args[1]
 24543			sh := v.Args[1]
 24544			if sh.Op != OpS390XSLDconst {
 24545				break
 24546			}
 24547			if sh.AuxInt != 16 {
 24548				break
 24549			}
 24550			x0 := sh.Args[0]
 24551			if x0.Op != OpS390XMOVHZloadidx {
 24552				break
 24553			}
 24554			i0 := x0.AuxInt
 24555			if x0.Aux != s {
 24556				break
 24557			}
 24558			_ = x0.Args[2]
 24559			if p != x0.Args[0] {
 24560				break
 24561			}
 24562			if idx != x0.Args[1] {
 24563				break
 24564			}
 24565			if mem != x0.Args[2] {
 24566				break
 24567			}
 24568			if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 24569				break
 24570			}
 24571			b = mergePoint(b, x0, x1)
 24572			v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
 24573			v.reset(OpCopy)
 24574			v.AddArg(v0)
 24575			v0.AuxInt = i0
 24576			v0.Aux = s
 24577			v0.AddArg(p)
 24578			v0.AddArg(idx)
 24579			v0.AddArg(mem)
 24580			return true
 24581		}
 24582		return false
 24583	}
 24584	func rewriteValueS390X_OpS390XOR_40(v *Value) bool {
 24585		b := v.Block
 24586		typ := &b.Func.Config.Types
 24587		// match: (OR x1:(MOVHZloadidx [i1] {s} idx p mem) sh:(SLDconst [16] x0:(MOVHZloadidx [i0] {s} p idx mem)))
 24588		// cond: i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 24589		// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
 24590		for {
 24591			_ = v.Args[1]
 24592			x1 := v.Args[0]
 24593			if x1.Op != OpS390XMOVHZloadidx {
 24594				break
 24595			}
 24596			i1 := x1.AuxInt
 24597			s := x1.Aux
 24598			mem := x1.Args[2]
 24599			idx := x1.Args[0]
 24600			p := x1.Args[1]
 24601			sh := v.Args[1]
 24602			if sh.Op != OpS390XSLDconst {
 24603				break
 24604			}
 24605			if sh.AuxInt != 16 {
 24606				break
 24607			}
 24608			x0 := sh.Args[0]
 24609			if x0.Op != OpS390XMOVHZloadidx {
 24610				break
 24611			}
 24612			i0 := x0.AuxInt
 24613			if x0.Aux != s {
 24614				break
 24615			}
 24616			_ = x0.Args[2]
 24617			if p != x0.Args[0] {
 24618				break
 24619			}
 24620			if idx != x0.Args[1] {
 24621				break
 24622			}
 24623			if mem != x0.Args[2] {
 24624				break
 24625			}
 24626			if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 24627				break
 24628			}
 24629			b = mergePoint(b, x0, x1)
 24630			v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
 24631			v.reset(OpCopy)
 24632			v.AddArg(v0)
 24633			v0.AuxInt = i0
 24634			v0.Aux = s
 24635			v0.AddArg(p)
 24636			v0.AddArg(idx)
 24637			v0.AddArg(mem)
 24638			return true
 24639		}
 24640		// match: (OR x1:(MOVHZloadidx [i1] {s} p idx mem) sh:(SLDconst [16] x0:(MOVHZloadidx [i0] {s} idx p mem)))
 24641		// cond: i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 24642		// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
 24643		for {
 24644			_ = v.Args[1]
 24645			x1 := v.Args[0]
 24646			if x1.Op != OpS390XMOVHZloadidx {
 24647				break
 24648			}
 24649			i1 := x1.AuxInt
 24650			s := x1.Aux
 24651			mem := x1.Args[2]
 24652			p := x1.Args[0]
 24653			idx := x1.Args[1]
 24654			sh := v.Args[1]
 24655			if sh.Op != OpS390XSLDconst {
 24656				break
 24657			}
 24658			if sh.AuxInt != 16 {
 24659				break
 24660			}
 24661			x0 := sh.Args[0]
 24662			if x0.Op != OpS390XMOVHZloadidx {
 24663				break
 24664			}
 24665			i0 := x0.AuxInt
 24666			if x0.Aux != s {
 24667				break
 24668			}
 24669			_ = x0.Args[2]
 24670			if idx != x0.Args[0] {
 24671				break
 24672			}
 24673			if p != x0.Args[1] {
 24674				break
 24675			}
 24676			if mem != x0.Args[2] {
 24677				break
 24678			}
 24679			if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 24680				break
 24681			}
 24682			b = mergePoint(b, x0, x1)
 24683			v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
 24684			v.reset(OpCopy)
 24685			v.AddArg(v0)
 24686			v0.AuxInt = i0
 24687			v0.Aux = s
 24688			v0.AddArg(p)
 24689			v0.AddArg(idx)
 24690			v0.AddArg(mem)
 24691			return true
 24692		}
 24693		// match: (OR x1:(MOVHZloadidx [i1] {s} idx p mem) sh:(SLDconst [16] x0:(MOVHZloadidx [i0] {s} idx p mem)))
 24694		// cond: i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 24695		// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
 24696		for {
 24697			_ = v.Args[1]
 24698			x1 := v.Args[0]
 24699			if x1.Op != OpS390XMOVHZloadidx {
 24700				break
 24701			}
 24702			i1 := x1.AuxInt
 24703			s := x1.Aux
 24704			mem := x1.Args[2]
 24705			idx := x1.Args[0]
 24706			p := x1.Args[1]
 24707			sh := v.Args[1]
 24708			if sh.Op != OpS390XSLDconst {
 24709				break
 24710			}
 24711			if sh.AuxInt != 16 {
 24712				break
 24713			}
 24714			x0 := sh.Args[0]
 24715			if x0.Op != OpS390XMOVHZloadidx {
 24716				break
 24717			}
 24718			i0 := x0.AuxInt
 24719			if x0.Aux != s {
 24720				break
 24721			}
 24722			_ = x0.Args[2]
 24723			if idx != x0.Args[0] {
 24724				break
 24725			}
 24726			if p != x0.Args[1] {
 24727				break
 24728			}
 24729			if mem != x0.Args[2] {
 24730				break
 24731			}
 24732			if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 24733				break
 24734			}
 24735			b = mergePoint(b, x0, x1)
 24736			v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
 24737			v.reset(OpCopy)
 24738			v.AddArg(v0)
 24739			v0.AuxInt = i0
 24740			v0.Aux = s
 24741			v0.AddArg(p)
 24742			v0.AddArg(idx)
 24743			v0.AddArg(mem)
 24744			return true
 24745		}
 24746		// match: (OR sh:(SLDconst [16] x0:(MOVHZloadidx [i0] {s} p idx mem)) x1:(MOVHZloadidx [i1] {s} p idx mem))
 24747		// cond: i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 24748		// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
 24749		for {
 24750			_ = v.Args[1]
 24751			sh := v.Args[0]
 24752			if sh.Op != OpS390XSLDconst {
 24753				break
 24754			}
 24755			if sh.AuxInt != 16 {
 24756				break
 24757			}
 24758			x0 := sh.Args[0]
 24759			if x0.Op != OpS390XMOVHZloadidx {
 24760				break
 24761			}
 24762			i0 := x0.AuxInt
 24763			s := x0.Aux
 24764			mem := x0.Args[2]
 24765			p := x0.Args[0]
 24766			idx := x0.Args[1]
 24767			x1 := v.Args[1]
 24768			if x1.Op != OpS390XMOVHZloadidx {
 24769				break
 24770			}
 24771			i1 := x1.AuxInt
 24772			if x1.Aux != s {
 24773				break
 24774			}
 24775			_ = x1.Args[2]
 24776			if p != x1.Args[0] {
 24777				break
 24778			}
 24779			if idx != x1.Args[1] {
 24780				break
 24781			}
 24782			if mem != x1.Args[2] {
 24783				break
 24784			}
 24785			if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 24786				break
 24787			}
 24788			b = mergePoint(b, x0, x1)
 24789			v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
 24790			v.reset(OpCopy)
 24791			v.AddArg(v0)
 24792			v0.AuxInt = i0
 24793			v0.Aux = s
 24794			v0.AddArg(p)
 24795			v0.AddArg(idx)
 24796			v0.AddArg(mem)
 24797			return true
 24798		}
 24799		// match: (OR sh:(SLDconst [16] x0:(MOVHZloadidx [i0] {s} idx p mem)) x1:(MOVHZloadidx [i1] {s} p idx mem))
 24800		// cond: i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 24801		// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
 24802		for {
 24803			_ = v.Args[1]
 24804			sh := v.Args[0]
 24805			if sh.Op != OpS390XSLDconst {
 24806				break
 24807			}
 24808			if sh.AuxInt != 16 {
 24809				break
 24810			}
 24811			x0 := sh.Args[0]
 24812			if x0.Op != OpS390XMOVHZloadidx {
 24813				break
 24814			}
 24815			i0 := x0.AuxInt
 24816			s := x0.Aux
 24817			mem := x0.Args[2]
 24818			idx := x0.Args[0]
 24819			p := x0.Args[1]
 24820			x1 := v.Args[1]
 24821			if x1.Op != OpS390XMOVHZloadidx {
 24822				break
 24823			}
 24824			i1 := x1.AuxInt
 24825			if x1.Aux != s {
 24826				break
 24827			}
 24828			_ = x1.Args[2]
 24829			if p != x1.Args[0] {
 24830				break
 24831			}
 24832			if idx != x1.Args[1] {
 24833				break
 24834			}
 24835			if mem != x1.Args[2] {
 24836				break
 24837			}
 24838			if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 24839				break
 24840			}
 24841			b = mergePoint(b, x0, x1)
 24842			v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
 24843			v.reset(OpCopy)
 24844			v.AddArg(v0)
 24845			v0.AuxInt = i0
 24846			v0.Aux = s
 24847			v0.AddArg(p)
 24848			v0.AddArg(idx)
 24849			v0.AddArg(mem)
 24850			return true
 24851		}
 24852		// match: (OR sh:(SLDconst [16] x0:(MOVHZloadidx [i0] {s} p idx mem)) x1:(MOVHZloadidx [i1] {s} idx p mem))
 24853		// cond: i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 24854		// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
 24855		for {
 24856			_ = v.Args[1]
 24857			sh := v.Args[0]
 24858			if sh.Op != OpS390XSLDconst {
 24859				break
 24860			}
 24861			if sh.AuxInt != 16 {
 24862				break
 24863			}
 24864			x0 := sh.Args[0]
 24865			if x0.Op != OpS390XMOVHZloadidx {
 24866				break
 24867			}
 24868			i0 := x0.AuxInt
 24869			s := x0.Aux
 24870			mem := x0.Args[2]
 24871			p := x0.Args[0]
 24872			idx := x0.Args[1]
 24873			x1 := v.Args[1]
 24874			if x1.Op != OpS390XMOVHZloadidx {
 24875				break
 24876			}
 24877			i1 := x1.AuxInt
 24878			if x1.Aux != s {
 24879				break
 24880			}
 24881			_ = x1.Args[2]
 24882			if idx != x1.Args[0] {
 24883				break
 24884			}
 24885			if p != x1.Args[1] {
 24886				break
 24887			}
 24888			if mem != x1.Args[2] {
 24889				break
 24890			}
 24891			if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 24892				break
 24893			}
 24894			b = mergePoint(b, x0, x1)
 24895			v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
 24896			v.reset(OpCopy)
 24897			v.AddArg(v0)
 24898			v0.AuxInt = i0
 24899			v0.Aux = s
 24900			v0.AddArg(p)
 24901			v0.AddArg(idx)
 24902			v0.AddArg(mem)
 24903			return true
 24904		}
 24905		// match: (OR sh:(SLDconst [16] x0:(MOVHZloadidx [i0] {s} idx p mem)) x1:(MOVHZloadidx [i1] {s} idx p mem))
 24906		// cond: i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 24907		// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
 24908		for {
 24909			_ = v.Args[1]
 24910			sh := v.Args[0]
 24911			if sh.Op != OpS390XSLDconst {
 24912				break
 24913			}
 24914			if sh.AuxInt != 16 {
 24915				break
 24916			}
 24917			x0 := sh.Args[0]
 24918			if x0.Op != OpS390XMOVHZloadidx {
 24919				break
 24920			}
 24921			i0 := x0.AuxInt
 24922			s := x0.Aux
 24923			mem := x0.Args[2]
 24924			idx := x0.Args[0]
 24925			p := x0.Args[1]
 24926			x1 := v.Args[1]
 24927			if x1.Op != OpS390XMOVHZloadidx {
 24928				break
 24929			}
 24930			i1 := x1.AuxInt
 24931			if x1.Aux != s {
 24932				break
 24933			}
 24934			_ = x1.Args[2]
 24935			if idx != x1.Args[0] {
 24936				break
 24937			}
 24938			if p != x1.Args[1] {
 24939				break
 24940			}
 24941			if mem != x1.Args[2] {
 24942				break
 24943			}
 24944			if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 24945				break
 24946			}
 24947			b = mergePoint(b, x0, x1)
 24948			v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
 24949			v.reset(OpCopy)
 24950			v.AddArg(v0)
 24951			v0.AuxInt = i0
 24952			v0.Aux = s
 24953			v0.AddArg(p)
 24954			v0.AddArg(idx)
 24955			v0.AddArg(mem)
 24956			return true
 24957		}
 24958		// match: (OR x1:(MOVWZloadidx [i1] {s} p idx mem) sh:(SLDconst [32] x0:(MOVWZloadidx [i0] {s} p idx mem)))
 24959		// cond: i1 == i0+4 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 24960		// result: @mergePoint(b,x0,x1) (MOVDloadidx [i0] {s} p idx mem)
 24961		for {
 24962			_ = v.Args[1]
 24963			x1 := v.Args[0]
 24964			if x1.Op != OpS390XMOVWZloadidx {
 24965				break
 24966			}
 24967			i1 := x1.AuxInt
 24968			s := x1.Aux
 24969			mem := x1.Args[2]
 24970			p := x1.Args[0]
 24971			idx := x1.Args[1]
 24972			sh := v.Args[1]
 24973			if sh.Op != OpS390XSLDconst {
 24974				break
 24975			}
 24976			if sh.AuxInt != 32 {
 24977				break
 24978			}
 24979			x0 := sh.Args[0]
 24980			if x0.Op != OpS390XMOVWZloadidx {
 24981				break
 24982			}
 24983			i0 := x0.AuxInt
 24984			if x0.Aux != s {
 24985				break
 24986			}
 24987			_ = x0.Args[2]
 24988			if p != x0.Args[0] {
 24989				break
 24990			}
 24991			if idx != x0.Args[1] {
 24992				break
 24993			}
 24994			if mem != x0.Args[2] {
 24995				break
 24996			}
 24997			if !(i1 == i0+4 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 24998				break
 24999			}
 25000			b = mergePoint(b, x0, x1)
 25001			v0 := b.NewValue0(v.Pos, OpS390XMOVDloadidx, typ.UInt64)
 25002			v.reset(OpCopy)
 25003			v.AddArg(v0)
 25004			v0.AuxInt = i0
 25005			v0.Aux = s
 25006			v0.AddArg(p)
 25007			v0.AddArg(idx)
 25008			v0.AddArg(mem)
 25009			return true
 25010		}
 25011		// match: (OR x1:(MOVWZloadidx [i1] {s} idx p mem) sh:(SLDconst [32] x0:(MOVWZloadidx [i0] {s} p idx mem)))
 25012		// cond: i1 == i0+4 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 25013		// result: @mergePoint(b,x0,x1) (MOVDloadidx [i0] {s} p idx mem)
 25014		for {
 25015			_ = v.Args[1]
 25016			x1 := v.Args[0]
 25017			if x1.Op != OpS390XMOVWZloadidx {
 25018				break
 25019			}
 25020			i1 := x1.AuxInt
 25021			s := x1.Aux
 25022			mem := x1.Args[2]
 25023			idx := x1.Args[0]
 25024			p := x1.Args[1]
 25025			sh := v.Args[1]
 25026			if sh.Op != OpS390XSLDconst {
 25027				break
 25028			}
 25029			if sh.AuxInt != 32 {
 25030				break
 25031			}
 25032			x0 := sh.Args[0]
 25033			if x0.Op != OpS390XMOVWZloadidx {
 25034				break
 25035			}
 25036			i0 := x0.AuxInt
 25037			if x0.Aux != s {
 25038				break
 25039			}
 25040			_ = x0.Args[2]
 25041			if p != x0.Args[0] {
 25042				break
 25043			}
 25044			if idx != x0.Args[1] {
 25045				break
 25046			}
 25047			if mem != x0.Args[2] {
 25048				break
 25049			}
 25050			if !(i1 == i0+4 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 25051				break
 25052			}
 25053			b = mergePoint(b, x0, x1)
 25054			v0 := b.NewValue0(v.Pos, OpS390XMOVDloadidx, typ.UInt64)
 25055			v.reset(OpCopy)
 25056			v.AddArg(v0)
 25057			v0.AuxInt = i0
 25058			v0.Aux = s
 25059			v0.AddArg(p)
 25060			v0.AddArg(idx)
 25061			v0.AddArg(mem)
 25062			return true
 25063		}
 25064		// match: (OR x1:(MOVWZloadidx [i1] {s} p idx mem) sh:(SLDconst [32] x0:(MOVWZloadidx [i0] {s} idx p mem)))
 25065		// cond: i1 == i0+4 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 25066		// result: @mergePoint(b,x0,x1) (MOVDloadidx [i0] {s} p idx mem)
 25067		for {
 25068			_ = v.Args[1]
 25069			x1 := v.Args[0]
 25070			if x1.Op != OpS390XMOVWZloadidx {
 25071				break
 25072			}
 25073			i1 := x1.AuxInt
 25074			s := x1.Aux
 25075			mem := x1.Args[2]
 25076			p := x1.Args[0]
 25077			idx := x1.Args[1]
 25078			sh := v.Args[1]
 25079			if sh.Op != OpS390XSLDconst {
 25080				break
 25081			}
 25082			if sh.AuxInt != 32 {
 25083				break
 25084			}
 25085			x0 := sh.Args[0]
 25086			if x0.Op != OpS390XMOVWZloadidx {
 25087				break
 25088			}
 25089			i0 := x0.AuxInt
 25090			if x0.Aux != s {
 25091				break
 25092			}
 25093			_ = x0.Args[2]
 25094			if idx != x0.Args[0] {
 25095				break
 25096			}
 25097			if p != x0.Args[1] {
 25098				break
 25099			}
 25100			if mem != x0.Args[2] {
 25101				break
 25102			}
 25103			if !(i1 == i0+4 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 25104				break
 25105			}
 25106			b = mergePoint(b, x0, x1)
 25107			v0 := b.NewValue0(v.Pos, OpS390XMOVDloadidx, typ.UInt64)
 25108			v.reset(OpCopy)
 25109			v.AddArg(v0)
 25110			v0.AuxInt = i0
 25111			v0.Aux = s
 25112			v0.AddArg(p)
 25113			v0.AddArg(idx)
 25114			v0.AddArg(mem)
 25115			return true
 25116		}
 25117		return false
 25118	}
 25119	func rewriteValueS390X_OpS390XOR_50(v *Value) bool {
 25120		b := v.Block
 25121		typ := &b.Func.Config.Types
 25122		// match: (OR x1:(MOVWZloadidx [i1] {s} idx p mem) sh:(SLDconst [32] x0:(MOVWZloadidx [i0] {s} idx p mem)))
 25123		// cond: i1 == i0+4 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 25124		// result: @mergePoint(b,x0,x1) (MOVDloadidx [i0] {s} p idx mem)
 25125		for {
 25126			_ = v.Args[1]
 25127			x1 := v.Args[0]
 25128			if x1.Op != OpS390XMOVWZloadidx {
 25129				break
 25130			}
 25131			i1 := x1.AuxInt
 25132			s := x1.Aux
 25133			mem := x1.Args[2]
 25134			idx := x1.Args[0]
 25135			p := x1.Args[1]
 25136			sh := v.Args[1]
 25137			if sh.Op != OpS390XSLDconst {
 25138				break
 25139			}
 25140			if sh.AuxInt != 32 {
 25141				break
 25142			}
 25143			x0 := sh.Args[0]
 25144			if x0.Op != OpS390XMOVWZloadidx {
 25145				break
 25146			}
 25147			i0 := x0.AuxInt
 25148			if x0.Aux != s {
 25149				break
 25150			}
 25151			_ = x0.Args[2]
 25152			if idx != x0.Args[0] {
 25153				break
 25154			}
 25155			if p != x0.Args[1] {
 25156				break
 25157			}
 25158			if mem != x0.Args[2] {
 25159				break
 25160			}
 25161			if !(i1 == i0+4 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 25162				break
 25163			}
 25164			b = mergePoint(b, x0, x1)
 25165			v0 := b.NewValue0(v.Pos, OpS390XMOVDloadidx, typ.UInt64)
 25166			v.reset(OpCopy)
 25167			v.AddArg(v0)
 25168			v0.AuxInt = i0
 25169			v0.Aux = s
 25170			v0.AddArg(p)
 25171			v0.AddArg(idx)
 25172			v0.AddArg(mem)
 25173			return true
 25174		}
 25175		// match: (OR sh:(SLDconst [32] x0:(MOVWZloadidx [i0] {s} p idx mem)) x1:(MOVWZloadidx [i1] {s} p idx mem))
 25176		// cond: i1 == i0+4 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 25177		// result: @mergePoint(b,x0,x1) (MOVDloadidx [i0] {s} p idx mem)
 25178		for {
 25179			_ = v.Args[1]
 25180			sh := v.Args[0]
 25181			if sh.Op != OpS390XSLDconst {
 25182				break
 25183			}
 25184			if sh.AuxInt != 32 {
 25185				break
 25186			}
 25187			x0 := sh.Args[0]
 25188			if x0.Op != OpS390XMOVWZloadidx {
 25189				break
 25190			}
 25191			i0 := x0.AuxInt
 25192			s := x0.Aux
 25193			mem := x0.Args[2]
 25194			p := x0.Args[0]
 25195			idx := x0.Args[1]
 25196			x1 := v.Args[1]
 25197			if x1.Op != OpS390XMOVWZloadidx {
 25198				break
 25199			}
 25200			i1 := x1.AuxInt
 25201			if x1.Aux != s {
 25202				break
 25203			}
 25204			_ = x1.Args[2]
 25205			if p != x1.Args[0] {
 25206				break
 25207			}
 25208			if idx != x1.Args[1] {
 25209				break
 25210			}
 25211			if mem != x1.Args[2] {
 25212				break
 25213			}
 25214			if !(i1 == i0+4 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 25215				break
 25216			}
 25217			b = mergePoint(b, x0, x1)
 25218			v0 := b.NewValue0(v.Pos, OpS390XMOVDloadidx, typ.UInt64)
 25219			v.reset(OpCopy)
 25220			v.AddArg(v0)
 25221			v0.AuxInt = i0
 25222			v0.Aux = s
 25223			v0.AddArg(p)
 25224			v0.AddArg(idx)
 25225			v0.AddArg(mem)
 25226			return true
 25227		}
 25228		// match: (OR sh:(SLDconst [32] x0:(MOVWZloadidx [i0] {s} idx p mem)) x1:(MOVWZloadidx [i1] {s} p idx mem))
 25229		// cond: i1 == i0+4 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 25230		// result: @mergePoint(b,x0,x1) (MOVDloadidx [i0] {s} p idx mem)
 25231		for {
 25232			_ = v.Args[1]
 25233			sh := v.Args[0]
 25234			if sh.Op != OpS390XSLDconst {
 25235				break
 25236			}
 25237			if sh.AuxInt != 32 {
 25238				break
 25239			}
 25240			x0 := sh.Args[0]
 25241			if x0.Op != OpS390XMOVWZloadidx {
 25242				break
 25243			}
 25244			i0 := x0.AuxInt
 25245			s := x0.Aux
 25246			mem := x0.Args[2]
 25247			idx := x0.Args[0]
 25248			p := x0.Args[1]
 25249			x1 := v.Args[1]
 25250			if x1.Op != OpS390XMOVWZloadidx {
 25251				break
 25252			}
 25253			i1 := x1.AuxInt
 25254			if x1.Aux != s {
 25255				break
 25256			}
 25257			_ = x1.Args[2]
 25258			if p != x1.Args[0] {
 25259				break
 25260			}
 25261			if idx != x1.Args[1] {
 25262				break
 25263			}
 25264			if mem != x1.Args[2] {
 25265				break
 25266			}
 25267			if !(i1 == i0+4 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 25268				break
 25269			}
 25270			b = mergePoint(b, x0, x1)
 25271			v0 := b.NewValue0(v.Pos, OpS390XMOVDloadidx, typ.UInt64)
 25272			v.reset(OpCopy)
 25273			v.AddArg(v0)
 25274			v0.AuxInt = i0
 25275			v0.Aux = s
 25276			v0.AddArg(p)
 25277			v0.AddArg(idx)
 25278			v0.AddArg(mem)
 25279			return true
 25280		}
 25281		// match: (OR sh:(SLDconst [32] x0:(MOVWZloadidx [i0] {s} p idx mem)) x1:(MOVWZloadidx [i1] {s} idx p mem))
 25282		// cond: i1 == i0+4 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 25283		// result: @mergePoint(b,x0,x1) (MOVDloadidx [i0] {s} p idx mem)
 25284		for {
 25285			_ = v.Args[1]
 25286			sh := v.Args[0]
 25287			if sh.Op != OpS390XSLDconst {
 25288				break
 25289			}
 25290			if sh.AuxInt != 32 {
 25291				break
 25292			}
 25293			x0 := sh.Args[0]
 25294			if x0.Op != OpS390XMOVWZloadidx {
 25295				break
 25296			}
 25297			i0 := x0.AuxInt
 25298			s := x0.Aux
 25299			mem := x0.Args[2]
 25300			p := x0.Args[0]
 25301			idx := x0.Args[1]
 25302			x1 := v.Args[1]
 25303			if x1.Op != OpS390XMOVWZloadidx {
 25304				break
 25305			}
 25306			i1 := x1.AuxInt
 25307			if x1.Aux != s {
 25308				break
 25309			}
 25310			_ = x1.Args[2]
 25311			if idx != x1.Args[0] {
 25312				break
 25313			}
 25314			if p != x1.Args[1] {
 25315				break
 25316			}
 25317			if mem != x1.Args[2] {
 25318				break
 25319			}
 25320			if !(i1 == i0+4 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 25321				break
 25322			}
 25323			b = mergePoint(b, x0, x1)
 25324			v0 := b.NewValue0(v.Pos, OpS390XMOVDloadidx, typ.UInt64)
 25325			v.reset(OpCopy)
 25326			v.AddArg(v0)
 25327			v0.AuxInt = i0
 25328			v0.Aux = s
 25329			v0.AddArg(p)
 25330			v0.AddArg(idx)
 25331			v0.AddArg(mem)
 25332			return true
 25333		}
 25334		// match: (OR sh:(SLDconst [32] x0:(MOVWZloadidx [i0] {s} idx p mem)) x1:(MOVWZloadidx [i1] {s} idx p mem))
 25335		// cond: i1 == i0+4 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 25336		// result: @mergePoint(b,x0,x1) (MOVDloadidx [i0] {s} p idx mem)
 25337		for {
 25338			_ = v.Args[1]
 25339			sh := v.Args[0]
 25340			if sh.Op != OpS390XSLDconst {
 25341				break
 25342			}
 25343			if sh.AuxInt != 32 {
 25344				break
 25345			}
 25346			x0 := sh.Args[0]
 25347			if x0.Op != OpS390XMOVWZloadidx {
 25348				break
 25349			}
 25350			i0 := x0.AuxInt
 25351			s := x0.Aux
 25352			mem := x0.Args[2]
 25353			idx := x0.Args[0]
 25354			p := x0.Args[1]
 25355			x1 := v.Args[1]
 25356			if x1.Op != OpS390XMOVWZloadidx {
 25357				break
 25358			}
 25359			i1 := x1.AuxInt
 25360			if x1.Aux != s {
 25361				break
 25362			}
 25363			_ = x1.Args[2]
 25364			if idx != x1.Args[0] {
 25365				break
 25366			}
 25367			if p != x1.Args[1] {
 25368				break
 25369			}
 25370			if mem != x1.Args[2] {
 25371				break
 25372			}
 25373			if !(i1 == i0+4 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 25374				break
 25375			}
 25376			b = mergePoint(b, x0, x1)
 25377			v0 := b.NewValue0(v.Pos, OpS390XMOVDloadidx, typ.UInt64)
 25378			v.reset(OpCopy)
 25379			v.AddArg(v0)
 25380			v0.AuxInt = i0
 25381			v0.Aux = s
 25382			v0.AddArg(p)
 25383			v0.AddArg(idx)
 25384			v0.AddArg(mem)
 25385			return true
 25386		}
 25387		// match: (OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) or:(OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)) y))
 25388		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 25389		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
 25390		for {
 25391			_ = v.Args[1]
 25392			s0 := v.Args[0]
 25393			if s0.Op != OpS390XSLDconst {
 25394				break
 25395			}
 25396			j0 := s0.AuxInt
 25397			x0 := s0.Args[0]
 25398			if x0.Op != OpS390XMOVBZloadidx {
 25399				break
 25400			}
 25401			i0 := x0.AuxInt
 25402			s := x0.Aux
 25403			mem := x0.Args[2]
 25404			p := x0.Args[0]
 25405			idx := x0.Args[1]
 25406			or := v.Args[1]
 25407			if or.Op != OpS390XOR {
 25408				break
 25409			}
 25410			y := or.Args[1]
 25411			s1 := or.Args[0]
 25412			if s1.Op != OpS390XSLDconst {
 25413				break
 25414			}
 25415			j1 := s1.AuxInt
 25416			x1 := s1.Args[0]
 25417			if x1.Op != OpS390XMOVBZloadidx {
 25418				break
 25419			}
 25420			i1 := x1.AuxInt
 25421			if x1.Aux != s {
 25422				break
 25423			}
 25424			_ = x1.Args[2]
 25425			if p != x1.Args[0] {
 25426				break
 25427			}
 25428			if idx != x1.Args[1] {
 25429				break
 25430			}
 25431			if mem != x1.Args[2] {
 25432				break
 25433			}
 25434			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 25435				break
 25436			}
 25437			b = mergePoint(b, x0, x1, y)
 25438			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 25439			v.reset(OpCopy)
 25440			v.AddArg(v0)
 25441			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 25442			v1.AuxInt = j1
 25443			v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 25444			v2.AuxInt = i0
 25445			v2.Aux = s
 25446			v2.AddArg(p)
 25447			v2.AddArg(idx)
 25448			v2.AddArg(mem)
 25449			v1.AddArg(v2)
 25450			v0.AddArg(v1)
 25451			v0.AddArg(y)
 25452			return true
 25453		}
 25454		// match: (OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) or:(OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)) y))
 25455		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 25456		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
 25457		for {
 25458			_ = v.Args[1]
 25459			s0 := v.Args[0]
 25460			if s0.Op != OpS390XSLDconst {
 25461				break
 25462			}
 25463			j0 := s0.AuxInt
 25464			x0 := s0.Args[0]
 25465			if x0.Op != OpS390XMOVBZloadidx {
 25466				break
 25467			}
 25468			i0 := x0.AuxInt
 25469			s := x0.Aux
 25470			mem := x0.Args[2]
 25471			idx := x0.Args[0]
 25472			p := x0.Args[1]
 25473			or := v.Args[1]
 25474			if or.Op != OpS390XOR {
 25475				break
 25476			}
 25477			y := or.Args[1]
 25478			s1 := or.Args[0]
 25479			if s1.Op != OpS390XSLDconst {
 25480				break
 25481			}
 25482			j1 := s1.AuxInt
 25483			x1 := s1.Args[0]
 25484			if x1.Op != OpS390XMOVBZloadidx {
 25485				break
 25486			}
 25487			i1 := x1.AuxInt
 25488			if x1.Aux != s {
 25489				break
 25490			}
 25491			_ = x1.Args[2]
 25492			if p != x1.Args[0] {
 25493				break
 25494			}
 25495			if idx != x1.Args[1] {
 25496				break
 25497			}
 25498			if mem != x1.Args[2] {
 25499				break
 25500			}
 25501			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 25502				break
 25503			}
 25504			b = mergePoint(b, x0, x1, y)
 25505			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 25506			v.reset(OpCopy)
 25507			v.AddArg(v0)
 25508			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 25509			v1.AuxInt = j1
 25510			v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 25511			v2.AuxInt = i0
 25512			v2.Aux = s
 25513			v2.AddArg(p)
 25514			v2.AddArg(idx)
 25515			v2.AddArg(mem)
 25516			v1.AddArg(v2)
 25517			v0.AddArg(v1)
 25518			v0.AddArg(y)
 25519			return true
 25520		}
 25521		// match: (OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) or:(OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) y))
 25522		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 25523		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
 25524		for {
 25525			_ = v.Args[1]
 25526			s0 := v.Args[0]
 25527			if s0.Op != OpS390XSLDconst {
 25528				break
 25529			}
 25530			j0 := s0.AuxInt
 25531			x0 := s0.Args[0]
 25532			if x0.Op != OpS390XMOVBZloadidx {
 25533				break
 25534			}
 25535			i0 := x0.AuxInt
 25536			s := x0.Aux
 25537			mem := x0.Args[2]
 25538			p := x0.Args[0]
 25539			idx := x0.Args[1]
 25540			or := v.Args[1]
 25541			if or.Op != OpS390XOR {
 25542				break
 25543			}
 25544			y := or.Args[1]
 25545			s1 := or.Args[0]
 25546			if s1.Op != OpS390XSLDconst {
 25547				break
 25548			}
 25549			j1 := s1.AuxInt
 25550			x1 := s1.Args[0]
 25551			if x1.Op != OpS390XMOVBZloadidx {
 25552				break
 25553			}
 25554			i1 := x1.AuxInt
 25555			if x1.Aux != s {
 25556				break
 25557			}
 25558			_ = x1.Args[2]
 25559			if idx != x1.Args[0] {
 25560				break
 25561			}
 25562			if p != x1.Args[1] {
 25563				break
 25564			}
 25565			if mem != x1.Args[2] {
 25566				break
 25567			}
 25568			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 25569				break
 25570			}
 25571			b = mergePoint(b, x0, x1, y)
 25572			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 25573			v.reset(OpCopy)
 25574			v.AddArg(v0)
 25575			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 25576			v1.AuxInt = j1
 25577			v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 25578			v2.AuxInt = i0
 25579			v2.Aux = s
 25580			v2.AddArg(p)
 25581			v2.AddArg(idx)
 25582			v2.AddArg(mem)
 25583			v1.AddArg(v2)
 25584			v0.AddArg(v1)
 25585			v0.AddArg(y)
 25586			return true
 25587		}
 25588		// match: (OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) or:(OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) y))
 25589		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 25590		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
 25591		for {
 25592			_ = v.Args[1]
 25593			s0 := v.Args[0]
 25594			if s0.Op != OpS390XSLDconst {
 25595				break
 25596			}
 25597			j0 := s0.AuxInt
 25598			x0 := s0.Args[0]
 25599			if x0.Op != OpS390XMOVBZloadidx {
 25600				break
 25601			}
 25602			i0 := x0.AuxInt
 25603			s := x0.Aux
 25604			mem := x0.Args[2]
 25605			idx := x0.Args[0]
 25606			p := x0.Args[1]
 25607			or := v.Args[1]
 25608			if or.Op != OpS390XOR {
 25609				break
 25610			}
 25611			y := or.Args[1]
 25612			s1 := or.Args[0]
 25613			if s1.Op != OpS390XSLDconst {
 25614				break
 25615			}
 25616			j1 := s1.AuxInt
 25617			x1 := s1.Args[0]
 25618			if x1.Op != OpS390XMOVBZloadidx {
 25619				break
 25620			}
 25621			i1 := x1.AuxInt
 25622			if x1.Aux != s {
 25623				break
 25624			}
 25625			_ = x1.Args[2]
 25626			if idx != x1.Args[0] {
 25627				break
 25628			}
 25629			if p != x1.Args[1] {
 25630				break
 25631			}
 25632			if mem != x1.Args[2] {
 25633				break
 25634			}
 25635			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 25636				break
 25637			}
 25638			b = mergePoint(b, x0, x1, y)
 25639			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 25640			v.reset(OpCopy)
 25641			v.AddArg(v0)
 25642			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 25643			v1.AuxInt = j1
 25644			v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 25645			v2.AuxInt = i0
 25646			v2.Aux = s
 25647			v2.AddArg(p)
 25648			v2.AddArg(idx)
 25649			v2.AddArg(mem)
 25650			v1.AddArg(v2)
 25651			v0.AddArg(v1)
 25652			v0.AddArg(y)
 25653			return true
 25654		}
 25655		// match: (OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) or:(OR y s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem))))
 25656		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 25657		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
 25658		for {
 25659			_ = v.Args[1]
 25660			s0 := v.Args[0]
 25661			if s0.Op != OpS390XSLDconst {
 25662				break
 25663			}
 25664			j0 := s0.AuxInt
 25665			x0 := s0.Args[0]
 25666			if x0.Op != OpS390XMOVBZloadidx {
 25667				break
 25668			}
 25669			i0 := x0.AuxInt
 25670			s := x0.Aux
 25671			mem := x0.Args[2]
 25672			p := x0.Args[0]
 25673			idx := x0.Args[1]
 25674			or := v.Args[1]
 25675			if or.Op != OpS390XOR {
 25676				break
 25677			}
 25678			_ = or.Args[1]
 25679			y := or.Args[0]
 25680			s1 := or.Args[1]
 25681			if s1.Op != OpS390XSLDconst {
 25682				break
 25683			}
 25684			j1 := s1.AuxInt
 25685			x1 := s1.Args[0]
 25686			if x1.Op != OpS390XMOVBZloadidx {
 25687				break
 25688			}
 25689			i1 := x1.AuxInt
 25690			if x1.Aux != s {
 25691				break
 25692			}
 25693			_ = x1.Args[2]
 25694			if p != x1.Args[0] {
 25695				break
 25696			}
 25697			if idx != x1.Args[1] {
 25698				break
 25699			}
 25700			if mem != x1.Args[2] {
 25701				break
 25702			}
 25703			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 25704				break
 25705			}
 25706			b = mergePoint(b, x0, x1, y)
 25707			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 25708			v.reset(OpCopy)
 25709			v.AddArg(v0)
 25710			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 25711			v1.AuxInt = j1
 25712			v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 25713			v2.AuxInt = i0
 25714			v2.Aux = s
 25715			v2.AddArg(p)
 25716			v2.AddArg(idx)
 25717			v2.AddArg(mem)
 25718			v1.AddArg(v2)
 25719			v0.AddArg(v1)
 25720			v0.AddArg(y)
 25721			return true
 25722		}
 25723		return false
 25724	}
 25725	func rewriteValueS390X_OpS390XOR_60(v *Value) bool {
 25726		b := v.Block
 25727		typ := &b.Func.Config.Types
 25728		// match: (OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) or:(OR y s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem))))
 25729		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 25730		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
 25731		for {
 25732			_ = v.Args[1]
 25733			s0 := v.Args[0]
 25734			if s0.Op != OpS390XSLDconst {
 25735				break
 25736			}
 25737			j0 := s0.AuxInt
 25738			x0 := s0.Args[0]
 25739			if x0.Op != OpS390XMOVBZloadidx {
 25740				break
 25741			}
 25742			i0 := x0.AuxInt
 25743			s := x0.Aux
 25744			mem := x0.Args[2]
 25745			idx := x0.Args[0]
 25746			p := x0.Args[1]
 25747			or := v.Args[1]
 25748			if or.Op != OpS390XOR {
 25749				break
 25750			}
 25751			_ = or.Args[1]
 25752			y := or.Args[0]
 25753			s1 := or.Args[1]
 25754			if s1.Op != OpS390XSLDconst {
 25755				break
 25756			}
 25757			j1 := s1.AuxInt
 25758			x1 := s1.Args[0]
 25759			if x1.Op != OpS390XMOVBZloadidx {
 25760				break
 25761			}
 25762			i1 := x1.AuxInt
 25763			if x1.Aux != s {
 25764				break
 25765			}
 25766			_ = x1.Args[2]
 25767			if p != x1.Args[0] {
 25768				break
 25769			}
 25770			if idx != x1.Args[1] {
 25771				break
 25772			}
 25773			if mem != x1.Args[2] {
 25774				break
 25775			}
 25776			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 25777				break
 25778			}
 25779			b = mergePoint(b, x0, x1, y)
 25780			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 25781			v.reset(OpCopy)
 25782			v.AddArg(v0)
 25783			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 25784			v1.AuxInt = j1
 25785			v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 25786			v2.AuxInt = i0
 25787			v2.Aux = s
 25788			v2.AddArg(p)
 25789			v2.AddArg(idx)
 25790			v2.AddArg(mem)
 25791			v1.AddArg(v2)
 25792			v0.AddArg(v1)
 25793			v0.AddArg(y)
 25794			return true
 25795		}
 25796		// match: (OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) or:(OR y s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem))))
 25797		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 25798		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
 25799		for {
 25800			_ = v.Args[1]
 25801			s0 := v.Args[0]
 25802			if s0.Op != OpS390XSLDconst {
 25803				break
 25804			}
 25805			j0 := s0.AuxInt
 25806			x0 := s0.Args[0]
 25807			if x0.Op != OpS390XMOVBZloadidx {
 25808				break
 25809			}
 25810			i0 := x0.AuxInt
 25811			s := x0.Aux
 25812			mem := x0.Args[2]
 25813			p := x0.Args[0]
 25814			idx := x0.Args[1]
 25815			or := v.Args[1]
 25816			if or.Op != OpS390XOR {
 25817				break
 25818			}
 25819			_ = or.Args[1]
 25820			y := or.Args[0]
 25821			s1 := or.Args[1]
 25822			if s1.Op != OpS390XSLDconst {
 25823				break
 25824			}
 25825			j1 := s1.AuxInt
 25826			x1 := s1.Args[0]
 25827			if x1.Op != OpS390XMOVBZloadidx {
 25828				break
 25829			}
 25830			i1 := x1.AuxInt
 25831			if x1.Aux != s {
 25832				break
 25833			}
 25834			_ = x1.Args[2]
 25835			if idx != x1.Args[0] {
 25836				break
 25837			}
 25838			if p != x1.Args[1] {
 25839				break
 25840			}
 25841			if mem != x1.Args[2] {
 25842				break
 25843			}
 25844			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 25845				break
 25846			}
 25847			b = mergePoint(b, x0, x1, y)
 25848			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 25849			v.reset(OpCopy)
 25850			v.AddArg(v0)
 25851			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 25852			v1.AuxInt = j1
 25853			v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 25854			v2.AuxInt = i0
 25855			v2.Aux = s
 25856			v2.AddArg(p)
 25857			v2.AddArg(idx)
 25858			v2.AddArg(mem)
 25859			v1.AddArg(v2)
 25860			v0.AddArg(v1)
 25861			v0.AddArg(y)
 25862			return true
 25863		}
 25864		// match: (OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) or:(OR y s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem))))
 25865		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 25866		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
 25867		for {
 25868			_ = v.Args[1]
 25869			s0 := v.Args[0]
 25870			if s0.Op != OpS390XSLDconst {
 25871				break
 25872			}
 25873			j0 := s0.AuxInt
 25874			x0 := s0.Args[0]
 25875			if x0.Op != OpS390XMOVBZloadidx {
 25876				break
 25877			}
 25878			i0 := x0.AuxInt
 25879			s := x0.Aux
 25880			mem := x0.Args[2]
 25881			idx := x0.Args[0]
 25882			p := x0.Args[1]
 25883			or := v.Args[1]
 25884			if or.Op != OpS390XOR {
 25885				break
 25886			}
 25887			_ = or.Args[1]
 25888			y := or.Args[0]
 25889			s1 := or.Args[1]
 25890			if s1.Op != OpS390XSLDconst {
 25891				break
 25892			}
 25893			j1 := s1.AuxInt
 25894			x1 := s1.Args[0]
 25895			if x1.Op != OpS390XMOVBZloadidx {
 25896				break
 25897			}
 25898			i1 := x1.AuxInt
 25899			if x1.Aux != s {
 25900				break
 25901			}
 25902			_ = x1.Args[2]
 25903			if idx != x1.Args[0] {
 25904				break
 25905			}
 25906			if p != x1.Args[1] {
 25907				break
 25908			}
 25909			if mem != x1.Args[2] {
 25910				break
 25911			}
 25912			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 25913				break
 25914			}
 25915			b = mergePoint(b, x0, x1, y)
 25916			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 25917			v.reset(OpCopy)
 25918			v.AddArg(v0)
 25919			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 25920			v1.AuxInt = j1
 25921			v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 25922			v2.AuxInt = i0
 25923			v2.Aux = s
 25924			v2.AddArg(p)
 25925			v2.AddArg(idx)
 25926			v2.AddArg(mem)
 25927			v1.AddArg(v2)
 25928			v0.AddArg(v1)
 25929			v0.AddArg(y)
 25930			return true
 25931		}
 25932		// match: (OR or:(OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)) y) s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)))
 25933		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 25934		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
 25935		for {
 25936			_ = v.Args[1]
 25937			or := v.Args[0]
 25938			if or.Op != OpS390XOR {
 25939				break
 25940			}
 25941			y := or.Args[1]
 25942			s1 := or.Args[0]
 25943			if s1.Op != OpS390XSLDconst {
 25944				break
 25945			}
 25946			j1 := s1.AuxInt
 25947			x1 := s1.Args[0]
 25948			if x1.Op != OpS390XMOVBZloadidx {
 25949				break
 25950			}
 25951			i1 := x1.AuxInt
 25952			s := x1.Aux
 25953			mem := x1.Args[2]
 25954			p := x1.Args[0]
 25955			idx := x1.Args[1]
 25956			s0 := v.Args[1]
 25957			if s0.Op != OpS390XSLDconst {
 25958				break
 25959			}
 25960			j0 := s0.AuxInt
 25961			x0 := s0.Args[0]
 25962			if x0.Op != OpS390XMOVBZloadidx {
 25963				break
 25964			}
 25965			i0 := x0.AuxInt
 25966			if x0.Aux != s {
 25967				break
 25968			}
 25969			_ = x0.Args[2]
 25970			if p != x0.Args[0] {
 25971				break
 25972			}
 25973			if idx != x0.Args[1] {
 25974				break
 25975			}
 25976			if mem != x0.Args[2] {
 25977				break
 25978			}
 25979			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 25980				break
 25981			}
 25982			b = mergePoint(b, x0, x1, y)
 25983			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 25984			v.reset(OpCopy)
 25985			v.AddArg(v0)
 25986			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 25987			v1.AuxInt = j1
 25988			v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 25989			v2.AuxInt = i0
 25990			v2.Aux = s
 25991			v2.AddArg(p)
 25992			v2.AddArg(idx)
 25993			v2.AddArg(mem)
 25994			v1.AddArg(v2)
 25995			v0.AddArg(v1)
 25996			v0.AddArg(y)
 25997			return true
 25998		}
 25999		// match: (OR or:(OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) y) s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)))
 26000		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 26001		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
 26002		for {
 26003			_ = v.Args[1]
 26004			or := v.Args[0]
 26005			if or.Op != OpS390XOR {
 26006				break
 26007			}
 26008			y := or.Args[1]
 26009			s1 := or.Args[0]
 26010			if s1.Op != OpS390XSLDconst {
 26011				break
 26012			}
 26013			j1 := s1.AuxInt
 26014			x1 := s1.Args[0]
 26015			if x1.Op != OpS390XMOVBZloadidx {
 26016				break
 26017			}
 26018			i1 := x1.AuxInt
 26019			s := x1.Aux
 26020			mem := x1.Args[2]
 26021			idx := x1.Args[0]
 26022			p := x1.Args[1]
 26023			s0 := v.Args[1]
 26024			if s0.Op != OpS390XSLDconst {
 26025				break
 26026			}
 26027			j0 := s0.AuxInt
 26028			x0 := s0.Args[0]
 26029			if x0.Op != OpS390XMOVBZloadidx {
 26030				break
 26031			}
 26032			i0 := x0.AuxInt
 26033			if x0.Aux != s {
 26034				break
 26035			}
 26036			_ = x0.Args[2]
 26037			if p != x0.Args[0] {
 26038				break
 26039			}
 26040			if idx != x0.Args[1] {
 26041				break
 26042			}
 26043			if mem != x0.Args[2] {
 26044				break
 26045			}
 26046			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 26047				break
 26048			}
 26049			b = mergePoint(b, x0, x1, y)
 26050			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 26051			v.reset(OpCopy)
 26052			v.AddArg(v0)
 26053			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 26054			v1.AuxInt = j1
 26055			v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 26056			v2.AuxInt = i0
 26057			v2.Aux = s
 26058			v2.AddArg(p)
 26059			v2.AddArg(idx)
 26060			v2.AddArg(mem)
 26061			v1.AddArg(v2)
 26062			v0.AddArg(v1)
 26063			v0.AddArg(y)
 26064			return true
 26065		}
 26066		// match: (OR or:(OR y s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem))) s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)))
 26067		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 26068		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
 26069		for {
 26070			_ = v.Args[1]
 26071			or := v.Args[0]
 26072			if or.Op != OpS390XOR {
 26073				break
 26074			}
 26075			_ = or.Args[1]
 26076			y := or.Args[0]
 26077			s1 := or.Args[1]
 26078			if s1.Op != OpS390XSLDconst {
 26079				break
 26080			}
 26081			j1 := s1.AuxInt
 26082			x1 := s1.Args[0]
 26083			if x1.Op != OpS390XMOVBZloadidx {
 26084				break
 26085			}
 26086			i1 := x1.AuxInt
 26087			s := x1.Aux
 26088			mem := x1.Args[2]
 26089			p := x1.Args[0]
 26090			idx := x1.Args[1]
 26091			s0 := v.Args[1]
 26092			if s0.Op != OpS390XSLDconst {
 26093				break
 26094			}
 26095			j0 := s0.AuxInt
 26096			x0 := s0.Args[0]
 26097			if x0.Op != OpS390XMOVBZloadidx {
 26098				break
 26099			}
 26100			i0 := x0.AuxInt
 26101			if x0.Aux != s {
 26102				break
 26103			}
 26104			_ = x0.Args[2]
 26105			if p != x0.Args[0] {
 26106				break
 26107			}
 26108			if idx != x0.Args[1] {
 26109				break
 26110			}
 26111			if mem != x0.Args[2] {
 26112				break
 26113			}
 26114			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 26115				break
 26116			}
 26117			b = mergePoint(b, x0, x1, y)
 26118			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 26119			v.reset(OpCopy)
 26120			v.AddArg(v0)
 26121			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 26122			v1.AuxInt = j1
 26123			v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 26124			v2.AuxInt = i0
 26125			v2.Aux = s
 26126			v2.AddArg(p)
 26127			v2.AddArg(idx)
 26128			v2.AddArg(mem)
 26129			v1.AddArg(v2)
 26130			v0.AddArg(v1)
 26131			v0.AddArg(y)
 26132			return true
 26133		}
 26134		// match: (OR or:(OR y s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem))) s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)))
 26135		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 26136		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
 26137		for {
 26138			_ = v.Args[1]
 26139			or := v.Args[0]
 26140			if or.Op != OpS390XOR {
 26141				break
 26142			}
 26143			_ = or.Args[1]
 26144			y := or.Args[0]
 26145			s1 := or.Args[1]
 26146			if s1.Op != OpS390XSLDconst {
 26147				break
 26148			}
 26149			j1 := s1.AuxInt
 26150			x1 := s1.Args[0]
 26151			if x1.Op != OpS390XMOVBZloadidx {
 26152				break
 26153			}
 26154			i1 := x1.AuxInt
 26155			s := x1.Aux
 26156			mem := x1.Args[2]
 26157			idx := x1.Args[0]
 26158			p := x1.Args[1]
 26159			s0 := v.Args[1]
 26160			if s0.Op != OpS390XSLDconst {
 26161				break
 26162			}
 26163			j0 := s0.AuxInt
 26164			x0 := s0.Args[0]
 26165			if x0.Op != OpS390XMOVBZloadidx {
 26166				break
 26167			}
 26168			i0 := x0.AuxInt
 26169			if x0.Aux != s {
 26170				break
 26171			}
 26172			_ = x0.Args[2]
 26173			if p != x0.Args[0] {
 26174				break
 26175			}
 26176			if idx != x0.Args[1] {
 26177				break
 26178			}
 26179			if mem != x0.Args[2] {
 26180				break
 26181			}
 26182			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 26183				break
 26184			}
 26185			b = mergePoint(b, x0, x1, y)
 26186			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 26187			v.reset(OpCopy)
 26188			v.AddArg(v0)
 26189			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 26190			v1.AuxInt = j1
 26191			v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 26192			v2.AuxInt = i0
 26193			v2.Aux = s
 26194			v2.AddArg(p)
 26195			v2.AddArg(idx)
 26196			v2.AddArg(mem)
 26197			v1.AddArg(v2)
 26198			v0.AddArg(v1)
 26199			v0.AddArg(y)
 26200			return true
 26201		}
 26202		// match: (OR or:(OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)) y) s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)))
 26203		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 26204		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
 26205		for {
 26206			_ = v.Args[1]
 26207			or := v.Args[0]
 26208			if or.Op != OpS390XOR {
 26209				break
 26210			}
 26211			y := or.Args[1]
 26212			s1 := or.Args[0]
 26213			if s1.Op != OpS390XSLDconst {
 26214				break
 26215			}
 26216			j1 := s1.AuxInt
 26217			x1 := s1.Args[0]
 26218			if x1.Op != OpS390XMOVBZloadidx {
 26219				break
 26220			}
 26221			i1 := x1.AuxInt
 26222			s := x1.Aux
 26223			mem := x1.Args[2]
 26224			p := x1.Args[0]
 26225			idx := x1.Args[1]
 26226			s0 := v.Args[1]
 26227			if s0.Op != OpS390XSLDconst {
 26228				break
 26229			}
 26230			j0 := s0.AuxInt
 26231			x0 := s0.Args[0]
 26232			if x0.Op != OpS390XMOVBZloadidx {
 26233				break
 26234			}
 26235			i0 := x0.AuxInt
 26236			if x0.Aux != s {
 26237				break
 26238			}
 26239			_ = x0.Args[2]
 26240			if idx != x0.Args[0] {
 26241				break
 26242			}
 26243			if p != x0.Args[1] {
 26244				break
 26245			}
 26246			if mem != x0.Args[2] {
 26247				break
 26248			}
 26249			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 26250				break
 26251			}
 26252			b = mergePoint(b, x0, x1, y)
 26253			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 26254			v.reset(OpCopy)
 26255			v.AddArg(v0)
 26256			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 26257			v1.AuxInt = j1
 26258			v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 26259			v2.AuxInt = i0
 26260			v2.Aux = s
 26261			v2.AddArg(p)
 26262			v2.AddArg(idx)
 26263			v2.AddArg(mem)
 26264			v1.AddArg(v2)
 26265			v0.AddArg(v1)
 26266			v0.AddArg(y)
 26267			return true
 26268		}
 26269		// match: (OR or:(OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) y) s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)))
 26270		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 26271		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
 26272		for {
 26273			_ = v.Args[1]
 26274			or := v.Args[0]
 26275			if or.Op != OpS390XOR {
 26276				break
 26277			}
 26278			y := or.Args[1]
 26279			s1 := or.Args[0]
 26280			if s1.Op != OpS390XSLDconst {
 26281				break
 26282			}
 26283			j1 := s1.AuxInt
 26284			x1 := s1.Args[0]
 26285			if x1.Op != OpS390XMOVBZloadidx {
 26286				break
 26287			}
 26288			i1 := x1.AuxInt
 26289			s := x1.Aux
 26290			mem := x1.Args[2]
 26291			idx := x1.Args[0]
 26292			p := x1.Args[1]
 26293			s0 := v.Args[1]
 26294			if s0.Op != OpS390XSLDconst {
 26295				break
 26296			}
 26297			j0 := s0.AuxInt
 26298			x0 := s0.Args[0]
 26299			if x0.Op != OpS390XMOVBZloadidx {
 26300				break
 26301			}
 26302			i0 := x0.AuxInt
 26303			if x0.Aux != s {
 26304				break
 26305			}
 26306			_ = x0.Args[2]
 26307			if idx != x0.Args[0] {
 26308				break
 26309			}
 26310			if p != x0.Args[1] {
 26311				break
 26312			}
 26313			if mem != x0.Args[2] {
 26314				break
 26315			}
 26316			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 26317				break
 26318			}
 26319			b = mergePoint(b, x0, x1, y)
 26320			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 26321			v.reset(OpCopy)
 26322			v.AddArg(v0)
 26323			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 26324			v1.AuxInt = j1
 26325			v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 26326			v2.AuxInt = i0
 26327			v2.Aux = s
 26328			v2.AddArg(p)
 26329			v2.AddArg(idx)
 26330			v2.AddArg(mem)
 26331			v1.AddArg(v2)
 26332			v0.AddArg(v1)
 26333			v0.AddArg(y)
 26334			return true
 26335		}
 26336		// match: (OR or:(OR y s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem))) s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)))
 26337		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 26338		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
 26339		for {
 26340			_ = v.Args[1]
 26341			or := v.Args[0]
 26342			if or.Op != OpS390XOR {
 26343				break
 26344			}
 26345			_ = or.Args[1]
 26346			y := or.Args[0]
 26347			s1 := or.Args[1]
 26348			if s1.Op != OpS390XSLDconst {
 26349				break
 26350			}
 26351			j1 := s1.AuxInt
 26352			x1 := s1.Args[0]
 26353			if x1.Op != OpS390XMOVBZloadidx {
 26354				break
 26355			}
 26356			i1 := x1.AuxInt
 26357			s := x1.Aux
 26358			mem := x1.Args[2]
 26359			p := x1.Args[0]
 26360			idx := x1.Args[1]
 26361			s0 := v.Args[1]
 26362			if s0.Op != OpS390XSLDconst {
 26363				break
 26364			}
 26365			j0 := s0.AuxInt
 26366			x0 := s0.Args[0]
 26367			if x0.Op != OpS390XMOVBZloadidx {
 26368				break
 26369			}
 26370			i0 := x0.AuxInt
 26371			if x0.Aux != s {
 26372				break
 26373			}
 26374			_ = x0.Args[2]
 26375			if idx != x0.Args[0] {
 26376				break
 26377			}
 26378			if p != x0.Args[1] {
 26379				break
 26380			}
 26381			if mem != x0.Args[2] {
 26382				break
 26383			}
 26384			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 26385				break
 26386			}
 26387			b = mergePoint(b, x0, x1, y)
 26388			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 26389			v.reset(OpCopy)
 26390			v.AddArg(v0)
 26391			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 26392			v1.AuxInt = j1
 26393			v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 26394			v2.AuxInt = i0
 26395			v2.Aux = s
 26396			v2.AddArg(p)
 26397			v2.AddArg(idx)
 26398			v2.AddArg(mem)
 26399			v1.AddArg(v2)
 26400			v0.AddArg(v1)
 26401			v0.AddArg(y)
 26402			return true
 26403		}
 26404		return false
 26405	}
 26406	func rewriteValueS390X_OpS390XOR_70(v *Value) bool {
 26407		b := v.Block
 26408		typ := &b.Func.Config.Types
 26409		// match: (OR or:(OR y s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem))) s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)))
 26410		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 26411		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
 26412		for {
 26413			_ = v.Args[1]
 26414			or := v.Args[0]
 26415			if or.Op != OpS390XOR {
 26416				break
 26417			}
 26418			_ = or.Args[1]
 26419			y := or.Args[0]
 26420			s1 := or.Args[1]
 26421			if s1.Op != OpS390XSLDconst {
 26422				break
 26423			}
 26424			j1 := s1.AuxInt
 26425			x1 := s1.Args[0]
 26426			if x1.Op != OpS390XMOVBZloadidx {
 26427				break
 26428			}
 26429			i1 := x1.AuxInt
 26430			s := x1.Aux
 26431			mem := x1.Args[2]
 26432			idx := x1.Args[0]
 26433			p := x1.Args[1]
 26434			s0 := v.Args[1]
 26435			if s0.Op != OpS390XSLDconst {
 26436				break
 26437			}
 26438			j0 := s0.AuxInt
 26439			x0 := s0.Args[0]
 26440			if x0.Op != OpS390XMOVBZloadidx {
 26441				break
 26442			}
 26443			i0 := x0.AuxInt
 26444			if x0.Aux != s {
 26445				break
 26446			}
 26447			_ = x0.Args[2]
 26448			if idx != x0.Args[0] {
 26449				break
 26450			}
 26451			if p != x0.Args[1] {
 26452				break
 26453			}
 26454			if mem != x0.Args[2] {
 26455				break
 26456			}
 26457			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 26458				break
 26459			}
 26460			b = mergePoint(b, x0, x1, y)
 26461			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 26462			v.reset(OpCopy)
 26463			v.AddArg(v0)
 26464			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 26465			v1.AuxInt = j1
 26466			v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 26467			v2.AuxInt = i0
 26468			v2.Aux = s
 26469			v2.AddArg(p)
 26470			v2.AddArg(idx)
 26471			v2.AddArg(mem)
 26472			v1.AddArg(v2)
 26473			v0.AddArg(v1)
 26474			v0.AddArg(y)
 26475			return true
 26476		}
 26477		// match: (OR s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} p idx mem)) or:(OR s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} p idx mem)) y))
 26478		// cond: i1 == i0+2 && j1 == j0-16 && j1 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 26479		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
 26480		for {
 26481			_ = v.Args[1]
 26482			s0 := v.Args[0]
 26483			if s0.Op != OpS390XSLDconst {
 26484				break
 26485			}
 26486			j0 := s0.AuxInt
 26487			x0 := s0.Args[0]
 26488			if x0.Op != OpS390XMOVHZloadidx {
 26489				break
 26490			}
 26491			i0 := x0.AuxInt
 26492			s := x0.Aux
 26493			mem := x0.Args[2]
 26494			p := x0.Args[0]
 26495			idx := x0.Args[1]
 26496			or := v.Args[1]
 26497			if or.Op != OpS390XOR {
 26498				break
 26499			}
 26500			y := or.Args[1]
 26501			s1 := or.Args[0]
 26502			if s1.Op != OpS390XSLDconst {
 26503				break
 26504			}
 26505			j1 := s1.AuxInt
 26506			x1 := s1.Args[0]
 26507			if x1.Op != OpS390XMOVHZloadidx {
 26508				break
 26509			}
 26510			i1 := x1.AuxInt
 26511			if x1.Aux != s {
 26512				break
 26513			}
 26514			_ = x1.Args[2]
 26515			if p != x1.Args[0] {
 26516				break
 26517			}
 26518			if idx != x1.Args[1] {
 26519				break
 26520			}
 26521			if mem != x1.Args[2] {
 26522				break
 26523			}
 26524			if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 26525				break
 26526			}
 26527			b = mergePoint(b, x0, x1, y)
 26528			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 26529			v.reset(OpCopy)
 26530			v.AddArg(v0)
 26531			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 26532			v1.AuxInt = j1
 26533			v2 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
 26534			v2.AuxInt = i0
 26535			v2.Aux = s
 26536			v2.AddArg(p)
 26537			v2.AddArg(idx)
 26538			v2.AddArg(mem)
 26539			v1.AddArg(v2)
 26540			v0.AddArg(v1)
 26541			v0.AddArg(y)
 26542			return true
 26543		}
 26544		// match: (OR s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} idx p mem)) or:(OR s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} p idx mem)) y))
 26545		// cond: i1 == i0+2 && j1 == j0-16 && j1 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 26546		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
 26547		for {
 26548			_ = v.Args[1]
 26549			s0 := v.Args[0]
 26550			if s0.Op != OpS390XSLDconst {
 26551				break
 26552			}
 26553			j0 := s0.AuxInt
 26554			x0 := s0.Args[0]
 26555			if x0.Op != OpS390XMOVHZloadidx {
 26556				break
 26557			}
 26558			i0 := x0.AuxInt
 26559			s := x0.Aux
 26560			mem := x0.Args[2]
 26561			idx := x0.Args[0]
 26562			p := x0.Args[1]
 26563			or := v.Args[1]
 26564			if or.Op != OpS390XOR {
 26565				break
 26566			}
 26567			y := or.Args[1]
 26568			s1 := or.Args[0]
 26569			if s1.Op != OpS390XSLDconst {
 26570				break
 26571			}
 26572			j1 := s1.AuxInt
 26573			x1 := s1.Args[0]
 26574			if x1.Op != OpS390XMOVHZloadidx {
 26575				break
 26576			}
 26577			i1 := x1.AuxInt
 26578			if x1.Aux != s {
 26579				break
 26580			}
 26581			_ = x1.Args[2]
 26582			if p != x1.Args[0] {
 26583				break
 26584			}
 26585			if idx != x1.Args[1] {
 26586				break
 26587			}
 26588			if mem != x1.Args[2] {
 26589				break
 26590			}
 26591			if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 26592				break
 26593			}
 26594			b = mergePoint(b, x0, x1, y)
 26595			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 26596			v.reset(OpCopy)
 26597			v.AddArg(v0)
 26598			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 26599			v1.AuxInt = j1
 26600			v2 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
 26601			v2.AuxInt = i0
 26602			v2.Aux = s
 26603			v2.AddArg(p)
 26604			v2.AddArg(idx)
 26605			v2.AddArg(mem)
 26606			v1.AddArg(v2)
 26607			v0.AddArg(v1)
 26608			v0.AddArg(y)
 26609			return true
 26610		}
 26611		// match: (OR s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} p idx mem)) or:(OR s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} idx p mem)) y))
 26612		// cond: i1 == i0+2 && j1 == j0-16 && j1 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 26613		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
 26614		for {
 26615			_ = v.Args[1]
 26616			s0 := v.Args[0]
 26617			if s0.Op != OpS390XSLDconst {
 26618				break
 26619			}
 26620			j0 := s0.AuxInt
 26621			x0 := s0.Args[0]
 26622			if x0.Op != OpS390XMOVHZloadidx {
 26623				break
 26624			}
 26625			i0 := x0.AuxInt
 26626			s := x0.Aux
 26627			mem := x0.Args[2]
 26628			p := x0.Args[0]
 26629			idx := x0.Args[1]
 26630			or := v.Args[1]
 26631			if or.Op != OpS390XOR {
 26632				break
 26633			}
 26634			y := or.Args[1]
 26635			s1 := or.Args[0]
 26636			if s1.Op != OpS390XSLDconst {
 26637				break
 26638			}
 26639			j1 := s1.AuxInt
 26640			x1 := s1.Args[0]
 26641			if x1.Op != OpS390XMOVHZloadidx {
 26642				break
 26643			}
 26644			i1 := x1.AuxInt
 26645			if x1.Aux != s {
 26646				break
 26647			}
 26648			_ = x1.Args[2]
 26649			if idx != x1.Args[0] {
 26650				break
 26651			}
 26652			if p != x1.Args[1] {
 26653				break
 26654			}
 26655			if mem != x1.Args[2] {
 26656				break
 26657			}
 26658			if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 26659				break
 26660			}
 26661			b = mergePoint(b, x0, x1, y)
 26662			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 26663			v.reset(OpCopy)
 26664			v.AddArg(v0)
 26665			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 26666			v1.AuxInt = j1
 26667			v2 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
 26668			v2.AuxInt = i0
 26669			v2.Aux = s
 26670			v2.AddArg(p)
 26671			v2.AddArg(idx)
 26672			v2.AddArg(mem)
 26673			v1.AddArg(v2)
 26674			v0.AddArg(v1)
 26675			v0.AddArg(y)
 26676			return true
 26677		}
 26678		// match: (OR s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} idx p mem)) or:(OR s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} idx p mem)) y))
 26679		// cond: i1 == i0+2 && j1 == j0-16 && j1 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 26680		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
 26681		for {
 26682			_ = v.Args[1]
 26683			s0 := v.Args[0]
 26684			if s0.Op != OpS390XSLDconst {
 26685				break
 26686			}
 26687			j0 := s0.AuxInt
 26688			x0 := s0.Args[0]
 26689			if x0.Op != OpS390XMOVHZloadidx {
 26690				break
 26691			}
 26692			i0 := x0.AuxInt
 26693			s := x0.Aux
 26694			mem := x0.Args[2]
 26695			idx := x0.Args[0]
 26696			p := x0.Args[1]
 26697			or := v.Args[1]
 26698			if or.Op != OpS390XOR {
 26699				break
 26700			}
 26701			y := or.Args[1]
 26702			s1 := or.Args[0]
 26703			if s1.Op != OpS390XSLDconst {
 26704				break
 26705			}
 26706			j1 := s1.AuxInt
 26707			x1 := s1.Args[0]
 26708			if x1.Op != OpS390XMOVHZloadidx {
 26709				break
 26710			}
 26711			i1 := x1.AuxInt
 26712			if x1.Aux != s {
 26713				break
 26714			}
 26715			_ = x1.Args[2]
 26716			if idx != x1.Args[0] {
 26717				break
 26718			}
 26719			if p != x1.Args[1] {
 26720				break
 26721			}
 26722			if mem != x1.Args[2] {
 26723				break
 26724			}
 26725			if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 26726				break
 26727			}
 26728			b = mergePoint(b, x0, x1, y)
 26729			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 26730			v.reset(OpCopy)
 26731			v.AddArg(v0)
 26732			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 26733			v1.AuxInt = j1
 26734			v2 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
 26735			v2.AuxInt = i0
 26736			v2.Aux = s
 26737			v2.AddArg(p)
 26738			v2.AddArg(idx)
 26739			v2.AddArg(mem)
 26740			v1.AddArg(v2)
 26741			v0.AddArg(v1)
 26742			v0.AddArg(y)
 26743			return true
 26744		}
 26745		// match: (OR s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} p idx mem)) or:(OR y s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} p idx mem))))
 26746		// cond: i1 == i0+2 && j1 == j0-16 && j1 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 26747		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
 26748		for {
 26749			_ = v.Args[1]
 26750			s0 := v.Args[0]
 26751			if s0.Op != OpS390XSLDconst {
 26752				break
 26753			}
 26754			j0 := s0.AuxInt
 26755			x0 := s0.Args[0]
 26756			if x0.Op != OpS390XMOVHZloadidx {
 26757				break
 26758			}
 26759			i0 := x0.AuxInt
 26760			s := x0.Aux
 26761			mem := x0.Args[2]
 26762			p := x0.Args[0]
 26763			idx := x0.Args[1]
 26764			or := v.Args[1]
 26765			if or.Op != OpS390XOR {
 26766				break
 26767			}
 26768			_ = or.Args[1]
 26769			y := or.Args[0]
 26770			s1 := or.Args[1]
 26771			if s1.Op != OpS390XSLDconst {
 26772				break
 26773			}
 26774			j1 := s1.AuxInt
 26775			x1 := s1.Args[0]
 26776			if x1.Op != OpS390XMOVHZloadidx {
 26777				break
 26778			}
 26779			i1 := x1.AuxInt
 26780			if x1.Aux != s {
 26781				break
 26782			}
 26783			_ = x1.Args[2]
 26784			if p != x1.Args[0] {
 26785				break
 26786			}
 26787			if idx != x1.Args[1] {
 26788				break
 26789			}
 26790			if mem != x1.Args[2] {
 26791				break
 26792			}
 26793			if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 26794				break
 26795			}
 26796			b = mergePoint(b, x0, x1, y)
 26797			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 26798			v.reset(OpCopy)
 26799			v.AddArg(v0)
 26800			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 26801			v1.AuxInt = j1
 26802			v2 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
 26803			v2.AuxInt = i0
 26804			v2.Aux = s
 26805			v2.AddArg(p)
 26806			v2.AddArg(idx)
 26807			v2.AddArg(mem)
 26808			v1.AddArg(v2)
 26809			v0.AddArg(v1)
 26810			v0.AddArg(y)
 26811			return true
 26812		}
 26813		// match: (OR s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} idx p mem)) or:(OR y s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} p idx mem))))
 26814		// cond: i1 == i0+2 && j1 == j0-16 && j1 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 26815		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
 26816		for {
 26817			_ = v.Args[1]
 26818			s0 := v.Args[0]
 26819			if s0.Op != OpS390XSLDconst {
 26820				break
 26821			}
 26822			j0 := s0.AuxInt
 26823			x0 := s0.Args[0]
 26824			if x0.Op != OpS390XMOVHZloadidx {
 26825				break
 26826			}
 26827			i0 := x0.AuxInt
 26828			s := x0.Aux
 26829			mem := x0.Args[2]
 26830			idx := x0.Args[0]
 26831			p := x0.Args[1]
 26832			or := v.Args[1]
 26833			if or.Op != OpS390XOR {
 26834				break
 26835			}
 26836			_ = or.Args[1]
 26837			y := or.Args[0]
 26838			s1 := or.Args[1]
 26839			if s1.Op != OpS390XSLDconst {
 26840				break
 26841			}
 26842			j1 := s1.AuxInt
 26843			x1 := s1.Args[0]
 26844			if x1.Op != OpS390XMOVHZloadidx {
 26845				break
 26846			}
 26847			i1 := x1.AuxInt
 26848			if x1.Aux != s {
 26849				break
 26850			}
 26851			_ = x1.Args[2]
 26852			if p != x1.Args[0] {
 26853				break
 26854			}
 26855			if idx != x1.Args[1] {
 26856				break
 26857			}
 26858			if mem != x1.Args[2] {
 26859				break
 26860			}
 26861			if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 26862				break
 26863			}
 26864			b = mergePoint(b, x0, x1, y)
 26865			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 26866			v.reset(OpCopy)
 26867			v.AddArg(v0)
 26868			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 26869			v1.AuxInt = j1
 26870			v2 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
 26871			v2.AuxInt = i0
 26872			v2.Aux = s
 26873			v2.AddArg(p)
 26874			v2.AddArg(idx)
 26875			v2.AddArg(mem)
 26876			v1.AddArg(v2)
 26877			v0.AddArg(v1)
 26878			v0.AddArg(y)
 26879			return true
 26880		}
 26881		// match: (OR s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} p idx mem)) or:(OR y s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} idx p mem))))
 26882		// cond: i1 == i0+2 && j1 == j0-16 && j1 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 26883		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
 26884		for {
 26885			_ = v.Args[1]
 26886			s0 := v.Args[0]
 26887			if s0.Op != OpS390XSLDconst {
 26888				break
 26889			}
 26890			j0 := s0.AuxInt
 26891			x0 := s0.Args[0]
 26892			if x0.Op != OpS390XMOVHZloadidx {
 26893				break
 26894			}
 26895			i0 := x0.AuxInt
 26896			s := x0.Aux
 26897			mem := x0.Args[2]
 26898			p := x0.Args[0]
 26899			idx := x0.Args[1]
 26900			or := v.Args[1]
 26901			if or.Op != OpS390XOR {
 26902				break
 26903			}
 26904			_ = or.Args[1]
 26905			y := or.Args[0]
 26906			s1 := or.Args[1]
 26907			if s1.Op != OpS390XSLDconst {
 26908				break
 26909			}
 26910			j1 := s1.AuxInt
 26911			x1 := s1.Args[0]
 26912			if x1.Op != OpS390XMOVHZloadidx {
 26913				break
 26914			}
 26915			i1 := x1.AuxInt
 26916			if x1.Aux != s {
 26917				break
 26918			}
 26919			_ = x1.Args[2]
 26920			if idx != x1.Args[0] {
 26921				break
 26922			}
 26923			if p != x1.Args[1] {
 26924				break
 26925			}
 26926			if mem != x1.Args[2] {
 26927				break
 26928			}
 26929			if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 26930				break
 26931			}
 26932			b = mergePoint(b, x0, x1, y)
 26933			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 26934			v.reset(OpCopy)
 26935			v.AddArg(v0)
 26936			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 26937			v1.AuxInt = j1
 26938			v2 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
 26939			v2.AuxInt = i0
 26940			v2.Aux = s
 26941			v2.AddArg(p)
 26942			v2.AddArg(idx)
 26943			v2.AddArg(mem)
 26944			v1.AddArg(v2)
 26945			v0.AddArg(v1)
 26946			v0.AddArg(y)
 26947			return true
 26948		}
 26949		// match: (OR s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} idx p mem)) or:(OR y s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} idx p mem))))
 26950		// cond: i1 == i0+2 && j1 == j0-16 && j1 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 26951		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
 26952		for {
 26953			_ = v.Args[1]
 26954			s0 := v.Args[0]
 26955			if s0.Op != OpS390XSLDconst {
 26956				break
 26957			}
 26958			j0 := s0.AuxInt
 26959			x0 := s0.Args[0]
 26960			if x0.Op != OpS390XMOVHZloadidx {
 26961				break
 26962			}
 26963			i0 := x0.AuxInt
 26964			s := x0.Aux
 26965			mem := x0.Args[2]
 26966			idx := x0.Args[0]
 26967			p := x0.Args[1]
 26968			or := v.Args[1]
 26969			if or.Op != OpS390XOR {
 26970				break
 26971			}
 26972			_ = or.Args[1]
 26973			y := or.Args[0]
 26974			s1 := or.Args[1]
 26975			if s1.Op != OpS390XSLDconst {
 26976				break
 26977			}
 26978			j1 := s1.AuxInt
 26979			x1 := s1.Args[0]
 26980			if x1.Op != OpS390XMOVHZloadidx {
 26981				break
 26982			}
 26983			i1 := x1.AuxInt
 26984			if x1.Aux != s {
 26985				break
 26986			}
 26987			_ = x1.Args[2]
 26988			if idx != x1.Args[0] {
 26989				break
 26990			}
 26991			if p != x1.Args[1] {
 26992				break
 26993			}
 26994			if mem != x1.Args[2] {
 26995				break
 26996			}
 26997			if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 26998				break
 26999			}
 27000			b = mergePoint(b, x0, x1, y)
 27001			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 27002			v.reset(OpCopy)
 27003			v.AddArg(v0)
 27004			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 27005			v1.AuxInt = j1
 27006			v2 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
 27007			v2.AuxInt = i0
 27008			v2.Aux = s
 27009			v2.AddArg(p)
 27010			v2.AddArg(idx)
 27011			v2.AddArg(mem)
 27012			v1.AddArg(v2)
 27013			v0.AddArg(v1)
 27014			v0.AddArg(y)
 27015			return true
 27016		}
 27017		// match: (OR or:(OR s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} p idx mem)) y) s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} p idx mem)))
 27018		// cond: i1 == i0+2 && j1 == j0-16 && j1 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 27019		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
 27020		for {
 27021			_ = v.Args[1]
 27022			or := v.Args[0]
 27023			if or.Op != OpS390XOR {
 27024				break
 27025			}
 27026			y := or.Args[1]
 27027			s1 := or.Args[0]
 27028			if s1.Op != OpS390XSLDconst {
 27029				break
 27030			}
 27031			j1 := s1.AuxInt
 27032			x1 := s1.Args[0]
 27033			if x1.Op != OpS390XMOVHZloadidx {
 27034				break
 27035			}
 27036			i1 := x1.AuxInt
 27037			s := x1.Aux
 27038			mem := x1.Args[2]
 27039			p := x1.Args[0]
 27040			idx := x1.Args[1]
 27041			s0 := v.Args[1]
 27042			if s0.Op != OpS390XSLDconst {
 27043				break
 27044			}
 27045			j0 := s0.AuxInt
 27046			x0 := s0.Args[0]
 27047			if x0.Op != OpS390XMOVHZloadidx {
 27048				break
 27049			}
 27050			i0 := x0.AuxInt
 27051			if x0.Aux != s {
 27052				break
 27053			}
 27054			_ = x0.Args[2]
 27055			if p != x0.Args[0] {
 27056				break
 27057			}
 27058			if idx != x0.Args[1] {
 27059				break
 27060			}
 27061			if mem != x0.Args[2] {
 27062				break
 27063			}
 27064			if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 27065				break
 27066			}
 27067			b = mergePoint(b, x0, x1, y)
 27068			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 27069			v.reset(OpCopy)
 27070			v.AddArg(v0)
 27071			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 27072			v1.AuxInt = j1
 27073			v2 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
 27074			v2.AuxInt = i0
 27075			v2.Aux = s
 27076			v2.AddArg(p)
 27077			v2.AddArg(idx)
 27078			v2.AddArg(mem)
 27079			v1.AddArg(v2)
 27080			v0.AddArg(v1)
 27081			v0.AddArg(y)
 27082			return true
 27083		}
 27084		return false
 27085	}
 27086	func rewriteValueS390X_OpS390XOR_80(v *Value) bool {
 27087		b := v.Block
 27088		typ := &b.Func.Config.Types
 27089		// match: (OR or:(OR s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} idx p mem)) y) s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} p idx mem)))
 27090		// cond: i1 == i0+2 && j1 == j0-16 && j1 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 27091		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
 27092		for {
 27093			_ = v.Args[1]
 27094			or := v.Args[0]
 27095			if or.Op != OpS390XOR {
 27096				break
 27097			}
 27098			y := or.Args[1]
 27099			s1 := or.Args[0]
 27100			if s1.Op != OpS390XSLDconst {
 27101				break
 27102			}
 27103			j1 := s1.AuxInt
 27104			x1 := s1.Args[0]
 27105			if x1.Op != OpS390XMOVHZloadidx {
 27106				break
 27107			}
 27108			i1 := x1.AuxInt
 27109			s := x1.Aux
 27110			mem := x1.Args[2]
 27111			idx := x1.Args[0]
 27112			p := x1.Args[1]
 27113			s0 := v.Args[1]
 27114			if s0.Op != OpS390XSLDconst {
 27115				break
 27116			}
 27117			j0 := s0.AuxInt
 27118			x0 := s0.Args[0]
 27119			if x0.Op != OpS390XMOVHZloadidx {
 27120				break
 27121			}
 27122			i0 := x0.AuxInt
 27123			if x0.Aux != s {
 27124				break
 27125			}
 27126			_ = x0.Args[2]
 27127			if p != x0.Args[0] {
 27128				break
 27129			}
 27130			if idx != x0.Args[1] {
 27131				break
 27132			}
 27133			if mem != x0.Args[2] {
 27134				break
 27135			}
 27136			if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 27137				break
 27138			}
 27139			b = mergePoint(b, x0, x1, y)
 27140			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 27141			v.reset(OpCopy)
 27142			v.AddArg(v0)
 27143			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 27144			v1.AuxInt = j1
 27145			v2 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
 27146			v2.AuxInt = i0
 27147			v2.Aux = s
 27148			v2.AddArg(p)
 27149			v2.AddArg(idx)
 27150			v2.AddArg(mem)
 27151			v1.AddArg(v2)
 27152			v0.AddArg(v1)
 27153			v0.AddArg(y)
 27154			return true
 27155		}
 27156		// match: (OR or:(OR y s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} p idx mem))) s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} p idx mem)))
 27157		// cond: i1 == i0+2 && j1 == j0-16 && j1 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 27158		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
 27159		for {
 27160			_ = v.Args[1]
 27161			or := v.Args[0]
 27162			if or.Op != OpS390XOR {
 27163				break
 27164			}
 27165			_ = or.Args[1]
 27166			y := or.Args[0]
 27167			s1 := or.Args[1]
 27168			if s1.Op != OpS390XSLDconst {
 27169				break
 27170			}
 27171			j1 := s1.AuxInt
 27172			x1 := s1.Args[0]
 27173			if x1.Op != OpS390XMOVHZloadidx {
 27174				break
 27175			}
 27176			i1 := x1.AuxInt
 27177			s := x1.Aux
 27178			mem := x1.Args[2]
 27179			p := x1.Args[0]
 27180			idx := x1.Args[1]
 27181			s0 := v.Args[1]
 27182			if s0.Op != OpS390XSLDconst {
 27183				break
 27184			}
 27185			j0 := s0.AuxInt
 27186			x0 := s0.Args[0]
 27187			if x0.Op != OpS390XMOVHZloadidx {
 27188				break
 27189			}
 27190			i0 := x0.AuxInt
 27191			if x0.Aux != s {
 27192				break
 27193			}
 27194			_ = x0.Args[2]
 27195			if p != x0.Args[0] {
 27196				break
 27197			}
 27198			if idx != x0.Args[1] {
 27199				break
 27200			}
 27201			if mem != x0.Args[2] {
 27202				break
 27203			}
 27204			if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 27205				break
 27206			}
 27207			b = mergePoint(b, x0, x1, y)
 27208			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 27209			v.reset(OpCopy)
 27210			v.AddArg(v0)
 27211			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 27212			v1.AuxInt = j1
 27213			v2 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
 27214			v2.AuxInt = i0
 27215			v2.Aux = s
 27216			v2.AddArg(p)
 27217			v2.AddArg(idx)
 27218			v2.AddArg(mem)
 27219			v1.AddArg(v2)
 27220			v0.AddArg(v1)
 27221			v0.AddArg(y)
 27222			return true
 27223		}
 27224		// match: (OR or:(OR y s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} idx p mem))) s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} p idx mem)))
 27225		// cond: i1 == i0+2 && j1 == j0-16 && j1 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 27226		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
 27227		for {
 27228			_ = v.Args[1]
 27229			or := v.Args[0]
 27230			if or.Op != OpS390XOR {
 27231				break
 27232			}
 27233			_ = or.Args[1]
 27234			y := or.Args[0]
 27235			s1 := or.Args[1]
 27236			if s1.Op != OpS390XSLDconst {
 27237				break
 27238			}
 27239			j1 := s1.AuxInt
 27240			x1 := s1.Args[0]
 27241			if x1.Op != OpS390XMOVHZloadidx {
 27242				break
 27243			}
 27244			i1 := x1.AuxInt
 27245			s := x1.Aux
 27246			mem := x1.Args[2]
 27247			idx := x1.Args[0]
 27248			p := x1.Args[1]
 27249			s0 := v.Args[1]
 27250			if s0.Op != OpS390XSLDconst {
 27251				break
 27252			}
 27253			j0 := s0.AuxInt
 27254			x0 := s0.Args[0]
 27255			if x0.Op != OpS390XMOVHZloadidx {
 27256				break
 27257			}
 27258			i0 := x0.AuxInt
 27259			if x0.Aux != s {
 27260				break
 27261			}
 27262			_ = x0.Args[2]
 27263			if p != x0.Args[0] {
 27264				break
 27265			}
 27266			if idx != x0.Args[1] {
 27267				break
 27268			}
 27269			if mem != x0.Args[2] {
 27270				break
 27271			}
 27272			if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 27273				break
 27274			}
 27275			b = mergePoint(b, x0, x1, y)
 27276			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 27277			v.reset(OpCopy)
 27278			v.AddArg(v0)
 27279			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 27280			v1.AuxInt = j1
 27281			v2 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
 27282			v2.AuxInt = i0
 27283			v2.Aux = s
 27284			v2.AddArg(p)
 27285			v2.AddArg(idx)
 27286			v2.AddArg(mem)
 27287			v1.AddArg(v2)
 27288			v0.AddArg(v1)
 27289			v0.AddArg(y)
 27290			return true
 27291		}
 27292		// match: (OR or:(OR s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} p idx mem)) y) s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} idx p mem)))
 27293		// cond: i1 == i0+2 && j1 == j0-16 && j1 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 27294		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
 27295		for {
 27296			_ = v.Args[1]
 27297			or := v.Args[0]
 27298			if or.Op != OpS390XOR {
 27299				break
 27300			}
 27301			y := or.Args[1]
 27302			s1 := or.Args[0]
 27303			if s1.Op != OpS390XSLDconst {
 27304				break
 27305			}
 27306			j1 := s1.AuxInt
 27307			x1 := s1.Args[0]
 27308			if x1.Op != OpS390XMOVHZloadidx {
 27309				break
 27310			}
 27311			i1 := x1.AuxInt
 27312			s := x1.Aux
 27313			mem := x1.Args[2]
 27314			p := x1.Args[0]
 27315			idx := x1.Args[1]
 27316			s0 := v.Args[1]
 27317			if s0.Op != OpS390XSLDconst {
 27318				break
 27319			}
 27320			j0 := s0.AuxInt
 27321			x0 := s0.Args[0]
 27322			if x0.Op != OpS390XMOVHZloadidx {
 27323				break
 27324			}
 27325			i0 := x0.AuxInt
 27326			if x0.Aux != s {
 27327				break
 27328			}
 27329			_ = x0.Args[2]
 27330			if idx != x0.Args[0] {
 27331				break
 27332			}
 27333			if p != x0.Args[1] {
 27334				break
 27335			}
 27336			if mem != x0.Args[2] {
 27337				break
 27338			}
 27339			if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 27340				break
 27341			}
 27342			b = mergePoint(b, x0, x1, y)
 27343			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 27344			v.reset(OpCopy)
 27345			v.AddArg(v0)
 27346			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 27347			v1.AuxInt = j1
 27348			v2 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
 27349			v2.AuxInt = i0
 27350			v2.Aux = s
 27351			v2.AddArg(p)
 27352			v2.AddArg(idx)
 27353			v2.AddArg(mem)
 27354			v1.AddArg(v2)
 27355			v0.AddArg(v1)
 27356			v0.AddArg(y)
 27357			return true
 27358		}
 27359		// match: (OR or:(OR s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} idx p mem)) y) s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} idx p mem)))
 27360		// cond: i1 == i0+2 && j1 == j0-16 && j1 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 27361		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
 27362		for {
 27363			_ = v.Args[1]
 27364			or := v.Args[0]
 27365			if or.Op != OpS390XOR {
 27366				break
 27367			}
 27368			y := or.Args[1]
 27369			s1 := or.Args[0]
 27370			if s1.Op != OpS390XSLDconst {
 27371				break
 27372			}
 27373			j1 := s1.AuxInt
 27374			x1 := s1.Args[0]
 27375			if x1.Op != OpS390XMOVHZloadidx {
 27376				break
 27377			}
 27378			i1 := x1.AuxInt
 27379			s := x1.Aux
 27380			mem := x1.Args[2]
 27381			idx := x1.Args[0]
 27382			p := x1.Args[1]
 27383			s0 := v.Args[1]
 27384			if s0.Op != OpS390XSLDconst {
 27385				break
 27386			}
 27387			j0 := s0.AuxInt
 27388			x0 := s0.Args[0]
 27389			if x0.Op != OpS390XMOVHZloadidx {
 27390				break
 27391			}
 27392			i0 := x0.AuxInt
 27393			if x0.Aux != s {
 27394				break
 27395			}
 27396			_ = x0.Args[2]
 27397			if idx != x0.Args[0] {
 27398				break
 27399			}
 27400			if p != x0.Args[1] {
 27401				break
 27402			}
 27403			if mem != x0.Args[2] {
 27404				break
 27405			}
 27406			if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 27407				break
 27408			}
 27409			b = mergePoint(b, x0, x1, y)
 27410			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 27411			v.reset(OpCopy)
 27412			v.AddArg(v0)
 27413			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 27414			v1.AuxInt = j1
 27415			v2 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
 27416			v2.AuxInt = i0
 27417			v2.Aux = s
 27418			v2.AddArg(p)
 27419			v2.AddArg(idx)
 27420			v2.AddArg(mem)
 27421			v1.AddArg(v2)
 27422			v0.AddArg(v1)
 27423			v0.AddArg(y)
 27424			return true
 27425		}
 27426		// match: (OR or:(OR y s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} p idx mem))) s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} idx p mem)))
 27427		// cond: i1 == i0+2 && j1 == j0-16 && j1 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 27428		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
 27429		for {
 27430			_ = v.Args[1]
 27431			or := v.Args[0]
 27432			if or.Op != OpS390XOR {
 27433				break
 27434			}
 27435			_ = or.Args[1]
 27436			y := or.Args[0]
 27437			s1 := or.Args[1]
 27438			if s1.Op != OpS390XSLDconst {
 27439				break
 27440			}
 27441			j1 := s1.AuxInt
 27442			x1 := s1.Args[0]
 27443			if x1.Op != OpS390XMOVHZloadidx {
 27444				break
 27445			}
 27446			i1 := x1.AuxInt
 27447			s := x1.Aux
 27448			mem := x1.Args[2]
 27449			p := x1.Args[0]
 27450			idx := x1.Args[1]
 27451			s0 := v.Args[1]
 27452			if s0.Op != OpS390XSLDconst {
 27453				break
 27454			}
 27455			j0 := s0.AuxInt
 27456			x0 := s0.Args[0]
 27457			if x0.Op != OpS390XMOVHZloadidx {
 27458				break
 27459			}
 27460			i0 := x0.AuxInt
 27461			if x0.Aux != s {
 27462				break
 27463			}
 27464			_ = x0.Args[2]
 27465			if idx != x0.Args[0] {
 27466				break
 27467			}
 27468			if p != x0.Args[1] {
 27469				break
 27470			}
 27471			if mem != x0.Args[2] {
 27472				break
 27473			}
 27474			if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 27475				break
 27476			}
 27477			b = mergePoint(b, x0, x1, y)
 27478			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 27479			v.reset(OpCopy)
 27480			v.AddArg(v0)
 27481			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 27482			v1.AuxInt = j1
 27483			v2 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
 27484			v2.AuxInt = i0
 27485			v2.Aux = s
 27486			v2.AddArg(p)
 27487			v2.AddArg(idx)
 27488			v2.AddArg(mem)
 27489			v1.AddArg(v2)
 27490			v0.AddArg(v1)
 27491			v0.AddArg(y)
 27492			return true
 27493		}
 27494		// match: (OR or:(OR y s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} idx p mem))) s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} idx p mem)))
 27495		// cond: i1 == i0+2 && j1 == j0-16 && j1 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 27496		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
 27497		for {
 27498			_ = v.Args[1]
 27499			or := v.Args[0]
 27500			if or.Op != OpS390XOR {
 27501				break
 27502			}
 27503			_ = or.Args[1]
 27504			y := or.Args[0]
 27505			s1 := or.Args[1]
 27506			if s1.Op != OpS390XSLDconst {
 27507				break
 27508			}
 27509			j1 := s1.AuxInt
 27510			x1 := s1.Args[0]
 27511			if x1.Op != OpS390XMOVHZloadidx {
 27512				break
 27513			}
 27514			i1 := x1.AuxInt
 27515			s := x1.Aux
 27516			mem := x1.Args[2]
 27517			idx := x1.Args[0]
 27518			p := x1.Args[1]
 27519			s0 := v.Args[1]
 27520			if s0.Op != OpS390XSLDconst {
 27521				break
 27522			}
 27523			j0 := s0.AuxInt
 27524			x0 := s0.Args[0]
 27525			if x0.Op != OpS390XMOVHZloadidx {
 27526				break
 27527			}
 27528			i0 := x0.AuxInt
 27529			if x0.Aux != s {
 27530				break
 27531			}
 27532			_ = x0.Args[2]
 27533			if idx != x0.Args[0] {
 27534				break
 27535			}
 27536			if p != x0.Args[1] {
 27537				break
 27538			}
 27539			if mem != x0.Args[2] {
 27540				break
 27541			}
 27542			if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 27543				break
 27544			}
 27545			b = mergePoint(b, x0, x1, y)
 27546			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 27547			v.reset(OpCopy)
 27548			v.AddArg(v0)
 27549			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 27550			v1.AuxInt = j1
 27551			v2 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
 27552			v2.AuxInt = i0
 27553			v2.Aux = s
 27554			v2.AddArg(p)
 27555			v2.AddArg(idx)
 27556			v2.AddArg(mem)
 27557			v1.AddArg(v2)
 27558			v0.AddArg(v1)
 27559			v0.AddArg(y)
 27560			return true
 27561		}
 27562		// match: (OR x0:(MOVBZload [i0] {s} p mem) sh:(SLDconst [8] x1:(MOVBZload [i1] {s} p mem)))
 27563		// cond: p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 27564		// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRload [i0] {s} p mem))
 27565		for {
 27566			_ = v.Args[1]
 27567			x0 := v.Args[0]
 27568			if x0.Op != OpS390XMOVBZload {
 27569				break
 27570			}
 27571			i0 := x0.AuxInt
 27572			s := x0.Aux
 27573			mem := x0.Args[1]
 27574			p := x0.Args[0]
 27575			sh := v.Args[1]
 27576			if sh.Op != OpS390XSLDconst {
 27577				break
 27578			}
 27579			if sh.AuxInt != 8 {
 27580				break
 27581			}
 27582			x1 := sh.Args[0]
 27583			if x1.Op != OpS390XMOVBZload {
 27584				break
 27585			}
 27586			i1 := x1.AuxInt
 27587			if x1.Aux != s {
 27588				break
 27589			}
 27590			_ = x1.Args[1]
 27591			if p != x1.Args[0] {
 27592				break
 27593			}
 27594			if mem != x1.Args[1] {
 27595				break
 27596			}
 27597			if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 27598				break
 27599			}
 27600			b = mergePoint(b, x0, x1)
 27601			v0 := b.NewValue0(x1.Pos, OpS390XMOVHZreg, typ.UInt64)
 27602			v.reset(OpCopy)
 27603			v.AddArg(v0)
 27604			v1 := b.NewValue0(x1.Pos, OpS390XMOVHBRload, typ.UInt16)
 27605			v1.AuxInt = i0
 27606			v1.Aux = s
 27607			v1.AddArg(p)
 27608			v1.AddArg(mem)
 27609			v0.AddArg(v1)
 27610			return true
 27611		}
 27612		// match: (OR sh:(SLDconst [8] x1:(MOVBZload [i1] {s} p mem)) x0:(MOVBZload [i0] {s} p mem))
 27613		// cond: p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 27614		// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRload [i0] {s} p mem))
 27615		for {
 27616			_ = v.Args[1]
 27617			sh := v.Args[0]
 27618			if sh.Op != OpS390XSLDconst {
 27619				break
 27620			}
 27621			if sh.AuxInt != 8 {
 27622				break
 27623			}
 27624			x1 := sh.Args[0]
 27625			if x1.Op != OpS390XMOVBZload {
 27626				break
 27627			}
 27628			i1 := x1.AuxInt
 27629			s := x1.Aux
 27630			mem := x1.Args[1]
 27631			p := x1.Args[0]
 27632			x0 := v.Args[1]
 27633			if x0.Op != OpS390XMOVBZload {
 27634				break
 27635			}
 27636			i0 := x0.AuxInt
 27637			if x0.Aux != s {
 27638				break
 27639			}
 27640			_ = x0.Args[1]
 27641			if p != x0.Args[0] {
 27642				break
 27643			}
 27644			if mem != x0.Args[1] {
 27645				break
 27646			}
 27647			if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 27648				break
 27649			}
 27650			b = mergePoint(b, x0, x1)
 27651			v0 := b.NewValue0(x0.Pos, OpS390XMOVHZreg, typ.UInt64)
 27652			v.reset(OpCopy)
 27653			v.AddArg(v0)
 27654			v1 := b.NewValue0(x0.Pos, OpS390XMOVHBRload, typ.UInt16)
 27655			v1.AuxInt = i0
 27656			v1.Aux = s
 27657			v1.AddArg(p)
 27658			v1.AddArg(mem)
 27659			v0.AddArg(v1)
 27660			return true
 27661		}
 27662		// match: (OR r0:(MOVHZreg x0:(MOVHBRload [i0] {s} p mem)) sh:(SLDconst [16] r1:(MOVHZreg x1:(MOVHBRload [i1] {s} p mem))))
 27663		// cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
 27664		// result: @mergePoint(b,x0,x1) (MOVWZreg (MOVWBRload [i0] {s} p mem))
 27665		for {
 27666			_ = v.Args[1]
 27667			r0 := v.Args[0]
 27668			if r0.Op != OpS390XMOVHZreg {
 27669				break
 27670			}
 27671			x0 := r0.Args[0]
 27672			if x0.Op != OpS390XMOVHBRload {
 27673				break
 27674			}
 27675			i0 := x0.AuxInt
 27676			s := x0.Aux
 27677			mem := x0.Args[1]
 27678			p := x0.Args[0]
 27679			sh := v.Args[1]
 27680			if sh.Op != OpS390XSLDconst {
 27681				break
 27682			}
 27683			if sh.AuxInt != 16 {
 27684				break
 27685			}
 27686			r1 := sh.Args[0]
 27687			if r1.Op != OpS390XMOVHZreg {
 27688				break
 27689			}
 27690			x1 := r1.Args[0]
 27691			if x1.Op != OpS390XMOVHBRload {
 27692				break
 27693			}
 27694			i1 := x1.AuxInt
 27695			if x1.Aux != s {
 27696				break
 27697			}
 27698			_ = x1.Args[1]
 27699			if p != x1.Args[0] {
 27700				break
 27701			}
 27702			if mem != x1.Args[1] {
 27703				break
 27704			}
 27705			if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
 27706				break
 27707			}
 27708			b = mergePoint(b, x0, x1)
 27709			v0 := b.NewValue0(x1.Pos, OpS390XMOVWZreg, typ.UInt64)
 27710			v.reset(OpCopy)
 27711			v.AddArg(v0)
 27712			v1 := b.NewValue0(x1.Pos, OpS390XMOVWBRload, typ.UInt32)
 27713			v1.AuxInt = i0
 27714			v1.Aux = s
 27715			v1.AddArg(p)
 27716			v1.AddArg(mem)
 27717			v0.AddArg(v1)
 27718			return true
 27719		}
 27720		return false
 27721	}
 27722	func rewriteValueS390X_OpS390XOR_90(v *Value) bool {
 27723		b := v.Block
 27724		typ := &b.Func.Config.Types
 27725		// match: (OR sh:(SLDconst [16] r1:(MOVHZreg x1:(MOVHBRload [i1] {s} p mem))) r0:(MOVHZreg x0:(MOVHBRload [i0] {s} p mem)))
 27726		// cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
 27727		// result: @mergePoint(b,x0,x1) (MOVWZreg (MOVWBRload [i0] {s} p mem))
 27728		for {
 27729			_ = v.Args[1]
 27730			sh := v.Args[0]
 27731			if sh.Op != OpS390XSLDconst {
 27732				break
 27733			}
 27734			if sh.AuxInt != 16 {
 27735				break
 27736			}
 27737			r1 := sh.Args[0]
 27738			if r1.Op != OpS390XMOVHZreg {
 27739				break
 27740			}
 27741			x1 := r1.Args[0]
 27742			if x1.Op != OpS390XMOVHBRload {
 27743				break
 27744			}
 27745			i1 := x1.AuxInt
 27746			s := x1.Aux
 27747			mem := x1.Args[1]
 27748			p := x1.Args[0]
 27749			r0 := v.Args[1]
 27750			if r0.Op != OpS390XMOVHZreg {
 27751				break
 27752			}
 27753			x0 := r0.Args[0]
 27754			if x0.Op != OpS390XMOVHBRload {
 27755				break
 27756			}
 27757			i0 := x0.AuxInt
 27758			if x0.Aux != s {
 27759				break
 27760			}
 27761			_ = x0.Args[1]
 27762			if p != x0.Args[0] {
 27763				break
 27764			}
 27765			if mem != x0.Args[1] {
 27766				break
 27767			}
 27768			if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
 27769				break
 27770			}
 27771			b = mergePoint(b, x0, x1)
 27772			v0 := b.NewValue0(x0.Pos, OpS390XMOVWZreg, typ.UInt64)
 27773			v.reset(OpCopy)
 27774			v.AddArg(v0)
 27775			v1 := b.NewValue0(x0.Pos, OpS390XMOVWBRload, typ.UInt32)
 27776			v1.AuxInt = i0
 27777			v1.Aux = s
 27778			v1.AddArg(p)
 27779			v1.AddArg(mem)
 27780			v0.AddArg(v1)
 27781			return true
 27782		}
 27783		// match: (OR r0:(MOVWZreg x0:(MOVWBRload [i0] {s} p mem)) sh:(SLDconst [32] r1:(MOVWZreg x1:(MOVWBRload [i1] {s} p mem))))
 27784		// cond: i1 == i0+4 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
 27785		// result: @mergePoint(b,x0,x1) (MOVDBRload [i0] {s} p mem)
 27786		for {
 27787			_ = v.Args[1]
 27788			r0 := v.Args[0]
 27789			if r0.Op != OpS390XMOVWZreg {
 27790				break
 27791			}
 27792			x0 := r0.Args[0]
 27793			if x0.Op != OpS390XMOVWBRload {
 27794				break
 27795			}
 27796			i0 := x0.AuxInt
 27797			s := x0.Aux
 27798			mem := x0.Args[1]
 27799			p := x0.Args[0]
 27800			sh := v.Args[1]
 27801			if sh.Op != OpS390XSLDconst {
 27802				break
 27803			}
 27804			if sh.AuxInt != 32 {
 27805				break
 27806			}
 27807			r1 := sh.Args[0]
 27808			if r1.Op != OpS390XMOVWZreg {
 27809				break
 27810			}
 27811			x1 := r1.Args[0]
 27812			if x1.Op != OpS390XMOVWBRload {
 27813				break
 27814			}
 27815			i1 := x1.AuxInt
 27816			if x1.Aux != s {
 27817				break
 27818			}
 27819			_ = x1.Args[1]
 27820			if p != x1.Args[0] {
 27821				break
 27822			}
 27823			if mem != x1.Args[1] {
 27824				break
 27825			}
 27826			if !(i1 == i0+4 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
 27827				break
 27828			}
 27829			b = mergePoint(b, x0, x1)
 27830			v0 := b.NewValue0(x1.Pos, OpS390XMOVDBRload, typ.UInt64)
 27831			v.reset(OpCopy)
 27832			v.AddArg(v0)
 27833			v0.AuxInt = i0
 27834			v0.Aux = s
 27835			v0.AddArg(p)
 27836			v0.AddArg(mem)
 27837			return true
 27838		}
 27839		// match: (OR sh:(SLDconst [32] r1:(MOVWZreg x1:(MOVWBRload [i1] {s} p mem))) r0:(MOVWZreg x0:(MOVWBRload [i0] {s} p mem)))
 27840		// cond: i1 == i0+4 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
 27841		// result: @mergePoint(b,x0,x1) (MOVDBRload [i0] {s} p mem)
 27842		for {
 27843			_ = v.Args[1]
 27844			sh := v.Args[0]
 27845			if sh.Op != OpS390XSLDconst {
 27846				break
 27847			}
 27848			if sh.AuxInt != 32 {
 27849				break
 27850			}
 27851			r1 := sh.Args[0]
 27852			if r1.Op != OpS390XMOVWZreg {
 27853				break
 27854			}
 27855			x1 := r1.Args[0]
 27856			if x1.Op != OpS390XMOVWBRload {
 27857				break
 27858			}
 27859			i1 := x1.AuxInt
 27860			s := x1.Aux
 27861			mem := x1.Args[1]
 27862			p := x1.Args[0]
 27863			r0 := v.Args[1]
 27864			if r0.Op != OpS390XMOVWZreg {
 27865				break
 27866			}
 27867			x0 := r0.Args[0]
 27868			if x0.Op != OpS390XMOVWBRload {
 27869				break
 27870			}
 27871			i0 := x0.AuxInt
 27872			if x0.Aux != s {
 27873				break
 27874			}
 27875			_ = x0.Args[1]
 27876			if p != x0.Args[0] {
 27877				break
 27878			}
 27879			if mem != x0.Args[1] {
 27880				break
 27881			}
 27882			if !(i1 == i0+4 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
 27883				break
 27884			}
 27885			b = mergePoint(b, x0, x1)
 27886			v0 := b.NewValue0(x0.Pos, OpS390XMOVDBRload, typ.UInt64)
 27887			v.reset(OpCopy)
 27888			v.AddArg(v0)
 27889			v0.AuxInt = i0
 27890			v0.Aux = s
 27891			v0.AddArg(p)
 27892			v0.AddArg(mem)
 27893			return true
 27894		}
 27895		// match: (OR s1:(SLDconst [j1] x1:(MOVBZload [i1] {s} p mem)) or:(OR s0:(SLDconst [j0] x0:(MOVBZload [i0] {s} p mem)) y))
 27896		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 27897		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRload [i0] {s} p mem))) y)
 27898		for {
 27899			_ = v.Args[1]
 27900			s1 := v.Args[0]
 27901			if s1.Op != OpS390XSLDconst {
 27902				break
 27903			}
 27904			j1 := s1.AuxInt
 27905			x1 := s1.Args[0]
 27906			if x1.Op != OpS390XMOVBZload {
 27907				break
 27908			}
 27909			i1 := x1.AuxInt
 27910			s := x1.Aux
 27911			mem := x1.Args[1]
 27912			p := x1.Args[0]
 27913			or := v.Args[1]
 27914			if or.Op != OpS390XOR {
 27915				break
 27916			}
 27917			y := or.Args[1]
 27918			s0 := or.Args[0]
 27919			if s0.Op != OpS390XSLDconst {
 27920				break
 27921			}
 27922			j0 := s0.AuxInt
 27923			x0 := s0.Args[0]
 27924			if x0.Op != OpS390XMOVBZload {
 27925				break
 27926			}
 27927			i0 := x0.AuxInt
 27928			if x0.Aux != s {
 27929				break
 27930			}
 27931			_ = x0.Args[1]
 27932			if p != x0.Args[0] {
 27933				break
 27934			}
 27935			if mem != x0.Args[1] {
 27936				break
 27937			}
 27938			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 27939				break
 27940			}
 27941			b = mergePoint(b, x0, x1, y)
 27942			v0 := b.NewValue0(x0.Pos, OpS390XOR, v.Type)
 27943			v.reset(OpCopy)
 27944			v.AddArg(v0)
 27945			v1 := b.NewValue0(x0.Pos, OpS390XSLDconst, v.Type)
 27946			v1.AuxInt = j0
 27947			v2 := b.NewValue0(x0.Pos, OpS390XMOVHZreg, typ.UInt64)
 27948			v3 := b.NewValue0(x0.Pos, OpS390XMOVHBRload, typ.UInt16)
 27949			v3.AuxInt = i0
 27950			v3.Aux = s
 27951			v3.AddArg(p)
 27952			v3.AddArg(mem)
 27953			v2.AddArg(v3)
 27954			v1.AddArg(v2)
 27955			v0.AddArg(v1)
 27956			v0.AddArg(y)
 27957			return true
 27958		}
 27959		// match: (OR s1:(SLDconst [j1] x1:(MOVBZload [i1] {s} p mem)) or:(OR y s0:(SLDconst [j0] x0:(MOVBZload [i0] {s} p mem))))
 27960		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 27961		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRload [i0] {s} p mem))) y)
 27962		for {
 27963			_ = v.Args[1]
 27964			s1 := v.Args[0]
 27965			if s1.Op != OpS390XSLDconst {
 27966				break
 27967			}
 27968			j1 := s1.AuxInt
 27969			x1 := s1.Args[0]
 27970			if x1.Op != OpS390XMOVBZload {
 27971				break
 27972			}
 27973			i1 := x1.AuxInt
 27974			s := x1.Aux
 27975			mem := x1.Args[1]
 27976			p := x1.Args[0]
 27977			or := v.Args[1]
 27978			if or.Op != OpS390XOR {
 27979				break
 27980			}
 27981			_ = or.Args[1]
 27982			y := or.Args[0]
 27983			s0 := or.Args[1]
 27984			if s0.Op != OpS390XSLDconst {
 27985				break
 27986			}
 27987			j0 := s0.AuxInt
 27988			x0 := s0.Args[0]
 27989			if x0.Op != OpS390XMOVBZload {
 27990				break
 27991			}
 27992			i0 := x0.AuxInt
 27993			if x0.Aux != s {
 27994				break
 27995			}
 27996			_ = x0.Args[1]
 27997			if p != x0.Args[0] {
 27998				break
 27999			}
 28000			if mem != x0.Args[1] {
 28001				break
 28002			}
 28003			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 28004				break
 28005			}
 28006			b = mergePoint(b, x0, x1, y)
 28007			v0 := b.NewValue0(x0.Pos, OpS390XOR, v.Type)
 28008			v.reset(OpCopy)
 28009			v.AddArg(v0)
 28010			v1 := b.NewValue0(x0.Pos, OpS390XSLDconst, v.Type)
 28011			v1.AuxInt = j0
 28012			v2 := b.NewValue0(x0.Pos, OpS390XMOVHZreg, typ.UInt64)
 28013			v3 := b.NewValue0(x0.Pos, OpS390XMOVHBRload, typ.UInt16)
 28014			v3.AuxInt = i0
 28015			v3.Aux = s
 28016			v3.AddArg(p)
 28017			v3.AddArg(mem)
 28018			v2.AddArg(v3)
 28019			v1.AddArg(v2)
 28020			v0.AddArg(v1)
 28021			v0.AddArg(y)
 28022			return true
 28023		}
 28024		// match: (OR or:(OR s0:(SLDconst [j0] x0:(MOVBZload [i0] {s} p mem)) y) s1:(SLDconst [j1] x1:(MOVBZload [i1] {s} p mem)))
 28025		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 28026		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRload [i0] {s} p mem))) y)
 28027		for {
 28028			_ = v.Args[1]
 28029			or := v.Args[0]
 28030			if or.Op != OpS390XOR {
 28031				break
 28032			}
 28033			y := or.Args[1]
 28034			s0 := or.Args[0]
 28035			if s0.Op != OpS390XSLDconst {
 28036				break
 28037			}
 28038			j0 := s0.AuxInt
 28039			x0 := s0.Args[0]
 28040			if x0.Op != OpS390XMOVBZload {
 28041				break
 28042			}
 28043			i0 := x0.AuxInt
 28044			s := x0.Aux
 28045			mem := x0.Args[1]
 28046			p := x0.Args[0]
 28047			s1 := v.Args[1]
 28048			if s1.Op != OpS390XSLDconst {
 28049				break
 28050			}
 28051			j1 := s1.AuxInt
 28052			x1 := s1.Args[0]
 28053			if x1.Op != OpS390XMOVBZload {
 28054				break
 28055			}
 28056			i1 := x1.AuxInt
 28057			if x1.Aux != s {
 28058				break
 28059			}
 28060			_ = x1.Args[1]
 28061			if p != x1.Args[0] {
 28062				break
 28063			}
 28064			if mem != x1.Args[1] {
 28065				break
 28066			}
 28067			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 28068				break
 28069			}
 28070			b = mergePoint(b, x0, x1, y)
 28071			v0 := b.NewValue0(x1.Pos, OpS390XOR, v.Type)
 28072			v.reset(OpCopy)
 28073			v.AddArg(v0)
 28074			v1 := b.NewValue0(x1.Pos, OpS390XSLDconst, v.Type)
 28075			v1.AuxInt = j0
 28076			v2 := b.NewValue0(x1.Pos, OpS390XMOVHZreg, typ.UInt64)
 28077			v3 := b.NewValue0(x1.Pos, OpS390XMOVHBRload, typ.UInt16)
 28078			v3.AuxInt = i0
 28079			v3.Aux = s
 28080			v3.AddArg(p)
 28081			v3.AddArg(mem)
 28082			v2.AddArg(v3)
 28083			v1.AddArg(v2)
 28084			v0.AddArg(v1)
 28085			v0.AddArg(y)
 28086			return true
 28087		}
 28088		// match: (OR or:(OR y s0:(SLDconst [j0] x0:(MOVBZload [i0] {s} p mem))) s1:(SLDconst [j1] x1:(MOVBZload [i1] {s} p mem)))
 28089		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 28090		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRload [i0] {s} p mem))) y)
 28091		for {
 28092			_ = v.Args[1]
 28093			or := v.Args[0]
 28094			if or.Op != OpS390XOR {
 28095				break
 28096			}
 28097			_ = or.Args[1]
 28098			y := or.Args[0]
 28099			s0 := or.Args[1]
 28100			if s0.Op != OpS390XSLDconst {
 28101				break
 28102			}
 28103			j0 := s0.AuxInt
 28104			x0 := s0.Args[0]
 28105			if x0.Op != OpS390XMOVBZload {
 28106				break
 28107			}
 28108			i0 := x0.AuxInt
 28109			s := x0.Aux
 28110			mem := x0.Args[1]
 28111			p := x0.Args[0]
 28112			s1 := v.Args[1]
 28113			if s1.Op != OpS390XSLDconst {
 28114				break
 28115			}
 28116			j1 := s1.AuxInt
 28117			x1 := s1.Args[0]
 28118			if x1.Op != OpS390XMOVBZload {
 28119				break
 28120			}
 28121			i1 := x1.AuxInt
 28122			if x1.Aux != s {
 28123				break
 28124			}
 28125			_ = x1.Args[1]
 28126			if p != x1.Args[0] {
 28127				break
 28128			}
 28129			if mem != x1.Args[1] {
 28130				break
 28131			}
 28132			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 28133				break
 28134			}
 28135			b = mergePoint(b, x0, x1, y)
 28136			v0 := b.NewValue0(x1.Pos, OpS390XOR, v.Type)
 28137			v.reset(OpCopy)
 28138			v.AddArg(v0)
 28139			v1 := b.NewValue0(x1.Pos, OpS390XSLDconst, v.Type)
 28140			v1.AuxInt = j0
 28141			v2 := b.NewValue0(x1.Pos, OpS390XMOVHZreg, typ.UInt64)
 28142			v3 := b.NewValue0(x1.Pos, OpS390XMOVHBRload, typ.UInt16)
 28143			v3.AuxInt = i0
 28144			v3.Aux = s
 28145			v3.AddArg(p)
 28146			v3.AddArg(mem)
 28147			v2.AddArg(v3)
 28148			v1.AddArg(v2)
 28149			v0.AddArg(v1)
 28150			v0.AddArg(y)
 28151			return true
 28152		}
 28153		// match: (OR s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRload [i1] {s} p mem))) or:(OR s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRload [i0] {s} p mem))) y))
 28154		// cond: i1 == i0+2 && j1 == j0+16 && j0 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)
 28155		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRload [i0] {s} p mem))) y)
 28156		for {
 28157			_ = v.Args[1]
 28158			s1 := v.Args[0]
 28159			if s1.Op != OpS390XSLDconst {
 28160				break
 28161			}
 28162			j1 := s1.AuxInt
 28163			r1 := s1.Args[0]
 28164			if r1.Op != OpS390XMOVHZreg {
 28165				break
 28166			}
 28167			x1 := r1.Args[0]
 28168			if x1.Op != OpS390XMOVHBRload {
 28169				break
 28170			}
 28171			i1 := x1.AuxInt
 28172			s := x1.Aux
 28173			mem := x1.Args[1]
 28174			p := x1.Args[0]
 28175			or := v.Args[1]
 28176			if or.Op != OpS390XOR {
 28177				break
 28178			}
 28179			y := or.Args[1]
 28180			s0 := or.Args[0]
 28181			if s0.Op != OpS390XSLDconst {
 28182				break
 28183			}
 28184			j0 := s0.AuxInt
 28185			r0 := s0.Args[0]
 28186			if r0.Op != OpS390XMOVHZreg {
 28187				break
 28188			}
 28189			x0 := r0.Args[0]
 28190			if x0.Op != OpS390XMOVHBRload {
 28191				break
 28192			}
 28193			i0 := x0.AuxInt
 28194			if x0.Aux != s {
 28195				break
 28196			}
 28197			_ = x0.Args[1]
 28198			if p != x0.Args[0] {
 28199				break
 28200			}
 28201			if mem != x0.Args[1] {
 28202				break
 28203			}
 28204			if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
 28205				break
 28206			}
 28207			b = mergePoint(b, x0, x1, y)
 28208			v0 := b.NewValue0(x0.Pos, OpS390XOR, v.Type)
 28209			v.reset(OpCopy)
 28210			v.AddArg(v0)
 28211			v1 := b.NewValue0(x0.Pos, OpS390XSLDconst, v.Type)
 28212			v1.AuxInt = j0
 28213			v2 := b.NewValue0(x0.Pos, OpS390XMOVWZreg, typ.UInt64)
 28214			v3 := b.NewValue0(x0.Pos, OpS390XMOVWBRload, typ.UInt32)
 28215			v3.AuxInt = i0
 28216			v3.Aux = s
 28217			v3.AddArg(p)
 28218			v3.AddArg(mem)
 28219			v2.AddArg(v3)
 28220			v1.AddArg(v2)
 28221			v0.AddArg(v1)
 28222			v0.AddArg(y)
 28223			return true
 28224		}
 28225		// match: (OR s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRload [i1] {s} p mem))) or:(OR y s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRload [i0] {s} p mem)))))
 28226		// cond: i1 == i0+2 && j1 == j0+16 && j0 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)
 28227		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRload [i0] {s} p mem))) y)
 28228		for {
 28229			_ = v.Args[1]
 28230			s1 := v.Args[0]
 28231			if s1.Op != OpS390XSLDconst {
 28232				break
 28233			}
 28234			j1 := s1.AuxInt
 28235			r1 := s1.Args[0]
 28236			if r1.Op != OpS390XMOVHZreg {
 28237				break
 28238			}
 28239			x1 := r1.Args[0]
 28240			if x1.Op != OpS390XMOVHBRload {
 28241				break
 28242			}
 28243			i1 := x1.AuxInt
 28244			s := x1.Aux
 28245			mem := x1.Args[1]
 28246			p := x1.Args[0]
 28247			or := v.Args[1]
 28248			if or.Op != OpS390XOR {
 28249				break
 28250			}
 28251			_ = or.Args[1]
 28252			y := or.Args[0]
 28253			s0 := or.Args[1]
 28254			if s0.Op != OpS390XSLDconst {
 28255				break
 28256			}
 28257			j0 := s0.AuxInt
 28258			r0 := s0.Args[0]
 28259			if r0.Op != OpS390XMOVHZreg {
 28260				break
 28261			}
 28262			x0 := r0.Args[0]
 28263			if x0.Op != OpS390XMOVHBRload {
 28264				break
 28265			}
 28266			i0 := x0.AuxInt
 28267			if x0.Aux != s {
 28268				break
 28269			}
 28270			_ = x0.Args[1]
 28271			if p != x0.Args[0] {
 28272				break
 28273			}
 28274			if mem != x0.Args[1] {
 28275				break
 28276			}
 28277			if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
 28278				break
 28279			}
 28280			b = mergePoint(b, x0, x1, y)
 28281			v0 := b.NewValue0(x0.Pos, OpS390XOR, v.Type)
 28282			v.reset(OpCopy)
 28283			v.AddArg(v0)
 28284			v1 := b.NewValue0(x0.Pos, OpS390XSLDconst, v.Type)
 28285			v1.AuxInt = j0
 28286			v2 := b.NewValue0(x0.Pos, OpS390XMOVWZreg, typ.UInt64)
 28287			v3 := b.NewValue0(x0.Pos, OpS390XMOVWBRload, typ.UInt32)
 28288			v3.AuxInt = i0
 28289			v3.Aux = s
 28290			v3.AddArg(p)
 28291			v3.AddArg(mem)
 28292			v2.AddArg(v3)
 28293			v1.AddArg(v2)
 28294			v0.AddArg(v1)
 28295			v0.AddArg(y)
 28296			return true
 28297		}
 28298		// match: (OR or:(OR s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRload [i0] {s} p mem))) y) s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRload [i1] {s} p mem))))
 28299		// cond: i1 == i0+2 && j1 == j0+16 && j0 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)
 28300		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRload [i0] {s} p mem))) y)
 28301		for {
 28302			_ = v.Args[1]
 28303			or := v.Args[0]
 28304			if or.Op != OpS390XOR {
 28305				break
 28306			}
 28307			y := or.Args[1]
 28308			s0 := or.Args[0]
 28309			if s0.Op != OpS390XSLDconst {
 28310				break
 28311			}
 28312			j0 := s0.AuxInt
 28313			r0 := s0.Args[0]
 28314			if r0.Op != OpS390XMOVHZreg {
 28315				break
 28316			}
 28317			x0 := r0.Args[0]
 28318			if x0.Op != OpS390XMOVHBRload {
 28319				break
 28320			}
 28321			i0 := x0.AuxInt
 28322			s := x0.Aux
 28323			mem := x0.Args[1]
 28324			p := x0.Args[0]
 28325			s1 := v.Args[1]
 28326			if s1.Op != OpS390XSLDconst {
 28327				break
 28328			}
 28329			j1 := s1.AuxInt
 28330			r1 := s1.Args[0]
 28331			if r1.Op != OpS390XMOVHZreg {
 28332				break
 28333			}
 28334			x1 := r1.Args[0]
 28335			if x1.Op != OpS390XMOVHBRload {
 28336				break
 28337			}
 28338			i1 := x1.AuxInt
 28339			if x1.Aux != s {
 28340				break
 28341			}
 28342			_ = x1.Args[1]
 28343			if p != x1.Args[0] {
 28344				break
 28345			}
 28346			if mem != x1.Args[1] {
 28347				break
 28348			}
 28349			if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
 28350				break
 28351			}
 28352			b = mergePoint(b, x0, x1, y)
 28353			v0 := b.NewValue0(x1.Pos, OpS390XOR, v.Type)
 28354			v.reset(OpCopy)
 28355			v.AddArg(v0)
 28356			v1 := b.NewValue0(x1.Pos, OpS390XSLDconst, v.Type)
 28357			v1.AuxInt = j0
 28358			v2 := b.NewValue0(x1.Pos, OpS390XMOVWZreg, typ.UInt64)
 28359			v3 := b.NewValue0(x1.Pos, OpS390XMOVWBRload, typ.UInt32)
 28360			v3.AuxInt = i0
 28361			v3.Aux = s
 28362			v3.AddArg(p)
 28363			v3.AddArg(mem)
 28364			v2.AddArg(v3)
 28365			v1.AddArg(v2)
 28366			v0.AddArg(v1)
 28367			v0.AddArg(y)
 28368			return true
 28369		}
 28370		return false
 28371	}
 28372	func rewriteValueS390X_OpS390XOR_100(v *Value) bool {
 28373		b := v.Block
 28374		typ := &b.Func.Config.Types
 28375		// match: (OR or:(OR y s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRload [i0] {s} p mem)))) s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRload [i1] {s} p mem))))
 28376		// cond: i1 == i0+2 && j1 == j0+16 && j0 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)
 28377		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRload [i0] {s} p mem))) y)
 28378		for {
 28379			_ = v.Args[1]
 28380			or := v.Args[0]
 28381			if or.Op != OpS390XOR {
 28382				break
 28383			}
 28384			_ = or.Args[1]
 28385			y := or.Args[0]
 28386			s0 := or.Args[1]
 28387			if s0.Op != OpS390XSLDconst {
 28388				break
 28389			}
 28390			j0 := s0.AuxInt
 28391			r0 := s0.Args[0]
 28392			if r0.Op != OpS390XMOVHZreg {
 28393				break
 28394			}
 28395			x0 := r0.Args[0]
 28396			if x0.Op != OpS390XMOVHBRload {
 28397				break
 28398			}
 28399			i0 := x0.AuxInt
 28400			s := x0.Aux
 28401			mem := x0.Args[1]
 28402			p := x0.Args[0]
 28403			s1 := v.Args[1]
 28404			if s1.Op != OpS390XSLDconst {
 28405				break
 28406			}
 28407			j1 := s1.AuxInt
 28408			r1 := s1.Args[0]
 28409			if r1.Op != OpS390XMOVHZreg {
 28410				break
 28411			}
 28412			x1 := r1.Args[0]
 28413			if x1.Op != OpS390XMOVHBRload {
 28414				break
 28415			}
 28416			i1 := x1.AuxInt
 28417			if x1.Aux != s {
 28418				break
 28419			}
 28420			_ = x1.Args[1]
 28421			if p != x1.Args[0] {
 28422				break
 28423			}
 28424			if mem != x1.Args[1] {
 28425				break
 28426			}
 28427			if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
 28428				break
 28429			}
 28430			b = mergePoint(b, x0, x1, y)
 28431			v0 := b.NewValue0(x1.Pos, OpS390XOR, v.Type)
 28432			v.reset(OpCopy)
 28433			v.AddArg(v0)
 28434			v1 := b.NewValue0(x1.Pos, OpS390XSLDconst, v.Type)
 28435			v1.AuxInt = j0
 28436			v2 := b.NewValue0(x1.Pos, OpS390XMOVWZreg, typ.UInt64)
 28437			v3 := b.NewValue0(x1.Pos, OpS390XMOVWBRload, typ.UInt32)
 28438			v3.AuxInt = i0
 28439			v3.Aux = s
 28440			v3.AddArg(p)
 28441			v3.AddArg(mem)
 28442			v2.AddArg(v3)
 28443			v1.AddArg(v2)
 28444			v0.AddArg(v1)
 28445			v0.AddArg(y)
 28446			return true
 28447		}
 28448		// match: (OR x0:(MOVBZloadidx [i0] {s} p idx mem) sh:(SLDconst [8] x1:(MOVBZloadidx [i1] {s} p idx mem)))
 28449		// cond: p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 28450		// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))
 28451		for {
 28452			_ = v.Args[1]
 28453			x0 := v.Args[0]
 28454			if x0.Op != OpS390XMOVBZloadidx {
 28455				break
 28456			}
 28457			i0 := x0.AuxInt
 28458			s := x0.Aux
 28459			mem := x0.Args[2]
 28460			p := x0.Args[0]
 28461			idx := x0.Args[1]
 28462			sh := v.Args[1]
 28463			if sh.Op != OpS390XSLDconst {
 28464				break
 28465			}
 28466			if sh.AuxInt != 8 {
 28467				break
 28468			}
 28469			x1 := sh.Args[0]
 28470			if x1.Op != OpS390XMOVBZloadidx {
 28471				break
 28472			}
 28473			i1 := x1.AuxInt
 28474			if x1.Aux != s {
 28475				break
 28476			}
 28477			_ = x1.Args[2]
 28478			if p != x1.Args[0] {
 28479				break
 28480			}
 28481			if idx != x1.Args[1] {
 28482				break
 28483			}
 28484			if mem != x1.Args[2] {
 28485				break
 28486			}
 28487			if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 28488				break
 28489			}
 28490			b = mergePoint(b, x0, x1)
 28491			v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 28492			v.reset(OpCopy)
 28493			v.AddArg(v0)
 28494			v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 28495			v1.AuxInt = i0
 28496			v1.Aux = s
 28497			v1.AddArg(p)
 28498			v1.AddArg(idx)
 28499			v1.AddArg(mem)
 28500			v0.AddArg(v1)
 28501			return true
 28502		}
 28503		// match: (OR x0:(MOVBZloadidx [i0] {s} idx p mem) sh:(SLDconst [8] x1:(MOVBZloadidx [i1] {s} p idx mem)))
 28504		// cond: p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 28505		// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))
 28506		for {
 28507			_ = v.Args[1]
 28508			x0 := v.Args[0]
 28509			if x0.Op != OpS390XMOVBZloadidx {
 28510				break
 28511			}
 28512			i0 := x0.AuxInt
 28513			s := x0.Aux
 28514			mem := x0.Args[2]
 28515			idx := x0.Args[0]
 28516			p := x0.Args[1]
 28517			sh := v.Args[1]
 28518			if sh.Op != OpS390XSLDconst {
 28519				break
 28520			}
 28521			if sh.AuxInt != 8 {
 28522				break
 28523			}
 28524			x1 := sh.Args[0]
 28525			if x1.Op != OpS390XMOVBZloadidx {
 28526				break
 28527			}
 28528			i1 := x1.AuxInt
 28529			if x1.Aux != s {
 28530				break
 28531			}
 28532			_ = x1.Args[2]
 28533			if p != x1.Args[0] {
 28534				break
 28535			}
 28536			if idx != x1.Args[1] {
 28537				break
 28538			}
 28539			if mem != x1.Args[2] {
 28540				break
 28541			}
 28542			if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 28543				break
 28544			}
 28545			b = mergePoint(b, x0, x1)
 28546			v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 28547			v.reset(OpCopy)
 28548			v.AddArg(v0)
 28549			v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 28550			v1.AuxInt = i0
 28551			v1.Aux = s
 28552			v1.AddArg(p)
 28553			v1.AddArg(idx)
 28554			v1.AddArg(mem)
 28555			v0.AddArg(v1)
 28556			return true
 28557		}
 28558		// match: (OR x0:(MOVBZloadidx [i0] {s} p idx mem) sh:(SLDconst [8] x1:(MOVBZloadidx [i1] {s} idx p mem)))
 28559		// cond: p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 28560		// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))
 28561		for {
 28562			_ = v.Args[1]
 28563			x0 := v.Args[0]
 28564			if x0.Op != OpS390XMOVBZloadidx {
 28565				break
 28566			}
 28567			i0 := x0.AuxInt
 28568			s := x0.Aux
 28569			mem := x0.Args[2]
 28570			p := x0.Args[0]
 28571			idx := x0.Args[1]
 28572			sh := v.Args[1]
 28573			if sh.Op != OpS390XSLDconst {
 28574				break
 28575			}
 28576			if sh.AuxInt != 8 {
 28577				break
 28578			}
 28579			x1 := sh.Args[0]
 28580			if x1.Op != OpS390XMOVBZloadidx {
 28581				break
 28582			}
 28583			i1 := x1.AuxInt
 28584			if x1.Aux != s {
 28585				break
 28586			}
 28587			_ = x1.Args[2]
 28588			if idx != x1.Args[0] {
 28589				break
 28590			}
 28591			if p != x1.Args[1] {
 28592				break
 28593			}
 28594			if mem != x1.Args[2] {
 28595				break
 28596			}
 28597			if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 28598				break
 28599			}
 28600			b = mergePoint(b, x0, x1)
 28601			v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 28602			v.reset(OpCopy)
 28603			v.AddArg(v0)
 28604			v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 28605			v1.AuxInt = i0
 28606			v1.Aux = s
 28607			v1.AddArg(p)
 28608			v1.AddArg(idx)
 28609			v1.AddArg(mem)
 28610			v0.AddArg(v1)
 28611			return true
 28612		}
 28613		// match: (OR x0:(MOVBZloadidx [i0] {s} idx p mem) sh:(SLDconst [8] x1:(MOVBZloadidx [i1] {s} idx p mem)))
 28614		// cond: p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 28615		// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))
 28616		for {
 28617			_ = v.Args[1]
 28618			x0 := v.Args[0]
 28619			if x0.Op != OpS390XMOVBZloadidx {
 28620				break
 28621			}
 28622			i0 := x0.AuxInt
 28623			s := x0.Aux
 28624			mem := x0.Args[2]
 28625			idx := x0.Args[0]
 28626			p := x0.Args[1]
 28627			sh := v.Args[1]
 28628			if sh.Op != OpS390XSLDconst {
 28629				break
 28630			}
 28631			if sh.AuxInt != 8 {
 28632				break
 28633			}
 28634			x1 := sh.Args[0]
 28635			if x1.Op != OpS390XMOVBZloadidx {
 28636				break
 28637			}
 28638			i1 := x1.AuxInt
 28639			if x1.Aux != s {
 28640				break
 28641			}
 28642			_ = x1.Args[2]
 28643			if idx != x1.Args[0] {
 28644				break
 28645			}
 28646			if p != x1.Args[1] {
 28647				break
 28648			}
 28649			if mem != x1.Args[2] {
 28650				break
 28651			}
 28652			if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 28653				break
 28654			}
 28655			b = mergePoint(b, x0, x1)
 28656			v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 28657			v.reset(OpCopy)
 28658			v.AddArg(v0)
 28659			v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 28660			v1.AuxInt = i0
 28661			v1.Aux = s
 28662			v1.AddArg(p)
 28663			v1.AddArg(idx)
 28664			v1.AddArg(mem)
 28665			v0.AddArg(v1)
 28666			return true
 28667		}
 28668		// match: (OR sh:(SLDconst [8] x1:(MOVBZloadidx [i1] {s} p idx mem)) x0:(MOVBZloadidx [i0] {s} p idx mem))
 28669		// cond: p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 28670		// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))
 28671		for {
 28672			_ = v.Args[1]
 28673			sh := v.Args[0]
 28674			if sh.Op != OpS390XSLDconst {
 28675				break
 28676			}
 28677			if sh.AuxInt != 8 {
 28678				break
 28679			}
 28680			x1 := sh.Args[0]
 28681			if x1.Op != OpS390XMOVBZloadidx {
 28682				break
 28683			}
 28684			i1 := x1.AuxInt
 28685			s := x1.Aux
 28686			mem := x1.Args[2]
 28687			p := x1.Args[0]
 28688			idx := x1.Args[1]
 28689			x0 := v.Args[1]
 28690			if x0.Op != OpS390XMOVBZloadidx {
 28691				break
 28692			}
 28693			i0 := x0.AuxInt
 28694			if x0.Aux != s {
 28695				break
 28696			}
 28697			_ = x0.Args[2]
 28698			if p != x0.Args[0] {
 28699				break
 28700			}
 28701			if idx != x0.Args[1] {
 28702				break
 28703			}
 28704			if mem != x0.Args[2] {
 28705				break
 28706			}
 28707			if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 28708				break
 28709			}
 28710			b = mergePoint(b, x0, x1)
 28711			v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 28712			v.reset(OpCopy)
 28713			v.AddArg(v0)
 28714			v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 28715			v1.AuxInt = i0
 28716			v1.Aux = s
 28717			v1.AddArg(p)
 28718			v1.AddArg(idx)
 28719			v1.AddArg(mem)
 28720			v0.AddArg(v1)
 28721			return true
 28722		}
 28723		// match: (OR sh:(SLDconst [8] x1:(MOVBZloadidx [i1] {s} idx p mem)) x0:(MOVBZloadidx [i0] {s} p idx mem))
 28724		// cond: p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 28725		// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))
 28726		for {
 28727			_ = v.Args[1]
 28728			sh := v.Args[0]
 28729			if sh.Op != OpS390XSLDconst {
 28730				break
 28731			}
 28732			if sh.AuxInt != 8 {
 28733				break
 28734			}
 28735			x1 := sh.Args[0]
 28736			if x1.Op != OpS390XMOVBZloadidx {
 28737				break
 28738			}
 28739			i1 := x1.AuxInt
 28740			s := x1.Aux
 28741			mem := x1.Args[2]
 28742			idx := x1.Args[0]
 28743			p := x1.Args[1]
 28744			x0 := v.Args[1]
 28745			if x0.Op != OpS390XMOVBZloadidx {
 28746				break
 28747			}
 28748			i0 := x0.AuxInt
 28749			if x0.Aux != s {
 28750				break
 28751			}
 28752			_ = x0.Args[2]
 28753			if p != x0.Args[0] {
 28754				break
 28755			}
 28756			if idx != x0.Args[1] {
 28757				break
 28758			}
 28759			if mem != x0.Args[2] {
 28760				break
 28761			}
 28762			if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 28763				break
 28764			}
 28765			b = mergePoint(b, x0, x1)
 28766			v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 28767			v.reset(OpCopy)
 28768			v.AddArg(v0)
 28769			v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 28770			v1.AuxInt = i0
 28771			v1.Aux = s
 28772			v1.AddArg(p)
 28773			v1.AddArg(idx)
 28774			v1.AddArg(mem)
 28775			v0.AddArg(v1)
 28776			return true
 28777		}
 28778		// match: (OR sh:(SLDconst [8] x1:(MOVBZloadidx [i1] {s} p idx mem)) x0:(MOVBZloadidx [i0] {s} idx p mem))
 28779		// cond: p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 28780		// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))
 28781		for {
 28782			_ = v.Args[1]
 28783			sh := v.Args[0]
 28784			if sh.Op != OpS390XSLDconst {
 28785				break
 28786			}
 28787			if sh.AuxInt != 8 {
 28788				break
 28789			}
 28790			x1 := sh.Args[0]
 28791			if x1.Op != OpS390XMOVBZloadidx {
 28792				break
 28793			}
 28794			i1 := x1.AuxInt
 28795			s := x1.Aux
 28796			mem := x1.Args[2]
 28797			p := x1.Args[0]
 28798			idx := x1.Args[1]
 28799			x0 := v.Args[1]
 28800			if x0.Op != OpS390XMOVBZloadidx {
 28801				break
 28802			}
 28803			i0 := x0.AuxInt
 28804			if x0.Aux != s {
 28805				break
 28806			}
 28807			_ = x0.Args[2]
 28808			if idx != x0.Args[0] {
 28809				break
 28810			}
 28811			if p != x0.Args[1] {
 28812				break
 28813			}
 28814			if mem != x0.Args[2] {
 28815				break
 28816			}
 28817			if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 28818				break
 28819			}
 28820			b = mergePoint(b, x0, x1)
 28821			v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 28822			v.reset(OpCopy)
 28823			v.AddArg(v0)
 28824			v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 28825			v1.AuxInt = i0
 28826			v1.Aux = s
 28827			v1.AddArg(p)
 28828			v1.AddArg(idx)
 28829			v1.AddArg(mem)
 28830			v0.AddArg(v1)
 28831			return true
 28832		}
 28833		// match: (OR sh:(SLDconst [8] x1:(MOVBZloadidx [i1] {s} idx p mem)) x0:(MOVBZloadidx [i0] {s} idx p mem))
 28834		// cond: p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 28835		// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))
 28836		for {
 28837			_ = v.Args[1]
 28838			sh := v.Args[0]
 28839			if sh.Op != OpS390XSLDconst {
 28840				break
 28841			}
 28842			if sh.AuxInt != 8 {
 28843				break
 28844			}
 28845			x1 := sh.Args[0]
 28846			if x1.Op != OpS390XMOVBZloadidx {
 28847				break
 28848			}
 28849			i1 := x1.AuxInt
 28850			s := x1.Aux
 28851			mem := x1.Args[2]
 28852			idx := x1.Args[0]
 28853			p := x1.Args[1]
 28854			x0 := v.Args[1]
 28855			if x0.Op != OpS390XMOVBZloadidx {
 28856				break
 28857			}
 28858			i0 := x0.AuxInt
 28859			if x0.Aux != s {
 28860				break
 28861			}
 28862			_ = x0.Args[2]
 28863			if idx != x0.Args[0] {
 28864				break
 28865			}
 28866			if p != x0.Args[1] {
 28867				break
 28868			}
 28869			if mem != x0.Args[2] {
 28870				break
 28871			}
 28872			if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 28873				break
 28874			}
 28875			b = mergePoint(b, x0, x1)
 28876			v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 28877			v.reset(OpCopy)
 28878			v.AddArg(v0)
 28879			v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 28880			v1.AuxInt = i0
 28881			v1.Aux = s
 28882			v1.AddArg(p)
 28883			v1.AddArg(idx)
 28884			v1.AddArg(mem)
 28885			v0.AddArg(v1)
 28886			return true
 28887		}
 28888		// match: (OR r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} p idx mem)) sh:(SLDconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem))))
 28889		// cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
 28890		// result: @mergePoint(b,x0,x1) (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))
 28891		for {
 28892			_ = v.Args[1]
 28893			r0 := v.Args[0]
 28894			if r0.Op != OpS390XMOVHZreg {
 28895				break
 28896			}
 28897			x0 := r0.Args[0]
 28898			if x0.Op != OpS390XMOVHBRloadidx {
 28899				break
 28900			}
 28901			i0 := x0.AuxInt
 28902			s := x0.Aux
 28903			mem := x0.Args[2]
 28904			p := x0.Args[0]
 28905			idx := x0.Args[1]
 28906			sh := v.Args[1]
 28907			if sh.Op != OpS390XSLDconst {
 28908				break
 28909			}
 28910			if sh.AuxInt != 16 {
 28911				break
 28912			}
 28913			r1 := sh.Args[0]
 28914			if r1.Op != OpS390XMOVHZreg {
 28915				break
 28916			}
 28917			x1 := r1.Args[0]
 28918			if x1.Op != OpS390XMOVHBRloadidx {
 28919				break
 28920			}
 28921			i1 := x1.AuxInt
 28922			if x1.Aux != s {
 28923				break
 28924			}
 28925			_ = x1.Args[2]
 28926			if p != x1.Args[0] {
 28927				break
 28928			}
 28929			if idx != x1.Args[1] {
 28930				break
 28931			}
 28932			if mem != x1.Args[2] {
 28933				break
 28934			}
 28935			if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
 28936				break
 28937			}
 28938			b = mergePoint(b, x0, x1)
 28939			v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
 28940			v.reset(OpCopy)
 28941			v.AddArg(v0)
 28942			v1 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
 28943			v1.AuxInt = i0
 28944			v1.Aux = s
 28945			v1.AddArg(p)
 28946			v1.AddArg(idx)
 28947			v1.AddArg(mem)
 28948			v0.AddArg(v1)
 28949			return true
 28950		}
 28951		return false
 28952	}
 28953	func rewriteValueS390X_OpS390XOR_110(v *Value) bool {
 28954		b := v.Block
 28955		typ := &b.Func.Config.Types
 28956		// match: (OR r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem)) sh:(SLDconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem))))
 28957		// cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
 28958		// result: @mergePoint(b,x0,x1) (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))
 28959		for {
 28960			_ = v.Args[1]
 28961			r0 := v.Args[0]
 28962			if r0.Op != OpS390XMOVHZreg {
 28963				break
 28964			}
 28965			x0 := r0.Args[0]
 28966			if x0.Op != OpS390XMOVHBRloadidx {
 28967				break
 28968			}
 28969			i0 := x0.AuxInt
 28970			s := x0.Aux
 28971			mem := x0.Args[2]
 28972			idx := x0.Args[0]
 28973			p := x0.Args[1]
 28974			sh := v.Args[1]
 28975			if sh.Op != OpS390XSLDconst {
 28976				break
 28977			}
 28978			if sh.AuxInt != 16 {
 28979				break
 28980			}
 28981			r1 := sh.Args[0]
 28982			if r1.Op != OpS390XMOVHZreg {
 28983				break
 28984			}
 28985			x1 := r1.Args[0]
 28986			if x1.Op != OpS390XMOVHBRloadidx {
 28987				break
 28988			}
 28989			i1 := x1.AuxInt
 28990			if x1.Aux != s {
 28991				break
 28992			}
 28993			_ = x1.Args[2]
 28994			if p != x1.Args[0] {
 28995				break
 28996			}
 28997			if idx != x1.Args[1] {
 28998				break
 28999			}
 29000			if mem != x1.Args[2] {
 29001				break
 29002			}
 29003			if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
 29004				break
 29005			}
 29006			b = mergePoint(b, x0, x1)
 29007			v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
 29008			v.reset(OpCopy)
 29009			v.AddArg(v0)
 29010			v1 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
 29011			v1.AuxInt = i0
 29012			v1.Aux = s
 29013			v1.AddArg(p)
 29014			v1.AddArg(idx)
 29015			v1.AddArg(mem)
 29016			v0.AddArg(v1)
 29017			return true
 29018		}
 29019		// match: (OR r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} p idx mem)) sh:(SLDconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))))
 29020		// cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
 29021		// result: @mergePoint(b,x0,x1) (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))
 29022		for {
 29023			_ = v.Args[1]
 29024			r0 := v.Args[0]
 29025			if r0.Op != OpS390XMOVHZreg {
 29026				break
 29027			}
 29028			x0 := r0.Args[0]
 29029			if x0.Op != OpS390XMOVHBRloadidx {
 29030				break
 29031			}
 29032			i0 := x0.AuxInt
 29033			s := x0.Aux
 29034			mem := x0.Args[2]
 29035			p := x0.Args[0]
 29036			idx := x0.Args[1]
 29037			sh := v.Args[1]
 29038			if sh.Op != OpS390XSLDconst {
 29039				break
 29040			}
 29041			if sh.AuxInt != 16 {
 29042				break
 29043			}
 29044			r1 := sh.Args[0]
 29045			if r1.Op != OpS390XMOVHZreg {
 29046				break
 29047			}
 29048			x1 := r1.Args[0]
 29049			if x1.Op != OpS390XMOVHBRloadidx {
 29050				break
 29051			}
 29052			i1 := x1.AuxInt
 29053			if x1.Aux != s {
 29054				break
 29055			}
 29056			_ = x1.Args[2]
 29057			if idx != x1.Args[0] {
 29058				break
 29059			}
 29060			if p != x1.Args[1] {
 29061				break
 29062			}
 29063			if mem != x1.Args[2] {
 29064				break
 29065			}
 29066			if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
 29067				break
 29068			}
 29069			b = mergePoint(b, x0, x1)
 29070			v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
 29071			v.reset(OpCopy)
 29072			v.AddArg(v0)
 29073			v1 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
 29074			v1.AuxInt = i0
 29075			v1.Aux = s
 29076			v1.AddArg(p)
 29077			v1.AddArg(idx)
 29078			v1.AddArg(mem)
 29079			v0.AddArg(v1)
 29080			return true
 29081		}
 29082		// match: (OR r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem)) sh:(SLDconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))))
 29083		// cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
 29084		// result: @mergePoint(b,x0,x1) (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))
 29085		for {
 29086			_ = v.Args[1]
 29087			r0 := v.Args[0]
 29088			if r0.Op != OpS390XMOVHZreg {
 29089				break
 29090			}
 29091			x0 := r0.Args[0]
 29092			if x0.Op != OpS390XMOVHBRloadidx {
 29093				break
 29094			}
 29095			i0 := x0.AuxInt
 29096			s := x0.Aux
 29097			mem := x0.Args[2]
 29098			idx := x0.Args[0]
 29099			p := x0.Args[1]
 29100			sh := v.Args[1]
 29101			if sh.Op != OpS390XSLDconst {
 29102				break
 29103			}
 29104			if sh.AuxInt != 16 {
 29105				break
 29106			}
 29107			r1 := sh.Args[0]
 29108			if r1.Op != OpS390XMOVHZreg {
 29109				break
 29110			}
 29111			x1 := r1.Args[0]
 29112			if x1.Op != OpS390XMOVHBRloadidx {
 29113				break
 29114			}
 29115			i1 := x1.AuxInt
 29116			if x1.Aux != s {
 29117				break
 29118			}
 29119			_ = x1.Args[2]
 29120			if idx != x1.Args[0] {
 29121				break
 29122			}
 29123			if p != x1.Args[1] {
 29124				break
 29125			}
 29126			if mem != x1.Args[2] {
 29127				break
 29128			}
 29129			if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
 29130				break
 29131			}
 29132			b = mergePoint(b, x0, x1)
 29133			v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
 29134			v.reset(OpCopy)
 29135			v.AddArg(v0)
 29136			v1 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
 29137			v1.AuxInt = i0
 29138			v1.Aux = s
 29139			v1.AddArg(p)
 29140			v1.AddArg(idx)
 29141			v1.AddArg(mem)
 29142			v0.AddArg(v1)
 29143			return true
 29144		}
 29145		// match: (OR sh:(SLDconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem))) r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} p idx mem)))
 29146		// cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
 29147		// result: @mergePoint(b,x0,x1) (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))
 29148		for {
 29149			_ = v.Args[1]
 29150			sh := v.Args[0]
 29151			if sh.Op != OpS390XSLDconst {
 29152				break
 29153			}
 29154			if sh.AuxInt != 16 {
 29155				break
 29156			}
 29157			r1 := sh.Args[0]
 29158			if r1.Op != OpS390XMOVHZreg {
 29159				break
 29160			}
 29161			x1 := r1.Args[0]
 29162			if x1.Op != OpS390XMOVHBRloadidx {
 29163				break
 29164			}
 29165			i1 := x1.AuxInt
 29166			s := x1.Aux
 29167			mem := x1.Args[2]
 29168			p := x1.Args[0]
 29169			idx := x1.Args[1]
 29170			r0 := v.Args[1]
 29171			if r0.Op != OpS390XMOVHZreg {
 29172				break
 29173			}
 29174			x0 := r0.Args[0]
 29175			if x0.Op != OpS390XMOVHBRloadidx {
 29176				break
 29177			}
 29178			i0 := x0.AuxInt
 29179			if x0.Aux != s {
 29180				break
 29181			}
 29182			_ = x0.Args[2]
 29183			if p != x0.Args[0] {
 29184				break
 29185			}
 29186			if idx != x0.Args[1] {
 29187				break
 29188			}
 29189			if mem != x0.Args[2] {
 29190				break
 29191			}
 29192			if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
 29193				break
 29194			}
 29195			b = mergePoint(b, x0, x1)
 29196			v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
 29197			v.reset(OpCopy)
 29198			v.AddArg(v0)
 29199			v1 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
 29200			v1.AuxInt = i0
 29201			v1.Aux = s
 29202			v1.AddArg(p)
 29203			v1.AddArg(idx)
 29204			v1.AddArg(mem)
 29205			v0.AddArg(v1)
 29206			return true
 29207		}
 29208		// match: (OR sh:(SLDconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))) r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} p idx mem)))
 29209		// cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
 29210		// result: @mergePoint(b,x0,x1) (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))
 29211		for {
 29212			_ = v.Args[1]
 29213			sh := v.Args[0]
 29214			if sh.Op != OpS390XSLDconst {
 29215				break
 29216			}
 29217			if sh.AuxInt != 16 {
 29218				break
 29219			}
 29220			r1 := sh.Args[0]
 29221			if r1.Op != OpS390XMOVHZreg {
 29222				break
 29223			}
 29224			x1 := r1.Args[0]
 29225			if x1.Op != OpS390XMOVHBRloadidx {
 29226				break
 29227			}
 29228			i1 := x1.AuxInt
 29229			s := x1.Aux
 29230			mem := x1.Args[2]
 29231			idx := x1.Args[0]
 29232			p := x1.Args[1]
 29233			r0 := v.Args[1]
 29234			if r0.Op != OpS390XMOVHZreg {
 29235				break
 29236			}
 29237			x0 := r0.Args[0]
 29238			if x0.Op != OpS390XMOVHBRloadidx {
 29239				break
 29240			}
 29241			i0 := x0.AuxInt
 29242			if x0.Aux != s {
 29243				break
 29244			}
 29245			_ = x0.Args[2]
 29246			if p != x0.Args[0] {
 29247				break
 29248			}
 29249			if idx != x0.Args[1] {
 29250				break
 29251			}
 29252			if mem != x0.Args[2] {
 29253				break
 29254			}
 29255			if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
 29256				break
 29257			}
 29258			b = mergePoint(b, x0, x1)
 29259			v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
 29260			v.reset(OpCopy)
 29261			v.AddArg(v0)
 29262			v1 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
 29263			v1.AuxInt = i0
 29264			v1.Aux = s
 29265			v1.AddArg(p)
 29266			v1.AddArg(idx)
 29267			v1.AddArg(mem)
 29268			v0.AddArg(v1)
 29269			return true
 29270		}
 29271		// match: (OR sh:(SLDconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem))) r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem)))
 29272		// cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
 29273		// result: @mergePoint(b,x0,x1) (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))
 29274		for {
 29275			_ = v.Args[1]
 29276			sh := v.Args[0]
 29277			if sh.Op != OpS390XSLDconst {
 29278				break
 29279			}
 29280			if sh.AuxInt != 16 {
 29281				break
 29282			}
 29283			r1 := sh.Args[0]
 29284			if r1.Op != OpS390XMOVHZreg {
 29285				break
 29286			}
 29287			x1 := r1.Args[0]
 29288			if x1.Op != OpS390XMOVHBRloadidx {
 29289				break
 29290			}
 29291			i1 := x1.AuxInt
 29292			s := x1.Aux
 29293			mem := x1.Args[2]
 29294			p := x1.Args[0]
 29295			idx := x1.Args[1]
 29296			r0 := v.Args[1]
 29297			if r0.Op != OpS390XMOVHZreg {
 29298				break
 29299			}
 29300			x0 := r0.Args[0]
 29301			if x0.Op != OpS390XMOVHBRloadidx {
 29302				break
 29303			}
 29304			i0 := x0.AuxInt
 29305			if x0.Aux != s {
 29306				break
 29307			}
 29308			_ = x0.Args[2]
 29309			if idx != x0.Args[0] {
 29310				break
 29311			}
 29312			if p != x0.Args[1] {
 29313				break
 29314			}
 29315			if mem != x0.Args[2] {
 29316				break
 29317			}
 29318			if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
 29319				break
 29320			}
 29321			b = mergePoint(b, x0, x1)
 29322			v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
 29323			v.reset(OpCopy)
 29324			v.AddArg(v0)
 29325			v1 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
 29326			v1.AuxInt = i0
 29327			v1.Aux = s
 29328			v1.AddArg(p)
 29329			v1.AddArg(idx)
 29330			v1.AddArg(mem)
 29331			v0.AddArg(v1)
 29332			return true
 29333		}
 29334		// match: (OR sh:(SLDconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))) r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem)))
 29335		// cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
 29336		// result: @mergePoint(b,x0,x1) (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))
 29337		for {
 29338			_ = v.Args[1]
 29339			sh := v.Args[0]
 29340			if sh.Op != OpS390XSLDconst {
 29341				break
 29342			}
 29343			if sh.AuxInt != 16 {
 29344				break
 29345			}
 29346			r1 := sh.Args[0]
 29347			if r1.Op != OpS390XMOVHZreg {
 29348				break
 29349			}
 29350			x1 := r1.Args[0]
 29351			if x1.Op != OpS390XMOVHBRloadidx {
 29352				break
 29353			}
 29354			i1 := x1.AuxInt
 29355			s := x1.Aux
 29356			mem := x1.Args[2]
 29357			idx := x1.Args[0]
 29358			p := x1.Args[1]
 29359			r0 := v.Args[1]
 29360			if r0.Op != OpS390XMOVHZreg {
 29361				break
 29362			}
 29363			x0 := r0.Args[0]
 29364			if x0.Op != OpS390XMOVHBRloadidx {
 29365				break
 29366			}
 29367			i0 := x0.AuxInt
 29368			if x0.Aux != s {
 29369				break
 29370			}
 29371			_ = x0.Args[2]
 29372			if idx != x0.Args[0] {
 29373				break
 29374			}
 29375			if p != x0.Args[1] {
 29376				break
 29377			}
 29378			if mem != x0.Args[2] {
 29379				break
 29380			}
 29381			if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
 29382				break
 29383			}
 29384			b = mergePoint(b, x0, x1)
 29385			v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
 29386			v.reset(OpCopy)
 29387			v.AddArg(v0)
 29388			v1 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
 29389			v1.AuxInt = i0
 29390			v1.Aux = s
 29391			v1.AddArg(p)
 29392			v1.AddArg(idx)
 29393			v1.AddArg(mem)
 29394			v0.AddArg(v1)
 29395			return true
 29396		}
 29397		// match: (OR r0:(MOVWZreg x0:(MOVWBRloadidx [i0] {s} p idx mem)) sh:(SLDconst [32] r1:(MOVWZreg x1:(MOVWBRloadidx [i1] {s} p idx mem))))
 29398		// cond: i1 == i0+4 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
 29399		// result: @mergePoint(b,x0,x1) (MOVDBRloadidx [i0] {s} p idx mem)
 29400		for {
 29401			_ = v.Args[1]
 29402			r0 := v.Args[0]
 29403			if r0.Op != OpS390XMOVWZreg {
 29404				break
 29405			}
 29406			x0 := r0.Args[0]
 29407			if x0.Op != OpS390XMOVWBRloadidx {
 29408				break
 29409			}
 29410			i0 := x0.AuxInt
 29411			s := x0.Aux
 29412			mem := x0.Args[2]
 29413			p := x0.Args[0]
 29414			idx := x0.Args[1]
 29415			sh := v.Args[1]
 29416			if sh.Op != OpS390XSLDconst {
 29417				break
 29418			}
 29419			if sh.AuxInt != 32 {
 29420				break
 29421			}
 29422			r1 := sh.Args[0]
 29423			if r1.Op != OpS390XMOVWZreg {
 29424				break
 29425			}
 29426			x1 := r1.Args[0]
 29427			if x1.Op != OpS390XMOVWBRloadidx {
 29428				break
 29429			}
 29430			i1 := x1.AuxInt
 29431			if x1.Aux != s {
 29432				break
 29433			}
 29434			_ = x1.Args[2]
 29435			if p != x1.Args[0] {
 29436				break
 29437			}
 29438			if idx != x1.Args[1] {
 29439				break
 29440			}
 29441			if mem != x1.Args[2] {
 29442				break
 29443			}
 29444			if !(i1 == i0+4 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
 29445				break
 29446			}
 29447			b = mergePoint(b, x0, x1)
 29448			v0 := b.NewValue0(v.Pos, OpS390XMOVDBRloadidx, typ.Int64)
 29449			v.reset(OpCopy)
 29450			v.AddArg(v0)
 29451			v0.AuxInt = i0
 29452			v0.Aux = s
 29453			v0.AddArg(p)
 29454			v0.AddArg(idx)
 29455			v0.AddArg(mem)
 29456			return true
 29457		}
 29458		// match: (OR r0:(MOVWZreg x0:(MOVWBRloadidx [i0] {s} idx p mem)) sh:(SLDconst [32] r1:(MOVWZreg x1:(MOVWBRloadidx [i1] {s} p idx mem))))
 29459		// cond: i1 == i0+4 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
 29460		// result: @mergePoint(b,x0,x1) (MOVDBRloadidx [i0] {s} p idx mem)
 29461		for {
 29462			_ = v.Args[1]
 29463			r0 := v.Args[0]
 29464			if r0.Op != OpS390XMOVWZreg {
 29465				break
 29466			}
 29467			x0 := r0.Args[0]
 29468			if x0.Op != OpS390XMOVWBRloadidx {
 29469				break
 29470			}
 29471			i0 := x0.AuxInt
 29472			s := x0.Aux
 29473			mem := x0.Args[2]
 29474			idx := x0.Args[0]
 29475			p := x0.Args[1]
 29476			sh := v.Args[1]
 29477			if sh.Op != OpS390XSLDconst {
 29478				break
 29479			}
 29480			if sh.AuxInt != 32 {
 29481				break
 29482			}
 29483			r1 := sh.Args[0]
 29484			if r1.Op != OpS390XMOVWZreg {
 29485				break
 29486			}
 29487			x1 := r1.Args[0]
 29488			if x1.Op != OpS390XMOVWBRloadidx {
 29489				break
 29490			}
 29491			i1 := x1.AuxInt
 29492			if x1.Aux != s {
 29493				break
 29494			}
 29495			_ = x1.Args[2]
 29496			if p != x1.Args[0] {
 29497				break
 29498			}
 29499			if idx != x1.Args[1] {
 29500				break
 29501			}
 29502			if mem != x1.Args[2] {
 29503				break
 29504			}
 29505			if !(i1 == i0+4 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
 29506				break
 29507			}
 29508			b = mergePoint(b, x0, x1)
 29509			v0 := b.NewValue0(v.Pos, OpS390XMOVDBRloadidx, typ.Int64)
 29510			v.reset(OpCopy)
 29511			v.AddArg(v0)
 29512			v0.AuxInt = i0
 29513			v0.Aux = s
 29514			v0.AddArg(p)
 29515			v0.AddArg(idx)
 29516			v0.AddArg(mem)
 29517			return true
 29518		}
 29519		// match: (OR r0:(MOVWZreg x0:(MOVWBRloadidx [i0] {s} p idx mem)) sh:(SLDconst [32] r1:(MOVWZreg x1:(MOVWBRloadidx [i1] {s} idx p mem))))
 29520		// cond: i1 == i0+4 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
 29521		// result: @mergePoint(b,x0,x1) (MOVDBRloadidx [i0] {s} p idx mem)
 29522		for {
 29523			_ = v.Args[1]
 29524			r0 := v.Args[0]
 29525			if r0.Op != OpS390XMOVWZreg {
 29526				break
 29527			}
 29528			x0 := r0.Args[0]
 29529			if x0.Op != OpS390XMOVWBRloadidx {
 29530				break
 29531			}
 29532			i0 := x0.AuxInt
 29533			s := x0.Aux
 29534			mem := x0.Args[2]
 29535			p := x0.Args[0]
 29536			idx := x0.Args[1]
 29537			sh := v.Args[1]
 29538			if sh.Op != OpS390XSLDconst {
 29539				break
 29540			}
 29541			if sh.AuxInt != 32 {
 29542				break
 29543			}
 29544			r1 := sh.Args[0]
 29545			if r1.Op != OpS390XMOVWZreg {
 29546				break
 29547			}
 29548			x1 := r1.Args[0]
 29549			if x1.Op != OpS390XMOVWBRloadidx {
 29550				break
 29551			}
 29552			i1 := x1.AuxInt
 29553			if x1.Aux != s {
 29554				break
 29555			}
 29556			_ = x1.Args[2]
 29557			if idx != x1.Args[0] {
 29558				break
 29559			}
 29560			if p != x1.Args[1] {
 29561				break
 29562			}
 29563			if mem != x1.Args[2] {
 29564				break
 29565			}
 29566			if !(i1 == i0+4 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
 29567				break
 29568			}
 29569			b = mergePoint(b, x0, x1)
 29570			v0 := b.NewValue0(v.Pos, OpS390XMOVDBRloadidx, typ.Int64)
 29571			v.reset(OpCopy)
 29572			v.AddArg(v0)
 29573			v0.AuxInt = i0
 29574			v0.Aux = s
 29575			v0.AddArg(p)
 29576			v0.AddArg(idx)
 29577			v0.AddArg(mem)
 29578			return true
 29579		}
 29580		return false
 29581	}
 29582	func rewriteValueS390X_OpS390XOR_120(v *Value) bool {
 29583		b := v.Block
 29584		typ := &b.Func.Config.Types
 29585		// match: (OR r0:(MOVWZreg x0:(MOVWBRloadidx [i0] {s} idx p mem)) sh:(SLDconst [32] r1:(MOVWZreg x1:(MOVWBRloadidx [i1] {s} idx p mem))))
 29586		// cond: i1 == i0+4 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
 29587		// result: @mergePoint(b,x0,x1) (MOVDBRloadidx [i0] {s} p idx mem)
 29588		for {
 29589			_ = v.Args[1]
 29590			r0 := v.Args[0]
 29591			if r0.Op != OpS390XMOVWZreg {
 29592				break
 29593			}
 29594			x0 := r0.Args[0]
 29595			if x0.Op != OpS390XMOVWBRloadidx {
 29596				break
 29597			}
 29598			i0 := x0.AuxInt
 29599			s := x0.Aux
 29600			mem := x0.Args[2]
 29601			idx := x0.Args[0]
 29602			p := x0.Args[1]
 29603			sh := v.Args[1]
 29604			if sh.Op != OpS390XSLDconst {
 29605				break
 29606			}
 29607			if sh.AuxInt != 32 {
 29608				break
 29609			}
 29610			r1 := sh.Args[0]
 29611			if r1.Op != OpS390XMOVWZreg {
 29612				break
 29613			}
 29614			x1 := r1.Args[0]
 29615			if x1.Op != OpS390XMOVWBRloadidx {
 29616				break
 29617			}
 29618			i1 := x1.AuxInt
 29619			if x1.Aux != s {
 29620				break
 29621			}
 29622			_ = x1.Args[2]
 29623			if idx != x1.Args[0] {
 29624				break
 29625			}
 29626			if p != x1.Args[1] {
 29627				break
 29628			}
 29629			if mem != x1.Args[2] {
 29630				break
 29631			}
 29632			if !(i1 == i0+4 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
 29633				break
 29634			}
 29635			b = mergePoint(b, x0, x1)
 29636			v0 := b.NewValue0(v.Pos, OpS390XMOVDBRloadidx, typ.Int64)
 29637			v.reset(OpCopy)
 29638			v.AddArg(v0)
 29639			v0.AuxInt = i0
 29640			v0.Aux = s
 29641			v0.AddArg(p)
 29642			v0.AddArg(idx)
 29643			v0.AddArg(mem)
 29644			return true
 29645		}
 29646		// match: (OR sh:(SLDconst [32] r1:(MOVWZreg x1:(MOVWBRloadidx [i1] {s} p idx mem))) r0:(MOVWZreg x0:(MOVWBRloadidx [i0] {s} p idx mem)))
 29647		// cond: i1 == i0+4 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
 29648		// result: @mergePoint(b,x0,x1) (MOVDBRloadidx [i0] {s} p idx mem)
 29649		for {
 29650			_ = v.Args[1]
 29651			sh := v.Args[0]
 29652			if sh.Op != OpS390XSLDconst {
 29653				break
 29654			}
 29655			if sh.AuxInt != 32 {
 29656				break
 29657			}
 29658			r1 := sh.Args[0]
 29659			if r1.Op != OpS390XMOVWZreg {
 29660				break
 29661			}
 29662			x1 := r1.Args[0]
 29663			if x1.Op != OpS390XMOVWBRloadidx {
 29664				break
 29665			}
 29666			i1 := x1.AuxInt
 29667			s := x1.Aux
 29668			mem := x1.Args[2]
 29669			p := x1.Args[0]
 29670			idx := x1.Args[1]
 29671			r0 := v.Args[1]
 29672			if r0.Op != OpS390XMOVWZreg {
 29673				break
 29674			}
 29675			x0 := r0.Args[0]
 29676			if x0.Op != OpS390XMOVWBRloadidx {
 29677				break
 29678			}
 29679			i0 := x0.AuxInt
 29680			if x0.Aux != s {
 29681				break
 29682			}
 29683			_ = x0.Args[2]
 29684			if p != x0.Args[0] {
 29685				break
 29686			}
 29687			if idx != x0.Args[1] {
 29688				break
 29689			}
 29690			if mem != x0.Args[2] {
 29691				break
 29692			}
 29693			if !(i1 == i0+4 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
 29694				break
 29695			}
 29696			b = mergePoint(b, x0, x1)
 29697			v0 := b.NewValue0(v.Pos, OpS390XMOVDBRloadidx, typ.Int64)
 29698			v.reset(OpCopy)
 29699			v.AddArg(v0)
 29700			v0.AuxInt = i0
 29701			v0.Aux = s
 29702			v0.AddArg(p)
 29703			v0.AddArg(idx)
 29704			v0.AddArg(mem)
 29705			return true
 29706		}
 29707		// match: (OR sh:(SLDconst [32] r1:(MOVWZreg x1:(MOVWBRloadidx [i1] {s} idx p mem))) r0:(MOVWZreg x0:(MOVWBRloadidx [i0] {s} p idx mem)))
 29708		// cond: i1 == i0+4 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
 29709		// result: @mergePoint(b,x0,x1) (MOVDBRloadidx [i0] {s} p idx mem)
 29710		for {
 29711			_ = v.Args[1]
 29712			sh := v.Args[0]
 29713			if sh.Op != OpS390XSLDconst {
 29714				break
 29715			}
 29716			if sh.AuxInt != 32 {
 29717				break
 29718			}
 29719			r1 := sh.Args[0]
 29720			if r1.Op != OpS390XMOVWZreg {
 29721				break
 29722			}
 29723			x1 := r1.Args[0]
 29724			if x1.Op != OpS390XMOVWBRloadidx {
 29725				break
 29726			}
 29727			i1 := x1.AuxInt
 29728			s := x1.Aux
 29729			mem := x1.Args[2]
 29730			idx := x1.Args[0]
 29731			p := x1.Args[1]
 29732			r0 := v.Args[1]
 29733			if r0.Op != OpS390XMOVWZreg {
 29734				break
 29735			}
 29736			x0 := r0.Args[0]
 29737			if x0.Op != OpS390XMOVWBRloadidx {
 29738				break
 29739			}
 29740			i0 := x0.AuxInt
 29741			if x0.Aux != s {
 29742				break
 29743			}
 29744			_ = x0.Args[2]
 29745			if p != x0.Args[0] {
 29746				break
 29747			}
 29748			if idx != x0.Args[1] {
 29749				break
 29750			}
 29751			if mem != x0.Args[2] {
 29752				break
 29753			}
 29754			if !(i1 == i0+4 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
 29755				break
 29756			}
 29757			b = mergePoint(b, x0, x1)
 29758			v0 := b.NewValue0(v.Pos, OpS390XMOVDBRloadidx, typ.Int64)
 29759			v.reset(OpCopy)
 29760			v.AddArg(v0)
 29761			v0.AuxInt = i0
 29762			v0.Aux = s
 29763			v0.AddArg(p)
 29764			v0.AddArg(idx)
 29765			v0.AddArg(mem)
 29766			return true
 29767		}
 29768		// match: (OR sh:(SLDconst [32] r1:(MOVWZreg x1:(MOVWBRloadidx [i1] {s} p idx mem))) r0:(MOVWZreg x0:(MOVWBRloadidx [i0] {s} idx p mem)))
 29769		// cond: i1 == i0+4 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
 29770		// result: @mergePoint(b,x0,x1) (MOVDBRloadidx [i0] {s} p idx mem)
 29771		for {
 29772			_ = v.Args[1]
 29773			sh := v.Args[0]
 29774			if sh.Op != OpS390XSLDconst {
 29775				break
 29776			}
 29777			if sh.AuxInt != 32 {
 29778				break
 29779			}
 29780			r1 := sh.Args[0]
 29781			if r1.Op != OpS390XMOVWZreg {
 29782				break
 29783			}
 29784			x1 := r1.Args[0]
 29785			if x1.Op != OpS390XMOVWBRloadidx {
 29786				break
 29787			}
 29788			i1 := x1.AuxInt
 29789			s := x1.Aux
 29790			mem := x1.Args[2]
 29791			p := x1.Args[0]
 29792			idx := x1.Args[1]
 29793			r0 := v.Args[1]
 29794			if r0.Op != OpS390XMOVWZreg {
 29795				break
 29796			}
 29797			x0 := r0.Args[0]
 29798			if x0.Op != OpS390XMOVWBRloadidx {
 29799				break
 29800			}
 29801			i0 := x0.AuxInt
 29802			if x0.Aux != s {
 29803				break
 29804			}
 29805			_ = x0.Args[2]
 29806			if idx != x0.Args[0] {
 29807				break
 29808			}
 29809			if p != x0.Args[1] {
 29810				break
 29811			}
 29812			if mem != x0.Args[2] {
 29813				break
 29814			}
 29815			if !(i1 == i0+4 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
 29816				break
 29817			}
 29818			b = mergePoint(b, x0, x1)
 29819			v0 := b.NewValue0(v.Pos, OpS390XMOVDBRloadidx, typ.Int64)
 29820			v.reset(OpCopy)
 29821			v.AddArg(v0)
 29822			v0.AuxInt = i0
 29823			v0.Aux = s
 29824			v0.AddArg(p)
 29825			v0.AddArg(idx)
 29826			v0.AddArg(mem)
 29827			return true
 29828		}
 29829		// match: (OR sh:(SLDconst [32] r1:(MOVWZreg x1:(MOVWBRloadidx [i1] {s} idx p mem))) r0:(MOVWZreg x0:(MOVWBRloadidx [i0] {s} idx p mem)))
 29830		// cond: i1 == i0+4 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
 29831		// result: @mergePoint(b,x0,x1) (MOVDBRloadidx [i0] {s} p idx mem)
 29832		for {
 29833			_ = v.Args[1]
 29834			sh := v.Args[0]
 29835			if sh.Op != OpS390XSLDconst {
 29836				break
 29837			}
 29838			if sh.AuxInt != 32 {
 29839				break
 29840			}
 29841			r1 := sh.Args[0]
 29842			if r1.Op != OpS390XMOVWZreg {
 29843				break
 29844			}
 29845			x1 := r1.Args[0]
 29846			if x1.Op != OpS390XMOVWBRloadidx {
 29847				break
 29848			}
 29849			i1 := x1.AuxInt
 29850			s := x1.Aux
 29851			mem := x1.Args[2]
 29852			idx := x1.Args[0]
 29853			p := x1.Args[1]
 29854			r0 := v.Args[1]
 29855			if r0.Op != OpS390XMOVWZreg {
 29856				break
 29857			}
 29858			x0 := r0.Args[0]
 29859			if x0.Op != OpS390XMOVWBRloadidx {
 29860				break
 29861			}
 29862			i0 := x0.AuxInt
 29863			if x0.Aux != s {
 29864				break
 29865			}
 29866			_ = x0.Args[2]
 29867			if idx != x0.Args[0] {
 29868				break
 29869			}
 29870			if p != x0.Args[1] {
 29871				break
 29872			}
 29873			if mem != x0.Args[2] {
 29874				break
 29875			}
 29876			if !(i1 == i0+4 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
 29877				break
 29878			}
 29879			b = mergePoint(b, x0, x1)
 29880			v0 := b.NewValue0(v.Pos, OpS390XMOVDBRloadidx, typ.Int64)
 29881			v.reset(OpCopy)
 29882			v.AddArg(v0)
 29883			v0.AuxInt = i0
 29884			v0.Aux = s
 29885			v0.AddArg(p)
 29886			v0.AddArg(idx)
 29887			v0.AddArg(mem)
 29888			return true
 29889		}
 29890		// match: (OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)) or:(OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) y))
 29891		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 29892		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
 29893		for {
 29894			_ = v.Args[1]
 29895			s1 := v.Args[0]
 29896			if s1.Op != OpS390XSLDconst {
 29897				break
 29898			}
 29899			j1 := s1.AuxInt
 29900			x1 := s1.Args[0]
 29901			if x1.Op != OpS390XMOVBZloadidx {
 29902				break
 29903			}
 29904			i1 := x1.AuxInt
 29905			s := x1.Aux
 29906			mem := x1.Args[2]
 29907			p := x1.Args[0]
 29908			idx := x1.Args[1]
 29909			or := v.Args[1]
 29910			if or.Op != OpS390XOR {
 29911				break
 29912			}
 29913			y := or.Args[1]
 29914			s0 := or.Args[0]
 29915			if s0.Op != OpS390XSLDconst {
 29916				break
 29917			}
 29918			j0 := s0.AuxInt
 29919			x0 := s0.Args[0]
 29920			if x0.Op != OpS390XMOVBZloadidx {
 29921				break
 29922			}
 29923			i0 := x0.AuxInt
 29924			if x0.Aux != s {
 29925				break
 29926			}
 29927			_ = x0.Args[2]
 29928			if p != x0.Args[0] {
 29929				break
 29930			}
 29931			if idx != x0.Args[1] {
 29932				break
 29933			}
 29934			if mem != x0.Args[2] {
 29935				break
 29936			}
 29937			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 29938				break
 29939			}
 29940			b = mergePoint(b, x0, x1, y)
 29941			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 29942			v.reset(OpCopy)
 29943			v.AddArg(v0)
 29944			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 29945			v1.AuxInt = j0
 29946			v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 29947			v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 29948			v3.AuxInt = i0
 29949			v3.Aux = s
 29950			v3.AddArg(p)
 29951			v3.AddArg(idx)
 29952			v3.AddArg(mem)
 29953			v2.AddArg(v3)
 29954			v1.AddArg(v2)
 29955			v0.AddArg(v1)
 29956			v0.AddArg(y)
 29957			return true
 29958		}
 29959		// match: (OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) or:(OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) y))
 29960		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 29961		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
 29962		for {
 29963			_ = v.Args[1]
 29964			s1 := v.Args[0]
 29965			if s1.Op != OpS390XSLDconst {
 29966				break
 29967			}
 29968			j1 := s1.AuxInt
 29969			x1 := s1.Args[0]
 29970			if x1.Op != OpS390XMOVBZloadidx {
 29971				break
 29972			}
 29973			i1 := x1.AuxInt
 29974			s := x1.Aux
 29975			mem := x1.Args[2]
 29976			idx := x1.Args[0]
 29977			p := x1.Args[1]
 29978			or := v.Args[1]
 29979			if or.Op != OpS390XOR {
 29980				break
 29981			}
 29982			y := or.Args[1]
 29983			s0 := or.Args[0]
 29984			if s0.Op != OpS390XSLDconst {
 29985				break
 29986			}
 29987			j0 := s0.AuxInt
 29988			x0 := s0.Args[0]
 29989			if x0.Op != OpS390XMOVBZloadidx {
 29990				break
 29991			}
 29992			i0 := x0.AuxInt
 29993			if x0.Aux != s {
 29994				break
 29995			}
 29996			_ = x0.Args[2]
 29997			if p != x0.Args[0] {
 29998				break
 29999			}
 30000			if idx != x0.Args[1] {
 30001				break
 30002			}
 30003			if mem != x0.Args[2] {
 30004				break
 30005			}
 30006			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 30007				break
 30008			}
 30009			b = mergePoint(b, x0, x1, y)
 30010			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 30011			v.reset(OpCopy)
 30012			v.AddArg(v0)
 30013			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 30014			v1.AuxInt = j0
 30015			v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 30016			v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 30017			v3.AuxInt = i0
 30018			v3.Aux = s
 30019			v3.AddArg(p)
 30020			v3.AddArg(idx)
 30021			v3.AddArg(mem)
 30022			v2.AddArg(v3)
 30023			v1.AddArg(v2)
 30024			v0.AddArg(v1)
 30025			v0.AddArg(y)
 30026			return true
 30027		}
 30028		// match: (OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)) or:(OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) y))
 30029		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 30030		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
 30031		for {
 30032			_ = v.Args[1]
 30033			s1 := v.Args[0]
 30034			if s1.Op != OpS390XSLDconst {
 30035				break
 30036			}
 30037			j1 := s1.AuxInt
 30038			x1 := s1.Args[0]
 30039			if x1.Op != OpS390XMOVBZloadidx {
 30040				break
 30041			}
 30042			i1 := x1.AuxInt
 30043			s := x1.Aux
 30044			mem := x1.Args[2]
 30045			p := x1.Args[0]
 30046			idx := x1.Args[1]
 30047			or := v.Args[1]
 30048			if or.Op != OpS390XOR {
 30049				break
 30050			}
 30051			y := or.Args[1]
 30052			s0 := or.Args[0]
 30053			if s0.Op != OpS390XSLDconst {
 30054				break
 30055			}
 30056			j0 := s0.AuxInt
 30057			x0 := s0.Args[0]
 30058			if x0.Op != OpS390XMOVBZloadidx {
 30059				break
 30060			}
 30061			i0 := x0.AuxInt
 30062			if x0.Aux != s {
 30063				break
 30064			}
 30065			_ = x0.Args[2]
 30066			if idx != x0.Args[0] {
 30067				break
 30068			}
 30069			if p != x0.Args[1] {
 30070				break
 30071			}
 30072			if mem != x0.Args[2] {
 30073				break
 30074			}
 30075			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 30076				break
 30077			}
 30078			b = mergePoint(b, x0, x1, y)
 30079			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 30080			v.reset(OpCopy)
 30081			v.AddArg(v0)
 30082			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 30083			v1.AuxInt = j0
 30084			v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 30085			v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 30086			v3.AuxInt = i0
 30087			v3.Aux = s
 30088			v3.AddArg(p)
 30089			v3.AddArg(idx)
 30090			v3.AddArg(mem)
 30091			v2.AddArg(v3)
 30092			v1.AddArg(v2)
 30093			v0.AddArg(v1)
 30094			v0.AddArg(y)
 30095			return true
 30096		}
 30097		// match: (OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) or:(OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) y))
 30098		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 30099		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
 30100		for {
 30101			_ = v.Args[1]
 30102			s1 := v.Args[0]
 30103			if s1.Op != OpS390XSLDconst {
 30104				break
 30105			}
 30106			j1 := s1.AuxInt
 30107			x1 := s1.Args[0]
 30108			if x1.Op != OpS390XMOVBZloadidx {
 30109				break
 30110			}
 30111			i1 := x1.AuxInt
 30112			s := x1.Aux
 30113			mem := x1.Args[2]
 30114			idx := x1.Args[0]
 30115			p := x1.Args[1]
 30116			or := v.Args[1]
 30117			if or.Op != OpS390XOR {
 30118				break
 30119			}
 30120			y := or.Args[1]
 30121			s0 := or.Args[0]
 30122			if s0.Op != OpS390XSLDconst {
 30123				break
 30124			}
 30125			j0 := s0.AuxInt
 30126			x0 := s0.Args[0]
 30127			if x0.Op != OpS390XMOVBZloadidx {
 30128				break
 30129			}
 30130			i0 := x0.AuxInt
 30131			if x0.Aux != s {
 30132				break
 30133			}
 30134			_ = x0.Args[2]
 30135			if idx != x0.Args[0] {
 30136				break
 30137			}
 30138			if p != x0.Args[1] {
 30139				break
 30140			}
 30141			if mem != x0.Args[2] {
 30142				break
 30143			}
 30144			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 30145				break
 30146			}
 30147			b = mergePoint(b, x0, x1, y)
 30148			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 30149			v.reset(OpCopy)
 30150			v.AddArg(v0)
 30151			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 30152			v1.AuxInt = j0
 30153			v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 30154			v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 30155			v3.AuxInt = i0
 30156			v3.Aux = s
 30157			v3.AddArg(p)
 30158			v3.AddArg(idx)
 30159			v3.AddArg(mem)
 30160			v2.AddArg(v3)
 30161			v1.AddArg(v2)
 30162			v0.AddArg(v1)
 30163			v0.AddArg(y)
 30164			return true
 30165		}
 30166		// match: (OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)) or:(OR y s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem))))
 30167		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 30168		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
 30169		for {
 30170			_ = v.Args[1]
 30171			s1 := v.Args[0]
 30172			if s1.Op != OpS390XSLDconst {
 30173				break
 30174			}
 30175			j1 := s1.AuxInt
 30176			x1 := s1.Args[0]
 30177			if x1.Op != OpS390XMOVBZloadidx {
 30178				break
 30179			}
 30180			i1 := x1.AuxInt
 30181			s := x1.Aux
 30182			mem := x1.Args[2]
 30183			p := x1.Args[0]
 30184			idx := x1.Args[1]
 30185			or := v.Args[1]
 30186			if or.Op != OpS390XOR {
 30187				break
 30188			}
 30189			_ = or.Args[1]
 30190			y := or.Args[0]
 30191			s0 := or.Args[1]
 30192			if s0.Op != OpS390XSLDconst {
 30193				break
 30194			}
 30195			j0 := s0.AuxInt
 30196			x0 := s0.Args[0]
 30197			if x0.Op != OpS390XMOVBZloadidx {
 30198				break
 30199			}
 30200			i0 := x0.AuxInt
 30201			if x0.Aux != s {
 30202				break
 30203			}
 30204			_ = x0.Args[2]
 30205			if p != x0.Args[0] {
 30206				break
 30207			}
 30208			if idx != x0.Args[1] {
 30209				break
 30210			}
 30211			if mem != x0.Args[2] {
 30212				break
 30213			}
 30214			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 30215				break
 30216			}
 30217			b = mergePoint(b, x0, x1, y)
 30218			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 30219			v.reset(OpCopy)
 30220			v.AddArg(v0)
 30221			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 30222			v1.AuxInt = j0
 30223			v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 30224			v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 30225			v3.AuxInt = i0
 30226			v3.Aux = s
 30227			v3.AddArg(p)
 30228			v3.AddArg(idx)
 30229			v3.AddArg(mem)
 30230			v2.AddArg(v3)
 30231			v1.AddArg(v2)
 30232			v0.AddArg(v1)
 30233			v0.AddArg(y)
 30234			return true
 30235		}
 30236		return false
 30237	}
 30238	func rewriteValueS390X_OpS390XOR_130(v *Value) bool {
 30239		b := v.Block
 30240		typ := &b.Func.Config.Types
 30241		// match: (OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) or:(OR y s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem))))
 30242		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 30243		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
 30244		for {
 30245			_ = v.Args[1]
 30246			s1 := v.Args[0]
 30247			if s1.Op != OpS390XSLDconst {
 30248				break
 30249			}
 30250			j1 := s1.AuxInt
 30251			x1 := s1.Args[0]
 30252			if x1.Op != OpS390XMOVBZloadidx {
 30253				break
 30254			}
 30255			i1 := x1.AuxInt
 30256			s := x1.Aux
 30257			mem := x1.Args[2]
 30258			idx := x1.Args[0]
 30259			p := x1.Args[1]
 30260			or := v.Args[1]
 30261			if or.Op != OpS390XOR {
 30262				break
 30263			}
 30264			_ = or.Args[1]
 30265			y := or.Args[0]
 30266			s0 := or.Args[1]
 30267			if s0.Op != OpS390XSLDconst {
 30268				break
 30269			}
 30270			j0 := s0.AuxInt
 30271			x0 := s0.Args[0]
 30272			if x0.Op != OpS390XMOVBZloadidx {
 30273				break
 30274			}
 30275			i0 := x0.AuxInt
 30276			if x0.Aux != s {
 30277				break
 30278			}
 30279			_ = x0.Args[2]
 30280			if p != x0.Args[0] {
 30281				break
 30282			}
 30283			if idx != x0.Args[1] {
 30284				break
 30285			}
 30286			if mem != x0.Args[2] {
 30287				break
 30288			}
 30289			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 30290				break
 30291			}
 30292			b = mergePoint(b, x0, x1, y)
 30293			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 30294			v.reset(OpCopy)
 30295			v.AddArg(v0)
 30296			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 30297			v1.AuxInt = j0
 30298			v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 30299			v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 30300			v3.AuxInt = i0
 30301			v3.Aux = s
 30302			v3.AddArg(p)
 30303			v3.AddArg(idx)
 30304			v3.AddArg(mem)
 30305			v2.AddArg(v3)
 30306			v1.AddArg(v2)
 30307			v0.AddArg(v1)
 30308			v0.AddArg(y)
 30309			return true
 30310		}
 30311		// match: (OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)) or:(OR y s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem))))
 30312		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 30313		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
 30314		for {
 30315			_ = v.Args[1]
 30316			s1 := v.Args[0]
 30317			if s1.Op != OpS390XSLDconst {
 30318				break
 30319			}
 30320			j1 := s1.AuxInt
 30321			x1 := s1.Args[0]
 30322			if x1.Op != OpS390XMOVBZloadidx {
 30323				break
 30324			}
 30325			i1 := x1.AuxInt
 30326			s := x1.Aux
 30327			mem := x1.Args[2]
 30328			p := x1.Args[0]
 30329			idx := x1.Args[1]
 30330			or := v.Args[1]
 30331			if or.Op != OpS390XOR {
 30332				break
 30333			}
 30334			_ = or.Args[1]
 30335			y := or.Args[0]
 30336			s0 := or.Args[1]
 30337			if s0.Op != OpS390XSLDconst {
 30338				break
 30339			}
 30340			j0 := s0.AuxInt
 30341			x0 := s0.Args[0]
 30342			if x0.Op != OpS390XMOVBZloadidx {
 30343				break
 30344			}
 30345			i0 := x0.AuxInt
 30346			if x0.Aux != s {
 30347				break
 30348			}
 30349			_ = x0.Args[2]
 30350			if idx != x0.Args[0] {
 30351				break
 30352			}
 30353			if p != x0.Args[1] {
 30354				break
 30355			}
 30356			if mem != x0.Args[2] {
 30357				break
 30358			}
 30359			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 30360				break
 30361			}
 30362			b = mergePoint(b, x0, x1, y)
 30363			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 30364			v.reset(OpCopy)
 30365			v.AddArg(v0)
 30366			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 30367			v1.AuxInt = j0
 30368			v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 30369			v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 30370			v3.AuxInt = i0
 30371			v3.Aux = s
 30372			v3.AddArg(p)
 30373			v3.AddArg(idx)
 30374			v3.AddArg(mem)
 30375			v2.AddArg(v3)
 30376			v1.AddArg(v2)
 30377			v0.AddArg(v1)
 30378			v0.AddArg(y)
 30379			return true
 30380		}
 30381		// match: (OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) or:(OR y s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem))))
 30382		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 30383		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
 30384		for {
 30385			_ = v.Args[1]
 30386			s1 := v.Args[0]
 30387			if s1.Op != OpS390XSLDconst {
 30388				break
 30389			}
 30390			j1 := s1.AuxInt
 30391			x1 := s1.Args[0]
 30392			if x1.Op != OpS390XMOVBZloadidx {
 30393				break
 30394			}
 30395			i1 := x1.AuxInt
 30396			s := x1.Aux
 30397			mem := x1.Args[2]
 30398			idx := x1.Args[0]
 30399			p := x1.Args[1]
 30400			or := v.Args[1]
 30401			if or.Op != OpS390XOR {
 30402				break
 30403			}
 30404			_ = or.Args[1]
 30405			y := or.Args[0]
 30406			s0 := or.Args[1]
 30407			if s0.Op != OpS390XSLDconst {
 30408				break
 30409			}
 30410			j0 := s0.AuxInt
 30411			x0 := s0.Args[0]
 30412			if x0.Op != OpS390XMOVBZloadidx {
 30413				break
 30414			}
 30415			i0 := x0.AuxInt
 30416			if x0.Aux != s {
 30417				break
 30418			}
 30419			_ = x0.Args[2]
 30420			if idx != x0.Args[0] {
 30421				break
 30422			}
 30423			if p != x0.Args[1] {
 30424				break
 30425			}
 30426			if mem != x0.Args[2] {
 30427				break
 30428			}
 30429			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 30430				break
 30431			}
 30432			b = mergePoint(b, x0, x1, y)
 30433			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 30434			v.reset(OpCopy)
 30435			v.AddArg(v0)
 30436			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 30437			v1.AuxInt = j0
 30438			v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 30439			v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 30440			v3.AuxInt = i0
 30441			v3.Aux = s
 30442			v3.AddArg(p)
 30443			v3.AddArg(idx)
 30444			v3.AddArg(mem)
 30445			v2.AddArg(v3)
 30446			v1.AddArg(v2)
 30447			v0.AddArg(v1)
 30448			v0.AddArg(y)
 30449			return true
 30450		}
 30451		// match: (OR or:(OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) y) s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)))
 30452		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 30453		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
 30454		for {
 30455			_ = v.Args[1]
 30456			or := v.Args[0]
 30457			if or.Op != OpS390XOR {
 30458				break
 30459			}
 30460			y := or.Args[1]
 30461			s0 := or.Args[0]
 30462			if s0.Op != OpS390XSLDconst {
 30463				break
 30464			}
 30465			j0 := s0.AuxInt
 30466			x0 := s0.Args[0]
 30467			if x0.Op != OpS390XMOVBZloadidx {
 30468				break
 30469			}
 30470			i0 := x0.AuxInt
 30471			s := x0.Aux
 30472			mem := x0.Args[2]
 30473			p := x0.Args[0]
 30474			idx := x0.Args[1]
 30475			s1 := v.Args[1]
 30476			if s1.Op != OpS390XSLDconst {
 30477				break
 30478			}
 30479			j1 := s1.AuxInt
 30480			x1 := s1.Args[0]
 30481			if x1.Op != OpS390XMOVBZloadidx {
 30482				break
 30483			}
 30484			i1 := x1.AuxInt
 30485			if x1.Aux != s {
 30486				break
 30487			}
 30488			_ = x1.Args[2]
 30489			if p != x1.Args[0] {
 30490				break
 30491			}
 30492			if idx != x1.Args[1] {
 30493				break
 30494			}
 30495			if mem != x1.Args[2] {
 30496				break
 30497			}
 30498			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 30499				break
 30500			}
 30501			b = mergePoint(b, x0, x1, y)
 30502			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 30503			v.reset(OpCopy)
 30504			v.AddArg(v0)
 30505			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 30506			v1.AuxInt = j0
 30507			v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 30508			v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 30509			v3.AuxInt = i0
 30510			v3.Aux = s
 30511			v3.AddArg(p)
 30512			v3.AddArg(idx)
 30513			v3.AddArg(mem)
 30514			v2.AddArg(v3)
 30515			v1.AddArg(v2)
 30516			v0.AddArg(v1)
 30517			v0.AddArg(y)
 30518			return true
 30519		}
 30520		// match: (OR or:(OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) y) s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)))
 30521		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 30522		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
 30523		for {
 30524			_ = v.Args[1]
 30525			or := v.Args[0]
 30526			if or.Op != OpS390XOR {
 30527				break
 30528			}
 30529			y := or.Args[1]
 30530			s0 := or.Args[0]
 30531			if s0.Op != OpS390XSLDconst {
 30532				break
 30533			}
 30534			j0 := s0.AuxInt
 30535			x0 := s0.Args[0]
 30536			if x0.Op != OpS390XMOVBZloadidx {
 30537				break
 30538			}
 30539			i0 := x0.AuxInt
 30540			s := x0.Aux
 30541			mem := x0.Args[2]
 30542			idx := x0.Args[0]
 30543			p := x0.Args[1]
 30544			s1 := v.Args[1]
 30545			if s1.Op != OpS390XSLDconst {
 30546				break
 30547			}
 30548			j1 := s1.AuxInt
 30549			x1 := s1.Args[0]
 30550			if x1.Op != OpS390XMOVBZloadidx {
 30551				break
 30552			}
 30553			i1 := x1.AuxInt
 30554			if x1.Aux != s {
 30555				break
 30556			}
 30557			_ = x1.Args[2]
 30558			if p != x1.Args[0] {
 30559				break
 30560			}
 30561			if idx != x1.Args[1] {
 30562				break
 30563			}
 30564			if mem != x1.Args[2] {
 30565				break
 30566			}
 30567			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 30568				break
 30569			}
 30570			b = mergePoint(b, x0, x1, y)
 30571			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 30572			v.reset(OpCopy)
 30573			v.AddArg(v0)
 30574			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 30575			v1.AuxInt = j0
 30576			v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 30577			v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 30578			v3.AuxInt = i0
 30579			v3.Aux = s
 30580			v3.AddArg(p)
 30581			v3.AddArg(idx)
 30582			v3.AddArg(mem)
 30583			v2.AddArg(v3)
 30584			v1.AddArg(v2)
 30585			v0.AddArg(v1)
 30586			v0.AddArg(y)
 30587			return true
 30588		}
 30589		// match: (OR or:(OR y s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem))) s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)))
 30590		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 30591		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
 30592		for {
 30593			_ = v.Args[1]
 30594			or := v.Args[0]
 30595			if or.Op != OpS390XOR {
 30596				break
 30597			}
 30598			_ = or.Args[1]
 30599			y := or.Args[0]
 30600			s0 := or.Args[1]
 30601			if s0.Op != OpS390XSLDconst {
 30602				break
 30603			}
 30604			j0 := s0.AuxInt
 30605			x0 := s0.Args[0]
 30606			if x0.Op != OpS390XMOVBZloadidx {
 30607				break
 30608			}
 30609			i0 := x0.AuxInt
 30610			s := x0.Aux
 30611			mem := x0.Args[2]
 30612			p := x0.Args[0]
 30613			idx := x0.Args[1]
 30614			s1 := v.Args[1]
 30615			if s1.Op != OpS390XSLDconst {
 30616				break
 30617			}
 30618			j1 := s1.AuxInt
 30619			x1 := s1.Args[0]
 30620			if x1.Op != OpS390XMOVBZloadidx {
 30621				break
 30622			}
 30623			i1 := x1.AuxInt
 30624			if x1.Aux != s {
 30625				break
 30626			}
 30627			_ = x1.Args[2]
 30628			if p != x1.Args[0] {
 30629				break
 30630			}
 30631			if idx != x1.Args[1] {
 30632				break
 30633			}
 30634			if mem != x1.Args[2] {
 30635				break
 30636			}
 30637			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 30638				break
 30639			}
 30640			b = mergePoint(b, x0, x1, y)
 30641			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 30642			v.reset(OpCopy)
 30643			v.AddArg(v0)
 30644			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 30645			v1.AuxInt = j0
 30646			v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 30647			v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 30648			v3.AuxInt = i0
 30649			v3.Aux = s
 30650			v3.AddArg(p)
 30651			v3.AddArg(idx)
 30652			v3.AddArg(mem)
 30653			v2.AddArg(v3)
 30654			v1.AddArg(v2)
 30655			v0.AddArg(v1)
 30656			v0.AddArg(y)
 30657			return true
 30658		}
 30659		// match: (OR or:(OR y s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem))) s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)))
 30660		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 30661		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
 30662		for {
 30663			_ = v.Args[1]
 30664			or := v.Args[0]
 30665			if or.Op != OpS390XOR {
 30666				break
 30667			}
 30668			_ = or.Args[1]
 30669			y := or.Args[0]
 30670			s0 := or.Args[1]
 30671			if s0.Op != OpS390XSLDconst {
 30672				break
 30673			}
 30674			j0 := s0.AuxInt
 30675			x0 := s0.Args[0]
 30676			if x0.Op != OpS390XMOVBZloadidx {
 30677				break
 30678			}
 30679			i0 := x0.AuxInt
 30680			s := x0.Aux
 30681			mem := x0.Args[2]
 30682			idx := x0.Args[0]
 30683			p := x0.Args[1]
 30684			s1 := v.Args[1]
 30685			if s1.Op != OpS390XSLDconst {
 30686				break
 30687			}
 30688			j1 := s1.AuxInt
 30689			x1 := s1.Args[0]
 30690			if x1.Op != OpS390XMOVBZloadidx {
 30691				break
 30692			}
 30693			i1 := x1.AuxInt
 30694			if x1.Aux != s {
 30695				break
 30696			}
 30697			_ = x1.Args[2]
 30698			if p != x1.Args[0] {
 30699				break
 30700			}
 30701			if idx != x1.Args[1] {
 30702				break
 30703			}
 30704			if mem != x1.Args[2] {
 30705				break
 30706			}
 30707			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 30708				break
 30709			}
 30710			b = mergePoint(b, x0, x1, y)
 30711			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 30712			v.reset(OpCopy)
 30713			v.AddArg(v0)
 30714			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 30715			v1.AuxInt = j0
 30716			v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 30717			v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 30718			v3.AuxInt = i0
 30719			v3.Aux = s
 30720			v3.AddArg(p)
 30721			v3.AddArg(idx)
 30722			v3.AddArg(mem)
 30723			v2.AddArg(v3)
 30724			v1.AddArg(v2)
 30725			v0.AddArg(v1)
 30726			v0.AddArg(y)
 30727			return true
 30728		}
 30729		// match: (OR or:(OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) y) s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)))
 30730		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 30731		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
 30732		for {
 30733			_ = v.Args[1]
 30734			or := v.Args[0]
 30735			if or.Op != OpS390XOR {
 30736				break
 30737			}
 30738			y := or.Args[1]
 30739			s0 := or.Args[0]
 30740			if s0.Op != OpS390XSLDconst {
 30741				break
 30742			}
 30743			j0 := s0.AuxInt
 30744			x0 := s0.Args[0]
 30745			if x0.Op != OpS390XMOVBZloadidx {
 30746				break
 30747			}
 30748			i0 := x0.AuxInt
 30749			s := x0.Aux
 30750			mem := x0.Args[2]
 30751			p := x0.Args[0]
 30752			idx := x0.Args[1]
 30753			s1 := v.Args[1]
 30754			if s1.Op != OpS390XSLDconst {
 30755				break
 30756			}
 30757			j1 := s1.AuxInt
 30758			x1 := s1.Args[0]
 30759			if x1.Op != OpS390XMOVBZloadidx {
 30760				break
 30761			}
 30762			i1 := x1.AuxInt
 30763			if x1.Aux != s {
 30764				break
 30765			}
 30766			_ = x1.Args[2]
 30767			if idx != x1.Args[0] {
 30768				break
 30769			}
 30770			if p != x1.Args[1] {
 30771				break
 30772			}
 30773			if mem != x1.Args[2] {
 30774				break
 30775			}
 30776			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 30777				break
 30778			}
 30779			b = mergePoint(b, x0, x1, y)
 30780			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 30781			v.reset(OpCopy)
 30782			v.AddArg(v0)
 30783			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 30784			v1.AuxInt = j0
 30785			v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 30786			v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 30787			v3.AuxInt = i0
 30788			v3.Aux = s
 30789			v3.AddArg(p)
 30790			v3.AddArg(idx)
 30791			v3.AddArg(mem)
 30792			v2.AddArg(v3)
 30793			v1.AddArg(v2)
 30794			v0.AddArg(v1)
 30795			v0.AddArg(y)
 30796			return true
 30797		}
 30798		// match: (OR or:(OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) y) s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)))
 30799		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 30800		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
 30801		for {
 30802			_ = v.Args[1]
 30803			or := v.Args[0]
 30804			if or.Op != OpS390XOR {
 30805				break
 30806			}
 30807			y := or.Args[1]
 30808			s0 := or.Args[0]
 30809			if s0.Op != OpS390XSLDconst {
 30810				break
 30811			}
 30812			j0 := s0.AuxInt
 30813			x0 := s0.Args[0]
 30814			if x0.Op != OpS390XMOVBZloadidx {
 30815				break
 30816			}
 30817			i0 := x0.AuxInt
 30818			s := x0.Aux
 30819			mem := x0.Args[2]
 30820			idx := x0.Args[0]
 30821			p := x0.Args[1]
 30822			s1 := v.Args[1]
 30823			if s1.Op != OpS390XSLDconst {
 30824				break
 30825			}
 30826			j1 := s1.AuxInt
 30827			x1 := s1.Args[0]
 30828			if x1.Op != OpS390XMOVBZloadidx {
 30829				break
 30830			}
 30831			i1 := x1.AuxInt
 30832			if x1.Aux != s {
 30833				break
 30834			}
 30835			_ = x1.Args[2]
 30836			if idx != x1.Args[0] {
 30837				break
 30838			}
 30839			if p != x1.Args[1] {
 30840				break
 30841			}
 30842			if mem != x1.Args[2] {
 30843				break
 30844			}
 30845			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 30846				break
 30847			}
 30848			b = mergePoint(b, x0, x1, y)
 30849			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 30850			v.reset(OpCopy)
 30851			v.AddArg(v0)
 30852			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 30853			v1.AuxInt = j0
 30854			v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 30855			v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 30856			v3.AuxInt = i0
 30857			v3.Aux = s
 30858			v3.AddArg(p)
 30859			v3.AddArg(idx)
 30860			v3.AddArg(mem)
 30861			v2.AddArg(v3)
 30862			v1.AddArg(v2)
 30863			v0.AddArg(v1)
 30864			v0.AddArg(y)
 30865			return true
 30866		}
 30867		// match: (OR or:(OR y s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem))) s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)))
 30868		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 30869		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
 30870		for {
 30871			_ = v.Args[1]
 30872			or := v.Args[0]
 30873			if or.Op != OpS390XOR {
 30874				break
 30875			}
 30876			_ = or.Args[1]
 30877			y := or.Args[0]
 30878			s0 := or.Args[1]
 30879			if s0.Op != OpS390XSLDconst {
 30880				break
 30881			}
 30882			j0 := s0.AuxInt
 30883			x0 := s0.Args[0]
 30884			if x0.Op != OpS390XMOVBZloadidx {
 30885				break
 30886			}
 30887			i0 := x0.AuxInt
 30888			s := x0.Aux
 30889			mem := x0.Args[2]
 30890			p := x0.Args[0]
 30891			idx := x0.Args[1]
 30892			s1 := v.Args[1]
 30893			if s1.Op != OpS390XSLDconst {
 30894				break
 30895			}
 30896			j1 := s1.AuxInt
 30897			x1 := s1.Args[0]
 30898			if x1.Op != OpS390XMOVBZloadidx {
 30899				break
 30900			}
 30901			i1 := x1.AuxInt
 30902			if x1.Aux != s {
 30903				break
 30904			}
 30905			_ = x1.Args[2]
 30906			if idx != x1.Args[0] {
 30907				break
 30908			}
 30909			if p != x1.Args[1] {
 30910				break
 30911			}
 30912			if mem != x1.Args[2] {
 30913				break
 30914			}
 30915			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 30916				break
 30917			}
 30918			b = mergePoint(b, x0, x1, y)
 30919			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 30920			v.reset(OpCopy)
 30921			v.AddArg(v0)
 30922			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 30923			v1.AuxInt = j0
 30924			v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 30925			v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 30926			v3.AuxInt = i0
 30927			v3.Aux = s
 30928			v3.AddArg(p)
 30929			v3.AddArg(idx)
 30930			v3.AddArg(mem)
 30931			v2.AddArg(v3)
 30932			v1.AddArg(v2)
 30933			v0.AddArg(v1)
 30934			v0.AddArg(y)
 30935			return true
 30936		}
 30937		return false
 30938	}
 30939	func rewriteValueS390X_OpS390XOR_140(v *Value) bool {
 30940		b := v.Block
 30941		typ := &b.Func.Config.Types
 30942		// match: (OR or:(OR y s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem))) s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)))
 30943		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 30944		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
 30945		for {
 30946			_ = v.Args[1]
 30947			or := v.Args[0]
 30948			if or.Op != OpS390XOR {
 30949				break
 30950			}
 30951			_ = or.Args[1]
 30952			y := or.Args[0]
 30953			s0 := or.Args[1]
 30954			if s0.Op != OpS390XSLDconst {
 30955				break
 30956			}
 30957			j0 := s0.AuxInt
 30958			x0 := s0.Args[0]
 30959			if x0.Op != OpS390XMOVBZloadidx {
 30960				break
 30961			}
 30962			i0 := x0.AuxInt
 30963			s := x0.Aux
 30964			mem := x0.Args[2]
 30965			idx := x0.Args[0]
 30966			p := x0.Args[1]
 30967			s1 := v.Args[1]
 30968			if s1.Op != OpS390XSLDconst {
 30969				break
 30970			}
 30971			j1 := s1.AuxInt
 30972			x1 := s1.Args[0]
 30973			if x1.Op != OpS390XMOVBZloadidx {
 30974				break
 30975			}
 30976			i1 := x1.AuxInt
 30977			if x1.Aux != s {
 30978				break
 30979			}
 30980			_ = x1.Args[2]
 30981			if idx != x1.Args[0] {
 30982				break
 30983			}
 30984			if p != x1.Args[1] {
 30985				break
 30986			}
 30987			if mem != x1.Args[2] {
 30988				break
 30989			}
 30990			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 30991				break
 30992			}
 30993			b = mergePoint(b, x0, x1, y)
 30994			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 30995			v.reset(OpCopy)
 30996			v.AddArg(v0)
 30997			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 30998			v1.AuxInt = j0
 30999			v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 31000			v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 31001			v3.AuxInt = i0
 31002			v3.Aux = s
 31003			v3.AddArg(p)
 31004			v3.AddArg(idx)
 31005			v3.AddArg(mem)
 31006			v2.AddArg(v3)
 31007			v1.AddArg(v2)
 31008			v0.AddArg(v1)
 31009			v0.AddArg(y)
 31010			return true
 31011		}
 31012		// match: (OR s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem))) or:(OR s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} p idx mem))) y))
 31013		// cond: i1 == i0+2 && j1 == j0+16 && j0 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)
 31014		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
 31015		for {
 31016			_ = v.Args[1]
 31017			s1 := v.Args[0]
 31018			if s1.Op != OpS390XSLDconst {
 31019				break
 31020			}
 31021			j1 := s1.AuxInt
 31022			r1 := s1.Args[0]
 31023			if r1.Op != OpS390XMOVHZreg {
 31024				break
 31025			}
 31026			x1 := r1.Args[0]
 31027			if x1.Op != OpS390XMOVHBRloadidx {
 31028				break
 31029			}
 31030			i1 := x1.AuxInt
 31031			s := x1.Aux
 31032			mem := x1.Args[2]
 31033			p := x1.Args[0]
 31034			idx := x1.Args[1]
 31035			or := v.Args[1]
 31036			if or.Op != OpS390XOR {
 31037				break
 31038			}
 31039			y := or.Args[1]
 31040			s0 := or.Args[0]
 31041			if s0.Op != OpS390XSLDconst {
 31042				break
 31043			}
 31044			j0 := s0.AuxInt
 31045			r0 := s0.Args[0]
 31046			if r0.Op != OpS390XMOVHZreg {
 31047				break
 31048			}
 31049			x0 := r0.Args[0]
 31050			if x0.Op != OpS390XMOVHBRloadidx {
 31051				break
 31052			}
 31053			i0 := x0.AuxInt
 31054			if x0.Aux != s {
 31055				break
 31056			}
 31057			_ = x0.Args[2]
 31058			if p != x0.Args[0] {
 31059				break
 31060			}
 31061			if idx != x0.Args[1] {
 31062				break
 31063			}
 31064			if mem != x0.Args[2] {
 31065				break
 31066			}
 31067			if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
 31068				break
 31069			}
 31070			b = mergePoint(b, x0, x1, y)
 31071			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 31072			v.reset(OpCopy)
 31073			v.AddArg(v0)
 31074			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 31075			v1.AuxInt = j0
 31076			v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
 31077			v3 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
 31078			v3.AuxInt = i0
 31079			v3.Aux = s
 31080			v3.AddArg(p)
 31081			v3.AddArg(idx)
 31082			v3.AddArg(mem)
 31083			v2.AddArg(v3)
 31084			v1.AddArg(v2)
 31085			v0.AddArg(v1)
 31086			v0.AddArg(y)
 31087			return true
 31088		}
 31089		// match: (OR s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))) or:(OR s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} p idx mem))) y))
 31090		// cond: i1 == i0+2 && j1 == j0+16 && j0 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)
 31091		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
 31092		for {
 31093			_ = v.Args[1]
 31094			s1 := v.Args[0]
 31095			if s1.Op != OpS390XSLDconst {
 31096				break
 31097			}
 31098			j1 := s1.AuxInt
 31099			r1 := s1.Args[0]
 31100			if r1.Op != OpS390XMOVHZreg {
 31101				break
 31102			}
 31103			x1 := r1.Args[0]
 31104			if x1.Op != OpS390XMOVHBRloadidx {
 31105				break
 31106			}
 31107			i1 := x1.AuxInt
 31108			s := x1.Aux
 31109			mem := x1.Args[2]
 31110			idx := x1.Args[0]
 31111			p := x1.Args[1]
 31112			or := v.Args[1]
 31113			if or.Op != OpS390XOR {
 31114				break
 31115			}
 31116			y := or.Args[1]
 31117			s0 := or.Args[0]
 31118			if s0.Op != OpS390XSLDconst {
 31119				break
 31120			}
 31121			j0 := s0.AuxInt
 31122			r0 := s0.Args[0]
 31123			if r0.Op != OpS390XMOVHZreg {
 31124				break
 31125			}
 31126			x0 := r0.Args[0]
 31127			if x0.Op != OpS390XMOVHBRloadidx {
 31128				break
 31129			}
 31130			i0 := x0.AuxInt
 31131			if x0.Aux != s {
 31132				break
 31133			}
 31134			_ = x0.Args[2]
 31135			if p != x0.Args[0] {
 31136				break
 31137			}
 31138			if idx != x0.Args[1] {
 31139				break
 31140			}
 31141			if mem != x0.Args[2] {
 31142				break
 31143			}
 31144			if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
 31145				break
 31146			}
 31147			b = mergePoint(b, x0, x1, y)
 31148			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 31149			v.reset(OpCopy)
 31150			v.AddArg(v0)
 31151			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 31152			v1.AuxInt = j0
 31153			v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
 31154			v3 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
 31155			v3.AuxInt = i0
 31156			v3.Aux = s
 31157			v3.AddArg(p)
 31158			v3.AddArg(idx)
 31159			v3.AddArg(mem)
 31160			v2.AddArg(v3)
 31161			v1.AddArg(v2)
 31162			v0.AddArg(v1)
 31163			v0.AddArg(y)
 31164			return true
 31165		}
 31166		// match: (OR s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem))) or:(OR s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem))) y))
 31167		// cond: i1 == i0+2 && j1 == j0+16 && j0 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)
 31168		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
 31169		for {
 31170			_ = v.Args[1]
 31171			s1 := v.Args[0]
 31172			if s1.Op != OpS390XSLDconst {
 31173				break
 31174			}
 31175			j1 := s1.AuxInt
 31176			r1 := s1.Args[0]
 31177			if r1.Op != OpS390XMOVHZreg {
 31178				break
 31179			}
 31180			x1 := r1.Args[0]
 31181			if x1.Op != OpS390XMOVHBRloadidx {
 31182				break
 31183			}
 31184			i1 := x1.AuxInt
 31185			s := x1.Aux
 31186			mem := x1.Args[2]
 31187			p := x1.Args[0]
 31188			idx := x1.Args[1]
 31189			or := v.Args[1]
 31190			if or.Op != OpS390XOR {
 31191				break
 31192			}
 31193			y := or.Args[1]
 31194			s0 := or.Args[0]
 31195			if s0.Op != OpS390XSLDconst {
 31196				break
 31197			}
 31198			j0 := s0.AuxInt
 31199			r0 := s0.Args[0]
 31200			if r0.Op != OpS390XMOVHZreg {
 31201				break
 31202			}
 31203			x0 := r0.Args[0]
 31204			if x0.Op != OpS390XMOVHBRloadidx {
 31205				break
 31206			}
 31207			i0 := x0.AuxInt
 31208			if x0.Aux != s {
 31209				break
 31210			}
 31211			_ = x0.Args[2]
 31212			if idx != x0.Args[0] {
 31213				break
 31214			}
 31215			if p != x0.Args[1] {
 31216				break
 31217			}
 31218			if mem != x0.Args[2] {
 31219				break
 31220			}
 31221			if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
 31222				break
 31223			}
 31224			b = mergePoint(b, x0, x1, y)
 31225			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 31226			v.reset(OpCopy)
 31227			v.AddArg(v0)
 31228			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 31229			v1.AuxInt = j0
 31230			v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
 31231			v3 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
 31232			v3.AuxInt = i0
 31233			v3.Aux = s
 31234			v3.AddArg(p)
 31235			v3.AddArg(idx)
 31236			v3.AddArg(mem)
 31237			v2.AddArg(v3)
 31238			v1.AddArg(v2)
 31239			v0.AddArg(v1)
 31240			v0.AddArg(y)
 31241			return true
 31242		}
 31243		// match: (OR s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))) or:(OR s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem))) y))
 31244		// cond: i1 == i0+2 && j1 == j0+16 && j0 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)
 31245		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
 31246		for {
 31247			_ = v.Args[1]
 31248			s1 := v.Args[0]
 31249			if s1.Op != OpS390XSLDconst {
 31250				break
 31251			}
 31252			j1 := s1.AuxInt
 31253			r1 := s1.Args[0]
 31254			if r1.Op != OpS390XMOVHZreg {
 31255				break
 31256			}
 31257			x1 := r1.Args[0]
 31258			if x1.Op != OpS390XMOVHBRloadidx {
 31259				break
 31260			}
 31261			i1 := x1.AuxInt
 31262			s := x1.Aux
 31263			mem := x1.Args[2]
 31264			idx := x1.Args[0]
 31265			p := x1.Args[1]
 31266			or := v.Args[1]
 31267			if or.Op != OpS390XOR {
 31268				break
 31269			}
 31270			y := or.Args[1]
 31271			s0 := or.Args[0]
 31272			if s0.Op != OpS390XSLDconst {
 31273				break
 31274			}
 31275			j0 := s0.AuxInt
 31276			r0 := s0.Args[0]
 31277			if r0.Op != OpS390XMOVHZreg {
 31278				break
 31279			}
 31280			x0 := r0.Args[0]
 31281			if x0.Op != OpS390XMOVHBRloadidx {
 31282				break
 31283			}
 31284			i0 := x0.AuxInt
 31285			if x0.Aux != s {
 31286				break
 31287			}
 31288			_ = x0.Args[2]
 31289			if idx != x0.Args[0] {
 31290				break
 31291			}
 31292			if p != x0.Args[1] {
 31293				break
 31294			}
 31295			if mem != x0.Args[2] {
 31296				break
 31297			}
 31298			if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
 31299				break
 31300			}
 31301			b = mergePoint(b, x0, x1, y)
 31302			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 31303			v.reset(OpCopy)
 31304			v.AddArg(v0)
 31305			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 31306			v1.AuxInt = j0
 31307			v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
 31308			v3 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
 31309			v3.AuxInt = i0
 31310			v3.Aux = s
 31311			v3.AddArg(p)
 31312			v3.AddArg(idx)
 31313			v3.AddArg(mem)
 31314			v2.AddArg(v3)
 31315			v1.AddArg(v2)
 31316			v0.AddArg(v1)
 31317			v0.AddArg(y)
 31318			return true
 31319		}
 31320		// match: (OR s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem))) or:(OR y s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} p idx mem)))))
 31321		// cond: i1 == i0+2 && j1 == j0+16 && j0 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)
 31322		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
 31323		for {
 31324			_ = v.Args[1]
 31325			s1 := v.Args[0]
 31326			if s1.Op != OpS390XSLDconst {
 31327				break
 31328			}
 31329			j1 := s1.AuxInt
 31330			r1 := s1.Args[0]
 31331			if r1.Op != OpS390XMOVHZreg {
 31332				break
 31333			}
 31334			x1 := r1.Args[0]
 31335			if x1.Op != OpS390XMOVHBRloadidx {
 31336				break
 31337			}
 31338			i1 := x1.AuxInt
 31339			s := x1.Aux
 31340			mem := x1.Args[2]
 31341			p := x1.Args[0]
 31342			idx := x1.Args[1]
 31343			or := v.Args[1]
 31344			if or.Op != OpS390XOR {
 31345				break
 31346			}
 31347			_ = or.Args[1]
 31348			y := or.Args[0]
 31349			s0 := or.Args[1]
 31350			if s0.Op != OpS390XSLDconst {
 31351				break
 31352			}
 31353			j0 := s0.AuxInt
 31354			r0 := s0.Args[0]
 31355			if r0.Op != OpS390XMOVHZreg {
 31356				break
 31357			}
 31358			x0 := r0.Args[0]
 31359			if x0.Op != OpS390XMOVHBRloadidx {
 31360				break
 31361			}
 31362			i0 := x0.AuxInt
 31363			if x0.Aux != s {
 31364				break
 31365			}
 31366			_ = x0.Args[2]
 31367			if p != x0.Args[0] {
 31368				break
 31369			}
 31370			if idx != x0.Args[1] {
 31371				break
 31372			}
 31373			if mem != x0.Args[2] {
 31374				break
 31375			}
 31376			if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
 31377				break
 31378			}
 31379			b = mergePoint(b, x0, x1, y)
 31380			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 31381			v.reset(OpCopy)
 31382			v.AddArg(v0)
 31383			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 31384			v1.AuxInt = j0
 31385			v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
 31386			v3 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
 31387			v3.AuxInt = i0
 31388			v3.Aux = s
 31389			v3.AddArg(p)
 31390			v3.AddArg(idx)
 31391			v3.AddArg(mem)
 31392			v2.AddArg(v3)
 31393			v1.AddArg(v2)
 31394			v0.AddArg(v1)
 31395			v0.AddArg(y)
 31396			return true
 31397		}
 31398		// match: (OR s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))) or:(OR y s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} p idx mem)))))
 31399		// cond: i1 == i0+2 && j1 == j0+16 && j0 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)
 31400		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
 31401		for {
 31402			_ = v.Args[1]
 31403			s1 := v.Args[0]
 31404			if s1.Op != OpS390XSLDconst {
 31405				break
 31406			}
 31407			j1 := s1.AuxInt
 31408			r1 := s1.Args[0]
 31409			if r1.Op != OpS390XMOVHZreg {
 31410				break
 31411			}
 31412			x1 := r1.Args[0]
 31413			if x1.Op != OpS390XMOVHBRloadidx {
 31414				break
 31415			}
 31416			i1 := x1.AuxInt
 31417			s := x1.Aux
 31418			mem := x1.Args[2]
 31419			idx := x1.Args[0]
 31420			p := x1.Args[1]
 31421			or := v.Args[1]
 31422			if or.Op != OpS390XOR {
 31423				break
 31424			}
 31425			_ = or.Args[1]
 31426			y := or.Args[0]
 31427			s0 := or.Args[1]
 31428			if s0.Op != OpS390XSLDconst {
 31429				break
 31430			}
 31431			j0 := s0.AuxInt
 31432			r0 := s0.Args[0]
 31433			if r0.Op != OpS390XMOVHZreg {
 31434				break
 31435			}
 31436			x0 := r0.Args[0]
 31437			if x0.Op != OpS390XMOVHBRloadidx {
 31438				break
 31439			}
 31440			i0 := x0.AuxInt
 31441			if x0.Aux != s {
 31442				break
 31443			}
 31444			_ = x0.Args[2]
 31445			if p != x0.Args[0] {
 31446				break
 31447			}
 31448			if idx != x0.Args[1] {
 31449				break
 31450			}
 31451			if mem != x0.Args[2] {
 31452				break
 31453			}
 31454			if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
 31455				break
 31456			}
 31457			b = mergePoint(b, x0, x1, y)
 31458			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 31459			v.reset(OpCopy)
 31460			v.AddArg(v0)
 31461			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 31462			v1.AuxInt = j0
 31463			v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
 31464			v3 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
 31465			v3.AuxInt = i0
 31466			v3.Aux = s
 31467			v3.AddArg(p)
 31468			v3.AddArg(idx)
 31469			v3.AddArg(mem)
 31470			v2.AddArg(v3)
 31471			v1.AddArg(v2)
 31472			v0.AddArg(v1)
 31473			v0.AddArg(y)
 31474			return true
 31475		}
 31476		// match: (OR s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem))) or:(OR y s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem)))))
 31477		// cond: i1 == i0+2 && j1 == j0+16 && j0 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)
 31478		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
 31479		for {
 31480			_ = v.Args[1]
 31481			s1 := v.Args[0]
 31482			if s1.Op != OpS390XSLDconst {
 31483				break
 31484			}
 31485			j1 := s1.AuxInt
 31486			r1 := s1.Args[0]
 31487			if r1.Op != OpS390XMOVHZreg {
 31488				break
 31489			}
 31490			x1 := r1.Args[0]
 31491			if x1.Op != OpS390XMOVHBRloadidx {
 31492				break
 31493			}
 31494			i1 := x1.AuxInt
 31495			s := x1.Aux
 31496			mem := x1.Args[2]
 31497			p := x1.Args[0]
 31498			idx := x1.Args[1]
 31499			or := v.Args[1]
 31500			if or.Op != OpS390XOR {
 31501				break
 31502			}
 31503			_ = or.Args[1]
 31504			y := or.Args[0]
 31505			s0 := or.Args[1]
 31506			if s0.Op != OpS390XSLDconst {
 31507				break
 31508			}
 31509			j0 := s0.AuxInt
 31510			r0 := s0.Args[0]
 31511			if r0.Op != OpS390XMOVHZreg {
 31512				break
 31513			}
 31514			x0 := r0.Args[0]
 31515			if x0.Op != OpS390XMOVHBRloadidx {
 31516				break
 31517			}
 31518			i0 := x0.AuxInt
 31519			if x0.Aux != s {
 31520				break
 31521			}
 31522			_ = x0.Args[2]
 31523			if idx != x0.Args[0] {
 31524				break
 31525			}
 31526			if p != x0.Args[1] {
 31527				break
 31528			}
 31529			if mem != x0.Args[2] {
 31530				break
 31531			}
 31532			if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
 31533				break
 31534			}
 31535			b = mergePoint(b, x0, x1, y)
 31536			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 31537			v.reset(OpCopy)
 31538			v.AddArg(v0)
 31539			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 31540			v1.AuxInt = j0
 31541			v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
 31542			v3 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
 31543			v3.AuxInt = i0
 31544			v3.Aux = s
 31545			v3.AddArg(p)
 31546			v3.AddArg(idx)
 31547			v3.AddArg(mem)
 31548			v2.AddArg(v3)
 31549			v1.AddArg(v2)
 31550			v0.AddArg(v1)
 31551			v0.AddArg(y)
 31552			return true
 31553		}
 31554		// match: (OR s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))) or:(OR y s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem)))))
 31555		// cond: i1 == i0+2 && j1 == j0+16 && j0 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)
 31556		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
 31557		for {
 31558			_ = v.Args[1]
 31559			s1 := v.Args[0]
 31560			if s1.Op != OpS390XSLDconst {
 31561				break
 31562			}
 31563			j1 := s1.AuxInt
 31564			r1 := s1.Args[0]
 31565			if r1.Op != OpS390XMOVHZreg {
 31566				break
 31567			}
 31568			x1 := r1.Args[0]
 31569			if x1.Op != OpS390XMOVHBRloadidx {
 31570				break
 31571			}
 31572			i1 := x1.AuxInt
 31573			s := x1.Aux
 31574			mem := x1.Args[2]
 31575			idx := x1.Args[0]
 31576			p := x1.Args[1]
 31577			or := v.Args[1]
 31578			if or.Op != OpS390XOR {
 31579				break
 31580			}
 31581			_ = or.Args[1]
 31582			y := or.Args[0]
 31583			s0 := or.Args[1]
 31584			if s0.Op != OpS390XSLDconst {
 31585				break
 31586			}
 31587			j0 := s0.AuxInt
 31588			r0 := s0.Args[0]
 31589			if r0.Op != OpS390XMOVHZreg {
 31590				break
 31591			}
 31592			x0 := r0.Args[0]
 31593			if x0.Op != OpS390XMOVHBRloadidx {
 31594				break
 31595			}
 31596			i0 := x0.AuxInt
 31597			if x0.Aux != s {
 31598				break
 31599			}
 31600			_ = x0.Args[2]
 31601			if idx != x0.Args[0] {
 31602				break
 31603			}
 31604			if p != x0.Args[1] {
 31605				break
 31606			}
 31607			if mem != x0.Args[2] {
 31608				break
 31609			}
 31610			if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
 31611				break
 31612			}
 31613			b = mergePoint(b, x0, x1, y)
 31614			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 31615			v.reset(OpCopy)
 31616			v.AddArg(v0)
 31617			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 31618			v1.AuxInt = j0
 31619			v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
 31620			v3 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
 31621			v3.AuxInt = i0
 31622			v3.Aux = s
 31623			v3.AddArg(p)
 31624			v3.AddArg(idx)
 31625			v3.AddArg(mem)
 31626			v2.AddArg(v3)
 31627			v1.AddArg(v2)
 31628			v0.AddArg(v1)
 31629			v0.AddArg(y)
 31630			return true
 31631		}
 31632		// match: (OR or:(OR s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} p idx mem))) y) s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem))))
 31633		// cond: i1 == i0+2 && j1 == j0+16 && j0 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)
 31634		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
 31635		for {
 31636			_ = v.Args[1]
 31637			or := v.Args[0]
 31638			if or.Op != OpS390XOR {
 31639				break
 31640			}
 31641			y := or.Args[1]
 31642			s0 := or.Args[0]
 31643			if s0.Op != OpS390XSLDconst {
 31644				break
 31645			}
 31646			j0 := s0.AuxInt
 31647			r0 := s0.Args[0]
 31648			if r0.Op != OpS390XMOVHZreg {
 31649				break
 31650			}
 31651			x0 := r0.Args[0]
 31652			if x0.Op != OpS390XMOVHBRloadidx {
 31653				break
 31654			}
 31655			i0 := x0.AuxInt
 31656			s := x0.Aux
 31657			mem := x0.Args[2]
 31658			p := x0.Args[0]
 31659			idx := x0.Args[1]
 31660			s1 := v.Args[1]
 31661			if s1.Op != OpS390XSLDconst {
 31662				break
 31663			}
 31664			j1 := s1.AuxInt
 31665			r1 := s1.Args[0]
 31666			if r1.Op != OpS390XMOVHZreg {
 31667				break
 31668			}
 31669			x1 := r1.Args[0]
 31670			if x1.Op != OpS390XMOVHBRloadidx {
 31671				break
 31672			}
 31673			i1 := x1.AuxInt
 31674			if x1.Aux != s {
 31675				break
 31676			}
 31677			_ = x1.Args[2]
 31678			if p != x1.Args[0] {
 31679				break
 31680			}
 31681			if idx != x1.Args[1] {
 31682				break
 31683			}
 31684			if mem != x1.Args[2] {
 31685				break
 31686			}
 31687			if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
 31688				break
 31689			}
 31690			b = mergePoint(b, x0, x1, y)
 31691			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 31692			v.reset(OpCopy)
 31693			v.AddArg(v0)
 31694			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 31695			v1.AuxInt = j0
 31696			v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
 31697			v3 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
 31698			v3.AuxInt = i0
 31699			v3.Aux = s
 31700			v3.AddArg(p)
 31701			v3.AddArg(idx)
 31702			v3.AddArg(mem)
 31703			v2.AddArg(v3)
 31704			v1.AddArg(v2)
 31705			v0.AddArg(v1)
 31706			v0.AddArg(y)
 31707			return true
 31708		}
 31709		return false
 31710	}
 31711	func rewriteValueS390X_OpS390XOR_150(v *Value) bool {
 31712		b := v.Block
 31713		typ := &b.Func.Config.Types
 31714		// match: (OR or:(OR s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem))) y) s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem))))
 31715		// cond: i1 == i0+2 && j1 == j0+16 && j0 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)
 31716		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
 31717		for {
 31718			_ = v.Args[1]
 31719			or := v.Args[0]
 31720			if or.Op != OpS390XOR {
 31721				break
 31722			}
 31723			y := or.Args[1]
 31724			s0 := or.Args[0]
 31725			if s0.Op != OpS390XSLDconst {
 31726				break
 31727			}
 31728			j0 := s0.AuxInt
 31729			r0 := s0.Args[0]
 31730			if r0.Op != OpS390XMOVHZreg {
 31731				break
 31732			}
 31733			x0 := r0.Args[0]
 31734			if x0.Op != OpS390XMOVHBRloadidx {
 31735				break
 31736			}
 31737			i0 := x0.AuxInt
 31738			s := x0.Aux
 31739			mem := x0.Args[2]
 31740			idx := x0.Args[0]
 31741			p := x0.Args[1]
 31742			s1 := v.Args[1]
 31743			if s1.Op != OpS390XSLDconst {
 31744				break
 31745			}
 31746			j1 := s1.AuxInt
 31747			r1 := s1.Args[0]
 31748			if r1.Op != OpS390XMOVHZreg {
 31749				break
 31750			}
 31751			x1 := r1.Args[0]
 31752			if x1.Op != OpS390XMOVHBRloadidx {
 31753				break
 31754			}
 31755			i1 := x1.AuxInt
 31756			if x1.Aux != s {
 31757				break
 31758			}
 31759			_ = x1.Args[2]
 31760			if p != x1.Args[0] {
 31761				break
 31762			}
 31763			if idx != x1.Args[1] {
 31764				break
 31765			}
 31766			if mem != x1.Args[2] {
 31767				break
 31768			}
 31769			if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
 31770				break
 31771			}
 31772			b = mergePoint(b, x0, x1, y)
 31773			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 31774			v.reset(OpCopy)
 31775			v.AddArg(v0)
 31776			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 31777			v1.AuxInt = j0
 31778			v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
 31779			v3 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
 31780			v3.AuxInt = i0
 31781			v3.Aux = s
 31782			v3.AddArg(p)
 31783			v3.AddArg(idx)
 31784			v3.AddArg(mem)
 31785			v2.AddArg(v3)
 31786			v1.AddArg(v2)
 31787			v0.AddArg(v1)
 31788			v0.AddArg(y)
 31789			return true
 31790		}
 31791		// match: (OR or:(OR y s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} p idx mem)))) s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem))))
 31792		// cond: i1 == i0+2 && j1 == j0+16 && j0 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)
 31793		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
 31794		for {
 31795			_ = v.Args[1]
 31796			or := v.Args[0]
 31797			if or.Op != OpS390XOR {
 31798				break
 31799			}
 31800			_ = or.Args[1]
 31801			y := or.Args[0]
 31802			s0 := or.Args[1]
 31803			if s0.Op != OpS390XSLDconst {
 31804				break
 31805			}
 31806			j0 := s0.AuxInt
 31807			r0 := s0.Args[0]
 31808			if r0.Op != OpS390XMOVHZreg {
 31809				break
 31810			}
 31811			x0 := r0.Args[0]
 31812			if x0.Op != OpS390XMOVHBRloadidx {
 31813				break
 31814			}
 31815			i0 := x0.AuxInt
 31816			s := x0.Aux
 31817			mem := x0.Args[2]
 31818			p := x0.Args[0]
 31819			idx := x0.Args[1]
 31820			s1 := v.Args[1]
 31821			if s1.Op != OpS390XSLDconst {
 31822				break
 31823			}
 31824			j1 := s1.AuxInt
 31825			r1 := s1.Args[0]
 31826			if r1.Op != OpS390XMOVHZreg {
 31827				break
 31828			}
 31829			x1 := r1.Args[0]
 31830			if x1.Op != OpS390XMOVHBRloadidx {
 31831				break
 31832			}
 31833			i1 := x1.AuxInt
 31834			if x1.Aux != s {
 31835				break
 31836			}
 31837			_ = x1.Args[2]
 31838			if p != x1.Args[0] {
 31839				break
 31840			}
 31841			if idx != x1.Args[1] {
 31842				break
 31843			}
 31844			if mem != x1.Args[2] {
 31845				break
 31846			}
 31847			if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
 31848				break
 31849			}
 31850			b = mergePoint(b, x0, x1, y)
 31851			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 31852			v.reset(OpCopy)
 31853			v.AddArg(v0)
 31854			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 31855			v1.AuxInt = j0
 31856			v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
 31857			v3 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
 31858			v3.AuxInt = i0
 31859			v3.Aux = s
 31860			v3.AddArg(p)
 31861			v3.AddArg(idx)
 31862			v3.AddArg(mem)
 31863			v2.AddArg(v3)
 31864			v1.AddArg(v2)
 31865			v0.AddArg(v1)
 31866			v0.AddArg(y)
 31867			return true
 31868		}
 31869		// match: (OR or:(OR y s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem)))) s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem))))
 31870		// cond: i1 == i0+2 && j1 == j0+16 && j0 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)
 31871		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
 31872		for {
 31873			_ = v.Args[1]
 31874			or := v.Args[0]
 31875			if or.Op != OpS390XOR {
 31876				break
 31877			}
 31878			_ = or.Args[1]
 31879			y := or.Args[0]
 31880			s0 := or.Args[1]
 31881			if s0.Op != OpS390XSLDconst {
 31882				break
 31883			}
 31884			j0 := s0.AuxInt
 31885			r0 := s0.Args[0]
 31886			if r0.Op != OpS390XMOVHZreg {
 31887				break
 31888			}
 31889			x0 := r0.Args[0]
 31890			if x0.Op != OpS390XMOVHBRloadidx {
 31891				break
 31892			}
 31893			i0 := x0.AuxInt
 31894			s := x0.Aux
 31895			mem := x0.Args[2]
 31896			idx := x0.Args[0]
 31897			p := x0.Args[1]
 31898			s1 := v.Args[1]
 31899			if s1.Op != OpS390XSLDconst {
 31900				break
 31901			}
 31902			j1 := s1.AuxInt
 31903			r1 := s1.Args[0]
 31904			if r1.Op != OpS390XMOVHZreg {
 31905				break
 31906			}
 31907			x1 := r1.Args[0]
 31908			if x1.Op != OpS390XMOVHBRloadidx {
 31909				break
 31910			}
 31911			i1 := x1.AuxInt
 31912			if x1.Aux != s {
 31913				break
 31914			}
 31915			_ = x1.Args[2]
 31916			if p != x1.Args[0] {
 31917				break
 31918			}
 31919			if idx != x1.Args[1] {
 31920				break
 31921			}
 31922			if mem != x1.Args[2] {
 31923				break
 31924			}
 31925			if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
 31926				break
 31927			}
 31928			b = mergePoint(b, x0, x1, y)
 31929			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 31930			v.reset(OpCopy)
 31931			v.AddArg(v0)
 31932			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 31933			v1.AuxInt = j0
 31934			v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
 31935			v3 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
 31936			v3.AuxInt = i0
 31937			v3.Aux = s
 31938			v3.AddArg(p)
 31939			v3.AddArg(idx)
 31940			v3.AddArg(mem)
 31941			v2.AddArg(v3)
 31942			v1.AddArg(v2)
 31943			v0.AddArg(v1)
 31944			v0.AddArg(y)
 31945			return true
 31946		}
 31947		// match: (OR or:(OR s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} p idx mem))) y) s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))))
 31948		// cond: i1 == i0+2 && j1 == j0+16 && j0 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)
 31949		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
 31950		for {
 31951			_ = v.Args[1]
 31952			or := v.Args[0]
 31953			if or.Op != OpS390XOR {
 31954				break
 31955			}
 31956			y := or.Args[1]
 31957			s0 := or.Args[0]
 31958			if s0.Op != OpS390XSLDconst {
 31959				break
 31960			}
 31961			j0 := s0.AuxInt
 31962			r0 := s0.Args[0]
 31963			if r0.Op != OpS390XMOVHZreg {
 31964				break
 31965			}
 31966			x0 := r0.Args[0]
 31967			if x0.Op != OpS390XMOVHBRloadidx {
 31968				break
 31969			}
 31970			i0 := x0.AuxInt
 31971			s := x0.Aux
 31972			mem := x0.Args[2]
 31973			p := x0.Args[0]
 31974			idx := x0.Args[1]
 31975			s1 := v.Args[1]
 31976			if s1.Op != OpS390XSLDconst {
 31977				break
 31978			}
 31979			j1 := s1.AuxInt
 31980			r1 := s1.Args[0]
 31981			if r1.Op != OpS390XMOVHZreg {
 31982				break
 31983			}
 31984			x1 := r1.Args[0]
 31985			if x1.Op != OpS390XMOVHBRloadidx {
 31986				break
 31987			}
 31988			i1 := x1.AuxInt
 31989			if x1.Aux != s {
 31990				break
 31991			}
 31992			_ = x1.Args[2]
 31993			if idx != x1.Args[0] {
 31994				break
 31995			}
 31996			if p != x1.Args[1] {
 31997				break
 31998			}
 31999			if mem != x1.Args[2] {
 32000				break
 32001			}
 32002			if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
 32003				break
 32004			}
 32005			b = mergePoint(b, x0, x1, y)
 32006			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 32007			v.reset(OpCopy)
 32008			v.AddArg(v0)
 32009			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 32010			v1.AuxInt = j0
 32011			v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
 32012			v3 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
 32013			v3.AuxInt = i0
 32014			v3.Aux = s
 32015			v3.AddArg(p)
 32016			v3.AddArg(idx)
 32017			v3.AddArg(mem)
 32018			v2.AddArg(v3)
 32019			v1.AddArg(v2)
 32020			v0.AddArg(v1)
 32021			v0.AddArg(y)
 32022			return true
 32023		}
 32024		// match: (OR or:(OR s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem))) y) s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))))
 32025		// cond: i1 == i0+2 && j1 == j0+16 && j0 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)
 32026		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
 32027		for {
 32028			_ = v.Args[1]
 32029			or := v.Args[0]
 32030			if or.Op != OpS390XOR {
 32031				break
 32032			}
 32033			y := or.Args[1]
 32034			s0 := or.Args[0]
 32035			if s0.Op != OpS390XSLDconst {
 32036				break
 32037			}
 32038			j0 := s0.AuxInt
 32039			r0 := s0.Args[0]
 32040			if r0.Op != OpS390XMOVHZreg {
 32041				break
 32042			}
 32043			x0 := r0.Args[0]
 32044			if x0.Op != OpS390XMOVHBRloadidx {
 32045				break
 32046			}
 32047			i0 := x0.AuxInt
 32048			s := x0.Aux
 32049			mem := x0.Args[2]
 32050			idx := x0.Args[0]
 32051			p := x0.Args[1]
 32052			s1 := v.Args[1]
 32053			if s1.Op != OpS390XSLDconst {
 32054				break
 32055			}
 32056			j1 := s1.AuxInt
 32057			r1 := s1.Args[0]
 32058			if r1.Op != OpS390XMOVHZreg {
 32059				break
 32060			}
 32061			x1 := r1.Args[0]
 32062			if x1.Op != OpS390XMOVHBRloadidx {
 32063				break
 32064			}
 32065			i1 := x1.AuxInt
 32066			if x1.Aux != s {
 32067				break
 32068			}
 32069			_ = x1.Args[2]
 32070			if idx != x1.Args[0] {
 32071				break
 32072			}
 32073			if p != x1.Args[1] {
 32074				break
 32075			}
 32076			if mem != x1.Args[2] {
 32077				break
 32078			}
 32079			if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
 32080				break
 32081			}
 32082			b = mergePoint(b, x0, x1, y)
 32083			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 32084			v.reset(OpCopy)
 32085			v.AddArg(v0)
 32086			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 32087			v1.AuxInt = j0
 32088			v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
 32089			v3 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
 32090			v3.AuxInt = i0
 32091			v3.Aux = s
 32092			v3.AddArg(p)
 32093			v3.AddArg(idx)
 32094			v3.AddArg(mem)
 32095			v2.AddArg(v3)
 32096			v1.AddArg(v2)
 32097			v0.AddArg(v1)
 32098			v0.AddArg(y)
 32099			return true
 32100		}
 32101		// match: (OR or:(OR y s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} p idx mem)))) s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))))
 32102		// cond: i1 == i0+2 && j1 == j0+16 && j0 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)
 32103		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
 32104		for {
 32105			_ = v.Args[1]
 32106			or := v.Args[0]
 32107			if or.Op != OpS390XOR {
 32108				break
 32109			}
 32110			_ = or.Args[1]
 32111			y := or.Args[0]
 32112			s0 := or.Args[1]
 32113			if s0.Op != OpS390XSLDconst {
 32114				break
 32115			}
 32116			j0 := s0.AuxInt
 32117			r0 := s0.Args[0]
 32118			if r0.Op != OpS390XMOVHZreg {
 32119				break
 32120			}
 32121			x0 := r0.Args[0]
 32122			if x0.Op != OpS390XMOVHBRloadidx {
 32123				break
 32124			}
 32125			i0 := x0.AuxInt
 32126			s := x0.Aux
 32127			mem := x0.Args[2]
 32128			p := x0.Args[0]
 32129			idx := x0.Args[1]
 32130			s1 := v.Args[1]
 32131			if s1.Op != OpS390XSLDconst {
 32132				break
 32133			}
 32134			j1 := s1.AuxInt
 32135			r1 := s1.Args[0]
 32136			if r1.Op != OpS390XMOVHZreg {
 32137				break
 32138			}
 32139			x1 := r1.Args[0]
 32140			if x1.Op != OpS390XMOVHBRloadidx {
 32141				break
 32142			}
 32143			i1 := x1.AuxInt
 32144			if x1.Aux != s {
 32145				break
 32146			}
 32147			_ = x1.Args[2]
 32148			if idx != x1.Args[0] {
 32149				break
 32150			}
 32151			if p != x1.Args[1] {
 32152				break
 32153			}
 32154			if mem != x1.Args[2] {
 32155				break
 32156			}
 32157			if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
 32158				break
 32159			}
 32160			b = mergePoint(b, x0, x1, y)
 32161			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 32162			v.reset(OpCopy)
 32163			v.AddArg(v0)
 32164			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 32165			v1.AuxInt = j0
 32166			v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
 32167			v3 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
 32168			v3.AuxInt = i0
 32169			v3.Aux = s
 32170			v3.AddArg(p)
 32171			v3.AddArg(idx)
 32172			v3.AddArg(mem)
 32173			v2.AddArg(v3)
 32174			v1.AddArg(v2)
 32175			v0.AddArg(v1)
 32176			v0.AddArg(y)
 32177			return true
 32178		}
 32179		// match: (OR or:(OR y s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem)))) s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))))
 32180		// cond: i1 == i0+2 && j1 == j0+16 && j0 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)
 32181		// result: @mergePoint(b,x0,x1,y) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
 32182		for {
 32183			_ = v.Args[1]
 32184			or := v.Args[0]
 32185			if or.Op != OpS390XOR {
 32186				break
 32187			}
 32188			_ = or.Args[1]
 32189			y := or.Args[0]
 32190			s0 := or.Args[1]
 32191			if s0.Op != OpS390XSLDconst {
 32192				break
 32193			}
 32194			j0 := s0.AuxInt
 32195			r0 := s0.Args[0]
 32196			if r0.Op != OpS390XMOVHZreg {
 32197				break
 32198			}
 32199			x0 := r0.Args[0]
 32200			if x0.Op != OpS390XMOVHBRloadidx {
 32201				break
 32202			}
 32203			i0 := x0.AuxInt
 32204			s := x0.Aux
 32205			mem := x0.Args[2]
 32206			idx := x0.Args[0]
 32207			p := x0.Args[1]
 32208			s1 := v.Args[1]
 32209			if s1.Op != OpS390XSLDconst {
 32210				break
 32211			}
 32212			j1 := s1.AuxInt
 32213			r1 := s1.Args[0]
 32214			if r1.Op != OpS390XMOVHZreg {
 32215				break
 32216			}
 32217			x1 := r1.Args[0]
 32218			if x1.Op != OpS390XMOVHBRloadidx {
 32219				break
 32220			}
 32221			i1 := x1.AuxInt
 32222			if x1.Aux != s {
 32223				break
 32224			}
 32225			_ = x1.Args[2]
 32226			if idx != x1.Args[0] {
 32227				break
 32228			}
 32229			if p != x1.Args[1] {
 32230				break
 32231			}
 32232			if mem != x1.Args[2] {
 32233				break
 32234			}
 32235			if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
 32236				break
 32237			}
 32238			b = mergePoint(b, x0, x1, y)
 32239			v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
 32240			v.reset(OpCopy)
 32241			v.AddArg(v0)
 32242			v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
 32243			v1.AuxInt = j0
 32244			v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
 32245			v3 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
 32246			v3.AuxInt = i0
 32247			v3.Aux = s
 32248			v3.AddArg(p)
 32249			v3.AddArg(idx)
 32250			v3.AddArg(mem)
 32251			v2.AddArg(v3)
 32252			v1.AddArg(v2)
 32253			v0.AddArg(v1)
 32254			v0.AddArg(y)
 32255			return true
 32256		}
 32257		return false
 32258	}
 32259	func rewriteValueS390X_OpS390XORW_0(v *Value) bool {
 32260		// match: (ORW x (MOVDconst [c]))
 32261		// cond:
 32262		// result: (ORWconst [int64(int32(c))] x)
 32263		for {
 32264			_ = v.Args[1]
 32265			x := v.Args[0]
 32266			v_1 := v.Args[1]
 32267			if v_1.Op != OpS390XMOVDconst {
 32268				break
 32269			}
 32270			c := v_1.AuxInt
 32271			v.reset(OpS390XORWconst)
 32272			v.AuxInt = int64(int32(c))
 32273			v.AddArg(x)
 32274			return true
 32275		}
 32276		// match: (ORW (MOVDconst [c]) x)
 32277		// cond:
 32278		// result: (ORWconst [int64(int32(c))] x)
 32279		for {
 32280			x := v.Args[1]
 32281			v_0 := v.Args[0]
 32282			if v_0.Op != OpS390XMOVDconst {
 32283				break
 32284			}
 32285			c := v_0.AuxInt
 32286			v.reset(OpS390XORWconst)
 32287			v.AuxInt = int64(int32(c))
 32288			v.AddArg(x)
 32289			return true
 32290		}
 32291		// match: (ORW (SLWconst x [c]) (SRWconst x [d]))
 32292		// cond: d == 32-c
 32293		// result: (RLLconst [c] x)
 32294		for {
 32295			_ = v.Args[1]
 32296			v_0 := v.Args[0]
 32297			if v_0.Op != OpS390XSLWconst {
 32298				break
 32299			}
 32300			c := v_0.AuxInt
 32301			x := v_0.Args[0]
 32302			v_1 := v.Args[1]
 32303			if v_1.Op != OpS390XSRWconst {
 32304				break
 32305			}
 32306			d := v_1.AuxInt
 32307			if x != v_1.Args[0] {
 32308				break
 32309			}
 32310			if !(d == 32-c) {
 32311				break
 32312			}
 32313			v.reset(OpS390XRLLconst)
 32314			v.AuxInt = c
 32315			v.AddArg(x)
 32316			return true
 32317		}
 32318		// match: (ORW (SRWconst x [d]) (SLWconst x [c]))
 32319		// cond: d == 32-c
 32320		// result: (RLLconst [c] x)
 32321		for {
 32322			_ = v.Args[1]
 32323			v_0 := v.Args[0]
 32324			if v_0.Op != OpS390XSRWconst {
 32325				break
 32326			}
 32327			d := v_0.AuxInt
 32328			x := v_0.Args[0]
 32329			v_1 := v.Args[1]
 32330			if v_1.Op != OpS390XSLWconst {
 32331				break
 32332			}
 32333			c := v_1.AuxInt
 32334			if x != v_1.Args[0] {
 32335				break
 32336			}
 32337			if !(d == 32-c) {
 32338				break
 32339			}
 32340			v.reset(OpS390XRLLconst)
 32341			v.AuxInt = c
 32342			v.AddArg(x)
 32343			return true
 32344		}
 32345		// match: (ORW x x)
 32346		// cond:
 32347		// result: x
 32348		for {
 32349			x := v.Args[1]
 32350			if x != v.Args[0] {
 32351				break
 32352			}
 32353			v.reset(OpCopy)
 32354			v.Type = x.Type
 32355			v.AddArg(x)
 32356			return true
 32357		}
 32358		// match: (ORW <t> x g:(MOVWload [off] {sym} ptr mem))
 32359		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 32360		// result: (ORWload <t> [off] {sym} x ptr mem)
 32361		for {
 32362			t := v.Type
 32363			_ = v.Args[1]
 32364			x := v.Args[0]
 32365			g := v.Args[1]
 32366			if g.Op != OpS390XMOVWload {
 32367				break
 32368			}
 32369			off := g.AuxInt
 32370			sym := g.Aux
 32371			mem := g.Args[1]
 32372			ptr := g.Args[0]
 32373			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 32374				break
 32375			}
 32376			v.reset(OpS390XORWload)
 32377			v.Type = t
 32378			v.AuxInt = off
 32379			v.Aux = sym
 32380			v.AddArg(x)
 32381			v.AddArg(ptr)
 32382			v.AddArg(mem)
 32383			return true
 32384		}
 32385		// match: (ORW <t> g:(MOVWload [off] {sym} ptr mem) x)
 32386		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 32387		// result: (ORWload <t> [off] {sym} x ptr mem)
 32388		for {
 32389			t := v.Type
 32390			x := v.Args[1]
 32391			g := v.Args[0]
 32392			if g.Op != OpS390XMOVWload {
 32393				break
 32394			}
 32395			off := g.AuxInt
 32396			sym := g.Aux
 32397			mem := g.Args[1]
 32398			ptr := g.Args[0]
 32399			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 32400				break
 32401			}
 32402			v.reset(OpS390XORWload)
 32403			v.Type = t
 32404			v.AuxInt = off
 32405			v.Aux = sym
 32406			v.AddArg(x)
 32407			v.AddArg(ptr)
 32408			v.AddArg(mem)
 32409			return true
 32410		}
 32411		// match: (ORW <t> g:(MOVWload [off] {sym} ptr mem) x)
 32412		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 32413		// result: (ORWload <t> [off] {sym} x ptr mem)
 32414		for {
 32415			t := v.Type
 32416			x := v.Args[1]
 32417			g := v.Args[0]
 32418			if g.Op != OpS390XMOVWload {
 32419				break
 32420			}
 32421			off := g.AuxInt
 32422			sym := g.Aux
 32423			mem := g.Args[1]
 32424			ptr := g.Args[0]
 32425			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 32426				break
 32427			}
 32428			v.reset(OpS390XORWload)
 32429			v.Type = t
 32430			v.AuxInt = off
 32431			v.Aux = sym
 32432			v.AddArg(x)
 32433			v.AddArg(ptr)
 32434			v.AddArg(mem)
 32435			return true
 32436		}
 32437		// match: (ORW <t> x g:(MOVWload [off] {sym} ptr mem))
 32438		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 32439		// result: (ORWload <t> [off] {sym} x ptr mem)
 32440		for {
 32441			t := v.Type
 32442			_ = v.Args[1]
 32443			x := v.Args[0]
 32444			g := v.Args[1]
 32445			if g.Op != OpS390XMOVWload {
 32446				break
 32447			}
 32448			off := g.AuxInt
 32449			sym := g.Aux
 32450			mem := g.Args[1]
 32451			ptr := g.Args[0]
 32452			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 32453				break
 32454			}
 32455			v.reset(OpS390XORWload)
 32456			v.Type = t
 32457			v.AuxInt = off
 32458			v.Aux = sym
 32459			v.AddArg(x)
 32460			v.AddArg(ptr)
 32461			v.AddArg(mem)
 32462			return true
 32463		}
 32464		// match: (ORW <t> x g:(MOVWZload [off] {sym} ptr mem))
 32465		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 32466		// result: (ORWload <t> [off] {sym} x ptr mem)
 32467		for {
 32468			t := v.Type
 32469			_ = v.Args[1]
 32470			x := v.Args[0]
 32471			g := v.Args[1]
 32472			if g.Op != OpS390XMOVWZload {
 32473				break
 32474			}
 32475			off := g.AuxInt
 32476			sym := g.Aux
 32477			mem := g.Args[1]
 32478			ptr := g.Args[0]
 32479			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 32480				break
 32481			}
 32482			v.reset(OpS390XORWload)
 32483			v.Type = t
 32484			v.AuxInt = off
 32485			v.Aux = sym
 32486			v.AddArg(x)
 32487			v.AddArg(ptr)
 32488			v.AddArg(mem)
 32489			return true
 32490		}
 32491		return false
 32492	}
 32493	func rewriteValueS390X_OpS390XORW_10(v *Value) bool {
 32494		b := v.Block
 32495		typ := &b.Func.Config.Types
 32496		// match: (ORW <t> g:(MOVWZload [off] {sym} ptr mem) x)
 32497		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 32498		// result: (ORWload <t> [off] {sym} x ptr mem)
 32499		for {
 32500			t := v.Type
 32501			x := v.Args[1]
 32502			g := v.Args[0]
 32503			if g.Op != OpS390XMOVWZload {
 32504				break
 32505			}
 32506			off := g.AuxInt
 32507			sym := g.Aux
 32508			mem := g.Args[1]
 32509			ptr := g.Args[0]
 32510			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 32511				break
 32512			}
 32513			v.reset(OpS390XORWload)
 32514			v.Type = t
 32515			v.AuxInt = off
 32516			v.Aux = sym
 32517			v.AddArg(x)
 32518			v.AddArg(ptr)
 32519			v.AddArg(mem)
 32520			return true
 32521		}
 32522		// match: (ORW <t> g:(MOVWZload [off] {sym} ptr mem) x)
 32523		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 32524		// result: (ORWload <t> [off] {sym} x ptr mem)
 32525		for {
 32526			t := v.Type
 32527			x := v.Args[1]
 32528			g := v.Args[0]
 32529			if g.Op != OpS390XMOVWZload {
 32530				break
 32531			}
 32532			off := g.AuxInt
 32533			sym := g.Aux
 32534			mem := g.Args[1]
 32535			ptr := g.Args[0]
 32536			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 32537				break
 32538			}
 32539			v.reset(OpS390XORWload)
 32540			v.Type = t
 32541			v.AuxInt = off
 32542			v.Aux = sym
 32543			v.AddArg(x)
 32544			v.AddArg(ptr)
 32545			v.AddArg(mem)
 32546			return true
 32547		}
 32548		// match: (ORW <t> x g:(MOVWZload [off] {sym} ptr mem))
 32549		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 32550		// result: (ORWload <t> [off] {sym} x ptr mem)
 32551		for {
 32552			t := v.Type
 32553			_ = v.Args[1]
 32554			x := v.Args[0]
 32555			g := v.Args[1]
 32556			if g.Op != OpS390XMOVWZload {
 32557				break
 32558			}
 32559			off := g.AuxInt
 32560			sym := g.Aux
 32561			mem := g.Args[1]
 32562			ptr := g.Args[0]
 32563			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 32564				break
 32565			}
 32566			v.reset(OpS390XORWload)
 32567			v.Type = t
 32568			v.AuxInt = off
 32569			v.Aux = sym
 32570			v.AddArg(x)
 32571			v.AddArg(ptr)
 32572			v.AddArg(mem)
 32573			return true
 32574		}
 32575		// match: (ORW x1:(MOVBZload [i1] {s} p mem) sh:(SLWconst [8] x0:(MOVBZload [i0] {s} p mem)))
 32576		// cond: i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 32577		// result: @mergePoint(b,x0,x1) (MOVHZload [i0] {s} p mem)
 32578		for {
 32579			_ = v.Args[1]
 32580			x1 := v.Args[0]
 32581			if x1.Op != OpS390XMOVBZload {
 32582				break
 32583			}
 32584			i1 := x1.AuxInt
 32585			s := x1.Aux
 32586			mem := x1.Args[1]
 32587			p := x1.Args[0]
 32588			sh := v.Args[1]
 32589			if sh.Op != OpS390XSLWconst {
 32590				break
 32591			}
 32592			if sh.AuxInt != 8 {
 32593				break
 32594			}
 32595			x0 := sh.Args[0]
 32596			if x0.Op != OpS390XMOVBZload {
 32597				break
 32598			}
 32599			i0 := x0.AuxInt
 32600			if x0.Aux != s {
 32601				break
 32602			}
 32603			_ = x0.Args[1]
 32604			if p != x0.Args[0] {
 32605				break
 32606			}
 32607			if mem != x0.Args[1] {
 32608				break
 32609			}
 32610			if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 32611				break
 32612			}
 32613			b = mergePoint(b, x0, x1)
 32614			v0 := b.NewValue0(x0.Pos, OpS390XMOVHZload, typ.UInt16)
 32615			v.reset(OpCopy)
 32616			v.AddArg(v0)
 32617			v0.AuxInt = i0
 32618			v0.Aux = s
 32619			v0.AddArg(p)
 32620			v0.AddArg(mem)
 32621			return true
 32622		}
 32623		// match: (ORW sh:(SLWconst [8] x0:(MOVBZload [i0] {s} p mem)) x1:(MOVBZload [i1] {s} p mem))
 32624		// cond: i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 32625		// result: @mergePoint(b,x0,x1) (MOVHZload [i0] {s} p mem)
 32626		for {
 32627			_ = v.Args[1]
 32628			sh := v.Args[0]
 32629			if sh.Op != OpS390XSLWconst {
 32630				break
 32631			}
 32632			if sh.AuxInt != 8 {
 32633				break
 32634			}
 32635			x0 := sh.Args[0]
 32636			if x0.Op != OpS390XMOVBZload {
 32637				break
 32638			}
 32639			i0 := x0.AuxInt
 32640			s := x0.Aux
 32641			mem := x0.Args[1]
 32642			p := x0.Args[0]
 32643			x1 := v.Args[1]
 32644			if x1.Op != OpS390XMOVBZload {
 32645				break
 32646			}
 32647			i1 := x1.AuxInt
 32648			if x1.Aux != s {
 32649				break
 32650			}
 32651			_ = x1.Args[1]
 32652			if p != x1.Args[0] {
 32653				break
 32654			}
 32655			if mem != x1.Args[1] {
 32656				break
 32657			}
 32658			if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 32659				break
 32660			}
 32661			b = mergePoint(b, x0, x1)
 32662			v0 := b.NewValue0(x1.Pos, OpS390XMOVHZload, typ.UInt16)
 32663			v.reset(OpCopy)
 32664			v.AddArg(v0)
 32665			v0.AuxInt = i0
 32666			v0.Aux = s
 32667			v0.AddArg(p)
 32668			v0.AddArg(mem)
 32669			return true
 32670		}
 32671		// match: (ORW x1:(MOVHZload [i1] {s} p mem) sh:(SLWconst [16] x0:(MOVHZload [i0] {s} p mem)))
 32672		// cond: i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 32673		// result: @mergePoint(b,x0,x1) (MOVWZload [i0] {s} p mem)
 32674		for {
 32675			_ = v.Args[1]
 32676			x1 := v.Args[0]
 32677			if x1.Op != OpS390XMOVHZload {
 32678				break
 32679			}
 32680			i1 := x1.AuxInt
 32681			s := x1.Aux
 32682			mem := x1.Args[1]
 32683			p := x1.Args[0]
 32684			sh := v.Args[1]
 32685			if sh.Op != OpS390XSLWconst {
 32686				break
 32687			}
 32688			if sh.AuxInt != 16 {
 32689				break
 32690			}
 32691			x0 := sh.Args[0]
 32692			if x0.Op != OpS390XMOVHZload {
 32693				break
 32694			}
 32695			i0 := x0.AuxInt
 32696			if x0.Aux != s {
 32697				break
 32698			}
 32699			_ = x0.Args[1]
 32700			if p != x0.Args[0] {
 32701				break
 32702			}
 32703			if mem != x0.Args[1] {
 32704				break
 32705			}
 32706			if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 32707				break
 32708			}
 32709			b = mergePoint(b, x0, x1)
 32710			v0 := b.NewValue0(x0.Pos, OpS390XMOVWZload, typ.UInt32)
 32711			v.reset(OpCopy)
 32712			v.AddArg(v0)
 32713			v0.AuxInt = i0
 32714			v0.Aux = s
 32715			v0.AddArg(p)
 32716			v0.AddArg(mem)
 32717			return true
 32718		}
 32719		// match: (ORW sh:(SLWconst [16] x0:(MOVHZload [i0] {s} p mem)) x1:(MOVHZload [i1] {s} p mem))
 32720		// cond: i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 32721		// result: @mergePoint(b,x0,x1) (MOVWZload [i0] {s} p mem)
 32722		for {
 32723			_ = v.Args[1]
 32724			sh := v.Args[0]
 32725			if sh.Op != OpS390XSLWconst {
 32726				break
 32727			}
 32728			if sh.AuxInt != 16 {
 32729				break
 32730			}
 32731			x0 := sh.Args[0]
 32732			if x0.Op != OpS390XMOVHZload {
 32733				break
 32734			}
 32735			i0 := x0.AuxInt
 32736			s := x0.Aux
 32737			mem := x0.Args[1]
 32738			p := x0.Args[0]
 32739			x1 := v.Args[1]
 32740			if x1.Op != OpS390XMOVHZload {
 32741				break
 32742			}
 32743			i1 := x1.AuxInt
 32744			if x1.Aux != s {
 32745				break
 32746			}
 32747			_ = x1.Args[1]
 32748			if p != x1.Args[0] {
 32749				break
 32750			}
 32751			if mem != x1.Args[1] {
 32752				break
 32753			}
 32754			if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 32755				break
 32756			}
 32757			b = mergePoint(b, x0, x1)
 32758			v0 := b.NewValue0(x1.Pos, OpS390XMOVWZload, typ.UInt32)
 32759			v.reset(OpCopy)
 32760			v.AddArg(v0)
 32761			v0.AuxInt = i0
 32762			v0.Aux = s
 32763			v0.AddArg(p)
 32764			v0.AddArg(mem)
 32765			return true
 32766		}
 32767		// match: (ORW s0:(SLWconst [j0] x0:(MOVBZload [i0] {s} p mem)) or:(ORW s1:(SLWconst [j1] x1:(MOVBZload [i1] {s} p mem)) y))
 32768		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 32769		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZload [i0] {s} p mem)) y)
 32770		for {
 32771			_ = v.Args[1]
 32772			s0 := v.Args[0]
 32773			if s0.Op != OpS390XSLWconst {
 32774				break
 32775			}
 32776			j0 := s0.AuxInt
 32777			x0 := s0.Args[0]
 32778			if x0.Op != OpS390XMOVBZload {
 32779				break
 32780			}
 32781			i0 := x0.AuxInt
 32782			s := x0.Aux
 32783			mem := x0.Args[1]
 32784			p := x0.Args[0]
 32785			or := v.Args[1]
 32786			if or.Op != OpS390XORW {
 32787				break
 32788			}
 32789			y := or.Args[1]
 32790			s1 := or.Args[0]
 32791			if s1.Op != OpS390XSLWconst {
 32792				break
 32793			}
 32794			j1 := s1.AuxInt
 32795			x1 := s1.Args[0]
 32796			if x1.Op != OpS390XMOVBZload {
 32797				break
 32798			}
 32799			i1 := x1.AuxInt
 32800			if x1.Aux != s {
 32801				break
 32802			}
 32803			_ = x1.Args[1]
 32804			if p != x1.Args[0] {
 32805				break
 32806			}
 32807			if mem != x1.Args[1] {
 32808				break
 32809			}
 32810			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 32811				break
 32812			}
 32813			b = mergePoint(b, x0, x1, y)
 32814			v0 := b.NewValue0(x1.Pos, OpS390XORW, v.Type)
 32815			v.reset(OpCopy)
 32816			v.AddArg(v0)
 32817			v1 := b.NewValue0(x1.Pos, OpS390XSLWconst, v.Type)
 32818			v1.AuxInt = j1
 32819			v2 := b.NewValue0(x1.Pos, OpS390XMOVHZload, typ.UInt16)
 32820			v2.AuxInt = i0
 32821			v2.Aux = s
 32822			v2.AddArg(p)
 32823			v2.AddArg(mem)
 32824			v1.AddArg(v2)
 32825			v0.AddArg(v1)
 32826			v0.AddArg(y)
 32827			return true
 32828		}
 32829		// match: (ORW s0:(SLWconst [j0] x0:(MOVBZload [i0] {s} p mem)) or:(ORW y s1:(SLWconst [j1] x1:(MOVBZload [i1] {s} p mem))))
 32830		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 32831		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZload [i0] {s} p mem)) y)
 32832		for {
 32833			_ = v.Args[1]
 32834			s0 := v.Args[0]
 32835			if s0.Op != OpS390XSLWconst {
 32836				break
 32837			}
 32838			j0 := s0.AuxInt
 32839			x0 := s0.Args[0]
 32840			if x0.Op != OpS390XMOVBZload {
 32841				break
 32842			}
 32843			i0 := x0.AuxInt
 32844			s := x0.Aux
 32845			mem := x0.Args[1]
 32846			p := x0.Args[0]
 32847			or := v.Args[1]
 32848			if or.Op != OpS390XORW {
 32849				break
 32850			}
 32851			_ = or.Args[1]
 32852			y := or.Args[0]
 32853			s1 := or.Args[1]
 32854			if s1.Op != OpS390XSLWconst {
 32855				break
 32856			}
 32857			j1 := s1.AuxInt
 32858			x1 := s1.Args[0]
 32859			if x1.Op != OpS390XMOVBZload {
 32860				break
 32861			}
 32862			i1 := x1.AuxInt
 32863			if x1.Aux != s {
 32864				break
 32865			}
 32866			_ = x1.Args[1]
 32867			if p != x1.Args[0] {
 32868				break
 32869			}
 32870			if mem != x1.Args[1] {
 32871				break
 32872			}
 32873			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 32874				break
 32875			}
 32876			b = mergePoint(b, x0, x1, y)
 32877			v0 := b.NewValue0(x1.Pos, OpS390XORW, v.Type)
 32878			v.reset(OpCopy)
 32879			v.AddArg(v0)
 32880			v1 := b.NewValue0(x1.Pos, OpS390XSLWconst, v.Type)
 32881			v1.AuxInt = j1
 32882			v2 := b.NewValue0(x1.Pos, OpS390XMOVHZload, typ.UInt16)
 32883			v2.AuxInt = i0
 32884			v2.Aux = s
 32885			v2.AddArg(p)
 32886			v2.AddArg(mem)
 32887			v1.AddArg(v2)
 32888			v0.AddArg(v1)
 32889			v0.AddArg(y)
 32890			return true
 32891		}
 32892		// match: (ORW or:(ORW s1:(SLWconst [j1] x1:(MOVBZload [i1] {s} p mem)) y) s0:(SLWconst [j0] x0:(MOVBZload [i0] {s} p mem)))
 32893		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 32894		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZload [i0] {s} p mem)) y)
 32895		for {
 32896			_ = v.Args[1]
 32897			or := v.Args[0]
 32898			if or.Op != OpS390XORW {
 32899				break
 32900			}
 32901			y := or.Args[1]
 32902			s1 := or.Args[0]
 32903			if s1.Op != OpS390XSLWconst {
 32904				break
 32905			}
 32906			j1 := s1.AuxInt
 32907			x1 := s1.Args[0]
 32908			if x1.Op != OpS390XMOVBZload {
 32909				break
 32910			}
 32911			i1 := x1.AuxInt
 32912			s := x1.Aux
 32913			mem := x1.Args[1]
 32914			p := x1.Args[0]
 32915			s0 := v.Args[1]
 32916			if s0.Op != OpS390XSLWconst {
 32917				break
 32918			}
 32919			j0 := s0.AuxInt
 32920			x0 := s0.Args[0]
 32921			if x0.Op != OpS390XMOVBZload {
 32922				break
 32923			}
 32924			i0 := x0.AuxInt
 32925			if x0.Aux != s {
 32926				break
 32927			}
 32928			_ = x0.Args[1]
 32929			if p != x0.Args[0] {
 32930				break
 32931			}
 32932			if mem != x0.Args[1] {
 32933				break
 32934			}
 32935			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 32936				break
 32937			}
 32938			b = mergePoint(b, x0, x1, y)
 32939			v0 := b.NewValue0(x0.Pos, OpS390XORW, v.Type)
 32940			v.reset(OpCopy)
 32941			v.AddArg(v0)
 32942			v1 := b.NewValue0(x0.Pos, OpS390XSLWconst, v.Type)
 32943			v1.AuxInt = j1
 32944			v2 := b.NewValue0(x0.Pos, OpS390XMOVHZload, typ.UInt16)
 32945			v2.AuxInt = i0
 32946			v2.Aux = s
 32947			v2.AddArg(p)
 32948			v2.AddArg(mem)
 32949			v1.AddArg(v2)
 32950			v0.AddArg(v1)
 32951			v0.AddArg(y)
 32952			return true
 32953		}
 32954		return false
 32955	}
 32956	func rewriteValueS390X_OpS390XORW_20(v *Value) bool {
 32957		b := v.Block
 32958		typ := &b.Func.Config.Types
 32959		// match: (ORW or:(ORW y s1:(SLWconst [j1] x1:(MOVBZload [i1] {s} p mem))) s0:(SLWconst [j0] x0:(MOVBZload [i0] {s} p mem)))
 32960		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 32961		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZload [i0] {s} p mem)) y)
 32962		for {
 32963			_ = v.Args[1]
 32964			or := v.Args[0]
 32965			if or.Op != OpS390XORW {
 32966				break
 32967			}
 32968			_ = or.Args[1]
 32969			y := or.Args[0]
 32970			s1 := or.Args[1]
 32971			if s1.Op != OpS390XSLWconst {
 32972				break
 32973			}
 32974			j1 := s1.AuxInt
 32975			x1 := s1.Args[0]
 32976			if x1.Op != OpS390XMOVBZload {
 32977				break
 32978			}
 32979			i1 := x1.AuxInt
 32980			s := x1.Aux
 32981			mem := x1.Args[1]
 32982			p := x1.Args[0]
 32983			s0 := v.Args[1]
 32984			if s0.Op != OpS390XSLWconst {
 32985				break
 32986			}
 32987			j0 := s0.AuxInt
 32988			x0 := s0.Args[0]
 32989			if x0.Op != OpS390XMOVBZload {
 32990				break
 32991			}
 32992			i0 := x0.AuxInt
 32993			if x0.Aux != s {
 32994				break
 32995			}
 32996			_ = x0.Args[1]
 32997			if p != x0.Args[0] {
 32998				break
 32999			}
 33000			if mem != x0.Args[1] {
 33001				break
 33002			}
 33003			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 33004				break
 33005			}
 33006			b = mergePoint(b, x0, x1, y)
 33007			v0 := b.NewValue0(x0.Pos, OpS390XORW, v.Type)
 33008			v.reset(OpCopy)
 33009			v.AddArg(v0)
 33010			v1 := b.NewValue0(x0.Pos, OpS390XSLWconst, v.Type)
 33011			v1.AuxInt = j1
 33012			v2 := b.NewValue0(x0.Pos, OpS390XMOVHZload, typ.UInt16)
 33013			v2.AuxInt = i0
 33014			v2.Aux = s
 33015			v2.AddArg(p)
 33016			v2.AddArg(mem)
 33017			v1.AddArg(v2)
 33018			v0.AddArg(v1)
 33019			v0.AddArg(y)
 33020			return true
 33021		}
 33022		// match: (ORW x1:(MOVBZloadidx [i1] {s} p idx mem) sh:(SLWconst [8] x0:(MOVBZloadidx [i0] {s} p idx mem)))
 33023		// cond: i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 33024		// result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem)
 33025		for {
 33026			_ = v.Args[1]
 33027			x1 := v.Args[0]
 33028			if x1.Op != OpS390XMOVBZloadidx {
 33029				break
 33030			}
 33031			i1 := x1.AuxInt
 33032			s := x1.Aux
 33033			mem := x1.Args[2]
 33034			p := x1.Args[0]
 33035			idx := x1.Args[1]
 33036			sh := v.Args[1]
 33037			if sh.Op != OpS390XSLWconst {
 33038				break
 33039			}
 33040			if sh.AuxInt != 8 {
 33041				break
 33042			}
 33043			x0 := sh.Args[0]
 33044			if x0.Op != OpS390XMOVBZloadidx {
 33045				break
 33046			}
 33047			i0 := x0.AuxInt
 33048			if x0.Aux != s {
 33049				break
 33050			}
 33051			_ = x0.Args[2]
 33052			if p != x0.Args[0] {
 33053				break
 33054			}
 33055			if idx != x0.Args[1] {
 33056				break
 33057			}
 33058			if mem != x0.Args[2] {
 33059				break
 33060			}
 33061			if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 33062				break
 33063			}
 33064			b = mergePoint(b, x0, x1)
 33065			v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 33066			v.reset(OpCopy)
 33067			v.AddArg(v0)
 33068			v0.AuxInt = i0
 33069			v0.Aux = s
 33070			v0.AddArg(p)
 33071			v0.AddArg(idx)
 33072			v0.AddArg(mem)
 33073			return true
 33074		}
 33075		// match: (ORW x1:(MOVBZloadidx [i1] {s} idx p mem) sh:(SLWconst [8] x0:(MOVBZloadidx [i0] {s} p idx mem)))
 33076		// cond: i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 33077		// result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem)
 33078		for {
 33079			_ = v.Args[1]
 33080			x1 := v.Args[0]
 33081			if x1.Op != OpS390XMOVBZloadidx {
 33082				break
 33083			}
 33084			i1 := x1.AuxInt
 33085			s := x1.Aux
 33086			mem := x1.Args[2]
 33087			idx := x1.Args[0]
 33088			p := x1.Args[1]
 33089			sh := v.Args[1]
 33090			if sh.Op != OpS390XSLWconst {
 33091				break
 33092			}
 33093			if sh.AuxInt != 8 {
 33094				break
 33095			}
 33096			x0 := sh.Args[0]
 33097			if x0.Op != OpS390XMOVBZloadidx {
 33098				break
 33099			}
 33100			i0 := x0.AuxInt
 33101			if x0.Aux != s {
 33102				break
 33103			}
 33104			_ = x0.Args[2]
 33105			if p != x0.Args[0] {
 33106				break
 33107			}
 33108			if idx != x0.Args[1] {
 33109				break
 33110			}
 33111			if mem != x0.Args[2] {
 33112				break
 33113			}
 33114			if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 33115				break
 33116			}
 33117			b = mergePoint(b, x0, x1)
 33118			v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 33119			v.reset(OpCopy)
 33120			v.AddArg(v0)
 33121			v0.AuxInt = i0
 33122			v0.Aux = s
 33123			v0.AddArg(p)
 33124			v0.AddArg(idx)
 33125			v0.AddArg(mem)
 33126			return true
 33127		}
 33128		// match: (ORW x1:(MOVBZloadidx [i1] {s} p idx mem) sh:(SLWconst [8] x0:(MOVBZloadidx [i0] {s} idx p mem)))
 33129		// cond: i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 33130		// result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem)
 33131		for {
 33132			_ = v.Args[1]
 33133			x1 := v.Args[0]
 33134			if x1.Op != OpS390XMOVBZloadidx {
 33135				break
 33136			}
 33137			i1 := x1.AuxInt
 33138			s := x1.Aux
 33139			mem := x1.Args[2]
 33140			p := x1.Args[0]
 33141			idx := x1.Args[1]
 33142			sh := v.Args[1]
 33143			if sh.Op != OpS390XSLWconst {
 33144				break
 33145			}
 33146			if sh.AuxInt != 8 {
 33147				break
 33148			}
 33149			x0 := sh.Args[0]
 33150			if x0.Op != OpS390XMOVBZloadidx {
 33151				break
 33152			}
 33153			i0 := x0.AuxInt
 33154			if x0.Aux != s {
 33155				break
 33156			}
 33157			_ = x0.Args[2]
 33158			if idx != x0.Args[0] {
 33159				break
 33160			}
 33161			if p != x0.Args[1] {
 33162				break
 33163			}
 33164			if mem != x0.Args[2] {
 33165				break
 33166			}
 33167			if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 33168				break
 33169			}
 33170			b = mergePoint(b, x0, x1)
 33171			v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 33172			v.reset(OpCopy)
 33173			v.AddArg(v0)
 33174			v0.AuxInt = i0
 33175			v0.Aux = s
 33176			v0.AddArg(p)
 33177			v0.AddArg(idx)
 33178			v0.AddArg(mem)
 33179			return true
 33180		}
 33181		// match: (ORW x1:(MOVBZloadidx [i1] {s} idx p mem) sh:(SLWconst [8] x0:(MOVBZloadidx [i0] {s} idx p mem)))
 33182		// cond: i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 33183		// result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem)
 33184		for {
 33185			_ = v.Args[1]
 33186			x1 := v.Args[0]
 33187			if x1.Op != OpS390XMOVBZloadidx {
 33188				break
 33189			}
 33190			i1 := x1.AuxInt
 33191			s := x1.Aux
 33192			mem := x1.Args[2]
 33193			idx := x1.Args[0]
 33194			p := x1.Args[1]
 33195			sh := v.Args[1]
 33196			if sh.Op != OpS390XSLWconst {
 33197				break
 33198			}
 33199			if sh.AuxInt != 8 {
 33200				break
 33201			}
 33202			x0 := sh.Args[0]
 33203			if x0.Op != OpS390XMOVBZloadidx {
 33204				break
 33205			}
 33206			i0 := x0.AuxInt
 33207			if x0.Aux != s {
 33208				break
 33209			}
 33210			_ = x0.Args[2]
 33211			if idx != x0.Args[0] {
 33212				break
 33213			}
 33214			if p != x0.Args[1] {
 33215				break
 33216			}
 33217			if mem != x0.Args[2] {
 33218				break
 33219			}
 33220			if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 33221				break
 33222			}
 33223			b = mergePoint(b, x0, x1)
 33224			v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 33225			v.reset(OpCopy)
 33226			v.AddArg(v0)
 33227			v0.AuxInt = i0
 33228			v0.Aux = s
 33229			v0.AddArg(p)
 33230			v0.AddArg(idx)
 33231			v0.AddArg(mem)
 33232			return true
 33233		}
 33234		// match: (ORW sh:(SLWconst [8] x0:(MOVBZloadidx [i0] {s} p idx mem)) x1:(MOVBZloadidx [i1] {s} p idx mem))
 33235		// cond: i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 33236		// result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem)
 33237		for {
 33238			_ = v.Args[1]
 33239			sh := v.Args[0]
 33240			if sh.Op != OpS390XSLWconst {
 33241				break
 33242			}
 33243			if sh.AuxInt != 8 {
 33244				break
 33245			}
 33246			x0 := sh.Args[0]
 33247			if x0.Op != OpS390XMOVBZloadidx {
 33248				break
 33249			}
 33250			i0 := x0.AuxInt
 33251			s := x0.Aux
 33252			mem := x0.Args[2]
 33253			p := x0.Args[0]
 33254			idx := x0.Args[1]
 33255			x1 := v.Args[1]
 33256			if x1.Op != OpS390XMOVBZloadidx {
 33257				break
 33258			}
 33259			i1 := x1.AuxInt
 33260			if x1.Aux != s {
 33261				break
 33262			}
 33263			_ = x1.Args[2]
 33264			if p != x1.Args[0] {
 33265				break
 33266			}
 33267			if idx != x1.Args[1] {
 33268				break
 33269			}
 33270			if mem != x1.Args[2] {
 33271				break
 33272			}
 33273			if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 33274				break
 33275			}
 33276			b = mergePoint(b, x0, x1)
 33277			v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 33278			v.reset(OpCopy)
 33279			v.AddArg(v0)
 33280			v0.AuxInt = i0
 33281			v0.Aux = s
 33282			v0.AddArg(p)
 33283			v0.AddArg(idx)
 33284			v0.AddArg(mem)
 33285			return true
 33286		}
 33287		// match: (ORW sh:(SLWconst [8] x0:(MOVBZloadidx [i0] {s} idx p mem)) x1:(MOVBZloadidx [i1] {s} p idx mem))
 33288		// cond: i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 33289		// result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem)
 33290		for {
 33291			_ = v.Args[1]
 33292			sh := v.Args[0]
 33293			if sh.Op != OpS390XSLWconst {
 33294				break
 33295			}
 33296			if sh.AuxInt != 8 {
 33297				break
 33298			}
 33299			x0 := sh.Args[0]
 33300			if x0.Op != OpS390XMOVBZloadidx {
 33301				break
 33302			}
 33303			i0 := x0.AuxInt
 33304			s := x0.Aux
 33305			mem := x0.Args[2]
 33306			idx := x0.Args[0]
 33307			p := x0.Args[1]
 33308			x1 := v.Args[1]
 33309			if x1.Op != OpS390XMOVBZloadidx {
 33310				break
 33311			}
 33312			i1 := x1.AuxInt
 33313			if x1.Aux != s {
 33314				break
 33315			}
 33316			_ = x1.Args[2]
 33317			if p != x1.Args[0] {
 33318				break
 33319			}
 33320			if idx != x1.Args[1] {
 33321				break
 33322			}
 33323			if mem != x1.Args[2] {
 33324				break
 33325			}
 33326			if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 33327				break
 33328			}
 33329			b = mergePoint(b, x0, x1)
 33330			v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 33331			v.reset(OpCopy)
 33332			v.AddArg(v0)
 33333			v0.AuxInt = i0
 33334			v0.Aux = s
 33335			v0.AddArg(p)
 33336			v0.AddArg(idx)
 33337			v0.AddArg(mem)
 33338			return true
 33339		}
 33340		// match: (ORW sh:(SLWconst [8] x0:(MOVBZloadidx [i0] {s} p idx mem)) x1:(MOVBZloadidx [i1] {s} idx p mem))
 33341		// cond: i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 33342		// result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem)
 33343		for {
 33344			_ = v.Args[1]
 33345			sh := v.Args[0]
 33346			if sh.Op != OpS390XSLWconst {
 33347				break
 33348			}
 33349			if sh.AuxInt != 8 {
 33350				break
 33351			}
 33352			x0 := sh.Args[0]
 33353			if x0.Op != OpS390XMOVBZloadidx {
 33354				break
 33355			}
 33356			i0 := x0.AuxInt
 33357			s := x0.Aux
 33358			mem := x0.Args[2]
 33359			p := x0.Args[0]
 33360			idx := x0.Args[1]
 33361			x1 := v.Args[1]
 33362			if x1.Op != OpS390XMOVBZloadidx {
 33363				break
 33364			}
 33365			i1 := x1.AuxInt
 33366			if x1.Aux != s {
 33367				break
 33368			}
 33369			_ = x1.Args[2]
 33370			if idx != x1.Args[0] {
 33371				break
 33372			}
 33373			if p != x1.Args[1] {
 33374				break
 33375			}
 33376			if mem != x1.Args[2] {
 33377				break
 33378			}
 33379			if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 33380				break
 33381			}
 33382			b = mergePoint(b, x0, x1)
 33383			v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 33384			v.reset(OpCopy)
 33385			v.AddArg(v0)
 33386			v0.AuxInt = i0
 33387			v0.Aux = s
 33388			v0.AddArg(p)
 33389			v0.AddArg(idx)
 33390			v0.AddArg(mem)
 33391			return true
 33392		}
 33393		// match: (ORW sh:(SLWconst [8] x0:(MOVBZloadidx [i0] {s} idx p mem)) x1:(MOVBZloadidx [i1] {s} idx p mem))
 33394		// cond: i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 33395		// result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem)
 33396		for {
 33397			_ = v.Args[1]
 33398			sh := v.Args[0]
 33399			if sh.Op != OpS390XSLWconst {
 33400				break
 33401			}
 33402			if sh.AuxInt != 8 {
 33403				break
 33404			}
 33405			x0 := sh.Args[0]
 33406			if x0.Op != OpS390XMOVBZloadidx {
 33407				break
 33408			}
 33409			i0 := x0.AuxInt
 33410			s := x0.Aux
 33411			mem := x0.Args[2]
 33412			idx := x0.Args[0]
 33413			p := x0.Args[1]
 33414			x1 := v.Args[1]
 33415			if x1.Op != OpS390XMOVBZloadidx {
 33416				break
 33417			}
 33418			i1 := x1.AuxInt
 33419			if x1.Aux != s {
 33420				break
 33421			}
 33422			_ = x1.Args[2]
 33423			if idx != x1.Args[0] {
 33424				break
 33425			}
 33426			if p != x1.Args[1] {
 33427				break
 33428			}
 33429			if mem != x1.Args[2] {
 33430				break
 33431			}
 33432			if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 33433				break
 33434			}
 33435			b = mergePoint(b, x0, x1)
 33436			v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 33437			v.reset(OpCopy)
 33438			v.AddArg(v0)
 33439			v0.AuxInt = i0
 33440			v0.Aux = s
 33441			v0.AddArg(p)
 33442			v0.AddArg(idx)
 33443			v0.AddArg(mem)
 33444			return true
 33445		}
 33446		// match: (ORW x1:(MOVHZloadidx [i1] {s} p idx mem) sh:(SLWconst [16] x0:(MOVHZloadidx [i0] {s} p idx mem)))
 33447		// cond: i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 33448		// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
 33449		for {
 33450			_ = v.Args[1]
 33451			x1 := v.Args[0]
 33452			if x1.Op != OpS390XMOVHZloadidx {
 33453				break
 33454			}
 33455			i1 := x1.AuxInt
 33456			s := x1.Aux
 33457			mem := x1.Args[2]
 33458			p := x1.Args[0]
 33459			idx := x1.Args[1]
 33460			sh := v.Args[1]
 33461			if sh.Op != OpS390XSLWconst {
 33462				break
 33463			}
 33464			if sh.AuxInt != 16 {
 33465				break
 33466			}
 33467			x0 := sh.Args[0]
 33468			if x0.Op != OpS390XMOVHZloadidx {
 33469				break
 33470			}
 33471			i0 := x0.AuxInt
 33472			if x0.Aux != s {
 33473				break
 33474			}
 33475			_ = x0.Args[2]
 33476			if p != x0.Args[0] {
 33477				break
 33478			}
 33479			if idx != x0.Args[1] {
 33480				break
 33481			}
 33482			if mem != x0.Args[2] {
 33483				break
 33484			}
 33485			if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 33486				break
 33487			}
 33488			b = mergePoint(b, x0, x1)
 33489			v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
 33490			v.reset(OpCopy)
 33491			v.AddArg(v0)
 33492			v0.AuxInt = i0
 33493			v0.Aux = s
 33494			v0.AddArg(p)
 33495			v0.AddArg(idx)
 33496			v0.AddArg(mem)
 33497			return true
 33498		}
 33499		return false
 33500	}
 33501	func rewriteValueS390X_OpS390XORW_30(v *Value) bool {
 33502		b := v.Block
 33503		typ := &b.Func.Config.Types
 33504		// match: (ORW x1:(MOVHZloadidx [i1] {s} idx p mem) sh:(SLWconst [16] x0:(MOVHZloadidx [i0] {s} p idx mem)))
 33505		// cond: i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 33506		// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
 33507		for {
 33508			_ = v.Args[1]
 33509			x1 := v.Args[0]
 33510			if x1.Op != OpS390XMOVHZloadidx {
 33511				break
 33512			}
 33513			i1 := x1.AuxInt
 33514			s := x1.Aux
 33515			mem := x1.Args[2]
 33516			idx := x1.Args[0]
 33517			p := x1.Args[1]
 33518			sh := v.Args[1]
 33519			if sh.Op != OpS390XSLWconst {
 33520				break
 33521			}
 33522			if sh.AuxInt != 16 {
 33523				break
 33524			}
 33525			x0 := sh.Args[0]
 33526			if x0.Op != OpS390XMOVHZloadidx {
 33527				break
 33528			}
 33529			i0 := x0.AuxInt
 33530			if x0.Aux != s {
 33531				break
 33532			}
 33533			_ = x0.Args[2]
 33534			if p != x0.Args[0] {
 33535				break
 33536			}
 33537			if idx != x0.Args[1] {
 33538				break
 33539			}
 33540			if mem != x0.Args[2] {
 33541				break
 33542			}
 33543			if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 33544				break
 33545			}
 33546			b = mergePoint(b, x0, x1)
 33547			v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
 33548			v.reset(OpCopy)
 33549			v.AddArg(v0)
 33550			v0.AuxInt = i0
 33551			v0.Aux = s
 33552			v0.AddArg(p)
 33553			v0.AddArg(idx)
 33554			v0.AddArg(mem)
 33555			return true
 33556		}
 33557		// match: (ORW x1:(MOVHZloadidx [i1] {s} p idx mem) sh:(SLWconst [16] x0:(MOVHZloadidx [i0] {s} idx p mem)))
 33558		// cond: i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 33559		// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
 33560		for {
 33561			_ = v.Args[1]
 33562			x1 := v.Args[0]
 33563			if x1.Op != OpS390XMOVHZloadidx {
 33564				break
 33565			}
 33566			i1 := x1.AuxInt
 33567			s := x1.Aux
 33568			mem := x1.Args[2]
 33569			p := x1.Args[0]
 33570			idx := x1.Args[1]
 33571			sh := v.Args[1]
 33572			if sh.Op != OpS390XSLWconst {
 33573				break
 33574			}
 33575			if sh.AuxInt != 16 {
 33576				break
 33577			}
 33578			x0 := sh.Args[0]
 33579			if x0.Op != OpS390XMOVHZloadidx {
 33580				break
 33581			}
 33582			i0 := x0.AuxInt
 33583			if x0.Aux != s {
 33584				break
 33585			}
 33586			_ = x0.Args[2]
 33587			if idx != x0.Args[0] {
 33588				break
 33589			}
 33590			if p != x0.Args[1] {
 33591				break
 33592			}
 33593			if mem != x0.Args[2] {
 33594				break
 33595			}
 33596			if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 33597				break
 33598			}
 33599			b = mergePoint(b, x0, x1)
 33600			v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
 33601			v.reset(OpCopy)
 33602			v.AddArg(v0)
 33603			v0.AuxInt = i0
 33604			v0.Aux = s
 33605			v0.AddArg(p)
 33606			v0.AddArg(idx)
 33607			v0.AddArg(mem)
 33608			return true
 33609		}
 33610		// match: (ORW x1:(MOVHZloadidx [i1] {s} idx p mem) sh:(SLWconst [16] x0:(MOVHZloadidx [i0] {s} idx p mem)))
 33611		// cond: i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 33612		// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
 33613		for {
 33614			_ = v.Args[1]
 33615			x1 := v.Args[0]
 33616			if x1.Op != OpS390XMOVHZloadidx {
 33617				break
 33618			}
 33619			i1 := x1.AuxInt
 33620			s := x1.Aux
 33621			mem := x1.Args[2]
 33622			idx := x1.Args[0]
 33623			p := x1.Args[1]
 33624			sh := v.Args[1]
 33625			if sh.Op != OpS390XSLWconst {
 33626				break
 33627			}
 33628			if sh.AuxInt != 16 {
 33629				break
 33630			}
 33631			x0 := sh.Args[0]
 33632			if x0.Op != OpS390XMOVHZloadidx {
 33633				break
 33634			}
 33635			i0 := x0.AuxInt
 33636			if x0.Aux != s {
 33637				break
 33638			}
 33639			_ = x0.Args[2]
 33640			if idx != x0.Args[0] {
 33641				break
 33642			}
 33643			if p != x0.Args[1] {
 33644				break
 33645			}
 33646			if mem != x0.Args[2] {
 33647				break
 33648			}
 33649			if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 33650				break
 33651			}
 33652			b = mergePoint(b, x0, x1)
 33653			v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
 33654			v.reset(OpCopy)
 33655			v.AddArg(v0)
 33656			v0.AuxInt = i0
 33657			v0.Aux = s
 33658			v0.AddArg(p)
 33659			v0.AddArg(idx)
 33660			v0.AddArg(mem)
 33661			return true
 33662		}
 33663		// match: (ORW sh:(SLWconst [16] x0:(MOVHZloadidx [i0] {s} p idx mem)) x1:(MOVHZloadidx [i1] {s} p idx mem))
 33664		// cond: i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 33665		// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
 33666		for {
 33667			_ = v.Args[1]
 33668			sh := v.Args[0]
 33669			if sh.Op != OpS390XSLWconst {
 33670				break
 33671			}
 33672			if sh.AuxInt != 16 {
 33673				break
 33674			}
 33675			x0 := sh.Args[0]
 33676			if x0.Op != OpS390XMOVHZloadidx {
 33677				break
 33678			}
 33679			i0 := x0.AuxInt
 33680			s := x0.Aux
 33681			mem := x0.Args[2]
 33682			p := x0.Args[0]
 33683			idx := x0.Args[1]
 33684			x1 := v.Args[1]
 33685			if x1.Op != OpS390XMOVHZloadidx {
 33686				break
 33687			}
 33688			i1 := x1.AuxInt
 33689			if x1.Aux != s {
 33690				break
 33691			}
 33692			_ = x1.Args[2]
 33693			if p != x1.Args[0] {
 33694				break
 33695			}
 33696			if idx != x1.Args[1] {
 33697				break
 33698			}
 33699			if mem != x1.Args[2] {
 33700				break
 33701			}
 33702			if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 33703				break
 33704			}
 33705			b = mergePoint(b, x0, x1)
 33706			v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
 33707			v.reset(OpCopy)
 33708			v.AddArg(v0)
 33709			v0.AuxInt = i0
 33710			v0.Aux = s
 33711			v0.AddArg(p)
 33712			v0.AddArg(idx)
 33713			v0.AddArg(mem)
 33714			return true
 33715		}
 33716		// match: (ORW sh:(SLWconst [16] x0:(MOVHZloadidx [i0] {s} idx p mem)) x1:(MOVHZloadidx [i1] {s} p idx mem))
 33717		// cond: i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 33718		// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
 33719		for {
 33720			_ = v.Args[1]
 33721			sh := v.Args[0]
 33722			if sh.Op != OpS390XSLWconst {
 33723				break
 33724			}
 33725			if sh.AuxInt != 16 {
 33726				break
 33727			}
 33728			x0 := sh.Args[0]
 33729			if x0.Op != OpS390XMOVHZloadidx {
 33730				break
 33731			}
 33732			i0 := x0.AuxInt
 33733			s := x0.Aux
 33734			mem := x0.Args[2]
 33735			idx := x0.Args[0]
 33736			p := x0.Args[1]
 33737			x1 := v.Args[1]
 33738			if x1.Op != OpS390XMOVHZloadidx {
 33739				break
 33740			}
 33741			i1 := x1.AuxInt
 33742			if x1.Aux != s {
 33743				break
 33744			}
 33745			_ = x1.Args[2]
 33746			if p != x1.Args[0] {
 33747				break
 33748			}
 33749			if idx != x1.Args[1] {
 33750				break
 33751			}
 33752			if mem != x1.Args[2] {
 33753				break
 33754			}
 33755			if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 33756				break
 33757			}
 33758			b = mergePoint(b, x0, x1)
 33759			v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
 33760			v.reset(OpCopy)
 33761			v.AddArg(v0)
 33762			v0.AuxInt = i0
 33763			v0.Aux = s
 33764			v0.AddArg(p)
 33765			v0.AddArg(idx)
 33766			v0.AddArg(mem)
 33767			return true
 33768		}
 33769		// match: (ORW sh:(SLWconst [16] x0:(MOVHZloadidx [i0] {s} p idx mem)) x1:(MOVHZloadidx [i1] {s} idx p mem))
 33770		// cond: i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 33771		// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
 33772		for {
 33773			_ = v.Args[1]
 33774			sh := v.Args[0]
 33775			if sh.Op != OpS390XSLWconst {
 33776				break
 33777			}
 33778			if sh.AuxInt != 16 {
 33779				break
 33780			}
 33781			x0 := sh.Args[0]
 33782			if x0.Op != OpS390XMOVHZloadidx {
 33783				break
 33784			}
 33785			i0 := x0.AuxInt
 33786			s := x0.Aux
 33787			mem := x0.Args[2]
 33788			p := x0.Args[0]
 33789			idx := x0.Args[1]
 33790			x1 := v.Args[1]
 33791			if x1.Op != OpS390XMOVHZloadidx {
 33792				break
 33793			}
 33794			i1 := x1.AuxInt
 33795			if x1.Aux != s {
 33796				break
 33797			}
 33798			_ = x1.Args[2]
 33799			if idx != x1.Args[0] {
 33800				break
 33801			}
 33802			if p != x1.Args[1] {
 33803				break
 33804			}
 33805			if mem != x1.Args[2] {
 33806				break
 33807			}
 33808			if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 33809				break
 33810			}
 33811			b = mergePoint(b, x0, x1)
 33812			v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
 33813			v.reset(OpCopy)
 33814			v.AddArg(v0)
 33815			v0.AuxInt = i0
 33816			v0.Aux = s
 33817			v0.AddArg(p)
 33818			v0.AddArg(idx)
 33819			v0.AddArg(mem)
 33820			return true
 33821		}
 33822		// match: (ORW sh:(SLWconst [16] x0:(MOVHZloadidx [i0] {s} idx p mem)) x1:(MOVHZloadidx [i1] {s} idx p mem))
 33823		// cond: i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 33824		// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
 33825		for {
 33826			_ = v.Args[1]
 33827			sh := v.Args[0]
 33828			if sh.Op != OpS390XSLWconst {
 33829				break
 33830			}
 33831			if sh.AuxInt != 16 {
 33832				break
 33833			}
 33834			x0 := sh.Args[0]
 33835			if x0.Op != OpS390XMOVHZloadidx {
 33836				break
 33837			}
 33838			i0 := x0.AuxInt
 33839			s := x0.Aux
 33840			mem := x0.Args[2]
 33841			idx := x0.Args[0]
 33842			p := x0.Args[1]
 33843			x1 := v.Args[1]
 33844			if x1.Op != OpS390XMOVHZloadidx {
 33845				break
 33846			}
 33847			i1 := x1.AuxInt
 33848			if x1.Aux != s {
 33849				break
 33850			}
 33851			_ = x1.Args[2]
 33852			if idx != x1.Args[0] {
 33853				break
 33854			}
 33855			if p != x1.Args[1] {
 33856				break
 33857			}
 33858			if mem != x1.Args[2] {
 33859				break
 33860			}
 33861			if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 33862				break
 33863			}
 33864			b = mergePoint(b, x0, x1)
 33865			v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
 33866			v.reset(OpCopy)
 33867			v.AddArg(v0)
 33868			v0.AuxInt = i0
 33869			v0.Aux = s
 33870			v0.AddArg(p)
 33871			v0.AddArg(idx)
 33872			v0.AddArg(mem)
 33873			return true
 33874		}
 33875		// match: (ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) or:(ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)) y))
 33876		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 33877		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
 33878		for {
 33879			_ = v.Args[1]
 33880			s0 := v.Args[0]
 33881			if s0.Op != OpS390XSLWconst {
 33882				break
 33883			}
 33884			j0 := s0.AuxInt
 33885			x0 := s0.Args[0]
 33886			if x0.Op != OpS390XMOVBZloadidx {
 33887				break
 33888			}
 33889			i0 := x0.AuxInt
 33890			s := x0.Aux
 33891			mem := x0.Args[2]
 33892			p := x0.Args[0]
 33893			idx := x0.Args[1]
 33894			or := v.Args[1]
 33895			if or.Op != OpS390XORW {
 33896				break
 33897			}
 33898			y := or.Args[1]
 33899			s1 := or.Args[0]
 33900			if s1.Op != OpS390XSLWconst {
 33901				break
 33902			}
 33903			j1 := s1.AuxInt
 33904			x1 := s1.Args[0]
 33905			if x1.Op != OpS390XMOVBZloadidx {
 33906				break
 33907			}
 33908			i1 := x1.AuxInt
 33909			if x1.Aux != s {
 33910				break
 33911			}
 33912			_ = x1.Args[2]
 33913			if p != x1.Args[0] {
 33914				break
 33915			}
 33916			if idx != x1.Args[1] {
 33917				break
 33918			}
 33919			if mem != x1.Args[2] {
 33920				break
 33921			}
 33922			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 33923				break
 33924			}
 33925			b = mergePoint(b, x0, x1, y)
 33926			v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
 33927			v.reset(OpCopy)
 33928			v.AddArg(v0)
 33929			v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
 33930			v1.AuxInt = j1
 33931			v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 33932			v2.AuxInt = i0
 33933			v2.Aux = s
 33934			v2.AddArg(p)
 33935			v2.AddArg(idx)
 33936			v2.AddArg(mem)
 33937			v1.AddArg(v2)
 33938			v0.AddArg(v1)
 33939			v0.AddArg(y)
 33940			return true
 33941		}
 33942		// match: (ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) or:(ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)) y))
 33943		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 33944		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
 33945		for {
 33946			_ = v.Args[1]
 33947			s0 := v.Args[0]
 33948			if s0.Op != OpS390XSLWconst {
 33949				break
 33950			}
 33951			j0 := s0.AuxInt
 33952			x0 := s0.Args[0]
 33953			if x0.Op != OpS390XMOVBZloadidx {
 33954				break
 33955			}
 33956			i0 := x0.AuxInt
 33957			s := x0.Aux
 33958			mem := x0.Args[2]
 33959			idx := x0.Args[0]
 33960			p := x0.Args[1]
 33961			or := v.Args[1]
 33962			if or.Op != OpS390XORW {
 33963				break
 33964			}
 33965			y := or.Args[1]
 33966			s1 := or.Args[0]
 33967			if s1.Op != OpS390XSLWconst {
 33968				break
 33969			}
 33970			j1 := s1.AuxInt
 33971			x1 := s1.Args[0]
 33972			if x1.Op != OpS390XMOVBZloadidx {
 33973				break
 33974			}
 33975			i1 := x1.AuxInt
 33976			if x1.Aux != s {
 33977				break
 33978			}
 33979			_ = x1.Args[2]
 33980			if p != x1.Args[0] {
 33981				break
 33982			}
 33983			if idx != x1.Args[1] {
 33984				break
 33985			}
 33986			if mem != x1.Args[2] {
 33987				break
 33988			}
 33989			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 33990				break
 33991			}
 33992			b = mergePoint(b, x0, x1, y)
 33993			v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
 33994			v.reset(OpCopy)
 33995			v.AddArg(v0)
 33996			v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
 33997			v1.AuxInt = j1
 33998			v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 33999			v2.AuxInt = i0
 34000			v2.Aux = s
 34001			v2.AddArg(p)
 34002			v2.AddArg(idx)
 34003			v2.AddArg(mem)
 34004			v1.AddArg(v2)
 34005			v0.AddArg(v1)
 34006			v0.AddArg(y)
 34007			return true
 34008		}
 34009		// match: (ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) or:(ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) y))
 34010		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 34011		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
 34012		for {
 34013			_ = v.Args[1]
 34014			s0 := v.Args[0]
 34015			if s0.Op != OpS390XSLWconst {
 34016				break
 34017			}
 34018			j0 := s0.AuxInt
 34019			x0 := s0.Args[0]
 34020			if x0.Op != OpS390XMOVBZloadidx {
 34021				break
 34022			}
 34023			i0 := x0.AuxInt
 34024			s := x0.Aux
 34025			mem := x0.Args[2]
 34026			p := x0.Args[0]
 34027			idx := x0.Args[1]
 34028			or := v.Args[1]
 34029			if or.Op != OpS390XORW {
 34030				break
 34031			}
 34032			y := or.Args[1]
 34033			s1 := or.Args[0]
 34034			if s1.Op != OpS390XSLWconst {
 34035				break
 34036			}
 34037			j1 := s1.AuxInt
 34038			x1 := s1.Args[0]
 34039			if x1.Op != OpS390XMOVBZloadidx {
 34040				break
 34041			}
 34042			i1 := x1.AuxInt
 34043			if x1.Aux != s {
 34044				break
 34045			}
 34046			_ = x1.Args[2]
 34047			if idx != x1.Args[0] {
 34048				break
 34049			}
 34050			if p != x1.Args[1] {
 34051				break
 34052			}
 34053			if mem != x1.Args[2] {
 34054				break
 34055			}
 34056			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 34057				break
 34058			}
 34059			b = mergePoint(b, x0, x1, y)
 34060			v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
 34061			v.reset(OpCopy)
 34062			v.AddArg(v0)
 34063			v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
 34064			v1.AuxInt = j1
 34065			v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 34066			v2.AuxInt = i0
 34067			v2.Aux = s
 34068			v2.AddArg(p)
 34069			v2.AddArg(idx)
 34070			v2.AddArg(mem)
 34071			v1.AddArg(v2)
 34072			v0.AddArg(v1)
 34073			v0.AddArg(y)
 34074			return true
 34075		}
 34076		return false
 34077	}
 34078	func rewriteValueS390X_OpS390XORW_40(v *Value) bool {
 34079		b := v.Block
 34080		typ := &b.Func.Config.Types
 34081		// match: (ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) or:(ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) y))
 34082		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 34083		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
 34084		for {
 34085			_ = v.Args[1]
 34086			s0 := v.Args[0]
 34087			if s0.Op != OpS390XSLWconst {
 34088				break
 34089			}
 34090			j0 := s0.AuxInt
 34091			x0 := s0.Args[0]
 34092			if x0.Op != OpS390XMOVBZloadidx {
 34093				break
 34094			}
 34095			i0 := x0.AuxInt
 34096			s := x0.Aux
 34097			mem := x0.Args[2]
 34098			idx := x0.Args[0]
 34099			p := x0.Args[1]
 34100			or := v.Args[1]
 34101			if or.Op != OpS390XORW {
 34102				break
 34103			}
 34104			y := or.Args[1]
 34105			s1 := or.Args[0]
 34106			if s1.Op != OpS390XSLWconst {
 34107				break
 34108			}
 34109			j1 := s1.AuxInt
 34110			x1 := s1.Args[0]
 34111			if x1.Op != OpS390XMOVBZloadidx {
 34112				break
 34113			}
 34114			i1 := x1.AuxInt
 34115			if x1.Aux != s {
 34116				break
 34117			}
 34118			_ = x1.Args[2]
 34119			if idx != x1.Args[0] {
 34120				break
 34121			}
 34122			if p != x1.Args[1] {
 34123				break
 34124			}
 34125			if mem != x1.Args[2] {
 34126				break
 34127			}
 34128			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 34129				break
 34130			}
 34131			b = mergePoint(b, x0, x1, y)
 34132			v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
 34133			v.reset(OpCopy)
 34134			v.AddArg(v0)
 34135			v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
 34136			v1.AuxInt = j1
 34137			v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 34138			v2.AuxInt = i0
 34139			v2.Aux = s
 34140			v2.AddArg(p)
 34141			v2.AddArg(idx)
 34142			v2.AddArg(mem)
 34143			v1.AddArg(v2)
 34144			v0.AddArg(v1)
 34145			v0.AddArg(y)
 34146			return true
 34147		}
 34148		// match: (ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) or:(ORW y s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem))))
 34149		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 34150		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
 34151		for {
 34152			_ = v.Args[1]
 34153			s0 := v.Args[0]
 34154			if s0.Op != OpS390XSLWconst {
 34155				break
 34156			}
 34157			j0 := s0.AuxInt
 34158			x0 := s0.Args[0]
 34159			if x0.Op != OpS390XMOVBZloadidx {
 34160				break
 34161			}
 34162			i0 := x0.AuxInt
 34163			s := x0.Aux
 34164			mem := x0.Args[2]
 34165			p := x0.Args[0]
 34166			idx := x0.Args[1]
 34167			or := v.Args[1]
 34168			if or.Op != OpS390XORW {
 34169				break
 34170			}
 34171			_ = or.Args[1]
 34172			y := or.Args[0]
 34173			s1 := or.Args[1]
 34174			if s1.Op != OpS390XSLWconst {
 34175				break
 34176			}
 34177			j1 := s1.AuxInt
 34178			x1 := s1.Args[0]
 34179			if x1.Op != OpS390XMOVBZloadidx {
 34180				break
 34181			}
 34182			i1 := x1.AuxInt
 34183			if x1.Aux != s {
 34184				break
 34185			}
 34186			_ = x1.Args[2]
 34187			if p != x1.Args[0] {
 34188				break
 34189			}
 34190			if idx != x1.Args[1] {
 34191				break
 34192			}
 34193			if mem != x1.Args[2] {
 34194				break
 34195			}
 34196			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 34197				break
 34198			}
 34199			b = mergePoint(b, x0, x1, y)
 34200			v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
 34201			v.reset(OpCopy)
 34202			v.AddArg(v0)
 34203			v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
 34204			v1.AuxInt = j1
 34205			v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 34206			v2.AuxInt = i0
 34207			v2.Aux = s
 34208			v2.AddArg(p)
 34209			v2.AddArg(idx)
 34210			v2.AddArg(mem)
 34211			v1.AddArg(v2)
 34212			v0.AddArg(v1)
 34213			v0.AddArg(y)
 34214			return true
 34215		}
 34216		// match: (ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) or:(ORW y s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem))))
 34217		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 34218		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
 34219		for {
 34220			_ = v.Args[1]
 34221			s0 := v.Args[0]
 34222			if s0.Op != OpS390XSLWconst {
 34223				break
 34224			}
 34225			j0 := s0.AuxInt
 34226			x0 := s0.Args[0]
 34227			if x0.Op != OpS390XMOVBZloadidx {
 34228				break
 34229			}
 34230			i0 := x0.AuxInt
 34231			s := x0.Aux
 34232			mem := x0.Args[2]
 34233			idx := x0.Args[0]
 34234			p := x0.Args[1]
 34235			or := v.Args[1]
 34236			if or.Op != OpS390XORW {
 34237				break
 34238			}
 34239			_ = or.Args[1]
 34240			y := or.Args[0]
 34241			s1 := or.Args[1]
 34242			if s1.Op != OpS390XSLWconst {
 34243				break
 34244			}
 34245			j1 := s1.AuxInt
 34246			x1 := s1.Args[0]
 34247			if x1.Op != OpS390XMOVBZloadidx {
 34248				break
 34249			}
 34250			i1 := x1.AuxInt
 34251			if x1.Aux != s {
 34252				break
 34253			}
 34254			_ = x1.Args[2]
 34255			if p != x1.Args[0] {
 34256				break
 34257			}
 34258			if idx != x1.Args[1] {
 34259				break
 34260			}
 34261			if mem != x1.Args[2] {
 34262				break
 34263			}
 34264			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 34265				break
 34266			}
 34267			b = mergePoint(b, x0, x1, y)
 34268			v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
 34269			v.reset(OpCopy)
 34270			v.AddArg(v0)
 34271			v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
 34272			v1.AuxInt = j1
 34273			v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 34274			v2.AuxInt = i0
 34275			v2.Aux = s
 34276			v2.AddArg(p)
 34277			v2.AddArg(idx)
 34278			v2.AddArg(mem)
 34279			v1.AddArg(v2)
 34280			v0.AddArg(v1)
 34281			v0.AddArg(y)
 34282			return true
 34283		}
 34284		// match: (ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) or:(ORW y s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem))))
 34285		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 34286		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
 34287		for {
 34288			_ = v.Args[1]
 34289			s0 := v.Args[0]
 34290			if s0.Op != OpS390XSLWconst {
 34291				break
 34292			}
 34293			j0 := s0.AuxInt
 34294			x0 := s0.Args[0]
 34295			if x0.Op != OpS390XMOVBZloadidx {
 34296				break
 34297			}
 34298			i0 := x0.AuxInt
 34299			s := x0.Aux
 34300			mem := x0.Args[2]
 34301			p := x0.Args[0]
 34302			idx := x0.Args[1]
 34303			or := v.Args[1]
 34304			if or.Op != OpS390XORW {
 34305				break
 34306			}
 34307			_ = or.Args[1]
 34308			y := or.Args[0]
 34309			s1 := or.Args[1]
 34310			if s1.Op != OpS390XSLWconst {
 34311				break
 34312			}
 34313			j1 := s1.AuxInt
 34314			x1 := s1.Args[0]
 34315			if x1.Op != OpS390XMOVBZloadidx {
 34316				break
 34317			}
 34318			i1 := x1.AuxInt
 34319			if x1.Aux != s {
 34320				break
 34321			}
 34322			_ = x1.Args[2]
 34323			if idx != x1.Args[0] {
 34324				break
 34325			}
 34326			if p != x1.Args[1] {
 34327				break
 34328			}
 34329			if mem != x1.Args[2] {
 34330				break
 34331			}
 34332			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 34333				break
 34334			}
 34335			b = mergePoint(b, x0, x1, y)
 34336			v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
 34337			v.reset(OpCopy)
 34338			v.AddArg(v0)
 34339			v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
 34340			v1.AuxInt = j1
 34341			v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 34342			v2.AuxInt = i0
 34343			v2.Aux = s
 34344			v2.AddArg(p)
 34345			v2.AddArg(idx)
 34346			v2.AddArg(mem)
 34347			v1.AddArg(v2)
 34348			v0.AddArg(v1)
 34349			v0.AddArg(y)
 34350			return true
 34351		}
 34352		// match: (ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) or:(ORW y s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem))))
 34353		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 34354		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
 34355		for {
 34356			_ = v.Args[1]
 34357			s0 := v.Args[0]
 34358			if s0.Op != OpS390XSLWconst {
 34359				break
 34360			}
 34361			j0 := s0.AuxInt
 34362			x0 := s0.Args[0]
 34363			if x0.Op != OpS390XMOVBZloadidx {
 34364				break
 34365			}
 34366			i0 := x0.AuxInt
 34367			s := x0.Aux
 34368			mem := x0.Args[2]
 34369			idx := x0.Args[0]
 34370			p := x0.Args[1]
 34371			or := v.Args[1]
 34372			if or.Op != OpS390XORW {
 34373				break
 34374			}
 34375			_ = or.Args[1]
 34376			y := or.Args[0]
 34377			s1 := or.Args[1]
 34378			if s1.Op != OpS390XSLWconst {
 34379				break
 34380			}
 34381			j1 := s1.AuxInt
 34382			x1 := s1.Args[0]
 34383			if x1.Op != OpS390XMOVBZloadidx {
 34384				break
 34385			}
 34386			i1 := x1.AuxInt
 34387			if x1.Aux != s {
 34388				break
 34389			}
 34390			_ = x1.Args[2]
 34391			if idx != x1.Args[0] {
 34392				break
 34393			}
 34394			if p != x1.Args[1] {
 34395				break
 34396			}
 34397			if mem != x1.Args[2] {
 34398				break
 34399			}
 34400			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 34401				break
 34402			}
 34403			b = mergePoint(b, x0, x1, y)
 34404			v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
 34405			v.reset(OpCopy)
 34406			v.AddArg(v0)
 34407			v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
 34408			v1.AuxInt = j1
 34409			v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 34410			v2.AuxInt = i0
 34411			v2.Aux = s
 34412			v2.AddArg(p)
 34413			v2.AddArg(idx)
 34414			v2.AddArg(mem)
 34415			v1.AddArg(v2)
 34416			v0.AddArg(v1)
 34417			v0.AddArg(y)
 34418			return true
 34419		}
 34420		// match: (ORW or:(ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)) y) s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)))
 34421		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 34422		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
 34423		for {
 34424			_ = v.Args[1]
 34425			or := v.Args[0]
 34426			if or.Op != OpS390XORW {
 34427				break
 34428			}
 34429			y := or.Args[1]
 34430			s1 := or.Args[0]
 34431			if s1.Op != OpS390XSLWconst {
 34432				break
 34433			}
 34434			j1 := s1.AuxInt
 34435			x1 := s1.Args[0]
 34436			if x1.Op != OpS390XMOVBZloadidx {
 34437				break
 34438			}
 34439			i1 := x1.AuxInt
 34440			s := x1.Aux
 34441			mem := x1.Args[2]
 34442			p := x1.Args[0]
 34443			idx := x1.Args[1]
 34444			s0 := v.Args[1]
 34445			if s0.Op != OpS390XSLWconst {
 34446				break
 34447			}
 34448			j0 := s0.AuxInt
 34449			x0 := s0.Args[0]
 34450			if x0.Op != OpS390XMOVBZloadidx {
 34451				break
 34452			}
 34453			i0 := x0.AuxInt
 34454			if x0.Aux != s {
 34455				break
 34456			}
 34457			_ = x0.Args[2]
 34458			if p != x0.Args[0] {
 34459				break
 34460			}
 34461			if idx != x0.Args[1] {
 34462				break
 34463			}
 34464			if mem != x0.Args[2] {
 34465				break
 34466			}
 34467			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 34468				break
 34469			}
 34470			b = mergePoint(b, x0, x1, y)
 34471			v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
 34472			v.reset(OpCopy)
 34473			v.AddArg(v0)
 34474			v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
 34475			v1.AuxInt = j1
 34476			v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 34477			v2.AuxInt = i0
 34478			v2.Aux = s
 34479			v2.AddArg(p)
 34480			v2.AddArg(idx)
 34481			v2.AddArg(mem)
 34482			v1.AddArg(v2)
 34483			v0.AddArg(v1)
 34484			v0.AddArg(y)
 34485			return true
 34486		}
 34487		// match: (ORW or:(ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) y) s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)))
 34488		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 34489		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
 34490		for {
 34491			_ = v.Args[1]
 34492			or := v.Args[0]
 34493			if or.Op != OpS390XORW {
 34494				break
 34495			}
 34496			y := or.Args[1]
 34497			s1 := or.Args[0]
 34498			if s1.Op != OpS390XSLWconst {
 34499				break
 34500			}
 34501			j1 := s1.AuxInt
 34502			x1 := s1.Args[0]
 34503			if x1.Op != OpS390XMOVBZloadidx {
 34504				break
 34505			}
 34506			i1 := x1.AuxInt
 34507			s := x1.Aux
 34508			mem := x1.Args[2]
 34509			idx := x1.Args[0]
 34510			p := x1.Args[1]
 34511			s0 := v.Args[1]
 34512			if s0.Op != OpS390XSLWconst {
 34513				break
 34514			}
 34515			j0 := s0.AuxInt
 34516			x0 := s0.Args[0]
 34517			if x0.Op != OpS390XMOVBZloadidx {
 34518				break
 34519			}
 34520			i0 := x0.AuxInt
 34521			if x0.Aux != s {
 34522				break
 34523			}
 34524			_ = x0.Args[2]
 34525			if p != x0.Args[0] {
 34526				break
 34527			}
 34528			if idx != x0.Args[1] {
 34529				break
 34530			}
 34531			if mem != x0.Args[2] {
 34532				break
 34533			}
 34534			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 34535				break
 34536			}
 34537			b = mergePoint(b, x0, x1, y)
 34538			v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
 34539			v.reset(OpCopy)
 34540			v.AddArg(v0)
 34541			v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
 34542			v1.AuxInt = j1
 34543			v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 34544			v2.AuxInt = i0
 34545			v2.Aux = s
 34546			v2.AddArg(p)
 34547			v2.AddArg(idx)
 34548			v2.AddArg(mem)
 34549			v1.AddArg(v2)
 34550			v0.AddArg(v1)
 34551			v0.AddArg(y)
 34552			return true
 34553		}
 34554		// match: (ORW or:(ORW y s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem))) s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)))
 34555		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 34556		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
 34557		for {
 34558			_ = v.Args[1]
 34559			or := v.Args[0]
 34560			if or.Op != OpS390XORW {
 34561				break
 34562			}
 34563			_ = or.Args[1]
 34564			y := or.Args[0]
 34565			s1 := or.Args[1]
 34566			if s1.Op != OpS390XSLWconst {
 34567				break
 34568			}
 34569			j1 := s1.AuxInt
 34570			x1 := s1.Args[0]
 34571			if x1.Op != OpS390XMOVBZloadidx {
 34572				break
 34573			}
 34574			i1 := x1.AuxInt
 34575			s := x1.Aux
 34576			mem := x1.Args[2]
 34577			p := x1.Args[0]
 34578			idx := x1.Args[1]
 34579			s0 := v.Args[1]
 34580			if s0.Op != OpS390XSLWconst {
 34581				break
 34582			}
 34583			j0 := s0.AuxInt
 34584			x0 := s0.Args[0]
 34585			if x0.Op != OpS390XMOVBZloadidx {
 34586				break
 34587			}
 34588			i0 := x0.AuxInt
 34589			if x0.Aux != s {
 34590				break
 34591			}
 34592			_ = x0.Args[2]
 34593			if p != x0.Args[0] {
 34594				break
 34595			}
 34596			if idx != x0.Args[1] {
 34597				break
 34598			}
 34599			if mem != x0.Args[2] {
 34600				break
 34601			}
 34602			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 34603				break
 34604			}
 34605			b = mergePoint(b, x0, x1, y)
 34606			v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
 34607			v.reset(OpCopy)
 34608			v.AddArg(v0)
 34609			v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
 34610			v1.AuxInt = j1
 34611			v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 34612			v2.AuxInt = i0
 34613			v2.Aux = s
 34614			v2.AddArg(p)
 34615			v2.AddArg(idx)
 34616			v2.AddArg(mem)
 34617			v1.AddArg(v2)
 34618			v0.AddArg(v1)
 34619			v0.AddArg(y)
 34620			return true
 34621		}
 34622		// match: (ORW or:(ORW y s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem))) s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)))
 34623		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 34624		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
 34625		for {
 34626			_ = v.Args[1]
 34627			or := v.Args[0]
 34628			if or.Op != OpS390XORW {
 34629				break
 34630			}
 34631			_ = or.Args[1]
 34632			y := or.Args[0]
 34633			s1 := or.Args[1]
 34634			if s1.Op != OpS390XSLWconst {
 34635				break
 34636			}
 34637			j1 := s1.AuxInt
 34638			x1 := s1.Args[0]
 34639			if x1.Op != OpS390XMOVBZloadidx {
 34640				break
 34641			}
 34642			i1 := x1.AuxInt
 34643			s := x1.Aux
 34644			mem := x1.Args[2]
 34645			idx := x1.Args[0]
 34646			p := x1.Args[1]
 34647			s0 := v.Args[1]
 34648			if s0.Op != OpS390XSLWconst {
 34649				break
 34650			}
 34651			j0 := s0.AuxInt
 34652			x0 := s0.Args[0]
 34653			if x0.Op != OpS390XMOVBZloadidx {
 34654				break
 34655			}
 34656			i0 := x0.AuxInt
 34657			if x0.Aux != s {
 34658				break
 34659			}
 34660			_ = x0.Args[2]
 34661			if p != x0.Args[0] {
 34662				break
 34663			}
 34664			if idx != x0.Args[1] {
 34665				break
 34666			}
 34667			if mem != x0.Args[2] {
 34668				break
 34669			}
 34670			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 34671				break
 34672			}
 34673			b = mergePoint(b, x0, x1, y)
 34674			v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
 34675			v.reset(OpCopy)
 34676			v.AddArg(v0)
 34677			v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
 34678			v1.AuxInt = j1
 34679			v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 34680			v2.AuxInt = i0
 34681			v2.Aux = s
 34682			v2.AddArg(p)
 34683			v2.AddArg(idx)
 34684			v2.AddArg(mem)
 34685			v1.AddArg(v2)
 34686			v0.AddArg(v1)
 34687			v0.AddArg(y)
 34688			return true
 34689		}
 34690		// match: (ORW or:(ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)) y) s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)))
 34691		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 34692		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
 34693		for {
 34694			_ = v.Args[1]
 34695			or := v.Args[0]
 34696			if or.Op != OpS390XORW {
 34697				break
 34698			}
 34699			y := or.Args[1]
 34700			s1 := or.Args[0]
 34701			if s1.Op != OpS390XSLWconst {
 34702				break
 34703			}
 34704			j1 := s1.AuxInt
 34705			x1 := s1.Args[0]
 34706			if x1.Op != OpS390XMOVBZloadidx {
 34707				break
 34708			}
 34709			i1 := x1.AuxInt
 34710			s := x1.Aux
 34711			mem := x1.Args[2]
 34712			p := x1.Args[0]
 34713			idx := x1.Args[1]
 34714			s0 := v.Args[1]
 34715			if s0.Op != OpS390XSLWconst {
 34716				break
 34717			}
 34718			j0 := s0.AuxInt
 34719			x0 := s0.Args[0]
 34720			if x0.Op != OpS390XMOVBZloadidx {
 34721				break
 34722			}
 34723			i0 := x0.AuxInt
 34724			if x0.Aux != s {
 34725				break
 34726			}
 34727			_ = x0.Args[2]
 34728			if idx != x0.Args[0] {
 34729				break
 34730			}
 34731			if p != x0.Args[1] {
 34732				break
 34733			}
 34734			if mem != x0.Args[2] {
 34735				break
 34736			}
 34737			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 34738				break
 34739			}
 34740			b = mergePoint(b, x0, x1, y)
 34741			v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
 34742			v.reset(OpCopy)
 34743			v.AddArg(v0)
 34744			v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
 34745			v1.AuxInt = j1
 34746			v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 34747			v2.AuxInt = i0
 34748			v2.Aux = s
 34749			v2.AddArg(p)
 34750			v2.AddArg(idx)
 34751			v2.AddArg(mem)
 34752			v1.AddArg(v2)
 34753			v0.AddArg(v1)
 34754			v0.AddArg(y)
 34755			return true
 34756		}
 34757		return false
 34758	}
 34759	func rewriteValueS390X_OpS390XORW_50(v *Value) bool {
 34760		b := v.Block
 34761		typ := &b.Func.Config.Types
 34762		// match: (ORW or:(ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) y) s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)))
 34763		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 34764		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
 34765		for {
 34766			_ = v.Args[1]
 34767			or := v.Args[0]
 34768			if or.Op != OpS390XORW {
 34769				break
 34770			}
 34771			y := or.Args[1]
 34772			s1 := or.Args[0]
 34773			if s1.Op != OpS390XSLWconst {
 34774				break
 34775			}
 34776			j1 := s1.AuxInt
 34777			x1 := s1.Args[0]
 34778			if x1.Op != OpS390XMOVBZloadidx {
 34779				break
 34780			}
 34781			i1 := x1.AuxInt
 34782			s := x1.Aux
 34783			mem := x1.Args[2]
 34784			idx := x1.Args[0]
 34785			p := x1.Args[1]
 34786			s0 := v.Args[1]
 34787			if s0.Op != OpS390XSLWconst {
 34788				break
 34789			}
 34790			j0 := s0.AuxInt
 34791			x0 := s0.Args[0]
 34792			if x0.Op != OpS390XMOVBZloadidx {
 34793				break
 34794			}
 34795			i0 := x0.AuxInt
 34796			if x0.Aux != s {
 34797				break
 34798			}
 34799			_ = x0.Args[2]
 34800			if idx != x0.Args[0] {
 34801				break
 34802			}
 34803			if p != x0.Args[1] {
 34804				break
 34805			}
 34806			if mem != x0.Args[2] {
 34807				break
 34808			}
 34809			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 34810				break
 34811			}
 34812			b = mergePoint(b, x0, x1, y)
 34813			v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
 34814			v.reset(OpCopy)
 34815			v.AddArg(v0)
 34816			v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
 34817			v1.AuxInt = j1
 34818			v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 34819			v2.AuxInt = i0
 34820			v2.Aux = s
 34821			v2.AddArg(p)
 34822			v2.AddArg(idx)
 34823			v2.AddArg(mem)
 34824			v1.AddArg(v2)
 34825			v0.AddArg(v1)
 34826			v0.AddArg(y)
 34827			return true
 34828		}
 34829		// match: (ORW or:(ORW y s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem))) s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)))
 34830		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 34831		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
 34832		for {
 34833			_ = v.Args[1]
 34834			or := v.Args[0]
 34835			if or.Op != OpS390XORW {
 34836				break
 34837			}
 34838			_ = or.Args[1]
 34839			y := or.Args[0]
 34840			s1 := or.Args[1]
 34841			if s1.Op != OpS390XSLWconst {
 34842				break
 34843			}
 34844			j1 := s1.AuxInt
 34845			x1 := s1.Args[0]
 34846			if x1.Op != OpS390XMOVBZloadidx {
 34847				break
 34848			}
 34849			i1 := x1.AuxInt
 34850			s := x1.Aux
 34851			mem := x1.Args[2]
 34852			p := x1.Args[0]
 34853			idx := x1.Args[1]
 34854			s0 := v.Args[1]
 34855			if s0.Op != OpS390XSLWconst {
 34856				break
 34857			}
 34858			j0 := s0.AuxInt
 34859			x0 := s0.Args[0]
 34860			if x0.Op != OpS390XMOVBZloadidx {
 34861				break
 34862			}
 34863			i0 := x0.AuxInt
 34864			if x0.Aux != s {
 34865				break
 34866			}
 34867			_ = x0.Args[2]
 34868			if idx != x0.Args[0] {
 34869				break
 34870			}
 34871			if p != x0.Args[1] {
 34872				break
 34873			}
 34874			if mem != x0.Args[2] {
 34875				break
 34876			}
 34877			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 34878				break
 34879			}
 34880			b = mergePoint(b, x0, x1, y)
 34881			v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
 34882			v.reset(OpCopy)
 34883			v.AddArg(v0)
 34884			v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
 34885			v1.AuxInt = j1
 34886			v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 34887			v2.AuxInt = i0
 34888			v2.Aux = s
 34889			v2.AddArg(p)
 34890			v2.AddArg(idx)
 34891			v2.AddArg(mem)
 34892			v1.AddArg(v2)
 34893			v0.AddArg(v1)
 34894			v0.AddArg(y)
 34895			return true
 34896		}
 34897		// match: (ORW or:(ORW y s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem))) s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)))
 34898		// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 34899		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
 34900		for {
 34901			_ = v.Args[1]
 34902			or := v.Args[0]
 34903			if or.Op != OpS390XORW {
 34904				break
 34905			}
 34906			_ = or.Args[1]
 34907			y := or.Args[0]
 34908			s1 := or.Args[1]
 34909			if s1.Op != OpS390XSLWconst {
 34910				break
 34911			}
 34912			j1 := s1.AuxInt
 34913			x1 := s1.Args[0]
 34914			if x1.Op != OpS390XMOVBZloadidx {
 34915				break
 34916			}
 34917			i1 := x1.AuxInt
 34918			s := x1.Aux
 34919			mem := x1.Args[2]
 34920			idx := x1.Args[0]
 34921			p := x1.Args[1]
 34922			s0 := v.Args[1]
 34923			if s0.Op != OpS390XSLWconst {
 34924				break
 34925			}
 34926			j0 := s0.AuxInt
 34927			x0 := s0.Args[0]
 34928			if x0.Op != OpS390XMOVBZloadidx {
 34929				break
 34930			}
 34931			i0 := x0.AuxInt
 34932			if x0.Aux != s {
 34933				break
 34934			}
 34935			_ = x0.Args[2]
 34936			if idx != x0.Args[0] {
 34937				break
 34938			}
 34939			if p != x0.Args[1] {
 34940				break
 34941			}
 34942			if mem != x0.Args[2] {
 34943				break
 34944			}
 34945			if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 34946				break
 34947			}
 34948			b = mergePoint(b, x0, x1, y)
 34949			v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
 34950			v.reset(OpCopy)
 34951			v.AddArg(v0)
 34952			v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
 34953			v1.AuxInt = j1
 34954			v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
 34955			v2.AuxInt = i0
 34956			v2.Aux = s
 34957			v2.AddArg(p)
 34958			v2.AddArg(idx)
 34959			v2.AddArg(mem)
 34960			v1.AddArg(v2)
 34961			v0.AddArg(v1)
 34962			v0.AddArg(y)
 34963			return true
 34964		}
 34965		// match: (ORW x0:(MOVBZload [i0] {s} p mem) sh:(SLWconst [8] x1:(MOVBZload [i1] {s} p mem)))
 34966		// cond: p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 34967		// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRload [i0] {s} p mem))
 34968		for {
 34969			_ = v.Args[1]
 34970			x0 := v.Args[0]
 34971			if x0.Op != OpS390XMOVBZload {
 34972				break
 34973			}
 34974			i0 := x0.AuxInt
 34975			s := x0.Aux
 34976			mem := x0.Args[1]
 34977			p := x0.Args[0]
 34978			sh := v.Args[1]
 34979			if sh.Op != OpS390XSLWconst {
 34980				break
 34981			}
 34982			if sh.AuxInt != 8 {
 34983				break
 34984			}
 34985			x1 := sh.Args[0]
 34986			if x1.Op != OpS390XMOVBZload {
 34987				break
 34988			}
 34989			i1 := x1.AuxInt
 34990			if x1.Aux != s {
 34991				break
 34992			}
 34993			_ = x1.Args[1]
 34994			if p != x1.Args[0] {
 34995				break
 34996			}
 34997			if mem != x1.Args[1] {
 34998				break
 34999			}
 35000			if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 35001				break
 35002			}
 35003			b = mergePoint(b, x0, x1)
 35004			v0 := b.NewValue0(x1.Pos, OpS390XMOVHZreg, typ.UInt64)
 35005			v.reset(OpCopy)
 35006			v.AddArg(v0)
 35007			v1 := b.NewValue0(x1.Pos, OpS390XMOVHBRload, typ.UInt16)
 35008			v1.AuxInt = i0
 35009			v1.Aux = s
 35010			v1.AddArg(p)
 35011			v1.AddArg(mem)
 35012			v0.AddArg(v1)
 35013			return true
 35014		}
 35015		// match: (ORW sh:(SLWconst [8] x1:(MOVBZload [i1] {s} p mem)) x0:(MOVBZload [i0] {s} p mem))
 35016		// cond: p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 35017		// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRload [i0] {s} p mem))
 35018		for {
 35019			_ = v.Args[1]
 35020			sh := v.Args[0]
 35021			if sh.Op != OpS390XSLWconst {
 35022				break
 35023			}
 35024			if sh.AuxInt != 8 {
 35025				break
 35026			}
 35027			x1 := sh.Args[0]
 35028			if x1.Op != OpS390XMOVBZload {
 35029				break
 35030			}
 35031			i1 := x1.AuxInt
 35032			s := x1.Aux
 35033			mem := x1.Args[1]
 35034			p := x1.Args[0]
 35035			x0 := v.Args[1]
 35036			if x0.Op != OpS390XMOVBZload {
 35037				break
 35038			}
 35039			i0 := x0.AuxInt
 35040			if x0.Aux != s {
 35041				break
 35042			}
 35043			_ = x0.Args[1]
 35044			if p != x0.Args[0] {
 35045				break
 35046			}
 35047			if mem != x0.Args[1] {
 35048				break
 35049			}
 35050			if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 35051				break
 35052			}
 35053			b = mergePoint(b, x0, x1)
 35054			v0 := b.NewValue0(x0.Pos, OpS390XMOVHZreg, typ.UInt64)
 35055			v.reset(OpCopy)
 35056			v.AddArg(v0)
 35057			v1 := b.NewValue0(x0.Pos, OpS390XMOVHBRload, typ.UInt16)
 35058			v1.AuxInt = i0
 35059			v1.Aux = s
 35060			v1.AddArg(p)
 35061			v1.AddArg(mem)
 35062			v0.AddArg(v1)
 35063			return true
 35064		}
 35065		// match: (ORW r0:(MOVHZreg x0:(MOVHBRload [i0] {s} p mem)) sh:(SLWconst [16] r1:(MOVHZreg x1:(MOVHBRload [i1] {s} p mem))))
 35066		// cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
 35067		// result: @mergePoint(b,x0,x1) (MOVWBRload [i0] {s} p mem)
 35068		for {
 35069			_ = v.Args[1]
 35070			r0 := v.Args[0]
 35071			if r0.Op != OpS390XMOVHZreg {
 35072				break
 35073			}
 35074			x0 := r0.Args[0]
 35075			if x0.Op != OpS390XMOVHBRload {
 35076				break
 35077			}
 35078			i0 := x0.AuxInt
 35079			s := x0.Aux
 35080			mem := x0.Args[1]
 35081			p := x0.Args[0]
 35082			sh := v.Args[1]
 35083			if sh.Op != OpS390XSLWconst {
 35084				break
 35085			}
 35086			if sh.AuxInt != 16 {
 35087				break
 35088			}
 35089			r1 := sh.Args[0]
 35090			if r1.Op != OpS390XMOVHZreg {
 35091				break
 35092			}
 35093			x1 := r1.Args[0]
 35094			if x1.Op != OpS390XMOVHBRload {
 35095				break
 35096			}
 35097			i1 := x1.AuxInt
 35098			if x1.Aux != s {
 35099				break
 35100			}
 35101			_ = x1.Args[1]
 35102			if p != x1.Args[0] {
 35103				break
 35104			}
 35105			if mem != x1.Args[1] {
 35106				break
 35107			}
 35108			if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
 35109				break
 35110			}
 35111			b = mergePoint(b, x0, x1)
 35112			v0 := b.NewValue0(x1.Pos, OpS390XMOVWBRload, typ.UInt32)
 35113			v.reset(OpCopy)
 35114			v.AddArg(v0)
 35115			v0.AuxInt = i0
 35116			v0.Aux = s
 35117			v0.AddArg(p)
 35118			v0.AddArg(mem)
 35119			return true
 35120		}
 35121		// match: (ORW sh:(SLWconst [16] r1:(MOVHZreg x1:(MOVHBRload [i1] {s} p mem))) r0:(MOVHZreg x0:(MOVHBRload [i0] {s} p mem)))
 35122		// cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
 35123		// result: @mergePoint(b,x0,x1) (MOVWBRload [i0] {s} p mem)
 35124		for {
 35125			_ = v.Args[1]
 35126			sh := v.Args[0]
 35127			if sh.Op != OpS390XSLWconst {
 35128				break
 35129			}
 35130			if sh.AuxInt != 16 {
 35131				break
 35132			}
 35133			r1 := sh.Args[0]
 35134			if r1.Op != OpS390XMOVHZreg {
 35135				break
 35136			}
 35137			x1 := r1.Args[0]
 35138			if x1.Op != OpS390XMOVHBRload {
 35139				break
 35140			}
 35141			i1 := x1.AuxInt
 35142			s := x1.Aux
 35143			mem := x1.Args[1]
 35144			p := x1.Args[0]
 35145			r0 := v.Args[1]
 35146			if r0.Op != OpS390XMOVHZreg {
 35147				break
 35148			}
 35149			x0 := r0.Args[0]
 35150			if x0.Op != OpS390XMOVHBRload {
 35151				break
 35152			}
 35153			i0 := x0.AuxInt
 35154			if x0.Aux != s {
 35155				break
 35156			}
 35157			_ = x0.Args[1]
 35158			if p != x0.Args[0] {
 35159				break
 35160			}
 35161			if mem != x0.Args[1] {
 35162				break
 35163			}
 35164			if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
 35165				break
 35166			}
 35167			b = mergePoint(b, x0, x1)
 35168			v0 := b.NewValue0(x0.Pos, OpS390XMOVWBRload, typ.UInt32)
 35169			v.reset(OpCopy)
 35170			v.AddArg(v0)
 35171			v0.AuxInt = i0
 35172			v0.Aux = s
 35173			v0.AddArg(p)
 35174			v0.AddArg(mem)
 35175			return true
 35176		}
 35177		// match: (ORW s1:(SLWconst [j1] x1:(MOVBZload [i1] {s} p mem)) or:(ORW s0:(SLWconst [j0] x0:(MOVBZload [i0] {s} p mem)) y))
 35178		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 35179		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRload [i0] {s} p mem))) y)
 35180		for {
 35181			_ = v.Args[1]
 35182			s1 := v.Args[0]
 35183			if s1.Op != OpS390XSLWconst {
 35184				break
 35185			}
 35186			j1 := s1.AuxInt
 35187			x1 := s1.Args[0]
 35188			if x1.Op != OpS390XMOVBZload {
 35189				break
 35190			}
 35191			i1 := x1.AuxInt
 35192			s := x1.Aux
 35193			mem := x1.Args[1]
 35194			p := x1.Args[0]
 35195			or := v.Args[1]
 35196			if or.Op != OpS390XORW {
 35197				break
 35198			}
 35199			y := or.Args[1]
 35200			s0 := or.Args[0]
 35201			if s0.Op != OpS390XSLWconst {
 35202				break
 35203			}
 35204			j0 := s0.AuxInt
 35205			x0 := s0.Args[0]
 35206			if x0.Op != OpS390XMOVBZload {
 35207				break
 35208			}
 35209			i0 := x0.AuxInt
 35210			if x0.Aux != s {
 35211				break
 35212			}
 35213			_ = x0.Args[1]
 35214			if p != x0.Args[0] {
 35215				break
 35216			}
 35217			if mem != x0.Args[1] {
 35218				break
 35219			}
 35220			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 35221				break
 35222			}
 35223			b = mergePoint(b, x0, x1, y)
 35224			v0 := b.NewValue0(x0.Pos, OpS390XORW, v.Type)
 35225			v.reset(OpCopy)
 35226			v.AddArg(v0)
 35227			v1 := b.NewValue0(x0.Pos, OpS390XSLWconst, v.Type)
 35228			v1.AuxInt = j0
 35229			v2 := b.NewValue0(x0.Pos, OpS390XMOVHZreg, typ.UInt64)
 35230			v3 := b.NewValue0(x0.Pos, OpS390XMOVHBRload, typ.UInt16)
 35231			v3.AuxInt = i0
 35232			v3.Aux = s
 35233			v3.AddArg(p)
 35234			v3.AddArg(mem)
 35235			v2.AddArg(v3)
 35236			v1.AddArg(v2)
 35237			v0.AddArg(v1)
 35238			v0.AddArg(y)
 35239			return true
 35240		}
 35241		// match: (ORW s1:(SLWconst [j1] x1:(MOVBZload [i1] {s} p mem)) or:(ORW y s0:(SLWconst [j0] x0:(MOVBZload [i0] {s} p mem))))
 35242		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 35243		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRload [i0] {s} p mem))) y)
 35244		for {
 35245			_ = v.Args[1]
 35246			s1 := v.Args[0]
 35247			if s1.Op != OpS390XSLWconst {
 35248				break
 35249			}
 35250			j1 := s1.AuxInt
 35251			x1 := s1.Args[0]
 35252			if x1.Op != OpS390XMOVBZload {
 35253				break
 35254			}
 35255			i1 := x1.AuxInt
 35256			s := x1.Aux
 35257			mem := x1.Args[1]
 35258			p := x1.Args[0]
 35259			or := v.Args[1]
 35260			if or.Op != OpS390XORW {
 35261				break
 35262			}
 35263			_ = or.Args[1]
 35264			y := or.Args[0]
 35265			s0 := or.Args[1]
 35266			if s0.Op != OpS390XSLWconst {
 35267				break
 35268			}
 35269			j0 := s0.AuxInt
 35270			x0 := s0.Args[0]
 35271			if x0.Op != OpS390XMOVBZload {
 35272				break
 35273			}
 35274			i0 := x0.AuxInt
 35275			if x0.Aux != s {
 35276				break
 35277			}
 35278			_ = x0.Args[1]
 35279			if p != x0.Args[0] {
 35280				break
 35281			}
 35282			if mem != x0.Args[1] {
 35283				break
 35284			}
 35285			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 35286				break
 35287			}
 35288			b = mergePoint(b, x0, x1, y)
 35289			v0 := b.NewValue0(x0.Pos, OpS390XORW, v.Type)
 35290			v.reset(OpCopy)
 35291			v.AddArg(v0)
 35292			v1 := b.NewValue0(x0.Pos, OpS390XSLWconst, v.Type)
 35293			v1.AuxInt = j0
 35294			v2 := b.NewValue0(x0.Pos, OpS390XMOVHZreg, typ.UInt64)
 35295			v3 := b.NewValue0(x0.Pos, OpS390XMOVHBRload, typ.UInt16)
 35296			v3.AuxInt = i0
 35297			v3.Aux = s
 35298			v3.AddArg(p)
 35299			v3.AddArg(mem)
 35300			v2.AddArg(v3)
 35301			v1.AddArg(v2)
 35302			v0.AddArg(v1)
 35303			v0.AddArg(y)
 35304			return true
 35305		}
 35306		// match: (ORW or:(ORW s0:(SLWconst [j0] x0:(MOVBZload [i0] {s} p mem)) y) s1:(SLWconst [j1] x1:(MOVBZload [i1] {s} p mem)))
 35307		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 35308		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRload [i0] {s} p mem))) y)
 35309		for {
 35310			_ = v.Args[1]
 35311			or := v.Args[0]
 35312			if or.Op != OpS390XORW {
 35313				break
 35314			}
 35315			y := or.Args[1]
 35316			s0 := or.Args[0]
 35317			if s0.Op != OpS390XSLWconst {
 35318				break
 35319			}
 35320			j0 := s0.AuxInt
 35321			x0 := s0.Args[0]
 35322			if x0.Op != OpS390XMOVBZload {
 35323				break
 35324			}
 35325			i0 := x0.AuxInt
 35326			s := x0.Aux
 35327			mem := x0.Args[1]
 35328			p := x0.Args[0]
 35329			s1 := v.Args[1]
 35330			if s1.Op != OpS390XSLWconst {
 35331				break
 35332			}
 35333			j1 := s1.AuxInt
 35334			x1 := s1.Args[0]
 35335			if x1.Op != OpS390XMOVBZload {
 35336				break
 35337			}
 35338			i1 := x1.AuxInt
 35339			if x1.Aux != s {
 35340				break
 35341			}
 35342			_ = x1.Args[1]
 35343			if p != x1.Args[0] {
 35344				break
 35345			}
 35346			if mem != x1.Args[1] {
 35347				break
 35348			}
 35349			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 35350				break
 35351			}
 35352			b = mergePoint(b, x0, x1, y)
 35353			v0 := b.NewValue0(x1.Pos, OpS390XORW, v.Type)
 35354			v.reset(OpCopy)
 35355			v.AddArg(v0)
 35356			v1 := b.NewValue0(x1.Pos, OpS390XSLWconst, v.Type)
 35357			v1.AuxInt = j0
 35358			v2 := b.NewValue0(x1.Pos, OpS390XMOVHZreg, typ.UInt64)
 35359			v3 := b.NewValue0(x1.Pos, OpS390XMOVHBRload, typ.UInt16)
 35360			v3.AuxInt = i0
 35361			v3.Aux = s
 35362			v3.AddArg(p)
 35363			v3.AddArg(mem)
 35364			v2.AddArg(v3)
 35365			v1.AddArg(v2)
 35366			v0.AddArg(v1)
 35367			v0.AddArg(y)
 35368			return true
 35369		}
 35370		return false
 35371	}
 35372	func rewriteValueS390X_OpS390XORW_60(v *Value) bool {
 35373		b := v.Block
 35374		typ := &b.Func.Config.Types
 35375		// match: (ORW or:(ORW y s0:(SLWconst [j0] x0:(MOVBZload [i0] {s} p mem))) s1:(SLWconst [j1] x1:(MOVBZload [i1] {s} p mem)))
 35376		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 35377		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRload [i0] {s} p mem))) y)
 35378		for {
 35379			_ = v.Args[1]
 35380			or := v.Args[0]
 35381			if or.Op != OpS390XORW {
 35382				break
 35383			}
 35384			_ = or.Args[1]
 35385			y := or.Args[0]
 35386			s0 := or.Args[1]
 35387			if s0.Op != OpS390XSLWconst {
 35388				break
 35389			}
 35390			j0 := s0.AuxInt
 35391			x0 := s0.Args[0]
 35392			if x0.Op != OpS390XMOVBZload {
 35393				break
 35394			}
 35395			i0 := x0.AuxInt
 35396			s := x0.Aux
 35397			mem := x0.Args[1]
 35398			p := x0.Args[0]
 35399			s1 := v.Args[1]
 35400			if s1.Op != OpS390XSLWconst {
 35401				break
 35402			}
 35403			j1 := s1.AuxInt
 35404			x1 := s1.Args[0]
 35405			if x1.Op != OpS390XMOVBZload {
 35406				break
 35407			}
 35408			i1 := x1.AuxInt
 35409			if x1.Aux != s {
 35410				break
 35411			}
 35412			_ = x1.Args[1]
 35413			if p != x1.Args[0] {
 35414				break
 35415			}
 35416			if mem != x1.Args[1] {
 35417				break
 35418			}
 35419			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 35420				break
 35421			}
 35422			b = mergePoint(b, x0, x1, y)
 35423			v0 := b.NewValue0(x1.Pos, OpS390XORW, v.Type)
 35424			v.reset(OpCopy)
 35425			v.AddArg(v0)
 35426			v1 := b.NewValue0(x1.Pos, OpS390XSLWconst, v.Type)
 35427			v1.AuxInt = j0
 35428			v2 := b.NewValue0(x1.Pos, OpS390XMOVHZreg, typ.UInt64)
 35429			v3 := b.NewValue0(x1.Pos, OpS390XMOVHBRload, typ.UInt16)
 35430			v3.AuxInt = i0
 35431			v3.Aux = s
 35432			v3.AddArg(p)
 35433			v3.AddArg(mem)
 35434			v2.AddArg(v3)
 35435			v1.AddArg(v2)
 35436			v0.AddArg(v1)
 35437			v0.AddArg(y)
 35438			return true
 35439		}
 35440		// match: (ORW x0:(MOVBZloadidx [i0] {s} p idx mem) sh:(SLWconst [8] x1:(MOVBZloadidx [i1] {s} p idx mem)))
 35441		// cond: p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 35442		// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))
 35443		for {
 35444			_ = v.Args[1]
 35445			x0 := v.Args[0]
 35446			if x0.Op != OpS390XMOVBZloadidx {
 35447				break
 35448			}
 35449			i0 := x0.AuxInt
 35450			s := x0.Aux
 35451			mem := x0.Args[2]
 35452			p := x0.Args[0]
 35453			idx := x0.Args[1]
 35454			sh := v.Args[1]
 35455			if sh.Op != OpS390XSLWconst {
 35456				break
 35457			}
 35458			if sh.AuxInt != 8 {
 35459				break
 35460			}
 35461			x1 := sh.Args[0]
 35462			if x1.Op != OpS390XMOVBZloadidx {
 35463				break
 35464			}
 35465			i1 := x1.AuxInt
 35466			if x1.Aux != s {
 35467				break
 35468			}
 35469			_ = x1.Args[2]
 35470			if p != x1.Args[0] {
 35471				break
 35472			}
 35473			if idx != x1.Args[1] {
 35474				break
 35475			}
 35476			if mem != x1.Args[2] {
 35477				break
 35478			}
 35479			if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 35480				break
 35481			}
 35482			b = mergePoint(b, x0, x1)
 35483			v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 35484			v.reset(OpCopy)
 35485			v.AddArg(v0)
 35486			v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 35487			v1.AuxInt = i0
 35488			v1.Aux = s
 35489			v1.AddArg(p)
 35490			v1.AddArg(idx)
 35491			v1.AddArg(mem)
 35492			v0.AddArg(v1)
 35493			return true
 35494		}
 35495		// match: (ORW x0:(MOVBZloadidx [i0] {s} idx p mem) sh:(SLWconst [8] x1:(MOVBZloadidx [i1] {s} p idx mem)))
 35496		// cond: p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 35497		// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))
 35498		for {
 35499			_ = v.Args[1]
 35500			x0 := v.Args[0]
 35501			if x0.Op != OpS390XMOVBZloadidx {
 35502				break
 35503			}
 35504			i0 := x0.AuxInt
 35505			s := x0.Aux
 35506			mem := x0.Args[2]
 35507			idx := x0.Args[0]
 35508			p := x0.Args[1]
 35509			sh := v.Args[1]
 35510			if sh.Op != OpS390XSLWconst {
 35511				break
 35512			}
 35513			if sh.AuxInt != 8 {
 35514				break
 35515			}
 35516			x1 := sh.Args[0]
 35517			if x1.Op != OpS390XMOVBZloadidx {
 35518				break
 35519			}
 35520			i1 := x1.AuxInt
 35521			if x1.Aux != s {
 35522				break
 35523			}
 35524			_ = x1.Args[2]
 35525			if p != x1.Args[0] {
 35526				break
 35527			}
 35528			if idx != x1.Args[1] {
 35529				break
 35530			}
 35531			if mem != x1.Args[2] {
 35532				break
 35533			}
 35534			if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 35535				break
 35536			}
 35537			b = mergePoint(b, x0, x1)
 35538			v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 35539			v.reset(OpCopy)
 35540			v.AddArg(v0)
 35541			v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 35542			v1.AuxInt = i0
 35543			v1.Aux = s
 35544			v1.AddArg(p)
 35545			v1.AddArg(idx)
 35546			v1.AddArg(mem)
 35547			v0.AddArg(v1)
 35548			return true
 35549		}
 35550		// match: (ORW x0:(MOVBZloadidx [i0] {s} p idx mem) sh:(SLWconst [8] x1:(MOVBZloadidx [i1] {s} idx p mem)))
 35551		// cond: p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 35552		// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))
 35553		for {
 35554			_ = v.Args[1]
 35555			x0 := v.Args[0]
 35556			if x0.Op != OpS390XMOVBZloadidx {
 35557				break
 35558			}
 35559			i0 := x0.AuxInt
 35560			s := x0.Aux
 35561			mem := x0.Args[2]
 35562			p := x0.Args[0]
 35563			idx := x0.Args[1]
 35564			sh := v.Args[1]
 35565			if sh.Op != OpS390XSLWconst {
 35566				break
 35567			}
 35568			if sh.AuxInt != 8 {
 35569				break
 35570			}
 35571			x1 := sh.Args[0]
 35572			if x1.Op != OpS390XMOVBZloadidx {
 35573				break
 35574			}
 35575			i1 := x1.AuxInt
 35576			if x1.Aux != s {
 35577				break
 35578			}
 35579			_ = x1.Args[2]
 35580			if idx != x1.Args[0] {
 35581				break
 35582			}
 35583			if p != x1.Args[1] {
 35584				break
 35585			}
 35586			if mem != x1.Args[2] {
 35587				break
 35588			}
 35589			if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 35590				break
 35591			}
 35592			b = mergePoint(b, x0, x1)
 35593			v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 35594			v.reset(OpCopy)
 35595			v.AddArg(v0)
 35596			v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 35597			v1.AuxInt = i0
 35598			v1.Aux = s
 35599			v1.AddArg(p)
 35600			v1.AddArg(idx)
 35601			v1.AddArg(mem)
 35602			v0.AddArg(v1)
 35603			return true
 35604		}
 35605		// match: (ORW x0:(MOVBZloadidx [i0] {s} idx p mem) sh:(SLWconst [8] x1:(MOVBZloadidx [i1] {s} idx p mem)))
 35606		// cond: p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 35607		// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))
 35608		for {
 35609			_ = v.Args[1]
 35610			x0 := v.Args[0]
 35611			if x0.Op != OpS390XMOVBZloadidx {
 35612				break
 35613			}
 35614			i0 := x0.AuxInt
 35615			s := x0.Aux
 35616			mem := x0.Args[2]
 35617			idx := x0.Args[0]
 35618			p := x0.Args[1]
 35619			sh := v.Args[1]
 35620			if sh.Op != OpS390XSLWconst {
 35621				break
 35622			}
 35623			if sh.AuxInt != 8 {
 35624				break
 35625			}
 35626			x1 := sh.Args[0]
 35627			if x1.Op != OpS390XMOVBZloadidx {
 35628				break
 35629			}
 35630			i1 := x1.AuxInt
 35631			if x1.Aux != s {
 35632				break
 35633			}
 35634			_ = x1.Args[2]
 35635			if idx != x1.Args[0] {
 35636				break
 35637			}
 35638			if p != x1.Args[1] {
 35639				break
 35640			}
 35641			if mem != x1.Args[2] {
 35642				break
 35643			}
 35644			if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 35645				break
 35646			}
 35647			b = mergePoint(b, x0, x1)
 35648			v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 35649			v.reset(OpCopy)
 35650			v.AddArg(v0)
 35651			v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 35652			v1.AuxInt = i0
 35653			v1.Aux = s
 35654			v1.AddArg(p)
 35655			v1.AddArg(idx)
 35656			v1.AddArg(mem)
 35657			v0.AddArg(v1)
 35658			return true
 35659		}
 35660		// match: (ORW sh:(SLWconst [8] x1:(MOVBZloadidx [i1] {s} p idx mem)) x0:(MOVBZloadidx [i0] {s} p idx mem))
 35661		// cond: p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 35662		// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))
 35663		for {
 35664			_ = v.Args[1]
 35665			sh := v.Args[0]
 35666			if sh.Op != OpS390XSLWconst {
 35667				break
 35668			}
 35669			if sh.AuxInt != 8 {
 35670				break
 35671			}
 35672			x1 := sh.Args[0]
 35673			if x1.Op != OpS390XMOVBZloadidx {
 35674				break
 35675			}
 35676			i1 := x1.AuxInt
 35677			s := x1.Aux
 35678			mem := x1.Args[2]
 35679			p := x1.Args[0]
 35680			idx := x1.Args[1]
 35681			x0 := v.Args[1]
 35682			if x0.Op != OpS390XMOVBZloadidx {
 35683				break
 35684			}
 35685			i0 := x0.AuxInt
 35686			if x0.Aux != s {
 35687				break
 35688			}
 35689			_ = x0.Args[2]
 35690			if p != x0.Args[0] {
 35691				break
 35692			}
 35693			if idx != x0.Args[1] {
 35694				break
 35695			}
 35696			if mem != x0.Args[2] {
 35697				break
 35698			}
 35699			if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 35700				break
 35701			}
 35702			b = mergePoint(b, x0, x1)
 35703			v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 35704			v.reset(OpCopy)
 35705			v.AddArg(v0)
 35706			v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 35707			v1.AuxInt = i0
 35708			v1.Aux = s
 35709			v1.AddArg(p)
 35710			v1.AddArg(idx)
 35711			v1.AddArg(mem)
 35712			v0.AddArg(v1)
 35713			return true
 35714		}
 35715		// match: (ORW sh:(SLWconst [8] x1:(MOVBZloadidx [i1] {s} idx p mem)) x0:(MOVBZloadidx [i0] {s} p idx mem))
 35716		// cond: p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 35717		// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))
 35718		for {
 35719			_ = v.Args[1]
 35720			sh := v.Args[0]
 35721			if sh.Op != OpS390XSLWconst {
 35722				break
 35723			}
 35724			if sh.AuxInt != 8 {
 35725				break
 35726			}
 35727			x1 := sh.Args[0]
 35728			if x1.Op != OpS390XMOVBZloadidx {
 35729				break
 35730			}
 35731			i1 := x1.AuxInt
 35732			s := x1.Aux
 35733			mem := x1.Args[2]
 35734			idx := x1.Args[0]
 35735			p := x1.Args[1]
 35736			x0 := v.Args[1]
 35737			if x0.Op != OpS390XMOVBZloadidx {
 35738				break
 35739			}
 35740			i0 := x0.AuxInt
 35741			if x0.Aux != s {
 35742				break
 35743			}
 35744			_ = x0.Args[2]
 35745			if p != x0.Args[0] {
 35746				break
 35747			}
 35748			if idx != x0.Args[1] {
 35749				break
 35750			}
 35751			if mem != x0.Args[2] {
 35752				break
 35753			}
 35754			if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 35755				break
 35756			}
 35757			b = mergePoint(b, x0, x1)
 35758			v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 35759			v.reset(OpCopy)
 35760			v.AddArg(v0)
 35761			v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 35762			v1.AuxInt = i0
 35763			v1.Aux = s
 35764			v1.AddArg(p)
 35765			v1.AddArg(idx)
 35766			v1.AddArg(mem)
 35767			v0.AddArg(v1)
 35768			return true
 35769		}
 35770		// match: (ORW sh:(SLWconst [8] x1:(MOVBZloadidx [i1] {s} p idx mem)) x0:(MOVBZloadidx [i0] {s} idx p mem))
 35771		// cond: p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 35772		// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))
 35773		for {
 35774			_ = v.Args[1]
 35775			sh := v.Args[0]
 35776			if sh.Op != OpS390XSLWconst {
 35777				break
 35778			}
 35779			if sh.AuxInt != 8 {
 35780				break
 35781			}
 35782			x1 := sh.Args[0]
 35783			if x1.Op != OpS390XMOVBZloadidx {
 35784				break
 35785			}
 35786			i1 := x1.AuxInt
 35787			s := x1.Aux
 35788			mem := x1.Args[2]
 35789			p := x1.Args[0]
 35790			idx := x1.Args[1]
 35791			x0 := v.Args[1]
 35792			if x0.Op != OpS390XMOVBZloadidx {
 35793				break
 35794			}
 35795			i0 := x0.AuxInt
 35796			if x0.Aux != s {
 35797				break
 35798			}
 35799			_ = x0.Args[2]
 35800			if idx != x0.Args[0] {
 35801				break
 35802			}
 35803			if p != x0.Args[1] {
 35804				break
 35805			}
 35806			if mem != x0.Args[2] {
 35807				break
 35808			}
 35809			if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 35810				break
 35811			}
 35812			b = mergePoint(b, x0, x1)
 35813			v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 35814			v.reset(OpCopy)
 35815			v.AddArg(v0)
 35816			v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 35817			v1.AuxInt = i0
 35818			v1.Aux = s
 35819			v1.AddArg(p)
 35820			v1.AddArg(idx)
 35821			v1.AddArg(mem)
 35822			v0.AddArg(v1)
 35823			return true
 35824		}
 35825		// match: (ORW sh:(SLWconst [8] x1:(MOVBZloadidx [i1] {s} idx p mem)) x0:(MOVBZloadidx [i0] {s} idx p mem))
 35826		// cond: p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
 35827		// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))
 35828		for {
 35829			_ = v.Args[1]
 35830			sh := v.Args[0]
 35831			if sh.Op != OpS390XSLWconst {
 35832				break
 35833			}
 35834			if sh.AuxInt != 8 {
 35835				break
 35836			}
 35837			x1 := sh.Args[0]
 35838			if x1.Op != OpS390XMOVBZloadidx {
 35839				break
 35840			}
 35841			i1 := x1.AuxInt
 35842			s := x1.Aux
 35843			mem := x1.Args[2]
 35844			idx := x1.Args[0]
 35845			p := x1.Args[1]
 35846			x0 := v.Args[1]
 35847			if x0.Op != OpS390XMOVBZloadidx {
 35848				break
 35849			}
 35850			i0 := x0.AuxInt
 35851			if x0.Aux != s {
 35852				break
 35853			}
 35854			_ = x0.Args[2]
 35855			if idx != x0.Args[0] {
 35856				break
 35857			}
 35858			if p != x0.Args[1] {
 35859				break
 35860			}
 35861			if mem != x0.Args[2] {
 35862				break
 35863			}
 35864			if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
 35865				break
 35866			}
 35867			b = mergePoint(b, x0, x1)
 35868			v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 35869			v.reset(OpCopy)
 35870			v.AddArg(v0)
 35871			v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 35872			v1.AuxInt = i0
 35873			v1.Aux = s
 35874			v1.AddArg(p)
 35875			v1.AddArg(idx)
 35876			v1.AddArg(mem)
 35877			v0.AddArg(v1)
 35878			return true
 35879		}
 35880		// match: (ORW r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} p idx mem)) sh:(SLWconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem))))
 35881		// cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
 35882		// result: @mergePoint(b,x0,x1) (MOVWBRloadidx [i0] {s} p idx mem)
 35883		for {
 35884			_ = v.Args[1]
 35885			r0 := v.Args[0]
 35886			if r0.Op != OpS390XMOVHZreg {
 35887				break
 35888			}
 35889			x0 := r0.Args[0]
 35890			if x0.Op != OpS390XMOVHBRloadidx {
 35891				break
 35892			}
 35893			i0 := x0.AuxInt
 35894			s := x0.Aux
 35895			mem := x0.Args[2]
 35896			p := x0.Args[0]
 35897			idx := x0.Args[1]
 35898			sh := v.Args[1]
 35899			if sh.Op != OpS390XSLWconst {
 35900				break
 35901			}
 35902			if sh.AuxInt != 16 {
 35903				break
 35904			}
 35905			r1 := sh.Args[0]
 35906			if r1.Op != OpS390XMOVHZreg {
 35907				break
 35908			}
 35909			x1 := r1.Args[0]
 35910			if x1.Op != OpS390XMOVHBRloadidx {
 35911				break
 35912			}
 35913			i1 := x1.AuxInt
 35914			if x1.Aux != s {
 35915				break
 35916			}
 35917			_ = x1.Args[2]
 35918			if p != x1.Args[0] {
 35919				break
 35920			}
 35921			if idx != x1.Args[1] {
 35922				break
 35923			}
 35924			if mem != x1.Args[2] {
 35925				break
 35926			}
 35927			if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
 35928				break
 35929			}
 35930			b = mergePoint(b, x0, x1)
 35931			v0 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
 35932			v.reset(OpCopy)
 35933			v.AddArg(v0)
 35934			v0.AuxInt = i0
 35935			v0.Aux = s
 35936			v0.AddArg(p)
 35937			v0.AddArg(idx)
 35938			v0.AddArg(mem)
 35939			return true
 35940		}
 35941		return false
 35942	}
 35943	func rewriteValueS390X_OpS390XORW_70(v *Value) bool {
 35944		b := v.Block
 35945		typ := &b.Func.Config.Types
 35946		// match: (ORW r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem)) sh:(SLWconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem))))
 35947		// cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
 35948		// result: @mergePoint(b,x0,x1) (MOVWBRloadidx [i0] {s} p idx mem)
 35949		for {
 35950			_ = v.Args[1]
 35951			r0 := v.Args[0]
 35952			if r0.Op != OpS390XMOVHZreg {
 35953				break
 35954			}
 35955			x0 := r0.Args[0]
 35956			if x0.Op != OpS390XMOVHBRloadidx {
 35957				break
 35958			}
 35959			i0 := x0.AuxInt
 35960			s := x0.Aux
 35961			mem := x0.Args[2]
 35962			idx := x0.Args[0]
 35963			p := x0.Args[1]
 35964			sh := v.Args[1]
 35965			if sh.Op != OpS390XSLWconst {
 35966				break
 35967			}
 35968			if sh.AuxInt != 16 {
 35969				break
 35970			}
 35971			r1 := sh.Args[0]
 35972			if r1.Op != OpS390XMOVHZreg {
 35973				break
 35974			}
 35975			x1 := r1.Args[0]
 35976			if x1.Op != OpS390XMOVHBRloadidx {
 35977				break
 35978			}
 35979			i1 := x1.AuxInt
 35980			if x1.Aux != s {
 35981				break
 35982			}
 35983			_ = x1.Args[2]
 35984			if p != x1.Args[0] {
 35985				break
 35986			}
 35987			if idx != x1.Args[1] {
 35988				break
 35989			}
 35990			if mem != x1.Args[2] {
 35991				break
 35992			}
 35993			if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
 35994				break
 35995			}
 35996			b = mergePoint(b, x0, x1)
 35997			v0 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
 35998			v.reset(OpCopy)
 35999			v.AddArg(v0)
 36000			v0.AuxInt = i0
 36001			v0.Aux = s
 36002			v0.AddArg(p)
 36003			v0.AddArg(idx)
 36004			v0.AddArg(mem)
 36005			return true
 36006		}
 36007		// match: (ORW r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} p idx mem)) sh:(SLWconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))))
 36008		// cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
 36009		// result: @mergePoint(b,x0,x1) (MOVWBRloadidx [i0] {s} p idx mem)
 36010		for {
 36011			_ = v.Args[1]
 36012			r0 := v.Args[0]
 36013			if r0.Op != OpS390XMOVHZreg {
 36014				break
 36015			}
 36016			x0 := r0.Args[0]
 36017			if x0.Op != OpS390XMOVHBRloadidx {
 36018				break
 36019			}
 36020			i0 := x0.AuxInt
 36021			s := x0.Aux
 36022			mem := x0.Args[2]
 36023			p := x0.Args[0]
 36024			idx := x0.Args[1]
 36025			sh := v.Args[1]
 36026			if sh.Op != OpS390XSLWconst {
 36027				break
 36028			}
 36029			if sh.AuxInt != 16 {
 36030				break
 36031			}
 36032			r1 := sh.Args[0]
 36033			if r1.Op != OpS390XMOVHZreg {
 36034				break
 36035			}
 36036			x1 := r1.Args[0]
 36037			if x1.Op != OpS390XMOVHBRloadidx {
 36038				break
 36039			}
 36040			i1 := x1.AuxInt
 36041			if x1.Aux != s {
 36042				break
 36043			}
 36044			_ = x1.Args[2]
 36045			if idx != x1.Args[0] {
 36046				break
 36047			}
 36048			if p != x1.Args[1] {
 36049				break
 36050			}
 36051			if mem != x1.Args[2] {
 36052				break
 36053			}
 36054			if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
 36055				break
 36056			}
 36057			b = mergePoint(b, x0, x1)
 36058			v0 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
 36059			v.reset(OpCopy)
 36060			v.AddArg(v0)
 36061			v0.AuxInt = i0
 36062			v0.Aux = s
 36063			v0.AddArg(p)
 36064			v0.AddArg(idx)
 36065			v0.AddArg(mem)
 36066			return true
 36067		}
 36068		// match: (ORW r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem)) sh:(SLWconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))))
 36069		// cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
 36070		// result: @mergePoint(b,x0,x1) (MOVWBRloadidx [i0] {s} p idx mem)
 36071		for {
 36072			_ = v.Args[1]
 36073			r0 := v.Args[0]
 36074			if r0.Op != OpS390XMOVHZreg {
 36075				break
 36076			}
 36077			x0 := r0.Args[0]
 36078			if x0.Op != OpS390XMOVHBRloadidx {
 36079				break
 36080			}
 36081			i0 := x0.AuxInt
 36082			s := x0.Aux
 36083			mem := x0.Args[2]
 36084			idx := x0.Args[0]
 36085			p := x0.Args[1]
 36086			sh := v.Args[1]
 36087			if sh.Op != OpS390XSLWconst {
 36088				break
 36089			}
 36090			if sh.AuxInt != 16 {
 36091				break
 36092			}
 36093			r1 := sh.Args[0]
 36094			if r1.Op != OpS390XMOVHZreg {
 36095				break
 36096			}
 36097			x1 := r1.Args[0]
 36098			if x1.Op != OpS390XMOVHBRloadidx {
 36099				break
 36100			}
 36101			i1 := x1.AuxInt
 36102			if x1.Aux != s {
 36103				break
 36104			}
 36105			_ = x1.Args[2]
 36106			if idx != x1.Args[0] {
 36107				break
 36108			}
 36109			if p != x1.Args[1] {
 36110				break
 36111			}
 36112			if mem != x1.Args[2] {
 36113				break
 36114			}
 36115			if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
 36116				break
 36117			}
 36118			b = mergePoint(b, x0, x1)
 36119			v0 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
 36120			v.reset(OpCopy)
 36121			v.AddArg(v0)
 36122			v0.AuxInt = i0
 36123			v0.Aux = s
 36124			v0.AddArg(p)
 36125			v0.AddArg(idx)
 36126			v0.AddArg(mem)
 36127			return true
 36128		}
 36129		// match: (ORW sh:(SLWconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem))) r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} p idx mem)))
 36130		// cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
 36131		// result: @mergePoint(b,x0,x1) (MOVWBRloadidx [i0] {s} p idx mem)
 36132		for {
 36133			_ = v.Args[1]
 36134			sh := v.Args[0]
 36135			if sh.Op != OpS390XSLWconst {
 36136				break
 36137			}
 36138			if sh.AuxInt != 16 {
 36139				break
 36140			}
 36141			r1 := sh.Args[0]
 36142			if r1.Op != OpS390XMOVHZreg {
 36143				break
 36144			}
 36145			x1 := r1.Args[0]
 36146			if x1.Op != OpS390XMOVHBRloadidx {
 36147				break
 36148			}
 36149			i1 := x1.AuxInt
 36150			s := x1.Aux
 36151			mem := x1.Args[2]
 36152			p := x1.Args[0]
 36153			idx := x1.Args[1]
 36154			r0 := v.Args[1]
 36155			if r0.Op != OpS390XMOVHZreg {
 36156				break
 36157			}
 36158			x0 := r0.Args[0]
 36159			if x0.Op != OpS390XMOVHBRloadidx {
 36160				break
 36161			}
 36162			i0 := x0.AuxInt
 36163			if x0.Aux != s {
 36164				break
 36165			}
 36166			_ = x0.Args[2]
 36167			if p != x0.Args[0] {
 36168				break
 36169			}
 36170			if idx != x0.Args[1] {
 36171				break
 36172			}
 36173			if mem != x0.Args[2] {
 36174				break
 36175			}
 36176			if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
 36177				break
 36178			}
 36179			b = mergePoint(b, x0, x1)
 36180			v0 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
 36181			v.reset(OpCopy)
 36182			v.AddArg(v0)
 36183			v0.AuxInt = i0
 36184			v0.Aux = s
 36185			v0.AddArg(p)
 36186			v0.AddArg(idx)
 36187			v0.AddArg(mem)
 36188			return true
 36189		}
 36190		// match: (ORW sh:(SLWconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))) r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} p idx mem)))
 36191		// cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
 36192		// result: @mergePoint(b,x0,x1) (MOVWBRloadidx [i0] {s} p idx mem)
 36193		for {
 36194			_ = v.Args[1]
 36195			sh := v.Args[0]
 36196			if sh.Op != OpS390XSLWconst {
 36197				break
 36198			}
 36199			if sh.AuxInt != 16 {
 36200				break
 36201			}
 36202			r1 := sh.Args[0]
 36203			if r1.Op != OpS390XMOVHZreg {
 36204				break
 36205			}
 36206			x1 := r1.Args[0]
 36207			if x1.Op != OpS390XMOVHBRloadidx {
 36208				break
 36209			}
 36210			i1 := x1.AuxInt
 36211			s := x1.Aux
 36212			mem := x1.Args[2]
 36213			idx := x1.Args[0]
 36214			p := x1.Args[1]
 36215			r0 := v.Args[1]
 36216			if r0.Op != OpS390XMOVHZreg {
 36217				break
 36218			}
 36219			x0 := r0.Args[0]
 36220			if x0.Op != OpS390XMOVHBRloadidx {
 36221				break
 36222			}
 36223			i0 := x0.AuxInt
 36224			if x0.Aux != s {
 36225				break
 36226			}
 36227			_ = x0.Args[2]
 36228			if p != x0.Args[0] {
 36229				break
 36230			}
 36231			if idx != x0.Args[1] {
 36232				break
 36233			}
 36234			if mem != x0.Args[2] {
 36235				break
 36236			}
 36237			if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
 36238				break
 36239			}
 36240			b = mergePoint(b, x0, x1)
 36241			v0 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
 36242			v.reset(OpCopy)
 36243			v.AddArg(v0)
 36244			v0.AuxInt = i0
 36245			v0.Aux = s
 36246			v0.AddArg(p)
 36247			v0.AddArg(idx)
 36248			v0.AddArg(mem)
 36249			return true
 36250		}
 36251		// match: (ORW sh:(SLWconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem))) r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem)))
 36252		// cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
 36253		// result: @mergePoint(b,x0,x1) (MOVWBRloadidx [i0] {s} p idx mem)
 36254		for {
 36255			_ = v.Args[1]
 36256			sh := v.Args[0]
 36257			if sh.Op != OpS390XSLWconst {
 36258				break
 36259			}
 36260			if sh.AuxInt != 16 {
 36261				break
 36262			}
 36263			r1 := sh.Args[0]
 36264			if r1.Op != OpS390XMOVHZreg {
 36265				break
 36266			}
 36267			x1 := r1.Args[0]
 36268			if x1.Op != OpS390XMOVHBRloadidx {
 36269				break
 36270			}
 36271			i1 := x1.AuxInt
 36272			s := x1.Aux
 36273			mem := x1.Args[2]
 36274			p := x1.Args[0]
 36275			idx := x1.Args[1]
 36276			r0 := v.Args[1]
 36277			if r0.Op != OpS390XMOVHZreg {
 36278				break
 36279			}
 36280			x0 := r0.Args[0]
 36281			if x0.Op != OpS390XMOVHBRloadidx {
 36282				break
 36283			}
 36284			i0 := x0.AuxInt
 36285			if x0.Aux != s {
 36286				break
 36287			}
 36288			_ = x0.Args[2]
 36289			if idx != x0.Args[0] {
 36290				break
 36291			}
 36292			if p != x0.Args[1] {
 36293				break
 36294			}
 36295			if mem != x0.Args[2] {
 36296				break
 36297			}
 36298			if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
 36299				break
 36300			}
 36301			b = mergePoint(b, x0, x1)
 36302			v0 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
 36303			v.reset(OpCopy)
 36304			v.AddArg(v0)
 36305			v0.AuxInt = i0
 36306			v0.Aux = s
 36307			v0.AddArg(p)
 36308			v0.AddArg(idx)
 36309			v0.AddArg(mem)
 36310			return true
 36311		}
 36312		// match: (ORW sh:(SLWconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))) r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem)))
 36313		// cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
 36314		// result: @mergePoint(b,x0,x1) (MOVWBRloadidx [i0] {s} p idx mem)
 36315		for {
 36316			_ = v.Args[1]
 36317			sh := v.Args[0]
 36318			if sh.Op != OpS390XSLWconst {
 36319				break
 36320			}
 36321			if sh.AuxInt != 16 {
 36322				break
 36323			}
 36324			r1 := sh.Args[0]
 36325			if r1.Op != OpS390XMOVHZreg {
 36326				break
 36327			}
 36328			x1 := r1.Args[0]
 36329			if x1.Op != OpS390XMOVHBRloadidx {
 36330				break
 36331			}
 36332			i1 := x1.AuxInt
 36333			s := x1.Aux
 36334			mem := x1.Args[2]
 36335			idx := x1.Args[0]
 36336			p := x1.Args[1]
 36337			r0 := v.Args[1]
 36338			if r0.Op != OpS390XMOVHZreg {
 36339				break
 36340			}
 36341			x0 := r0.Args[0]
 36342			if x0.Op != OpS390XMOVHBRloadidx {
 36343				break
 36344			}
 36345			i0 := x0.AuxInt
 36346			if x0.Aux != s {
 36347				break
 36348			}
 36349			_ = x0.Args[2]
 36350			if idx != x0.Args[0] {
 36351				break
 36352			}
 36353			if p != x0.Args[1] {
 36354				break
 36355			}
 36356			if mem != x0.Args[2] {
 36357				break
 36358			}
 36359			if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
 36360				break
 36361			}
 36362			b = mergePoint(b, x0, x1)
 36363			v0 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
 36364			v.reset(OpCopy)
 36365			v.AddArg(v0)
 36366			v0.AuxInt = i0
 36367			v0.Aux = s
 36368			v0.AddArg(p)
 36369			v0.AddArg(idx)
 36370			v0.AddArg(mem)
 36371			return true
 36372		}
 36373		// match: (ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)) or:(ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) y))
 36374		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 36375		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
 36376		for {
 36377			_ = v.Args[1]
 36378			s1 := v.Args[0]
 36379			if s1.Op != OpS390XSLWconst {
 36380				break
 36381			}
 36382			j1 := s1.AuxInt
 36383			x1 := s1.Args[0]
 36384			if x1.Op != OpS390XMOVBZloadidx {
 36385				break
 36386			}
 36387			i1 := x1.AuxInt
 36388			s := x1.Aux
 36389			mem := x1.Args[2]
 36390			p := x1.Args[0]
 36391			idx := x1.Args[1]
 36392			or := v.Args[1]
 36393			if or.Op != OpS390XORW {
 36394				break
 36395			}
 36396			y := or.Args[1]
 36397			s0 := or.Args[0]
 36398			if s0.Op != OpS390XSLWconst {
 36399				break
 36400			}
 36401			j0 := s0.AuxInt
 36402			x0 := s0.Args[0]
 36403			if x0.Op != OpS390XMOVBZloadidx {
 36404				break
 36405			}
 36406			i0 := x0.AuxInt
 36407			if x0.Aux != s {
 36408				break
 36409			}
 36410			_ = x0.Args[2]
 36411			if p != x0.Args[0] {
 36412				break
 36413			}
 36414			if idx != x0.Args[1] {
 36415				break
 36416			}
 36417			if mem != x0.Args[2] {
 36418				break
 36419			}
 36420			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 36421				break
 36422			}
 36423			b = mergePoint(b, x0, x1, y)
 36424			v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
 36425			v.reset(OpCopy)
 36426			v.AddArg(v0)
 36427			v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
 36428			v1.AuxInt = j0
 36429			v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 36430			v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 36431			v3.AuxInt = i0
 36432			v3.Aux = s
 36433			v3.AddArg(p)
 36434			v3.AddArg(idx)
 36435			v3.AddArg(mem)
 36436			v2.AddArg(v3)
 36437			v1.AddArg(v2)
 36438			v0.AddArg(v1)
 36439			v0.AddArg(y)
 36440			return true
 36441		}
 36442		// match: (ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) or:(ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) y))
 36443		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 36444		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
 36445		for {
 36446			_ = v.Args[1]
 36447			s1 := v.Args[0]
 36448			if s1.Op != OpS390XSLWconst {
 36449				break
 36450			}
 36451			j1 := s1.AuxInt
 36452			x1 := s1.Args[0]
 36453			if x1.Op != OpS390XMOVBZloadidx {
 36454				break
 36455			}
 36456			i1 := x1.AuxInt
 36457			s := x1.Aux
 36458			mem := x1.Args[2]
 36459			idx := x1.Args[0]
 36460			p := x1.Args[1]
 36461			or := v.Args[1]
 36462			if or.Op != OpS390XORW {
 36463				break
 36464			}
 36465			y := or.Args[1]
 36466			s0 := or.Args[0]
 36467			if s0.Op != OpS390XSLWconst {
 36468				break
 36469			}
 36470			j0 := s0.AuxInt
 36471			x0 := s0.Args[0]
 36472			if x0.Op != OpS390XMOVBZloadidx {
 36473				break
 36474			}
 36475			i0 := x0.AuxInt
 36476			if x0.Aux != s {
 36477				break
 36478			}
 36479			_ = x0.Args[2]
 36480			if p != x0.Args[0] {
 36481				break
 36482			}
 36483			if idx != x0.Args[1] {
 36484				break
 36485			}
 36486			if mem != x0.Args[2] {
 36487				break
 36488			}
 36489			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 36490				break
 36491			}
 36492			b = mergePoint(b, x0, x1, y)
 36493			v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
 36494			v.reset(OpCopy)
 36495			v.AddArg(v0)
 36496			v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
 36497			v1.AuxInt = j0
 36498			v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 36499			v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 36500			v3.AuxInt = i0
 36501			v3.Aux = s
 36502			v3.AddArg(p)
 36503			v3.AddArg(idx)
 36504			v3.AddArg(mem)
 36505			v2.AddArg(v3)
 36506			v1.AddArg(v2)
 36507			v0.AddArg(v1)
 36508			v0.AddArg(y)
 36509			return true
 36510		}
 36511		// match: (ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)) or:(ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) y))
 36512		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 36513		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
 36514		for {
 36515			_ = v.Args[1]
 36516			s1 := v.Args[0]
 36517			if s1.Op != OpS390XSLWconst {
 36518				break
 36519			}
 36520			j1 := s1.AuxInt
 36521			x1 := s1.Args[0]
 36522			if x1.Op != OpS390XMOVBZloadidx {
 36523				break
 36524			}
 36525			i1 := x1.AuxInt
 36526			s := x1.Aux
 36527			mem := x1.Args[2]
 36528			p := x1.Args[0]
 36529			idx := x1.Args[1]
 36530			or := v.Args[1]
 36531			if or.Op != OpS390XORW {
 36532				break
 36533			}
 36534			y := or.Args[1]
 36535			s0 := or.Args[0]
 36536			if s0.Op != OpS390XSLWconst {
 36537				break
 36538			}
 36539			j0 := s0.AuxInt
 36540			x0 := s0.Args[0]
 36541			if x0.Op != OpS390XMOVBZloadidx {
 36542				break
 36543			}
 36544			i0 := x0.AuxInt
 36545			if x0.Aux != s {
 36546				break
 36547			}
 36548			_ = x0.Args[2]
 36549			if idx != x0.Args[0] {
 36550				break
 36551			}
 36552			if p != x0.Args[1] {
 36553				break
 36554			}
 36555			if mem != x0.Args[2] {
 36556				break
 36557			}
 36558			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 36559				break
 36560			}
 36561			b = mergePoint(b, x0, x1, y)
 36562			v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
 36563			v.reset(OpCopy)
 36564			v.AddArg(v0)
 36565			v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
 36566			v1.AuxInt = j0
 36567			v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 36568			v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 36569			v3.AuxInt = i0
 36570			v3.Aux = s
 36571			v3.AddArg(p)
 36572			v3.AddArg(idx)
 36573			v3.AddArg(mem)
 36574			v2.AddArg(v3)
 36575			v1.AddArg(v2)
 36576			v0.AddArg(v1)
 36577			v0.AddArg(y)
 36578			return true
 36579		}
 36580		return false
 36581	}
 36582	func rewriteValueS390X_OpS390XORW_80(v *Value) bool {
 36583		b := v.Block
 36584		typ := &b.Func.Config.Types
 36585		// match: (ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) or:(ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) y))
 36586		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 36587		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
 36588		for {
 36589			_ = v.Args[1]
 36590			s1 := v.Args[0]
 36591			if s1.Op != OpS390XSLWconst {
 36592				break
 36593			}
 36594			j1 := s1.AuxInt
 36595			x1 := s1.Args[0]
 36596			if x1.Op != OpS390XMOVBZloadidx {
 36597				break
 36598			}
 36599			i1 := x1.AuxInt
 36600			s := x1.Aux
 36601			mem := x1.Args[2]
 36602			idx := x1.Args[0]
 36603			p := x1.Args[1]
 36604			or := v.Args[1]
 36605			if or.Op != OpS390XORW {
 36606				break
 36607			}
 36608			y := or.Args[1]
 36609			s0 := or.Args[0]
 36610			if s0.Op != OpS390XSLWconst {
 36611				break
 36612			}
 36613			j0 := s0.AuxInt
 36614			x0 := s0.Args[0]
 36615			if x0.Op != OpS390XMOVBZloadidx {
 36616				break
 36617			}
 36618			i0 := x0.AuxInt
 36619			if x0.Aux != s {
 36620				break
 36621			}
 36622			_ = x0.Args[2]
 36623			if idx != x0.Args[0] {
 36624				break
 36625			}
 36626			if p != x0.Args[1] {
 36627				break
 36628			}
 36629			if mem != x0.Args[2] {
 36630				break
 36631			}
 36632			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 36633				break
 36634			}
 36635			b = mergePoint(b, x0, x1, y)
 36636			v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
 36637			v.reset(OpCopy)
 36638			v.AddArg(v0)
 36639			v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
 36640			v1.AuxInt = j0
 36641			v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 36642			v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 36643			v3.AuxInt = i0
 36644			v3.Aux = s
 36645			v3.AddArg(p)
 36646			v3.AddArg(idx)
 36647			v3.AddArg(mem)
 36648			v2.AddArg(v3)
 36649			v1.AddArg(v2)
 36650			v0.AddArg(v1)
 36651			v0.AddArg(y)
 36652			return true
 36653		}
 36654		// match: (ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)) or:(ORW y s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem))))
 36655		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 36656		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
 36657		for {
 36658			_ = v.Args[1]
 36659			s1 := v.Args[0]
 36660			if s1.Op != OpS390XSLWconst {
 36661				break
 36662			}
 36663			j1 := s1.AuxInt
 36664			x1 := s1.Args[0]
 36665			if x1.Op != OpS390XMOVBZloadidx {
 36666				break
 36667			}
 36668			i1 := x1.AuxInt
 36669			s := x1.Aux
 36670			mem := x1.Args[2]
 36671			p := x1.Args[0]
 36672			idx := x1.Args[1]
 36673			or := v.Args[1]
 36674			if or.Op != OpS390XORW {
 36675				break
 36676			}
 36677			_ = or.Args[1]
 36678			y := or.Args[0]
 36679			s0 := or.Args[1]
 36680			if s0.Op != OpS390XSLWconst {
 36681				break
 36682			}
 36683			j0 := s0.AuxInt
 36684			x0 := s0.Args[0]
 36685			if x0.Op != OpS390XMOVBZloadidx {
 36686				break
 36687			}
 36688			i0 := x0.AuxInt
 36689			if x0.Aux != s {
 36690				break
 36691			}
 36692			_ = x0.Args[2]
 36693			if p != x0.Args[0] {
 36694				break
 36695			}
 36696			if idx != x0.Args[1] {
 36697				break
 36698			}
 36699			if mem != x0.Args[2] {
 36700				break
 36701			}
 36702			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 36703				break
 36704			}
 36705			b = mergePoint(b, x0, x1, y)
 36706			v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
 36707			v.reset(OpCopy)
 36708			v.AddArg(v0)
 36709			v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
 36710			v1.AuxInt = j0
 36711			v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 36712			v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 36713			v3.AuxInt = i0
 36714			v3.Aux = s
 36715			v3.AddArg(p)
 36716			v3.AddArg(idx)
 36717			v3.AddArg(mem)
 36718			v2.AddArg(v3)
 36719			v1.AddArg(v2)
 36720			v0.AddArg(v1)
 36721			v0.AddArg(y)
 36722			return true
 36723		}
 36724		// match: (ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) or:(ORW y s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem))))
 36725		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 36726		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
 36727		for {
 36728			_ = v.Args[1]
 36729			s1 := v.Args[0]
 36730			if s1.Op != OpS390XSLWconst {
 36731				break
 36732			}
 36733			j1 := s1.AuxInt
 36734			x1 := s1.Args[0]
 36735			if x1.Op != OpS390XMOVBZloadidx {
 36736				break
 36737			}
 36738			i1 := x1.AuxInt
 36739			s := x1.Aux
 36740			mem := x1.Args[2]
 36741			idx := x1.Args[0]
 36742			p := x1.Args[1]
 36743			or := v.Args[1]
 36744			if or.Op != OpS390XORW {
 36745				break
 36746			}
 36747			_ = or.Args[1]
 36748			y := or.Args[0]
 36749			s0 := or.Args[1]
 36750			if s0.Op != OpS390XSLWconst {
 36751				break
 36752			}
 36753			j0 := s0.AuxInt
 36754			x0 := s0.Args[0]
 36755			if x0.Op != OpS390XMOVBZloadidx {
 36756				break
 36757			}
 36758			i0 := x0.AuxInt
 36759			if x0.Aux != s {
 36760				break
 36761			}
 36762			_ = x0.Args[2]
 36763			if p != x0.Args[0] {
 36764				break
 36765			}
 36766			if idx != x0.Args[1] {
 36767				break
 36768			}
 36769			if mem != x0.Args[2] {
 36770				break
 36771			}
 36772			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 36773				break
 36774			}
 36775			b = mergePoint(b, x0, x1, y)
 36776			v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
 36777			v.reset(OpCopy)
 36778			v.AddArg(v0)
 36779			v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
 36780			v1.AuxInt = j0
 36781			v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 36782			v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 36783			v3.AuxInt = i0
 36784			v3.Aux = s
 36785			v3.AddArg(p)
 36786			v3.AddArg(idx)
 36787			v3.AddArg(mem)
 36788			v2.AddArg(v3)
 36789			v1.AddArg(v2)
 36790			v0.AddArg(v1)
 36791			v0.AddArg(y)
 36792			return true
 36793		}
 36794		// match: (ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)) or:(ORW y s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem))))
 36795		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 36796		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
 36797		for {
 36798			_ = v.Args[1]
 36799			s1 := v.Args[0]
 36800			if s1.Op != OpS390XSLWconst {
 36801				break
 36802			}
 36803			j1 := s1.AuxInt
 36804			x1 := s1.Args[0]
 36805			if x1.Op != OpS390XMOVBZloadidx {
 36806				break
 36807			}
 36808			i1 := x1.AuxInt
 36809			s := x1.Aux
 36810			mem := x1.Args[2]
 36811			p := x1.Args[0]
 36812			idx := x1.Args[1]
 36813			or := v.Args[1]
 36814			if or.Op != OpS390XORW {
 36815				break
 36816			}
 36817			_ = or.Args[1]
 36818			y := or.Args[0]
 36819			s0 := or.Args[1]
 36820			if s0.Op != OpS390XSLWconst {
 36821				break
 36822			}
 36823			j0 := s0.AuxInt
 36824			x0 := s0.Args[0]
 36825			if x0.Op != OpS390XMOVBZloadidx {
 36826				break
 36827			}
 36828			i0 := x0.AuxInt
 36829			if x0.Aux != s {
 36830				break
 36831			}
 36832			_ = x0.Args[2]
 36833			if idx != x0.Args[0] {
 36834				break
 36835			}
 36836			if p != x0.Args[1] {
 36837				break
 36838			}
 36839			if mem != x0.Args[2] {
 36840				break
 36841			}
 36842			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 36843				break
 36844			}
 36845			b = mergePoint(b, x0, x1, y)
 36846			v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
 36847			v.reset(OpCopy)
 36848			v.AddArg(v0)
 36849			v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
 36850			v1.AuxInt = j0
 36851			v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 36852			v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 36853			v3.AuxInt = i0
 36854			v3.Aux = s
 36855			v3.AddArg(p)
 36856			v3.AddArg(idx)
 36857			v3.AddArg(mem)
 36858			v2.AddArg(v3)
 36859			v1.AddArg(v2)
 36860			v0.AddArg(v1)
 36861			v0.AddArg(y)
 36862			return true
 36863		}
 36864		// match: (ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) or:(ORW y s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem))))
 36865		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 36866		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
 36867		for {
 36868			_ = v.Args[1]
 36869			s1 := v.Args[0]
 36870			if s1.Op != OpS390XSLWconst {
 36871				break
 36872			}
 36873			j1 := s1.AuxInt
 36874			x1 := s1.Args[0]
 36875			if x1.Op != OpS390XMOVBZloadidx {
 36876				break
 36877			}
 36878			i1 := x1.AuxInt
 36879			s := x1.Aux
 36880			mem := x1.Args[2]
 36881			idx := x1.Args[0]
 36882			p := x1.Args[1]
 36883			or := v.Args[1]
 36884			if or.Op != OpS390XORW {
 36885				break
 36886			}
 36887			_ = or.Args[1]
 36888			y := or.Args[0]
 36889			s0 := or.Args[1]
 36890			if s0.Op != OpS390XSLWconst {
 36891				break
 36892			}
 36893			j0 := s0.AuxInt
 36894			x0 := s0.Args[0]
 36895			if x0.Op != OpS390XMOVBZloadidx {
 36896				break
 36897			}
 36898			i0 := x0.AuxInt
 36899			if x0.Aux != s {
 36900				break
 36901			}
 36902			_ = x0.Args[2]
 36903			if idx != x0.Args[0] {
 36904				break
 36905			}
 36906			if p != x0.Args[1] {
 36907				break
 36908			}
 36909			if mem != x0.Args[2] {
 36910				break
 36911			}
 36912			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 36913				break
 36914			}
 36915			b = mergePoint(b, x0, x1, y)
 36916			v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
 36917			v.reset(OpCopy)
 36918			v.AddArg(v0)
 36919			v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
 36920			v1.AuxInt = j0
 36921			v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 36922			v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 36923			v3.AuxInt = i0
 36924			v3.Aux = s
 36925			v3.AddArg(p)
 36926			v3.AddArg(idx)
 36927			v3.AddArg(mem)
 36928			v2.AddArg(v3)
 36929			v1.AddArg(v2)
 36930			v0.AddArg(v1)
 36931			v0.AddArg(y)
 36932			return true
 36933		}
 36934		// match: (ORW or:(ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) y) s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)))
 36935		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 36936		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
 36937		for {
 36938			_ = v.Args[1]
 36939			or := v.Args[0]
 36940			if or.Op != OpS390XORW {
 36941				break
 36942			}
 36943			y := or.Args[1]
 36944			s0 := or.Args[0]
 36945			if s0.Op != OpS390XSLWconst {
 36946				break
 36947			}
 36948			j0 := s0.AuxInt
 36949			x0 := s0.Args[0]
 36950			if x0.Op != OpS390XMOVBZloadidx {
 36951				break
 36952			}
 36953			i0 := x0.AuxInt
 36954			s := x0.Aux
 36955			mem := x0.Args[2]
 36956			p := x0.Args[0]
 36957			idx := x0.Args[1]
 36958			s1 := v.Args[1]
 36959			if s1.Op != OpS390XSLWconst {
 36960				break
 36961			}
 36962			j1 := s1.AuxInt
 36963			x1 := s1.Args[0]
 36964			if x1.Op != OpS390XMOVBZloadidx {
 36965				break
 36966			}
 36967			i1 := x1.AuxInt
 36968			if x1.Aux != s {
 36969				break
 36970			}
 36971			_ = x1.Args[2]
 36972			if p != x1.Args[0] {
 36973				break
 36974			}
 36975			if idx != x1.Args[1] {
 36976				break
 36977			}
 36978			if mem != x1.Args[2] {
 36979				break
 36980			}
 36981			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 36982				break
 36983			}
 36984			b = mergePoint(b, x0, x1, y)
 36985			v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
 36986			v.reset(OpCopy)
 36987			v.AddArg(v0)
 36988			v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
 36989			v1.AuxInt = j0
 36990			v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 36991			v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 36992			v3.AuxInt = i0
 36993			v3.Aux = s
 36994			v3.AddArg(p)
 36995			v3.AddArg(idx)
 36996			v3.AddArg(mem)
 36997			v2.AddArg(v3)
 36998			v1.AddArg(v2)
 36999			v0.AddArg(v1)
 37000			v0.AddArg(y)
 37001			return true
 37002		}
 37003		// match: (ORW or:(ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) y) s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)))
 37004		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 37005		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
 37006		for {
 37007			_ = v.Args[1]
 37008			or := v.Args[0]
 37009			if or.Op != OpS390XORW {
 37010				break
 37011			}
 37012			y := or.Args[1]
 37013			s0 := or.Args[0]
 37014			if s0.Op != OpS390XSLWconst {
 37015				break
 37016			}
 37017			j0 := s0.AuxInt
 37018			x0 := s0.Args[0]
 37019			if x0.Op != OpS390XMOVBZloadidx {
 37020				break
 37021			}
 37022			i0 := x0.AuxInt
 37023			s := x0.Aux
 37024			mem := x0.Args[2]
 37025			idx := x0.Args[0]
 37026			p := x0.Args[1]
 37027			s1 := v.Args[1]
 37028			if s1.Op != OpS390XSLWconst {
 37029				break
 37030			}
 37031			j1 := s1.AuxInt
 37032			x1 := s1.Args[0]
 37033			if x1.Op != OpS390XMOVBZloadidx {
 37034				break
 37035			}
 37036			i1 := x1.AuxInt
 37037			if x1.Aux != s {
 37038				break
 37039			}
 37040			_ = x1.Args[2]
 37041			if p != x1.Args[0] {
 37042				break
 37043			}
 37044			if idx != x1.Args[1] {
 37045				break
 37046			}
 37047			if mem != x1.Args[2] {
 37048				break
 37049			}
 37050			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 37051				break
 37052			}
 37053			b = mergePoint(b, x0, x1, y)
 37054			v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
 37055			v.reset(OpCopy)
 37056			v.AddArg(v0)
 37057			v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
 37058			v1.AuxInt = j0
 37059			v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 37060			v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 37061			v3.AuxInt = i0
 37062			v3.Aux = s
 37063			v3.AddArg(p)
 37064			v3.AddArg(idx)
 37065			v3.AddArg(mem)
 37066			v2.AddArg(v3)
 37067			v1.AddArg(v2)
 37068			v0.AddArg(v1)
 37069			v0.AddArg(y)
 37070			return true
 37071		}
 37072		// match: (ORW or:(ORW y s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem))) s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)))
 37073		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 37074		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
 37075		for {
 37076			_ = v.Args[1]
 37077			or := v.Args[0]
 37078			if or.Op != OpS390XORW {
 37079				break
 37080			}
 37081			_ = or.Args[1]
 37082			y := or.Args[0]
 37083			s0 := or.Args[1]
 37084			if s0.Op != OpS390XSLWconst {
 37085				break
 37086			}
 37087			j0 := s0.AuxInt
 37088			x0 := s0.Args[0]
 37089			if x0.Op != OpS390XMOVBZloadidx {
 37090				break
 37091			}
 37092			i0 := x0.AuxInt
 37093			s := x0.Aux
 37094			mem := x0.Args[2]
 37095			p := x0.Args[0]
 37096			idx := x0.Args[1]
 37097			s1 := v.Args[1]
 37098			if s1.Op != OpS390XSLWconst {
 37099				break
 37100			}
 37101			j1 := s1.AuxInt
 37102			x1 := s1.Args[0]
 37103			if x1.Op != OpS390XMOVBZloadidx {
 37104				break
 37105			}
 37106			i1 := x1.AuxInt
 37107			if x1.Aux != s {
 37108				break
 37109			}
 37110			_ = x1.Args[2]
 37111			if p != x1.Args[0] {
 37112				break
 37113			}
 37114			if idx != x1.Args[1] {
 37115				break
 37116			}
 37117			if mem != x1.Args[2] {
 37118				break
 37119			}
 37120			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 37121				break
 37122			}
 37123			b = mergePoint(b, x0, x1, y)
 37124			v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
 37125			v.reset(OpCopy)
 37126			v.AddArg(v0)
 37127			v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
 37128			v1.AuxInt = j0
 37129			v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 37130			v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 37131			v3.AuxInt = i0
 37132			v3.Aux = s
 37133			v3.AddArg(p)
 37134			v3.AddArg(idx)
 37135			v3.AddArg(mem)
 37136			v2.AddArg(v3)
 37137			v1.AddArg(v2)
 37138			v0.AddArg(v1)
 37139			v0.AddArg(y)
 37140			return true
 37141		}
 37142		// match: (ORW or:(ORW y s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem))) s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)))
 37143		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 37144		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
 37145		for {
 37146			_ = v.Args[1]
 37147			or := v.Args[0]
 37148			if or.Op != OpS390XORW {
 37149				break
 37150			}
 37151			_ = or.Args[1]
 37152			y := or.Args[0]
 37153			s0 := or.Args[1]
 37154			if s0.Op != OpS390XSLWconst {
 37155				break
 37156			}
 37157			j0 := s0.AuxInt
 37158			x0 := s0.Args[0]
 37159			if x0.Op != OpS390XMOVBZloadidx {
 37160				break
 37161			}
 37162			i0 := x0.AuxInt
 37163			s := x0.Aux
 37164			mem := x0.Args[2]
 37165			idx := x0.Args[0]
 37166			p := x0.Args[1]
 37167			s1 := v.Args[1]
 37168			if s1.Op != OpS390XSLWconst {
 37169				break
 37170			}
 37171			j1 := s1.AuxInt
 37172			x1 := s1.Args[0]
 37173			if x1.Op != OpS390XMOVBZloadidx {
 37174				break
 37175			}
 37176			i1 := x1.AuxInt
 37177			if x1.Aux != s {
 37178				break
 37179			}
 37180			_ = x1.Args[2]
 37181			if p != x1.Args[0] {
 37182				break
 37183			}
 37184			if idx != x1.Args[1] {
 37185				break
 37186			}
 37187			if mem != x1.Args[2] {
 37188				break
 37189			}
 37190			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 37191				break
 37192			}
 37193			b = mergePoint(b, x0, x1, y)
 37194			v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
 37195			v.reset(OpCopy)
 37196			v.AddArg(v0)
 37197			v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
 37198			v1.AuxInt = j0
 37199			v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 37200			v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 37201			v3.AuxInt = i0
 37202			v3.Aux = s
 37203			v3.AddArg(p)
 37204			v3.AddArg(idx)
 37205			v3.AddArg(mem)
 37206			v2.AddArg(v3)
 37207			v1.AddArg(v2)
 37208			v0.AddArg(v1)
 37209			v0.AddArg(y)
 37210			return true
 37211		}
 37212		// match: (ORW or:(ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) y) s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)))
 37213		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 37214		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
 37215		for {
 37216			_ = v.Args[1]
 37217			or := v.Args[0]
 37218			if or.Op != OpS390XORW {
 37219				break
 37220			}
 37221			y := or.Args[1]
 37222			s0 := or.Args[0]
 37223			if s0.Op != OpS390XSLWconst {
 37224				break
 37225			}
 37226			j0 := s0.AuxInt
 37227			x0 := s0.Args[0]
 37228			if x0.Op != OpS390XMOVBZloadidx {
 37229				break
 37230			}
 37231			i0 := x0.AuxInt
 37232			s := x0.Aux
 37233			mem := x0.Args[2]
 37234			p := x0.Args[0]
 37235			idx := x0.Args[1]
 37236			s1 := v.Args[1]
 37237			if s1.Op != OpS390XSLWconst {
 37238				break
 37239			}
 37240			j1 := s1.AuxInt
 37241			x1 := s1.Args[0]
 37242			if x1.Op != OpS390XMOVBZloadidx {
 37243				break
 37244			}
 37245			i1 := x1.AuxInt
 37246			if x1.Aux != s {
 37247				break
 37248			}
 37249			_ = x1.Args[2]
 37250			if idx != x1.Args[0] {
 37251				break
 37252			}
 37253			if p != x1.Args[1] {
 37254				break
 37255			}
 37256			if mem != x1.Args[2] {
 37257				break
 37258			}
 37259			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 37260				break
 37261			}
 37262			b = mergePoint(b, x0, x1, y)
 37263			v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
 37264			v.reset(OpCopy)
 37265			v.AddArg(v0)
 37266			v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
 37267			v1.AuxInt = j0
 37268			v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 37269			v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 37270			v3.AuxInt = i0
 37271			v3.Aux = s
 37272			v3.AddArg(p)
 37273			v3.AddArg(idx)
 37274			v3.AddArg(mem)
 37275			v2.AddArg(v3)
 37276			v1.AddArg(v2)
 37277			v0.AddArg(v1)
 37278			v0.AddArg(y)
 37279			return true
 37280		}
 37281		return false
 37282	}
 37283	func rewriteValueS390X_OpS390XORW_90(v *Value) bool {
 37284		b := v.Block
 37285		typ := &b.Func.Config.Types
 37286		// match: (ORW or:(ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) y) s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)))
 37287		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 37288		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
 37289		for {
 37290			_ = v.Args[1]
 37291			or := v.Args[0]
 37292			if or.Op != OpS390XORW {
 37293				break
 37294			}
 37295			y := or.Args[1]
 37296			s0 := or.Args[0]
 37297			if s0.Op != OpS390XSLWconst {
 37298				break
 37299			}
 37300			j0 := s0.AuxInt
 37301			x0 := s0.Args[0]
 37302			if x0.Op != OpS390XMOVBZloadidx {
 37303				break
 37304			}
 37305			i0 := x0.AuxInt
 37306			s := x0.Aux
 37307			mem := x0.Args[2]
 37308			idx := x0.Args[0]
 37309			p := x0.Args[1]
 37310			s1 := v.Args[1]
 37311			if s1.Op != OpS390XSLWconst {
 37312				break
 37313			}
 37314			j1 := s1.AuxInt
 37315			x1 := s1.Args[0]
 37316			if x1.Op != OpS390XMOVBZloadidx {
 37317				break
 37318			}
 37319			i1 := x1.AuxInt
 37320			if x1.Aux != s {
 37321				break
 37322			}
 37323			_ = x1.Args[2]
 37324			if idx != x1.Args[0] {
 37325				break
 37326			}
 37327			if p != x1.Args[1] {
 37328				break
 37329			}
 37330			if mem != x1.Args[2] {
 37331				break
 37332			}
 37333			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 37334				break
 37335			}
 37336			b = mergePoint(b, x0, x1, y)
 37337			v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
 37338			v.reset(OpCopy)
 37339			v.AddArg(v0)
 37340			v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
 37341			v1.AuxInt = j0
 37342			v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 37343			v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 37344			v3.AuxInt = i0
 37345			v3.Aux = s
 37346			v3.AddArg(p)
 37347			v3.AddArg(idx)
 37348			v3.AddArg(mem)
 37349			v2.AddArg(v3)
 37350			v1.AddArg(v2)
 37351			v0.AddArg(v1)
 37352			v0.AddArg(y)
 37353			return true
 37354		}
 37355		// match: (ORW or:(ORW y s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem))) s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)))
 37356		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 37357		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
 37358		for {
 37359			_ = v.Args[1]
 37360			or := v.Args[0]
 37361			if or.Op != OpS390XORW {
 37362				break
 37363			}
 37364			_ = or.Args[1]
 37365			y := or.Args[0]
 37366			s0 := or.Args[1]
 37367			if s0.Op != OpS390XSLWconst {
 37368				break
 37369			}
 37370			j0 := s0.AuxInt
 37371			x0 := s0.Args[0]
 37372			if x0.Op != OpS390XMOVBZloadidx {
 37373				break
 37374			}
 37375			i0 := x0.AuxInt
 37376			s := x0.Aux
 37377			mem := x0.Args[2]
 37378			p := x0.Args[0]
 37379			idx := x0.Args[1]
 37380			s1 := v.Args[1]
 37381			if s1.Op != OpS390XSLWconst {
 37382				break
 37383			}
 37384			j1 := s1.AuxInt
 37385			x1 := s1.Args[0]
 37386			if x1.Op != OpS390XMOVBZloadidx {
 37387				break
 37388			}
 37389			i1 := x1.AuxInt
 37390			if x1.Aux != s {
 37391				break
 37392			}
 37393			_ = x1.Args[2]
 37394			if idx != x1.Args[0] {
 37395				break
 37396			}
 37397			if p != x1.Args[1] {
 37398				break
 37399			}
 37400			if mem != x1.Args[2] {
 37401				break
 37402			}
 37403			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 37404				break
 37405			}
 37406			b = mergePoint(b, x0, x1, y)
 37407			v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
 37408			v.reset(OpCopy)
 37409			v.AddArg(v0)
 37410			v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
 37411			v1.AuxInt = j0
 37412			v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 37413			v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 37414			v3.AuxInt = i0
 37415			v3.Aux = s
 37416			v3.AddArg(p)
 37417			v3.AddArg(idx)
 37418			v3.AddArg(mem)
 37419			v2.AddArg(v3)
 37420			v1.AddArg(v2)
 37421			v0.AddArg(v1)
 37422			v0.AddArg(y)
 37423			return true
 37424		}
 37425		// match: (ORW or:(ORW y s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem))) s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)))
 37426		// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
 37427		// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
 37428		for {
 37429			_ = v.Args[1]
 37430			or := v.Args[0]
 37431			if or.Op != OpS390XORW {
 37432				break
 37433			}
 37434			_ = or.Args[1]
 37435			y := or.Args[0]
 37436			s0 := or.Args[1]
 37437			if s0.Op != OpS390XSLWconst {
 37438				break
 37439			}
 37440			j0 := s0.AuxInt
 37441			x0 := s0.Args[0]
 37442			if x0.Op != OpS390XMOVBZloadidx {
 37443				break
 37444			}
 37445			i0 := x0.AuxInt
 37446			s := x0.Aux
 37447			mem := x0.Args[2]
 37448			idx := x0.Args[0]
 37449			p := x0.Args[1]
 37450			s1 := v.Args[1]
 37451			if s1.Op != OpS390XSLWconst {
 37452				break
 37453			}
 37454			j1 := s1.AuxInt
 37455			x1 := s1.Args[0]
 37456			if x1.Op != OpS390XMOVBZloadidx {
 37457				break
 37458			}
 37459			i1 := x1.AuxInt
 37460			if x1.Aux != s {
 37461				break
 37462			}
 37463			_ = x1.Args[2]
 37464			if idx != x1.Args[0] {
 37465				break
 37466			}
 37467			if p != x1.Args[1] {
 37468				break
 37469			}
 37470			if mem != x1.Args[2] {
 37471				break
 37472			}
 37473			if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1, y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
 37474				break
 37475			}
 37476			b = mergePoint(b, x0, x1, y)
 37477			v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
 37478			v.reset(OpCopy)
 37479			v.AddArg(v0)
 37480			v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
 37481			v1.AuxInt = j0
 37482			v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
 37483			v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
 37484			v3.AuxInt = i0
 37485			v3.Aux = s
 37486			v3.AddArg(p)
 37487			v3.AddArg(idx)
 37488			v3.AddArg(mem)
 37489			v2.AddArg(v3)
 37490			v1.AddArg(v2)
 37491			v0.AddArg(v1)
 37492			v0.AddArg(y)
 37493			return true
 37494		}
 37495		return false
 37496	}
 37497	func rewriteValueS390X_OpS390XORWconst_0(v *Value) bool {
 37498		// match: (ORWconst [c] x)
 37499		// cond: int32(c)==0
 37500		// result: x
 37501		for {
 37502			c := v.AuxInt
 37503			x := v.Args[0]
 37504			if !(int32(c) == 0) {
 37505				break
 37506			}
 37507			v.reset(OpCopy)
 37508			v.Type = x.Type
 37509			v.AddArg(x)
 37510			return true
 37511		}
 37512		// match: (ORWconst [c] _)
 37513		// cond: int32(c)==-1
 37514		// result: (MOVDconst [-1])
 37515		for {
 37516			c := v.AuxInt
 37517			if !(int32(c) == -1) {
 37518				break
 37519			}
 37520			v.reset(OpS390XMOVDconst)
 37521			v.AuxInt = -1
 37522			return true
 37523		}
 37524		// match: (ORWconst [c] (MOVDconst [d]))
 37525		// cond:
 37526		// result: (MOVDconst [c|d])
 37527		for {
 37528			c := v.AuxInt
 37529			v_0 := v.Args[0]
 37530			if v_0.Op != OpS390XMOVDconst {
 37531				break
 37532			}
 37533			d := v_0.AuxInt
 37534			v.reset(OpS390XMOVDconst)
 37535			v.AuxInt = c | d
 37536			return true
 37537		}
 37538		return false
 37539	}
 37540	func rewriteValueS390X_OpS390XORWload_0(v *Value) bool {
 37541		// match: (ORWload [off1] {sym} x (ADDconst [off2] ptr) mem)
 37542		// cond: ptr.Op != OpSB && is20Bit(off1+off2)
 37543		// result: (ORWload [off1+off2] {sym} x ptr mem)
 37544		for {
 37545			off1 := v.AuxInt
 37546			sym := v.Aux
 37547			mem := v.Args[2]
 37548			x := v.Args[0]
 37549			v_1 := v.Args[1]
 37550			if v_1.Op != OpS390XADDconst {
 37551				break
 37552			}
 37553			off2 := v_1.AuxInt
 37554			ptr := v_1.Args[0]
 37555			if !(ptr.Op != OpSB && is20Bit(off1+off2)) {
 37556				break
 37557			}
 37558			v.reset(OpS390XORWload)
 37559			v.AuxInt = off1 + off2
 37560			v.Aux = sym
 37561			v.AddArg(x)
 37562			v.AddArg(ptr)
 37563			v.AddArg(mem)
 37564			return true
 37565		}
 37566		// match: (ORWload [o1] {s1} x (MOVDaddr [o2] {s2} ptr) mem)
 37567		// cond: ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)
 37568		// result: (ORWload [o1+o2] {mergeSym(s1, s2)} x ptr mem)
 37569		for {
 37570			o1 := v.AuxInt
 37571			s1 := v.Aux
 37572			mem := v.Args[2]
 37573			x := v.Args[0]
 37574			v_1 := v.Args[1]
 37575			if v_1.Op != OpS390XMOVDaddr {
 37576				break
 37577			}
 37578			o2 := v_1.AuxInt
 37579			s2 := v_1.Aux
 37580			ptr := v_1.Args[0]
 37581			if !(ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)) {
 37582				break
 37583			}
 37584			v.reset(OpS390XORWload)
 37585			v.AuxInt = o1 + o2
 37586			v.Aux = mergeSym(s1, s2)
 37587			v.AddArg(x)
 37588			v.AddArg(ptr)
 37589			v.AddArg(mem)
 37590			return true
 37591		}
 37592		return false
 37593	}
 37594	func rewriteValueS390X_OpS390XORconst_0(v *Value) bool {
 37595		// match: (ORconst [0] x)
 37596		// cond:
 37597		// result: x
 37598		for {
 37599			if v.AuxInt != 0 {
 37600				break
 37601			}
 37602			x := v.Args[0]
 37603			v.reset(OpCopy)
 37604			v.Type = x.Type
 37605			v.AddArg(x)
 37606			return true
 37607		}
 37608		// match: (ORconst [-1] _)
 37609		// cond:
 37610		// result: (MOVDconst [-1])
 37611		for {
 37612			if v.AuxInt != -1 {
 37613				break
 37614			}
 37615			v.reset(OpS390XMOVDconst)
 37616			v.AuxInt = -1
 37617			return true
 37618		}
 37619		// match: (ORconst [c] (MOVDconst [d]))
 37620		// cond:
 37621		// result: (MOVDconst [c|d])
 37622		for {
 37623			c := v.AuxInt
 37624			v_0 := v.Args[0]
 37625			if v_0.Op != OpS390XMOVDconst {
 37626				break
 37627			}
 37628			d := v_0.AuxInt
 37629			v.reset(OpS390XMOVDconst)
 37630			v.AuxInt = c | d
 37631			return true
 37632		}
 37633		return false
 37634	}
 37635	func rewriteValueS390X_OpS390XORload_0(v *Value) bool {
 37636		b := v.Block
 37637		// match: (ORload <t> [off] {sym} x ptr1 (FMOVDstore [off] {sym} ptr2 y _))
 37638		// cond: isSamePtr(ptr1, ptr2)
 37639		// result: (OR x (LGDR <t> y))
 37640		for {
 37641			t := v.Type
 37642			off := v.AuxInt
 37643			sym := v.Aux
 37644			_ = v.Args[2]
 37645			x := v.Args[0]
 37646			ptr1 := v.Args[1]
 37647			v_2 := v.Args[2]
 37648			if v_2.Op != OpS390XFMOVDstore {
 37649				break
 37650			}
 37651			if v_2.AuxInt != off {
 37652				break
 37653			}
 37654			if v_2.Aux != sym {
 37655				break
 37656			}
 37657			_ = v_2.Args[2]
 37658			ptr2 := v_2.Args[0]
 37659			y := v_2.Args[1]
 37660			if !(isSamePtr(ptr1, ptr2)) {
 37661				break
 37662			}
 37663			v.reset(OpS390XOR)
 37664			v.AddArg(x)
 37665			v0 := b.NewValue0(v_2.Pos, OpS390XLGDR, t)
 37666			v0.AddArg(y)
 37667			v.AddArg(v0)
 37668			return true
 37669		}
 37670		// match: (ORload [off1] {sym} x (ADDconst [off2] ptr) mem)
 37671		// cond: ptr.Op != OpSB && is20Bit(off1+off2)
 37672		// result: (ORload [off1+off2] {sym} x ptr mem)
 37673		for {
 37674			off1 := v.AuxInt
 37675			sym := v.Aux
 37676			mem := v.Args[2]
 37677			x := v.Args[0]
 37678			v_1 := v.Args[1]
 37679			if v_1.Op != OpS390XADDconst {
 37680				break
 37681			}
 37682			off2 := v_1.AuxInt
 37683			ptr := v_1.Args[0]
 37684			if !(ptr.Op != OpSB && is20Bit(off1+off2)) {
 37685				break
 37686			}
 37687			v.reset(OpS390XORload)
 37688			v.AuxInt = off1 + off2
 37689			v.Aux = sym
 37690			v.AddArg(x)
 37691			v.AddArg(ptr)
 37692			v.AddArg(mem)
 37693			return true
 37694		}
 37695		// match: (ORload [o1] {s1} x (MOVDaddr [o2] {s2} ptr) mem)
 37696		// cond: ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)
 37697		// result: (ORload [o1+o2] {mergeSym(s1, s2)} x ptr mem)
 37698		for {
 37699			o1 := v.AuxInt
 37700			s1 := v.Aux
 37701			mem := v.Args[2]
 37702			x := v.Args[0]
 37703			v_1 := v.Args[1]
 37704			if v_1.Op != OpS390XMOVDaddr {
 37705				break
 37706			}
 37707			o2 := v_1.AuxInt
 37708			s2 := v_1.Aux
 37709			ptr := v_1.Args[0]
 37710			if !(ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)) {
 37711				break
 37712			}
 37713			v.reset(OpS390XORload)
 37714			v.AuxInt = o1 + o2
 37715			v.Aux = mergeSym(s1, s2)
 37716			v.AddArg(x)
 37717			v.AddArg(ptr)
 37718			v.AddArg(mem)
 37719			return true
 37720		}
 37721		return false
 37722	}
 37723	func rewriteValueS390X_OpS390XRLL_0(v *Value) bool {
 37724		// match: (RLL x (MOVDconst [c]))
 37725		// cond:
 37726		// result: (RLLconst x [c&31])
 37727		for {
 37728			_ = v.Args[1]
 37729			x := v.Args[0]
 37730			v_1 := v.Args[1]
 37731			if v_1.Op != OpS390XMOVDconst {
 37732				break
 37733			}
 37734			c := v_1.AuxInt
 37735			v.reset(OpS390XRLLconst)
 37736			v.AuxInt = c & 31
 37737			v.AddArg(x)
 37738			return true
 37739		}
 37740		return false
 37741	}
 37742	func rewriteValueS390X_OpS390XRLLG_0(v *Value) bool {
 37743		// match: (RLLG x (MOVDconst [c]))
 37744		// cond:
 37745		// result: (RLLGconst x [c&63])
 37746		for {
 37747			_ = v.Args[1]
 37748			x := v.Args[0]
 37749			v_1 := v.Args[1]
 37750			if v_1.Op != OpS390XMOVDconst {
 37751				break
 37752			}
 37753			c := v_1.AuxInt
 37754			v.reset(OpS390XRLLGconst)
 37755			v.AuxInt = c & 63
 37756			v.AddArg(x)
 37757			return true
 37758		}
 37759		return false
 37760	}
 37761	func rewriteValueS390X_OpS390XSLD_0(v *Value) bool {
 37762		b := v.Block
 37763		typ := &b.Func.Config.Types
 37764		// match: (SLD x (MOVDconst [c]))
 37765		// cond:
 37766		// result: (SLDconst x [c&63])
 37767		for {
 37768			_ = v.Args[1]
 37769			x := v.Args[0]
 37770			v_1 := v.Args[1]
 37771			if v_1.Op != OpS390XMOVDconst {
 37772				break
 37773			}
 37774			c := v_1.AuxInt
 37775			v.reset(OpS390XSLDconst)
 37776			v.AuxInt = c & 63
 37777			v.AddArg(x)
 37778			return true
 37779		}
 37780		// match: (SLD x (AND (MOVDconst [c]) y))
 37781		// cond:
 37782		// result: (SLD x (ANDWconst <typ.UInt32> [c&63] y))
 37783		for {
 37784			_ = v.Args[1]
 37785			x := v.Args[0]
 37786			v_1 := v.Args[1]
 37787			if v_1.Op != OpS390XAND {
 37788				break
 37789			}
 37790			y := v_1.Args[1]
 37791			v_1_0 := v_1.Args[0]
 37792			if v_1_0.Op != OpS390XMOVDconst {
 37793				break
 37794			}
 37795			c := v_1_0.AuxInt
 37796			v.reset(OpS390XSLD)
 37797			v.AddArg(x)
 37798			v0 := b.NewValue0(v.Pos, OpS390XANDWconst, typ.UInt32)
 37799			v0.AuxInt = c & 63
 37800			v0.AddArg(y)
 37801			v.AddArg(v0)
 37802			return true
 37803		}
 37804		// match: (SLD x (AND y (MOVDconst [c])))
 37805		// cond:
 37806		// result: (SLD x (ANDWconst <typ.UInt32> [c&63] y))
 37807		for {
 37808			_ = v.Args[1]
 37809			x := v.Args[0]
 37810			v_1 := v.Args[1]
 37811			if v_1.Op != OpS390XAND {
 37812				break
 37813			}
 37814			_ = v_1.Args[1]
 37815			y := v_1.Args[0]
 37816			v_1_1 := v_1.Args[1]
 37817			if v_1_1.Op != OpS390XMOVDconst {
 37818				break
 37819			}
 37820			c := v_1_1.AuxInt
 37821			v.reset(OpS390XSLD)
 37822			v.AddArg(x)
 37823			v0 := b.NewValue0(v.Pos, OpS390XANDWconst, typ.UInt32)
 37824			v0.AuxInt = c & 63
 37825			v0.AddArg(y)
 37826			v.AddArg(v0)
 37827			return true
 37828		}
 37829		// match: (SLD x (ANDWconst [c] y))
 37830		// cond: c&63 == 63
 37831		// result: (SLD x y)
 37832		for {
 37833			_ = v.Args[1]
 37834			x := v.Args[0]
 37835			v_1 := v.Args[1]
 37836			if v_1.Op != OpS390XANDWconst {
 37837				break
 37838			}
 37839			c := v_1.AuxInt
 37840			y := v_1.Args[0]
 37841			if !(c&63 == 63) {
 37842				break
 37843			}
 37844			v.reset(OpS390XSLD)
 37845			v.AddArg(x)
 37846			v.AddArg(y)
 37847			return true
 37848		}
 37849		// match: (SLD x (MOVDreg y))
 37850		// cond:
 37851		// result: (SLD x y)
 37852		for {
 37853			_ = v.Args[1]
 37854			x := v.Args[0]
 37855			v_1 := v.Args[1]
 37856			if v_1.Op != OpS390XMOVDreg {
 37857				break
 37858			}
 37859			y := v_1.Args[0]
 37860			v.reset(OpS390XSLD)
 37861			v.AddArg(x)
 37862			v.AddArg(y)
 37863			return true
 37864		}
 37865		// match: (SLD x (MOVWreg y))
 37866		// cond:
 37867		// result: (SLD x y)
 37868		for {
 37869			_ = v.Args[1]
 37870			x := v.Args[0]
 37871			v_1 := v.Args[1]
 37872			if v_1.Op != OpS390XMOVWreg {
 37873				break
 37874			}
 37875			y := v_1.Args[0]
 37876			v.reset(OpS390XSLD)
 37877			v.AddArg(x)
 37878			v.AddArg(y)
 37879			return true
 37880		}
 37881		// match: (SLD x (MOVHreg y))
 37882		// cond:
 37883		// result: (SLD x y)
 37884		for {
 37885			_ = v.Args[1]
 37886			x := v.Args[0]
 37887			v_1 := v.Args[1]
 37888			if v_1.Op != OpS390XMOVHreg {
 37889				break
 37890			}
 37891			y := v_1.Args[0]
 37892			v.reset(OpS390XSLD)
 37893			v.AddArg(x)
 37894			v.AddArg(y)
 37895			return true
 37896		}
 37897		// match: (SLD x (MOVBreg y))
 37898		// cond:
 37899		// result: (SLD x y)
 37900		for {
 37901			_ = v.Args[1]
 37902			x := v.Args[0]
 37903			v_1 := v.Args[1]
 37904			if v_1.Op != OpS390XMOVBreg {
 37905				break
 37906			}
 37907			y := v_1.Args[0]
 37908			v.reset(OpS390XSLD)
 37909			v.AddArg(x)
 37910			v.AddArg(y)
 37911			return true
 37912		}
 37913		// match: (SLD x (MOVWZreg y))
 37914		// cond:
 37915		// result: (SLD x y)
 37916		for {
 37917			_ = v.Args[1]
 37918			x := v.Args[0]
 37919			v_1 := v.Args[1]
 37920			if v_1.Op != OpS390XMOVWZreg {
 37921				break
 37922			}
 37923			y := v_1.Args[0]
 37924			v.reset(OpS390XSLD)
 37925			v.AddArg(x)
 37926			v.AddArg(y)
 37927			return true
 37928		}
 37929		// match: (SLD x (MOVHZreg y))
 37930		// cond:
 37931		// result: (SLD x y)
 37932		for {
 37933			_ = v.Args[1]
 37934			x := v.Args[0]
 37935			v_1 := v.Args[1]
 37936			if v_1.Op != OpS390XMOVHZreg {
 37937				break
 37938			}
 37939			y := v_1.Args[0]
 37940			v.reset(OpS390XSLD)
 37941			v.AddArg(x)
 37942			v.AddArg(y)
 37943			return true
 37944		}
 37945		return false
 37946	}
 37947	func rewriteValueS390X_OpS390XSLD_10(v *Value) bool {
 37948		// match: (SLD x (MOVBZreg y))
 37949		// cond:
 37950		// result: (SLD x y)
 37951		for {
 37952			_ = v.Args[1]
 37953			x := v.Args[0]
 37954			v_1 := v.Args[1]
 37955			if v_1.Op != OpS390XMOVBZreg {
 37956				break
 37957			}
 37958			y := v_1.Args[0]
 37959			v.reset(OpS390XSLD)
 37960			v.AddArg(x)
 37961			v.AddArg(y)
 37962			return true
 37963		}
 37964		return false
 37965	}
 37966	func rewriteValueS390X_OpS390XSLW_0(v *Value) bool {
 37967		b := v.Block
 37968		typ := &b.Func.Config.Types
 37969		// match: (SLW x (MOVDconst [c]))
 37970		// cond:
 37971		// result: (SLWconst x [c&63])
 37972		for {
 37973			_ = v.Args[1]
 37974			x := v.Args[0]
 37975			v_1 := v.Args[1]
 37976			if v_1.Op != OpS390XMOVDconst {
 37977				break
 37978			}
 37979			c := v_1.AuxInt
 37980			v.reset(OpS390XSLWconst)
 37981			v.AuxInt = c & 63
 37982			v.AddArg(x)
 37983			return true
 37984		}
 37985		// match: (SLW x (AND (MOVDconst [c]) y))
 37986		// cond:
 37987		// result: (SLW x (ANDWconst <typ.UInt32> [c&63] y))
 37988		for {
 37989			_ = v.Args[1]
 37990			x := v.Args[0]
 37991			v_1 := v.Args[1]
 37992			if v_1.Op != OpS390XAND {
 37993				break
 37994			}
 37995			y := v_1.Args[1]
 37996			v_1_0 := v_1.Args[0]
 37997			if v_1_0.Op != OpS390XMOVDconst {
 37998				break
 37999			}
 38000			c := v_1_0.AuxInt
 38001			v.reset(OpS390XSLW)
 38002			v.AddArg(x)
 38003			v0 := b.NewValue0(v.Pos, OpS390XANDWconst, typ.UInt32)
 38004			v0.AuxInt = c & 63
 38005			v0.AddArg(y)
 38006			v.AddArg(v0)
 38007			return true
 38008		}
 38009		// match: (SLW x (AND y (MOVDconst [c])))
 38010		// cond:
 38011		// result: (SLW x (ANDWconst <typ.UInt32> [c&63] y))
 38012		for {
 38013			_ = v.Args[1]
 38014			x := v.Args[0]
 38015			v_1 := v.Args[1]
 38016			if v_1.Op != OpS390XAND {
 38017				break
 38018			}
 38019			_ = v_1.Args[1]
 38020			y := v_1.Args[0]
 38021			v_1_1 := v_1.Args[1]
 38022			if v_1_1.Op != OpS390XMOVDconst {
 38023				break
 38024			}
 38025			c := v_1_1.AuxInt
 38026			v.reset(OpS390XSLW)
 38027			v.AddArg(x)
 38028			v0 := b.NewValue0(v.Pos, OpS390XANDWconst, typ.UInt32)
 38029			v0.AuxInt = c & 63
 38030			v0.AddArg(y)
 38031			v.AddArg(v0)
 38032			return true
 38033		}
 38034		// match: (SLW x (ANDWconst [c] y))
 38035		// cond: c&63 == 63
 38036		// result: (SLW x y)
 38037		for {
 38038			_ = v.Args[1]
 38039			x := v.Args[0]
 38040			v_1 := v.Args[1]
 38041			if v_1.Op != OpS390XANDWconst {
 38042				break
 38043			}
 38044			c := v_1.AuxInt
 38045			y := v_1.Args[0]
 38046			if !(c&63 == 63) {
 38047				break
 38048			}
 38049			v.reset(OpS390XSLW)
 38050			v.AddArg(x)
 38051			v.AddArg(y)
 38052			return true
 38053		}
 38054		// match: (SLW x (MOVDreg y))
 38055		// cond:
 38056		// result: (SLW x y)
 38057		for {
 38058			_ = v.Args[1]
 38059			x := v.Args[0]
 38060			v_1 := v.Args[1]
 38061			if v_1.Op != OpS390XMOVDreg {
 38062				break
 38063			}
 38064			y := v_1.Args[0]
 38065			v.reset(OpS390XSLW)
 38066			v.AddArg(x)
 38067			v.AddArg(y)
 38068			return true
 38069		}
 38070		// match: (SLW x (MOVWreg y))
 38071		// cond:
 38072		// result: (SLW x y)
 38073		for {
 38074			_ = v.Args[1]
 38075			x := v.Args[0]
 38076			v_1 := v.Args[1]
 38077			if v_1.Op != OpS390XMOVWreg {
 38078				break
 38079			}
 38080			y := v_1.Args[0]
 38081			v.reset(OpS390XSLW)
 38082			v.AddArg(x)
 38083			v.AddArg(y)
 38084			return true
 38085		}
 38086		// match: (SLW x (MOVHreg y))
 38087		// cond:
 38088		// result: (SLW x y)
 38089		for {
 38090			_ = v.Args[1]
 38091			x := v.Args[0]
 38092			v_1 := v.Args[1]
 38093			if v_1.Op != OpS390XMOVHreg {
 38094				break
 38095			}
 38096			y := v_1.Args[0]
 38097			v.reset(OpS390XSLW)
 38098			v.AddArg(x)
 38099			v.AddArg(y)
 38100			return true
 38101		}
 38102		// match: (SLW x (MOVBreg y))
 38103		// cond:
 38104		// result: (SLW x y)
 38105		for {
 38106			_ = v.Args[1]
 38107			x := v.Args[0]
 38108			v_1 := v.Args[1]
 38109			if v_1.Op != OpS390XMOVBreg {
 38110				break
 38111			}
 38112			y := v_1.Args[0]
 38113			v.reset(OpS390XSLW)
 38114			v.AddArg(x)
 38115			v.AddArg(y)
 38116			return true
 38117		}
 38118		// match: (SLW x (MOVWZreg y))
 38119		// cond:
 38120		// result: (SLW x y)
 38121		for {
 38122			_ = v.Args[1]
 38123			x := v.Args[0]
 38124			v_1 := v.Args[1]
 38125			if v_1.Op != OpS390XMOVWZreg {
 38126				break
 38127			}
 38128			y := v_1.Args[0]
 38129			v.reset(OpS390XSLW)
 38130			v.AddArg(x)
 38131			v.AddArg(y)
 38132			return true
 38133		}
 38134		// match: (SLW x (MOVHZreg y))
 38135		// cond:
 38136		// result: (SLW x y)
 38137		for {
 38138			_ = v.Args[1]
 38139			x := v.Args[0]
 38140			v_1 := v.Args[1]
 38141			if v_1.Op != OpS390XMOVHZreg {
 38142				break
 38143			}
 38144			y := v_1.Args[0]
 38145			v.reset(OpS390XSLW)
 38146			v.AddArg(x)
 38147			v.AddArg(y)
 38148			return true
 38149		}
 38150		return false
 38151	}
 38152	func rewriteValueS390X_OpS390XSLW_10(v *Value) bool {
 38153		// match: (SLW x (MOVBZreg y))
 38154		// cond:
 38155		// result: (SLW x y)
 38156		for {
 38157			_ = v.Args[1]
 38158			x := v.Args[0]
 38159			v_1 := v.Args[1]
 38160			if v_1.Op != OpS390XMOVBZreg {
 38161				break
 38162			}
 38163			y := v_1.Args[0]
 38164			v.reset(OpS390XSLW)
 38165			v.AddArg(x)
 38166			v.AddArg(y)
 38167			return true
 38168		}
 38169		return false
 38170	}
 38171	func rewriteValueS390X_OpS390XSRAD_0(v *Value) bool {
 38172		b := v.Block
 38173		typ := &b.Func.Config.Types
 38174		// match: (SRAD x (MOVDconst [c]))
 38175		// cond:
 38176		// result: (SRADconst x [c&63])
 38177		for {
 38178			_ = v.Args[1]
 38179			x := v.Args[0]
 38180			v_1 := v.Args[1]
 38181			if v_1.Op != OpS390XMOVDconst {
 38182				break
 38183			}
 38184			c := v_1.AuxInt
 38185			v.reset(OpS390XSRADconst)
 38186			v.AuxInt = c & 63
 38187			v.AddArg(x)
 38188			return true
 38189		}
 38190		// match: (SRAD x (AND (MOVDconst [c]) y))
 38191		// cond:
 38192		// result: (SRAD x (ANDWconst <typ.UInt32> [c&63] y))
 38193		for {
 38194			_ = v.Args[1]
 38195			x := v.Args[0]
 38196			v_1 := v.Args[1]
 38197			if v_1.Op != OpS390XAND {
 38198				break
 38199			}
 38200			y := v_1.Args[1]
 38201			v_1_0 := v_1.Args[0]
 38202			if v_1_0.Op != OpS390XMOVDconst {
 38203				break
 38204			}
 38205			c := v_1_0.AuxInt
 38206			v.reset(OpS390XSRAD)
 38207			v.AddArg(x)
 38208			v0 := b.NewValue0(v.Pos, OpS390XANDWconst, typ.UInt32)
 38209			v0.AuxInt = c & 63
 38210			v0.AddArg(y)
 38211			v.AddArg(v0)
 38212			return true
 38213		}
 38214		// match: (SRAD x (AND y (MOVDconst [c])))
 38215		// cond:
 38216		// result: (SRAD x (ANDWconst <typ.UInt32> [c&63] y))
 38217		for {
 38218			_ = v.Args[1]
 38219			x := v.Args[0]
 38220			v_1 := v.Args[1]
 38221			if v_1.Op != OpS390XAND {
 38222				break
 38223			}
 38224			_ = v_1.Args[1]
 38225			y := v_1.Args[0]
 38226			v_1_1 := v_1.Args[1]
 38227			if v_1_1.Op != OpS390XMOVDconst {
 38228				break
 38229			}
 38230			c := v_1_1.AuxInt
 38231			v.reset(OpS390XSRAD)
 38232			v.AddArg(x)
 38233			v0 := b.NewValue0(v.Pos, OpS390XANDWconst, typ.UInt32)
 38234			v0.AuxInt = c & 63
 38235			v0.AddArg(y)
 38236			v.AddArg(v0)
 38237			return true
 38238		}
 38239		// match: (SRAD x (ANDWconst [c] y))
 38240		// cond: c&63 == 63
 38241		// result: (SRAD x y)
 38242		for {
 38243			_ = v.Args[1]
 38244			x := v.Args[0]
 38245			v_1 := v.Args[1]
 38246			if v_1.Op != OpS390XANDWconst {
 38247				break
 38248			}
 38249			c := v_1.AuxInt
 38250			y := v_1.Args[0]
 38251			if !(c&63 == 63) {
 38252				break
 38253			}
 38254			v.reset(OpS390XSRAD)
 38255			v.AddArg(x)
 38256			v.AddArg(y)
 38257			return true
 38258		}
 38259		// match: (SRAD x (MOVDreg y))
 38260		// cond:
 38261		// result: (SRAD x y)
 38262		for {
 38263			_ = v.Args[1]
 38264			x := v.Args[0]
 38265			v_1 := v.Args[1]
 38266			if v_1.Op != OpS390XMOVDreg {
 38267				break
 38268			}
 38269			y := v_1.Args[0]
 38270			v.reset(OpS390XSRAD)
 38271			v.AddArg(x)
 38272			v.AddArg(y)
 38273			return true
 38274		}
 38275		// match: (SRAD x (MOVWreg y))
 38276		// cond:
 38277		// result: (SRAD x y)
 38278		for {
 38279			_ = v.Args[1]
 38280			x := v.Args[0]
 38281			v_1 := v.Args[1]
 38282			if v_1.Op != OpS390XMOVWreg {
 38283				break
 38284			}
 38285			y := v_1.Args[0]
 38286			v.reset(OpS390XSRAD)
 38287			v.AddArg(x)
 38288			v.AddArg(y)
 38289			return true
 38290		}
 38291		// match: (SRAD x (MOVHreg y))
 38292		// cond:
 38293		// result: (SRAD x y)
 38294		for {
 38295			_ = v.Args[1]
 38296			x := v.Args[0]
 38297			v_1 := v.Args[1]
 38298			if v_1.Op != OpS390XMOVHreg {
 38299				break
 38300			}
 38301			y := v_1.Args[0]
 38302			v.reset(OpS390XSRAD)
 38303			v.AddArg(x)
 38304			v.AddArg(y)
 38305			return true
 38306		}
 38307		// match: (SRAD x (MOVBreg y))
 38308		// cond:
 38309		// result: (SRAD x y)
 38310		for {
 38311			_ = v.Args[1]
 38312			x := v.Args[0]
 38313			v_1 := v.Args[1]
 38314			if v_1.Op != OpS390XMOVBreg {
 38315				break
 38316			}
 38317			y := v_1.Args[0]
 38318			v.reset(OpS390XSRAD)
 38319			v.AddArg(x)
 38320			v.AddArg(y)
 38321			return true
 38322		}
 38323		// match: (SRAD x (MOVWZreg y))
 38324		// cond:
 38325		// result: (SRAD x y)
 38326		for {
 38327			_ = v.Args[1]
 38328			x := v.Args[0]
 38329			v_1 := v.Args[1]
 38330			if v_1.Op != OpS390XMOVWZreg {
 38331				break
 38332			}
 38333			y := v_1.Args[0]
 38334			v.reset(OpS390XSRAD)
 38335			v.AddArg(x)
 38336			v.AddArg(y)
 38337			return true
 38338		}
 38339		// match: (SRAD x (MOVHZreg y))
 38340		// cond:
 38341		// result: (SRAD x y)
 38342		for {
 38343			_ = v.Args[1]
 38344			x := v.Args[0]
 38345			v_1 := v.Args[1]
 38346			if v_1.Op != OpS390XMOVHZreg {
 38347				break
 38348			}
 38349			y := v_1.Args[0]
 38350			v.reset(OpS390XSRAD)
 38351			v.AddArg(x)
 38352			v.AddArg(y)
 38353			return true
 38354		}
 38355		return false
 38356	}
 38357	func rewriteValueS390X_OpS390XSRAD_10(v *Value) bool {
 38358		// match: (SRAD x (MOVBZreg y))
 38359		// cond:
 38360		// result: (SRAD x y)
 38361		for {
 38362			_ = v.Args[1]
 38363			x := v.Args[0]
 38364			v_1 := v.Args[1]
 38365			if v_1.Op != OpS390XMOVBZreg {
 38366				break
 38367			}
 38368			y := v_1.Args[0]
 38369			v.reset(OpS390XSRAD)
 38370			v.AddArg(x)
 38371			v.AddArg(y)
 38372			return true
 38373		}
 38374		return false
 38375	}
 38376	func rewriteValueS390X_OpS390XSRADconst_0(v *Value) bool {
 38377		// match: (SRADconst [c] (MOVDconst [d]))
 38378		// cond:
 38379		// result: (MOVDconst [d>>uint64(c)])
 38380		for {
 38381			c := v.AuxInt
 38382			v_0 := v.Args[0]
 38383			if v_0.Op != OpS390XMOVDconst {
 38384				break
 38385			}
 38386			d := v_0.AuxInt
 38387			v.reset(OpS390XMOVDconst)
 38388			v.AuxInt = d >> uint64(c)
 38389			return true
 38390		}
 38391		return false
 38392	}
 38393	func rewriteValueS390X_OpS390XSRAW_0(v *Value) bool {
 38394		b := v.Block
 38395		typ := &b.Func.Config.Types
 38396		// match: (SRAW x (MOVDconst [c]))
 38397		// cond:
 38398		// result: (SRAWconst x [c&63])
 38399		for {
 38400			_ = v.Args[1]
 38401			x := v.Args[0]
 38402			v_1 := v.Args[1]
 38403			if v_1.Op != OpS390XMOVDconst {
 38404				break
 38405			}
 38406			c := v_1.AuxInt
 38407			v.reset(OpS390XSRAWconst)
 38408			v.AuxInt = c & 63
 38409			v.AddArg(x)
 38410			return true
 38411		}
 38412		// match: (SRAW x (AND (MOVDconst [c]) y))
 38413		// cond:
 38414		// result: (SRAW x (ANDWconst <typ.UInt32> [c&63] y))
 38415		for {
 38416			_ = v.Args[1]
 38417			x := v.Args[0]
 38418			v_1 := v.Args[1]
 38419			if v_1.Op != OpS390XAND {
 38420				break
 38421			}
 38422			y := v_1.Args[1]
 38423			v_1_0 := v_1.Args[0]
 38424			if v_1_0.Op != OpS390XMOVDconst {
 38425				break
 38426			}
 38427			c := v_1_0.AuxInt
 38428			v.reset(OpS390XSRAW)
 38429			v.AddArg(x)
 38430			v0 := b.NewValue0(v.Pos, OpS390XANDWconst, typ.UInt32)
 38431			v0.AuxInt = c & 63
 38432			v0.AddArg(y)
 38433			v.AddArg(v0)
 38434			return true
 38435		}
 38436		// match: (SRAW x (AND y (MOVDconst [c])))
 38437		// cond:
 38438		// result: (SRAW x (ANDWconst <typ.UInt32> [c&63] y))
 38439		for {
 38440			_ = v.Args[1]
 38441			x := v.Args[0]
 38442			v_1 := v.Args[1]
 38443			if v_1.Op != OpS390XAND {
 38444				break
 38445			}
 38446			_ = v_1.Args[1]
 38447			y := v_1.Args[0]
 38448			v_1_1 := v_1.Args[1]
 38449			if v_1_1.Op != OpS390XMOVDconst {
 38450				break
 38451			}
 38452			c := v_1_1.AuxInt
 38453			v.reset(OpS390XSRAW)
 38454			v.AddArg(x)
 38455			v0 := b.NewValue0(v.Pos, OpS390XANDWconst, typ.UInt32)
 38456			v0.AuxInt = c & 63
 38457			v0.AddArg(y)
 38458			v.AddArg(v0)
 38459			return true
 38460		}
 38461		// match: (SRAW x (ANDWconst [c] y))
 38462		// cond: c&63 == 63
 38463		// result: (SRAW x y)
 38464		for {
 38465			_ = v.Args[1]
 38466			x := v.Args[0]
 38467			v_1 := v.Args[1]
 38468			if v_1.Op != OpS390XANDWconst {
 38469				break
 38470			}
 38471			c := v_1.AuxInt
 38472			y := v_1.Args[0]
 38473			if !(c&63 == 63) {
 38474				break
 38475			}
 38476			v.reset(OpS390XSRAW)
 38477			v.AddArg(x)
 38478			v.AddArg(y)
 38479			return true
 38480		}
 38481		// match: (SRAW x (MOVDreg y))
 38482		// cond:
 38483		// result: (SRAW x y)
 38484		for {
 38485			_ = v.Args[1]
 38486			x := v.Args[0]
 38487			v_1 := v.Args[1]
 38488			if v_1.Op != OpS390XMOVDreg {
 38489				break
 38490			}
 38491			y := v_1.Args[0]
 38492			v.reset(OpS390XSRAW)
 38493			v.AddArg(x)
 38494			v.AddArg(y)
 38495			return true
 38496		}
 38497		// match: (SRAW x (MOVWreg y))
 38498		// cond:
 38499		// result: (SRAW x y)
 38500		for {
 38501			_ = v.Args[1]
 38502			x := v.Args[0]
 38503			v_1 := v.Args[1]
 38504			if v_1.Op != OpS390XMOVWreg {
 38505				break
 38506			}
 38507			y := v_1.Args[0]
 38508			v.reset(OpS390XSRAW)
 38509			v.AddArg(x)
 38510			v.AddArg(y)
 38511			return true
 38512		}
 38513		// match: (SRAW x (MOVHreg y))
 38514		// cond:
 38515		// result: (SRAW x y)
 38516		for {
 38517			_ = v.Args[1]
 38518			x := v.Args[0]
 38519			v_1 := v.Args[1]
 38520			if v_1.Op != OpS390XMOVHreg {
 38521				break
 38522			}
 38523			y := v_1.Args[0]
 38524			v.reset(OpS390XSRAW)
 38525			v.AddArg(x)
 38526			v.AddArg(y)
 38527			return true
 38528		}
 38529		// match: (SRAW x (MOVBreg y))
 38530		// cond:
 38531		// result: (SRAW x y)
 38532		for {
 38533			_ = v.Args[1]
 38534			x := v.Args[0]
 38535			v_1 := v.Args[1]
 38536			if v_1.Op != OpS390XMOVBreg {
 38537				break
 38538			}
 38539			y := v_1.Args[0]
 38540			v.reset(OpS390XSRAW)
 38541			v.AddArg(x)
 38542			v.AddArg(y)
 38543			return true
 38544		}
 38545		// match: (SRAW x (MOVWZreg y))
 38546		// cond:
 38547		// result: (SRAW x y)
 38548		for {
 38549			_ = v.Args[1]
 38550			x := v.Args[0]
 38551			v_1 := v.Args[1]
 38552			if v_1.Op != OpS390XMOVWZreg {
 38553				break
 38554			}
 38555			y := v_1.Args[0]
 38556			v.reset(OpS390XSRAW)
 38557			v.AddArg(x)
 38558			v.AddArg(y)
 38559			return true
 38560		}
 38561		// match: (SRAW x (MOVHZreg y))
 38562		// cond:
 38563		// result: (SRAW x y)
 38564		for {
 38565			_ = v.Args[1]
 38566			x := v.Args[0]
 38567			v_1 := v.Args[1]
 38568			if v_1.Op != OpS390XMOVHZreg {
 38569				break
 38570			}
 38571			y := v_1.Args[0]
 38572			v.reset(OpS390XSRAW)
 38573			v.AddArg(x)
 38574			v.AddArg(y)
 38575			return true
 38576		}
 38577		return false
 38578	}
 38579	func rewriteValueS390X_OpS390XSRAW_10(v *Value) bool {
 38580		// match: (SRAW x (MOVBZreg y))
 38581		// cond:
 38582		// result: (SRAW x y)
 38583		for {
 38584			_ = v.Args[1]
 38585			x := v.Args[0]
 38586			v_1 := v.Args[1]
 38587			if v_1.Op != OpS390XMOVBZreg {
 38588				break
 38589			}
 38590			y := v_1.Args[0]
 38591			v.reset(OpS390XSRAW)
 38592			v.AddArg(x)
 38593			v.AddArg(y)
 38594			return true
 38595		}
 38596		return false
 38597	}
 38598	func rewriteValueS390X_OpS390XSRAWconst_0(v *Value) bool {
 38599		// match: (SRAWconst [c] (MOVDconst [d]))
 38600		// cond:
 38601		// result: (MOVDconst [int64(int32(d))>>uint64(c)])
 38602		for {
 38603			c := v.AuxInt
 38604			v_0 := v.Args[0]
 38605			if v_0.Op != OpS390XMOVDconst {
 38606				break
 38607			}
 38608			d := v_0.AuxInt
 38609			v.reset(OpS390XMOVDconst)
 38610			v.AuxInt = int64(int32(d)) >> uint64(c)
 38611			return true
 38612		}
 38613		return false
 38614	}
 38615	func rewriteValueS390X_OpS390XSRD_0(v *Value) bool {
 38616		b := v.Block
 38617		typ := &b.Func.Config.Types
 38618		// match: (SRD x (MOVDconst [c]))
 38619		// cond:
 38620		// result: (SRDconst x [c&63])
 38621		for {
 38622			_ = v.Args[1]
 38623			x := v.Args[0]
 38624			v_1 := v.Args[1]
 38625			if v_1.Op != OpS390XMOVDconst {
 38626				break
 38627			}
 38628			c := v_1.AuxInt
 38629			v.reset(OpS390XSRDconst)
 38630			v.AuxInt = c & 63
 38631			v.AddArg(x)
 38632			return true
 38633		}
 38634		// match: (SRD x (AND (MOVDconst [c]) y))
 38635		// cond:
 38636		// result: (SRD x (ANDWconst <typ.UInt32> [c&63] y))
 38637		for {
 38638			_ = v.Args[1]
 38639			x := v.Args[0]
 38640			v_1 := v.Args[1]
 38641			if v_1.Op != OpS390XAND {
 38642				break
 38643			}
 38644			y := v_1.Args[1]
 38645			v_1_0 := v_1.Args[0]
 38646			if v_1_0.Op != OpS390XMOVDconst {
 38647				break
 38648			}
 38649			c := v_1_0.AuxInt
 38650			v.reset(OpS390XSRD)
 38651			v.AddArg(x)
 38652			v0 := b.NewValue0(v.Pos, OpS390XANDWconst, typ.UInt32)
 38653			v0.AuxInt = c & 63
 38654			v0.AddArg(y)
 38655			v.AddArg(v0)
 38656			return true
 38657		}
 38658		// match: (SRD x (AND y (MOVDconst [c])))
 38659		// cond:
 38660		// result: (SRD x (ANDWconst <typ.UInt32> [c&63] y))
 38661		for {
 38662			_ = v.Args[1]
 38663			x := v.Args[0]
 38664			v_1 := v.Args[1]
 38665			if v_1.Op != OpS390XAND {
 38666				break
 38667			}
 38668			_ = v_1.Args[1]
 38669			y := v_1.Args[0]
 38670			v_1_1 := v_1.Args[1]
 38671			if v_1_1.Op != OpS390XMOVDconst {
 38672				break
 38673			}
 38674			c := v_1_1.AuxInt
 38675			v.reset(OpS390XSRD)
 38676			v.AddArg(x)
 38677			v0 := b.NewValue0(v.Pos, OpS390XANDWconst, typ.UInt32)
 38678			v0.AuxInt = c & 63
 38679			v0.AddArg(y)
 38680			v.AddArg(v0)
 38681			return true
 38682		}
 38683		// match: (SRD x (ANDWconst [c] y))
 38684		// cond: c&63 == 63
 38685		// result: (SRD x y)
 38686		for {
 38687			_ = v.Args[1]
 38688			x := v.Args[0]
 38689			v_1 := v.Args[1]
 38690			if v_1.Op != OpS390XANDWconst {
 38691				break
 38692			}
 38693			c := v_1.AuxInt
 38694			y := v_1.Args[0]
 38695			if !(c&63 == 63) {
 38696				break
 38697			}
 38698			v.reset(OpS390XSRD)
 38699			v.AddArg(x)
 38700			v.AddArg(y)
 38701			return true
 38702		}
 38703		// match: (SRD x (MOVDreg y))
 38704		// cond:
 38705		// result: (SRD x y)
 38706		for {
 38707			_ = v.Args[1]
 38708			x := v.Args[0]
 38709			v_1 := v.Args[1]
 38710			if v_1.Op != OpS390XMOVDreg {
 38711				break
 38712			}
 38713			y := v_1.Args[0]
 38714			v.reset(OpS390XSRD)
 38715			v.AddArg(x)
 38716			v.AddArg(y)
 38717			return true
 38718		}
 38719		// match: (SRD x (MOVWreg y))
 38720		// cond:
 38721		// result: (SRD x y)
 38722		for {
 38723			_ = v.Args[1]
 38724			x := v.Args[0]
 38725			v_1 := v.Args[1]
 38726			if v_1.Op != OpS390XMOVWreg {
 38727				break
 38728			}
 38729			y := v_1.Args[0]
 38730			v.reset(OpS390XSRD)
 38731			v.AddArg(x)
 38732			v.AddArg(y)
 38733			return true
 38734		}
 38735		// match: (SRD x (MOVHreg y))
 38736		// cond:
 38737		// result: (SRD x y)
 38738		for {
 38739			_ = v.Args[1]
 38740			x := v.Args[0]
 38741			v_1 := v.Args[1]
 38742			if v_1.Op != OpS390XMOVHreg {
 38743				break
 38744			}
 38745			y := v_1.Args[0]
 38746			v.reset(OpS390XSRD)
 38747			v.AddArg(x)
 38748			v.AddArg(y)
 38749			return true
 38750		}
 38751		// match: (SRD x (MOVBreg y))
 38752		// cond:
 38753		// result: (SRD x y)
 38754		for {
 38755			_ = v.Args[1]
 38756			x := v.Args[0]
 38757			v_1 := v.Args[1]
 38758			if v_1.Op != OpS390XMOVBreg {
 38759				break
 38760			}
 38761			y := v_1.Args[0]
 38762			v.reset(OpS390XSRD)
 38763			v.AddArg(x)
 38764			v.AddArg(y)
 38765			return true
 38766		}
 38767		// match: (SRD x (MOVWZreg y))
 38768		// cond:
 38769		// result: (SRD x y)
 38770		for {
 38771			_ = v.Args[1]
 38772			x := v.Args[0]
 38773			v_1 := v.Args[1]
 38774			if v_1.Op != OpS390XMOVWZreg {
 38775				break
 38776			}
 38777			y := v_1.Args[0]
 38778			v.reset(OpS390XSRD)
 38779			v.AddArg(x)
 38780			v.AddArg(y)
 38781			return true
 38782		}
 38783		// match: (SRD x (MOVHZreg y))
 38784		// cond:
 38785		// result: (SRD x y)
 38786		for {
 38787			_ = v.Args[1]
 38788			x := v.Args[0]
 38789			v_1 := v.Args[1]
 38790			if v_1.Op != OpS390XMOVHZreg {
 38791				break
 38792			}
 38793			y := v_1.Args[0]
 38794			v.reset(OpS390XSRD)
 38795			v.AddArg(x)
 38796			v.AddArg(y)
 38797			return true
 38798		}
 38799		return false
 38800	}
 38801	func rewriteValueS390X_OpS390XSRD_10(v *Value) bool {
 38802		// match: (SRD x (MOVBZreg y))
 38803		// cond:
 38804		// result: (SRD x y)
 38805		for {
 38806			_ = v.Args[1]
 38807			x := v.Args[0]
 38808			v_1 := v.Args[1]
 38809			if v_1.Op != OpS390XMOVBZreg {
 38810				break
 38811			}
 38812			y := v_1.Args[0]
 38813			v.reset(OpS390XSRD)
 38814			v.AddArg(x)
 38815			v.AddArg(y)
 38816			return true
 38817		}
 38818		return false
 38819	}
 38820	func rewriteValueS390X_OpS390XSRDconst_0(v *Value) bool {
 38821		b := v.Block
 38822		// match: (SRDconst [1] (SLDconst [1] (LGDR <t> x)))
 38823		// cond:
 38824		// result: (LGDR <t> (LPDFR <x.Type> x))
 38825		for {
 38826			if v.AuxInt != 1 {
 38827				break
 38828			}
 38829			v_0 := v.Args[0]
 38830			if v_0.Op != OpS390XSLDconst {
 38831				break
 38832			}
 38833			if v_0.AuxInt != 1 {
 38834				break
 38835			}
 38836			v_0_0 := v_0.Args[0]
 38837			if v_0_0.Op != OpS390XLGDR {
 38838				break
 38839			}
 38840			t := v_0_0.Type
 38841			x := v_0_0.Args[0]
 38842			v.reset(OpS390XLGDR)
 38843			v.Type = t
 38844			v0 := b.NewValue0(v.Pos, OpS390XLPDFR, x.Type)
 38845			v0.AddArg(x)
 38846			v.AddArg(v0)
 38847			return true
 38848		}
 38849		return false
 38850	}
 38851	func rewriteValueS390X_OpS390XSRW_0(v *Value) bool {
 38852		b := v.Block
 38853		typ := &b.Func.Config.Types
 38854		// match: (SRW x (MOVDconst [c]))
 38855		// cond:
 38856		// result: (SRWconst x [c&63])
 38857		for {
 38858			_ = v.Args[1]
 38859			x := v.Args[0]
 38860			v_1 := v.Args[1]
 38861			if v_1.Op != OpS390XMOVDconst {
 38862				break
 38863			}
 38864			c := v_1.AuxInt
 38865			v.reset(OpS390XSRWconst)
 38866			v.AuxInt = c & 63
 38867			v.AddArg(x)
 38868			return true
 38869		}
 38870		// match: (SRW x (AND (MOVDconst [c]) y))
 38871		// cond:
 38872		// result: (SRW x (ANDWconst <typ.UInt32> [c&63] y))
 38873		for {
 38874			_ = v.Args[1]
 38875			x := v.Args[0]
 38876			v_1 := v.Args[1]
 38877			if v_1.Op != OpS390XAND {
 38878				break
 38879			}
 38880			y := v_1.Args[1]
 38881			v_1_0 := v_1.Args[0]
 38882			if v_1_0.Op != OpS390XMOVDconst {
 38883				break
 38884			}
 38885			c := v_1_0.AuxInt
 38886			v.reset(OpS390XSRW)
 38887			v.AddArg(x)
 38888			v0 := b.NewValue0(v.Pos, OpS390XANDWconst, typ.UInt32)
 38889			v0.AuxInt = c & 63
 38890			v0.AddArg(y)
 38891			v.AddArg(v0)
 38892			return true
 38893		}
 38894		// match: (SRW x (AND y (MOVDconst [c])))
 38895		// cond:
 38896		// result: (SRW x (ANDWconst <typ.UInt32> [c&63] y))
 38897		for {
 38898			_ = v.Args[1]
 38899			x := v.Args[0]
 38900			v_1 := v.Args[1]
 38901			if v_1.Op != OpS390XAND {
 38902				break
 38903			}
 38904			_ = v_1.Args[1]
 38905			y := v_1.Args[0]
 38906			v_1_1 := v_1.Args[1]
 38907			if v_1_1.Op != OpS390XMOVDconst {
 38908				break
 38909			}
 38910			c := v_1_1.AuxInt
 38911			v.reset(OpS390XSRW)
 38912			v.AddArg(x)
 38913			v0 := b.NewValue0(v.Pos, OpS390XANDWconst, typ.UInt32)
 38914			v0.AuxInt = c & 63
 38915			v0.AddArg(y)
 38916			v.AddArg(v0)
 38917			return true
 38918		}
 38919		// match: (SRW x (ANDWconst [c] y))
 38920		// cond: c&63 == 63
 38921		// result: (SRW x y)
 38922		for {
 38923			_ = v.Args[1]
 38924			x := v.Args[0]
 38925			v_1 := v.Args[1]
 38926			if v_1.Op != OpS390XANDWconst {
 38927				break
 38928			}
 38929			c := v_1.AuxInt
 38930			y := v_1.Args[0]
 38931			if !(c&63 == 63) {
 38932				break
 38933			}
 38934			v.reset(OpS390XSRW)
 38935			v.AddArg(x)
 38936			v.AddArg(y)
 38937			return true
 38938		}
 38939		// match: (SRW x (MOVDreg y))
 38940		// cond:
 38941		// result: (SRW x y)
 38942		for {
 38943			_ = v.Args[1]
 38944			x := v.Args[0]
 38945			v_1 := v.Args[1]
 38946			if v_1.Op != OpS390XMOVDreg {
 38947				break
 38948			}
 38949			y := v_1.Args[0]
 38950			v.reset(OpS390XSRW)
 38951			v.AddArg(x)
 38952			v.AddArg(y)
 38953			return true
 38954		}
 38955		// match: (SRW x (MOVWreg y))
 38956		// cond:
 38957		// result: (SRW x y)
 38958		for {
 38959			_ = v.Args[1]
 38960			x := v.Args[0]
 38961			v_1 := v.Args[1]
 38962			if v_1.Op != OpS390XMOVWreg {
 38963				break
 38964			}
 38965			y := v_1.Args[0]
 38966			v.reset(OpS390XSRW)
 38967			v.AddArg(x)
 38968			v.AddArg(y)
 38969			return true
 38970		}
 38971		// match: (SRW x (MOVHreg y))
 38972		// cond:
 38973		// result: (SRW x y)
 38974		for {
 38975			_ = v.Args[1]
 38976			x := v.Args[0]
 38977			v_1 := v.Args[1]
 38978			if v_1.Op != OpS390XMOVHreg {
 38979				break
 38980			}
 38981			y := v_1.Args[0]
 38982			v.reset(OpS390XSRW)
 38983			v.AddArg(x)
 38984			v.AddArg(y)
 38985			return true
 38986		}
 38987		// match: (SRW x (MOVBreg y))
 38988		// cond:
 38989		// result: (SRW x y)
 38990		for {
 38991			_ = v.Args[1]
 38992			x := v.Args[0]
 38993			v_1 := v.Args[1]
 38994			if v_1.Op != OpS390XMOVBreg {
 38995				break
 38996			}
 38997			y := v_1.Args[0]
 38998			v.reset(OpS390XSRW)
 38999			v.AddArg(x)
 39000			v.AddArg(y)
 39001			return true
 39002		}
 39003		// match: (SRW x (MOVWZreg y))
 39004		// cond:
 39005		// result: (SRW x y)
 39006		for {
 39007			_ = v.Args[1]
 39008			x := v.Args[0]
 39009			v_1 := v.Args[1]
 39010			if v_1.Op != OpS390XMOVWZreg {
 39011				break
 39012			}
 39013			y := v_1.Args[0]
 39014			v.reset(OpS390XSRW)
 39015			v.AddArg(x)
 39016			v.AddArg(y)
 39017			return true
 39018		}
 39019		// match: (SRW x (MOVHZreg y))
 39020		// cond:
 39021		// result: (SRW x y)
 39022		for {
 39023			_ = v.Args[1]
 39024			x := v.Args[0]
 39025			v_1 := v.Args[1]
 39026			if v_1.Op != OpS390XMOVHZreg {
 39027				break
 39028			}
 39029			y := v_1.Args[0]
 39030			v.reset(OpS390XSRW)
 39031			v.AddArg(x)
 39032			v.AddArg(y)
 39033			return true
 39034		}
 39035		return false
 39036	}
 39037	func rewriteValueS390X_OpS390XSRW_10(v *Value) bool {
 39038		// match: (SRW x (MOVBZreg y))
 39039		// cond:
 39040		// result: (SRW x y)
 39041		for {
 39042			_ = v.Args[1]
 39043			x := v.Args[0]
 39044			v_1 := v.Args[1]
 39045			if v_1.Op != OpS390XMOVBZreg {
 39046				break
 39047			}
 39048			y := v_1.Args[0]
 39049			v.reset(OpS390XSRW)
 39050			v.AddArg(x)
 39051			v.AddArg(y)
 39052			return true
 39053		}
 39054		return false
 39055	}
 39056	func rewriteValueS390X_OpS390XSTM2_0(v *Value) bool {
 39057		// match: (STM2 [i] {s} p w2 w3 x:(STM2 [i-8] {s} p w0 w1 mem))
 39058		// cond: x.Uses == 1 && is20Bit(i-8) && clobber(x)
 39059		// result: (STM4 [i-8] {s} p w0 w1 w2 w3 mem)
 39060		for {
 39061			i := v.AuxInt
 39062			s := v.Aux
 39063			_ = v.Args[3]
 39064			p := v.Args[0]
 39065			w2 := v.Args[1]
 39066			w3 := v.Args[2]
 39067			x := v.Args[3]
 39068			if x.Op != OpS390XSTM2 {
 39069				break
 39070			}
 39071			if x.AuxInt != i-8 {
 39072				break
 39073			}
 39074			if x.Aux != s {
 39075				break
 39076			}
 39077			mem := x.Args[3]
 39078			if p != x.Args[0] {
 39079				break
 39080			}
 39081			w0 := x.Args[1]
 39082			w1 := x.Args[2]
 39083			if !(x.Uses == 1 && is20Bit(i-8) && clobber(x)) {
 39084				break
 39085			}
 39086			v.reset(OpS390XSTM4)
 39087			v.AuxInt = i - 8
 39088			v.Aux = s
 39089			v.AddArg(p)
 39090			v.AddArg(w0)
 39091			v.AddArg(w1)
 39092			v.AddArg(w2)
 39093			v.AddArg(w3)
 39094			v.AddArg(mem)
 39095			return true
 39096		}
 39097		// match: (STM2 [i] {s} p (SRDconst [32] x) x mem)
 39098		// cond:
 39099		// result: (MOVDstore [i] {s} p x mem)
 39100		for {
 39101			i := v.AuxInt
 39102			s := v.Aux
 39103			mem := v.Args[3]
 39104			p := v.Args[0]
 39105			v_1 := v.Args[1]
 39106			if v_1.Op != OpS390XSRDconst {
 39107				break
 39108			}
 39109			if v_1.AuxInt != 32 {
 39110				break
 39111			}
 39112			x := v_1.Args[0]
 39113			if x != v.Args[2] {
 39114				break
 39115			}
 39116			v.reset(OpS390XMOVDstore)
 39117			v.AuxInt = i
 39118			v.Aux = s
 39119			v.AddArg(p)
 39120			v.AddArg(x)
 39121			v.AddArg(mem)
 39122			return true
 39123		}
 39124		return false
 39125	}
 39126	func rewriteValueS390X_OpS390XSTMG2_0(v *Value) bool {
 39127		// match: (STMG2 [i] {s} p w2 w3 x:(STMG2 [i-16] {s} p w0 w1 mem))
 39128		// cond: x.Uses == 1 && is20Bit(i-16) && clobber(x)
 39129		// result: (STMG4 [i-16] {s} p w0 w1 w2 w3 mem)
 39130		for {
 39131			i := v.AuxInt
 39132			s := v.Aux
 39133			_ = v.Args[3]
 39134			p := v.Args[0]
 39135			w2 := v.Args[1]
 39136			w3 := v.Args[2]
 39137			x := v.Args[3]
 39138			if x.Op != OpS390XSTMG2 {
 39139				break
 39140			}
 39141			if x.AuxInt != i-16 {
 39142				break
 39143			}
 39144			if x.Aux != s {
 39145				break
 39146			}
 39147			mem := x.Args[3]
 39148			if p != x.Args[0] {
 39149				break
 39150			}
 39151			w0 := x.Args[1]
 39152			w1 := x.Args[2]
 39153			if !(x.Uses == 1 && is20Bit(i-16) && clobber(x)) {
 39154				break
 39155			}
 39156			v.reset(OpS390XSTMG4)
 39157			v.AuxInt = i - 16
 39158			v.Aux = s
 39159			v.AddArg(p)
 39160			v.AddArg(w0)
 39161			v.AddArg(w1)
 39162			v.AddArg(w2)
 39163			v.AddArg(w3)
 39164			v.AddArg(mem)
 39165			return true
 39166		}
 39167		return false
 39168	}
 39169	func rewriteValueS390X_OpS390XSUB_0(v *Value) bool {
 39170		b := v.Block
 39171		// match: (SUB x (MOVDconst [c]))
 39172		// cond: is32Bit(c)
 39173		// result: (SUBconst x [c])
 39174		for {
 39175			_ = v.Args[1]
 39176			x := v.Args[0]
 39177			v_1 := v.Args[1]
 39178			if v_1.Op != OpS390XMOVDconst {
 39179				break
 39180			}
 39181			c := v_1.AuxInt
 39182			if !(is32Bit(c)) {
 39183				break
 39184			}
 39185			v.reset(OpS390XSUBconst)
 39186			v.AuxInt = c
 39187			v.AddArg(x)
 39188			return true
 39189		}
 39190		// match: (SUB (MOVDconst [c]) x)
 39191		// cond: is32Bit(c)
 39192		// result: (NEG (SUBconst <v.Type> x [c]))
 39193		for {
 39194			x := v.Args[1]
 39195			v_0 := v.Args[0]
 39196			if v_0.Op != OpS390XMOVDconst {
 39197				break
 39198			}
 39199			c := v_0.AuxInt
 39200			if !(is32Bit(c)) {
 39201				break
 39202			}
 39203			v.reset(OpS390XNEG)
 39204			v0 := b.NewValue0(v.Pos, OpS390XSUBconst, v.Type)
 39205			v0.AuxInt = c
 39206			v0.AddArg(x)
 39207			v.AddArg(v0)
 39208			return true
 39209		}
 39210		// match: (SUB x x)
 39211		// cond:
 39212		// result: (MOVDconst [0])
 39213		for {
 39214			x := v.Args[1]
 39215			if x != v.Args[0] {
 39216				break
 39217			}
 39218			v.reset(OpS390XMOVDconst)
 39219			v.AuxInt = 0
 39220			return true
 39221		}
 39222		// match: (SUB <t> x g:(MOVDload [off] {sym} ptr mem))
 39223		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 39224		// result: (SUBload <t> [off] {sym} x ptr mem)
 39225		for {
 39226			t := v.Type
 39227			_ = v.Args[1]
 39228			x := v.Args[0]
 39229			g := v.Args[1]
 39230			if g.Op != OpS390XMOVDload {
 39231				break
 39232			}
 39233			off := g.AuxInt
 39234			sym := g.Aux
 39235			mem := g.Args[1]
 39236			ptr := g.Args[0]
 39237			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 39238				break
 39239			}
 39240			v.reset(OpS390XSUBload)
 39241			v.Type = t
 39242			v.AuxInt = off
 39243			v.Aux = sym
 39244			v.AddArg(x)
 39245			v.AddArg(ptr)
 39246			v.AddArg(mem)
 39247			return true
 39248		}
 39249		return false
 39250	}
 39251	func rewriteValueS390X_OpS390XSUBE_0(v *Value) bool {
 39252		// match: (SUBE x y (FlagGT))
 39253		// cond:
 39254		// result: (SUBC x y)
 39255		for {
 39256			_ = v.Args[2]
 39257			x := v.Args[0]
 39258			y := v.Args[1]
 39259			v_2 := v.Args[2]
 39260			if v_2.Op != OpS390XFlagGT {
 39261				break
 39262			}
 39263			v.reset(OpS390XSUBC)
 39264			v.AddArg(x)
 39265			v.AddArg(y)
 39266			return true
 39267		}
 39268		// match: (SUBE x y (FlagOV))
 39269		// cond:
 39270		// result: (SUBC x y)
 39271		for {
 39272			_ = v.Args[2]
 39273			x := v.Args[0]
 39274			y := v.Args[1]
 39275			v_2 := v.Args[2]
 39276			if v_2.Op != OpS390XFlagOV {
 39277				break
 39278			}
 39279			v.reset(OpS390XSUBC)
 39280			v.AddArg(x)
 39281			v.AddArg(y)
 39282			return true
 39283		}
 39284		// match: (SUBE x y (Select1 (SUBC (MOVDconst [0]) (NEG (Select0 (SUBE (MOVDconst [0]) (MOVDconst [0]) c))))))
 39285		// cond:
 39286		// result: (SUBE x y c)
 39287		for {
 39288			_ = v.Args[2]
 39289			x := v.Args[0]
 39290			y := v.Args[1]
 39291			v_2 := v.Args[2]
 39292			if v_2.Op != OpSelect1 {
 39293				break
 39294			}
 39295			v_2_0 := v_2.Args[0]
 39296			if v_2_0.Op != OpS390XSUBC {
 39297				break
 39298			}
 39299			_ = v_2_0.Args[1]
 39300			v_2_0_0 := v_2_0.Args[0]
 39301			if v_2_0_0.Op != OpS390XMOVDconst {
 39302				break
 39303			}
 39304			if v_2_0_0.AuxInt != 0 {
 39305				break
 39306			}
 39307			v_2_0_1 := v_2_0.Args[1]
 39308			if v_2_0_1.Op != OpS390XNEG {
 39309				break
 39310			}
 39311			v_2_0_1_0 := v_2_0_1.Args[0]
 39312			if v_2_0_1_0.Op != OpSelect0 {
 39313				break
 39314			}
 39315			v_2_0_1_0_0 := v_2_0_1_0.Args[0]
 39316			if v_2_0_1_0_0.Op != OpS390XSUBE {
 39317				break
 39318			}
 39319			c := v_2_0_1_0_0.Args[2]
 39320			v_2_0_1_0_0_0 := v_2_0_1_0_0.Args[0]
 39321			if v_2_0_1_0_0_0.Op != OpS390XMOVDconst {
 39322				break
 39323			}
 39324			if v_2_0_1_0_0_0.AuxInt != 0 {
 39325				break
 39326			}
 39327			v_2_0_1_0_0_1 := v_2_0_1_0_0.Args[1]
 39328			if v_2_0_1_0_0_1.Op != OpS390XMOVDconst {
 39329				break
 39330			}
 39331			if v_2_0_1_0_0_1.AuxInt != 0 {
 39332				break
 39333			}
 39334			v.reset(OpS390XSUBE)
 39335			v.AddArg(x)
 39336			v.AddArg(y)
 39337			v.AddArg(c)
 39338			return true
 39339		}
 39340		return false
 39341	}
 39342	func rewriteValueS390X_OpS390XSUBW_0(v *Value) bool {
 39343		b := v.Block
 39344		// match: (SUBW x (MOVDconst [c]))
 39345		// cond:
 39346		// result: (SUBWconst x [int64(int32(c))])
 39347		for {
 39348			_ = v.Args[1]
 39349			x := v.Args[0]
 39350			v_1 := v.Args[1]
 39351			if v_1.Op != OpS390XMOVDconst {
 39352				break
 39353			}
 39354			c := v_1.AuxInt
 39355			v.reset(OpS390XSUBWconst)
 39356			v.AuxInt = int64(int32(c))
 39357			v.AddArg(x)
 39358			return true
 39359		}
 39360		// match: (SUBW (MOVDconst [c]) x)
 39361		// cond:
 39362		// result: (NEGW (SUBWconst <v.Type> x [int64(int32(c))]))
 39363		for {
 39364			x := v.Args[1]
 39365			v_0 := v.Args[0]
 39366			if v_0.Op != OpS390XMOVDconst {
 39367				break
 39368			}
 39369			c := v_0.AuxInt
 39370			v.reset(OpS390XNEGW)
 39371			v0 := b.NewValue0(v.Pos, OpS390XSUBWconst, v.Type)
 39372			v0.AuxInt = int64(int32(c))
 39373			v0.AddArg(x)
 39374			v.AddArg(v0)
 39375			return true
 39376		}
 39377		// match: (SUBW x x)
 39378		// cond:
 39379		// result: (MOVDconst [0])
 39380		for {
 39381			x := v.Args[1]
 39382			if x != v.Args[0] {
 39383				break
 39384			}
 39385			v.reset(OpS390XMOVDconst)
 39386			v.AuxInt = 0
 39387			return true
 39388		}
 39389		// match: (SUBW <t> x g:(MOVWload [off] {sym} ptr mem))
 39390		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 39391		// result: (SUBWload <t> [off] {sym} x ptr mem)
 39392		for {
 39393			t := v.Type
 39394			_ = v.Args[1]
 39395			x := v.Args[0]
 39396			g := v.Args[1]
 39397			if g.Op != OpS390XMOVWload {
 39398				break
 39399			}
 39400			off := g.AuxInt
 39401			sym := g.Aux
 39402			mem := g.Args[1]
 39403			ptr := g.Args[0]
 39404			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 39405				break
 39406			}
 39407			v.reset(OpS390XSUBWload)
 39408			v.Type = t
 39409			v.AuxInt = off
 39410			v.Aux = sym
 39411			v.AddArg(x)
 39412			v.AddArg(ptr)
 39413			v.AddArg(mem)
 39414			return true
 39415		}
 39416		// match: (SUBW <t> x g:(MOVWZload [off] {sym} ptr mem))
 39417		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 39418		// result: (SUBWload <t> [off] {sym} x ptr mem)
 39419		for {
 39420			t := v.Type
 39421			_ = v.Args[1]
 39422			x := v.Args[0]
 39423			g := v.Args[1]
 39424			if g.Op != OpS390XMOVWZload {
 39425				break
 39426			}
 39427			off := g.AuxInt
 39428			sym := g.Aux
 39429			mem := g.Args[1]
 39430			ptr := g.Args[0]
 39431			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 39432				break
 39433			}
 39434			v.reset(OpS390XSUBWload)
 39435			v.Type = t
 39436			v.AuxInt = off
 39437			v.Aux = sym
 39438			v.AddArg(x)
 39439			v.AddArg(ptr)
 39440			v.AddArg(mem)
 39441			return true
 39442		}
 39443		return false
 39444	}
 39445	func rewriteValueS390X_OpS390XSUBWconst_0(v *Value) bool {
 39446		// match: (SUBWconst [c] x)
 39447		// cond: int32(c) == 0
 39448		// result: x
 39449		for {
 39450			c := v.AuxInt
 39451			x := v.Args[0]
 39452			if !(int32(c) == 0) {
 39453				break
 39454			}
 39455			v.reset(OpCopy)
 39456			v.Type = x.Type
 39457			v.AddArg(x)
 39458			return true
 39459		}
 39460		// match: (SUBWconst [c] x)
 39461		// cond:
 39462		// result: (ADDWconst [int64(int32(-c))] x)
 39463		for {
 39464			c := v.AuxInt
 39465			x := v.Args[0]
 39466			v.reset(OpS390XADDWconst)
 39467			v.AuxInt = int64(int32(-c))
 39468			v.AddArg(x)
 39469			return true
 39470		}
 39471	}
 39472	func rewriteValueS390X_OpS390XSUBWload_0(v *Value) bool {
 39473		// match: (SUBWload [off1] {sym} x (ADDconst [off2] ptr) mem)
 39474		// cond: ptr.Op != OpSB && is20Bit(off1+off2)
 39475		// result: (SUBWload [off1+off2] {sym} x ptr mem)
 39476		for {
 39477			off1 := v.AuxInt
 39478			sym := v.Aux
 39479			mem := v.Args[2]
 39480			x := v.Args[0]
 39481			v_1 := v.Args[1]
 39482			if v_1.Op != OpS390XADDconst {
 39483				break
 39484			}
 39485			off2 := v_1.AuxInt
 39486			ptr := v_1.Args[0]
 39487			if !(ptr.Op != OpSB && is20Bit(off1+off2)) {
 39488				break
 39489			}
 39490			v.reset(OpS390XSUBWload)
 39491			v.AuxInt = off1 + off2
 39492			v.Aux = sym
 39493			v.AddArg(x)
 39494			v.AddArg(ptr)
 39495			v.AddArg(mem)
 39496			return true
 39497		}
 39498		// match: (SUBWload [o1] {s1} x (MOVDaddr [o2] {s2} ptr) mem)
 39499		// cond: ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)
 39500		// result: (SUBWload [o1+o2] {mergeSym(s1, s2)} x ptr mem)
 39501		for {
 39502			o1 := v.AuxInt
 39503			s1 := v.Aux
 39504			mem := v.Args[2]
 39505			x := v.Args[0]
 39506			v_1 := v.Args[1]
 39507			if v_1.Op != OpS390XMOVDaddr {
 39508				break
 39509			}
 39510			o2 := v_1.AuxInt
 39511			s2 := v_1.Aux
 39512			ptr := v_1.Args[0]
 39513			if !(ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)) {
 39514				break
 39515			}
 39516			v.reset(OpS390XSUBWload)
 39517			v.AuxInt = o1 + o2
 39518			v.Aux = mergeSym(s1, s2)
 39519			v.AddArg(x)
 39520			v.AddArg(ptr)
 39521			v.AddArg(mem)
 39522			return true
 39523		}
 39524		return false
 39525	}
 39526	func rewriteValueS390X_OpS390XSUBconst_0(v *Value) bool {
 39527		// match: (SUBconst [0] x)
 39528		// cond:
 39529		// result: x
 39530		for {
 39531			if v.AuxInt != 0 {
 39532				break
 39533			}
 39534			x := v.Args[0]
 39535			v.reset(OpCopy)
 39536			v.Type = x.Type
 39537			v.AddArg(x)
 39538			return true
 39539		}
 39540		// match: (SUBconst [c] x)
 39541		// cond: c != -(1<<31)
 39542		// result: (ADDconst [-c] x)
 39543		for {
 39544			c := v.AuxInt
 39545			x := v.Args[0]
 39546			if !(c != -(1 << 31)) {
 39547				break
 39548			}
 39549			v.reset(OpS390XADDconst)
 39550			v.AuxInt = -c
 39551			v.AddArg(x)
 39552			return true
 39553		}
 39554		// match: (SUBconst (MOVDconst [d]) [c])
 39555		// cond:
 39556		// result: (MOVDconst [d-c])
 39557		for {
 39558			c := v.AuxInt
 39559			v_0 := v.Args[0]
 39560			if v_0.Op != OpS390XMOVDconst {
 39561				break
 39562			}
 39563			d := v_0.AuxInt
 39564			v.reset(OpS390XMOVDconst)
 39565			v.AuxInt = d - c
 39566			return true
 39567		}
 39568		// match: (SUBconst (SUBconst x [d]) [c])
 39569		// cond: is32Bit(-c-d)
 39570		// result: (ADDconst [-c-d] x)
 39571		for {
 39572			c := v.AuxInt
 39573			v_0 := v.Args[0]
 39574			if v_0.Op != OpS390XSUBconst {
 39575				break
 39576			}
 39577			d := v_0.AuxInt
 39578			x := v_0.Args[0]
 39579			if !(is32Bit(-c - d)) {
 39580				break
 39581			}
 39582			v.reset(OpS390XADDconst)
 39583			v.AuxInt = -c - d
 39584			v.AddArg(x)
 39585			return true
 39586		}
 39587		return false
 39588	}
 39589	func rewriteValueS390X_OpS390XSUBload_0(v *Value) bool {
 39590		b := v.Block
 39591		// match: (SUBload <t> [off] {sym} x ptr1 (FMOVDstore [off] {sym} ptr2 y _))
 39592		// cond: isSamePtr(ptr1, ptr2)
 39593		// result: (SUB x (LGDR <t> y))
 39594		for {
 39595			t := v.Type
 39596			off := v.AuxInt
 39597			sym := v.Aux
 39598			_ = v.Args[2]
 39599			x := v.Args[0]
 39600			ptr1 := v.Args[1]
 39601			v_2 := v.Args[2]
 39602			if v_2.Op != OpS390XFMOVDstore {
 39603				break
 39604			}
 39605			if v_2.AuxInt != off {
 39606				break
 39607			}
 39608			if v_2.Aux != sym {
 39609				break
 39610			}
 39611			_ = v_2.Args[2]
 39612			ptr2 := v_2.Args[0]
 39613			y := v_2.Args[1]
 39614			if !(isSamePtr(ptr1, ptr2)) {
 39615				break
 39616			}
 39617			v.reset(OpS390XSUB)
 39618			v.AddArg(x)
 39619			v0 := b.NewValue0(v_2.Pos, OpS390XLGDR, t)
 39620			v0.AddArg(y)
 39621			v.AddArg(v0)
 39622			return true
 39623		}
 39624		// match: (SUBload [off1] {sym} x (ADDconst [off2] ptr) mem)
 39625		// cond: ptr.Op != OpSB && is20Bit(off1+off2)
 39626		// result: (SUBload [off1+off2] {sym} x ptr mem)
 39627		for {
 39628			off1 := v.AuxInt
 39629			sym := v.Aux
 39630			mem := v.Args[2]
 39631			x := v.Args[0]
 39632			v_1 := v.Args[1]
 39633			if v_1.Op != OpS390XADDconst {
 39634				break
 39635			}
 39636			off2 := v_1.AuxInt
 39637			ptr := v_1.Args[0]
 39638			if !(ptr.Op != OpSB && is20Bit(off1+off2)) {
 39639				break
 39640			}
 39641			v.reset(OpS390XSUBload)
 39642			v.AuxInt = off1 + off2
 39643			v.Aux = sym
 39644			v.AddArg(x)
 39645			v.AddArg(ptr)
 39646			v.AddArg(mem)
 39647			return true
 39648		}
 39649		// match: (SUBload [o1] {s1} x (MOVDaddr [o2] {s2} ptr) mem)
 39650		// cond: ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)
 39651		// result: (SUBload [o1+o2] {mergeSym(s1, s2)} x ptr mem)
 39652		for {
 39653			o1 := v.AuxInt
 39654			s1 := v.Aux
 39655			mem := v.Args[2]
 39656			x := v.Args[0]
 39657			v_1 := v.Args[1]
 39658			if v_1.Op != OpS390XMOVDaddr {
 39659				break
 39660			}
 39661			o2 := v_1.AuxInt
 39662			s2 := v_1.Aux
 39663			ptr := v_1.Args[0]
 39664			if !(ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)) {
 39665				break
 39666			}
 39667			v.reset(OpS390XSUBload)
 39668			v.AuxInt = o1 + o2
 39669			v.Aux = mergeSym(s1, s2)
 39670			v.AddArg(x)
 39671			v.AddArg(ptr)
 39672			v.AddArg(mem)
 39673			return true
 39674		}
 39675		return false
 39676	}
 39677	func rewriteValueS390X_OpS390XSumBytes2_0(v *Value) bool {
 39678		b := v.Block
 39679		typ := &b.Func.Config.Types
 39680		// match: (SumBytes2 x)
 39681		// cond:
 39682		// result: (ADDW (SRWconst <typ.UInt8> x [8]) x)
 39683		for {
 39684			x := v.Args[0]
 39685			v.reset(OpS390XADDW)
 39686			v0 := b.NewValue0(v.Pos, OpS390XSRWconst, typ.UInt8)
 39687			v0.AuxInt = 8
 39688			v0.AddArg(x)
 39689			v.AddArg(v0)
 39690			v.AddArg(x)
 39691			return true
 39692		}
 39693	}
 39694	func rewriteValueS390X_OpS390XSumBytes4_0(v *Value) bool {
 39695		b := v.Block
 39696		typ := &b.Func.Config.Types
 39697		// match: (SumBytes4 x)
 39698		// cond:
 39699		// result: (SumBytes2 (ADDW <typ.UInt16> (SRWconst <typ.UInt16> x [16]) x))
 39700		for {
 39701			x := v.Args[0]
 39702			v.reset(OpS390XSumBytes2)
 39703			v0 := b.NewValue0(v.Pos, OpS390XADDW, typ.UInt16)
 39704			v1 := b.NewValue0(v.Pos, OpS390XSRWconst, typ.UInt16)
 39705			v1.AuxInt = 16
 39706			v1.AddArg(x)
 39707			v0.AddArg(v1)
 39708			v0.AddArg(x)
 39709			v.AddArg(v0)
 39710			return true
 39711		}
 39712	}
 39713	func rewriteValueS390X_OpS390XSumBytes8_0(v *Value) bool {
 39714		b := v.Block
 39715		typ := &b.Func.Config.Types
 39716		// match: (SumBytes8 x)
 39717		// cond:
 39718		// result: (SumBytes4 (ADDW <typ.UInt32> (SRDconst <typ.UInt32> x [32]) x))
 39719		for {
 39720			x := v.Args[0]
 39721			v.reset(OpS390XSumBytes4)
 39722			v0 := b.NewValue0(v.Pos, OpS390XADDW, typ.UInt32)
 39723			v1 := b.NewValue0(v.Pos, OpS390XSRDconst, typ.UInt32)
 39724			v1.AuxInt = 32
 39725			v1.AddArg(x)
 39726			v0.AddArg(v1)
 39727			v0.AddArg(x)
 39728			v.AddArg(v0)
 39729			return true
 39730		}
 39731	}
 39732	func rewriteValueS390X_OpS390XXOR_0(v *Value) bool {
 39733		// match: (XOR x (MOVDconst [c]))
 39734		// cond: isU32Bit(c)
 39735		// result: (XORconst [c] x)
 39736		for {
 39737			_ = v.Args[1]
 39738			x := v.Args[0]
 39739			v_1 := v.Args[1]
 39740			if v_1.Op != OpS390XMOVDconst {
 39741				break
 39742			}
 39743			c := v_1.AuxInt
 39744			if !(isU32Bit(c)) {
 39745				break
 39746			}
 39747			v.reset(OpS390XXORconst)
 39748			v.AuxInt = c
 39749			v.AddArg(x)
 39750			return true
 39751		}
 39752		// match: (XOR (MOVDconst [c]) x)
 39753		// cond: isU32Bit(c)
 39754		// result: (XORconst [c] x)
 39755		for {
 39756			x := v.Args[1]
 39757			v_0 := v.Args[0]
 39758			if v_0.Op != OpS390XMOVDconst {
 39759				break
 39760			}
 39761			c := v_0.AuxInt
 39762			if !(isU32Bit(c)) {
 39763				break
 39764			}
 39765			v.reset(OpS390XXORconst)
 39766			v.AuxInt = c
 39767			v.AddArg(x)
 39768			return true
 39769		}
 39770		// match: (XOR (SLDconst x [c]) (SRDconst x [d]))
 39771		// cond: d == 64-c
 39772		// result: (RLLGconst [c] x)
 39773		for {
 39774			_ = v.Args[1]
 39775			v_0 := v.Args[0]
 39776			if v_0.Op != OpS390XSLDconst {
 39777				break
 39778			}
 39779			c := v_0.AuxInt
 39780			x := v_0.Args[0]
 39781			v_1 := v.Args[1]
 39782			if v_1.Op != OpS390XSRDconst {
 39783				break
 39784			}
 39785			d := v_1.AuxInt
 39786			if x != v_1.Args[0] {
 39787				break
 39788			}
 39789			if !(d == 64-c) {
 39790				break
 39791			}
 39792			v.reset(OpS390XRLLGconst)
 39793			v.AuxInt = c
 39794			v.AddArg(x)
 39795			return true
 39796		}
 39797		// match: (XOR (SRDconst x [d]) (SLDconst x [c]))
 39798		// cond: d == 64-c
 39799		// result: (RLLGconst [c] x)
 39800		for {
 39801			_ = v.Args[1]
 39802			v_0 := v.Args[0]
 39803			if v_0.Op != OpS390XSRDconst {
 39804				break
 39805			}
 39806			d := v_0.AuxInt
 39807			x := v_0.Args[0]
 39808			v_1 := v.Args[1]
 39809			if v_1.Op != OpS390XSLDconst {
 39810				break
 39811			}
 39812			c := v_1.AuxInt
 39813			if x != v_1.Args[0] {
 39814				break
 39815			}
 39816			if !(d == 64-c) {
 39817				break
 39818			}
 39819			v.reset(OpS390XRLLGconst)
 39820			v.AuxInt = c
 39821			v.AddArg(x)
 39822			return true
 39823		}
 39824		// match: (XOR (MOVDconst [c]) (MOVDconst [d]))
 39825		// cond:
 39826		// result: (MOVDconst [c^d])
 39827		for {
 39828			_ = v.Args[1]
 39829			v_0 := v.Args[0]
 39830			if v_0.Op != OpS390XMOVDconst {
 39831				break
 39832			}
 39833			c := v_0.AuxInt
 39834			v_1 := v.Args[1]
 39835			if v_1.Op != OpS390XMOVDconst {
 39836				break
 39837			}
 39838			d := v_1.AuxInt
 39839			v.reset(OpS390XMOVDconst)
 39840			v.AuxInt = c ^ d
 39841			return true
 39842		}
 39843		// match: (XOR (MOVDconst [d]) (MOVDconst [c]))
 39844		// cond:
 39845		// result: (MOVDconst [c^d])
 39846		for {
 39847			_ = v.Args[1]
 39848			v_0 := v.Args[0]
 39849			if v_0.Op != OpS390XMOVDconst {
 39850				break
 39851			}
 39852			d := v_0.AuxInt
 39853			v_1 := v.Args[1]
 39854			if v_1.Op != OpS390XMOVDconst {
 39855				break
 39856			}
 39857			c := v_1.AuxInt
 39858			v.reset(OpS390XMOVDconst)
 39859			v.AuxInt = c ^ d
 39860			return true
 39861		}
 39862		// match: (XOR x x)
 39863		// cond:
 39864		// result: (MOVDconst [0])
 39865		for {
 39866			x := v.Args[1]
 39867			if x != v.Args[0] {
 39868				break
 39869			}
 39870			v.reset(OpS390XMOVDconst)
 39871			v.AuxInt = 0
 39872			return true
 39873		}
 39874		// match: (XOR <t> x g:(MOVDload [off] {sym} ptr mem))
 39875		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 39876		// result: (XORload <t> [off] {sym} x ptr mem)
 39877		for {
 39878			t := v.Type
 39879			_ = v.Args[1]
 39880			x := v.Args[0]
 39881			g := v.Args[1]
 39882			if g.Op != OpS390XMOVDload {
 39883				break
 39884			}
 39885			off := g.AuxInt
 39886			sym := g.Aux
 39887			mem := g.Args[1]
 39888			ptr := g.Args[0]
 39889			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 39890				break
 39891			}
 39892			v.reset(OpS390XXORload)
 39893			v.Type = t
 39894			v.AuxInt = off
 39895			v.Aux = sym
 39896			v.AddArg(x)
 39897			v.AddArg(ptr)
 39898			v.AddArg(mem)
 39899			return true
 39900		}
 39901		// match: (XOR <t> g:(MOVDload [off] {sym} ptr mem) x)
 39902		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 39903		// result: (XORload <t> [off] {sym} x ptr mem)
 39904		for {
 39905			t := v.Type
 39906			x := v.Args[1]
 39907			g := v.Args[0]
 39908			if g.Op != OpS390XMOVDload {
 39909				break
 39910			}
 39911			off := g.AuxInt
 39912			sym := g.Aux
 39913			mem := g.Args[1]
 39914			ptr := g.Args[0]
 39915			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 39916				break
 39917			}
 39918			v.reset(OpS390XXORload)
 39919			v.Type = t
 39920			v.AuxInt = off
 39921			v.Aux = sym
 39922			v.AddArg(x)
 39923			v.AddArg(ptr)
 39924			v.AddArg(mem)
 39925			return true
 39926		}
 39927		// match: (XOR <t> g:(MOVDload [off] {sym} ptr mem) x)
 39928		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 39929		// result: (XORload <t> [off] {sym} x ptr mem)
 39930		for {
 39931			t := v.Type
 39932			x := v.Args[1]
 39933			g := v.Args[0]
 39934			if g.Op != OpS390XMOVDload {
 39935				break
 39936			}
 39937			off := g.AuxInt
 39938			sym := g.Aux
 39939			mem := g.Args[1]
 39940			ptr := g.Args[0]
 39941			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 39942				break
 39943			}
 39944			v.reset(OpS390XXORload)
 39945			v.Type = t
 39946			v.AuxInt = off
 39947			v.Aux = sym
 39948			v.AddArg(x)
 39949			v.AddArg(ptr)
 39950			v.AddArg(mem)
 39951			return true
 39952		}
 39953		return false
 39954	}
 39955	func rewriteValueS390X_OpS390XXOR_10(v *Value) bool {
 39956		// match: (XOR <t> x g:(MOVDload [off] {sym} ptr mem))
 39957		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 39958		// result: (XORload <t> [off] {sym} x ptr mem)
 39959		for {
 39960			t := v.Type
 39961			_ = v.Args[1]
 39962			x := v.Args[0]
 39963			g := v.Args[1]
 39964			if g.Op != OpS390XMOVDload {
 39965				break
 39966			}
 39967			off := g.AuxInt
 39968			sym := g.Aux
 39969			mem := g.Args[1]
 39970			ptr := g.Args[0]
 39971			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 39972				break
 39973			}
 39974			v.reset(OpS390XXORload)
 39975			v.Type = t
 39976			v.AuxInt = off
 39977			v.Aux = sym
 39978			v.AddArg(x)
 39979			v.AddArg(ptr)
 39980			v.AddArg(mem)
 39981			return true
 39982		}
 39983		return false
 39984	}
 39985	func rewriteValueS390X_OpS390XXORW_0(v *Value) bool {
 39986		// match: (XORW x (MOVDconst [c]))
 39987		// cond:
 39988		// result: (XORWconst [int64(int32(c))] x)
 39989		for {
 39990			_ = v.Args[1]
 39991			x := v.Args[0]
 39992			v_1 := v.Args[1]
 39993			if v_1.Op != OpS390XMOVDconst {
 39994				break
 39995			}
 39996			c := v_1.AuxInt
 39997			v.reset(OpS390XXORWconst)
 39998			v.AuxInt = int64(int32(c))
 39999			v.AddArg(x)
 40000			return true
 40001		}
 40002		// match: (XORW (MOVDconst [c]) x)
 40003		// cond:
 40004		// result: (XORWconst [int64(int32(c))] x)
 40005		for {
 40006			x := v.Args[1]
 40007			v_0 := v.Args[0]
 40008			if v_0.Op != OpS390XMOVDconst {
 40009				break
 40010			}
 40011			c := v_0.AuxInt
 40012			v.reset(OpS390XXORWconst)
 40013			v.AuxInt = int64(int32(c))
 40014			v.AddArg(x)
 40015			return true
 40016		}
 40017		// match: (XORW (SLWconst x [c]) (SRWconst x [d]))
 40018		// cond: d == 32-c
 40019		// result: (RLLconst [c] x)
 40020		for {
 40021			_ = v.Args[1]
 40022			v_0 := v.Args[0]
 40023			if v_0.Op != OpS390XSLWconst {
 40024				break
 40025			}
 40026			c := v_0.AuxInt
 40027			x := v_0.Args[0]
 40028			v_1 := v.Args[1]
 40029			if v_1.Op != OpS390XSRWconst {
 40030				break
 40031			}
 40032			d := v_1.AuxInt
 40033			if x != v_1.Args[0] {
 40034				break
 40035			}
 40036			if !(d == 32-c) {
 40037				break
 40038			}
 40039			v.reset(OpS390XRLLconst)
 40040			v.AuxInt = c
 40041			v.AddArg(x)
 40042			return true
 40043		}
 40044		// match: (XORW (SRWconst x [d]) (SLWconst x [c]))
 40045		// cond: d == 32-c
 40046		// result: (RLLconst [c] x)
 40047		for {
 40048			_ = v.Args[1]
 40049			v_0 := v.Args[0]
 40050			if v_0.Op != OpS390XSRWconst {
 40051				break
 40052			}
 40053			d := v_0.AuxInt
 40054			x := v_0.Args[0]
 40055			v_1 := v.Args[1]
 40056			if v_1.Op != OpS390XSLWconst {
 40057				break
 40058			}
 40059			c := v_1.AuxInt
 40060			if x != v_1.Args[0] {
 40061				break
 40062			}
 40063			if !(d == 32-c) {
 40064				break
 40065			}
 40066			v.reset(OpS390XRLLconst)
 40067			v.AuxInt = c
 40068			v.AddArg(x)
 40069			return true
 40070		}
 40071		// match: (XORW x x)
 40072		// cond:
 40073		// result: (MOVDconst [0])
 40074		for {
 40075			x := v.Args[1]
 40076			if x != v.Args[0] {
 40077				break
 40078			}
 40079			v.reset(OpS390XMOVDconst)
 40080			v.AuxInt = 0
 40081			return true
 40082		}
 40083		// match: (XORW <t> x g:(MOVWload [off] {sym} ptr mem))
 40084		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 40085		// result: (XORWload <t> [off] {sym} x ptr mem)
 40086		for {
 40087			t := v.Type
 40088			_ = v.Args[1]
 40089			x := v.Args[0]
 40090			g := v.Args[1]
 40091			if g.Op != OpS390XMOVWload {
 40092				break
 40093			}
 40094			off := g.AuxInt
 40095			sym := g.Aux
 40096			mem := g.Args[1]
 40097			ptr := g.Args[0]
 40098			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 40099				break
 40100			}
 40101			v.reset(OpS390XXORWload)
 40102			v.Type = t
 40103			v.AuxInt = off
 40104			v.Aux = sym
 40105			v.AddArg(x)
 40106			v.AddArg(ptr)
 40107			v.AddArg(mem)
 40108			return true
 40109		}
 40110		// match: (XORW <t> g:(MOVWload [off] {sym} ptr mem) x)
 40111		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 40112		// result: (XORWload <t> [off] {sym} x ptr mem)
 40113		for {
 40114			t := v.Type
 40115			x := v.Args[1]
 40116			g := v.Args[0]
 40117			if g.Op != OpS390XMOVWload {
 40118				break
 40119			}
 40120			off := g.AuxInt
 40121			sym := g.Aux
 40122			mem := g.Args[1]
 40123			ptr := g.Args[0]
 40124			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 40125				break
 40126			}
 40127			v.reset(OpS390XXORWload)
 40128			v.Type = t
 40129			v.AuxInt = off
 40130			v.Aux = sym
 40131			v.AddArg(x)
 40132			v.AddArg(ptr)
 40133			v.AddArg(mem)
 40134			return true
 40135		}
 40136		// match: (XORW <t> g:(MOVWload [off] {sym} ptr mem) x)
 40137		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 40138		// result: (XORWload <t> [off] {sym} x ptr mem)
 40139		for {
 40140			t := v.Type
 40141			x := v.Args[1]
 40142			g := v.Args[0]
 40143			if g.Op != OpS390XMOVWload {
 40144				break
 40145			}
 40146			off := g.AuxInt
 40147			sym := g.Aux
 40148			mem := g.Args[1]
 40149			ptr := g.Args[0]
 40150			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 40151				break
 40152			}
 40153			v.reset(OpS390XXORWload)
 40154			v.Type = t
 40155			v.AuxInt = off
 40156			v.Aux = sym
 40157			v.AddArg(x)
 40158			v.AddArg(ptr)
 40159			v.AddArg(mem)
 40160			return true
 40161		}
 40162		// match: (XORW <t> x g:(MOVWload [off] {sym} ptr mem))
 40163		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 40164		// result: (XORWload <t> [off] {sym} x ptr mem)
 40165		for {
 40166			t := v.Type
 40167			_ = v.Args[1]
 40168			x := v.Args[0]
 40169			g := v.Args[1]
 40170			if g.Op != OpS390XMOVWload {
 40171				break
 40172			}
 40173			off := g.AuxInt
 40174			sym := g.Aux
 40175			mem := g.Args[1]
 40176			ptr := g.Args[0]
 40177			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 40178				break
 40179			}
 40180			v.reset(OpS390XXORWload)
 40181			v.Type = t
 40182			v.AuxInt = off
 40183			v.Aux = sym
 40184			v.AddArg(x)
 40185			v.AddArg(ptr)
 40186			v.AddArg(mem)
 40187			return true
 40188		}
 40189		// match: (XORW <t> x g:(MOVWZload [off] {sym} ptr mem))
 40190		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 40191		// result: (XORWload <t> [off] {sym} x ptr mem)
 40192		for {
 40193			t := v.Type
 40194			_ = v.Args[1]
 40195			x := v.Args[0]
 40196			g := v.Args[1]
 40197			if g.Op != OpS390XMOVWZload {
 40198				break
 40199			}
 40200			off := g.AuxInt
 40201			sym := g.Aux
 40202			mem := g.Args[1]
 40203			ptr := g.Args[0]
 40204			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 40205				break
 40206			}
 40207			v.reset(OpS390XXORWload)
 40208			v.Type = t
 40209			v.AuxInt = off
 40210			v.Aux = sym
 40211			v.AddArg(x)
 40212			v.AddArg(ptr)
 40213			v.AddArg(mem)
 40214			return true
 40215		}
 40216		return false
 40217	}
 40218	func rewriteValueS390X_OpS390XXORW_10(v *Value) bool {
 40219		// match: (XORW <t> g:(MOVWZload [off] {sym} ptr mem) x)
 40220		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 40221		// result: (XORWload <t> [off] {sym} x ptr mem)
 40222		for {
 40223			t := v.Type
 40224			x := v.Args[1]
 40225			g := v.Args[0]
 40226			if g.Op != OpS390XMOVWZload {
 40227				break
 40228			}
 40229			off := g.AuxInt
 40230			sym := g.Aux
 40231			mem := g.Args[1]
 40232			ptr := g.Args[0]
 40233			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 40234				break
 40235			}
 40236			v.reset(OpS390XXORWload)
 40237			v.Type = t
 40238			v.AuxInt = off
 40239			v.Aux = sym
 40240			v.AddArg(x)
 40241			v.AddArg(ptr)
 40242			v.AddArg(mem)
 40243			return true
 40244		}
 40245		// match: (XORW <t> g:(MOVWZload [off] {sym} ptr mem) x)
 40246		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 40247		// result: (XORWload <t> [off] {sym} x ptr mem)
 40248		for {
 40249			t := v.Type
 40250			x := v.Args[1]
 40251			g := v.Args[0]
 40252			if g.Op != OpS390XMOVWZload {
 40253				break
 40254			}
 40255			off := g.AuxInt
 40256			sym := g.Aux
 40257			mem := g.Args[1]
 40258			ptr := g.Args[0]
 40259			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 40260				break
 40261			}
 40262			v.reset(OpS390XXORWload)
 40263			v.Type = t
 40264			v.AuxInt = off
 40265			v.Aux = sym
 40266			v.AddArg(x)
 40267			v.AddArg(ptr)
 40268			v.AddArg(mem)
 40269			return true
 40270		}
 40271		// match: (XORW <t> x g:(MOVWZload [off] {sym} ptr mem))
 40272		// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
 40273		// result: (XORWload <t> [off] {sym} x ptr mem)
 40274		for {
 40275			t := v.Type
 40276			_ = v.Args[1]
 40277			x := v.Args[0]
 40278			g := v.Args[1]
 40279			if g.Op != OpS390XMOVWZload {
 40280				break
 40281			}
 40282			off := g.AuxInt
 40283			sym := g.Aux
 40284			mem := g.Args[1]
 40285			ptr := g.Args[0]
 40286			if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
 40287				break
 40288			}
 40289			v.reset(OpS390XXORWload)
 40290			v.Type = t
 40291			v.AuxInt = off
 40292			v.Aux = sym
 40293			v.AddArg(x)
 40294			v.AddArg(ptr)
 40295			v.AddArg(mem)
 40296			return true
 40297		}
 40298		return false
 40299	}
 40300	func rewriteValueS390X_OpS390XXORWconst_0(v *Value) bool {
 40301		// match: (XORWconst [c] x)
 40302		// cond: int32(c)==0
 40303		// result: x
 40304		for {
 40305			c := v.AuxInt
 40306			x := v.Args[0]
 40307			if !(int32(c) == 0) {
 40308				break
 40309			}
 40310			v.reset(OpCopy)
 40311			v.Type = x.Type
 40312			v.AddArg(x)
 40313			return true
 40314		}
 40315		// match: (XORWconst [c] (MOVDconst [d]))
 40316		// cond:
 40317		// result: (MOVDconst [c^d])
 40318		for {
 40319			c := v.AuxInt
 40320			v_0 := v.Args[0]
 40321			if v_0.Op != OpS390XMOVDconst {
 40322				break
 40323			}
 40324			d := v_0.AuxInt
 40325			v.reset(OpS390XMOVDconst)
 40326			v.AuxInt = c ^ d
 40327			return true
 40328		}
 40329		return false
 40330	}
 40331	func rewriteValueS390X_OpS390XXORWload_0(v *Value) bool {
 40332		// match: (XORWload [off1] {sym} x (ADDconst [off2] ptr) mem)
 40333		// cond: ptr.Op != OpSB && is20Bit(off1+off2)
 40334		// result: (XORWload [off1+off2] {sym} x ptr mem)
 40335		for {
 40336			off1 := v.AuxInt
 40337			sym := v.Aux
 40338			mem := v.Args[2]
 40339			x := v.Args[0]
 40340			v_1 := v.Args[1]
 40341			if v_1.Op != OpS390XADDconst {
 40342				break
 40343			}
 40344			off2 := v_1.AuxInt
 40345			ptr := v_1.Args[0]
 40346			if !(ptr.Op != OpSB && is20Bit(off1+off2)) {
 40347				break
 40348			}
 40349			v.reset(OpS390XXORWload)
 40350			v.AuxInt = off1 + off2
 40351			v.Aux = sym
 40352			v.AddArg(x)
 40353			v.AddArg(ptr)
 40354			v.AddArg(mem)
 40355			return true
 40356		}
 40357		// match: (XORWload [o1] {s1} x (MOVDaddr [o2] {s2} ptr) mem)
 40358		// cond: ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)
 40359		// result: (XORWload [o1+o2] {mergeSym(s1, s2)} x ptr mem)
 40360		for {
 40361			o1 := v.AuxInt
 40362			s1 := v.Aux
 40363			mem := v.Args[2]
 40364			x := v.Args[0]
 40365			v_1 := v.Args[1]
 40366			if v_1.Op != OpS390XMOVDaddr {
 40367				break
 40368			}
 40369			o2 := v_1.AuxInt
 40370			s2 := v_1.Aux
 40371			ptr := v_1.Args[0]
 40372			if !(ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)) {
 40373				break
 40374			}
 40375			v.reset(OpS390XXORWload)
 40376			v.AuxInt = o1 + o2
 40377			v.Aux = mergeSym(s1, s2)
 40378			v.AddArg(x)
 40379			v.AddArg(ptr)
 40380			v.AddArg(mem)
 40381			return true
 40382		}
 40383		return false
 40384	}
 40385	func rewriteValueS390X_OpS390XXORconst_0(v *Value) bool {
 40386		// match: (XORconst [0] x)
 40387		// cond:
 40388		// result: x
 40389		for {
 40390			if v.AuxInt != 0 {
 40391				break
 40392			}
 40393			x := v.Args[0]
 40394			v.reset(OpCopy)
 40395			v.Type = x.Type
 40396			v.AddArg(x)
 40397			return true
 40398		}
 40399		// match: (XORconst [c] (MOVDconst [d]))
 40400		// cond:
 40401		// result: (MOVDconst [c^d])
 40402		for {
 40403			c := v.AuxInt
 40404			v_0 := v.Args[0]
 40405			if v_0.Op != OpS390XMOVDconst {
 40406				break
 40407			}
 40408			d := v_0.AuxInt
 40409			v.reset(OpS390XMOVDconst)
 40410			v.AuxInt = c ^ d
 40411			return true
 40412		}
 40413		return false
 40414	}
 40415	func rewriteValueS390X_OpS390XXORload_0(v *Value) bool {
 40416		b := v.Block
 40417		// match: (XORload <t> [off] {sym} x ptr1 (FMOVDstore [off] {sym} ptr2 y _))
 40418		// cond: isSamePtr(ptr1, ptr2)
 40419		// result: (XOR x (LGDR <t> y))
 40420		for {
 40421			t := v.Type
 40422			off := v.AuxInt
 40423			sym := v.Aux
 40424			_ = v.Args[2]
 40425			x := v.Args[0]
 40426			ptr1 := v.Args[1]
 40427			v_2 := v.Args[2]
 40428			if v_2.Op != OpS390XFMOVDstore {
 40429				break
 40430			}
 40431			if v_2.AuxInt != off {
 40432				break
 40433			}
 40434			if v_2.Aux != sym {
 40435				break
 40436			}
 40437			_ = v_2.Args[2]
 40438			ptr2 := v_2.Args[0]
 40439			y := v_2.Args[1]
 40440			if !(isSamePtr(ptr1, ptr2)) {
 40441				break
 40442			}
 40443			v.reset(OpS390XXOR)
 40444			v.AddArg(x)
 40445			v0 := b.NewValue0(v_2.Pos, OpS390XLGDR, t)
 40446			v0.AddArg(y)
 40447			v.AddArg(v0)
 40448			return true
 40449		}
 40450		// match: (XORload [off1] {sym} x (ADDconst [off2] ptr) mem)
 40451		// cond: ptr.Op != OpSB && is20Bit(off1+off2)
 40452		// result: (XORload [off1+off2] {sym} x ptr mem)
 40453		for {
 40454			off1 := v.AuxInt
 40455			sym := v.Aux
 40456			mem := v.Args[2]
 40457			x := v.Args[0]
 40458			v_1 := v.Args[1]
 40459			if v_1.Op != OpS390XADDconst {
 40460				break
 40461			}
 40462			off2 := v_1.AuxInt
 40463			ptr := v_1.Args[0]
 40464			if !(ptr.Op != OpSB && is20Bit(off1+off2)) {
 40465				break
 40466			}
 40467			v.reset(OpS390XXORload)
 40468			v.AuxInt = off1 + off2
 40469			v.Aux = sym
 40470			v.AddArg(x)
 40471			v.AddArg(ptr)
 40472			v.AddArg(mem)
 40473			return true
 40474		}
 40475		// match: (XORload [o1] {s1} x (MOVDaddr [o2] {s2} ptr) mem)
 40476		// cond: ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)
 40477		// result: (XORload [o1+o2] {mergeSym(s1, s2)} x ptr mem)
 40478		for {
 40479			o1 := v.AuxInt
 40480			s1 := v.Aux
 40481			mem := v.Args[2]
 40482			x := v.Args[0]
 40483			v_1 := v.Args[1]
 40484			if v_1.Op != OpS390XMOVDaddr {
 40485				break
 40486			}
 40487			o2 := v_1.AuxInt
 40488			s2 := v_1.Aux
 40489			ptr := v_1.Args[0]
 40490			if !(ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)) {
 40491				break
 40492			}
 40493			v.reset(OpS390XXORload)
 40494			v.AuxInt = o1 + o2
 40495			v.Aux = mergeSym(s1, s2)
 40496			v.AddArg(x)
 40497			v.AddArg(ptr)
 40498			v.AddArg(mem)
 40499			return true
 40500		}
 40501		return false
 40502	}
 40503	func rewriteValueS390X_OpSelect0_0(v *Value) bool {
 40504		b := v.Block
 40505		typ := &b.Func.Config.Types
 40506		// match: (Select0 (Add64carry x y c))
 40507		// cond:
 40508		// result: (Select0 <typ.UInt64> (ADDE x y (Select1 <types.TypeFlags> (ADDCconst c [-1]))))
 40509		for {
 40510			v_0 := v.Args[0]
 40511			if v_0.Op != OpAdd64carry {
 40512				break
 40513			}
 40514			c := v_0.Args[2]
 40515			x := v_0.Args[0]
 40516			y := v_0.Args[1]
 40517			v.reset(OpSelect0)
 40518			v.Type = typ.UInt64
 40519			v0 := b.NewValue0(v.Pos, OpS390XADDE, types.NewTuple(typ.UInt64, types.TypeFlags))
 40520			v0.AddArg(x)
 40521			v0.AddArg(y)
 40522			v1 := b.NewValue0(v.Pos, OpSelect1, types.TypeFlags)
 40523			v2 := b.NewValue0(v.Pos, OpS390XADDCconst, types.NewTuple(typ.UInt64, types.TypeFlags))
 40524			v2.AuxInt = -1
 40525			v2.AddArg(c)
 40526			v1.AddArg(v2)
 40527			v0.AddArg(v1)
 40528			v.AddArg(v0)
 40529			return true
 40530		}
 40531		// match: (Select0 (Sub64borrow x y c))
 40532		// cond:
 40533		// result: (Select0 <typ.UInt64> (SUBE x y (Select1 <types.TypeFlags> (SUBC (MOVDconst [0]) c))))
 40534		for {
 40535			v_0 := v.Args[0]
 40536			if v_0.Op != OpSub64borrow {
 40537				break
 40538			}
 40539			c := v_0.Args[2]
 40540			x := v_0.Args[0]
 40541			y := v_0.Args[1]
 40542			v.reset(OpSelect0)
 40543			v.Type = typ.UInt64
 40544			v0 := b.NewValue0(v.Pos, OpS390XSUBE, types.NewTuple(typ.UInt64, types.TypeFlags))
 40545			v0.AddArg(x)
 40546			v0.AddArg(y)
 40547			v1 := b.NewValue0(v.Pos, OpSelect1, types.TypeFlags)
 40548			v2 := b.NewValue0(v.Pos, OpS390XSUBC, types.NewTuple(typ.UInt64, types.TypeFlags))
 40549			v3 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
 40550			v3.AuxInt = 0
 40551			v2.AddArg(v3)
 40552			v2.AddArg(c)
 40553			v1.AddArg(v2)
 40554			v0.AddArg(v1)
 40555			v.AddArg(v0)
 40556			return true
 40557		}
 40558		// match: (Select0 <t> (AddTupleFirst32 val tuple))
 40559		// cond:
 40560		// result: (ADDW val (Select0 <t> tuple))
 40561		for {
 40562			t := v.Type
 40563			v_0 := v.Args[0]
 40564			if v_0.Op != OpS390XAddTupleFirst32 {
 40565				break
 40566			}
 40567			tuple := v_0.Args[1]
 40568			val := v_0.Args[0]
 40569			v.reset(OpS390XADDW)
 40570			v.AddArg(val)
 40571			v0 := b.NewValue0(v.Pos, OpSelect0, t)
 40572			v0.AddArg(tuple)
 40573			v.AddArg(v0)
 40574			return true
 40575		}
 40576		// match: (Select0 <t> (AddTupleFirst64 val tuple))
 40577		// cond:
 40578		// result: (ADD val (Select0 <t> tuple))
 40579		for {
 40580			t := v.Type
 40581			v_0 := v.Args[0]
 40582			if v_0.Op != OpS390XAddTupleFirst64 {
 40583				break
 40584			}
 40585			tuple := v_0.Args[1]
 40586			val := v_0.Args[0]
 40587			v.reset(OpS390XADD)
 40588			v.AddArg(val)
 40589			v0 := b.NewValue0(v.Pos, OpSelect0, t)
 40590			v0.AddArg(tuple)
 40591			v.AddArg(v0)
 40592			return true
 40593		}
 40594		// match: (Select0 (ADDCconst (MOVDconst [c]) [d]))
 40595		// cond:
 40596		// result: (MOVDconst [c+d])
 40597		for {
 40598			v_0 := v.Args[0]
 40599			if v_0.Op != OpS390XADDCconst {
 40600				break
 40601			}
 40602			d := v_0.AuxInt
 40603			v_0_0 := v_0.Args[0]
 40604			if v_0_0.Op != OpS390XMOVDconst {
 40605				break
 40606			}
 40607			c := v_0_0.AuxInt
 40608			v.reset(OpS390XMOVDconst)
 40609			v.AuxInt = c + d
 40610			return true
 40611		}
 40612		// match: (Select0 (SUBC (MOVDconst [c]) (MOVDconst [d])))
 40613		// cond:
 40614		// result: (MOVDconst [c-d])
 40615		for {
 40616			v_0 := v.Args[0]
 40617			if v_0.Op != OpS390XSUBC {
 40618				break
 40619			}
 40620			_ = v_0.Args[1]
 40621			v_0_0 := v_0.Args[0]
 40622			if v_0_0.Op != OpS390XMOVDconst {
 40623				break
 40624			}
 40625			c := v_0_0.AuxInt
 40626			v_0_1 := v_0.Args[1]
 40627			if v_0_1.Op != OpS390XMOVDconst {
 40628				break
 40629			}
 40630			d := v_0_1.AuxInt
 40631			v.reset(OpS390XMOVDconst)
 40632			v.AuxInt = c - d
 40633			return true
 40634		}
 40635		return false
 40636	}
 40637	func rewriteValueS390X_OpSelect1_0(v *Value) bool {
 40638		b := v.Block
 40639		typ := &b.Func.Config.Types
 40640		// match: (Select1 (Add64carry x y c))
 40641		// cond:
 40642		// result: (Select0 <typ.UInt64> (ADDE (MOVDconst [0]) (MOVDconst [0]) (Select1 <types.TypeFlags> (ADDE x y (Select1 <types.TypeFlags> (ADDCconst c [-1]))))))
 40643		for {
 40644			v_0 := v.Args[0]
 40645			if v_0.Op != OpAdd64carry {
 40646				break
 40647			}
 40648			c := v_0.Args[2]
 40649			x := v_0.Args[0]
 40650			y := v_0.Args[1]
 40651			v.reset(OpSelect0)
 40652			v.Type = typ.UInt64
 40653			v0 := b.NewValue0(v.Pos, OpS390XADDE, types.NewTuple(typ.UInt64, types.TypeFlags))
 40654			v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
 40655			v1.AuxInt = 0
 40656			v0.AddArg(v1)
 40657			v2 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
 40658			v2.AuxInt = 0
 40659			v0.AddArg(v2)
 40660			v3 := b.NewValue0(v.Pos, OpSelect1, types.TypeFlags)
 40661			v4 := b.NewValue0(v.Pos, OpS390XADDE, types.NewTuple(typ.UInt64, types.TypeFlags))
 40662			v4.AddArg(x)
 40663			v4.AddArg(y)
 40664			v5 := b.NewValue0(v.Pos, OpSelect1, types.TypeFlags)
 40665			v6 := b.NewValue0(v.Pos, OpS390XADDCconst, types.NewTuple(typ.UInt64, types.TypeFlags))
 40666			v6.AuxInt = -1
 40667			v6.AddArg(c)
 40668			v5.AddArg(v6)
 40669			v4.AddArg(v5)
 40670			v3.AddArg(v4)
 40671			v0.AddArg(v3)
 40672			v.AddArg(v0)
 40673			return true
 40674		}
 40675		// match: (Select1 (Sub64borrow x y c))
 40676		// cond:
 40677		// result: (NEG (Select0 <typ.UInt64> (SUBE (MOVDconst [0]) (MOVDconst [0]) (Select1 <types.TypeFlags> (SUBE x y (Select1 <types.TypeFlags> (SUBC (MOVDconst [0]) c)))))))
 40678		for {
 40679			v_0 := v.Args[0]
 40680			if v_0.Op != OpSub64borrow {
 40681				break
 40682			}
 40683			c := v_0.Args[2]
 40684			x := v_0.Args[0]
 40685			y := v_0.Args[1]
 40686			v.reset(OpS390XNEG)
 40687			v0 := b.NewValue0(v.Pos, OpSelect0, typ.UInt64)
 40688			v1 := b.NewValue0(v.Pos, OpS390XSUBE, types.NewTuple(typ.UInt64, types.TypeFlags))
 40689			v2 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
 40690			v2.AuxInt = 0
 40691			v1.AddArg(v2)
 40692			v3 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
 40693			v3.AuxInt = 0
 40694			v1.AddArg(v3)
 40695			v4 := b.NewValue0(v.Pos, OpSelect1, types.TypeFlags)
 40696			v5 := b.NewValue0(v.Pos, OpS390XSUBE, types.NewTuple(typ.UInt64, types.TypeFlags))
 40697			v5.AddArg(x)
 40698			v5.AddArg(y)
 40699			v6 := b.NewValue0(v.Pos, OpSelect1, types.TypeFlags)
 40700			v7 := b.NewValue0(v.Pos, OpS390XSUBC, types.NewTuple(typ.UInt64, types.TypeFlags))
 40701			v8 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
 40702			v8.AuxInt = 0
 40703			v7.AddArg(v8)
 40704			v7.AddArg(c)
 40705			v6.AddArg(v7)
 40706			v5.AddArg(v6)
 40707			v4.AddArg(v5)
 40708			v1.AddArg(v4)
 40709			v0.AddArg(v1)
 40710			v.AddArg(v0)
 40711			return true
 40712		}
 40713		// match: (Select1 (AddTupleFirst32 _ tuple))
 40714		// cond:
 40715		// result: (Select1 tuple)
 40716		for {
 40717			v_0 := v.Args[0]
 40718			if v_0.Op != OpS390XAddTupleFirst32 {
 40719				break
 40720			}
 40721			tuple := v_0.Args[1]
 40722			v.reset(OpSelect1)
 40723			v.AddArg(tuple)
 40724			return true
 40725		}
 40726		// match: (Select1 (AddTupleFirst64 _ tuple))
 40727		// cond:
 40728		// result: (Select1 tuple)
 40729		for {
 40730			v_0 := v.Args[0]
 40731			if v_0.Op != OpS390XAddTupleFirst64 {
 40732				break
 40733			}
 40734			tuple := v_0.Args[1]
 40735			v.reset(OpSelect1)
 40736			v.AddArg(tuple)
 40737			return true
 40738		}
 40739		// match: (Select1 (ADDCconst (MOVDconst [c]) [d]))
 40740		// cond: uint64(c+d) >= uint64(c) && c+d == 0
 40741		// result: (FlagEQ)
 40742		for {
 40743			v_0 := v.Args[0]
 40744			if v_0.Op != OpS390XADDCconst {
 40745				break
 40746			}
 40747			d := v_0.AuxInt
 40748			v_0_0 := v_0.Args[0]
 40749			if v_0_0.Op != OpS390XMOVDconst {
 40750				break
 40751			}
 40752			c := v_0_0.AuxInt
 40753			if !(uint64(c+d) >= uint64(c) && c+d == 0) {
 40754				break
 40755			}
 40756			v.reset(OpS390XFlagEQ)
 40757			return true
 40758		}
 40759		// match: (Select1 (ADDCconst (MOVDconst [c]) [d]))
 40760		// cond: uint64(c+d) >= uint64(c) && c+d != 0
 40761		// result: (FlagLT)
 40762		for {
 40763			v_0 := v.Args[0]
 40764			if v_0.Op != OpS390XADDCconst {
 40765				break
 40766			}
 40767			d := v_0.AuxInt
 40768			v_0_0 := v_0.Args[0]
 40769			if v_0_0.Op != OpS390XMOVDconst {
 40770				break
 40771			}
 40772			c := v_0_0.AuxInt
 40773			if !(uint64(c+d) >= uint64(c) && c+d != 0) {
 40774				break
 40775			}
 40776			v.reset(OpS390XFlagLT)
 40777			return true
 40778		}
 40779		// match: (Select1 (SUBC (MOVDconst [c]) (MOVDconst [d])))
 40780		// cond: uint64(d) <= uint64(c) && c-d == 0
 40781		// result: (FlagGT)
 40782		for {
 40783			v_0 := v.Args[0]
 40784			if v_0.Op != OpS390XSUBC {
 40785				break
 40786			}
 40787			_ = v_0.Args[1]
 40788			v_0_0 := v_0.Args[0]
 40789			if v_0_0.Op != OpS390XMOVDconst {
 40790				break
 40791			}
 40792			c := v_0_0.AuxInt
 40793			v_0_1 := v_0.Args[1]
 40794			if v_0_1.Op != OpS390XMOVDconst {
 40795				break
 40796			}
 40797			d := v_0_1.AuxInt
 40798			if !(uint64(d) <= uint64(c) && c-d == 0) {
 40799				break
 40800			}
 40801			v.reset(OpS390XFlagGT)
 40802			return true
 40803		}
 40804		// match: (Select1 (SUBC (MOVDconst [c]) (MOVDconst [d])))
 40805		// cond: uint64(d) <= uint64(c) && c-d != 0
 40806		// result: (FlagOV)
 40807		for {
 40808			v_0 := v.Args[0]
 40809			if v_0.Op != OpS390XSUBC {
 40810				break
 40811			}
 40812			_ = v_0.Args[1]
 40813			v_0_0 := v_0.Args[0]
 40814			if v_0_0.Op != OpS390XMOVDconst {
 40815				break
 40816			}
 40817			c := v_0_0.AuxInt
 40818			v_0_1 := v_0.Args[1]
 40819			if v_0_1.Op != OpS390XMOVDconst {
 40820				break
 40821			}
 40822			d := v_0_1.AuxInt
 40823			if !(uint64(d) <= uint64(c) && c-d != 0) {
 40824				break
 40825			}
 40826			v.reset(OpS390XFlagOV)
 40827			return true
 40828		}
 40829		return false
 40830	}
 40831	func rewriteValueS390X_OpSignExt16to32_0(v *Value) bool {
 40832		// match: (SignExt16to32 x)
 40833		// cond:
 40834		// result: (MOVHreg x)
 40835		for {
 40836			x := v.Args[0]
 40837			v.reset(OpS390XMOVHreg)
 40838			v.AddArg(x)
 40839			return true
 40840		}
 40841	}
 40842	func rewriteValueS390X_OpSignExt16to64_0(v *Value) bool {
 40843		// match: (SignExt16to64 x)
 40844		// cond:
 40845		// result: (MOVHreg x)
 40846		for {
 40847			x := v.Args[0]
 40848			v.reset(OpS390XMOVHreg)
 40849			v.AddArg(x)
 40850			return true
 40851		}
 40852	}
 40853	func rewriteValueS390X_OpSignExt32to64_0(v *Value) bool {
 40854		// match: (SignExt32to64 x)
 40855		// cond:
 40856		// result: (MOVWreg x)
 40857		for {
 40858			x := v.Args[0]
 40859			v.reset(OpS390XMOVWreg)
 40860			v.AddArg(x)
 40861			return true
 40862		}
 40863	}
 40864	func rewriteValueS390X_OpSignExt8to16_0(v *Value) bool {
 40865		// match: (SignExt8to16 x)
 40866		// cond:
 40867		// result: (MOVBreg x)
 40868		for {
 40869			x := v.Args[0]
 40870			v.reset(OpS390XMOVBreg)
 40871			v.AddArg(x)
 40872			return true
 40873		}
 40874	}
 40875	func rewriteValueS390X_OpSignExt8to32_0(v *Value) bool {
 40876		// match: (SignExt8to32 x)
 40877		// cond:
 40878		// result: (MOVBreg x)
 40879		for {
 40880			x := v.Args[0]
 40881			v.reset(OpS390XMOVBreg)
 40882			v.AddArg(x)
 40883			return true
 40884		}
 40885	}
 40886	func rewriteValueS390X_OpSignExt8to64_0(v *Value) bool {
 40887		// match: (SignExt8to64 x)
 40888		// cond:
 40889		// result: (MOVBreg x)
 40890		for {
 40891			x := v.Args[0]
 40892			v.reset(OpS390XMOVBreg)
 40893			v.AddArg(x)
 40894			return true
 40895		}
 40896	}
 40897	func rewriteValueS390X_OpSlicemask_0(v *Value) bool {
 40898		b := v.Block
 40899		// match: (Slicemask <t> x)
 40900		// cond:
 40901		// result: (SRADconst (NEG <t> x) [63])
 40902		for {
 40903			t := v.Type
 40904			x := v.Args[0]
 40905			v.reset(OpS390XSRADconst)
 40906			v.AuxInt = 63
 40907			v0 := b.NewValue0(v.Pos, OpS390XNEG, t)
 40908			v0.AddArg(x)
 40909			v.AddArg(v0)
 40910			return true
 40911		}
 40912	}
 40913	func rewriteValueS390X_OpSqrt_0(v *Value) bool {
 40914		// match: (Sqrt x)
 40915		// cond:
 40916		// result: (FSQRT x)
 40917		for {
 40918			x := v.Args[0]
 40919			v.reset(OpS390XFSQRT)
 40920			v.AddArg(x)
 40921			return true
 40922		}
 40923	}
 40924	func rewriteValueS390X_OpStaticCall_0(v *Value) bool {
 40925		// match: (StaticCall [argwid] {target} mem)
 40926		// cond:
 40927		// result: (CALLstatic [argwid] {target} mem)
 40928		for {
 40929			argwid := v.AuxInt
 40930			target := v.Aux
 40931			mem := v.Args[0]
 40932			v.reset(OpS390XCALLstatic)
 40933			v.AuxInt = argwid
 40934			v.Aux = target
 40935			v.AddArg(mem)
 40936			return true
 40937		}
 40938	}
 40939	func rewriteValueS390X_OpStore_0(v *Value) bool {
 40940		// match: (Store {t} ptr val mem)
 40941		// cond: t.(*types.Type).Size() == 8 && is64BitFloat(val.Type)
 40942		// result: (FMOVDstore ptr val mem)
 40943		for {
 40944			t := v.Aux
 40945			mem := v.Args[2]
 40946			ptr := v.Args[0]
 40947			val := v.Args[1]
 40948			if !(t.(*types.Type).Size() == 8 && is64BitFloat(val.Type)) {
 40949				break
 40950			}
 40951			v.reset(OpS390XFMOVDstore)
 40952			v.AddArg(ptr)
 40953			v.AddArg(val)
 40954			v.AddArg(mem)
 40955			return true
 40956		}
 40957		// match: (Store {t} ptr val mem)
 40958		// cond: t.(*types.Type).Size() == 4 && is32BitFloat(val.Type)
 40959		// result: (FMOVSstore ptr val mem)
 40960		for {
 40961			t := v.Aux
 40962			mem := v.Args[2]
 40963			ptr := v.Args[0]
 40964			val := v.Args[1]
 40965			if !(t.(*types.Type).Size() == 4 && is32BitFloat(val.Type)) {
 40966				break
 40967			}
 40968			v.reset(OpS390XFMOVSstore)
 40969			v.AddArg(ptr)
 40970			v.AddArg(val)
 40971			v.AddArg(mem)
 40972			return true
 40973		}
 40974		// match: (Store {t} ptr val mem)
 40975		// cond: t.(*types.Type).Size() == 8
 40976		// result: (MOVDstore ptr val mem)
 40977		for {
 40978			t := v.Aux
 40979			mem := v.Args[2]
 40980			ptr := v.Args[0]
 40981			val := v.Args[1]
 40982			if !(t.(*types.Type).Size() == 8) {
 40983				break
 40984			}
 40985			v.reset(OpS390XMOVDstore)
 40986			v.AddArg(ptr)
 40987			v.AddArg(val)
 40988			v.AddArg(mem)
 40989			return true
 40990		}
 40991		// match: (Store {t} ptr val mem)
 40992		// cond: t.(*types.Type).Size() == 4
 40993		// result: (MOVWstore ptr val mem)
 40994		for {
 40995			t := v.Aux
 40996			mem := v.Args[2]
 40997			ptr := v.Args[0]
 40998			val := v.Args[1]
 40999			if !(t.(*types.Type).Size() == 4) {
 41000				break
 41001			}
 41002			v.reset(OpS390XMOVWstore)
 41003			v.AddArg(ptr)
 41004			v.AddArg(val)
 41005			v.AddArg(mem)
 41006			return true
 41007		}
 41008		// match: (Store {t} ptr val mem)
 41009		// cond: t.(*types.Type).Size() == 2
 41010		// result: (MOVHstore ptr val mem)
 41011		for {
 41012			t := v.Aux
 41013			mem := v.Args[2]
 41014			ptr := v.Args[0]
 41015			val := v.Args[1]
 41016			if !(t.(*types.Type).Size() == 2) {
 41017				break
 41018			}
 41019			v.reset(OpS390XMOVHstore)
 41020			v.AddArg(ptr)
 41021			v.AddArg(val)
 41022			v.AddArg(mem)
 41023			return true
 41024		}
 41025		// match: (Store {t} ptr val mem)
 41026		// cond: t.(*types.Type).Size() == 1
 41027		// result: (MOVBstore ptr val mem)
 41028		for {
 41029			t := v.Aux
 41030			mem := v.Args[2]
 41031			ptr := v.Args[0]
 41032			val := v.Args[1]
 41033			if !(t.(*types.Type).Size() == 1) {
 41034				break
 41035			}
 41036			v.reset(OpS390XMOVBstore)
 41037			v.AddArg(ptr)
 41038			v.AddArg(val)
 41039			v.AddArg(mem)
 41040			return true
 41041		}
 41042		return false
 41043	}
 41044	func rewriteValueS390X_OpSub16_0(v *Value) bool {
 41045		// match: (Sub16 x y)
 41046		// cond:
 41047		// result: (SUBW x y)
 41048		for {
 41049			y := v.Args[1]
 41050			x := v.Args[0]
 41051			v.reset(OpS390XSUBW)
 41052			v.AddArg(x)
 41053			v.AddArg(y)
 41054			return true
 41055		}
 41056	}
 41057	func rewriteValueS390X_OpSub32_0(v *Value) bool {
 41058		// match: (Sub32 x y)
 41059		// cond:
 41060		// result: (SUBW x y)
 41061		for {
 41062			y := v.Args[1]
 41063			x := v.Args[0]
 41064			v.reset(OpS390XSUBW)
 41065			v.AddArg(x)
 41066			v.AddArg(y)
 41067			return true
 41068		}
 41069	}
 41070	func rewriteValueS390X_OpSub32F_0(v *Value) bool {
 41071		// match: (Sub32F x y)
 41072		// cond:
 41073		// result: (FSUBS x y)
 41074		for {
 41075			y := v.Args[1]
 41076			x := v.Args[0]
 41077			v.reset(OpS390XFSUBS)
 41078			v.AddArg(x)
 41079			v.AddArg(y)
 41080			return true
 41081		}
 41082	}
 41083	func rewriteValueS390X_OpSub64_0(v *Value) bool {
 41084		// match: (Sub64 x y)
 41085		// cond:
 41086		// result: (SUB x y)
 41087		for {
 41088			y := v.Args[1]
 41089			x := v.Args[0]
 41090			v.reset(OpS390XSUB)
 41091			v.AddArg(x)
 41092			v.AddArg(y)
 41093			return true
 41094		}
 41095	}
 41096	func rewriteValueS390X_OpSub64F_0(v *Value) bool {
 41097		// match: (Sub64F x y)
 41098		// cond:
 41099		// result: (FSUB x y)
 41100		for {
 41101			y := v.Args[1]
 41102			x := v.Args[0]
 41103			v.reset(OpS390XFSUB)
 41104			v.AddArg(x)
 41105			v.AddArg(y)
 41106			return true
 41107		}
 41108	}
 41109	func rewriteValueS390X_OpSub8_0(v *Value) bool {
 41110		// match: (Sub8 x y)
 41111		// cond:
 41112		// result: (SUBW x y)
 41113		for {
 41114			y := v.Args[1]
 41115			x := v.Args[0]
 41116			v.reset(OpS390XSUBW)
 41117			v.AddArg(x)
 41118			v.AddArg(y)
 41119			return true
 41120		}
 41121	}
 41122	func rewriteValueS390X_OpSubPtr_0(v *Value) bool {
 41123		// match: (SubPtr x y)
 41124		// cond:
 41125		// result: (SUB x y)
 41126		for {
 41127			y := v.Args[1]
 41128			x := v.Args[0]
 41129			v.reset(OpS390XSUB)
 41130			v.AddArg(x)
 41131			v.AddArg(y)
 41132			return true
 41133		}
 41134	}
 41135	func rewriteValueS390X_OpTrunc_0(v *Value) bool {
 41136		// match: (Trunc x)
 41137		// cond:
 41138		// result: (FIDBR [5] x)
 41139		for {
 41140			x := v.Args[0]
 41141			v.reset(OpS390XFIDBR)
 41142			v.AuxInt = 5
 41143			v.AddArg(x)
 41144			return true
 41145		}
 41146	}
 41147	func rewriteValueS390X_OpTrunc16to8_0(v *Value) bool {
 41148		// match: (Trunc16to8 x)
 41149		// cond:
 41150		// result: x
 41151		for {
 41152			x := v.Args[0]
 41153			v.reset(OpCopy)
 41154			v.Type = x.Type
 41155			v.AddArg(x)
 41156			return true
 41157		}
 41158	}
 41159	func rewriteValueS390X_OpTrunc32to16_0(v *Value) bool {
 41160		// match: (Trunc32to16 x)
 41161		// cond:
 41162		// result: x
 41163		for {
 41164			x := v.Args[0]
 41165			v.reset(OpCopy)
 41166			v.Type = x.Type
 41167			v.AddArg(x)
 41168			return true
 41169		}
 41170	}
 41171	func rewriteValueS390X_OpTrunc32to8_0(v *Value) bool {
 41172		// match: (Trunc32to8 x)
 41173		// cond:
 41174		// result: x
 41175		for {
 41176			x := v.Args[0]
 41177			v.reset(OpCopy)
 41178			v.Type = x.Type
 41179			v.AddArg(x)
 41180			return true
 41181		}
 41182	}
 41183	func rewriteValueS390X_OpTrunc64to16_0(v *Value) bool {
 41184		// match: (Trunc64to16 x)
 41185		// cond:
 41186		// result: x
 41187		for {
 41188			x := v.Args[0]
 41189			v.reset(OpCopy)
 41190			v.Type = x.Type
 41191			v.AddArg(x)
 41192			return true
 41193		}
 41194	}
 41195	func rewriteValueS390X_OpTrunc64to32_0(v *Value) bool {
 41196		// match: (Trunc64to32 x)
 41197		// cond:
 41198		// result: x
 41199		for {
 41200			x := v.Args[0]
 41201			v.reset(OpCopy)
 41202			v.Type = x.Type
 41203			v.AddArg(x)
 41204			return true
 41205		}
 41206	}
 41207	func rewriteValueS390X_OpTrunc64to8_0(v *Value) bool {
 41208		// match: (Trunc64to8 x)
 41209		// cond:
 41210		// result: x
 41211		for {
 41212			x := v.Args[0]
 41213			v.reset(OpCopy)
 41214			v.Type = x.Type
 41215			v.AddArg(x)
 41216			return true
 41217		}
 41218	}
 41219	func rewriteValueS390X_OpWB_0(v *Value) bool {
 41220		// match: (WB {fn} destptr srcptr mem)
 41221		// cond:
 41222		// result: (LoweredWB {fn} destptr srcptr mem)
 41223		for {
 41224			fn := v.Aux
 41225			mem := v.Args[2]
 41226			destptr := v.Args[0]
 41227			srcptr := v.Args[1]
 41228			v.reset(OpS390XLoweredWB)
 41229			v.Aux = fn
 41230			v.AddArg(destptr)
 41231			v.AddArg(srcptr)
 41232			v.AddArg(mem)
 41233			return true
 41234		}
 41235	}
 41236	func rewriteValueS390X_OpXor16_0(v *Value) bool {
 41237		// match: (Xor16 x y)
 41238		// cond:
 41239		// result: (XORW x y)
 41240		for {
 41241			y := v.Args[1]
 41242			x := v.Args[0]
 41243			v.reset(OpS390XXORW)
 41244			v.AddArg(x)
 41245			v.AddArg(y)
 41246			return true
 41247		}
 41248	}
 41249	func rewriteValueS390X_OpXor32_0(v *Value) bool {
 41250		// match: (Xor32 x y)
 41251		// cond:
 41252		// result: (XORW x y)
 41253		for {
 41254			y := v.Args[1]
 41255			x := v.Args[0]
 41256			v.reset(OpS390XXORW)
 41257			v.AddArg(x)
 41258			v.AddArg(y)
 41259			return true
 41260		}
 41261	}
 41262	func rewriteValueS390X_OpXor64_0(v *Value) bool {
 41263		// match: (Xor64 x y)
 41264		// cond:
 41265		// result: (XOR x y)
 41266		for {
 41267			y := v.Args[1]
 41268			x := v.Args[0]
 41269			v.reset(OpS390XXOR)
 41270			v.AddArg(x)
 41271			v.AddArg(y)
 41272			return true
 41273		}
 41274	}
 41275	func rewriteValueS390X_OpXor8_0(v *Value) bool {
 41276		// match: (Xor8 x y)
 41277		// cond:
 41278		// result: (XORW x y)
 41279		for {
 41280			y := v.Args[1]
 41281			x := v.Args[0]
 41282			v.reset(OpS390XXORW)
 41283			v.AddArg(x)
 41284			v.AddArg(y)
 41285			return true
 41286		}
 41287	}
 41288	func rewriteValueS390X_OpZero_0(v *Value) bool {
 41289		b := v.Block
 41290		// match: (Zero [0] _ mem)
 41291		// cond:
 41292		// result: mem
 41293		for {
 41294			if v.AuxInt != 0 {
 41295				break
 41296			}
 41297			mem := v.Args[1]
 41298			v.reset(OpCopy)
 41299			v.Type = mem.Type
 41300			v.AddArg(mem)
 41301			return true
 41302		}
 41303		// match: (Zero [1] destptr mem)
 41304		// cond:
 41305		// result: (MOVBstoreconst [0] destptr mem)
 41306		for {
 41307			if v.AuxInt != 1 {
 41308				break
 41309			}
 41310			mem := v.Args[1]
 41311			destptr := v.Args[0]
 41312			v.reset(OpS390XMOVBstoreconst)
 41313			v.AuxInt = 0
 41314			v.AddArg(destptr)
 41315			v.AddArg(mem)
 41316			return true
 41317		}
 41318		// match: (Zero [2] destptr mem)
 41319		// cond:
 41320		// result: (MOVHstoreconst [0] destptr mem)
 41321		for {
 41322			if v.AuxInt != 2 {
 41323				break
 41324			}
 41325			mem := v.Args[1]
 41326			destptr := v.Args[0]
 41327			v.reset(OpS390XMOVHstoreconst)
 41328			v.AuxInt = 0
 41329			v.AddArg(destptr)
 41330			v.AddArg(mem)
 41331			return true
 41332		}
 41333		// match: (Zero [4] destptr mem)
 41334		// cond:
 41335		// result: (MOVWstoreconst [0] destptr mem)
 41336		for {
 41337			if v.AuxInt != 4 {
 41338				break
 41339			}
 41340			mem := v.Args[1]
 41341			destptr := v.Args[0]
 41342			v.reset(OpS390XMOVWstoreconst)
 41343			v.AuxInt = 0
 41344			v.AddArg(destptr)
 41345			v.AddArg(mem)
 41346			return true
 41347		}
 41348		// match: (Zero [8] destptr mem)
 41349		// cond:
 41350		// result: (MOVDstoreconst [0] destptr mem)
 41351		for {
 41352			if v.AuxInt != 8 {
 41353				break
 41354			}
 41355			mem := v.Args[1]
 41356			destptr := v.Args[0]
 41357			v.reset(OpS390XMOVDstoreconst)
 41358			v.AuxInt = 0
 41359			v.AddArg(destptr)
 41360			v.AddArg(mem)
 41361			return true
 41362		}
 41363		// match: (Zero [3] destptr mem)
 41364		// cond:
 41365		// result: (MOVBstoreconst [makeValAndOff(0,2)] destptr (MOVHstoreconst [0] destptr mem))
 41366		for {
 41367			if v.AuxInt != 3 {
 41368				break
 41369			}
 41370			mem := v.Args[1]
 41371			destptr := v.Args[0]
 41372			v.reset(OpS390XMOVBstoreconst)
 41373			v.AuxInt = makeValAndOff(0, 2)
 41374			v.AddArg(destptr)
 41375			v0 := b.NewValue0(v.Pos, OpS390XMOVHstoreconst, types.TypeMem)
 41376			v0.AuxInt = 0
 41377			v0.AddArg(destptr)
 41378			v0.AddArg(mem)
 41379			v.AddArg(v0)
 41380			return true
 41381		}
 41382		// match: (Zero [5] destptr mem)
 41383		// cond:
 41384		// result: (MOVBstoreconst [makeValAndOff(0,4)] destptr (MOVWstoreconst [0] destptr mem))
 41385		for {
 41386			if v.AuxInt != 5 {
 41387				break
 41388			}
 41389			mem := v.Args[1]
 41390			destptr := v.Args[0]
 41391			v.reset(OpS390XMOVBstoreconst)
 41392			v.AuxInt = makeValAndOff(0, 4)
 41393			v.AddArg(destptr)
 41394			v0 := b.NewValue0(v.Pos, OpS390XMOVWstoreconst, types.TypeMem)
 41395			v0.AuxInt = 0
 41396			v0.AddArg(destptr)
 41397			v0.AddArg(mem)
 41398			v.AddArg(v0)
 41399			return true
 41400		}
 41401		// match: (Zero [6] destptr mem)
 41402		// cond:
 41403		// result: (MOVHstoreconst [makeValAndOff(0,4)] destptr (MOVWstoreconst [0] destptr mem))
 41404		for {
 41405			if v.AuxInt != 6 {
 41406				break
 41407			}
 41408			mem := v.Args[1]
 41409			destptr := v.Args[0]
 41410			v.reset(OpS390XMOVHstoreconst)
 41411			v.AuxInt = makeValAndOff(0, 4)
 41412			v.AddArg(destptr)
 41413			v0 := b.NewValue0(v.Pos, OpS390XMOVWstoreconst, types.TypeMem)
 41414			v0.AuxInt = 0
 41415			v0.AddArg(destptr)
 41416			v0.AddArg(mem)
 41417			v.AddArg(v0)
 41418			return true
 41419		}
 41420		// match: (Zero [7] destptr mem)
 41421		// cond:
 41422		// result: (MOVWstoreconst [makeValAndOff(0,3)] destptr (MOVWstoreconst [0] destptr mem))
 41423		for {
 41424			if v.AuxInt != 7 {
 41425				break
 41426			}
 41427			mem := v.Args[1]
 41428			destptr := v.Args[0]
 41429			v.reset(OpS390XMOVWstoreconst)
 41430			v.AuxInt = makeValAndOff(0, 3)
 41431			v.AddArg(destptr)
 41432			v0 := b.NewValue0(v.Pos, OpS390XMOVWstoreconst, types.TypeMem)
 41433			v0.AuxInt = 0
 41434			v0.AddArg(destptr)
 41435			v0.AddArg(mem)
 41436			v.AddArg(v0)
 41437			return true
 41438		}
 41439		// match: (Zero [s] destptr mem)
 41440		// cond: s > 0 && s <= 1024
 41441		// result: (CLEAR [makeValAndOff(s, 0)] destptr mem)
 41442		for {
 41443			s := v.AuxInt
 41444			mem := v.Args[1]
 41445			destptr := v.Args[0]
 41446			if !(s > 0 && s <= 1024) {
 41447				break
 41448			}
 41449			v.reset(OpS390XCLEAR)
 41450			v.AuxInt = makeValAndOff(s, 0)
 41451			v.AddArg(destptr)
 41452			v.AddArg(mem)
 41453			return true
 41454		}
 41455		return false
 41456	}
 41457	func rewriteValueS390X_OpZero_10(v *Value) bool {
 41458		b := v.Block
 41459		// match: (Zero [s] destptr mem)
 41460		// cond: s > 1024
 41461		// result: (LoweredZero [s%256] destptr (ADDconst <destptr.Type> destptr [(s/256)*256]) mem)
 41462		for {
 41463			s := v.AuxInt
 41464			mem := v.Args[1]
 41465			destptr := v.Args[0]
 41466			if !(s > 1024) {
 41467				break
 41468			}
 41469			v.reset(OpS390XLoweredZero)
 41470			v.AuxInt = s % 256
 41471			v.AddArg(destptr)
 41472			v0 := b.NewValue0(v.Pos, OpS390XADDconst, destptr.Type)
 41473			v0.AuxInt = (s / 256) * 256
 41474			v0.AddArg(destptr)
 41475			v.AddArg(v0)
 41476			v.AddArg(mem)
 41477			return true
 41478		}
 41479		return false
 41480	}
 41481	func rewriteValueS390X_OpZeroExt16to32_0(v *Value) bool {
 41482		// match: (ZeroExt16to32 x)
 41483		// cond:
 41484		// result: (MOVHZreg x)
 41485		for {
 41486			x := v.Args[0]
 41487			v.reset(OpS390XMOVHZreg)
 41488			v.AddArg(x)
 41489			return true
 41490		}
 41491	}
 41492	func rewriteValueS390X_OpZeroExt16to64_0(v *Value) bool {
 41493		// match: (ZeroExt16to64 x)
 41494		// cond:
 41495		// result: (MOVHZreg x)
 41496		for {
 41497			x := v.Args[0]
 41498			v.reset(OpS390XMOVHZreg)
 41499			v.AddArg(x)
 41500			return true
 41501		}
 41502	}
 41503	func rewriteValueS390X_OpZeroExt32to64_0(v *Value) bool {
 41504		// match: (ZeroExt32to64 x)
 41505		// cond:
 41506		// result: (MOVWZreg x)
 41507		for {
 41508			x := v.Args[0]
 41509			v.reset(OpS390XMOVWZreg)
 41510			v.AddArg(x)
 41511			return true
 41512		}
 41513	}
 41514	func rewriteValueS390X_OpZeroExt8to16_0(v *Value) bool {
 41515		// match: (ZeroExt8to16 x)
 41516		// cond:
 41517		// result: (MOVBZreg x)
 41518		for {
 41519			x := v.Args[0]
 41520			v.reset(OpS390XMOVBZreg)
 41521			v.AddArg(x)
 41522			return true
 41523		}
 41524	}
 41525	func rewriteValueS390X_OpZeroExt8to32_0(v *Value) bool {
 41526		// match: (ZeroExt8to32 x)
 41527		// cond:
 41528		// result: (MOVBZreg x)
 41529		for {
 41530			x := v.Args[0]
 41531			v.reset(OpS390XMOVBZreg)
 41532			v.AddArg(x)
 41533			return true
 41534		}
 41535	}
 41536	func rewriteValueS390X_OpZeroExt8to64_0(v *Value) bool {
 41537		// match: (ZeroExt8to64 x)
 41538		// cond:
 41539		// result: (MOVBZreg x)
 41540		for {
 41541			x := v.Args[0]
 41542			v.reset(OpS390XMOVBZreg)
 41543			v.AddArg(x)
 41544			return true
 41545		}
 41546	}
 41547	func rewriteBlockS390X(b *Block) bool {
 41548		config := b.Func.Config
 41549		typ := &config.Types
 41550		_ = typ
 41551		v := b.Control
 41552		_ = v
 41553		switch b.Kind {
 41554		case BlockS390XEQ:
 41555			// match: (EQ (InvertFlags cmp) yes no)
 41556			// cond:
 41557			// result: (EQ cmp yes no)
 41558			for v.Op == OpS390XInvertFlags {
 41559				cmp := v.Args[0]
 41560				b.Kind = BlockS390XEQ
 41561				b.SetControl(cmp)
 41562				b.Aux = nil
 41563				return true
 41564			}
 41565			// match: (EQ (FlagEQ) yes no)
 41566			// cond:
 41567			// result: (First nil yes no)
 41568			for v.Op == OpS390XFlagEQ {
 41569				b.Kind = BlockFirst
 41570				b.SetControl(nil)
 41571				b.Aux = nil
 41572				return true
 41573			}
 41574			// match: (EQ (FlagLT) yes no)
 41575			// cond:
 41576			// result: (First nil no yes)
 41577			for v.Op == OpS390XFlagLT {
 41578				b.Kind = BlockFirst
 41579				b.SetControl(nil)
 41580				b.Aux = nil
 41581				b.swapSuccessors()
 41582				return true
 41583			}
 41584			// match: (EQ (FlagGT) yes no)
 41585			// cond:
 41586			// result: (First nil no yes)
 41587			for v.Op == OpS390XFlagGT {
 41588				b.Kind = BlockFirst
 41589				b.SetControl(nil)
 41590				b.Aux = nil
 41591				b.swapSuccessors()
 41592				return true
 41593			}
 41594		case BlockS390XGE:
 41595			// match: (GE (InvertFlags cmp) yes no)
 41596			// cond:
 41597			// result: (LE cmp yes no)
 41598			for v.Op == OpS390XInvertFlags {
 41599				cmp := v.Args[0]
 41600				b.Kind = BlockS390XLE
 41601				b.SetControl(cmp)
 41602				b.Aux = nil
 41603				return true
 41604			}
 41605			// match: (GE (FlagEQ) yes no)
 41606			// cond:
 41607			// result: (First nil yes no)
 41608			for v.Op == OpS390XFlagEQ {
 41609				b.Kind = BlockFirst
 41610				b.SetControl(nil)
 41611				b.Aux = nil
 41612				return true
 41613			}
 41614			// match: (GE (FlagLT) yes no)
 41615			// cond:
 41616			// result: (First nil no yes)
 41617			for v.Op == OpS390XFlagLT {
 41618				b.Kind = BlockFirst
 41619				b.SetControl(nil)
 41620				b.Aux = nil
 41621				b.swapSuccessors()
 41622				return true
 41623			}
 41624			// match: (GE (FlagGT) yes no)
 41625			// cond:
 41626			// result: (First nil yes no)
 41627			for v.Op == OpS390XFlagGT {
 41628				b.Kind = BlockFirst
 41629				b.SetControl(nil)
 41630				b.Aux = nil
 41631				return true
 41632			}
 41633		case BlockS390XGT:
 41634			// match: (GT (InvertFlags cmp) yes no)
 41635			// cond:
 41636			// result: (LT cmp yes no)
 41637			for v.Op == OpS390XInvertFlags {
 41638				cmp := v.Args[0]
 41639				b.Kind = BlockS390XLT
 41640				b.SetControl(cmp)
 41641				b.Aux = nil
 41642				return true
 41643			}
 41644			// match: (GT (FlagEQ) yes no)
 41645			// cond:
 41646			// result: (First nil no yes)
 41647			for v.Op == OpS390XFlagEQ {
 41648				b.Kind = BlockFirst
 41649				b.SetControl(nil)
 41650				b.Aux = nil
 41651				b.swapSuccessors()
 41652				return true
 41653			}
 41654			// match: (GT (FlagLT) yes no)
 41655			// cond:
 41656			// result: (First nil no yes)
 41657			for v.Op == OpS390XFlagLT {
 41658				b.Kind = BlockFirst
 41659				b.SetControl(nil)
 41660				b.Aux = nil
 41661				b.swapSuccessors()
 41662				return true
 41663			}
 41664			// match: (GT (FlagGT) yes no)
 41665			// cond:
 41666			// result: (First nil yes no)
 41667			for v.Op == OpS390XFlagGT {
 41668				b.Kind = BlockFirst
 41669				b.SetControl(nil)
 41670				b.Aux = nil
 41671				return true
 41672			}
 41673		case BlockIf:
 41674			// match: (If (MOVDLT (MOVDconst [0]) (MOVDconst [1]) cmp) yes no)
 41675			// cond:
 41676			// result: (LT cmp yes no)
 41677			for v.Op == OpS390XMOVDLT {
 41678				cmp := v.Args[2]
 41679				v_0 := v.Args[0]
 41680				if v_0.Op != OpS390XMOVDconst {
 41681					break
 41682				}
 41683				if v_0.AuxInt != 0 {
 41684					break
 41685				}
 41686				v_1 := v.Args[1]
 41687				if v_1.Op != OpS390XMOVDconst {
 41688					break
 41689				}
 41690				if v_1.AuxInt != 1 {
 41691					break
 41692				}
 41693				b.Kind = BlockS390XLT
 41694				b.SetControl(cmp)
 41695				b.Aux = nil
 41696				return true
 41697			}
 41698			// match: (If (MOVDLE (MOVDconst [0]) (MOVDconst [1]) cmp) yes no)
 41699			// cond:
 41700			// result: (LE cmp yes no)
 41701			for v.Op == OpS390XMOVDLE {
 41702				cmp := v.Args[2]
 41703				v_0 := v.Args[0]
 41704				if v_0.Op != OpS390XMOVDconst {
 41705					break
 41706				}
 41707				if v_0.AuxInt != 0 {
 41708					break
 41709				}
 41710				v_1 := v.Args[1]
 41711				if v_1.Op != OpS390XMOVDconst {
 41712					break
 41713				}
 41714				if v_1.AuxInt != 1 {
 41715					break
 41716				}
 41717				b.Kind = BlockS390XLE
 41718				b.SetControl(cmp)
 41719				b.Aux = nil
 41720				return true
 41721			}
 41722			// match: (If (MOVDGT (MOVDconst [0]) (MOVDconst [1]) cmp) yes no)
 41723			// cond:
 41724			// result: (GT cmp yes no)
 41725			for v.Op == OpS390XMOVDGT {
 41726				cmp := v.Args[2]
 41727				v_0 := v.Args[0]
 41728				if v_0.Op != OpS390XMOVDconst {
 41729					break
 41730				}
 41731				if v_0.AuxInt != 0 {
 41732					break
 41733				}
 41734				v_1 := v.Args[1]
 41735				if v_1.Op != OpS390XMOVDconst {
 41736					break
 41737				}
 41738				if v_1.AuxInt != 1 {
 41739					break
 41740				}
 41741				b.Kind = BlockS390XGT
 41742				b.SetControl(cmp)
 41743				b.Aux = nil
 41744				return true
 41745			}
 41746			// match: (If (MOVDGE (MOVDconst [0]) (MOVDconst [1]) cmp) yes no)
 41747			// cond:
 41748			// result: (GE cmp yes no)
 41749			for v.Op == OpS390XMOVDGE {
 41750				cmp := v.Args[2]
 41751				v_0 := v.Args[0]
 41752				if v_0.Op != OpS390XMOVDconst {
 41753					break
 41754				}
 41755				if v_0.AuxInt != 0 {
 41756					break
 41757				}
 41758				v_1 := v.Args[1]
 41759				if v_1.Op != OpS390XMOVDconst {
 41760					break
 41761				}
 41762				if v_1.AuxInt != 1 {
 41763					break
 41764				}
 41765				b.Kind = BlockS390XGE
 41766				b.SetControl(cmp)
 41767				b.Aux = nil
 41768				return true
 41769			}
 41770			// match: (If (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) cmp) yes no)
 41771			// cond:
 41772			// result: (EQ cmp yes no)
 41773			for v.Op == OpS390XMOVDEQ {
 41774				cmp := v.Args[2]
 41775				v_0 := v.Args[0]
 41776				if v_0.Op != OpS390XMOVDconst {
 41777					break
 41778				}
 41779				if v_0.AuxInt != 0 {
 41780					break
 41781				}
 41782				v_1 := v.Args[1]
 41783				if v_1.Op != OpS390XMOVDconst {
 41784					break
 41785				}
 41786				if v_1.AuxInt != 1 {
 41787					break
 41788				}
 41789				b.Kind = BlockS390XEQ
 41790				b.SetControl(cmp)
 41791				b.Aux = nil
 41792				return true
 41793			}
 41794			// match: (If (MOVDNE (MOVDconst [0]) (MOVDconst [1]) cmp) yes no)
 41795			// cond:
 41796			// result: (NE cmp yes no)
 41797			for v.Op == OpS390XMOVDNE {
 41798				cmp := v.Args[2]
 41799				v_0 := v.Args[0]
 41800				if v_0.Op != OpS390XMOVDconst {
 41801					break
 41802				}
 41803				if v_0.AuxInt != 0 {
 41804					break
 41805				}
 41806				v_1 := v.Args[1]
 41807				if v_1.Op != OpS390XMOVDconst {
 41808					break
 41809				}
 41810				if v_1.AuxInt != 1 {
 41811					break
 41812				}
 41813				b.Kind = BlockS390XNE
 41814				b.SetControl(cmp)
 41815				b.Aux = nil
 41816				return true
 41817			}
 41818			// match: (If (MOVDGTnoinv (MOVDconst [0]) (MOVDconst [1]) cmp) yes no)
 41819			// cond:
 41820			// result: (GTF cmp yes no)
 41821			for v.Op == OpS390XMOVDGTnoinv {
 41822				cmp := v.Args[2]
 41823				v_0 := v.Args[0]
 41824				if v_0.Op != OpS390XMOVDconst {
 41825					break
 41826				}
 41827				if v_0.AuxInt != 0 {
 41828					break
 41829				}
 41830				v_1 := v.Args[1]
 41831				if v_1.Op != OpS390XMOVDconst {
 41832					break
 41833				}
 41834				if v_1.AuxInt != 1 {
 41835					break
 41836				}
 41837				b.Kind = BlockS390XGTF
 41838				b.SetControl(cmp)
 41839				b.Aux = nil
 41840				return true
 41841			}
 41842			// match: (If (MOVDGEnoinv (MOVDconst [0]) (MOVDconst [1]) cmp) yes no)
 41843			// cond:
 41844			// result: (GEF cmp yes no)
 41845			for v.Op == OpS390XMOVDGEnoinv {
 41846				cmp := v.Args[2]
 41847				v_0 := v.Args[0]
 41848				if v_0.Op != OpS390XMOVDconst {
 41849					break
 41850				}
 41851				if v_0.AuxInt != 0 {
 41852					break
 41853				}
 41854				v_1 := v.Args[1]
 41855				if v_1.Op != OpS390XMOVDconst {
 41856					break
 41857				}
 41858				if v_1.AuxInt != 1 {
 41859					break
 41860				}
 41861				b.Kind = BlockS390XGEF
 41862				b.SetControl(cmp)
 41863				b.Aux = nil
 41864				return true
 41865			}
 41866			// match: (If cond yes no)
 41867			// cond:
 41868			// result: (NE (CMPWconst [0] (MOVBZreg <typ.Bool> cond)) yes no)
 41869			for {
 41870				cond := b.Control
 41871				b.Kind = BlockS390XNE
 41872				v0 := b.NewValue0(v.Pos, OpS390XCMPWconst, types.TypeFlags)
 41873				v0.AuxInt = 0
 41874				v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.Bool)
 41875				v1.AddArg(cond)
 41876				v0.AddArg(v1)
 41877				b.SetControl(v0)
 41878				b.Aux = nil
 41879				return true
 41880			}
 41881		case BlockS390XLE:
 41882			// match: (LE (InvertFlags cmp) yes no)
 41883			// cond:
 41884			// result: (GE cmp yes no)
 41885			for v.Op == OpS390XInvertFlags {
 41886				cmp := v.Args[0]
 41887				b.Kind = BlockS390XGE
 41888				b.SetControl(cmp)
 41889				b.Aux = nil
 41890				return true
 41891			}
 41892			// match: (LE (FlagEQ) yes no)
 41893			// cond:
 41894			// result: (First nil yes no)
 41895			for v.Op == OpS390XFlagEQ {
 41896				b.Kind = BlockFirst
 41897				b.SetControl(nil)
 41898				b.Aux = nil
 41899				return true
 41900			}
 41901			// match: (LE (FlagLT) yes no)
 41902			// cond:
 41903			// result: (First nil yes no)
 41904			for v.Op == OpS390XFlagLT {
 41905				b.Kind = BlockFirst
 41906				b.SetControl(nil)
 41907				b.Aux = nil
 41908				return true
 41909			}
 41910			// match: (LE (FlagGT) yes no)
 41911			// cond:
 41912			// result: (First nil no yes)
 41913			for v.Op == OpS390XFlagGT {
 41914				b.Kind = BlockFirst
 41915				b.SetControl(nil)
 41916				b.Aux = nil
 41917				b.swapSuccessors()
 41918				return true
 41919			}
 41920		case BlockS390XLT:
 41921			// match: (LT (InvertFlags cmp) yes no)
 41922			// cond:
 41923			// result: (GT cmp yes no)
 41924			for v.Op == OpS390XInvertFlags {
 41925				cmp := v.Args[0]
 41926				b.Kind = BlockS390XGT
 41927				b.SetControl(cmp)
 41928				b.Aux = nil
 41929				return true
 41930			}
 41931			// match: (LT (FlagEQ) yes no)
 41932			// cond:
 41933			// result: (First nil no yes)
 41934			for v.Op == OpS390XFlagEQ {
 41935				b.Kind = BlockFirst
 41936				b.SetControl(nil)
 41937				b.Aux = nil
 41938				b.swapSuccessors()
 41939				return true
 41940			}
 41941			// match: (LT (FlagLT) yes no)
 41942			// cond:
 41943			// result: (First nil yes no)
 41944			for v.Op == OpS390XFlagLT {
 41945				b.Kind = BlockFirst
 41946				b.SetControl(nil)
 41947				b.Aux = nil
 41948				return true
 41949			}
 41950			// match: (LT (FlagGT) yes no)
 41951			// cond:
 41952			// result: (First nil no yes)
 41953			for v.Op == OpS390XFlagGT {
 41954				b.Kind = BlockFirst
 41955				b.SetControl(nil)
 41956				b.Aux = nil
 41957				b.swapSuccessors()
 41958				return true
 41959			}
 41960		case BlockS390XNE:
 41961			// match: (NE (CMPWconst [0] (MOVDLT (MOVDconst [0]) (MOVDconst [1]) cmp)) yes no)
 41962			// cond:
 41963			// result: (LT cmp yes no)
 41964			for v.Op == OpS390XCMPWconst {
 41965				if v.AuxInt != 0 {
 41966					break
 41967				}
 41968				v_0 := v.Args[0]
 41969				if v_0.Op != OpS390XMOVDLT {
 41970					break
 41971				}
 41972				cmp := v_0.Args[2]
 41973				v_0_0 := v_0.Args[0]
 41974				if v_0_0.Op != OpS390XMOVDconst {
 41975					break
 41976				}
 41977				if v_0_0.AuxInt != 0 {
 41978					break
 41979				}
 41980				v_0_1 := v_0.Args[1]
 41981				if v_0_1.Op != OpS390XMOVDconst {
 41982					break
 41983				}
 41984				if v_0_1.AuxInt != 1 {
 41985					break
 41986				}
 41987				b.Kind = BlockS390XLT
 41988				b.SetControl(cmp)
 41989				b.Aux = nil
 41990				return true
 41991			}
 41992			// match: (NE (CMPWconst [0] (MOVDLE (MOVDconst [0]) (MOVDconst [1]) cmp)) yes no)
 41993			// cond:
 41994			// result: (LE cmp yes no)
 41995			for v.Op == OpS390XCMPWconst {
 41996				if v.AuxInt != 0 {
 41997					break
 41998				}
 41999				v_0 := v.Args[0]
 42000				if v_0.Op != OpS390XMOVDLE {
 42001					break
 42002				}
 42003				cmp := v_0.Args[2]
 42004				v_0_0 := v_0.Args[0]
 42005				if v_0_0.Op != OpS390XMOVDconst {
 42006					break
 42007				}
 42008				if v_0_0.AuxInt != 0 {
 42009					break
 42010				}
 42011				v_0_1 := v_0.Args[1]
 42012				if v_0_1.Op != OpS390XMOVDconst {
 42013					break
 42014				}
 42015				if v_0_1.AuxInt != 1 {
 42016					break
 42017				}
 42018				b.Kind = BlockS390XLE
 42019				b.SetControl(cmp)
 42020				b.Aux = nil
 42021				return true
 42022			}
 42023			// match: (NE (CMPWconst [0] (MOVDGT (MOVDconst [0]) (MOVDconst [1]) cmp)) yes no)
 42024			// cond:
 42025			// result: (GT cmp yes no)
 42026			for v.Op == OpS390XCMPWconst {
 42027				if v.AuxInt != 0 {
 42028					break
 42029				}
 42030				v_0 := v.Args[0]
 42031				if v_0.Op != OpS390XMOVDGT {
 42032					break
 42033				}
 42034				cmp := v_0.Args[2]
 42035				v_0_0 := v_0.Args[0]
 42036				if v_0_0.Op != OpS390XMOVDconst {
 42037					break
 42038				}
 42039				if v_0_0.AuxInt != 0 {
 42040					break
 42041				}
 42042				v_0_1 := v_0.Args[1]
 42043				if v_0_1.Op != OpS390XMOVDconst {
 42044					break
 42045				}
 42046				if v_0_1.AuxInt != 1 {
 42047					break
 42048				}
 42049				b.Kind = BlockS390XGT
 42050				b.SetControl(cmp)
 42051				b.Aux = nil
 42052				return true
 42053			}
 42054			// match: (NE (CMPWconst [0] (MOVDGE (MOVDconst [0]) (MOVDconst [1]) cmp)) yes no)
 42055			// cond:
 42056			// result: (GE cmp yes no)
 42057			for v.Op == OpS390XCMPWconst {
 42058				if v.AuxInt != 0 {
 42059					break
 42060				}
 42061				v_0 := v.Args[0]
 42062				if v_0.Op != OpS390XMOVDGE {
 42063					break
 42064				}
 42065				cmp := v_0.Args[2]
 42066				v_0_0 := v_0.Args[0]
 42067				if v_0_0.Op != OpS390XMOVDconst {
 42068					break
 42069				}
 42070				if v_0_0.AuxInt != 0 {
 42071					break
 42072				}
 42073				v_0_1 := v_0.Args[1]
 42074				if v_0_1.Op != OpS390XMOVDconst {
 42075					break
 42076				}
 42077				if v_0_1.AuxInt != 1 {
 42078					break
 42079				}
 42080				b.Kind = BlockS390XGE
 42081				b.SetControl(cmp)
 42082				b.Aux = nil
 42083				return true
 42084			}
 42085			// match: (NE (CMPWconst [0] (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) cmp)) yes no)
 42086			// cond:
 42087			// result: (EQ cmp yes no)
 42088			for v.Op == OpS390XCMPWconst {
 42089				if v.AuxInt != 0 {
 42090					break
 42091				}
 42092				v_0 := v.Args[0]
 42093				if v_0.Op != OpS390XMOVDEQ {
 42094					break
 42095				}
 42096				cmp := v_0.Args[2]
 42097				v_0_0 := v_0.Args[0]
 42098				if v_0_0.Op != OpS390XMOVDconst {
 42099					break
 42100				}
 42101				if v_0_0.AuxInt != 0 {
 42102					break
 42103				}
 42104				v_0_1 := v_0.Args[1]
 42105				if v_0_1.Op != OpS390XMOVDconst {
 42106					break
 42107				}
 42108				if v_0_1.AuxInt != 1 {
 42109					break
 42110				}
 42111				b.Kind = BlockS390XEQ
 42112				b.SetControl(cmp)
 42113				b.Aux = nil
 42114				return true
 42115			}
 42116			// match: (NE (CMPWconst [0] (MOVDNE (MOVDconst [0]) (MOVDconst [1]) cmp)) yes no)
 42117			// cond:
 42118			// result: (NE cmp yes no)
 42119			for v.Op == OpS390XCMPWconst {
 42120				if v.AuxInt != 0 {
 42121					break
 42122				}
 42123				v_0 := v.Args[0]
 42124				if v_0.Op != OpS390XMOVDNE {
 42125					break
 42126				}
 42127				cmp := v_0.Args[2]
 42128				v_0_0 := v_0.Args[0]
 42129				if v_0_0.Op != OpS390XMOVDconst {
 42130					break
 42131				}
 42132				if v_0_0.AuxInt != 0 {
 42133					break
 42134				}
 42135				v_0_1 := v_0.Args[1]
 42136				if v_0_1.Op != OpS390XMOVDconst {
 42137					break
 42138				}
 42139				if v_0_1.AuxInt != 1 {
 42140					break
 42141				}
 42142				b.Kind = BlockS390XNE
 42143				b.SetControl(cmp)
 42144				b.Aux = nil
 42145				return true
 42146			}
 42147			// match: (NE (CMPWconst [0] (MOVDGTnoinv (MOVDconst [0]) (MOVDconst [1]) cmp)) yes no)
 42148			// cond:
 42149			// result: (GTF cmp yes no)
 42150			for v.Op == OpS390XCMPWconst {
 42151				if v.AuxInt != 0 {
 42152					break
 42153				}
 42154				v_0 := v.Args[0]
 42155				if v_0.Op != OpS390XMOVDGTnoinv {
 42156					break
 42157				}
 42158				cmp := v_0.Args[2]
 42159				v_0_0 := v_0.Args[0]
 42160				if v_0_0.Op != OpS390XMOVDconst {
 42161					break
 42162				}
 42163				if v_0_0.AuxInt != 0 {
 42164					break
 42165				}
 42166				v_0_1 := v_0.Args[1]
 42167				if v_0_1.Op != OpS390XMOVDconst {
 42168					break
 42169				}
 42170				if v_0_1.AuxInt != 1 {
 42171					break
 42172				}
 42173				b.Kind = BlockS390XGTF
 42174				b.SetControl(cmp)
 42175				b.Aux = nil
 42176				return true
 42177			}
 42178			// match: (NE (CMPWconst [0] (MOVDGEnoinv (MOVDconst [0]) (MOVDconst [1]) cmp)) yes no)
 42179			// cond:
 42180			// result: (GEF cmp yes no)
 42181			for v.Op == OpS390XCMPWconst {
 42182				if v.AuxInt != 0 {
 42183					break
 42184				}
 42185				v_0 := v.Args[0]
 42186				if v_0.Op != OpS390XMOVDGEnoinv {
 42187					break
 42188				}
 42189				cmp := v_0.Args[2]
 42190				v_0_0 := v_0.Args[0]
 42191				if v_0_0.Op != OpS390XMOVDconst {
 42192					break
 42193				}
 42194				if v_0_0.AuxInt != 0 {
 42195					break
 42196				}
 42197				v_0_1 := v_0.Args[1]
 42198				if v_0_1.Op != OpS390XMOVDconst {
 42199					break
 42200				}
 42201				if v_0_1.AuxInt != 1 {
 42202					break
 42203				}
 42204				b.Kind = BlockS390XGEF
 42205				b.SetControl(cmp)
 42206				b.Aux = nil
 42207				return true
 42208			}
 42209			// match: (NE (InvertFlags cmp) yes no)
 42210			// cond:
 42211			// result: (NE cmp yes no)
 42212			for v.Op == OpS390XInvertFlags {
 42213				cmp := v.Args[0]
 42214				b.Kind = BlockS390XNE
 42215				b.SetControl(cmp)
 42216				b.Aux = nil
 42217				return true
 42218			}
 42219			// match: (NE (FlagEQ) yes no)
 42220			// cond:
 42221			// result: (First nil no yes)
 42222			for v.Op == OpS390XFlagEQ {
 42223				b.Kind = BlockFirst
 42224				b.SetControl(nil)
 42225				b.Aux = nil
 42226				b.swapSuccessors()
 42227				return true
 42228			}
 42229			// match: (NE (FlagLT) yes no)
 42230			// cond:
 42231			// result: (First nil yes no)
 42232			for v.Op == OpS390XFlagLT {
 42233				b.Kind = BlockFirst
 42234				b.SetControl(nil)
 42235				b.Aux = nil
 42236				return true
 42237			}
 42238			// match: (NE (FlagGT) yes no)
 42239			// cond:
 42240			// result: (First nil yes no)
 42241			for v.Op == OpS390XFlagGT {
 42242				b.Kind = BlockFirst
 42243				b.SetControl(nil)
 42244				b.Aux = nil
 42245				return true
 42246			}
 42247		}
 42248		return false
 42249	}
 42250	

View as plain text