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

     1	// Code generated from gen/Wasm.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 rewriteValueWasm(v *Value) bool {
    19		switch v.Op {
    20		case OpAbs:
    21			return rewriteValueWasm_OpAbs_0(v)
    22		case OpAdd16:
    23			return rewriteValueWasm_OpAdd16_0(v)
    24		case OpAdd32:
    25			return rewriteValueWasm_OpAdd32_0(v)
    26		case OpAdd32F:
    27			return rewriteValueWasm_OpAdd32F_0(v)
    28		case OpAdd64:
    29			return rewriteValueWasm_OpAdd64_0(v)
    30		case OpAdd64F:
    31			return rewriteValueWasm_OpAdd64F_0(v)
    32		case OpAdd8:
    33			return rewriteValueWasm_OpAdd8_0(v)
    34		case OpAddPtr:
    35			return rewriteValueWasm_OpAddPtr_0(v)
    36		case OpAddr:
    37			return rewriteValueWasm_OpAddr_0(v)
    38		case OpAnd16:
    39			return rewriteValueWasm_OpAnd16_0(v)
    40		case OpAnd32:
    41			return rewriteValueWasm_OpAnd32_0(v)
    42		case OpAnd64:
    43			return rewriteValueWasm_OpAnd64_0(v)
    44		case OpAnd8:
    45			return rewriteValueWasm_OpAnd8_0(v)
    46		case OpAndB:
    47			return rewriteValueWasm_OpAndB_0(v)
    48		case OpBitLen64:
    49			return rewriteValueWasm_OpBitLen64_0(v)
    50		case OpCeil:
    51			return rewriteValueWasm_OpCeil_0(v)
    52		case OpClosureCall:
    53			return rewriteValueWasm_OpClosureCall_0(v)
    54		case OpCom16:
    55			return rewriteValueWasm_OpCom16_0(v)
    56		case OpCom32:
    57			return rewriteValueWasm_OpCom32_0(v)
    58		case OpCom64:
    59			return rewriteValueWasm_OpCom64_0(v)
    60		case OpCom8:
    61			return rewriteValueWasm_OpCom8_0(v)
    62		case OpConst16:
    63			return rewriteValueWasm_OpConst16_0(v)
    64		case OpConst32:
    65			return rewriteValueWasm_OpConst32_0(v)
    66		case OpConst32F:
    67			return rewriteValueWasm_OpConst32F_0(v)
    68		case OpConst64:
    69			return rewriteValueWasm_OpConst64_0(v)
    70		case OpConst64F:
    71			return rewriteValueWasm_OpConst64F_0(v)
    72		case OpConst8:
    73			return rewriteValueWasm_OpConst8_0(v)
    74		case OpConstBool:
    75			return rewriteValueWasm_OpConstBool_0(v)
    76		case OpConstNil:
    77			return rewriteValueWasm_OpConstNil_0(v)
    78		case OpConvert:
    79			return rewriteValueWasm_OpConvert_0(v)
    80		case OpCopysign:
    81			return rewriteValueWasm_OpCopysign_0(v)
    82		case OpCtz16:
    83			return rewriteValueWasm_OpCtz16_0(v)
    84		case OpCtz16NonZero:
    85			return rewriteValueWasm_OpCtz16NonZero_0(v)
    86		case OpCtz32:
    87			return rewriteValueWasm_OpCtz32_0(v)
    88		case OpCtz32NonZero:
    89			return rewriteValueWasm_OpCtz32NonZero_0(v)
    90		case OpCtz64:
    91			return rewriteValueWasm_OpCtz64_0(v)
    92		case OpCtz64NonZero:
    93			return rewriteValueWasm_OpCtz64NonZero_0(v)
    94		case OpCtz8:
    95			return rewriteValueWasm_OpCtz8_0(v)
    96		case OpCtz8NonZero:
    97			return rewriteValueWasm_OpCtz8NonZero_0(v)
    98		case OpCvt32Fto32:
    99			return rewriteValueWasm_OpCvt32Fto32_0(v)
   100		case OpCvt32Fto32U:
   101			return rewriteValueWasm_OpCvt32Fto32U_0(v)
   102		case OpCvt32Fto64:
   103			return rewriteValueWasm_OpCvt32Fto64_0(v)
   104		case OpCvt32Fto64F:
   105			return rewriteValueWasm_OpCvt32Fto64F_0(v)
   106		case OpCvt32Fto64U:
   107			return rewriteValueWasm_OpCvt32Fto64U_0(v)
   108		case OpCvt32Uto32F:
   109			return rewriteValueWasm_OpCvt32Uto32F_0(v)
   110		case OpCvt32Uto64F:
   111			return rewriteValueWasm_OpCvt32Uto64F_0(v)
   112		case OpCvt32to32F:
   113			return rewriteValueWasm_OpCvt32to32F_0(v)
   114		case OpCvt32to64F:
   115			return rewriteValueWasm_OpCvt32to64F_0(v)
   116		case OpCvt64Fto32:
   117			return rewriteValueWasm_OpCvt64Fto32_0(v)
   118		case OpCvt64Fto32F:
   119			return rewriteValueWasm_OpCvt64Fto32F_0(v)
   120		case OpCvt64Fto32U:
   121			return rewriteValueWasm_OpCvt64Fto32U_0(v)
   122		case OpCvt64Fto64:
   123			return rewriteValueWasm_OpCvt64Fto64_0(v)
   124		case OpCvt64Fto64U:
   125			return rewriteValueWasm_OpCvt64Fto64U_0(v)
   126		case OpCvt64Uto32F:
   127			return rewriteValueWasm_OpCvt64Uto32F_0(v)
   128		case OpCvt64Uto64F:
   129			return rewriteValueWasm_OpCvt64Uto64F_0(v)
   130		case OpCvt64to32F:
   131			return rewriteValueWasm_OpCvt64to32F_0(v)
   132		case OpCvt64to64F:
   133			return rewriteValueWasm_OpCvt64to64F_0(v)
   134		case OpDiv16:
   135			return rewriteValueWasm_OpDiv16_0(v)
   136		case OpDiv16u:
   137			return rewriteValueWasm_OpDiv16u_0(v)
   138		case OpDiv32:
   139			return rewriteValueWasm_OpDiv32_0(v)
   140		case OpDiv32F:
   141			return rewriteValueWasm_OpDiv32F_0(v)
   142		case OpDiv32u:
   143			return rewriteValueWasm_OpDiv32u_0(v)
   144		case OpDiv64:
   145			return rewriteValueWasm_OpDiv64_0(v)
   146		case OpDiv64F:
   147			return rewriteValueWasm_OpDiv64F_0(v)
   148		case OpDiv64u:
   149			return rewriteValueWasm_OpDiv64u_0(v)
   150		case OpDiv8:
   151			return rewriteValueWasm_OpDiv8_0(v)
   152		case OpDiv8u:
   153			return rewriteValueWasm_OpDiv8u_0(v)
   154		case OpEq16:
   155			return rewriteValueWasm_OpEq16_0(v)
   156		case OpEq32:
   157			return rewriteValueWasm_OpEq32_0(v)
   158		case OpEq32F:
   159			return rewriteValueWasm_OpEq32F_0(v)
   160		case OpEq64:
   161			return rewriteValueWasm_OpEq64_0(v)
   162		case OpEq64F:
   163			return rewriteValueWasm_OpEq64F_0(v)
   164		case OpEq8:
   165			return rewriteValueWasm_OpEq8_0(v)
   166		case OpEqB:
   167			return rewriteValueWasm_OpEqB_0(v)
   168		case OpEqPtr:
   169			return rewriteValueWasm_OpEqPtr_0(v)
   170		case OpFloor:
   171			return rewriteValueWasm_OpFloor_0(v)
   172		case OpGeq16:
   173			return rewriteValueWasm_OpGeq16_0(v)
   174		case OpGeq16U:
   175			return rewriteValueWasm_OpGeq16U_0(v)
   176		case OpGeq32:
   177			return rewriteValueWasm_OpGeq32_0(v)
   178		case OpGeq32F:
   179			return rewriteValueWasm_OpGeq32F_0(v)
   180		case OpGeq32U:
   181			return rewriteValueWasm_OpGeq32U_0(v)
   182		case OpGeq64:
   183			return rewriteValueWasm_OpGeq64_0(v)
   184		case OpGeq64F:
   185			return rewriteValueWasm_OpGeq64F_0(v)
   186		case OpGeq64U:
   187			return rewriteValueWasm_OpGeq64U_0(v)
   188		case OpGeq8:
   189			return rewriteValueWasm_OpGeq8_0(v)
   190		case OpGeq8U:
   191			return rewriteValueWasm_OpGeq8U_0(v)
   192		case OpGetCallerPC:
   193			return rewriteValueWasm_OpGetCallerPC_0(v)
   194		case OpGetCallerSP:
   195			return rewriteValueWasm_OpGetCallerSP_0(v)
   196		case OpGetClosurePtr:
   197			return rewriteValueWasm_OpGetClosurePtr_0(v)
   198		case OpGreater16:
   199			return rewriteValueWasm_OpGreater16_0(v)
   200		case OpGreater16U:
   201			return rewriteValueWasm_OpGreater16U_0(v)
   202		case OpGreater32:
   203			return rewriteValueWasm_OpGreater32_0(v)
   204		case OpGreater32F:
   205			return rewriteValueWasm_OpGreater32F_0(v)
   206		case OpGreater32U:
   207			return rewriteValueWasm_OpGreater32U_0(v)
   208		case OpGreater64:
   209			return rewriteValueWasm_OpGreater64_0(v)
   210		case OpGreater64F:
   211			return rewriteValueWasm_OpGreater64F_0(v)
   212		case OpGreater64U:
   213			return rewriteValueWasm_OpGreater64U_0(v)
   214		case OpGreater8:
   215			return rewriteValueWasm_OpGreater8_0(v)
   216		case OpGreater8U:
   217			return rewriteValueWasm_OpGreater8U_0(v)
   218		case OpInterCall:
   219			return rewriteValueWasm_OpInterCall_0(v)
   220		case OpIsInBounds:
   221			return rewriteValueWasm_OpIsInBounds_0(v)
   222		case OpIsNonNil:
   223			return rewriteValueWasm_OpIsNonNil_0(v)
   224		case OpIsSliceInBounds:
   225			return rewriteValueWasm_OpIsSliceInBounds_0(v)
   226		case OpLeq16:
   227			return rewriteValueWasm_OpLeq16_0(v)
   228		case OpLeq16U:
   229			return rewriteValueWasm_OpLeq16U_0(v)
   230		case OpLeq32:
   231			return rewriteValueWasm_OpLeq32_0(v)
   232		case OpLeq32F:
   233			return rewriteValueWasm_OpLeq32F_0(v)
   234		case OpLeq32U:
   235			return rewriteValueWasm_OpLeq32U_0(v)
   236		case OpLeq64:
   237			return rewriteValueWasm_OpLeq64_0(v)
   238		case OpLeq64F:
   239			return rewriteValueWasm_OpLeq64F_0(v)
   240		case OpLeq64U:
   241			return rewriteValueWasm_OpLeq64U_0(v)
   242		case OpLeq8:
   243			return rewriteValueWasm_OpLeq8_0(v)
   244		case OpLeq8U:
   245			return rewriteValueWasm_OpLeq8U_0(v)
   246		case OpLess16:
   247			return rewriteValueWasm_OpLess16_0(v)
   248		case OpLess16U:
   249			return rewriteValueWasm_OpLess16U_0(v)
   250		case OpLess32:
   251			return rewriteValueWasm_OpLess32_0(v)
   252		case OpLess32F:
   253			return rewriteValueWasm_OpLess32F_0(v)
   254		case OpLess32U:
   255			return rewriteValueWasm_OpLess32U_0(v)
   256		case OpLess64:
   257			return rewriteValueWasm_OpLess64_0(v)
   258		case OpLess64F:
   259			return rewriteValueWasm_OpLess64F_0(v)
   260		case OpLess64U:
   261			return rewriteValueWasm_OpLess64U_0(v)
   262		case OpLess8:
   263			return rewriteValueWasm_OpLess8_0(v)
   264		case OpLess8U:
   265			return rewriteValueWasm_OpLess8U_0(v)
   266		case OpLoad:
   267			return rewriteValueWasm_OpLoad_0(v)
   268		case OpLocalAddr:
   269			return rewriteValueWasm_OpLocalAddr_0(v)
   270		case OpLsh16x16:
   271			return rewriteValueWasm_OpLsh16x16_0(v)
   272		case OpLsh16x32:
   273			return rewriteValueWasm_OpLsh16x32_0(v)
   274		case OpLsh16x64:
   275			return rewriteValueWasm_OpLsh16x64_0(v)
   276		case OpLsh16x8:
   277			return rewriteValueWasm_OpLsh16x8_0(v)
   278		case OpLsh32x16:
   279			return rewriteValueWasm_OpLsh32x16_0(v)
   280		case OpLsh32x32:
   281			return rewriteValueWasm_OpLsh32x32_0(v)
   282		case OpLsh32x64:
   283			return rewriteValueWasm_OpLsh32x64_0(v)
   284		case OpLsh32x8:
   285			return rewriteValueWasm_OpLsh32x8_0(v)
   286		case OpLsh64x16:
   287			return rewriteValueWasm_OpLsh64x16_0(v)
   288		case OpLsh64x32:
   289			return rewriteValueWasm_OpLsh64x32_0(v)
   290		case OpLsh64x64:
   291			return rewriteValueWasm_OpLsh64x64_0(v)
   292		case OpLsh64x8:
   293			return rewriteValueWasm_OpLsh64x8_0(v)
   294		case OpLsh8x16:
   295			return rewriteValueWasm_OpLsh8x16_0(v)
   296		case OpLsh8x32:
   297			return rewriteValueWasm_OpLsh8x32_0(v)
   298		case OpLsh8x64:
   299			return rewriteValueWasm_OpLsh8x64_0(v)
   300		case OpLsh8x8:
   301			return rewriteValueWasm_OpLsh8x8_0(v)
   302		case OpMod16:
   303			return rewriteValueWasm_OpMod16_0(v)
   304		case OpMod16u:
   305			return rewriteValueWasm_OpMod16u_0(v)
   306		case OpMod32:
   307			return rewriteValueWasm_OpMod32_0(v)
   308		case OpMod32u:
   309			return rewriteValueWasm_OpMod32u_0(v)
   310		case OpMod64:
   311			return rewriteValueWasm_OpMod64_0(v)
   312		case OpMod64u:
   313			return rewriteValueWasm_OpMod64u_0(v)
   314		case OpMod8:
   315			return rewriteValueWasm_OpMod8_0(v)
   316		case OpMod8u:
   317			return rewriteValueWasm_OpMod8u_0(v)
   318		case OpMove:
   319			return rewriteValueWasm_OpMove_0(v) || rewriteValueWasm_OpMove_10(v)
   320		case OpMul16:
   321			return rewriteValueWasm_OpMul16_0(v)
   322		case OpMul32:
   323			return rewriteValueWasm_OpMul32_0(v)
   324		case OpMul32F:
   325			return rewriteValueWasm_OpMul32F_0(v)
   326		case OpMul64:
   327			return rewriteValueWasm_OpMul64_0(v)
   328		case OpMul64F:
   329			return rewriteValueWasm_OpMul64F_0(v)
   330		case OpMul8:
   331			return rewriteValueWasm_OpMul8_0(v)
   332		case OpNeg16:
   333			return rewriteValueWasm_OpNeg16_0(v)
   334		case OpNeg32:
   335			return rewriteValueWasm_OpNeg32_0(v)
   336		case OpNeg32F:
   337			return rewriteValueWasm_OpNeg32F_0(v)
   338		case OpNeg64:
   339			return rewriteValueWasm_OpNeg64_0(v)
   340		case OpNeg64F:
   341			return rewriteValueWasm_OpNeg64F_0(v)
   342		case OpNeg8:
   343			return rewriteValueWasm_OpNeg8_0(v)
   344		case OpNeq16:
   345			return rewriteValueWasm_OpNeq16_0(v)
   346		case OpNeq32:
   347			return rewriteValueWasm_OpNeq32_0(v)
   348		case OpNeq32F:
   349			return rewriteValueWasm_OpNeq32F_0(v)
   350		case OpNeq64:
   351			return rewriteValueWasm_OpNeq64_0(v)
   352		case OpNeq64F:
   353			return rewriteValueWasm_OpNeq64F_0(v)
   354		case OpNeq8:
   355			return rewriteValueWasm_OpNeq8_0(v)
   356		case OpNeqB:
   357			return rewriteValueWasm_OpNeqB_0(v)
   358		case OpNeqPtr:
   359			return rewriteValueWasm_OpNeqPtr_0(v)
   360		case OpNilCheck:
   361			return rewriteValueWasm_OpNilCheck_0(v)
   362		case OpNot:
   363			return rewriteValueWasm_OpNot_0(v)
   364		case OpOffPtr:
   365			return rewriteValueWasm_OpOffPtr_0(v)
   366		case OpOr16:
   367			return rewriteValueWasm_OpOr16_0(v)
   368		case OpOr32:
   369			return rewriteValueWasm_OpOr32_0(v)
   370		case OpOr64:
   371			return rewriteValueWasm_OpOr64_0(v)
   372		case OpOr8:
   373			return rewriteValueWasm_OpOr8_0(v)
   374		case OpOrB:
   375			return rewriteValueWasm_OpOrB_0(v)
   376		case OpPopCount16:
   377			return rewriteValueWasm_OpPopCount16_0(v)
   378		case OpPopCount32:
   379			return rewriteValueWasm_OpPopCount32_0(v)
   380		case OpPopCount64:
   381			return rewriteValueWasm_OpPopCount64_0(v)
   382		case OpPopCount8:
   383			return rewriteValueWasm_OpPopCount8_0(v)
   384		case OpRotateLeft16:
   385			return rewriteValueWasm_OpRotateLeft16_0(v)
   386		case OpRotateLeft32:
   387			return rewriteValueWasm_OpRotateLeft32_0(v)
   388		case OpRotateLeft64:
   389			return rewriteValueWasm_OpRotateLeft64_0(v)
   390		case OpRotateLeft8:
   391			return rewriteValueWasm_OpRotateLeft8_0(v)
   392		case OpRound32F:
   393			return rewriteValueWasm_OpRound32F_0(v)
   394		case OpRound64F:
   395			return rewriteValueWasm_OpRound64F_0(v)
   396		case OpRoundToEven:
   397			return rewriteValueWasm_OpRoundToEven_0(v)
   398		case OpRsh16Ux16:
   399			return rewriteValueWasm_OpRsh16Ux16_0(v)
   400		case OpRsh16Ux32:
   401			return rewriteValueWasm_OpRsh16Ux32_0(v)
   402		case OpRsh16Ux64:
   403			return rewriteValueWasm_OpRsh16Ux64_0(v)
   404		case OpRsh16Ux8:
   405			return rewriteValueWasm_OpRsh16Ux8_0(v)
   406		case OpRsh16x16:
   407			return rewriteValueWasm_OpRsh16x16_0(v)
   408		case OpRsh16x32:
   409			return rewriteValueWasm_OpRsh16x32_0(v)
   410		case OpRsh16x64:
   411			return rewriteValueWasm_OpRsh16x64_0(v)
   412		case OpRsh16x8:
   413			return rewriteValueWasm_OpRsh16x8_0(v)
   414		case OpRsh32Ux16:
   415			return rewriteValueWasm_OpRsh32Ux16_0(v)
   416		case OpRsh32Ux32:
   417			return rewriteValueWasm_OpRsh32Ux32_0(v)
   418		case OpRsh32Ux64:
   419			return rewriteValueWasm_OpRsh32Ux64_0(v)
   420		case OpRsh32Ux8:
   421			return rewriteValueWasm_OpRsh32Ux8_0(v)
   422		case OpRsh32x16:
   423			return rewriteValueWasm_OpRsh32x16_0(v)
   424		case OpRsh32x32:
   425			return rewriteValueWasm_OpRsh32x32_0(v)
   426		case OpRsh32x64:
   427			return rewriteValueWasm_OpRsh32x64_0(v)
   428		case OpRsh32x8:
   429			return rewriteValueWasm_OpRsh32x8_0(v)
   430		case OpRsh64Ux16:
   431			return rewriteValueWasm_OpRsh64Ux16_0(v)
   432		case OpRsh64Ux32:
   433			return rewriteValueWasm_OpRsh64Ux32_0(v)
   434		case OpRsh64Ux64:
   435			return rewriteValueWasm_OpRsh64Ux64_0(v)
   436		case OpRsh64Ux8:
   437			return rewriteValueWasm_OpRsh64Ux8_0(v)
   438		case OpRsh64x16:
   439			return rewriteValueWasm_OpRsh64x16_0(v)
   440		case OpRsh64x32:
   441			return rewriteValueWasm_OpRsh64x32_0(v)
   442		case OpRsh64x64:
   443			return rewriteValueWasm_OpRsh64x64_0(v)
   444		case OpRsh64x8:
   445			return rewriteValueWasm_OpRsh64x8_0(v)
   446		case OpRsh8Ux16:
   447			return rewriteValueWasm_OpRsh8Ux16_0(v)
   448		case OpRsh8Ux32:
   449			return rewriteValueWasm_OpRsh8Ux32_0(v)
   450		case OpRsh8Ux64:
   451			return rewriteValueWasm_OpRsh8Ux64_0(v)
   452		case OpRsh8Ux8:
   453			return rewriteValueWasm_OpRsh8Ux8_0(v)
   454		case OpRsh8x16:
   455			return rewriteValueWasm_OpRsh8x16_0(v)
   456		case OpRsh8x32:
   457			return rewriteValueWasm_OpRsh8x32_0(v)
   458		case OpRsh8x64:
   459			return rewriteValueWasm_OpRsh8x64_0(v)
   460		case OpRsh8x8:
   461			return rewriteValueWasm_OpRsh8x8_0(v)
   462		case OpSignExt16to32:
   463			return rewriteValueWasm_OpSignExt16to32_0(v)
   464		case OpSignExt16to64:
   465			return rewriteValueWasm_OpSignExt16to64_0(v)
   466		case OpSignExt32to64:
   467			return rewriteValueWasm_OpSignExt32to64_0(v)
   468		case OpSignExt8to16:
   469			return rewriteValueWasm_OpSignExt8to16_0(v)
   470		case OpSignExt8to32:
   471			return rewriteValueWasm_OpSignExt8to32_0(v)
   472		case OpSignExt8to64:
   473			return rewriteValueWasm_OpSignExt8to64_0(v)
   474		case OpSlicemask:
   475			return rewriteValueWasm_OpSlicemask_0(v)
   476		case OpSqrt:
   477			return rewriteValueWasm_OpSqrt_0(v)
   478		case OpStaticCall:
   479			return rewriteValueWasm_OpStaticCall_0(v)
   480		case OpStore:
   481			return rewriteValueWasm_OpStore_0(v)
   482		case OpSub16:
   483			return rewriteValueWasm_OpSub16_0(v)
   484		case OpSub32:
   485			return rewriteValueWasm_OpSub32_0(v)
   486		case OpSub32F:
   487			return rewriteValueWasm_OpSub32F_0(v)
   488		case OpSub64:
   489			return rewriteValueWasm_OpSub64_0(v)
   490		case OpSub64F:
   491			return rewriteValueWasm_OpSub64F_0(v)
   492		case OpSub8:
   493			return rewriteValueWasm_OpSub8_0(v)
   494		case OpSubPtr:
   495			return rewriteValueWasm_OpSubPtr_0(v)
   496		case OpTrunc:
   497			return rewriteValueWasm_OpTrunc_0(v)
   498		case OpTrunc16to8:
   499			return rewriteValueWasm_OpTrunc16to8_0(v)
   500		case OpTrunc32to16:
   501			return rewriteValueWasm_OpTrunc32to16_0(v)
   502		case OpTrunc32to8:
   503			return rewriteValueWasm_OpTrunc32to8_0(v)
   504		case OpTrunc64to16:
   505			return rewriteValueWasm_OpTrunc64to16_0(v)
   506		case OpTrunc64to32:
   507			return rewriteValueWasm_OpTrunc64to32_0(v)
   508		case OpTrunc64to8:
   509			return rewriteValueWasm_OpTrunc64to8_0(v)
   510		case OpWB:
   511			return rewriteValueWasm_OpWB_0(v)
   512		case OpWasmF64Add:
   513			return rewriteValueWasm_OpWasmF64Add_0(v)
   514		case OpWasmF64Mul:
   515			return rewriteValueWasm_OpWasmF64Mul_0(v)
   516		case OpWasmI64Add:
   517			return rewriteValueWasm_OpWasmI64Add_0(v)
   518		case OpWasmI64AddConst:
   519			return rewriteValueWasm_OpWasmI64AddConst_0(v)
   520		case OpWasmI64And:
   521			return rewriteValueWasm_OpWasmI64And_0(v)
   522		case OpWasmI64Eq:
   523			return rewriteValueWasm_OpWasmI64Eq_0(v)
   524		case OpWasmI64Eqz:
   525			return rewriteValueWasm_OpWasmI64Eqz_0(v)
   526		case OpWasmI64Load:
   527			return rewriteValueWasm_OpWasmI64Load_0(v)
   528		case OpWasmI64Load16S:
   529			return rewriteValueWasm_OpWasmI64Load16S_0(v)
   530		case OpWasmI64Load16U:
   531			return rewriteValueWasm_OpWasmI64Load16U_0(v)
   532		case OpWasmI64Load32S:
   533			return rewriteValueWasm_OpWasmI64Load32S_0(v)
   534		case OpWasmI64Load32U:
   535			return rewriteValueWasm_OpWasmI64Load32U_0(v)
   536		case OpWasmI64Load8S:
   537			return rewriteValueWasm_OpWasmI64Load8S_0(v)
   538		case OpWasmI64Load8U:
   539			return rewriteValueWasm_OpWasmI64Load8U_0(v)
   540		case OpWasmI64Mul:
   541			return rewriteValueWasm_OpWasmI64Mul_0(v)
   542		case OpWasmI64Ne:
   543			return rewriteValueWasm_OpWasmI64Ne_0(v)
   544		case OpWasmI64Or:
   545			return rewriteValueWasm_OpWasmI64Or_0(v)
   546		case OpWasmI64Shl:
   547			return rewriteValueWasm_OpWasmI64Shl_0(v)
   548		case OpWasmI64ShrS:
   549			return rewriteValueWasm_OpWasmI64ShrS_0(v)
   550		case OpWasmI64ShrU:
   551			return rewriteValueWasm_OpWasmI64ShrU_0(v)
   552		case OpWasmI64Store:
   553			return rewriteValueWasm_OpWasmI64Store_0(v)
   554		case OpWasmI64Store16:
   555			return rewriteValueWasm_OpWasmI64Store16_0(v)
   556		case OpWasmI64Store32:
   557			return rewriteValueWasm_OpWasmI64Store32_0(v)
   558		case OpWasmI64Store8:
   559			return rewriteValueWasm_OpWasmI64Store8_0(v)
   560		case OpWasmI64Xor:
   561			return rewriteValueWasm_OpWasmI64Xor_0(v)
   562		case OpXor16:
   563			return rewriteValueWasm_OpXor16_0(v)
   564		case OpXor32:
   565			return rewriteValueWasm_OpXor32_0(v)
   566		case OpXor64:
   567			return rewriteValueWasm_OpXor64_0(v)
   568		case OpXor8:
   569			return rewriteValueWasm_OpXor8_0(v)
   570		case OpZero:
   571			return rewriteValueWasm_OpZero_0(v) || rewriteValueWasm_OpZero_10(v)
   572		case OpZeroExt16to32:
   573			return rewriteValueWasm_OpZeroExt16to32_0(v)
   574		case OpZeroExt16to64:
   575			return rewriteValueWasm_OpZeroExt16to64_0(v)
   576		case OpZeroExt32to64:
   577			return rewriteValueWasm_OpZeroExt32to64_0(v)
   578		case OpZeroExt8to16:
   579			return rewriteValueWasm_OpZeroExt8to16_0(v)
   580		case OpZeroExt8to32:
   581			return rewriteValueWasm_OpZeroExt8to32_0(v)
   582		case OpZeroExt8to64:
   583			return rewriteValueWasm_OpZeroExt8to64_0(v)
   584		}
   585		return false
   586	}
   587	func rewriteValueWasm_OpAbs_0(v *Value) bool {
   588		// match: (Abs x)
   589		// cond:
   590		// result: (F64Abs x)
   591		for {
   592			x := v.Args[0]
   593			v.reset(OpWasmF64Abs)
   594			v.AddArg(x)
   595			return true
   596		}
   597	}
   598	func rewriteValueWasm_OpAdd16_0(v *Value) bool {
   599		// match: (Add16 x y)
   600		// cond:
   601		// result: (I64Add x y)
   602		for {
   603			y := v.Args[1]
   604			x := v.Args[0]
   605			v.reset(OpWasmI64Add)
   606			v.AddArg(x)
   607			v.AddArg(y)
   608			return true
   609		}
   610	}
   611	func rewriteValueWasm_OpAdd32_0(v *Value) bool {
   612		// match: (Add32 x y)
   613		// cond:
   614		// result: (I64Add x y)
   615		for {
   616			y := v.Args[1]
   617			x := v.Args[0]
   618			v.reset(OpWasmI64Add)
   619			v.AddArg(x)
   620			v.AddArg(y)
   621			return true
   622		}
   623	}
   624	func rewriteValueWasm_OpAdd32F_0(v *Value) bool {
   625		// match: (Add32F x y)
   626		// cond:
   627		// result: (F64Add x y)
   628		for {
   629			y := v.Args[1]
   630			x := v.Args[0]
   631			v.reset(OpWasmF64Add)
   632			v.AddArg(x)
   633			v.AddArg(y)
   634			return true
   635		}
   636	}
   637	func rewriteValueWasm_OpAdd64_0(v *Value) bool {
   638		// match: (Add64 x y)
   639		// cond:
   640		// result: (I64Add x y)
   641		for {
   642			y := v.Args[1]
   643			x := v.Args[0]
   644			v.reset(OpWasmI64Add)
   645			v.AddArg(x)
   646			v.AddArg(y)
   647			return true
   648		}
   649	}
   650	func rewriteValueWasm_OpAdd64F_0(v *Value) bool {
   651		// match: (Add64F x y)
   652		// cond:
   653		// result: (F64Add x y)
   654		for {
   655			y := v.Args[1]
   656			x := v.Args[0]
   657			v.reset(OpWasmF64Add)
   658			v.AddArg(x)
   659			v.AddArg(y)
   660			return true
   661		}
   662	}
   663	func rewriteValueWasm_OpAdd8_0(v *Value) bool {
   664		// match: (Add8 x y)
   665		// cond:
   666		// result: (I64Add x y)
   667		for {
   668			y := v.Args[1]
   669			x := v.Args[0]
   670			v.reset(OpWasmI64Add)
   671			v.AddArg(x)
   672			v.AddArg(y)
   673			return true
   674		}
   675	}
   676	func rewriteValueWasm_OpAddPtr_0(v *Value) bool {
   677		// match: (AddPtr x y)
   678		// cond:
   679		// result: (I64Add x y)
   680		for {
   681			y := v.Args[1]
   682			x := v.Args[0]
   683			v.reset(OpWasmI64Add)
   684			v.AddArg(x)
   685			v.AddArg(y)
   686			return true
   687		}
   688	}
   689	func rewriteValueWasm_OpAddr_0(v *Value) bool {
   690		// match: (Addr {sym} base)
   691		// cond:
   692		// result: (LoweredAddr {sym} base)
   693		for {
   694			sym := v.Aux
   695			base := v.Args[0]
   696			v.reset(OpWasmLoweredAddr)
   697			v.Aux = sym
   698			v.AddArg(base)
   699			return true
   700		}
   701	}
   702	func rewriteValueWasm_OpAnd16_0(v *Value) bool {
   703		// match: (And16 x y)
   704		// cond:
   705		// result: (I64And x y)
   706		for {
   707			y := v.Args[1]
   708			x := v.Args[0]
   709			v.reset(OpWasmI64And)
   710			v.AddArg(x)
   711			v.AddArg(y)
   712			return true
   713		}
   714	}
   715	func rewriteValueWasm_OpAnd32_0(v *Value) bool {
   716		// match: (And32 x y)
   717		// cond:
   718		// result: (I64And x y)
   719		for {
   720			y := v.Args[1]
   721			x := v.Args[0]
   722			v.reset(OpWasmI64And)
   723			v.AddArg(x)
   724			v.AddArg(y)
   725			return true
   726		}
   727	}
   728	func rewriteValueWasm_OpAnd64_0(v *Value) bool {
   729		// match: (And64 x y)
   730		// cond:
   731		// result: (I64And x y)
   732		for {
   733			y := v.Args[1]
   734			x := v.Args[0]
   735			v.reset(OpWasmI64And)
   736			v.AddArg(x)
   737			v.AddArg(y)
   738			return true
   739		}
   740	}
   741	func rewriteValueWasm_OpAnd8_0(v *Value) bool {
   742		// match: (And8 x y)
   743		// cond:
   744		// result: (I64And x y)
   745		for {
   746			y := v.Args[1]
   747			x := v.Args[0]
   748			v.reset(OpWasmI64And)
   749			v.AddArg(x)
   750			v.AddArg(y)
   751			return true
   752		}
   753	}
   754	func rewriteValueWasm_OpAndB_0(v *Value) bool {
   755		// match: (AndB x y)
   756		// cond:
   757		// result: (I64And x y)
   758		for {
   759			y := v.Args[1]
   760			x := v.Args[0]
   761			v.reset(OpWasmI64And)
   762			v.AddArg(x)
   763			v.AddArg(y)
   764			return true
   765		}
   766	}
   767	func rewriteValueWasm_OpBitLen64_0(v *Value) bool {
   768		b := v.Block
   769		typ := &b.Func.Config.Types
   770		// match: (BitLen64 x)
   771		// cond:
   772		// result: (I64Sub (I64Const [64]) (I64Clz x))
   773		for {
   774			x := v.Args[0]
   775			v.reset(OpWasmI64Sub)
   776			v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
   777			v0.AuxInt = 64
   778			v.AddArg(v0)
   779			v1 := b.NewValue0(v.Pos, OpWasmI64Clz, typ.Int64)
   780			v1.AddArg(x)
   781			v.AddArg(v1)
   782			return true
   783		}
   784	}
   785	func rewriteValueWasm_OpCeil_0(v *Value) bool {
   786		// match: (Ceil x)
   787		// cond:
   788		// result: (F64Ceil x)
   789		for {
   790			x := v.Args[0]
   791			v.reset(OpWasmF64Ceil)
   792			v.AddArg(x)
   793			return true
   794		}
   795	}
   796	func rewriteValueWasm_OpClosureCall_0(v *Value) bool {
   797		// match: (ClosureCall [argwid] entry closure mem)
   798		// cond:
   799		// result: (LoweredClosureCall [argwid] entry closure mem)
   800		for {
   801			argwid := v.AuxInt
   802			mem := v.Args[2]
   803			entry := v.Args[0]
   804			closure := v.Args[1]
   805			v.reset(OpWasmLoweredClosureCall)
   806			v.AuxInt = argwid
   807			v.AddArg(entry)
   808			v.AddArg(closure)
   809			v.AddArg(mem)
   810			return true
   811		}
   812	}
   813	func rewriteValueWasm_OpCom16_0(v *Value) bool {
   814		b := v.Block
   815		typ := &b.Func.Config.Types
   816		// match: (Com16 x)
   817		// cond:
   818		// result: (I64Xor x (I64Const [-1]))
   819		for {
   820			x := v.Args[0]
   821			v.reset(OpWasmI64Xor)
   822			v.AddArg(x)
   823			v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
   824			v0.AuxInt = -1
   825			v.AddArg(v0)
   826			return true
   827		}
   828	}
   829	func rewriteValueWasm_OpCom32_0(v *Value) bool {
   830		b := v.Block
   831		typ := &b.Func.Config.Types
   832		// match: (Com32 x)
   833		// cond:
   834		// result: (I64Xor x (I64Const [-1]))
   835		for {
   836			x := v.Args[0]
   837			v.reset(OpWasmI64Xor)
   838			v.AddArg(x)
   839			v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
   840			v0.AuxInt = -1
   841			v.AddArg(v0)
   842			return true
   843		}
   844	}
   845	func rewriteValueWasm_OpCom64_0(v *Value) bool {
   846		b := v.Block
   847		typ := &b.Func.Config.Types
   848		// match: (Com64 x)
   849		// cond:
   850		// result: (I64Xor x (I64Const [-1]))
   851		for {
   852			x := v.Args[0]
   853			v.reset(OpWasmI64Xor)
   854			v.AddArg(x)
   855			v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
   856			v0.AuxInt = -1
   857			v.AddArg(v0)
   858			return true
   859		}
   860	}
   861	func rewriteValueWasm_OpCom8_0(v *Value) bool {
   862		b := v.Block
   863		typ := &b.Func.Config.Types
   864		// match: (Com8 x)
   865		// cond:
   866		// result: (I64Xor x (I64Const [-1]))
   867		for {
   868			x := v.Args[0]
   869			v.reset(OpWasmI64Xor)
   870			v.AddArg(x)
   871			v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
   872			v0.AuxInt = -1
   873			v.AddArg(v0)
   874			return true
   875		}
   876	}
   877	func rewriteValueWasm_OpConst16_0(v *Value) bool {
   878		// match: (Const16 [val])
   879		// cond:
   880		// result: (I64Const [val])
   881		for {
   882			val := v.AuxInt
   883			v.reset(OpWasmI64Const)
   884			v.AuxInt = val
   885			return true
   886		}
   887	}
   888	func rewriteValueWasm_OpConst32_0(v *Value) bool {
   889		// match: (Const32 [val])
   890		// cond:
   891		// result: (I64Const [val])
   892		for {
   893			val := v.AuxInt
   894			v.reset(OpWasmI64Const)
   895			v.AuxInt = val
   896			return true
   897		}
   898	}
   899	func rewriteValueWasm_OpConst32F_0(v *Value) bool {
   900		// match: (Const32F [val])
   901		// cond:
   902		// result: (F64Const [val])
   903		for {
   904			val := v.AuxInt
   905			v.reset(OpWasmF64Const)
   906			v.AuxInt = val
   907			return true
   908		}
   909	}
   910	func rewriteValueWasm_OpConst64_0(v *Value) bool {
   911		// match: (Const64 [val])
   912		// cond:
   913		// result: (I64Const [val])
   914		for {
   915			val := v.AuxInt
   916			v.reset(OpWasmI64Const)
   917			v.AuxInt = val
   918			return true
   919		}
   920	}
   921	func rewriteValueWasm_OpConst64F_0(v *Value) bool {
   922		// match: (Const64F [val])
   923		// cond:
   924		// result: (F64Const [val])
   925		for {
   926			val := v.AuxInt
   927			v.reset(OpWasmF64Const)
   928			v.AuxInt = val
   929			return true
   930		}
   931	}
   932	func rewriteValueWasm_OpConst8_0(v *Value) bool {
   933		// match: (Const8 [val])
   934		// cond:
   935		// result: (I64Const [val])
   936		for {
   937			val := v.AuxInt
   938			v.reset(OpWasmI64Const)
   939			v.AuxInt = val
   940			return true
   941		}
   942	}
   943	func rewriteValueWasm_OpConstBool_0(v *Value) bool {
   944		// match: (ConstBool [b])
   945		// cond:
   946		// result: (I64Const [b])
   947		for {
   948			b := v.AuxInt
   949			v.reset(OpWasmI64Const)
   950			v.AuxInt = b
   951			return true
   952		}
   953	}
   954	func rewriteValueWasm_OpConstNil_0(v *Value) bool {
   955		// match: (ConstNil)
   956		// cond:
   957		// result: (I64Const [0])
   958		for {
   959			v.reset(OpWasmI64Const)
   960			v.AuxInt = 0
   961			return true
   962		}
   963	}
   964	func rewriteValueWasm_OpConvert_0(v *Value) bool {
   965		// match: (Convert <t> x mem)
   966		// cond:
   967		// result: (LoweredConvert <t> x mem)
   968		for {
   969			t := v.Type
   970			mem := v.Args[1]
   971			x := v.Args[0]
   972			v.reset(OpWasmLoweredConvert)
   973			v.Type = t
   974			v.AddArg(x)
   975			v.AddArg(mem)
   976			return true
   977		}
   978	}
   979	func rewriteValueWasm_OpCopysign_0(v *Value) bool {
   980		// match: (Copysign x y)
   981		// cond:
   982		// result: (F64Copysign x y)
   983		for {
   984			y := v.Args[1]
   985			x := v.Args[0]
   986			v.reset(OpWasmF64Copysign)
   987			v.AddArg(x)
   988			v.AddArg(y)
   989			return true
   990		}
   991	}
   992	func rewriteValueWasm_OpCtz16_0(v *Value) bool {
   993		b := v.Block
   994		typ := &b.Func.Config.Types
   995		// match: (Ctz16 x)
   996		// cond:
   997		// result: (I64Ctz (I64Or x (I64Const [0x10000])))
   998		for {
   999			x := v.Args[0]
  1000			v.reset(OpWasmI64Ctz)
  1001			v0 := b.NewValue0(v.Pos, OpWasmI64Or, typ.Int64)
  1002			v0.AddArg(x)
  1003			v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  1004			v1.AuxInt = 0x10000
  1005			v0.AddArg(v1)
  1006			v.AddArg(v0)
  1007			return true
  1008		}
  1009	}
  1010	func rewriteValueWasm_OpCtz16NonZero_0(v *Value) bool {
  1011		// match: (Ctz16NonZero x)
  1012		// cond:
  1013		// result: (I64Ctz x)
  1014		for {
  1015			x := v.Args[0]
  1016			v.reset(OpWasmI64Ctz)
  1017			v.AddArg(x)
  1018			return true
  1019		}
  1020	}
  1021	func rewriteValueWasm_OpCtz32_0(v *Value) bool {
  1022		b := v.Block
  1023		typ := &b.Func.Config.Types
  1024		// match: (Ctz32 x)
  1025		// cond:
  1026		// result: (I64Ctz (I64Or x (I64Const [0x100000000])))
  1027		for {
  1028			x := v.Args[0]
  1029			v.reset(OpWasmI64Ctz)
  1030			v0 := b.NewValue0(v.Pos, OpWasmI64Or, typ.Int64)
  1031			v0.AddArg(x)
  1032			v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  1033			v1.AuxInt = 0x100000000
  1034			v0.AddArg(v1)
  1035			v.AddArg(v0)
  1036			return true
  1037		}
  1038	}
  1039	func rewriteValueWasm_OpCtz32NonZero_0(v *Value) bool {
  1040		// match: (Ctz32NonZero x)
  1041		// cond:
  1042		// result: (I64Ctz x)
  1043		for {
  1044			x := v.Args[0]
  1045			v.reset(OpWasmI64Ctz)
  1046			v.AddArg(x)
  1047			return true
  1048		}
  1049	}
  1050	func rewriteValueWasm_OpCtz64_0(v *Value) bool {
  1051		// match: (Ctz64 x)
  1052		// cond:
  1053		// result: (I64Ctz x)
  1054		for {
  1055			x := v.Args[0]
  1056			v.reset(OpWasmI64Ctz)
  1057			v.AddArg(x)
  1058			return true
  1059		}
  1060	}
  1061	func rewriteValueWasm_OpCtz64NonZero_0(v *Value) bool {
  1062		// match: (Ctz64NonZero x)
  1063		// cond:
  1064		// result: (I64Ctz x)
  1065		for {
  1066			x := v.Args[0]
  1067			v.reset(OpWasmI64Ctz)
  1068			v.AddArg(x)
  1069			return true
  1070		}
  1071	}
  1072	func rewriteValueWasm_OpCtz8_0(v *Value) bool {
  1073		b := v.Block
  1074		typ := &b.Func.Config.Types
  1075		// match: (Ctz8 x)
  1076		// cond:
  1077		// result: (I64Ctz (I64Or x (I64Const [0x100])))
  1078		for {
  1079			x := v.Args[0]
  1080			v.reset(OpWasmI64Ctz)
  1081			v0 := b.NewValue0(v.Pos, OpWasmI64Or, typ.Int64)
  1082			v0.AddArg(x)
  1083			v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  1084			v1.AuxInt = 0x100
  1085			v0.AddArg(v1)
  1086			v.AddArg(v0)
  1087			return true
  1088		}
  1089	}
  1090	func rewriteValueWasm_OpCtz8NonZero_0(v *Value) bool {
  1091		// match: (Ctz8NonZero x)
  1092		// cond:
  1093		// result: (I64Ctz x)
  1094		for {
  1095			x := v.Args[0]
  1096			v.reset(OpWasmI64Ctz)
  1097			v.AddArg(x)
  1098			return true
  1099		}
  1100	}
  1101	func rewriteValueWasm_OpCvt32Fto32_0(v *Value) bool {
  1102		// match: (Cvt32Fto32 x)
  1103		// cond:
  1104		// result: (I64TruncSatF64S x)
  1105		for {
  1106			x := v.Args[0]
  1107			v.reset(OpWasmI64TruncSatF64S)
  1108			v.AddArg(x)
  1109			return true
  1110		}
  1111	}
  1112	func rewriteValueWasm_OpCvt32Fto32U_0(v *Value) bool {
  1113		// match: (Cvt32Fto32U x)
  1114		// cond:
  1115		// result: (I64TruncSatF64U x)
  1116		for {
  1117			x := v.Args[0]
  1118			v.reset(OpWasmI64TruncSatF64U)
  1119			v.AddArg(x)
  1120			return true
  1121		}
  1122	}
  1123	func rewriteValueWasm_OpCvt32Fto64_0(v *Value) bool {
  1124		// match: (Cvt32Fto64 x)
  1125		// cond:
  1126		// result: (I64TruncSatF64S x)
  1127		for {
  1128			x := v.Args[0]
  1129			v.reset(OpWasmI64TruncSatF64S)
  1130			v.AddArg(x)
  1131			return true
  1132		}
  1133	}
  1134	func rewriteValueWasm_OpCvt32Fto64F_0(v *Value) bool {
  1135		// match: (Cvt32Fto64F x)
  1136		// cond:
  1137		// result: x
  1138		for {
  1139			x := v.Args[0]
  1140			v.reset(OpCopy)
  1141			v.Type = x.Type
  1142			v.AddArg(x)
  1143			return true
  1144		}
  1145	}
  1146	func rewriteValueWasm_OpCvt32Fto64U_0(v *Value) bool {
  1147		// match: (Cvt32Fto64U x)
  1148		// cond:
  1149		// result: (I64TruncSatF64U x)
  1150		for {
  1151			x := v.Args[0]
  1152			v.reset(OpWasmI64TruncSatF64U)
  1153			v.AddArg(x)
  1154			return true
  1155		}
  1156	}
  1157	func rewriteValueWasm_OpCvt32Uto32F_0(v *Value) bool {
  1158		b := v.Block
  1159		typ := &b.Func.Config.Types
  1160		// match: (Cvt32Uto32F x)
  1161		// cond:
  1162		// result: (LoweredRound32F (F64ConvertI64U (ZeroExt32to64 x)))
  1163		for {
  1164			x := v.Args[0]
  1165			v.reset(OpWasmLoweredRound32F)
  1166			v0 := b.NewValue0(v.Pos, OpWasmF64ConvertI64U, typ.Float64)
  1167			v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  1168			v1.AddArg(x)
  1169			v0.AddArg(v1)
  1170			v.AddArg(v0)
  1171			return true
  1172		}
  1173	}
  1174	func rewriteValueWasm_OpCvt32Uto64F_0(v *Value) bool {
  1175		b := v.Block
  1176		typ := &b.Func.Config.Types
  1177		// match: (Cvt32Uto64F x)
  1178		// cond:
  1179		// result: (F64ConvertI64U (ZeroExt32to64 x))
  1180		for {
  1181			x := v.Args[0]
  1182			v.reset(OpWasmF64ConvertI64U)
  1183			v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  1184			v0.AddArg(x)
  1185			v.AddArg(v0)
  1186			return true
  1187		}
  1188	}
  1189	func rewriteValueWasm_OpCvt32to32F_0(v *Value) bool {
  1190		b := v.Block
  1191		typ := &b.Func.Config.Types
  1192		// match: (Cvt32to32F x)
  1193		// cond:
  1194		// result: (LoweredRound32F (F64ConvertI64S (SignExt32to64 x)))
  1195		for {
  1196			x := v.Args[0]
  1197			v.reset(OpWasmLoweredRound32F)
  1198			v0 := b.NewValue0(v.Pos, OpWasmF64ConvertI64S, typ.Float64)
  1199			v1 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
  1200			v1.AddArg(x)
  1201			v0.AddArg(v1)
  1202			v.AddArg(v0)
  1203			return true
  1204		}
  1205	}
  1206	func rewriteValueWasm_OpCvt32to64F_0(v *Value) bool {
  1207		b := v.Block
  1208		typ := &b.Func.Config.Types
  1209		// match: (Cvt32to64F x)
  1210		// cond:
  1211		// result: (F64ConvertI64S (SignExt32to64 x))
  1212		for {
  1213			x := v.Args[0]
  1214			v.reset(OpWasmF64ConvertI64S)
  1215			v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
  1216			v0.AddArg(x)
  1217			v.AddArg(v0)
  1218			return true
  1219		}
  1220	}
  1221	func rewriteValueWasm_OpCvt64Fto32_0(v *Value) bool {
  1222		// match: (Cvt64Fto32 x)
  1223		// cond:
  1224		// result: (I64TruncSatF64S x)
  1225		for {
  1226			x := v.Args[0]
  1227			v.reset(OpWasmI64TruncSatF64S)
  1228			v.AddArg(x)
  1229			return true
  1230		}
  1231	}
  1232	func rewriteValueWasm_OpCvt64Fto32F_0(v *Value) bool {
  1233		// match: (Cvt64Fto32F x)
  1234		// cond:
  1235		// result: (LoweredRound32F x)
  1236		for {
  1237			x := v.Args[0]
  1238			v.reset(OpWasmLoweredRound32F)
  1239			v.AddArg(x)
  1240			return true
  1241		}
  1242	}
  1243	func rewriteValueWasm_OpCvt64Fto32U_0(v *Value) bool {
  1244		// match: (Cvt64Fto32U x)
  1245		// cond:
  1246		// result: (I64TruncSatF64U x)
  1247		for {
  1248			x := v.Args[0]
  1249			v.reset(OpWasmI64TruncSatF64U)
  1250			v.AddArg(x)
  1251			return true
  1252		}
  1253	}
  1254	func rewriteValueWasm_OpCvt64Fto64_0(v *Value) bool {
  1255		// match: (Cvt64Fto64 x)
  1256		// cond:
  1257		// result: (I64TruncSatF64S x)
  1258		for {
  1259			x := v.Args[0]
  1260			v.reset(OpWasmI64TruncSatF64S)
  1261			v.AddArg(x)
  1262			return true
  1263		}
  1264	}
  1265	func rewriteValueWasm_OpCvt64Fto64U_0(v *Value) bool {
  1266		// match: (Cvt64Fto64U x)
  1267		// cond:
  1268		// result: (I64TruncSatF64U x)
  1269		for {
  1270			x := v.Args[0]
  1271			v.reset(OpWasmI64TruncSatF64U)
  1272			v.AddArg(x)
  1273			return true
  1274		}
  1275	}
  1276	func rewriteValueWasm_OpCvt64Uto32F_0(v *Value) bool {
  1277		b := v.Block
  1278		typ := &b.Func.Config.Types
  1279		// match: (Cvt64Uto32F x)
  1280		// cond:
  1281		// result: (LoweredRound32F (F64ConvertI64U x))
  1282		for {
  1283			x := v.Args[0]
  1284			v.reset(OpWasmLoweredRound32F)
  1285			v0 := b.NewValue0(v.Pos, OpWasmF64ConvertI64U, typ.Float64)
  1286			v0.AddArg(x)
  1287			v.AddArg(v0)
  1288			return true
  1289		}
  1290	}
  1291	func rewriteValueWasm_OpCvt64Uto64F_0(v *Value) bool {
  1292		// match: (Cvt64Uto64F x)
  1293		// cond:
  1294		// result: (F64ConvertI64U x)
  1295		for {
  1296			x := v.Args[0]
  1297			v.reset(OpWasmF64ConvertI64U)
  1298			v.AddArg(x)
  1299			return true
  1300		}
  1301	}
  1302	func rewriteValueWasm_OpCvt64to32F_0(v *Value) bool {
  1303		b := v.Block
  1304		typ := &b.Func.Config.Types
  1305		// match: (Cvt64to32F x)
  1306		// cond:
  1307		// result: (LoweredRound32F (F64ConvertI64S x))
  1308		for {
  1309			x := v.Args[0]
  1310			v.reset(OpWasmLoweredRound32F)
  1311			v0 := b.NewValue0(v.Pos, OpWasmF64ConvertI64S, typ.Float64)
  1312			v0.AddArg(x)
  1313			v.AddArg(v0)
  1314			return true
  1315		}
  1316	}
  1317	func rewriteValueWasm_OpCvt64to64F_0(v *Value) bool {
  1318		// match: (Cvt64to64F x)
  1319		// cond:
  1320		// result: (F64ConvertI64S x)
  1321		for {
  1322			x := v.Args[0]
  1323			v.reset(OpWasmF64ConvertI64S)
  1324			v.AddArg(x)
  1325			return true
  1326		}
  1327	}
  1328	func rewriteValueWasm_OpDiv16_0(v *Value) bool {
  1329		b := v.Block
  1330		typ := &b.Func.Config.Types
  1331		// match: (Div16 x y)
  1332		// cond:
  1333		// result: (I64DivS (SignExt16to64 x) (SignExt16to64 y))
  1334		for {
  1335			y := v.Args[1]
  1336			x := v.Args[0]
  1337			v.reset(OpWasmI64DivS)
  1338			v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
  1339			v0.AddArg(x)
  1340			v.AddArg(v0)
  1341			v1 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
  1342			v1.AddArg(y)
  1343			v.AddArg(v1)
  1344			return true
  1345		}
  1346	}
  1347	func rewriteValueWasm_OpDiv16u_0(v *Value) bool {
  1348		b := v.Block
  1349		typ := &b.Func.Config.Types
  1350		// match: (Div16u x y)
  1351		// cond:
  1352		// result: (I64DivU (ZeroExt16to64 x) (ZeroExt16to64 y))
  1353		for {
  1354			y := v.Args[1]
  1355			x := v.Args[0]
  1356			v.reset(OpWasmI64DivU)
  1357			v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  1358			v0.AddArg(x)
  1359			v.AddArg(v0)
  1360			v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  1361			v1.AddArg(y)
  1362			v.AddArg(v1)
  1363			return true
  1364		}
  1365	}
  1366	func rewriteValueWasm_OpDiv32_0(v *Value) bool {
  1367		b := v.Block
  1368		typ := &b.Func.Config.Types
  1369		// match: (Div32 x y)
  1370		// cond:
  1371		// result: (I64DivS (SignExt32to64 x) (SignExt32to64 y))
  1372		for {
  1373			y := v.Args[1]
  1374			x := v.Args[0]
  1375			v.reset(OpWasmI64DivS)
  1376			v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
  1377			v0.AddArg(x)
  1378			v.AddArg(v0)
  1379			v1 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
  1380			v1.AddArg(y)
  1381			v.AddArg(v1)
  1382			return true
  1383		}
  1384	}
  1385	func rewriteValueWasm_OpDiv32F_0(v *Value) bool {
  1386		// match: (Div32F x y)
  1387		// cond:
  1388		// result: (F64Div x y)
  1389		for {
  1390			y := v.Args[1]
  1391			x := v.Args[0]
  1392			v.reset(OpWasmF64Div)
  1393			v.AddArg(x)
  1394			v.AddArg(y)
  1395			return true
  1396		}
  1397	}
  1398	func rewriteValueWasm_OpDiv32u_0(v *Value) bool {
  1399		b := v.Block
  1400		typ := &b.Func.Config.Types
  1401		// match: (Div32u x y)
  1402		// cond:
  1403		// result: (I64DivU (ZeroExt32to64 x) (ZeroExt32to64 y))
  1404		for {
  1405			y := v.Args[1]
  1406			x := v.Args[0]
  1407			v.reset(OpWasmI64DivU)
  1408			v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  1409			v0.AddArg(x)
  1410			v.AddArg(v0)
  1411			v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  1412			v1.AddArg(y)
  1413			v.AddArg(v1)
  1414			return true
  1415		}
  1416	}
  1417	func rewriteValueWasm_OpDiv64_0(v *Value) bool {
  1418		// match: (Div64 x y)
  1419		// cond:
  1420		// result: (I64DivS x y)
  1421		for {
  1422			y := v.Args[1]
  1423			x := v.Args[0]
  1424			v.reset(OpWasmI64DivS)
  1425			v.AddArg(x)
  1426			v.AddArg(y)
  1427			return true
  1428		}
  1429	}
  1430	func rewriteValueWasm_OpDiv64F_0(v *Value) bool {
  1431		// match: (Div64F x y)
  1432		// cond:
  1433		// result: (F64Div x y)
  1434		for {
  1435			y := v.Args[1]
  1436			x := v.Args[0]
  1437			v.reset(OpWasmF64Div)
  1438			v.AddArg(x)
  1439			v.AddArg(y)
  1440			return true
  1441		}
  1442	}
  1443	func rewriteValueWasm_OpDiv64u_0(v *Value) bool {
  1444		// match: (Div64u x y)
  1445		// cond:
  1446		// result: (I64DivU x y)
  1447		for {
  1448			y := v.Args[1]
  1449			x := v.Args[0]
  1450			v.reset(OpWasmI64DivU)
  1451			v.AddArg(x)
  1452			v.AddArg(y)
  1453			return true
  1454		}
  1455	}
  1456	func rewriteValueWasm_OpDiv8_0(v *Value) bool {
  1457		b := v.Block
  1458		typ := &b.Func.Config.Types
  1459		// match: (Div8 x y)
  1460		// cond:
  1461		// result: (I64DivS (SignExt8to64 x) (SignExt8to64 y))
  1462		for {
  1463			y := v.Args[1]
  1464			x := v.Args[0]
  1465			v.reset(OpWasmI64DivS)
  1466			v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
  1467			v0.AddArg(x)
  1468			v.AddArg(v0)
  1469			v1 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
  1470			v1.AddArg(y)
  1471			v.AddArg(v1)
  1472			return true
  1473		}
  1474	}
  1475	func rewriteValueWasm_OpDiv8u_0(v *Value) bool {
  1476		b := v.Block
  1477		typ := &b.Func.Config.Types
  1478		// match: (Div8u x y)
  1479		// cond:
  1480		// result: (I64DivU (ZeroExt8to64 x) (ZeroExt8to64 y))
  1481		for {
  1482			y := v.Args[1]
  1483			x := v.Args[0]
  1484			v.reset(OpWasmI64DivU)
  1485			v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  1486			v0.AddArg(x)
  1487			v.AddArg(v0)
  1488			v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  1489			v1.AddArg(y)
  1490			v.AddArg(v1)
  1491			return true
  1492		}
  1493	}
  1494	func rewriteValueWasm_OpEq16_0(v *Value) bool {
  1495		b := v.Block
  1496		typ := &b.Func.Config.Types
  1497		// match: (Eq16 x y)
  1498		// cond:
  1499		// result: (I64Eq (ZeroExt16to64 x) (ZeroExt16to64 y))
  1500		for {
  1501			y := v.Args[1]
  1502			x := v.Args[0]
  1503			v.reset(OpWasmI64Eq)
  1504			v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  1505			v0.AddArg(x)
  1506			v.AddArg(v0)
  1507			v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  1508			v1.AddArg(y)
  1509			v.AddArg(v1)
  1510			return true
  1511		}
  1512	}
  1513	func rewriteValueWasm_OpEq32_0(v *Value) bool {
  1514		b := v.Block
  1515		typ := &b.Func.Config.Types
  1516		// match: (Eq32 x y)
  1517		// cond:
  1518		// result: (I64Eq (ZeroExt32to64 x) (ZeroExt32to64 y))
  1519		for {
  1520			y := v.Args[1]
  1521			x := v.Args[0]
  1522			v.reset(OpWasmI64Eq)
  1523			v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  1524			v0.AddArg(x)
  1525			v.AddArg(v0)
  1526			v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  1527			v1.AddArg(y)
  1528			v.AddArg(v1)
  1529			return true
  1530		}
  1531	}
  1532	func rewriteValueWasm_OpEq32F_0(v *Value) bool {
  1533		b := v.Block
  1534		typ := &b.Func.Config.Types
  1535		// match: (Eq32F x y)
  1536		// cond:
  1537		// result: (F64Eq (LoweredRound32F x) (LoweredRound32F y))
  1538		for {
  1539			y := v.Args[1]
  1540			x := v.Args[0]
  1541			v.reset(OpWasmF64Eq)
  1542			v0 := b.NewValue0(v.Pos, OpWasmLoweredRound32F, typ.Float32)
  1543			v0.AddArg(x)
  1544			v.AddArg(v0)
  1545			v1 := b.NewValue0(v.Pos, OpWasmLoweredRound32F, typ.Float32)
  1546			v1.AddArg(y)
  1547			v.AddArg(v1)
  1548			return true
  1549		}
  1550	}
  1551	func rewriteValueWasm_OpEq64_0(v *Value) bool {
  1552		// match: (Eq64 x y)
  1553		// cond:
  1554		// result: (I64Eq x y)
  1555		for {
  1556			y := v.Args[1]
  1557			x := v.Args[0]
  1558			v.reset(OpWasmI64Eq)
  1559			v.AddArg(x)
  1560			v.AddArg(y)
  1561			return true
  1562		}
  1563	}
  1564	func rewriteValueWasm_OpEq64F_0(v *Value) bool {
  1565		// match: (Eq64F x y)
  1566		// cond:
  1567		// result: (F64Eq x y)
  1568		for {
  1569			y := v.Args[1]
  1570			x := v.Args[0]
  1571			v.reset(OpWasmF64Eq)
  1572			v.AddArg(x)
  1573			v.AddArg(y)
  1574			return true
  1575		}
  1576	}
  1577	func rewriteValueWasm_OpEq8_0(v *Value) bool {
  1578		b := v.Block
  1579		typ := &b.Func.Config.Types
  1580		// match: (Eq8 x y)
  1581		// cond:
  1582		// result: (I64Eq (ZeroExt8to64 x) (ZeroExt8to64 y))
  1583		for {
  1584			y := v.Args[1]
  1585			x := v.Args[0]
  1586			v.reset(OpWasmI64Eq)
  1587			v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  1588			v0.AddArg(x)
  1589			v.AddArg(v0)
  1590			v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  1591			v1.AddArg(y)
  1592			v.AddArg(v1)
  1593			return true
  1594		}
  1595	}
  1596	func rewriteValueWasm_OpEqB_0(v *Value) bool {
  1597		// match: (EqB x y)
  1598		// cond:
  1599		// result: (I64Eq x y)
  1600		for {
  1601			y := v.Args[1]
  1602			x := v.Args[0]
  1603			v.reset(OpWasmI64Eq)
  1604			v.AddArg(x)
  1605			v.AddArg(y)
  1606			return true
  1607		}
  1608	}
  1609	func rewriteValueWasm_OpEqPtr_0(v *Value) bool {
  1610		// match: (EqPtr x y)
  1611		// cond:
  1612		// result: (I64Eq x y)
  1613		for {
  1614			y := v.Args[1]
  1615			x := v.Args[0]
  1616			v.reset(OpWasmI64Eq)
  1617			v.AddArg(x)
  1618			v.AddArg(y)
  1619			return true
  1620		}
  1621	}
  1622	func rewriteValueWasm_OpFloor_0(v *Value) bool {
  1623		// match: (Floor x)
  1624		// cond:
  1625		// result: (F64Floor x)
  1626		for {
  1627			x := v.Args[0]
  1628			v.reset(OpWasmF64Floor)
  1629			v.AddArg(x)
  1630			return true
  1631		}
  1632	}
  1633	func rewriteValueWasm_OpGeq16_0(v *Value) bool {
  1634		b := v.Block
  1635		typ := &b.Func.Config.Types
  1636		// match: (Geq16 x y)
  1637		// cond:
  1638		// result: (I64GeS (SignExt16to64 x) (SignExt16to64 y))
  1639		for {
  1640			y := v.Args[1]
  1641			x := v.Args[0]
  1642			v.reset(OpWasmI64GeS)
  1643			v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
  1644			v0.AddArg(x)
  1645			v.AddArg(v0)
  1646			v1 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
  1647			v1.AddArg(y)
  1648			v.AddArg(v1)
  1649			return true
  1650		}
  1651	}
  1652	func rewriteValueWasm_OpGeq16U_0(v *Value) bool {
  1653		b := v.Block
  1654		typ := &b.Func.Config.Types
  1655		// match: (Geq16U x y)
  1656		// cond:
  1657		// result: (I64GeU (ZeroExt16to64 x) (ZeroExt16to64 y))
  1658		for {
  1659			y := v.Args[1]
  1660			x := v.Args[0]
  1661			v.reset(OpWasmI64GeU)
  1662			v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  1663			v0.AddArg(x)
  1664			v.AddArg(v0)
  1665			v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  1666			v1.AddArg(y)
  1667			v.AddArg(v1)
  1668			return true
  1669		}
  1670	}
  1671	func rewriteValueWasm_OpGeq32_0(v *Value) bool {
  1672		b := v.Block
  1673		typ := &b.Func.Config.Types
  1674		// match: (Geq32 x y)
  1675		// cond:
  1676		// result: (I64GeS (SignExt32to64 x) (SignExt32to64 y))
  1677		for {
  1678			y := v.Args[1]
  1679			x := v.Args[0]
  1680			v.reset(OpWasmI64GeS)
  1681			v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
  1682			v0.AddArg(x)
  1683			v.AddArg(v0)
  1684			v1 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
  1685			v1.AddArg(y)
  1686			v.AddArg(v1)
  1687			return true
  1688		}
  1689	}
  1690	func rewriteValueWasm_OpGeq32F_0(v *Value) bool {
  1691		b := v.Block
  1692		typ := &b.Func.Config.Types
  1693		// match: (Geq32F x y)
  1694		// cond:
  1695		// result: (F64Ge (LoweredRound32F x) (LoweredRound32F y))
  1696		for {
  1697			y := v.Args[1]
  1698			x := v.Args[0]
  1699			v.reset(OpWasmF64Ge)
  1700			v0 := b.NewValue0(v.Pos, OpWasmLoweredRound32F, typ.Float32)
  1701			v0.AddArg(x)
  1702			v.AddArg(v0)
  1703			v1 := b.NewValue0(v.Pos, OpWasmLoweredRound32F, typ.Float32)
  1704			v1.AddArg(y)
  1705			v.AddArg(v1)
  1706			return true
  1707		}
  1708	}
  1709	func rewriteValueWasm_OpGeq32U_0(v *Value) bool {
  1710		b := v.Block
  1711		typ := &b.Func.Config.Types
  1712		// match: (Geq32U x y)
  1713		// cond:
  1714		// result: (I64GeU (ZeroExt32to64 x) (ZeroExt32to64 y))
  1715		for {
  1716			y := v.Args[1]
  1717			x := v.Args[0]
  1718			v.reset(OpWasmI64GeU)
  1719			v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  1720			v0.AddArg(x)
  1721			v.AddArg(v0)
  1722			v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  1723			v1.AddArg(y)
  1724			v.AddArg(v1)
  1725			return true
  1726		}
  1727	}
  1728	func rewriteValueWasm_OpGeq64_0(v *Value) bool {
  1729		// match: (Geq64 x y)
  1730		// cond:
  1731		// result: (I64GeS x y)
  1732		for {
  1733			y := v.Args[1]
  1734			x := v.Args[0]
  1735			v.reset(OpWasmI64GeS)
  1736			v.AddArg(x)
  1737			v.AddArg(y)
  1738			return true
  1739		}
  1740	}
  1741	func rewriteValueWasm_OpGeq64F_0(v *Value) bool {
  1742		// match: (Geq64F x y)
  1743		// cond:
  1744		// result: (F64Ge x y)
  1745		for {
  1746			y := v.Args[1]
  1747			x := v.Args[0]
  1748			v.reset(OpWasmF64Ge)
  1749			v.AddArg(x)
  1750			v.AddArg(y)
  1751			return true
  1752		}
  1753	}
  1754	func rewriteValueWasm_OpGeq64U_0(v *Value) bool {
  1755		// match: (Geq64U x y)
  1756		// cond:
  1757		// result: (I64GeU x y)
  1758		for {
  1759			y := v.Args[1]
  1760			x := v.Args[0]
  1761			v.reset(OpWasmI64GeU)
  1762			v.AddArg(x)
  1763			v.AddArg(y)
  1764			return true
  1765		}
  1766	}
  1767	func rewriteValueWasm_OpGeq8_0(v *Value) bool {
  1768		b := v.Block
  1769		typ := &b.Func.Config.Types
  1770		// match: (Geq8 x y)
  1771		// cond:
  1772		// result: (I64GeS (SignExt8to64 x) (SignExt8to64 y))
  1773		for {
  1774			y := v.Args[1]
  1775			x := v.Args[0]
  1776			v.reset(OpWasmI64GeS)
  1777			v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
  1778			v0.AddArg(x)
  1779			v.AddArg(v0)
  1780			v1 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
  1781			v1.AddArg(y)
  1782			v.AddArg(v1)
  1783			return true
  1784		}
  1785	}
  1786	func rewriteValueWasm_OpGeq8U_0(v *Value) bool {
  1787		b := v.Block
  1788		typ := &b.Func.Config.Types
  1789		// match: (Geq8U x y)
  1790		// cond:
  1791		// result: (I64GeU (ZeroExt8to64 x) (ZeroExt8to64 y))
  1792		for {
  1793			y := v.Args[1]
  1794			x := v.Args[0]
  1795			v.reset(OpWasmI64GeU)
  1796			v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  1797			v0.AddArg(x)
  1798			v.AddArg(v0)
  1799			v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  1800			v1.AddArg(y)
  1801			v.AddArg(v1)
  1802			return true
  1803		}
  1804	}
  1805	func rewriteValueWasm_OpGetCallerPC_0(v *Value) bool {
  1806		// match: (GetCallerPC)
  1807		// cond:
  1808		// result: (LoweredGetCallerPC)
  1809		for {
  1810			v.reset(OpWasmLoweredGetCallerPC)
  1811			return true
  1812		}
  1813	}
  1814	func rewriteValueWasm_OpGetCallerSP_0(v *Value) bool {
  1815		// match: (GetCallerSP)
  1816		// cond:
  1817		// result: (LoweredGetCallerSP)
  1818		for {
  1819			v.reset(OpWasmLoweredGetCallerSP)
  1820			return true
  1821		}
  1822	}
  1823	func rewriteValueWasm_OpGetClosurePtr_0(v *Value) bool {
  1824		// match: (GetClosurePtr)
  1825		// cond:
  1826		// result: (LoweredGetClosurePtr)
  1827		for {
  1828			v.reset(OpWasmLoweredGetClosurePtr)
  1829			return true
  1830		}
  1831	}
  1832	func rewriteValueWasm_OpGreater16_0(v *Value) bool {
  1833		b := v.Block
  1834		typ := &b.Func.Config.Types
  1835		// match: (Greater16 x y)
  1836		// cond:
  1837		// result: (I64GtS (SignExt16to64 x) (SignExt16to64 y))
  1838		for {
  1839			y := v.Args[1]
  1840			x := v.Args[0]
  1841			v.reset(OpWasmI64GtS)
  1842			v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
  1843			v0.AddArg(x)
  1844			v.AddArg(v0)
  1845			v1 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
  1846			v1.AddArg(y)
  1847			v.AddArg(v1)
  1848			return true
  1849		}
  1850	}
  1851	func rewriteValueWasm_OpGreater16U_0(v *Value) bool {
  1852		b := v.Block
  1853		typ := &b.Func.Config.Types
  1854		// match: (Greater16U x y)
  1855		// cond:
  1856		// result: (I64GtU (ZeroExt16to64 x) (ZeroExt16to64 y))
  1857		for {
  1858			y := v.Args[1]
  1859			x := v.Args[0]
  1860			v.reset(OpWasmI64GtU)
  1861			v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  1862			v0.AddArg(x)
  1863			v.AddArg(v0)
  1864			v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  1865			v1.AddArg(y)
  1866			v.AddArg(v1)
  1867			return true
  1868		}
  1869	}
  1870	func rewriteValueWasm_OpGreater32_0(v *Value) bool {
  1871		b := v.Block
  1872		typ := &b.Func.Config.Types
  1873		// match: (Greater32 x y)
  1874		// cond:
  1875		// result: (I64GtS (SignExt32to64 x) (SignExt32to64 y))
  1876		for {
  1877			y := v.Args[1]
  1878			x := v.Args[0]
  1879			v.reset(OpWasmI64GtS)
  1880			v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
  1881			v0.AddArg(x)
  1882			v.AddArg(v0)
  1883			v1 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
  1884			v1.AddArg(y)
  1885			v.AddArg(v1)
  1886			return true
  1887		}
  1888	}
  1889	func rewriteValueWasm_OpGreater32F_0(v *Value) bool {
  1890		b := v.Block
  1891		typ := &b.Func.Config.Types
  1892		// match: (Greater32F x y)
  1893		// cond:
  1894		// result: (F64Gt (LoweredRound32F x) (LoweredRound32F y))
  1895		for {
  1896			y := v.Args[1]
  1897			x := v.Args[0]
  1898			v.reset(OpWasmF64Gt)
  1899			v0 := b.NewValue0(v.Pos, OpWasmLoweredRound32F, typ.Float32)
  1900			v0.AddArg(x)
  1901			v.AddArg(v0)
  1902			v1 := b.NewValue0(v.Pos, OpWasmLoweredRound32F, typ.Float32)
  1903			v1.AddArg(y)
  1904			v.AddArg(v1)
  1905			return true
  1906		}
  1907	}
  1908	func rewriteValueWasm_OpGreater32U_0(v *Value) bool {
  1909		b := v.Block
  1910		typ := &b.Func.Config.Types
  1911		// match: (Greater32U x y)
  1912		// cond:
  1913		// result: (I64GtU (ZeroExt32to64 x) (ZeroExt32to64 y))
  1914		for {
  1915			y := v.Args[1]
  1916			x := v.Args[0]
  1917			v.reset(OpWasmI64GtU)
  1918			v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  1919			v0.AddArg(x)
  1920			v.AddArg(v0)
  1921			v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  1922			v1.AddArg(y)
  1923			v.AddArg(v1)
  1924			return true
  1925		}
  1926	}
  1927	func rewriteValueWasm_OpGreater64_0(v *Value) bool {
  1928		// match: (Greater64 x y)
  1929		// cond:
  1930		// result: (I64GtS x y)
  1931		for {
  1932			y := v.Args[1]
  1933			x := v.Args[0]
  1934			v.reset(OpWasmI64GtS)
  1935			v.AddArg(x)
  1936			v.AddArg(y)
  1937			return true
  1938		}
  1939	}
  1940	func rewriteValueWasm_OpGreater64F_0(v *Value) bool {
  1941		// match: (Greater64F x y)
  1942		// cond:
  1943		// result: (F64Gt x y)
  1944		for {
  1945			y := v.Args[1]
  1946			x := v.Args[0]
  1947			v.reset(OpWasmF64Gt)
  1948			v.AddArg(x)
  1949			v.AddArg(y)
  1950			return true
  1951		}
  1952	}
  1953	func rewriteValueWasm_OpGreater64U_0(v *Value) bool {
  1954		// match: (Greater64U x y)
  1955		// cond:
  1956		// result: (I64GtU x y)
  1957		for {
  1958			y := v.Args[1]
  1959			x := v.Args[0]
  1960			v.reset(OpWasmI64GtU)
  1961			v.AddArg(x)
  1962			v.AddArg(y)
  1963			return true
  1964		}
  1965	}
  1966	func rewriteValueWasm_OpGreater8_0(v *Value) bool {
  1967		b := v.Block
  1968		typ := &b.Func.Config.Types
  1969		// match: (Greater8 x y)
  1970		// cond:
  1971		// result: (I64GtS (SignExt8to64 x) (SignExt8to64 y))
  1972		for {
  1973			y := v.Args[1]
  1974			x := v.Args[0]
  1975			v.reset(OpWasmI64GtS)
  1976			v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
  1977			v0.AddArg(x)
  1978			v.AddArg(v0)
  1979			v1 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
  1980			v1.AddArg(y)
  1981			v.AddArg(v1)
  1982			return true
  1983		}
  1984	}
  1985	func rewriteValueWasm_OpGreater8U_0(v *Value) bool {
  1986		b := v.Block
  1987		typ := &b.Func.Config.Types
  1988		// match: (Greater8U x y)
  1989		// cond:
  1990		// result: (I64GtU (ZeroExt8to64 x) (ZeroExt8to64 y))
  1991		for {
  1992			y := v.Args[1]
  1993			x := v.Args[0]
  1994			v.reset(OpWasmI64GtU)
  1995			v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  1996			v0.AddArg(x)
  1997			v.AddArg(v0)
  1998			v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  1999			v1.AddArg(y)
  2000			v.AddArg(v1)
  2001			return true
  2002		}
  2003	}
  2004	func rewriteValueWasm_OpInterCall_0(v *Value) bool {
  2005		// match: (InterCall [argwid] entry mem)
  2006		// cond:
  2007		// result: (LoweredInterCall [argwid] entry mem)
  2008		for {
  2009			argwid := v.AuxInt
  2010			mem := v.Args[1]
  2011			entry := v.Args[0]
  2012			v.reset(OpWasmLoweredInterCall)
  2013			v.AuxInt = argwid
  2014			v.AddArg(entry)
  2015			v.AddArg(mem)
  2016			return true
  2017		}
  2018	}
  2019	func rewriteValueWasm_OpIsInBounds_0(v *Value) bool {
  2020		// match: (IsInBounds idx len)
  2021		// cond:
  2022		// result: (I64LtU idx len)
  2023		for {
  2024			len := v.Args[1]
  2025			idx := v.Args[0]
  2026			v.reset(OpWasmI64LtU)
  2027			v.AddArg(idx)
  2028			v.AddArg(len)
  2029			return true
  2030		}
  2031	}
  2032	func rewriteValueWasm_OpIsNonNil_0(v *Value) bool {
  2033		b := v.Block
  2034		typ := &b.Func.Config.Types
  2035		// match: (IsNonNil p)
  2036		// cond:
  2037		// result: (I64Eqz (I64Eqz p))
  2038		for {
  2039			p := v.Args[0]
  2040			v.reset(OpWasmI64Eqz)
  2041			v0 := b.NewValue0(v.Pos, OpWasmI64Eqz, typ.Bool)
  2042			v0.AddArg(p)
  2043			v.AddArg(v0)
  2044			return true
  2045		}
  2046	}
  2047	func rewriteValueWasm_OpIsSliceInBounds_0(v *Value) bool {
  2048		// match: (IsSliceInBounds idx len)
  2049		// cond:
  2050		// result: (I64LeU idx len)
  2051		for {
  2052			len := v.Args[1]
  2053			idx := v.Args[0]
  2054			v.reset(OpWasmI64LeU)
  2055			v.AddArg(idx)
  2056			v.AddArg(len)
  2057			return true
  2058		}
  2059	}
  2060	func rewriteValueWasm_OpLeq16_0(v *Value) bool {
  2061		b := v.Block
  2062		typ := &b.Func.Config.Types
  2063		// match: (Leq16 x y)
  2064		// cond:
  2065		// result: (I64LeS (SignExt16to64 x) (SignExt16to64 y))
  2066		for {
  2067			y := v.Args[1]
  2068			x := v.Args[0]
  2069			v.reset(OpWasmI64LeS)
  2070			v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
  2071			v0.AddArg(x)
  2072			v.AddArg(v0)
  2073			v1 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
  2074			v1.AddArg(y)
  2075			v.AddArg(v1)
  2076			return true
  2077		}
  2078	}
  2079	func rewriteValueWasm_OpLeq16U_0(v *Value) bool {
  2080		b := v.Block
  2081		typ := &b.Func.Config.Types
  2082		// match: (Leq16U x y)
  2083		// cond:
  2084		// result: (I64LeU (ZeroExt16to64 x) (ZeroExt16to64 y))
  2085		for {
  2086			y := v.Args[1]
  2087			x := v.Args[0]
  2088			v.reset(OpWasmI64LeU)
  2089			v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  2090			v0.AddArg(x)
  2091			v.AddArg(v0)
  2092			v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  2093			v1.AddArg(y)
  2094			v.AddArg(v1)
  2095			return true
  2096		}
  2097	}
  2098	func rewriteValueWasm_OpLeq32_0(v *Value) bool {
  2099		b := v.Block
  2100		typ := &b.Func.Config.Types
  2101		// match: (Leq32 x y)
  2102		// cond:
  2103		// result: (I64LeS (SignExt32to64 x) (SignExt32to64 y))
  2104		for {
  2105			y := v.Args[1]
  2106			x := v.Args[0]
  2107			v.reset(OpWasmI64LeS)
  2108			v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
  2109			v0.AddArg(x)
  2110			v.AddArg(v0)
  2111			v1 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
  2112			v1.AddArg(y)
  2113			v.AddArg(v1)
  2114			return true
  2115		}
  2116	}
  2117	func rewriteValueWasm_OpLeq32F_0(v *Value) bool {
  2118		b := v.Block
  2119		typ := &b.Func.Config.Types
  2120		// match: (Leq32F x y)
  2121		// cond:
  2122		// result: (F64Le (LoweredRound32F x) (LoweredRound32F y))
  2123		for {
  2124			y := v.Args[1]
  2125			x := v.Args[0]
  2126			v.reset(OpWasmF64Le)
  2127			v0 := b.NewValue0(v.Pos, OpWasmLoweredRound32F, typ.Float32)
  2128			v0.AddArg(x)
  2129			v.AddArg(v0)
  2130			v1 := b.NewValue0(v.Pos, OpWasmLoweredRound32F, typ.Float32)
  2131			v1.AddArg(y)
  2132			v.AddArg(v1)
  2133			return true
  2134		}
  2135	}
  2136	func rewriteValueWasm_OpLeq32U_0(v *Value) bool {
  2137		b := v.Block
  2138		typ := &b.Func.Config.Types
  2139		// match: (Leq32U x y)
  2140		// cond:
  2141		// result: (I64LeU (ZeroExt32to64 x) (ZeroExt32to64 y))
  2142		for {
  2143			y := v.Args[1]
  2144			x := v.Args[0]
  2145			v.reset(OpWasmI64LeU)
  2146			v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  2147			v0.AddArg(x)
  2148			v.AddArg(v0)
  2149			v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  2150			v1.AddArg(y)
  2151			v.AddArg(v1)
  2152			return true
  2153		}
  2154	}
  2155	func rewriteValueWasm_OpLeq64_0(v *Value) bool {
  2156		// match: (Leq64 x y)
  2157		// cond:
  2158		// result: (I64LeS x y)
  2159		for {
  2160			y := v.Args[1]
  2161			x := v.Args[0]
  2162			v.reset(OpWasmI64LeS)
  2163			v.AddArg(x)
  2164			v.AddArg(y)
  2165			return true
  2166		}
  2167	}
  2168	func rewriteValueWasm_OpLeq64F_0(v *Value) bool {
  2169		// match: (Leq64F x y)
  2170		// cond:
  2171		// result: (F64Le x y)
  2172		for {
  2173			y := v.Args[1]
  2174			x := v.Args[0]
  2175			v.reset(OpWasmF64Le)
  2176			v.AddArg(x)
  2177			v.AddArg(y)
  2178			return true
  2179		}
  2180	}
  2181	func rewriteValueWasm_OpLeq64U_0(v *Value) bool {
  2182		// match: (Leq64U x y)
  2183		// cond:
  2184		// result: (I64LeU x y)
  2185		for {
  2186			y := v.Args[1]
  2187			x := v.Args[0]
  2188			v.reset(OpWasmI64LeU)
  2189			v.AddArg(x)
  2190			v.AddArg(y)
  2191			return true
  2192		}
  2193	}
  2194	func rewriteValueWasm_OpLeq8_0(v *Value) bool {
  2195		b := v.Block
  2196		typ := &b.Func.Config.Types
  2197		// match: (Leq8 x y)
  2198		// cond:
  2199		// result: (I64LeS (SignExt8to64 x) (SignExt8to64 y))
  2200		for {
  2201			y := v.Args[1]
  2202			x := v.Args[0]
  2203			v.reset(OpWasmI64LeS)
  2204			v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
  2205			v0.AddArg(x)
  2206			v.AddArg(v0)
  2207			v1 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
  2208			v1.AddArg(y)
  2209			v.AddArg(v1)
  2210			return true
  2211		}
  2212	}
  2213	func rewriteValueWasm_OpLeq8U_0(v *Value) bool {
  2214		b := v.Block
  2215		typ := &b.Func.Config.Types
  2216		// match: (Leq8U x y)
  2217		// cond:
  2218		// result: (I64LeU (ZeroExt8to64 x) (ZeroExt8to64 y))
  2219		for {
  2220			y := v.Args[1]
  2221			x := v.Args[0]
  2222			v.reset(OpWasmI64LeU)
  2223			v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  2224			v0.AddArg(x)
  2225			v.AddArg(v0)
  2226			v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  2227			v1.AddArg(y)
  2228			v.AddArg(v1)
  2229			return true
  2230		}
  2231	}
  2232	func rewriteValueWasm_OpLess16_0(v *Value) bool {
  2233		b := v.Block
  2234		typ := &b.Func.Config.Types
  2235		// match: (Less16 x y)
  2236		// cond:
  2237		// result: (I64LtS (SignExt16to64 x) (SignExt16to64 y))
  2238		for {
  2239			y := v.Args[1]
  2240			x := v.Args[0]
  2241			v.reset(OpWasmI64LtS)
  2242			v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
  2243			v0.AddArg(x)
  2244			v.AddArg(v0)
  2245			v1 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
  2246			v1.AddArg(y)
  2247			v.AddArg(v1)
  2248			return true
  2249		}
  2250	}
  2251	func rewriteValueWasm_OpLess16U_0(v *Value) bool {
  2252		b := v.Block
  2253		typ := &b.Func.Config.Types
  2254		// match: (Less16U x y)
  2255		// cond:
  2256		// result: (I64LtU (ZeroExt16to64 x) (ZeroExt16to64 y))
  2257		for {
  2258			y := v.Args[1]
  2259			x := v.Args[0]
  2260			v.reset(OpWasmI64LtU)
  2261			v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  2262			v0.AddArg(x)
  2263			v.AddArg(v0)
  2264			v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  2265			v1.AddArg(y)
  2266			v.AddArg(v1)
  2267			return true
  2268		}
  2269	}
  2270	func rewriteValueWasm_OpLess32_0(v *Value) bool {
  2271		b := v.Block
  2272		typ := &b.Func.Config.Types
  2273		// match: (Less32 x y)
  2274		// cond:
  2275		// result: (I64LtS (SignExt32to64 x) (SignExt32to64 y))
  2276		for {
  2277			y := v.Args[1]
  2278			x := v.Args[0]
  2279			v.reset(OpWasmI64LtS)
  2280			v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
  2281			v0.AddArg(x)
  2282			v.AddArg(v0)
  2283			v1 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
  2284			v1.AddArg(y)
  2285			v.AddArg(v1)
  2286			return true
  2287		}
  2288	}
  2289	func rewriteValueWasm_OpLess32F_0(v *Value) bool {
  2290		b := v.Block
  2291		typ := &b.Func.Config.Types
  2292		// match: (Less32F x y)
  2293		// cond:
  2294		// result: (F64Lt (LoweredRound32F x) (LoweredRound32F y))
  2295		for {
  2296			y := v.Args[1]
  2297			x := v.Args[0]
  2298			v.reset(OpWasmF64Lt)
  2299			v0 := b.NewValue0(v.Pos, OpWasmLoweredRound32F, typ.Float32)
  2300			v0.AddArg(x)
  2301			v.AddArg(v0)
  2302			v1 := b.NewValue0(v.Pos, OpWasmLoweredRound32F, typ.Float32)
  2303			v1.AddArg(y)
  2304			v.AddArg(v1)
  2305			return true
  2306		}
  2307	}
  2308	func rewriteValueWasm_OpLess32U_0(v *Value) bool {
  2309		b := v.Block
  2310		typ := &b.Func.Config.Types
  2311		// match: (Less32U x y)
  2312		// cond:
  2313		// result: (I64LtU (ZeroExt32to64 x) (ZeroExt32to64 y))
  2314		for {
  2315			y := v.Args[1]
  2316			x := v.Args[0]
  2317			v.reset(OpWasmI64LtU)
  2318			v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  2319			v0.AddArg(x)
  2320			v.AddArg(v0)
  2321			v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  2322			v1.AddArg(y)
  2323			v.AddArg(v1)
  2324			return true
  2325		}
  2326	}
  2327	func rewriteValueWasm_OpLess64_0(v *Value) bool {
  2328		// match: (Less64 x y)
  2329		// cond:
  2330		// result: (I64LtS x y)
  2331		for {
  2332			y := v.Args[1]
  2333			x := v.Args[0]
  2334			v.reset(OpWasmI64LtS)
  2335			v.AddArg(x)
  2336			v.AddArg(y)
  2337			return true
  2338		}
  2339	}
  2340	func rewriteValueWasm_OpLess64F_0(v *Value) bool {
  2341		// match: (Less64F x y)
  2342		// cond:
  2343		// result: (F64Lt x y)
  2344		for {
  2345			y := v.Args[1]
  2346			x := v.Args[0]
  2347			v.reset(OpWasmF64Lt)
  2348			v.AddArg(x)
  2349			v.AddArg(y)
  2350			return true
  2351		}
  2352	}
  2353	func rewriteValueWasm_OpLess64U_0(v *Value) bool {
  2354		// match: (Less64U x y)
  2355		// cond:
  2356		// result: (I64LtU x y)
  2357		for {
  2358			y := v.Args[1]
  2359			x := v.Args[0]
  2360			v.reset(OpWasmI64LtU)
  2361			v.AddArg(x)
  2362			v.AddArg(y)
  2363			return true
  2364		}
  2365	}
  2366	func rewriteValueWasm_OpLess8_0(v *Value) bool {
  2367		b := v.Block
  2368		typ := &b.Func.Config.Types
  2369		// match: (Less8 x y)
  2370		// cond:
  2371		// result: (I64LtS (SignExt8to64 x) (SignExt8to64 y))
  2372		for {
  2373			y := v.Args[1]
  2374			x := v.Args[0]
  2375			v.reset(OpWasmI64LtS)
  2376			v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
  2377			v0.AddArg(x)
  2378			v.AddArg(v0)
  2379			v1 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
  2380			v1.AddArg(y)
  2381			v.AddArg(v1)
  2382			return true
  2383		}
  2384	}
  2385	func rewriteValueWasm_OpLess8U_0(v *Value) bool {
  2386		b := v.Block
  2387		typ := &b.Func.Config.Types
  2388		// match: (Less8U x y)
  2389		// cond:
  2390		// result: (I64LtU (ZeroExt8to64 x) (ZeroExt8to64 y))
  2391		for {
  2392			y := v.Args[1]
  2393			x := v.Args[0]
  2394			v.reset(OpWasmI64LtU)
  2395			v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  2396			v0.AddArg(x)
  2397			v.AddArg(v0)
  2398			v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  2399			v1.AddArg(y)
  2400			v.AddArg(v1)
  2401			return true
  2402		}
  2403	}
  2404	func rewriteValueWasm_OpLoad_0(v *Value) bool {
  2405		// match: (Load <t> ptr mem)
  2406		// cond: is32BitFloat(t)
  2407		// result: (F32Load ptr mem)
  2408		for {
  2409			t := v.Type
  2410			mem := v.Args[1]
  2411			ptr := v.Args[0]
  2412			if !(is32BitFloat(t)) {
  2413				break
  2414			}
  2415			v.reset(OpWasmF32Load)
  2416			v.AddArg(ptr)
  2417			v.AddArg(mem)
  2418			return true
  2419		}
  2420		// match: (Load <t> ptr mem)
  2421		// cond: is64BitFloat(t)
  2422		// result: (F64Load ptr mem)
  2423		for {
  2424			t := v.Type
  2425			mem := v.Args[1]
  2426			ptr := v.Args[0]
  2427			if !(is64BitFloat(t)) {
  2428				break
  2429			}
  2430			v.reset(OpWasmF64Load)
  2431			v.AddArg(ptr)
  2432			v.AddArg(mem)
  2433			return true
  2434		}
  2435		// match: (Load <t> ptr mem)
  2436		// cond: t.Size() == 8
  2437		// result: (I64Load ptr mem)
  2438		for {
  2439			t := v.Type
  2440			mem := v.Args[1]
  2441			ptr := v.Args[0]
  2442			if !(t.Size() == 8) {
  2443				break
  2444			}
  2445			v.reset(OpWasmI64Load)
  2446			v.AddArg(ptr)
  2447			v.AddArg(mem)
  2448			return true
  2449		}
  2450		// match: (Load <t> ptr mem)
  2451		// cond: t.Size() == 4 && !t.IsSigned()
  2452		// result: (I64Load32U ptr mem)
  2453		for {
  2454			t := v.Type
  2455			mem := v.Args[1]
  2456			ptr := v.Args[0]
  2457			if !(t.Size() == 4 && !t.IsSigned()) {
  2458				break
  2459			}
  2460			v.reset(OpWasmI64Load32U)
  2461			v.AddArg(ptr)
  2462			v.AddArg(mem)
  2463			return true
  2464		}
  2465		// match: (Load <t> ptr mem)
  2466		// cond: t.Size() == 4 && t.IsSigned()
  2467		// result: (I64Load32S ptr mem)
  2468		for {
  2469			t := v.Type
  2470			mem := v.Args[1]
  2471			ptr := v.Args[0]
  2472			if !(t.Size() == 4 && t.IsSigned()) {
  2473				break
  2474			}
  2475			v.reset(OpWasmI64Load32S)
  2476			v.AddArg(ptr)
  2477			v.AddArg(mem)
  2478			return true
  2479		}
  2480		// match: (Load <t> ptr mem)
  2481		// cond: t.Size() == 2 && !t.IsSigned()
  2482		// result: (I64Load16U ptr mem)
  2483		for {
  2484			t := v.Type
  2485			mem := v.Args[1]
  2486			ptr := v.Args[0]
  2487			if !(t.Size() == 2 && !t.IsSigned()) {
  2488				break
  2489			}
  2490			v.reset(OpWasmI64Load16U)
  2491			v.AddArg(ptr)
  2492			v.AddArg(mem)
  2493			return true
  2494		}
  2495		// match: (Load <t> ptr mem)
  2496		// cond: t.Size() == 2 && t.IsSigned()
  2497		// result: (I64Load16S ptr mem)
  2498		for {
  2499			t := v.Type
  2500			mem := v.Args[1]
  2501			ptr := v.Args[0]
  2502			if !(t.Size() == 2 && t.IsSigned()) {
  2503				break
  2504			}
  2505			v.reset(OpWasmI64Load16S)
  2506			v.AddArg(ptr)
  2507			v.AddArg(mem)
  2508			return true
  2509		}
  2510		// match: (Load <t> ptr mem)
  2511		// cond: t.Size() == 1 && !t.IsSigned()
  2512		// result: (I64Load8U ptr mem)
  2513		for {
  2514			t := v.Type
  2515			mem := v.Args[1]
  2516			ptr := v.Args[0]
  2517			if !(t.Size() == 1 && !t.IsSigned()) {
  2518				break
  2519			}
  2520			v.reset(OpWasmI64Load8U)
  2521			v.AddArg(ptr)
  2522			v.AddArg(mem)
  2523			return true
  2524		}
  2525		// match: (Load <t> ptr mem)
  2526		// cond: t.Size() == 1 && t.IsSigned()
  2527		// result: (I64Load8S ptr mem)
  2528		for {
  2529			t := v.Type
  2530			mem := v.Args[1]
  2531			ptr := v.Args[0]
  2532			if !(t.Size() == 1 && t.IsSigned()) {
  2533				break
  2534			}
  2535			v.reset(OpWasmI64Load8S)
  2536			v.AddArg(ptr)
  2537			v.AddArg(mem)
  2538			return true
  2539		}
  2540		return false
  2541	}
  2542	func rewriteValueWasm_OpLocalAddr_0(v *Value) bool {
  2543		// match: (LocalAddr {sym} base _)
  2544		// cond:
  2545		// result: (LoweredAddr {sym} base)
  2546		for {
  2547			sym := v.Aux
  2548			_ = v.Args[1]
  2549			base := v.Args[0]
  2550			v.reset(OpWasmLoweredAddr)
  2551			v.Aux = sym
  2552			v.AddArg(base)
  2553			return true
  2554		}
  2555	}
  2556	func rewriteValueWasm_OpLsh16x16_0(v *Value) bool {
  2557		b := v.Block
  2558		typ := &b.Func.Config.Types
  2559		// match: (Lsh16x16 x y)
  2560		// cond:
  2561		// result: (Lsh64x64 x (ZeroExt16to64 y))
  2562		for {
  2563			y := v.Args[1]
  2564			x := v.Args[0]
  2565			v.reset(OpLsh64x64)
  2566			v.AddArg(x)
  2567			v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  2568			v0.AddArg(y)
  2569			v.AddArg(v0)
  2570			return true
  2571		}
  2572	}
  2573	func rewriteValueWasm_OpLsh16x32_0(v *Value) bool {
  2574		b := v.Block
  2575		typ := &b.Func.Config.Types
  2576		// match: (Lsh16x32 x y)
  2577		// cond:
  2578		// result: (Lsh64x64 x (ZeroExt32to64 y))
  2579		for {
  2580			y := v.Args[1]
  2581			x := v.Args[0]
  2582			v.reset(OpLsh64x64)
  2583			v.AddArg(x)
  2584			v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  2585			v0.AddArg(y)
  2586			v.AddArg(v0)
  2587			return true
  2588		}
  2589	}
  2590	func rewriteValueWasm_OpLsh16x64_0(v *Value) bool {
  2591		// match: (Lsh16x64 x y)
  2592		// cond:
  2593		// result: (Lsh64x64 x y)
  2594		for {
  2595			y := v.Args[1]
  2596			x := v.Args[0]
  2597			v.reset(OpLsh64x64)
  2598			v.AddArg(x)
  2599			v.AddArg(y)
  2600			return true
  2601		}
  2602	}
  2603	func rewriteValueWasm_OpLsh16x8_0(v *Value) bool {
  2604		b := v.Block
  2605		typ := &b.Func.Config.Types
  2606		// match: (Lsh16x8 x y)
  2607		// cond:
  2608		// result: (Lsh64x64 x (ZeroExt8to64 y))
  2609		for {
  2610			y := v.Args[1]
  2611			x := v.Args[0]
  2612			v.reset(OpLsh64x64)
  2613			v.AddArg(x)
  2614			v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  2615			v0.AddArg(y)
  2616			v.AddArg(v0)
  2617			return true
  2618		}
  2619	}
  2620	func rewriteValueWasm_OpLsh32x16_0(v *Value) bool {
  2621		b := v.Block
  2622		typ := &b.Func.Config.Types
  2623		// match: (Lsh32x16 x y)
  2624		// cond:
  2625		// result: (Lsh64x64 x (ZeroExt16to64 y))
  2626		for {
  2627			y := v.Args[1]
  2628			x := v.Args[0]
  2629			v.reset(OpLsh64x64)
  2630			v.AddArg(x)
  2631			v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  2632			v0.AddArg(y)
  2633			v.AddArg(v0)
  2634			return true
  2635		}
  2636	}
  2637	func rewriteValueWasm_OpLsh32x32_0(v *Value) bool {
  2638		b := v.Block
  2639		typ := &b.Func.Config.Types
  2640		// match: (Lsh32x32 x y)
  2641		// cond:
  2642		// result: (Lsh64x64 x (ZeroExt32to64 y))
  2643		for {
  2644			y := v.Args[1]
  2645			x := v.Args[0]
  2646			v.reset(OpLsh64x64)
  2647			v.AddArg(x)
  2648			v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  2649			v0.AddArg(y)
  2650			v.AddArg(v0)
  2651			return true
  2652		}
  2653	}
  2654	func rewriteValueWasm_OpLsh32x64_0(v *Value) bool {
  2655		// match: (Lsh32x64 x y)
  2656		// cond:
  2657		// result: (Lsh64x64 x y)
  2658		for {
  2659			y := v.Args[1]
  2660			x := v.Args[0]
  2661			v.reset(OpLsh64x64)
  2662			v.AddArg(x)
  2663			v.AddArg(y)
  2664			return true
  2665		}
  2666	}
  2667	func rewriteValueWasm_OpLsh32x8_0(v *Value) bool {
  2668		b := v.Block
  2669		typ := &b.Func.Config.Types
  2670		// match: (Lsh32x8 x y)
  2671		// cond:
  2672		// result: (Lsh64x64 x (ZeroExt8to64 y))
  2673		for {
  2674			y := v.Args[1]
  2675			x := v.Args[0]
  2676			v.reset(OpLsh64x64)
  2677			v.AddArg(x)
  2678			v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  2679			v0.AddArg(y)
  2680			v.AddArg(v0)
  2681			return true
  2682		}
  2683	}
  2684	func rewriteValueWasm_OpLsh64x16_0(v *Value) bool {
  2685		b := v.Block
  2686		typ := &b.Func.Config.Types
  2687		// match: (Lsh64x16 x y)
  2688		// cond:
  2689		// result: (Lsh64x64 x (ZeroExt16to64 y))
  2690		for {
  2691			y := v.Args[1]
  2692			x := v.Args[0]
  2693			v.reset(OpLsh64x64)
  2694			v.AddArg(x)
  2695			v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  2696			v0.AddArg(y)
  2697			v.AddArg(v0)
  2698			return true
  2699		}
  2700	}
  2701	func rewriteValueWasm_OpLsh64x32_0(v *Value) bool {
  2702		b := v.Block
  2703		typ := &b.Func.Config.Types
  2704		// match: (Lsh64x32 x y)
  2705		// cond:
  2706		// result: (Lsh64x64 x (ZeroExt32to64 y))
  2707		for {
  2708			y := v.Args[1]
  2709			x := v.Args[0]
  2710			v.reset(OpLsh64x64)
  2711			v.AddArg(x)
  2712			v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  2713			v0.AddArg(y)
  2714			v.AddArg(v0)
  2715			return true
  2716		}
  2717	}
  2718	func rewriteValueWasm_OpLsh64x64_0(v *Value) bool {
  2719		b := v.Block
  2720		typ := &b.Func.Config.Types
  2721		// match: (Lsh64x64 x y)
  2722		// cond:
  2723		// result: (Select (I64Shl x y) (I64Const [0]) (I64LtU y (I64Const [64])))
  2724		for {
  2725			y := v.Args[1]
  2726			x := v.Args[0]
  2727			v.reset(OpWasmSelect)
  2728			v0 := b.NewValue0(v.Pos, OpWasmI64Shl, typ.Int64)
  2729			v0.AddArg(x)
  2730			v0.AddArg(y)
  2731			v.AddArg(v0)
  2732			v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  2733			v1.AuxInt = 0
  2734			v.AddArg(v1)
  2735			v2 := b.NewValue0(v.Pos, OpWasmI64LtU, typ.Bool)
  2736			v2.AddArg(y)
  2737			v3 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  2738			v3.AuxInt = 64
  2739			v2.AddArg(v3)
  2740			v.AddArg(v2)
  2741			return true
  2742		}
  2743	}
  2744	func rewriteValueWasm_OpLsh64x8_0(v *Value) bool {
  2745		b := v.Block
  2746		typ := &b.Func.Config.Types
  2747		// match: (Lsh64x8 x y)
  2748		// cond:
  2749		// result: (Lsh64x64 x (ZeroExt8to64 y))
  2750		for {
  2751			y := v.Args[1]
  2752			x := v.Args[0]
  2753			v.reset(OpLsh64x64)
  2754			v.AddArg(x)
  2755			v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  2756			v0.AddArg(y)
  2757			v.AddArg(v0)
  2758			return true
  2759		}
  2760	}
  2761	func rewriteValueWasm_OpLsh8x16_0(v *Value) bool {
  2762		b := v.Block
  2763		typ := &b.Func.Config.Types
  2764		// match: (Lsh8x16 x y)
  2765		// cond:
  2766		// result: (Lsh64x64 x (ZeroExt16to64 y))
  2767		for {
  2768			y := v.Args[1]
  2769			x := v.Args[0]
  2770			v.reset(OpLsh64x64)
  2771			v.AddArg(x)
  2772			v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  2773			v0.AddArg(y)
  2774			v.AddArg(v0)
  2775			return true
  2776		}
  2777	}
  2778	func rewriteValueWasm_OpLsh8x32_0(v *Value) bool {
  2779		b := v.Block
  2780		typ := &b.Func.Config.Types
  2781		// match: (Lsh8x32 x y)
  2782		// cond:
  2783		// result: (Lsh64x64 x (ZeroExt32to64 y))
  2784		for {
  2785			y := v.Args[1]
  2786			x := v.Args[0]
  2787			v.reset(OpLsh64x64)
  2788			v.AddArg(x)
  2789			v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  2790			v0.AddArg(y)
  2791			v.AddArg(v0)
  2792			return true
  2793		}
  2794	}
  2795	func rewriteValueWasm_OpLsh8x64_0(v *Value) bool {
  2796		// match: (Lsh8x64 x y)
  2797		// cond:
  2798		// result: (Lsh64x64 x y)
  2799		for {
  2800			y := v.Args[1]
  2801			x := v.Args[0]
  2802			v.reset(OpLsh64x64)
  2803			v.AddArg(x)
  2804			v.AddArg(y)
  2805			return true
  2806		}
  2807	}
  2808	func rewriteValueWasm_OpLsh8x8_0(v *Value) bool {
  2809		b := v.Block
  2810		typ := &b.Func.Config.Types
  2811		// match: (Lsh8x8 x y)
  2812		// cond:
  2813		// result: (Lsh64x64 x (ZeroExt8to64 y))
  2814		for {
  2815			y := v.Args[1]
  2816			x := v.Args[0]
  2817			v.reset(OpLsh64x64)
  2818			v.AddArg(x)
  2819			v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  2820			v0.AddArg(y)
  2821			v.AddArg(v0)
  2822			return true
  2823		}
  2824	}
  2825	func rewriteValueWasm_OpMod16_0(v *Value) bool {
  2826		b := v.Block
  2827		typ := &b.Func.Config.Types
  2828		// match: (Mod16 x y)
  2829		// cond:
  2830		// result: (I64RemS (SignExt16to64 x) (SignExt16to64 y))
  2831		for {
  2832			y := v.Args[1]
  2833			x := v.Args[0]
  2834			v.reset(OpWasmI64RemS)
  2835			v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
  2836			v0.AddArg(x)
  2837			v.AddArg(v0)
  2838			v1 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
  2839			v1.AddArg(y)
  2840			v.AddArg(v1)
  2841			return true
  2842		}
  2843	}
  2844	func rewriteValueWasm_OpMod16u_0(v *Value) bool {
  2845		b := v.Block
  2846		typ := &b.Func.Config.Types
  2847		// match: (Mod16u x y)
  2848		// cond:
  2849		// result: (I64RemU (ZeroExt16to64 x) (ZeroExt16to64 y))
  2850		for {
  2851			y := v.Args[1]
  2852			x := v.Args[0]
  2853			v.reset(OpWasmI64RemU)
  2854			v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  2855			v0.AddArg(x)
  2856			v.AddArg(v0)
  2857			v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  2858			v1.AddArg(y)
  2859			v.AddArg(v1)
  2860			return true
  2861		}
  2862	}
  2863	func rewriteValueWasm_OpMod32_0(v *Value) bool {
  2864		b := v.Block
  2865		typ := &b.Func.Config.Types
  2866		// match: (Mod32 x y)
  2867		// cond:
  2868		// result: (I64RemS (SignExt32to64 x) (SignExt32to64 y))
  2869		for {
  2870			y := v.Args[1]
  2871			x := v.Args[0]
  2872			v.reset(OpWasmI64RemS)
  2873			v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
  2874			v0.AddArg(x)
  2875			v.AddArg(v0)
  2876			v1 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
  2877			v1.AddArg(y)
  2878			v.AddArg(v1)
  2879			return true
  2880		}
  2881	}
  2882	func rewriteValueWasm_OpMod32u_0(v *Value) bool {
  2883		b := v.Block
  2884		typ := &b.Func.Config.Types
  2885		// match: (Mod32u x y)
  2886		// cond:
  2887		// result: (I64RemU (ZeroExt32to64 x) (ZeroExt32to64 y))
  2888		for {
  2889			y := v.Args[1]
  2890			x := v.Args[0]
  2891			v.reset(OpWasmI64RemU)
  2892			v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  2893			v0.AddArg(x)
  2894			v.AddArg(v0)
  2895			v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  2896			v1.AddArg(y)
  2897			v.AddArg(v1)
  2898			return true
  2899		}
  2900	}
  2901	func rewriteValueWasm_OpMod64_0(v *Value) bool {
  2902		// match: (Mod64 x y)
  2903		// cond:
  2904		// result: (I64RemS x y)
  2905		for {
  2906			y := v.Args[1]
  2907			x := v.Args[0]
  2908			v.reset(OpWasmI64RemS)
  2909			v.AddArg(x)
  2910			v.AddArg(y)
  2911			return true
  2912		}
  2913	}
  2914	func rewriteValueWasm_OpMod64u_0(v *Value) bool {
  2915		// match: (Mod64u x y)
  2916		// cond:
  2917		// result: (I64RemU x y)
  2918		for {
  2919			y := v.Args[1]
  2920			x := v.Args[0]
  2921			v.reset(OpWasmI64RemU)
  2922			v.AddArg(x)
  2923			v.AddArg(y)
  2924			return true
  2925		}
  2926	}
  2927	func rewriteValueWasm_OpMod8_0(v *Value) bool {
  2928		b := v.Block
  2929		typ := &b.Func.Config.Types
  2930		// match: (Mod8 x y)
  2931		// cond:
  2932		// result: (I64RemS (SignExt8to64 x) (SignExt8to64 y))
  2933		for {
  2934			y := v.Args[1]
  2935			x := v.Args[0]
  2936			v.reset(OpWasmI64RemS)
  2937			v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
  2938			v0.AddArg(x)
  2939			v.AddArg(v0)
  2940			v1 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
  2941			v1.AddArg(y)
  2942			v.AddArg(v1)
  2943			return true
  2944		}
  2945	}
  2946	func rewriteValueWasm_OpMod8u_0(v *Value) bool {
  2947		b := v.Block
  2948		typ := &b.Func.Config.Types
  2949		// match: (Mod8u x y)
  2950		// cond:
  2951		// result: (I64RemU (ZeroExt8to64 x) (ZeroExt8to64 y))
  2952		for {
  2953			y := v.Args[1]
  2954			x := v.Args[0]
  2955			v.reset(OpWasmI64RemU)
  2956			v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  2957			v0.AddArg(x)
  2958			v.AddArg(v0)
  2959			v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  2960			v1.AddArg(y)
  2961			v.AddArg(v1)
  2962			return true
  2963		}
  2964	}
  2965	func rewriteValueWasm_OpMove_0(v *Value) bool {
  2966		b := v.Block
  2967		typ := &b.Func.Config.Types
  2968		// match: (Move [0] _ _ mem)
  2969		// cond:
  2970		// result: mem
  2971		for {
  2972			if v.AuxInt != 0 {
  2973				break
  2974			}
  2975			mem := v.Args[2]
  2976			v.reset(OpCopy)
  2977			v.Type = mem.Type
  2978			v.AddArg(mem)
  2979			return true
  2980		}
  2981		// match: (Move [1] dst src mem)
  2982		// cond:
  2983		// result: (I64Store8 dst (I64Load8U src mem) mem)
  2984		for {
  2985			if v.AuxInt != 1 {
  2986				break
  2987			}
  2988			mem := v.Args[2]
  2989			dst := v.Args[0]
  2990			src := v.Args[1]
  2991			v.reset(OpWasmI64Store8)
  2992			v.AddArg(dst)
  2993			v0 := b.NewValue0(v.Pos, OpWasmI64Load8U, typ.UInt8)
  2994			v0.AddArg(src)
  2995			v0.AddArg(mem)
  2996			v.AddArg(v0)
  2997			v.AddArg(mem)
  2998			return true
  2999		}
  3000		// match: (Move [2] dst src mem)
  3001		// cond:
  3002		// result: (I64Store16 dst (I64Load16U src mem) mem)
  3003		for {
  3004			if v.AuxInt != 2 {
  3005				break
  3006			}
  3007			mem := v.Args[2]
  3008			dst := v.Args[0]
  3009			src := v.Args[1]
  3010			v.reset(OpWasmI64Store16)
  3011			v.AddArg(dst)
  3012			v0 := b.NewValue0(v.Pos, OpWasmI64Load16U, typ.UInt16)
  3013			v0.AddArg(src)
  3014			v0.AddArg(mem)
  3015			v.AddArg(v0)
  3016			v.AddArg(mem)
  3017			return true
  3018		}
  3019		// match: (Move [4] dst src mem)
  3020		// cond:
  3021		// result: (I64Store32 dst (I64Load32U src mem) mem)
  3022		for {
  3023			if v.AuxInt != 4 {
  3024				break
  3025			}
  3026			mem := v.Args[2]
  3027			dst := v.Args[0]
  3028			src := v.Args[1]
  3029			v.reset(OpWasmI64Store32)
  3030			v.AddArg(dst)
  3031			v0 := b.NewValue0(v.Pos, OpWasmI64Load32U, typ.UInt32)
  3032			v0.AddArg(src)
  3033			v0.AddArg(mem)
  3034			v.AddArg(v0)
  3035			v.AddArg(mem)
  3036			return true
  3037		}
  3038		// match: (Move [8] dst src mem)
  3039		// cond:
  3040		// result: (I64Store dst (I64Load src mem) mem)
  3041		for {
  3042			if v.AuxInt != 8 {
  3043				break
  3044			}
  3045			mem := v.Args[2]
  3046			dst := v.Args[0]
  3047			src := v.Args[1]
  3048			v.reset(OpWasmI64Store)
  3049			v.AddArg(dst)
  3050			v0 := b.NewValue0(v.Pos, OpWasmI64Load, typ.UInt64)
  3051			v0.AddArg(src)
  3052			v0.AddArg(mem)
  3053			v.AddArg(v0)
  3054			v.AddArg(mem)
  3055			return true
  3056		}
  3057		// match: (Move [16] dst src mem)
  3058		// cond:
  3059		// result: (I64Store [8] dst (I64Load [8] src mem) (I64Store dst (I64Load src mem) mem))
  3060		for {
  3061			if v.AuxInt != 16 {
  3062				break
  3063			}
  3064			mem := v.Args[2]
  3065			dst := v.Args[0]
  3066			src := v.Args[1]
  3067			v.reset(OpWasmI64Store)
  3068			v.AuxInt = 8
  3069			v.AddArg(dst)
  3070			v0 := b.NewValue0(v.Pos, OpWasmI64Load, typ.UInt64)
  3071			v0.AuxInt = 8
  3072			v0.AddArg(src)
  3073			v0.AddArg(mem)
  3074			v.AddArg(v0)
  3075			v1 := b.NewValue0(v.Pos, OpWasmI64Store, types.TypeMem)
  3076			v1.AddArg(dst)
  3077			v2 := b.NewValue0(v.Pos, OpWasmI64Load, typ.UInt64)
  3078			v2.AddArg(src)
  3079			v2.AddArg(mem)
  3080			v1.AddArg(v2)
  3081			v1.AddArg(mem)
  3082			v.AddArg(v1)
  3083			return true
  3084		}
  3085		// match: (Move [3] dst src mem)
  3086		// cond:
  3087		// result: (I64Store8 [2] dst (I64Load8U [2] src mem) (I64Store16 dst (I64Load16U src mem) mem))
  3088		for {
  3089			if v.AuxInt != 3 {
  3090				break
  3091			}
  3092			mem := v.Args[2]
  3093			dst := v.Args[0]
  3094			src := v.Args[1]
  3095			v.reset(OpWasmI64Store8)
  3096			v.AuxInt = 2
  3097			v.AddArg(dst)
  3098			v0 := b.NewValue0(v.Pos, OpWasmI64Load8U, typ.UInt8)
  3099			v0.AuxInt = 2
  3100			v0.AddArg(src)
  3101			v0.AddArg(mem)
  3102			v.AddArg(v0)
  3103			v1 := b.NewValue0(v.Pos, OpWasmI64Store16, types.TypeMem)
  3104			v1.AddArg(dst)
  3105			v2 := b.NewValue0(v.Pos, OpWasmI64Load16U, typ.UInt16)
  3106			v2.AddArg(src)
  3107			v2.AddArg(mem)
  3108			v1.AddArg(v2)
  3109			v1.AddArg(mem)
  3110			v.AddArg(v1)
  3111			return true
  3112		}
  3113		// match: (Move [5] dst src mem)
  3114		// cond:
  3115		// result: (I64Store8 [4] dst (I64Load8U [4] src mem) (I64Store32 dst (I64Load32U src mem) mem))
  3116		for {
  3117			if v.AuxInt != 5 {
  3118				break
  3119			}
  3120			mem := v.Args[2]
  3121			dst := v.Args[0]
  3122			src := v.Args[1]
  3123			v.reset(OpWasmI64Store8)
  3124			v.AuxInt = 4
  3125			v.AddArg(dst)
  3126			v0 := b.NewValue0(v.Pos, OpWasmI64Load8U, typ.UInt8)
  3127			v0.AuxInt = 4
  3128			v0.AddArg(src)
  3129			v0.AddArg(mem)
  3130			v.AddArg(v0)
  3131			v1 := b.NewValue0(v.Pos, OpWasmI64Store32, types.TypeMem)
  3132			v1.AddArg(dst)
  3133			v2 := b.NewValue0(v.Pos, OpWasmI64Load32U, typ.UInt32)
  3134			v2.AddArg(src)
  3135			v2.AddArg(mem)
  3136			v1.AddArg(v2)
  3137			v1.AddArg(mem)
  3138			v.AddArg(v1)
  3139			return true
  3140		}
  3141		// match: (Move [6] dst src mem)
  3142		// cond:
  3143		// result: (I64Store16 [4] dst (I64Load16U [4] src mem) (I64Store32 dst (I64Load32U src mem) mem))
  3144		for {
  3145			if v.AuxInt != 6 {
  3146				break
  3147			}
  3148			mem := v.Args[2]
  3149			dst := v.Args[0]
  3150			src := v.Args[1]
  3151			v.reset(OpWasmI64Store16)
  3152			v.AuxInt = 4
  3153			v.AddArg(dst)
  3154			v0 := b.NewValue0(v.Pos, OpWasmI64Load16U, typ.UInt16)
  3155			v0.AuxInt = 4
  3156			v0.AddArg(src)
  3157			v0.AddArg(mem)
  3158			v.AddArg(v0)
  3159			v1 := b.NewValue0(v.Pos, OpWasmI64Store32, types.TypeMem)
  3160			v1.AddArg(dst)
  3161			v2 := b.NewValue0(v.Pos, OpWasmI64Load32U, typ.UInt32)
  3162			v2.AddArg(src)
  3163			v2.AddArg(mem)
  3164			v1.AddArg(v2)
  3165			v1.AddArg(mem)
  3166			v.AddArg(v1)
  3167			return true
  3168		}
  3169		// match: (Move [7] dst src mem)
  3170		// cond:
  3171		// result: (I64Store32 [3] dst (I64Load32U [3] src mem) (I64Store32 dst (I64Load32U src mem) mem))
  3172		for {
  3173			if v.AuxInt != 7 {
  3174				break
  3175			}
  3176			mem := v.Args[2]
  3177			dst := v.Args[0]
  3178			src := v.Args[1]
  3179			v.reset(OpWasmI64Store32)
  3180			v.AuxInt = 3
  3181			v.AddArg(dst)
  3182			v0 := b.NewValue0(v.Pos, OpWasmI64Load32U, typ.UInt32)
  3183			v0.AuxInt = 3
  3184			v0.AddArg(src)
  3185			v0.AddArg(mem)
  3186			v.AddArg(v0)
  3187			v1 := b.NewValue0(v.Pos, OpWasmI64Store32, types.TypeMem)
  3188			v1.AddArg(dst)
  3189			v2 := b.NewValue0(v.Pos, OpWasmI64Load32U, typ.UInt32)
  3190			v2.AddArg(src)
  3191			v2.AddArg(mem)
  3192			v1.AddArg(v2)
  3193			v1.AddArg(mem)
  3194			v.AddArg(v1)
  3195			return true
  3196		}
  3197		return false
  3198	}
  3199	func rewriteValueWasm_OpMove_10(v *Value) bool {
  3200		b := v.Block
  3201		typ := &b.Func.Config.Types
  3202		// match: (Move [s] dst src mem)
  3203		// cond: s > 8 && s < 16
  3204		// result: (I64Store [s-8] dst (I64Load [s-8] src mem) (I64Store dst (I64Load src mem) mem))
  3205		for {
  3206			s := v.AuxInt
  3207			mem := v.Args[2]
  3208			dst := v.Args[0]
  3209			src := v.Args[1]
  3210			if !(s > 8 && s < 16) {
  3211				break
  3212			}
  3213			v.reset(OpWasmI64Store)
  3214			v.AuxInt = s - 8
  3215			v.AddArg(dst)
  3216			v0 := b.NewValue0(v.Pos, OpWasmI64Load, typ.UInt64)
  3217			v0.AuxInt = s - 8
  3218			v0.AddArg(src)
  3219			v0.AddArg(mem)
  3220			v.AddArg(v0)
  3221			v1 := b.NewValue0(v.Pos, OpWasmI64Store, types.TypeMem)
  3222			v1.AddArg(dst)
  3223			v2 := b.NewValue0(v.Pos, OpWasmI64Load, typ.UInt64)
  3224			v2.AddArg(src)
  3225			v2.AddArg(mem)
  3226			v1.AddArg(v2)
  3227			v1.AddArg(mem)
  3228			v.AddArg(v1)
  3229			return true
  3230		}
  3231		// match: (Move [s] dst src mem)
  3232		// cond: s > 16 && s%16 != 0 && s%16 <= 8
  3233		// result: (Move [s-s%16] (OffPtr <dst.Type> dst [s%16]) (OffPtr <src.Type> src [s%16]) (I64Store dst (I64Load src mem) mem))
  3234		for {
  3235			s := v.AuxInt
  3236			mem := v.Args[2]
  3237			dst := v.Args[0]
  3238			src := v.Args[1]
  3239			if !(s > 16 && s%16 != 0 && s%16 <= 8) {
  3240				break
  3241			}
  3242			v.reset(OpMove)
  3243			v.AuxInt = s - s%16
  3244			v0 := b.NewValue0(v.Pos, OpOffPtr, dst.Type)
  3245			v0.AuxInt = s % 16
  3246			v0.AddArg(dst)
  3247			v.AddArg(v0)
  3248			v1 := b.NewValue0(v.Pos, OpOffPtr, src.Type)
  3249			v1.AuxInt = s % 16
  3250			v1.AddArg(src)
  3251			v.AddArg(v1)
  3252			v2 := b.NewValue0(v.Pos, OpWasmI64Store, types.TypeMem)
  3253			v2.AddArg(dst)
  3254			v3 := b.NewValue0(v.Pos, OpWasmI64Load, typ.UInt64)
  3255			v3.AddArg(src)
  3256			v3.AddArg(mem)
  3257			v2.AddArg(v3)
  3258			v2.AddArg(mem)
  3259			v.AddArg(v2)
  3260			return true
  3261		}
  3262		// match: (Move [s] dst src mem)
  3263		// cond: s > 16 && s%16 != 0 && s%16 > 8
  3264		// result: (Move [s-s%16] (OffPtr <dst.Type> dst [s%16]) (OffPtr <src.Type> src [s%16]) (I64Store [8] dst (I64Load [8] src mem) (I64Store dst (I64Load src mem) mem)))
  3265		for {
  3266			s := v.AuxInt
  3267			mem := v.Args[2]
  3268			dst := v.Args[0]
  3269			src := v.Args[1]
  3270			if !(s > 16 && s%16 != 0 && s%16 > 8) {
  3271				break
  3272			}
  3273			v.reset(OpMove)
  3274			v.AuxInt = s - s%16
  3275			v0 := b.NewValue0(v.Pos, OpOffPtr, dst.Type)
  3276			v0.AuxInt = s % 16
  3277			v0.AddArg(dst)
  3278			v.AddArg(v0)
  3279			v1 := b.NewValue0(v.Pos, OpOffPtr, src.Type)
  3280			v1.AuxInt = s % 16
  3281			v1.AddArg(src)
  3282			v.AddArg(v1)
  3283			v2 := b.NewValue0(v.Pos, OpWasmI64Store, types.TypeMem)
  3284			v2.AuxInt = 8
  3285			v2.AddArg(dst)
  3286			v3 := b.NewValue0(v.Pos, OpWasmI64Load, typ.UInt64)
  3287			v3.AuxInt = 8
  3288			v3.AddArg(src)
  3289			v3.AddArg(mem)
  3290			v2.AddArg(v3)
  3291			v4 := b.NewValue0(v.Pos, OpWasmI64Store, types.TypeMem)
  3292			v4.AddArg(dst)
  3293			v5 := b.NewValue0(v.Pos, OpWasmI64Load, typ.UInt64)
  3294			v5.AddArg(src)
  3295			v5.AddArg(mem)
  3296			v4.AddArg(v5)
  3297			v4.AddArg(mem)
  3298			v2.AddArg(v4)
  3299			v.AddArg(v2)
  3300			return true
  3301		}
  3302		// match: (Move [s] dst src mem)
  3303		// cond: s%8 == 0
  3304		// result: (LoweredMove [s/8] dst src mem)
  3305		for {
  3306			s := v.AuxInt
  3307			mem := v.Args[2]
  3308			dst := v.Args[0]
  3309			src := v.Args[1]
  3310			if !(s%8 == 0) {
  3311				break
  3312			}
  3313			v.reset(OpWasmLoweredMove)
  3314			v.AuxInt = s / 8
  3315			v.AddArg(dst)
  3316			v.AddArg(src)
  3317			v.AddArg(mem)
  3318			return true
  3319		}
  3320		return false
  3321	}
  3322	func rewriteValueWasm_OpMul16_0(v *Value) bool {
  3323		// match: (Mul16 x y)
  3324		// cond:
  3325		// result: (I64Mul x y)
  3326		for {
  3327			y := v.Args[1]
  3328			x := v.Args[0]
  3329			v.reset(OpWasmI64Mul)
  3330			v.AddArg(x)
  3331			v.AddArg(y)
  3332			return true
  3333		}
  3334	}
  3335	func rewriteValueWasm_OpMul32_0(v *Value) bool {
  3336		// match: (Mul32 x y)
  3337		// cond:
  3338		// result: (I64Mul x y)
  3339		for {
  3340			y := v.Args[1]
  3341			x := v.Args[0]
  3342			v.reset(OpWasmI64Mul)
  3343			v.AddArg(x)
  3344			v.AddArg(y)
  3345			return true
  3346		}
  3347	}
  3348	func rewriteValueWasm_OpMul32F_0(v *Value) bool {
  3349		// match: (Mul32F x y)
  3350		// cond:
  3351		// result: (F64Mul x y)
  3352		for {
  3353			y := v.Args[1]
  3354			x := v.Args[0]
  3355			v.reset(OpWasmF64Mul)
  3356			v.AddArg(x)
  3357			v.AddArg(y)
  3358			return true
  3359		}
  3360	}
  3361	func rewriteValueWasm_OpMul64_0(v *Value) bool {
  3362		// match: (Mul64 x y)
  3363		// cond:
  3364		// result: (I64Mul x y)
  3365		for {
  3366			y := v.Args[1]
  3367			x := v.Args[0]
  3368			v.reset(OpWasmI64Mul)
  3369			v.AddArg(x)
  3370			v.AddArg(y)
  3371			return true
  3372		}
  3373	}
  3374	func rewriteValueWasm_OpMul64F_0(v *Value) bool {
  3375		// match: (Mul64F x y)
  3376		// cond:
  3377		// result: (F64Mul x y)
  3378		for {
  3379			y := v.Args[1]
  3380			x := v.Args[0]
  3381			v.reset(OpWasmF64Mul)
  3382			v.AddArg(x)
  3383			v.AddArg(y)
  3384			return true
  3385		}
  3386	}
  3387	func rewriteValueWasm_OpMul8_0(v *Value) bool {
  3388		// match: (Mul8 x y)
  3389		// cond:
  3390		// result: (I64Mul x y)
  3391		for {
  3392			y := v.Args[1]
  3393			x := v.Args[0]
  3394			v.reset(OpWasmI64Mul)
  3395			v.AddArg(x)
  3396			v.AddArg(y)
  3397			return true
  3398		}
  3399	}
  3400	func rewriteValueWasm_OpNeg16_0(v *Value) bool {
  3401		b := v.Block
  3402		typ := &b.Func.Config.Types
  3403		// match: (Neg16 x)
  3404		// cond:
  3405		// result: (I64Sub (I64Const [0]) x)
  3406		for {
  3407			x := v.Args[0]
  3408			v.reset(OpWasmI64Sub)
  3409			v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  3410			v0.AuxInt = 0
  3411			v.AddArg(v0)
  3412			v.AddArg(x)
  3413			return true
  3414		}
  3415	}
  3416	func rewriteValueWasm_OpNeg32_0(v *Value) bool {
  3417		b := v.Block
  3418		typ := &b.Func.Config.Types
  3419		// match: (Neg32 x)
  3420		// cond:
  3421		// result: (I64Sub (I64Const [0]) x)
  3422		for {
  3423			x := v.Args[0]
  3424			v.reset(OpWasmI64Sub)
  3425			v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  3426			v0.AuxInt = 0
  3427			v.AddArg(v0)
  3428			v.AddArg(x)
  3429			return true
  3430		}
  3431	}
  3432	func rewriteValueWasm_OpNeg32F_0(v *Value) bool {
  3433		// match: (Neg32F x)
  3434		// cond:
  3435		// result: (F64Neg x)
  3436		for {
  3437			x := v.Args[0]
  3438			v.reset(OpWasmF64Neg)
  3439			v.AddArg(x)
  3440			return true
  3441		}
  3442	}
  3443	func rewriteValueWasm_OpNeg64_0(v *Value) bool {
  3444		b := v.Block
  3445		typ := &b.Func.Config.Types
  3446		// match: (Neg64 x)
  3447		// cond:
  3448		// result: (I64Sub (I64Const [0]) x)
  3449		for {
  3450			x := v.Args[0]
  3451			v.reset(OpWasmI64Sub)
  3452			v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  3453			v0.AuxInt = 0
  3454			v.AddArg(v0)
  3455			v.AddArg(x)
  3456			return true
  3457		}
  3458	}
  3459	func rewriteValueWasm_OpNeg64F_0(v *Value) bool {
  3460		// match: (Neg64F x)
  3461		// cond:
  3462		// result: (F64Neg x)
  3463		for {
  3464			x := v.Args[0]
  3465			v.reset(OpWasmF64Neg)
  3466			v.AddArg(x)
  3467			return true
  3468		}
  3469	}
  3470	func rewriteValueWasm_OpNeg8_0(v *Value) bool {
  3471		b := v.Block
  3472		typ := &b.Func.Config.Types
  3473		// match: (Neg8 x)
  3474		// cond:
  3475		// result: (I64Sub (I64Const [0]) x)
  3476		for {
  3477			x := v.Args[0]
  3478			v.reset(OpWasmI64Sub)
  3479			v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  3480			v0.AuxInt = 0
  3481			v.AddArg(v0)
  3482			v.AddArg(x)
  3483			return true
  3484		}
  3485	}
  3486	func rewriteValueWasm_OpNeq16_0(v *Value) bool {
  3487		b := v.Block
  3488		typ := &b.Func.Config.Types
  3489		// match: (Neq16 x y)
  3490		// cond:
  3491		// result: (I64Ne (ZeroExt16to64 x) (ZeroExt16to64 y))
  3492		for {
  3493			y := v.Args[1]
  3494			x := v.Args[0]
  3495			v.reset(OpWasmI64Ne)
  3496			v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  3497			v0.AddArg(x)
  3498			v.AddArg(v0)
  3499			v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  3500			v1.AddArg(y)
  3501			v.AddArg(v1)
  3502			return true
  3503		}
  3504	}
  3505	func rewriteValueWasm_OpNeq32_0(v *Value) bool {
  3506		b := v.Block
  3507		typ := &b.Func.Config.Types
  3508		// match: (Neq32 x y)
  3509		// cond:
  3510		// result: (I64Ne (ZeroExt32to64 x) (ZeroExt32to64 y))
  3511		for {
  3512			y := v.Args[1]
  3513			x := v.Args[0]
  3514			v.reset(OpWasmI64Ne)
  3515			v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  3516			v0.AddArg(x)
  3517			v.AddArg(v0)
  3518			v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  3519			v1.AddArg(y)
  3520			v.AddArg(v1)
  3521			return true
  3522		}
  3523	}
  3524	func rewriteValueWasm_OpNeq32F_0(v *Value) bool {
  3525		b := v.Block
  3526		typ := &b.Func.Config.Types
  3527		// match: (Neq32F x y)
  3528		// cond:
  3529		// result: (F64Ne (LoweredRound32F x) (LoweredRound32F y))
  3530		for {
  3531			y := v.Args[1]
  3532			x := v.Args[0]
  3533			v.reset(OpWasmF64Ne)
  3534			v0 := b.NewValue0(v.Pos, OpWasmLoweredRound32F, typ.Float32)
  3535			v0.AddArg(x)
  3536			v.AddArg(v0)
  3537			v1 := b.NewValue0(v.Pos, OpWasmLoweredRound32F, typ.Float32)
  3538			v1.AddArg(y)
  3539			v.AddArg(v1)
  3540			return true
  3541		}
  3542	}
  3543	func rewriteValueWasm_OpNeq64_0(v *Value) bool {
  3544		// match: (Neq64 x y)
  3545		// cond:
  3546		// result: (I64Ne x y)
  3547		for {
  3548			y := v.Args[1]
  3549			x := v.Args[0]
  3550			v.reset(OpWasmI64Ne)
  3551			v.AddArg(x)
  3552			v.AddArg(y)
  3553			return true
  3554		}
  3555	}
  3556	func rewriteValueWasm_OpNeq64F_0(v *Value) bool {
  3557		// match: (Neq64F x y)
  3558		// cond:
  3559		// result: (F64Ne x y)
  3560		for {
  3561			y := v.Args[1]
  3562			x := v.Args[0]
  3563			v.reset(OpWasmF64Ne)
  3564			v.AddArg(x)
  3565			v.AddArg(y)
  3566			return true
  3567		}
  3568	}
  3569	func rewriteValueWasm_OpNeq8_0(v *Value) bool {
  3570		b := v.Block
  3571		typ := &b.Func.Config.Types
  3572		// match: (Neq8 x y)
  3573		// cond:
  3574		// result: (I64Ne (ZeroExt8to64 x) (ZeroExt8to64 y))
  3575		for {
  3576			y := v.Args[1]
  3577			x := v.Args[0]
  3578			v.reset(OpWasmI64Ne)
  3579			v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  3580			v0.AddArg(x)
  3581			v.AddArg(v0)
  3582			v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  3583			v1.AddArg(y)
  3584			v.AddArg(v1)
  3585			return true
  3586		}
  3587	}
  3588	func rewriteValueWasm_OpNeqB_0(v *Value) bool {
  3589		// match: (NeqB x y)
  3590		// cond:
  3591		// result: (I64Ne x y)
  3592		for {
  3593			y := v.Args[1]
  3594			x := v.Args[0]
  3595			v.reset(OpWasmI64Ne)
  3596			v.AddArg(x)
  3597			v.AddArg(y)
  3598			return true
  3599		}
  3600	}
  3601	func rewriteValueWasm_OpNeqPtr_0(v *Value) bool {
  3602		// match: (NeqPtr x y)
  3603		// cond:
  3604		// result: (I64Ne x y)
  3605		for {
  3606			y := v.Args[1]
  3607			x := v.Args[0]
  3608			v.reset(OpWasmI64Ne)
  3609			v.AddArg(x)
  3610			v.AddArg(y)
  3611			return true
  3612		}
  3613	}
  3614	func rewriteValueWasm_OpNilCheck_0(v *Value) bool {
  3615		// match: (NilCheck ptr mem)
  3616		// cond:
  3617		// result: (LoweredNilCheck ptr mem)
  3618		for {
  3619			mem := v.Args[1]
  3620			ptr := v.Args[0]
  3621			v.reset(OpWasmLoweredNilCheck)
  3622			v.AddArg(ptr)
  3623			v.AddArg(mem)
  3624			return true
  3625		}
  3626	}
  3627	func rewriteValueWasm_OpNot_0(v *Value) bool {
  3628		// match: (Not x)
  3629		// cond:
  3630		// result: (I64Eqz x)
  3631		for {
  3632			x := v.Args[0]
  3633			v.reset(OpWasmI64Eqz)
  3634			v.AddArg(x)
  3635			return true
  3636		}
  3637	}
  3638	func rewriteValueWasm_OpOffPtr_0(v *Value) bool {
  3639		// match: (OffPtr [off] ptr)
  3640		// cond:
  3641		// result: (I64AddConst [off] ptr)
  3642		for {
  3643			off := v.AuxInt
  3644			ptr := v.Args[0]
  3645			v.reset(OpWasmI64AddConst)
  3646			v.AuxInt = off
  3647			v.AddArg(ptr)
  3648			return true
  3649		}
  3650	}
  3651	func rewriteValueWasm_OpOr16_0(v *Value) bool {
  3652		// match: (Or16 x y)
  3653		// cond:
  3654		// result: (I64Or x y)
  3655		for {
  3656			y := v.Args[1]
  3657			x := v.Args[0]
  3658			v.reset(OpWasmI64Or)
  3659			v.AddArg(x)
  3660			v.AddArg(y)
  3661			return true
  3662		}
  3663	}
  3664	func rewriteValueWasm_OpOr32_0(v *Value) bool {
  3665		// match: (Or32 x y)
  3666		// cond:
  3667		// result: (I64Or x y)
  3668		for {
  3669			y := v.Args[1]
  3670			x := v.Args[0]
  3671			v.reset(OpWasmI64Or)
  3672			v.AddArg(x)
  3673			v.AddArg(y)
  3674			return true
  3675		}
  3676	}
  3677	func rewriteValueWasm_OpOr64_0(v *Value) bool {
  3678		// match: (Or64 x y)
  3679		// cond:
  3680		// result: (I64Or x y)
  3681		for {
  3682			y := v.Args[1]
  3683			x := v.Args[0]
  3684			v.reset(OpWasmI64Or)
  3685			v.AddArg(x)
  3686			v.AddArg(y)
  3687			return true
  3688		}
  3689	}
  3690	func rewriteValueWasm_OpOr8_0(v *Value) bool {
  3691		// match: (Or8 x y)
  3692		// cond:
  3693		// result: (I64Or x y)
  3694		for {
  3695			y := v.Args[1]
  3696			x := v.Args[0]
  3697			v.reset(OpWasmI64Or)
  3698			v.AddArg(x)
  3699			v.AddArg(y)
  3700			return true
  3701		}
  3702	}
  3703	func rewriteValueWasm_OpOrB_0(v *Value) bool {
  3704		// match: (OrB x y)
  3705		// cond:
  3706		// result: (I64Or x y)
  3707		for {
  3708			y := v.Args[1]
  3709			x := v.Args[0]
  3710			v.reset(OpWasmI64Or)
  3711			v.AddArg(x)
  3712			v.AddArg(y)
  3713			return true
  3714		}
  3715	}
  3716	func rewriteValueWasm_OpPopCount16_0(v *Value) bool {
  3717		b := v.Block
  3718		typ := &b.Func.Config.Types
  3719		// match: (PopCount16 x)
  3720		// cond:
  3721		// result: (I64Popcnt (ZeroExt16to64 x))
  3722		for {
  3723			x := v.Args[0]
  3724			v.reset(OpWasmI64Popcnt)
  3725			v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  3726			v0.AddArg(x)
  3727			v.AddArg(v0)
  3728			return true
  3729		}
  3730	}
  3731	func rewriteValueWasm_OpPopCount32_0(v *Value) bool {
  3732		b := v.Block
  3733		typ := &b.Func.Config.Types
  3734		// match: (PopCount32 x)
  3735		// cond:
  3736		// result: (I64Popcnt (ZeroExt32to64 x))
  3737		for {
  3738			x := v.Args[0]
  3739			v.reset(OpWasmI64Popcnt)
  3740			v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  3741			v0.AddArg(x)
  3742			v.AddArg(v0)
  3743			return true
  3744		}
  3745	}
  3746	func rewriteValueWasm_OpPopCount64_0(v *Value) bool {
  3747		// match: (PopCount64 x)
  3748		// cond:
  3749		// result: (I64Popcnt x)
  3750		for {
  3751			x := v.Args[0]
  3752			v.reset(OpWasmI64Popcnt)
  3753			v.AddArg(x)
  3754			return true
  3755		}
  3756	}
  3757	func rewriteValueWasm_OpPopCount8_0(v *Value) bool {
  3758		b := v.Block
  3759		typ := &b.Func.Config.Types
  3760		// match: (PopCount8 x)
  3761		// cond:
  3762		// result: (I64Popcnt (ZeroExt8to64 x))
  3763		for {
  3764			x := v.Args[0]
  3765			v.reset(OpWasmI64Popcnt)
  3766			v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  3767			v0.AddArg(x)
  3768			v.AddArg(v0)
  3769			return true
  3770		}
  3771	}
  3772	func rewriteValueWasm_OpRotateLeft16_0(v *Value) bool {
  3773		b := v.Block
  3774		typ := &b.Func.Config.Types
  3775		// match: (RotateLeft16 <t> x (I64Const [c]))
  3776		// cond:
  3777		// result: (Or16 (Lsh16x64 <t> x (I64Const [c&15])) (Rsh16Ux64 <t> x (I64Const [-c&15])))
  3778		for {
  3779			t := v.Type
  3780			_ = v.Args[1]
  3781			x := v.Args[0]
  3782			v_1 := v.Args[1]
  3783			if v_1.Op != OpWasmI64Const {
  3784				break
  3785			}
  3786			c := v_1.AuxInt
  3787			v.reset(OpOr16)
  3788			v0 := b.NewValue0(v.Pos, OpLsh16x64, t)
  3789			v0.AddArg(x)
  3790			v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  3791			v1.AuxInt = c & 15
  3792			v0.AddArg(v1)
  3793			v.AddArg(v0)
  3794			v2 := b.NewValue0(v.Pos, OpRsh16Ux64, t)
  3795			v2.AddArg(x)
  3796			v3 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  3797			v3.AuxInt = -c & 15
  3798			v2.AddArg(v3)
  3799			v.AddArg(v2)
  3800			return true
  3801		}
  3802		return false
  3803	}
  3804	func rewriteValueWasm_OpRotateLeft32_0(v *Value) bool {
  3805		b := v.Block
  3806		typ := &b.Func.Config.Types
  3807		// match: (RotateLeft32 <t> x (I64Const [c]))
  3808		// cond:
  3809		// result: (Or32 (Lsh32x64 <t> x (I64Const [c&31])) (Rsh32Ux64 <t> x (I64Const [-c&31])))
  3810		for {
  3811			t := v.Type
  3812			_ = v.Args[1]
  3813			x := v.Args[0]
  3814			v_1 := v.Args[1]
  3815			if v_1.Op != OpWasmI64Const {
  3816				break
  3817			}
  3818			c := v_1.AuxInt
  3819			v.reset(OpOr32)
  3820			v0 := b.NewValue0(v.Pos, OpLsh32x64, t)
  3821			v0.AddArg(x)
  3822			v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  3823			v1.AuxInt = c & 31
  3824			v0.AddArg(v1)
  3825			v.AddArg(v0)
  3826			v2 := b.NewValue0(v.Pos, OpRsh32Ux64, t)
  3827			v2.AddArg(x)
  3828			v3 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  3829			v3.AuxInt = -c & 31
  3830			v2.AddArg(v3)
  3831			v.AddArg(v2)
  3832			return true
  3833		}
  3834		return false
  3835	}
  3836	func rewriteValueWasm_OpRotateLeft64_0(v *Value) bool {
  3837		// match: (RotateLeft64 x y)
  3838		// cond:
  3839		// result: (I64Rotl x y)
  3840		for {
  3841			y := v.Args[1]
  3842			x := v.Args[0]
  3843			v.reset(OpWasmI64Rotl)
  3844			v.AddArg(x)
  3845			v.AddArg(y)
  3846			return true
  3847		}
  3848	}
  3849	func rewriteValueWasm_OpRotateLeft8_0(v *Value) bool {
  3850		b := v.Block
  3851		typ := &b.Func.Config.Types
  3852		// match: (RotateLeft8 <t> x (I64Const [c]))
  3853		// cond:
  3854		// result: (Or8 (Lsh8x64 <t> x (I64Const [c&7])) (Rsh8Ux64 <t> x (I64Const [-c&7])))
  3855		for {
  3856			t := v.Type
  3857			_ = v.Args[1]
  3858			x := v.Args[0]
  3859			v_1 := v.Args[1]
  3860			if v_1.Op != OpWasmI64Const {
  3861				break
  3862			}
  3863			c := v_1.AuxInt
  3864			v.reset(OpOr8)
  3865			v0 := b.NewValue0(v.Pos, OpLsh8x64, t)
  3866			v0.AddArg(x)
  3867			v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  3868			v1.AuxInt = c & 7
  3869			v0.AddArg(v1)
  3870			v.AddArg(v0)
  3871			v2 := b.NewValue0(v.Pos, OpRsh8Ux64, t)
  3872			v2.AddArg(x)
  3873			v3 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  3874			v3.AuxInt = -c & 7
  3875			v2.AddArg(v3)
  3876			v.AddArg(v2)
  3877			return true
  3878		}
  3879		return false
  3880	}
  3881	func rewriteValueWasm_OpRound32F_0(v *Value) bool {
  3882		// match: (Round32F x)
  3883		// cond:
  3884		// result: (LoweredRound32F x)
  3885		for {
  3886			x := v.Args[0]
  3887			v.reset(OpWasmLoweredRound32F)
  3888			v.AddArg(x)
  3889			return true
  3890		}
  3891	}
  3892	func rewriteValueWasm_OpRound64F_0(v *Value) bool {
  3893		// match: (Round64F x)
  3894		// cond:
  3895		// result: x
  3896		for {
  3897			x := v.Args[0]
  3898			v.reset(OpCopy)
  3899			v.Type = x.Type
  3900			v.AddArg(x)
  3901			return true
  3902		}
  3903	}
  3904	func rewriteValueWasm_OpRoundToEven_0(v *Value) bool {
  3905		// match: (RoundToEven x)
  3906		// cond:
  3907		// result: (F64Nearest x)
  3908		for {
  3909			x := v.Args[0]
  3910			v.reset(OpWasmF64Nearest)
  3911			v.AddArg(x)
  3912			return true
  3913		}
  3914	}
  3915	func rewriteValueWasm_OpRsh16Ux16_0(v *Value) bool {
  3916		b := v.Block
  3917		typ := &b.Func.Config.Types
  3918		// match: (Rsh16Ux16 x y)
  3919		// cond:
  3920		// result: (Rsh64Ux64 (ZeroExt16to64 x) (ZeroExt16to64 y))
  3921		for {
  3922			y := v.Args[1]
  3923			x := v.Args[0]
  3924			v.reset(OpRsh64Ux64)
  3925			v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  3926			v0.AddArg(x)
  3927			v.AddArg(v0)
  3928			v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  3929			v1.AddArg(y)
  3930			v.AddArg(v1)
  3931			return true
  3932		}
  3933	}
  3934	func rewriteValueWasm_OpRsh16Ux32_0(v *Value) bool {
  3935		b := v.Block
  3936		typ := &b.Func.Config.Types
  3937		// match: (Rsh16Ux32 x y)
  3938		// cond:
  3939		// result: (Rsh64Ux64 (ZeroExt16to64 x) (ZeroExt32to64 y))
  3940		for {
  3941			y := v.Args[1]
  3942			x := v.Args[0]
  3943			v.reset(OpRsh64Ux64)
  3944			v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  3945			v0.AddArg(x)
  3946			v.AddArg(v0)
  3947			v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  3948			v1.AddArg(y)
  3949			v.AddArg(v1)
  3950			return true
  3951		}
  3952	}
  3953	func rewriteValueWasm_OpRsh16Ux64_0(v *Value) bool {
  3954		b := v.Block
  3955		typ := &b.Func.Config.Types
  3956		// match: (Rsh16Ux64 x y)
  3957		// cond:
  3958		// result: (Rsh64Ux64 (ZeroExt16to64 x) y)
  3959		for {
  3960			y := v.Args[1]
  3961			x := v.Args[0]
  3962			v.reset(OpRsh64Ux64)
  3963			v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  3964			v0.AddArg(x)
  3965			v.AddArg(v0)
  3966			v.AddArg(y)
  3967			return true
  3968		}
  3969	}
  3970	func rewriteValueWasm_OpRsh16Ux8_0(v *Value) bool {
  3971		b := v.Block
  3972		typ := &b.Func.Config.Types
  3973		// match: (Rsh16Ux8 x y)
  3974		// cond:
  3975		// result: (Rsh64Ux64 (ZeroExt16to64 x) (ZeroExt8to64 y))
  3976		for {
  3977			y := v.Args[1]
  3978			x := v.Args[0]
  3979			v.reset(OpRsh64Ux64)
  3980			v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  3981			v0.AddArg(x)
  3982			v.AddArg(v0)
  3983			v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  3984			v1.AddArg(y)
  3985			v.AddArg(v1)
  3986			return true
  3987		}
  3988	}
  3989	func rewriteValueWasm_OpRsh16x16_0(v *Value) bool {
  3990		b := v.Block
  3991		typ := &b.Func.Config.Types
  3992		// match: (Rsh16x16 x y)
  3993		// cond:
  3994		// result: (Rsh64x64 (SignExt16to64 x) (ZeroExt16to64 y))
  3995		for {
  3996			y := v.Args[1]
  3997			x := v.Args[0]
  3998			v.reset(OpRsh64x64)
  3999			v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
  4000			v0.AddArg(x)
  4001			v.AddArg(v0)
  4002			v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  4003			v1.AddArg(y)
  4004			v.AddArg(v1)
  4005			return true
  4006		}
  4007	}
  4008	func rewriteValueWasm_OpRsh16x32_0(v *Value) bool {
  4009		b := v.Block
  4010		typ := &b.Func.Config.Types
  4011		// match: (Rsh16x32 x y)
  4012		// cond:
  4013		// result: (Rsh64x64 (SignExt16to64 x) (ZeroExt32to64 y))
  4014		for {
  4015			y := v.Args[1]
  4016			x := v.Args[0]
  4017			v.reset(OpRsh64x64)
  4018			v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
  4019			v0.AddArg(x)
  4020			v.AddArg(v0)
  4021			v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  4022			v1.AddArg(y)
  4023			v.AddArg(v1)
  4024			return true
  4025		}
  4026	}
  4027	func rewriteValueWasm_OpRsh16x64_0(v *Value) bool {
  4028		b := v.Block
  4029		typ := &b.Func.Config.Types
  4030		// match: (Rsh16x64 x y)
  4031		// cond:
  4032		// result: (Rsh64x64 (SignExt16to64 x) y)
  4033		for {
  4034			y := v.Args[1]
  4035			x := v.Args[0]
  4036			v.reset(OpRsh64x64)
  4037			v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
  4038			v0.AddArg(x)
  4039			v.AddArg(v0)
  4040			v.AddArg(y)
  4041			return true
  4042		}
  4043	}
  4044	func rewriteValueWasm_OpRsh16x8_0(v *Value) bool {
  4045		b := v.Block
  4046		typ := &b.Func.Config.Types
  4047		// match: (Rsh16x8 x y)
  4048		// cond:
  4049		// result: (Rsh64x64 (SignExt16to64 x) (ZeroExt8to64 y))
  4050		for {
  4051			y := v.Args[1]
  4052			x := v.Args[0]
  4053			v.reset(OpRsh64x64)
  4054			v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
  4055			v0.AddArg(x)
  4056			v.AddArg(v0)
  4057			v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  4058			v1.AddArg(y)
  4059			v.AddArg(v1)
  4060			return true
  4061		}
  4062	}
  4063	func rewriteValueWasm_OpRsh32Ux16_0(v *Value) bool {
  4064		b := v.Block
  4065		typ := &b.Func.Config.Types
  4066		// match: (Rsh32Ux16 x y)
  4067		// cond:
  4068		// result: (Rsh64Ux64 (ZeroExt32to64 x) (ZeroExt16to64 y))
  4069		for {
  4070			y := v.Args[1]
  4071			x := v.Args[0]
  4072			v.reset(OpRsh64Ux64)
  4073			v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  4074			v0.AddArg(x)
  4075			v.AddArg(v0)
  4076			v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  4077			v1.AddArg(y)
  4078			v.AddArg(v1)
  4079			return true
  4080		}
  4081	}
  4082	func rewriteValueWasm_OpRsh32Ux32_0(v *Value) bool {
  4083		b := v.Block
  4084		typ := &b.Func.Config.Types
  4085		// match: (Rsh32Ux32 x y)
  4086		// cond:
  4087		// result: (Rsh64Ux64 (ZeroExt32to64 x) (ZeroExt32to64 y))
  4088		for {
  4089			y := v.Args[1]
  4090			x := v.Args[0]
  4091			v.reset(OpRsh64Ux64)
  4092			v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  4093			v0.AddArg(x)
  4094			v.AddArg(v0)
  4095			v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  4096			v1.AddArg(y)
  4097			v.AddArg(v1)
  4098			return true
  4099		}
  4100	}
  4101	func rewriteValueWasm_OpRsh32Ux64_0(v *Value) bool {
  4102		b := v.Block
  4103		typ := &b.Func.Config.Types
  4104		// match: (Rsh32Ux64 x y)
  4105		// cond:
  4106		// result: (Rsh64Ux64 (ZeroExt32to64 x) y)
  4107		for {
  4108			y := v.Args[1]
  4109			x := v.Args[0]
  4110			v.reset(OpRsh64Ux64)
  4111			v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  4112			v0.AddArg(x)
  4113			v.AddArg(v0)
  4114			v.AddArg(y)
  4115			return true
  4116		}
  4117	}
  4118	func rewriteValueWasm_OpRsh32Ux8_0(v *Value) bool {
  4119		b := v.Block
  4120		typ := &b.Func.Config.Types
  4121		// match: (Rsh32Ux8 x y)
  4122		// cond:
  4123		// result: (Rsh64Ux64 (ZeroExt32to64 x) (ZeroExt8to64 y))
  4124		for {
  4125			y := v.Args[1]
  4126			x := v.Args[0]
  4127			v.reset(OpRsh64Ux64)
  4128			v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  4129			v0.AddArg(x)
  4130			v.AddArg(v0)
  4131			v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  4132			v1.AddArg(y)
  4133			v.AddArg(v1)
  4134			return true
  4135		}
  4136	}
  4137	func rewriteValueWasm_OpRsh32x16_0(v *Value) bool {
  4138		b := v.Block
  4139		typ := &b.Func.Config.Types
  4140		// match: (Rsh32x16 x y)
  4141		// cond:
  4142		// result: (Rsh64x64 (SignExt32to64 x) (ZeroExt16to64 y))
  4143		for {
  4144			y := v.Args[1]
  4145			x := v.Args[0]
  4146			v.reset(OpRsh64x64)
  4147			v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
  4148			v0.AddArg(x)
  4149			v.AddArg(v0)
  4150			v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  4151			v1.AddArg(y)
  4152			v.AddArg(v1)
  4153			return true
  4154		}
  4155	}
  4156	func rewriteValueWasm_OpRsh32x32_0(v *Value) bool {
  4157		b := v.Block
  4158		typ := &b.Func.Config.Types
  4159		// match: (Rsh32x32 x y)
  4160		// cond:
  4161		// result: (Rsh64x64 (SignExt32to64 x) (ZeroExt32to64 y))
  4162		for {
  4163			y := v.Args[1]
  4164			x := v.Args[0]
  4165			v.reset(OpRsh64x64)
  4166			v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
  4167			v0.AddArg(x)
  4168			v.AddArg(v0)
  4169			v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  4170			v1.AddArg(y)
  4171			v.AddArg(v1)
  4172			return true
  4173		}
  4174	}
  4175	func rewriteValueWasm_OpRsh32x64_0(v *Value) bool {
  4176		b := v.Block
  4177		typ := &b.Func.Config.Types
  4178		// match: (Rsh32x64 x y)
  4179		// cond:
  4180		// result: (Rsh64x64 (SignExt32to64 x) y)
  4181		for {
  4182			y := v.Args[1]
  4183			x := v.Args[0]
  4184			v.reset(OpRsh64x64)
  4185			v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
  4186			v0.AddArg(x)
  4187			v.AddArg(v0)
  4188			v.AddArg(y)
  4189			return true
  4190		}
  4191	}
  4192	func rewriteValueWasm_OpRsh32x8_0(v *Value) bool {
  4193		b := v.Block
  4194		typ := &b.Func.Config.Types
  4195		// match: (Rsh32x8 x y)
  4196		// cond:
  4197		// result: (Rsh64x64 (SignExt32to64 x) (ZeroExt8to64 y))
  4198		for {
  4199			y := v.Args[1]
  4200			x := v.Args[0]
  4201			v.reset(OpRsh64x64)
  4202			v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
  4203			v0.AddArg(x)
  4204			v.AddArg(v0)
  4205			v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  4206			v1.AddArg(y)
  4207			v.AddArg(v1)
  4208			return true
  4209		}
  4210	}
  4211	func rewriteValueWasm_OpRsh64Ux16_0(v *Value) bool {
  4212		b := v.Block
  4213		typ := &b.Func.Config.Types
  4214		// match: (Rsh64Ux16 x y)
  4215		// cond:
  4216		// result: (Rsh64Ux64 x (ZeroExt16to64 y))
  4217		for {
  4218			y := v.Args[1]
  4219			x := v.Args[0]
  4220			v.reset(OpRsh64Ux64)
  4221			v.AddArg(x)
  4222			v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  4223			v0.AddArg(y)
  4224			v.AddArg(v0)
  4225			return true
  4226		}
  4227	}
  4228	func rewriteValueWasm_OpRsh64Ux32_0(v *Value) bool {
  4229		b := v.Block
  4230		typ := &b.Func.Config.Types
  4231		// match: (Rsh64Ux32 x y)
  4232		// cond:
  4233		// result: (Rsh64Ux64 x (ZeroExt32to64 y))
  4234		for {
  4235			y := v.Args[1]
  4236			x := v.Args[0]
  4237			v.reset(OpRsh64Ux64)
  4238			v.AddArg(x)
  4239			v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  4240			v0.AddArg(y)
  4241			v.AddArg(v0)
  4242			return true
  4243		}
  4244	}
  4245	func rewriteValueWasm_OpRsh64Ux64_0(v *Value) bool {
  4246		b := v.Block
  4247		typ := &b.Func.Config.Types
  4248		// match: (Rsh64Ux64 x y)
  4249		// cond:
  4250		// result: (Select (I64ShrU x y) (I64Const [0]) (I64LtU y (I64Const [64])))
  4251		for {
  4252			y := v.Args[1]
  4253			x := v.Args[0]
  4254			v.reset(OpWasmSelect)
  4255			v0 := b.NewValue0(v.Pos, OpWasmI64ShrU, typ.Int64)
  4256			v0.AddArg(x)
  4257			v0.AddArg(y)
  4258			v.AddArg(v0)
  4259			v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  4260			v1.AuxInt = 0
  4261			v.AddArg(v1)
  4262			v2 := b.NewValue0(v.Pos, OpWasmI64LtU, typ.Bool)
  4263			v2.AddArg(y)
  4264			v3 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  4265			v3.AuxInt = 64
  4266			v2.AddArg(v3)
  4267			v.AddArg(v2)
  4268			return true
  4269		}
  4270	}
  4271	func rewriteValueWasm_OpRsh64Ux8_0(v *Value) bool {
  4272		b := v.Block
  4273		typ := &b.Func.Config.Types
  4274		// match: (Rsh64Ux8 x y)
  4275		// cond:
  4276		// result: (Rsh64Ux64 x (ZeroExt8to64 y))
  4277		for {
  4278			y := v.Args[1]
  4279			x := v.Args[0]
  4280			v.reset(OpRsh64Ux64)
  4281			v.AddArg(x)
  4282			v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  4283			v0.AddArg(y)
  4284			v.AddArg(v0)
  4285			return true
  4286		}
  4287	}
  4288	func rewriteValueWasm_OpRsh64x16_0(v *Value) bool {
  4289		b := v.Block
  4290		typ := &b.Func.Config.Types
  4291		// match: (Rsh64x16 x y)
  4292		// cond:
  4293		// result: (Rsh64x64 x (ZeroExt16to64 y))
  4294		for {
  4295			y := v.Args[1]
  4296			x := v.Args[0]
  4297			v.reset(OpRsh64x64)
  4298			v.AddArg(x)
  4299			v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  4300			v0.AddArg(y)
  4301			v.AddArg(v0)
  4302			return true
  4303		}
  4304	}
  4305	func rewriteValueWasm_OpRsh64x32_0(v *Value) bool {
  4306		b := v.Block
  4307		typ := &b.Func.Config.Types
  4308		// match: (Rsh64x32 x y)
  4309		// cond:
  4310		// result: (Rsh64x64 x (ZeroExt32to64 y))
  4311		for {
  4312			y := v.Args[1]
  4313			x := v.Args[0]
  4314			v.reset(OpRsh64x64)
  4315			v.AddArg(x)
  4316			v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  4317			v0.AddArg(y)
  4318			v.AddArg(v0)
  4319			return true
  4320		}
  4321	}
  4322	func rewriteValueWasm_OpRsh64x64_0(v *Value) bool {
  4323		b := v.Block
  4324		typ := &b.Func.Config.Types
  4325		// match: (Rsh64x64 x y)
  4326		// cond:
  4327		// result: (I64ShrS x (Select <typ.Int64> y (I64Const [63]) (I64LtU y (I64Const [64]))))
  4328		for {
  4329			y := v.Args[1]
  4330			x := v.Args[0]
  4331			v.reset(OpWasmI64ShrS)
  4332			v.AddArg(x)
  4333			v0 := b.NewValue0(v.Pos, OpWasmSelect, typ.Int64)
  4334			v0.AddArg(y)
  4335			v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  4336			v1.AuxInt = 63
  4337			v0.AddArg(v1)
  4338			v2 := b.NewValue0(v.Pos, OpWasmI64LtU, typ.Bool)
  4339			v2.AddArg(y)
  4340			v3 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  4341			v3.AuxInt = 64
  4342			v2.AddArg(v3)
  4343			v0.AddArg(v2)
  4344			v.AddArg(v0)
  4345			return true
  4346		}
  4347	}
  4348	func rewriteValueWasm_OpRsh64x8_0(v *Value) bool {
  4349		b := v.Block
  4350		typ := &b.Func.Config.Types
  4351		// match: (Rsh64x8 x y)
  4352		// cond:
  4353		// result: (Rsh64x64 x (ZeroExt8to64 y))
  4354		for {
  4355			y := v.Args[1]
  4356			x := v.Args[0]
  4357			v.reset(OpRsh64x64)
  4358			v.AddArg(x)
  4359			v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  4360			v0.AddArg(y)
  4361			v.AddArg(v0)
  4362			return true
  4363		}
  4364	}
  4365	func rewriteValueWasm_OpRsh8Ux16_0(v *Value) bool {
  4366		b := v.Block
  4367		typ := &b.Func.Config.Types
  4368		// match: (Rsh8Ux16 x y)
  4369		// cond:
  4370		// result: (Rsh64Ux64 (ZeroExt8to64 x) (ZeroExt16to64 y))
  4371		for {
  4372			y := v.Args[1]
  4373			x := v.Args[0]
  4374			v.reset(OpRsh64Ux64)
  4375			v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  4376			v0.AddArg(x)
  4377			v.AddArg(v0)
  4378			v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  4379			v1.AddArg(y)
  4380			v.AddArg(v1)
  4381			return true
  4382		}
  4383	}
  4384	func rewriteValueWasm_OpRsh8Ux32_0(v *Value) bool {
  4385		b := v.Block
  4386		typ := &b.Func.Config.Types
  4387		// match: (Rsh8Ux32 x y)
  4388		// cond:
  4389		// result: (Rsh64Ux64 (ZeroExt8to64 x) (ZeroExt32to64 y))
  4390		for {
  4391			y := v.Args[1]
  4392			x := v.Args[0]
  4393			v.reset(OpRsh64Ux64)
  4394			v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  4395			v0.AddArg(x)
  4396			v.AddArg(v0)
  4397			v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  4398			v1.AddArg(y)
  4399			v.AddArg(v1)
  4400			return true
  4401		}
  4402	}
  4403	func rewriteValueWasm_OpRsh8Ux64_0(v *Value) bool {
  4404		b := v.Block
  4405		typ := &b.Func.Config.Types
  4406		// match: (Rsh8Ux64 x y)
  4407		// cond:
  4408		// result: (Rsh64Ux64 (ZeroExt8to64 x) y)
  4409		for {
  4410			y := v.Args[1]
  4411			x := v.Args[0]
  4412			v.reset(OpRsh64Ux64)
  4413			v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  4414			v0.AddArg(x)
  4415			v.AddArg(v0)
  4416			v.AddArg(y)
  4417			return true
  4418		}
  4419	}
  4420	func rewriteValueWasm_OpRsh8Ux8_0(v *Value) bool {
  4421		b := v.Block
  4422		typ := &b.Func.Config.Types
  4423		// match: (Rsh8Ux8 x y)
  4424		// cond:
  4425		// result: (Rsh64Ux64 (ZeroExt8to64 x) (ZeroExt8to64 y))
  4426		for {
  4427			y := v.Args[1]
  4428			x := v.Args[0]
  4429			v.reset(OpRsh64Ux64)
  4430			v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  4431			v0.AddArg(x)
  4432			v.AddArg(v0)
  4433			v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  4434			v1.AddArg(y)
  4435			v.AddArg(v1)
  4436			return true
  4437		}
  4438	}
  4439	func rewriteValueWasm_OpRsh8x16_0(v *Value) bool {
  4440		b := v.Block
  4441		typ := &b.Func.Config.Types
  4442		// match: (Rsh8x16 x y)
  4443		// cond:
  4444		// result: (Rsh64x64 (SignExt8to64 x) (ZeroExt16to64 y))
  4445		for {
  4446			y := v.Args[1]
  4447			x := v.Args[0]
  4448			v.reset(OpRsh64x64)
  4449			v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
  4450			v0.AddArg(x)
  4451			v.AddArg(v0)
  4452			v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  4453			v1.AddArg(y)
  4454			v.AddArg(v1)
  4455			return true
  4456		}
  4457	}
  4458	func rewriteValueWasm_OpRsh8x32_0(v *Value) bool {
  4459		b := v.Block
  4460		typ := &b.Func.Config.Types
  4461		// match: (Rsh8x32 x y)
  4462		// cond:
  4463		// result: (Rsh64x64 (SignExt8to64 x) (ZeroExt32to64 y))
  4464		for {
  4465			y := v.Args[1]
  4466			x := v.Args[0]
  4467			v.reset(OpRsh64x64)
  4468			v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
  4469			v0.AddArg(x)
  4470			v.AddArg(v0)
  4471			v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  4472			v1.AddArg(y)
  4473			v.AddArg(v1)
  4474			return true
  4475		}
  4476	}
  4477	func rewriteValueWasm_OpRsh8x64_0(v *Value) bool {
  4478		b := v.Block
  4479		typ := &b.Func.Config.Types
  4480		// match: (Rsh8x64 x y)
  4481		// cond:
  4482		// result: (Rsh64x64 (SignExt8to64 x) y)
  4483		for {
  4484			y := v.Args[1]
  4485			x := v.Args[0]
  4486			v.reset(OpRsh64x64)
  4487			v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
  4488			v0.AddArg(x)
  4489			v.AddArg(v0)
  4490			v.AddArg(y)
  4491			return true
  4492		}
  4493	}
  4494	func rewriteValueWasm_OpRsh8x8_0(v *Value) bool {
  4495		b := v.Block
  4496		typ := &b.Func.Config.Types
  4497		// match: (Rsh8x8 x y)
  4498		// cond:
  4499		// result: (Rsh64x64 (SignExt8to64 x) (ZeroExt8to64 y))
  4500		for {
  4501			y := v.Args[1]
  4502			x := v.Args[0]
  4503			v.reset(OpRsh64x64)
  4504			v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
  4505			v0.AddArg(x)
  4506			v.AddArg(v0)
  4507			v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  4508			v1.AddArg(y)
  4509			v.AddArg(v1)
  4510			return true
  4511		}
  4512	}
  4513	func rewriteValueWasm_OpSignExt16to32_0(v *Value) bool {
  4514		b := v.Block
  4515		typ := &b.Func.Config.Types
  4516		// match: (SignExt16to32 x:(I64Load16S _ _))
  4517		// cond:
  4518		// result: x
  4519		for {
  4520			x := v.Args[0]
  4521			if x.Op != OpWasmI64Load16S {
  4522				break
  4523			}
  4524			_ = x.Args[1]
  4525			v.reset(OpCopy)
  4526			v.Type = x.Type
  4527			v.AddArg(x)
  4528			return true
  4529		}
  4530		// match: (SignExt16to32 x)
  4531		// cond: objabi.GOWASM.SignExt
  4532		// result: (I64Extend16S x)
  4533		for {
  4534			x := v.Args[0]
  4535			if !(objabi.GOWASM.SignExt) {
  4536				break
  4537			}
  4538			v.reset(OpWasmI64Extend16S)
  4539			v.AddArg(x)
  4540			return true
  4541		}
  4542		// match: (SignExt16to32 x)
  4543		// cond:
  4544		// result: (I64ShrS (I64Shl x (I64Const [48])) (I64Const [48]))
  4545		for {
  4546			x := v.Args[0]
  4547			v.reset(OpWasmI64ShrS)
  4548			v0 := b.NewValue0(v.Pos, OpWasmI64Shl, typ.Int64)
  4549			v0.AddArg(x)
  4550			v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  4551			v1.AuxInt = 48
  4552			v0.AddArg(v1)
  4553			v.AddArg(v0)
  4554			v2 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  4555			v2.AuxInt = 48
  4556			v.AddArg(v2)
  4557			return true
  4558		}
  4559	}
  4560	func rewriteValueWasm_OpSignExt16to64_0(v *Value) bool {
  4561		b := v.Block
  4562		typ := &b.Func.Config.Types
  4563		// match: (SignExt16to64 x:(I64Load16S _ _))
  4564		// cond:
  4565		// result: x
  4566		for {
  4567			x := v.Args[0]
  4568			if x.Op != OpWasmI64Load16S {
  4569				break
  4570			}
  4571			_ = x.Args[1]
  4572			v.reset(OpCopy)
  4573			v.Type = x.Type
  4574			v.AddArg(x)
  4575			return true
  4576		}
  4577		// match: (SignExt16to64 x)
  4578		// cond: objabi.GOWASM.SignExt
  4579		// result: (I64Extend16S x)
  4580		for {
  4581			x := v.Args[0]
  4582			if !(objabi.GOWASM.SignExt) {
  4583				break
  4584			}
  4585			v.reset(OpWasmI64Extend16S)
  4586			v.AddArg(x)
  4587			return true
  4588		}
  4589		// match: (SignExt16to64 x)
  4590		// cond:
  4591		// result: (I64ShrS (I64Shl x (I64Const [48])) (I64Const [48]))
  4592		for {
  4593			x := v.Args[0]
  4594			v.reset(OpWasmI64ShrS)
  4595			v0 := b.NewValue0(v.Pos, OpWasmI64Shl, typ.Int64)
  4596			v0.AddArg(x)
  4597			v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  4598			v1.AuxInt = 48
  4599			v0.AddArg(v1)
  4600			v.AddArg(v0)
  4601			v2 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  4602			v2.AuxInt = 48
  4603			v.AddArg(v2)
  4604			return true
  4605		}
  4606	}
  4607	func rewriteValueWasm_OpSignExt32to64_0(v *Value) bool {
  4608		b := v.Block
  4609		typ := &b.Func.Config.Types
  4610		// match: (SignExt32to64 x:(I64Load32S _ _))
  4611		// cond:
  4612		// result: x
  4613		for {
  4614			x := v.Args[0]
  4615			if x.Op != OpWasmI64Load32S {
  4616				break
  4617			}
  4618			_ = x.Args[1]
  4619			v.reset(OpCopy)
  4620			v.Type = x.Type
  4621			v.AddArg(x)
  4622			return true
  4623		}
  4624		// match: (SignExt32to64 x)
  4625		// cond: objabi.GOWASM.SignExt
  4626		// result: (I64Extend32S x)
  4627		for {
  4628			x := v.Args[0]
  4629			if !(objabi.GOWASM.SignExt) {
  4630				break
  4631			}
  4632			v.reset(OpWasmI64Extend32S)
  4633			v.AddArg(x)
  4634			return true
  4635		}
  4636		// match: (SignExt32to64 x)
  4637		// cond:
  4638		// result: (I64ShrS (I64Shl x (I64Const [32])) (I64Const [32]))
  4639		for {
  4640			x := v.Args[0]
  4641			v.reset(OpWasmI64ShrS)
  4642			v0 := b.NewValue0(v.Pos, OpWasmI64Shl, typ.Int64)
  4643			v0.AddArg(x)
  4644			v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  4645			v1.AuxInt = 32
  4646			v0.AddArg(v1)
  4647			v.AddArg(v0)
  4648			v2 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  4649			v2.AuxInt = 32
  4650			v.AddArg(v2)
  4651			return true
  4652		}
  4653	}
  4654	func rewriteValueWasm_OpSignExt8to16_0(v *Value) bool {
  4655		b := v.Block
  4656		typ := &b.Func.Config.Types
  4657		// match: (SignExt8to16 x:(I64Load8S _ _))
  4658		// cond:
  4659		// result: x
  4660		for {
  4661			x := v.Args[0]
  4662			if x.Op != OpWasmI64Load8S {
  4663				break
  4664			}
  4665			_ = x.Args[1]
  4666			v.reset(OpCopy)
  4667			v.Type = x.Type
  4668			v.AddArg(x)
  4669			return true
  4670		}
  4671		// match: (SignExt8to16 x)
  4672		// cond: objabi.GOWASM.SignExt
  4673		// result: (I64Extend8S x)
  4674		for {
  4675			x := v.Args[0]
  4676			if !(objabi.GOWASM.SignExt) {
  4677				break
  4678			}
  4679			v.reset(OpWasmI64Extend8S)
  4680			v.AddArg(x)
  4681			return true
  4682		}
  4683		// match: (SignExt8to16 x)
  4684		// cond:
  4685		// result: (I64ShrS (I64Shl x (I64Const [56])) (I64Const [56]))
  4686		for {
  4687			x := v.Args[0]
  4688			v.reset(OpWasmI64ShrS)
  4689			v0 := b.NewValue0(v.Pos, OpWasmI64Shl, typ.Int64)
  4690			v0.AddArg(x)
  4691			v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  4692			v1.AuxInt = 56
  4693			v0.AddArg(v1)
  4694			v.AddArg(v0)
  4695			v2 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  4696			v2.AuxInt = 56
  4697			v.AddArg(v2)
  4698			return true
  4699		}
  4700	}
  4701	func rewriteValueWasm_OpSignExt8to32_0(v *Value) bool {
  4702		b := v.Block
  4703		typ := &b.Func.Config.Types
  4704		// match: (SignExt8to32 x:(I64Load8S _ _))
  4705		// cond:
  4706		// result: x
  4707		for {
  4708			x := v.Args[0]
  4709			if x.Op != OpWasmI64Load8S {
  4710				break
  4711			}
  4712			_ = x.Args[1]
  4713			v.reset(OpCopy)
  4714			v.Type = x.Type
  4715			v.AddArg(x)
  4716			return true
  4717		}
  4718		// match: (SignExt8to32 x)
  4719		// cond: objabi.GOWASM.SignExt
  4720		// result: (I64Extend8S x)
  4721		for {
  4722			x := v.Args[0]
  4723			if !(objabi.GOWASM.SignExt) {
  4724				break
  4725			}
  4726			v.reset(OpWasmI64Extend8S)
  4727			v.AddArg(x)
  4728			return true
  4729		}
  4730		// match: (SignExt8to32 x)
  4731		// cond:
  4732		// result: (I64ShrS (I64Shl x (I64Const [56])) (I64Const [56]))
  4733		for {
  4734			x := v.Args[0]
  4735			v.reset(OpWasmI64ShrS)
  4736			v0 := b.NewValue0(v.Pos, OpWasmI64Shl, typ.Int64)
  4737			v0.AddArg(x)
  4738			v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  4739			v1.AuxInt = 56
  4740			v0.AddArg(v1)
  4741			v.AddArg(v0)
  4742			v2 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  4743			v2.AuxInt = 56
  4744			v.AddArg(v2)
  4745			return true
  4746		}
  4747	}
  4748	func rewriteValueWasm_OpSignExt8to64_0(v *Value) bool {
  4749		b := v.Block
  4750		typ := &b.Func.Config.Types
  4751		// match: (SignExt8to64 x:(I64Load8S _ _))
  4752		// cond:
  4753		// result: x
  4754		for {
  4755			x := v.Args[0]
  4756			if x.Op != OpWasmI64Load8S {
  4757				break
  4758			}
  4759			_ = x.Args[1]
  4760			v.reset(OpCopy)
  4761			v.Type = x.Type
  4762			v.AddArg(x)
  4763			return true
  4764		}
  4765		// match: (SignExt8to64 x)
  4766		// cond: objabi.GOWASM.SignExt
  4767		// result: (I64Extend8S x)
  4768		for {
  4769			x := v.Args[0]
  4770			if !(objabi.GOWASM.SignExt) {
  4771				break
  4772			}
  4773			v.reset(OpWasmI64Extend8S)
  4774			v.AddArg(x)
  4775			return true
  4776		}
  4777		// match: (SignExt8to64 x)
  4778		// cond:
  4779		// result: (I64ShrS (I64Shl x (I64Const [56])) (I64Const [56]))
  4780		for {
  4781			x := v.Args[0]
  4782			v.reset(OpWasmI64ShrS)
  4783			v0 := b.NewValue0(v.Pos, OpWasmI64Shl, typ.Int64)
  4784			v0.AddArg(x)
  4785			v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  4786			v1.AuxInt = 56
  4787			v0.AddArg(v1)
  4788			v.AddArg(v0)
  4789			v2 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  4790			v2.AuxInt = 56
  4791			v.AddArg(v2)
  4792			return true
  4793		}
  4794	}
  4795	func rewriteValueWasm_OpSlicemask_0(v *Value) bool {
  4796		b := v.Block
  4797		typ := &b.Func.Config.Types
  4798		// match: (Slicemask x)
  4799		// cond:
  4800		// result: (I64ShrS (I64Sub (I64Const [0]) x) (I64Const [63]))
  4801		for {
  4802			x := v.Args[0]
  4803			v.reset(OpWasmI64ShrS)
  4804			v0 := b.NewValue0(v.Pos, OpWasmI64Sub, typ.Int64)
  4805			v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  4806			v1.AuxInt = 0
  4807			v0.AddArg(v1)
  4808			v0.AddArg(x)
  4809			v.AddArg(v0)
  4810			v2 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  4811			v2.AuxInt = 63
  4812			v.AddArg(v2)
  4813			return true
  4814		}
  4815	}
  4816	func rewriteValueWasm_OpSqrt_0(v *Value) bool {
  4817		// match: (Sqrt x)
  4818		// cond:
  4819		// result: (F64Sqrt x)
  4820		for {
  4821			x := v.Args[0]
  4822			v.reset(OpWasmF64Sqrt)
  4823			v.AddArg(x)
  4824			return true
  4825		}
  4826	}
  4827	func rewriteValueWasm_OpStaticCall_0(v *Value) bool {
  4828		// match: (StaticCall [argwid] {target} mem)
  4829		// cond:
  4830		// result: (LoweredStaticCall [argwid] {target} mem)
  4831		for {
  4832			argwid := v.AuxInt
  4833			target := v.Aux
  4834			mem := v.Args[0]
  4835			v.reset(OpWasmLoweredStaticCall)
  4836			v.AuxInt = argwid
  4837			v.Aux = target
  4838			v.AddArg(mem)
  4839			return true
  4840		}
  4841	}
  4842	func rewriteValueWasm_OpStore_0(v *Value) bool {
  4843		// match: (Store {t} ptr val mem)
  4844		// cond: is64BitFloat(t.(*types.Type))
  4845		// result: (F64Store ptr val mem)
  4846		for {
  4847			t := v.Aux
  4848			mem := v.Args[2]
  4849			ptr := v.Args[0]
  4850			val := v.Args[1]
  4851			if !(is64BitFloat(t.(*types.Type))) {
  4852				break
  4853			}
  4854			v.reset(OpWasmF64Store)
  4855			v.AddArg(ptr)
  4856			v.AddArg(val)
  4857			v.AddArg(mem)
  4858			return true
  4859		}
  4860		// match: (Store {t} ptr val mem)
  4861		// cond: is32BitFloat(t.(*types.Type))
  4862		// result: (F32Store ptr val mem)
  4863		for {
  4864			t := v.Aux
  4865			mem := v.Args[2]
  4866			ptr := v.Args[0]
  4867			val := v.Args[1]
  4868			if !(is32BitFloat(t.(*types.Type))) {
  4869				break
  4870			}
  4871			v.reset(OpWasmF32Store)
  4872			v.AddArg(ptr)
  4873			v.AddArg(val)
  4874			v.AddArg(mem)
  4875			return true
  4876		}
  4877		// match: (Store {t} ptr val mem)
  4878		// cond: t.(*types.Type).Size() == 8
  4879		// result: (I64Store ptr val mem)
  4880		for {
  4881			t := v.Aux
  4882			mem := v.Args[2]
  4883			ptr := v.Args[0]
  4884			val := v.Args[1]
  4885			if !(t.(*types.Type).Size() == 8) {
  4886				break
  4887			}
  4888			v.reset(OpWasmI64Store)
  4889			v.AddArg(ptr)
  4890			v.AddArg(val)
  4891			v.AddArg(mem)
  4892			return true
  4893		}
  4894		// match: (Store {t} ptr val mem)
  4895		// cond: t.(*types.Type).Size() == 4
  4896		// result: (I64Store32 ptr val mem)
  4897		for {
  4898			t := v.Aux
  4899			mem := v.Args[2]
  4900			ptr := v.Args[0]
  4901			val := v.Args[1]
  4902			if !(t.(*types.Type).Size() == 4) {
  4903				break
  4904			}
  4905			v.reset(OpWasmI64Store32)
  4906			v.AddArg(ptr)
  4907			v.AddArg(val)
  4908			v.AddArg(mem)
  4909			return true
  4910		}
  4911		// match: (Store {t} ptr val mem)
  4912		// cond: t.(*types.Type).Size() == 2
  4913		// result: (I64Store16 ptr val mem)
  4914		for {
  4915			t := v.Aux
  4916			mem := v.Args[2]
  4917			ptr := v.Args[0]
  4918			val := v.Args[1]
  4919			if !(t.(*types.Type).Size() == 2) {
  4920				break
  4921			}
  4922			v.reset(OpWasmI64Store16)
  4923			v.AddArg(ptr)
  4924			v.AddArg(val)
  4925			v.AddArg(mem)
  4926			return true
  4927		}
  4928		// match: (Store {t} ptr val mem)
  4929		// cond: t.(*types.Type).Size() == 1
  4930		// result: (I64Store8 ptr val mem)
  4931		for {
  4932			t := v.Aux
  4933			mem := v.Args[2]
  4934			ptr := v.Args[0]
  4935			val := v.Args[1]
  4936			if !(t.(*types.Type).Size() == 1) {
  4937				break
  4938			}
  4939			v.reset(OpWasmI64Store8)
  4940			v.AddArg(ptr)
  4941			v.AddArg(val)
  4942			v.AddArg(mem)
  4943			return true
  4944		}
  4945		return false
  4946	}
  4947	func rewriteValueWasm_OpSub16_0(v *Value) bool {
  4948		// match: (Sub16 x y)
  4949		// cond:
  4950		// result: (I64Sub x y)
  4951		for {
  4952			y := v.Args[1]
  4953			x := v.Args[0]
  4954			v.reset(OpWasmI64Sub)
  4955			v.AddArg(x)
  4956			v.AddArg(y)
  4957			return true
  4958		}
  4959	}
  4960	func rewriteValueWasm_OpSub32_0(v *Value) bool {
  4961		// match: (Sub32 x y)
  4962		// cond:
  4963		// result: (I64Sub x y)
  4964		for {
  4965			y := v.Args[1]
  4966			x := v.Args[0]
  4967			v.reset(OpWasmI64Sub)
  4968			v.AddArg(x)
  4969			v.AddArg(y)
  4970			return true
  4971		}
  4972	}
  4973	func rewriteValueWasm_OpSub32F_0(v *Value) bool {
  4974		// match: (Sub32F x y)
  4975		// cond:
  4976		// result: (F64Sub x y)
  4977		for {
  4978			y := v.Args[1]
  4979			x := v.Args[0]
  4980			v.reset(OpWasmF64Sub)
  4981			v.AddArg(x)
  4982			v.AddArg(y)
  4983			return true
  4984		}
  4985	}
  4986	func rewriteValueWasm_OpSub64_0(v *Value) bool {
  4987		// match: (Sub64 x y)
  4988		// cond:
  4989		// result: (I64Sub x y)
  4990		for {
  4991			y := v.Args[1]
  4992			x := v.Args[0]
  4993			v.reset(OpWasmI64Sub)
  4994			v.AddArg(x)
  4995			v.AddArg(y)
  4996			return true
  4997		}
  4998	}
  4999	func rewriteValueWasm_OpSub64F_0(v *Value) bool {
  5000		// match: (Sub64F x y)
  5001		// cond:
  5002		// result: (F64Sub x y)
  5003		for {
  5004			y := v.Args[1]
  5005			x := v.Args[0]
  5006			v.reset(OpWasmF64Sub)
  5007			v.AddArg(x)
  5008			v.AddArg(y)
  5009			return true
  5010		}
  5011	}
  5012	func rewriteValueWasm_OpSub8_0(v *Value) bool {
  5013		// match: (Sub8 x y)
  5014		// cond:
  5015		// result: (I64Sub x y)
  5016		for {
  5017			y := v.Args[1]
  5018			x := v.Args[0]
  5019			v.reset(OpWasmI64Sub)
  5020			v.AddArg(x)
  5021			v.AddArg(y)
  5022			return true
  5023		}
  5024	}
  5025	func rewriteValueWasm_OpSubPtr_0(v *Value) bool {
  5026		// match: (SubPtr x y)
  5027		// cond:
  5028		// result: (I64Sub x y)
  5029		for {
  5030			y := v.Args[1]
  5031			x := v.Args[0]
  5032			v.reset(OpWasmI64Sub)
  5033			v.AddArg(x)
  5034			v.AddArg(y)
  5035			return true
  5036		}
  5037	}
  5038	func rewriteValueWasm_OpTrunc_0(v *Value) bool {
  5039		// match: (Trunc x)
  5040		// cond:
  5041		// result: (F64Trunc x)
  5042		for {
  5043			x := v.Args[0]
  5044			v.reset(OpWasmF64Trunc)
  5045			v.AddArg(x)
  5046			return true
  5047		}
  5048	}
  5049	func rewriteValueWasm_OpTrunc16to8_0(v *Value) bool {
  5050		// match: (Trunc16to8 x)
  5051		// cond:
  5052		// result: x
  5053		for {
  5054			x := v.Args[0]
  5055			v.reset(OpCopy)
  5056			v.Type = x.Type
  5057			v.AddArg(x)
  5058			return true
  5059		}
  5060	}
  5061	func rewriteValueWasm_OpTrunc32to16_0(v *Value) bool {
  5062		// match: (Trunc32to16 x)
  5063		// cond:
  5064		// result: x
  5065		for {
  5066			x := v.Args[0]
  5067			v.reset(OpCopy)
  5068			v.Type = x.Type
  5069			v.AddArg(x)
  5070			return true
  5071		}
  5072	}
  5073	func rewriteValueWasm_OpTrunc32to8_0(v *Value) bool {
  5074		// match: (Trunc32to8 x)
  5075		// cond:
  5076		// result: x
  5077		for {
  5078			x := v.Args[0]
  5079			v.reset(OpCopy)
  5080			v.Type = x.Type
  5081			v.AddArg(x)
  5082			return true
  5083		}
  5084	}
  5085	func rewriteValueWasm_OpTrunc64to16_0(v *Value) bool {
  5086		// match: (Trunc64to16 x)
  5087		// cond:
  5088		// result: x
  5089		for {
  5090			x := v.Args[0]
  5091			v.reset(OpCopy)
  5092			v.Type = x.Type
  5093			v.AddArg(x)
  5094			return true
  5095		}
  5096	}
  5097	func rewriteValueWasm_OpTrunc64to32_0(v *Value) bool {
  5098		// match: (Trunc64to32 x)
  5099		// cond:
  5100		// result: x
  5101		for {
  5102			x := v.Args[0]
  5103			v.reset(OpCopy)
  5104			v.Type = x.Type
  5105			v.AddArg(x)
  5106			return true
  5107		}
  5108	}
  5109	func rewriteValueWasm_OpTrunc64to8_0(v *Value) bool {
  5110		// match: (Trunc64to8 x)
  5111		// cond:
  5112		// result: x
  5113		for {
  5114			x := v.Args[0]
  5115			v.reset(OpCopy)
  5116			v.Type = x.Type
  5117			v.AddArg(x)
  5118			return true
  5119		}
  5120	}
  5121	func rewriteValueWasm_OpWB_0(v *Value) bool {
  5122		// match: (WB {fn} destptr srcptr mem)
  5123		// cond:
  5124		// result: (LoweredWB {fn} destptr srcptr mem)
  5125		for {
  5126			fn := v.Aux
  5127			mem := v.Args[2]
  5128			destptr := v.Args[0]
  5129			srcptr := v.Args[1]
  5130			v.reset(OpWasmLoweredWB)
  5131			v.Aux = fn
  5132			v.AddArg(destptr)
  5133			v.AddArg(srcptr)
  5134			v.AddArg(mem)
  5135			return true
  5136		}
  5137	}
  5138	func rewriteValueWasm_OpWasmF64Add_0(v *Value) bool {
  5139		b := v.Block
  5140		typ := &b.Func.Config.Types
  5141		// match: (F64Add (F64Const [x]) (F64Const [y]))
  5142		// cond:
  5143		// result: (F64Const [auxFrom64F(auxTo64F(x) + auxTo64F(y))])
  5144		for {
  5145			_ = v.Args[1]
  5146			v_0 := v.Args[0]
  5147			if v_0.Op != OpWasmF64Const {
  5148				break
  5149			}
  5150			x := v_0.AuxInt
  5151			v_1 := v.Args[1]
  5152			if v_1.Op != OpWasmF64Const {
  5153				break
  5154			}
  5155			y := v_1.AuxInt
  5156			v.reset(OpWasmF64Const)
  5157			v.AuxInt = auxFrom64F(auxTo64F(x) + auxTo64F(y))
  5158			return true
  5159		}
  5160		// match: (F64Add (F64Const [x]) y)
  5161		// cond:
  5162		// result: (F64Add y (F64Const [x]))
  5163		for {
  5164			y := v.Args[1]
  5165			v_0 := v.Args[0]
  5166			if v_0.Op != OpWasmF64Const {
  5167				break
  5168			}
  5169			x := v_0.AuxInt
  5170			v.reset(OpWasmF64Add)
  5171			v.AddArg(y)
  5172			v0 := b.NewValue0(v.Pos, OpWasmF64Const, typ.Float64)
  5173			v0.AuxInt = x
  5174			v.AddArg(v0)
  5175			return true
  5176		}
  5177		return false
  5178	}
  5179	func rewriteValueWasm_OpWasmF64Mul_0(v *Value) bool {
  5180		b := v.Block
  5181		typ := &b.Func.Config.Types
  5182		// match: (F64Mul (F64Const [x]) (F64Const [y]))
  5183		// cond:
  5184		// result: (F64Const [auxFrom64F(auxTo64F(x) * auxTo64F(y))])
  5185		for {
  5186			_ = v.Args[1]
  5187			v_0 := v.Args[0]
  5188			if v_0.Op != OpWasmF64Const {
  5189				break
  5190			}
  5191			x := v_0.AuxInt
  5192			v_1 := v.Args[1]
  5193			if v_1.Op != OpWasmF64Const {
  5194				break
  5195			}
  5196			y := v_1.AuxInt
  5197			v.reset(OpWasmF64Const)
  5198			v.AuxInt = auxFrom64F(auxTo64F(x) * auxTo64F(y))
  5199			return true
  5200		}
  5201		// match: (F64Mul (F64Const [x]) y)
  5202		// cond:
  5203		// result: (F64Mul y (F64Const [x]))
  5204		for {
  5205			y := v.Args[1]
  5206			v_0 := v.Args[0]
  5207			if v_0.Op != OpWasmF64Const {
  5208				break
  5209			}
  5210			x := v_0.AuxInt
  5211			v.reset(OpWasmF64Mul)
  5212			v.AddArg(y)
  5213			v0 := b.NewValue0(v.Pos, OpWasmF64Const, typ.Float64)
  5214			v0.AuxInt = x
  5215			v.AddArg(v0)
  5216			return true
  5217		}
  5218		return false
  5219	}
  5220	func rewriteValueWasm_OpWasmI64Add_0(v *Value) bool {
  5221		b := v.Block
  5222		typ := &b.Func.Config.Types
  5223		// match: (I64Add (I64Const [x]) (I64Const [y]))
  5224		// cond:
  5225		// result: (I64Const [x + y])
  5226		for {
  5227			_ = v.Args[1]
  5228			v_0 := v.Args[0]
  5229			if v_0.Op != OpWasmI64Const {
  5230				break
  5231			}
  5232			x := v_0.AuxInt
  5233			v_1 := v.Args[1]
  5234			if v_1.Op != OpWasmI64Const {
  5235				break
  5236			}
  5237			y := v_1.AuxInt
  5238			v.reset(OpWasmI64Const)
  5239			v.AuxInt = x + y
  5240			return true
  5241		}
  5242		// match: (I64Add (I64Const [x]) y)
  5243		// cond:
  5244		// result: (I64Add y (I64Const [x]))
  5245		for {
  5246			y := v.Args[1]
  5247			v_0 := v.Args[0]
  5248			if v_0.Op != OpWasmI64Const {
  5249				break
  5250			}
  5251			x := v_0.AuxInt
  5252			v.reset(OpWasmI64Add)
  5253			v.AddArg(y)
  5254			v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  5255			v0.AuxInt = x
  5256			v.AddArg(v0)
  5257			return true
  5258		}
  5259		// match: (I64Add x (I64Const [y]))
  5260		// cond:
  5261		// result: (I64AddConst [y] x)
  5262		for {
  5263			_ = v.Args[1]
  5264			x := v.Args[0]
  5265			v_1 := v.Args[1]
  5266			if v_1.Op != OpWasmI64Const {
  5267				break
  5268			}
  5269			y := v_1.AuxInt
  5270			v.reset(OpWasmI64AddConst)
  5271			v.AuxInt = y
  5272			v.AddArg(x)
  5273			return true
  5274		}
  5275		return false
  5276	}
  5277	func rewriteValueWasm_OpWasmI64AddConst_0(v *Value) bool {
  5278		// match: (I64AddConst [0] x)
  5279		// cond:
  5280		// result: x
  5281		for {
  5282			if v.AuxInt != 0 {
  5283				break
  5284			}
  5285			x := v.Args[0]
  5286			v.reset(OpCopy)
  5287			v.Type = x.Type
  5288			v.AddArg(x)
  5289			return true
  5290		}
  5291		// match: (I64AddConst [off] (LoweredAddr {sym} [off2] base))
  5292		// cond: isU32Bit(off+off2)
  5293		// result: (LoweredAddr {sym} [off+off2] base)
  5294		for {
  5295			off := v.AuxInt
  5296			v_0 := v.Args[0]
  5297			if v_0.Op != OpWasmLoweredAddr {
  5298				break
  5299			}
  5300			off2 := v_0.AuxInt
  5301			sym := v_0.Aux
  5302			base := v_0.Args[0]
  5303			if !(isU32Bit(off + off2)) {
  5304				break
  5305			}
  5306			v.reset(OpWasmLoweredAddr)
  5307			v.AuxInt = off + off2
  5308			v.Aux = sym
  5309			v.AddArg(base)
  5310			return true
  5311		}
  5312		return false
  5313	}
  5314	func rewriteValueWasm_OpWasmI64And_0(v *Value) bool {
  5315		b := v.Block
  5316		typ := &b.Func.Config.Types
  5317		// match: (I64And (I64Const [x]) (I64Const [y]))
  5318		// cond:
  5319		// result: (I64Const [x & y])
  5320		for {
  5321			_ = v.Args[1]
  5322			v_0 := v.Args[0]
  5323			if v_0.Op != OpWasmI64Const {
  5324				break
  5325			}
  5326			x := v_0.AuxInt
  5327			v_1 := v.Args[1]
  5328			if v_1.Op != OpWasmI64Const {
  5329				break
  5330			}
  5331			y := v_1.AuxInt
  5332			v.reset(OpWasmI64Const)
  5333			v.AuxInt = x & y
  5334			return true
  5335		}
  5336		// match: (I64And (I64Const [x]) y)
  5337		// cond:
  5338		// result: (I64And y (I64Const [x]))
  5339		for {
  5340			y := v.Args[1]
  5341			v_0 := v.Args[0]
  5342			if v_0.Op != OpWasmI64Const {
  5343				break
  5344			}
  5345			x := v_0.AuxInt
  5346			v.reset(OpWasmI64And)
  5347			v.AddArg(y)
  5348			v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  5349			v0.AuxInt = x
  5350			v.AddArg(v0)
  5351			return true
  5352		}
  5353		return false
  5354	}
  5355	func rewriteValueWasm_OpWasmI64Eq_0(v *Value) bool {
  5356		b := v.Block
  5357		typ := &b.Func.Config.Types
  5358		// match: (I64Eq (I64Const [x]) (I64Const [y]))
  5359		// cond: x == y
  5360		// result: (I64Const [1])
  5361		for {
  5362			_ = v.Args[1]
  5363			v_0 := v.Args[0]
  5364			if v_0.Op != OpWasmI64Const {
  5365				break
  5366			}
  5367			x := v_0.AuxInt
  5368			v_1 := v.Args[1]
  5369			if v_1.Op != OpWasmI64Const {
  5370				break
  5371			}
  5372			y := v_1.AuxInt
  5373			if !(x == y) {
  5374				break
  5375			}
  5376			v.reset(OpWasmI64Const)
  5377			v.AuxInt = 1
  5378			return true
  5379		}
  5380		// match: (I64Eq (I64Const [x]) (I64Const [y]))
  5381		// cond: x != y
  5382		// result: (I64Const [0])
  5383		for {
  5384			_ = v.Args[1]
  5385			v_0 := v.Args[0]
  5386			if v_0.Op != OpWasmI64Const {
  5387				break
  5388			}
  5389			x := v_0.AuxInt
  5390			v_1 := v.Args[1]
  5391			if v_1.Op != OpWasmI64Const {
  5392				break
  5393			}
  5394			y := v_1.AuxInt
  5395			if !(x != y) {
  5396				break
  5397			}
  5398			v.reset(OpWasmI64Const)
  5399			v.AuxInt = 0
  5400			return true
  5401		}
  5402		// match: (I64Eq (I64Const [x]) y)
  5403		// cond:
  5404		// result: (I64Eq y (I64Const [x]))
  5405		for {
  5406			y := v.Args[1]
  5407			v_0 := v.Args[0]
  5408			if v_0.Op != OpWasmI64Const {
  5409				break
  5410			}
  5411			x := v_0.AuxInt
  5412			v.reset(OpWasmI64Eq)
  5413			v.AddArg(y)
  5414			v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  5415			v0.AuxInt = x
  5416			v.AddArg(v0)
  5417			return true
  5418		}
  5419		// match: (I64Eq x (I64Const [0]))
  5420		// cond:
  5421		// result: (I64Eqz x)
  5422		for {
  5423			_ = v.Args[1]
  5424			x := v.Args[0]
  5425			v_1 := v.Args[1]
  5426			if v_1.Op != OpWasmI64Const {
  5427				break
  5428			}
  5429			if v_1.AuxInt != 0 {
  5430				break
  5431			}
  5432			v.reset(OpWasmI64Eqz)
  5433			v.AddArg(x)
  5434			return true
  5435		}
  5436		return false
  5437	}
  5438	func rewriteValueWasm_OpWasmI64Eqz_0(v *Value) bool {
  5439		// match: (I64Eqz (I64Eqz (I64Eqz x)))
  5440		// cond:
  5441		// result: (I64Eqz x)
  5442		for {
  5443			v_0 := v.Args[0]
  5444			if v_0.Op != OpWasmI64Eqz {
  5445				break
  5446			}
  5447			v_0_0 := v_0.Args[0]
  5448			if v_0_0.Op != OpWasmI64Eqz {
  5449				break
  5450			}
  5451			x := v_0_0.Args[0]
  5452			v.reset(OpWasmI64Eqz)
  5453			v.AddArg(x)
  5454			return true
  5455		}
  5456		return false
  5457	}
  5458	func rewriteValueWasm_OpWasmI64Load_0(v *Value) bool {
  5459		// match: (I64Load [off] (I64AddConst [off2] ptr) mem)
  5460		// cond: isU32Bit(off+off2)
  5461		// result: (I64Load [off+off2] ptr mem)
  5462		for {
  5463			off := v.AuxInt
  5464			mem := v.Args[1]
  5465			v_0 := v.Args[0]
  5466			if v_0.Op != OpWasmI64AddConst {
  5467				break
  5468			}
  5469			off2 := v_0.AuxInt
  5470			ptr := v_0.Args[0]
  5471			if !(isU32Bit(off + off2)) {
  5472				break
  5473			}
  5474			v.reset(OpWasmI64Load)
  5475			v.AuxInt = off + off2
  5476			v.AddArg(ptr)
  5477			v.AddArg(mem)
  5478			return true
  5479		}
  5480		return false
  5481	}
  5482	func rewriteValueWasm_OpWasmI64Load16S_0(v *Value) bool {
  5483		// match: (I64Load16S [off] (I64AddConst [off2] ptr) mem)
  5484		// cond: isU32Bit(off+off2)
  5485		// result: (I64Load16S [off+off2] ptr mem)
  5486		for {
  5487			off := v.AuxInt
  5488			mem := v.Args[1]
  5489			v_0 := v.Args[0]
  5490			if v_0.Op != OpWasmI64AddConst {
  5491				break
  5492			}
  5493			off2 := v_0.AuxInt
  5494			ptr := v_0.Args[0]
  5495			if !(isU32Bit(off + off2)) {
  5496				break
  5497			}
  5498			v.reset(OpWasmI64Load16S)
  5499			v.AuxInt = off + off2
  5500			v.AddArg(ptr)
  5501			v.AddArg(mem)
  5502			return true
  5503		}
  5504		return false
  5505	}
  5506	func rewriteValueWasm_OpWasmI64Load16U_0(v *Value) bool {
  5507		// match: (I64Load16U [off] (I64AddConst [off2] ptr) mem)
  5508		// cond: isU32Bit(off+off2)
  5509		// result: (I64Load16U [off+off2] ptr mem)
  5510		for {
  5511			off := v.AuxInt
  5512			mem := v.Args[1]
  5513			v_0 := v.Args[0]
  5514			if v_0.Op != OpWasmI64AddConst {
  5515				break
  5516			}
  5517			off2 := v_0.AuxInt
  5518			ptr := v_0.Args[0]
  5519			if !(isU32Bit(off + off2)) {
  5520				break
  5521			}
  5522			v.reset(OpWasmI64Load16U)
  5523			v.AuxInt = off + off2
  5524			v.AddArg(ptr)
  5525			v.AddArg(mem)
  5526			return true
  5527		}
  5528		return false
  5529	}
  5530	func rewriteValueWasm_OpWasmI64Load32S_0(v *Value) bool {
  5531		// match: (I64Load32S [off] (I64AddConst [off2] ptr) mem)
  5532		// cond: isU32Bit(off+off2)
  5533		// result: (I64Load32S [off+off2] ptr mem)
  5534		for {
  5535			off := v.AuxInt
  5536			mem := v.Args[1]
  5537			v_0 := v.Args[0]
  5538			if v_0.Op != OpWasmI64AddConst {
  5539				break
  5540			}
  5541			off2 := v_0.AuxInt
  5542			ptr := v_0.Args[0]
  5543			if !(isU32Bit(off + off2)) {
  5544				break
  5545			}
  5546			v.reset(OpWasmI64Load32S)
  5547			v.AuxInt = off + off2
  5548			v.AddArg(ptr)
  5549			v.AddArg(mem)
  5550			return true
  5551		}
  5552		return false
  5553	}
  5554	func rewriteValueWasm_OpWasmI64Load32U_0(v *Value) bool {
  5555		// match: (I64Load32U [off] (I64AddConst [off2] ptr) mem)
  5556		// cond: isU32Bit(off+off2)
  5557		// result: (I64Load32U [off+off2] ptr mem)
  5558		for {
  5559			off := v.AuxInt
  5560			mem := v.Args[1]
  5561			v_0 := v.Args[0]
  5562			if v_0.Op != OpWasmI64AddConst {
  5563				break
  5564			}
  5565			off2 := v_0.AuxInt
  5566			ptr := v_0.Args[0]
  5567			if !(isU32Bit(off + off2)) {
  5568				break
  5569			}
  5570			v.reset(OpWasmI64Load32U)
  5571			v.AuxInt = off + off2
  5572			v.AddArg(ptr)
  5573			v.AddArg(mem)
  5574			return true
  5575		}
  5576		return false
  5577	}
  5578	func rewriteValueWasm_OpWasmI64Load8S_0(v *Value) bool {
  5579		// match: (I64Load8S [off] (I64AddConst [off2] ptr) mem)
  5580		// cond: isU32Bit(off+off2)
  5581		// result: (I64Load8S [off+off2] ptr mem)
  5582		for {
  5583			off := v.AuxInt
  5584			mem := v.Args[1]
  5585			v_0 := v.Args[0]
  5586			if v_0.Op != OpWasmI64AddConst {
  5587				break
  5588			}
  5589			off2 := v_0.AuxInt
  5590			ptr := v_0.Args[0]
  5591			if !(isU32Bit(off + off2)) {
  5592				break
  5593			}
  5594			v.reset(OpWasmI64Load8S)
  5595			v.AuxInt = off + off2
  5596			v.AddArg(ptr)
  5597			v.AddArg(mem)
  5598			return true
  5599		}
  5600		return false
  5601	}
  5602	func rewriteValueWasm_OpWasmI64Load8U_0(v *Value) bool {
  5603		// match: (I64Load8U [off] (I64AddConst [off2] ptr) mem)
  5604		// cond: isU32Bit(off+off2)
  5605		// result: (I64Load8U [off+off2] ptr mem)
  5606		for {
  5607			off := v.AuxInt
  5608			mem := v.Args[1]
  5609			v_0 := v.Args[0]
  5610			if v_0.Op != OpWasmI64AddConst {
  5611				break
  5612			}
  5613			off2 := v_0.AuxInt
  5614			ptr := v_0.Args[0]
  5615			if !(isU32Bit(off + off2)) {
  5616				break
  5617			}
  5618			v.reset(OpWasmI64Load8U)
  5619			v.AuxInt = off + off2
  5620			v.AddArg(ptr)
  5621			v.AddArg(mem)
  5622			return true
  5623		}
  5624		return false
  5625	}
  5626	func rewriteValueWasm_OpWasmI64Mul_0(v *Value) bool {
  5627		b := v.Block
  5628		typ := &b.Func.Config.Types
  5629		// match: (I64Mul (I64Const [x]) (I64Const [y]))
  5630		// cond:
  5631		// result: (I64Const [x * y])
  5632		for {
  5633			_ = v.Args[1]
  5634			v_0 := v.Args[0]
  5635			if v_0.Op != OpWasmI64Const {
  5636				break
  5637			}
  5638			x := v_0.AuxInt
  5639			v_1 := v.Args[1]
  5640			if v_1.Op != OpWasmI64Const {
  5641				break
  5642			}
  5643			y := v_1.AuxInt
  5644			v.reset(OpWasmI64Const)
  5645			v.AuxInt = x * y
  5646			return true
  5647		}
  5648		// match: (I64Mul (I64Const [x]) y)
  5649		// cond:
  5650		// result: (I64Mul y (I64Const [x]))
  5651		for {
  5652			y := v.Args[1]
  5653			v_0 := v.Args[0]
  5654			if v_0.Op != OpWasmI64Const {
  5655				break
  5656			}
  5657			x := v_0.AuxInt
  5658			v.reset(OpWasmI64Mul)
  5659			v.AddArg(y)
  5660			v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  5661			v0.AuxInt = x
  5662			v.AddArg(v0)
  5663			return true
  5664		}
  5665		return false
  5666	}
  5667	func rewriteValueWasm_OpWasmI64Ne_0(v *Value) bool {
  5668		b := v.Block
  5669		typ := &b.Func.Config.Types
  5670		// match: (I64Ne (I64Const [x]) (I64Const [y]))
  5671		// cond: x == y
  5672		// result: (I64Const [0])
  5673		for {
  5674			_ = v.Args[1]
  5675			v_0 := v.Args[0]
  5676			if v_0.Op != OpWasmI64Const {
  5677				break
  5678			}
  5679			x := v_0.AuxInt
  5680			v_1 := v.Args[1]
  5681			if v_1.Op != OpWasmI64Const {
  5682				break
  5683			}
  5684			y := v_1.AuxInt
  5685			if !(x == y) {
  5686				break
  5687			}
  5688			v.reset(OpWasmI64Const)
  5689			v.AuxInt = 0
  5690			return true
  5691		}
  5692		// match: (I64Ne (I64Const [x]) (I64Const [y]))
  5693		// cond: x != y
  5694		// result: (I64Const [1])
  5695		for {
  5696			_ = v.Args[1]
  5697			v_0 := v.Args[0]
  5698			if v_0.Op != OpWasmI64Const {
  5699				break
  5700			}
  5701			x := v_0.AuxInt
  5702			v_1 := v.Args[1]
  5703			if v_1.Op != OpWasmI64Const {
  5704				break
  5705			}
  5706			y := v_1.AuxInt
  5707			if !(x != y) {
  5708				break
  5709			}
  5710			v.reset(OpWasmI64Const)
  5711			v.AuxInt = 1
  5712			return true
  5713		}
  5714		// match: (I64Ne (I64Const [x]) y)
  5715		// cond:
  5716		// result: (I64Ne y (I64Const [x]))
  5717		for {
  5718			y := v.Args[1]
  5719			v_0 := v.Args[0]
  5720			if v_0.Op != OpWasmI64Const {
  5721				break
  5722			}
  5723			x := v_0.AuxInt
  5724			v.reset(OpWasmI64Ne)
  5725			v.AddArg(y)
  5726			v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  5727			v0.AuxInt = x
  5728			v.AddArg(v0)
  5729			return true
  5730		}
  5731		// match: (I64Ne x (I64Const [0]))
  5732		// cond:
  5733		// result: (I64Eqz (I64Eqz x))
  5734		for {
  5735			_ = v.Args[1]
  5736			x := v.Args[0]
  5737			v_1 := v.Args[1]
  5738			if v_1.Op != OpWasmI64Const {
  5739				break
  5740			}
  5741			if v_1.AuxInt != 0 {
  5742				break
  5743			}
  5744			v.reset(OpWasmI64Eqz)
  5745			v0 := b.NewValue0(v.Pos, OpWasmI64Eqz, typ.Bool)
  5746			v0.AddArg(x)
  5747			v.AddArg(v0)
  5748			return true
  5749		}
  5750		return false
  5751	}
  5752	func rewriteValueWasm_OpWasmI64Or_0(v *Value) bool {
  5753		b := v.Block
  5754		typ := &b.Func.Config.Types
  5755		// match: (I64Or (I64Const [x]) (I64Const [y]))
  5756		// cond:
  5757		// result: (I64Const [x | y])
  5758		for {
  5759			_ = v.Args[1]
  5760			v_0 := v.Args[0]
  5761			if v_0.Op != OpWasmI64Const {
  5762				break
  5763			}
  5764			x := v_0.AuxInt
  5765			v_1 := v.Args[1]
  5766			if v_1.Op != OpWasmI64Const {
  5767				break
  5768			}
  5769			y := v_1.AuxInt
  5770			v.reset(OpWasmI64Const)
  5771			v.AuxInt = x | y
  5772			return true
  5773		}
  5774		// match: (I64Or (I64Const [x]) y)
  5775		// cond:
  5776		// result: (I64Or y (I64Const [x]))
  5777		for {
  5778			y := v.Args[1]
  5779			v_0 := v.Args[0]
  5780			if v_0.Op != OpWasmI64Const {
  5781				break
  5782			}
  5783			x := v_0.AuxInt
  5784			v.reset(OpWasmI64Or)
  5785			v.AddArg(y)
  5786			v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  5787			v0.AuxInt = x
  5788			v.AddArg(v0)
  5789			return true
  5790		}
  5791		return false
  5792	}
  5793	func rewriteValueWasm_OpWasmI64Shl_0(v *Value) bool {
  5794		// match: (I64Shl (I64Const [x]) (I64Const [y]))
  5795		// cond:
  5796		// result: (I64Const [x << uint64(y)])
  5797		for {
  5798			_ = v.Args[1]
  5799			v_0 := v.Args[0]
  5800			if v_0.Op != OpWasmI64Const {
  5801				break
  5802			}
  5803			x := v_0.AuxInt
  5804			v_1 := v.Args[1]
  5805			if v_1.Op != OpWasmI64Const {
  5806				break
  5807			}
  5808			y := v_1.AuxInt
  5809			v.reset(OpWasmI64Const)
  5810			v.AuxInt = x << uint64(y)
  5811			return true
  5812		}
  5813		return false
  5814	}
  5815	func rewriteValueWasm_OpWasmI64ShrS_0(v *Value) bool {
  5816		// match: (I64ShrS (I64Const [x]) (I64Const [y]))
  5817		// cond:
  5818		// result: (I64Const [x >> uint64(y)])
  5819		for {
  5820			_ = v.Args[1]
  5821			v_0 := v.Args[0]
  5822			if v_0.Op != OpWasmI64Const {
  5823				break
  5824			}
  5825			x := v_0.AuxInt
  5826			v_1 := v.Args[1]
  5827			if v_1.Op != OpWasmI64Const {
  5828				break
  5829			}
  5830			y := v_1.AuxInt
  5831			v.reset(OpWasmI64Const)
  5832			v.AuxInt = x >> uint64(y)
  5833			return true
  5834		}
  5835		return false
  5836	}
  5837	func rewriteValueWasm_OpWasmI64ShrU_0(v *Value) bool {
  5838		// match: (I64ShrU (I64Const [x]) (I64Const [y]))
  5839		// cond:
  5840		// result: (I64Const [int64(uint64(x) >> uint64(y))])
  5841		for {
  5842			_ = v.Args[1]
  5843			v_0 := v.Args[0]
  5844			if v_0.Op != OpWasmI64Const {
  5845				break
  5846			}
  5847			x := v_0.AuxInt
  5848			v_1 := v.Args[1]
  5849			if v_1.Op != OpWasmI64Const {
  5850				break
  5851			}
  5852			y := v_1.AuxInt
  5853			v.reset(OpWasmI64Const)
  5854			v.AuxInt = int64(uint64(x) >> uint64(y))
  5855			return true
  5856		}
  5857		return false
  5858	}
  5859	func rewriteValueWasm_OpWasmI64Store_0(v *Value) bool {
  5860		// match: (I64Store [off] (I64AddConst [off2] ptr) val mem)
  5861		// cond: isU32Bit(off+off2)
  5862		// result: (I64Store [off+off2] ptr val mem)
  5863		for {
  5864			off := v.AuxInt
  5865			mem := v.Args[2]
  5866			v_0 := v.Args[0]
  5867			if v_0.Op != OpWasmI64AddConst {
  5868				break
  5869			}
  5870			off2 := v_0.AuxInt
  5871			ptr := v_0.Args[0]
  5872			val := v.Args[1]
  5873			if !(isU32Bit(off + off2)) {
  5874				break
  5875			}
  5876			v.reset(OpWasmI64Store)
  5877			v.AuxInt = off + off2
  5878			v.AddArg(ptr)
  5879			v.AddArg(val)
  5880			v.AddArg(mem)
  5881			return true
  5882		}
  5883		return false
  5884	}
  5885	func rewriteValueWasm_OpWasmI64Store16_0(v *Value) bool {
  5886		// match: (I64Store16 [off] (I64AddConst [off2] ptr) val mem)
  5887		// cond: isU32Bit(off+off2)
  5888		// result: (I64Store16 [off+off2] ptr val mem)
  5889		for {
  5890			off := v.AuxInt
  5891			mem := v.Args[2]
  5892			v_0 := v.Args[0]
  5893			if v_0.Op != OpWasmI64AddConst {
  5894				break
  5895			}
  5896			off2 := v_0.AuxInt
  5897			ptr := v_0.Args[0]
  5898			val := v.Args[1]
  5899			if !(isU32Bit(off + off2)) {
  5900				break
  5901			}
  5902			v.reset(OpWasmI64Store16)
  5903			v.AuxInt = off + off2
  5904			v.AddArg(ptr)
  5905			v.AddArg(val)
  5906			v.AddArg(mem)
  5907			return true
  5908		}
  5909		return false
  5910	}
  5911	func rewriteValueWasm_OpWasmI64Store32_0(v *Value) bool {
  5912		// match: (I64Store32 [off] (I64AddConst [off2] ptr) val mem)
  5913		// cond: isU32Bit(off+off2)
  5914		// result: (I64Store32 [off+off2] ptr val mem)
  5915		for {
  5916			off := v.AuxInt
  5917			mem := v.Args[2]
  5918			v_0 := v.Args[0]
  5919			if v_0.Op != OpWasmI64AddConst {
  5920				break
  5921			}
  5922			off2 := v_0.AuxInt
  5923			ptr := v_0.Args[0]
  5924			val := v.Args[1]
  5925			if !(isU32Bit(off + off2)) {
  5926				break
  5927			}
  5928			v.reset(OpWasmI64Store32)
  5929			v.AuxInt = off + off2
  5930			v.AddArg(ptr)
  5931			v.AddArg(val)
  5932			v.AddArg(mem)
  5933			return true
  5934		}
  5935		return false
  5936	}
  5937	func rewriteValueWasm_OpWasmI64Store8_0(v *Value) bool {
  5938		// match: (I64Store8 [off] (I64AddConst [off2] ptr) val mem)
  5939		// cond: isU32Bit(off+off2)
  5940		// result: (I64Store8 [off+off2] ptr val mem)
  5941		for {
  5942			off := v.AuxInt
  5943			mem := v.Args[2]
  5944			v_0 := v.Args[0]
  5945			if v_0.Op != OpWasmI64AddConst {
  5946				break
  5947			}
  5948			off2 := v_0.AuxInt
  5949			ptr := v_0.Args[0]
  5950			val := v.Args[1]
  5951			if !(isU32Bit(off + off2)) {
  5952				break
  5953			}
  5954			v.reset(OpWasmI64Store8)
  5955			v.AuxInt = off + off2
  5956			v.AddArg(ptr)
  5957			v.AddArg(val)
  5958			v.AddArg(mem)
  5959			return true
  5960		}
  5961		return false
  5962	}
  5963	func rewriteValueWasm_OpWasmI64Xor_0(v *Value) bool {
  5964		b := v.Block
  5965		typ := &b.Func.Config.Types
  5966		// match: (I64Xor (I64Const [x]) (I64Const [y]))
  5967		// cond:
  5968		// result: (I64Const [x ^ y])
  5969		for {
  5970			_ = v.Args[1]
  5971			v_0 := v.Args[0]
  5972			if v_0.Op != OpWasmI64Const {
  5973				break
  5974			}
  5975			x := v_0.AuxInt
  5976			v_1 := v.Args[1]
  5977			if v_1.Op != OpWasmI64Const {
  5978				break
  5979			}
  5980			y := v_1.AuxInt
  5981			v.reset(OpWasmI64Const)
  5982			v.AuxInt = x ^ y
  5983			return true
  5984		}
  5985		// match: (I64Xor (I64Const [x]) y)
  5986		// cond:
  5987		// result: (I64Xor y (I64Const [x]))
  5988		for {
  5989			y := v.Args[1]
  5990			v_0 := v.Args[0]
  5991			if v_0.Op != OpWasmI64Const {
  5992				break
  5993			}
  5994			x := v_0.AuxInt
  5995			v.reset(OpWasmI64Xor)
  5996			v.AddArg(y)
  5997			v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  5998			v0.AuxInt = x
  5999			v.AddArg(v0)
  6000			return true
  6001		}
  6002		return false
  6003	}
  6004	func rewriteValueWasm_OpXor16_0(v *Value) bool {
  6005		// match: (Xor16 x y)
  6006		// cond:
  6007		// result: (I64Xor x y)
  6008		for {
  6009			y := v.Args[1]
  6010			x := v.Args[0]
  6011			v.reset(OpWasmI64Xor)
  6012			v.AddArg(x)
  6013			v.AddArg(y)
  6014			return true
  6015		}
  6016	}
  6017	func rewriteValueWasm_OpXor32_0(v *Value) bool {
  6018		// match: (Xor32 x y)
  6019		// cond:
  6020		// result: (I64Xor x y)
  6021		for {
  6022			y := v.Args[1]
  6023			x := v.Args[0]
  6024			v.reset(OpWasmI64Xor)
  6025			v.AddArg(x)
  6026			v.AddArg(y)
  6027			return true
  6028		}
  6029	}
  6030	func rewriteValueWasm_OpXor64_0(v *Value) bool {
  6031		// match: (Xor64 x y)
  6032		// cond:
  6033		// result: (I64Xor x y)
  6034		for {
  6035			y := v.Args[1]
  6036			x := v.Args[0]
  6037			v.reset(OpWasmI64Xor)
  6038			v.AddArg(x)
  6039			v.AddArg(y)
  6040			return true
  6041		}
  6042	}
  6043	func rewriteValueWasm_OpXor8_0(v *Value) bool {
  6044		// match: (Xor8 x y)
  6045		// cond:
  6046		// result: (I64Xor x y)
  6047		for {
  6048			y := v.Args[1]
  6049			x := v.Args[0]
  6050			v.reset(OpWasmI64Xor)
  6051			v.AddArg(x)
  6052			v.AddArg(y)
  6053			return true
  6054		}
  6055	}
  6056	func rewriteValueWasm_OpZero_0(v *Value) bool {
  6057		b := v.Block
  6058		typ := &b.Func.Config.Types
  6059		// match: (Zero [0] _ mem)
  6060		// cond:
  6061		// result: mem
  6062		for {
  6063			if v.AuxInt != 0 {
  6064				break
  6065			}
  6066			mem := v.Args[1]
  6067			v.reset(OpCopy)
  6068			v.Type = mem.Type
  6069			v.AddArg(mem)
  6070			return true
  6071		}
  6072		// match: (Zero [1] destptr mem)
  6073		// cond:
  6074		// result: (I64Store8 destptr (I64Const [0]) mem)
  6075		for {
  6076			if v.AuxInt != 1 {
  6077				break
  6078			}
  6079			mem := v.Args[1]
  6080			destptr := v.Args[0]
  6081			v.reset(OpWasmI64Store8)
  6082			v.AddArg(destptr)
  6083			v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  6084			v0.AuxInt = 0
  6085			v.AddArg(v0)
  6086			v.AddArg(mem)
  6087			return true
  6088		}
  6089		// match: (Zero [2] destptr mem)
  6090		// cond:
  6091		// result: (I64Store16 destptr (I64Const [0]) mem)
  6092		for {
  6093			if v.AuxInt != 2 {
  6094				break
  6095			}
  6096			mem := v.Args[1]
  6097			destptr := v.Args[0]
  6098			v.reset(OpWasmI64Store16)
  6099			v.AddArg(destptr)
  6100			v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  6101			v0.AuxInt = 0
  6102			v.AddArg(v0)
  6103			v.AddArg(mem)
  6104			return true
  6105		}
  6106		// match: (Zero [4] destptr mem)
  6107		// cond:
  6108		// result: (I64Store32 destptr (I64Const [0]) mem)
  6109		for {
  6110			if v.AuxInt != 4 {
  6111				break
  6112			}
  6113			mem := v.Args[1]
  6114			destptr := v.Args[0]
  6115			v.reset(OpWasmI64Store32)
  6116			v.AddArg(destptr)
  6117			v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  6118			v0.AuxInt = 0
  6119			v.AddArg(v0)
  6120			v.AddArg(mem)
  6121			return true
  6122		}
  6123		// match: (Zero [8] destptr mem)
  6124		// cond:
  6125		// result: (I64Store destptr (I64Const [0]) mem)
  6126		for {
  6127			if v.AuxInt != 8 {
  6128				break
  6129			}
  6130			mem := v.Args[1]
  6131			destptr := v.Args[0]
  6132			v.reset(OpWasmI64Store)
  6133			v.AddArg(destptr)
  6134			v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  6135			v0.AuxInt = 0
  6136			v.AddArg(v0)
  6137			v.AddArg(mem)
  6138			return true
  6139		}
  6140		// match: (Zero [3] destptr mem)
  6141		// cond:
  6142		// result: (I64Store8 [2] destptr (I64Const [0]) (I64Store16 destptr (I64Const [0]) mem))
  6143		for {
  6144			if v.AuxInt != 3 {
  6145				break
  6146			}
  6147			mem := v.Args[1]
  6148			destptr := v.Args[0]
  6149			v.reset(OpWasmI64Store8)
  6150			v.AuxInt = 2
  6151			v.AddArg(destptr)
  6152			v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  6153			v0.AuxInt = 0
  6154			v.AddArg(v0)
  6155			v1 := b.NewValue0(v.Pos, OpWasmI64Store16, types.TypeMem)
  6156			v1.AddArg(destptr)
  6157			v2 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  6158			v2.AuxInt = 0
  6159			v1.AddArg(v2)
  6160			v1.AddArg(mem)
  6161			v.AddArg(v1)
  6162			return true
  6163		}
  6164		// match: (Zero [5] destptr mem)
  6165		// cond:
  6166		// result: (I64Store8 [4] destptr (I64Const [0]) (I64Store32 destptr (I64Const [0]) mem))
  6167		for {
  6168			if v.AuxInt != 5 {
  6169				break
  6170			}
  6171			mem := v.Args[1]
  6172			destptr := v.Args[0]
  6173			v.reset(OpWasmI64Store8)
  6174			v.AuxInt = 4
  6175			v.AddArg(destptr)
  6176			v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  6177			v0.AuxInt = 0
  6178			v.AddArg(v0)
  6179			v1 := b.NewValue0(v.Pos, OpWasmI64Store32, types.TypeMem)
  6180			v1.AddArg(destptr)
  6181			v2 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  6182			v2.AuxInt = 0
  6183			v1.AddArg(v2)
  6184			v1.AddArg(mem)
  6185			v.AddArg(v1)
  6186			return true
  6187		}
  6188		// match: (Zero [6] destptr mem)
  6189		// cond:
  6190		// result: (I64Store16 [4] destptr (I64Const [0]) (I64Store32 destptr (I64Const [0]) mem))
  6191		for {
  6192			if v.AuxInt != 6 {
  6193				break
  6194			}
  6195			mem := v.Args[1]
  6196			destptr := v.Args[0]
  6197			v.reset(OpWasmI64Store16)
  6198			v.AuxInt = 4
  6199			v.AddArg(destptr)
  6200			v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  6201			v0.AuxInt = 0
  6202			v.AddArg(v0)
  6203			v1 := b.NewValue0(v.Pos, OpWasmI64Store32, types.TypeMem)
  6204			v1.AddArg(destptr)
  6205			v2 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  6206			v2.AuxInt = 0
  6207			v1.AddArg(v2)
  6208			v1.AddArg(mem)
  6209			v.AddArg(v1)
  6210			return true
  6211		}
  6212		// match: (Zero [7] destptr mem)
  6213		// cond:
  6214		// result: (I64Store32 [3] destptr (I64Const [0]) (I64Store32 destptr (I64Const [0]) mem))
  6215		for {
  6216			if v.AuxInt != 7 {
  6217				break
  6218			}
  6219			mem := v.Args[1]
  6220			destptr := v.Args[0]
  6221			v.reset(OpWasmI64Store32)
  6222			v.AuxInt = 3
  6223			v.AddArg(destptr)
  6224			v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  6225			v0.AuxInt = 0
  6226			v.AddArg(v0)
  6227			v1 := b.NewValue0(v.Pos, OpWasmI64Store32, types.TypeMem)
  6228			v1.AddArg(destptr)
  6229			v2 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  6230			v2.AuxInt = 0
  6231			v1.AddArg(v2)
  6232			v1.AddArg(mem)
  6233			v.AddArg(v1)
  6234			return true
  6235		}
  6236		// match: (Zero [s] destptr mem)
  6237		// cond: s%8 != 0 && s > 8
  6238		// result: (Zero [s-s%8] (OffPtr <destptr.Type> destptr [s%8]) (I64Store destptr (I64Const [0]) mem))
  6239		for {
  6240			s := v.AuxInt
  6241			mem := v.Args[1]
  6242			destptr := v.Args[0]
  6243			if !(s%8 != 0 && s > 8) {
  6244				break
  6245			}
  6246			v.reset(OpZero)
  6247			v.AuxInt = s - s%8
  6248			v0 := b.NewValue0(v.Pos, OpOffPtr, destptr.Type)
  6249			v0.AuxInt = s % 8
  6250			v0.AddArg(destptr)
  6251			v.AddArg(v0)
  6252			v1 := b.NewValue0(v.Pos, OpWasmI64Store, types.TypeMem)
  6253			v1.AddArg(destptr)
  6254			v2 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  6255			v2.AuxInt = 0
  6256			v1.AddArg(v2)
  6257			v1.AddArg(mem)
  6258			v.AddArg(v1)
  6259			return true
  6260		}
  6261		return false
  6262	}
  6263	func rewriteValueWasm_OpZero_10(v *Value) bool {
  6264		b := v.Block
  6265		typ := &b.Func.Config.Types
  6266		// match: (Zero [16] destptr mem)
  6267		// cond:
  6268		// result: (I64Store [8] destptr (I64Const [0]) (I64Store destptr (I64Const [0]) mem))
  6269		for {
  6270			if v.AuxInt != 16 {
  6271				break
  6272			}
  6273			mem := v.Args[1]
  6274			destptr := v.Args[0]
  6275			v.reset(OpWasmI64Store)
  6276			v.AuxInt = 8
  6277			v.AddArg(destptr)
  6278			v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  6279			v0.AuxInt = 0
  6280			v.AddArg(v0)
  6281			v1 := b.NewValue0(v.Pos, OpWasmI64Store, types.TypeMem)
  6282			v1.AddArg(destptr)
  6283			v2 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  6284			v2.AuxInt = 0
  6285			v1.AddArg(v2)
  6286			v1.AddArg(mem)
  6287			v.AddArg(v1)
  6288			return true
  6289		}
  6290		// match: (Zero [24] destptr mem)
  6291		// cond:
  6292		// result: (I64Store [16] destptr (I64Const [0]) (I64Store [8] destptr (I64Const [0]) (I64Store destptr (I64Const [0]) mem)))
  6293		for {
  6294			if v.AuxInt != 24 {
  6295				break
  6296			}
  6297			mem := v.Args[1]
  6298			destptr := v.Args[0]
  6299			v.reset(OpWasmI64Store)
  6300			v.AuxInt = 16
  6301			v.AddArg(destptr)
  6302			v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  6303			v0.AuxInt = 0
  6304			v.AddArg(v0)
  6305			v1 := b.NewValue0(v.Pos, OpWasmI64Store, types.TypeMem)
  6306			v1.AuxInt = 8
  6307			v1.AddArg(destptr)
  6308			v2 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  6309			v2.AuxInt = 0
  6310			v1.AddArg(v2)
  6311			v3 := b.NewValue0(v.Pos, OpWasmI64Store, types.TypeMem)
  6312			v3.AddArg(destptr)
  6313			v4 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  6314			v4.AuxInt = 0
  6315			v3.AddArg(v4)
  6316			v3.AddArg(mem)
  6317			v1.AddArg(v3)
  6318			v.AddArg(v1)
  6319			return true
  6320		}
  6321		// match: (Zero [32] destptr mem)
  6322		// cond:
  6323		// result: (I64Store [24] destptr (I64Const [0]) (I64Store [16] destptr (I64Const [0]) (I64Store [8] destptr (I64Const [0]) (I64Store destptr (I64Const [0]) mem))))
  6324		for {
  6325			if v.AuxInt != 32 {
  6326				break
  6327			}
  6328			mem := v.Args[1]
  6329			destptr := v.Args[0]
  6330			v.reset(OpWasmI64Store)
  6331			v.AuxInt = 24
  6332			v.AddArg(destptr)
  6333			v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  6334			v0.AuxInt = 0
  6335			v.AddArg(v0)
  6336			v1 := b.NewValue0(v.Pos, OpWasmI64Store, types.TypeMem)
  6337			v1.AuxInt = 16
  6338			v1.AddArg(destptr)
  6339			v2 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  6340			v2.AuxInt = 0
  6341			v1.AddArg(v2)
  6342			v3 := b.NewValue0(v.Pos, OpWasmI64Store, types.TypeMem)
  6343			v3.AuxInt = 8
  6344			v3.AddArg(destptr)
  6345			v4 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  6346			v4.AuxInt = 0
  6347			v3.AddArg(v4)
  6348			v5 := b.NewValue0(v.Pos, OpWasmI64Store, types.TypeMem)
  6349			v5.AddArg(destptr)
  6350			v6 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  6351			v6.AuxInt = 0
  6352			v5.AddArg(v6)
  6353			v5.AddArg(mem)
  6354			v3.AddArg(v5)
  6355			v1.AddArg(v3)
  6356			v.AddArg(v1)
  6357			return true
  6358		}
  6359		// match: (Zero [s] destptr mem)
  6360		// cond: s%8 == 0 && s > 32
  6361		// result: (LoweredZero [s/8] destptr mem)
  6362		for {
  6363			s := v.AuxInt
  6364			mem := v.Args[1]
  6365			destptr := v.Args[0]
  6366			if !(s%8 == 0 && s > 32) {
  6367				break
  6368			}
  6369			v.reset(OpWasmLoweredZero)
  6370			v.AuxInt = s / 8
  6371			v.AddArg(destptr)
  6372			v.AddArg(mem)
  6373			return true
  6374		}
  6375		return false
  6376	}
  6377	func rewriteValueWasm_OpZeroExt16to32_0(v *Value) bool {
  6378		b := v.Block
  6379		typ := &b.Func.Config.Types
  6380		// match: (ZeroExt16to32 x:(I64Load16U _ _))
  6381		// cond:
  6382		// result: x
  6383		for {
  6384			x := v.Args[0]
  6385			if x.Op != OpWasmI64Load16U {
  6386				break
  6387			}
  6388			_ = x.Args[1]
  6389			v.reset(OpCopy)
  6390			v.Type = x.Type
  6391			v.AddArg(x)
  6392			return true
  6393		}
  6394		// match: (ZeroExt16to32 x)
  6395		// cond:
  6396		// result: (I64And x (I64Const [0xffff]))
  6397		for {
  6398			x := v.Args[0]
  6399			v.reset(OpWasmI64And)
  6400			v.AddArg(x)
  6401			v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  6402			v0.AuxInt = 0xffff
  6403			v.AddArg(v0)
  6404			return true
  6405		}
  6406	}
  6407	func rewriteValueWasm_OpZeroExt16to64_0(v *Value) bool {
  6408		b := v.Block
  6409		typ := &b.Func.Config.Types
  6410		// match: (ZeroExt16to64 x:(I64Load16U _ _))
  6411		// cond:
  6412		// result: x
  6413		for {
  6414			x := v.Args[0]
  6415			if x.Op != OpWasmI64Load16U {
  6416				break
  6417			}
  6418			_ = x.Args[1]
  6419			v.reset(OpCopy)
  6420			v.Type = x.Type
  6421			v.AddArg(x)
  6422			return true
  6423		}
  6424		// match: (ZeroExt16to64 x)
  6425		// cond:
  6426		// result: (I64And x (I64Const [0xffff]))
  6427		for {
  6428			x := v.Args[0]
  6429			v.reset(OpWasmI64And)
  6430			v.AddArg(x)
  6431			v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  6432			v0.AuxInt = 0xffff
  6433			v.AddArg(v0)
  6434			return true
  6435		}
  6436	}
  6437	func rewriteValueWasm_OpZeroExt32to64_0(v *Value) bool {
  6438		b := v.Block
  6439		typ := &b.Func.Config.Types
  6440		// match: (ZeroExt32to64 x:(I64Load32U _ _))
  6441		// cond:
  6442		// result: x
  6443		for {
  6444			x := v.Args[0]
  6445			if x.Op != OpWasmI64Load32U {
  6446				break
  6447			}
  6448			_ = x.Args[1]
  6449			v.reset(OpCopy)
  6450			v.Type = x.Type
  6451			v.AddArg(x)
  6452			return true
  6453		}
  6454		// match: (ZeroExt32to64 x)
  6455		// cond:
  6456		// result: (I64And x (I64Const [0xffffffff]))
  6457		for {
  6458			x := v.Args[0]
  6459			v.reset(OpWasmI64And)
  6460			v.AddArg(x)
  6461			v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  6462			v0.AuxInt = 0xffffffff
  6463			v.AddArg(v0)
  6464			return true
  6465		}
  6466	}
  6467	func rewriteValueWasm_OpZeroExt8to16_0(v *Value) bool {
  6468		b := v.Block
  6469		typ := &b.Func.Config.Types
  6470		// match: (ZeroExt8to16 x:(I64Load8U _ _))
  6471		// cond:
  6472		// result: x
  6473		for {
  6474			x := v.Args[0]
  6475			if x.Op != OpWasmI64Load8U {
  6476				break
  6477			}
  6478			_ = x.Args[1]
  6479			v.reset(OpCopy)
  6480			v.Type = x.Type
  6481			v.AddArg(x)
  6482			return true
  6483		}
  6484		// match: (ZeroExt8to16 x)
  6485		// cond:
  6486		// result: (I64And x (I64Const [0xff]))
  6487		for {
  6488			x := v.Args[0]
  6489			v.reset(OpWasmI64And)
  6490			v.AddArg(x)
  6491			v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  6492			v0.AuxInt = 0xff
  6493			v.AddArg(v0)
  6494			return true
  6495		}
  6496	}
  6497	func rewriteValueWasm_OpZeroExt8to32_0(v *Value) bool {
  6498		b := v.Block
  6499		typ := &b.Func.Config.Types
  6500		// match: (ZeroExt8to32 x:(I64Load8U _ _))
  6501		// cond:
  6502		// result: x
  6503		for {
  6504			x := v.Args[0]
  6505			if x.Op != OpWasmI64Load8U {
  6506				break
  6507			}
  6508			_ = x.Args[1]
  6509			v.reset(OpCopy)
  6510			v.Type = x.Type
  6511			v.AddArg(x)
  6512			return true
  6513		}
  6514		// match: (ZeroExt8to32 x)
  6515		// cond:
  6516		// result: (I64And x (I64Const [0xff]))
  6517		for {
  6518			x := v.Args[0]
  6519			v.reset(OpWasmI64And)
  6520			v.AddArg(x)
  6521			v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  6522			v0.AuxInt = 0xff
  6523			v.AddArg(v0)
  6524			return true
  6525		}
  6526	}
  6527	func rewriteValueWasm_OpZeroExt8to64_0(v *Value) bool {
  6528		b := v.Block
  6529		typ := &b.Func.Config.Types
  6530		// match: (ZeroExt8to64 x:(I64Load8U _ _))
  6531		// cond:
  6532		// result: x
  6533		for {
  6534			x := v.Args[0]
  6535			if x.Op != OpWasmI64Load8U {
  6536				break
  6537			}
  6538			_ = x.Args[1]
  6539			v.reset(OpCopy)
  6540			v.Type = x.Type
  6541			v.AddArg(x)
  6542			return true
  6543		}
  6544		// match: (ZeroExt8to64 x)
  6545		// cond:
  6546		// result: (I64And x (I64Const [0xff]))
  6547		for {
  6548			x := v.Args[0]
  6549			v.reset(OpWasmI64And)
  6550			v.AddArg(x)
  6551			v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
  6552			v0.AuxInt = 0xff
  6553			v.AddArg(v0)
  6554			return true
  6555		}
  6556	}
  6557	func rewriteBlockWasm(b *Block) bool {
  6558		config := b.Func.Config
  6559		typ := &config.Types
  6560		_ = typ
  6561		v := b.Control
  6562		_ = v
  6563		switch b.Kind {
  6564		}
  6565		return false
  6566	}
  6567	

View as plain text