Documents Packages The Project Help Blog

The Go Programming Language

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

     1	// Code generated from gen/generic.rules; DO NOT EDIT.
     2	// generated with: cd gen; go run *.go
     3	
     4	package ssa
     5	
     6	import "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 rewriteValuegeneric(v *Value) bool {
    19		switch v.Op {
    20		case OpAdd16:
    21			return rewriteValuegeneric_OpAdd16_0(v) || rewriteValuegeneric_OpAdd16_10(v) || rewriteValuegeneric_OpAdd16_20(v) || rewriteValuegeneric_OpAdd16_30(v)
    22		case OpAdd32:
    23			return rewriteValuegeneric_OpAdd32_0(v) || rewriteValuegeneric_OpAdd32_10(v) || rewriteValuegeneric_OpAdd32_20(v) || rewriteValuegeneric_OpAdd32_30(v)
    24		case OpAdd32F:
    25			return rewriteValuegeneric_OpAdd32F_0(v)
    26		case OpAdd64:
    27			return rewriteValuegeneric_OpAdd64_0(v) || rewriteValuegeneric_OpAdd64_10(v) || rewriteValuegeneric_OpAdd64_20(v) || rewriteValuegeneric_OpAdd64_30(v)
    28		case OpAdd64F:
    29			return rewriteValuegeneric_OpAdd64F_0(v)
    30		case OpAdd8:
    31			return rewriteValuegeneric_OpAdd8_0(v) || rewriteValuegeneric_OpAdd8_10(v) || rewriteValuegeneric_OpAdd8_20(v) || rewriteValuegeneric_OpAdd8_30(v)
    32		case OpAddPtr:
    33			return rewriteValuegeneric_OpAddPtr_0(v)
    34		case OpAnd16:
    35			return rewriteValuegeneric_OpAnd16_0(v) || rewriteValuegeneric_OpAnd16_10(v) || rewriteValuegeneric_OpAnd16_20(v)
    36		case OpAnd32:
    37			return rewriteValuegeneric_OpAnd32_0(v) || rewriteValuegeneric_OpAnd32_10(v) || rewriteValuegeneric_OpAnd32_20(v)
    38		case OpAnd64:
    39			return rewriteValuegeneric_OpAnd64_0(v) || rewriteValuegeneric_OpAnd64_10(v) || rewriteValuegeneric_OpAnd64_20(v)
    40		case OpAnd8:
    41			return rewriteValuegeneric_OpAnd8_0(v) || rewriteValuegeneric_OpAnd8_10(v) || rewriteValuegeneric_OpAnd8_20(v)
    42		case OpArraySelect:
    43			return rewriteValuegeneric_OpArraySelect_0(v)
    44		case OpCom16:
    45			return rewriteValuegeneric_OpCom16_0(v)
    46		case OpCom32:
    47			return rewriteValuegeneric_OpCom32_0(v)
    48		case OpCom64:
    49			return rewriteValuegeneric_OpCom64_0(v)
    50		case OpCom8:
    51			return rewriteValuegeneric_OpCom8_0(v)
    52		case OpConstInterface:
    53			return rewriteValuegeneric_OpConstInterface_0(v)
    54		case OpConstSlice:
    55			return rewriteValuegeneric_OpConstSlice_0(v)
    56		case OpConstString:
    57			return rewriteValuegeneric_OpConstString_0(v)
    58		case OpConvert:
    59			return rewriteValuegeneric_OpConvert_0(v)
    60		case OpCvt32Fto32:
    61			return rewriteValuegeneric_OpCvt32Fto32_0(v)
    62		case OpCvt32Fto64:
    63			return rewriteValuegeneric_OpCvt32Fto64_0(v)
    64		case OpCvt32Fto64F:
    65			return rewriteValuegeneric_OpCvt32Fto64F_0(v)
    66		case OpCvt32to32F:
    67			return rewriteValuegeneric_OpCvt32to32F_0(v)
    68		case OpCvt32to64F:
    69			return rewriteValuegeneric_OpCvt32to64F_0(v)
    70		case OpCvt64Fto32:
    71			return rewriteValuegeneric_OpCvt64Fto32_0(v)
    72		case OpCvt64Fto32F:
    73			return rewriteValuegeneric_OpCvt64Fto32F_0(v)
    74		case OpCvt64Fto64:
    75			return rewriteValuegeneric_OpCvt64Fto64_0(v)
    76		case OpCvt64to32F:
    77			return rewriteValuegeneric_OpCvt64to32F_0(v)
    78		case OpCvt64to64F:
    79			return rewriteValuegeneric_OpCvt64to64F_0(v)
    80		case OpDiv16:
    81			return rewriteValuegeneric_OpDiv16_0(v)
    82		case OpDiv16u:
    83			return rewriteValuegeneric_OpDiv16u_0(v)
    84		case OpDiv32:
    85			return rewriteValuegeneric_OpDiv32_0(v)
    86		case OpDiv32F:
    87			return rewriteValuegeneric_OpDiv32F_0(v)
    88		case OpDiv32u:
    89			return rewriteValuegeneric_OpDiv32u_0(v)
    90		case OpDiv64:
    91			return rewriteValuegeneric_OpDiv64_0(v)
    92		case OpDiv64F:
    93			return rewriteValuegeneric_OpDiv64F_0(v)
    94		case OpDiv64u:
    95			return rewriteValuegeneric_OpDiv64u_0(v)
    96		case OpDiv8:
    97			return rewriteValuegeneric_OpDiv8_0(v)
    98		case OpDiv8u:
    99			return rewriteValuegeneric_OpDiv8u_0(v)
   100		case OpEq16:
   101			return rewriteValuegeneric_OpEq16_0(v) || rewriteValuegeneric_OpEq16_10(v) || rewriteValuegeneric_OpEq16_20(v) || rewriteValuegeneric_OpEq16_30(v) || rewriteValuegeneric_OpEq16_40(v) || rewriteValuegeneric_OpEq16_50(v)
   102		case OpEq32:
   103			return rewriteValuegeneric_OpEq32_0(v) || rewriteValuegeneric_OpEq32_10(v) || rewriteValuegeneric_OpEq32_20(v) || rewriteValuegeneric_OpEq32_30(v) || rewriteValuegeneric_OpEq32_40(v) || rewriteValuegeneric_OpEq32_50(v) || rewriteValuegeneric_OpEq32_60(v) || rewriteValuegeneric_OpEq32_70(v) || rewriteValuegeneric_OpEq32_80(v) || rewriteValuegeneric_OpEq32_90(v)
   104		case OpEq32F:
   105			return rewriteValuegeneric_OpEq32F_0(v)
   106		case OpEq64:
   107			return rewriteValuegeneric_OpEq64_0(v) || rewriteValuegeneric_OpEq64_10(v) || rewriteValuegeneric_OpEq64_20(v) || rewriteValuegeneric_OpEq64_30(v) || rewriteValuegeneric_OpEq64_40(v) || rewriteValuegeneric_OpEq64_50(v) || rewriteValuegeneric_OpEq64_60(v)
   108		case OpEq64F:
   109			return rewriteValuegeneric_OpEq64F_0(v)
   110		case OpEq8:
   111			return rewriteValuegeneric_OpEq8_0(v) || rewriteValuegeneric_OpEq8_10(v) || rewriteValuegeneric_OpEq8_20(v) || rewriteValuegeneric_OpEq8_30(v)
   112		case OpEqB:
   113			return rewriteValuegeneric_OpEqB_0(v)
   114		case OpEqInter:
   115			return rewriteValuegeneric_OpEqInter_0(v)
   116		case OpEqPtr:
   117			return rewriteValuegeneric_OpEqPtr_0(v) || rewriteValuegeneric_OpEqPtr_10(v) || rewriteValuegeneric_OpEqPtr_20(v)
   118		case OpEqSlice:
   119			return rewriteValuegeneric_OpEqSlice_0(v)
   120		case OpGeq16:
   121			return rewriteValuegeneric_OpGeq16_0(v)
   122		case OpGeq16U:
   123			return rewriteValuegeneric_OpGeq16U_0(v)
   124		case OpGeq32:
   125			return rewriteValuegeneric_OpGeq32_0(v)
   126		case OpGeq32F:
   127			return rewriteValuegeneric_OpGeq32F_0(v)
   128		case OpGeq32U:
   129			return rewriteValuegeneric_OpGeq32U_0(v)
   130		case OpGeq64:
   131			return rewriteValuegeneric_OpGeq64_0(v)
   132		case OpGeq64F:
   133			return rewriteValuegeneric_OpGeq64F_0(v)
   134		case OpGeq64U:
   135			return rewriteValuegeneric_OpGeq64U_0(v)
   136		case OpGeq8:
   137			return rewriteValuegeneric_OpGeq8_0(v)
   138		case OpGeq8U:
   139			return rewriteValuegeneric_OpGeq8U_0(v)
   140		case OpGreater16:
   141			return rewriteValuegeneric_OpGreater16_0(v)
   142		case OpGreater16U:
   143			return rewriteValuegeneric_OpGreater16U_0(v)
   144		case OpGreater32:
   145			return rewriteValuegeneric_OpGreater32_0(v)
   146		case OpGreater32F:
   147			return rewriteValuegeneric_OpGreater32F_0(v)
   148		case OpGreater32U:
   149			return rewriteValuegeneric_OpGreater32U_0(v)
   150		case OpGreater64:
   151			return rewriteValuegeneric_OpGreater64_0(v)
   152		case OpGreater64F:
   153			return rewriteValuegeneric_OpGreater64F_0(v)
   154		case OpGreater64U:
   155			return rewriteValuegeneric_OpGreater64U_0(v)
   156		case OpGreater8:
   157			return rewriteValuegeneric_OpGreater8_0(v)
   158		case OpGreater8U:
   159			return rewriteValuegeneric_OpGreater8U_0(v)
   160		case OpIMake:
   161			return rewriteValuegeneric_OpIMake_0(v)
   162		case OpInterCall:
   163			return rewriteValuegeneric_OpInterCall_0(v)
   164		case OpIsInBounds:
   165			return rewriteValuegeneric_OpIsInBounds_0(v) || rewriteValuegeneric_OpIsInBounds_10(v) || rewriteValuegeneric_OpIsInBounds_20(v) || rewriteValuegeneric_OpIsInBounds_30(v)
   166		case OpIsNonNil:
   167			return rewriteValuegeneric_OpIsNonNil_0(v)
   168		case OpIsSliceInBounds:
   169			return rewriteValuegeneric_OpIsSliceInBounds_0(v)
   170		case OpLeq16:
   171			return rewriteValuegeneric_OpLeq16_0(v)
   172		case OpLeq16U:
   173			return rewriteValuegeneric_OpLeq16U_0(v)
   174		case OpLeq32:
   175			return rewriteValuegeneric_OpLeq32_0(v)
   176		case OpLeq32F:
   177			return rewriteValuegeneric_OpLeq32F_0(v)
   178		case OpLeq32U:
   179			return rewriteValuegeneric_OpLeq32U_0(v)
   180		case OpLeq64:
   181			return rewriteValuegeneric_OpLeq64_0(v)
   182		case OpLeq64F:
   183			return rewriteValuegeneric_OpLeq64F_0(v)
   184		case OpLeq64U:
   185			return rewriteValuegeneric_OpLeq64U_0(v)
   186		case OpLeq8:
   187			return rewriteValuegeneric_OpLeq8_0(v)
   188		case OpLeq8U:
   189			return rewriteValuegeneric_OpLeq8U_0(v)
   190		case OpLess16:
   191			return rewriteValuegeneric_OpLess16_0(v)
   192		case OpLess16U:
   193			return rewriteValuegeneric_OpLess16U_0(v)
   194		case OpLess32:
   195			return rewriteValuegeneric_OpLess32_0(v)
   196		case OpLess32F:
   197			return rewriteValuegeneric_OpLess32F_0(v)
   198		case OpLess32U:
   199			return rewriteValuegeneric_OpLess32U_0(v)
   200		case OpLess64:
   201			return rewriteValuegeneric_OpLess64_0(v)
   202		case OpLess64F:
   203			return rewriteValuegeneric_OpLess64F_0(v)
   204		case OpLess64U:
   205			return rewriteValuegeneric_OpLess64U_0(v)
   206		case OpLess8:
   207			return rewriteValuegeneric_OpLess8_0(v)
   208		case OpLess8U:
   209			return rewriteValuegeneric_OpLess8U_0(v)
   210		case OpLoad:
   211			return rewriteValuegeneric_OpLoad_0(v) || rewriteValuegeneric_OpLoad_10(v) || rewriteValuegeneric_OpLoad_20(v)
   212		case OpLsh16x16:
   213			return rewriteValuegeneric_OpLsh16x16_0(v)
   214		case OpLsh16x32:
   215			return rewriteValuegeneric_OpLsh16x32_0(v)
   216		case OpLsh16x64:
   217			return rewriteValuegeneric_OpLsh16x64_0(v)
   218		case OpLsh16x8:
   219			return rewriteValuegeneric_OpLsh16x8_0(v)
   220		case OpLsh32x16:
   221			return rewriteValuegeneric_OpLsh32x16_0(v)
   222		case OpLsh32x32:
   223			return rewriteValuegeneric_OpLsh32x32_0(v)
   224		case OpLsh32x64:
   225			return rewriteValuegeneric_OpLsh32x64_0(v)
   226		case OpLsh32x8:
   227			return rewriteValuegeneric_OpLsh32x8_0(v)
   228		case OpLsh64x16:
   229			return rewriteValuegeneric_OpLsh64x16_0(v)
   230		case OpLsh64x32:
   231			return rewriteValuegeneric_OpLsh64x32_0(v)
   232		case OpLsh64x64:
   233			return rewriteValuegeneric_OpLsh64x64_0(v)
   234		case OpLsh64x8:
   235			return rewriteValuegeneric_OpLsh64x8_0(v)
   236		case OpLsh8x16:
   237			return rewriteValuegeneric_OpLsh8x16_0(v)
   238		case OpLsh8x32:
   239			return rewriteValuegeneric_OpLsh8x32_0(v)
   240		case OpLsh8x64:
   241			return rewriteValuegeneric_OpLsh8x64_0(v)
   242		case OpLsh8x8:
   243			return rewriteValuegeneric_OpLsh8x8_0(v)
   244		case OpMod16:
   245			return rewriteValuegeneric_OpMod16_0(v)
   246		case OpMod16u:
   247			return rewriteValuegeneric_OpMod16u_0(v)
   248		case OpMod32:
   249			return rewriteValuegeneric_OpMod32_0(v)
   250		case OpMod32u:
   251			return rewriteValuegeneric_OpMod32u_0(v)
   252		case OpMod64:
   253			return rewriteValuegeneric_OpMod64_0(v)
   254		case OpMod64u:
   255			return rewriteValuegeneric_OpMod64u_0(v)
   256		case OpMod8:
   257			return rewriteValuegeneric_OpMod8_0(v)
   258		case OpMod8u:
   259			return rewriteValuegeneric_OpMod8u_0(v)
   260		case OpMove:
   261			return rewriteValuegeneric_OpMove_0(v) || rewriteValuegeneric_OpMove_10(v) || rewriteValuegeneric_OpMove_20(v)
   262		case OpMul16:
   263			return rewriteValuegeneric_OpMul16_0(v) || rewriteValuegeneric_OpMul16_10(v)
   264		case OpMul32:
   265			return rewriteValuegeneric_OpMul32_0(v) || rewriteValuegeneric_OpMul32_10(v)
   266		case OpMul32F:
   267			return rewriteValuegeneric_OpMul32F_0(v)
   268		case OpMul64:
   269			return rewriteValuegeneric_OpMul64_0(v) || rewriteValuegeneric_OpMul64_10(v)
   270		case OpMul64F:
   271			return rewriteValuegeneric_OpMul64F_0(v)
   272		case OpMul8:
   273			return rewriteValuegeneric_OpMul8_0(v) || rewriteValuegeneric_OpMul8_10(v)
   274		case OpNeg16:
   275			return rewriteValuegeneric_OpNeg16_0(v)
   276		case OpNeg32:
   277			return rewriteValuegeneric_OpNeg32_0(v)
   278		case OpNeg32F:
   279			return rewriteValuegeneric_OpNeg32F_0(v)
   280		case OpNeg64:
   281			return rewriteValuegeneric_OpNeg64_0(v)
   282		case OpNeg64F:
   283			return rewriteValuegeneric_OpNeg64F_0(v)
   284		case OpNeg8:
   285			return rewriteValuegeneric_OpNeg8_0(v)
   286		case OpNeq16:
   287			return rewriteValuegeneric_OpNeq16_0(v)
   288		case OpNeq32:
   289			return rewriteValuegeneric_OpNeq32_0(v)
   290		case OpNeq32F:
   291			return rewriteValuegeneric_OpNeq32F_0(v)
   292		case OpNeq64:
   293			return rewriteValuegeneric_OpNeq64_0(v)
   294		case OpNeq64F:
   295			return rewriteValuegeneric_OpNeq64F_0(v)
   296		case OpNeq8:
   297			return rewriteValuegeneric_OpNeq8_0(v)
   298		case OpNeqB:
   299			return rewriteValuegeneric_OpNeqB_0(v)
   300		case OpNeqInter:
   301			return rewriteValuegeneric_OpNeqInter_0(v)
   302		case OpNeqPtr:
   303			return rewriteValuegeneric_OpNeqPtr_0(v) || rewriteValuegeneric_OpNeqPtr_10(v) || rewriteValuegeneric_OpNeqPtr_20(v)
   304		case OpNeqSlice:
   305			return rewriteValuegeneric_OpNeqSlice_0(v)
   306		case OpNilCheck:
   307			return rewriteValuegeneric_OpNilCheck_0(v)
   308		case OpNot:
   309			return rewriteValuegeneric_OpNot_0(v) || rewriteValuegeneric_OpNot_10(v) || rewriteValuegeneric_OpNot_20(v) || rewriteValuegeneric_OpNot_30(v) || rewriteValuegeneric_OpNot_40(v)
   310		case OpOffPtr:
   311			return rewriteValuegeneric_OpOffPtr_0(v)
   312		case OpOr16:
   313			return rewriteValuegeneric_OpOr16_0(v) || rewriteValuegeneric_OpOr16_10(v) || rewriteValuegeneric_OpOr16_20(v)
   314		case OpOr32:
   315			return rewriteValuegeneric_OpOr32_0(v) || rewriteValuegeneric_OpOr32_10(v) || rewriteValuegeneric_OpOr32_20(v)
   316		case OpOr64:
   317			return rewriteValuegeneric_OpOr64_0(v) || rewriteValuegeneric_OpOr64_10(v) || rewriteValuegeneric_OpOr64_20(v)
   318		case OpOr8:
   319			return rewriteValuegeneric_OpOr8_0(v) || rewriteValuegeneric_OpOr8_10(v) || rewriteValuegeneric_OpOr8_20(v)
   320		case OpPhi:
   321			return rewriteValuegeneric_OpPhi_0(v)
   322		case OpPtrIndex:
   323			return rewriteValuegeneric_OpPtrIndex_0(v)
   324		case OpRotateLeft16:
   325			return rewriteValuegeneric_OpRotateLeft16_0(v)
   326		case OpRotateLeft32:
   327			return rewriteValuegeneric_OpRotateLeft32_0(v)
   328		case OpRotateLeft64:
   329			return rewriteValuegeneric_OpRotateLeft64_0(v)
   330		case OpRotateLeft8:
   331			return rewriteValuegeneric_OpRotateLeft8_0(v)
   332		case OpRound32F:
   333			return rewriteValuegeneric_OpRound32F_0(v)
   334		case OpRound64F:
   335			return rewriteValuegeneric_OpRound64F_0(v)
   336		case OpRsh16Ux16:
   337			return rewriteValuegeneric_OpRsh16Ux16_0(v)
   338		case OpRsh16Ux32:
   339			return rewriteValuegeneric_OpRsh16Ux32_0(v)
   340		case OpRsh16Ux64:
   341			return rewriteValuegeneric_OpRsh16Ux64_0(v)
   342		case OpRsh16Ux8:
   343			return rewriteValuegeneric_OpRsh16Ux8_0(v)
   344		case OpRsh16x16:
   345			return rewriteValuegeneric_OpRsh16x16_0(v)
   346		case OpRsh16x32:
   347			return rewriteValuegeneric_OpRsh16x32_0(v)
   348		case OpRsh16x64:
   349			return rewriteValuegeneric_OpRsh16x64_0(v)
   350		case OpRsh16x8:
   351			return rewriteValuegeneric_OpRsh16x8_0(v)
   352		case OpRsh32Ux16:
   353			return rewriteValuegeneric_OpRsh32Ux16_0(v)
   354		case OpRsh32Ux32:
   355			return rewriteValuegeneric_OpRsh32Ux32_0(v)
   356		case OpRsh32Ux64:
   357			return rewriteValuegeneric_OpRsh32Ux64_0(v)
   358		case OpRsh32Ux8:
   359			return rewriteValuegeneric_OpRsh32Ux8_0(v)
   360		case OpRsh32x16:
   361			return rewriteValuegeneric_OpRsh32x16_0(v)
   362		case OpRsh32x32:
   363			return rewriteValuegeneric_OpRsh32x32_0(v)
   364		case OpRsh32x64:
   365			return rewriteValuegeneric_OpRsh32x64_0(v)
   366		case OpRsh32x8:
   367			return rewriteValuegeneric_OpRsh32x8_0(v)
   368		case OpRsh64Ux16:
   369			return rewriteValuegeneric_OpRsh64Ux16_0(v)
   370		case OpRsh64Ux32:
   371			return rewriteValuegeneric_OpRsh64Ux32_0(v)
   372		case OpRsh64Ux64:
   373			return rewriteValuegeneric_OpRsh64Ux64_0(v)
   374		case OpRsh64Ux8:
   375			return rewriteValuegeneric_OpRsh64Ux8_0(v)
   376		case OpRsh64x16:
   377			return rewriteValuegeneric_OpRsh64x16_0(v)
   378		case OpRsh64x32:
   379			return rewriteValuegeneric_OpRsh64x32_0(v)
   380		case OpRsh64x64:
   381			return rewriteValuegeneric_OpRsh64x64_0(v)
   382		case OpRsh64x8:
   383			return rewriteValuegeneric_OpRsh64x8_0(v)
   384		case OpRsh8Ux16:
   385			return rewriteValuegeneric_OpRsh8Ux16_0(v)
   386		case OpRsh8Ux32:
   387			return rewriteValuegeneric_OpRsh8Ux32_0(v)
   388		case OpRsh8Ux64:
   389			return rewriteValuegeneric_OpRsh8Ux64_0(v)
   390		case OpRsh8Ux8:
   391			return rewriteValuegeneric_OpRsh8Ux8_0(v)
   392		case OpRsh8x16:
   393			return rewriteValuegeneric_OpRsh8x16_0(v)
   394		case OpRsh8x32:
   395			return rewriteValuegeneric_OpRsh8x32_0(v)
   396		case OpRsh8x64:
   397			return rewriteValuegeneric_OpRsh8x64_0(v)
   398		case OpRsh8x8:
   399			return rewriteValuegeneric_OpRsh8x8_0(v)
   400		case OpSelect0:
   401			return rewriteValuegeneric_OpSelect0_0(v)
   402		case OpSelect1:
   403			return rewriteValuegeneric_OpSelect1_0(v)
   404		case OpSignExt16to32:
   405			return rewriteValuegeneric_OpSignExt16to32_0(v)
   406		case OpSignExt16to64:
   407			return rewriteValuegeneric_OpSignExt16to64_0(v)
   408		case OpSignExt32to64:
   409			return rewriteValuegeneric_OpSignExt32to64_0(v)
   410		case OpSignExt8to16:
   411			return rewriteValuegeneric_OpSignExt8to16_0(v)
   412		case OpSignExt8to32:
   413			return rewriteValuegeneric_OpSignExt8to32_0(v)
   414		case OpSignExt8to64:
   415			return rewriteValuegeneric_OpSignExt8to64_0(v)
   416		case OpSliceCap:
   417			return rewriteValuegeneric_OpSliceCap_0(v)
   418		case OpSliceLen:
   419			return rewriteValuegeneric_OpSliceLen_0(v)
   420		case OpSlicePtr:
   421			return rewriteValuegeneric_OpSlicePtr_0(v)
   422		case OpSlicemask:
   423			return rewriteValuegeneric_OpSlicemask_0(v)
   424		case OpSqrt:
   425			return rewriteValuegeneric_OpSqrt_0(v)
   426		case OpStaticCall:
   427			return rewriteValuegeneric_OpStaticCall_0(v)
   428		case OpStore:
   429			return rewriteValuegeneric_OpStore_0(v) || rewriteValuegeneric_OpStore_10(v) || rewriteValuegeneric_OpStore_20(v)
   430		case OpStringLen:
   431			return rewriteValuegeneric_OpStringLen_0(v)
   432		case OpStringPtr:
   433			return rewriteValuegeneric_OpStringPtr_0(v)
   434		case OpStructSelect:
   435			return rewriteValuegeneric_OpStructSelect_0(v) || rewriteValuegeneric_OpStructSelect_10(v)
   436		case OpSub16:
   437			return rewriteValuegeneric_OpSub16_0(v) || rewriteValuegeneric_OpSub16_10(v)
   438		case OpSub32:
   439			return rewriteValuegeneric_OpSub32_0(v) || rewriteValuegeneric_OpSub32_10(v)
   440		case OpSub32F:
   441			return rewriteValuegeneric_OpSub32F_0(v)
   442		case OpSub64:
   443			return rewriteValuegeneric_OpSub64_0(v) || rewriteValuegeneric_OpSub64_10(v)
   444		case OpSub64F:
   445			return rewriteValuegeneric_OpSub64F_0(v)
   446		case OpSub8:
   447			return rewriteValuegeneric_OpSub8_0(v) || rewriteValuegeneric_OpSub8_10(v)
   448		case OpTrunc16to8:
   449			return rewriteValuegeneric_OpTrunc16to8_0(v)
   450		case OpTrunc32to16:
   451			return rewriteValuegeneric_OpTrunc32to16_0(v)
   452		case OpTrunc32to8:
   453			return rewriteValuegeneric_OpTrunc32to8_0(v)
   454		case OpTrunc64to16:
   455			return rewriteValuegeneric_OpTrunc64to16_0(v)
   456		case OpTrunc64to32:
   457			return rewriteValuegeneric_OpTrunc64to32_0(v)
   458		case OpTrunc64to8:
   459			return rewriteValuegeneric_OpTrunc64to8_0(v)
   460		case OpXor16:
   461			return rewriteValuegeneric_OpXor16_0(v) || rewriteValuegeneric_OpXor16_10(v)
   462		case OpXor32:
   463			return rewriteValuegeneric_OpXor32_0(v) || rewriteValuegeneric_OpXor32_10(v)
   464		case OpXor64:
   465			return rewriteValuegeneric_OpXor64_0(v) || rewriteValuegeneric_OpXor64_10(v)
   466		case OpXor8:
   467			return rewriteValuegeneric_OpXor8_0(v) || rewriteValuegeneric_OpXor8_10(v)
   468		case OpZero:
   469			return rewriteValuegeneric_OpZero_0(v)
   470		case OpZeroExt16to32:
   471			return rewriteValuegeneric_OpZeroExt16to32_0(v)
   472		case OpZeroExt16to64:
   473			return rewriteValuegeneric_OpZeroExt16to64_0(v)
   474		case OpZeroExt32to64:
   475			return rewriteValuegeneric_OpZeroExt32to64_0(v)
   476		case OpZeroExt8to16:
   477			return rewriteValuegeneric_OpZeroExt8to16_0(v)
   478		case OpZeroExt8to32:
   479			return rewriteValuegeneric_OpZeroExt8to32_0(v)
   480		case OpZeroExt8to64:
   481			return rewriteValuegeneric_OpZeroExt8to64_0(v)
   482		}
   483		return false
   484	}
   485	func rewriteValuegeneric_OpAdd16_0(v *Value) bool {
   486		b := v.Block
   487		// match: (Add16 (Const16 [c]) (Const16 [d]))
   488		// cond:
   489		// result: (Const16 [int64(int16(c+d))])
   490		for {
   491			_ = v.Args[1]
   492			v_0 := v.Args[0]
   493			if v_0.Op != OpConst16 {
   494				break
   495			}
   496			c := v_0.AuxInt
   497			v_1 := v.Args[1]
   498			if v_1.Op != OpConst16 {
   499				break
   500			}
   501			d := v_1.AuxInt
   502			v.reset(OpConst16)
   503			v.AuxInt = int64(int16(c + d))
   504			return true
   505		}
   506		// match: (Add16 (Const16 [d]) (Const16 [c]))
   507		// cond:
   508		// result: (Const16 [int64(int16(c+d))])
   509		for {
   510			_ = v.Args[1]
   511			v_0 := v.Args[0]
   512			if v_0.Op != OpConst16 {
   513				break
   514			}
   515			d := v_0.AuxInt
   516			v_1 := v.Args[1]
   517			if v_1.Op != OpConst16 {
   518				break
   519			}
   520			c := v_1.AuxInt
   521			v.reset(OpConst16)
   522			v.AuxInt = int64(int16(c + d))
   523			return true
   524		}
   525		// match: (Add16 <t> (Mul16 x y) (Mul16 x z))
   526		// cond:
   527		// result: (Mul16 x (Add16 <t> y z))
   528		for {
   529			t := v.Type
   530			_ = v.Args[1]
   531			v_0 := v.Args[0]
   532			if v_0.Op != OpMul16 {
   533				break
   534			}
   535			y := v_0.Args[1]
   536			x := v_0.Args[0]
   537			v_1 := v.Args[1]
   538			if v_1.Op != OpMul16 {
   539				break
   540			}
   541			z := v_1.Args[1]
   542			if x != v_1.Args[0] {
   543				break
   544			}
   545			v.reset(OpMul16)
   546			v.AddArg(x)
   547			v0 := b.NewValue0(v.Pos, OpAdd16, t)
   548			v0.AddArg(y)
   549			v0.AddArg(z)
   550			v.AddArg(v0)
   551			return true
   552		}
   553		// match: (Add16 <t> (Mul16 y x) (Mul16 x z))
   554		// cond:
   555		// result: (Mul16 x (Add16 <t> y z))
   556		for {
   557			t := v.Type
   558			_ = v.Args[1]
   559			v_0 := v.Args[0]
   560			if v_0.Op != OpMul16 {
   561				break
   562			}
   563			x := v_0.Args[1]
   564			y := v_0.Args[0]
   565			v_1 := v.Args[1]
   566			if v_1.Op != OpMul16 {
   567				break
   568			}
   569			z := v_1.Args[1]
   570			if x != v_1.Args[0] {
   571				break
   572			}
   573			v.reset(OpMul16)
   574			v.AddArg(x)
   575			v0 := b.NewValue0(v.Pos, OpAdd16, t)
   576			v0.AddArg(y)
   577			v0.AddArg(z)
   578			v.AddArg(v0)
   579			return true
   580		}
   581		// match: (Add16 <t> (Mul16 x y) (Mul16 z x))
   582		// cond:
   583		// result: (Mul16 x (Add16 <t> y z))
   584		for {
   585			t := v.Type
   586			_ = v.Args[1]
   587			v_0 := v.Args[0]
   588			if v_0.Op != OpMul16 {
   589				break
   590			}
   591			y := v_0.Args[1]
   592			x := v_0.Args[0]
   593			v_1 := v.Args[1]
   594			if v_1.Op != OpMul16 {
   595				break
   596			}
   597			_ = v_1.Args[1]
   598			z := v_1.Args[0]
   599			if x != v_1.Args[1] {
   600				break
   601			}
   602			v.reset(OpMul16)
   603			v.AddArg(x)
   604			v0 := b.NewValue0(v.Pos, OpAdd16, t)
   605			v0.AddArg(y)
   606			v0.AddArg(z)
   607			v.AddArg(v0)
   608			return true
   609		}
   610		// match: (Add16 <t> (Mul16 y x) (Mul16 z x))
   611		// cond:
   612		// result: (Mul16 x (Add16 <t> y z))
   613		for {
   614			t := v.Type
   615			_ = v.Args[1]
   616			v_0 := v.Args[0]
   617			if v_0.Op != OpMul16 {
   618				break
   619			}
   620			x := v_0.Args[1]
   621			y := v_0.Args[0]
   622			v_1 := v.Args[1]
   623			if v_1.Op != OpMul16 {
   624				break
   625			}
   626			_ = v_1.Args[1]
   627			z := v_1.Args[0]
   628			if x != v_1.Args[1] {
   629				break
   630			}
   631			v.reset(OpMul16)
   632			v.AddArg(x)
   633			v0 := b.NewValue0(v.Pos, OpAdd16, t)
   634			v0.AddArg(y)
   635			v0.AddArg(z)
   636			v.AddArg(v0)
   637			return true
   638		}
   639		// match: (Add16 <t> (Mul16 x z) (Mul16 x y))
   640		// cond:
   641		// result: (Mul16 x (Add16 <t> y z))
   642		for {
   643			t := v.Type
   644			_ = v.Args[1]
   645			v_0 := v.Args[0]
   646			if v_0.Op != OpMul16 {
   647				break
   648			}
   649			z := v_0.Args[1]
   650			x := v_0.Args[0]
   651			v_1 := v.Args[1]
   652			if v_1.Op != OpMul16 {
   653				break
   654			}
   655			y := v_1.Args[1]
   656			if x != v_1.Args[0] {
   657				break
   658			}
   659			v.reset(OpMul16)
   660			v.AddArg(x)
   661			v0 := b.NewValue0(v.Pos, OpAdd16, t)
   662			v0.AddArg(y)
   663			v0.AddArg(z)
   664			v.AddArg(v0)
   665			return true
   666		}
   667		// match: (Add16 <t> (Mul16 z x) (Mul16 x y))
   668		// cond:
   669		// result: (Mul16 x (Add16 <t> y z))
   670		for {
   671			t := v.Type
   672			_ = v.Args[1]
   673			v_0 := v.Args[0]
   674			if v_0.Op != OpMul16 {
   675				break
   676			}
   677			x := v_0.Args[1]
   678			z := v_0.Args[0]
   679			v_1 := v.Args[1]
   680			if v_1.Op != OpMul16 {
   681				break
   682			}
   683			y := v_1.Args[1]
   684			if x != v_1.Args[0] {
   685				break
   686			}
   687			v.reset(OpMul16)
   688			v.AddArg(x)
   689			v0 := b.NewValue0(v.Pos, OpAdd16, t)
   690			v0.AddArg(y)
   691			v0.AddArg(z)
   692			v.AddArg(v0)
   693			return true
   694		}
   695		// match: (Add16 <t> (Mul16 x z) (Mul16 y x))
   696		// cond:
   697		// result: (Mul16 x (Add16 <t> y z))
   698		for {
   699			t := v.Type
   700			_ = v.Args[1]
   701			v_0 := v.Args[0]
   702			if v_0.Op != OpMul16 {
   703				break
   704			}
   705			z := v_0.Args[1]
   706			x := v_0.Args[0]
   707			v_1 := v.Args[1]
   708			if v_1.Op != OpMul16 {
   709				break
   710			}
   711			_ = v_1.Args[1]
   712			y := v_1.Args[0]
   713			if x != v_1.Args[1] {
   714				break
   715			}
   716			v.reset(OpMul16)
   717			v.AddArg(x)
   718			v0 := b.NewValue0(v.Pos, OpAdd16, t)
   719			v0.AddArg(y)
   720			v0.AddArg(z)
   721			v.AddArg(v0)
   722			return true
   723		}
   724		// match: (Add16 <t> (Mul16 z x) (Mul16 y x))
   725		// cond:
   726		// result: (Mul16 x (Add16 <t> y z))
   727		for {
   728			t := v.Type
   729			_ = v.Args[1]
   730			v_0 := v.Args[0]
   731			if v_0.Op != OpMul16 {
   732				break
   733			}
   734			x := v_0.Args[1]
   735			z := v_0.Args[0]
   736			v_1 := v.Args[1]
   737			if v_1.Op != OpMul16 {
   738				break
   739			}
   740			_ = v_1.Args[1]
   741			y := v_1.Args[0]
   742			if x != v_1.Args[1] {
   743				break
   744			}
   745			v.reset(OpMul16)
   746			v.AddArg(x)
   747			v0 := b.NewValue0(v.Pos, OpAdd16, t)
   748			v0.AddArg(y)
   749			v0.AddArg(z)
   750			v.AddArg(v0)
   751			return true
   752		}
   753		return false
   754	}
   755	func rewriteValuegeneric_OpAdd16_10(v *Value) bool {
   756		b := v.Block
   757		// match: (Add16 (Const16 [0]) x)
   758		// cond:
   759		// result: x
   760		for {
   761			x := v.Args[1]
   762			v_0 := v.Args[0]
   763			if v_0.Op != OpConst16 {
   764				break
   765			}
   766			if v_0.AuxInt != 0 {
   767				break
   768			}
   769			v.reset(OpCopy)
   770			v.Type = x.Type
   771			v.AddArg(x)
   772			return true
   773		}
   774		// match: (Add16 x (Const16 [0]))
   775		// cond:
   776		// result: x
   777		for {
   778			_ = v.Args[1]
   779			x := v.Args[0]
   780			v_1 := v.Args[1]
   781			if v_1.Op != OpConst16 {
   782				break
   783			}
   784			if v_1.AuxInt != 0 {
   785				break
   786			}
   787			v.reset(OpCopy)
   788			v.Type = x.Type
   789			v.AddArg(x)
   790			return true
   791		}
   792		// match: (Add16 (Const16 [1]) (Com16 x))
   793		// cond:
   794		// result: (Neg16 x)
   795		for {
   796			_ = v.Args[1]
   797			v_0 := v.Args[0]
   798			if v_0.Op != OpConst16 {
   799				break
   800			}
   801			if v_0.AuxInt != 1 {
   802				break
   803			}
   804			v_1 := v.Args[1]
   805			if v_1.Op != OpCom16 {
   806				break
   807			}
   808			x := v_1.Args[0]
   809			v.reset(OpNeg16)
   810			v.AddArg(x)
   811			return true
   812		}
   813		// match: (Add16 (Com16 x) (Const16 [1]))
   814		// cond:
   815		// result: (Neg16 x)
   816		for {
   817			_ = v.Args[1]
   818			v_0 := v.Args[0]
   819			if v_0.Op != OpCom16 {
   820				break
   821			}
   822			x := v_0.Args[0]
   823			v_1 := v.Args[1]
   824			if v_1.Op != OpConst16 {
   825				break
   826			}
   827			if v_1.AuxInt != 1 {
   828				break
   829			}
   830			v.reset(OpNeg16)
   831			v.AddArg(x)
   832			return true
   833		}
   834		// match: (Add16 (Add16 i:(Const16 <t>) z) x)
   835		// cond: (z.Op != OpConst16 && x.Op != OpConst16)
   836		// result: (Add16 i (Add16 <t> z x))
   837		for {
   838			x := v.Args[1]
   839			v_0 := v.Args[0]
   840			if v_0.Op != OpAdd16 {
   841				break
   842			}
   843			z := v_0.Args[1]
   844			i := v_0.Args[0]
   845			if i.Op != OpConst16 {
   846				break
   847			}
   848			t := i.Type
   849			if !(z.Op != OpConst16 && x.Op != OpConst16) {
   850				break
   851			}
   852			v.reset(OpAdd16)
   853			v.AddArg(i)
   854			v0 := b.NewValue0(v.Pos, OpAdd16, t)
   855			v0.AddArg(z)
   856			v0.AddArg(x)
   857			v.AddArg(v0)
   858			return true
   859		}
   860		// match: (Add16 (Add16 z i:(Const16 <t>)) x)
   861		// cond: (z.Op != OpConst16 && x.Op != OpConst16)
   862		// result: (Add16 i (Add16 <t> z x))
   863		for {
   864			x := v.Args[1]
   865			v_0 := v.Args[0]
   866			if v_0.Op != OpAdd16 {
   867				break
   868			}
   869			_ = v_0.Args[1]
   870			z := v_0.Args[0]
   871			i := v_0.Args[1]
   872			if i.Op != OpConst16 {
   873				break
   874			}
   875			t := i.Type
   876			if !(z.Op != OpConst16 && x.Op != OpConst16) {
   877				break
   878			}
   879			v.reset(OpAdd16)
   880			v.AddArg(i)
   881			v0 := b.NewValue0(v.Pos, OpAdd16, t)
   882			v0.AddArg(z)
   883			v0.AddArg(x)
   884			v.AddArg(v0)
   885			return true
   886		}
   887		// match: (Add16 x (Add16 i:(Const16 <t>) z))
   888		// cond: (z.Op != OpConst16 && x.Op != OpConst16)
   889		// result: (Add16 i (Add16 <t> z x))
   890		for {
   891			_ = v.Args[1]
   892			x := v.Args[0]
   893			v_1 := v.Args[1]
   894			if v_1.Op != OpAdd16 {
   895				break
   896			}
   897			z := v_1.Args[1]
   898			i := v_1.Args[0]
   899			if i.Op != OpConst16 {
   900				break
   901			}
   902			t := i.Type
   903			if !(z.Op != OpConst16 && x.Op != OpConst16) {
   904				break
   905			}
   906			v.reset(OpAdd16)
   907			v.AddArg(i)
   908			v0 := b.NewValue0(v.Pos, OpAdd16, t)
   909			v0.AddArg(z)
   910			v0.AddArg(x)
   911			v.AddArg(v0)
   912			return true
   913		}
   914		// match: (Add16 x (Add16 z i:(Const16 <t>)))
   915		// cond: (z.Op != OpConst16 && x.Op != OpConst16)
   916		// result: (Add16 i (Add16 <t> z x))
   917		for {
   918			_ = v.Args[1]
   919			x := v.Args[0]
   920			v_1 := v.Args[1]
   921			if v_1.Op != OpAdd16 {
   922				break
   923			}
   924			_ = v_1.Args[1]
   925			z := v_1.Args[0]
   926			i := v_1.Args[1]
   927			if i.Op != OpConst16 {
   928				break
   929			}
   930			t := i.Type
   931			if !(z.Op != OpConst16 && x.Op != OpConst16) {
   932				break
   933			}
   934			v.reset(OpAdd16)
   935			v.AddArg(i)
   936			v0 := b.NewValue0(v.Pos, OpAdd16, t)
   937			v0.AddArg(z)
   938			v0.AddArg(x)
   939			v.AddArg(v0)
   940			return true
   941		}
   942		// match: (Add16 (Sub16 i:(Const16 <t>) z) x)
   943		// cond: (z.Op != OpConst16 && x.Op != OpConst16)
   944		// result: (Add16 i (Sub16 <t> x z))
   945		for {
   946			x := v.Args[1]
   947			v_0 := v.Args[0]
   948			if v_0.Op != OpSub16 {
   949				break
   950			}
   951			z := v_0.Args[1]
   952			i := v_0.Args[0]
   953			if i.Op != OpConst16 {
   954				break
   955			}
   956			t := i.Type
   957			if !(z.Op != OpConst16 && x.Op != OpConst16) {
   958				break
   959			}
   960			v.reset(OpAdd16)
   961			v.AddArg(i)
   962			v0 := b.NewValue0(v.Pos, OpSub16, t)
   963			v0.AddArg(x)
   964			v0.AddArg(z)
   965			v.AddArg(v0)
   966			return true
   967		}
   968		// match: (Add16 x (Sub16 i:(Const16 <t>) z))
   969		// cond: (z.Op != OpConst16 && x.Op != OpConst16)
   970		// result: (Add16 i (Sub16 <t> x z))
   971		for {
   972			_ = v.Args[1]
   973			x := v.Args[0]
   974			v_1 := v.Args[1]
   975			if v_1.Op != OpSub16 {
   976				break
   977			}
   978			z := v_1.Args[1]
   979			i := v_1.Args[0]
   980			if i.Op != OpConst16 {
   981				break
   982			}
   983			t := i.Type
   984			if !(z.Op != OpConst16 && x.Op != OpConst16) {
   985				break
   986			}
   987			v.reset(OpAdd16)
   988			v.AddArg(i)
   989			v0 := b.NewValue0(v.Pos, OpSub16, t)
   990			v0.AddArg(x)
   991			v0.AddArg(z)
   992			v.AddArg(v0)
   993			return true
   994		}
   995		return false
   996	}
   997	func rewriteValuegeneric_OpAdd16_20(v *Value) bool {
   998		b := v.Block
   999		// match: (Add16 x (Sub16 i:(Const16 <t>) z))
  1000		// cond: (z.Op != OpConst16 && x.Op != OpConst16)
  1001		// result: (Add16 i (Sub16 <t> x z))
  1002		for {
  1003			_ = v.Args[1]
  1004			x := v.Args[0]
  1005			v_1 := v.Args[1]
  1006			if v_1.Op != OpSub16 {
  1007				break
  1008			}
  1009			z := v_1.Args[1]
  1010			i := v_1.Args[0]
  1011			if i.Op != OpConst16 {
  1012				break
  1013			}
  1014			t := i.Type
  1015			if !(z.Op != OpConst16 && x.Op != OpConst16) {
  1016				break
  1017			}
  1018			v.reset(OpAdd16)
  1019			v.AddArg(i)
  1020			v0 := b.NewValue0(v.Pos, OpSub16, t)
  1021			v0.AddArg(x)
  1022			v0.AddArg(z)
  1023			v.AddArg(v0)
  1024			return true
  1025		}
  1026		// match: (Add16 (Sub16 i:(Const16 <t>) z) x)
  1027		// cond: (z.Op != OpConst16 && x.Op != OpConst16)
  1028		// result: (Add16 i (Sub16 <t> x z))
  1029		for {
  1030			x := v.Args[1]
  1031			v_0 := v.Args[0]
  1032			if v_0.Op != OpSub16 {
  1033				break
  1034			}
  1035			z := v_0.Args[1]
  1036			i := v_0.Args[0]
  1037			if i.Op != OpConst16 {
  1038				break
  1039			}
  1040			t := i.Type
  1041			if !(z.Op != OpConst16 && x.Op != OpConst16) {
  1042				break
  1043			}
  1044			v.reset(OpAdd16)
  1045			v.AddArg(i)
  1046			v0 := b.NewValue0(v.Pos, OpSub16, t)
  1047			v0.AddArg(x)
  1048			v0.AddArg(z)
  1049			v.AddArg(v0)
  1050			return true
  1051		}
  1052		// match: (Add16 (Sub16 z i:(Const16 <t>)) x)
  1053		// cond: (z.Op != OpConst16 && x.Op != OpConst16)
  1054		// result: (Sub16 (Add16 <t> x z) i)
  1055		for {
  1056			x := v.Args[1]
  1057			v_0 := v.Args[0]
  1058			if v_0.Op != OpSub16 {
  1059				break
  1060			}
  1061			_ = v_0.Args[1]
  1062			z := v_0.Args[0]
  1063			i := v_0.Args[1]
  1064			if i.Op != OpConst16 {
  1065				break
  1066			}
  1067			t := i.Type
  1068			if !(z.Op != OpConst16 && x.Op != OpConst16) {
  1069				break
  1070			}
  1071			v.reset(OpSub16)
  1072			v0 := b.NewValue0(v.Pos, OpAdd16, t)
  1073			v0.AddArg(x)
  1074			v0.AddArg(z)
  1075			v.AddArg(v0)
  1076			v.AddArg(i)
  1077			return true
  1078		}
  1079		// match: (Add16 x (Sub16 z i:(Const16 <t>)))
  1080		// cond: (z.Op != OpConst16 && x.Op != OpConst16)
  1081		// result: (Sub16 (Add16 <t> x z) i)
  1082		for {
  1083			_ = v.Args[1]
  1084			x := v.Args[0]
  1085			v_1 := v.Args[1]
  1086			if v_1.Op != OpSub16 {
  1087				break
  1088			}
  1089			_ = v_1.Args[1]
  1090			z := v_1.Args[0]
  1091			i := v_1.Args[1]
  1092			if i.Op != OpConst16 {
  1093				break
  1094			}
  1095			t := i.Type
  1096			if !(z.Op != OpConst16 && x.Op != OpConst16) {
  1097				break
  1098			}
  1099			v.reset(OpSub16)
  1100			v0 := b.NewValue0(v.Pos, OpAdd16, t)
  1101			v0.AddArg(x)
  1102			v0.AddArg(z)
  1103			v.AddArg(v0)
  1104			v.AddArg(i)
  1105			return true
  1106		}
  1107		// match: (Add16 x (Sub16 z i:(Const16 <t>)))
  1108		// cond: (z.Op != OpConst16 && x.Op != OpConst16)
  1109		// result: (Sub16 (Add16 <t> x z) i)
  1110		for {
  1111			_ = v.Args[1]
  1112			x := v.Args[0]
  1113			v_1 := v.Args[1]
  1114			if v_1.Op != OpSub16 {
  1115				break
  1116			}
  1117			_ = v_1.Args[1]
  1118			z := v_1.Args[0]
  1119			i := v_1.Args[1]
  1120			if i.Op != OpConst16 {
  1121				break
  1122			}
  1123			t := i.Type
  1124			if !(z.Op != OpConst16 && x.Op != OpConst16) {
  1125				break
  1126			}
  1127			v.reset(OpSub16)
  1128			v0 := b.NewValue0(v.Pos, OpAdd16, t)
  1129			v0.AddArg(x)
  1130			v0.AddArg(z)
  1131			v.AddArg(v0)
  1132			v.AddArg(i)
  1133			return true
  1134		}
  1135		// match: (Add16 (Sub16 z i:(Const16 <t>)) x)
  1136		// cond: (z.Op != OpConst16 && x.Op != OpConst16)
  1137		// result: (Sub16 (Add16 <t> x z) i)
  1138		for {
  1139			x := v.Args[1]
  1140			v_0 := v.Args[0]
  1141			if v_0.Op != OpSub16 {
  1142				break
  1143			}
  1144			_ = v_0.Args[1]
  1145			z := v_0.Args[0]
  1146			i := v_0.Args[1]
  1147			if i.Op != OpConst16 {
  1148				break
  1149			}
  1150			t := i.Type
  1151			if !(z.Op != OpConst16 && x.Op != OpConst16) {
  1152				break
  1153			}
  1154			v.reset(OpSub16)
  1155			v0 := b.NewValue0(v.Pos, OpAdd16, t)
  1156			v0.AddArg(x)
  1157			v0.AddArg(z)
  1158			v.AddArg(v0)
  1159			v.AddArg(i)
  1160			return true
  1161		}
  1162		// match: (Add16 (Const16 <t> [c]) (Add16 (Const16 <t> [d]) x))
  1163		// cond:
  1164		// result: (Add16 (Const16 <t> [int64(int16(c+d))]) x)
  1165		for {
  1166			_ = v.Args[1]
  1167			v_0 := v.Args[0]
  1168			if v_0.Op != OpConst16 {
  1169				break
  1170			}
  1171			t := v_0.Type
  1172			c := v_0.AuxInt
  1173			v_1 := v.Args[1]
  1174			if v_1.Op != OpAdd16 {
  1175				break
  1176			}
  1177			x := v_1.Args[1]
  1178			v_1_0 := v_1.Args[0]
  1179			if v_1_0.Op != OpConst16 {
  1180				break
  1181			}
  1182			if v_1_0.Type != t {
  1183				break
  1184			}
  1185			d := v_1_0.AuxInt
  1186			v.reset(OpAdd16)
  1187			v0 := b.NewValue0(v.Pos, OpConst16, t)
  1188			v0.AuxInt = int64(int16(c + d))
  1189			v.AddArg(v0)
  1190			v.AddArg(x)
  1191			return true
  1192		}
  1193		// match: (Add16 (Const16 <t> [c]) (Add16 x (Const16 <t> [d])))
  1194		// cond:
  1195		// result: (Add16 (Const16 <t> [int64(int16(c+d))]) x)
  1196		for {
  1197			_ = v.Args[1]
  1198			v_0 := v.Args[0]
  1199			if v_0.Op != OpConst16 {
  1200				break
  1201			}
  1202			t := v_0.Type
  1203			c := v_0.AuxInt
  1204			v_1 := v.Args[1]
  1205			if v_1.Op != OpAdd16 {
  1206				break
  1207			}
  1208			_ = v_1.Args[1]
  1209			x := v_1.Args[0]
  1210			v_1_1 := v_1.Args[1]
  1211			if v_1_1.Op != OpConst16 {
  1212				break
  1213			}
  1214			if v_1_1.Type != t {
  1215				break
  1216			}
  1217			d := v_1_1.AuxInt
  1218			v.reset(OpAdd16)
  1219			v0 := b.NewValue0(v.Pos, OpConst16, t)
  1220			v0.AuxInt = int64(int16(c + d))
  1221			v.AddArg(v0)
  1222			v.AddArg(x)
  1223			return true
  1224		}
  1225		// match: (Add16 (Add16 (Const16 <t> [d]) x) (Const16 <t> [c]))
  1226		// cond:
  1227		// result: (Add16 (Const16 <t> [int64(int16(c+d))]) x)
  1228		for {
  1229			_ = v.Args[1]
  1230			v_0 := v.Args[0]
  1231			if v_0.Op != OpAdd16 {
  1232				break
  1233			}
  1234			x := v_0.Args[1]
  1235			v_0_0 := v_0.Args[0]
  1236			if v_0_0.Op != OpConst16 {
  1237				break
  1238			}
  1239			t := v_0_0.Type
  1240			d := v_0_0.AuxInt
  1241			v_1 := v.Args[1]
  1242			if v_1.Op != OpConst16 {
  1243				break
  1244			}
  1245			if v_1.Type != t {
  1246				break
  1247			}
  1248			c := v_1.AuxInt
  1249			v.reset(OpAdd16)
  1250			v0 := b.NewValue0(v.Pos, OpConst16, t)
  1251			v0.AuxInt = int64(int16(c + d))
  1252			v.AddArg(v0)
  1253			v.AddArg(x)
  1254			return true
  1255		}
  1256		// match: (Add16 (Add16 x (Const16 <t> [d])) (Const16 <t> [c]))
  1257		// cond:
  1258		// result: (Add16 (Const16 <t> [int64(int16(c+d))]) x)
  1259		for {
  1260			_ = v.Args[1]
  1261			v_0 := v.Args[0]
  1262			if v_0.Op != OpAdd16 {
  1263				break
  1264			}
  1265			_ = v_0.Args[1]
  1266			x := v_0.Args[0]
  1267			v_0_1 := v_0.Args[1]
  1268			if v_0_1.Op != OpConst16 {
  1269				break
  1270			}
  1271			t := v_0_1.Type
  1272			d := v_0_1.AuxInt
  1273			v_1 := v.Args[1]
  1274			if v_1.Op != OpConst16 {
  1275				break
  1276			}
  1277			if v_1.Type != t {
  1278				break
  1279			}
  1280			c := v_1.AuxInt
  1281			v.reset(OpAdd16)
  1282			v0 := b.NewValue0(v.Pos, OpConst16, t)
  1283			v0.AuxInt = int64(int16(c + d))
  1284			v.AddArg(v0)
  1285			v.AddArg(x)
  1286			return true
  1287		}
  1288		return false
  1289	}
  1290	func rewriteValuegeneric_OpAdd16_30(v *Value) bool {
  1291		b := v.Block
  1292		// match: (Add16 (Const16 <t> [c]) (Sub16 (Const16 <t> [d]) x))
  1293		// cond:
  1294		// result: (Sub16 (Const16 <t> [int64(int16(c+d))]) x)
  1295		for {
  1296			_ = v.Args[1]
  1297			v_0 := v.Args[0]
  1298			if v_0.Op != OpConst16 {
  1299				break
  1300			}
  1301			t := v_0.Type
  1302			c := v_0.AuxInt
  1303			v_1 := v.Args[1]
  1304			if v_1.Op != OpSub16 {
  1305				break
  1306			}
  1307			x := v_1.Args[1]
  1308			v_1_0 := v_1.Args[0]
  1309			if v_1_0.Op != OpConst16 {
  1310				break
  1311			}
  1312			if v_1_0.Type != t {
  1313				break
  1314			}
  1315			d := v_1_0.AuxInt
  1316			v.reset(OpSub16)
  1317			v0 := b.NewValue0(v.Pos, OpConst16, t)
  1318			v0.AuxInt = int64(int16(c + d))
  1319			v.AddArg(v0)
  1320			v.AddArg(x)
  1321			return true
  1322		}
  1323		// match: (Add16 (Sub16 (Const16 <t> [d]) x) (Const16 <t> [c]))
  1324		// cond:
  1325		// result: (Sub16 (Const16 <t> [int64(int16(c+d))]) x)
  1326		for {
  1327			_ = v.Args[1]
  1328			v_0 := v.Args[0]
  1329			if v_0.Op != OpSub16 {
  1330				break
  1331			}
  1332			x := v_0.Args[1]
  1333			v_0_0 := v_0.Args[0]
  1334			if v_0_0.Op != OpConst16 {
  1335				break
  1336			}
  1337			t := v_0_0.Type
  1338			d := v_0_0.AuxInt
  1339			v_1 := v.Args[1]
  1340			if v_1.Op != OpConst16 {
  1341				break
  1342			}
  1343			if v_1.Type != t {
  1344				break
  1345			}
  1346			c := v_1.AuxInt
  1347			v.reset(OpSub16)
  1348			v0 := b.NewValue0(v.Pos, OpConst16, t)
  1349			v0.AuxInt = int64(int16(c + d))
  1350			v.AddArg(v0)
  1351			v.AddArg(x)
  1352			return true
  1353		}
  1354		// match: (Add16 (Const16 <t> [c]) (Sub16 x (Const16 <t> [d])))
  1355		// cond:
  1356		// result: (Add16 (Const16 <t> [int64(int16(c-d))]) x)
  1357		for {
  1358			_ = v.Args[1]
  1359			v_0 := v.Args[0]
  1360			if v_0.Op != OpConst16 {
  1361				break
  1362			}
  1363			t := v_0.Type
  1364			c := v_0.AuxInt
  1365			v_1 := v.Args[1]
  1366			if v_1.Op != OpSub16 {
  1367				break
  1368			}
  1369			_ = v_1.Args[1]
  1370			x := v_1.Args[0]
  1371			v_1_1 := v_1.Args[1]
  1372			if v_1_1.Op != OpConst16 {
  1373				break
  1374			}
  1375			if v_1_1.Type != t {
  1376				break
  1377			}
  1378			d := v_1_1.AuxInt
  1379			v.reset(OpAdd16)
  1380			v0 := b.NewValue0(v.Pos, OpConst16, t)
  1381			v0.AuxInt = int64(int16(c - d))
  1382			v.AddArg(v0)
  1383			v.AddArg(x)
  1384			return true
  1385		}
  1386		// match: (Add16 (Sub16 x (Const16 <t> [d])) (Const16 <t> [c]))
  1387		// cond:
  1388		// result: (Add16 (Const16 <t> [int64(int16(c-d))]) x)
  1389		for {
  1390			_ = v.Args[1]
  1391			v_0 := v.Args[0]
  1392			if v_0.Op != OpSub16 {
  1393				break
  1394			}
  1395			_ = v_0.Args[1]
  1396			x := v_0.Args[0]
  1397			v_0_1 := v_0.Args[1]
  1398			if v_0_1.Op != OpConst16 {
  1399				break
  1400			}
  1401			t := v_0_1.Type
  1402			d := v_0_1.AuxInt
  1403			v_1 := v.Args[1]
  1404			if v_1.Op != OpConst16 {
  1405				break
  1406			}
  1407			if v_1.Type != t {
  1408				break
  1409			}
  1410			c := v_1.AuxInt
  1411			v.reset(OpAdd16)
  1412			v0 := b.NewValue0(v.Pos, OpConst16, t)
  1413			v0.AuxInt = int64(int16(c - d))
  1414			v.AddArg(v0)
  1415			v.AddArg(x)
  1416			return true
  1417		}
  1418		return false
  1419	}
  1420	func rewriteValuegeneric_OpAdd32_0(v *Value) bool {
  1421		b := v.Block
  1422		// match: (Add32 (Const32 [c]) (Const32 [d]))
  1423		// cond:
  1424		// result: (Const32 [int64(int32(c+d))])
  1425		for {
  1426			_ = v.Args[1]
  1427			v_0 := v.Args[0]
  1428			if v_0.Op != OpConst32 {
  1429				break
  1430			}
  1431			c := v_0.AuxInt
  1432			v_1 := v.Args[1]
  1433			if v_1.Op != OpConst32 {
  1434				break
  1435			}
  1436			d := v_1.AuxInt
  1437			v.reset(OpConst32)
  1438			v.AuxInt = int64(int32(c + d))
  1439			return true
  1440		}
  1441		// match: (Add32 (Const32 [d]) (Const32 [c]))
  1442		// cond:
  1443		// result: (Const32 [int64(int32(c+d))])
  1444		for {
  1445			_ = v.Args[1]
  1446			v_0 := v.Args[0]
  1447			if v_0.Op != OpConst32 {
  1448				break
  1449			}
  1450			d := v_0.AuxInt
  1451			v_1 := v.Args[1]
  1452			if v_1.Op != OpConst32 {
  1453				break
  1454			}
  1455			c := v_1.AuxInt
  1456			v.reset(OpConst32)
  1457			v.AuxInt = int64(int32(c + d))
  1458			return true
  1459		}
  1460		// match: (Add32 <t> (Mul32 x y) (Mul32 x z))
  1461		// cond:
  1462		// result: (Mul32 x (Add32 <t> y z))
  1463		for {
  1464			t := v.Type
  1465			_ = v.Args[1]
  1466			v_0 := v.Args[0]
  1467			if v_0.Op != OpMul32 {
  1468				break
  1469			}
  1470			y := v_0.Args[1]
  1471			x := v_0.Args[0]
  1472			v_1 := v.Args[1]
  1473			if v_1.Op != OpMul32 {
  1474				break
  1475			}
  1476			z := v_1.Args[1]
  1477			if x != v_1.Args[0] {
  1478				break
  1479			}
  1480			v.reset(OpMul32)
  1481			v.AddArg(x)
  1482			v0 := b.NewValue0(v.Pos, OpAdd32, t)
  1483			v0.AddArg(y)
  1484			v0.AddArg(z)
  1485			v.AddArg(v0)
  1486			return true
  1487		}
  1488		// match: (Add32 <t> (Mul32 y x) (Mul32 x z))
  1489		// cond:
  1490		// result: (Mul32 x (Add32 <t> y z))
  1491		for {
  1492			t := v.Type
  1493			_ = v.Args[1]
  1494			v_0 := v.Args[0]
  1495			if v_0.Op != OpMul32 {
  1496				break
  1497			}
  1498			x := v_0.Args[1]
  1499			y := v_0.Args[0]
  1500			v_1 := v.Args[1]
  1501			if v_1.Op != OpMul32 {
  1502				break
  1503			}
  1504			z := v_1.Args[1]
  1505			if x != v_1.Args[0] {
  1506				break
  1507			}
  1508			v.reset(OpMul32)
  1509			v.AddArg(x)
  1510			v0 := b.NewValue0(v.Pos, OpAdd32, t)
  1511			v0.AddArg(y)
  1512			v0.AddArg(z)
  1513			v.AddArg(v0)
  1514			return true
  1515		}
  1516		// match: (Add32 <t> (Mul32 x y) (Mul32 z x))
  1517		// cond:
  1518		// result: (Mul32 x (Add32 <t> y z))
  1519		for {
  1520			t := v.Type
  1521			_ = v.Args[1]
  1522			v_0 := v.Args[0]
  1523			if v_0.Op != OpMul32 {
  1524				break
  1525			}
  1526			y := v_0.Args[1]
  1527			x := v_0.Args[0]
  1528			v_1 := v.Args[1]
  1529			if v_1.Op != OpMul32 {
  1530				break
  1531			}
  1532			_ = v_1.Args[1]
  1533			z := v_1.Args[0]
  1534			if x != v_1.Args[1] {
  1535				break
  1536			}
  1537			v.reset(OpMul32)
  1538			v.AddArg(x)
  1539			v0 := b.NewValue0(v.Pos, OpAdd32, t)
  1540			v0.AddArg(y)
  1541			v0.AddArg(z)
  1542			v.AddArg(v0)
  1543			return true
  1544		}
  1545		// match: (Add32 <t> (Mul32 y x) (Mul32 z x))
  1546		// cond:
  1547		// result: (Mul32 x (Add32 <t> y z))
  1548		for {
  1549			t := v.Type
  1550			_ = v.Args[1]
  1551			v_0 := v.Args[0]
  1552			if v_0.Op != OpMul32 {
  1553				break
  1554			}
  1555			x := v_0.Args[1]
  1556			y := v_0.Args[0]
  1557			v_1 := v.Args[1]
  1558			if v_1.Op != OpMul32 {
  1559				break
  1560			}
  1561			_ = v_1.Args[1]
  1562			z := v_1.Args[0]
  1563			if x != v_1.Args[1] {
  1564				break
  1565			}
  1566			v.reset(OpMul32)
  1567			v.AddArg(x)
  1568			v0 := b.NewValue0(v.Pos, OpAdd32, t)
  1569			v0.AddArg(y)
  1570			v0.AddArg(z)
  1571			v.AddArg(v0)
  1572			return true
  1573		}
  1574		// match: (Add32 <t> (Mul32 x z) (Mul32 x y))
  1575		// cond:
  1576		// result: (Mul32 x (Add32 <t> y z))
  1577		for {
  1578			t := v.Type
  1579			_ = v.Args[1]
  1580			v_0 := v.Args[0]
  1581			if v_0.Op != OpMul32 {
  1582				break
  1583			}
  1584			z := v_0.Args[1]
  1585			x := v_0.Args[0]
  1586			v_1 := v.Args[1]
  1587			if v_1.Op != OpMul32 {
  1588				break
  1589			}
  1590			y := v_1.Args[1]
  1591			if x != v_1.Args[0] {
  1592				break
  1593			}
  1594			v.reset(OpMul32)
  1595			v.AddArg(x)
  1596			v0 := b.NewValue0(v.Pos, OpAdd32, t)
  1597			v0.AddArg(y)
  1598			v0.AddArg(z)
  1599			v.AddArg(v0)
  1600			return true
  1601		}
  1602		// match: (Add32 <t> (Mul32 z x) (Mul32 x y))
  1603		// cond:
  1604		// result: (Mul32 x (Add32 <t> y z))
  1605		for {
  1606			t := v.Type
  1607			_ = v.Args[1]
  1608			v_0 := v.Args[0]
  1609			if v_0.Op != OpMul32 {
  1610				break
  1611			}
  1612			x := v_0.Args[1]
  1613			z := v_0.Args[0]
  1614			v_1 := v.Args[1]
  1615			if v_1.Op != OpMul32 {
  1616				break
  1617			}
  1618			y := v_1.Args[1]
  1619			if x != v_1.Args[0] {
  1620				break
  1621			}
  1622			v.reset(OpMul32)
  1623			v.AddArg(x)
  1624			v0 := b.NewValue0(v.Pos, OpAdd32, t)
  1625			v0.AddArg(y)
  1626			v0.AddArg(z)
  1627			v.AddArg(v0)
  1628			return true
  1629		}
  1630		// match: (Add32 <t> (Mul32 x z) (Mul32 y x))
  1631		// cond:
  1632		// result: (Mul32 x (Add32 <t> y z))
  1633		for {
  1634			t := v.Type
  1635			_ = v.Args[1]
  1636			v_0 := v.Args[0]
  1637			if v_0.Op != OpMul32 {
  1638				break
  1639			}
  1640			z := v_0.Args[1]
  1641			x := v_0.Args[0]
  1642			v_1 := v.Args[1]
  1643			if v_1.Op != OpMul32 {
  1644				break
  1645			}
  1646			_ = v_1.Args[1]
  1647			y := v_1.Args[0]
  1648			if x != v_1.Args[1] {
  1649				break
  1650			}
  1651			v.reset(OpMul32)
  1652			v.AddArg(x)
  1653			v0 := b.NewValue0(v.Pos, OpAdd32, t)
  1654			v0.AddArg(y)
  1655			v0.AddArg(z)
  1656			v.AddArg(v0)
  1657			return true
  1658		}
  1659		// match: (Add32 <t> (Mul32 z x) (Mul32 y x))
  1660		// cond:
  1661		// result: (Mul32 x (Add32 <t> y z))
  1662		for {
  1663			t := v.Type
  1664			_ = v.Args[1]
  1665			v_0 := v.Args[0]
  1666			if v_0.Op != OpMul32 {
  1667				break
  1668			}
  1669			x := v_0.Args[1]
  1670			z := v_0.Args[0]
  1671			v_1 := v.Args[1]
  1672			if v_1.Op != OpMul32 {
  1673				break
  1674			}
  1675			_ = v_1.Args[1]
  1676			y := v_1.Args[0]
  1677			if x != v_1.Args[1] {
  1678				break
  1679			}
  1680			v.reset(OpMul32)
  1681			v.AddArg(x)
  1682			v0 := b.NewValue0(v.Pos, OpAdd32, t)
  1683			v0.AddArg(y)
  1684			v0.AddArg(z)
  1685			v.AddArg(v0)
  1686			return true
  1687		}
  1688		return false
  1689	}
  1690	func rewriteValuegeneric_OpAdd32_10(v *Value) bool {
  1691		b := v.Block
  1692		// match: (Add32 (Const32 [0]) x)
  1693		// cond:
  1694		// result: x
  1695		for {
  1696			x := v.Args[1]
  1697			v_0 := v.Args[0]
  1698			if v_0.Op != OpConst32 {
  1699				break
  1700			}
  1701			if v_0.AuxInt != 0 {
  1702				break
  1703			}
  1704			v.reset(OpCopy)
  1705			v.Type = x.Type
  1706			v.AddArg(x)
  1707			return true
  1708		}
  1709		// match: (Add32 x (Const32 [0]))
  1710		// cond:
  1711		// result: x
  1712		for {
  1713			_ = v.Args[1]
  1714			x := v.Args[0]
  1715			v_1 := v.Args[1]
  1716			if v_1.Op != OpConst32 {
  1717				break
  1718			}
  1719			if v_1.AuxInt != 0 {
  1720				break
  1721			}
  1722			v.reset(OpCopy)
  1723			v.Type = x.Type
  1724			v.AddArg(x)
  1725			return true
  1726		}
  1727		// match: (Add32 (Const32 [1]) (Com32 x))
  1728		// cond:
  1729		// result: (Neg32 x)
  1730		for {
  1731			_ = v.Args[1]
  1732			v_0 := v.Args[0]
  1733			if v_0.Op != OpConst32 {
  1734				break
  1735			}
  1736			if v_0.AuxInt != 1 {
  1737				break
  1738			}
  1739			v_1 := v.Args[1]
  1740			if v_1.Op != OpCom32 {
  1741				break
  1742			}
  1743			x := v_1.Args[0]
  1744			v.reset(OpNeg32)
  1745			v.AddArg(x)
  1746			return true
  1747		}
  1748		// match: (Add32 (Com32 x) (Const32 [1]))
  1749		// cond:
  1750		// result: (Neg32 x)
  1751		for {
  1752			_ = v.Args[1]
  1753			v_0 := v.Args[0]
  1754			if v_0.Op != OpCom32 {
  1755				break
  1756			}
  1757			x := v_0.Args[0]
  1758			v_1 := v.Args[1]
  1759			if v_1.Op != OpConst32 {
  1760				break
  1761			}
  1762			if v_1.AuxInt != 1 {
  1763				break
  1764			}
  1765			v.reset(OpNeg32)
  1766			v.AddArg(x)
  1767			return true
  1768		}
  1769		// match: (Add32 (Add32 i:(Const32 <t>) z) x)
  1770		// cond: (z.Op != OpConst32 && x.Op != OpConst32)
  1771		// result: (Add32 i (Add32 <t> z x))
  1772		for {
  1773			x := v.Args[1]
  1774			v_0 := v.Args[0]
  1775			if v_0.Op != OpAdd32 {
  1776				break
  1777			}
  1778			z := v_0.Args[1]
  1779			i := v_0.Args[0]
  1780			if i.Op != OpConst32 {
  1781				break
  1782			}
  1783			t := i.Type
  1784			if !(z.Op != OpConst32 && x.Op != OpConst32) {
  1785				break
  1786			}
  1787			v.reset(OpAdd32)
  1788			v.AddArg(i)
  1789			v0 := b.NewValue0(v.Pos, OpAdd32, t)
  1790			v0.AddArg(z)
  1791			v0.AddArg(x)
  1792			v.AddArg(v0)
  1793			return true
  1794		}
  1795		// match: (Add32 (Add32 z i:(Const32 <t>)) x)
  1796		// cond: (z.Op != OpConst32 && x.Op != OpConst32)
  1797		// result: (Add32 i (Add32 <t> z x))
  1798		for {
  1799			x := v.Args[1]
  1800			v_0 := v.Args[0]
  1801			if v_0.Op != OpAdd32 {
  1802				break
  1803			}
  1804			_ = v_0.Args[1]
  1805			z := v_0.Args[0]
  1806			i := v_0.Args[1]
  1807			if i.Op != OpConst32 {
  1808				break
  1809			}
  1810			t := i.Type
  1811			if !(z.Op != OpConst32 && x.Op != OpConst32) {
  1812				break
  1813			}
  1814			v.reset(OpAdd32)
  1815			v.AddArg(i)
  1816			v0 := b.NewValue0(v.Pos, OpAdd32, t)
  1817			v0.AddArg(z)
  1818			v0.AddArg(x)
  1819			v.AddArg(v0)
  1820			return true
  1821		}
  1822		// match: (Add32 x (Add32 i:(Const32 <t>) z))
  1823		// cond: (z.Op != OpConst32 && x.Op != OpConst32)
  1824		// result: (Add32 i (Add32 <t> z x))
  1825		for {
  1826			_ = v.Args[1]
  1827			x := v.Args[0]
  1828			v_1 := v.Args[1]
  1829			if v_1.Op != OpAdd32 {
  1830				break
  1831			}
  1832			z := v_1.Args[1]
  1833			i := v_1.Args[0]
  1834			if i.Op != OpConst32 {
  1835				break
  1836			}
  1837			t := i.Type
  1838			if !(z.Op != OpConst32 && x.Op != OpConst32) {
  1839				break
  1840			}
  1841			v.reset(OpAdd32)
  1842			v.AddArg(i)
  1843			v0 := b.NewValue0(v.Pos, OpAdd32, t)
  1844			v0.AddArg(z)
  1845			v0.AddArg(x)
  1846			v.AddArg(v0)
  1847			return true
  1848		}
  1849		// match: (Add32 x (Add32 z i:(Const32 <t>)))
  1850		// cond: (z.Op != OpConst32 && x.Op != OpConst32)
  1851		// result: (Add32 i (Add32 <t> z x))
  1852		for {
  1853			_ = v.Args[1]
  1854			x := v.Args[0]
  1855			v_1 := v.Args[1]
  1856			if v_1.Op != OpAdd32 {
  1857				break
  1858			}
  1859			_ = v_1.Args[1]
  1860			z := v_1.Args[0]
  1861			i := v_1.Args[1]
  1862			if i.Op != OpConst32 {
  1863				break
  1864			}
  1865			t := i.Type
  1866			if !(z.Op != OpConst32 && x.Op != OpConst32) {
  1867				break
  1868			}
  1869			v.reset(OpAdd32)
  1870			v.AddArg(i)
  1871			v0 := b.NewValue0(v.Pos, OpAdd32, t)
  1872			v0.AddArg(z)
  1873			v0.AddArg(x)
  1874			v.AddArg(v0)
  1875			return true
  1876		}
  1877		// match: (Add32 (Sub32 i:(Const32 <t>) z) x)
  1878		// cond: (z.Op != OpConst32 && x.Op != OpConst32)
  1879		// result: (Add32 i (Sub32 <t> x z))
  1880		for {
  1881			x := v.Args[1]
  1882			v_0 := v.Args[0]
  1883			if v_0.Op != OpSub32 {
  1884				break
  1885			}
  1886			z := v_0.Args[1]
  1887			i := v_0.Args[0]
  1888			if i.Op != OpConst32 {
  1889				break
  1890			}
  1891			t := i.Type
  1892			if !(z.Op != OpConst32 && x.Op != OpConst32) {
  1893				break
  1894			}
  1895			v.reset(OpAdd32)
  1896			v.AddArg(i)
  1897			v0 := b.NewValue0(v.Pos, OpSub32, t)
  1898			v0.AddArg(x)
  1899			v0.AddArg(z)
  1900			v.AddArg(v0)
  1901			return true
  1902		}
  1903		// match: (Add32 x (Sub32 i:(Const32 <t>) z))
  1904		// cond: (z.Op != OpConst32 && x.Op != OpConst32)
  1905		// result: (Add32 i (Sub32 <t> x z))
  1906		for {
  1907			_ = v.Args[1]
  1908			x := v.Args[0]
  1909			v_1 := v.Args[1]
  1910			if v_1.Op != OpSub32 {
  1911				break
  1912			}
  1913			z := v_1.Args[1]
  1914			i := v_1.Args[0]
  1915			if i.Op != OpConst32 {
  1916				break
  1917			}
  1918			t := i.Type
  1919			if !(z.Op != OpConst32 && x.Op != OpConst32) {
  1920				break
  1921			}
  1922			v.reset(OpAdd32)
  1923			v.AddArg(i)
  1924			v0 := b.NewValue0(v.Pos, OpSub32, t)
  1925			v0.AddArg(x)
  1926			v0.AddArg(z)
  1927			v.AddArg(v0)
  1928			return true
  1929		}
  1930		return false
  1931	}
  1932	func rewriteValuegeneric_OpAdd32_20(v *Value) bool {
  1933		b := v.Block
  1934		// match: (Add32 x (Sub32 i:(Const32 <t>) z))
  1935		// cond: (z.Op != OpConst32 && x.Op != OpConst32)
  1936		// result: (Add32 i (Sub32 <t> x z))
  1937		for {
  1938			_ = v.Args[1]
  1939			x := v.Args[0]
  1940			v_1 := v.Args[1]
  1941			if v_1.Op != OpSub32 {
  1942				break
  1943			}
  1944			z := v_1.Args[1]
  1945			i := v_1.Args[0]
  1946			if i.Op != OpConst32 {
  1947				break
  1948			}
  1949			t := i.Type
  1950			if !(z.Op != OpConst32 && x.Op != OpConst32) {
  1951				break
  1952			}
  1953			v.reset(OpAdd32)
  1954			v.AddArg(i)
  1955			v0 := b.NewValue0(v.Pos, OpSub32, t)
  1956			v0.AddArg(x)
  1957			v0.AddArg(z)
  1958			v.AddArg(v0)
  1959			return true
  1960		}
  1961		// match: (Add32 (Sub32 i:(Const32 <t>) z) x)
  1962		// cond: (z.Op != OpConst32 && x.Op != OpConst32)
  1963		// result: (Add32 i (Sub32 <t> x z))
  1964		for {
  1965			x := v.Args[1]
  1966			v_0 := v.Args[0]
  1967			if v_0.Op != OpSub32 {
  1968				break
  1969			}
  1970			z := v_0.Args[1]
  1971			i := v_0.Args[0]
  1972			if i.Op != OpConst32 {
  1973				break
  1974			}
  1975			t := i.Type
  1976			if !(z.Op != OpConst32 && x.Op != OpConst32) {
  1977				break
  1978			}
  1979			v.reset(OpAdd32)
  1980			v.AddArg(i)
  1981			v0 := b.NewValue0(v.Pos, OpSub32, t)
  1982			v0.AddArg(x)
  1983			v0.AddArg(z)
  1984			v.AddArg(v0)
  1985			return true
  1986		}
  1987		// match: (Add32 (Sub32 z i:(Const32 <t>)) x)
  1988		// cond: (z.Op != OpConst32 && x.Op != OpConst32)
  1989		// result: (Sub32 (Add32 <t> x z) i)
  1990		for {
  1991			x := v.Args[1]
  1992			v_0 := v.Args[0]
  1993			if v_0.Op != OpSub32 {
  1994				break
  1995			}
  1996			_ = v_0.Args[1]
  1997			z := v_0.Args[0]
  1998			i := v_0.Args[1]
  1999			if i.Op != OpConst32 {
  2000				break
  2001			}
  2002			t := i.Type
  2003			if !(z.Op != OpConst32 && x.Op != OpConst32) {
  2004				break
  2005			}
  2006			v.reset(OpSub32)
  2007			v0 := b.NewValue0(v.Pos, OpAdd32, t)
  2008			v0.AddArg(x)
  2009			v0.AddArg(z)
  2010			v.AddArg(v0)
  2011			v.AddArg(i)
  2012			return true
  2013		}
  2014		// match: (Add32 x (Sub32 z i:(Const32 <t>)))
  2015		// cond: (z.Op != OpConst32 && x.Op != OpConst32)
  2016		// result: (Sub32 (Add32 <t> x z) i)
  2017		for {
  2018			_ = v.Args[1]
  2019			x := v.Args[0]
  2020			v_1 := v.Args[1]
  2021			if v_1.Op != OpSub32 {
  2022				break
  2023			}
  2024			_ = v_1.Args[1]
  2025			z := v_1.Args[0]
  2026			i := v_1.Args[1]
  2027			if i.Op != OpConst32 {
  2028				break
  2029			}
  2030			t := i.Type
  2031			if !(z.Op != OpConst32 && x.Op != OpConst32) {
  2032				break
  2033			}
  2034			v.reset(OpSub32)
  2035			v0 := b.NewValue0(v.Pos, OpAdd32, t)
  2036			v0.AddArg(x)
  2037			v0.AddArg(z)
  2038			v.AddArg(v0)
  2039			v.AddArg(i)
  2040			return true
  2041		}
  2042		// match: (Add32 x (Sub32 z i:(Const32 <t>)))
  2043		// cond: (z.Op != OpConst32 && x.Op != OpConst32)
  2044		// result: (Sub32 (Add32 <t> x z) i)
  2045		for {
  2046			_ = v.Args[1]
  2047			x := v.Args[0]
  2048			v_1 := v.Args[1]
  2049			if v_1.Op != OpSub32 {
  2050				break
  2051			}
  2052			_ = v_1.Args[1]
  2053			z := v_1.Args[0]
  2054			i := v_1.Args[1]
  2055			if i.Op != OpConst32 {
  2056				break
  2057			}
  2058			t := i.Type
  2059			if !(z.Op != OpConst32 && x.Op != OpConst32) {
  2060				break
  2061			}
  2062			v.reset(OpSub32)
  2063			v0 := b.NewValue0(v.Pos, OpAdd32, t)
  2064			v0.AddArg(x)
  2065			v0.AddArg(z)
  2066			v.AddArg(v0)
  2067			v.AddArg(i)
  2068			return true
  2069		}
  2070		// match: (Add32 (Sub32 z i:(Const32 <t>)) x)
  2071		// cond: (z.Op != OpConst32 && x.Op != OpConst32)
  2072		// result: (Sub32 (Add32 <t> x z) i)
  2073		for {
  2074			x := v.Args[1]
  2075			v_0 := v.Args[0]
  2076			if v_0.Op != OpSub32 {
  2077				break
  2078			}
  2079			_ = v_0.Args[1]
  2080			z := v_0.Args[0]
  2081			i := v_0.Args[1]
  2082			if i.Op != OpConst32 {
  2083				break
  2084			}
  2085			t := i.Type
  2086			if !(z.Op != OpConst32 && x.Op != OpConst32) {
  2087				break
  2088			}
  2089			v.reset(OpSub32)
  2090			v0 := b.NewValue0(v.Pos, OpAdd32, t)
  2091			v0.AddArg(x)
  2092			v0.AddArg(z)
  2093			v.AddArg(v0)
  2094			v.AddArg(i)
  2095			return true
  2096		}
  2097		// match: (Add32 (Const32 <t> [c]) (Add32 (Const32 <t> [d]) x))
  2098		// cond:
  2099		// result: (Add32 (Const32 <t> [int64(int32(c+d))]) x)
  2100		for {
  2101			_ = v.Args[1]
  2102			v_0 := v.Args[0]
  2103			if v_0.Op != OpConst32 {
  2104				break
  2105			}
  2106			t := v_0.Type
  2107			c := v_0.AuxInt
  2108			v_1 := v.Args[1]
  2109			if v_1.Op != OpAdd32 {
  2110				break
  2111			}
  2112			x := v_1.Args[1]
  2113			v_1_0 := v_1.Args[0]
  2114			if v_1_0.Op != OpConst32 {
  2115				break
  2116			}
  2117			if v_1_0.Type != t {
  2118				break
  2119			}
  2120			d := v_1_0.AuxInt
  2121			v.reset(OpAdd32)
  2122			v0 := b.NewValue0(v.Pos, OpConst32, t)
  2123			v0.AuxInt = int64(int32(c + d))
  2124			v.AddArg(v0)
  2125			v.AddArg(x)
  2126			return true
  2127		}
  2128		// match: (Add32 (Const32 <t> [c]) (Add32 x (Const32 <t> [d])))
  2129		// cond:
  2130		// result: (Add32 (Const32 <t> [int64(int32(c+d))]) x)
  2131		for {
  2132			_ = v.Args[1]
  2133			v_0 := v.Args[0]
  2134			if v_0.Op != OpConst32 {
  2135				break
  2136			}
  2137			t := v_0.Type
  2138			c := v_0.AuxInt
  2139			v_1 := v.Args[1]
  2140			if v_1.Op != OpAdd32 {
  2141				break
  2142			}
  2143			_ = v_1.Args[1]
  2144			x := v_1.Args[0]
  2145			v_1_1 := v_1.Args[1]
  2146			if v_1_1.Op != OpConst32 {
  2147				break
  2148			}
  2149			if v_1_1.Type != t {
  2150				break
  2151			}
  2152			d := v_1_1.AuxInt
  2153			v.reset(OpAdd32)
  2154			v0 := b.NewValue0(v.Pos, OpConst32, t)
  2155			v0.AuxInt = int64(int32(c + d))
  2156			v.AddArg(v0)
  2157			v.AddArg(x)
  2158			return true
  2159		}
  2160		// match: (Add32 (Add32 (Const32 <t> [d]) x) (Const32 <t> [c]))
  2161		// cond:
  2162		// result: (Add32 (Const32 <t> [int64(int32(c+d))]) x)
  2163		for {
  2164			_ = v.Args[1]
  2165			v_0 := v.Args[0]
  2166			if v_0.Op != OpAdd32 {
  2167				break
  2168			}
  2169			x := v_0.Args[1]
  2170			v_0_0 := v_0.Args[0]
  2171			if v_0_0.Op != OpConst32 {
  2172				break
  2173			}
  2174			t := v_0_0.Type
  2175			d := v_0_0.AuxInt
  2176			v_1 := v.Args[1]
  2177			if v_1.Op != OpConst32 {
  2178				break
  2179			}
  2180			if v_1.Type != t {
  2181				break
  2182			}
  2183			c := v_1.AuxInt
  2184			v.reset(OpAdd32)
  2185			v0 := b.NewValue0(v.Pos, OpConst32, t)
  2186			v0.AuxInt = int64(int32(c + d))
  2187			v.AddArg(v0)
  2188			v.AddArg(x)
  2189			return true
  2190		}
  2191		// match: (Add32 (Add32 x (Const32 <t> [d])) (Const32 <t> [c]))
  2192		// cond:
  2193		// result: (Add32 (Const32 <t> [int64(int32(c+d))]) x)
  2194		for {
  2195			_ = v.Args[1]
  2196			v_0 := v.Args[0]
  2197			if v_0.Op != OpAdd32 {
  2198				break
  2199			}
  2200			_ = v_0.Args[1]
  2201			x := v_0.Args[0]
  2202			v_0_1 := v_0.Args[1]
  2203			if v_0_1.Op != OpConst32 {
  2204				break
  2205			}
  2206			t := v_0_1.Type
  2207			d := v_0_1.AuxInt
  2208			v_1 := v.Args[1]
  2209			if v_1.Op != OpConst32 {
  2210				break
  2211			}
  2212			if v_1.Type != t {
  2213				break
  2214			}
  2215			c := v_1.AuxInt
  2216			v.reset(OpAdd32)
  2217			v0 := b.NewValue0(v.Pos, OpConst32, t)
  2218			v0.AuxInt = int64(int32(c + d))
  2219			v.AddArg(v0)
  2220			v.AddArg(x)
  2221			return true
  2222		}
  2223		return false
  2224	}
  2225	func rewriteValuegeneric_OpAdd32_30(v *Value) bool {
  2226		b := v.Block
  2227		// match: (Add32 (Const32 <t> [c]) (Sub32 (Const32 <t> [d]) x))
  2228		// cond:
  2229		// result: (Sub32 (Const32 <t> [int64(int32(c+d))]) x)
  2230		for {
  2231			_ = v.Args[1]
  2232			v_0 := v.Args[0]
  2233			if v_0.Op != OpConst32 {
  2234				break
  2235			}
  2236			t := v_0.Type
  2237			c := v_0.AuxInt
  2238			v_1 := v.Args[1]
  2239			if v_1.Op != OpSub32 {
  2240				break
  2241			}
  2242			x := v_1.Args[1]
  2243			v_1_0 := v_1.Args[0]
  2244			if v_1_0.Op != OpConst32 {
  2245				break
  2246			}
  2247			if v_1_0.Type != t {
  2248				break
  2249			}
  2250			d := v_1_0.AuxInt
  2251			v.reset(OpSub32)
  2252			v0 := b.NewValue0(v.Pos, OpConst32, t)
  2253			v0.AuxInt = int64(int32(c + d))
  2254			v.AddArg(v0)
  2255			v.AddArg(x)
  2256			return true
  2257		}
  2258		// match: (Add32 (Sub32 (Const32 <t> [d]) x) (Const32 <t> [c]))
  2259		// cond:
  2260		// result: (Sub32 (Const32 <t> [int64(int32(c+d))]) x)
  2261		for {
  2262			_ = v.Args[1]
  2263			v_0 := v.Args[0]
  2264			if v_0.Op != OpSub32 {
  2265				break
  2266			}
  2267			x := v_0.Args[1]
  2268			v_0_0 := v_0.Args[0]
  2269			if v_0_0.Op != OpConst32 {
  2270				break
  2271			}
  2272			t := v_0_0.Type
  2273			d := v_0_0.AuxInt
  2274			v_1 := v.Args[1]
  2275			if v_1.Op != OpConst32 {
  2276				break
  2277			}
  2278			if v_1.Type != t {
  2279				break
  2280			}
  2281			c := v_1.AuxInt
  2282			v.reset(OpSub32)
  2283			v0 := b.NewValue0(v.Pos, OpConst32, t)
  2284			v0.AuxInt = int64(int32(c + d))
  2285			v.AddArg(v0)
  2286			v.AddArg(x)
  2287			return true
  2288		}
  2289		// match: (Add32 (Const32 <t> [c]) (Sub32 x (Const32 <t> [d])))
  2290		// cond:
  2291		// result: (Add32 (Const32 <t> [int64(int32(c-d))]) x)
  2292		for {
  2293			_ = v.Args[1]
  2294			v_0 := v.Args[0]
  2295			if v_0.Op != OpConst32 {
  2296				break
  2297			}
  2298			t := v_0.Type
  2299			c := v_0.AuxInt
  2300			v_1 := v.Args[1]
  2301			if v_1.Op != OpSub32 {
  2302				break
  2303			}
  2304			_ = v_1.Args[1]
  2305			x := v_1.Args[0]
  2306			v_1_1 := v_1.Args[1]
  2307			if v_1_1.Op != OpConst32 {
  2308				break
  2309			}
  2310			if v_1_1.Type != t {
  2311				break
  2312			}
  2313			d := v_1_1.AuxInt
  2314			v.reset(OpAdd32)
  2315			v0 := b.NewValue0(v.Pos, OpConst32, t)
  2316			v0.AuxInt = int64(int32(c - d))
  2317			v.AddArg(v0)
  2318			v.AddArg(x)
  2319			return true
  2320		}
  2321		// match: (Add32 (Sub32 x (Const32 <t> [d])) (Const32 <t> [c]))
  2322		// cond:
  2323		// result: (Add32 (Const32 <t> [int64(int32(c-d))]) x)
  2324		for {
  2325			_ = v.Args[1]
  2326			v_0 := v.Args[0]
  2327			if v_0.Op != OpSub32 {
  2328				break
  2329			}
  2330			_ = v_0.Args[1]
  2331			x := v_0.Args[0]
  2332			v_0_1 := v_0.Args[1]
  2333			if v_0_1.Op != OpConst32 {
  2334				break
  2335			}
  2336			t := v_0_1.Type
  2337			d := v_0_1.AuxInt
  2338			v_1 := v.Args[1]
  2339			if v_1.Op != OpConst32 {
  2340				break
  2341			}
  2342			if v_1.Type != t {
  2343				break
  2344			}
  2345			c := v_1.AuxInt
  2346			v.reset(OpAdd32)
  2347			v0 := b.NewValue0(v.Pos, OpConst32, t)
  2348			v0.AuxInt = int64(int32(c - d))
  2349			v.AddArg(v0)
  2350			v.AddArg(x)
  2351			return true
  2352		}
  2353		return false
  2354	}
  2355	func rewriteValuegeneric_OpAdd32F_0(v *Value) bool {
  2356		// match: (Add32F (Const32F [c]) (Const32F [d]))
  2357		// cond:
  2358		// result: (Const32F [auxFrom32F(auxTo32F(c) + auxTo32F(d))])
  2359		for {
  2360			_ = v.Args[1]
  2361			v_0 := v.Args[0]
  2362			if v_0.Op != OpConst32F {
  2363				break
  2364			}
  2365			c := v_0.AuxInt
  2366			v_1 := v.Args[1]
  2367			if v_1.Op != OpConst32F {
  2368				break
  2369			}
  2370			d := v_1.AuxInt
  2371			v.reset(OpConst32F)
  2372			v.AuxInt = auxFrom32F(auxTo32F(c) + auxTo32F(d))
  2373			return true
  2374		}
  2375		// match: (Add32F (Const32F [d]) (Const32F [c]))
  2376		// cond:
  2377		// result: (Const32F [auxFrom32F(auxTo32F(c) + auxTo32F(d))])
  2378		for {
  2379			_ = v.Args[1]
  2380			v_0 := v.Args[0]
  2381			if v_0.Op != OpConst32F {
  2382				break
  2383			}
  2384			d := v_0.AuxInt
  2385			v_1 := v.Args[1]
  2386			if v_1.Op != OpConst32F {
  2387				break
  2388			}
  2389			c := v_1.AuxInt
  2390			v.reset(OpConst32F)
  2391			v.AuxInt = auxFrom32F(auxTo32F(c) + auxTo32F(d))
  2392			return true
  2393		}
  2394		return false
  2395	}
  2396	func rewriteValuegeneric_OpAdd64_0(v *Value) bool {
  2397		b := v.Block
  2398		// match: (Add64 (Const64 [c]) (Const64 [d]))
  2399		// cond:
  2400		// result: (Const64 [c+d])
  2401		for {
  2402			_ = v.Args[1]
  2403			v_0 := v.Args[0]
  2404			if v_0.Op != OpConst64 {
  2405				break
  2406			}
  2407			c := v_0.AuxInt
  2408			v_1 := v.Args[1]
  2409			if v_1.Op != OpConst64 {
  2410				break
  2411			}
  2412			d := v_1.AuxInt
  2413			v.reset(OpConst64)
  2414			v.AuxInt = c + d
  2415			return true
  2416		}
  2417		// match: (Add64 (Const64 [d]) (Const64 [c]))
  2418		// cond:
  2419		// result: (Const64 [c+d])
  2420		for {
  2421			_ = v.Args[1]
  2422			v_0 := v.Args[0]
  2423			if v_0.Op != OpConst64 {
  2424				break
  2425			}
  2426			d := v_0.AuxInt
  2427			v_1 := v.Args[1]
  2428			if v_1.Op != OpConst64 {
  2429				break
  2430			}
  2431			c := v_1.AuxInt
  2432			v.reset(OpConst64)
  2433			v.AuxInt = c + d
  2434			return true
  2435		}
  2436		// match: (Add64 <t> (Mul64 x y) (Mul64 x z))
  2437		// cond:
  2438		// result: (Mul64 x (Add64 <t> y z))
  2439		for {
  2440			t := v.Type
  2441			_ = v.Args[1]
  2442			v_0 := v.Args[0]
  2443			if v_0.Op != OpMul64 {
  2444				break
  2445			}
  2446			y := v_0.Args[1]
  2447			x := v_0.Args[0]
  2448			v_1 := v.Args[1]
  2449			if v_1.Op != OpMul64 {
  2450				break
  2451			}
  2452			z := v_1.Args[1]
  2453			if x != v_1.Args[0] {
  2454				break
  2455			}
  2456			v.reset(OpMul64)
  2457			v.AddArg(x)
  2458			v0 := b.NewValue0(v.Pos, OpAdd64, t)
  2459			v0.AddArg(y)
  2460			v0.AddArg(z)
  2461			v.AddArg(v0)
  2462			return true
  2463		}
  2464		// match: (Add64 <t> (Mul64 y x) (Mul64 x z))
  2465		// cond:
  2466		// result: (Mul64 x (Add64 <t> y z))
  2467		for {
  2468			t := v.Type
  2469			_ = v.Args[1]
  2470			v_0 := v.Args[0]
  2471			if v_0.Op != OpMul64 {
  2472				break
  2473			}
  2474			x := v_0.Args[1]
  2475			y := v_0.Args[0]
  2476			v_1 := v.Args[1]
  2477			if v_1.Op != OpMul64 {
  2478				break
  2479			}
  2480			z := v_1.Args[1]
  2481			if x != v_1.Args[0] {
  2482				break
  2483			}
  2484			v.reset(OpMul64)
  2485			v.AddArg(x)
  2486			v0 := b.NewValue0(v.Pos, OpAdd64, t)
  2487			v0.AddArg(y)
  2488			v0.AddArg(z)
  2489			v.AddArg(v0)
  2490			return true
  2491		}
  2492		// match: (Add64 <t> (Mul64 x y) (Mul64 z x))
  2493		// cond:
  2494		// result: (Mul64 x (Add64 <t> y z))
  2495		for {
  2496			t := v.Type
  2497			_ = v.Args[1]
  2498			v_0 := v.Args[0]
  2499			if v_0.Op != OpMul64 {
  2500				break
  2501			}
  2502			y := v_0.Args[1]
  2503			x := v_0.Args[0]
  2504			v_1 := v.Args[1]
  2505			if v_1.Op != OpMul64 {
  2506				break
  2507			}
  2508			_ = v_1.Args[1]
  2509			z := v_1.Args[0]
  2510			if x != v_1.Args[1] {
  2511				break
  2512			}
  2513			v.reset(OpMul64)
  2514			v.AddArg(x)
  2515			v0 := b.NewValue0(v.Pos, OpAdd64, t)
  2516			v0.AddArg(y)
  2517			v0.AddArg(z)
  2518			v.AddArg(v0)
  2519			return true
  2520		}
  2521		// match: (Add64 <t> (Mul64 y x) (Mul64 z x))
  2522		// cond:
  2523		// result: (Mul64 x (Add64 <t> y z))
  2524		for {
  2525			t := v.Type
  2526			_ = v.Args[1]
  2527			v_0 := v.Args[0]
  2528			if v_0.Op != OpMul64 {
  2529				break
  2530			}
  2531			x := v_0.Args[1]
  2532			y := v_0.Args[0]
  2533			v_1 := v.Args[1]
  2534			if v_1.Op != OpMul64 {
  2535				break
  2536			}
  2537			_ = v_1.Args[1]
  2538			z := v_1.Args[0]
  2539			if x != v_1.Args[1] {
  2540				break
  2541			}
  2542			v.reset(OpMul64)
  2543			v.AddArg(x)
  2544			v0 := b.NewValue0(v.Pos, OpAdd64, t)
  2545			v0.AddArg(y)
  2546			v0.AddArg(z)
  2547			v.AddArg(v0)
  2548			return true
  2549		}
  2550		// match: (Add64 <t> (Mul64 x z) (Mul64 x y))
  2551		// cond:
  2552		// result: (Mul64 x (Add64 <t> y z))
  2553		for {
  2554			t := v.Type
  2555			_ = v.Args[1]
  2556			v_0 := v.Args[0]
  2557			if v_0.Op != OpMul64 {
  2558				break
  2559			}
  2560			z := v_0.Args[1]
  2561			x := v_0.Args[0]
  2562			v_1 := v.Args[1]
  2563			if v_1.Op != OpMul64 {
  2564				break
  2565			}
  2566			y := v_1.Args[1]
  2567			if x != v_1.Args[0] {
  2568				break
  2569			}
  2570			v.reset(OpMul64)
  2571			v.AddArg(x)
  2572			v0 := b.NewValue0(v.Pos, OpAdd64, t)
  2573			v0.AddArg(y)
  2574			v0.AddArg(z)
  2575			v.AddArg(v0)
  2576			return true
  2577		}
  2578		// match: (Add64 <t> (Mul64 z x) (Mul64 x y))
  2579		// cond:
  2580		// result: (Mul64 x (Add64 <t> y z))
  2581		for {
  2582			t := v.Type
  2583			_ = v.Args[1]
  2584			v_0 := v.Args[0]
  2585			if v_0.Op != OpMul64 {
  2586				break
  2587			}
  2588			x := v_0.Args[1]
  2589			z := v_0.Args[0]
  2590			v_1 := v.Args[1]
  2591			if v_1.Op != OpMul64 {
  2592				break
  2593			}
  2594			y := v_1.Args[1]
  2595			if x != v_1.Args[0] {
  2596				break
  2597			}
  2598			v.reset(OpMul64)
  2599			v.AddArg(x)
  2600			v0 := b.NewValue0(v.Pos, OpAdd64, t)
  2601			v0.AddArg(y)
  2602			v0.AddArg(z)
  2603			v.AddArg(v0)
  2604			return true
  2605		}
  2606		// match: (Add64 <t> (Mul64 x z) (Mul64 y x))
  2607		// cond:
  2608		// result: (Mul64 x (Add64 <t> y z))
  2609		for {
  2610			t := v.Type
  2611			_ = v.Args[1]
  2612			v_0 := v.Args[0]
  2613			if v_0.Op != OpMul64 {
  2614				break
  2615			}
  2616			z := v_0.Args[1]
  2617			x := v_0.Args[0]
  2618			v_1 := v.Args[1]
  2619			if v_1.Op != OpMul64 {
  2620				break
  2621			}
  2622			_ = v_1.Args[1]
  2623			y := v_1.Args[0]
  2624			if x != v_1.Args[1] {
  2625				break
  2626			}
  2627			v.reset(OpMul64)
  2628			v.AddArg(x)
  2629			v0 := b.NewValue0(v.Pos, OpAdd64, t)
  2630			v0.AddArg(y)
  2631			v0.AddArg(z)
  2632			v.AddArg(v0)
  2633			return true
  2634		}
  2635		// match: (Add64 <t> (Mul64 z x) (Mul64 y x))
  2636		// cond:
  2637		// result: (Mul64 x (Add64 <t> y z))
  2638		for {
  2639			t := v.Type
  2640			_ = v.Args[1]
  2641			v_0 := v.Args[0]
  2642			if v_0.Op != OpMul64 {
  2643				break
  2644			}
  2645			x := v_0.Args[1]
  2646			z := v_0.Args[0]
  2647			v_1 := v.Args[1]
  2648			if v_1.Op != OpMul64 {
  2649				break
  2650			}
  2651			_ = v_1.Args[1]
  2652			y := v_1.Args[0]
  2653			if x != v_1.Args[1] {
  2654				break
  2655			}
  2656			v.reset(OpMul64)
  2657			v.AddArg(x)
  2658			v0 := b.NewValue0(v.Pos, OpAdd64, t)
  2659			v0.AddArg(y)
  2660			v0.AddArg(z)
  2661			v.AddArg(v0)
  2662			return true
  2663		}
  2664		return false
  2665	}
  2666	func rewriteValuegeneric_OpAdd64_10(v *Value) bool {
  2667		b := v.Block
  2668		// match: (Add64 (Const64 [0]) x)
  2669		// cond:
  2670		// result: x
  2671		for {
  2672			x := v.Args[1]
  2673			v_0 := v.Args[0]
  2674			if v_0.Op != OpConst64 {
  2675				break
  2676			}
  2677			if v_0.AuxInt != 0 {
  2678				break
  2679			}
  2680			v.reset(OpCopy)
  2681			v.Type = x.Type
  2682			v.AddArg(x)
  2683			return true
  2684		}
  2685		// match: (Add64 x (Const64 [0]))
  2686		// cond:
  2687		// result: x
  2688		for {
  2689			_ = v.Args[1]
  2690			x := v.Args[0]
  2691			v_1 := v.Args[1]
  2692			if v_1.Op != OpConst64 {
  2693				break
  2694			}
  2695			if v_1.AuxInt != 0 {
  2696				break
  2697			}
  2698			v.reset(OpCopy)
  2699			v.Type = x.Type
  2700			v.AddArg(x)
  2701			return true
  2702		}
  2703		// match: (Add64 (Const64 [1]) (Com64 x))
  2704		// cond:
  2705		// result: (Neg64 x)
  2706		for {
  2707			_ = v.Args[1]
  2708			v_0 := v.Args[0]
  2709			if v_0.Op != OpConst64 {
  2710				break
  2711			}
  2712			if v_0.AuxInt != 1 {
  2713				break
  2714			}
  2715			v_1 := v.Args[1]
  2716			if v_1.Op != OpCom64 {
  2717				break
  2718			}
  2719			x := v_1.Args[0]
  2720			v.reset(OpNeg64)
  2721			v.AddArg(x)
  2722			return true
  2723		}
  2724		// match: (Add64 (Com64 x) (Const64 [1]))
  2725		// cond:
  2726		// result: (Neg64 x)
  2727		for {
  2728			_ = v.Args[1]
  2729			v_0 := v.Args[0]
  2730			if v_0.Op != OpCom64 {
  2731				break
  2732			}
  2733			x := v_0.Args[0]
  2734			v_1 := v.Args[1]
  2735			if v_1.Op != OpConst64 {
  2736				break
  2737			}
  2738			if v_1.AuxInt != 1 {
  2739				break
  2740			}
  2741			v.reset(OpNeg64)
  2742			v.AddArg(x)
  2743			return true
  2744		}
  2745		// match: (Add64 (Add64 i:(Const64 <t>) z) x)
  2746		// cond: (z.Op != OpConst64 && x.Op != OpConst64)
  2747		// result: (Add64 i (Add64 <t> z x))
  2748		for {
  2749			x := v.Args[1]
  2750			v_0 := v.Args[0]
  2751			if v_0.Op != OpAdd64 {
  2752				break
  2753			}
  2754			z := v_0.Args[1]
  2755			i := v_0.Args[0]
  2756			if i.Op != OpConst64 {
  2757				break
  2758			}
  2759			t := i.Type
  2760			if !(z.Op != OpConst64 && x.Op != OpConst64) {
  2761				break
  2762			}
  2763			v.reset(OpAdd64)
  2764			v.AddArg(i)
  2765			v0 := b.NewValue0(v.Pos, OpAdd64, t)
  2766			v0.AddArg(z)
  2767			v0.AddArg(x)
  2768			v.AddArg(v0)
  2769			return true
  2770		}
  2771		// match: (Add64 (Add64 z i:(Const64 <t>)) x)
  2772		// cond: (z.Op != OpConst64 && x.Op != OpConst64)
  2773		// result: (Add64 i (Add64 <t> z x))
  2774		for {
  2775			x := v.Args[1]
  2776			v_0 := v.Args[0]
  2777			if v_0.Op != OpAdd64 {
  2778				break
  2779			}
  2780			_ = v_0.Args[1]
  2781			z := v_0.Args[0]
  2782			i := v_0.Args[1]
  2783			if i.Op != OpConst64 {
  2784				break
  2785			}
  2786			t := i.Type
  2787			if !(z.Op != OpConst64 && x.Op != OpConst64) {
  2788				break
  2789			}
  2790			v.reset(OpAdd64)
  2791			v.AddArg(i)
  2792			v0 := b.NewValue0(v.Pos, OpAdd64, t)
  2793			v0.AddArg(z)
  2794			v0.AddArg(x)
  2795			v.AddArg(v0)
  2796			return true
  2797		}
  2798		// match: (Add64 x (Add64 i:(Const64 <t>) z))
  2799		// cond: (z.Op != OpConst64 && x.Op != OpConst64)
  2800		// result: (Add64 i (Add64 <t> z x))
  2801		for {
  2802			_ = v.Args[1]
  2803			x := v.Args[0]
  2804			v_1 := v.Args[1]
  2805			if v_1.Op != OpAdd64 {
  2806				break
  2807			}
  2808			z := v_1.Args[1]
  2809			i := v_1.Args[0]
  2810			if i.Op != OpConst64 {
  2811				break
  2812			}
  2813			t := i.Type
  2814			if !(z.Op != OpConst64 && x.Op != OpConst64) {
  2815				break
  2816			}
  2817			v.reset(OpAdd64)
  2818			v.AddArg(i)
  2819			v0 := b.NewValue0(v.Pos, OpAdd64, t)
  2820			v0.AddArg(z)
  2821			v0.AddArg(x)
  2822			v.AddArg(v0)
  2823			return true
  2824		}
  2825		// match: (Add64 x (Add64 z i:(Const64 <t>)))
  2826		// cond: (z.Op != OpConst64 && x.Op != OpConst64)
  2827		// result: (Add64 i (Add64 <t> z x))
  2828		for {
  2829			_ = v.Args[1]
  2830			x := v.Args[0]
  2831			v_1 := v.Args[1]
  2832			if v_1.Op != OpAdd64 {
  2833				break
  2834			}
  2835			_ = v_1.Args[1]
  2836			z := v_1.Args[0]
  2837			i := v_1.Args[1]
  2838			if i.Op != OpConst64 {
  2839				break
  2840			}
  2841			t := i.Type
  2842			if !(z.Op != OpConst64 && x.Op != OpConst64) {
  2843				break
  2844			}
  2845			v.reset(OpAdd64)
  2846			v.AddArg(i)
  2847			v0 := b.NewValue0(v.Pos, OpAdd64, t)
  2848			v0.AddArg(z)
  2849			v0.AddArg(x)
  2850			v.AddArg(v0)
  2851			return true
  2852		}
  2853		// match: (Add64 (Sub64 i:(Const64 <t>) z) x)
  2854		// cond: (z.Op != OpConst64 && x.Op != OpConst64)
  2855		// result: (Add64 i (Sub64 <t> x z))
  2856		for {
  2857			x := v.Args[1]
  2858			v_0 := v.Args[0]
  2859			if v_0.Op != OpSub64 {
  2860				break
  2861			}
  2862			z := v_0.Args[1]
  2863			i := v_0.Args[0]
  2864			if i.Op != OpConst64 {
  2865				break
  2866			}
  2867			t := i.Type
  2868			if !(z.Op != OpConst64 && x.Op != OpConst64) {
  2869				break
  2870			}
  2871			v.reset(OpAdd64)
  2872			v.AddArg(i)
  2873			v0 := b.NewValue0(v.Pos, OpSub64, t)
  2874			v0.AddArg(x)
  2875			v0.AddArg(z)
  2876			v.AddArg(v0)
  2877			return true
  2878		}
  2879		// match: (Add64 x (Sub64 i:(Const64 <t>) z))
  2880		// cond: (z.Op != OpConst64 && x.Op != OpConst64)
  2881		// result: (Add64 i (Sub64 <t> x z))
  2882		for {
  2883			_ = v.Args[1]
  2884			x := v.Args[0]
  2885			v_1 := v.Args[1]
  2886			if v_1.Op != OpSub64 {
  2887				break
  2888			}
  2889			z := v_1.Args[1]
  2890			i := v_1.Args[0]
  2891			if i.Op != OpConst64 {
  2892				break
  2893			}
  2894			t := i.Type
  2895			if !(z.Op != OpConst64 && x.Op != OpConst64) {
  2896				break
  2897			}
  2898			v.reset(OpAdd64)
  2899			v.AddArg(i)
  2900			v0 := b.NewValue0(v.Pos, OpSub64, t)
  2901			v0.AddArg(x)
  2902			v0.AddArg(z)
  2903			v.AddArg(v0)
  2904			return true
  2905		}
  2906		return false
  2907	}
  2908	func rewriteValuegeneric_OpAdd64_20(v *Value) bool {
  2909		b := v.Block
  2910		// match: (Add64 x (Sub64 i:(Const64 <t>) z))
  2911		// cond: (z.Op != OpConst64 && x.Op != OpConst64)
  2912		// result: (Add64 i (Sub64 <t> x z))
  2913		for {
  2914			_ = v.Args[1]
  2915			x := v.Args[0]
  2916			v_1 := v.Args[1]
  2917			if v_1.Op != OpSub64 {
  2918				break
  2919			}
  2920			z := v_1.Args[1]
  2921			i := v_1.Args[0]
  2922			if i.Op != OpConst64 {
  2923				break
  2924			}
  2925			t := i.Type
  2926			if !(z.Op != OpConst64 && x.Op != OpConst64) {
  2927				break
  2928			}
  2929			v.reset(OpAdd64)
  2930			v.AddArg(i)
  2931			v0 := b.NewValue0(v.Pos, OpSub64, t)
  2932			v0.AddArg(x)
  2933			v0.AddArg(z)
  2934			v.AddArg(v0)
  2935			return true
  2936		}
  2937		// match: (Add64 (Sub64 i:(Const64 <t>) z) x)
  2938		// cond: (z.Op != OpConst64 && x.Op != OpConst64)
  2939		// result: (Add64 i (Sub64 <t> x z))
  2940		for {
  2941			x := v.Args[1]
  2942			v_0 := v.Args[0]
  2943			if v_0.Op != OpSub64 {
  2944				break
  2945			}
  2946			z := v_0.Args[1]
  2947			i := v_0.Args[0]
  2948			if i.Op != OpConst64 {
  2949				break
  2950			}
  2951			t := i.Type
  2952			if !(z.Op != OpConst64 && x.Op != OpConst64) {
  2953				break
  2954			}
  2955			v.reset(OpAdd64)
  2956			v.AddArg(i)
  2957			v0 := b.NewValue0(v.Pos, OpSub64, t)
  2958			v0.AddArg(x)
  2959			v0.AddArg(z)
  2960			v.AddArg(v0)
  2961			return true
  2962		}
  2963		// match: (Add64 (Sub64 z i:(Const64 <t>)) x)
  2964		// cond: (z.Op != OpConst64 && x.Op != OpConst64)
  2965		// result: (Sub64 (Add64 <t> x z) i)
  2966		for {
  2967			x := v.Args[1]
  2968			v_0 := v.Args[0]
  2969			if v_0.Op != OpSub64 {
  2970				break
  2971			}
  2972			_ = v_0.Args[1]
  2973			z := v_0.Args[0]
  2974			i := v_0.Args[1]
  2975			if i.Op != OpConst64 {
  2976				break
  2977			}
  2978			t := i.Type
  2979			if !(z.Op != OpConst64 && x.Op != OpConst64) {
  2980				break
  2981			}
  2982			v.reset(OpSub64)
  2983			v0 := b.NewValue0(v.Pos, OpAdd64, t)
  2984			v0.AddArg(x)
  2985			v0.AddArg(z)
  2986			v.AddArg(v0)
  2987			v.AddArg(i)
  2988			return true
  2989		}
  2990		// match: (Add64 x (Sub64 z i:(Const64 <t>)))
  2991		// cond: (z.Op != OpConst64 && x.Op != OpConst64)
  2992		// result: (Sub64 (Add64 <t> x z) i)
  2993		for {
  2994			_ = v.Args[1]
  2995			x := v.Args[0]
  2996			v_1 := v.Args[1]
  2997			if v_1.Op != OpSub64 {
  2998				break
  2999			}
  3000			_ = v_1.Args[1]
  3001			z := v_1.Args[0]
  3002			i := v_1.Args[1]
  3003			if i.Op != OpConst64 {
  3004				break
  3005			}
  3006			t := i.Type
  3007			if !(z.Op != OpConst64 && x.Op != OpConst64) {
  3008				break
  3009			}
  3010			v.reset(OpSub64)
  3011			v0 := b.NewValue0(v.Pos, OpAdd64, t)
  3012			v0.AddArg(x)
  3013			v0.AddArg(z)
  3014			v.AddArg(v0)
  3015			v.AddArg(i)
  3016			return true
  3017		}
  3018		// match: (Add64 x (Sub64 z i:(Const64 <t>)))
  3019		// cond: (z.Op != OpConst64 && x.Op != OpConst64)
  3020		// result: (Sub64 (Add64 <t> x z) i)
  3021		for {
  3022			_ = v.Args[1]
  3023			x := v.Args[0]
  3024			v_1 := v.Args[1]
  3025			if v_1.Op != OpSub64 {
  3026				break
  3027			}
  3028			_ = v_1.Args[1]
  3029			z := v_1.Args[0]
  3030			i := v_1.Args[1]
  3031			if i.Op != OpConst64 {
  3032				break
  3033			}
  3034			t := i.Type
  3035			if !(z.Op != OpConst64 && x.Op != OpConst64) {
  3036				break
  3037			}
  3038			v.reset(OpSub64)
  3039			v0 := b.NewValue0(v.Pos, OpAdd64, t)
  3040			v0.AddArg(x)
  3041			v0.AddArg(z)
  3042			v.AddArg(v0)
  3043			v.AddArg(i)
  3044			return true
  3045		}
  3046		// match: (Add64 (Sub64 z i:(Const64 <t>)) x)
  3047		// cond: (z.Op != OpConst64 && x.Op != OpConst64)
  3048		// result: (Sub64 (Add64 <t> x z) i)
  3049		for {
  3050			x := v.Args[1]
  3051			v_0 := v.Args[0]
  3052			if v_0.Op != OpSub64 {
  3053				break
  3054			}
  3055			_ = v_0.Args[1]
  3056			z := v_0.Args[0]
  3057			i := v_0.Args[1]
  3058			if i.Op != OpConst64 {
  3059				break
  3060			}
  3061			t := i.Type
  3062			if !(z.Op != OpConst64 && x.Op != OpConst64) {
  3063				break
  3064			}
  3065			v.reset(OpSub64)
  3066			v0 := b.NewValue0(v.Pos, OpAdd64, t)
  3067			v0.AddArg(x)
  3068			v0.AddArg(z)
  3069			v.AddArg(v0)
  3070			v.AddArg(i)
  3071			return true
  3072		}
  3073		// match: (Add64 (Const64 <t> [c]) (Add64 (Const64 <t> [d]) x))
  3074		// cond:
  3075		// result: (Add64 (Const64 <t> [c+d]) x)
  3076		for {
  3077			_ = v.Args[1]
  3078			v_0 := v.Args[0]
  3079			if v_0.Op != OpConst64 {
  3080				break
  3081			}
  3082			t := v_0.Type
  3083			c := v_0.AuxInt
  3084			v_1 := v.Args[1]
  3085			if v_1.Op != OpAdd64 {
  3086				break
  3087			}
  3088			x := v_1.Args[1]
  3089			v_1_0 := v_1.Args[0]
  3090			if v_1_0.Op != OpConst64 {
  3091				break
  3092			}
  3093			if v_1_0.Type != t {
  3094				break
  3095			}
  3096			d := v_1_0.AuxInt
  3097			v.reset(OpAdd64)
  3098			v0 := b.NewValue0(v.Pos, OpConst64, t)
  3099			v0.AuxInt = c + d
  3100			v.AddArg(v0)
  3101			v.AddArg(x)
  3102			return true
  3103		}
  3104		// match: (Add64 (Const64 <t> [c]) (Add64 x (Const64 <t> [d])))
  3105		// cond:
  3106		// result: (Add64 (Const64 <t> [c+d]) x)
  3107		for {
  3108			_ = v.Args[1]
  3109			v_0 := v.Args[0]
  3110			if v_0.Op != OpConst64 {
  3111				break
  3112			}
  3113			t := v_0.Type
  3114			c := v_0.AuxInt
  3115			v_1 := v.Args[1]
  3116			if v_1.Op != OpAdd64 {
  3117				break
  3118			}
  3119			_ = v_1.Args[1]
  3120			x := v_1.Args[0]
  3121			v_1_1 := v_1.Args[1]
  3122			if v_1_1.Op != OpConst64 {
  3123				break
  3124			}
  3125			if v_1_1.Type != t {
  3126				break
  3127			}
  3128			d := v_1_1.AuxInt
  3129			v.reset(OpAdd64)
  3130			v0 := b.NewValue0(v.Pos, OpConst64, t)
  3131			v0.AuxInt = c + d
  3132			v.AddArg(v0)
  3133			v.AddArg(x)
  3134			return true
  3135		}
  3136		// match: (Add64 (Add64 (Const64 <t> [d]) x) (Const64 <t> [c]))
  3137		// cond:
  3138		// result: (Add64 (Const64 <t> [c+d]) x)
  3139		for {
  3140			_ = v.Args[1]
  3141			v_0 := v.Args[0]
  3142			if v_0.Op != OpAdd64 {
  3143				break
  3144			}
  3145			x := v_0.Args[1]
  3146			v_0_0 := v_0.Args[0]
  3147			if v_0_0.Op != OpConst64 {
  3148				break
  3149			}
  3150			t := v_0_0.Type
  3151			d := v_0_0.AuxInt
  3152			v_1 := v.Args[1]
  3153			if v_1.Op != OpConst64 {
  3154				break
  3155			}
  3156			if v_1.Type != t {
  3157				break
  3158			}
  3159			c := v_1.AuxInt
  3160			v.reset(OpAdd64)
  3161			v0 := b.NewValue0(v.Pos, OpConst64, t)
  3162			v0.AuxInt = c + d
  3163			v.AddArg(v0)
  3164			v.AddArg(x)
  3165			return true
  3166		}
  3167		// match: (Add64 (Add64 x (Const64 <t> [d])) (Const64 <t> [c]))
  3168		// cond:
  3169		// result: (Add64 (Const64 <t> [c+d]) x)
  3170		for {
  3171			_ = v.Args[1]
  3172			v_0 := v.Args[0]
  3173			if v_0.Op != OpAdd64 {
  3174				break
  3175			}
  3176			_ = v_0.Args[1]
  3177			x := v_0.Args[0]
  3178			v_0_1 := v_0.Args[1]
  3179			if v_0_1.Op != OpConst64 {
  3180				break
  3181			}
  3182			t := v_0_1.Type
  3183			d := v_0_1.AuxInt
  3184			v_1 := v.Args[1]
  3185			if v_1.Op != OpConst64 {
  3186				break
  3187			}
  3188			if v_1.Type != t {
  3189				break
  3190			}
  3191			c := v_1.AuxInt
  3192			v.reset(OpAdd64)
  3193			v0 := b.NewValue0(v.Pos, OpConst64, t)
  3194			v0.AuxInt = c + d
  3195			v.AddArg(v0)
  3196			v.AddArg(x)
  3197			return true
  3198		}
  3199		return false
  3200	}
  3201	func rewriteValuegeneric_OpAdd64_30(v *Value) bool {
  3202		b := v.Block
  3203		// match: (Add64 (Const64 <t> [c]) (Sub64 (Const64 <t> [d]) x))
  3204		// cond:
  3205		// result: (Sub64 (Const64 <t> [c+d]) x)
  3206		for {
  3207			_ = v.Args[1]
  3208			v_0 := v.Args[0]
  3209			if v_0.Op != OpConst64 {
  3210				break
  3211			}
  3212			t := v_0.Type
  3213			c := v_0.AuxInt
  3214			v_1 := v.Args[1]
  3215			if v_1.Op != OpSub64 {
  3216				break
  3217			}
  3218			x := v_1.Args[1]
  3219			v_1_0 := v_1.Args[0]
  3220			if v_1_0.Op != OpConst64 {
  3221				break
  3222			}
  3223			if v_1_0.Type != t {
  3224				break
  3225			}
  3226			d := v_1_0.AuxInt
  3227			v.reset(OpSub64)
  3228			v0 := b.NewValue0(v.Pos, OpConst64, t)
  3229			v0.AuxInt = c + d
  3230			v.AddArg(v0)
  3231			v.AddArg(x)
  3232			return true
  3233		}
  3234		// match: (Add64 (Sub64 (Const64 <t> [d]) x) (Const64 <t> [c]))
  3235		// cond:
  3236		// result: (Sub64 (Const64 <t> [c+d]) x)
  3237		for {
  3238			_ = v.Args[1]
  3239			v_0 := v.Args[0]
  3240			if v_0.Op != OpSub64 {
  3241				break
  3242			}
  3243			x := v_0.Args[1]
  3244			v_0_0 := v_0.Args[0]
  3245			if v_0_0.Op != OpConst64 {
  3246				break
  3247			}
  3248			t := v_0_0.Type
  3249			d := v_0_0.AuxInt
  3250			v_1 := v.Args[1]
  3251			if v_1.Op != OpConst64 {
  3252				break
  3253			}
  3254			if v_1.Type != t {
  3255				break
  3256			}
  3257			c := v_1.AuxInt
  3258			v.reset(OpSub64)
  3259			v0 := b.NewValue0(v.Pos, OpConst64, t)
  3260			v0.AuxInt = c + d
  3261			v.AddArg(v0)
  3262			v.AddArg(x)
  3263			return true
  3264		}
  3265		// match: (Add64 (Const64 <t> [c]) (Sub64 x (Const64 <t> [d])))
  3266		// cond:
  3267		// result: (Add64 (Const64 <t> [c-d]) x)
  3268		for {
  3269			_ = v.Args[1]
  3270			v_0 := v.Args[0]
  3271			if v_0.Op != OpConst64 {
  3272				break
  3273			}
  3274			t := v_0.Type
  3275			c := v_0.AuxInt
  3276			v_1 := v.Args[1]
  3277			if v_1.Op != OpSub64 {
  3278				break
  3279			}
  3280			_ = v_1.Args[1]
  3281			x := v_1.Args[0]
  3282			v_1_1 := v_1.Args[1]
  3283			if v_1_1.Op != OpConst64 {
  3284				break
  3285			}
  3286			if v_1_1.Type != t {
  3287				break
  3288			}
  3289			d := v_1_1.AuxInt
  3290			v.reset(OpAdd64)
  3291			v0 := b.NewValue0(v.Pos, OpConst64, t)
  3292			v0.AuxInt = c - d
  3293			v.AddArg(v0)
  3294			v.AddArg(x)
  3295			return true
  3296		}
  3297		// match: (Add64 (Sub64 x (Const64 <t> [d])) (Const64 <t> [c]))
  3298		// cond:
  3299		// result: (Add64 (Const64 <t> [c-d]) x)
  3300		for {
  3301			_ = v.Args[1]
  3302			v_0 := v.Args[0]
  3303			if v_0.Op != OpSub64 {
  3304				break
  3305			}
  3306			_ = v_0.Args[1]
  3307			x := v_0.Args[0]
  3308			v_0_1 := v_0.Args[1]
  3309			if v_0_1.Op != OpConst64 {
  3310				break
  3311			}
  3312			t := v_0_1.Type
  3313			d := v_0_1.AuxInt
  3314			v_1 := v.Args[1]
  3315			if v_1.Op != OpConst64 {
  3316				break
  3317			}
  3318			if v_1.Type != t {
  3319				break
  3320			}
  3321			c := v_1.AuxInt
  3322			v.reset(OpAdd64)
  3323			v0 := b.NewValue0(v.Pos, OpConst64, t)
  3324			v0.AuxInt = c - d
  3325			v.AddArg(v0)
  3326			v.AddArg(x)
  3327			return true
  3328		}
  3329		return false
  3330	}
  3331	func rewriteValuegeneric_OpAdd64F_0(v *Value) bool {
  3332		// match: (Add64F (Const64F [c]) (Const64F [d]))
  3333		// cond:
  3334		// result: (Const64F [auxFrom64F(auxTo64F(c) + auxTo64F(d))])
  3335		for {
  3336			_ = v.Args[1]
  3337			v_0 := v.Args[0]
  3338			if v_0.Op != OpConst64F {
  3339				break
  3340			}
  3341			c := v_0.AuxInt
  3342			v_1 := v.Args[1]
  3343			if v_1.Op != OpConst64F {
  3344				break
  3345			}
  3346			d := v_1.AuxInt
  3347			v.reset(OpConst64F)
  3348			v.AuxInt = auxFrom64F(auxTo64F(c) + auxTo64F(d))
  3349			return true
  3350		}
  3351		// match: (Add64F (Const64F [d]) (Const64F [c]))
  3352		// cond:
  3353		// result: (Const64F [auxFrom64F(auxTo64F(c) + auxTo64F(d))])
  3354		for {
  3355			_ = v.Args[1]
  3356			v_0 := v.Args[0]
  3357			if v_0.Op != OpConst64F {
  3358				break
  3359			}
  3360			d := v_0.AuxInt
  3361			v_1 := v.Args[1]
  3362			if v_1.Op != OpConst64F {
  3363				break
  3364			}
  3365			c := v_1.AuxInt
  3366			v.reset(OpConst64F)
  3367			v.AuxInt = auxFrom64F(auxTo64F(c) + auxTo64F(d))
  3368			return true
  3369		}
  3370		return false
  3371	}
  3372	func rewriteValuegeneric_OpAdd8_0(v *Value) bool {
  3373		b := v.Block
  3374		// match: (Add8 (Const8 [c]) (Const8 [d]))
  3375		// cond:
  3376		// result: (Const8 [int64(int8(c+d))])
  3377		for {
  3378			_ = v.Args[1]
  3379			v_0 := v.Args[0]
  3380			if v_0.Op != OpConst8 {
  3381				break
  3382			}
  3383			c := v_0.AuxInt
  3384			v_1 := v.Args[1]
  3385			if v_1.Op != OpConst8 {
  3386				break
  3387			}
  3388			d := v_1.AuxInt
  3389			v.reset(OpConst8)
  3390			v.AuxInt = int64(int8(c + d))
  3391			return true
  3392		}
  3393		// match: (Add8 (Const8 [d]) (Const8 [c]))
  3394		// cond:
  3395		// result: (Const8 [int64(int8(c+d))])
  3396		for {
  3397			_ = v.Args[1]
  3398			v_0 := v.Args[0]
  3399			if v_0.Op != OpConst8 {
  3400				break
  3401			}
  3402			d := v_0.AuxInt
  3403			v_1 := v.Args[1]
  3404			if v_1.Op != OpConst8 {
  3405				break
  3406			}
  3407			c := v_1.AuxInt
  3408			v.reset(OpConst8)
  3409			v.AuxInt = int64(int8(c + d))
  3410			return true
  3411		}
  3412		// match: (Add8 <t> (Mul8 x y) (Mul8 x z))
  3413		// cond:
  3414		// result: (Mul8 x (Add8 <t> y z))
  3415		for {
  3416			t := v.Type
  3417			_ = v.Args[1]
  3418			v_0 := v.Args[0]
  3419			if v_0.Op != OpMul8 {
  3420				break
  3421			}
  3422			y := v_0.Args[1]
  3423			x := v_0.Args[0]
  3424			v_1 := v.Args[1]
  3425			if v_1.Op != OpMul8 {
  3426				break
  3427			}
  3428			z := v_1.Args[1]
  3429			if x != v_1.Args[0] {
  3430				break
  3431			}
  3432			v.reset(OpMul8)
  3433			v.AddArg(x)
  3434			v0 := b.NewValue0(v.Pos, OpAdd8, t)
  3435			v0.AddArg(y)
  3436			v0.AddArg(z)
  3437			v.AddArg(v0)
  3438			return true
  3439		}
  3440		// match: (Add8 <t> (Mul8 y x) (Mul8 x z))
  3441		// cond:
  3442		// result: (Mul8 x (Add8 <t> y z))
  3443		for {
  3444			t := v.Type
  3445			_ = v.Args[1]
  3446			v_0 := v.Args[0]
  3447			if v_0.Op != OpMul8 {
  3448				break
  3449			}
  3450			x := v_0.Args[1]
  3451			y := v_0.Args[0]
  3452			v_1 := v.Args[1]
  3453			if v_1.Op != OpMul8 {
  3454				break
  3455			}
  3456			z := v_1.Args[1]
  3457			if x != v_1.Args[0] {
  3458				break
  3459			}
  3460			v.reset(OpMul8)
  3461			v.AddArg(x)
  3462			v0 := b.NewValue0(v.Pos, OpAdd8, t)
  3463			v0.AddArg(y)
  3464			v0.AddArg(z)
  3465			v.AddArg(v0)
  3466			return true
  3467		}
  3468		// match: (Add8 <t> (Mul8 x y) (Mul8 z x))
  3469		// cond:
  3470		// result: (Mul8 x (Add8 <t> y z))
  3471		for {
  3472			t := v.Type
  3473			_ = v.Args[1]
  3474			v_0 := v.Args[0]
  3475			if v_0.Op != OpMul8 {
  3476				break
  3477			}
  3478			y := v_0.Args[1]
  3479			x := v_0.Args[0]
  3480			v_1 := v.Args[1]
  3481			if v_1.Op != OpMul8 {
  3482				break
  3483			}
  3484			_ = v_1.Args[1]
  3485			z := v_1.Args[0]
  3486			if x != v_1.Args[1] {
  3487				break
  3488			}
  3489			v.reset(OpMul8)
  3490			v.AddArg(x)
  3491			v0 := b.NewValue0(v.Pos, OpAdd8, t)
  3492			v0.AddArg(y)
  3493			v0.AddArg(z)
  3494			v.AddArg(v0)
  3495			return true
  3496		}
  3497		// match: (Add8 <t> (Mul8 y x) (Mul8 z x))
  3498		// cond:
  3499		// result: (Mul8 x (Add8 <t> y z))
  3500		for {
  3501			t := v.Type
  3502			_ = v.Args[1]
  3503			v_0 := v.Args[0]
  3504			if v_0.Op != OpMul8 {
  3505				break
  3506			}
  3507			x := v_0.Args[1]
  3508			y := v_0.Args[0]
  3509			v_1 := v.Args[1]
  3510			if v_1.Op != OpMul8 {
  3511				break
  3512			}
  3513			_ = v_1.Args[1]
  3514			z := v_1.Args[0]
  3515			if x != v_1.Args[1] {
  3516				break
  3517			}
  3518			v.reset(OpMul8)
  3519			v.AddArg(x)
  3520			v0 := b.NewValue0(v.Pos, OpAdd8, t)
  3521			v0.AddArg(y)
  3522			v0.AddArg(z)
  3523			v.AddArg(v0)
  3524			return true
  3525		}
  3526		// match: (Add8 <t> (Mul8 x z) (Mul8 x y))
  3527		// cond:
  3528		// result: (Mul8 x (Add8 <t> y z))
  3529		for {
  3530			t := v.Type
  3531			_ = v.Args[1]
  3532			v_0 := v.Args[0]
  3533			if v_0.Op != OpMul8 {
  3534				break
  3535			}
  3536			z := v_0.Args[1]
  3537			x := v_0.Args[0]
  3538			v_1 := v.Args[1]
  3539			if v_1.Op != OpMul8 {
  3540				break
  3541			}
  3542			y := v_1.Args[1]
  3543			if x != v_1.Args[0] {
  3544				break
  3545			}
  3546			v.reset(OpMul8)
  3547			v.AddArg(x)
  3548			v0 := b.NewValue0(v.Pos, OpAdd8, t)
  3549			v0.AddArg(y)
  3550			v0.AddArg(z)
  3551			v.AddArg(v0)
  3552			return true
  3553		}
  3554		// match: (Add8 <t> (Mul8 z x) (Mul8 x y))
  3555		// cond:
  3556		// result: (Mul8 x (Add8 <t> y z))
  3557		for {
  3558			t := v.Type
  3559			_ = v.Args[1]
  3560			v_0 := v.Args[0]
  3561			if v_0.Op != OpMul8 {
  3562				break
  3563			}
  3564			x := v_0.Args[1]
  3565			z := v_0.Args[0]
  3566			v_1 := v.Args[1]
  3567			if v_1.Op != OpMul8 {
  3568				break
  3569			}
  3570			y := v_1.Args[1]
  3571			if x != v_1.Args[0] {
  3572				break
  3573			}
  3574			v.reset(OpMul8)
  3575			v.AddArg(x)
  3576			v0 := b.NewValue0(v.Pos, OpAdd8, t)
  3577			v0.AddArg(y)
  3578			v0.AddArg(z)
  3579			v.AddArg(v0)
  3580			return true
  3581		}
  3582		// match: (Add8 <t> (Mul8 x z) (Mul8 y x))
  3583		// cond:
  3584		// result: (Mul8 x (Add8 <t> y z))
  3585		for {
  3586			t := v.Type
  3587			_ = v.Args[1]
  3588			v_0 := v.Args[0]
  3589			if v_0.Op != OpMul8 {
  3590				break
  3591			}
  3592			z := v_0.Args[1]
  3593			x := v_0.Args[0]
  3594			v_1 := v.Args[1]
  3595			if v_1.Op != OpMul8 {
  3596				break
  3597			}
  3598			_ = v_1.Args[1]
  3599			y := v_1.Args[0]
  3600			if x != v_1.Args[1] {
  3601				break
  3602			}
  3603			v.reset(OpMul8)
  3604			v.AddArg(x)
  3605			v0 := b.NewValue0(v.Pos, OpAdd8, t)
  3606			v0.AddArg(y)
  3607			v0.AddArg(z)
  3608			v.AddArg(v0)
  3609			return true
  3610		}
  3611		// match: (Add8 <t> (Mul8 z x) (Mul8 y x))
  3612		// cond:
  3613		// result: (Mul8 x (Add8 <t> y z))
  3614		for {
  3615			t := v.Type
  3616			_ = v.Args[1]
  3617			v_0 := v.Args[0]
  3618			if v_0.Op != OpMul8 {
  3619				break
  3620			}
  3621			x := v_0.Args[1]
  3622			z := v_0.Args[0]
  3623			v_1 := v.Args[1]
  3624			if v_1.Op != OpMul8 {
  3625				break
  3626			}
  3627			_ = v_1.Args[1]
  3628			y := v_1.Args[0]
  3629			if x != v_1.Args[1] {
  3630				break
  3631			}
  3632			v.reset(OpMul8)
  3633			v.AddArg(x)
  3634			v0 := b.NewValue0(v.Pos, OpAdd8, t)
  3635			v0.AddArg(y)
  3636			v0.AddArg(z)
  3637			v.AddArg(v0)
  3638			return true
  3639		}
  3640		return false
  3641	}
  3642	func rewriteValuegeneric_OpAdd8_10(v *Value) bool {
  3643		b := v.Block
  3644		// match: (Add8 (Const8 [0]) x)
  3645		// cond:
  3646		// result: x
  3647		for {
  3648			x := v.Args[1]
  3649			v_0 := v.Args[0]
  3650			if v_0.Op != OpConst8 {
  3651				break
  3652			}
  3653			if v_0.AuxInt != 0 {
  3654				break
  3655			}
  3656			v.reset(OpCopy)
  3657			v.Type = x.Type
  3658			v.AddArg(x)
  3659			return true
  3660		}
  3661		// match: (Add8 x (Const8 [0]))
  3662		// cond:
  3663		// result: x
  3664		for {
  3665			_ = v.Args[1]
  3666			x := v.Args[0]
  3667			v_1 := v.Args[1]
  3668			if v_1.Op != OpConst8 {
  3669				break
  3670			}
  3671			if v_1.AuxInt != 0 {
  3672				break
  3673			}
  3674			v.reset(OpCopy)
  3675			v.Type = x.Type
  3676			v.AddArg(x)
  3677			return true
  3678		}
  3679		// match: (Add8 (Const8 [1]) (Com8 x))
  3680		// cond:
  3681		// result: (Neg8 x)
  3682		for {
  3683			_ = v.Args[1]
  3684			v_0 := v.Args[0]
  3685			if v_0.Op != OpConst8 {
  3686				break
  3687			}
  3688			if v_0.AuxInt != 1 {
  3689				break
  3690			}
  3691			v_1 := v.Args[1]
  3692			if v_1.Op != OpCom8 {
  3693				break
  3694			}
  3695			x := v_1.Args[0]
  3696			v.reset(OpNeg8)
  3697			v.AddArg(x)
  3698			return true
  3699		}
  3700		// match: (Add8 (Com8 x) (Const8 [1]))
  3701		// cond:
  3702		// result: (Neg8 x)
  3703		for {
  3704			_ = v.Args[1]
  3705			v_0 := v.Args[0]
  3706			if v_0.Op != OpCom8 {
  3707				break
  3708			}
  3709			x := v_0.Args[0]
  3710			v_1 := v.Args[1]
  3711			if v_1.Op != OpConst8 {
  3712				break
  3713			}
  3714			if v_1.AuxInt != 1 {
  3715				break
  3716			}
  3717			v.reset(OpNeg8)
  3718			v.AddArg(x)
  3719			return true
  3720		}
  3721		// match: (Add8 (Add8 i:(Const8 <t>) z) x)
  3722		// cond: (z.Op != OpConst8 && x.Op != OpConst8)
  3723		// result: (Add8 i (Add8 <t> z x))
  3724		for {
  3725			x := v.Args[1]
  3726			v_0 := v.Args[0]
  3727			if v_0.Op != OpAdd8 {
  3728				break
  3729			}
  3730			z := v_0.Args[1]
  3731			i := v_0.Args[0]
  3732			if i.Op != OpConst8 {
  3733				break
  3734			}
  3735			t := i.Type
  3736			if !(z.Op != OpConst8 && x.Op != OpConst8) {
  3737				break
  3738			}
  3739			v.reset(OpAdd8)
  3740			v.AddArg(i)
  3741			v0 := b.NewValue0(v.Pos, OpAdd8, t)
  3742			v0.AddArg(z)
  3743			v0.AddArg(x)
  3744			v.AddArg(v0)
  3745			return true
  3746		}
  3747		// match: (Add8 (Add8 z i:(Const8 <t>)) x)
  3748		// cond: (z.Op != OpConst8 && x.Op != OpConst8)
  3749		// result: (Add8 i (Add8 <t> z x))
  3750		for {
  3751			x := v.Args[1]
  3752			v_0 := v.Args[0]
  3753			if v_0.Op != OpAdd8 {
  3754				break
  3755			}
  3756			_ = v_0.Args[1]
  3757			z := v_0.Args[0]
  3758			i := v_0.Args[1]
  3759			if i.Op != OpConst8 {
  3760				break
  3761			}
  3762			t := i.Type
  3763			if !(z.Op != OpConst8 && x.Op != OpConst8) {
  3764				break
  3765			}
  3766			v.reset(OpAdd8)
  3767			v.AddArg(i)
  3768			v0 := b.NewValue0(v.Pos, OpAdd8, t)
  3769			v0.AddArg(z)
  3770			v0.AddArg(x)
  3771			v.AddArg(v0)
  3772			return true
  3773		}
  3774		// match: (Add8 x (Add8 i:(Const8 <t>) z))
  3775		// cond: (z.Op != OpConst8 && x.Op != OpConst8)
  3776		// result: (Add8 i (Add8 <t> z x))
  3777		for {
  3778			_ = v.Args[1]
  3779			x := v.Args[0]
  3780			v_1 := v.Args[1]
  3781			if v_1.Op != OpAdd8 {
  3782				break
  3783			}
  3784			z := v_1.Args[1]
  3785			i := v_1.Args[0]
  3786			if i.Op != OpConst8 {
  3787				break
  3788			}
  3789			t := i.Type
  3790			if !(z.Op != OpConst8 && x.Op != OpConst8) {
  3791				break
  3792			}
  3793			v.reset(OpAdd8)
  3794			v.AddArg(i)
  3795			v0 := b.NewValue0(v.Pos, OpAdd8, t)
  3796			v0.AddArg(z)
  3797			v0.AddArg(x)
  3798			v.AddArg(v0)
  3799			return true
  3800		}
  3801		// match: (Add8 x (Add8 z i:(Const8 <t>)))
  3802		// cond: (z.Op != OpConst8 && x.Op != OpConst8)
  3803		// result: (Add8 i (Add8 <t> z x))
  3804		for {
  3805			_ = v.Args[1]
  3806			x := v.Args[0]
  3807			v_1 := v.Args[1]
  3808			if v_1.Op != OpAdd8 {
  3809				break
  3810			}
  3811			_ = v_1.Args[1]
  3812			z := v_1.Args[0]
  3813			i := v_1.Args[1]
  3814			if i.Op != OpConst8 {
  3815				break
  3816			}
  3817			t := i.Type
  3818			if !(z.Op != OpConst8 && x.Op != OpConst8) {
  3819				break
  3820			}
  3821			v.reset(OpAdd8)
  3822			v.AddArg(i)
  3823			v0 := b.NewValue0(v.Pos, OpAdd8, t)
  3824			v0.AddArg(z)
  3825			v0.AddArg(x)
  3826			v.AddArg(v0)
  3827			return true
  3828		}
  3829		// match: (Add8 (Sub8 i:(Const8 <t>) z) x)
  3830		// cond: (z.Op != OpConst8 && x.Op != OpConst8)
  3831		// result: (Add8 i (Sub8 <t> x z))
  3832		for {
  3833			x := v.Args[1]
  3834			v_0 := v.Args[0]
  3835			if v_0.Op != OpSub8 {
  3836				break
  3837			}
  3838			z := v_0.Args[1]
  3839			i := v_0.Args[0]
  3840			if i.Op != OpConst8 {
  3841				break
  3842			}
  3843			t := i.Type
  3844			if !(z.Op != OpConst8 && x.Op != OpConst8) {
  3845				break
  3846			}
  3847			v.reset(OpAdd8)
  3848			v.AddArg(i)
  3849			v0 := b.NewValue0(v.Pos, OpSub8, t)
  3850			v0.AddArg(x)
  3851			v0.AddArg(z)
  3852			v.AddArg(v0)
  3853			return true
  3854		}
  3855		// match: (Add8 x (Sub8 i:(Const8 <t>) z))
  3856		// cond: (z.Op != OpConst8 && x.Op != OpConst8)
  3857		// result: (Add8 i (Sub8 <t> x z))
  3858		for {
  3859			_ = v.Args[1]
  3860			x := v.Args[0]
  3861			v_1 := v.Args[1]
  3862			if v_1.Op != OpSub8 {
  3863				break
  3864			}
  3865			z := v_1.Args[1]
  3866			i := v_1.Args[0]
  3867			if i.Op != OpConst8 {
  3868				break
  3869			}
  3870			t := i.Type
  3871			if !(z.Op != OpConst8 && x.Op != OpConst8) {
  3872				break
  3873			}
  3874			v.reset(OpAdd8)
  3875			v.AddArg(i)
  3876			v0 := b.NewValue0(v.Pos, OpSub8, t)
  3877			v0.AddArg(x)
  3878			v0.AddArg(z)
  3879			v.AddArg(v0)
  3880			return true
  3881		}
  3882		return false
  3883	}
  3884	func rewriteValuegeneric_OpAdd8_20(v *Value) bool {
  3885		b := v.Block
  3886		// match: (Add8 x (Sub8 i:(Const8 <t>) z))
  3887		// cond: (z.Op != OpConst8 && x.Op != OpConst8)
  3888		// result: (Add8 i (Sub8 <t> x z))
  3889		for {
  3890			_ = v.Args[1]
  3891			x := v.Args[0]
  3892			v_1 := v.Args[1]
  3893			if v_1.Op != OpSub8 {
  3894				break
  3895			}
  3896			z := v_1.Args[1]
  3897			i := v_1.Args[0]
  3898			if i.Op != OpConst8 {
  3899				break
  3900			}
  3901			t := i.Type
  3902			if !(z.Op != OpConst8 && x.Op != OpConst8) {
  3903				break
  3904			}
  3905			v.reset(OpAdd8)
  3906			v.AddArg(i)
  3907			v0 := b.NewValue0(v.Pos, OpSub8, t)
  3908			v0.AddArg(x)
  3909			v0.AddArg(z)
  3910			v.AddArg(v0)
  3911			return true
  3912		}
  3913		// match: (Add8 (Sub8 i:(Const8 <t>) z) x)
  3914		// cond: (z.Op != OpConst8 && x.Op != OpConst8)
  3915		// result: (Add8 i (Sub8 <t> x z))
  3916		for {
  3917			x := v.Args[1]
  3918			v_0 := v.Args[0]
  3919			if v_0.Op != OpSub8 {
  3920				break
  3921			}
  3922			z := v_0.Args[1]
  3923			i := v_0.Args[0]
  3924			if i.Op != OpConst8 {
  3925				break
  3926			}
  3927			t := i.Type
  3928			if !(z.Op != OpConst8 && x.Op != OpConst8) {
  3929				break
  3930			}
  3931			v.reset(OpAdd8)
  3932			v.AddArg(i)
  3933			v0 := b.NewValue0(v.Pos, OpSub8, t)
  3934			v0.AddArg(x)
  3935			v0.AddArg(z)
  3936			v.AddArg(v0)
  3937			return true
  3938		}
  3939		// match: (Add8 (Sub8 z i:(Const8 <t>)) x)
  3940		// cond: (z.Op != OpConst8 && x.Op != OpConst8)
  3941		// result: (Sub8 (Add8 <t> x z) i)
  3942		for {
  3943			x := v.Args[1]
  3944			v_0 := v.Args[0]
  3945			if v_0.Op != OpSub8 {
  3946				break
  3947			}
  3948			_ = v_0.Args[1]
  3949			z := v_0.Args[0]
  3950			i := v_0.Args[1]
  3951			if i.Op != OpConst8 {
  3952				break
  3953			}
  3954			t := i.Type
  3955			if !(z.Op != OpConst8 && x.Op != OpConst8) {
  3956				break
  3957			}
  3958			v.reset(OpSub8)
  3959			v0 := b.NewValue0(v.Pos, OpAdd8, t)
  3960			v0.AddArg(x)
  3961			v0.AddArg(z)
  3962			v.AddArg(v0)
  3963			v.AddArg(i)
  3964			return true
  3965		}
  3966		// match: (Add8 x (Sub8 z i:(Const8 <t>)))
  3967		// cond: (z.Op != OpConst8 && x.Op != OpConst8)
  3968		// result: (Sub8 (Add8 <t> x z) i)
  3969		for {
  3970			_ = v.Args[1]
  3971			x := v.Args[0]
  3972			v_1 := v.Args[1]
  3973			if v_1.Op != OpSub8 {
  3974				break
  3975			}
  3976			_ = v_1.Args[1]
  3977			z := v_1.Args[0]
  3978			i := v_1.Args[1]
  3979			if i.Op != OpConst8 {
  3980				break
  3981			}
  3982			t := i.Type
  3983			if !(z.Op != OpConst8 && x.Op != OpConst8) {
  3984				break
  3985			}
  3986			v.reset(OpSub8)
  3987			v0 := b.NewValue0(v.Pos, OpAdd8, t)
  3988			v0.AddArg(x)
  3989			v0.AddArg(z)
  3990			v.AddArg(v0)
  3991			v.AddArg(i)
  3992			return true
  3993		}
  3994		// match: (Add8 x (Sub8 z i:(Const8 <t>)))
  3995		// cond: (z.Op != OpConst8 && x.Op != OpConst8)
  3996		// result: (Sub8 (Add8 <t> x z) i)
  3997		for {
  3998			_ = v.Args[1]
  3999			x := v.Args[0]
  4000			v_1 := v.Args[1]
  4001			if v_1.Op != OpSub8 {
  4002				break
  4003			}
  4004			_ = v_1.Args[1]
  4005			z := v_1.Args[0]
  4006			i := v_1.Args[1]
  4007			if i.Op != OpConst8 {
  4008				break
  4009			}
  4010			t := i.Type
  4011			if !(z.Op != OpConst8 && x.Op != OpConst8) {
  4012				break
  4013			}
  4014			v.reset(OpSub8)
  4015			v0 := b.NewValue0(v.Pos, OpAdd8, t)
  4016			v0.AddArg(x)
  4017			v0.AddArg(z)
  4018			v.AddArg(v0)
  4019			v.AddArg(i)
  4020			return true
  4021		}
  4022		// match: (Add8 (Sub8 z i:(Const8 <t>)) x)
  4023		// cond: (z.Op != OpConst8 && x.Op != OpConst8)
  4024		// result: (Sub8 (Add8 <t> x z) i)
  4025		for {
  4026			x := v.Args[1]
  4027			v_0 := v.Args[0]
  4028			if v_0.Op != OpSub8 {
  4029				break
  4030			}
  4031			_ = v_0.Args[1]
  4032			z := v_0.Args[0]
  4033			i := v_0.Args[1]
  4034			if i.Op != OpConst8 {
  4035				break
  4036			}
  4037			t := i.Type
  4038			if !(z.Op != OpConst8 && x.Op != OpConst8) {
  4039				break
  4040			}
  4041			v.reset(OpSub8)
  4042			v0 := b.NewValue0(v.Pos, OpAdd8, t)
  4043			v0.AddArg(x)
  4044			v0.AddArg(z)
  4045			v.AddArg(v0)
  4046			v.AddArg(i)
  4047			return true
  4048		}
  4049		// match: (Add8 (Const8 <t> [c]) (Add8 (Const8 <t> [d]) x))
  4050		// cond:
  4051		// result: (Add8 (Const8 <t> [int64(int8(c+d))]) x)
  4052		for {
  4053			_ = v.Args[1]
  4054			v_0 := v.Args[0]
  4055			if v_0.Op != OpConst8 {
  4056				break
  4057			}
  4058			t := v_0.Type
  4059			c := v_0.AuxInt
  4060			v_1 := v.Args[1]
  4061			if v_1.Op != OpAdd8 {
  4062				break
  4063			}
  4064			x := v_1.Args[1]
  4065			v_1_0 := v_1.Args[0]
  4066			if v_1_0.Op != OpConst8 {
  4067				break
  4068			}
  4069			if v_1_0.Type != t {
  4070				break
  4071			}
  4072			d := v_1_0.AuxInt
  4073			v.reset(OpAdd8)
  4074			v0 := b.NewValue0(v.Pos, OpConst8, t)
  4075			v0.AuxInt = int64(int8(c + d))
  4076			v.AddArg(v0)
  4077			v.AddArg(x)
  4078			return true
  4079		}
  4080		// match: (Add8 (Const8 <t> [c]) (Add8 x (Const8 <t> [d])))
  4081		// cond:
  4082		// result: (Add8 (Const8 <t> [int64(int8(c+d))]) x)
  4083		for {
  4084			_ = v.Args[1]
  4085			v_0 := v.Args[0]
  4086			if v_0.Op != OpConst8 {
  4087				break
  4088			}
  4089			t := v_0.Type
  4090			c := v_0.AuxInt
  4091			v_1 := v.Args[1]
  4092			if v_1.Op != OpAdd8 {
  4093				break
  4094			}
  4095			_ = v_1.Args[1]
  4096			x := v_1.Args[0]
  4097			v_1_1 := v_1.Args[1]
  4098			if v_1_1.Op != OpConst8 {
  4099				break
  4100			}
  4101			if v_1_1.Type != t {
  4102				break
  4103			}
  4104			d := v_1_1.AuxInt
  4105			v.reset(OpAdd8)
  4106			v0 := b.NewValue0(v.Pos, OpConst8, t)
  4107			v0.AuxInt = int64(int8(c + d))
  4108			v.AddArg(v0)
  4109			v.AddArg(x)
  4110			return true
  4111		}
  4112		// match: (Add8 (Add8 (Const8 <t> [d]) x) (Const8 <t> [c]))
  4113		// cond:
  4114		// result: (Add8 (Const8 <t> [int64(int8(c+d))]) x)
  4115		for {
  4116			_ = v.Args[1]
  4117			v_0 := v.Args[0]
  4118			if v_0.Op != OpAdd8 {
  4119				break
  4120			}
  4121			x := v_0.Args[1]
  4122			v_0_0 := v_0.Args[0]
  4123			if v_0_0.Op != OpConst8 {
  4124				break
  4125			}
  4126			t := v_0_0.Type
  4127			d := v_0_0.AuxInt
  4128			v_1 := v.Args[1]
  4129			if v_1.Op != OpConst8 {
  4130				break
  4131			}
  4132			if v_1.Type != t {
  4133				break
  4134			}
  4135			c := v_1.AuxInt
  4136			v.reset(OpAdd8)
  4137			v0 := b.NewValue0(v.Pos, OpConst8, t)
  4138			v0.AuxInt = int64(int8(c + d))
  4139			v.AddArg(v0)
  4140			v.AddArg(x)
  4141			return true
  4142		}
  4143		// match: (Add8 (Add8 x (Const8 <t> [d])) (Const8 <t> [c]))
  4144		// cond:
  4145		// result: (Add8 (Const8 <t> [int64(int8(c+d))]) x)
  4146		for {
  4147			_ = v.Args[1]
  4148			v_0 := v.Args[0]
  4149			if v_0.Op != OpAdd8 {
  4150				break
  4151			}
  4152			_ = v_0.Args[1]
  4153			x := v_0.Args[0]
  4154			v_0_1 := v_0.Args[1]
  4155			if v_0_1.Op != OpConst8 {
  4156				break
  4157			}
  4158			t := v_0_1.Type
  4159			d := v_0_1.AuxInt
  4160			v_1 := v.Args[1]
  4161			if v_1.Op != OpConst8 {
  4162				break
  4163			}
  4164			if v_1.Type != t {
  4165				break
  4166			}
  4167			c := v_1.AuxInt
  4168			v.reset(OpAdd8)
  4169			v0 := b.NewValue0(v.Pos, OpConst8, t)
  4170			v0.AuxInt = int64(int8(c + d))
  4171			v.AddArg(v0)
  4172			v.AddArg(x)
  4173			return true
  4174		}
  4175		return false
  4176	}
  4177	func rewriteValuegeneric_OpAdd8_30(v *Value) bool {
  4178		b := v.Block
  4179		// match: (Add8 (Const8 <t> [c]) (Sub8 (Const8 <t> [d]) x))
  4180		// cond:
  4181		// result: (Sub8 (Const8 <t> [int64(int8(c+d))]) x)
  4182		for {
  4183			_ = v.Args[1]
  4184			v_0 := v.Args[0]
  4185			if v_0.Op != OpConst8 {
  4186				break
  4187			}
  4188			t := v_0.Type
  4189			c := v_0.AuxInt
  4190			v_1 := v.Args[1]
  4191			if v_1.Op != OpSub8 {
  4192				break
  4193			}
  4194			x := v_1.Args[1]
  4195			v_1_0 := v_1.Args[0]
  4196			if v_1_0.Op != OpConst8 {
  4197				break
  4198			}
  4199			if v_1_0.Type != t {
  4200				break
  4201			}
  4202			d := v_1_0.AuxInt
  4203			v.reset(OpSub8)
  4204			v0 := b.NewValue0(v.Pos, OpConst8, t)
  4205			v0.AuxInt = int64(int8(c + d))
  4206			v.AddArg(v0)
  4207			v.AddArg(x)
  4208			return true
  4209		}
  4210		// match: (Add8 (Sub8 (Const8 <t> [d]) x) (Const8 <t> [c]))
  4211		// cond:
  4212		// result: (Sub8 (Const8 <t> [int64(int8(c+d))]) x)
  4213		for {
  4214			_ = v.Args[1]
  4215			v_0 := v.Args[0]
  4216			if v_0.Op != OpSub8 {
  4217				break
  4218			}
  4219			x := v_0.Args[1]
  4220			v_0_0 := v_0.Args[0]
  4221			if v_0_0.Op != OpConst8 {
  4222				break
  4223			}
  4224			t := v_0_0.Type
  4225			d := v_0_0.AuxInt
  4226			v_1 := v.Args[1]
  4227			if v_1.Op != OpConst8 {
  4228				break
  4229			}
  4230			if v_1.Type != t {
  4231				break
  4232			}
  4233			c := v_1.AuxInt
  4234			v.reset(OpSub8)
  4235			v0 := b.NewValue0(v.Pos, OpConst8, t)
  4236			v0.AuxInt = int64(int8(c + d))
  4237			v.AddArg(v0)
  4238			v.AddArg(x)
  4239			return true
  4240		}
  4241		// match: (Add8 (Const8 <t> [c]) (Sub8 x (Const8 <t> [d])))
  4242		// cond:
  4243		// result: (Add8 (Const8 <t> [int64(int8(c-d))]) x)
  4244		for {
  4245			_ = v.Args[1]
  4246			v_0 := v.Args[0]
  4247			if v_0.Op != OpConst8 {
  4248				break
  4249			}
  4250			t := v_0.Type
  4251			c := v_0.AuxInt
  4252			v_1 := v.Args[1]
  4253			if v_1.Op != OpSub8 {
  4254				break
  4255			}
  4256			_ = v_1.Args[1]
  4257			x := v_1.Args[0]
  4258			v_1_1 := v_1.Args[1]
  4259			if v_1_1.Op != OpConst8 {
  4260				break
  4261			}
  4262			if v_1_1.Type != t {
  4263				break
  4264			}
  4265			d := v_1_1.AuxInt
  4266			v.reset(OpAdd8)
  4267			v0 := b.NewValue0(v.Pos, OpConst8, t)
  4268			v0.AuxInt = int64(int8(c - d))
  4269			v.AddArg(v0)
  4270			v.AddArg(x)
  4271			return true
  4272		}
  4273		// match: (Add8 (Sub8 x (Const8 <t> [d])) (Const8 <t> [c]))
  4274		// cond:
  4275		// result: (Add8 (Const8 <t> [int64(int8(c-d))]) x)
  4276		for {
  4277			_ = v.Args[1]
  4278			v_0 := v.Args[0]
  4279			if v_0.Op != OpSub8 {
  4280				break
  4281			}
  4282			_ = v_0.Args[1]
  4283			x := v_0.Args[0]
  4284			v_0_1 := v_0.Args[1]
  4285			if v_0_1.Op != OpConst8 {
  4286				break
  4287			}
  4288			t := v_0_1.Type
  4289			d := v_0_1.AuxInt
  4290			v_1 := v.Args[1]
  4291			if v_1.Op != OpConst8 {
  4292				break
  4293			}
  4294			if v_1.Type != t {
  4295				break
  4296			}
  4297			c := v_1.AuxInt
  4298			v.reset(OpAdd8)
  4299			v0 := b.NewValue0(v.Pos, OpConst8, t)
  4300			v0.AuxInt = int64(int8(c - d))
  4301			v.AddArg(v0)
  4302			v.AddArg(x)
  4303			return true
  4304		}
  4305		return false
  4306	}
  4307	func rewriteValuegeneric_OpAddPtr_0(v *Value) bool {
  4308		// match: (AddPtr <t> x (Const64 [c]))
  4309		// cond:
  4310		// result: (OffPtr <t> x [c])
  4311		for {
  4312			t := v.Type
  4313			_ = v.Args[1]
  4314			x := v.Args[0]
  4315			v_1 := v.Args[1]
  4316			if v_1.Op != OpConst64 {
  4317				break
  4318			}
  4319			c := v_1.AuxInt
  4320			v.reset(OpOffPtr)
  4321			v.Type = t
  4322			v.AuxInt = c
  4323			v.AddArg(x)
  4324			return true
  4325		}
  4326		// match: (AddPtr <t> x (Const32 [c]))
  4327		// cond:
  4328		// result: (OffPtr <t> x [c])
  4329		for {
  4330			t := v.Type
  4331			_ = v.Args[1]
  4332			x := v.Args[0]
  4333			v_1 := v.Args[1]
  4334			if v_1.Op != OpConst32 {
  4335				break
  4336			}
  4337			c := v_1.AuxInt
  4338			v.reset(OpOffPtr)
  4339			v.Type = t
  4340			v.AuxInt = c
  4341			v.AddArg(x)
  4342			return true
  4343		}
  4344		return false
  4345	}
  4346	func rewriteValuegeneric_OpAnd16_0(v *Value) bool {
  4347		// match: (And16 (Const16 [c]) (Const16 [d]))
  4348		// cond:
  4349		// result: (Const16 [int64(int16(c&d))])
  4350		for {
  4351			_ = v.Args[1]
  4352			v_0 := v.Args[0]
  4353			if v_0.Op != OpConst16 {
  4354				break
  4355			}
  4356			c := v_0.AuxInt
  4357			v_1 := v.Args[1]
  4358			if v_1.Op != OpConst16 {
  4359				break
  4360			}
  4361			d := v_1.AuxInt
  4362			v.reset(OpConst16)
  4363			v.AuxInt = int64(int16(c & d))
  4364			return true
  4365		}
  4366		// match: (And16 (Const16 [d]) (Const16 [c]))
  4367		// cond:
  4368		// result: (Const16 [int64(int16(c&d))])
  4369		for {
  4370			_ = v.Args[1]
  4371			v_0 := v.Args[0]
  4372			if v_0.Op != OpConst16 {
  4373				break
  4374			}
  4375			d := v_0.AuxInt
  4376			v_1 := v.Args[1]
  4377			if v_1.Op != OpConst16 {
  4378				break
  4379			}
  4380			c := v_1.AuxInt
  4381			v.reset(OpConst16)
  4382			v.AuxInt = int64(int16(c & d))
  4383			return true
  4384		}
  4385		// match: (And16 (Const16 [m]) (Rsh16Ux64 _ (Const64 [c])))
  4386		// cond: c >= 64-ntz(m)
  4387		// result: (Const16 [0])
  4388		for {
  4389			_ = v.Args[1]
  4390			v_0 := v.Args[0]
  4391			if v_0.Op != OpConst16 {
  4392				break
  4393			}
  4394			m := v_0.AuxInt
  4395			v_1 := v.Args[1]
  4396			if v_1.Op != OpRsh16Ux64 {
  4397				break
  4398			}
  4399			_ = v_1.Args[1]
  4400			v_1_1 := v_1.Args[1]
  4401			if v_1_1.Op != OpConst64 {
  4402				break
  4403			}
  4404			c := v_1_1.AuxInt
  4405			if !(c >= 64-ntz(m)) {
  4406				break
  4407			}
  4408			v.reset(OpConst16)
  4409			v.AuxInt = 0
  4410			return true
  4411		}
  4412		// match: (And16 (Rsh16Ux64 _ (Const64 [c])) (Const16 [m]))
  4413		// cond: c >= 64-ntz(m)
  4414		// result: (Const16 [0])
  4415		for {
  4416			_ = v.Args[1]
  4417			v_0 := v.Args[0]
  4418			if v_0.Op != OpRsh16Ux64 {
  4419				break
  4420			}
  4421			_ = v_0.Args[1]
  4422			v_0_1 := v_0.Args[1]
  4423			if v_0_1.Op != OpConst64 {
  4424				break
  4425			}
  4426			c := v_0_1.AuxInt
  4427			v_1 := v.Args[1]
  4428			if v_1.Op != OpConst16 {
  4429				break
  4430			}
  4431			m := v_1.AuxInt
  4432			if !(c >= 64-ntz(m)) {
  4433				break
  4434			}
  4435			v.reset(OpConst16)
  4436			v.AuxInt = 0
  4437			return true
  4438		}
  4439		// match: (And16 (Const16 [m]) (Lsh16x64 _ (Const64 [c])))
  4440		// cond: c >= 64-nlz(m)
  4441		// result: (Const16 [0])
  4442		for {
  4443			_ = v.Args[1]
  4444			v_0 := v.Args[0]
  4445			if v_0.Op != OpConst16 {
  4446				break
  4447			}
  4448			m := v_0.AuxInt
  4449			v_1 := v.Args[1]
  4450			if v_1.Op != OpLsh16x64 {
  4451				break
  4452			}
  4453			_ = v_1.Args[1]
  4454			v_1_1 := v_1.Args[1]
  4455			if v_1_1.Op != OpConst64 {
  4456				break
  4457			}
  4458			c := v_1_1.AuxInt
  4459			if !(c >= 64-nlz(m)) {
  4460				break
  4461			}
  4462			v.reset(OpConst16)
  4463			v.AuxInt = 0
  4464			return true
  4465		}
  4466		// match: (And16 (Lsh16x64 _ (Const64 [c])) (Const16 [m]))
  4467		// cond: c >= 64-nlz(m)
  4468		// result: (Const16 [0])
  4469		for {
  4470			_ = v.Args[1]
  4471			v_0 := v.Args[0]
  4472			if v_0.Op != OpLsh16x64 {
  4473				break
  4474			}
  4475			_ = v_0.Args[1]
  4476			v_0_1 := v_0.Args[1]
  4477			if v_0_1.Op != OpConst64 {
  4478				break
  4479			}
  4480			c := v_0_1.AuxInt
  4481			v_1 := v.Args[1]
  4482			if v_1.Op != OpConst16 {
  4483				break
  4484			}
  4485			m := v_1.AuxInt
  4486			if !(c >= 64-nlz(m)) {
  4487				break
  4488			}
  4489			v.reset(OpConst16)
  4490			v.AuxInt = 0
  4491			return true
  4492		}
  4493		// match: (And16 x x)
  4494		// cond:
  4495		// result: x
  4496		for {
  4497			x := v.Args[1]
  4498			if x != v.Args[0] {
  4499				break
  4500			}
  4501			v.reset(OpCopy)
  4502			v.Type = x.Type
  4503			v.AddArg(x)
  4504			return true
  4505		}
  4506		// match: (And16 (Const16 [-1]) x)
  4507		// cond:
  4508		// result: x
  4509		for {
  4510			x := v.Args[1]
  4511			v_0 := v.Args[0]
  4512			if v_0.Op != OpConst16 {
  4513				break
  4514			}
  4515			if v_0.AuxInt != -1 {
  4516				break
  4517			}
  4518			v.reset(OpCopy)
  4519			v.Type = x.Type
  4520			v.AddArg(x)
  4521			return true
  4522		}
  4523		// match: (And16 x (Const16 [-1]))
  4524		// cond:
  4525		// result: x
  4526		for {
  4527			_ = v.Args[1]
  4528			x := v.Args[0]
  4529			v_1 := v.Args[1]
  4530			if v_1.Op != OpConst16 {
  4531				break
  4532			}
  4533			if v_1.AuxInt != -1 {
  4534				break
  4535			}
  4536			v.reset(OpCopy)
  4537			v.Type = x.Type
  4538			v.AddArg(x)
  4539			return true
  4540		}
  4541		// match: (And16 (Const16 [0]) _)
  4542		// cond:
  4543		// result: (Const16 [0])
  4544		for {
  4545			_ = v.Args[1]
  4546			v_0 := v.Args[0]
  4547			if v_0.Op != OpConst16 {
  4548				break
  4549			}
  4550			if v_0.AuxInt != 0 {
  4551				break
  4552			}
  4553			v.reset(OpConst16)
  4554			v.AuxInt = 0
  4555			return true
  4556		}
  4557		return false
  4558	}
  4559	func rewriteValuegeneric_OpAnd16_10(v *Value) bool {
  4560		b := v.Block
  4561		// match: (And16 _ (Const16 [0]))
  4562		// cond:
  4563		// result: (Const16 [0])
  4564		for {
  4565			_ = v.Args[1]
  4566			v_1 := v.Args[1]
  4567			if v_1.Op != OpConst16 {
  4568				break
  4569			}
  4570			if v_1.AuxInt != 0 {
  4571				break
  4572			}
  4573			v.reset(OpConst16)
  4574			v.AuxInt = 0
  4575			return true
  4576		}
  4577		// match: (And16 x (And16 x y))
  4578		// cond:
  4579		// result: (And16 x y)
  4580		for {
  4581			_ = v.Args[1]
  4582			x := v.Args[0]
  4583			v_1 := v.Args[1]
  4584			if v_1.Op != OpAnd16 {
  4585				break
  4586			}
  4587			y := v_1.Args[1]
  4588			if x != v_1.Args[0] {
  4589				break
  4590			}
  4591			v.reset(OpAnd16)
  4592			v.AddArg(x)
  4593			v.AddArg(y)
  4594			return true
  4595		}
  4596		// match: (And16 x (And16 y x))
  4597		// cond:
  4598		// result: (And16 x y)
  4599		for {
  4600			_ = v.Args[1]
  4601			x := v.Args[0]
  4602			v_1 := v.Args[1]
  4603			if v_1.Op != OpAnd16 {
  4604				break
  4605			}
  4606			_ = v_1.Args[1]
  4607			y := v_1.Args[0]
  4608			if x != v_1.Args[1] {
  4609				break
  4610			}
  4611			v.reset(OpAnd16)
  4612			v.AddArg(x)
  4613			v.AddArg(y)
  4614			return true
  4615		}
  4616		// match: (And16 (And16 x y) x)
  4617		// cond:
  4618		// result: (And16 x y)
  4619		for {
  4620			x := v.Args[1]
  4621			v_0 := v.Args[0]
  4622			if v_0.Op != OpAnd16 {
  4623				break
  4624			}
  4625			y := v_0.Args[1]
  4626			if x != v_0.Args[0] {
  4627				break
  4628			}
  4629			v.reset(OpAnd16)
  4630			v.AddArg(x)
  4631			v.AddArg(y)
  4632			return true
  4633		}
  4634		// match: (And16 (And16 y x) x)
  4635		// cond:
  4636		// result: (And16 x y)
  4637		for {
  4638			x := v.Args[1]
  4639			v_0 := v.Args[0]
  4640			if v_0.Op != OpAnd16 {
  4641				break
  4642			}
  4643			_ = v_0.Args[1]
  4644			y := v_0.Args[0]
  4645			if x != v_0.Args[1] {
  4646				break
  4647			}
  4648			v.reset(OpAnd16)
  4649			v.AddArg(x)
  4650			v.AddArg(y)
  4651			return true
  4652		}
  4653		// match: (And16 (And16 i:(Const16 <t>) z) x)
  4654		// cond: (z.Op != OpConst16 && x.Op != OpConst16)
  4655		// result: (And16 i (And16 <t> z x))
  4656		for {
  4657			x := v.Args[1]
  4658			v_0 := v.Args[0]
  4659			if v_0.Op != OpAnd16 {
  4660				break
  4661			}
  4662			z := v_0.Args[1]
  4663			i := v_0.Args[0]
  4664			if i.Op != OpConst16 {
  4665				break
  4666			}
  4667			t := i.Type
  4668			if !(z.Op != OpConst16 && x.Op != OpConst16) {
  4669				break
  4670			}
  4671			v.reset(OpAnd16)
  4672			v.AddArg(i)
  4673			v0 := b.NewValue0(v.Pos, OpAnd16, t)
  4674			v0.AddArg(z)
  4675			v0.AddArg(x)
  4676			v.AddArg(v0)
  4677			return true
  4678		}
  4679		// match: (And16 (And16 z i:(Const16 <t>)) x)
  4680		// cond: (z.Op != OpConst16 && x.Op != OpConst16)
  4681		// result: (And16 i (And16 <t> z x))
  4682		for {
  4683			x := v.Args[1]
  4684			v_0 := v.Args[0]
  4685			if v_0.Op != OpAnd16 {
  4686				break
  4687			}
  4688			_ = v_0.Args[1]
  4689			z := v_0.Args[0]
  4690			i := v_0.Args[1]
  4691			if i.Op != OpConst16 {
  4692				break
  4693			}
  4694			t := i.Type
  4695			if !(z.Op != OpConst16 && x.Op != OpConst16) {
  4696				break
  4697			}
  4698			v.reset(OpAnd16)
  4699			v.AddArg(i)
  4700			v0 := b.NewValue0(v.Pos, OpAnd16, t)
  4701			v0.AddArg(z)
  4702			v0.AddArg(x)
  4703			v.AddArg(v0)
  4704			return true
  4705		}
  4706		// match: (And16 x (And16 i:(Const16 <t>) z))
  4707		// cond: (z.Op != OpConst16 && x.Op != OpConst16)
  4708		// result: (And16 i (And16 <t> z x))
  4709		for {
  4710			_ = v.Args[1]
  4711			x := v.Args[0]
  4712			v_1 := v.Args[1]
  4713			if v_1.Op != OpAnd16 {
  4714				break
  4715			}
  4716			z := v_1.Args[1]
  4717			i := v_1.Args[0]
  4718			if i.Op != OpConst16 {
  4719				break
  4720			}
  4721			t := i.Type
  4722			if !(z.Op != OpConst16 && x.Op != OpConst16) {
  4723				break
  4724			}
  4725			v.reset(OpAnd16)
  4726			v.AddArg(i)
  4727			v0 := b.NewValue0(v.Pos, OpAnd16, t)
  4728			v0.AddArg(z)
  4729			v0.AddArg(x)
  4730			v.AddArg(v0)
  4731			return true
  4732		}
  4733		// match: (And16 x (And16 z i:(Const16 <t>)))
  4734		// cond: (z.Op != OpConst16 && x.Op != OpConst16)
  4735		// result: (And16 i (And16 <t> z x))
  4736		for {
  4737			_ = v.Args[1]
  4738			x := v.Args[0]
  4739			v_1 := v.Args[1]
  4740			if v_1.Op != OpAnd16 {
  4741				break
  4742			}
  4743			_ = v_1.Args[1]
  4744			z := v_1.Args[0]
  4745			i := v_1.Args[1]
  4746			if i.Op != OpConst16 {
  4747				break
  4748			}
  4749			t := i.Type
  4750			if !(z.Op != OpConst16 && x.Op != OpConst16) {
  4751				break
  4752			}
  4753			v.reset(OpAnd16)
  4754			v.AddArg(i)
  4755			v0 := b.NewValue0(v.Pos, OpAnd16, t)
  4756			v0.AddArg(z)
  4757			v0.AddArg(x)
  4758			v.AddArg(v0)
  4759			return true
  4760		}
  4761		// match: (And16 (Const16 <t> [c]) (And16 (Const16 <t> [d]) x))
  4762		// cond:
  4763		// result: (And16 (Const16 <t> [int64(int16(c&d))]) x)
  4764		for {
  4765			_ = v.Args[1]
  4766			v_0 := v.Args[0]
  4767			if v_0.Op != OpConst16 {
  4768				break
  4769			}
  4770			t := v_0.Type
  4771			c := v_0.AuxInt
  4772			v_1 := v.Args[1]
  4773			if v_1.Op != OpAnd16 {
  4774				break
  4775			}
  4776			x := v_1.Args[1]
  4777			v_1_0 := v_1.Args[0]
  4778			if v_1_0.Op != OpConst16 {
  4779				break
  4780			}
  4781			if v_1_0.Type != t {
  4782				break
  4783			}
  4784			d := v_1_0.AuxInt
  4785			v.reset(OpAnd16)
  4786			v0 := b.NewValue0(v.Pos, OpConst16, t)
  4787			v0.AuxInt = int64(int16(c & d))
  4788			v.AddArg(v0)
  4789			v.AddArg(x)
  4790			return true
  4791		}
  4792		return false
  4793	}
  4794	func rewriteValuegeneric_OpAnd16_20(v *Value) bool {
  4795		b := v.Block
  4796		// match: (And16 (Const16 <t> [c]) (And16 x (Const16 <t> [d])))
  4797		// cond:
  4798		// result: (And16 (Const16 <t> [int64(int16(c&d))]) x)
  4799		for {
  4800			_ = v.Args[1]
  4801			v_0 := v.Args[0]
  4802			if v_0.Op != OpConst16 {
  4803				break
  4804			}
  4805			t := v_0.Type
  4806			c := v_0.AuxInt
  4807			v_1 := v.Args[1]
  4808			if v_1.Op != OpAnd16 {
  4809				break
  4810			}
  4811			_ = v_1.Args[1]
  4812			x := v_1.Args[0]
  4813			v_1_1 := v_1.Args[1]
  4814			if v_1_1.Op != OpConst16 {
  4815				break
  4816			}
  4817			if v_1_1.Type != t {
  4818				break
  4819			}
  4820			d := v_1_1.AuxInt
  4821			v.reset(OpAnd16)
  4822			v0 := b.NewValue0(v.Pos, OpConst16, t)
  4823			v0.AuxInt = int64(int16(c & d))
  4824			v.AddArg(v0)
  4825			v.AddArg(x)
  4826			return true
  4827		}
  4828		// match: (And16 (And16 (Const16 <t> [d]) x) (Const16 <t> [c]))
  4829		// cond:
  4830		// result: (And16 (Const16 <t> [int64(int16(c&d))]) x)
  4831		for {
  4832			_ = v.Args[1]
  4833			v_0 := v.Args[0]
  4834			if v_0.Op != OpAnd16 {
  4835				break
  4836			}
  4837			x := v_0.Args[1]
  4838			v_0_0 := v_0.Args[0]
  4839			if v_0_0.Op != OpConst16 {
  4840				break
  4841			}
  4842			t := v_0_0.Type
  4843			d := v_0_0.AuxInt
  4844			v_1 := v.Args[1]
  4845			if v_1.Op != OpConst16 {
  4846				break
  4847			}
  4848			if v_1.Type != t {
  4849				break
  4850			}
  4851			c := v_1.AuxInt
  4852			v.reset(OpAnd16)
  4853			v0 := b.NewValue0(v.Pos, OpConst16, t)
  4854			v0.AuxInt = int64(int16(c & d))
  4855			v.AddArg(v0)
  4856			v.AddArg(x)
  4857			return true
  4858		}
  4859		// match: (And16 (And16 x (Const16 <t> [d])) (Const16 <t> [c]))
  4860		// cond:
  4861		// result: (And16 (Const16 <t> [int64(int16(c&d))]) x)
  4862		for {
  4863			_ = v.Args[1]
  4864			v_0 := v.Args[0]
  4865			if v_0.Op != OpAnd16 {
  4866				break
  4867			}
  4868			_ = v_0.Args[1]
  4869			x := v_0.Args[0]
  4870			v_0_1 := v_0.Args[1]
  4871			if v_0_1.Op != OpConst16 {
  4872				break
  4873			}
  4874			t := v_0_1.Type
  4875			d := v_0_1.AuxInt
  4876			v_1 := v.Args[1]
  4877			if v_1.Op != OpConst16 {
  4878				break
  4879			}
  4880			if v_1.Type != t {
  4881				break
  4882			}
  4883			c := v_1.AuxInt
  4884			v.reset(OpAnd16)
  4885			v0 := b.NewValue0(v.Pos, OpConst16, t)
  4886			v0.AuxInt = int64(int16(c & d))
  4887			v.AddArg(v0)
  4888			v.AddArg(x)
  4889			return true
  4890		}
  4891		return false
  4892	}
  4893	func rewriteValuegeneric_OpAnd32_0(v *Value) bool {
  4894		// match: (And32 (Const32 [c]) (Const32 [d]))
  4895		// cond:
  4896		// result: (Const32 [int64(int32(c&d))])
  4897		for {
  4898			_ = v.Args[1]
  4899			v_0 := v.Args[0]
  4900			if v_0.Op != OpConst32 {
  4901				break
  4902			}
  4903			c := v_0.AuxInt
  4904			v_1 := v.Args[1]
  4905			if v_1.Op != OpConst32 {
  4906				break
  4907			}
  4908			d := v_1.AuxInt
  4909			v.reset(OpConst32)
  4910			v.AuxInt = int64(int32(c & d))
  4911			return true
  4912		}
  4913		// match: (And32 (Const32 [d]) (Const32 [c]))
  4914		// cond:
  4915		// result: (Const32 [int64(int32(c&d))])
  4916		for {
  4917			_ = v.Args[1]
  4918			v_0 := v.Args[0]
  4919			if v_0.Op != OpConst32 {
  4920				break
  4921			}
  4922			d := v_0.AuxInt
  4923			v_1 := v.Args[1]
  4924			if v_1.Op != OpConst32 {
  4925				break
  4926			}
  4927			c := v_1.AuxInt
  4928			v.reset(OpConst32)
  4929			v.AuxInt = int64(int32(c & d))
  4930			return true
  4931		}
  4932		// match: (And32 (Const32 [m]) (Rsh32Ux64 _ (Const64 [c])))
  4933		// cond: c >= 64-ntz(m)
  4934		// result: (Const32 [0])
  4935		for {
  4936			_ = v.Args[1]
  4937			v_0 := v.Args[0]
  4938			if v_0.Op != OpConst32 {
  4939				break
  4940			}
  4941			m := v_0.AuxInt
  4942			v_1 := v.Args[1]
  4943			if v_1.Op != OpRsh32Ux64 {
  4944				break
  4945			}
  4946			_ = v_1.Args[1]
  4947			v_1_1 := v_1.Args[1]
  4948			if v_1_1.Op != OpConst64 {
  4949				break
  4950			}
  4951			c := v_1_1.AuxInt
  4952			if !(c >= 64-ntz(m)) {
  4953				break
  4954			}
  4955			v.reset(OpConst32)
  4956			v.AuxInt = 0
  4957			return true
  4958		}
  4959		// match: (And32 (Rsh32Ux64 _ (Const64 [c])) (Const32 [m]))
  4960		// cond: c >= 64-ntz(m)
  4961		// result: (Const32 [0])
  4962		for {
  4963			_ = v.Args[1]
  4964			v_0 := v.Args[0]
  4965			if v_0.Op != OpRsh32Ux64 {
  4966				break
  4967			}
  4968			_ = v_0.Args[1]
  4969			v_0_1 := v_0.Args[1]
  4970			if v_0_1.Op != OpConst64 {
  4971				break
  4972			}
  4973			c := v_0_1.AuxInt
  4974			v_1 := v.Args[1]
  4975			if v_1.Op != OpConst32 {
  4976				break
  4977			}
  4978			m := v_1.AuxInt
  4979			if !(c >= 64-ntz(m)) {
  4980				break
  4981			}
  4982			v.reset(OpConst32)
  4983			v.AuxInt = 0
  4984			return true
  4985		}
  4986		// match: (And32 (Const32 [m]) (Lsh32x64 _ (Const64 [c])))
  4987		// cond: c >= 64-nlz(m)
  4988		// result: (Const32 [0])
  4989		for {
  4990			_ = v.Args[1]
  4991			v_0 := v.Args[0]
  4992			if v_0.Op != OpConst32 {
  4993				break
  4994			}
  4995			m := v_0.AuxInt
  4996			v_1 := v.Args[1]
  4997			if v_1.Op != OpLsh32x64 {
  4998				break
  4999			}
  5000			_ = v_1.Args[1]
  5001			v_1_1 := v_1.Args[1]
  5002			if v_1_1.Op != OpConst64 {
  5003				break
  5004			}
  5005			c := v_1_1.AuxInt
  5006			if !(c >= 64-nlz(m)) {
  5007				break
  5008			}
  5009			v.reset(OpConst32)
  5010			v.AuxInt = 0
  5011			return true
  5012		}
  5013		// match: (And32 (Lsh32x64 _ (Const64 [c])) (Const32 [m]))
  5014		// cond: c >= 64-nlz(m)
  5015		// result: (Const32 [0])
  5016		for {
  5017			_ = v.Args[1]
  5018			v_0 := v.Args[0]
  5019			if v_0.Op != OpLsh32x64 {
  5020				break
  5021			}
  5022			_ = v_0.Args[1]
  5023			v_0_1 := v_0.Args[1]
  5024			if v_0_1.Op != OpConst64 {
  5025				break
  5026			}
  5027			c := v_0_1.AuxInt
  5028			v_1 := v.Args[1]
  5029			if v_1.Op != OpConst32 {
  5030				break
  5031			}
  5032			m := v_1.AuxInt
  5033			if !(c >= 64-nlz(m)) {
  5034				break
  5035			}
  5036			v.reset(OpConst32)
  5037			v.AuxInt = 0
  5038			return true
  5039		}
  5040		// match: (And32 x x)
  5041		// cond:
  5042		// result: x
  5043		for {
  5044			x := v.Args[1]
  5045			if x != v.Args[0] {
  5046				break
  5047			}
  5048			v.reset(OpCopy)
  5049			v.Type = x.Type
  5050			v.AddArg(x)
  5051			return true
  5052		}
  5053		// match: (And32 (Const32 [-1]) x)
  5054		// cond:
  5055		// result: x
  5056		for {
  5057			x := v.Args[1]
  5058			v_0 := v.Args[0]
  5059			if v_0.Op != OpConst32 {
  5060				break
  5061			}
  5062			if v_0.AuxInt != -1 {
  5063				break
  5064			}
  5065			v.reset(OpCopy)
  5066			v.Type = x.Type
  5067			v.AddArg(x)
  5068			return true
  5069		}
  5070		// match: (And32 x (Const32 [-1]))
  5071		// cond:
  5072		// result: x
  5073		for {
  5074			_ = v.Args[1]
  5075			x := v.Args[0]
  5076			v_1 := v.Args[1]
  5077			if v_1.Op != OpConst32 {
  5078				break
  5079			}
  5080			if v_1.AuxInt != -1 {
  5081				break
  5082			}
  5083			v.reset(OpCopy)
  5084			v.Type = x.Type
  5085			v.AddArg(x)
  5086			return true
  5087		}
  5088		// match: (And32 (Const32 [0]) _)
  5089		// cond:
  5090		// result: (Const32 [0])
  5091		for {
  5092			_ = v.Args[1]
  5093			v_0 := v.Args[0]
  5094			if v_0.Op != OpConst32 {
  5095				break
  5096			}
  5097			if v_0.AuxInt != 0 {
  5098				break
  5099			}
  5100			v.reset(OpConst32)
  5101			v.AuxInt = 0
  5102			return true
  5103		}
  5104		return false
  5105	}
  5106	func rewriteValuegeneric_OpAnd32_10(v *Value) bool {
  5107		b := v.Block
  5108		// match: (And32 _ (Const32 [0]))
  5109		// cond:
  5110		// result: (Const32 [0])
  5111		for {
  5112			_ = v.Args[1]
  5113			v_1 := v.Args[1]
  5114			if v_1.Op != OpConst32 {
  5115				break
  5116			}
  5117			if v_1.AuxInt != 0 {
  5118				break
  5119			}
  5120			v.reset(OpConst32)
  5121			v.AuxInt = 0
  5122			return true
  5123		}
  5124		// match: (And32 x (And32 x y))
  5125		// cond:
  5126		// result: (And32 x y)
  5127		for {
  5128			_ = v.Args[1]
  5129			x := v.Args[0]
  5130			v_1 := v.Args[1]
  5131			if v_1.Op != OpAnd32 {
  5132				break
  5133			}
  5134			y := v_1.Args[1]
  5135			if x != v_1.Args[0] {
  5136				break
  5137			}
  5138			v.reset(OpAnd32)
  5139			v.AddArg(x)
  5140			v.AddArg(y)
  5141			return true
  5142		}
  5143		// match: (And32 x (And32 y x))
  5144		// cond:
  5145		// result: (And32 x y)
  5146		for {
  5147			_ = v.Args[1]
  5148			x := v.Args[0]
  5149			v_1 := v.Args[1]
  5150			if v_1.Op != OpAnd32 {
  5151				break
  5152			}
  5153			_ = v_1.Args[1]
  5154			y := v_1.Args[0]
  5155			if x != v_1.Args[1] {
  5156				break
  5157			}
  5158			v.reset(OpAnd32)
  5159			v.AddArg(x)
  5160			v.AddArg(y)
  5161			return true
  5162		}
  5163		// match: (And32 (And32 x y) x)
  5164		// cond:
  5165		// result: (And32 x y)
  5166		for {
  5167			x := v.Args[1]
  5168			v_0 := v.Args[0]
  5169			if v_0.Op != OpAnd32 {
  5170				break
  5171			}
  5172			y := v_0.Args[1]
  5173			if x != v_0.Args[0] {
  5174				break
  5175			}
  5176			v.reset(OpAnd32)
  5177			v.AddArg(x)
  5178			v.AddArg(y)
  5179			return true
  5180		}
  5181		// match: (And32 (And32 y x) x)
  5182		// cond:
  5183		// result: (And32 x y)
  5184		for {
  5185			x := v.Args[1]
  5186			v_0 := v.Args[0]
  5187			if v_0.Op != OpAnd32 {
  5188				break
  5189			}
  5190			_ = v_0.Args[1]
  5191			y := v_0.Args[0]
  5192			if x != v_0.Args[1] {
  5193				break
  5194			}
  5195			v.reset(OpAnd32)
  5196			v.AddArg(x)
  5197			v.AddArg(y)
  5198			return true
  5199		}
  5200		// match: (And32 (And32 i:(Const32 <t>) z) x)
  5201		// cond: (z.Op != OpConst32 && x.Op != OpConst32)
  5202		// result: (And32 i (And32 <t> z x))
  5203		for {
  5204			x := v.Args[1]
  5205			v_0 := v.Args[0]
  5206			if v_0.Op != OpAnd32 {
  5207				break
  5208			}
  5209			z := v_0.Args[1]
  5210			i := v_0.Args[0]
  5211			if i.Op != OpConst32 {
  5212				break
  5213			}
  5214			t := i.Type
  5215			if !(z.Op != OpConst32 && x.Op != OpConst32) {
  5216				break
  5217			}
  5218			v.reset(OpAnd32)
  5219			v.AddArg(i)
  5220			v0 := b.NewValue0(v.Pos, OpAnd32, t)
  5221			v0.AddArg(z)
  5222			v0.AddArg(x)
  5223			v.AddArg(v0)
  5224			return true
  5225		}
  5226		// match: (And32 (And32 z i:(Const32 <t>)) x)
  5227		// cond: (z.Op != OpConst32 && x.Op != OpConst32)
  5228		// result: (And32 i (And32 <t> z x))
  5229		for {
  5230			x := v.Args[1]
  5231			v_0 := v.Args[0]
  5232			if v_0.Op != OpAnd32 {
  5233				break
  5234			}
  5235			_ = v_0.Args[1]
  5236			z := v_0.Args[0]
  5237			i := v_0.Args[1]
  5238			if i.Op != OpConst32 {
  5239				break
  5240			}
  5241			t := i.Type
  5242			if !(z.Op != OpConst32 && x.Op != OpConst32) {
  5243				break
  5244			}
  5245			v.reset(OpAnd32)
  5246			v.AddArg(i)
  5247			v0 := b.NewValue0(v.Pos, OpAnd32, t)
  5248			v0.AddArg(z)
  5249			v0.AddArg(x)
  5250			v.AddArg(v0)
  5251			return true
  5252		}
  5253		// match: (And32 x (And32 i:(Const32 <t>) z))
  5254		// cond: (z.Op != OpConst32 && x.Op != OpConst32)
  5255		// result: (And32 i (And32 <t> z x))
  5256		for {
  5257			_ = v.Args[1]
  5258			x := v.Args[0]
  5259			v_1 := v.Args[1]
  5260			if v_1.Op != OpAnd32 {
  5261				break
  5262			}
  5263			z := v_1.Args[1]
  5264			i := v_1.Args[0]
  5265			if i.Op != OpConst32 {
  5266				break
  5267			}
  5268			t := i.Type
  5269			if !(z.Op != OpConst32 && x.Op != OpConst32) {
  5270				break
  5271			}
  5272			v.reset(OpAnd32)
  5273			v.AddArg(i)
  5274			v0 := b.NewValue0(v.Pos, OpAnd32, t)
  5275			v0.AddArg(z)
  5276			v0.AddArg(x)
  5277			v.AddArg(v0)
  5278			return true
  5279		}
  5280		// match: (And32 x (And32 z i:(Const32 <t>)))
  5281		// cond: (z.Op != OpConst32 && x.Op != OpConst32)
  5282		// result: (And32 i (And32 <t> z x))
  5283		for {
  5284			_ = v.Args[1]
  5285			x := v.Args[0]
  5286			v_1 := v.Args[1]
  5287			if v_1.Op != OpAnd32 {
  5288				break
  5289			}
  5290			_ = v_1.Args[1]
  5291			z := v_1.Args[0]
  5292			i := v_1.Args[1]
  5293			if i.Op != OpConst32 {
  5294				break
  5295			}
  5296			t := i.Type
  5297			if !(z.Op != OpConst32 && x.Op != OpConst32) {
  5298				break
  5299			}
  5300			v.reset(OpAnd32)
  5301			v.AddArg(i)
  5302			v0 := b.NewValue0(v.Pos, OpAnd32, t)
  5303			v0.AddArg(z)
  5304			v0.AddArg(x)
  5305			v.AddArg(v0)
  5306			return true
  5307		}
  5308		// match: (And32 (Const32 <t> [c]) (And32 (Const32 <t> [d]) x))
  5309		// cond:
  5310		// result: (And32 (Const32 <t> [int64(int32(c&d))]) x)
  5311		for {
  5312			_ = v.Args[1]
  5313			v_0 := v.Args[0]
  5314			if v_0.Op != OpConst32 {
  5315				break
  5316			}
  5317			t := v_0.Type
  5318			c := v_0.AuxInt
  5319			v_1 := v.Args[1]
  5320			if v_1.Op != OpAnd32 {
  5321				break
  5322			}
  5323			x := v_1.Args[1]
  5324			v_1_0 := v_1.Args[0]
  5325			if v_1_0.Op != OpConst32 {
  5326				break
  5327			}
  5328			if v_1_0.Type != t {
  5329				break
  5330			}
  5331			d := v_1_0.AuxInt
  5332			v.reset(OpAnd32)
  5333			v0 := b.NewValue0(v.Pos, OpConst32, t)
  5334			v0.AuxInt = int64(int32(c & d))
  5335			v.AddArg(v0)
  5336			v.AddArg(x)
  5337			return true
  5338		}
  5339		return false
  5340	}
  5341	func rewriteValuegeneric_OpAnd32_20(v *Value) bool {
  5342		b := v.Block
  5343		// match: (And32 (Const32 <t> [c]) (And32 x (Const32 <t> [d])))
  5344		// cond:
  5345		// result: (And32 (Const32 <t> [int64(int32(c&d))]) x)
  5346		for {
  5347			_ = v.Args[1]
  5348			v_0 := v.Args[0]
  5349			if v_0.Op != OpConst32 {
  5350				break
  5351			}
  5352			t := v_0.Type
  5353			c := v_0.AuxInt
  5354			v_1 := v.Args[1]
  5355			if v_1.Op != OpAnd32 {
  5356				break
  5357			}
  5358			_ = v_1.Args[1]
  5359			x := v_1.Args[0]
  5360			v_1_1 := v_1.Args[1]
  5361			if v_1_1.Op != OpConst32 {
  5362				break
  5363			}
  5364			if v_1_1.Type != t {
  5365				break
  5366			}
  5367			d := v_1_1.AuxInt
  5368			v.reset(OpAnd32)
  5369			v0 := b.NewValue0(v.Pos, OpConst32, t)
  5370			v0.AuxInt = int64(int32(c & d))
  5371			v.AddArg(v0)
  5372			v.AddArg(x)
  5373			return true
  5374		}
  5375		// match: (And32 (And32 (Const32 <t> [d]) x) (Const32 <t> [c]))
  5376		// cond:
  5377		// result: (And32 (Const32 <t> [int64(int32(c&d))]) x)
  5378		for {
  5379			_ = v.Args[1]
  5380			v_0 := v.Args[0]
  5381			if v_0.Op != OpAnd32 {
  5382				break
  5383			}
  5384			x := v_0.Args[1]
  5385			v_0_0 := v_0.Args[0]
  5386			if v_0_0.Op != OpConst32 {
  5387				break
  5388			}
  5389			t := v_0_0.Type
  5390			d := v_0_0.AuxInt
  5391			v_1 := v.Args[1]
  5392			if v_1.Op != OpConst32 {
  5393				break
  5394			}
  5395			if v_1.Type != t {
  5396				break
  5397			}
  5398			c := v_1.AuxInt
  5399			v.reset(OpAnd32)
  5400			v0 := b.NewValue0(v.Pos, OpConst32, t)
  5401			v0.AuxInt = int64(int32(c & d))
  5402			v.AddArg(v0)
  5403			v.AddArg(x)
  5404			return true
  5405		}
  5406		// match: (And32 (And32 x (Const32 <t> [d])) (Const32 <t> [c]))
  5407		// cond:
  5408		// result: (And32 (Const32 <t> [int64(int32(c&d))]) x)
  5409		for {
  5410			_ = v.Args[1]
  5411			v_0 := v.Args[0]
  5412			if v_0.Op != OpAnd32 {
  5413				break
  5414			}
  5415			_ = v_0.Args[1]
  5416			x := v_0.Args[0]
  5417			v_0_1 := v_0.Args[1]
  5418			if v_0_1.Op != OpConst32 {
  5419				break
  5420			}
  5421			t := v_0_1.Type
  5422			d := v_0_1.AuxInt
  5423			v_1 := v.Args[1]
  5424			if v_1.Op != OpConst32 {
  5425				break
  5426			}
  5427			if v_1.Type != t {
  5428				break
  5429			}
  5430			c := v_1.AuxInt
  5431			v.reset(OpAnd32)
  5432			v0 := b.NewValue0(v.Pos, OpConst32, t)
  5433			v0.AuxInt = int64(int32(c & d))
  5434			v.AddArg(v0)
  5435			v.AddArg(x)
  5436			return true
  5437		}
  5438		return false
  5439	}
  5440	func rewriteValuegeneric_OpAnd64_0(v *Value) bool {
  5441		// match: (And64 (Const64 [c]) (Const64 [d]))
  5442		// cond:
  5443		// result: (Const64 [c&d])
  5444		for {
  5445			_ = v.Args[1]
  5446			v_0 := v.Args[0]
  5447			if v_0.Op != OpConst64 {
  5448				break
  5449			}
  5450			c := v_0.AuxInt
  5451			v_1 := v.Args[1]
  5452			if v_1.Op != OpConst64 {
  5453				break
  5454			}
  5455			d := v_1.AuxInt
  5456			v.reset(OpConst64)
  5457			v.AuxInt = c & d
  5458			return true
  5459		}
  5460		// match: (And64 (Const64 [d]) (Const64 [c]))
  5461		// cond:
  5462		// result: (Const64 [c&d])
  5463		for {
  5464			_ = v.Args[1]
  5465			v_0 := v.Args[0]
  5466			if v_0.Op != OpConst64 {
  5467				break
  5468			}
  5469			d := v_0.AuxInt
  5470			v_1 := v.Args[1]
  5471			if v_1.Op != OpConst64 {
  5472				break
  5473			}
  5474			c := v_1.AuxInt
  5475			v.reset(OpConst64)
  5476			v.AuxInt = c & d
  5477			return true
  5478		}
  5479		// match: (And64 (Const64 [m]) (Rsh64Ux64 _ (Const64 [c])))
  5480		// cond: c >= 64-ntz(m)
  5481		// result: (Const64 [0])
  5482		for {
  5483			_ = v.Args[1]
  5484			v_0 := v.Args[0]
  5485			if v_0.Op != OpConst64 {
  5486				break
  5487			}
  5488			m := v_0.AuxInt
  5489			v_1 := v.Args[1]
  5490			if v_1.Op != OpRsh64Ux64 {
  5491				break
  5492			}
  5493			_ = v_1.Args[1]
  5494			v_1_1 := v_1.Args[1]
  5495			if v_1_1.Op != OpConst64 {
  5496				break
  5497			}
  5498			c := v_1_1.AuxInt
  5499			if !(c >= 64-ntz(m)) {
  5500				break
  5501			}
  5502			v.reset(OpConst64)
  5503			v.AuxInt = 0
  5504			return true
  5505		}
  5506		// match: (And64 (Rsh64Ux64 _ (Const64 [c])) (Const64 [m]))
  5507		// cond: c >= 64-ntz(m)
  5508		// result: (Const64 [0])
  5509		for {
  5510			_ = v.Args[1]
  5511			v_0 := v.Args[0]
  5512			if v_0.Op != OpRsh64Ux64 {
  5513				break
  5514			}
  5515			_ = v_0.Args[1]
  5516			v_0_1 := v_0.Args[1]
  5517			if v_0_1.Op != OpConst64 {
  5518				break
  5519			}
  5520			c := v_0_1.AuxInt
  5521			v_1 := v.Args[1]
  5522			if v_1.Op != OpConst64 {
  5523				break
  5524			}
  5525			m := v_1.AuxInt
  5526			if !(c >= 64-ntz(m)) {
  5527				break
  5528			}
  5529			v.reset(OpConst64)
  5530			v.AuxInt = 0
  5531			return true
  5532		}
  5533		// match: (And64 (Const64 [m]) (Lsh64x64 _ (Const64 [c])))
  5534		// cond: c >= 64-nlz(m)
  5535		// result: (Const64 [0])
  5536		for {
  5537			_ = v.Args[1]
  5538			v_0 := v.Args[0]
  5539			if v_0.Op != OpConst64 {
  5540				break
  5541			}
  5542			m := v_0.AuxInt
  5543			v_1 := v.Args[1]
  5544			if v_1.Op != OpLsh64x64 {
  5545				break
  5546			}
  5547			_ = v_1.Args[1]
  5548			v_1_1 := v_1.Args[1]
  5549			if v_1_1.Op != OpConst64 {
  5550				break
  5551			}
  5552			c := v_1_1.AuxInt
  5553			if !(c >= 64-nlz(m)) {
  5554				break
  5555			}
  5556			v.reset(OpConst64)
  5557			v.AuxInt = 0
  5558			return true
  5559		}
  5560		// match: (And64 (Lsh64x64 _ (Const64 [c])) (Const64 [m]))
  5561		// cond: c >= 64-nlz(m)
  5562		// result: (Const64 [0])
  5563		for {
  5564			_ = v.Args[1]
  5565			v_0 := v.Args[0]
  5566			if v_0.Op != OpLsh64x64 {
  5567				break
  5568			}
  5569			_ = v_0.Args[1]
  5570			v_0_1 := v_0.Args[1]
  5571			if v_0_1.Op != OpConst64 {
  5572				break
  5573			}
  5574			c := v_0_1.AuxInt
  5575			v_1 := v.Args[1]
  5576			if v_1.Op != OpConst64 {
  5577				break
  5578			}
  5579			m := v_1.AuxInt
  5580			if !(c >= 64-nlz(m)) {
  5581				break
  5582			}
  5583			v.reset(OpConst64)
  5584			v.AuxInt = 0
  5585			return true
  5586		}
  5587		// match: (And64 x x)
  5588		// cond:
  5589		// result: x
  5590		for {
  5591			x := v.Args[1]
  5592			if x != v.Args[0] {
  5593				break
  5594			}
  5595			v.reset(OpCopy)
  5596			v.Type = x.Type
  5597			v.AddArg(x)
  5598			return true
  5599		}
  5600		// match: (And64 (Const64 [-1]) x)
  5601		// cond:
  5602		// result: x
  5603		for {
  5604			x := v.Args[1]
  5605			v_0 := v.Args[0]
  5606			if v_0.Op != OpConst64 {
  5607				break
  5608			}
  5609			if v_0.AuxInt != -1 {
  5610				break
  5611			}
  5612			v.reset(OpCopy)
  5613			v.Type = x.Type
  5614			v.AddArg(x)
  5615			return true
  5616		}
  5617		// match: (And64 x (Const64 [-1]))
  5618		// cond:
  5619		// result: x
  5620		for {
  5621			_ = v.Args[1]
  5622			x := v.Args[0]
  5623			v_1 := v.Args[1]
  5624			if v_1.Op != OpConst64 {
  5625				break
  5626			}
  5627			if v_1.AuxInt != -1 {
  5628				break
  5629			}
  5630			v.reset(OpCopy)
  5631			v.Type = x.Type
  5632			v.AddArg(x)
  5633			return true
  5634		}
  5635		// match: (And64 (Const64 [0]) _)
  5636		// cond:
  5637		// result: (Const64 [0])
  5638		for {
  5639			_ = v.Args[1]
  5640			v_0 := v.Args[0]
  5641			if v_0.Op != OpConst64 {
  5642				break
  5643			}
  5644			if v_0.AuxInt != 0 {
  5645				break
  5646			}
  5647			v.reset(OpConst64)
  5648			v.AuxInt = 0
  5649			return true
  5650		}
  5651		return false
  5652	}
  5653	func rewriteValuegeneric_OpAnd64_10(v *Value) bool {
  5654		b := v.Block
  5655		// match: (And64 _ (Const64 [0]))
  5656		// cond:
  5657		// result: (Const64 [0])
  5658		for {
  5659			_ = v.Args[1]
  5660			v_1 := v.Args[1]
  5661			if v_1.Op != OpConst64 {
  5662				break
  5663			}
  5664			if v_1.AuxInt != 0 {
  5665				break
  5666			}
  5667			v.reset(OpConst64)
  5668			v.AuxInt = 0
  5669			return true
  5670		}
  5671		// match: (And64 x (And64 x y))
  5672		// cond:
  5673		// result: (And64 x y)
  5674		for {
  5675			_ = v.Args[1]
  5676			x := v.Args[0]
  5677			v_1 := v.Args[1]
  5678			if v_1.Op != OpAnd64 {
  5679				break
  5680			}
  5681			y := v_1.Args[1]
  5682			if x != v_1.Args[0] {
  5683				break
  5684			}
  5685			v.reset(OpAnd64)
  5686			v.AddArg(x)
  5687			v.AddArg(y)
  5688			return true
  5689		}
  5690		// match: (And64 x (And64 y x))
  5691		// cond:
  5692		// result: (And64 x y)
  5693		for {
  5694			_ = v.Args[1]
  5695			x := v.Args[0]
  5696			v_1 := v.Args[1]
  5697			if v_1.Op != OpAnd64 {
  5698				break
  5699			}
  5700			_ = v_1.Args[1]
  5701			y := v_1.Args[0]
  5702			if x != v_1.Args[1] {
  5703				break
  5704			}
  5705			v.reset(OpAnd64)
  5706			v.AddArg(x)
  5707			v.AddArg(y)
  5708			return true
  5709		}
  5710		// match: (And64 (And64 x y) x)
  5711		// cond:
  5712		// result: (And64 x y)
  5713		for {
  5714			x := v.Args[1]
  5715			v_0 := v.Args[0]
  5716			if v_0.Op != OpAnd64 {
  5717				break
  5718			}
  5719			y := v_0.Args[1]
  5720			if x != v_0.Args[0] {
  5721				break
  5722			}
  5723			v.reset(OpAnd64)
  5724			v.AddArg(x)
  5725			v.AddArg(y)
  5726			return true
  5727		}
  5728		// match: (And64 (And64 y x) x)
  5729		// cond:
  5730		// result: (And64 x y)
  5731		for {
  5732			x := v.Args[1]
  5733			v_0 := v.Args[0]
  5734			if v_0.Op != OpAnd64 {
  5735				break
  5736			}
  5737			_ = v_0.Args[1]
  5738			y := v_0.Args[0]
  5739			if x != v_0.Args[1] {
  5740				break
  5741			}
  5742			v.reset(OpAnd64)
  5743			v.AddArg(x)
  5744			v.AddArg(y)
  5745			return true
  5746		}
  5747		// match: (And64 <t> (Const64 [y]) x)
  5748		// cond: nlz(y) + nto(y) == 64 && nto(y) >= 32
  5749		// result: (Rsh64Ux64 (Lsh64x64 <t> x (Const64 <t> [nlz(y)])) (Const64 <t> [nlz(y)]))
  5750		for {
  5751			t := v.Type
  5752			x := v.Args[1]
  5753			v_0 := v.Args[0]
  5754			if v_0.Op != OpConst64 {
  5755				break
  5756			}
  5757			y := v_0.AuxInt
  5758			if !(nlz(y)+nto(y) == 64 && nto(y) >= 32) {
  5759				break
  5760			}
  5761			v.reset(OpRsh64Ux64)
  5762			v0 := b.NewValue0(v.Pos, OpLsh64x64, t)
  5763			v0.AddArg(x)
  5764			v1 := b.NewValue0(v.Pos, OpConst64, t)
  5765			v1.AuxInt = nlz(y)
  5766			v0.AddArg(v1)
  5767			v.AddArg(v0)
  5768			v2 := b.NewValue0(v.Pos, OpConst64, t)
  5769			v2.AuxInt = nlz(y)
  5770			v.AddArg(v2)
  5771			return true
  5772		}
  5773		// match: (And64 <t> x (Const64 [y]))
  5774		// cond: nlz(y) + nto(y) == 64 && nto(y) >= 32
  5775		// result: (Rsh64Ux64 (Lsh64x64 <t> x (Const64 <t> [nlz(y)])) (Const64 <t> [nlz(y)]))
  5776		for {
  5777			t := v.Type
  5778			_ = v.Args[1]
  5779			x := v.Args[0]
  5780			v_1 := v.Args[1]
  5781			if v_1.Op != OpConst64 {
  5782				break
  5783			}
  5784			y := v_1.AuxInt
  5785			if !(nlz(y)+nto(y) == 64 && nto(y) >= 32) {
  5786				break
  5787			}
  5788			v.reset(OpRsh64Ux64)
  5789			v0 := b.NewValue0(v.Pos, OpLsh64x64, t)
  5790			v0.AddArg(x)
  5791			v1 := b.NewValue0(v.Pos, OpConst64, t)
  5792			v1.AuxInt = nlz(y)
  5793			v0.AddArg(v1)
  5794			v.AddArg(v0)
  5795			v2 := b.NewValue0(v.Pos, OpConst64, t)
  5796			v2.AuxInt = nlz(y)
  5797			v.AddArg(v2)
  5798			return true
  5799		}
  5800		// match: (And64 <t> (Const64 [y]) x)
  5801		// cond: nlo(y) + ntz(y) == 64 && ntz(y) >= 32
  5802		// result: (Lsh64x64 (Rsh64Ux64 <t> x (Const64 <t> [ntz(y)])) (Const64 <t> [ntz(y)]))
  5803		for {
  5804			t := v.Type
  5805			x := v.Args[1]
  5806			v_0 := v.Args[0]
  5807			if v_0.Op != OpConst64 {
  5808				break
  5809			}
  5810			y := v_0.AuxInt
  5811			if !(nlo(y)+ntz(y) == 64 && ntz(y) >= 32) {
  5812				break
  5813			}
  5814			v.reset(OpLsh64x64)
  5815			v0 := b.NewValue0(v.Pos, OpRsh64Ux64, t)
  5816			v0.AddArg(x)
  5817			v1 := b.NewValue0(v.Pos, OpConst64, t)
  5818			v1.AuxInt = ntz(y)
  5819			v0.AddArg(v1)
  5820			v.AddArg(v0)
  5821			v2 := b.NewValue0(v.Pos, OpConst64, t)
  5822			v2.AuxInt = ntz(y)
  5823			v.AddArg(v2)
  5824			return true
  5825		}
  5826		// match: (And64 <t> x (Const64 [y]))
  5827		// cond: nlo(y) + ntz(y) == 64 && ntz(y) >= 32
  5828		// result: (Lsh64x64 (Rsh64Ux64 <t> x (Const64 <t> [ntz(y)])) (Const64 <t> [ntz(y)]))
  5829		for {
  5830			t := v.Type
  5831			_ = v.Args[1]
  5832			x := v.Args[0]
  5833			v_1 := v.Args[1]
  5834			if v_1.Op != OpConst64 {
  5835				break
  5836			}
  5837			y := v_1.AuxInt
  5838			if !(nlo(y)+ntz(y) == 64 && ntz(y) >= 32) {
  5839				break
  5840			}
  5841			v.reset(OpLsh64x64)
  5842			v0 := b.NewValue0(v.Pos, OpRsh64Ux64, t)
  5843			v0.AddArg(x)
  5844			v1 := b.NewValue0(v.Pos, OpConst64, t)
  5845			v1.AuxInt = ntz(y)
  5846			v0.AddArg(v1)
  5847			v.AddArg(v0)
  5848			v2 := b.NewValue0(v.Pos, OpConst64, t)
  5849			v2.AuxInt = ntz(y)
  5850			v.AddArg(v2)
  5851			return true
  5852		}
  5853		// match: (And64 (And64 i:(Const64 <t>) z) x)
  5854		// cond: (z.Op != OpConst64 && x.Op != OpConst64)
  5855		// result: (And64 i (And64 <t> z x))
  5856		for {
  5857			x := v.Args[1]
  5858			v_0 := v.Args[0]
  5859			if v_0.Op != OpAnd64 {
  5860				break
  5861			}
  5862			z := v_0.Args[1]
  5863			i := v_0.Args[0]
  5864			if i.Op != OpConst64 {
  5865				break
  5866			}
  5867			t := i.Type
  5868			if !(z.Op != OpConst64 && x.Op != OpConst64) {
  5869				break
  5870			}
  5871			v.reset(OpAnd64)
  5872			v.AddArg(i)
  5873			v0 := b.NewValue0(v.Pos, OpAnd64, t)
  5874			v0.AddArg(z)
  5875			v0.AddArg(x)
  5876			v.AddArg(v0)
  5877			return true
  5878		}
  5879		return false
  5880	}
  5881	func rewriteValuegeneric_OpAnd64_20(v *Value) bool {
  5882		b := v.Block
  5883		// match: (And64 (And64 z i:(Const64 <t>)) x)
  5884		// cond: (z.Op != OpConst64 && x.Op != OpConst64)
  5885		// result: (And64 i (And64 <t> z x))
  5886		for {
  5887			x := v.Args[1]
  5888			v_0 := v.Args[0]
  5889			if v_0.Op != OpAnd64 {
  5890				break
  5891			}
  5892			_ = v_0.Args[1]
  5893			z := v_0.Args[0]
  5894			i := v_0.Args[1]
  5895			if i.Op != OpConst64 {
  5896				break
  5897			}
  5898			t := i.Type
  5899			if !(z.Op != OpConst64 && x.Op != OpConst64) {
  5900				break
  5901			}
  5902			v.reset(OpAnd64)
  5903			v.AddArg(i)
  5904			v0 := b.NewValue0(v.Pos, OpAnd64, t)
  5905			v0.AddArg(z)
  5906			v0.AddArg(x)
  5907			v.AddArg(v0)
  5908			return true
  5909		}
  5910		// match: (And64 x (And64 i:(Const64 <t>) z))
  5911		// cond: (z.Op != OpConst64 && x.Op != OpConst64)
  5912		// result: (And64 i (And64 <t> z x))
  5913		for {
  5914			_ = v.Args[1]
  5915			x := v.Args[0]
  5916			v_1 := v.Args[1]
  5917			if v_1.Op != OpAnd64 {
  5918				break
  5919			}
  5920			z := v_1.Args[1]
  5921			i := v_1.Args[0]
  5922			if i.Op != OpConst64 {
  5923				break
  5924			}
  5925			t := i.Type
  5926			if !(z.Op != OpConst64 && x.Op != OpConst64) {
  5927				break
  5928			}
  5929			v.reset(OpAnd64)
  5930			v.AddArg(i)
  5931			v0 := b.NewValue0(v.Pos, OpAnd64, t)
  5932			v0.AddArg(z)
  5933			v0.AddArg(x)
  5934			v.AddArg(v0)
  5935			return true
  5936		}
  5937		// match: (And64 x (And64 z i:(Const64 <t>)))
  5938		// cond: (z.Op != OpConst64 && x.Op != OpConst64)
  5939		// result: (And64 i (And64 <t> z x))
  5940		for {
  5941			_ = v.Args[1]
  5942			x := v.Args[0]
  5943			v_1 := v.Args[1]
  5944			if v_1.Op != OpAnd64 {
  5945				break
  5946			}
  5947			_ = v_1.Args[1]
  5948			z := v_1.Args[0]
  5949			i := v_1.Args[1]
  5950			if i.Op != OpConst64 {
  5951				break
  5952			}
  5953			t := i.Type
  5954			if !(z.Op != OpConst64 && x.Op != OpConst64) {
  5955				break
  5956			}
  5957			v.reset(OpAnd64)
  5958			v.AddArg(i)
  5959			v0 := b.NewValue0(v.Pos, OpAnd64, t)
  5960			v0.AddArg(z)
  5961			v0.AddArg(x)
  5962			v.AddArg(v0)
  5963			return true
  5964		}
  5965		// match: (And64 (Const64 <t> [c]) (And64 (Const64 <t> [d]) x))
  5966		// cond:
  5967		// result: (And64 (Const64 <t> [c&d]) x)
  5968		for {
  5969			_ = v.Args[1]
  5970			v_0 := v.Args[0]
  5971			if v_0.Op != OpConst64 {
  5972				break
  5973			}
  5974			t := v_0.Type
  5975			c := v_0.AuxInt
  5976			v_1 := v.Args[1]
  5977			if v_1.Op != OpAnd64 {
  5978				break
  5979			}
  5980			x := v_1.Args[1]
  5981			v_1_0 := v_1.Args[0]
  5982			if v_1_0.Op != OpConst64 {
  5983				break
  5984			}
  5985			if v_1_0.Type != t {
  5986				break
  5987			}
  5988			d := v_1_0.AuxInt
  5989			v.reset(OpAnd64)
  5990			v0 := b.NewValue0(v.Pos, OpConst64, t)
  5991			v0.AuxInt = c & d
  5992			v.AddArg(v0)
  5993			v.AddArg(x)
  5994			return true
  5995		}
  5996		// match: (And64 (Const64 <t> [c]) (And64 x (Const64 <t> [d])))
  5997		// cond:
  5998		// result: (And64 (Const64 <t> [c&d]) x)
  5999		for {
  6000			_ = v.Args[1]
  6001			v_0 := v.Args[0]
  6002			if v_0.Op != OpConst64 {
  6003				break
  6004			}
  6005			t := v_0.Type
  6006			c := v_0.AuxInt
  6007			v_1 := v.Args[1]
  6008			if v_1.Op != OpAnd64 {
  6009				break
  6010			}
  6011			_ = v_1.Args[1]
  6012			x := v_1.Args[0]
  6013			v_1_1 := v_1.Args[1]
  6014			if v_1_1.Op != OpConst64 {
  6015				break
  6016			}
  6017			if v_1_1.Type != t {
  6018				break
  6019			}
  6020			d := v_1_1.AuxInt
  6021			v.reset(OpAnd64)
  6022			v0 := b.NewValue0(v.Pos, OpConst64, t)
  6023			v0.AuxInt = c & d
  6024			v.AddArg(v0)
  6025			v.AddArg(x)
  6026			return true
  6027		}
  6028		// match: (And64 (And64 (Const64 <t> [d]) x) (Const64 <t> [c]))
  6029		// cond:
  6030		// result: (And64 (Const64 <t> [c&d]) x)
  6031		for {
  6032			_ = v.Args[1]
  6033			v_0 := v.Args[0]
  6034			if v_0.Op != OpAnd64 {
  6035				break
  6036			}
  6037			x := v_0.Args[1]
  6038			v_0_0 := v_0.Args[0]
  6039			if v_0_0.Op != OpConst64 {
  6040				break
  6041			}
  6042			t := v_0_0.Type
  6043			d := v_0_0.AuxInt
  6044			v_1 := v.Args[1]
  6045			if v_1.Op != OpConst64 {
  6046				break
  6047			}
  6048			if v_1.Type != t {
  6049				break
  6050			}
  6051			c := v_1.AuxInt
  6052			v.reset(OpAnd64)
  6053			v0 := b.NewValue0(v.Pos, OpConst64, t)
  6054			v0.AuxInt = c & d
  6055			v.AddArg(v0)
  6056			v.AddArg(x)
  6057			return true
  6058		}
  6059		// match: (And64 (And64 x (Const64 <t> [d])) (Const64 <t> [c]))
  6060		// cond:
  6061		// result: (And64 (Const64 <t> [c&d]) x)
  6062		for {
  6063			_ = v.Args[1]
  6064			v_0 := v.Args[0]
  6065			if v_0.Op != OpAnd64 {
  6066				break
  6067			}
  6068			_ = v_0.Args[1]
  6069			x := v_0.Args[0]
  6070			v_0_1 := v_0.Args[1]
  6071			if v_0_1.Op != OpConst64 {
  6072				break
  6073			}
  6074			t := v_0_1.Type
  6075			d := v_0_1.AuxInt
  6076			v_1 := v.Args[1]
  6077			if v_1.Op != OpConst64 {
  6078				break
  6079			}
  6080			if v_1.Type != t {
  6081				break
  6082			}
  6083			c := v_1.AuxInt
  6084			v.reset(OpAnd64)
  6085			v0 := b.NewValue0(v.Pos, OpConst64, t)
  6086			v0.AuxInt = c & d
  6087			v.AddArg(v0)
  6088			v.AddArg(x)
  6089			return true
  6090		}
  6091		return false
  6092	}
  6093	func rewriteValuegeneric_OpAnd8_0(v *Value) bool {
  6094		// match: (And8 (Const8 [c]) (Const8 [d]))
  6095		// cond:
  6096		// result: (Const8 [int64(int8(c&d))])
  6097		for {
  6098			_ = v.Args[1]
  6099			v_0 := v.Args[0]
  6100			if v_0.Op != OpConst8 {
  6101				break
  6102			}
  6103			c := v_0.AuxInt
  6104			v_1 := v.Args[1]
  6105			if v_1.Op != OpConst8 {
  6106				break
  6107			}
  6108			d := v_1.AuxInt
  6109			v.reset(OpConst8)
  6110			v.AuxInt = int64(int8(c & d))
  6111			return true
  6112		}
  6113		// match: (And8 (Const8 [d]) (Const8 [c]))
  6114		// cond:
  6115		// result: (Const8 [int64(int8(c&d))])
  6116		for {
  6117			_ = v.Args[1]
  6118			v_0 := v.Args[0]
  6119			if v_0.Op != OpConst8 {
  6120				break
  6121			}
  6122			d := v_0.AuxInt
  6123			v_1 := v.Args[1]
  6124			if v_1.Op != OpConst8 {
  6125				break
  6126			}
  6127			c := v_1.AuxInt
  6128			v.reset(OpConst8)
  6129			v.AuxInt = int64(int8(c & d))
  6130			return true
  6131		}
  6132		// match: (And8 (Const8 [m]) (Rsh8Ux64 _ (Const64 [c])))
  6133		// cond: c >= 64-ntz(m)
  6134		// result: (Const8 [0])
  6135		for {
  6136			_ = v.Args[1]
  6137			v_0 := v.Args[0]
  6138			if v_0.Op != OpConst8 {
  6139				break
  6140			}
  6141			m := v_0.AuxInt
  6142			v_1 := v.Args[1]
  6143			if v_1.Op != OpRsh8Ux64 {
  6144				break
  6145			}
  6146			_ = v_1.Args[1]
  6147			v_1_1 := v_1.Args[1]
  6148			if v_1_1.Op != OpConst64 {
  6149				break
  6150			}
  6151			c := v_1_1.AuxInt
  6152			if !(c >= 64-ntz(m)) {
  6153				break
  6154			}
  6155			v.reset(OpConst8)
  6156			v.AuxInt = 0
  6157			return true
  6158		}
  6159		// match: (And8 (Rsh8Ux64 _ (Const64 [c])) (Const8 [m]))
  6160		// cond: c >= 64-ntz(m)
  6161		// result: (Const8 [0])
  6162		for {
  6163			_ = v.Args[1]
  6164			v_0 := v.Args[0]
  6165			if v_0.Op != OpRsh8Ux64 {
  6166				break
  6167			}
  6168			_ = v_0.Args[1]
  6169			v_0_1 := v_0.Args[1]
  6170			if v_0_1.Op != OpConst64 {
  6171				break
  6172			}
  6173			c := v_0_1.AuxInt
  6174			v_1 := v.Args[1]
  6175			if v_1.Op != OpConst8 {
  6176				break
  6177			}
  6178			m := v_1.AuxInt
  6179			if !(c >= 64-ntz(m)) {
  6180				break
  6181			}
  6182			v.reset(OpConst8)
  6183			v.AuxInt = 0
  6184			return true
  6185		}
  6186		// match: (And8 (Const8 [m]) (Lsh8x64 _ (Const64 [c])))
  6187		// cond: c >= 64-nlz(m)
  6188		// result: (Const8 [0])
  6189		for {
  6190			_ = v.Args[1]
  6191			v_0 := v.Args[0]
  6192			if v_0.Op != OpConst8 {
  6193				break
  6194			}
  6195			m := v_0.AuxInt
  6196			v_1 := v.Args[1]
  6197			if v_1.Op != OpLsh8x64 {
  6198				break
  6199			}
  6200			_ = v_1.Args[1]
  6201			v_1_1 := v_1.Args[1]
  6202			if v_1_1.Op != OpConst64 {
  6203				break
  6204			}
  6205			c := v_1_1.AuxInt
  6206			if !(c >= 64-nlz(m)) {
  6207				break
  6208			}
  6209			v.reset(OpConst8)
  6210			v.AuxInt = 0
  6211			return true
  6212		}
  6213		// match: (And8 (Lsh8x64 _ (Const64 [c])) (Const8 [m]))
  6214		// cond: c >= 64-nlz(m)
  6215		// result: (Const8 [0])
  6216		for {
  6217			_ = v.Args[1]
  6218			v_0 := v.Args[0]
  6219			if v_0.Op != OpLsh8x64 {
  6220				break
  6221			}
  6222			_ = v_0.Args[1]
  6223			v_0_1 := v_0.Args[1]
  6224			if v_0_1.Op != OpConst64 {
  6225				break
  6226			}
  6227			c := v_0_1.AuxInt
  6228			v_1 := v.Args[1]
  6229			if v_1.Op != OpConst8 {
  6230				break
  6231			}
  6232			m := v_1.AuxInt
  6233			if !(c >= 64-nlz(m)) {
  6234				break
  6235			}
  6236			v.reset(OpConst8)
  6237			v.AuxInt = 0
  6238			return true
  6239		}
  6240		// match: (And8 x x)
  6241		// cond:
  6242		// result: x
  6243		for {
  6244			x := v.Args[1]
  6245			if x != v.Args[0] {
  6246				break
  6247			}
  6248			v.reset(OpCopy)
  6249			v.Type = x.Type
  6250			v.AddArg(x)
  6251			return true
  6252		}
  6253		// match: (And8 (Const8 [-1]) x)
  6254		// cond:
  6255		// result: x
  6256		for {
  6257			x := v.Args[1]
  6258			v_0 := v.Args[0]
  6259			if v_0.Op != OpConst8 {
  6260				break
  6261			}
  6262			if v_0.AuxInt != -1 {
  6263				break
  6264			}
  6265			v.reset(OpCopy)
  6266			v.Type = x.Type
  6267			v.AddArg(x)
  6268			return true
  6269		}
  6270		// match: (And8 x (Const8 [-1]))
  6271		// cond:
  6272		// result: x
  6273		for {
  6274			_ = v.Args[1]
  6275			x := v.Args[0]
  6276			v_1 := v.Args[1]
  6277			if v_1.Op != OpConst8 {
  6278				break
  6279			}
  6280			if v_1.AuxInt != -1 {
  6281				break
  6282			}
  6283			v.reset(OpCopy)
  6284			v.Type = x.Type
  6285			v.AddArg(x)
  6286			return true
  6287		}
  6288		// match: (And8 (Const8 [0]) _)
  6289		// cond:
  6290		// result: (Const8 [0])
  6291		for {
  6292			_ = v.Args[1]
  6293			v_0 := v.Args[0]
  6294			if v_0.Op != OpConst8 {
  6295				break
  6296			}
  6297			if v_0.AuxInt != 0 {
  6298				break
  6299			}
  6300			v.reset(OpConst8)
  6301			v.AuxInt = 0
  6302			return true
  6303		}
  6304		return false
  6305	}
  6306	func rewriteValuegeneric_OpAnd8_10(v *Value) bool {
  6307		b := v.Block
  6308		// match: (And8 _ (Const8 [0]))
  6309		// cond:
  6310		// result: (Const8 [0])
  6311		for {
  6312			_ = v.Args[1]
  6313			v_1 := v.Args[1]
  6314			if v_1.Op != OpConst8 {
  6315				break
  6316			}
  6317			if v_1.AuxInt != 0 {
  6318				break
  6319			}
  6320			v.reset(OpConst8)
  6321			v.AuxInt = 0
  6322			return true
  6323		}
  6324		// match: (And8 x (And8 x y))
  6325		// cond:
  6326		// result: (And8 x y)
  6327		for {
  6328			_ = v.Args[1]
  6329			x := v.Args[0]
  6330			v_1 := v.Args[1]
  6331			if v_1.Op != OpAnd8 {
  6332				break
  6333			}
  6334			y := v_1.Args[1]
  6335			if x != v_1.Args[0] {
  6336				break
  6337			}
  6338			v.reset(OpAnd8)
  6339			v.AddArg(x)
  6340			v.AddArg(y)
  6341			return true
  6342		}
  6343		// match: (And8 x (And8 y x))
  6344		// cond:
  6345		// result: (And8 x y)
  6346		for {
  6347			_ = v.Args[1]
  6348			x := v.Args[0]
  6349			v_1 := v.Args[1]
  6350			if v_1.Op != OpAnd8 {
  6351				break
  6352			}
  6353			_ = v_1.Args[1]
  6354			y := v_1.Args[0]
  6355			if x != v_1.Args[1] {
  6356				break
  6357			}
  6358			v.reset(OpAnd8)
  6359			v.AddArg(x)
  6360			v.AddArg(y)
  6361			return true
  6362		}
  6363		// match: (And8 (And8 x y) x)
  6364		// cond:
  6365		// result: (And8 x y)
  6366		for {
  6367			x := v.Args[1]
  6368			v_0 := v.Args[0]
  6369			if v_0.Op != OpAnd8 {
  6370				break
  6371			}
  6372			y := v_0.Args[1]
  6373			if x != v_0.Args[0] {
  6374				break
  6375			}
  6376			v.reset(OpAnd8)
  6377			v.AddArg(x)
  6378			v.AddArg(y)
  6379			return true
  6380		}
  6381		// match: (And8 (And8 y x) x)
  6382		// cond:
  6383		// result: (And8 x y)
  6384		for {
  6385			x := v.Args[1]
  6386			v_0 := v.Args[0]
  6387			if v_0.Op != OpAnd8 {
  6388				break
  6389			}
  6390			_ = v_0.Args[1]
  6391			y := v_0.Args[0]
  6392			if x != v_0.Args[1] {
  6393				break
  6394			}
  6395			v.reset(OpAnd8)
  6396			v.AddArg(x)
  6397			v.AddArg(y)
  6398			return true
  6399		}
  6400		// match: (And8 (And8 i:(Const8 <t>) z) x)
  6401		// cond: (z.Op != OpConst8 && x.Op != OpConst8)
  6402		// result: (And8 i (And8 <t> z x))
  6403		for {
  6404			x := v.Args[1]
  6405			v_0 := v.Args[0]
  6406			if v_0.Op != OpAnd8 {
  6407				break
  6408			}
  6409			z := v_0.Args[1]
  6410			i := v_0.Args[0]
  6411			if i.Op != OpConst8 {
  6412				break
  6413			}
  6414			t := i.Type
  6415			if !(z.Op != OpConst8 && x.Op != OpConst8) {
  6416				break
  6417			}
  6418			v.reset(OpAnd8)
  6419			v.AddArg(i)
  6420			v0 := b.NewValue0(v.Pos, OpAnd8, t)
  6421			v0.AddArg(z)
  6422			v0.AddArg(x)
  6423			v.AddArg(v0)
  6424			return true
  6425		}
  6426		// match: (And8 (And8 z i:(Const8 <t>)) x)
  6427		// cond: (z.Op != OpConst8 && x.Op != OpConst8)
  6428		// result: (And8 i (And8 <t> z x))
  6429		for {
  6430			x := v.Args[1]
  6431			v_0 := v.Args[0]
  6432			if v_0.Op != OpAnd8 {
  6433				break
  6434			}
  6435			_ = v_0.Args[1]
  6436			z := v_0.Args[0]
  6437			i := v_0.Args[1]
  6438			if i.Op != OpConst8 {
  6439				break
  6440			}
  6441			t := i.Type
  6442			if !(z.Op != OpConst8 && x.Op != OpConst8) {
  6443				break
  6444			}
  6445			v.reset(OpAnd8)
  6446			v.AddArg(i)
  6447			v0 := b.NewValue0(v.Pos, OpAnd8, t)
  6448			v0.AddArg(z)
  6449			v0.AddArg(x)
  6450			v.AddArg(v0)
  6451			return true
  6452		}
  6453		// match: (And8 x (And8 i:(Const8 <t>) z))
  6454		// cond: (z.Op != OpConst8 && x.Op != OpConst8)
  6455		// result: (And8 i (And8 <t> z x))
  6456		for {
  6457			_ = v.Args[1]
  6458			x := v.Args[0]
  6459			v_1 := v.Args[1]
  6460			if v_1.Op != OpAnd8 {
  6461				break
  6462			}
  6463			z := v_1.Args[1]
  6464			i := v_1.Args[0]
  6465			if i.Op != OpConst8 {
  6466				break
  6467			}
  6468			t := i.Type
  6469			if !(z.Op != OpConst8 && x.Op != OpConst8) {
  6470				break
  6471			}
  6472			v.reset(OpAnd8)
  6473			v.AddArg(i)
  6474			v0 := b.NewValue0(v.Pos, OpAnd8, t)
  6475			v0.AddArg(z)
  6476			v0.AddArg(x)
  6477			v.AddArg(v0)
  6478			return true
  6479		}
  6480		// match: (And8 x (And8 z i:(Const8 <t>)))
  6481		// cond: (z.Op != OpConst8 && x.Op != OpConst8)
  6482		// result: (And8 i (And8 <t> z x))
  6483		for {
  6484			_ = v.Args[1]
  6485			x := v.Args[0]
  6486			v_1 := v.Args[1]
  6487			if v_1.Op != OpAnd8 {
  6488				break
  6489			}
  6490			_ = v_1.Args[1]
  6491			z := v_1.Args[0]
  6492			i := v_1.Args[1]
  6493			if i.Op != OpConst8 {
  6494				break
  6495			}
  6496			t := i.Type
  6497			if !(z.Op != OpConst8 && x.Op != OpConst8) {
  6498				break
  6499			}
  6500			v.reset(OpAnd8)
  6501			v.AddArg(i)
  6502			v0 := b.NewValue0(v.Pos, OpAnd8, t)
  6503			v0.AddArg(z)
  6504			v0.AddArg(x)
  6505			v.AddArg(v0)
  6506			return true
  6507		}
  6508		// match: (And8 (Const8 <t> [c]) (And8 (Const8 <t> [d]) x))
  6509		// cond:
  6510		// result: (And8 (Const8 <t> [int64(int8(c&d))]) x)
  6511		for {
  6512			_ = v.Args[1]
  6513			v_0 := v.Args[0]
  6514			if v_0.Op != OpConst8 {
  6515				break
  6516			}
  6517			t := v_0.Type
  6518			c := v_0.AuxInt
  6519			v_1 := v.Args[1]
  6520			if v_1.Op != OpAnd8 {
  6521				break
  6522			}
  6523			x := v_1.Args[1]
  6524			v_1_0 := v_1.Args[0]
  6525			if v_1_0.Op != OpConst8 {
  6526				break
  6527			}
  6528			if v_1_0.Type != t {
  6529				break
  6530			}
  6531			d := v_1_0.AuxInt
  6532			v.reset(OpAnd8)
  6533			v0 := b.NewValue0(v.Pos, OpConst8, t)
  6534			v0.AuxInt = int64(int8(c & d))
  6535			v.AddArg(v0)
  6536			v.AddArg(x)
  6537			return true
  6538		}
  6539		return false
  6540	}
  6541	func rewriteValuegeneric_OpAnd8_20(v *Value) bool {
  6542		b := v.Block
  6543		// match: (And8 (Const8 <t> [c]) (And8 x (Const8 <t> [d])))
  6544		// cond:
  6545		// result: (And8 (Const8 <t> [int64(int8(c&d))]) x)
  6546		for {
  6547			_ = v.Args[1]
  6548			v_0 := v.Args[0]
  6549			if v_0.Op != OpConst8 {
  6550				break
  6551			}
  6552			t := v_0.Type
  6553			c := v_0.AuxInt
  6554			v_1 := v.Args[1]
  6555			if v_1.Op != OpAnd8 {
  6556				break
  6557			}
  6558			_ = v_1.Args[1]
  6559			x := v_1.Args[0]
  6560			v_1_1 := v_1.Args[1]
  6561			if v_1_1.Op != OpConst8 {
  6562				break
  6563			}
  6564			if v_1_1.Type != t {
  6565				break
  6566			}
  6567			d := v_1_1.AuxInt
  6568			v.reset(OpAnd8)
  6569			v0 := b.NewValue0(v.Pos, OpConst8, t)
  6570			v0.AuxInt = int64(int8(c & d))
  6571			v.AddArg(v0)
  6572			v.AddArg(x)
  6573			return true
  6574		}
  6575		// match: (And8 (And8 (Const8 <t> [d]) x) (Const8 <t> [c]))
  6576		// cond:
  6577		// result: (And8 (Const8 <t> [int64(int8(c&d))]) x)
  6578		for {
  6579			_ = v.Args[1]
  6580			v_0 := v.Args[0]
  6581			if v_0.Op != OpAnd8 {
  6582				break
  6583			}
  6584			x := v_0.Args[1]
  6585			v_0_0 := v_0.Args[0]
  6586			if v_0_0.Op != OpConst8 {
  6587				break
  6588			}
  6589			t := v_0_0.Type
  6590			d := v_0_0.AuxInt
  6591			v_1 := v.Args[1]
  6592			if v_1.Op != OpConst8 {
  6593				break
  6594			}
  6595			if v_1.Type != t {
  6596				break
  6597			}
  6598			c := v_1.AuxInt
  6599			v.reset(OpAnd8)
  6600			v0 := b.NewValue0(v.Pos, OpConst8, t)
  6601			v0.AuxInt = int64(int8(c & d))
  6602			v.AddArg(v0)
  6603			v.AddArg(x)
  6604			return true
  6605		}
  6606		// match: (And8 (And8 x (Const8 <t> [d])) (Const8 <t> [c]))
  6607		// cond:
  6608		// result: (And8 (Const8 <t> [int64(int8(c&d))]) x)
  6609		for {
  6610			_ = v.Args[1]
  6611			v_0 := v.Args[0]
  6612			if v_0.Op != OpAnd8 {
  6613				break
  6614			}
  6615			_ = v_0.Args[1]
  6616			x := v_0.Args[0]
  6617			v_0_1 := v_0.Args[1]
  6618			if v_0_1.Op != OpConst8 {
  6619				break
  6620			}
  6621			t := v_0_1.Type
  6622			d := v_0_1.AuxInt
  6623			v_1 := v.Args[1]
  6624			if v_1.Op != OpConst8 {
  6625				break
  6626			}
  6627			if v_1.Type != t {
  6628				break
  6629			}
  6630			c := v_1.AuxInt
  6631			v.reset(OpAnd8)
  6632			v0 := b.NewValue0(v.Pos, OpConst8, t)
  6633			v0.AuxInt = int64(int8(c & d))
  6634			v.AddArg(v0)
  6635			v.AddArg(x)
  6636			return true
  6637		}
  6638		return false
  6639	}
  6640	func rewriteValuegeneric_OpArraySelect_0(v *Value) bool {
  6641		// match: (ArraySelect (ArrayMake1 x))
  6642		// cond:
  6643		// result: x
  6644		for {
  6645			v_0 := v.Args[0]
  6646			if v_0.Op != OpArrayMake1 {
  6647				break
  6648			}
  6649			x := v_0.Args[0]
  6650			v.reset(OpCopy)
  6651			v.Type = x.Type
  6652			v.AddArg(x)
  6653			return true
  6654		}
  6655		// match: (ArraySelect [0] x:(IData _))
  6656		// cond:
  6657		// result: x
  6658		for {
  6659			if v.AuxInt != 0 {
  6660				break
  6661			}
  6662			x := v.Args[0]
  6663			if x.Op != OpIData {
  6664				break
  6665			}
  6666			v.reset(OpCopy)
  6667			v.Type = x.Type
  6668			v.AddArg(x)
  6669			return true
  6670		}
  6671		return false
  6672	}
  6673	func rewriteValuegeneric_OpCom16_0(v *Value) bool {
  6674		// match: (Com16 (Com16 x))
  6675		// cond:
  6676		// result: x
  6677		for {
  6678			v_0 := v.Args[0]
  6679			if v_0.Op != OpCom16 {
  6680				break
  6681			}
  6682			x := v_0.Args[0]
  6683			v.reset(OpCopy)
  6684			v.Type = x.Type
  6685			v.AddArg(x)
  6686			return true
  6687		}
  6688		// match: (Com16 (Const16 [c]))
  6689		// cond:
  6690		// result: (Const16 [^c])
  6691		for {
  6692			v_0 := v.Args[0]
  6693			if v_0.Op != OpConst16 {
  6694				break
  6695			}
  6696			c := v_0.AuxInt
  6697			v.reset(OpConst16)
  6698			v.AuxInt = ^c
  6699			return true
  6700		}
  6701		return false
  6702	}
  6703	func rewriteValuegeneric_OpCom32_0(v *Value) bool {
  6704		// match: (Com32 (Com32 x))
  6705		// cond:
  6706		// result: x
  6707		for {
  6708			v_0 := v.Args[0]
  6709			if v_0.Op != OpCom32 {
  6710				break
  6711			}
  6712			x := v_0.Args[0]
  6713			v.reset(OpCopy)
  6714			v.Type = x.Type
  6715			v.AddArg(x)
  6716			return true
  6717		}
  6718		// match: (Com32 (Const32 [c]))
  6719		// cond:
  6720		// result: (Const32 [^c])
  6721		for {
  6722			v_0 := v.Args[0]
  6723			if v_0.Op != OpConst32 {
  6724				break
  6725			}
  6726			c := v_0.AuxInt
  6727			v.reset(OpConst32)
  6728			v.AuxInt = ^c
  6729			return true
  6730		}
  6731		return false
  6732	}
  6733	func rewriteValuegeneric_OpCom64_0(v *Value) bool {
  6734		// match: (Com64 (Com64 x))
  6735		// cond:
  6736		// result: x
  6737		for {
  6738			v_0 := v.Args[0]
  6739			if v_0.Op != OpCom64 {
  6740				break
  6741			}
  6742			x := v_0.Args[0]
  6743			v.reset(OpCopy)
  6744			v.Type = x.Type
  6745			v.AddArg(x)
  6746			return true
  6747		}
  6748		// match: (Com64 (Const64 [c]))
  6749		// cond:
  6750		// result: (Const64 [^c])
  6751		for {
  6752			v_0 := v.Args[0]
  6753			if v_0.Op != OpConst64 {
  6754				break
  6755			}
  6756			c := v_0.AuxInt
  6757			v.reset(OpConst64)
  6758			v.AuxInt = ^c
  6759			return true
  6760		}
  6761		return false
  6762	}
  6763	func rewriteValuegeneric_OpCom8_0(v *Value) bool {
  6764		// match: (Com8 (Com8 x))
  6765		// cond:
  6766		// result: x
  6767		for {
  6768			v_0 := v.Args[0]
  6769			if v_0.Op != OpCom8 {
  6770				break
  6771			}
  6772			x := v_0.Args[0]
  6773			v.reset(OpCopy)
  6774			v.Type = x.Type
  6775			v.AddArg(x)
  6776			return true
  6777		}
  6778		// match: (Com8 (Const8 [c]))
  6779		// cond:
  6780		// result: (Const8 [^c])
  6781		for {
  6782			v_0 := v.Args[0]
  6783			if v_0.Op != OpConst8 {
  6784				break
  6785			}
  6786			c := v_0.AuxInt
  6787			v.reset(OpConst8)
  6788			v.AuxInt = ^c
  6789			return true
  6790		}
  6791		return false
  6792	}
  6793	func rewriteValuegeneric_OpConstInterface_0(v *Value) bool {
  6794		b := v.Block
  6795		typ := &b.Func.Config.Types
  6796		// match: (ConstInterface)
  6797		// cond:
  6798		// result: (IMake (ConstNil <typ.Uintptr>) (ConstNil <typ.BytePtr>))
  6799		for {
  6800			v.reset(OpIMake)
  6801			v0 := b.NewValue0(v.Pos, OpConstNil, typ.Uintptr)
  6802			v.AddArg(v0)
  6803			v1 := b.NewValue0(v.Pos, OpConstNil, typ.BytePtr)
  6804			v.AddArg(v1)
  6805			return true
  6806		}
  6807	}
  6808	func rewriteValuegeneric_OpConstSlice_0(v *Value) bool {
  6809		b := v.Block
  6810		config := b.Func.Config
  6811		typ := &b.Func.Config.Types
  6812		// match: (ConstSlice)
  6813		// cond: config.PtrSize == 4
  6814		// result: (SliceMake (ConstNil <v.Type.Elem().PtrTo()>) (Const32 <typ.Int> [0]) (Const32 <typ.Int> [0]))
  6815		for {
  6816			if !(config.PtrSize == 4) {
  6817				break
  6818			}
  6819			v.reset(OpSliceMake)
  6820			v0 := b.NewValue0(v.Pos, OpConstNil, v.Type.Elem().PtrTo())
  6821			v.AddArg(v0)
  6822			v1 := b.NewValue0(v.Pos, OpConst32, typ.Int)
  6823			v1.AuxInt = 0
  6824			v.AddArg(v1)
  6825			v2 := b.NewValue0(v.Pos, OpConst32, typ.Int)
  6826			v2.AuxInt = 0
  6827			v.AddArg(v2)
  6828			return true
  6829		}
  6830		// match: (ConstSlice)
  6831		// cond: config.PtrSize == 8
  6832		// result: (SliceMake (ConstNil <v.Type.Elem().PtrTo()>) (Const64 <typ.Int> [0]) (Const64 <typ.Int> [0]))
  6833		for {
  6834			if !(config.PtrSize == 8) {
  6835				break
  6836			}
  6837			v.reset(OpSliceMake)
  6838			v0 := b.NewValue0(v.Pos, OpConstNil, v.Type.Elem().PtrTo())
  6839			v.AddArg(v0)
  6840			v1 := b.NewValue0(v.Pos, OpConst64, typ.Int)
  6841			v1.AuxInt = 0
  6842			v.AddArg(v1)
  6843			v2 := b.NewValue0(v.Pos, OpConst64, typ.Int)
  6844			v2.AuxInt = 0
  6845			v.AddArg(v2)
  6846			return true
  6847		}
  6848		return false
  6849	}
  6850	func rewriteValuegeneric_OpConstString_0(v *Value) bool {
  6851		b := v.Block
  6852		config := b.Func.Config
  6853		fe := b.Func.fe
  6854		typ := &b.Func.Config.Types
  6855		// match: (ConstString {s})
  6856		// cond: config.PtrSize == 4 && s.(string) == ""
  6857		// result: (StringMake (ConstNil) (Const32 <typ.Int> [0]))
  6858		for {
  6859			s := v.Aux
  6860			if !(config.PtrSize == 4 && s.(string) == "") {
  6861				break
  6862			}
  6863			v.reset(OpStringMake)
  6864			v0 := b.NewValue0(v.Pos, OpConstNil, typ.BytePtr)
  6865			v.AddArg(v0)
  6866			v1 := b.NewValue0(v.Pos, OpConst32, typ.Int)
  6867			v1.AuxInt = 0
  6868			v.AddArg(v1)
  6869			return true
  6870		}
  6871		// match: (ConstString {s})
  6872		// cond: config.PtrSize == 8 && s.(string) == ""
  6873		// result: (StringMake (ConstNil) (Const64 <typ.Int> [0]))
  6874		for {
  6875			s := v.Aux
  6876			if !(config.PtrSize == 8 && s.(string) == "") {
  6877				break
  6878			}
  6879			v.reset(OpStringMake)
  6880			v0 := b.NewValue0(v.Pos, OpConstNil, typ.BytePtr)
  6881			v.AddArg(v0)
  6882			v1 := b.NewValue0(v.Pos, OpConst64, typ.Int)
  6883			v1.AuxInt = 0
  6884			v.AddArg(v1)
  6885			return true
  6886		}
  6887		// match: (ConstString {s})
  6888		// cond: config.PtrSize == 4 && s.(string) != ""
  6889		// result: (StringMake (Addr <typ.BytePtr> {fe.StringData(s.(string))} (SB)) (Const32 <typ.Int> [int64(len(s.(string)))]))
  6890		for {
  6891			s := v.Aux
  6892			if !(config.PtrSize == 4 && s.(string) != "") {
  6893				break
  6894			}
  6895			v.reset(OpStringMake)
  6896			v0 := b.NewValue0(v.Pos, OpAddr, typ.BytePtr)
  6897			v0.Aux = fe.StringData(s.(string))
  6898			v1 := b.NewValue0(v.Pos, OpSB, typ.Uintptr)
  6899			v0.AddArg(v1)
  6900			v.AddArg(v0)
  6901			v2 := b.NewValue0(v.Pos, OpConst32, typ.Int)
  6902			v2.AuxInt = int64(len(s.(string)))
  6903			v.AddArg(v2)
  6904			return true
  6905		}
  6906		// match: (ConstString {s})
  6907		// cond: config.PtrSize == 8 && s.(string) != ""
  6908		// result: (StringMake (Addr <typ.BytePtr> {fe.StringData(s.(string))} (SB)) (Const64 <typ.Int> [int64(len(s.(string)))]))
  6909		for {
  6910			s := v.Aux
  6911			if !(config.PtrSize == 8 && s.(string) != "") {
  6912				break
  6913			}
  6914			v.reset(OpStringMake)
  6915			v0 := b.NewValue0(v.Pos, OpAddr, typ.BytePtr)
  6916			v0.Aux = fe.StringData(s.(string))
  6917			v1 := b.NewValue0(v.Pos, OpSB, typ.Uintptr)
  6918			v0.AddArg(v1)
  6919			v.AddArg(v0)
  6920			v2 := b.NewValue0(v.Pos, OpConst64, typ.Int)
  6921			v2.AuxInt = int64(len(s.(string)))
  6922			v.AddArg(v2)
  6923			return true
  6924		}
  6925		return false
  6926	}
  6927	func rewriteValuegeneric_OpConvert_0(v *Value) bool {
  6928		// match: (Convert (Add64 (Convert ptr mem) off) mem)
  6929		// cond:
  6930		// result: (Add64 ptr off)
  6931		for {
  6932			mem := v.Args[1]
  6933			v_0 := v.Args[0]
  6934			if v_0.Op != OpAdd64 {
  6935				break
  6936			}
  6937			off := v_0.Args[1]
  6938			v_0_0 := v_0.Args[0]
  6939			if v_0_0.Op != OpConvert {
  6940				break
  6941			}
  6942			_ = v_0_0.Args[1]
  6943			ptr := v_0_0.Args[0]
  6944			if mem != v_0_0.Args[1] {
  6945				break
  6946			}
  6947			v.reset(OpAdd64)
  6948			v.AddArg(ptr)
  6949			v.AddArg(off)
  6950			return true
  6951		}
  6952		// match: (Convert (Add64 off (Convert ptr mem)) mem)
  6953		// cond:
  6954		// result: (Add64 ptr off)
  6955		for {
  6956			mem := v.Args[1]
  6957			v_0 := v.Args[0]
  6958			if v_0.Op != OpAdd64 {
  6959				break
  6960			}
  6961			_ = v_0.Args[1]
  6962			off := v_0.Args[0]
  6963			v_0_1 := v_0.Args[1]
  6964			if v_0_1.Op != OpConvert {
  6965				break
  6966			}
  6967			_ = v_0_1.Args[1]
  6968			ptr := v_0_1.Args[0]
  6969			if mem != v_0_1.Args[1] {
  6970				break
  6971			}
  6972			v.reset(OpAdd64)
  6973			v.AddArg(ptr)
  6974			v.AddArg(off)
  6975			return true
  6976		}
  6977		// match: (Convert (Add32 (Convert ptr mem) off) mem)
  6978		// cond:
  6979		// result: (Add32 ptr off)
  6980		for {
  6981			mem := v.Args[1]
  6982			v_0 := v.Args[0]
  6983			if v_0.Op != OpAdd32 {
  6984				break
  6985			}
  6986			off := v_0.Args[1]
  6987			v_0_0 := v_0.Args[0]
  6988			if v_0_0.Op != OpConvert {
  6989				break
  6990			}
  6991			_ = v_0_0.Args[1]
  6992			ptr := v_0_0.Args[0]
  6993			if mem != v_0_0.Args[1] {
  6994				break
  6995			}
  6996			v.reset(OpAdd32)
  6997			v.AddArg(ptr)
  6998			v.AddArg(off)
  6999			return true
  7000		}
  7001		// match: (Convert (Add32 off (Convert ptr mem)) mem)
  7002		// cond:
  7003		// result: (Add32 ptr off)
  7004		for {
  7005			mem := v.Args[1]
  7006			v_0 := v.Args[0]
  7007			if v_0.Op != OpAdd32 {
  7008				break
  7009			}
  7010			_ = v_0.Args[1]
  7011			off := v_0.Args[0]
  7012			v_0_1 := v_0.Args[1]
  7013			if v_0_1.Op != OpConvert {
  7014				break
  7015			}
  7016			_ = v_0_1.Args[1]
  7017			ptr := v_0_1.Args[0]
  7018			if mem != v_0_1.Args[1] {
  7019				break
  7020			}
  7021			v.reset(OpAdd32)
  7022			v.AddArg(ptr)
  7023			v.AddArg(off)
  7024			return true
  7025		}
  7026		// match: (Convert (Convert ptr mem) mem)
  7027		// cond:
  7028		// result: ptr
  7029		for {
  7030			mem := v.Args[1]
  7031			v_0 := v.Args[0]
  7032			if v_0.Op != OpConvert {
  7033				break
  7034			}
  7035			_ = v_0.Args[1]
  7036			ptr := v_0.Args[0]
  7037			if mem != v_0.Args[1] {
  7038				break
  7039			}
  7040			v.reset(OpCopy)
  7041			v.Type = ptr.Type
  7042			v.AddArg(ptr)
  7043			return true
  7044		}
  7045		return false
  7046	}
  7047	func rewriteValuegeneric_OpCvt32Fto32_0(v *Value) bool {
  7048		// match: (Cvt32Fto32 (Const32F [c]))
  7049		// cond:
  7050		// result: (Const32 [int64(int32(auxTo32F(c)))])
  7051		for {
  7052			v_0 := v.Args[0]
  7053			if v_0.Op != OpConst32F {
  7054				break
  7055			}
  7056			c := v_0.AuxInt
  7057			v.reset(OpConst32)
  7058			v.AuxInt = int64(int32(auxTo32F(c)))
  7059			return true
  7060		}
  7061		return false
  7062	}
  7063	func rewriteValuegeneric_OpCvt32Fto64_0(v *Value) bool {
  7064		// match: (Cvt32Fto64 (Const32F [c]))
  7065		// cond:
  7066		// result: (Const64 [int64(auxTo32F(c))])
  7067		for {
  7068			v_0 := v.Args[0]
  7069			if v_0.Op != OpConst32F {
  7070				break
  7071			}
  7072			c := v_0.AuxInt
  7073			v.reset(OpConst64)
  7074			v.AuxInt = int64(auxTo32F(c))
  7075			return true
  7076		}
  7077		return false
  7078	}
  7079	func rewriteValuegeneric_OpCvt32Fto64F_0(v *Value) bool {
  7080		// match: (Cvt32Fto64F (Const32F [c]))
  7081		// cond:
  7082		// result: (Const64F [c])
  7083		for {
  7084			v_0 := v.Args[0]
  7085			if v_0.Op != OpConst32F {
  7086				break
  7087			}
  7088			c := v_0.AuxInt
  7089			v.reset(OpConst64F)
  7090			v.AuxInt = c
  7091			return true
  7092		}
  7093		return false
  7094	}
  7095	func rewriteValuegeneric_OpCvt32to32F_0(v *Value) bool {
  7096		// match: (Cvt32to32F (Const32 [c]))
  7097		// cond:
  7098		// result: (Const32F [auxFrom32F(float32(int32(c)))])
  7099		for {
  7100			v_0 := v.Args[0]
  7101			if v_0.Op != OpConst32 {
  7102				break
  7103			}
  7104			c := v_0.AuxInt
  7105			v.reset(OpConst32F)
  7106			v.AuxInt = auxFrom32F(float32(int32(c)))
  7107			return true
  7108		}
  7109		return false
  7110	}
  7111	func rewriteValuegeneric_OpCvt32to64F_0(v *Value) bool {
  7112		// match: (Cvt32to64F (Const32 [c]))
  7113		// cond:
  7114		// result: (Const64F [auxFrom64F(float64(int32(c)))])
  7115		for {
  7116			v_0 := v.Args[0]
  7117			if v_0.Op != OpConst32 {
  7118				break
  7119			}
  7120			c := v_0.AuxInt
  7121			v.reset(OpConst64F)
  7122			v.AuxInt = auxFrom64F(float64(int32(c)))
  7123			return true
  7124		}
  7125		return false
  7126	}
  7127	func rewriteValuegeneric_OpCvt64Fto32_0(v *Value) bool {
  7128		// match: (Cvt64Fto32 (Const64F [c]))
  7129		// cond:
  7130		// result: (Const32 [int64(int32(auxTo64F(c)))])
  7131		for {
  7132			v_0 := v.Args[0]
  7133			if v_0.Op != OpConst64F {
  7134				break
  7135			}
  7136			c := v_0.AuxInt
  7137			v.reset(OpConst32)
  7138			v.AuxInt = int64(int32(auxTo64F(c)))
  7139			return true
  7140		}
  7141		return false
  7142	}
  7143	func rewriteValuegeneric_OpCvt64Fto32F_0(v *Value) bool {
  7144		// match: (Cvt64Fto32F (Const64F [c]))
  7145		// cond:
  7146		// result: (Const32F [auxFrom32F(float32(auxTo64F(c)))])
  7147		for {
  7148			v_0 := v.Args[0]
  7149			if v_0.Op != OpConst64F {
  7150				break
  7151			}
  7152			c := v_0.AuxInt
  7153			v.reset(OpConst32F)
  7154			v.AuxInt = auxFrom32F(float32(auxTo64F(c)))
  7155			return true
  7156		}
  7157		return false
  7158	}
  7159	func rewriteValuegeneric_OpCvt64Fto64_0(v *Value) bool {
  7160		// match: (Cvt64Fto64 (Const64F [c]))
  7161		// cond:
  7162		// result: (Const64 [int64(auxTo64F(c))])
  7163		for {
  7164			v_0 := v.Args[0]
  7165			if v_0.Op != OpConst64F {
  7166				break
  7167			}
  7168			c := v_0.AuxInt
  7169			v.reset(OpConst64)
  7170			v.AuxInt = int64(auxTo64F(c))
  7171			return true
  7172		}
  7173		return false
  7174	}
  7175	func rewriteValuegeneric_OpCvt64to32F_0(v *Value) bool {
  7176		// match: (Cvt64to32F (Const64 [c]))
  7177		// cond:
  7178		// result: (Const32F [auxFrom32F(float32(c))])
  7179		for {
  7180			v_0 := v.Args[0]
  7181			if v_0.Op != OpConst64 {
  7182				break
  7183			}
  7184			c := v_0.AuxInt
  7185			v.reset(OpConst32F)
  7186			v.AuxInt = auxFrom32F(float32(c))
  7187			return true
  7188		}
  7189		return false
  7190	}
  7191	func rewriteValuegeneric_OpCvt64to64F_0(v *Value) bool {
  7192		// match: (Cvt64to64F (Const64 [c]))
  7193		// cond:
  7194		// result: (Const64F [auxFrom64F(float64(c))])
  7195		for {
  7196			v_0 := v.Args[0]
  7197			if v_0.Op != OpConst64 {
  7198				break
  7199			}
  7200			c := v_0.AuxInt
  7201			v.reset(OpConst64F)
  7202			v.AuxInt = auxFrom64F(float64(c))
  7203			return true
  7204		}
  7205		return false
  7206	}
  7207	func rewriteValuegeneric_OpDiv16_0(v *Value) bool {
  7208		b := v.Block
  7209		typ := &b.Func.Config.Types
  7210		// match: (Div16 (Const16 [c]) (Const16 [d]))
  7211		// cond: d != 0
  7212		// result: (Const16 [int64(int16(c)/int16(d))])
  7213		for {
  7214			_ = v.Args[1]
  7215			v_0 := v.Args[0]
  7216			if v_0.Op != OpConst16 {
  7217				break
  7218			}
  7219			c := v_0.AuxInt
  7220			v_1 := v.Args[1]
  7221			if v_1.Op != OpConst16 {
  7222				break
  7223			}
  7224			d := v_1.AuxInt
  7225			if !(d != 0) {
  7226				break
  7227			}
  7228			v.reset(OpConst16)
  7229			v.AuxInt = int64(int16(c) / int16(d))
  7230			return true
  7231		}
  7232		// match: (Div16 n (Const16 [c]))
  7233		// cond: isNonNegative(n) && isPowerOfTwo(c&0xffff)
  7234		// result: (Rsh16Ux64 n (Const64 <typ.UInt64> [log2(c&0xffff)]))
  7235		for {
  7236			_ = v.Args[1]
  7237			n := v.Args[0]
  7238			v_1 := v.Args[1]
  7239			if v_1.Op != OpConst16 {
  7240				break
  7241			}
  7242			c := v_1.AuxInt
  7243			if !(isNonNegative(n) && isPowerOfTwo(c&0xffff)) {
  7244				break
  7245			}
  7246			v.reset(OpRsh16Ux64)
  7247			v.AddArg(n)
  7248			v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7249			v0.AuxInt = log2(c & 0xffff)
  7250			v.AddArg(v0)
  7251			return true
  7252		}
  7253		// match: (Div16 <t> n (Const16 [c]))
  7254		// cond: c < 0 && c != -1<<15
  7255		// result: (Neg16 (Div16 <t> n (Const16 <t> [-c])))
  7256		for {
  7257			t := v.Type
  7258			_ = v.Args[1]
  7259			n := v.Args[0]
  7260			v_1 := v.Args[1]
  7261			if v_1.Op != OpConst16 {
  7262				break
  7263			}
  7264			c := v_1.AuxInt
  7265			if !(c < 0 && c != -1<<15) {
  7266				break
  7267			}
  7268			v.reset(OpNeg16)
  7269			v0 := b.NewValue0(v.Pos, OpDiv16, t)
  7270			v0.AddArg(n)
  7271			v1 := b.NewValue0(v.Pos, OpConst16, t)
  7272			v1.AuxInt = -c
  7273			v0.AddArg(v1)
  7274			v.AddArg(v0)
  7275			return true
  7276		}
  7277		// match: (Div16 <t> x (Const16 [-1<<15]))
  7278		// cond:
  7279		// result: (Rsh16Ux64 (And16 <t> x (Neg16 <t> x)) (Const64 <typ.UInt64> [15]))
  7280		for {
  7281			t := v.Type
  7282			_ = v.Args[1]
  7283			x := v.Args[0]
  7284			v_1 := v.Args[1]
  7285			if v_1.Op != OpConst16 {
  7286				break
  7287			}
  7288			if v_1.AuxInt != -1<<15 {
  7289				break
  7290			}
  7291			v.reset(OpRsh16Ux64)
  7292			v0 := b.NewValue0(v.Pos, OpAnd16, t)
  7293			v0.AddArg(x)
  7294			v1 := b.NewValue0(v.Pos, OpNeg16, t)
  7295			v1.AddArg(x)
  7296			v0.AddArg(v1)
  7297			v.AddArg(v0)
  7298			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7299			v2.AuxInt = 15
  7300			v.AddArg(v2)
  7301			return true
  7302		}
  7303		// match: (Div16 <t> n (Const16 [c]))
  7304		// cond: isPowerOfTwo(c)
  7305		// result: (Rsh16x64 (Add16 <t> n (Rsh16Ux64 <t> (Rsh16x64 <t> n (Const64 <typ.UInt64> [15])) (Const64 <typ.UInt64> [16-log2(c)]))) (Const64 <typ.UInt64> [log2(c)]))
  7306		for {
  7307			t := v.Type
  7308			_ = v.Args[1]
  7309			n := v.Args[0]
  7310			v_1 := v.Args[1]
  7311			if v_1.Op != OpConst16 {
  7312				break
  7313			}
  7314			c := v_1.AuxInt
  7315			if !(isPowerOfTwo(c)) {
  7316				break
  7317			}
  7318			v.reset(OpRsh16x64)
  7319			v0 := b.NewValue0(v.Pos, OpAdd16, t)
  7320			v0.AddArg(n)
  7321			v1 := b.NewValue0(v.Pos, OpRsh16Ux64, t)
  7322			v2 := b.NewValue0(v.Pos, OpRsh16x64, t)
  7323			v2.AddArg(n)
  7324			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7325			v3.AuxInt = 15
  7326			v2.AddArg(v3)
  7327			v1.AddArg(v2)
  7328			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7329			v4.AuxInt = 16 - log2(c)
  7330			v1.AddArg(v4)
  7331			v0.AddArg(v1)
  7332			v.AddArg(v0)
  7333			v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7334			v5.AuxInt = log2(c)
  7335			v.AddArg(v5)
  7336			return true
  7337		}
  7338		// match: (Div16 <t> x (Const16 [c]))
  7339		// cond: smagicOK(16,c)
  7340		// result: (Sub16 <t> (Rsh32x64 <t> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(smagic(16,c).m)]) (SignExt16to32 x)) (Const64 <typ.UInt64> [16+smagic(16,c).s])) (Rsh32x64 <t> (SignExt16to32 x) (Const64 <typ.UInt64> [31])))
  7341		for {
  7342			t := v.Type
  7343			_ = v.Args[1]
  7344			x := v.Args[0]
  7345			v_1 := v.Args[1]
  7346			if v_1.Op != OpConst16 {
  7347				break
  7348			}
  7349			c := v_1.AuxInt
  7350			if !(smagicOK(16, c)) {
  7351				break
  7352			}
  7353			v.reset(OpSub16)
  7354			v.Type = t
  7355			v0 := b.NewValue0(v.Pos, OpRsh32x64, t)
  7356			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
  7357			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  7358			v2.AuxInt = int64(smagic(16, c).m)
  7359			v1.AddArg(v2)
  7360			v3 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
  7361			v3.AddArg(x)
  7362			v1.AddArg(v3)
  7363			v0.AddArg(v1)
  7364			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7365			v4.AuxInt = 16 + smagic(16, c).s
  7366			v0.AddArg(v4)
  7367			v.AddArg(v0)
  7368			v5 := b.NewValue0(v.Pos, OpRsh32x64, t)
  7369			v6 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
  7370			v6.AddArg(x)
  7371			v5.AddArg(v6)
  7372			v7 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7373			v7.AuxInt = 31
  7374			v5.AddArg(v7)
  7375			v.AddArg(v5)
  7376			return true
  7377		}
  7378		return false
  7379	}
  7380	func rewriteValuegeneric_OpDiv16u_0(v *Value) bool {
  7381		b := v.Block
  7382		config := b.Func.Config
  7383		typ := &b.Func.Config.Types
  7384		// match: (Div16u (Const16 [c]) (Const16 [d]))
  7385		// cond: d != 0
  7386		// result: (Const16 [int64(int16(uint16(c)/uint16(d)))])
  7387		for {
  7388			_ = v.Args[1]
  7389			v_0 := v.Args[0]
  7390			if v_0.Op != OpConst16 {
  7391				break
  7392			}
  7393			c := v_0.AuxInt
  7394			v_1 := v.Args[1]
  7395			if v_1.Op != OpConst16 {
  7396				break
  7397			}
  7398			d := v_1.AuxInt
  7399			if !(d != 0) {
  7400				break
  7401			}
  7402			v.reset(OpConst16)
  7403			v.AuxInt = int64(int16(uint16(c) / uint16(d)))
  7404			return true
  7405		}
  7406		// match: (Div16u n (Const16 [c]))
  7407		// cond: isPowerOfTwo(c&0xffff)
  7408		// result: (Rsh16Ux64 n (Const64 <typ.UInt64> [log2(c&0xffff)]))
  7409		for {
  7410			_ = v.Args[1]
  7411			n := v.Args[0]
  7412			v_1 := v.Args[1]
  7413			if v_1.Op != OpConst16 {
  7414				break
  7415			}
  7416			c := v_1.AuxInt
  7417			if !(isPowerOfTwo(c & 0xffff)) {
  7418				break
  7419			}
  7420			v.reset(OpRsh16Ux64)
  7421			v.AddArg(n)
  7422			v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7423			v0.AuxInt = log2(c & 0xffff)
  7424			v.AddArg(v0)
  7425			return true
  7426		}
  7427		// match: (Div16u x (Const16 [c]))
  7428		// cond: umagicOK(16, c) && config.RegSize == 8
  7429		// result: (Trunc64to16 (Rsh64Ux64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(1<<16+umagic(16,c).m)]) (ZeroExt16to64 x)) (Const64 <typ.UInt64> [16+umagic(16,c).s])))
  7430		for {
  7431			_ = v.Args[1]
  7432			x := v.Args[0]
  7433			v_1 := v.Args[1]
  7434			if v_1.Op != OpConst16 {
  7435				break
  7436			}
  7437			c := v_1.AuxInt
  7438			if !(umagicOK(16, c) && config.RegSize == 8) {
  7439				break
  7440			}
  7441			v.reset(OpTrunc64to16)
  7442			v0 := b.NewValue0(v.Pos, OpRsh64Ux64, typ.UInt64)
  7443			v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
  7444			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7445			v2.AuxInt = int64(1<<16 + umagic(16, c).m)
  7446			v1.AddArg(v2)
  7447			v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  7448			v3.AddArg(x)
  7449			v1.AddArg(v3)
  7450			v0.AddArg(v1)
  7451			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7452			v4.AuxInt = 16 + umagic(16, c).s
  7453			v0.AddArg(v4)
  7454			v.AddArg(v0)
  7455			return true
  7456		}
  7457		// match: (Div16u x (Const16 [c]))
  7458		// cond: umagicOK(16, c) && config.RegSize == 4 && umagic(16,c).m&1 == 0
  7459		// result: (Trunc32to16 (Rsh32Ux64 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(1<<15+umagic(16,c).m/2)]) (ZeroExt16to32 x)) (Const64 <typ.UInt64> [16+umagic(16,c).s-1])))
  7460		for {
  7461			_ = v.Args[1]
  7462			x := v.Args[0]
  7463			v_1 := v.Args[1]
  7464			if v_1.Op != OpConst16 {
  7465				break
  7466			}
  7467			c := v_1.AuxInt
  7468			if !(umagicOK(16, c) && config.RegSize == 4 && umagic(16, c).m&1 == 0) {
  7469				break
  7470			}
  7471			v.reset(OpTrunc32to16)
  7472			v0 := b.NewValue0(v.Pos, OpRsh32Ux64, typ.UInt32)
  7473			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
  7474			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  7475			v2.AuxInt = int64(1<<15 + umagic(16, c).m/2)
  7476			v1.AddArg(v2)
  7477			v3 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
  7478			v3.AddArg(x)
  7479			v1.AddArg(v3)
  7480			v0.AddArg(v1)
  7481			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7482			v4.AuxInt = 16 + umagic(16, c).s - 1
  7483			v0.AddArg(v4)
  7484			v.AddArg(v0)
  7485			return true
  7486		}
  7487		// match: (Div16u x (Const16 [c]))
  7488		// cond: umagicOK(16, c) && config.RegSize == 4 && c&1 == 0
  7489		// result: (Trunc32to16 (Rsh32Ux64 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(1<<15+(umagic(16,c).m+1)/2)]) (Rsh32Ux64 <typ.UInt32> (ZeroExt16to32 x) (Const64 <typ.UInt64> [1]))) (Const64 <typ.UInt64> [16+umagic(16,c).s-2])))
  7490		for {
  7491			_ = v.Args[1]
  7492			x := v.Args[0]
  7493			v_1 := v.Args[1]
  7494			if v_1.Op != OpConst16 {
  7495				break
  7496			}
  7497			c := v_1.AuxInt
  7498			if !(umagicOK(16, c) && config.RegSize == 4 && c&1 == 0) {
  7499				break
  7500			}
  7501			v.reset(OpTrunc32to16)
  7502			v0 := b.NewValue0(v.Pos, OpRsh32Ux64, typ.UInt32)
  7503			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
  7504			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  7505			v2.AuxInt = int64(1<<15 + (umagic(16, c).m+1)/2)
  7506			v1.AddArg(v2)
  7507			v3 := b.NewValue0(v.Pos, OpRsh32Ux64, typ.UInt32)
  7508			v4 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
  7509			v4.AddArg(x)
  7510			v3.AddArg(v4)
  7511			v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7512			v5.AuxInt = 1
  7513			v3.AddArg(v5)
  7514			v1.AddArg(v3)
  7515			v0.AddArg(v1)
  7516			v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7517			v6.AuxInt = 16 + umagic(16, c).s - 2
  7518			v0.AddArg(v6)
  7519			v.AddArg(v0)
  7520			return true
  7521		}
  7522		// match: (Div16u x (Const16 [c]))
  7523		// cond: umagicOK(16, c) && config.RegSize == 4 && config.useAvg
  7524		// result: (Trunc32to16 (Rsh32Ux64 <typ.UInt32> (Avg32u (Lsh32x64 <typ.UInt32> (ZeroExt16to32 x) (Const64 <typ.UInt64> [16])) (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(umagic(16,c).m)]) (ZeroExt16to32 x))) (Const64 <typ.UInt64> [16+umagic(16,c).s-1])))
  7525		for {
  7526			_ = v.Args[1]
  7527			x := v.Args[0]
  7528			v_1 := v.Args[1]
  7529			if v_1.Op != OpConst16 {
  7530				break
  7531			}
  7532			c := v_1.AuxInt
  7533			if !(umagicOK(16, c) && config.RegSize == 4 && config.useAvg) {
  7534				break
  7535			}
  7536			v.reset(OpTrunc32to16)
  7537			v0 := b.NewValue0(v.Pos, OpRsh32Ux64, typ.UInt32)
  7538			v1 := b.NewValue0(v.Pos, OpAvg32u, typ.UInt32)
  7539			v2 := b.NewValue0(v.Pos, OpLsh32x64, typ.UInt32)
  7540			v3 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
  7541			v3.AddArg(x)
  7542			v2.AddArg(v3)
  7543			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7544			v4.AuxInt = 16
  7545			v2.AddArg(v4)
  7546			v1.AddArg(v2)
  7547			v5 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
  7548			v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  7549			v6.AuxInt = int64(umagic(16, c).m)
  7550			v5.AddArg(v6)
  7551			v7 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
  7552			v7.AddArg(x)
  7553			v5.AddArg(v7)
  7554			v1.AddArg(v5)
  7555			v0.AddArg(v1)
  7556			v8 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7557			v8.AuxInt = 16 + umagic(16, c).s - 1
  7558			v0.AddArg(v8)
  7559			v.AddArg(v0)
  7560			return true
  7561		}
  7562		return false
  7563	}
  7564	func rewriteValuegeneric_OpDiv32_0(v *Value) bool {
  7565		b := v.Block
  7566		config := b.Func.Config
  7567		typ := &b.Func.Config.Types
  7568		// match: (Div32 (Const32 [c]) (Const32 [d]))
  7569		// cond: d != 0
  7570		// result: (Const32 [int64(int32(c)/int32(d))])
  7571		for {
  7572			_ = v.Args[1]
  7573			v_0 := v.Args[0]
  7574			if v_0.Op != OpConst32 {
  7575				break
  7576			}
  7577			c := v_0.AuxInt
  7578			v_1 := v.Args[1]
  7579			if v_1.Op != OpConst32 {
  7580				break
  7581			}
  7582			d := v_1.AuxInt
  7583			if !(d != 0) {
  7584				break
  7585			}
  7586			v.reset(OpConst32)
  7587			v.AuxInt = int64(int32(c) / int32(d))
  7588			return true
  7589		}
  7590		// match: (Div32 n (Const32 [c]))
  7591		// cond: isNonNegative(n) && isPowerOfTwo(c&0xffffffff)
  7592		// result: (Rsh32Ux64 n (Const64 <typ.UInt64> [log2(c&0xffffffff)]))
  7593		for {
  7594			_ = v.Args[1]
  7595			n := v.Args[0]
  7596			v_1 := v.Args[1]
  7597			if v_1.Op != OpConst32 {
  7598				break
  7599			}
  7600			c := v_1.AuxInt
  7601			if !(isNonNegative(n) && isPowerOfTwo(c&0xffffffff)) {
  7602				break
  7603			}
  7604			v.reset(OpRsh32Ux64)
  7605			v.AddArg(n)
  7606			v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7607			v0.AuxInt = log2(c & 0xffffffff)
  7608			v.AddArg(v0)
  7609			return true
  7610		}
  7611		// match: (Div32 <t> n (Const32 [c]))
  7612		// cond: c < 0 && c != -1<<31
  7613		// result: (Neg32 (Div32 <t> n (Const32 <t> [-c])))
  7614		for {
  7615			t := v.Type
  7616			_ = v.Args[1]
  7617			n := v.Args[0]
  7618			v_1 := v.Args[1]
  7619			if v_1.Op != OpConst32 {
  7620				break
  7621			}
  7622			c := v_1.AuxInt
  7623			if !(c < 0 && c != -1<<31) {
  7624				break
  7625			}
  7626			v.reset(OpNeg32)
  7627			v0 := b.NewValue0(v.Pos, OpDiv32, t)
  7628			v0.AddArg(n)
  7629			v1 := b.NewValue0(v.Pos, OpConst32, t)
  7630			v1.AuxInt = -c
  7631			v0.AddArg(v1)
  7632			v.AddArg(v0)
  7633			return true
  7634		}
  7635		// match: (Div32 <t> x (Const32 [-1<<31]))
  7636		// cond:
  7637		// result: (Rsh32Ux64 (And32 <t> x (Neg32 <t> x)) (Const64 <typ.UInt64> [31]))
  7638		for {
  7639			t := v.Type
  7640			_ = v.Args[1]
  7641			x := v.Args[0]
  7642			v_1 := v.Args[1]
  7643			if v_1.Op != OpConst32 {
  7644				break
  7645			}
  7646			if v_1.AuxInt != -1<<31 {
  7647				break
  7648			}
  7649			v.reset(OpRsh32Ux64)
  7650			v0 := b.NewValue0(v.Pos, OpAnd32, t)
  7651			v0.AddArg(x)
  7652			v1 := b.NewValue0(v.Pos, OpNeg32, t)
  7653			v1.AddArg(x)
  7654			v0.AddArg(v1)
  7655			v.AddArg(v0)
  7656			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7657			v2.AuxInt = 31
  7658			v.AddArg(v2)
  7659			return true
  7660		}
  7661		// match: (Div32 <t> n (Const32 [c]))
  7662		// cond: isPowerOfTwo(c)
  7663		// result: (Rsh32x64 (Add32 <t> n (Rsh32Ux64 <t> (Rsh32x64 <t> n (Const64 <typ.UInt64> [31])) (Const64 <typ.UInt64> [32-log2(c)]))) (Const64 <typ.UInt64> [log2(c)]))
  7664		for {
  7665			t := v.Type
  7666			_ = v.Args[1]
  7667			n := v.Args[0]
  7668			v_1 := v.Args[1]
  7669			if v_1.Op != OpConst32 {
  7670				break
  7671			}
  7672			c := v_1.AuxInt
  7673			if !(isPowerOfTwo(c)) {
  7674				break
  7675			}
  7676			v.reset(OpRsh32x64)
  7677			v0 := b.NewValue0(v.Pos, OpAdd32, t)
  7678			v0.AddArg(n)
  7679			v1 := b.NewValue0(v.Pos, OpRsh32Ux64, t)
  7680			v2 := b.NewValue0(v.Pos, OpRsh32x64, t)
  7681			v2.AddArg(n)
  7682			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7683			v3.AuxInt = 31
  7684			v2.AddArg(v3)
  7685			v1.AddArg(v2)
  7686			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7687			v4.AuxInt = 32 - log2(c)
  7688			v1.AddArg(v4)
  7689			v0.AddArg(v1)
  7690			v.AddArg(v0)
  7691			v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7692			v5.AuxInt = log2(c)
  7693			v.AddArg(v5)
  7694			return true
  7695		}
  7696		// match: (Div32 <t> x (Const32 [c]))
  7697		// cond: smagicOK(32,c) && config.RegSize == 8
  7698		// result: (Sub32 <t> (Rsh64x64 <t> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(smagic(32,c).m)]) (SignExt32to64 x)) (Const64 <typ.UInt64> [32+smagic(32,c).s])) (Rsh64x64 <t> (SignExt32to64 x) (Const64 <typ.UInt64> [63])))
  7699		for {
  7700			t := v.Type
  7701			_ = v.Args[1]
  7702			x := v.Args[0]
  7703			v_1 := v.Args[1]
  7704			if v_1.Op != OpConst32 {
  7705				break
  7706			}
  7707			c := v_1.AuxInt
  7708			if !(smagicOK(32, c) && config.RegSize == 8) {
  7709				break
  7710			}
  7711			v.reset(OpSub32)
  7712			v.Type = t
  7713			v0 := b.NewValue0(v.Pos, OpRsh64x64, t)
  7714			v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
  7715			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7716			v2.AuxInt = int64(smagic(32, c).m)
  7717			v1.AddArg(v2)
  7718			v3 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
  7719			v3.AddArg(x)
  7720			v1.AddArg(v3)
  7721			v0.AddArg(v1)
  7722			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7723			v4.AuxInt = 32 + smagic(32, c).s
  7724			v0.AddArg(v4)
  7725			v.AddArg(v0)
  7726			v5 := b.NewValue0(v.Pos, OpRsh64x64, t)
  7727			v6 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
  7728			v6.AddArg(x)
  7729			v5.AddArg(v6)
  7730			v7 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7731			v7.AuxInt = 63
  7732			v5.AddArg(v7)
  7733			v.AddArg(v5)
  7734			return true
  7735		}
  7736		// match: (Div32 <t> x (Const32 [c]))
  7737		// cond: smagicOK(32,c) && config.RegSize == 4 && smagic(32,c).m&1 == 0 && config.useHmul
  7738		// result: (Sub32 <t> (Rsh32x64 <t> (Hmul32 <t> (Const32 <typ.UInt32> [int64(int32(smagic(32,c).m/2))]) x) (Const64 <typ.UInt64> [smagic(32,c).s-1])) (Rsh32x64 <t> x (Const64 <typ.UInt64> [31])))
  7739		for {
  7740			t := v.Type
  7741			_ = v.Args[1]
  7742			x := v.Args[0]
  7743			v_1 := v.Args[1]
  7744			if v_1.Op != OpConst32 {
  7745				break
  7746			}
  7747			c := v_1.AuxInt
  7748			if !(smagicOK(32, c) && config.RegSize == 4 && smagic(32, c).m&1 == 0 && config.useHmul) {
  7749				break
  7750			}
  7751			v.reset(OpSub32)
  7752			v.Type = t
  7753			v0 := b.NewValue0(v.Pos, OpRsh32x64, t)
  7754			v1 := b.NewValue0(v.Pos, OpHmul32, t)
  7755			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  7756			v2.AuxInt = int64(int32(smagic(32, c).m / 2))
  7757			v1.AddArg(v2)
  7758			v1.AddArg(x)
  7759			v0.AddArg(v1)
  7760			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7761			v3.AuxInt = smagic(32, c).s - 1
  7762			v0.AddArg(v3)
  7763			v.AddArg(v0)
  7764			v4 := b.NewValue0(v.Pos, OpRsh32x64, t)
  7765			v4.AddArg(x)
  7766			v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7767			v5.AuxInt = 31
  7768			v4.AddArg(v5)
  7769			v.AddArg(v4)
  7770			return true
  7771		}
  7772		// match: (Div32 <t> x (Const32 [c]))
  7773		// cond: smagicOK(32,c) && config.RegSize == 4 && smagic(32,c).m&1 != 0 && config.useHmul
  7774		// result: (Sub32 <t> (Rsh32x64 <t> (Add32 <t> (Hmul32 <t> (Const32 <typ.UInt32> [int64(int32(smagic(32,c).m))]) x) x) (Const64 <typ.UInt64> [smagic(32,c).s])) (Rsh32x64 <t> x (Const64 <typ.UInt64> [31])))
  7775		for {
  7776			t := v.Type
  7777			_ = v.Args[1]
  7778			x := v.Args[0]
  7779			v_1 := v.Args[1]
  7780			if v_1.Op != OpConst32 {
  7781				break
  7782			}
  7783			c := v_1.AuxInt
  7784			if !(smagicOK(32, c) && config.RegSize == 4 && smagic(32, c).m&1 != 0 && config.useHmul) {
  7785				break
  7786			}
  7787			v.reset(OpSub32)
  7788			v.Type = t
  7789			v0 := b.NewValue0(v.Pos, OpRsh32x64, t)
  7790			v1 := b.NewValue0(v.Pos, OpAdd32, t)
  7791			v2 := b.NewValue0(v.Pos, OpHmul32, t)
  7792			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  7793			v3.AuxInt = int64(int32(smagic(32, c).m))
  7794			v2.AddArg(v3)
  7795			v2.AddArg(x)
  7796			v1.AddArg(v2)
  7797			v1.AddArg(x)
  7798			v0.AddArg(v1)
  7799			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7800			v4.AuxInt = smagic(32, c).s
  7801			v0.AddArg(v4)
  7802			v.AddArg(v0)
  7803			v5 := b.NewValue0(v.Pos, OpRsh32x64, t)
  7804			v5.AddArg(x)
  7805			v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7806			v6.AuxInt = 31
  7807			v5.AddArg(v6)
  7808			v.AddArg(v5)
  7809			return true
  7810		}
  7811		return false
  7812	}
  7813	func rewriteValuegeneric_OpDiv32F_0(v *Value) bool {
  7814		b := v.Block
  7815		// match: (Div32F (Const32F [c]) (Const32F [d]))
  7816		// cond:
  7817		// result: (Const32F [auxFrom32F(auxTo32F(c) / auxTo32F(d))])
  7818		for {
  7819			_ = v.Args[1]
  7820			v_0 := v.Args[0]
  7821			if v_0.Op != OpConst32F {
  7822				break
  7823			}
  7824			c := v_0.AuxInt
  7825			v_1 := v.Args[1]
  7826			if v_1.Op != OpConst32F {
  7827				break
  7828			}
  7829			d := v_1.AuxInt
  7830			v.reset(OpConst32F)
  7831			v.AuxInt = auxFrom32F(auxTo32F(c) / auxTo32F(d))
  7832			return true
  7833		}
  7834		// match: (Div32F x (Const32F <t> [c]))
  7835		// cond: reciprocalExact32(auxTo32F(c))
  7836		// result: (Mul32F x (Const32F <t> [auxFrom32F(1/auxTo32F(c))]))
  7837		for {
  7838			_ = v.Args[1]
  7839			x := v.Args[0]
  7840			v_1 := v.Args[1]
  7841			if v_1.Op != OpConst32F {
  7842				break
  7843			}
  7844			t := v_1.Type
  7845			c := v_1.AuxInt
  7846			if !(reciprocalExact32(auxTo32F(c))) {
  7847				break
  7848			}
  7849			v.reset(OpMul32F)
  7850			v.AddArg(x)
  7851			v0 := b.NewValue0(v.Pos, OpConst32F, t)
  7852			v0.AuxInt = auxFrom32F(1 / auxTo32F(c))
  7853			v.AddArg(v0)
  7854			return true
  7855		}
  7856		return false
  7857	}
  7858	func rewriteValuegeneric_OpDiv32u_0(v *Value) bool {
  7859		b := v.Block
  7860		config := b.Func.Config
  7861		typ := &b.Func.Config.Types
  7862		// match: (Div32u (Const32 [c]) (Const32 [d]))
  7863		// cond: d != 0
  7864		// result: (Const32 [int64(int32(uint32(c)/uint32(d)))])
  7865		for {
  7866			_ = v.Args[1]
  7867			v_0 := v.Args[0]
  7868			if v_0.Op != OpConst32 {
  7869				break
  7870			}
  7871			c := v_0.AuxInt
  7872			v_1 := v.Args[1]
  7873			if v_1.Op != OpConst32 {
  7874				break
  7875			}
  7876			d := v_1.AuxInt
  7877			if !(d != 0) {
  7878				break
  7879			}
  7880			v.reset(OpConst32)
  7881			v.AuxInt = int64(int32(uint32(c) / uint32(d)))
  7882			return true
  7883		}
  7884		// match: (Div32u n (Const32 [c]))
  7885		// cond: isPowerOfTwo(c&0xffffffff)
  7886		// result: (Rsh32Ux64 n (Const64 <typ.UInt64> [log2(c&0xffffffff)]))
  7887		for {
  7888			_ = v.Args[1]
  7889			n := v.Args[0]
  7890			v_1 := v.Args[1]
  7891			if v_1.Op != OpConst32 {
  7892				break
  7893			}
  7894			c := v_1.AuxInt
  7895			if !(isPowerOfTwo(c & 0xffffffff)) {
  7896				break
  7897			}
  7898			v.reset(OpRsh32Ux64)
  7899			v.AddArg(n)
  7900			v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7901			v0.AuxInt = log2(c & 0xffffffff)
  7902			v.AddArg(v0)
  7903			return true
  7904		}
  7905		// match: (Div32u x (Const32 [c]))
  7906		// cond: umagicOK(32, c) && config.RegSize == 4 && umagic(32,c).m&1 == 0 && config.useHmul
  7907		// result: (Rsh32Ux64 <typ.UInt32> (Hmul32u <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(1<<31+umagic(32,c).m/2))]) x) (Const64 <typ.UInt64> [umagic(32,c).s-1]))
  7908		for {
  7909			_ = v.Args[1]
  7910			x := v.Args[0]
  7911			v_1 := v.Args[1]
  7912			if v_1.Op != OpConst32 {
  7913				break
  7914			}
  7915			c := v_1.AuxInt
  7916			if !(umagicOK(32, c) && config.RegSize == 4 && umagic(32, c).m&1 == 0 && config.useHmul) {
  7917				break
  7918			}
  7919			v.reset(OpRsh32Ux64)
  7920			v.Type = typ.UInt32
  7921			v0 := b.NewValue0(v.Pos, OpHmul32u, typ.UInt32)
  7922			v1 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  7923			v1.AuxInt = int64(int32(1<<31 + umagic(32, c).m/2))
  7924			v0.AddArg(v1)
  7925			v0.AddArg(x)
  7926			v.AddArg(v0)
  7927			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7928			v2.AuxInt = umagic(32, c).s - 1
  7929			v.AddArg(v2)
  7930			return true
  7931		}
  7932		// match: (Div32u x (Const32 [c]))
  7933		// cond: umagicOK(32, c) && config.RegSize == 4 && c&1 == 0 && config.useHmul
  7934		// result: (Rsh32Ux64 <typ.UInt32> (Hmul32u <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(1<<31+(umagic(32,c).m+1)/2))]) (Rsh32Ux64 <typ.UInt32> x (Const64 <typ.UInt64> [1]))) (Const64 <typ.UInt64> [umagic(32,c).s-2]))
  7935		for {
  7936			_ = v.Args[1]
  7937			x := v.Args[0]
  7938			v_1 := v.Args[1]
  7939			if v_1.Op != OpConst32 {
  7940				break
  7941			}
  7942			c := v_1.AuxInt
  7943			if !(umagicOK(32, c) && config.RegSize == 4 && c&1 == 0 && config.useHmul) {
  7944				break
  7945			}
  7946			v.reset(OpRsh32Ux64)
  7947			v.Type = typ.UInt32
  7948			v0 := b.NewValue0(v.Pos, OpHmul32u, typ.UInt32)
  7949			v1 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  7950			v1.AuxInt = int64(int32(1<<31 + (umagic(32, c).m+1)/2))
  7951			v0.AddArg(v1)
  7952			v2 := b.NewValue0(v.Pos, OpRsh32Ux64, typ.UInt32)
  7953			v2.AddArg(x)
  7954			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7955			v3.AuxInt = 1
  7956			v2.AddArg(v3)
  7957			v0.AddArg(v2)
  7958			v.AddArg(v0)
  7959			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7960			v4.AuxInt = umagic(32, c).s - 2
  7961			v.AddArg(v4)
  7962			return true
  7963		}
  7964		// match: (Div32u x (Const32 [c]))
  7965		// cond: umagicOK(32, c) && config.RegSize == 4 && config.useAvg && config.useHmul
  7966		// result: (Rsh32Ux64 <typ.UInt32> (Avg32u x (Hmul32u <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(umagic(32,c).m))]) x)) (Const64 <typ.UInt64> [umagic(32,c).s-1]))
  7967		for {
  7968			_ = v.Args[1]
  7969			x := v.Args[0]
  7970			v_1 := v.Args[1]
  7971			if v_1.Op != OpConst32 {
  7972				break
  7973			}
  7974			c := v_1.AuxInt
  7975			if !(umagicOK(32, c) && config.RegSize == 4 && config.useAvg && config.useHmul) {
  7976				break
  7977			}
  7978			v.reset(OpRsh32Ux64)
  7979			v.Type = typ.UInt32
  7980			v0 := b.NewValue0(v.Pos, OpAvg32u, typ.UInt32)
  7981			v0.AddArg(x)
  7982			v1 := b.NewValue0(v.Pos, OpHmul32u, typ.UInt32)
  7983			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  7984			v2.AuxInt = int64(int32(umagic(32, c).m))
  7985			v1.AddArg(v2)
  7986			v1.AddArg(x)
  7987			v0.AddArg(v1)
  7988			v.AddArg(v0)
  7989			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7990			v3.AuxInt = umagic(32, c).s - 1
  7991			v.AddArg(v3)
  7992			return true
  7993		}
  7994		// match: (Div32u x (Const32 [c]))
  7995		// cond: umagicOK(32, c) && config.RegSize == 8 && umagic(32,c).m&1 == 0
  7996		// result: (Trunc64to32 (Rsh64Ux64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(1<<31+umagic(32,c).m/2)]) (ZeroExt32to64 x)) (Const64 <typ.UInt64> [32+umagic(32,c).s-1])))
  7997		for {
  7998			_ = v.Args[1]
  7999			x := v.Args[0]
  8000			v_1 := v.Args[1]
  8001			if v_1.Op != OpConst32 {
  8002				break
  8003			}
  8004			c := v_1.AuxInt
  8005			if !(umagicOK(32, c) && config.RegSize == 8 && umagic(32, c).m&1 == 0) {
  8006				break
  8007			}
  8008			v.reset(OpTrunc64to32)
  8009			v0 := b.NewValue0(v.Pos, OpRsh64Ux64, typ.UInt64)
  8010			v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
  8011			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8012			v2.AuxInt = int64(1<<31 + umagic(32, c).m/2)
  8013			v1.AddArg(v2)
  8014			v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  8015			v3.AddArg(x)
  8016			v1.AddArg(v3)
  8017			v0.AddArg(v1)
  8018			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8019			v4.AuxInt = 32 + umagic(32, c).s - 1
  8020			v0.AddArg(v4)
  8021			v.AddArg(v0)
  8022			return true
  8023		}
  8024		// match: (Div32u x (Const32 [c]))
  8025		// cond: umagicOK(32, c) && config.RegSize == 8 && c&1 == 0
  8026		// result: (Trunc64to32 (Rsh64Ux64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(1<<31+(umagic(32,c).m+1)/2)]) (Rsh64Ux64 <typ.UInt64> (ZeroExt32to64 x) (Const64 <typ.UInt64> [1]))) (Const64 <typ.UInt64> [32+umagic(32,c).s-2])))
  8027		for {
  8028			_ = v.Args[1]
  8029			x := v.Args[0]
  8030			v_1 := v.Args[1]
  8031			if v_1.Op != OpConst32 {
  8032				break
  8033			}
  8034			c := v_1.AuxInt
  8035			if !(umagicOK(32, c) && config.RegSize == 8 && c&1 == 0) {
  8036				break
  8037			}
  8038			v.reset(OpTrunc64to32)
  8039			v0 := b.NewValue0(v.Pos, OpRsh64Ux64, typ.UInt64)
  8040			v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
  8041			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8042			v2.AuxInt = int64(1<<31 + (umagic(32, c).m+1)/2)
  8043			v1.AddArg(v2)
  8044			v3 := b.NewValue0(v.Pos, OpRsh64Ux64, typ.UInt64)
  8045			v4 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  8046			v4.AddArg(x)
  8047			v3.AddArg(v4)
  8048			v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8049			v5.AuxInt = 1
  8050			v3.AddArg(v5)
  8051			v1.AddArg(v3)
  8052			v0.AddArg(v1)
  8053			v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8054			v6.AuxInt = 32 + umagic(32, c).s - 2
  8055			v0.AddArg(v6)
  8056			v.AddArg(v0)
  8057			return true
  8058		}
  8059		// match: (Div32u x (Const32 [c]))
  8060		// cond: umagicOK(32, c) && config.RegSize == 8 && config.useAvg
  8061		// result: (Trunc64to32 (Rsh64Ux64 <typ.UInt64> (Avg64u (Lsh64x64 <typ.UInt64> (ZeroExt32to64 x) (Const64 <typ.UInt64> [32])) (Mul64 <typ.UInt64> (Const64 <typ.UInt32> [int64(umagic(32,c).m)]) (ZeroExt32to64 x))) (Const64 <typ.UInt64> [32+umagic(32,c).s-1])))
  8062		for {
  8063			_ = v.Args[1]
  8064			x := v.Args[0]
  8065			v_1 := v.Args[1]
  8066			if v_1.Op != OpConst32 {
  8067				break
  8068			}
  8069			c := v_1.AuxInt
  8070			if !(umagicOK(32, c) && config.RegSize == 8 && config.useAvg) {
  8071				break
  8072			}
  8073			v.reset(OpTrunc64to32)
  8074			v0 := b.NewValue0(v.Pos, OpRsh64Ux64, typ.UInt64)
  8075			v1 := b.NewValue0(v.Pos, OpAvg64u, typ.UInt64)
  8076			v2 := b.NewValue0(v.Pos, OpLsh64x64, typ.UInt64)
  8077			v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  8078			v3.AddArg(x)
  8079			v2.AddArg(v3)
  8080			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8081			v4.AuxInt = 32
  8082			v2.AddArg(v4)
  8083			v1.AddArg(v2)
  8084			v5 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
  8085			v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt32)
  8086			v6.AuxInt = int64(umagic(32, c).m)
  8087			v5.AddArg(v6)
  8088			v7 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  8089			v7.AddArg(x)
  8090			v5.AddArg(v7)
  8091			v1.AddArg(v5)
  8092			v0.AddArg(v1)
  8093			v8 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8094			v8.AuxInt = 32 + umagic(32, c).s - 1
  8095			v0.AddArg(v8)
  8096			v.AddArg(v0)
  8097			return true
  8098		}
  8099		return false
  8100	}
  8101	func rewriteValuegeneric_OpDiv64_0(v *Value) bool {
  8102		b := v.Block
  8103		config := b.Func.Config
  8104		typ := &b.Func.Config.Types
  8105		// match: (Div64 (Const64 [c]) (Const64 [d]))
  8106		// cond: d != 0
  8107		// result: (Const64 [c/d])
  8108		for {
  8109			_ = v.Args[1]
  8110			v_0 := v.Args[0]
  8111			if v_0.Op != OpConst64 {
  8112				break
  8113			}
  8114			c := v_0.AuxInt
  8115			v_1 := v.Args[1]
  8116			if v_1.Op != OpConst64 {
  8117				break
  8118			}
  8119			d := v_1.AuxInt
  8120			if !(d != 0) {
  8121				break
  8122			}
  8123			v.reset(OpConst64)
  8124			v.AuxInt = c / d
  8125			return true
  8126		}
  8127		// match: (Div64 n (Const64 [c]))
  8128		// cond: isNonNegative(n) && isPowerOfTwo(c)
  8129		// result: (Rsh64Ux64 n (Const64 <typ.UInt64> [log2(c)]))
  8130		for {
  8131			_ = v.Args[1]
  8132			n := v.Args[0]
  8133			v_1 := v.Args[1]
  8134			if v_1.Op != OpConst64 {
  8135				break
  8136			}
  8137			c := v_1.AuxInt
  8138			if !(isNonNegative(n) && isPowerOfTwo(c)) {
  8139				break
  8140			}
  8141			v.reset(OpRsh64Ux64)
  8142			v.AddArg(n)
  8143			v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8144			v0.AuxInt = log2(c)
  8145			v.AddArg(v0)
  8146			return true
  8147		}
  8148		// match: (Div64 n (Const64 [-1<<63]))
  8149		// cond: isNonNegative(n)
  8150		// result: (Const64 [0])
  8151		for {
  8152			_ = v.Args[1]
  8153			n := v.Args[0]
  8154			v_1 := v.Args[1]
  8155			if v_1.Op != OpConst64 {
  8156				break
  8157			}
  8158			if v_1.AuxInt != -1<<63 {
  8159				break
  8160			}
  8161			if !(isNonNegative(n)) {
  8162				break
  8163			}
  8164			v.reset(OpConst64)
  8165			v.AuxInt = 0
  8166			return true
  8167		}
  8168		// match: (Div64 <t> n (Const64 [c]))
  8169		// cond: c < 0 && c != -1<<63
  8170		// result: (Neg64 (Div64 <t> n (Const64 <t> [-c])))
  8171		for {
  8172			t := v.Type
  8173			_ = v.Args[1]
  8174			n := v.Args[0]
  8175			v_1 := v.Args[1]
  8176			if v_1.Op != OpConst64 {
  8177				break
  8178			}
  8179			c := v_1.AuxInt
  8180			if !(c < 0 && c != -1<<63) {
  8181				break
  8182			}
  8183			v.reset(OpNeg64)
  8184			v0 := b.NewValue0(v.Pos, OpDiv64, t)
  8185			v0.AddArg(n)
  8186			v1 := b.NewValue0(v.Pos, OpConst64, t)
  8187			v1.AuxInt = -c
  8188			v0.AddArg(v1)
  8189			v.AddArg(v0)
  8190			return true
  8191		}
  8192		// match: (Div64 <t> x (Const64 [-1<<63]))
  8193		// cond:
  8194		// result: (Rsh64Ux64 (And64 <t> x (Neg64 <t> x)) (Const64 <typ.UInt64> [63]))
  8195		for {
  8196			t := v.Type
  8197			_ = v.Args[1]
  8198			x := v.Args[0]
  8199			v_1 := v.Args[1]
  8200			if v_1.Op != OpConst64 {
  8201				break
  8202			}
  8203			if v_1.AuxInt != -1<<63 {
  8204				break
  8205			}
  8206			v.reset(OpRsh64Ux64)
  8207			v0 := b.NewValue0(v.Pos, OpAnd64, t)
  8208			v0.AddArg(x)
  8209			v1 := b.NewValue0(v.Pos, OpNeg64, t)
  8210			v1.AddArg(x)
  8211			v0.AddArg(v1)
  8212			v.AddArg(v0)
  8213			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8214			v2.AuxInt = 63
  8215			v.AddArg(v2)
  8216			return true
  8217		}
  8218		// match: (Div64 <t> n (Const64 [c]))
  8219		// cond: isPowerOfTwo(c)
  8220		// result: (Rsh64x64 (Add64 <t> n (Rsh64Ux64 <t> (Rsh64x64 <t> n (Const64 <typ.UInt64> [63])) (Const64 <typ.UInt64> [64-log2(c)]))) (Const64 <typ.UInt64> [log2(c)]))
  8221		for {
  8222			t := v.Type
  8223			_ = v.Args[1]
  8224			n := v.Args[0]
  8225			v_1 := v.Args[1]
  8226			if v_1.Op != OpConst64 {
  8227				break
  8228			}
  8229			c := v_1.AuxInt
  8230			if !(isPowerOfTwo(c)) {
  8231				break
  8232			}
  8233			v.reset(OpRsh64x64)
  8234			v0 := b.NewValue0(v.Pos, OpAdd64, t)
  8235			v0.AddArg(n)
  8236			v1 := b.NewValue0(v.Pos, OpRsh64Ux64, t)
  8237			v2 := b.NewValue0(v.Pos, OpRsh64x64, t)
  8238			v2.AddArg(n)
  8239			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8240			v3.AuxInt = 63
  8241			v2.AddArg(v3)
  8242			v1.AddArg(v2)
  8243			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8244			v4.AuxInt = 64 - log2(c)
  8245			v1.AddArg(v4)
  8246			v0.AddArg(v1)
  8247			v.AddArg(v0)
  8248			v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8249			v5.AuxInt = log2(c)
  8250			v.AddArg(v5)
  8251			return true
  8252		}
  8253		// match: (Div64 <t> x (Const64 [c]))
  8254		// cond: smagicOK(64,c) && smagic(64,c).m&1 == 0 && config.useHmul
  8255		// result: (Sub64 <t> (Rsh64x64 <t> (Hmul64 <t> (Const64 <typ.UInt64> [int64(smagic(64,c).m/2)]) x) (Const64 <typ.UInt64> [smagic(64,c).s-1])) (Rsh64x64 <t> x (Const64 <typ.UInt64> [63])))
  8256		for {
  8257			t := v.Type
  8258			_ = v.Args[1]
  8259			x := v.Args[0]
  8260			v_1 := v.Args[1]
  8261			if v_1.Op != OpConst64 {
  8262				break
  8263			}
  8264			c := v_1.AuxInt
  8265			if !(smagicOK(64, c) && smagic(64, c).m&1 == 0 && config.useHmul) {
  8266				break
  8267			}
  8268			v.reset(OpSub64)
  8269			v.Type = t
  8270			v0 := b.NewValue0(v.Pos, OpRsh64x64, t)
  8271			v1 := b.NewValue0(v.Pos, OpHmul64, t)
  8272			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8273			v2.AuxInt = int64(smagic(64, c).m / 2)
  8274			v1.AddArg(v2)
  8275			v1.AddArg(x)
  8276			v0.AddArg(v1)
  8277			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8278			v3.AuxInt = smagic(64, c).s - 1
  8279			v0.AddArg(v3)
  8280			v.AddArg(v0)
  8281			v4 := b.NewValue0(v.Pos, OpRsh64x64, t)
  8282			v4.AddArg(x)
  8283			v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8284			v5.AuxInt = 63
  8285			v4.AddArg(v5)
  8286			v.AddArg(v4)
  8287			return true
  8288		}
  8289		// match: (Div64 <t> x (Const64 [c]))
  8290		// cond: smagicOK(64,c) && smagic(64,c).m&1 != 0 && config.useHmul
  8291		// result: (Sub64 <t> (Rsh64x64 <t> (Add64 <t> (Hmul64 <t> (Const64 <typ.UInt64> [int64(smagic(64,c).m)]) x) x) (Const64 <typ.UInt64> [smagic(64,c).s])) (Rsh64x64 <t> x (Const64 <typ.UInt64> [63])))
  8292		for {
  8293			t := v.Type
  8294			_ = v.Args[1]
  8295			x := v.Args[0]
  8296			v_1 := v.Args[1]
  8297			if v_1.Op != OpConst64 {
  8298				break
  8299			}
  8300			c := v_1.AuxInt
  8301			if !(smagicOK(64, c) && smagic(64, c).m&1 != 0 && config.useHmul) {
  8302				break
  8303			}
  8304			v.reset(OpSub64)
  8305			v.Type = t
  8306			v0 := b.NewValue0(v.Pos, OpRsh64x64, t)
  8307			v1 := b.NewValue0(v.Pos, OpAdd64, t)
  8308			v2 := b.NewValue0(v.Pos, OpHmul64, t)
  8309			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8310			v3.AuxInt = int64(smagic(64, c).m)
  8311			v2.AddArg(v3)
  8312			v2.AddArg(x)
  8313			v1.AddArg(v2)
  8314			v1.AddArg(x)
  8315			v0.AddArg(v1)
  8316			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8317			v4.AuxInt = smagic(64, c).s
  8318			v0.AddArg(v4)
  8319			v.AddArg(v0)
  8320			v5 := b.NewValue0(v.Pos, OpRsh64x64, t)
  8321			v5.AddArg(x)
  8322			v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8323			v6.AuxInt = 63
  8324			v5.AddArg(v6)
  8325			v.AddArg(v5)
  8326			return true
  8327		}
  8328		return false
  8329	}
  8330	func rewriteValuegeneric_OpDiv64F_0(v *Value) bool {
  8331		b := v.Block
  8332		// match: (Div64F (Const64F [c]) (Const64F [d]))
  8333		// cond:
  8334		// result: (Const64F [auxFrom64F(auxTo64F(c) / auxTo64F(d))])
  8335		for {
  8336			_ = v.Args[1]
  8337			v_0 := v.Args[0]
  8338			if v_0.Op != OpConst64F {
  8339				break
  8340			}
  8341			c := v_0.AuxInt
  8342			v_1 := v.Args[1]
  8343			if v_1.Op != OpConst64F {
  8344				break
  8345			}
  8346			d := v_1.AuxInt
  8347			v.reset(OpConst64F)
  8348			v.AuxInt = auxFrom64F(auxTo64F(c) / auxTo64F(d))
  8349			return true
  8350		}
  8351		// match: (Div64F x (Const64F <t> [c]))
  8352		// cond: reciprocalExact64(auxTo64F(c))
  8353		// result: (Mul64F x (Const64F <t> [auxFrom64F(1/auxTo64F(c))]))
  8354		for {
  8355			_ = v.Args[1]
  8356			x := v.Args[0]
  8357			v_1 := v.Args[1]
  8358			if v_1.Op != OpConst64F {
  8359				break
  8360			}
  8361			t := v_1.Type
  8362			c := v_1.AuxInt
  8363			if !(reciprocalExact64(auxTo64F(c))) {
  8364				break
  8365			}
  8366			v.reset(OpMul64F)
  8367			v.AddArg(x)
  8368			v0 := b.NewValue0(v.Pos, OpConst64F, t)
  8369			v0.AuxInt = auxFrom64F(1 / auxTo64F(c))
  8370			v.AddArg(v0)
  8371			return true
  8372		}
  8373		return false
  8374	}
  8375	func rewriteValuegeneric_OpDiv64u_0(v *Value) bool {
  8376		b := v.Block
  8377		config := b.Func.Config
  8378		typ := &b.Func.Config.Types
  8379		// match: (Div64u (Const64 [c]) (Const64 [d]))
  8380		// cond: d != 0
  8381		// result: (Const64 [int64(uint64(c)/uint64(d))])
  8382		for {
  8383			_ = v.Args[1]
  8384			v_0 := v.Args[0]
  8385			if v_0.Op != OpConst64 {
  8386				break
  8387			}
  8388			c := v_0.AuxInt
  8389			v_1 := v.Args[1]
  8390			if v_1.Op != OpConst64 {
  8391				break
  8392			}
  8393			d := v_1.AuxInt
  8394			if !(d != 0) {
  8395				break
  8396			}
  8397			v.reset(OpConst64)
  8398			v.AuxInt = int64(uint64(c) / uint64(d))
  8399			return true
  8400		}
  8401		// match: (Div64u n (Const64 [c]))
  8402		// cond: isPowerOfTwo(c)
  8403		// result: (Rsh64Ux64 n (Const64 <typ.UInt64> [log2(c)]))
  8404		for {
  8405			_ = v.Args[1]
  8406			n := v.Args[0]
  8407			v_1 := v.Args[1]
  8408			if v_1.Op != OpConst64 {
  8409				break
  8410			}
  8411			c := v_1.AuxInt
  8412			if !(isPowerOfTwo(c)) {
  8413				break
  8414			}
  8415			v.reset(OpRsh64Ux64)
  8416			v.AddArg(n)
  8417			v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8418			v0.AuxInt = log2(c)
  8419			v.AddArg(v0)
  8420			return true
  8421		}
  8422		// match: (Div64u n (Const64 [-1<<63]))
  8423		// cond:
  8424		// result: (Rsh64Ux64 n (Const64 <typ.UInt64> [63]))
  8425		for {
  8426			_ = v.Args[1]
  8427			n := v.Args[0]
  8428			v_1 := v.Args[1]
  8429			if v_1.Op != OpConst64 {
  8430				break
  8431			}
  8432			if v_1.AuxInt != -1<<63 {
  8433				break
  8434			}
  8435			v.reset(OpRsh64Ux64)
  8436			v.AddArg(n)
  8437			v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8438			v0.AuxInt = 63
  8439			v.AddArg(v0)
  8440			return true
  8441		}
  8442		// match: (Div64u x (Const64 [c]))
  8443		// cond: umagicOK(64, c) && config.RegSize == 8 && umagic(64,c).m&1 == 0 && config.useHmul
  8444		// result: (Rsh64Ux64 <typ.UInt64> (Hmul64u <typ.UInt64> (Const64 <typ.UInt64> [int64(1<<63+umagic(64,c).m/2)]) x) (Const64 <typ.UInt64> [umagic(64,c).s-1]))
  8445		for {
  8446			_ = v.Args[1]
  8447			x := v.Args[0]
  8448			v_1 := v.Args[1]
  8449			if v_1.Op != OpConst64 {
  8450				break
  8451			}
  8452			c := v_1.AuxInt
  8453			if !(umagicOK(64, c) && config.RegSize == 8 && umagic(64, c).m&1 == 0 && config.useHmul) {
  8454				break
  8455			}
  8456			v.reset(OpRsh64Ux64)
  8457			v.Type = typ.UInt64
  8458			v0 := b.NewValue0(v.Pos, OpHmul64u, typ.UInt64)
  8459			v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8460			v1.AuxInt = int64(1<<63 + umagic(64, c).m/2)
  8461			v0.AddArg(v1)
  8462			v0.AddArg(x)
  8463			v.AddArg(v0)
  8464			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8465			v2.AuxInt = umagic(64, c).s - 1
  8466			v.AddArg(v2)
  8467			return true
  8468		}
  8469		// match: (Div64u x (Const64 [c]))
  8470		// cond: umagicOK(64, c) && config.RegSize == 8 && c&1 == 0 && config.useHmul
  8471		// result: (Rsh64Ux64 <typ.UInt64> (Hmul64u <typ.UInt64> (Const64 <typ.UInt64> [int64(1<<63+(umagic(64,c).m+1)/2)]) (Rsh64Ux64 <typ.UInt64> x (Const64 <typ.UInt64> [1]))) (Const64 <typ.UInt64> [umagic(64,c).s-2]))
  8472		for {
  8473			_ = v.Args[1]
  8474			x := v.Args[0]
  8475			v_1 := v.Args[1]
  8476			if v_1.Op != OpConst64 {
  8477				break
  8478			}
  8479			c := v_1.AuxInt
  8480			if !(umagicOK(64, c) && config.RegSize == 8 && c&1 == 0 && config.useHmul) {
  8481				break
  8482			}
  8483			v.reset(OpRsh64Ux64)
  8484			v.Type = typ.UInt64
  8485			v0 := b.NewValue0(v.Pos, OpHmul64u, typ.UInt64)
  8486			v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8487			v1.AuxInt = int64(1<<63 + (umagic(64, c).m+1)/2)
  8488			v0.AddArg(v1)
  8489			v2 := b.NewValue0(v.Pos, OpRsh64Ux64, typ.UInt64)
  8490			v2.AddArg(x)
  8491			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8492			v3.AuxInt = 1
  8493			v2.AddArg(v3)
  8494			v0.AddArg(v2)
  8495			v.AddArg(v0)
  8496			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8497			v4.AuxInt = umagic(64, c).s - 2
  8498			v.AddArg(v4)
  8499			return true
  8500		}
  8501		// match: (Div64u x (Const64 [c]))
  8502		// cond: umagicOK(64, c) && config.RegSize == 8 && config.useAvg && config.useHmul
  8503		// result: (Rsh64Ux64 <typ.UInt64> (Avg64u x (Hmul64u <typ.UInt64> (Const64 <typ.UInt64> [int64(umagic(64,c).m)]) x)) (Const64 <typ.UInt64> [umagic(64,c).s-1]))
  8504		for {
  8505			_ = v.Args[1]
  8506			x := v.Args[0]
  8507			v_1 := v.Args[1]
  8508			if v_1.Op != OpConst64 {
  8509				break
  8510			}
  8511			c := v_1.AuxInt
  8512			if !(umagicOK(64, c) && config.RegSize == 8 && config.useAvg && config.useHmul) {
  8513				break
  8514			}
  8515			v.reset(OpRsh64Ux64)
  8516			v.Type = typ.UInt64
  8517			v0 := b.NewValue0(v.Pos, OpAvg64u, typ.UInt64)
  8518			v0.AddArg(x)
  8519			v1 := b.NewValue0(v.Pos, OpHmul64u, typ.UInt64)
  8520			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8521			v2.AuxInt = int64(umagic(64, c).m)
  8522			v1.AddArg(v2)
  8523			v1.AddArg(x)
  8524			v0.AddArg(v1)
  8525			v.AddArg(v0)
  8526			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8527			v3.AuxInt = umagic(64, c).s - 1
  8528			v.AddArg(v3)
  8529			return true
  8530		}
  8531		return false
  8532	}
  8533	func rewriteValuegeneric_OpDiv8_0(v *Value) bool {
  8534		b := v.Block
  8535		typ := &b.Func.Config.Types
  8536		// match: (Div8 (Const8 [c]) (Const8 [d]))
  8537		// cond: d != 0
  8538		// result: (Const8 [int64(int8(c)/int8(d))])
  8539		for {
  8540			_ = v.Args[1]
  8541			v_0 := v.Args[0]
  8542			if v_0.Op != OpConst8 {
  8543				break
  8544			}
  8545			c := v_0.AuxInt
  8546			v_1 := v.Args[1]
  8547			if v_1.Op != OpConst8 {
  8548				break
  8549			}
  8550			d := v_1.AuxInt
  8551			if !(d != 0) {
  8552				break
  8553			}
  8554			v.reset(OpConst8)
  8555			v.AuxInt = int64(int8(c) / int8(d))
  8556			return true
  8557		}
  8558		// match: (Div8 n (Const8 [c]))
  8559		// cond: isNonNegative(n) && isPowerOfTwo(c&0xff)
  8560		// result: (Rsh8Ux64 n (Const64 <typ.UInt64> [log2(c&0xff)]))
  8561		for {
  8562			_ = v.Args[1]
  8563			n := v.Args[0]
  8564			v_1 := v.Args[1]
  8565			if v_1.Op != OpConst8 {
  8566				break
  8567			}
  8568			c := v_1.AuxInt
  8569			if !(isNonNegative(n) && isPowerOfTwo(c&0xff)) {
  8570				break
  8571			}
  8572			v.reset(OpRsh8Ux64)
  8573			v.AddArg(n)
  8574			v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8575			v0.AuxInt = log2(c & 0xff)
  8576			v.AddArg(v0)
  8577			return true
  8578		}
  8579		// match: (Div8 <t> n (Const8 [c]))
  8580		// cond: c < 0 && c != -1<<7
  8581		// result: (Neg8 (Div8 <t> n (Const8 <t> [-c])))
  8582		for {
  8583			t := v.Type
  8584			_ = v.Args[1]
  8585			n := v.Args[0]
  8586			v_1 := v.Args[1]
  8587			if v_1.Op != OpConst8 {
  8588				break
  8589			}
  8590			c := v_1.AuxInt
  8591			if !(c < 0 && c != -1<<7) {
  8592				break
  8593			}
  8594			v.reset(OpNeg8)
  8595			v0 := b.NewValue0(v.Pos, OpDiv8, t)
  8596			v0.AddArg(n)
  8597			v1 := b.NewValue0(v.Pos, OpConst8, t)
  8598			v1.AuxInt = -c
  8599			v0.AddArg(v1)
  8600			v.AddArg(v0)
  8601			return true
  8602		}
  8603		// match: (Div8 <t> x (Const8 [-1<<7 ]))
  8604		// cond:
  8605		// result: (Rsh8Ux64 (And8 <t> x (Neg8 <t> x)) (Const64 <typ.UInt64> [7 ]))
  8606		for {
  8607			t := v.Type
  8608			_ = v.Args[1]
  8609			x := v.Args[0]
  8610			v_1 := v.Args[1]
  8611			if v_1.Op != OpConst8 {
  8612				break
  8613			}
  8614			if v_1.AuxInt != -1<<7 {
  8615				break
  8616			}
  8617			v.reset(OpRsh8Ux64)
  8618			v0 := b.NewValue0(v.Pos, OpAnd8, t)
  8619			v0.AddArg(x)
  8620			v1 := b.NewValue0(v.Pos, OpNeg8, t)
  8621			v1.AddArg(x)
  8622			v0.AddArg(v1)
  8623			v.AddArg(v0)
  8624			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8625			v2.AuxInt = 7
  8626			v.AddArg(v2)
  8627			return true
  8628		}
  8629		// match: (Div8 <t> n (Const8 [c]))
  8630		// cond: isPowerOfTwo(c)
  8631		// result: (Rsh8x64 (Add8 <t> n (Rsh8Ux64 <t> (Rsh8x64 <t> n (Const64 <typ.UInt64> [ 7])) (Const64 <typ.UInt64> [ 8-log2(c)]))) (Const64 <typ.UInt64> [log2(c)]))
  8632		for {
  8633			t := v.Type
  8634			_ = v.Args[1]
  8635			n := v.Args[0]
  8636			v_1 := v.Args[1]
  8637			if v_1.Op != OpConst8 {
  8638				break
  8639			}
  8640			c := v_1.AuxInt
  8641			if !(isPowerOfTwo(c)) {
  8642				break
  8643			}
  8644			v.reset(OpRsh8x64)
  8645			v0 := b.NewValue0(v.Pos, OpAdd8, t)
  8646			v0.AddArg(n)
  8647			v1 := b.NewValue0(v.Pos, OpRsh8Ux64, t)
  8648			v2 := b.NewValue0(v.Pos, OpRsh8x64, t)
  8649			v2.AddArg(n)
  8650			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8651			v3.AuxInt = 7
  8652			v2.AddArg(v3)
  8653			v1.AddArg(v2)
  8654			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8655			v4.AuxInt = 8 - log2(c)
  8656			v1.AddArg(v4)
  8657			v0.AddArg(v1)
  8658			v.AddArg(v0)
  8659			v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8660			v5.AuxInt = log2(c)
  8661			v.AddArg(v5)
  8662			return true
  8663		}
  8664		// match: (Div8 <t> x (Const8 [c]))
  8665		// cond: smagicOK(8,c)
  8666		// result: (Sub8 <t> (Rsh32x64 <t> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(smagic(8,c).m)]) (SignExt8to32 x)) (Const64 <typ.UInt64> [8+smagic(8,c).s])) (Rsh32x64 <t> (SignExt8to32 x) (Const64 <typ.UInt64> [31])))
  8667		for {
  8668			t := v.Type
  8669			_ = v.Args[1]
  8670			x := v.Args[0]
  8671			v_1 := v.Args[1]
  8672			if v_1.Op != OpConst8 {
  8673				break
  8674			}
  8675			c := v_1.AuxInt
  8676			if !(smagicOK(8, c)) {
  8677				break
  8678			}
  8679			v.reset(OpSub8)
  8680			v.Type = t
  8681			v0 := b.NewValue0(v.Pos, OpRsh32x64, t)
  8682			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
  8683			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  8684			v2.AuxInt = int64(smagic(8, c).m)
  8685			v1.AddArg(v2)
  8686			v3 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
  8687			v3.AddArg(x)
  8688			v1.AddArg(v3)
  8689			v0.AddArg(v1)
  8690			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8691			v4.AuxInt = 8 + smagic(8, c).s
  8692			v0.AddArg(v4)
  8693			v.AddArg(v0)
  8694			v5 := b.NewValue0(v.Pos, OpRsh32x64, t)
  8695			v6 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
  8696			v6.AddArg(x)
  8697			v5.AddArg(v6)
  8698			v7 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8699			v7.AuxInt = 31
  8700			v5.AddArg(v7)
  8701			v.AddArg(v5)
  8702			return true
  8703		}
  8704		return false
  8705	}
  8706	func rewriteValuegeneric_OpDiv8u_0(v *Value) bool {
  8707		b := v.Block
  8708		typ := &b.Func.Config.Types
  8709		// match: (Div8u (Const8 [c]) (Const8 [d]))
  8710		// cond: d != 0
  8711		// result: (Const8 [int64(int8(uint8(c)/uint8(d)))])
  8712		for {
  8713			_ = v.Args[1]
  8714			v_0 := v.Args[0]
  8715			if v_0.Op != OpConst8 {
  8716				break
  8717			}
  8718			c := v_0.AuxInt
  8719			v_1 := v.Args[1]
  8720			if v_1.Op != OpConst8 {
  8721				break
  8722			}
  8723			d := v_1.AuxInt
  8724			if !(d != 0) {
  8725				break
  8726			}
  8727			v.reset(OpConst8)
  8728			v.AuxInt = int64(int8(uint8(c) / uint8(d)))
  8729			return true
  8730		}
  8731		// match: (Div8u n (Const8 [c]))
  8732		// cond: isPowerOfTwo(c&0xff)
  8733		// result: (Rsh8Ux64 n (Const64 <typ.UInt64> [log2(c&0xff)]))
  8734		for {
  8735			_ = v.Args[1]
  8736			n := v.Args[0]
  8737			v_1 := v.Args[1]
  8738			if v_1.Op != OpConst8 {
  8739				break
  8740			}
  8741			c := v_1.AuxInt
  8742			if !(isPowerOfTwo(c & 0xff)) {
  8743				break
  8744			}
  8745			v.reset(OpRsh8Ux64)
  8746			v.AddArg(n)
  8747			v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8748			v0.AuxInt = log2(c & 0xff)
  8749			v.AddArg(v0)
  8750			return true
  8751		}
  8752		// match: (Div8u x (Const8 [c]))
  8753		// cond: umagicOK(8, c)
  8754		// result: (Trunc32to8 (Rsh32Ux64 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(1<<8+umagic(8,c).m)]) (ZeroExt8to32 x)) (Const64 <typ.UInt64> [8+umagic(8,c).s])))
  8755		for {
  8756			_ = v.Args[1]
  8757			x := v.Args[0]
  8758			v_1 := v.Args[1]
  8759			if v_1.Op != OpConst8 {
  8760				break
  8761			}
  8762			c := v_1.AuxInt
  8763			if !(umagicOK(8, c)) {
  8764				break
  8765			}
  8766			v.reset(OpTrunc32to8)
  8767			v0 := b.NewValue0(v.Pos, OpRsh32Ux64, typ.UInt32)
  8768			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
  8769			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  8770			v2.AuxInt = int64(1<<8 + umagic(8, c).m)
  8771			v1.AddArg(v2)
  8772			v3 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
  8773			v3.AddArg(x)
  8774			v1.AddArg(v3)
  8775			v0.AddArg(v1)
  8776			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8777			v4.AuxInt = 8 + umagic(8, c).s
  8778			v0.AddArg(v4)
  8779			v.AddArg(v0)
  8780			return true
  8781		}
  8782		return false
  8783	}
  8784	func rewriteValuegeneric_OpEq16_0(v *Value) bool {
  8785		b := v.Block
  8786		config := b.Func.Config
  8787		typ := &b.Func.Config.Types
  8788		// match: (Eq16 x x)
  8789		// cond:
  8790		// result: (ConstBool [1])
  8791		for {
  8792			x := v.Args[1]
  8793			if x != v.Args[0] {
  8794				break
  8795			}
  8796			v.reset(OpConstBool)
  8797			v.AuxInt = 1
  8798			return true
  8799		}
  8800		// match: (Eq16 (Const16 <t> [c]) (Add16 (Const16 <t> [d]) x))
  8801		// cond:
  8802		// result: (Eq16 (Const16 <t> [int64(int16(c-d))]) x)
  8803		for {
  8804			_ = v.Args[1]
  8805			v_0 := v.Args[0]
  8806			if v_0.Op != OpConst16 {
  8807				break
  8808			}
  8809			t := v_0.Type
  8810			c := v_0.AuxInt
  8811			v_1 := v.Args[1]
  8812			if v_1.Op != OpAdd16 {
  8813				break
  8814			}
  8815			x := v_1.Args[1]
  8816			v_1_0 := v_1.Args[0]
  8817			if v_1_0.Op != OpConst16 {
  8818				break
  8819			}
  8820			if v_1_0.Type != t {
  8821				break
  8822			}
  8823			d := v_1_0.AuxInt
  8824			v.reset(OpEq16)
  8825			v0 := b.NewValue0(v.Pos, OpConst16, t)
  8826			v0.AuxInt = int64(int16(c - d))
  8827			v.AddArg(v0)
  8828			v.AddArg(x)
  8829			return true
  8830		}
  8831		// match: (Eq16 (Const16 <t> [c]) (Add16 x (Const16 <t> [d])))
  8832		// cond:
  8833		// result: (Eq16 (Const16 <t> [int64(int16(c-d))]) x)
  8834		for {
  8835			_ = v.Args[1]
  8836			v_0 := v.Args[0]
  8837			if v_0.Op != OpConst16 {
  8838				break
  8839			}
  8840			t := v_0.Type
  8841			c := v_0.AuxInt
  8842			v_1 := v.Args[1]
  8843			if v_1.Op != OpAdd16 {
  8844				break
  8845			}
  8846			_ = v_1.Args[1]
  8847			x := v_1.Args[0]
  8848			v_1_1 := v_1.Args[1]
  8849			if v_1_1.Op != OpConst16 {
  8850				break
  8851			}
  8852			if v_1_1.Type != t {
  8853				break
  8854			}
  8855			d := v_1_1.AuxInt
  8856			v.reset(OpEq16)
  8857			v0 := b.NewValue0(v.Pos, OpConst16, t)
  8858			v0.AuxInt = int64(int16(c - d))
  8859			v.AddArg(v0)
  8860			v.AddArg(x)
  8861			return true
  8862		}
  8863		// match: (Eq16 (Add16 (Const16 <t> [d]) x) (Const16 <t> [c]))
  8864		// cond:
  8865		// result: (Eq16 (Const16 <t> [int64(int16(c-d))]) x)
  8866		for {
  8867			_ = v.Args[1]
  8868			v_0 := v.Args[0]
  8869			if v_0.Op != OpAdd16 {
  8870				break
  8871			}
  8872			x := v_0.Args[1]
  8873			v_0_0 := v_0.Args[0]
  8874			if v_0_0.Op != OpConst16 {
  8875				break
  8876			}
  8877			t := v_0_0.Type
  8878			d := v_0_0.AuxInt
  8879			v_1 := v.Args[1]
  8880			if v_1.Op != OpConst16 {
  8881				break
  8882			}
  8883			if v_1.Type != t {
  8884				break
  8885			}
  8886			c := v_1.AuxInt
  8887			v.reset(OpEq16)
  8888			v0 := b.NewValue0(v.Pos, OpConst16, t)
  8889			v0.AuxInt = int64(int16(c - d))
  8890			v.AddArg(v0)
  8891			v.AddArg(x)
  8892			return true
  8893		}
  8894		// match: (Eq16 (Add16 x (Const16 <t> [d])) (Const16 <t> [c]))
  8895		// cond:
  8896		// result: (Eq16 (Const16 <t> [int64(int16(c-d))]) x)
  8897		for {
  8898			_ = v.Args[1]
  8899			v_0 := v.Args[0]
  8900			if v_0.Op != OpAdd16 {
  8901				break
  8902			}
  8903			_ = v_0.Args[1]
  8904			x := v_0.Args[0]
  8905			v_0_1 := v_0.Args[1]
  8906			if v_0_1.Op != OpConst16 {
  8907				break
  8908			}
  8909			t := v_0_1.Type
  8910			d := v_0_1.AuxInt
  8911			v_1 := v.Args[1]
  8912			if v_1.Op != OpConst16 {
  8913				break
  8914			}
  8915			if v_1.Type != t {
  8916				break
  8917			}
  8918			c := v_1.AuxInt
  8919			v.reset(OpEq16)
  8920			v0 := b.NewValue0(v.Pos, OpConst16, t)
  8921			v0.AuxInt = int64(int16(c - d))
  8922			v.AddArg(v0)
  8923			v.AddArg(x)
  8924			return true
  8925		}
  8926		// match: (Eq16 (Const16 [c]) (Const16 [d]))
  8927		// cond:
  8928		// result: (ConstBool [b2i(c == d)])
  8929		for {
  8930			_ = v.Args[1]
  8931			v_0 := v.Args[0]
  8932			if v_0.Op != OpConst16 {
  8933				break
  8934			}
  8935			c := v_0.AuxInt
  8936			v_1 := v.Args[1]
  8937			if v_1.Op != OpConst16 {
  8938				break
  8939			}
  8940			d := v_1.AuxInt
  8941			v.reset(OpConstBool)
  8942			v.AuxInt = b2i(c == d)
  8943			return true
  8944		}
  8945		// match: (Eq16 (Const16 [d]) (Const16 [c]))
  8946		// cond:
  8947		// result: (ConstBool [b2i(c == d)])
  8948		for {
  8949			_ = v.Args[1]
  8950			v_0 := v.Args[0]
  8951			if v_0.Op != OpConst16 {
  8952				break
  8953			}
  8954			d := v_0.AuxInt
  8955			v_1 := v.Args[1]
  8956			if v_1.Op != OpConst16 {
  8957				break
  8958			}
  8959			c := v_1.AuxInt
  8960			v.reset(OpConstBool)
  8961			v.AuxInt = b2i(c == d)
  8962			return true
  8963		}
  8964		// match: (Eq16 (Mod16u x (Const16 [c])) (Const16 [0]))
  8965		// cond: x.Op != OpConst16 && udivisibleOK(16,c) && !hasSmallRotate(config)
  8966		// result: (Eq32 (Mod32u <typ.UInt32> (ZeroExt16to32 <typ.UInt32> x) (Const32 <typ.UInt32> [c&0xffff])) (Const32 <typ.UInt32> [0]))
  8967		for {
  8968			_ = v.Args[1]
  8969			v_0 := v.Args[0]
  8970			if v_0.Op != OpMod16u {
  8971				break
  8972			}
  8973			_ = v_0.Args[1]
  8974			x := v_0.Args[0]
  8975			v_0_1 := v_0.Args[1]
  8976			if v_0_1.Op != OpConst16 {
  8977				break
  8978			}
  8979			c := v_0_1.AuxInt
  8980			v_1 := v.Args[1]
  8981			if v_1.Op != OpConst16 {
  8982				break
  8983			}
  8984			if v_1.AuxInt != 0 {
  8985				break
  8986			}
  8987			if !(x.Op != OpConst16 && udivisibleOK(16, c) && !hasSmallRotate(config)) {
  8988				break
  8989			}
  8990			v.reset(OpEq32)
  8991			v0 := b.NewValue0(v.Pos, OpMod32u, typ.UInt32)
  8992			v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
  8993			v1.AddArg(x)
  8994			v0.AddArg(v1)
  8995			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  8996			v2.AuxInt = c & 0xffff
  8997			v0.AddArg(v2)
  8998			v.AddArg(v0)
  8999			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  9000			v3.AuxInt = 0
  9001			v.AddArg(v3)
  9002			return true
  9003		}
  9004		// match: (Eq16 (Const16 [0]) (Mod16u x (Const16 [c])))
  9005		// cond: x.Op != OpConst16 && udivisibleOK(16,c) && !hasSmallRotate(config)
  9006		// result: (Eq32 (Mod32u <typ.UInt32> (ZeroExt16to32 <typ.UInt32> x) (Const32 <typ.UInt32> [c&0xffff])) (Const32 <typ.UInt32> [0]))
  9007		for {
  9008			_ = v.Args[1]
  9009			v_0 := v.Args[0]
  9010			if v_0.Op != OpConst16 {
  9011				break
  9012			}
  9013			if v_0.AuxInt != 0 {
  9014				break
  9015			}
  9016			v_1 := v.Args[1]
  9017			if v_1.Op != OpMod16u {
  9018				break
  9019			}
  9020			_ = v_1.Args[1]
  9021			x := v_1.Args[0]
  9022			v_1_1 := v_1.Args[1]
  9023			if v_1_1.Op != OpConst16 {
  9024				break
  9025			}
  9026			c := v_1_1.AuxInt
  9027			if !(x.Op != OpConst16 && udivisibleOK(16, c) && !hasSmallRotate(config)) {
  9028				break
  9029			}
  9030			v.reset(OpEq32)
  9031			v0 := b.NewValue0(v.Pos, OpMod32u, typ.UInt32)
  9032			v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
  9033			v1.AddArg(x)
  9034			v0.AddArg(v1)
  9035			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  9036			v2.AuxInt = c & 0xffff
  9037			v0.AddArg(v2)
  9038			v.AddArg(v0)
  9039			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  9040			v3.AuxInt = 0
  9041			v.AddArg(v3)
  9042			return true
  9043		}
  9044		// match: (Eq16 (Mod16 x (Const16 [c])) (Const16 [0]))
  9045		// cond: x.Op != OpConst16 && sdivisibleOK(16,c) && !hasSmallRotate(config)
  9046		// result: (Eq32 (Mod32 <typ.Int32> (SignExt16to32 <typ.Int32> x) (Const32 <typ.Int32> [c])) (Const32 <typ.Int32> [0]))
  9047		for {
  9048			_ = v.Args[1]
  9049			v_0 := v.Args[0]
  9050			if v_0.Op != OpMod16 {
  9051				break
  9052			}
  9053			_ = v_0.Args[1]
  9054			x := v_0.Args[0]
  9055			v_0_1 := v_0.Args[1]
  9056			if v_0_1.Op != OpConst16 {
  9057				break
  9058			}
  9059			c := v_0_1.AuxInt
  9060			v_1 := v.Args[1]
  9061			if v_1.Op != OpConst16 {
  9062				break
  9063			}
  9064			if v_1.AuxInt != 0 {
  9065				break
  9066			}
  9067			if !(x.Op != OpConst16 && sdivisibleOK(16, c) && !hasSmallRotate(config)) {
  9068				break
  9069			}
  9070			v.reset(OpEq32)
  9071			v0 := b.NewValue0(v.Pos, OpMod32, typ.Int32)
  9072			v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
  9073			v1.AddArg(x)
  9074			v0.AddArg(v1)
  9075			v2 := b.NewValue0(v.Pos, OpConst32, typ.Int32)
  9076			v2.AuxInt = c
  9077			v0.AddArg(v2)
  9078			v.AddArg(v0)
  9079			v3 := b.NewValue0(v.Pos, OpConst32, typ.Int32)
  9080			v3.AuxInt = 0
  9081			v.AddArg(v3)
  9082			return true
  9083		}
  9084		return false
  9085	}
  9086	func rewriteValuegeneric_OpEq16_10(v *Value) bool {
  9087		b := v.Block
  9088		config := b.Func.Config
  9089		typ := &b.Func.Config.Types
  9090		// match: (Eq16 (Const16 [0]) (Mod16 x (Const16 [c])))
  9091		// cond: x.Op != OpConst16 && sdivisibleOK(16,c) && !hasSmallRotate(config)
  9092		// result: (Eq32 (Mod32 <typ.Int32> (SignExt16to32 <typ.Int32> x) (Const32 <typ.Int32> [c])) (Const32 <typ.Int32> [0]))
  9093		for {
  9094			_ = v.Args[1]
  9095			v_0 := v.Args[0]
  9096			if v_0.Op != OpConst16 {
  9097				break
  9098			}
  9099			if v_0.AuxInt != 0 {
  9100				break
  9101			}
  9102			v_1 := v.Args[1]
  9103			if v_1.Op != OpMod16 {
  9104				break
  9105			}
  9106			_ = v_1.Args[1]
  9107			x := v_1.Args[0]
  9108			v_1_1 := v_1.Args[1]
  9109			if v_1_1.Op != OpConst16 {
  9110				break
  9111			}
  9112			c := v_1_1.AuxInt
  9113			if !(x.Op != OpConst16 && sdivisibleOK(16, c) && !hasSmallRotate(config)) {
  9114				break
  9115			}
  9116			v.reset(OpEq32)
  9117			v0 := b.NewValue0(v.Pos, OpMod32, typ.Int32)
  9118			v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
  9119			v1.AddArg(x)
  9120			v0.AddArg(v1)
  9121			v2 := b.NewValue0(v.Pos, OpConst32, typ.Int32)
  9122			v2.AuxInt = c
  9123			v0.AddArg(v2)
  9124			v.AddArg(v0)
  9125			v3 := b.NewValue0(v.Pos, OpConst32, typ.Int32)
  9126			v3.AuxInt = 0
  9127			v.AddArg(v3)
  9128			return true
  9129		}
  9130		// match: (Eq16 x (Mul16 (Const16 [c]) (Trunc64to16 (Rsh64Ux64 mul:(Mul64 (Const64 [m]) (ZeroExt16to64 x)) (Const64 [s])))))
  9131		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<16+umagic(16,c).m) && s == 16+umagic(16,c).s && x.Op != OpConst16 && udivisibleOK(16,c)
  9132		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) )
  9133		for {
  9134			_ = v.Args[1]
  9135			x := v.Args[0]
  9136			v_1 := v.Args[1]
  9137			if v_1.Op != OpMul16 {
  9138				break
  9139			}
  9140			_ = v_1.Args[1]
  9141			v_1_0 := v_1.Args[0]
  9142			if v_1_0.Op != OpConst16 {
  9143				break
  9144			}
  9145			c := v_1_0.AuxInt
  9146			v_1_1 := v_1.Args[1]
  9147			if v_1_1.Op != OpTrunc64to16 {
  9148				break
  9149			}
  9150			v_1_1_0 := v_1_1.Args[0]
  9151			if v_1_1_0.Op != OpRsh64Ux64 {
  9152				break
  9153			}
  9154			_ = v_1_1_0.Args[1]
  9155			mul := v_1_1_0.Args[0]
  9156			if mul.Op != OpMul64 {
  9157				break
  9158			}
  9159			_ = mul.Args[1]
  9160			mul_0 := mul.Args[0]
  9161			if mul_0.Op != OpConst64 {
  9162				break
  9163			}
  9164			m := mul_0.AuxInt
  9165			mul_1 := mul.Args[1]
  9166			if mul_1.Op != OpZeroExt16to64 {
  9167				break
  9168			}
  9169			if x != mul_1.Args[0] {
  9170				break
  9171			}
  9172			v_1_1_0_1 := v_1_1_0.Args[1]
  9173			if v_1_1_0_1.Op != OpConst64 {
  9174				break
  9175			}
  9176			s := v_1_1_0_1.AuxInt
  9177			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<16+umagic(16, c).m) && s == 16+umagic(16, c).s && x.Op != OpConst16 && udivisibleOK(16, c)) {
  9178				break
  9179			}
  9180			v.reset(OpLeq16U)
  9181			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
  9182			v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
  9183			v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9184			v2.AuxInt = int64(int16(udivisible(16, c).m))
  9185			v1.AddArg(v2)
  9186			v1.AddArg(x)
  9187			v0.AddArg(v1)
  9188			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9189			v3.AuxInt = int64(16 - udivisible(16, c).k)
  9190			v0.AddArg(v3)
  9191			v.AddArg(v0)
  9192			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9193			v4.AuxInt = int64(int16(udivisible(16, c).max))
  9194			v.AddArg(v4)
  9195			return true
  9196		}
  9197		// match: (Eq16 x (Mul16 (Const16 [c]) (Trunc64to16 (Rsh64Ux64 mul:(Mul64 (ZeroExt16to64 x) (Const64 [m])) (Const64 [s])))))
  9198		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<16+umagic(16,c).m) && s == 16+umagic(16,c).s && x.Op != OpConst16 && udivisibleOK(16,c)
  9199		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) )
  9200		for {
  9201			_ = v.Args[1]
  9202			x := v.Args[0]
  9203			v_1 := v.Args[1]
  9204			if v_1.Op != OpMul16 {
  9205				break
  9206			}
  9207			_ = v_1.Args[1]
  9208			v_1_0 := v_1.Args[0]
  9209			if v_1_0.Op != OpConst16 {
  9210				break
  9211			}
  9212			c := v_1_0.AuxInt
  9213			v_1_1 := v_1.Args[1]
  9214			if v_1_1.Op != OpTrunc64to16 {
  9215				break
  9216			}
  9217			v_1_1_0 := v_1_1.Args[0]
  9218			if v_1_1_0.Op != OpRsh64Ux64 {
  9219				break
  9220			}
  9221			_ = v_1_1_0.Args[1]
  9222			mul := v_1_1_0.Args[0]
  9223			if mul.Op != OpMul64 {
  9224				break
  9225			}
  9226			_ = mul.Args[1]
  9227			mul_0 := mul.Args[0]
  9228			if mul_0.Op != OpZeroExt16to64 {
  9229				break
  9230			}
  9231			if x != mul_0.Args[0] {
  9232				break
  9233			}
  9234			mul_1 := mul.Args[1]
  9235			if mul_1.Op != OpConst64 {
  9236				break
  9237			}
  9238			m := mul_1.AuxInt
  9239			v_1_1_0_1 := v_1_1_0.Args[1]
  9240			if v_1_1_0_1.Op != OpConst64 {
  9241				break
  9242			}
  9243			s := v_1_1_0_1.AuxInt
  9244			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<16+umagic(16, c).m) && s == 16+umagic(16, c).s && x.Op != OpConst16 && udivisibleOK(16, c)) {
  9245				break
  9246			}
  9247			v.reset(OpLeq16U)
  9248			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
  9249			v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
  9250			v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9251			v2.AuxInt = int64(int16(udivisible(16, c).m))
  9252			v1.AddArg(v2)
  9253			v1.AddArg(x)
  9254			v0.AddArg(v1)
  9255			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9256			v3.AuxInt = int64(16 - udivisible(16, c).k)
  9257			v0.AddArg(v3)
  9258			v.AddArg(v0)
  9259			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9260			v4.AuxInt = int64(int16(udivisible(16, c).max))
  9261			v.AddArg(v4)
  9262			return true
  9263		}
  9264		// match: (Eq16 x (Mul16 (Trunc64to16 (Rsh64Ux64 mul:(Mul64 (Const64 [m]) (ZeroExt16to64 x)) (Const64 [s]))) (Const16 [c])))
  9265		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<16+umagic(16,c).m) && s == 16+umagic(16,c).s && x.Op != OpConst16 && udivisibleOK(16,c)
  9266		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) )
  9267		for {
  9268			_ = v.Args[1]
  9269			x := v.Args[0]
  9270			v_1 := v.Args[1]
  9271			if v_1.Op != OpMul16 {
  9272				break
  9273			}
  9274			_ = v_1.Args[1]
  9275			v_1_0 := v_1.Args[0]
  9276			if v_1_0.Op != OpTrunc64to16 {
  9277				break
  9278			}
  9279			v_1_0_0 := v_1_0.Args[0]
  9280			if v_1_0_0.Op != OpRsh64Ux64 {
  9281				break
  9282			}
  9283			_ = v_1_0_0.Args[1]
  9284			mul := v_1_0_0.Args[0]
  9285			if mul.Op != OpMul64 {
  9286				break
  9287			}
  9288			_ = mul.Args[1]
  9289			mul_0 := mul.Args[0]
  9290			if mul_0.Op != OpConst64 {
  9291				break
  9292			}
  9293			m := mul_0.AuxInt
  9294			mul_1 := mul.Args[1]
  9295			if mul_1.Op != OpZeroExt16to64 {
  9296				break
  9297			}
  9298			if x != mul_1.Args[0] {
  9299				break
  9300			}
  9301			v_1_0_0_1 := v_1_0_0.Args[1]
  9302			if v_1_0_0_1.Op != OpConst64 {
  9303				break
  9304			}
  9305			s := v_1_0_0_1.AuxInt
  9306			v_1_1 := v_1.Args[1]
  9307			if v_1_1.Op != OpConst16 {
  9308				break
  9309			}
  9310			c := v_1_1.AuxInt
  9311			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<16+umagic(16, c).m) && s == 16+umagic(16, c).s && x.Op != OpConst16 && udivisibleOK(16, c)) {
  9312				break
  9313			}
  9314			v.reset(OpLeq16U)
  9315			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
  9316			v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
  9317			v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9318			v2.AuxInt = int64(int16(udivisible(16, c).m))
  9319			v1.AddArg(v2)
  9320			v1.AddArg(x)
  9321			v0.AddArg(v1)
  9322			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9323			v3.AuxInt = int64(16 - udivisible(16, c).k)
  9324			v0.AddArg(v3)
  9325			v.AddArg(v0)
  9326			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9327			v4.AuxInt = int64(int16(udivisible(16, c).max))
  9328			v.AddArg(v4)
  9329			return true
  9330		}
  9331		// match: (Eq16 x (Mul16 (Trunc64to16 (Rsh64Ux64 mul:(Mul64 (ZeroExt16to64 x) (Const64 [m])) (Const64 [s]))) (Const16 [c])))
  9332		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<16+umagic(16,c).m) && s == 16+umagic(16,c).s && x.Op != OpConst16 && udivisibleOK(16,c)
  9333		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) )
  9334		for {
  9335			_ = v.Args[1]
  9336			x := v.Args[0]
  9337			v_1 := v.Args[1]
  9338			if v_1.Op != OpMul16 {
  9339				break
  9340			}
  9341			_ = v_1.Args[1]
  9342			v_1_0 := v_1.Args[0]
  9343			if v_1_0.Op != OpTrunc64to16 {
  9344				break
  9345			}
  9346			v_1_0_0 := v_1_0.Args[0]
  9347			if v_1_0_0.Op != OpRsh64Ux64 {
  9348				break
  9349			}
  9350			_ = v_1_0_0.Args[1]
  9351			mul := v_1_0_0.Args[0]
  9352			if mul.Op != OpMul64 {
  9353				break
  9354			}
  9355			_ = mul.Args[1]
  9356			mul_0 := mul.Args[0]
  9357			if mul_0.Op != OpZeroExt16to64 {
  9358				break
  9359			}
  9360			if x != mul_0.Args[0] {
  9361				break
  9362			}
  9363			mul_1 := mul.Args[1]
  9364			if mul_1.Op != OpConst64 {
  9365				break
  9366			}
  9367			m := mul_1.AuxInt
  9368			v_1_0_0_1 := v_1_0_0.Args[1]
  9369			if v_1_0_0_1.Op != OpConst64 {
  9370				break
  9371			}
  9372			s := v_1_0_0_1.AuxInt
  9373			v_1_1 := v_1.Args[1]
  9374			if v_1_1.Op != OpConst16 {
  9375				break
  9376			}
  9377			c := v_1_1.AuxInt
  9378			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<16+umagic(16, c).m) && s == 16+umagic(16, c).s && x.Op != OpConst16 && udivisibleOK(16, c)) {
  9379				break
  9380			}
  9381			v.reset(OpLeq16U)
  9382			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
  9383			v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
  9384			v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9385			v2.AuxInt = int64(int16(udivisible(16, c).m))
  9386			v1.AddArg(v2)
  9387			v1.AddArg(x)
  9388			v0.AddArg(v1)
  9389			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9390			v3.AuxInt = int64(16 - udivisible(16, c).k)
  9391			v0.AddArg(v3)
  9392			v.AddArg(v0)
  9393			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9394			v4.AuxInt = int64(int16(udivisible(16, c).max))
  9395			v.AddArg(v4)
  9396			return true
  9397		}
  9398		// match: (Eq16 (Mul16 (Const16 [c]) (Trunc64to16 (Rsh64Ux64 mul:(Mul64 (Const64 [m]) (ZeroExt16to64 x)) (Const64 [s])))) x)
  9399		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<16+umagic(16,c).m) && s == 16+umagic(16,c).s && x.Op != OpConst16 && udivisibleOK(16,c)
  9400		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) )
  9401		for {
  9402			x := v.Args[1]
  9403			v_0 := v.Args[0]
  9404			if v_0.Op != OpMul16 {
  9405				break
  9406			}
  9407			_ = v_0.Args[1]
  9408			v_0_0 := v_0.Args[0]
  9409			if v_0_0.Op != OpConst16 {
  9410				break
  9411			}
  9412			c := v_0_0.AuxInt
  9413			v_0_1 := v_0.Args[1]
  9414			if v_0_1.Op != OpTrunc64to16 {
  9415				break
  9416			}
  9417			v_0_1_0 := v_0_1.Args[0]
  9418			if v_0_1_0.Op != OpRsh64Ux64 {
  9419				break
  9420			}
  9421			_ = v_0_1_0.Args[1]
  9422			mul := v_0_1_0.Args[0]
  9423			if mul.Op != OpMul64 {
  9424				break
  9425			}
  9426			_ = mul.Args[1]
  9427			mul_0 := mul.Args[0]
  9428			if mul_0.Op != OpConst64 {
  9429				break
  9430			}
  9431			m := mul_0.AuxInt
  9432			mul_1 := mul.Args[1]
  9433			if mul_1.Op != OpZeroExt16to64 {
  9434				break
  9435			}
  9436			if x != mul_1.Args[0] {
  9437				break
  9438			}
  9439			v_0_1_0_1 := v_0_1_0.Args[1]
  9440			if v_0_1_0_1.Op != OpConst64 {
  9441				break
  9442			}
  9443			s := v_0_1_0_1.AuxInt
  9444			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<16+umagic(16, c).m) && s == 16+umagic(16, c).s && x.Op != OpConst16 && udivisibleOK(16, c)) {
  9445				break
  9446			}
  9447			v.reset(OpLeq16U)
  9448			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
  9449			v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
  9450			v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9451			v2.AuxInt = int64(int16(udivisible(16, c).m))
  9452			v1.AddArg(v2)
  9453			v1.AddArg(x)
  9454			v0.AddArg(v1)
  9455			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9456			v3.AuxInt = int64(16 - udivisible(16, c).k)
  9457			v0.AddArg(v3)
  9458			v.AddArg(v0)
  9459			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9460			v4.AuxInt = int64(int16(udivisible(16, c).max))
  9461			v.AddArg(v4)
  9462			return true
  9463		}
  9464		// match: (Eq16 (Mul16 (Const16 [c]) (Trunc64to16 (Rsh64Ux64 mul:(Mul64 (ZeroExt16to64 x) (Const64 [m])) (Const64 [s])))) x)
  9465		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<16+umagic(16,c).m) && s == 16+umagic(16,c).s && x.Op != OpConst16 && udivisibleOK(16,c)
  9466		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) )
  9467		for {
  9468			x := v.Args[1]
  9469			v_0 := v.Args[0]
  9470			if v_0.Op != OpMul16 {
  9471				break
  9472			}
  9473			_ = v_0.Args[1]
  9474			v_0_0 := v_0.Args[0]
  9475			if v_0_0.Op != OpConst16 {
  9476				break
  9477			}
  9478			c := v_0_0.AuxInt
  9479			v_0_1 := v_0.Args[1]
  9480			if v_0_1.Op != OpTrunc64to16 {
  9481				break
  9482			}
  9483			v_0_1_0 := v_0_1.Args[0]
  9484			if v_0_1_0.Op != OpRsh64Ux64 {
  9485				break
  9486			}
  9487			_ = v_0_1_0.Args[1]
  9488			mul := v_0_1_0.Args[0]
  9489			if mul.Op != OpMul64 {
  9490				break
  9491			}
  9492			_ = mul.Args[1]
  9493			mul_0 := mul.Args[0]
  9494			if mul_0.Op != OpZeroExt16to64 {
  9495				break
  9496			}
  9497			if x != mul_0.Args[0] {
  9498				break
  9499			}
  9500			mul_1 := mul.Args[1]
  9501			if mul_1.Op != OpConst64 {
  9502				break
  9503			}
  9504			m := mul_1.AuxInt
  9505			v_0_1_0_1 := v_0_1_0.Args[1]
  9506			if v_0_1_0_1.Op != OpConst64 {
  9507				break
  9508			}
  9509			s := v_0_1_0_1.AuxInt
  9510			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<16+umagic(16, c).m) && s == 16+umagic(16, c).s && x.Op != OpConst16 && udivisibleOK(16, c)) {
  9511				break
  9512			}
  9513			v.reset(OpLeq16U)
  9514			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
  9515			v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
  9516			v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9517			v2.AuxInt = int64(int16(udivisible(16, c).m))
  9518			v1.AddArg(v2)
  9519			v1.AddArg(x)
  9520			v0.AddArg(v1)
  9521			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9522			v3.AuxInt = int64(16 - udivisible(16, c).k)
  9523			v0.AddArg(v3)
  9524			v.AddArg(v0)
  9525			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9526			v4.AuxInt = int64(int16(udivisible(16, c).max))
  9527			v.AddArg(v4)
  9528			return true
  9529		}
  9530		// match: (Eq16 (Mul16 (Trunc64to16 (Rsh64Ux64 mul:(Mul64 (Const64 [m]) (ZeroExt16to64 x)) (Const64 [s]))) (Const16 [c])) x)
  9531		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<16+umagic(16,c).m) && s == 16+umagic(16,c).s && x.Op != OpConst16 && udivisibleOK(16,c)
  9532		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) )
  9533		for {
  9534			x := v.Args[1]
  9535			v_0 := v.Args[0]
  9536			if v_0.Op != OpMul16 {
  9537				break
  9538			}
  9539			_ = v_0.Args[1]
  9540			v_0_0 := v_0.Args[0]
  9541			if v_0_0.Op != OpTrunc64to16 {
  9542				break
  9543			}
  9544			v_0_0_0 := v_0_0.Args[0]
  9545			if v_0_0_0.Op != OpRsh64Ux64 {
  9546				break
  9547			}
  9548			_ = v_0_0_0.Args[1]
  9549			mul := v_0_0_0.Args[0]
  9550			if mul.Op != OpMul64 {
  9551				break
  9552			}
  9553			_ = mul.Args[1]
  9554			mul_0 := mul.Args[0]
  9555			if mul_0.Op != OpConst64 {
  9556				break
  9557			}
  9558			m := mul_0.AuxInt
  9559			mul_1 := mul.Args[1]
  9560			if mul_1.Op != OpZeroExt16to64 {
  9561				break
  9562			}
  9563			if x != mul_1.Args[0] {
  9564				break
  9565			}
  9566			v_0_0_0_1 := v_0_0_0.Args[1]
  9567			if v_0_0_0_1.Op != OpConst64 {
  9568				break
  9569			}
  9570			s := v_0_0_0_1.AuxInt
  9571			v_0_1 := v_0.Args[1]
  9572			if v_0_1.Op != OpConst16 {
  9573				break
  9574			}
  9575			c := v_0_1.AuxInt
  9576			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<16+umagic(16, c).m) && s == 16+umagic(16, c).s && x.Op != OpConst16 && udivisibleOK(16, c)) {
  9577				break
  9578			}
  9579			v.reset(OpLeq16U)
  9580			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
  9581			v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
  9582			v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9583			v2.AuxInt = int64(int16(udivisible(16, c).m))
  9584			v1.AddArg(v2)
  9585			v1.AddArg(x)
  9586			v0.AddArg(v1)
  9587			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9588			v3.AuxInt = int64(16 - udivisible(16, c).k)
  9589			v0.AddArg(v3)
  9590			v.AddArg(v0)
  9591			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9592			v4.AuxInt = int64(int16(udivisible(16, c).max))
  9593			v.AddArg(v4)
  9594			return true
  9595		}
  9596		// match: (Eq16 (Mul16 (Trunc64to16 (Rsh64Ux64 mul:(Mul64 (ZeroExt16to64 x) (Const64 [m])) (Const64 [s]))) (Const16 [c])) x)
  9597		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<16+umagic(16,c).m) && s == 16+umagic(16,c).s && x.Op != OpConst16 && udivisibleOK(16,c)
  9598		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) )
  9599		for {
  9600			x := v.Args[1]
  9601			v_0 := v.Args[0]
  9602			if v_0.Op != OpMul16 {
  9603				break
  9604			}
  9605			_ = v_0.Args[1]
  9606			v_0_0 := v_0.Args[0]
  9607			if v_0_0.Op != OpTrunc64to16 {
  9608				break
  9609			}
  9610			v_0_0_0 := v_0_0.Args[0]
  9611			if v_0_0_0.Op != OpRsh64Ux64 {
  9612				break
  9613			}
  9614			_ = v_0_0_0.Args[1]
  9615			mul := v_0_0_0.Args[0]
  9616			if mul.Op != OpMul64 {
  9617				break
  9618			}
  9619			_ = mul.Args[1]
  9620			mul_0 := mul.Args[0]
  9621			if mul_0.Op != OpZeroExt16to64 {
  9622				break
  9623			}
  9624			if x != mul_0.Args[0] {
  9625				break
  9626			}
  9627			mul_1 := mul.Args[1]
  9628			if mul_1.Op != OpConst64 {
  9629				break
  9630			}
  9631			m := mul_1.AuxInt
  9632			v_0_0_0_1 := v_0_0_0.Args[1]
  9633			if v_0_0_0_1.Op != OpConst64 {
  9634				break
  9635			}
  9636			s := v_0_0_0_1.AuxInt
  9637			v_0_1 := v_0.Args[1]
  9638			if v_0_1.Op != OpConst16 {
  9639				break
  9640			}
  9641			c := v_0_1.AuxInt
  9642			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<16+umagic(16, c).m) && s == 16+umagic(16, c).s && x.Op != OpConst16 && udivisibleOK(16, c)) {
  9643				break
  9644			}
  9645			v.reset(OpLeq16U)
  9646			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
  9647			v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
  9648			v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9649			v2.AuxInt = int64(int16(udivisible(16, c).m))
  9650			v1.AddArg(v2)
  9651			v1.AddArg(x)
  9652			v0.AddArg(v1)
  9653			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9654			v3.AuxInt = int64(16 - udivisible(16, c).k)
  9655			v0.AddArg(v3)
  9656			v.AddArg(v0)
  9657			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9658			v4.AuxInt = int64(int16(udivisible(16, c).max))
  9659			v.AddArg(v4)
  9660			return true
  9661		}
  9662		// match: (Eq16 x (Mul16 (Const16 [c]) (Trunc32to16 (Rsh32Ux64 mul:(Mul32 (Const32 [m]) (ZeroExt16to32 x)) (Const64 [s])))))
  9663		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+umagic(16,c).m/2) && s == 16+umagic(16,c).s-1 && x.Op != OpConst16 && udivisibleOK(16,c)
  9664		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) )
  9665		for {
  9666			_ = v.Args[1]
  9667			x := v.Args[0]
  9668			v_1 := v.Args[1]
  9669			if v_1.Op != OpMul16 {
  9670				break
  9671			}
  9672			_ = v_1.Args[1]
  9673			v_1_0 := v_1.Args[0]
  9674			if v_1_0.Op != OpConst16 {
  9675				break
  9676			}
  9677			c := v_1_0.AuxInt
  9678			v_1_1 := v_1.Args[1]
  9679			if v_1_1.Op != OpTrunc32to16 {
  9680				break
  9681			}
  9682			v_1_1_0 := v_1_1.Args[0]
  9683			if v_1_1_0.Op != OpRsh32Ux64 {
  9684				break
  9685			}
  9686			_ = v_1_1_0.Args[1]
  9687			mul := v_1_1_0.Args[0]
  9688			if mul.Op != OpMul32 {
  9689				break
  9690			}
  9691			_ = mul.Args[1]
  9692			mul_0 := mul.Args[0]
  9693			if mul_0.Op != OpConst32 {
  9694				break
  9695			}
  9696			m := mul_0.AuxInt
  9697			mul_1 := mul.Args[1]
  9698			if mul_1.Op != OpZeroExt16to32 {
  9699				break
  9700			}
  9701			if x != mul_1.Args[0] {
  9702				break
  9703			}
  9704			v_1_1_0_1 := v_1_1_0.Args[1]
  9705			if v_1_1_0_1.Op != OpConst64 {
  9706				break
  9707			}
  9708			s := v_1_1_0_1.AuxInt
  9709			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+umagic(16, c).m/2) && s == 16+umagic(16, c).s-1 && x.Op != OpConst16 && udivisibleOK(16, c)) {
  9710				break
  9711			}
  9712			v.reset(OpLeq16U)
  9713			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
  9714			v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
  9715			v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9716			v2.AuxInt = int64(int16(udivisible(16, c).m))
  9717			v1.AddArg(v2)
  9718			v1.AddArg(x)
  9719			v0.AddArg(v1)
  9720			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9721			v3.AuxInt = int64(16 - udivisible(16, c).k)
  9722			v0.AddArg(v3)
  9723			v.AddArg(v0)
  9724			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9725			v4.AuxInt = int64(int16(udivisible(16, c).max))
  9726			v.AddArg(v4)
  9727			return true
  9728		}
  9729		return false
  9730	}
  9731	func rewriteValuegeneric_OpEq16_20(v *Value) bool {
  9732		b := v.Block
  9733		typ := &b.Func.Config.Types
  9734		// match: (Eq16 x (Mul16 (Const16 [c]) (Trunc32to16 (Rsh32Ux64 mul:(Mul32 (ZeroExt16to32 x) (Const32 [m])) (Const64 [s])))))
  9735		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+umagic(16,c).m/2) && s == 16+umagic(16,c).s-1 && x.Op != OpConst16 && udivisibleOK(16,c)
  9736		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) )
  9737		for {
  9738			_ = v.Args[1]
  9739			x := v.Args[0]
  9740			v_1 := v.Args[1]
  9741			if v_1.Op != OpMul16 {
  9742				break
  9743			}
  9744			_ = v_1.Args[1]
  9745			v_1_0 := v_1.Args[0]
  9746			if v_1_0.Op != OpConst16 {
  9747				break
  9748			}
  9749			c := v_1_0.AuxInt
  9750			v_1_1 := v_1.Args[1]
  9751			if v_1_1.Op != OpTrunc32to16 {
  9752				break
  9753			}
  9754			v_1_1_0 := v_1_1.Args[0]
  9755			if v_1_1_0.Op != OpRsh32Ux64 {
  9756				break
  9757			}
  9758			_ = v_1_1_0.Args[1]
  9759			mul := v_1_1_0.Args[0]
  9760			if mul.Op != OpMul32 {
  9761				break
  9762			}
  9763			_ = mul.Args[1]
  9764			mul_0 := mul.Args[0]
  9765			if mul_0.Op != OpZeroExt16to32 {
  9766				break
  9767			}
  9768			if x != mul_0.Args[0] {
  9769				break
  9770			}
  9771			mul_1 := mul.Args[1]
  9772			if mul_1.Op != OpConst32 {
  9773				break
  9774			}
  9775			m := mul_1.AuxInt
  9776			v_1_1_0_1 := v_1_1_0.Args[1]
  9777			if v_1_1_0_1.Op != OpConst64 {
  9778				break
  9779			}
  9780			s := v_1_1_0_1.AuxInt
  9781			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+umagic(16, c).m/2) && s == 16+umagic(16, c).s-1 && x.Op != OpConst16 && udivisibleOK(16, c)) {
  9782				break
  9783			}
  9784			v.reset(OpLeq16U)
  9785			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
  9786			v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
  9787			v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9788			v2.AuxInt = int64(int16(udivisible(16, c).m))
  9789			v1.AddArg(v2)
  9790			v1.AddArg(x)
  9791			v0.AddArg(v1)
  9792			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9793			v3.AuxInt = int64(16 - udivisible(16, c).k)
  9794			v0.AddArg(v3)
  9795			v.AddArg(v0)
  9796			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9797			v4.AuxInt = int64(int16(udivisible(16, c).max))
  9798			v.AddArg(v4)
  9799			return true
  9800		}
  9801		// match: (Eq16 x (Mul16 (Trunc32to16 (Rsh32Ux64 mul:(Mul32 (Const32 [m]) (ZeroExt16to32 x)) (Const64 [s]))) (Const16 [c])))
  9802		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+umagic(16,c).m/2) && s == 16+umagic(16,c).s-1 && x.Op != OpConst16 && udivisibleOK(16,c)
  9803		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) )
  9804		for {
  9805			_ = v.Args[1]
  9806			x := v.Args[0]
  9807			v_1 := v.Args[1]
  9808			if v_1.Op != OpMul16 {
  9809				break
  9810			}
  9811			_ = v_1.Args[1]
  9812			v_1_0 := v_1.Args[0]
  9813			if v_1_0.Op != OpTrunc32to16 {
  9814				break
  9815			}
  9816			v_1_0_0 := v_1_0.Args[0]
  9817			if v_1_0_0.Op != OpRsh32Ux64 {
  9818				break
  9819			}
  9820			_ = v_1_0_0.Args[1]
  9821			mul := v_1_0_0.Args[0]
  9822			if mul.Op != OpMul32 {
  9823				break
  9824			}
  9825			_ = mul.Args[1]
  9826			mul_0 := mul.Args[0]
  9827			if mul_0.Op != OpConst32 {
  9828				break
  9829			}
  9830			m := mul_0.AuxInt
  9831			mul_1 := mul.Args[1]
  9832			if mul_1.Op != OpZeroExt16to32 {
  9833				break
  9834			}
  9835			if x != mul_1.Args[0] {
  9836				break
  9837			}
  9838			v_1_0_0_1 := v_1_0_0.Args[1]
  9839			if v_1_0_0_1.Op != OpConst64 {
  9840				break
  9841			}
  9842			s := v_1_0_0_1.AuxInt
  9843			v_1_1 := v_1.Args[1]
  9844			if v_1_1.Op != OpConst16 {
  9845				break
  9846			}
  9847			c := v_1_1.AuxInt
  9848			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+umagic(16, c).m/2) && s == 16+umagic(16, c).s-1 && x.Op != OpConst16 && udivisibleOK(16, c)) {
  9849				break
  9850			}
  9851			v.reset(OpLeq16U)
  9852			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
  9853			v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
  9854			v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9855			v2.AuxInt = int64(int16(udivisible(16, c).m))
  9856			v1.AddArg(v2)
  9857			v1.AddArg(x)
  9858			v0.AddArg(v1)
  9859			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9860			v3.AuxInt = int64(16 - udivisible(16, c).k)
  9861			v0.AddArg(v3)
  9862			v.AddArg(v0)
  9863			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9864			v4.AuxInt = int64(int16(udivisible(16, c).max))
  9865			v.AddArg(v4)
  9866			return true
  9867		}
  9868		// match: (Eq16 x (Mul16 (Trunc32to16 (Rsh32Ux64 mul:(Mul32 (ZeroExt16to32 x) (Const32 [m])) (Const64 [s]))) (Const16 [c])))
  9869		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+umagic(16,c).m/2) && s == 16+umagic(16,c).s-1 && x.Op != OpConst16 && udivisibleOK(16,c)
  9870		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) )
  9871		for {
  9872			_ = v.Args[1]
  9873			x := v.Args[0]
  9874			v_1 := v.Args[1]
  9875			if v_1.Op != OpMul16 {
  9876				break
  9877			}
  9878			_ = v_1.Args[1]
  9879			v_1_0 := v_1.Args[0]
  9880			if v_1_0.Op != OpTrunc32to16 {
  9881				break
  9882			}
  9883			v_1_0_0 := v_1_0.Args[0]
  9884			if v_1_0_0.Op != OpRsh32Ux64 {
  9885				break
  9886			}
  9887			_ = v_1_0_0.Args[1]
  9888			mul := v_1_0_0.Args[0]
  9889			if mul.Op != OpMul32 {
  9890				break
  9891			}
  9892			_ = mul.Args[1]
  9893			mul_0 := mul.Args[0]
  9894			if mul_0.Op != OpZeroExt16to32 {
  9895				break
  9896			}
  9897			if x != mul_0.Args[0] {
  9898				break
  9899			}
  9900			mul_1 := mul.Args[1]
  9901			if mul_1.Op != OpConst32 {
  9902				break
  9903			}
  9904			m := mul_1.AuxInt
  9905			v_1_0_0_1 := v_1_0_0.Args[1]
  9906			if v_1_0_0_1.Op != OpConst64 {
  9907				break
  9908			}
  9909			s := v_1_0_0_1.AuxInt
  9910			v_1_1 := v_1.Args[1]
  9911			if v_1_1.Op != OpConst16 {
  9912				break
  9913			}
  9914			c := v_1_1.AuxInt
  9915			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+umagic(16, c).m/2) && s == 16+umagic(16, c).s-1 && x.Op != OpConst16 && udivisibleOK(16, c)) {
  9916				break
  9917			}
  9918			v.reset(OpLeq16U)
  9919			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
  9920			v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
  9921			v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9922			v2.AuxInt = int64(int16(udivisible(16, c).m))
  9923			v1.AddArg(v2)
  9924			v1.AddArg(x)
  9925			v0.AddArg(v1)
  9926			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9927			v3.AuxInt = int64(16 - udivisible(16, c).k)
  9928			v0.AddArg(v3)
  9929			v.AddArg(v0)
  9930			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9931			v4.AuxInt = int64(int16(udivisible(16, c).max))
  9932			v.AddArg(v4)
  9933			return true
  9934		}
  9935		// match: (Eq16 (Mul16 (Const16 [c]) (Trunc32to16 (Rsh32Ux64 mul:(Mul32 (Const32 [m]) (ZeroExt16to32 x)) (Const64 [s])))) x)
  9936		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+umagic(16,c).m/2) && s == 16+umagic(16,c).s-1 && x.Op != OpConst16 && udivisibleOK(16,c)
  9937		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) )
  9938		for {
  9939			x := v.Args[1]
  9940			v_0 := v.Args[0]
  9941			if v_0.Op != OpMul16 {
  9942				break
  9943			}
  9944			_ = v_0.Args[1]
  9945			v_0_0 := v_0.Args[0]
  9946			if v_0_0.Op != OpConst16 {
  9947				break
  9948			}
  9949			c := v_0_0.AuxInt
  9950			v_0_1 := v_0.Args[1]
  9951			if v_0_1.Op != OpTrunc32to16 {
  9952				break
  9953			}
  9954			v_0_1_0 := v_0_1.Args[0]
  9955			if v_0_1_0.Op != OpRsh32Ux64 {
  9956				break
  9957			}
  9958			_ = v_0_1_0.Args[1]
  9959			mul := v_0_1_0.Args[0]
  9960			if mul.Op != OpMul32 {
  9961				break
  9962			}
  9963			_ = mul.Args[1]
  9964			mul_0 := mul.Args[0]
  9965			if mul_0.Op != OpConst32 {
  9966				break
  9967			}
  9968			m := mul_0.AuxInt
  9969			mul_1 := mul.Args[1]
  9970			if mul_1.Op != OpZeroExt16to32 {
  9971				break
  9972			}
  9973			if x != mul_1.Args[0] {
  9974				break
  9975			}
  9976			v_0_1_0_1 := v_0_1_0.Args[1]
  9977			if v_0_1_0_1.Op != OpConst64 {
  9978				break
  9979			}
  9980			s := v_0_1_0_1.AuxInt
  9981			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+umagic(16, c).m/2) && s == 16+umagic(16, c).s-1 && x.Op != OpConst16 && udivisibleOK(16, c)) {
  9982				break
  9983			}
  9984			v.reset(OpLeq16U)
  9985			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
  9986			v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
  9987			v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9988			v2.AuxInt = int64(int16(udivisible(16, c).m))
  9989			v1.AddArg(v2)
  9990			v1.AddArg(x)
  9991			v0.AddArg(v1)
  9992			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9993			v3.AuxInt = int64(16 - udivisible(16, c).k)
  9994			v0.AddArg(v3)
  9995			v.AddArg(v0)
  9996			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  9997			v4.AuxInt = int64(int16(udivisible(16, c).max))
  9998			v.AddArg(v4)
  9999			return true
 10000		}
 10001		// match: (Eq16 (Mul16 (Const16 [c]) (Trunc32to16 (Rsh32Ux64 mul:(Mul32 (ZeroExt16to32 x) (Const32 [m])) (Const64 [s])))) x)
 10002		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+umagic(16,c).m/2) && s == 16+umagic(16,c).s-1 && x.Op != OpConst16 && udivisibleOK(16,c)
 10003		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) )
 10004		for {
 10005			x := v.Args[1]
 10006			v_0 := v.Args[0]
 10007			if v_0.Op != OpMul16 {
 10008				break
 10009			}
 10010			_ = v_0.Args[1]
 10011			v_0_0 := v_0.Args[0]
 10012			if v_0_0.Op != OpConst16 {
 10013				break
 10014			}
 10015			c := v_0_0.AuxInt
 10016			v_0_1 := v_0.Args[1]
 10017			if v_0_1.Op != OpTrunc32to16 {
 10018				break
 10019			}
 10020			v_0_1_0 := v_0_1.Args[0]
 10021			if v_0_1_0.Op != OpRsh32Ux64 {
 10022				break
 10023			}
 10024			_ = v_0_1_0.Args[1]
 10025			mul := v_0_1_0.Args[0]
 10026			if mul.Op != OpMul32 {
 10027				break
 10028			}
 10029			_ = mul.Args[1]
 10030			mul_0 := mul.Args[0]
 10031			if mul_0.Op != OpZeroExt16to32 {
 10032				break
 10033			}
 10034			if x != mul_0.Args[0] {
 10035				break
 10036			}
 10037			mul_1 := mul.Args[1]
 10038			if mul_1.Op != OpConst32 {
 10039				break
 10040			}
 10041			m := mul_1.AuxInt
 10042			v_0_1_0_1 := v_0_1_0.Args[1]
 10043			if v_0_1_0_1.Op != OpConst64 {
 10044				break
 10045			}
 10046			s := v_0_1_0_1.AuxInt
 10047			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+umagic(16, c).m/2) && s == 16+umagic(16, c).s-1 && x.Op != OpConst16 && udivisibleOK(16, c)) {
 10048				break
 10049			}
 10050			v.reset(OpLeq16U)
 10051			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
 10052			v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
 10053			v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10054			v2.AuxInt = int64(int16(udivisible(16, c).m))
 10055			v1.AddArg(v2)
 10056			v1.AddArg(x)
 10057			v0.AddArg(v1)
 10058			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10059			v3.AuxInt = int64(16 - udivisible(16, c).k)
 10060			v0.AddArg(v3)
 10061			v.AddArg(v0)
 10062			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10063			v4.AuxInt = int64(int16(udivisible(16, c).max))
 10064			v.AddArg(v4)
 10065			return true
 10066		}
 10067		// match: (Eq16 (Mul16 (Trunc32to16 (Rsh32Ux64 mul:(Mul32 (Const32 [m]) (ZeroExt16to32 x)) (Const64 [s]))) (Const16 [c])) x)
 10068		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+umagic(16,c).m/2) && s == 16+umagic(16,c).s-1 && x.Op != OpConst16 && udivisibleOK(16,c)
 10069		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) )
 10070		for {
 10071			x := v.Args[1]
 10072			v_0 := v.Args[0]
 10073			if v_0.Op != OpMul16 {
 10074				break
 10075			}
 10076			_ = v_0.Args[1]
 10077			v_0_0 := v_0.Args[0]
 10078			if v_0_0.Op != OpTrunc32to16 {
 10079				break
 10080			}
 10081			v_0_0_0 := v_0_0.Args[0]
 10082			if v_0_0_0.Op != OpRsh32Ux64 {
 10083				break
 10084			}
 10085			_ = v_0_0_0.Args[1]
 10086			mul := v_0_0_0.Args[0]
 10087			if mul.Op != OpMul32 {
 10088				break
 10089			}
 10090			_ = mul.Args[1]
 10091			mul_0 := mul.Args[0]
 10092			if mul_0.Op != OpConst32 {
 10093				break
 10094			}
 10095			m := mul_0.AuxInt
 10096			mul_1 := mul.Args[1]
 10097			if mul_1.Op != OpZeroExt16to32 {
 10098				break
 10099			}
 10100			if x != mul_1.Args[0] {
 10101				break
 10102			}
 10103			v_0_0_0_1 := v_0_0_0.Args[1]
 10104			if v_0_0_0_1.Op != OpConst64 {
 10105				break
 10106			}
 10107			s := v_0_0_0_1.AuxInt
 10108			v_0_1 := v_0.Args[1]
 10109			if v_0_1.Op != OpConst16 {
 10110				break
 10111			}
 10112			c := v_0_1.AuxInt
 10113			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+umagic(16, c).m/2) && s == 16+umagic(16, c).s-1 && x.Op != OpConst16 && udivisibleOK(16, c)) {
 10114				break
 10115			}
 10116			v.reset(OpLeq16U)
 10117			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
 10118			v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
 10119			v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10120			v2.AuxInt = int64(int16(udivisible(16, c).m))
 10121			v1.AddArg(v2)
 10122			v1.AddArg(x)
 10123			v0.AddArg(v1)
 10124			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10125			v3.AuxInt = int64(16 - udivisible(16, c).k)
 10126			v0.AddArg(v3)
 10127			v.AddArg(v0)
 10128			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10129			v4.AuxInt = int64(int16(udivisible(16, c).max))
 10130			v.AddArg(v4)
 10131			return true
 10132		}
 10133		// match: (Eq16 (Mul16 (Trunc32to16 (Rsh32Ux64 mul:(Mul32 (ZeroExt16to32 x) (Const32 [m])) (Const64 [s]))) (Const16 [c])) x)
 10134		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+umagic(16,c).m/2) && s == 16+umagic(16,c).s-1 && x.Op != OpConst16 && udivisibleOK(16,c)
 10135		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) )
 10136		for {
 10137			x := v.Args[1]
 10138			v_0 := v.Args[0]
 10139			if v_0.Op != OpMul16 {
 10140				break
 10141			}
 10142			_ = v_0.Args[1]
 10143			v_0_0 := v_0.Args[0]
 10144			if v_0_0.Op != OpTrunc32to16 {
 10145				break
 10146			}
 10147			v_0_0_0 := v_0_0.Args[0]
 10148			if v_0_0_0.Op != OpRsh32Ux64 {
 10149				break
 10150			}
 10151			_ = v_0_0_0.Args[1]
 10152			mul := v_0_0_0.Args[0]
 10153			if mul.Op != OpMul32 {
 10154				break
 10155			}
 10156			_ = mul.Args[1]
 10157			mul_0 := mul.Args[0]
 10158			if mul_0.Op != OpZeroExt16to32 {
 10159				break
 10160			}
 10161			if x != mul_0.Args[0] {
 10162				break
 10163			}
 10164			mul_1 := mul.Args[1]
 10165			if mul_1.Op != OpConst32 {
 10166				break
 10167			}
 10168			m := mul_1.AuxInt
 10169			v_0_0_0_1 := v_0_0_0.Args[1]
 10170			if v_0_0_0_1.Op != OpConst64 {
 10171				break
 10172			}
 10173			s := v_0_0_0_1.AuxInt
 10174			v_0_1 := v_0.Args[1]
 10175			if v_0_1.Op != OpConst16 {
 10176				break
 10177			}
 10178			c := v_0_1.AuxInt
 10179			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+umagic(16, c).m/2) && s == 16+umagic(16, c).s-1 && x.Op != OpConst16 && udivisibleOK(16, c)) {
 10180				break
 10181			}
 10182			v.reset(OpLeq16U)
 10183			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
 10184			v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
 10185			v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10186			v2.AuxInt = int64(int16(udivisible(16, c).m))
 10187			v1.AddArg(v2)
 10188			v1.AddArg(x)
 10189			v0.AddArg(v1)
 10190			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10191			v3.AuxInt = int64(16 - udivisible(16, c).k)
 10192			v0.AddArg(v3)
 10193			v.AddArg(v0)
 10194			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10195			v4.AuxInt = int64(int16(udivisible(16, c).max))
 10196			v.AddArg(v4)
 10197			return true
 10198		}
 10199		// match: (Eq16 x (Mul16 (Const16 [c]) (Trunc32to16 (Rsh32Ux64 mul:(Mul32 (Const32 [m]) (Rsh32Ux64 (ZeroExt16to32 x) (Const64 [1]))) (Const64 [s])))))
 10200		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+(umagic(16,c).m+1)/2) && s == 16+umagic(16,c).s-2 && x.Op != OpConst16 && udivisibleOK(16,c)
 10201		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) )
 10202		for {
 10203			_ = v.Args[1]
 10204			x := v.Args[0]
 10205			v_1 := v.Args[1]
 10206			if v_1.Op != OpMul16 {
 10207				break
 10208			}
 10209			_ = v_1.Args[1]
 10210			v_1_0 := v_1.Args[0]
 10211			if v_1_0.Op != OpConst16 {
 10212				break
 10213			}
 10214			c := v_1_0.AuxInt
 10215			v_1_1 := v_1.Args[1]
 10216			if v_1_1.Op != OpTrunc32to16 {
 10217				break
 10218			}
 10219			v_1_1_0 := v_1_1.Args[0]
 10220			if v_1_1_0.Op != OpRsh32Ux64 {
 10221				break
 10222			}
 10223			_ = v_1_1_0.Args[1]
 10224			mul := v_1_1_0.Args[0]
 10225			if mul.Op != OpMul32 {
 10226				break
 10227			}
 10228			_ = mul.Args[1]
 10229			mul_0 := mul.Args[0]
 10230			if mul_0.Op != OpConst32 {
 10231				break
 10232			}
 10233			m := mul_0.AuxInt
 10234			mul_1 := mul.Args[1]
 10235			if mul_1.Op != OpRsh32Ux64 {
 10236				break
 10237			}
 10238			_ = mul_1.Args[1]
 10239			mul_1_0 := mul_1.Args[0]
 10240			if mul_1_0.Op != OpZeroExt16to32 {
 10241				break
 10242			}
 10243			if x != mul_1_0.Args[0] {
 10244				break
 10245			}
 10246			mul_1_1 := mul_1.Args[1]
 10247			if mul_1_1.Op != OpConst64 {
 10248				break
 10249			}
 10250			if mul_1_1.AuxInt != 1 {
 10251				break
 10252			}
 10253			v_1_1_0_1 := v_1_1_0.Args[1]
 10254			if v_1_1_0_1.Op != OpConst64 {
 10255				break
 10256			}
 10257			s := v_1_1_0_1.AuxInt
 10258			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+(umagic(16, c).m+1)/2) && s == 16+umagic(16, c).s-2 && x.Op != OpConst16 && udivisibleOK(16, c)) {
 10259				break
 10260			}
 10261			v.reset(OpLeq16U)
 10262			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
 10263			v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
 10264			v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10265			v2.AuxInt = int64(int16(udivisible(16, c).m))
 10266			v1.AddArg(v2)
 10267			v1.AddArg(x)
 10268			v0.AddArg(v1)
 10269			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10270			v3.AuxInt = int64(16 - udivisible(16, c).k)
 10271			v0.AddArg(v3)
 10272			v.AddArg(v0)
 10273			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10274			v4.AuxInt = int64(int16(udivisible(16, c).max))
 10275			v.AddArg(v4)
 10276			return true
 10277		}
 10278		// match: (Eq16 x (Mul16 (Const16 [c]) (Trunc32to16 (Rsh32Ux64 mul:(Mul32 (Rsh32Ux64 (ZeroExt16to32 x) (Const64 [1])) (Const32 [m])) (Const64 [s])))))
 10279		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+(umagic(16,c).m+1)/2) && s == 16+umagic(16,c).s-2 && x.Op != OpConst16 && udivisibleOK(16,c)
 10280		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) )
 10281		for {
 10282			_ = v.Args[1]
 10283			x := v.Args[0]
 10284			v_1 := v.Args[1]
 10285			if v_1.Op != OpMul16 {
 10286				break
 10287			}
 10288			_ = v_1.Args[1]
 10289			v_1_0 := v_1.Args[0]
 10290			if v_1_0.Op != OpConst16 {
 10291				break
 10292			}
 10293			c := v_1_0.AuxInt
 10294			v_1_1 := v_1.Args[1]
 10295			if v_1_1.Op != OpTrunc32to16 {
 10296				break
 10297			}
 10298			v_1_1_0 := v_1_1.Args[0]
 10299			if v_1_1_0.Op != OpRsh32Ux64 {
 10300				break
 10301			}
 10302			_ = v_1_1_0.Args[1]
 10303			mul := v_1_1_0.Args[0]
 10304			if mul.Op != OpMul32 {
 10305				break
 10306			}
 10307			_ = mul.Args[1]
 10308			mul_0 := mul.Args[0]
 10309			if mul_0.Op != OpRsh32Ux64 {
 10310				break
 10311			}
 10312			_ = mul_0.Args[1]
 10313			mul_0_0 := mul_0.Args[0]
 10314			if mul_0_0.Op != OpZeroExt16to32 {
 10315				break
 10316			}
 10317			if x != mul_0_0.Args[0] {
 10318				break
 10319			}
 10320			mul_0_1 := mul_0.Args[1]
 10321			if mul_0_1.Op != OpConst64 {
 10322				break
 10323			}
 10324			if mul_0_1.AuxInt != 1 {
 10325				break
 10326			}
 10327			mul_1 := mul.Args[1]
 10328			if mul_1.Op != OpConst32 {
 10329				break
 10330			}
 10331			m := mul_1.AuxInt
 10332			v_1_1_0_1 := v_1_1_0.Args[1]
 10333			if v_1_1_0_1.Op != OpConst64 {
 10334				break
 10335			}
 10336			s := v_1_1_0_1.AuxInt
 10337			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+(umagic(16, c).m+1)/2) && s == 16+umagic(16, c).s-2 && x.Op != OpConst16 && udivisibleOK(16, c)) {
 10338				break
 10339			}
 10340			v.reset(OpLeq16U)
 10341			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
 10342			v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
 10343			v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10344			v2.AuxInt = int64(int16(udivisible(16, c).m))
 10345			v1.AddArg(v2)
 10346			v1.AddArg(x)
 10347			v0.AddArg(v1)
 10348			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10349			v3.AuxInt = int64(16 - udivisible(16, c).k)
 10350			v0.AddArg(v3)
 10351			v.AddArg(v0)
 10352			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10353			v4.AuxInt = int64(int16(udivisible(16, c).max))
 10354			v.AddArg(v4)
 10355			return true
 10356		}
 10357		// match: (Eq16 x (Mul16 (Trunc32to16 (Rsh32Ux64 mul:(Mul32 (Const32 [m]) (Rsh32Ux64 (ZeroExt16to32 x) (Const64 [1]))) (Const64 [s]))) (Const16 [c])))
 10358		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+(umagic(16,c).m+1)/2) && s == 16+umagic(16,c).s-2 && x.Op != OpConst16 && udivisibleOK(16,c)
 10359		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) )
 10360		for {
 10361			_ = v.Args[1]
 10362			x := v.Args[0]
 10363			v_1 := v.Args[1]
 10364			if v_1.Op != OpMul16 {
 10365				break
 10366			}
 10367			_ = v_1.Args[1]
 10368			v_1_0 := v_1.Args[0]
 10369			if v_1_0.Op != OpTrunc32to16 {
 10370				break
 10371			}
 10372			v_1_0_0 := v_1_0.Args[0]
 10373			if v_1_0_0.Op != OpRsh32Ux64 {
 10374				break
 10375			}
 10376			_ = v_1_0_0.Args[1]
 10377			mul := v_1_0_0.Args[0]
 10378			if mul.Op != OpMul32 {
 10379				break
 10380			}
 10381			_ = mul.Args[1]
 10382			mul_0 := mul.Args[0]
 10383			if mul_0.Op != OpConst32 {
 10384				break
 10385			}
 10386			m := mul_0.AuxInt
 10387			mul_1 := mul.Args[1]
 10388			if mul_1.Op != OpRsh32Ux64 {
 10389				break
 10390			}
 10391			_ = mul_1.Args[1]
 10392			mul_1_0 := mul_1.Args[0]
 10393			if mul_1_0.Op != OpZeroExt16to32 {
 10394				break
 10395			}
 10396			if x != mul_1_0.Args[0] {
 10397				break
 10398			}
 10399			mul_1_1 := mul_1.Args[1]
 10400			if mul_1_1.Op != OpConst64 {
 10401				break
 10402			}
 10403			if mul_1_1.AuxInt != 1 {
 10404				break
 10405			}
 10406			v_1_0_0_1 := v_1_0_0.Args[1]
 10407			if v_1_0_0_1.Op != OpConst64 {
 10408				break
 10409			}
 10410			s := v_1_0_0_1.AuxInt
 10411			v_1_1 := v_1.Args[1]
 10412			if v_1_1.Op != OpConst16 {
 10413				break
 10414			}
 10415			c := v_1_1.AuxInt
 10416			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+(umagic(16, c).m+1)/2) && s == 16+umagic(16, c).s-2 && x.Op != OpConst16 && udivisibleOK(16, c)) {
 10417				break
 10418			}
 10419			v.reset(OpLeq16U)
 10420			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
 10421			v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
 10422			v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10423			v2.AuxInt = int64(int16(udivisible(16, c).m))
 10424			v1.AddArg(v2)
 10425			v1.AddArg(x)
 10426			v0.AddArg(v1)
 10427			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10428			v3.AuxInt = int64(16 - udivisible(16, c).k)
 10429			v0.AddArg(v3)
 10430			v.AddArg(v0)
 10431			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10432			v4.AuxInt = int64(int16(udivisible(16, c).max))
 10433			v.AddArg(v4)
 10434			return true
 10435		}
 10436		return false
 10437	}
 10438	func rewriteValuegeneric_OpEq16_30(v *Value) bool {
 10439		b := v.Block
 10440		typ := &b.Func.Config.Types
 10441		// match: (Eq16 x (Mul16 (Trunc32to16 (Rsh32Ux64 mul:(Mul32 (Rsh32Ux64 (ZeroExt16to32 x) (Const64 [1])) (Const32 [m])) (Const64 [s]))) (Const16 [c])))
 10442		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+(umagic(16,c).m+1)/2) && s == 16+umagic(16,c).s-2 && x.Op != OpConst16 && udivisibleOK(16,c)
 10443		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) )
 10444		for {
 10445			_ = v.Args[1]
 10446			x := v.Args[0]
 10447			v_1 := v.Args[1]
 10448			if v_1.Op != OpMul16 {
 10449				break
 10450			}
 10451			_ = v_1.Args[1]
 10452			v_1_0 := v_1.Args[0]
 10453			if v_1_0.Op != OpTrunc32to16 {
 10454				break
 10455			}
 10456			v_1_0_0 := v_1_0.Args[0]
 10457			if v_1_0_0.Op != OpRsh32Ux64 {
 10458				break
 10459			}
 10460			_ = v_1_0_0.Args[1]
 10461			mul := v_1_0_0.Args[0]
 10462			if mul.Op != OpMul32 {
 10463				break
 10464			}
 10465			_ = mul.Args[1]
 10466			mul_0 := mul.Args[0]
 10467			if mul_0.Op != OpRsh32Ux64 {
 10468				break
 10469			}
 10470			_ = mul_0.Args[1]
 10471			mul_0_0 := mul_0.Args[0]
 10472			if mul_0_0.Op != OpZeroExt16to32 {
 10473				break
 10474			}
 10475			if x != mul_0_0.Args[0] {
 10476				break
 10477			}
 10478			mul_0_1 := mul_0.Args[1]
 10479			if mul_0_1.Op != OpConst64 {
 10480				break
 10481			}
 10482			if mul_0_1.AuxInt != 1 {
 10483				break
 10484			}
 10485			mul_1 := mul.Args[1]
 10486			if mul_1.Op != OpConst32 {
 10487				break
 10488			}
 10489			m := mul_1.AuxInt
 10490			v_1_0_0_1 := v_1_0_0.Args[1]
 10491			if v_1_0_0_1.Op != OpConst64 {
 10492				break
 10493			}
 10494			s := v_1_0_0_1.AuxInt
 10495			v_1_1 := v_1.Args[1]
 10496			if v_1_1.Op != OpConst16 {
 10497				break
 10498			}
 10499			c := v_1_1.AuxInt
 10500			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+(umagic(16, c).m+1)/2) && s == 16+umagic(16, c).s-2 && x.Op != OpConst16 && udivisibleOK(16, c)) {
 10501				break
 10502			}
 10503			v.reset(OpLeq16U)
 10504			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
 10505			v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
 10506			v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10507			v2.AuxInt = int64(int16(udivisible(16, c).m))
 10508			v1.AddArg(v2)
 10509			v1.AddArg(x)
 10510			v0.AddArg(v1)
 10511			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10512			v3.AuxInt = int64(16 - udivisible(16, c).k)
 10513			v0.AddArg(v3)
 10514			v.AddArg(v0)
 10515			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10516			v4.AuxInt = int64(int16(udivisible(16, c).max))
 10517			v.AddArg(v4)
 10518			return true
 10519		}
 10520		// match: (Eq16 (Mul16 (Const16 [c]) (Trunc32to16 (Rsh32Ux64 mul:(Mul32 (Const32 [m]) (Rsh32Ux64 (ZeroExt16to32 x) (Const64 [1]))) (Const64 [s])))) x)
 10521		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+(umagic(16,c).m+1)/2) && s == 16+umagic(16,c).s-2 && x.Op != OpConst16 && udivisibleOK(16,c)
 10522		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) )
 10523		for {
 10524			x := v.Args[1]
 10525			v_0 := v.Args[0]
 10526			if v_0.Op != OpMul16 {
 10527				break
 10528			}
 10529			_ = v_0.Args[1]
 10530			v_0_0 := v_0.Args[0]
 10531			if v_0_0.Op != OpConst16 {
 10532				break
 10533			}
 10534			c := v_0_0.AuxInt
 10535			v_0_1 := v_0.Args[1]
 10536			if v_0_1.Op != OpTrunc32to16 {
 10537				break
 10538			}
 10539			v_0_1_0 := v_0_1.Args[0]
 10540			if v_0_1_0.Op != OpRsh32Ux64 {
 10541				break
 10542			}
 10543			_ = v_0_1_0.Args[1]
 10544			mul := v_0_1_0.Args[0]
 10545			if mul.Op != OpMul32 {
 10546				break
 10547			}
 10548			_ = mul.Args[1]
 10549			mul_0 := mul.Args[0]
 10550			if mul_0.Op != OpConst32 {
 10551				break
 10552			}
 10553			m := mul_0.AuxInt
 10554			mul_1 := mul.Args[1]
 10555			if mul_1.Op != OpRsh32Ux64 {
 10556				break
 10557			}
 10558			_ = mul_1.Args[1]
 10559			mul_1_0 := mul_1.Args[0]
 10560			if mul_1_0.Op != OpZeroExt16to32 {
 10561				break
 10562			}
 10563			if x != mul_1_0.Args[0] {
 10564				break
 10565			}
 10566			mul_1_1 := mul_1.Args[1]
 10567			if mul_1_1.Op != OpConst64 {
 10568				break
 10569			}
 10570			if mul_1_1.AuxInt != 1 {
 10571				break
 10572			}
 10573			v_0_1_0_1 := v_0_1_0.Args[1]
 10574			if v_0_1_0_1.Op != OpConst64 {
 10575				break
 10576			}
 10577			s := v_0_1_0_1.AuxInt
 10578			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+(umagic(16, c).m+1)/2) && s == 16+umagic(16, c).s-2 && x.Op != OpConst16 && udivisibleOK(16, c)) {
 10579				break
 10580			}
 10581			v.reset(OpLeq16U)
 10582			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
 10583			v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
 10584			v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10585			v2.AuxInt = int64(int16(udivisible(16, c).m))
 10586			v1.AddArg(v2)
 10587			v1.AddArg(x)
 10588			v0.AddArg(v1)
 10589			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10590			v3.AuxInt = int64(16 - udivisible(16, c).k)
 10591			v0.AddArg(v3)
 10592			v.AddArg(v0)
 10593			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10594			v4.AuxInt = int64(int16(udivisible(16, c).max))
 10595			v.AddArg(v4)
 10596			return true
 10597		}
 10598		// match: (Eq16 (Mul16 (Const16 [c]) (Trunc32to16 (Rsh32Ux64 mul:(Mul32 (Rsh32Ux64 (ZeroExt16to32 x) (Const64 [1])) (Const32 [m])) (Const64 [s])))) x)
 10599		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+(umagic(16,c).m+1)/2) && s == 16+umagic(16,c).s-2 && x.Op != OpConst16 && udivisibleOK(16,c)
 10600		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) )
 10601		for {
 10602			x := v.Args[1]
 10603			v_0 := v.Args[0]
 10604			if v_0.Op != OpMul16 {
 10605				break
 10606			}
 10607			_ = v_0.Args[1]
 10608			v_0_0 := v_0.Args[0]
 10609			if v_0_0.Op != OpConst16 {
 10610				break
 10611			}
 10612			c := v_0_0.AuxInt
 10613			v_0_1 := v_0.Args[1]
 10614			if v_0_1.Op != OpTrunc32to16 {
 10615				break
 10616			}
 10617			v_0_1_0 := v_0_1.Args[0]
 10618			if v_0_1_0.Op != OpRsh32Ux64 {
 10619				break
 10620			}
 10621			_ = v_0_1_0.Args[1]
 10622			mul := v_0_1_0.Args[0]
 10623			if mul.Op != OpMul32 {
 10624				break
 10625			}
 10626			_ = mul.Args[1]
 10627			mul_0 := mul.Args[0]
 10628			if mul_0.Op != OpRsh32Ux64 {
 10629				break
 10630			}
 10631			_ = mul_0.Args[1]
 10632			mul_0_0 := mul_0.Args[0]
 10633			if mul_0_0.Op != OpZeroExt16to32 {
 10634				break
 10635			}
 10636			if x != mul_0_0.Args[0] {
 10637				break
 10638			}
 10639			mul_0_1 := mul_0.Args[1]
 10640			if mul_0_1.Op != OpConst64 {
 10641				break
 10642			}
 10643			if mul_0_1.AuxInt != 1 {
 10644				break
 10645			}
 10646			mul_1 := mul.Args[1]
 10647			if mul_1.Op != OpConst32 {
 10648				break
 10649			}
 10650			m := mul_1.AuxInt
 10651			v_0_1_0_1 := v_0_1_0.Args[1]
 10652			if v_0_1_0_1.Op != OpConst64 {
 10653				break
 10654			}
 10655			s := v_0_1_0_1.AuxInt
 10656			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+(umagic(16, c).m+1)/2) && s == 16+umagic(16, c).s-2 && x.Op != OpConst16 && udivisibleOK(16, c)) {
 10657				break
 10658			}
 10659			v.reset(OpLeq16U)
 10660			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
 10661			v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
 10662			v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10663			v2.AuxInt = int64(int16(udivisible(16, c).m))
 10664			v1.AddArg(v2)
 10665			v1.AddArg(x)
 10666			v0.AddArg(v1)
 10667			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10668			v3.AuxInt = int64(16 - udivisible(16, c).k)
 10669			v0.AddArg(v3)
 10670			v.AddArg(v0)
 10671			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10672			v4.AuxInt = int64(int16(udivisible(16, c).max))
 10673			v.AddArg(v4)
 10674			return true
 10675		}
 10676		// match: (Eq16 (Mul16 (Trunc32to16 (Rsh32Ux64 mul:(Mul32 (Const32 [m]) (Rsh32Ux64 (ZeroExt16to32 x) (Const64 [1]))) (Const64 [s]))) (Const16 [c])) x)
 10677		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+(umagic(16,c).m+1)/2) && s == 16+umagic(16,c).s-2 && x.Op != OpConst16 && udivisibleOK(16,c)
 10678		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) )
 10679		for {
 10680			x := v.Args[1]
 10681			v_0 := v.Args[0]
 10682			if v_0.Op != OpMul16 {
 10683				break
 10684			}
 10685			_ = v_0.Args[1]
 10686			v_0_0 := v_0.Args[0]
 10687			if v_0_0.Op != OpTrunc32to16 {
 10688				break
 10689			}
 10690			v_0_0_0 := v_0_0.Args[0]
 10691			if v_0_0_0.Op != OpRsh32Ux64 {
 10692				break
 10693			}
 10694			_ = v_0_0_0.Args[1]
 10695			mul := v_0_0_0.Args[0]
 10696			if mul.Op != OpMul32 {
 10697				break
 10698			}
 10699			_ = mul.Args[1]
 10700			mul_0 := mul.Args[0]
 10701			if mul_0.Op != OpConst32 {
 10702				break
 10703			}
 10704			m := mul_0.AuxInt
 10705			mul_1 := mul.Args[1]
 10706			if mul_1.Op != OpRsh32Ux64 {
 10707				break
 10708			}
 10709			_ = mul_1.Args[1]
 10710			mul_1_0 := mul_1.Args[0]
 10711			if mul_1_0.Op != OpZeroExt16to32 {
 10712				break
 10713			}
 10714			if x != mul_1_0.Args[0] {
 10715				break
 10716			}
 10717			mul_1_1 := mul_1.Args[1]
 10718			if mul_1_1.Op != OpConst64 {
 10719				break
 10720			}
 10721			if mul_1_1.AuxInt != 1 {
 10722				break
 10723			}
 10724			v_0_0_0_1 := v_0_0_0.Args[1]
 10725			if v_0_0_0_1.Op != OpConst64 {
 10726				break
 10727			}
 10728			s := v_0_0_0_1.AuxInt
 10729			v_0_1 := v_0.Args[1]
 10730			if v_0_1.Op != OpConst16 {
 10731				break
 10732			}
 10733			c := v_0_1.AuxInt
 10734			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+(umagic(16, c).m+1)/2) && s == 16+umagic(16, c).s-2 && x.Op != OpConst16 && udivisibleOK(16, c)) {
 10735				break
 10736			}
 10737			v.reset(OpLeq16U)
 10738			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
 10739			v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
 10740			v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10741			v2.AuxInt = int64(int16(udivisible(16, c).m))
 10742			v1.AddArg(v2)
 10743			v1.AddArg(x)
 10744			v0.AddArg(v1)
 10745			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10746			v3.AuxInt = int64(16 - udivisible(16, c).k)
 10747			v0.AddArg(v3)
 10748			v.AddArg(v0)
 10749			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10750			v4.AuxInt = int64(int16(udivisible(16, c).max))
 10751			v.AddArg(v4)
 10752			return true
 10753		}
 10754		// match: (Eq16 (Mul16 (Trunc32to16 (Rsh32Ux64 mul:(Mul32 (Rsh32Ux64 (ZeroExt16to32 x) (Const64 [1])) (Const32 [m])) (Const64 [s]))) (Const16 [c])) x)
 10755		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+(umagic(16,c).m+1)/2) && s == 16+umagic(16,c).s-2 && x.Op != OpConst16 && udivisibleOK(16,c)
 10756		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) )
 10757		for {
 10758			x := v.Args[1]
 10759			v_0 := v.Args[0]
 10760			if v_0.Op != OpMul16 {
 10761				break
 10762			}
 10763			_ = v_0.Args[1]
 10764			v_0_0 := v_0.Args[0]
 10765			if v_0_0.Op != OpTrunc32to16 {
 10766				break
 10767			}
 10768			v_0_0_0 := v_0_0.Args[0]
 10769			if v_0_0_0.Op != OpRsh32Ux64 {
 10770				break
 10771			}
 10772			_ = v_0_0_0.Args[1]
 10773			mul := v_0_0_0.Args[0]
 10774			if mul.Op != OpMul32 {
 10775				break
 10776			}
 10777			_ = mul.Args[1]
 10778			mul_0 := mul.Args[0]
 10779			if mul_0.Op != OpRsh32Ux64 {
 10780				break
 10781			}
 10782			_ = mul_0.Args[1]
 10783			mul_0_0 := mul_0.Args[0]
 10784			if mul_0_0.Op != OpZeroExt16to32 {
 10785				break
 10786			}
 10787			if x != mul_0_0.Args[0] {
 10788				break
 10789			}
 10790			mul_0_1 := mul_0.Args[1]
 10791			if mul_0_1.Op != OpConst64 {
 10792				break
 10793			}
 10794			if mul_0_1.AuxInt != 1 {
 10795				break
 10796			}
 10797			mul_1 := mul.Args[1]
 10798			if mul_1.Op != OpConst32 {
 10799				break
 10800			}
 10801			m := mul_1.AuxInt
 10802			v_0_0_0_1 := v_0_0_0.Args[1]
 10803			if v_0_0_0_1.Op != OpConst64 {
 10804				break
 10805			}
 10806			s := v_0_0_0_1.AuxInt
 10807			v_0_1 := v_0.Args[1]
 10808			if v_0_1.Op != OpConst16 {
 10809				break
 10810			}
 10811			c := v_0_1.AuxInt
 10812			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+(umagic(16, c).m+1)/2) && s == 16+umagic(16, c).s-2 && x.Op != OpConst16 && udivisibleOK(16, c)) {
 10813				break
 10814			}
 10815			v.reset(OpLeq16U)
 10816			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
 10817			v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
 10818			v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10819			v2.AuxInt = int64(int16(udivisible(16, c).m))
 10820			v1.AddArg(v2)
 10821			v1.AddArg(x)
 10822			v0.AddArg(v1)
 10823			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10824			v3.AuxInt = int64(16 - udivisible(16, c).k)
 10825			v0.AddArg(v3)
 10826			v.AddArg(v0)
 10827			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10828			v4.AuxInt = int64(int16(udivisible(16, c).max))
 10829			v.AddArg(v4)
 10830			return true
 10831		}
 10832		// match: (Eq16 x (Mul16 (Const16 [c]) (Trunc32to16 (Rsh32Ux64 (Avg32u (Lsh32x64 (ZeroExt16to32 x) (Const64 [16])) mul:(Mul32 (Const32 [m]) (ZeroExt16to32 x))) (Const64 [s])))))
 10833		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(16,c).m) && s == 16+umagic(16,c).s-1 && x.Op != OpConst16 && udivisibleOK(16,c)
 10834		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) )
 10835		for {
 10836			_ = v.Args[1]
 10837			x := v.Args[0]
 10838			v_1 := v.Args[1]
 10839			if v_1.Op != OpMul16 {
 10840				break
 10841			}
 10842			_ = v_1.Args[1]
 10843			v_1_0 := v_1.Args[0]
 10844			if v_1_0.Op != OpConst16 {
 10845				break
 10846			}
 10847			c := v_1_0.AuxInt
 10848			v_1_1 := v_1.Args[1]
 10849			if v_1_1.Op != OpTrunc32to16 {
 10850				break
 10851			}
 10852			v_1_1_0 := v_1_1.Args[0]
 10853			if v_1_1_0.Op != OpRsh32Ux64 {
 10854				break
 10855			}
 10856			_ = v_1_1_0.Args[1]
 10857			v_1_1_0_0 := v_1_1_0.Args[0]
 10858			if v_1_1_0_0.Op != OpAvg32u {
 10859				break
 10860			}
 10861			_ = v_1_1_0_0.Args[1]
 10862			v_1_1_0_0_0 := v_1_1_0_0.Args[0]
 10863			if v_1_1_0_0_0.Op != OpLsh32x64 {
 10864				break
 10865			}
 10866			_ = v_1_1_0_0_0.Args[1]
 10867			v_1_1_0_0_0_0 := v_1_1_0_0_0.Args[0]
 10868			if v_1_1_0_0_0_0.Op != OpZeroExt16to32 {
 10869				break
 10870			}
 10871			if x != v_1_1_0_0_0_0.Args[0] {
 10872				break
 10873			}
 10874			v_1_1_0_0_0_1 := v_1_1_0_0_0.Args[1]
 10875			if v_1_1_0_0_0_1.Op != OpConst64 {
 10876				break
 10877			}
 10878			if v_1_1_0_0_0_1.AuxInt != 16 {
 10879				break
 10880			}
 10881			mul := v_1_1_0_0.Args[1]
 10882			if mul.Op != OpMul32 {
 10883				break
 10884			}
 10885			_ = mul.Args[1]
 10886			mul_0 := mul.Args[0]
 10887			if mul_0.Op != OpConst32 {
 10888				break
 10889			}
 10890			m := mul_0.AuxInt
 10891			mul_1 := mul.Args[1]
 10892			if mul_1.Op != OpZeroExt16to32 {
 10893				break
 10894			}
 10895			if x != mul_1.Args[0] {
 10896				break
 10897			}
 10898			v_1_1_0_1 := v_1_1_0.Args[1]
 10899			if v_1_1_0_1.Op != OpConst64 {
 10900				break
 10901			}
 10902			s := v_1_1_0_1.AuxInt
 10903			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(16, c).m) && s == 16+umagic(16, c).s-1 && x.Op != OpConst16 && udivisibleOK(16, c)) {
 10904				break
 10905			}
 10906			v.reset(OpLeq16U)
 10907			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
 10908			v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
 10909			v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10910			v2.AuxInt = int64(int16(udivisible(16, c).m))
 10911			v1.AddArg(v2)
 10912			v1.AddArg(x)
 10913			v0.AddArg(v1)
 10914			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10915			v3.AuxInt = int64(16 - udivisible(16, c).k)
 10916			v0.AddArg(v3)
 10917			v.AddArg(v0)
 10918			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 10919			v4.AuxInt = int64(int16(udivisible(16, c).max))
 10920			v.AddArg(v4)
 10921			return true
 10922		}
 10923		// match: (Eq16 x (Mul16 (Const16 [c]) (Trunc32to16 (Rsh32Ux64 (Avg32u (Lsh32x64 (ZeroExt16to32 x) (Const64 [16])) mul:(Mul32 (ZeroExt16to32 x) (Const32 [m]))) (Const64 [s])))))
 10924		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(16,c).m) && s == 16+umagic(16,c).s-1 && x.Op != OpConst16 && udivisibleOK(16,c)
 10925		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) )
 10926		for {
 10927			_ = v.Args[1]
 10928			x := v.Args[0]
 10929			v_1 := v.Args[1]
 10930			if v_1.Op != OpMul16 {
 10931				break
 10932			}
 10933			_ = v_1.Args[1]
 10934			v_1_0 := v_1.Args[0]
 10935			if v_1_0.Op != OpConst16 {
 10936				break
 10937			}
 10938			c := v_1_0.AuxInt
 10939			v_1_1 := v_1.Args[1]
 10940			if v_1_1.Op != OpTrunc32to16 {
 10941				break
 10942			}
 10943			v_1_1_0 := v_1_1.Args[0]
 10944			if v_1_1_0.Op != OpRsh32Ux64 {
 10945				break
 10946			}
 10947			_ = v_1_1_0.Args[1]
 10948			v_1_1_0_0 := v_1_1_0.Args[0]
 10949			if v_1_1_0_0.Op != OpAvg32u {
 10950				break
 10951			}
 10952			_ = v_1_1_0_0.Args[1]
 10953			v_1_1_0_0_0 := v_1_1_0_0.Args[0]
 10954			if v_1_1_0_0_0.Op != OpLsh32x64 {
 10955				break
 10956			}
 10957			_ = v_1_1_0_0_0.Args[1]
 10958			v_1_1_0_0_0_0 := v_1_1_0_0_0.Args[0]
 10959			if v_1_1_0_0_0_0.Op != OpZeroExt16to32 {
 10960				break
 10961			}
 10962			if x != v_1_1_0_0_0_0.Args[0] {
 10963				break
 10964			}
 10965			v_1_1_0_0_0_1 := v_1_1_0_0_0.Args[1]
 10966			if v_1_1_0_0_0_1.Op != OpConst64 {
 10967				break
 10968			}
 10969			if v_1_1_0_0_0_1.AuxInt != 16 {
 10970				break
 10971			}
 10972			mul := v_1_1_0_0.Args[1]
 10973			if mul.Op != OpMul32 {
 10974				break
 10975			}
 10976			_ = mul.Args[1]
 10977			mul_0 := mul.Args[0]
 10978			if mul_0.Op != OpZeroExt16to32 {
 10979				break
 10980			}
 10981			if x != mul_0.Args[0] {
 10982				break
 10983			}
 10984			mul_1 := mul.Args[1]
 10985			if mul_1.Op != OpConst32 {
 10986				break
 10987			}
 10988			m := mul_1.AuxInt
 10989			v_1_1_0_1 := v_1_1_0.Args[1]
 10990			if v_1_1_0_1.Op != OpConst64 {
 10991				break
 10992			}
 10993			s := v_1_1_0_1.AuxInt
 10994			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(16, c).m) && s == 16+umagic(16, c).s-1 && x.Op != OpConst16 && udivisibleOK(16, c)) {
 10995				break
 10996			}
 10997			v.reset(OpLeq16U)
 10998			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
 10999			v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
 11000			v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11001			v2.AuxInt = int64(int16(udivisible(16, c).m))
 11002			v1.AddArg(v2)
 11003			v1.AddArg(x)
 11004			v0.AddArg(v1)
 11005			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11006			v3.AuxInt = int64(16 - udivisible(16, c).k)
 11007			v0.AddArg(v3)
 11008			v.AddArg(v0)
 11009			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11010			v4.AuxInt = int64(int16(udivisible(16, c).max))
 11011			v.AddArg(v4)
 11012			return true
 11013		}
 11014		// match: (Eq16 x (Mul16 (Trunc32to16 (Rsh32Ux64 (Avg32u (Lsh32x64 (ZeroExt16to32 x) (Const64 [16])) mul:(Mul32 (Const32 [m]) (ZeroExt16to32 x))) (Const64 [s]))) (Const16 [c])))
 11015		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(16,c).m) && s == 16+umagic(16,c).s-1 && x.Op != OpConst16 && udivisibleOK(16,c)
 11016		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) )
 11017		for {
 11018			_ = v.Args[1]
 11019			x := v.Args[0]
 11020			v_1 := v.Args[1]
 11021			if v_1.Op != OpMul16 {
 11022				break
 11023			}
 11024			_ = v_1.Args[1]
 11025			v_1_0 := v_1.Args[0]
 11026			if v_1_0.Op != OpTrunc32to16 {
 11027				break
 11028			}
 11029			v_1_0_0 := v_1_0.Args[0]
 11030			if v_1_0_0.Op != OpRsh32Ux64 {
 11031				break
 11032			}
 11033			_ = v_1_0_0.Args[1]
 11034			v_1_0_0_0 := v_1_0_0.Args[0]
 11035			if v_1_0_0_0.Op != OpAvg32u {
 11036				break
 11037			}
 11038			_ = v_1_0_0_0.Args[1]
 11039			v_1_0_0_0_0 := v_1_0_0_0.Args[0]
 11040			if v_1_0_0_0_0.Op != OpLsh32x64 {
 11041				break
 11042			}
 11043			_ = v_1_0_0_0_0.Args[1]
 11044			v_1_0_0_0_0_0 := v_1_0_0_0_0.Args[0]
 11045			if v_1_0_0_0_0_0.Op != OpZeroExt16to32 {
 11046				break
 11047			}
 11048			if x != v_1_0_0_0_0_0.Args[0] {
 11049				break
 11050			}
 11051			v_1_0_0_0_0_1 := v_1_0_0_0_0.Args[1]
 11052			if v_1_0_0_0_0_1.Op != OpConst64 {
 11053				break
 11054			}
 11055			if v_1_0_0_0_0_1.AuxInt != 16 {
 11056				break
 11057			}
 11058			mul := v_1_0_0_0.Args[1]
 11059			if mul.Op != OpMul32 {
 11060				break
 11061			}
 11062			_ = mul.Args[1]
 11063			mul_0 := mul.Args[0]
 11064			if mul_0.Op != OpConst32 {
 11065				break
 11066			}
 11067			m := mul_0.AuxInt
 11068			mul_1 := mul.Args[1]
 11069			if mul_1.Op != OpZeroExt16to32 {
 11070				break
 11071			}
 11072			if x != mul_1.Args[0] {
 11073				break
 11074			}
 11075			v_1_0_0_1 := v_1_0_0.Args[1]
 11076			if v_1_0_0_1.Op != OpConst64 {
 11077				break
 11078			}
 11079			s := v_1_0_0_1.AuxInt
 11080			v_1_1 := v_1.Args[1]
 11081			if v_1_1.Op != OpConst16 {
 11082				break
 11083			}
 11084			c := v_1_1.AuxInt
 11085			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(16, c).m) && s == 16+umagic(16, c).s-1 && x.Op != OpConst16 && udivisibleOK(16, c)) {
 11086				break
 11087			}
 11088			v.reset(OpLeq16U)
 11089			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
 11090			v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
 11091			v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11092			v2.AuxInt = int64(int16(udivisible(16, c).m))
 11093			v1.AddArg(v2)
 11094			v1.AddArg(x)
 11095			v0.AddArg(v1)
 11096			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11097			v3.AuxInt = int64(16 - udivisible(16, c).k)
 11098			v0.AddArg(v3)
 11099			v.AddArg(v0)
 11100			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11101			v4.AuxInt = int64(int16(udivisible(16, c).max))
 11102			v.AddArg(v4)
 11103			return true
 11104		}
 11105		// match: (Eq16 x (Mul16 (Trunc32to16 (Rsh32Ux64 (Avg32u (Lsh32x64 (ZeroExt16to32 x) (Const64 [16])) mul:(Mul32 (ZeroExt16to32 x) (Const32 [m]))) (Const64 [s]))) (Const16 [c])))
 11106		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(16,c).m) && s == 16+umagic(16,c).s-1 && x.Op != OpConst16 && udivisibleOK(16,c)
 11107		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) )
 11108		for {
 11109			_ = v.Args[1]
 11110			x := v.Args[0]
 11111			v_1 := v.Args[1]
 11112			if v_1.Op != OpMul16 {
 11113				break
 11114			}
 11115			_ = v_1.Args[1]
 11116			v_1_0 := v_1.Args[0]
 11117			if v_1_0.Op != OpTrunc32to16 {
 11118				break
 11119			}
 11120			v_1_0_0 := v_1_0.Args[0]
 11121			if v_1_0_0.Op != OpRsh32Ux64 {
 11122				break
 11123			}
 11124			_ = v_1_0_0.Args[1]
 11125			v_1_0_0_0 := v_1_0_0.Args[0]
 11126			if v_1_0_0_0.Op != OpAvg32u {
 11127				break
 11128			}
 11129			_ = v_1_0_0_0.Args[1]
 11130			v_1_0_0_0_0 := v_1_0_0_0.Args[0]
 11131			if v_1_0_0_0_0.Op != OpLsh32x64 {
 11132				break
 11133			}
 11134			_ = v_1_0_0_0_0.Args[1]
 11135			v_1_0_0_0_0_0 := v_1_0_0_0_0.Args[0]
 11136			if v_1_0_0_0_0_0.Op != OpZeroExt16to32 {
 11137				break
 11138			}
 11139			if x != v_1_0_0_0_0_0.Args[0] {
 11140				break
 11141			}
 11142			v_1_0_0_0_0_1 := v_1_0_0_0_0.Args[1]
 11143			if v_1_0_0_0_0_1.Op != OpConst64 {
 11144				break
 11145			}
 11146			if v_1_0_0_0_0_1.AuxInt != 16 {
 11147				break
 11148			}
 11149			mul := v_1_0_0_0.Args[1]
 11150			if mul.Op != OpMul32 {
 11151				break
 11152			}
 11153			_ = mul.Args[1]
 11154			mul_0 := mul.Args[0]
 11155			if mul_0.Op != OpZeroExt16to32 {
 11156				break
 11157			}
 11158			if x != mul_0.Args[0] {
 11159				break
 11160			}
 11161			mul_1 := mul.Args[1]
 11162			if mul_1.Op != OpConst32 {
 11163				break
 11164			}
 11165			m := mul_1.AuxInt
 11166			v_1_0_0_1 := v_1_0_0.Args[1]
 11167			if v_1_0_0_1.Op != OpConst64 {
 11168				break
 11169			}
 11170			s := v_1_0_0_1.AuxInt
 11171			v_1_1 := v_1.Args[1]
 11172			if v_1_1.Op != OpConst16 {
 11173				break
 11174			}
 11175			c := v_1_1.AuxInt
 11176			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(16, c).m) && s == 16+umagic(16, c).s-1 && x.Op != OpConst16 && udivisibleOK(16, c)) {
 11177				break
 11178			}
 11179			v.reset(OpLeq16U)
 11180			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
 11181			v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
 11182			v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11183			v2.AuxInt = int64(int16(udivisible(16, c).m))
 11184			v1.AddArg(v2)
 11185			v1.AddArg(x)
 11186			v0.AddArg(v1)
 11187			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11188			v3.AuxInt = int64(16 - udivisible(16, c).k)
 11189			v0.AddArg(v3)
 11190			v.AddArg(v0)
 11191			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11192			v4.AuxInt = int64(int16(udivisible(16, c).max))
 11193			v.AddArg(v4)
 11194			return true
 11195		}
 11196		// match: (Eq16 (Mul16 (Const16 [c]) (Trunc32to16 (Rsh32Ux64 (Avg32u (Lsh32x64 (ZeroExt16to32 x) (Const64 [16])) mul:(Mul32 (Const32 [m]) (ZeroExt16to32 x))) (Const64 [s])))) x)
 11197		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(16,c).m) && s == 16+umagic(16,c).s-1 && x.Op != OpConst16 && udivisibleOK(16,c)
 11198		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) )
 11199		for {
 11200			x := v.Args[1]
 11201			v_0 := v.Args[0]
 11202			if v_0.Op != OpMul16 {
 11203				break
 11204			}
 11205			_ = v_0.Args[1]
 11206			v_0_0 := v_0.Args[0]
 11207			if v_0_0.Op != OpConst16 {
 11208				break
 11209			}
 11210			c := v_0_0.AuxInt
 11211			v_0_1 := v_0.Args[1]
 11212			if v_0_1.Op != OpTrunc32to16 {
 11213				break
 11214			}
 11215			v_0_1_0 := v_0_1.Args[0]
 11216			if v_0_1_0.Op != OpRsh32Ux64 {
 11217				break
 11218			}
 11219			_ = v_0_1_0.Args[1]
 11220			v_0_1_0_0 := v_0_1_0.Args[0]
 11221			if v_0_1_0_0.Op != OpAvg32u {
 11222				break
 11223			}
 11224			_ = v_0_1_0_0.Args[1]
 11225			v_0_1_0_0_0 := v_0_1_0_0.Args[0]
 11226			if v_0_1_0_0_0.Op != OpLsh32x64 {
 11227				break
 11228			}
 11229			_ = v_0_1_0_0_0.Args[1]
 11230			v_0_1_0_0_0_0 := v_0_1_0_0_0.Args[0]
 11231			if v_0_1_0_0_0_0.Op != OpZeroExt16to32 {
 11232				break
 11233			}
 11234			if x != v_0_1_0_0_0_0.Args[0] {
 11235				break
 11236			}
 11237			v_0_1_0_0_0_1 := v_0_1_0_0_0.Args[1]
 11238			if v_0_1_0_0_0_1.Op != OpConst64 {
 11239				break
 11240			}
 11241			if v_0_1_0_0_0_1.AuxInt != 16 {
 11242				break
 11243			}
 11244			mul := v_0_1_0_0.Args[1]
 11245			if mul.Op != OpMul32 {
 11246				break
 11247			}
 11248			_ = mul.Args[1]
 11249			mul_0 := mul.Args[0]
 11250			if mul_0.Op != OpConst32 {
 11251				break
 11252			}
 11253			m := mul_0.AuxInt
 11254			mul_1 := mul.Args[1]
 11255			if mul_1.Op != OpZeroExt16to32 {
 11256				break
 11257			}
 11258			if x != mul_1.Args[0] {
 11259				break
 11260			}
 11261			v_0_1_0_1 := v_0_1_0.Args[1]
 11262			if v_0_1_0_1.Op != OpConst64 {
 11263				break
 11264			}
 11265			s := v_0_1_0_1.AuxInt
 11266			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(16, c).m) && s == 16+umagic(16, c).s-1 && x.Op != OpConst16 && udivisibleOK(16, c)) {
 11267				break
 11268			}
 11269			v.reset(OpLeq16U)
 11270			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
 11271			v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
 11272			v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11273			v2.AuxInt = int64(int16(udivisible(16, c).m))
 11274			v1.AddArg(v2)
 11275			v1.AddArg(x)
 11276			v0.AddArg(v1)
 11277			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11278			v3.AuxInt = int64(16 - udivisible(16, c).k)
 11279			v0.AddArg(v3)
 11280			v.AddArg(v0)
 11281			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11282			v4.AuxInt = int64(int16(udivisible(16, c).max))
 11283			v.AddArg(v4)
 11284			return true
 11285		}
 11286		return false
 11287	}
 11288	func rewriteValuegeneric_OpEq16_40(v *Value) bool {
 11289		b := v.Block
 11290		typ := &b.Func.Config.Types
 11291		// match: (Eq16 (Mul16 (Const16 [c]) (Trunc32to16 (Rsh32Ux64 (Avg32u (Lsh32x64 (ZeroExt16to32 x) (Const64 [16])) mul:(Mul32 (ZeroExt16to32 x) (Const32 [m]))) (Const64 [s])))) x)
 11292		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(16,c).m) && s == 16+umagic(16,c).s-1 && x.Op != OpConst16 && udivisibleOK(16,c)
 11293		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) )
 11294		for {
 11295			x := v.Args[1]
 11296			v_0 := v.Args[0]
 11297			if v_0.Op != OpMul16 {
 11298				break
 11299			}
 11300			_ = v_0.Args[1]
 11301			v_0_0 := v_0.Args[0]
 11302			if v_0_0.Op != OpConst16 {
 11303				break
 11304			}
 11305			c := v_0_0.AuxInt
 11306			v_0_1 := v_0.Args[1]
 11307			if v_0_1.Op != OpTrunc32to16 {
 11308				break
 11309			}
 11310			v_0_1_0 := v_0_1.Args[0]
 11311			if v_0_1_0.Op != OpRsh32Ux64 {
 11312				break
 11313			}
 11314			_ = v_0_1_0.Args[1]
 11315			v_0_1_0_0 := v_0_1_0.Args[0]
 11316			if v_0_1_0_0.Op != OpAvg32u {
 11317				break
 11318			}
 11319			_ = v_0_1_0_0.Args[1]
 11320			v_0_1_0_0_0 := v_0_1_0_0.Args[0]
 11321			if v_0_1_0_0_0.Op != OpLsh32x64 {
 11322				break
 11323			}
 11324			_ = v_0_1_0_0_0.Args[1]
 11325			v_0_1_0_0_0_0 := v_0_1_0_0_0.Args[0]
 11326			if v_0_1_0_0_0_0.Op != OpZeroExt16to32 {
 11327				break
 11328			}
 11329			if x != v_0_1_0_0_0_0.Args[0] {
 11330				break
 11331			}
 11332			v_0_1_0_0_0_1 := v_0_1_0_0_0.Args[1]
 11333			if v_0_1_0_0_0_1.Op != OpConst64 {
 11334				break
 11335			}
 11336			if v_0_1_0_0_0_1.AuxInt != 16 {
 11337				break
 11338			}
 11339			mul := v_0_1_0_0.Args[1]
 11340			if mul.Op != OpMul32 {
 11341				break
 11342			}
 11343			_ = mul.Args[1]
 11344			mul_0 := mul.Args[0]
 11345			if mul_0.Op != OpZeroExt16to32 {
 11346				break
 11347			}
 11348			if x != mul_0.Args[0] {
 11349				break
 11350			}
 11351			mul_1 := mul.Args[1]
 11352			if mul_1.Op != OpConst32 {
 11353				break
 11354			}
 11355			m := mul_1.AuxInt
 11356			v_0_1_0_1 := v_0_1_0.Args[1]
 11357			if v_0_1_0_1.Op != OpConst64 {
 11358				break
 11359			}
 11360			s := v_0_1_0_1.AuxInt
 11361			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(16, c).m) && s == 16+umagic(16, c).s-1 && x.Op != OpConst16 && udivisibleOK(16, c)) {
 11362				break
 11363			}
 11364			v.reset(OpLeq16U)
 11365			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
 11366			v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
 11367			v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11368			v2.AuxInt = int64(int16(udivisible(16, c).m))
 11369			v1.AddArg(v2)
 11370			v1.AddArg(x)
 11371			v0.AddArg(v1)
 11372			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11373			v3.AuxInt = int64(16 - udivisible(16, c).k)
 11374			v0.AddArg(v3)
 11375			v.AddArg(v0)
 11376			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11377			v4.AuxInt = int64(int16(udivisible(16, c).max))
 11378			v.AddArg(v4)
 11379			return true
 11380		}
 11381		// match: (Eq16 (Mul16 (Trunc32to16 (Rsh32Ux64 (Avg32u (Lsh32x64 (ZeroExt16to32 x) (Const64 [16])) mul:(Mul32 (Const32 [m]) (ZeroExt16to32 x))) (Const64 [s]))) (Const16 [c])) x)
 11382		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(16,c).m) && s == 16+umagic(16,c).s-1 && x.Op != OpConst16 && udivisibleOK(16,c)
 11383		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) )
 11384		for {
 11385			x := v.Args[1]
 11386			v_0 := v.Args[0]
 11387			if v_0.Op != OpMul16 {
 11388				break
 11389			}
 11390			_ = v_0.Args[1]
 11391			v_0_0 := v_0.Args[0]
 11392			if v_0_0.Op != OpTrunc32to16 {
 11393				break
 11394			}
 11395			v_0_0_0 := v_0_0.Args[0]
 11396			if v_0_0_0.Op != OpRsh32Ux64 {
 11397				break
 11398			}
 11399			_ = v_0_0_0.Args[1]
 11400			v_0_0_0_0 := v_0_0_0.Args[0]
 11401			if v_0_0_0_0.Op != OpAvg32u {
 11402				break
 11403			}
 11404			_ = v_0_0_0_0.Args[1]
 11405			v_0_0_0_0_0 := v_0_0_0_0.Args[0]
 11406			if v_0_0_0_0_0.Op != OpLsh32x64 {
 11407				break
 11408			}
 11409			_ = v_0_0_0_0_0.Args[1]
 11410			v_0_0_0_0_0_0 := v_0_0_0_0_0.Args[0]
 11411			if v_0_0_0_0_0_0.Op != OpZeroExt16to32 {
 11412				break
 11413			}
 11414			if x != v_0_0_0_0_0_0.Args[0] {
 11415				break
 11416			}
 11417			v_0_0_0_0_0_1 := v_0_0_0_0_0.Args[1]
 11418			if v_0_0_0_0_0_1.Op != OpConst64 {
 11419				break
 11420			}
 11421			if v_0_0_0_0_0_1.AuxInt != 16 {
 11422				break
 11423			}
 11424			mul := v_0_0_0_0.Args[1]
 11425			if mul.Op != OpMul32 {
 11426				break
 11427			}
 11428			_ = mul.Args[1]
 11429			mul_0 := mul.Args[0]
 11430			if mul_0.Op != OpConst32 {
 11431				break
 11432			}
 11433			m := mul_0.AuxInt
 11434			mul_1 := mul.Args[1]
 11435			if mul_1.Op != OpZeroExt16to32 {
 11436				break
 11437			}
 11438			if x != mul_1.Args[0] {
 11439				break
 11440			}
 11441			v_0_0_0_1 := v_0_0_0.Args[1]
 11442			if v_0_0_0_1.Op != OpConst64 {
 11443				break
 11444			}
 11445			s := v_0_0_0_1.AuxInt
 11446			v_0_1 := v_0.Args[1]
 11447			if v_0_1.Op != OpConst16 {
 11448				break
 11449			}
 11450			c := v_0_1.AuxInt
 11451			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(16, c).m) && s == 16+umagic(16, c).s-1 && x.Op != OpConst16 && udivisibleOK(16, c)) {
 11452				break
 11453			}
 11454			v.reset(OpLeq16U)
 11455			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
 11456			v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
 11457			v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11458			v2.AuxInt = int64(int16(udivisible(16, c).m))
 11459			v1.AddArg(v2)
 11460			v1.AddArg(x)
 11461			v0.AddArg(v1)
 11462			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11463			v3.AuxInt = int64(16 - udivisible(16, c).k)
 11464			v0.AddArg(v3)
 11465			v.AddArg(v0)
 11466			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11467			v4.AuxInt = int64(int16(udivisible(16, c).max))
 11468			v.AddArg(v4)
 11469			return true
 11470		}
 11471		// match: (Eq16 (Mul16 (Trunc32to16 (Rsh32Ux64 (Avg32u (Lsh32x64 (ZeroExt16to32 x) (Const64 [16])) mul:(Mul32 (ZeroExt16to32 x) (Const32 [m]))) (Const64 [s]))) (Const16 [c])) x)
 11472		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(16,c).m) && s == 16+umagic(16,c).s-1 && x.Op != OpConst16 && udivisibleOK(16,c)
 11473		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) )
 11474		for {
 11475			x := v.Args[1]
 11476			v_0 := v.Args[0]
 11477			if v_0.Op != OpMul16 {
 11478				break
 11479			}
 11480			_ = v_0.Args[1]
 11481			v_0_0 := v_0.Args[0]
 11482			if v_0_0.Op != OpTrunc32to16 {
 11483				break
 11484			}
 11485			v_0_0_0 := v_0_0.Args[0]
 11486			if v_0_0_0.Op != OpRsh32Ux64 {
 11487				break
 11488			}
 11489			_ = v_0_0_0.Args[1]
 11490			v_0_0_0_0 := v_0_0_0.Args[0]
 11491			if v_0_0_0_0.Op != OpAvg32u {
 11492				break
 11493			}
 11494			_ = v_0_0_0_0.Args[1]
 11495			v_0_0_0_0_0 := v_0_0_0_0.Args[0]
 11496			if v_0_0_0_0_0.Op != OpLsh32x64 {
 11497				break
 11498			}
 11499			_ = v_0_0_0_0_0.Args[1]
 11500			v_0_0_0_0_0_0 := v_0_0_0_0_0.Args[0]
 11501			if v_0_0_0_0_0_0.Op != OpZeroExt16to32 {
 11502				break
 11503			}
 11504			if x != v_0_0_0_0_0_0.Args[0] {
 11505				break
 11506			}
 11507			v_0_0_0_0_0_1 := v_0_0_0_0_0.Args[1]
 11508			if v_0_0_0_0_0_1.Op != OpConst64 {
 11509				break
 11510			}
 11511			if v_0_0_0_0_0_1.AuxInt != 16 {
 11512				break
 11513			}
 11514			mul := v_0_0_0_0.Args[1]
 11515			if mul.Op != OpMul32 {
 11516				break
 11517			}
 11518			_ = mul.Args[1]
 11519			mul_0 := mul.Args[0]
 11520			if mul_0.Op != OpZeroExt16to32 {
 11521				break
 11522			}
 11523			if x != mul_0.Args[0] {
 11524				break
 11525			}
 11526			mul_1 := mul.Args[1]
 11527			if mul_1.Op != OpConst32 {
 11528				break
 11529			}
 11530			m := mul_1.AuxInt
 11531			v_0_0_0_1 := v_0_0_0.Args[1]
 11532			if v_0_0_0_1.Op != OpConst64 {
 11533				break
 11534			}
 11535			s := v_0_0_0_1.AuxInt
 11536			v_0_1 := v_0.Args[1]
 11537			if v_0_1.Op != OpConst16 {
 11538				break
 11539			}
 11540			c := v_0_1.AuxInt
 11541			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(16, c).m) && s == 16+umagic(16, c).s-1 && x.Op != OpConst16 && udivisibleOK(16, c)) {
 11542				break
 11543			}
 11544			v.reset(OpLeq16U)
 11545			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
 11546			v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
 11547			v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11548			v2.AuxInt = int64(int16(udivisible(16, c).m))
 11549			v1.AddArg(v2)
 11550			v1.AddArg(x)
 11551			v0.AddArg(v1)
 11552			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11553			v3.AuxInt = int64(16 - udivisible(16, c).k)
 11554			v0.AddArg(v3)
 11555			v.AddArg(v0)
 11556			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11557			v4.AuxInt = int64(int16(udivisible(16, c).max))
 11558			v.AddArg(v4)
 11559			return true
 11560		}
 11561		// match: (Eq16 x (Mul16 (Const16 [c]) (Sub16 (Rsh32x64 mul:(Mul32 (Const32 [m]) (SignExt16to32 x)) (Const64 [s])) (Rsh32x64 (SignExt16to32 x) (Const64 [31])))))
 11562		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(16,c).m) && s == 16+smagic(16,c).s && x.Op != OpConst16 && sdivisibleOK(16,c)
 11563		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Add16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).a))]) ) (Const16 <typ.UInt16> [int64(16-sdivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).max))]) )
 11564		for {
 11565			_ = v.Args[1]
 11566			x := v.Args[0]
 11567			v_1 := v.Args[1]
 11568			if v_1.Op != OpMul16 {
 11569				break
 11570			}
 11571			_ = v_1.Args[1]
 11572			v_1_0 := v_1.Args[0]
 11573			if v_1_0.Op != OpConst16 {
 11574				break
 11575			}
 11576			c := v_1_0.AuxInt
 11577			v_1_1 := v_1.Args[1]
 11578			if v_1_1.Op != OpSub16 {
 11579				break
 11580			}
 11581			_ = v_1_1.Args[1]
 11582			v_1_1_0 := v_1_1.Args[0]
 11583			if v_1_1_0.Op != OpRsh32x64 {
 11584				break
 11585			}
 11586			_ = v_1_1_0.Args[1]
 11587			mul := v_1_1_0.Args[0]
 11588			if mul.Op != OpMul32 {
 11589				break
 11590			}
 11591			_ = mul.Args[1]
 11592			mul_0 := mul.Args[0]
 11593			if mul_0.Op != OpConst32 {
 11594				break
 11595			}
 11596			m := mul_0.AuxInt
 11597			mul_1 := mul.Args[1]
 11598			if mul_1.Op != OpSignExt16to32 {
 11599				break
 11600			}
 11601			if x != mul_1.Args[0] {
 11602				break
 11603			}
 11604			v_1_1_0_1 := v_1_1_0.Args[1]
 11605			if v_1_1_0_1.Op != OpConst64 {
 11606				break
 11607			}
 11608			s := v_1_1_0_1.AuxInt
 11609			v_1_1_1 := v_1_1.Args[1]
 11610			if v_1_1_1.Op != OpRsh32x64 {
 11611				break
 11612			}
 11613			_ = v_1_1_1.Args[1]
 11614			v_1_1_1_0 := v_1_1_1.Args[0]
 11615			if v_1_1_1_0.Op != OpSignExt16to32 {
 11616				break
 11617			}
 11618			if x != v_1_1_1_0.Args[0] {
 11619				break
 11620			}
 11621			v_1_1_1_1 := v_1_1_1.Args[1]
 11622			if v_1_1_1_1.Op != OpConst64 {
 11623				break
 11624			}
 11625			if v_1_1_1_1.AuxInt != 31 {
 11626				break
 11627			}
 11628			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(16, c).m) && s == 16+smagic(16, c).s && x.Op != OpConst16 && sdivisibleOK(16, c)) {
 11629				break
 11630			}
 11631			v.reset(OpLeq16U)
 11632			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
 11633			v1 := b.NewValue0(v.Pos, OpAdd16, typ.UInt16)
 11634			v2 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
 11635			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11636			v3.AuxInt = int64(int16(sdivisible(16, c).m))
 11637			v2.AddArg(v3)
 11638			v2.AddArg(x)
 11639			v1.AddArg(v2)
 11640			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11641			v4.AuxInt = int64(int16(sdivisible(16, c).a))
 11642			v1.AddArg(v4)
 11643			v0.AddArg(v1)
 11644			v5 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11645			v5.AuxInt = int64(16 - sdivisible(16, c).k)
 11646			v0.AddArg(v5)
 11647			v.AddArg(v0)
 11648			v6 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11649			v6.AuxInt = int64(int16(sdivisible(16, c).max))
 11650			v.AddArg(v6)
 11651			return true
 11652		}
 11653		// match: (Eq16 x (Mul16 (Const16 [c]) (Sub16 (Rsh32x64 mul:(Mul32 (SignExt16to32 x) (Const32 [m])) (Const64 [s])) (Rsh32x64 (SignExt16to32 x) (Const64 [31])))))
 11654		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(16,c).m) && s == 16+smagic(16,c).s && x.Op != OpConst16 && sdivisibleOK(16,c)
 11655		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Add16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).a))]) ) (Const16 <typ.UInt16> [int64(16-sdivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).max))]) )
 11656		for {
 11657			_ = v.Args[1]
 11658			x := v.Args[0]
 11659			v_1 := v.Args[1]
 11660			if v_1.Op != OpMul16 {
 11661				break
 11662			}
 11663			_ = v_1.Args[1]
 11664			v_1_0 := v_1.Args[0]
 11665			if v_1_0.Op != OpConst16 {
 11666				break
 11667			}
 11668			c := v_1_0.AuxInt
 11669			v_1_1 := v_1.Args[1]
 11670			if v_1_1.Op != OpSub16 {
 11671				break
 11672			}
 11673			_ = v_1_1.Args[1]
 11674			v_1_1_0 := v_1_1.Args[0]
 11675			if v_1_1_0.Op != OpRsh32x64 {
 11676				break
 11677			}
 11678			_ = v_1_1_0.Args[1]
 11679			mul := v_1_1_0.Args[0]
 11680			if mul.Op != OpMul32 {
 11681				break
 11682			}
 11683			_ = mul.Args[1]
 11684			mul_0 := mul.Args[0]
 11685			if mul_0.Op != OpSignExt16to32 {
 11686				break
 11687			}
 11688			if x != mul_0.Args[0] {
 11689				break
 11690			}
 11691			mul_1 := mul.Args[1]
 11692			if mul_1.Op != OpConst32 {
 11693				break
 11694			}
 11695			m := mul_1.AuxInt
 11696			v_1_1_0_1 := v_1_1_0.Args[1]
 11697			if v_1_1_0_1.Op != OpConst64 {
 11698				break
 11699			}
 11700			s := v_1_1_0_1.AuxInt
 11701			v_1_1_1 := v_1_1.Args[1]
 11702			if v_1_1_1.Op != OpRsh32x64 {
 11703				break
 11704			}
 11705			_ = v_1_1_1.Args[1]
 11706			v_1_1_1_0 := v_1_1_1.Args[0]
 11707			if v_1_1_1_0.Op != OpSignExt16to32 {
 11708				break
 11709			}
 11710			if x != v_1_1_1_0.Args[0] {
 11711				break
 11712			}
 11713			v_1_1_1_1 := v_1_1_1.Args[1]
 11714			if v_1_1_1_1.Op != OpConst64 {
 11715				break
 11716			}
 11717			if v_1_1_1_1.AuxInt != 31 {
 11718				break
 11719			}
 11720			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(16, c).m) && s == 16+smagic(16, c).s && x.Op != OpConst16 && sdivisibleOK(16, c)) {
 11721				break
 11722			}
 11723			v.reset(OpLeq16U)
 11724			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
 11725			v1 := b.NewValue0(v.Pos, OpAdd16, typ.UInt16)
 11726			v2 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
 11727			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11728			v3.AuxInt = int64(int16(sdivisible(16, c).m))
 11729			v2.AddArg(v3)
 11730			v2.AddArg(x)
 11731			v1.AddArg(v2)
 11732			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11733			v4.AuxInt = int64(int16(sdivisible(16, c).a))
 11734			v1.AddArg(v4)
 11735			v0.AddArg(v1)
 11736			v5 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11737			v5.AuxInt = int64(16 - sdivisible(16, c).k)
 11738			v0.AddArg(v5)
 11739			v.AddArg(v0)
 11740			v6 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11741			v6.AuxInt = int64(int16(sdivisible(16, c).max))
 11742			v.AddArg(v6)
 11743			return true
 11744		}
 11745		// match: (Eq16 x (Mul16 (Sub16 (Rsh32x64 mul:(Mul32 (Const32 [m]) (SignExt16to32 x)) (Const64 [s])) (Rsh32x64 (SignExt16to32 x) (Const64 [31]))) (Const16 [c])))
 11746		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(16,c).m) && s == 16+smagic(16,c).s && x.Op != OpConst16 && sdivisibleOK(16,c)
 11747		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Add16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).a))]) ) (Const16 <typ.UInt16> [int64(16-sdivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).max))]) )
 11748		for {
 11749			_ = v.Args[1]
 11750			x := v.Args[0]
 11751			v_1 := v.Args[1]
 11752			if v_1.Op != OpMul16 {
 11753				break
 11754			}
 11755			_ = v_1.Args[1]
 11756			v_1_0 := v_1.Args[0]
 11757			if v_1_0.Op != OpSub16 {
 11758				break
 11759			}
 11760			_ = v_1_0.Args[1]
 11761			v_1_0_0 := v_1_0.Args[0]
 11762			if v_1_0_0.Op != OpRsh32x64 {
 11763				break
 11764			}
 11765			_ = v_1_0_0.Args[1]
 11766			mul := v_1_0_0.Args[0]
 11767			if mul.Op != OpMul32 {
 11768				break
 11769			}
 11770			_ = mul.Args[1]
 11771			mul_0 := mul.Args[0]
 11772			if mul_0.Op != OpConst32 {
 11773				break
 11774			}
 11775			m := mul_0.AuxInt
 11776			mul_1 := mul.Args[1]
 11777			if mul_1.Op != OpSignExt16to32 {
 11778				break
 11779			}
 11780			if x != mul_1.Args[0] {
 11781				break
 11782			}
 11783			v_1_0_0_1 := v_1_0_0.Args[1]
 11784			if v_1_0_0_1.Op != OpConst64 {
 11785				break
 11786			}
 11787			s := v_1_0_0_1.AuxInt
 11788			v_1_0_1 := v_1_0.Args[1]
 11789			if v_1_0_1.Op != OpRsh32x64 {
 11790				break
 11791			}
 11792			_ = v_1_0_1.Args[1]
 11793			v_1_0_1_0 := v_1_0_1.Args[0]
 11794			if v_1_0_1_0.Op != OpSignExt16to32 {
 11795				break
 11796			}
 11797			if x != v_1_0_1_0.Args[0] {
 11798				break
 11799			}
 11800			v_1_0_1_1 := v_1_0_1.Args[1]
 11801			if v_1_0_1_1.Op != OpConst64 {
 11802				break
 11803			}
 11804			if v_1_0_1_1.AuxInt != 31 {
 11805				break
 11806			}
 11807			v_1_1 := v_1.Args[1]
 11808			if v_1_1.Op != OpConst16 {
 11809				break
 11810			}
 11811			c := v_1_1.AuxInt
 11812			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(16, c).m) && s == 16+smagic(16, c).s && x.Op != OpConst16 && sdivisibleOK(16, c)) {
 11813				break
 11814			}
 11815			v.reset(OpLeq16U)
 11816			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
 11817			v1 := b.NewValue0(v.Pos, OpAdd16, typ.UInt16)
 11818			v2 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
 11819			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11820			v3.AuxInt = int64(int16(sdivisible(16, c).m))
 11821			v2.AddArg(v3)
 11822			v2.AddArg(x)
 11823			v1.AddArg(v2)
 11824			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11825			v4.AuxInt = int64(int16(sdivisible(16, c).a))
 11826			v1.AddArg(v4)
 11827			v0.AddArg(v1)
 11828			v5 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11829			v5.AuxInt = int64(16 - sdivisible(16, c).k)
 11830			v0.AddArg(v5)
 11831			v.AddArg(v0)
 11832			v6 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11833			v6.AuxInt = int64(int16(sdivisible(16, c).max))
 11834			v.AddArg(v6)
 11835			return true
 11836		}
 11837		// match: (Eq16 x (Mul16 (Sub16 (Rsh32x64 mul:(Mul32 (SignExt16to32 x) (Const32 [m])) (Const64 [s])) (Rsh32x64 (SignExt16to32 x) (Const64 [31]))) (Const16 [c])))
 11838		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(16,c).m) && s == 16+smagic(16,c).s && x.Op != OpConst16 && sdivisibleOK(16,c)
 11839		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Add16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).a))]) ) (Const16 <typ.UInt16> [int64(16-sdivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).max))]) )
 11840		for {
 11841			_ = v.Args[1]
 11842			x := v.Args[0]
 11843			v_1 := v.Args[1]
 11844			if v_1.Op != OpMul16 {
 11845				break
 11846			}
 11847			_ = v_1.Args[1]
 11848			v_1_0 := v_1.Args[0]
 11849			if v_1_0.Op != OpSub16 {
 11850				break
 11851			}
 11852			_ = v_1_0.Args[1]
 11853			v_1_0_0 := v_1_0.Args[0]
 11854			if v_1_0_0.Op != OpRsh32x64 {
 11855				break
 11856			}
 11857			_ = v_1_0_0.Args[1]
 11858			mul := v_1_0_0.Args[0]
 11859			if mul.Op != OpMul32 {
 11860				break
 11861			}
 11862			_ = mul.Args[1]
 11863			mul_0 := mul.Args[0]
 11864			if mul_0.Op != OpSignExt16to32 {
 11865				break
 11866			}
 11867			if x != mul_0.Args[0] {
 11868				break
 11869			}
 11870			mul_1 := mul.Args[1]
 11871			if mul_1.Op != OpConst32 {
 11872				break
 11873			}
 11874			m := mul_1.AuxInt
 11875			v_1_0_0_1 := v_1_0_0.Args[1]
 11876			if v_1_0_0_1.Op != OpConst64 {
 11877				break
 11878			}
 11879			s := v_1_0_0_1.AuxInt
 11880			v_1_0_1 := v_1_0.Args[1]
 11881			if v_1_0_1.Op != OpRsh32x64 {
 11882				break
 11883			}
 11884			_ = v_1_0_1.Args[1]
 11885			v_1_0_1_0 := v_1_0_1.Args[0]
 11886			if v_1_0_1_0.Op != OpSignExt16to32 {
 11887				break
 11888			}
 11889			if x != v_1_0_1_0.Args[0] {
 11890				break
 11891			}
 11892			v_1_0_1_1 := v_1_0_1.Args[1]
 11893			if v_1_0_1_1.Op != OpConst64 {
 11894				break
 11895			}
 11896			if v_1_0_1_1.AuxInt != 31 {
 11897				break
 11898			}
 11899			v_1_1 := v_1.Args[1]
 11900			if v_1_1.Op != OpConst16 {
 11901				break
 11902			}
 11903			c := v_1_1.AuxInt
 11904			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(16, c).m) && s == 16+smagic(16, c).s && x.Op != OpConst16 && sdivisibleOK(16, c)) {
 11905				break
 11906			}
 11907			v.reset(OpLeq16U)
 11908			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
 11909			v1 := b.NewValue0(v.Pos, OpAdd16, typ.UInt16)
 11910			v2 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
 11911			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11912			v3.AuxInt = int64(int16(sdivisible(16, c).m))
 11913			v2.AddArg(v3)
 11914			v2.AddArg(x)
 11915			v1.AddArg(v2)
 11916			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11917			v4.AuxInt = int64(int16(sdivisible(16, c).a))
 11918			v1.AddArg(v4)
 11919			v0.AddArg(v1)
 11920			v5 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11921			v5.AuxInt = int64(16 - sdivisible(16, c).k)
 11922			v0.AddArg(v5)
 11923			v.AddArg(v0)
 11924			v6 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 11925			v6.AuxInt = int64(int16(sdivisible(16, c).max))
 11926			v.AddArg(v6)
 11927			return true
 11928		}
 11929		// match: (Eq16 (Mul16 (Const16 [c]) (Sub16 (Rsh32x64 mul:(Mul32 (Const32 [m]) (SignExt16to32 x)) (Const64 [s])) (Rsh32x64 (SignExt16to32 x) (Const64 [31])))) x)
 11930		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(16,c).m) && s == 16+smagic(16,c).s && x.Op != OpConst16 && sdivisibleOK(16,c)
 11931		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Add16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).a))]) ) (Const16 <typ.UInt16> [int64(16-sdivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).max))]) )
 11932		for {
 11933			x := v.Args[1]
 11934			v_0 := v.Args[0]
 11935			if v_0.Op != OpMul16 {
 11936				break
 11937			}
 11938			_ = v_0.Args[1]
 11939			v_0_0 := v_0.Args[0]
 11940			if v_0_0.Op != OpConst16 {
 11941				break
 11942			}
 11943			c := v_0_0.AuxInt
 11944			v_0_1 := v_0.Args[1]
 11945			if v_0_1.Op != OpSub16 {
 11946				break
 11947			}
 11948			_ = v_0_1.Args[1]
 11949			v_0_1_0 := v_0_1.Args[0]
 11950			if v_0_1_0.Op != OpRsh32x64 {
 11951				break
 11952			}
 11953			_ = v_0_1_0.Args[1]
 11954			mul := v_0_1_0.Args[0]
 11955			if mul.Op != OpMul32 {
 11956				break
 11957			}
 11958			_ = mul.Args[1]
 11959			mul_0 := mul.Args[0]
 11960			if mul_0.Op != OpConst32 {
 11961				break
 11962			}
 11963			m := mul_0.AuxInt
 11964			mul_1 := mul.Args[1]
 11965			if mul_1.Op != OpSignExt16to32 {
 11966				break
 11967			}
 11968			if x != mul_1.Args[0] {
 11969				break
 11970			}
 11971			v_0_1_0_1 := v_0_1_0.Args[1]
 11972			if v_0_1_0_1.Op != OpConst64 {
 11973				break
 11974			}
 11975			s := v_0_1_0_1.AuxInt
 11976			v_0_1_1 := v_0_1.Args[1]
 11977			if v_0_1_1.Op != OpRsh32x64 {
 11978				break
 11979			}
 11980			_ = v_0_1_1.Args[1]
 11981			v_0_1_1_0 := v_0_1_1.Args[0]
 11982			if v_0_1_1_0.Op != OpSignExt16to32 {
 11983				break
 11984			}
 11985			if x != v_0_1_1_0.Args[0] {
 11986				break
 11987			}
 11988			v_0_1_1_1 := v_0_1_1.Args[1]
 11989			if v_0_1_1_1.Op != OpConst64 {
 11990				break
 11991			}
 11992			if v_0_1_1_1.AuxInt != 31 {
 11993				break
 11994			}
 11995			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(16, c).m) && s == 16+smagic(16, c).s && x.Op != OpConst16 && sdivisibleOK(16, c)) {
 11996				break
 11997			}
 11998			v.reset(OpLeq16U)
 11999			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
 12000			v1 := b.NewValue0(v.Pos, OpAdd16, typ.UInt16)
 12001			v2 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
 12002			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 12003			v3.AuxInt = int64(int16(sdivisible(16, c).m))
 12004			v2.AddArg(v3)
 12005			v2.AddArg(x)
 12006			v1.AddArg(v2)
 12007			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 12008			v4.AuxInt = int64(int16(sdivisible(16, c).a))
 12009			v1.AddArg(v4)
 12010			v0.AddArg(v1)
 12011			v5 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 12012			v5.AuxInt = int64(16 - sdivisible(16, c).k)
 12013			v0.AddArg(v5)
 12014			v.AddArg(v0)
 12015			v6 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 12016			v6.AuxInt = int64(int16(sdivisible(16, c).max))
 12017			v.AddArg(v6)
 12018			return true
 12019		}
 12020		// match: (Eq16 (Mul16 (Const16 [c]) (Sub16 (Rsh32x64 mul:(Mul32 (SignExt16to32 x) (Const32 [m])) (Const64 [s])) (Rsh32x64 (SignExt16to32 x) (Const64 [31])))) x)
 12021		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(16,c).m) && s == 16+smagic(16,c).s && x.Op != OpConst16 && sdivisibleOK(16,c)
 12022		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Add16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).a))]) ) (Const16 <typ.UInt16> [int64(16-sdivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).max))]) )
 12023		for {
 12024			x := v.Args[1]
 12025			v_0 := v.Args[0]
 12026			if v_0.Op != OpMul16 {
 12027				break
 12028			}
 12029			_ = v_0.Args[1]
 12030			v_0_0 := v_0.Args[0]
 12031			if v_0_0.Op != OpConst16 {
 12032				break
 12033			}
 12034			c := v_0_0.AuxInt
 12035			v_0_1 := v_0.Args[1]
 12036			if v_0_1.Op != OpSub16 {
 12037				break
 12038			}
 12039			_ = v_0_1.Args[1]
 12040			v_0_1_0 := v_0_1.Args[0]
 12041			if v_0_1_0.Op != OpRsh32x64 {
 12042				break
 12043			}
 12044			_ = v_0_1_0.Args[1]
 12045			mul := v_0_1_0.Args[0]
 12046			if mul.Op != OpMul32 {
 12047				break
 12048			}
 12049			_ = mul.Args[1]
 12050			mul_0 := mul.Args[0]
 12051			if mul_0.Op != OpSignExt16to32 {
 12052				break
 12053			}
 12054			if x != mul_0.Args[0] {
 12055				break
 12056			}
 12057			mul_1 := mul.Args[1]
 12058			if mul_1.Op != OpConst32 {
 12059				break
 12060			}
 12061			m := mul_1.AuxInt
 12062			v_0_1_0_1 := v_0_1_0.Args[1]
 12063			if v_0_1_0_1.Op != OpConst64 {
 12064				break
 12065			}
 12066			s := v_0_1_0_1.AuxInt
 12067			v_0_1_1 := v_0_1.Args[1]
 12068			if v_0_1_1.Op != OpRsh32x64 {
 12069				break
 12070			}
 12071			_ = v_0_1_1.Args[1]
 12072			v_0_1_1_0 := v_0_1_1.Args[0]
 12073			if v_0_1_1_0.Op != OpSignExt16to32 {
 12074				break
 12075			}
 12076			if x != v_0_1_1_0.Args[0] {
 12077				break
 12078			}
 12079			v_0_1_1_1 := v_0_1_1.Args[1]
 12080			if v_0_1_1_1.Op != OpConst64 {
 12081				break
 12082			}
 12083			if v_0_1_1_1.AuxInt != 31 {
 12084				break
 12085			}
 12086			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(16, c).m) && s == 16+smagic(16, c).s && x.Op != OpConst16 && sdivisibleOK(16, c)) {
 12087				break
 12088			}
 12089			v.reset(OpLeq16U)
 12090			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
 12091			v1 := b.NewValue0(v.Pos, OpAdd16, typ.UInt16)
 12092			v2 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
 12093			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 12094			v3.AuxInt = int64(int16(sdivisible(16, c).m))
 12095			v2.AddArg(v3)
 12096			v2.AddArg(x)
 12097			v1.AddArg(v2)
 12098			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 12099			v4.AuxInt = int64(int16(sdivisible(16, c).a))
 12100			v1.AddArg(v4)
 12101			v0.AddArg(v1)
 12102			v5 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 12103			v5.AuxInt = int64(16 - sdivisible(16, c).k)
 12104			v0.AddArg(v5)
 12105			v.AddArg(v0)
 12106			v6 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 12107			v6.AuxInt = int64(int16(sdivisible(16, c).max))
 12108			v.AddArg(v6)
 12109			return true
 12110		}
 12111		// match: (Eq16 (Mul16 (Sub16 (Rsh32x64 mul:(Mul32 (Const32 [m]) (SignExt16to32 x)) (Const64 [s])) (Rsh32x64 (SignExt16to32 x) (Const64 [31]))) (Const16 [c])) x)
 12112		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(16,c).m) && s == 16+smagic(16,c).s && x.Op != OpConst16 && sdivisibleOK(16,c)
 12113		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Add16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).a))]) ) (Const16 <typ.UInt16> [int64(16-sdivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).max))]) )
 12114		for {
 12115			x := v.Args[1]
 12116			v_0 := v.Args[0]
 12117			if v_0.Op != OpMul16 {
 12118				break
 12119			}
 12120			_ = v_0.Args[1]
 12121			v_0_0 := v_0.Args[0]
 12122			if v_0_0.Op != OpSub16 {
 12123				break
 12124			}
 12125			_ = v_0_0.Args[1]
 12126			v_0_0_0 := v_0_0.Args[0]
 12127			if v_0_0_0.Op != OpRsh32x64 {
 12128				break
 12129			}
 12130			_ = v_0_0_0.Args[1]
 12131			mul := v_0_0_0.Args[0]
 12132			if mul.Op != OpMul32 {
 12133				break
 12134			}
 12135			_ = mul.Args[1]
 12136			mul_0 := mul.Args[0]
 12137			if mul_0.Op != OpConst32 {
 12138				break
 12139			}
 12140			m := mul_0.AuxInt
 12141			mul_1 := mul.Args[1]
 12142			if mul_1.Op != OpSignExt16to32 {
 12143				break
 12144			}
 12145			if x != mul_1.Args[0] {
 12146				break
 12147			}
 12148			v_0_0_0_1 := v_0_0_0.Args[1]
 12149			if v_0_0_0_1.Op != OpConst64 {
 12150				break
 12151			}
 12152			s := v_0_0_0_1.AuxInt
 12153			v_0_0_1 := v_0_0.Args[1]
 12154			if v_0_0_1.Op != OpRsh32x64 {
 12155				break
 12156			}
 12157			_ = v_0_0_1.Args[1]
 12158			v_0_0_1_0 := v_0_0_1.Args[0]
 12159			if v_0_0_1_0.Op != OpSignExt16to32 {
 12160				break
 12161			}
 12162			if x != v_0_0_1_0.Args[0] {
 12163				break
 12164			}
 12165			v_0_0_1_1 := v_0_0_1.Args[1]
 12166			if v_0_0_1_1.Op != OpConst64 {
 12167				break
 12168			}
 12169			if v_0_0_1_1.AuxInt != 31 {
 12170				break
 12171			}
 12172			v_0_1 := v_0.Args[1]
 12173			if v_0_1.Op != OpConst16 {
 12174				break
 12175			}
 12176			c := v_0_1.AuxInt
 12177			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(16, c).m) && s == 16+smagic(16, c).s && x.Op != OpConst16 && sdivisibleOK(16, c)) {
 12178				break
 12179			}
 12180			v.reset(OpLeq16U)
 12181			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
 12182			v1 := b.NewValue0(v.Pos, OpAdd16, typ.UInt16)
 12183			v2 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
 12184			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 12185			v3.AuxInt = int64(int16(sdivisible(16, c).m))
 12186			v2.AddArg(v3)
 12187			v2.AddArg(x)
 12188			v1.AddArg(v2)
 12189			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 12190			v4.AuxInt = int64(int16(sdivisible(16, c).a))
 12191			v1.AddArg(v4)
 12192			v0.AddArg(v1)
 12193			v5 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 12194			v5.AuxInt = int64(16 - sdivisible(16, c).k)
 12195			v0.AddArg(v5)
 12196			v.AddArg(v0)
 12197			v6 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 12198			v6.AuxInt = int64(int16(sdivisible(16, c).max))
 12199			v.AddArg(v6)
 12200			return true
 12201		}
 12202		return false
 12203	}
 12204	func rewriteValuegeneric_OpEq16_50(v *Value) bool {
 12205		b := v.Block
 12206		typ := &b.Func.Config.Types
 12207		// match: (Eq16 (Mul16 (Sub16 (Rsh32x64 mul:(Mul32 (SignExt16to32 x) (Const32 [m])) (Const64 [s])) (Rsh32x64 (SignExt16to32 x) (Const64 [31]))) (Const16 [c])) x)
 12208		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(16,c).m) && s == 16+smagic(16,c).s && x.Op != OpConst16 && sdivisibleOK(16,c)
 12209		// result: (Leq16U (RotateLeft16 <typ.UInt16> (Add16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).a))]) ) (Const16 <typ.UInt16> [int64(16-sdivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).max))]) )
 12210		for {
 12211			x := v.Args[1]
 12212			v_0 := v.Args[0]
 12213			if v_0.Op != OpMul16 {
 12214				break
 12215			}
 12216			_ = v_0.Args[1]
 12217			v_0_0 := v_0.Args[0]
 12218			if v_0_0.Op != OpSub16 {
 12219				break
 12220			}
 12221			_ = v_0_0.Args[1]
 12222			v_0_0_0 := v_0_0.Args[0]
 12223			if v_0_0_0.Op != OpRsh32x64 {
 12224				break
 12225			}
 12226			_ = v_0_0_0.Args[1]
 12227			mul := v_0_0_0.Args[0]
 12228			if mul.Op != OpMul32 {
 12229				break
 12230			}
 12231			_ = mul.Args[1]
 12232			mul_0 := mul.Args[0]
 12233			if mul_0.Op != OpSignExt16to32 {
 12234				break
 12235			}
 12236			if x != mul_0.Args[0] {
 12237				break
 12238			}
 12239			mul_1 := mul.Args[1]
 12240			if mul_1.Op != OpConst32 {
 12241				break
 12242			}
 12243			m := mul_1.AuxInt
 12244			v_0_0_0_1 := v_0_0_0.Args[1]
 12245			if v_0_0_0_1.Op != OpConst64 {
 12246				break
 12247			}
 12248			s := v_0_0_0_1.AuxInt
 12249			v_0_0_1 := v_0_0.Args[1]
 12250			if v_0_0_1.Op != OpRsh32x64 {
 12251				break
 12252			}
 12253			_ = v_0_0_1.Args[1]
 12254			v_0_0_1_0 := v_0_0_1.Args[0]
 12255			if v_0_0_1_0.Op != OpSignExt16to32 {
 12256				break
 12257			}
 12258			if x != v_0_0_1_0.Args[0] {
 12259				break
 12260			}
 12261			v_0_0_1_1 := v_0_0_1.Args[1]
 12262			if v_0_0_1_1.Op != OpConst64 {
 12263				break
 12264			}
 12265			if v_0_0_1_1.AuxInt != 31 {
 12266				break
 12267			}
 12268			v_0_1 := v_0.Args[1]
 12269			if v_0_1.Op != OpConst16 {
 12270				break
 12271			}
 12272			c := v_0_1.AuxInt
 12273			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(16, c).m) && s == 16+smagic(16, c).s && x.Op != OpConst16 && sdivisibleOK(16, c)) {
 12274				break
 12275			}
 12276			v.reset(OpLeq16U)
 12277			v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16)
 12278			v1 := b.NewValue0(v.Pos, OpAdd16, typ.UInt16)
 12279			v2 := b.NewValue0(v.Pos, OpMul16, typ.UInt16)
 12280			v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 12281			v3.AuxInt = int64(int16(sdivisible(16, c).m))
 12282			v2.AddArg(v3)
 12283			v2.AddArg(x)
 12284			v1.AddArg(v2)
 12285			v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 12286			v4.AuxInt = int64(int16(sdivisible(16, c).a))
 12287			v1.AddArg(v4)
 12288			v0.AddArg(v1)
 12289			v5 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 12290			v5.AuxInt = int64(16 - sdivisible(16, c).k)
 12291			v0.AddArg(v5)
 12292			v.AddArg(v0)
 12293			v6 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
 12294			v6.AuxInt = int64(int16(sdivisible(16, c).max))
 12295			v.AddArg(v6)
 12296			return true
 12297		}
 12298		// match: (Eq16 n (Lsh16x64 (Rsh16x64 (Add16 <t> n (Rsh16Ux64 <t> (Rsh16x64 <t> n (Const64 <typ.UInt64> [15])) (Const64 <typ.UInt64> [kbar]))) (Const64 <typ.UInt64> [k])) (Const64 <typ.UInt64> [k])))
 12299		// cond: k > 0 && k < 15 && kbar == 16 - k
 12300		// result: (Eq16 (And16 <t> n (Const16 <t> [int64(1<<uint(k)-1)])) (Const16 <t> [0]))
 12301		for {
 12302			_ = v.Args[1]
 12303			n := v.Args[0]
 12304			v_1 := v.Args[1]
 12305			if v_1.Op != OpLsh16x64 {
 12306				break
 12307			}
 12308			_ = v_1.Args[1]
 12309			v_1_0 := v_1.Args[0]
 12310			if v_1_0.Op != OpRsh16x64 {
 12311				break
 12312			}
 12313			_ = v_1_0.Args[1]
 12314			v_1_0_0 := v_1_0.Args[0]
 12315			if v_1_0_0.Op != OpAdd16 {
 12316				break
 12317			}
 12318			t := v_1_0_0.Type
 12319			_ = v_1_0_0.Args[1]
 12320			if n != v_1_0_0.Args[0] {
 12321				break
 12322			}
 12323			v_1_0_0_1 := v_1_0_0.Args[1]
 12324			if v_1_0_0_1.Op != OpRsh16Ux64 {
 12325				break
 12326			}
 12327			if v_1_0_0_1.Type != t {
 12328				break
 12329			}
 12330			_ = v_1_0_0_1.Args[1]
 12331			v_1_0_0_1_0 := v_1_0_0_1.Args[0]
 12332			if v_1_0_0_1_0.Op != OpRsh16x64 {
 12333				break
 12334			}
 12335			if v_1_0_0_1_0.Type != t {
 12336				break
 12337			}
 12338			_ = v_1_0_0_1_0.Args[1]
 12339			if n != v_1_0_0_1_0.Args[0] {
 12340				break
 12341			}
 12342			v_1_0_0_1_0_1 := v_1_0_0_1_0.Args[1]
 12343			if v_1_0_0_1_0_1.Op != OpConst64 {
 12344				break
 12345			}
 12346			if v_1_0_0_1_0_1.Type != typ.UInt64 {
 12347				break
 12348			}
 12349			if v_1_0_0_1_0_1.AuxInt != 15 {
 12350				break
 12351			}
 12352			v_1_0_0_1_1 := v_1_0_0_1.Args[1]
 12353			if v_1_0_0_1_1.Op != OpConst64 {
 12354				break
 12355			}
 12356			if v_1_0_0_1_1.Type != typ.UInt64 {
 12357				break
 12358			}
 12359			kbar := v_1_0_0_1_1.AuxInt
 12360			v_1_0_1 := v_1_0.Args[1]
 12361			if v_1_0_1.Op != OpConst64 {
 12362				break
 12363			}
 12364			if v_1_0_1.Type != typ.UInt64 {
 12365				break
 12366			}
 12367			k := v_1_0_1.AuxInt
 12368			v_1_1 := v_1.Args[1]
 12369			if v_1_1.Op != OpConst64 {
 12370				break
 12371			}
 12372			if v_1_1.Type != typ.UInt64 {
 12373				break
 12374			}
 12375			if v_1_1.AuxInt != k {
 12376				break
 12377			}
 12378			if !(k > 0 && k < 15 && kbar == 16-k) {
 12379				break
 12380			}
 12381			v.reset(OpEq16)
 12382			v0 := b.NewValue0(v.Pos, OpAnd16, t)
 12383			v0.AddArg(n)
 12384			v1 := b.NewValue0(v.Pos, OpConst16, t)
 12385			v1.AuxInt = int64(1<<uint(k) - 1)
 12386			v0.AddArg(v1)
 12387			v.AddArg(v0)
 12388			v2 := b.NewValue0(v.Pos, OpConst16, t)
 12389			v2.AuxInt = 0
 12390			v.AddArg(v2)
 12391			return true
 12392		}
 12393		// match: (Eq16 n (Lsh16x64 (Rsh16x64 (Add16 <t> (Rsh16Ux64 <t> (Rsh16x64 <t> n (Const64 <typ.UInt64> [15])) (Const64 <typ.UInt64> [kbar])) n) (Const64 <typ.UInt64> [k])) (Const64 <typ.UInt64> [k])))
 12394		// cond: k > 0 && k < 15 && kbar == 16 - k
 12395		// result: (Eq16 (And16 <t> n (Const16 <t> [int64(1<<uint(k)-1)])) (Const16 <t> [0]))
 12396		for {
 12397			_ = v.Args[1]
 12398			n := v.Args[0]
 12399			v_1 := v.Args[1]
 12400			if v_1.Op != OpLsh16x64 {
 12401				break
 12402			}
 12403			_ = v_1.Args[1]
 12404			v_1_0 := v_1.Args[0]
 12405			if v_1_0.Op != OpRsh16x64 {
 12406				break
 12407			}
 12408			_ = v_1_0.Args[1]
 12409			v_1_0_0 := v_1_0.Args[0]
 12410			if v_1_0_0.Op != OpAdd16 {
 12411				break
 12412			}
 12413			t := v_1_0_0.Type
 12414			_ = v_1_0_0.Args[1]
 12415			v_1_0_0_0 := v_1_0_0.Args[0]
 12416			if v_1_0_0_0.Op != OpRsh16Ux64 {
 12417				break
 12418			}
 12419			if v_1_0_0_0.Type != t {
 12420				break
 12421			}
 12422			_ = v_1_0_0_0.Args[1]
 12423			v_1_0_0_0_0 := v_1_0_0_0.Args[0]
 12424			if v_1_0_0_0_0.Op != OpRsh16x64 {
 12425				break
 12426			}
 12427			if v_1_0_0_0_0.Type != t {
 12428				break
 12429			}
 12430			_ = v_1_0_0_0_0.Args[1]
 12431			if n != v_1_0_0_0_0.Args[0] {
 12432				break
 12433			}
 12434			v_1_0_0_0_0_1 := v_1_0_0_0_0.Args[1]
 12435			if v_1_0_0_0_0_1.Op != OpConst64 {
 12436				break
 12437			}
 12438			if v_1_0_0_0_0_1.Type != typ.UInt64 {
 12439				break
 12440			}
 12441			if v_1_0_0_0_0_1.AuxInt != 15 {
 12442				break
 12443			}
 12444			v_1_0_0_0_1 := v_1_0_0_0.Args[1]
 12445			if v_1_0_0_0_1.Op != OpConst64 {
 12446				break
 12447			}
 12448			if v_1_0_0_0_1.Type != typ.UInt64 {
 12449				break
 12450			}
 12451			kbar := v_1_0_0_0_1.AuxInt
 12452			if n != v_1_0_0.Args[1] {
 12453				break
 12454			}
 12455			v_1_0_1 := v_1_0.Args[1]
 12456			if v_1_0_1.Op != OpConst64 {
 12457				break
 12458			}
 12459			if v_1_0_1.Type != typ.UInt64 {
 12460				break
 12461			}
 12462			k := v_1_0_1.AuxInt
 12463			v_1_1 := v_1.Args[1]
 12464			if v_1_1.Op != OpConst64 {
 12465				break
 12466			}
 12467			if v_1_1.Type != typ.UInt64 {
 12468				break
 12469			}
 12470			if v_1_1.AuxInt != k {
 12471				break
 12472			}
 12473			if !(k > 0 && k < 15 && kbar == 16-k) {
 12474				break
 12475			}
 12476			v.reset(OpEq16)
 12477			v0 := b.NewValue0(v.Pos, OpAnd16, t)
 12478			v0.AddArg(n)
 12479			v1 := b.NewValue0(v.Pos, OpConst16, t)
 12480			v1.AuxInt = int64(1<<uint(k) - 1)
 12481			v0.AddArg(v1)
 12482			v.AddArg(v0)
 12483			v2 := b.NewValue0(v.Pos, OpConst16, t)
 12484			v2.AuxInt = 0
 12485			v.AddArg(v2)
 12486			return true
 12487		}
 12488		// match: (Eq16 (Lsh16x64 (Rsh16x64 (Add16 <t> n (Rsh16Ux64 <t> (Rsh16x64 <t> n (Const64 <typ.UInt64> [15])) (Const64 <typ.UInt64> [kbar]))) (Const64 <typ.UInt64> [k])) (Const64 <typ.UInt64> [k])) n)
 12489		// cond: k > 0 && k < 15 && kbar == 16 - k
 12490		// result: (Eq16 (And16 <t> n (Const16 <t> [int64(1<<uint(k)-1)])) (Const16 <t> [0]))
 12491		for {
 12492			n := v.Args[1]
 12493			v_0 := v.Args[0]
 12494			if v_0.Op != OpLsh16x64 {
 12495				break
 12496			}
 12497			_ = v_0.Args[1]
 12498			v_0_0 := v_0.Args[0]
 12499			if v_0_0.Op != OpRsh16x64 {
 12500				break
 12501			}
 12502			_ = v_0_0.Args[1]
 12503			v_0_0_0 := v_0_0.Args[0]
 12504			if v_0_0_0.Op != OpAdd16 {
 12505				break
 12506			}
 12507			t := v_0_0_0.Type
 12508			_ = v_0_0_0.Args[1]
 12509			if n != v_0_0_0.Args[0] {
 12510				break
 12511			}
 12512			v_0_0_0_1 := v_0_0_0.Args[1]
 12513			if v_0_0_0_1.Op != OpRsh16Ux64 {
 12514				break
 12515			}
 12516			if v_0_0_0_1.Type != t {
 12517				break
 12518			}
 12519			_ = v_0_0_0_1.Args[1]
 12520			v_0_0_0_1_0 := v_0_0_0_1.Args[0]
 12521			if v_0_0_0_1_0.Op != OpRsh16x64 {
 12522				break
 12523			}
 12524			if v_0_0_0_1_0.Type != t {
 12525				break
 12526			}
 12527			_ = v_0_0_0_1_0.Args[1]
 12528			if n != v_0_0_0_1_0.Args[0] {
 12529				break
 12530			}
 12531			v_0_0_0_1_0_1 := v_0_0_0_1_0.Args[1]
 12532			if v_0_0_0_1_0_1.Op != OpConst64 {
 12533				break
 12534			}
 12535			if v_0_0_0_1_0_1.Type != typ.UInt64 {
 12536				break
 12537			}
 12538			if v_0_0_0_1_0_1.AuxInt != 15 {
 12539				break
 12540			}
 12541			v_0_0_0_1_1 := v_0_0_0_1.Args[1]
 12542			if v_0_0_0_1_1.Op != OpConst64 {
 12543				break
 12544			}
 12545			if v_0_0_0_1_1.Type != typ.UInt64 {
 12546				break
 12547			}
 12548			kbar := v_0_0_0_1_1.AuxInt
 12549			v_0_0_1 := v_0_0.Args[1]
 12550			if v_0_0_1.Op != OpConst64 {
 12551				break
 12552			}
 12553			if v_0_0_1.Type != typ.UInt64 {
 12554				break
 12555			}
 12556			k := v_0_0_1.AuxInt
 12557			v_0_1 := v_0.Args[1]
 12558			if v_0_1.Op != OpConst64 {
 12559				break
 12560			}
 12561			if v_0_1.Type != typ.UInt64 {
 12562				break
 12563			}
 12564			if v_0_1.AuxInt != k {
 12565				break
 12566			}
 12567			if !(k > 0 && k < 15 && kbar == 16-k) {
 12568				break
 12569			}
 12570			v.reset(OpEq16)
 12571			v0 := b.NewValue0(v.Pos, OpAnd16, t)
 12572			v0.AddArg(n)
 12573			v1 := b.NewValue0(v.Pos, OpConst16, t)
 12574			v1.AuxInt = int64(1<<uint(k) - 1)
 12575			v0.AddArg(v1)
 12576			v.AddArg(v0)
 12577			v2 := b.NewValue0(v.Pos, OpConst16, t)
 12578			v2.AuxInt = 0
 12579			v.AddArg(v2)
 12580			return true
 12581		}
 12582		// match: (Eq16 (Lsh16x64 (Rsh16x64 (Add16 <t> (Rsh16Ux64 <t> (Rsh16x64 <t> n (Const64 <typ.UInt64> [15])) (Const64 <typ.UInt64> [kbar])) n) (Const64 <typ.UInt64> [k])) (Const64 <typ.UInt64> [k])) n)
 12583		// cond: k > 0 && k < 15 && kbar == 16 - k
 12584		// result: (Eq16 (And16 <t> n (Const16 <t> [int64(1<<uint(k)-1)])) (Const16 <t> [0]))
 12585		for {
 12586			n := v.Args[1]
 12587			v_0 := v.Args[0]
 12588			if v_0.Op != OpLsh16x64 {
 12589				break
 12590			}
 12591			_ = v_0.Args[1]
 12592			v_0_0 := v_0.Args[0]
 12593			if v_0_0.Op != OpRsh16x64 {
 12594				break
 12595			}
 12596			_ = v_0_0.Args[1]
 12597			v_0_0_0 := v_0_0.Args[0]
 12598			if v_0_0_0.Op != OpAdd16 {
 12599				break
 12600			}
 12601			t := v_0_0_0.Type
 12602			_ = v_0_0_0.Args[1]
 12603			v_0_0_0_0 := v_0_0_0.Args[0]
 12604			if v_0_0_0_0.Op != OpRsh16Ux64 {
 12605				break
 12606			}
 12607			if v_0_0_0_0.Type != t {
 12608				break
 12609			}
 12610			_ = v_0_0_0_0.Args[1]
 12611			v_0_0_0_0_0 := v_0_0_0_0.Args[0]
 12612			if v_0_0_0_0_0.Op != OpRsh16x64 {
 12613				break
 12614			}
 12615			if v_0_0_0_0_0.Type != t {
 12616				break
 12617			}
 12618			_ = v_0_0_0_0_0.Args[1]
 12619			if n != v_0_0_0_0_0.Args[0] {
 12620				break
 12621			}
 12622			v_0_0_0_0_0_1 := v_0_0_0_0_0.Args[1]
 12623			if v_0_0_0_0_0_1.Op != OpConst64 {
 12624				break
 12625			}
 12626			if v_0_0_0_0_0_1.Type != typ.UInt64 {
 12627				break
 12628			}
 12629			if v_0_0_0_0_0_1.AuxInt != 15 {
 12630				break
 12631			}
 12632			v_0_0_0_0_1 := v_0_0_0_0.Args[1]
 12633			if v_0_0_0_0_1.Op != OpConst64 {
 12634				break
 12635			}
 12636			if v_0_0_0_0_1.Type != typ.UInt64 {
 12637				break
 12638			}
 12639			kbar := v_0_0_0_0_1.AuxInt
 12640			if n != v_0_0_0.Args[1] {
 12641				break
 12642			}
 12643			v_0_0_1 := v_0_0.Args[1]
 12644			if v_0_0_1.Op != OpConst64 {
 12645				break
 12646			}
 12647			if v_0_0_1.Type != typ.UInt64 {
 12648				break
 12649			}
 12650			k := v_0_0_1.AuxInt
 12651			v_0_1 := v_0.Args[1]
 12652			if v_0_1.Op != OpConst64 {
 12653				break
 12654			}
 12655			if v_0_1.Type != typ.UInt64 {
 12656				break
 12657			}
 12658			if v_0_1.AuxInt != k {
 12659				break
 12660			}
 12661			if !(k > 0 && k < 15 && kbar == 16-k) {
 12662				break
 12663			}
 12664			v.reset(OpEq16)
 12665			v0 := b.NewValue0(v.Pos, OpAnd16, t)
 12666			v0.AddArg(n)
 12667			v1 := b.NewValue0(v.Pos, OpConst16, t)
 12668			v1.AuxInt = int64(1<<uint(k) - 1)
 12669			v0.AddArg(v1)
 12670			v.AddArg(v0)
 12671			v2 := b.NewValue0(v.Pos, OpConst16, t)
 12672			v2.AuxInt = 0
 12673			v.AddArg(v2)
 12674			return true
 12675		}
 12676		// match: (Eq16 s:(Sub16 x y) (Const16 [0]))
 12677		// cond: s.Uses == 1
 12678		// result: (Eq16 x y)
 12679		for {
 12680			_ = v.Args[1]
 12681			s := v.Args[0]
 12682			if s.Op != OpSub16 {
 12683				break
 12684			}
 12685			y := s.Args[1]
 12686			x := s.Args[0]
 12687			v_1 := v.Args[1]
 12688			if v_1.Op != OpConst16 {
 12689				break
 12690			}
 12691			if v_1.AuxInt != 0 {
 12692				break
 12693			}
 12694			if !(s.Uses == 1) {
 12695				break
 12696			}
 12697			v.reset(OpEq16)
 12698			v.AddArg(x)
 12699			v.AddArg(y)
 12700			return true
 12701		}
 12702		// match: (Eq16 (Const16 [0]) s:(Sub16 x y))
 12703		// cond: s.Uses == 1
 12704		// result: (Eq16 x y)
 12705		for {
 12706			_ = v.Args[1]
 12707			v_0 := v.Args[0]
 12708			if v_0.Op != OpConst16 {
 12709				break
 12710			}
 12711			if v_0.AuxInt != 0 {
 12712				break
 12713			}
 12714			s := v.Args[1]
 12715			if s.Op != OpSub16 {
 12716				break
 12717			}
 12718			y := s.Args[1]
 12719			x := s.Args[0]
 12720			if !(s.Uses == 1) {
 12721				break
 12722			}
 12723			v.reset(OpEq16)
 12724			v.AddArg(x)
 12725			v.AddArg(y)
 12726			return true
 12727		}
 12728		return false
 12729	}
 12730	func rewriteValuegeneric_OpEq32_0(v *Value) bool {
 12731		b := v.Block
 12732		typ := &b.Func.Config.Types
 12733		// match: (Eq32 x x)
 12734		// cond:
 12735		// result: (ConstBool [1])
 12736		for {
 12737			x := v.Args[1]
 12738			if x != v.Args[0] {
 12739				break
 12740			}
 12741			v.reset(OpConstBool)
 12742			v.AuxInt = 1
 12743			return true
 12744		}
 12745		// match: (Eq32 (Const32 <t> [c]) (Add32 (Const32 <t> [d]) x))
 12746		// cond:
 12747		// result: (Eq32 (Const32 <t> [int64(int32(c-d))]) x)
 12748		for {
 12749			_ = v.Args[1]
 12750			v_0 := v.Args[0]
 12751			if v_0.Op != OpConst32 {
 12752				break
 12753			}
 12754			t := v_0.Type
 12755			c := v_0.AuxInt
 12756			v_1 := v.Args[1]
 12757			if v_1.Op != OpAdd32 {
 12758				break
 12759			}
 12760			x := v_1.Args[1]
 12761			v_1_0 := v_1.Args[0]
 12762			if v_1_0.Op != OpConst32 {
 12763				break
 12764			}
 12765			if v_1_0.Type != t {
 12766				break
 12767			}
 12768			d := v_1_0.AuxInt
 12769			v.reset(OpEq32)
 12770			v0 := b.NewValue0(v.Pos, OpConst32, t)
 12771			v0.AuxInt = int64(int32(c - d))
 12772			v.AddArg(v0)
 12773			v.AddArg(x)
 12774			return true
 12775		}
 12776		// match: (Eq32 (Const32 <t> [c]) (Add32 x (Const32 <t> [d])))
 12777		// cond:
 12778		// result: (Eq32 (Const32 <t> [int64(int32(c-d))]) x)
 12779		for {
 12780			_ = v.Args[1]
 12781			v_0 := v.Args[0]
 12782			if v_0.Op != OpConst32 {
 12783				break
 12784			}
 12785			t := v_0.Type
 12786			c := v_0.AuxInt
 12787			v_1 := v.Args[1]
 12788			if v_1.Op != OpAdd32 {
 12789				break
 12790			}
 12791			_ = v_1.Args[1]
 12792			x := v_1.Args[0]
 12793			v_1_1 := v_1.Args[1]
 12794			if v_1_1.Op != OpConst32 {
 12795				break
 12796			}
 12797			if v_1_1.Type != t {
 12798				break
 12799			}
 12800			d := v_1_1.AuxInt
 12801			v.reset(OpEq32)
 12802			v0 := b.NewValue0(v.Pos, OpConst32, t)
 12803			v0.AuxInt = int64(int32(c - d))
 12804			v.AddArg(v0)
 12805			v.AddArg(x)
 12806			return true
 12807		}
 12808		// match: (Eq32 (Add32 (Const32 <t> [d]) x) (Const32 <t> [c]))
 12809		// cond:
 12810		// result: (Eq32 (Const32 <t> [int64(int32(c-d))]) x)
 12811		for {
 12812			_ = v.Args[1]
 12813			v_0 := v.Args[0]
 12814			if v_0.Op != OpAdd32 {
 12815				break
 12816			}
 12817			x := v_0.Args[1]
 12818			v_0_0 := v_0.Args[0]
 12819			if v_0_0.Op != OpConst32 {
 12820				break
 12821			}
 12822			t := v_0_0.Type
 12823			d := v_0_0.AuxInt
 12824			v_1 := v.Args[1]
 12825			if v_1.Op != OpConst32 {
 12826				break
 12827			}
 12828			if v_1.Type != t {
 12829				break
 12830			}
 12831			c := v_1.AuxInt
 12832			v.reset(OpEq32)
 12833			v0 := b.NewValue0(v.Pos, OpConst32, t)
 12834			v0.AuxInt = int64(int32(c - d))
 12835			v.AddArg(v0)
 12836			v.AddArg(x)
 12837			return true
 12838		}
 12839		// match: (Eq32 (Add32 x (Const32 <t> [d])) (Const32 <t> [c]))
 12840		// cond:
 12841		// result: (Eq32 (Const32 <t> [int64(int32(c-d))]) x)
 12842		for {
 12843			_ = v.Args[1]
 12844			v_0 := v.Args[0]
 12845			if v_0.Op != OpAdd32 {
 12846				break
 12847			}
 12848			_ = v_0.Args[1]
 12849			x := v_0.Args[0]
 12850			v_0_1 := v_0.Args[1]
 12851			if v_0_1.Op != OpConst32 {
 12852				break
 12853			}
 12854			t := v_0_1.Type
 12855			d := v_0_1.AuxInt
 12856			v_1 := v.Args[1]
 12857			if v_1.Op != OpConst32 {
 12858				break
 12859			}
 12860			if v_1.Type != t {
 12861				break
 12862			}
 12863			c := v_1.AuxInt
 12864			v.reset(OpEq32)
 12865			v0 := b.NewValue0(v.Pos, OpConst32, t)
 12866			v0.AuxInt = int64(int32(c - d))
 12867			v.AddArg(v0)
 12868			v.AddArg(x)
 12869			return true
 12870		}
 12871		// match: (Eq32 (Const32 [c]) (Const32 [d]))
 12872		// cond:
 12873		// result: (ConstBool [b2i(c == d)])
 12874		for {
 12875			_ = v.Args[1]
 12876			v_0 := v.Args[0]
 12877			if v_0.Op != OpConst32 {
 12878				break
 12879			}
 12880			c := v_0.AuxInt
 12881			v_1 := v.Args[1]
 12882			if v_1.Op != OpConst32 {
 12883				break
 12884			}
 12885			d := v_1.AuxInt
 12886			v.reset(OpConstBool)
 12887			v.AuxInt = b2i(c == d)
 12888			return true
 12889		}
 12890		// match: (Eq32 (Const32 [d]) (Const32 [c]))
 12891		// cond:
 12892		// result: (ConstBool [b2i(c == d)])
 12893		for {
 12894			_ = v.Args[1]
 12895			v_0 := v.Args[0]
 12896			if v_0.Op != OpConst32 {
 12897				break
 12898			}
 12899			d := v_0.AuxInt
 12900			v_1 := v.Args[1]
 12901			if v_1.Op != OpConst32 {
 12902				break
 12903			}
 12904			c := v_1.AuxInt
 12905			v.reset(OpConstBool)
 12906			v.AuxInt = b2i(c == d)
 12907			return true
 12908		}
 12909		// match: (Eq32 x (Mul32 (Const32 [c]) (Rsh32Ux64 mul:(Hmul32u (Const32 [m]) x) (Const64 [s]))))
 12910		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+umagic(32,c).m/2)) && s == umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c)
 12911		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 12912		for {
 12913			_ = v.Args[1]
 12914			x := v.Args[0]
 12915			v_1 := v.Args[1]
 12916			if v_1.Op != OpMul32 {
 12917				break
 12918			}
 12919			_ = v_1.Args[1]
 12920			v_1_0 := v_1.Args[0]
 12921			if v_1_0.Op != OpConst32 {
 12922				break
 12923			}
 12924			c := v_1_0.AuxInt
 12925			v_1_1 := v_1.Args[1]
 12926			if v_1_1.Op != OpRsh32Ux64 {
 12927				break
 12928			}
 12929			_ = v_1_1.Args[1]
 12930			mul := v_1_1.Args[0]
 12931			if mul.Op != OpHmul32u {
 12932				break
 12933			}
 12934			_ = mul.Args[1]
 12935			mul_0 := mul.Args[0]
 12936			if mul_0.Op != OpConst32 {
 12937				break
 12938			}
 12939			m := mul_0.AuxInt
 12940			if x != mul.Args[1] {
 12941				break
 12942			}
 12943			v_1_1_1 := v_1_1.Args[1]
 12944			if v_1_1_1.Op != OpConst64 {
 12945				break
 12946			}
 12947			s := v_1_1_1.AuxInt
 12948			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+umagic(32, c).m/2)) && s == umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 12949				break
 12950			}
 12951			v.reset(OpLeq32U)
 12952			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 12953			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 12954			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 12955			v2.AuxInt = int64(int32(udivisible(32, c).m))
 12956			v1.AddArg(v2)
 12957			v1.AddArg(x)
 12958			v0.AddArg(v1)
 12959			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 12960			v3.AuxInt = int64(32 - udivisible(32, c).k)
 12961			v0.AddArg(v3)
 12962			v.AddArg(v0)
 12963			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 12964			v4.AuxInt = int64(int32(udivisible(32, c).max))
 12965			v.AddArg(v4)
 12966			return true
 12967		}
 12968		// match: (Eq32 x (Mul32 (Const32 [c]) (Rsh32Ux64 mul:(Hmul32u x (Const32 [m])) (Const64 [s]))))
 12969		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+umagic(32,c).m/2)) && s == umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c)
 12970		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 12971		for {
 12972			_ = v.Args[1]
 12973			x := v.Args[0]
 12974			v_1 := v.Args[1]
 12975			if v_1.Op != OpMul32 {
 12976				break
 12977			}
 12978			_ = v_1.Args[1]
 12979			v_1_0 := v_1.Args[0]
 12980			if v_1_0.Op != OpConst32 {
 12981				break
 12982			}
 12983			c := v_1_0.AuxInt
 12984			v_1_1 := v_1.Args[1]
 12985			if v_1_1.Op != OpRsh32Ux64 {
 12986				break
 12987			}
 12988			_ = v_1_1.Args[1]
 12989			mul := v_1_1.Args[0]
 12990			if mul.Op != OpHmul32u {
 12991				break
 12992			}
 12993			_ = mul.Args[1]
 12994			if x != mul.Args[0] {
 12995				break
 12996			}
 12997			mul_1 := mul.Args[1]
 12998			if mul_1.Op != OpConst32 {
 12999				break
 13000			}
 13001			m := mul_1.AuxInt
 13002			v_1_1_1 := v_1_1.Args[1]
 13003			if v_1_1_1.Op != OpConst64 {
 13004				break
 13005			}
 13006			s := v_1_1_1.AuxInt
 13007			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+umagic(32, c).m/2)) && s == umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 13008				break
 13009			}
 13010			v.reset(OpLeq32U)
 13011			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 13012			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 13013			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13014			v2.AuxInt = int64(int32(udivisible(32, c).m))
 13015			v1.AddArg(v2)
 13016			v1.AddArg(x)
 13017			v0.AddArg(v1)
 13018			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13019			v3.AuxInt = int64(32 - udivisible(32, c).k)
 13020			v0.AddArg(v3)
 13021			v.AddArg(v0)
 13022			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13023			v4.AuxInt = int64(int32(udivisible(32, c).max))
 13024			v.AddArg(v4)
 13025			return true
 13026		}
 13027		// match: (Eq32 x (Mul32 (Rsh32Ux64 mul:(Hmul32u (Const32 [m]) x) (Const64 [s])) (Const32 [c])))
 13028		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+umagic(32,c).m/2)) && s == umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c)
 13029		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 13030		for {
 13031			_ = v.Args[1]
 13032			x := v.Args[0]
 13033			v_1 := v.Args[1]
 13034			if v_1.Op != OpMul32 {
 13035				break
 13036			}
 13037			_ = v_1.Args[1]
 13038			v_1_0 := v_1.Args[0]
 13039			if v_1_0.Op != OpRsh32Ux64 {
 13040				break
 13041			}
 13042			_ = v_1_0.Args[1]
 13043			mul := v_1_0.Args[0]
 13044			if mul.Op != OpHmul32u {
 13045				break
 13046			}
 13047			_ = mul.Args[1]
 13048			mul_0 := mul.Args[0]
 13049			if mul_0.Op != OpConst32 {
 13050				break
 13051			}
 13052			m := mul_0.AuxInt
 13053			if x != mul.Args[1] {
 13054				break
 13055			}
 13056			v_1_0_1 := v_1_0.Args[1]
 13057			if v_1_0_1.Op != OpConst64 {
 13058				break
 13059			}
 13060			s := v_1_0_1.AuxInt
 13061			v_1_1 := v_1.Args[1]
 13062			if v_1_1.Op != OpConst32 {
 13063				break
 13064			}
 13065			c := v_1_1.AuxInt
 13066			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+umagic(32, c).m/2)) && s == umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 13067				break
 13068			}
 13069			v.reset(OpLeq32U)
 13070			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 13071			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 13072			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13073			v2.AuxInt = int64(int32(udivisible(32, c).m))
 13074			v1.AddArg(v2)
 13075			v1.AddArg(x)
 13076			v0.AddArg(v1)
 13077			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13078			v3.AuxInt = int64(32 - udivisible(32, c).k)
 13079			v0.AddArg(v3)
 13080			v.AddArg(v0)
 13081			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13082			v4.AuxInt = int64(int32(udivisible(32, c).max))
 13083			v.AddArg(v4)
 13084			return true
 13085		}
 13086		return false
 13087	}
 13088	func rewriteValuegeneric_OpEq32_10(v *Value) bool {
 13089		b := v.Block
 13090		typ := &b.Func.Config.Types
 13091		// match: (Eq32 x (Mul32 (Rsh32Ux64 mul:(Hmul32u x (Const32 [m])) (Const64 [s])) (Const32 [c])))
 13092		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+umagic(32,c).m/2)) && s == umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c)
 13093		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 13094		for {
 13095			_ = v.Args[1]
 13096			x := v.Args[0]
 13097			v_1 := v.Args[1]
 13098			if v_1.Op != OpMul32 {
 13099				break
 13100			}
 13101			_ = v_1.Args[1]
 13102			v_1_0 := v_1.Args[0]
 13103			if v_1_0.Op != OpRsh32Ux64 {
 13104				break
 13105			}
 13106			_ = v_1_0.Args[1]
 13107			mul := v_1_0.Args[0]
 13108			if mul.Op != OpHmul32u {
 13109				break
 13110			}
 13111			_ = mul.Args[1]
 13112			if x != mul.Args[0] {
 13113				break
 13114			}
 13115			mul_1 := mul.Args[1]
 13116			if mul_1.Op != OpConst32 {
 13117				break
 13118			}
 13119			m := mul_1.AuxInt
 13120			v_1_0_1 := v_1_0.Args[1]
 13121			if v_1_0_1.Op != OpConst64 {
 13122				break
 13123			}
 13124			s := v_1_0_1.AuxInt
 13125			v_1_1 := v_1.Args[1]
 13126			if v_1_1.Op != OpConst32 {
 13127				break
 13128			}
 13129			c := v_1_1.AuxInt
 13130			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+umagic(32, c).m/2)) && s == umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 13131				break
 13132			}
 13133			v.reset(OpLeq32U)
 13134			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 13135			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 13136			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13137			v2.AuxInt = int64(int32(udivisible(32, c).m))
 13138			v1.AddArg(v2)
 13139			v1.AddArg(x)
 13140			v0.AddArg(v1)
 13141			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13142			v3.AuxInt = int64(32 - udivisible(32, c).k)
 13143			v0.AddArg(v3)
 13144			v.AddArg(v0)
 13145			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13146			v4.AuxInt = int64(int32(udivisible(32, c).max))
 13147			v.AddArg(v4)
 13148			return true
 13149		}
 13150		// match: (Eq32 (Mul32 (Const32 [c]) (Rsh32Ux64 mul:(Hmul32u (Const32 [m]) x) (Const64 [s]))) x)
 13151		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+umagic(32,c).m/2)) && s == umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c)
 13152		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 13153		for {
 13154			x := v.Args[1]
 13155			v_0 := v.Args[0]
 13156			if v_0.Op != OpMul32 {
 13157				break
 13158			}
 13159			_ = v_0.Args[1]
 13160			v_0_0 := v_0.Args[0]
 13161			if v_0_0.Op != OpConst32 {
 13162				break
 13163			}
 13164			c := v_0_0.AuxInt
 13165			v_0_1 := v_0.Args[1]
 13166			if v_0_1.Op != OpRsh32Ux64 {
 13167				break
 13168			}
 13169			_ = v_0_1.Args[1]
 13170			mul := v_0_1.Args[0]
 13171			if mul.Op != OpHmul32u {
 13172				break
 13173			}
 13174			_ = mul.Args[1]
 13175			mul_0 := mul.Args[0]
 13176			if mul_0.Op != OpConst32 {
 13177				break
 13178			}
 13179			m := mul_0.AuxInt
 13180			if x != mul.Args[1] {
 13181				break
 13182			}
 13183			v_0_1_1 := v_0_1.Args[1]
 13184			if v_0_1_1.Op != OpConst64 {
 13185				break
 13186			}
 13187			s := v_0_1_1.AuxInt
 13188			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+umagic(32, c).m/2)) && s == umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 13189				break
 13190			}
 13191			v.reset(OpLeq32U)
 13192			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 13193			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 13194			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13195			v2.AuxInt = int64(int32(udivisible(32, c).m))
 13196			v1.AddArg(v2)
 13197			v1.AddArg(x)
 13198			v0.AddArg(v1)
 13199			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13200			v3.AuxInt = int64(32 - udivisible(32, c).k)
 13201			v0.AddArg(v3)
 13202			v.AddArg(v0)
 13203			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13204			v4.AuxInt = int64(int32(udivisible(32, c).max))
 13205			v.AddArg(v4)
 13206			return true
 13207		}
 13208		// match: (Eq32 (Mul32 (Const32 [c]) (Rsh32Ux64 mul:(Hmul32u x (Const32 [m])) (Const64 [s]))) x)
 13209		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+umagic(32,c).m/2)) && s == umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c)
 13210		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 13211		for {
 13212			x := v.Args[1]
 13213			v_0 := v.Args[0]
 13214			if v_0.Op != OpMul32 {
 13215				break
 13216			}
 13217			_ = v_0.Args[1]
 13218			v_0_0 := v_0.Args[0]
 13219			if v_0_0.Op != OpConst32 {
 13220				break
 13221			}
 13222			c := v_0_0.AuxInt
 13223			v_0_1 := v_0.Args[1]
 13224			if v_0_1.Op != OpRsh32Ux64 {
 13225				break
 13226			}
 13227			_ = v_0_1.Args[1]
 13228			mul := v_0_1.Args[0]
 13229			if mul.Op != OpHmul32u {
 13230				break
 13231			}
 13232			_ = mul.Args[1]
 13233			if x != mul.Args[0] {
 13234				break
 13235			}
 13236			mul_1 := mul.Args[1]
 13237			if mul_1.Op != OpConst32 {
 13238				break
 13239			}
 13240			m := mul_1.AuxInt
 13241			v_0_1_1 := v_0_1.Args[1]
 13242			if v_0_1_1.Op != OpConst64 {
 13243				break
 13244			}
 13245			s := v_0_1_1.AuxInt
 13246			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+umagic(32, c).m/2)) && s == umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 13247				break
 13248			}
 13249			v.reset(OpLeq32U)
 13250			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 13251			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 13252			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13253			v2.AuxInt = int64(int32(udivisible(32, c).m))
 13254			v1.AddArg(v2)
 13255			v1.AddArg(x)
 13256			v0.AddArg(v1)
 13257			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13258			v3.AuxInt = int64(32 - udivisible(32, c).k)
 13259			v0.AddArg(v3)
 13260			v.AddArg(v0)
 13261			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13262			v4.AuxInt = int64(int32(udivisible(32, c).max))
 13263			v.AddArg(v4)
 13264			return true
 13265		}
 13266		// match: (Eq32 (Mul32 (Rsh32Ux64 mul:(Hmul32u (Const32 [m]) x) (Const64 [s])) (Const32 [c])) x)
 13267		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+umagic(32,c).m/2)) && s == umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c)
 13268		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 13269		for {
 13270			x := v.Args[1]
 13271			v_0 := v.Args[0]
 13272			if v_0.Op != OpMul32 {
 13273				break
 13274			}
 13275			_ = v_0.Args[1]
 13276			v_0_0 := v_0.Args[0]
 13277			if v_0_0.Op != OpRsh32Ux64 {
 13278				break
 13279			}
 13280			_ = v_0_0.Args[1]
 13281			mul := v_0_0.Args[0]
 13282			if mul.Op != OpHmul32u {
 13283				break
 13284			}
 13285			_ = mul.Args[1]
 13286			mul_0 := mul.Args[0]
 13287			if mul_0.Op != OpConst32 {
 13288				break
 13289			}
 13290			m := mul_0.AuxInt
 13291			if x != mul.Args[1] {
 13292				break
 13293			}
 13294			v_0_0_1 := v_0_0.Args[1]
 13295			if v_0_0_1.Op != OpConst64 {
 13296				break
 13297			}
 13298			s := v_0_0_1.AuxInt
 13299			v_0_1 := v_0.Args[1]
 13300			if v_0_1.Op != OpConst32 {
 13301				break
 13302			}
 13303			c := v_0_1.AuxInt
 13304			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+umagic(32, c).m/2)) && s == umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 13305				break
 13306			}
 13307			v.reset(OpLeq32U)
 13308			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 13309			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 13310			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13311			v2.AuxInt = int64(int32(udivisible(32, c).m))
 13312			v1.AddArg(v2)
 13313			v1.AddArg(x)
 13314			v0.AddArg(v1)
 13315			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13316			v3.AuxInt = int64(32 - udivisible(32, c).k)
 13317			v0.AddArg(v3)
 13318			v.AddArg(v0)
 13319			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13320			v4.AuxInt = int64(int32(udivisible(32, c).max))
 13321			v.AddArg(v4)
 13322			return true
 13323		}
 13324		// match: (Eq32 (Mul32 (Rsh32Ux64 mul:(Hmul32u x (Const32 [m])) (Const64 [s])) (Const32 [c])) x)
 13325		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+umagic(32,c).m/2)) && s == umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c)
 13326		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 13327		for {
 13328			x := v.Args[1]
 13329			v_0 := v.Args[0]
 13330			if v_0.Op != OpMul32 {
 13331				break
 13332			}
 13333			_ = v_0.Args[1]
 13334			v_0_0 := v_0.Args[0]
 13335			if v_0_0.Op != OpRsh32Ux64 {
 13336				break
 13337			}
 13338			_ = v_0_0.Args[1]
 13339			mul := v_0_0.Args[0]
 13340			if mul.Op != OpHmul32u {
 13341				break
 13342			}
 13343			_ = mul.Args[1]
 13344			if x != mul.Args[0] {
 13345				break
 13346			}
 13347			mul_1 := mul.Args[1]
 13348			if mul_1.Op != OpConst32 {
 13349				break
 13350			}
 13351			m := mul_1.AuxInt
 13352			v_0_0_1 := v_0_0.Args[1]
 13353			if v_0_0_1.Op != OpConst64 {
 13354				break
 13355			}
 13356			s := v_0_0_1.AuxInt
 13357			v_0_1 := v_0.Args[1]
 13358			if v_0_1.Op != OpConst32 {
 13359				break
 13360			}
 13361			c := v_0_1.AuxInt
 13362			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+umagic(32, c).m/2)) && s == umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 13363				break
 13364			}
 13365			v.reset(OpLeq32U)
 13366			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 13367			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 13368			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13369			v2.AuxInt = int64(int32(udivisible(32, c).m))
 13370			v1.AddArg(v2)
 13371			v1.AddArg(x)
 13372			v0.AddArg(v1)
 13373			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13374			v3.AuxInt = int64(32 - udivisible(32, c).k)
 13375			v0.AddArg(v3)
 13376			v.AddArg(v0)
 13377			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13378			v4.AuxInt = int64(int32(udivisible(32, c).max))
 13379			v.AddArg(v4)
 13380			return true
 13381		}
 13382		// match: (Eq32 x (Mul32 (Const32 [c]) (Rsh32Ux64 mul:(Hmul32u (Const32 <typ.UInt32> [m]) (Rsh32Ux64 x (Const64 [1]))) (Const64 [s]))))
 13383		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+(umagic(32,c).m+1)/2)) && s == umagic(32,c).s-2 && x.Op != OpConst32 && udivisibleOK(32,c)
 13384		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 13385		for {
 13386			_ = v.Args[1]
 13387			x := v.Args[0]
 13388			v_1 := v.Args[1]
 13389			if v_1.Op != OpMul32 {
 13390				break
 13391			}
 13392			_ = v_1.Args[1]
 13393			v_1_0 := v_1.Args[0]
 13394			if v_1_0.Op != OpConst32 {
 13395				break
 13396			}
 13397			c := v_1_0.AuxInt
 13398			v_1_1 := v_1.Args[1]
 13399			if v_1_1.Op != OpRsh32Ux64 {
 13400				break
 13401			}
 13402			_ = v_1_1.Args[1]
 13403			mul := v_1_1.Args[0]
 13404			if mul.Op != OpHmul32u {
 13405				break
 13406			}
 13407			_ = mul.Args[1]
 13408			mul_0 := mul.Args[0]
 13409			if mul_0.Op != OpConst32 {
 13410				break
 13411			}
 13412			if mul_0.Type != typ.UInt32 {
 13413				break
 13414			}
 13415			m := mul_0.AuxInt
 13416			mul_1 := mul.Args[1]
 13417			if mul_1.Op != OpRsh32Ux64 {
 13418				break
 13419			}
 13420			_ = mul_1.Args[1]
 13421			if x != mul_1.Args[0] {
 13422				break
 13423			}
 13424			mul_1_1 := mul_1.Args[1]
 13425			if mul_1_1.Op != OpConst64 {
 13426				break
 13427			}
 13428			if mul_1_1.AuxInt != 1 {
 13429				break
 13430			}
 13431			v_1_1_1 := v_1_1.Args[1]
 13432			if v_1_1_1.Op != OpConst64 {
 13433				break
 13434			}
 13435			s := v_1_1_1.AuxInt
 13436			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+(umagic(32, c).m+1)/2)) && s == umagic(32, c).s-2 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 13437				break
 13438			}
 13439			v.reset(OpLeq32U)
 13440			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 13441			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 13442			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13443			v2.AuxInt = int64(int32(udivisible(32, c).m))
 13444			v1.AddArg(v2)
 13445			v1.AddArg(x)
 13446			v0.AddArg(v1)
 13447			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13448			v3.AuxInt = int64(32 - udivisible(32, c).k)
 13449			v0.AddArg(v3)
 13450			v.AddArg(v0)
 13451			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13452			v4.AuxInt = int64(int32(udivisible(32, c).max))
 13453			v.AddArg(v4)
 13454			return true
 13455		}
 13456		// match: (Eq32 x (Mul32 (Const32 [c]) (Rsh32Ux64 mul:(Hmul32u (Rsh32Ux64 x (Const64 [1])) (Const32 <typ.UInt32> [m])) (Const64 [s]))))
 13457		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+(umagic(32,c).m+1)/2)) && s == umagic(32,c).s-2 && x.Op != OpConst32 && udivisibleOK(32,c)
 13458		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 13459		for {
 13460			_ = v.Args[1]
 13461			x := v.Args[0]
 13462			v_1 := v.Args[1]
 13463			if v_1.Op != OpMul32 {
 13464				break
 13465			}
 13466			_ = v_1.Args[1]
 13467			v_1_0 := v_1.Args[0]
 13468			if v_1_0.Op != OpConst32 {
 13469				break
 13470			}
 13471			c := v_1_0.AuxInt
 13472			v_1_1 := v_1.Args[1]
 13473			if v_1_1.Op != OpRsh32Ux64 {
 13474				break
 13475			}
 13476			_ = v_1_1.Args[1]
 13477			mul := v_1_1.Args[0]
 13478			if mul.Op != OpHmul32u {
 13479				break
 13480			}
 13481			_ = mul.Args[1]
 13482			mul_0 := mul.Args[0]
 13483			if mul_0.Op != OpRsh32Ux64 {
 13484				break
 13485			}
 13486			_ = mul_0.Args[1]
 13487			if x != mul_0.Args[0] {
 13488				break
 13489			}
 13490			mul_0_1 := mul_0.Args[1]
 13491			if mul_0_1.Op != OpConst64 {
 13492				break
 13493			}
 13494			if mul_0_1.AuxInt != 1 {
 13495				break
 13496			}
 13497			mul_1 := mul.Args[1]
 13498			if mul_1.Op != OpConst32 {
 13499				break
 13500			}
 13501			if mul_1.Type != typ.UInt32 {
 13502				break
 13503			}
 13504			m := mul_1.AuxInt
 13505			v_1_1_1 := v_1_1.Args[1]
 13506			if v_1_1_1.Op != OpConst64 {
 13507				break
 13508			}
 13509			s := v_1_1_1.AuxInt
 13510			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+(umagic(32, c).m+1)/2)) && s == umagic(32, c).s-2 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 13511				break
 13512			}
 13513			v.reset(OpLeq32U)
 13514			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 13515			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 13516			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13517			v2.AuxInt = int64(int32(udivisible(32, c).m))
 13518			v1.AddArg(v2)
 13519			v1.AddArg(x)
 13520			v0.AddArg(v1)
 13521			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13522			v3.AuxInt = int64(32 - udivisible(32, c).k)
 13523			v0.AddArg(v3)
 13524			v.AddArg(v0)
 13525			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13526			v4.AuxInt = int64(int32(udivisible(32, c).max))
 13527			v.AddArg(v4)
 13528			return true
 13529		}
 13530		// match: (Eq32 x (Mul32 (Rsh32Ux64 mul:(Hmul32u (Const32 <typ.UInt32> [m]) (Rsh32Ux64 x (Const64 [1]))) (Const64 [s])) (Const32 [c])))
 13531		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+(umagic(32,c).m+1)/2)) && s == umagic(32,c).s-2 && x.Op != OpConst32 && udivisibleOK(32,c)
 13532		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 13533		for {
 13534			_ = v.Args[1]
 13535			x := v.Args[0]
 13536			v_1 := v.Args[1]
 13537			if v_1.Op != OpMul32 {
 13538				break
 13539			}
 13540			_ = v_1.Args[1]
 13541			v_1_0 := v_1.Args[0]
 13542			if v_1_0.Op != OpRsh32Ux64 {
 13543				break
 13544			}
 13545			_ = v_1_0.Args[1]
 13546			mul := v_1_0.Args[0]
 13547			if mul.Op != OpHmul32u {
 13548				break
 13549			}
 13550			_ = mul.Args[1]
 13551			mul_0 := mul.Args[0]
 13552			if mul_0.Op != OpConst32 {
 13553				break
 13554			}
 13555			if mul_0.Type != typ.UInt32 {
 13556				break
 13557			}
 13558			m := mul_0.AuxInt
 13559			mul_1 := mul.Args[1]
 13560			if mul_1.Op != OpRsh32Ux64 {
 13561				break
 13562			}
 13563			_ = mul_1.Args[1]
 13564			if x != mul_1.Args[0] {
 13565				break
 13566			}
 13567			mul_1_1 := mul_1.Args[1]
 13568			if mul_1_1.Op != OpConst64 {
 13569				break
 13570			}
 13571			if mul_1_1.AuxInt != 1 {
 13572				break
 13573			}
 13574			v_1_0_1 := v_1_0.Args[1]
 13575			if v_1_0_1.Op != OpConst64 {
 13576				break
 13577			}
 13578			s := v_1_0_1.AuxInt
 13579			v_1_1 := v_1.Args[1]
 13580			if v_1_1.Op != OpConst32 {
 13581				break
 13582			}
 13583			c := v_1_1.AuxInt
 13584			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+(umagic(32, c).m+1)/2)) && s == umagic(32, c).s-2 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 13585				break
 13586			}
 13587			v.reset(OpLeq32U)
 13588			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 13589			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 13590			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13591			v2.AuxInt = int64(int32(udivisible(32, c).m))
 13592			v1.AddArg(v2)
 13593			v1.AddArg(x)
 13594			v0.AddArg(v1)
 13595			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13596			v3.AuxInt = int64(32 - udivisible(32, c).k)
 13597			v0.AddArg(v3)
 13598			v.AddArg(v0)
 13599			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13600			v4.AuxInt = int64(int32(udivisible(32, c).max))
 13601			v.AddArg(v4)
 13602			return true
 13603		}
 13604		// match: (Eq32 x (Mul32 (Rsh32Ux64 mul:(Hmul32u (Rsh32Ux64 x (Const64 [1])) (Const32 <typ.UInt32> [m])) (Const64 [s])) (Const32 [c])))
 13605		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+(umagic(32,c).m+1)/2)) && s == umagic(32,c).s-2 && x.Op != OpConst32 && udivisibleOK(32,c)
 13606		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 13607		for {
 13608			_ = v.Args[1]
 13609			x := v.Args[0]
 13610			v_1 := v.Args[1]
 13611			if v_1.Op != OpMul32 {
 13612				break
 13613			}
 13614			_ = v_1.Args[1]
 13615			v_1_0 := v_1.Args[0]
 13616			if v_1_0.Op != OpRsh32Ux64 {
 13617				break
 13618			}
 13619			_ = v_1_0.Args[1]
 13620			mul := v_1_0.Args[0]
 13621			if mul.Op != OpHmul32u {
 13622				break
 13623			}
 13624			_ = mul.Args[1]
 13625			mul_0 := mul.Args[0]
 13626			if mul_0.Op != OpRsh32Ux64 {
 13627				break
 13628			}
 13629			_ = mul_0.Args[1]
 13630			if x != mul_0.Args[0] {
 13631				break
 13632			}
 13633			mul_0_1 := mul_0.Args[1]
 13634			if mul_0_1.Op != OpConst64 {
 13635				break
 13636			}
 13637			if mul_0_1.AuxInt != 1 {
 13638				break
 13639			}
 13640			mul_1 := mul.Args[1]
 13641			if mul_1.Op != OpConst32 {
 13642				break
 13643			}
 13644			if mul_1.Type != typ.UInt32 {
 13645				break
 13646			}
 13647			m := mul_1.AuxInt
 13648			v_1_0_1 := v_1_0.Args[1]
 13649			if v_1_0_1.Op != OpConst64 {
 13650				break
 13651			}
 13652			s := v_1_0_1.AuxInt
 13653			v_1_1 := v_1.Args[1]
 13654			if v_1_1.Op != OpConst32 {
 13655				break
 13656			}
 13657			c := v_1_1.AuxInt
 13658			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+(umagic(32, c).m+1)/2)) && s == umagic(32, c).s-2 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 13659				break
 13660			}
 13661			v.reset(OpLeq32U)
 13662			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 13663			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 13664			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13665			v2.AuxInt = int64(int32(udivisible(32, c).m))
 13666			v1.AddArg(v2)
 13667			v1.AddArg(x)
 13668			v0.AddArg(v1)
 13669			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13670			v3.AuxInt = int64(32 - udivisible(32, c).k)
 13671			v0.AddArg(v3)
 13672			v.AddArg(v0)
 13673			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13674			v4.AuxInt = int64(int32(udivisible(32, c).max))
 13675			v.AddArg(v4)
 13676			return true
 13677		}
 13678		// match: (Eq32 (Mul32 (Const32 [c]) (Rsh32Ux64 mul:(Hmul32u (Const32 <typ.UInt32> [m]) (Rsh32Ux64 x (Const64 [1]))) (Const64 [s]))) x)
 13679		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+(umagic(32,c).m+1)/2)) && s == umagic(32,c).s-2 && x.Op != OpConst32 && udivisibleOK(32,c)
 13680		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 13681		for {
 13682			x := v.Args[1]
 13683			v_0 := v.Args[0]
 13684			if v_0.Op != OpMul32 {
 13685				break
 13686			}
 13687			_ = v_0.Args[1]
 13688			v_0_0 := v_0.Args[0]
 13689			if v_0_0.Op != OpConst32 {
 13690				break
 13691			}
 13692			c := v_0_0.AuxInt
 13693			v_0_1 := v_0.Args[1]
 13694			if v_0_1.Op != OpRsh32Ux64 {
 13695				break
 13696			}
 13697			_ = v_0_1.Args[1]
 13698			mul := v_0_1.Args[0]
 13699			if mul.Op != OpHmul32u {
 13700				break
 13701			}
 13702			_ = mul.Args[1]
 13703			mul_0 := mul.Args[0]
 13704			if mul_0.Op != OpConst32 {
 13705				break
 13706			}
 13707			if mul_0.Type != typ.UInt32 {
 13708				break
 13709			}
 13710			m := mul_0.AuxInt
 13711			mul_1 := mul.Args[1]
 13712			if mul_1.Op != OpRsh32Ux64 {
 13713				break
 13714			}
 13715			_ = mul_1.Args[1]
 13716			if x != mul_1.Args[0] {
 13717				break
 13718			}
 13719			mul_1_1 := mul_1.Args[1]
 13720			if mul_1_1.Op != OpConst64 {
 13721				break
 13722			}
 13723			if mul_1_1.AuxInt != 1 {
 13724				break
 13725			}
 13726			v_0_1_1 := v_0_1.Args[1]
 13727			if v_0_1_1.Op != OpConst64 {
 13728				break
 13729			}
 13730			s := v_0_1_1.AuxInt
 13731			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+(umagic(32, c).m+1)/2)) && s == umagic(32, c).s-2 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 13732				break
 13733			}
 13734			v.reset(OpLeq32U)
 13735			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 13736			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 13737			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13738			v2.AuxInt = int64(int32(udivisible(32, c).m))
 13739			v1.AddArg(v2)
 13740			v1.AddArg(x)
 13741			v0.AddArg(v1)
 13742			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13743			v3.AuxInt = int64(32 - udivisible(32, c).k)
 13744			v0.AddArg(v3)
 13745			v.AddArg(v0)
 13746			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13747			v4.AuxInt = int64(int32(udivisible(32, c).max))
 13748			v.AddArg(v4)
 13749			return true
 13750		}
 13751		return false
 13752	}
 13753	func rewriteValuegeneric_OpEq32_20(v *Value) bool {
 13754		b := v.Block
 13755		typ := &b.Func.Config.Types
 13756		// match: (Eq32 (Mul32 (Const32 [c]) (Rsh32Ux64 mul:(Hmul32u (Rsh32Ux64 x (Const64 [1])) (Const32 <typ.UInt32> [m])) (Const64 [s]))) x)
 13757		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+(umagic(32,c).m+1)/2)) && s == umagic(32,c).s-2 && x.Op != OpConst32 && udivisibleOK(32,c)
 13758		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 13759		for {
 13760			x := v.Args[1]
 13761			v_0 := v.Args[0]
 13762			if v_0.Op != OpMul32 {
 13763				break
 13764			}
 13765			_ = v_0.Args[1]
 13766			v_0_0 := v_0.Args[0]
 13767			if v_0_0.Op != OpConst32 {
 13768				break
 13769			}
 13770			c := v_0_0.AuxInt
 13771			v_0_1 := v_0.Args[1]
 13772			if v_0_1.Op != OpRsh32Ux64 {
 13773				break
 13774			}
 13775			_ = v_0_1.Args[1]
 13776			mul := v_0_1.Args[0]
 13777			if mul.Op != OpHmul32u {
 13778				break
 13779			}
 13780			_ = mul.Args[1]
 13781			mul_0 := mul.Args[0]
 13782			if mul_0.Op != OpRsh32Ux64 {
 13783				break
 13784			}
 13785			_ = mul_0.Args[1]
 13786			if x != mul_0.Args[0] {
 13787				break
 13788			}
 13789			mul_0_1 := mul_0.Args[1]
 13790			if mul_0_1.Op != OpConst64 {
 13791				break
 13792			}
 13793			if mul_0_1.AuxInt != 1 {
 13794				break
 13795			}
 13796			mul_1 := mul.Args[1]
 13797			if mul_1.Op != OpConst32 {
 13798				break
 13799			}
 13800			if mul_1.Type != typ.UInt32 {
 13801				break
 13802			}
 13803			m := mul_1.AuxInt
 13804			v_0_1_1 := v_0_1.Args[1]
 13805			if v_0_1_1.Op != OpConst64 {
 13806				break
 13807			}
 13808			s := v_0_1_1.AuxInt
 13809			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+(umagic(32, c).m+1)/2)) && s == umagic(32, c).s-2 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 13810				break
 13811			}
 13812			v.reset(OpLeq32U)
 13813			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 13814			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 13815			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13816			v2.AuxInt = int64(int32(udivisible(32, c).m))
 13817			v1.AddArg(v2)
 13818			v1.AddArg(x)
 13819			v0.AddArg(v1)
 13820			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13821			v3.AuxInt = int64(32 - udivisible(32, c).k)
 13822			v0.AddArg(v3)
 13823			v.AddArg(v0)
 13824			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13825			v4.AuxInt = int64(int32(udivisible(32, c).max))
 13826			v.AddArg(v4)
 13827			return true
 13828		}
 13829		// match: (Eq32 (Mul32 (Rsh32Ux64 mul:(Hmul32u (Const32 <typ.UInt32> [m]) (Rsh32Ux64 x (Const64 [1]))) (Const64 [s])) (Const32 [c])) x)
 13830		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+(umagic(32,c).m+1)/2)) && s == umagic(32,c).s-2 && x.Op != OpConst32 && udivisibleOK(32,c)
 13831		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 13832		for {
 13833			x := v.Args[1]
 13834			v_0 := v.Args[0]
 13835			if v_0.Op != OpMul32 {
 13836				break
 13837			}
 13838			_ = v_0.Args[1]
 13839			v_0_0 := v_0.Args[0]
 13840			if v_0_0.Op != OpRsh32Ux64 {
 13841				break
 13842			}
 13843			_ = v_0_0.Args[1]
 13844			mul := v_0_0.Args[0]
 13845			if mul.Op != OpHmul32u {
 13846				break
 13847			}
 13848			_ = mul.Args[1]
 13849			mul_0 := mul.Args[0]
 13850			if mul_0.Op != OpConst32 {
 13851				break
 13852			}
 13853			if mul_0.Type != typ.UInt32 {
 13854				break
 13855			}
 13856			m := mul_0.AuxInt
 13857			mul_1 := mul.Args[1]
 13858			if mul_1.Op != OpRsh32Ux64 {
 13859				break
 13860			}
 13861			_ = mul_1.Args[1]
 13862			if x != mul_1.Args[0] {
 13863				break
 13864			}
 13865			mul_1_1 := mul_1.Args[1]
 13866			if mul_1_1.Op != OpConst64 {
 13867				break
 13868			}
 13869			if mul_1_1.AuxInt != 1 {
 13870				break
 13871			}
 13872			v_0_0_1 := v_0_0.Args[1]
 13873			if v_0_0_1.Op != OpConst64 {
 13874				break
 13875			}
 13876			s := v_0_0_1.AuxInt
 13877			v_0_1 := v_0.Args[1]
 13878			if v_0_1.Op != OpConst32 {
 13879				break
 13880			}
 13881			c := v_0_1.AuxInt
 13882			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+(umagic(32, c).m+1)/2)) && s == umagic(32, c).s-2 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 13883				break
 13884			}
 13885			v.reset(OpLeq32U)
 13886			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 13887			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 13888			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13889			v2.AuxInt = int64(int32(udivisible(32, c).m))
 13890			v1.AddArg(v2)
 13891			v1.AddArg(x)
 13892			v0.AddArg(v1)
 13893			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13894			v3.AuxInt = int64(32 - udivisible(32, c).k)
 13895			v0.AddArg(v3)
 13896			v.AddArg(v0)
 13897			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13898			v4.AuxInt = int64(int32(udivisible(32, c).max))
 13899			v.AddArg(v4)
 13900			return true
 13901		}
 13902		// match: (Eq32 (Mul32 (Rsh32Ux64 mul:(Hmul32u (Rsh32Ux64 x (Const64 [1])) (Const32 <typ.UInt32> [m])) (Const64 [s])) (Const32 [c])) x)
 13903		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+(umagic(32,c).m+1)/2)) && s == umagic(32,c).s-2 && x.Op != OpConst32 && udivisibleOK(32,c)
 13904		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 13905		for {
 13906			x := v.Args[1]
 13907			v_0 := v.Args[0]
 13908			if v_0.Op != OpMul32 {
 13909				break
 13910			}
 13911			_ = v_0.Args[1]
 13912			v_0_0 := v_0.Args[0]
 13913			if v_0_0.Op != OpRsh32Ux64 {
 13914				break
 13915			}
 13916			_ = v_0_0.Args[1]
 13917			mul := v_0_0.Args[0]
 13918			if mul.Op != OpHmul32u {
 13919				break
 13920			}
 13921			_ = mul.Args[1]
 13922			mul_0 := mul.Args[0]
 13923			if mul_0.Op != OpRsh32Ux64 {
 13924				break
 13925			}
 13926			_ = mul_0.Args[1]
 13927			if x != mul_0.Args[0] {
 13928				break
 13929			}
 13930			mul_0_1 := mul_0.Args[1]
 13931			if mul_0_1.Op != OpConst64 {
 13932				break
 13933			}
 13934			if mul_0_1.AuxInt != 1 {
 13935				break
 13936			}
 13937			mul_1 := mul.Args[1]
 13938			if mul_1.Op != OpConst32 {
 13939				break
 13940			}
 13941			if mul_1.Type != typ.UInt32 {
 13942				break
 13943			}
 13944			m := mul_1.AuxInt
 13945			v_0_0_1 := v_0_0.Args[1]
 13946			if v_0_0_1.Op != OpConst64 {
 13947				break
 13948			}
 13949			s := v_0_0_1.AuxInt
 13950			v_0_1 := v_0.Args[1]
 13951			if v_0_1.Op != OpConst32 {
 13952				break
 13953			}
 13954			c := v_0_1.AuxInt
 13955			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+(umagic(32, c).m+1)/2)) && s == umagic(32, c).s-2 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 13956				break
 13957			}
 13958			v.reset(OpLeq32U)
 13959			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 13960			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 13961			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13962			v2.AuxInt = int64(int32(udivisible(32, c).m))
 13963			v1.AddArg(v2)
 13964			v1.AddArg(x)
 13965			v0.AddArg(v1)
 13966			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13967			v3.AuxInt = int64(32 - udivisible(32, c).k)
 13968			v0.AddArg(v3)
 13969			v.AddArg(v0)
 13970			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 13971			v4.AuxInt = int64(int32(udivisible(32, c).max))
 13972			v.AddArg(v4)
 13973			return true
 13974		}
 13975		// match: (Eq32 x (Mul32 (Const32 [c]) (Rsh32Ux64 (Avg32u x mul:(Hmul32u (Const32 [m]) x)) (Const64 [s]))))
 13976		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(umagic(32,c).m)) && s == umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c)
 13977		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 13978		for {
 13979			_ = v.Args[1]
 13980			x := v.Args[0]
 13981			v_1 := v.Args[1]
 13982			if v_1.Op != OpMul32 {
 13983				break
 13984			}
 13985			_ = v_1.Args[1]
 13986			v_1_0 := v_1.Args[0]
 13987			if v_1_0.Op != OpConst32 {
 13988				break
 13989			}
 13990			c := v_1_0.AuxInt
 13991			v_1_1 := v_1.Args[1]
 13992			if v_1_1.Op != OpRsh32Ux64 {
 13993				break
 13994			}
 13995			_ = v_1_1.Args[1]
 13996			v_1_1_0 := v_1_1.Args[0]
 13997			if v_1_1_0.Op != OpAvg32u {
 13998				break
 13999			}
 14000			_ = v_1_1_0.Args[1]
 14001			if x != v_1_1_0.Args[0] {
 14002				break
 14003			}
 14004			mul := v_1_1_0.Args[1]
 14005			if mul.Op != OpHmul32u {
 14006				break
 14007			}
 14008			_ = mul.Args[1]
 14009			mul_0 := mul.Args[0]
 14010			if mul_0.Op != OpConst32 {
 14011				break
 14012			}
 14013			m := mul_0.AuxInt
 14014			if x != mul.Args[1] {
 14015				break
 14016			}
 14017			v_1_1_1 := v_1_1.Args[1]
 14018			if v_1_1_1.Op != OpConst64 {
 14019				break
 14020			}
 14021			s := v_1_1_1.AuxInt
 14022			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(umagic(32, c).m)) && s == umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 14023				break
 14024			}
 14025			v.reset(OpLeq32U)
 14026			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 14027			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 14028			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14029			v2.AuxInt = int64(int32(udivisible(32, c).m))
 14030			v1.AddArg(v2)
 14031			v1.AddArg(x)
 14032			v0.AddArg(v1)
 14033			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14034			v3.AuxInt = int64(32 - udivisible(32, c).k)
 14035			v0.AddArg(v3)
 14036			v.AddArg(v0)
 14037			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14038			v4.AuxInt = int64(int32(udivisible(32, c).max))
 14039			v.AddArg(v4)
 14040			return true
 14041		}
 14042		// match: (Eq32 x (Mul32 (Const32 [c]) (Rsh32Ux64 (Avg32u x mul:(Hmul32u x (Const32 [m]))) (Const64 [s]))))
 14043		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(umagic(32,c).m)) && s == umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c)
 14044		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 14045		for {
 14046			_ = v.Args[1]
 14047			x := v.Args[0]
 14048			v_1 := v.Args[1]
 14049			if v_1.Op != OpMul32 {
 14050				break
 14051			}
 14052			_ = v_1.Args[1]
 14053			v_1_0 := v_1.Args[0]
 14054			if v_1_0.Op != OpConst32 {
 14055				break
 14056			}
 14057			c := v_1_0.AuxInt
 14058			v_1_1 := v_1.Args[1]
 14059			if v_1_1.Op != OpRsh32Ux64 {
 14060				break
 14061			}
 14062			_ = v_1_1.Args[1]
 14063			v_1_1_0 := v_1_1.Args[0]
 14064			if v_1_1_0.Op != OpAvg32u {
 14065				break
 14066			}
 14067			_ = v_1_1_0.Args[1]
 14068			if x != v_1_1_0.Args[0] {
 14069				break
 14070			}
 14071			mul := v_1_1_0.Args[1]
 14072			if mul.Op != OpHmul32u {
 14073				break
 14074			}
 14075			_ = mul.Args[1]
 14076			if x != mul.Args[0] {
 14077				break
 14078			}
 14079			mul_1 := mul.Args[1]
 14080			if mul_1.Op != OpConst32 {
 14081				break
 14082			}
 14083			m := mul_1.AuxInt
 14084			v_1_1_1 := v_1_1.Args[1]
 14085			if v_1_1_1.Op != OpConst64 {
 14086				break
 14087			}
 14088			s := v_1_1_1.AuxInt
 14089			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(umagic(32, c).m)) && s == umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 14090				break
 14091			}
 14092			v.reset(OpLeq32U)
 14093			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 14094			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 14095			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14096			v2.AuxInt = int64(int32(udivisible(32, c).m))
 14097			v1.AddArg(v2)
 14098			v1.AddArg(x)
 14099			v0.AddArg(v1)
 14100			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14101			v3.AuxInt = int64(32 - udivisible(32, c).k)
 14102			v0.AddArg(v3)
 14103			v.AddArg(v0)
 14104			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14105			v4.AuxInt = int64(int32(udivisible(32, c).max))
 14106			v.AddArg(v4)
 14107			return true
 14108		}
 14109		// match: (Eq32 x (Mul32 (Rsh32Ux64 (Avg32u x mul:(Hmul32u (Const32 [m]) x)) (Const64 [s])) (Const32 [c])))
 14110		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(umagic(32,c).m)) && s == umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c)
 14111		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 14112		for {
 14113			_ = v.Args[1]
 14114			x := v.Args[0]
 14115			v_1 := v.Args[1]
 14116			if v_1.Op != OpMul32 {
 14117				break
 14118			}
 14119			_ = v_1.Args[1]
 14120			v_1_0 := v_1.Args[0]
 14121			if v_1_0.Op != OpRsh32Ux64 {
 14122				break
 14123			}
 14124			_ = v_1_0.Args[1]
 14125			v_1_0_0 := v_1_0.Args[0]
 14126			if v_1_0_0.Op != OpAvg32u {
 14127				break
 14128			}
 14129			_ = v_1_0_0.Args[1]
 14130			if x != v_1_0_0.Args[0] {
 14131				break
 14132			}
 14133			mul := v_1_0_0.Args[1]
 14134			if mul.Op != OpHmul32u {
 14135				break
 14136			}
 14137			_ = mul.Args[1]
 14138			mul_0 := mul.Args[0]
 14139			if mul_0.Op != OpConst32 {
 14140				break
 14141			}
 14142			m := mul_0.AuxInt
 14143			if x != mul.Args[1] {
 14144				break
 14145			}
 14146			v_1_0_1 := v_1_0.Args[1]
 14147			if v_1_0_1.Op != OpConst64 {
 14148				break
 14149			}
 14150			s := v_1_0_1.AuxInt
 14151			v_1_1 := v_1.Args[1]
 14152			if v_1_1.Op != OpConst32 {
 14153				break
 14154			}
 14155			c := v_1_1.AuxInt
 14156			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(umagic(32, c).m)) && s == umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 14157				break
 14158			}
 14159			v.reset(OpLeq32U)
 14160			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 14161			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 14162			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14163			v2.AuxInt = int64(int32(udivisible(32, c).m))
 14164			v1.AddArg(v2)
 14165			v1.AddArg(x)
 14166			v0.AddArg(v1)
 14167			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14168			v3.AuxInt = int64(32 - udivisible(32, c).k)
 14169			v0.AddArg(v3)
 14170			v.AddArg(v0)
 14171			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14172			v4.AuxInt = int64(int32(udivisible(32, c).max))
 14173			v.AddArg(v4)
 14174			return true
 14175		}
 14176		// match: (Eq32 x (Mul32 (Rsh32Ux64 (Avg32u x mul:(Hmul32u x (Const32 [m]))) (Const64 [s])) (Const32 [c])))
 14177		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(umagic(32,c).m)) && s == umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c)
 14178		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 14179		for {
 14180			_ = v.Args[1]
 14181			x := v.Args[0]
 14182			v_1 := v.Args[1]
 14183			if v_1.Op != OpMul32 {
 14184				break
 14185			}
 14186			_ = v_1.Args[1]
 14187			v_1_0 := v_1.Args[0]
 14188			if v_1_0.Op != OpRsh32Ux64 {
 14189				break
 14190			}
 14191			_ = v_1_0.Args[1]
 14192			v_1_0_0 := v_1_0.Args[0]
 14193			if v_1_0_0.Op != OpAvg32u {
 14194				break
 14195			}
 14196			_ = v_1_0_0.Args[1]
 14197			if x != v_1_0_0.Args[0] {
 14198				break
 14199			}
 14200			mul := v_1_0_0.Args[1]
 14201			if mul.Op != OpHmul32u {
 14202				break
 14203			}
 14204			_ = mul.Args[1]
 14205			if x != mul.Args[0] {
 14206				break
 14207			}
 14208			mul_1 := mul.Args[1]
 14209			if mul_1.Op != OpConst32 {
 14210				break
 14211			}
 14212			m := mul_1.AuxInt
 14213			v_1_0_1 := v_1_0.Args[1]
 14214			if v_1_0_1.Op != OpConst64 {
 14215				break
 14216			}
 14217			s := v_1_0_1.AuxInt
 14218			v_1_1 := v_1.Args[1]
 14219			if v_1_1.Op != OpConst32 {
 14220				break
 14221			}
 14222			c := v_1_1.AuxInt
 14223			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(umagic(32, c).m)) && s == umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 14224				break
 14225			}
 14226			v.reset(OpLeq32U)
 14227			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 14228			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 14229			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14230			v2.AuxInt = int64(int32(udivisible(32, c).m))
 14231			v1.AddArg(v2)
 14232			v1.AddArg(x)
 14233			v0.AddArg(v1)
 14234			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14235			v3.AuxInt = int64(32 - udivisible(32, c).k)
 14236			v0.AddArg(v3)
 14237			v.AddArg(v0)
 14238			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14239			v4.AuxInt = int64(int32(udivisible(32, c).max))
 14240			v.AddArg(v4)
 14241			return true
 14242		}
 14243		// match: (Eq32 (Mul32 (Const32 [c]) (Rsh32Ux64 (Avg32u x mul:(Hmul32u (Const32 [m]) x)) (Const64 [s]))) x)
 14244		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(umagic(32,c).m)) && s == umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c)
 14245		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 14246		for {
 14247			x := v.Args[1]
 14248			v_0 := v.Args[0]
 14249			if v_0.Op != OpMul32 {
 14250				break
 14251			}
 14252			_ = v_0.Args[1]
 14253			v_0_0 := v_0.Args[0]
 14254			if v_0_0.Op != OpConst32 {
 14255				break
 14256			}
 14257			c := v_0_0.AuxInt
 14258			v_0_1 := v_0.Args[1]
 14259			if v_0_1.Op != OpRsh32Ux64 {
 14260				break
 14261			}
 14262			_ = v_0_1.Args[1]
 14263			v_0_1_0 := v_0_1.Args[0]
 14264			if v_0_1_0.Op != OpAvg32u {
 14265				break
 14266			}
 14267			_ = v_0_1_0.Args[1]
 14268			if x != v_0_1_0.Args[0] {
 14269				break
 14270			}
 14271			mul := v_0_1_0.Args[1]
 14272			if mul.Op != OpHmul32u {
 14273				break
 14274			}
 14275			_ = mul.Args[1]
 14276			mul_0 := mul.Args[0]
 14277			if mul_0.Op != OpConst32 {
 14278				break
 14279			}
 14280			m := mul_0.AuxInt
 14281			if x != mul.Args[1] {
 14282				break
 14283			}
 14284			v_0_1_1 := v_0_1.Args[1]
 14285			if v_0_1_1.Op != OpConst64 {
 14286				break
 14287			}
 14288			s := v_0_1_1.AuxInt
 14289			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(umagic(32, c).m)) && s == umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 14290				break
 14291			}
 14292			v.reset(OpLeq32U)
 14293			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 14294			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 14295			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14296			v2.AuxInt = int64(int32(udivisible(32, c).m))
 14297			v1.AddArg(v2)
 14298			v1.AddArg(x)
 14299			v0.AddArg(v1)
 14300			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14301			v3.AuxInt = int64(32 - udivisible(32, c).k)
 14302			v0.AddArg(v3)
 14303			v.AddArg(v0)
 14304			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14305			v4.AuxInt = int64(int32(udivisible(32, c).max))
 14306			v.AddArg(v4)
 14307			return true
 14308		}
 14309		// match: (Eq32 (Mul32 (Const32 [c]) (Rsh32Ux64 (Avg32u x mul:(Hmul32u x (Const32 [m]))) (Const64 [s]))) x)
 14310		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(umagic(32,c).m)) && s == umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c)
 14311		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 14312		for {
 14313			x := v.Args[1]
 14314			v_0 := v.Args[0]
 14315			if v_0.Op != OpMul32 {
 14316				break
 14317			}
 14318			_ = v_0.Args[1]
 14319			v_0_0 := v_0.Args[0]
 14320			if v_0_0.Op != OpConst32 {
 14321				break
 14322			}
 14323			c := v_0_0.AuxInt
 14324			v_0_1 := v_0.Args[1]
 14325			if v_0_1.Op != OpRsh32Ux64 {
 14326				break
 14327			}
 14328			_ = v_0_1.Args[1]
 14329			v_0_1_0 := v_0_1.Args[0]
 14330			if v_0_1_0.Op != OpAvg32u {
 14331				break
 14332			}
 14333			_ = v_0_1_0.Args[1]
 14334			if x != v_0_1_0.Args[0] {
 14335				break
 14336			}
 14337			mul := v_0_1_0.Args[1]
 14338			if mul.Op != OpHmul32u {
 14339				break
 14340			}
 14341			_ = mul.Args[1]
 14342			if x != mul.Args[0] {
 14343				break
 14344			}
 14345			mul_1 := mul.Args[1]
 14346			if mul_1.Op != OpConst32 {
 14347				break
 14348			}
 14349			m := mul_1.AuxInt
 14350			v_0_1_1 := v_0_1.Args[1]
 14351			if v_0_1_1.Op != OpConst64 {
 14352				break
 14353			}
 14354			s := v_0_1_1.AuxInt
 14355			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(umagic(32, c).m)) && s == umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 14356				break
 14357			}
 14358			v.reset(OpLeq32U)
 14359			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 14360			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 14361			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14362			v2.AuxInt = int64(int32(udivisible(32, c).m))
 14363			v1.AddArg(v2)
 14364			v1.AddArg(x)
 14365			v0.AddArg(v1)
 14366			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14367			v3.AuxInt = int64(32 - udivisible(32, c).k)
 14368			v0.AddArg(v3)
 14369			v.AddArg(v0)
 14370			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14371			v4.AuxInt = int64(int32(udivisible(32, c).max))
 14372			v.AddArg(v4)
 14373			return true
 14374		}
 14375		// match: (Eq32 (Mul32 (Rsh32Ux64 (Avg32u x mul:(Hmul32u (Const32 [m]) x)) (Const64 [s])) (Const32 [c])) x)
 14376		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(umagic(32,c).m)) && s == umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c)
 14377		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 14378		for {
 14379			x := v.Args[1]
 14380			v_0 := v.Args[0]
 14381			if v_0.Op != OpMul32 {
 14382				break
 14383			}
 14384			_ = v_0.Args[1]
 14385			v_0_0 := v_0.Args[0]
 14386			if v_0_0.Op != OpRsh32Ux64 {
 14387				break
 14388			}
 14389			_ = v_0_0.Args[1]
 14390			v_0_0_0 := v_0_0.Args[0]
 14391			if v_0_0_0.Op != OpAvg32u {
 14392				break
 14393			}
 14394			_ = v_0_0_0.Args[1]
 14395			if x != v_0_0_0.Args[0] {
 14396				break
 14397			}
 14398			mul := v_0_0_0.Args[1]
 14399			if mul.Op != OpHmul32u {
 14400				break
 14401			}
 14402			_ = mul.Args[1]
 14403			mul_0 := mul.Args[0]
 14404			if mul_0.Op != OpConst32 {
 14405				break
 14406			}
 14407			m := mul_0.AuxInt
 14408			if x != mul.Args[1] {
 14409				break
 14410			}
 14411			v_0_0_1 := v_0_0.Args[1]
 14412			if v_0_0_1.Op != OpConst64 {
 14413				break
 14414			}
 14415			s := v_0_0_1.AuxInt
 14416			v_0_1 := v_0.Args[1]
 14417			if v_0_1.Op != OpConst32 {
 14418				break
 14419			}
 14420			c := v_0_1.AuxInt
 14421			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(umagic(32, c).m)) && s == umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 14422				break
 14423			}
 14424			v.reset(OpLeq32U)
 14425			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 14426			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 14427			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14428			v2.AuxInt = int64(int32(udivisible(32, c).m))
 14429			v1.AddArg(v2)
 14430			v1.AddArg(x)
 14431			v0.AddArg(v1)
 14432			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14433			v3.AuxInt = int64(32 - udivisible(32, c).k)
 14434			v0.AddArg(v3)
 14435			v.AddArg(v0)
 14436			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14437			v4.AuxInt = int64(int32(udivisible(32, c).max))
 14438			v.AddArg(v4)
 14439			return true
 14440		}
 14441		return false
 14442	}
 14443	func rewriteValuegeneric_OpEq32_30(v *Value) bool {
 14444		b := v.Block
 14445		typ := &b.Func.Config.Types
 14446		// match: (Eq32 (Mul32 (Rsh32Ux64 (Avg32u x mul:(Hmul32u x (Const32 [m]))) (Const64 [s])) (Const32 [c])) x)
 14447		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(umagic(32,c).m)) && s == umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c)
 14448		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 14449		for {
 14450			x := v.Args[1]
 14451			v_0 := v.Args[0]
 14452			if v_0.Op != OpMul32 {
 14453				break
 14454			}
 14455			_ = v_0.Args[1]
 14456			v_0_0 := v_0.Args[0]
 14457			if v_0_0.Op != OpRsh32Ux64 {
 14458				break
 14459			}
 14460			_ = v_0_0.Args[1]
 14461			v_0_0_0 := v_0_0.Args[0]
 14462			if v_0_0_0.Op != OpAvg32u {
 14463				break
 14464			}
 14465			_ = v_0_0_0.Args[1]
 14466			if x != v_0_0_0.Args[0] {
 14467				break
 14468			}
 14469			mul := v_0_0_0.Args[1]
 14470			if mul.Op != OpHmul32u {
 14471				break
 14472			}
 14473			_ = mul.Args[1]
 14474			if x != mul.Args[0] {
 14475				break
 14476			}
 14477			mul_1 := mul.Args[1]
 14478			if mul_1.Op != OpConst32 {
 14479				break
 14480			}
 14481			m := mul_1.AuxInt
 14482			v_0_0_1 := v_0_0.Args[1]
 14483			if v_0_0_1.Op != OpConst64 {
 14484				break
 14485			}
 14486			s := v_0_0_1.AuxInt
 14487			v_0_1 := v_0.Args[1]
 14488			if v_0_1.Op != OpConst32 {
 14489				break
 14490			}
 14491			c := v_0_1.AuxInt
 14492			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(umagic(32, c).m)) && s == umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 14493				break
 14494			}
 14495			v.reset(OpLeq32U)
 14496			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 14497			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 14498			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14499			v2.AuxInt = int64(int32(udivisible(32, c).m))
 14500			v1.AddArg(v2)
 14501			v1.AddArg(x)
 14502			v0.AddArg(v1)
 14503			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14504			v3.AuxInt = int64(32 - udivisible(32, c).k)
 14505			v0.AddArg(v3)
 14506			v.AddArg(v0)
 14507			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14508			v4.AuxInt = int64(int32(udivisible(32, c).max))
 14509			v.AddArg(v4)
 14510			return true
 14511		}
 14512		// match: (Eq32 x (Mul32 (Const32 [c]) (Trunc64to32 (Rsh64Ux64 mul:(Mul64 (Const64 [m]) (ZeroExt32to64 x)) (Const64 [s])))))
 14513		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+umagic(32,c).m/2) && s == 32+umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c)
 14514		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 14515		for {
 14516			_ = v.Args[1]
 14517			x := v.Args[0]
 14518			v_1 := v.Args[1]
 14519			if v_1.Op != OpMul32 {
 14520				break
 14521			}
 14522			_ = v_1.Args[1]
 14523			v_1_0 := v_1.Args[0]
 14524			if v_1_0.Op != OpConst32 {
 14525				break
 14526			}
 14527			c := v_1_0.AuxInt
 14528			v_1_1 := v_1.Args[1]
 14529			if v_1_1.Op != OpTrunc64to32 {
 14530				break
 14531			}
 14532			v_1_1_0 := v_1_1.Args[0]
 14533			if v_1_1_0.Op != OpRsh64Ux64 {
 14534				break
 14535			}
 14536			_ = v_1_1_0.Args[1]
 14537			mul := v_1_1_0.Args[0]
 14538			if mul.Op != OpMul64 {
 14539				break
 14540			}
 14541			_ = mul.Args[1]
 14542			mul_0 := mul.Args[0]
 14543			if mul_0.Op != OpConst64 {
 14544				break
 14545			}
 14546			m := mul_0.AuxInt
 14547			mul_1 := mul.Args[1]
 14548			if mul_1.Op != OpZeroExt32to64 {
 14549				break
 14550			}
 14551			if x != mul_1.Args[0] {
 14552				break
 14553			}
 14554			v_1_1_0_1 := v_1_1_0.Args[1]
 14555			if v_1_1_0_1.Op != OpConst64 {
 14556				break
 14557			}
 14558			s := v_1_1_0_1.AuxInt
 14559			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+umagic(32, c).m/2) && s == 32+umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 14560				break
 14561			}
 14562			v.reset(OpLeq32U)
 14563			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 14564			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 14565			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14566			v2.AuxInt = int64(int32(udivisible(32, c).m))
 14567			v1.AddArg(v2)
 14568			v1.AddArg(x)
 14569			v0.AddArg(v1)
 14570			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14571			v3.AuxInt = int64(32 - udivisible(32, c).k)
 14572			v0.AddArg(v3)
 14573			v.AddArg(v0)
 14574			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14575			v4.AuxInt = int64(int32(udivisible(32, c).max))
 14576			v.AddArg(v4)
 14577			return true
 14578		}
 14579		// match: (Eq32 x (Mul32 (Const32 [c]) (Trunc64to32 (Rsh64Ux64 mul:(Mul64 (ZeroExt32to64 x) (Const64 [m])) (Const64 [s])))))
 14580		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+umagic(32,c).m/2) && s == 32+umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c)
 14581		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 14582		for {
 14583			_ = v.Args[1]
 14584			x := v.Args[0]
 14585			v_1 := v.Args[1]
 14586			if v_1.Op != OpMul32 {
 14587				break
 14588			}
 14589			_ = v_1.Args[1]
 14590			v_1_0 := v_1.Args[0]
 14591			if v_1_0.Op != OpConst32 {
 14592				break
 14593			}
 14594			c := v_1_0.AuxInt
 14595			v_1_1 := v_1.Args[1]
 14596			if v_1_1.Op != OpTrunc64to32 {
 14597				break
 14598			}
 14599			v_1_1_0 := v_1_1.Args[0]
 14600			if v_1_1_0.Op != OpRsh64Ux64 {
 14601				break
 14602			}
 14603			_ = v_1_1_0.Args[1]
 14604			mul := v_1_1_0.Args[0]
 14605			if mul.Op != OpMul64 {
 14606				break
 14607			}
 14608			_ = mul.Args[1]
 14609			mul_0 := mul.Args[0]
 14610			if mul_0.Op != OpZeroExt32to64 {
 14611				break
 14612			}
 14613			if x != mul_0.Args[0] {
 14614				break
 14615			}
 14616			mul_1 := mul.Args[1]
 14617			if mul_1.Op != OpConst64 {
 14618				break
 14619			}
 14620			m := mul_1.AuxInt
 14621			v_1_1_0_1 := v_1_1_0.Args[1]
 14622			if v_1_1_0_1.Op != OpConst64 {
 14623				break
 14624			}
 14625			s := v_1_1_0_1.AuxInt
 14626			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+umagic(32, c).m/2) && s == 32+umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 14627				break
 14628			}
 14629			v.reset(OpLeq32U)
 14630			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 14631			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 14632			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14633			v2.AuxInt = int64(int32(udivisible(32, c).m))
 14634			v1.AddArg(v2)
 14635			v1.AddArg(x)
 14636			v0.AddArg(v1)
 14637			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14638			v3.AuxInt = int64(32 - udivisible(32, c).k)
 14639			v0.AddArg(v3)
 14640			v.AddArg(v0)
 14641			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14642			v4.AuxInt = int64(int32(udivisible(32, c).max))
 14643			v.AddArg(v4)
 14644			return true
 14645		}
 14646		// match: (Eq32 x (Mul32 (Trunc64to32 (Rsh64Ux64 mul:(Mul64 (Const64 [m]) (ZeroExt32to64 x)) (Const64 [s]))) (Const32 [c])))
 14647		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+umagic(32,c).m/2) && s == 32+umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c)
 14648		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 14649		for {
 14650			_ = v.Args[1]
 14651			x := v.Args[0]
 14652			v_1 := v.Args[1]
 14653			if v_1.Op != OpMul32 {
 14654				break
 14655			}
 14656			_ = v_1.Args[1]
 14657			v_1_0 := v_1.Args[0]
 14658			if v_1_0.Op != OpTrunc64to32 {
 14659				break
 14660			}
 14661			v_1_0_0 := v_1_0.Args[0]
 14662			if v_1_0_0.Op != OpRsh64Ux64 {
 14663				break
 14664			}
 14665			_ = v_1_0_0.Args[1]
 14666			mul := v_1_0_0.Args[0]
 14667			if mul.Op != OpMul64 {
 14668				break
 14669			}
 14670			_ = mul.Args[1]
 14671			mul_0 := mul.Args[0]
 14672			if mul_0.Op != OpConst64 {
 14673				break
 14674			}
 14675			m := mul_0.AuxInt
 14676			mul_1 := mul.Args[1]
 14677			if mul_1.Op != OpZeroExt32to64 {
 14678				break
 14679			}
 14680			if x != mul_1.Args[0] {
 14681				break
 14682			}
 14683			v_1_0_0_1 := v_1_0_0.Args[1]
 14684			if v_1_0_0_1.Op != OpConst64 {
 14685				break
 14686			}
 14687			s := v_1_0_0_1.AuxInt
 14688			v_1_1 := v_1.Args[1]
 14689			if v_1_1.Op != OpConst32 {
 14690				break
 14691			}
 14692			c := v_1_1.AuxInt
 14693			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+umagic(32, c).m/2) && s == 32+umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 14694				break
 14695			}
 14696			v.reset(OpLeq32U)
 14697			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 14698			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 14699			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14700			v2.AuxInt = int64(int32(udivisible(32, c).m))
 14701			v1.AddArg(v2)
 14702			v1.AddArg(x)
 14703			v0.AddArg(v1)
 14704			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14705			v3.AuxInt = int64(32 - udivisible(32, c).k)
 14706			v0.AddArg(v3)
 14707			v.AddArg(v0)
 14708			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14709			v4.AuxInt = int64(int32(udivisible(32, c).max))
 14710			v.AddArg(v4)
 14711			return true
 14712		}
 14713		// match: (Eq32 x (Mul32 (Trunc64to32 (Rsh64Ux64 mul:(Mul64 (ZeroExt32to64 x) (Const64 [m])) (Const64 [s]))) (Const32 [c])))
 14714		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+umagic(32,c).m/2) && s == 32+umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c)
 14715		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 14716		for {
 14717			_ = v.Args[1]
 14718			x := v.Args[0]
 14719			v_1 := v.Args[1]
 14720			if v_1.Op != OpMul32 {
 14721				break
 14722			}
 14723			_ = v_1.Args[1]
 14724			v_1_0 := v_1.Args[0]
 14725			if v_1_0.Op != OpTrunc64to32 {
 14726				break
 14727			}
 14728			v_1_0_0 := v_1_0.Args[0]
 14729			if v_1_0_0.Op != OpRsh64Ux64 {
 14730				break
 14731			}
 14732			_ = v_1_0_0.Args[1]
 14733			mul := v_1_0_0.Args[0]
 14734			if mul.Op != OpMul64 {
 14735				break
 14736			}
 14737			_ = mul.Args[1]
 14738			mul_0 := mul.Args[0]
 14739			if mul_0.Op != OpZeroExt32to64 {
 14740				break
 14741			}
 14742			if x != mul_0.Args[0] {
 14743				break
 14744			}
 14745			mul_1 := mul.Args[1]
 14746			if mul_1.Op != OpConst64 {
 14747				break
 14748			}
 14749			m := mul_1.AuxInt
 14750			v_1_0_0_1 := v_1_0_0.Args[1]
 14751			if v_1_0_0_1.Op != OpConst64 {
 14752				break
 14753			}
 14754			s := v_1_0_0_1.AuxInt
 14755			v_1_1 := v_1.Args[1]
 14756			if v_1_1.Op != OpConst32 {
 14757				break
 14758			}
 14759			c := v_1_1.AuxInt
 14760			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+umagic(32, c).m/2) && s == 32+umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 14761				break
 14762			}
 14763			v.reset(OpLeq32U)
 14764			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 14765			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 14766			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14767			v2.AuxInt = int64(int32(udivisible(32, c).m))
 14768			v1.AddArg(v2)
 14769			v1.AddArg(x)
 14770			v0.AddArg(v1)
 14771			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14772			v3.AuxInt = int64(32 - udivisible(32, c).k)
 14773			v0.AddArg(v3)
 14774			v.AddArg(v0)
 14775			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14776			v4.AuxInt = int64(int32(udivisible(32, c).max))
 14777			v.AddArg(v4)
 14778			return true
 14779		}
 14780		// match: (Eq32 (Mul32 (Const32 [c]) (Trunc64to32 (Rsh64Ux64 mul:(Mul64 (Const64 [m]) (ZeroExt32to64 x)) (Const64 [s])))) x)
 14781		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+umagic(32,c).m/2) && s == 32+umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c)
 14782		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 14783		for {
 14784			x := v.Args[1]
 14785			v_0 := v.Args[0]
 14786			if v_0.Op != OpMul32 {
 14787				break
 14788			}
 14789			_ = v_0.Args[1]
 14790			v_0_0 := v_0.Args[0]
 14791			if v_0_0.Op != OpConst32 {
 14792				break
 14793			}
 14794			c := v_0_0.AuxInt
 14795			v_0_1 := v_0.Args[1]
 14796			if v_0_1.Op != OpTrunc64to32 {
 14797				break
 14798			}
 14799			v_0_1_0 := v_0_1.Args[0]
 14800			if v_0_1_0.Op != OpRsh64Ux64 {
 14801				break
 14802			}
 14803			_ = v_0_1_0.Args[1]
 14804			mul := v_0_1_0.Args[0]
 14805			if mul.Op != OpMul64 {
 14806				break
 14807			}
 14808			_ = mul.Args[1]
 14809			mul_0 := mul.Args[0]
 14810			if mul_0.Op != OpConst64 {
 14811				break
 14812			}
 14813			m := mul_0.AuxInt
 14814			mul_1 := mul.Args[1]
 14815			if mul_1.Op != OpZeroExt32to64 {
 14816				break
 14817			}
 14818			if x != mul_1.Args[0] {
 14819				break
 14820			}
 14821			v_0_1_0_1 := v_0_1_0.Args[1]
 14822			if v_0_1_0_1.Op != OpConst64 {
 14823				break
 14824			}
 14825			s := v_0_1_0_1.AuxInt
 14826			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+umagic(32, c).m/2) && s == 32+umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 14827				break
 14828			}
 14829			v.reset(OpLeq32U)
 14830			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 14831			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 14832			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14833			v2.AuxInt = int64(int32(udivisible(32, c).m))
 14834			v1.AddArg(v2)
 14835			v1.AddArg(x)
 14836			v0.AddArg(v1)
 14837			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14838			v3.AuxInt = int64(32 - udivisible(32, c).k)
 14839			v0.AddArg(v3)
 14840			v.AddArg(v0)
 14841			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14842			v4.AuxInt = int64(int32(udivisible(32, c).max))
 14843			v.AddArg(v4)
 14844			return true
 14845		}
 14846		// match: (Eq32 (Mul32 (Const32 [c]) (Trunc64to32 (Rsh64Ux64 mul:(Mul64 (ZeroExt32to64 x) (Const64 [m])) (Const64 [s])))) x)
 14847		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+umagic(32,c).m/2) && s == 32+umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c)
 14848		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 14849		for {
 14850			x := v.Args[1]
 14851			v_0 := v.Args[0]
 14852			if v_0.Op != OpMul32 {
 14853				break
 14854			}
 14855			_ = v_0.Args[1]
 14856			v_0_0 := v_0.Args[0]
 14857			if v_0_0.Op != OpConst32 {
 14858				break
 14859			}
 14860			c := v_0_0.AuxInt
 14861			v_0_1 := v_0.Args[1]
 14862			if v_0_1.Op != OpTrunc64to32 {
 14863				break
 14864			}
 14865			v_0_1_0 := v_0_1.Args[0]
 14866			if v_0_1_0.Op != OpRsh64Ux64 {
 14867				break
 14868			}
 14869			_ = v_0_1_0.Args[1]
 14870			mul := v_0_1_0.Args[0]
 14871			if mul.Op != OpMul64 {
 14872				break
 14873			}
 14874			_ = mul.Args[1]
 14875			mul_0 := mul.Args[0]
 14876			if mul_0.Op != OpZeroExt32to64 {
 14877				break
 14878			}
 14879			if x != mul_0.Args[0] {
 14880				break
 14881			}
 14882			mul_1 := mul.Args[1]
 14883			if mul_1.Op != OpConst64 {
 14884				break
 14885			}
 14886			m := mul_1.AuxInt
 14887			v_0_1_0_1 := v_0_1_0.Args[1]
 14888			if v_0_1_0_1.Op != OpConst64 {
 14889				break
 14890			}
 14891			s := v_0_1_0_1.AuxInt
 14892			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+umagic(32, c).m/2) && s == 32+umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 14893				break
 14894			}
 14895			v.reset(OpLeq32U)
 14896			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 14897			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 14898			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14899			v2.AuxInt = int64(int32(udivisible(32, c).m))
 14900			v1.AddArg(v2)
 14901			v1.AddArg(x)
 14902			v0.AddArg(v1)
 14903			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14904			v3.AuxInt = int64(32 - udivisible(32, c).k)
 14905			v0.AddArg(v3)
 14906			v.AddArg(v0)
 14907			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14908			v4.AuxInt = int64(int32(udivisible(32, c).max))
 14909			v.AddArg(v4)
 14910			return true
 14911		}
 14912		// match: (Eq32 (Mul32 (Trunc64to32 (Rsh64Ux64 mul:(Mul64 (Const64 [m]) (ZeroExt32to64 x)) (Const64 [s]))) (Const32 [c])) x)
 14913		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+umagic(32,c).m/2) && s == 32+umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c)
 14914		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 14915		for {
 14916			x := v.Args[1]
 14917			v_0 := v.Args[0]
 14918			if v_0.Op != OpMul32 {
 14919				break
 14920			}
 14921			_ = v_0.Args[1]
 14922			v_0_0 := v_0.Args[0]
 14923			if v_0_0.Op != OpTrunc64to32 {
 14924				break
 14925			}
 14926			v_0_0_0 := v_0_0.Args[0]
 14927			if v_0_0_0.Op != OpRsh64Ux64 {
 14928				break
 14929			}
 14930			_ = v_0_0_0.Args[1]
 14931			mul := v_0_0_0.Args[0]
 14932			if mul.Op != OpMul64 {
 14933				break
 14934			}
 14935			_ = mul.Args[1]
 14936			mul_0 := mul.Args[0]
 14937			if mul_0.Op != OpConst64 {
 14938				break
 14939			}
 14940			m := mul_0.AuxInt
 14941			mul_1 := mul.Args[1]
 14942			if mul_1.Op != OpZeroExt32to64 {
 14943				break
 14944			}
 14945			if x != mul_1.Args[0] {
 14946				break
 14947			}
 14948			v_0_0_0_1 := v_0_0_0.Args[1]
 14949			if v_0_0_0_1.Op != OpConst64 {
 14950				break
 14951			}
 14952			s := v_0_0_0_1.AuxInt
 14953			v_0_1 := v_0.Args[1]
 14954			if v_0_1.Op != OpConst32 {
 14955				break
 14956			}
 14957			c := v_0_1.AuxInt
 14958			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+umagic(32, c).m/2) && s == 32+umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 14959				break
 14960			}
 14961			v.reset(OpLeq32U)
 14962			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 14963			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 14964			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14965			v2.AuxInt = int64(int32(udivisible(32, c).m))
 14966			v1.AddArg(v2)
 14967			v1.AddArg(x)
 14968			v0.AddArg(v1)
 14969			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14970			v3.AuxInt = int64(32 - udivisible(32, c).k)
 14971			v0.AddArg(v3)
 14972			v.AddArg(v0)
 14973			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 14974			v4.AuxInt = int64(int32(udivisible(32, c).max))
 14975			v.AddArg(v4)
 14976			return true
 14977		}
 14978		// match: (Eq32 (Mul32 (Trunc64to32 (Rsh64Ux64 mul:(Mul64 (ZeroExt32to64 x) (Const64 [m])) (Const64 [s]))) (Const32 [c])) x)
 14979		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+umagic(32,c).m/2) && s == 32+umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c)
 14980		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 14981		for {
 14982			x := v.Args[1]
 14983			v_0 := v.Args[0]
 14984			if v_0.Op != OpMul32 {
 14985				break
 14986			}
 14987			_ = v_0.Args[1]
 14988			v_0_0 := v_0.Args[0]
 14989			if v_0_0.Op != OpTrunc64to32 {
 14990				break
 14991			}
 14992			v_0_0_0 := v_0_0.Args[0]
 14993			if v_0_0_0.Op != OpRsh64Ux64 {
 14994				break
 14995			}
 14996			_ = v_0_0_0.Args[1]
 14997			mul := v_0_0_0.Args[0]
 14998			if mul.Op != OpMul64 {
 14999				break
 15000			}
 15001			_ = mul.Args[1]
 15002			mul_0 := mul.Args[0]
 15003			if mul_0.Op != OpZeroExt32to64 {
 15004				break
 15005			}
 15006			if x != mul_0.Args[0] {
 15007				break
 15008			}
 15009			mul_1 := mul.Args[1]
 15010			if mul_1.Op != OpConst64 {
 15011				break
 15012			}
 15013			m := mul_1.AuxInt
 15014			v_0_0_0_1 := v_0_0_0.Args[1]
 15015			if v_0_0_0_1.Op != OpConst64 {
 15016				break
 15017			}
 15018			s := v_0_0_0_1.AuxInt
 15019			v_0_1 := v_0.Args[1]
 15020			if v_0_1.Op != OpConst32 {
 15021				break
 15022			}
 15023			c := v_0_1.AuxInt
 15024			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+umagic(32, c).m/2) && s == 32+umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 15025				break
 15026			}
 15027			v.reset(OpLeq32U)
 15028			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 15029			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 15030			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15031			v2.AuxInt = int64(int32(udivisible(32, c).m))
 15032			v1.AddArg(v2)
 15033			v1.AddArg(x)
 15034			v0.AddArg(v1)
 15035			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15036			v3.AuxInt = int64(32 - udivisible(32, c).k)
 15037			v0.AddArg(v3)
 15038			v.AddArg(v0)
 15039			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15040			v4.AuxInt = int64(int32(udivisible(32, c).max))
 15041			v.AddArg(v4)
 15042			return true
 15043		}
 15044		// match: (Eq32 x (Mul32 (Const32 [c]) (Trunc64to32 (Rsh64Ux64 mul:(Mul64 (Const64 [m]) (Rsh64Ux64 (ZeroExt32to64 x) (Const64 [1]))) (Const64 [s])))))
 15045		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+(umagic(32,c).m+1)/2) && s == 32+umagic(32,c).s-2 && x.Op != OpConst32 && udivisibleOK(32,c)
 15046		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 15047		for {
 15048			_ = v.Args[1]
 15049			x := v.Args[0]
 15050			v_1 := v.Args[1]
 15051			if v_1.Op != OpMul32 {
 15052				break
 15053			}
 15054			_ = v_1.Args[1]
 15055			v_1_0 := v_1.Args[0]
 15056			if v_1_0.Op != OpConst32 {
 15057				break
 15058			}
 15059			c := v_1_0.AuxInt
 15060			v_1_1 := v_1.Args[1]
 15061			if v_1_1.Op != OpTrunc64to32 {
 15062				break
 15063			}
 15064			v_1_1_0 := v_1_1.Args[0]
 15065			if v_1_1_0.Op != OpRsh64Ux64 {
 15066				break
 15067			}
 15068			_ = v_1_1_0.Args[1]
 15069			mul := v_1_1_0.Args[0]
 15070			if mul.Op != OpMul64 {
 15071				break
 15072			}
 15073			_ = mul.Args[1]
 15074			mul_0 := mul.Args[0]
 15075			if mul_0.Op != OpConst64 {
 15076				break
 15077			}
 15078			m := mul_0.AuxInt
 15079			mul_1 := mul.Args[1]
 15080			if mul_1.Op != OpRsh64Ux64 {
 15081				break
 15082			}
 15083			_ = mul_1.Args[1]
 15084			mul_1_0 := mul_1.Args[0]
 15085			if mul_1_0.Op != OpZeroExt32to64 {
 15086				break
 15087			}
 15088			if x != mul_1_0.Args[0] {
 15089				break
 15090			}
 15091			mul_1_1 := mul_1.Args[1]
 15092			if mul_1_1.Op != OpConst64 {
 15093				break
 15094			}
 15095			if mul_1_1.AuxInt != 1 {
 15096				break
 15097			}
 15098			v_1_1_0_1 := v_1_1_0.Args[1]
 15099			if v_1_1_0_1.Op != OpConst64 {
 15100				break
 15101			}
 15102			s := v_1_1_0_1.AuxInt
 15103			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+(umagic(32, c).m+1)/2) && s == 32+umagic(32, c).s-2 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 15104				break
 15105			}
 15106			v.reset(OpLeq32U)
 15107			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 15108			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 15109			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15110			v2.AuxInt = int64(int32(udivisible(32, c).m))
 15111			v1.AddArg(v2)
 15112			v1.AddArg(x)
 15113			v0.AddArg(v1)
 15114			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15115			v3.AuxInt = int64(32 - udivisible(32, c).k)
 15116			v0.AddArg(v3)
 15117			v.AddArg(v0)
 15118			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15119			v4.AuxInt = int64(int32(udivisible(32, c).max))
 15120			v.AddArg(v4)
 15121			return true
 15122		}
 15123		return false
 15124	}
 15125	func rewriteValuegeneric_OpEq32_40(v *Value) bool {
 15126		b := v.Block
 15127		typ := &b.Func.Config.Types
 15128		// match: (Eq32 x (Mul32 (Const32 [c]) (Trunc64to32 (Rsh64Ux64 mul:(Mul64 (Rsh64Ux64 (ZeroExt32to64 x) (Const64 [1])) (Const64 [m])) (Const64 [s])))))
 15129		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+(umagic(32,c).m+1)/2) && s == 32+umagic(32,c).s-2 && x.Op != OpConst32 && udivisibleOK(32,c)
 15130		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 15131		for {
 15132			_ = v.Args[1]
 15133			x := v.Args[0]
 15134			v_1 := v.Args[1]
 15135			if v_1.Op != OpMul32 {
 15136				break
 15137			}
 15138			_ = v_1.Args[1]
 15139			v_1_0 := v_1.Args[0]
 15140			if v_1_0.Op != OpConst32 {
 15141				break
 15142			}
 15143			c := v_1_0.AuxInt
 15144			v_1_1 := v_1.Args[1]
 15145			if v_1_1.Op != OpTrunc64to32 {
 15146				break
 15147			}
 15148			v_1_1_0 := v_1_1.Args[0]
 15149			if v_1_1_0.Op != OpRsh64Ux64 {
 15150				break
 15151			}
 15152			_ = v_1_1_0.Args[1]
 15153			mul := v_1_1_0.Args[0]
 15154			if mul.Op != OpMul64 {
 15155				break
 15156			}
 15157			_ = mul.Args[1]
 15158			mul_0 := mul.Args[0]
 15159			if mul_0.Op != OpRsh64Ux64 {
 15160				break
 15161			}
 15162			_ = mul_0.Args[1]
 15163			mul_0_0 := mul_0.Args[0]
 15164			if mul_0_0.Op != OpZeroExt32to64 {
 15165				break
 15166			}
 15167			if x != mul_0_0.Args[0] {
 15168				break
 15169			}
 15170			mul_0_1 := mul_0.Args[1]
 15171			if mul_0_1.Op != OpConst64 {
 15172				break
 15173			}
 15174			if mul_0_1.AuxInt != 1 {
 15175				break
 15176			}
 15177			mul_1 := mul.Args[1]
 15178			if mul_1.Op != OpConst64 {
 15179				break
 15180			}
 15181			m := mul_1.AuxInt
 15182			v_1_1_0_1 := v_1_1_0.Args[1]
 15183			if v_1_1_0_1.Op != OpConst64 {
 15184				break
 15185			}
 15186			s := v_1_1_0_1.AuxInt
 15187			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+(umagic(32, c).m+1)/2) && s == 32+umagic(32, c).s-2 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 15188				break
 15189			}
 15190			v.reset(OpLeq32U)
 15191			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 15192			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 15193			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15194			v2.AuxInt = int64(int32(udivisible(32, c).m))
 15195			v1.AddArg(v2)
 15196			v1.AddArg(x)
 15197			v0.AddArg(v1)
 15198			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15199			v3.AuxInt = int64(32 - udivisible(32, c).k)
 15200			v0.AddArg(v3)
 15201			v.AddArg(v0)
 15202			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15203			v4.AuxInt = int64(int32(udivisible(32, c).max))
 15204			v.AddArg(v4)
 15205			return true
 15206		}
 15207		// match: (Eq32 x (Mul32 (Trunc64to32 (Rsh64Ux64 mul:(Mul64 (Const64 [m]) (Rsh64Ux64 (ZeroExt32to64 x) (Const64 [1]))) (Const64 [s]))) (Const32 [c])))
 15208		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+(umagic(32,c).m+1)/2) && s == 32+umagic(32,c).s-2 && x.Op != OpConst32 && udivisibleOK(32,c)
 15209		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 15210		for {
 15211			_ = v.Args[1]
 15212			x := v.Args[0]
 15213			v_1 := v.Args[1]
 15214			if v_1.Op != OpMul32 {
 15215				break
 15216			}
 15217			_ = v_1.Args[1]
 15218			v_1_0 := v_1.Args[0]
 15219			if v_1_0.Op != OpTrunc64to32 {
 15220				break
 15221			}
 15222			v_1_0_0 := v_1_0.Args[0]
 15223			if v_1_0_0.Op != OpRsh64Ux64 {
 15224				break
 15225			}
 15226			_ = v_1_0_0.Args[1]
 15227			mul := v_1_0_0.Args[0]
 15228			if mul.Op != OpMul64 {
 15229				break
 15230			}
 15231			_ = mul.Args[1]
 15232			mul_0 := mul.Args[0]
 15233			if mul_0.Op != OpConst64 {
 15234				break
 15235			}
 15236			m := mul_0.AuxInt
 15237			mul_1 := mul.Args[1]
 15238			if mul_1.Op != OpRsh64Ux64 {
 15239				break
 15240			}
 15241			_ = mul_1.Args[1]
 15242			mul_1_0 := mul_1.Args[0]
 15243			if mul_1_0.Op != OpZeroExt32to64 {
 15244				break
 15245			}
 15246			if x != mul_1_0.Args[0] {
 15247				break
 15248			}
 15249			mul_1_1 := mul_1.Args[1]
 15250			if mul_1_1.Op != OpConst64 {
 15251				break
 15252			}
 15253			if mul_1_1.AuxInt != 1 {
 15254				break
 15255			}
 15256			v_1_0_0_1 := v_1_0_0.Args[1]
 15257			if v_1_0_0_1.Op != OpConst64 {
 15258				break
 15259			}
 15260			s := v_1_0_0_1.AuxInt
 15261			v_1_1 := v_1.Args[1]
 15262			if v_1_1.Op != OpConst32 {
 15263				break
 15264			}
 15265			c := v_1_1.AuxInt
 15266			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+(umagic(32, c).m+1)/2) && s == 32+umagic(32, c).s-2 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 15267				break
 15268			}
 15269			v.reset(OpLeq32U)
 15270			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 15271			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 15272			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15273			v2.AuxInt = int64(int32(udivisible(32, c).m))
 15274			v1.AddArg(v2)
 15275			v1.AddArg(x)
 15276			v0.AddArg(v1)
 15277			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15278			v3.AuxInt = int64(32 - udivisible(32, c).k)
 15279			v0.AddArg(v3)
 15280			v.AddArg(v0)
 15281			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15282			v4.AuxInt = int64(int32(udivisible(32, c).max))
 15283			v.AddArg(v4)
 15284			return true
 15285		}
 15286		// match: (Eq32 x (Mul32 (Trunc64to32 (Rsh64Ux64 mul:(Mul64 (Rsh64Ux64 (ZeroExt32to64 x) (Const64 [1])) (Const64 [m])) (Const64 [s]))) (Const32 [c])))
 15287		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+(umagic(32,c).m+1)/2) && s == 32+umagic(32,c).s-2 && x.Op != OpConst32 && udivisibleOK(32,c)
 15288		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 15289		for {
 15290			_ = v.Args[1]
 15291			x := v.Args[0]
 15292			v_1 := v.Args[1]
 15293			if v_1.Op != OpMul32 {
 15294				break
 15295			}
 15296			_ = v_1.Args[1]
 15297			v_1_0 := v_1.Args[0]
 15298			if v_1_0.Op != OpTrunc64to32 {
 15299				break
 15300			}
 15301			v_1_0_0 := v_1_0.Args[0]
 15302			if v_1_0_0.Op != OpRsh64Ux64 {
 15303				break
 15304			}
 15305			_ = v_1_0_0.Args[1]
 15306			mul := v_1_0_0.Args[0]
 15307			if mul.Op != OpMul64 {
 15308				break
 15309			}
 15310			_ = mul.Args[1]
 15311			mul_0 := mul.Args[0]
 15312			if mul_0.Op != OpRsh64Ux64 {
 15313				break
 15314			}
 15315			_ = mul_0.Args[1]
 15316			mul_0_0 := mul_0.Args[0]
 15317			if mul_0_0.Op != OpZeroExt32to64 {
 15318				break
 15319			}
 15320			if x != mul_0_0.Args[0] {
 15321				break
 15322			}
 15323			mul_0_1 := mul_0.Args[1]
 15324			if mul_0_1.Op != OpConst64 {
 15325				break
 15326			}
 15327			if mul_0_1.AuxInt != 1 {
 15328				break
 15329			}
 15330			mul_1 := mul.Args[1]
 15331			if mul_1.Op != OpConst64 {
 15332				break
 15333			}
 15334			m := mul_1.AuxInt
 15335			v_1_0_0_1 := v_1_0_0.Args[1]
 15336			if v_1_0_0_1.Op != OpConst64 {
 15337				break
 15338			}
 15339			s := v_1_0_0_1.AuxInt
 15340			v_1_1 := v_1.Args[1]
 15341			if v_1_1.Op != OpConst32 {
 15342				break
 15343			}
 15344			c := v_1_1.AuxInt
 15345			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+(umagic(32, c).m+1)/2) && s == 32+umagic(32, c).s-2 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 15346				break
 15347			}
 15348			v.reset(OpLeq32U)
 15349			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 15350			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 15351			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15352			v2.AuxInt = int64(int32(udivisible(32, c).m))
 15353			v1.AddArg(v2)
 15354			v1.AddArg(x)
 15355			v0.AddArg(v1)
 15356			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15357			v3.AuxInt = int64(32 - udivisible(32, c).k)
 15358			v0.AddArg(v3)
 15359			v.AddArg(v0)
 15360			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15361			v4.AuxInt = int64(int32(udivisible(32, c).max))
 15362			v.AddArg(v4)
 15363			return true
 15364		}
 15365		// match: (Eq32 (Mul32 (Const32 [c]) (Trunc64to32 (Rsh64Ux64 mul:(Mul64 (Const64 [m]) (Rsh64Ux64 (ZeroExt32to64 x) (Const64 [1]))) (Const64 [s])))) x)
 15366		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+(umagic(32,c).m+1)/2) && s == 32+umagic(32,c).s-2 && x.Op != OpConst32 && udivisibleOK(32,c)
 15367		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 15368		for {
 15369			x := v.Args[1]
 15370			v_0 := v.Args[0]
 15371			if v_0.Op != OpMul32 {
 15372				break
 15373			}
 15374			_ = v_0.Args[1]
 15375			v_0_0 := v_0.Args[0]
 15376			if v_0_0.Op != OpConst32 {
 15377				break
 15378			}
 15379			c := v_0_0.AuxInt
 15380			v_0_1 := v_0.Args[1]
 15381			if v_0_1.Op != OpTrunc64to32 {
 15382				break
 15383			}
 15384			v_0_1_0 := v_0_1.Args[0]
 15385			if v_0_1_0.Op != OpRsh64Ux64 {
 15386				break
 15387			}
 15388			_ = v_0_1_0.Args[1]
 15389			mul := v_0_1_0.Args[0]
 15390			if mul.Op != OpMul64 {
 15391				break
 15392			}
 15393			_ = mul.Args[1]
 15394			mul_0 := mul.Args[0]
 15395			if mul_0.Op != OpConst64 {
 15396				break
 15397			}
 15398			m := mul_0.AuxInt
 15399			mul_1 := mul.Args[1]
 15400			if mul_1.Op != OpRsh64Ux64 {
 15401				break
 15402			}
 15403			_ = mul_1.Args[1]
 15404			mul_1_0 := mul_1.Args[0]
 15405			if mul_1_0.Op != OpZeroExt32to64 {
 15406				break
 15407			}
 15408			if x != mul_1_0.Args[0] {
 15409				break
 15410			}
 15411			mul_1_1 := mul_1.Args[1]
 15412			if mul_1_1.Op != OpConst64 {
 15413				break
 15414			}
 15415			if mul_1_1.AuxInt != 1 {
 15416				break
 15417			}
 15418			v_0_1_0_1 := v_0_1_0.Args[1]
 15419			if v_0_1_0_1.Op != OpConst64 {
 15420				break
 15421			}
 15422			s := v_0_1_0_1.AuxInt
 15423			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+(umagic(32, c).m+1)/2) && s == 32+umagic(32, c).s-2 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 15424				break
 15425			}
 15426			v.reset(OpLeq32U)
 15427			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 15428			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 15429			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15430			v2.AuxInt = int64(int32(udivisible(32, c).m))
 15431			v1.AddArg(v2)
 15432			v1.AddArg(x)
 15433			v0.AddArg(v1)
 15434			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15435			v3.AuxInt = int64(32 - udivisible(32, c).k)
 15436			v0.AddArg(v3)
 15437			v.AddArg(v0)
 15438			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15439			v4.AuxInt = int64(int32(udivisible(32, c).max))
 15440			v.AddArg(v4)
 15441			return true
 15442		}
 15443		// match: (Eq32 (Mul32 (Const32 [c]) (Trunc64to32 (Rsh64Ux64 mul:(Mul64 (Rsh64Ux64 (ZeroExt32to64 x) (Const64 [1])) (Const64 [m])) (Const64 [s])))) x)
 15444		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+(umagic(32,c).m+1)/2) && s == 32+umagic(32,c).s-2 && x.Op != OpConst32 && udivisibleOK(32,c)
 15445		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 15446		for {
 15447			x := v.Args[1]
 15448			v_0 := v.Args[0]
 15449			if v_0.Op != OpMul32 {
 15450				break
 15451			}
 15452			_ = v_0.Args[1]
 15453			v_0_0 := v_0.Args[0]
 15454			if v_0_0.Op != OpConst32 {
 15455				break
 15456			}
 15457			c := v_0_0.AuxInt
 15458			v_0_1 := v_0.Args[1]
 15459			if v_0_1.Op != OpTrunc64to32 {
 15460				break
 15461			}
 15462			v_0_1_0 := v_0_1.Args[0]
 15463			if v_0_1_0.Op != OpRsh64Ux64 {
 15464				break
 15465			}
 15466			_ = v_0_1_0.Args[1]
 15467			mul := v_0_1_0.Args[0]
 15468			if mul.Op != OpMul64 {
 15469				break
 15470			}
 15471			_ = mul.Args[1]
 15472			mul_0 := mul.Args[0]
 15473			if mul_0.Op != OpRsh64Ux64 {
 15474				break
 15475			}
 15476			_ = mul_0.Args[1]
 15477			mul_0_0 := mul_0.Args[0]
 15478			if mul_0_0.Op != OpZeroExt32to64 {
 15479				break
 15480			}
 15481			if x != mul_0_0.Args[0] {
 15482				break
 15483			}
 15484			mul_0_1 := mul_0.Args[1]
 15485			if mul_0_1.Op != OpConst64 {
 15486				break
 15487			}
 15488			if mul_0_1.AuxInt != 1 {
 15489				break
 15490			}
 15491			mul_1 := mul.Args[1]
 15492			if mul_1.Op != OpConst64 {
 15493				break
 15494			}
 15495			m := mul_1.AuxInt
 15496			v_0_1_0_1 := v_0_1_0.Args[1]
 15497			if v_0_1_0_1.Op != OpConst64 {
 15498				break
 15499			}
 15500			s := v_0_1_0_1.AuxInt
 15501			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+(umagic(32, c).m+1)/2) && s == 32+umagic(32, c).s-2 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 15502				break
 15503			}
 15504			v.reset(OpLeq32U)
 15505			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 15506			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 15507			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15508			v2.AuxInt = int64(int32(udivisible(32, c).m))
 15509			v1.AddArg(v2)
 15510			v1.AddArg(x)
 15511			v0.AddArg(v1)
 15512			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15513			v3.AuxInt = int64(32 - udivisible(32, c).k)
 15514			v0.AddArg(v3)
 15515			v.AddArg(v0)
 15516			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15517			v4.AuxInt = int64(int32(udivisible(32, c).max))
 15518			v.AddArg(v4)
 15519			return true
 15520		}
 15521		// match: (Eq32 (Mul32 (Trunc64to32 (Rsh64Ux64 mul:(Mul64 (Const64 [m]) (Rsh64Ux64 (ZeroExt32to64 x) (Const64 [1]))) (Const64 [s]))) (Const32 [c])) x)
 15522		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+(umagic(32,c).m+1)/2) && s == 32+umagic(32,c).s-2 && x.Op != OpConst32 && udivisibleOK(32,c)
 15523		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 15524		for {
 15525			x := v.Args[1]
 15526			v_0 := v.Args[0]
 15527			if v_0.Op != OpMul32 {
 15528				break
 15529			}
 15530			_ = v_0.Args[1]
 15531			v_0_0 := v_0.Args[0]
 15532			if v_0_0.Op != OpTrunc64to32 {
 15533				break
 15534			}
 15535			v_0_0_0 := v_0_0.Args[0]
 15536			if v_0_0_0.Op != OpRsh64Ux64 {
 15537				break
 15538			}
 15539			_ = v_0_0_0.Args[1]
 15540			mul := v_0_0_0.Args[0]
 15541			if mul.Op != OpMul64 {
 15542				break
 15543			}
 15544			_ = mul.Args[1]
 15545			mul_0 := mul.Args[0]
 15546			if mul_0.Op != OpConst64 {
 15547				break
 15548			}
 15549			m := mul_0.AuxInt
 15550			mul_1 := mul.Args[1]
 15551			if mul_1.Op != OpRsh64Ux64 {
 15552				break
 15553			}
 15554			_ = mul_1.Args[1]
 15555			mul_1_0 := mul_1.Args[0]
 15556			if mul_1_0.Op != OpZeroExt32to64 {
 15557				break
 15558			}
 15559			if x != mul_1_0.Args[0] {
 15560				break
 15561			}
 15562			mul_1_1 := mul_1.Args[1]
 15563			if mul_1_1.Op != OpConst64 {
 15564				break
 15565			}
 15566			if mul_1_1.AuxInt != 1 {
 15567				break
 15568			}
 15569			v_0_0_0_1 := v_0_0_0.Args[1]
 15570			if v_0_0_0_1.Op != OpConst64 {
 15571				break
 15572			}
 15573			s := v_0_0_0_1.AuxInt
 15574			v_0_1 := v_0.Args[1]
 15575			if v_0_1.Op != OpConst32 {
 15576				break
 15577			}
 15578			c := v_0_1.AuxInt
 15579			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+(umagic(32, c).m+1)/2) && s == 32+umagic(32, c).s-2 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 15580				break
 15581			}
 15582			v.reset(OpLeq32U)
 15583			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 15584			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 15585			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15586			v2.AuxInt = int64(int32(udivisible(32, c).m))
 15587			v1.AddArg(v2)
 15588			v1.AddArg(x)
 15589			v0.AddArg(v1)
 15590			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15591			v3.AuxInt = int64(32 - udivisible(32, c).k)
 15592			v0.AddArg(v3)
 15593			v.AddArg(v0)
 15594			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15595			v4.AuxInt = int64(int32(udivisible(32, c).max))
 15596			v.AddArg(v4)
 15597			return true
 15598		}
 15599		// match: (Eq32 (Mul32 (Trunc64to32 (Rsh64Ux64 mul:(Mul64 (Rsh64Ux64 (ZeroExt32to64 x) (Const64 [1])) (Const64 [m])) (Const64 [s]))) (Const32 [c])) x)
 15600		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+(umagic(32,c).m+1)/2) && s == 32+umagic(32,c).s-2 && x.Op != OpConst32 && udivisibleOK(32,c)
 15601		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 15602		for {
 15603			x := v.Args[1]
 15604			v_0 := v.Args[0]
 15605			if v_0.Op != OpMul32 {
 15606				break
 15607			}
 15608			_ = v_0.Args[1]
 15609			v_0_0 := v_0.Args[0]
 15610			if v_0_0.Op != OpTrunc64to32 {
 15611				break
 15612			}
 15613			v_0_0_0 := v_0_0.Args[0]
 15614			if v_0_0_0.Op != OpRsh64Ux64 {
 15615				break
 15616			}
 15617			_ = v_0_0_0.Args[1]
 15618			mul := v_0_0_0.Args[0]
 15619			if mul.Op != OpMul64 {
 15620				break
 15621			}
 15622			_ = mul.Args[1]
 15623			mul_0 := mul.Args[0]
 15624			if mul_0.Op != OpRsh64Ux64 {
 15625				break
 15626			}
 15627			_ = mul_0.Args[1]
 15628			mul_0_0 := mul_0.Args[0]
 15629			if mul_0_0.Op != OpZeroExt32to64 {
 15630				break
 15631			}
 15632			if x != mul_0_0.Args[0] {
 15633				break
 15634			}
 15635			mul_0_1 := mul_0.Args[1]
 15636			if mul_0_1.Op != OpConst64 {
 15637				break
 15638			}
 15639			if mul_0_1.AuxInt != 1 {
 15640				break
 15641			}
 15642			mul_1 := mul.Args[1]
 15643			if mul_1.Op != OpConst64 {
 15644				break
 15645			}
 15646			m := mul_1.AuxInt
 15647			v_0_0_0_1 := v_0_0_0.Args[1]
 15648			if v_0_0_0_1.Op != OpConst64 {
 15649				break
 15650			}
 15651			s := v_0_0_0_1.AuxInt
 15652			v_0_1 := v_0.Args[1]
 15653			if v_0_1.Op != OpConst32 {
 15654				break
 15655			}
 15656			c := v_0_1.AuxInt
 15657			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+(umagic(32, c).m+1)/2) && s == 32+umagic(32, c).s-2 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 15658				break
 15659			}
 15660			v.reset(OpLeq32U)
 15661			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 15662			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 15663			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15664			v2.AuxInt = int64(int32(udivisible(32, c).m))
 15665			v1.AddArg(v2)
 15666			v1.AddArg(x)
 15667			v0.AddArg(v1)
 15668			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15669			v3.AuxInt = int64(32 - udivisible(32, c).k)
 15670			v0.AddArg(v3)
 15671			v.AddArg(v0)
 15672			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15673			v4.AuxInt = int64(int32(udivisible(32, c).max))
 15674			v.AddArg(v4)
 15675			return true
 15676		}
 15677		// match: (Eq32 x (Mul32 (Const32 [c]) (Trunc64to32 (Rsh64Ux64 (Avg64u (Lsh64x64 (ZeroExt32to64 x) (Const64 [32])) mul:(Mul64 (Const64 [m]) (ZeroExt32to64 x))) (Const64 [s])))))
 15678		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(32,c).m) && s == 32+umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c)
 15679		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 15680		for {
 15681			_ = v.Args[1]
 15682			x := v.Args[0]
 15683			v_1 := v.Args[1]
 15684			if v_1.Op != OpMul32 {
 15685				break
 15686			}
 15687			_ = v_1.Args[1]
 15688			v_1_0 := v_1.Args[0]
 15689			if v_1_0.Op != OpConst32 {
 15690				break
 15691			}
 15692			c := v_1_0.AuxInt
 15693			v_1_1 := v_1.Args[1]
 15694			if v_1_1.Op != OpTrunc64to32 {
 15695				break
 15696			}
 15697			v_1_1_0 := v_1_1.Args[0]
 15698			if v_1_1_0.Op != OpRsh64Ux64 {
 15699				break
 15700			}
 15701			_ = v_1_1_0.Args[1]
 15702			v_1_1_0_0 := v_1_1_0.Args[0]
 15703			if v_1_1_0_0.Op != OpAvg64u {
 15704				break
 15705			}
 15706			_ = v_1_1_0_0.Args[1]
 15707			v_1_1_0_0_0 := v_1_1_0_0.Args[0]
 15708			if v_1_1_0_0_0.Op != OpLsh64x64 {
 15709				break
 15710			}
 15711			_ = v_1_1_0_0_0.Args[1]
 15712			v_1_1_0_0_0_0 := v_1_1_0_0_0.Args[0]
 15713			if v_1_1_0_0_0_0.Op != OpZeroExt32to64 {
 15714				break
 15715			}
 15716			if x != v_1_1_0_0_0_0.Args[0] {
 15717				break
 15718			}
 15719			v_1_1_0_0_0_1 := v_1_1_0_0_0.Args[1]
 15720			if v_1_1_0_0_0_1.Op != OpConst64 {
 15721				break
 15722			}
 15723			if v_1_1_0_0_0_1.AuxInt != 32 {
 15724				break
 15725			}
 15726			mul := v_1_1_0_0.Args[1]
 15727			if mul.Op != OpMul64 {
 15728				break
 15729			}
 15730			_ = mul.Args[1]
 15731			mul_0 := mul.Args[0]
 15732			if mul_0.Op != OpConst64 {
 15733				break
 15734			}
 15735			m := mul_0.AuxInt
 15736			mul_1 := mul.Args[1]
 15737			if mul_1.Op != OpZeroExt32to64 {
 15738				break
 15739			}
 15740			if x != mul_1.Args[0] {
 15741				break
 15742			}
 15743			v_1_1_0_1 := v_1_1_0.Args[1]
 15744			if v_1_1_0_1.Op != OpConst64 {
 15745				break
 15746			}
 15747			s := v_1_1_0_1.AuxInt
 15748			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(32, c).m) && s == 32+umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 15749				break
 15750			}
 15751			v.reset(OpLeq32U)
 15752			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 15753			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 15754			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15755			v2.AuxInt = int64(int32(udivisible(32, c).m))
 15756			v1.AddArg(v2)
 15757			v1.AddArg(x)
 15758			v0.AddArg(v1)
 15759			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15760			v3.AuxInt = int64(32 - udivisible(32, c).k)
 15761			v0.AddArg(v3)
 15762			v.AddArg(v0)
 15763			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15764			v4.AuxInt = int64(int32(udivisible(32, c).max))
 15765			v.AddArg(v4)
 15766			return true
 15767		}
 15768		// match: (Eq32 x (Mul32 (Const32 [c]) (Trunc64to32 (Rsh64Ux64 (Avg64u (Lsh64x64 (ZeroExt32to64 x) (Const64 [32])) mul:(Mul64 (ZeroExt32to64 x) (Const64 [m]))) (Const64 [s])))))
 15769		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(32,c).m) && s == 32+umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c)
 15770		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 15771		for {
 15772			_ = v.Args[1]
 15773			x := v.Args[0]
 15774			v_1 := v.Args[1]
 15775			if v_1.Op != OpMul32 {
 15776				break
 15777			}
 15778			_ = v_1.Args[1]
 15779			v_1_0 := v_1.Args[0]
 15780			if v_1_0.Op != OpConst32 {
 15781				break
 15782			}
 15783			c := v_1_0.AuxInt
 15784			v_1_1 := v_1.Args[1]
 15785			if v_1_1.Op != OpTrunc64to32 {
 15786				break
 15787			}
 15788			v_1_1_0 := v_1_1.Args[0]
 15789			if v_1_1_0.Op != OpRsh64Ux64 {
 15790				break
 15791			}
 15792			_ = v_1_1_0.Args[1]
 15793			v_1_1_0_0 := v_1_1_0.Args[0]
 15794			if v_1_1_0_0.Op != OpAvg64u {
 15795				break
 15796			}
 15797			_ = v_1_1_0_0.Args[1]
 15798			v_1_1_0_0_0 := v_1_1_0_0.Args[0]
 15799			if v_1_1_0_0_0.Op != OpLsh64x64 {
 15800				break
 15801			}
 15802			_ = v_1_1_0_0_0.Args[1]
 15803			v_1_1_0_0_0_0 := v_1_1_0_0_0.Args[0]
 15804			if v_1_1_0_0_0_0.Op != OpZeroExt32to64 {
 15805				break
 15806			}
 15807			if x != v_1_1_0_0_0_0.Args[0] {
 15808				break
 15809			}
 15810			v_1_1_0_0_0_1 := v_1_1_0_0_0.Args[1]
 15811			if v_1_1_0_0_0_1.Op != OpConst64 {
 15812				break
 15813			}
 15814			if v_1_1_0_0_0_1.AuxInt != 32 {
 15815				break
 15816			}
 15817			mul := v_1_1_0_0.Args[1]
 15818			if mul.Op != OpMul64 {
 15819				break
 15820			}
 15821			_ = mul.Args[1]
 15822			mul_0 := mul.Args[0]
 15823			if mul_0.Op != OpZeroExt32to64 {
 15824				break
 15825			}
 15826			if x != mul_0.Args[0] {
 15827				break
 15828			}
 15829			mul_1 := mul.Args[1]
 15830			if mul_1.Op != OpConst64 {
 15831				break
 15832			}
 15833			m := mul_1.AuxInt
 15834			v_1_1_0_1 := v_1_1_0.Args[1]
 15835			if v_1_1_0_1.Op != OpConst64 {
 15836				break
 15837			}
 15838			s := v_1_1_0_1.AuxInt
 15839			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(32, c).m) && s == 32+umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 15840				break
 15841			}
 15842			v.reset(OpLeq32U)
 15843			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 15844			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 15845			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15846			v2.AuxInt = int64(int32(udivisible(32, c).m))
 15847			v1.AddArg(v2)
 15848			v1.AddArg(x)
 15849			v0.AddArg(v1)
 15850			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15851			v3.AuxInt = int64(32 - udivisible(32, c).k)
 15852			v0.AddArg(v3)
 15853			v.AddArg(v0)
 15854			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15855			v4.AuxInt = int64(int32(udivisible(32, c).max))
 15856			v.AddArg(v4)
 15857			return true
 15858		}
 15859		// match: (Eq32 x (Mul32 (Trunc64to32 (Rsh64Ux64 (Avg64u (Lsh64x64 (ZeroExt32to64 x) (Const64 [32])) mul:(Mul64 (Const64 [m]) (ZeroExt32to64 x))) (Const64 [s]))) (Const32 [c])))
 15860		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(32,c).m) && s == 32+umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c)
 15861		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 15862		for {
 15863			_ = v.Args[1]
 15864			x := v.Args[0]
 15865			v_1 := v.Args[1]
 15866			if v_1.Op != OpMul32 {
 15867				break
 15868			}
 15869			_ = v_1.Args[1]
 15870			v_1_0 := v_1.Args[0]
 15871			if v_1_0.Op != OpTrunc64to32 {
 15872				break
 15873			}
 15874			v_1_0_0 := v_1_0.Args[0]
 15875			if v_1_0_0.Op != OpRsh64Ux64 {
 15876				break
 15877			}
 15878			_ = v_1_0_0.Args[1]
 15879			v_1_0_0_0 := v_1_0_0.Args[0]
 15880			if v_1_0_0_0.Op != OpAvg64u {
 15881				break
 15882			}
 15883			_ = v_1_0_0_0.Args[1]
 15884			v_1_0_0_0_0 := v_1_0_0_0.Args[0]
 15885			if v_1_0_0_0_0.Op != OpLsh64x64 {
 15886				break
 15887			}
 15888			_ = v_1_0_0_0_0.Args[1]
 15889			v_1_0_0_0_0_0 := v_1_0_0_0_0.Args[0]
 15890			if v_1_0_0_0_0_0.Op != OpZeroExt32to64 {
 15891				break
 15892			}
 15893			if x != v_1_0_0_0_0_0.Args[0] {
 15894				break
 15895			}
 15896			v_1_0_0_0_0_1 := v_1_0_0_0_0.Args[1]
 15897			if v_1_0_0_0_0_1.Op != OpConst64 {
 15898				break
 15899			}
 15900			if v_1_0_0_0_0_1.AuxInt != 32 {
 15901				break
 15902			}
 15903			mul := v_1_0_0_0.Args[1]
 15904			if mul.Op != OpMul64 {
 15905				break
 15906			}
 15907			_ = mul.Args[1]
 15908			mul_0 := mul.Args[0]
 15909			if mul_0.Op != OpConst64 {
 15910				break
 15911			}
 15912			m := mul_0.AuxInt
 15913			mul_1 := mul.Args[1]
 15914			if mul_1.Op != OpZeroExt32to64 {
 15915				break
 15916			}
 15917			if x != mul_1.Args[0] {
 15918				break
 15919			}
 15920			v_1_0_0_1 := v_1_0_0.Args[1]
 15921			if v_1_0_0_1.Op != OpConst64 {
 15922				break
 15923			}
 15924			s := v_1_0_0_1.AuxInt
 15925			v_1_1 := v_1.Args[1]
 15926			if v_1_1.Op != OpConst32 {
 15927				break
 15928			}
 15929			c := v_1_1.AuxInt
 15930			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(32, c).m) && s == 32+umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 15931				break
 15932			}
 15933			v.reset(OpLeq32U)
 15934			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 15935			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 15936			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15937			v2.AuxInt = int64(int32(udivisible(32, c).m))
 15938			v1.AddArg(v2)
 15939			v1.AddArg(x)
 15940			v0.AddArg(v1)
 15941			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15942			v3.AuxInt = int64(32 - udivisible(32, c).k)
 15943			v0.AddArg(v3)
 15944			v.AddArg(v0)
 15945			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 15946			v4.AuxInt = int64(int32(udivisible(32, c).max))
 15947			v.AddArg(v4)
 15948			return true
 15949		}
 15950		return false
 15951	}
 15952	func rewriteValuegeneric_OpEq32_50(v *Value) bool {
 15953		b := v.Block
 15954		typ := &b.Func.Config.Types
 15955		// match: (Eq32 x (Mul32 (Trunc64to32 (Rsh64Ux64 (Avg64u (Lsh64x64 (ZeroExt32to64 x) (Const64 [32])) mul:(Mul64 (ZeroExt32to64 x) (Const64 [m]))) (Const64 [s]))) (Const32 [c])))
 15956		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(32,c).m) && s == 32+umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c)
 15957		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 15958		for {
 15959			_ = v.Args[1]
 15960			x := v.Args[0]
 15961			v_1 := v.Args[1]
 15962			if v_1.Op != OpMul32 {
 15963				break
 15964			}
 15965			_ = v_1.Args[1]
 15966			v_1_0 := v_1.Args[0]
 15967			if v_1_0.Op != OpTrunc64to32 {
 15968				break
 15969			}
 15970			v_1_0_0 := v_1_0.Args[0]
 15971			if v_1_0_0.Op != OpRsh64Ux64 {
 15972				break
 15973			}
 15974			_ = v_1_0_0.Args[1]
 15975			v_1_0_0_0 := v_1_0_0.Args[0]
 15976			if v_1_0_0_0.Op != OpAvg64u {
 15977				break
 15978			}
 15979			_ = v_1_0_0_0.Args[1]
 15980			v_1_0_0_0_0 := v_1_0_0_0.Args[0]
 15981			if v_1_0_0_0_0.Op != OpLsh64x64 {
 15982				break
 15983			}
 15984			_ = v_1_0_0_0_0.Args[1]
 15985			v_1_0_0_0_0_0 := v_1_0_0_0_0.Args[0]
 15986			if v_1_0_0_0_0_0.Op != OpZeroExt32to64 {
 15987				break
 15988			}
 15989			if x != v_1_0_0_0_0_0.Args[0] {
 15990				break
 15991			}
 15992			v_1_0_0_0_0_1 := v_1_0_0_0_0.Args[1]
 15993			if v_1_0_0_0_0_1.Op != OpConst64 {
 15994				break
 15995			}
 15996			if v_1_0_0_0_0_1.AuxInt != 32 {
 15997				break
 15998			}
 15999			mul := v_1_0_0_0.Args[1]
 16000			if mul.Op != OpMul64 {
 16001				break
 16002			}
 16003			_ = mul.Args[1]
 16004			mul_0 := mul.Args[0]
 16005			if mul_0.Op != OpZeroExt32to64 {
 16006				break
 16007			}
 16008			if x != mul_0.Args[0] {
 16009				break
 16010			}
 16011			mul_1 := mul.Args[1]
 16012			if mul_1.Op != OpConst64 {
 16013				break
 16014			}
 16015			m := mul_1.AuxInt
 16016			v_1_0_0_1 := v_1_0_0.Args[1]
 16017			if v_1_0_0_1.Op != OpConst64 {
 16018				break
 16019			}
 16020			s := v_1_0_0_1.AuxInt
 16021			v_1_1 := v_1.Args[1]
 16022			if v_1_1.Op != OpConst32 {
 16023				break
 16024			}
 16025			c := v_1_1.AuxInt
 16026			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(32, c).m) && s == 32+umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 16027				break
 16028			}
 16029			v.reset(OpLeq32U)
 16030			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 16031			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 16032			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16033			v2.AuxInt = int64(int32(udivisible(32, c).m))
 16034			v1.AddArg(v2)
 16035			v1.AddArg(x)
 16036			v0.AddArg(v1)
 16037			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16038			v3.AuxInt = int64(32 - udivisible(32, c).k)
 16039			v0.AddArg(v3)
 16040			v.AddArg(v0)
 16041			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16042			v4.AuxInt = int64(int32(udivisible(32, c).max))
 16043			v.AddArg(v4)
 16044			return true
 16045		}
 16046		// match: (Eq32 (Mul32 (Const32 [c]) (Trunc64to32 (Rsh64Ux64 (Avg64u (Lsh64x64 (ZeroExt32to64 x) (Const64 [32])) mul:(Mul64 (Const64 [m]) (ZeroExt32to64 x))) (Const64 [s])))) x)
 16047		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(32,c).m) && s == 32+umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c)
 16048		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 16049		for {
 16050			x := v.Args[1]
 16051			v_0 := v.Args[0]
 16052			if v_0.Op != OpMul32 {
 16053				break
 16054			}
 16055			_ = v_0.Args[1]
 16056			v_0_0 := v_0.Args[0]
 16057			if v_0_0.Op != OpConst32 {
 16058				break
 16059			}
 16060			c := v_0_0.AuxInt
 16061			v_0_1 := v_0.Args[1]
 16062			if v_0_1.Op != OpTrunc64to32 {
 16063				break
 16064			}
 16065			v_0_1_0 := v_0_1.Args[0]
 16066			if v_0_1_0.Op != OpRsh64Ux64 {
 16067				break
 16068			}
 16069			_ = v_0_1_0.Args[1]
 16070			v_0_1_0_0 := v_0_1_0.Args[0]
 16071			if v_0_1_0_0.Op != OpAvg64u {
 16072				break
 16073			}
 16074			_ = v_0_1_0_0.Args[1]
 16075			v_0_1_0_0_0 := v_0_1_0_0.Args[0]
 16076			if v_0_1_0_0_0.Op != OpLsh64x64 {
 16077				break
 16078			}
 16079			_ = v_0_1_0_0_0.Args[1]
 16080			v_0_1_0_0_0_0 := v_0_1_0_0_0.Args[0]
 16081			if v_0_1_0_0_0_0.Op != OpZeroExt32to64 {
 16082				break
 16083			}
 16084			if x != v_0_1_0_0_0_0.Args[0] {
 16085				break
 16086			}
 16087			v_0_1_0_0_0_1 := v_0_1_0_0_0.Args[1]
 16088			if v_0_1_0_0_0_1.Op != OpConst64 {
 16089				break
 16090			}
 16091			if v_0_1_0_0_0_1.AuxInt != 32 {
 16092				break
 16093			}
 16094			mul := v_0_1_0_0.Args[1]
 16095			if mul.Op != OpMul64 {
 16096				break
 16097			}
 16098			_ = mul.Args[1]
 16099			mul_0 := mul.Args[0]
 16100			if mul_0.Op != OpConst64 {
 16101				break
 16102			}
 16103			m := mul_0.AuxInt
 16104			mul_1 := mul.Args[1]
 16105			if mul_1.Op != OpZeroExt32to64 {
 16106				break
 16107			}
 16108			if x != mul_1.Args[0] {
 16109				break
 16110			}
 16111			v_0_1_0_1 := v_0_1_0.Args[1]
 16112			if v_0_1_0_1.Op != OpConst64 {
 16113				break
 16114			}
 16115			s := v_0_1_0_1.AuxInt
 16116			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(32, c).m) && s == 32+umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 16117				break
 16118			}
 16119			v.reset(OpLeq32U)
 16120			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 16121			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 16122			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16123			v2.AuxInt = int64(int32(udivisible(32, c).m))
 16124			v1.AddArg(v2)
 16125			v1.AddArg(x)
 16126			v0.AddArg(v1)
 16127			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16128			v3.AuxInt = int64(32 - udivisible(32, c).k)
 16129			v0.AddArg(v3)
 16130			v.AddArg(v0)
 16131			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16132			v4.AuxInt = int64(int32(udivisible(32, c).max))
 16133			v.AddArg(v4)
 16134			return true
 16135		}
 16136		// match: (Eq32 (Mul32 (Const32 [c]) (Trunc64to32 (Rsh64Ux64 (Avg64u (Lsh64x64 (ZeroExt32to64 x) (Const64 [32])) mul:(Mul64 (ZeroExt32to64 x) (Const64 [m]))) (Const64 [s])))) x)
 16137		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(32,c).m) && s == 32+umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c)
 16138		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 16139		for {
 16140			x := v.Args[1]
 16141			v_0 := v.Args[0]
 16142			if v_0.Op != OpMul32 {
 16143				break
 16144			}
 16145			_ = v_0.Args[1]
 16146			v_0_0 := v_0.Args[0]
 16147			if v_0_0.Op != OpConst32 {
 16148				break
 16149			}
 16150			c := v_0_0.AuxInt
 16151			v_0_1 := v_0.Args[1]
 16152			if v_0_1.Op != OpTrunc64to32 {
 16153				break
 16154			}
 16155			v_0_1_0 := v_0_1.Args[0]
 16156			if v_0_1_0.Op != OpRsh64Ux64 {
 16157				break
 16158			}
 16159			_ = v_0_1_0.Args[1]
 16160			v_0_1_0_0 := v_0_1_0.Args[0]
 16161			if v_0_1_0_0.Op != OpAvg64u {
 16162				break
 16163			}
 16164			_ = v_0_1_0_0.Args[1]
 16165			v_0_1_0_0_0 := v_0_1_0_0.Args[0]
 16166			if v_0_1_0_0_0.Op != OpLsh64x64 {
 16167				break
 16168			}
 16169			_ = v_0_1_0_0_0.Args[1]
 16170			v_0_1_0_0_0_0 := v_0_1_0_0_0.Args[0]
 16171			if v_0_1_0_0_0_0.Op != OpZeroExt32to64 {
 16172				break
 16173			}
 16174			if x != v_0_1_0_0_0_0.Args[0] {
 16175				break
 16176			}
 16177			v_0_1_0_0_0_1 := v_0_1_0_0_0.Args[1]
 16178			if v_0_1_0_0_0_1.Op != OpConst64 {
 16179				break
 16180			}
 16181			if v_0_1_0_0_0_1.AuxInt != 32 {
 16182				break
 16183			}
 16184			mul := v_0_1_0_0.Args[1]
 16185			if mul.Op != OpMul64 {
 16186				break
 16187			}
 16188			_ = mul.Args[1]
 16189			mul_0 := mul.Args[0]
 16190			if mul_0.Op != OpZeroExt32to64 {
 16191				break
 16192			}
 16193			if x != mul_0.Args[0] {
 16194				break
 16195			}
 16196			mul_1 := mul.Args[1]
 16197			if mul_1.Op != OpConst64 {
 16198				break
 16199			}
 16200			m := mul_1.AuxInt
 16201			v_0_1_0_1 := v_0_1_0.Args[1]
 16202			if v_0_1_0_1.Op != OpConst64 {
 16203				break
 16204			}
 16205			s := v_0_1_0_1.AuxInt
 16206			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(32, c).m) && s == 32+umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 16207				break
 16208			}
 16209			v.reset(OpLeq32U)
 16210			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 16211			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 16212			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16213			v2.AuxInt = int64(int32(udivisible(32, c).m))
 16214			v1.AddArg(v2)
 16215			v1.AddArg(x)
 16216			v0.AddArg(v1)
 16217			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16218			v3.AuxInt = int64(32 - udivisible(32, c).k)
 16219			v0.AddArg(v3)
 16220			v.AddArg(v0)
 16221			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16222			v4.AuxInt = int64(int32(udivisible(32, c).max))
 16223			v.AddArg(v4)
 16224			return true
 16225		}
 16226		// match: (Eq32 (Mul32 (Trunc64to32 (Rsh64Ux64 (Avg64u (Lsh64x64 (ZeroExt32to64 x) (Const64 [32])) mul:(Mul64 (Const64 [m]) (ZeroExt32to64 x))) (Const64 [s]))) (Const32 [c])) x)
 16227		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(32,c).m) && s == 32+umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c)
 16228		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 16229		for {
 16230			x := v.Args[1]
 16231			v_0 := v.Args[0]
 16232			if v_0.Op != OpMul32 {
 16233				break
 16234			}
 16235			_ = v_0.Args[1]
 16236			v_0_0 := v_0.Args[0]
 16237			if v_0_0.Op != OpTrunc64to32 {
 16238				break
 16239			}
 16240			v_0_0_0 := v_0_0.Args[0]
 16241			if v_0_0_0.Op != OpRsh64Ux64 {
 16242				break
 16243			}
 16244			_ = v_0_0_0.Args[1]
 16245			v_0_0_0_0 := v_0_0_0.Args[0]
 16246			if v_0_0_0_0.Op != OpAvg64u {
 16247				break
 16248			}
 16249			_ = v_0_0_0_0.Args[1]
 16250			v_0_0_0_0_0 := v_0_0_0_0.Args[0]
 16251			if v_0_0_0_0_0.Op != OpLsh64x64 {
 16252				break
 16253			}
 16254			_ = v_0_0_0_0_0.Args[1]
 16255			v_0_0_0_0_0_0 := v_0_0_0_0_0.Args[0]
 16256			if v_0_0_0_0_0_0.Op != OpZeroExt32to64 {
 16257				break
 16258			}
 16259			if x != v_0_0_0_0_0_0.Args[0] {
 16260				break
 16261			}
 16262			v_0_0_0_0_0_1 := v_0_0_0_0_0.Args[1]
 16263			if v_0_0_0_0_0_1.Op != OpConst64 {
 16264				break
 16265			}
 16266			if v_0_0_0_0_0_1.AuxInt != 32 {
 16267				break
 16268			}
 16269			mul := v_0_0_0_0.Args[1]
 16270			if mul.Op != OpMul64 {
 16271				break
 16272			}
 16273			_ = mul.Args[1]
 16274			mul_0 := mul.Args[0]
 16275			if mul_0.Op != OpConst64 {
 16276				break
 16277			}
 16278			m := mul_0.AuxInt
 16279			mul_1 := mul.Args[1]
 16280			if mul_1.Op != OpZeroExt32to64 {
 16281				break
 16282			}
 16283			if x != mul_1.Args[0] {
 16284				break
 16285			}
 16286			v_0_0_0_1 := v_0_0_0.Args[1]
 16287			if v_0_0_0_1.Op != OpConst64 {
 16288				break
 16289			}
 16290			s := v_0_0_0_1.AuxInt
 16291			v_0_1 := v_0.Args[1]
 16292			if v_0_1.Op != OpConst32 {
 16293				break
 16294			}
 16295			c := v_0_1.AuxInt
 16296			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(32, c).m) && s == 32+umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 16297				break
 16298			}
 16299			v.reset(OpLeq32U)
 16300			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 16301			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 16302			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16303			v2.AuxInt = int64(int32(udivisible(32, c).m))
 16304			v1.AddArg(v2)
 16305			v1.AddArg(x)
 16306			v0.AddArg(v1)
 16307			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16308			v3.AuxInt = int64(32 - udivisible(32, c).k)
 16309			v0.AddArg(v3)
 16310			v.AddArg(v0)
 16311			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16312			v4.AuxInt = int64(int32(udivisible(32, c).max))
 16313			v.AddArg(v4)
 16314			return true
 16315		}
 16316		// match: (Eq32 (Mul32 (Trunc64to32 (Rsh64Ux64 (Avg64u (Lsh64x64 (ZeroExt32to64 x) (Const64 [32])) mul:(Mul64 (ZeroExt32to64 x) (Const64 [m]))) (Const64 [s]))) (Const32 [c])) x)
 16317		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(32,c).m) && s == 32+umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c)
 16318		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) )
 16319		for {
 16320			x := v.Args[1]
 16321			v_0 := v.Args[0]
 16322			if v_0.Op != OpMul32 {
 16323				break
 16324			}
 16325			_ = v_0.Args[1]
 16326			v_0_0 := v_0.Args[0]
 16327			if v_0_0.Op != OpTrunc64to32 {
 16328				break
 16329			}
 16330			v_0_0_0 := v_0_0.Args[0]
 16331			if v_0_0_0.Op != OpRsh64Ux64 {
 16332				break
 16333			}
 16334			_ = v_0_0_0.Args[1]
 16335			v_0_0_0_0 := v_0_0_0.Args[0]
 16336			if v_0_0_0_0.Op != OpAvg64u {
 16337				break
 16338			}
 16339			_ = v_0_0_0_0.Args[1]
 16340			v_0_0_0_0_0 := v_0_0_0_0.Args[0]
 16341			if v_0_0_0_0_0.Op != OpLsh64x64 {
 16342				break
 16343			}
 16344			_ = v_0_0_0_0_0.Args[1]
 16345			v_0_0_0_0_0_0 := v_0_0_0_0_0.Args[0]
 16346			if v_0_0_0_0_0_0.Op != OpZeroExt32to64 {
 16347				break
 16348			}
 16349			if x != v_0_0_0_0_0_0.Args[0] {
 16350				break
 16351			}
 16352			v_0_0_0_0_0_1 := v_0_0_0_0_0.Args[1]
 16353			if v_0_0_0_0_0_1.Op != OpConst64 {
 16354				break
 16355			}
 16356			if v_0_0_0_0_0_1.AuxInt != 32 {
 16357				break
 16358			}
 16359			mul := v_0_0_0_0.Args[1]
 16360			if mul.Op != OpMul64 {
 16361				break
 16362			}
 16363			_ = mul.Args[1]
 16364			mul_0 := mul.Args[0]
 16365			if mul_0.Op != OpZeroExt32to64 {
 16366				break
 16367			}
 16368			if x != mul_0.Args[0] {
 16369				break
 16370			}
 16371			mul_1 := mul.Args[1]
 16372			if mul_1.Op != OpConst64 {
 16373				break
 16374			}
 16375			m := mul_1.AuxInt
 16376			v_0_0_0_1 := v_0_0_0.Args[1]
 16377			if v_0_0_0_1.Op != OpConst64 {
 16378				break
 16379			}
 16380			s := v_0_0_0_1.AuxInt
 16381			v_0_1 := v_0.Args[1]
 16382			if v_0_1.Op != OpConst32 {
 16383				break
 16384			}
 16385			c := v_0_1.AuxInt
 16386			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(32, c).m) && s == 32+umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) {
 16387				break
 16388			}
 16389			v.reset(OpLeq32U)
 16390			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 16391			v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 16392			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16393			v2.AuxInt = int64(int32(udivisible(32, c).m))
 16394			v1.AddArg(v2)
 16395			v1.AddArg(x)
 16396			v0.AddArg(v1)
 16397			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16398			v3.AuxInt = int64(32 - udivisible(32, c).k)
 16399			v0.AddArg(v3)
 16400			v.AddArg(v0)
 16401			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16402			v4.AuxInt = int64(int32(udivisible(32, c).max))
 16403			v.AddArg(v4)
 16404			return true
 16405		}
 16406		// match: (Eq32 x (Mul32 (Const32 [c]) (Sub32 (Rsh64x64 mul:(Mul64 (Const64 [m]) (SignExt32to64 x)) (Const64 [s])) (Rsh64x64 (SignExt32to64 x) (Const64 [63])))))
 16407		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(32,c).m) && s == 32+smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c)
 16408		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) )
 16409		for {
 16410			_ = v.Args[1]
 16411			x := v.Args[0]
 16412			v_1 := v.Args[1]
 16413			if v_1.Op != OpMul32 {
 16414				break
 16415			}
 16416			_ = v_1.Args[1]
 16417			v_1_0 := v_1.Args[0]
 16418			if v_1_0.Op != OpConst32 {
 16419				break
 16420			}
 16421			c := v_1_0.AuxInt
 16422			v_1_1 := v_1.Args[1]
 16423			if v_1_1.Op != OpSub32 {
 16424				break
 16425			}
 16426			_ = v_1_1.Args[1]
 16427			v_1_1_0 := v_1_1.Args[0]
 16428			if v_1_1_0.Op != OpRsh64x64 {
 16429				break
 16430			}
 16431			_ = v_1_1_0.Args[1]
 16432			mul := v_1_1_0.Args[0]
 16433			if mul.Op != OpMul64 {
 16434				break
 16435			}
 16436			_ = mul.Args[1]
 16437			mul_0 := mul.Args[0]
 16438			if mul_0.Op != OpConst64 {
 16439				break
 16440			}
 16441			m := mul_0.AuxInt
 16442			mul_1 := mul.Args[1]
 16443			if mul_1.Op != OpSignExt32to64 {
 16444				break
 16445			}
 16446			if x != mul_1.Args[0] {
 16447				break
 16448			}
 16449			v_1_1_0_1 := v_1_1_0.Args[1]
 16450			if v_1_1_0_1.Op != OpConst64 {
 16451				break
 16452			}
 16453			s := v_1_1_0_1.AuxInt
 16454			v_1_1_1 := v_1_1.Args[1]
 16455			if v_1_1_1.Op != OpRsh64x64 {
 16456				break
 16457			}
 16458			_ = v_1_1_1.Args[1]
 16459			v_1_1_1_0 := v_1_1_1.Args[0]
 16460			if v_1_1_1_0.Op != OpSignExt32to64 {
 16461				break
 16462			}
 16463			if x != v_1_1_1_0.Args[0] {
 16464				break
 16465			}
 16466			v_1_1_1_1 := v_1_1_1.Args[1]
 16467			if v_1_1_1_1.Op != OpConst64 {
 16468				break
 16469			}
 16470			if v_1_1_1_1.AuxInt != 63 {
 16471				break
 16472			}
 16473			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(32, c).m) && s == 32+smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) {
 16474				break
 16475			}
 16476			v.reset(OpLeq32U)
 16477			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 16478			v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
 16479			v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 16480			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16481			v3.AuxInt = int64(int32(sdivisible(32, c).m))
 16482			v2.AddArg(v3)
 16483			v2.AddArg(x)
 16484			v1.AddArg(v2)
 16485			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16486			v4.AuxInt = int64(int32(sdivisible(32, c).a))
 16487			v1.AddArg(v4)
 16488			v0.AddArg(v1)
 16489			v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16490			v5.AuxInt = int64(32 - sdivisible(32, c).k)
 16491			v0.AddArg(v5)
 16492			v.AddArg(v0)
 16493			v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16494			v6.AuxInt = int64(int32(sdivisible(32, c).max))
 16495			v.AddArg(v6)
 16496			return true
 16497		}
 16498		// match: (Eq32 x (Mul32 (Const32 [c]) (Sub32 (Rsh64x64 mul:(Mul64 (SignExt32to64 x) (Const64 [m])) (Const64 [s])) (Rsh64x64 (SignExt32to64 x) (Const64 [63])))))
 16499		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(32,c).m) && s == 32+smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c)
 16500		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) )
 16501		for {
 16502			_ = v.Args[1]
 16503			x := v.Args[0]
 16504			v_1 := v.Args[1]
 16505			if v_1.Op != OpMul32 {
 16506				break
 16507			}
 16508			_ = v_1.Args[1]
 16509			v_1_0 := v_1.Args[0]
 16510			if v_1_0.Op != OpConst32 {
 16511				break
 16512			}
 16513			c := v_1_0.AuxInt
 16514			v_1_1 := v_1.Args[1]
 16515			if v_1_1.Op != OpSub32 {
 16516				break
 16517			}
 16518			_ = v_1_1.Args[1]
 16519			v_1_1_0 := v_1_1.Args[0]
 16520			if v_1_1_0.Op != OpRsh64x64 {
 16521				break
 16522			}
 16523			_ = v_1_1_0.Args[1]
 16524			mul := v_1_1_0.Args[0]
 16525			if mul.Op != OpMul64 {
 16526				break
 16527			}
 16528			_ = mul.Args[1]
 16529			mul_0 := mul.Args[0]
 16530			if mul_0.Op != OpSignExt32to64 {
 16531				break
 16532			}
 16533			if x != mul_0.Args[0] {
 16534				break
 16535			}
 16536			mul_1 := mul.Args[1]
 16537			if mul_1.Op != OpConst64 {
 16538				break
 16539			}
 16540			m := mul_1.AuxInt
 16541			v_1_1_0_1 := v_1_1_0.Args[1]
 16542			if v_1_1_0_1.Op != OpConst64 {
 16543				break
 16544			}
 16545			s := v_1_1_0_1.AuxInt
 16546			v_1_1_1 := v_1_1.Args[1]
 16547			if v_1_1_1.Op != OpRsh64x64 {
 16548				break
 16549			}
 16550			_ = v_1_1_1.Args[1]
 16551			v_1_1_1_0 := v_1_1_1.Args[0]
 16552			if v_1_1_1_0.Op != OpSignExt32to64 {
 16553				break
 16554			}
 16555			if x != v_1_1_1_0.Args[0] {
 16556				break
 16557			}
 16558			v_1_1_1_1 := v_1_1_1.Args[1]
 16559			if v_1_1_1_1.Op != OpConst64 {
 16560				break
 16561			}
 16562			if v_1_1_1_1.AuxInt != 63 {
 16563				break
 16564			}
 16565			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(32, c).m) && s == 32+smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) {
 16566				break
 16567			}
 16568			v.reset(OpLeq32U)
 16569			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 16570			v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
 16571			v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 16572			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16573			v3.AuxInt = int64(int32(sdivisible(32, c).m))
 16574			v2.AddArg(v3)
 16575			v2.AddArg(x)
 16576			v1.AddArg(v2)
 16577			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16578			v4.AuxInt = int64(int32(sdivisible(32, c).a))
 16579			v1.AddArg(v4)
 16580			v0.AddArg(v1)
 16581			v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16582			v5.AuxInt = int64(32 - sdivisible(32, c).k)
 16583			v0.AddArg(v5)
 16584			v.AddArg(v0)
 16585			v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16586			v6.AuxInt = int64(int32(sdivisible(32, c).max))
 16587			v.AddArg(v6)
 16588			return true
 16589		}
 16590		// match: (Eq32 x (Mul32 (Sub32 (Rsh64x64 mul:(Mul64 (Const64 [m]) (SignExt32to64 x)) (Const64 [s])) (Rsh64x64 (SignExt32to64 x) (Const64 [63]))) (Const32 [c])))
 16591		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(32,c).m) && s == 32+smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c)
 16592		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) )
 16593		for {
 16594			_ = v.Args[1]
 16595			x := v.Args[0]
 16596			v_1 := v.Args[1]
 16597			if v_1.Op != OpMul32 {
 16598				break
 16599			}
 16600			_ = v_1.Args[1]
 16601			v_1_0 := v_1.Args[0]
 16602			if v_1_0.Op != OpSub32 {
 16603				break
 16604			}
 16605			_ = v_1_0.Args[1]
 16606			v_1_0_0 := v_1_0.Args[0]
 16607			if v_1_0_0.Op != OpRsh64x64 {
 16608				break
 16609			}
 16610			_ = v_1_0_0.Args[1]
 16611			mul := v_1_0_0.Args[0]
 16612			if mul.Op != OpMul64 {
 16613				break
 16614			}
 16615			_ = mul.Args[1]
 16616			mul_0 := mul.Args[0]
 16617			if mul_0.Op != OpConst64 {
 16618				break
 16619			}
 16620			m := mul_0.AuxInt
 16621			mul_1 := mul.Args[1]
 16622			if mul_1.Op != OpSignExt32to64 {
 16623				break
 16624			}
 16625			if x != mul_1.Args[0] {
 16626				break
 16627			}
 16628			v_1_0_0_1 := v_1_0_0.Args[1]
 16629			if v_1_0_0_1.Op != OpConst64 {
 16630				break
 16631			}
 16632			s := v_1_0_0_1.AuxInt
 16633			v_1_0_1 := v_1_0.Args[1]
 16634			if v_1_0_1.Op != OpRsh64x64 {
 16635				break
 16636			}
 16637			_ = v_1_0_1.Args[1]
 16638			v_1_0_1_0 := v_1_0_1.Args[0]
 16639			if v_1_0_1_0.Op != OpSignExt32to64 {
 16640				break
 16641			}
 16642			if x != v_1_0_1_0.Args[0] {
 16643				break
 16644			}
 16645			v_1_0_1_1 := v_1_0_1.Args[1]
 16646			if v_1_0_1_1.Op != OpConst64 {
 16647				break
 16648			}
 16649			if v_1_0_1_1.AuxInt != 63 {
 16650				break
 16651			}
 16652			v_1_1 := v_1.Args[1]
 16653			if v_1_1.Op != OpConst32 {
 16654				break
 16655			}
 16656			c := v_1_1.AuxInt
 16657			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(32, c).m) && s == 32+smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) {
 16658				break
 16659			}
 16660			v.reset(OpLeq32U)
 16661			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 16662			v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
 16663			v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 16664			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16665			v3.AuxInt = int64(int32(sdivisible(32, c).m))
 16666			v2.AddArg(v3)
 16667			v2.AddArg(x)
 16668			v1.AddArg(v2)
 16669			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16670			v4.AuxInt = int64(int32(sdivisible(32, c).a))
 16671			v1.AddArg(v4)
 16672			v0.AddArg(v1)
 16673			v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16674			v5.AuxInt = int64(32 - sdivisible(32, c).k)
 16675			v0.AddArg(v5)
 16676			v.AddArg(v0)
 16677			v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16678			v6.AuxInt = int64(int32(sdivisible(32, c).max))
 16679			v.AddArg(v6)
 16680			return true
 16681		}
 16682		// match: (Eq32 x (Mul32 (Sub32 (Rsh64x64 mul:(Mul64 (SignExt32to64 x) (Const64 [m])) (Const64 [s])) (Rsh64x64 (SignExt32to64 x) (Const64 [63]))) (Const32 [c])))
 16683		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(32,c).m) && s == 32+smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c)
 16684		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) )
 16685		for {
 16686			_ = v.Args[1]
 16687			x := v.Args[0]
 16688			v_1 := v.Args[1]
 16689			if v_1.Op != OpMul32 {
 16690				break
 16691			}
 16692			_ = v_1.Args[1]
 16693			v_1_0 := v_1.Args[0]
 16694			if v_1_0.Op != OpSub32 {
 16695				break
 16696			}
 16697			_ = v_1_0.Args[1]
 16698			v_1_0_0 := v_1_0.Args[0]
 16699			if v_1_0_0.Op != OpRsh64x64 {
 16700				break
 16701			}
 16702			_ = v_1_0_0.Args[1]
 16703			mul := v_1_0_0.Args[0]
 16704			if mul.Op != OpMul64 {
 16705				break
 16706			}
 16707			_ = mul.Args[1]
 16708			mul_0 := mul.Args[0]
 16709			if mul_0.Op != OpSignExt32to64 {
 16710				break
 16711			}
 16712			if x != mul_0.Args[0] {
 16713				break
 16714			}
 16715			mul_1 := mul.Args[1]
 16716			if mul_1.Op != OpConst64 {
 16717				break
 16718			}
 16719			m := mul_1.AuxInt
 16720			v_1_0_0_1 := v_1_0_0.Args[1]
 16721			if v_1_0_0_1.Op != OpConst64 {
 16722				break
 16723			}
 16724			s := v_1_0_0_1.AuxInt
 16725			v_1_0_1 := v_1_0.Args[1]
 16726			if v_1_0_1.Op != OpRsh64x64 {
 16727				break
 16728			}
 16729			_ = v_1_0_1.Args[1]
 16730			v_1_0_1_0 := v_1_0_1.Args[0]
 16731			if v_1_0_1_0.Op != OpSignExt32to64 {
 16732				break
 16733			}
 16734			if x != v_1_0_1_0.Args[0] {
 16735				break
 16736			}
 16737			v_1_0_1_1 := v_1_0_1.Args[1]
 16738			if v_1_0_1_1.Op != OpConst64 {
 16739				break
 16740			}
 16741			if v_1_0_1_1.AuxInt != 63 {
 16742				break
 16743			}
 16744			v_1_1 := v_1.Args[1]
 16745			if v_1_1.Op != OpConst32 {
 16746				break
 16747			}
 16748			c := v_1_1.AuxInt
 16749			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(32, c).m) && s == 32+smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) {
 16750				break
 16751			}
 16752			v.reset(OpLeq32U)
 16753			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 16754			v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
 16755			v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 16756			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16757			v3.AuxInt = int64(int32(sdivisible(32, c).m))
 16758			v2.AddArg(v3)
 16759			v2.AddArg(x)
 16760			v1.AddArg(v2)
 16761			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16762			v4.AuxInt = int64(int32(sdivisible(32, c).a))
 16763			v1.AddArg(v4)
 16764			v0.AddArg(v1)
 16765			v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16766			v5.AuxInt = int64(32 - sdivisible(32, c).k)
 16767			v0.AddArg(v5)
 16768			v.AddArg(v0)
 16769			v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16770			v6.AuxInt = int64(int32(sdivisible(32, c).max))
 16771			v.AddArg(v6)
 16772			return true
 16773		}
 16774		// match: (Eq32 (Mul32 (Const32 [c]) (Sub32 (Rsh64x64 mul:(Mul64 (Const64 [m]) (SignExt32to64 x)) (Const64 [s])) (Rsh64x64 (SignExt32to64 x) (Const64 [63])))) x)
 16775		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(32,c).m) && s == 32+smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c)
 16776		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) )
 16777		for {
 16778			x := v.Args[1]
 16779			v_0 := v.Args[0]
 16780			if v_0.Op != OpMul32 {
 16781				break
 16782			}
 16783			_ = v_0.Args[1]
 16784			v_0_0 := v_0.Args[0]
 16785			if v_0_0.Op != OpConst32 {
 16786				break
 16787			}
 16788			c := v_0_0.AuxInt
 16789			v_0_1 := v_0.Args[1]
 16790			if v_0_1.Op != OpSub32 {
 16791				break
 16792			}
 16793			_ = v_0_1.Args[1]
 16794			v_0_1_0 := v_0_1.Args[0]
 16795			if v_0_1_0.Op != OpRsh64x64 {
 16796				break
 16797			}
 16798			_ = v_0_1_0.Args[1]
 16799			mul := v_0_1_0.Args[0]
 16800			if mul.Op != OpMul64 {
 16801				break
 16802			}
 16803			_ = mul.Args[1]
 16804			mul_0 := mul.Args[0]
 16805			if mul_0.Op != OpConst64 {
 16806				break
 16807			}
 16808			m := mul_0.AuxInt
 16809			mul_1 := mul.Args[1]
 16810			if mul_1.Op != OpSignExt32to64 {
 16811				break
 16812			}
 16813			if x != mul_1.Args[0] {
 16814				break
 16815			}
 16816			v_0_1_0_1 := v_0_1_0.Args[1]
 16817			if v_0_1_0_1.Op != OpConst64 {
 16818				break
 16819			}
 16820			s := v_0_1_0_1.AuxInt
 16821			v_0_1_1 := v_0_1.Args[1]
 16822			if v_0_1_1.Op != OpRsh64x64 {
 16823				break
 16824			}
 16825			_ = v_0_1_1.Args[1]
 16826			v_0_1_1_0 := v_0_1_1.Args[0]
 16827			if v_0_1_1_0.Op != OpSignExt32to64 {
 16828				break
 16829			}
 16830			if x != v_0_1_1_0.Args[0] {
 16831				break
 16832			}
 16833			v_0_1_1_1 := v_0_1_1.Args[1]
 16834			if v_0_1_1_1.Op != OpConst64 {
 16835				break
 16836			}
 16837			if v_0_1_1_1.AuxInt != 63 {
 16838				break
 16839			}
 16840			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(32, c).m) && s == 32+smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) {
 16841				break
 16842			}
 16843			v.reset(OpLeq32U)
 16844			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 16845			v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
 16846			v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 16847			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16848			v3.AuxInt = int64(int32(sdivisible(32, c).m))
 16849			v2.AddArg(v3)
 16850			v2.AddArg(x)
 16851			v1.AddArg(v2)
 16852			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16853			v4.AuxInt = int64(int32(sdivisible(32, c).a))
 16854			v1.AddArg(v4)
 16855			v0.AddArg(v1)
 16856			v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16857			v5.AuxInt = int64(32 - sdivisible(32, c).k)
 16858			v0.AddArg(v5)
 16859			v.AddArg(v0)
 16860			v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16861			v6.AuxInt = int64(int32(sdivisible(32, c).max))
 16862			v.AddArg(v6)
 16863			return true
 16864		}
 16865		return false
 16866	}
 16867	func rewriteValuegeneric_OpEq32_60(v *Value) bool {
 16868		b := v.Block
 16869		typ := &b.Func.Config.Types
 16870		// match: (Eq32 (Mul32 (Const32 [c]) (Sub32 (Rsh64x64 mul:(Mul64 (SignExt32to64 x) (Const64 [m])) (Const64 [s])) (Rsh64x64 (SignExt32to64 x) (Const64 [63])))) x)
 16871		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(32,c).m) && s == 32+smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c)
 16872		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) )
 16873		for {
 16874			x := v.Args[1]
 16875			v_0 := v.Args[0]
 16876			if v_0.Op != OpMul32 {
 16877				break
 16878			}
 16879			_ = v_0.Args[1]
 16880			v_0_0 := v_0.Args[0]
 16881			if v_0_0.Op != OpConst32 {
 16882				break
 16883			}
 16884			c := v_0_0.AuxInt
 16885			v_0_1 := v_0.Args[1]
 16886			if v_0_1.Op != OpSub32 {
 16887				break
 16888			}
 16889			_ = v_0_1.Args[1]
 16890			v_0_1_0 := v_0_1.Args[0]
 16891			if v_0_1_0.Op != OpRsh64x64 {
 16892				break
 16893			}
 16894			_ = v_0_1_0.Args[1]
 16895			mul := v_0_1_0.Args[0]
 16896			if mul.Op != OpMul64 {
 16897				break
 16898			}
 16899			_ = mul.Args[1]
 16900			mul_0 := mul.Args[0]
 16901			if mul_0.Op != OpSignExt32to64 {
 16902				break
 16903			}
 16904			if x != mul_0.Args[0] {
 16905				break
 16906			}
 16907			mul_1 := mul.Args[1]
 16908			if mul_1.Op != OpConst64 {
 16909				break
 16910			}
 16911			m := mul_1.AuxInt
 16912			v_0_1_0_1 := v_0_1_0.Args[1]
 16913			if v_0_1_0_1.Op != OpConst64 {
 16914				break
 16915			}
 16916			s := v_0_1_0_1.AuxInt
 16917			v_0_1_1 := v_0_1.Args[1]
 16918			if v_0_1_1.Op != OpRsh64x64 {
 16919				break
 16920			}
 16921			_ = v_0_1_1.Args[1]
 16922			v_0_1_1_0 := v_0_1_1.Args[0]
 16923			if v_0_1_1_0.Op != OpSignExt32to64 {
 16924				break
 16925			}
 16926			if x != v_0_1_1_0.Args[0] {
 16927				break
 16928			}
 16929			v_0_1_1_1 := v_0_1_1.Args[1]
 16930			if v_0_1_1_1.Op != OpConst64 {
 16931				break
 16932			}
 16933			if v_0_1_1_1.AuxInt != 63 {
 16934				break
 16935			}
 16936			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(32, c).m) && s == 32+smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) {
 16937				break
 16938			}
 16939			v.reset(OpLeq32U)
 16940			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 16941			v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
 16942			v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 16943			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16944			v3.AuxInt = int64(int32(sdivisible(32, c).m))
 16945			v2.AddArg(v3)
 16946			v2.AddArg(x)
 16947			v1.AddArg(v2)
 16948			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16949			v4.AuxInt = int64(int32(sdivisible(32, c).a))
 16950			v1.AddArg(v4)
 16951			v0.AddArg(v1)
 16952			v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16953			v5.AuxInt = int64(32 - sdivisible(32, c).k)
 16954			v0.AddArg(v5)
 16955			v.AddArg(v0)
 16956			v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 16957			v6.AuxInt = int64(int32(sdivisible(32, c).max))
 16958			v.AddArg(v6)
 16959			return true
 16960		}
 16961		// match: (Eq32 (Mul32 (Sub32 (Rsh64x64 mul:(Mul64 (Const64 [m]) (SignExt32to64 x)) (Const64 [s])) (Rsh64x64 (SignExt32to64 x) (Const64 [63]))) (Const32 [c])) x)
 16962		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(32,c).m) && s == 32+smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c)
 16963		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) )
 16964		for {
 16965			x := v.Args[1]
 16966			v_0 := v.Args[0]
 16967			if v_0.Op != OpMul32 {
 16968				break
 16969			}
 16970			_ = v_0.Args[1]
 16971			v_0_0 := v_0.Args[0]
 16972			if v_0_0.Op != OpSub32 {
 16973				break
 16974			}
 16975			_ = v_0_0.Args[1]
 16976			v_0_0_0 := v_0_0.Args[0]
 16977			if v_0_0_0.Op != OpRsh64x64 {
 16978				break
 16979			}
 16980			_ = v_0_0_0.Args[1]
 16981			mul := v_0_0_0.Args[0]
 16982			if mul.Op != OpMul64 {
 16983				break
 16984			}
 16985			_ = mul.Args[1]
 16986			mul_0 := mul.Args[0]
 16987			if mul_0.Op != OpConst64 {
 16988				break
 16989			}
 16990			m := mul_0.AuxInt
 16991			mul_1 := mul.Args[1]
 16992			if mul_1.Op != OpSignExt32to64 {
 16993				break
 16994			}
 16995			if x != mul_1.Args[0] {
 16996				break
 16997			}
 16998			v_0_0_0_1 := v_0_0_0.Args[1]
 16999			if v_0_0_0_1.Op != OpConst64 {
 17000				break
 17001			}
 17002			s := v_0_0_0_1.AuxInt
 17003			v_0_0_1 := v_0_0.Args[1]
 17004			if v_0_0_1.Op != OpRsh64x64 {
 17005				break
 17006			}
 17007			_ = v_0_0_1.Args[1]
 17008			v_0_0_1_0 := v_0_0_1.Args[0]
 17009			if v_0_0_1_0.Op != OpSignExt32to64 {
 17010				break
 17011			}
 17012			if x != v_0_0_1_0.Args[0] {
 17013				break
 17014			}
 17015			v_0_0_1_1 := v_0_0_1.Args[1]
 17016			if v_0_0_1_1.Op != OpConst64 {
 17017				break
 17018			}
 17019			if v_0_0_1_1.AuxInt != 63 {
 17020				break
 17021			}
 17022			v_0_1 := v_0.Args[1]
 17023			if v_0_1.Op != OpConst32 {
 17024				break
 17025			}
 17026			c := v_0_1.AuxInt
 17027			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(32, c).m) && s == 32+smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) {
 17028				break
 17029			}
 17030			v.reset(OpLeq32U)
 17031			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 17032			v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
 17033			v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 17034			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17035			v3.AuxInt = int64(int32(sdivisible(32, c).m))
 17036			v2.AddArg(v3)
 17037			v2.AddArg(x)
 17038			v1.AddArg(v2)
 17039			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17040			v4.AuxInt = int64(int32(sdivisible(32, c).a))
 17041			v1.AddArg(v4)
 17042			v0.AddArg(v1)
 17043			v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17044			v5.AuxInt = int64(32 - sdivisible(32, c).k)
 17045			v0.AddArg(v5)
 17046			v.AddArg(v0)
 17047			v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17048			v6.AuxInt = int64(int32(sdivisible(32, c).max))
 17049			v.AddArg(v6)
 17050			return true
 17051		}
 17052		// match: (Eq32 (Mul32 (Sub32 (Rsh64x64 mul:(Mul64 (SignExt32to64 x) (Const64 [m])) (Const64 [s])) (Rsh64x64 (SignExt32to64 x) (Const64 [63]))) (Const32 [c])) x)
 17053		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(32,c).m) && s == 32+smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c)
 17054		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) )
 17055		for {
 17056			x := v.Args[1]
 17057			v_0 := v.Args[0]
 17058			if v_0.Op != OpMul32 {
 17059				break
 17060			}
 17061			_ = v_0.Args[1]
 17062			v_0_0 := v_0.Args[0]
 17063			if v_0_0.Op != OpSub32 {
 17064				break
 17065			}
 17066			_ = v_0_0.Args[1]
 17067			v_0_0_0 := v_0_0.Args[0]
 17068			if v_0_0_0.Op != OpRsh64x64 {
 17069				break
 17070			}
 17071			_ = v_0_0_0.Args[1]
 17072			mul := v_0_0_0.Args[0]
 17073			if mul.Op != OpMul64 {
 17074				break
 17075			}
 17076			_ = mul.Args[1]
 17077			mul_0 := mul.Args[0]
 17078			if mul_0.Op != OpSignExt32to64 {
 17079				break
 17080			}
 17081			if x != mul_0.Args[0] {
 17082				break
 17083			}
 17084			mul_1 := mul.Args[1]
 17085			if mul_1.Op != OpConst64 {
 17086				break
 17087			}
 17088			m := mul_1.AuxInt
 17089			v_0_0_0_1 := v_0_0_0.Args[1]
 17090			if v_0_0_0_1.Op != OpConst64 {
 17091				break
 17092			}
 17093			s := v_0_0_0_1.AuxInt
 17094			v_0_0_1 := v_0_0.Args[1]
 17095			if v_0_0_1.Op != OpRsh64x64 {
 17096				break
 17097			}
 17098			_ = v_0_0_1.Args[1]
 17099			v_0_0_1_0 := v_0_0_1.Args[0]
 17100			if v_0_0_1_0.Op != OpSignExt32to64 {
 17101				break
 17102			}
 17103			if x != v_0_0_1_0.Args[0] {
 17104				break
 17105			}
 17106			v_0_0_1_1 := v_0_0_1.Args[1]
 17107			if v_0_0_1_1.Op != OpConst64 {
 17108				break
 17109			}
 17110			if v_0_0_1_1.AuxInt != 63 {
 17111				break
 17112			}
 17113			v_0_1 := v_0.Args[1]
 17114			if v_0_1.Op != OpConst32 {
 17115				break
 17116			}
 17117			c := v_0_1.AuxInt
 17118			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(32, c).m) && s == 32+smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) {
 17119				break
 17120			}
 17121			v.reset(OpLeq32U)
 17122			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 17123			v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
 17124			v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 17125			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17126			v3.AuxInt = int64(int32(sdivisible(32, c).m))
 17127			v2.AddArg(v3)
 17128			v2.AddArg(x)
 17129			v1.AddArg(v2)
 17130			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17131			v4.AuxInt = int64(int32(sdivisible(32, c).a))
 17132			v1.AddArg(v4)
 17133			v0.AddArg(v1)
 17134			v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17135			v5.AuxInt = int64(32 - sdivisible(32, c).k)
 17136			v0.AddArg(v5)
 17137			v.AddArg(v0)
 17138			v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17139			v6.AuxInt = int64(int32(sdivisible(32, c).max))
 17140			v.AddArg(v6)
 17141			return true
 17142		}
 17143		// match: (Eq32 x (Mul32 (Const32 [c]) (Sub32 (Rsh32x64 mul:(Hmul32 (Const32 [m]) x) (Const64 [s])) (Rsh32x64 x (Const64 [31])))))
 17144		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m/2)) && s == smagic(32,c).s-1 && x.Op != OpConst32 && sdivisibleOK(32,c)
 17145		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) )
 17146		for {
 17147			_ = v.Args[1]
 17148			x := v.Args[0]
 17149			v_1 := v.Args[1]
 17150			if v_1.Op != OpMul32 {
 17151				break
 17152			}
 17153			_ = v_1.Args[1]
 17154			v_1_0 := v_1.Args[0]
 17155			if v_1_0.Op != OpConst32 {
 17156				break
 17157			}
 17158			c := v_1_0.AuxInt
 17159			v_1_1 := v_1.Args[1]
 17160			if v_1_1.Op != OpSub32 {
 17161				break
 17162			}
 17163			_ = v_1_1.Args[1]
 17164			v_1_1_0 := v_1_1.Args[0]
 17165			if v_1_1_0.Op != OpRsh32x64 {
 17166				break
 17167			}
 17168			_ = v_1_1_0.Args[1]
 17169			mul := v_1_1_0.Args[0]
 17170			if mul.Op != OpHmul32 {
 17171				break
 17172			}
 17173			_ = mul.Args[1]
 17174			mul_0 := mul.Args[0]
 17175			if mul_0.Op != OpConst32 {
 17176				break
 17177			}
 17178			m := mul_0.AuxInt
 17179			if x != mul.Args[1] {
 17180				break
 17181			}
 17182			v_1_1_0_1 := v_1_1_0.Args[1]
 17183			if v_1_1_0_1.Op != OpConst64 {
 17184				break
 17185			}
 17186			s := v_1_1_0_1.AuxInt
 17187			v_1_1_1 := v_1_1.Args[1]
 17188			if v_1_1_1.Op != OpRsh32x64 {
 17189				break
 17190			}
 17191			_ = v_1_1_1.Args[1]
 17192			if x != v_1_1_1.Args[0] {
 17193				break
 17194			}
 17195			v_1_1_1_1 := v_1_1_1.Args[1]
 17196			if v_1_1_1_1.Op != OpConst64 {
 17197				break
 17198			}
 17199			if v_1_1_1_1.AuxInt != 31 {
 17200				break
 17201			}
 17202			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m/2)) && s == smagic(32, c).s-1 && x.Op != OpConst32 && sdivisibleOK(32, c)) {
 17203				break
 17204			}
 17205			v.reset(OpLeq32U)
 17206			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 17207			v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
 17208			v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 17209			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17210			v3.AuxInt = int64(int32(sdivisible(32, c).m))
 17211			v2.AddArg(v3)
 17212			v2.AddArg(x)
 17213			v1.AddArg(v2)
 17214			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17215			v4.AuxInt = int64(int32(sdivisible(32, c).a))
 17216			v1.AddArg(v4)
 17217			v0.AddArg(v1)
 17218			v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17219			v5.AuxInt = int64(32 - sdivisible(32, c).k)
 17220			v0.AddArg(v5)
 17221			v.AddArg(v0)
 17222			v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17223			v6.AuxInt = int64(int32(sdivisible(32, c).max))
 17224			v.AddArg(v6)
 17225			return true
 17226		}
 17227		// match: (Eq32 x (Mul32 (Const32 [c]) (Sub32 (Rsh32x64 mul:(Hmul32 x (Const32 [m])) (Const64 [s])) (Rsh32x64 x (Const64 [31])))))
 17228		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m/2)) && s == smagic(32,c).s-1 && x.Op != OpConst32 && sdivisibleOK(32,c)
 17229		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) )
 17230		for {
 17231			_ = v.Args[1]
 17232			x := v.Args[0]
 17233			v_1 := v.Args[1]
 17234			if v_1.Op != OpMul32 {
 17235				break
 17236			}
 17237			_ = v_1.Args[1]
 17238			v_1_0 := v_1.Args[0]
 17239			if v_1_0.Op != OpConst32 {
 17240				break
 17241			}
 17242			c := v_1_0.AuxInt
 17243			v_1_1 := v_1.Args[1]
 17244			if v_1_1.Op != OpSub32 {
 17245				break
 17246			}
 17247			_ = v_1_1.Args[1]
 17248			v_1_1_0 := v_1_1.Args[0]
 17249			if v_1_1_0.Op != OpRsh32x64 {
 17250				break
 17251			}
 17252			_ = v_1_1_0.Args[1]
 17253			mul := v_1_1_0.Args[0]
 17254			if mul.Op != OpHmul32 {
 17255				break
 17256			}
 17257			_ = mul.Args[1]
 17258			if x != mul.Args[0] {
 17259				break
 17260			}
 17261			mul_1 := mul.Args[1]
 17262			if mul_1.Op != OpConst32 {
 17263				break
 17264			}
 17265			m := mul_1.AuxInt
 17266			v_1_1_0_1 := v_1_1_0.Args[1]
 17267			if v_1_1_0_1.Op != OpConst64 {
 17268				break
 17269			}
 17270			s := v_1_1_0_1.AuxInt
 17271			v_1_1_1 := v_1_1.Args[1]
 17272			if v_1_1_1.Op != OpRsh32x64 {
 17273				break
 17274			}
 17275			_ = v_1_1_1.Args[1]
 17276			if x != v_1_1_1.Args[0] {
 17277				break
 17278			}
 17279			v_1_1_1_1 := v_1_1_1.Args[1]
 17280			if v_1_1_1_1.Op != OpConst64 {
 17281				break
 17282			}
 17283			if v_1_1_1_1.AuxInt != 31 {
 17284				break
 17285			}
 17286			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m/2)) && s == smagic(32, c).s-1 && x.Op != OpConst32 && sdivisibleOK(32, c)) {
 17287				break
 17288			}
 17289			v.reset(OpLeq32U)
 17290			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 17291			v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
 17292			v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 17293			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17294			v3.AuxInt = int64(int32(sdivisible(32, c).m))
 17295			v2.AddArg(v3)
 17296			v2.AddArg(x)
 17297			v1.AddArg(v2)
 17298			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17299			v4.AuxInt = int64(int32(sdivisible(32, c).a))
 17300			v1.AddArg(v4)
 17301			v0.AddArg(v1)
 17302			v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17303			v5.AuxInt = int64(32 - sdivisible(32, c).k)
 17304			v0.AddArg(v5)
 17305			v.AddArg(v0)
 17306			v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17307			v6.AuxInt = int64(int32(sdivisible(32, c).max))
 17308			v.AddArg(v6)
 17309			return true
 17310		}
 17311		// match: (Eq32 x (Mul32 (Sub32 (Rsh32x64 mul:(Hmul32 (Const32 [m]) x) (Const64 [s])) (Rsh32x64 x (Const64 [31]))) (Const32 [c])))
 17312		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m/2)) && s == smagic(32,c).s-1 && x.Op != OpConst32 && sdivisibleOK(32,c)
 17313		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) )
 17314		for {
 17315			_ = v.Args[1]
 17316			x := v.Args[0]
 17317			v_1 := v.Args[1]
 17318			if v_1.Op != OpMul32 {
 17319				break
 17320			}
 17321			_ = v_1.Args[1]
 17322			v_1_0 := v_1.Args[0]
 17323			if v_1_0.Op != OpSub32 {
 17324				break
 17325			}
 17326			_ = v_1_0.Args[1]
 17327			v_1_0_0 := v_1_0.Args[0]
 17328			if v_1_0_0.Op != OpRsh32x64 {
 17329				break
 17330			}
 17331			_ = v_1_0_0.Args[1]
 17332			mul := v_1_0_0.Args[0]
 17333			if mul.Op != OpHmul32 {
 17334				break
 17335			}
 17336			_ = mul.Args[1]
 17337			mul_0 := mul.Args[0]
 17338			if mul_0.Op != OpConst32 {
 17339				break
 17340			}
 17341			m := mul_0.AuxInt
 17342			if x != mul.Args[1] {
 17343				break
 17344			}
 17345			v_1_0_0_1 := v_1_0_0.Args[1]
 17346			if v_1_0_0_1.Op != OpConst64 {
 17347				break
 17348			}
 17349			s := v_1_0_0_1.AuxInt
 17350			v_1_0_1 := v_1_0.Args[1]
 17351			if v_1_0_1.Op != OpRsh32x64 {
 17352				break
 17353			}
 17354			_ = v_1_0_1.Args[1]
 17355			if x != v_1_0_1.Args[0] {
 17356				break
 17357			}
 17358			v_1_0_1_1 := v_1_0_1.Args[1]
 17359			if v_1_0_1_1.Op != OpConst64 {
 17360				break
 17361			}
 17362			if v_1_0_1_1.AuxInt != 31 {
 17363				break
 17364			}
 17365			v_1_1 := v_1.Args[1]
 17366			if v_1_1.Op != OpConst32 {
 17367				break
 17368			}
 17369			c := v_1_1.AuxInt
 17370			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m/2)) && s == smagic(32, c).s-1 && x.Op != OpConst32 && sdivisibleOK(32, c)) {
 17371				break
 17372			}
 17373			v.reset(OpLeq32U)
 17374			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 17375			v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
 17376			v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 17377			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17378			v3.AuxInt = int64(int32(sdivisible(32, c).m))
 17379			v2.AddArg(v3)
 17380			v2.AddArg(x)
 17381			v1.AddArg(v2)
 17382			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17383			v4.AuxInt = int64(int32(sdivisible(32, c).a))
 17384			v1.AddArg(v4)
 17385			v0.AddArg(v1)
 17386			v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17387			v5.AuxInt = int64(32 - sdivisible(32, c).k)
 17388			v0.AddArg(v5)
 17389			v.AddArg(v0)
 17390			v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17391			v6.AuxInt = int64(int32(sdivisible(32, c).max))
 17392			v.AddArg(v6)
 17393			return true
 17394		}
 17395		// match: (Eq32 x (Mul32 (Sub32 (Rsh32x64 mul:(Hmul32 x (Const32 [m])) (Const64 [s])) (Rsh32x64 x (Const64 [31]))) (Const32 [c])))
 17396		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m/2)) && s == smagic(32,c).s-1 && x.Op != OpConst32 && sdivisibleOK(32,c)
 17397		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) )
 17398		for {
 17399			_ = v.Args[1]
 17400			x := v.Args[0]
 17401			v_1 := v.Args[1]
 17402			if v_1.Op != OpMul32 {
 17403				break
 17404			}
 17405			_ = v_1.Args[1]
 17406			v_1_0 := v_1.Args[0]
 17407			if v_1_0.Op != OpSub32 {
 17408				break
 17409			}
 17410			_ = v_1_0.Args[1]
 17411			v_1_0_0 := v_1_0.Args[0]
 17412			if v_1_0_0.Op != OpRsh32x64 {
 17413				break
 17414			}
 17415			_ = v_1_0_0.Args[1]
 17416			mul := v_1_0_0.Args[0]
 17417			if mul.Op != OpHmul32 {
 17418				break
 17419			}
 17420			_ = mul.Args[1]
 17421			if x != mul.Args[0] {
 17422				break
 17423			}
 17424			mul_1 := mul.Args[1]
 17425			if mul_1.Op != OpConst32 {
 17426				break
 17427			}
 17428			m := mul_1.AuxInt
 17429			v_1_0_0_1 := v_1_0_0.Args[1]
 17430			if v_1_0_0_1.Op != OpConst64 {
 17431				break
 17432			}
 17433			s := v_1_0_0_1.AuxInt
 17434			v_1_0_1 := v_1_0.Args[1]
 17435			if v_1_0_1.Op != OpRsh32x64 {
 17436				break
 17437			}
 17438			_ = v_1_0_1.Args[1]
 17439			if x != v_1_0_1.Args[0] {
 17440				break
 17441			}
 17442			v_1_0_1_1 := v_1_0_1.Args[1]
 17443			if v_1_0_1_1.Op != OpConst64 {
 17444				break
 17445			}
 17446			if v_1_0_1_1.AuxInt != 31 {
 17447				break
 17448			}
 17449			v_1_1 := v_1.Args[1]
 17450			if v_1_1.Op != OpConst32 {
 17451				break
 17452			}
 17453			c := v_1_1.AuxInt
 17454			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m/2)) && s == smagic(32, c).s-1 && x.Op != OpConst32 && sdivisibleOK(32, c)) {
 17455				break
 17456			}
 17457			v.reset(OpLeq32U)
 17458			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 17459			v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
 17460			v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 17461			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17462			v3.AuxInt = int64(int32(sdivisible(32, c).m))
 17463			v2.AddArg(v3)
 17464			v2.AddArg(x)
 17465			v1.AddArg(v2)
 17466			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17467			v4.AuxInt = int64(int32(sdivisible(32, c).a))
 17468			v1.AddArg(v4)
 17469			v0.AddArg(v1)
 17470			v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17471			v5.AuxInt = int64(32 - sdivisible(32, c).k)
 17472			v0.AddArg(v5)
 17473			v.AddArg(v0)
 17474			v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17475			v6.AuxInt = int64(int32(sdivisible(32, c).max))
 17476			v.AddArg(v6)
 17477			return true
 17478		}
 17479		// match: (Eq32 (Mul32 (Const32 [c]) (Sub32 (Rsh32x64 mul:(Hmul32 (Const32 [m]) x) (Const64 [s])) (Rsh32x64 x (Const64 [31])))) x)
 17480		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m/2)) && s == smagic(32,c).s-1 && x.Op != OpConst32 && sdivisibleOK(32,c)
 17481		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) )
 17482		for {
 17483			x := v.Args[1]
 17484			v_0 := v.Args[0]
 17485			if v_0.Op != OpMul32 {
 17486				break
 17487			}
 17488			_ = v_0.Args[1]
 17489			v_0_0 := v_0.Args[0]
 17490			if v_0_0.Op != OpConst32 {
 17491				break
 17492			}
 17493			c := v_0_0.AuxInt
 17494			v_0_1 := v_0.Args[1]
 17495			if v_0_1.Op != OpSub32 {
 17496				break
 17497			}
 17498			_ = v_0_1.Args[1]
 17499			v_0_1_0 := v_0_1.Args[0]
 17500			if v_0_1_0.Op != OpRsh32x64 {
 17501				break
 17502			}
 17503			_ = v_0_1_0.Args[1]
 17504			mul := v_0_1_0.Args[0]
 17505			if mul.Op != OpHmul32 {
 17506				break
 17507			}
 17508			_ = mul.Args[1]
 17509			mul_0 := mul.Args[0]
 17510			if mul_0.Op != OpConst32 {
 17511				break
 17512			}
 17513			m := mul_0.AuxInt
 17514			if x != mul.Args[1] {
 17515				break
 17516			}
 17517			v_0_1_0_1 := v_0_1_0.Args[1]
 17518			if v_0_1_0_1.Op != OpConst64 {
 17519				break
 17520			}
 17521			s := v_0_1_0_1.AuxInt
 17522			v_0_1_1 := v_0_1.Args[1]
 17523			if v_0_1_1.Op != OpRsh32x64 {
 17524				break
 17525			}
 17526			_ = v_0_1_1.Args[1]
 17527			if x != v_0_1_1.Args[0] {
 17528				break
 17529			}
 17530			v_0_1_1_1 := v_0_1_1.Args[1]
 17531			if v_0_1_1_1.Op != OpConst64 {
 17532				break
 17533			}
 17534			if v_0_1_1_1.AuxInt != 31 {
 17535				break
 17536			}
 17537			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m/2)) && s == smagic(32, c).s-1 && x.Op != OpConst32 && sdivisibleOK(32, c)) {
 17538				break
 17539			}
 17540			v.reset(OpLeq32U)
 17541			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 17542			v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
 17543			v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 17544			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17545			v3.AuxInt = int64(int32(sdivisible(32, c).m))
 17546			v2.AddArg(v3)
 17547			v2.AddArg(x)
 17548			v1.AddArg(v2)
 17549			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17550			v4.AuxInt = int64(int32(sdivisible(32, c).a))
 17551			v1.AddArg(v4)
 17552			v0.AddArg(v1)
 17553			v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17554			v5.AuxInt = int64(32 - sdivisible(32, c).k)
 17555			v0.AddArg(v5)
 17556			v.AddArg(v0)
 17557			v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17558			v6.AuxInt = int64(int32(sdivisible(32, c).max))
 17559			v.AddArg(v6)
 17560			return true
 17561		}
 17562		// match: (Eq32 (Mul32 (Const32 [c]) (Sub32 (Rsh32x64 mul:(Hmul32 x (Const32 [m])) (Const64 [s])) (Rsh32x64 x (Const64 [31])))) x)
 17563		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m/2)) && s == smagic(32,c).s-1 && x.Op != OpConst32 && sdivisibleOK(32,c)
 17564		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) )
 17565		for {
 17566			x := v.Args[1]
 17567			v_0 := v.Args[0]
 17568			if v_0.Op != OpMul32 {
 17569				break
 17570			}
 17571			_ = v_0.Args[1]
 17572			v_0_0 := v_0.Args[0]
 17573			if v_0_0.Op != OpConst32 {
 17574				break
 17575			}
 17576			c := v_0_0.AuxInt
 17577			v_0_1 := v_0.Args[1]
 17578			if v_0_1.Op != OpSub32 {
 17579				break
 17580			}
 17581			_ = v_0_1.Args[1]
 17582			v_0_1_0 := v_0_1.Args[0]
 17583			if v_0_1_0.Op != OpRsh32x64 {
 17584				break
 17585			}
 17586			_ = v_0_1_0.Args[1]
 17587			mul := v_0_1_0.Args[0]
 17588			if mul.Op != OpHmul32 {
 17589				break
 17590			}
 17591			_ = mul.Args[1]
 17592			if x != mul.Args[0] {
 17593				break
 17594			}
 17595			mul_1 := mul.Args[1]
 17596			if mul_1.Op != OpConst32 {
 17597				break
 17598			}
 17599			m := mul_1.AuxInt
 17600			v_0_1_0_1 := v_0_1_0.Args[1]
 17601			if v_0_1_0_1.Op != OpConst64 {
 17602				break
 17603			}
 17604			s := v_0_1_0_1.AuxInt
 17605			v_0_1_1 := v_0_1.Args[1]
 17606			if v_0_1_1.Op != OpRsh32x64 {
 17607				break
 17608			}
 17609			_ = v_0_1_1.Args[1]
 17610			if x != v_0_1_1.Args[0] {
 17611				break
 17612			}
 17613			v_0_1_1_1 := v_0_1_1.Args[1]
 17614			if v_0_1_1_1.Op != OpConst64 {
 17615				break
 17616			}
 17617			if v_0_1_1_1.AuxInt != 31 {
 17618				break
 17619			}
 17620			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m/2)) && s == smagic(32, c).s-1 && x.Op != OpConst32 && sdivisibleOK(32, c)) {
 17621				break
 17622			}
 17623			v.reset(OpLeq32U)
 17624			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 17625			v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
 17626			v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 17627			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17628			v3.AuxInt = int64(int32(sdivisible(32, c).m))
 17629			v2.AddArg(v3)
 17630			v2.AddArg(x)
 17631			v1.AddArg(v2)
 17632			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17633			v4.AuxInt = int64(int32(sdivisible(32, c).a))
 17634			v1.AddArg(v4)
 17635			v0.AddArg(v1)
 17636			v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17637			v5.AuxInt = int64(32 - sdivisible(32, c).k)
 17638			v0.AddArg(v5)
 17639			v.AddArg(v0)
 17640			v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17641			v6.AuxInt = int64(int32(sdivisible(32, c).max))
 17642			v.AddArg(v6)
 17643			return true
 17644		}
 17645		// match: (Eq32 (Mul32 (Sub32 (Rsh32x64 mul:(Hmul32 (Const32 [m]) x) (Const64 [s])) (Rsh32x64 x (Const64 [31]))) (Const32 [c])) x)
 17646		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m/2)) && s == smagic(32,c).s-1 && x.Op != OpConst32 && sdivisibleOK(32,c)
 17647		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) )
 17648		for {
 17649			x := v.Args[1]
 17650			v_0 := v.Args[0]
 17651			if v_0.Op != OpMul32 {
 17652				break
 17653			}
 17654			_ = v_0.Args[1]
 17655			v_0_0 := v_0.Args[0]
 17656			if v_0_0.Op != OpSub32 {
 17657				break
 17658			}
 17659			_ = v_0_0.Args[1]
 17660			v_0_0_0 := v_0_0.Args[0]
 17661			if v_0_0_0.Op != OpRsh32x64 {
 17662				break
 17663			}
 17664			_ = v_0_0_0.Args[1]
 17665			mul := v_0_0_0.Args[0]
 17666			if mul.Op != OpHmul32 {
 17667				break
 17668			}
 17669			_ = mul.Args[1]
 17670			mul_0 := mul.Args[0]
 17671			if mul_0.Op != OpConst32 {
 17672				break
 17673			}
 17674			m := mul_0.AuxInt
 17675			if x != mul.Args[1] {
 17676				break
 17677			}
 17678			v_0_0_0_1 := v_0_0_0.Args[1]
 17679			if v_0_0_0_1.Op != OpConst64 {
 17680				break
 17681			}
 17682			s := v_0_0_0_1.AuxInt
 17683			v_0_0_1 := v_0_0.Args[1]
 17684			if v_0_0_1.Op != OpRsh32x64 {
 17685				break
 17686			}
 17687			_ = v_0_0_1.Args[1]
 17688			if x != v_0_0_1.Args[0] {
 17689				break
 17690			}
 17691			v_0_0_1_1 := v_0_0_1.Args[1]
 17692			if v_0_0_1_1.Op != OpConst64 {
 17693				break
 17694			}
 17695			if v_0_0_1_1.AuxInt != 31 {
 17696				break
 17697			}
 17698			v_0_1 := v_0.Args[1]
 17699			if v_0_1.Op != OpConst32 {
 17700				break
 17701			}
 17702			c := v_0_1.AuxInt
 17703			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m/2)) && s == smagic(32, c).s-1 && x.Op != OpConst32 && sdivisibleOK(32, c)) {
 17704				break
 17705			}
 17706			v.reset(OpLeq32U)
 17707			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 17708			v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
 17709			v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 17710			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17711			v3.AuxInt = int64(int32(sdivisible(32, c).m))
 17712			v2.AddArg(v3)
 17713			v2.AddArg(x)
 17714			v1.AddArg(v2)
 17715			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17716			v4.AuxInt = int64(int32(sdivisible(32, c).a))
 17717			v1.AddArg(v4)
 17718			v0.AddArg(v1)
 17719			v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17720			v5.AuxInt = int64(32 - sdivisible(32, c).k)
 17721			v0.AddArg(v5)
 17722			v.AddArg(v0)
 17723			v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17724			v6.AuxInt = int64(int32(sdivisible(32, c).max))
 17725			v.AddArg(v6)
 17726			return true
 17727		}
 17728		return false
 17729	}
 17730	func rewriteValuegeneric_OpEq32_70(v *Value) bool {
 17731		b := v.Block
 17732		typ := &b.Func.Config.Types
 17733		// match: (Eq32 (Mul32 (Sub32 (Rsh32x64 mul:(Hmul32 x (Const32 [m])) (Const64 [s])) (Rsh32x64 x (Const64 [31]))) (Const32 [c])) x)
 17734		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m/2)) && s == smagic(32,c).s-1 && x.Op != OpConst32 && sdivisibleOK(32,c)
 17735		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) )
 17736		for {
 17737			x := v.Args[1]
 17738			v_0 := v.Args[0]
 17739			if v_0.Op != OpMul32 {
 17740				break
 17741			}
 17742			_ = v_0.Args[1]
 17743			v_0_0 := v_0.Args[0]
 17744			if v_0_0.Op != OpSub32 {
 17745				break
 17746			}
 17747			_ = v_0_0.Args[1]
 17748			v_0_0_0 := v_0_0.Args[0]
 17749			if v_0_0_0.Op != OpRsh32x64 {
 17750				break
 17751			}
 17752			_ = v_0_0_0.Args[1]
 17753			mul := v_0_0_0.Args[0]
 17754			if mul.Op != OpHmul32 {
 17755				break
 17756			}
 17757			_ = mul.Args[1]
 17758			if x != mul.Args[0] {
 17759				break
 17760			}
 17761			mul_1 := mul.Args[1]
 17762			if mul_1.Op != OpConst32 {
 17763				break
 17764			}
 17765			m := mul_1.AuxInt
 17766			v_0_0_0_1 := v_0_0_0.Args[1]
 17767			if v_0_0_0_1.Op != OpConst64 {
 17768				break
 17769			}
 17770			s := v_0_0_0_1.AuxInt
 17771			v_0_0_1 := v_0_0.Args[1]
 17772			if v_0_0_1.Op != OpRsh32x64 {
 17773				break
 17774			}
 17775			_ = v_0_0_1.Args[1]
 17776			if x != v_0_0_1.Args[0] {
 17777				break
 17778			}
 17779			v_0_0_1_1 := v_0_0_1.Args[1]
 17780			if v_0_0_1_1.Op != OpConst64 {
 17781				break
 17782			}
 17783			if v_0_0_1_1.AuxInt != 31 {
 17784				break
 17785			}
 17786			v_0_1 := v_0.Args[1]
 17787			if v_0_1.Op != OpConst32 {
 17788				break
 17789			}
 17790			c := v_0_1.AuxInt
 17791			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m/2)) && s == smagic(32, c).s-1 && x.Op != OpConst32 && sdivisibleOK(32, c)) {
 17792				break
 17793			}
 17794			v.reset(OpLeq32U)
 17795			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 17796			v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
 17797			v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 17798			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17799			v3.AuxInt = int64(int32(sdivisible(32, c).m))
 17800			v2.AddArg(v3)
 17801			v2.AddArg(x)
 17802			v1.AddArg(v2)
 17803			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17804			v4.AuxInt = int64(int32(sdivisible(32, c).a))
 17805			v1.AddArg(v4)
 17806			v0.AddArg(v1)
 17807			v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17808			v5.AuxInt = int64(32 - sdivisible(32, c).k)
 17809			v0.AddArg(v5)
 17810			v.AddArg(v0)
 17811			v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17812			v6.AuxInt = int64(int32(sdivisible(32, c).max))
 17813			v.AddArg(v6)
 17814			return true
 17815		}
 17816		// match: (Eq32 x (Mul32 (Const32 [c]) (Sub32 (Rsh32x64 (Add32 mul:(Hmul32 (Const32 [m]) x) x) (Const64 [s])) (Rsh32x64 x (Const64 [31])))))
 17817		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m)) && s == smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c)
 17818		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) )
 17819		for {
 17820			_ = v.Args[1]
 17821			x := v.Args[0]
 17822			v_1 := v.Args[1]
 17823			if v_1.Op != OpMul32 {
 17824				break
 17825			}
 17826			_ = v_1.Args[1]
 17827			v_1_0 := v_1.Args[0]
 17828			if v_1_0.Op != OpConst32 {
 17829				break
 17830			}
 17831			c := v_1_0.AuxInt
 17832			v_1_1 := v_1.Args[1]
 17833			if v_1_1.Op != OpSub32 {
 17834				break
 17835			}
 17836			_ = v_1_1.Args[1]
 17837			v_1_1_0 := v_1_1.Args[0]
 17838			if v_1_1_0.Op != OpRsh32x64 {
 17839				break
 17840			}
 17841			_ = v_1_1_0.Args[1]
 17842			v_1_1_0_0 := v_1_1_0.Args[0]
 17843			if v_1_1_0_0.Op != OpAdd32 {
 17844				break
 17845			}
 17846			_ = v_1_1_0_0.Args[1]
 17847			mul := v_1_1_0_0.Args[0]
 17848			if mul.Op != OpHmul32 {
 17849				break
 17850			}
 17851			_ = mul.Args[1]
 17852			mul_0 := mul.Args[0]
 17853			if mul_0.Op != OpConst32 {
 17854				break
 17855			}
 17856			m := mul_0.AuxInt
 17857			if x != mul.Args[1] {
 17858				break
 17859			}
 17860			if x != v_1_1_0_0.Args[1] {
 17861				break
 17862			}
 17863			v_1_1_0_1 := v_1_1_0.Args[1]
 17864			if v_1_1_0_1.Op != OpConst64 {
 17865				break
 17866			}
 17867			s := v_1_1_0_1.AuxInt
 17868			v_1_1_1 := v_1_1.Args[1]
 17869			if v_1_1_1.Op != OpRsh32x64 {
 17870				break
 17871			}
 17872			_ = v_1_1_1.Args[1]
 17873			if x != v_1_1_1.Args[0] {
 17874				break
 17875			}
 17876			v_1_1_1_1 := v_1_1_1.Args[1]
 17877			if v_1_1_1_1.Op != OpConst64 {
 17878				break
 17879			}
 17880			if v_1_1_1_1.AuxInt != 31 {
 17881				break
 17882			}
 17883			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m)) && s == smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) {
 17884				break
 17885			}
 17886			v.reset(OpLeq32U)
 17887			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 17888			v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
 17889			v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 17890			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17891			v3.AuxInt = int64(int32(sdivisible(32, c).m))
 17892			v2.AddArg(v3)
 17893			v2.AddArg(x)
 17894			v1.AddArg(v2)
 17895			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17896			v4.AuxInt = int64(int32(sdivisible(32, c).a))
 17897			v1.AddArg(v4)
 17898			v0.AddArg(v1)
 17899			v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17900			v5.AuxInt = int64(32 - sdivisible(32, c).k)
 17901			v0.AddArg(v5)
 17902			v.AddArg(v0)
 17903			v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17904			v6.AuxInt = int64(int32(sdivisible(32, c).max))
 17905			v.AddArg(v6)
 17906			return true
 17907		}
 17908		// match: (Eq32 x (Mul32 (Const32 [c]) (Sub32 (Rsh32x64 (Add32 mul:(Hmul32 x (Const32 [m])) x) (Const64 [s])) (Rsh32x64 x (Const64 [31])))))
 17909		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m)) && s == smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c)
 17910		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) )
 17911		for {
 17912			_ = v.Args[1]
 17913			x := v.Args[0]
 17914			v_1 := v.Args[1]
 17915			if v_1.Op != OpMul32 {
 17916				break
 17917			}
 17918			_ = v_1.Args[1]
 17919			v_1_0 := v_1.Args[0]
 17920			if v_1_0.Op != OpConst32 {
 17921				break
 17922			}
 17923			c := v_1_0.AuxInt
 17924			v_1_1 := v_1.Args[1]
 17925			if v_1_1.Op != OpSub32 {
 17926				break
 17927			}
 17928			_ = v_1_1.Args[1]
 17929			v_1_1_0 := v_1_1.Args[0]
 17930			if v_1_1_0.Op != OpRsh32x64 {
 17931				break
 17932			}
 17933			_ = v_1_1_0.Args[1]
 17934			v_1_1_0_0 := v_1_1_0.Args[0]
 17935			if v_1_1_0_0.Op != OpAdd32 {
 17936				break
 17937			}
 17938			_ = v_1_1_0_0.Args[1]
 17939			mul := v_1_1_0_0.Args[0]
 17940			if mul.Op != OpHmul32 {
 17941				break
 17942			}
 17943			_ = mul.Args[1]
 17944			if x != mul.Args[0] {
 17945				break
 17946			}
 17947			mul_1 := mul.Args[1]
 17948			if mul_1.Op != OpConst32 {
 17949				break
 17950			}
 17951			m := mul_1.AuxInt
 17952			if x != v_1_1_0_0.Args[1] {
 17953				break
 17954			}
 17955			v_1_1_0_1 := v_1_1_0.Args[1]
 17956			if v_1_1_0_1.Op != OpConst64 {
 17957				break
 17958			}
 17959			s := v_1_1_0_1.AuxInt
 17960			v_1_1_1 := v_1_1.Args[1]
 17961			if v_1_1_1.Op != OpRsh32x64 {
 17962				break
 17963			}
 17964			_ = v_1_1_1.Args[1]
 17965			if x != v_1_1_1.Args[0] {
 17966				break
 17967			}
 17968			v_1_1_1_1 := v_1_1_1.Args[1]
 17969			if v_1_1_1_1.Op != OpConst64 {
 17970				break
 17971			}
 17972			if v_1_1_1_1.AuxInt != 31 {
 17973				break
 17974			}
 17975			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m)) && s == smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) {
 17976				break
 17977			}
 17978			v.reset(OpLeq32U)
 17979			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 17980			v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
 17981			v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 17982			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17983			v3.AuxInt = int64(int32(sdivisible(32, c).m))
 17984			v2.AddArg(v3)
 17985			v2.AddArg(x)
 17986			v1.AddArg(v2)
 17987			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17988			v4.AuxInt = int64(int32(sdivisible(32, c).a))
 17989			v1.AddArg(v4)
 17990			v0.AddArg(v1)
 17991			v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17992			v5.AuxInt = int64(32 - sdivisible(32, c).k)
 17993			v0.AddArg(v5)
 17994			v.AddArg(v0)
 17995			v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 17996			v6.AuxInt = int64(int32(sdivisible(32, c).max))
 17997			v.AddArg(v6)
 17998			return true
 17999		}
 18000		// match: (Eq32 x (Mul32 (Const32 [c]) (Sub32 (Rsh32x64 (Add32 x mul:(Hmul32 (Const32 [m]) x)) (Const64 [s])) (Rsh32x64 x (Const64 [31])))))
 18001		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m)) && s == smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c)
 18002		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) )
 18003		for {
 18004			_ = v.Args[1]
 18005			x := v.Args[0]
 18006			v_1 := v.Args[1]
 18007			if v_1.Op != OpMul32 {
 18008				break
 18009			}
 18010			_ = v_1.Args[1]
 18011			v_1_0 := v_1.Args[0]
 18012			if v_1_0.Op != OpConst32 {
 18013				break
 18014			}
 18015			c := v_1_0.AuxInt
 18016			v_1_1 := v_1.Args[1]
 18017			if v_1_1.Op != OpSub32 {
 18018				break
 18019			}
 18020			_ = v_1_1.Args[1]
 18021			v_1_1_0 := v_1_1.Args[0]
 18022			if v_1_1_0.Op != OpRsh32x64 {
 18023				break
 18024			}
 18025			_ = v_1_1_0.Args[1]
 18026			v_1_1_0_0 := v_1_1_0.Args[0]
 18027			if v_1_1_0_0.Op != OpAdd32 {
 18028				break
 18029			}
 18030			_ = v_1_1_0_0.Args[1]
 18031			if x != v_1_1_0_0.Args[0] {
 18032				break
 18033			}
 18034			mul := v_1_1_0_0.Args[1]
 18035			if mul.Op != OpHmul32 {
 18036				break
 18037			}
 18038			_ = mul.Args[1]
 18039			mul_0 := mul.Args[0]
 18040			if mul_0.Op != OpConst32 {
 18041				break
 18042			}
 18043			m := mul_0.AuxInt
 18044			if x != mul.Args[1] {
 18045				break
 18046			}
 18047			v_1_1_0_1 := v_1_1_0.Args[1]
 18048			if v_1_1_0_1.Op != OpConst64 {
 18049				break
 18050			}
 18051			s := v_1_1_0_1.AuxInt
 18052			v_1_1_1 := v_1_1.Args[1]
 18053			if v_1_1_1.Op != OpRsh32x64 {
 18054				break
 18055			}
 18056			_ = v_1_1_1.Args[1]
 18057			if x != v_1_1_1.Args[0] {
 18058				break
 18059			}
 18060			v_1_1_1_1 := v_1_1_1.Args[1]
 18061			if v_1_1_1_1.Op != OpConst64 {
 18062				break
 18063			}
 18064			if v_1_1_1_1.AuxInt != 31 {
 18065				break
 18066			}
 18067			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m)) && s == smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) {
 18068				break
 18069			}
 18070			v.reset(OpLeq32U)
 18071			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 18072			v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
 18073			v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 18074			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18075			v3.AuxInt = int64(int32(sdivisible(32, c).m))
 18076			v2.AddArg(v3)
 18077			v2.AddArg(x)
 18078			v1.AddArg(v2)
 18079			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18080			v4.AuxInt = int64(int32(sdivisible(32, c).a))
 18081			v1.AddArg(v4)
 18082			v0.AddArg(v1)
 18083			v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18084			v5.AuxInt = int64(32 - sdivisible(32, c).k)
 18085			v0.AddArg(v5)
 18086			v.AddArg(v0)
 18087			v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18088			v6.AuxInt = int64(int32(sdivisible(32, c).max))
 18089			v.AddArg(v6)
 18090			return true
 18091		}
 18092		// match: (Eq32 x (Mul32 (Const32 [c]) (Sub32 (Rsh32x64 (Add32 x mul:(Hmul32 x (Const32 [m]))) (Const64 [s])) (Rsh32x64 x (Const64 [31])))))
 18093		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m)) && s == smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c)
 18094		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) )
 18095		for {
 18096			_ = v.Args[1]
 18097			x := v.Args[0]
 18098			v_1 := v.Args[1]
 18099			if v_1.Op != OpMul32 {
 18100				break
 18101			}
 18102			_ = v_1.Args[1]
 18103			v_1_0 := v_1.Args[0]
 18104			if v_1_0.Op != OpConst32 {
 18105				break
 18106			}
 18107			c := v_1_0.AuxInt
 18108			v_1_1 := v_1.Args[1]
 18109			if v_1_1.Op != OpSub32 {
 18110				break
 18111			}
 18112			_ = v_1_1.Args[1]
 18113			v_1_1_0 := v_1_1.Args[0]
 18114			if v_1_1_0.Op != OpRsh32x64 {
 18115				break
 18116			}
 18117			_ = v_1_1_0.Args[1]
 18118			v_1_1_0_0 := v_1_1_0.Args[0]
 18119			if v_1_1_0_0.Op != OpAdd32 {
 18120				break
 18121			}
 18122			_ = v_1_1_0_0.Args[1]
 18123			if x != v_1_1_0_0.Args[0] {
 18124				break
 18125			}
 18126			mul := v_1_1_0_0.Args[1]
 18127			if mul.Op != OpHmul32 {
 18128				break
 18129			}
 18130			_ = mul.Args[1]
 18131			if x != mul.Args[0] {
 18132				break
 18133			}
 18134			mul_1 := mul.Args[1]
 18135			if mul_1.Op != OpConst32 {
 18136				break
 18137			}
 18138			m := mul_1.AuxInt
 18139			v_1_1_0_1 := v_1_1_0.Args[1]
 18140			if v_1_1_0_1.Op != OpConst64 {
 18141				break
 18142			}
 18143			s := v_1_1_0_1.AuxInt
 18144			v_1_1_1 := v_1_1.Args[1]
 18145			if v_1_1_1.Op != OpRsh32x64 {
 18146				break
 18147			}
 18148			_ = v_1_1_1.Args[1]
 18149			if x != v_1_1_1.Args[0] {
 18150				break
 18151			}
 18152			v_1_1_1_1 := v_1_1_1.Args[1]
 18153			if v_1_1_1_1.Op != OpConst64 {
 18154				break
 18155			}
 18156			if v_1_1_1_1.AuxInt != 31 {
 18157				break
 18158			}
 18159			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m)) && s == smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) {
 18160				break
 18161			}
 18162			v.reset(OpLeq32U)
 18163			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 18164			v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
 18165			v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 18166			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18167			v3.AuxInt = int64(int32(sdivisible(32, c).m))
 18168			v2.AddArg(v3)
 18169			v2.AddArg(x)
 18170			v1.AddArg(v2)
 18171			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18172			v4.AuxInt = int64(int32(sdivisible(32, c).a))
 18173			v1.AddArg(v4)
 18174			v0.AddArg(v1)
 18175			v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18176			v5.AuxInt = int64(32 - sdivisible(32, c).k)
 18177			v0.AddArg(v5)
 18178			v.AddArg(v0)
 18179			v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18180			v6.AuxInt = int64(int32(sdivisible(32, c).max))
 18181			v.AddArg(v6)
 18182			return true
 18183		}
 18184		// match: (Eq32 x (Mul32 (Sub32 (Rsh32x64 (Add32 mul:(Hmul32 (Const32 [m]) x) x) (Const64 [s])) (Rsh32x64 x (Const64 [31]))) (Const32 [c])))
 18185		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m)) && s == smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c)
 18186		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) )
 18187		for {
 18188			_ = v.Args[1]
 18189			x := v.Args[0]
 18190			v_1 := v.Args[1]
 18191			if v_1.Op != OpMul32 {
 18192				break
 18193			}
 18194			_ = v_1.Args[1]
 18195			v_1_0 := v_1.Args[0]
 18196			if v_1_0.Op != OpSub32 {
 18197				break
 18198			}
 18199			_ = v_1_0.Args[1]
 18200			v_1_0_0 := v_1_0.Args[0]
 18201			if v_1_0_0.Op != OpRsh32x64 {
 18202				break
 18203			}
 18204			_ = v_1_0_0.Args[1]
 18205			v_1_0_0_0 := v_1_0_0.Args[0]
 18206			if v_1_0_0_0.Op != OpAdd32 {
 18207				break
 18208			}
 18209			_ = v_1_0_0_0.Args[1]
 18210			mul := v_1_0_0_0.Args[0]
 18211			if mul.Op != OpHmul32 {
 18212				break
 18213			}
 18214			_ = mul.Args[1]
 18215			mul_0 := mul.Args[0]
 18216			if mul_0.Op != OpConst32 {
 18217				break
 18218			}
 18219			m := mul_0.AuxInt
 18220			if x != mul.Args[1] {
 18221				break
 18222			}
 18223			if x != v_1_0_0_0.Args[1] {
 18224				break
 18225			}
 18226			v_1_0_0_1 := v_1_0_0.Args[1]
 18227			if v_1_0_0_1.Op != OpConst64 {
 18228				break
 18229			}
 18230			s := v_1_0_0_1.AuxInt
 18231			v_1_0_1 := v_1_0.Args[1]
 18232			if v_1_0_1.Op != OpRsh32x64 {
 18233				break
 18234			}
 18235			_ = v_1_0_1.Args[1]
 18236			if x != v_1_0_1.Args[0] {
 18237				break
 18238			}
 18239			v_1_0_1_1 := v_1_0_1.Args[1]
 18240			if v_1_0_1_1.Op != OpConst64 {
 18241				break
 18242			}
 18243			if v_1_0_1_1.AuxInt != 31 {
 18244				break
 18245			}
 18246			v_1_1 := v_1.Args[1]
 18247			if v_1_1.Op != OpConst32 {
 18248				break
 18249			}
 18250			c := v_1_1.AuxInt
 18251			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m)) && s == smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) {
 18252				break
 18253			}
 18254			v.reset(OpLeq32U)
 18255			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 18256			v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
 18257			v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 18258			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18259			v3.AuxInt = int64(int32(sdivisible(32, c).m))
 18260			v2.AddArg(v3)
 18261			v2.AddArg(x)
 18262			v1.AddArg(v2)
 18263			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18264			v4.AuxInt = int64(int32(sdivisible(32, c).a))
 18265			v1.AddArg(v4)
 18266			v0.AddArg(v1)
 18267			v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18268			v5.AuxInt = int64(32 - sdivisible(32, c).k)
 18269			v0.AddArg(v5)
 18270			v.AddArg(v0)
 18271			v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18272			v6.AuxInt = int64(int32(sdivisible(32, c).max))
 18273			v.AddArg(v6)
 18274			return true
 18275		}
 18276		// match: (Eq32 x (Mul32 (Sub32 (Rsh32x64 (Add32 mul:(Hmul32 x (Const32 [m])) x) (Const64 [s])) (Rsh32x64 x (Const64 [31]))) (Const32 [c])))
 18277		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m)) && s == smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c)
 18278		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) )
 18279		for {
 18280			_ = v.Args[1]
 18281			x := v.Args[0]
 18282			v_1 := v.Args[1]
 18283			if v_1.Op != OpMul32 {
 18284				break
 18285			}
 18286			_ = v_1.Args[1]
 18287			v_1_0 := v_1.Args[0]
 18288			if v_1_0.Op != OpSub32 {
 18289				break
 18290			}
 18291			_ = v_1_0.Args[1]
 18292			v_1_0_0 := v_1_0.Args[0]
 18293			if v_1_0_0.Op != OpRsh32x64 {
 18294				break
 18295			}
 18296			_ = v_1_0_0.Args[1]
 18297			v_1_0_0_0 := v_1_0_0.Args[0]
 18298			if v_1_0_0_0.Op != OpAdd32 {
 18299				break
 18300			}
 18301			_ = v_1_0_0_0.Args[1]
 18302			mul := v_1_0_0_0.Args[0]
 18303			if mul.Op != OpHmul32 {
 18304				break
 18305			}
 18306			_ = mul.Args[1]
 18307			if x != mul.Args[0] {
 18308				break
 18309			}
 18310			mul_1 := mul.Args[1]
 18311			if mul_1.Op != OpConst32 {
 18312				break
 18313			}
 18314			m := mul_1.AuxInt
 18315			if x != v_1_0_0_0.Args[1] {
 18316				break
 18317			}
 18318			v_1_0_0_1 := v_1_0_0.Args[1]
 18319			if v_1_0_0_1.Op != OpConst64 {
 18320				break
 18321			}
 18322			s := v_1_0_0_1.AuxInt
 18323			v_1_0_1 := v_1_0.Args[1]
 18324			if v_1_0_1.Op != OpRsh32x64 {
 18325				break
 18326			}
 18327			_ = v_1_0_1.Args[1]
 18328			if x != v_1_0_1.Args[0] {
 18329				break
 18330			}
 18331			v_1_0_1_1 := v_1_0_1.Args[1]
 18332			if v_1_0_1_1.Op != OpConst64 {
 18333				break
 18334			}
 18335			if v_1_0_1_1.AuxInt != 31 {
 18336				break
 18337			}
 18338			v_1_1 := v_1.Args[1]
 18339			if v_1_1.Op != OpConst32 {
 18340				break
 18341			}
 18342			c := v_1_1.AuxInt
 18343			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m)) && s == smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) {
 18344				break
 18345			}
 18346			v.reset(OpLeq32U)
 18347			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 18348			v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
 18349			v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 18350			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18351			v3.AuxInt = int64(int32(sdivisible(32, c).m))
 18352			v2.AddArg(v3)
 18353			v2.AddArg(x)
 18354			v1.AddArg(v2)
 18355			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18356			v4.AuxInt = int64(int32(sdivisible(32, c).a))
 18357			v1.AddArg(v4)
 18358			v0.AddArg(v1)
 18359			v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18360			v5.AuxInt = int64(32 - sdivisible(32, c).k)
 18361			v0.AddArg(v5)
 18362			v.AddArg(v0)
 18363			v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18364			v6.AuxInt = int64(int32(sdivisible(32, c).max))
 18365			v.AddArg(v6)
 18366			return true
 18367		}
 18368		// match: (Eq32 x (Mul32 (Sub32 (Rsh32x64 (Add32 x mul:(Hmul32 (Const32 [m]) x)) (Const64 [s])) (Rsh32x64 x (Const64 [31]))) (Const32 [c])))
 18369		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m)) && s == smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c)
 18370		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) )
 18371		for {
 18372			_ = v.Args[1]
 18373			x := v.Args[0]
 18374			v_1 := v.Args[1]
 18375			if v_1.Op != OpMul32 {
 18376				break
 18377			}
 18378			_ = v_1.Args[1]
 18379			v_1_0 := v_1.Args[0]
 18380			if v_1_0.Op != OpSub32 {
 18381				break
 18382			}
 18383			_ = v_1_0.Args[1]
 18384			v_1_0_0 := v_1_0.Args[0]
 18385			if v_1_0_0.Op != OpRsh32x64 {
 18386				break
 18387			}
 18388			_ = v_1_0_0.Args[1]
 18389			v_1_0_0_0 := v_1_0_0.Args[0]
 18390			if v_1_0_0_0.Op != OpAdd32 {
 18391				break
 18392			}
 18393			_ = v_1_0_0_0.Args[1]
 18394			if x != v_1_0_0_0.Args[0] {
 18395				break
 18396			}
 18397			mul := v_1_0_0_0.Args[1]
 18398			if mul.Op != OpHmul32 {
 18399				break
 18400			}
 18401			_ = mul.Args[1]
 18402			mul_0 := mul.Args[0]
 18403			if mul_0.Op != OpConst32 {
 18404				break
 18405			}
 18406			m := mul_0.AuxInt
 18407			if x != mul.Args[1] {
 18408				break
 18409			}
 18410			v_1_0_0_1 := v_1_0_0.Args[1]
 18411			if v_1_0_0_1.Op != OpConst64 {
 18412				break
 18413			}
 18414			s := v_1_0_0_1.AuxInt
 18415			v_1_0_1 := v_1_0.Args[1]
 18416			if v_1_0_1.Op != OpRsh32x64 {
 18417				break
 18418			}
 18419			_ = v_1_0_1.Args[1]
 18420			if x != v_1_0_1.Args[0] {
 18421				break
 18422			}
 18423			v_1_0_1_1 := v_1_0_1.Args[1]
 18424			if v_1_0_1_1.Op != OpConst64 {
 18425				break
 18426			}
 18427			if v_1_0_1_1.AuxInt != 31 {
 18428				break
 18429			}
 18430			v_1_1 := v_1.Args[1]
 18431			if v_1_1.Op != OpConst32 {
 18432				break
 18433			}
 18434			c := v_1_1.AuxInt
 18435			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m)) && s == smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) {
 18436				break
 18437			}
 18438			v.reset(OpLeq32U)
 18439			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 18440			v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
 18441			v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 18442			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18443			v3.AuxInt = int64(int32(sdivisible(32, c).m))
 18444			v2.AddArg(v3)
 18445			v2.AddArg(x)
 18446			v1.AddArg(v2)
 18447			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18448			v4.AuxInt = int64(int32(sdivisible(32, c).a))
 18449			v1.AddArg(v4)
 18450			v0.AddArg(v1)
 18451			v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18452			v5.AuxInt = int64(32 - sdivisible(32, c).k)
 18453			v0.AddArg(v5)
 18454			v.AddArg(v0)
 18455			v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18456			v6.AuxInt = int64(int32(sdivisible(32, c).max))
 18457			v.AddArg(v6)
 18458			return true
 18459		}
 18460		// match: (Eq32 x (Mul32 (Sub32 (Rsh32x64 (Add32 x mul:(Hmul32 x (Const32 [m]))) (Const64 [s])) (Rsh32x64 x (Const64 [31]))) (Const32 [c])))
 18461		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m)) && s == smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c)
 18462		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) )
 18463		for {
 18464			_ = v.Args[1]
 18465			x := v.Args[0]
 18466			v_1 := v.Args[1]
 18467			if v_1.Op != OpMul32 {
 18468				break
 18469			}
 18470			_ = v_1.Args[1]
 18471			v_1_0 := v_1.Args[0]
 18472			if v_1_0.Op != OpSub32 {
 18473				break
 18474			}
 18475			_ = v_1_0.Args[1]
 18476			v_1_0_0 := v_1_0.Args[0]
 18477			if v_1_0_0.Op != OpRsh32x64 {
 18478				break
 18479			}
 18480			_ = v_1_0_0.Args[1]
 18481			v_1_0_0_0 := v_1_0_0.Args[0]
 18482			if v_1_0_0_0.Op != OpAdd32 {
 18483				break
 18484			}
 18485			_ = v_1_0_0_0.Args[1]
 18486			if x != v_1_0_0_0.Args[0] {
 18487				break
 18488			}
 18489			mul := v_1_0_0_0.Args[1]
 18490			if mul.Op != OpHmul32 {
 18491				break
 18492			}
 18493			_ = mul.Args[1]
 18494			if x != mul.Args[0] {
 18495				break
 18496			}
 18497			mul_1 := mul.Args[1]
 18498			if mul_1.Op != OpConst32 {
 18499				break
 18500			}
 18501			m := mul_1.AuxInt
 18502			v_1_0_0_1 := v_1_0_0.Args[1]
 18503			if v_1_0_0_1.Op != OpConst64 {
 18504				break
 18505			}
 18506			s := v_1_0_0_1.AuxInt
 18507			v_1_0_1 := v_1_0.Args[1]
 18508			if v_1_0_1.Op != OpRsh32x64 {
 18509				break
 18510			}
 18511			_ = v_1_0_1.Args[1]
 18512			if x != v_1_0_1.Args[0] {
 18513				break
 18514			}
 18515			v_1_0_1_1 := v_1_0_1.Args[1]
 18516			if v_1_0_1_1.Op != OpConst64 {
 18517				break
 18518			}
 18519			if v_1_0_1_1.AuxInt != 31 {
 18520				break
 18521			}
 18522			v_1_1 := v_1.Args[1]
 18523			if v_1_1.Op != OpConst32 {
 18524				break
 18525			}
 18526			c := v_1_1.AuxInt
 18527			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m)) && s == smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) {
 18528				break
 18529			}
 18530			v.reset(OpLeq32U)
 18531			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 18532			v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
 18533			v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 18534			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18535			v3.AuxInt = int64(int32(sdivisible(32, c).m))
 18536			v2.AddArg(v3)
 18537			v2.AddArg(x)
 18538			v1.AddArg(v2)
 18539			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18540			v4.AuxInt = int64(int32(sdivisible(32, c).a))
 18541			v1.AddArg(v4)
 18542			v0.AddArg(v1)
 18543			v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18544			v5.AuxInt = int64(32 - sdivisible(32, c).k)
 18545			v0.AddArg(v5)
 18546			v.AddArg(v0)
 18547			v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18548			v6.AuxInt = int64(int32(sdivisible(32, c).max))
 18549			v.AddArg(v6)
 18550			return true
 18551		}
 18552		// match: (Eq32 (Mul32 (Const32 [c]) (Sub32 (Rsh32x64 (Add32 mul:(Hmul32 (Const32 [m]) x) x) (Const64 [s])) (Rsh32x64 x (Const64 [31])))) x)
 18553		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m)) && s == smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c)
 18554		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) )
 18555		for {
 18556			x := v.Args[1]
 18557			v_0 := v.Args[0]
 18558			if v_0.Op != OpMul32 {
 18559				break
 18560			}
 18561			_ = v_0.Args[1]
 18562			v_0_0 := v_0.Args[0]
 18563			if v_0_0.Op != OpConst32 {
 18564				break
 18565			}
 18566			c := v_0_0.AuxInt
 18567			v_0_1 := v_0.Args[1]
 18568			if v_0_1.Op != OpSub32 {
 18569				break
 18570			}
 18571			_ = v_0_1.Args[1]
 18572			v_0_1_0 := v_0_1.Args[0]
 18573			if v_0_1_0.Op != OpRsh32x64 {
 18574				break
 18575			}
 18576			_ = v_0_1_0.Args[1]
 18577			v_0_1_0_0 := v_0_1_0.Args[0]
 18578			if v_0_1_0_0.Op != OpAdd32 {
 18579				break
 18580			}
 18581			_ = v_0_1_0_0.Args[1]
 18582			mul := v_0_1_0_0.Args[0]
 18583			if mul.Op != OpHmul32 {
 18584				break
 18585			}
 18586			_ = mul.Args[1]
 18587			mul_0 := mul.Args[0]
 18588			if mul_0.Op != OpConst32 {
 18589				break
 18590			}
 18591			m := mul_0.AuxInt
 18592			if x != mul.Args[1] {
 18593				break
 18594			}
 18595			if x != v_0_1_0_0.Args[1] {
 18596				break
 18597			}
 18598			v_0_1_0_1 := v_0_1_0.Args[1]
 18599			if v_0_1_0_1.Op != OpConst64 {
 18600				break
 18601			}
 18602			s := v_0_1_0_1.AuxInt
 18603			v_0_1_1 := v_0_1.Args[1]
 18604			if v_0_1_1.Op != OpRsh32x64 {
 18605				break
 18606			}
 18607			_ = v_0_1_1.Args[1]
 18608			if x != v_0_1_1.Args[0] {
 18609				break
 18610			}
 18611			v_0_1_1_1 := v_0_1_1.Args[1]
 18612			if v_0_1_1_1.Op != OpConst64 {
 18613				break
 18614			}
 18615			if v_0_1_1_1.AuxInt != 31 {
 18616				break
 18617			}
 18618			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m)) && s == smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) {
 18619				break
 18620			}
 18621			v.reset(OpLeq32U)
 18622			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 18623			v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
 18624			v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 18625			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18626			v3.AuxInt = int64(int32(sdivisible(32, c).m))
 18627			v2.AddArg(v3)
 18628			v2.AddArg(x)
 18629			v1.AddArg(v2)
 18630			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18631			v4.AuxInt = int64(int32(sdivisible(32, c).a))
 18632			v1.AddArg(v4)
 18633			v0.AddArg(v1)
 18634			v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18635			v5.AuxInt = int64(32 - sdivisible(32, c).k)
 18636			v0.AddArg(v5)
 18637			v.AddArg(v0)
 18638			v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18639			v6.AuxInt = int64(int32(sdivisible(32, c).max))
 18640			v.AddArg(v6)
 18641			return true
 18642		}
 18643		return false
 18644	}
 18645	func rewriteValuegeneric_OpEq32_80(v *Value) bool {
 18646		b := v.Block
 18647		typ := &b.Func.Config.Types
 18648		// match: (Eq32 (Mul32 (Const32 [c]) (Sub32 (Rsh32x64 (Add32 mul:(Hmul32 x (Const32 [m])) x) (Const64 [s])) (Rsh32x64 x (Const64 [31])))) x)
 18649		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m)) && s == smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c)
 18650		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) )
 18651		for {
 18652			x := v.Args[1]
 18653			v_0 := v.Args[0]
 18654			if v_0.Op != OpMul32 {
 18655				break
 18656			}
 18657			_ = v_0.Args[1]
 18658			v_0_0 := v_0.Args[0]
 18659			if v_0_0.Op != OpConst32 {
 18660				break
 18661			}
 18662			c := v_0_0.AuxInt
 18663			v_0_1 := v_0.Args[1]
 18664			if v_0_1.Op != OpSub32 {
 18665				break
 18666			}
 18667			_ = v_0_1.Args[1]
 18668			v_0_1_0 := v_0_1.Args[0]
 18669			if v_0_1_0.Op != OpRsh32x64 {
 18670				break
 18671			}
 18672			_ = v_0_1_0.Args[1]
 18673			v_0_1_0_0 := v_0_1_0.Args[0]
 18674			if v_0_1_0_0.Op != OpAdd32 {
 18675				break
 18676			}
 18677			_ = v_0_1_0_0.Args[1]
 18678			mul := v_0_1_0_0.Args[0]
 18679			if mul.Op != OpHmul32 {
 18680				break
 18681			}
 18682			_ = mul.Args[1]
 18683			if x != mul.Args[0] {
 18684				break
 18685			}
 18686			mul_1 := mul.Args[1]
 18687			if mul_1.Op != OpConst32 {
 18688				break
 18689			}
 18690			m := mul_1.AuxInt
 18691			if x != v_0_1_0_0.Args[1] {
 18692				break
 18693			}
 18694			v_0_1_0_1 := v_0_1_0.Args[1]
 18695			if v_0_1_0_1.Op != OpConst64 {
 18696				break
 18697			}
 18698			s := v_0_1_0_1.AuxInt
 18699			v_0_1_1 := v_0_1.Args[1]
 18700			if v_0_1_1.Op != OpRsh32x64 {
 18701				break
 18702			}
 18703			_ = v_0_1_1.Args[1]
 18704			if x != v_0_1_1.Args[0] {
 18705				break
 18706			}
 18707			v_0_1_1_1 := v_0_1_1.Args[1]
 18708			if v_0_1_1_1.Op != OpConst64 {
 18709				break
 18710			}
 18711			if v_0_1_1_1.AuxInt != 31 {
 18712				break
 18713			}
 18714			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m)) && s == smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) {
 18715				break
 18716			}
 18717			v.reset(OpLeq32U)
 18718			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 18719			v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
 18720			v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 18721			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18722			v3.AuxInt = int64(int32(sdivisible(32, c).m))
 18723			v2.AddArg(v3)
 18724			v2.AddArg(x)
 18725			v1.AddArg(v2)
 18726			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18727			v4.AuxInt = int64(int32(sdivisible(32, c).a))
 18728			v1.AddArg(v4)
 18729			v0.AddArg(v1)
 18730			v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18731			v5.AuxInt = int64(32 - sdivisible(32, c).k)
 18732			v0.AddArg(v5)
 18733			v.AddArg(v0)
 18734			v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18735			v6.AuxInt = int64(int32(sdivisible(32, c).max))
 18736			v.AddArg(v6)
 18737			return true
 18738		}
 18739		// match: (Eq32 (Mul32 (Const32 [c]) (Sub32 (Rsh32x64 (Add32 x mul:(Hmul32 (Const32 [m]) x)) (Const64 [s])) (Rsh32x64 x (Const64 [31])))) x)
 18740		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m)) && s == smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c)
 18741		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) )
 18742		for {
 18743			x := v.Args[1]
 18744			v_0 := v.Args[0]
 18745			if v_0.Op != OpMul32 {
 18746				break
 18747			}
 18748			_ = v_0.Args[1]
 18749			v_0_0 := v_0.Args[0]
 18750			if v_0_0.Op != OpConst32 {
 18751				break
 18752			}
 18753			c := v_0_0.AuxInt
 18754			v_0_1 := v_0.Args[1]
 18755			if v_0_1.Op != OpSub32 {
 18756				break
 18757			}
 18758			_ = v_0_1.Args[1]
 18759			v_0_1_0 := v_0_1.Args[0]
 18760			if v_0_1_0.Op != OpRsh32x64 {
 18761				break
 18762			}
 18763			_ = v_0_1_0.Args[1]
 18764			v_0_1_0_0 := v_0_1_0.Args[0]
 18765			if v_0_1_0_0.Op != OpAdd32 {
 18766				break
 18767			}
 18768			_ = v_0_1_0_0.Args[1]
 18769			if x != v_0_1_0_0.Args[0] {
 18770				break
 18771			}
 18772			mul := v_0_1_0_0.Args[1]
 18773			if mul.Op != OpHmul32 {
 18774				break
 18775			}
 18776			_ = mul.Args[1]
 18777			mul_0 := mul.Args[0]
 18778			if mul_0.Op != OpConst32 {
 18779				break
 18780			}
 18781			m := mul_0.AuxInt
 18782			if x != mul.Args[1] {
 18783				break
 18784			}
 18785			v_0_1_0_1 := v_0_1_0.Args[1]
 18786			if v_0_1_0_1.Op != OpConst64 {
 18787				break
 18788			}
 18789			s := v_0_1_0_1.AuxInt
 18790			v_0_1_1 := v_0_1.Args[1]
 18791			if v_0_1_1.Op != OpRsh32x64 {
 18792				break
 18793			}
 18794			_ = v_0_1_1.Args[1]
 18795			if x != v_0_1_1.Args[0] {
 18796				break
 18797			}
 18798			v_0_1_1_1 := v_0_1_1.Args[1]
 18799			if v_0_1_1_1.Op != OpConst64 {
 18800				break
 18801			}
 18802			if v_0_1_1_1.AuxInt != 31 {
 18803				break
 18804			}
 18805			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m)) && s == smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) {
 18806				break
 18807			}
 18808			v.reset(OpLeq32U)
 18809			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 18810			v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
 18811			v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 18812			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18813			v3.AuxInt = int64(int32(sdivisible(32, c).m))
 18814			v2.AddArg(v3)
 18815			v2.AddArg(x)
 18816			v1.AddArg(v2)
 18817			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18818			v4.AuxInt = int64(int32(sdivisible(32, c).a))
 18819			v1.AddArg(v4)
 18820			v0.AddArg(v1)
 18821			v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18822			v5.AuxInt = int64(32 - sdivisible(32, c).k)
 18823			v0.AddArg(v5)
 18824			v.AddArg(v0)
 18825			v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18826			v6.AuxInt = int64(int32(sdivisible(32, c).max))
 18827			v.AddArg(v6)
 18828			return true
 18829		}
 18830		// match: (Eq32 (Mul32 (Const32 [c]) (Sub32 (Rsh32x64 (Add32 x mul:(Hmul32 x (Const32 [m]))) (Const64 [s])) (Rsh32x64 x (Const64 [31])))) x)
 18831		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m)) && s == smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c)
 18832		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) )
 18833		for {
 18834			x := v.Args[1]
 18835			v_0 := v.Args[0]
 18836			if v_0.Op != OpMul32 {
 18837				break
 18838			}
 18839			_ = v_0.Args[1]
 18840			v_0_0 := v_0.Args[0]
 18841			if v_0_0.Op != OpConst32 {
 18842				break
 18843			}
 18844			c := v_0_0.AuxInt
 18845			v_0_1 := v_0.Args[1]
 18846			if v_0_1.Op != OpSub32 {
 18847				break
 18848			}
 18849			_ = v_0_1.Args[1]
 18850			v_0_1_0 := v_0_1.Args[0]
 18851			if v_0_1_0.Op != OpRsh32x64 {
 18852				break
 18853			}
 18854			_ = v_0_1_0.Args[1]
 18855			v_0_1_0_0 := v_0_1_0.Args[0]
 18856			if v_0_1_0_0.Op != OpAdd32 {
 18857				break
 18858			}
 18859			_ = v_0_1_0_0.Args[1]
 18860			if x != v_0_1_0_0.Args[0] {
 18861				break
 18862			}
 18863			mul := v_0_1_0_0.Args[1]
 18864			if mul.Op != OpHmul32 {
 18865				break
 18866			}
 18867			_ = mul.Args[1]
 18868			if x != mul.Args[0] {
 18869				break
 18870			}
 18871			mul_1 := mul.Args[1]
 18872			if mul_1.Op != OpConst32 {
 18873				break
 18874			}
 18875			m := mul_1.AuxInt
 18876			v_0_1_0_1 := v_0_1_0.Args[1]
 18877			if v_0_1_0_1.Op != OpConst64 {
 18878				break
 18879			}
 18880			s := v_0_1_0_1.AuxInt
 18881			v_0_1_1 := v_0_1.Args[1]
 18882			if v_0_1_1.Op != OpRsh32x64 {
 18883				break
 18884			}
 18885			_ = v_0_1_1.Args[1]
 18886			if x != v_0_1_1.Args[0] {
 18887				break
 18888			}
 18889			v_0_1_1_1 := v_0_1_1.Args[1]
 18890			if v_0_1_1_1.Op != OpConst64 {
 18891				break
 18892			}
 18893			if v_0_1_1_1.AuxInt != 31 {
 18894				break
 18895			}
 18896			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m)) && s == smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) {
 18897				break
 18898			}
 18899			v.reset(OpLeq32U)
 18900			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 18901			v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
 18902			v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 18903			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18904			v3.AuxInt = int64(int32(sdivisible(32, c).m))
 18905			v2.AddArg(v3)
 18906			v2.AddArg(x)
 18907			v1.AddArg(v2)
 18908			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18909			v4.AuxInt = int64(int32(sdivisible(32, c).a))
 18910			v1.AddArg(v4)
 18911			v0.AddArg(v1)
 18912			v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18913			v5.AuxInt = int64(32 - sdivisible(32, c).k)
 18914			v0.AddArg(v5)
 18915			v.AddArg(v0)
 18916			v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18917			v6.AuxInt = int64(int32(sdivisible(32, c).max))
 18918			v.AddArg(v6)
 18919			return true
 18920		}
 18921		// match: (Eq32 (Mul32 (Sub32 (Rsh32x64 (Add32 mul:(Hmul32 (Const32 [m]) x) x) (Const64 [s])) (Rsh32x64 x (Const64 [31]))) (Const32 [c])) x)
 18922		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m)) && s == smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c)
 18923		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) )
 18924		for {
 18925			x := v.Args[1]
 18926			v_0 := v.Args[0]
 18927			if v_0.Op != OpMul32 {
 18928				break
 18929			}
 18930			_ = v_0.Args[1]
 18931			v_0_0 := v_0.Args[0]
 18932			if v_0_0.Op != OpSub32 {
 18933				break
 18934			}
 18935			_ = v_0_0.Args[1]
 18936			v_0_0_0 := v_0_0.Args[0]
 18937			if v_0_0_0.Op != OpRsh32x64 {
 18938				break
 18939			}
 18940			_ = v_0_0_0.Args[1]
 18941			v_0_0_0_0 := v_0_0_0.Args[0]
 18942			if v_0_0_0_0.Op != OpAdd32 {
 18943				break
 18944			}
 18945			_ = v_0_0_0_0.Args[1]
 18946			mul := v_0_0_0_0.Args[0]
 18947			if mul.Op != OpHmul32 {
 18948				break
 18949			}
 18950			_ = mul.Args[1]
 18951			mul_0 := mul.Args[0]
 18952			if mul_0.Op != OpConst32 {
 18953				break
 18954			}
 18955			m := mul_0.AuxInt
 18956			if x != mul.Args[1] {
 18957				break
 18958			}
 18959			if x != v_0_0_0_0.Args[1] {
 18960				break
 18961			}
 18962			v_0_0_0_1 := v_0_0_0.Args[1]
 18963			if v_0_0_0_1.Op != OpConst64 {
 18964				break
 18965			}
 18966			s := v_0_0_0_1.AuxInt
 18967			v_0_0_1 := v_0_0.Args[1]
 18968			if v_0_0_1.Op != OpRsh32x64 {
 18969				break
 18970			}
 18971			_ = v_0_0_1.Args[1]
 18972			if x != v_0_0_1.Args[0] {
 18973				break
 18974			}
 18975			v_0_0_1_1 := v_0_0_1.Args[1]
 18976			if v_0_0_1_1.Op != OpConst64 {
 18977				break
 18978			}
 18979			if v_0_0_1_1.AuxInt != 31 {
 18980				break
 18981			}
 18982			v_0_1 := v_0.Args[1]
 18983			if v_0_1.Op != OpConst32 {
 18984				break
 18985			}
 18986			c := v_0_1.AuxInt
 18987			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m)) && s == smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) {
 18988				break
 18989			}
 18990			v.reset(OpLeq32U)
 18991			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 18992			v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
 18993			v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 18994			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 18995			v3.AuxInt = int64(int32(sdivisible(32, c).m))
 18996			v2.AddArg(v3)
 18997			v2.AddArg(x)
 18998			v1.AddArg(v2)
 18999			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 19000			v4.AuxInt = int64(int32(sdivisible(32, c).a))
 19001			v1.AddArg(v4)
 19002			v0.AddArg(v1)
 19003			v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 19004			v5.AuxInt = int64(32 - sdivisible(32, c).k)
 19005			v0.AddArg(v5)
 19006			v.AddArg(v0)
 19007			v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 19008			v6.AuxInt = int64(int32(sdivisible(32, c).max))
 19009			v.AddArg(v6)
 19010			return true
 19011		}
 19012		// match: (Eq32 (Mul32 (Sub32 (Rsh32x64 (Add32 mul:(Hmul32 x (Const32 [m])) x) (Const64 [s])) (Rsh32x64 x (Const64 [31]))) (Const32 [c])) x)
 19013		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m)) && s == smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c)
 19014		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) )
 19015		for {
 19016			x := v.Args[1]
 19017			v_0 := v.Args[0]
 19018			if v_0.Op != OpMul32 {
 19019				break
 19020			}
 19021			_ = v_0.Args[1]
 19022			v_0_0 := v_0.Args[0]
 19023			if v_0_0.Op != OpSub32 {
 19024				break
 19025			}
 19026			_ = v_0_0.Args[1]
 19027			v_0_0_0 := v_0_0.Args[0]
 19028			if v_0_0_0.Op != OpRsh32x64 {
 19029				break
 19030			}
 19031			_ = v_0_0_0.Args[1]
 19032			v_0_0_0_0 := v_0_0_0.Args[0]
 19033			if v_0_0_0_0.Op != OpAdd32 {
 19034				break
 19035			}
 19036			_ = v_0_0_0_0.Args[1]
 19037			mul := v_0_0_0_0.Args[0]
 19038			if mul.Op != OpHmul32 {
 19039				break
 19040			}
 19041			_ = mul.Args[1]
 19042			if x != mul.Args[0] {
 19043				break
 19044			}
 19045			mul_1 := mul.Args[1]
 19046			if mul_1.Op != OpConst32 {
 19047				break
 19048			}
 19049			m := mul_1.AuxInt
 19050			if x != v_0_0_0_0.Args[1] {
 19051				break
 19052			}
 19053			v_0_0_0_1 := v_0_0_0.Args[1]
 19054			if v_0_0_0_1.Op != OpConst64 {
 19055				break
 19056			}
 19057			s := v_0_0_0_1.AuxInt
 19058			v_0_0_1 := v_0_0.Args[1]
 19059			if v_0_0_1.Op != OpRsh32x64 {
 19060				break
 19061			}
 19062			_ = v_0_0_1.Args[1]
 19063			if x != v_0_0_1.Args[0] {
 19064				break
 19065			}
 19066			v_0_0_1_1 := v_0_0_1.Args[1]
 19067			if v_0_0_1_1.Op != OpConst64 {
 19068				break
 19069			}
 19070			if v_0_0_1_1.AuxInt != 31 {
 19071				break
 19072			}
 19073			v_0_1 := v_0.Args[1]
 19074			if v_0_1.Op != OpConst32 {
 19075				break
 19076			}
 19077			c := v_0_1.AuxInt
 19078			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m)) && s == smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) {
 19079				break
 19080			}
 19081			v.reset(OpLeq32U)
 19082			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 19083			v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
 19084			v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 19085			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 19086			v3.AuxInt = int64(int32(sdivisible(32, c).m))
 19087			v2.AddArg(v3)
 19088			v2.AddArg(x)
 19089			v1.AddArg(v2)
 19090			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 19091			v4.AuxInt = int64(int32(sdivisible(32, c).a))
 19092			v1.AddArg(v4)
 19093			v0.AddArg(v1)
 19094			v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 19095			v5.AuxInt = int64(32 - sdivisible(32, c).k)
 19096			v0.AddArg(v5)
 19097			v.AddArg(v0)
 19098			v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 19099			v6.AuxInt = int64(int32(sdivisible(32, c).max))
 19100			v.AddArg(v6)
 19101			return true
 19102		}
 19103		// match: (Eq32 (Mul32 (Sub32 (Rsh32x64 (Add32 x mul:(Hmul32 (Const32 [m]) x)) (Const64 [s])) (Rsh32x64 x (Const64 [31]))) (Const32 [c])) x)
 19104		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m)) && s == smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c)
 19105		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) )
 19106		for {
 19107			x := v.Args[1]
 19108			v_0 := v.Args[0]
 19109			if v_0.Op != OpMul32 {
 19110				break
 19111			}
 19112			_ = v_0.Args[1]
 19113			v_0_0 := v_0.Args[0]
 19114			if v_0_0.Op != OpSub32 {
 19115				break
 19116			}
 19117			_ = v_0_0.Args[1]
 19118			v_0_0_0 := v_0_0.Args[0]
 19119			if v_0_0_0.Op != OpRsh32x64 {
 19120				break
 19121			}
 19122			_ = v_0_0_0.Args[1]
 19123			v_0_0_0_0 := v_0_0_0.Args[0]
 19124			if v_0_0_0_0.Op != OpAdd32 {
 19125				break
 19126			}
 19127			_ = v_0_0_0_0.Args[1]
 19128			if x != v_0_0_0_0.Args[0] {
 19129				break
 19130			}
 19131			mul := v_0_0_0_0.Args[1]
 19132			if mul.Op != OpHmul32 {
 19133				break
 19134			}
 19135			_ = mul.Args[1]
 19136			mul_0 := mul.Args[0]
 19137			if mul_0.Op != OpConst32 {
 19138				break
 19139			}
 19140			m := mul_0.AuxInt
 19141			if x != mul.Args[1] {
 19142				break
 19143			}
 19144			v_0_0_0_1 := v_0_0_0.Args[1]
 19145			if v_0_0_0_1.Op != OpConst64 {
 19146				break
 19147			}
 19148			s := v_0_0_0_1.AuxInt
 19149			v_0_0_1 := v_0_0.Args[1]
 19150			if v_0_0_1.Op != OpRsh32x64 {
 19151				break
 19152			}
 19153			_ = v_0_0_1.Args[1]
 19154			if x != v_0_0_1.Args[0] {
 19155				break
 19156			}
 19157			v_0_0_1_1 := v_0_0_1.Args[1]
 19158			if v_0_0_1_1.Op != OpConst64 {
 19159				break
 19160			}
 19161			if v_0_0_1_1.AuxInt != 31 {
 19162				break
 19163			}
 19164			v_0_1 := v_0.Args[1]
 19165			if v_0_1.Op != OpConst32 {
 19166				break
 19167			}
 19168			c := v_0_1.AuxInt
 19169			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m)) && s == smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) {
 19170				break
 19171			}
 19172			v.reset(OpLeq32U)
 19173			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 19174			v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
 19175			v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 19176			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 19177			v3.AuxInt = int64(int32(sdivisible(32, c).m))
 19178			v2.AddArg(v3)
 19179			v2.AddArg(x)
 19180			v1.AddArg(v2)
 19181			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 19182			v4.AuxInt = int64(int32(sdivisible(32, c).a))
 19183			v1.AddArg(v4)
 19184			v0.AddArg(v1)
 19185			v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 19186			v5.AuxInt = int64(32 - sdivisible(32, c).k)
 19187			v0.AddArg(v5)
 19188			v.AddArg(v0)
 19189			v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 19190			v6.AuxInt = int64(int32(sdivisible(32, c).max))
 19191			v.AddArg(v6)
 19192			return true
 19193		}
 19194		// match: (Eq32 (Mul32 (Sub32 (Rsh32x64 (Add32 x mul:(Hmul32 x (Const32 [m]))) (Const64 [s])) (Rsh32x64 x (Const64 [31]))) (Const32 [c])) x)
 19195		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m)) && s == smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c)
 19196		// result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) )
 19197		for {
 19198			x := v.Args[1]
 19199			v_0 := v.Args[0]
 19200			if v_0.Op != OpMul32 {
 19201				break
 19202			}
 19203			_ = v_0.Args[1]
 19204			v_0_0 := v_0.Args[0]
 19205			if v_0_0.Op != OpSub32 {
 19206				break
 19207			}
 19208			_ = v_0_0.Args[1]
 19209			v_0_0_0 := v_0_0.Args[0]
 19210			if v_0_0_0.Op != OpRsh32x64 {
 19211				break
 19212			}
 19213			_ = v_0_0_0.Args[1]
 19214			v_0_0_0_0 := v_0_0_0.Args[0]
 19215			if v_0_0_0_0.Op != OpAdd32 {
 19216				break
 19217			}
 19218			_ = v_0_0_0_0.Args[1]
 19219			if x != v_0_0_0_0.Args[0] {
 19220				break
 19221			}
 19222			mul := v_0_0_0_0.Args[1]
 19223			if mul.Op != OpHmul32 {
 19224				break
 19225			}
 19226			_ = mul.Args[1]
 19227			if x != mul.Args[0] {
 19228				break
 19229			}
 19230			mul_1 := mul.Args[1]
 19231			if mul_1.Op != OpConst32 {
 19232				break
 19233			}
 19234			m := mul_1.AuxInt
 19235			v_0_0_0_1 := v_0_0_0.Args[1]
 19236			if v_0_0_0_1.Op != OpConst64 {
 19237				break
 19238			}
 19239			s := v_0_0_0_1.AuxInt
 19240			v_0_0_1 := v_0_0.Args[1]
 19241			if v_0_0_1.Op != OpRsh32x64 {
 19242				break
 19243			}
 19244			_ = v_0_0_1.Args[1]
 19245			if x != v_0_0_1.Args[0] {
 19246				break
 19247			}
 19248			v_0_0_1_1 := v_0_0_1.Args[1]
 19249			if v_0_0_1_1.Op != OpConst64 {
 19250				break
 19251			}
 19252			if v_0_0_1_1.AuxInt != 31 {
 19253				break
 19254			}
 19255			v_0_1 := v_0.Args[1]
 19256			if v_0_1.Op != OpConst32 {
 19257				break
 19258			}
 19259			c := v_0_1.AuxInt
 19260			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m)) && s == smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) {
 19261				break
 19262			}
 19263			v.reset(OpLeq32U)
 19264			v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32)
 19265			v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
 19266			v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
 19267			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 19268			v3.AuxInt = int64(int32(sdivisible(32, c).m))
 19269			v2.AddArg(v3)
 19270			v2.AddArg(x)
 19271			v1.AddArg(v2)
 19272			v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 19273			v4.AuxInt = int64(int32(sdivisible(32, c).a))
 19274			v1.AddArg(v4)
 19275			v0.AddArg(v1)
 19276			v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 19277			v5.AuxInt = int64(32 - sdivisible(32, c).k)
 19278			v0.AddArg(v5)
 19279			v.AddArg(v0)
 19280			v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 19281			v6.AuxInt = int64(int32(sdivisible(32, c).max))
 19282			v.AddArg(v6)
 19283			return true
 19284		}
 19285		// match: (Eq32 n (Lsh32x64 (Rsh32x64 (Add32 <t> n (Rsh32Ux64 <t> (Rsh32x64 <t> n (Const64 <typ.UInt64> [31])) (Const64 <typ.UInt64> [kbar]))) (Const64 <typ.UInt64> [k])) (Const64 <typ.UInt64> [k])))
 19286		// cond: k > 0 && k < 31 && kbar == 32 - k
 19287		// result: (Eq32 (And32 <t> n (Const32 <t> [int64(1<<uint(k)-1)])) (Const32 <t> [0]))
 19288		for {
 19289			_ = v.Args[1]
 19290			n := v.Args[0]
 19291			v_1 := v.Args[1]
 19292			if v_1.Op != OpLsh32x64 {
 19293				break
 19294			}
 19295			_ = v_1.Args[1]
 19296			v_1_0 := v_1.Args[0]
 19297			if v_1_0.Op != OpRsh32x64 {
 19298				break
 19299			}
 19300			_ = v_1_0.Args[1]
 19301			v_1_0_0 := v_1_0.Args[0]
 19302			if v_1_0_0.Op != OpAdd32 {
 19303				break
 19304			}
 19305			t := v_1_0_0.Type
 19306			_ = v_1_0_0.Args[1]
 19307			if n != v_1_0_0.Args[0] {
 19308				break
 19309			}
 19310			v_1_0_0_1 := v_1_0_0.Args[1]
 19311			if v_1_0_0_1.Op != OpRsh32Ux64 {
 19312				break
 19313			}
 19314			if v_1_0_0_1.Type != t {
 19315				break
 19316			}
 19317			_ = v_1_0_0_1.Args[1]
 19318			v_1_0_0_1_0 := v_1_0_0_1.Args[0]
 19319			if v_1_0_0_1_0.Op != OpRsh32x64 {
 19320				break
 19321			}
 19322			if v_1_0_0_1_0.Type != t {
 19323				break
 19324			}
 19325			_ = v_1_0_0_1_0.Args[1]
 19326			if n != v_1_0_0_1_0.Args[0] {
 19327				break
 19328			}
 19329			v_1_0_0_1_0_1 := v_1_0_0_1_0.Args[1]
 19330			if v_1_0_0_1_0_1.Op != OpConst64 {
 19331				break
 19332			}
 19333			if v_1_0_0_1_0_1.Type != typ.UInt64 {
 19334				break
 19335			}
 19336			if v_1_0_0_1_0_1.AuxInt != 31 {
 19337				break
 19338			}
 19339			v_1_0_0_1_1 := v_1_0_0_1.Args[1]
 19340			if v_1_0_0_1_1.Op != OpConst64 {
 19341				break
 19342			}
 19343			if v_1_0_0_1_1.Type != typ.UInt64 {
 19344				break
 19345			}
 19346			kbar := v_1_0_0_1_1.AuxInt
 19347			v_1_0_1 := v_1_0.Args[1]
 19348			if v_1_0_1.Op != OpConst64 {
 19349				break
 19350			}
 19351			if v_1_0_1.Type != typ.UInt64 {
 19352				break
 19353			}
 19354			k := v_1_0_1.AuxInt
 19355			v_1_1 := v_1.Args[1]
 19356			if v_1_1.Op != OpConst64 {
 19357				break
 19358			}
 19359			if v_1_1.Type != typ.UInt64 {
 19360				break
 19361			}
 19362			if v_1_1.AuxInt != k {
 19363				break
 19364			}
 19365			if !(k > 0 && k < 31 && kbar == 32-k) {
 19366				break
 19367			}
 19368			v.reset(OpEq32)
 19369			v0 := b.NewValue0(v.Pos, OpAnd32, t)
 19370			v0.AddArg(n)
 19371			v1 := b.NewValue0(v.Pos, OpConst32, t)
 19372			v1.AuxInt = int64(1<<uint(k) - 1)
 19373			v0.AddArg(v1)
 19374			v.AddArg(v0)
 19375			v2 := b.NewValue0(v.Pos, OpConst32, t)
 19376			v2.AuxInt = 0
 19377			v.AddArg(v2)
 19378			return true
 19379		}
 19380		// match: (Eq32 n (Lsh32x64 (Rsh32x64 (Add32 <t> (Rsh32Ux64 <t> (Rsh32x64 <t> n (Const64 <typ.UInt64> [31])) (Const64 <typ.UInt64> [kbar])) n) (Const64 <typ.UInt64> [k])) (Const64 <typ.UInt64> [k])))
 19381		// cond: k > 0 && k < 31 && kbar == 32 - k
 19382		// result: (Eq32 (And32 <t> n (Const32 <t> [int64(1<<uint(k)-1)])) (Const32 <t> [0]))
 19383		for {
 19384			_ = v.Args[1]
 19385			n := v.Args[0]
 19386			v_1 := v.Args[1]
 19387			if v_1.Op != OpLsh32x64 {
 19388				break
 19389			}
 19390			_ = v_1.Args[1]
 19391			v_1_0 := v_1.Args[0]
 19392			if v_1_0.Op != OpRsh32x64 {
 19393				break
 19394			}
 19395			_ = v_1_0.Args[1]
 19396			v_1_0_0 := v_1_0.Args[0]
 19397			if v_1_0_0.Op != OpAdd32 {
 19398				break
 19399			}
 19400			t := v_1_0_0.Type
 19401			_ = v_1_0_0.Args[1]
 19402			v_1_0_0_0 := v_1_0_0.Args[0]
 19403			if v_1_0_0_0.Op != OpRsh32Ux64 {
 19404				break
 19405			}
 19406			if v_1_0_0_0.Type != t {
 19407				break
 19408			}
 19409			_ = v_1_0_0_0.Args[1]
 19410			v_1_0_0_0_0 := v_1_0_0_0.Args[0]
 19411			if v_1_0_0_0_0.Op != OpRsh32x64 {
 19412				break
 19413			}
 19414			if v_1_0_0_0_0.Type != t {
 19415				break
 19416			}
 19417			_ = v_1_0_0_0_0.Args[1]
 19418			if n != v_1_0_0_0_0.Args[0] {
 19419				break
 19420			}
 19421			v_1_0_0_0_0_1 := v_1_0_0_0_0.Args[1]
 19422			if v_1_0_0_0_0_1.Op != OpConst64 {
 19423				break
 19424			}
 19425			if v_1_0_0_0_0_1.Type != typ.UInt64 {
 19426				break
 19427			}
 19428			if v_1_0_0_0_0_1.AuxInt != 31 {
 19429				break
 19430			}
 19431			v_1_0_0_0_1 := v_1_0_0_0.Args[1]
 19432			if v_1_0_0_0_1.Op != OpConst64 {
 19433				break
 19434			}
 19435			if v_1_0_0_0_1.Type != typ.UInt64 {
 19436				break
 19437			}
 19438			kbar := v_1_0_0_0_1.AuxInt
 19439			if n != v_1_0_0.Args[1] {
 19440				break
 19441			}
 19442			v_1_0_1 := v_1_0.Args[1]
 19443			if v_1_0_1.Op != OpConst64 {
 19444				break
 19445			}
 19446			if v_1_0_1.Type != typ.UInt64 {
 19447				break
 19448			}
 19449			k := v_1_0_1.AuxInt
 19450			v_1_1 := v_1.Args[1]
 19451			if v_1_1.Op != OpConst64 {
 19452				break
 19453			}
 19454			if v_1_1.Type != typ.UInt64 {
 19455				break
 19456			}
 19457			if v_1_1.AuxInt != k {
 19458				break
 19459			}
 19460			if !(k > 0 && k < 31 && kbar == 32-k) {
 19461				break
 19462			}
 19463			v.reset(OpEq32)
 19464			v0 := b.NewValue0(v.Pos, OpAnd32, t)
 19465			v0.AddArg(n)
 19466			v1 := b.NewValue0(v.Pos, OpConst32, t)
 19467			v1.AuxInt = int64(1<<uint(k) - 1)
 19468			v0.AddArg(v1)
 19469			v.AddArg(v0)
 19470			v2 := b.NewValue0(v.Pos, OpConst32, t)
 19471			v2.AuxInt = 0
 19472			v.AddArg(v2)
 19473			return true
 19474		}
 19475		// match: (Eq32 (Lsh32x64 (Rsh32x64 (Add32 <t> n (Rsh32Ux64 <t> (Rsh32x64 <t> n (Const64 <typ.UInt64> [31])) (Const64 <typ.UInt64> [kbar]))) (Const64 <typ.UInt64> [k])) (Const64 <typ.UInt64> [k])) n)
 19476		// cond: k > 0 && k < 31 && kbar == 32 - k
 19477		// result: (Eq32 (And32 <t> n (Const32 <t> [int64(1<<uint(k)-1)])) (Const32 <t> [0]))
 19478		for {
 19479			n := v.Args[1]
 19480			v_0 := v.Args[0]
 19481			if v_0.Op != OpLsh32x64 {
 19482				break
 19483			}
 19484			_ = v_0.Args[1]
 19485			v_0_0 := v_0.Args[0]
 19486			if v_0_0.Op != OpRsh32x64 {
 19487				break
 19488			}
 19489			_ = v_0_0.Args[1]
 19490			v_0_0_0 := v_0_0.Args[0]
 19491			if v_0_0_0.Op != OpAdd32 {
 19492				break
 19493			}
 19494			t := v_0_0_0.Type
 19495			_ = v_0_0_0.Args[1]
 19496			if n != v_0_0_0.Args[0] {
 19497				break
 19498			}
 19499			v_0_0_0_1 := v_0_0_0.Args[1]
 19500			if v_0_0_0_1.Op != OpRsh32Ux64 {
 19501				break
 19502			}
 19503			if v_0_0_0_1.Type != t {
 19504				break
 19505			}
 19506			_ = v_0_0_0_1.Args[1]
 19507			v_0_0_0_1_0 := v_0_0_0_1.Args[0]
 19508			if v_0_0_0_1_0.Op != OpRsh32x64 {
 19509				break
 19510			}
 19511			if v_0_0_0_1_0.Type != t {
 19512				break
 19513			}
 19514			_ = v_0_0_0_1_0.Args[1]
 19515			if n != v_0_0_0_1_0.Args[0] {
 19516				break
 19517			}
 19518			v_0_0_0_1_0_1 := v_0_0_0_1_0.Args[1]
 19519			if v_0_0_0_1_0_1.Op != OpConst64 {
 19520				break
 19521			}
 19522			if v_0_0_0_1_0_1.Type != typ.UInt64 {
 19523				break
 19524			}
 19525			if v_0_0_0_1_0_1.AuxInt != 31 {
 19526				break
 19527			}
 19528			v_0_0_0_1_1 := v_0_0_0_1.Args[1]
 19529			if v_0_0_0_1_1.Op != OpConst64 {
 19530				break
 19531			}
 19532			if v_0_0_0_1_1.Type != typ.UInt64 {
 19533				break
 19534			}
 19535			kbar := v_0_0_0_1_1.AuxInt
 19536			v_0_0_1 := v_0_0.Args[1]
 19537			if v_0_0_1.Op != OpConst64 {
 19538				break
 19539			}
 19540			if v_0_0_1.Type != typ.UInt64 {
 19541				break
 19542			}
 19543			k := v_0_0_1.AuxInt
 19544			v_0_1 := v_0.Args[1]
 19545			if v_0_1.Op != OpConst64 {
 19546				break
 19547			}
 19548			if v_0_1.Type != typ.UInt64 {
 19549				break
 19550			}
 19551			if v_0_1.AuxInt != k {
 19552				break
 19553			}
 19554			if !(k > 0 && k < 31 && kbar == 32-k) {
 19555				break
 19556			}
 19557			v.reset(OpEq32)
 19558			v0 := b.NewValue0(v.Pos, OpAnd32, t)
 19559			v0.AddArg(n)
 19560			v1 := b.NewValue0(v.Pos, OpConst32, t)
 19561			v1.AuxInt = int64(1<<uint(k) - 1)
 19562			v0.AddArg(v1)
 19563			v.AddArg(v0)
 19564			v2 := b.NewValue0(v.Pos, OpConst32, t)
 19565			v2.AuxInt = 0
 19566			v.AddArg(v2)
 19567			return true
 19568		}
 19569		return false
 19570	}
 19571	func rewriteValuegeneric_OpEq32_90(v *Value) bool {
 19572		b := v.Block
 19573		typ := &b.Func.Config.Types
 19574		// match: (Eq32 (Lsh32x64 (Rsh32x64 (Add32 <t> (Rsh32Ux64 <t> (Rsh32x64 <t> n (Const64 <typ.UInt64> [31])) (Const64 <typ.UInt64> [kbar])) n) (Const64 <typ.UInt64> [k])) (Const64 <typ.UInt64> [k])) n)
 19575		// cond: k > 0 && k < 31 && kbar == 32 - k
 19576		// result: (Eq32 (And32 <t> n (Const32 <t> [int64(1<<uint(k)-1)])) (Const32 <t> [0]))
 19577		for {
 19578			n := v.Args[1]
 19579			v_0 := v.Args[0]
 19580			if v_0.Op != OpLsh32x64 {
 19581				break
 19582			}
 19583			_ = v_0.Args[1]
 19584			v_0_0 := v_0.Args[0]
 19585			if v_0_0.Op != OpRsh32x64 {
 19586				break
 19587			}
 19588			_ = v_0_0.Args[1]
 19589			v_0_0_0 := v_0_0.Args[0]
 19590			if v_0_0_0.Op != OpAdd32 {
 19591				break
 19592			}
 19593			t := v_0_0_0.Type
 19594			_ = v_0_0_0.Args[1]
 19595			v_0_0_0_0 := v_0_0_0.Args[0]
 19596			if v_0_0_0_0.Op != OpRsh32Ux64 {
 19597				break
 19598			}
 19599			if v_0_0_0_0.Type != t {
 19600				break
 19601			}
 19602			_ = v_0_0_0_0.Args[1]
 19603			v_0_0_0_0_0 := v_0_0_0_0.Args[0]
 19604			if v_0_0_0_0_0.Op != OpRsh32x64 {
 19605				break
 19606			}
 19607			if v_0_0_0_0_0.Type != t {
 19608				break
 19609			}
 19610			_ = v_0_0_0_0_0.Args[1]
 19611			if n != v_0_0_0_0_0.Args[0] {
 19612				break
 19613			}
 19614			v_0_0_0_0_0_1 := v_0_0_0_0_0.Args[1]
 19615			if v_0_0_0_0_0_1.Op != OpConst64 {
 19616				break
 19617			}
 19618			if v_0_0_0_0_0_1.Type != typ.UInt64 {
 19619				break
 19620			}
 19621			if v_0_0_0_0_0_1.AuxInt != 31 {
 19622				break
 19623			}
 19624			v_0_0_0_0_1 := v_0_0_0_0.Args[1]
 19625			if v_0_0_0_0_1.Op != OpConst64 {
 19626				break
 19627			}
 19628			if v_0_0_0_0_1.Type != typ.UInt64 {
 19629				break
 19630			}
 19631			kbar := v_0_0_0_0_1.AuxInt
 19632			if n != v_0_0_0.Args[1] {
 19633				break
 19634			}
 19635			v_0_0_1 := v_0_0.Args[1]
 19636			if v_0_0_1.Op != OpConst64 {
 19637				break
 19638			}
 19639			if v_0_0_1.Type != typ.UInt64 {
 19640				break
 19641			}
 19642			k := v_0_0_1.AuxInt
 19643			v_0_1 := v_0.Args[1]
 19644			if v_0_1.Op != OpConst64 {
 19645				break
 19646			}
 19647			if v_0_1.Type != typ.UInt64 {
 19648				break
 19649			}
 19650			if v_0_1.AuxInt != k {
 19651				break
 19652			}
 19653			if !(k > 0 && k < 31 && kbar == 32-k) {
 19654				break
 19655			}
 19656			v.reset(OpEq32)
 19657			v0 := b.NewValue0(v.Pos, OpAnd32, t)
 19658			v0.AddArg(n)
 19659			v1 := b.NewValue0(v.Pos, OpConst32, t)
 19660			v1.AuxInt = int64(1<<uint(k) - 1)
 19661			v0.AddArg(v1)
 19662			v.AddArg(v0)
 19663			v2 := b.NewValue0(v.Pos, OpConst32, t)
 19664			v2.AuxInt = 0
 19665			v.AddArg(v2)
 19666			return true
 19667		}
 19668		// match: (Eq32 s:(Sub32 x y) (Const32 [0]))
 19669		// cond: s.Uses == 1
 19670		// result: (Eq32 x y)
 19671		for {
 19672			_ = v.Args[1]
 19673			s := v.Args[0]
 19674			if s.Op != OpSub32 {
 19675				break
 19676			}
 19677			y := s.Args[1]
 19678			x := s.Args[0]
 19679			v_1 := v.Args[1]
 19680			if v_1.Op != OpConst32 {
 19681				break
 19682			}
 19683			if v_1.AuxInt != 0 {
 19684				break
 19685			}
 19686			if !(s.Uses == 1) {
 19687				break
 19688			}
 19689			v.reset(OpEq32)
 19690			v.AddArg(x)
 19691			v.AddArg(y)
 19692			return true
 19693		}
 19694		// match: (Eq32 (Const32 [0]) s:(Sub32 x y))
 19695		// cond: s.Uses == 1
 19696		// result: (Eq32 x y)
 19697		for {
 19698			_ = v.Args[1]
 19699			v_0 := v.Args[0]
 19700			if v_0.Op != OpConst32 {
 19701				break
 19702			}
 19703			if v_0.AuxInt != 0 {
 19704				break
 19705			}
 19706			s := v.Args[1]
 19707			if s.Op != OpSub32 {
 19708				break
 19709			}
 19710			y := s.Args[1]
 19711			x := s.Args[0]
 19712			if !(s.Uses == 1) {
 19713				break
 19714			}
 19715			v.reset(OpEq32)
 19716			v.AddArg(x)
 19717			v.AddArg(y)
 19718			return true
 19719		}
 19720		return false
 19721	}
 19722	func rewriteValuegeneric_OpEq32F_0(v *Value) bool {
 19723		// match: (Eq32F (Const32F [c]) (Const32F [d]))
 19724		// cond:
 19725		// result: (ConstBool [b2i(auxTo32F(c) == auxTo32F(d))])
 19726		for {
 19727			_ = v.Args[1]
 19728			v_0 := v.Args[0]
 19729			if v_0.Op != OpConst32F {
 19730				break
 19731			}
 19732			c := v_0.AuxInt
 19733			v_1 := v.Args[1]
 19734			if v_1.Op != OpConst32F {
 19735				break
 19736			}
 19737			d := v_1.AuxInt
 19738			v.reset(OpConstBool)
 19739			v.AuxInt = b2i(auxTo32F(c) == auxTo32F(d))
 19740			return true
 19741		}
 19742		// match: (Eq32F (Const32F [d]) (Const32F [c]))
 19743		// cond:
 19744		// result: (ConstBool [b2i(auxTo32F(c) == auxTo32F(d))])
 19745		for {
 19746			_ = v.Args[1]
 19747			v_0 := v.Args[0]
 19748			if v_0.Op != OpConst32F {
 19749				break
 19750			}
 19751			d := v_0.AuxInt
 19752			v_1 := v.Args[1]
 19753			if v_1.Op != OpConst32F {
 19754				break
 19755			}
 19756			c := v_1.AuxInt
 19757			v.reset(OpConstBool)
 19758			v.AuxInt = b2i(auxTo32F(c) == auxTo32F(d))
 19759			return true
 19760		}
 19761		return false
 19762	}
 19763	func rewriteValuegeneric_OpEq64_0(v *Value) bool {
 19764		b := v.Block
 19765		typ := &b.Func.Config.Types
 19766		// match: (Eq64 x x)
 19767		// cond:
 19768		// result: (ConstBool [1])
 19769		for {
 19770			x := v.Args[1]
 19771			if x != v.Args[0] {
 19772				break
 19773			}
 19774			v.reset(OpConstBool)
 19775			v.AuxInt = 1
 19776			return true
 19777		}
 19778		// match: (Eq64 (Const64 <t> [c]) (Add64 (Const64 <t> [d]) x))
 19779		// cond:
 19780		// result: (Eq64 (Const64 <t> [c-d]) x)
 19781		for {
 19782			_ = v.Args[1]
 19783			v_0 := v.Args[0]
 19784			if v_0.Op != OpConst64 {
 19785				break
 19786			}
 19787			t := v_0.Type
 19788			c := v_0.AuxInt
 19789			v_1 := v.Args[1]
 19790			if v_1.Op != OpAdd64 {
 19791				break
 19792			}
 19793			x := v_1.Args[1]
 19794			v_1_0 := v_1.Args[0]
 19795			if v_1_0.Op != OpConst64 {
 19796				break
 19797			}
 19798			if v_1_0.Type != t {
 19799				break
 19800			}
 19801			d := v_1_0.AuxInt
 19802			v.reset(OpEq64)
 19803			v0 := b.NewValue0(v.Pos, OpConst64, t)
 19804			v0.AuxInt = c - d
 19805			v.AddArg(v0)
 19806			v.AddArg(x)
 19807			return true
 19808		}
 19809		// match: (Eq64 (Const64 <t> [c]) (Add64 x (Const64 <t> [d])))
 19810		// cond:
 19811		// result: (Eq64 (Const64 <t> [c-d]) x)
 19812		for {
 19813			_ = v.Args[1]
 19814			v_0 := v.Args[0]
 19815			if v_0.Op != OpConst64 {
 19816				break
 19817			}
 19818			t := v_0.Type
 19819			c := v_0.AuxInt
 19820			v_1 := v.Args[1]
 19821			if v_1.Op != OpAdd64 {
 19822				break
 19823			}
 19824			_ = v_1.Args[1]
 19825			x := v_1.Args[0]
 19826			v_1_1 := v_1.Args[1]
 19827			if v_1_1.Op != OpConst64 {
 19828				break
 19829			}
 19830			if v_1_1.Type != t {
 19831				break
 19832			}
 19833			d := v_1_1.AuxInt
 19834			v.reset(OpEq64)
 19835			v0 := b.NewValue0(v.Pos, OpConst64, t)
 19836			v0.AuxInt = c - d
 19837			v.AddArg(v0)
 19838			v.AddArg(x)
 19839			return true
 19840		}
 19841		// match: (Eq64 (Add64 (Const64 <t> [d]) x) (Const64 <t> [c]))
 19842		// cond:
 19843		// result: (Eq64 (Const64 <t> [c-d]) x)
 19844		for {
 19845			_ = v.Args[1]
 19846			v_0 := v.Args[0]
 19847			if v_0.Op != OpAdd64 {
 19848				break
 19849			}
 19850			x := v_0.Args[1]
 19851			v_0_0 := v_0.Args[0]
 19852			if v_0_0.Op != OpConst64 {
 19853				break
 19854			}
 19855			t := v_0_0.Type
 19856			d := v_0_0.AuxInt
 19857			v_1 := v.Args[1]
 19858			if v_1.Op != OpConst64 {
 19859				break
 19860			}
 19861			if v_1.Type != t {
 19862				break
 19863			}
 19864			c := v_1.AuxInt
 19865			v.reset(OpEq64)
 19866			v0 := b.NewValue0(v.Pos, OpConst64, t)
 19867			v0.AuxInt = c - d
 19868			v.AddArg(v0)
 19869			v.AddArg(x)
 19870			return true
 19871		}
 19872		// match: (Eq64 (Add64 x (Const64 <t> [d])) (Const64 <t> [c]))
 19873		// cond:
 19874		// result: (Eq64 (Const64 <t> [c-d]) x)
 19875		for {
 19876			_ = v.Args[1]
 19877			v_0 := v.Args[0]
 19878			if v_0.Op != OpAdd64 {
 19879				break
 19880			}
 19881			_ = v_0.Args[1]
 19882			x := v_0.Args[0]
 19883			v_0_1 := v_0.Args[1]
 19884			if v_0_1.Op != OpConst64 {
 19885				break
 19886			}
 19887			t := v_0_1.Type
 19888			d := v_0_1.AuxInt
 19889			v_1 := v.Args[1]
 19890			if v_1.Op != OpConst64 {
 19891				break
 19892			}
 19893			if v_1.Type != t {
 19894				break
 19895			}
 19896			c := v_1.AuxInt
 19897			v.reset(OpEq64)
 19898			v0 := b.NewValue0(v.Pos, OpConst64, t)
 19899			v0.AuxInt = c - d
 19900			v.AddArg(v0)
 19901			v.AddArg(x)
 19902			return true
 19903		}
 19904		// match: (Eq64 (Const64 [c]) (Const64 [d]))
 19905		// cond:
 19906		// result: (ConstBool [b2i(c == d)])
 19907		for {
 19908			_ = v.Args[1]
 19909			v_0 := v.Args[0]
 19910			if v_0.Op != OpConst64 {
 19911				break
 19912			}
 19913			c := v_0.AuxInt
 19914			v_1 := v.Args[1]
 19915			if v_1.Op != OpConst64 {
 19916				break
 19917			}
 19918			d := v_1.AuxInt
 19919			v.reset(OpConstBool)
 19920			v.AuxInt = b2i(c == d)
 19921			return true
 19922		}
 19923		// match: (Eq64 (Const64 [d]) (Const64 [c]))
 19924		// cond:
 19925		// result: (ConstBool [b2i(c == d)])
 19926		for {
 19927			_ = v.Args[1]
 19928			v_0 := v.Args[0]
 19929			if v_0.Op != OpConst64 {
 19930				break
 19931			}
 19932			d := v_0.AuxInt
 19933			v_1 := v.Args[1]
 19934			if v_1.Op != OpConst64 {
 19935				break
 19936			}
 19937			c := v_1.AuxInt
 19938			v.reset(OpConstBool)
 19939			v.AuxInt = b2i(c == d)
 19940			return true
 19941		}
 19942		// match: (Eq64 x (Mul64 (Const64 [c]) (Rsh64Ux64 mul:(Hmul64u (Const64 [m]) x) (Const64 [s]))))
 19943		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+umagic(64,c).m/2) && s == umagic(64,c).s-1 && x.Op != OpConst64 && udivisibleOK(64,c)
 19944		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) )
 19945		for {
 19946			_ = v.Args[1]
 19947			x := v.Args[0]
 19948			v_1 := v.Args[1]
 19949			if v_1.Op != OpMul64 {
 19950				break
 19951			}
 19952			_ = v_1.Args[1]
 19953			v_1_0 := v_1.Args[0]
 19954			if v_1_0.Op != OpConst64 {
 19955				break
 19956			}
 19957			c := v_1_0.AuxInt
 19958			v_1_1 := v_1.Args[1]
 19959			if v_1_1.Op != OpRsh64Ux64 {
 19960				break
 19961			}
 19962			_ = v_1_1.Args[1]
 19963			mul := v_1_1.Args[0]
 19964			if mul.Op != OpHmul64u {
 19965				break
 19966			}
 19967			_ = mul.Args[1]
 19968			mul_0 := mul.Args[0]
 19969			if mul_0.Op != OpConst64 {
 19970				break
 19971			}
 19972			m := mul_0.AuxInt
 19973			if x != mul.Args[1] {
 19974				break
 19975			}
 19976			v_1_1_1 := v_1_1.Args[1]
 19977			if v_1_1_1.Op != OpConst64 {
 19978				break
 19979			}
 19980			s := v_1_1_1.AuxInt
 19981			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+umagic(64, c).m/2) && s == umagic(64, c).s-1 && x.Op != OpConst64 && udivisibleOK(64, c)) {
 19982				break
 19983			}
 19984			v.reset(OpLeq64U)
 19985			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 19986			v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 19987			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 19988			v2.AuxInt = int64(udivisible(64, c).m)
 19989			v1.AddArg(v2)
 19990			v1.AddArg(x)
 19991			v0.AddArg(v1)
 19992			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 19993			v3.AuxInt = int64(64 - udivisible(64, c).k)
 19994			v0.AddArg(v3)
 19995			v.AddArg(v0)
 19996			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 19997			v4.AuxInt = int64(udivisible(64, c).max)
 19998			v.AddArg(v4)
 19999			return true
 20000		}
 20001		// match: (Eq64 x (Mul64 (Const64 [c]) (Rsh64Ux64 mul:(Hmul64u x (Const64 [m])) (Const64 [s]))))
 20002		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+umagic(64,c).m/2) && s == umagic(64,c).s-1 && x.Op != OpConst64 && udivisibleOK(64,c)
 20003		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) )
 20004		for {
 20005			_ = v.Args[1]
 20006			x := v.Args[0]
 20007			v_1 := v.Args[1]
 20008			if v_1.Op != OpMul64 {
 20009				break
 20010			}
 20011			_ = v_1.Args[1]
 20012			v_1_0 := v_1.Args[0]
 20013			if v_1_0.Op != OpConst64 {
 20014				break
 20015			}
 20016			c := v_1_0.AuxInt
 20017			v_1_1 := v_1.Args[1]
 20018			if v_1_1.Op != OpRsh64Ux64 {
 20019				break
 20020			}
 20021			_ = v_1_1.Args[1]
 20022			mul := v_1_1.Args[0]
 20023			if mul.Op != OpHmul64u {
 20024				break
 20025			}
 20026			_ = mul.Args[1]
 20027			if x != mul.Args[0] {
 20028				break
 20029			}
 20030			mul_1 := mul.Args[1]
 20031			if mul_1.Op != OpConst64 {
 20032				break
 20033			}
 20034			m := mul_1.AuxInt
 20035			v_1_1_1 := v_1_1.Args[1]
 20036			if v_1_1_1.Op != OpConst64 {
 20037				break
 20038			}
 20039			s := v_1_1_1.AuxInt
 20040			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+umagic(64, c).m/2) && s == umagic(64, c).s-1 && x.Op != OpConst64 && udivisibleOK(64, c)) {
 20041				break
 20042			}
 20043			v.reset(OpLeq64U)
 20044			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 20045			v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 20046			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20047			v2.AuxInt = int64(udivisible(64, c).m)
 20048			v1.AddArg(v2)
 20049			v1.AddArg(x)
 20050			v0.AddArg(v1)
 20051			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20052			v3.AuxInt = int64(64 - udivisible(64, c).k)
 20053			v0.AddArg(v3)
 20054			v.AddArg(v0)
 20055			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20056			v4.AuxInt = int64(udivisible(64, c).max)
 20057			v.AddArg(v4)
 20058			return true
 20059		}
 20060		// match: (Eq64 x (Mul64 (Rsh64Ux64 mul:(Hmul64u (Const64 [m]) x) (Const64 [s])) (Const64 [c])))
 20061		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+umagic(64,c).m/2) && s == umagic(64,c).s-1 && x.Op != OpConst64 && udivisibleOK(64,c)
 20062		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) )
 20063		for {
 20064			_ = v.Args[1]
 20065			x := v.Args[0]
 20066			v_1 := v.Args[1]
 20067			if v_1.Op != OpMul64 {
 20068				break
 20069			}
 20070			_ = v_1.Args[1]
 20071			v_1_0 := v_1.Args[0]
 20072			if v_1_0.Op != OpRsh64Ux64 {
 20073				break
 20074			}
 20075			_ = v_1_0.Args[1]
 20076			mul := v_1_0.Args[0]
 20077			if mul.Op != OpHmul64u {
 20078				break
 20079			}
 20080			_ = mul.Args[1]
 20081			mul_0 := mul.Args[0]
 20082			if mul_0.Op != OpConst64 {
 20083				break
 20084			}
 20085			m := mul_0.AuxInt
 20086			if x != mul.Args[1] {
 20087				break
 20088			}
 20089			v_1_0_1 := v_1_0.Args[1]
 20090			if v_1_0_1.Op != OpConst64 {
 20091				break
 20092			}
 20093			s := v_1_0_1.AuxInt
 20094			v_1_1 := v_1.Args[1]
 20095			if v_1_1.Op != OpConst64 {
 20096				break
 20097			}
 20098			c := v_1_1.AuxInt
 20099			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+umagic(64, c).m/2) && s == umagic(64, c).s-1 && x.Op != OpConst64 && udivisibleOK(64, c)) {
 20100				break
 20101			}
 20102			v.reset(OpLeq64U)
 20103			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 20104			v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 20105			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20106			v2.AuxInt = int64(udivisible(64, c).m)
 20107			v1.AddArg(v2)
 20108			v1.AddArg(x)
 20109			v0.AddArg(v1)
 20110			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20111			v3.AuxInt = int64(64 - udivisible(64, c).k)
 20112			v0.AddArg(v3)
 20113			v.AddArg(v0)
 20114			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20115			v4.AuxInt = int64(udivisible(64, c).max)
 20116			v.AddArg(v4)
 20117			return true
 20118		}
 20119		return false
 20120	}
 20121	func rewriteValuegeneric_OpEq64_10(v *Value) bool {
 20122		b := v.Block
 20123		typ := &b.Func.Config.Types
 20124		// match: (Eq64 x (Mul64 (Rsh64Ux64 mul:(Hmul64u x (Const64 [m])) (Const64 [s])) (Const64 [c])))
 20125		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+umagic(64,c).m/2) && s == umagic(64,c).s-1 && x.Op != OpConst64 && udivisibleOK(64,c)
 20126		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) )
 20127		for {
 20128			_ = v.Args[1]
 20129			x := v.Args[0]
 20130			v_1 := v.Args[1]
 20131			if v_1.Op != OpMul64 {
 20132				break
 20133			}
 20134			_ = v_1.Args[1]
 20135			v_1_0 := v_1.Args[0]
 20136			if v_1_0.Op != OpRsh64Ux64 {
 20137				break
 20138			}
 20139			_ = v_1_0.Args[1]
 20140			mul := v_1_0.Args[0]
 20141			if mul.Op != OpHmul64u {
 20142				break
 20143			}
 20144			_ = mul.Args[1]
 20145			if x != mul.Args[0] {
 20146				break
 20147			}
 20148			mul_1 := mul.Args[1]
 20149			if mul_1.Op != OpConst64 {
 20150				break
 20151			}
 20152			m := mul_1.AuxInt
 20153			v_1_0_1 := v_1_0.Args[1]
 20154			if v_1_0_1.Op != OpConst64 {
 20155				break
 20156			}
 20157			s := v_1_0_1.AuxInt
 20158			v_1_1 := v_1.Args[1]
 20159			if v_1_1.Op != OpConst64 {
 20160				break
 20161			}
 20162			c := v_1_1.AuxInt
 20163			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+umagic(64, c).m/2) && s == umagic(64, c).s-1 && x.Op != OpConst64 && udivisibleOK(64, c)) {
 20164				break
 20165			}
 20166			v.reset(OpLeq64U)
 20167			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 20168			v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 20169			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20170			v2.AuxInt = int64(udivisible(64, c).m)
 20171			v1.AddArg(v2)
 20172			v1.AddArg(x)
 20173			v0.AddArg(v1)
 20174			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20175			v3.AuxInt = int64(64 - udivisible(64, c).k)
 20176			v0.AddArg(v3)
 20177			v.AddArg(v0)
 20178			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20179			v4.AuxInt = int64(udivisible(64, c).max)
 20180			v.AddArg(v4)
 20181			return true
 20182		}
 20183		// match: (Eq64 (Mul64 (Const64 [c]) (Rsh64Ux64 mul:(Hmul64u (Const64 [m]) x) (Const64 [s]))) x)
 20184		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+umagic(64,c).m/2) && s == umagic(64,c).s-1 && x.Op != OpConst64 && udivisibleOK(64,c)
 20185		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) )
 20186		for {
 20187			x := v.Args[1]
 20188			v_0 := v.Args[0]
 20189			if v_0.Op != OpMul64 {
 20190				break
 20191			}
 20192			_ = v_0.Args[1]
 20193			v_0_0 := v_0.Args[0]
 20194			if v_0_0.Op != OpConst64 {
 20195				break
 20196			}
 20197			c := v_0_0.AuxInt
 20198			v_0_1 := v_0.Args[1]
 20199			if v_0_1.Op != OpRsh64Ux64 {
 20200				break
 20201			}
 20202			_ = v_0_1.Args[1]
 20203			mul := v_0_1.Args[0]
 20204			if mul.Op != OpHmul64u {
 20205				break
 20206			}
 20207			_ = mul.Args[1]
 20208			mul_0 := mul.Args[0]
 20209			if mul_0.Op != OpConst64 {
 20210				break
 20211			}
 20212			m := mul_0.AuxInt
 20213			if x != mul.Args[1] {
 20214				break
 20215			}
 20216			v_0_1_1 := v_0_1.Args[1]
 20217			if v_0_1_1.Op != OpConst64 {
 20218				break
 20219			}
 20220			s := v_0_1_1.AuxInt
 20221			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+umagic(64, c).m/2) && s == umagic(64, c).s-1 && x.Op != OpConst64 && udivisibleOK(64, c)) {
 20222				break
 20223			}
 20224			v.reset(OpLeq64U)
 20225			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 20226			v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 20227			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20228			v2.AuxInt = int64(udivisible(64, c).m)
 20229			v1.AddArg(v2)
 20230			v1.AddArg(x)
 20231			v0.AddArg(v1)
 20232			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20233			v3.AuxInt = int64(64 - udivisible(64, c).k)
 20234			v0.AddArg(v3)
 20235			v.AddArg(v0)
 20236			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20237			v4.AuxInt = int64(udivisible(64, c).max)
 20238			v.AddArg(v4)
 20239			return true
 20240		}
 20241		// match: (Eq64 (Mul64 (Const64 [c]) (Rsh64Ux64 mul:(Hmul64u x (Const64 [m])) (Const64 [s]))) x)
 20242		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+umagic(64,c).m/2) && s == umagic(64,c).s-1 && x.Op != OpConst64 && udivisibleOK(64,c)
 20243		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) )
 20244		for {
 20245			x := v.Args[1]
 20246			v_0 := v.Args[0]
 20247			if v_0.Op != OpMul64 {
 20248				break
 20249			}
 20250			_ = v_0.Args[1]
 20251			v_0_0 := v_0.Args[0]
 20252			if v_0_0.Op != OpConst64 {
 20253				break
 20254			}
 20255			c := v_0_0.AuxInt
 20256			v_0_1 := v_0.Args[1]
 20257			if v_0_1.Op != OpRsh64Ux64 {
 20258				break
 20259			}
 20260			_ = v_0_1.Args[1]
 20261			mul := v_0_1.Args[0]
 20262			if mul.Op != OpHmul64u {
 20263				break
 20264			}
 20265			_ = mul.Args[1]
 20266			if x != mul.Args[0] {
 20267				break
 20268			}
 20269			mul_1 := mul.Args[1]
 20270			if mul_1.Op != OpConst64 {
 20271				break
 20272			}
 20273			m := mul_1.AuxInt
 20274			v_0_1_1 := v_0_1.Args[1]
 20275			if v_0_1_1.Op != OpConst64 {
 20276				break
 20277			}
 20278			s := v_0_1_1.AuxInt
 20279			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+umagic(64, c).m/2) && s == umagic(64, c).s-1 && x.Op != OpConst64 && udivisibleOK(64, c)) {
 20280				break
 20281			}
 20282			v.reset(OpLeq64U)
 20283			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 20284			v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 20285			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20286			v2.AuxInt = int64(udivisible(64, c).m)
 20287			v1.AddArg(v2)
 20288			v1.AddArg(x)
 20289			v0.AddArg(v1)
 20290			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20291			v3.AuxInt = int64(64 - udivisible(64, c).k)
 20292			v0.AddArg(v3)
 20293			v.AddArg(v0)
 20294			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20295			v4.AuxInt = int64(udivisible(64, c).max)
 20296			v.AddArg(v4)
 20297			return true
 20298		}
 20299		// match: (Eq64 (Mul64 (Rsh64Ux64 mul:(Hmul64u (Const64 [m]) x) (Const64 [s])) (Const64 [c])) x)
 20300		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+umagic(64,c).m/2) && s == umagic(64,c).s-1 && x.Op != OpConst64 && udivisibleOK(64,c)
 20301		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) )
 20302		for {
 20303			x := v.Args[1]
 20304			v_0 := v.Args[0]
 20305			if v_0.Op != OpMul64 {
 20306				break
 20307			}
 20308			_ = v_0.Args[1]
 20309			v_0_0 := v_0.Args[0]
 20310			if v_0_0.Op != OpRsh64Ux64 {
 20311				break
 20312			}
 20313			_ = v_0_0.Args[1]
 20314			mul := v_0_0.Args[0]
 20315			if mul.Op != OpHmul64u {
 20316				break
 20317			}
 20318			_ = mul.Args[1]
 20319			mul_0 := mul.Args[0]
 20320			if mul_0.Op != OpConst64 {
 20321				break
 20322			}
 20323			m := mul_0.AuxInt
 20324			if x != mul.Args[1] {
 20325				break
 20326			}
 20327			v_0_0_1 := v_0_0.Args[1]
 20328			if v_0_0_1.Op != OpConst64 {
 20329				break
 20330			}
 20331			s := v_0_0_1.AuxInt
 20332			v_0_1 := v_0.Args[1]
 20333			if v_0_1.Op != OpConst64 {
 20334				break
 20335			}
 20336			c := v_0_1.AuxInt
 20337			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+umagic(64, c).m/2) && s == umagic(64, c).s-1 && x.Op != OpConst64 && udivisibleOK(64, c)) {
 20338				break
 20339			}
 20340			v.reset(OpLeq64U)
 20341			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 20342			v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 20343			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20344			v2.AuxInt = int64(udivisible(64, c).m)
 20345			v1.AddArg(v2)
 20346			v1.AddArg(x)
 20347			v0.AddArg(v1)
 20348			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20349			v3.AuxInt = int64(64 - udivisible(64, c).k)
 20350			v0.AddArg(v3)
 20351			v.AddArg(v0)
 20352			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20353			v4.AuxInt = int64(udivisible(64, c).max)
 20354			v.AddArg(v4)
 20355			return true
 20356		}
 20357		// match: (Eq64 (Mul64 (Rsh64Ux64 mul:(Hmul64u x (Const64 [m])) (Const64 [s])) (Const64 [c])) x)
 20358		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+umagic(64,c).m/2) && s == umagic(64,c).s-1 && x.Op != OpConst64 && udivisibleOK(64,c)
 20359		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) )
 20360		for {
 20361			x := v.Args[1]
 20362			v_0 := v.Args[0]
 20363			if v_0.Op != OpMul64 {
 20364				break
 20365			}
 20366			_ = v_0.Args[1]
 20367			v_0_0 := v_0.Args[0]
 20368			if v_0_0.Op != OpRsh64Ux64 {
 20369				break
 20370			}
 20371			_ = v_0_0.Args[1]
 20372			mul := v_0_0.Args[0]
 20373			if mul.Op != OpHmul64u {
 20374				break
 20375			}
 20376			_ = mul.Args[1]
 20377			if x != mul.Args[0] {
 20378				break
 20379			}
 20380			mul_1 := mul.Args[1]
 20381			if mul_1.Op != OpConst64 {
 20382				break
 20383			}
 20384			m := mul_1.AuxInt
 20385			v_0_0_1 := v_0_0.Args[1]
 20386			if v_0_0_1.Op != OpConst64 {
 20387				break
 20388			}
 20389			s := v_0_0_1.AuxInt
 20390			v_0_1 := v_0.Args[1]
 20391			if v_0_1.Op != OpConst64 {
 20392				break
 20393			}
 20394			c := v_0_1.AuxInt
 20395			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+umagic(64, c).m/2) && s == umagic(64, c).s-1 && x.Op != OpConst64 && udivisibleOK(64, c)) {
 20396				break
 20397			}
 20398			v.reset(OpLeq64U)
 20399			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 20400			v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 20401			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20402			v2.AuxInt = int64(udivisible(64, c).m)
 20403			v1.AddArg(v2)
 20404			v1.AddArg(x)
 20405			v0.AddArg(v1)
 20406			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20407			v3.AuxInt = int64(64 - udivisible(64, c).k)
 20408			v0.AddArg(v3)
 20409			v.AddArg(v0)
 20410			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20411			v4.AuxInt = int64(udivisible(64, c).max)
 20412			v.AddArg(v4)
 20413			return true
 20414		}
 20415		// match: (Eq64 x (Mul64 (Const64 [c]) (Rsh64Ux64 mul:(Hmul64u (Const64 [m]) (Rsh64Ux64 x (Const64 [1]))) (Const64 [s]))))
 20416		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+(umagic(64,c).m+1)/2) && s == umagic(64,c).s-2 && x.Op != OpConst64 && udivisibleOK(64,c)
 20417		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) )
 20418		for {
 20419			_ = v.Args[1]
 20420			x := v.Args[0]
 20421			v_1 := v.Args[1]
 20422			if v_1.Op != OpMul64 {
 20423				break
 20424			}
 20425			_ = v_1.Args[1]
 20426			v_1_0 := v_1.Args[0]
 20427			if v_1_0.Op != OpConst64 {
 20428				break
 20429			}
 20430			c := v_1_0.AuxInt
 20431			v_1_1 := v_1.Args[1]
 20432			if v_1_1.Op != OpRsh64Ux64 {
 20433				break
 20434			}
 20435			_ = v_1_1.Args[1]
 20436			mul := v_1_1.Args[0]
 20437			if mul.Op != OpHmul64u {
 20438				break
 20439			}
 20440			_ = mul.Args[1]
 20441			mul_0 := mul.Args[0]
 20442			if mul_0.Op != OpConst64 {
 20443				break
 20444			}
 20445			m := mul_0.AuxInt
 20446			mul_1 := mul.Args[1]
 20447			if mul_1.Op != OpRsh64Ux64 {
 20448				break
 20449			}
 20450			_ = mul_1.Args[1]
 20451			if x != mul_1.Args[0] {
 20452				break
 20453			}
 20454			mul_1_1 := mul_1.Args[1]
 20455			if mul_1_1.Op != OpConst64 {
 20456				break
 20457			}
 20458			if mul_1_1.AuxInt != 1 {
 20459				break
 20460			}
 20461			v_1_1_1 := v_1_1.Args[1]
 20462			if v_1_1_1.Op != OpConst64 {
 20463				break
 20464			}
 20465			s := v_1_1_1.AuxInt
 20466			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+(umagic(64, c).m+1)/2) && s == umagic(64, c).s-2 && x.Op != OpConst64 && udivisibleOK(64, c)) {
 20467				break
 20468			}
 20469			v.reset(OpLeq64U)
 20470			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 20471			v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 20472			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20473			v2.AuxInt = int64(udivisible(64, c).m)
 20474			v1.AddArg(v2)
 20475			v1.AddArg(x)
 20476			v0.AddArg(v1)
 20477			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20478			v3.AuxInt = int64(64 - udivisible(64, c).k)
 20479			v0.AddArg(v3)
 20480			v.AddArg(v0)
 20481			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20482			v4.AuxInt = int64(udivisible(64, c).max)
 20483			v.AddArg(v4)
 20484			return true
 20485		}
 20486		// match: (Eq64 x (Mul64 (Const64 [c]) (Rsh64Ux64 mul:(Hmul64u (Rsh64Ux64 x (Const64 [1])) (Const64 [m])) (Const64 [s]))))
 20487		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+(umagic(64,c).m+1)/2) && s == umagic(64,c).s-2 && x.Op != OpConst64 && udivisibleOK(64,c)
 20488		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) )
 20489		for {
 20490			_ = v.Args[1]
 20491			x := v.Args[0]
 20492			v_1 := v.Args[1]
 20493			if v_1.Op != OpMul64 {
 20494				break
 20495			}
 20496			_ = v_1.Args[1]
 20497			v_1_0 := v_1.Args[0]
 20498			if v_1_0.Op != OpConst64 {
 20499				break
 20500			}
 20501			c := v_1_0.AuxInt
 20502			v_1_1 := v_1.Args[1]
 20503			if v_1_1.Op != OpRsh64Ux64 {
 20504				break
 20505			}
 20506			_ = v_1_1.Args[1]
 20507			mul := v_1_1.Args[0]
 20508			if mul.Op != OpHmul64u {
 20509				break
 20510			}
 20511			_ = mul.Args[1]
 20512			mul_0 := mul.Args[0]
 20513			if mul_0.Op != OpRsh64Ux64 {
 20514				break
 20515			}
 20516			_ = mul_0.Args[1]
 20517			if x != mul_0.Args[0] {
 20518				break
 20519			}
 20520			mul_0_1 := mul_0.Args[1]
 20521			if mul_0_1.Op != OpConst64 {
 20522				break
 20523			}
 20524			if mul_0_1.AuxInt != 1 {
 20525				break
 20526			}
 20527			mul_1 := mul.Args[1]
 20528			if mul_1.Op != OpConst64 {
 20529				break
 20530			}
 20531			m := mul_1.AuxInt
 20532			v_1_1_1 := v_1_1.Args[1]
 20533			if v_1_1_1.Op != OpConst64 {
 20534				break
 20535			}
 20536			s := v_1_1_1.AuxInt
 20537			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+(umagic(64, c).m+1)/2) && s == umagic(64, c).s-2 && x.Op != OpConst64 && udivisibleOK(64, c)) {
 20538				break
 20539			}
 20540			v.reset(OpLeq64U)
 20541			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 20542			v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 20543			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20544			v2.AuxInt = int64(udivisible(64, c).m)
 20545			v1.AddArg(v2)
 20546			v1.AddArg(x)
 20547			v0.AddArg(v1)
 20548			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20549			v3.AuxInt = int64(64 - udivisible(64, c).k)
 20550			v0.AddArg(v3)
 20551			v.AddArg(v0)
 20552			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20553			v4.AuxInt = int64(udivisible(64, c).max)
 20554			v.AddArg(v4)
 20555			return true
 20556		}
 20557		// match: (Eq64 x (Mul64 (Rsh64Ux64 mul:(Hmul64u (Const64 [m]) (Rsh64Ux64 x (Const64 [1]))) (Const64 [s])) (Const64 [c])))
 20558		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+(umagic(64,c).m+1)/2) && s == umagic(64,c).s-2 && x.Op != OpConst64 && udivisibleOK(64,c)
 20559		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) )
 20560		for {
 20561			_ = v.Args[1]
 20562			x := v.Args[0]
 20563			v_1 := v.Args[1]
 20564			if v_1.Op != OpMul64 {
 20565				break
 20566			}
 20567			_ = v_1.Args[1]
 20568			v_1_0 := v_1.Args[0]
 20569			if v_1_0.Op != OpRsh64Ux64 {
 20570				break
 20571			}
 20572			_ = v_1_0.Args[1]
 20573			mul := v_1_0.Args[0]
 20574			if mul.Op != OpHmul64u {
 20575				break
 20576			}
 20577			_ = mul.Args[1]
 20578			mul_0 := mul.Args[0]
 20579			if mul_0.Op != OpConst64 {
 20580				break
 20581			}
 20582			m := mul_0.AuxInt
 20583			mul_1 := mul.Args[1]
 20584			if mul_1.Op != OpRsh64Ux64 {
 20585				break
 20586			}
 20587			_ = mul_1.Args[1]
 20588			if x != mul_1.Args[0] {
 20589				break
 20590			}
 20591			mul_1_1 := mul_1.Args[1]
 20592			if mul_1_1.Op != OpConst64 {
 20593				break
 20594			}
 20595			if mul_1_1.AuxInt != 1 {
 20596				break
 20597			}
 20598			v_1_0_1 := v_1_0.Args[1]
 20599			if v_1_0_1.Op != OpConst64 {
 20600				break
 20601			}
 20602			s := v_1_0_1.AuxInt
 20603			v_1_1 := v_1.Args[1]
 20604			if v_1_1.Op != OpConst64 {
 20605				break
 20606			}
 20607			c := v_1_1.AuxInt
 20608			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+(umagic(64, c).m+1)/2) && s == umagic(64, c).s-2 && x.Op != OpConst64 && udivisibleOK(64, c)) {
 20609				break
 20610			}
 20611			v.reset(OpLeq64U)
 20612			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 20613			v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 20614			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20615			v2.AuxInt = int64(udivisible(64, c).m)
 20616			v1.AddArg(v2)
 20617			v1.AddArg(x)
 20618			v0.AddArg(v1)
 20619			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20620			v3.AuxInt = int64(64 - udivisible(64, c).k)
 20621			v0.AddArg(v3)
 20622			v.AddArg(v0)
 20623			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20624			v4.AuxInt = int64(udivisible(64, c).max)
 20625			v.AddArg(v4)
 20626			return true
 20627		}
 20628		// match: (Eq64 x (Mul64 (Rsh64Ux64 mul:(Hmul64u (Rsh64Ux64 x (Const64 [1])) (Const64 [m])) (Const64 [s])) (Const64 [c])))
 20629		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+(umagic(64,c).m+1)/2) && s == umagic(64,c).s-2 && x.Op != OpConst64 && udivisibleOK(64,c)
 20630		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) )
 20631		for {
 20632			_ = v.Args[1]
 20633			x := v.Args[0]
 20634			v_1 := v.Args[1]
 20635			if v_1.Op != OpMul64 {
 20636				break
 20637			}
 20638			_ = v_1.Args[1]
 20639			v_1_0 := v_1.Args[0]
 20640			if v_1_0.Op != OpRsh64Ux64 {
 20641				break
 20642			}
 20643			_ = v_1_0.Args[1]
 20644			mul := v_1_0.Args[0]
 20645			if mul.Op != OpHmul64u {
 20646				break
 20647			}
 20648			_ = mul.Args[1]
 20649			mul_0 := mul.Args[0]
 20650			if mul_0.Op != OpRsh64Ux64 {
 20651				break
 20652			}
 20653			_ = mul_0.Args[1]
 20654			if x != mul_0.Args[0] {
 20655				break
 20656			}
 20657			mul_0_1 := mul_0.Args[1]
 20658			if mul_0_1.Op != OpConst64 {
 20659				break
 20660			}
 20661			if mul_0_1.AuxInt != 1 {
 20662				break
 20663			}
 20664			mul_1 := mul.Args[1]
 20665			if mul_1.Op != OpConst64 {
 20666				break
 20667			}
 20668			m := mul_1.AuxInt
 20669			v_1_0_1 := v_1_0.Args[1]
 20670			if v_1_0_1.Op != OpConst64 {
 20671				break
 20672			}
 20673			s := v_1_0_1.AuxInt
 20674			v_1_1 := v_1.Args[1]
 20675			if v_1_1.Op != OpConst64 {
 20676				break
 20677			}
 20678			c := v_1_1.AuxInt
 20679			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+(umagic(64, c).m+1)/2) && s == umagic(64, c).s-2 && x.Op != OpConst64 && udivisibleOK(64, c)) {
 20680				break
 20681			}
 20682			v.reset(OpLeq64U)
 20683			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 20684			v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 20685			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20686			v2.AuxInt = int64(udivisible(64, c).m)
 20687			v1.AddArg(v2)
 20688			v1.AddArg(x)
 20689			v0.AddArg(v1)
 20690			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20691			v3.AuxInt = int64(64 - udivisible(64, c).k)
 20692			v0.AddArg(v3)
 20693			v.AddArg(v0)
 20694			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20695			v4.AuxInt = int64(udivisible(64, c).max)
 20696			v.AddArg(v4)
 20697			return true
 20698		}
 20699		// match: (Eq64 (Mul64 (Const64 [c]) (Rsh64Ux64 mul:(Hmul64u (Const64 [m]) (Rsh64Ux64 x (Const64 [1]))) (Const64 [s]))) x)
 20700		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+(umagic(64,c).m+1)/2) && s == umagic(64,c).s-2 && x.Op != OpConst64 && udivisibleOK(64,c)
 20701		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) )
 20702		for {
 20703			x := v.Args[1]
 20704			v_0 := v.Args[0]
 20705			if v_0.Op != OpMul64 {
 20706				break
 20707			}
 20708			_ = v_0.Args[1]
 20709			v_0_0 := v_0.Args[0]
 20710			if v_0_0.Op != OpConst64 {
 20711				break
 20712			}
 20713			c := v_0_0.AuxInt
 20714			v_0_1 := v_0.Args[1]
 20715			if v_0_1.Op != OpRsh64Ux64 {
 20716				break
 20717			}
 20718			_ = v_0_1.Args[1]
 20719			mul := v_0_1.Args[0]
 20720			if mul.Op != OpHmul64u {
 20721				break
 20722			}
 20723			_ = mul.Args[1]
 20724			mul_0 := mul.Args[0]
 20725			if mul_0.Op != OpConst64 {
 20726				break
 20727			}
 20728			m := mul_0.AuxInt
 20729			mul_1 := mul.Args[1]
 20730			if mul_1.Op != OpRsh64Ux64 {
 20731				break
 20732			}
 20733			_ = mul_1.Args[1]
 20734			if x != mul_1.Args[0] {
 20735				break
 20736			}
 20737			mul_1_1 := mul_1.Args[1]
 20738			if mul_1_1.Op != OpConst64 {
 20739				break
 20740			}
 20741			if mul_1_1.AuxInt != 1 {
 20742				break
 20743			}
 20744			v_0_1_1 := v_0_1.Args[1]
 20745			if v_0_1_1.Op != OpConst64 {
 20746				break
 20747			}
 20748			s := v_0_1_1.AuxInt
 20749			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+(umagic(64, c).m+1)/2) && s == umagic(64, c).s-2 && x.Op != OpConst64 && udivisibleOK(64, c)) {
 20750				break
 20751			}
 20752			v.reset(OpLeq64U)
 20753			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 20754			v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 20755			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20756			v2.AuxInt = int64(udivisible(64, c).m)
 20757			v1.AddArg(v2)
 20758			v1.AddArg(x)
 20759			v0.AddArg(v1)
 20760			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20761			v3.AuxInt = int64(64 - udivisible(64, c).k)
 20762			v0.AddArg(v3)
 20763			v.AddArg(v0)
 20764			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20765			v4.AuxInt = int64(udivisible(64, c).max)
 20766			v.AddArg(v4)
 20767			return true
 20768		}
 20769		return false
 20770	}
 20771	func rewriteValuegeneric_OpEq64_20(v *Value) bool {
 20772		b := v.Block
 20773		typ := &b.Func.Config.Types
 20774		// match: (Eq64 (Mul64 (Const64 [c]) (Rsh64Ux64 mul:(Hmul64u (Rsh64Ux64 x (Const64 [1])) (Const64 [m])) (Const64 [s]))) x)
 20775		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+(umagic(64,c).m+1)/2) && s == umagic(64,c).s-2 && x.Op != OpConst64 && udivisibleOK(64,c)
 20776		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) )
 20777		for {
 20778			x := v.Args[1]
 20779			v_0 := v.Args[0]
 20780			if v_0.Op != OpMul64 {
 20781				break
 20782			}
 20783			_ = v_0.Args[1]
 20784			v_0_0 := v_0.Args[0]
 20785			if v_0_0.Op != OpConst64 {
 20786				break
 20787			}
 20788			c := v_0_0.AuxInt
 20789			v_0_1 := v_0.Args[1]
 20790			if v_0_1.Op != OpRsh64Ux64 {
 20791				break
 20792			}
 20793			_ = v_0_1.Args[1]
 20794			mul := v_0_1.Args[0]
 20795			if mul.Op != OpHmul64u {
 20796				break
 20797			}
 20798			_ = mul.Args[1]
 20799			mul_0 := mul.Args[0]
 20800			if mul_0.Op != OpRsh64Ux64 {
 20801				break
 20802			}
 20803			_ = mul_0.Args[1]
 20804			if x != mul_0.Args[0] {
 20805				break
 20806			}
 20807			mul_0_1 := mul_0.Args[1]
 20808			if mul_0_1.Op != OpConst64 {
 20809				break
 20810			}
 20811			if mul_0_1.AuxInt != 1 {
 20812				break
 20813			}
 20814			mul_1 := mul.Args[1]
 20815			if mul_1.Op != OpConst64 {
 20816				break
 20817			}
 20818			m := mul_1.AuxInt
 20819			v_0_1_1 := v_0_1.Args[1]
 20820			if v_0_1_1.Op != OpConst64 {
 20821				break
 20822			}
 20823			s := v_0_1_1.AuxInt
 20824			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+(umagic(64, c).m+1)/2) && s == umagic(64, c).s-2 && x.Op != OpConst64 && udivisibleOK(64, c)) {
 20825				break
 20826			}
 20827			v.reset(OpLeq64U)
 20828			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 20829			v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 20830			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20831			v2.AuxInt = int64(udivisible(64, c).m)
 20832			v1.AddArg(v2)
 20833			v1.AddArg(x)
 20834			v0.AddArg(v1)
 20835			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20836			v3.AuxInt = int64(64 - udivisible(64, c).k)
 20837			v0.AddArg(v3)
 20838			v.AddArg(v0)
 20839			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20840			v4.AuxInt = int64(udivisible(64, c).max)
 20841			v.AddArg(v4)
 20842			return true
 20843		}
 20844		// match: (Eq64 (Mul64 (Rsh64Ux64 mul:(Hmul64u (Const64 [m]) (Rsh64Ux64 x (Const64 [1]))) (Const64 [s])) (Const64 [c])) x)
 20845		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+(umagic(64,c).m+1)/2) && s == umagic(64,c).s-2 && x.Op != OpConst64 && udivisibleOK(64,c)
 20846		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) )
 20847		for {
 20848			x := v.Args[1]
 20849			v_0 := v.Args[0]
 20850			if v_0.Op != OpMul64 {
 20851				break
 20852			}
 20853			_ = v_0.Args[1]
 20854			v_0_0 := v_0.Args[0]
 20855			if v_0_0.Op != OpRsh64Ux64 {
 20856				break
 20857			}
 20858			_ = v_0_0.Args[1]
 20859			mul := v_0_0.Args[0]
 20860			if mul.Op != OpHmul64u {
 20861				break
 20862			}
 20863			_ = mul.Args[1]
 20864			mul_0 := mul.Args[0]
 20865			if mul_0.Op != OpConst64 {
 20866				break
 20867			}
 20868			m := mul_0.AuxInt
 20869			mul_1 := mul.Args[1]
 20870			if mul_1.Op != OpRsh64Ux64 {
 20871				break
 20872			}
 20873			_ = mul_1.Args[1]
 20874			if x != mul_1.Args[0] {
 20875				break
 20876			}
 20877			mul_1_1 := mul_1.Args[1]
 20878			if mul_1_1.Op != OpConst64 {
 20879				break
 20880			}
 20881			if mul_1_1.AuxInt != 1 {
 20882				break
 20883			}
 20884			v_0_0_1 := v_0_0.Args[1]
 20885			if v_0_0_1.Op != OpConst64 {
 20886				break
 20887			}
 20888			s := v_0_0_1.AuxInt
 20889			v_0_1 := v_0.Args[1]
 20890			if v_0_1.Op != OpConst64 {
 20891				break
 20892			}
 20893			c := v_0_1.AuxInt
 20894			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+(umagic(64, c).m+1)/2) && s == umagic(64, c).s-2 && x.Op != OpConst64 && udivisibleOK(64, c)) {
 20895				break
 20896			}
 20897			v.reset(OpLeq64U)
 20898			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 20899			v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 20900			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20901			v2.AuxInt = int64(udivisible(64, c).m)
 20902			v1.AddArg(v2)
 20903			v1.AddArg(x)
 20904			v0.AddArg(v1)
 20905			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20906			v3.AuxInt = int64(64 - udivisible(64, c).k)
 20907			v0.AddArg(v3)
 20908			v.AddArg(v0)
 20909			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20910			v4.AuxInt = int64(udivisible(64, c).max)
 20911			v.AddArg(v4)
 20912			return true
 20913		}
 20914		// match: (Eq64 (Mul64 (Rsh64Ux64 mul:(Hmul64u (Rsh64Ux64 x (Const64 [1])) (Const64 [m])) (Const64 [s])) (Const64 [c])) x)
 20915		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+(umagic(64,c).m+1)/2) && s == umagic(64,c).s-2 && x.Op != OpConst64 && udivisibleOK(64,c)
 20916		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) )
 20917		for {
 20918			x := v.Args[1]
 20919			v_0 := v.Args[0]
 20920			if v_0.Op != OpMul64 {
 20921				break
 20922			}
 20923			_ = v_0.Args[1]
 20924			v_0_0 := v_0.Args[0]
 20925			if v_0_0.Op != OpRsh64Ux64 {
 20926				break
 20927			}
 20928			_ = v_0_0.Args[1]
 20929			mul := v_0_0.Args[0]
 20930			if mul.Op != OpHmul64u {
 20931				break
 20932			}
 20933			_ = mul.Args[1]
 20934			mul_0 := mul.Args[0]
 20935			if mul_0.Op != OpRsh64Ux64 {
 20936				break
 20937			}
 20938			_ = mul_0.Args[1]
 20939			if x != mul_0.Args[0] {
 20940				break
 20941			}
 20942			mul_0_1 := mul_0.Args[1]
 20943			if mul_0_1.Op != OpConst64 {
 20944				break
 20945			}
 20946			if mul_0_1.AuxInt != 1 {
 20947				break
 20948			}
 20949			mul_1 := mul.Args[1]
 20950			if mul_1.Op != OpConst64 {
 20951				break
 20952			}
 20953			m := mul_1.AuxInt
 20954			v_0_0_1 := v_0_0.Args[1]
 20955			if v_0_0_1.Op != OpConst64 {
 20956				break
 20957			}
 20958			s := v_0_0_1.AuxInt
 20959			v_0_1 := v_0.Args[1]
 20960			if v_0_1.Op != OpConst64 {
 20961				break
 20962			}
 20963			c := v_0_1.AuxInt
 20964			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+(umagic(64, c).m+1)/2) && s == umagic(64, c).s-2 && x.Op != OpConst64 && udivisibleOK(64, c)) {
 20965				break
 20966			}
 20967			v.reset(OpLeq64U)
 20968			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 20969			v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 20970			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20971			v2.AuxInt = int64(udivisible(64, c).m)
 20972			v1.AddArg(v2)
 20973			v1.AddArg(x)
 20974			v0.AddArg(v1)
 20975			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20976			v3.AuxInt = int64(64 - udivisible(64, c).k)
 20977			v0.AddArg(v3)
 20978			v.AddArg(v0)
 20979			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 20980			v4.AuxInt = int64(udivisible(64, c).max)
 20981			v.AddArg(v4)
 20982			return true
 20983		}
 20984		// match: (Eq64 x (Mul64 (Const64 [c]) (Rsh64Ux64 (Avg64u x mul:(Hmul64u (Const64 [m]) x)) (Const64 [s]))))
 20985		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(64,c).m) && s == umagic(64,c).s-1 && x.Op != OpConst64 && udivisibleOK(64,c)
 20986		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) )
 20987		for {
 20988			_ = v.Args[1]
 20989			x := v.Args[0]
 20990			v_1 := v.Args[1]
 20991			if v_1.Op != OpMul64 {
 20992				break
 20993			}
 20994			_ = v_1.Args[1]
 20995			v_1_0 := v_1.Args[0]
 20996			if v_1_0.Op != OpConst64 {
 20997				break
 20998			}
 20999			c := v_1_0.AuxInt
 21000			v_1_1 := v_1.Args[1]
 21001			if v_1_1.Op != OpRsh64Ux64 {
 21002				break
 21003			}
 21004			_ = v_1_1.Args[1]
 21005			v_1_1_0 := v_1_1.Args[0]
 21006			if v_1_1_0.Op != OpAvg64u {
 21007				break
 21008			}
 21009			_ = v_1_1_0.Args[1]
 21010			if x != v_1_1_0.Args[0] {
 21011				break
 21012			}
 21013			mul := v_1_1_0.Args[1]
 21014			if mul.Op != OpHmul64u {
 21015				break
 21016			}
 21017			_ = mul.Args[1]
 21018			mul_0 := mul.Args[0]
 21019			if mul_0.Op != OpConst64 {
 21020				break
 21021			}
 21022			m := mul_0.AuxInt
 21023			if x != mul.Args[1] {
 21024				break
 21025			}
 21026			v_1_1_1 := v_1_1.Args[1]
 21027			if v_1_1_1.Op != OpConst64 {
 21028				break
 21029			}
 21030			s := v_1_1_1.AuxInt
 21031			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(64, c).m) && s == umagic(64, c).s-1 && x.Op != OpConst64 && udivisibleOK(64, c)) {
 21032				break
 21033			}
 21034			v.reset(OpLeq64U)
 21035			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 21036			v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 21037			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21038			v2.AuxInt = int64(udivisible(64, c).m)
 21039			v1.AddArg(v2)
 21040			v1.AddArg(x)
 21041			v0.AddArg(v1)
 21042			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21043			v3.AuxInt = int64(64 - udivisible(64, c).k)
 21044			v0.AddArg(v3)
 21045			v.AddArg(v0)
 21046			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21047			v4.AuxInt = int64(udivisible(64, c).max)
 21048			v.AddArg(v4)
 21049			return true
 21050		}
 21051		// match: (Eq64 x (Mul64 (Const64 [c]) (Rsh64Ux64 (Avg64u x mul:(Hmul64u x (Const64 [m]))) (Const64 [s]))))
 21052		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(64,c).m) && s == umagic(64,c).s-1 && x.Op != OpConst64 && udivisibleOK(64,c)
 21053		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) )
 21054		for {
 21055			_ = v.Args[1]
 21056			x := v.Args[0]
 21057			v_1 := v.Args[1]
 21058			if v_1.Op != OpMul64 {
 21059				break
 21060			}
 21061			_ = v_1.Args[1]
 21062			v_1_0 := v_1.Args[0]
 21063			if v_1_0.Op != OpConst64 {
 21064				break
 21065			}
 21066			c := v_1_0.AuxInt
 21067			v_1_1 := v_1.Args[1]
 21068			if v_1_1.Op != OpRsh64Ux64 {
 21069				break
 21070			}
 21071			_ = v_1_1.Args[1]
 21072			v_1_1_0 := v_1_1.Args[0]
 21073			if v_1_1_0.Op != OpAvg64u {
 21074				break
 21075			}
 21076			_ = v_1_1_0.Args[1]
 21077			if x != v_1_1_0.Args[0] {
 21078				break
 21079			}
 21080			mul := v_1_1_0.Args[1]
 21081			if mul.Op != OpHmul64u {
 21082				break
 21083			}
 21084			_ = mul.Args[1]
 21085			if x != mul.Args[0] {
 21086				break
 21087			}
 21088			mul_1 := mul.Args[1]
 21089			if mul_1.Op != OpConst64 {
 21090				break
 21091			}
 21092			m := mul_1.AuxInt
 21093			v_1_1_1 := v_1_1.Args[1]
 21094			if v_1_1_1.Op != OpConst64 {
 21095				break
 21096			}
 21097			s := v_1_1_1.AuxInt
 21098			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(64, c).m) && s == umagic(64, c).s-1 && x.Op != OpConst64 && udivisibleOK(64, c)) {
 21099				break
 21100			}
 21101			v.reset(OpLeq64U)
 21102			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 21103			v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 21104			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21105			v2.AuxInt = int64(udivisible(64, c).m)
 21106			v1.AddArg(v2)
 21107			v1.AddArg(x)
 21108			v0.AddArg(v1)
 21109			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21110			v3.AuxInt = int64(64 - udivisible(64, c).k)
 21111			v0.AddArg(v3)
 21112			v.AddArg(v0)
 21113			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21114			v4.AuxInt = int64(udivisible(64, c).max)
 21115			v.AddArg(v4)
 21116			return true
 21117		}
 21118		// match: (Eq64 x (Mul64 (Rsh64Ux64 (Avg64u x mul:(Hmul64u (Const64 [m]) x)) (Const64 [s])) (Const64 [c])))
 21119		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(64,c).m) && s == umagic(64,c).s-1 && x.Op != OpConst64 && udivisibleOK(64,c)
 21120		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) )
 21121		for {
 21122			_ = v.Args[1]
 21123			x := v.Args[0]
 21124			v_1 := v.Args[1]
 21125			if v_1.Op != OpMul64 {
 21126				break
 21127			}
 21128			_ = v_1.Args[1]
 21129			v_1_0 := v_1.Args[0]
 21130			if v_1_0.Op != OpRsh64Ux64 {
 21131				break
 21132			}
 21133			_ = v_1_0.Args[1]
 21134			v_1_0_0 := v_1_0.Args[0]
 21135			if v_1_0_0.Op != OpAvg64u {
 21136				break
 21137			}
 21138			_ = v_1_0_0.Args[1]
 21139			if x != v_1_0_0.Args[0] {
 21140				break
 21141			}
 21142			mul := v_1_0_0.Args[1]
 21143			if mul.Op != OpHmul64u {
 21144				break
 21145			}
 21146			_ = mul.Args[1]
 21147			mul_0 := mul.Args[0]
 21148			if mul_0.Op != OpConst64 {
 21149				break
 21150			}
 21151			m := mul_0.AuxInt
 21152			if x != mul.Args[1] {
 21153				break
 21154			}
 21155			v_1_0_1 := v_1_0.Args[1]
 21156			if v_1_0_1.Op != OpConst64 {
 21157				break
 21158			}
 21159			s := v_1_0_1.AuxInt
 21160			v_1_1 := v_1.Args[1]
 21161			if v_1_1.Op != OpConst64 {
 21162				break
 21163			}
 21164			c := v_1_1.AuxInt
 21165			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(64, c).m) && s == umagic(64, c).s-1 && x.Op != OpConst64 && udivisibleOK(64, c)) {
 21166				break
 21167			}
 21168			v.reset(OpLeq64U)
 21169			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 21170			v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 21171			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21172			v2.AuxInt = int64(udivisible(64, c).m)
 21173			v1.AddArg(v2)
 21174			v1.AddArg(x)
 21175			v0.AddArg(v1)
 21176			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21177			v3.AuxInt = int64(64 - udivisible(64, c).k)
 21178			v0.AddArg(v3)
 21179			v.AddArg(v0)
 21180			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21181			v4.AuxInt = int64(udivisible(64, c).max)
 21182			v.AddArg(v4)
 21183			return true
 21184		}
 21185		// match: (Eq64 x (Mul64 (Rsh64Ux64 (Avg64u x mul:(Hmul64u x (Const64 [m]))) (Const64 [s])) (Const64 [c])))
 21186		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(64,c).m) && s == umagic(64,c).s-1 && x.Op != OpConst64 && udivisibleOK(64,c)
 21187		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) )
 21188		for {
 21189			_ = v.Args[1]
 21190			x := v.Args[0]
 21191			v_1 := v.Args[1]
 21192			if v_1.Op != OpMul64 {
 21193				break
 21194			}
 21195			_ = v_1.Args[1]
 21196			v_1_0 := v_1.Args[0]
 21197			if v_1_0.Op != OpRsh64Ux64 {
 21198				break
 21199			}
 21200			_ = v_1_0.Args[1]
 21201			v_1_0_0 := v_1_0.Args[0]
 21202			if v_1_0_0.Op != OpAvg64u {
 21203				break
 21204			}
 21205			_ = v_1_0_0.Args[1]
 21206			if x != v_1_0_0.Args[0] {
 21207				break
 21208			}
 21209			mul := v_1_0_0.Args[1]
 21210			if mul.Op != OpHmul64u {
 21211				break
 21212			}
 21213			_ = mul.Args[1]
 21214			if x != mul.Args[0] {
 21215				break
 21216			}
 21217			mul_1 := mul.Args[1]
 21218			if mul_1.Op != OpConst64 {
 21219				break
 21220			}
 21221			m := mul_1.AuxInt
 21222			v_1_0_1 := v_1_0.Args[1]
 21223			if v_1_0_1.Op != OpConst64 {
 21224				break
 21225			}
 21226			s := v_1_0_1.AuxInt
 21227			v_1_1 := v_1.Args[1]
 21228			if v_1_1.Op != OpConst64 {
 21229				break
 21230			}
 21231			c := v_1_1.AuxInt
 21232			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(64, c).m) && s == umagic(64, c).s-1 && x.Op != OpConst64 && udivisibleOK(64, c)) {
 21233				break
 21234			}
 21235			v.reset(OpLeq64U)
 21236			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 21237			v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 21238			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21239			v2.AuxInt = int64(udivisible(64, c).m)
 21240			v1.AddArg(v2)
 21241			v1.AddArg(x)
 21242			v0.AddArg(v1)
 21243			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21244			v3.AuxInt = int64(64 - udivisible(64, c).k)
 21245			v0.AddArg(v3)
 21246			v.AddArg(v0)
 21247			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21248			v4.AuxInt = int64(udivisible(64, c).max)
 21249			v.AddArg(v4)
 21250			return true
 21251		}
 21252		// match: (Eq64 (Mul64 (Const64 [c]) (Rsh64Ux64 (Avg64u x mul:(Hmul64u (Const64 [m]) x)) (Const64 [s]))) x)
 21253		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(64,c).m) && s == umagic(64,c).s-1 && x.Op != OpConst64 && udivisibleOK(64,c)
 21254		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) )
 21255		for {
 21256			x := v.Args[1]
 21257			v_0 := v.Args[0]
 21258			if v_0.Op != OpMul64 {
 21259				break
 21260			}
 21261			_ = v_0.Args[1]
 21262			v_0_0 := v_0.Args[0]
 21263			if v_0_0.Op != OpConst64 {
 21264				break
 21265			}
 21266			c := v_0_0.AuxInt
 21267			v_0_1 := v_0.Args[1]
 21268			if v_0_1.Op != OpRsh64Ux64 {
 21269				break
 21270			}
 21271			_ = v_0_1.Args[1]
 21272			v_0_1_0 := v_0_1.Args[0]
 21273			if v_0_1_0.Op != OpAvg64u {
 21274				break
 21275			}
 21276			_ = v_0_1_0.Args[1]
 21277			if x != v_0_1_0.Args[0] {
 21278				break
 21279			}
 21280			mul := v_0_1_0.Args[1]
 21281			if mul.Op != OpHmul64u {
 21282				break
 21283			}
 21284			_ = mul.Args[1]
 21285			mul_0 := mul.Args[0]
 21286			if mul_0.Op != OpConst64 {
 21287				break
 21288			}
 21289			m := mul_0.AuxInt
 21290			if x != mul.Args[1] {
 21291				break
 21292			}
 21293			v_0_1_1 := v_0_1.Args[1]
 21294			if v_0_1_1.Op != OpConst64 {
 21295				break
 21296			}
 21297			s := v_0_1_1.AuxInt
 21298			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(64, c).m) && s == umagic(64, c).s-1 && x.Op != OpConst64 && udivisibleOK(64, c)) {
 21299				break
 21300			}
 21301			v.reset(OpLeq64U)
 21302			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 21303			v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 21304			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21305			v2.AuxInt = int64(udivisible(64, c).m)
 21306			v1.AddArg(v2)
 21307			v1.AddArg(x)
 21308			v0.AddArg(v1)
 21309			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21310			v3.AuxInt = int64(64 - udivisible(64, c).k)
 21311			v0.AddArg(v3)
 21312			v.AddArg(v0)
 21313			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21314			v4.AuxInt = int64(udivisible(64, c).max)
 21315			v.AddArg(v4)
 21316			return true
 21317		}
 21318		// match: (Eq64 (Mul64 (Const64 [c]) (Rsh64Ux64 (Avg64u x mul:(Hmul64u x (Const64 [m]))) (Const64 [s]))) x)
 21319		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(64,c).m) && s == umagic(64,c).s-1 && x.Op != OpConst64 && udivisibleOK(64,c)
 21320		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) )
 21321		for {
 21322			x := v.Args[1]
 21323			v_0 := v.Args[0]
 21324			if v_0.Op != OpMul64 {
 21325				break
 21326			}
 21327			_ = v_0.Args[1]
 21328			v_0_0 := v_0.Args[0]
 21329			if v_0_0.Op != OpConst64 {
 21330				break
 21331			}
 21332			c := v_0_0.AuxInt
 21333			v_0_1 := v_0.Args[1]
 21334			if v_0_1.Op != OpRsh64Ux64 {
 21335				break
 21336			}
 21337			_ = v_0_1.Args[1]
 21338			v_0_1_0 := v_0_1.Args[0]
 21339			if v_0_1_0.Op != OpAvg64u {
 21340				break
 21341			}
 21342			_ = v_0_1_0.Args[1]
 21343			if x != v_0_1_0.Args[0] {
 21344				break
 21345			}
 21346			mul := v_0_1_0.Args[1]
 21347			if mul.Op != OpHmul64u {
 21348				break
 21349			}
 21350			_ = mul.Args[1]
 21351			if x != mul.Args[0] {
 21352				break
 21353			}
 21354			mul_1 := mul.Args[1]
 21355			if mul_1.Op != OpConst64 {
 21356				break
 21357			}
 21358			m := mul_1.AuxInt
 21359			v_0_1_1 := v_0_1.Args[1]
 21360			if v_0_1_1.Op != OpConst64 {
 21361				break
 21362			}
 21363			s := v_0_1_1.AuxInt
 21364			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(64, c).m) && s == umagic(64, c).s-1 && x.Op != OpConst64 && udivisibleOK(64, c)) {
 21365				break
 21366			}
 21367			v.reset(OpLeq64U)
 21368			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 21369			v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 21370			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21371			v2.AuxInt = int64(udivisible(64, c).m)
 21372			v1.AddArg(v2)
 21373			v1.AddArg(x)
 21374			v0.AddArg(v1)
 21375			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21376			v3.AuxInt = int64(64 - udivisible(64, c).k)
 21377			v0.AddArg(v3)
 21378			v.AddArg(v0)
 21379			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21380			v4.AuxInt = int64(udivisible(64, c).max)
 21381			v.AddArg(v4)
 21382			return true
 21383		}
 21384		// match: (Eq64 (Mul64 (Rsh64Ux64 (Avg64u x mul:(Hmul64u (Const64 [m]) x)) (Const64 [s])) (Const64 [c])) x)
 21385		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(64,c).m) && s == umagic(64,c).s-1 && x.Op != OpConst64 && udivisibleOK(64,c)
 21386		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) )
 21387		for {
 21388			x := v.Args[1]
 21389			v_0 := v.Args[0]
 21390			if v_0.Op != OpMul64 {
 21391				break
 21392			}
 21393			_ = v_0.Args[1]
 21394			v_0_0 := v_0.Args[0]
 21395			if v_0_0.Op != OpRsh64Ux64 {
 21396				break
 21397			}
 21398			_ = v_0_0.Args[1]
 21399			v_0_0_0 := v_0_0.Args[0]
 21400			if v_0_0_0.Op != OpAvg64u {
 21401				break
 21402			}
 21403			_ = v_0_0_0.Args[1]
 21404			if x != v_0_0_0.Args[0] {
 21405				break
 21406			}
 21407			mul := v_0_0_0.Args[1]
 21408			if mul.Op != OpHmul64u {
 21409				break
 21410			}
 21411			_ = mul.Args[1]
 21412			mul_0 := mul.Args[0]
 21413			if mul_0.Op != OpConst64 {
 21414				break
 21415			}
 21416			m := mul_0.AuxInt
 21417			if x != mul.Args[1] {
 21418				break
 21419			}
 21420			v_0_0_1 := v_0_0.Args[1]
 21421			if v_0_0_1.Op != OpConst64 {
 21422				break
 21423			}
 21424			s := v_0_0_1.AuxInt
 21425			v_0_1 := v_0.Args[1]
 21426			if v_0_1.Op != OpConst64 {
 21427				break
 21428			}
 21429			c := v_0_1.AuxInt
 21430			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(64, c).m) && s == umagic(64, c).s-1 && x.Op != OpConst64 && udivisibleOK(64, c)) {
 21431				break
 21432			}
 21433			v.reset(OpLeq64U)
 21434			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 21435			v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 21436			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21437			v2.AuxInt = int64(udivisible(64, c).m)
 21438			v1.AddArg(v2)
 21439			v1.AddArg(x)
 21440			v0.AddArg(v1)
 21441			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21442			v3.AuxInt = int64(64 - udivisible(64, c).k)
 21443			v0.AddArg(v3)
 21444			v.AddArg(v0)
 21445			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21446			v4.AuxInt = int64(udivisible(64, c).max)
 21447			v.AddArg(v4)
 21448			return true
 21449		}
 21450		return false
 21451	}
 21452	func rewriteValuegeneric_OpEq64_30(v *Value) bool {
 21453		b := v.Block
 21454		typ := &b.Func.Config.Types
 21455		// match: (Eq64 (Mul64 (Rsh64Ux64 (Avg64u x mul:(Hmul64u x (Const64 [m]))) (Const64 [s])) (Const64 [c])) x)
 21456		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(64,c).m) && s == umagic(64,c).s-1 && x.Op != OpConst64 && udivisibleOK(64,c)
 21457		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) )
 21458		for {
 21459			x := v.Args[1]
 21460			v_0 := v.Args[0]
 21461			if v_0.Op != OpMul64 {
 21462				break
 21463			}
 21464			_ = v_0.Args[1]
 21465			v_0_0 := v_0.Args[0]
 21466			if v_0_0.Op != OpRsh64Ux64 {
 21467				break
 21468			}
 21469			_ = v_0_0.Args[1]
 21470			v_0_0_0 := v_0_0.Args[0]
 21471			if v_0_0_0.Op != OpAvg64u {
 21472				break
 21473			}
 21474			_ = v_0_0_0.Args[1]
 21475			if x != v_0_0_0.Args[0] {
 21476				break
 21477			}
 21478			mul := v_0_0_0.Args[1]
 21479			if mul.Op != OpHmul64u {
 21480				break
 21481			}
 21482			_ = mul.Args[1]
 21483			if x != mul.Args[0] {
 21484				break
 21485			}
 21486			mul_1 := mul.Args[1]
 21487			if mul_1.Op != OpConst64 {
 21488				break
 21489			}
 21490			m := mul_1.AuxInt
 21491			v_0_0_1 := v_0_0.Args[1]
 21492			if v_0_0_1.Op != OpConst64 {
 21493				break
 21494			}
 21495			s := v_0_0_1.AuxInt
 21496			v_0_1 := v_0.Args[1]
 21497			if v_0_1.Op != OpConst64 {
 21498				break
 21499			}
 21500			c := v_0_1.AuxInt
 21501			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(64, c).m) && s == umagic(64, c).s-1 && x.Op != OpConst64 && udivisibleOK(64, c)) {
 21502				break
 21503			}
 21504			v.reset(OpLeq64U)
 21505			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 21506			v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 21507			v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21508			v2.AuxInt = int64(udivisible(64, c).m)
 21509			v1.AddArg(v2)
 21510			v1.AddArg(x)
 21511			v0.AddArg(v1)
 21512			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21513			v3.AuxInt = int64(64 - udivisible(64, c).k)
 21514			v0.AddArg(v3)
 21515			v.AddArg(v0)
 21516			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21517			v4.AuxInt = int64(udivisible(64, c).max)
 21518			v.AddArg(v4)
 21519			return true
 21520		}
 21521		// match: (Eq64 x (Mul64 (Const64 [c]) (Sub64 (Rsh64x64 mul:(Hmul64 (Const64 [m]) x) (Const64 [s])) (Rsh64x64 x (Const64 [63])))))
 21522		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64,c).m/2) && s == smagic(64,c).s-1 && x.Op != OpConst64 && sdivisibleOK(64,c)
 21523		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Add64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(sdivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(sdivisible(64,c).a)]) ) (Const64 <typ.UInt64> [int64(64-sdivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(sdivisible(64,c).max)]) )
 21524		for {
 21525			_ = v.Args[1]
 21526			x := v.Args[0]
 21527			v_1 := v.Args[1]
 21528			if v_1.Op != OpMul64 {
 21529				break
 21530			}
 21531			_ = v_1.Args[1]
 21532			v_1_0 := v_1.Args[0]
 21533			if v_1_0.Op != OpConst64 {
 21534				break
 21535			}
 21536			c := v_1_0.AuxInt
 21537			v_1_1 := v_1.Args[1]
 21538			if v_1_1.Op != OpSub64 {
 21539				break
 21540			}
 21541			_ = v_1_1.Args[1]
 21542			v_1_1_0 := v_1_1.Args[0]
 21543			if v_1_1_0.Op != OpRsh64x64 {
 21544				break
 21545			}
 21546			_ = v_1_1_0.Args[1]
 21547			mul := v_1_1_0.Args[0]
 21548			if mul.Op != OpHmul64 {
 21549				break
 21550			}
 21551			_ = mul.Args[1]
 21552			mul_0 := mul.Args[0]
 21553			if mul_0.Op != OpConst64 {
 21554				break
 21555			}
 21556			m := mul_0.AuxInt
 21557			if x != mul.Args[1] {
 21558				break
 21559			}
 21560			v_1_1_0_1 := v_1_1_0.Args[1]
 21561			if v_1_1_0_1.Op != OpConst64 {
 21562				break
 21563			}
 21564			s := v_1_1_0_1.AuxInt
 21565			v_1_1_1 := v_1_1.Args[1]
 21566			if v_1_1_1.Op != OpRsh64x64 {
 21567				break
 21568			}
 21569			_ = v_1_1_1.Args[1]
 21570			if x != v_1_1_1.Args[0] {
 21571				break
 21572			}
 21573			v_1_1_1_1 := v_1_1_1.Args[1]
 21574			if v_1_1_1_1.Op != OpConst64 {
 21575				break
 21576			}
 21577			if v_1_1_1_1.AuxInt != 63 {
 21578				break
 21579			}
 21580			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64, c).m/2) && s == smagic(64, c).s-1 && x.Op != OpConst64 && sdivisibleOK(64, c)) {
 21581				break
 21582			}
 21583			v.reset(OpLeq64U)
 21584			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 21585			v1 := b.NewValue0(v.Pos, OpAdd64, typ.UInt64)
 21586			v2 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 21587			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21588			v3.AuxInt = int64(sdivisible(64, c).m)
 21589			v2.AddArg(v3)
 21590			v2.AddArg(x)
 21591			v1.AddArg(v2)
 21592			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21593			v4.AuxInt = int64(sdivisible(64, c).a)
 21594			v1.AddArg(v4)
 21595			v0.AddArg(v1)
 21596			v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21597			v5.AuxInt = int64(64 - sdivisible(64, c).k)
 21598			v0.AddArg(v5)
 21599			v.AddArg(v0)
 21600			v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21601			v6.AuxInt = int64(sdivisible(64, c).max)
 21602			v.AddArg(v6)
 21603			return true
 21604		}
 21605		// match: (Eq64 x (Mul64 (Const64 [c]) (Sub64 (Rsh64x64 mul:(Hmul64 x (Const64 [m])) (Const64 [s])) (Rsh64x64 x (Const64 [63])))))
 21606		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64,c).m/2) && s == smagic(64,c).s-1 && x.Op != OpConst64 && sdivisibleOK(64,c)
 21607		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Add64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(sdivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(sdivisible(64,c).a)]) ) (Const64 <typ.UInt64> [int64(64-sdivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(sdivisible(64,c).max)]) )
 21608		for {
 21609			_ = v.Args[1]
 21610			x := v.Args[0]
 21611			v_1 := v.Args[1]
 21612			if v_1.Op != OpMul64 {
 21613				break
 21614			}
 21615			_ = v_1.Args[1]
 21616			v_1_0 := v_1.Args[0]
 21617			if v_1_0.Op != OpConst64 {
 21618				break
 21619			}
 21620			c := v_1_0.AuxInt
 21621			v_1_1 := v_1.Args[1]
 21622			if v_1_1.Op != OpSub64 {
 21623				break
 21624			}
 21625			_ = v_1_1.Args[1]
 21626			v_1_1_0 := v_1_1.Args[0]
 21627			if v_1_1_0.Op != OpRsh64x64 {
 21628				break
 21629			}
 21630			_ = v_1_1_0.Args[1]
 21631			mul := v_1_1_0.Args[0]
 21632			if mul.Op != OpHmul64 {
 21633				break
 21634			}
 21635			_ = mul.Args[1]
 21636			if x != mul.Args[0] {
 21637				break
 21638			}
 21639			mul_1 := mul.Args[1]
 21640			if mul_1.Op != OpConst64 {
 21641				break
 21642			}
 21643			m := mul_1.AuxInt
 21644			v_1_1_0_1 := v_1_1_0.Args[1]
 21645			if v_1_1_0_1.Op != OpConst64 {
 21646				break
 21647			}
 21648			s := v_1_1_0_1.AuxInt
 21649			v_1_1_1 := v_1_1.Args[1]
 21650			if v_1_1_1.Op != OpRsh64x64 {
 21651				break
 21652			}
 21653			_ = v_1_1_1.Args[1]
 21654			if x != v_1_1_1.Args[0] {
 21655				break
 21656			}
 21657			v_1_1_1_1 := v_1_1_1.Args[1]
 21658			if v_1_1_1_1.Op != OpConst64 {
 21659				break
 21660			}
 21661			if v_1_1_1_1.AuxInt != 63 {
 21662				break
 21663			}
 21664			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64, c).m/2) && s == smagic(64, c).s-1 && x.Op != OpConst64 && sdivisibleOK(64, c)) {
 21665				break
 21666			}
 21667			v.reset(OpLeq64U)
 21668			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 21669			v1 := b.NewValue0(v.Pos, OpAdd64, typ.UInt64)
 21670			v2 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 21671			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21672			v3.AuxInt = int64(sdivisible(64, c).m)
 21673			v2.AddArg(v3)
 21674			v2.AddArg(x)
 21675			v1.AddArg(v2)
 21676			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21677			v4.AuxInt = int64(sdivisible(64, c).a)
 21678			v1.AddArg(v4)
 21679			v0.AddArg(v1)
 21680			v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21681			v5.AuxInt = int64(64 - sdivisible(64, c).k)
 21682			v0.AddArg(v5)
 21683			v.AddArg(v0)
 21684			v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21685			v6.AuxInt = int64(sdivisible(64, c).max)
 21686			v.AddArg(v6)
 21687			return true
 21688		}
 21689		// match: (Eq64 x (Mul64 (Sub64 (Rsh64x64 mul:(Hmul64 (Const64 [m]) x) (Const64 [s])) (Rsh64x64 x (Const64 [63]))) (Const64 [c])))
 21690		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64,c).m/2) && s == smagic(64,c).s-1 && x.Op != OpConst64 && sdivisibleOK(64,c)
 21691		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Add64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(sdivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(sdivisible(64,c).a)]) ) (Const64 <typ.UInt64> [int64(64-sdivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(sdivisible(64,c).max)]) )
 21692		for {
 21693			_ = v.Args[1]
 21694			x := v.Args[0]
 21695			v_1 := v.Args[1]
 21696			if v_1.Op != OpMul64 {
 21697				break
 21698			}
 21699			_ = v_1.Args[1]
 21700			v_1_0 := v_1.Args[0]
 21701			if v_1_0.Op != OpSub64 {
 21702				break
 21703			}
 21704			_ = v_1_0.Args[1]
 21705			v_1_0_0 := v_1_0.Args[0]
 21706			if v_1_0_0.Op != OpRsh64x64 {
 21707				break
 21708			}
 21709			_ = v_1_0_0.Args[1]
 21710			mul := v_1_0_0.Args[0]
 21711			if mul.Op != OpHmul64 {
 21712				break
 21713			}
 21714			_ = mul.Args[1]
 21715			mul_0 := mul.Args[0]
 21716			if mul_0.Op != OpConst64 {
 21717				break
 21718			}
 21719			m := mul_0.AuxInt
 21720			if x != mul.Args[1] {
 21721				break
 21722			}
 21723			v_1_0_0_1 := v_1_0_0.Args[1]
 21724			if v_1_0_0_1.Op != OpConst64 {
 21725				break
 21726			}
 21727			s := v_1_0_0_1.AuxInt
 21728			v_1_0_1 := v_1_0.Args[1]
 21729			if v_1_0_1.Op != OpRsh64x64 {
 21730				break
 21731			}
 21732			_ = v_1_0_1.Args[1]
 21733			if x != v_1_0_1.Args[0] {
 21734				break
 21735			}
 21736			v_1_0_1_1 := v_1_0_1.Args[1]
 21737			if v_1_0_1_1.Op != OpConst64 {
 21738				break
 21739			}
 21740			if v_1_0_1_1.AuxInt != 63 {
 21741				break
 21742			}
 21743			v_1_1 := v_1.Args[1]
 21744			if v_1_1.Op != OpConst64 {
 21745				break
 21746			}
 21747			c := v_1_1.AuxInt
 21748			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64, c).m/2) && s == smagic(64, c).s-1 && x.Op != OpConst64 && sdivisibleOK(64, c)) {
 21749				break
 21750			}
 21751			v.reset(OpLeq64U)
 21752			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 21753			v1 := b.NewValue0(v.Pos, OpAdd64, typ.UInt64)
 21754			v2 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 21755			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21756			v3.AuxInt = int64(sdivisible(64, c).m)
 21757			v2.AddArg(v3)
 21758			v2.AddArg(x)
 21759			v1.AddArg(v2)
 21760			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21761			v4.AuxInt = int64(sdivisible(64, c).a)
 21762			v1.AddArg(v4)
 21763			v0.AddArg(v1)
 21764			v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21765			v5.AuxInt = int64(64 - sdivisible(64, c).k)
 21766			v0.AddArg(v5)
 21767			v.AddArg(v0)
 21768			v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21769			v6.AuxInt = int64(sdivisible(64, c).max)
 21770			v.AddArg(v6)
 21771			return true
 21772		}
 21773		// match: (Eq64 x (Mul64 (Sub64 (Rsh64x64 mul:(Hmul64 x (Const64 [m])) (Const64 [s])) (Rsh64x64 x (Const64 [63]))) (Const64 [c])))
 21774		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64,c).m/2) && s == smagic(64,c).s-1 && x.Op != OpConst64 && sdivisibleOK(64,c)
 21775		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Add64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(sdivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(sdivisible(64,c).a)]) ) (Const64 <typ.UInt64> [int64(64-sdivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(sdivisible(64,c).max)]) )
 21776		for {
 21777			_ = v.Args[1]
 21778			x := v.Args[0]
 21779			v_1 := v.Args[1]
 21780			if v_1.Op != OpMul64 {
 21781				break
 21782			}
 21783			_ = v_1.Args[1]
 21784			v_1_0 := v_1.Args[0]
 21785			if v_1_0.Op != OpSub64 {
 21786				break
 21787			}
 21788			_ = v_1_0.Args[1]
 21789			v_1_0_0 := v_1_0.Args[0]
 21790			if v_1_0_0.Op != OpRsh64x64 {
 21791				break
 21792			}
 21793			_ = v_1_0_0.Args[1]
 21794			mul := v_1_0_0.Args[0]
 21795			if mul.Op != OpHmul64 {
 21796				break
 21797			}
 21798			_ = mul.Args[1]
 21799			if x != mul.Args[0] {
 21800				break
 21801			}
 21802			mul_1 := mul.Args[1]
 21803			if mul_1.Op != OpConst64 {
 21804				break
 21805			}
 21806			m := mul_1.AuxInt
 21807			v_1_0_0_1 := v_1_0_0.Args[1]
 21808			if v_1_0_0_1.Op != OpConst64 {
 21809				break
 21810			}
 21811			s := v_1_0_0_1.AuxInt
 21812			v_1_0_1 := v_1_0.Args[1]
 21813			if v_1_0_1.Op != OpRsh64x64 {
 21814				break
 21815			}
 21816			_ = v_1_0_1.Args[1]
 21817			if x != v_1_0_1.Args[0] {
 21818				break
 21819			}
 21820			v_1_0_1_1 := v_1_0_1.Args[1]
 21821			if v_1_0_1_1.Op != OpConst64 {
 21822				break
 21823			}
 21824			if v_1_0_1_1.AuxInt != 63 {
 21825				break
 21826			}
 21827			v_1_1 := v_1.Args[1]
 21828			if v_1_1.Op != OpConst64 {
 21829				break
 21830			}
 21831			c := v_1_1.AuxInt
 21832			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64, c).m/2) && s == smagic(64, c).s-1 && x.Op != OpConst64 && sdivisibleOK(64, c)) {
 21833				break
 21834			}
 21835			v.reset(OpLeq64U)
 21836			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 21837			v1 := b.NewValue0(v.Pos, OpAdd64, typ.UInt64)
 21838			v2 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 21839			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21840			v3.AuxInt = int64(sdivisible(64, c).m)
 21841			v2.AddArg(v3)
 21842			v2.AddArg(x)
 21843			v1.AddArg(v2)
 21844			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21845			v4.AuxInt = int64(sdivisible(64, c).a)
 21846			v1.AddArg(v4)
 21847			v0.AddArg(v1)
 21848			v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21849			v5.AuxInt = int64(64 - sdivisible(64, c).k)
 21850			v0.AddArg(v5)
 21851			v.AddArg(v0)
 21852			v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21853			v6.AuxInt = int64(sdivisible(64, c).max)
 21854			v.AddArg(v6)
 21855			return true
 21856		}
 21857		// match: (Eq64 (Mul64 (Const64 [c]) (Sub64 (Rsh64x64 mul:(Hmul64 (Const64 [m]) x) (Const64 [s])) (Rsh64x64 x (Const64 [63])))) x)
 21858		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64,c).m/2) && s == smagic(64,c).s-1 && x.Op != OpConst64 && sdivisibleOK(64,c)
 21859		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Add64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(sdivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(sdivisible(64,c).a)]) ) (Const64 <typ.UInt64> [int64(64-sdivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(sdivisible(64,c).max)]) )
 21860		for {
 21861			x := v.Args[1]
 21862			v_0 := v.Args[0]
 21863			if v_0.Op != OpMul64 {
 21864				break
 21865			}
 21866			_ = v_0.Args[1]
 21867			v_0_0 := v_0.Args[0]
 21868			if v_0_0.Op != OpConst64 {
 21869				break
 21870			}
 21871			c := v_0_0.AuxInt
 21872			v_0_1 := v_0.Args[1]
 21873			if v_0_1.Op != OpSub64 {
 21874				break
 21875			}
 21876			_ = v_0_1.Args[1]
 21877			v_0_1_0 := v_0_1.Args[0]
 21878			if v_0_1_0.Op != OpRsh64x64 {
 21879				break
 21880			}
 21881			_ = v_0_1_0.Args[1]
 21882			mul := v_0_1_0.Args[0]
 21883			if mul.Op != OpHmul64 {
 21884				break
 21885			}
 21886			_ = mul.Args[1]
 21887			mul_0 := mul.Args[0]
 21888			if mul_0.Op != OpConst64 {
 21889				break
 21890			}
 21891			m := mul_0.AuxInt
 21892			if x != mul.Args[1] {
 21893				break
 21894			}
 21895			v_0_1_0_1 := v_0_1_0.Args[1]
 21896			if v_0_1_0_1.Op != OpConst64 {
 21897				break
 21898			}
 21899			s := v_0_1_0_1.AuxInt
 21900			v_0_1_1 := v_0_1.Args[1]
 21901			if v_0_1_1.Op != OpRsh64x64 {
 21902				break
 21903			}
 21904			_ = v_0_1_1.Args[1]
 21905			if x != v_0_1_1.Args[0] {
 21906				break
 21907			}
 21908			v_0_1_1_1 := v_0_1_1.Args[1]
 21909			if v_0_1_1_1.Op != OpConst64 {
 21910				break
 21911			}
 21912			if v_0_1_1_1.AuxInt != 63 {
 21913				break
 21914			}
 21915			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64, c).m/2) && s == smagic(64, c).s-1 && x.Op != OpConst64 && sdivisibleOK(64, c)) {
 21916				break
 21917			}
 21918			v.reset(OpLeq64U)
 21919			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 21920			v1 := b.NewValue0(v.Pos, OpAdd64, typ.UInt64)
 21921			v2 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 21922			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21923			v3.AuxInt = int64(sdivisible(64, c).m)
 21924			v2.AddArg(v3)
 21925			v2.AddArg(x)
 21926			v1.AddArg(v2)
 21927			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21928			v4.AuxInt = int64(sdivisible(64, c).a)
 21929			v1.AddArg(v4)
 21930			v0.AddArg(v1)
 21931			v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21932			v5.AuxInt = int64(64 - sdivisible(64, c).k)
 21933			v0.AddArg(v5)
 21934			v.AddArg(v0)
 21935			v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 21936			v6.AuxInt = int64(sdivisible(64, c).max)
 21937			v.AddArg(v6)
 21938			return true
 21939		}
 21940		// match: (Eq64 (Mul64 (Const64 [c]) (Sub64 (Rsh64x64 mul:(Hmul64 x (Const64 [m])) (Const64 [s])) (Rsh64x64 x (Const64 [63])))) x)
 21941		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64,c).m/2) && s == smagic(64,c).s-1 && x.Op != OpConst64 && sdivisibleOK(64,c)
 21942		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Add64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(sdivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(sdivisible(64,c).a)]) ) (Const64 <typ.UInt64> [int64(64-sdivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(sdivisible(64,c).max)]) )
 21943		for {
 21944			x := v.Args[1]
 21945			v_0 := v.Args[0]
 21946			if v_0.Op != OpMul64 {
 21947				break
 21948			}
 21949			_ = v_0.Args[1]
 21950			v_0_0 := v_0.Args[0]
 21951			if v_0_0.Op != OpConst64 {
 21952				break
 21953			}
 21954			c := v_0_0.AuxInt
 21955			v_0_1 := v_0.Args[1]
 21956			if v_0_1.Op != OpSub64 {
 21957				break
 21958			}
 21959			_ = v_0_1.Args[1]
 21960			v_0_1_0 := v_0_1.Args[0]
 21961			if v_0_1_0.Op != OpRsh64x64 {
 21962				break
 21963			}
 21964			_ = v_0_1_0.Args[1]
 21965			mul := v_0_1_0.Args[0]
 21966			if mul.Op != OpHmul64 {
 21967				break
 21968			}
 21969			_ = mul.Args[1]
 21970			if x != mul.Args[0] {
 21971				break
 21972			}
 21973			mul_1 := mul.Args[1]
 21974			if mul_1.Op != OpConst64 {
 21975				break
 21976			}
 21977			m := mul_1.AuxInt
 21978			v_0_1_0_1 := v_0_1_0.Args[1]
 21979			if v_0_1_0_1.Op != OpConst64 {
 21980				break
 21981			}
 21982			s := v_0_1_0_1.AuxInt
 21983			v_0_1_1 := v_0_1.Args[1]
 21984			if v_0_1_1.Op != OpRsh64x64 {
 21985				break
 21986			}
 21987			_ = v_0_1_1.Args[1]
 21988			if x != v_0_1_1.Args[0] {
 21989				break
 21990			}
 21991			v_0_1_1_1 := v_0_1_1.Args[1]
 21992			if v_0_1_1_1.Op != OpConst64 {
 21993				break
 21994			}
 21995			if v_0_1_1_1.AuxInt != 63 {
 21996				break
 21997			}
 21998			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64, c).m/2) && s == smagic(64, c).s-1 && x.Op != OpConst64 && sdivisibleOK(64, c)) {
 21999				break
 22000			}
 22001			v.reset(OpLeq64U)
 22002			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 22003			v1 := b.NewValue0(v.Pos, OpAdd64, typ.UInt64)
 22004			v2 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 22005			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22006			v3.AuxInt = int64(sdivisible(64, c).m)
 22007			v2.AddArg(v3)
 22008			v2.AddArg(x)
 22009			v1.AddArg(v2)
 22010			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22011			v4.AuxInt = int64(sdivisible(64, c).a)
 22012			v1.AddArg(v4)
 22013			v0.AddArg(v1)
 22014			v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22015			v5.AuxInt = int64(64 - sdivisible(64, c).k)
 22016			v0.AddArg(v5)
 22017			v.AddArg(v0)
 22018			v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22019			v6.AuxInt = int64(sdivisible(64, c).max)
 22020			v.AddArg(v6)
 22021			return true
 22022		}
 22023		// match: (Eq64 (Mul64 (Sub64 (Rsh64x64 mul:(Hmul64 (Const64 [m]) x) (Const64 [s])) (Rsh64x64 x (Const64 [63]))) (Const64 [c])) x)
 22024		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64,c).m/2) && s == smagic(64,c).s-1 && x.Op != OpConst64 && sdivisibleOK(64,c)
 22025		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Add64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(sdivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(sdivisible(64,c).a)]) ) (Const64 <typ.UInt64> [int64(64-sdivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(sdivisible(64,c).max)]) )
 22026		for {
 22027			x := v.Args[1]
 22028			v_0 := v.Args[0]
 22029			if v_0.Op != OpMul64 {
 22030				break
 22031			}
 22032			_ = v_0.Args[1]
 22033			v_0_0 := v_0.Args[0]
 22034			if v_0_0.Op != OpSub64 {
 22035				break
 22036			}
 22037			_ = v_0_0.Args[1]
 22038			v_0_0_0 := v_0_0.Args[0]
 22039			if v_0_0_0.Op != OpRsh64x64 {
 22040				break
 22041			}
 22042			_ = v_0_0_0.Args[1]
 22043			mul := v_0_0_0.Args[0]
 22044			if mul.Op != OpHmul64 {
 22045				break
 22046			}
 22047			_ = mul.Args[1]
 22048			mul_0 := mul.Args[0]
 22049			if mul_0.Op != OpConst64 {
 22050				break
 22051			}
 22052			m := mul_0.AuxInt
 22053			if x != mul.Args[1] {
 22054				break
 22055			}
 22056			v_0_0_0_1 := v_0_0_0.Args[1]
 22057			if v_0_0_0_1.Op != OpConst64 {
 22058				break
 22059			}
 22060			s := v_0_0_0_1.AuxInt
 22061			v_0_0_1 := v_0_0.Args[1]
 22062			if v_0_0_1.Op != OpRsh64x64 {
 22063				break
 22064			}
 22065			_ = v_0_0_1.Args[1]
 22066			if x != v_0_0_1.Args[0] {
 22067				break
 22068			}
 22069			v_0_0_1_1 := v_0_0_1.Args[1]
 22070			if v_0_0_1_1.Op != OpConst64 {
 22071				break
 22072			}
 22073			if v_0_0_1_1.AuxInt != 63 {
 22074				break
 22075			}
 22076			v_0_1 := v_0.Args[1]
 22077			if v_0_1.Op != OpConst64 {
 22078				break
 22079			}
 22080			c := v_0_1.AuxInt
 22081			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64, c).m/2) && s == smagic(64, c).s-1 && x.Op != OpConst64 && sdivisibleOK(64, c)) {
 22082				break
 22083			}
 22084			v.reset(OpLeq64U)
 22085			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 22086			v1 := b.NewValue0(v.Pos, OpAdd64, typ.UInt64)
 22087			v2 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 22088			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22089			v3.AuxInt = int64(sdivisible(64, c).m)
 22090			v2.AddArg(v3)
 22091			v2.AddArg(x)
 22092			v1.AddArg(v2)
 22093			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22094			v4.AuxInt = int64(sdivisible(64, c).a)
 22095			v1.AddArg(v4)
 22096			v0.AddArg(v1)
 22097			v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22098			v5.AuxInt = int64(64 - sdivisible(64, c).k)
 22099			v0.AddArg(v5)
 22100			v.AddArg(v0)
 22101			v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22102			v6.AuxInt = int64(sdivisible(64, c).max)
 22103			v.AddArg(v6)
 22104			return true
 22105		}
 22106		// match: (Eq64 (Mul64 (Sub64 (Rsh64x64 mul:(Hmul64 x (Const64 [m])) (Const64 [s])) (Rsh64x64 x (Const64 [63]))) (Const64 [c])) x)
 22107		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64,c).m/2) && s == smagic(64,c).s-1 && x.Op != OpConst64 && sdivisibleOK(64,c)
 22108		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Add64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(sdivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(sdivisible(64,c).a)]) ) (Const64 <typ.UInt64> [int64(64-sdivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(sdivisible(64,c).max)]) )
 22109		for {
 22110			x := v.Args[1]
 22111			v_0 := v.Args[0]
 22112			if v_0.Op != OpMul64 {
 22113				break
 22114			}
 22115			_ = v_0.Args[1]
 22116			v_0_0 := v_0.Args[0]
 22117			if v_0_0.Op != OpSub64 {
 22118				break
 22119			}
 22120			_ = v_0_0.Args[1]
 22121			v_0_0_0 := v_0_0.Args[0]
 22122			if v_0_0_0.Op != OpRsh64x64 {
 22123				break
 22124			}
 22125			_ = v_0_0_0.Args[1]
 22126			mul := v_0_0_0.Args[0]
 22127			if mul.Op != OpHmul64 {
 22128				break
 22129			}
 22130			_ = mul.Args[1]
 22131			if x != mul.Args[0] {
 22132				break
 22133			}
 22134			mul_1 := mul.Args[1]
 22135			if mul_1.Op != OpConst64 {
 22136				break
 22137			}
 22138			m := mul_1.AuxInt
 22139			v_0_0_0_1 := v_0_0_0.Args[1]
 22140			if v_0_0_0_1.Op != OpConst64 {
 22141				break
 22142			}
 22143			s := v_0_0_0_1.AuxInt
 22144			v_0_0_1 := v_0_0.Args[1]
 22145			if v_0_0_1.Op != OpRsh64x64 {
 22146				break
 22147			}
 22148			_ = v_0_0_1.Args[1]
 22149			if x != v_0_0_1.Args[0] {
 22150				break
 22151			}
 22152			v_0_0_1_1 := v_0_0_1.Args[1]
 22153			if v_0_0_1_1.Op != OpConst64 {
 22154				break
 22155			}
 22156			if v_0_0_1_1.AuxInt != 63 {
 22157				break
 22158			}
 22159			v_0_1 := v_0.Args[1]
 22160			if v_0_1.Op != OpConst64 {
 22161				break
 22162			}
 22163			c := v_0_1.AuxInt
 22164			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64, c).m/2) && s == smagic(64, c).s-1 && x.Op != OpConst64 && sdivisibleOK(64, c)) {
 22165				break
 22166			}
 22167			v.reset(OpLeq64U)
 22168			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 22169			v1 := b.NewValue0(v.Pos, OpAdd64, typ.UInt64)
 22170			v2 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 22171			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22172			v3.AuxInt = int64(sdivisible(64, c).m)
 22173			v2.AddArg(v3)
 22174			v2.AddArg(x)
 22175			v1.AddArg(v2)
 22176			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22177			v4.AuxInt = int64(sdivisible(64, c).a)
 22178			v1.AddArg(v4)
 22179			v0.AddArg(v1)
 22180			v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22181			v5.AuxInt = int64(64 - sdivisible(64, c).k)
 22182			v0.AddArg(v5)
 22183			v.AddArg(v0)
 22184			v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22185			v6.AuxInt = int64(sdivisible(64, c).max)
 22186			v.AddArg(v6)
 22187			return true
 22188		}
 22189		// match: (Eq64 x (Mul64 (Const64 [c]) (Sub64 (Rsh64x64 (Add64 mul:(Hmul64 (Const64 [m]) x) x) (Const64 [s])) (Rsh64x64 x (Const64 [63])))))
 22190		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64,c).m) && s == smagic(64,c).s && x.Op != OpConst64 && sdivisibleOK(64,c)
 22191		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Add64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(sdivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(sdivisible(64,c).a)]) ) (Const64 <typ.UInt64> [int64(64-sdivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(sdivisible(64,c).max)]) )
 22192		for {
 22193			_ = v.Args[1]
 22194			x := v.Args[0]
 22195			v_1 := v.Args[1]
 22196			if v_1.Op != OpMul64 {
 22197				break
 22198			}
 22199			_ = v_1.Args[1]
 22200			v_1_0 := v_1.Args[0]
 22201			if v_1_0.Op != OpConst64 {
 22202				break
 22203			}
 22204			c := v_1_0.AuxInt
 22205			v_1_1 := v_1.Args[1]
 22206			if v_1_1.Op != OpSub64 {
 22207				break
 22208			}
 22209			_ = v_1_1.Args[1]
 22210			v_1_1_0 := v_1_1.Args[0]
 22211			if v_1_1_0.Op != OpRsh64x64 {
 22212				break
 22213			}
 22214			_ = v_1_1_0.Args[1]
 22215			v_1_1_0_0 := v_1_1_0.Args[0]
 22216			if v_1_1_0_0.Op != OpAdd64 {
 22217				break
 22218			}
 22219			_ = v_1_1_0_0.Args[1]
 22220			mul := v_1_1_0_0.Args[0]
 22221			if mul.Op != OpHmul64 {
 22222				break
 22223			}
 22224			_ = mul.Args[1]
 22225			mul_0 := mul.Args[0]
 22226			if mul_0.Op != OpConst64 {
 22227				break
 22228			}
 22229			m := mul_0.AuxInt
 22230			if x != mul.Args[1] {
 22231				break
 22232			}
 22233			if x != v_1_1_0_0.Args[1] {
 22234				break
 22235			}
 22236			v_1_1_0_1 := v_1_1_0.Args[1]
 22237			if v_1_1_0_1.Op != OpConst64 {
 22238				break
 22239			}
 22240			s := v_1_1_0_1.AuxInt
 22241			v_1_1_1 := v_1_1.Args[1]
 22242			if v_1_1_1.Op != OpRsh64x64 {
 22243				break
 22244			}
 22245			_ = v_1_1_1.Args[1]
 22246			if x != v_1_1_1.Args[0] {
 22247				break
 22248			}
 22249			v_1_1_1_1 := v_1_1_1.Args[1]
 22250			if v_1_1_1_1.Op != OpConst64 {
 22251				break
 22252			}
 22253			if v_1_1_1_1.AuxInt != 63 {
 22254				break
 22255			}
 22256			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64, c).m) && s == smagic(64, c).s && x.Op != OpConst64 && sdivisibleOK(64, c)) {
 22257				break
 22258			}
 22259			v.reset(OpLeq64U)
 22260			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 22261			v1 := b.NewValue0(v.Pos, OpAdd64, typ.UInt64)
 22262			v2 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 22263			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22264			v3.AuxInt = int64(sdivisible(64, c).m)
 22265			v2.AddArg(v3)
 22266			v2.AddArg(x)
 22267			v1.AddArg(v2)
 22268			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22269			v4.AuxInt = int64(sdivisible(64, c).a)
 22270			v1.AddArg(v4)
 22271			v0.AddArg(v1)
 22272			v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22273			v5.AuxInt = int64(64 - sdivisible(64, c).k)
 22274			v0.AddArg(v5)
 22275			v.AddArg(v0)
 22276			v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22277			v6.AuxInt = int64(sdivisible(64, c).max)
 22278			v.AddArg(v6)
 22279			return true
 22280		}
 22281		return false
 22282	}
 22283	func rewriteValuegeneric_OpEq64_40(v *Value) bool {
 22284		b := v.Block
 22285		typ := &b.Func.Config.Types
 22286		// match: (Eq64 x (Mul64 (Const64 [c]) (Sub64 (Rsh64x64 (Add64 mul:(Hmul64 x (Const64 [m])) x) (Const64 [s])) (Rsh64x64 x (Const64 [63])))))
 22287		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64,c).m) && s == smagic(64,c).s && x.Op != OpConst64 && sdivisibleOK(64,c)
 22288		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Add64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(sdivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(sdivisible(64,c).a)]) ) (Const64 <typ.UInt64> [int64(64-sdivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(sdivisible(64,c).max)]) )
 22289		for {
 22290			_ = v.Args[1]
 22291			x := v.Args[0]
 22292			v_1 := v.Args[1]
 22293			if v_1.Op != OpMul64 {
 22294				break
 22295			}
 22296			_ = v_1.Args[1]
 22297			v_1_0 := v_1.Args[0]
 22298			if v_1_0.Op != OpConst64 {
 22299				break
 22300			}
 22301			c := v_1_0.AuxInt
 22302			v_1_1 := v_1.Args[1]
 22303			if v_1_1.Op != OpSub64 {
 22304				break
 22305			}
 22306			_ = v_1_1.Args[1]
 22307			v_1_1_0 := v_1_1.Args[0]
 22308			if v_1_1_0.Op != OpRsh64x64 {
 22309				break
 22310			}
 22311			_ = v_1_1_0.Args[1]
 22312			v_1_1_0_0 := v_1_1_0.Args[0]
 22313			if v_1_1_0_0.Op != OpAdd64 {
 22314				break
 22315			}
 22316			_ = v_1_1_0_0.Args[1]
 22317			mul := v_1_1_0_0.Args[0]
 22318			if mul.Op != OpHmul64 {
 22319				break
 22320			}
 22321			_ = mul.Args[1]
 22322			if x != mul.Args[0] {
 22323				break
 22324			}
 22325			mul_1 := mul.Args[1]
 22326			if mul_1.Op != OpConst64 {
 22327				break
 22328			}
 22329			m := mul_1.AuxInt
 22330			if x != v_1_1_0_0.Args[1] {
 22331				break
 22332			}
 22333			v_1_1_0_1 := v_1_1_0.Args[1]
 22334			if v_1_1_0_1.Op != OpConst64 {
 22335				break
 22336			}
 22337			s := v_1_1_0_1.AuxInt
 22338			v_1_1_1 := v_1_1.Args[1]
 22339			if v_1_1_1.Op != OpRsh64x64 {
 22340				break
 22341			}
 22342			_ = v_1_1_1.Args[1]
 22343			if x != v_1_1_1.Args[0] {
 22344				break
 22345			}
 22346			v_1_1_1_1 := v_1_1_1.Args[1]
 22347			if v_1_1_1_1.Op != OpConst64 {
 22348				break
 22349			}
 22350			if v_1_1_1_1.AuxInt != 63 {
 22351				break
 22352			}
 22353			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64, c).m) && s == smagic(64, c).s && x.Op != OpConst64 && sdivisibleOK(64, c)) {
 22354				break
 22355			}
 22356			v.reset(OpLeq64U)
 22357			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 22358			v1 := b.NewValue0(v.Pos, OpAdd64, typ.UInt64)
 22359			v2 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 22360			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22361			v3.AuxInt = int64(sdivisible(64, c).m)
 22362			v2.AddArg(v3)
 22363			v2.AddArg(x)
 22364			v1.AddArg(v2)
 22365			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22366			v4.AuxInt = int64(sdivisible(64, c).a)
 22367			v1.AddArg(v4)
 22368			v0.AddArg(v1)
 22369			v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22370			v5.AuxInt = int64(64 - sdivisible(64, c).k)
 22371			v0.AddArg(v5)
 22372			v.AddArg(v0)
 22373			v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22374			v6.AuxInt = int64(sdivisible(64, c).max)
 22375			v.AddArg(v6)
 22376			return true
 22377		}
 22378		// match: (Eq64 x (Mul64 (Const64 [c]) (Sub64 (Rsh64x64 (Add64 x mul:(Hmul64 (Const64 [m]) x)) (Const64 [s])) (Rsh64x64 x (Const64 [63])))))
 22379		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64,c).m) && s == smagic(64,c).s && x.Op != OpConst64 && sdivisibleOK(64,c)
 22380		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Add64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(sdivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(sdivisible(64,c).a)]) ) (Const64 <typ.UInt64> [int64(64-sdivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(sdivisible(64,c).max)]) )
 22381		for {
 22382			_ = v.Args[1]
 22383			x := v.Args[0]
 22384			v_1 := v.Args[1]
 22385			if v_1.Op != OpMul64 {
 22386				break
 22387			}
 22388			_ = v_1.Args[1]
 22389			v_1_0 := v_1.Args[0]
 22390			if v_1_0.Op != OpConst64 {
 22391				break
 22392			}
 22393			c := v_1_0.AuxInt
 22394			v_1_1 := v_1.Args[1]
 22395			if v_1_1.Op != OpSub64 {
 22396				break
 22397			}
 22398			_ = v_1_1.Args[1]
 22399			v_1_1_0 := v_1_1.Args[0]
 22400			if v_1_1_0.Op != OpRsh64x64 {
 22401				break
 22402			}
 22403			_ = v_1_1_0.Args[1]
 22404			v_1_1_0_0 := v_1_1_0.Args[0]
 22405			if v_1_1_0_0.Op != OpAdd64 {
 22406				break
 22407			}
 22408			_ = v_1_1_0_0.Args[1]
 22409			if x != v_1_1_0_0.Args[0] {
 22410				break
 22411			}
 22412			mul := v_1_1_0_0.Args[1]
 22413			if mul.Op != OpHmul64 {
 22414				break
 22415			}
 22416			_ = mul.Args[1]
 22417			mul_0 := mul.Args[0]
 22418			if mul_0.Op != OpConst64 {
 22419				break
 22420			}
 22421			m := mul_0.AuxInt
 22422			if x != mul.Args[1] {
 22423				break
 22424			}
 22425			v_1_1_0_1 := v_1_1_0.Args[1]
 22426			if v_1_1_0_1.Op != OpConst64 {
 22427				break
 22428			}
 22429			s := v_1_1_0_1.AuxInt
 22430			v_1_1_1 := v_1_1.Args[1]
 22431			if v_1_1_1.Op != OpRsh64x64 {
 22432				break
 22433			}
 22434			_ = v_1_1_1.Args[1]
 22435			if x != v_1_1_1.Args[0] {
 22436				break
 22437			}
 22438			v_1_1_1_1 := v_1_1_1.Args[1]
 22439			if v_1_1_1_1.Op != OpConst64 {
 22440				break
 22441			}
 22442			if v_1_1_1_1.AuxInt != 63 {
 22443				break
 22444			}
 22445			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64, c).m) && s == smagic(64, c).s && x.Op != OpConst64 && sdivisibleOK(64, c)) {
 22446				break
 22447			}
 22448			v.reset(OpLeq64U)
 22449			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 22450			v1 := b.NewValue0(v.Pos, OpAdd64, typ.UInt64)
 22451			v2 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 22452			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22453			v3.AuxInt = int64(sdivisible(64, c).m)
 22454			v2.AddArg(v3)
 22455			v2.AddArg(x)
 22456			v1.AddArg(v2)
 22457			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22458			v4.AuxInt = int64(sdivisible(64, c).a)
 22459			v1.AddArg(v4)
 22460			v0.AddArg(v1)
 22461			v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22462			v5.AuxInt = int64(64 - sdivisible(64, c).k)
 22463			v0.AddArg(v5)
 22464			v.AddArg(v0)
 22465			v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22466			v6.AuxInt = int64(sdivisible(64, c).max)
 22467			v.AddArg(v6)
 22468			return true
 22469		}
 22470		// match: (Eq64 x (Mul64 (Const64 [c]) (Sub64 (Rsh64x64 (Add64 x mul:(Hmul64 x (Const64 [m]))) (Const64 [s])) (Rsh64x64 x (Const64 [63])))))
 22471		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64,c).m) && s == smagic(64,c).s && x.Op != OpConst64 && sdivisibleOK(64,c)
 22472		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Add64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(sdivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(sdivisible(64,c).a)]) ) (Const64 <typ.UInt64> [int64(64-sdivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(sdivisible(64,c).max)]) )
 22473		for {
 22474			_ = v.Args[1]
 22475			x := v.Args[0]
 22476			v_1 := v.Args[1]
 22477			if v_1.Op != OpMul64 {
 22478				break
 22479			}
 22480			_ = v_1.Args[1]
 22481			v_1_0 := v_1.Args[0]
 22482			if v_1_0.Op != OpConst64 {
 22483				break
 22484			}
 22485			c := v_1_0.AuxInt
 22486			v_1_1 := v_1.Args[1]
 22487			if v_1_1.Op != OpSub64 {
 22488				break
 22489			}
 22490			_ = v_1_1.Args[1]
 22491			v_1_1_0 := v_1_1.Args[0]
 22492			if v_1_1_0.Op != OpRsh64x64 {
 22493				break
 22494			}
 22495			_ = v_1_1_0.Args[1]
 22496			v_1_1_0_0 := v_1_1_0.Args[0]
 22497			if v_1_1_0_0.Op != OpAdd64 {
 22498				break
 22499			}
 22500			_ = v_1_1_0_0.Args[1]
 22501			if x != v_1_1_0_0.Args[0] {
 22502				break
 22503			}
 22504			mul := v_1_1_0_0.Args[1]
 22505			if mul.Op != OpHmul64 {
 22506				break
 22507			}
 22508			_ = mul.Args[1]
 22509			if x != mul.Args[0] {
 22510				break
 22511			}
 22512			mul_1 := mul.Args[1]
 22513			if mul_1.Op != OpConst64 {
 22514				break
 22515			}
 22516			m := mul_1.AuxInt
 22517			v_1_1_0_1 := v_1_1_0.Args[1]
 22518			if v_1_1_0_1.Op != OpConst64 {
 22519				break
 22520			}
 22521			s := v_1_1_0_1.AuxInt
 22522			v_1_1_1 := v_1_1.Args[1]
 22523			if v_1_1_1.Op != OpRsh64x64 {
 22524				break
 22525			}
 22526			_ = v_1_1_1.Args[1]
 22527			if x != v_1_1_1.Args[0] {
 22528				break
 22529			}
 22530			v_1_1_1_1 := v_1_1_1.Args[1]
 22531			if v_1_1_1_1.Op != OpConst64 {
 22532				break
 22533			}
 22534			if v_1_1_1_1.AuxInt != 63 {
 22535				break
 22536			}
 22537			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64, c).m) && s == smagic(64, c).s && x.Op != OpConst64 && sdivisibleOK(64, c)) {
 22538				break
 22539			}
 22540			v.reset(OpLeq64U)
 22541			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 22542			v1 := b.NewValue0(v.Pos, OpAdd64, typ.UInt64)
 22543			v2 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 22544			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22545			v3.AuxInt = int64(sdivisible(64, c).m)
 22546			v2.AddArg(v3)
 22547			v2.AddArg(x)
 22548			v1.AddArg(v2)
 22549			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22550			v4.AuxInt = int64(sdivisible(64, c).a)
 22551			v1.AddArg(v4)
 22552			v0.AddArg(v1)
 22553			v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22554			v5.AuxInt = int64(64 - sdivisible(64, c).k)
 22555			v0.AddArg(v5)
 22556			v.AddArg(v0)
 22557			v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22558			v6.AuxInt = int64(sdivisible(64, c).max)
 22559			v.AddArg(v6)
 22560			return true
 22561		}
 22562		// match: (Eq64 x (Mul64 (Sub64 (Rsh64x64 (Add64 mul:(Hmul64 (Const64 [m]) x) x) (Const64 [s])) (Rsh64x64 x (Const64 [63]))) (Const64 [c])))
 22563		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64,c).m) && s == smagic(64,c).s && x.Op != OpConst64 && sdivisibleOK(64,c)
 22564		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Add64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(sdivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(sdivisible(64,c).a)]) ) (Const64 <typ.UInt64> [int64(64-sdivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(sdivisible(64,c).max)]) )
 22565		for {
 22566			_ = v.Args[1]
 22567			x := v.Args[0]
 22568			v_1 := v.Args[1]
 22569			if v_1.Op != OpMul64 {
 22570				break
 22571			}
 22572			_ = v_1.Args[1]
 22573			v_1_0 := v_1.Args[0]
 22574			if v_1_0.Op != OpSub64 {
 22575				break
 22576			}
 22577			_ = v_1_0.Args[1]
 22578			v_1_0_0 := v_1_0.Args[0]
 22579			if v_1_0_0.Op != OpRsh64x64 {
 22580				break
 22581			}
 22582			_ = v_1_0_0.Args[1]
 22583			v_1_0_0_0 := v_1_0_0.Args[0]
 22584			if v_1_0_0_0.Op != OpAdd64 {
 22585				break
 22586			}
 22587			_ = v_1_0_0_0.Args[1]
 22588			mul := v_1_0_0_0.Args[0]
 22589			if mul.Op != OpHmul64 {
 22590				break
 22591			}
 22592			_ = mul.Args[1]
 22593			mul_0 := mul.Args[0]
 22594			if mul_0.Op != OpConst64 {
 22595				break
 22596			}
 22597			m := mul_0.AuxInt
 22598			if x != mul.Args[1] {
 22599				break
 22600			}
 22601			if x != v_1_0_0_0.Args[1] {
 22602				break
 22603			}
 22604			v_1_0_0_1 := v_1_0_0.Args[1]
 22605			if v_1_0_0_1.Op != OpConst64 {
 22606				break
 22607			}
 22608			s := v_1_0_0_1.AuxInt
 22609			v_1_0_1 := v_1_0.Args[1]
 22610			if v_1_0_1.Op != OpRsh64x64 {
 22611				break
 22612			}
 22613			_ = v_1_0_1.Args[1]
 22614			if x != v_1_0_1.Args[0] {
 22615				break
 22616			}
 22617			v_1_0_1_1 := v_1_0_1.Args[1]
 22618			if v_1_0_1_1.Op != OpConst64 {
 22619				break
 22620			}
 22621			if v_1_0_1_1.AuxInt != 63 {
 22622				break
 22623			}
 22624			v_1_1 := v_1.Args[1]
 22625			if v_1_1.Op != OpConst64 {
 22626				break
 22627			}
 22628			c := v_1_1.AuxInt
 22629			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64, c).m) && s == smagic(64, c).s && x.Op != OpConst64 && sdivisibleOK(64, c)) {
 22630				break
 22631			}
 22632			v.reset(OpLeq64U)
 22633			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 22634			v1 := b.NewValue0(v.Pos, OpAdd64, typ.UInt64)
 22635			v2 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 22636			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22637			v3.AuxInt = int64(sdivisible(64, c).m)
 22638			v2.AddArg(v3)
 22639			v2.AddArg(x)
 22640			v1.AddArg(v2)
 22641			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22642			v4.AuxInt = int64(sdivisible(64, c).a)
 22643			v1.AddArg(v4)
 22644			v0.AddArg(v1)
 22645			v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22646			v5.AuxInt = int64(64 - sdivisible(64, c).k)
 22647			v0.AddArg(v5)
 22648			v.AddArg(v0)
 22649			v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22650			v6.AuxInt = int64(sdivisible(64, c).max)
 22651			v.AddArg(v6)
 22652			return true
 22653		}
 22654		// match: (Eq64 x (Mul64 (Sub64 (Rsh64x64 (Add64 mul:(Hmul64 x (Const64 [m])) x) (Const64 [s])) (Rsh64x64 x (Const64 [63]))) (Const64 [c])))
 22655		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64,c).m) && s == smagic(64,c).s && x.Op != OpConst64 && sdivisibleOK(64,c)
 22656		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Add64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(sdivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(sdivisible(64,c).a)]) ) (Const64 <typ.UInt64> [int64(64-sdivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(sdivisible(64,c).max)]) )
 22657		for {
 22658			_ = v.Args[1]
 22659			x := v.Args[0]
 22660			v_1 := v.Args[1]
 22661			if v_1.Op != OpMul64 {
 22662				break
 22663			}
 22664			_ = v_1.Args[1]
 22665			v_1_0 := v_1.Args[0]
 22666			if v_1_0.Op != OpSub64 {
 22667				break
 22668			}
 22669			_ = v_1_0.Args[1]
 22670			v_1_0_0 := v_1_0.Args[0]
 22671			if v_1_0_0.Op != OpRsh64x64 {
 22672				break
 22673			}
 22674			_ = v_1_0_0.Args[1]
 22675			v_1_0_0_0 := v_1_0_0.Args[0]
 22676			if v_1_0_0_0.Op != OpAdd64 {
 22677				break
 22678			}
 22679			_ = v_1_0_0_0.Args[1]
 22680			mul := v_1_0_0_0.Args[0]
 22681			if mul.Op != OpHmul64 {
 22682				break
 22683			}
 22684			_ = mul.Args[1]
 22685			if x != mul.Args[0] {
 22686				break
 22687			}
 22688			mul_1 := mul.Args[1]
 22689			if mul_1.Op != OpConst64 {
 22690				break
 22691			}
 22692			m := mul_1.AuxInt
 22693			if x != v_1_0_0_0.Args[1] {
 22694				break
 22695			}
 22696			v_1_0_0_1 := v_1_0_0.Args[1]
 22697			if v_1_0_0_1.Op != OpConst64 {
 22698				break
 22699			}
 22700			s := v_1_0_0_1.AuxInt
 22701			v_1_0_1 := v_1_0.Args[1]
 22702			if v_1_0_1.Op != OpRsh64x64 {
 22703				break
 22704			}
 22705			_ = v_1_0_1.Args[1]
 22706			if x != v_1_0_1.Args[0] {
 22707				break
 22708			}
 22709			v_1_0_1_1 := v_1_0_1.Args[1]
 22710			if v_1_0_1_1.Op != OpConst64 {
 22711				break
 22712			}
 22713			if v_1_0_1_1.AuxInt != 63 {
 22714				break
 22715			}
 22716			v_1_1 := v_1.Args[1]
 22717			if v_1_1.Op != OpConst64 {
 22718				break
 22719			}
 22720			c := v_1_1.AuxInt
 22721			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64, c).m) && s == smagic(64, c).s && x.Op != OpConst64 && sdivisibleOK(64, c)) {
 22722				break
 22723			}
 22724			v.reset(OpLeq64U)
 22725			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 22726			v1 := b.NewValue0(v.Pos, OpAdd64, typ.UInt64)
 22727			v2 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 22728			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22729			v3.AuxInt = int64(sdivisible(64, c).m)
 22730			v2.AddArg(v3)
 22731			v2.AddArg(x)
 22732			v1.AddArg(v2)
 22733			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22734			v4.AuxInt = int64(sdivisible(64, c).a)
 22735			v1.AddArg(v4)
 22736			v0.AddArg(v1)
 22737			v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22738			v5.AuxInt = int64(64 - sdivisible(64, c).k)
 22739			v0.AddArg(v5)
 22740			v.AddArg(v0)
 22741			v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22742			v6.AuxInt = int64(sdivisible(64, c).max)
 22743			v.AddArg(v6)
 22744			return true
 22745		}
 22746		// match: (Eq64 x (Mul64 (Sub64 (Rsh64x64 (Add64 x mul:(Hmul64 (Const64 [m]) x)) (Const64 [s])) (Rsh64x64 x (Const64 [63]))) (Const64 [c])))
 22747		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64,c).m) && s == smagic(64,c).s && x.Op != OpConst64 && sdivisibleOK(64,c)
 22748		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Add64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(sdivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(sdivisible(64,c).a)]) ) (Const64 <typ.UInt64> [int64(64-sdivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(sdivisible(64,c).max)]) )
 22749		for {
 22750			_ = v.Args[1]
 22751			x := v.Args[0]
 22752			v_1 := v.Args[1]
 22753			if v_1.Op != OpMul64 {
 22754				break
 22755			}
 22756			_ = v_1.Args[1]
 22757			v_1_0 := v_1.Args[0]
 22758			if v_1_0.Op != OpSub64 {
 22759				break
 22760			}
 22761			_ = v_1_0.Args[1]
 22762			v_1_0_0 := v_1_0.Args[0]
 22763			if v_1_0_0.Op != OpRsh64x64 {
 22764				break
 22765			}
 22766			_ = v_1_0_0.Args[1]
 22767			v_1_0_0_0 := v_1_0_0.Args[0]
 22768			if v_1_0_0_0.Op != OpAdd64 {
 22769				break
 22770			}
 22771			_ = v_1_0_0_0.Args[1]
 22772			if x != v_1_0_0_0.Args[0] {
 22773				break
 22774			}
 22775			mul := v_1_0_0_0.Args[1]
 22776			if mul.Op != OpHmul64 {
 22777				break
 22778			}
 22779			_ = mul.Args[1]
 22780			mul_0 := mul.Args[0]
 22781			if mul_0.Op != OpConst64 {
 22782				break
 22783			}
 22784			m := mul_0.AuxInt
 22785			if x != mul.Args[1] {
 22786				break
 22787			}
 22788			v_1_0_0_1 := v_1_0_0.Args[1]
 22789			if v_1_0_0_1.Op != OpConst64 {
 22790				break
 22791			}
 22792			s := v_1_0_0_1.AuxInt
 22793			v_1_0_1 := v_1_0.Args[1]
 22794			if v_1_0_1.Op != OpRsh64x64 {
 22795				break
 22796			}
 22797			_ = v_1_0_1.Args[1]
 22798			if x != v_1_0_1.Args[0] {
 22799				break
 22800			}
 22801			v_1_0_1_1 := v_1_0_1.Args[1]
 22802			if v_1_0_1_1.Op != OpConst64 {
 22803				break
 22804			}
 22805			if v_1_0_1_1.AuxInt != 63 {
 22806				break
 22807			}
 22808			v_1_1 := v_1.Args[1]
 22809			if v_1_1.Op != OpConst64 {
 22810				break
 22811			}
 22812			c := v_1_1.AuxInt
 22813			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64, c).m) && s == smagic(64, c).s && x.Op != OpConst64 && sdivisibleOK(64, c)) {
 22814				break
 22815			}
 22816			v.reset(OpLeq64U)
 22817			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 22818			v1 := b.NewValue0(v.Pos, OpAdd64, typ.UInt64)
 22819			v2 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 22820			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22821			v3.AuxInt = int64(sdivisible(64, c).m)
 22822			v2.AddArg(v3)
 22823			v2.AddArg(x)
 22824			v1.AddArg(v2)
 22825			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22826			v4.AuxInt = int64(sdivisible(64, c).a)
 22827			v1.AddArg(v4)
 22828			v0.AddArg(v1)
 22829			v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22830			v5.AuxInt = int64(64 - sdivisible(64, c).k)
 22831			v0.AddArg(v5)
 22832			v.AddArg(v0)
 22833			v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22834			v6.AuxInt = int64(sdivisible(64, c).max)
 22835			v.AddArg(v6)
 22836			return true
 22837		}
 22838		// match: (Eq64 x (Mul64 (Sub64 (Rsh64x64 (Add64 x mul:(Hmul64 x (Const64 [m]))) (Const64 [s])) (Rsh64x64 x (Const64 [63]))) (Const64 [c])))
 22839		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64,c).m) && s == smagic(64,c).s && x.Op != OpConst64 && sdivisibleOK(64,c)
 22840		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Add64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(sdivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(sdivisible(64,c).a)]) ) (Const64 <typ.UInt64> [int64(64-sdivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(sdivisible(64,c).max)]) )
 22841		for {
 22842			_ = v.Args[1]
 22843			x := v.Args[0]
 22844			v_1 := v.Args[1]
 22845			if v_1.Op != OpMul64 {
 22846				break
 22847			}
 22848			_ = v_1.Args[1]
 22849			v_1_0 := v_1.Args[0]
 22850			if v_1_0.Op != OpSub64 {
 22851				break
 22852			}
 22853			_ = v_1_0.Args[1]
 22854			v_1_0_0 := v_1_0.Args[0]
 22855			if v_1_0_0.Op != OpRsh64x64 {
 22856				break
 22857			}
 22858			_ = v_1_0_0.Args[1]
 22859			v_1_0_0_0 := v_1_0_0.Args[0]
 22860			if v_1_0_0_0.Op != OpAdd64 {
 22861				break
 22862			}
 22863			_ = v_1_0_0_0.Args[1]
 22864			if x != v_1_0_0_0.Args[0] {
 22865				break
 22866			}
 22867			mul := v_1_0_0_0.Args[1]
 22868			if mul.Op != OpHmul64 {
 22869				break
 22870			}
 22871			_ = mul.Args[1]
 22872			if x != mul.Args[0] {
 22873				break
 22874			}
 22875			mul_1 := mul.Args[1]
 22876			if mul_1.Op != OpConst64 {
 22877				break
 22878			}
 22879			m := mul_1.AuxInt
 22880			v_1_0_0_1 := v_1_0_0.Args[1]
 22881			if v_1_0_0_1.Op != OpConst64 {
 22882				break
 22883			}
 22884			s := v_1_0_0_1.AuxInt
 22885			v_1_0_1 := v_1_0.Args[1]
 22886			if v_1_0_1.Op != OpRsh64x64 {
 22887				break
 22888			}
 22889			_ = v_1_0_1.Args[1]
 22890			if x != v_1_0_1.Args[0] {
 22891				break
 22892			}
 22893			v_1_0_1_1 := v_1_0_1.Args[1]
 22894			if v_1_0_1_1.Op != OpConst64 {
 22895				break
 22896			}
 22897			if v_1_0_1_1.AuxInt != 63 {
 22898				break
 22899			}
 22900			v_1_1 := v_1.Args[1]
 22901			if v_1_1.Op != OpConst64 {
 22902				break
 22903			}
 22904			c := v_1_1.AuxInt
 22905			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64, c).m) && s == smagic(64, c).s && x.Op != OpConst64 && sdivisibleOK(64, c)) {
 22906				break
 22907			}
 22908			v.reset(OpLeq64U)
 22909			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 22910			v1 := b.NewValue0(v.Pos, OpAdd64, typ.UInt64)
 22911			v2 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 22912			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22913			v3.AuxInt = int64(sdivisible(64, c).m)
 22914			v2.AddArg(v3)
 22915			v2.AddArg(x)
 22916			v1.AddArg(v2)
 22917			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22918			v4.AuxInt = int64(sdivisible(64, c).a)
 22919			v1.AddArg(v4)
 22920			v0.AddArg(v1)
 22921			v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22922			v5.AuxInt = int64(64 - sdivisible(64, c).k)
 22923			v0.AddArg(v5)
 22924			v.AddArg(v0)
 22925			v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 22926			v6.AuxInt = int64(sdivisible(64, c).max)
 22927			v.AddArg(v6)
 22928			return true
 22929		}
 22930		// match: (Eq64 (Mul64 (Const64 [c]) (Sub64 (Rsh64x64 (Add64 mul:(Hmul64 (Const64 [m]) x) x) (Const64 [s])) (Rsh64x64 x (Const64 [63])))) x)
 22931		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64,c).m) && s == smagic(64,c).s && x.Op != OpConst64 && sdivisibleOK(64,c)
 22932		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Add64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(sdivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(sdivisible(64,c).a)]) ) (Const64 <typ.UInt64> [int64(64-sdivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(sdivisible(64,c).max)]) )
 22933		for {
 22934			x := v.Args[1]
 22935			v_0 := v.Args[0]
 22936			if v_0.Op != OpMul64 {
 22937				break
 22938			}
 22939			_ = v_0.Args[1]
 22940			v_0_0 := v_0.Args[0]
 22941			if v_0_0.Op != OpConst64 {
 22942				break
 22943			}
 22944			c := v_0_0.AuxInt
 22945			v_0_1 := v_0.Args[1]
 22946			if v_0_1.Op != OpSub64 {
 22947				break
 22948			}
 22949			_ = v_0_1.Args[1]
 22950			v_0_1_0 := v_0_1.Args[0]
 22951			if v_0_1_0.Op != OpRsh64x64 {
 22952				break
 22953			}
 22954			_ = v_0_1_0.Args[1]
 22955			v_0_1_0_0 := v_0_1_0.Args[0]
 22956			if v_0_1_0_0.Op != OpAdd64 {
 22957				break
 22958			}
 22959			_ = v_0_1_0_0.Args[1]
 22960			mul := v_0_1_0_0.Args[0]
 22961			if mul.Op != OpHmul64 {
 22962				break
 22963			}
 22964			_ = mul.Args[1]
 22965			mul_0 := mul.Args[0]
 22966			if mul_0.Op != OpConst64 {
 22967				break
 22968			}
 22969			m := mul_0.AuxInt
 22970			if x != mul.Args[1] {
 22971				break
 22972			}
 22973			if x != v_0_1_0_0.Args[1] {
 22974				break
 22975			}
 22976			v_0_1_0_1 := v_0_1_0.Args[1]
 22977			if v_0_1_0_1.Op != OpConst64 {
 22978				break
 22979			}
 22980			s := v_0_1_0_1.AuxInt
 22981			v_0_1_1 := v_0_1.Args[1]
 22982			if v_0_1_1.Op != OpRsh64x64 {
 22983				break
 22984			}
 22985			_ = v_0_1_1.Args[1]
 22986			if x != v_0_1_1.Args[0] {
 22987				break
 22988			}
 22989			v_0_1_1_1 := v_0_1_1.Args[1]
 22990			if v_0_1_1_1.Op != OpConst64 {
 22991				break
 22992			}
 22993			if v_0_1_1_1.AuxInt != 63 {
 22994				break
 22995			}
 22996			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64, c).m) && s == smagic(64, c).s && x.Op != OpConst64 && sdivisibleOK(64, c)) {
 22997				break
 22998			}
 22999			v.reset(OpLeq64U)
 23000			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 23001			v1 := b.NewValue0(v.Pos, OpAdd64, typ.UInt64)
 23002			v2 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 23003			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 23004			v3.AuxInt = int64(sdivisible(64, c).m)
 23005			v2.AddArg(v3)
 23006			v2.AddArg(x)
 23007			v1.AddArg(v2)
 23008			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 23009			v4.AuxInt = int64(sdivisible(64, c).a)
 23010			v1.AddArg(v4)
 23011			v0.AddArg(v1)
 23012			v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 23013			v5.AuxInt = int64(64 - sdivisible(64, c).k)
 23014			v0.AddArg(v5)
 23015			v.AddArg(v0)
 23016			v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 23017			v6.AuxInt = int64(sdivisible(64, c).max)
 23018			v.AddArg(v6)
 23019			return true
 23020		}
 23021		// match: (Eq64 (Mul64 (Const64 [c]) (Sub64 (Rsh64x64 (Add64 mul:(Hmul64 x (Const64 [m])) x) (Const64 [s])) (Rsh64x64 x (Const64 [63])))) x)
 23022		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64,c).m) && s == smagic(64,c).s && x.Op != OpConst64 && sdivisibleOK(64,c)
 23023		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Add64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(sdivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(sdivisible(64,c).a)]) ) (Const64 <typ.UInt64> [int64(64-sdivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(sdivisible(64,c).max)]) )
 23024		for {
 23025			x := v.Args[1]
 23026			v_0 := v.Args[0]
 23027			if v_0.Op != OpMul64 {
 23028				break
 23029			}
 23030			_ = v_0.Args[1]
 23031			v_0_0 := v_0.Args[0]
 23032			if v_0_0.Op != OpConst64 {
 23033				break
 23034			}
 23035			c := v_0_0.AuxInt
 23036			v_0_1 := v_0.Args[1]
 23037			if v_0_1.Op != OpSub64 {
 23038				break
 23039			}
 23040			_ = v_0_1.Args[1]
 23041			v_0_1_0 := v_0_1.Args[0]
 23042			if v_0_1_0.Op != OpRsh64x64 {
 23043				break
 23044			}
 23045			_ = v_0_1_0.Args[1]
 23046			v_0_1_0_0 := v_0_1_0.Args[0]
 23047			if v_0_1_0_0.Op != OpAdd64 {
 23048				break
 23049			}
 23050			_ = v_0_1_0_0.Args[1]
 23051			mul := v_0_1_0_0.Args[0]
 23052			if mul.Op != OpHmul64 {
 23053				break
 23054			}
 23055			_ = mul.Args[1]
 23056			if x != mul.Args[0] {
 23057				break
 23058			}
 23059			mul_1 := mul.Args[1]
 23060			if mul_1.Op != OpConst64 {
 23061				break
 23062			}
 23063			m := mul_1.AuxInt
 23064			if x != v_0_1_0_0.Args[1] {
 23065				break
 23066			}
 23067			v_0_1_0_1 := v_0_1_0.Args[1]
 23068			if v_0_1_0_1.Op != OpConst64 {
 23069				break
 23070			}
 23071			s := v_0_1_0_1.AuxInt
 23072			v_0_1_1 := v_0_1.Args[1]
 23073			if v_0_1_1.Op != OpRsh64x64 {
 23074				break
 23075			}
 23076			_ = v_0_1_1.Args[1]
 23077			if x != v_0_1_1.Args[0] {
 23078				break
 23079			}
 23080			v_0_1_1_1 := v_0_1_1.Args[1]
 23081			if v_0_1_1_1.Op != OpConst64 {
 23082				break
 23083			}
 23084			if v_0_1_1_1.AuxInt != 63 {
 23085				break
 23086			}
 23087			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64, c).m) && s == smagic(64, c).s && x.Op != OpConst64 && sdivisibleOK(64, c)) {
 23088				break
 23089			}
 23090			v.reset(OpLeq64U)
 23091			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 23092			v1 := b.NewValue0(v.Pos, OpAdd64, typ.UInt64)
 23093			v2 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 23094			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 23095			v3.AuxInt = int64(sdivisible(64, c).m)
 23096			v2.AddArg(v3)
 23097			v2.AddArg(x)
 23098			v1.AddArg(v2)
 23099			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 23100			v4.AuxInt = int64(sdivisible(64, c).a)
 23101			v1.AddArg(v4)
 23102			v0.AddArg(v1)
 23103			v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 23104			v5.AuxInt = int64(64 - sdivisible(64, c).k)
 23105			v0.AddArg(v5)
 23106			v.AddArg(v0)
 23107			v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 23108			v6.AuxInt = int64(sdivisible(64, c).max)
 23109			v.AddArg(v6)
 23110			return true
 23111		}
 23112		// match: (Eq64 (Mul64 (Const64 [c]) (Sub64 (Rsh64x64 (Add64 x mul:(Hmul64 (Const64 [m]) x)) (Const64 [s])) (Rsh64x64 x (Const64 [63])))) x)
 23113		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64,c).m) && s == smagic(64,c).s && x.Op != OpConst64 && sdivisibleOK(64,c)
 23114		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Add64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(sdivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(sdivisible(64,c).a)]) ) (Const64 <typ.UInt64> [int64(64-sdivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(sdivisible(64,c).max)]) )
 23115		for {
 23116			x := v.Args[1]
 23117			v_0 := v.Args[0]
 23118			if v_0.Op != OpMul64 {
 23119				break
 23120			}
 23121			_ = v_0.Args[1]
 23122			v_0_0 := v_0.Args[0]
 23123			if v_0_0.Op != OpConst64 {
 23124				break
 23125			}
 23126			c := v_0_0.AuxInt
 23127			v_0_1 := v_0.Args[1]
 23128			if v_0_1.Op != OpSub64 {
 23129				break
 23130			}
 23131			_ = v_0_1.Args[1]
 23132			v_0_1_0 := v_0_1.Args[0]
 23133			if v_0_1_0.Op != OpRsh64x64 {
 23134				break
 23135			}
 23136			_ = v_0_1_0.Args[1]
 23137			v_0_1_0_0 := v_0_1_0.Args[0]
 23138			if v_0_1_0_0.Op != OpAdd64 {
 23139				break
 23140			}
 23141			_ = v_0_1_0_0.Args[1]
 23142			if x != v_0_1_0_0.Args[0] {
 23143				break
 23144			}
 23145			mul := v_0_1_0_0.Args[1]
 23146			if mul.Op != OpHmul64 {
 23147				break
 23148			}
 23149			_ = mul.Args[1]
 23150			mul_0 := mul.Args[0]
 23151			if mul_0.Op != OpConst64 {
 23152				break
 23153			}
 23154			m := mul_0.AuxInt
 23155			if x != mul.Args[1] {
 23156				break
 23157			}
 23158			v_0_1_0_1 := v_0_1_0.Args[1]
 23159			if v_0_1_0_1.Op != OpConst64 {
 23160				break
 23161			}
 23162			s := v_0_1_0_1.AuxInt
 23163			v_0_1_1 := v_0_1.Args[1]
 23164			if v_0_1_1.Op != OpRsh64x64 {
 23165				break
 23166			}
 23167			_ = v_0_1_1.Args[1]
 23168			if x != v_0_1_1.Args[0] {
 23169				break
 23170			}
 23171			v_0_1_1_1 := v_0_1_1.Args[1]
 23172			if v_0_1_1_1.Op != OpConst64 {
 23173				break
 23174			}
 23175			if v_0_1_1_1.AuxInt != 63 {
 23176				break
 23177			}
 23178			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64, c).m) && s == smagic(64, c).s && x.Op != OpConst64 && sdivisibleOK(64, c)) {
 23179				break
 23180			}
 23181			v.reset(OpLeq64U)
 23182			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 23183			v1 := b.NewValue0(v.Pos, OpAdd64, typ.UInt64)
 23184			v2 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 23185			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 23186			v3.AuxInt = int64(sdivisible(64, c).m)
 23187			v2.AddArg(v3)
 23188			v2.AddArg(x)
 23189			v1.AddArg(v2)
 23190			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 23191			v4.AuxInt = int64(sdivisible(64, c).a)
 23192			v1.AddArg(v4)
 23193			v0.AddArg(v1)
 23194			v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 23195			v5.AuxInt = int64(64 - sdivisible(64, c).k)
 23196			v0.AddArg(v5)
 23197			v.AddArg(v0)
 23198			v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 23199			v6.AuxInt = int64(sdivisible(64, c).max)
 23200			v.AddArg(v6)
 23201			return true
 23202		}
 23203		return false
 23204	}
 23205	func rewriteValuegeneric_OpEq64_50(v *Value) bool {
 23206		b := v.Block
 23207		typ := &b.Func.Config.Types
 23208		// match: (Eq64 (Mul64 (Const64 [c]) (Sub64 (Rsh64x64 (Add64 x mul:(Hmul64 x (Const64 [m]))) (Const64 [s])) (Rsh64x64 x (Const64 [63])))) x)
 23209		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64,c).m) && s == smagic(64,c).s && x.Op != OpConst64 && sdivisibleOK(64,c)
 23210		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Add64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(sdivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(sdivisible(64,c).a)]) ) (Const64 <typ.UInt64> [int64(64-sdivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(sdivisible(64,c).max)]) )
 23211		for {
 23212			x := v.Args[1]
 23213			v_0 := v.Args[0]
 23214			if v_0.Op != OpMul64 {
 23215				break
 23216			}
 23217			_ = v_0.Args[1]
 23218			v_0_0 := v_0.Args[0]
 23219			if v_0_0.Op != OpConst64 {
 23220				break
 23221			}
 23222			c := v_0_0.AuxInt
 23223			v_0_1 := v_0.Args[1]
 23224			if v_0_1.Op != OpSub64 {
 23225				break
 23226			}
 23227			_ = v_0_1.Args[1]
 23228			v_0_1_0 := v_0_1.Args[0]
 23229			if v_0_1_0.Op != OpRsh64x64 {
 23230				break
 23231			}
 23232			_ = v_0_1_0.Args[1]
 23233			v_0_1_0_0 := v_0_1_0.Args[0]
 23234			if v_0_1_0_0.Op != OpAdd64 {
 23235				break
 23236			}
 23237			_ = v_0_1_0_0.Args[1]
 23238			if x != v_0_1_0_0.Args[0] {
 23239				break
 23240			}
 23241			mul := v_0_1_0_0.Args[1]
 23242			if mul.Op != OpHmul64 {
 23243				break
 23244			}
 23245			_ = mul.Args[1]
 23246			if x != mul.Args[0] {
 23247				break
 23248			}
 23249			mul_1 := mul.Args[1]
 23250			if mul_1.Op != OpConst64 {
 23251				break
 23252			}
 23253			m := mul_1.AuxInt
 23254			v_0_1_0_1 := v_0_1_0.Args[1]
 23255			if v_0_1_0_1.Op != OpConst64 {
 23256				break
 23257			}
 23258			s := v_0_1_0_1.AuxInt
 23259			v_0_1_1 := v_0_1.Args[1]
 23260			if v_0_1_1.Op != OpRsh64x64 {
 23261				break
 23262			}
 23263			_ = v_0_1_1.Args[1]
 23264			if x != v_0_1_1.Args[0] {
 23265				break
 23266			}
 23267			v_0_1_1_1 := v_0_1_1.Args[1]
 23268			if v_0_1_1_1.Op != OpConst64 {
 23269				break
 23270			}
 23271			if v_0_1_1_1.AuxInt != 63 {
 23272				break
 23273			}
 23274			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64, c).m) && s == smagic(64, c).s && x.Op != OpConst64 && sdivisibleOK(64, c)) {
 23275				break
 23276			}
 23277			v.reset(OpLeq64U)
 23278			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 23279			v1 := b.NewValue0(v.Pos, OpAdd64, typ.UInt64)
 23280			v2 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 23281			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 23282			v3.AuxInt = int64(sdivisible(64, c).m)
 23283			v2.AddArg(v3)
 23284			v2.AddArg(x)
 23285			v1.AddArg(v2)
 23286			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 23287			v4.AuxInt = int64(sdivisible(64, c).a)
 23288			v1.AddArg(v4)
 23289			v0.AddArg(v1)
 23290			v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 23291			v5.AuxInt = int64(64 - sdivisible(64, c).k)
 23292			v0.AddArg(v5)
 23293			v.AddArg(v0)
 23294			v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 23295			v6.AuxInt = int64(sdivisible(64, c).max)
 23296			v.AddArg(v6)
 23297			return true
 23298		}
 23299		// match: (Eq64 (Mul64 (Sub64 (Rsh64x64 (Add64 mul:(Hmul64 (Const64 [m]) x) x) (Const64 [s])) (Rsh64x64 x (Const64 [63]))) (Const64 [c])) x)
 23300		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64,c).m) && s == smagic(64,c).s && x.Op != OpConst64 && sdivisibleOK(64,c)
 23301		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Add64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(sdivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(sdivisible(64,c).a)]) ) (Const64 <typ.UInt64> [int64(64-sdivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(sdivisible(64,c).max)]) )
 23302		for {
 23303			x := v.Args[1]
 23304			v_0 := v.Args[0]
 23305			if v_0.Op != OpMul64 {
 23306				break
 23307			}
 23308			_ = v_0.Args[1]
 23309			v_0_0 := v_0.Args[0]
 23310			if v_0_0.Op != OpSub64 {
 23311				break
 23312			}
 23313			_ = v_0_0.Args[1]
 23314			v_0_0_0 := v_0_0.Args[0]
 23315			if v_0_0_0.Op != OpRsh64x64 {
 23316				break
 23317			}
 23318			_ = v_0_0_0.Args[1]
 23319			v_0_0_0_0 := v_0_0_0.Args[0]
 23320			if v_0_0_0_0.Op != OpAdd64 {
 23321				break
 23322			}
 23323			_ = v_0_0_0_0.Args[1]
 23324			mul := v_0_0_0_0.Args[0]
 23325			if mul.Op != OpHmul64 {
 23326				break
 23327			}
 23328			_ = mul.Args[1]
 23329			mul_0 := mul.Args[0]
 23330			if mul_0.Op != OpConst64 {
 23331				break
 23332			}
 23333			m := mul_0.AuxInt
 23334			if x != mul.Args[1] {
 23335				break
 23336			}
 23337			if x != v_0_0_0_0.Args[1] {
 23338				break
 23339			}
 23340			v_0_0_0_1 := v_0_0_0.Args[1]
 23341			if v_0_0_0_1.Op != OpConst64 {
 23342				break
 23343			}
 23344			s := v_0_0_0_1.AuxInt
 23345			v_0_0_1 := v_0_0.Args[1]
 23346			if v_0_0_1.Op != OpRsh64x64 {
 23347				break
 23348			}
 23349			_ = v_0_0_1.Args[1]
 23350			if x != v_0_0_1.Args[0] {
 23351				break
 23352			}
 23353			v_0_0_1_1 := v_0_0_1.Args[1]
 23354			if v_0_0_1_1.Op != OpConst64 {
 23355				break
 23356			}
 23357			if v_0_0_1_1.AuxInt != 63 {
 23358				break
 23359			}
 23360			v_0_1 := v_0.Args[1]
 23361			if v_0_1.Op != OpConst64 {
 23362				break
 23363			}
 23364			c := v_0_1.AuxInt
 23365			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64, c).m) && s == smagic(64, c).s && x.Op != OpConst64 && sdivisibleOK(64, c)) {
 23366				break
 23367			}
 23368			v.reset(OpLeq64U)
 23369			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 23370			v1 := b.NewValue0(v.Pos, OpAdd64, typ.UInt64)
 23371			v2 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 23372			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 23373			v3.AuxInt = int64(sdivisible(64, c).m)
 23374			v2.AddArg(v3)
 23375			v2.AddArg(x)
 23376			v1.AddArg(v2)
 23377			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 23378			v4.AuxInt = int64(sdivisible(64, c).a)
 23379			v1.AddArg(v4)
 23380			v0.AddArg(v1)
 23381			v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 23382			v5.AuxInt = int64(64 - sdivisible(64, c).k)
 23383			v0.AddArg(v5)
 23384			v.AddArg(v0)
 23385			v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 23386			v6.AuxInt = int64(sdivisible(64, c).max)
 23387			v.AddArg(v6)
 23388			return true
 23389		}
 23390		// match: (Eq64 (Mul64 (Sub64 (Rsh64x64 (Add64 mul:(Hmul64 x (Const64 [m])) x) (Const64 [s])) (Rsh64x64 x (Const64 [63]))) (Const64 [c])) x)
 23391		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64,c).m) && s == smagic(64,c).s && x.Op != OpConst64 && sdivisibleOK(64,c)
 23392		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Add64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(sdivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(sdivisible(64,c).a)]) ) (Const64 <typ.UInt64> [int64(64-sdivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(sdivisible(64,c).max)]) )
 23393		for {
 23394			x := v.Args[1]
 23395			v_0 := v.Args[0]
 23396			if v_0.Op != OpMul64 {
 23397				break
 23398			}
 23399			_ = v_0.Args[1]
 23400			v_0_0 := v_0.Args[0]
 23401			if v_0_0.Op != OpSub64 {
 23402				break
 23403			}
 23404			_ = v_0_0.Args[1]
 23405			v_0_0_0 := v_0_0.Args[0]
 23406			if v_0_0_0.Op != OpRsh64x64 {
 23407				break
 23408			}
 23409			_ = v_0_0_0.Args[1]
 23410			v_0_0_0_0 := v_0_0_0.Args[0]
 23411			if v_0_0_0_0.Op != OpAdd64 {
 23412				break
 23413			}
 23414			_ = v_0_0_0_0.Args[1]
 23415			mul := v_0_0_0_0.Args[0]
 23416			if mul.Op != OpHmul64 {
 23417				break
 23418			}
 23419			_ = mul.Args[1]
 23420			if x != mul.Args[0] {
 23421				break
 23422			}
 23423			mul_1 := mul.Args[1]
 23424			if mul_1.Op != OpConst64 {
 23425				break
 23426			}
 23427			m := mul_1.AuxInt
 23428			if x != v_0_0_0_0.Args[1] {
 23429				break
 23430			}
 23431			v_0_0_0_1 := v_0_0_0.Args[1]
 23432			if v_0_0_0_1.Op != OpConst64 {
 23433				break
 23434			}
 23435			s := v_0_0_0_1.AuxInt
 23436			v_0_0_1 := v_0_0.Args[1]
 23437			if v_0_0_1.Op != OpRsh64x64 {
 23438				break
 23439			}
 23440			_ = v_0_0_1.Args[1]
 23441			if x != v_0_0_1.Args[0] {
 23442				break
 23443			}
 23444			v_0_0_1_1 := v_0_0_1.Args[1]
 23445			if v_0_0_1_1.Op != OpConst64 {
 23446				break
 23447			}
 23448			if v_0_0_1_1.AuxInt != 63 {
 23449				break
 23450			}
 23451			v_0_1 := v_0.Args[1]
 23452			if v_0_1.Op != OpConst64 {
 23453				break
 23454			}
 23455			c := v_0_1.AuxInt
 23456			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64, c).m) && s == smagic(64, c).s && x.Op != OpConst64 && sdivisibleOK(64, c)) {
 23457				break
 23458			}
 23459			v.reset(OpLeq64U)
 23460			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 23461			v1 := b.NewValue0(v.Pos, OpAdd64, typ.UInt64)
 23462			v2 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 23463			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 23464			v3.AuxInt = int64(sdivisible(64, c).m)
 23465			v2.AddArg(v3)
 23466			v2.AddArg(x)
 23467			v1.AddArg(v2)
 23468			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 23469			v4.AuxInt = int64(sdivisible(64, c).a)
 23470			v1.AddArg(v4)
 23471			v0.AddArg(v1)
 23472			v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 23473			v5.AuxInt = int64(64 - sdivisible(64, c).k)
 23474			v0.AddArg(v5)
 23475			v.AddArg(v0)
 23476			v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 23477			v6.AuxInt = int64(sdivisible(64, c).max)
 23478			v.AddArg(v6)
 23479			return true
 23480		}
 23481		// match: (Eq64 (Mul64 (Sub64 (Rsh64x64 (Add64 x mul:(Hmul64 (Const64 [m]) x)) (Const64 [s])) (Rsh64x64 x (Const64 [63]))) (Const64 [c])) x)
 23482		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64,c).m) && s == smagic(64,c).s && x.Op != OpConst64 && sdivisibleOK(64,c)
 23483		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Add64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(sdivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(sdivisible(64,c).a)]) ) (Const64 <typ.UInt64> [int64(64-sdivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(sdivisible(64,c).max)]) )
 23484		for {
 23485			x := v.Args[1]
 23486			v_0 := v.Args[0]
 23487			if v_0.Op != OpMul64 {
 23488				break
 23489			}
 23490			_ = v_0.Args[1]
 23491			v_0_0 := v_0.Args[0]
 23492			if v_0_0.Op != OpSub64 {
 23493				break
 23494			}
 23495			_ = v_0_0.Args[1]
 23496			v_0_0_0 := v_0_0.Args[0]
 23497			if v_0_0_0.Op != OpRsh64x64 {
 23498				break
 23499			}
 23500			_ = v_0_0_0.Args[1]
 23501			v_0_0_0_0 := v_0_0_0.Args[0]
 23502			if v_0_0_0_0.Op != OpAdd64 {
 23503				break
 23504			}
 23505			_ = v_0_0_0_0.Args[1]
 23506			if x != v_0_0_0_0.Args[0] {
 23507				break
 23508			}
 23509			mul := v_0_0_0_0.Args[1]
 23510			if mul.Op != OpHmul64 {
 23511				break
 23512			}
 23513			_ = mul.Args[1]
 23514			mul_0 := mul.Args[0]
 23515			if mul_0.Op != OpConst64 {
 23516				break
 23517			}
 23518			m := mul_0.AuxInt
 23519			if x != mul.Args[1] {
 23520				break
 23521			}
 23522			v_0_0_0_1 := v_0_0_0.Args[1]
 23523			if v_0_0_0_1.Op != OpConst64 {
 23524				break
 23525			}
 23526			s := v_0_0_0_1.AuxInt
 23527			v_0_0_1 := v_0_0.Args[1]
 23528			if v_0_0_1.Op != OpRsh64x64 {
 23529				break
 23530			}
 23531			_ = v_0_0_1.Args[1]
 23532			if x != v_0_0_1.Args[0] {
 23533				break
 23534			}
 23535			v_0_0_1_1 := v_0_0_1.Args[1]
 23536			if v_0_0_1_1.Op != OpConst64 {
 23537				break
 23538			}
 23539			if v_0_0_1_1.AuxInt != 63 {
 23540				break
 23541			}
 23542			v_0_1 := v_0.Args[1]
 23543			if v_0_1.Op != OpConst64 {
 23544				break
 23545			}
 23546			c := v_0_1.AuxInt
 23547			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64, c).m) && s == smagic(64, c).s && x.Op != OpConst64 && sdivisibleOK(64, c)) {
 23548				break
 23549			}
 23550			v.reset(OpLeq64U)
 23551			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 23552			v1 := b.NewValue0(v.Pos, OpAdd64, typ.UInt64)
 23553			v2 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 23554			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 23555			v3.AuxInt = int64(sdivisible(64, c).m)
 23556			v2.AddArg(v3)
 23557			v2.AddArg(x)
 23558			v1.AddArg(v2)
 23559			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 23560			v4.AuxInt = int64(sdivisible(64, c).a)
 23561			v1.AddArg(v4)
 23562			v0.AddArg(v1)
 23563			v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 23564			v5.AuxInt = int64(64 - sdivisible(64, c).k)
 23565			v0.AddArg(v5)
 23566			v.AddArg(v0)
 23567			v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 23568			v6.AuxInt = int64(sdivisible(64, c).max)
 23569			v.AddArg(v6)
 23570			return true
 23571		}
 23572		// match: (Eq64 (Mul64 (Sub64 (Rsh64x64 (Add64 x mul:(Hmul64 x (Const64 [m]))) (Const64 [s])) (Rsh64x64 x (Const64 [63]))) (Const64 [c])) x)
 23573		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64,c).m) && s == smagic(64,c).s && x.Op != OpConst64 && sdivisibleOK(64,c)
 23574		// result: (Leq64U (RotateLeft64 <typ.UInt64> (Add64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(sdivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(sdivisible(64,c).a)]) ) (Const64 <typ.UInt64> [int64(64-sdivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(sdivisible(64,c).max)]) )
 23575		for {
 23576			x := v.Args[1]
 23577			v_0 := v.Args[0]
 23578			if v_0.Op != OpMul64 {
 23579				break
 23580			}
 23581			_ = v_0.Args[1]
 23582			v_0_0 := v_0.Args[0]
 23583			if v_0_0.Op != OpSub64 {
 23584				break
 23585			}
 23586			_ = v_0_0.Args[1]
 23587			v_0_0_0 := v_0_0.Args[0]
 23588			if v_0_0_0.Op != OpRsh64x64 {
 23589				break
 23590			}
 23591			_ = v_0_0_0.Args[1]
 23592			v_0_0_0_0 := v_0_0_0.Args[0]
 23593			if v_0_0_0_0.Op != OpAdd64 {
 23594				break
 23595			}
 23596			_ = v_0_0_0_0.Args[1]
 23597			if x != v_0_0_0_0.Args[0] {
 23598				break
 23599			}
 23600			mul := v_0_0_0_0.Args[1]
 23601			if mul.Op != OpHmul64 {
 23602				break
 23603			}
 23604			_ = mul.Args[1]
 23605			if x != mul.Args[0] {
 23606				break
 23607			}
 23608			mul_1 := mul.Args[1]
 23609			if mul_1.Op != OpConst64 {
 23610				break
 23611			}
 23612			m := mul_1.AuxInt
 23613			v_0_0_0_1 := v_0_0_0.Args[1]
 23614			if v_0_0_0_1.Op != OpConst64 {
 23615				break
 23616			}
 23617			s := v_0_0_0_1.AuxInt
 23618			v_0_0_1 := v_0_0.Args[1]
 23619			if v_0_0_1.Op != OpRsh64x64 {
 23620				break
 23621			}
 23622			_ = v_0_0_1.Args[1]
 23623			if x != v_0_0_1.Args[0] {
 23624				break
 23625			}
 23626			v_0_0_1_1 := v_0_0_1.Args[1]
 23627			if v_0_0_1_1.Op != OpConst64 {
 23628				break
 23629			}
 23630			if v_0_0_1_1.AuxInt != 63 {
 23631				break
 23632			}
 23633			v_0_1 := v_0.Args[1]
 23634			if v_0_1.Op != OpConst64 {
 23635				break
 23636			}
 23637			c := v_0_1.AuxInt
 23638			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64, c).m) && s == smagic(64, c).s && x.Op != OpConst64 && sdivisibleOK(64, c)) {
 23639				break
 23640			}
 23641			v.reset(OpLeq64U)
 23642			v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64)
 23643			v1 := b.NewValue0(v.Pos, OpAdd64, typ.UInt64)
 23644			v2 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
 23645			v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 23646			v3.AuxInt = int64(sdivisible(64, c).m)
 23647			v2.AddArg(v3)
 23648			v2.AddArg(x)
 23649			v1.AddArg(v2)
 23650			v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 23651			v4.AuxInt = int64(sdivisible(64, c).a)
 23652			v1.AddArg(v4)
 23653			v0.AddArg(v1)
 23654			v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 23655			v5.AuxInt = int64(64 - sdivisible(64, c).k)
 23656			v0.AddArg(v5)
 23657			v.AddArg(v0)
 23658			v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 23659			v6.AuxInt = int64(sdivisible(64, c).max)
 23660			v.AddArg(v6)
 23661			return true
 23662		}
 23663		// match: (Eq64 n (Lsh64x64 (Rsh64x64 (Add64 <t> n (Rsh64Ux64 <t> (Rsh64x64 <t> n (Const64 <typ.UInt64> [63])) (Const64 <typ.UInt64> [kbar]))) (Const64 <typ.UInt64> [k])) (Const64 <typ.UInt64> [k])))
 23664		// cond: k > 0 && k < 63 && kbar == 64 - k
 23665		// result: (Eq64 (And64 <t> n (Const64 <t> [int64(1<<uint(k)-1)])) (Const64 <t> [0]))
 23666		for {
 23667			_ = v.Args[1]
 23668			n := v.Args[0]
 23669			v_1 := v.Args[1]
 23670			if v_1.Op != OpLsh64x64 {
 23671				break
 23672			}
 23673			_ = v_1.Args[1]
 23674			v_1_0 := v_1.Args[0]
 23675			if v_1_0.Op != OpRsh64x64 {
 23676				break
 23677			}
 23678			_ = v_1_0.Args[1]
 23679			v_1_0_0 := v_1_0.Args[0]
 23680			if v_1_0_0.Op != OpAdd64 {
 23681				break
 23682			}
 23683			t := v_1_0_0.Type
 23684			_ = v_1_0_0.Args[1]
 23685			if n != v_1_0_0.Args[0] {
 23686				break
 23687			}
 23688			v_1_0_0_1 := v_1_0_0.Args[1]
 23689			if v_1_0_0_1.Op != OpRsh64Ux64 {
 23690				break
 23691			}
 23692			if v_1_0_0_1.Type != t {
 23693				break
 23694			}
 23695			_ = v_1_0_0_1.Args[1]
 23696			v_1_0_0_1_0 := v_1_0_0_1.Args[0]
 23697			if v_1_0_0_1_0.Op != OpRsh64x64 {
 23698				break
 23699			}
 23700			if v_1_0_0_1_0.Type != t {
 23701				break
 23702			}
 23703			_ = v_1_0_0_1_0.Args[1]
 23704			if n != v_1_0_0_1_0.Args[0] {
 23705				break
 23706			}
 23707			v_1_0_0_1_0_1 := v_1_0_0_1_0.Args[1]
 23708			if v_1_0_0_1_0_1.Op != OpConst64 {
 23709				break
 23710			}
 23711			if v_1_0_0_1_0_1.Type != typ.UInt64 {
 23712				break
 23713			}
 23714			if v_1_0_0_1_0_1.AuxInt != 63 {
 23715				break
 23716			}
 23717			v_1_0_0_1_1 := v_1_0_0_1.Args[1]
 23718			if v_1_0_0_1_1.Op != OpConst64 {
 23719				break
 23720			}
 23721			if v_1_0_0_1_1.Type != typ.UInt64 {
 23722				break
 23723			}
 23724			kbar := v_1_0_0_1_1.AuxInt
 23725			v_1_0_1 := v_1_0.Args[1]
 23726			if v_1_0_1.Op != OpConst64 {
 23727				break
 23728			}
 23729			if v_1_0_1.Type != typ.UInt64 {
 23730				break
 23731			}
 23732			k := v_1_0_1.AuxInt
 23733			v_1_1 := v_1.Args[1]
 23734			if v_1_1.Op != OpConst64 {
 23735				break
 23736			}
 23737			if v_1_1.Type != typ.UInt64 {
 23738				break
 23739			}
 23740			if v_1_1.AuxInt != k {
 23741				break
 23742			}
 23743			if !(k > 0 && k < 63 && kbar == 64-k) {
 23744				break
 23745			}
 23746			v.reset(OpEq64)
 23747			v0 := b.NewValue0(v.Pos, OpAnd64, t)
 23748			v0.AddArg(n)
 23749			v1 := b.NewValue0(v.Pos, OpConst64, t)
 23750			v1.AuxInt = int64(1<<uint(k) - 1)
 23751			v0.AddArg(v1)
 23752			v.AddArg(v0)
 23753			v2 := b.NewValue0(v.Pos, OpConst64, t)
 23754			v2.AuxInt = 0
 23755			v.AddArg(v2)
 23756			return true
 23757		}
 23758		// match: (Eq64 n (Lsh64x64 (Rsh64x64 (Add64 <t> (Rsh64Ux64 <t> (Rsh64x64 <t> n (Const64 <typ.UInt64> [63])) (Const64 <typ.UInt64> [kbar])) n) (Const64 <typ.UInt64> [k])) (Const64 <typ.UInt64> [k])))
 23759		// cond: k > 0 && k < 63 && kbar == 64 - k
 23760		// result: (Eq64 (And64 <t> n (Const64 <t> [int64(1<<uint(k)-1)])) (Const64 <t> [0]))
 23761		for {
 23762			_ = v.Args[1]
 23763			n := v.Args[0]
 23764			v_1 := v.Args[1]
 23765			if v_1.Op != OpLsh64x64 {
 23766				break
 23767			}
 23768			_ = v_1.Args[1]
 23769			v_1_0 := v_1.Args[0]
 23770			if v_1_0.Op != OpRsh64x64 {
 23771				break
 23772			}
 23773			_ = v_1_0.Args[1]
 23774			v_1_0_0 := v_1_0.Args[0]
 23775			if v_1_0_0.Op != OpAdd64 {
 23776				break
 23777			}
 23778			t := v_1_0_0.Type
 23779			_ = v_1_0_0.Args[1]
 23780			v_1_0_0_0 := v_1_0_0.Args[0]
 23781			if v_1_0_0_0.Op != OpRsh64Ux64 {
 23782				break
 23783			}
 23784			if v_1_0_0_0.Type != t {
 23785				break
 23786			}
 23787			_ = v_1_0_0_0.Args[1]
 23788			v_1_0_0_0_0 := v_1_0_0_0.Args[0]
 23789			if v_1_0_0_0_0.Op != OpRsh64x64 {
 23790				break
 23791			}
 23792			if v_1_0_0_0_0.Type != t {
 23793				break
 23794			}
 23795			_ = v_1_0_0_0_0.Args[1]
 23796			if n != v_1_0_0_0_0.Args[0] {
 23797				break
 23798			}
 23799			v_1_0_0_0_0_1 := v_1_0_0_0_0.Args[1]
 23800			if v_1_0_0_0_0_1.Op != OpConst64 {
 23801				break
 23802			}
 23803			if v_1_0_0_0_0_1.Type != typ.UInt64 {
 23804				break
 23805			}
 23806			if v_1_0_0_0_0_1.AuxInt != 63 {
 23807				break
 23808			}
 23809			v_1_0_0_0_1 := v_1_0_0_0.Args[1]
 23810			if v_1_0_0_0_1.Op != OpConst64 {
 23811				break
 23812			}
 23813			if v_1_0_0_0_1.Type != typ.UInt64 {
 23814				break
 23815			}
 23816			kbar := v_1_0_0_0_1.AuxInt
 23817			if n != v_1_0_0.Args[1] {
 23818				break
 23819			}
 23820			v_1_0_1 := v_1_0.Args[1]
 23821			if v_1_0_1.Op != OpConst64 {
 23822				break
 23823			}
 23824			if v_1_0_1.Type != typ.UInt64 {
 23825				break
 23826			}
 23827			k := v_1_0_1.AuxInt
 23828			v_1_1 := v_1.Args[1]
 23829			if v_1_1.Op != OpConst64 {
 23830				break
 23831			}
 23832			if v_1_1.Type != typ.UInt64 {
 23833				break
 23834			}
 23835			if v_1_1.AuxInt != k {
 23836				break
 23837			}
 23838			if !(k > 0 && k < 63 && kbar == 64-k) {
 23839				break
 23840			}
 23841			v.reset(OpEq64)
 23842			v0 := b.NewValue0(v.Pos, OpAnd64, t)
 23843			v0.AddArg(n)
 23844			v1 := b.NewValue0(v.Pos, OpConst64, t)
 23845			v1.AuxInt = int64(1<<uint(k) - 1)
 23846			v0.AddArg(v1)
 23847			v.AddArg(v0)
 23848			v2 := b.NewValue0(v.Pos, OpConst64, t)
 23849			v2.AuxInt = 0
 23850			v.AddArg(v2)
 23851			return true
 23852		}
 23853		// match: (Eq64 (Lsh64x64 (Rsh64x64 (Add64 <t> n (Rsh64Ux64 <t> (Rsh64x64 <t> n (Const64 <typ.UInt64> [63])) (Const64 <typ.UInt64> [kbar]))) (Const64 <typ.UInt64> [k])) (Const64 <typ.UInt64> [k])) n)
 23854		// cond: k > 0 && k < 63 && kbar == 64 - k
 23855		// result: (Eq64 (And64 <t> n (Const64 <t> [int64(1<<uint(k)-1)])) (Const64 <t> [0]))
 23856		for {
 23857			n := v.Args[1]
 23858			v_0 := v.Args[0]
 23859			if v_0.Op != OpLsh64x64 {
 23860				break
 23861			}
 23862			_ = v_0.Args[1]
 23863			v_0_0 := v_0.Args[0]
 23864			if v_0_0.Op != OpRsh64x64 {
 23865				break
 23866			}
 23867			_ = v_0_0.Args[1]
 23868			v_0_0_0 := v_0_0.Args[0]
 23869			if v_0_0_0.Op != OpAdd64 {
 23870				break
 23871			}
 23872			t := v_0_0_0.Type
 23873			_ = v_0_0_0.Args[1]
 23874			if n != v_0_0_0.Args[0] {
 23875				break
 23876			}
 23877			v_0_0_0_1 := v_0_0_0.Args[1]
 23878			if v_0_0_0_1.Op != OpRsh64Ux64 {
 23879				break
 23880			}
 23881			if v_0_0_0_1.Type != t {
 23882				break
 23883			}
 23884			_ = v_0_0_0_1.Args[1]
 23885			v_0_0_0_1_0 := v_0_0_0_1.Args[0]
 23886			if v_0_0_0_1_0.Op != OpRsh64x64 {
 23887				break
 23888			}
 23889			if v_0_0_0_1_0.Type != t {
 23890				break
 23891			}
 23892			_ = v_0_0_0_1_0.Args[1]
 23893			if n != v_0_0_0_1_0.Args[0] {
 23894				break
 23895			}
 23896			v_0_0_0_1_0_1 := v_0_0_0_1_0.Args[1]
 23897			if v_0_0_0_1_0_1.Op != OpConst64 {
 23898				break
 23899			}
 23900			if v_0_0_0_1_0_1.Type != typ.UInt64 {
 23901				break
 23902			}
 23903			if v_0_0_0_1_0_1.AuxInt != 63 {
 23904				break
 23905			}
 23906			v_0_0_0_1_1 := v_0_0_0_1.Args[1]
 23907			if v_0_0_0_1_1.Op != OpConst64 {
 23908				break
 23909			}
 23910			if v_0_0_0_1_1.Type != typ.UInt64 {
 23911				break
 23912			}
 23913			kbar := v_0_0_0_1_1.AuxInt
 23914			v_0_0_1 := v_0_0.Args[1]
 23915			if v_0_0_1.Op != OpConst64 {
 23916				break
 23917			}
 23918			if v_0_0_1.Type != typ.UInt64 {
 23919				break
 23920			}
 23921			k := v_0_0_1.AuxInt
 23922			v_0_1 := v_0.Args[1]
 23923			if v_0_1.Op != OpConst64 {
 23924				break
 23925			}
 23926			if v_0_1.Type != typ.UInt64 {
 23927				break
 23928			}
 23929			if v_0_1.AuxInt != k {
 23930				break
 23931			}
 23932			if !(k > 0 && k < 63 && kbar == 64-k) {
 23933				break
 23934			}
 23935			v.reset(OpEq64)
 23936			v0 := b.NewValue0(v.Pos, OpAnd64, t)
 23937			v0.AddArg(n)
 23938			v1 := b.NewValue0(v.Pos, OpConst64, t)
 23939			v1.AuxInt = int64(1<<uint(k) - 1)
 23940			v0.AddArg(v1)
 23941			v.AddArg(v0)
 23942			v2 := b.NewValue0(v.Pos, OpConst64, t)
 23943			v2.AuxInt = 0
 23944			v.AddArg(v2)
 23945			return true
 23946		}
 23947		// match: (Eq64 (Lsh64x64 (Rsh64x64 (Add64 <t> (Rsh64Ux64 <t> (Rsh64x64 <t> n (Const64 <typ.UInt64> [63])) (Const64 <typ.UInt64> [kbar])) n) (Const64 <typ.UInt64> [k])) (Const64 <typ.UInt64> [k])) n)
 23948		// cond: k > 0 && k < 63 && kbar == 64 - k
 23949		// result: (Eq64 (And64 <t> n (Const64 <t> [int64(1<<uint(k)-1)])) (Const64 <t> [0]))
 23950		for {
 23951			n := v.Args[1]
 23952			v_0 := v.Args[0]
 23953			if v_0.Op != OpLsh64x64 {
 23954				break
 23955			}
 23956			_ = v_0.Args[1]
 23957			v_0_0 := v_0.Args[0]
 23958			if v_0_0.Op != OpRsh64x64 {
 23959				break
 23960			}
 23961			_ = v_0_0.Args[1]
 23962			v_0_0_0 := v_0_0.Args[0]
 23963			if v_0_0_0.Op != OpAdd64 {
 23964				break
 23965			}
 23966			t := v_0_0_0.Type
 23967			_ = v_0_0_0.Args[1]
 23968			v_0_0_0_0 := v_0_0_0.Args[0]
 23969			if v_0_0_0_0.Op != OpRsh64Ux64 {
 23970				break
 23971			}
 23972			if v_0_0_0_0.Type != t {
 23973				break
 23974			}
 23975			_ = v_0_0_0_0.Args[1]
 23976			v_0_0_0_0_0 := v_0_0_0_0.Args[0]
 23977			if v_0_0_0_0_0.Op != OpRsh64x64 {
 23978				break
 23979			}
 23980			if v_0_0_0_0_0.Type != t {
 23981				break
 23982			}
 23983			_ = v_0_0_0_0_0.Args[1]
 23984			if n != v_0_0_0_0_0.Args[0] {
 23985				break
 23986			}
 23987			v_0_0_0_0_0_1 := v_0_0_0_0_0.Args[1]
 23988			if v_0_0_0_0_0_1.Op != OpConst64 {
 23989				break
 23990			}
 23991			if v_0_0_0_0_0_1.Type != typ.UInt64 {
 23992				break
 23993			}
 23994			if v_0_0_0_0_0_1.AuxInt != 63 {
 23995				break
 23996			}
 23997			v_0_0_0_0_1 := v_0_0_0_0.Args[1]
 23998			if v_0_0_0_0_1.Op != OpConst64 {
 23999				break
 24000			}
 24001			if v_0_0_0_0_1.Type != typ.UInt64 {
 24002				break
 24003			}
 24004			kbar := v_0_0_0_0_1.AuxInt
 24005			if n != v_0_0_0.Args[1] {
 24006				break
 24007			}
 24008			v_0_0_1 := v_0_0.Args[1]
 24009			if v_0_0_1.Op != OpConst64 {
 24010				break
 24011			}
 24012			if v_0_0_1.Type != typ.UInt64 {
 24013				break
 24014			}
 24015			k := v_0_0_1.AuxInt
 24016			v_0_1 := v_0.Args[1]
 24017			if v_0_1.Op != OpConst64 {
 24018				break
 24019			}
 24020			if v_0_1.Type != typ.UInt64 {
 24021				break
 24022			}
 24023			if v_0_1.AuxInt != k {
 24024				break
 24025			}
 24026			if !(k > 0 && k < 63 && kbar == 64-k) {
 24027				break
 24028			}
 24029			v.reset(OpEq64)
 24030			v0 := b.NewValue0(v.Pos, OpAnd64, t)
 24031			v0.AddArg(n)
 24032			v1 := b.NewValue0(v.Pos, OpConst64, t)
 24033			v1.AuxInt = int64(1<<uint(k) - 1)
 24034			v0.AddArg(v1)
 24035			v.AddArg(v0)
 24036			v2 := b.NewValue0(v.Pos, OpConst64, t)
 24037			v2.AuxInt = 0
 24038			v.AddArg(v2)
 24039			return true
 24040		}
 24041		// match: (Eq64 s:(Sub64 x y) (Const64 [0]))
 24042		// cond: s.Uses == 1
 24043		// result: (Eq64 x y)
 24044		for {
 24045			_ = v.Args[1]
 24046			s := v.Args[0]
 24047			if s.Op != OpSub64 {
 24048				break
 24049			}
 24050			y := s.Args[1]
 24051			x := s.Args[0]
 24052			v_1 := v.Args[1]
 24053			if v_1.Op != OpConst64 {
 24054				break
 24055			}
 24056			if v_1.AuxInt != 0 {
 24057				break
 24058			}
 24059			if !(s.Uses == 1) {
 24060				break
 24061			}
 24062			v.reset(OpEq64)
 24063			v.AddArg(x)
 24064			v.AddArg(y)
 24065			return true
 24066		}
 24067		return false
 24068	}
 24069	func rewriteValuegeneric_OpEq64_60(v *Value) bool {
 24070		// match: (Eq64 (Const64 [0]) s:(Sub64 x y))
 24071		// cond: s.Uses == 1
 24072		// result: (Eq64 x y)
 24073		for {
 24074			_ = v.Args[1]
 24075			v_0 := v.Args[0]
 24076			if v_0.Op != OpConst64 {
 24077				break
 24078			}
 24079			if v_0.AuxInt != 0 {
 24080				break
 24081			}
 24082			s := v.Args[1]
 24083			if s.Op != OpSub64 {
 24084				break
 24085			}
 24086			y := s.Args[1]
 24087			x := s.Args[0]
 24088			if !(s.Uses == 1) {
 24089				break
 24090			}
 24091			v.reset(OpEq64)
 24092			v.AddArg(x)
 24093			v.AddArg(y)
 24094			return true
 24095		}
 24096		return false
 24097	}
 24098	func rewriteValuegeneric_OpEq64F_0(v *Value) bool {
 24099		// match: (Eq64F (Const64F [c]) (Const64F [d]))
 24100		// cond:
 24101		// result: (ConstBool [b2i(auxTo64F(c) == auxTo64F(d))])
 24102		for {
 24103			_ = v.Args[1]
 24104			v_0 := v.Args[0]
 24105			if v_0.Op != OpConst64F {
 24106				break
 24107			}
 24108			c := v_0.AuxInt
 24109			v_1 := v.Args[1]
 24110			if v_1.Op != OpConst64F {
 24111				break
 24112			}
 24113			d := v_1.AuxInt
 24114			v.reset(OpConstBool)
 24115			v.AuxInt = b2i(auxTo64F(c) == auxTo64F(d))
 24116			return true
 24117		}
 24118		// match: (Eq64F (Const64F [d]) (Const64F [c]))
 24119		// cond:
 24120		// result: (ConstBool [b2i(auxTo64F(c) == auxTo64F(d))])
 24121		for {
 24122			_ = v.Args[1]
 24123			v_0 := v.Args[0]
 24124			if v_0.Op != OpConst64F {
 24125				break
 24126			}
 24127			d := v_0.AuxInt
 24128			v_1 := v.Args[1]
 24129			if v_1.Op != OpConst64F {
 24130				break
 24131			}
 24132			c := v_1.AuxInt
 24133			v.reset(OpConstBool)
 24134			v.AuxInt = b2i(auxTo64F(c) == auxTo64F(d))
 24135			return true
 24136		}
 24137		return false
 24138	}
 24139	func rewriteValuegeneric_OpEq8_0(v *Value) bool {
 24140		b := v.Block
 24141		config := b.Func.Config
 24142		typ := &b.Func.Config.Types
 24143		// match: (Eq8 x x)
 24144		// cond:
 24145		// result: (ConstBool [1])
 24146		for {
 24147			x := v.Args[1]
 24148			if x != v.Args[0] {
 24149				break
 24150			}
 24151			v.reset(OpConstBool)
 24152			v.AuxInt = 1
 24153			return true
 24154		}
 24155		// match: (Eq8 (Const8 <t> [c]) (Add8 (Const8 <t> [d]) x))
 24156		// cond:
 24157		// result: (Eq8 (Const8 <t> [int64(int8(c-d))]) x)
 24158		for {
 24159			_ = v.Args[1]
 24160			v_0 := v.Args[0]
 24161			if v_0.Op != OpConst8 {
 24162				break
 24163			}
 24164			t := v_0.Type
 24165			c := v_0.AuxInt
 24166			v_1 := v.Args[1]
 24167			if v_1.Op != OpAdd8 {
 24168				break
 24169			}
 24170			x := v_1.Args[1]
 24171			v_1_0 := v_1.Args[0]
 24172			if v_1_0.Op != OpConst8 {
 24173				break
 24174			}
 24175			if v_1_0.Type != t {
 24176				break
 24177			}
 24178			d := v_1_0.AuxInt
 24179			v.reset(OpEq8)
 24180			v0 := b.NewValue0(v.Pos, OpConst8, t)
 24181			v0.AuxInt = int64(int8(c - d))
 24182			v.AddArg(v0)
 24183			v.AddArg(x)
 24184			return true
 24185		}
 24186		// match: (Eq8 (Const8 <t> [c]) (Add8 x (Const8 <t> [d])))
 24187		// cond:
 24188		// result: (Eq8 (Const8 <t> [int64(int8(c-d))]) x)
 24189		for {
 24190			_ = v.Args[1]
 24191			v_0 := v.Args[0]
 24192			if v_0.Op != OpConst8 {
 24193				break
 24194			}
 24195			t := v_0.Type
 24196			c := v_0.AuxInt
 24197			v_1 := v.Args[1]
 24198			if v_1.Op != OpAdd8 {
 24199				break
 24200			}
 24201			_ = v_1.Args[1]
 24202			x := v_1.Args[0]
 24203			v_1_1 := v_1.Args[1]
 24204			if v_1_1.Op != OpConst8 {
 24205				break
 24206			}
 24207			if v_1_1.Type != t {
 24208				break
 24209			}
 24210			d := v_1_1.AuxInt
 24211			v.reset(OpEq8)
 24212			v0 := b.NewValue0(v.Pos, OpConst8, t)
 24213			v0.AuxInt = int64(int8(c - d))
 24214			v.AddArg(v0)
 24215			v.AddArg(x)
 24216			return true
 24217		}
 24218		// match: (Eq8 (Add8 (Const8 <t> [d]) x) (Const8 <t> [c]))
 24219		// cond:
 24220		// result: (Eq8 (Const8 <t> [int64(int8(c-d))]) x)
 24221		for {
 24222			_ = v.Args[1]
 24223			v_0 := v.Args[0]
 24224			if v_0.Op != OpAdd8 {
 24225				break
 24226			}
 24227			x := v_0.Args[1]
 24228			v_0_0 := v_0.Args[0]
 24229			if v_0_0.Op != OpConst8 {
 24230				break
 24231			}
 24232			t := v_0_0.Type
 24233			d := v_0_0.AuxInt
 24234			v_1 := v.Args[1]
 24235			if v_1.Op != OpConst8 {
 24236				break
 24237			}
 24238			if v_1.Type != t {
 24239				break
 24240			}
 24241			c := v_1.AuxInt
 24242			v.reset(OpEq8)
 24243			v0 := b.NewValue0(v.Pos, OpConst8, t)
 24244			v0.AuxInt = int64(int8(c - d))
 24245			v.AddArg(v0)
 24246			v.AddArg(x)
 24247			return true
 24248		}
 24249		// match: (Eq8 (Add8 x (Const8 <t> [d])) (Const8 <t> [c]))
 24250		// cond:
 24251		// result: (Eq8 (Const8 <t> [int64(int8(c-d))]) x)
 24252		for {
 24253			_ = v.Args[1]
 24254			v_0 := v.Args[0]
 24255			if v_0.Op != OpAdd8 {
 24256				break
 24257			}
 24258			_ = v_0.Args[1]
 24259			x := v_0.Args[0]
 24260			v_0_1 := v_0.Args[1]
 24261			if v_0_1.Op != OpConst8 {
 24262				break
 24263			}
 24264			t := v_0_1.Type
 24265			d := v_0_1.AuxInt
 24266			v_1 := v.Args[1]
 24267			if v_1.Op != OpConst8 {
 24268				break
 24269			}
 24270			if v_1.Type != t {
 24271				break
 24272			}
 24273			c := v_1.AuxInt
 24274			v.reset(OpEq8)
 24275			v0 := b.NewValue0(v.Pos, OpConst8, t)
 24276			v0.AuxInt = int64(int8(c - d))
 24277			v.AddArg(v0)
 24278			v.AddArg(x)
 24279			return true
 24280		}
 24281		// match: (Eq8 (Const8 [c]) (Const8 [d]))
 24282		// cond:
 24283		// result: (ConstBool [b2i(c == d)])
 24284		for {
 24285			_ = v.Args[1]
 24286			v_0 := v.Args[0]
 24287			if v_0.Op != OpConst8 {
 24288				break
 24289			}
 24290			c := v_0.AuxInt
 24291			v_1 := v.Args[1]
 24292			if v_1.Op != OpConst8 {
 24293				break
 24294			}
 24295			d := v_1.AuxInt
 24296			v.reset(OpConstBool)
 24297			v.AuxInt = b2i(c == d)
 24298			return true
 24299		}
 24300		// match: (Eq8 (Const8 [d]) (Const8 [c]))
 24301		// cond:
 24302		// result: (ConstBool [b2i(c == d)])
 24303		for {
 24304			_ = v.Args[1]
 24305			v_0 := v.Args[0]
 24306			if v_0.Op != OpConst8 {
 24307				break
 24308			}
 24309			d := v_0.AuxInt
 24310			v_1 := v.Args[1]
 24311			if v_1.Op != OpConst8 {
 24312				break
 24313			}
 24314			c := v_1.AuxInt
 24315			v.reset(OpConstBool)
 24316			v.AuxInt = b2i(c == d)
 24317			return true
 24318		}
 24319		// match: (Eq8 (Mod8u x (Const8 [c])) (Const8 [0]))
 24320		// cond: x.Op != OpConst8 && udivisibleOK(8,c) && !hasSmallRotate(config)
 24321		// result: (Eq32 (Mod32u <typ.UInt32> (ZeroExt8to32 <typ.UInt32> x) (Const32 <typ.UInt32> [c&0xff])) (Const32 <typ.UInt32> [0]))
 24322		for {
 24323			_ = v.Args[1]
 24324			v_0 := v.Args[0]
 24325			if v_0.Op != OpMod8u {
 24326				break
 24327			}
 24328			_ = v_0.Args[1]
 24329			x := v_0.Args[0]
 24330			v_0_1 := v_0.Args[1]
 24331			if v_0_1.Op != OpConst8 {
 24332				break
 24333			}
 24334			c := v_0_1.AuxInt
 24335			v_1 := v.Args[1]
 24336			if v_1.Op != OpConst8 {
 24337				break
 24338			}
 24339			if v_1.AuxInt != 0 {
 24340				break
 24341			}
 24342			if !(x.Op != OpConst8 && udivisibleOK(8, c) && !hasSmallRotate(config)) {
 24343				break
 24344			}
 24345			v.reset(OpEq32)
 24346			v0 := b.NewValue0(v.Pos, OpMod32u, typ.UInt32)
 24347			v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
 24348			v1.AddArg(x)
 24349			v0.AddArg(v1)
 24350			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 24351			v2.AuxInt = c & 0xff
 24352			v0.AddArg(v2)
 24353			v.AddArg(v0)
 24354			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 24355			v3.AuxInt = 0
 24356			v.AddArg(v3)
 24357			return true
 24358		}
 24359		// match: (Eq8 (Const8 [0]) (Mod8u x (Const8 [c])))
 24360		// cond: x.Op != OpConst8 && udivisibleOK(8,c) && !hasSmallRotate(config)
 24361		// result: (Eq32 (Mod32u <typ.UInt32> (ZeroExt8to32 <typ.UInt32> x) (Const32 <typ.UInt32> [c&0xff])) (Const32 <typ.UInt32> [0]))
 24362		for {
 24363			_ = v.Args[1]
 24364			v_0 := v.Args[0]
 24365			if v_0.Op != OpConst8 {
 24366				break
 24367			}
 24368			if v_0.AuxInt != 0 {
 24369				break
 24370			}
 24371			v_1 := v.Args[1]
 24372			if v_1.Op != OpMod8u {
 24373				break
 24374			}
 24375			_ = v_1.Args[1]
 24376			x := v_1.Args[0]
 24377			v_1_1 := v_1.Args[1]
 24378			if v_1_1.Op != OpConst8 {
 24379				break
 24380			}
 24381			c := v_1_1.AuxInt
 24382			if !(x.Op != OpConst8 && udivisibleOK(8, c) && !hasSmallRotate(config)) {
 24383				break
 24384			}
 24385			v.reset(OpEq32)
 24386			v0 := b.NewValue0(v.Pos, OpMod32u, typ.UInt32)
 24387			v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
 24388			v1.AddArg(x)
 24389			v0.AddArg(v1)
 24390			v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 24391			v2.AuxInt = c & 0xff
 24392			v0.AddArg(v2)
 24393			v.AddArg(v0)
 24394			v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
 24395			v3.AuxInt = 0
 24396			v.AddArg(v3)
 24397			return true
 24398		}
 24399		// match: (Eq8 (Mod8 x (Const8 [c])) (Const8 [0]))
 24400		// cond: x.Op != OpConst8 && sdivisibleOK(8,c) && !hasSmallRotate(config)
 24401		// result: (Eq32 (Mod32 <typ.Int32> (SignExt8to32 <typ.Int32> x) (Const32 <typ.Int32> [c])) (Const32 <typ.Int32> [0]))
 24402		for {
 24403			_ = v.Args[1]
 24404			v_0 := v.Args[0]
 24405			if v_0.Op != OpMod8 {
 24406				break
 24407			}
 24408			_ = v_0.Args[1]
 24409			x := v_0.Args[0]
 24410			v_0_1 := v_0.Args[1]
 24411			if v_0_1.Op != OpConst8 {
 24412				break
 24413			}
 24414			c := v_0_1.AuxInt
 24415			v_1 := v.Args[1]
 24416			if v_1.Op != OpConst8 {
 24417				break
 24418			}
 24419			if v_1.AuxInt != 0 {
 24420				break
 24421			}
 24422			if !(x.Op != OpConst8 && sdivisibleOK(8, c) && !hasSmallRotate(config)) {
 24423				break
 24424			}
 24425			v.reset(OpEq32)
 24426			v0 := b.NewValue0(v.Pos, OpMod32, typ.Int32)
 24427			v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
 24428			v1.AddArg(x)
 24429			v0.AddArg(v1)
 24430			v2 := b.NewValue0(v.Pos, OpConst32, typ.Int32)
 24431			v2.AuxInt = c
 24432			v0.AddArg(v2)
 24433			v.AddArg(v0)
 24434			v3 := b.NewValue0(v.Pos, OpConst32, typ.Int32)
 24435			v3.AuxInt = 0
 24436			v.AddArg(v3)
 24437			return true
 24438		}
 24439		return false
 24440	}
 24441	func rewriteValuegeneric_OpEq8_10(v *Value) bool {
 24442		b := v.Block
 24443		config := b.Func.Config
 24444		typ := &b.Func.Config.Types
 24445		// match: (Eq8 (Const8 [0]) (Mod8 x (Const8 [c])))
 24446		// cond: x.Op != OpConst8 && sdivisibleOK(8,c) && !hasSmallRotate(config)
 24447		// result: (Eq32 (Mod32 <typ.Int32> (SignExt8to32 <typ.Int32> x) (Const32 <typ.Int32> [c])) (Const32 <typ.Int32> [0]))
 24448		for {
 24449			_ = v.Args[1]
 24450			v_0 := v.Args[0]
 24451			if v_0.Op != OpConst8 {
 24452				break
 24453			}
 24454			if v_0.AuxInt != 0 {
 24455				break
 24456			}
 24457			v_1 := v.Args[1]
 24458			if v_1.Op != OpMod8 {
 24459				break
 24460			}
 24461			_ = v_1.Args[1]
 24462			x := v_1.Args[0]
 24463			v_1_1 := v_1.Args[1]
 24464			if v_1_1.Op != OpConst8 {
 24465				break
 24466			}
 24467			c := v_1_1.AuxInt
 24468			if !(x.Op != OpConst8 && sdivisibleOK(8, c) && !hasSmallRotate(config)) {
 24469				break
 24470			}
 24471			v.reset(OpEq32)
 24472			v0 := b.NewValue0(v.Pos, OpMod32, typ.Int32)
 24473			v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
 24474			v1.AddArg(x)
 24475			v0.AddArg(v1)
 24476			v2 := b.NewValue0(v.Pos, OpConst32, typ.Int32)
 24477			v2.AuxInt = c
 24478			v0.AddArg(v2)
 24479			v.AddArg(v0)
 24480			v3 := b.NewValue0(v.Pos, OpConst32, typ.Int32)
 24481			v3.AuxInt = 0
 24482			v.AddArg(v3)
 24483			return true
 24484		}
 24485		// match: (Eq8 x (Mul8 (Const8 [c]) (Trunc32to8 (Rsh32Ux64 mul:(Mul32 (Const32 [m]) (ZeroExt8to32 x)) (Const64 [s])))))
 24486		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<8+umagic(8,c).m) && s == 8+umagic(8,c).s && x.Op != OpConst8 && udivisibleOK(8,c)
 24487		// result: (Leq8U (RotateLeft8 <typ.UInt8> (Mul8 <typ.UInt8> (Const8 <typ.UInt8> [int64(int8(udivisible(8,c).m))]) x) (Const8 <typ.UInt8> [int64(8-udivisible(8,c).k)]) ) (Const8 <typ.UInt8> [int64(int8(udivisible(8,c).max))]) )
 24488		for {
 24489			_ = v.Args[1]
 24490			x := v.Args[0]
 24491			v_1 := v.Args[1]
 24492			if v_1.Op != OpMul8 {
 24493				break
 24494			}
 24495			_ = v_1.Args[1]
 24496			v_1_0 := v_1.Args[0]
 24497			if v_1_0.Op != OpConst8 {
 24498				break
 24499			}
 24500			c := v_1_0.AuxInt
 24501			v_1_1 := v_1.Args[1]
 24502			if v_1_1.Op != OpTrunc32to8 {
 24503				break
 24504			}
 24505			v_1_1_0 := v_1_1.Args[0]
 24506			if v_1_1_0.Op != OpRsh32Ux64 {
 24507				break
 24508			}
 24509			_ = v_1_1_0.Args[1]
 24510			mul := v_1_1_0.Args[0]
 24511			if mul.Op != OpMul32 {
 24512				break
 24513			}
 24514			_ = mul.Args[1]
 24515			mul_0 := mul.Args[0]
 24516			if mul_0.Op != OpConst32 {
 24517				break
 24518			}
 24519			m := mul_0.AuxInt
 24520			mul_1 := mul.Args[1]
 24521			if mul_1.Op != OpZeroExt8to32 {
 24522				break
 24523			}
 24524			if x != mul_1.Args[0] {
 24525				break
 24526			}
 24527			v_1_1_0_1 := v_1_1_0.Args[1]
 24528			if v_1_1_0_1.Op != OpConst64 {
 24529				break
 24530			}
 24531			s := v_1_1_0_1.AuxInt
 24532			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<8+umagic(8, c).m) && s == 8+umagic(8, c).s && x.Op != OpConst8 && udivisibleOK(8, c)) {
 24533				break
 24534			}
 24535			v.reset(OpLeq8U)
 24536			v0 := b.NewValue0(v.Pos, OpRotateLeft8, typ.UInt8)
 24537			v1 := b.NewValue0(v.Pos, OpMul8, typ.UInt8)
 24538			v2 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 24539			v2.AuxInt = int64(int8(udivisible(8, c).m))
 24540			v1.AddArg(v2)
 24541			v1.AddArg(x)
 24542			v0.AddArg(v1)
 24543			v3 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 24544			v3.AuxInt = int64(8 - udivisible(8, c).k)
 24545			v0.AddArg(v3)
 24546			v.AddArg(v0)
 24547			v4 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 24548			v4.AuxInt = int64(int8(udivisible(8, c).max))
 24549			v.AddArg(v4)
 24550			return true
 24551		}
 24552		// match: (Eq8 x (Mul8 (Const8 [c]) (Trunc32to8 (Rsh32Ux64 mul:(Mul32 (ZeroExt8to32 x) (Const32 [m])) (Const64 [s])))))
 24553		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<8+umagic(8,c).m) && s == 8+umagic(8,c).s && x.Op != OpConst8 && udivisibleOK(8,c)
 24554		// result: (Leq8U (RotateLeft8 <typ.UInt8> (Mul8 <typ.UInt8> (Const8 <typ.UInt8> [int64(int8(udivisible(8,c).m))]) x) (Const8 <typ.UInt8> [int64(8-udivisible(8,c).k)]) ) (Const8 <typ.UInt8> [int64(int8(udivisible(8,c).max))]) )
 24555		for {
 24556			_ = v.Args[1]
 24557			x := v.Args[0]
 24558			v_1 := v.Args[1]
 24559			if v_1.Op != OpMul8 {
 24560				break
 24561			}
 24562			_ = v_1.Args[1]
 24563			v_1_0 := v_1.Args[0]
 24564			if v_1_0.Op != OpConst8 {
 24565				break
 24566			}
 24567			c := v_1_0.AuxInt
 24568			v_1_1 := v_1.Args[1]
 24569			if v_1_1.Op != OpTrunc32to8 {
 24570				break
 24571			}
 24572			v_1_1_0 := v_1_1.Args[0]
 24573			if v_1_1_0.Op != OpRsh32Ux64 {
 24574				break
 24575			}
 24576			_ = v_1_1_0.Args[1]
 24577			mul := v_1_1_0.Args[0]
 24578			if mul.Op != OpMul32 {
 24579				break
 24580			}
 24581			_ = mul.Args[1]
 24582			mul_0 := mul.Args[0]
 24583			if mul_0.Op != OpZeroExt8to32 {
 24584				break
 24585			}
 24586			if x != mul_0.Args[0] {
 24587				break
 24588			}
 24589			mul_1 := mul.Args[1]
 24590			if mul_1.Op != OpConst32 {
 24591				break
 24592			}
 24593			m := mul_1.AuxInt
 24594			v_1_1_0_1 := v_1_1_0.Args[1]
 24595			if v_1_1_0_1.Op != OpConst64 {
 24596				break
 24597			}
 24598			s := v_1_1_0_1.AuxInt
 24599			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<8+umagic(8, c).m) && s == 8+umagic(8, c).s && x.Op != OpConst8 && udivisibleOK(8, c)) {
 24600				break
 24601			}
 24602			v.reset(OpLeq8U)
 24603			v0 := b.NewValue0(v.Pos, OpRotateLeft8, typ.UInt8)
 24604			v1 := b.NewValue0(v.Pos, OpMul8, typ.UInt8)
 24605			v2 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 24606			v2.AuxInt = int64(int8(udivisible(8, c).m))
 24607			v1.AddArg(v2)
 24608			v1.AddArg(x)
 24609			v0.AddArg(v1)
 24610			v3 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 24611			v3.AuxInt = int64(8 - udivisible(8, c).k)
 24612			v0.AddArg(v3)
 24613			v.AddArg(v0)
 24614			v4 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 24615			v4.AuxInt = int64(int8(udivisible(8, c).max))
 24616			v.AddArg(v4)
 24617			return true
 24618		}
 24619		// match: (Eq8 x (Mul8 (Trunc32to8 (Rsh32Ux64 mul:(Mul32 (Const32 [m]) (ZeroExt8to32 x)) (Const64 [s]))) (Const8 [c])))
 24620		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<8+umagic(8,c).m) && s == 8+umagic(8,c).s && x.Op != OpConst8 && udivisibleOK(8,c)
 24621		// result: (Leq8U (RotateLeft8 <typ.UInt8> (Mul8 <typ.UInt8> (Const8 <typ.UInt8> [int64(int8(udivisible(8,c).m))]) x) (Const8 <typ.UInt8> [int64(8-udivisible(8,c).k)]) ) (Const8 <typ.UInt8> [int64(int8(udivisible(8,c).max))]) )
 24622		for {
 24623			_ = v.Args[1]
 24624			x := v.Args[0]
 24625			v_1 := v.Args[1]
 24626			if v_1.Op != OpMul8 {
 24627				break
 24628			}
 24629			_ = v_1.Args[1]
 24630			v_1_0 := v_1.Args[0]
 24631			if v_1_0.Op != OpTrunc32to8 {
 24632				break
 24633			}
 24634			v_1_0_0 := v_1_0.Args[0]
 24635			if v_1_0_0.Op != OpRsh32Ux64 {
 24636				break
 24637			}
 24638			_ = v_1_0_0.Args[1]
 24639			mul := v_1_0_0.Args[0]
 24640			if mul.Op != OpMul32 {
 24641				break
 24642			}
 24643			_ = mul.Args[1]
 24644			mul_0 := mul.Args[0]
 24645			if mul_0.Op != OpConst32 {
 24646				break
 24647			}
 24648			m := mul_0.AuxInt
 24649			mul_1 := mul.Args[1]
 24650			if mul_1.Op != OpZeroExt8to32 {
 24651				break
 24652			}
 24653			if x != mul_1.Args[0] {
 24654				break
 24655			}
 24656			v_1_0_0_1 := v_1_0_0.Args[1]
 24657			if v_1_0_0_1.Op != OpConst64 {
 24658				break
 24659			}
 24660			s := v_1_0_0_1.AuxInt
 24661			v_1_1 := v_1.Args[1]
 24662			if v_1_1.Op != OpConst8 {
 24663				break
 24664			}
 24665			c := v_1_1.AuxInt
 24666			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<8+umagic(8, c).m) && s == 8+umagic(8, c).s && x.Op != OpConst8 && udivisibleOK(8, c)) {
 24667				break
 24668			}
 24669			v.reset(OpLeq8U)
 24670			v0 := b.NewValue0(v.Pos, OpRotateLeft8, typ.UInt8)
 24671			v1 := b.NewValue0(v.Pos, OpMul8, typ.UInt8)
 24672			v2 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 24673			v2.AuxInt = int64(int8(udivisible(8, c).m))
 24674			v1.AddArg(v2)
 24675			v1.AddArg(x)
 24676			v0.AddArg(v1)
 24677			v3 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 24678			v3.AuxInt = int64(8 - udivisible(8, c).k)
 24679			v0.AddArg(v3)
 24680			v.AddArg(v0)
 24681			v4 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 24682			v4.AuxInt = int64(int8(udivisible(8, c).max))
 24683			v.AddArg(v4)
 24684			return true
 24685		}
 24686		// match: (Eq8 x (Mul8 (Trunc32to8 (Rsh32Ux64 mul:(Mul32 (ZeroExt8to32 x) (Const32 [m])) (Const64 [s]))) (Const8 [c])))
 24687		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<8+umagic(8,c).m) && s == 8+umagic(8,c).s && x.Op != OpConst8 && udivisibleOK(8,c)
 24688		// result: (Leq8U (RotateLeft8 <typ.UInt8> (Mul8 <typ.UInt8> (Const8 <typ.UInt8> [int64(int8(udivisible(8,c).m))]) x) (Const8 <typ.UInt8> [int64(8-udivisible(8,c).k)]) ) (Const8 <typ.UInt8> [int64(int8(udivisible(8,c).max))]) )
 24689		for {
 24690			_ = v.Args[1]
 24691			x := v.Args[0]
 24692			v_1 := v.Args[1]
 24693			if v_1.Op != OpMul8 {
 24694				break
 24695			}
 24696			_ = v_1.Args[1]
 24697			v_1_0 := v_1.Args[0]
 24698			if v_1_0.Op != OpTrunc32to8 {
 24699				break
 24700			}
 24701			v_1_0_0 := v_1_0.Args[0]
 24702			if v_1_0_0.Op != OpRsh32Ux64 {
 24703				break
 24704			}
 24705			_ = v_1_0_0.Args[1]
 24706			mul := v_1_0_0.Args[0]
 24707			if mul.Op != OpMul32 {
 24708				break
 24709			}
 24710			_ = mul.Args[1]
 24711			mul_0 := mul.Args[0]
 24712			if mul_0.Op != OpZeroExt8to32 {
 24713				break
 24714			}
 24715			if x != mul_0.Args[0] {
 24716				break
 24717			}
 24718			mul_1 := mul.Args[1]
 24719			if mul_1.Op != OpConst32 {
 24720				break
 24721			}
 24722			m := mul_1.AuxInt
 24723			v_1_0_0_1 := v_1_0_0.Args[1]
 24724			if v_1_0_0_1.Op != OpConst64 {
 24725				break
 24726			}
 24727			s := v_1_0_0_1.AuxInt
 24728			v_1_1 := v_1.Args[1]
 24729			if v_1_1.Op != OpConst8 {
 24730				break
 24731			}
 24732			c := v_1_1.AuxInt
 24733			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<8+umagic(8, c).m) && s == 8+umagic(8, c).s && x.Op != OpConst8 && udivisibleOK(8, c)) {
 24734				break
 24735			}
 24736			v.reset(OpLeq8U)
 24737			v0 := b.NewValue0(v.Pos, OpRotateLeft8, typ.UInt8)
 24738			v1 := b.NewValue0(v.Pos, OpMul8, typ.UInt8)
 24739			v2 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 24740			v2.AuxInt = int64(int8(udivisible(8, c).m))
 24741			v1.AddArg(v2)
 24742			v1.AddArg(x)
 24743			v0.AddArg(v1)
 24744			v3 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 24745			v3.AuxInt = int64(8 - udivisible(8, c).k)
 24746			v0.AddArg(v3)
 24747			v.AddArg(v0)
 24748			v4 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 24749			v4.AuxInt = int64(int8(udivisible(8, c).max))
 24750			v.AddArg(v4)
 24751			return true
 24752		}
 24753		// match: (Eq8 (Mul8 (Const8 [c]) (Trunc32to8 (Rsh32Ux64 mul:(Mul32 (Const32 [m]) (ZeroExt8to32 x)) (Const64 [s])))) x)
 24754		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<8+umagic(8,c).m) && s == 8+umagic(8,c).s && x.Op != OpConst8 && udivisibleOK(8,c)
 24755		// result: (Leq8U (RotateLeft8 <typ.UInt8> (Mul8 <typ.UInt8> (Const8 <typ.UInt8> [int64(int8(udivisible(8,c).m))]) x) (Const8 <typ.UInt8> [int64(8-udivisible(8,c).k)]) ) (Const8 <typ.UInt8> [int64(int8(udivisible(8,c).max))]) )
 24756		for {
 24757			x := v.Args[1]
 24758			v_0 := v.Args[0]
 24759			if v_0.Op != OpMul8 {
 24760				break
 24761			}
 24762			_ = v_0.Args[1]
 24763			v_0_0 := v_0.Args[0]
 24764			if v_0_0.Op != OpConst8 {
 24765				break
 24766			}
 24767			c := v_0_0.AuxInt
 24768			v_0_1 := v_0.Args[1]
 24769			if v_0_1.Op != OpTrunc32to8 {
 24770				break
 24771			}
 24772			v_0_1_0 := v_0_1.Args[0]
 24773			if v_0_1_0.Op != OpRsh32Ux64 {
 24774				break
 24775			}
 24776			_ = v_0_1_0.Args[1]
 24777			mul := v_0_1_0.Args[0]
 24778			if mul.Op != OpMul32 {
 24779				break
 24780			}
 24781			_ = mul.Args[1]
 24782			mul_0 := mul.Args[0]
 24783			if mul_0.Op != OpConst32 {
 24784				break
 24785			}
 24786			m := mul_0.AuxInt
 24787			mul_1 := mul.Args[1]
 24788			if mul_1.Op != OpZeroExt8to32 {
 24789				break
 24790			}
 24791			if x != mul_1.Args[0] {
 24792				break
 24793			}
 24794			v_0_1_0_1 := v_0_1_0.Args[1]
 24795			if v_0_1_0_1.Op != OpConst64 {
 24796				break
 24797			}
 24798			s := v_0_1_0_1.AuxInt
 24799			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<8+umagic(8, c).m) && s == 8+umagic(8, c).s && x.Op != OpConst8 && udivisibleOK(8, c)) {
 24800				break
 24801			}
 24802			v.reset(OpLeq8U)
 24803			v0 := b.NewValue0(v.Pos, OpRotateLeft8, typ.UInt8)
 24804			v1 := b.NewValue0(v.Pos, OpMul8, typ.UInt8)
 24805			v2 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 24806			v2.AuxInt = int64(int8(udivisible(8, c).m))
 24807			v1.AddArg(v2)
 24808			v1.AddArg(x)
 24809			v0.AddArg(v1)
 24810			v3 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 24811			v3.AuxInt = int64(8 - udivisible(8, c).k)
 24812			v0.AddArg(v3)
 24813			v.AddArg(v0)
 24814			v4 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 24815			v4.AuxInt = int64(int8(udivisible(8, c).max))
 24816			v.AddArg(v4)
 24817			return true
 24818		}
 24819		// match: (Eq8 (Mul8 (Const8 [c]) (Trunc32to8 (Rsh32Ux64 mul:(Mul32 (ZeroExt8to32 x) (Const32 [m])) (Const64 [s])))) x)
 24820		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<8+umagic(8,c).m) && s == 8+umagic(8,c).s && x.Op != OpConst8 && udivisibleOK(8,c)
 24821		// result: (Leq8U (RotateLeft8 <typ.UInt8> (Mul8 <typ.UInt8> (Const8 <typ.UInt8> [int64(int8(udivisible(8,c).m))]) x) (Const8 <typ.UInt8> [int64(8-udivisible(8,c).k)]) ) (Const8 <typ.UInt8> [int64(int8(udivisible(8,c).max))]) )
 24822		for {
 24823			x := v.Args[1]
 24824			v_0 := v.Args[0]
 24825			if v_0.Op != OpMul8 {
 24826				break
 24827			}
 24828			_ = v_0.Args[1]
 24829			v_0_0 := v_0.Args[0]
 24830			if v_0_0.Op != OpConst8 {
 24831				break
 24832			}
 24833			c := v_0_0.AuxInt
 24834			v_0_1 := v_0.Args[1]
 24835			if v_0_1.Op != OpTrunc32to8 {
 24836				break
 24837			}
 24838			v_0_1_0 := v_0_1.Args[0]
 24839			if v_0_1_0.Op != OpRsh32Ux64 {
 24840				break
 24841			}
 24842			_ = v_0_1_0.Args[1]
 24843			mul := v_0_1_0.Args[0]
 24844			if mul.Op != OpMul32 {
 24845				break
 24846			}
 24847			_ = mul.Args[1]
 24848			mul_0 := mul.Args[0]
 24849			if mul_0.Op != OpZeroExt8to32 {
 24850				break
 24851			}
 24852			if x != mul_0.Args[0] {
 24853				break
 24854			}
 24855			mul_1 := mul.Args[1]
 24856			if mul_1.Op != OpConst32 {
 24857				break
 24858			}
 24859			m := mul_1.AuxInt
 24860			v_0_1_0_1 := v_0_1_0.Args[1]
 24861			if v_0_1_0_1.Op != OpConst64 {
 24862				break
 24863			}
 24864			s := v_0_1_0_1.AuxInt
 24865			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<8+umagic(8, c).m) && s == 8+umagic(8, c).s && x.Op != OpConst8 && udivisibleOK(8, c)) {
 24866				break
 24867			}
 24868			v.reset(OpLeq8U)
 24869			v0 := b.NewValue0(v.Pos, OpRotateLeft8, typ.UInt8)
 24870			v1 := b.NewValue0(v.Pos, OpMul8, typ.UInt8)
 24871			v2 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 24872			v2.AuxInt = int64(int8(udivisible(8, c).m))
 24873			v1.AddArg(v2)
 24874			v1.AddArg(x)
 24875			v0.AddArg(v1)
 24876			v3 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 24877			v3.AuxInt = int64(8 - udivisible(8, c).k)
 24878			v0.AddArg(v3)
 24879			v.AddArg(v0)
 24880			v4 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 24881			v4.AuxInt = int64(int8(udivisible(8, c).max))
 24882			v.AddArg(v4)
 24883			return true
 24884		}
 24885		// match: (Eq8 (Mul8 (Trunc32to8 (Rsh32Ux64 mul:(Mul32 (Const32 [m]) (ZeroExt8to32 x)) (Const64 [s]))) (Const8 [c])) x)
 24886		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<8+umagic(8,c).m) && s == 8+umagic(8,c).s && x.Op != OpConst8 && udivisibleOK(8,c)
 24887		// result: (Leq8U (RotateLeft8 <typ.UInt8> (Mul8 <typ.UInt8> (Const8 <typ.UInt8> [int64(int8(udivisible(8,c).m))]) x) (Const8 <typ.UInt8> [int64(8-udivisible(8,c).k)]) ) (Const8 <typ.UInt8> [int64(int8(udivisible(8,c).max))]) )
 24888		for {
 24889			x := v.Args[1]
 24890			v_0 := v.Args[0]
 24891			if v_0.Op != OpMul8 {
 24892				break
 24893			}
 24894			_ = v_0.Args[1]
 24895			v_0_0 := v_0.Args[0]
 24896			if v_0_0.Op != OpTrunc32to8 {
 24897				break
 24898			}
 24899			v_0_0_0 := v_0_0.Args[0]
 24900			if v_0_0_0.Op != OpRsh32Ux64 {
 24901				break
 24902			}
 24903			_ = v_0_0_0.Args[1]
 24904			mul := v_0_0_0.Args[0]
 24905			if mul.Op != OpMul32 {
 24906				break
 24907			}
 24908			_ = mul.Args[1]
 24909			mul_0 := mul.Args[0]
 24910			if mul_0.Op != OpConst32 {
 24911				break
 24912			}
 24913			m := mul_0.AuxInt
 24914			mul_1 := mul.Args[1]
 24915			if mul_1.Op != OpZeroExt8to32 {
 24916				break
 24917			}
 24918			if x != mul_1.Args[0] {
 24919				break
 24920			}
 24921			v_0_0_0_1 := v_0_0_0.Args[1]
 24922			if v_0_0_0_1.Op != OpConst64 {
 24923				break
 24924			}
 24925			s := v_0_0_0_1.AuxInt
 24926			v_0_1 := v_0.Args[1]
 24927			if v_0_1.Op != OpConst8 {
 24928				break
 24929			}
 24930			c := v_0_1.AuxInt
 24931			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<8+umagic(8, c).m) && s == 8+umagic(8, c).s && x.Op != OpConst8 && udivisibleOK(8, c)) {
 24932				break
 24933			}
 24934			v.reset(OpLeq8U)
 24935			v0 := b.NewValue0(v.Pos, OpRotateLeft8, typ.UInt8)
 24936			v1 := b.NewValue0(v.Pos, OpMul8, typ.UInt8)
 24937			v2 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 24938			v2.AuxInt = int64(int8(udivisible(8, c).m))
 24939			v1.AddArg(v2)
 24940			v1.AddArg(x)
 24941			v0.AddArg(v1)
 24942			v3 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 24943			v3.AuxInt = int64(8 - udivisible(8, c).k)
 24944			v0.AddArg(v3)
 24945			v.AddArg(v0)
 24946			v4 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 24947			v4.AuxInt = int64(int8(udivisible(8, c).max))
 24948			v.AddArg(v4)
 24949			return true
 24950		}
 24951		// match: (Eq8 (Mul8 (Trunc32to8 (Rsh32Ux64 mul:(Mul32 (ZeroExt8to32 x) (Const32 [m])) (Const64 [s]))) (Const8 [c])) x)
 24952		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<8+umagic(8,c).m) && s == 8+umagic(8,c).s && x.Op != OpConst8 && udivisibleOK(8,c)
 24953		// result: (Leq8U (RotateLeft8 <typ.UInt8> (Mul8 <typ.UInt8> (Const8 <typ.UInt8> [int64(int8(udivisible(8,c).m))]) x) (Const8 <typ.UInt8> [int64(8-udivisible(8,c).k)]) ) (Const8 <typ.UInt8> [int64(int8(udivisible(8,c).max))]) )
 24954		for {
 24955			x := v.Args[1]
 24956			v_0 := v.Args[0]
 24957			if v_0.Op != OpMul8 {
 24958				break
 24959			}
 24960			_ = v_0.Args[1]
 24961			v_0_0 := v_0.Args[0]
 24962			if v_0_0.Op != OpTrunc32to8 {
 24963				break
 24964			}
 24965			v_0_0_0 := v_0_0.Args[0]
 24966			if v_0_0_0.Op != OpRsh32Ux64 {
 24967				break
 24968			}
 24969			_ = v_0_0_0.Args[1]
 24970			mul := v_0_0_0.Args[0]
 24971			if mul.Op != OpMul32 {
 24972				break
 24973			}
 24974			_ = mul.Args[1]
 24975			mul_0 := mul.Args[0]
 24976			if mul_0.Op != OpZeroExt8to32 {
 24977				break
 24978			}
 24979			if x != mul_0.Args[0] {
 24980				break
 24981			}
 24982			mul_1 := mul.Args[1]
 24983			if mul_1.Op != OpConst32 {
 24984				break
 24985			}
 24986			m := mul_1.AuxInt
 24987			v_0_0_0_1 := v_0_0_0.Args[1]
 24988			if v_0_0_0_1.Op != OpConst64 {
 24989				break
 24990			}
 24991			s := v_0_0_0_1.AuxInt
 24992			v_0_1 := v_0.Args[1]
 24993			if v_0_1.Op != OpConst8 {
 24994				break
 24995			}
 24996			c := v_0_1.AuxInt
 24997			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<8+umagic(8, c).m) && s == 8+umagic(8, c).s && x.Op != OpConst8 && udivisibleOK(8, c)) {
 24998				break
 24999			}
 25000			v.reset(OpLeq8U)
 25001			v0 := b.NewValue0(v.Pos, OpRotateLeft8, typ.UInt8)
 25002			v1 := b.NewValue0(v.Pos, OpMul8, typ.UInt8)
 25003			v2 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 25004			v2.AuxInt = int64(int8(udivisible(8, c).m))
 25005			v1.AddArg(v2)
 25006			v1.AddArg(x)
 25007			v0.AddArg(v1)
 25008			v3 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 25009			v3.AuxInt = int64(8 - udivisible(8, c).k)
 25010			v0.AddArg(v3)
 25011			v.AddArg(v0)
 25012			v4 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 25013			v4.AuxInt = int64(int8(udivisible(8, c).max))
 25014			v.AddArg(v4)
 25015			return true
 25016		}
 25017		// match: (Eq8 x (Mul8 (Const8 [c]) (Sub8 (Rsh32x64 mul:(Mul32 (Const32 [m]) (SignExt8to32 x)) (Const64 [s])) (Rsh32x64 (SignExt8to32 x) (Const64 [31])))))
 25018		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(8,c).m) && s == 8+smagic(8,c).s && x.Op != OpConst8 && sdivisibleOK(8,c)
 25019		// result: (Leq8U (RotateLeft8 <typ.UInt8> (Add8 <typ.UInt8> (Mul8 <typ.UInt8> (Const8 <typ.UInt8> [int64(int8(sdivisible(8,c).m))]) x) (Const8 <typ.UInt8> [int64(int8(sdivisible(8,c).a))]) ) (Const8 <typ.UInt8> [int64(8-sdivisible(8,c).k)]) ) (Const8 <typ.UInt8> [int64(int8(sdivisible(8,c).max))]) )
 25020		for {
 25021			_ = v.Args[1]
 25022			x := v.Args[0]
 25023			v_1 := v.Args[1]
 25024			if v_1.Op != OpMul8 {
 25025				break
 25026			}
 25027			_ = v_1.Args[1]
 25028			v_1_0 := v_1.Args[0]
 25029			if v_1_0.Op != OpConst8 {
 25030				break
 25031			}
 25032			c := v_1_0.AuxInt
 25033			v_1_1 := v_1.Args[1]
 25034			if v_1_1.Op != OpSub8 {
 25035				break
 25036			}
 25037			_ = v_1_1.Args[1]
 25038			v_1_1_0 := v_1_1.Args[0]
 25039			if v_1_1_0.Op != OpRsh32x64 {
 25040				break
 25041			}
 25042			_ = v_1_1_0.Args[1]
 25043			mul := v_1_1_0.Args[0]
 25044			if mul.Op != OpMul32 {
 25045				break
 25046			}
 25047			_ = mul.Args[1]
 25048			mul_0 := mul.Args[0]
 25049			if mul_0.Op != OpConst32 {
 25050				break
 25051			}
 25052			m := mul_0.AuxInt
 25053			mul_1 := mul.Args[1]
 25054			if mul_1.Op != OpSignExt8to32 {
 25055				break
 25056			}
 25057			if x != mul_1.Args[0] {
 25058				break
 25059			}
 25060			v_1_1_0_1 := v_1_1_0.Args[1]
 25061			if v_1_1_0_1.Op != OpConst64 {
 25062				break
 25063			}
 25064			s := v_1_1_0_1.AuxInt
 25065			v_1_1_1 := v_1_1.Args[1]
 25066			if v_1_1_1.Op != OpRsh32x64 {
 25067				break
 25068			}
 25069			_ = v_1_1_1.Args[1]
 25070			v_1_1_1_0 := v_1_1_1.Args[0]
 25071			if v_1_1_1_0.Op != OpSignExt8to32 {
 25072				break
 25073			}
 25074			if x != v_1_1_1_0.Args[0] {
 25075				break
 25076			}
 25077			v_1_1_1_1 := v_1_1_1.Args[1]
 25078			if v_1_1_1_1.Op != OpConst64 {
 25079				break
 25080			}
 25081			if v_1_1_1_1.AuxInt != 31 {
 25082				break
 25083			}
 25084			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(8, c).m) && s == 8+smagic(8, c).s && x.Op != OpConst8 && sdivisibleOK(8, c)) {
 25085				break
 25086			}
 25087			v.reset(OpLeq8U)
 25088			v0 := b.NewValue0(v.Pos, OpRotateLeft8, typ.UInt8)
 25089			v1 := b.NewValue0(v.Pos, OpAdd8, typ.UInt8)
 25090			v2 := b.NewValue0(v.Pos, OpMul8, typ.UInt8)
 25091			v3 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 25092			v3.AuxInt = int64(int8(sdivisible(8, c).m))
 25093			v2.AddArg(v3)
 25094			v2.AddArg(x)
 25095			v1.AddArg(v2)
 25096			v4 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 25097			v4.AuxInt = int64(int8(sdivisible(8, c).a))
 25098			v1.AddArg(v4)
 25099			v0.AddArg(v1)
 25100			v5 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 25101			v5.AuxInt = int64(8 - sdivisible(8, c).k)
 25102			v0.AddArg(v5)
 25103			v.AddArg(v0)
 25104			v6 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 25105			v6.AuxInt = int64(int8(sdivisible(8, c).max))
 25106			v.AddArg(v6)
 25107			return true
 25108		}
 25109		return false
 25110	}
 25111	func rewriteValuegeneric_OpEq8_20(v *Value) bool {
 25112		b := v.Block
 25113		typ := &b.Func.Config.Types
 25114		// match: (Eq8 x (Mul8 (Const8 [c]) (Sub8 (Rsh32x64 mul:(Mul32 (SignExt8to32 x) (Const32 [m])) (Const64 [s])) (Rsh32x64 (SignExt8to32 x) (Const64 [31])))))
 25115		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(8,c).m) && s == 8+smagic(8,c).s && x.Op != OpConst8 && sdivisibleOK(8,c)
 25116		// result: (Leq8U (RotateLeft8 <typ.UInt8> (Add8 <typ.UInt8> (Mul8 <typ.UInt8> (Const8 <typ.UInt8> [int64(int8(sdivisible(8,c).m))]) x) (Const8 <typ.UInt8> [int64(int8(sdivisible(8,c).a))]) ) (Const8 <typ.UInt8> [int64(8-sdivisible(8,c).k)]) ) (Const8 <typ.UInt8> [int64(int8(sdivisible(8,c).max))]) )
 25117		for {
 25118			_ = v.Args[1]
 25119			x := v.Args[0]
 25120			v_1 := v.Args[1]
 25121			if v_1.Op != OpMul8 {
 25122				break
 25123			}
 25124			_ = v_1.Args[1]
 25125			v_1_0 := v_1.Args[0]
 25126			if v_1_0.Op != OpConst8 {
 25127				break
 25128			}
 25129			c := v_1_0.AuxInt
 25130			v_1_1 := v_1.Args[1]
 25131			if v_1_1.Op != OpSub8 {
 25132				break
 25133			}
 25134			_ = v_1_1.Args[1]
 25135			v_1_1_0 := v_1_1.Args[0]
 25136			if v_1_1_0.Op != OpRsh32x64 {
 25137				break
 25138			}
 25139			_ = v_1_1_0.Args[1]
 25140			mul := v_1_1_0.Args[0]
 25141			if mul.Op != OpMul32 {
 25142				break
 25143			}
 25144			_ = mul.Args[1]
 25145			mul_0 := mul.Args[0]
 25146			if mul_0.Op != OpSignExt8to32 {
 25147				break
 25148			}
 25149			if x != mul_0.Args[0] {
 25150				break
 25151			}
 25152			mul_1 := mul.Args[1]
 25153			if mul_1.Op != OpConst32 {
 25154				break
 25155			}
 25156			m := mul_1.AuxInt
 25157			v_1_1_0_1 := v_1_1_0.Args[1]
 25158			if v_1_1_0_1.Op != OpConst64 {
 25159				break
 25160			}
 25161			s := v_1_1_0_1.AuxInt
 25162			v_1_1_1 := v_1_1.Args[1]
 25163			if v_1_1_1.Op != OpRsh32x64 {
 25164				break
 25165			}
 25166			_ = v_1_1_1.Args[1]
 25167			v_1_1_1_0 := v_1_1_1.Args[0]
 25168			if v_1_1_1_0.Op != OpSignExt8to32 {
 25169				break
 25170			}
 25171			if x != v_1_1_1_0.Args[0] {
 25172				break
 25173			}
 25174			v_1_1_1_1 := v_1_1_1.Args[1]
 25175			if v_1_1_1_1.Op != OpConst64 {
 25176				break
 25177			}
 25178			if v_1_1_1_1.AuxInt != 31 {
 25179				break
 25180			}
 25181			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(8, c).m) && s == 8+smagic(8, c).s && x.Op != OpConst8 && sdivisibleOK(8, c)) {
 25182				break
 25183			}
 25184			v.reset(OpLeq8U)
 25185			v0 := b.NewValue0(v.Pos, OpRotateLeft8, typ.UInt8)
 25186			v1 := b.NewValue0(v.Pos, OpAdd8, typ.UInt8)
 25187			v2 := b.NewValue0(v.Pos, OpMul8, typ.UInt8)
 25188			v3 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 25189			v3.AuxInt = int64(int8(sdivisible(8, c).m))
 25190			v2.AddArg(v3)
 25191			v2.AddArg(x)
 25192			v1.AddArg(v2)
 25193			v4 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 25194			v4.AuxInt = int64(int8(sdivisible(8, c).a))
 25195			v1.AddArg(v4)
 25196			v0.AddArg(v1)
 25197			v5 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 25198			v5.AuxInt = int64(8 - sdivisible(8, c).k)
 25199			v0.AddArg(v5)
 25200			v.AddArg(v0)
 25201			v6 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 25202			v6.AuxInt = int64(int8(sdivisible(8, c).max))
 25203			v.AddArg(v6)
 25204			return true
 25205		}
 25206		// match: (Eq8 x (Mul8 (Sub8 (Rsh32x64 mul:(Mul32 (Const32 [m]) (SignExt8to32 x)) (Const64 [s])) (Rsh32x64 (SignExt8to32 x) (Const64 [31]))) (Const8 [c])))
 25207		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(8,c).m) && s == 8+smagic(8,c).s && x.Op != OpConst8 && sdivisibleOK(8,c)
 25208		// result: (Leq8U (RotateLeft8 <typ.UInt8> (Add8 <typ.UInt8> (Mul8 <typ.UInt8> (Const8 <typ.UInt8> [int64(int8(sdivisible(8,c).m))]) x) (Const8 <typ.UInt8> [int64(int8(sdivisible(8,c).a))]) ) (Const8 <typ.UInt8> [int64(8-sdivisible(8,c).k)]) ) (Const8 <typ.UInt8> [int64(int8(sdivisible(8,c).max))]) )
 25209		for {
 25210			_ = v.Args[1]
 25211			x := v.Args[0]
 25212			v_1 := v.Args[1]
 25213			if v_1.Op != OpMul8 {
 25214				break
 25215			}
 25216			_ = v_1.Args[1]
 25217			v_1_0 := v_1.Args[0]
 25218			if v_1_0.Op != OpSub8 {
 25219				break
 25220			}
 25221			_ = v_1_0.Args[1]
 25222			v_1_0_0 := v_1_0.Args[0]
 25223			if v_1_0_0.Op != OpRsh32x64 {
 25224				break
 25225			}
 25226			_ = v_1_0_0.Args[1]
 25227			mul := v_1_0_0.Args[0]
 25228			if mul.Op != OpMul32 {
 25229				break
 25230			}
 25231			_ = mul.Args[1]
 25232			mul_0 := mul.Args[0]
 25233			if mul_0.Op != OpConst32 {
 25234				break
 25235			}
 25236			m := mul_0.AuxInt
 25237			mul_1 := mul.Args[1]
 25238			if mul_1.Op != OpSignExt8to32 {
 25239				break
 25240			}
 25241			if x != mul_1.Args[0] {
 25242				break
 25243			}
 25244			v_1_0_0_1 := v_1_0_0.Args[1]
 25245			if v_1_0_0_1.Op != OpConst64 {
 25246				break
 25247			}
 25248			s := v_1_0_0_1.AuxInt
 25249			v_1_0_1 := v_1_0.Args[1]
 25250			if v_1_0_1.Op != OpRsh32x64 {
 25251				break
 25252			}
 25253			_ = v_1_0_1.Args[1]
 25254			v_1_0_1_0 := v_1_0_1.Args[0]
 25255			if v_1_0_1_0.Op != OpSignExt8to32 {
 25256				break
 25257			}
 25258			if x != v_1_0_1_0.Args[0] {
 25259				break
 25260			}
 25261			v_1_0_1_1 := v_1_0_1.Args[1]
 25262			if v_1_0_1_1.Op != OpConst64 {
 25263				break
 25264			}
 25265			if v_1_0_1_1.AuxInt != 31 {
 25266				break
 25267			}
 25268			v_1_1 := v_1.Args[1]
 25269			if v_1_1.Op != OpConst8 {
 25270				break
 25271			}
 25272			c := v_1_1.AuxInt
 25273			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(8, c).m) && s == 8+smagic(8, c).s && x.Op != OpConst8 && sdivisibleOK(8, c)) {
 25274				break
 25275			}
 25276			v.reset(OpLeq8U)
 25277			v0 := b.NewValue0(v.Pos, OpRotateLeft8, typ.UInt8)
 25278			v1 := b.NewValue0(v.Pos, OpAdd8, typ.UInt8)
 25279			v2 := b.NewValue0(v.Pos, OpMul8, typ.UInt8)
 25280			v3 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 25281			v3.AuxInt = int64(int8(sdivisible(8, c).m))
 25282			v2.AddArg(v3)
 25283			v2.AddArg(x)
 25284			v1.AddArg(v2)
 25285			v4 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 25286			v4.AuxInt = int64(int8(sdivisible(8, c).a))
 25287			v1.AddArg(v4)
 25288			v0.AddArg(v1)
 25289			v5 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 25290			v5.AuxInt = int64(8 - sdivisible(8, c).k)
 25291			v0.AddArg(v5)
 25292			v.AddArg(v0)
 25293			v6 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 25294			v6.AuxInt = int64(int8(sdivisible(8, c).max))
 25295			v.AddArg(v6)
 25296			return true
 25297		}
 25298		// match: (Eq8 x (Mul8 (Sub8 (Rsh32x64 mul:(Mul32 (SignExt8to32 x) (Const32 [m])) (Const64 [s])) (Rsh32x64 (SignExt8to32 x) (Const64 [31]))) (Const8 [c])))
 25299		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(8,c).m) && s == 8+smagic(8,c).s && x.Op != OpConst8 && sdivisibleOK(8,c)
 25300		// result: (Leq8U (RotateLeft8 <typ.UInt8> (Add8 <typ.UInt8> (Mul8 <typ.UInt8> (Const8 <typ.UInt8> [int64(int8(sdivisible(8,c).m))]) x) (Const8 <typ.UInt8> [int64(int8(sdivisible(8,c).a))]) ) (Const8 <typ.UInt8> [int64(8-sdivisible(8,c).k)]) ) (Const8 <typ.UInt8> [int64(int8(sdivisible(8,c).max))]) )
 25301		for {
 25302			_ = v.Args[1]
 25303			x := v.Args[0]
 25304			v_1 := v.Args[1]
 25305			if v_1.Op != OpMul8 {
 25306				break
 25307			}
 25308			_ = v_1.Args[1]
 25309			v_1_0 := v_1.Args[0]
 25310			if v_1_0.Op != OpSub8 {
 25311				break
 25312			}
 25313			_ = v_1_0.Args[1]
 25314			v_1_0_0 := v_1_0.Args[0]
 25315			if v_1_0_0.Op != OpRsh32x64 {
 25316				break
 25317			}
 25318			_ = v_1_0_0.Args[1]
 25319			mul := v_1_0_0.Args[0]
 25320			if mul.Op != OpMul32 {
 25321				break
 25322			}
 25323			_ = mul.Args[1]
 25324			mul_0 := mul.Args[0]
 25325			if mul_0.Op != OpSignExt8to32 {
 25326				break
 25327			}
 25328			if x != mul_0.Args[0] {
 25329				break
 25330			}
 25331			mul_1 := mul.Args[1]
 25332			if mul_1.Op != OpConst32 {
 25333				break
 25334			}
 25335			m := mul_1.AuxInt
 25336			v_1_0_0_1 := v_1_0_0.Args[1]
 25337			if v_1_0_0_1.Op != OpConst64 {
 25338				break
 25339			}
 25340			s := v_1_0_0_1.AuxInt
 25341			v_1_0_1 := v_1_0.Args[1]
 25342			if v_1_0_1.Op != OpRsh32x64 {
 25343				break
 25344			}
 25345			_ = v_1_0_1.Args[1]
 25346			v_1_0_1_0 := v_1_0_1.Args[0]
 25347			if v_1_0_1_0.Op != OpSignExt8to32 {
 25348				break
 25349			}
 25350			if x != v_1_0_1_0.Args[0] {
 25351				break
 25352			}
 25353			v_1_0_1_1 := v_1_0_1.Args[1]
 25354			if v_1_0_1_1.Op != OpConst64 {
 25355				break
 25356			}
 25357			if v_1_0_1_1.AuxInt != 31 {
 25358				break
 25359			}
 25360			v_1_1 := v_1.Args[1]
 25361			if v_1_1.Op != OpConst8 {
 25362				break
 25363			}
 25364			c := v_1_1.AuxInt
 25365			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(8, c).m) && s == 8+smagic(8, c).s && x.Op != OpConst8 && sdivisibleOK(8, c)) {
 25366				break
 25367			}
 25368			v.reset(OpLeq8U)
 25369			v0 := b.NewValue0(v.Pos, OpRotateLeft8, typ.UInt8)
 25370			v1 := b.NewValue0(v.Pos, OpAdd8, typ.UInt8)
 25371			v2 := b.NewValue0(v.Pos, OpMul8, typ.UInt8)
 25372			v3 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 25373			v3.AuxInt = int64(int8(sdivisible(8, c).m))
 25374			v2.AddArg(v3)
 25375			v2.AddArg(x)
 25376			v1.AddArg(v2)
 25377			v4 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 25378			v4.AuxInt = int64(int8(sdivisible(8, c).a))
 25379			v1.AddArg(v4)
 25380			v0.AddArg(v1)
 25381			v5 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 25382			v5.AuxInt = int64(8 - sdivisible(8, c).k)
 25383			v0.AddArg(v5)
 25384			v.AddArg(v0)
 25385			v6 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 25386			v6.AuxInt = int64(int8(sdivisible(8, c).max))
 25387			v.AddArg(v6)
 25388			return true
 25389		}
 25390		// match: (Eq8 (Mul8 (Const8 [c]) (Sub8 (Rsh32x64 mul:(Mul32 (Const32 [m]) (SignExt8to32 x)) (Const64 [s])) (Rsh32x64 (SignExt8to32 x) (Const64 [31])))) x)
 25391		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(8,c).m) && s == 8+smagic(8,c).s && x.Op != OpConst8 && sdivisibleOK(8,c)
 25392		// result: (Leq8U (RotateLeft8 <typ.UInt8> (Add8 <typ.UInt8> (Mul8 <typ.UInt8> (Const8 <typ.UInt8> [int64(int8(sdivisible(8,c).m))]) x) (Const8 <typ.UInt8> [int64(int8(sdivisible(8,c).a))]) ) (Const8 <typ.UInt8> [int64(8-sdivisible(8,c).k)]) ) (Const8 <typ.UInt8> [int64(int8(sdivisible(8,c).max))]) )
 25393		for {
 25394			x := v.Args[1]
 25395			v_0 := v.Args[0]
 25396			if v_0.Op != OpMul8 {
 25397				break
 25398			}
 25399			_ = v_0.Args[1]
 25400			v_0_0 := v_0.Args[0]
 25401			if v_0_0.Op != OpConst8 {
 25402				break
 25403			}
 25404			c := v_0_0.AuxInt
 25405			v_0_1 := v_0.Args[1]
 25406			if v_0_1.Op != OpSub8 {
 25407				break
 25408			}
 25409			_ = v_0_1.Args[1]
 25410			v_0_1_0 := v_0_1.Args[0]
 25411			if v_0_1_0.Op != OpRsh32x64 {
 25412				break
 25413			}
 25414			_ = v_0_1_0.Args[1]
 25415			mul := v_0_1_0.Args[0]
 25416			if mul.Op != OpMul32 {
 25417				break
 25418			}
 25419			_ = mul.Args[1]
 25420			mul_0 := mul.Args[0]
 25421			if mul_0.Op != OpConst32 {
 25422				break
 25423			}
 25424			m := mul_0.AuxInt
 25425			mul_1 := mul.Args[1]
 25426			if mul_1.Op != OpSignExt8to32 {
 25427				break
 25428			}
 25429			if x != mul_1.Args[0] {
 25430				break
 25431			}
 25432			v_0_1_0_1 := v_0_1_0.Args[1]
 25433			if v_0_1_0_1.Op != OpConst64 {
 25434				break
 25435			}
 25436			s := v_0_1_0_1.AuxInt
 25437			v_0_1_1 := v_0_1.Args[1]
 25438			if v_0_1_1.Op != OpRsh32x64 {
 25439				break
 25440			}
 25441			_ = v_0_1_1.Args[1]
 25442			v_0_1_1_0 := v_0_1_1.Args[0]
 25443			if v_0_1_1_0.Op != OpSignExt8to32 {
 25444				break
 25445			}
 25446			if x != v_0_1_1_0.Args[0] {
 25447				break
 25448			}
 25449			v_0_1_1_1 := v_0_1_1.Args[1]
 25450			if v_0_1_1_1.Op != OpConst64 {
 25451				break
 25452			}
 25453			if v_0_1_1_1.AuxInt != 31 {
 25454				break
 25455			}
 25456			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(8, c).m) && s == 8+smagic(8, c).s && x.Op != OpConst8 && sdivisibleOK(8, c)) {
 25457				break
 25458			}
 25459			v.reset(OpLeq8U)
 25460			v0 := b.NewValue0(v.Pos, OpRotateLeft8, typ.UInt8)
 25461			v1 := b.NewValue0(v.Pos, OpAdd8, typ.UInt8)
 25462			v2 := b.NewValue0(v.Pos, OpMul8, typ.UInt8)
 25463			v3 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 25464			v3.AuxInt = int64(int8(sdivisible(8, c).m))
 25465			v2.AddArg(v3)
 25466			v2.AddArg(x)
 25467			v1.AddArg(v2)
 25468			v4 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 25469			v4.AuxInt = int64(int8(sdivisible(8, c).a))
 25470			v1.AddArg(v4)
 25471			v0.AddArg(v1)
 25472			v5 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 25473			v5.AuxInt = int64(8 - sdivisible(8, c).k)
 25474			v0.AddArg(v5)
 25475			v.AddArg(v0)
 25476			v6 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 25477			v6.AuxInt = int64(int8(sdivisible(8, c).max))
 25478			v.AddArg(v6)
 25479			return true
 25480		}
 25481		// match: (Eq8 (Mul8 (Const8 [c]) (Sub8 (Rsh32x64 mul:(Mul32 (SignExt8to32 x) (Const32 [m])) (Const64 [s])) (Rsh32x64 (SignExt8to32 x) (Const64 [31])))) x)
 25482		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(8,c).m) && s == 8+smagic(8,c).s && x.Op != OpConst8 && sdivisibleOK(8,c)
 25483		// result: (Leq8U (RotateLeft8 <typ.UInt8> (Add8 <typ.UInt8> (Mul8 <typ.UInt8> (Const8 <typ.UInt8> [int64(int8(sdivisible(8,c).m))]) x) (Const8 <typ.UInt8> [int64(int8(sdivisible(8,c).a))]) ) (Const8 <typ.UInt8> [int64(8-sdivisible(8,c).k)]) ) (Const8 <typ.UInt8> [int64(int8(sdivisible(8,c).max))]) )
 25484		for {
 25485			x := v.Args[1]
 25486			v_0 := v.Args[0]
 25487			if v_0.Op != OpMul8 {
 25488				break
 25489			}
 25490			_ = v_0.Args[1]
 25491			v_0_0 := v_0.Args[0]
 25492			if v_0_0.Op != OpConst8 {
 25493				break
 25494			}
 25495			c := v_0_0.AuxInt
 25496			v_0_1 := v_0.Args[1]
 25497			if v_0_1.Op != OpSub8 {
 25498				break
 25499			}
 25500			_ = v_0_1.Args[1]
 25501			v_0_1_0 := v_0_1.Args[0]
 25502			if v_0_1_0.Op != OpRsh32x64 {
 25503				break
 25504			}
 25505			_ = v_0_1_0.Args[1]
 25506			mul := v_0_1_0.Args[0]
 25507			if mul.Op != OpMul32 {
 25508				break
 25509			}
 25510			_ = mul.Args[1]
 25511			mul_0 := mul.Args[0]
 25512			if mul_0.Op != OpSignExt8to32 {
 25513				break
 25514			}
 25515			if x != mul_0.Args[0] {
 25516				break
 25517			}
 25518			mul_1 := mul.Args[1]
 25519			if mul_1.Op != OpConst32 {
 25520				break
 25521			}
 25522			m := mul_1.AuxInt
 25523			v_0_1_0_1 := v_0_1_0.Args[1]
 25524			if v_0_1_0_1.Op != OpConst64 {
 25525				break
 25526			}
 25527			s := v_0_1_0_1.AuxInt
 25528			v_0_1_1 := v_0_1.Args[1]
 25529			if v_0_1_1.Op != OpRsh32x64 {
 25530				break
 25531			}
 25532			_ = v_0_1_1.Args[1]
 25533			v_0_1_1_0 := v_0_1_1.Args[0]
 25534			if v_0_1_1_0.Op != OpSignExt8to32 {
 25535				break
 25536			}
 25537			if x != v_0_1_1_0.Args[0] {
 25538				break
 25539			}
 25540			v_0_1_1_1 := v_0_1_1.Args[1]
 25541			if v_0_1_1_1.Op != OpConst64 {
 25542				break
 25543			}
 25544			if v_0_1_1_1.AuxInt != 31 {
 25545				break
 25546			}
 25547			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(8, c).m) && s == 8+smagic(8, c).s && x.Op != OpConst8 && sdivisibleOK(8, c)) {
 25548				break
 25549			}
 25550			v.reset(OpLeq8U)
 25551			v0 := b.NewValue0(v.Pos, OpRotateLeft8, typ.UInt8)
 25552			v1 := b.NewValue0(v.Pos, OpAdd8, typ.UInt8)
 25553			v2 := b.NewValue0(v.Pos, OpMul8, typ.UInt8)
 25554			v3 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 25555			v3.AuxInt = int64(int8(sdivisible(8, c).m))
 25556			v2.AddArg(v3)
 25557			v2.AddArg(x)
 25558			v1.AddArg(v2)
 25559			v4 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 25560			v4.AuxInt = int64(int8(sdivisible(8, c).a))
 25561			v1.AddArg(v4)
 25562			v0.AddArg(v1)
 25563			v5 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 25564			v5.AuxInt = int64(8 - sdivisible(8, c).k)
 25565			v0.AddArg(v5)
 25566			v.AddArg(v0)
 25567			v6 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 25568			v6.AuxInt = int64(int8(sdivisible(8, c).max))
 25569			v.AddArg(v6)
 25570			return true
 25571		}
 25572		// match: (Eq8 (Mul8 (Sub8 (Rsh32x64 mul:(Mul32 (Const32 [m]) (SignExt8to32 x)) (Const64 [s])) (Rsh32x64 (SignExt8to32 x) (Const64 [31]))) (Const8 [c])) x)
 25573		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(8,c).m) && s == 8+smagic(8,c).s && x.Op != OpConst8 && sdivisibleOK(8,c)
 25574		// result: (Leq8U (RotateLeft8 <typ.UInt8> (Add8 <typ.UInt8> (Mul8 <typ.UInt8> (Const8 <typ.UInt8> [int64(int8(sdivisible(8,c).m))]) x) (Const8 <typ.UInt8> [int64(int8(sdivisible(8,c).a))]) ) (Const8 <typ.UInt8> [int64(8-sdivisible(8,c).k)]) ) (Const8 <typ.UInt8> [int64(int8(sdivisible(8,c).max))]) )
 25575		for {
 25576			x := v.Args[1]
 25577			v_0 := v.Args[0]
 25578			if v_0.Op != OpMul8 {
 25579				break
 25580			}
 25581			_ = v_0.Args[1]
 25582			v_0_0 := v_0.Args[0]
 25583			if v_0_0.Op != OpSub8 {
 25584				break
 25585			}
 25586			_ = v_0_0.Args[1]
 25587			v_0_0_0 := v_0_0.Args[0]
 25588			if v_0_0_0.Op != OpRsh32x64 {
 25589				break
 25590			}
 25591			_ = v_0_0_0.Args[1]
 25592			mul := v_0_0_0.Args[0]
 25593			if mul.Op != OpMul32 {
 25594				break
 25595			}
 25596			_ = mul.Args[1]
 25597			mul_0 := mul.Args[0]
 25598			if mul_0.Op != OpConst32 {
 25599				break
 25600			}
 25601			m := mul_0.AuxInt
 25602			mul_1 := mul.Args[1]
 25603			if mul_1.Op != OpSignExt8to32 {
 25604				break
 25605			}
 25606			if x != mul_1.Args[0] {
 25607				break
 25608			}
 25609			v_0_0_0_1 := v_0_0_0.Args[1]
 25610			if v_0_0_0_1.Op != OpConst64 {
 25611				break
 25612			}
 25613			s := v_0_0_0_1.AuxInt
 25614			v_0_0_1 := v_0_0.Args[1]
 25615			if v_0_0_1.Op != OpRsh32x64 {
 25616				break
 25617			}
 25618			_ = v_0_0_1.Args[1]
 25619			v_0_0_1_0 := v_0_0_1.Args[0]
 25620			if v_0_0_1_0.Op != OpSignExt8to32 {
 25621				break
 25622			}
 25623			if x != v_0_0_1_0.Args[0] {
 25624				break
 25625			}
 25626			v_0_0_1_1 := v_0_0_1.Args[1]
 25627			if v_0_0_1_1.Op != OpConst64 {
 25628				break
 25629			}
 25630			if v_0_0_1_1.AuxInt != 31 {
 25631				break
 25632			}
 25633			v_0_1 := v_0.Args[1]
 25634			if v_0_1.Op != OpConst8 {
 25635				break
 25636			}
 25637			c := v_0_1.AuxInt
 25638			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(8, c).m) && s == 8+smagic(8, c).s && x.Op != OpConst8 && sdivisibleOK(8, c)) {
 25639				break
 25640			}
 25641			v.reset(OpLeq8U)
 25642			v0 := b.NewValue0(v.Pos, OpRotateLeft8, typ.UInt8)
 25643			v1 := b.NewValue0(v.Pos, OpAdd8, typ.UInt8)
 25644			v2 := b.NewValue0(v.Pos, OpMul8, typ.UInt8)
 25645			v3 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 25646			v3.AuxInt = int64(int8(sdivisible(8, c).m))
 25647			v2.AddArg(v3)
 25648			v2.AddArg(x)
 25649			v1.AddArg(v2)
 25650			v4 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 25651			v4.AuxInt = int64(int8(sdivisible(8, c).a))
 25652			v1.AddArg(v4)
 25653			v0.AddArg(v1)
 25654			v5 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 25655			v5.AuxInt = int64(8 - sdivisible(8, c).k)
 25656			v0.AddArg(v5)
 25657			v.AddArg(v0)
 25658			v6 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 25659			v6.AuxInt = int64(int8(sdivisible(8, c).max))
 25660			v.AddArg(v6)
 25661			return true
 25662		}
 25663		// match: (Eq8 (Mul8 (Sub8 (Rsh32x64 mul:(Mul32 (SignExt8to32 x) (Const32 [m])) (Const64 [s])) (Rsh32x64 (SignExt8to32 x) (Const64 [31]))) (Const8 [c])) x)
 25664		// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(8,c).m) && s == 8+smagic(8,c).s && x.Op != OpConst8 && sdivisibleOK(8,c)
 25665		// result: (Leq8U (RotateLeft8 <typ.UInt8> (Add8 <typ.UInt8> (Mul8 <typ.UInt8> (Const8 <typ.UInt8> [int64(int8(sdivisible(8,c).m))]) x) (Const8 <typ.UInt8> [int64(int8(sdivisible(8,c).a))]) ) (Const8 <typ.UInt8> [int64(8-sdivisible(8,c).k)]) ) (Const8 <typ.UInt8> [int64(int8(sdivisible(8,c).max))]) )
 25666		for {
 25667			x := v.Args[1]
 25668			v_0 := v.Args[0]
 25669			if v_0.Op != OpMul8 {
 25670				break
 25671			}
 25672			_ = v_0.Args[1]
 25673			v_0_0 := v_0.Args[0]
 25674			if v_0_0.Op != OpSub8 {
 25675				break
 25676			}
 25677			_ = v_0_0.Args[1]
 25678			v_0_0_0 := v_0_0.Args[0]
 25679			if v_0_0_0.Op != OpRsh32x64 {
 25680				break
 25681			}
 25682			_ = v_0_0_0.Args[1]
 25683			mul := v_0_0_0.Args[0]
 25684			if mul.Op != OpMul32 {
 25685				break
 25686			}
 25687			_ = mul.Args[1]
 25688			mul_0 := mul.Args[0]
 25689			if mul_0.Op != OpSignExt8to32 {
 25690				break
 25691			}
 25692			if x != mul_0.Args[0] {
 25693				break
 25694			}
 25695			mul_1 := mul.Args[1]
 25696			if mul_1.Op != OpConst32 {
 25697				break
 25698			}
 25699			m := mul_1.AuxInt
 25700			v_0_0_0_1 := v_0_0_0.Args[1]
 25701			if v_0_0_0_1.Op != OpConst64 {
 25702				break
 25703			}
 25704			s := v_0_0_0_1.AuxInt
 25705			v_0_0_1 := v_0_0.Args[1]
 25706			if v_0_0_1.Op != OpRsh32x64 {
 25707				break
 25708			}
 25709			_ = v_0_0_1.Args[1]
 25710			v_0_0_1_0 := v_0_0_1.Args[0]
 25711			if v_0_0_1_0.Op != OpSignExt8to32 {
 25712				break
 25713			}
 25714			if x != v_0_0_1_0.Args[0] {
 25715				break
 25716			}
 25717			v_0_0_1_1 := v_0_0_1.Args[1]
 25718			if v_0_0_1_1.Op != OpConst64 {
 25719				break
 25720			}
 25721			if v_0_0_1_1.AuxInt != 31 {
 25722				break
 25723			}
 25724			v_0_1 := v_0.Args[1]
 25725			if v_0_1.Op != OpConst8 {
 25726				break
 25727			}
 25728			c := v_0_1.AuxInt
 25729			if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(8, c).m) && s == 8+smagic(8, c).s && x.Op != OpConst8 && sdivisibleOK(8, c)) {
 25730				break
 25731			}
 25732			v.reset(OpLeq8U)
 25733			v0 := b.NewValue0(v.Pos, OpRotateLeft8, typ.UInt8)
 25734			v1 := b.NewValue0(v.Pos, OpAdd8, typ.UInt8)
 25735			v2 := b.NewValue0(v.Pos, OpMul8, typ.UInt8)
 25736			v3 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 25737			v3.AuxInt = int64(int8(sdivisible(8, c).m))
 25738			v2.AddArg(v3)
 25739			v2.AddArg(x)
 25740			v1.AddArg(v2)
 25741			v4 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 25742			v4.AuxInt = int64(int8(sdivisible(8, c).a))
 25743			v1.AddArg(v4)
 25744			v0.AddArg(v1)
 25745			v5 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 25746			v5.AuxInt = int64(8 - sdivisible(8, c).k)
 25747			v0.AddArg(v5)
 25748			v.AddArg(v0)
 25749			v6 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
 25750			v6.AuxInt = int64(int8(sdivisible(8, c).max))
 25751			v.AddArg(v6)
 25752			return true
 25753		}
 25754		// match: (Eq8 n (Lsh8x64 (Rsh8x64 (Add8 <t> n (Rsh8Ux64 <t> (Rsh8x64 <t> n (Const64 <typ.UInt64> [ 7])) (Const64 <typ.UInt64> [kbar]))) (Const64 <typ.UInt64> [k])) (Const64 <typ.UInt64> [k])))
 25755		// cond: k > 0 && k < 7 && kbar == 8 - k
 25756		// result: (Eq8 (And8 <t> n (Const8 <t> [int64(1<<uint(k)-1)])) (Const8 <t> [0]))
 25757		for {
 25758			_ = v.Args[1]
 25759			n := v.Args[0]
 25760			v_1 := v.Args[1]
 25761			if v_1.Op != OpLsh8x64 {
 25762				break
 25763			}
 25764			_ = v_1.Args[1]
 25765			v_1_0 := v_1.Args[0]
 25766			if v_1_0.Op != OpRsh8x64 {
 25767				break
 25768			}
 25769			_ = v_1_0.Args[1]
 25770			v_1_0_0 := v_1_0.Args[0]
 25771			if v_1_0_0.Op != OpAdd8 {
 25772				break
 25773			}
 25774			t := v_1_0_0.Type
 25775			_ = v_1_0_0.Args[1]
 25776			if n != v_1_0_0.Args[0] {
 25777				break
 25778			}
 25779			v_1_0_0_1 := v_1_0_0.Args[1]
 25780			if v_1_0_0_1.Op != OpRsh8Ux64 {
 25781				break
 25782			}
 25783			if v_1_0_0_1.Type != t {
 25784				break
 25785			}
 25786			_ = v_1_0_0_1.Args[1]
 25787			v_1_0_0_1_0 := v_1_0_0_1.Args[0]
 25788			if v_1_0_0_1_0.Op != OpRsh8x64 {
 25789				break
 25790			}
 25791			if v_1_0_0_1_0.Type != t {
 25792				break
 25793			}
 25794			_ = v_1_0_0_1_0.Args[1]
 25795			if n != v_1_0_0_1_0.Args[0] {
 25796				break
 25797			}
 25798			v_1_0_0_1_0_1 := v_1_0_0_1_0.Args[1]
 25799			if v_1_0_0_1_0_1.Op != OpConst64 {
 25800				break
 25801			}
 25802			if v_1_0_0_1_0_1.Type != typ.UInt64 {
 25803				break
 25804			}
 25805			if v_1_0_0_1_0_1.AuxInt != 7 {
 25806				break
 25807			}
 25808			v_1_0_0_1_1 := v_1_0_0_1.Args[1]
 25809			if v_1_0_0_1_1.Op != OpConst64 {
 25810				break
 25811			}
 25812			if v_1_0_0_1_1.Type != typ.UInt64 {
 25813				break
 25814			}
 25815			kbar := v_1_0_0_1_1.AuxInt
 25816			v_1_0_1 := v_1_0.Args[1]
 25817			if v_1_0_1.Op != OpConst64 {
 25818				break
 25819			}
 25820			if v_1_0_1.Type != typ.UInt64 {
 25821				break
 25822			}
 25823			k := v_1_0_1.AuxInt
 25824			v_1_1 := v_1.Args[1]
 25825			if v_1_1.Op != OpConst64 {
 25826				break
 25827			}
 25828			if v_1_1.Type != typ.UInt64 {
 25829				break
 25830			}
 25831			if v_1_1.AuxInt != k {
 25832				break
 25833			}
 25834			if !(k > 0 && k < 7 && kbar == 8-k) {
 25835				break
 25836			}
 25837			v.reset(OpEq8)
 25838			v0 := b.NewValue0(v.Pos, OpAnd8, t)
 25839			v0.AddArg(n)
 25840			v1 := b.NewValue0(v.Pos, OpConst8, t)
 25841			v1.AuxInt = int64(1<<uint(k) - 1)
 25842			v0.AddArg(v1)
 25843			v.AddArg(v0)
 25844			v2 := b.NewValue0(v.Pos, OpConst8, t)
 25845			v2.AuxInt = 0
 25846			v.AddArg(v2)
 25847			return true
 25848		}
 25849		// match: (Eq8 n (Lsh8x64 (Rsh8x64 (Add8 <t> (Rsh8Ux64 <t> (Rsh8x64 <t> n (Const64 <typ.UInt64> [ 7])) (Const64 <typ.UInt64> [kbar])) n) (Const64 <typ.UInt64> [k])) (Const64 <typ.UInt64> [k])))
 25850		// cond: k > 0 && k < 7 && kbar == 8 - k
 25851		// result: (Eq8 (And8 <t> n (Const8 <t> [int64(1<<uint(k)-1)])) (Const8 <t> [0]))
 25852		for {
 25853			_ = v.Args[1]
 25854			n := v.Args[0]
 25855			v_1 := v.Args[1]
 25856			if v_1.Op != OpLsh8x64 {
 25857				break
 25858			}
 25859			_ = v_1.Args[1]
 25860			v_1_0 := v_1.Args[0]
 25861			if v_1_0.Op != OpRsh8x64 {
 25862				break
 25863			}
 25864			_ = v_1_0.Args[1]
 25865			v_1_0_0 := v_1_0.Args[0]
 25866			if v_1_0_0.Op != OpAdd8 {
 25867				break
 25868			}
 25869			t := v_1_0_0.Type
 25870			_ = v_1_0_0.Args[1]
 25871			v_1_0_0_0 := v_1_0_0.Args[0]
 25872			if v_1_0_0_0.Op != OpRsh8Ux64 {
 25873				break
 25874			}
 25875			if v_1_0_0_0.Type != t {
 25876				break
 25877			}
 25878			_ = v_1_0_0_0.Args[1]
 25879			v_1_0_0_0_0 := v_1_0_0_0.Args[0]
 25880			if v_1_0_0_0_0.Op != OpRsh8x64 {
 25881				break
 25882			}
 25883			if v_1_0_0_0_0.Type != t {
 25884				break
 25885			}
 25886			_ = v_1_0_0_0_0.Args[1]
 25887			if n != v_1_0_0_0_0.Args[0] {
 25888				break
 25889			}
 25890			v_1_0_0_0_0_1 := v_1_0_0_0_0.Args[1]
 25891			if v_1_0_0_0_0_1.Op != OpConst64 {
 25892				break
 25893			}
 25894			if v_1_0_0_0_0_1.Type != typ.UInt64 {
 25895				break
 25896			}
 25897			if v_1_0_0_0_0_1.AuxInt != 7 {
 25898				break
 25899			}
 25900			v_1_0_0_0_1 := v_1_0_0_0.Args[1]
 25901			if v_1_0_0_0_1.Op != OpConst64 {
 25902				break
 25903			}
 25904			if v_1_0_0_0_1.Type != typ.UInt64 {
 25905				break
 25906			}
 25907			kbar := v_1_0_0_0_1.AuxInt
 25908			if n != v_1_0_0.Args[1] {
 25909				break
 25910			}
 25911			v_1_0_1 := v_1_0.Args[1]
 25912			if v_1_0_1.Op != OpConst64 {
 25913				break
 25914			}
 25915			if v_1_0_1.Type != typ.UInt64 {
 25916				break
 25917			}
 25918			k := v_1_0_1.AuxInt
 25919			v_1_1 := v_1.Args[1]
 25920			if v_1_1.Op != OpConst64 {
 25921				break
 25922			}
 25923			if v_1_1.Type != typ.UInt64 {
 25924				break
 25925			}
 25926			if v_1_1.AuxInt != k {
 25927				break
 25928			}
 25929			if !(k > 0 && k < 7 && kbar == 8-k) {
 25930				break
 25931			}
 25932			v.reset(OpEq8)
 25933			v0 := b.NewValue0(v.Pos, OpAnd8, t)
 25934			v0.AddArg(n)
 25935			v1 := b.NewValue0(v.Pos, OpConst8, t)
 25936			v1.AuxInt = int64(1<<uint(k) - 1)
 25937			v0.AddArg(v1)
 25938			v.AddArg(v0)
 25939			v2 := b.NewValue0(v.Pos, OpConst8, t)
 25940			v2.AuxInt = 0
 25941			v.AddArg(v2)
 25942			return true
 25943		}
 25944		// match: (Eq8 (Lsh8x64 (Rsh8x64 (Add8 <t> n (Rsh8Ux64 <t> (Rsh8x64 <t> n (Const64 <typ.UInt64> [ 7])) (Const64 <typ.UInt64> [kbar]))) (Const64 <typ.UInt64> [k])) (Const64 <typ.UInt64> [k])) n)
 25945		// cond: k > 0 && k < 7 && kbar == 8 - k
 25946		// result: (Eq8 (And8 <t> n (Const8 <t> [int64(1<<uint(k)-1)])) (Const8 <t> [0]))
 25947		for {
 25948			n := v.Args[1]
 25949			v_0 := v.Args[0]
 25950			if v_0.Op != OpLsh8x64 {
 25951				break
 25952			}
 25953			_ = v_0.Args[1]
 25954			v_0_0 := v_0.Args[0]
 25955			if v_0_0.Op != OpRsh8x64 {
 25956				break
 25957			}
 25958			_ = v_0_0.Args[1]
 25959			v_0_0_0 := v_0_0.Args[0]
 25960			if v_0_0_0.Op != OpAdd8 {
 25961				break
 25962			}
 25963			t := v_0_0_0.Type
 25964			_ = v_0_0_0.Args[1]
 25965			if n != v_0_0_0.Args[0] {
 25966				break
 25967			}
 25968			v_0_0_0_1 := v_0_0_0.Args[1]
 25969			if v_0_0_0_1.Op != OpRsh8Ux64 {
 25970				break
 25971			}
 25972			if v_0_0_0_1.Type != t {
 25973				break
 25974			}
 25975			_ = v_0_0_0_1.Args[1]
 25976			v_0_0_0_1_0 := v_0_0_0_1.Args[0]
 25977			if v_0_0_0_1_0.Op != OpRsh8x64 {
 25978				break
 25979			}
 25980			if v_0_0_0_1_0.Type != t {
 25981				break
 25982			}
 25983			_ = v_0_0_0_1_0.Args[1]
 25984			if n != v_0_0_0_1_0.Args[0] {
 25985				break
 25986			}
 25987			v_0_0_0_1_0_1 := v_0_0_0_1_0.Args[1]
 25988			if v_0_0_0_1_0_1.Op != OpConst64 {
 25989				break
 25990			}
 25991			if v_0_0_0_1_0_1.Type != typ.UInt64 {
 25992				break
 25993			}
 25994			if v_0_0_0_1_0_1.AuxInt != 7 {
 25995				break
 25996			}
 25997			v_0_0_0_1_1 := v_0_0_0_1.Args[1]
 25998			if v_0_0_0_1_1.Op != OpConst64 {
 25999				break
 26000			}
 26001			if v_0_0_0_1_1.Type != typ.UInt64 {
 26002				break
 26003			}
 26004			kbar := v_0_0_0_1_1.AuxInt
 26005			v_0_0_1 := v_0_0.Args[1]
 26006			if v_0_0_1.Op != OpConst64 {
 26007				break
 26008			}
 26009			if v_0_0_1.Type != typ.UInt64 {
 26010				break
 26011			}
 26012			k := v_0_0_1.AuxInt
 26013			v_0_1 := v_0.Args[1]
 26014			if v_0_1.Op != OpConst64 {
 26015				break
 26016			}
 26017			if v_0_1.Type != typ.UInt64 {
 26018				break
 26019			}
 26020			if v_0_1.AuxInt != k {
 26021				break
 26022			}
 26023			if !(k > 0 && k < 7 && kbar == 8-k) {
 26024				break
 26025			}
 26026			v.reset(OpEq8)
 26027			v0 := b.NewValue0(v.Pos, OpAnd8, t)
 26028			v0.AddArg(n)
 26029			v1 := b.NewValue0(v.Pos, OpConst8, t)
 26030			v1.AuxInt = int64(1<<uint(k) - 1)
 26031			v0.AddArg(v1)
 26032			v.AddArg(v0)
 26033			v2 := b.NewValue0(v.Pos, OpConst8, t)
 26034			v2.AuxInt = 0
 26035			v.AddArg(v2)
 26036			return true
 26037		}
 26038		return false
 26039	}
 26040	func rewriteValuegeneric_OpEq8_30(v *Value) bool {
 26041		b := v.Block
 26042		typ := &b.Func.Config.Types
 26043		// match: (Eq8 (Lsh8x64 (Rsh8x64 (Add8 <t> (Rsh8Ux64 <t> (Rsh8x64 <t> n (Const64 <typ.UInt64> [ 7])) (Const64 <typ.UInt64> [kbar])) n) (Const64 <typ.UInt64> [k])) (Const64 <typ.UInt64> [k])) n)
 26044		// cond: k > 0 && k < 7 && kbar == 8 - k
 26045		// result: (Eq8 (And8 <t> n (Const8 <t> [int64(1<<uint(k)-1)])) (Const8 <t> [0]))
 26046		for {
 26047			n := v.Args[1]
 26048			v_0 := v.Args[0]
 26049			if v_0.Op != OpLsh8x64 {
 26050				break
 26051			}
 26052			_ = v_0.Args[1]
 26053			v_0_0 := v_0.Args[0]
 26054			if v_0_0.Op != OpRsh8x64 {
 26055				break
 26056			}
 26057			_ = v_0_0.Args[1]
 26058			v_0_0_0 := v_0_0.Args[0]
 26059			if v_0_0_0.Op != OpAdd8 {
 26060				break
 26061			}
 26062			t := v_0_0_0.Type
 26063			_ = v_0_0_0.Args[1]
 26064			v_0_0_0_0 := v_0_0_0.Args[0]
 26065			if v_0_0_0_0.Op != OpRsh8Ux64 {
 26066				break
 26067			}
 26068			if v_0_0_0_0.Type != t {
 26069				break
 26070			}
 26071			_ = v_0_0_0_0.Args[1]
 26072			v_0_0_0_0_0 := v_0_0_0_0.Args[0]
 26073			if v_0_0_0_0_0.Op != OpRsh8x64 {
 26074				break
 26075			}
 26076			if v_0_0_0_0_0.Type != t {
 26077				break
 26078			}
 26079			_ = v_0_0_0_0_0.Args[1]
 26080			if n != v_0_0_0_0_0.Args[0] {
 26081				break
 26082			}
 26083			v_0_0_0_0_0_1 := v_0_0_0_0_0.Args[1]
 26084			if v_0_0_0_0_0_1.Op != OpConst64 {
 26085				break
 26086			}
 26087			if v_0_0_0_0_0_1.Type != typ.UInt64 {
 26088				break
 26089			}
 26090			if v_0_0_0_0_0_1.AuxInt != 7 {
 26091				break
 26092			}
 26093			v_0_0_0_0_1 := v_0_0_0_0.Args[1]
 26094			if v_0_0_0_0_1.Op != OpConst64 {
 26095				break
 26096			}
 26097			if v_0_0_0_0_1.Type != typ.UInt64 {
 26098				break
 26099			}
 26100			kbar := v_0_0_0_0_1.AuxInt
 26101			if n != v_0_0_0.Args[1] {
 26102				break
 26103			}
 26104			v_0_0_1 := v_0_0.Args[1]
 26105			if v_0_0_1.Op != OpConst64 {
 26106				break
 26107			}
 26108			if v_0_0_1.Type != typ.UInt64 {
 26109				break
 26110			}
 26111			k := v_0_0_1.AuxInt
 26112			v_0_1 := v_0.Args[1]
 26113			if v_0_1.Op != OpConst64 {
 26114				break
 26115			}
 26116			if v_0_1.Type != typ.UInt64 {
 26117				break
 26118			}
 26119			if v_0_1.AuxInt != k {
 26120				break
 26121			}
 26122			if !(k > 0 && k < 7 && kbar == 8-k) {
 26123				break
 26124			}
 26125			v.reset(OpEq8)
 26126			v0 := b.NewValue0(v.Pos, OpAnd8, t)
 26127			v0.AddArg(n)
 26128			v1 := b.NewValue0(v.Pos, OpConst8, t)
 26129			v1.AuxInt = int64(1<<uint(k) - 1)
 26130			v0.AddArg(v1)
 26131			v.AddArg(v0)
 26132			v2 := b.NewValue0(v.Pos, OpConst8, t)
 26133			v2.AuxInt = 0
 26134			v.AddArg(v2)
 26135			return true
 26136		}
 26137		// match: (Eq8 s:(Sub8 x y) (Const8 [0]))
 26138		// cond: s.Uses == 1
 26139		// result: (Eq8 x y)
 26140		for {
 26141			_ = v.Args[1]
 26142			s := v.Args[0]
 26143			if s.Op != OpSub8 {
 26144				break
 26145			}
 26146			y := s.Args[1]
 26147			x := s.Args[0]
 26148			v_1 := v.Args[1]
 26149			if v_1.Op != OpConst8 {
 26150				break
 26151			}
 26152			if v_1.AuxInt != 0 {
 26153				break
 26154			}
 26155			if !(s.Uses == 1) {
 26156				break
 26157			}
 26158			v.reset(OpEq8)
 26159			v.AddArg(x)
 26160			v.AddArg(y)
 26161			return true
 26162		}
 26163		// match: (Eq8 (Const8 [0]) s:(Sub8 x y))
 26164		// cond: s.Uses == 1
 26165		// result: (Eq8 x y)
 26166		for {
 26167			_ = v.Args[1]
 26168			v_0 := v.Args[0]
 26169			if v_0.Op != OpConst8 {
 26170				break
 26171			}
 26172			if v_0.AuxInt != 0 {
 26173				break
 26174			}
 26175			s := v.Args[1]
 26176			if s.Op != OpSub8 {
 26177				break
 26178			}
 26179			y := s.Args[1]
 26180			x := s.Args[0]
 26181			if !(s.Uses == 1) {
 26182				break
 26183			}
 26184			v.reset(OpEq8)
 26185			v.AddArg(x)
 26186			v.AddArg(y)
 26187			return true
 26188		}
 26189		return false
 26190	}
 26191	func rewriteValuegeneric_OpEqB_0(v *Value) bool {
 26192		// match: (EqB (ConstBool [c]) (ConstBool [d]))
 26193		// cond:
 26194		// result: (ConstBool [b2i(c == d)])
 26195		for {
 26196			_ = v.Args[1]
 26197			v_0 := v.Args[0]
 26198			if v_0.Op != OpConstBool {
 26199				break
 26200			}
 26201			c := v_0.AuxInt
 26202			v_1 := v.Args[1]
 26203			if v_1.Op != OpConstBool {
 26204				break
 26205			}
 26206			d := v_1.AuxInt
 26207			v.reset(OpConstBool)
 26208			v.AuxInt = b2i(c == d)
 26209			return true
 26210		}
 26211		// match: (EqB (ConstBool [d]) (ConstBool [c]))
 26212		// cond:
 26213		// result: (ConstBool [b2i(c == d)])
 26214		for {
 26215			_ = v.Args[1]
 26216			v_0 := v.Args[0]
 26217			if v_0.Op != OpConstBool {
 26218				break
 26219			}
 26220			d := v_0.AuxInt
 26221			v_1 := v.Args[1]
 26222			if v_1.Op != OpConstBool {
 26223				break
 26224			}
 26225			c := v_1.AuxInt
 26226			v.reset(OpConstBool)
 26227			v.AuxInt = b2i(c == d)
 26228			return true
 26229		}
 26230		// match: (EqB (ConstBool [0]) x)
 26231		// cond:
 26232		// result: (Not x)
 26233		for {
 26234			x := v.Args[1]
 26235			v_0 := v.Args[0]
 26236			if v_0.Op != OpConstBool {
 26237				break
 26238			}
 26239			if v_0.AuxInt != 0 {
 26240				break
 26241			}
 26242			v.reset(OpNot)
 26243			v.AddArg(x)
 26244			return true
 26245		}
 26246		// match: (EqB x (ConstBool [0]))
 26247		// cond:
 26248		// result: (Not x)
 26249		for {
 26250			_ = v.Args[1]
 26251			x := v.Args[0]
 26252			v_1 := v.Args[1]
 26253			if v_1.Op != OpConstBool {
 26254				break
 26255			}
 26256			if v_1.AuxInt != 0 {
 26257				break
 26258			}
 26259			v.reset(OpNot)
 26260			v.AddArg(x)
 26261			return true
 26262		}
 26263		// match: (EqB (ConstBool [1]) x)
 26264		// cond:
 26265		// result: x
 26266		for {
 26267			x := v.Args[1]
 26268			v_0 := v.Args[0]
 26269			if v_0.Op != OpConstBool {
 26270				break
 26271			}
 26272			if v_0.AuxInt != 1 {
 26273				break
 26274			}
 26275			v.reset(OpCopy)
 26276			v.Type = x.Type
 26277			v.AddArg(x)
 26278			return true
 26279		}
 26280		// match: (EqB x (ConstBool [1]))
 26281		// cond:
 26282		// result: x
 26283		for {
 26284			_ = v.Args[1]
 26285			x := v.Args[0]
 26286			v_1 := v.Args[1]
 26287			if v_1.Op != OpConstBool {
 26288				break
 26289			}
 26290			if v_1.AuxInt != 1 {
 26291				break
 26292			}
 26293			v.reset(OpCopy)
 26294			v.Type = x.Type
 26295			v.AddArg(x)
 26296			return true
 26297		}
 26298		return false
 26299	}
 26300	func rewriteValuegeneric_OpEqInter_0(v *Value) bool {
 26301		b := v.Block
 26302		typ := &b.Func.Config.Types
 26303		// match: (EqInter x y)
 26304		// cond:
 26305		// result: (EqPtr (ITab x) (ITab y))
 26306		for {
 26307			y := v.Args[1]
 26308			x := v.Args[0]
 26309			v.reset(OpEqPtr)
 26310			v0 := b.NewValue0(v.Pos, OpITab, typ.Uintptr)
 26311			v0.AddArg(x)
 26312			v.AddArg(v0)
 26313			v1 := b.NewValue0(v.Pos, OpITab, typ.Uintptr)
 26314			v1.AddArg(y)
 26315			v.AddArg(v1)
 26316			return true
 26317		}
 26318	}
 26319	func rewriteValuegeneric_OpEqPtr_0(v *Value) bool {
 26320		// match: (EqPtr x x)
 26321		// cond:
 26322		// result: (ConstBool [1])
 26323		for {
 26324			x := v.Args[1]
 26325			if x != v.Args[0] {
 26326				break
 26327			}
 26328			v.reset(OpConstBool)
 26329			v.AuxInt = 1
 26330			return true
 26331		}
 26332		// match: (EqPtr (Addr {a} _) (Addr {b} _))
 26333		// cond:
 26334		// result: (ConstBool [b2i(a == b)])
 26335		for {
 26336			_ = v.Args[1]
 26337			v_0 := v.Args[0]
 26338			if v_0.Op != OpAddr {
 26339				break
 26340			}
 26341			a := v_0.Aux
 26342			v_1 := v.Args[1]
 26343			if v_1.Op != OpAddr {
 26344				break
 26345			}
 26346			b := v_1.Aux
 26347			v.reset(OpConstBool)
 26348			v.AuxInt = b2i(a == b)
 26349			return true
 26350		}
 26351		// match: (EqPtr (Addr {b} _) (Addr {a} _))
 26352		// cond:
 26353		// result: (ConstBool [b2i(a == b)])
 26354		for {
 26355			_ = v.Args[1]
 26356			v_0 := v.Args[0]
 26357			if v_0.Op != OpAddr {
 26358				break
 26359			}
 26360			b := v_0.Aux
 26361			v_1 := v.Args[1]
 26362			if v_1.Op != OpAddr {
 26363				break
 26364			}
 26365			a := v_1.Aux
 26366			v.reset(OpConstBool)
 26367			v.AuxInt = b2i(a == b)
 26368			return true
 26369		}
 26370		// match: (EqPtr (LocalAddr {a} _ _) (LocalAddr {b} _ _))
 26371		// cond:
 26372		// result: (ConstBool [b2i(a == b)])
 26373		for {
 26374			_ = v.Args[1]
 26375			v_0 := v.Args[0]
 26376			if v_0.Op != OpLocalAddr {
 26377				break
 26378			}
 26379			a := v_0.Aux
 26380			_ = v_0.Args[1]
 26381			v_1 := v.Args[1]
 26382			if v_1.Op != OpLocalAddr {
 26383				break
 26384			}
 26385			b := v_1.Aux
 26386			_ = v_1.Args[1]
 26387			v.reset(OpConstBool)
 26388			v.AuxInt = b2i(a == b)
 26389			return true
 26390		}
 26391		// match: (EqPtr (LocalAddr {b} _ _) (LocalAddr {a} _ _))
 26392		// cond:
 26393		// result: (ConstBool [b2i(a == b)])
 26394		for {
 26395			_ = v.Args[1]
 26396			v_0 := v.Args[0]
 26397			if v_0.Op != OpLocalAddr {
 26398				break
 26399			}
 26400			b := v_0.Aux
 26401			_ = v_0.Args[1]
 26402			v_1 := v.Args[1]
 26403			if v_1.Op != OpLocalAddr {
 26404				break
 26405			}
 26406			a := v_1.Aux
 26407			_ = v_1.Args[1]
 26408			v.reset(OpConstBool)
 26409			v.AuxInt = b2i(a == b)
 26410			return true
 26411		}
 26412		// match: (EqPtr (OffPtr [o1] p1) p2)
 26413		// cond: isSamePtr(p1, p2)
 26414		// result: (ConstBool [b2i(o1 == 0)])
 26415		for {
 26416			p2 := v.Args[1]
 26417			v_0 := v.Args[0]
 26418			if v_0.Op != OpOffPtr {
 26419				break
 26420			}
 26421			o1 := v_0.AuxInt
 26422			p1 := v_0.Args[0]
 26423			if !(isSamePtr(p1, p2)) {
 26424				break
 26425			}
 26426			v.reset(OpConstBool)
 26427			v.AuxInt = b2i(o1 == 0)
 26428			return true
 26429		}
 26430		// match: (EqPtr p2 (OffPtr [o1] p1))
 26431		// cond: isSamePtr(p1, p2)
 26432		// result: (ConstBool [b2i(o1 == 0)])
 26433		for {
 26434			_ = v.Args[1]
 26435			p2 := v.Args[0]
 26436			v_1 := v.Args[1]
 26437			if v_1.Op != OpOffPtr {
 26438				break
 26439			}
 26440			o1 := v_1.AuxInt
 26441			p1 := v_1.Args[0]
 26442			if !(isSamePtr(p1, p2)) {
 26443				break
 26444			}
 26445			v.reset(OpConstBool)
 26446			v.AuxInt = b2i(o1 == 0)
 26447			return true
 26448		}
 26449		// match: (EqPtr (OffPtr [o1] p1) (OffPtr [o2] p2))
 26450		// cond: isSamePtr(p1, p2)
 26451		// result: (ConstBool [b2i(o1 == o2)])
 26452		for {
 26453			_ = v.Args[1]
 26454			v_0 := v.Args[0]
 26455			if v_0.Op != OpOffPtr {
 26456				break
 26457			}
 26458			o1 := v_0.AuxInt
 26459			p1 := v_0.Args[0]
 26460			v_1 := v.Args[1]
 26461			if v_1.Op != OpOffPtr {
 26462				break
 26463			}
 26464			o2 := v_1.AuxInt
 26465			p2 := v_1.Args[0]
 26466			if !(isSamePtr(p1, p2)) {
 26467				break
 26468			}
 26469			v.reset(OpConstBool)
 26470			v.AuxInt = b2i(o1 == o2)
 26471			return true
 26472		}
 26473		// match: (EqPtr (OffPtr [o2] p2) (OffPtr [o1] p1))
 26474		// cond: isSamePtr(p1, p2)
 26475		// result: (ConstBool [b2i(o1 == o2)])
 26476		for {
 26477			_ = v.Args[1]
 26478			v_0 := v.Args[0]
 26479			if v_0.Op != OpOffPtr {
 26480				break
 26481			}
 26482			o2 := v_0.AuxInt
 26483			p2 := v_0.Args[0]
 26484			v_1 := v.Args[1]
 26485			if v_1.Op != OpOffPtr {
 26486				break
 26487			}
 26488			o1 := v_1.AuxInt
 26489			p1 := v_1.Args[0]
 26490			if !(isSamePtr(p1, p2)) {
 26491				break
 26492			}
 26493			v.reset(OpConstBool)
 26494			v.AuxInt = b2i(o1 == o2)
 26495			return true
 26496		}
 26497		// match: (EqPtr (Const32 [c]) (Const32 [d]))
 26498		// cond:
 26499		// result: (ConstBool [b2i(c == d)])
 26500		for {
 26501			_ = v.Args[1]
 26502			v_0 := v.Args[0]
 26503			if v_0.Op != OpConst32 {
 26504				break
 26505			}
 26506			c := v_0.AuxInt
 26507			v_1 := v.Args[1]
 26508			if v_1.Op != OpConst32 {
 26509				break
 26510			}
 26511			d := v_1.AuxInt
 26512			v.reset(OpConstBool)
 26513			v.AuxInt = b2i(c == d)
 26514			return true
 26515		}
 26516		return false
 26517	}
 26518	func rewriteValuegeneric_OpEqPtr_10(v *Value) bool {
 26519		b := v.Block
 26520		typ := &b.Func.Config.Types
 26521		// match: (EqPtr (Const32 [d]) (Const32 [c]))
 26522		// cond:
 26523		// result: (ConstBool [b2i(c == d)])
 26524		for {
 26525			_ = v.Args[1]
 26526			v_0 := v.Args[0]
 26527			if v_0.Op != OpConst32 {
 26528				break
 26529			}
 26530			d := v_0.AuxInt
 26531			v_1 := v.Args[1]
 26532			if v_1.Op != OpConst32 {
 26533				break
 26534			}
 26535			c := v_1.AuxInt
 26536			v.reset(OpConstBool)
 26537			v.AuxInt = b2i(c == d)
 26538			return true
 26539		}
 26540		// match: (EqPtr (Const64 [c]) (Const64 [d]))
 26541		// cond:
 26542		// result: (ConstBool [b2i(c == d)])
 26543		for {
 26544			_ = v.Args[1]
 26545			v_0 := v.Args[0]
 26546			if v_0.Op != OpConst64 {
 26547				break
 26548			}
 26549			c := v_0.AuxInt
 26550			v_1 := v.Args[1]
 26551			if v_1.Op != OpConst64 {
 26552				break
 26553			}
 26554			d := v_1.AuxInt
 26555			v.reset(OpConstBool)
 26556			v.AuxInt = b2i(c == d)
 26557			return true
 26558		}
 26559		// match: (EqPtr (Const64 [d]) (Const64 [c]))
 26560		// cond:
 26561		// result: (ConstBool [b2i(c == d)])
 26562		for {
 26563			_ = v.Args[1]
 26564			v_0 := v.Args[0]
 26565			if v_0.Op != OpConst64 {
 26566				break
 26567			}
 26568			d := v_0.AuxInt
 26569			v_1 := v.Args[1]
 26570			if v_1.Op != OpConst64 {
 26571				break
 26572			}
 26573			c := v_1.AuxInt
 26574			v.reset(OpConstBool)
 26575			v.AuxInt = b2i(c == d)
 26576			return true
 26577		}
 26578		// match: (EqPtr (LocalAddr _ _) (Addr _))
 26579		// cond:
 26580		// result: (ConstBool [0])
 26581		for {
 26582			_ = v.Args[1]
 26583			v_0 := v.Args[0]
 26584			if v_0.Op != OpLocalAddr {
 26585				break
 26586			}
 26587			_ = v_0.Args[1]
 26588			v_1 := v.Args[1]
 26589			if v_1.Op != OpAddr {
 26590				break
 26591			}
 26592			v.reset(OpConstBool)
 26593			v.AuxInt = 0
 26594			return true
 26595		}
 26596		// match: (EqPtr (Addr _) (LocalAddr _ _))
 26597		// cond:
 26598		// result: (ConstBool [0])
 26599		for {
 26600			_ = v.Args[1]
 26601			v_0 := v.Args[0]
 26602			if v_0.Op != OpAddr {
 26603				break
 26604			}
 26605			v_1 := v.Args[1]
 26606			if v_1.Op != OpLocalAddr {
 26607				break
 26608			}
 26609			_ = v_1.Args[1]
 26610			v.reset(OpConstBool)
 26611			v.AuxInt = 0
 26612			return true
 26613		}
 26614		// match: (EqPtr (Addr _) (LocalAddr _ _))
 26615		// cond:
 26616		// result: (ConstBool [0])
 26617		for {
 26618			_ = v.Args[1]
 26619			v_0 := v.Args[0]
 26620			if v_0.Op != OpAddr {
 26621				break
 26622			}
 26623			v_1 := v.Args[1]
 26624			if v_1.Op != OpLocalAddr {
 26625				break
 26626			}
 26627			_ = v_1.Args[1]
 26628			v.reset(OpConstBool)
 26629			v.AuxInt = 0
 26630			return true
 26631		}
 26632		// match: (EqPtr (LocalAddr _ _) (Addr _))
 26633		// cond:
 26634		// result: (ConstBool [0])
 26635		for {
 26636			_ = v.Args[1]
 26637			v_0 := v.Args[0]
 26638			if v_0.Op != OpLocalAddr {
 26639				break
 26640			}
 26641			_ = v_0.Args[1]
 26642			v_1 := v.Args[1]
 26643			if v_1.Op != OpAddr {
 26644				break
 26645			}
 26646			v.reset(OpConstBool)
 26647			v.AuxInt = 0
 26648			return true
 26649		}
 26650		// match: (EqPtr (AddPtr p1 o1) p2)
 26651		// cond: isSamePtr(p1, p2)
 26652		// result: (Not (IsNonNil o1))
 26653		for {
 26654			p2 := v.Args[1]
 26655			v_0 := v.Args[0]
 26656			if v_0.Op != OpAddPtr {
 26657				break
 26658			}
 26659			o1 := v_0.Args[1]
 26660			p1 := v_0.Args[0]
 26661			if !(isSamePtr(p1, p2)) {
 26662				break
 26663			}
 26664			v.reset(OpNot)
 26665			v0 := b.NewValue0(v.Pos, OpIsNonNil, typ.Bool)
 26666			v0.AddArg(o1)
 26667			v.AddArg(v0)
 26668			return true
 26669		}
 26670		// match: (EqPtr p2 (AddPtr p1 o1))
 26671		// cond: isSamePtr(p1, p2)
 26672		// result: (Not (IsNonNil o1))
 26673		for {
 26674			_ = v.Args[1]
 26675			p2 := v.Args[0]
 26676			v_1 := v.Args[1]
 26677			if v_1.Op != OpAddPtr {
 26678				break
 26679			}
 26680			o1 := v_1.Args[1]
 26681			p1 := v_1.Args[0]
 26682			if !(isSamePtr(p1, p2)) {
 26683				break
 26684			}
 26685			v.reset(OpNot)
 26686			v0 := b.NewValue0(v.Pos, OpIsNonNil, typ.Bool)
 26687			v0.AddArg(o1)
 26688			v.AddArg(v0)
 26689			return true
 26690		}
 26691		// match: (EqPtr (Const32 [0]) p)
 26692		// cond:
 26693		// result: (Not (IsNonNil p))
 26694		for {
 26695			p := v.Args[1]
 26696			v_0 := v.Args[0]
 26697			if v_0.Op != OpConst32 {
 26698				break
 26699			}
 26700			if v_0.AuxInt != 0 {
 26701				break
 26702			}
 26703			v.reset(OpNot)
 26704			v0 := b.NewValue0(v.Pos, OpIsNonNil, typ.Bool)
 26705			v0.AddArg(p)
 26706			v.AddArg(v0)
 26707			return true
 26708		}
 26709		return false
 26710	}
 26711	func rewriteValuegeneric_OpEqPtr_20(v *Value) bool {
 26712		b := v.Block
 26713		typ := &b.Func.Config.Types
 26714		// match: (EqPtr p (Const32 [0]))
 26715		// cond:
 26716		// result: (Not (IsNonNil p))
 26717		for {
 26718			_ = v.Args[1]
 26719			p := v.Args[0]
 26720			v_1 := v.Args[1]
 26721			if v_1.Op != OpConst32 {
 26722				break
 26723			}
 26724			if v_1.AuxInt != 0 {
 26725				break
 26726			}
 26727			v.reset(OpNot)
 26728			v0 := b.NewValue0(v.Pos, OpIsNonNil, typ.Bool)
 26729			v0.AddArg(p)
 26730			v.AddArg(v0)
 26731			return true
 26732		}
 26733		// match: (EqPtr (Const64 [0]) p)
 26734		// cond:
 26735		// result: (Not (IsNonNil p))
 26736		for {
 26737			p := v.Args[1]
 26738			v_0 := v.Args[0]
 26739			if v_0.Op != OpConst64 {
 26740				break
 26741			}
 26742			if v_0.AuxInt != 0 {
 26743				break
 26744			}
 26745			v.reset(OpNot)
 26746			v0 := b.NewValue0(v.Pos, OpIsNonNil, typ.Bool)
 26747			v0.AddArg(p)
 26748			v.AddArg(v0)
 26749			return true
 26750		}
 26751		// match: (EqPtr p (Const64 [0]))
 26752		// cond:
 26753		// result: (Not (IsNonNil p))
 26754		for {
 26755			_ = v.Args[1]
 26756			p := v.Args[0]
 26757			v_1 := v.Args[1]
 26758			if v_1.Op != OpConst64 {
 26759				break
 26760			}
 26761			if v_1.AuxInt != 0 {
 26762				break
 26763			}
 26764			v.reset(OpNot)
 26765			v0 := b.NewValue0(v.Pos, OpIsNonNil, typ.Bool)
 26766			v0.AddArg(p)
 26767			v.AddArg(v0)
 26768			return true
 26769		}
 26770		// match: (EqPtr (ConstNil) p)
 26771		// cond:
 26772		// result: (Not (IsNonNil p))
 26773		for {
 26774			p := v.Args[1]
 26775			v_0 := v.Args[0]
 26776			if v_0.Op != OpConstNil {
 26777				break
 26778			}
 26779			v.reset(OpNot)
 26780			v0 := b.NewValue0(v.Pos, OpIsNonNil, typ.Bool)
 26781			v0.AddArg(p)
 26782			v.AddArg(v0)
 26783			return true
 26784		}
 26785		// match: (EqPtr p (ConstNil))
 26786		// cond:
 26787		// result: (Not (IsNonNil p))
 26788		for {
 26789			_ = v.Args[1]
 26790			p := v.Args[0]
 26791			v_1 := v.Args[1]
 26792			if v_1.Op != OpConstNil {
 26793				break
 26794			}
 26795			v.reset(OpNot)
 26796			v0 := b.NewValue0(v.Pos, OpIsNonNil, typ.Bool)
 26797			v0.AddArg(p)
 26798			v.AddArg(v0)
 26799			return true
 26800		}
 26801		return false
 26802	}
 26803	func rewriteValuegeneric_OpEqSlice_0(v *Value) bool {
 26804		b := v.Block
 26805		typ := &b.Func.Config.Types
 26806		// match: (EqSlice x y)
 26807		// cond:
 26808		// result: (EqPtr (SlicePtr x) (SlicePtr y))
 26809		for {
 26810			y := v.Args[1]
 26811			x := v.Args[0]
 26812			v.reset(OpEqPtr)
 26813			v0 := b.NewValue0(v.Pos, OpSlicePtr, typ.BytePtr)
 26814			v0.AddArg(x)
 26815			v.AddArg(v0)
 26816			v1 := b.NewValue0(v.Pos, OpSlicePtr, typ.BytePtr)
 26817			v1.AddArg(y)
 26818			v.AddArg(v1)
 26819			return true
 26820		}
 26821	}
 26822	func rewriteValuegeneric_OpGeq16_0(v *Value) bool {
 26823		// match: (Geq16 (Const16 [c]) (Const16 [d]))
 26824		// cond:
 26825		// result: (ConstBool [b2i(c >= d)])
 26826		for {
 26827			_ = v.Args[1]
 26828			v_0 := v.Args[0]
 26829			if v_0.Op != OpConst16 {
 26830				break
 26831			}
 26832			c := v_0.AuxInt
 26833			v_1 := v.Args[1]
 26834			if v_1.Op != OpConst16 {
 26835				break
 26836			}
 26837			d := v_1.AuxInt
 26838			v.reset(OpConstBool)
 26839			v.AuxInt = b2i(c >= d)
 26840			return true
 26841		}
 26842		// match: (Geq16 (And16 _ (Const16 [c])) (Const16 [0]))
 26843		// cond: int16(c) >= 0
 26844		// result: (ConstBool [1])
 26845		for {
 26846			_ = v.Args[1]
 26847			v_0 := v.Args[0]
 26848			if v_0.Op != OpAnd16 {
 26849				break
 26850			}
 26851			_ = v_0.Args[1]
 26852			v_0_1 := v_0.Args[1]
 26853			if v_0_1.Op != OpConst16 {
 26854				break
 26855			}
 26856			c := v_0_1.AuxInt
 26857			v_1 := v.Args[1]
 26858			if v_1.Op != OpConst16 {
 26859				break
 26860			}
 26861			if v_1.AuxInt != 0 {
 26862				break
 26863			}
 26864			if !(int16(c) >= 0) {
 26865				break
 26866			}
 26867			v.reset(OpConstBool)
 26868			v.AuxInt = 1
 26869			return true
 26870		}
 26871		// match: (Geq16 (And16 (Const16 [c]) _) (Const16 [0]))
 26872		// cond: int16(c) >= 0
 26873		// result: (ConstBool [1])
 26874		for {
 26875			_ = v.Args[1]
 26876			v_0 := v.Args[0]
 26877			if v_0.Op != OpAnd16 {
 26878				break
 26879			}
 26880			_ = v_0.Args[1]
 26881			v_0_0 := v_0.Args[0]
 26882			if v_0_0.Op != OpConst16 {
 26883				break
 26884			}
 26885			c := v_0_0.AuxInt
 26886			v_1 := v.Args[1]
 26887			if v_1.Op != OpConst16 {
 26888				break
 26889			}
 26890			if v_1.AuxInt != 0 {
 26891				break
 26892			}
 26893			if !(int16(c) >= 0) {
 26894				break
 26895			}
 26896			v.reset(OpConstBool)
 26897			v.AuxInt = 1
 26898			return true
 26899		}
 26900		return false
 26901	}
 26902	func rewriteValuegeneric_OpGeq16U_0(v *Value) bool {
 26903		// match: (Geq16U (Const16 [c]) (Const16 [d]))
 26904		// cond:
 26905		// result: (ConstBool [b2i(uint16(c) >= uint16(d))])
 26906		for {
 26907			_ = v.Args[1]
 26908			v_0 := v.Args[0]
 26909			if v_0.Op != OpConst16 {
 26910				break
 26911			}
 26912			c := v_0.AuxInt
 26913			v_1 := v.Args[1]
 26914			if v_1.Op != OpConst16 {
 26915				break
 26916			}
 26917			d := v_1.AuxInt
 26918			v.reset(OpConstBool)
 26919			v.AuxInt = b2i(uint16(c) >= uint16(d))
 26920			return true
 26921		}
 26922		return false
 26923	}
 26924	func rewriteValuegeneric_OpGeq32_0(v *Value) bool {
 26925		// match: (Geq32 (Const32 [c]) (Const32 [d]))
 26926		// cond:
 26927		// result: (ConstBool [b2i(c >= d)])
 26928		for {
 26929			_ = v.Args[1]
 26930			v_0 := v.Args[0]
 26931			if v_0.Op != OpConst32 {
 26932				break
 26933			}
 26934			c := v_0.AuxInt
 26935			v_1 := v.Args[1]
 26936			if v_1.Op != OpConst32 {
 26937				break
 26938			}
 26939			d := v_1.AuxInt
 26940			v.reset(OpConstBool)
 26941			v.AuxInt = b2i(c >= d)
 26942			return true
 26943		}
 26944		// match: (Geq32 (And32 _ (Const32 [c])) (Const32 [0]))
 26945		// cond: int32(c) >= 0
 26946		// result: (ConstBool [1])
 26947		for {
 26948			_ = v.Args[1]
 26949			v_0 := v.Args[0]
 26950			if v_0.Op != OpAnd32 {
 26951				break
 26952			}
 26953			_ = v_0.Args[1]
 26954			v_0_1 := v_0.Args[1]
 26955			if v_0_1.Op != OpConst32 {
 26956				break
 26957			}
 26958			c := v_0_1.AuxInt
 26959			v_1 := v.Args[1]
 26960			if v_1.Op != OpConst32 {
 26961				break
 26962			}
 26963			if v_1.AuxInt != 0 {
 26964				break
 26965			}
 26966			if !(int32(c) >= 0) {
 26967				break
 26968			}
 26969			v.reset(OpConstBool)
 26970			v.AuxInt = 1
 26971			return true
 26972		}
 26973		// match: (Geq32 (And32 (Const32 [c]) _) (Const32 [0]))
 26974		// cond: int32(c) >= 0
 26975		// result: (ConstBool [1])
 26976		for {
 26977			_ = v.Args[1]
 26978			v_0 := v.Args[0]
 26979			if v_0.Op != OpAnd32 {
 26980				break
 26981			}
 26982			_ = v_0.Args[1]
 26983			v_0_0 := v_0.Args[0]
 26984			if v_0_0.Op != OpConst32 {
 26985				break
 26986			}
 26987			c := v_0_0.AuxInt
 26988			v_1 := v.Args[1]
 26989			if v_1.Op != OpConst32 {
 26990				break
 26991			}
 26992			if v_1.AuxInt != 0 {
 26993				break
 26994			}
 26995			if !(int32(c) >= 0) {
 26996				break
 26997			}
 26998			v.reset(OpConstBool)
 26999			v.AuxInt = 1
 27000			return true
 27001		}
 27002		return false
 27003	}
 27004	func rewriteValuegeneric_OpGeq32F_0(v *Value) bool {
 27005		// match: (Geq32F (Const32F [c]) (Const32F [d]))
 27006		// cond:
 27007		// result: (ConstBool [b2i(auxTo32F(c) >= auxTo32F(d))])
 27008		for {
 27009			_ = v.Args[1]
 27010			v_0 := v.Args[0]
 27011			if v_0.Op != OpConst32F {
 27012				break
 27013			}
 27014			c := v_0.AuxInt
 27015			v_1 := v.Args[1]
 27016			if v_1.Op != OpConst32F {
 27017				break
 27018			}
 27019			d := v_1.AuxInt
 27020			v.reset(OpConstBool)
 27021			v.AuxInt = b2i(auxTo32F(c) >= auxTo32F(d))
 27022			return true
 27023		}
 27024		return false
 27025	}
 27026	func rewriteValuegeneric_OpGeq32U_0(v *Value) bool {
 27027		// match: (Geq32U (Const32 [c]) (Const32 [d]))
 27028		// cond:
 27029		// result: (ConstBool [b2i(uint32(c) >= uint32(d))])
 27030		for {
 27031			_ = v.Args[1]
 27032			v_0 := v.Args[0]
 27033			if v_0.Op != OpConst32 {
 27034				break
 27035			}
 27036			c := v_0.AuxInt
 27037			v_1 := v.Args[1]
 27038			if v_1.Op != OpConst32 {
 27039				break
 27040			}
 27041			d := v_1.AuxInt
 27042			v.reset(OpConstBool)
 27043			v.AuxInt = b2i(uint32(c) >= uint32(d))
 27044			return true
 27045		}
 27046		return false
 27047	}
 27048	func rewriteValuegeneric_OpGeq64_0(v *Value) bool {
 27049		// match: (Geq64 (Const64 [c]) (Const64 [d]))
 27050		// cond:
 27051		// result: (ConstBool [b2i(c >= d)])
 27052		for {
 27053			_ = v.Args[1]
 27054			v_0 := v.Args[0]
 27055			if v_0.Op != OpConst64 {
 27056				break
 27057			}
 27058			c := v_0.AuxInt
 27059			v_1 := v.Args[1]
 27060			if v_1.Op != OpConst64 {
 27061				break
 27062			}
 27063			d := v_1.AuxInt
 27064			v.reset(OpConstBool)
 27065			v.AuxInt = b2i(c >= d)
 27066			return true
 27067		}
 27068		// match: (Geq64 (And64 _ (Const64 [c])) (Const64 [0]))
 27069		// cond: int64(c) >= 0
 27070		// result: (ConstBool [1])
 27071		for {
 27072			_ = v.Args[1]
 27073			v_0 := v.Args[0]
 27074			if v_0.Op != OpAnd64 {
 27075				break
 27076			}
 27077			_ = v_0.Args[1]
 27078			v_0_1 := v_0.Args[1]
 27079			if v_0_1.Op != OpConst64 {
 27080				break
 27081			}
 27082			c := v_0_1.AuxInt
 27083			v_1 := v.Args[1]
 27084			if v_1.Op != OpConst64 {
 27085				break
 27086			}
 27087			if v_1.AuxInt != 0 {
 27088				break
 27089			}
 27090			if !(int64(c) >= 0) {
 27091				break
 27092			}
 27093			v.reset(OpConstBool)
 27094			v.AuxInt = 1
 27095			return true
 27096		}
 27097		// match: (Geq64 (And64 (Const64 [c]) _) (Const64 [0]))
 27098		// cond: int64(c) >= 0
 27099		// result: (ConstBool [1])
 27100		for {
 27101			_ = v.Args[1]
 27102			v_0 := v.Args[0]
 27103			if v_0.Op != OpAnd64 {
 27104				break
 27105			}
 27106			_ = v_0.Args[1]
 27107			v_0_0 := v_0.Args[0]
 27108			if v_0_0.Op != OpConst64 {
 27109				break
 27110			}
 27111			c := v_0_0.AuxInt
 27112			v_1 := v.Args[1]
 27113			if v_1.Op != OpConst64 {
 27114				break
 27115			}
 27116			if v_1.AuxInt != 0 {
 27117				break
 27118			}
 27119			if !(int64(c) >= 0) {
 27120				break
 27121			}
 27122			v.reset(OpConstBool)
 27123			v.AuxInt = 1
 27124			return true
 27125		}
 27126		// match: (Geq64 (Rsh64Ux64 _ (Const64 [c])) (Const64 [0]))
 27127		// cond: c > 0
 27128		// result: (ConstBool [1])
 27129		for {
 27130			_ = v.Args[1]
 27131			v_0 := v.Args[0]
 27132			if v_0.Op != OpRsh64Ux64 {
 27133				break
 27134			}
 27135			_ = v_0.Args[1]
 27136			v_0_1 := v_0.Args[1]
 27137			if v_0_1.Op != OpConst64 {
 27138				break
 27139			}
 27140			c := v_0_1.AuxInt
 27141			v_1 := v.Args[1]
 27142			if v_1.Op != OpConst64 {
 27143				break
 27144			}
 27145			if v_1.AuxInt != 0 {
 27146				break
 27147			}
 27148			if !(c > 0) {
 27149				break
 27150			}
 27151			v.reset(OpConstBool)
 27152			v.AuxInt = 1
 27153			return true
 27154		}
 27155		return false
 27156	}
 27157	func rewriteValuegeneric_OpGeq64F_0(v *Value) bool {
 27158		// match: (Geq64F (Const64F [c]) (Const64F [d]))
 27159		// cond:
 27160		// result: (ConstBool [b2i(auxTo64F(c) >= auxTo64F(d))])
 27161		for {
 27162			_ = v.Args[1]
 27163			v_0 := v.Args[0]
 27164			if v_0.Op != OpConst64F {
 27165				break
 27166			}
 27167			c := v_0.AuxInt
 27168			v_1 := v.Args[1]
 27169			if v_1.Op != OpConst64F {
 27170				break
 27171			}
 27172			d := v_1.AuxInt
 27173			v.reset(OpConstBool)
 27174			v.AuxInt = b2i(auxTo64F(c) >= auxTo64F(d))
 27175			return true
 27176		}
 27177		return false
 27178	}
 27179	func rewriteValuegeneric_OpGeq64U_0(v *Value) bool {
 27180		// match: (Geq64U (Const64 [c]) (Const64 [d]))
 27181		// cond:
 27182		// result: (ConstBool [b2i(uint64(c) >= uint64(d))])
 27183		for {
 27184			_ = v.Args[1]
 27185			v_0 := v.Args[0]
 27186			if v_0.Op != OpConst64 {
 27187				break
 27188			}
 27189			c := v_0.AuxInt
 27190			v_1 := v.Args[1]
 27191			if v_1.Op != OpConst64 {
 27192				break
 27193			}
 27194			d := v_1.AuxInt
 27195			v.reset(OpConstBool)
 27196			v.AuxInt = b2i(uint64(c) >= uint64(d))
 27197			return true
 27198		}
 27199		return false
 27200	}
 27201	func rewriteValuegeneric_OpGeq8_0(v *Value) bool {
 27202		// match: (Geq8 (Const8 [c]) (Const8 [d]))
 27203		// cond:
 27204		// result: (ConstBool [b2i(c >= d)])
 27205		for {
 27206			_ = v.Args[1]
 27207			v_0 := v.Args[0]
 27208			if v_0.Op != OpConst8 {
 27209				break
 27210			}
 27211			c := v_0.AuxInt
 27212			v_1 := v.Args[1]
 27213			if v_1.Op != OpConst8 {
 27214				break
 27215			}
 27216			d := v_1.AuxInt
 27217			v.reset(OpConstBool)
 27218			v.AuxInt = b2i(c >= d)
 27219			return true
 27220		}
 27221		// match: (Geq8 (And8 _ (Const8 [c])) (Const8 [0]))
 27222		// cond: int8(c) >= 0
 27223		// result: (ConstBool [1])
 27224		for {
 27225			_ = v.Args[1]
 27226			v_0 := v.Args[0]
 27227			if v_0.Op != OpAnd8 {
 27228				break
 27229			}
 27230			_ = v_0.Args[1]
 27231			v_0_1 := v_0.Args[1]
 27232			if v_0_1.Op != OpConst8 {
 27233				break
 27234			}
 27235			c := v_0_1.AuxInt
 27236			v_1 := v.Args[1]
 27237			if v_1.Op != OpConst8 {
 27238				break
 27239			}
 27240			if v_1.AuxInt != 0 {
 27241				break
 27242			}
 27243			if !(int8(c) >= 0) {
 27244				break
 27245			}
 27246			v.reset(OpConstBool)
 27247			v.AuxInt = 1
 27248			return true
 27249		}
 27250		// match: (Geq8 (And8 (Const8 [c]) _) (Const8 [0]))
 27251		// cond: int8(c) >= 0
 27252		// result: (ConstBool [1])
 27253		for {
 27254			_ = v.Args[1]
 27255			v_0 := v.Args[0]
 27256			if v_0.Op != OpAnd8 {
 27257				break
 27258			}
 27259			_ = v_0.Args[1]
 27260			v_0_0 := v_0.Args[0]
 27261			if v_0_0.Op != OpConst8 {
 27262				break
 27263			}
 27264			c := v_0_0.AuxInt
 27265			v_1 := v.Args[1]
 27266			if v_1.Op != OpConst8 {
 27267				break
 27268			}
 27269			if v_1.AuxInt != 0 {
 27270				break
 27271			}
 27272			if !(int8(c) >= 0) {
 27273				break
 27274			}
 27275			v.reset(OpConstBool)
 27276			v.AuxInt = 1
 27277			return true
 27278		}
 27279		return false
 27280	}
 27281	func rewriteValuegeneric_OpGeq8U_0(v *Value) bool {
 27282		// match: (Geq8U (Const8 [c]) (Const8 [d]))
 27283		// cond:
 27284		// result: (ConstBool [b2i(uint8(c) >= uint8(d))])
 27285		for {
 27286			_ = v.Args[1]
 27287			v_0 := v.Args[0]
 27288			if v_0.Op != OpConst8 {
 27289				break
 27290			}
 27291			c := v_0.AuxInt
 27292			v_1 := v.Args[1]
 27293			if v_1.Op != OpConst8 {
 27294				break
 27295			}
 27296			d := v_1.AuxInt
 27297			v.reset(OpConstBool)
 27298			v.AuxInt = b2i(uint8(c) >= uint8(d))
 27299			return true
 27300		}
 27301		return false
 27302	}
 27303	func rewriteValuegeneric_OpGreater16_0(v *Value) bool {
 27304		// match: (Greater16 (Const16 [c]) (Const16 [d]))
 27305		// cond:
 27306		// result: (ConstBool [b2i(c > d)])
 27307		for {
 27308			_ = v.Args[1]
 27309			v_0 := v.Args[0]
 27310			if v_0.Op != OpConst16 {
 27311				break
 27312			}
 27313			c := v_0.AuxInt
 27314			v_1 := v.Args[1]
 27315			if v_1.Op != OpConst16 {
 27316				break
 27317			}
 27318			d := v_1.AuxInt
 27319			v.reset(OpConstBool)
 27320			v.AuxInt = b2i(c > d)
 27321			return true
 27322		}
 27323		return false
 27324	}
 27325	func rewriteValuegeneric_OpGreater16U_0(v *Value) bool {
 27326		// match: (Greater16U (Const16 [c]) (Const16 [d]))
 27327		// cond:
 27328		// result: (ConstBool [b2i(uint16(c) > uint16(d))])
 27329		for {
 27330			_ = v.Args[1]
 27331			v_0 := v.Args[0]
 27332			if v_0.Op != OpConst16 {
 27333				break
 27334			}
 27335			c := v_0.AuxInt
 27336			v_1 := v.Args[1]
 27337			if v_1.Op != OpConst16 {
 27338				break
 27339			}
 27340			d := v_1.AuxInt
 27341			v.reset(OpConstBool)
 27342			v.AuxInt = b2i(uint16(c) > uint16(d))
 27343			return true
 27344		}
 27345		return false
 27346	}
 27347	func rewriteValuegeneric_OpGreater32_0(v *Value) bool {
 27348		// match: (Greater32 (Const32 [c]) (Const32 [d]))
 27349		// cond:
 27350		// result: (ConstBool [b2i(c > d)])
 27351		for {
 27352			_ = v.Args[1]
 27353			v_0 := v.Args[0]
 27354			if v_0.Op != OpConst32 {
 27355				break
 27356			}
 27357			c := v_0.AuxInt
 27358			v_1 := v.Args[1]
 27359			if v_1.Op != OpConst32 {
 27360				break
 27361			}
 27362			d := v_1.AuxInt
 27363			v.reset(OpConstBool)
 27364			v.AuxInt = b2i(c > d)
 27365			return true
 27366		}
 27367		return false
 27368	}
 27369	func rewriteValuegeneric_OpGreater32F_0(v *Value) bool {
 27370		// match: (Greater32F (Const32F [c]) (Const32F [d]))
 27371		// cond:
 27372		// result: (ConstBool [b2i(auxTo32F(c) > auxTo32F(d))])
 27373		for {
 27374			_ = v.Args[1]
 27375			v_0 := v.Args[0]
 27376			if v_0.Op != OpConst32F {
 27377				break
 27378			}
 27379			c := v_0.AuxInt
 27380			v_1 := v.Args[1]
 27381			if v_1.Op != OpConst32F {
 27382				break
 27383			}
 27384			d := v_1.AuxInt
 27385			v.reset(OpConstBool)
 27386			v.AuxInt = b2i(auxTo32F(c) > auxTo32F(d))
 27387			return true
 27388		}
 27389		return false
 27390	}
 27391	func rewriteValuegeneric_OpGreater32U_0(v *Value) bool {
 27392		// match: (Greater32U (Const32 [c]) (Const32 [d]))
 27393		// cond:
 27394		// result: (ConstBool [b2i(uint32(c) > uint32(d))])
 27395		for {
 27396			_ = v.Args[1]
 27397			v_0 := v.Args[0]
 27398			if v_0.Op != OpConst32 {
 27399				break
 27400			}
 27401			c := v_0.AuxInt
 27402			v_1 := v.Args[1]
 27403			if v_1.Op != OpConst32 {
 27404				break
 27405			}
 27406			d := v_1.AuxInt
 27407			v.reset(OpConstBool)
 27408			v.AuxInt = b2i(uint32(c) > uint32(d))
 27409			return true
 27410		}
 27411		return false
 27412	}
 27413	func rewriteValuegeneric_OpGreater64_0(v *Value) bool {
 27414		// match: (Greater64 (Const64 [c]) (Const64 [d]))
 27415		// cond:
 27416		// result: (ConstBool [b2i(c > d)])
 27417		for {
 27418			_ = v.Args[1]
 27419			v_0 := v.Args[0]
 27420			if v_0.Op != OpConst64 {
 27421				break
 27422			}
 27423			c := v_0.AuxInt
 27424			v_1 := v.Args[1]
 27425			if v_1.Op != OpConst64 {
 27426				break
 27427			}
 27428			d := v_1.AuxInt
 27429			v.reset(OpConstBool)
 27430			v.AuxInt = b2i(c > d)
 27431			return true
 27432		}
 27433		return false
 27434	}
 27435	func rewriteValuegeneric_OpGreater64F_0(v *Value) bool {
 27436		// match: (Greater64F (Const64F [c]) (Const64F [d]))
 27437		// cond:
 27438		// result: (ConstBool [b2i(auxTo64F(c) > auxTo64F(d))])
 27439		for {
 27440			_ = v.Args[1]
 27441			v_0 := v.Args[0]
 27442			if v_0.Op != OpConst64F {
 27443				break
 27444			}
 27445			c := v_0.AuxInt
 27446			v_1 := v.Args[1]
 27447			if v_1.Op != OpConst64F {
 27448				break
 27449			}
 27450			d := v_1.AuxInt
 27451			v.reset(OpConstBool)
 27452			v.AuxInt = b2i(auxTo64F(c) > auxTo64F(d))
 27453			return true
 27454		}
 27455		return false
 27456	}
 27457	func rewriteValuegeneric_OpGreater64U_0(v *Value) bool {
 27458		// match: (Greater64U (Const64 [c]) (Const64 [d]))
 27459		// cond:
 27460		// result: (ConstBool [b2i(uint64(c) > uint64(d))])
 27461		for {
 27462			_ = v.Args[1]
 27463			v_0 := v.Args[0]
 27464			if v_0.Op != OpConst64 {
 27465				break
 27466			}
 27467			c := v_0.AuxInt
 27468			v_1 := v.Args[1]
 27469			if v_1.Op != OpConst64 {
 27470				break
 27471			}
 27472			d := v_1.AuxInt
 27473			v.reset(OpConstBool)
 27474			v.AuxInt = b2i(uint64(c) > uint64(d))
 27475			return true
 27476		}
 27477		return false
 27478	}
 27479	func rewriteValuegeneric_OpGreater8_0(v *Value) bool {
 27480		// match: (Greater8 (Const8 [c]) (Const8 [d]))
 27481		// cond:
 27482		// result: (ConstBool [b2i(c > d)])
 27483		for {
 27484			_ = v.Args[1]
 27485			v_0 := v.Args[0]
 27486			if v_0.Op != OpConst8 {
 27487				break
 27488			}
 27489			c := v_0.AuxInt
 27490			v_1 := v.Args[1]
 27491			if v_1.Op != OpConst8 {
 27492				break
 27493			}
 27494			d := v_1.AuxInt
 27495			v.reset(OpConstBool)
 27496			v.AuxInt = b2i(c > d)
 27497			return true
 27498		}
 27499		return false
 27500	}
 27501	func rewriteValuegeneric_OpGreater8U_0(v *Value) bool {
 27502		// match: (Greater8U (Const8 [c]) (Const8 [d]))
 27503		// cond:
 27504		// result: (ConstBool [b2i(uint8(c) > uint8(d))])
 27505		for {
 27506			_ = v.Args[1]
 27507			v_0 := v.Args[0]
 27508			if v_0.Op != OpConst8 {
 27509				break
 27510			}
 27511			c := v_0.AuxInt
 27512			v_1 := v.Args[1]
 27513			if v_1.Op != OpConst8 {
 27514				break
 27515			}
 27516			d := v_1.AuxInt
 27517			v.reset(OpConstBool)
 27518			v.AuxInt = b2i(uint8(c) > uint8(d))
 27519			return true
 27520		}
 27521		return false
 27522	}
 27523	func rewriteValuegeneric_OpIMake_0(v *Value) bool {
 27524		// match: (IMake typ (StructMake1 val))
 27525		// cond:
 27526		// result: (IMake typ val)
 27527		for {
 27528			_ = v.Args[1]
 27529			typ := v.Args[0]
 27530			v_1 := v.Args[1]
 27531			if v_1.Op != OpStructMake1 {
 27532				break
 27533			}
 27534			val := v_1.Args[0]
 27535			v.reset(OpIMake)
 27536			v.AddArg(typ)
 27537			v.AddArg(val)
 27538			return true
 27539		}
 27540		// match: (IMake typ (ArrayMake1 val))
 27541		// cond:
 27542		// result: (IMake typ val)
 27543		for {
 27544			_ = v.Args[1]
 27545			typ := v.Args[0]
 27546			v_1 := v.Args[1]
 27547			if v_1.Op != OpArrayMake1 {
 27548				break
 27549			}
 27550			val := v_1.Args[0]
 27551			v.reset(OpIMake)
 27552			v.AddArg(typ)
 27553			v.AddArg(val)
 27554			return true
 27555		}
 27556		return false
 27557	}
 27558	func rewriteValuegeneric_OpInterCall_0(v *Value) bool {
 27559		// match: (InterCall [argsize] (Load (OffPtr [off] (ITab (IMake (Addr {itab} (SB)) _))) _) mem)
 27560		// cond: devirt(v, itab, off) != nil
 27561		// result: (StaticCall [argsize] {devirt(v, itab, off)} mem)
 27562		for {
 27563			argsize := v.AuxInt
 27564			mem := v.Args[1]
 27565			v_0 := v.Args[0]
 27566			if v_0.Op != OpLoad {
 27567				break
 27568			}
 27569			_ = v_0.Args[1]
 27570			v_0_0 := v_0.Args[0]
 27571			if v_0_0.Op != OpOffPtr {
 27572				break
 27573			}
 27574			off := v_0_0.AuxInt
 27575			v_0_0_0 := v_0_0.Args[0]
 27576			if v_0_0_0.Op != OpITab {
 27577				break
 27578			}
 27579			v_0_0_0_0 := v_0_0_0.Args[0]
 27580			if v_0_0_0_0.Op != OpIMake {
 27581				break
 27582			}
 27583			_ = v_0_0_0_0.Args[1]
 27584			v_0_0_0_0_0 := v_0_0_0_0.Args[0]
 27585			if v_0_0_0_0_0.Op != OpAddr {
 27586				break
 27587			}
 27588			itab := v_0_0_0_0_0.Aux
 27589			v_0_0_0_0_0_0 := v_0_0_0_0_0.Args[0]
 27590			if v_0_0_0_0_0_0.Op != OpSB {
 27591				break
 27592			}
 27593			if !(devirt(v, itab, off) != nil) {
 27594				break
 27595			}
 27596			v.reset(OpStaticCall)
 27597			v.AuxInt = argsize
 27598			v.Aux = devirt(v, itab, off)
 27599			v.AddArg(mem)
 27600			return true
 27601		}
 27602		return false
 27603	}
 27604	func rewriteValuegeneric_OpIsInBounds_0(v *Value) bool {
 27605		// match: (IsInBounds (ZeroExt8to32 _) (Const32 [c]))
 27606		// cond: (1 << 8) <= c
 27607		// result: (ConstBool [1])
 27608		for {
 27609			_ = v.Args[1]
 27610			v_0 := v.Args[0]
 27611			if v_0.Op != OpZeroExt8to32 {
 27612				break
 27613			}
 27614			v_1 := v.Args[1]
 27615			if v_1.Op != OpConst32 {
 27616				break
 27617			}
 27618			c := v_1.AuxInt
 27619			if !((1 << 8) <= c) {
 27620				break
 27621			}
 27622			v.reset(OpConstBool)
 27623			v.AuxInt = 1
 27624			return true
 27625		}
 27626		// match: (IsInBounds (ZeroExt8to64 _) (Const64 [c]))
 27627		// cond: (1 << 8) <= c
 27628		// result: (ConstBool [1])
 27629		for {
 27630			_ = v.Args[1]
 27631			v_0 := v.Args[0]
 27632			if v_0.Op != OpZeroExt8to64 {
 27633				break
 27634			}
 27635			v_1 := v.Args[1]
 27636			if v_1.Op != OpConst64 {
 27637				break
 27638			}
 27639			c := v_1.AuxInt
 27640			if !((1 << 8) <= c) {
 27641				break
 27642			}
 27643			v.reset(OpConstBool)
 27644			v.AuxInt = 1
 27645			return true
 27646		}
 27647		// match: (IsInBounds (ZeroExt16to32 _) (Const32 [c]))
 27648		// cond: (1 << 16) <= c
 27649		// result: (ConstBool [1])
 27650		for {
 27651			_ = v.Args[1]
 27652			v_0 := v.Args[0]
 27653			if v_0.Op != OpZeroExt16to32 {
 27654				break
 27655			}
 27656			v_1 := v.Args[1]
 27657			if v_1.Op != OpConst32 {
 27658				break
 27659			}
 27660			c := v_1.AuxInt
 27661			if !((1 << 16) <= c) {
 27662				break
 27663			}
 27664			v.reset(OpConstBool)
 27665			v.AuxInt = 1
 27666			return true
 27667		}
 27668		// match: (IsInBounds (ZeroExt16to64 _) (Const64 [c]))
 27669		// cond: (1 << 16) <= c
 27670		// result: (ConstBool [1])
 27671		for {
 27672			_ = v.Args[1]
 27673			v_0 := v.Args[0]
 27674			if v_0.Op != OpZeroExt16to64 {
 27675				break
 27676			}
 27677			v_1 := v.Args[1]
 27678			if v_1.Op != OpConst64 {
 27679				break
 27680			}
 27681			c := v_1.AuxInt
 27682			if !((1 << 16) <= c) {
 27683				break
 27684			}
 27685			v.reset(OpConstBool)
 27686			v.AuxInt = 1
 27687			return true
 27688		}
 27689		// match: (IsInBounds x x)
 27690		// cond:
 27691		// result: (ConstBool [0])
 27692		for {
 27693			x := v.Args[1]
 27694			if x != v.Args[0] {
 27695				break
 27696			}
 27697			v.reset(OpConstBool)
 27698			v.AuxInt = 0
 27699			return true
 27700		}
 27701		// match: (IsInBounds (And8 (Const8 [c]) _) (Const8 [d]))
 27702		// cond: 0 <= c && c < d
 27703		// result: (ConstBool [1])
 27704		for {
 27705			_ = v.Args[1]
 27706			v_0 := v.Args[0]
 27707			if v_0.Op != OpAnd8 {
 27708				break
 27709			}
 27710			_ = v_0.Args[1]
 27711			v_0_0 := v_0.Args[0]
 27712			if v_0_0.Op != OpConst8 {
 27713				break
 27714			}
 27715			c := v_0_0.AuxInt
 27716			v_1 := v.Args[1]
 27717			if v_1.Op != OpConst8 {
 27718				break
 27719			}
 27720			d := v_1.AuxInt
 27721			if !(0 <= c && c < d) {
 27722				break
 27723			}
 27724			v.reset(OpConstBool)
 27725			v.AuxInt = 1
 27726			return true
 27727		}
 27728		// match: (IsInBounds (And8 _ (Const8 [c])) (Const8 [d]))
 27729		// cond: 0 <= c && c < d
 27730		// result: (ConstBool [1])
 27731		for {
 27732			_ = v.Args[1]
 27733			v_0 := v.Args[0]
 27734			if v_0.Op != OpAnd8 {
 27735				break
 27736			}
 27737			_ = v_0.Args[1]
 27738			v_0_1 := v_0.Args[1]
 27739			if v_0_1.Op != OpConst8 {
 27740				break
 27741			}
 27742			c := v_0_1.AuxInt
 27743			v_1 := v.Args[1]
 27744			if v_1.Op != OpConst8 {
 27745				break
 27746			}
 27747			d := v_1.AuxInt
 27748			if !(0 <= c && c < d) {
 27749				break
 27750			}
 27751			v.reset(OpConstBool)
 27752			v.AuxInt = 1
 27753			return true
 27754		}
 27755		// match: (IsInBounds (ZeroExt8to16 (And8 (Const8 [c]) _)) (Const16 [d]))
 27756		// cond: 0 <= c && c < d
 27757		// result: (ConstBool [1])
 27758		for {
 27759			_ = v.Args[1]
 27760			v_0 := v.Args[0]
 27761			if v_0.Op != OpZeroExt8to16 {
 27762				break
 27763			}
 27764			v_0_0 := v_0.Args[0]
 27765			if v_0_0.Op != OpAnd8 {
 27766				break
 27767			}
 27768			_ = v_0_0.Args[1]
 27769			v_0_0_0 := v_0_0.Args[0]
 27770			if v_0_0_0.Op != OpConst8 {
 27771				break
 27772			}
 27773			c := v_0_0_0.AuxInt
 27774			v_1 := v.Args[1]
 27775			if v_1.Op != OpConst16 {
 27776				break
 27777			}
 27778			d := v_1.AuxInt
 27779			if !(0 <= c && c < d) {
 27780				break
 27781			}
 27782			v.reset(OpConstBool)
 27783			v.AuxInt = 1
 27784			return true
 27785		}
 27786		// match: (IsInBounds (ZeroExt8to16 (And8 _ (Const8 [c]))) (Const16 [d]))
 27787		// cond: 0 <= c && c < d
 27788		// result: (ConstBool [1])
 27789		for {
 27790			_ = v.Args[1]
 27791			v_0 := v.Args[0]
 27792			if v_0.Op != OpZeroExt8to16 {
 27793				break
 27794			}
 27795			v_0_0 := v_0.Args[0]
 27796			if v_0_0.Op != OpAnd8 {
 27797				break
 27798			}
 27799			_ = v_0_0.Args[1]
 27800			v_0_0_1 := v_0_0.Args[1]
 27801			if v_0_0_1.Op != OpConst8 {
 27802				break
 27803			}
 27804			c := v_0_0_1.AuxInt
 27805			v_1 := v.Args[1]
 27806			if v_1.Op != OpConst16 {
 27807				break
 27808			}
 27809			d := v_1.AuxInt
 27810			if !(0 <= c && c < d) {
 27811				break
 27812			}
 27813			v.reset(OpConstBool)
 27814			v.AuxInt = 1
 27815			return true
 27816		}
 27817		// match: (IsInBounds (ZeroExt8to32 (And8 (Const8 [c]) _)) (Const32 [d]))
 27818		// cond: 0 <= c && c < d
 27819		// result: (ConstBool [1])
 27820		for {
 27821			_ = v.Args[1]
 27822			v_0 := v.Args[0]
 27823			if v_0.Op != OpZeroExt8to32 {
 27824				break
 27825			}
 27826			v_0_0 := v_0.Args[0]
 27827			if v_0_0.Op != OpAnd8 {
 27828				break
 27829			}
 27830			_ = v_0_0.Args[1]
 27831			v_0_0_0 := v_0_0.Args[0]
 27832			if v_0_0_0.Op != OpConst8 {
 27833				break
 27834			}
 27835			c := v_0_0_0.AuxInt
 27836			v_1 := v.Args[1]
 27837			if v_1.Op != OpConst32 {
 27838				break
 27839			}
 27840			d := v_1.AuxInt
 27841			if !(0 <= c && c < d) {
 27842				break
 27843			}
 27844			v.reset(OpConstBool)
 27845			v.AuxInt = 1
 27846			return true
 27847		}
 27848		return false
 27849	}
 27850	func rewriteValuegeneric_OpIsInBounds_10(v *Value) bool {
 27851		// match: (IsInBounds (ZeroExt8to32 (And8 _ (Const8 [c]))) (Const32 [d]))
 27852		// cond: 0 <= c && c < d
 27853		// result: (ConstBool [1])
 27854		for {
 27855			_ = v.Args[1]
 27856			v_0 := v.Args[0]
 27857			if v_0.Op != OpZeroExt8to32 {
 27858				break
 27859			}
 27860			v_0_0 := v_0.Args[0]
 27861			if v_0_0.Op != OpAnd8 {
 27862				break
 27863			}
 27864			_ = v_0_0.Args[1]
 27865			v_0_0_1 := v_0_0.Args[1]
 27866			if v_0_0_1.Op != OpConst8 {
 27867				break
 27868			}
 27869			c := v_0_0_1.AuxInt
 27870			v_1 := v.Args[1]
 27871			if v_1.Op != OpConst32 {
 27872				break
 27873			}
 27874			d := v_1.AuxInt
 27875			if !(0 <= c && c < d) {
 27876				break
 27877			}
 27878			v.reset(OpConstBool)
 27879			v.AuxInt = 1
 27880			return true
 27881		}
 27882		// match: (IsInBounds (ZeroExt8to64 (And8 (Const8 [c]) _)) (Const64 [d]))
 27883		// cond: 0 <= c && c < d
 27884		// result: (ConstBool [1])
 27885		for {
 27886			_ = v.Args[1]
 27887			v_0 := v.Args[0]
 27888			if v_0.Op != OpZeroExt8to64 {
 27889				break
 27890			}
 27891			v_0_0 := v_0.Args[0]
 27892			if v_0_0.Op != OpAnd8 {
 27893				break
 27894			}
 27895			_ = v_0_0.Args[1]
 27896			v_0_0_0 := v_0_0.Args[0]
 27897			if v_0_0_0.Op != OpConst8 {
 27898				break
 27899			}
 27900			c := v_0_0_0.AuxInt
 27901			v_1 := v.Args[1]
 27902			if v_1.Op != OpConst64 {
 27903				break
 27904			}
 27905			d := v_1.AuxInt
 27906			if !(0 <= c && c < d) {
 27907				break
 27908			}
 27909			v.reset(OpConstBool)
 27910			v.AuxInt = 1
 27911			return true
 27912		}
 27913		// match: (IsInBounds (ZeroExt8to64 (And8 _ (Const8 [c]))) (Const64 [d]))
 27914		// cond: 0 <= c && c < d
 27915		// result: (ConstBool [1])
 27916		for {
 27917			_ = v.Args[1]
 27918			v_0 := v.Args[0]
 27919			if v_0.Op != OpZeroExt8to64 {
 27920				break
 27921			}
 27922			v_0_0 := v_0.Args[0]
 27923			if v_0_0.Op != OpAnd8 {
 27924				break
 27925			}
 27926			_ = v_0_0.Args[1]
 27927			v_0_0_1 := v_0_0.Args[1]
 27928			if v_0_0_1.Op != OpConst8 {
 27929				break
 27930			}
 27931			c := v_0_0_1.AuxInt
 27932			v_1 := v.Args[1]
 27933			if v_1.Op != OpConst64 {
 27934				break
 27935			}
 27936			d := v_1.AuxInt
 27937			if !(0 <= c && c < d) {
 27938				break
 27939			}
 27940			v.reset(OpConstBool)
 27941			v.AuxInt = 1
 27942			return true
 27943		}
 27944		// match: (IsInBounds (And16 (Const16 [c]) _) (Const16 [d]))
 27945		// cond: 0 <= c && c < d
 27946		// result: (ConstBool [1])
 27947		for {
 27948			_ = v.Args[1]
 27949			v_0 := v.Args[0]
 27950			if v_0.Op != OpAnd16 {
 27951				break
 27952			}
 27953			_ = v_0.Args[1]
 27954			v_0_0 := v_0.Args[0]
 27955			if v_0_0.Op != OpConst16 {
 27956				break
 27957			}
 27958			c := v_0_0.AuxInt
 27959			v_1 := v.Args[1]
 27960			if v_1.Op != OpConst16 {
 27961				break
 27962			}
 27963			d := v_1.AuxInt
 27964			if !(0 <= c && c < d) {
 27965				break
 27966			}
 27967			v.reset(OpConstBool)
 27968			v.AuxInt = 1
 27969			return true
 27970		}
 27971		// match: (IsInBounds (And16 _ (Const16 [c])) (Const16 [d]))
 27972		// cond: 0 <= c && c < d
 27973		// result: (ConstBool [1])
 27974		for {
 27975			_ = v.Args[1]
 27976			v_0 := v.Args[0]
 27977			if v_0.Op != OpAnd16 {
 27978				break
 27979			}
 27980			_ = v_0.Args[1]
 27981			v_0_1 := v_0.Args[1]
 27982			if v_0_1.Op != OpConst16 {
 27983				break
 27984			}
 27985			c := v_0_1.AuxInt
 27986			v_1 := v.Args[1]
 27987			if v_1.Op != OpConst16 {
 27988				break
 27989			}
 27990			d := v_1.AuxInt
 27991			if !(0 <= c && c < d) {
 27992				break
 27993			}
 27994			v.reset(OpConstBool)
 27995			v.AuxInt = 1
 27996			return true
 27997		}
 27998		// match: (IsInBounds (ZeroExt16to32 (And16 (Const16 [c]) _)) (Const32 [d]))
 27999		// cond: 0 <= c && c < d
 28000		// result: (ConstBool [1])
 28001		for {
 28002			_ = v.Args[1]
 28003			v_0 := v.Args[0]
 28004			if v_0.Op != OpZeroExt16to32 {
 28005				break
 28006			}
 28007			v_0_0 := v_0.Args[0]
 28008			if v_0_0.Op != OpAnd16 {
 28009				break
 28010			}
 28011			_ = v_0_0.Args[1]
 28012			v_0_0_0 := v_0_0.Args[0]
 28013			if v_0_0_0.Op != OpConst16 {
 28014				break
 28015			}
 28016			c := v_0_0_0.AuxInt
 28017			v_1 := v.Args[1]
 28018			if v_1.Op != OpConst32 {
 28019				break
 28020			}
 28021			d := v_1.AuxInt
 28022			if !(0 <= c && c < d) {
 28023				break
 28024			}
 28025			v.reset(OpConstBool)
 28026			v.AuxInt = 1
 28027			return true
 28028		}
 28029		// match: (IsInBounds (ZeroExt16to32 (And16 _ (Const16 [c]))) (Const32 [d]))
 28030		// cond: 0 <= c && c < d
 28031		// result: (ConstBool [1])
 28032		for {
 28033			_ = v.Args[1]
 28034			v_0 := v.Args[0]
 28035			if v_0.Op != OpZeroExt16to32 {
 28036				break
 28037			}
 28038			v_0_0 := v_0.Args[0]
 28039			if v_0_0.Op != OpAnd16 {
 28040				break
 28041			}
 28042			_ = v_0_0.Args[1]
 28043			v_0_0_1 := v_0_0.Args[1]
 28044			if v_0_0_1.Op != OpConst16 {
 28045				break
 28046			}
 28047			c := v_0_0_1.AuxInt
 28048			v_1 := v.Args[1]
 28049			if v_1.Op != OpConst32 {
 28050				break
 28051			}
 28052			d := v_1.AuxInt
 28053			if !(0 <= c && c < d) {
 28054				break
 28055			}
 28056			v.reset(OpConstBool)
 28057			v.AuxInt = 1
 28058			return true
 28059		}
 28060		// match: (IsInBounds (ZeroExt16to64 (And16 (Const16 [c]) _)) (Const64 [d]))
 28061		// cond: 0 <= c && c < d
 28062		// result: (ConstBool [1])
 28063		for {
 28064			_ = v.Args[1]
 28065			v_0 := v.Args[0]
 28066			if v_0.Op != OpZeroExt16to64 {
 28067				break
 28068			}
 28069			v_0_0 := v_0.Args[0]
 28070			if v_0_0.Op != OpAnd16 {
 28071				break
 28072			}
 28073			_ = v_0_0.Args[1]
 28074			v_0_0_0 := v_0_0.Args[0]
 28075			if v_0_0_0.Op != OpConst16 {
 28076				break
 28077			}
 28078			c := v_0_0_0.AuxInt
 28079			v_1 := v.Args[1]
 28080			if v_1.Op != OpConst64 {
 28081				break
 28082			}
 28083			d := v_1.AuxInt
 28084			if !(0 <= c && c < d) {
 28085				break
 28086			}
 28087			v.reset(OpConstBool)
 28088			v.AuxInt = 1
 28089			return true
 28090		}
 28091		// match: (IsInBounds (ZeroExt16to64 (And16 _ (Const16 [c]))) (Const64 [d]))
 28092		// cond: 0 <= c && c < d
 28093		// result: (ConstBool [1])
 28094		for {
 28095			_ = v.Args[1]
 28096			v_0 := v.Args[0]
 28097			if v_0.Op != OpZeroExt16to64 {
 28098				break
 28099			}
 28100			v_0_0 := v_0.Args[0]
 28101			if v_0_0.Op != OpAnd16 {
 28102				break
 28103			}
 28104			_ = v_0_0.Args[1]
 28105			v_0_0_1 := v_0_0.Args[1]
 28106			if v_0_0_1.Op != OpConst16 {
 28107				break
 28108			}
 28109			c := v_0_0_1.AuxInt
 28110			v_1 := v.Args[1]
 28111			if v_1.Op != OpConst64 {
 28112				break
 28113			}
 28114			d := v_1.AuxInt
 28115			if !(0 <= c && c < d) {
 28116				break
 28117			}
 28118			v.reset(OpConstBool)
 28119			v.AuxInt = 1
 28120			return true
 28121		}
 28122		// match: (IsInBounds (And32 (Const32 [c]) _) (Const32 [d]))
 28123		// cond: 0 <= c && c < d
 28124		// result: (ConstBool [1])
 28125		for {
 28126			_ = v.Args[1]
 28127			v_0 := v.Args[0]
 28128			if v_0.Op != OpAnd32 {
 28129				break
 28130			}
 28131			_ = v_0.Args[1]
 28132			v_0_0 := v_0.Args[0]
 28133			if v_0_0.Op != OpConst32 {
 28134				break
 28135			}
 28136			c := v_0_0.AuxInt
 28137			v_1 := v.Args[1]
 28138			if v_1.Op != OpConst32 {
 28139				break
 28140			}
 28141			d := v_1.AuxInt
 28142			if !(0 <= c && c < d) {
 28143				break
 28144			}
 28145			v.reset(OpConstBool)
 28146			v.AuxInt = 1
 28147			return true
 28148		}
 28149		return false
 28150	}
 28151	func rewriteValuegeneric_OpIsInBounds_20(v *Value) bool {
 28152		// match: (IsInBounds (And32 _ (Const32 [c])) (Const32 [d]))
 28153		// cond: 0 <= c && c < d
 28154		// result: (ConstBool [1])
 28155		for {
 28156			_ = v.Args[1]
 28157			v_0 := v.Args[0]
 28158			if v_0.Op != OpAnd32 {
 28159				break
 28160			}
 28161			_ = v_0.Args[1]
 28162			v_0_1 := v_0.Args[1]
 28163			if v_0_1.Op != OpConst32 {
 28164				break
 28165			}
 28166			c := v_0_1.AuxInt
 28167			v_1 := v.Args[1]
 28168			if v_1.Op != OpConst32 {
 28169				break
 28170			}
 28171			d := v_1.AuxInt
 28172			if !(0 <= c && c < d) {
 28173				break
 28174			}
 28175			v.reset(OpConstBool)
 28176			v.AuxInt = 1
 28177			return true
 28178		}
 28179		// match: (IsInBounds (ZeroExt32to64 (And32 (Const32 [c]) _)) (Const64 [d]))
 28180		// cond: 0 <= c && c < d
 28181		// result: (ConstBool [1])
 28182		for {
 28183			_ = v.Args[1]
 28184			v_0 := v.Args[0]
 28185			if v_0.Op != OpZeroExt32to64 {
 28186				break
 28187			}
 28188			v_0_0 := v_0.Args[0]
 28189			if v_0_0.Op != OpAnd32 {
 28190				break
 28191			}
 28192			_ = v_0_0.Args[1]
 28193			v_0_0_0 := v_0_0.Args[0]
 28194			if v_0_0_0.Op != OpConst32 {
 28195				break
 28196			}
 28197			c := v_0_0_0.AuxInt
 28198			v_1 := v.Args[1]
 28199			if v_1.Op != OpConst64 {
 28200				break
 28201			}
 28202			d := v_1.AuxInt
 28203			if !(0 <= c && c < d) {
 28204				break
 28205			}
 28206			v.reset(OpConstBool)
 28207			v.AuxInt = 1
 28208			return true
 28209		}
 28210		// match: (IsInBounds (ZeroExt32to64 (And32 _ (Const32 [c]))) (Const64 [d]))
 28211		// cond: 0 <= c && c < d
 28212		// result: (ConstBool [1])
 28213		for {
 28214			_ = v.Args[1]
 28215			v_0 := v.Args[0]
 28216			if v_0.Op != OpZeroExt32to64 {
 28217				break
 28218			}
 28219			v_0_0 := v_0.Args[0]
 28220			if v_0_0.Op != OpAnd32 {
 28221				break
 28222			}
 28223			_ = v_0_0.Args[1]
 28224			v_0_0_1 := v_0_0.Args[1]
 28225			if v_0_0_1.Op != OpConst32 {
 28226				break
 28227			}
 28228			c := v_0_0_1.AuxInt
 28229			v_1 := v.Args[1]
 28230			if v_1.Op != OpConst64 {
 28231				break
 28232			}
 28233			d := v_1.AuxInt
 28234			if !(0 <= c && c < d) {
 28235				break
 28236			}
 28237			v.reset(OpConstBool)
 28238			v.AuxInt = 1
 28239			return true
 28240		}
 28241		// match: (IsInBounds (And64 (Const64 [c]) _) (Const64 [d]))
 28242		// cond: 0 <= c && c < d
 28243		// result: (ConstBool [1])
 28244		for {
 28245			_ = v.Args[1]
 28246			v_0 := v.Args[0]
 28247			if v_0.Op != OpAnd64 {
 28248				break
 28249			}
 28250			_ = v_0.Args[1]
 28251			v_0_0 := v_0.Args[0]
 28252			if v_0_0.Op != OpConst64 {
 28253				break
 28254			}
 28255			c := v_0_0.AuxInt
 28256			v_1 := v.Args[1]
 28257			if v_1.Op != OpConst64 {
 28258				break
 28259			}
 28260			d := v_1.AuxInt
 28261			if !(0 <= c && c < d) {
 28262				break
 28263			}
 28264			v.reset(OpConstBool)
 28265			v.AuxInt = 1
 28266			return true
 28267		}
 28268		// match: (IsInBounds (And64 _ (Const64 [c])) (Const64 [d]))
 28269		// cond: 0 <= c && c < d
 28270		// result: (ConstBool [1])
 28271		for {
 28272			_ = v.Args[1]
 28273			v_0 := v.Args[0]
 28274			if v_0.Op != OpAnd64 {
 28275				break
 28276			}
 28277			_ = v_0.Args[1]
 28278			v_0_1 := v_0.Args[1]
 28279			if v_0_1.Op != OpConst64 {
 28280				break
 28281			}
 28282			c := v_0_1.AuxInt
 28283			v_1 := v.Args[1]
 28284			if v_1.Op != OpConst64 {
 28285				break
 28286			}
 28287			d := v_1.AuxInt
 28288			if !(0 <= c && c < d) {
 28289				break
 28290			}
 28291			v.reset(OpConstBool)
 28292			v.AuxInt = 1
 28293			return true
 28294		}
 28295		// match: (IsInBounds (Const32 [c]) (Const32 [d]))
 28296		// cond:
 28297		// result: (ConstBool [b2i(0 <= c && c < d)])
 28298		for {
 28299			_ = v.Args[1]
 28300			v_0 := v.Args[0]
 28301			if v_0.Op != OpConst32 {
 28302				break
 28303			}
 28304			c := v_0.AuxInt
 28305			v_1 := v.Args[1]
 28306			if v_1.Op != OpConst32 {
 28307				break
 28308			}
 28309			d := v_1.AuxInt
 28310			v.reset(OpConstBool)
 28311			v.AuxInt = b2i(0 <= c && c < d)
 28312			return true
 28313		}
 28314		// match: (IsInBounds (Const64 [c]) (Const64 [d]))
 28315		// cond:
 28316		// result: (ConstBool [b2i(0 <= c && c < d)])
 28317		for {
 28318			_ = v.Args[1]
 28319			v_0 := v.Args[0]
 28320			if v_0.Op != OpConst64 {
 28321				break
 28322			}
 28323			c := v_0.AuxInt
 28324			v_1 := v.Args[1]
 28325			if v_1.Op != OpConst64 {
 28326				break
 28327			}
 28328			d := v_1.AuxInt
 28329			v.reset(OpConstBool)
 28330			v.AuxInt = b2i(0 <= c && c < d)
 28331			return true
 28332		}
 28333		// match: (IsInBounds (Mod32u _ y) y)
 28334		// cond:
 28335		// result: (ConstBool [1])
 28336		for {
 28337			y := v.Args[1]
 28338			v_0 := v.Args[0]
 28339			if v_0.Op != OpMod32u {
 28340				break
 28341			}
 28342			_ = v_0.Args[1]
 28343			if y != v_0.Args[1] {
 28344				break
 28345			}
 28346			v.reset(OpConstBool)
 28347			v.AuxInt = 1
 28348			return true
 28349		}
 28350		// match: (IsInBounds (Mod64u _ y) y)
 28351		// cond:
 28352		// result: (ConstBool [1])
 28353		for {
 28354			y := v.Args[1]
 28355			v_0 := v.Args[0]
 28356			if v_0.Op != OpMod64u {
 28357				break
 28358			}
 28359			_ = v_0.Args[1]
 28360			if y != v_0.Args[1] {
 28361				break
 28362			}
 28363			v.reset(OpConstBool)
 28364			v.AuxInt = 1
 28365			return true
 28366		}
 28367		// match: (IsInBounds (ZeroExt8to64 (Rsh8Ux64 _ (Const64 [c]))) (Const64 [d]))
 28368		// cond: 0 < c && c < 8 && 1<<uint( 8-c)-1 < d
 28369		// result: (ConstBool [1])
 28370		for {
 28371			_ = v.Args[1]
 28372			v_0 := v.Args[0]
 28373			if v_0.Op != OpZeroExt8to64 {
 28374				break
 28375			}
 28376			v_0_0 := v_0.Args[0]
 28377			if v_0_0.Op != OpRsh8Ux64 {
 28378				break
 28379			}
 28380			_ = v_0_0.Args[1]
 28381			v_0_0_1 := v_0_0.Args[1]
 28382			if v_0_0_1.Op != OpConst64 {
 28383				break
 28384			}
 28385			c := v_0_0_1.AuxInt
 28386			v_1 := v.Args[1]
 28387			if v_1.Op != OpConst64 {
 28388				break
 28389			}
 28390			d := v_1.AuxInt
 28391			if !(0 < c && c < 8 && 1<<uint(8-c)-1 < d) {
 28392				break
 28393			}
 28394			v.reset(OpConstBool)
 28395			v.AuxInt = 1
 28396			return true
 28397		}
 28398		return false
 28399	}
 28400	func rewriteValuegeneric_OpIsInBounds_30(v *Value) bool {
 28401		// match: (IsInBounds (ZeroExt8to32 (Rsh8Ux64 _ (Const64 [c]))) (Const32 [d]))
 28402		// cond: 0 < c && c < 8 && 1<<uint( 8-c)-1 < d
 28403		// result: (ConstBool [1])
 28404		for {
 28405			_ = v.Args[1]
 28406			v_0 := v.Args[0]
 28407			if v_0.Op != OpZeroExt8to32 {
 28408				break
 28409			}
 28410			v_0_0 := v_0.Args[0]
 28411			if v_0_0.Op != OpRsh8Ux64 {
 28412				break
 28413			}
 28414			_ = v_0_0.Args[1]
 28415			v_0_0_1 := v_0_0.Args[1]
 28416			if v_0_0_1.Op != OpConst64 {
 28417				break
 28418			}
 28419			c := v_0_0_1.AuxInt
 28420			v_1 := v.Args[1]
 28421			if v_1.Op != OpConst32 {
 28422				break
 28423			}
 28424			d := v_1.AuxInt
 28425			if !(0 < c && c < 8 && 1<<uint(8-c)-1 < d) {
 28426				break
 28427			}
 28428			v.reset(OpConstBool)
 28429			v.AuxInt = 1
 28430			return true
 28431		}
 28432		// match: (IsInBounds (ZeroExt8to16 (Rsh8Ux64 _ (Const64 [c]))) (Const16 [d]))
 28433		// cond: 0 < c && c < 8 && 1<<uint( 8-c)-1 < d
 28434		// result: (ConstBool [1])
 28435		for {
 28436			_ = v.Args[1]
 28437			v_0 := v.Args[0]
 28438			if v_0.Op != OpZeroExt8to16 {
 28439				break
 28440			}
 28441			v_0_0 := v_0.Args[0]
 28442			if v_0_0.Op != OpRsh8Ux64 {
 28443				break
 28444			}
 28445			_ = v_0_0.Args[1]
 28446			v_0_0_1 := v_0_0.Args[1]
 28447			if v_0_0_1.Op != OpConst64 {
 28448				break
 28449			}
 28450			c := v_0_0_1.AuxInt
 28451			v_1 := v.Args[1]
 28452			if v_1.Op != OpConst16 {
 28453				break
 28454			}
 28455			d := v_1.AuxInt
 28456			if !(0 < c && c < 8 && 1<<uint(8-c)-1 < d) {
 28457				break
 28458			}
 28459			v.reset(OpConstBool)
 28460			v.AuxInt = 1
 28461			return true
 28462		}
 28463		// match: (IsInBounds (Rsh8Ux64 _ (Const64 [c])) (Const64 [d]))
 28464		// cond: 0 < c && c < 8 && 1<<uint( 8-c)-1 < d
 28465		// result: (ConstBool [1])
 28466		for {
 28467			_ = v.Args[1]
 28468			v_0 := v.Args[0]
 28469			if v_0.Op != OpRsh8Ux64 {
 28470				break
 28471			}
 28472			_ = v_0.Args[1]
 28473			v_0_1 := v_0.Args[1]
 28474			if v_0_1.Op != OpConst64 {
 28475				break
 28476			}
 28477			c := v_0_1.AuxInt
 28478			v_1 := v.Args[1]
 28479			if v_1.Op != OpConst64 {
 28480				break
 28481			}
 28482			d := v_1.AuxInt
 28483			if !(0 < c && c < 8 && 1<<uint(8-c)-1 < d) {
 28484				break
 28485			}
 28486			v.reset(OpConstBool)
 28487			v.AuxInt = 1
 28488			return true
 28489		}
 28490		// match: (IsInBounds (ZeroExt16to64 (Rsh16Ux64 _ (Const64 [c]))) (Const64 [d]))
 28491		// cond: 0 < c && c < 16 && 1<<uint(16-c)-1 < d
 28492		// result: (ConstBool [1])
 28493		for {
 28494			_ = v.Args[1]
 28495			v_0 := v.Args[0]
 28496			if v_0.Op != OpZeroExt16to64 {
 28497				break
 28498			}
 28499			v_0_0 := v_0.Args[0]
 28500			if v_0_0.Op != OpRsh16Ux64 {
 28501				break
 28502			}
 28503			_ = v_0_0.Args[1]
 28504			v_0_0_1 := v_0_0.Args[1]
 28505			if v_0_0_1.Op != OpConst64 {
 28506				break
 28507			}
 28508			c := v_0_0_1.AuxInt
 28509			v_1 := v.Args[1]
 28510			if v_1.Op != OpConst64 {
 28511				break
 28512			}
 28513			d := v_1.AuxInt
 28514			if !(0 < c && c < 16 && 1<<uint(16-c)-1 < d) {
 28515				break
 28516			}
 28517			v.reset(OpConstBool)
 28518			v.AuxInt = 1
 28519			return true
 28520		}
 28521		// match: (IsInBounds (ZeroExt16to32 (Rsh16Ux64 _ (Const64 [c]))) (Const64 [d]))
 28522		// cond: 0 < c && c < 16 && 1<<uint(16-c)-1 < d
 28523		// result: (ConstBool [1])
 28524		for {
 28525			_ = v.Args[1]
 28526			v_0 := v.Args[0]
 28527			if v_0.Op != OpZeroExt16to32 {
 28528				break
 28529			}
 28530			v_0_0 := v_0.Args[0]
 28531			if v_0_0.Op != OpRsh16Ux64 {
 28532				break
 28533			}
 28534			_ = v_0_0.Args[1]
 28535			v_0_0_1 := v_0_0.Args[1]
 28536			if v_0_0_1.Op != OpConst64 {
 28537				break
 28538			}
 28539			c := v_0_0_1.AuxInt
 28540			v_1 := v.Args[1]
 28541			if v_1.Op != OpConst64 {
 28542				break
 28543			}
 28544			d := v_1.AuxInt
 28545			if !(0 < c && c < 16 && 1<<uint(16-c)-1 < d) {
 28546				break
 28547			}
 28548			v.reset(OpConstBool)
 28549			v.AuxInt = 1
 28550			return true
 28551		}
 28552		// match: (IsInBounds (Rsh16Ux64 _ (Const64 [c])) (Const64 [d]))
 28553		// cond: 0 < c && c < 16 && 1<<uint(16-c)-1 < d
 28554		// result: (ConstBool [1])
 28555		for {
 28556			_ = v.Args[1]
 28557			v_0 := v.Args[0]
 28558			if v_0.Op != OpRsh16Ux64 {
 28559				break
 28560			}
 28561			_ = v_0.Args[1]
 28562			v_0_1 := v_0.Args[1]
 28563			if v_0_1.Op != OpConst64 {
 28564				break
 28565			}
 28566			c := v_0_1.AuxInt
 28567			v_1 := v.Args[1]
 28568			if v_1.Op != OpConst64 {
 28569				break
 28570			}
 28571			d := v_1.AuxInt
 28572			if !(0 < c && c < 16 && 1<<uint(16-c)-1 < d) {
 28573				break
 28574			}
 28575			v.reset(OpConstBool)
 28576			v.AuxInt = 1
 28577			return true
 28578		}
 28579		// match: (IsInBounds (ZeroExt32to64 (Rsh32Ux64 _ (Const64 [c]))) (Const64 [d]))
 28580		// cond: 0 < c && c < 32 && 1<<uint(32-c)-1 < d
 28581		// result: (ConstBool [1])
 28582		for {
 28583			_ = v.Args[1]
 28584			v_0 := v.Args[0]
 28585			if v_0.Op != OpZeroExt32to64 {
 28586				break
 28587			}
 28588			v_0_0 := v_0.Args[0]
 28589			if v_0_0.Op != OpRsh32Ux64 {
 28590				break
 28591			}
 28592			_ = v_0_0.Args[1]
 28593			v_0_0_1 := v_0_0.Args[1]
 28594			if v_0_0_1.Op != OpConst64 {
 28595				break
 28596			}
 28597			c := v_0_0_1.AuxInt
 28598			v_1 := v.Args[1]
 28599			if v_1.Op != OpConst64 {
 28600				break
 28601			}
 28602			d := v_1.AuxInt
 28603			if !(0 < c && c < 32 && 1<<uint(32-c)-1 < d) {
 28604				break
 28605			}
 28606			v.reset(OpConstBool)
 28607			v.AuxInt = 1
 28608			return true
 28609		}
 28610		// match: (IsInBounds (Rsh32Ux64 _ (Const64 [c])) (Const64 [d]))
 28611		// cond: 0 < c && c < 32 && 1<<uint(32-c)-1 < d
 28612		// result: (ConstBool [1])
 28613		for {
 28614			_ = v.Args[1]
 28615			v_0 := v.Args[0]
 28616			if v_0.Op != OpRsh32Ux64 {
 28617				break
 28618			}
 28619			_ = v_0.Args[1]
 28620			v_0_1 := v_0.Args[1]
 28621			if v_0_1.Op != OpConst64 {
 28622				break
 28623			}
 28624			c := v_0_1.AuxInt
 28625			v_1 := v.Args[1]
 28626			if v_1.Op != OpConst64 {
 28627				break
 28628			}
 28629			d := v_1.AuxInt
 28630			if !(0 < c && c < 32 && 1<<uint(32-c)-1 < d) {
 28631				break
 28632			}
 28633			v.reset(OpConstBool)
 28634			v.AuxInt = 1
 28635			return true
 28636		}
 28637		// match: (IsInBounds (Rsh64Ux64 _ (Const64 [c])) (Const64 [d]))
 28638		// cond: 0 < c && c < 64 && 1<<uint(64-c)-1 < d
 28639		// result: (ConstBool [1])
 28640		for {
 28641			_ = v.Args[1]
 28642			v_0 := v.Args[0]
 28643			if v_0.Op != OpRsh64Ux64 {
 28644				break
 28645			}
 28646			_ = v_0.Args[1]
 28647			v_0_1 := v_0.Args[1]
 28648			if v_0_1.Op != OpConst64 {
 28649				break
 28650			}
 28651			c := v_0_1.AuxInt
 28652			v_1 := v.Args[1]
 28653			if v_1.Op != OpConst64 {
 28654				break
 28655			}
 28656			d := v_1.AuxInt
 28657			if !(0 < c && c < 64 && 1<<uint(64-c)-1 < d) {
 28658				break
 28659			}
 28660			v.reset(OpConstBool)
 28661			v.AuxInt = 1
 28662			return true
 28663		}
 28664		return false
 28665	}
 28666	func rewriteValuegeneric_OpIsNonNil_0(v *Value) bool {
 28667		// match: (IsNonNil (ConstNil))
 28668		// cond:
 28669		// result: (ConstBool [0])
 28670		for {
 28671			v_0 := v.Args[0]
 28672			if v_0.Op != OpConstNil {
 28673				break
 28674			}
 28675			v.reset(OpConstBool)
 28676			v.AuxInt = 0
 28677			return true
 28678		}
 28679		// match: (IsNonNil (Const32 [c]))
 28680		// cond:
 28681		// result: (ConstBool [b2i(c != 0)])
 28682		for {
 28683			v_0 := v.Args[0]
 28684			if v_0.Op != OpConst32 {
 28685				break
 28686			}
 28687			c := v_0.AuxInt
 28688			v.reset(OpConstBool)
 28689			v.AuxInt = b2i(c != 0)
 28690			return true
 28691		}
 28692		// match: (IsNonNil (Const64 [c]))
 28693		// cond:
 28694		// result: (ConstBool [b2i(c != 0)])
 28695		for {
 28696			v_0 := v.Args[0]
 28697			if v_0.Op != OpConst64 {
 28698				break
 28699			}
 28700			c := v_0.AuxInt
 28701			v.reset(OpConstBool)
 28702			v.AuxInt = b2i(c != 0)
 28703			return true
 28704		}
 28705		// match: (IsNonNil (Addr _))
 28706		// cond:
 28707		// result: (ConstBool [1])
 28708		for {
 28709			v_0 := v.Args[0]
 28710			if v_0.Op != OpAddr {
 28711				break
 28712			}
 28713			v.reset(OpConstBool)
 28714			v.AuxInt = 1
 28715			return true
 28716		}
 28717		// match: (IsNonNil (LocalAddr _ _))
 28718		// cond:
 28719		// result: (ConstBool [1])
 28720		for {
 28721			v_0 := v.Args[0]
 28722			if v_0.Op != OpLocalAddr {
 28723				break
 28724			}
 28725			_ = v_0.Args[1]
 28726			v.reset(OpConstBool)
 28727			v.AuxInt = 1
 28728			return true
 28729		}
 28730		return false
 28731	}
 28732	func rewriteValuegeneric_OpIsSliceInBounds_0(v *Value) bool {
 28733		// match: (IsSliceInBounds x x)
 28734		// cond:
 28735		// result: (ConstBool [1])
 28736		for {
 28737			x := v.Args[1]
 28738			if x != v.Args[0] {
 28739				break
 28740			}
 28741			v.reset(OpConstBool)
 28742			v.AuxInt = 1
 28743			return true
 28744		}
 28745		// match: (IsSliceInBounds (And32 (Const32 [c]) _) (Const32 [d]))
 28746		// cond: 0 <= c && c <= d
 28747		// result: (ConstBool [1])
 28748		for {
 28749			_ = v.Args[1]
 28750			v_0 := v.Args[0]
 28751			if v_0.Op != OpAnd32 {
 28752				break
 28753			}
 28754			_ = v_0.Args[1]
 28755			v_0_0 := v_0.Args[0]
 28756			if v_0_0.Op != OpConst32 {
 28757				break
 28758			}
 28759			c := v_0_0.AuxInt
 28760			v_1 := v.Args[1]
 28761			if v_1.Op != OpConst32 {
 28762				break
 28763			}
 28764			d := v_1.AuxInt
 28765			if !(0 <= c && c <= d) {
 28766				break
 28767			}
 28768			v.reset(OpConstBool)
 28769			v.AuxInt = 1
 28770			return true
 28771		}
 28772		// match: (IsSliceInBounds (And32 _ (Const32 [c])) (Const32 [d]))
 28773		// cond: 0 <= c && c <= d
 28774		// result: (ConstBool [1])
 28775		for {
 28776			_ = v.Args[1]
 28777			v_0 := v.Args[0]
 28778			if v_0.Op != OpAnd32 {
 28779				break
 28780			}
 28781			_ = v_0.Args[1]
 28782			v_0_1 := v_0.Args[1]
 28783			if v_0_1.Op != OpConst32 {
 28784				break
 28785			}
 28786			c := v_0_1.AuxInt
 28787			v_1 := v.Args[1]
 28788			if v_1.Op != OpConst32 {
 28789				break
 28790			}
 28791			d := v_1.AuxInt
 28792			if !(0 <= c && c <= d) {
 28793				break
 28794			}
 28795			v.reset(OpConstBool)
 28796			v.AuxInt = 1
 28797			return true
 28798		}
 28799		// match: (IsSliceInBounds (And64 (Const64 [c]) _) (Const64 [d]))
 28800		// cond: 0 <= c && c <= d
 28801		// result: (ConstBool [1])
 28802		for {
 28803			_ = v.Args[1]
 28804			v_0 := v.Args[0]
 28805			if v_0.Op != OpAnd64 {
 28806				break
 28807			}
 28808			_ = v_0.Args[1]
 28809			v_0_0 := v_0.Args[0]
 28810			if v_0_0.Op != OpConst64 {
 28811				break
 28812			}
 28813			c := v_0_0.AuxInt
 28814			v_1 := v.Args[1]
 28815			if v_1.Op != OpConst64 {
 28816				break
 28817			}
 28818			d := v_1.AuxInt
 28819			if !(0 <= c && c <= d) {
 28820				break
 28821			}
 28822			v.reset(OpConstBool)
 28823			v.AuxInt = 1
 28824			return true
 28825		}
 28826		// match: (IsSliceInBounds (And64 _ (Const64 [c])) (Const64 [d]))
 28827		// cond: 0 <= c && c <= d
 28828		// result: (ConstBool [1])
 28829		for {
 28830			_ = v.Args[1]
 28831			v_0 := v.Args[0]
 28832			if v_0.Op != OpAnd64 {
 28833				break
 28834			}
 28835			_ = v_0.Args[1]
 28836			v_0_1 := v_0.Args[1]
 28837			if v_0_1.Op != OpConst64 {
 28838				break
 28839			}
 28840			c := v_0_1.AuxInt
 28841			v_1 := v.Args[1]
 28842			if v_1.Op != OpConst64 {
 28843				break
 28844			}
 28845			d := v_1.AuxInt
 28846			if !(0 <= c && c <= d) {
 28847				break
 28848			}
 28849			v.reset(OpConstBool)
 28850			v.AuxInt = 1
 28851			return true
 28852		}
 28853		// match: (IsSliceInBounds (Const32 [0]) _)
 28854		// cond:
 28855		// result: (ConstBool [1])
 28856		for {
 28857			_ = v.Args[1]
 28858			v_0 := v.Args[0]
 28859			if v_0.Op != OpConst32 {
 28860				break
 28861			}
 28862			if v_0.AuxInt != 0 {
 28863				break
 28864			}
 28865			v.reset(OpConstBool)
 28866			v.AuxInt = 1
 28867			return true
 28868		}
 28869		// match: (IsSliceInBounds (Const64 [0]) _)
 28870		// cond:
 28871		// result: (ConstBool [1])
 28872		for {
 28873			_ = v.Args[1]
 28874			v_0 := v.Args[0]
 28875			if v_0.Op != OpConst64 {
 28876				break
 28877			}
 28878			if v_0.AuxInt != 0 {
 28879				break
 28880			}
 28881			v.reset(OpConstBool)
 28882			v.AuxInt = 1
 28883			return true
 28884		}
 28885		// match: (IsSliceInBounds (Const32 [c]) (Const32 [d]))
 28886		// cond:
 28887		// result: (ConstBool [b2i(0 <= c && c <= d)])
 28888		for {
 28889			_ = v.Args[1]
 28890			v_0 := v.Args[0]
 28891			if v_0.Op != OpConst32 {
 28892				break
 28893			}
 28894			c := v_0.AuxInt
 28895			v_1 := v.Args[1]
 28896			if v_1.Op != OpConst32 {
 28897				break
 28898			}
 28899			d := v_1.AuxInt
 28900			v.reset(OpConstBool)
 28901			v.AuxInt = b2i(0 <= c && c <= d)
 28902			return true
 28903		}
 28904		// match: (IsSliceInBounds (Const64 [c]) (Const64 [d]))
 28905		// cond:
 28906		// result: (ConstBool [b2i(0 <= c && c <= d)])
 28907		for {
 28908			_ = v.Args[1]
 28909			v_0 := v.Args[0]
 28910			if v_0.Op != OpConst64 {
 28911				break
 28912			}
 28913			c := v_0.AuxInt
 28914			v_1 := v.Args[1]
 28915			if v_1.Op != OpConst64 {
 28916				break
 28917			}
 28918			d := v_1.AuxInt
 28919			v.reset(OpConstBool)
 28920			v.AuxInt = b2i(0 <= c && c <= d)
 28921			return true
 28922		}
 28923		// match: (IsSliceInBounds (SliceLen x) (SliceCap x))
 28924		// cond:
 28925		// result: (ConstBool [1])
 28926		for {
 28927			_ = v.Args[1]
 28928			v_0 := v.Args[0]
 28929			if v_0.Op != OpSliceLen {
 28930				break
 28931			}
 28932			x := v_0.Args[0]
 28933			v_1 := v.Args[1]
 28934			if v_1.Op != OpSliceCap {
 28935				break
 28936			}
 28937			if x != v_1.Args[0] {
 28938				break
 28939			}
 28940			v.reset(OpConstBool)
 28941			v.AuxInt = 1
 28942			return true
 28943		}
 28944		return false
 28945	}
 28946	func rewriteValuegeneric_OpLeq16_0(v *Value) bool {
 28947		// match: (Leq16 (Const16 [c]) (Const16 [d]))
 28948		// cond:
 28949		// result: (ConstBool [b2i(c <= d)])
 28950		for {
 28951			_ = v.Args[1]
 28952			v_0 := v.Args[0]
 28953			if v_0.Op != OpConst16 {
 28954				break
 28955			}
 28956			c := v_0.AuxInt
 28957			v_1 := v.Args[1]
 28958			if v_1.Op != OpConst16 {
 28959				break
 28960			}
 28961			d := v_1.AuxInt
 28962			v.reset(OpConstBool)
 28963			v.AuxInt = b2i(c <= d)
 28964			return true
 28965		}
 28966		return false
 28967	}
 28968	func rewriteValuegeneric_OpLeq16U_0(v *Value) bool {
 28969		// match: (Leq16U (Const16 [c]) (Const16 [d]))
 28970		// cond:
 28971		// result: (ConstBool [b2i(uint16(c) <= uint16(d))])
 28972		for {
 28973			_ = v.Args[1]
 28974			v_0 := v.Args[0]
 28975			if v_0.Op != OpConst16 {
 28976				break
 28977			}
 28978			c := v_0.AuxInt
 28979			v_1 := v.Args[1]
 28980			if v_1.Op != OpConst16 {
 28981				break
 28982			}
 28983			d := v_1.AuxInt
 28984			v.reset(OpConstBool)
 28985			v.AuxInt = b2i(uint16(c) <= uint16(d))
 28986			return true
 28987		}
 28988		return false
 28989	}
 28990	func rewriteValuegeneric_OpLeq32_0(v *Value) bool {
 28991		// match: (Leq32 (Const32 [c]) (Const32 [d]))
 28992		// cond:
 28993		// result: (ConstBool [b2i(c <= d)])
 28994		for {
 28995			_ = v.Args[1]
 28996			v_0 := v.Args[0]
 28997			if v_0.Op != OpConst32 {
 28998				break
 28999			}
 29000			c := v_0.AuxInt
 29001			v_1 := v.Args[1]
 29002			if v_1.Op != OpConst32 {
 29003				break
 29004			}
 29005			d := v_1.AuxInt
 29006			v.reset(OpConstBool)
 29007			v.AuxInt = b2i(c <= d)
 29008			return true
 29009		}
 29010		return false
 29011	}
 29012	func rewriteValuegeneric_OpLeq32F_0(v *Value) bool {
 29013		// match: (Leq32F (Const32F [c]) (Const32F [d]))
 29014		// cond:
 29015		// result: (ConstBool [b2i(auxTo32F(c) <= auxTo32F(d))])
 29016		for {
 29017			_ = v.Args[1]
 29018			v_0 := v.Args[0]
 29019			if v_0.Op != OpConst32F {
 29020				break
 29021			}
 29022			c := v_0.AuxInt
 29023			v_1 := v.Args[1]
 29024			if v_1.Op != OpConst32F {
 29025				break
 29026			}
 29027			d := v_1.AuxInt
 29028			v.reset(OpConstBool)
 29029			v.AuxInt = b2i(auxTo32F(c) <= auxTo32F(d))
 29030			return true
 29031		}
 29032		return false
 29033	}
 29034	func rewriteValuegeneric_OpLeq32U_0(v *Value) bool {
 29035		// match: (Leq32U (Const32 [c]) (Const32 [d]))
 29036		// cond:
 29037		// result: (ConstBool [b2i(uint32(c) <= uint32(d))])
 29038		for {
 29039			_ = v.Args[1]
 29040			v_0 := v.Args[0]
 29041			if v_0.Op != OpConst32 {
 29042				break
 29043			}
 29044			c := v_0.AuxInt
 29045			v_1 := v.Args[1]
 29046			if v_1.Op != OpConst32 {
 29047				break
 29048			}
 29049			d := v_1.AuxInt
 29050			v.reset(OpConstBool)
 29051			v.AuxInt = b2i(uint32(c) <= uint32(d))
 29052			return true
 29053		}
 29054		return false
 29055	}
 29056	func rewriteValuegeneric_OpLeq64_0(v *Value) bool {
 29057		// match: (Leq64 (Const64 [c]) (Const64 [d]))
 29058		// cond:
 29059		// result: (ConstBool [b2i(c <= d)])
 29060		for {
 29061			_ = v.Args[1]
 29062			v_0 := v.Args[0]
 29063			if v_0.Op != OpConst64 {
 29064				break
 29065			}
 29066			c := v_0.AuxInt
 29067			v_1 := v.Args[1]
 29068			if v_1.Op != OpConst64 {
 29069				break
 29070			}
 29071			d := v_1.AuxInt
 29072			v.reset(OpConstBool)
 29073			v.AuxInt = b2i(c <= d)
 29074			return true
 29075		}
 29076		return false
 29077	}
 29078	func rewriteValuegeneric_OpLeq64F_0(v *Value) bool {
 29079		// match: (Leq64F (Const64F [c]) (Const64F [d]))
 29080		// cond:
 29081		// result: (ConstBool [b2i(auxTo64F(c) <= auxTo64F(d))])
 29082		for {
 29083			_ = v.Args[1]
 29084			v_0 := v.Args[0]
 29085			if v_0.Op != OpConst64F {
 29086				break
 29087			}
 29088			c := v_0.AuxInt
 29089			v_1 := v.Args[1]
 29090			if v_1.Op != OpConst64F {
 29091				break
 29092			}
 29093			d := v_1.AuxInt
 29094			v.reset(OpConstBool)
 29095			v.AuxInt = b2i(auxTo64F(c) <= auxTo64F(d))
 29096			return true
 29097		}
 29098		return false
 29099	}
 29100	func rewriteValuegeneric_OpLeq64U_0(v *Value) bool {
 29101		// match: (Leq64U (Const64 [c]) (Const64 [d]))
 29102		// cond:
 29103		// result: (ConstBool [b2i(uint64(c) <= uint64(d))])
 29104		for {
 29105			_ = v.Args[1]
 29106			v_0 := v.Args[0]
 29107			if v_0.Op != OpConst64 {
 29108				break
 29109			}
 29110			c := v_0.AuxInt
 29111			v_1 := v.Args[1]
 29112			if v_1.Op != OpConst64 {
 29113				break
 29114			}
 29115			d := v_1.AuxInt
 29116			v.reset(OpConstBool)
 29117			v.AuxInt = b2i(uint64(c) <= uint64(d))
 29118			return true
 29119		}
 29120		return false
 29121	}
 29122	func rewriteValuegeneric_OpLeq8_0(v *Value) bool {
 29123		// match: (Leq8 (Const8 [c]) (Const8 [d]))
 29124		// cond:
 29125		// result: (ConstBool [b2i(c <= d)])
 29126		for {
 29127			_ = v.Args[1]
 29128			v_0 := v.Args[0]
 29129			if v_0.Op != OpConst8 {
 29130				break
 29131			}
 29132			c := v_0.AuxInt
 29133			v_1 := v.Args[1]
 29134			if v_1.Op != OpConst8 {
 29135				break
 29136			}
 29137			d := v_1.AuxInt
 29138			v.reset(OpConstBool)
 29139			v.AuxInt = b2i(c <= d)
 29140			return true
 29141		}
 29142		return false
 29143	}
 29144	func rewriteValuegeneric_OpLeq8U_0(v *Value) bool {
 29145		// match: (Leq8U (Const8 [c]) (Const8 [d]))
 29146		// cond:
 29147		// result: (ConstBool [b2i(uint8(c) <= uint8(d))])
 29148		for {
 29149			_ = v.Args[1]
 29150			v_0 := v.Args[0]
 29151			if v_0.Op != OpConst8 {
 29152				break
 29153			}
 29154			c := v_0.AuxInt
 29155			v_1 := v.Args[1]
 29156			if v_1.Op != OpConst8 {
 29157				break
 29158			}
 29159			d := v_1.AuxInt
 29160			v.reset(OpConstBool)
 29161			v.AuxInt = b2i(uint8(c) <= uint8(d))
 29162			return true
 29163		}
 29164		return false
 29165	}
 29166	func rewriteValuegeneric_OpLess16_0(v *Value) bool {
 29167		// match: (Less16 (Const16 [c]) (Const16 [d]))
 29168		// cond:
 29169		// result: (ConstBool [b2i(c < d)])
 29170		for {
 29171			_ = v.Args[1]
 29172			v_0 := v.Args[0]
 29173			if v_0.Op != OpConst16 {
 29174				break
 29175			}
 29176			c := v_0.AuxInt
 29177			v_1 := v.Args[1]
 29178			if v_1.Op != OpConst16 {
 29179				break
 29180			}
 29181			d := v_1.AuxInt
 29182			v.reset(OpConstBool)
 29183			v.AuxInt = b2i(c < d)
 29184			return true
 29185		}
 29186		return false
 29187	}
 29188	func rewriteValuegeneric_OpLess16U_0(v *Value) bool {
 29189		// match: (Less16U (Const16 [c]) (Const16 [d]))
 29190		// cond:
 29191		// result: (ConstBool [b2i(uint16(c) < uint16(d))])
 29192		for {
 29193			_ = v.Args[1]
 29194			v_0 := v.Args[0]
 29195			if v_0.Op != OpConst16 {
 29196				break
 29197			}
 29198			c := v_0.AuxInt
 29199			v_1 := v.Args[1]
 29200			if v_1.Op != OpConst16 {
 29201				break
 29202			}
 29203			d := v_1.AuxInt
 29204			v.reset(OpConstBool)
 29205			v.AuxInt = b2i(uint16(c) < uint16(d))
 29206			return true
 29207		}
 29208		return false
 29209	}
 29210	func rewriteValuegeneric_OpLess32_0(v *Value) bool {
 29211		// match: (Less32 (Const32 [c]) (Const32 [d]))
 29212		// cond:
 29213		// result: (ConstBool [b2i(c < d)])
 29214		for {
 29215			_ = v.Args[1]
 29216			v_0 := v.Args[0]
 29217			if v_0.Op != OpConst32 {
 29218				break
 29219			}
 29220			c := v_0.AuxInt
 29221			v_1 := v.Args[1]
 29222			if v_1.Op != OpConst32 {
 29223				break
 29224			}
 29225			d := v_1.AuxInt
 29226			v.reset(OpConstBool)
 29227			v.AuxInt = b2i(c < d)
 29228			return true
 29229		}
 29230		return false
 29231	}
 29232	func rewriteValuegeneric_OpLess32F_0(v *Value) bool {
 29233		// match: (Less32F (Const32F [c]) (Const32F [d]))
 29234		// cond:
 29235		// result: (ConstBool [b2i(auxTo32F(c) < auxTo32F(d))])
 29236		for {
 29237			_ = v.Args[1]
 29238			v_0 := v.Args[0]
 29239			if v_0.Op != OpConst32F {
 29240				break
 29241			}
 29242			c := v_0.AuxInt
 29243			v_1 := v.Args[1]
 29244			if v_1.Op != OpConst32F {
 29245				break
 29246			}
 29247			d := v_1.AuxInt
 29248			v.reset(OpConstBool)
 29249			v.AuxInt = b2i(auxTo32F(c) < auxTo32F(d))
 29250			return true
 29251		}
 29252		return false
 29253	}
 29254	func rewriteValuegeneric_OpLess32U_0(v *Value) bool {
 29255		// match: (Less32U (Const32 [c]) (Const32 [d]))
 29256		// cond:
 29257		// result: (ConstBool [b2i(uint32(c) < uint32(d))])
 29258		for {
 29259			_ = v.Args[1]
 29260			v_0 := v.Args[0]
 29261			if v_0.Op != OpConst32 {
 29262				break
 29263			}
 29264			c := v_0.AuxInt
 29265			v_1 := v.Args[1]
 29266			if v_1.Op != OpConst32 {
 29267				break
 29268			}
 29269			d := v_1.AuxInt
 29270			v.reset(OpConstBool)
 29271			v.AuxInt = b2i(uint32(c) < uint32(d))
 29272			return true
 29273		}
 29274		return false
 29275	}
 29276	func rewriteValuegeneric_OpLess64_0(v *Value) bool {
 29277		// match: (Less64 (Const64 [c]) (Const64 [d]))
 29278		// cond:
 29279		// result: (ConstBool [b2i(c < d)])
 29280		for {
 29281			_ = v.Args[1]
 29282			v_0 := v.Args[0]
 29283			if v_0.Op != OpConst64 {
 29284				break
 29285			}
 29286			c := v_0.AuxInt
 29287			v_1 := v.Args[1]
 29288			if v_1.Op != OpConst64 {
 29289				break
 29290			}
 29291			d := v_1.AuxInt
 29292			v.reset(OpConstBool)
 29293			v.AuxInt = b2i(c < d)
 29294			return true
 29295		}
 29296		return false
 29297	}
 29298	func rewriteValuegeneric_OpLess64F_0(v *Value) bool {
 29299		// match: (Less64F (Const64F [c]) (Const64F [d]))
 29300		// cond:
 29301		// result: (ConstBool [b2i(auxTo64F(c) < auxTo64F(d))])
 29302		for {
 29303			_ = v.Args[1]
 29304			v_0 := v.Args[0]
 29305			if v_0.Op != OpConst64F {
 29306				break
 29307			}
 29308			c := v_0.AuxInt
 29309			v_1 := v.Args[1]
 29310			if v_1.Op != OpConst64F {
 29311				break
 29312			}
 29313			d := v_1.AuxInt
 29314			v.reset(OpConstBool)
 29315			v.AuxInt = b2i(auxTo64F(c) < auxTo64F(d))
 29316			return true
 29317		}
 29318		return false
 29319	}
 29320	func rewriteValuegeneric_OpLess64U_0(v *Value) bool {
 29321		// match: (Less64U (Const64 [c]) (Const64 [d]))
 29322		// cond:
 29323		// result: (ConstBool [b2i(uint64(c) < uint64(d))])
 29324		for {
 29325			_ = v.Args[1]
 29326			v_0 := v.Args[0]
 29327			if v_0.Op != OpConst64 {
 29328				break
 29329			}
 29330			c := v_0.AuxInt
 29331			v_1 := v.Args[1]
 29332			if v_1.Op != OpConst64 {
 29333				break
 29334			}
 29335			d := v_1.AuxInt
 29336			v.reset(OpConstBool)
 29337			v.AuxInt = b2i(uint64(c) < uint64(d))
 29338			return true
 29339		}
 29340		return false
 29341	}
 29342	func rewriteValuegeneric_OpLess8_0(v *Value) bool {
 29343		// match: (Less8 (Const8 [c]) (Const8 [d]))
 29344		// cond:
 29345		// result: (ConstBool [b2i(c < d)])
 29346		for {
 29347			_ = v.Args[1]
 29348			v_0 := v.Args[0]
 29349			if v_0.Op != OpConst8 {
 29350				break
 29351			}
 29352			c := v_0.AuxInt
 29353			v_1 := v.Args[1]
 29354			if v_1.Op != OpConst8 {
 29355				break
 29356			}
 29357			d := v_1.AuxInt
 29358			v.reset(OpConstBool)
 29359			v.AuxInt = b2i(c < d)
 29360			return true
 29361		}
 29362		return false
 29363	}
 29364	func rewriteValuegeneric_OpLess8U_0(v *Value) bool {
 29365		// match: (Less8U (Const8 [c]) (Const8 [d]))
 29366		// cond:
 29367		// result: (ConstBool [b2i(uint8(c) < uint8(d))])
 29368		for {
 29369			_ = v.Args[1]
 29370			v_0 := v.Args[0]
 29371			if v_0.Op != OpConst8 {
 29372				break
 29373			}
 29374			c := v_0.AuxInt
 29375			v_1 := v.Args[1]
 29376			if v_1.Op != OpConst8 {
 29377				break
 29378			}
 29379			d := v_1.AuxInt
 29380			v.reset(OpConstBool)
 29381			v.AuxInt = b2i(uint8(c) < uint8(d))
 29382			return true
 29383		}
 29384		return false
 29385	}
 29386	func rewriteValuegeneric_OpLoad_0(v *Value) bool {
 29387		b := v.Block
 29388		fe := b.Func.fe
 29389		// match: (Load <t1> p1 (Store {t2} p2 x _))
 29390		// cond: isSamePtr(p1, p2) && t1.Compare(x.Type) == types.CMPeq && t1.Size() == sizeof(t2)
 29391		// result: x
 29392		for {
 29393			t1 := v.Type
 29394			_ = v.Args[1]
 29395			p1 := v.Args[0]
 29396			v_1 := v.Args[1]
 29397			if v_1.Op != OpStore {
 29398				break
 29399			}
 29400			t2 := v_1.Aux
 29401			_ = v_1.Args[2]
 29402			p2 := v_1.Args[0]
 29403			x := v_1.Args[1]
 29404			if !(isSamePtr(p1, p2) && t1.Compare(x.Type) == types.CMPeq && t1.Size() == sizeof(t2)) {
 29405				break
 29406			}
 29407			v.reset(OpCopy)
 29408			v.Type = x.Type
 29409			v.AddArg(x)
 29410			return true
 29411		}
 29412		// match: (Load <t1> p1 (Store {t2} p2 _ (Store {t3} p3 x _)))
 29413		// cond: isSamePtr(p1, p3) && t1.Compare(x.Type) == types.CMPeq && t1.Size() == sizeof(t2) && disjoint(p3, sizeof(t3), p2, sizeof(t2))
 29414		// result: x
 29415		for {
 29416			t1 := v.Type
 29417			_ = v.Args[1]
 29418			p1 := v.Args[0]
 29419			v_1 := v.Args[1]
 29420			if v_1.Op != OpStore {
 29421				break
 29422			}
 29423			t2 := v_1.Aux
 29424			_ = v_1.Args[2]
 29425			p2 := v_1.Args[0]
 29426			v_1_2 := v_1.Args[2]
 29427			if v_1_2.Op != OpStore {
 29428				break
 29429			}
 29430			t3 := v_1_2.Aux
 29431			_ = v_1_2.Args[2]
 29432			p3 := v_1_2.Args[0]
 29433			x := v_1_2.Args[1]
 29434			if !(isSamePtr(p1, p3) && t1.Compare(x.Type) == types.CMPeq && t1.Size() == sizeof(t2) && disjoint(p3, sizeof(t3), p2, sizeof(t2))) {
 29435				break
 29436			}
 29437			v.reset(OpCopy)
 29438			v.Type = x.Type
 29439			v.AddArg(x)
 29440			return true
 29441		}
 29442		// match: (Load <t1> p1 (Store {t2} p2 _ (Store {t3} p3 _ (Store {t4} p4 x _))))
 29443		// cond: isSamePtr(p1, p4) && t1.Compare(x.Type) == types.CMPeq && t1.Size() == sizeof(t2) && disjoint(p4, sizeof(t4), p2, sizeof(t2)) && disjoint(p4, sizeof(t4), p3, sizeof(t3))
 29444		// result: x
 29445		for {
 29446			t1 := v.Type
 29447			_ = v.Args[1]
 29448			p1 := v.Args[0]
 29449			v_1 := v.Args[1]
 29450			if v_1.Op != OpStore {
 29451				break
 29452			}
 29453			t2 := v_1.Aux
 29454			_ = v_1.Args[2]
 29455			p2 := v_1.Args[0]
 29456			v_1_2 := v_1.Args[2]
 29457			if v_1_2.Op != OpStore {
 29458				break
 29459			}
 29460			t3 := v_1_2.Aux
 29461			_ = v_1_2.Args[2]
 29462			p3 := v_1_2.Args[0]
 29463			v_1_2_2 := v_1_2.Args[2]
 29464			if v_1_2_2.Op != OpStore {
 29465				break
 29466			}
 29467			t4 := v_1_2_2.Aux
 29468			_ = v_1_2_2.Args[2]
 29469			p4 := v_1_2_2.Args[0]
 29470			x := v_1_2_2.Args[1]
 29471			if !(isSamePtr(p1, p4) && t1.Compare(x.Type) == types.CMPeq && t1.Size() == sizeof(t2) && disjoint(p4, sizeof(t4), p2, sizeof(t2)) && disjoint(p4, sizeof(t4), p3, sizeof(t3))) {
 29472				break
 29473			}
 29474			v.reset(OpCopy)
 29475			v.Type = x.Type
 29476			v.AddArg(x)
 29477			return true
 29478		}
 29479		// match: (Load <t1> p1 (Store {t2} p2 _ (Store {t3} p3 _ (Store {t4} p4 _ (Store {t5} p5 x _)))))
 29480		// cond: isSamePtr(p1, p5) && t1.Compare(x.Type) == types.CMPeq && t1.Size() == sizeof(t2) && disjoint(p5, sizeof(t5), p2, sizeof(t2)) && disjoint(p5, sizeof(t5), p3, sizeof(t3)) && disjoint(p5, sizeof(t5), p4, sizeof(t4))
 29481		// result: x
 29482		for {
 29483			t1 := v.Type
 29484			_ = v.Args[1]
 29485			p1 := v.Args[0]
 29486			v_1 := v.Args[1]
 29487			if v_1.Op != OpStore {
 29488				break
 29489			}
 29490			t2 := v_1.Aux
 29491			_ = v_1.Args[2]
 29492			p2 := v_1.Args[0]
 29493			v_1_2 := v_1.Args[2]
 29494			if v_1_2.Op != OpStore {
 29495				break
 29496			}
 29497			t3 := v_1_2.Aux
 29498			_ = v_1_2.Args[2]
 29499			p3 := v_1_2.Args[0]
 29500			v_1_2_2 := v_1_2.Args[2]
 29501			if v_1_2_2.Op != OpStore {
 29502				break
 29503			}
 29504			t4 := v_1_2_2.Aux
 29505			_ = v_1_2_2.Args[2]
 29506			p4 := v_1_2_2.Args[0]
 29507			v_1_2_2_2 := v_1_2_2.Args[2]
 29508			if v_1_2_2_2.Op != OpStore {
 29509				break
 29510			}
 29511			t5 := v_1_2_2_2.Aux
 29512			_ = v_1_2_2_2.Args[2]
 29513			p5 := v_1_2_2_2.Args[0]
 29514			x := v_1_2_2_2.Args[1]
 29515			if !(isSamePtr(p1, p5) && t1.Compare(x.Type) == types.CMPeq && t1.Size() == sizeof(t2) && disjoint(p5, sizeof(t5), p2, sizeof(t2)) && disjoint(p5, sizeof(t5), p3, sizeof(t3)) && disjoint(p5, sizeof(t5), p4, sizeof(t4))) {
 29516				break
 29517			}
 29518			v.reset(OpCopy)
 29519			v.Type = x.Type
 29520			v.AddArg(x)
 29521			return true
 29522		}
 29523		// match: (Load <t1> p1 (Store {t2} p2 (Const64 [x]) _))
 29524		// cond: isSamePtr(p1,p2) && sizeof(t2) == 8 && is64BitFloat(t1)
 29525		// result: (Const64F [x])
 29526		for {
 29527			t1 := v.Type
 29528			_ = v.Args[1]
 29529			p1 := v.Args[0]
 29530			v_1 := v.Args[1]
 29531			if v_1.Op != OpStore {
 29532				break
 29533			}
 29534			t2 := v_1.Aux
 29535			_ = v_1.Args[2]
 29536			p2 := v_1.Args[0]
 29537			v_1_1 := v_1.Args[1]
 29538			if v_1_1.Op != OpConst64 {
 29539				break
 29540			}
 29541			x := v_1_1.AuxInt
 29542			if !(isSamePtr(p1, p2) && sizeof(t2) == 8 && is64BitFloat(t1)) {
 29543				break
 29544			}
 29545			v.reset(OpConst64F)
 29546			v.AuxInt = x
 29547			return true
 29548		}
 29549		// match: (Load <t1> p1 (Store {t2} p2 (Const32 [x]) _))
 29550		// cond: isSamePtr(p1,p2) && sizeof(t2) == 4 && is32BitFloat(t1)
 29551		// result: (Const32F [auxFrom32F(math.Float32frombits(uint32(x)))])
 29552		for {
 29553			t1 := v.Type
 29554			_ = v.Args[1]
 29555			p1 := v.Args[0]
 29556			v_1 := v.Args[1]
 29557			if v_1.Op != OpStore {
 29558				break
 29559			}
 29560			t2 := v_1.Aux
 29561			_ = v_1.Args[2]
 29562			p2 := v_1.Args[0]
 29563			v_1_1 := v_1.Args[1]
 29564			if v_1_1.Op != OpConst32 {
 29565				break
 29566			}
 29567			x := v_1_1.AuxInt
 29568			if !(isSamePtr(p1, p2) && sizeof(t2) == 4 && is32BitFloat(t1)) {
 29569				break
 29570			}
 29571			v.reset(OpConst32F)
 29572			v.AuxInt = auxFrom32F(math.Float32frombits(uint32(x)))
 29573			return true
 29574		}
 29575		// match: (Load <t1> p1 (Store {t2} p2 (Const64F [x]) _))
 29576		// cond: isSamePtr(p1,p2) && sizeof(t2) == 8 && is64BitInt(t1)
 29577		// result: (Const64 [x])
 29578		for {
 29579			t1 := v.Type
 29580			_ = v.Args[1]
 29581			p1 := v.Args[0]
 29582			v_1 := v.Args[1]
 29583			if v_1.Op != OpStore {
 29584				break
 29585			}
 29586			t2 := v_1.Aux
 29587			_ = v_1.Args[2]
 29588			p2 := v_1.Args[0]
 29589			v_1_1 := v_1.Args[1]
 29590			if v_1_1.Op != OpConst64F {
 29591				break
 29592			}
 29593			x := v_1_1.AuxInt
 29594			if !(isSamePtr(p1, p2) && sizeof(t2) == 8 && is64BitInt(t1)) {
 29595				break
 29596			}
 29597			v.reset(OpConst64)
 29598			v.AuxInt = x
 29599			return true
 29600		}
 29601		// match: (Load <t1> p1 (Store {t2} p2 (Const32F [x]) _))
 29602		// cond: isSamePtr(p1,p2) && sizeof(t2) == 4 && is32BitInt(t1)
 29603		// result: (Const32 [int64(int32(math.Float32bits(auxTo32F(x))))])
 29604		for {
 29605			t1 := v.Type
 29606			_ = v.Args[1]
 29607			p1 := v.Args[0]
 29608			v_1 := v.Args[1]
 29609			if v_1.Op != OpStore {
 29610				break
 29611			}
 29612			t2 := v_1.Aux
 29613			_ = v_1.Args[2]
 29614			p2 := v_1.Args[0]
 29615			v_1_1 := v_1.Args[1]
 29616			if v_1_1.Op != OpConst32F {
 29617				break
 29618			}
 29619			x := v_1_1.AuxInt
 29620			if !(isSamePtr(p1, p2) && sizeof(t2) == 4 && is32BitInt(t1)) {
 29621				break
 29622			}
 29623			v.reset(OpConst32)
 29624			v.AuxInt = int64(int32(math.Float32bits(auxTo32F(x))))
 29625			return true
 29626		}
 29627		// match: (Load <t1> op:(OffPtr [o1] p1) (Store {t2} p2 _ mem:(Zero [n] p3 _)))
 29628		// cond: o1 >= 0 && o1+t1.Size() <= n && isSamePtr(p1, p3) && fe.CanSSA(t1) && disjoint(op, t1.Size(), p2, sizeof(t2))
 29629		// result: @mem.Block (Load <t1> (OffPtr <op.Type> [o1] p3) mem)
 29630		for {
 29631			t1 := v.Type
 29632			_ = v.Args[1]
 29633			op := v.Args[0]
 29634			if op.Op != OpOffPtr {
 29635				break
 29636			}
 29637			o1 := op.AuxInt
 29638			p1 := op.Args[0]
 29639			v_1 := v.Args[1]
 29640			if v_1.Op != OpStore {
 29641				break
 29642			}
 29643			t2 := v_1.Aux
 29644			_ = v_1.Args[2]
 29645			p2 := v_1.Args[0]
 29646			mem := v_1.Args[2]
 29647			if mem.Op != OpZero {
 29648				break
 29649			}
 29650			n := mem.AuxInt
 29651			_ = mem.Args[1]
 29652			p3 := mem.Args[0]
 29653			if !(o1 >= 0 && o1+t1.Size() <= n && isSamePtr(p1, p3) && fe.CanSSA(t1) && disjoint(op, t1.Size(), p2, sizeof(t2))) {
 29654				break
 29655			}
 29656			b = mem.Block
 29657			v0 := b.NewValue0(v.Pos, OpLoad, t1)
 29658			v.reset(OpCopy)
 29659			v.AddArg(v0)
 29660			v1 := b.NewValue0(v.Pos, OpOffPtr, op.Type)
 29661			v1.AuxInt = o1
 29662			v1.AddArg(p3)
 29663			v0.AddArg(v1)
 29664			v0.AddArg(mem)
 29665			return true
 29666		}
 29667		// match: (Load <t1> op:(OffPtr [o1] p1) (Store {t2} p2 _ (Store {t3} p3 _ mem:(Zero [n] p4 _))))
 29668		// cond: o1 >= 0 && o1+t1.Size() <= n && isSamePtr(p1, p4) && fe.CanSSA(t1) && disjoint(op, t1.Size(), p2, sizeof(t2)) && disjoint(op, t1.Size(), p3, sizeof(t3))
 29669		// result: @mem.Block (Load <t1> (OffPtr <op.Type> [o1] p4) mem)
 29670		for {
 29671			t1 := v.Type
 29672			_ = v.Args[1]
 29673			op := v.Args[0]
 29674			if op.Op != OpOffPtr {
 29675				break
 29676			}
 29677			o1 := op.AuxInt
 29678			p1 := op.Args[0]
 29679			v_1 := v.Args[1]
 29680			if v_1.Op != OpStore {
 29681				break
 29682			}
 29683			t2 := v_1.Aux
 29684			_ = v_1.Args[2]
 29685			p2 := v_1.Args[0]
 29686			v_1_2 := v_1.Args[2]
 29687			if v_1_2.Op != OpStore {
 29688				break
 29689			}
 29690			t3 := v_1_2.Aux
 29691			_ = v_1_2.Args[2]
 29692			p3 := v_1_2.Args[0]
 29693			mem := v_1_2.Args[2]
 29694			if mem.Op != OpZero {
 29695				break
 29696			}
 29697			n := mem.AuxInt
 29698			_ = mem.Args[1]
 29699			p4 := mem.Args[0]
 29700			if !(o1 >= 0 && o1+t1.Size() <= n && isSamePtr(p1, p4) && fe.CanSSA(t1) && disjoint(op, t1.Size(), p2, sizeof(t2)) && disjoint(op, t1.Size(), p3, sizeof(t3))) {
 29701				break
 29702			}
 29703			b = mem.Block
 29704			v0 := b.NewValue0(v.Pos, OpLoad, t1)
 29705			v.reset(OpCopy)
 29706			v.AddArg(v0)
 29707			v1 := b.NewValue0(v.Pos, OpOffPtr, op.Type)
 29708			v1.AuxInt = o1
 29709			v1.AddArg(p4)
 29710			v0.AddArg(v1)
 29711			v0.AddArg(mem)
 29712			return true
 29713		}
 29714		return false
 29715	}
 29716	func rewriteValuegeneric_OpLoad_10(v *Value) bool {
 29717		b := v.Block
 29718		fe := b.Func.fe
 29719		// match: (Load <t1> op:(OffPtr [o1] p1) (Store {t2} p2 _ (Store {t3} p3 _ (Store {t4} p4 _ mem:(Zero [n] p5 _)))))
 29720		// cond: o1 >= 0 && o1+t1.Size() <= n && isSamePtr(p1, p5) && fe.CanSSA(t1) && disjoint(op, t1.Size(), p2, sizeof(t2)) && disjoint(op, t1.Size(), p3, sizeof(t3)) && disjoint(op, t1.Size(), p4, sizeof(t4))
 29721		// result: @mem.Block (Load <t1> (OffPtr <op.Type> [o1] p5) mem)
 29722		for {
 29723			t1 := v.Type
 29724			_ = v.Args[1]
 29725			op := v.Args[0]
 29726			if op.Op != OpOffPtr {
 29727				break
 29728			}
 29729			o1 := op.AuxInt
 29730			p1 := op.Args[0]
 29731			v_1 := v.Args[1]
 29732			if v_1.Op != OpStore {
 29733				break
 29734			}
 29735			t2 := v_1.Aux
 29736			_ = v_1.Args[2]
 29737			p2 := v_1.Args[0]
 29738			v_1_2 := v_1.Args[2]
 29739			if v_1_2.Op != OpStore {
 29740				break
 29741			}
 29742			t3 := v_1_2.Aux
 29743			_ = v_1_2.Args[2]
 29744			p3 := v_1_2.Args[0]
 29745			v_1_2_2 := v_1_2.Args[2]
 29746			if v_1_2_2.Op != OpStore {
 29747				break
 29748			}
 29749			t4 := v_1_2_2.Aux
 29750			_ = v_1_2_2.Args[2]
 29751			p4 := v_1_2_2.Args[0]
 29752			mem := v_1_2_2.Args[2]
 29753			if mem.Op != OpZero {
 29754				break
 29755			}
 29756			n := mem.AuxInt
 29757			_ = mem.Args[1]
 29758			p5 := mem.Args[0]
 29759			if !(o1 >= 0 && o1+t1.Size() <= n && isSamePtr(p1, p5) && fe.CanSSA(t1) && disjoint(op, t1.Size(), p2, sizeof(t2)) && disjoint(op, t1.Size(), p3, sizeof(t3)) && disjoint(op, t1.Size(), p4, sizeof(t4))) {
 29760				break
 29761			}
 29762			b = mem.Block
 29763			v0 := b.NewValue0(v.Pos, OpLoad, t1)
 29764			v.reset(OpCopy)
 29765			v.AddArg(v0)
 29766			v1 := b.NewValue0(v.Pos, OpOffPtr, op.Type)
 29767			v1.AuxInt = o1
 29768			v1.AddArg(p5)
 29769			v0.AddArg(v1)
 29770			v0.AddArg(mem)
 29771			return true
 29772		}
 29773		// match: (Load <t1> op:(OffPtr [o1] p1) (Store {t2} p2 _ (Store {t3} p3 _ (Store {t4} p4 _ (Store {t5} p5 _ mem:(Zero [n] p6 _))))))
 29774		// cond: o1 >= 0 && o1+t1.Size() <= n && isSamePtr(p1, p6) && fe.CanSSA(t1) && disjoint(op, t1.Size(), p2, sizeof(t2)) && disjoint(op, t1.Size(), p3, sizeof(t3)) && disjoint(op, t1.Size(), p4, sizeof(t4)) && disjoint(op, t1.Size(), p5, sizeof(t5))
 29775		// result: @mem.Block (Load <t1> (OffPtr <op.Type> [o1] p6) mem)
 29776		for {
 29777			t1 := v.Type
 29778			_ = v.Args[1]
 29779			op := v.Args[0]
 29780			if op.Op != OpOffPtr {
 29781				break
 29782			}
 29783			o1 := op.AuxInt
 29784			p1 := op.Args[0]
 29785			v_1 := v.Args[1]
 29786			if v_1.Op != OpStore {
 29787				break
 29788			}
 29789			t2 := v_1.Aux
 29790			_ = v_1.Args[2]
 29791			p2 := v_1.Args[0]
 29792			v_1_2 := v_1.Args[2]
 29793			if v_1_2.Op != OpStore {
 29794				break
 29795			}
 29796			t3 := v_1_2.Aux
 29797			_ = v_1_2.Args[2]
 29798			p3 := v_1_2.Args[0]
 29799			v_1_2_2 := v_1_2.Args[2]
 29800			if v_1_2_2.Op != OpStore {
 29801				break
 29802			}
 29803			t4 := v_1_2_2.Aux
 29804			_ = v_1_2_2.Args[2]
 29805			p4 := v_1_2_2.Args[0]
 29806			v_1_2_2_2 := v_1_2_2.Args[2]
 29807			if v_1_2_2_2.Op != OpStore {
 29808				break
 29809			}
 29810			t5 := v_1_2_2_2.Aux
 29811			_ = v_1_2_2_2.Args[2]
 29812			p5 := v_1_2_2_2.Args[0]
 29813			mem := v_1_2_2_2.Args[2]
 29814			if mem.Op != OpZero {
 29815				break
 29816			}
 29817			n := mem.AuxInt
 29818			_ = mem.Args[1]
 29819			p6 := mem.Args[0]
 29820			if !(o1 >= 0 && o1+t1.Size() <= n && isSamePtr(p1, p6) && fe.CanSSA(t1) && disjoint(op, t1.Size(), p2, sizeof(t2)) && disjoint(op, t1.Size(), p3, sizeof(t3)) && disjoint(op, t1.Size(), p4, sizeof(t4)) && disjoint(op, t1.Size(), p5, sizeof(t5))) {
 29821				break
 29822			}
 29823			b = mem.Block
 29824			v0 := b.NewValue0(v.Pos, OpLoad, t1)
 29825			v.reset(OpCopy)
 29826			v.AddArg(v0)
 29827			v1 := b.NewValue0(v.Pos, OpOffPtr, op.Type)
 29828			v1.AuxInt = o1
 29829			v1.AddArg(p6)
 29830			v0.AddArg(v1)
 29831			v0.AddArg(mem)
 29832			return true
 29833		}
 29834		// match: (Load <t1> (OffPtr [o] p1) (Zero [n] p2 _))
 29835		// cond: t1.IsBoolean() && isSamePtr(p1, p2) && n >= o + 1
 29836		// result: (ConstBool [0])
 29837		for {
 29838			t1 := v.Type
 29839			_ = v.Args[1]
 29840			v_0 := v.Args[0]
 29841			if v_0.Op != OpOffPtr {
 29842				break
 29843			}
 29844			o := v_0.AuxInt
 29845			p1 := v_0.Args[0]
 29846			v_1 := v.Args[1]
 29847			if v_1.Op != OpZero {
 29848				break
 29849			}
 29850			n := v_1.AuxInt
 29851			_ = v_1.Args[1]
 29852			p2 := v_1.Args[0]
 29853			if !(t1.IsBoolean() && isSamePtr(p1, p2) && n >= o+1) {
 29854				break
 29855			}
 29856			v.reset(OpConstBool)
 29857			v.AuxInt = 0
 29858			return true
 29859		}
 29860		// match: (Load <t1> (OffPtr [o] p1) (Zero [n] p2 _))
 29861		// cond: is8BitInt(t1) && isSamePtr(p1, p2) && n >= o + 1
 29862		// result: (Const8 [0])
 29863		for {
 29864			t1 := v.Type
 29865			_ = v.Args[1]
 29866			v_0 := v.Args[0]
 29867			if v_0.Op != OpOffPtr {
 29868				break
 29869			}
 29870			o := v_0.AuxInt
 29871			p1 := v_0.Args[0]
 29872			v_1 := v.Args[1]
 29873			if v_1.Op != OpZero {
 29874				break
 29875			}
 29876			n := v_1.AuxInt
 29877			_ = v_1.Args[1]
 29878			p2 := v_1.Args[0]
 29879			if !(is8BitInt(t1) && isSamePtr(p1, p2) && n >= o+1) {
 29880				break
 29881			}
 29882			v.reset(OpConst8)
 29883			v.AuxInt = 0
 29884			return true
 29885		}
 29886		// match: (Load <t1> (OffPtr [o] p1) (Zero [n] p2 _))
 29887		// cond: is16BitInt(t1) && isSamePtr(p1, p2) && n >= o + 2
 29888		// result: (Const16 [0])
 29889		for {
 29890			t1 := v.Type
 29891			_ = v.Args[1]
 29892			v_0 := v.Args[0]
 29893			if v_0.Op != OpOffPtr {
 29894				break
 29895			}
 29896			o := v_0.AuxInt
 29897			p1 := v_0.Args[0]
 29898			v_1 := v.Args[1]
 29899			if v_1.Op != OpZero {
 29900				break
 29901			}
 29902			n := v_1.AuxInt
 29903			_ = v_1.Args[1]
 29904			p2 := v_1.Args[0]
 29905			if !(is16BitInt(t1) && isSamePtr(p1, p2) && n >= o+2) {
 29906				break
 29907			}
 29908			v.reset(OpConst16)
 29909			v.AuxInt = 0
 29910			return true
 29911		}
 29912		// match: (Load <t1> (OffPtr [o] p1) (Zero [n] p2 _))
 29913		// cond: is32BitInt(t1) && isSamePtr(p1, p2) && n >= o + 4
 29914		// result: (Const32 [0])
 29915		for {
 29916			t1 := v.Type
 29917			_ = v.Args[1]
 29918			v_0 := v.Args[0]
 29919			if v_0.Op != OpOffPtr {
 29920				break
 29921			}
 29922			o := v_0.AuxInt
 29923			p1 := v_0.Args[0]
 29924			v_1 := v.Args[1]
 29925			if v_1.Op != OpZero {
 29926				break
 29927			}
 29928			n := v_1.AuxInt
 29929			_ = v_1.Args[1]
 29930			p2 := v_1.Args[0]
 29931			if !(is32BitInt(t1) && isSamePtr(p1, p2) && n >= o+4) {
 29932				break
 29933			}
 29934			v.reset(OpConst32)
 29935			v.AuxInt = 0
 29936			return true
 29937		}
 29938		// match: (Load <t1> (OffPtr [o] p1) (Zero [n] p2 _))
 29939		// cond: is64BitInt(t1) && isSamePtr(p1, p2) && n >= o + 8
 29940		// result: (Const64 [0])
 29941		for {
 29942			t1 := v.Type
 29943			_ = v.Args[1]
 29944			v_0 := v.Args[0]
 29945			if v_0.Op != OpOffPtr {
 29946				break
 29947			}
 29948			o := v_0.AuxInt
 29949			p1 := v_0.Args[0]
 29950			v_1 := v.Args[1]
 29951			if v_1.Op != OpZero {
 29952				break
 29953			}
 29954			n := v_1.AuxInt
 29955			_ = v_1.Args[1]
 29956			p2 := v_1.Args[0]
 29957			if !(is64BitInt(t1) && isSamePtr(p1, p2) && n >= o+8) {
 29958				break
 29959			}
 29960			v.reset(OpConst64)
 29961			v.AuxInt = 0
 29962			return true
 29963		}
 29964		// match: (Load <t1> (OffPtr [o] p1) (Zero [n] p2 _))
 29965		// cond: is32BitFloat(t1) && isSamePtr(p1, p2) && n >= o + 4
 29966		// result: (Const32F [0])
 29967		for {
 29968			t1 := v.Type
 29969			_ = v.Args[1]
 29970			v_0 := v.Args[0]
 29971			if v_0.Op != OpOffPtr {
 29972				break
 29973			}
 29974			o := v_0.AuxInt
 29975			p1 := v_0.Args[0]
 29976			v_1 := v.Args[1]
 29977			if v_1.Op != OpZero {
 29978				break
 29979			}
 29980			n := v_1.AuxInt
 29981			_ = v_1.Args[1]
 29982			p2 := v_1.Args[0]
 29983			if !(is32BitFloat(t1) && isSamePtr(p1, p2) && n >= o+4) {
 29984				break
 29985			}
 29986			v.reset(OpConst32F)
 29987			v.AuxInt = 0
 29988			return true
 29989		}
 29990		// match: (Load <t1> (OffPtr [o] p1) (Zero [n] p2 _))
 29991		// cond: is64BitFloat(t1) && isSamePtr(p1, p2) && n >= o + 8
 29992		// result: (Const64F [0])
 29993		for {
 29994			t1 := v.Type
 29995			_ = v.Args[1]
 29996			v_0 := v.Args[0]
 29997			if v_0.Op != OpOffPtr {
 29998				break
 29999			}
 30000			o := v_0.AuxInt
 30001			p1 := v_0.Args[0]
 30002			v_1 := v.Args[1]
 30003			if v_1.Op != OpZero {
 30004				break
 30005			}
 30006			n := v_1.AuxInt
 30007			_ = v_1.Args[1]
 30008			p2 := v_1.Args[0]
 30009			if !(is64BitFloat(t1) && isSamePtr(p1, p2) && n >= o+8) {
 30010				break
 30011			}
 30012			v.reset(OpConst64F)
 30013			v.AuxInt = 0
 30014			return true
 30015		}
 30016		// match: (Load <t> _ _)
 30017		// cond: t.IsStruct() && t.NumFields() == 0 && fe.CanSSA(t)
 30018		// result: (StructMake0)
 30019		for {
 30020			t := v.Type
 30021			_ = v.Args[1]
 30022			if !(t.IsStruct() && t.NumFields() == 0 && fe.CanSSA(t)) {
 30023				break
 30024			}
 30025			v.reset(OpStructMake0)
 30026			return true
 30027		}
 30028		return false
 30029	}
 30030	func rewriteValuegeneric_OpLoad_20(v *Value) bool {
 30031		b := v.Block
 30032		fe := b.Func.fe
 30033		// match: (Load <t> ptr mem)
 30034		// cond: t.IsStruct() && t.NumFields() == 1 && fe.CanSSA(t)
 30035		// result: (StructMake1 (Load <t.FieldType(0)> (OffPtr <t.FieldType(0).PtrTo()> [0] ptr) mem))
 30036		for {
 30037			t := v.Type
 30038			mem := v.Args[1]
 30039			ptr := v.Args[0]
 30040			if !(t.IsStruct() && t.NumFields() == 1 && fe.CanSSA(t)) {
 30041				break
 30042			}
 30043			v.reset(OpStructMake1)
 30044			v0 := b.NewValue0(v.Pos, OpLoad, t.FieldType(0))
 30045			v1 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo())
 30046			v1.AuxInt = 0
 30047			v1.AddArg(ptr)
 30048			v0.AddArg(v1)
 30049			v0.AddArg(mem)
 30050			v.AddArg(v0)
 30051			return true
 30052		}
 30053		// match: (Load <t> ptr mem)
 30054		// cond: t.IsStruct() && t.NumFields() == 2 && fe.CanSSA(t)
 30055		// result: (StructMake2 (Load <t.FieldType(0)> (OffPtr <t.FieldType(0).PtrTo()> [0] ptr) mem) (Load <t.FieldType(1)> (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] ptr) mem))
 30056		for {
 30057			t := v.Type
 30058			mem := v.Args[1]
 30059			ptr := v.Args[0]
 30060			if !(t.IsStruct() && t.NumFields() == 2 && fe.CanSSA(t)) {
 30061				break
 30062			}
 30063			v.reset(OpStructMake2)
 30064			v0 := b.NewValue0(v.Pos, OpLoad, t.FieldType(0))
 30065			v1 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo())
 30066			v1.AuxInt = 0
 30067			v1.AddArg(ptr)
 30068			v0.AddArg(v1)
 30069			v0.AddArg(mem)
 30070			v.AddArg(v0)
 30071			v2 := b.NewValue0(v.Pos, OpLoad, t.FieldType(1))
 30072			v3 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(1).PtrTo())
 30073			v3.AuxInt = t.FieldOff(1)
 30074			v3.AddArg(ptr)
 30075			v2.AddArg(v3)
 30076			v2.AddArg(mem)
 30077			v.AddArg(v2)
 30078			return true
 30079		}
 30080		// match: (Load <t> ptr mem)
 30081		// cond: t.IsStruct() && t.NumFields() == 3 && fe.CanSSA(t)
 30082		// result: (StructMake3 (Load <t.FieldType(0)> (OffPtr <t.FieldType(0).PtrTo()> [0] ptr) mem) (Load <t.FieldType(1)> (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] ptr) mem) (Load <t.FieldType(2)> (OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] ptr) mem))
 30083		for {
 30084			t := v.Type
 30085			mem := v.Args[1]
 30086			ptr := v.Args[0]
 30087			if !(t.IsStruct() && t.NumFields() == 3 && fe.CanSSA(t)) {
 30088				break
 30089			}
 30090			v.reset(OpStructMake3)
 30091			v0 := b.NewValue0(v.Pos, OpLoad, t.FieldType(0))
 30092			v1 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo())
 30093			v1.AuxInt = 0
 30094			v1.AddArg(ptr)
 30095			v0.AddArg(v1)
 30096			v0.AddArg(mem)
 30097			v.AddArg(v0)
 30098			v2 := b.NewValue0(v.Pos, OpLoad, t.FieldType(1))
 30099			v3 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(1).PtrTo())
 30100			v3.AuxInt = t.FieldOff(1)
 30101			v3.AddArg(ptr)
 30102			v2.AddArg(v3)
 30103			v2.AddArg(mem)
 30104			v.AddArg(v2)
 30105			v4 := b.NewValue0(v.Pos, OpLoad, t.FieldType(2))
 30106			v5 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(2).PtrTo())
 30107			v5.AuxInt = t.FieldOff(2)
 30108			v5.AddArg(ptr)
 30109			v4.AddArg(v5)
 30110			v4.AddArg(mem)
 30111			v.AddArg(v4)
 30112			return true
 30113		}
 30114		// match: (Load <t> ptr mem)
 30115		// cond: t.IsStruct() && t.NumFields() == 4 && fe.CanSSA(t)
 30116		// result: (StructMake4 (Load <t.FieldType(0)> (OffPtr <t.FieldType(0).PtrTo()> [0] ptr) mem) (Load <t.FieldType(1)> (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] ptr) mem) (Load <t.FieldType(2)> (OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] ptr) mem) (Load <t.FieldType(3)> (OffPtr <t.FieldType(3).PtrTo()> [t.FieldOff(3)] ptr) mem))
 30117		for {
 30118			t := v.Type
 30119			mem := v.Args[1]
 30120			ptr := v.Args[0]
 30121			if !(t.IsStruct() && t.NumFields() == 4 && fe.CanSSA(t)) {
 30122				break
 30123			}
 30124			v.reset(OpStructMake4)
 30125			v0 := b.NewValue0(v.Pos, OpLoad, t.FieldType(0))
 30126			v1 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo())
 30127			v1.AuxInt = 0
 30128			v1.AddArg(ptr)
 30129			v0.AddArg(v1)
 30130			v0.AddArg(mem)
 30131			v.AddArg(v0)
 30132			v2 := b.NewValue0(v.Pos, OpLoad, t.FieldType(1))
 30133			v3 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(1).PtrTo())
 30134			v3.AuxInt = t.FieldOff(1)
 30135			v3.AddArg(ptr)
 30136			v2.AddArg(v3)
 30137			v2.AddArg(mem)
 30138			v.AddArg(v2)
 30139			v4 := b.NewValue0(v.Pos, OpLoad, t.FieldType(2))
 30140			v5 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(2).PtrTo())
 30141			v5.AuxInt = t.FieldOff(2)
 30142			v5.AddArg(ptr)
 30143			v4.AddArg(v5)
 30144			v4.AddArg(mem)
 30145			v.AddArg(v4)
 30146			v6 := b.NewValue0(v.Pos, OpLoad, t.FieldType(3))
 30147			v7 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(3).PtrTo())
 30148			v7.AuxInt = t.FieldOff(3)
 30149			v7.AddArg(ptr)
 30150			v6.AddArg(v7)
 30151			v6.AddArg(mem)
 30152			v.AddArg(v6)
 30153			return true
 30154		}
 30155		// match: (Load <t> _ _)
 30156		// cond: t.IsArray() && t.NumElem() == 0
 30157		// result: (ArrayMake0)
 30158		for {
 30159			t := v.Type
 30160			_ = v.Args[1]
 30161			if !(t.IsArray() && t.NumElem() == 0) {
 30162				break
 30163			}
 30164			v.reset(OpArrayMake0)
 30165			return true
 30166		}
 30167		// match: (Load <t> ptr mem)
 30168		// cond: t.IsArray() && t.NumElem() == 1 && fe.CanSSA(t)
 30169		// result: (ArrayMake1 (Load <t.Elem()> ptr mem))
 30170		for {
 30171			t := v.Type
 30172			mem := v.Args[1]
 30173			ptr := v.Args[0]
 30174			if !(t.IsArray() && t.NumElem() == 1 && fe.CanSSA(t)) {
 30175				break
 30176			}
 30177			v.reset(OpArrayMake1)
 30178			v0 := b.NewValue0(v.Pos, OpLoad, t.Elem())
 30179			v0.AddArg(ptr)
 30180			v0.AddArg(mem)
 30181			v.AddArg(v0)
 30182			return true
 30183		}
 30184		return false
 30185	}
 30186	func rewriteValuegeneric_OpLsh16x16_0(v *Value) bool {
 30187		b := v.Block
 30188		// match: (Lsh16x16 <t> x (Const16 [c]))
 30189		// cond:
 30190		// result: (Lsh16x64 x (Const64 <t> [int64(uint16(c))]))
 30191		for {
 30192			t := v.Type
 30193			_ = v.Args[1]
 30194			x := v.Args[0]
 30195			v_1 := v.Args[1]
 30196			if v_1.Op != OpConst16 {
 30197				break
 30198			}
 30199			c := v_1.AuxInt
 30200			v.reset(OpLsh16x64)
 30201			v.AddArg(x)
 30202			v0 := b.NewValue0(v.Pos, OpConst64, t)
 30203			v0.AuxInt = int64(uint16(c))
 30204			v.AddArg(v0)
 30205			return true
 30206		}
 30207		// match: (Lsh16x16 (Const16 [0]) _)
 30208		// cond:
 30209		// result: (Const16 [0])
 30210		for {
 30211			_ = v.Args[1]
 30212			v_0 := v.Args[0]
 30213			if v_0.Op != OpConst16 {
 30214				break
 30215			}
 30216			if v_0.AuxInt != 0 {
 30217				break
 30218			}
 30219			v.reset(OpConst16)
 30220			v.AuxInt = 0
 30221			return true
 30222		}
 30223		return false
 30224	}
 30225	func rewriteValuegeneric_OpLsh16x32_0(v *Value) bool {
 30226		b := v.Block
 30227		// match: (Lsh16x32 <t> x (Const32 [c]))
 30228		// cond:
 30229		// result: (Lsh16x64 x (Const64 <t> [int64(uint32(c))]))
 30230		for {
 30231			t := v.Type
 30232			_ = v.Args[1]
 30233			x := v.Args[0]
 30234			v_1 := v.Args[1]
 30235			if v_1.Op != OpConst32 {
 30236				break
 30237			}
 30238			c := v_1.AuxInt
 30239			v.reset(OpLsh16x64)
 30240			v.AddArg(x)
 30241			v0 := b.NewValue0(v.Pos, OpConst64, t)
 30242			v0.AuxInt = int64(uint32(c))
 30243			v.AddArg(v0)
 30244			return true
 30245		}
 30246		// match: (Lsh16x32 (Const16 [0]) _)
 30247		// cond:
 30248		// result: (Const16 [0])
 30249		for {
 30250			_ = v.Args[1]
 30251			v_0 := v.Args[0]
 30252			if v_0.Op != OpConst16 {
 30253				break
 30254			}
 30255			if v_0.AuxInt != 0 {
 30256				break
 30257			}
 30258			v.reset(OpConst16)
 30259			v.AuxInt = 0
 30260			return true
 30261		}
 30262		return false
 30263	}
 30264	func rewriteValuegeneric_OpLsh16x64_0(v *Value) bool {
 30265		b := v.Block
 30266		typ := &b.Func.Config.Types
 30267		// match: (Lsh16x64 (Const16 [c]) (Const64 [d]))
 30268		// cond:
 30269		// result: (Const16 [int64(int16(c) << uint64(d))])
 30270		for {
 30271			_ = v.Args[1]
 30272			v_0 := v.Args[0]
 30273			if v_0.Op != OpConst16 {
 30274				break
 30275			}
 30276			c := v_0.AuxInt
 30277			v_1 := v.Args[1]
 30278			if v_1.Op != OpConst64 {
 30279				break
 30280			}
 30281			d := v_1.AuxInt
 30282			v.reset(OpConst16)
 30283			v.AuxInt = int64(int16(c) << uint64(d))
 30284			return true
 30285		}
 30286		// match: (Lsh16x64 x (Const64 [0]))
 30287		// cond:
 30288		// result: x
 30289		for {
 30290			_ = v.Args[1]
 30291			x := v.Args[0]
 30292			v_1 := v.Args[1]
 30293			if v_1.Op != OpConst64 {
 30294				break
 30295			}
 30296			if v_1.AuxInt != 0 {
 30297				break
 30298			}
 30299			v.reset(OpCopy)
 30300			v.Type = x.Type
 30301			v.AddArg(x)
 30302			return true
 30303		}
 30304		// match: (Lsh16x64 (Const16 [0]) _)
 30305		// cond:
 30306		// result: (Const16 [0])
 30307		for {
 30308			_ = v.Args[1]
 30309			v_0 := v.Args[0]
 30310			if v_0.Op != OpConst16 {
 30311				break
 30312			}
 30313			if v_0.AuxInt != 0 {
 30314				break
 30315			}
 30316			v.reset(OpConst16)
 30317			v.AuxInt = 0
 30318			return true
 30319		}
 30320		// match: (Lsh16x64 _ (Const64 [c]))
 30321		// cond: uint64(c) >= 16
 30322		// result: (Const16 [0])
 30323		for {
 30324			_ = v.Args[1]
 30325			v_1 := v.Args[1]
 30326			if v_1.Op != OpConst64 {
 30327				break
 30328			}
 30329			c := v_1.AuxInt
 30330			if !(uint64(c) >= 16) {
 30331				break
 30332			}
 30333			v.reset(OpConst16)
 30334			v.AuxInt = 0
 30335			return true
 30336		}
 30337		// match: (Lsh16x64 <t> (Lsh16x64 x (Const64 [c])) (Const64 [d]))
 30338		// cond: !uaddOvf(c,d)
 30339		// result: (Lsh16x64 x (Const64 <t> [c+d]))
 30340		for {
 30341			t := v.Type
 30342			_ = v.Args[1]
 30343			v_0 := v.Args[0]
 30344			if v_0.Op != OpLsh16x64 {
 30345				break
 30346			}
 30347			_ = v_0.Args[1]
 30348			x := v_0.Args[0]
 30349			v_0_1 := v_0.Args[1]
 30350			if v_0_1.Op != OpConst64 {
 30351				break
 30352			}
 30353			c := v_0_1.AuxInt
 30354			v_1 := v.Args[1]
 30355			if v_1.Op != OpConst64 {
 30356				break
 30357			}
 30358			d := v_1.AuxInt
 30359			if !(!uaddOvf(c, d)) {
 30360				break
 30361			}
 30362			v.reset(OpLsh16x64)
 30363			v.AddArg(x)
 30364			v0 := b.NewValue0(v.Pos, OpConst64, t)
 30365			v0.AuxInt = c + d
 30366			v.AddArg(v0)
 30367			return true
 30368		}
 30369		// match: (Lsh16x64 (Rsh16Ux64 (Lsh16x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
 30370		// cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
 30371		// result: (Lsh16x64 x (Const64 <typ.UInt64> [c1-c2+c3]))
 30372		for {
 30373			_ = v.Args[1]
 30374			v_0 := v.Args[0]
 30375			if v_0.Op != OpRsh16Ux64 {
 30376				break
 30377			}
 30378			_ = v_0.Args[1]
 30379			v_0_0 := v_0.Args[0]
 30380			if v_0_0.Op != OpLsh16x64 {
 30381				break
 30382			}
 30383			_ = v_0_0.Args[1]
 30384			x := v_0_0.Args[0]
 30385			v_0_0_1 := v_0_0.Args[1]
 30386			if v_0_0_1.Op != OpConst64 {
 30387				break
 30388			}
 30389			c1 := v_0_0_1.AuxInt
 30390			v_0_1 := v_0.Args[1]
 30391			if v_0_1.Op != OpConst64 {
 30392				break
 30393			}
 30394			c2 := v_0_1.AuxInt
 30395			v_1 := v.Args[1]
 30396			if v_1.Op != OpConst64 {
 30397				break
 30398			}
 30399			c3 := v_1.AuxInt
 30400			if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) {
 30401				break
 30402			}
 30403			v.reset(OpLsh16x64)
 30404			v.AddArg(x)
 30405			v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 30406			v0.AuxInt = c1 - c2 + c3
 30407			v.AddArg(v0)
 30408			return true
 30409		}
 30410		return false
 30411	}
 30412	func rewriteValuegeneric_OpLsh16x8_0(v *Value) bool {
 30413		b := v.Block
 30414		// match: (Lsh16x8 <t> x (Const8 [c]))
 30415		// cond:
 30416		// result: (Lsh16x64 x (Const64 <t> [int64(uint8(c))]))
 30417		for {
 30418			t := v.Type
 30419			_ = v.Args[1]
 30420			x := v.Args[0]
 30421			v_1 := v.Args[1]
 30422			if v_1.Op != OpConst8 {
 30423				break
 30424			}
 30425			c := v_1.AuxInt
 30426			v.reset(OpLsh16x64)
 30427			v.AddArg(x)
 30428			v0 := b.NewValue0(v.Pos, OpConst64, t)
 30429			v0.AuxInt = int64(uint8(c))
 30430			v.AddArg(v0)
 30431			return true
 30432		}
 30433		// match: (Lsh16x8 (Const16 [0]) _)
 30434		// cond:
 30435		// result: (Const16 [0])
 30436		for {
 30437			_ = v.Args[1]
 30438			v_0 := v.Args[0]
 30439			if v_0.Op != OpConst16 {
 30440				break
 30441			}
 30442			if v_0.AuxInt != 0 {
 30443				break
 30444			}
 30445			v.reset(OpConst16)
 30446			v.AuxInt = 0
 30447			return true
 30448		}
 30449		return false
 30450	}
 30451	func rewriteValuegeneric_OpLsh32x16_0(v *Value) bool {
 30452		b := v.Block
 30453		// match: (Lsh32x16 <t> x (Const16 [c]))
 30454		// cond:
 30455		// result: (Lsh32x64 x (Const64 <t> [int64(uint16(c))]))
 30456		for {
 30457			t := v.Type
 30458			_ = v.Args[1]
 30459			x := v.Args[0]
 30460			v_1 := v.Args[1]
 30461			if v_1.Op != OpConst16 {
 30462				break
 30463			}
 30464			c := v_1.AuxInt
 30465			v.reset(OpLsh32x64)
 30466			v.AddArg(x)
 30467			v0 := b.NewValue0(v.Pos, OpConst64, t)
 30468			v0.AuxInt = int64(uint16(c))
 30469			v.AddArg(v0)
 30470			return true
 30471		}
 30472		// match: (Lsh32x16 (Const32 [0]) _)
 30473		// cond:
 30474		// result: (Const32 [0])
 30475		for {
 30476			_ = v.Args[1]
 30477			v_0 := v.Args[0]
 30478			if v_0.Op != OpConst32 {
 30479				break
 30480			}
 30481			if v_0.AuxInt != 0 {
 30482				break
 30483			}
 30484			v.reset(OpConst32)
 30485			v.AuxInt = 0
 30486			return true
 30487		}
 30488		return false
 30489	}
 30490	func rewriteValuegeneric_OpLsh32x32_0(v *Value) bool {
 30491		b := v.Block
 30492		// match: (Lsh32x32 <t> x (Const32 [c]))
 30493		// cond:
 30494		// result: (Lsh32x64 x (Const64 <t> [int64(uint32(c))]))
 30495		for {
 30496			t := v.Type
 30497			_ = v.Args[1]
 30498			x := v.Args[0]
 30499			v_1 := v.Args[1]
 30500			if v_1.Op != OpConst32 {
 30501				break
 30502			}
 30503			c := v_1.AuxInt
 30504			v.reset(OpLsh32x64)
 30505			v.AddArg(x)
 30506			v0 := b.NewValue0(v.Pos, OpConst64, t)
 30507			v0.AuxInt = int64(uint32(c))
 30508			v.AddArg(v0)
 30509			return true
 30510		}
 30511		// match: (Lsh32x32 (Const32 [0]) _)
 30512		// cond:
 30513		// result: (Const32 [0])
 30514		for {
 30515			_ = v.Args[1]
 30516			v_0 := v.Args[0]
 30517			if v_0.Op != OpConst32 {
 30518				break
 30519			}
 30520			if v_0.AuxInt != 0 {
 30521				break
 30522			}
 30523			v.reset(OpConst32)
 30524			v.AuxInt = 0
 30525			return true
 30526		}
 30527		return false
 30528	}
 30529	func rewriteValuegeneric_OpLsh32x64_0(v *Value) bool {
 30530		b := v.Block
 30531		typ := &b.Func.Config.Types
 30532		// match: (Lsh32x64 (Const32 [c]) (Const64 [d]))
 30533		// cond:
 30534		// result: (Const32 [int64(int32(c) << uint64(d))])
 30535		for {
 30536			_ = v.Args[1]
 30537			v_0 := v.Args[0]
 30538			if v_0.Op != OpConst32 {
 30539				break
 30540			}
 30541			c := v_0.AuxInt
 30542			v_1 := v.Args[1]
 30543			if v_1.Op != OpConst64 {
 30544				break
 30545			}
 30546			d := v_1.AuxInt
 30547			v.reset(OpConst32)
 30548			v.AuxInt = int64(int32(c) << uint64(d))
 30549			return true
 30550		}
 30551		// match: (Lsh32x64 x (Const64 [0]))
 30552		// cond:
 30553		// result: x
 30554		for {
 30555			_ = v.Args[1]
 30556			x := v.Args[0]
 30557			v_1 := v.Args[1]
 30558			if v_1.Op != OpConst64 {
 30559				break
 30560			}
 30561			if v_1.AuxInt != 0 {
 30562				break
 30563			}
 30564			v.reset(OpCopy)
 30565			v.Type = x.Type
 30566			v.AddArg(x)
 30567			return true
 30568		}
 30569		// match: (Lsh32x64 (Const32 [0]) _)
 30570		// cond:
 30571		// result: (Const32 [0])
 30572		for {
 30573			_ = v.Args[1]
 30574			v_0 := v.Args[0]
 30575			if v_0.Op != OpConst32 {
 30576				break
 30577			}
 30578			if v_0.AuxInt != 0 {
 30579				break
 30580			}
 30581			v.reset(OpConst32)
 30582			v.AuxInt = 0
 30583			return true
 30584		}
 30585		// match: (Lsh32x64 _ (Const64 [c]))
 30586		// cond: uint64(c) >= 32
 30587		// result: (Const32 [0])
 30588		for {
 30589			_ = v.Args[1]
 30590			v_1 := v.Args[1]
 30591			if v_1.Op != OpConst64 {
 30592				break
 30593			}
 30594			c := v_1.AuxInt
 30595			if !(uint64(c) >= 32) {
 30596				break
 30597			}
 30598			v.reset(OpConst32)
 30599			v.AuxInt = 0
 30600			return true
 30601		}
 30602		// match: (Lsh32x64 <t> (Lsh32x64 x (Const64 [c])) (Const64 [d]))
 30603		// cond: !uaddOvf(c,d)
 30604		// result: (Lsh32x64 x (Const64 <t> [c+d]))
 30605		for {
 30606			t := v.Type
 30607			_ = v.Args[1]
 30608			v_0 := v.Args[0]
 30609			if v_0.Op != OpLsh32x64 {
 30610				break
 30611			}
 30612			_ = v_0.Args[1]
 30613			x := v_0.Args[0]
 30614			v_0_1 := v_0.Args[1]
 30615			if v_0_1.Op != OpConst64 {
 30616				break
 30617			}
 30618			c := v_0_1.AuxInt
 30619			v_1 := v.Args[1]
 30620			if v_1.Op != OpConst64 {
 30621				break
 30622			}
 30623			d := v_1.AuxInt
 30624			if !(!uaddOvf(c, d)) {
 30625				break
 30626			}
 30627			v.reset(OpLsh32x64)
 30628			v.AddArg(x)
 30629			v0 := b.NewValue0(v.Pos, OpConst64, t)
 30630			v0.AuxInt = c + d
 30631			v.AddArg(v0)
 30632			return true
 30633		}
 30634		// match: (Lsh32x64 (Rsh32Ux64 (Lsh32x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
 30635		// cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
 30636		// result: (Lsh32x64 x (Const64 <typ.UInt64> [c1-c2+c3]))
 30637		for {
 30638			_ = v.Args[1]
 30639			v_0 := v.Args[0]
 30640			if v_0.Op != OpRsh32Ux64 {
 30641				break
 30642			}
 30643			_ = v_0.Args[1]
 30644			v_0_0 := v_0.Args[0]
 30645			if v_0_0.Op != OpLsh32x64 {
 30646				break
 30647			}
 30648			_ = v_0_0.Args[1]
 30649			x := v_0_0.Args[0]
 30650			v_0_0_1 := v_0_0.Args[1]
 30651			if v_0_0_1.Op != OpConst64 {
 30652				break
 30653			}
 30654			c1 := v_0_0_1.AuxInt
 30655			v_0_1 := v_0.Args[1]
 30656			if v_0_1.Op != OpConst64 {
 30657				break
 30658			}
 30659			c2 := v_0_1.AuxInt
 30660			v_1 := v.Args[1]
 30661			if v_1.Op != OpConst64 {
 30662				break
 30663			}
 30664			c3 := v_1.AuxInt
 30665			if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) {
 30666				break
 30667			}
 30668			v.reset(OpLsh32x64)
 30669			v.AddArg(x)
 30670			v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 30671			v0.AuxInt = c1 - c2 + c3
 30672			v.AddArg(v0)
 30673			return true
 30674		}
 30675		return false
 30676	}
 30677	func rewriteValuegeneric_OpLsh32x8_0(v *Value) bool {
 30678		b := v.Block
 30679		// match: (Lsh32x8 <t> x (Const8 [c]))
 30680		// cond:
 30681		// result: (Lsh32x64 x (Const64 <t> [int64(uint8(c))]))
 30682		for {
 30683			t := v.Type
 30684			_ = v.Args[1]
 30685			x := v.Args[0]
 30686			v_1 := v.Args[1]
 30687			if v_1.Op != OpConst8 {
 30688				break
 30689			}
 30690			c := v_1.AuxInt
 30691			v.reset(OpLsh32x64)
 30692			v.AddArg(x)
 30693			v0 := b.NewValue0(v.Pos, OpConst64, t)
 30694			v0.AuxInt = int64(uint8(c))
 30695			v.AddArg(v0)
 30696			return true
 30697		}
 30698		// match: (Lsh32x8 (Const32 [0]) _)
 30699		// cond:
 30700		// result: (Const32 [0])
 30701		for {
 30702			_ = v.Args[1]
 30703			v_0 := v.Args[0]
 30704			if v_0.Op != OpConst32 {
 30705				break
 30706			}
 30707			if v_0.AuxInt != 0 {
 30708				break
 30709			}
 30710			v.reset(OpConst32)
 30711			v.AuxInt = 0
 30712			return true
 30713		}
 30714		return false
 30715	}
 30716	func rewriteValuegeneric_OpLsh64x16_0(v *Value) bool {
 30717		b := v.Block
 30718		// match: (Lsh64x16 <t> x (Const16 [c]))
 30719		// cond:
 30720		// result: (Lsh64x64 x (Const64 <t> [int64(uint16(c))]))
 30721		for {
 30722			t := v.Type
 30723			_ = v.Args[1]
 30724			x := v.Args[0]
 30725			v_1 := v.Args[1]
 30726			if v_1.Op != OpConst16 {
 30727				break
 30728			}
 30729			c := v_1.AuxInt
 30730			v.reset(OpLsh64x64)
 30731			v.AddArg(x)
 30732			v0 := b.NewValue0(v.Pos, OpConst64, t)
 30733			v0.AuxInt = int64(uint16(c))
 30734			v.AddArg(v0)
 30735			return true
 30736		}
 30737		// match: (Lsh64x16 (Const64 [0]) _)
 30738		// cond:
 30739		// result: (Const64 [0])
 30740		for {
 30741			_ = v.Args[1]
 30742			v_0 := v.Args[0]
 30743			if v_0.Op != OpConst64 {
 30744				break
 30745			}
 30746			if v_0.AuxInt != 0 {
 30747				break
 30748			}
 30749			v.reset(OpConst64)
 30750			v.AuxInt = 0
 30751			return true
 30752		}
 30753		return false
 30754	}
 30755	func rewriteValuegeneric_OpLsh64x32_0(v *Value) bool {
 30756		b := v.Block
 30757		// match: (Lsh64x32 <t> x (Const32 [c]))
 30758		// cond:
 30759		// result: (Lsh64x64 x (Const64 <t> [int64(uint32(c))]))
 30760		for {
 30761			t := v.Type
 30762			_ = v.Args[1]
 30763			x := v.Args[0]
 30764			v_1 := v.Args[1]
 30765			if v_1.Op != OpConst32 {
 30766				break
 30767			}
 30768			c := v_1.AuxInt
 30769			v.reset(OpLsh64x64)
 30770			v.AddArg(x)
 30771			v0 := b.NewValue0(v.Pos, OpConst64, t)
 30772			v0.AuxInt = int64(uint32(c))
 30773			v.AddArg(v0)
 30774			return true
 30775		}
 30776		// match: (Lsh64x32 (Const64 [0]) _)
 30777		// cond:
 30778		// result: (Const64 [0])
 30779		for {
 30780			_ = v.Args[1]
 30781			v_0 := v.Args[0]
 30782			if v_0.Op != OpConst64 {
 30783				break
 30784			}
 30785			if v_0.AuxInt != 0 {
 30786				break
 30787			}
 30788			v.reset(OpConst64)
 30789			v.AuxInt = 0
 30790			return true
 30791		}
 30792		return false
 30793	}
 30794	func rewriteValuegeneric_OpLsh64x64_0(v *Value) bool {
 30795		b := v.Block
 30796		typ := &b.Func.Config.Types
 30797		// match: (Lsh64x64 (Const64 [c]) (Const64 [d]))
 30798		// cond:
 30799		// result: (Const64 [c << uint64(d)])
 30800		for {
 30801			_ = v.Args[1]
 30802			v_0 := v.Args[0]
 30803			if v_0.Op != OpConst64 {
 30804				break
 30805			}
 30806			c := v_0.AuxInt
 30807			v_1 := v.Args[1]
 30808			if v_1.Op != OpConst64 {
 30809				break
 30810			}
 30811			d := v_1.AuxInt
 30812			v.reset(OpConst64)
 30813			v.AuxInt = c << uint64(d)
 30814			return true
 30815		}
 30816		// match: (Lsh64x64 x (Const64 [0]))
 30817		// cond:
 30818		// result: x
 30819		for {
 30820			_ = v.Args[1]
 30821			x := v.Args[0]
 30822			v_1 := v.Args[1]
 30823			if v_1.Op != OpConst64 {
 30824				break
 30825			}
 30826			if v_1.AuxInt != 0 {
 30827				break
 30828			}
 30829			v.reset(OpCopy)
 30830			v.Type = x.Type
 30831			v.AddArg(x)
 30832			return true
 30833		}
 30834		// match: (Lsh64x64 (Const64 [0]) _)
 30835		// cond:
 30836		// result: (Const64 [0])
 30837		for {
 30838			_ = v.Args[1]
 30839			v_0 := v.Args[0]
 30840			if v_0.Op != OpConst64 {
 30841				break
 30842			}
 30843			if v_0.AuxInt != 0 {
 30844				break
 30845			}
 30846			v.reset(OpConst64)
 30847			v.AuxInt = 0
 30848			return true
 30849		}
 30850		// match: (Lsh64x64 _ (Const64 [c]))
 30851		// cond: uint64(c) >= 64
 30852		// result: (Const64 [0])
 30853		for {
 30854			_ = v.Args[1]
 30855			v_1 := v.Args[1]
 30856			if v_1.Op != OpConst64 {
 30857				break
 30858			}
 30859			c := v_1.AuxInt
 30860			if !(uint64(c) >= 64) {
 30861				break
 30862			}
 30863			v.reset(OpConst64)
 30864			v.AuxInt = 0
 30865			return true
 30866		}
 30867		// match: (Lsh64x64 <t> (Lsh64x64 x (Const64 [c])) (Const64 [d]))
 30868		// cond: !uaddOvf(c,d)
 30869		// result: (Lsh64x64 x (Const64 <t> [c+d]))
 30870		for {
 30871			t := v.Type
 30872			_ = v.Args[1]
 30873			v_0 := v.Args[0]
 30874			if v_0.Op != OpLsh64x64 {
 30875				break
 30876			}
 30877			_ = v_0.Args[1]
 30878			x := v_0.Args[0]
 30879			v_0_1 := v_0.Args[1]
 30880			if v_0_1.Op != OpConst64 {
 30881				break
 30882			}
 30883			c := v_0_1.AuxInt
 30884			v_1 := v.Args[1]
 30885			if v_1.Op != OpConst64 {
 30886				break
 30887			}
 30888			d := v_1.AuxInt
 30889			if !(!uaddOvf(c, d)) {
 30890				break
 30891			}
 30892			v.reset(OpLsh64x64)
 30893			v.AddArg(x)
 30894			v0 := b.NewValue0(v.Pos, OpConst64, t)
 30895			v0.AuxInt = c + d
 30896			v.AddArg(v0)
 30897			return true
 30898		}
 30899		// match: (Lsh64x64 (Rsh64Ux64 (Lsh64x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
 30900		// cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
 30901		// result: (Lsh64x64 x (Const64 <typ.UInt64> [c1-c2+c3]))
 30902		for {
 30903			_ = v.Args[1]
 30904			v_0 := v.Args[0]
 30905			if v_0.Op != OpRsh64Ux64 {
 30906				break
 30907			}
 30908			_ = v_0.Args[1]
 30909			v_0_0 := v_0.Args[0]
 30910			if v_0_0.Op != OpLsh64x64 {
 30911				break
 30912			}
 30913			_ = v_0_0.Args[1]
 30914			x := v_0_0.Args[0]
 30915			v_0_0_1 := v_0_0.Args[1]
 30916			if v_0_0_1.Op != OpConst64 {
 30917				break
 30918			}
 30919			c1 := v_0_0_1.AuxInt
 30920			v_0_1 := v_0.Args[1]
 30921			if v_0_1.Op != OpConst64 {
 30922				break
 30923			}
 30924			c2 := v_0_1.AuxInt
 30925			v_1 := v.Args[1]
 30926			if v_1.Op != OpConst64 {
 30927				break
 30928			}
 30929			c3 := v_1.AuxInt
 30930			if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) {
 30931				break
 30932			}
 30933			v.reset(OpLsh64x64)
 30934			v.AddArg(x)
 30935			v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 30936			v0.AuxInt = c1 - c2 + c3
 30937			v.AddArg(v0)
 30938			return true
 30939		}
 30940		return false
 30941	}
 30942	func rewriteValuegeneric_OpLsh64x8_0(v *Value) bool {
 30943		b := v.Block
 30944		// match: (Lsh64x8 <t> x (Const8 [c]))
 30945		// cond:
 30946		// result: (Lsh64x64 x (Const64 <t> [int64(uint8(c))]))
 30947		for {
 30948			t := v.Type
 30949			_ = v.Args[1]
 30950			x := v.Args[0]
 30951			v_1 := v.Args[1]
 30952			if v_1.Op != OpConst8 {
 30953				break
 30954			}
 30955			c := v_1.AuxInt
 30956			v.reset(OpLsh64x64)
 30957			v.AddArg(x)
 30958			v0 := b.NewValue0(v.Pos, OpConst64, t)
 30959			v0.AuxInt = int64(uint8(c))
 30960			v.AddArg(v0)
 30961			return true
 30962		}
 30963		// match: (Lsh64x8 (Const64 [0]) _)
 30964		// cond:
 30965		// result: (Const64 [0])
 30966		for {
 30967			_ = v.Args[1]
 30968			v_0 := v.Args[0]
 30969			if v_0.Op != OpConst64 {
 30970				break
 30971			}
 30972			if v_0.AuxInt != 0 {
 30973				break
 30974			}
 30975			v.reset(OpConst64)
 30976			v.AuxInt = 0
 30977			return true
 30978		}
 30979		return false
 30980	}
 30981	func rewriteValuegeneric_OpLsh8x16_0(v *Value) bool {
 30982		b := v.Block
 30983		// match: (Lsh8x16 <t> x (Const16 [c]))
 30984		// cond:
 30985		// result: (Lsh8x64 x (Const64 <t> [int64(uint16(c))]))
 30986		for {
 30987			t := v.Type
 30988			_ = v.Args[1]
 30989			x := v.Args[0]
 30990			v_1 := v.Args[1]
 30991			if v_1.Op != OpConst16 {
 30992				break
 30993			}
 30994			c := v_1.AuxInt
 30995			v.reset(OpLsh8x64)
 30996			v.AddArg(x)
 30997			v0 := b.NewValue0(v.Pos, OpConst64, t)
 30998			v0.AuxInt = int64(uint16(c))
 30999			v.AddArg(v0)
 31000			return true
 31001		}
 31002		// match: (Lsh8x16 (Const8 [0]) _)
 31003		// cond:
 31004		// result: (Const8 [0])
 31005		for {
 31006			_ = v.Args[1]
 31007			v_0 := v.Args[0]
 31008			if v_0.Op != OpConst8 {
 31009				break
 31010			}
 31011			if v_0.AuxInt != 0 {
 31012				break
 31013			}
 31014			v.reset(OpConst8)
 31015			v.AuxInt = 0
 31016			return true
 31017		}
 31018		return false
 31019	}
 31020	func rewriteValuegeneric_OpLsh8x32_0(v *Value) bool {
 31021		b := v.Block
 31022		// match: (Lsh8x32 <t> x (Const32 [c]))
 31023		// cond:
 31024		// result: (Lsh8x64 x (Const64 <t> [int64(uint32(c))]))
 31025		for {
 31026			t := v.Type
 31027			_ = v.Args[1]
 31028			x := v.Args[0]
 31029			v_1 := v.Args[1]
 31030			if v_1.Op != OpConst32 {
 31031				break
 31032			}
 31033			c := v_1.AuxInt
 31034			v.reset(OpLsh8x64)
 31035			v.AddArg(x)
 31036			v0 := b.NewValue0(v.Pos, OpConst64, t)
 31037			v0.AuxInt = int64(uint32(c))
 31038			v.AddArg(v0)
 31039			return true
 31040		}
 31041		// match: (Lsh8x32 (Const8 [0]) _)
 31042		// cond:
 31043		// result: (Const8 [0])
 31044		for {
 31045			_ = v.Args[1]
 31046			v_0 := v.Args[0]
 31047			if v_0.Op != OpConst8 {
 31048				break
 31049			}
 31050			if v_0.AuxInt != 0 {
 31051				break
 31052			}
 31053			v.reset(OpConst8)
 31054			v.AuxInt = 0
 31055			return true
 31056		}
 31057		return false
 31058	}
 31059	func rewriteValuegeneric_OpLsh8x64_0(v *Value) bool {
 31060		b := v.Block
 31061		typ := &b.Func.Config.Types
 31062		// match: (Lsh8x64 (Const8 [c]) (Const64 [d]))
 31063		// cond:
 31064		// result: (Const8 [int64(int8(c) << uint64(d))])
 31065		for {
 31066			_ = v.Args[1]
 31067			v_0 := v.Args[0]
 31068			if v_0.Op != OpConst8 {
 31069				break
 31070			}
 31071			c := v_0.AuxInt
 31072			v_1 := v.Args[1]
 31073			if v_1.Op != OpConst64 {
 31074				break
 31075			}
 31076			d := v_1.AuxInt
 31077			v.reset(OpConst8)
 31078			v.AuxInt = int64(int8(c) << uint64(d))
 31079			return true
 31080		}
 31081		// match: (Lsh8x64 x (Const64 [0]))
 31082		// cond:
 31083		// result: x
 31084		for {
 31085			_ = v.Args[1]
 31086			x := v.Args[0]
 31087			v_1 := v.Args[1]
 31088			if v_1.Op != OpConst64 {
 31089				break
 31090			}
 31091			if v_1.AuxInt != 0 {
 31092				break
 31093			}
 31094			v.reset(OpCopy)
 31095			v.Type = x.Type
 31096			v.AddArg(x)
 31097			return true
 31098		}
 31099		// match: (Lsh8x64 (Const8 [0]) _)
 31100		// cond:
 31101		// result: (Const8 [0])
 31102		for {
 31103			_ = v.Args[1]
 31104			v_0 := v.Args[0]
 31105			if v_0.Op != OpConst8 {
 31106				break
 31107			}
 31108			if v_0.AuxInt != 0 {
 31109				break
 31110			}
 31111			v.reset(OpConst8)
 31112			v.AuxInt = 0
 31113			return true
 31114		}
 31115		// match: (Lsh8x64 _ (Const64 [c]))
 31116		// cond: uint64(c) >= 8
 31117		// result: (Const8 [0])
 31118		for {
 31119			_ = v.Args[1]
 31120			v_1 := v.Args[1]
 31121			if v_1.Op != OpConst64 {
 31122				break
 31123			}
 31124			c := v_1.AuxInt
 31125			if !(uint64(c) >= 8) {
 31126				break
 31127			}
 31128			v.reset(OpConst8)
 31129			v.AuxInt = 0
 31130			return true
 31131		}
 31132		// match: (Lsh8x64 <t> (Lsh8x64 x (Const64 [c])) (Const64 [d]))
 31133		// cond: !uaddOvf(c,d)
 31134		// result: (Lsh8x64 x (Const64 <t> [c+d]))
 31135		for {
 31136			t := v.Type
 31137			_ = v.Args[1]
 31138			v_0 := v.Args[0]
 31139			if v_0.Op != OpLsh8x64 {
 31140				break
 31141			}
 31142			_ = v_0.Args[1]
 31143			x := v_0.Args[0]
 31144			v_0_1 := v_0.Args[1]
 31145			if v_0_1.Op != OpConst64 {
 31146				break
 31147			}
 31148			c := v_0_1.AuxInt
 31149			v_1 := v.Args[1]
 31150			if v_1.Op != OpConst64 {
 31151				break
 31152			}
 31153			d := v_1.AuxInt
 31154			if !(!uaddOvf(c, d)) {
 31155				break
 31156			}
 31157			v.reset(OpLsh8x64)
 31158			v.AddArg(x)
 31159			v0 := b.NewValue0(v.Pos, OpConst64, t)
 31160			v0.AuxInt = c + d
 31161			v.AddArg(v0)
 31162			return true
 31163		}
 31164		// match: (Lsh8x64 (Rsh8Ux64 (Lsh8x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
 31165		// cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
 31166		// result: (Lsh8x64 x (Const64 <typ.UInt64> [c1-c2+c3]))
 31167		for {
 31168			_ = v.Args[1]
 31169			v_0 := v.Args[0]
 31170			if v_0.Op != OpRsh8Ux64 {
 31171				break
 31172			}
 31173			_ = v_0.Args[1]
 31174			v_0_0 := v_0.Args[0]
 31175			if v_0_0.Op != OpLsh8x64 {
 31176				break
 31177			}
 31178			_ = v_0_0.Args[1]
 31179			x := v_0_0.Args[0]
 31180			v_0_0_1 := v_0_0.Args[1]
 31181			if v_0_0_1.Op != OpConst64 {
 31182				break
 31183			}
 31184			c1 := v_0_0_1.AuxInt
 31185			v_0_1 := v_0.Args[1]
 31186			if v_0_1.Op != OpConst64 {
 31187				break
 31188			}
 31189			c2 := v_0_1.AuxInt
 31190			v_1 := v.Args[1]
 31191			if v_1.Op != OpConst64 {
 31192				break
 31193			}
 31194			c3 := v_1.AuxInt
 31195			if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) {
 31196				break
 31197			}
 31198			v.reset(OpLsh8x64)
 31199			v.AddArg(x)
 31200			v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 31201			v0.AuxInt = c1 - c2 + c3
 31202			v.AddArg(v0)
 31203			return true
 31204		}
 31205		return false
 31206	}
 31207	func rewriteValuegeneric_OpLsh8x8_0(v *Value) bool {
 31208		b := v.Block
 31209		// match: (Lsh8x8 <t> x (Const8 [c]))
 31210		// cond:
 31211		// result: (Lsh8x64 x (Const64 <t> [int64(uint8(c))]))
 31212		for {
 31213			t := v.Type
 31214			_ = v.Args[1]
 31215			x := v.Args[0]
 31216			v_1 := v.Args[1]
 31217			if v_1.Op != OpConst8 {
 31218				break
 31219			}
 31220			c := v_1.AuxInt
 31221			v.reset(OpLsh8x64)
 31222			v.AddArg(x)
 31223			v0 := b.NewValue0(v.Pos, OpConst64, t)
 31224			v0.AuxInt = int64(uint8(c))
 31225			v.AddArg(v0)
 31226			return true
 31227		}
 31228		// match: (Lsh8x8 (Const8 [0]) _)
 31229		// cond:
 31230		// result: (Const8 [0])
 31231		for {
 31232			_ = v.Args[1]
 31233			v_0 := v.Args[0]
 31234			if v_0.Op != OpConst8 {
 31235				break
 31236			}
 31237			if v_0.AuxInt != 0 {
 31238				break
 31239			}
 31240			v.reset(OpConst8)
 31241			v.AuxInt = 0
 31242			return true
 31243		}
 31244		return false
 31245	}
 31246	func rewriteValuegeneric_OpMod16_0(v *Value) bool {
 31247		b := v.Block
 31248		// match: (Mod16 (Const16 [c]) (Const16 [d]))
 31249		// cond: d != 0
 31250		// result: (Const16 [int64(int16(c % d))])
 31251		for {
 31252			_ = v.Args[1]
 31253			v_0 := v.Args[0]
 31254			if v_0.Op != OpConst16 {
 31255				break
 31256			}
 31257			c := v_0.AuxInt
 31258			v_1 := v.Args[1]
 31259			if v_1.Op != OpConst16 {
 31260				break
 31261			}
 31262			d := v_1.AuxInt
 31263			if !(d != 0) {
 31264				break
 31265			}
 31266			v.reset(OpConst16)
 31267			v.AuxInt = int64(int16(c % d))
 31268			return true
 31269		}
 31270		// match: (Mod16 <t> n (Const16 [c]))
 31271		// cond: isNonNegative(n) && isPowerOfTwo(c&0xffff)
 31272		// result: (And16 n (Const16 <t> [(c&0xffff)-1]))
 31273		for {
 31274			t := v.Type
 31275			_ = v.Args[1]
 31276			n := v.Args[0]
 31277			v_1 := v.Args[1]
 31278			if v_1.Op != OpConst16 {
 31279				break
 31280			}
 31281			c := v_1.AuxInt
 31282			if !(isNonNegative(n) && isPowerOfTwo(c&0xffff)) {
 31283				break
 31284			}
 31285			v.reset(OpAnd16)
 31286			v.AddArg(n)
 31287			v0 := b.NewValue0(v.Pos, OpConst16, t)
 31288			v0.AuxInt = (c & 0xffff) - 1
 31289			v.AddArg(v0)
 31290			return true
 31291		}
 31292		// match: (Mod16 <t> n (Const16 [c]))
 31293		// cond: c < 0 && c != -1<<15
 31294		// result: (Mod16 <t> n (Const16 <t> [-c]))
 31295		for {
 31296			t := v.Type
 31297			_ = v.Args[1]
 31298			n := v.Args[0]
 31299			v_1 := v.Args[1]
 31300			if v_1.Op != OpConst16 {
 31301				break
 31302			}
 31303			c := v_1.AuxInt
 31304			if !(c < 0 && c != -1<<15) {
 31305				break
 31306			}
 31307			v.reset(OpMod16)
 31308			v.Type = t
 31309			v.AddArg(n)
 31310			v0 := b.NewValue0(v.Pos, OpConst16, t)
 31311			v0.AuxInt = -c
 31312			v.AddArg(v0)
 31313			return true
 31314		}
 31315		// match: (Mod16 <t> x (Const16 [c]))
 31316		// cond: x.Op != OpConst16 && (c > 0 || c == -1<<15)
 31317		// result: (Sub16 x (Mul16 <t> (Div16 <t> x (Const16 <t> [c])) (Const16 <t> [c])))
 31318		for {
 31319			t := v.Type
 31320			_ = v.Args[1]
 31321			x := v.Args[0]
 31322			v_1 := v.Args[1]
 31323			if v_1.Op != OpConst16 {
 31324				break
 31325			}
 31326			c := v_1.AuxInt
 31327			if !(x.Op != OpConst16 && (c > 0 || c == -1<<15)) {
 31328				break
 31329			}
 31330			v.reset(OpSub16)
 31331			v.AddArg(x)
 31332			v0 := b.NewValue0(v.Pos, OpMul16, t)
 31333			v1 := b.NewValue0(v.Pos, OpDiv16, t)
 31334			v1.AddArg(x)
 31335			v2 := b.NewValue0(v.Pos, OpConst16, t)
 31336			v2.AuxInt = c
 31337			v1.AddArg(v2)
 31338			v0.AddArg(v1)
 31339			v3 := b.NewValue0(v.Pos, OpConst16, t)
 31340			v3.AuxInt = c
 31341			v0.AddArg(v3)
 31342			v.AddArg(v0)
 31343			return true
 31344		}
 31345		return false
 31346	}
 31347	func rewriteValuegeneric_OpMod16u_0(v *Value) bool {
 31348		b := v.Block
 31349		// match: (Mod16u (Const16 [c]) (Const16 [d]))
 31350		// cond: d != 0
 31351		// result: (Const16 [int64(uint16(c) % uint16(d))])
 31352		for {
 31353			_ = v.Args[1]
 31354			v_0 := v.Args[0]
 31355			if v_0.Op != OpConst16 {
 31356				break
 31357			}
 31358			c := v_0.AuxInt
 31359			v_1 := v.Args[1]
 31360			if v_1.Op != OpConst16 {
 31361				break
 31362			}
 31363			d := v_1.AuxInt
 31364			if !(d != 0) {
 31365				break
 31366			}
 31367			v.reset(OpConst16)
 31368			v.AuxInt = int64(uint16(c) % uint16(d))
 31369			return true
 31370		}
 31371		// match: (Mod16u <t> n (Const16 [c]))
 31372		// cond: isPowerOfTwo(c&0xffff)
 31373		// result: (And16 n (Const16 <t> [(c&0xffff)-1]))
 31374		for {
 31375			t := v.Type
 31376			_ = v.Args[1]
 31377			n := v.Args[0]
 31378			v_1 := v.Args[1]
 31379			if v_1.Op != OpConst16 {
 31380				break
 31381			}
 31382			c := v_1.AuxInt
 31383			if !(isPowerOfTwo(c & 0xffff)) {
 31384				break
 31385			}
 31386			v.reset(OpAnd16)
 31387			v.AddArg(n)
 31388			v0 := b.NewValue0(v.Pos, OpConst16, t)
 31389			v0.AuxInt = (c & 0xffff) - 1
 31390			v.AddArg(v0)
 31391			return true
 31392		}
 31393		// match: (Mod16u <t> x (Const16 [c]))
 31394		// cond: x.Op != OpConst16 && c > 0 && umagicOK(16,c)
 31395		// result: (Sub16 x (Mul16 <t> (Div16u <t> x (Const16 <t> [c])) (Const16 <t> [c])))
 31396		for {
 31397			t := v.Type
 31398			_ = v.Args[1]
 31399			x := v.Args[0]
 31400			v_1 := v.Args[1]
 31401			if v_1.Op != OpConst16 {
 31402				break
 31403			}
 31404			c := v_1.AuxInt
 31405			if !(x.Op != OpConst16 && c > 0 && umagicOK(16, c)) {
 31406				break
 31407			}
 31408			v.reset(OpSub16)
 31409			v.AddArg(x)
 31410			v0 := b.NewValue0(v.Pos, OpMul16, t)
 31411			v1 := b.NewValue0(v.Pos, OpDiv16u, t)
 31412			v1.AddArg(x)
 31413			v2 := b.NewValue0(v.Pos, OpConst16, t)
 31414			v2.AuxInt = c
 31415			v1.AddArg(v2)
 31416			v0.AddArg(v1)
 31417			v3 := b.NewValue0(v.Pos, OpConst16, t)
 31418			v3.AuxInt = c
 31419			v0.AddArg(v3)
 31420			v.AddArg(v0)
 31421			return true
 31422		}
 31423		return false
 31424	}
 31425	func rewriteValuegeneric_OpMod32_0(v *Value) bool {
 31426		b := v.Block
 31427		// match: (Mod32 (Const32 [c]) (Const32 [d]))
 31428		// cond: d != 0
 31429		// result: (Const32 [int64(int32(c % d))])
 31430		for {
 31431			_ = v.Args[1]
 31432			v_0 := v.Args[0]
 31433			if v_0.Op != OpConst32 {
 31434				break
 31435			}
 31436			c := v_0.AuxInt
 31437			v_1 := v.Args[1]
 31438			if v_1.Op != OpConst32 {
 31439				break
 31440			}
 31441			d := v_1.AuxInt
 31442			if !(d != 0) {
 31443				break
 31444			}
 31445			v.reset(OpConst32)
 31446			v.AuxInt = int64(int32(c % d))
 31447			return true
 31448		}
 31449		// match: (Mod32 <t> n (Const32 [c]))
 31450		// cond: isNonNegative(n) && isPowerOfTwo(c&0xffffffff)
 31451		// result: (And32 n (Const32 <t> [(c&0xffffffff)-1]))
 31452		for {
 31453			t := v.Type
 31454			_ = v.Args[1]
 31455			n := v.Args[0]
 31456			v_1 := v.Args[1]
 31457			if v_1.Op != OpConst32 {
 31458				break
 31459			}
 31460			c := v_1.AuxInt
 31461			if !(isNonNegative(n) && isPowerOfTwo(c&0xffffffff)) {
 31462				break
 31463			}
 31464			v.reset(OpAnd32)
 31465			v.AddArg(n)
 31466			v0 := b.NewValue0(v.Pos, OpConst32, t)
 31467			v0.AuxInt = (c & 0xffffffff) - 1
 31468			v.AddArg(v0)
 31469			return true
 31470		}
 31471		// match: (Mod32 <t> n (Const32 [c]))
 31472		// cond: c < 0 && c != -1<<31
 31473		// result: (Mod32 <t> n (Const32 <t> [-c]))
 31474		for {
 31475			t := v.Type
 31476			_ = v.Args[1]
 31477			n := v.Args[0]
 31478			v_1 := v.Args[1]
 31479			if v_1.Op != OpConst32 {
 31480				break
 31481			}
 31482			c := v_1.AuxInt
 31483			if !(c < 0 && c != -1<<31) {
 31484				break
 31485			}
 31486			v.reset(OpMod32)
 31487			v.Type = t
 31488			v.AddArg(n)
 31489			v0 := b.NewValue0(v.Pos, OpConst32, t)
 31490			v0.AuxInt = -c
 31491			v.AddArg(v0)
 31492			return true
 31493		}
 31494		// match: (Mod32 <t> x (Const32 [c]))
 31495		// cond: x.Op != OpConst32 && (c > 0 || c == -1<<31)
 31496		// result: (Sub32 x (Mul32 <t> (Div32 <t> x (Const32 <t> [c])) (Const32 <t> [c])))
 31497		for {
 31498			t := v.Type
 31499			_ = v.Args[1]
 31500			x := v.Args[0]
 31501			v_1 := v.Args[1]
 31502			if v_1.Op != OpConst32 {
 31503				break
 31504			}
 31505			c := v_1.AuxInt
 31506			if !(x.Op != OpConst32 && (c > 0 || c == -1<<31)) {
 31507				break
 31508			}
 31509			v.reset(OpSub32)
 31510			v.AddArg(x)
 31511			v0 := b.NewValue0(v.Pos, OpMul32, t)
 31512			v1 := b.NewValue0(v.Pos, OpDiv32, t)
 31513			v1.AddArg(x)
 31514			v2 := b.NewValue0(v.Pos, OpConst32, t)
 31515			v2.AuxInt = c
 31516			v1.AddArg(v2)
 31517			v0.AddArg(v1)
 31518			v3 := b.NewValue0(v.Pos, OpConst32, t)
 31519			v3.AuxInt = c
 31520			v0.AddArg(v3)
 31521			v.AddArg(v0)
 31522			return true
 31523		}
 31524		return false
 31525	}
 31526	func rewriteValuegeneric_OpMod32u_0(v *Value) bool {
 31527		b := v.Block
 31528		// match: (Mod32u (Const32 [c]) (Const32 [d]))
 31529		// cond: d != 0
 31530		// result: (Const32 [int64(uint32(c) % uint32(d))])
 31531		for {
 31532			_ = v.Args[1]
 31533			v_0 := v.Args[0]
 31534			if v_0.Op != OpConst32 {
 31535				break
 31536			}
 31537			c := v_0.AuxInt
 31538			v_1 := v.Args[1]
 31539			if v_1.Op != OpConst32 {
 31540				break
 31541			}
 31542			d := v_1.AuxInt
 31543			if !(d != 0) {
 31544				break
 31545			}
 31546			v.reset(OpConst32)
 31547			v.AuxInt = int64(uint32(c) % uint32(d))
 31548			return true
 31549		}
 31550		// match: (Mod32u <t> n (Const32 [c]))
 31551		// cond: isPowerOfTwo(c&0xffffffff)
 31552		// result: (And32 n (Const32 <t> [(c&0xffffffff)-1]))
 31553		for {
 31554			t := v.Type
 31555			_ = v.Args[1]
 31556			n := v.Args[0]
 31557			v_1 := v.Args[1]
 31558			if v_1.Op != OpConst32 {
 31559				break
 31560			}
 31561			c := v_1.AuxInt
 31562			if !(isPowerOfTwo(c & 0xffffffff)) {
 31563				break
 31564			}
 31565			v.reset(OpAnd32)
 31566			v.AddArg(n)
 31567			v0 := b.NewValue0(v.Pos, OpConst32, t)
 31568			v0.AuxInt = (c & 0xffffffff) - 1
 31569			v.AddArg(v0)
 31570			return true
 31571		}
 31572		// match: (Mod32u <t> x (Const32 [c]))
 31573		// cond: x.Op != OpConst32 && c > 0 && umagicOK(32,c)
 31574		// result: (Sub32 x (Mul32 <t> (Div32u <t> x (Const32 <t> [c])) (Const32 <t> [c])))
 31575		for {
 31576			t := v.Type
 31577			_ = v.Args[1]
 31578			x := v.Args[0]
 31579			v_1 := v.Args[1]
 31580			if v_1.Op != OpConst32 {
 31581				break
 31582			}
 31583			c := v_1.AuxInt
 31584			if !(x.Op != OpConst32 && c > 0 && umagicOK(32, c)) {
 31585				break
 31586			}
 31587			v.reset(OpSub32)
 31588			v.AddArg(x)
 31589			v0 := b.NewValue0(v.Pos, OpMul32, t)
 31590			v1 := b.NewValue0(v.Pos, OpDiv32u, t)
 31591			v1.AddArg(x)
 31592			v2 := b.NewValue0(v.Pos, OpConst32, t)
 31593			v2.AuxInt = c
 31594			v1.AddArg(v2)
 31595			v0.AddArg(v1)
 31596			v3 := b.NewValue0(v.Pos, OpConst32, t)
 31597			v3.AuxInt = c
 31598			v0.AddArg(v3)
 31599			v.AddArg(v0)
 31600			return true
 31601		}
 31602		return false
 31603	}
 31604	func rewriteValuegeneric_OpMod64_0(v *Value) bool {
 31605		b := v.Block
 31606		// match: (Mod64 (Const64 [c]) (Const64 [d]))
 31607		// cond: d != 0
 31608		// result: (Const64 [c % d])
 31609		for {
 31610			_ = v.Args[1]
 31611			v_0 := v.Args[0]
 31612			if v_0.Op != OpConst64 {
 31613				break
 31614			}
 31615			c := v_0.AuxInt
 31616			v_1 := v.Args[1]
 31617			if v_1.Op != OpConst64 {
 31618				break
 31619			}
 31620			d := v_1.AuxInt
 31621			if !(d != 0) {
 31622				break
 31623			}
 31624			v.reset(OpConst64)
 31625			v.AuxInt = c % d
 31626			return true
 31627		}
 31628		// match: (Mod64 <t> n (Const64 [c]))
 31629		// cond: isNonNegative(n) && isPowerOfTwo(c)
 31630		// result: (And64 n (Const64 <t> [c-1]))
 31631		for {
 31632			t := v.Type
 31633			_ = v.Args[1]
 31634			n := v.Args[0]
 31635			v_1 := v.Args[1]
 31636			if v_1.Op != OpConst64 {
 31637				break
 31638			}
 31639			c := v_1.AuxInt
 31640			if !(isNonNegative(n) && isPowerOfTwo(c)) {
 31641				break
 31642			}
 31643			v.reset(OpAnd64)
 31644			v.AddArg(n)
 31645			v0 := b.NewValue0(v.Pos, OpConst64, t)
 31646			v0.AuxInt = c - 1
 31647			v.AddArg(v0)
 31648			return true
 31649		}
 31650		// match: (Mod64 n (Const64 [-1<<63]))
 31651		// cond: isNonNegative(n)
 31652		// result: n
 31653		for {
 31654			_ = v.Args[1]
 31655			n := v.Args[0]
 31656			v_1 := v.Args[1]
 31657			if v_1.Op != OpConst64 {
 31658				break
 31659			}
 31660			if v_1.AuxInt != -1<<63 {
 31661				break
 31662			}
 31663			if !(isNonNegative(n)) {
 31664				break
 31665			}
 31666			v.reset(OpCopy)
 31667			v.Type = n.Type
 31668			v.AddArg(n)
 31669			return true
 31670		}
 31671		// match: (Mod64 <t> n (Const64 [c]))
 31672		// cond: c < 0 && c != -1<<63
 31673		// result: (Mod64 <t> n (Const64 <t> [-c]))
 31674		for {
 31675			t := v.Type
 31676			_ = v.Args[1]
 31677			n := v.Args[0]
 31678			v_1 := v.Args[1]
 31679			if v_1.Op != OpConst64 {
 31680				break
 31681			}
 31682			c := v_1.AuxInt
 31683			if !(c < 0 && c != -1<<63) {
 31684				break
 31685			}
 31686			v.reset(OpMod64)
 31687			v.Type = t
 31688			v.AddArg(n)
 31689			v0 := b.NewValue0(v.Pos, OpConst64, t)
 31690			v0.AuxInt = -c
 31691			v.AddArg(v0)
 31692			return true
 31693		}
 31694		// match: (Mod64 <t> x (Const64 [c]))
 31695		// cond: x.Op != OpConst64 && (c > 0 || c == -1<<63)
 31696		// result: (Sub64 x (Mul64 <t> (Div64 <t> x (Const64 <t> [c])) (Const64 <t> [c])))
 31697		for {
 31698			t := v.Type
 31699			_ = v.Args[1]
 31700			x := v.Args[0]
 31701			v_1 := v.Args[1]
 31702			if v_1.Op != OpConst64 {
 31703				break
 31704			}
 31705			c := v_1.AuxInt
 31706			if !(x.Op != OpConst64 && (c > 0 || c == -1<<63)) {
 31707				break
 31708			}
 31709			v.reset(OpSub64)
 31710			v.AddArg(x)
 31711			v0 := b.NewValue0(v.Pos, OpMul64, t)
 31712			v1 := b.NewValue0(v.Pos, OpDiv64, t)
 31713			v1.AddArg(x)
 31714			v2 := b.NewValue0(v.Pos, OpConst64, t)
 31715			v2.AuxInt = c
 31716			v1.AddArg(v2)
 31717			v0.AddArg(v1)
 31718			v3 := b.NewValue0(v.Pos, OpConst64, t)
 31719			v3.AuxInt = c
 31720			v0.AddArg(v3)
 31721			v.AddArg(v0)
 31722			return true
 31723		}
 31724		return false
 31725	}
 31726	func rewriteValuegeneric_OpMod64u_0(v *Value) bool {
 31727		b := v.Block
 31728		// match: (Mod64u (Const64 [c]) (Const64 [d]))
 31729		// cond: d != 0
 31730		// result: (Const64 [int64(uint64(c) % uint64(d))])
 31731		for {
 31732			_ = v.Args[1]
 31733			v_0 := v.Args[0]
 31734			if v_0.Op != OpConst64 {
 31735				break
 31736			}
 31737			c := v_0.AuxInt
 31738			v_1 := v.Args[1]
 31739			if v_1.Op != OpConst64 {
 31740				break
 31741			}
 31742			d := v_1.AuxInt
 31743			if !(d != 0) {
 31744				break
 31745			}
 31746			v.reset(OpConst64)
 31747			v.AuxInt = int64(uint64(c) % uint64(d))
 31748			return true
 31749		}
 31750		// match: (Mod64u <t> n (Const64 [c]))
 31751		// cond: isPowerOfTwo(c)
 31752		// result: (And64 n (Const64 <t> [c-1]))
 31753		for {
 31754			t := v.Type
 31755			_ = v.Args[1]
 31756			n := v.Args[0]
 31757			v_1 := v.Args[1]
 31758			if v_1.Op != OpConst64 {
 31759				break
 31760			}
 31761			c := v_1.AuxInt
 31762			if !(isPowerOfTwo(c)) {
 31763				break
 31764			}
 31765			v.reset(OpAnd64)
 31766			v.AddArg(n)
 31767			v0 := b.NewValue0(v.Pos, OpConst64, t)
 31768			v0.AuxInt = c - 1
 31769			v.AddArg(v0)
 31770			return true
 31771		}
 31772		// match: (Mod64u <t> n (Const64 [-1<<63]))
 31773		// cond:
 31774		// result: (And64 n (Const64 <t> [1<<63-1]))
 31775		for {
 31776			t := v.Type
 31777			_ = v.Args[1]
 31778			n := v.Args[0]
 31779			v_1 := v.Args[1]
 31780			if v_1.Op != OpConst64 {
 31781				break
 31782			}
 31783			if v_1.AuxInt != -1<<63 {
 31784				break
 31785			}
 31786			v.reset(OpAnd64)
 31787			v.AddArg(n)
 31788			v0 := b.NewValue0(v.Pos, OpConst64, t)
 31789			v0.AuxInt = 1<<63 - 1
 31790			v.AddArg(v0)
 31791			return true
 31792		}
 31793		// match: (Mod64u <t> x (Const64 [c]))
 31794		// cond: x.Op != OpConst64 && c > 0 && umagicOK(64,c)
 31795		// result: (Sub64 x (Mul64 <t> (Div64u <t> x (Const64 <t> [c])) (Const64 <t> [c])))
 31796		for {
 31797			t := v.Type
 31798			_ = v.Args[1]
 31799			x := v.Args[0]
 31800			v_1 := v.Args[1]
 31801			if v_1.Op != OpConst64 {
 31802				break
 31803			}
 31804			c := v_1.AuxInt
 31805			if !(x.Op != OpConst64 && c > 0 && umagicOK(64, c)) {
 31806				break
 31807			}
 31808			v.reset(OpSub64)
 31809			v.AddArg(x)
 31810			v0 := b.NewValue0(v.Pos, OpMul64, t)
 31811			v1 := b.NewValue0(v.Pos, OpDiv64u, t)
 31812			v1.AddArg(x)
 31813			v2 := b.NewValue0(v.Pos, OpConst64, t)
 31814			v2.AuxInt = c
 31815			v1.AddArg(v2)
 31816			v0.AddArg(v1)
 31817			v3 := b.NewValue0(v.Pos, OpConst64, t)
 31818			v3.AuxInt = c
 31819			v0.AddArg(v3)
 31820			v.AddArg(v0)
 31821			return true
 31822		}
 31823		return false
 31824	}
 31825	func rewriteValuegeneric_OpMod8_0(v *Value) bool {
 31826		b := v.Block
 31827		// match: (Mod8 (Const8 [c]) (Const8 [d]))
 31828		// cond: d != 0
 31829		// result: (Const8 [int64(int8(c % d))])
 31830		for {
 31831			_ = v.Args[1]
 31832			v_0 := v.Args[0]
 31833			if v_0.Op != OpConst8 {
 31834				break
 31835			}
 31836			c := v_0.AuxInt
 31837			v_1 := v.Args[1]
 31838			if v_1.Op != OpConst8 {
 31839				break
 31840			}
 31841			d := v_1.AuxInt
 31842			if !(d != 0) {
 31843				break
 31844			}
 31845			v.reset(OpConst8)
 31846			v.AuxInt = int64(int8(c % d))
 31847			return true
 31848		}
 31849		// match: (Mod8 <t> n (Const8 [c]))
 31850		// cond: isNonNegative(n) && isPowerOfTwo(c&0xff)
 31851		// result: (And8 n (Const8 <t> [(c&0xff)-1]))
 31852		for {
 31853			t := v.Type
 31854			_ = v.Args[1]
 31855			n := v.Args[0]
 31856			v_1 := v.Args[1]
 31857			if v_1.Op != OpConst8 {
 31858				break
 31859			}
 31860			c := v_1.AuxInt
 31861			if !(isNonNegative(n) && isPowerOfTwo(c&0xff)) {
 31862				break
 31863			}
 31864			v.reset(OpAnd8)
 31865			v.AddArg(n)
 31866			v0 := b.NewValue0(v.Pos, OpConst8, t)
 31867			v0.AuxInt = (c & 0xff) - 1
 31868			v.AddArg(v0)
 31869			return true
 31870		}
 31871		// match: (Mod8 <t> n (Const8 [c]))
 31872		// cond: c < 0 && c != -1<<7
 31873		// result: (Mod8 <t> n (Const8 <t> [-c]))
 31874		for {
 31875			t := v.Type
 31876			_ = v.Args[1]
 31877			n := v.Args[0]
 31878			v_1 := v.Args[1]
 31879			if v_1.Op != OpConst8 {
 31880				break
 31881			}
 31882			c := v_1.AuxInt
 31883			if !(c < 0 && c != -1<<7) {
 31884				break
 31885			}
 31886			v.reset(OpMod8)
 31887			v.Type = t
 31888			v.AddArg(n)
 31889			v0 := b.NewValue0(v.Pos, OpConst8, t)
 31890			v0.AuxInt = -c
 31891			v.AddArg(v0)
 31892			return true
 31893		}
 31894		// match: (Mod8 <t> x (Const8 [c]))
 31895		// cond: x.Op != OpConst8 && (c > 0 || c == -1<<7)
 31896		// result: (Sub8 x (Mul8 <t> (Div8 <t> x (Const8 <t> [c])) (Const8 <t> [c])))
 31897		for {
 31898			t := v.Type
 31899			_ = v.Args[1]
 31900			x := v.Args[0]
 31901			v_1 := v.Args[1]
 31902			if v_1.Op != OpConst8 {
 31903				break
 31904			}
 31905			c := v_1.AuxInt
 31906			if !(x.Op != OpConst8 && (c > 0 || c == -1<<7)) {
 31907				break
 31908			}
 31909			v.reset(OpSub8)
 31910			v.AddArg(x)
 31911			v0 := b.NewValue0(v.Pos, OpMul8, t)
 31912			v1 := b.NewValue0(v.Pos, OpDiv8, t)
 31913			v1.AddArg(x)
 31914			v2 := b.NewValue0(v.Pos, OpConst8, t)
 31915			v2.AuxInt = c
 31916			v1.AddArg(v2)
 31917			v0.AddArg(v1)
 31918			v3 := b.NewValue0(v.Pos, OpConst8, t)
 31919			v3.AuxInt = c
 31920			v0.AddArg(v3)
 31921			v.AddArg(v0)
 31922			return true
 31923		}
 31924		return false
 31925	}
 31926	func rewriteValuegeneric_OpMod8u_0(v *Value) bool {
 31927		b := v.Block
 31928		// match: (Mod8u (Const8 [c]) (Const8 [d]))
 31929		// cond: d != 0
 31930		// result: (Const8 [int64(uint8(c) % uint8(d))])
 31931		for {
 31932			_ = v.Args[1]
 31933			v_0 := v.Args[0]
 31934			if v_0.Op != OpConst8 {
 31935				break
 31936			}
 31937			c := v_0.AuxInt
 31938			v_1 := v.Args[1]
 31939			if v_1.Op != OpConst8 {
 31940				break
 31941			}
 31942			d := v_1.AuxInt
 31943			if !(d != 0) {
 31944				break
 31945			}
 31946			v.reset(OpConst8)
 31947			v.AuxInt = int64(uint8(c) % uint8(d))
 31948			return true
 31949		}
 31950		// match: (Mod8u <t> n (Const8 [c]))
 31951		// cond: isPowerOfTwo(c&0xff)
 31952		// result: (And8 n (Const8 <t> [(c&0xff)-1]))
 31953		for {
 31954			t := v.Type
 31955			_ = v.Args[1]
 31956			n := v.Args[0]
 31957			v_1 := v.Args[1]
 31958			if v_1.Op != OpConst8 {
 31959				break
 31960			}
 31961			c := v_1.AuxInt
 31962			if !(isPowerOfTwo(c & 0xff)) {
 31963				break
 31964			}
 31965			v.reset(OpAnd8)
 31966			v.AddArg(n)
 31967			v0 := b.NewValue0(v.Pos, OpConst8, t)
 31968			v0.AuxInt = (c & 0xff) - 1
 31969			v.AddArg(v0)
 31970			return true
 31971		}
 31972		// match: (Mod8u <t> x (Const8 [c]))
 31973		// cond: x.Op != OpConst8 && c > 0 && umagicOK(8, c)
 31974		// result: (Sub8 x (Mul8 <t> (Div8u <t> x (Const8 <t> [c])) (Const8 <t> [c])))
 31975		for {
 31976			t := v.Type
 31977			_ = v.Args[1]
 31978			x := v.Args[0]
 31979			v_1 := v.Args[1]
 31980			if v_1.Op != OpConst8 {
 31981				break
 31982			}
 31983			c := v_1.AuxInt
 31984			if !(x.Op != OpConst8 && c > 0 && umagicOK(8, c)) {
 31985				break
 31986			}
 31987			v.reset(OpSub8)
 31988			v.AddArg(x)
 31989			v0 := b.NewValue0(v.Pos, OpMul8, t)
 31990			v1 := b.NewValue0(v.Pos, OpDiv8u, t)
 31991			v1.AddArg(x)
 31992			v2 := b.NewValue0(v.Pos, OpConst8, t)
 31993			v2.AuxInt = c
 31994			v1.AddArg(v2)
 31995			v0.AddArg(v1)
 31996			v3 := b.NewValue0(v.Pos, OpConst8, t)
 31997			v3.AuxInt = c
 31998			v0.AddArg(v3)
 31999			v.AddArg(v0)
 32000			return true
 32001		}
 32002		return false
 32003	}
 32004	func rewriteValuegeneric_OpMove_0(v *Value) bool {
 32005		b := v.Block
 32006		// match: (Move {t} [n] dst1 src mem:(Zero {t} [n] dst2 _))
 32007		// cond: isSamePtr(src, dst2)
 32008		// result: (Zero {t} [n] dst1 mem)
 32009		for {
 32010			n := v.AuxInt
 32011			t := v.Aux
 32012			_ = v.Args[2]
 32013			dst1 := v.Args[0]
 32014			src := v.Args[1]
 32015			mem := v.Args[2]
 32016			if mem.Op != OpZero {
 32017				break
 32018			}
 32019			if mem.AuxInt != n {
 32020				break
 32021			}
 32022			if mem.Aux != t {
 32023				break
 32024			}
 32025			_ = mem.Args[1]
 32026			dst2 := mem.Args[0]
 32027			if !(isSamePtr(src, dst2)) {
 32028				break
 32029			}
 32030			v.reset(OpZero)
 32031			v.AuxInt = n
 32032			v.Aux = t
 32033			v.AddArg(dst1)
 32034			v.AddArg(mem)
 32035			return true
 32036		}
 32037		// match: (Move {t} [n] dst1 src mem:(VarDef (Zero {t} [n] dst0 _)))
 32038		// cond: isSamePtr(src, dst0)
 32039		// result: (Zero {t} [n] dst1 mem)
 32040		for {
 32041			n := v.AuxInt
 32042			t := v.Aux
 32043			_ = v.Args[2]
 32044			dst1 := v.Args[0]
 32045			src := v.Args[1]
 32046			mem := v.Args[2]
 32047			if mem.Op != OpVarDef {
 32048				break
 32049			}
 32050			mem_0 := mem.Args[0]
 32051			if mem_0.Op != OpZero {
 32052				break
 32053			}
 32054			if mem_0.AuxInt != n {
 32055				break
 32056			}
 32057			if mem_0.Aux != t {
 32058				break
 32059			}
 32060			_ = mem_0.Args[1]
 32061			dst0 := mem_0.Args[0]
 32062			if !(isSamePtr(src, dst0)) {
 32063				break
 32064			}
 32065			v.reset(OpZero)
 32066			v.AuxInt = n
 32067			v.Aux = t
 32068			v.AddArg(dst1)
 32069			v.AddArg(mem)
 32070			return true
 32071		}
 32072		// match: (Move {t1} [n] dst1 src1 store:(Store {t2} op:(OffPtr [o2] dst2) _ mem))
 32073		// cond: isSamePtr(dst1, dst2) && store.Uses == 1 && n >= o2 + sizeof(t2) && disjoint(src1, n, op, sizeof(t2)) && clobber(store)
 32074		// result: (Move {t1} [n] dst1 src1 mem)
 32075		for {
 32076			n := v.AuxInt
 32077			t1 := v.Aux
 32078			_ = v.Args[2]
 32079			dst1 := v.Args[0]
 32080			src1 := v.Args[1]
 32081			store := v.Args[2]
 32082			if store.Op != OpStore {
 32083				break
 32084			}
 32085			t2 := store.Aux
 32086			mem := store.Args[2]
 32087			op := store.Args[0]
 32088			if op.Op != OpOffPtr {
 32089				break
 32090			}
 32091			o2 := op.AuxInt
 32092			dst2 := op.Args[0]
 32093			if !(isSamePtr(dst1, dst2) && store.Uses == 1 && n >= o2+sizeof(t2) && disjoint(src1, n, op, sizeof(t2)) && clobber(store)) {
 32094				break
 32095			}
 32096			v.reset(OpMove)
 32097			v.AuxInt = n
 32098			v.Aux = t1
 32099			v.AddArg(dst1)
 32100			v.AddArg(src1)
 32101			v.AddArg(mem)
 32102			return true
 32103		}
 32104		// match: (Move {t} [n] dst1 src1 move:(Move {t} [n] dst2 _ mem))
 32105		// cond: move.Uses == 1 && isSamePtr(dst1, dst2) && disjoint(src1, n, dst2, n) && clobber(move)
 32106		// result: (Move {t} [n] dst1 src1 mem)
 32107		for {
 32108			n := v.AuxInt
 32109			t := v.Aux
 32110			_ = v.Args[2]
 32111			dst1 := v.Args[0]
 32112			src1 := v.Args[1]
 32113			move := v.Args[2]
 32114			if move.Op != OpMove {
 32115				break
 32116			}
 32117			if move.AuxInt != n {
 32118				break
 32119			}
 32120			if move.Aux != t {
 32121				break
 32122			}
 32123			mem := move.Args[2]
 32124			dst2 := move.Args[0]
 32125			if !(move.Uses == 1 && isSamePtr(dst1, dst2) && disjoint(src1, n, dst2, n) && clobber(move)) {
 32126				break
 32127			}
 32128			v.reset(OpMove)
 32129			v.AuxInt = n
 32130			v.Aux = t
 32131			v.AddArg(dst1)
 32132			v.AddArg(src1)
 32133			v.AddArg(mem)
 32134			return true
 32135		}
 32136		// match: (Move {t} [n] dst1 src1 vardef:(VarDef {x} move:(Move {t} [n] dst2 _ mem)))
 32137		// cond: move.Uses == 1 && vardef.Uses == 1 && isSamePtr(dst1, dst2) && disjoint(src1, n, dst2, n) && clobber(move) && clobber(vardef)
 32138		// result: (Move {t} [n] dst1 src1 (VarDef {x} mem))
 32139		for {
 32140			n := v.AuxInt
 32141			t := v.Aux
 32142			_ = v.Args[2]
 32143			dst1 := v.Args[0]
 32144			src1 := v.Args[1]
 32145			vardef := v.Args[2]
 32146			if vardef.Op != OpVarDef {
 32147				break
 32148			}
 32149			x := vardef.Aux
 32150			move := vardef.Args[0]
 32151			if move.Op != OpMove {
 32152				break
 32153			}
 32154			if move.AuxInt != n {
 32155				break
 32156			}
 32157			if move.Aux != t {
 32158				break
 32159			}
 32160			mem := move.Args[2]
 32161			dst2 := move.Args[0]
 32162			if !(move.Uses == 1 && vardef.Uses == 1 && isSamePtr(dst1, dst2) && disjoint(src1, n, dst2, n) && clobber(move) && clobber(vardef)) {
 32163				break
 32164			}
 32165			v.reset(OpMove)
 32166			v.AuxInt = n
 32167			v.Aux = t
 32168			v.AddArg(dst1)
 32169			v.AddArg(src1)
 32170			v0 := b.NewValue0(v.Pos, OpVarDef, types.TypeMem)
 32171			v0.Aux = x
 32172			v0.AddArg(mem)
 32173			v.AddArg(v0)
 32174			return true
 32175		}
 32176		// match: (Move {t} [n] dst1 src1 zero:(Zero {t} [n] dst2 mem))
 32177		// cond: zero.Uses == 1 && isSamePtr(dst1, dst2) && disjoint(src1, n, dst2, n) && clobber(zero)
 32178		// result: (Move {t} [n] dst1 src1 mem)
 32179		for {
 32180			n := v.AuxInt
 32181			t := v.Aux
 32182			_ = v.Args[2]
 32183			dst1 := v.Args[0]
 32184			src1 := v.Args[1]
 32185			zero := v.Args[2]
 32186			if zero.Op != OpZero {
 32187				break
 32188			}
 32189			if zero.AuxInt != n {
 32190				break
 32191			}
 32192			if zero.Aux != t {
 32193				break
 32194			}
 32195			mem := zero.Args[1]
 32196			dst2 := zero.Args[0]
 32197			if !(zero.Uses == 1 && isSamePtr(dst1, dst2) && disjoint(src1, n, dst2, n) && clobber(zero)) {
 32198				break
 32199			}
 32200			v.reset(OpMove)
 32201			v.AuxInt = n
 32202			v.Aux = t
 32203			v.AddArg(dst1)
 32204			v.AddArg(src1)
 32205			v.AddArg(mem)
 32206			return true
 32207		}
 32208		// match: (Move {t} [n] dst1 src1 vardef:(VarDef {x} zero:(Zero {t} [n] dst2 mem)))
 32209		// cond: zero.Uses == 1 && vardef.Uses == 1 && isSamePtr(dst1, dst2) && disjoint(src1, n, dst2, n) && clobber(zero) && clobber(vardef)
 32210		// result: (Move {t} [n] dst1 src1 (VarDef {x} mem))
 32211		for {
 32212			n := v.AuxInt
 32213			t := v.Aux
 32214			_ = v.Args[2]
 32215			dst1 := v.Args[0]
 32216			src1 := v.Args[1]
 32217			vardef := v.Args[2]
 32218			if vardef.Op != OpVarDef {
 32219				break
 32220			}
 32221			x := vardef.Aux
 32222			zero := vardef.Args[0]
 32223			if zero.Op != OpZero {
 32224				break
 32225			}
 32226			if zero.AuxInt != n {
 32227				break
 32228			}
 32229			if zero.Aux != t {
 32230				break
 32231			}
 32232			mem := zero.Args[1]
 32233			dst2 := zero.Args[0]
 32234			if !(zero.Uses == 1 && vardef.Uses == 1 && isSamePtr(dst1, dst2) && disjoint(src1, n, dst2, n) && clobber(zero) && clobber(vardef)) {
 32235				break
 32236			}
 32237			v.reset(OpMove)
 32238			v.AuxInt = n
 32239			v.Aux = t
 32240			v.AddArg(dst1)
 32241			v.AddArg(src1)
 32242			v0 := b.NewValue0(v.Pos, OpVarDef, types.TypeMem)
 32243			v0.Aux = x
 32244			v0.AddArg(mem)
 32245			v.AddArg(v0)
 32246			return true
 32247		}
 32248		// match: (Move {t1} [n] dst p1 mem:(Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Store {t3} op3:(OffPtr <tt3> [0] p3) d2 _)))
 32249		// cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && o2 == sizeof(t3) && n == sizeof(t2) + sizeof(t3)
 32250		// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [0] dst) d2 mem))
 32251		for {
 32252			n := v.AuxInt
 32253			t1 := v.Aux
 32254			_ = v.Args[2]
 32255			dst := v.Args[0]
 32256			p1 := v.Args[1]
 32257			mem := v.Args[2]
 32258			if mem.Op != OpStore {
 32259				break
 32260			}
 32261			t2 := mem.Aux
 32262			_ = mem.Args[2]
 32263			op2 := mem.Args[0]
 32264			if op2.Op != OpOffPtr {
 32265				break
 32266			}
 32267			tt2 := op2.Type
 32268			o2 := op2.AuxInt
 32269			p2 := op2.Args[0]
 32270			d1 := mem.Args[1]
 32271			mem_2 := mem.Args[2]
 32272			if mem_2.Op != OpStore {
 32273				break
 32274			}
 32275			t3 := mem_2.Aux
 32276			_ = mem_2.Args[2]
 32277			op3 := mem_2.Args[0]
 32278			if op3.Op != OpOffPtr {
 32279				break
 32280			}
 32281			tt3 := op3.Type
 32282			if op3.AuxInt != 0 {
 32283				break
 32284			}
 32285			p3 := op3.Args[0]
 32286			d2 := mem_2.Args[1]
 32287			if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && o2 == sizeof(t3) && n == sizeof(t2)+sizeof(t3)) {
 32288				break
 32289			}
 32290			v.reset(OpStore)
 32291			v.Aux = t2
 32292			v0 := b.NewValue0(v.Pos, OpOffPtr, tt2)
 32293			v0.AuxInt = o2
 32294			v0.AddArg(dst)
 32295			v.AddArg(v0)
 32296			v.AddArg(d1)
 32297			v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 32298			v1.Aux = t3
 32299			v2 := b.NewValue0(v.Pos, OpOffPtr, tt3)
 32300			v2.AuxInt = 0
 32301			v2.AddArg(dst)
 32302			v1.AddArg(v2)
 32303			v1.AddArg(d2)
 32304			v1.AddArg(mem)
 32305			v.AddArg(v1)
 32306			return true
 32307		}
 32308		// match: (Move {t1} [n] dst p1 mem:(Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Store {t3} op3:(OffPtr <tt3> [o3] p3) d2 (Store {t4} op4:(OffPtr <tt4> [0] p4) d3 _))))
 32309		// cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && o3 == sizeof(t4) && o2-o3 == sizeof(t3) && n == sizeof(t2) + sizeof(t3) + sizeof(t4)
 32310		// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [0] dst) d3 mem)))
 32311		for {
 32312			n := v.AuxInt
 32313			t1 := v.Aux
 32314			_ = v.Args[2]
 32315			dst := v.Args[0]
 32316			p1 := v.Args[1]
 32317			mem := v.Args[2]
 32318			if mem.Op != OpStore {
 32319				break
 32320			}
 32321			t2 := mem.Aux
 32322			_ = mem.Args[2]
 32323			op2 := mem.Args[0]
 32324			if op2.Op != OpOffPtr {
 32325				break
 32326			}
 32327			tt2 := op2.Type
 32328			o2 := op2.AuxInt
 32329			p2 := op2.Args[0]
 32330			d1 := mem.Args[1]
 32331			mem_2 := mem.Args[2]
 32332			if mem_2.Op != OpStore {
 32333				break
 32334			}
 32335			t3 := mem_2.Aux
 32336			_ = mem_2.Args[2]
 32337			op3 := mem_2.Args[0]
 32338			if op3.Op != OpOffPtr {
 32339				break
 32340			}
 32341			tt3 := op3.Type
 32342			o3 := op3.AuxInt
 32343			p3 := op3.Args[0]
 32344			d2 := mem_2.Args[1]
 32345			mem_2_2 := mem_2.Args[2]
 32346			if mem_2_2.Op != OpStore {
 32347				break
 32348			}
 32349			t4 := mem_2_2.Aux
 32350			_ = mem_2_2.Args[2]
 32351			op4 := mem_2_2.Args[0]
 32352			if op4.Op != OpOffPtr {
 32353				break
 32354			}
 32355			tt4 := op4.Type
 32356			if op4.AuxInt != 0 {
 32357				break
 32358			}
 32359			p4 := op4.Args[0]
 32360			d3 := mem_2_2.Args[1]
 32361			if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && o3 == sizeof(t4) && o2-o3 == sizeof(t3) && n == sizeof(t2)+sizeof(t3)+sizeof(t4)) {
 32362				break
 32363			}
 32364			v.reset(OpStore)
 32365			v.Aux = t2
 32366			v0 := b.NewValue0(v.Pos, OpOffPtr, tt2)
 32367			v0.AuxInt = o2
 32368			v0.AddArg(dst)
 32369			v.AddArg(v0)
 32370			v.AddArg(d1)
 32371			v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 32372			v1.Aux = t3
 32373			v2 := b.NewValue0(v.Pos, OpOffPtr, tt3)
 32374			v2.AuxInt = o3
 32375			v2.AddArg(dst)
 32376			v1.AddArg(v2)
 32377			v1.AddArg(d2)
 32378			v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 32379			v3.Aux = t4
 32380			v4 := b.NewValue0(v.Pos, OpOffPtr, tt4)
 32381			v4.AuxInt = 0
 32382			v4.AddArg(dst)
 32383			v3.AddArg(v4)
 32384			v3.AddArg(d3)
 32385			v3.AddArg(mem)
 32386			v1.AddArg(v3)
 32387			v.AddArg(v1)
 32388			return true
 32389		}
 32390		// match: (Move {t1} [n] dst p1 mem:(Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Store {t3} op3:(OffPtr <tt3> [o3] p3) d2 (Store {t4} op4:(OffPtr <tt4> [o4] p4) d3 (Store {t5} op5:(OffPtr <tt5> [0] p5) d4 _)))))
 32391		// cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && o4 == sizeof(t5) && o3-o4 == sizeof(t4) && o2-o3 == sizeof(t3) && n == sizeof(t2) + sizeof(t3) + sizeof(t4) + sizeof(t5)
 32392		// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [o4] dst) d3 (Store {t5} (OffPtr <tt5> [0] dst) d4 mem))))
 32393		for {
 32394			n := v.AuxInt
 32395			t1 := v.Aux
 32396			_ = v.Args[2]
 32397			dst := v.Args[0]
 32398			p1 := v.Args[1]
 32399			mem := v.Args[2]
 32400			if mem.Op != OpStore {
 32401				break
 32402			}
 32403			t2 := mem.Aux
 32404			_ = mem.Args[2]
 32405			op2 := mem.Args[0]
 32406			if op2.Op != OpOffPtr {
 32407				break
 32408			}
 32409			tt2 := op2.Type
 32410			o2 := op2.AuxInt
 32411			p2 := op2.Args[0]
 32412			d1 := mem.Args[1]
 32413			mem_2 := mem.Args[2]
 32414			if mem_2.Op != OpStore {
 32415				break
 32416			}
 32417			t3 := mem_2.Aux
 32418			_ = mem_2.Args[2]
 32419			op3 := mem_2.Args[0]
 32420			if op3.Op != OpOffPtr {
 32421				break
 32422			}
 32423			tt3 := op3.Type
 32424			o3 := op3.AuxInt
 32425			p3 := op3.Args[0]
 32426			d2 := mem_2.Args[1]
 32427			mem_2_2 := mem_2.Args[2]
 32428			if mem_2_2.Op != OpStore {
 32429				break
 32430			}
 32431			t4 := mem_2_2.Aux
 32432			_ = mem_2_2.Args[2]
 32433			op4 := mem_2_2.Args[0]
 32434			if op4.Op != OpOffPtr {
 32435				break
 32436			}
 32437			tt4 := op4.Type
 32438			o4 := op4.AuxInt
 32439			p4 := op4.Args[0]
 32440			d3 := mem_2_2.Args[1]
 32441			mem_2_2_2 := mem_2_2.Args[2]
 32442			if mem_2_2_2.Op != OpStore {
 32443				break
 32444			}
 32445			t5 := mem_2_2_2.Aux
 32446			_ = mem_2_2_2.Args[2]
 32447			op5 := mem_2_2_2.Args[0]
 32448			if op5.Op != OpOffPtr {
 32449				break
 32450			}
 32451			tt5 := op5.Type
 32452			if op5.AuxInt != 0 {
 32453				break
 32454			}
 32455			p5 := op5.Args[0]
 32456			d4 := mem_2_2_2.Args[1]
 32457			if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && o4 == sizeof(t5) && o3-o4 == sizeof(t4) && o2-o3 == sizeof(t3) && n == sizeof(t2)+sizeof(t3)+sizeof(t4)+sizeof(t5)) {
 32458				break
 32459			}
 32460			v.reset(OpStore)
 32461			v.Aux = t2
 32462			v0 := b.NewValue0(v.Pos, OpOffPtr, tt2)
 32463			v0.AuxInt = o2
 32464			v0.AddArg(dst)
 32465			v.AddArg(v0)
 32466			v.AddArg(d1)
 32467			v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 32468			v1.Aux = t3
 32469			v2 := b.NewValue0(v.Pos, OpOffPtr, tt3)
 32470			v2.AuxInt = o3
 32471			v2.AddArg(dst)
 32472			v1.AddArg(v2)
 32473			v1.AddArg(d2)
 32474			v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 32475			v3.Aux = t4
 32476			v4 := b.NewValue0(v.Pos, OpOffPtr, tt4)
 32477			v4.AuxInt = o4
 32478			v4.AddArg(dst)
 32479			v3.AddArg(v4)
 32480			v3.AddArg(d3)
 32481			v5 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 32482			v5.Aux = t5
 32483			v6 := b.NewValue0(v.Pos, OpOffPtr, tt5)
 32484			v6.AuxInt = 0
 32485			v6.AddArg(dst)
 32486			v5.AddArg(v6)
 32487			v5.AddArg(d4)
 32488			v5.AddArg(mem)
 32489			v3.AddArg(v5)
 32490			v1.AddArg(v3)
 32491			v.AddArg(v1)
 32492			return true
 32493		}
 32494		return false
 32495	}
 32496	func rewriteValuegeneric_OpMove_10(v *Value) bool {
 32497		b := v.Block
 32498		// match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Store {t3} op3:(OffPtr <tt3> [0] p3) d2 _))))
 32499		// cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && o2 == sizeof(t3) && n == sizeof(t2) + sizeof(t3)
 32500		// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [0] dst) d2 mem))
 32501		for {
 32502			n := v.AuxInt
 32503			t1 := v.Aux
 32504			_ = v.Args[2]
 32505			dst := v.Args[0]
 32506			p1 := v.Args[1]
 32507			mem := v.Args[2]
 32508			if mem.Op != OpVarDef {
 32509				break
 32510			}
 32511			mem_0 := mem.Args[0]
 32512			if mem_0.Op != OpStore {
 32513				break
 32514			}
 32515			t2 := mem_0.Aux
 32516			_ = mem_0.Args[2]
 32517			op2 := mem_0.Args[0]
 32518			if op2.Op != OpOffPtr {
 32519				break
 32520			}
 32521			tt2 := op2.Type
 32522			o2 := op2.AuxInt
 32523			p2 := op2.Args[0]
 32524			d1 := mem_0.Args[1]
 32525			mem_0_2 := mem_0.Args[2]
 32526			if mem_0_2.Op != OpStore {
 32527				break
 32528			}
 32529			t3 := mem_0_2.Aux
 32530			_ = mem_0_2.Args[2]
 32531			op3 := mem_0_2.Args[0]
 32532			if op3.Op != OpOffPtr {
 32533				break
 32534			}
 32535			tt3 := op3.Type
 32536			if op3.AuxInt != 0 {
 32537				break
 32538			}
 32539			p3 := op3.Args[0]
 32540			d2 := mem_0_2.Args[1]
 32541			if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && o2 == sizeof(t3) && n == sizeof(t2)+sizeof(t3)) {
 32542				break
 32543			}
 32544			v.reset(OpStore)
 32545			v.Aux = t2
 32546			v0 := b.NewValue0(v.Pos, OpOffPtr, tt2)
 32547			v0.AuxInt = o2
 32548			v0.AddArg(dst)
 32549			v.AddArg(v0)
 32550			v.AddArg(d1)
 32551			v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 32552			v1.Aux = t3
 32553			v2 := b.NewValue0(v.Pos, OpOffPtr, tt3)
 32554			v2.AuxInt = 0
 32555			v2.AddArg(dst)
 32556			v1.AddArg(v2)
 32557			v1.AddArg(d2)
 32558			v1.AddArg(mem)
 32559			v.AddArg(v1)
 32560			return true
 32561		}
 32562		// match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Store {t3} op3:(OffPtr <tt3> [o3] p3) d2 (Store {t4} op4:(OffPtr <tt4> [0] p4) d3 _)))))
 32563		// cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && o3 == sizeof(t4) && o2-o3 == sizeof(t3) && n == sizeof(t2) + sizeof(t3) + sizeof(t4)
 32564		// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [0] dst) d3 mem)))
 32565		for {
 32566			n := v.AuxInt
 32567			t1 := v.Aux
 32568			_ = v.Args[2]
 32569			dst := v.Args[0]
 32570			p1 := v.Args[1]
 32571			mem := v.Args[2]
 32572			if mem.Op != OpVarDef {
 32573				break
 32574			}
 32575			mem_0 := mem.Args[0]
 32576			if mem_0.Op != OpStore {
 32577				break
 32578			}
 32579			t2 := mem_0.Aux
 32580			_ = mem_0.Args[2]
 32581			op2 := mem_0.Args[0]
 32582			if op2.Op != OpOffPtr {
 32583				break
 32584			}
 32585			tt2 := op2.Type
 32586			o2 := op2.AuxInt
 32587			p2 := op2.Args[0]
 32588			d1 := mem_0.Args[1]
 32589			mem_0_2 := mem_0.Args[2]
 32590			if mem_0_2.Op != OpStore {
 32591				break
 32592			}
 32593			t3 := mem_0_2.Aux
 32594			_ = mem_0_2.Args[2]
 32595			op3 := mem_0_2.Args[0]
 32596			if op3.Op != OpOffPtr {
 32597				break
 32598			}
 32599			tt3 := op3.Type
 32600			o3 := op3.AuxInt
 32601			p3 := op3.Args[0]
 32602			d2 := mem_0_2.Args[1]
 32603			mem_0_2_2 := mem_0_2.Args[2]
 32604			if mem_0_2_2.Op != OpStore {
 32605				break
 32606			}
 32607			t4 := mem_0_2_2.Aux
 32608			_ = mem_0_2_2.Args[2]
 32609			op4 := mem_0_2_2.Args[0]
 32610			if op4.Op != OpOffPtr {
 32611				break
 32612			}
 32613			tt4 := op4.Type
 32614			if op4.AuxInt != 0 {
 32615				break
 32616			}
 32617			p4 := op4.Args[0]
 32618			d3 := mem_0_2_2.Args[1]
 32619			if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && o3 == sizeof(t4) && o2-o3 == sizeof(t3) && n == sizeof(t2)+sizeof(t3)+sizeof(t4)) {
 32620				break
 32621			}
 32622			v.reset(OpStore)
 32623			v.Aux = t2
 32624			v0 := b.NewValue0(v.Pos, OpOffPtr, tt2)
 32625			v0.AuxInt = o2
 32626			v0.AddArg(dst)
 32627			v.AddArg(v0)
 32628			v.AddArg(d1)
 32629			v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 32630			v1.Aux = t3
 32631			v2 := b.NewValue0(v.Pos, OpOffPtr, tt3)
 32632			v2.AuxInt = o3
 32633			v2.AddArg(dst)
 32634			v1.AddArg(v2)
 32635			v1.AddArg(d2)
 32636			v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 32637			v3.Aux = t4
 32638			v4 := b.NewValue0(v.Pos, OpOffPtr, tt4)
 32639			v4.AuxInt = 0
 32640			v4.AddArg(dst)
 32641			v3.AddArg(v4)
 32642			v3.AddArg(d3)
 32643			v3.AddArg(mem)
 32644			v1.AddArg(v3)
 32645			v.AddArg(v1)
 32646			return true
 32647		}
 32648		// match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Store {t3} op3:(OffPtr <tt3> [o3] p3) d2 (Store {t4} op4:(OffPtr <tt4> [o4] p4) d3 (Store {t5} op5:(OffPtr <tt5> [0] p5) d4 _))))))
 32649		// cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && o4 == sizeof(t5) && o3-o4 == sizeof(t4) && o2-o3 == sizeof(t3) && n == sizeof(t2) + sizeof(t3) + sizeof(t4) + sizeof(t5)
 32650		// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [o4] dst) d3 (Store {t5} (OffPtr <tt5> [0] dst) d4 mem))))
 32651		for {
 32652			n := v.AuxInt
 32653			t1 := v.Aux
 32654			_ = v.Args[2]
 32655			dst := v.Args[0]
 32656			p1 := v.Args[1]
 32657			mem := v.Args[2]
 32658			if mem.Op != OpVarDef {
 32659				break
 32660			}
 32661			mem_0 := mem.Args[0]
 32662			if mem_0.Op != OpStore {
 32663				break
 32664			}
 32665			t2 := mem_0.Aux
 32666			_ = mem_0.Args[2]
 32667			op2 := mem_0.Args[0]
 32668			if op2.Op != OpOffPtr {
 32669				break
 32670			}
 32671			tt2 := op2.Type
 32672			o2 := op2.AuxInt
 32673			p2 := op2.Args[0]
 32674			d1 := mem_0.Args[1]
 32675			mem_0_2 := mem_0.Args[2]
 32676			if mem_0_2.Op != OpStore {
 32677				break
 32678			}
 32679			t3 := mem_0_2.Aux
 32680			_ = mem_0_2.Args[2]
 32681			op3 := mem_0_2.Args[0]
 32682			if op3.Op != OpOffPtr {
 32683				break
 32684			}
 32685			tt3 := op3.Type
 32686			o3 := op3.AuxInt
 32687			p3 := op3.Args[0]
 32688			d2 := mem_0_2.Args[1]
 32689			mem_0_2_2 := mem_0_2.Args[2]
 32690			if mem_0_2_2.Op != OpStore {
 32691				break
 32692			}
 32693			t4 := mem_0_2_2.Aux
 32694			_ = mem_0_2_2.Args[2]
 32695			op4 := mem_0_2_2.Args[0]
 32696			if op4.Op != OpOffPtr {
 32697				break
 32698			}
 32699			tt4 := op4.Type
 32700			o4 := op4.AuxInt
 32701			p4 := op4.Args[0]
 32702			d3 := mem_0_2_2.Args[1]
 32703			mem_0_2_2_2 := mem_0_2_2.Args[2]
 32704			if mem_0_2_2_2.Op != OpStore {
 32705				break
 32706			}
 32707			t5 := mem_0_2_2_2.Aux
 32708			_ = mem_0_2_2_2.Args[2]
 32709			op5 := mem_0_2_2_2.Args[0]
 32710			if op5.Op != OpOffPtr {
 32711				break
 32712			}
 32713			tt5 := op5.Type
 32714			if op5.AuxInt != 0 {
 32715				break
 32716			}
 32717			p5 := op5.Args[0]
 32718			d4 := mem_0_2_2_2.Args[1]
 32719			if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && o4 == sizeof(t5) && o3-o4 == sizeof(t4) && o2-o3 == sizeof(t3) && n == sizeof(t2)+sizeof(t3)+sizeof(t4)+sizeof(t5)) {
 32720				break
 32721			}
 32722			v.reset(OpStore)
 32723			v.Aux = t2
 32724			v0 := b.NewValue0(v.Pos, OpOffPtr, tt2)
 32725			v0.AuxInt = o2
 32726			v0.AddArg(dst)
 32727			v.AddArg(v0)
 32728			v.AddArg(d1)
 32729			v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 32730			v1.Aux = t3
 32731			v2 := b.NewValue0(v.Pos, OpOffPtr, tt3)
 32732			v2.AuxInt = o3
 32733			v2.AddArg(dst)
 32734			v1.AddArg(v2)
 32735			v1.AddArg(d2)
 32736			v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 32737			v3.Aux = t4
 32738			v4 := b.NewValue0(v.Pos, OpOffPtr, tt4)
 32739			v4.AuxInt = o4
 32740			v4.AddArg(dst)
 32741			v3.AddArg(v4)
 32742			v3.AddArg(d3)
 32743			v5 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 32744			v5.Aux = t5
 32745			v6 := b.NewValue0(v.Pos, OpOffPtr, tt5)
 32746			v6.AuxInt = 0
 32747			v6.AddArg(dst)
 32748			v5.AddArg(v6)
 32749			v5.AddArg(d4)
 32750			v5.AddArg(mem)
 32751			v3.AddArg(v5)
 32752			v1.AddArg(v3)
 32753			v.AddArg(v1)
 32754			return true
 32755		}
 32756		// match: (Move {t1} [n] dst p1 mem:(Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Zero {t3} [n] p3 _)))
 32757		// cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && registerizable(b, t2) && n >= o2 + sizeof(t2)
 32758		// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Zero {t1} [n] dst mem))
 32759		for {
 32760			n := v.AuxInt
 32761			t1 := v.Aux
 32762			_ = v.Args[2]
 32763			dst := v.Args[0]
 32764			p1 := v.Args[1]
 32765			mem := v.Args[2]
 32766			if mem.Op != OpStore {
 32767				break
 32768			}
 32769			t2 := mem.Aux
 32770			_ = mem.Args[2]
 32771			op2 := mem.Args[0]
 32772			if op2.Op != OpOffPtr {
 32773				break
 32774			}
 32775			tt2 := op2.Type
 32776			o2 := op2.AuxInt
 32777			p2 := op2.Args[0]
 32778			d1 := mem.Args[1]
 32779			mem_2 := mem.Args[2]
 32780			if mem_2.Op != OpZero {
 32781				break
 32782			}
 32783			if mem_2.AuxInt != n {
 32784				break
 32785			}
 32786			t3 := mem_2.Aux
 32787			_ = mem_2.Args[1]
 32788			p3 := mem_2.Args[0]
 32789			if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && registerizable(b, t2) && n >= o2+sizeof(t2)) {
 32790				break
 32791			}
 32792			v.reset(OpStore)
 32793			v.Aux = t2
 32794			v0 := b.NewValue0(v.Pos, OpOffPtr, tt2)
 32795			v0.AuxInt = o2
 32796			v0.AddArg(dst)
 32797			v.AddArg(v0)
 32798			v.AddArg(d1)
 32799			v1 := b.NewValue0(v.Pos, OpZero, types.TypeMem)
 32800			v1.AuxInt = n
 32801			v1.Aux = t1
 32802			v1.AddArg(dst)
 32803			v1.AddArg(mem)
 32804			v.AddArg(v1)
 32805			return true
 32806		}
 32807		// match: (Move {t1} [n] dst p1 mem:(Store {t2} (OffPtr <tt2> [o2] p2) d1 (Store {t3} (OffPtr <tt3> [o3] p3) d2 (Zero {t4} [n] p4 _))))
 32808		// cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && n >= o2 + sizeof(t2) && n >= o3 + sizeof(t3)
 32809		// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Zero {t1} [n] dst mem)))
 32810		for {
 32811			n := v.AuxInt
 32812			t1 := v.Aux
 32813			_ = v.Args[2]
 32814			dst := v.Args[0]
 32815			p1 := v.Args[1]
 32816			mem := v.Args[2]
 32817			if mem.Op != OpStore {
 32818				break
 32819			}
 32820			t2 := mem.Aux
 32821			_ = mem.Args[2]
 32822			mem_0 := mem.Args[0]
 32823			if mem_0.Op != OpOffPtr {
 32824				break
 32825			}
 32826			tt2 := mem_0.Type
 32827			o2 := mem_0.AuxInt
 32828			p2 := mem_0.Args[0]
 32829			d1 := mem.Args[1]
 32830			mem_2 := mem.Args[2]
 32831			if mem_2.Op != OpStore {
 32832				break
 32833			}
 32834			t3 := mem_2.Aux
 32835			_ = mem_2.Args[2]
 32836			mem_2_0 := mem_2.Args[0]
 32837			if mem_2_0.Op != OpOffPtr {
 32838				break
 32839			}
 32840			tt3 := mem_2_0.Type
 32841			o3 := mem_2_0.AuxInt
 32842			p3 := mem_2_0.Args[0]
 32843			d2 := mem_2.Args[1]
 32844			mem_2_2 := mem_2.Args[2]
 32845			if mem_2_2.Op != OpZero {
 32846				break
 32847			}
 32848			if mem_2_2.AuxInt != n {
 32849				break
 32850			}
 32851			t4 := mem_2_2.Aux
 32852			_ = mem_2_2.Args[1]
 32853			p4 := mem_2_2.Args[0]
 32854			if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && n >= o2+sizeof(t2) && n >= o3+sizeof(t3)) {
 32855				break
 32856			}
 32857			v.reset(OpStore)
 32858			v.Aux = t2
 32859			v0 := b.NewValue0(v.Pos, OpOffPtr, tt2)
 32860			v0.AuxInt = o2
 32861			v0.AddArg(dst)
 32862			v.AddArg(v0)
 32863			v.AddArg(d1)
 32864			v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 32865			v1.Aux = t3
 32866			v2 := b.NewValue0(v.Pos, OpOffPtr, tt3)
 32867			v2.AuxInt = o3
 32868			v2.AddArg(dst)
 32869			v1.AddArg(v2)
 32870			v1.AddArg(d2)
 32871			v3 := b.NewValue0(v.Pos, OpZero, types.TypeMem)
 32872			v3.AuxInt = n
 32873			v3.Aux = t1
 32874			v3.AddArg(dst)
 32875			v3.AddArg(mem)
 32876			v1.AddArg(v3)
 32877			v.AddArg(v1)
 32878			return true
 32879		}
 32880		// match: (Move {t1} [n] dst p1 mem:(Store {t2} (OffPtr <tt2> [o2] p2) d1 (Store {t3} (OffPtr <tt3> [o3] p3) d2 (Store {t4} (OffPtr <tt4> [o4] p4) d3 (Zero {t5} [n] p5 _)))))
 32881		// cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && n >= o2 + sizeof(t2) && n >= o3 + sizeof(t3) && n >= o4 + sizeof(t4)
 32882		// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [o4] dst) d3 (Zero {t1} [n] dst mem))))
 32883		for {
 32884			n := v.AuxInt
 32885			t1 := v.Aux
 32886			_ = v.Args[2]
 32887			dst := v.Args[0]
 32888			p1 := v.Args[1]
 32889			mem := v.Args[2]
 32890			if mem.Op != OpStore {
 32891				break
 32892			}
 32893			t2 := mem.Aux
 32894			_ = mem.Args[2]
 32895			mem_0 := mem.Args[0]
 32896			if mem_0.Op != OpOffPtr {
 32897				break
 32898			}
 32899			tt2 := mem_0.Type
 32900			o2 := mem_0.AuxInt
 32901			p2 := mem_0.Args[0]
 32902			d1 := mem.Args[1]
 32903			mem_2 := mem.Args[2]
 32904			if mem_2.Op != OpStore {
 32905				break
 32906			}
 32907			t3 := mem_2.Aux
 32908			_ = mem_2.Args[2]
 32909			mem_2_0 := mem_2.Args[0]
 32910			if mem_2_0.Op != OpOffPtr {
 32911				break
 32912			}
 32913			tt3 := mem_2_0.Type
 32914			o3 := mem_2_0.AuxInt
 32915			p3 := mem_2_0.Args[0]
 32916			d2 := mem_2.Args[1]
 32917			mem_2_2 := mem_2.Args[2]
 32918			if mem_2_2.Op != OpStore {
 32919				break
 32920			}
 32921			t4 := mem_2_2.Aux
 32922			_ = mem_2_2.Args[2]
 32923			mem_2_2_0 := mem_2_2.Args[0]
 32924			if mem_2_2_0.Op != OpOffPtr {
 32925				break
 32926			}
 32927			tt4 := mem_2_2_0.Type
 32928			o4 := mem_2_2_0.AuxInt
 32929			p4 := mem_2_2_0.Args[0]
 32930			d3 := mem_2_2.Args[1]
 32931			mem_2_2_2 := mem_2_2.Args[2]
 32932			if mem_2_2_2.Op != OpZero {
 32933				break
 32934			}
 32935			if mem_2_2_2.AuxInt != n {
 32936				break
 32937			}
 32938			t5 := mem_2_2_2.Aux
 32939			_ = mem_2_2_2.Args[1]
 32940			p5 := mem_2_2_2.Args[0]
 32941			if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && n >= o2+sizeof(t2) && n >= o3+sizeof(t3) && n >= o4+sizeof(t4)) {
 32942				break
 32943			}
 32944			v.reset(OpStore)
 32945			v.Aux = t2
 32946			v0 := b.NewValue0(v.Pos, OpOffPtr, tt2)
 32947			v0.AuxInt = o2
 32948			v0.AddArg(dst)
 32949			v.AddArg(v0)
 32950			v.AddArg(d1)
 32951			v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 32952			v1.Aux = t3
 32953			v2 := b.NewValue0(v.Pos, OpOffPtr, tt3)
 32954			v2.AuxInt = o3
 32955			v2.AddArg(dst)
 32956			v1.AddArg(v2)
 32957			v1.AddArg(d2)
 32958			v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 32959			v3.Aux = t4
 32960			v4 := b.NewValue0(v.Pos, OpOffPtr, tt4)
 32961			v4.AuxInt = o4
 32962			v4.AddArg(dst)
 32963			v3.AddArg(v4)
 32964			v3.AddArg(d3)
 32965			v5 := b.NewValue0(v.Pos, OpZero, types.TypeMem)
 32966			v5.AuxInt = n
 32967			v5.Aux = t1
 32968			v5.AddArg(dst)
 32969			v5.AddArg(mem)
 32970			v3.AddArg(v5)
 32971			v1.AddArg(v3)
 32972			v.AddArg(v1)
 32973			return true
 32974		}
 32975		// match: (Move {t1} [n] dst p1 mem:(Store {t2} (OffPtr <tt2> [o2] p2) d1 (Store {t3} (OffPtr <tt3> [o3] p3) d2 (Store {t4} (OffPtr <tt4> [o4] p4) d3 (Store {t5} (OffPtr <tt5> [o5] p5) d4 (Zero {t6} [n] p6 _))))))
 32976		// cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && isSamePtr(p5, p6) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && alignof(t6) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && n >= o2 + sizeof(t2) && n >= o3 + sizeof(t3) && n >= o4 + sizeof(t4) && n >= o5 + sizeof(t5)
 32977		// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [o4] dst) d3 (Store {t5} (OffPtr <tt5> [o5] dst) d4 (Zero {t1} [n] dst mem)))))
 32978		for {
 32979			n := v.AuxInt
 32980			t1 := v.Aux
 32981			_ = v.Args[2]
 32982			dst := v.Args[0]
 32983			p1 := v.Args[1]
 32984			mem := v.Args[2]
 32985			if mem.Op != OpStore {
 32986				break
 32987			}
 32988			t2 := mem.Aux
 32989			_ = mem.Args[2]
 32990			mem_0 := mem.Args[0]
 32991			if mem_0.Op != OpOffPtr {
 32992				break
 32993			}
 32994			tt2 := mem_0.Type
 32995			o2 := mem_0.AuxInt
 32996			p2 := mem_0.Args[0]
 32997			d1 := mem.Args[1]
 32998			mem_2 := mem.Args[2]
 32999			if mem_2.Op != OpStore {
 33000				break
 33001			}
 33002			t3 := mem_2.Aux
 33003			_ = mem_2.Args[2]
 33004			mem_2_0 := mem_2.Args[0]
 33005			if mem_2_0.Op != OpOffPtr {
 33006				break
 33007			}
 33008			tt3 := mem_2_0.Type
 33009			o3 := mem_2_0.AuxInt
 33010			p3 := mem_2_0.Args[0]
 33011			d2 := mem_2.Args[1]
 33012			mem_2_2 := mem_2.Args[2]
 33013			if mem_2_2.Op != OpStore {
 33014				break
 33015			}
 33016			t4 := mem_2_2.Aux
 33017			_ = mem_2_2.Args[2]
 33018			mem_2_2_0 := mem_2_2.Args[0]
 33019			if mem_2_2_0.Op != OpOffPtr {
 33020				break
 33021			}
 33022			tt4 := mem_2_2_0.Type
 33023			o4 := mem_2_2_0.AuxInt
 33024			p4 := mem_2_2_0.Args[0]
 33025			d3 := mem_2_2.Args[1]
 33026			mem_2_2_2 := mem_2_2.Args[2]
 33027			if mem_2_2_2.Op != OpStore {
 33028				break
 33029			}
 33030			t5 := mem_2_2_2.Aux
 33031			_ = mem_2_2_2.Args[2]
 33032			mem_2_2_2_0 := mem_2_2_2.Args[0]
 33033			if mem_2_2_2_0.Op != OpOffPtr {
 33034				break
 33035			}
 33036			tt5 := mem_2_2_2_0.Type
 33037			o5 := mem_2_2_2_0.AuxInt
 33038			p5 := mem_2_2_2_0.Args[0]
 33039			d4 := mem_2_2_2.Args[1]
 33040			mem_2_2_2_2 := mem_2_2_2.Args[2]
 33041			if mem_2_2_2_2.Op != OpZero {
 33042				break
 33043			}
 33044			if mem_2_2_2_2.AuxInt != n {
 33045				break
 33046			}
 33047			t6 := mem_2_2_2_2.Aux
 33048			_ = mem_2_2_2_2.Args[1]
 33049			p6 := mem_2_2_2_2.Args[0]
 33050			if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && isSamePtr(p5, p6) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && alignof(t6) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && n >= o2+sizeof(t2) && n >= o3+sizeof(t3) && n >= o4+sizeof(t4) && n >= o5+sizeof(t5)) {
 33051				break
 33052			}
 33053			v.reset(OpStore)
 33054			v.Aux = t2
 33055			v0 := b.NewValue0(v.Pos, OpOffPtr, tt2)
 33056			v0.AuxInt = o2
 33057			v0.AddArg(dst)
 33058			v.AddArg(v0)
 33059			v.AddArg(d1)
 33060			v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 33061			v1.Aux = t3
 33062			v2 := b.NewValue0(v.Pos, OpOffPtr, tt3)
 33063			v2.AuxInt = o3
 33064			v2.AddArg(dst)
 33065			v1.AddArg(v2)
 33066			v1.AddArg(d2)
 33067			v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 33068			v3.Aux = t4
 33069			v4 := b.NewValue0(v.Pos, OpOffPtr, tt4)
 33070			v4.AuxInt = o4
 33071			v4.AddArg(dst)
 33072			v3.AddArg(v4)
 33073			v3.AddArg(d3)
 33074			v5 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 33075			v5.Aux = t5
 33076			v6 := b.NewValue0(v.Pos, OpOffPtr, tt5)
 33077			v6.AuxInt = o5
 33078			v6.AddArg(dst)
 33079			v5.AddArg(v6)
 33080			v5.AddArg(d4)
 33081			v7 := b.NewValue0(v.Pos, OpZero, types.TypeMem)
 33082			v7.AuxInt = n
 33083			v7.Aux = t1
 33084			v7.AddArg(dst)
 33085			v7.AddArg(mem)
 33086			v5.AddArg(v7)
 33087			v3.AddArg(v5)
 33088			v1.AddArg(v3)
 33089			v.AddArg(v1)
 33090			return true
 33091		}
 33092		// match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Zero {t3} [n] p3 _))))
 33093		// cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && registerizable(b, t2) && n >= o2 + sizeof(t2)
 33094		// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Zero {t1} [n] dst mem))
 33095		for {
 33096			n := v.AuxInt
 33097			t1 := v.Aux
 33098			_ = v.Args[2]
 33099			dst := v.Args[0]
 33100			p1 := v.Args[1]
 33101			mem := v.Args[2]
 33102			if mem.Op != OpVarDef {
 33103				break
 33104			}
 33105			mem_0 := mem.Args[0]
 33106			if mem_0.Op != OpStore {
 33107				break
 33108			}
 33109			t2 := mem_0.Aux
 33110			_ = mem_0.Args[2]
 33111			op2 := mem_0.Args[0]
 33112			if op2.Op != OpOffPtr {
 33113				break
 33114			}
 33115			tt2 := op2.Type
 33116			o2 := op2.AuxInt
 33117			p2 := op2.Args[0]
 33118			d1 := mem_0.Args[1]
 33119			mem_0_2 := mem_0.Args[2]
 33120			if mem_0_2.Op != OpZero {
 33121				break
 33122			}
 33123			if mem_0_2.AuxInt != n {
 33124				break
 33125			}
 33126			t3 := mem_0_2.Aux
 33127			_ = mem_0_2.Args[1]
 33128			p3 := mem_0_2.Args[0]
 33129			if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && registerizable(b, t2) && n >= o2+sizeof(t2)) {
 33130				break
 33131			}
 33132			v.reset(OpStore)
 33133			v.Aux = t2
 33134			v0 := b.NewValue0(v.Pos, OpOffPtr, tt2)
 33135			v0.AuxInt = o2
 33136			v0.AddArg(dst)
 33137			v.AddArg(v0)
 33138			v.AddArg(d1)
 33139			v1 := b.NewValue0(v.Pos, OpZero, types.TypeMem)
 33140			v1.AuxInt = n
 33141			v1.Aux = t1
 33142			v1.AddArg(dst)
 33143			v1.AddArg(mem)
 33144			v.AddArg(v1)
 33145			return true
 33146		}
 33147		// match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} (OffPtr <tt2> [o2] p2) d1 (Store {t3} (OffPtr <tt3> [o3] p3) d2 (Zero {t4} [n] p4 _)))))
 33148		// cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && n >= o2 + sizeof(t2) && n >= o3 + sizeof(t3)
 33149		// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Zero {t1} [n] dst mem)))
 33150		for {
 33151			n := v.AuxInt
 33152			t1 := v.Aux
 33153			_ = v.Args[2]
 33154			dst := v.Args[0]
 33155			p1 := v.Args[1]
 33156			mem := v.Args[2]
 33157			if mem.Op != OpVarDef {
 33158				break
 33159			}
 33160			mem_0 := mem.Args[0]
 33161			if mem_0.Op != OpStore {
 33162				break
 33163			}
 33164			t2 := mem_0.Aux
 33165			_ = mem_0.Args[2]
 33166			mem_0_0 := mem_0.Args[0]
 33167			if mem_0_0.Op != OpOffPtr {
 33168				break
 33169			}
 33170			tt2 := mem_0_0.Type
 33171			o2 := mem_0_0.AuxInt
 33172			p2 := mem_0_0.Args[0]
 33173			d1 := mem_0.Args[1]
 33174			mem_0_2 := mem_0.Args[2]
 33175			if mem_0_2.Op != OpStore {
 33176				break
 33177			}
 33178			t3 := mem_0_2.Aux
 33179			_ = mem_0_2.Args[2]
 33180			mem_0_2_0 := mem_0_2.Args[0]
 33181			if mem_0_2_0.Op != OpOffPtr {
 33182				break
 33183			}
 33184			tt3 := mem_0_2_0.Type
 33185			o3 := mem_0_2_0.AuxInt
 33186			p3 := mem_0_2_0.Args[0]
 33187			d2 := mem_0_2.Args[1]
 33188			mem_0_2_2 := mem_0_2.Args[2]
 33189			if mem_0_2_2.Op != OpZero {
 33190				break
 33191			}
 33192			if mem_0_2_2.AuxInt != n {
 33193				break
 33194			}
 33195			t4 := mem_0_2_2.Aux
 33196			_ = mem_0_2_2.Args[1]
 33197			p4 := mem_0_2_2.Args[0]
 33198			if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && n >= o2+sizeof(t2) && n >= o3+sizeof(t3)) {
 33199				break
 33200			}
 33201			v.reset(OpStore)
 33202			v.Aux = t2
 33203			v0 := b.NewValue0(v.Pos, OpOffPtr, tt2)
 33204			v0.AuxInt = o2
 33205			v0.AddArg(dst)
 33206			v.AddArg(v0)
 33207			v.AddArg(d1)
 33208			v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 33209			v1.Aux = t3
 33210			v2 := b.NewValue0(v.Pos, OpOffPtr, tt3)
 33211			v2.AuxInt = o3
 33212			v2.AddArg(dst)
 33213			v1.AddArg(v2)
 33214			v1.AddArg(d2)
 33215			v3 := b.NewValue0(v.Pos, OpZero, types.TypeMem)
 33216			v3.AuxInt = n
 33217			v3.Aux = t1
 33218			v3.AddArg(dst)
 33219			v3.AddArg(mem)
 33220			v1.AddArg(v3)
 33221			v.AddArg(v1)
 33222			return true
 33223		}
 33224		// match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} (OffPtr <tt2> [o2] p2) d1 (Store {t3} (OffPtr <tt3> [o3] p3) d2 (Store {t4} (OffPtr <tt4> [o4] p4) d3 (Zero {t5} [n] p5 _))))))
 33225		// cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && n >= o2 + sizeof(t2) && n >= o3 + sizeof(t3) && n >= o4 + sizeof(t4)
 33226		// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [o4] dst) d3 (Zero {t1} [n] dst mem))))
 33227		for {
 33228			n := v.AuxInt
 33229			t1 := v.Aux
 33230			_ = v.Args[2]
 33231			dst := v.Args[0]
 33232			p1 := v.Args[1]
 33233			mem := v.Args[2]
 33234			if mem.Op != OpVarDef {
 33235				break
 33236			}
 33237			mem_0 := mem.Args[0]
 33238			if mem_0.Op != OpStore {
 33239				break
 33240			}
 33241			t2 := mem_0.Aux
 33242			_ = mem_0.Args[2]
 33243			mem_0_0 := mem_0.Args[0]
 33244			if mem_0_0.Op != OpOffPtr {
 33245				break
 33246			}
 33247			tt2 := mem_0_0.Type
 33248			o2 := mem_0_0.AuxInt
 33249			p2 := mem_0_0.Args[0]
 33250			d1 := mem_0.Args[1]
 33251			mem_0_2 := mem_0.Args[2]
 33252			if mem_0_2.Op != OpStore {
 33253				break
 33254			}
 33255			t3 := mem_0_2.Aux
 33256			_ = mem_0_2.Args[2]
 33257			mem_0_2_0 := mem_0_2.Args[0]
 33258			if mem_0_2_0.Op != OpOffPtr {
 33259				break
 33260			}
 33261			tt3 := mem_0_2_0.Type
 33262			o3 := mem_0_2_0.AuxInt
 33263			p3 := mem_0_2_0.Args[0]
 33264			d2 := mem_0_2.Args[1]
 33265			mem_0_2_2 := mem_0_2.Args[2]
 33266			if mem_0_2_2.Op != OpStore {
 33267				break
 33268			}
 33269			t4 := mem_0_2_2.Aux
 33270			_ = mem_0_2_2.Args[2]
 33271			mem_0_2_2_0 := mem_0_2_2.Args[0]
 33272			if mem_0_2_2_0.Op != OpOffPtr {
 33273				break
 33274			}
 33275			tt4 := mem_0_2_2_0.Type
 33276			o4 := mem_0_2_2_0.AuxInt
 33277			p4 := mem_0_2_2_0.Args[0]
 33278			d3 := mem_0_2_2.Args[1]
 33279			mem_0_2_2_2 := mem_0_2_2.Args[2]
 33280			if mem_0_2_2_2.Op != OpZero {
 33281				break
 33282			}
 33283			if mem_0_2_2_2.AuxInt != n {
 33284				break
 33285			}
 33286			t5 := mem_0_2_2_2.Aux
 33287			_ = mem_0_2_2_2.Args[1]
 33288			p5 := mem_0_2_2_2.Args[0]
 33289			if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && n >= o2+sizeof(t2) && n >= o3+sizeof(t3) && n >= o4+sizeof(t4)) {
 33290				break
 33291			}
 33292			v.reset(OpStore)
 33293			v.Aux = t2
 33294			v0 := b.NewValue0(v.Pos, OpOffPtr, tt2)
 33295			v0.AuxInt = o2
 33296			v0.AddArg(dst)
 33297			v.AddArg(v0)
 33298			v.AddArg(d1)
 33299			v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 33300			v1.Aux = t3
 33301			v2 := b.NewValue0(v.Pos, OpOffPtr, tt3)
 33302			v2.AuxInt = o3
 33303			v2.AddArg(dst)
 33304			v1.AddArg(v2)
 33305			v1.AddArg(d2)
 33306			v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 33307			v3.Aux = t4
 33308			v4 := b.NewValue0(v.Pos, OpOffPtr, tt4)
 33309			v4.AuxInt = o4
 33310			v4.AddArg(dst)
 33311			v3.AddArg(v4)
 33312			v3.AddArg(d3)
 33313			v5 := b.NewValue0(v.Pos, OpZero, types.TypeMem)
 33314			v5.AuxInt = n
 33315			v5.Aux = t1
 33316			v5.AddArg(dst)
 33317			v5.AddArg(mem)
 33318			v3.AddArg(v5)
 33319			v1.AddArg(v3)
 33320			v.AddArg(v1)
 33321			return true
 33322		}
 33323		return false
 33324	}
 33325	func rewriteValuegeneric_OpMove_20(v *Value) bool {
 33326		b := v.Block
 33327		config := b.Func.Config
 33328		// match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} (OffPtr <tt2> [o2] p2) d1 (Store {t3} (OffPtr <tt3> [o3] p3) d2 (Store {t4} (OffPtr <tt4> [o4] p4) d3 (Store {t5} (OffPtr <tt5> [o5] p5) d4 (Zero {t6} [n] p6 _)))))))
 33329		// cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && isSamePtr(p5, p6) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && alignof(t6) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && n >= o2 + sizeof(t2) && n >= o3 + sizeof(t3) && n >= o4 + sizeof(t4) && n >= o5 + sizeof(t5)
 33330		// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [o4] dst) d3 (Store {t5} (OffPtr <tt5> [o5] dst) d4 (Zero {t1} [n] dst mem)))))
 33331		for {
 33332			n := v.AuxInt
 33333			t1 := v.Aux
 33334			_ = v.Args[2]
 33335			dst := v.Args[0]
 33336			p1 := v.Args[1]
 33337			mem := v.Args[2]
 33338			if mem.Op != OpVarDef {
 33339				break
 33340			}
 33341			mem_0 := mem.Args[0]
 33342			if mem_0.Op != OpStore {
 33343				break
 33344			}
 33345			t2 := mem_0.Aux
 33346			_ = mem_0.Args[2]
 33347			mem_0_0 := mem_0.Args[0]
 33348			if mem_0_0.Op != OpOffPtr {
 33349				break
 33350			}
 33351			tt2 := mem_0_0.Type
 33352			o2 := mem_0_0.AuxInt
 33353			p2 := mem_0_0.Args[0]
 33354			d1 := mem_0.Args[1]
 33355			mem_0_2 := mem_0.Args[2]
 33356			if mem_0_2.Op != OpStore {
 33357				break
 33358			}
 33359			t3 := mem_0_2.Aux
 33360			_ = mem_0_2.Args[2]
 33361			mem_0_2_0 := mem_0_2.Args[0]
 33362			if mem_0_2_0.Op != OpOffPtr {
 33363				break
 33364			}
 33365			tt3 := mem_0_2_0.Type
 33366			o3 := mem_0_2_0.AuxInt
 33367			p3 := mem_0_2_0.Args[0]
 33368			d2 := mem_0_2.Args[1]
 33369			mem_0_2_2 := mem_0_2.Args[2]
 33370			if mem_0_2_2.Op != OpStore {
 33371				break
 33372			}
 33373			t4 := mem_0_2_2.Aux
 33374			_ = mem_0_2_2.Args[2]
 33375			mem_0_2_2_0 := mem_0_2_2.Args[0]
 33376			if mem_0_2_2_0.Op != OpOffPtr {
 33377				break
 33378			}
 33379			tt4 := mem_0_2_2_0.Type
 33380			o4 := mem_0_2_2_0.AuxInt
 33381			p4 := mem_0_2_2_0.Args[0]
 33382			d3 := mem_0_2_2.Args[1]
 33383			mem_0_2_2_2 := mem_0_2_2.Args[2]
 33384			if mem_0_2_2_2.Op != OpStore {
 33385				break
 33386			}
 33387			t5 := mem_0_2_2_2.Aux
 33388			_ = mem_0_2_2_2.Args[2]
 33389			mem_0_2_2_2_0 := mem_0_2_2_2.Args[0]
 33390			if mem_0_2_2_2_0.Op != OpOffPtr {
 33391				break
 33392			}
 33393			tt5 := mem_0_2_2_2_0.Type
 33394			o5 := mem_0_2_2_2_0.AuxInt
 33395			p5 := mem_0_2_2_2_0.Args[0]
 33396			d4 := mem_0_2_2_2.Args[1]
 33397			mem_0_2_2_2_2 := mem_0_2_2_2.Args[2]
 33398			if mem_0_2_2_2_2.Op != OpZero {
 33399				break
 33400			}
 33401			if mem_0_2_2_2_2.AuxInt != n {
 33402				break
 33403			}
 33404			t6 := mem_0_2_2_2_2.Aux
 33405			_ = mem_0_2_2_2_2.Args[1]
 33406			p6 := mem_0_2_2_2_2.Args[0]
 33407			if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && isSamePtr(p5, p6) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && alignof(t6) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && n >= o2+sizeof(t2) && n >= o3+sizeof(t3) && n >= o4+sizeof(t4) && n >= o5+sizeof(t5)) {
 33408				break
 33409			}
 33410			v.reset(OpStore)
 33411			v.Aux = t2
 33412			v0 := b.NewValue0(v.Pos, OpOffPtr, tt2)
 33413			v0.AuxInt = o2
 33414			v0.AddArg(dst)
 33415			v.AddArg(v0)
 33416			v.AddArg(d1)
 33417			v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 33418			v1.Aux = t3
 33419			v2 := b.NewValue0(v.Pos, OpOffPtr, tt3)
 33420			v2.AuxInt = o3
 33421			v2.AddArg(dst)
 33422			v1.AddArg(v2)
 33423			v1.AddArg(d2)
 33424			v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 33425			v3.Aux = t4
 33426			v4 := b.NewValue0(v.Pos, OpOffPtr, tt4)
 33427			v4.AuxInt = o4
 33428			v4.AddArg(dst)
 33429			v3.AddArg(v4)
 33430			v3.AddArg(d3)
 33431			v5 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 33432			v5.Aux = t5
 33433			v6 := b.NewValue0(v.Pos, OpOffPtr, tt5)
 33434			v6.AuxInt = o5
 33435			v6.AddArg(dst)
 33436			v5.AddArg(v6)
 33437			v5.AddArg(d4)
 33438			v7 := b.NewValue0(v.Pos, OpZero, types.TypeMem)
 33439			v7.AuxInt = n
 33440			v7.Aux = t1
 33441			v7.AddArg(dst)
 33442			v7.AddArg(mem)
 33443			v5.AddArg(v7)
 33444			v3.AddArg(v5)
 33445			v1.AddArg(v3)
 33446			v.AddArg(v1)
 33447			return true
 33448		}
 33449		// match: (Move {t1} [s] dst tmp1 midmem:(Move {t2} [s] tmp2 src _))
 33450		// cond: t1.(*types.Type).Compare(t2.(*types.Type)) == types.CMPeq && isSamePtr(tmp1, tmp2) && isStackPtr(src) && disjoint(src, s, tmp2, s) && (disjoint(src, s, dst, s) || isInlinableMemmove(dst, src, s, config))
 33451		// result: (Move {t1} [s] dst src midmem)
 33452		for {
 33453			s := v.AuxInt
 33454			t1 := v.Aux
 33455			_ = v.Args[2]
 33456			dst := v.Args[0]
 33457			tmp1 := v.Args[1]
 33458			midmem := v.Args[2]
 33459			if midmem.Op != OpMove {
 33460				break
 33461			}
 33462			if midmem.AuxInt != s {
 33463				break
 33464			}
 33465			t2 := midmem.Aux
 33466			_ = midmem.Args[2]
 33467			tmp2 := midmem.Args[0]
 33468			src := midmem.Args[1]
 33469			if !(t1.(*types.Type).Compare(t2.(*types.Type)) == types.CMPeq && isSamePtr(tmp1, tmp2) && isStackPtr(src) && disjoint(src, s, tmp2, s) && (disjoint(src, s, dst, s) || isInlinableMemmove(dst, src, s, config))) {
 33470				break
 33471			}
 33472			v.reset(OpMove)
 33473			v.AuxInt = s
 33474			v.Aux = t1
 33475			v.AddArg(dst)
 33476			v.AddArg(src)
 33477			v.AddArg(midmem)
 33478			return true
 33479		}
 33480		// match: (Move {t1} [s] dst tmp1 midmem:(VarDef (Move {t2} [s] tmp2 src _)))
 33481		// cond: t1.(*types.Type).Compare(t2.(*types.Type)) == types.CMPeq && isSamePtr(tmp1, tmp2) && isStackPtr(src) && disjoint(src, s, tmp2, s) && (disjoint(src, s, dst, s) || isInlinableMemmove(dst, src, s, config))
 33482		// result: (Move {t1} [s] dst src midmem)
 33483		for {
 33484			s := v.AuxInt
 33485			t1 := v.Aux
 33486			_ = v.Args[2]
 33487			dst := v.Args[0]
 33488			tmp1 := v.Args[1]
 33489			midmem := v.Args[2]
 33490			if midmem.Op != OpVarDef {
 33491				break
 33492			}
 33493			midmem_0 := midmem.Args[0]
 33494			if midmem_0.Op != OpMove {
 33495				break
 33496			}
 33497			if midmem_0.AuxInt != s {
 33498				break
 33499			}
 33500			t2 := midmem_0.Aux
 33501			_ = midmem_0.Args[2]
 33502			tmp2 := midmem_0.Args[0]
 33503			src := midmem_0.Args[1]
 33504			if !(t1.(*types.Type).Compare(t2.(*types.Type)) == types.CMPeq && isSamePtr(tmp1, tmp2) && isStackPtr(src) && disjoint(src, s, tmp2, s) && (disjoint(src, s, dst, s) || isInlinableMemmove(dst, src, s, config))) {
 33505				break
 33506			}
 33507			v.reset(OpMove)
 33508			v.AuxInt = s
 33509			v.Aux = t1
 33510			v.AddArg(dst)
 33511			v.AddArg(src)
 33512			v.AddArg(midmem)
 33513			return true
 33514		}
 33515		// match: (Move dst src mem)
 33516		// cond: isSamePtr(dst, src)
 33517		// result: mem
 33518		for {
 33519			mem := v.Args[2]
 33520			dst := v.Args[0]
 33521			src := v.Args[1]
 33522			if !(isSamePtr(dst, src)) {
 33523				break
 33524			}
 33525			v.reset(OpCopy)
 33526			v.Type = mem.Type
 33527			v.AddArg(mem)
 33528			return true
 33529		}
 33530		return false
 33531	}
 33532	func rewriteValuegeneric_OpMul16_0(v *Value) bool {
 33533		b := v.Block
 33534		typ := &b.Func.Config.Types
 33535		// match: (Mul16 (Const16 [c]) (Const16 [d]))
 33536		// cond:
 33537		// result: (Const16 [int64(int16(c*d))])
 33538		for {
 33539			_ = v.Args[1]
 33540			v_0 := v.Args[0]
 33541			if v_0.Op != OpConst16 {
 33542				break
 33543			}
 33544			c := v_0.AuxInt
 33545			v_1 := v.Args[1]
 33546			if v_1.Op != OpConst16 {
 33547				break
 33548			}
 33549			d := v_1.AuxInt
 33550			v.reset(OpConst16)
 33551			v.AuxInt = int64(int16(c * d))
 33552			return true
 33553		}
 33554		// match: (Mul16 (Const16 [d]) (Const16 [c]))
 33555		// cond:
 33556		// result: (Const16 [int64(int16(c*d))])
 33557		for {
 33558			_ = v.Args[1]
 33559			v_0 := v.Args[0]
 33560			if v_0.Op != OpConst16 {
 33561				break
 33562			}
 33563			d := v_0.AuxInt
 33564			v_1 := v.Args[1]
 33565			if v_1.Op != OpConst16 {
 33566				break
 33567			}
 33568			c := v_1.AuxInt
 33569			v.reset(OpConst16)
 33570			v.AuxInt = int64(int16(c * d))
 33571			return true
 33572		}
 33573		// match: (Mul16 (Const16 [1]) x)
 33574		// cond:
 33575		// result: x
 33576		for {
 33577			x := v.Args[1]
 33578			v_0 := v.Args[0]
 33579			if v_0.Op != OpConst16 {
 33580				break
 33581			}
 33582			if v_0.AuxInt != 1 {
 33583				break
 33584			}
 33585			v.reset(OpCopy)
 33586			v.Type = x.Type
 33587			v.AddArg(x)
 33588			return true
 33589		}
 33590		// match: (Mul16 x (Const16 [1]))
 33591		// cond:
 33592		// result: x
 33593		for {
 33594			_ = v.Args[1]
 33595			x := v.Args[0]
 33596			v_1 := v.Args[1]
 33597			if v_1.Op != OpConst16 {
 33598				break
 33599			}
 33600			if v_1.AuxInt != 1 {
 33601				break
 33602			}
 33603			v.reset(OpCopy)
 33604			v.Type = x.Type
 33605			v.AddArg(x)
 33606			return true
 33607		}
 33608		// match: (Mul16 (Const16 [-1]) x)
 33609		// cond:
 33610		// result: (Neg16 x)
 33611		for {
 33612			x := v.Args[1]
 33613			v_0 := v.Args[0]
 33614			if v_0.Op != OpConst16 {
 33615				break
 33616			}
 33617			if v_0.AuxInt != -1 {
 33618				break
 33619			}
 33620			v.reset(OpNeg16)
 33621			v.AddArg(x)
 33622			return true
 33623		}
 33624		// match: (Mul16 x (Const16 [-1]))
 33625		// cond:
 33626		// result: (Neg16 x)
 33627		for {
 33628			_ = v.Args[1]
 33629			x := v.Args[0]
 33630			v_1 := v.Args[1]
 33631			if v_1.Op != OpConst16 {
 33632				break
 33633			}
 33634			if v_1.AuxInt != -1 {
 33635				break
 33636			}
 33637			v.reset(OpNeg16)
 33638			v.AddArg(x)
 33639			return true
 33640		}
 33641		// match: (Mul16 <t> n (Const16 [c]))
 33642		// cond: isPowerOfTwo(c)
 33643		// result: (Lsh16x64 <t> n (Const64 <typ.UInt64> [log2(c)]))
 33644		for {
 33645			t := v.Type
 33646			_ = v.Args[1]
 33647			n := v.Args[0]
 33648			v_1 := v.Args[1]
 33649			if v_1.Op != OpConst16 {
 33650				break
 33651			}
 33652			c := v_1.AuxInt
 33653			if !(isPowerOfTwo(c)) {
 33654				break
 33655			}
 33656			v.reset(OpLsh16x64)
 33657			v.Type = t
 33658			v.AddArg(n)
 33659			v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 33660			v0.AuxInt = log2(c)
 33661			v.AddArg(v0)
 33662			return true
 33663		}
 33664		// match: (Mul16 <t> (Const16 [c]) n)
 33665		// cond: isPowerOfTwo(c)
 33666		// result: (Lsh16x64 <t> n (Const64 <typ.UInt64> [log2(c)]))
 33667		for {
 33668			t := v.Type
 33669			n := v.Args[1]
 33670			v_0 := v.Args[0]
 33671			if v_0.Op != OpConst16 {
 33672				break
 33673			}
 33674			c := v_0.AuxInt
 33675			if !(isPowerOfTwo(c)) {
 33676				break
 33677			}
 33678			v.reset(OpLsh16x64)
 33679			v.Type = t
 33680			v.AddArg(n)
 33681			v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 33682			v0.AuxInt = log2(c)
 33683			v.AddArg(v0)
 33684			return true
 33685		}
 33686		// match: (Mul16 <t> n (Const16 [c]))
 33687		// cond: t.IsSigned() && isPowerOfTwo(-c)
 33688		// result: (Neg16 (Lsh16x64 <t> n (Const64 <typ.UInt64> [log2(-c)])))
 33689		for {
 33690			t := v.Type
 33691			_ = v.Args[1]
 33692			n := v.Args[0]
 33693			v_1 := v.Args[1]
 33694			if v_1.Op != OpConst16 {
 33695				break
 33696			}
 33697			c := v_1.AuxInt
 33698			if !(t.IsSigned() && isPowerOfTwo(-c)) {
 33699				break
 33700			}
 33701			v.reset(OpNeg16)
 33702			v0 := b.NewValue0(v.Pos, OpLsh16x64, t)
 33703			v0.AddArg(n)
 33704			v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 33705			v1.AuxInt = log2(-c)
 33706			v0.AddArg(v1)
 33707			v.AddArg(v0)
 33708			return true
 33709		}
 33710		// match: (Mul16 <t> (Const16 [c]) n)
 33711		// cond: t.IsSigned() && isPowerOfTwo(-c)
 33712		// result: (Neg16 (Lsh16x64 <t> n (Const64 <typ.UInt64> [log2(-c)])))
 33713		for {
 33714			t := v.Type
 33715			n := v.Args[1]
 33716			v_0 := v.Args[0]
 33717			if v_0.Op != OpConst16 {
 33718				break
 33719			}
 33720			c := v_0.AuxInt
 33721			if !(t.IsSigned() && isPowerOfTwo(-c)) {
 33722				break
 33723			}
 33724			v.reset(OpNeg16)
 33725			v0 := b.NewValue0(v.Pos, OpLsh16x64, t)
 33726			v0.AddArg(n)
 33727			v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 33728			v1.AuxInt = log2(-c)
 33729			v0.AddArg(v1)
 33730			v.AddArg(v0)
 33731			return true
 33732		}
 33733		return false
 33734	}
 33735	func rewriteValuegeneric_OpMul16_10(v *Value) bool {
 33736		b := v.Block
 33737		// match: (Mul16 (Const16 [0]) _)
 33738		// cond:
 33739		// result: (Const16 [0])
 33740		for {
 33741			_ = v.Args[1]
 33742			v_0 := v.Args[0]
 33743			if v_0.Op != OpConst16 {
 33744				break
 33745			}
 33746			if v_0.AuxInt != 0 {
 33747				break
 33748			}
 33749			v.reset(OpConst16)
 33750			v.AuxInt = 0
 33751			return true
 33752		}
 33753		// match: (Mul16 _ (Const16 [0]))
 33754		// cond:
 33755		// result: (Const16 [0])
 33756		for {
 33757			_ = v.Args[1]
 33758			v_1 := v.Args[1]
 33759			if v_1.Op != OpConst16 {
 33760				break
 33761			}
 33762			if v_1.AuxInt != 0 {
 33763				break
 33764			}
 33765			v.reset(OpConst16)
 33766			v.AuxInt = 0
 33767			return true
 33768		}
 33769		// match: (Mul16 (Const16 <t> [c]) (Mul16 (Const16 <t> [d]) x))
 33770		// cond:
 33771		// result: (Mul16 (Const16 <t> [int64(int16(c*d))]) x)
 33772		for {
 33773			_ = v.Args[1]
 33774			v_0 := v.Args[0]
 33775			if v_0.Op != OpConst16 {
 33776				break
 33777			}
 33778			t := v_0.Type
 33779			c := v_0.AuxInt
 33780			v_1 := v.Args[1]
 33781			if v_1.Op != OpMul16 {
 33782				break
 33783			}
 33784			x := v_1.Args[1]
 33785			v_1_0 := v_1.Args[0]
 33786			if v_1_0.Op != OpConst16 {
 33787				break
 33788			}
 33789			if v_1_0.Type != t {
 33790				break
 33791			}
 33792			d := v_1_0.AuxInt
 33793			v.reset(OpMul16)
 33794			v0 := b.NewValue0(v.Pos, OpConst16, t)
 33795			v0.AuxInt = int64(int16(c * d))
 33796			v.AddArg(v0)
 33797			v.AddArg(x)
 33798			return true
 33799		}
 33800		// match: (Mul16 (Const16 <t> [c]) (Mul16 x (Const16 <t> [d])))
 33801		// cond:
 33802		// result: (Mul16 (Const16 <t> [int64(int16(c*d))]) x)
 33803		for {
 33804			_ = v.Args[1]
 33805			v_0 := v.Args[0]
 33806			if v_0.Op != OpConst16 {
 33807				break
 33808			}
 33809			t := v_0.Type
 33810			c := v_0.AuxInt
 33811			v_1 := v.Args[1]
 33812			if v_1.Op != OpMul16 {
 33813				break
 33814			}
 33815			_ = v_1.Args[1]
 33816			x := v_1.Args[0]
 33817			v_1_1 := v_1.Args[1]
 33818			if v_1_1.Op != OpConst16 {
 33819				break
 33820			}
 33821			if v_1_1.Type != t {
 33822				break
 33823			}
 33824			d := v_1_1.AuxInt
 33825			v.reset(OpMul16)
 33826			v0 := b.NewValue0(v.Pos, OpConst16, t)
 33827			v0.AuxInt = int64(int16(c * d))
 33828			v.AddArg(v0)
 33829			v.AddArg(x)
 33830			return true
 33831		}
 33832		// match: (Mul16 (Mul16 (Const16 <t> [d]) x) (Const16 <t> [c]))
 33833		// cond:
 33834		// result: (Mul16 (Const16 <t> [int64(int16(c*d))]) x)
 33835		for {
 33836			_ = v.Args[1]
 33837			v_0 := v.Args[0]
 33838			if v_0.Op != OpMul16 {
 33839				break
 33840			}
 33841			x := v_0.Args[1]
 33842			v_0_0 := v_0.Args[0]
 33843			if v_0_0.Op != OpConst16 {
 33844				break
 33845			}
 33846			t := v_0_0.Type
 33847			d := v_0_0.AuxInt
 33848			v_1 := v.Args[1]
 33849			if v_1.Op != OpConst16 {
 33850				break
 33851			}
 33852			if v_1.Type != t {
 33853				break
 33854			}
 33855			c := v_1.AuxInt
 33856			v.reset(OpMul16)
 33857			v0 := b.NewValue0(v.Pos, OpConst16, t)
 33858			v0.AuxInt = int64(int16(c * d))
 33859			v.AddArg(v0)
 33860			v.AddArg(x)
 33861			return true
 33862		}
 33863		// match: (Mul16 (Mul16 x (Const16 <t> [d])) (Const16 <t> [c]))
 33864		// cond:
 33865		// result: (Mul16 (Const16 <t> [int64(int16(c*d))]) x)
 33866		for {
 33867			_ = v.Args[1]
 33868			v_0 := v.Args[0]
 33869			if v_0.Op != OpMul16 {
 33870				break
 33871			}
 33872			_ = v_0.Args[1]
 33873			x := v_0.Args[0]
 33874			v_0_1 := v_0.Args[1]
 33875			if v_0_1.Op != OpConst16 {
 33876				break
 33877			}
 33878			t := v_0_1.Type
 33879			d := v_0_1.AuxInt
 33880			v_1 := v.Args[1]
 33881			if v_1.Op != OpConst16 {
 33882				break
 33883			}
 33884			if v_1.Type != t {
 33885				break
 33886			}
 33887			c := v_1.AuxInt
 33888			v.reset(OpMul16)
 33889			v0 := b.NewValue0(v.Pos, OpConst16, t)
 33890			v0.AuxInt = int64(int16(c * d))
 33891			v.AddArg(v0)
 33892			v.AddArg(x)
 33893			return true
 33894		}
 33895		return false
 33896	}
 33897	func rewriteValuegeneric_OpMul32_0(v *Value) bool {
 33898		b := v.Block
 33899		typ := &b.Func.Config.Types
 33900		// match: (Mul32 (Const32 [c]) (Const32 [d]))
 33901		// cond:
 33902		// result: (Const32 [int64(int32(c*d))])
 33903		for {
 33904			_ = v.Args[1]
 33905			v_0 := v.Args[0]
 33906			if v_0.Op != OpConst32 {
 33907				break
 33908			}
 33909			c := v_0.AuxInt
 33910			v_1 := v.Args[1]
 33911			if v_1.Op != OpConst32 {
 33912				break
 33913			}
 33914			d := v_1.AuxInt
 33915			v.reset(OpConst32)
 33916			v.AuxInt = int64(int32(c * d))
 33917			return true
 33918		}
 33919		// match: (Mul32 (Const32 [d]) (Const32 [c]))
 33920		// cond:
 33921		// result: (Const32 [int64(int32(c*d))])
 33922		for {
 33923			_ = v.Args[1]
 33924			v_0 := v.Args[0]
 33925			if v_0.Op != OpConst32 {
 33926				break
 33927			}
 33928			d := v_0.AuxInt
 33929			v_1 := v.Args[1]
 33930			if v_1.Op != OpConst32 {
 33931				break
 33932			}
 33933			c := v_1.AuxInt
 33934			v.reset(OpConst32)
 33935			v.AuxInt = int64(int32(c * d))
 33936			return true
 33937		}
 33938		// match: (Mul32 (Const32 [1]) x)
 33939		// cond:
 33940		// result: x
 33941		for {
 33942			x := v.Args[1]
 33943			v_0 := v.Args[0]
 33944			if v_0.Op != OpConst32 {
 33945				break
 33946			}
 33947			if v_0.AuxInt != 1 {
 33948				break
 33949			}
 33950			v.reset(OpCopy)
 33951			v.Type = x.Type
 33952			v.AddArg(x)
 33953			return true
 33954		}
 33955		// match: (Mul32 x (Const32 [1]))
 33956		// cond:
 33957		// result: x
 33958		for {
 33959			_ = v.Args[1]
 33960			x := v.Args[0]
 33961			v_1 := v.Args[1]
 33962			if v_1.Op != OpConst32 {
 33963				break
 33964			}
 33965			if v_1.AuxInt != 1 {
 33966				break
 33967			}
 33968			v.reset(OpCopy)
 33969			v.Type = x.Type
 33970			v.AddArg(x)
 33971			return true
 33972		}
 33973		// match: (Mul32 (Const32 [-1]) x)
 33974		// cond:
 33975		// result: (Neg32 x)
 33976		for {
 33977			x := v.Args[1]
 33978			v_0 := v.Args[0]
 33979			if v_0.Op != OpConst32 {
 33980				break
 33981			}
 33982			if v_0.AuxInt != -1 {
 33983				break
 33984			}
 33985			v.reset(OpNeg32)
 33986			v.AddArg(x)
 33987			return true
 33988		}
 33989		// match: (Mul32 x (Const32 [-1]))
 33990		// cond:
 33991		// result: (Neg32 x)
 33992		for {
 33993			_ = v.Args[1]
 33994			x := v.Args[0]
 33995			v_1 := v.Args[1]
 33996			if v_1.Op != OpConst32 {
 33997				break
 33998			}
 33999			if v_1.AuxInt != -1 {
 34000				break
 34001			}
 34002			v.reset(OpNeg32)
 34003			v.AddArg(x)
 34004			return true
 34005		}
 34006		// match: (Mul32 <t> n (Const32 [c]))
 34007		// cond: isPowerOfTwo(c)
 34008		// result: (Lsh32x64 <t> n (Const64 <typ.UInt64> [log2(c)]))
 34009		for {
 34010			t := v.Type
 34011			_ = v.Args[1]
 34012			n := v.Args[0]
 34013			v_1 := v.Args[1]
 34014			if v_1.Op != OpConst32 {
 34015				break
 34016			}
 34017			c := v_1.AuxInt
 34018			if !(isPowerOfTwo(c)) {
 34019				break
 34020			}
 34021			v.reset(OpLsh32x64)
 34022			v.Type = t
 34023			v.AddArg(n)
 34024			v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 34025			v0.AuxInt = log2(c)
 34026			v.AddArg(v0)
 34027			return true
 34028		}
 34029		// match: (Mul32 <t> (Const32 [c]) n)
 34030		// cond: isPowerOfTwo(c)
 34031		// result: (Lsh32x64 <t> n (Const64 <typ.UInt64> [log2(c)]))
 34032		for {
 34033			t := v.Type
 34034			n := v.Args[1]
 34035			v_0 := v.Args[0]
 34036			if v_0.Op != OpConst32 {
 34037				break
 34038			}
 34039			c := v_0.AuxInt
 34040			if !(isPowerOfTwo(c)) {
 34041				break
 34042			}
 34043			v.reset(OpLsh32x64)
 34044			v.Type = t
 34045			v.AddArg(n)
 34046			v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 34047			v0.AuxInt = log2(c)
 34048			v.AddArg(v0)
 34049			return true
 34050		}
 34051		// match: (Mul32 <t> n (Const32 [c]))
 34052		// cond: t.IsSigned() && isPowerOfTwo(-c)
 34053		// result: (Neg32 (Lsh32x64 <t> n (Const64 <typ.UInt64> [log2(-c)])))
 34054		for {
 34055			t := v.Type
 34056			_ = v.Args[1]
 34057			n := v.Args[0]
 34058			v_1 := v.Args[1]
 34059			if v_1.Op != OpConst32 {
 34060				break
 34061			}
 34062			c := v_1.AuxInt
 34063			if !(t.IsSigned() && isPowerOfTwo(-c)) {
 34064				break
 34065			}
 34066			v.reset(OpNeg32)
 34067			v0 := b.NewValue0(v.Pos, OpLsh32x64, t)
 34068			v0.AddArg(n)
 34069			v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 34070			v1.AuxInt = log2(-c)
 34071			v0.AddArg(v1)
 34072			v.AddArg(v0)
 34073			return true
 34074		}
 34075		// match: (Mul32 <t> (Const32 [c]) n)
 34076		// cond: t.IsSigned() && isPowerOfTwo(-c)
 34077		// result: (Neg32 (Lsh32x64 <t> n (Const64 <typ.UInt64> [log2(-c)])))
 34078		for {
 34079			t := v.Type
 34080			n := v.Args[1]
 34081			v_0 := v.Args[0]
 34082			if v_0.Op != OpConst32 {
 34083				break
 34084			}
 34085			c := v_0.AuxInt
 34086			if !(t.IsSigned() && isPowerOfTwo(-c)) {
 34087				break
 34088			}
 34089			v.reset(OpNeg32)
 34090			v0 := b.NewValue0(v.Pos, OpLsh32x64, t)
 34091			v0.AddArg(n)
 34092			v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 34093			v1.AuxInt = log2(-c)
 34094			v0.AddArg(v1)
 34095			v.AddArg(v0)
 34096			return true
 34097		}
 34098		return false
 34099	}
 34100	func rewriteValuegeneric_OpMul32_10(v *Value) bool {
 34101		b := v.Block
 34102		// match: (Mul32 (Const32 <t> [c]) (Add32 <t> (Const32 <t> [d]) x))
 34103		// cond:
 34104		// result: (Add32 (Const32 <t> [int64(int32(c*d))]) (Mul32 <t> (Const32 <t> [c]) x))
 34105		for {
 34106			_ = v.Args[1]
 34107			v_0 := v.Args[0]
 34108			if v_0.Op != OpConst32 {
 34109				break
 34110			}
 34111			t := v_0.Type
 34112			c := v_0.AuxInt
 34113			v_1 := v.Args[1]
 34114			if v_1.Op != OpAdd32 {
 34115				break
 34116			}
 34117			if v_1.Type != t {
 34118				break
 34119			}
 34120			x := v_1.Args[1]
 34121			v_1_0 := v_1.Args[0]
 34122			if v_1_0.Op != OpConst32 {
 34123				break
 34124			}
 34125			if v_1_0.Type != t {
 34126				break
 34127			}
 34128			d := v_1_0.AuxInt
 34129			v.reset(OpAdd32)
 34130			v0 := b.NewValue0(v.Pos, OpConst32, t)
 34131			v0.AuxInt = int64(int32(c * d))
 34132			v.AddArg(v0)
 34133			v1 := b.NewValue0(v.Pos, OpMul32, t)
 34134			v2 := b.NewValue0(v.Pos, OpConst32, t)
 34135			v2.AuxInt = c
 34136			v1.AddArg(v2)
 34137			v1.AddArg(x)
 34138			v.AddArg(v1)
 34139			return true
 34140		}
 34141		// match: (Mul32 (Const32 <t> [c]) (Add32 <t> x (Const32 <t> [d])))
 34142		// cond:
 34143		// result: (Add32 (Const32 <t> [int64(int32(c*d))]) (Mul32 <t> (Const32 <t> [c]) x))
 34144		for {
 34145			_ = v.Args[1]
 34146			v_0 := v.Args[0]
 34147			if v_0.Op != OpConst32 {
 34148				break
 34149			}
 34150			t := v_0.Type
 34151			c := v_0.AuxInt
 34152			v_1 := v.Args[1]
 34153			if v_1.Op != OpAdd32 {
 34154				break
 34155			}
 34156			if v_1.Type != t {
 34157				break
 34158			}
 34159			_ = v_1.Args[1]
 34160			x := v_1.Args[0]
 34161			v_1_1 := v_1.Args[1]
 34162			if v_1_1.Op != OpConst32 {
 34163				break
 34164			}
 34165			if v_1_1.Type != t {
 34166				break
 34167			}
 34168			d := v_1_1.AuxInt
 34169			v.reset(OpAdd32)
 34170			v0 := b.NewValue0(v.Pos, OpConst32, t)
 34171			v0.AuxInt = int64(int32(c * d))
 34172			v.AddArg(v0)
 34173			v1 := b.NewValue0(v.Pos, OpMul32, t)
 34174			v2 := b.NewValue0(v.Pos, OpConst32, t)
 34175			v2.AuxInt = c
 34176			v1.AddArg(v2)
 34177			v1.AddArg(x)
 34178			v.AddArg(v1)
 34179			return true
 34180		}
 34181		// match: (Mul32 (Add32 <t> (Const32 <t> [d]) x) (Const32 <t> [c]))
 34182		// cond:
 34183		// result: (Add32 (Const32 <t> [int64(int32(c*d))]) (Mul32 <t> (Const32 <t> [c]) x))
 34184		for {
 34185			_ = v.Args[1]
 34186			v_0 := v.Args[0]
 34187			if v_0.Op != OpAdd32 {
 34188				break
 34189			}
 34190			t := v_0.Type
 34191			x := v_0.Args[1]
 34192			v_0_0 := v_0.Args[0]
 34193			if v_0_0.Op != OpConst32 {
 34194				break
 34195			}
 34196			if v_0_0.Type != t {
 34197				break
 34198			}
 34199			d := v_0_0.AuxInt
 34200			v_1 := v.Args[1]
 34201			if v_1.Op != OpConst32 {
 34202				break
 34203			}
 34204			if v_1.Type != t {
 34205				break
 34206			}
 34207			c := v_1.AuxInt
 34208			v.reset(OpAdd32)
 34209			v0 := b.NewValue0(v.Pos, OpConst32, t)
 34210			v0.AuxInt = int64(int32(c * d))
 34211			v.AddArg(v0)
 34212			v1 := b.NewValue0(v.Pos, OpMul32, t)
 34213			v2 := b.NewValue0(v.Pos, OpConst32, t)
 34214			v2.AuxInt = c
 34215			v1.AddArg(v2)
 34216			v1.AddArg(x)
 34217			v.AddArg(v1)
 34218			return true
 34219		}
 34220		// match: (Mul32 (Add32 <t> x (Const32 <t> [d])) (Const32 <t> [c]))
 34221		// cond:
 34222		// result: (Add32 (Const32 <t> [int64(int32(c*d))]) (Mul32 <t> (Const32 <t> [c]) x))
 34223		for {
 34224			_ = v.Args[1]
 34225			v_0 := v.Args[0]
 34226			if v_0.Op != OpAdd32 {
 34227				break
 34228			}
 34229			t := v_0.Type
 34230			_ = v_0.Args[1]
 34231			x := v_0.Args[0]
 34232			v_0_1 := v_0.Args[1]
 34233			if v_0_1.Op != OpConst32 {
 34234				break
 34235			}
 34236			if v_0_1.Type != t {
 34237				break
 34238			}
 34239			d := v_0_1.AuxInt
 34240			v_1 := v.Args[1]
 34241			if v_1.Op != OpConst32 {
 34242				break
 34243			}
 34244			if v_1.Type != t {
 34245				break
 34246			}
 34247			c := v_1.AuxInt
 34248			v.reset(OpAdd32)
 34249			v0 := b.NewValue0(v.Pos, OpConst32, t)
 34250			v0.AuxInt = int64(int32(c * d))
 34251			v.AddArg(v0)
 34252			v1 := b.NewValue0(v.Pos, OpMul32, t)
 34253			v2 := b.NewValue0(v.Pos, OpConst32, t)
 34254			v2.AuxInt = c
 34255			v1.AddArg(v2)
 34256			v1.AddArg(x)
 34257			v.AddArg(v1)
 34258			return true
 34259		}
 34260		// match: (Mul32 (Const32 [0]) _)
 34261		// cond:
 34262		// result: (Const32 [0])
 34263		for {
 34264			_ = v.Args[1]
 34265			v_0 := v.Args[0]
 34266			if v_0.Op != OpConst32 {
 34267				break
 34268			}
 34269			if v_0.AuxInt != 0 {
 34270				break
 34271			}
 34272			v.reset(OpConst32)
 34273			v.AuxInt = 0
 34274			return true
 34275		}
 34276		// match: (Mul32 _ (Const32 [0]))
 34277		// cond:
 34278		// result: (Const32 [0])
 34279		for {
 34280			_ = v.Args[1]
 34281			v_1 := v.Args[1]
 34282			if v_1.Op != OpConst32 {
 34283				break
 34284			}
 34285			if v_1.AuxInt != 0 {
 34286				break
 34287			}
 34288			v.reset(OpConst32)
 34289			v.AuxInt = 0
 34290			return true
 34291		}
 34292		// match: (Mul32 (Const32 <t> [c]) (Mul32 (Const32 <t> [d]) x))
 34293		// cond:
 34294		// result: (Mul32 (Const32 <t> [int64(int32(c*d))]) x)
 34295		for {
 34296			_ = v.Args[1]
 34297			v_0 := v.Args[0]
 34298			if v_0.Op != OpConst32 {
 34299				break
 34300			}
 34301			t := v_0.Type
 34302			c := v_0.AuxInt
 34303			v_1 := v.Args[1]
 34304			if v_1.Op != OpMul32 {
 34305				break
 34306			}
 34307			x := v_1.Args[1]
 34308			v_1_0 := v_1.Args[0]
 34309			if v_1_0.Op != OpConst32 {
 34310				break
 34311			}
 34312			if v_1_0.Type != t {
 34313				break
 34314			}
 34315			d := v_1_0.AuxInt
 34316			v.reset(OpMul32)
 34317			v0 := b.NewValue0(v.Pos, OpConst32, t)
 34318			v0.AuxInt = int64(int32(c * d))
 34319			v.AddArg(v0)
 34320			v.AddArg(x)
 34321			return true
 34322		}
 34323		// match: (Mul32 (Const32 <t> [c]) (Mul32 x (Const32 <t> [d])))
 34324		// cond:
 34325		// result: (Mul32 (Const32 <t> [int64(int32(c*d))]) x)
 34326		for {
 34327			_ = v.Args[1]
 34328			v_0 := v.Args[0]
 34329			if v_0.Op != OpConst32 {
 34330				break
 34331			}
 34332			t := v_0.Type
 34333			c := v_0.AuxInt
 34334			v_1 := v.Args[1]
 34335			if v_1.Op != OpMul32 {
 34336				break
 34337			}
 34338			_ = v_1.Args[1]
 34339			x := v_1.Args[0]
 34340			v_1_1 := v_1.Args[1]
 34341			if v_1_1.Op != OpConst32 {
 34342				break
 34343			}
 34344			if v_1_1.Type != t {
 34345				break
 34346			}
 34347			d := v_1_1.AuxInt
 34348			v.reset(OpMul32)
 34349			v0 := b.NewValue0(v.Pos, OpConst32, t)
 34350			v0.AuxInt = int64(int32(c * d))
 34351			v.AddArg(v0)
 34352			v.AddArg(x)
 34353			return true
 34354		}
 34355		// match: (Mul32 (Mul32 (Const32 <t> [d]) x) (Const32 <t> [c]))
 34356		// cond:
 34357		// result: (Mul32 (Const32 <t> [int64(int32(c*d))]) x)
 34358		for {
 34359			_ = v.Args[1]
 34360			v_0 := v.Args[0]
 34361			if v_0.Op != OpMul32 {
 34362				break
 34363			}
 34364			x := v_0.Args[1]
 34365			v_0_0 := v_0.Args[0]
 34366			if v_0_0.Op != OpConst32 {
 34367				break
 34368			}
 34369			t := v_0_0.Type
 34370			d := v_0_0.AuxInt
 34371			v_1 := v.Args[1]
 34372			if v_1.Op != OpConst32 {
 34373				break
 34374			}
 34375			if v_1.Type != t {
 34376				break
 34377			}
 34378			c := v_1.AuxInt
 34379			v.reset(OpMul32)
 34380			v0 := b.NewValue0(v.Pos, OpConst32, t)
 34381			v0.AuxInt = int64(int32(c * d))
 34382			v.AddArg(v0)
 34383			v.AddArg(x)
 34384			return true
 34385		}
 34386		// match: (Mul32 (Mul32 x (Const32 <t> [d])) (Const32 <t> [c]))
 34387		// cond:
 34388		// result: (Mul32 (Const32 <t> [int64(int32(c*d))]) x)
 34389		for {
 34390			_ = v.Args[1]
 34391			v_0 := v.Args[0]
 34392			if v_0.Op != OpMul32 {
 34393				break
 34394			}
 34395			_ = v_0.Args[1]
 34396			x := v_0.Args[0]
 34397			v_0_1 := v_0.Args[1]
 34398			if v_0_1.Op != OpConst32 {
 34399				break
 34400			}
 34401			t := v_0_1.Type
 34402			d := v_0_1.AuxInt
 34403			v_1 := v.Args[1]
 34404			if v_1.Op != OpConst32 {
 34405				break
 34406			}
 34407			if v_1.Type != t {
 34408				break
 34409			}
 34410			c := v_1.AuxInt
 34411			v.reset(OpMul32)
 34412			v0 := b.NewValue0(v.Pos, OpConst32, t)
 34413			v0.AuxInt = int64(int32(c * d))
 34414			v.AddArg(v0)
 34415			v.AddArg(x)
 34416			return true
 34417		}
 34418		return false
 34419	}
 34420	func rewriteValuegeneric_OpMul32F_0(v *Value) bool {
 34421		// match: (Mul32F (Const32F [c]) (Const32F [d]))
 34422		// cond:
 34423		// result: (Const32F [auxFrom32F(auxTo32F(c) * auxTo32F(d))])
 34424		for {
 34425			_ = v.Args[1]
 34426			v_0 := v.Args[0]
 34427			if v_0.Op != OpConst32F {
 34428				break
 34429			}
 34430			c := v_0.AuxInt
 34431			v_1 := v.Args[1]
 34432			if v_1.Op != OpConst32F {
 34433				break
 34434			}
 34435			d := v_1.AuxInt
 34436			v.reset(OpConst32F)
 34437			v.AuxInt = auxFrom32F(auxTo32F(c) * auxTo32F(d))
 34438			return true
 34439		}
 34440		// match: (Mul32F (Const32F [d]) (Const32F [c]))
 34441		// cond:
 34442		// result: (Const32F [auxFrom32F(auxTo32F(c) * auxTo32F(d))])
 34443		for {
 34444			_ = v.Args[1]
 34445			v_0 := v.Args[0]
 34446			if v_0.Op != OpConst32F {
 34447				break
 34448			}
 34449			d := v_0.AuxInt
 34450			v_1 := v.Args[1]
 34451			if v_1.Op != OpConst32F {
 34452				break
 34453			}
 34454			c := v_1.AuxInt
 34455			v.reset(OpConst32F)
 34456			v.AuxInt = auxFrom32F(auxTo32F(c) * auxTo32F(d))
 34457			return true
 34458		}
 34459		// match: (Mul32F x (Const32F [auxFrom64F(1)]))
 34460		// cond:
 34461		// result: x
 34462		for {
 34463			_ = v.Args[1]
 34464			x := v.Args[0]
 34465			v_1 := v.Args[1]
 34466			if v_1.Op != OpConst32F {
 34467				break
 34468			}
 34469			if v_1.AuxInt != auxFrom64F(1) {
 34470				break
 34471			}
 34472			v.reset(OpCopy)
 34473			v.Type = x.Type
 34474			v.AddArg(x)
 34475			return true
 34476		}
 34477		// match: (Mul32F (Const32F [auxFrom64F(1)]) x)
 34478		// cond:
 34479		// result: x
 34480		for {
 34481			x := v.Args[1]
 34482			v_0 := v.Args[0]
 34483			if v_0.Op != OpConst32F {
 34484				break
 34485			}
 34486			if v_0.AuxInt != auxFrom64F(1) {
 34487				break
 34488			}
 34489			v.reset(OpCopy)
 34490			v.Type = x.Type
 34491			v.AddArg(x)
 34492			return true
 34493		}
 34494		// match: (Mul32F x (Const32F [auxFrom32F(-1)]))
 34495		// cond:
 34496		// result: (Neg32F x)
 34497		for {
 34498			_ = v.Args[1]
 34499			x := v.Args[0]
 34500			v_1 := v.Args[1]
 34501			if v_1.Op != OpConst32F {
 34502				break
 34503			}
 34504			if v_1.AuxInt != auxFrom32F(-1) {
 34505				break
 34506			}
 34507			v.reset(OpNeg32F)
 34508			v.AddArg(x)
 34509			return true
 34510		}
 34511		// match: (Mul32F (Const32F [auxFrom32F(-1)]) x)
 34512		// cond:
 34513		// result: (Neg32F x)
 34514		for {
 34515			x := v.Args[1]
 34516			v_0 := v.Args[0]
 34517			if v_0.Op != OpConst32F {
 34518				break
 34519			}
 34520			if v_0.AuxInt != auxFrom32F(-1) {
 34521				break
 34522			}
 34523			v.reset(OpNeg32F)
 34524			v.AddArg(x)
 34525			return true
 34526		}
 34527		// match: (Mul32F x (Const32F [auxFrom32F(2)]))
 34528		// cond:
 34529		// result: (Add32F x x)
 34530		for {
 34531			_ = v.Args[1]
 34532			x := v.Args[0]
 34533			v_1 := v.Args[1]
 34534			if v_1.Op != OpConst32F {
 34535				break
 34536			}
 34537			if v_1.AuxInt != auxFrom32F(2) {
 34538				break
 34539			}
 34540			v.reset(OpAdd32F)
 34541			v.AddArg(x)
 34542			v.AddArg(x)
 34543			return true
 34544		}
 34545		// match: (Mul32F (Const32F [auxFrom32F(2)]) x)
 34546		// cond:
 34547		// result: (Add32F x x)
 34548		for {
 34549			x := v.Args[1]
 34550			v_0 := v.Args[0]
 34551			if v_0.Op != OpConst32F {
 34552				break
 34553			}
 34554			if v_0.AuxInt != auxFrom32F(2) {
 34555				break
 34556			}
 34557			v.reset(OpAdd32F)
 34558			v.AddArg(x)
 34559			v.AddArg(x)
 34560			return true
 34561		}
 34562		return false
 34563	}
 34564	func rewriteValuegeneric_OpMul64_0(v *Value) bool {
 34565		b := v.Block
 34566		typ := &b.Func.Config.Types
 34567		// match: (Mul64 (Const64 [c]) (Const64 [d]))
 34568		// cond:
 34569		// result: (Const64 [c*d])
 34570		for {
 34571			_ = v.Args[1]
 34572			v_0 := v.Args[0]
 34573			if v_0.Op != OpConst64 {
 34574				break
 34575			}
 34576			c := v_0.AuxInt
 34577			v_1 := v.Args[1]
 34578			if v_1.Op != OpConst64 {
 34579				break
 34580			}
 34581			d := v_1.AuxInt
 34582			v.reset(OpConst64)
 34583			v.AuxInt = c * d
 34584			return true
 34585		}
 34586		// match: (Mul64 (Const64 [d]) (Const64 [c]))
 34587		// cond:
 34588		// result: (Const64 [c*d])
 34589		for {
 34590			_ = v.Args[1]
 34591			v_0 := v.Args[0]
 34592			if v_0.Op != OpConst64 {
 34593				break
 34594			}
 34595			d := v_0.AuxInt
 34596			v_1 := v.Args[1]
 34597			if v_1.Op != OpConst64 {
 34598				break
 34599			}
 34600			c := v_1.AuxInt
 34601			v.reset(OpConst64)
 34602			v.AuxInt = c * d
 34603			return true
 34604		}
 34605		// match: (Mul64 (Const64 [1]) x)
 34606		// cond:
 34607		// result: x
 34608		for {
 34609			x := v.Args[1]
 34610			v_0 := v.Args[0]
 34611			if v_0.Op != OpConst64 {
 34612				break
 34613			}
 34614			if v_0.AuxInt != 1 {
 34615				break
 34616			}
 34617			v.reset(OpCopy)
 34618			v.Type = x.Type
 34619			v.AddArg(x)
 34620			return true
 34621		}
 34622		// match: (Mul64 x (Const64 [1]))
 34623		// cond:
 34624		// result: x
 34625		for {
 34626			_ = v.Args[1]
 34627			x := v.Args[0]
 34628			v_1 := v.Args[1]
 34629			if v_1.Op != OpConst64 {
 34630				break
 34631			}
 34632			if v_1.AuxInt != 1 {
 34633				break
 34634			}
 34635			v.reset(OpCopy)
 34636			v.Type = x.Type
 34637			v.AddArg(x)
 34638			return true
 34639		}
 34640		// match: (Mul64 (Const64 [-1]) x)
 34641		// cond:
 34642		// result: (Neg64 x)
 34643		for {
 34644			x := v.Args[1]
 34645			v_0 := v.Args[0]
 34646			if v_0.Op != OpConst64 {
 34647				break
 34648			}
 34649			if v_0.AuxInt != -1 {
 34650				break
 34651			}
 34652			v.reset(OpNeg64)
 34653			v.AddArg(x)
 34654			return true
 34655		}
 34656		// match: (Mul64 x (Const64 [-1]))
 34657		// cond:
 34658		// result: (Neg64 x)
 34659		for {
 34660			_ = v.Args[1]
 34661			x := v.Args[0]
 34662			v_1 := v.Args[1]
 34663			if v_1.Op != OpConst64 {
 34664				break
 34665			}
 34666			if v_1.AuxInt != -1 {
 34667				break
 34668			}
 34669			v.reset(OpNeg64)
 34670			v.AddArg(x)
 34671			return true
 34672		}
 34673		// match: (Mul64 <t> n (Const64 [c]))
 34674		// cond: isPowerOfTwo(c)
 34675		// result: (Lsh64x64 <t> n (Const64 <typ.UInt64> [log2(c)]))
 34676		for {
 34677			t := v.Type
 34678			_ = v.Args[1]
 34679			n := v.Args[0]
 34680			v_1 := v.Args[1]
 34681			if v_1.Op != OpConst64 {
 34682				break
 34683			}
 34684			c := v_1.AuxInt
 34685			if !(isPowerOfTwo(c)) {
 34686				break
 34687			}
 34688			v.reset(OpLsh64x64)
 34689			v.Type = t
 34690			v.AddArg(n)
 34691			v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 34692			v0.AuxInt = log2(c)
 34693			v.AddArg(v0)
 34694			return true
 34695		}
 34696		// match: (Mul64 <t> (Const64 [c]) n)
 34697		// cond: isPowerOfTwo(c)
 34698		// result: (Lsh64x64 <t> n (Const64 <typ.UInt64> [log2(c)]))
 34699		for {
 34700			t := v.Type
 34701			n := v.Args[1]
 34702			v_0 := v.Args[0]
 34703			if v_0.Op != OpConst64 {
 34704				break
 34705			}
 34706			c := v_0.AuxInt
 34707			if !(isPowerOfTwo(c)) {
 34708				break
 34709			}
 34710			v.reset(OpLsh64x64)
 34711			v.Type = t
 34712			v.AddArg(n)
 34713			v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 34714			v0.AuxInt = log2(c)
 34715			v.AddArg(v0)
 34716			return true
 34717		}
 34718		// match: (Mul64 <t> n (Const64 [c]))
 34719		// cond: t.IsSigned() && isPowerOfTwo(-c)
 34720		// result: (Neg64 (Lsh64x64 <t> n (Const64 <typ.UInt64> [log2(-c)])))
 34721		for {
 34722			t := v.Type
 34723			_ = v.Args[1]
 34724			n := v.Args[0]
 34725			v_1 := v.Args[1]
 34726			if v_1.Op != OpConst64 {
 34727				break
 34728			}
 34729			c := v_1.AuxInt
 34730			if !(t.IsSigned() && isPowerOfTwo(-c)) {
 34731				break
 34732			}
 34733			v.reset(OpNeg64)
 34734			v0 := b.NewValue0(v.Pos, OpLsh64x64, t)
 34735			v0.AddArg(n)
 34736			v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 34737			v1.AuxInt = log2(-c)
 34738			v0.AddArg(v1)
 34739			v.AddArg(v0)
 34740			return true
 34741		}
 34742		// match: (Mul64 <t> (Const64 [c]) n)
 34743		// cond: t.IsSigned() && isPowerOfTwo(-c)
 34744		// result: (Neg64 (Lsh64x64 <t> n (Const64 <typ.UInt64> [log2(-c)])))
 34745		for {
 34746			t := v.Type
 34747			n := v.Args[1]
 34748			v_0 := v.Args[0]
 34749			if v_0.Op != OpConst64 {
 34750				break
 34751			}
 34752			c := v_0.AuxInt
 34753			if !(t.IsSigned() && isPowerOfTwo(-c)) {
 34754				break
 34755			}
 34756			v.reset(OpNeg64)
 34757			v0 := b.NewValue0(v.Pos, OpLsh64x64, t)
 34758			v0.AddArg(n)
 34759			v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 34760			v1.AuxInt = log2(-c)
 34761			v0.AddArg(v1)
 34762			v.AddArg(v0)
 34763			return true
 34764		}
 34765		return false
 34766	}
 34767	func rewriteValuegeneric_OpMul64_10(v *Value) bool {
 34768		b := v.Block
 34769		// match: (Mul64 (Const64 <t> [c]) (Add64 <t> (Const64 <t> [d]) x))
 34770		// cond:
 34771		// result: (Add64 (Const64 <t> [c*d]) (Mul64 <t> (Const64 <t> [c]) x))
 34772		for {
 34773			_ = v.Args[1]
 34774			v_0 := v.Args[0]
 34775			if v_0.Op != OpConst64 {
 34776				break
 34777			}
 34778			t := v_0.Type
 34779			c := v_0.AuxInt
 34780			v_1 := v.Args[1]
 34781			if v_1.Op != OpAdd64 {
 34782				break
 34783			}
 34784			if v_1.Type != t {
 34785				break
 34786			}
 34787			x := v_1.Args[1]
 34788			v_1_0 := v_1.Args[0]
 34789			if v_1_0.Op != OpConst64 {
 34790				break
 34791			}
 34792			if v_1_0.Type != t {
 34793				break
 34794			}
 34795			d := v_1_0.AuxInt
 34796			v.reset(OpAdd64)
 34797			v0 := b.NewValue0(v.Pos, OpConst64, t)
 34798			v0.AuxInt = c * d
 34799			v.AddArg(v0)
 34800			v1 := b.NewValue0(v.Pos, OpMul64, t)
 34801			v2 := b.NewValue0(v.Pos, OpConst64, t)
 34802			v2.AuxInt = c
 34803			v1.AddArg(v2)
 34804			v1.AddArg(x)
 34805			v.AddArg(v1)
 34806			return true
 34807		}
 34808		// match: (Mul64 (Const64 <t> [c]) (Add64 <t> x (Const64 <t> [d])))
 34809		// cond:
 34810		// result: (Add64 (Const64 <t> [c*d]) (Mul64 <t> (Const64 <t> [c]) x))
 34811		for {
 34812			_ = v.Args[1]
 34813			v_0 := v.Args[0]
 34814			if v_0.Op != OpConst64 {
 34815				break
 34816			}
 34817			t := v_0.Type
 34818			c := v_0.AuxInt
 34819			v_1 := v.Args[1]
 34820			if v_1.Op != OpAdd64 {
 34821				break
 34822			}
 34823			if v_1.Type != t {
 34824				break
 34825			}
 34826			_ = v_1.Args[1]
 34827			x := v_1.Args[0]
 34828			v_1_1 := v_1.Args[1]
 34829			if v_1_1.Op != OpConst64 {
 34830				break
 34831			}
 34832			if v_1_1.Type != t {
 34833				break
 34834			}
 34835			d := v_1_1.AuxInt
 34836			v.reset(OpAdd64)
 34837			v0 := b.NewValue0(v.Pos, OpConst64, t)
 34838			v0.AuxInt = c * d
 34839			v.AddArg(v0)
 34840			v1 := b.NewValue0(v.Pos, OpMul64, t)
 34841			v2 := b.NewValue0(v.Pos, OpConst64, t)
 34842			v2.AuxInt = c
 34843			v1.AddArg(v2)
 34844			v1.AddArg(x)
 34845			v.AddArg(v1)
 34846			return true
 34847		}
 34848		// match: (Mul64 (Add64 <t> (Const64 <t> [d]) x) (Const64 <t> [c]))
 34849		// cond:
 34850		// result: (Add64 (Const64 <t> [c*d]) (Mul64 <t> (Const64 <t> [c]) x))
 34851		for {
 34852			_ = v.Args[1]
 34853			v_0 := v.Args[0]
 34854			if v_0.Op != OpAdd64 {
 34855				break
 34856			}
 34857			t := v_0.Type
 34858			x := v_0.Args[1]
 34859			v_0_0 := v_0.Args[0]
 34860			if v_0_0.Op != OpConst64 {
 34861				break
 34862			}
 34863			if v_0_0.Type != t {
 34864				break
 34865			}
 34866			d := v_0_0.AuxInt
 34867			v_1 := v.Args[1]
 34868			if v_1.Op != OpConst64 {
 34869				break
 34870			}
 34871			if v_1.Type != t {
 34872				break
 34873			}
 34874			c := v_1.AuxInt
 34875			v.reset(OpAdd64)
 34876			v0 := b.NewValue0(v.Pos, OpConst64, t)
 34877			v0.AuxInt = c * d
 34878			v.AddArg(v0)
 34879			v1 := b.NewValue0(v.Pos, OpMul64, t)
 34880			v2 := b.NewValue0(v.Pos, OpConst64, t)
 34881			v2.AuxInt = c
 34882			v1.AddArg(v2)
 34883			v1.AddArg(x)
 34884			v.AddArg(v1)
 34885			return true
 34886		}
 34887		// match: (Mul64 (Add64 <t> x (Const64 <t> [d])) (Const64 <t> [c]))
 34888		// cond:
 34889		// result: (Add64 (Const64 <t> [c*d]) (Mul64 <t> (Const64 <t> [c]) x))
 34890		for {
 34891			_ = v.Args[1]
 34892			v_0 := v.Args[0]
 34893			if v_0.Op != OpAdd64 {
 34894				break
 34895			}
 34896			t := v_0.Type
 34897			_ = v_0.Args[1]
 34898			x := v_0.Args[0]
 34899			v_0_1 := v_0.Args[1]
 34900			if v_0_1.Op != OpConst64 {
 34901				break
 34902			}
 34903			if v_0_1.Type != t {
 34904				break
 34905			}
 34906			d := v_0_1.AuxInt
 34907			v_1 := v.Args[1]
 34908			if v_1.Op != OpConst64 {
 34909				break
 34910			}
 34911			if v_1.Type != t {
 34912				break
 34913			}
 34914			c := v_1.AuxInt
 34915			v.reset(OpAdd64)
 34916			v0 := b.NewValue0(v.Pos, OpConst64, t)
 34917			v0.AuxInt = c * d
 34918			v.AddArg(v0)
 34919			v1 := b.NewValue0(v.Pos, OpMul64, t)
 34920			v2 := b.NewValue0(v.Pos, OpConst64, t)
 34921			v2.AuxInt = c
 34922			v1.AddArg(v2)
 34923			v1.AddArg(x)
 34924			v.AddArg(v1)
 34925			return true
 34926		}
 34927		// match: (Mul64 (Const64 [0]) _)
 34928		// cond:
 34929		// result: (Const64 [0])
 34930		for {
 34931			_ = v.Args[1]
 34932			v_0 := v.Args[0]
 34933			if v_0.Op != OpConst64 {
 34934				break
 34935			}
 34936			if v_0.AuxInt != 0 {
 34937				break
 34938			}
 34939			v.reset(OpConst64)
 34940			v.AuxInt = 0
 34941			return true
 34942		}
 34943		// match: (Mul64 _ (Const64 [0]))
 34944		// cond:
 34945		// result: (Const64 [0])
 34946		for {
 34947			_ = v.Args[1]
 34948			v_1 := v.Args[1]
 34949			if v_1.Op != OpConst64 {
 34950				break
 34951			}
 34952			if v_1.AuxInt != 0 {
 34953				break
 34954			}
 34955			v.reset(OpConst64)
 34956			v.AuxInt = 0
 34957			return true
 34958		}
 34959		// match: (Mul64 (Const64 <t> [c]) (Mul64 (Const64 <t> [d]) x))
 34960		// cond:
 34961		// result: (Mul64 (Const64 <t> [c*d]) x)
 34962		for {
 34963			_ = v.Args[1]
 34964			v_0 := v.Args[0]
 34965			if v_0.Op != OpConst64 {
 34966				break
 34967			}
 34968			t := v_0.Type
 34969			c := v_0.AuxInt
 34970			v_1 := v.Args[1]
 34971			if v_1.Op != OpMul64 {
 34972				break
 34973			}
 34974			x := v_1.Args[1]
 34975			v_1_0 := v_1.Args[0]
 34976			if v_1_0.Op != OpConst64 {
 34977				break
 34978			}
 34979			if v_1_0.Type != t {
 34980				break
 34981			}
 34982			d := v_1_0.AuxInt
 34983			v.reset(OpMul64)
 34984			v0 := b.NewValue0(v.Pos, OpConst64, t)
 34985			v0.AuxInt = c * d
 34986			v.AddArg(v0)
 34987			v.AddArg(x)
 34988			return true
 34989		}
 34990		// match: (Mul64 (Const64 <t> [c]) (Mul64 x (Const64 <t> [d])))
 34991		// cond:
 34992		// result: (Mul64 (Const64 <t> [c*d]) x)
 34993		for {
 34994			_ = v.Args[1]
 34995			v_0 := v.Args[0]
 34996			if v_0.Op != OpConst64 {
 34997				break
 34998			}
 34999			t := v_0.Type
 35000			c := v_0.AuxInt
 35001			v_1 := v.Args[1]
 35002			if v_1.Op != OpMul64 {
 35003				break
 35004			}
 35005			_ = v_1.Args[1]
 35006			x := v_1.Args[0]
 35007			v_1_1 := v_1.Args[1]
 35008			if v_1_1.Op != OpConst64 {
 35009				break
 35010			}
 35011			if v_1_1.Type != t {
 35012				break
 35013			}
 35014			d := v_1_1.AuxInt
 35015			v.reset(OpMul64)
 35016			v0 := b.NewValue0(v.Pos, OpConst64, t)
 35017			v0.AuxInt = c * d
 35018			v.AddArg(v0)
 35019			v.AddArg(x)
 35020			return true
 35021		}
 35022		// match: (Mul64 (Mul64 (Const64 <t> [d]) x) (Const64 <t> [c]))
 35023		// cond:
 35024		// result: (Mul64 (Const64 <t> [c*d]) x)
 35025		for {
 35026			_ = v.Args[1]
 35027			v_0 := v.Args[0]
 35028			if v_0.Op != OpMul64 {
 35029				break
 35030			}
 35031			x := v_0.Args[1]
 35032			v_0_0 := v_0.Args[0]
 35033			if v_0_0.Op != OpConst64 {
 35034				break
 35035			}
 35036			t := v_0_0.Type
 35037			d := v_0_0.AuxInt
 35038			v_1 := v.Args[1]
 35039			if v_1.Op != OpConst64 {
 35040				break
 35041			}
 35042			if v_1.Type != t {
 35043				break
 35044			}
 35045			c := v_1.AuxInt
 35046			v.reset(OpMul64)
 35047			v0 := b.NewValue0(v.Pos, OpConst64, t)
 35048			v0.AuxInt = c * d
 35049			v.AddArg(v0)
 35050			v.AddArg(x)
 35051			return true
 35052		}
 35053		// match: (Mul64 (Mul64 x (Const64 <t> [d])) (Const64 <t> [c]))
 35054		// cond:
 35055		// result: (Mul64 (Const64 <t> [c*d]) x)
 35056		for {
 35057			_ = v.Args[1]
 35058			v_0 := v.Args[0]
 35059			if v_0.Op != OpMul64 {
 35060				break
 35061			}
 35062			_ = v_0.Args[1]
 35063			x := v_0.Args[0]
 35064			v_0_1 := v_0.Args[1]
 35065			if v_0_1.Op != OpConst64 {
 35066				break
 35067			}
 35068			t := v_0_1.Type
 35069			d := v_0_1.AuxInt
 35070			v_1 := v.Args[1]
 35071			if v_1.Op != OpConst64 {
 35072				break
 35073			}
 35074			if v_1.Type != t {
 35075				break
 35076			}
 35077			c := v_1.AuxInt
 35078			v.reset(OpMul64)
 35079			v0 := b.NewValue0(v.Pos, OpConst64, t)
 35080			v0.AuxInt = c * d
 35081			v.AddArg(v0)
 35082			v.AddArg(x)
 35083			return true
 35084		}
 35085		return false
 35086	}
 35087	func rewriteValuegeneric_OpMul64F_0(v *Value) bool {
 35088		// match: (Mul64F (Const64F [c]) (Const64F [d]))
 35089		// cond:
 35090		// result: (Const64F [auxFrom64F(auxTo64F(c) * auxTo64F(d))])
 35091		for {
 35092			_ = v.Args[1]
 35093			v_0 := v.Args[0]
 35094			if v_0.Op != OpConst64F {
 35095				break
 35096			}
 35097			c := v_0.AuxInt
 35098			v_1 := v.Args[1]
 35099			if v_1.Op != OpConst64F {
 35100				break
 35101			}
 35102			d := v_1.AuxInt
 35103			v.reset(OpConst64F)
 35104			v.AuxInt = auxFrom64F(auxTo64F(c) * auxTo64F(d))
 35105			return true
 35106		}
 35107		// match: (Mul64F (Const64F [d]) (Const64F [c]))
 35108		// cond:
 35109		// result: (Const64F [auxFrom64F(auxTo64F(c) * auxTo64F(d))])
 35110		for {
 35111			_ = v.Args[1]
 35112			v_0 := v.Args[0]
 35113			if v_0.Op != OpConst64F {
 35114				break
 35115			}
 35116			d := v_0.AuxInt
 35117			v_1 := v.Args[1]
 35118			if v_1.Op != OpConst64F {
 35119				break
 35120			}
 35121			c := v_1.AuxInt
 35122			v.reset(OpConst64F)
 35123			v.AuxInt = auxFrom64F(auxTo64F(c) * auxTo64F(d))
 35124			return true
 35125		}
 35126		// match: (Mul64F x (Const64F [auxFrom64F(1)]))
 35127		// cond:
 35128		// result: x
 35129		for {
 35130			_ = v.Args[1]
 35131			x := v.Args[0]
 35132			v_1 := v.Args[1]
 35133			if v_1.Op != OpConst64F {
 35134				break
 35135			}
 35136			if v_1.AuxInt != auxFrom64F(1) {
 35137				break
 35138			}
 35139			v.reset(OpCopy)
 35140			v.Type = x.Type
 35141			v.AddArg(x)
 35142			return true
 35143		}
 35144		// match: (Mul64F (Const64F [auxFrom64F(1)]) x)
 35145		// cond:
 35146		// result: x
 35147		for {
 35148			x := v.Args[1]
 35149			v_0 := v.Args[0]
 35150			if v_0.Op != OpConst64F {
 35151				break
 35152			}
 35153			if v_0.AuxInt != auxFrom64F(1) {
 35154				break
 35155			}
 35156			v.reset(OpCopy)
 35157			v.Type = x.Type
 35158			v.AddArg(x)
 35159			return true
 35160		}
 35161		// match: (Mul64F x (Const64F [auxFrom64F(-1)]))
 35162		// cond:
 35163		// result: (Neg64F x)
 35164		for {
 35165			_ = v.Args[1]
 35166			x := v.Args[0]
 35167			v_1 := v.Args[1]
 35168			if v_1.Op != OpConst64F {
 35169				break
 35170			}
 35171			if v_1.AuxInt != auxFrom64F(-1) {
 35172				break
 35173			}
 35174			v.reset(OpNeg64F)
 35175			v.AddArg(x)
 35176			return true
 35177		}
 35178		// match: (Mul64F (Const64F [auxFrom64F(-1)]) x)
 35179		// cond:
 35180		// result: (Neg64F x)
 35181		for {
 35182			x := v.Args[1]
 35183			v_0 := v.Args[0]
 35184			if v_0.Op != OpConst64F {
 35185				break
 35186			}
 35187			if v_0.AuxInt != auxFrom64F(-1) {
 35188				break
 35189			}
 35190			v.reset(OpNeg64F)
 35191			v.AddArg(x)
 35192			return true
 35193		}
 35194		// match: (Mul64F x (Const64F [auxFrom64F(2)]))
 35195		// cond:
 35196		// result: (Add64F x x)
 35197		for {
 35198			_ = v.Args[1]
 35199			x := v.Args[0]
 35200			v_1 := v.Args[1]
 35201			if v_1.Op != OpConst64F {
 35202				break
 35203			}
 35204			if v_1.AuxInt != auxFrom64F(2) {
 35205				break
 35206			}
 35207			v.reset(OpAdd64F)
 35208			v.AddArg(x)
 35209			v.AddArg(x)
 35210			return true
 35211		}
 35212		// match: (Mul64F (Const64F [auxFrom64F(2)]) x)
 35213		// cond:
 35214		// result: (Add64F x x)
 35215		for {
 35216			x := v.Args[1]
 35217			v_0 := v.Args[0]
 35218			if v_0.Op != OpConst64F {
 35219				break
 35220			}
 35221			if v_0.AuxInt != auxFrom64F(2) {
 35222				break
 35223			}
 35224			v.reset(OpAdd64F)
 35225			v.AddArg(x)
 35226			v.AddArg(x)
 35227			return true
 35228		}
 35229		return false
 35230	}
 35231	func rewriteValuegeneric_OpMul8_0(v *Value) bool {
 35232		b := v.Block
 35233		typ := &b.Func.Config.Types
 35234		// match: (Mul8 (Const8 [c]) (Const8 [d]))
 35235		// cond:
 35236		// result: (Const8 [int64(int8(c*d))])
 35237		for {
 35238			_ = v.Args[1]
 35239			v_0 := v.Args[0]
 35240			if v_0.Op != OpConst8 {
 35241				break
 35242			}
 35243			c := v_0.AuxInt
 35244			v_1 := v.Args[1]
 35245			if v_1.Op != OpConst8 {
 35246				break
 35247			}
 35248			d := v_1.AuxInt
 35249			v.reset(OpConst8)
 35250			v.AuxInt = int64(int8(c * d))
 35251			return true
 35252		}
 35253		// match: (Mul8 (Const8 [d]) (Const8 [c]))
 35254		// cond:
 35255		// result: (Const8 [int64(int8(c*d))])
 35256		for {
 35257			_ = v.Args[1]
 35258			v_0 := v.Args[0]
 35259			if v_0.Op != OpConst8 {
 35260				break
 35261			}
 35262			d := v_0.AuxInt
 35263			v_1 := v.Args[1]
 35264			if v_1.Op != OpConst8 {
 35265				break
 35266			}
 35267			c := v_1.AuxInt
 35268			v.reset(OpConst8)
 35269			v.AuxInt = int64(int8(c * d))
 35270			return true
 35271		}
 35272		// match: (Mul8 (Const8 [1]) x)
 35273		// cond:
 35274		// result: x
 35275		for {
 35276			x := v.Args[1]
 35277			v_0 := v.Args[0]
 35278			if v_0.Op != OpConst8 {
 35279				break
 35280			}
 35281			if v_0.AuxInt != 1 {
 35282				break
 35283			}
 35284			v.reset(OpCopy)
 35285			v.Type = x.Type
 35286			v.AddArg(x)
 35287			return true
 35288		}
 35289		// match: (Mul8 x (Const8 [1]))
 35290		// cond:
 35291		// result: x
 35292		for {
 35293			_ = v.Args[1]
 35294			x := v.Args[0]
 35295			v_1 := v.Args[1]
 35296			if v_1.Op != OpConst8 {
 35297				break
 35298			}
 35299			if v_1.AuxInt != 1 {
 35300				break
 35301			}
 35302			v.reset(OpCopy)
 35303			v.Type = x.Type
 35304			v.AddArg(x)
 35305			return true
 35306		}
 35307		// match: (Mul8 (Const8 [-1]) x)
 35308		// cond:
 35309		// result: (Neg8 x)
 35310		for {
 35311			x := v.Args[1]
 35312			v_0 := v.Args[0]
 35313			if v_0.Op != OpConst8 {
 35314				break
 35315			}
 35316			if v_0.AuxInt != -1 {
 35317				break
 35318			}
 35319			v.reset(OpNeg8)
 35320			v.AddArg(x)
 35321			return true
 35322		}
 35323		// match: (Mul8 x (Const8 [-1]))
 35324		// cond:
 35325		// result: (Neg8 x)
 35326		for {
 35327			_ = v.Args[1]
 35328			x := v.Args[0]
 35329			v_1 := v.Args[1]
 35330			if v_1.Op != OpConst8 {
 35331				break
 35332			}
 35333			if v_1.AuxInt != -1 {
 35334				break
 35335			}
 35336			v.reset(OpNeg8)
 35337			v.AddArg(x)
 35338			return true
 35339		}
 35340		// match: (Mul8 <t> n (Const8 [c]))
 35341		// cond: isPowerOfTwo(c)
 35342		// result: (Lsh8x64 <t> n (Const64 <typ.UInt64> [log2(c)]))
 35343		for {
 35344			t := v.Type
 35345			_ = v.Args[1]
 35346			n := v.Args[0]
 35347			v_1 := v.Args[1]
 35348			if v_1.Op != OpConst8 {
 35349				break
 35350			}
 35351			c := v_1.AuxInt
 35352			if !(isPowerOfTwo(c)) {
 35353				break
 35354			}
 35355			v.reset(OpLsh8x64)
 35356			v.Type = t
 35357			v.AddArg(n)
 35358			v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 35359			v0.AuxInt = log2(c)
 35360			v.AddArg(v0)
 35361			return true
 35362		}
 35363		// match: (Mul8 <t> (Const8 [c]) n)
 35364		// cond: isPowerOfTwo(c)
 35365		// result: (Lsh8x64 <t> n (Const64 <typ.UInt64> [log2(c)]))
 35366		for {
 35367			t := v.Type
 35368			n := v.Args[1]
 35369			v_0 := v.Args[0]
 35370			if v_0.Op != OpConst8 {
 35371				break
 35372			}
 35373			c := v_0.AuxInt
 35374			if !(isPowerOfTwo(c)) {
 35375				break
 35376			}
 35377			v.reset(OpLsh8x64)
 35378			v.Type = t
 35379			v.AddArg(n)
 35380			v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 35381			v0.AuxInt = log2(c)
 35382			v.AddArg(v0)
 35383			return true
 35384		}
 35385		// match: (Mul8 <t> n (Const8 [c]))
 35386		// cond: t.IsSigned() && isPowerOfTwo(-c)
 35387		// result: (Neg8 (Lsh8x64 <t> n (Const64 <typ.UInt64> [log2(-c)])))
 35388		for {
 35389			t := v.Type
 35390			_ = v.Args[1]
 35391			n := v.Args[0]
 35392			v_1 := v.Args[1]
 35393			if v_1.Op != OpConst8 {
 35394				break
 35395			}
 35396			c := v_1.AuxInt
 35397			if !(t.IsSigned() && isPowerOfTwo(-c)) {
 35398				break
 35399			}
 35400			v.reset(OpNeg8)
 35401			v0 := b.NewValue0(v.Pos, OpLsh8x64, t)
 35402			v0.AddArg(n)
 35403			v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 35404			v1.AuxInt = log2(-c)
 35405			v0.AddArg(v1)
 35406			v.AddArg(v0)
 35407			return true
 35408		}
 35409		// match: (Mul8 <t> (Const8 [c]) n)
 35410		// cond: t.IsSigned() && isPowerOfTwo(-c)
 35411		// result: (Neg8 (Lsh8x64 <t> n (Const64 <typ.UInt64> [log2(-c)])))
 35412		for {
 35413			t := v.Type
 35414			n := v.Args[1]
 35415			v_0 := v.Args[0]
 35416			if v_0.Op != OpConst8 {
 35417				break
 35418			}
 35419			c := v_0.AuxInt
 35420			if !(t.IsSigned() && isPowerOfTwo(-c)) {
 35421				break
 35422			}
 35423			v.reset(OpNeg8)
 35424			v0 := b.NewValue0(v.Pos, OpLsh8x64, t)
 35425			v0.AddArg(n)
 35426			v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 35427			v1.AuxInt = log2(-c)
 35428			v0.AddArg(v1)
 35429			v.AddArg(v0)
 35430			return true
 35431		}
 35432		return false
 35433	}
 35434	func rewriteValuegeneric_OpMul8_10(v *Value) bool {
 35435		b := v.Block
 35436		// match: (Mul8 (Const8 [0]) _)
 35437		// cond:
 35438		// result: (Const8 [0])
 35439		for {
 35440			_ = v.Args[1]
 35441			v_0 := v.Args[0]
 35442			if v_0.Op != OpConst8 {
 35443				break
 35444			}
 35445			if v_0.AuxInt != 0 {
 35446				break
 35447			}
 35448			v.reset(OpConst8)
 35449			v.AuxInt = 0
 35450			return true
 35451		}
 35452		// match: (Mul8 _ (Const8 [0]))
 35453		// cond:
 35454		// result: (Const8 [0])
 35455		for {
 35456			_ = v.Args[1]
 35457			v_1 := v.Args[1]
 35458			if v_1.Op != OpConst8 {
 35459				break
 35460			}
 35461			if v_1.AuxInt != 0 {
 35462				break
 35463			}
 35464			v.reset(OpConst8)
 35465			v.AuxInt = 0
 35466			return true
 35467		}
 35468		// match: (Mul8 (Const8 <t> [c]) (Mul8 (Const8 <t> [d]) x))
 35469		// cond:
 35470		// result: (Mul8 (Const8 <t> [int64(int8(c*d))]) x)
 35471		for {
 35472			_ = v.Args[1]
 35473			v_0 := v.Args[0]
 35474			if v_0.Op != OpConst8 {
 35475				break
 35476			}
 35477			t := v_0.Type
 35478			c := v_0.AuxInt
 35479			v_1 := v.Args[1]
 35480			if v_1.Op != OpMul8 {
 35481				break
 35482			}
 35483			x := v_1.Args[1]
 35484			v_1_0 := v_1.Args[0]
 35485			if v_1_0.Op != OpConst8 {
 35486				break
 35487			}
 35488			if v_1_0.Type != t {
 35489				break
 35490			}
 35491			d := v_1_0.AuxInt
 35492			v.reset(OpMul8)
 35493			v0 := b.NewValue0(v.Pos, OpConst8, t)
 35494			v0.AuxInt = int64(int8(c * d))
 35495			v.AddArg(v0)
 35496			v.AddArg(x)
 35497			return true
 35498		}
 35499		// match: (Mul8 (Const8 <t> [c]) (Mul8 x (Const8 <t> [d])))
 35500		// cond:
 35501		// result: (Mul8 (Const8 <t> [int64(int8(c*d))]) x)
 35502		for {
 35503			_ = v.Args[1]
 35504			v_0 := v.Args[0]
 35505			if v_0.Op != OpConst8 {
 35506				break
 35507			}
 35508			t := v_0.Type
 35509			c := v_0.AuxInt
 35510			v_1 := v.Args[1]
 35511			if v_1.Op != OpMul8 {
 35512				break
 35513			}
 35514			_ = v_1.Args[1]
 35515			x := v_1.Args[0]
 35516			v_1_1 := v_1.Args[1]
 35517			if v_1_1.Op != OpConst8 {
 35518				break
 35519			}
 35520			if v_1_1.Type != t {
 35521				break
 35522			}
 35523			d := v_1_1.AuxInt
 35524			v.reset(OpMul8)
 35525			v0 := b.NewValue0(v.Pos, OpConst8, t)
 35526			v0.AuxInt = int64(int8(c * d))
 35527			v.AddArg(v0)
 35528			v.AddArg(x)
 35529			return true
 35530		}
 35531		// match: (Mul8 (Mul8 (Const8 <t> [d]) x) (Const8 <t> [c]))
 35532		// cond:
 35533		// result: (Mul8 (Const8 <t> [int64(int8(c*d))]) x)
 35534		for {
 35535			_ = v.Args[1]
 35536			v_0 := v.Args[0]
 35537			if v_0.Op != OpMul8 {
 35538				break
 35539			}
 35540			x := v_0.Args[1]
 35541			v_0_0 := v_0.Args[0]
 35542			if v_0_0.Op != OpConst8 {
 35543				break
 35544			}
 35545			t := v_0_0.Type
 35546			d := v_0_0.AuxInt
 35547			v_1 := v.Args[1]
 35548			if v_1.Op != OpConst8 {
 35549				break
 35550			}
 35551			if v_1.Type != t {
 35552				break
 35553			}
 35554			c := v_1.AuxInt
 35555			v.reset(OpMul8)
 35556			v0 := b.NewValue0(v.Pos, OpConst8, t)
 35557			v0.AuxInt = int64(int8(c * d))
 35558			v.AddArg(v0)
 35559			v.AddArg(x)
 35560			return true
 35561		}
 35562		// match: (Mul8 (Mul8 x (Const8 <t> [d])) (Const8 <t> [c]))
 35563		// cond:
 35564		// result: (Mul8 (Const8 <t> [int64(int8(c*d))]) x)
 35565		for {
 35566			_ = v.Args[1]
 35567			v_0 := v.Args[0]
 35568			if v_0.Op != OpMul8 {
 35569				break
 35570			}
 35571			_ = v_0.Args[1]
 35572			x := v_0.Args[0]
 35573			v_0_1 := v_0.Args[1]
 35574			if v_0_1.Op != OpConst8 {
 35575				break
 35576			}
 35577			t := v_0_1.Type
 35578			d := v_0_1.AuxInt
 35579			v_1 := v.Args[1]
 35580			if v_1.Op != OpConst8 {
 35581				break
 35582			}
 35583			if v_1.Type != t {
 35584				break
 35585			}
 35586			c := v_1.AuxInt
 35587			v.reset(OpMul8)
 35588			v0 := b.NewValue0(v.Pos, OpConst8, t)
 35589			v0.AuxInt = int64(int8(c * d))
 35590			v.AddArg(v0)
 35591			v.AddArg(x)
 35592			return true
 35593		}
 35594		return false
 35595	}
 35596	func rewriteValuegeneric_OpNeg16_0(v *Value) bool {
 35597		// match: (Neg16 (Const16 [c]))
 35598		// cond:
 35599		// result: (Const16 [int64(-int16(c))])
 35600		for {
 35601			v_0 := v.Args[0]
 35602			if v_0.Op != OpConst16 {
 35603				break
 35604			}
 35605			c := v_0.AuxInt
 35606			v.reset(OpConst16)
 35607			v.AuxInt = int64(-int16(c))
 35608			return true
 35609		}
 35610		// match: (Neg16 (Sub16 x y))
 35611		// cond:
 35612		// result: (Sub16 y x)
 35613		for {
 35614			v_0 := v.Args[0]
 35615			if v_0.Op != OpSub16 {
 35616				break
 35617			}
 35618			y := v_0.Args[1]
 35619			x := v_0.Args[0]
 35620			v.reset(OpSub16)
 35621			v.AddArg(y)
 35622			v.AddArg(x)
 35623			return true
 35624		}
 35625		return false
 35626	}
 35627	func rewriteValuegeneric_OpNeg32_0(v *Value) bool {
 35628		// match: (Neg32 (Const32 [c]))
 35629		// cond:
 35630		// result: (Const32 [int64(-int32(c))])
 35631		for {
 35632			v_0 := v.Args[0]
 35633			if v_0.Op != OpConst32 {
 35634				break
 35635			}
 35636			c := v_0.AuxInt
 35637			v.reset(OpConst32)
 35638			v.AuxInt = int64(-int32(c))
 35639			return true
 35640		}
 35641		// match: (Neg32 (Sub32 x y))
 35642		// cond:
 35643		// result: (Sub32 y x)
 35644		for {
 35645			v_0 := v.Args[0]
 35646			if v_0.Op != OpSub32 {
 35647				break
 35648			}
 35649			y := v_0.Args[1]
 35650			x := v_0.Args[0]
 35651			v.reset(OpSub32)
 35652			v.AddArg(y)
 35653			v.AddArg(x)
 35654			return true
 35655		}
 35656		return false
 35657	}
 35658	func rewriteValuegeneric_OpNeg32F_0(v *Value) bool {
 35659		// match: (Neg32F (Const32F [c]))
 35660		// cond: auxTo32F(c) != 0
 35661		// result: (Const32F [auxFrom32F(-auxTo32F(c))])
 35662		for {
 35663			v_0 := v.Args[0]
 35664			if v_0.Op != OpConst32F {
 35665				break
 35666			}
 35667			c := v_0.AuxInt
 35668			if !(auxTo32F(c) != 0) {
 35669				break
 35670			}
 35671			v.reset(OpConst32F)
 35672			v.AuxInt = auxFrom32F(-auxTo32F(c))
 35673			return true
 35674		}
 35675		return false
 35676	}
 35677	func rewriteValuegeneric_OpNeg64_0(v *Value) bool {
 35678		// match: (Neg64 (Const64 [c]))
 35679		// cond:
 35680		// result: (Const64 [-c])
 35681		for {
 35682			v_0 := v.Args[0]
 35683			if v_0.Op != OpConst64 {
 35684				break
 35685			}
 35686			c := v_0.AuxInt
 35687			v.reset(OpConst64)
 35688			v.AuxInt = -c
 35689			return true
 35690		}
 35691		// match: (Neg64 (Sub64 x y))
 35692		// cond:
 35693		// result: (Sub64 y x)
 35694		for {
 35695			v_0 := v.Args[0]
 35696			if v_0.Op != OpSub64 {
 35697				break
 35698			}
 35699			y := v_0.Args[1]
 35700			x := v_0.Args[0]
 35701			v.reset(OpSub64)
 35702			v.AddArg(y)
 35703			v.AddArg(x)
 35704			return true
 35705		}
 35706		return false
 35707	}
 35708	func rewriteValuegeneric_OpNeg64F_0(v *Value) bool {
 35709		// match: (Neg64F (Const64F [c]))
 35710		// cond: auxTo64F(c) != 0
 35711		// result: (Const64F [auxFrom64F(-auxTo64F(c))])
 35712		for {
 35713			v_0 := v.Args[0]
 35714			if v_0.Op != OpConst64F {
 35715				break
 35716			}
 35717			c := v_0.AuxInt
 35718			if !(auxTo64F(c) != 0) {
 35719				break
 35720			}
 35721			v.reset(OpConst64F)
 35722			v.AuxInt = auxFrom64F(-auxTo64F(c))
 35723			return true
 35724		}
 35725		return false
 35726	}
 35727	func rewriteValuegeneric_OpNeg8_0(v *Value) bool {
 35728		// match: (Neg8 (Const8 [c]))
 35729		// cond:
 35730		// result: (Const8 [int64( -int8(c))])
 35731		for {
 35732			v_0 := v.Args[0]
 35733			if v_0.Op != OpConst8 {
 35734				break
 35735			}
 35736			c := v_0.AuxInt
 35737			v.reset(OpConst8)
 35738			v.AuxInt = int64(-int8(c))
 35739			return true
 35740		}
 35741		// match: (Neg8 (Sub8 x y))
 35742		// cond:
 35743		// result: (Sub8 y x)
 35744		for {
 35745			v_0 := v.Args[0]
 35746			if v_0.Op != OpSub8 {
 35747				break
 35748			}
 35749			y := v_0.Args[1]
 35750			x := v_0.Args[0]
 35751			v.reset(OpSub8)
 35752			v.AddArg(y)
 35753			v.AddArg(x)
 35754			return true
 35755		}
 35756		return false
 35757	}
 35758	func rewriteValuegeneric_OpNeq16_0(v *Value) bool {
 35759		b := v.Block
 35760		// match: (Neq16 x x)
 35761		// cond:
 35762		// result: (ConstBool [0])
 35763		for {
 35764			x := v.Args[1]
 35765			if x != v.Args[0] {
 35766				break
 35767			}
 35768			v.reset(OpConstBool)
 35769			v.AuxInt = 0
 35770			return true
 35771		}
 35772		// match: (Neq16 (Const16 <t> [c]) (Add16 (Const16 <t> [d]) x))
 35773		// cond:
 35774		// result: (Neq16 (Const16 <t> [int64(int16(c-d))]) x)
 35775		for {
 35776			_ = v.Args[1]
 35777			v_0 := v.Args[0]
 35778			if v_0.Op != OpConst16 {
 35779				break
 35780			}
 35781			t := v_0.Type
 35782			c := v_0.AuxInt
 35783			v_1 := v.Args[1]
 35784			if v_1.Op != OpAdd16 {
 35785				break
 35786			}
 35787			x := v_1.Args[1]
 35788			v_1_0 := v_1.Args[0]
 35789			if v_1_0.Op != OpConst16 {
 35790				break
 35791			}
 35792			if v_1_0.Type != t {
 35793				break
 35794			}
 35795			d := v_1_0.AuxInt
 35796			v.reset(OpNeq16)
 35797			v0 := b.NewValue0(v.Pos, OpConst16, t)
 35798			v0.AuxInt = int64(int16(c - d))
 35799			v.AddArg(v0)
 35800			v.AddArg(x)
 35801			return true
 35802		}
 35803		// match: (Neq16 (Const16 <t> [c]) (Add16 x (Const16 <t> [d])))
 35804		// cond:
 35805		// result: (Neq16 (Const16 <t> [int64(int16(c-d))]) x)
 35806		for {
 35807			_ = v.Args[1]
 35808			v_0 := v.Args[0]
 35809			if v_0.Op != OpConst16 {
 35810				break
 35811			}
 35812			t := v_0.Type
 35813			c := v_0.AuxInt
 35814			v_1 := v.Args[1]
 35815			if v_1.Op != OpAdd16 {
 35816				break
 35817			}
 35818			_ = v_1.Args[1]
 35819			x := v_1.Args[0]
 35820			v_1_1 := v_1.Args[1]
 35821			if v_1_1.Op != OpConst16 {
 35822				break
 35823			}
 35824			if v_1_1.Type != t {
 35825				break
 35826			}
 35827			d := v_1_1.AuxInt
 35828			v.reset(OpNeq16)
 35829			v0 := b.NewValue0(v.Pos, OpConst16, t)
 35830			v0.AuxInt = int64(int16(c - d))
 35831			v.AddArg(v0)
 35832			v.AddArg(x)
 35833			return true
 35834		}
 35835		// match: (Neq16 (Add16 (Const16 <t> [d]) x) (Const16 <t> [c]))
 35836		// cond:
 35837		// result: (Neq16 (Const16 <t> [int64(int16(c-d))]) x)
 35838		for {
 35839			_ = v.Args[1]
 35840			v_0 := v.Args[0]
 35841			if v_0.Op != OpAdd16 {
 35842				break
 35843			}
 35844			x := v_0.Args[1]
 35845			v_0_0 := v_0.Args[0]
 35846			if v_0_0.Op != OpConst16 {
 35847				break
 35848			}
 35849			t := v_0_0.Type
 35850			d := v_0_0.AuxInt
 35851			v_1 := v.Args[1]
 35852			if v_1.Op != OpConst16 {
 35853				break
 35854			}
 35855			if v_1.Type != t {
 35856				break
 35857			}
 35858			c := v_1.AuxInt
 35859			v.reset(OpNeq16)
 35860			v0 := b.NewValue0(v.Pos, OpConst16, t)
 35861			v0.AuxInt = int64(int16(c - d))
 35862			v.AddArg(v0)
 35863			v.AddArg(x)
 35864			return true
 35865		}
 35866		// match: (Neq16 (Add16 x (Const16 <t> [d])) (Const16 <t> [c]))
 35867		// cond:
 35868		// result: (Neq16 (Const16 <t> [int64(int16(c-d))]) x)
 35869		for {
 35870			_ = v.Args[1]
 35871			v_0 := v.Args[0]
 35872			if v_0.Op != OpAdd16 {
 35873				break
 35874			}
 35875			_ = v_0.Args[1]
 35876			x := v_0.Args[0]
 35877			v_0_1 := v_0.Args[1]
 35878			if v_0_1.Op != OpConst16 {
 35879				break
 35880			}
 35881			t := v_0_1.Type
 35882			d := v_0_1.AuxInt
 35883			v_1 := v.Args[1]
 35884			if v_1.Op != OpConst16 {
 35885				break
 35886			}
 35887			if v_1.Type != t {
 35888				break
 35889			}
 35890			c := v_1.AuxInt
 35891			v.reset(OpNeq16)
 35892			v0 := b.NewValue0(v.Pos, OpConst16, t)
 35893			v0.AuxInt = int64(int16(c - d))
 35894			v.AddArg(v0)
 35895			v.AddArg(x)
 35896			return true
 35897		}
 35898		// match: (Neq16 (Const16 [c]) (Const16 [d]))
 35899		// cond:
 35900		// result: (ConstBool [b2i(c != d)])
 35901		for {
 35902			_ = v.Args[1]
 35903			v_0 := v.Args[0]
 35904			if v_0.Op != OpConst16 {
 35905				break
 35906			}
 35907			c := v_0.AuxInt
 35908			v_1 := v.Args[1]
 35909			if v_1.Op != OpConst16 {
 35910				break
 35911			}
 35912			d := v_1.AuxInt
 35913			v.reset(OpConstBool)
 35914			v.AuxInt = b2i(c != d)
 35915			return true
 35916		}
 35917		// match: (Neq16 (Const16 [d]) (Const16 [c]))
 35918		// cond:
 35919		// result: (ConstBool [b2i(c != d)])
 35920		for {
 35921			_ = v.Args[1]
 35922			v_0 := v.Args[0]
 35923			if v_0.Op != OpConst16 {
 35924				break
 35925			}
 35926			d := v_0.AuxInt
 35927			v_1 := v.Args[1]
 35928			if v_1.Op != OpConst16 {
 35929				break
 35930			}
 35931			c := v_1.AuxInt
 35932			v.reset(OpConstBool)
 35933			v.AuxInt = b2i(c != d)
 35934			return true
 35935		}
 35936		// match: (Neq16 s:(Sub16 x y) (Const16 [0]))
 35937		// cond: s.Uses == 1
 35938		// result: (Neq16 x y)
 35939		for {
 35940			_ = v.Args[1]
 35941			s := v.Args[0]
 35942			if s.Op != OpSub16 {
 35943				break
 35944			}
 35945			y := s.Args[1]
 35946			x := s.Args[0]
 35947			v_1 := v.Args[1]
 35948			if v_1.Op != OpConst16 {
 35949				break
 35950			}
 35951			if v_1.AuxInt != 0 {
 35952				break
 35953			}
 35954			if !(s.Uses == 1) {
 35955				break
 35956			}
 35957			v.reset(OpNeq16)
 35958			v.AddArg(x)
 35959			v.AddArg(y)
 35960			return true
 35961		}
 35962		// match: (Neq16 (Const16 [0]) s:(Sub16 x y))
 35963		// cond: s.Uses == 1
 35964		// result: (Neq16 x y)
 35965		for {
 35966			_ = v.Args[1]
 35967			v_0 := v.Args[0]
 35968			if v_0.Op != OpConst16 {
 35969				break
 35970			}
 35971			if v_0.AuxInt != 0 {
 35972				break
 35973			}
 35974			s := v.Args[1]
 35975			if s.Op != OpSub16 {
 35976				break
 35977			}
 35978			y := s.Args[1]
 35979			x := s.Args[0]
 35980			if !(s.Uses == 1) {
 35981				break
 35982			}
 35983			v.reset(OpNeq16)
 35984			v.AddArg(x)
 35985			v.AddArg(y)
 35986			return true
 35987		}
 35988		return false
 35989	}
 35990	func rewriteValuegeneric_OpNeq32_0(v *Value) bool {
 35991		b := v.Block
 35992		// match: (Neq32 x x)
 35993		// cond:
 35994		// result: (ConstBool [0])
 35995		for {
 35996			x := v.Args[1]
 35997			if x != v.Args[0] {
 35998				break
 35999			}
 36000			v.reset(OpConstBool)
 36001			v.AuxInt = 0
 36002			return true
 36003		}
 36004		// match: (Neq32 (Const32 <t> [c]) (Add32 (Const32 <t> [d]) x))
 36005		// cond:
 36006		// result: (Neq32 (Const32 <t> [int64(int32(c-d))]) x)
 36007		for {
 36008			_ = v.Args[1]
 36009			v_0 := v.Args[0]
 36010			if v_0.Op != OpConst32 {
 36011				break
 36012			}
 36013			t := v_0.Type
 36014			c := v_0.AuxInt
 36015			v_1 := v.Args[1]
 36016			if v_1.Op != OpAdd32 {
 36017				break
 36018			}
 36019			x := v_1.Args[1]
 36020			v_1_0 := v_1.Args[0]
 36021			if v_1_0.Op != OpConst32 {
 36022				break
 36023			}
 36024			if v_1_0.Type != t {
 36025				break
 36026			}
 36027			d := v_1_0.AuxInt
 36028			v.reset(OpNeq32)
 36029			v0 := b.NewValue0(v.Pos, OpConst32, t)
 36030			v0.AuxInt = int64(int32(c - d))
 36031			v.AddArg(v0)
 36032			v.AddArg(x)
 36033			return true
 36034		}
 36035		// match: (Neq32 (Const32 <t> [c]) (Add32 x (Const32 <t> [d])))
 36036		// cond:
 36037		// result: (Neq32 (Const32 <t> [int64(int32(c-d))]) x)
 36038		for {
 36039			_ = v.Args[1]
 36040			v_0 := v.Args[0]
 36041			if v_0.Op != OpConst32 {
 36042				break
 36043			}
 36044			t := v_0.Type
 36045			c := v_0.AuxInt
 36046			v_1 := v.Args[1]
 36047			if v_1.Op != OpAdd32 {
 36048				break
 36049			}
 36050			_ = v_1.Args[1]
 36051			x := v_1.Args[0]
 36052			v_1_1 := v_1.Args[1]
 36053			if v_1_1.Op != OpConst32 {
 36054				break
 36055			}
 36056			if v_1_1.Type != t {
 36057				break
 36058			}
 36059			d := v_1_1.AuxInt
 36060			v.reset(OpNeq32)
 36061			v0 := b.NewValue0(v.Pos, OpConst32, t)
 36062			v0.AuxInt = int64(int32(c - d))
 36063			v.AddArg(v0)
 36064			v.AddArg(x)
 36065			return true
 36066		}
 36067		// match: (Neq32 (Add32 (Const32 <t> [d]) x) (Const32 <t> [c]))
 36068		// cond:
 36069		// result: (Neq32 (Const32 <t> [int64(int32(c-d))]) x)
 36070		for {
 36071			_ = v.Args[1]
 36072			v_0 := v.Args[0]
 36073			if v_0.Op != OpAdd32 {
 36074				break
 36075			}
 36076			x := v_0.Args[1]
 36077			v_0_0 := v_0.Args[0]
 36078			if v_0_0.Op != OpConst32 {
 36079				break
 36080			}
 36081			t := v_0_0.Type
 36082			d := v_0_0.AuxInt
 36083			v_1 := v.Args[1]
 36084			if v_1.Op != OpConst32 {
 36085				break
 36086			}
 36087			if v_1.Type != t {
 36088				break
 36089			}
 36090			c := v_1.AuxInt
 36091			v.reset(OpNeq32)
 36092			v0 := b.NewValue0(v.Pos, OpConst32, t)
 36093			v0.AuxInt = int64(int32(c - d))
 36094			v.AddArg(v0)
 36095			v.AddArg(x)
 36096			return true
 36097		}
 36098		// match: (Neq32 (Add32 x (Const32 <t> [d])) (Const32 <t> [c]))
 36099		// cond:
 36100		// result: (Neq32 (Const32 <t> [int64(int32(c-d))]) x)
 36101		for {
 36102			_ = v.Args[1]
 36103			v_0 := v.Args[0]
 36104			if v_0.Op != OpAdd32 {
 36105				break
 36106			}
 36107			_ = v_0.Args[1]
 36108			x := v_0.Args[0]
 36109			v_0_1 := v_0.Args[1]
 36110			if v_0_1.Op != OpConst32 {
 36111				break
 36112			}
 36113			t := v_0_1.Type
 36114			d := v_0_1.AuxInt
 36115			v_1 := v.Args[1]
 36116			if v_1.Op != OpConst32 {
 36117				break
 36118			}
 36119			if v_1.Type != t {
 36120				break
 36121			}
 36122			c := v_1.AuxInt
 36123			v.reset(OpNeq32)
 36124			v0 := b.NewValue0(v.Pos, OpConst32, t)
 36125			v0.AuxInt = int64(int32(c - d))
 36126			v.AddArg(v0)
 36127			v.AddArg(x)
 36128			return true
 36129		}
 36130		// match: (Neq32 (Const32 [c]) (Const32 [d]))
 36131		// cond:
 36132		// result: (ConstBool [b2i(c != d)])
 36133		for {
 36134			_ = v.Args[1]
 36135			v_0 := v.Args[0]
 36136			if v_0.Op != OpConst32 {
 36137				break
 36138			}
 36139			c := v_0.AuxInt
 36140			v_1 := v.Args[1]
 36141			if v_1.Op != OpConst32 {
 36142				break
 36143			}
 36144			d := v_1.AuxInt
 36145			v.reset(OpConstBool)
 36146			v.AuxInt = b2i(c != d)
 36147			return true
 36148		}
 36149		// match: (Neq32 (Const32 [d]) (Const32 [c]))
 36150		// cond:
 36151		// result: (ConstBool [b2i(c != d)])
 36152		for {
 36153			_ = v.Args[1]
 36154			v_0 := v.Args[0]
 36155			if v_0.Op != OpConst32 {
 36156				break
 36157			}
 36158			d := v_0.AuxInt
 36159			v_1 := v.Args[1]
 36160			if v_1.Op != OpConst32 {
 36161				break
 36162			}
 36163			c := v_1.AuxInt
 36164			v.reset(OpConstBool)
 36165			v.AuxInt = b2i(c != d)
 36166			return true
 36167		}
 36168		// match: (Neq32 s:(Sub32 x y) (Const32 [0]))
 36169		// cond: s.Uses == 1
 36170		// result: (Neq32 x y)
 36171		for {
 36172			_ = v.Args[1]
 36173			s := v.Args[0]
 36174			if s.Op != OpSub32 {
 36175				break
 36176			}
 36177			y := s.Args[1]
 36178			x := s.Args[0]
 36179			v_1 := v.Args[1]
 36180			if v_1.Op != OpConst32 {
 36181				break
 36182			}
 36183			if v_1.AuxInt != 0 {
 36184				break
 36185			}
 36186			if !(s.Uses == 1) {
 36187				break
 36188			}
 36189			v.reset(OpNeq32)
 36190			v.AddArg(x)
 36191			v.AddArg(y)
 36192			return true
 36193		}
 36194		// match: (Neq32 (Const32 [0]) s:(Sub32 x y))
 36195		// cond: s.Uses == 1
 36196		// result: (Neq32 x y)
 36197		for {
 36198			_ = v.Args[1]
 36199			v_0 := v.Args[0]
 36200			if v_0.Op != OpConst32 {
 36201				break
 36202			}
 36203			if v_0.AuxInt != 0 {
 36204				break
 36205			}
 36206			s := v.Args[1]
 36207			if s.Op != OpSub32 {
 36208				break
 36209			}
 36210			y := s.Args[1]
 36211			x := s.Args[0]
 36212			if !(s.Uses == 1) {
 36213				break
 36214			}
 36215			v.reset(OpNeq32)
 36216			v.AddArg(x)
 36217			v.AddArg(y)
 36218			return true
 36219		}
 36220		return false
 36221	}
 36222	func rewriteValuegeneric_OpNeq32F_0(v *Value) bool {
 36223		// match: (Neq32F (Const32F [c]) (Const32F [d]))
 36224		// cond:
 36225		// result: (ConstBool [b2i(auxTo32F(c) != auxTo32F(d))])
 36226		for {
 36227			_ = v.Args[1]
 36228			v_0 := v.Args[0]
 36229			if v_0.Op != OpConst32F {
 36230				break
 36231			}
 36232			c := v_0.AuxInt
 36233			v_1 := v.Args[1]
 36234			if v_1.Op != OpConst32F {
 36235				break
 36236			}
 36237			d := v_1.AuxInt
 36238			v.reset(OpConstBool)
 36239			v.AuxInt = b2i(auxTo32F(c) != auxTo32F(d))
 36240			return true
 36241		}
 36242		// match: (Neq32F (Const32F [d]) (Const32F [c]))
 36243		// cond:
 36244		// result: (ConstBool [b2i(auxTo32F(c) != auxTo32F(d))])
 36245		for {
 36246			_ = v.Args[1]
 36247			v_0 := v.Args[0]
 36248			if v_0.Op != OpConst32F {
 36249				break
 36250			}
 36251			d := v_0.AuxInt
 36252			v_1 := v.Args[1]
 36253			if v_1.Op != OpConst32F {
 36254				break
 36255			}
 36256			c := v_1.AuxInt
 36257			v.reset(OpConstBool)
 36258			v.AuxInt = b2i(auxTo32F(c) != auxTo32F(d))
 36259			return true
 36260		}
 36261		return false
 36262	}
 36263	func rewriteValuegeneric_OpNeq64_0(v *Value) bool {
 36264		b := v.Block
 36265		// match: (Neq64 x x)
 36266		// cond:
 36267		// result: (ConstBool [0])
 36268		for {
 36269			x := v.Args[1]
 36270			if x != v.Args[0] {
 36271				break
 36272			}
 36273			v.reset(OpConstBool)
 36274			v.AuxInt = 0
 36275			return true
 36276		}
 36277		// match: (Neq64 (Const64 <t> [c]) (Add64 (Const64 <t> [d]) x))
 36278		// cond:
 36279		// result: (Neq64 (Const64 <t> [c-d]) x)
 36280		for {
 36281			_ = v.Args[1]
 36282			v_0 := v.Args[0]
 36283			if v_0.Op != OpConst64 {
 36284				break
 36285			}
 36286			t := v_0.Type
 36287			c := v_0.AuxInt
 36288			v_1 := v.Args[1]
 36289			if v_1.Op != OpAdd64 {
 36290				break
 36291			}
 36292			x := v_1.Args[1]
 36293			v_1_0 := v_1.Args[0]
 36294			if v_1_0.Op != OpConst64 {
 36295				break
 36296			}
 36297			if v_1_0.Type != t {
 36298				break
 36299			}
 36300			d := v_1_0.AuxInt
 36301			v.reset(OpNeq64)
 36302			v0 := b.NewValue0(v.Pos, OpConst64, t)
 36303			v0.AuxInt = c - d
 36304			v.AddArg(v0)
 36305			v.AddArg(x)
 36306			return true
 36307		}
 36308		// match: (Neq64 (Const64 <t> [c]) (Add64 x (Const64 <t> [d])))
 36309		// cond:
 36310		// result: (Neq64 (Const64 <t> [c-d]) x)
 36311		for {
 36312			_ = v.Args[1]
 36313			v_0 := v.Args[0]
 36314			if v_0.Op != OpConst64 {
 36315				break
 36316			}
 36317			t := v_0.Type
 36318			c := v_0.AuxInt
 36319			v_1 := v.Args[1]
 36320			if v_1.Op != OpAdd64 {
 36321				break
 36322			}
 36323			_ = v_1.Args[1]
 36324			x := v_1.Args[0]
 36325			v_1_1 := v_1.Args[1]
 36326			if v_1_1.Op != OpConst64 {
 36327				break
 36328			}
 36329			if v_1_1.Type != t {
 36330				break
 36331			}
 36332			d := v_1_1.AuxInt
 36333			v.reset(OpNeq64)
 36334			v0 := b.NewValue0(v.Pos, OpConst64, t)
 36335			v0.AuxInt = c - d
 36336			v.AddArg(v0)
 36337			v.AddArg(x)
 36338			return true
 36339		}
 36340		// match: (Neq64 (Add64 (Const64 <t> [d]) x) (Const64 <t> [c]))
 36341		// cond:
 36342		// result: (Neq64 (Const64 <t> [c-d]) x)
 36343		for {
 36344			_ = v.Args[1]
 36345			v_0 := v.Args[0]
 36346			if v_0.Op != OpAdd64 {
 36347				break
 36348			}
 36349			x := v_0.Args[1]
 36350			v_0_0 := v_0.Args[0]
 36351			if v_0_0.Op != OpConst64 {
 36352				break
 36353			}
 36354			t := v_0_0.Type
 36355			d := v_0_0.AuxInt
 36356			v_1 := v.Args[1]
 36357			if v_1.Op != OpConst64 {
 36358				break
 36359			}
 36360			if v_1.Type != t {
 36361				break
 36362			}
 36363			c := v_1.AuxInt
 36364			v.reset(OpNeq64)
 36365			v0 := b.NewValue0(v.Pos, OpConst64, t)
 36366			v0.AuxInt = c - d
 36367			v.AddArg(v0)
 36368			v.AddArg(x)
 36369			return true
 36370		}
 36371		// match: (Neq64 (Add64 x (Const64 <t> [d])) (Const64 <t> [c]))
 36372		// cond:
 36373		// result: (Neq64 (Const64 <t> [c-d]) x)
 36374		for {
 36375			_ = v.Args[1]
 36376			v_0 := v.Args[0]
 36377			if v_0.Op != OpAdd64 {
 36378				break
 36379			}
 36380			_ = v_0.Args[1]
 36381			x := v_0.Args[0]
 36382			v_0_1 := v_0.Args[1]
 36383			if v_0_1.Op != OpConst64 {
 36384				break
 36385			}
 36386			t := v_0_1.Type
 36387			d := v_0_1.AuxInt
 36388			v_1 := v.Args[1]
 36389			if v_1.Op != OpConst64 {
 36390				break
 36391			}
 36392			if v_1.Type != t {
 36393				break
 36394			}
 36395			c := v_1.AuxInt
 36396			v.reset(OpNeq64)
 36397			v0 := b.NewValue0(v.Pos, OpConst64, t)
 36398			v0.AuxInt = c - d
 36399			v.AddArg(v0)
 36400			v.AddArg(x)
 36401			return true
 36402		}
 36403		// match: (Neq64 (Const64 [c]) (Const64 [d]))
 36404		// cond:
 36405		// result: (ConstBool [b2i(c != d)])
 36406		for {
 36407			_ = v.Args[1]
 36408			v_0 := v.Args[0]
 36409			if v_0.Op != OpConst64 {
 36410				break
 36411			}
 36412			c := v_0.AuxInt
 36413			v_1 := v.Args[1]
 36414			if v_1.Op != OpConst64 {
 36415				break
 36416			}
 36417			d := v_1.AuxInt
 36418			v.reset(OpConstBool)
 36419			v.AuxInt = b2i(c != d)
 36420			return true
 36421		}
 36422		// match: (Neq64 (Const64 [d]) (Const64 [c]))
 36423		// cond:
 36424		// result: (ConstBool [b2i(c != d)])
 36425		for {
 36426			_ = v.Args[1]
 36427			v_0 := v.Args[0]
 36428			if v_0.Op != OpConst64 {
 36429				break
 36430			}
 36431			d := v_0.AuxInt
 36432			v_1 := v.Args[1]
 36433			if v_1.Op != OpConst64 {
 36434				break
 36435			}
 36436			c := v_1.AuxInt
 36437			v.reset(OpConstBool)
 36438			v.AuxInt = b2i(c != d)
 36439			return true
 36440		}
 36441		// match: (Neq64 s:(Sub64 x y) (Const64 [0]))
 36442		// cond: s.Uses == 1
 36443		// result: (Neq64 x y)
 36444		for {
 36445			_ = v.Args[1]
 36446			s := v.Args[0]
 36447			if s.Op != OpSub64 {
 36448				break
 36449			}
 36450			y := s.Args[1]
 36451			x := s.Args[0]
 36452			v_1 := v.Args[1]
 36453			if v_1.Op != OpConst64 {
 36454				break
 36455			}
 36456			if v_1.AuxInt != 0 {
 36457				break
 36458			}
 36459			if !(s.Uses == 1) {
 36460				break
 36461			}
 36462			v.reset(OpNeq64)
 36463			v.AddArg(x)
 36464			v.AddArg(y)
 36465			return true
 36466		}
 36467		// match: (Neq64 (Const64 [0]) s:(Sub64 x y))
 36468		// cond: s.Uses == 1
 36469		// result: (Neq64 x y)
 36470		for {
 36471			_ = v.Args[1]
 36472			v_0 := v.Args[0]
 36473			if v_0.Op != OpConst64 {
 36474				break
 36475			}
 36476			if v_0.AuxInt != 0 {
 36477				break
 36478			}
 36479			s := v.Args[1]
 36480			if s.Op != OpSub64 {
 36481				break
 36482			}
 36483			y := s.Args[1]
 36484			x := s.Args[0]
 36485			if !(s.Uses == 1) {
 36486				break
 36487			}
 36488			v.reset(OpNeq64)
 36489			v.AddArg(x)
 36490			v.AddArg(y)
 36491			return true
 36492		}
 36493		return false
 36494	}
 36495	func rewriteValuegeneric_OpNeq64F_0(v *Value) bool {
 36496		// match: (Neq64F (Const64F [c]) (Const64F [d]))
 36497		// cond:
 36498		// result: (ConstBool [b2i(auxTo64F(c) != auxTo64F(d))])
 36499		for {
 36500			_ = v.Args[1]
 36501			v_0 := v.Args[0]
 36502			if v_0.Op != OpConst64F {
 36503				break
 36504			}
 36505			c := v_0.AuxInt
 36506			v_1 := v.Args[1]
 36507			if v_1.Op != OpConst64F {
 36508				break
 36509			}
 36510			d := v_1.AuxInt
 36511			v.reset(OpConstBool)
 36512			v.AuxInt = b2i(auxTo64F(c) != auxTo64F(d))
 36513			return true
 36514		}
 36515		// match: (Neq64F (Const64F [d]) (Const64F [c]))
 36516		// cond:
 36517		// result: (ConstBool [b2i(auxTo64F(c) != auxTo64F(d))])
 36518		for {
 36519			_ = v.Args[1]
 36520			v_0 := v.Args[0]
 36521			if v_0.Op != OpConst64F {
 36522				break
 36523			}
 36524			d := v_0.AuxInt
 36525			v_1 := v.Args[1]
 36526			if v_1.Op != OpConst64F {
 36527				break
 36528			}
 36529			c := v_1.AuxInt
 36530			v.reset(OpConstBool)
 36531			v.AuxInt = b2i(auxTo64F(c) != auxTo64F(d))
 36532			return true
 36533		}
 36534		return false
 36535	}
 36536	func rewriteValuegeneric_OpNeq8_0(v *Value) bool {
 36537		b := v.Block
 36538		// match: (Neq8 x x)
 36539		// cond:
 36540		// result: (ConstBool [0])
 36541		for {
 36542			x := v.Args[1]
 36543			if x != v.Args[0] {
 36544				break
 36545			}
 36546			v.reset(OpConstBool)
 36547			v.AuxInt = 0
 36548			return true
 36549		}
 36550		// match: (Neq8 (Const8 <t> [c]) (Add8 (Const8 <t> [d]) x))
 36551		// cond:
 36552		// result: (Neq8 (Const8 <t> [int64(int8(c-d))]) x)
 36553		for {
 36554			_ = v.Args[1]
 36555			v_0 := v.Args[0]
 36556			if v_0.Op != OpConst8 {
 36557				break
 36558			}
 36559			t := v_0.Type
 36560			c := v_0.AuxInt
 36561			v_1 := v.Args[1]
 36562			if v_1.Op != OpAdd8 {
 36563				break
 36564			}
 36565			x := v_1.Args[1]
 36566			v_1_0 := v_1.Args[0]
 36567			if v_1_0.Op != OpConst8 {
 36568				break
 36569			}
 36570			if v_1_0.Type != t {
 36571				break
 36572			}
 36573			d := v_1_0.AuxInt
 36574			v.reset(OpNeq8)
 36575			v0 := b.NewValue0(v.Pos, OpConst8, t)
 36576			v0.AuxInt = int64(int8(c - d))
 36577			v.AddArg(v0)
 36578			v.AddArg(x)
 36579			return true
 36580		}
 36581		// match: (Neq8 (Const8 <t> [c]) (Add8 x (Const8 <t> [d])))
 36582		// cond:
 36583		// result: (Neq8 (Const8 <t> [int64(int8(c-d))]) x)
 36584		for {
 36585			_ = v.Args[1]
 36586			v_0 := v.Args[0]
 36587			if v_0.Op != OpConst8 {
 36588				break
 36589			}
 36590			t := v_0.Type
 36591			c := v_0.AuxInt
 36592			v_1 := v.Args[1]
 36593			if v_1.Op != OpAdd8 {
 36594				break
 36595			}
 36596			_ = v_1.Args[1]
 36597			x := v_1.Args[0]
 36598			v_1_1 := v_1.Args[1]
 36599			if v_1_1.Op != OpConst8 {
 36600				break
 36601			}
 36602			if v_1_1.Type != t {
 36603				break
 36604			}
 36605			d := v_1_1.AuxInt
 36606			v.reset(OpNeq8)
 36607			v0 := b.NewValue0(v.Pos, OpConst8, t)
 36608			v0.AuxInt = int64(int8(c - d))
 36609			v.AddArg(v0)
 36610			v.AddArg(x)
 36611			return true
 36612		}
 36613		// match: (Neq8 (Add8 (Const8 <t> [d]) x) (Const8 <t> [c]))
 36614		// cond:
 36615		// result: (Neq8 (Const8 <t> [int64(int8(c-d))]) x)
 36616		for {
 36617			_ = v.Args[1]
 36618			v_0 := v.Args[0]
 36619			if v_0.Op != OpAdd8 {
 36620				break
 36621			}
 36622			x := v_0.Args[1]
 36623			v_0_0 := v_0.Args[0]
 36624			if v_0_0.Op != OpConst8 {
 36625				break
 36626			}
 36627			t := v_0_0.Type
 36628			d := v_0_0.AuxInt
 36629			v_1 := v.Args[1]
 36630			if v_1.Op != OpConst8 {
 36631				break
 36632			}
 36633			if v_1.Type != t {
 36634				break
 36635			}
 36636			c := v_1.AuxInt
 36637			v.reset(OpNeq8)
 36638			v0 := b.NewValue0(v.Pos, OpConst8, t)
 36639			v0.AuxInt = int64(int8(c - d))
 36640			v.AddArg(v0)
 36641			v.AddArg(x)
 36642			return true
 36643		}
 36644		// match: (Neq8 (Add8 x (Const8 <t> [d])) (Const8 <t> [c]))
 36645		// cond:
 36646		// result: (Neq8 (Const8 <t> [int64(int8(c-d))]) x)
 36647		for {
 36648			_ = v.Args[1]
 36649			v_0 := v.Args[0]
 36650			if v_0.Op != OpAdd8 {
 36651				break
 36652			}
 36653			_ = v_0.Args[1]
 36654			x := v_0.Args[0]
 36655			v_0_1 := v_0.Args[1]
 36656			if v_0_1.Op != OpConst8 {
 36657				break
 36658			}
 36659			t := v_0_1.Type
 36660			d := v_0_1.AuxInt
 36661			v_1 := v.Args[1]
 36662			if v_1.Op != OpConst8 {
 36663				break
 36664			}
 36665			if v_1.Type != t {
 36666				break
 36667			}
 36668			c := v_1.AuxInt
 36669			v.reset(OpNeq8)
 36670			v0 := b.NewValue0(v.Pos, OpConst8, t)
 36671			v0.AuxInt = int64(int8(c - d))
 36672			v.AddArg(v0)
 36673			v.AddArg(x)
 36674			return true
 36675		}
 36676		// match: (Neq8 (Const8 [c]) (Const8 [d]))
 36677		// cond:
 36678		// result: (ConstBool [b2i(c != d)])
 36679		for {
 36680			_ = v.Args[1]
 36681			v_0 := v.Args[0]
 36682			if v_0.Op != OpConst8 {
 36683				break
 36684			}
 36685			c := v_0.AuxInt
 36686			v_1 := v.Args[1]
 36687			if v_1.Op != OpConst8 {
 36688				break
 36689			}
 36690			d := v_1.AuxInt
 36691			v.reset(OpConstBool)
 36692			v.AuxInt = b2i(c != d)
 36693			return true
 36694		}
 36695		// match: (Neq8 (Const8 [d]) (Const8 [c]))
 36696		// cond:
 36697		// result: (ConstBool [b2i(c != d)])
 36698		for {
 36699			_ = v.Args[1]
 36700			v_0 := v.Args[0]
 36701			if v_0.Op != OpConst8 {
 36702				break
 36703			}
 36704			d := v_0.AuxInt
 36705			v_1 := v.Args[1]
 36706			if v_1.Op != OpConst8 {
 36707				break
 36708			}
 36709			c := v_1.AuxInt
 36710			v.reset(OpConstBool)
 36711			v.AuxInt = b2i(c != d)
 36712			return true
 36713		}
 36714		// match: (Neq8 s:(Sub8 x y) (Const8 [0]))
 36715		// cond: s.Uses == 1
 36716		// result: (Neq8 x y)
 36717		for {
 36718			_ = v.Args[1]
 36719			s := v.Args[0]
 36720			if s.Op != OpSub8 {
 36721				break
 36722			}
 36723			y := s.Args[1]
 36724			x := s.Args[0]
 36725			v_1 := v.Args[1]
 36726			if v_1.Op != OpConst8 {
 36727				break
 36728			}
 36729			if v_1.AuxInt != 0 {
 36730				break
 36731			}
 36732			if !(s.Uses == 1) {
 36733				break
 36734			}
 36735			v.reset(OpNeq8)
 36736			v.AddArg(x)
 36737			v.AddArg(y)
 36738			return true
 36739		}
 36740		// match: (Neq8 (Const8 [0]) s:(Sub8 x y))
 36741		// cond: s.Uses == 1
 36742		// result: (Neq8 x y)
 36743		for {
 36744			_ = v.Args[1]
 36745			v_0 := v.Args[0]
 36746			if v_0.Op != OpConst8 {
 36747				break
 36748			}
 36749			if v_0.AuxInt != 0 {
 36750				break
 36751			}
 36752			s := v.Args[1]
 36753			if s.Op != OpSub8 {
 36754				break
 36755			}
 36756			y := s.Args[1]
 36757			x := s.Args[0]
 36758			if !(s.Uses == 1) {
 36759				break
 36760			}
 36761			v.reset(OpNeq8)
 36762			v.AddArg(x)
 36763			v.AddArg(y)
 36764			return true
 36765		}
 36766		return false
 36767	}
 36768	func rewriteValuegeneric_OpNeqB_0(v *Value) bool {
 36769		// match: (NeqB (ConstBool [c]) (ConstBool [d]))
 36770		// cond:
 36771		// result: (ConstBool [b2i(c != d)])
 36772		for {
 36773			_ = v.Args[1]
 36774			v_0 := v.Args[0]
 36775			if v_0.Op != OpConstBool {
 36776				break
 36777			}
 36778			c := v_0.AuxInt
 36779			v_1 := v.Args[1]
 36780			if v_1.Op != OpConstBool {
 36781				break
 36782			}
 36783			d := v_1.AuxInt
 36784			v.reset(OpConstBool)
 36785			v.AuxInt = b2i(c != d)
 36786			return true
 36787		}
 36788		// match: (NeqB (ConstBool [d]) (ConstBool [c]))
 36789		// cond:
 36790		// result: (ConstBool [b2i(c != d)])
 36791		for {
 36792			_ = v.Args[1]
 36793			v_0 := v.Args[0]
 36794			if v_0.Op != OpConstBool {
 36795				break
 36796			}
 36797			d := v_0.AuxInt
 36798			v_1 := v.Args[1]
 36799			if v_1.Op != OpConstBool {
 36800				break
 36801			}
 36802			c := v_1.AuxInt
 36803			v.reset(OpConstBool)
 36804			v.AuxInt = b2i(c != d)
 36805			return true
 36806		}
 36807		// match: (NeqB (ConstBool [0]) x)
 36808		// cond:
 36809		// result: x
 36810		for {
 36811			x := v.Args[1]
 36812			v_0 := v.Args[0]
 36813			if v_0.Op != OpConstBool {
 36814				break
 36815			}
 36816			if v_0.AuxInt != 0 {
 36817				break
 36818			}
 36819			v.reset(OpCopy)
 36820			v.Type = x.Type
 36821			v.AddArg(x)
 36822			return true
 36823		}
 36824		// match: (NeqB x (ConstBool [0]))
 36825		// cond:
 36826		// result: x
 36827		for {
 36828			_ = v.Args[1]
 36829			x := v.Args[0]
 36830			v_1 := v.Args[1]
 36831			if v_1.Op != OpConstBool {
 36832				break
 36833			}
 36834			if v_1.AuxInt != 0 {
 36835				break
 36836			}
 36837			v.reset(OpCopy)
 36838			v.Type = x.Type
 36839			v.AddArg(x)
 36840			return true
 36841		}
 36842		// match: (NeqB (ConstBool [1]) x)
 36843		// cond:
 36844		// result: (Not x)
 36845		for {
 36846			x := v.Args[1]
 36847			v_0 := v.Args[0]
 36848			if v_0.Op != OpConstBool {
 36849				break
 36850			}
 36851			if v_0.AuxInt != 1 {
 36852				break
 36853			}
 36854			v.reset(OpNot)
 36855			v.AddArg(x)
 36856			return true
 36857		}
 36858		// match: (NeqB x (ConstBool [1]))
 36859		// cond:
 36860		// result: (Not x)
 36861		for {
 36862			_ = v.Args[1]
 36863			x := v.Args[0]
 36864			v_1 := v.Args[1]
 36865			if v_1.Op != OpConstBool {
 36866				break
 36867			}
 36868			if v_1.AuxInt != 1 {
 36869				break
 36870			}
 36871			v.reset(OpNot)
 36872			v.AddArg(x)
 36873			return true
 36874		}
 36875		// match: (NeqB (Not x) (Not y))
 36876		// cond:
 36877		// result: (NeqB x y)
 36878		for {
 36879			_ = v.Args[1]
 36880			v_0 := v.Args[0]
 36881			if v_0.Op != OpNot {
 36882				break
 36883			}
 36884			x := v_0.Args[0]
 36885			v_1 := v.Args[1]
 36886			if v_1.Op != OpNot {
 36887				break
 36888			}
 36889			y := v_1.Args[0]
 36890			v.reset(OpNeqB)
 36891			v.AddArg(x)
 36892			v.AddArg(y)
 36893			return true
 36894		}
 36895		// match: (NeqB (Not y) (Not x))
 36896		// cond:
 36897		// result: (NeqB x y)
 36898		for {
 36899			_ = v.Args[1]
 36900			v_0 := v.Args[0]
 36901			if v_0.Op != OpNot {
 36902				break
 36903			}
 36904			y := v_0.Args[0]
 36905			v_1 := v.Args[1]
 36906			if v_1.Op != OpNot {
 36907				break
 36908			}
 36909			x := v_1.Args[0]
 36910			v.reset(OpNeqB)
 36911			v.AddArg(x)
 36912			v.AddArg(y)
 36913			return true
 36914		}
 36915		return false
 36916	}
 36917	func rewriteValuegeneric_OpNeqInter_0(v *Value) bool {
 36918		b := v.Block
 36919		typ := &b.Func.Config.Types
 36920		// match: (NeqInter x y)
 36921		// cond:
 36922		// result: (NeqPtr (ITab x) (ITab y))
 36923		for {
 36924			y := v.Args[1]
 36925			x := v.Args[0]
 36926			v.reset(OpNeqPtr)
 36927			v0 := b.NewValue0(v.Pos, OpITab, typ.Uintptr)
 36928			v0.AddArg(x)
 36929			v.AddArg(v0)
 36930			v1 := b.NewValue0(v.Pos, OpITab, typ.Uintptr)
 36931			v1.AddArg(y)
 36932			v.AddArg(v1)
 36933			return true
 36934		}
 36935	}
 36936	func rewriteValuegeneric_OpNeqPtr_0(v *Value) bool {
 36937		// match: (NeqPtr x x)
 36938		// cond:
 36939		// result: (ConstBool [0])
 36940		for {
 36941			x := v.Args[1]
 36942			if x != v.Args[0] {
 36943				break
 36944			}
 36945			v.reset(OpConstBool)
 36946			v.AuxInt = 0
 36947			return true
 36948		}
 36949		// match: (NeqPtr (Addr {a} _) (Addr {b} _))
 36950		// cond:
 36951		// result: (ConstBool [b2i(a != b)])
 36952		for {
 36953			_ = v.Args[1]
 36954			v_0 := v.Args[0]
 36955			if v_0.Op != OpAddr {
 36956				break
 36957			}
 36958			a := v_0.Aux
 36959			v_1 := v.Args[1]
 36960			if v_1.Op != OpAddr {
 36961				break
 36962			}
 36963			b := v_1.Aux
 36964			v.reset(OpConstBool)
 36965			v.AuxInt = b2i(a != b)
 36966			return true
 36967		}
 36968		// match: (NeqPtr (Addr {b} _) (Addr {a} _))
 36969		// cond:
 36970		// result: (ConstBool [b2i(a != b)])
 36971		for {
 36972			_ = v.Args[1]
 36973			v_0 := v.Args[0]
 36974			if v_0.Op != OpAddr {
 36975				break
 36976			}
 36977			b := v_0.Aux
 36978			v_1 := v.Args[1]
 36979			if v_1.Op != OpAddr {
 36980				break
 36981			}
 36982			a := v_1.Aux
 36983			v.reset(OpConstBool)
 36984			v.AuxInt = b2i(a != b)
 36985			return true
 36986		}
 36987		// match: (NeqPtr (LocalAddr {a} _ _) (LocalAddr {b} _ _))
 36988		// cond:
 36989		// result: (ConstBool [b2i(a != b)])
 36990		for {
 36991			_ = v.Args[1]
 36992			v_0 := v.Args[0]
 36993			if v_0.Op != OpLocalAddr {
 36994				break
 36995			}
 36996			a := v_0.Aux
 36997			_ = v_0.Args[1]
 36998			v_1 := v.Args[1]
 36999			if v_1.Op != OpLocalAddr {
 37000				break
 37001			}
 37002			b := v_1.Aux
 37003			_ = v_1.Args[1]
 37004			v.reset(OpConstBool)
 37005			v.AuxInt = b2i(a != b)
 37006			return true
 37007		}
 37008		// match: (NeqPtr (LocalAddr {b} _ _) (LocalAddr {a} _ _))
 37009		// cond:
 37010		// result: (ConstBool [b2i(a != b)])
 37011		for {
 37012			_ = v.Args[1]
 37013			v_0 := v.Args[0]
 37014			if v_0.Op != OpLocalAddr {
 37015				break
 37016			}
 37017			b := v_0.Aux
 37018			_ = v_0.Args[1]
 37019			v_1 := v.Args[1]
 37020			if v_1.Op != OpLocalAddr {
 37021				break
 37022			}
 37023			a := v_1.Aux
 37024			_ = v_1.Args[1]
 37025			v.reset(OpConstBool)
 37026			v.AuxInt = b2i(a != b)
 37027			return true
 37028		}
 37029		// match: (NeqPtr (OffPtr [o1] p1) p2)
 37030		// cond: isSamePtr(p1, p2)
 37031		// result: (ConstBool [b2i(o1 != 0)])
 37032		for {
 37033			p2 := v.Args[1]
 37034			v_0 := v.Args[0]
 37035			if v_0.Op != OpOffPtr {
 37036				break
 37037			}
 37038			o1 := v_0.AuxInt
 37039			p1 := v_0.Args[0]
 37040			if !(isSamePtr(p1, p2)) {
 37041				break
 37042			}
 37043			v.reset(OpConstBool)
 37044			v.AuxInt = b2i(o1 != 0)
 37045			return true
 37046		}
 37047		// match: (NeqPtr p2 (OffPtr [o1] p1))
 37048		// cond: isSamePtr(p1, p2)
 37049		// result: (ConstBool [b2i(o1 != 0)])
 37050		for {
 37051			_ = v.Args[1]
 37052			p2 := v.Args[0]
 37053			v_1 := v.Args[1]
 37054			if v_1.Op != OpOffPtr {
 37055				break
 37056			}
 37057			o1 := v_1.AuxInt
 37058			p1 := v_1.Args[0]
 37059			if !(isSamePtr(p1, p2)) {
 37060				break
 37061			}
 37062			v.reset(OpConstBool)
 37063			v.AuxInt = b2i(o1 != 0)
 37064			return true
 37065		}
 37066		// match: (NeqPtr (OffPtr [o1] p1) (OffPtr [o2] p2))
 37067		// cond: isSamePtr(p1, p2)
 37068		// result: (ConstBool [b2i(o1 != o2)])
 37069		for {
 37070			_ = v.Args[1]
 37071			v_0 := v.Args[0]
 37072			if v_0.Op != OpOffPtr {
 37073				break
 37074			}
 37075			o1 := v_0.AuxInt
 37076			p1 := v_0.Args[0]
 37077			v_1 := v.Args[1]
 37078			if v_1.Op != OpOffPtr {
 37079				break
 37080			}
 37081			o2 := v_1.AuxInt
 37082			p2 := v_1.Args[0]
 37083			if !(isSamePtr(p1, p2)) {
 37084				break
 37085			}
 37086			v.reset(OpConstBool)
 37087			v.AuxInt = b2i(o1 != o2)
 37088			return true
 37089		}
 37090		// match: (NeqPtr (OffPtr [o2] p2) (OffPtr [o1] p1))
 37091		// cond: isSamePtr(p1, p2)
 37092		// result: (ConstBool [b2i(o1 != o2)])
 37093		for {
 37094			_ = v.Args[1]
 37095			v_0 := v.Args[0]
 37096			if v_0.Op != OpOffPtr {
 37097				break
 37098			}
 37099			o2 := v_0.AuxInt
 37100			p2 := v_0.Args[0]
 37101			v_1 := v.Args[1]
 37102			if v_1.Op != OpOffPtr {
 37103				break
 37104			}
 37105			o1 := v_1.AuxInt
 37106			p1 := v_1.Args[0]
 37107			if !(isSamePtr(p1, p2)) {
 37108				break
 37109			}
 37110			v.reset(OpConstBool)
 37111			v.AuxInt = b2i(o1 != o2)
 37112			return true
 37113		}
 37114		// match: (NeqPtr (Const32 [c]) (Const32 [d]))
 37115		// cond:
 37116		// result: (ConstBool [b2i(c != d)])
 37117		for {
 37118			_ = v.Args[1]
 37119			v_0 := v.Args[0]
 37120			if v_0.Op != OpConst32 {
 37121				break
 37122			}
 37123			c := v_0.AuxInt
 37124			v_1 := v.Args[1]
 37125			if v_1.Op != OpConst32 {
 37126				break
 37127			}
 37128			d := v_1.AuxInt
 37129			v.reset(OpConstBool)
 37130			v.AuxInt = b2i(c != d)
 37131			return true
 37132		}
 37133		return false
 37134	}
 37135	func rewriteValuegeneric_OpNeqPtr_10(v *Value) bool {
 37136		// match: (NeqPtr (Const32 [d]) (Const32 [c]))
 37137		// cond:
 37138		// result: (ConstBool [b2i(c != d)])
 37139		for {
 37140			_ = v.Args[1]
 37141			v_0 := v.Args[0]
 37142			if v_0.Op != OpConst32 {
 37143				break
 37144			}
 37145			d := v_0.AuxInt
 37146			v_1 := v.Args[1]
 37147			if v_1.Op != OpConst32 {
 37148				break
 37149			}
 37150			c := v_1.AuxInt
 37151			v.reset(OpConstBool)
 37152			v.AuxInt = b2i(c != d)
 37153			return true
 37154		}
 37155		// match: (NeqPtr (Const64 [c]) (Const64 [d]))
 37156		// cond:
 37157		// result: (ConstBool [b2i(c != d)])
 37158		for {
 37159			_ = v.Args[1]
 37160			v_0 := v.Args[0]
 37161			if v_0.Op != OpConst64 {
 37162				break
 37163			}
 37164			c := v_0.AuxInt
 37165			v_1 := v.Args[1]
 37166			if v_1.Op != OpConst64 {
 37167				break
 37168			}
 37169			d := v_1.AuxInt
 37170			v.reset(OpConstBool)
 37171			v.AuxInt = b2i(c != d)
 37172			return true
 37173		}
 37174		// match: (NeqPtr (Const64 [d]) (Const64 [c]))
 37175		// cond:
 37176		// result: (ConstBool [b2i(c != d)])
 37177		for {
 37178			_ = v.Args[1]
 37179			v_0 := v.Args[0]
 37180			if v_0.Op != OpConst64 {
 37181				break
 37182			}
 37183			d := v_0.AuxInt
 37184			v_1 := v.Args[1]
 37185			if v_1.Op != OpConst64 {
 37186				break
 37187			}
 37188			c := v_1.AuxInt
 37189			v.reset(OpConstBool)
 37190			v.AuxInt = b2i(c != d)
 37191			return true
 37192		}
 37193		// match: (NeqPtr (LocalAddr _ _) (Addr _))
 37194		// cond:
 37195		// result: (ConstBool [1])
 37196		for {
 37197			_ = v.Args[1]
 37198			v_0 := v.Args[0]
 37199			if v_0.Op != OpLocalAddr {
 37200				break
 37201			}
 37202			_ = v_0.Args[1]
 37203			v_1 := v.Args[1]
 37204			if v_1.Op != OpAddr {
 37205				break
 37206			}
 37207			v.reset(OpConstBool)
 37208			v.AuxInt = 1
 37209			return true
 37210		}
 37211		// match: (NeqPtr (Addr _) (LocalAddr _ _))
 37212		// cond:
 37213		// result: (ConstBool [1])
 37214		for {
 37215			_ = v.Args[1]
 37216			v_0 := v.Args[0]
 37217			if v_0.Op != OpAddr {
 37218				break
 37219			}
 37220			v_1 := v.Args[1]
 37221			if v_1.Op != OpLocalAddr {
 37222				break
 37223			}
 37224			_ = v_1.Args[1]
 37225			v.reset(OpConstBool)
 37226			v.AuxInt = 1
 37227			return true
 37228		}
 37229		// match: (NeqPtr (Addr _) (LocalAddr _ _))
 37230		// cond:
 37231		// result: (ConstBool [1])
 37232		for {
 37233			_ = v.Args[1]
 37234			v_0 := v.Args[0]
 37235			if v_0.Op != OpAddr {
 37236				break
 37237			}
 37238			v_1 := v.Args[1]
 37239			if v_1.Op != OpLocalAddr {
 37240				break
 37241			}
 37242			_ = v_1.Args[1]
 37243			v.reset(OpConstBool)
 37244			v.AuxInt = 1
 37245			return true
 37246		}
 37247		// match: (NeqPtr (LocalAddr _ _) (Addr _))
 37248		// cond:
 37249		// result: (ConstBool [1])
 37250		for {
 37251			_ = v.Args[1]
 37252			v_0 := v.Args[0]
 37253			if v_0.Op != OpLocalAddr {
 37254				break
 37255			}
 37256			_ = v_0.Args[1]
 37257			v_1 := v.Args[1]
 37258			if v_1.Op != OpAddr {
 37259				break
 37260			}
 37261			v.reset(OpConstBool)
 37262			v.AuxInt = 1
 37263			return true
 37264		}
 37265		// match: (NeqPtr (AddPtr p1 o1) p2)
 37266		// cond: isSamePtr(p1, p2)
 37267		// result: (IsNonNil o1)
 37268		for {
 37269			p2 := v.Args[1]
 37270			v_0 := v.Args[0]
 37271			if v_0.Op != OpAddPtr {
 37272				break
 37273			}
 37274			o1 := v_0.Args[1]
 37275			p1 := v_0.Args[0]
 37276			if !(isSamePtr(p1, p2)) {
 37277				break
 37278			}
 37279			v.reset(OpIsNonNil)
 37280			v.AddArg(o1)
 37281			return true
 37282		}
 37283		// match: (NeqPtr p2 (AddPtr p1 o1))
 37284		// cond: isSamePtr(p1, p2)
 37285		// result: (IsNonNil o1)
 37286		for {
 37287			_ = v.Args[1]
 37288			p2 := v.Args[0]
 37289			v_1 := v.Args[1]
 37290			if v_1.Op != OpAddPtr {
 37291				break
 37292			}
 37293			o1 := v_1.Args[1]
 37294			p1 := v_1.Args[0]
 37295			if !(isSamePtr(p1, p2)) {
 37296				break
 37297			}
 37298			v.reset(OpIsNonNil)
 37299			v.AddArg(o1)
 37300			return true
 37301		}
 37302		// match: (NeqPtr (Const32 [0]) p)
 37303		// cond:
 37304		// result: (IsNonNil p)
 37305		for {
 37306			p := v.Args[1]
 37307			v_0 := v.Args[0]
 37308			if v_0.Op != OpConst32 {
 37309				break
 37310			}
 37311			if v_0.AuxInt != 0 {
 37312				break
 37313			}
 37314			v.reset(OpIsNonNil)
 37315			v.AddArg(p)
 37316			return true
 37317		}
 37318		return false
 37319	}
 37320	func rewriteValuegeneric_OpNeqPtr_20(v *Value) bool {
 37321		// match: (NeqPtr p (Const32 [0]))
 37322		// cond:
 37323		// result: (IsNonNil p)
 37324		for {
 37325			_ = v.Args[1]
 37326			p := v.Args[0]
 37327			v_1 := v.Args[1]
 37328			if v_1.Op != OpConst32 {
 37329				break
 37330			}
 37331			if v_1.AuxInt != 0 {
 37332				break
 37333			}
 37334			v.reset(OpIsNonNil)
 37335			v.AddArg(p)
 37336			return true
 37337		}
 37338		// match: (NeqPtr (Const64 [0]) p)
 37339		// cond:
 37340		// result: (IsNonNil p)
 37341		for {
 37342			p := v.Args[1]
 37343			v_0 := v.Args[0]
 37344			if v_0.Op != OpConst64 {
 37345				break
 37346			}
 37347			if v_0.AuxInt != 0 {
 37348				break
 37349			}
 37350			v.reset(OpIsNonNil)
 37351			v.AddArg(p)
 37352			return true
 37353		}
 37354		// match: (NeqPtr p (Const64 [0]))
 37355		// cond:
 37356		// result: (IsNonNil p)
 37357		for {
 37358			_ = v.Args[1]
 37359			p := v.Args[0]
 37360			v_1 := v.Args[1]
 37361			if v_1.Op != OpConst64 {
 37362				break
 37363			}
 37364			if v_1.AuxInt != 0 {
 37365				break
 37366			}
 37367			v.reset(OpIsNonNil)
 37368			v.AddArg(p)
 37369			return true
 37370		}
 37371		// match: (NeqPtr (ConstNil) p)
 37372		// cond:
 37373		// result: (IsNonNil p)
 37374		for {
 37375			p := v.Args[1]
 37376			v_0 := v.Args[0]
 37377			if v_0.Op != OpConstNil {
 37378				break
 37379			}
 37380			v.reset(OpIsNonNil)
 37381			v.AddArg(p)
 37382			return true
 37383		}
 37384		// match: (NeqPtr p (ConstNil))
 37385		// cond:
 37386		// result: (IsNonNil p)
 37387		for {
 37388			_ = v.Args[1]
 37389			p := v.Args[0]
 37390			v_1 := v.Args[1]
 37391			if v_1.Op != OpConstNil {
 37392				break
 37393			}
 37394			v.reset(OpIsNonNil)
 37395			v.AddArg(p)
 37396			return true
 37397		}
 37398		return false
 37399	}
 37400	func rewriteValuegeneric_OpNeqSlice_0(v *Value) bool {
 37401		b := v.Block
 37402		typ := &b.Func.Config.Types
 37403		// match: (NeqSlice x y)
 37404		// cond:
 37405		// result: (NeqPtr (SlicePtr x) (SlicePtr y))
 37406		for {
 37407			y := v.Args[1]
 37408			x := v.Args[0]
 37409			v.reset(OpNeqPtr)
 37410			v0 := b.NewValue0(v.Pos, OpSlicePtr, typ.BytePtr)
 37411			v0.AddArg(x)
 37412			v.AddArg(v0)
 37413			v1 := b.NewValue0(v.Pos, OpSlicePtr, typ.BytePtr)
 37414			v1.AddArg(y)
 37415			v.AddArg(v1)
 37416			return true
 37417		}
 37418	}
 37419	func rewriteValuegeneric_OpNilCheck_0(v *Value) bool {
 37420		b := v.Block
 37421		config := b.Func.Config
 37422		fe := b.Func.fe
 37423		// match: (NilCheck (GetG mem) mem)
 37424		// cond:
 37425		// result: mem
 37426		for {
 37427			mem := v.Args[1]
 37428			v_0 := v.Args[0]
 37429			if v_0.Op != OpGetG {
 37430				break
 37431			}
 37432			if mem != v_0.Args[0] {
 37433				break
 37434			}
 37435			v.reset(OpCopy)
 37436			v.Type = mem.Type
 37437			v.AddArg(mem)
 37438			return true
 37439		}
 37440		// match: (NilCheck (Load (OffPtr [c] (SP)) (StaticCall {sym} _)) _)
 37441		// cond: isSameSym(sym, "runtime.newobject") && c == config.ctxt.FixedFrameSize() + config.RegSize && warnRule(fe.Debug_checknil(), v, "removed nil check")
 37442		// result: (Invalid)
 37443		for {
 37444			_ = v.Args[1]
 37445			v_0 := v.Args[0]
 37446			if v_0.Op != OpLoad {
 37447				break
 37448			}
 37449			_ = v_0.Args[1]
 37450			v_0_0 := v_0.Args[0]
 37451			if v_0_0.Op != OpOffPtr {
 37452				break
 37453			}
 37454			c := v_0_0.AuxInt
 37455			v_0_0_0 := v_0_0.Args[0]
 37456			if v_0_0_0.Op != OpSP {
 37457				break
 37458			}
 37459			v_0_1 := v_0.Args[1]
 37460			if v_0_1.Op != OpStaticCall {
 37461				break
 37462			}
 37463			sym := v_0_1.Aux
 37464			if !(isSameSym(sym, "runtime.newobject") && c == config.ctxt.FixedFrameSize()+config.RegSize && warnRule(fe.Debug_checknil(), v, "removed nil check")) {
 37465				break
 37466			}
 37467			v.reset(OpInvalid)
 37468			return true
 37469		}
 37470		// match: (NilCheck (OffPtr (Load (OffPtr [c] (SP)) (StaticCall {sym} _))) _)
 37471		// cond: isSameSym(sym, "runtime.newobject") && c == config.ctxt.FixedFrameSize() + config.RegSize && warnRule(fe.Debug_checknil(), v, "removed nil check")
 37472		// result: (Invalid)
 37473		for {
 37474			_ = v.Args[1]
 37475			v_0 := v.Args[0]
 37476			if v_0.Op != OpOffPtr {
 37477				break
 37478			}
 37479			v_0_0 := v_0.Args[0]
 37480			if v_0_0.Op != OpLoad {
 37481				break
 37482			}
 37483			_ = v_0_0.Args[1]
 37484			v_0_0_0 := v_0_0.Args[0]
 37485			if v_0_0_0.Op != OpOffPtr {
 37486				break
 37487			}
 37488			c := v_0_0_0.AuxInt
 37489			v_0_0_0_0 := v_0_0_0.Args[0]
 37490			if v_0_0_0_0.Op != OpSP {
 37491				break
 37492			}
 37493			v_0_0_1 := v_0_0.Args[1]
 37494			if v_0_0_1.Op != OpStaticCall {
 37495				break
 37496			}
 37497			sym := v_0_0_1.Aux
 37498			if !(isSameSym(sym, "runtime.newobject") && c == config.ctxt.FixedFrameSize()+config.RegSize && warnRule(fe.Debug_checknil(), v, "removed nil check")) {
 37499				break
 37500			}
 37501			v.reset(OpInvalid)
 37502			return true
 37503		}
 37504		return false
 37505	}
 37506	func rewriteValuegeneric_OpNot_0(v *Value) bool {
 37507		// match: (Not (ConstBool [c]))
 37508		// cond:
 37509		// result: (ConstBool [1-c])
 37510		for {
 37511			v_0 := v.Args[0]
 37512			if v_0.Op != OpConstBool {
 37513				break
 37514			}
 37515			c := v_0.AuxInt
 37516			v.reset(OpConstBool)
 37517			v.AuxInt = 1 - c
 37518			return true
 37519		}
 37520		// match: (Not (Eq64 x y))
 37521		// cond:
 37522		// result: (Neq64 x y)
 37523		for {
 37524			v_0 := v.Args[0]
 37525			if v_0.Op != OpEq64 {
 37526				break
 37527			}
 37528			y := v_0.Args[1]
 37529			x := v_0.Args[0]
 37530			v.reset(OpNeq64)
 37531			v.AddArg(x)
 37532			v.AddArg(y)
 37533			return true
 37534		}
 37535		// match: (Not (Eq32 x y))
 37536		// cond:
 37537		// result: (Neq32 x y)
 37538		for {
 37539			v_0 := v.Args[0]
 37540			if v_0.Op != OpEq32 {
 37541				break
 37542			}
 37543			y := v_0.Args[1]
 37544			x := v_0.Args[0]
 37545			v.reset(OpNeq32)
 37546			v.AddArg(x)
 37547			v.AddArg(y)
 37548			return true
 37549		}
 37550		// match: (Not (Eq16 x y))
 37551		// cond:
 37552		// result: (Neq16 x y)
 37553		for {
 37554			v_0 := v.Args[0]
 37555			if v_0.Op != OpEq16 {
 37556				break
 37557			}
 37558			y := v_0.Args[1]
 37559			x := v_0.Args[0]
 37560			v.reset(OpNeq16)
 37561			v.AddArg(x)
 37562			v.AddArg(y)
 37563			return true
 37564		}
 37565		// match: (Not (Eq8 x y))
 37566		// cond:
 37567		// result: (Neq8 x y)
 37568		for {
 37569			v_0 := v.Args[0]
 37570			if v_0.Op != OpEq8 {
 37571				break
 37572			}
 37573			y := v_0.Args[1]
 37574			x := v_0.Args[0]
 37575			v.reset(OpNeq8)
 37576			v.AddArg(x)
 37577			v.AddArg(y)
 37578			return true
 37579		}
 37580		// match: (Not (EqB x y))
 37581		// cond:
 37582		// result: (NeqB x y)
 37583		for {
 37584			v_0 := v.Args[0]
 37585			if v_0.Op != OpEqB {
 37586				break
 37587			}
 37588			y := v_0.Args[1]
 37589			x := v_0.Args[0]
 37590			v.reset(OpNeqB)
 37591			v.AddArg(x)
 37592			v.AddArg(y)
 37593			return true
 37594		}
 37595		// match: (Not (Neq64 x y))
 37596		// cond:
 37597		// result: (Eq64 x y)
 37598		for {
 37599			v_0 := v.Args[0]
 37600			if v_0.Op != OpNeq64 {
 37601				break
 37602			}
 37603			y := v_0.Args[1]
 37604			x := v_0.Args[0]
 37605			v.reset(OpEq64)
 37606			v.AddArg(x)
 37607			v.AddArg(y)
 37608			return true
 37609		}
 37610		// match: (Not (Neq32 x y))
 37611		// cond:
 37612		// result: (Eq32 x y)
 37613		for {
 37614			v_0 := v.Args[0]
 37615			if v_0.Op != OpNeq32 {
 37616				break
 37617			}
 37618			y := v_0.Args[1]
 37619			x := v_0.Args[0]
 37620			v.reset(OpEq32)
 37621			v.AddArg(x)
 37622			v.AddArg(y)
 37623			return true
 37624		}
 37625		// match: (Not (Neq16 x y))
 37626		// cond:
 37627		// result: (Eq16 x y)
 37628		for {
 37629			v_0 := v.Args[0]
 37630			if v_0.Op != OpNeq16 {
 37631				break
 37632			}
 37633			y := v_0.Args[1]
 37634			x := v_0.Args[0]
 37635			v.reset(OpEq16)
 37636			v.AddArg(x)
 37637			v.AddArg(y)
 37638			return true
 37639		}
 37640		// match: (Not (Neq8 x y))
 37641		// cond:
 37642		// result: (Eq8 x y)
 37643		for {
 37644			v_0 := v.Args[0]
 37645			if v_0.Op != OpNeq8 {
 37646				break
 37647			}
 37648			y := v_0.Args[1]
 37649			x := v_0.Args[0]
 37650			v.reset(OpEq8)
 37651			v.AddArg(x)
 37652			v.AddArg(y)
 37653			return true
 37654		}
 37655		return false
 37656	}
 37657	func rewriteValuegeneric_OpNot_10(v *Value) bool {
 37658		// match: (Not (NeqB x y))
 37659		// cond:
 37660		// result: (EqB x y)
 37661		for {
 37662			v_0 := v.Args[0]
 37663			if v_0.Op != OpNeqB {
 37664				break
 37665			}
 37666			y := v_0.Args[1]
 37667			x := v_0.Args[0]
 37668			v.reset(OpEqB)
 37669			v.AddArg(x)
 37670			v.AddArg(y)
 37671			return true
 37672		}
 37673		// match: (Not (Greater64 x y))
 37674		// cond:
 37675		// result: (Leq64 x y)
 37676		for {
 37677			v_0 := v.Args[0]
 37678			if v_0.Op != OpGreater64 {
 37679				break
 37680			}
 37681			y := v_0.Args[1]
 37682			x := v_0.Args[0]
 37683			v.reset(OpLeq64)
 37684			v.AddArg(x)
 37685			v.AddArg(y)
 37686			return true
 37687		}
 37688		// match: (Not (Greater32 x y))
 37689		// cond:
 37690		// result: (Leq32 x y)
 37691		for {
 37692			v_0 := v.Args[0]
 37693			if v_0.Op != OpGreater32 {
 37694				break
 37695			}
 37696			y := v_0.Args[1]
 37697			x := v_0.Args[0]
 37698			v.reset(OpLeq32)
 37699			v.AddArg(x)
 37700			v.AddArg(y)
 37701			return true
 37702		}
 37703		// match: (Not (Greater16 x y))
 37704		// cond:
 37705		// result: (Leq16 x y)
 37706		for {
 37707			v_0 := v.Args[0]
 37708			if v_0.Op != OpGreater16 {
 37709				break
 37710			}
 37711			y := v_0.Args[1]
 37712			x := v_0.Args[0]
 37713			v.reset(OpLeq16)
 37714			v.AddArg(x)
 37715			v.AddArg(y)
 37716			return true
 37717		}
 37718		// match: (Not (Greater8 x y))
 37719		// cond:
 37720		// result: (Leq8 x y)
 37721		for {
 37722			v_0 := v.Args[0]
 37723			if v_0.Op != OpGreater8 {
 37724				break
 37725			}
 37726			y := v_0.Args[1]
 37727			x := v_0.Args[0]
 37728			v.reset(OpLeq8)
 37729			v.AddArg(x)
 37730			v.AddArg(y)
 37731			return true
 37732		}
 37733		// match: (Not (Greater64U x y))
 37734		// cond:
 37735		// result: (Leq64U x y)
 37736		for {
 37737			v_0 := v.Args[0]
 37738			if v_0.Op != OpGreater64U {
 37739				break
 37740			}
 37741			y := v_0.Args[1]
 37742			x := v_0.Args[0]
 37743			v.reset(OpLeq64U)
 37744			v.AddArg(x)
 37745			v.AddArg(y)
 37746			return true
 37747		}
 37748		// match: (Not (Greater32U x y))
 37749		// cond:
 37750		// result: (Leq32U x y)
 37751		for {
 37752			v_0 := v.Args[0]
 37753			if v_0.Op != OpGreater32U {
 37754				break
 37755			}
 37756			y := v_0.Args[1]
 37757			x := v_0.Args[0]
 37758			v.reset(OpLeq32U)
 37759			v.AddArg(x)
 37760			v.AddArg(y)
 37761			return true
 37762		}
 37763		// match: (Not (Greater16U x y))
 37764		// cond:
 37765		// result: (Leq16U x y)
 37766		for {
 37767			v_0 := v.Args[0]
 37768			if v_0.Op != OpGreater16U {
 37769				break
 37770			}
 37771			y := v_0.Args[1]
 37772			x := v_0.Args[0]
 37773			v.reset(OpLeq16U)
 37774			v.AddArg(x)
 37775			v.AddArg(y)
 37776			return true
 37777		}
 37778		// match: (Not (Greater8U x y))
 37779		// cond:
 37780		// result: (Leq8U x y)
 37781		for {
 37782			v_0 := v.Args[0]
 37783			if v_0.Op != OpGreater8U {
 37784				break
 37785			}
 37786			y := v_0.Args[1]
 37787			x := v_0.Args[0]
 37788			v.reset(OpLeq8U)
 37789			v.AddArg(x)
 37790			v.AddArg(y)
 37791			return true
 37792		}
 37793		// match: (Not (Geq64 x y))
 37794		// cond:
 37795		// result: (Less64 x y)
 37796		for {
 37797			v_0 := v.Args[0]
 37798			if v_0.Op != OpGeq64 {
 37799				break
 37800			}
 37801			y := v_0.Args[1]
 37802			x := v_0.Args[0]
 37803			v.reset(OpLess64)
 37804			v.AddArg(x)
 37805			v.AddArg(y)
 37806			return true
 37807		}
 37808		return false
 37809	}
 37810	func rewriteValuegeneric_OpNot_20(v *Value) bool {
 37811		// match: (Not (Geq32 x y))
 37812		// cond:
 37813		// result: (Less32 x y)
 37814		for {
 37815			v_0 := v.Args[0]
 37816			if v_0.Op != OpGeq32 {
 37817				break
 37818			}
 37819			y := v_0.Args[1]
 37820			x := v_0.Args[0]
 37821			v.reset(OpLess32)
 37822			v.AddArg(x)
 37823			v.AddArg(y)
 37824			return true
 37825		}
 37826		// match: (Not (Geq16 x y))
 37827		// cond:
 37828		// result: (Less16 x y)
 37829		for {
 37830			v_0 := v.Args[0]
 37831			if v_0.Op != OpGeq16 {
 37832				break
 37833			}
 37834			y := v_0.Args[1]
 37835			x := v_0.Args[0]
 37836			v.reset(OpLess16)
 37837			v.AddArg(x)
 37838			v.AddArg(y)
 37839			return true
 37840		}
 37841		// match: (Not (Geq8 x y))
 37842		// cond:
 37843		// result: (Less8 x y)
 37844		for {
 37845			v_0 := v.Args[0]
 37846			if v_0.Op != OpGeq8 {
 37847				break
 37848			}
 37849			y := v_0.Args[1]
 37850			x := v_0.Args[0]
 37851			v.reset(OpLess8)
 37852			v.AddArg(x)
 37853			v.AddArg(y)
 37854			return true
 37855		}
 37856		// match: (Not (Geq64U x y))
 37857		// cond:
 37858		// result: (Less64U x y)
 37859		for {
 37860			v_0 := v.Args[0]
 37861			if v_0.Op != OpGeq64U {
 37862				break
 37863			}
 37864			y := v_0.Args[1]
 37865			x := v_0.Args[0]
 37866			v.reset(OpLess64U)
 37867			v.AddArg(x)
 37868			v.AddArg(y)
 37869			return true
 37870		}
 37871		// match: (Not (Geq32U x y))
 37872		// cond:
 37873		// result: (Less32U x y)
 37874		for {
 37875			v_0 := v.Args[0]
 37876			if v_0.Op != OpGeq32U {
 37877				break
 37878			}
 37879			y := v_0.Args[1]
 37880			x := v_0.Args[0]
 37881			v.reset(OpLess32U)
 37882			v.AddArg(x)
 37883			v.AddArg(y)
 37884			return true
 37885		}
 37886		// match: (Not (Geq16U x y))
 37887		// cond:
 37888		// result: (Less16U x y)
 37889		for {
 37890			v_0 := v.Args[0]
 37891			if v_0.Op != OpGeq16U {
 37892				break
 37893			}
 37894			y := v_0.Args[1]
 37895			x := v_0.Args[0]
 37896			v.reset(OpLess16U)
 37897			v.AddArg(x)
 37898			v.AddArg(y)
 37899			return true
 37900		}
 37901		// match: (Not (Geq8U x y))
 37902		// cond:
 37903		// result: (Less8U x y)
 37904		for {
 37905			v_0 := v.Args[0]
 37906			if v_0.Op != OpGeq8U {
 37907				break
 37908			}
 37909			y := v_0.Args[1]
 37910			x := v_0.Args[0]
 37911			v.reset(OpLess8U)
 37912			v.AddArg(x)
 37913			v.AddArg(y)
 37914			return true
 37915		}
 37916		// match: (Not (Less64 x y))
 37917		// cond:
 37918		// result: (Geq64 x y)
 37919		for {
 37920			v_0 := v.Args[0]
 37921			if v_0.Op != OpLess64 {
 37922				break
 37923			}
 37924			y := v_0.Args[1]
 37925			x := v_0.Args[0]
 37926			v.reset(OpGeq64)
 37927			v.AddArg(x)
 37928			v.AddArg(y)
 37929			return true
 37930		}
 37931		// match: (Not (Less32 x y))
 37932		// cond:
 37933		// result: (Geq32 x y)
 37934		for {
 37935			v_0 := v.Args[0]
 37936			if v_0.Op != OpLess32 {
 37937				break
 37938			}
 37939			y := v_0.Args[1]
 37940			x := v_0.Args[0]
 37941			v.reset(OpGeq32)
 37942			v.AddArg(x)
 37943			v.AddArg(y)
 37944			return true
 37945		}
 37946		// match: (Not (Less16 x y))
 37947		// cond:
 37948		// result: (Geq16 x y)
 37949		for {
 37950			v_0 := v.Args[0]
 37951			if v_0.Op != OpLess16 {
 37952				break
 37953			}
 37954			y := v_0.Args[1]
 37955			x := v_0.Args[0]
 37956			v.reset(OpGeq16)
 37957			v.AddArg(x)
 37958			v.AddArg(y)
 37959			return true
 37960		}
 37961		return false
 37962	}
 37963	func rewriteValuegeneric_OpNot_30(v *Value) bool {
 37964		// match: (Not (Less8 x y))
 37965		// cond:
 37966		// result: (Geq8 x y)
 37967		for {
 37968			v_0 := v.Args[0]
 37969			if v_0.Op != OpLess8 {
 37970				break
 37971			}
 37972			y := v_0.Args[1]
 37973			x := v_0.Args[0]
 37974			v.reset(OpGeq8)
 37975			v.AddArg(x)
 37976			v.AddArg(y)
 37977			return true
 37978		}
 37979		// match: (Not (Less64U x y))
 37980		// cond:
 37981		// result: (Geq64U x y)
 37982		for {
 37983			v_0 := v.Args[0]
 37984			if v_0.Op != OpLess64U {
 37985				break
 37986			}
 37987			y := v_0.Args[1]
 37988			x := v_0.Args[0]
 37989			v.reset(OpGeq64U)
 37990			v.AddArg(x)
 37991			v.AddArg(y)
 37992			return true
 37993		}
 37994		// match: (Not (Less32U x y))
 37995		// cond:
 37996		// result: (Geq32U x y)
 37997		for {
 37998			v_0 := v.Args[0]
 37999			if v_0.Op != OpLess32U {
 38000				break
 38001			}
 38002			y := v_0.Args[1]
 38003			x := v_0.Args[0]
 38004			v.reset(OpGeq32U)
 38005			v.AddArg(x)
 38006			v.AddArg(y)
 38007			return true
 38008		}
 38009		// match: (Not (Less16U x y))
 38010		// cond:
 38011		// result: (Geq16U x y)
 38012		for {
 38013			v_0 := v.Args[0]
 38014			if v_0.Op != OpLess16U {
 38015				break
 38016			}
 38017			y := v_0.Args[1]
 38018			x := v_0.Args[0]
 38019			v.reset(OpGeq16U)
 38020			v.AddArg(x)
 38021			v.AddArg(y)
 38022			return true
 38023		}
 38024		// match: (Not (Less8U x y))
 38025		// cond:
 38026		// result: (Geq8U x y)
 38027		for {
 38028			v_0 := v.Args[0]
 38029			if v_0.Op != OpLess8U {
 38030				break
 38031			}
 38032			y := v_0.Args[1]
 38033			x := v_0.Args[0]
 38034			v.reset(OpGeq8U)
 38035			v.AddArg(x)
 38036			v.AddArg(y)
 38037			return true
 38038		}
 38039		// match: (Not (Leq64 x y))
 38040		// cond:
 38041		// result: (Greater64 x y)
 38042		for {
 38043			v_0 := v.Args[0]
 38044			if v_0.Op != OpLeq64 {
 38045				break
 38046			}
 38047			y := v_0.Args[1]
 38048			x := v_0.Args[0]
 38049			v.reset(OpGreater64)
 38050			v.AddArg(x)
 38051			v.AddArg(y)
 38052			return true
 38053		}
 38054		// match: (Not (Leq32 x y))
 38055		// cond:
 38056		// result: (Greater32 x y)
 38057		for {
 38058			v_0 := v.Args[0]
 38059			if v_0.Op != OpLeq32 {
 38060				break
 38061			}
 38062			y := v_0.Args[1]
 38063			x := v_0.Args[0]
 38064			v.reset(OpGreater32)
 38065			v.AddArg(x)
 38066			v.AddArg(y)
 38067			return true
 38068		}
 38069		// match: (Not (Leq16 x y))
 38070		// cond:
 38071		// result: (Greater16 x y)
 38072		for {
 38073			v_0 := v.Args[0]
 38074			if v_0.Op != OpLeq16 {
 38075				break
 38076			}
 38077			y := v_0.Args[1]
 38078			x := v_0.Args[0]
 38079			v.reset(OpGreater16)
 38080			v.AddArg(x)
 38081			v.AddArg(y)
 38082			return true
 38083		}
 38084		// match: (Not (Leq8 x y))
 38085		// cond:
 38086		// result: (Greater8 x y)
 38087		for {
 38088			v_0 := v.Args[0]
 38089			if v_0.Op != OpLeq8 {
 38090				break
 38091			}
 38092			y := v_0.Args[1]
 38093			x := v_0.Args[0]
 38094			v.reset(OpGreater8)
 38095			v.AddArg(x)
 38096			v.AddArg(y)
 38097			return true
 38098		}
 38099		// match: (Not (Leq64U x y))
 38100		// cond:
 38101		// result: (Greater64U x y)
 38102		for {
 38103			v_0 := v.Args[0]
 38104			if v_0.Op != OpLeq64U {
 38105				break
 38106			}
 38107			y := v_0.Args[1]
 38108			x := v_0.Args[0]
 38109			v.reset(OpGreater64U)
 38110			v.AddArg(x)
 38111			v.AddArg(y)
 38112			return true
 38113		}
 38114		return false
 38115	}
 38116	func rewriteValuegeneric_OpNot_40(v *Value) bool {
 38117		// match: (Not (Leq32U x y))
 38118		// cond:
 38119		// result: (Greater32U x y)
 38120		for {
 38121			v_0 := v.Args[0]
 38122			if v_0.Op != OpLeq32U {
 38123				break
 38124			}
 38125			y := v_0.Args[1]
 38126			x := v_0.Args[0]
 38127			v.reset(OpGreater32U)
 38128			v.AddArg(x)
 38129			v.AddArg(y)
 38130			return true
 38131		}
 38132		// match: (Not (Leq16U x y))
 38133		// cond:
 38134		// result: (Greater16U x y)
 38135		for {
 38136			v_0 := v.Args[0]
 38137			if v_0.Op != OpLeq16U {
 38138				break
 38139			}
 38140			y := v_0.Args[1]
 38141			x := v_0.Args[0]
 38142			v.reset(OpGreater16U)
 38143			v.AddArg(x)
 38144			v.AddArg(y)
 38145			return true
 38146		}
 38147		// match: (Not (Leq8U x y))
 38148		// cond:
 38149		// result: (Greater8U x y)
 38150		for {
 38151			v_0 := v.Args[0]
 38152			if v_0.Op != OpLeq8U {
 38153				break
 38154			}
 38155			y := v_0.Args[1]
 38156			x := v_0.Args[0]
 38157			v.reset(OpGreater8U)
 38158			v.AddArg(x)
 38159			v.AddArg(y)
 38160			return true
 38161		}
 38162		return false
 38163	}
 38164	func rewriteValuegeneric_OpOffPtr_0(v *Value) bool {
 38165		// match: (OffPtr (OffPtr p [b]) [a])
 38166		// cond:
 38167		// result: (OffPtr p [a+b])
 38168		for {
 38169			a := v.AuxInt
 38170			v_0 := v.Args[0]
 38171			if v_0.Op != OpOffPtr {
 38172				break
 38173			}
 38174			b := v_0.AuxInt
 38175			p := v_0.Args[0]
 38176			v.reset(OpOffPtr)
 38177			v.AuxInt = a + b
 38178			v.AddArg(p)
 38179			return true
 38180		}
 38181		// match: (OffPtr p [0])
 38182		// cond: v.Type.Compare(p.Type) == types.CMPeq
 38183		// result: p
 38184		for {
 38185			if v.AuxInt != 0 {
 38186				break
 38187			}
 38188			p := v.Args[0]
 38189			if !(v.Type.Compare(p.Type) == types.CMPeq) {
 38190				break
 38191			}
 38192			v.reset(OpCopy)
 38193			v.Type = p.Type
 38194			v.AddArg(p)
 38195			return true
 38196		}
 38197		return false
 38198	}
 38199	func rewriteValuegeneric_OpOr16_0(v *Value) bool {
 38200		// match: (Or16 (Const16 [c]) (Const16 [d]))
 38201		// cond:
 38202		// result: (Const16 [int64(int16(c|d))])
 38203		for {
 38204			_ = v.Args[1]
 38205			v_0 := v.Args[0]
 38206			if v_0.Op != OpConst16 {
 38207				break
 38208			}
 38209			c := v_0.AuxInt
 38210			v_1 := v.Args[1]
 38211			if v_1.Op != OpConst16 {
 38212				break
 38213			}
 38214			d := v_1.AuxInt
 38215			v.reset(OpConst16)
 38216			v.AuxInt = int64(int16(c | d))
 38217			return true
 38218		}
 38219		// match: (Or16 (Const16 [d]) (Const16 [c]))
 38220		// cond:
 38221		// result: (Const16 [int64(int16(c|d))])
 38222		for {
 38223			_ = v.Args[1]
 38224			v_0 := v.Args[0]
 38225			if v_0.Op != OpConst16 {
 38226				break
 38227			}
 38228			d := v_0.AuxInt
 38229			v_1 := v.Args[1]
 38230			if v_1.Op != OpConst16 {
 38231				break
 38232			}
 38233			c := v_1.AuxInt
 38234			v.reset(OpConst16)
 38235			v.AuxInt = int64(int16(c | d))
 38236			return true
 38237		}
 38238		// match: (Or16 x x)
 38239		// cond:
 38240		// result: x
 38241		for {
 38242			x := v.Args[1]
 38243			if x != v.Args[0] {
 38244				break
 38245			}
 38246			v.reset(OpCopy)
 38247			v.Type = x.Type
 38248			v.AddArg(x)
 38249			return true
 38250		}
 38251		// match: (Or16 (Const16 [0]) x)
 38252		// cond:
 38253		// result: x
 38254		for {
 38255			x := v.Args[1]
 38256			v_0 := v.Args[0]
 38257			if v_0.Op != OpConst16 {
 38258				break
 38259			}
 38260			if v_0.AuxInt != 0 {
 38261				break
 38262			}
 38263			v.reset(OpCopy)
 38264			v.Type = x.Type
 38265			v.AddArg(x)
 38266			return true
 38267		}
 38268		// match: (Or16 x (Const16 [0]))
 38269		// cond:
 38270		// result: x
 38271		for {
 38272			_ = v.Args[1]
 38273			x := v.Args[0]
 38274			v_1 := v.Args[1]
 38275			if v_1.Op != OpConst16 {
 38276				break
 38277			}
 38278			if v_1.AuxInt != 0 {
 38279				break
 38280			}
 38281			v.reset(OpCopy)
 38282			v.Type = x.Type
 38283			v.AddArg(x)
 38284			return true
 38285		}
 38286		// match: (Or16 (Const16 [-1]) _)
 38287		// cond:
 38288		// result: (Const16 [-1])
 38289		for {
 38290			_ = v.Args[1]
 38291			v_0 := v.Args[0]
 38292			if v_0.Op != OpConst16 {
 38293				break
 38294			}
 38295			if v_0.AuxInt != -1 {
 38296				break
 38297			}
 38298			v.reset(OpConst16)
 38299			v.AuxInt = -1
 38300			return true
 38301		}
 38302		// match: (Or16 _ (Const16 [-1]))
 38303		// cond:
 38304		// result: (Const16 [-1])
 38305		for {
 38306			_ = v.Args[1]
 38307			v_1 := v.Args[1]
 38308			if v_1.Op != OpConst16 {
 38309				break
 38310			}
 38311			if v_1.AuxInt != -1 {
 38312				break
 38313			}
 38314			v.reset(OpConst16)
 38315			v.AuxInt = -1
 38316			return true
 38317		}
 38318		// match: (Or16 x (Or16 x y))
 38319		// cond:
 38320		// result: (Or16 x y)
 38321		for {
 38322			_ = v.Args[1]
 38323			x := v.Args[0]
 38324			v_1 := v.Args[1]
 38325			if v_1.Op != OpOr16 {
 38326				break
 38327			}
 38328			y := v_1.Args[1]
 38329			if x != v_1.Args[0] {
 38330				break
 38331			}
 38332			v.reset(OpOr16)
 38333			v.AddArg(x)
 38334			v.AddArg(y)
 38335			return true
 38336		}
 38337		// match: (Or16 x (Or16 y x))
 38338		// cond:
 38339		// result: (Or16 x y)
 38340		for {
 38341			_ = v.Args[1]
 38342			x := v.Args[0]
 38343			v_1 := v.Args[1]
 38344			if v_1.Op != OpOr16 {
 38345				break
 38346			}
 38347			_ = v_1.Args[1]
 38348			y := v_1.Args[0]
 38349			if x != v_1.Args[1] {
 38350				break
 38351			}
 38352			v.reset(OpOr16)
 38353			v.AddArg(x)
 38354			v.AddArg(y)
 38355			return true
 38356		}
 38357		// match: (Or16 (Or16 x y) x)
 38358		// cond:
 38359		// result: (Or16 x y)
 38360		for {
 38361			x := v.Args[1]
 38362			v_0 := v.Args[0]
 38363			if v_0.Op != OpOr16 {
 38364				break
 38365			}
 38366			y := v_0.Args[1]
 38367			if x != v_0.Args[0] {
 38368				break
 38369			}
 38370			v.reset(OpOr16)
 38371			v.AddArg(x)
 38372			v.AddArg(y)
 38373			return true
 38374		}
 38375		return false
 38376	}
 38377	func rewriteValuegeneric_OpOr16_10(v *Value) bool {
 38378		b := v.Block
 38379		// match: (Or16 (Or16 y x) x)
 38380		// cond:
 38381		// result: (Or16 x y)
 38382		for {
 38383			x := v.Args[1]
 38384			v_0 := v.Args[0]
 38385			if v_0.Op != OpOr16 {
 38386				break
 38387			}
 38388			_ = v_0.Args[1]
 38389			y := v_0.Args[0]
 38390			if x != v_0.Args[1] {
 38391				break
 38392			}
 38393			v.reset(OpOr16)
 38394			v.AddArg(x)
 38395			v.AddArg(y)
 38396			return true
 38397		}
 38398		// match: (Or16 (And16 x (Const16 [c2])) (Const16 <t> [c1]))
 38399		// cond: ^(c1 | c2) == 0
 38400		// result: (Or16 (Const16 <t> [c1]) x)
 38401		for {
 38402			_ = v.Args[1]
 38403			v_0 := v.Args[0]
 38404			if v_0.Op != OpAnd16 {
 38405				break
 38406			}
 38407			_ = v_0.Args[1]
 38408			x := v_0.Args[0]
 38409			v_0_1 := v_0.Args[1]
 38410			if v_0_1.Op != OpConst16 {
 38411				break
 38412			}
 38413			c2 := v_0_1.AuxInt
 38414			v_1 := v.Args[1]
 38415			if v_1.Op != OpConst16 {
 38416				break
 38417			}
 38418			t := v_1.Type
 38419			c1 := v_1.AuxInt
 38420			if !(^(c1 | c2) == 0) {
 38421				break
 38422			}
 38423			v.reset(OpOr16)
 38424			v0 := b.NewValue0(v.Pos, OpConst16, t)
 38425			v0.AuxInt = c1
 38426			v.AddArg(v0)
 38427			v.AddArg(x)
 38428			return true
 38429		}
 38430		// match: (Or16 (And16 (Const16 [c2]) x) (Const16 <t> [c1]))
 38431		// cond: ^(c1 | c2) == 0
 38432		// result: (Or16 (Const16 <t> [c1]) x)
 38433		for {
 38434			_ = v.Args[1]
 38435			v_0 := v.Args[0]
 38436			if v_0.Op != OpAnd16 {
 38437				break
 38438			}
 38439			x := v_0.Args[1]
 38440			v_0_0 := v_0.Args[0]
 38441			if v_0_0.Op != OpConst16 {
 38442				break
 38443			}
 38444			c2 := v_0_0.AuxInt
 38445			v_1 := v.Args[1]
 38446			if v_1.Op != OpConst16 {
 38447				break
 38448			}
 38449			t := v_1.Type
 38450			c1 := v_1.AuxInt
 38451			if !(^(c1 | c2) == 0) {
 38452				break
 38453			}
 38454			v.reset(OpOr16)
 38455			v0 := b.NewValue0(v.Pos, OpConst16, t)
 38456			v0.AuxInt = c1
 38457			v.AddArg(v0)
 38458			v.AddArg(x)
 38459			return true
 38460		}
 38461		// match: (Or16 (Const16 <t> [c1]) (And16 x (Const16 [c2])))
 38462		// cond: ^(c1 | c2) == 0
 38463		// result: (Or16 (Const16 <t> [c1]) x)
 38464		for {
 38465			_ = v.Args[1]
 38466			v_0 := v.Args[0]
 38467			if v_0.Op != OpConst16 {
 38468				break
 38469			}
 38470			t := v_0.Type
 38471			c1 := v_0.AuxInt
 38472			v_1 := v.Args[1]
 38473			if v_1.Op != OpAnd16 {
 38474				break
 38475			}
 38476			_ = v_1.Args[1]
 38477			x := v_1.Args[0]
 38478			v_1_1 := v_1.Args[1]
 38479			if v_1_1.Op != OpConst16 {
 38480				break
 38481			}
 38482			c2 := v_1_1.AuxInt
 38483			if !(^(c1 | c2) == 0) {
 38484				break
 38485			}
 38486			v.reset(OpOr16)
 38487			v0 := b.NewValue0(v.Pos, OpConst16, t)
 38488			v0.AuxInt = c1
 38489			v.AddArg(v0)
 38490			v.AddArg(x)
 38491			return true
 38492		}
 38493		// match: (Or16 (Const16 <t> [c1]) (And16 (Const16 [c2]) x))
 38494		// cond: ^(c1 | c2) == 0
 38495		// result: (Or16 (Const16 <t> [c1]) x)
 38496		for {
 38497			_ = v.Args[1]
 38498			v_0 := v.Args[0]
 38499			if v_0.Op != OpConst16 {
 38500				break
 38501			}
 38502			t := v_0.Type
 38503			c1 := v_0.AuxInt
 38504			v_1 := v.Args[1]
 38505			if v_1.Op != OpAnd16 {
 38506				break
 38507			}
 38508			x := v_1.Args[1]
 38509			v_1_0 := v_1.Args[0]
 38510			if v_1_0.Op != OpConst16 {
 38511				break
 38512			}
 38513			c2 := v_1_0.AuxInt
 38514			if !(^(c1 | c2) == 0) {
 38515				break
 38516			}
 38517			v.reset(OpOr16)
 38518			v0 := b.NewValue0(v.Pos, OpConst16, t)
 38519			v0.AuxInt = c1
 38520			v.AddArg(v0)
 38521			v.AddArg(x)
 38522			return true
 38523		}
 38524		// match: (Or16 (Or16 i:(Const16 <t>) z) x)
 38525		// cond: (z.Op != OpConst16 && x.Op != OpConst16)
 38526		// result: (Or16 i (Or16 <t> z x))
 38527		for {
 38528			x := v.Args[1]
 38529			v_0 := v.Args[0]
 38530			if v_0.Op != OpOr16 {
 38531				break
 38532			}
 38533			z := v_0.Args[1]
 38534			i := v_0.Args[0]
 38535			if i.Op != OpConst16 {
 38536				break
 38537			}
 38538			t := i.Type
 38539			if !(z.Op != OpConst16 && x.Op != OpConst16) {
 38540				break
 38541			}
 38542			v.reset(OpOr16)
 38543			v.AddArg(i)
 38544			v0 := b.NewValue0(v.Pos, OpOr16, t)
 38545			v0.AddArg(z)
 38546			v0.AddArg(x)
 38547			v.AddArg(v0)
 38548			return true
 38549		}
 38550		// match: (Or16 (Or16 z i:(Const16 <t>)) x)
 38551		// cond: (z.Op != OpConst16 && x.Op != OpConst16)
 38552		// result: (Or16 i (Or16 <t> z x))
 38553		for {
 38554			x := v.Args[1]
 38555			v_0 := v.Args[0]
 38556			if v_0.Op != OpOr16 {
 38557				break
 38558			}
 38559			_ = v_0.Args[1]
 38560			z := v_0.Args[0]
 38561			i := v_0.Args[1]
 38562			if i.Op != OpConst16 {
 38563				break
 38564			}
 38565			t := i.Type
 38566			if !(z.Op != OpConst16 && x.Op != OpConst16) {
 38567				break
 38568			}
 38569			v.reset(OpOr16)
 38570			v.AddArg(i)
 38571			v0 := b.NewValue0(v.Pos, OpOr16, t)
 38572			v0.AddArg(z)
 38573			v0.AddArg(x)
 38574			v.AddArg(v0)
 38575			return true
 38576		}
 38577		// match: (Or16 x (Or16 i:(Const16 <t>) z))
 38578		// cond: (z.Op != OpConst16 && x.Op != OpConst16)
 38579		// result: (Or16 i (Or16 <t> z x))
 38580		for {
 38581			_ = v.Args[1]
 38582			x := v.Args[0]
 38583			v_1 := v.Args[1]
 38584			if v_1.Op != OpOr16 {
 38585				break
 38586			}
 38587			z := v_1.Args[1]
 38588			i := v_1.Args[0]
 38589			if i.Op != OpConst16 {
 38590				break
 38591			}
 38592			t := i.Type
 38593			if !(z.Op != OpConst16 && x.Op != OpConst16) {
 38594				break
 38595			}
 38596			v.reset(OpOr16)
 38597			v.AddArg(i)
 38598			v0 := b.NewValue0(v.Pos, OpOr16, t)
 38599			v0.AddArg(z)
 38600			v0.AddArg(x)
 38601			v.AddArg(v0)
 38602			return true
 38603		}
 38604		// match: (Or16 x (Or16 z i:(Const16 <t>)))
 38605		// cond: (z.Op != OpConst16 && x.Op != OpConst16)
 38606		// result: (Or16 i (Or16 <t> z x))
 38607		for {
 38608			_ = v.Args[1]
 38609			x := v.Args[0]
 38610			v_1 := v.Args[1]
 38611			if v_1.Op != OpOr16 {
 38612				break
 38613			}
 38614			_ = v_1.Args[1]
 38615			z := v_1.Args[0]
 38616			i := v_1.Args[1]
 38617			if i.Op != OpConst16 {
 38618				break
 38619			}
 38620			t := i.Type
 38621			if !(z.Op != OpConst16 && x.Op != OpConst16) {
 38622				break
 38623			}
 38624			v.reset(OpOr16)
 38625			v.AddArg(i)
 38626			v0 := b.NewValue0(v.Pos, OpOr16, t)
 38627			v0.AddArg(z)
 38628			v0.AddArg(x)
 38629			v.AddArg(v0)
 38630			return true
 38631		}
 38632		// match: (Or16 (Const16 <t> [c]) (Or16 (Const16 <t> [d]) x))
 38633		// cond:
 38634		// result: (Or16 (Const16 <t> [int64(int16(c|d))]) x)
 38635		for {
 38636			_ = v.Args[1]
 38637			v_0 := v.Args[0]
 38638			if v_0.Op != OpConst16 {
 38639				break
 38640			}
 38641			t := v_0.Type
 38642			c := v_0.AuxInt
 38643			v_1 := v.Args[1]
 38644			if v_1.Op != OpOr16 {
 38645				break
 38646			}
 38647			x := v_1.Args[1]
 38648			v_1_0 := v_1.Args[0]
 38649			if v_1_0.Op != OpConst16 {
 38650				break
 38651			}
 38652			if v_1_0.Type != t {
 38653				break
 38654			}
 38655			d := v_1_0.AuxInt
 38656			v.reset(OpOr16)
 38657			v0 := b.NewValue0(v.Pos, OpConst16, t)
 38658			v0.AuxInt = int64(int16(c | d))
 38659			v.AddArg(v0)
 38660			v.AddArg(x)
 38661			return true
 38662		}
 38663		return false
 38664	}
 38665	func rewriteValuegeneric_OpOr16_20(v *Value) bool {
 38666		b := v.Block
 38667		// match: (Or16 (Const16 <t> [c]) (Or16 x (Const16 <t> [d])))
 38668		// cond:
 38669		// result: (Or16 (Const16 <t> [int64(int16(c|d))]) x)
 38670		for {
 38671			_ = v.Args[1]
 38672			v_0 := v.Args[0]
 38673			if v_0.Op != OpConst16 {
 38674				break
 38675			}
 38676			t := v_0.Type
 38677			c := v_0.AuxInt
 38678			v_1 := v.Args[1]
 38679			if v_1.Op != OpOr16 {
 38680				break
 38681			}
 38682			_ = v_1.Args[1]
 38683			x := v_1.Args[0]
 38684			v_1_1 := v_1.Args[1]
 38685			if v_1_1.Op != OpConst16 {
 38686				break
 38687			}
 38688			if v_1_1.Type != t {
 38689				break
 38690			}
 38691			d := v_1_1.AuxInt
 38692			v.reset(OpOr16)
 38693			v0 := b.NewValue0(v.Pos, OpConst16, t)
 38694			v0.AuxInt = int64(int16(c | d))
 38695			v.AddArg(v0)
 38696			v.AddArg(x)
 38697			return true
 38698		}
 38699		// match: (Or16 (Or16 (Const16 <t> [d]) x) (Const16 <t> [c]))
 38700		// cond:
 38701		// result: (Or16 (Const16 <t> [int64(int16(c|d))]) x)
 38702		for {
 38703			_ = v.Args[1]
 38704			v_0 := v.Args[0]
 38705			if v_0.Op != OpOr16 {
 38706				break
 38707			}
 38708			x := v_0.Args[1]
 38709			v_0_0 := v_0.Args[0]
 38710			if v_0_0.Op != OpConst16 {
 38711				break
 38712			}
 38713			t := v_0_0.Type
 38714			d := v_0_0.AuxInt
 38715			v_1 := v.Args[1]
 38716			if v_1.Op != OpConst16 {
 38717				break
 38718			}
 38719			if v_1.Type != t {
 38720				break
 38721			}
 38722			c := v_1.AuxInt
 38723			v.reset(OpOr16)
 38724			v0 := b.NewValue0(v.Pos, OpConst16, t)
 38725			v0.AuxInt = int64(int16(c | d))
 38726			v.AddArg(v0)
 38727			v.AddArg(x)
 38728			return true
 38729		}
 38730		// match: (Or16 (Or16 x (Const16 <t> [d])) (Const16 <t> [c]))
 38731		// cond:
 38732		// result: (Or16 (Const16 <t> [int64(int16(c|d))]) x)
 38733		for {
 38734			_ = v.Args[1]
 38735			v_0 := v.Args[0]
 38736			if v_0.Op != OpOr16 {
 38737				break
 38738			}
 38739			_ = v_0.Args[1]
 38740			x := v_0.Args[0]
 38741			v_0_1 := v_0.Args[1]
 38742			if v_0_1.Op != OpConst16 {
 38743				break
 38744			}
 38745			t := v_0_1.Type
 38746			d := v_0_1.AuxInt
 38747			v_1 := v.Args[1]
 38748			if v_1.Op != OpConst16 {
 38749				break
 38750			}
 38751			if v_1.Type != t {
 38752				break
 38753			}
 38754			c := v_1.AuxInt
 38755			v.reset(OpOr16)
 38756			v0 := b.NewValue0(v.Pos, OpConst16, t)
 38757			v0.AuxInt = int64(int16(c | d))
 38758			v.AddArg(v0)
 38759			v.AddArg(x)
 38760			return true
 38761		}
 38762		return false
 38763	}
 38764	func rewriteValuegeneric_OpOr32_0(v *Value) bool {
 38765		// match: (Or32 (Const32 [c]) (Const32 [d]))
 38766		// cond:
 38767		// result: (Const32 [int64(int32(c|d))])
 38768		for {
 38769			_ = v.Args[1]
 38770			v_0 := v.Args[0]
 38771			if v_0.Op != OpConst32 {
 38772				break
 38773			}
 38774			c := v_0.AuxInt
 38775			v_1 := v.Args[1]
 38776			if v_1.Op != OpConst32 {
 38777				break
 38778			}
 38779			d := v_1.AuxInt
 38780			v.reset(OpConst32)
 38781			v.AuxInt = int64(int32(c | d))
 38782			return true
 38783		}
 38784		// match: (Or32 (Const32 [d]) (Const32 [c]))
 38785		// cond:
 38786		// result: (Const32 [int64(int32(c|d))])
 38787		for {
 38788			_ = v.Args[1]
 38789			v_0 := v.Args[0]
 38790			if v_0.Op != OpConst32 {
 38791				break
 38792			}
 38793			d := v_0.AuxInt
 38794			v_1 := v.Args[1]
 38795			if v_1.Op != OpConst32 {
 38796				break
 38797			}
 38798			c := v_1.AuxInt
 38799			v.reset(OpConst32)
 38800			v.AuxInt = int64(int32(c | d))
 38801			return true
 38802		}
 38803		// match: (Or32 x x)
 38804		// cond:
 38805		// result: x
 38806		for {
 38807			x := v.Args[1]
 38808			if x != v.Args[0] {
 38809				break
 38810			}
 38811			v.reset(OpCopy)
 38812			v.Type = x.Type
 38813			v.AddArg(x)
 38814			return true
 38815		}
 38816		// match: (Or32 (Const32 [0]) x)
 38817		// cond:
 38818		// result: x
 38819		for {
 38820			x := v.Args[1]
 38821			v_0 := v.Args[0]
 38822			if v_0.Op != OpConst32 {
 38823				break
 38824			}
 38825			if v_0.AuxInt != 0 {
 38826				break
 38827			}
 38828			v.reset(OpCopy)
 38829			v.Type = x.Type
 38830			v.AddArg(x)
 38831			return true
 38832		}
 38833		// match: (Or32 x (Const32 [0]))
 38834		// cond:
 38835		// result: x
 38836		for {
 38837			_ = v.Args[1]
 38838			x := v.Args[0]
 38839			v_1 := v.Args[1]
 38840			if v_1.Op != OpConst32 {
 38841				break
 38842			}
 38843			if v_1.AuxInt != 0 {
 38844				break
 38845			}
 38846			v.reset(OpCopy)
 38847			v.Type = x.Type
 38848			v.AddArg(x)
 38849			return true
 38850		}
 38851		// match: (Or32 (Const32 [-1]) _)
 38852		// cond:
 38853		// result: (Const32 [-1])
 38854		for {
 38855			_ = v.Args[1]
 38856			v_0 := v.Args[0]
 38857			if v_0.Op != OpConst32 {
 38858				break
 38859			}
 38860			if v_0.AuxInt != -1 {
 38861				break
 38862			}
 38863			v.reset(OpConst32)
 38864			v.AuxInt = -1
 38865			return true
 38866		}
 38867		// match: (Or32 _ (Const32 [-1]))
 38868		// cond:
 38869		// result: (Const32 [-1])
 38870		for {
 38871			_ = v.Args[1]
 38872			v_1 := v.Args[1]
 38873			if v_1.Op != OpConst32 {
 38874				break
 38875			}
 38876			if v_1.AuxInt != -1 {
 38877				break
 38878			}
 38879			v.reset(OpConst32)
 38880			v.AuxInt = -1
 38881			return true
 38882		}
 38883		// match: (Or32 x (Or32 x y))
 38884		// cond:
 38885		// result: (Or32 x y)
 38886		for {
 38887			_ = v.Args[1]
 38888			x := v.Args[0]
 38889			v_1 := v.Args[1]
 38890			if v_1.Op != OpOr32 {
 38891				break
 38892			}
 38893			y := v_1.Args[1]
 38894			if x != v_1.Args[0] {
 38895				break
 38896			}
 38897			v.reset(OpOr32)
 38898			v.AddArg(x)
 38899			v.AddArg(y)
 38900			return true
 38901		}
 38902		// match: (Or32 x (Or32 y x))
 38903		// cond:
 38904		// result: (Or32 x y)
 38905		for {
 38906			_ = v.Args[1]
 38907			x := v.Args[0]
 38908			v_1 := v.Args[1]
 38909			if v_1.Op != OpOr32 {
 38910				break
 38911			}
 38912			_ = v_1.Args[1]
 38913			y := v_1.Args[0]
 38914			if x != v_1.Args[1] {
 38915				break
 38916			}
 38917			v.reset(OpOr32)
 38918			v.AddArg(x)
 38919			v.AddArg(y)
 38920			return true
 38921		}
 38922		// match: (Or32 (Or32 x y) x)
 38923		// cond:
 38924		// result: (Or32 x y)
 38925		for {
 38926			x := v.Args[1]
 38927			v_0 := v.Args[0]
 38928			if v_0.Op != OpOr32 {
 38929				break
 38930			}
 38931			y := v_0.Args[1]
 38932			if x != v_0.Args[0] {
 38933				break
 38934			}
 38935			v.reset(OpOr32)
 38936			v.AddArg(x)
 38937			v.AddArg(y)
 38938			return true
 38939		}
 38940		return false
 38941	}
 38942	func rewriteValuegeneric_OpOr32_10(v *Value) bool {
 38943		b := v.Block
 38944		// match: (Or32 (Or32 y x) x)
 38945		// cond:
 38946		// result: (Or32 x y)
 38947		for {
 38948			x := v.Args[1]
 38949			v_0 := v.Args[0]
 38950			if v_0.Op != OpOr32 {
 38951				break
 38952			}
 38953			_ = v_0.Args[1]
 38954			y := v_0.Args[0]
 38955			if x != v_0.Args[1] {
 38956				break
 38957			}
 38958			v.reset(OpOr32)
 38959			v.AddArg(x)
 38960			v.AddArg(y)
 38961			return true
 38962		}
 38963		// match: (Or32 (And32 x (Const32 [c2])) (Const32 <t> [c1]))
 38964		// cond: ^(c1 | c2) == 0
 38965		// result: (Or32 (Const32 <t> [c1]) x)
 38966		for {
 38967			_ = v.Args[1]
 38968			v_0 := v.Args[0]
 38969			if v_0.Op != OpAnd32 {
 38970				break
 38971			}
 38972			_ = v_0.Args[1]
 38973			x := v_0.Args[0]
 38974			v_0_1 := v_0.Args[1]
 38975			if v_0_1.Op != OpConst32 {
 38976				break
 38977			}
 38978			c2 := v_0_1.AuxInt
 38979			v_1 := v.Args[1]
 38980			if v_1.Op != OpConst32 {
 38981				break
 38982			}
 38983			t := v_1.Type
 38984			c1 := v_1.AuxInt
 38985			if !(^(c1 | c2) == 0) {
 38986				break
 38987			}
 38988			v.reset(OpOr32)
 38989			v0 := b.NewValue0(v.Pos, OpConst32, t)
 38990			v0.AuxInt = c1
 38991			v.AddArg(v0)
 38992			v.AddArg(x)
 38993			return true
 38994		}
 38995		// match: (Or32 (And32 (Const32 [c2]) x) (Const32 <t> [c1]))
 38996		// cond: ^(c1 | c2) == 0
 38997		// result: (Or32 (Const32 <t> [c1]) x)
 38998		for {
 38999			_ = v.Args[1]
 39000			v_0 := v.Args[0]
 39001			if v_0.Op != OpAnd32 {
 39002				break
 39003			}
 39004			x := v_0.Args[1]
 39005			v_0_0 := v_0.Args[0]
 39006			if v_0_0.Op != OpConst32 {
 39007				break
 39008			}
 39009			c2 := v_0_0.AuxInt
 39010			v_1 := v.Args[1]
 39011			if v_1.Op != OpConst32 {
 39012				break
 39013			}
 39014			t := v_1.Type
 39015			c1 := v_1.AuxInt
 39016			if !(^(c1 | c2) == 0) {
 39017				break
 39018			}
 39019			v.reset(OpOr32)
 39020			v0 := b.NewValue0(v.Pos, OpConst32, t)
 39021			v0.AuxInt = c1
 39022			v.AddArg(v0)
 39023			v.AddArg(x)
 39024			return true
 39025		}
 39026		// match: (Or32 (Const32 <t> [c1]) (And32 x (Const32 [c2])))
 39027		// cond: ^(c1 | c2) == 0
 39028		// result: (Or32 (Const32 <t> [c1]) x)
 39029		for {
 39030			_ = v.Args[1]
 39031			v_0 := v.Args[0]
 39032			if v_0.Op != OpConst32 {
 39033				break
 39034			}
 39035			t := v_0.Type
 39036			c1 := v_0.AuxInt
 39037			v_1 := v.Args[1]
 39038			if v_1.Op != OpAnd32 {
 39039				break
 39040			}
 39041			_ = v_1.Args[1]
 39042			x := v_1.Args[0]
 39043			v_1_1 := v_1.Args[1]
 39044			if v_1_1.Op != OpConst32 {
 39045				break
 39046			}
 39047			c2 := v_1_1.AuxInt
 39048			if !(^(c1 | c2) == 0) {
 39049				break
 39050			}
 39051			v.reset(OpOr32)
 39052			v0 := b.NewValue0(v.Pos, OpConst32, t)
 39053			v0.AuxInt = c1
 39054			v.AddArg(v0)
 39055			v.AddArg(x)
 39056			return true
 39057		}
 39058		// match: (Or32 (Const32 <t> [c1]) (And32 (Const32 [c2]) x))
 39059		// cond: ^(c1 | c2) == 0
 39060		// result: (Or32 (Const32 <t> [c1]) x)
 39061		for {
 39062			_ = v.Args[1]
 39063			v_0 := v.Args[0]
 39064			if v_0.Op != OpConst32 {
 39065				break
 39066			}
 39067			t := v_0.Type
 39068			c1 := v_0.AuxInt
 39069			v_1 := v.Args[1]
 39070			if v_1.Op != OpAnd32 {
 39071				break
 39072			}
 39073			x := v_1.Args[1]
 39074			v_1_0 := v_1.Args[0]
 39075			if v_1_0.Op != OpConst32 {
 39076				break
 39077			}
 39078			c2 := v_1_0.AuxInt
 39079			if !(^(c1 | c2) == 0) {
 39080				break
 39081			}
 39082			v.reset(OpOr32)
 39083			v0 := b.NewValue0(v.Pos, OpConst32, t)
 39084			v0.AuxInt = c1
 39085			v.AddArg(v0)
 39086			v.AddArg(x)
 39087			return true
 39088		}
 39089		// match: (Or32 (Or32 i:(Const32 <t>) z) x)
 39090		// cond: (z.Op != OpConst32 && x.Op != OpConst32)
 39091		// result: (Or32 i (Or32 <t> z x))
 39092		for {
 39093			x := v.Args[1]
 39094			v_0 := v.Args[0]
 39095			if v_0.Op != OpOr32 {
 39096				break
 39097			}
 39098			z := v_0.Args[1]
 39099			i := v_0.Args[0]
 39100			if i.Op != OpConst32 {
 39101				break
 39102			}
 39103			t := i.Type
 39104			if !(z.Op != OpConst32 && x.Op != OpConst32) {
 39105				break
 39106			}
 39107			v.reset(OpOr32)
 39108			v.AddArg(i)
 39109			v0 := b.NewValue0(v.Pos, OpOr32, t)
 39110			v0.AddArg(z)
 39111			v0.AddArg(x)
 39112			v.AddArg(v0)
 39113			return true
 39114		}
 39115		// match: (Or32 (Or32 z i:(Const32 <t>)) x)
 39116		// cond: (z.Op != OpConst32 && x.Op != OpConst32)
 39117		// result: (Or32 i (Or32 <t> z x))
 39118		for {
 39119			x := v.Args[1]
 39120			v_0 := v.Args[0]
 39121			if v_0.Op != OpOr32 {
 39122				break
 39123			}
 39124			_ = v_0.Args[1]
 39125			z := v_0.Args[0]
 39126			i := v_0.Args[1]
 39127			if i.Op != OpConst32 {
 39128				break
 39129			}
 39130			t := i.Type
 39131			if !(z.Op != OpConst32 && x.Op != OpConst32) {
 39132				break
 39133			}
 39134			v.reset(OpOr32)
 39135			v.AddArg(i)
 39136			v0 := b.NewValue0(v.Pos, OpOr32, t)
 39137			v0.AddArg(z)
 39138			v0.AddArg(x)
 39139			v.AddArg(v0)
 39140			return true
 39141		}
 39142		// match: (Or32 x (Or32 i:(Const32 <t>) z))
 39143		// cond: (z.Op != OpConst32 && x.Op != OpConst32)
 39144		// result: (Or32 i (Or32 <t> z x))
 39145		for {
 39146			_ = v.Args[1]
 39147			x := v.Args[0]
 39148			v_1 := v.Args[1]
 39149			if v_1.Op != OpOr32 {
 39150				break
 39151			}
 39152			z := v_1.Args[1]
 39153			i := v_1.Args[0]
 39154			if i.Op != OpConst32 {
 39155				break
 39156			}
 39157			t := i.Type
 39158			if !(z.Op != OpConst32 && x.Op != OpConst32) {
 39159				break
 39160			}
 39161			v.reset(OpOr32)
 39162			v.AddArg(i)
 39163			v0 := b.NewValue0(v.Pos, OpOr32, t)
 39164			v0.AddArg(z)
 39165			v0.AddArg(x)
 39166			v.AddArg(v0)
 39167			return true
 39168		}
 39169		// match: (Or32 x (Or32 z i:(Const32 <t>)))
 39170		// cond: (z.Op != OpConst32 && x.Op != OpConst32)
 39171		// result: (Or32 i (Or32 <t> z x))
 39172		for {
 39173			_ = v.Args[1]
 39174			x := v.Args[0]
 39175			v_1 := v.Args[1]
 39176			if v_1.Op != OpOr32 {
 39177				break
 39178			}
 39179			_ = v_1.Args[1]
 39180			z := v_1.Args[0]
 39181			i := v_1.Args[1]
 39182			if i.Op != OpConst32 {
 39183				break
 39184			}
 39185			t := i.Type
 39186			if !(z.Op != OpConst32 && x.Op != OpConst32) {
 39187				break
 39188			}
 39189			v.reset(OpOr32)
 39190			v.AddArg(i)
 39191			v0 := b.NewValue0(v.Pos, OpOr32, t)
 39192			v0.AddArg(z)
 39193			v0.AddArg(x)
 39194			v.AddArg(v0)
 39195			return true
 39196		}
 39197		// match: (Or32 (Const32 <t> [c]) (Or32 (Const32 <t> [d]) x))
 39198		// cond:
 39199		// result: (Or32 (Const32 <t> [int64(int32(c|d))]) x)
 39200		for {
 39201			_ = v.Args[1]
 39202			v_0 := v.Args[0]
 39203			if v_0.Op != OpConst32 {
 39204				break
 39205			}
 39206			t := v_0.Type
 39207			c := v_0.AuxInt
 39208			v_1 := v.Args[1]
 39209			if v_1.Op != OpOr32 {
 39210				break
 39211			}
 39212			x := v_1.Args[1]
 39213			v_1_0 := v_1.Args[0]
 39214			if v_1_0.Op != OpConst32 {
 39215				break
 39216			}
 39217			if v_1_0.Type != t {
 39218				break
 39219			}
 39220			d := v_1_0.AuxInt
 39221			v.reset(OpOr32)
 39222			v0 := b.NewValue0(v.Pos, OpConst32, t)
 39223			v0.AuxInt = int64(int32(c | d))
 39224			v.AddArg(v0)
 39225			v.AddArg(x)
 39226			return true
 39227		}
 39228		return false
 39229	}
 39230	func rewriteValuegeneric_OpOr32_20(v *Value) bool {
 39231		b := v.Block
 39232		// match: (Or32 (Const32 <t> [c]) (Or32 x (Const32 <t> [d])))
 39233		// cond:
 39234		// result: (Or32 (Const32 <t> [int64(int32(c|d))]) x)
 39235		for {
 39236			_ = v.Args[1]
 39237			v_0 := v.Args[0]
 39238			if v_0.Op != OpConst32 {
 39239				break
 39240			}
 39241			t := v_0.Type
 39242			c := v_0.AuxInt
 39243			v_1 := v.Args[1]
 39244			if v_1.Op != OpOr32 {
 39245				break
 39246			}
 39247			_ = v_1.Args[1]
 39248			x := v_1.Args[0]
 39249			v_1_1 := v_1.Args[1]
 39250			if v_1_1.Op != OpConst32 {
 39251				break
 39252			}
 39253			if v_1_1.Type != t {
 39254				break
 39255			}
 39256			d := v_1_1.AuxInt
 39257			v.reset(OpOr32)
 39258			v0 := b.NewValue0(v.Pos, OpConst32, t)
 39259			v0.AuxInt = int64(int32(c | d))
 39260			v.AddArg(v0)
 39261			v.AddArg(x)
 39262			return true
 39263		}
 39264		// match: (Or32 (Or32 (Const32 <t> [d]) x) (Const32 <t> [c]))
 39265		// cond:
 39266		// result: (Or32 (Const32 <t> [int64(int32(c|d))]) x)
 39267		for {
 39268			_ = v.Args[1]
 39269			v_0 := v.Args[0]
 39270			if v_0.Op != OpOr32 {
 39271				break
 39272			}
 39273			x := v_0.Args[1]
 39274			v_0_0 := v_0.Args[0]
 39275			if v_0_0.Op != OpConst32 {
 39276				break
 39277			}
 39278			t := v_0_0.Type
 39279			d := v_0_0.AuxInt
 39280			v_1 := v.Args[1]
 39281			if v_1.Op != OpConst32 {
 39282				break
 39283			}
 39284			if v_1.Type != t {
 39285				break
 39286			}
 39287			c := v_1.AuxInt
 39288			v.reset(OpOr32)
 39289			v0 := b.NewValue0(v.Pos, OpConst32, t)
 39290			v0.AuxInt = int64(int32(c | d))
 39291			v.AddArg(v0)
 39292			v.AddArg(x)
 39293			return true
 39294		}
 39295		// match: (Or32 (Or32 x (Const32 <t> [d])) (Const32 <t> [c]))
 39296		// cond:
 39297		// result: (Or32 (Const32 <t> [int64(int32(c|d))]) x)
 39298		for {
 39299			_ = v.Args[1]
 39300			v_0 := v.Args[0]
 39301			if v_0.Op != OpOr32 {
 39302				break
 39303			}
 39304			_ = v_0.Args[1]
 39305			x := v_0.Args[0]
 39306			v_0_1 := v_0.Args[1]
 39307			if v_0_1.Op != OpConst32 {
 39308				break
 39309			}
 39310			t := v_0_1.Type
 39311			d := v_0_1.AuxInt
 39312			v_1 := v.Args[1]
 39313			if v_1.Op != OpConst32 {
 39314				break
 39315			}
 39316			if v_1.Type != t {
 39317				break
 39318			}
 39319			c := v_1.AuxInt
 39320			v.reset(OpOr32)
 39321			v0 := b.NewValue0(v.Pos, OpConst32, t)
 39322			v0.AuxInt = int64(int32(c | d))
 39323			v.AddArg(v0)
 39324			v.AddArg(x)
 39325			return true
 39326		}
 39327		return false
 39328	}
 39329	func rewriteValuegeneric_OpOr64_0(v *Value) bool {
 39330		// match: (Or64 (Const64 [c]) (Const64 [d]))
 39331		// cond:
 39332		// result: (Const64 [c|d])
 39333		for {
 39334			_ = v.Args[1]
 39335			v_0 := v.Args[0]
 39336			if v_0.Op != OpConst64 {
 39337				break
 39338			}
 39339			c := v_0.AuxInt
 39340			v_1 := v.Args[1]
 39341			if v_1.Op != OpConst64 {
 39342				break
 39343			}
 39344			d := v_1.AuxInt
 39345			v.reset(OpConst64)
 39346			v.AuxInt = c | d
 39347			return true
 39348		}
 39349		// match: (Or64 (Const64 [d]) (Const64 [c]))
 39350		// cond:
 39351		// result: (Const64 [c|d])
 39352		for {
 39353			_ = v.Args[1]
 39354			v_0 := v.Args[0]
 39355			if v_0.Op != OpConst64 {
 39356				break
 39357			}
 39358			d := v_0.AuxInt
 39359			v_1 := v.Args[1]
 39360			if v_1.Op != OpConst64 {
 39361				break
 39362			}
 39363			c := v_1.AuxInt
 39364			v.reset(OpConst64)
 39365			v.AuxInt = c | d
 39366			return true
 39367		}
 39368		// match: (Or64 x x)
 39369		// cond:
 39370		// result: x
 39371		for {
 39372			x := v.Args[1]
 39373			if x != v.Args[0] {
 39374				break
 39375			}
 39376			v.reset(OpCopy)
 39377			v.Type = x.Type
 39378			v.AddArg(x)
 39379			return true
 39380		}
 39381		// match: (Or64 (Const64 [0]) x)
 39382		// cond:
 39383		// result: x
 39384		for {
 39385			x := v.Args[1]
 39386			v_0 := v.Args[0]
 39387			if v_0.Op != OpConst64 {
 39388				break
 39389			}
 39390			if v_0.AuxInt != 0 {
 39391				break
 39392			}
 39393			v.reset(OpCopy)
 39394			v.Type = x.Type
 39395			v.AddArg(x)
 39396			return true
 39397		}
 39398		// match: (Or64 x (Const64 [0]))
 39399		// cond:
 39400		// result: x
 39401		for {
 39402			_ = v.Args[1]
 39403			x := v.Args[0]
 39404			v_1 := v.Args[1]
 39405			if v_1.Op != OpConst64 {
 39406				break
 39407			}
 39408			if v_1.AuxInt != 0 {
 39409				break
 39410			}
 39411			v.reset(OpCopy)
 39412			v.Type = x.Type
 39413			v.AddArg(x)
 39414			return true
 39415		}
 39416		// match: (Or64 (Const64 [-1]) _)
 39417		// cond:
 39418		// result: (Const64 [-1])
 39419		for {
 39420			_ = v.Args[1]
 39421			v_0 := v.Args[0]
 39422			if v_0.Op != OpConst64 {
 39423				break
 39424			}
 39425			if v_0.AuxInt != -1 {
 39426				break
 39427			}
 39428			v.reset(OpConst64)
 39429			v.AuxInt = -1
 39430			return true
 39431		}
 39432		// match: (Or64 _ (Const64 [-1]))
 39433		// cond:
 39434		// result: (Const64 [-1])
 39435		for {
 39436			_ = v.Args[1]
 39437			v_1 := v.Args[1]
 39438			if v_1.Op != OpConst64 {
 39439				break
 39440			}
 39441			if v_1.AuxInt != -1 {
 39442				break
 39443			}
 39444			v.reset(OpConst64)
 39445			v.AuxInt = -1
 39446			return true
 39447		}
 39448		// match: (Or64 x (Or64 x y))
 39449		// cond:
 39450		// result: (Or64 x y)
 39451		for {
 39452			_ = v.Args[1]
 39453			x := v.Args[0]
 39454			v_1 := v.Args[1]
 39455			if v_1.Op != OpOr64 {
 39456				break
 39457			}
 39458			y := v_1.Args[1]
 39459			if x != v_1.Args[0] {
 39460				break
 39461			}
 39462			v.reset(OpOr64)
 39463			v.AddArg(x)
 39464			v.AddArg(y)
 39465			return true
 39466		}
 39467		// match: (Or64 x (Or64 y x))
 39468		// cond:
 39469		// result: (Or64 x y)
 39470		for {
 39471			_ = v.Args[1]
 39472			x := v.Args[0]
 39473			v_1 := v.Args[1]
 39474			if v_1.Op != OpOr64 {
 39475				break
 39476			}
 39477			_ = v_1.Args[1]
 39478			y := v_1.Args[0]
 39479			if x != v_1.Args[1] {
 39480				break
 39481			}
 39482			v.reset(OpOr64)
 39483			v.AddArg(x)
 39484			v.AddArg(y)
 39485			return true
 39486		}
 39487		// match: (Or64 (Or64 x y) x)
 39488		// cond:
 39489		// result: (Or64 x y)
 39490		for {
 39491			x := v.Args[1]
 39492			v_0 := v.Args[0]
 39493			if v_0.Op != OpOr64 {
 39494				break
 39495			}
 39496			y := v_0.Args[1]
 39497			if x != v_0.Args[0] {
 39498				break
 39499			}
 39500			v.reset(OpOr64)
 39501			v.AddArg(x)
 39502			v.AddArg(y)
 39503			return true
 39504		}
 39505		return false
 39506	}
 39507	func rewriteValuegeneric_OpOr64_10(v *Value) bool {
 39508		b := v.Block
 39509		// match: (Or64 (Or64 y x) x)
 39510		// cond:
 39511		// result: (Or64 x y)
 39512		for {
 39513			x := v.Args[1]
 39514			v_0 := v.Args[0]
 39515			if v_0.Op != OpOr64 {
 39516				break
 39517			}
 39518			_ = v_0.Args[1]
 39519			y := v_0.Args[0]
 39520			if x != v_0.Args[1] {
 39521				break
 39522			}
 39523			v.reset(OpOr64)
 39524			v.AddArg(x)
 39525			v.AddArg(y)
 39526			return true
 39527		}
 39528		// match: (Or64 (And64 x (Const64 [c2])) (Const64 <t> [c1]))
 39529		// cond: ^(c1 | c2) == 0
 39530		// result: (Or64 (Const64 <t> [c1]) x)
 39531		for {
 39532			_ = v.Args[1]
 39533			v_0 := v.Args[0]
 39534			if v_0.Op != OpAnd64 {
 39535				break
 39536			}
 39537			_ = v_0.Args[1]
 39538			x := v_0.Args[0]
 39539			v_0_1 := v_0.Args[1]
 39540			if v_0_1.Op != OpConst64 {
 39541				break
 39542			}
 39543			c2 := v_0_1.AuxInt
 39544			v_1 := v.Args[1]
 39545			if v_1.Op != OpConst64 {
 39546				break
 39547			}
 39548			t := v_1.Type
 39549			c1 := v_1.AuxInt
 39550			if !(^(c1 | c2) == 0) {
 39551				break
 39552			}
 39553			v.reset(OpOr64)
 39554			v0 := b.NewValue0(v.Pos, OpConst64, t)
 39555			v0.AuxInt = c1
 39556			v.AddArg(v0)
 39557			v.AddArg(x)
 39558			return true
 39559		}
 39560		// match: (Or64 (And64 (Const64 [c2]) x) (Const64 <t> [c1]))
 39561		// cond: ^(c1 | c2) == 0
 39562		// result: (Or64 (Const64 <t> [c1]) x)
 39563		for {
 39564			_ = v.Args[1]
 39565			v_0 := v.Args[0]
 39566			if v_0.Op != OpAnd64 {
 39567				break
 39568			}
 39569			x := v_0.Args[1]
 39570			v_0_0 := v_0.Args[0]
 39571			if v_0_0.Op != OpConst64 {
 39572				break
 39573			}
 39574			c2 := v_0_0.AuxInt
 39575			v_1 := v.Args[1]
 39576			if v_1.Op != OpConst64 {
 39577				break
 39578			}
 39579			t := v_1.Type
 39580			c1 := v_1.AuxInt
 39581			if !(^(c1 | c2) == 0) {
 39582				break
 39583			}
 39584			v.reset(OpOr64)
 39585			v0 := b.NewValue0(v.Pos, OpConst64, t)
 39586			v0.AuxInt = c1
 39587			v.AddArg(v0)
 39588			v.AddArg(x)
 39589			return true
 39590		}
 39591		// match: (Or64 (Const64 <t> [c1]) (And64 x (Const64 [c2])))
 39592		// cond: ^(c1 | c2) == 0
 39593		// result: (Or64 (Const64 <t> [c1]) x)
 39594		for {
 39595			_ = v.Args[1]
 39596			v_0 := v.Args[0]
 39597			if v_0.Op != OpConst64 {
 39598				break
 39599			}
 39600			t := v_0.Type
 39601			c1 := v_0.AuxInt
 39602			v_1 := v.Args[1]
 39603			if v_1.Op != OpAnd64 {
 39604				break
 39605			}
 39606			_ = v_1.Args[1]
 39607			x := v_1.Args[0]
 39608			v_1_1 := v_1.Args[1]
 39609			if v_1_1.Op != OpConst64 {
 39610				break
 39611			}
 39612			c2 := v_1_1.AuxInt
 39613			if !(^(c1 | c2) == 0) {
 39614				break
 39615			}
 39616			v.reset(OpOr64)
 39617			v0 := b.NewValue0(v.Pos, OpConst64, t)
 39618			v0.AuxInt = c1
 39619			v.AddArg(v0)
 39620			v.AddArg(x)
 39621			return true
 39622		}
 39623		// match: (Or64 (Const64 <t> [c1]) (And64 (Const64 [c2]) x))
 39624		// cond: ^(c1 | c2) == 0
 39625		// result: (Or64 (Const64 <t> [c1]) x)
 39626		for {
 39627			_ = v.Args[1]
 39628			v_0 := v.Args[0]
 39629			if v_0.Op != OpConst64 {
 39630				break
 39631			}
 39632			t := v_0.Type
 39633			c1 := v_0.AuxInt
 39634			v_1 := v.Args[1]
 39635			if v_1.Op != OpAnd64 {
 39636				break
 39637			}
 39638			x := v_1.Args[1]
 39639			v_1_0 := v_1.Args[0]
 39640			if v_1_0.Op != OpConst64 {
 39641				break
 39642			}
 39643			c2 := v_1_0.AuxInt
 39644			if !(^(c1 | c2) == 0) {
 39645				break
 39646			}
 39647			v.reset(OpOr64)
 39648			v0 := b.NewValue0(v.Pos, OpConst64, t)
 39649			v0.AuxInt = c1
 39650			v.AddArg(v0)
 39651			v.AddArg(x)
 39652			return true
 39653		}
 39654		// match: (Or64 (Or64 i:(Const64 <t>) z) x)
 39655		// cond: (z.Op != OpConst64 && x.Op != OpConst64)
 39656		// result: (Or64 i (Or64 <t> z x))
 39657		for {
 39658			x := v.Args[1]
 39659			v_0 := v.Args[0]
 39660			if v_0.Op != OpOr64 {
 39661				break
 39662			}
 39663			z := v_0.Args[1]
 39664			i := v_0.Args[0]
 39665			if i.Op != OpConst64 {
 39666				break
 39667			}
 39668			t := i.Type
 39669			if !(z.Op != OpConst64 && x.Op != OpConst64) {
 39670				break
 39671			}
 39672			v.reset(OpOr64)
 39673			v.AddArg(i)
 39674			v0 := b.NewValue0(v.Pos, OpOr64, t)
 39675			v0.AddArg(z)
 39676			v0.AddArg(x)
 39677			v.AddArg(v0)
 39678			return true
 39679		}
 39680		// match: (Or64 (Or64 z i:(Const64 <t>)) x)
 39681		// cond: (z.Op != OpConst64 && x.Op != OpConst64)
 39682		// result: (Or64 i (Or64 <t> z x))
 39683		for {
 39684			x := v.Args[1]
 39685			v_0 := v.Args[0]
 39686			if v_0.Op != OpOr64 {
 39687				break
 39688			}
 39689			_ = v_0.Args[1]
 39690			z := v_0.Args[0]
 39691			i := v_0.Args[1]
 39692			if i.Op != OpConst64 {
 39693				break
 39694			}
 39695			t := i.Type
 39696			if !(z.Op != OpConst64 && x.Op != OpConst64) {
 39697				break
 39698			}
 39699			v.reset(OpOr64)
 39700			v.AddArg(i)
 39701			v0 := b.NewValue0(v.Pos, OpOr64, t)
 39702			v0.AddArg(z)
 39703			v0.AddArg(x)
 39704			v.AddArg(v0)
 39705			return true
 39706		}
 39707		// match: (Or64 x (Or64 i:(Const64 <t>) z))
 39708		// cond: (z.Op != OpConst64 && x.Op != OpConst64)
 39709		// result: (Or64 i (Or64 <t> z x))
 39710		for {
 39711			_ = v.Args[1]
 39712			x := v.Args[0]
 39713			v_1 := v.Args[1]
 39714			if v_1.Op != OpOr64 {
 39715				break
 39716			}
 39717			z := v_1.Args[1]
 39718			i := v_1.Args[0]
 39719			if i.Op != OpConst64 {
 39720				break
 39721			}
 39722			t := i.Type
 39723			if !(z.Op != OpConst64 && x.Op != OpConst64) {
 39724				break
 39725			}
 39726			v.reset(OpOr64)
 39727			v.AddArg(i)
 39728			v0 := b.NewValue0(v.Pos, OpOr64, t)
 39729			v0.AddArg(z)
 39730			v0.AddArg(x)
 39731			v.AddArg(v0)
 39732			return true
 39733		}
 39734		// match: (Or64 x (Or64 z i:(Const64 <t>)))
 39735		// cond: (z.Op != OpConst64 && x.Op != OpConst64)
 39736		// result: (Or64 i (Or64 <t> z x))
 39737		for {
 39738			_ = v.Args[1]
 39739			x := v.Args[0]
 39740			v_1 := v.Args[1]
 39741			if v_1.Op != OpOr64 {
 39742				break
 39743			}
 39744			_ = v_1.Args[1]
 39745			z := v_1.Args[0]
 39746			i := v_1.Args[1]
 39747			if i.Op != OpConst64 {
 39748				break
 39749			}
 39750			t := i.Type
 39751			if !(z.Op != OpConst64 && x.Op != OpConst64) {
 39752				break
 39753			}
 39754			v.reset(OpOr64)
 39755			v.AddArg(i)
 39756			v0 := b.NewValue0(v.Pos, OpOr64, t)
 39757			v0.AddArg(z)
 39758			v0.AddArg(x)
 39759			v.AddArg(v0)
 39760			return true
 39761		}
 39762		// match: (Or64 (Const64 <t> [c]) (Or64 (Const64 <t> [d]) x))
 39763		// cond:
 39764		// result: (Or64 (Const64 <t> [c|d]) x)
 39765		for {
 39766			_ = v.Args[1]
 39767			v_0 := v.Args[0]
 39768			if v_0.Op != OpConst64 {
 39769				break
 39770			}
 39771			t := v_0.Type
 39772			c := v_0.AuxInt
 39773			v_1 := v.Args[1]
 39774			if v_1.Op != OpOr64 {
 39775				break
 39776			}
 39777			x := v_1.Args[1]
 39778			v_1_0 := v_1.Args[0]
 39779			if v_1_0.Op != OpConst64 {
 39780				break
 39781			}
 39782			if v_1_0.Type != t {
 39783				break
 39784			}
 39785			d := v_1_0.AuxInt
 39786			v.reset(OpOr64)
 39787			v0 := b.NewValue0(v.Pos, OpConst64, t)
 39788			v0.AuxInt = c | d
 39789			v.AddArg(v0)
 39790			v.AddArg(x)
 39791			return true
 39792		}
 39793		return false
 39794	}
 39795	func rewriteValuegeneric_OpOr64_20(v *Value) bool {
 39796		b := v.Block
 39797		// match: (Or64 (Const64 <t> [c]) (Or64 x (Const64 <t> [d])))
 39798		// cond:
 39799		// result: (Or64 (Const64 <t> [c|d]) x)
 39800		for {
 39801			_ = v.Args[1]
 39802			v_0 := v.Args[0]
 39803			if v_0.Op != OpConst64 {
 39804				break
 39805			}
 39806			t := v_0.Type
 39807			c := v_0.AuxInt
 39808			v_1 := v.Args[1]
 39809			if v_1.Op != OpOr64 {
 39810				break
 39811			}
 39812			_ = v_1.Args[1]
 39813			x := v_1.Args[0]
 39814			v_1_1 := v_1.Args[1]
 39815			if v_1_1.Op != OpConst64 {
 39816				break
 39817			}
 39818			if v_1_1.Type != t {
 39819				break
 39820			}
 39821			d := v_1_1.AuxInt
 39822			v.reset(OpOr64)
 39823			v0 := b.NewValue0(v.Pos, OpConst64, t)
 39824			v0.AuxInt = c | d
 39825			v.AddArg(v0)
 39826			v.AddArg(x)
 39827			return true
 39828		}
 39829		// match: (Or64 (Or64 (Const64 <t> [d]) x) (Const64 <t> [c]))
 39830		// cond:
 39831		// result: (Or64 (Const64 <t> [c|d]) x)
 39832		for {
 39833			_ = v.Args[1]
 39834			v_0 := v.Args[0]
 39835			if v_0.Op != OpOr64 {
 39836				break
 39837			}
 39838			x := v_0.Args[1]
 39839			v_0_0 := v_0.Args[0]
 39840			if v_0_0.Op != OpConst64 {
 39841				break
 39842			}
 39843			t := v_0_0.Type
 39844			d := v_0_0.AuxInt
 39845			v_1 := v.Args[1]
 39846			if v_1.Op != OpConst64 {
 39847				break
 39848			}
 39849			if v_1.Type != t {
 39850				break
 39851			}
 39852			c := v_1.AuxInt
 39853			v.reset(OpOr64)
 39854			v0 := b.NewValue0(v.Pos, OpConst64, t)
 39855			v0.AuxInt = c | d
 39856			v.AddArg(v0)
 39857			v.AddArg(x)
 39858			return true
 39859		}
 39860		// match: (Or64 (Or64 x (Const64 <t> [d])) (Const64 <t> [c]))
 39861		// cond:
 39862		// result: (Or64 (Const64 <t> [c|d]) x)
 39863		for {
 39864			_ = v.Args[1]
 39865			v_0 := v.Args[0]
 39866			if v_0.Op != OpOr64 {
 39867				break
 39868			}
 39869			_ = v_0.Args[1]
 39870			x := v_0.Args[0]
 39871			v_0_1 := v_0.Args[1]
 39872			if v_0_1.Op != OpConst64 {
 39873				break
 39874			}
 39875			t := v_0_1.Type
 39876			d := v_0_1.AuxInt
 39877			v_1 := v.Args[1]
 39878			if v_1.Op != OpConst64 {
 39879				break
 39880			}
 39881			if v_1.Type != t {
 39882				break
 39883			}
 39884			c := v_1.AuxInt
 39885			v.reset(OpOr64)
 39886			v0 := b.NewValue0(v.Pos, OpConst64, t)
 39887			v0.AuxInt = c | d
 39888			v.AddArg(v0)
 39889			v.AddArg(x)
 39890			return true
 39891		}
 39892		return false
 39893	}
 39894	func rewriteValuegeneric_OpOr8_0(v *Value) bool {
 39895		// match: (Or8 (Const8 [c]) (Const8 [d]))
 39896		// cond:
 39897		// result: (Const8 [int64(int8(c|d))])
 39898		for {
 39899			_ = v.Args[1]
 39900			v_0 := v.Args[0]
 39901			if v_0.Op != OpConst8 {
 39902				break
 39903			}
 39904			c := v_0.AuxInt
 39905			v_1 := v.Args[1]
 39906			if v_1.Op != OpConst8 {
 39907				break
 39908			}
 39909			d := v_1.AuxInt
 39910			v.reset(OpConst8)
 39911			v.AuxInt = int64(int8(c | d))
 39912			return true
 39913		}
 39914		// match: (Or8 (Const8 [d]) (Const8 [c]))
 39915		// cond:
 39916		// result: (Const8 [int64(int8(c|d))])
 39917		for {
 39918			_ = v.Args[1]
 39919			v_0 := v.Args[0]
 39920			if v_0.Op != OpConst8 {
 39921				break
 39922			}
 39923			d := v_0.AuxInt
 39924			v_1 := v.Args[1]
 39925			if v_1.Op != OpConst8 {
 39926				break
 39927			}
 39928			c := v_1.AuxInt
 39929			v.reset(OpConst8)
 39930			v.AuxInt = int64(int8(c | d))
 39931			return true
 39932		}
 39933		// match: (Or8 x x)
 39934		// cond:
 39935		// result: x
 39936		for {
 39937			x := v.Args[1]
 39938			if x != v.Args[0] {
 39939				break
 39940			}
 39941			v.reset(OpCopy)
 39942			v.Type = x.Type
 39943			v.AddArg(x)
 39944			return true
 39945		}
 39946		// match: (Or8 (Const8 [0]) x)
 39947		// cond:
 39948		// result: x
 39949		for {
 39950			x := v.Args[1]
 39951			v_0 := v.Args[0]
 39952			if v_0.Op != OpConst8 {
 39953				break
 39954			}
 39955			if v_0.AuxInt != 0 {
 39956				break
 39957			}
 39958			v.reset(OpCopy)
 39959			v.Type = x.Type
 39960			v.AddArg(x)
 39961			return true
 39962		}
 39963		// match: (Or8 x (Const8 [0]))
 39964		// cond:
 39965		// result: x
 39966		for {
 39967			_ = v.Args[1]
 39968			x := v.Args[0]
 39969			v_1 := v.Args[1]
 39970			if v_1.Op != OpConst8 {
 39971				break
 39972			}
 39973			if v_1.AuxInt != 0 {
 39974				break
 39975			}
 39976			v.reset(OpCopy)
 39977			v.Type = x.Type
 39978			v.AddArg(x)
 39979			return true
 39980		}
 39981		// match: (Or8 (Const8 [-1]) _)
 39982		// cond:
 39983		// result: (Const8 [-1])
 39984		for {
 39985			_ = v.Args[1]
 39986			v_0 := v.Args[0]
 39987			if v_0.Op != OpConst8 {
 39988				break
 39989			}
 39990			if v_0.AuxInt != -1 {
 39991				break
 39992			}
 39993			v.reset(OpConst8)
 39994			v.AuxInt = -1
 39995			return true
 39996		}
 39997		// match: (Or8 _ (Const8 [-1]))
 39998		// cond:
 39999		// result: (Const8 [-1])
 40000		for {
 40001			_ = v.Args[1]
 40002			v_1 := v.Args[1]
 40003			if v_1.Op != OpConst8 {
 40004				break
 40005			}
 40006			if v_1.AuxInt != -1 {
 40007				break
 40008			}
 40009			v.reset(OpConst8)
 40010			v.AuxInt = -1
 40011			return true
 40012		}
 40013		// match: (Or8 x (Or8 x y))
 40014		// cond:
 40015		// result: (Or8 x y)
 40016		for {
 40017			_ = v.Args[1]
 40018			x := v.Args[0]
 40019			v_1 := v.Args[1]
 40020			if v_1.Op != OpOr8 {
 40021				break
 40022			}
 40023			y := v_1.Args[1]
 40024			if x != v_1.Args[0] {
 40025				break
 40026			}
 40027			v.reset(OpOr8)
 40028			v.AddArg(x)
 40029			v.AddArg(y)
 40030			return true
 40031		}
 40032		// match: (Or8 x (Or8 y x))
 40033		// cond:
 40034		// result: (Or8 x y)
 40035		for {
 40036			_ = v.Args[1]
 40037			x := v.Args[0]
 40038			v_1 := v.Args[1]
 40039			if v_1.Op != OpOr8 {
 40040				break
 40041			}
 40042			_ = v_1.Args[1]
 40043			y := v_1.Args[0]
 40044			if x != v_1.Args[1] {
 40045				break
 40046			}
 40047			v.reset(OpOr8)
 40048			v.AddArg(x)
 40049			v.AddArg(y)
 40050			return true
 40051		}
 40052		// match: (Or8 (Or8 x y) x)
 40053		// cond:
 40054		// result: (Or8 x y)
 40055		for {
 40056			x := v.Args[1]
 40057			v_0 := v.Args[0]
 40058			if v_0.Op != OpOr8 {
 40059				break
 40060			}
 40061			y := v_0.Args[1]
 40062			if x != v_0.Args[0] {
 40063				break
 40064			}
 40065			v.reset(OpOr8)
 40066			v.AddArg(x)
 40067			v.AddArg(y)
 40068			return true
 40069		}
 40070		return false
 40071	}
 40072	func rewriteValuegeneric_OpOr8_10(v *Value) bool {
 40073		b := v.Block
 40074		// match: (Or8 (Or8 y x) x)
 40075		// cond:
 40076		// result: (Or8 x y)
 40077		for {
 40078			x := v.Args[1]
 40079			v_0 := v.Args[0]
 40080			if v_0.Op != OpOr8 {
 40081				break
 40082			}
 40083			_ = v_0.Args[1]
 40084			y := v_0.Args[0]
 40085			if x != v_0.Args[1] {
 40086				break
 40087			}
 40088			v.reset(OpOr8)
 40089			v.AddArg(x)
 40090			v.AddArg(y)
 40091			return true
 40092		}
 40093		// match: (Or8 (And8 x (Const8 [c2])) (Const8 <t> [c1]))
 40094		// cond: ^(c1 | c2) == 0
 40095		// result: (Or8 (Const8 <t> [c1]) x)
 40096		for {
 40097			_ = v.Args[1]
 40098			v_0 := v.Args[0]
 40099			if v_0.Op != OpAnd8 {
 40100				break
 40101			}
 40102			_ = v_0.Args[1]
 40103			x := v_0.Args[0]
 40104			v_0_1 := v_0.Args[1]
 40105			if v_0_1.Op != OpConst8 {
 40106				break
 40107			}
 40108			c2 := v_0_1.AuxInt
 40109			v_1 := v.Args[1]
 40110			if v_1.Op != OpConst8 {
 40111				break
 40112			}
 40113			t := v_1.Type
 40114			c1 := v_1.AuxInt
 40115			if !(^(c1 | c2) == 0) {
 40116				break
 40117			}
 40118			v.reset(OpOr8)
 40119			v0 := b.NewValue0(v.Pos, OpConst8, t)
 40120			v0.AuxInt = c1
 40121			v.AddArg(v0)
 40122			v.AddArg(x)
 40123			return true
 40124		}
 40125		// match: (Or8 (And8 (Const8 [c2]) x) (Const8 <t> [c1]))
 40126		// cond: ^(c1 | c2) == 0
 40127		// result: (Or8 (Const8 <t> [c1]) x)
 40128		for {
 40129			_ = v.Args[1]
 40130			v_0 := v.Args[0]
 40131			if v_0.Op != OpAnd8 {
 40132				break
 40133			}
 40134			x := v_0.Args[1]
 40135			v_0_0 := v_0.Args[0]
 40136			if v_0_0.Op != OpConst8 {
 40137				break
 40138			}
 40139			c2 := v_0_0.AuxInt
 40140			v_1 := v.Args[1]
 40141			if v_1.Op != OpConst8 {
 40142				break
 40143			}
 40144			t := v_1.Type
 40145			c1 := v_1.AuxInt
 40146			if !(^(c1 | c2) == 0) {
 40147				break
 40148			}
 40149			v.reset(OpOr8)
 40150			v0 := b.NewValue0(v.Pos, OpConst8, t)
 40151			v0.AuxInt = c1
 40152			v.AddArg(v0)
 40153			v.AddArg(x)
 40154			return true
 40155		}
 40156		// match: (Or8 (Const8 <t> [c1]) (And8 x (Const8 [c2])))
 40157		// cond: ^(c1 | c2) == 0
 40158		// result: (Or8 (Const8 <t> [c1]) x)
 40159		for {
 40160			_ = v.Args[1]
 40161			v_0 := v.Args[0]
 40162			if v_0.Op != OpConst8 {
 40163				break
 40164			}
 40165			t := v_0.Type
 40166			c1 := v_0.AuxInt
 40167			v_1 := v.Args[1]
 40168			if v_1.Op != OpAnd8 {
 40169				break
 40170			}
 40171			_ = v_1.Args[1]
 40172			x := v_1.Args[0]
 40173			v_1_1 := v_1.Args[1]
 40174			if v_1_1.Op != OpConst8 {
 40175				break
 40176			}
 40177			c2 := v_1_1.AuxInt
 40178			if !(^(c1 | c2) == 0) {
 40179				break
 40180			}
 40181			v.reset(OpOr8)
 40182			v0 := b.NewValue0(v.Pos, OpConst8, t)
 40183			v0.AuxInt = c1
 40184			v.AddArg(v0)
 40185			v.AddArg(x)
 40186			return true
 40187		}
 40188		// match: (Or8 (Const8 <t> [c1]) (And8 (Const8 [c2]) x))
 40189		// cond: ^(c1 | c2) == 0
 40190		// result: (Or8 (Const8 <t> [c1]) x)
 40191		for {
 40192			_ = v.Args[1]
 40193			v_0 := v.Args[0]
 40194			if v_0.Op != OpConst8 {
 40195				break
 40196			}
 40197			t := v_0.Type
 40198			c1 := v_0.AuxInt
 40199			v_1 := v.Args[1]
 40200			if v_1.Op != OpAnd8 {
 40201				break
 40202			}
 40203			x := v_1.Args[1]
 40204			v_1_0 := v_1.Args[0]
 40205			if v_1_0.Op != OpConst8 {
 40206				break
 40207			}
 40208			c2 := v_1_0.AuxInt
 40209			if !(^(c1 | c2) == 0) {
 40210				break
 40211			}
 40212			v.reset(OpOr8)
 40213			v0 := b.NewValue0(v.Pos, OpConst8, t)
 40214			v0.AuxInt = c1
 40215			v.AddArg(v0)
 40216			v.AddArg(x)
 40217			return true
 40218		}
 40219		// match: (Or8 (Or8 i:(Const8 <t>) z) x)
 40220		// cond: (z.Op != OpConst8 && x.Op != OpConst8)
 40221		// result: (Or8 i (Or8 <t> z x))
 40222		for {
 40223			x := v.Args[1]
 40224			v_0 := v.Args[0]
 40225			if v_0.Op != OpOr8 {
 40226				break
 40227			}
 40228			z := v_0.Args[1]
 40229			i := v_0.Args[0]
 40230			if i.Op != OpConst8 {
 40231				break
 40232			}
 40233			t := i.Type
 40234			if !(z.Op != OpConst8 && x.Op != OpConst8) {
 40235				break
 40236			}
 40237			v.reset(OpOr8)
 40238			v.AddArg(i)
 40239			v0 := b.NewValue0(v.Pos, OpOr8, t)
 40240			v0.AddArg(z)
 40241			v0.AddArg(x)
 40242			v.AddArg(v0)
 40243			return true
 40244		}
 40245		// match: (Or8 (Or8 z i:(Const8 <t>)) x)
 40246		// cond: (z.Op != OpConst8 && x.Op != OpConst8)
 40247		// result: (Or8 i (Or8 <t> z x))
 40248		for {
 40249			x := v.Args[1]
 40250			v_0 := v.Args[0]
 40251			if v_0.Op != OpOr8 {
 40252				break
 40253			}
 40254			_ = v_0.Args[1]
 40255			z := v_0.Args[0]
 40256			i := v_0.Args[1]
 40257			if i.Op != OpConst8 {
 40258				break
 40259			}
 40260			t := i.Type
 40261			if !(z.Op != OpConst8 && x.Op != OpConst8) {
 40262				break
 40263			}
 40264			v.reset(OpOr8)
 40265			v.AddArg(i)
 40266			v0 := b.NewValue0(v.Pos, OpOr8, t)
 40267			v0.AddArg(z)
 40268			v0.AddArg(x)
 40269			v.AddArg(v0)
 40270			return true
 40271		}
 40272		// match: (Or8 x (Or8 i:(Const8 <t>) z))
 40273		// cond: (z.Op != OpConst8 && x.Op != OpConst8)
 40274		// result: (Or8 i (Or8 <t> z x))
 40275		for {
 40276			_ = v.Args[1]
 40277			x := v.Args[0]
 40278			v_1 := v.Args[1]
 40279			if v_1.Op != OpOr8 {
 40280				break
 40281			}
 40282			z := v_1.Args[1]
 40283			i := v_1.Args[0]
 40284			if i.Op != OpConst8 {
 40285				break
 40286			}
 40287			t := i.Type
 40288			if !(z.Op != OpConst8 && x.Op != OpConst8) {
 40289				break
 40290			}
 40291			v.reset(OpOr8)
 40292			v.AddArg(i)
 40293			v0 := b.NewValue0(v.Pos, OpOr8, t)
 40294			v0.AddArg(z)
 40295			v0.AddArg(x)
 40296			v.AddArg(v0)
 40297			return true
 40298		}
 40299		// match: (Or8 x (Or8 z i:(Const8 <t>)))
 40300		// cond: (z.Op != OpConst8 && x.Op != OpConst8)
 40301		// result: (Or8 i (Or8 <t> z x))
 40302		for {
 40303			_ = v.Args[1]
 40304			x := v.Args[0]
 40305			v_1 := v.Args[1]
 40306			if v_1.Op != OpOr8 {
 40307				break
 40308			}
 40309			_ = v_1.Args[1]
 40310			z := v_1.Args[0]
 40311			i := v_1.Args[1]
 40312			if i.Op != OpConst8 {
 40313				break
 40314			}
 40315			t := i.Type
 40316			if !(z.Op != OpConst8 && x.Op != OpConst8) {
 40317				break
 40318			}
 40319			v.reset(OpOr8)
 40320			v.AddArg(i)
 40321			v0 := b.NewValue0(v.Pos, OpOr8, t)
 40322			v0.AddArg(z)
 40323			v0.AddArg(x)
 40324			v.AddArg(v0)
 40325			return true
 40326		}
 40327		// match: (Or8 (Const8 <t> [c]) (Or8 (Const8 <t> [d]) x))
 40328		// cond:
 40329		// result: (Or8 (Const8 <t> [int64(int8(c|d))]) x)
 40330		for {
 40331			_ = v.Args[1]
 40332			v_0 := v.Args[0]
 40333			if v_0.Op != OpConst8 {
 40334				break
 40335			}
 40336			t := v_0.Type
 40337			c := v_0.AuxInt
 40338			v_1 := v.Args[1]
 40339			if v_1.Op != OpOr8 {
 40340				break
 40341			}
 40342			x := v_1.Args[1]
 40343			v_1_0 := v_1.Args[0]
 40344			if v_1_0.Op != OpConst8 {
 40345				break
 40346			}
 40347			if v_1_0.Type != t {
 40348				break
 40349			}
 40350			d := v_1_0.AuxInt
 40351			v.reset(OpOr8)
 40352			v0 := b.NewValue0(v.Pos, OpConst8, t)
 40353			v0.AuxInt = int64(int8(c | d))
 40354			v.AddArg(v0)
 40355			v.AddArg(x)
 40356			return true
 40357		}
 40358		return false
 40359	}
 40360	func rewriteValuegeneric_OpOr8_20(v *Value) bool {
 40361		b := v.Block
 40362		// match: (Or8 (Const8 <t> [c]) (Or8 x (Const8 <t> [d])))
 40363		// cond:
 40364		// result: (Or8 (Const8 <t> [int64(int8(c|d))]) x)
 40365		for {
 40366			_ = v.Args[1]
 40367			v_0 := v.Args[0]
 40368			if v_0.Op != OpConst8 {
 40369				break
 40370			}
 40371			t := v_0.Type
 40372			c := v_0.AuxInt
 40373			v_1 := v.Args[1]
 40374			if v_1.Op != OpOr8 {
 40375				break
 40376			}
 40377			_ = v_1.Args[1]
 40378			x := v_1.Args[0]
 40379			v_1_1 := v_1.Args[1]
 40380			if v_1_1.Op != OpConst8 {
 40381				break
 40382			}
 40383			if v_1_1.Type != t {
 40384				break
 40385			}
 40386			d := v_1_1.AuxInt
 40387			v.reset(OpOr8)
 40388			v0 := b.NewValue0(v.Pos, OpConst8, t)
 40389			v0.AuxInt = int64(int8(c | d))
 40390			v.AddArg(v0)
 40391			v.AddArg(x)
 40392			return true
 40393		}
 40394		// match: (Or8 (Or8 (Const8 <t> [d]) x) (Const8 <t> [c]))
 40395		// cond:
 40396		// result: (Or8 (Const8 <t> [int64(int8(c|d))]) x)
 40397		for {
 40398			_ = v.Args[1]
 40399			v_0 := v.Args[0]
 40400			if v_0.Op != OpOr8 {
 40401				break
 40402			}
 40403			x := v_0.Args[1]
 40404			v_0_0 := v_0.Args[0]
 40405			if v_0_0.Op != OpConst8 {
 40406				break
 40407			}
 40408			t := v_0_0.Type
 40409			d := v_0_0.AuxInt
 40410			v_1 := v.Args[1]
 40411			if v_1.Op != OpConst8 {
 40412				break
 40413			}
 40414			if v_1.Type != t {
 40415				break
 40416			}
 40417			c := v_1.AuxInt
 40418			v.reset(OpOr8)
 40419			v0 := b.NewValue0(v.Pos, OpConst8, t)
 40420			v0.AuxInt = int64(int8(c | d))
 40421			v.AddArg(v0)
 40422			v.AddArg(x)
 40423			return true
 40424		}
 40425		// match: (Or8 (Or8 x (Const8 <t> [d])) (Const8 <t> [c]))
 40426		// cond:
 40427		// result: (Or8 (Const8 <t> [int64(int8(c|d))]) x)
 40428		for {
 40429			_ = v.Args[1]
 40430			v_0 := v.Args[0]
 40431			if v_0.Op != OpOr8 {
 40432				break
 40433			}
 40434			_ = v_0.Args[1]
 40435			x := v_0.Args[0]
 40436			v_0_1 := v_0.Args[1]
 40437			if v_0_1.Op != OpConst8 {
 40438				break
 40439			}
 40440			t := v_0_1.Type
 40441			d := v_0_1.AuxInt
 40442			v_1 := v.Args[1]
 40443			if v_1.Op != OpConst8 {
 40444				break
 40445			}
 40446			if v_1.Type != t {
 40447				break
 40448			}
 40449			c := v_1.AuxInt
 40450			v.reset(OpOr8)
 40451			v0 := b.NewValue0(v.Pos, OpConst8, t)
 40452			v0.AuxInt = int64(int8(c | d))
 40453			v.AddArg(v0)
 40454			v.AddArg(x)
 40455			return true
 40456		}
 40457		return false
 40458	}
 40459	func rewriteValuegeneric_OpPhi_0(v *Value) bool {
 40460		// match: (Phi (Const8 [c]) (Const8 [c]))
 40461		// cond:
 40462		// result: (Const8 [c])
 40463		for {
 40464			_ = v.Args[1]
 40465			v_0 := v.Args[0]
 40466			if v_0.Op != OpConst8 {
 40467				break
 40468			}
 40469			c := v_0.AuxInt
 40470			v_1 := v.Args[1]
 40471			if v_1.Op != OpConst8 {
 40472				break
 40473			}
 40474			if v_1.AuxInt != c {
 40475				break
 40476			}
 40477			if len(v.Args) != 2 {
 40478				break
 40479			}
 40480			v.reset(OpConst8)
 40481			v.AuxInt = c
 40482			return true
 40483		}
 40484		// match: (Phi (Const16 [c]) (Const16 [c]))
 40485		// cond:
 40486		// result: (Const16 [c])
 40487		for {
 40488			_ = v.Args[1]
 40489			v_0 := v.Args[0]
 40490			if v_0.Op != OpConst16 {
 40491				break
 40492			}
 40493			c := v_0.AuxInt
 40494			v_1 := v.Args[1]
 40495			if v_1.Op != OpConst16 {
 40496				break
 40497			}
 40498			if v_1.AuxInt != c {
 40499				break
 40500			}
 40501			if len(v.Args) != 2 {
 40502				break
 40503			}
 40504			v.reset(OpConst16)
 40505			v.AuxInt = c
 40506			return true
 40507		}
 40508		// match: (Phi (Const32 [c]) (Const32 [c]))
 40509		// cond:
 40510		// result: (Const32 [c])
 40511		for {
 40512			_ = v.Args[1]
 40513			v_0 := v.Args[0]
 40514			if v_0.Op != OpConst32 {
 40515				break
 40516			}
 40517			c := v_0.AuxInt
 40518			v_1 := v.Args[1]
 40519			if v_1.Op != OpConst32 {
 40520				break
 40521			}
 40522			if v_1.AuxInt != c {
 40523				break
 40524			}
 40525			if len(v.Args) != 2 {
 40526				break
 40527			}
 40528			v.reset(OpConst32)
 40529			v.AuxInt = c
 40530			return true
 40531		}
 40532		// match: (Phi (Const64 [c]) (Const64 [c]))
 40533		// cond:
 40534		// result: (Const64 [c])
 40535		for {
 40536			_ = v.Args[1]
 40537			v_0 := v.Args[0]
 40538			if v_0.Op != OpConst64 {
 40539				break
 40540			}
 40541			c := v_0.AuxInt
 40542			v_1 := v.Args[1]
 40543			if v_1.Op != OpConst64 {
 40544				break
 40545			}
 40546			if v_1.AuxInt != c {
 40547				break
 40548			}
 40549			if len(v.Args) != 2 {
 40550				break
 40551			}
 40552			v.reset(OpConst64)
 40553			v.AuxInt = c
 40554			return true
 40555		}
 40556		return false
 40557	}
 40558	func rewriteValuegeneric_OpPtrIndex_0(v *Value) bool {
 40559		b := v.Block
 40560		config := b.Func.Config
 40561		typ := &b.Func.Config.Types
 40562		// match: (PtrIndex <t> ptr idx)
 40563		// cond: config.PtrSize == 4
 40564		// result: (AddPtr ptr (Mul32 <typ.Int> idx (Const32 <typ.Int> [t.Elem().Size()])))
 40565		for {
 40566			t := v.Type
 40567			idx := v.Args[1]
 40568			ptr := v.Args[0]
 40569			if !(config.PtrSize == 4) {
 40570				break
 40571			}
 40572			v.reset(OpAddPtr)
 40573			v.AddArg(ptr)
 40574			v0 := b.NewValue0(v.Pos, OpMul32, typ.Int)
 40575			v0.AddArg(idx)
 40576			v1 := b.NewValue0(v.Pos, OpConst32, typ.Int)
 40577			v1.AuxInt = t.Elem().Size()
 40578			v0.AddArg(v1)
 40579			v.AddArg(v0)
 40580			return true
 40581		}
 40582		// match: (PtrIndex <t> ptr idx)
 40583		// cond: config.PtrSize == 8
 40584		// result: (AddPtr ptr (Mul64 <typ.Int> idx (Const64 <typ.Int> [t.Elem().Size()])))
 40585		for {
 40586			t := v.Type
 40587			idx := v.Args[1]
 40588			ptr := v.Args[0]
 40589			if !(config.PtrSize == 8) {
 40590				break
 40591			}
 40592			v.reset(OpAddPtr)
 40593			v.AddArg(ptr)
 40594			v0 := b.NewValue0(v.Pos, OpMul64, typ.Int)
 40595			v0.AddArg(idx)
 40596			v1 := b.NewValue0(v.Pos, OpConst64, typ.Int)
 40597			v1.AuxInt = t.Elem().Size()
 40598			v0.AddArg(v1)
 40599			v.AddArg(v0)
 40600			return true
 40601		}
 40602		return false
 40603	}
 40604	func rewriteValuegeneric_OpRotateLeft16_0(v *Value) bool {
 40605		// match: (RotateLeft16 x (Const16 [c]))
 40606		// cond: c%16 == 0
 40607		// result: x
 40608		for {
 40609			_ = v.Args[1]
 40610			x := v.Args[0]
 40611			v_1 := v.Args[1]
 40612			if v_1.Op != OpConst16 {
 40613				break
 40614			}
 40615			c := v_1.AuxInt
 40616			if !(c%16 == 0) {
 40617				break
 40618			}
 40619			v.reset(OpCopy)
 40620			v.Type = x.Type
 40621			v.AddArg(x)
 40622			return true
 40623		}
 40624		return false
 40625	}
 40626	func rewriteValuegeneric_OpRotateLeft32_0(v *Value) bool {
 40627		// match: (RotateLeft32 x (Const32 [c]))
 40628		// cond: c%32 == 0
 40629		// result: x
 40630		for {
 40631			_ = v.Args[1]
 40632			x := v.Args[0]
 40633			v_1 := v.Args[1]
 40634			if v_1.Op != OpConst32 {
 40635				break
 40636			}
 40637			c := v_1.AuxInt
 40638			if !(c%32 == 0) {
 40639				break
 40640			}
 40641			v.reset(OpCopy)
 40642			v.Type = x.Type
 40643			v.AddArg(x)
 40644			return true
 40645		}
 40646		return false
 40647	}
 40648	func rewriteValuegeneric_OpRotateLeft64_0(v *Value) bool {
 40649		// match: (RotateLeft64 x (Const64 [c]))
 40650		// cond: c%64 == 0
 40651		// result: x
 40652		for {
 40653			_ = v.Args[1]
 40654			x := v.Args[0]
 40655			v_1 := v.Args[1]
 40656			if v_1.Op != OpConst64 {
 40657				break
 40658			}
 40659			c := v_1.AuxInt
 40660			if !(c%64 == 0) {
 40661				break
 40662			}
 40663			v.reset(OpCopy)
 40664			v.Type = x.Type
 40665			v.AddArg(x)
 40666			return true
 40667		}
 40668		return false
 40669	}
 40670	func rewriteValuegeneric_OpRotateLeft8_0(v *Value) bool {
 40671		// match: (RotateLeft8 x (Const8 [c]))
 40672		// cond: c%8 == 0
 40673		// result: x
 40674		for {
 40675			_ = v.Args[1]
 40676			x := v.Args[0]
 40677			v_1 := v.Args[1]
 40678			if v_1.Op != OpConst8 {
 40679				break
 40680			}
 40681			c := v_1.AuxInt
 40682			if !(c%8 == 0) {
 40683				break
 40684			}
 40685			v.reset(OpCopy)
 40686			v.Type = x.Type
 40687			v.AddArg(x)
 40688			return true
 40689		}
 40690		return false
 40691	}
 40692	func rewriteValuegeneric_OpRound32F_0(v *Value) bool {
 40693		// match: (Round32F x:(Const32F))
 40694		// cond:
 40695		// result: x
 40696		for {
 40697			x := v.Args[0]
 40698			if x.Op != OpConst32F {
 40699				break
 40700			}
 40701			v.reset(OpCopy)
 40702			v.Type = x.Type
 40703			v.AddArg(x)
 40704			return true
 40705		}
 40706		return false
 40707	}
 40708	func rewriteValuegeneric_OpRound64F_0(v *Value) bool {
 40709		// match: (Round64F x:(Const64F))
 40710		// cond:
 40711		// result: x
 40712		for {
 40713			x := v.Args[0]
 40714			if x.Op != OpConst64F {
 40715				break
 40716			}
 40717			v.reset(OpCopy)
 40718			v.Type = x.Type
 40719			v.AddArg(x)
 40720			return true
 40721		}
 40722		return false
 40723	}
 40724	func rewriteValuegeneric_OpRsh16Ux16_0(v *Value) bool {
 40725		b := v.Block
 40726		// match: (Rsh16Ux16 <t> x (Const16 [c]))
 40727		// cond:
 40728		// result: (Rsh16Ux64 x (Const64 <t> [int64(uint16(c))]))
 40729		for {
 40730			t := v.Type
 40731			_ = v.Args[1]
 40732			x := v.Args[0]
 40733			v_1 := v.Args[1]
 40734			if v_1.Op != OpConst16 {
 40735				break
 40736			}
 40737			c := v_1.AuxInt
 40738			v.reset(OpRsh16Ux64)
 40739			v.AddArg(x)
 40740			v0 := b.NewValue0(v.Pos, OpConst64, t)
 40741			v0.AuxInt = int64(uint16(c))
 40742			v.AddArg(v0)
 40743			return true
 40744		}
 40745		// match: (Rsh16Ux16 (Const16 [0]) _)
 40746		// cond:
 40747		// result: (Const16 [0])
 40748		for {
 40749			_ = v.Args[1]
 40750			v_0 := v.Args[0]
 40751			if v_0.Op != OpConst16 {
 40752				break
 40753			}
 40754			if v_0.AuxInt != 0 {
 40755				break
 40756			}
 40757			v.reset(OpConst16)
 40758			v.AuxInt = 0
 40759			return true
 40760		}
 40761		return false
 40762	}
 40763	func rewriteValuegeneric_OpRsh16Ux32_0(v *Value) bool {
 40764		b := v.Block
 40765		// match: (Rsh16Ux32 <t> x (Const32 [c]))
 40766		// cond:
 40767		// result: (Rsh16Ux64 x (Const64 <t> [int64(uint32(c))]))
 40768		for {
 40769			t := v.Type
 40770			_ = v.Args[1]
 40771			x := v.Args[0]
 40772			v_1 := v.Args[1]
 40773			if v_1.Op != OpConst32 {
 40774				break
 40775			}
 40776			c := v_1.AuxInt
 40777			v.reset(OpRsh16Ux64)
 40778			v.AddArg(x)
 40779			v0 := b.NewValue0(v.Pos, OpConst64, t)
 40780			v0.AuxInt = int64(uint32(c))
 40781			v.AddArg(v0)
 40782			return true
 40783		}
 40784		// match: (Rsh16Ux32 (Const16 [0]) _)
 40785		// cond:
 40786		// result: (Const16 [0])
 40787		for {
 40788			_ = v.Args[1]
 40789			v_0 := v.Args[0]
 40790			if v_0.Op != OpConst16 {
 40791				break
 40792			}
 40793			if v_0.AuxInt != 0 {
 40794				break
 40795			}
 40796			v.reset(OpConst16)
 40797			v.AuxInt = 0
 40798			return true
 40799		}
 40800		return false
 40801	}
 40802	func rewriteValuegeneric_OpRsh16Ux64_0(v *Value) bool {
 40803		b := v.Block
 40804		typ := &b.Func.Config.Types
 40805		// match: (Rsh16Ux64 (Const16 [c]) (Const64 [d]))
 40806		// cond:
 40807		// result: (Const16 [int64(int16(uint16(c) >> uint64(d)))])
 40808		for {
 40809			_ = v.Args[1]
 40810			v_0 := v.Args[0]
 40811			if v_0.Op != OpConst16 {
 40812				break
 40813			}
 40814			c := v_0.AuxInt
 40815			v_1 := v.Args[1]
 40816			if v_1.Op != OpConst64 {
 40817				break
 40818			}
 40819			d := v_1.AuxInt
 40820			v.reset(OpConst16)
 40821			v.AuxInt = int64(int16(uint16(c) >> uint64(d)))
 40822			return true
 40823		}
 40824		// match: (Rsh16Ux64 x (Const64 [0]))
 40825		// cond:
 40826		// result: x
 40827		for {
 40828			_ = v.Args[1]
 40829			x := v.Args[0]
 40830			v_1 := v.Args[1]
 40831			if v_1.Op != OpConst64 {
 40832				break
 40833			}
 40834			if v_1.AuxInt != 0 {
 40835				break
 40836			}
 40837			v.reset(OpCopy)
 40838			v.Type = x.Type
 40839			v.AddArg(x)
 40840			return true
 40841		}
 40842		// match: (Rsh16Ux64 (Const16 [0]) _)
 40843		// cond:
 40844		// result: (Const16 [0])
 40845		for {
 40846			_ = v.Args[1]
 40847			v_0 := v.Args[0]
 40848			if v_0.Op != OpConst16 {
 40849				break
 40850			}
 40851			if v_0.AuxInt != 0 {
 40852				break
 40853			}
 40854			v.reset(OpConst16)
 40855			v.AuxInt = 0
 40856			return true
 40857		}
 40858		// match: (Rsh16Ux64 _ (Const64 [c]))
 40859		// cond: uint64(c) >= 16
 40860		// result: (Const16 [0])
 40861		for {
 40862			_ = v.Args[1]
 40863			v_1 := v.Args[1]
 40864			if v_1.Op != OpConst64 {
 40865				break
 40866			}
 40867			c := v_1.AuxInt
 40868			if !(uint64(c) >= 16) {
 40869				break
 40870			}
 40871			v.reset(OpConst16)
 40872			v.AuxInt = 0
 40873			return true
 40874		}
 40875		// match: (Rsh16Ux64 <t> (Rsh16Ux64 x (Const64 [c])) (Const64 [d]))
 40876		// cond: !uaddOvf(c,d)
 40877		// result: (Rsh16Ux64 x (Const64 <t> [c+d]))
 40878		for {
 40879			t := v.Type
 40880			_ = v.Args[1]
 40881			v_0 := v.Args[0]
 40882			if v_0.Op != OpRsh16Ux64 {
 40883				break
 40884			}
 40885			_ = v_0.Args[1]
 40886			x := v_0.Args[0]
 40887			v_0_1 := v_0.Args[1]
 40888			if v_0_1.Op != OpConst64 {
 40889				break
 40890			}
 40891			c := v_0_1.AuxInt
 40892			v_1 := v.Args[1]
 40893			if v_1.Op != OpConst64 {
 40894				break
 40895			}
 40896			d := v_1.AuxInt
 40897			if !(!uaddOvf(c, d)) {
 40898				break
 40899			}
 40900			v.reset(OpRsh16Ux64)
 40901			v.AddArg(x)
 40902			v0 := b.NewValue0(v.Pos, OpConst64, t)
 40903			v0.AuxInt = c + d
 40904			v.AddArg(v0)
 40905			return true
 40906		}
 40907		// match: (Rsh16Ux64 (Rsh16x64 x _) (Const64 <t> [15]))
 40908		// cond:
 40909		// result: (Rsh16Ux64 x (Const64 <t> [15]))
 40910		for {
 40911			_ = v.Args[1]
 40912			v_0 := v.Args[0]
 40913			if v_0.Op != OpRsh16x64 {
 40914				break
 40915			}
 40916			_ = v_0.Args[1]
 40917			x := v_0.Args[0]
 40918			v_1 := v.Args[1]
 40919			if v_1.Op != OpConst64 {
 40920				break
 40921			}
 40922			t := v_1.Type
 40923			if v_1.AuxInt != 15 {
 40924				break
 40925			}
 40926			v.reset(OpRsh16Ux64)
 40927			v.AddArg(x)
 40928			v0 := b.NewValue0(v.Pos, OpConst64, t)
 40929			v0.AuxInt = 15
 40930			v.AddArg(v0)
 40931			return true
 40932		}
 40933		// match: (Rsh16Ux64 (Lsh16x64 (Rsh16Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
 40934		// cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
 40935		// result: (Rsh16Ux64 x (Const64 <typ.UInt64> [c1-c2+c3]))
 40936		for {
 40937			_ = v.Args[1]
 40938			v_0 := v.Args[0]
 40939			if v_0.Op != OpLsh16x64 {
 40940				break
 40941			}
 40942			_ = v_0.Args[1]
 40943			v_0_0 := v_0.Args[0]
 40944			if v_0_0.Op != OpRsh16Ux64 {
 40945				break
 40946			}
 40947			_ = v_0_0.Args[1]
 40948			x := v_0_0.Args[0]
 40949			v_0_0_1 := v_0_0.Args[1]
 40950			if v_0_0_1.Op != OpConst64 {
 40951				break
 40952			}
 40953			c1 := v_0_0_1.AuxInt
 40954			v_0_1 := v_0.Args[1]
 40955			if v_0_1.Op != OpConst64 {
 40956				break
 40957			}
 40958			c2 := v_0_1.AuxInt
 40959			v_1 := v.Args[1]
 40960			if v_1.Op != OpConst64 {
 40961				break
 40962			}
 40963			c3 := v_1.AuxInt
 40964			if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) {
 40965				break
 40966			}
 40967			v.reset(OpRsh16Ux64)
 40968			v.AddArg(x)
 40969			v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 40970			v0.AuxInt = c1 - c2 + c3
 40971			v.AddArg(v0)
 40972			return true
 40973		}
 40974		// match: (Rsh16Ux64 (Lsh16x64 x (Const64 [8])) (Const64 [8]))
 40975		// cond:
 40976		// result: (ZeroExt8to16 (Trunc16to8 <typ.UInt8> x))
 40977		for {
 40978			_ = v.Args[1]
 40979			v_0 := v.Args[0]
 40980			if v_0.Op != OpLsh16x64 {
 40981				break
 40982			}
 40983			_ = v_0.Args[1]
 40984			x := v_0.Args[0]
 40985			v_0_1 := v_0.Args[1]
 40986			if v_0_1.Op != OpConst64 {
 40987				break
 40988			}
 40989			if v_0_1.AuxInt != 8 {
 40990				break
 40991			}
 40992			v_1 := v.Args[1]
 40993			if v_1.Op != OpConst64 {
 40994				break
 40995			}
 40996			if v_1.AuxInt != 8 {
 40997				break
 40998			}
 40999			v.reset(OpZeroExt8to16)
 41000			v0 := b.NewValue0(v.Pos, OpTrunc16to8, typ.UInt8)
 41001			v0.AddArg(x)
 41002			v.AddArg(v0)
 41003			return true
 41004		}
 41005		return false
 41006	}
 41007	func rewriteValuegeneric_OpRsh16Ux8_0(v *Value) bool {
 41008		b := v.Block
 41009		// match: (Rsh16Ux8 <t> x (Const8 [c]))
 41010		// cond:
 41011		// result: (Rsh16Ux64 x (Const64 <t> [int64(uint8(c))]))
 41012		for {
 41013			t := v.Type
 41014			_ = v.Args[1]
 41015			x := v.Args[0]
 41016			v_1 := v.Args[1]
 41017			if v_1.Op != OpConst8 {
 41018				break
 41019			}
 41020			c := v_1.AuxInt
 41021			v.reset(OpRsh16Ux64)
 41022			v.AddArg(x)
 41023			v0 := b.NewValue0(v.Pos, OpConst64, t)
 41024			v0.AuxInt = int64(uint8(c))
 41025			v.AddArg(v0)
 41026			return true
 41027		}
 41028		// match: (Rsh16Ux8 (Const16 [0]) _)
 41029		// cond:
 41030		// result: (Const16 [0])
 41031		for {
 41032			_ = v.Args[1]
 41033			v_0 := v.Args[0]
 41034			if v_0.Op != OpConst16 {
 41035				break
 41036			}
 41037			if v_0.AuxInt != 0 {
 41038				break
 41039			}
 41040			v.reset(OpConst16)
 41041			v.AuxInt = 0
 41042			return true
 41043		}
 41044		return false
 41045	}
 41046	func rewriteValuegeneric_OpRsh16x16_0(v *Value) bool {
 41047		b := v.Block
 41048		// match: (Rsh16x16 <t> x (Const16 [c]))
 41049		// cond:
 41050		// result: (Rsh16x64 x (Const64 <t> [int64(uint16(c))]))
 41051		for {
 41052			t := v.Type
 41053			_ = v.Args[1]
 41054			x := v.Args[0]
 41055			v_1 := v.Args[1]
 41056			if v_1.Op != OpConst16 {
 41057				break
 41058			}
 41059			c := v_1.AuxInt
 41060			v.reset(OpRsh16x64)
 41061			v.AddArg(x)
 41062			v0 := b.NewValue0(v.Pos, OpConst64, t)
 41063			v0.AuxInt = int64(uint16(c))
 41064			v.AddArg(v0)
 41065			return true
 41066		}
 41067		// match: (Rsh16x16 (Const16 [0]) _)
 41068		// cond:
 41069		// result: (Const16 [0])
 41070		for {
 41071			_ = v.Args[1]
 41072			v_0 := v.Args[0]
 41073			if v_0.Op != OpConst16 {
 41074				break
 41075			}
 41076			if v_0.AuxInt != 0 {
 41077				break
 41078			}
 41079			v.reset(OpConst16)
 41080			v.AuxInt = 0
 41081			return true
 41082		}
 41083		return false
 41084	}
 41085	func rewriteValuegeneric_OpRsh16x32_0(v *Value) bool {
 41086		b := v.Block
 41087		// match: (Rsh16x32 <t> x (Const32 [c]))
 41088		// cond:
 41089		// result: (Rsh16x64 x (Const64 <t> [int64(uint32(c))]))
 41090		for {
 41091			t := v.Type
 41092			_ = v.Args[1]
 41093			x := v.Args[0]
 41094			v_1 := v.Args[1]
 41095			if v_1.Op != OpConst32 {
 41096				break
 41097			}
 41098			c := v_1.AuxInt
 41099			v.reset(OpRsh16x64)
 41100			v.AddArg(x)
 41101			v0 := b.NewValue0(v.Pos, OpConst64, t)
 41102			v0.AuxInt = int64(uint32(c))
 41103			v.AddArg(v0)
 41104			return true
 41105		}
 41106		// match: (Rsh16x32 (Const16 [0]) _)
 41107		// cond:
 41108		// result: (Const16 [0])
 41109		for {
 41110			_ = v.Args[1]
 41111			v_0 := v.Args[0]
 41112			if v_0.Op != OpConst16 {
 41113				break
 41114			}
 41115			if v_0.AuxInt != 0 {
 41116				break
 41117			}
 41118			v.reset(OpConst16)
 41119			v.AuxInt = 0
 41120			return true
 41121		}
 41122		return false
 41123	}
 41124	func rewriteValuegeneric_OpRsh16x64_0(v *Value) bool {
 41125		b := v.Block
 41126		typ := &b.Func.Config.Types
 41127		// match: (Rsh16x64 (Const16 [c]) (Const64 [d]))
 41128		// cond:
 41129		// result: (Const16 [int64(int16(c) >> uint64(d))])
 41130		for {
 41131			_ = v.Args[1]
 41132			v_0 := v.Args[0]
 41133			if v_0.Op != OpConst16 {
 41134				break
 41135			}
 41136			c := v_0.AuxInt
 41137			v_1 := v.Args[1]
 41138			if v_1.Op != OpConst64 {
 41139				break
 41140			}
 41141			d := v_1.AuxInt
 41142			v.reset(OpConst16)
 41143			v.AuxInt = int64(int16(c) >> uint64(d))
 41144			return true
 41145		}
 41146		// match: (Rsh16x64 x (Const64 [0]))
 41147		// cond:
 41148		// result: x
 41149		for {
 41150			_ = v.Args[1]
 41151			x := v.Args[0]
 41152			v_1 := v.Args[1]
 41153			if v_1.Op != OpConst64 {
 41154				break
 41155			}
 41156			if v_1.AuxInt != 0 {
 41157				break
 41158			}
 41159			v.reset(OpCopy)
 41160			v.Type = x.Type
 41161			v.AddArg(x)
 41162			return true
 41163		}
 41164		// match: (Rsh16x64 (Const16 [0]) _)
 41165		// cond:
 41166		// result: (Const16 [0])
 41167		for {
 41168			_ = v.Args[1]
 41169			v_0 := v.Args[0]
 41170			if v_0.Op != OpConst16 {
 41171				break
 41172			}
 41173			if v_0.AuxInt != 0 {
 41174				break
 41175			}
 41176			v.reset(OpConst16)
 41177			v.AuxInt = 0
 41178			return true
 41179		}
 41180		// match: (Rsh16x64 <t> (Rsh16x64 x (Const64 [c])) (Const64 [d]))
 41181		// cond: !uaddOvf(c,d)
 41182		// result: (Rsh16x64 x (Const64 <t> [c+d]))
 41183		for {
 41184			t := v.Type
 41185			_ = v.Args[1]
 41186			v_0 := v.Args[0]
 41187			if v_0.Op != OpRsh16x64 {
 41188				break
 41189			}
 41190			_ = v_0.Args[1]
 41191			x := v_0.Args[0]
 41192			v_0_1 := v_0.Args[1]
 41193			if v_0_1.Op != OpConst64 {
 41194				break
 41195			}
 41196			c := v_0_1.AuxInt
 41197			v_1 := v.Args[1]
 41198			if v_1.Op != OpConst64 {
 41199				break
 41200			}
 41201			d := v_1.AuxInt
 41202			if !(!uaddOvf(c, d)) {
 41203				break
 41204			}
 41205			v.reset(OpRsh16x64)
 41206			v.AddArg(x)
 41207			v0 := b.NewValue0(v.Pos, OpConst64, t)
 41208			v0.AuxInt = c + d
 41209			v.AddArg(v0)
 41210			return true
 41211		}
 41212		// match: (Rsh16x64 (Lsh16x64 x (Const64 [8])) (Const64 [8]))
 41213		// cond:
 41214		// result: (SignExt8to16 (Trunc16to8 <typ.Int8> x))
 41215		for {
 41216			_ = v.Args[1]
 41217			v_0 := v.Args[0]
 41218			if v_0.Op != OpLsh16x64 {
 41219				break
 41220			}
 41221			_ = v_0.Args[1]
 41222			x := v_0.Args[0]
 41223			v_0_1 := v_0.Args[1]
 41224			if v_0_1.Op != OpConst64 {
 41225				break
 41226			}
 41227			if v_0_1.AuxInt != 8 {
 41228				break
 41229			}
 41230			v_1 := v.Args[1]
 41231			if v_1.Op != OpConst64 {
 41232				break
 41233			}
 41234			if v_1.AuxInt != 8 {
 41235				break
 41236			}
 41237			v.reset(OpSignExt8to16)
 41238			v0 := b.NewValue0(v.Pos, OpTrunc16to8, typ.Int8)
 41239			v0.AddArg(x)
 41240			v.AddArg(v0)
 41241			return true
 41242		}
 41243		return false
 41244	}
 41245	func rewriteValuegeneric_OpRsh16x8_0(v *Value) bool {
 41246		b := v.Block
 41247		// match: (Rsh16x8 <t> x (Const8 [c]))
 41248		// cond:
 41249		// result: (Rsh16x64 x (Const64 <t> [int64(uint8(c))]))
 41250		for {
 41251			t := v.Type
 41252			_ = v.Args[1]
 41253			x := v.Args[0]
 41254			v_1 := v.Args[1]
 41255			if v_1.Op != OpConst8 {
 41256				break
 41257			}
 41258			c := v_1.AuxInt
 41259			v.reset(OpRsh16x64)
 41260			v.AddArg(x)
 41261			v0 := b.NewValue0(v.Pos, OpConst64, t)
 41262			v0.AuxInt = int64(uint8(c))
 41263			v.AddArg(v0)
 41264			return true
 41265		}
 41266		// match: (Rsh16x8 (Const16 [0]) _)
 41267		// cond:
 41268		// result: (Const16 [0])
 41269		for {
 41270			_ = v.Args[1]
 41271			v_0 := v.Args[0]
 41272			if v_0.Op != OpConst16 {
 41273				break
 41274			}
 41275			if v_0.AuxInt != 0 {
 41276				break
 41277			}
 41278			v.reset(OpConst16)
 41279			v.AuxInt = 0
 41280			return true
 41281		}
 41282		return false
 41283	}
 41284	func rewriteValuegeneric_OpRsh32Ux16_0(v *Value) bool {
 41285		b := v.Block
 41286		// match: (Rsh32Ux16 <t> x (Const16 [c]))
 41287		// cond:
 41288		// result: (Rsh32Ux64 x (Const64 <t> [int64(uint16(c))]))
 41289		for {
 41290			t := v.Type
 41291			_ = v.Args[1]
 41292			x := v.Args[0]
 41293			v_1 := v.Args[1]
 41294			if v_1.Op != OpConst16 {
 41295				break
 41296			}
 41297			c := v_1.AuxInt
 41298			v.reset(OpRsh32Ux64)
 41299			v.AddArg(x)
 41300			v0 := b.NewValue0(v.Pos, OpConst64, t)
 41301			v0.AuxInt = int64(uint16(c))
 41302			v.AddArg(v0)
 41303			return true
 41304		}
 41305		// match: (Rsh32Ux16 (Const32 [0]) _)
 41306		// cond:
 41307		// result: (Const32 [0])
 41308		for {
 41309			_ = v.Args[1]
 41310			v_0 := v.Args[0]
 41311			if v_0.Op != OpConst32 {
 41312				break
 41313			}
 41314			if v_0.AuxInt != 0 {
 41315				break
 41316			}
 41317			v.reset(OpConst32)
 41318			v.AuxInt = 0
 41319			return true
 41320		}
 41321		return false
 41322	}
 41323	func rewriteValuegeneric_OpRsh32Ux32_0(v *Value) bool {
 41324		b := v.Block
 41325		// match: (Rsh32Ux32 <t> x (Const32 [c]))
 41326		// cond:
 41327		// result: (Rsh32Ux64 x (Const64 <t> [int64(uint32(c))]))
 41328		for {
 41329			t := v.Type
 41330			_ = v.Args[1]
 41331			x := v.Args[0]
 41332			v_1 := v.Args[1]
 41333			if v_1.Op != OpConst32 {
 41334				break
 41335			}
 41336			c := v_1.AuxInt
 41337			v.reset(OpRsh32Ux64)
 41338			v.AddArg(x)
 41339			v0 := b.NewValue0(v.Pos, OpConst64, t)
 41340			v0.AuxInt = int64(uint32(c))
 41341			v.AddArg(v0)
 41342			return true
 41343		}
 41344		// match: (Rsh32Ux32 (Const32 [0]) _)
 41345		// cond:
 41346		// result: (Const32 [0])
 41347		for {
 41348			_ = v.Args[1]
 41349			v_0 := v.Args[0]
 41350			if v_0.Op != OpConst32 {
 41351				break
 41352			}
 41353			if v_0.AuxInt != 0 {
 41354				break
 41355			}
 41356			v.reset(OpConst32)
 41357			v.AuxInt = 0
 41358			return true
 41359		}
 41360		return false
 41361	}
 41362	func rewriteValuegeneric_OpRsh32Ux64_0(v *Value) bool {
 41363		b := v.Block
 41364		typ := &b.Func.Config.Types
 41365		// match: (Rsh32Ux64 (Const32 [c]) (Const64 [d]))
 41366		// cond:
 41367		// result: (Const32 [int64(int32(uint32(c) >> uint64(d)))])
 41368		for {
 41369			_ = v.Args[1]
 41370			v_0 := v.Args[0]
 41371			if v_0.Op != OpConst32 {
 41372				break
 41373			}
 41374			c := v_0.AuxInt
 41375			v_1 := v.Args[1]
 41376			if v_1.Op != OpConst64 {
 41377				break
 41378			}
 41379			d := v_1.AuxInt
 41380			v.reset(OpConst32)
 41381			v.AuxInt = int64(int32(uint32(c) >> uint64(d)))
 41382			return true
 41383		}
 41384		// match: (Rsh32Ux64 x (Const64 [0]))
 41385		// cond:
 41386		// result: x
 41387		for {
 41388			_ = v.Args[1]
 41389			x := v.Args[0]
 41390			v_1 := v.Args[1]
 41391			if v_1.Op != OpConst64 {
 41392				break
 41393			}
 41394			if v_1.AuxInt != 0 {
 41395				break
 41396			}
 41397			v.reset(OpCopy)
 41398			v.Type = x.Type
 41399			v.AddArg(x)
 41400			return true
 41401		}
 41402		// match: (Rsh32Ux64 (Const32 [0]) _)
 41403		// cond:
 41404		// result: (Const32 [0])
 41405		for {
 41406			_ = v.Args[1]
 41407			v_0 := v.Args[0]
 41408			if v_0.Op != OpConst32 {
 41409				break
 41410			}
 41411			if v_0.AuxInt != 0 {
 41412				break
 41413			}
 41414			v.reset(OpConst32)
 41415			v.AuxInt = 0
 41416			return true
 41417		}
 41418		// match: (Rsh32Ux64 _ (Const64 [c]))
 41419		// cond: uint64(c) >= 32
 41420		// result: (Const32 [0])
 41421		for {
 41422			_ = v.Args[1]
 41423			v_1 := v.Args[1]
 41424			if v_1.Op != OpConst64 {
 41425				break
 41426			}
 41427			c := v_1.AuxInt
 41428			if !(uint64(c) >= 32) {
 41429				break
 41430			}
 41431			v.reset(OpConst32)
 41432			v.AuxInt = 0
 41433			return true
 41434		}
 41435		// match: (Rsh32Ux64 <t> (Rsh32Ux64 x (Const64 [c])) (Const64 [d]))
 41436		// cond: !uaddOvf(c,d)
 41437		// result: (Rsh32Ux64 x (Const64 <t> [c+d]))
 41438		for {
 41439			t := v.Type
 41440			_ = v.Args[1]
 41441			v_0 := v.Args[0]
 41442			if v_0.Op != OpRsh32Ux64 {
 41443				break
 41444			}
 41445			_ = v_0.Args[1]
 41446			x := v_0.Args[0]
 41447			v_0_1 := v_0.Args[1]
 41448			if v_0_1.Op != OpConst64 {
 41449				break
 41450			}
 41451			c := v_0_1.AuxInt
 41452			v_1 := v.Args[1]
 41453			if v_1.Op != OpConst64 {
 41454				break
 41455			}
 41456			d := v_1.AuxInt
 41457			if !(!uaddOvf(c, d)) {
 41458				break
 41459			}
 41460			v.reset(OpRsh32Ux64)
 41461			v.AddArg(x)
 41462			v0 := b.NewValue0(v.Pos, OpConst64, t)
 41463			v0.AuxInt = c + d
 41464			v.AddArg(v0)
 41465			return true
 41466		}
 41467		// match: (Rsh32Ux64 (Rsh32x64 x _) (Const64 <t> [31]))
 41468		// cond:
 41469		// result: (Rsh32Ux64 x (Const64 <t> [31]))
 41470		for {
 41471			_ = v.Args[1]
 41472			v_0 := v.Args[0]
 41473			if v_0.Op != OpRsh32x64 {
 41474				break
 41475			}
 41476			_ = v_0.Args[1]
 41477			x := v_0.Args[0]
 41478			v_1 := v.Args[1]
 41479			if v_1.Op != OpConst64 {
 41480				break
 41481			}
 41482			t := v_1.Type
 41483			if v_1.AuxInt != 31 {
 41484				break
 41485			}
 41486			v.reset(OpRsh32Ux64)
 41487			v.AddArg(x)
 41488			v0 := b.NewValue0(v.Pos, OpConst64, t)
 41489			v0.AuxInt = 31
 41490			v.AddArg(v0)
 41491			return true
 41492		}
 41493		// match: (Rsh32Ux64 (Lsh32x64 (Rsh32Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
 41494		// cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
 41495		// result: (Rsh32Ux64 x (Const64 <typ.UInt64> [c1-c2+c3]))
 41496		for {
 41497			_ = v.Args[1]
 41498			v_0 := v.Args[0]
 41499			if v_0.Op != OpLsh32x64 {
 41500				break
 41501			}
 41502			_ = v_0.Args[1]
 41503			v_0_0 := v_0.Args[0]
 41504			if v_0_0.Op != OpRsh32Ux64 {
 41505				break
 41506			}
 41507			_ = v_0_0.Args[1]
 41508			x := v_0_0.Args[0]
 41509			v_0_0_1 := v_0_0.Args[1]
 41510			if v_0_0_1.Op != OpConst64 {
 41511				break
 41512			}
 41513			c1 := v_0_0_1.AuxInt
 41514			v_0_1 := v_0.Args[1]
 41515			if v_0_1.Op != OpConst64 {
 41516				break
 41517			}
 41518			c2 := v_0_1.AuxInt
 41519			v_1 := v.Args[1]
 41520			if v_1.Op != OpConst64 {
 41521				break
 41522			}
 41523			c3 := v_1.AuxInt
 41524			if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) {
 41525				break
 41526			}
 41527			v.reset(OpRsh32Ux64)
 41528			v.AddArg(x)
 41529			v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 41530			v0.AuxInt = c1 - c2 + c3
 41531			v.AddArg(v0)
 41532			return true
 41533		}
 41534		// match: (Rsh32Ux64 (Lsh32x64 x (Const64 [24])) (Const64 [24]))
 41535		// cond:
 41536		// result: (ZeroExt8to32 (Trunc32to8 <typ.UInt8> x))
 41537		for {
 41538			_ = v.Args[1]
 41539			v_0 := v.Args[0]
 41540			if v_0.Op != OpLsh32x64 {
 41541				break
 41542			}
 41543			_ = v_0.Args[1]
 41544			x := v_0.Args[0]
 41545			v_0_1 := v_0.Args[1]
 41546			if v_0_1.Op != OpConst64 {
 41547				break
 41548			}
 41549			if v_0_1.AuxInt != 24 {
 41550				break
 41551			}
 41552			v_1 := v.Args[1]
 41553			if v_1.Op != OpConst64 {
 41554				break
 41555			}
 41556			if v_1.AuxInt != 24 {
 41557				break
 41558			}
 41559			v.reset(OpZeroExt8to32)
 41560			v0 := b.NewValue0(v.Pos, OpTrunc32to8, typ.UInt8)
 41561			v0.AddArg(x)
 41562			v.AddArg(v0)
 41563			return true
 41564		}
 41565		// match: (Rsh32Ux64 (Lsh32x64 x (Const64 [16])) (Const64 [16]))
 41566		// cond:
 41567		// result: (ZeroExt16to32 (Trunc32to16 <typ.UInt16> x))
 41568		for {
 41569			_ = v.Args[1]
 41570			v_0 := v.Args[0]
 41571			if v_0.Op != OpLsh32x64 {
 41572				break
 41573			}
 41574			_ = v_0.Args[1]
 41575			x := v_0.Args[0]
 41576			v_0_1 := v_0.Args[1]
 41577			if v_0_1.Op != OpConst64 {
 41578				break
 41579			}
 41580			if v_0_1.AuxInt != 16 {
 41581				break
 41582			}
 41583			v_1 := v.Args[1]
 41584			if v_1.Op != OpConst64 {
 41585				break
 41586			}
 41587			if v_1.AuxInt != 16 {
 41588				break
 41589			}
 41590			v.reset(OpZeroExt16to32)
 41591			v0 := b.NewValue0(v.Pos, OpTrunc32to16, typ.UInt16)
 41592			v0.AddArg(x)
 41593			v.AddArg(v0)
 41594			return true
 41595		}
 41596		return false
 41597	}
 41598	func rewriteValuegeneric_OpRsh32Ux8_0(v *Value) bool {
 41599		b := v.Block
 41600		// match: (Rsh32Ux8 <t> x (Const8 [c]))
 41601		// cond:
 41602		// result: (Rsh32Ux64 x (Const64 <t> [int64(uint8(c))]))
 41603		for {
 41604			t := v.Type
 41605			_ = v.Args[1]
 41606			x := v.Args[0]
 41607			v_1 := v.Args[1]
 41608			if v_1.Op != OpConst8 {
 41609				break
 41610			}
 41611			c := v_1.AuxInt
 41612			v.reset(OpRsh32Ux64)
 41613			v.AddArg(x)
 41614			v0 := b.NewValue0(v.Pos, OpConst64, t)
 41615			v0.AuxInt = int64(uint8(c))
 41616			v.AddArg(v0)
 41617			return true
 41618		}
 41619		// match: (Rsh32Ux8 (Const32 [0]) _)
 41620		// cond:
 41621		// result: (Const32 [0])
 41622		for {
 41623			_ = v.Args[1]
 41624			v_0 := v.Args[0]
 41625			if v_0.Op != OpConst32 {
 41626				break
 41627			}
 41628			if v_0.AuxInt != 0 {
 41629				break
 41630			}
 41631			v.reset(OpConst32)
 41632			v.AuxInt = 0
 41633			return true
 41634		}
 41635		return false
 41636	}
 41637	func rewriteValuegeneric_OpRsh32x16_0(v *Value) bool {
 41638		b := v.Block
 41639		// match: (Rsh32x16 <t> x (Const16 [c]))
 41640		// cond:
 41641		// result: (Rsh32x64 x (Const64 <t> [int64(uint16(c))]))
 41642		for {
 41643			t := v.Type
 41644			_ = v.Args[1]
 41645			x := v.Args[0]
 41646			v_1 := v.Args[1]
 41647			if v_1.Op != OpConst16 {
 41648				break
 41649			}
 41650			c := v_1.AuxInt
 41651			v.reset(OpRsh32x64)
 41652			v.AddArg(x)
 41653			v0 := b.NewValue0(v.Pos, OpConst64, t)
 41654			v0.AuxInt = int64(uint16(c))
 41655			v.AddArg(v0)
 41656			return true
 41657		}
 41658		// match: (Rsh32x16 (Const32 [0]) _)
 41659		// cond:
 41660		// result: (Const32 [0])
 41661		for {
 41662			_ = v.Args[1]
 41663			v_0 := v.Args[0]
 41664			if v_0.Op != OpConst32 {
 41665				break
 41666			}
 41667			if v_0.AuxInt != 0 {
 41668				break
 41669			}
 41670			v.reset(OpConst32)
 41671			v.AuxInt = 0
 41672			return true
 41673		}
 41674		return false
 41675	}
 41676	func rewriteValuegeneric_OpRsh32x32_0(v *Value) bool {
 41677		b := v.Block
 41678		// match: (Rsh32x32 <t> x (Const32 [c]))
 41679		// cond:
 41680		// result: (Rsh32x64 x (Const64 <t> [int64(uint32(c))]))
 41681		for {
 41682			t := v.Type
 41683			_ = v.Args[1]
 41684			x := v.Args[0]
 41685			v_1 := v.Args[1]
 41686			if v_1.Op != OpConst32 {
 41687				break
 41688			}
 41689			c := v_1.AuxInt
 41690			v.reset(OpRsh32x64)
 41691			v.AddArg(x)
 41692			v0 := b.NewValue0(v.Pos, OpConst64, t)
 41693			v0.AuxInt = int64(uint32(c))
 41694			v.AddArg(v0)
 41695			return true
 41696		}
 41697		// match: (Rsh32x32 (Const32 [0]) _)
 41698		// cond:
 41699		// result: (Const32 [0])
 41700		for {
 41701			_ = v.Args[1]
 41702			v_0 := v.Args[0]
 41703			if v_0.Op != OpConst32 {
 41704				break
 41705			}
 41706			if v_0.AuxInt != 0 {
 41707				break
 41708			}
 41709			v.reset(OpConst32)
 41710			v.AuxInt = 0
 41711			return true
 41712		}
 41713		return false
 41714	}
 41715	func rewriteValuegeneric_OpRsh32x64_0(v *Value) bool {
 41716		b := v.Block
 41717		typ := &b.Func.Config.Types
 41718		// match: (Rsh32x64 (Const32 [c]) (Const64 [d]))
 41719		// cond:
 41720		// result: (Const32 [int64(int32(c) >> uint64(d))])
 41721		for {
 41722			_ = v.Args[1]
 41723			v_0 := v.Args[0]
 41724			if v_0.Op != OpConst32 {
 41725				break
 41726			}
 41727			c := v_0.AuxInt
 41728			v_1 := v.Args[1]
 41729			if v_1.Op != OpConst64 {
 41730				break
 41731			}
 41732			d := v_1.AuxInt
 41733			v.reset(OpConst32)
 41734			v.AuxInt = int64(int32(c) >> uint64(d))
 41735			return true
 41736		}
 41737		// match: (Rsh32x64 x (Const64 [0]))
 41738		// cond:
 41739		// result: x
 41740		for {
 41741			_ = v.Args[1]
 41742			x := v.Args[0]
 41743			v_1 := v.Args[1]
 41744			if v_1.Op != OpConst64 {
 41745				break
 41746			}
 41747			if v_1.AuxInt != 0 {
 41748				break
 41749			}
 41750			v.reset(OpCopy)
 41751			v.Type = x.Type
 41752			v.AddArg(x)
 41753			return true
 41754		}
 41755		// match: (Rsh32x64 (Const32 [0]) _)
 41756		// cond:
 41757		// result: (Const32 [0])
 41758		for {
 41759			_ = v.Args[1]
 41760			v_0 := v.Args[0]
 41761			if v_0.Op != OpConst32 {
 41762				break
 41763			}
 41764			if v_0.AuxInt != 0 {
 41765				break
 41766			}
 41767			v.reset(OpConst32)
 41768			v.AuxInt = 0
 41769			return true
 41770		}
 41771		// match: (Rsh32x64 <t> (Rsh32x64 x (Const64 [c])) (Const64 [d]))
 41772		// cond: !uaddOvf(c,d)
 41773		// result: (Rsh32x64 x (Const64 <t> [c+d]))
 41774		for {
 41775			t := v.Type
 41776			_ = v.Args[1]
 41777			v_0 := v.Args[0]
 41778			if v_0.Op != OpRsh32x64 {
 41779				break
 41780			}
 41781			_ = v_0.Args[1]
 41782			x := v_0.Args[0]
 41783			v_0_1 := v_0.Args[1]
 41784			if v_0_1.Op != OpConst64 {
 41785				break
 41786			}
 41787			c := v_0_1.AuxInt
 41788			v_1 := v.Args[1]
 41789			if v_1.Op != OpConst64 {
 41790				break
 41791			}
 41792			d := v_1.AuxInt
 41793			if !(!uaddOvf(c, d)) {
 41794				break
 41795			}
 41796			v.reset(OpRsh32x64)
 41797			v.AddArg(x)
 41798			v0 := b.NewValue0(v.Pos, OpConst64, t)
 41799			v0.AuxInt = c + d
 41800			v.AddArg(v0)
 41801			return true
 41802		}
 41803		// match: (Rsh32x64 (Lsh32x64 x (Const64 [24])) (Const64 [24]))
 41804		// cond:
 41805		// result: (SignExt8to32 (Trunc32to8 <typ.Int8> x))
 41806		for {
 41807			_ = v.Args[1]
 41808			v_0 := v.Args[0]
 41809			if v_0.Op != OpLsh32x64 {
 41810				break
 41811			}
 41812			_ = v_0.Args[1]
 41813			x := v_0.Args[0]
 41814			v_0_1 := v_0.Args[1]
 41815			if v_0_1.Op != OpConst64 {
 41816				break
 41817			}
 41818			if v_0_1.AuxInt != 24 {
 41819				break
 41820			}
 41821			v_1 := v.Args[1]
 41822			if v_1.Op != OpConst64 {
 41823				break
 41824			}
 41825			if v_1.AuxInt != 24 {
 41826				break
 41827			}
 41828			v.reset(OpSignExt8to32)
 41829			v0 := b.NewValue0(v.Pos, OpTrunc32to8, typ.Int8)
 41830			v0.AddArg(x)
 41831			v.AddArg(v0)
 41832			return true
 41833		}
 41834		// match: (Rsh32x64 (Lsh32x64 x (Const64 [16])) (Const64 [16]))
 41835		// cond:
 41836		// result: (SignExt16to32 (Trunc32to16 <typ.Int16> x))
 41837		for {
 41838			_ = v.Args[1]
 41839			v_0 := v.Args[0]
 41840			if v_0.Op != OpLsh32x64 {
 41841				break
 41842			}
 41843			_ = v_0.Args[1]
 41844			x := v_0.Args[0]
 41845			v_0_1 := v_0.Args[1]
 41846			if v_0_1.Op != OpConst64 {
 41847				break
 41848			}
 41849			if v_0_1.AuxInt != 16 {
 41850				break
 41851			}
 41852			v_1 := v.Args[1]
 41853			if v_1.Op != OpConst64 {
 41854				break
 41855			}
 41856			if v_1.AuxInt != 16 {
 41857				break
 41858			}
 41859			v.reset(OpSignExt16to32)
 41860			v0 := b.NewValue0(v.Pos, OpTrunc32to16, typ.Int16)
 41861			v0.AddArg(x)
 41862			v.AddArg(v0)
 41863			return true
 41864		}
 41865		return false
 41866	}
 41867	func rewriteValuegeneric_OpRsh32x8_0(v *Value) bool {
 41868		b := v.Block
 41869		// match: (Rsh32x8 <t> x (Const8 [c]))
 41870		// cond:
 41871		// result: (Rsh32x64 x (Const64 <t> [int64(uint8(c))]))
 41872		for {
 41873			t := v.Type
 41874			_ = v.Args[1]
 41875			x := v.Args[0]
 41876			v_1 := v.Args[1]
 41877			if v_1.Op != OpConst8 {
 41878				break
 41879			}
 41880			c := v_1.AuxInt
 41881			v.reset(OpRsh32x64)
 41882			v.AddArg(x)
 41883			v0 := b.NewValue0(v.Pos, OpConst64, t)
 41884			v0.AuxInt = int64(uint8(c))
 41885			v.AddArg(v0)
 41886			return true
 41887		}
 41888		// match: (Rsh32x8 (Const32 [0]) _)
 41889		// cond:
 41890		// result: (Const32 [0])
 41891		for {
 41892			_ = v.Args[1]
 41893			v_0 := v.Args[0]
 41894			if v_0.Op != OpConst32 {
 41895				break
 41896			}
 41897			if v_0.AuxInt != 0 {
 41898				break
 41899			}
 41900			v.reset(OpConst32)
 41901			v.AuxInt = 0
 41902			return true
 41903		}
 41904		return false
 41905	}
 41906	func rewriteValuegeneric_OpRsh64Ux16_0(v *Value) bool {
 41907		b := v.Block
 41908		// match: (Rsh64Ux16 <t> x (Const16 [c]))
 41909		// cond:
 41910		// result: (Rsh64Ux64 x (Const64 <t> [int64(uint16(c))]))
 41911		for {
 41912			t := v.Type
 41913			_ = v.Args[1]
 41914			x := v.Args[0]
 41915			v_1 := v.Args[1]
 41916			if v_1.Op != OpConst16 {
 41917				break
 41918			}
 41919			c := v_1.AuxInt
 41920			v.reset(OpRsh64Ux64)
 41921			v.AddArg(x)
 41922			v0 := b.NewValue0(v.Pos, OpConst64, t)
 41923			v0.AuxInt = int64(uint16(c))
 41924			v.AddArg(v0)
 41925			return true
 41926		}
 41927		// match: (Rsh64Ux16 (Const64 [0]) _)
 41928		// cond:
 41929		// result: (Const64 [0])
 41930		for {
 41931			_ = v.Args[1]
 41932			v_0 := v.Args[0]
 41933			if v_0.Op != OpConst64 {
 41934				break
 41935			}
 41936			if v_0.AuxInt != 0 {
 41937				break
 41938			}
 41939			v.reset(OpConst64)
 41940			v.AuxInt = 0
 41941			return true
 41942		}
 41943		return false
 41944	}
 41945	func rewriteValuegeneric_OpRsh64Ux32_0(v *Value) bool {
 41946		b := v.Block
 41947		// match: (Rsh64Ux32 <t> x (Const32 [c]))
 41948		// cond:
 41949		// result: (Rsh64Ux64 x (Const64 <t> [int64(uint32(c))]))
 41950		for {
 41951			t := v.Type
 41952			_ = v.Args[1]
 41953			x := v.Args[0]
 41954			v_1 := v.Args[1]
 41955			if v_1.Op != OpConst32 {
 41956				break
 41957			}
 41958			c := v_1.AuxInt
 41959			v.reset(OpRsh64Ux64)
 41960			v.AddArg(x)
 41961			v0 := b.NewValue0(v.Pos, OpConst64, t)
 41962			v0.AuxInt = int64(uint32(c))
 41963			v.AddArg(v0)
 41964			return true
 41965		}
 41966		// match: (Rsh64Ux32 (Const64 [0]) _)
 41967		// cond:
 41968		// result: (Const64 [0])
 41969		for {
 41970			_ = v.Args[1]
 41971			v_0 := v.Args[0]
 41972			if v_0.Op != OpConst64 {
 41973				break
 41974			}
 41975			if v_0.AuxInt != 0 {
 41976				break
 41977			}
 41978			v.reset(OpConst64)
 41979			v.AuxInt = 0
 41980			return true
 41981		}
 41982		return false
 41983	}
 41984	func rewriteValuegeneric_OpRsh64Ux64_0(v *Value) bool {
 41985		b := v.Block
 41986		typ := &b.Func.Config.Types
 41987		// match: (Rsh64Ux64 (Const64 [c]) (Const64 [d]))
 41988		// cond:
 41989		// result: (Const64 [int64(uint64(c) >> uint64(d))])
 41990		for {
 41991			_ = v.Args[1]
 41992			v_0 := v.Args[0]
 41993			if v_0.Op != OpConst64 {
 41994				break
 41995			}
 41996			c := v_0.AuxInt
 41997			v_1 := v.Args[1]
 41998			if v_1.Op != OpConst64 {
 41999				break
 42000			}
 42001			d := v_1.AuxInt
 42002			v.reset(OpConst64)
 42003			v.AuxInt = int64(uint64(c) >> uint64(d))
 42004			return true
 42005		}
 42006		// match: (Rsh64Ux64 x (Const64 [0]))
 42007		// cond:
 42008		// result: x
 42009		for {
 42010			_ = v.Args[1]
 42011			x := v.Args[0]
 42012			v_1 := v.Args[1]
 42013			if v_1.Op != OpConst64 {
 42014				break
 42015			}
 42016			if v_1.AuxInt != 0 {
 42017				break
 42018			}
 42019			v.reset(OpCopy)
 42020			v.Type = x.Type
 42021			v.AddArg(x)
 42022			return true
 42023		}
 42024		// match: (Rsh64Ux64 (Const64 [0]) _)
 42025		// cond:
 42026		// result: (Const64 [0])
 42027		for {
 42028			_ = v.Args[1]
 42029			v_0 := v.Args[0]
 42030			if v_0.Op != OpConst64 {
 42031				break
 42032			}
 42033			if v_0.AuxInt != 0 {
 42034				break
 42035			}
 42036			v.reset(OpConst64)
 42037			v.AuxInt = 0
 42038			return true
 42039		}
 42040		// match: (Rsh64Ux64 _ (Const64 [c]))
 42041		// cond: uint64(c) >= 64
 42042		// result: (Const64 [0])
 42043		for {
 42044			_ = v.Args[1]
 42045			v_1 := v.Args[1]
 42046			if v_1.Op != OpConst64 {
 42047				break
 42048			}
 42049			c := v_1.AuxInt
 42050			if !(uint64(c) >= 64) {
 42051				break
 42052			}
 42053			v.reset(OpConst64)
 42054			v.AuxInt = 0
 42055			return true
 42056		}
 42057		// match: (Rsh64Ux64 <t> (Rsh64Ux64 x (Const64 [c])) (Const64 [d]))
 42058		// cond: !uaddOvf(c,d)
 42059		// result: (Rsh64Ux64 x (Const64 <t> [c+d]))
 42060		for {
 42061			t := v.Type
 42062			_ = v.Args[1]
 42063			v_0 := v.Args[0]
 42064			if v_0.Op != OpRsh64Ux64 {
 42065				break
 42066			}
 42067			_ = v_0.Args[1]
 42068			x := v_0.Args[0]
 42069			v_0_1 := v_0.Args[1]
 42070			if v_0_1.Op != OpConst64 {
 42071				break
 42072			}
 42073			c := v_0_1.AuxInt
 42074			v_1 := v.Args[1]
 42075			if v_1.Op != OpConst64 {
 42076				break
 42077			}
 42078			d := v_1.AuxInt
 42079			if !(!uaddOvf(c, d)) {
 42080				break
 42081			}
 42082			v.reset(OpRsh64Ux64)
 42083			v.AddArg(x)
 42084			v0 := b.NewValue0(v.Pos, OpConst64, t)
 42085			v0.AuxInt = c + d
 42086			v.AddArg(v0)
 42087			return true
 42088		}
 42089		// match: (Rsh64Ux64 (Rsh64x64 x _) (Const64 <t> [63]))
 42090		// cond:
 42091		// result: (Rsh64Ux64 x (Const64 <t> [63]))
 42092		for {
 42093			_ = v.Args[1]
 42094			v_0 := v.Args[0]
 42095			if v_0.Op != OpRsh64x64 {
 42096				break
 42097			}
 42098			_ = v_0.Args[1]
 42099			x := v_0.Args[0]
 42100			v_1 := v.Args[1]
 42101			if v_1.Op != OpConst64 {
 42102				break
 42103			}
 42104			t := v_1.Type
 42105			if v_1.AuxInt != 63 {
 42106				break
 42107			}
 42108			v.reset(OpRsh64Ux64)
 42109			v.AddArg(x)
 42110			v0 := b.NewValue0(v.Pos, OpConst64, t)
 42111			v0.AuxInt = 63
 42112			v.AddArg(v0)
 42113			return true
 42114		}
 42115		// match: (Rsh64Ux64 (Lsh64x64 (Rsh64Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
 42116		// cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
 42117		// result: (Rsh64Ux64 x (Const64 <typ.UInt64> [c1-c2+c3]))
 42118		for {
 42119			_ = v.Args[1]
 42120			v_0 := v.Args[0]
 42121			if v_0.Op != OpLsh64x64 {
 42122				break
 42123			}
 42124			_ = v_0.Args[1]
 42125			v_0_0 := v_0.Args[0]
 42126			if v_0_0.Op != OpRsh64Ux64 {
 42127				break
 42128			}
 42129			_ = v_0_0.Args[1]
 42130			x := v_0_0.Args[0]
 42131			v_0_0_1 := v_0_0.Args[1]
 42132			if v_0_0_1.Op != OpConst64 {
 42133				break
 42134			}
 42135			c1 := v_0_0_1.AuxInt
 42136			v_0_1 := v_0.Args[1]
 42137			if v_0_1.Op != OpConst64 {
 42138				break
 42139			}
 42140			c2 := v_0_1.AuxInt
 42141			v_1 := v.Args[1]
 42142			if v_1.Op != OpConst64 {
 42143				break
 42144			}
 42145			c3 := v_1.AuxInt
 42146			if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) {
 42147				break
 42148			}
 42149			v.reset(OpRsh64Ux64)
 42150			v.AddArg(x)
 42151			v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 42152			v0.AuxInt = c1 - c2 + c3
 42153			v.AddArg(v0)
 42154			return true
 42155		}
 42156		// match: (Rsh64Ux64 (Lsh64x64 x (Const64 [56])) (Const64 [56]))
 42157		// cond:
 42158		// result: (ZeroExt8to64 (Trunc64to8 <typ.UInt8> x))
 42159		for {
 42160			_ = v.Args[1]
 42161			v_0 := v.Args[0]
 42162			if v_0.Op != OpLsh64x64 {
 42163				break
 42164			}
 42165			_ = v_0.Args[1]
 42166			x := v_0.Args[0]
 42167			v_0_1 := v_0.Args[1]
 42168			if v_0_1.Op != OpConst64 {
 42169				break
 42170			}
 42171			if v_0_1.AuxInt != 56 {
 42172				break
 42173			}
 42174			v_1 := v.Args[1]
 42175			if v_1.Op != OpConst64 {
 42176				break
 42177			}
 42178			if v_1.AuxInt != 56 {
 42179				break
 42180			}
 42181			v.reset(OpZeroExt8to64)
 42182			v0 := b.NewValue0(v.Pos, OpTrunc64to8, typ.UInt8)
 42183			v0.AddArg(x)
 42184			v.AddArg(v0)
 42185			return true
 42186		}
 42187		// match: (Rsh64Ux64 (Lsh64x64 x (Const64 [48])) (Const64 [48]))
 42188		// cond:
 42189		// result: (ZeroExt16to64 (Trunc64to16 <typ.UInt16> x))
 42190		for {
 42191			_ = v.Args[1]
 42192			v_0 := v.Args[0]
 42193			if v_0.Op != OpLsh64x64 {
 42194				break
 42195			}
 42196			_ = v_0.Args[1]
 42197			x := v_0.Args[0]
 42198			v_0_1 := v_0.Args[1]
 42199			if v_0_1.Op != OpConst64 {
 42200				break
 42201			}
 42202			if v_0_1.AuxInt != 48 {
 42203				break
 42204			}
 42205			v_1 := v.Args[1]
 42206			if v_1.Op != OpConst64 {
 42207				break
 42208			}
 42209			if v_1.AuxInt != 48 {
 42210				break
 42211			}
 42212			v.reset(OpZeroExt16to64)
 42213			v0 := b.NewValue0(v.Pos, OpTrunc64to16, typ.UInt16)
 42214			v0.AddArg(x)
 42215			v.AddArg(v0)
 42216			return true
 42217		}
 42218		// match: (Rsh64Ux64 (Lsh64x64 x (Const64 [32])) (Const64 [32]))
 42219		// cond:
 42220		// result: (ZeroExt32to64 (Trunc64to32 <typ.UInt32> x))
 42221		for {
 42222			_ = v.Args[1]
 42223			v_0 := v.Args[0]
 42224			if v_0.Op != OpLsh64x64 {
 42225				break
 42226			}
 42227			_ = v_0.Args[1]
 42228			x := v_0.Args[0]
 42229			v_0_1 := v_0.Args[1]
 42230			if v_0_1.Op != OpConst64 {
 42231				break
 42232			}
 42233			if v_0_1.AuxInt != 32 {
 42234				break
 42235			}
 42236			v_1 := v.Args[1]
 42237			if v_1.Op != OpConst64 {
 42238				break
 42239			}
 42240			if v_1.AuxInt != 32 {
 42241				break
 42242			}
 42243			v.reset(OpZeroExt32to64)
 42244			v0 := b.NewValue0(v.Pos, OpTrunc64to32, typ.UInt32)
 42245			v0.AddArg(x)
 42246			v.AddArg(v0)
 42247			return true
 42248		}
 42249		return false
 42250	}
 42251	func rewriteValuegeneric_OpRsh64Ux8_0(v *Value) bool {
 42252		b := v.Block
 42253		// match: (Rsh64Ux8 <t> x (Const8 [c]))
 42254		// cond:
 42255		// result: (Rsh64Ux64 x (Const64 <t> [int64(uint8(c))]))
 42256		for {
 42257			t := v.Type
 42258			_ = v.Args[1]
 42259			x := v.Args[0]
 42260			v_1 := v.Args[1]
 42261			if v_1.Op != OpConst8 {
 42262				break
 42263			}
 42264			c := v_1.AuxInt
 42265			v.reset(OpRsh64Ux64)
 42266			v.AddArg(x)
 42267			v0 := b.NewValue0(v.Pos, OpConst64, t)
 42268			v0.AuxInt = int64(uint8(c))
 42269			v.AddArg(v0)
 42270			return true
 42271		}
 42272		// match: (Rsh64Ux8 (Const64 [0]) _)
 42273		// cond:
 42274		// result: (Const64 [0])
 42275		for {
 42276			_ = v.Args[1]
 42277			v_0 := v.Args[0]
 42278			if v_0.Op != OpConst64 {
 42279				break
 42280			}
 42281			if v_0.AuxInt != 0 {
 42282				break
 42283			}
 42284			v.reset(OpConst64)
 42285			v.AuxInt = 0
 42286			return true
 42287		}
 42288		return false
 42289	}
 42290	func rewriteValuegeneric_OpRsh64x16_0(v *Value) bool {
 42291		b := v.Block
 42292		// match: (Rsh64x16 <t> x (Const16 [c]))
 42293		// cond:
 42294		// result: (Rsh64x64 x (Const64 <t> [int64(uint16(c))]))
 42295		for {
 42296			t := v.Type
 42297			_ = v.Args[1]
 42298			x := v.Args[0]
 42299			v_1 := v.Args[1]
 42300			if v_1.Op != OpConst16 {
 42301				break
 42302			}
 42303			c := v_1.AuxInt
 42304			v.reset(OpRsh64x64)
 42305			v.AddArg(x)
 42306			v0 := b.NewValue0(v.Pos, OpConst64, t)
 42307			v0.AuxInt = int64(uint16(c))
 42308			v.AddArg(v0)
 42309			return true
 42310		}
 42311		// match: (Rsh64x16 (Const64 [0]) _)
 42312		// cond:
 42313		// result: (Const64 [0])
 42314		for {
 42315			_ = v.Args[1]
 42316			v_0 := v.Args[0]
 42317			if v_0.Op != OpConst64 {
 42318				break
 42319			}
 42320			if v_0.AuxInt != 0 {
 42321				break
 42322			}
 42323			v.reset(OpConst64)
 42324			v.AuxInt = 0
 42325			return true
 42326		}
 42327		return false
 42328	}
 42329	func rewriteValuegeneric_OpRsh64x32_0(v *Value) bool {
 42330		b := v.Block
 42331		// match: (Rsh64x32 <t> x (Const32 [c]))
 42332		// cond:
 42333		// result: (Rsh64x64 x (Const64 <t> [int64(uint32(c))]))
 42334		for {
 42335			t := v.Type
 42336			_ = v.Args[1]
 42337			x := v.Args[0]
 42338			v_1 := v.Args[1]
 42339			if v_1.Op != OpConst32 {
 42340				break
 42341			}
 42342			c := v_1.AuxInt
 42343			v.reset(OpRsh64x64)
 42344			v.AddArg(x)
 42345			v0 := b.NewValue0(v.Pos, OpConst64, t)
 42346			v0.AuxInt = int64(uint32(c))
 42347			v.AddArg(v0)
 42348			return true
 42349		}
 42350		// match: (Rsh64x32 (Const64 [0]) _)
 42351		// cond:
 42352		// result: (Const64 [0])
 42353		for {
 42354			_ = v.Args[1]
 42355			v_0 := v.Args[0]
 42356			if v_0.Op != OpConst64 {
 42357				break
 42358			}
 42359			if v_0.AuxInt != 0 {
 42360				break
 42361			}
 42362			v.reset(OpConst64)
 42363			v.AuxInt = 0
 42364			return true
 42365		}
 42366		return false
 42367	}
 42368	func rewriteValuegeneric_OpRsh64x64_0(v *Value) bool {
 42369		b := v.Block
 42370		typ := &b.Func.Config.Types
 42371		// match: (Rsh64x64 (Const64 [c]) (Const64 [d]))
 42372		// cond:
 42373		// result: (Const64 [c >> uint64(d)])
 42374		for {
 42375			_ = v.Args[1]
 42376			v_0 := v.Args[0]
 42377			if v_0.Op != OpConst64 {
 42378				break
 42379			}
 42380			c := v_0.AuxInt
 42381			v_1 := v.Args[1]
 42382			if v_1.Op != OpConst64 {
 42383				break
 42384			}
 42385			d := v_1.AuxInt
 42386			v.reset(OpConst64)
 42387			v.AuxInt = c >> uint64(d)
 42388			return true
 42389		}
 42390		// match: (Rsh64x64 x (Const64 [0]))
 42391		// cond:
 42392		// result: x
 42393		for {
 42394			_ = v.Args[1]
 42395			x := v.Args[0]
 42396			v_1 := v.Args[1]
 42397			if v_1.Op != OpConst64 {
 42398				break
 42399			}
 42400			if v_1.AuxInt != 0 {
 42401				break
 42402			}
 42403			v.reset(OpCopy)
 42404			v.Type = x.Type
 42405			v.AddArg(x)
 42406			return true
 42407		}
 42408		// match: (Rsh64x64 (Const64 [0]) _)
 42409		// cond:
 42410		// result: (Const64 [0])
 42411		for {
 42412			_ = v.Args[1]
 42413			v_0 := v.Args[0]
 42414			if v_0.Op != OpConst64 {
 42415				break
 42416			}
 42417			if v_0.AuxInt != 0 {
 42418				break
 42419			}
 42420			v.reset(OpConst64)
 42421			v.AuxInt = 0
 42422			return true
 42423		}
 42424		// match: (Rsh64x64 <t> (Rsh64x64 x (Const64 [c])) (Const64 [d]))
 42425		// cond: !uaddOvf(c,d)
 42426		// result: (Rsh64x64 x (Const64 <t> [c+d]))
 42427		for {
 42428			t := v.Type
 42429			_ = v.Args[1]
 42430			v_0 := v.Args[0]
 42431			if v_0.Op != OpRsh64x64 {
 42432				break
 42433			}
 42434			_ = v_0.Args[1]
 42435			x := v_0.Args[0]
 42436			v_0_1 := v_0.Args[1]
 42437			if v_0_1.Op != OpConst64 {
 42438				break
 42439			}
 42440			c := v_0_1.AuxInt
 42441			v_1 := v.Args[1]
 42442			if v_1.Op != OpConst64 {
 42443				break
 42444			}
 42445			d := v_1.AuxInt
 42446			if !(!uaddOvf(c, d)) {
 42447				break
 42448			}
 42449			v.reset(OpRsh64x64)
 42450			v.AddArg(x)
 42451			v0 := b.NewValue0(v.Pos, OpConst64, t)
 42452			v0.AuxInt = c + d
 42453			v.AddArg(v0)
 42454			return true
 42455		}
 42456		// match: (Rsh64x64 (Lsh64x64 x (Const64 [56])) (Const64 [56]))
 42457		// cond:
 42458		// result: (SignExt8to64 (Trunc64to8 <typ.Int8> x))
 42459		for {
 42460			_ = v.Args[1]
 42461			v_0 := v.Args[0]
 42462			if v_0.Op != OpLsh64x64 {
 42463				break
 42464			}
 42465			_ = v_0.Args[1]
 42466			x := v_0.Args[0]
 42467			v_0_1 := v_0.Args[1]
 42468			if v_0_1.Op != OpConst64 {
 42469				break
 42470			}
 42471			if v_0_1.AuxInt != 56 {
 42472				break
 42473			}
 42474			v_1 := v.Args[1]
 42475			if v_1.Op != OpConst64 {
 42476				break
 42477			}
 42478			if v_1.AuxInt != 56 {
 42479				break
 42480			}
 42481			v.reset(OpSignExt8to64)
 42482			v0 := b.NewValue0(v.Pos, OpTrunc64to8, typ.Int8)
 42483			v0.AddArg(x)
 42484			v.AddArg(v0)
 42485			return true
 42486		}
 42487		// match: (Rsh64x64 (Lsh64x64 x (Const64 [48])) (Const64 [48]))
 42488		// cond:
 42489		// result: (SignExt16to64 (Trunc64to16 <typ.Int16> x))
 42490		for {
 42491			_ = v.Args[1]
 42492			v_0 := v.Args[0]
 42493			if v_0.Op != OpLsh64x64 {
 42494				break
 42495			}
 42496			_ = v_0.Args[1]
 42497			x := v_0.Args[0]
 42498			v_0_1 := v_0.Args[1]
 42499			if v_0_1.Op != OpConst64 {
 42500				break
 42501			}
 42502			if v_0_1.AuxInt != 48 {
 42503				break
 42504			}
 42505			v_1 := v.Args[1]
 42506			if v_1.Op != OpConst64 {
 42507				break
 42508			}
 42509			if v_1.AuxInt != 48 {
 42510				break
 42511			}
 42512			v.reset(OpSignExt16to64)
 42513			v0 := b.NewValue0(v.Pos, OpTrunc64to16, typ.Int16)
 42514			v0.AddArg(x)
 42515			v.AddArg(v0)
 42516			return true
 42517		}
 42518		// match: (Rsh64x64 (Lsh64x64 x (Const64 [32])) (Const64 [32]))
 42519		// cond:
 42520		// result: (SignExt32to64 (Trunc64to32 <typ.Int32> x))
 42521		for {
 42522			_ = v.Args[1]
 42523			v_0 := v.Args[0]
 42524			if v_0.Op != OpLsh64x64 {
 42525				break
 42526			}
 42527			_ = v_0.Args[1]
 42528			x := v_0.Args[0]
 42529			v_0_1 := v_0.Args[1]
 42530			if v_0_1.Op != OpConst64 {
 42531				break
 42532			}
 42533			if v_0_1.AuxInt != 32 {
 42534				break
 42535			}
 42536			v_1 := v.Args[1]
 42537			if v_1.Op != OpConst64 {
 42538				break
 42539			}
 42540			if v_1.AuxInt != 32 {
 42541				break
 42542			}
 42543			v.reset(OpSignExt32to64)
 42544			v0 := b.NewValue0(v.Pos, OpTrunc64to32, typ.Int32)
 42545			v0.AddArg(x)
 42546			v.AddArg(v0)
 42547			return true
 42548		}
 42549		return false
 42550	}
 42551	func rewriteValuegeneric_OpRsh64x8_0(v *Value) bool {
 42552		b := v.Block
 42553		// match: (Rsh64x8 <t> x (Const8 [c]))
 42554		// cond:
 42555		// result: (Rsh64x64 x (Const64 <t> [int64(uint8(c))]))
 42556		for {
 42557			t := v.Type
 42558			_ = v.Args[1]
 42559			x := v.Args[0]
 42560			v_1 := v.Args[1]
 42561			if v_1.Op != OpConst8 {
 42562				break
 42563			}
 42564			c := v_1.AuxInt
 42565			v.reset(OpRsh64x64)
 42566			v.AddArg(x)
 42567			v0 := b.NewValue0(v.Pos, OpConst64, t)
 42568			v0.AuxInt = int64(uint8(c))
 42569			v.AddArg(v0)
 42570			return true
 42571		}
 42572		// match: (Rsh64x8 (Const64 [0]) _)
 42573		// cond:
 42574		// result: (Const64 [0])
 42575		for {
 42576			_ = v.Args[1]
 42577			v_0 := v.Args[0]
 42578			if v_0.Op != OpConst64 {
 42579				break
 42580			}
 42581			if v_0.AuxInt != 0 {
 42582				break
 42583			}
 42584			v.reset(OpConst64)
 42585			v.AuxInt = 0
 42586			return true
 42587		}
 42588		return false
 42589	}
 42590	func rewriteValuegeneric_OpRsh8Ux16_0(v *Value) bool {
 42591		b := v.Block
 42592		// match: (Rsh8Ux16 <t> x (Const16 [c]))
 42593		// cond:
 42594		// result: (Rsh8Ux64 x (Const64 <t> [int64(uint16(c))]))
 42595		for {
 42596			t := v.Type
 42597			_ = v.Args[1]
 42598			x := v.Args[0]
 42599			v_1 := v.Args[1]
 42600			if v_1.Op != OpConst16 {
 42601				break
 42602			}
 42603			c := v_1.AuxInt
 42604			v.reset(OpRsh8Ux64)
 42605			v.AddArg(x)
 42606			v0 := b.NewValue0(v.Pos, OpConst64, t)
 42607			v0.AuxInt = int64(uint16(c))
 42608			v.AddArg(v0)
 42609			return true
 42610		}
 42611		// match: (Rsh8Ux16 (Const8 [0]) _)
 42612		// cond:
 42613		// result: (Const8 [0])
 42614		for {
 42615			_ = v.Args[1]
 42616			v_0 := v.Args[0]
 42617			if v_0.Op != OpConst8 {
 42618				break
 42619			}
 42620			if v_0.AuxInt != 0 {
 42621				break
 42622			}
 42623			v.reset(OpConst8)
 42624			v.AuxInt = 0
 42625			return true
 42626		}
 42627		return false
 42628	}
 42629	func rewriteValuegeneric_OpRsh8Ux32_0(v *Value) bool {
 42630		b := v.Block
 42631		// match: (Rsh8Ux32 <t> x (Const32 [c]))
 42632		// cond:
 42633		// result: (Rsh8Ux64 x (Const64 <t> [int64(uint32(c))]))
 42634		for {
 42635			t := v.Type
 42636			_ = v.Args[1]
 42637			x := v.Args[0]
 42638			v_1 := v.Args[1]
 42639			if v_1.Op != OpConst32 {
 42640				break
 42641			}
 42642			c := v_1.AuxInt
 42643			v.reset(OpRsh8Ux64)
 42644			v.AddArg(x)
 42645			v0 := b.NewValue0(v.Pos, OpConst64, t)
 42646			v0.AuxInt = int64(uint32(c))
 42647			v.AddArg(v0)
 42648			return true
 42649		}
 42650		// match: (Rsh8Ux32 (Const8 [0]) _)
 42651		// cond:
 42652		// result: (Const8 [0])
 42653		for {
 42654			_ = v.Args[1]
 42655			v_0 := v.Args[0]
 42656			if v_0.Op != OpConst8 {
 42657				break
 42658			}
 42659			if v_0.AuxInt != 0 {
 42660				break
 42661			}
 42662			v.reset(OpConst8)
 42663			v.AuxInt = 0
 42664			return true
 42665		}
 42666		return false
 42667	}
 42668	func rewriteValuegeneric_OpRsh8Ux64_0(v *Value) bool {
 42669		b := v.Block
 42670		typ := &b.Func.Config.Types
 42671		// match: (Rsh8Ux64 (Const8 [c]) (Const64 [d]))
 42672		// cond:
 42673		// result: (Const8 [int64(int8(uint8(c) >> uint64(d)))])
 42674		for {
 42675			_ = v.Args[1]
 42676			v_0 := v.Args[0]
 42677			if v_0.Op != OpConst8 {
 42678				break
 42679			}
 42680			c := v_0.AuxInt
 42681			v_1 := v.Args[1]
 42682			if v_1.Op != OpConst64 {
 42683				break
 42684			}
 42685			d := v_1.AuxInt
 42686			v.reset(OpConst8)
 42687			v.AuxInt = int64(int8(uint8(c) >> uint64(d)))
 42688			return true
 42689		}
 42690		// match: (Rsh8Ux64 x (Const64 [0]))
 42691		// cond:
 42692		// result: x
 42693		for {
 42694			_ = v.Args[1]
 42695			x := v.Args[0]
 42696			v_1 := v.Args[1]
 42697			if v_1.Op != OpConst64 {
 42698				break
 42699			}
 42700			if v_1.AuxInt != 0 {
 42701				break
 42702			}
 42703			v.reset(OpCopy)
 42704			v.Type = x.Type
 42705			v.AddArg(x)
 42706			return true
 42707		}
 42708		// match: (Rsh8Ux64 (Const8 [0]) _)
 42709		// cond:
 42710		// result: (Const8 [0])
 42711		for {
 42712			_ = v.Args[1]
 42713			v_0 := v.Args[0]
 42714			if v_0.Op != OpConst8 {
 42715				break
 42716			}
 42717			if v_0.AuxInt != 0 {
 42718				break
 42719			}
 42720			v.reset(OpConst8)
 42721			v.AuxInt = 0
 42722			return true
 42723		}
 42724		// match: (Rsh8Ux64 _ (Const64 [c]))
 42725		// cond: uint64(c) >= 8
 42726		// result: (Const8 [0])
 42727		for {
 42728			_ = v.Args[1]
 42729			v_1 := v.Args[1]
 42730			if v_1.Op != OpConst64 {
 42731				break
 42732			}
 42733			c := v_1.AuxInt
 42734			if !(uint64(c) >= 8) {
 42735				break
 42736			}
 42737			v.reset(OpConst8)
 42738			v.AuxInt = 0
 42739			return true
 42740		}
 42741		// match: (Rsh8Ux64 <t> (Rsh8Ux64 x (Const64 [c])) (Const64 [d]))
 42742		// cond: !uaddOvf(c,d)
 42743		// result: (Rsh8Ux64 x (Const64 <t> [c+d]))
 42744		for {
 42745			t := v.Type
 42746			_ = v.Args[1]
 42747			v_0 := v.Args[0]
 42748			if v_0.Op != OpRsh8Ux64 {
 42749				break
 42750			}
 42751			_ = v_0.Args[1]
 42752			x := v_0.Args[0]
 42753			v_0_1 := v_0.Args[1]
 42754			if v_0_1.Op != OpConst64 {
 42755				break
 42756			}
 42757			c := v_0_1.AuxInt
 42758			v_1 := v.Args[1]
 42759			if v_1.Op != OpConst64 {
 42760				break
 42761			}
 42762			d := v_1.AuxInt
 42763			if !(!uaddOvf(c, d)) {
 42764				break
 42765			}
 42766			v.reset(OpRsh8Ux64)
 42767			v.AddArg(x)
 42768			v0 := b.NewValue0(v.Pos, OpConst64, t)
 42769			v0.AuxInt = c + d
 42770			v.AddArg(v0)
 42771			return true
 42772		}
 42773		// match: (Rsh8Ux64 (Rsh8x64 x _) (Const64 <t> [7]))
 42774		// cond:
 42775		// result: (Rsh8Ux64 x (Const64 <t> [7] ))
 42776		for {
 42777			_ = v.Args[1]
 42778			v_0 := v.Args[0]
 42779			if v_0.Op != OpRsh8x64 {
 42780				break
 42781			}
 42782			_ = v_0.Args[1]
 42783			x := v_0.Args[0]
 42784			v_1 := v.Args[1]
 42785			if v_1.Op != OpConst64 {
 42786				break
 42787			}
 42788			t := v_1.Type
 42789			if v_1.AuxInt != 7 {
 42790				break
 42791			}
 42792			v.reset(OpRsh8Ux64)
 42793			v.AddArg(x)
 42794			v0 := b.NewValue0(v.Pos, OpConst64, t)
 42795			v0.AuxInt = 7
 42796			v.AddArg(v0)
 42797			return true
 42798		}
 42799		// match: (Rsh8Ux64 (Lsh8x64 (Rsh8Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
 42800		// cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
 42801		// result: (Rsh8Ux64 x (Const64 <typ.UInt64> [c1-c2+c3]))
 42802		for {
 42803			_ = v.Args[1]
 42804			v_0 := v.Args[0]
 42805			if v_0.Op != OpLsh8x64 {
 42806				break
 42807			}
 42808			_ = v_0.Args[1]
 42809			v_0_0 := v_0.Args[0]
 42810			if v_0_0.Op != OpRsh8Ux64 {
 42811				break
 42812			}
 42813			_ = v_0_0.Args[1]
 42814			x := v_0_0.Args[0]
 42815			v_0_0_1 := v_0_0.Args[1]
 42816			if v_0_0_1.Op != OpConst64 {
 42817				break
 42818			}
 42819			c1 := v_0_0_1.AuxInt
 42820			v_0_1 := v_0.Args[1]
 42821			if v_0_1.Op != OpConst64 {
 42822				break
 42823			}
 42824			c2 := v_0_1.AuxInt
 42825			v_1 := v.Args[1]
 42826			if v_1.Op != OpConst64 {
 42827				break
 42828			}
 42829			c3 := v_1.AuxInt
 42830			if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) {
 42831				break
 42832			}
 42833			v.reset(OpRsh8Ux64)
 42834			v.AddArg(x)
 42835			v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 42836			v0.AuxInt = c1 - c2 + c3
 42837			v.AddArg(v0)
 42838			return true
 42839		}
 42840		return false
 42841	}
 42842	func rewriteValuegeneric_OpRsh8Ux8_0(v *Value) bool {
 42843		b := v.Block
 42844		// match: (Rsh8Ux8 <t> x (Const8 [c]))
 42845		// cond:
 42846		// result: (Rsh8Ux64 x (Const64 <t> [int64(uint8(c))]))
 42847		for {
 42848			t := v.Type
 42849			_ = v.Args[1]
 42850			x := v.Args[0]
 42851			v_1 := v.Args[1]
 42852			if v_1.Op != OpConst8 {
 42853				break
 42854			}
 42855			c := v_1.AuxInt
 42856			v.reset(OpRsh8Ux64)
 42857			v.AddArg(x)
 42858			v0 := b.NewValue0(v.Pos, OpConst64, t)
 42859			v0.AuxInt = int64(uint8(c))
 42860			v.AddArg(v0)
 42861			return true
 42862		}
 42863		// match: (Rsh8Ux8 (Const8 [0]) _)
 42864		// cond:
 42865		// result: (Const8 [0])
 42866		for {
 42867			_ = v.Args[1]
 42868			v_0 := v.Args[0]
 42869			if v_0.Op != OpConst8 {
 42870				break
 42871			}
 42872			if v_0.AuxInt != 0 {
 42873				break
 42874			}
 42875			v.reset(OpConst8)
 42876			v.AuxInt = 0
 42877			return true
 42878		}
 42879		return false
 42880	}
 42881	func rewriteValuegeneric_OpRsh8x16_0(v *Value) bool {
 42882		b := v.Block
 42883		// match: (Rsh8x16 <t> x (Const16 [c]))
 42884		// cond:
 42885		// result: (Rsh8x64 x (Const64 <t> [int64(uint16(c))]))
 42886		for {
 42887			t := v.Type
 42888			_ = v.Args[1]
 42889			x := v.Args[0]
 42890			v_1 := v.Args[1]
 42891			if v_1.Op != OpConst16 {
 42892				break
 42893			}
 42894			c := v_1.AuxInt
 42895			v.reset(OpRsh8x64)
 42896			v.AddArg(x)
 42897			v0 := b.NewValue0(v.Pos, OpConst64, t)
 42898			v0.AuxInt = int64(uint16(c))
 42899			v.AddArg(v0)
 42900			return true
 42901		}
 42902		// match: (Rsh8x16 (Const8 [0]) _)
 42903		// cond:
 42904		// result: (Const8 [0])
 42905		for {
 42906			_ = v.Args[1]
 42907			v_0 := v.Args[0]
 42908			if v_0.Op != OpConst8 {
 42909				break
 42910			}
 42911			if v_0.AuxInt != 0 {
 42912				break
 42913			}
 42914			v.reset(OpConst8)
 42915			v.AuxInt = 0
 42916			return true
 42917		}
 42918		return false
 42919	}
 42920	func rewriteValuegeneric_OpRsh8x32_0(v *Value) bool {
 42921		b := v.Block
 42922		// match: (Rsh8x32 <t> x (Const32 [c]))
 42923		// cond:
 42924		// result: (Rsh8x64 x (Const64 <t> [int64(uint32(c))]))
 42925		for {
 42926			t := v.Type
 42927			_ = v.Args[1]
 42928			x := v.Args[0]
 42929			v_1 := v.Args[1]
 42930			if v_1.Op != OpConst32 {
 42931				break
 42932			}
 42933			c := v_1.AuxInt
 42934			v.reset(OpRsh8x64)
 42935			v.AddArg(x)
 42936			v0 := b.NewValue0(v.Pos, OpConst64, t)
 42937			v0.AuxInt = int64(uint32(c))
 42938			v.AddArg(v0)
 42939			return true
 42940		}
 42941		// match: (Rsh8x32 (Const8 [0]) _)
 42942		// cond:
 42943		// result: (Const8 [0])
 42944		for {
 42945			_ = v.Args[1]
 42946			v_0 := v.Args[0]
 42947			if v_0.Op != OpConst8 {
 42948				break
 42949			}
 42950			if v_0.AuxInt != 0 {
 42951				break
 42952			}
 42953			v.reset(OpConst8)
 42954			v.AuxInt = 0
 42955			return true
 42956		}
 42957		return false
 42958	}
 42959	func rewriteValuegeneric_OpRsh8x64_0(v *Value) bool {
 42960		b := v.Block
 42961		// match: (Rsh8x64 (Const8 [c]) (Const64 [d]))
 42962		// cond:
 42963		// result: (Const8 [int64(int8(c) >> uint64(d))])
 42964		for {
 42965			_ = v.Args[1]
 42966			v_0 := v.Args[0]
 42967			if v_0.Op != OpConst8 {
 42968				break
 42969			}
 42970			c := v_0.AuxInt
 42971			v_1 := v.Args[1]
 42972			if v_1.Op != OpConst64 {
 42973				break
 42974			}
 42975			d := v_1.AuxInt
 42976			v.reset(OpConst8)
 42977			v.AuxInt = int64(int8(c) >> uint64(d))
 42978			return true
 42979		}
 42980		// match: (Rsh8x64 x (Const64 [0]))
 42981		// cond:
 42982		// result: x
 42983		for {
 42984			_ = v.Args[1]
 42985			x := v.Args[0]
 42986			v_1 := v.Args[1]
 42987			if v_1.Op != OpConst64 {
 42988				break
 42989			}
 42990			if v_1.AuxInt != 0 {
 42991				break
 42992			}
 42993			v.reset(OpCopy)
 42994			v.Type = x.Type
 42995			v.AddArg(x)
 42996			return true
 42997		}
 42998		// match: (Rsh8x64 (Const8 [0]) _)
 42999		// cond:
 43000		// result: (Const8 [0])
 43001		for {
 43002			_ = v.Args[1]
 43003			v_0 := v.Args[0]
 43004			if v_0.Op != OpConst8 {
 43005				break
 43006			}
 43007			if v_0.AuxInt != 0 {
 43008				break
 43009			}
 43010			v.reset(OpConst8)
 43011			v.AuxInt = 0
 43012			return true
 43013		}
 43014		// match: (Rsh8x64 <t> (Rsh8x64 x (Const64 [c])) (Const64 [d]))
 43015		// cond: !uaddOvf(c,d)
 43016		// result: (Rsh8x64 x (Const64 <t> [c+d]))
 43017		for {
 43018			t := v.Type
 43019			_ = v.Args[1]
 43020			v_0 := v.Args[0]
 43021			if v_0.Op != OpRsh8x64 {
 43022				break
 43023			}
 43024			_ = v_0.Args[1]
 43025			x := v_0.Args[0]
 43026			v_0_1 := v_0.Args[1]
 43027			if v_0_1.Op != OpConst64 {
 43028				break
 43029			}
 43030			c := v_0_1.AuxInt
 43031			v_1 := v.Args[1]
 43032			if v_1.Op != OpConst64 {
 43033				break
 43034			}
 43035			d := v_1.AuxInt
 43036			if !(!uaddOvf(c, d)) {
 43037				break
 43038			}
 43039			v.reset(OpRsh8x64)
 43040			v.AddArg(x)
 43041			v0 := b.NewValue0(v.Pos, OpConst64, t)
 43042			v0.AuxInt = c + d
 43043			v.AddArg(v0)
 43044			return true
 43045		}
 43046		return false
 43047	}
 43048	func rewriteValuegeneric_OpRsh8x8_0(v *Value) bool {
 43049		b := v.Block
 43050		// match: (Rsh8x8 <t> x (Const8 [c]))
 43051		// cond:
 43052		// result: (Rsh8x64 x (Const64 <t> [int64(uint8(c))]))
 43053		for {
 43054			t := v.Type
 43055			_ = v.Args[1]
 43056			x := v.Args[0]
 43057			v_1 := v.Args[1]
 43058			if v_1.Op != OpConst8 {
 43059				break
 43060			}
 43061			c := v_1.AuxInt
 43062			v.reset(OpRsh8x64)
 43063			v.AddArg(x)
 43064			v0 := b.NewValue0(v.Pos, OpConst64, t)
 43065			v0.AuxInt = int64(uint8(c))
 43066			v.AddArg(v0)
 43067			return true
 43068		}
 43069		// match: (Rsh8x8 (Const8 [0]) _)
 43070		// cond:
 43071		// result: (Const8 [0])
 43072		for {
 43073			_ = v.Args[1]
 43074			v_0 := v.Args[0]
 43075			if v_0.Op != OpConst8 {
 43076				break
 43077			}
 43078			if v_0.AuxInt != 0 {
 43079				break
 43080			}
 43081			v.reset(OpConst8)
 43082			v.AuxInt = 0
 43083			return true
 43084		}
 43085		return false
 43086	}
 43087	func rewriteValuegeneric_OpSelect0_0(v *Value) bool {
 43088		// match: (Select0 (Div128u (Const64 [0]) lo y))
 43089		// cond:
 43090		// result: (Div64u lo y)
 43091		for {
 43092			v_0 := v.Args[0]
 43093			if v_0.Op != OpDiv128u {
 43094				break
 43095			}
 43096			y := v_0.Args[2]
 43097			v_0_0 := v_0.Args[0]
 43098			if v_0_0.Op != OpConst64 {
 43099				break
 43100			}
 43101			if v_0_0.AuxInt != 0 {
 43102				break
 43103			}
 43104			lo := v_0.Args[1]
 43105			v.reset(OpDiv64u)
 43106			v.AddArg(lo)
 43107			v.AddArg(y)
 43108			return true
 43109		}
 43110		return false
 43111	}
 43112	func rewriteValuegeneric_OpSelect1_0(v *Value) bool {
 43113		// match: (Select1 (Div128u (Const64 [0]) lo y))
 43114		// cond:
 43115		// result: (Mod64u lo y)
 43116		for {
 43117			v_0 := v.Args[0]
 43118			if v_0.Op != OpDiv128u {
 43119				break
 43120			}
 43121			y := v_0.Args[2]
 43122			v_0_0 := v_0.Args[0]
 43123			if v_0_0.Op != OpConst64 {
 43124				break
 43125			}
 43126			if v_0_0.AuxInt != 0 {
 43127				break
 43128			}
 43129			lo := v_0.Args[1]
 43130			v.reset(OpMod64u)
 43131			v.AddArg(lo)
 43132			v.AddArg(y)
 43133			return true
 43134		}
 43135		return false
 43136	}
 43137	func rewriteValuegeneric_OpSignExt16to32_0(v *Value) bool {
 43138		// match: (SignExt16to32 (Const16 [c]))
 43139		// cond:
 43140		// result: (Const32 [int64( int16(c))])
 43141		for {
 43142			v_0 := v.Args[0]
 43143			if v_0.Op != OpConst16 {
 43144				break
 43145			}
 43146			c := v_0.AuxInt
 43147			v.reset(OpConst32)
 43148			v.AuxInt = int64(int16(c))
 43149			return true
 43150		}
 43151		// match: (SignExt16to32 (Trunc32to16 x:(Rsh32x64 _ (Const64 [s]))))
 43152		// cond: s >= 16
 43153		// result: x
 43154		for {
 43155			v_0 := v.Args[0]
 43156			if v_0.Op != OpTrunc32to16 {
 43157				break
 43158			}
 43159			x := v_0.Args[0]
 43160			if x.Op != OpRsh32x64 {
 43161				break
 43162			}
 43163			_ = x.Args[1]
 43164			x_1 := x.Args[1]
 43165			if x_1.Op != OpConst64 {
 43166				break
 43167			}
 43168			s := x_1.AuxInt
 43169			if !(s >= 16) {
 43170				break
 43171			}
 43172			v.reset(OpCopy)
 43173			v.Type = x.Type
 43174			v.AddArg(x)
 43175			return true
 43176		}
 43177		return false
 43178	}
 43179	func rewriteValuegeneric_OpSignExt16to64_0(v *Value) bool {
 43180		// match: (SignExt16to64 (Const16 [c]))
 43181		// cond:
 43182		// result: (Const64 [int64( int16(c))])
 43183		for {
 43184			v_0 := v.Args[0]
 43185			if v_0.Op != OpConst16 {
 43186				break
 43187			}
 43188			c := v_0.AuxInt
 43189			v.reset(OpConst64)
 43190			v.AuxInt = int64(int16(c))
 43191			return true
 43192		}
 43193		// match: (SignExt16to64 (Trunc64to16 x:(Rsh64x64 _ (Const64 [s]))))
 43194		// cond: s >= 48
 43195		// result: x
 43196		for {
 43197			v_0 := v.Args[0]
 43198			if v_0.Op != OpTrunc64to16 {
 43199				break
 43200			}
 43201			x := v_0.Args[0]
 43202			if x.Op != OpRsh64x64 {
 43203				break
 43204			}
 43205			_ = x.Args[1]
 43206			x_1 := x.Args[1]
 43207			if x_1.Op != OpConst64 {
 43208				break
 43209			}
 43210			s := x_1.AuxInt
 43211			if !(s >= 48) {
 43212				break
 43213			}
 43214			v.reset(OpCopy)
 43215			v.Type = x.Type
 43216			v.AddArg(x)
 43217			return true
 43218		}
 43219		return false
 43220	}
 43221	func rewriteValuegeneric_OpSignExt32to64_0(v *Value) bool {
 43222		// match: (SignExt32to64 (Const32 [c]))
 43223		// cond:
 43224		// result: (Const64 [int64( int32(c))])
 43225		for {
 43226			v_0 := v.Args[0]
 43227			if v_0.Op != OpConst32 {
 43228				break
 43229			}
 43230			c := v_0.AuxInt
 43231			v.reset(OpConst64)
 43232			v.AuxInt = int64(int32(c))
 43233			return true
 43234		}
 43235		// match: (SignExt32to64 (Trunc64to32 x:(Rsh64x64 _ (Const64 [s]))))
 43236		// cond: s >= 32
 43237		// result: x
 43238		for {
 43239			v_0 := v.Args[0]
 43240			if v_0.Op != OpTrunc64to32 {
 43241				break
 43242			}
 43243			x := v_0.Args[0]
 43244			if x.Op != OpRsh64x64 {
 43245				break
 43246			}
 43247			_ = x.Args[1]
 43248			x_1 := x.Args[1]
 43249			if x_1.Op != OpConst64 {
 43250				break
 43251			}
 43252			s := x_1.AuxInt
 43253			if !(s >= 32) {
 43254				break
 43255			}
 43256			v.reset(OpCopy)
 43257			v.Type = x.Type
 43258			v.AddArg(x)
 43259			return true
 43260		}
 43261		return false
 43262	}
 43263	func rewriteValuegeneric_OpSignExt8to16_0(v *Value) bool {
 43264		// match: (SignExt8to16 (Const8 [c]))
 43265		// cond:
 43266		// result: (Const16 [int64( int8(c))])
 43267		for {
 43268			v_0 := v.Args[0]
 43269			if v_0.Op != OpConst8 {
 43270				break
 43271			}
 43272			c := v_0.AuxInt
 43273			v.reset(OpConst16)
 43274			v.AuxInt = int64(int8(c))
 43275			return true
 43276		}
 43277		// match: (SignExt8to16 (Trunc16to8 x:(Rsh16x64 _ (Const64 [s]))))
 43278		// cond: s >= 8
 43279		// result: x
 43280		for {
 43281			v_0 := v.Args[0]
 43282			if v_0.Op != OpTrunc16to8 {
 43283				break
 43284			}
 43285			x := v_0.Args[0]
 43286			if x.Op != OpRsh16x64 {
 43287				break
 43288			}
 43289			_ = x.Args[1]
 43290			x_1 := x.Args[1]
 43291			if x_1.Op != OpConst64 {
 43292				break
 43293			}
 43294			s := x_1.AuxInt
 43295			if !(s >= 8) {
 43296				break
 43297			}
 43298			v.reset(OpCopy)
 43299			v.Type = x.Type
 43300			v.AddArg(x)
 43301			return true
 43302		}
 43303		return false
 43304	}
 43305	func rewriteValuegeneric_OpSignExt8to32_0(v *Value) bool {
 43306		// match: (SignExt8to32 (Const8 [c]))
 43307		// cond:
 43308		// result: (Const32 [int64( int8(c))])
 43309		for {
 43310			v_0 := v.Args[0]
 43311			if v_0.Op != OpConst8 {
 43312				break
 43313			}
 43314			c := v_0.AuxInt
 43315			v.reset(OpConst32)
 43316			v.AuxInt = int64(int8(c))
 43317			return true
 43318		}
 43319		// match: (SignExt8to32 (Trunc32to8 x:(Rsh32x64 _ (Const64 [s]))))
 43320		// cond: s >= 24
 43321		// result: x
 43322		for {
 43323			v_0 := v.Args[0]
 43324			if v_0.Op != OpTrunc32to8 {
 43325				break
 43326			}
 43327			x := v_0.Args[0]
 43328			if x.Op != OpRsh32x64 {
 43329				break
 43330			}
 43331			_ = x.Args[1]
 43332			x_1 := x.Args[1]
 43333			if x_1.Op != OpConst64 {
 43334				break
 43335			}
 43336			s := x_1.AuxInt
 43337			if !(s >= 24) {
 43338				break
 43339			}
 43340			v.reset(OpCopy)
 43341			v.Type = x.Type
 43342			v.AddArg(x)
 43343			return true
 43344		}
 43345		return false
 43346	}
 43347	func rewriteValuegeneric_OpSignExt8to64_0(v *Value) bool {
 43348		// match: (SignExt8to64 (Const8 [c]))
 43349		// cond:
 43350		// result: (Const64 [int64( int8(c))])
 43351		for {
 43352			v_0 := v.Args[0]
 43353			if v_0.Op != OpConst8 {
 43354				break
 43355			}
 43356			c := v_0.AuxInt
 43357			v.reset(OpConst64)
 43358			v.AuxInt = int64(int8(c))
 43359			return true
 43360		}
 43361		// match: (SignExt8to64 (Trunc64to8 x:(Rsh64x64 _ (Const64 [s]))))
 43362		// cond: s >= 56
 43363		// result: x
 43364		for {
 43365			v_0 := v.Args[0]
 43366			if v_0.Op != OpTrunc64to8 {
 43367				break
 43368			}
 43369			x := v_0.Args[0]
 43370			if x.Op != OpRsh64x64 {
 43371				break
 43372			}
 43373			_ = x.Args[1]
 43374			x_1 := x.Args[1]
 43375			if x_1.Op != OpConst64 {
 43376				break
 43377			}
 43378			s := x_1.AuxInt
 43379			if !(s >= 56) {
 43380				break
 43381			}
 43382			v.reset(OpCopy)
 43383			v.Type = x.Type
 43384			v.AddArg(x)
 43385			return true
 43386		}
 43387		return false
 43388	}
 43389	func rewriteValuegeneric_OpSliceCap_0(v *Value) bool {
 43390		// match: (SliceCap (SliceMake _ _ (Const64 <t> [c])))
 43391		// cond:
 43392		// result: (Const64 <t> [c])
 43393		for {
 43394			v_0 := v.Args[0]
 43395			if v_0.Op != OpSliceMake {
 43396				break
 43397			}
 43398			_ = v_0.Args[2]
 43399			v_0_2 := v_0.Args[2]
 43400			if v_0_2.Op != OpConst64 {
 43401				break
 43402			}
 43403			t := v_0_2.Type
 43404			c := v_0_2.AuxInt
 43405			v.reset(OpConst64)
 43406			v.Type = t
 43407			v.AuxInt = c
 43408			return true
 43409		}
 43410		// match: (SliceCap (SliceMake _ _ (Const32 <t> [c])))
 43411		// cond:
 43412		// result: (Const32 <t> [c])
 43413		for {
 43414			v_0 := v.Args[0]
 43415			if v_0.Op != OpSliceMake {
 43416				break
 43417			}
 43418			_ = v_0.Args[2]
 43419			v_0_2 := v_0.Args[2]
 43420			if v_0_2.Op != OpConst32 {
 43421				break
 43422			}
 43423			t := v_0_2.Type
 43424			c := v_0_2.AuxInt
 43425			v.reset(OpConst32)
 43426			v.Type = t
 43427			v.AuxInt = c
 43428			return true
 43429		}
 43430		// match: (SliceCap (SliceMake _ _ (SliceCap x)))
 43431		// cond:
 43432		// result: (SliceCap x)
 43433		for {
 43434			v_0 := v.Args[0]
 43435			if v_0.Op != OpSliceMake {
 43436				break
 43437			}
 43438			_ = v_0.Args[2]
 43439			v_0_2 := v_0.Args[2]
 43440			if v_0_2.Op != OpSliceCap {
 43441				break
 43442			}
 43443			x := v_0_2.Args[0]
 43444			v.reset(OpSliceCap)
 43445			v.AddArg(x)
 43446			return true
 43447		}
 43448		// match: (SliceCap (SliceMake _ _ (SliceLen x)))
 43449		// cond:
 43450		// result: (SliceLen x)
 43451		for {
 43452			v_0 := v.Args[0]
 43453			if v_0.Op != OpSliceMake {
 43454				break
 43455			}
 43456			_ = v_0.Args[2]
 43457			v_0_2 := v_0.Args[2]
 43458			if v_0_2.Op != OpSliceLen {
 43459				break
 43460			}
 43461			x := v_0_2.Args[0]
 43462			v.reset(OpSliceLen)
 43463			v.AddArg(x)
 43464			return true
 43465		}
 43466		return false
 43467	}
 43468	func rewriteValuegeneric_OpSliceLen_0(v *Value) bool {
 43469		// match: (SliceLen (SliceMake _ (Const64 <t> [c]) _))
 43470		// cond:
 43471		// result: (Const64 <t> [c])
 43472		for {
 43473			v_0 := v.Args[0]
 43474			if v_0.Op != OpSliceMake {
 43475				break
 43476			}
 43477			_ = v_0.Args[2]
 43478			v_0_1 := v_0.Args[1]
 43479			if v_0_1.Op != OpConst64 {
 43480				break
 43481			}
 43482			t := v_0_1.Type
 43483			c := v_0_1.AuxInt
 43484			v.reset(OpConst64)
 43485			v.Type = t
 43486			v.AuxInt = c
 43487			return true
 43488		}
 43489		// match: (SliceLen (SliceMake _ (Const32 <t> [c]) _))
 43490		// cond:
 43491		// result: (Const32 <t> [c])
 43492		for {
 43493			v_0 := v.Args[0]
 43494			if v_0.Op != OpSliceMake {
 43495				break
 43496			}
 43497			_ = v_0.Args[2]
 43498			v_0_1 := v_0.Args[1]
 43499			if v_0_1.Op != OpConst32 {
 43500				break
 43501			}
 43502			t := v_0_1.Type
 43503			c := v_0_1.AuxInt
 43504			v.reset(OpConst32)
 43505			v.Type = t
 43506			v.AuxInt = c
 43507			return true
 43508		}
 43509		// match: (SliceLen (SliceMake _ (SliceLen x) _))
 43510		// cond:
 43511		// result: (SliceLen x)
 43512		for {
 43513			v_0 := v.Args[0]
 43514			if v_0.Op != OpSliceMake {
 43515				break
 43516			}
 43517			_ = v_0.Args[2]
 43518			v_0_1 := v_0.Args[1]
 43519			if v_0_1.Op != OpSliceLen {
 43520				break
 43521			}
 43522			x := v_0_1.Args[0]
 43523			v.reset(OpSliceLen)
 43524			v.AddArg(x)
 43525			return true
 43526		}
 43527		return false
 43528	}
 43529	func rewriteValuegeneric_OpSlicePtr_0(v *Value) bool {
 43530		// match: (SlicePtr (SliceMake (SlicePtr x) _ _))
 43531		// cond:
 43532		// result: (SlicePtr x)
 43533		for {
 43534			v_0 := v.Args[0]
 43535			if v_0.Op != OpSliceMake {
 43536				break
 43537			}
 43538			_ = v_0.Args[2]
 43539			v_0_0 := v_0.Args[0]
 43540			if v_0_0.Op != OpSlicePtr {
 43541				break
 43542			}
 43543			x := v_0_0.Args[0]
 43544			v.reset(OpSlicePtr)
 43545			v.AddArg(x)
 43546			return true
 43547		}
 43548		return false
 43549	}
 43550	func rewriteValuegeneric_OpSlicemask_0(v *Value) bool {
 43551		// match: (Slicemask (Const32 [x]))
 43552		// cond: x > 0
 43553		// result: (Const32 [-1])
 43554		for {
 43555			v_0 := v.Args[0]
 43556			if v_0.Op != OpConst32 {
 43557				break
 43558			}
 43559			x := v_0.AuxInt
 43560			if !(x > 0) {
 43561				break
 43562			}
 43563			v.reset(OpConst32)
 43564			v.AuxInt = -1
 43565			return true
 43566		}
 43567		// match: (Slicemask (Const32 [0]))
 43568		// cond:
 43569		// result: (Const32 [0])
 43570		for {
 43571			v_0 := v.Args[0]
 43572			if v_0.Op != OpConst32 {
 43573				break
 43574			}
 43575			if v_0.AuxInt != 0 {
 43576				break
 43577			}
 43578			v.reset(OpConst32)
 43579			v.AuxInt = 0
 43580			return true
 43581		}
 43582		// match: (Slicemask (Const64 [x]))
 43583		// cond: x > 0
 43584		// result: (Const64 [-1])
 43585		for {
 43586			v_0 := v.Args[0]
 43587			if v_0.Op != OpConst64 {
 43588				break
 43589			}
 43590			x := v_0.AuxInt
 43591			if !(x > 0) {
 43592				break
 43593			}
 43594			v.reset(OpConst64)
 43595			v.AuxInt = -1
 43596			return true
 43597		}
 43598		// match: (Slicemask (Const64 [0]))
 43599		// cond:
 43600		// result: (Const64 [0])
 43601		for {
 43602			v_0 := v.Args[0]
 43603			if v_0.Op != OpConst64 {
 43604				break
 43605			}
 43606			if v_0.AuxInt != 0 {
 43607				break
 43608			}
 43609			v.reset(OpConst64)
 43610			v.AuxInt = 0
 43611			return true
 43612		}
 43613		return false
 43614	}
 43615	func rewriteValuegeneric_OpSqrt_0(v *Value) bool {
 43616		// match: (Sqrt (Const64F [c]))
 43617		// cond:
 43618		// result: (Const64F [auxFrom64F(math.Sqrt(auxTo64F(c)))])
 43619		for {
 43620			v_0 := v.Args[0]
 43621			if v_0.Op != OpConst64F {
 43622				break
 43623			}
 43624			c := v_0.AuxInt
 43625			v.reset(OpConst64F)
 43626			v.AuxInt = auxFrom64F(math.Sqrt(auxTo64F(c)))
 43627			return true
 43628		}
 43629		return false
 43630	}
 43631	func rewriteValuegeneric_OpStaticCall_0(v *Value) bool {
 43632		b := v.Block
 43633		config := b.Func.Config
 43634		// match: (StaticCall {sym} s1:(Store _ (Const64 [sz]) s2:(Store _ src s3:(Store {t} _ dst mem))))
 43635		// cond: isSameSym(sym,"runtime.memmove") && t.(*types.Type).IsPtr() && s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1 && isInlinableMemmove(dst,src,sz,config) && clobber(s1) && clobber(s2) && clobber(s3)
 43636		// result: (Move {t.(*types.Type).Elem()} [sz] dst src mem)
 43637		for {
 43638			sym := v.Aux
 43639			s1 := v.Args[0]
 43640			if s1.Op != OpStore {
 43641				break
 43642			}
 43643			_ = s1.Args[2]
 43644			s1_1 := s1.Args[1]
 43645			if s1_1.Op != OpConst64 {
 43646				break
 43647			}
 43648			sz := s1_1.AuxInt
 43649			s2 := s1.Args[2]
 43650			if s2.Op != OpStore {
 43651				break
 43652			}
 43653			_ = s2.Args[2]
 43654			src := s2.Args[1]
 43655			s3 := s2.Args[2]
 43656			if s3.Op != OpStore {
 43657				break
 43658			}
 43659			t := s3.Aux
 43660			mem := s3.Args[2]
 43661			dst := s3.Args[1]
 43662			if !(isSameSym(sym, "runtime.memmove") && t.(*types.Type).IsPtr() && s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1 && isInlinableMemmove(dst, src, sz, config) && clobber(s1) && clobber(s2) && clobber(s3)) {
 43663				break
 43664			}
 43665			v.reset(OpMove)
 43666			v.AuxInt = sz
 43667			v.Aux = t.(*types.Type).Elem()
 43668			v.AddArg(dst)
 43669			v.AddArg(src)
 43670			v.AddArg(mem)
 43671			return true
 43672		}
 43673		// match: (StaticCall {sym} s1:(Store _ (Const32 [sz]) s2:(Store _ src s3:(Store {t} _ dst mem))))
 43674		// cond: isSameSym(sym,"runtime.memmove") && t.(*types.Type).IsPtr() && s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1 && isInlinableMemmove(dst,src,sz,config) && clobber(s1) && clobber(s2) && clobber(s3)
 43675		// result: (Move {t.(*types.Type).Elem()} [sz] dst src mem)
 43676		for {
 43677			sym := v.Aux
 43678			s1 := v.Args[0]
 43679			if s1.Op != OpStore {
 43680				break
 43681			}
 43682			_ = s1.Args[2]
 43683			s1_1 := s1.Args[1]
 43684			if s1_1.Op != OpConst32 {
 43685				break
 43686			}
 43687			sz := s1_1.AuxInt
 43688			s2 := s1.Args[2]
 43689			if s2.Op != OpStore {
 43690				break
 43691			}
 43692			_ = s2.Args[2]
 43693			src := s2.Args[1]
 43694			s3 := s2.Args[2]
 43695			if s3.Op != OpStore {
 43696				break
 43697			}
 43698			t := s3.Aux
 43699			mem := s3.Args[2]
 43700			dst := s3.Args[1]
 43701			if !(isSameSym(sym, "runtime.memmove") && t.(*types.Type).IsPtr() && s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1 && isInlinableMemmove(dst, src, sz, config) && clobber(s1) && clobber(s2) && clobber(s3)) {
 43702				break
 43703			}
 43704			v.reset(OpMove)
 43705			v.AuxInt = sz
 43706			v.Aux = t.(*types.Type).Elem()
 43707			v.AddArg(dst)
 43708			v.AddArg(src)
 43709			v.AddArg(mem)
 43710			return true
 43711		}
 43712		// match: (StaticCall {sym} x)
 43713		// cond: needRaceCleanup(sym,v)
 43714		// result: x
 43715		for {
 43716			sym := v.Aux
 43717			x := v.Args[0]
 43718			if !(needRaceCleanup(sym, v)) {
 43719				break
 43720			}
 43721			v.reset(OpCopy)
 43722			v.Type = x.Type
 43723			v.AddArg(x)
 43724			return true
 43725		}
 43726		return false
 43727	}
 43728	func rewriteValuegeneric_OpStore_0(v *Value) bool {
 43729		b := v.Block
 43730		// match: (Store {t1} p1 (Load <t2> p2 mem) mem)
 43731		// cond: isSamePtr(p1, p2) && t2.Size() == sizeof(t1)
 43732		// result: mem
 43733		for {
 43734			t1 := v.Aux
 43735			mem := v.Args[2]
 43736			p1 := v.Args[0]
 43737			v_1 := v.Args[1]
 43738			if v_1.Op != OpLoad {
 43739				break
 43740			}
 43741			t2 := v_1.Type
 43742			_ = v_1.Args[1]
 43743			p2 := v_1.Args[0]
 43744			if mem != v_1.Args[1] {
 43745				break
 43746			}
 43747			if !(isSamePtr(p1, p2) && t2.Size() == sizeof(t1)) {
 43748				break
 43749			}
 43750			v.reset(OpCopy)
 43751			v.Type = mem.Type
 43752			v.AddArg(mem)
 43753			return true
 43754		}
 43755		// match: (Store {t1} p1 (Load <t2> p2 oldmem) mem:(Store {t3} p3 _ oldmem))
 43756		// cond: isSamePtr(p1, p2) && t2.Size() == sizeof(t1) && disjoint(p1, sizeof(t1), p3, sizeof(t3))
 43757		// result: mem
 43758		for {
 43759			t1 := v.Aux
 43760			_ = v.Args[2]
 43761			p1 := v.Args[0]
 43762			v_1 := v.Args[1]
 43763			if v_1.Op != OpLoad {
 43764				break
 43765			}
 43766			t2 := v_1.Type
 43767			oldmem := v_1.Args[1]
 43768			p2 := v_1.Args[0]
 43769			mem := v.Args[2]
 43770			if mem.Op != OpStore {
 43771				break
 43772			}
 43773			t3 := mem.Aux
 43774			_ = mem.Args[2]
 43775			p3 := mem.Args[0]
 43776			if oldmem != mem.Args[2] {
 43777				break
 43778			}
 43779			if !(isSamePtr(p1, p2) && t2.Size() == sizeof(t1) && disjoint(p1, sizeof(t1), p3, sizeof(t3))) {
 43780				break
 43781			}
 43782			v.reset(OpCopy)
 43783			v.Type = mem.Type
 43784			v.AddArg(mem)
 43785			return true
 43786		}
 43787		// match: (Store {t1} p1 (Load <t2> p2 oldmem) mem:(Store {t3} p3 _ (Store {t4} p4 _ oldmem)))
 43788		// cond: isSamePtr(p1, p2) && t2.Size() == sizeof(t1) && disjoint(p1, sizeof(t1), p3, sizeof(t3)) && disjoint(p1, sizeof(t1), p4, sizeof(t4))
 43789		// result: mem
 43790		for {
 43791			t1 := v.Aux
 43792			_ = v.Args[2]
 43793			p1 := v.Args[0]
 43794			v_1 := v.Args[1]
 43795			if v_1.Op != OpLoad {
 43796				break
 43797			}
 43798			t2 := v_1.Type
 43799			oldmem := v_1.Args[1]
 43800			p2 := v_1.Args[0]
 43801			mem := v.Args[2]
 43802			if mem.Op != OpStore {
 43803				break
 43804			}
 43805			t3 := mem.Aux
 43806			_ = mem.Args[2]
 43807			p3 := mem.Args[0]
 43808			mem_2 := mem.Args[2]
 43809			if mem_2.Op != OpStore {
 43810				break
 43811			}
 43812			t4 := mem_2.Aux
 43813			_ = mem_2.Args[2]
 43814			p4 := mem_2.Args[0]
 43815			if oldmem != mem_2.Args[2] {
 43816				break
 43817			}
 43818			if !(isSamePtr(p1, p2) && t2.Size() == sizeof(t1) && disjoint(p1, sizeof(t1), p3, sizeof(t3)) && disjoint(p1, sizeof(t1), p4, sizeof(t4))) {
 43819				break
 43820			}
 43821			v.reset(OpCopy)
 43822			v.Type = mem.Type
 43823			v.AddArg(mem)
 43824			return true
 43825		}
 43826		// match: (Store {t1} p1 (Load <t2> p2 oldmem) mem:(Store {t3} p3 _ (Store {t4} p4 _ (Store {t5} p5 _ oldmem))))
 43827		// cond: isSamePtr(p1, p2) && t2.Size() == sizeof(t1) && disjoint(p1, sizeof(t1), p3, sizeof(t3)) && disjoint(p1, sizeof(t1), p4, sizeof(t4)) && disjoint(p1, sizeof(t1), p5, sizeof(t5))
 43828		// result: mem
 43829		for {
 43830			t1 := v.Aux
 43831			_ = v.Args[2]
 43832			p1 := v.Args[0]
 43833			v_1 := v.Args[1]
 43834			if v_1.Op != OpLoad {
 43835				break
 43836			}
 43837			t2 := v_1.Type
 43838			oldmem := v_1.Args[1]
 43839			p2 := v_1.Args[0]
 43840			mem := v.Args[2]
 43841			if mem.Op != OpStore {
 43842				break
 43843			}
 43844			t3 := mem.Aux
 43845			_ = mem.Args[2]
 43846			p3 := mem.Args[0]
 43847			mem_2 := mem.Args[2]
 43848			if mem_2.Op != OpStore {
 43849				break
 43850			}
 43851			t4 := mem_2.Aux
 43852			_ = mem_2.Args[2]
 43853			p4 := mem_2.Args[0]
 43854			mem_2_2 := mem_2.Args[2]
 43855			if mem_2_2.Op != OpStore {
 43856				break
 43857			}
 43858			t5 := mem_2_2.Aux
 43859			_ = mem_2_2.Args[2]
 43860			p5 := mem_2_2.Args[0]
 43861			if oldmem != mem_2_2.Args[2] {
 43862				break
 43863			}
 43864			if !(isSamePtr(p1, p2) && t2.Size() == sizeof(t1) && disjoint(p1, sizeof(t1), p3, sizeof(t3)) && disjoint(p1, sizeof(t1), p4, sizeof(t4)) && disjoint(p1, sizeof(t1), p5, sizeof(t5))) {
 43865				break
 43866			}
 43867			v.reset(OpCopy)
 43868			v.Type = mem.Type
 43869			v.AddArg(mem)
 43870			return true
 43871		}
 43872		// match: (Store {t} (OffPtr [o] p1) x mem:(Zero [n] p2 _))
 43873		// cond: isConstZero(x) && o >= 0 && sizeof(t) + o <= n && isSamePtr(p1, p2)
 43874		// result: mem
 43875		for {
 43876			t := v.Aux
 43877			_ = v.Args[2]
 43878			v_0 := v.Args[0]
 43879			if v_0.Op != OpOffPtr {
 43880				break
 43881			}
 43882			o := v_0.AuxInt
 43883			p1 := v_0.Args[0]
 43884			x := v.Args[1]
 43885			mem := v.Args[2]
 43886			if mem.Op != OpZero {
 43887				break
 43888			}
 43889			n := mem.AuxInt
 43890			_ = mem.Args[1]
 43891			p2 := mem.Args[0]
 43892			if !(isConstZero(x) && o >= 0 && sizeof(t)+o <= n && isSamePtr(p1, p2)) {
 43893				break
 43894			}
 43895			v.reset(OpCopy)
 43896			v.Type = mem.Type
 43897			v.AddArg(mem)
 43898			return true
 43899		}
 43900		// match: (Store {t1} op:(OffPtr [o1] p1) x mem:(Store {t2} p2 _ (Zero [n] p3 _)))
 43901		// cond: isConstZero(x) && o1 >= 0 && sizeof(t1) + o1 <= n && isSamePtr(p1, p3) && disjoint(op, sizeof(t1), p2, sizeof(t2))
 43902		// result: mem
 43903		for {
 43904			t1 := v.Aux
 43905			_ = v.Args[2]
 43906			op := v.Args[0]
 43907			if op.Op != OpOffPtr {
 43908				break
 43909			}
 43910			o1 := op.AuxInt
 43911			p1 := op.Args[0]
 43912			x := v.Args[1]
 43913			mem := v.Args[2]
 43914			if mem.Op != OpStore {
 43915				break
 43916			}
 43917			t2 := mem.Aux
 43918			_ = mem.Args[2]
 43919			p2 := mem.Args[0]
 43920			mem_2 := mem.Args[2]
 43921			if mem_2.Op != OpZero {
 43922				break
 43923			}
 43924			n := mem_2.AuxInt
 43925			_ = mem_2.Args[1]
 43926			p3 := mem_2.Args[0]
 43927			if !(isConstZero(x) && o1 >= 0 && sizeof(t1)+o1 <= n && isSamePtr(p1, p3) && disjoint(op, sizeof(t1), p2, sizeof(t2))) {
 43928				break
 43929			}
 43930			v.reset(OpCopy)
 43931			v.Type = mem.Type
 43932			v.AddArg(mem)
 43933			return true
 43934		}
 43935		// match: (Store {t1} op:(OffPtr [o1] p1) x mem:(Store {t2} p2 _ (Store {t3} p3 _ (Zero [n] p4 _))))
 43936		// cond: isConstZero(x) && o1 >= 0 && sizeof(t1) + o1 <= n && isSamePtr(p1, p4) && disjoint(op, sizeof(t1), p2, sizeof(t2)) && disjoint(op, sizeof(t1), p3, sizeof(t3))
 43937		// result: mem
 43938		for {
 43939			t1 := v.Aux
 43940			_ = v.Args[2]
 43941			op := v.Args[0]
 43942			if op.Op != OpOffPtr {
 43943				break
 43944			}
 43945			o1 := op.AuxInt
 43946			p1 := op.Args[0]
 43947			x := v.Args[1]
 43948			mem := v.Args[2]
 43949			if mem.Op != OpStore {
 43950				break
 43951			}
 43952			t2 := mem.Aux
 43953			_ = mem.Args[2]
 43954			p2 := mem.Args[0]
 43955			mem_2 := mem.Args[2]
 43956			if mem_2.Op != OpStore {
 43957				break
 43958			}
 43959			t3 := mem_2.Aux
 43960			_ = mem_2.Args[2]
 43961			p3 := mem_2.Args[0]
 43962			mem_2_2 := mem_2.Args[2]
 43963			if mem_2_2.Op != OpZero {
 43964				break
 43965			}
 43966			n := mem_2_2.AuxInt
 43967			_ = mem_2_2.Args[1]
 43968			p4 := mem_2_2.Args[0]
 43969			if !(isConstZero(x) && o1 >= 0 && sizeof(t1)+o1 <= n && isSamePtr(p1, p4) && disjoint(op, sizeof(t1), p2, sizeof(t2)) && disjoint(op, sizeof(t1), p3, sizeof(t3))) {
 43970				break
 43971			}
 43972			v.reset(OpCopy)
 43973			v.Type = mem.Type
 43974			v.AddArg(mem)
 43975			return true
 43976		}
 43977		// match: (Store {t1} op:(OffPtr [o1] p1) x mem:(Store {t2} p2 _ (Store {t3} p3 _ (Store {t4} p4 _ (Zero [n] p5 _)))))
 43978		// cond: isConstZero(x) && o1 >= 0 && sizeof(t1) + o1 <= n && isSamePtr(p1, p5) && disjoint(op, sizeof(t1), p2, sizeof(t2)) && disjoint(op, sizeof(t1), p3, sizeof(t3)) && disjoint(op, sizeof(t1), p4, sizeof(t4))
 43979		// result: mem
 43980		for {
 43981			t1 := v.Aux
 43982			_ = v.Args[2]
 43983			op := v.Args[0]
 43984			if op.Op != OpOffPtr {
 43985				break
 43986			}
 43987			o1 := op.AuxInt
 43988			p1 := op.Args[0]
 43989			x := v.Args[1]
 43990			mem := v.Args[2]
 43991			if mem.Op != OpStore {
 43992				break
 43993			}
 43994			t2 := mem.Aux
 43995			_ = mem.Args[2]
 43996			p2 := mem.Args[0]
 43997			mem_2 := mem.Args[2]
 43998			if mem_2.Op != OpStore {
 43999				break
 44000			}
 44001			t3 := mem_2.Aux
 44002			_ = mem_2.Args[2]
 44003			p3 := mem_2.Args[0]
 44004			mem_2_2 := mem_2.Args[2]
 44005			if mem_2_2.Op != OpStore {
 44006				break
 44007			}
 44008			t4 := mem_2_2.Aux
 44009			_ = mem_2_2.Args[2]
 44010			p4 := mem_2_2.Args[0]
 44011			mem_2_2_2 := mem_2_2.Args[2]
 44012			if mem_2_2_2.Op != OpZero {
 44013				break
 44014			}
 44015			n := mem_2_2_2.AuxInt
 44016			_ = mem_2_2_2.Args[1]
 44017			p5 := mem_2_2_2.Args[0]
 44018			if !(isConstZero(x) && o1 >= 0 && sizeof(t1)+o1 <= n && isSamePtr(p1, p5) && disjoint(op, sizeof(t1), p2, sizeof(t2)) && disjoint(op, sizeof(t1), p3, sizeof(t3)) && disjoint(op, sizeof(t1), p4, sizeof(t4))) {
 44019				break
 44020			}
 44021			v.reset(OpCopy)
 44022			v.Type = mem.Type
 44023			v.AddArg(mem)
 44024			return true
 44025		}
 44026		// match: (Store _ (StructMake0) mem)
 44027		// cond:
 44028		// result: mem
 44029		for {
 44030			mem := v.Args[2]
 44031			v_1 := v.Args[1]
 44032			if v_1.Op != OpStructMake0 {
 44033				break
 44034			}
 44035			v.reset(OpCopy)
 44036			v.Type = mem.Type
 44037			v.AddArg(mem)
 44038			return true
 44039		}
 44040		// match: (Store dst (StructMake1 <t> f0) mem)
 44041		// cond:
 44042		// result: (Store {t.FieldType(0)} (OffPtr <t.FieldType(0).PtrTo()> [0] dst) f0 mem)
 44043		for {
 44044			mem := v.Args[2]
 44045			dst := v.Args[0]
 44046			v_1 := v.Args[1]
 44047			if v_1.Op != OpStructMake1 {
 44048				break
 44049			}
 44050			t := v_1.Type
 44051			f0 := v_1.Args[0]
 44052			v.reset(OpStore)
 44053			v.Aux = t.FieldType(0)
 44054			v0 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo())
 44055			v0.AuxInt = 0
 44056			v0.AddArg(dst)
 44057			v.AddArg(v0)
 44058			v.AddArg(f0)
 44059			v.AddArg(mem)
 44060			return true
 44061		}
 44062		return false
 44063	}
 44064	func rewriteValuegeneric_OpStore_10(v *Value) bool {
 44065		b := v.Block
 44066		config := b.Func.Config
 44067		fe := b.Func.fe
 44068		// match: (Store dst (StructMake2 <t> f0 f1) mem)
 44069		// cond:
 44070		// result: (Store {t.FieldType(1)} (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] dst) f1 (Store {t.FieldType(0)} (OffPtr <t.FieldType(0).PtrTo()> [0] dst) f0 mem))
 44071		for {
 44072			mem := v.Args[2]
 44073			dst := v.Args[0]
 44074			v_1 := v.Args[1]
 44075			if v_1.Op != OpStructMake2 {
 44076				break
 44077			}
 44078			t := v_1.Type
 44079			f1 := v_1.Args[1]
 44080			f0 := v_1.Args[0]
 44081			v.reset(OpStore)
 44082			v.Aux = t.FieldType(1)
 44083			v0 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(1).PtrTo())
 44084			v0.AuxInt = t.FieldOff(1)
 44085			v0.AddArg(dst)
 44086			v.AddArg(v0)
 44087			v.AddArg(f1)
 44088			v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 44089			v1.Aux = t.FieldType(0)
 44090			v2 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo())
 44091			v2.AuxInt = 0
 44092			v2.AddArg(dst)
 44093			v1.AddArg(v2)
 44094			v1.AddArg(f0)
 44095			v1.AddArg(mem)
 44096			v.AddArg(v1)
 44097			return true
 44098		}
 44099		// match: (Store dst (StructMake3 <t> f0 f1 f2) mem)
 44100		// cond:
 44101		// result: (Store {t.FieldType(2)} (OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] dst) f2 (Store {t.FieldType(1)} (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] dst) f1 (Store {t.FieldType(0)} (OffPtr <t.FieldType(0).PtrTo()> [0] dst) f0 mem)))
 44102		for {
 44103			mem := v.Args[2]
 44104			dst := v.Args[0]
 44105			v_1 := v.Args[1]
 44106			if v_1.Op != OpStructMake3 {
 44107				break
 44108			}
 44109			t := v_1.Type
 44110			f2 := v_1.Args[2]
 44111			f0 := v_1.Args[0]
 44112			f1 := v_1.Args[1]
 44113			v.reset(OpStore)
 44114			v.Aux = t.FieldType(2)
 44115			v0 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(2).PtrTo())
 44116			v0.AuxInt = t.FieldOff(2)
 44117			v0.AddArg(dst)
 44118			v.AddArg(v0)
 44119			v.AddArg(f2)
 44120			v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 44121			v1.Aux = t.FieldType(1)
 44122			v2 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(1).PtrTo())
 44123			v2.AuxInt = t.FieldOff(1)
 44124			v2.AddArg(dst)
 44125			v1.AddArg(v2)
 44126			v1.AddArg(f1)
 44127			v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 44128			v3.Aux = t.FieldType(0)
 44129			v4 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo())
 44130			v4.AuxInt = 0
 44131			v4.AddArg(dst)
 44132			v3.AddArg(v4)
 44133			v3.AddArg(f0)
 44134			v3.AddArg(mem)
 44135			v1.AddArg(v3)
 44136			v.AddArg(v1)
 44137			return true
 44138		}
 44139		// match: (Store dst (StructMake4 <t> f0 f1 f2 f3) mem)
 44140		// cond:
 44141		// result: (Store {t.FieldType(3)} (OffPtr <t.FieldType(3).PtrTo()> [t.FieldOff(3)] dst) f3 (Store {t.FieldType(2)} (OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] dst) f2 (Store {t.FieldType(1)} (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] dst) f1 (Store {t.FieldType(0)} (OffPtr <t.FieldType(0).PtrTo()> [0] dst) f0 mem))))
 44142		for {
 44143			mem := v.Args[2]
 44144			dst := v.Args[0]
 44145			v_1 := v.Args[1]
 44146			if v_1.Op != OpStructMake4 {
 44147				break
 44148			}
 44149			t := v_1.Type
 44150			f3 := v_1.Args[3]
 44151			f0 := v_1.Args[0]
 44152			f1 := v_1.Args[1]
 44153			f2 := v_1.Args[2]
 44154			v.reset(OpStore)
 44155			v.Aux = t.FieldType(3)
 44156			v0 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(3).PtrTo())
 44157			v0.AuxInt = t.FieldOff(3)
 44158			v0.AddArg(dst)
 44159			v.AddArg(v0)
 44160			v.AddArg(f3)
 44161			v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 44162			v1.Aux = t.FieldType(2)
 44163			v2 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(2).PtrTo())
 44164			v2.AuxInt = t.FieldOff(2)
 44165			v2.AddArg(dst)
 44166			v1.AddArg(v2)
 44167			v1.AddArg(f2)
 44168			v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 44169			v3.Aux = t.FieldType(1)
 44170			v4 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(1).PtrTo())
 44171			v4.AuxInt = t.FieldOff(1)
 44172			v4.AddArg(dst)
 44173			v3.AddArg(v4)
 44174			v3.AddArg(f1)
 44175			v5 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 44176			v5.Aux = t.FieldType(0)
 44177			v6 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo())
 44178			v6.AuxInt = 0
 44179			v6.AddArg(dst)
 44180			v5.AddArg(v6)
 44181			v5.AddArg(f0)
 44182			v5.AddArg(mem)
 44183			v3.AddArg(v5)
 44184			v1.AddArg(v3)
 44185			v.AddArg(v1)
 44186			return true
 44187		}
 44188		// match: (Store {t} dst (Load src mem) mem)
 44189		// cond: !fe.CanSSA(t.(*types.Type))
 44190		// result: (Move {t} [sizeof(t)] dst src mem)
 44191		for {
 44192			t := v.Aux
 44193			mem := v.Args[2]
 44194			dst := v.Args[0]
 44195			v_1 := v.Args[1]
 44196			if v_1.Op != OpLoad {
 44197				break
 44198			}
 44199			_ = v_1.Args[1]
 44200			src := v_1.Args[0]
 44201			if mem != v_1.Args[1] {
 44202				break
 44203			}
 44204			if !(!fe.CanSSA(t.(*types.Type))) {
 44205				break
 44206			}
 44207			v.reset(OpMove)
 44208			v.AuxInt = sizeof(t)
 44209			v.Aux = t
 44210			v.AddArg(dst)
 44211			v.AddArg(src)
 44212			v.AddArg(mem)
 44213			return true
 44214		}
 44215		// match: (Store {t} dst (Load src mem) (VarDef {x} mem))
 44216		// cond: !fe.CanSSA(t.(*types.Type))
 44217		// result: (Move {t} [sizeof(t)] dst src (VarDef {x} mem))
 44218		for {
 44219			t := v.Aux
 44220			_ = v.Args[2]
 44221			dst := v.Args[0]
 44222			v_1 := v.Args[1]
 44223			if v_1.Op != OpLoad {
 44224				break
 44225			}
 44226			mem := v_1.Args[1]
 44227			src := v_1.Args[0]
 44228			v_2 := v.Args[2]
 44229			if v_2.Op != OpVarDef {
 44230				break
 44231			}
 44232			x := v_2.Aux
 44233			if mem != v_2.Args[0] {
 44234				break
 44235			}
 44236			if !(!fe.CanSSA(t.(*types.Type))) {
 44237				break
 44238			}
 44239			v.reset(OpMove)
 44240			v.AuxInt = sizeof(t)
 44241			v.Aux = t
 44242			v.AddArg(dst)
 44243			v.AddArg(src)
 44244			v0 := b.NewValue0(v.Pos, OpVarDef, types.TypeMem)
 44245			v0.Aux = x
 44246			v0.AddArg(mem)
 44247			v.AddArg(v0)
 44248			return true
 44249		}
 44250		// match: (Store _ (ArrayMake0) mem)
 44251		// cond:
 44252		// result: mem
 44253		for {
 44254			mem := v.Args[2]
 44255			v_1 := v.Args[1]
 44256			if v_1.Op != OpArrayMake0 {
 44257				break
 44258			}
 44259			v.reset(OpCopy)
 44260			v.Type = mem.Type
 44261			v.AddArg(mem)
 44262			return true
 44263		}
 44264		// match: (Store dst (ArrayMake1 e) mem)
 44265		// cond:
 44266		// result: (Store {e.Type} dst e mem)
 44267		for {
 44268			mem := v.Args[2]
 44269			dst := v.Args[0]
 44270			v_1 := v.Args[1]
 44271			if v_1.Op != OpArrayMake1 {
 44272				break
 44273			}
 44274			e := v_1.Args[0]
 44275			v.reset(OpStore)
 44276			v.Aux = e.Type
 44277			v.AddArg(dst)
 44278			v.AddArg(e)
 44279			v.AddArg(mem)
 44280			return true
 44281		}
 44282		// match: (Store (Load (OffPtr [c] (SP)) mem) x mem)
 44283		// cond: isConstZero(x) && mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize() + config.RegSize
 44284		// result: mem
 44285		for {
 44286			mem := v.Args[2]
 44287			v_0 := v.Args[0]
 44288			if v_0.Op != OpLoad {
 44289				break
 44290			}
 44291			_ = v_0.Args[1]
 44292			v_0_0 := v_0.Args[0]
 44293			if v_0_0.Op != OpOffPtr {
 44294				break
 44295			}
 44296			c := v_0_0.AuxInt
 44297			v_0_0_0 := v_0_0.Args[0]
 44298			if v_0_0_0.Op != OpSP {
 44299				break
 44300			}
 44301			if mem != v_0.Args[1] {
 44302				break
 44303			}
 44304			x := v.Args[1]
 44305			if !(isConstZero(x) && mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize()+config.RegSize) {
 44306				break
 44307			}
 44308			v.reset(OpCopy)
 44309			v.Type = mem.Type
 44310			v.AddArg(mem)
 44311			return true
 44312		}
 44313		// match: (Store (OffPtr (Load (OffPtr [c] (SP)) mem)) x mem)
 44314		// cond: isConstZero(x) && mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize() + config.RegSize
 44315		// result: mem
 44316		for {
 44317			mem := v.Args[2]
 44318			v_0 := v.Args[0]
 44319			if v_0.Op != OpOffPtr {
 44320				break
 44321			}
 44322			v_0_0 := v_0.Args[0]
 44323			if v_0_0.Op != OpLoad {
 44324				break
 44325			}
 44326			_ = v_0_0.Args[1]
 44327			v_0_0_0 := v_0_0.Args[0]
 44328			if v_0_0_0.Op != OpOffPtr {
 44329				break
 44330			}
 44331			c := v_0_0_0.AuxInt
 44332			v_0_0_0_0 := v_0_0_0.Args[0]
 44333			if v_0_0_0_0.Op != OpSP {
 44334				break
 44335			}
 44336			if mem != v_0_0.Args[1] {
 44337				break
 44338			}
 44339			x := v.Args[1]
 44340			if !(isConstZero(x) && mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize()+config.RegSize) {
 44341				break
 44342			}
 44343			v.reset(OpCopy)
 44344			v.Type = mem.Type
 44345			v.AddArg(mem)
 44346			return true
 44347		}
 44348		// match: (Store {t1} op1:(OffPtr [o1] p1) d1 m2:(Store {t2} op2:(OffPtr [0] p2) d2 m3:(Move [n] p3 _ mem)))
 44349		// cond: m2.Uses == 1 && m3.Uses == 1 && o1 == sizeof(t2) && n == sizeof(t2) + sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && clobber(m2) && clobber(m3)
 44350		// result: (Store {t1} op1 d1 (Store {t2} op2 d2 mem))
 44351		for {
 44352			t1 := v.Aux
 44353			_ = v.Args[2]
 44354			op1 := v.Args[0]
 44355			if op1.Op != OpOffPtr {
 44356				break
 44357			}
 44358			o1 := op1.AuxInt
 44359			p1 := op1.Args[0]
 44360			d1 := v.Args[1]
 44361			m2 := v.Args[2]
 44362			if m2.Op != OpStore {
 44363				break
 44364			}
 44365			t2 := m2.Aux
 44366			_ = m2.Args[2]
 44367			op2 := m2.Args[0]
 44368			if op2.Op != OpOffPtr {
 44369				break
 44370			}
 44371			if op2.AuxInt != 0 {
 44372				break
 44373			}
 44374			p2 := op2.Args[0]
 44375			d2 := m2.Args[1]
 44376			m3 := m2.Args[2]
 44377			if m3.Op != OpMove {
 44378				break
 44379			}
 44380			n := m3.AuxInt
 44381			mem := m3.Args[2]
 44382			p3 := m3.Args[0]
 44383			if !(m2.Uses == 1 && m3.Uses == 1 && o1 == sizeof(t2) && n == sizeof(t2)+sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && clobber(m2) && clobber(m3)) {
 44384				break
 44385			}
 44386			v.reset(OpStore)
 44387			v.Aux = t1
 44388			v.AddArg(op1)
 44389			v.AddArg(d1)
 44390			v0 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 44391			v0.Aux = t2
 44392			v0.AddArg(op2)
 44393			v0.AddArg(d2)
 44394			v0.AddArg(mem)
 44395			v.AddArg(v0)
 44396			return true
 44397		}
 44398		return false
 44399	}
 44400	func rewriteValuegeneric_OpStore_20(v *Value) bool {
 44401		b := v.Block
 44402		// match: (Store {t1} op1:(OffPtr [o1] p1) d1 m2:(Store {t2} op2:(OffPtr [o2] p2) d2 m3:(Store {t3} op3:(OffPtr [0] p3) d3 m4:(Move [n] p4 _ mem))))
 44403		// cond: m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && o2 == sizeof(t3) && o1-o2 == sizeof(t2) && n == sizeof(t3) + sizeof(t2) + sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && clobber(m2) && clobber(m3) && clobber(m4)
 44404		// result: (Store {t1} op1 d1 (Store {t2} op2 d2 (Store {t3} op3 d3 mem)))
 44405		for {
 44406			t1 := v.Aux
 44407			_ = v.Args[2]
 44408			op1 := v.Args[0]
 44409			if op1.Op != OpOffPtr {
 44410				break
 44411			}
 44412			o1 := op1.AuxInt
 44413			p1 := op1.Args[0]
 44414			d1 := v.Args[1]
 44415			m2 := v.Args[2]
 44416			if m2.Op != OpStore {
 44417				break
 44418			}
 44419			t2 := m2.Aux
 44420			_ = m2.Args[2]
 44421			op2 := m2.Args[0]
 44422			if op2.Op != OpOffPtr {
 44423				break
 44424			}
 44425			o2 := op2.AuxInt
 44426			p2 := op2.Args[0]
 44427			d2 := m2.Args[1]
 44428			m3 := m2.Args[2]
 44429			if m3.Op != OpStore {
 44430				break
 44431			}
 44432			t3 := m3.Aux
 44433			_ = m3.Args[2]
 44434			op3 := m3.Args[0]
 44435			if op3.Op != OpOffPtr {
 44436				break
 44437			}
 44438			if op3.AuxInt != 0 {
 44439				break
 44440			}
 44441			p3 := op3.Args[0]
 44442			d3 := m3.Args[1]
 44443			m4 := m3.Args[2]
 44444			if m4.Op != OpMove {
 44445				break
 44446			}
 44447			n := m4.AuxInt
 44448			mem := m4.Args[2]
 44449			p4 := m4.Args[0]
 44450			if !(m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && o2 == sizeof(t3) && o1-o2 == sizeof(t2) && n == sizeof(t3)+sizeof(t2)+sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && clobber(m2) && clobber(m3) && clobber(m4)) {
 44451				break
 44452			}
 44453			v.reset(OpStore)
 44454			v.Aux = t1
 44455			v.AddArg(op1)
 44456			v.AddArg(d1)
 44457			v0 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 44458			v0.Aux = t2
 44459			v0.AddArg(op2)
 44460			v0.AddArg(d2)
 44461			v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 44462			v1.Aux = t3
 44463			v1.AddArg(op3)
 44464			v1.AddArg(d3)
 44465			v1.AddArg(mem)
 44466			v0.AddArg(v1)
 44467			v.AddArg(v0)
 44468			return true
 44469		}
 44470		// match: (Store {t1} op1:(OffPtr [o1] p1) d1 m2:(Store {t2} op2:(OffPtr [o2] p2) d2 m3:(Store {t3} op3:(OffPtr [o3] p3) d3 m4:(Store {t4} op4:(OffPtr [0] p4) d4 m5:(Move [n] p5 _ mem)))))
 44471		// cond: m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && m5.Uses == 1 && o3 == sizeof(t4) && o2-o3 == sizeof(t3) && o1-o2 == sizeof(t2) && n == sizeof(t4) + sizeof(t3) + sizeof(t2) + sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && clobber(m2) && clobber(m3) && clobber(m4) && clobber(m5)
 44472		// result: (Store {t1} op1 d1 (Store {t2} op2 d2 (Store {t3} op3 d3 (Store {t4} op4 d4 mem))))
 44473		for {
 44474			t1 := v.Aux
 44475			_ = v.Args[2]
 44476			op1 := v.Args[0]
 44477			if op1.Op != OpOffPtr {
 44478				break
 44479			}
 44480			o1 := op1.AuxInt
 44481			p1 := op1.Args[0]
 44482			d1 := v.Args[1]
 44483			m2 := v.Args[2]
 44484			if m2.Op != OpStore {
 44485				break
 44486			}
 44487			t2 := m2.Aux
 44488			_ = m2.Args[2]
 44489			op2 := m2.Args[0]
 44490			if op2.Op != OpOffPtr {
 44491				break
 44492			}
 44493			o2 := op2.AuxInt
 44494			p2 := op2.Args[0]
 44495			d2 := m2.Args[1]
 44496			m3 := m2.Args[2]
 44497			if m3.Op != OpStore {
 44498				break
 44499			}
 44500			t3 := m3.Aux
 44501			_ = m3.Args[2]
 44502			op3 := m3.Args[0]
 44503			if op3.Op != OpOffPtr {
 44504				break
 44505			}
 44506			o3 := op3.AuxInt
 44507			p3 := op3.Args[0]
 44508			d3 := m3.Args[1]
 44509			m4 := m3.Args[2]
 44510			if m4.Op != OpStore {
 44511				break
 44512			}
 44513			t4 := m4.Aux
 44514			_ = m4.Args[2]
 44515			op4 := m4.Args[0]
 44516			if op4.Op != OpOffPtr {
 44517				break
 44518			}
 44519			if op4.AuxInt != 0 {
 44520				break
 44521			}
 44522			p4 := op4.Args[0]
 44523			d4 := m4.Args[1]
 44524			m5 := m4.Args[2]
 44525			if m5.Op != OpMove {
 44526				break
 44527			}
 44528			n := m5.AuxInt
 44529			mem := m5.Args[2]
 44530			p5 := m5.Args[0]
 44531			if !(m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && m5.Uses == 1 && o3 == sizeof(t4) && o2-o3 == sizeof(t3) && o1-o2 == sizeof(t2) && n == sizeof(t4)+sizeof(t3)+sizeof(t2)+sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && clobber(m2) && clobber(m3) && clobber(m4) && clobber(m5)) {
 44532				break
 44533			}
 44534			v.reset(OpStore)
 44535			v.Aux = t1
 44536			v.AddArg(op1)
 44537			v.AddArg(d1)
 44538			v0 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 44539			v0.Aux = t2
 44540			v0.AddArg(op2)
 44541			v0.AddArg(d2)
 44542			v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 44543			v1.Aux = t3
 44544			v1.AddArg(op3)
 44545			v1.AddArg(d3)
 44546			v2 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 44547			v2.Aux = t4
 44548			v2.AddArg(op4)
 44549			v2.AddArg(d4)
 44550			v2.AddArg(mem)
 44551			v1.AddArg(v2)
 44552			v0.AddArg(v1)
 44553			v.AddArg(v0)
 44554			return true
 44555		}
 44556		// match: (Store {t1} op1:(OffPtr [o1] p1) d1 m2:(Store {t2} op2:(OffPtr [0] p2) d2 m3:(Zero [n] p3 mem)))
 44557		// cond: m2.Uses == 1 && m3.Uses == 1 && o1 == sizeof(t2) && n == sizeof(t2) + sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && clobber(m2) && clobber(m3)
 44558		// result: (Store {t1} op1 d1 (Store {t2} op2 d2 mem))
 44559		for {
 44560			t1 := v.Aux
 44561			_ = v.Args[2]
 44562			op1 := v.Args[0]
 44563			if op1.Op != OpOffPtr {
 44564				break
 44565			}
 44566			o1 := op1.AuxInt
 44567			p1 := op1.Args[0]
 44568			d1 := v.Args[1]
 44569			m2 := v.Args[2]
 44570			if m2.Op != OpStore {
 44571				break
 44572			}
 44573			t2 := m2.Aux
 44574			_ = m2.Args[2]
 44575			op2 := m2.Args[0]
 44576			if op2.Op != OpOffPtr {
 44577				break
 44578			}
 44579			if op2.AuxInt != 0 {
 44580				break
 44581			}
 44582			p2 := op2.Args[0]
 44583			d2 := m2.Args[1]
 44584			m3 := m2.Args[2]
 44585			if m3.Op != OpZero {
 44586				break
 44587			}
 44588			n := m3.AuxInt
 44589			mem := m3.Args[1]
 44590			p3 := m3.Args[0]
 44591			if !(m2.Uses == 1 && m3.Uses == 1 && o1 == sizeof(t2) && n == sizeof(t2)+sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && clobber(m2) && clobber(m3)) {
 44592				break
 44593			}
 44594			v.reset(OpStore)
 44595			v.Aux = t1
 44596			v.AddArg(op1)
 44597			v.AddArg(d1)
 44598			v0 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 44599			v0.Aux = t2
 44600			v0.AddArg(op2)
 44601			v0.AddArg(d2)
 44602			v0.AddArg(mem)
 44603			v.AddArg(v0)
 44604			return true
 44605		}
 44606		// match: (Store {t1} op1:(OffPtr [o1] p1) d1 m2:(Store {t2} op2:(OffPtr [o2] p2) d2 m3:(Store {t3} op3:(OffPtr [0] p3) d3 m4:(Zero [n] p4 mem))))
 44607		// cond: m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && o2 == sizeof(t3) && o1-o2 == sizeof(t2) && n == sizeof(t3) + sizeof(t2) + sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && clobber(m2) && clobber(m3) && clobber(m4)
 44608		// result: (Store {t1} op1 d1 (Store {t2} op2 d2 (Store {t3} op3 d3 mem)))
 44609		for {
 44610			t1 := v.Aux
 44611			_ = v.Args[2]
 44612			op1 := v.Args[0]
 44613			if op1.Op != OpOffPtr {
 44614				break
 44615			}
 44616			o1 := op1.AuxInt
 44617			p1 := op1.Args[0]
 44618			d1 := v.Args[1]
 44619			m2 := v.Args[2]
 44620			if m2.Op != OpStore {
 44621				break
 44622			}
 44623			t2 := m2.Aux
 44624			_ = m2.Args[2]
 44625			op2 := m2.Args[0]
 44626			if op2.Op != OpOffPtr {
 44627				break
 44628			}
 44629			o2 := op2.AuxInt
 44630			p2 := op2.Args[0]
 44631			d2 := m2.Args[1]
 44632			m3 := m2.Args[2]
 44633			if m3.Op != OpStore {
 44634				break
 44635			}
 44636			t3 := m3.Aux
 44637			_ = m3.Args[2]
 44638			op3 := m3.Args[0]
 44639			if op3.Op != OpOffPtr {
 44640				break
 44641			}
 44642			if op3.AuxInt != 0 {
 44643				break
 44644			}
 44645			p3 := op3.Args[0]
 44646			d3 := m3.Args[1]
 44647			m4 := m3.Args[2]
 44648			if m4.Op != OpZero {
 44649				break
 44650			}
 44651			n := m4.AuxInt
 44652			mem := m4.Args[1]
 44653			p4 := m4.Args[0]
 44654			if !(m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && o2 == sizeof(t3) && o1-o2 == sizeof(t2) && n == sizeof(t3)+sizeof(t2)+sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && clobber(m2) && clobber(m3) && clobber(m4)) {
 44655				break
 44656			}
 44657			v.reset(OpStore)
 44658			v.Aux = t1
 44659			v.AddArg(op1)
 44660			v.AddArg(d1)
 44661			v0 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 44662			v0.Aux = t2
 44663			v0.AddArg(op2)
 44664			v0.AddArg(d2)
 44665			v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 44666			v1.Aux = t3
 44667			v1.AddArg(op3)
 44668			v1.AddArg(d3)
 44669			v1.AddArg(mem)
 44670			v0.AddArg(v1)
 44671			v.AddArg(v0)
 44672			return true
 44673		}
 44674		// match: (Store {t1} op1:(OffPtr [o1] p1) d1 m2:(Store {t2} op2:(OffPtr [o2] p2) d2 m3:(Store {t3} op3:(OffPtr [o3] p3) d3 m4:(Store {t4} op4:(OffPtr [0] p4) d4 m5:(Zero [n] p5 mem)))))
 44675		// cond: m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && m5.Uses == 1 && o3 == sizeof(t4) && o2-o3 == sizeof(t3) && o1-o2 == sizeof(t2) && n == sizeof(t4) + sizeof(t3) + sizeof(t2) + sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && clobber(m2) && clobber(m3) && clobber(m4) && clobber(m5)
 44676		// result: (Store {t1} op1 d1 (Store {t2} op2 d2 (Store {t3} op3 d3 (Store {t4} op4 d4 mem))))
 44677		for {
 44678			t1 := v.Aux
 44679			_ = v.Args[2]
 44680			op1 := v.Args[0]
 44681			if op1.Op != OpOffPtr {
 44682				break
 44683			}
 44684			o1 := op1.AuxInt
 44685			p1 := op1.Args[0]
 44686			d1 := v.Args[1]
 44687			m2 := v.Args[2]
 44688			if m2.Op != OpStore {
 44689				break
 44690			}
 44691			t2 := m2.Aux
 44692			_ = m2.Args[2]
 44693			op2 := m2.Args[0]
 44694			if op2.Op != OpOffPtr {
 44695				break
 44696			}
 44697			o2 := op2.AuxInt
 44698			p2 := op2.Args[0]
 44699			d2 := m2.Args[1]
 44700			m3 := m2.Args[2]
 44701			if m3.Op != OpStore {
 44702				break
 44703			}
 44704			t3 := m3.Aux
 44705			_ = m3.Args[2]
 44706			op3 := m3.Args[0]
 44707			if op3.Op != OpOffPtr {
 44708				break
 44709			}
 44710			o3 := op3.AuxInt
 44711			p3 := op3.Args[0]
 44712			d3 := m3.Args[1]
 44713			m4 := m3.Args[2]
 44714			if m4.Op != OpStore {
 44715				break
 44716			}
 44717			t4 := m4.Aux
 44718			_ = m4.Args[2]
 44719			op4 := m4.Args[0]
 44720			if op4.Op != OpOffPtr {
 44721				break
 44722			}
 44723			if op4.AuxInt != 0 {
 44724				break
 44725			}
 44726			p4 := op4.Args[0]
 44727			d4 := m4.Args[1]
 44728			m5 := m4.Args[2]
 44729			if m5.Op != OpZero {
 44730				break
 44731			}
 44732			n := m5.AuxInt
 44733			mem := m5.Args[1]
 44734			p5 := m5.Args[0]
 44735			if !(m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && m5.Uses == 1 && o3 == sizeof(t4) && o2-o3 == sizeof(t3) && o1-o2 == sizeof(t2) && n == sizeof(t4)+sizeof(t3)+sizeof(t2)+sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && clobber(m2) && clobber(m3) && clobber(m4) && clobber(m5)) {
 44736				break
 44737			}
 44738			v.reset(OpStore)
 44739			v.Aux = t1
 44740			v.AddArg(op1)
 44741			v.AddArg(d1)
 44742			v0 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 44743			v0.Aux = t2
 44744			v0.AddArg(op2)
 44745			v0.AddArg(d2)
 44746			v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 44747			v1.Aux = t3
 44748			v1.AddArg(op3)
 44749			v1.AddArg(d3)
 44750			v2 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 44751			v2.Aux = t4
 44752			v2.AddArg(op4)
 44753			v2.AddArg(d4)
 44754			v2.AddArg(mem)
 44755			v1.AddArg(v2)
 44756			v0.AddArg(v1)
 44757			v.AddArg(v0)
 44758			return true
 44759		}
 44760		return false
 44761	}
 44762	func rewriteValuegeneric_OpStringLen_0(v *Value) bool {
 44763		// match: (StringLen (StringMake _ (Const64 <t> [c])))
 44764		// cond:
 44765		// result: (Const64 <t> [c])
 44766		for {
 44767			v_0 := v.Args[0]
 44768			if v_0.Op != OpStringMake {
 44769				break
 44770			}
 44771			_ = v_0.Args[1]
 44772			v_0_1 := v_0.Args[1]
 44773			if v_0_1.Op != OpConst64 {
 44774				break
 44775			}
 44776			t := v_0_1.Type
 44777			c := v_0_1.AuxInt
 44778			v.reset(OpConst64)
 44779			v.Type = t
 44780			v.AuxInt = c
 44781			return true
 44782		}
 44783		return false
 44784	}
 44785	func rewriteValuegeneric_OpStringPtr_0(v *Value) bool {
 44786		// match: (StringPtr (StringMake (Addr <t> {s} base) _))
 44787		// cond:
 44788		// result: (Addr <t> {s} base)
 44789		for {
 44790			v_0 := v.Args[0]
 44791			if v_0.Op != OpStringMake {
 44792				break
 44793			}
 44794			_ = v_0.Args[1]
 44795			v_0_0 := v_0.Args[0]
 44796			if v_0_0.Op != OpAddr {
 44797				break
 44798			}
 44799			t := v_0_0.Type
 44800			s := v_0_0.Aux
 44801			base := v_0_0.Args[0]
 44802			v.reset(OpAddr)
 44803			v.Type = t
 44804			v.Aux = s
 44805			v.AddArg(base)
 44806			return true
 44807		}
 44808		return false
 44809	}
 44810	func rewriteValuegeneric_OpStructSelect_0(v *Value) bool {
 44811		// match: (StructSelect (StructMake1 x))
 44812		// cond:
 44813		// result: x
 44814		for {
 44815			v_0 := v.Args[0]
 44816			if v_0.Op != OpStructMake1 {
 44817				break
 44818			}
 44819			x := v_0.Args[0]
 44820			v.reset(OpCopy)
 44821			v.Type = x.Type
 44822			v.AddArg(x)
 44823			return true
 44824		}
 44825		// match: (StructSelect [0] (StructMake2 x _))
 44826		// cond:
 44827		// result: x
 44828		for {
 44829			if v.AuxInt != 0 {
 44830				break
 44831			}
 44832			v_0 := v.Args[0]
 44833			if v_0.Op != OpStructMake2 {
 44834				break
 44835			}
 44836			_ = v_0.Args[1]
 44837			x := v_0.Args[0]
 44838			v.reset(OpCopy)
 44839			v.Type = x.Type
 44840			v.AddArg(x)
 44841			return true
 44842		}
 44843		// match: (StructSelect [1] (StructMake2 _ x))
 44844		// cond:
 44845		// result: x
 44846		for {
 44847			if v.AuxInt != 1 {
 44848				break
 44849			}
 44850			v_0 := v.Args[0]
 44851			if v_0.Op != OpStructMake2 {
 44852				break
 44853			}
 44854			x := v_0.Args[1]
 44855			v.reset(OpCopy)
 44856			v.Type = x.Type
 44857			v.AddArg(x)
 44858			return true
 44859		}
 44860		// match: (StructSelect [0] (StructMake3 x _ _))
 44861		// cond:
 44862		// result: x
 44863		for {
 44864			if v.AuxInt != 0 {
 44865				break
 44866			}
 44867			v_0 := v.Args[0]
 44868			if v_0.Op != OpStructMake3 {
 44869				break
 44870			}
 44871			_ = v_0.Args[2]
 44872			x := v_0.Args[0]
 44873			v.reset(OpCopy)
 44874			v.Type = x.Type
 44875			v.AddArg(x)
 44876			return true
 44877		}
 44878		// match: (StructSelect [1] (StructMake3 _ x _))
 44879		// cond:
 44880		// result: x
 44881		for {
 44882			if v.AuxInt != 1 {
 44883				break
 44884			}
 44885			v_0 := v.Args[0]
 44886			if v_0.Op != OpStructMake3 {
 44887				break
 44888			}
 44889			_ = v_0.Args[2]
 44890			x := v_0.Args[1]
 44891			v.reset(OpCopy)
 44892			v.Type = x.Type
 44893			v.AddArg(x)
 44894			return true
 44895		}
 44896		// match: (StructSelect [2] (StructMake3 _ _ x))
 44897		// cond:
 44898		// result: x
 44899		for {
 44900			if v.AuxInt != 2 {
 44901				break
 44902			}
 44903			v_0 := v.Args[0]
 44904			if v_0.Op != OpStructMake3 {
 44905				break
 44906			}
 44907			x := v_0.Args[2]
 44908			v.reset(OpCopy)
 44909			v.Type = x.Type
 44910			v.AddArg(x)
 44911			return true
 44912		}
 44913		// match: (StructSelect [0] (StructMake4 x _ _ _))
 44914		// cond:
 44915		// result: x
 44916		for {
 44917			if v.AuxInt != 0 {
 44918				break
 44919			}
 44920			v_0 := v.Args[0]
 44921			if v_0.Op != OpStructMake4 {
 44922				break
 44923			}
 44924			_ = v_0.Args[3]
 44925			x := v_0.Args[0]
 44926			v.reset(OpCopy)
 44927			v.Type = x.Type
 44928			v.AddArg(x)
 44929			return true
 44930		}
 44931		// match: (StructSelect [1] (StructMake4 _ x _ _))
 44932		// cond:
 44933		// result: x
 44934		for {
 44935			if v.AuxInt != 1 {
 44936				break
 44937			}
 44938			v_0 := v.Args[0]
 44939			if v_0.Op != OpStructMake4 {
 44940				break
 44941			}
 44942			_ = v_0.Args[3]
 44943			x := v_0.Args[1]
 44944			v.reset(OpCopy)
 44945			v.Type = x.Type
 44946			v.AddArg(x)
 44947			return true
 44948		}
 44949		// match: (StructSelect [2] (StructMake4 _ _ x _))
 44950		// cond:
 44951		// result: x
 44952		for {
 44953			if v.AuxInt != 2 {
 44954				break
 44955			}
 44956			v_0 := v.Args[0]
 44957			if v_0.Op != OpStructMake4 {
 44958				break
 44959			}
 44960			_ = v_0.Args[3]
 44961			x := v_0.Args[2]
 44962			v.reset(OpCopy)
 44963			v.Type = x.Type
 44964			v.AddArg(x)
 44965			return true
 44966		}
 44967		// match: (StructSelect [3] (StructMake4 _ _ _ x))
 44968		// cond:
 44969		// result: x
 44970		for {
 44971			if v.AuxInt != 3 {
 44972				break
 44973			}
 44974			v_0 := v.Args[0]
 44975			if v_0.Op != OpStructMake4 {
 44976				break
 44977			}
 44978			x := v_0.Args[3]
 44979			v.reset(OpCopy)
 44980			v.Type = x.Type
 44981			v.AddArg(x)
 44982			return true
 44983		}
 44984		return false
 44985	}
 44986	func rewriteValuegeneric_OpStructSelect_10(v *Value) bool {
 44987		b := v.Block
 44988		fe := b.Func.fe
 44989		// match: (StructSelect [i] x:(Load <t> ptr mem))
 44990		// cond: !fe.CanSSA(t)
 44991		// result: @x.Block (Load <v.Type> (OffPtr <v.Type.PtrTo()> [t.FieldOff(int(i))] ptr) mem)
 44992		for {
 44993			i := v.AuxInt
 44994			x := v.Args[0]
 44995			if x.Op != OpLoad {
 44996				break
 44997			}
 44998			t := x.Type
 44999			mem := x.Args[1]
 45000			ptr := x.Args[0]
 45001			if !(!fe.CanSSA(t)) {
 45002				break
 45003			}
 45004			b = x.Block
 45005			v0 := b.NewValue0(v.Pos, OpLoad, v.Type)
 45006			v.reset(OpCopy)
 45007			v.AddArg(v0)
 45008			v1 := b.NewValue0(v.Pos, OpOffPtr, v.Type.PtrTo())
 45009			v1.AuxInt = t.FieldOff(int(i))
 45010			v1.AddArg(ptr)
 45011			v0.AddArg(v1)
 45012			v0.AddArg(mem)
 45013			return true
 45014		}
 45015		// match: (StructSelect [0] x:(IData _))
 45016		// cond:
 45017		// result: x
 45018		for {
 45019			if v.AuxInt != 0 {
 45020				break
 45021			}
 45022			x := v.Args[0]
 45023			if x.Op != OpIData {
 45024				break
 45025			}
 45026			v.reset(OpCopy)
 45027			v.Type = x.Type
 45028			v.AddArg(x)
 45029			return true
 45030		}
 45031		return false
 45032	}
 45033	func rewriteValuegeneric_OpSub16_0(v *Value) bool {
 45034		b := v.Block
 45035		// match: (Sub16 (Const16 [c]) (Const16 [d]))
 45036		// cond:
 45037		// result: (Const16 [int64(int16(c-d))])
 45038		for {
 45039			_ = v.Args[1]
 45040			v_0 := v.Args[0]
 45041			if v_0.Op != OpConst16 {
 45042				break
 45043			}
 45044			c := v_0.AuxInt
 45045			v_1 := v.Args[1]
 45046			if v_1.Op != OpConst16 {
 45047				break
 45048			}
 45049			d := v_1.AuxInt
 45050			v.reset(OpConst16)
 45051			v.AuxInt = int64(int16(c - d))
 45052			return true
 45053		}
 45054		// match: (Sub16 x (Const16 <t> [c]))
 45055		// cond: x.Op != OpConst16
 45056		// result: (Add16 (Const16 <t> [int64(int16(-c))]) x)
 45057		for {
 45058			_ = v.Args[1]
 45059			x := v.Args[0]
 45060			v_1 := v.Args[1]
 45061			if v_1.Op != OpConst16 {
 45062				break
 45063			}
 45064			t := v_1.Type
 45065			c := v_1.AuxInt
 45066			if !(x.Op != OpConst16) {
 45067				break
 45068			}
 45069			v.reset(OpAdd16)
 45070			v0 := b.NewValue0(v.Pos, OpConst16, t)
 45071			v0.AuxInt = int64(int16(-c))
 45072			v.AddArg(v0)
 45073			v.AddArg(x)
 45074			return true
 45075		}
 45076		// match: (Sub16 <t> (Mul16 x y) (Mul16 x z))
 45077		// cond:
 45078		// result: (Mul16 x (Sub16 <t> y z))
 45079		for {
 45080			t := v.Type
 45081			_ = v.Args[1]
 45082			v_0 := v.Args[0]
 45083			if v_0.Op != OpMul16 {
 45084				break
 45085			}
 45086			y := v_0.Args[1]
 45087			x := v_0.Args[0]
 45088			v_1 := v.Args[1]
 45089			if v_1.Op != OpMul16 {
 45090				break
 45091			}
 45092			z := v_1.Args[1]
 45093			if x != v_1.Args[0] {
 45094				break
 45095			}
 45096			v.reset(OpMul16)
 45097			v.AddArg(x)
 45098			v0 := b.NewValue0(v.Pos, OpSub16, t)
 45099			v0.AddArg(y)
 45100			v0.AddArg(z)
 45101			v.AddArg(v0)
 45102			return true
 45103		}
 45104		// match: (Sub16 <t> (Mul16 y x) (Mul16 x z))
 45105		// cond:
 45106		// result: (Mul16 x (Sub16 <t> y z))
 45107		for {
 45108			t := v.Type
 45109			_ = v.Args[1]
 45110			v_0 := v.Args[0]
 45111			if v_0.Op != OpMul16 {
 45112				break
 45113			}
 45114			x := v_0.Args[1]
 45115			y := v_0.Args[0]
 45116			v_1 := v.Args[1]
 45117			if v_1.Op != OpMul16 {
 45118				break
 45119			}
 45120			z := v_1.Args[1]
 45121			if x != v_1.Args[0] {
 45122				break
 45123			}
 45124			v.reset(OpMul16)
 45125			v.AddArg(x)
 45126			v0 := b.NewValue0(v.Pos, OpSub16, t)
 45127			v0.AddArg(y)
 45128			v0.AddArg(z)
 45129			v.AddArg(v0)
 45130			return true
 45131		}
 45132		// match: (Sub16 <t> (Mul16 x y) (Mul16 z x))
 45133		// cond:
 45134		// result: (Mul16 x (Sub16 <t> y z))
 45135		for {
 45136			t := v.Type
 45137			_ = v.Args[1]
 45138			v_0 := v.Args[0]
 45139			if v_0.Op != OpMul16 {
 45140				break
 45141			}
 45142			y := v_0.Args[1]
 45143			x := v_0.Args[0]
 45144			v_1 := v.Args[1]
 45145			if v_1.Op != OpMul16 {
 45146				break
 45147			}
 45148			_ = v_1.Args[1]
 45149			z := v_1.Args[0]
 45150			if x != v_1.Args[1] {
 45151				break
 45152			}
 45153			v.reset(OpMul16)
 45154			v.AddArg(x)
 45155			v0 := b.NewValue0(v.Pos, OpSub16, t)
 45156			v0.AddArg(y)
 45157			v0.AddArg(z)
 45158			v.AddArg(v0)
 45159			return true
 45160		}
 45161		// match: (Sub16 <t> (Mul16 y x) (Mul16 z x))
 45162		// cond:
 45163		// result: (Mul16 x (Sub16 <t> y z))
 45164		for {
 45165			t := v.Type
 45166			_ = v.Args[1]
 45167			v_0 := v.Args[0]
 45168			if v_0.Op != OpMul16 {
 45169				break
 45170			}
 45171			x := v_0.Args[1]
 45172			y := v_0.Args[0]
 45173			v_1 := v.Args[1]
 45174			if v_1.Op != OpMul16 {
 45175				break
 45176			}
 45177			_ = v_1.Args[1]
 45178			z := v_1.Args[0]
 45179			if x != v_1.Args[1] {
 45180				break
 45181			}
 45182			v.reset(OpMul16)
 45183			v.AddArg(x)
 45184			v0 := b.NewValue0(v.Pos, OpSub16, t)
 45185			v0.AddArg(y)
 45186			v0.AddArg(z)
 45187			v.AddArg(v0)
 45188			return true
 45189		}
 45190		// match: (Sub16 x x)
 45191		// cond:
 45192		// result: (Const16 [0])
 45193		for {
 45194			x := v.Args[1]
 45195			if x != v.Args[0] {
 45196				break
 45197			}
 45198			v.reset(OpConst16)
 45199			v.AuxInt = 0
 45200			return true
 45201		}
 45202		// match: (Sub16 (Add16 x y) x)
 45203		// cond:
 45204		// result: y
 45205		for {
 45206			x := v.Args[1]
 45207			v_0 := v.Args[0]
 45208			if v_0.Op != OpAdd16 {
 45209				break
 45210			}
 45211			y := v_0.Args[1]
 45212			if x != v_0.Args[0] {
 45213				break
 45214			}
 45215			v.reset(OpCopy)
 45216			v.Type = y.Type
 45217			v.AddArg(y)
 45218			return true
 45219		}
 45220		// match: (Sub16 (Add16 y x) x)
 45221		// cond:
 45222		// result: y
 45223		for {
 45224			x := v.Args[1]
 45225			v_0 := v.Args[0]
 45226			if v_0.Op != OpAdd16 {
 45227				break
 45228			}
 45229			_ = v_0.Args[1]
 45230			y := v_0.Args[0]
 45231			if x != v_0.Args[1] {
 45232				break
 45233			}
 45234			v.reset(OpCopy)
 45235			v.Type = y.Type
 45236			v.AddArg(y)
 45237			return true
 45238		}
 45239		// match: (Sub16 (Add16 x y) y)
 45240		// cond:
 45241		// result: x
 45242		for {
 45243			y := v.Args[1]
 45244			v_0 := v.Args[0]
 45245			if v_0.Op != OpAdd16 {
 45246				break
 45247			}
 45248			_ = v_0.Args[1]
 45249			x := v_0.Args[0]
 45250			if y != v_0.Args[1] {
 45251				break
 45252			}
 45253			v.reset(OpCopy)
 45254			v.Type = x.Type
 45255			v.AddArg(x)
 45256			return true
 45257		}
 45258		return false
 45259	}
 45260	func rewriteValuegeneric_OpSub16_10(v *Value) bool {
 45261		b := v.Block
 45262		// match: (Sub16 (Add16 y x) y)
 45263		// cond:
 45264		// result: x
 45265		for {
 45266			y := v.Args[1]
 45267			v_0 := v.Args[0]
 45268			if v_0.Op != OpAdd16 {
 45269				break
 45270			}
 45271			x := v_0.Args[1]
 45272			if y != v_0.Args[0] {
 45273				break
 45274			}
 45275			v.reset(OpCopy)
 45276			v.Type = x.Type
 45277			v.AddArg(x)
 45278			return true
 45279		}
 45280		// match: (Sub16 x (Sub16 i:(Const16 <t>) z))
 45281		// cond: (z.Op != OpConst16 && x.Op != OpConst16)
 45282		// result: (Sub16 (Add16 <t> x z) i)
 45283		for {
 45284			_ = v.Args[1]
 45285			x := v.Args[0]
 45286			v_1 := v.Args[1]
 45287			if v_1.Op != OpSub16 {
 45288				break
 45289			}
 45290			z := v_1.Args[1]
 45291			i := v_1.Args[0]
 45292			if i.Op != OpConst16 {
 45293				break
 45294			}
 45295			t := i.Type
 45296			if !(z.Op != OpConst16 && x.Op != OpConst16) {
 45297				break
 45298			}
 45299			v.reset(OpSub16)
 45300			v0 := b.NewValue0(v.Pos, OpAdd16, t)
 45301			v0.AddArg(x)
 45302			v0.AddArg(z)
 45303			v.AddArg(v0)
 45304			v.AddArg(i)
 45305			return true
 45306		}
 45307		// match: (Sub16 x (Sub16 z i:(Const16 <t>)))
 45308		// cond: (z.Op != OpConst16 && x.Op != OpConst16)
 45309		// result: (Add16 i (Sub16 <t> x z))
 45310		for {
 45311			_ = v.Args[1]
 45312			x := v.Args[0]
 45313			v_1 := v.Args[1]
 45314			if v_1.Op != OpSub16 {
 45315				break
 45316			}
 45317			_ = v_1.Args[1]
 45318			z := v_1.Args[0]
 45319			i := v_1.Args[1]
 45320			if i.Op != OpConst16 {
 45321				break
 45322			}
 45323			t := i.Type
 45324			if !(z.Op != OpConst16 && x.Op != OpConst16) {
 45325				break
 45326			}
 45327			v.reset(OpAdd16)
 45328			v.AddArg(i)
 45329			v0 := b.NewValue0(v.Pos, OpSub16, t)
 45330			v0.AddArg(x)
 45331			v0.AddArg(z)
 45332			v.AddArg(v0)
 45333			return true
 45334		}
 45335		// match: (Sub16 (Const16 <t> [c]) (Sub16 x (Const16 <t> [d])))
 45336		// cond:
 45337		// result: (Sub16 (Const16 <t> [int64(int16(c+d))]) x)
 45338		for {
 45339			_ = v.Args[1]
 45340			v_0 := v.Args[0]
 45341			if v_0.Op != OpConst16 {
 45342				break
 45343			}
 45344			t := v_0.Type
 45345			c := v_0.AuxInt
 45346			v_1 := v.Args[1]
 45347			if v_1.Op != OpSub16 {
 45348				break
 45349			}
 45350			_ = v_1.Args[1]
 45351			x := v_1.Args[0]
 45352			v_1_1 := v_1.Args[1]
 45353			if v_1_1.Op != OpConst16 {
 45354				break
 45355			}
 45356			if v_1_1.Type != t {
 45357				break
 45358			}
 45359			d := v_1_1.AuxInt
 45360			v.reset(OpSub16)
 45361			v0 := b.NewValue0(v.Pos, OpConst16, t)
 45362			v0.AuxInt = int64(int16(c + d))
 45363			v.AddArg(v0)
 45364			v.AddArg(x)
 45365			return true
 45366		}
 45367		// match: (Sub16 (Const16 <t> [c]) (Sub16 (Const16 <t> [d]) x))
 45368		// cond:
 45369		// result: (Add16 (Const16 <t> [int64(int16(c-d))]) x)
 45370		for {
 45371			_ = v.Args[1]
 45372			v_0 := v.Args[0]
 45373			if v_0.Op != OpConst16 {
 45374				break
 45375			}
 45376			t := v_0.Type
 45377			c := v_0.AuxInt
 45378			v_1 := v.Args[1]
 45379			if v_1.Op != OpSub16 {
 45380				break
 45381			}
 45382			x := v_1.Args[1]
 45383			v_1_0 := v_1.Args[0]
 45384			if v_1_0.Op != OpConst16 {
 45385				break
 45386			}
 45387			if v_1_0.Type != t {
 45388				break
 45389			}
 45390			d := v_1_0.AuxInt
 45391			v.reset(OpAdd16)
 45392			v0 := b.NewValue0(v.Pos, OpConst16, t)
 45393			v0.AuxInt = int64(int16(c - d))
 45394			v.AddArg(v0)
 45395			v.AddArg(x)
 45396			return true
 45397		}
 45398		return false
 45399	}
 45400	func rewriteValuegeneric_OpSub32_0(v *Value) bool {
 45401		b := v.Block
 45402		// match: (Sub32 (Const32 [c]) (Const32 [d]))
 45403		// cond:
 45404		// result: (Const32 [int64(int32(c-d))])
 45405		for {
 45406			_ = v.Args[1]
 45407			v_0 := v.Args[0]
 45408			if v_0.Op != OpConst32 {
 45409				break
 45410			}
 45411			c := v_0.AuxInt
 45412			v_1 := v.Args[1]
 45413			if v_1.Op != OpConst32 {
 45414				break
 45415			}
 45416			d := v_1.AuxInt
 45417			v.reset(OpConst32)
 45418			v.AuxInt = int64(int32(c - d))
 45419			return true
 45420		}
 45421		// match: (Sub32 x (Const32 <t> [c]))
 45422		// cond: x.Op != OpConst32
 45423		// result: (Add32 (Const32 <t> [int64(int32(-c))]) x)
 45424		for {
 45425			_ = v.Args[1]
 45426			x := v.Args[0]
 45427			v_1 := v.Args[1]
 45428			if v_1.Op != OpConst32 {
 45429				break
 45430			}
 45431			t := v_1.Type
 45432			c := v_1.AuxInt
 45433			if !(x.Op != OpConst32) {
 45434				break
 45435			}
 45436			v.reset(OpAdd32)
 45437			v0 := b.NewValue0(v.Pos, OpConst32, t)
 45438			v0.AuxInt = int64(int32(-c))
 45439			v.AddArg(v0)
 45440			v.AddArg(x)
 45441			return true
 45442		}
 45443		// match: (Sub32 <t> (Mul32 x y) (Mul32 x z))
 45444		// cond:
 45445		// result: (Mul32 x (Sub32 <t> y z))
 45446		for {
 45447			t := v.Type
 45448			_ = v.Args[1]
 45449			v_0 := v.Args[0]
 45450			if v_0.Op != OpMul32 {
 45451				break
 45452			}
 45453			y := v_0.Args[1]
 45454			x := v_0.Args[0]
 45455			v_1 := v.Args[1]
 45456			if v_1.Op != OpMul32 {
 45457				break
 45458			}
 45459			z := v_1.Args[1]
 45460			if x != v_1.Args[0] {
 45461				break
 45462			}
 45463			v.reset(OpMul32)
 45464			v.AddArg(x)
 45465			v0 := b.NewValue0(v.Pos, OpSub32, t)
 45466			v0.AddArg(y)
 45467			v0.AddArg(z)
 45468			v.AddArg(v0)
 45469			return true
 45470		}
 45471		// match: (Sub32 <t> (Mul32 y x) (Mul32 x z))
 45472		// cond:
 45473		// result: (Mul32 x (Sub32 <t> y z))
 45474		for {
 45475			t := v.Type
 45476			_ = v.Args[1]
 45477			v_0 := v.Args[0]
 45478			if v_0.Op != OpMul32 {
 45479				break
 45480			}
 45481			x := v_0.Args[1]
 45482			y := v_0.Args[0]
 45483			v_1 := v.Args[1]
 45484			if v_1.Op != OpMul32 {
 45485				break
 45486			}
 45487			z := v_1.Args[1]
 45488			if x != v_1.Args[0] {
 45489				break
 45490			}
 45491			v.reset(OpMul32)
 45492			v.AddArg(x)
 45493			v0 := b.NewValue0(v.Pos, OpSub32, t)
 45494			v0.AddArg(y)
 45495			v0.AddArg(z)
 45496			v.AddArg(v0)
 45497			return true
 45498		}
 45499		// match: (Sub32 <t> (Mul32 x y) (Mul32 z x))
 45500		// cond:
 45501		// result: (Mul32 x (Sub32 <t> y z))
 45502		for {
 45503			t := v.Type
 45504			_ = v.Args[1]
 45505			v_0 := v.Args[0]
 45506			if v_0.Op != OpMul32 {
 45507				break
 45508			}
 45509			y := v_0.Args[1]
 45510			x := v_0.Args[0]
 45511			v_1 := v.Args[1]
 45512			if v_1.Op != OpMul32 {
 45513				break
 45514			}
 45515			_ = v_1.Args[1]
 45516			z := v_1.Args[0]
 45517			if x != v_1.Args[1] {
 45518				break
 45519			}
 45520			v.reset(OpMul32)
 45521			v.AddArg(x)
 45522			v0 := b.NewValue0(v.Pos, OpSub32, t)
 45523			v0.AddArg(y)
 45524			v0.AddArg(z)
 45525			v.AddArg(v0)
 45526			return true
 45527		}
 45528		// match: (Sub32 <t> (Mul32 y x) (Mul32 z x))
 45529		// cond:
 45530		// result: (Mul32 x (Sub32 <t> y z))
 45531		for {
 45532			t := v.Type
 45533			_ = v.Args[1]
 45534			v_0 := v.Args[0]
 45535			if v_0.Op != OpMul32 {
 45536				break
 45537			}
 45538			x := v_0.Args[1]
 45539			y := v_0.Args[0]
 45540			v_1 := v.Args[1]
 45541			if v_1.Op != OpMul32 {
 45542				break
 45543			}
 45544			_ = v_1.Args[1]
 45545			z := v_1.Args[0]
 45546			if x != v_1.Args[1] {
 45547				break
 45548			}
 45549			v.reset(OpMul32)
 45550			v.AddArg(x)
 45551			v0 := b.NewValue0(v.Pos, OpSub32, t)
 45552			v0.AddArg(y)
 45553			v0.AddArg(z)
 45554			v.AddArg(v0)
 45555			return true
 45556		}
 45557		// match: (Sub32 x x)
 45558		// cond:
 45559		// result: (Const32 [0])
 45560		for {
 45561			x := v.Args[1]
 45562			if x != v.Args[0] {
 45563				break
 45564			}
 45565			v.reset(OpConst32)
 45566			v.AuxInt = 0
 45567			return true
 45568		}
 45569		// match: (Sub32 (Add32 x y) x)
 45570		// cond:
 45571		// result: y
 45572		for {
 45573			x := v.Args[1]
 45574			v_0 := v.Args[0]
 45575			if v_0.Op != OpAdd32 {
 45576				break
 45577			}
 45578			y := v_0.Args[1]
 45579			if x != v_0.Args[0] {
 45580				break
 45581			}
 45582			v.reset(OpCopy)
 45583			v.Type = y.Type
 45584			v.AddArg(y)
 45585			return true
 45586		}
 45587		// match: (Sub32 (Add32 y x) x)
 45588		// cond:
 45589		// result: y
 45590		for {
 45591			x := v.Args[1]
 45592			v_0 := v.Args[0]
 45593			if v_0.Op != OpAdd32 {
 45594				break
 45595			}
 45596			_ = v_0.Args[1]
 45597			y := v_0.Args[0]
 45598			if x != v_0.Args[1] {
 45599				break
 45600			}
 45601			v.reset(OpCopy)
 45602			v.Type = y.Type
 45603			v.AddArg(y)
 45604			return true
 45605		}
 45606		// match: (Sub32 (Add32 x y) y)
 45607		// cond:
 45608		// result: x
 45609		for {
 45610			y := v.Args[1]
 45611			v_0 := v.Args[0]
 45612			if v_0.Op != OpAdd32 {
 45613				break
 45614			}
 45615			_ = v_0.Args[1]
 45616			x := v_0.Args[0]
 45617			if y != v_0.Args[1] {
 45618				break
 45619			}
 45620			v.reset(OpCopy)
 45621			v.Type = x.Type
 45622			v.AddArg(x)
 45623			return true
 45624		}
 45625		return false
 45626	}
 45627	func rewriteValuegeneric_OpSub32_10(v *Value) bool {
 45628		b := v.Block
 45629		// match: (Sub32 (Add32 y x) y)
 45630		// cond:
 45631		// result: x
 45632		for {
 45633			y := v.Args[1]
 45634			v_0 := v.Args[0]
 45635			if v_0.Op != OpAdd32 {
 45636				break
 45637			}
 45638			x := v_0.Args[1]
 45639			if y != v_0.Args[0] {
 45640				break
 45641			}
 45642			v.reset(OpCopy)
 45643			v.Type = x.Type
 45644			v.AddArg(x)
 45645			return true
 45646		}
 45647		// match: (Sub32 x (Sub32 i:(Const32 <t>) z))
 45648		// cond: (z.Op != OpConst32 && x.Op != OpConst32)
 45649		// result: (Sub32 (Add32 <t> x z) i)
 45650		for {
 45651			_ = v.Args[1]
 45652			x := v.Args[0]
 45653			v_1 := v.Args[1]
 45654			if v_1.Op != OpSub32 {
 45655				break
 45656			}
 45657			z := v_1.Args[1]
 45658			i := v_1.Args[0]
 45659			if i.Op != OpConst32 {
 45660				break
 45661			}
 45662			t := i.Type
 45663			if !(z.Op != OpConst32 && x.Op != OpConst32) {
 45664				break
 45665			}
 45666			v.reset(OpSub32)
 45667			v0 := b.NewValue0(v.Pos, OpAdd32, t)
 45668			v0.AddArg(x)
 45669			v0.AddArg(z)
 45670			v.AddArg(v0)
 45671			v.AddArg(i)
 45672			return true
 45673		}
 45674		// match: (Sub32 x (Sub32 z i:(Const32 <t>)))
 45675		// cond: (z.Op != OpConst32 && x.Op != OpConst32)
 45676		// result: (Add32 i (Sub32 <t> x z))
 45677		for {
 45678			_ = v.Args[1]
 45679			x := v.Args[0]
 45680			v_1 := v.Args[1]
 45681			if v_1.Op != OpSub32 {
 45682				break
 45683			}
 45684			_ = v_1.Args[1]
 45685			z := v_1.Args[0]
 45686			i := v_1.Args[1]
 45687			if i.Op != OpConst32 {
 45688				break
 45689			}
 45690			t := i.Type
 45691			if !(z.Op != OpConst32 && x.Op != OpConst32) {
 45692				break
 45693			}
 45694			v.reset(OpAdd32)
 45695			v.AddArg(i)
 45696			v0 := b.NewValue0(v.Pos, OpSub32, t)
 45697			v0.AddArg(x)
 45698			v0.AddArg(z)
 45699			v.AddArg(v0)
 45700			return true
 45701		}
 45702		// match: (Sub32 (Const32 <t> [c]) (Sub32 x (Const32 <t> [d])))
 45703		// cond:
 45704		// result: (Sub32 (Const32 <t> [int64(int32(c+d))]) x)
 45705		for {
 45706			_ = v.Args[1]
 45707			v_0 := v.Args[0]
 45708			if v_0.Op != OpConst32 {
 45709				break
 45710			}
 45711			t := v_0.Type
 45712			c := v_0.AuxInt
 45713			v_1 := v.Args[1]
 45714			if v_1.Op != OpSub32 {
 45715				break
 45716			}
 45717			_ = v_1.Args[1]
 45718			x := v_1.Args[0]
 45719			v_1_1 := v_1.Args[1]
 45720			if v_1_1.Op != OpConst32 {
 45721				break
 45722			}
 45723			if v_1_1.Type != t {
 45724				break
 45725			}
 45726			d := v_1_1.AuxInt
 45727			v.reset(OpSub32)
 45728			v0 := b.NewValue0(v.Pos, OpConst32, t)
 45729			v0.AuxInt = int64(int32(c + d))
 45730			v.AddArg(v0)
 45731			v.AddArg(x)
 45732			return true
 45733		}
 45734		// match: (Sub32 (Const32 <t> [c]) (Sub32 (Const32 <t> [d]) x))
 45735		// cond:
 45736		// result: (Add32 (Const32 <t> [int64(int32(c-d))]) x)
 45737		for {
 45738			_ = v.Args[1]
 45739			v_0 := v.Args[0]
 45740			if v_0.Op != OpConst32 {
 45741				break
 45742			}
 45743			t := v_0.Type
 45744			c := v_0.AuxInt
 45745			v_1 := v.Args[1]
 45746			if v_1.Op != OpSub32 {
 45747				break
 45748			}
 45749			x := v_1.Args[1]
 45750			v_1_0 := v_1.Args[0]
 45751			if v_1_0.Op != OpConst32 {
 45752				break
 45753			}
 45754			if v_1_0.Type != t {
 45755				break
 45756			}
 45757			d := v_1_0.AuxInt
 45758			v.reset(OpAdd32)
 45759			v0 := b.NewValue0(v.Pos, OpConst32, t)
 45760			v0.AuxInt = int64(int32(c - d))
 45761			v.AddArg(v0)
 45762			v.AddArg(x)
 45763			return true
 45764		}
 45765		return false
 45766	}
 45767	func rewriteValuegeneric_OpSub32F_0(v *Value) bool {
 45768		// match: (Sub32F (Const32F [c]) (Const32F [d]))
 45769		// cond:
 45770		// result: (Const32F [auxFrom32F(auxTo32F(c) - auxTo32F(d))])
 45771		for {
 45772			_ = v.Args[1]
 45773			v_0 := v.Args[0]
 45774			if v_0.Op != OpConst32F {
 45775				break
 45776			}
 45777			c := v_0.AuxInt
 45778			v_1 := v.Args[1]
 45779			if v_1.Op != OpConst32F {
 45780				break
 45781			}
 45782			d := v_1.AuxInt
 45783			v.reset(OpConst32F)
 45784			v.AuxInt = auxFrom32F(auxTo32F(c) - auxTo32F(d))
 45785			return true
 45786		}
 45787		return false
 45788	}
 45789	func rewriteValuegeneric_OpSub64_0(v *Value) bool {
 45790		b := v.Block
 45791		// match: (Sub64 (Const64 [c]) (Const64 [d]))
 45792		// cond:
 45793		// result: (Const64 [c-d])
 45794		for {
 45795			_ = v.Args[1]
 45796			v_0 := v.Args[0]
 45797			if v_0.Op != OpConst64 {
 45798				break
 45799			}
 45800			c := v_0.AuxInt
 45801			v_1 := v.Args[1]
 45802			if v_1.Op != OpConst64 {
 45803				break
 45804			}
 45805			d := v_1.AuxInt
 45806			v.reset(OpConst64)
 45807			v.AuxInt = c - d
 45808			return true
 45809		}
 45810		// match: (Sub64 x (Const64 <t> [c]))
 45811		// cond: x.Op != OpConst64
 45812		// result: (Add64 (Const64 <t> [-c]) x)
 45813		for {
 45814			_ = v.Args[1]
 45815			x := v.Args[0]
 45816			v_1 := v.Args[1]
 45817			if v_1.Op != OpConst64 {
 45818				break
 45819			}
 45820			t := v_1.Type
 45821			c := v_1.AuxInt
 45822			if !(x.Op != OpConst64) {
 45823				break
 45824			}
 45825			v.reset(OpAdd64)
 45826			v0 := b.NewValue0(v.Pos, OpConst64, t)
 45827			v0.AuxInt = -c
 45828			v.AddArg(v0)
 45829			v.AddArg(x)
 45830			return true
 45831		}
 45832		// match: (Sub64 <t> (Mul64 x y) (Mul64 x z))
 45833		// cond:
 45834		// result: (Mul64 x (Sub64 <t> y z))
 45835		for {
 45836			t := v.Type
 45837			_ = v.Args[1]
 45838			v_0 := v.Args[0]
 45839			if v_0.Op != OpMul64 {
 45840				break
 45841			}
 45842			y := v_0.Args[1]
 45843			x := v_0.Args[0]
 45844			v_1 := v.Args[1]
 45845			if v_1.Op != OpMul64 {
 45846				break
 45847			}
 45848			z := v_1.Args[1]
 45849			if x != v_1.Args[0] {
 45850				break
 45851			}
 45852			v.reset(OpMul64)
 45853			v.AddArg(x)
 45854			v0 := b.NewValue0(v.Pos, OpSub64, t)
 45855			v0.AddArg(y)
 45856			v0.AddArg(z)
 45857			v.AddArg(v0)
 45858			return true
 45859		}
 45860		// match: (Sub64 <t> (Mul64 y x) (Mul64 x z))
 45861		// cond:
 45862		// result: (Mul64 x (Sub64 <t> y z))
 45863		for {
 45864			t := v.Type
 45865			_ = v.Args[1]
 45866			v_0 := v.Args[0]
 45867			if v_0.Op != OpMul64 {
 45868				break
 45869			}
 45870			x := v_0.Args[1]
 45871			y := v_0.Args[0]
 45872			v_1 := v.Args[1]
 45873			if v_1.Op != OpMul64 {
 45874				break
 45875			}
 45876			z := v_1.Args[1]
 45877			if x != v_1.Args[0] {
 45878				break
 45879			}
 45880			v.reset(OpMul64)
 45881			v.AddArg(x)
 45882			v0 := b.NewValue0(v.Pos, OpSub64, t)
 45883			v0.AddArg(y)
 45884			v0.AddArg(z)
 45885			v.AddArg(v0)
 45886			return true
 45887		}
 45888		// match: (Sub64 <t> (Mul64 x y) (Mul64 z x))
 45889		// cond:
 45890		// result: (Mul64 x (Sub64 <t> y z))
 45891		for {
 45892			t := v.Type
 45893			_ = v.Args[1]
 45894			v_0 := v.Args[0]
 45895			if v_0.Op != OpMul64 {
 45896				break
 45897			}
 45898			y := v_0.Args[1]
 45899			x := v_0.Args[0]
 45900			v_1 := v.Args[1]
 45901			if v_1.Op != OpMul64 {
 45902				break
 45903			}
 45904			_ = v_1.Args[1]
 45905			z := v_1.Args[0]
 45906			if x != v_1.Args[1] {
 45907				break
 45908			}
 45909			v.reset(OpMul64)
 45910			v.AddArg(x)
 45911			v0 := b.NewValue0(v.Pos, OpSub64, t)
 45912			v0.AddArg(y)
 45913			v0.AddArg(z)
 45914			v.AddArg(v0)
 45915			return true
 45916		}
 45917		// match: (Sub64 <t> (Mul64 y x) (Mul64 z x))
 45918		// cond:
 45919		// result: (Mul64 x (Sub64 <t> y z))
 45920		for {
 45921			t := v.Type
 45922			_ = v.Args[1]
 45923			v_0 := v.Args[0]
 45924			if v_0.Op != OpMul64 {
 45925				break
 45926			}
 45927			x := v_0.Args[1]
 45928			y := v_0.Args[0]
 45929			v_1 := v.Args[1]
 45930			if v_1.Op != OpMul64 {
 45931				break
 45932			}
 45933			_ = v_1.Args[1]
 45934			z := v_1.Args[0]
 45935			if x != v_1.Args[1] {
 45936				break
 45937			}
 45938			v.reset(OpMul64)
 45939			v.AddArg(x)
 45940			v0 := b.NewValue0(v.Pos, OpSub64, t)
 45941			v0.AddArg(y)
 45942			v0.AddArg(z)
 45943			v.AddArg(v0)
 45944			return true
 45945		}
 45946		// match: (Sub64 x x)
 45947		// cond:
 45948		// result: (Const64 [0])
 45949		for {
 45950			x := v.Args[1]
 45951			if x != v.Args[0] {
 45952				break
 45953			}
 45954			v.reset(OpConst64)
 45955			v.AuxInt = 0
 45956			return true
 45957		}
 45958		// match: (Sub64 (Add64 x y) x)
 45959		// cond:
 45960		// result: y
 45961		for {
 45962			x := v.Args[1]
 45963			v_0 := v.Args[0]
 45964			if v_0.Op != OpAdd64 {
 45965				break
 45966			}
 45967			y := v_0.Args[1]
 45968			if x != v_0.Args[0] {
 45969				break
 45970			}
 45971			v.reset(OpCopy)
 45972			v.Type = y.Type
 45973			v.AddArg(y)
 45974			return true
 45975		}
 45976		// match: (Sub64 (Add64 y x) x)
 45977		// cond:
 45978		// result: y
 45979		for {
 45980			x := v.Args[1]
 45981			v_0 := v.Args[0]
 45982			if v_0.Op != OpAdd64 {
 45983				break
 45984			}
 45985			_ = v_0.Args[1]
 45986			y := v_0.Args[0]
 45987			if x != v_0.Args[1] {
 45988				break
 45989			}
 45990			v.reset(OpCopy)
 45991			v.Type = y.Type
 45992			v.AddArg(y)
 45993			return true
 45994		}
 45995		// match: (Sub64 (Add64 x y) y)
 45996		// cond:
 45997		// result: x
 45998		for {
 45999			y := v.Args[1]
 46000			v_0 := v.Args[0]
 46001			if v_0.Op != OpAdd64 {
 46002				break
 46003			}
 46004			_ = v_0.Args[1]
 46005			x := v_0.Args[0]
 46006			if y != v_0.Args[1] {
 46007				break
 46008			}
 46009			v.reset(OpCopy)
 46010			v.Type = x.Type
 46011			v.AddArg(x)
 46012			return true
 46013		}
 46014		return false
 46015	}
 46016	func rewriteValuegeneric_OpSub64_10(v *Value) bool {
 46017		b := v.Block
 46018		// match: (Sub64 (Add64 y x) y)
 46019		// cond:
 46020		// result: x
 46021		for {
 46022			y := v.Args[1]
 46023			v_0 := v.Args[0]
 46024			if v_0.Op != OpAdd64 {
 46025				break
 46026			}
 46027			x := v_0.Args[1]
 46028			if y != v_0.Args[0] {
 46029				break
 46030			}
 46031			v.reset(OpCopy)
 46032			v.Type = x.Type
 46033			v.AddArg(x)
 46034			return true
 46035		}
 46036		// match: (Sub64 x (Sub64 i:(Const64 <t>) z))
 46037		// cond: (z.Op != OpConst64 && x.Op != OpConst64)
 46038		// result: (Sub64 (Add64 <t> x z) i)
 46039		for {
 46040			_ = v.Args[1]
 46041			x := v.Args[0]
 46042			v_1 := v.Args[1]
 46043			if v_1.Op != OpSub64 {
 46044				break
 46045			}
 46046			z := v_1.Args[1]
 46047			i := v_1.Args[0]
 46048			if i.Op != OpConst64 {
 46049				break
 46050			}
 46051			t := i.Type
 46052			if !(z.Op != OpConst64 && x.Op != OpConst64) {
 46053				break
 46054			}
 46055			v.reset(OpSub64)
 46056			v0 := b.NewValue0(v.Pos, OpAdd64, t)
 46057			v0.AddArg(x)
 46058			v0.AddArg(z)
 46059			v.AddArg(v0)
 46060			v.AddArg(i)
 46061			return true
 46062		}
 46063		// match: (Sub64 x (Sub64 z i:(Const64 <t>)))
 46064		// cond: (z.Op != OpConst64 && x.Op != OpConst64)
 46065		// result: (Add64 i (Sub64 <t> x z))
 46066		for {
 46067			_ = v.Args[1]
 46068			x := v.Args[0]
 46069			v_1 := v.Args[1]
 46070			if v_1.Op != OpSub64 {
 46071				break
 46072			}
 46073			_ = v_1.Args[1]
 46074			z := v_1.Args[0]
 46075			i := v_1.Args[1]
 46076			if i.Op != OpConst64 {
 46077				break
 46078			}
 46079			t := i.Type
 46080			if !(z.Op != OpConst64 && x.Op != OpConst64) {
 46081				break
 46082			}
 46083			v.reset(OpAdd64)
 46084			v.AddArg(i)
 46085			v0 := b.NewValue0(v.Pos, OpSub64, t)
 46086			v0.AddArg(x)
 46087			v0.AddArg(z)
 46088			v.AddArg(v0)
 46089			return true
 46090		}
 46091		// match: (Sub64 (Const64 <t> [c]) (Sub64 x (Const64 <t> [d])))
 46092		// cond:
 46093		// result: (Sub64 (Const64 <t> [c+d]) x)
 46094		for {
 46095			_ = v.Args[1]
 46096			v_0 := v.Args[0]
 46097			if v_0.Op != OpConst64 {
 46098				break
 46099			}
 46100			t := v_0.Type
 46101			c := v_0.AuxInt
 46102			v_1 := v.Args[1]
 46103			if v_1.Op != OpSub64 {
 46104				break
 46105			}
 46106			_ = v_1.Args[1]
 46107			x := v_1.Args[0]
 46108			v_1_1 := v_1.Args[1]
 46109			if v_1_1.Op != OpConst64 {
 46110				break
 46111			}
 46112			if v_1_1.Type != t {
 46113				break
 46114			}
 46115			d := v_1_1.AuxInt
 46116			v.reset(OpSub64)
 46117			v0 := b.NewValue0(v.Pos, OpConst64, t)
 46118			v0.AuxInt = c + d
 46119			v.AddArg(v0)
 46120			v.AddArg(x)
 46121			return true
 46122		}
 46123		// match: (Sub64 (Const64 <t> [c]) (Sub64 (Const64 <t> [d]) x))
 46124		// cond:
 46125		// result: (Add64 (Const64 <t> [c-d]) x)
 46126		for {
 46127			_ = v.Args[1]
 46128			v_0 := v.Args[0]
 46129			if v_0.Op != OpConst64 {
 46130				break
 46131			}
 46132			t := v_0.Type
 46133			c := v_0.AuxInt
 46134			v_1 := v.Args[1]
 46135			if v_1.Op != OpSub64 {
 46136				break
 46137			}
 46138			x := v_1.Args[1]
 46139			v_1_0 := v_1.Args[0]
 46140			if v_1_0.Op != OpConst64 {
 46141				break
 46142			}
 46143			if v_1_0.Type != t {
 46144				break
 46145			}
 46146			d := v_1_0.AuxInt
 46147			v.reset(OpAdd64)
 46148			v0 := b.NewValue0(v.Pos, OpConst64, t)
 46149			v0.AuxInt = c - d
 46150			v.AddArg(v0)
 46151			v.AddArg(x)
 46152			return true
 46153		}
 46154		return false
 46155	}
 46156	func rewriteValuegeneric_OpSub64F_0(v *Value) bool {
 46157		// match: (Sub64F (Const64F [c]) (Const64F [d]))
 46158		// cond:
 46159		// result: (Const64F [auxFrom64F(auxTo64F(c) - auxTo64F(d))])
 46160		for {
 46161			_ = v.Args[1]
 46162			v_0 := v.Args[0]
 46163			if v_0.Op != OpConst64F {
 46164				break
 46165			}
 46166			c := v_0.AuxInt
 46167			v_1 := v.Args[1]
 46168			if v_1.Op != OpConst64F {
 46169				break
 46170			}
 46171			d := v_1.AuxInt
 46172			v.reset(OpConst64F)
 46173			v.AuxInt = auxFrom64F(auxTo64F(c) - auxTo64F(d))
 46174			return true
 46175		}
 46176		return false
 46177	}
 46178	func rewriteValuegeneric_OpSub8_0(v *Value) bool {
 46179		b := v.Block
 46180		// match: (Sub8 (Const8 [c]) (Const8 [d]))
 46181		// cond:
 46182		// result: (Const8 [int64(int8(c-d))])
 46183		for {
 46184			_ = v.Args[1]
 46185			v_0 := v.Args[0]
 46186			if v_0.Op != OpConst8 {
 46187				break
 46188			}
 46189			c := v_0.AuxInt
 46190			v_1 := v.Args[1]
 46191			if v_1.Op != OpConst8 {
 46192				break
 46193			}
 46194			d := v_1.AuxInt
 46195			v.reset(OpConst8)
 46196			v.AuxInt = int64(int8(c - d))
 46197			return true
 46198		}
 46199		// match: (Sub8 x (Const8 <t> [c]))
 46200		// cond: x.Op != OpConst8
 46201		// result: (Add8 (Const8 <t> [int64(int8(-c))]) x)
 46202		for {
 46203			_ = v.Args[1]
 46204			x := v.Args[0]
 46205			v_1 := v.Args[1]
 46206			if v_1.Op != OpConst8 {
 46207				break
 46208			}
 46209			t := v_1.Type
 46210			c := v_1.AuxInt
 46211			if !(x.Op != OpConst8) {
 46212				break
 46213			}
 46214			v.reset(OpAdd8)
 46215			v0 := b.NewValue0(v.Pos, OpConst8, t)
 46216			v0.AuxInt = int64(int8(-c))
 46217			v.AddArg(v0)
 46218			v.AddArg(x)
 46219			return true
 46220		}
 46221		// match: (Sub8 <t> (Mul8 x y) (Mul8 x z))
 46222		// cond:
 46223		// result: (Mul8 x (Sub8 <t> y z))
 46224		for {
 46225			t := v.Type
 46226			_ = v.Args[1]
 46227			v_0 := v.Args[0]
 46228			if v_0.Op != OpMul8 {
 46229				break
 46230			}
 46231			y := v_0.Args[1]
 46232			x := v_0.Args[0]
 46233			v_1 := v.Args[1]
 46234			if v_1.Op != OpMul8 {
 46235				break
 46236			}
 46237			z := v_1.Args[1]
 46238			if x != v_1.Args[0] {
 46239				break
 46240			}
 46241			v.reset(OpMul8)
 46242			v.AddArg(x)
 46243			v0 := b.NewValue0(v.Pos, OpSub8, t)
 46244			v0.AddArg(y)
 46245			v0.AddArg(z)
 46246			v.AddArg(v0)
 46247			return true
 46248		}
 46249		// match: (Sub8 <t> (Mul8 y x) (Mul8 x z))
 46250		// cond:
 46251		// result: (Mul8 x (Sub8 <t> y z))
 46252		for {
 46253			t := v.Type
 46254			_ = v.Args[1]
 46255			v_0 := v.Args[0]
 46256			if v_0.Op != OpMul8 {
 46257				break
 46258			}
 46259			x := v_0.Args[1]
 46260			y := v_0.Args[0]
 46261			v_1 := v.Args[1]
 46262			if v_1.Op != OpMul8 {
 46263				break
 46264			}
 46265			z := v_1.Args[1]
 46266			if x != v_1.Args[0] {
 46267				break
 46268			}
 46269			v.reset(OpMul8)
 46270			v.AddArg(x)
 46271			v0 := b.NewValue0(v.Pos, OpSub8, t)
 46272			v0.AddArg(y)
 46273			v0.AddArg(z)
 46274			v.AddArg(v0)
 46275			return true
 46276		}
 46277		// match: (Sub8 <t> (Mul8 x y) (Mul8 z x))
 46278		// cond:
 46279		// result: (Mul8 x (Sub8 <t> y z))
 46280		for {
 46281			t := v.Type
 46282			_ = v.Args[1]
 46283			v_0 := v.Args[0]
 46284			if v_0.Op != OpMul8 {
 46285				break
 46286			}
 46287			y := v_0.Args[1]
 46288			x := v_0.Args[0]
 46289			v_1 := v.Args[1]
 46290			if v_1.Op != OpMul8 {
 46291				break
 46292			}
 46293			_ = v_1.Args[1]
 46294			z := v_1.Args[0]
 46295			if x != v_1.Args[1] {
 46296				break
 46297			}
 46298			v.reset(OpMul8)
 46299			v.AddArg(x)
 46300			v0 := b.NewValue0(v.Pos, OpSub8, t)
 46301			v0.AddArg(y)
 46302			v0.AddArg(z)
 46303			v.AddArg(v0)
 46304			return true
 46305		}
 46306		// match: (Sub8 <t> (Mul8 y x) (Mul8 z x))
 46307		// cond:
 46308		// result: (Mul8 x (Sub8 <t> y z))
 46309		for {
 46310			t := v.Type
 46311			_ = v.Args[1]
 46312			v_0 := v.Args[0]
 46313			if v_0.Op != OpMul8 {
 46314				break
 46315			}
 46316			x := v_0.Args[1]
 46317			y := v_0.Args[0]
 46318			v_1 := v.Args[1]
 46319			if v_1.Op != OpMul8 {
 46320				break
 46321			}
 46322			_ = v_1.Args[1]
 46323			z := v_1.Args[0]
 46324			if x != v_1.Args[1] {
 46325				break
 46326			}
 46327			v.reset(OpMul8)
 46328			v.AddArg(x)
 46329			v0 := b.NewValue0(v.Pos, OpSub8, t)
 46330			v0.AddArg(y)
 46331			v0.AddArg(z)
 46332			v.AddArg(v0)
 46333			return true
 46334		}
 46335		// match: (Sub8 x x)
 46336		// cond:
 46337		// result: (Const8 [0])
 46338		for {
 46339			x := v.Args[1]
 46340			if x != v.Args[0] {
 46341				break
 46342			}
 46343			v.reset(OpConst8)
 46344			v.AuxInt = 0
 46345			return true
 46346		}
 46347		// match: (Sub8 (Add8 x y) x)
 46348		// cond:
 46349		// result: y
 46350		for {
 46351			x := v.Args[1]
 46352			v_0 := v.Args[0]
 46353			if v_0.Op != OpAdd8 {
 46354				break
 46355			}
 46356			y := v_0.Args[1]
 46357			if x != v_0.Args[0] {
 46358				break
 46359			}
 46360			v.reset(OpCopy)
 46361			v.Type = y.Type
 46362			v.AddArg(y)
 46363			return true
 46364		}
 46365		// match: (Sub8 (Add8 y x) x)
 46366		// cond:
 46367		// result: y
 46368		for {
 46369			x := v.Args[1]
 46370			v_0 := v.Args[0]
 46371			if v_0.Op != OpAdd8 {
 46372				break
 46373			}
 46374			_ = v_0.Args[1]
 46375			y := v_0.Args[0]
 46376			if x != v_0.Args[1] {
 46377				break
 46378			}
 46379			v.reset(OpCopy)
 46380			v.Type = y.Type
 46381			v.AddArg(y)
 46382			return true
 46383		}
 46384		// match: (Sub8 (Add8 x y) y)
 46385		// cond:
 46386		// result: x
 46387		for {
 46388			y := v.Args[1]
 46389			v_0 := v.Args[0]
 46390			if v_0.Op != OpAdd8 {
 46391				break
 46392			}
 46393			_ = v_0.Args[1]
 46394			x := v_0.Args[0]
 46395			if y != v_0.Args[1] {
 46396				break
 46397			}
 46398			v.reset(OpCopy)
 46399			v.Type = x.Type
 46400			v.AddArg(x)
 46401			return true
 46402		}
 46403		return false
 46404	}
 46405	func rewriteValuegeneric_OpSub8_10(v *Value) bool {
 46406		b := v.Block
 46407		// match: (Sub8 (Add8 y x) y)
 46408		// cond:
 46409		// result: x
 46410		for {
 46411			y := v.Args[1]
 46412			v_0 := v.Args[0]
 46413			if v_0.Op != OpAdd8 {
 46414				break
 46415			}
 46416			x := v_0.Args[1]
 46417			if y != v_0.Args[0] {
 46418				break
 46419			}
 46420			v.reset(OpCopy)
 46421			v.Type = x.Type
 46422			v.AddArg(x)
 46423			return true
 46424		}
 46425		// match: (Sub8 x (Sub8 i:(Const8 <t>) z))
 46426		// cond: (z.Op != OpConst8 && x.Op != OpConst8)
 46427		// result: (Sub8 (Add8 <t> x z) i)
 46428		for {
 46429			_ = v.Args[1]
 46430			x := v.Args[0]
 46431			v_1 := v.Args[1]
 46432			if v_1.Op != OpSub8 {
 46433				break
 46434			}
 46435			z := v_1.Args[1]
 46436			i := v_1.Args[0]
 46437			if i.Op != OpConst8 {
 46438				break
 46439			}
 46440			t := i.Type
 46441			if !(z.Op != OpConst8 && x.Op != OpConst8) {
 46442				break
 46443			}
 46444			v.reset(OpSub8)
 46445			v0 := b.NewValue0(v.Pos, OpAdd8, t)
 46446			v0.AddArg(x)
 46447			v0.AddArg(z)
 46448			v.AddArg(v0)
 46449			v.AddArg(i)
 46450			return true
 46451		}
 46452		// match: (Sub8 x (Sub8 z i:(Const8 <t>)))
 46453		// cond: (z.Op != OpConst8 && x.Op != OpConst8)
 46454		// result: (Add8 i (Sub8 <t> x z))
 46455		for {
 46456			_ = v.Args[1]
 46457			x := v.Args[0]
 46458			v_1 := v.Args[1]
 46459			if v_1.Op != OpSub8 {
 46460				break
 46461			}
 46462			_ = v_1.Args[1]
 46463			z := v_1.Args[0]
 46464			i := v_1.Args[1]
 46465			if i.Op != OpConst8 {
 46466				break
 46467			}
 46468			t := i.Type
 46469			if !(z.Op != OpConst8 && x.Op != OpConst8) {
 46470				break
 46471			}
 46472			v.reset(OpAdd8)
 46473			v.AddArg(i)
 46474			v0 := b.NewValue0(v.Pos, OpSub8, t)
 46475			v0.AddArg(x)
 46476			v0.AddArg(z)
 46477			v.AddArg(v0)
 46478			return true
 46479		}
 46480		// match: (Sub8 (Const8 <t> [c]) (Sub8 x (Const8 <t> [d])))
 46481		// cond:
 46482		// result: (Sub8 (Const8 <t> [int64(int8(c+d))]) x)
 46483		for {
 46484			_ = v.Args[1]
 46485			v_0 := v.Args[0]
 46486			if v_0.Op != OpConst8 {
 46487				break
 46488			}
 46489			t := v_0.Type
 46490			c := v_0.AuxInt
 46491			v_1 := v.Args[1]
 46492			if v_1.Op != OpSub8 {
 46493				break
 46494			}
 46495			_ = v_1.Args[1]
 46496			x := v_1.Args[0]
 46497			v_1_1 := v_1.Args[1]
 46498			if v_1_1.Op != OpConst8 {
 46499				break
 46500			}
 46501			if v_1_1.Type != t {
 46502				break
 46503			}
 46504			d := v_1_1.AuxInt
 46505			v.reset(OpSub8)
 46506			v0 := b.NewValue0(v.Pos, OpConst8, t)
 46507			v0.AuxInt = int64(int8(c + d))
 46508			v.AddArg(v0)
 46509			v.AddArg(x)
 46510			return true
 46511		}
 46512		// match: (Sub8 (Const8 <t> [c]) (Sub8 (Const8 <t> [d]) x))
 46513		// cond:
 46514		// result: (Add8 (Const8 <t> [int64(int8(c-d))]) x)
 46515		for {
 46516			_ = v.Args[1]
 46517			v_0 := v.Args[0]
 46518			if v_0.Op != OpConst8 {
 46519				break
 46520			}
 46521			t := v_0.Type
 46522			c := v_0.AuxInt
 46523			v_1 := v.Args[1]
 46524			if v_1.Op != OpSub8 {
 46525				break
 46526			}
 46527			x := v_1.Args[1]
 46528			v_1_0 := v_1.Args[0]
 46529			if v_1_0.Op != OpConst8 {
 46530				break
 46531			}
 46532			if v_1_0.Type != t {
 46533				break
 46534			}
 46535			d := v_1_0.AuxInt
 46536			v.reset(OpAdd8)
 46537			v0 := b.NewValue0(v.Pos, OpConst8, t)
 46538			v0.AuxInt = int64(int8(c - d))
 46539			v.AddArg(v0)
 46540			v.AddArg(x)
 46541			return true
 46542		}
 46543		return false
 46544	}
 46545	func rewriteValuegeneric_OpTrunc16to8_0(v *Value) bool {
 46546		// match: (Trunc16to8 (Const16 [c]))
 46547		// cond:
 46548		// result: (Const8 [int64(int8(c))])
 46549		for {
 46550			v_0 := v.Args[0]
 46551			if v_0.Op != OpConst16 {
 46552				break
 46553			}
 46554			c := v_0.AuxInt
 46555			v.reset(OpConst8)
 46556			v.AuxInt = int64(int8(c))
 46557			return true
 46558		}
 46559		// match: (Trunc16to8 (ZeroExt8to16 x))
 46560		// cond:
 46561		// result: x
 46562		for {
 46563			v_0 := v.Args[0]
 46564			if v_0.Op != OpZeroExt8to16 {
 46565				break
 46566			}
 46567			x := v_0.Args[0]
 46568			v.reset(OpCopy)
 46569			v.Type = x.Type
 46570			v.AddArg(x)
 46571			return true
 46572		}
 46573		// match: (Trunc16to8 (SignExt8to16 x))
 46574		// cond:
 46575		// result: x
 46576		for {
 46577			v_0 := v.Args[0]
 46578			if v_0.Op != OpSignExt8to16 {
 46579				break
 46580			}
 46581			x := v_0.Args[0]
 46582			v.reset(OpCopy)
 46583			v.Type = x.Type
 46584			v.AddArg(x)
 46585			return true
 46586		}
 46587		// match: (Trunc16to8 (And16 (Const16 [y]) x))
 46588		// cond: y&0xFF == 0xFF
 46589		// result: (Trunc16to8 x)
 46590		for {
 46591			v_0 := v.Args[0]
 46592			if v_0.Op != OpAnd16 {
 46593				break
 46594			}
 46595			x := v_0.Args[1]
 46596			v_0_0 := v_0.Args[0]
 46597			if v_0_0.Op != OpConst16 {
 46598				break
 46599			}
 46600			y := v_0_0.AuxInt
 46601			if !(y&0xFF == 0xFF) {
 46602				break
 46603			}
 46604			v.reset(OpTrunc16to8)
 46605			v.AddArg(x)
 46606			return true
 46607		}
 46608		// match: (Trunc16to8 (And16 x (Const16 [y])))
 46609		// cond: y&0xFF == 0xFF
 46610		// result: (Trunc16to8 x)
 46611		for {
 46612			v_0 := v.Args[0]
 46613			if v_0.Op != OpAnd16 {
 46614				break
 46615			}
 46616			_ = v_0.Args[1]
 46617			x := v_0.Args[0]
 46618			v_0_1 := v_0.Args[1]
 46619			if v_0_1.Op != OpConst16 {
 46620				break
 46621			}
 46622			y := v_0_1.AuxInt
 46623			if !(y&0xFF == 0xFF) {
 46624				break
 46625			}
 46626			v.reset(OpTrunc16to8)
 46627			v.AddArg(x)
 46628			return true
 46629		}
 46630		return false
 46631	}
 46632	func rewriteValuegeneric_OpTrunc32to16_0(v *Value) bool {
 46633		// match: (Trunc32to16 (Const32 [c]))
 46634		// cond:
 46635		// result: (Const16 [int64(int16(c))])
 46636		for {
 46637			v_0 := v.Args[0]
 46638			if v_0.Op != OpConst32 {
 46639				break
 46640			}
 46641			c := v_0.AuxInt
 46642			v.reset(OpConst16)
 46643			v.AuxInt = int64(int16(c))
 46644			return true
 46645		}
 46646		// match: (Trunc32to16 (ZeroExt8to32 x))
 46647		// cond:
 46648		// result: (ZeroExt8to16 x)
 46649		for {
 46650			v_0 := v.Args[0]
 46651			if v_0.Op != OpZeroExt8to32 {
 46652				break
 46653			}
 46654			x := v_0.Args[0]
 46655			v.reset(OpZeroExt8to16)
 46656			v.AddArg(x)
 46657			return true
 46658		}
 46659		// match: (Trunc32to16 (ZeroExt16to32 x))
 46660		// cond:
 46661		// result: x
 46662		for {
 46663			v_0 := v.Args[0]
 46664			if v_0.Op != OpZeroExt16to32 {
 46665				break
 46666			}
 46667			x := v_0.Args[0]
 46668			v.reset(OpCopy)
 46669			v.Type = x.Type
 46670			v.AddArg(x)
 46671			return true
 46672		}
 46673		// match: (Trunc32to16 (SignExt8to32 x))
 46674		// cond:
 46675		// result: (SignExt8to16 x)
 46676		for {
 46677			v_0 := v.Args[0]
 46678			if v_0.Op != OpSignExt8to32 {
 46679				break
 46680			}
 46681			x := v_0.Args[0]
 46682			v.reset(OpSignExt8to16)
 46683			v.AddArg(x)
 46684			return true
 46685		}
 46686		// match: (Trunc32to16 (SignExt16to32 x))
 46687		// cond:
 46688		// result: x
 46689		for {
 46690			v_0 := v.Args[0]
 46691			if v_0.Op != OpSignExt16to32 {
 46692				break
 46693			}
 46694			x := v_0.Args[0]
 46695			v.reset(OpCopy)
 46696			v.Type = x.Type
 46697			v.AddArg(x)
 46698			return true
 46699		}
 46700		// match: (Trunc32to16 (And32 (Const32 [y]) x))
 46701		// cond: y&0xFFFF == 0xFFFF
 46702		// result: (Trunc32to16 x)
 46703		for {
 46704			v_0 := v.Args[0]
 46705			if v_0.Op != OpAnd32 {
 46706				break
 46707			}
 46708			x := v_0.Args[1]
 46709			v_0_0 := v_0.Args[0]
 46710			if v_0_0.Op != OpConst32 {
 46711				break
 46712			}
 46713			y := v_0_0.AuxInt
 46714			if !(y&0xFFFF == 0xFFFF) {
 46715				break
 46716			}
 46717			v.reset(OpTrunc32to16)
 46718			v.AddArg(x)
 46719			return true
 46720		}
 46721		// match: (Trunc32to16 (And32 x (Const32 [y])))
 46722		// cond: y&0xFFFF == 0xFFFF
 46723		// result: (Trunc32to16 x)
 46724		for {
 46725			v_0 := v.Args[0]
 46726			if v_0.Op != OpAnd32 {
 46727				break
 46728			}
 46729			_ = v_0.Args[1]
 46730			x := v_0.Args[0]
 46731			v_0_1 := v_0.Args[1]
 46732			if v_0_1.Op != OpConst32 {
 46733				break
 46734			}
 46735			y := v_0_1.AuxInt
 46736			if !(y&0xFFFF == 0xFFFF) {
 46737				break
 46738			}
 46739			v.reset(OpTrunc32to16)
 46740			v.AddArg(x)
 46741			return true
 46742		}
 46743		return false
 46744	}
 46745	func rewriteValuegeneric_OpTrunc32to8_0(v *Value) bool {
 46746		// match: (Trunc32to8 (Const32 [c]))
 46747		// cond:
 46748		// result: (Const8 [int64(int8(c))])
 46749		for {
 46750			v_0 := v.Args[0]
 46751			if v_0.Op != OpConst32 {
 46752				break
 46753			}
 46754			c := v_0.AuxInt
 46755			v.reset(OpConst8)
 46756			v.AuxInt = int64(int8(c))
 46757			return true
 46758		}
 46759		// match: (Trunc32to8 (ZeroExt8to32 x))
 46760		// cond:
 46761		// result: x
 46762		for {
 46763			v_0 := v.Args[0]
 46764			if v_0.Op != OpZeroExt8to32 {
 46765				break
 46766			}
 46767			x := v_0.Args[0]
 46768			v.reset(OpCopy)
 46769			v.Type = x.Type
 46770			v.AddArg(x)
 46771			return true
 46772		}
 46773		// match: (Trunc32to8 (SignExt8to32 x))
 46774		// cond:
 46775		// result: x
 46776		for {
 46777			v_0 := v.Args[0]
 46778			if v_0.Op != OpSignExt8to32 {
 46779				break
 46780			}
 46781			x := v_0.Args[0]
 46782			v.reset(OpCopy)
 46783			v.Type = x.Type
 46784			v.AddArg(x)
 46785			return true
 46786		}
 46787		// match: (Trunc32to8 (And32 (Const32 [y]) x))
 46788		// cond: y&0xFF == 0xFF
 46789		// result: (Trunc32to8 x)
 46790		for {
 46791			v_0 := v.Args[0]
 46792			if v_0.Op != OpAnd32 {
 46793				break
 46794			}
 46795			x := v_0.Args[1]
 46796			v_0_0 := v_0.Args[0]
 46797			if v_0_0.Op != OpConst32 {
 46798				break
 46799			}
 46800			y := v_0_0.AuxInt
 46801			if !(y&0xFF == 0xFF) {
 46802				break
 46803			}
 46804			v.reset(OpTrunc32to8)
 46805			v.AddArg(x)
 46806			return true
 46807		}
 46808		// match: (Trunc32to8 (And32 x (Const32 [y])))
 46809		// cond: y&0xFF == 0xFF
 46810		// result: (Trunc32to8 x)
 46811		for {
 46812			v_0 := v.Args[0]
 46813			if v_0.Op != OpAnd32 {
 46814				break
 46815			}
 46816			_ = v_0.Args[1]
 46817			x := v_0.Args[0]
 46818			v_0_1 := v_0.Args[1]
 46819			if v_0_1.Op != OpConst32 {
 46820				break
 46821			}
 46822			y := v_0_1.AuxInt
 46823			if !(y&0xFF == 0xFF) {
 46824				break
 46825			}
 46826			v.reset(OpTrunc32to8)
 46827			v.AddArg(x)
 46828			return true
 46829		}
 46830		return false
 46831	}
 46832	func rewriteValuegeneric_OpTrunc64to16_0(v *Value) bool {
 46833		// match: (Trunc64to16 (Const64 [c]))
 46834		// cond:
 46835		// result: (Const16 [int64(int16(c))])
 46836		for {
 46837			v_0 := v.Args[0]
 46838			if v_0.Op != OpConst64 {
 46839				break
 46840			}
 46841			c := v_0.AuxInt
 46842			v.reset(OpConst16)
 46843			v.AuxInt = int64(int16(c))
 46844			return true
 46845		}
 46846		// match: (Trunc64to16 (ZeroExt8to64 x))
 46847		// cond:
 46848		// result: (ZeroExt8to16 x)
 46849		for {
 46850			v_0 := v.Args[0]
 46851			if v_0.Op != OpZeroExt8to64 {
 46852				break
 46853			}
 46854			x := v_0.Args[0]
 46855			v.reset(OpZeroExt8to16)
 46856			v.AddArg(x)
 46857			return true
 46858		}
 46859		// match: (Trunc64to16 (ZeroExt16to64 x))
 46860		// cond:
 46861		// result: x
 46862		for {
 46863			v_0 := v.Args[0]
 46864			if v_0.Op != OpZeroExt16to64 {
 46865				break
 46866			}
 46867			x := v_0.Args[0]
 46868			v.reset(OpCopy)
 46869			v.Type = x.Type
 46870			v.AddArg(x)
 46871			return true
 46872		}
 46873		// match: (Trunc64to16 (SignExt8to64 x))
 46874		// cond:
 46875		// result: (SignExt8to16 x)
 46876		for {
 46877			v_0 := v.Args[0]
 46878			if v_0.Op != OpSignExt8to64 {
 46879				break
 46880			}
 46881			x := v_0.Args[0]
 46882			v.reset(OpSignExt8to16)
 46883			v.AddArg(x)
 46884			return true
 46885		}
 46886		// match: (Trunc64to16 (SignExt16to64 x))
 46887		// cond:
 46888		// result: x
 46889		for {
 46890			v_0 := v.Args[0]
 46891			if v_0.Op != OpSignExt16to64 {
 46892				break
 46893			}
 46894			x := v_0.Args[0]
 46895			v.reset(OpCopy)
 46896			v.Type = x.Type
 46897			v.AddArg(x)
 46898			return true
 46899		}
 46900		// match: (Trunc64to16 (And64 (Const64 [y]) x))
 46901		// cond: y&0xFFFF == 0xFFFF
 46902		// result: (Trunc64to16 x)
 46903		for {
 46904			v_0 := v.Args[0]
 46905			if v_0.Op != OpAnd64 {
 46906				break
 46907			}
 46908			x := v_0.Args[1]
 46909			v_0_0 := v_0.Args[0]
 46910			if v_0_0.Op != OpConst64 {
 46911				break
 46912			}
 46913			y := v_0_0.AuxInt
 46914			if !(y&0xFFFF == 0xFFFF) {
 46915				break
 46916			}
 46917			v.reset(OpTrunc64to16)
 46918			v.AddArg(x)
 46919			return true
 46920		}
 46921		// match: (Trunc64to16 (And64 x (Const64 [y])))
 46922		// cond: y&0xFFFF == 0xFFFF
 46923		// result: (Trunc64to16 x)
 46924		for {
 46925			v_0 := v.Args[0]
 46926			if v_0.Op != OpAnd64 {
 46927				break
 46928			}
 46929			_ = v_0.Args[1]
 46930			x := v_0.Args[0]
 46931			v_0_1 := v_0.Args[1]
 46932			if v_0_1.Op != OpConst64 {
 46933				break
 46934			}
 46935			y := v_0_1.AuxInt
 46936			if !(y&0xFFFF == 0xFFFF) {
 46937				break
 46938			}
 46939			v.reset(OpTrunc64to16)
 46940			v.AddArg(x)
 46941			return true
 46942		}
 46943		return false
 46944	}
 46945	func rewriteValuegeneric_OpTrunc64to32_0(v *Value) bool {
 46946		// match: (Trunc64to32 (Const64 [c]))
 46947		// cond:
 46948		// result: (Const32 [int64(int32(c))])
 46949		for {
 46950			v_0 := v.Args[0]
 46951			if v_0.Op != OpConst64 {
 46952				break
 46953			}
 46954			c := v_0.AuxInt
 46955			v.reset(OpConst32)
 46956			v.AuxInt = int64(int32(c))
 46957			return true
 46958		}
 46959		// match: (Trunc64to32 (ZeroExt8to64 x))
 46960		// cond:
 46961		// result: (ZeroExt8to32 x)
 46962		for {
 46963			v_0 := v.Args[0]
 46964			if v_0.Op != OpZeroExt8to64 {
 46965				break
 46966			}
 46967			x := v_0.Args[0]
 46968			v.reset(OpZeroExt8to32)
 46969			v.AddArg(x)
 46970			return true
 46971		}
 46972		// match: (Trunc64to32 (ZeroExt16to64 x))
 46973		// cond:
 46974		// result: (ZeroExt16to32 x)
 46975		for {
 46976			v_0 := v.Args[0]
 46977			if v_0.Op != OpZeroExt16to64 {
 46978				break
 46979			}
 46980			x := v_0.Args[0]
 46981			v.reset(OpZeroExt16to32)
 46982			v.AddArg(x)
 46983			return true
 46984		}
 46985		// match: (Trunc64to32 (ZeroExt32to64 x))
 46986		// cond:
 46987		// result: x
 46988		for {
 46989			v_0 := v.Args[0]
 46990			if v_0.Op != OpZeroExt32to64 {
 46991				break
 46992			}
 46993			x := v_0.Args[0]
 46994			v.reset(OpCopy)
 46995			v.Type = x.Type
 46996			v.AddArg(x)
 46997			return true
 46998		}
 46999		// match: (Trunc64to32 (SignExt8to64 x))
 47000		// cond:
 47001		// result: (SignExt8to32 x)
 47002		for {
 47003			v_0 := v.Args[0]
 47004			if v_0.Op != OpSignExt8to64 {
 47005				break
 47006			}
 47007			x := v_0.Args[0]
 47008			v.reset(OpSignExt8to32)
 47009			v.AddArg(x)
 47010			return true
 47011		}
 47012		// match: (Trunc64to32 (SignExt16to64 x))
 47013		// cond:
 47014		// result: (SignExt16to32 x)
 47015		for {
 47016			v_0 := v.Args[0]
 47017			if v_0.Op != OpSignExt16to64 {
 47018				break
 47019			}
 47020			x := v_0.Args[0]
 47021			v.reset(OpSignExt16to32)
 47022			v.AddArg(x)
 47023			return true
 47024		}
 47025		// match: (Trunc64to32 (SignExt32to64 x))
 47026		// cond:
 47027		// result: x
 47028		for {
 47029			v_0 := v.Args[0]
 47030			if v_0.Op != OpSignExt32to64 {
 47031				break
 47032			}
 47033			x := v_0.Args[0]
 47034			v.reset(OpCopy)
 47035			v.Type = x.Type
 47036			v.AddArg(x)
 47037			return true
 47038		}
 47039		// match: (Trunc64to32 (And64 (Const64 [y]) x))
 47040		// cond: y&0xFFFFFFFF == 0xFFFFFFFF
 47041		// result: (Trunc64to32 x)
 47042		for {
 47043			v_0 := v.Args[0]
 47044			if v_0.Op != OpAnd64 {
 47045				break
 47046			}
 47047			x := v_0.Args[1]
 47048			v_0_0 := v_0.Args[0]
 47049			if v_0_0.Op != OpConst64 {
 47050				break
 47051			}
 47052			y := v_0_0.AuxInt
 47053			if !(y&0xFFFFFFFF == 0xFFFFFFFF) {
 47054				break
 47055			}
 47056			v.reset(OpTrunc64to32)
 47057			v.AddArg(x)
 47058			return true
 47059		}
 47060		// match: (Trunc64to32 (And64 x (Const64 [y])))
 47061		// cond: y&0xFFFFFFFF == 0xFFFFFFFF
 47062		// result: (Trunc64to32 x)
 47063		for {
 47064			v_0 := v.Args[0]
 47065			if v_0.Op != OpAnd64 {
 47066				break
 47067			}
 47068			_ = v_0.Args[1]
 47069			x := v_0.Args[0]
 47070			v_0_1 := v_0.Args[1]
 47071			if v_0_1.Op != OpConst64 {
 47072				break
 47073			}
 47074			y := v_0_1.AuxInt
 47075			if !(y&0xFFFFFFFF == 0xFFFFFFFF) {
 47076				break
 47077			}
 47078			v.reset(OpTrunc64to32)
 47079			v.AddArg(x)
 47080			return true
 47081		}
 47082		return false
 47083	}
 47084	func rewriteValuegeneric_OpTrunc64to8_0(v *Value) bool {
 47085		// match: (Trunc64to8 (Const64 [c]))
 47086		// cond:
 47087		// result: (Const8 [int64(int8(c))])
 47088		for {
 47089			v_0 := v.Args[0]
 47090			if v_0.Op != OpConst64 {
 47091				break
 47092			}
 47093			c := v_0.AuxInt
 47094			v.reset(OpConst8)
 47095			v.AuxInt = int64(int8(c))
 47096			return true
 47097		}
 47098		// match: (Trunc64to8 (ZeroExt8to64 x))
 47099		// cond:
 47100		// result: x
 47101		for {
 47102			v_0 := v.Args[0]
 47103			if v_0.Op != OpZeroExt8to64 {
 47104				break
 47105			}
 47106			x := v_0.Args[0]
 47107			v.reset(OpCopy)
 47108			v.Type = x.Type
 47109			v.AddArg(x)
 47110			return true
 47111		}
 47112		// match: (Trunc64to8 (SignExt8to64 x))
 47113		// cond:
 47114		// result: x
 47115		for {
 47116			v_0 := v.Args[0]
 47117			if v_0.Op != OpSignExt8to64 {
 47118				break
 47119			}
 47120			x := v_0.Args[0]
 47121			v.reset(OpCopy)
 47122			v.Type = x.Type
 47123			v.AddArg(x)
 47124			return true
 47125		}
 47126		// match: (Trunc64to8 (And64 (Const64 [y]) x))
 47127		// cond: y&0xFF == 0xFF
 47128		// result: (Trunc64to8 x)
 47129		for {
 47130			v_0 := v.Args[0]
 47131			if v_0.Op != OpAnd64 {
 47132				break
 47133			}
 47134			x := v_0.Args[1]
 47135			v_0_0 := v_0.Args[0]
 47136			if v_0_0.Op != OpConst64 {
 47137				break
 47138			}
 47139			y := v_0_0.AuxInt
 47140			if !(y&0xFF == 0xFF) {
 47141				break
 47142			}
 47143			v.reset(OpTrunc64to8)
 47144			v.AddArg(x)
 47145			return true
 47146		}
 47147		// match: (Trunc64to8 (And64 x (Const64 [y])))
 47148		// cond: y&0xFF == 0xFF
 47149		// result: (Trunc64to8 x)
 47150		for {
 47151			v_0 := v.Args[0]
 47152			if v_0.Op != OpAnd64 {
 47153				break
 47154			}
 47155			_ = v_0.Args[1]
 47156			x := v_0.Args[0]
 47157			v_0_1 := v_0.Args[1]
 47158			if v_0_1.Op != OpConst64 {
 47159				break
 47160			}
 47161			y := v_0_1.AuxInt
 47162			if !(y&0xFF == 0xFF) {
 47163				break
 47164			}
 47165			v.reset(OpTrunc64to8)
 47166			v.AddArg(x)
 47167			return true
 47168		}
 47169		return false
 47170	}
 47171	func rewriteValuegeneric_OpXor16_0(v *Value) bool {
 47172		b := v.Block
 47173		// match: (Xor16 (Const16 [c]) (Const16 [d]))
 47174		// cond:
 47175		// result: (Const16 [int64(int16(c^d))])
 47176		for {
 47177			_ = v.Args[1]
 47178			v_0 := v.Args[0]
 47179			if v_0.Op != OpConst16 {
 47180				break
 47181			}
 47182			c := v_0.AuxInt
 47183			v_1 := v.Args[1]
 47184			if v_1.Op != OpConst16 {
 47185				break
 47186			}
 47187			d := v_1.AuxInt
 47188			v.reset(OpConst16)
 47189			v.AuxInt = int64(int16(c ^ d))
 47190			return true
 47191		}
 47192		// match: (Xor16 (Const16 [d]) (Const16 [c]))
 47193		// cond:
 47194		// result: (Const16 [int64(int16(c^d))])
 47195		for {
 47196			_ = v.Args[1]
 47197			v_0 := v.Args[0]
 47198			if v_0.Op != OpConst16 {
 47199				break
 47200			}
 47201			d := v_0.AuxInt
 47202			v_1 := v.Args[1]
 47203			if v_1.Op != OpConst16 {
 47204				break
 47205			}
 47206			c := v_1.AuxInt
 47207			v.reset(OpConst16)
 47208			v.AuxInt = int64(int16(c ^ d))
 47209			return true
 47210		}
 47211		// match: (Xor16 x x)
 47212		// cond:
 47213		// result: (Const16 [0])
 47214		for {
 47215			x := v.Args[1]
 47216			if x != v.Args[0] {
 47217				break
 47218			}
 47219			v.reset(OpConst16)
 47220			v.AuxInt = 0
 47221			return true
 47222		}
 47223		// match: (Xor16 (Const16 [0]) x)
 47224		// cond:
 47225		// result: x
 47226		for {
 47227			x := v.Args[1]
 47228			v_0 := v.Args[0]
 47229			if v_0.Op != OpConst16 {
 47230				break
 47231			}
 47232			if v_0.AuxInt != 0 {
 47233				break
 47234			}
 47235			v.reset(OpCopy)
 47236			v.Type = x.Type
 47237			v.AddArg(x)
 47238			return true
 47239		}
 47240		// match: (Xor16 x (Const16 [0]))
 47241		// cond:
 47242		// result: x
 47243		for {
 47244			_ = v.Args[1]
 47245			x := v.Args[0]
 47246			v_1 := v.Args[1]
 47247			if v_1.Op != OpConst16 {
 47248				break
 47249			}
 47250			if v_1.AuxInt != 0 {
 47251				break
 47252			}
 47253			v.reset(OpCopy)
 47254			v.Type = x.Type
 47255			v.AddArg(x)
 47256			return true
 47257		}
 47258		// match: (Xor16 x (Xor16 x y))
 47259		// cond:
 47260		// result: y
 47261		for {
 47262			_ = v.Args[1]
 47263			x := v.Args[0]
 47264			v_1 := v.Args[1]
 47265			if v_1.Op != OpXor16 {
 47266				break
 47267			}
 47268			y := v_1.Args[1]
 47269			if x != v_1.Args[0] {
 47270				break
 47271			}
 47272			v.reset(OpCopy)
 47273			v.Type = y.Type
 47274			v.AddArg(y)
 47275			return true
 47276		}
 47277		// match: (Xor16 x (Xor16 y x))
 47278		// cond:
 47279		// result: y
 47280		for {
 47281			_ = v.Args[1]
 47282			x := v.Args[0]
 47283			v_1 := v.Args[1]
 47284			if v_1.Op != OpXor16 {
 47285				break
 47286			}
 47287			_ = v_1.Args[1]
 47288			y := v_1.Args[0]
 47289			if x != v_1.Args[1] {
 47290				break
 47291			}
 47292			v.reset(OpCopy)
 47293			v.Type = y.Type
 47294			v.AddArg(y)
 47295			return true
 47296		}
 47297		// match: (Xor16 (Xor16 x y) x)
 47298		// cond:
 47299		// result: y
 47300		for {
 47301			x := v.Args[1]
 47302			v_0 := v.Args[0]
 47303			if v_0.Op != OpXor16 {
 47304				break
 47305			}
 47306			y := v_0.Args[1]
 47307			if x != v_0.Args[0] {
 47308				break
 47309			}
 47310			v.reset(OpCopy)
 47311			v.Type = y.Type
 47312			v.AddArg(y)
 47313			return true
 47314		}
 47315		// match: (Xor16 (Xor16 y x) x)
 47316		// cond:
 47317		// result: y
 47318		for {
 47319			x := v.Args[1]
 47320			v_0 := v.Args[0]
 47321			if v_0.Op != OpXor16 {
 47322				break
 47323			}
 47324			_ = v_0.Args[1]
 47325			y := v_0.Args[0]
 47326			if x != v_0.Args[1] {
 47327				break
 47328			}
 47329			v.reset(OpCopy)
 47330			v.Type = y.Type
 47331			v.AddArg(y)
 47332			return true
 47333		}
 47334		// match: (Xor16 (Xor16 i:(Const16 <t>) z) x)
 47335		// cond: (z.Op != OpConst16 && x.Op != OpConst16)
 47336		// result: (Xor16 i (Xor16 <t> z x))
 47337		for {
 47338			x := v.Args[1]
 47339			v_0 := v.Args[0]
 47340			if v_0.Op != OpXor16 {
 47341				break
 47342			}
 47343			z := v_0.Args[1]
 47344			i := v_0.Args[0]
 47345			if i.Op != OpConst16 {
 47346				break
 47347			}
 47348			t := i.Type
 47349			if !(z.Op != OpConst16 && x.Op != OpConst16) {
 47350				break
 47351			}
 47352			v.reset(OpXor16)
 47353			v.AddArg(i)
 47354			v0 := b.NewValue0(v.Pos, OpXor16, t)
 47355			v0.AddArg(z)
 47356			v0.AddArg(x)
 47357			v.AddArg(v0)
 47358			return true
 47359		}
 47360		return false
 47361	}
 47362	func rewriteValuegeneric_OpXor16_10(v *Value) bool {
 47363		b := v.Block
 47364		// match: (Xor16 (Xor16 z i:(Const16 <t>)) x)
 47365		// cond: (z.Op != OpConst16 && x.Op != OpConst16)
 47366		// result: (Xor16 i (Xor16 <t> z x))
 47367		for {
 47368			x := v.Args[1]
 47369			v_0 := v.Args[0]
 47370			if v_0.Op != OpXor16 {
 47371				break
 47372			}
 47373			_ = v_0.Args[1]
 47374			z := v_0.Args[0]
 47375			i := v_0.Args[1]
 47376			if i.Op != OpConst16 {
 47377				break
 47378			}
 47379			t := i.Type
 47380			if !(z.Op != OpConst16 && x.Op != OpConst16) {
 47381				break
 47382			}
 47383			v.reset(OpXor16)
 47384			v.AddArg(i)
 47385			v0 := b.NewValue0(v.Pos, OpXor16, t)
 47386			v0.AddArg(z)
 47387			v0.AddArg(x)
 47388			v.AddArg(v0)
 47389			return true
 47390		}
 47391		// match: (Xor16 x (Xor16 i:(Const16 <t>) z))
 47392		// cond: (z.Op != OpConst16 && x.Op != OpConst16)
 47393		// result: (Xor16 i (Xor16 <t> z x))
 47394		for {
 47395			_ = v.Args[1]
 47396			x := v.Args[0]
 47397			v_1 := v.Args[1]
 47398			if v_1.Op != OpXor16 {
 47399				break
 47400			}
 47401			z := v_1.Args[1]
 47402			i := v_1.Args[0]
 47403			if i.Op != OpConst16 {
 47404				break
 47405			}
 47406			t := i.Type
 47407			if !(z.Op != OpConst16 && x.Op != OpConst16) {
 47408				break
 47409			}
 47410			v.reset(OpXor16)
 47411			v.AddArg(i)
 47412			v0 := b.NewValue0(v.Pos, OpXor16, t)
 47413			v0.AddArg(z)
 47414			v0.AddArg(x)
 47415			v.AddArg(v0)
 47416			return true
 47417		}
 47418		// match: (Xor16 x (Xor16 z i:(Const16 <t>)))
 47419		// cond: (z.Op != OpConst16 && x.Op != OpConst16)
 47420		// result: (Xor16 i (Xor16 <t> z x))
 47421		for {
 47422			_ = v.Args[1]
 47423			x := v.Args[0]
 47424			v_1 := v.Args[1]
 47425			if v_1.Op != OpXor16 {
 47426				break
 47427			}
 47428			_ = v_1.Args[1]
 47429			z := v_1.Args[0]
 47430			i := v_1.Args[1]
 47431			if i.Op != OpConst16 {
 47432				break
 47433			}
 47434			t := i.Type
 47435			if !(z.Op != OpConst16 && x.Op != OpConst16) {
 47436				break
 47437			}
 47438			v.reset(OpXor16)
 47439			v.AddArg(i)
 47440			v0 := b.NewValue0(v.Pos, OpXor16, t)
 47441			v0.AddArg(z)
 47442			v0.AddArg(x)
 47443			v.AddArg(v0)
 47444			return true
 47445		}
 47446		// match: (Xor16 (Const16 <t> [c]) (Xor16 (Const16 <t> [d]) x))
 47447		// cond:
 47448		// result: (Xor16 (Const16 <t> [int64(int16(c^d))]) x)
 47449		for {
 47450			_ = v.Args[1]
 47451			v_0 := v.Args[0]
 47452			if v_0.Op != OpConst16 {
 47453				break
 47454			}
 47455			t := v_0.Type
 47456			c := v_0.AuxInt
 47457			v_1 := v.Args[1]
 47458			if v_1.Op != OpXor16 {
 47459				break
 47460			}
 47461			x := v_1.Args[1]
 47462			v_1_0 := v_1.Args[0]
 47463			if v_1_0.Op != OpConst16 {
 47464				break
 47465			}
 47466			if v_1_0.Type != t {
 47467				break
 47468			}
 47469			d := v_1_0.AuxInt
 47470			v.reset(OpXor16)
 47471			v0 := b.NewValue0(v.Pos, OpConst16, t)
 47472			v0.AuxInt = int64(int16(c ^ d))
 47473			v.AddArg(v0)
 47474			v.AddArg(x)
 47475			return true
 47476		}
 47477		// match: (Xor16 (Const16 <t> [c]) (Xor16 x (Const16 <t> [d])))
 47478		// cond:
 47479		// result: (Xor16 (Const16 <t> [int64(int16(c^d))]) x)
 47480		for {
 47481			_ = v.Args[1]
 47482			v_0 := v.Args[0]
 47483			if v_0.Op != OpConst16 {
 47484				break
 47485			}
 47486			t := v_0.Type
 47487			c := v_0.AuxInt
 47488			v_1 := v.Args[1]
 47489			if v_1.Op != OpXor16 {
 47490				break
 47491			}
 47492			_ = v_1.Args[1]
 47493			x := v_1.Args[0]
 47494			v_1_1 := v_1.Args[1]
 47495			if v_1_1.Op != OpConst16 {
 47496				break
 47497			}
 47498			if v_1_1.Type != t {
 47499				break
 47500			}
 47501			d := v_1_1.AuxInt
 47502			v.reset(OpXor16)
 47503			v0 := b.NewValue0(v.Pos, OpConst16, t)
 47504			v0.AuxInt = int64(int16(c ^ d))
 47505			v.AddArg(v0)
 47506			v.AddArg(x)
 47507			return true
 47508		}
 47509		// match: (Xor16 (Xor16 (Const16 <t> [d]) x) (Const16 <t> [c]))
 47510		// cond:
 47511		// result: (Xor16 (Const16 <t> [int64(int16(c^d))]) x)
 47512		for {
 47513			_ = v.Args[1]
 47514			v_0 := v.Args[0]
 47515			if v_0.Op != OpXor16 {
 47516				break
 47517			}
 47518			x := v_0.Args[1]
 47519			v_0_0 := v_0.Args[0]
 47520			if v_0_0.Op != OpConst16 {
 47521				break
 47522			}
 47523			t := v_0_0.Type
 47524			d := v_0_0.AuxInt
 47525			v_1 := v.Args[1]
 47526			if v_1.Op != OpConst16 {
 47527				break
 47528			}
 47529			if v_1.Type != t {
 47530				break
 47531			}
 47532			c := v_1.AuxInt
 47533			v.reset(OpXor16)
 47534			v0 := b.NewValue0(v.Pos, OpConst16, t)
 47535			v0.AuxInt = int64(int16(c ^ d))
 47536			v.AddArg(v0)
 47537			v.AddArg(x)
 47538			return true
 47539		}
 47540		// match: (Xor16 (Xor16 x (Const16 <t> [d])) (Const16 <t> [c]))
 47541		// cond:
 47542		// result: (Xor16 (Const16 <t> [int64(int16(c^d))]) x)
 47543		for {
 47544			_ = v.Args[1]
 47545			v_0 := v.Args[0]
 47546			if v_0.Op != OpXor16 {
 47547				break
 47548			}
 47549			_ = v_0.Args[1]
 47550			x := v_0.Args[0]
 47551			v_0_1 := v_0.Args[1]
 47552			if v_0_1.Op != OpConst16 {
 47553				break
 47554			}
 47555			t := v_0_1.Type
 47556			d := v_0_1.AuxInt
 47557			v_1 := v.Args[1]
 47558			if v_1.Op != OpConst16 {
 47559				break
 47560			}
 47561			if v_1.Type != t {
 47562				break
 47563			}
 47564			c := v_1.AuxInt
 47565			v.reset(OpXor16)
 47566			v0 := b.NewValue0(v.Pos, OpConst16, t)
 47567			v0.AuxInt = int64(int16(c ^ d))
 47568			v.AddArg(v0)
 47569			v.AddArg(x)
 47570			return true
 47571		}
 47572		return false
 47573	}
 47574	func rewriteValuegeneric_OpXor32_0(v *Value) bool {
 47575		b := v.Block
 47576		// match: (Xor32 (Const32 [c]) (Const32 [d]))
 47577		// cond:
 47578		// result: (Const32 [int64(int32(c^d))])
 47579		for {
 47580			_ = v.Args[1]
 47581			v_0 := v.Args[0]
 47582			if v_0.Op != OpConst32 {
 47583				break
 47584			}
 47585			c := v_0.AuxInt
 47586			v_1 := v.Args[1]
 47587			if v_1.Op != OpConst32 {
 47588				break
 47589			}
 47590			d := v_1.AuxInt
 47591			v.reset(OpConst32)
 47592			v.AuxInt = int64(int32(c ^ d))
 47593			return true
 47594		}
 47595		// match: (Xor32 (Const32 [d]) (Const32 [c]))
 47596		// cond:
 47597		// result: (Const32 [int64(int32(c^d))])
 47598		for {
 47599			_ = v.Args[1]
 47600			v_0 := v.Args[0]
 47601			if v_0.Op != OpConst32 {
 47602				break
 47603			}
 47604			d := v_0.AuxInt
 47605			v_1 := v.Args[1]
 47606			if v_1.Op != OpConst32 {
 47607				break
 47608			}
 47609			c := v_1.AuxInt
 47610			v.reset(OpConst32)
 47611			v.AuxInt = int64(int32(c ^ d))
 47612			return true
 47613		}
 47614		// match: (Xor32 x x)
 47615		// cond:
 47616		// result: (Const32 [0])
 47617		for {
 47618			x := v.Args[1]
 47619			if x != v.Args[0] {
 47620				break
 47621			}
 47622			v.reset(OpConst32)
 47623			v.AuxInt = 0
 47624			return true
 47625		}
 47626		// match: (Xor32 (Const32 [0]) x)
 47627		// cond:
 47628		// result: x
 47629		for {
 47630			x := v.Args[1]
 47631			v_0 := v.Args[0]
 47632			if v_0.Op != OpConst32 {
 47633				break
 47634			}
 47635			if v_0.AuxInt != 0 {
 47636				break
 47637			}
 47638			v.reset(OpCopy)
 47639			v.Type = x.Type
 47640			v.AddArg(x)
 47641			return true
 47642		}
 47643		// match: (Xor32 x (Const32 [0]))
 47644		// cond:
 47645		// result: x
 47646		for {
 47647			_ = v.Args[1]
 47648			x := v.Args[0]
 47649			v_1 := v.Args[1]
 47650			if v_1.Op != OpConst32 {
 47651				break
 47652			}
 47653			if v_1.AuxInt != 0 {
 47654				break
 47655			}
 47656			v.reset(OpCopy)
 47657			v.Type = x.Type
 47658			v.AddArg(x)
 47659			return true
 47660		}
 47661		// match: (Xor32 x (Xor32 x y))
 47662		// cond:
 47663		// result: y
 47664		for {
 47665			_ = v.Args[1]
 47666			x := v.Args[0]
 47667			v_1 := v.Args[1]
 47668			if v_1.Op != OpXor32 {
 47669				break
 47670			}
 47671			y := v_1.Args[1]
 47672			if x != v_1.Args[0] {
 47673				break
 47674			}
 47675			v.reset(OpCopy)
 47676			v.Type = y.Type
 47677			v.AddArg(y)
 47678			return true
 47679		}
 47680		// match: (Xor32 x (Xor32 y x))
 47681		// cond:
 47682		// result: y
 47683		for {
 47684			_ = v.Args[1]
 47685			x := v.Args[0]
 47686			v_1 := v.Args[1]
 47687			if v_1.Op != OpXor32 {
 47688				break
 47689			}
 47690			_ = v_1.Args[1]
 47691			y := v_1.Args[0]
 47692			if x != v_1.Args[1] {
 47693				break
 47694			}
 47695			v.reset(OpCopy)
 47696			v.Type = y.Type
 47697			v.AddArg(y)
 47698			return true
 47699		}
 47700		// match: (Xor32 (Xor32 x y) x)
 47701		// cond:
 47702		// result: y
 47703		for {
 47704			x := v.Args[1]
 47705			v_0 := v.Args[0]
 47706			if v_0.Op != OpXor32 {
 47707				break
 47708			}
 47709			y := v_0.Args[1]
 47710			if x != v_0.Args[0] {
 47711				break
 47712			}
 47713			v.reset(OpCopy)
 47714			v.Type = y.Type
 47715			v.AddArg(y)
 47716			return true
 47717		}
 47718		// match: (Xor32 (Xor32 y x) x)
 47719		// cond:
 47720		// result: y
 47721		for {
 47722			x := v.Args[1]
 47723			v_0 := v.Args[0]
 47724			if v_0.Op != OpXor32 {
 47725				break
 47726			}
 47727			_ = v_0.Args[1]
 47728			y := v_0.Args[0]
 47729			if x != v_0.Args[1] {
 47730				break
 47731			}
 47732			v.reset(OpCopy)
 47733			v.Type = y.Type
 47734			v.AddArg(y)
 47735			return true
 47736		}
 47737		// match: (Xor32 (Xor32 i:(Const32 <t>) z) x)
 47738		// cond: (z.Op != OpConst32 && x.Op != OpConst32)
 47739		// result: (Xor32 i (Xor32 <t> z x))
 47740		for {
 47741			x := v.Args[1]
 47742			v_0 := v.Args[0]
 47743			if v_0.Op != OpXor32 {
 47744				break
 47745			}
 47746			z := v_0.Args[1]
 47747			i := v_0.Args[0]
 47748			if i.Op != OpConst32 {
 47749				break
 47750			}
 47751			t := i.Type
 47752			if !(z.Op != OpConst32 && x.Op != OpConst32) {
 47753				break
 47754			}
 47755			v.reset(OpXor32)
 47756			v.AddArg(i)
 47757			v0 := b.NewValue0(v.Pos, OpXor32, t)
 47758			v0.AddArg(z)
 47759			v0.AddArg(x)
 47760			v.AddArg(v0)
 47761			return true
 47762		}
 47763		return false
 47764	}
 47765	func rewriteValuegeneric_OpXor32_10(v *Value) bool {
 47766		b := v.Block
 47767		// match: (Xor32 (Xor32 z i:(Const32 <t>)) x)
 47768		// cond: (z.Op != OpConst32 && x.Op != OpConst32)
 47769		// result: (Xor32 i (Xor32 <t> z x))
 47770		for {
 47771			x := v.Args[1]
 47772			v_0 := v.Args[0]
 47773			if v_0.Op != OpXor32 {
 47774				break
 47775			}
 47776			_ = v_0.Args[1]
 47777			z := v_0.Args[0]
 47778			i := v_0.Args[1]
 47779			if i.Op != OpConst32 {
 47780				break
 47781			}
 47782			t := i.Type
 47783			if !(z.Op != OpConst32 && x.Op != OpConst32) {
 47784				break
 47785			}
 47786			v.reset(OpXor32)
 47787			v.AddArg(i)
 47788			v0 := b.NewValue0(v.Pos, OpXor32, t)
 47789			v0.AddArg(z)
 47790			v0.AddArg(x)
 47791			v.AddArg(v0)
 47792			return true
 47793		}
 47794		// match: (Xor32 x (Xor32 i:(Const32 <t>) z))
 47795		// cond: (z.Op != OpConst32 && x.Op != OpConst32)
 47796		// result: (Xor32 i (Xor32 <t> z x))
 47797		for {
 47798			_ = v.Args[1]
 47799			x := v.Args[0]
 47800			v_1 := v.Args[1]
 47801			if v_1.Op != OpXor32 {
 47802				break
 47803			}
 47804			z := v_1.Args[1]
 47805			i := v_1.Args[0]
 47806			if i.Op != OpConst32 {
 47807				break
 47808			}
 47809			t := i.Type
 47810			if !(z.Op != OpConst32 && x.Op != OpConst32) {
 47811				break
 47812			}
 47813			v.reset(OpXor32)
 47814			v.AddArg(i)
 47815			v0 := b.NewValue0(v.Pos, OpXor32, t)
 47816			v0.AddArg(z)
 47817			v0.AddArg(x)
 47818			v.AddArg(v0)
 47819			return true
 47820		}
 47821		// match: (Xor32 x (Xor32 z i:(Const32 <t>)))
 47822		// cond: (z.Op != OpConst32 && x.Op != OpConst32)
 47823		// result: (Xor32 i (Xor32 <t> z x))
 47824		for {
 47825			_ = v.Args[1]
 47826			x := v.Args[0]
 47827			v_1 := v.Args[1]
 47828			if v_1.Op != OpXor32 {
 47829				break
 47830			}
 47831			_ = v_1.Args[1]
 47832			z := v_1.Args[0]
 47833			i := v_1.Args[1]
 47834			if i.Op != OpConst32 {
 47835				break
 47836			}
 47837			t := i.Type
 47838			if !(z.Op != OpConst32 && x.Op != OpConst32) {
 47839				break
 47840			}
 47841			v.reset(OpXor32)
 47842			v.AddArg(i)
 47843			v0 := b.NewValue0(v.Pos, OpXor32, t)
 47844			v0.AddArg(z)
 47845			v0.AddArg(x)
 47846			v.AddArg(v0)
 47847			return true
 47848		}
 47849		// match: (Xor32 (Const32 <t> [c]) (Xor32 (Const32 <t> [d]) x))
 47850		// cond:
 47851		// result: (Xor32 (Const32 <t> [int64(int32(c^d))]) x)
 47852		for {
 47853			_ = v.Args[1]
 47854			v_0 := v.Args[0]
 47855			if v_0.Op != OpConst32 {
 47856				break
 47857			}
 47858			t := v_0.Type
 47859			c := v_0.AuxInt
 47860			v_1 := v.Args[1]
 47861			if v_1.Op != OpXor32 {
 47862				break
 47863			}
 47864			x := v_1.Args[1]
 47865			v_1_0 := v_1.Args[0]
 47866			if v_1_0.Op != OpConst32 {
 47867				break
 47868			}
 47869			if v_1_0.Type != t {
 47870				break
 47871			}
 47872			d := v_1_0.AuxInt
 47873			v.reset(OpXor32)
 47874			v0 := b.NewValue0(v.Pos, OpConst32, t)
 47875			v0.AuxInt = int64(int32(c ^ d))
 47876			v.AddArg(v0)
 47877			v.AddArg(x)
 47878			return true
 47879		}
 47880		// match: (Xor32 (Const32 <t> [c]) (Xor32 x (Const32 <t> [d])))
 47881		// cond:
 47882		// result: (Xor32 (Const32 <t> [int64(int32(c^d))]) x)
 47883		for {
 47884			_ = v.Args[1]
 47885			v_0 := v.Args[0]
 47886			if v_0.Op != OpConst32 {
 47887				break
 47888			}
 47889			t := v_0.Type
 47890			c := v_0.AuxInt
 47891			v_1 := v.Args[1]
 47892			if v_1.Op != OpXor32 {
 47893				break
 47894			}
 47895			_ = v_1.Args[1]
 47896			x := v_1.Args[0]
 47897			v_1_1 := v_1.Args[1]
 47898			if v_1_1.Op != OpConst32 {
 47899				break
 47900			}
 47901			if v_1_1.Type != t {
 47902				break
 47903			}
 47904			d := v_1_1.AuxInt
 47905			v.reset(OpXor32)
 47906			v0 := b.NewValue0(v.Pos, OpConst32, t)
 47907			v0.AuxInt = int64(int32(c ^ d))
 47908			v.AddArg(v0)
 47909			v.AddArg(x)
 47910			return true
 47911		}
 47912		// match: (Xor32 (Xor32 (Const32 <t> [d]) x) (Const32 <t> [c]))
 47913		// cond:
 47914		// result: (Xor32 (Const32 <t> [int64(int32(c^d))]) x)
 47915		for {
 47916			_ = v.Args[1]
 47917			v_0 := v.Args[0]
 47918			if v_0.Op != OpXor32 {
 47919				break
 47920			}
 47921			x := v_0.Args[1]
 47922			v_0_0 := v_0.Args[0]
 47923			if v_0_0.Op != OpConst32 {
 47924				break
 47925			}
 47926			t := v_0_0.Type
 47927			d := v_0_0.AuxInt
 47928			v_1 := v.Args[1]
 47929			if v_1.Op != OpConst32 {
 47930				break
 47931			}
 47932			if v_1.Type != t {
 47933				break
 47934			}
 47935			c := v_1.AuxInt
 47936			v.reset(OpXor32)
 47937			v0 := b.NewValue0(v.Pos, OpConst32, t)
 47938			v0.AuxInt = int64(int32(c ^ d))
 47939			v.AddArg(v0)
 47940			v.AddArg(x)
 47941			return true
 47942		}
 47943		// match: (Xor32 (Xor32 x (Const32 <t> [d])) (Const32 <t> [c]))
 47944		// cond:
 47945		// result: (Xor32 (Const32 <t> [int64(int32(c^d))]) x)
 47946		for {
 47947			_ = v.Args[1]
 47948			v_0 := v.Args[0]
 47949			if v_0.Op != OpXor32 {
 47950				break
 47951			}
 47952			_ = v_0.Args[1]
 47953			x := v_0.Args[0]
 47954			v_0_1 := v_0.Args[1]
 47955			if v_0_1.Op != OpConst32 {
 47956				break
 47957			}
 47958			t := v_0_1.Type
 47959			d := v_0_1.AuxInt
 47960			v_1 := v.Args[1]
 47961			if v_1.Op != OpConst32 {
 47962				break
 47963			}
 47964			if v_1.Type != t {
 47965				break
 47966			}
 47967			c := v_1.AuxInt
 47968			v.reset(OpXor32)
 47969			v0 := b.NewValue0(v.Pos, OpConst32, t)
 47970			v0.AuxInt = int64(int32(c ^ d))
 47971			v.AddArg(v0)
 47972			v.AddArg(x)
 47973			return true
 47974		}
 47975		return false
 47976	}
 47977	func rewriteValuegeneric_OpXor64_0(v *Value) bool {
 47978		b := v.Block
 47979		// match: (Xor64 (Const64 [c]) (Const64 [d]))
 47980		// cond:
 47981		// result: (Const64 [c^d])
 47982		for {
 47983			_ = v.Args[1]
 47984			v_0 := v.Args[0]
 47985			if v_0.Op != OpConst64 {
 47986				break
 47987			}
 47988			c := v_0.AuxInt
 47989			v_1 := v.Args[1]
 47990			if v_1.Op != OpConst64 {
 47991				break
 47992			}
 47993			d := v_1.AuxInt
 47994			v.reset(OpConst64)
 47995			v.AuxInt = c ^ d
 47996			return true
 47997		}
 47998		// match: (Xor64 (Const64 [d]) (Const64 [c]))
 47999		// cond:
 48000		// result: (Const64 [c^d])
 48001		for {
 48002			_ = v.Args[1]
 48003			v_0 := v.Args[0]
 48004			if v_0.Op != OpConst64 {
 48005				break
 48006			}
 48007			d := v_0.AuxInt
 48008			v_1 := v.Args[1]
 48009			if v_1.Op != OpConst64 {
 48010				break
 48011			}
 48012			c := v_1.AuxInt
 48013			v.reset(OpConst64)
 48014			v.AuxInt = c ^ d
 48015			return true
 48016		}
 48017		// match: (Xor64 x x)
 48018		// cond:
 48019		// result: (Const64 [0])
 48020		for {
 48021			x := v.Args[1]
 48022			if x != v.Args[0] {
 48023				break
 48024			}
 48025			v.reset(OpConst64)
 48026			v.AuxInt = 0
 48027			return true
 48028		}
 48029		// match: (Xor64 (Const64 [0]) x)
 48030		// cond:
 48031		// result: x
 48032		for {
 48033			x := v.Args[1]
 48034			v_0 := v.Args[0]
 48035			if v_0.Op != OpConst64 {
 48036				break
 48037			}
 48038			if v_0.AuxInt != 0 {
 48039				break
 48040			}
 48041			v.reset(OpCopy)
 48042			v.Type = x.Type
 48043			v.AddArg(x)
 48044			return true
 48045		}
 48046		// match: (Xor64 x (Const64 [0]))
 48047		// cond:
 48048		// result: x
 48049		for {
 48050			_ = v.Args[1]
 48051			x := v.Args[0]
 48052			v_1 := v.Args[1]
 48053			if v_1.Op != OpConst64 {
 48054				break
 48055			}
 48056			if v_1.AuxInt != 0 {
 48057				break
 48058			}
 48059			v.reset(OpCopy)
 48060			v.Type = x.Type
 48061			v.AddArg(x)
 48062			return true
 48063		}
 48064		// match: (Xor64 x (Xor64 x y))
 48065		// cond:
 48066		// result: y
 48067		for {
 48068			_ = v.Args[1]
 48069			x := v.Args[0]
 48070			v_1 := v.Args[1]
 48071			if v_1.Op != OpXor64 {
 48072				break
 48073			}
 48074			y := v_1.Args[1]
 48075			if x != v_1.Args[0] {
 48076				break
 48077			}
 48078			v.reset(OpCopy)
 48079			v.Type = y.Type
 48080			v.AddArg(y)
 48081			return true
 48082		}
 48083		// match: (Xor64 x (Xor64 y x))
 48084		// cond:
 48085		// result: y
 48086		for {
 48087			_ = v.Args[1]
 48088			x := v.Args[0]
 48089			v_1 := v.Args[1]
 48090			if v_1.Op != OpXor64 {
 48091				break
 48092			}
 48093			_ = v_1.Args[1]
 48094			y := v_1.Args[0]
 48095			if x != v_1.Args[1] {
 48096				break
 48097			}
 48098			v.reset(OpCopy)
 48099			v.Type = y.Type
 48100			v.AddArg(y)
 48101			return true
 48102		}
 48103		// match: (Xor64 (Xor64 x y) x)
 48104		// cond:
 48105		// result: y
 48106		for {
 48107			x := v.Args[1]
 48108			v_0 := v.Args[0]
 48109			if v_0.Op != OpXor64 {
 48110				break
 48111			}
 48112			y := v_0.Args[1]
 48113			if x != v_0.Args[0] {
 48114				break
 48115			}
 48116			v.reset(OpCopy)
 48117			v.Type = y.Type
 48118			v.AddArg(y)
 48119			return true
 48120		}
 48121		// match: (Xor64 (Xor64 y x) x)
 48122		// cond:
 48123		// result: y
 48124		for {
 48125			x := v.Args[1]
 48126			v_0 := v.Args[0]
 48127			if v_0.Op != OpXor64 {
 48128				break
 48129			}
 48130			_ = v_0.Args[1]
 48131			y := v_0.Args[0]
 48132			if x != v_0.Args[1] {
 48133				break
 48134			}
 48135			v.reset(OpCopy)
 48136			v.Type = y.Type
 48137			v.AddArg(y)
 48138			return true
 48139		}
 48140		// match: (Xor64 (Xor64 i:(Const64 <t>) z) x)
 48141		// cond: (z.Op != OpConst64 && x.Op != OpConst64)
 48142		// result: (Xor64 i (Xor64 <t> z x))
 48143		for {
 48144			x := v.Args[1]
 48145			v_0 := v.Args[0]
 48146			if v_0.Op != OpXor64 {
 48147				break
 48148			}
 48149			z := v_0.Args[1]
 48150			i := v_0.Args[0]
 48151			if i.Op != OpConst64 {
 48152				break
 48153			}
 48154			t := i.Type
 48155			if !(z.Op != OpConst64 && x.Op != OpConst64) {
 48156				break
 48157			}
 48158			v.reset(OpXor64)
 48159			v.AddArg(i)
 48160			v0 := b.NewValue0(v.Pos, OpXor64, t)
 48161			v0.AddArg(z)
 48162			v0.AddArg(x)
 48163			v.AddArg(v0)
 48164			return true
 48165		}
 48166		return false
 48167	}
 48168	func rewriteValuegeneric_OpXor64_10(v *Value) bool {
 48169		b := v.Block
 48170		// match: (Xor64 (Xor64 z i:(Const64 <t>)) x)
 48171		// cond: (z.Op != OpConst64 && x.Op != OpConst64)
 48172		// result: (Xor64 i (Xor64 <t> z x))
 48173		for {
 48174			x := v.Args[1]
 48175			v_0 := v.Args[0]
 48176			if v_0.Op != OpXor64 {
 48177				break
 48178			}
 48179			_ = v_0.Args[1]
 48180			z := v_0.Args[0]
 48181			i := v_0.Args[1]
 48182			if i.Op != OpConst64 {
 48183				break
 48184			}
 48185			t := i.Type
 48186			if !(z.Op != OpConst64 && x.Op != OpConst64) {
 48187				break
 48188			}
 48189			v.reset(OpXor64)
 48190			v.AddArg(i)
 48191			v0 := b.NewValue0(v.Pos, OpXor64, t)
 48192			v0.AddArg(z)
 48193			v0.AddArg(x)
 48194			v.AddArg(v0)
 48195			return true
 48196		}
 48197		// match: (Xor64 x (Xor64 i:(Const64 <t>) z))
 48198		// cond: (z.Op != OpConst64 && x.Op != OpConst64)
 48199		// result: (Xor64 i (Xor64 <t> z x))
 48200		for {
 48201			_ = v.Args[1]
 48202			x := v.Args[0]
 48203			v_1 := v.Args[1]
 48204			if v_1.Op != OpXor64 {
 48205				break
 48206			}
 48207			z := v_1.Args[1]
 48208			i := v_1.Args[0]
 48209			if i.Op != OpConst64 {
 48210				break
 48211			}
 48212			t := i.Type
 48213			if !(z.Op != OpConst64 && x.Op != OpConst64) {
 48214				break
 48215			}
 48216			v.reset(OpXor64)
 48217			v.AddArg(i)
 48218			v0 := b.NewValue0(v.Pos, OpXor64, t)
 48219			v0.AddArg(z)
 48220			v0.AddArg(x)
 48221			v.AddArg(v0)
 48222			return true
 48223		}
 48224		// match: (Xor64 x (Xor64 z i:(Const64 <t>)))
 48225		// cond: (z.Op != OpConst64 && x.Op != OpConst64)
 48226		// result: (Xor64 i (Xor64 <t> z x))
 48227		for {
 48228			_ = v.Args[1]
 48229			x := v.Args[0]
 48230			v_1 := v.Args[1]
 48231			if v_1.Op != OpXor64 {
 48232				break
 48233			}
 48234			_ = v_1.Args[1]
 48235			z := v_1.Args[0]
 48236			i := v_1.Args[1]
 48237			if i.Op != OpConst64 {
 48238				break
 48239			}
 48240			t := i.Type
 48241			if !(z.Op != OpConst64 && x.Op != OpConst64) {
 48242				break
 48243			}
 48244			v.reset(OpXor64)
 48245			v.AddArg(i)
 48246			v0 := b.NewValue0(v.Pos, OpXor64, t)
 48247			v0.AddArg(z)
 48248			v0.AddArg(x)
 48249			v.AddArg(v0)
 48250			return true
 48251		}
 48252		// match: (Xor64 (Const64 <t> [c]) (Xor64 (Const64 <t> [d]) x))
 48253		// cond:
 48254		// result: (Xor64 (Const64 <t> [c^d]) x)
 48255		for {
 48256			_ = v.Args[1]
 48257			v_0 := v.Args[0]
 48258			if v_0.Op != OpConst64 {
 48259				break
 48260			}
 48261			t := v_0.Type
 48262			c := v_0.AuxInt
 48263			v_1 := v.Args[1]
 48264			if v_1.Op != OpXor64 {
 48265				break
 48266			}
 48267			x := v_1.Args[1]
 48268			v_1_0 := v_1.Args[0]
 48269			if v_1_0.Op != OpConst64 {
 48270				break
 48271			}
 48272			if v_1_0.Type != t {
 48273				break
 48274			}
 48275			d := v_1_0.AuxInt
 48276			v.reset(OpXor64)
 48277			v0 := b.NewValue0(v.Pos, OpConst64, t)
 48278			v0.AuxInt = c ^ d
 48279			v.AddArg(v0)
 48280			v.AddArg(x)
 48281			return true
 48282		}
 48283		// match: (Xor64 (Const64 <t> [c]) (Xor64 x (Const64 <t> [d])))
 48284		// cond:
 48285		// result: (Xor64 (Const64 <t> [c^d]) x)
 48286		for {
 48287			_ = v.Args[1]
 48288			v_0 := v.Args[0]
 48289			if v_0.Op != OpConst64 {
 48290				break
 48291			}
 48292			t := v_0.Type
 48293			c := v_0.AuxInt
 48294			v_1 := v.Args[1]
 48295			if v_1.Op != OpXor64 {
 48296				break
 48297			}
 48298			_ = v_1.Args[1]
 48299			x := v_1.Args[0]
 48300			v_1_1 := v_1.Args[1]
 48301			if v_1_1.Op != OpConst64 {
 48302				break
 48303			}
 48304			if v_1_1.Type != t {
 48305				break
 48306			}
 48307			d := v_1_1.AuxInt
 48308			v.reset(OpXor64)
 48309			v0 := b.NewValue0(v.Pos, OpConst64, t)
 48310			v0.AuxInt = c ^ d
 48311			v.AddArg(v0)
 48312			v.AddArg(x)
 48313			return true
 48314		}
 48315		// match: (Xor64 (Xor64 (Const64 <t> [d]) x) (Const64 <t> [c]))
 48316		// cond:
 48317		// result: (Xor64 (Const64 <t> [c^d]) x)
 48318		for {
 48319			_ = v.Args[1]
 48320			v_0 := v.Args[0]
 48321			if v_0.Op != OpXor64 {
 48322				break
 48323			}
 48324			x := v_0.Args[1]
 48325			v_0_0 := v_0.Args[0]
 48326			if v_0_0.Op != OpConst64 {
 48327				break
 48328			}
 48329			t := v_0_0.Type
 48330			d := v_0_0.AuxInt
 48331			v_1 := v.Args[1]
 48332			if v_1.Op != OpConst64 {
 48333				break
 48334			}
 48335			if v_1.Type != t {
 48336				break
 48337			}
 48338			c := v_1.AuxInt
 48339			v.reset(OpXor64)
 48340			v0 := b.NewValue0(v.Pos, OpConst64, t)
 48341			v0.AuxInt = c ^ d
 48342			v.AddArg(v0)
 48343			v.AddArg(x)
 48344			return true
 48345		}
 48346		// match: (Xor64 (Xor64 x (Const64 <t> [d])) (Const64 <t> [c]))
 48347		// cond:
 48348		// result: (Xor64 (Const64 <t> [c^d]) x)
 48349		for {
 48350			_ = v.Args[1]
 48351			v_0 := v.Args[0]
 48352			if v_0.Op != OpXor64 {
 48353				break
 48354			}
 48355			_ = v_0.Args[1]
 48356			x := v_0.Args[0]
 48357			v_0_1 := v_0.Args[1]
 48358			if v_0_1.Op != OpConst64 {
 48359				break
 48360			}
 48361			t := v_0_1.Type
 48362			d := v_0_1.AuxInt
 48363			v_1 := v.Args[1]
 48364			if v_1.Op != OpConst64 {
 48365				break
 48366			}
 48367			if v_1.Type != t {
 48368				break
 48369			}
 48370			c := v_1.AuxInt
 48371			v.reset(OpXor64)
 48372			v0 := b.NewValue0(v.Pos, OpConst64, t)
 48373			v0.AuxInt = c ^ d
 48374			v.AddArg(v0)
 48375			v.AddArg(x)
 48376			return true
 48377		}
 48378		return false
 48379	}
 48380	func rewriteValuegeneric_OpXor8_0(v *Value) bool {
 48381		b := v.Block
 48382		// match: (Xor8 (Const8 [c]) (Const8 [d]))
 48383		// cond:
 48384		// result: (Const8 [int64(int8(c^d))])
 48385		for {
 48386			_ = v.Args[1]
 48387			v_0 := v.Args[0]
 48388			if v_0.Op != OpConst8 {
 48389				break
 48390			}
 48391			c := v_0.AuxInt
 48392			v_1 := v.Args[1]
 48393			if v_1.Op != OpConst8 {
 48394				break
 48395			}
 48396			d := v_1.AuxInt
 48397			v.reset(OpConst8)
 48398			v.AuxInt = int64(int8(c ^ d))
 48399			return true
 48400		}
 48401		// match: (Xor8 (Const8 [d]) (Const8 [c]))
 48402		// cond:
 48403		// result: (Const8 [int64(int8(c^d))])
 48404		for {
 48405			_ = v.Args[1]
 48406			v_0 := v.Args[0]
 48407			if v_0.Op != OpConst8 {
 48408				break
 48409			}
 48410			d := v_0.AuxInt
 48411			v_1 := v.Args[1]
 48412			if v_1.Op != OpConst8 {
 48413				break
 48414			}
 48415			c := v_1.AuxInt
 48416			v.reset(OpConst8)
 48417			v.AuxInt = int64(int8(c ^ d))
 48418			return true
 48419		}
 48420		// match: (Xor8 x x)
 48421		// cond:
 48422		// result: (Const8 [0])
 48423		for {
 48424			x := v.Args[1]
 48425			if x != v.Args[0] {
 48426				break
 48427			}
 48428			v.reset(OpConst8)
 48429			v.AuxInt = 0
 48430			return true
 48431		}
 48432		// match: (Xor8 (Const8 [0]) x)
 48433		// cond:
 48434		// result: x
 48435		for {
 48436			x := v.Args[1]
 48437			v_0 := v.Args[0]
 48438			if v_0.Op != OpConst8 {
 48439				break
 48440			}
 48441			if v_0.AuxInt != 0 {
 48442				break
 48443			}
 48444			v.reset(OpCopy)
 48445			v.Type = x.Type
 48446			v.AddArg(x)
 48447			return true
 48448		}
 48449		// match: (Xor8 x (Const8 [0]))
 48450		// cond:
 48451		// result: x
 48452		for {
 48453			_ = v.Args[1]
 48454			x := v.Args[0]
 48455			v_1 := v.Args[1]
 48456			if v_1.Op != OpConst8 {
 48457				break
 48458			}
 48459			if v_1.AuxInt != 0 {
 48460				break
 48461			}
 48462			v.reset(OpCopy)
 48463			v.Type = x.Type
 48464			v.AddArg(x)
 48465			return true
 48466		}
 48467		// match: (Xor8 x (Xor8 x y))
 48468		// cond:
 48469		// result: y
 48470		for {
 48471			_ = v.Args[1]
 48472			x := v.Args[0]
 48473			v_1 := v.Args[1]
 48474			if v_1.Op != OpXor8 {
 48475				break
 48476			}
 48477			y := v_1.Args[1]
 48478			if x != v_1.Args[0] {
 48479				break
 48480			}
 48481			v.reset(OpCopy)
 48482			v.Type = y.Type
 48483			v.AddArg(y)
 48484			return true
 48485		}
 48486		// match: (Xor8 x (Xor8 y x))
 48487		// cond:
 48488		// result: y
 48489		for {
 48490			_ = v.Args[1]
 48491			x := v.Args[0]
 48492			v_1 := v.Args[1]
 48493			if v_1.Op != OpXor8 {
 48494				break
 48495			}
 48496			_ = v_1.Args[1]
 48497			y := v_1.Args[0]
 48498			if x != v_1.Args[1] {
 48499				break
 48500			}
 48501			v.reset(OpCopy)
 48502			v.Type = y.Type
 48503			v.AddArg(y)
 48504			return true
 48505		}
 48506		// match: (Xor8 (Xor8 x y) x)
 48507		// cond:
 48508		// result: y
 48509		for {
 48510			x := v.Args[1]
 48511			v_0 := v.Args[0]
 48512			if v_0.Op != OpXor8 {
 48513				break
 48514			}
 48515			y := v_0.Args[1]
 48516			if x != v_0.Args[0] {
 48517				break
 48518			}
 48519			v.reset(OpCopy)
 48520			v.Type = y.Type
 48521			v.AddArg(y)
 48522			return true
 48523		}
 48524		// match: (Xor8 (Xor8 y x) x)
 48525		// cond:
 48526		// result: y
 48527		for {
 48528			x := v.Args[1]
 48529			v_0 := v.Args[0]
 48530			if v_0.Op != OpXor8 {
 48531				break
 48532			}
 48533			_ = v_0.Args[1]
 48534			y := v_0.Args[0]
 48535			if x != v_0.Args[1] {
 48536				break
 48537			}
 48538			v.reset(OpCopy)
 48539			v.Type = y.Type
 48540			v.AddArg(y)
 48541			return true
 48542		}
 48543		// match: (Xor8 (Xor8 i:(Const8 <t>) z) x)
 48544		// cond: (z.Op != OpConst8 && x.Op != OpConst8)
 48545		// result: (Xor8 i (Xor8 <t> z x))
 48546		for {
 48547			x := v.Args[1]
 48548			v_0 := v.Args[0]
 48549			if v_0.Op != OpXor8 {
 48550				break
 48551			}
 48552			z := v_0.Args[1]
 48553			i := v_0.Args[0]
 48554			if i.Op != OpConst8 {
 48555				break
 48556			}
 48557			t := i.Type
 48558			if !(z.Op != OpConst8 && x.Op != OpConst8) {
 48559				break
 48560			}
 48561			v.reset(OpXor8)
 48562			v.AddArg(i)
 48563			v0 := b.NewValue0(v.Pos, OpXor8, t)
 48564			v0.AddArg(z)
 48565			v0.AddArg(x)
 48566			v.AddArg(v0)
 48567			return true
 48568		}
 48569		return false
 48570	}
 48571	func rewriteValuegeneric_OpXor8_10(v *Value) bool {
 48572		b := v.Block
 48573		// match: (Xor8 (Xor8 z i:(Const8 <t>)) x)
 48574		// cond: (z.Op != OpConst8 && x.Op != OpConst8)
 48575		// result: (Xor8 i (Xor8 <t> z x))
 48576		for {
 48577			x := v.Args[1]
 48578			v_0 := v.Args[0]
 48579			if v_0.Op != OpXor8 {
 48580				break
 48581			}
 48582			_ = v_0.Args[1]
 48583			z := v_0.Args[0]
 48584			i := v_0.Args[1]
 48585			if i.Op != OpConst8 {
 48586				break
 48587			}
 48588			t := i.Type
 48589			if !(z.Op != OpConst8 && x.Op != OpConst8) {
 48590				break
 48591			}
 48592			v.reset(OpXor8)
 48593			v.AddArg(i)
 48594			v0 := b.NewValue0(v.Pos, OpXor8, t)
 48595			v0.AddArg(z)
 48596			v0.AddArg(x)
 48597			v.AddArg(v0)
 48598			return true
 48599		}
 48600		// match: (Xor8 x (Xor8 i:(Const8 <t>) z))
 48601		// cond: (z.Op != OpConst8 && x.Op != OpConst8)
 48602		// result: (Xor8 i (Xor8 <t> z x))
 48603		for {
 48604			_ = v.Args[1]
 48605			x := v.Args[0]
 48606			v_1 := v.Args[1]
 48607			if v_1.Op != OpXor8 {
 48608				break
 48609			}
 48610			z := v_1.Args[1]
 48611			i := v_1.Args[0]
 48612			if i.Op != OpConst8 {
 48613				break
 48614			}
 48615			t := i.Type
 48616			if !(z.Op != OpConst8 && x.Op != OpConst8) {
 48617				break
 48618			}
 48619			v.reset(OpXor8)
 48620			v.AddArg(i)
 48621			v0 := b.NewValue0(v.Pos, OpXor8, t)
 48622			v0.AddArg(z)
 48623			v0.AddArg(x)
 48624			v.AddArg(v0)
 48625			return true
 48626		}
 48627		// match: (Xor8 x (Xor8 z i:(Const8 <t>)))
 48628		// cond: (z.Op != OpConst8 && x.Op != OpConst8)
 48629		// result: (Xor8 i (Xor8 <t> z x))
 48630		for {
 48631			_ = v.Args[1]
 48632			x := v.Args[0]
 48633			v_1 := v.Args[1]
 48634			if v_1.Op != OpXor8 {
 48635				break
 48636			}
 48637			_ = v_1.Args[1]
 48638			z := v_1.Args[0]
 48639			i := v_1.Args[1]
 48640			if i.Op != OpConst8 {
 48641				break
 48642			}
 48643			t := i.Type
 48644			if !(z.Op != OpConst8 && x.Op != OpConst8) {
 48645				break
 48646			}
 48647			v.reset(OpXor8)
 48648			v.AddArg(i)
 48649			v0 := b.NewValue0(v.Pos, OpXor8, t)
 48650			v0.AddArg(z)
 48651			v0.AddArg(x)
 48652			v.AddArg(v0)
 48653			return true
 48654		}
 48655		// match: (Xor8 (Const8 <t> [c]) (Xor8 (Const8 <t> [d]) x))
 48656		// cond:
 48657		// result: (Xor8 (Const8 <t> [int64(int8(c^d))]) x)
 48658		for {
 48659			_ = v.Args[1]
 48660			v_0 := v.Args[0]
 48661			if v_0.Op != OpConst8 {
 48662				break
 48663			}
 48664			t := v_0.Type
 48665			c := v_0.AuxInt
 48666			v_1 := v.Args[1]
 48667			if v_1.Op != OpXor8 {
 48668				break
 48669			}
 48670			x := v_1.Args[1]
 48671			v_1_0 := v_1.Args[0]
 48672			if v_1_0.Op != OpConst8 {
 48673				break
 48674			}
 48675			if v_1_0.Type != t {
 48676				break
 48677			}
 48678			d := v_1_0.AuxInt
 48679			v.reset(OpXor8)
 48680			v0 := b.NewValue0(v.Pos, OpConst8, t)
 48681			v0.AuxInt = int64(int8(c ^ d))
 48682			v.AddArg(v0)
 48683			v.AddArg(x)
 48684			return true
 48685		}
 48686		// match: (Xor8 (Const8 <t> [c]) (Xor8 x (Const8 <t> [d])))
 48687		// cond:
 48688		// result: (Xor8 (Const8 <t> [int64(int8(c^d))]) x)
 48689		for {
 48690			_ = v.Args[1]
 48691			v_0 := v.Args[0]
 48692			if v_0.Op != OpConst8 {
 48693				break
 48694			}
 48695			t := v_0.Type
 48696			c := v_0.AuxInt
 48697			v_1 := v.Args[1]
 48698			if v_1.Op != OpXor8 {
 48699				break
 48700			}
 48701			_ = v_1.Args[1]
 48702			x := v_1.Args[0]
 48703			v_1_1 := v_1.Args[1]
 48704			if v_1_1.Op != OpConst8 {
 48705				break
 48706			}
 48707			if v_1_1.Type != t {
 48708				break
 48709			}
 48710			d := v_1_1.AuxInt
 48711			v.reset(OpXor8)
 48712			v0 := b.NewValue0(v.Pos, OpConst8, t)
 48713			v0.AuxInt = int64(int8(c ^ d))
 48714			v.AddArg(v0)
 48715			v.AddArg(x)
 48716			return true
 48717		}
 48718		// match: (Xor8 (Xor8 (Const8 <t> [d]) x) (Const8 <t> [c]))
 48719		// cond:
 48720		// result: (Xor8 (Const8 <t> [int64(int8(c^d))]) x)
 48721		for {
 48722			_ = v.Args[1]
 48723			v_0 := v.Args[0]
 48724			if v_0.Op != OpXor8 {
 48725				break
 48726			}
 48727			x := v_0.Args[1]
 48728			v_0_0 := v_0.Args[0]
 48729			if v_0_0.Op != OpConst8 {
 48730				break
 48731			}
 48732			t := v_0_0.Type
 48733			d := v_0_0.AuxInt
 48734			v_1 := v.Args[1]
 48735			if v_1.Op != OpConst8 {
 48736				break
 48737			}
 48738			if v_1.Type != t {
 48739				break
 48740			}
 48741			c := v_1.AuxInt
 48742			v.reset(OpXor8)
 48743			v0 := b.NewValue0(v.Pos, OpConst8, t)
 48744			v0.AuxInt = int64(int8(c ^ d))
 48745			v.AddArg(v0)
 48746			v.AddArg(x)
 48747			return true
 48748		}
 48749		// match: (Xor8 (Xor8 x (Const8 <t> [d])) (Const8 <t> [c]))
 48750		// cond:
 48751		// result: (Xor8 (Const8 <t> [int64(int8(c^d))]) x)
 48752		for {
 48753			_ = v.Args[1]
 48754			v_0 := v.Args[0]
 48755			if v_0.Op != OpXor8 {
 48756				break
 48757			}
 48758			_ = v_0.Args[1]
 48759			x := v_0.Args[0]
 48760			v_0_1 := v_0.Args[1]
 48761			if v_0_1.Op != OpConst8 {
 48762				break
 48763			}
 48764			t := v_0_1.Type
 48765			d := v_0_1.AuxInt
 48766			v_1 := v.Args[1]
 48767			if v_1.Op != OpConst8 {
 48768				break
 48769			}
 48770			if v_1.Type != t {
 48771				break
 48772			}
 48773			c := v_1.AuxInt
 48774			v.reset(OpXor8)
 48775			v0 := b.NewValue0(v.Pos, OpConst8, t)
 48776			v0.AuxInt = int64(int8(c ^ d))
 48777			v.AddArg(v0)
 48778			v.AddArg(x)
 48779			return true
 48780		}
 48781		return false
 48782	}
 48783	func rewriteValuegeneric_OpZero_0(v *Value) bool {
 48784		b := v.Block
 48785		config := b.Func.Config
 48786		// match: (Zero (Load (OffPtr [c] (SP)) mem) mem)
 48787		// cond: mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize() + config.RegSize
 48788		// result: mem
 48789		for {
 48790			mem := v.Args[1]
 48791			v_0 := v.Args[0]
 48792			if v_0.Op != OpLoad {
 48793				break
 48794			}
 48795			_ = v_0.Args[1]
 48796			v_0_0 := v_0.Args[0]
 48797			if v_0_0.Op != OpOffPtr {
 48798				break
 48799			}
 48800			c := v_0_0.AuxInt
 48801			v_0_0_0 := v_0_0.Args[0]
 48802			if v_0_0_0.Op != OpSP {
 48803				break
 48804			}
 48805			if mem != v_0.Args[1] {
 48806				break
 48807			}
 48808			if !(mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize()+config.RegSize) {
 48809				break
 48810			}
 48811			v.reset(OpCopy)
 48812			v.Type = mem.Type
 48813			v.AddArg(mem)
 48814			return true
 48815		}
 48816		// match: (Zero {t1} [n] p1 store:(Store {t2} (OffPtr [o2] p2) _ mem))
 48817		// cond: isSamePtr(p1, p2) && store.Uses == 1 && n >= o2 + sizeof(t2) && clobber(store)
 48818		// result: (Zero {t1} [n] p1 mem)
 48819		for {
 48820			n := v.AuxInt
 48821			t1 := v.Aux
 48822			_ = v.Args[1]
 48823			p1 := v.Args[0]
 48824			store := v.Args[1]
 48825			if store.Op != OpStore {
 48826				break
 48827			}
 48828			t2 := store.Aux
 48829			mem := store.Args[2]
 48830			store_0 := store.Args[0]
 48831			if store_0.Op != OpOffPtr {
 48832				break
 48833			}
 48834			o2 := store_0.AuxInt
 48835			p2 := store_0.Args[0]
 48836			if !(isSamePtr(p1, p2) && store.Uses == 1 && n >= o2+sizeof(t2) && clobber(store)) {
 48837				break
 48838			}
 48839			v.reset(OpZero)
 48840			v.AuxInt = n
 48841			v.Aux = t1
 48842			v.AddArg(p1)
 48843			v.AddArg(mem)
 48844			return true
 48845		}
 48846		// match: (Zero {t} [n] dst1 move:(Move {t} [n] dst2 _ mem))
 48847		// cond: move.Uses == 1 && isSamePtr(dst1, dst2) && clobber(move)
 48848		// result: (Zero {t} [n] dst1 mem)
 48849		for {
 48850			n := v.AuxInt
 48851			t := v.Aux
 48852			_ = v.Args[1]
 48853			dst1 := v.Args[0]
 48854			move := v.Args[1]
 48855			if move.Op != OpMove {
 48856				break
 48857			}
 48858			if move.AuxInt != n {
 48859				break
 48860			}
 48861			if move.Aux != t {
 48862				break
 48863			}
 48864			mem := move.Args[2]
 48865			dst2 := move.Args[0]
 48866			if !(move.Uses == 1 && isSamePtr(dst1, dst2) && clobber(move)) {
 48867				break
 48868			}
 48869			v.reset(OpZero)
 48870			v.AuxInt = n
 48871			v.Aux = t
 48872			v.AddArg(dst1)
 48873			v.AddArg(mem)
 48874			return true
 48875		}
 48876		// match: (Zero {t} [n] dst1 vardef:(VarDef {x} move:(Move {t} [n] dst2 _ mem)))
 48877		// cond: move.Uses == 1 && vardef.Uses == 1 && isSamePtr(dst1, dst2) && clobber(move) && clobber(vardef)
 48878		// result: (Zero {t} [n] dst1 (VarDef {x} mem))
 48879		for {
 48880			n := v.AuxInt
 48881			t := v.Aux
 48882			_ = v.Args[1]
 48883			dst1 := v.Args[0]
 48884			vardef := v.Args[1]
 48885			if vardef.Op != OpVarDef {
 48886				break
 48887			}
 48888			x := vardef.Aux
 48889			move := vardef.Args[0]
 48890			if move.Op != OpMove {
 48891				break
 48892			}
 48893			if move.AuxInt != n {
 48894				break
 48895			}
 48896			if move.Aux != t {
 48897				break
 48898			}
 48899			mem := move.Args[2]
 48900			dst2 := move.Args[0]
 48901			if !(move.Uses == 1 && vardef.Uses == 1 && isSamePtr(dst1, dst2) && clobber(move) && clobber(vardef)) {
 48902				break
 48903			}
 48904			v.reset(OpZero)
 48905			v.AuxInt = n
 48906			v.Aux = t
 48907			v.AddArg(dst1)
 48908			v0 := b.NewValue0(v.Pos, OpVarDef, types.TypeMem)
 48909			v0.Aux = x
 48910			v0.AddArg(mem)
 48911			v.AddArg(v0)
 48912			return true
 48913		}
 48914		return false
 48915	}
 48916	func rewriteValuegeneric_OpZeroExt16to32_0(v *Value) bool {
 48917		// match: (ZeroExt16to32 (Const16 [c]))
 48918		// cond:
 48919		// result: (Const32 [int64(uint16(c))])
 48920		for {
 48921			v_0 := v.Args[0]
 48922			if v_0.Op != OpConst16 {
 48923				break
 48924			}
 48925			c := v_0.AuxInt
 48926			v.reset(OpConst32)
 48927			v.AuxInt = int64(uint16(c))
 48928			return true
 48929		}
 48930		// match: (ZeroExt16to32 (Trunc32to16 x:(Rsh32Ux64 _ (Const64 [s]))))
 48931		// cond: s >= 16
 48932		// result: x
 48933		for {
 48934			v_0 := v.Args[0]
 48935			if v_0.Op != OpTrunc32to16 {
 48936				break
 48937			}
 48938			x := v_0.Args[0]
 48939			if x.Op != OpRsh32Ux64 {
 48940				break
 48941			}
 48942			_ = x.Args[1]
 48943			x_1 := x.Args[1]
 48944			if x_1.Op != OpConst64 {
 48945				break
 48946			}
 48947			s := x_1.AuxInt
 48948			if !(s >= 16) {
 48949				break
 48950			}
 48951			v.reset(OpCopy)
 48952			v.Type = x.Type
 48953			v.AddArg(x)
 48954			return true
 48955		}
 48956		return false
 48957	}
 48958	func rewriteValuegeneric_OpZeroExt16to64_0(v *Value) bool {
 48959		// match: (ZeroExt16to64 (Const16 [c]))
 48960		// cond:
 48961		// result: (Const64 [int64(uint16(c))])
 48962		for {
 48963			v_0 := v.Args[0]
 48964			if v_0.Op != OpConst16 {
 48965				break
 48966			}
 48967			c := v_0.AuxInt
 48968			v.reset(OpConst64)
 48969			v.AuxInt = int64(uint16(c))
 48970			return true
 48971		}
 48972		// match: (ZeroExt16to64 (Trunc64to16 x:(Rsh64Ux64 _ (Const64 [s]))))
 48973		// cond: s >= 48
 48974		// result: x
 48975		for {
 48976			v_0 := v.Args[0]
 48977			if v_0.Op != OpTrunc64to16 {
 48978				break
 48979			}
 48980			x := v_0.Args[0]
 48981			if x.Op != OpRsh64Ux64 {
 48982				break
 48983			}
 48984			_ = x.Args[1]
 48985			x_1 := x.Args[1]
 48986			if x_1.Op != OpConst64 {
 48987				break
 48988			}
 48989			s := x_1.AuxInt
 48990			if !(s >= 48) {
 48991				break
 48992			}
 48993			v.reset(OpCopy)
 48994			v.Type = x.Type
 48995			v.AddArg(x)
 48996			return true
 48997		}
 48998		return false
 48999	}
 49000	func rewriteValuegeneric_OpZeroExt32to64_0(v *Value) bool {
 49001		// match: (ZeroExt32to64 (Const32 [c]))
 49002		// cond:
 49003		// result: (Const64 [int64(uint32(c))])
 49004		for {
 49005			v_0 := v.Args[0]
 49006			if v_0.Op != OpConst32 {
 49007				break
 49008			}
 49009			c := v_0.AuxInt
 49010			v.reset(OpConst64)
 49011			v.AuxInt = int64(uint32(c))
 49012			return true
 49013		}
 49014		// match: (ZeroExt32to64 (Trunc64to32 x:(Rsh64Ux64 _ (Const64 [s]))))
 49015		// cond: s >= 32
 49016		// result: x
 49017		for {
 49018			v_0 := v.Args[0]
 49019			if v_0.Op != OpTrunc64to32 {
 49020				break
 49021			}
 49022			x := v_0.Args[0]
 49023			if x.Op != OpRsh64Ux64 {
 49024				break
 49025			}
 49026			_ = x.Args[1]
 49027			x_1 := x.Args[1]
 49028			if x_1.Op != OpConst64 {
 49029				break
 49030			}
 49031			s := x_1.AuxInt
 49032			if !(s >= 32) {
 49033				break
 49034			}
 49035			v.reset(OpCopy)
 49036			v.Type = x.Type
 49037			v.AddArg(x)
 49038			return true
 49039		}
 49040		return false
 49041	}
 49042	func rewriteValuegeneric_OpZeroExt8to16_0(v *Value) bool {
 49043		// match: (ZeroExt8to16 (Const8 [c]))
 49044		// cond:
 49045		// result: (Const16 [int64( uint8(c))])
 49046		for {
 49047			v_0 := v.Args[0]
 49048			if v_0.Op != OpConst8 {
 49049				break
 49050			}
 49051			c := v_0.AuxInt
 49052			v.reset(OpConst16)
 49053			v.AuxInt = int64(uint8(c))
 49054			return true
 49055		}
 49056		// match: (ZeroExt8to16 (Trunc16to8 x:(Rsh16Ux64 _ (Const64 [s]))))
 49057		// cond: s >= 8
 49058		// result: x
 49059		for {
 49060			v_0 := v.Args[0]
 49061			if v_0.Op != OpTrunc16to8 {
 49062				break
 49063			}
 49064			x := v_0.Args[0]
 49065			if x.Op != OpRsh16Ux64 {
 49066				break
 49067			}
 49068			_ = x.Args[1]
 49069			x_1 := x.Args[1]
 49070			if x_1.Op != OpConst64 {
 49071				break
 49072			}
 49073			s := x_1.AuxInt
 49074			if !(s >= 8) {
 49075				break
 49076			}
 49077			v.reset(OpCopy)
 49078			v.Type = x.Type
 49079			v.AddArg(x)
 49080			return true
 49081		}
 49082		return false
 49083	}
 49084	func rewriteValuegeneric_OpZeroExt8to32_0(v *Value) bool {
 49085		// match: (ZeroExt8to32 (Const8 [c]))
 49086		// cond:
 49087		// result: (Const32 [int64( uint8(c))])
 49088		for {
 49089			v_0 := v.Args[0]
 49090			if v_0.Op != OpConst8 {
 49091				break
 49092			}
 49093			c := v_0.AuxInt
 49094			v.reset(OpConst32)
 49095			v.AuxInt = int64(uint8(c))
 49096			return true
 49097		}
 49098		// match: (ZeroExt8to32 (Trunc32to8 x:(Rsh32Ux64 _ (Const64 [s]))))
 49099		// cond: s >= 24
 49100		// result: x
 49101		for {
 49102			v_0 := v.Args[0]
 49103			if v_0.Op != OpTrunc32to8 {
 49104				break
 49105			}
 49106			x := v_0.Args[0]
 49107			if x.Op != OpRsh32Ux64 {
 49108				break
 49109			}
 49110			_ = x.Args[1]
 49111			x_1 := x.Args[1]
 49112			if x_1.Op != OpConst64 {
 49113				break
 49114			}
 49115			s := x_1.AuxInt
 49116			if !(s >= 24) {
 49117				break
 49118			}
 49119			v.reset(OpCopy)
 49120			v.Type = x.Type
 49121			v.AddArg(x)
 49122			return true
 49123		}
 49124		return false
 49125	}
 49126	func rewriteValuegeneric_OpZeroExt8to64_0(v *Value) bool {
 49127		// match: (ZeroExt8to64 (Const8 [c]))
 49128		// cond:
 49129		// result: (Const64 [int64( uint8(c))])
 49130		for {
 49131			v_0 := v.Args[0]
 49132			if v_0.Op != OpConst8 {
 49133				break
 49134			}
 49135			c := v_0.AuxInt
 49136			v.reset(OpConst64)
 49137			v.AuxInt = int64(uint8(c))
 49138			return true
 49139		}
 49140		// match: (ZeroExt8to64 (Trunc64to8 x:(Rsh64Ux64 _ (Const64 [s]))))
 49141		// cond: s >= 56
 49142		// result: x
 49143		for {
 49144			v_0 := v.Args[0]
 49145			if v_0.Op != OpTrunc64to8 {
 49146				break
 49147			}
 49148			x := v_0.Args[0]
 49149			if x.Op != OpRsh64Ux64 {
 49150				break
 49151			}
 49152			_ = x.Args[1]
 49153			x_1 := x.Args[1]
 49154			if x_1.Op != OpConst64 {
 49155				break
 49156			}
 49157			s := x_1.AuxInt
 49158			if !(s >= 56) {
 49159				break
 49160			}
 49161			v.reset(OpCopy)
 49162			v.Type = x.Type
 49163			v.AddArg(x)
 49164			return true
 49165		}
 49166		return false
 49167	}
 49168	func rewriteBlockgeneric(b *Block) bool {
 49169		config := b.Func.Config
 49170		typ := &config.Types
 49171		_ = typ
 49172		v := b.Control
 49173		_ = v
 49174		switch b.Kind {
 49175		case BlockIf:
 49176			// match: (If (Not cond) yes no)
 49177			// cond:
 49178			// result: (If cond no yes)
 49179			for v.Op == OpNot {
 49180				cond := v.Args[0]
 49181				b.Kind = BlockIf
 49182				b.SetControl(cond)
 49183				b.Aux = nil
 49184				b.swapSuccessors()
 49185				return true
 49186			}
 49187			// match: (If (ConstBool [c]) yes no)
 49188			// cond: c == 1
 49189			// result: (First nil yes no)
 49190			for v.Op == OpConstBool {
 49191				c := v.AuxInt
 49192				if !(c == 1) {
 49193					break
 49194				}
 49195				b.Kind = BlockFirst
 49196				b.SetControl(nil)
 49197				b.Aux = nil
 49198				return true
 49199			}
 49200			// match: (If (ConstBool [c]) yes no)
 49201			// cond: c == 0
 49202			// result: (First nil no yes)
 49203			for v.Op == OpConstBool {
 49204				c := v.AuxInt
 49205				if !(c == 0) {
 49206					break
 49207				}
 49208				b.Kind = BlockFirst
 49209				b.SetControl(nil)
 49210				b.Aux = nil
 49211				b.swapSuccessors()
 49212				return true
 49213			}
 49214		}
 49215		return false
 49216	}
 49217	

View as plain text