Source file src/cmd/compile/internal/ssa/rewritedec64.go

     1  // Code generated from _gen/dec64.rules using 'go generate'; DO NOT EDIT.
     2  
     3  package ssa
     4  
     5  import "cmd/compile/internal/types"
     6  
     7  func rewriteValuedec64(v *Value) bool {
     8  	switch v.Op {
     9  	case OpAdd64:
    10  		return rewriteValuedec64_OpAdd64(v)
    11  	case OpAnd64:
    12  		return rewriteValuedec64_OpAnd64(v)
    13  	case OpArg:
    14  		return rewriteValuedec64_OpArg(v)
    15  	case OpAvg64u:
    16  		return rewriteValuedec64_OpAvg64u(v)
    17  	case OpBitLen64:
    18  		return rewriteValuedec64_OpBitLen64(v)
    19  	case OpBswap64:
    20  		return rewriteValuedec64_OpBswap64(v)
    21  	case OpCom64:
    22  		return rewriteValuedec64_OpCom64(v)
    23  	case OpConst64:
    24  		return rewriteValuedec64_OpConst64(v)
    25  	case OpCtz64:
    26  		return rewriteValuedec64_OpCtz64(v)
    27  	case OpCtz64NonZero:
    28  		v.Op = OpCtz64
    29  		return true
    30  	case OpEq64:
    31  		return rewriteValuedec64_OpEq64(v)
    32  	case OpHmul64:
    33  		return rewriteValuedec64_OpHmul64(v)
    34  	case OpHmul64u:
    35  		return rewriteValuedec64_OpHmul64u(v)
    36  	case OpInt64Hi:
    37  		return rewriteValuedec64_OpInt64Hi(v)
    38  	case OpInt64Lo:
    39  		return rewriteValuedec64_OpInt64Lo(v)
    40  	case OpLast:
    41  		return rewriteValuedec64_OpLast(v)
    42  	case OpLeq64:
    43  		return rewriteValuedec64_OpLeq64(v)
    44  	case OpLeq64U:
    45  		return rewriteValuedec64_OpLeq64U(v)
    46  	case OpLess64:
    47  		return rewriteValuedec64_OpLess64(v)
    48  	case OpLess64U:
    49  		return rewriteValuedec64_OpLess64U(v)
    50  	case OpLoad:
    51  		return rewriteValuedec64_OpLoad(v)
    52  	case OpLsh16x64:
    53  		return rewriteValuedec64_OpLsh16x64(v)
    54  	case OpLsh32x64:
    55  		return rewriteValuedec64_OpLsh32x64(v)
    56  	case OpLsh64x16:
    57  		return rewriteValuedec64_OpLsh64x16(v)
    58  	case OpLsh64x32:
    59  		return rewriteValuedec64_OpLsh64x32(v)
    60  	case OpLsh64x64:
    61  		return rewriteValuedec64_OpLsh64x64(v)
    62  	case OpLsh64x8:
    63  		return rewriteValuedec64_OpLsh64x8(v)
    64  	case OpLsh8x64:
    65  		return rewriteValuedec64_OpLsh8x64(v)
    66  	case OpMul64:
    67  		return rewriteValuedec64_OpMul64(v)
    68  	case OpMul64uhilo:
    69  		return rewriteValuedec64_OpMul64uhilo(v)
    70  	case OpNeg64:
    71  		return rewriteValuedec64_OpNeg64(v)
    72  	case OpNeq64:
    73  		return rewriteValuedec64_OpNeq64(v)
    74  	case OpOr32:
    75  		return rewriteValuedec64_OpOr32(v)
    76  	case OpOr64:
    77  		return rewriteValuedec64_OpOr64(v)
    78  	case OpRotateLeft16:
    79  		return rewriteValuedec64_OpRotateLeft16(v)
    80  	case OpRotateLeft32:
    81  		return rewriteValuedec64_OpRotateLeft32(v)
    82  	case OpRotateLeft64:
    83  		return rewriteValuedec64_OpRotateLeft64(v)
    84  	case OpRotateLeft8:
    85  		return rewriteValuedec64_OpRotateLeft8(v)
    86  	case OpRsh16Ux64:
    87  		return rewriteValuedec64_OpRsh16Ux64(v)
    88  	case OpRsh16x64:
    89  		return rewriteValuedec64_OpRsh16x64(v)
    90  	case OpRsh32Ux64:
    91  		return rewriteValuedec64_OpRsh32Ux64(v)
    92  	case OpRsh32x64:
    93  		return rewriteValuedec64_OpRsh32x64(v)
    94  	case OpRsh64Ux16:
    95  		return rewriteValuedec64_OpRsh64Ux16(v)
    96  	case OpRsh64Ux32:
    97  		return rewriteValuedec64_OpRsh64Ux32(v)
    98  	case OpRsh64Ux64:
    99  		return rewriteValuedec64_OpRsh64Ux64(v)
   100  	case OpRsh64Ux8:
   101  		return rewriteValuedec64_OpRsh64Ux8(v)
   102  	case OpRsh64x16:
   103  		return rewriteValuedec64_OpRsh64x16(v)
   104  	case OpRsh64x32:
   105  		return rewriteValuedec64_OpRsh64x32(v)
   106  	case OpRsh64x64:
   107  		return rewriteValuedec64_OpRsh64x64(v)
   108  	case OpRsh64x8:
   109  		return rewriteValuedec64_OpRsh64x8(v)
   110  	case OpRsh8Ux64:
   111  		return rewriteValuedec64_OpRsh8Ux64(v)
   112  	case OpRsh8x64:
   113  		return rewriteValuedec64_OpRsh8x64(v)
   114  	case OpSelect0:
   115  		return rewriteValuedec64_OpSelect0(v)
   116  	case OpSelect1:
   117  		return rewriteValuedec64_OpSelect1(v)
   118  	case OpSignExt16to64:
   119  		return rewriteValuedec64_OpSignExt16to64(v)
   120  	case OpSignExt32to64:
   121  		return rewriteValuedec64_OpSignExt32to64(v)
   122  	case OpSignExt8to64:
   123  		return rewriteValuedec64_OpSignExt8to64(v)
   124  	case OpStore:
   125  		return rewriteValuedec64_OpStore(v)
   126  	case OpSub64:
   127  		return rewriteValuedec64_OpSub64(v)
   128  	case OpTrunc64to16:
   129  		return rewriteValuedec64_OpTrunc64to16(v)
   130  	case OpTrunc64to32:
   131  		return rewriteValuedec64_OpTrunc64to32(v)
   132  	case OpTrunc64to8:
   133  		return rewriteValuedec64_OpTrunc64to8(v)
   134  	case OpXor64:
   135  		return rewriteValuedec64_OpXor64(v)
   136  	case OpZeroExt16to64:
   137  		return rewriteValuedec64_OpZeroExt16to64(v)
   138  	case OpZeroExt32to64:
   139  		return rewriteValuedec64_OpZeroExt32to64(v)
   140  	case OpZeroExt8to64:
   141  		return rewriteValuedec64_OpZeroExt8to64(v)
   142  	}
   143  	return false
   144  }
   145  func rewriteValuedec64_OpAdd64(v *Value) bool {
   146  	v_1 := v.Args[1]
   147  	v_0 := v.Args[0]
   148  	b := v.Block
   149  	typ := &b.Func.Config.Types
   150  	// match: (Add64 <t> x y)
   151  	// result: (Last <t> x0: (Int64Lo x) x1: (Int64Hi x) y0: (Int64Lo y) y1: (Int64Hi y) add: (Add32carry x0 y0) (Int64Make (Add32withcarry <typ.UInt32> x1 y1 (Select1 <types.TypeFlags> add)) (Select0 <typ.UInt32> add)))
   152  	for {
   153  		t := v.Type
   154  		x := v_0
   155  		y := v_1
   156  		v.reset(OpLast)
   157  		v.Type = t
   158  		x0 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   159  		x0.AddArg(x)
   160  		x1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   161  		x1.AddArg(x)
   162  		y0 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   163  		y0.AddArg(y)
   164  		y1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   165  		y1.AddArg(y)
   166  		add := b.NewValue0(v.Pos, OpAdd32carry, types.NewTuple(typ.UInt32, types.TypeFlags))
   167  		add.AddArg2(x0, y0)
   168  		v5 := b.NewValue0(v.Pos, OpInt64Make, typ.UInt64)
   169  		v6 := b.NewValue0(v.Pos, OpAdd32withcarry, typ.UInt32)
   170  		v7 := b.NewValue0(v.Pos, OpSelect1, types.TypeFlags)
   171  		v7.AddArg(add)
   172  		v6.AddArg3(x1, y1, v7)
   173  		v8 := b.NewValue0(v.Pos, OpSelect0, typ.UInt32)
   174  		v8.AddArg(add)
   175  		v5.AddArg2(v6, v8)
   176  		v.AddArg6(x0, x1, y0, y1, add, v5)
   177  		return true
   178  	}
   179  }
   180  func rewriteValuedec64_OpAnd64(v *Value) bool {
   181  	v_1 := v.Args[1]
   182  	v_0 := v.Args[0]
   183  	b := v.Block
   184  	typ := &b.Func.Config.Types
   185  	// match: (And64 x y)
   186  	// result: (Int64Make (And32 <typ.UInt32> (Int64Hi x) (Int64Hi y)) (And32 <typ.UInt32> (Int64Lo x) (Int64Lo y)))
   187  	for {
   188  		x := v_0
   189  		y := v_1
   190  		v.reset(OpInt64Make)
   191  		v0 := b.NewValue0(v.Pos, OpAnd32, typ.UInt32)
   192  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   193  		v1.AddArg(x)
   194  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   195  		v2.AddArg(y)
   196  		v0.AddArg2(v1, v2)
   197  		v3 := b.NewValue0(v.Pos, OpAnd32, typ.UInt32)
   198  		v4 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   199  		v4.AddArg(x)
   200  		v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   201  		v5.AddArg(y)
   202  		v3.AddArg2(v4, v5)
   203  		v.AddArg2(v0, v3)
   204  		return true
   205  	}
   206  }
   207  func rewriteValuedec64_OpArg(v *Value) bool {
   208  	b := v.Block
   209  	config := b.Func.Config
   210  	typ := &b.Func.Config.Types
   211  	// match: (Arg {n} [off])
   212  	// cond: is64BitInt(v.Type) && !config.BigEndian && v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")
   213  	// result: (Int64Make (Arg <typ.Int32> {n} [off+4]) (Arg <typ.UInt32> {n} [off]))
   214  	for {
   215  		off := auxIntToInt32(v.AuxInt)
   216  		n := auxToSym(v.Aux)
   217  		if !(is64BitInt(v.Type) && !config.BigEndian && v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")) {
   218  			break
   219  		}
   220  		v.reset(OpInt64Make)
   221  		v0 := b.NewValue0(v.Pos, OpArg, typ.Int32)
   222  		v0.AuxInt = int32ToAuxInt(off + 4)
   223  		v0.Aux = symToAux(n)
   224  		v1 := b.NewValue0(v.Pos, OpArg, typ.UInt32)
   225  		v1.AuxInt = int32ToAuxInt(off)
   226  		v1.Aux = symToAux(n)
   227  		v.AddArg2(v0, v1)
   228  		return true
   229  	}
   230  	// match: (Arg {n} [off])
   231  	// cond: is64BitInt(v.Type) && !config.BigEndian && !v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")
   232  	// result: (Int64Make (Arg <typ.UInt32> {n} [off+4]) (Arg <typ.UInt32> {n} [off]))
   233  	for {
   234  		off := auxIntToInt32(v.AuxInt)
   235  		n := auxToSym(v.Aux)
   236  		if !(is64BitInt(v.Type) && !config.BigEndian && !v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")) {
   237  			break
   238  		}
   239  		v.reset(OpInt64Make)
   240  		v0 := b.NewValue0(v.Pos, OpArg, typ.UInt32)
   241  		v0.AuxInt = int32ToAuxInt(off + 4)
   242  		v0.Aux = symToAux(n)
   243  		v1 := b.NewValue0(v.Pos, OpArg, typ.UInt32)
   244  		v1.AuxInt = int32ToAuxInt(off)
   245  		v1.Aux = symToAux(n)
   246  		v.AddArg2(v0, v1)
   247  		return true
   248  	}
   249  	// match: (Arg {n} [off])
   250  	// cond: is64BitInt(v.Type) && config.BigEndian && v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")
   251  	// result: (Int64Make (Arg <typ.Int32> {n} [off]) (Arg <typ.UInt32> {n} [off+4]))
   252  	for {
   253  		off := auxIntToInt32(v.AuxInt)
   254  		n := auxToSym(v.Aux)
   255  		if !(is64BitInt(v.Type) && config.BigEndian && v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")) {
   256  			break
   257  		}
   258  		v.reset(OpInt64Make)
   259  		v0 := b.NewValue0(v.Pos, OpArg, typ.Int32)
   260  		v0.AuxInt = int32ToAuxInt(off)
   261  		v0.Aux = symToAux(n)
   262  		v1 := b.NewValue0(v.Pos, OpArg, typ.UInt32)
   263  		v1.AuxInt = int32ToAuxInt(off + 4)
   264  		v1.Aux = symToAux(n)
   265  		v.AddArg2(v0, v1)
   266  		return true
   267  	}
   268  	// match: (Arg {n} [off])
   269  	// cond: is64BitInt(v.Type) && config.BigEndian && !v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")
   270  	// result: (Int64Make (Arg <typ.UInt32> {n} [off]) (Arg <typ.UInt32> {n} [off+4]))
   271  	for {
   272  		off := auxIntToInt32(v.AuxInt)
   273  		n := auxToSym(v.Aux)
   274  		if !(is64BitInt(v.Type) && config.BigEndian && !v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")) {
   275  			break
   276  		}
   277  		v.reset(OpInt64Make)
   278  		v0 := b.NewValue0(v.Pos, OpArg, typ.UInt32)
   279  		v0.AuxInt = int32ToAuxInt(off)
   280  		v0.Aux = symToAux(n)
   281  		v1 := b.NewValue0(v.Pos, OpArg, typ.UInt32)
   282  		v1.AuxInt = int32ToAuxInt(off + 4)
   283  		v1.Aux = symToAux(n)
   284  		v.AddArg2(v0, v1)
   285  		return true
   286  	}
   287  	return false
   288  }
   289  func rewriteValuedec64_OpAvg64u(v *Value) bool {
   290  	v_1 := v.Args[1]
   291  	v_0 := v.Args[0]
   292  	b := v.Block
   293  	typ := &b.Func.Config.Types
   294  	// match: (Avg64u <t> x y)
   295  	// result: (Add64 (Rsh64Ux32 <t> (Sub64 <t> x y) (Const32 <typ.UInt32> [1])) y)
   296  	for {
   297  		t := v.Type
   298  		x := v_0
   299  		y := v_1
   300  		v.reset(OpAdd64)
   301  		v0 := b.NewValue0(v.Pos, OpRsh64Ux32, t)
   302  		v1 := b.NewValue0(v.Pos, OpSub64, t)
   303  		v1.AddArg2(x, y)
   304  		v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
   305  		v2.AuxInt = int32ToAuxInt(1)
   306  		v0.AddArg2(v1, v2)
   307  		v.AddArg2(v0, y)
   308  		return true
   309  	}
   310  }
   311  func rewriteValuedec64_OpBitLen64(v *Value) bool {
   312  	v_0 := v.Args[0]
   313  	b := v.Block
   314  	typ := &b.Func.Config.Types
   315  	// match: (BitLen64 x)
   316  	// result: (Add32 <typ.Int> (BitLen32 <typ.Int> (Int64Hi x)) (BitLen32 <typ.Int> (Or32 <typ.UInt32> (Int64Lo x) (Zeromask (Int64Hi x)))))
   317  	for {
   318  		x := v_0
   319  		v.reset(OpAdd32)
   320  		v.Type = typ.Int
   321  		v0 := b.NewValue0(v.Pos, OpBitLen32, typ.Int)
   322  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   323  		v1.AddArg(x)
   324  		v0.AddArg(v1)
   325  		v2 := b.NewValue0(v.Pos, OpBitLen32, typ.Int)
   326  		v3 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
   327  		v4 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   328  		v4.AddArg(x)
   329  		v5 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
   330  		v5.AddArg(v1)
   331  		v3.AddArg2(v4, v5)
   332  		v2.AddArg(v3)
   333  		v.AddArg2(v0, v2)
   334  		return true
   335  	}
   336  }
   337  func rewriteValuedec64_OpBswap64(v *Value) bool {
   338  	v_0 := v.Args[0]
   339  	b := v.Block
   340  	typ := &b.Func.Config.Types
   341  	// match: (Bswap64 x)
   342  	// result: (Int64Make (Bswap32 <typ.UInt32> (Int64Lo x)) (Bswap32 <typ.UInt32> (Int64Hi x)))
   343  	for {
   344  		x := v_0
   345  		v.reset(OpInt64Make)
   346  		v0 := b.NewValue0(v.Pos, OpBswap32, typ.UInt32)
   347  		v1 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   348  		v1.AddArg(x)
   349  		v0.AddArg(v1)
   350  		v2 := b.NewValue0(v.Pos, OpBswap32, typ.UInt32)
   351  		v3 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   352  		v3.AddArg(x)
   353  		v2.AddArg(v3)
   354  		v.AddArg2(v0, v2)
   355  		return true
   356  	}
   357  }
   358  func rewriteValuedec64_OpCom64(v *Value) bool {
   359  	v_0 := v.Args[0]
   360  	b := v.Block
   361  	typ := &b.Func.Config.Types
   362  	// match: (Com64 x)
   363  	// result: (Int64Make (Com32 <typ.UInt32> (Int64Hi x)) (Com32 <typ.UInt32> (Int64Lo x)))
   364  	for {
   365  		x := v_0
   366  		v.reset(OpInt64Make)
   367  		v0 := b.NewValue0(v.Pos, OpCom32, typ.UInt32)
   368  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   369  		v1.AddArg(x)
   370  		v0.AddArg(v1)
   371  		v2 := b.NewValue0(v.Pos, OpCom32, typ.UInt32)
   372  		v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   373  		v3.AddArg(x)
   374  		v2.AddArg(v3)
   375  		v.AddArg2(v0, v2)
   376  		return true
   377  	}
   378  }
   379  func rewriteValuedec64_OpConst64(v *Value) bool {
   380  	b := v.Block
   381  	typ := &b.Func.Config.Types
   382  	// match: (Const64 <t> [c])
   383  	// cond: t.IsSigned()
   384  	// result: (Int64Make (Const32 <typ.Int32> [int32(c>>32)]) (Const32 <typ.UInt32> [int32(c)]))
   385  	for {
   386  		t := v.Type
   387  		c := auxIntToInt64(v.AuxInt)
   388  		if !(t.IsSigned()) {
   389  			break
   390  		}
   391  		v.reset(OpInt64Make)
   392  		v0 := b.NewValue0(v.Pos, OpConst32, typ.Int32)
   393  		v0.AuxInt = int32ToAuxInt(int32(c >> 32))
   394  		v1 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
   395  		v1.AuxInt = int32ToAuxInt(int32(c))
   396  		v.AddArg2(v0, v1)
   397  		return true
   398  	}
   399  	// match: (Const64 <t> [c])
   400  	// cond: !t.IsSigned()
   401  	// result: (Int64Make (Const32 <typ.UInt32> [int32(c>>32)]) (Const32 <typ.UInt32> [int32(c)]))
   402  	for {
   403  		t := v.Type
   404  		c := auxIntToInt64(v.AuxInt)
   405  		if !(!t.IsSigned()) {
   406  			break
   407  		}
   408  		v.reset(OpInt64Make)
   409  		v0 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
   410  		v0.AuxInt = int32ToAuxInt(int32(c >> 32))
   411  		v1 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
   412  		v1.AuxInt = int32ToAuxInt(int32(c))
   413  		v.AddArg2(v0, v1)
   414  		return true
   415  	}
   416  	return false
   417  }
   418  func rewriteValuedec64_OpCtz64(v *Value) bool {
   419  	v_0 := v.Args[0]
   420  	b := v.Block
   421  	typ := &b.Func.Config.Types
   422  	// match: (Ctz64 x)
   423  	// result: (Add32 <typ.UInt32> (Ctz32 <typ.UInt32> (Int64Lo x)) (And32 <typ.UInt32> (Com32 <typ.UInt32> (Zeromask (Int64Lo x))) (Ctz32 <typ.UInt32> (Int64Hi x))))
   424  	for {
   425  		x := v_0
   426  		v.reset(OpAdd32)
   427  		v.Type = typ.UInt32
   428  		v0 := b.NewValue0(v.Pos, OpCtz32, typ.UInt32)
   429  		v1 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   430  		v1.AddArg(x)
   431  		v0.AddArg(v1)
   432  		v2 := b.NewValue0(v.Pos, OpAnd32, typ.UInt32)
   433  		v3 := b.NewValue0(v.Pos, OpCom32, typ.UInt32)
   434  		v4 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
   435  		v4.AddArg(v1)
   436  		v3.AddArg(v4)
   437  		v5 := b.NewValue0(v.Pos, OpCtz32, typ.UInt32)
   438  		v6 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   439  		v6.AddArg(x)
   440  		v5.AddArg(v6)
   441  		v2.AddArg2(v3, v5)
   442  		v.AddArg2(v0, v2)
   443  		return true
   444  	}
   445  }
   446  func rewriteValuedec64_OpEq64(v *Value) bool {
   447  	v_1 := v.Args[1]
   448  	v_0 := v.Args[0]
   449  	b := v.Block
   450  	typ := &b.Func.Config.Types
   451  	// match: (Eq64 x y)
   452  	// result: (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Eq32 (Int64Lo x) (Int64Lo y)))
   453  	for {
   454  		x := v_0
   455  		y := v_1
   456  		v.reset(OpAndB)
   457  		v0 := b.NewValue0(v.Pos, OpEq32, typ.Bool)
   458  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   459  		v1.AddArg(x)
   460  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   461  		v2.AddArg(y)
   462  		v0.AddArg2(v1, v2)
   463  		v3 := b.NewValue0(v.Pos, OpEq32, typ.Bool)
   464  		v4 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   465  		v4.AddArg(x)
   466  		v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   467  		v5.AddArg(y)
   468  		v3.AddArg2(v4, v5)
   469  		v.AddArg2(v0, v3)
   470  		return true
   471  	}
   472  }
   473  func rewriteValuedec64_OpHmul64(v *Value) bool {
   474  	v_1 := v.Args[1]
   475  	v_0 := v.Args[0]
   476  	b := v.Block
   477  	typ := &b.Func.Config.Types
   478  	// match: (Hmul64 x y)
   479  	// result: (Last p: (Hmul64u <typ.UInt64> x y) xSign: (Int64Make xs:(Rsh32x32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [31])) xs) ySign: (Int64Make ys:(Rsh32x32 <typ.UInt32> (Int64Hi y) (Const32 <typ.UInt32> [31])) ys) (Sub64 <typ.Int64> (Sub64 <typ.Int64> p (And64 <typ.Int64> xSign y)) (And64 <typ.Int64> ySign x)))
   480  	for {
   481  		x := v_0
   482  		y := v_1
   483  		v.reset(OpLast)
   484  		p := b.NewValue0(v.Pos, OpHmul64u, typ.UInt64)
   485  		p.AddArg2(x, y)
   486  		xSign := b.NewValue0(v.Pos, OpInt64Make, typ.UInt64)
   487  		xs := b.NewValue0(v.Pos, OpRsh32x32, typ.UInt32)
   488  		v3 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   489  		v3.AddArg(x)
   490  		v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
   491  		v4.AuxInt = int32ToAuxInt(31)
   492  		xs.AddArg2(v3, v4)
   493  		xSign.AddArg2(xs, xs)
   494  		ySign := b.NewValue0(v.Pos, OpInt64Make, typ.UInt64)
   495  		ys := b.NewValue0(v.Pos, OpRsh32x32, typ.UInt32)
   496  		v7 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   497  		v7.AddArg(y)
   498  		ys.AddArg2(v7, v4)
   499  		ySign.AddArg2(ys, ys)
   500  		v8 := b.NewValue0(v.Pos, OpSub64, typ.Int64)
   501  		v9 := b.NewValue0(v.Pos, OpSub64, typ.Int64)
   502  		v10 := b.NewValue0(v.Pos, OpAnd64, typ.Int64)
   503  		v10.AddArg2(xSign, y)
   504  		v9.AddArg2(p, v10)
   505  		v11 := b.NewValue0(v.Pos, OpAnd64, typ.Int64)
   506  		v11.AddArg2(ySign, x)
   507  		v8.AddArg2(v9, v11)
   508  		v.AddArg4(p, xSign, ySign, v8)
   509  		return true
   510  	}
   511  }
   512  func rewriteValuedec64_OpHmul64u(v *Value) bool {
   513  	v_1 := v.Args[1]
   514  	v_0 := v.Args[0]
   515  	b := v.Block
   516  	typ := &b.Func.Config.Types
   517  	// match: (Hmul64u x y)
   518  	// result: (Select0 (Mul64uhilo x y))
   519  	for {
   520  		x := v_0
   521  		y := v_1
   522  		v.reset(OpSelect0)
   523  		v0 := b.NewValue0(v.Pos, OpMul64uhilo, types.NewTuple(typ.UInt64, typ.UInt64))
   524  		v0.AddArg2(x, y)
   525  		v.AddArg(v0)
   526  		return true
   527  	}
   528  }
   529  func rewriteValuedec64_OpInt64Hi(v *Value) bool {
   530  	v_0 := v.Args[0]
   531  	// match: (Int64Hi (Int64Make hi _))
   532  	// result: hi
   533  	for {
   534  		if v_0.Op != OpInt64Make {
   535  			break
   536  		}
   537  		hi := v_0.Args[0]
   538  		v.copyOf(hi)
   539  		return true
   540  	}
   541  	return false
   542  }
   543  func rewriteValuedec64_OpInt64Lo(v *Value) bool {
   544  	v_0 := v.Args[0]
   545  	// match: (Int64Lo (Int64Make _ lo))
   546  	// result: lo
   547  	for {
   548  		if v_0.Op != OpInt64Make {
   549  			break
   550  		}
   551  		lo := v_0.Args[1]
   552  		v.copyOf(lo)
   553  		return true
   554  	}
   555  	return false
   556  }
   557  func rewriteValuedec64_OpLast(v *Value) bool {
   558  	// match: (Last ___)
   559  	// result: v.Args[len(v.Args)-1]
   560  	for {
   561  		v.copyOf(v.Args[len(v.Args)-1])
   562  		return true
   563  	}
   564  }
   565  func rewriteValuedec64_OpLeq64(v *Value) bool {
   566  	v_1 := v.Args[1]
   567  	v_0 := v.Args[0]
   568  	b := v.Block
   569  	typ := &b.Func.Config.Types
   570  	// match: (Leq64 x y)
   571  	// result: (OrB (Less32 (Int64Hi x) (Int64Hi y)) (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Leq32U (Int64Lo x) (Int64Lo y))))
   572  	for {
   573  		x := v_0
   574  		y := v_1
   575  		v.reset(OpOrB)
   576  		v0 := b.NewValue0(v.Pos, OpLess32, typ.Bool)
   577  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   578  		v1.AddArg(x)
   579  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   580  		v2.AddArg(y)
   581  		v0.AddArg2(v1, v2)
   582  		v3 := b.NewValue0(v.Pos, OpAndB, typ.Bool)
   583  		v4 := b.NewValue0(v.Pos, OpEq32, typ.Bool)
   584  		v4.AddArg2(v1, v2)
   585  		v5 := b.NewValue0(v.Pos, OpLeq32U, typ.Bool)
   586  		v6 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   587  		v6.AddArg(x)
   588  		v7 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   589  		v7.AddArg(y)
   590  		v5.AddArg2(v6, v7)
   591  		v3.AddArg2(v4, v5)
   592  		v.AddArg2(v0, v3)
   593  		return true
   594  	}
   595  }
   596  func rewriteValuedec64_OpLeq64U(v *Value) bool {
   597  	v_1 := v.Args[1]
   598  	v_0 := v.Args[0]
   599  	b := v.Block
   600  	typ := &b.Func.Config.Types
   601  	// match: (Leq64U x y)
   602  	// result: (OrB (Less32U (Int64Hi x) (Int64Hi y)) (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Leq32U (Int64Lo x) (Int64Lo y))))
   603  	for {
   604  		x := v_0
   605  		y := v_1
   606  		v.reset(OpOrB)
   607  		v0 := b.NewValue0(v.Pos, OpLess32U, typ.Bool)
   608  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   609  		v1.AddArg(x)
   610  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   611  		v2.AddArg(y)
   612  		v0.AddArg2(v1, v2)
   613  		v3 := b.NewValue0(v.Pos, OpAndB, typ.Bool)
   614  		v4 := b.NewValue0(v.Pos, OpEq32, typ.Bool)
   615  		v4.AddArg2(v1, v2)
   616  		v5 := b.NewValue0(v.Pos, OpLeq32U, typ.Bool)
   617  		v6 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   618  		v6.AddArg(x)
   619  		v7 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   620  		v7.AddArg(y)
   621  		v5.AddArg2(v6, v7)
   622  		v3.AddArg2(v4, v5)
   623  		v.AddArg2(v0, v3)
   624  		return true
   625  	}
   626  }
   627  func rewriteValuedec64_OpLess64(v *Value) bool {
   628  	v_1 := v.Args[1]
   629  	v_0 := v.Args[0]
   630  	b := v.Block
   631  	typ := &b.Func.Config.Types
   632  	// match: (Less64 x y)
   633  	// result: (OrB (Less32 (Int64Hi x) (Int64Hi y)) (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Less32U (Int64Lo x) (Int64Lo y))))
   634  	for {
   635  		x := v_0
   636  		y := v_1
   637  		v.reset(OpOrB)
   638  		v0 := b.NewValue0(v.Pos, OpLess32, typ.Bool)
   639  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   640  		v1.AddArg(x)
   641  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   642  		v2.AddArg(y)
   643  		v0.AddArg2(v1, v2)
   644  		v3 := b.NewValue0(v.Pos, OpAndB, typ.Bool)
   645  		v4 := b.NewValue0(v.Pos, OpEq32, typ.Bool)
   646  		v4.AddArg2(v1, v2)
   647  		v5 := b.NewValue0(v.Pos, OpLess32U, typ.Bool)
   648  		v6 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   649  		v6.AddArg(x)
   650  		v7 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   651  		v7.AddArg(y)
   652  		v5.AddArg2(v6, v7)
   653  		v3.AddArg2(v4, v5)
   654  		v.AddArg2(v0, v3)
   655  		return true
   656  	}
   657  }
   658  func rewriteValuedec64_OpLess64U(v *Value) bool {
   659  	v_1 := v.Args[1]
   660  	v_0 := v.Args[0]
   661  	b := v.Block
   662  	typ := &b.Func.Config.Types
   663  	// match: (Less64U x y)
   664  	// result: (OrB (Less32U (Int64Hi x) (Int64Hi y)) (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Less32U (Int64Lo x) (Int64Lo y))))
   665  	for {
   666  		x := v_0
   667  		y := v_1
   668  		v.reset(OpOrB)
   669  		v0 := b.NewValue0(v.Pos, OpLess32U, typ.Bool)
   670  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   671  		v1.AddArg(x)
   672  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   673  		v2.AddArg(y)
   674  		v0.AddArg2(v1, v2)
   675  		v3 := b.NewValue0(v.Pos, OpAndB, typ.Bool)
   676  		v4 := b.NewValue0(v.Pos, OpEq32, typ.Bool)
   677  		v4.AddArg2(v1, v2)
   678  		v5 := b.NewValue0(v.Pos, OpLess32U, typ.Bool)
   679  		v6 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   680  		v6.AddArg(x)
   681  		v7 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   682  		v7.AddArg(y)
   683  		v5.AddArg2(v6, v7)
   684  		v3.AddArg2(v4, v5)
   685  		v.AddArg2(v0, v3)
   686  		return true
   687  	}
   688  }
   689  func rewriteValuedec64_OpLoad(v *Value) bool {
   690  	v_1 := v.Args[1]
   691  	v_0 := v.Args[0]
   692  	b := v.Block
   693  	config := b.Func.Config
   694  	typ := &b.Func.Config.Types
   695  	// match: (Load <t> ptr mem)
   696  	// cond: is64BitInt(t) && !config.BigEndian && t.IsSigned()
   697  	// result: (Int64Make (Load <typ.Int32> (OffPtr <typ.Int32Ptr> [4] ptr) mem) (Load <typ.UInt32> ptr mem))
   698  	for {
   699  		t := v.Type
   700  		ptr := v_0
   701  		mem := v_1
   702  		if !(is64BitInt(t) && !config.BigEndian && t.IsSigned()) {
   703  			break
   704  		}
   705  		v.reset(OpInt64Make)
   706  		v0 := b.NewValue0(v.Pos, OpLoad, typ.Int32)
   707  		v1 := b.NewValue0(v.Pos, OpOffPtr, typ.Int32Ptr)
   708  		v1.AuxInt = int64ToAuxInt(4)
   709  		v1.AddArg(ptr)
   710  		v0.AddArg2(v1, mem)
   711  		v2 := b.NewValue0(v.Pos, OpLoad, typ.UInt32)
   712  		v2.AddArg2(ptr, mem)
   713  		v.AddArg2(v0, v2)
   714  		return true
   715  	}
   716  	// match: (Load <t> ptr mem)
   717  	// cond: is64BitInt(t) && !config.BigEndian && !t.IsSigned()
   718  	// result: (Int64Make (Load <typ.UInt32> (OffPtr <typ.UInt32Ptr> [4] ptr) mem) (Load <typ.UInt32> ptr mem))
   719  	for {
   720  		t := v.Type
   721  		ptr := v_0
   722  		mem := v_1
   723  		if !(is64BitInt(t) && !config.BigEndian && !t.IsSigned()) {
   724  			break
   725  		}
   726  		v.reset(OpInt64Make)
   727  		v0 := b.NewValue0(v.Pos, OpLoad, typ.UInt32)
   728  		v1 := b.NewValue0(v.Pos, OpOffPtr, typ.UInt32Ptr)
   729  		v1.AuxInt = int64ToAuxInt(4)
   730  		v1.AddArg(ptr)
   731  		v0.AddArg2(v1, mem)
   732  		v2 := b.NewValue0(v.Pos, OpLoad, typ.UInt32)
   733  		v2.AddArg2(ptr, mem)
   734  		v.AddArg2(v0, v2)
   735  		return true
   736  	}
   737  	// match: (Load <t> ptr mem)
   738  	// cond: is64BitInt(t) && config.BigEndian && t.IsSigned()
   739  	// result: (Int64Make (Load <typ.Int32> ptr mem) (Load <typ.UInt32> (OffPtr <typ.UInt32Ptr> [4] ptr) mem))
   740  	for {
   741  		t := v.Type
   742  		ptr := v_0
   743  		mem := v_1
   744  		if !(is64BitInt(t) && config.BigEndian && t.IsSigned()) {
   745  			break
   746  		}
   747  		v.reset(OpInt64Make)
   748  		v0 := b.NewValue0(v.Pos, OpLoad, typ.Int32)
   749  		v0.AddArg2(ptr, mem)
   750  		v1 := b.NewValue0(v.Pos, OpLoad, typ.UInt32)
   751  		v2 := b.NewValue0(v.Pos, OpOffPtr, typ.UInt32Ptr)
   752  		v2.AuxInt = int64ToAuxInt(4)
   753  		v2.AddArg(ptr)
   754  		v1.AddArg2(v2, mem)
   755  		v.AddArg2(v0, v1)
   756  		return true
   757  	}
   758  	// match: (Load <t> ptr mem)
   759  	// cond: is64BitInt(t) && config.BigEndian && !t.IsSigned()
   760  	// result: (Int64Make (Load <typ.UInt32> ptr mem) (Load <typ.UInt32> (OffPtr <typ.UInt32Ptr> [4] ptr) mem))
   761  	for {
   762  		t := v.Type
   763  		ptr := v_0
   764  		mem := v_1
   765  		if !(is64BitInt(t) && config.BigEndian && !t.IsSigned()) {
   766  			break
   767  		}
   768  		v.reset(OpInt64Make)
   769  		v0 := b.NewValue0(v.Pos, OpLoad, typ.UInt32)
   770  		v0.AddArg2(ptr, mem)
   771  		v1 := b.NewValue0(v.Pos, OpLoad, typ.UInt32)
   772  		v2 := b.NewValue0(v.Pos, OpOffPtr, typ.UInt32Ptr)
   773  		v2.AuxInt = int64ToAuxInt(4)
   774  		v2.AddArg(ptr)
   775  		v1.AddArg2(v2, mem)
   776  		v.AddArg2(v0, v1)
   777  		return true
   778  	}
   779  	return false
   780  }
   781  func rewriteValuedec64_OpLsh16x64(v *Value) bool {
   782  	v_1 := v.Args[1]
   783  	v_0 := v.Args[0]
   784  	b := v.Block
   785  	typ := &b.Func.Config.Types
   786  	// match: (Lsh16x64 _ (Int64Make (Const32 [c]) _))
   787  	// cond: c != 0
   788  	// result: (Const32 [0])
   789  	for {
   790  		if v_1.Op != OpInt64Make {
   791  			break
   792  		}
   793  		v_1_0 := v_1.Args[0]
   794  		if v_1_0.Op != OpConst32 {
   795  			break
   796  		}
   797  		c := auxIntToInt32(v_1_0.AuxInt)
   798  		if !(c != 0) {
   799  			break
   800  		}
   801  		v.reset(OpConst32)
   802  		v.AuxInt = int32ToAuxInt(0)
   803  		return true
   804  	}
   805  	// match: (Lsh16x64 [c] x (Int64Make (Const32 [0]) lo))
   806  	// result: (Lsh16x32 [c] x lo)
   807  	for {
   808  		c := auxIntToBool(v.AuxInt)
   809  		x := v_0
   810  		if v_1.Op != OpInt64Make {
   811  			break
   812  		}
   813  		lo := v_1.Args[1]
   814  		v_1_0 := v_1.Args[0]
   815  		if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 {
   816  			break
   817  		}
   818  		v.reset(OpLsh16x32)
   819  		v.AuxInt = boolToAuxInt(c)
   820  		v.AddArg2(x, lo)
   821  		return true
   822  	}
   823  	// match: (Lsh16x64 x (Int64Make hi lo))
   824  	// cond: hi.Op != OpConst32
   825  	// result: (Lsh16x32 x (Or32 <typ.UInt32> (Zeromask hi) lo))
   826  	for {
   827  		x := v_0
   828  		if v_1.Op != OpInt64Make {
   829  			break
   830  		}
   831  		lo := v_1.Args[1]
   832  		hi := v_1.Args[0]
   833  		if !(hi.Op != OpConst32) {
   834  			break
   835  		}
   836  		v.reset(OpLsh16x32)
   837  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
   838  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
   839  		v1.AddArg(hi)
   840  		v0.AddArg2(v1, lo)
   841  		v.AddArg2(x, v0)
   842  		return true
   843  	}
   844  	// match: (Lsh16x64 x y)
   845  	// result: (Lsh16x32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))
   846  	for {
   847  		x := v_0
   848  		y := v_1
   849  		v.reset(OpLsh16x32)
   850  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
   851  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
   852  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   853  		v2.AddArg(y)
   854  		v1.AddArg(v2)
   855  		v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   856  		v3.AddArg(y)
   857  		v0.AddArg2(v1, v3)
   858  		v.AddArg2(x, v0)
   859  		return true
   860  	}
   861  }
   862  func rewriteValuedec64_OpLsh32x64(v *Value) bool {
   863  	v_1 := v.Args[1]
   864  	v_0 := v.Args[0]
   865  	b := v.Block
   866  	typ := &b.Func.Config.Types
   867  	// match: (Lsh32x64 _ (Int64Make (Const32 [c]) _))
   868  	// cond: c != 0
   869  	// result: (Const32 [0])
   870  	for {
   871  		if v_1.Op != OpInt64Make {
   872  			break
   873  		}
   874  		v_1_0 := v_1.Args[0]
   875  		if v_1_0.Op != OpConst32 {
   876  			break
   877  		}
   878  		c := auxIntToInt32(v_1_0.AuxInt)
   879  		if !(c != 0) {
   880  			break
   881  		}
   882  		v.reset(OpConst32)
   883  		v.AuxInt = int32ToAuxInt(0)
   884  		return true
   885  	}
   886  	// match: (Lsh32x64 [c] x (Int64Make (Const32 [0]) lo))
   887  	// result: (Lsh32x32 [c] x lo)
   888  	for {
   889  		c := auxIntToBool(v.AuxInt)
   890  		x := v_0
   891  		if v_1.Op != OpInt64Make {
   892  			break
   893  		}
   894  		lo := v_1.Args[1]
   895  		v_1_0 := v_1.Args[0]
   896  		if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 {
   897  			break
   898  		}
   899  		v.reset(OpLsh32x32)
   900  		v.AuxInt = boolToAuxInt(c)
   901  		v.AddArg2(x, lo)
   902  		return true
   903  	}
   904  	// match: (Lsh32x64 x (Int64Make hi lo))
   905  	// cond: hi.Op != OpConst32
   906  	// result: (Lsh32x32 x (Or32 <typ.UInt32> (Zeromask hi) lo))
   907  	for {
   908  		x := v_0
   909  		if v_1.Op != OpInt64Make {
   910  			break
   911  		}
   912  		lo := v_1.Args[1]
   913  		hi := v_1.Args[0]
   914  		if !(hi.Op != OpConst32) {
   915  			break
   916  		}
   917  		v.reset(OpLsh32x32)
   918  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
   919  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
   920  		v1.AddArg(hi)
   921  		v0.AddArg2(v1, lo)
   922  		v.AddArg2(x, v0)
   923  		return true
   924  	}
   925  	// match: (Lsh32x64 x y)
   926  	// result: (Lsh32x32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))
   927  	for {
   928  		x := v_0
   929  		y := v_1
   930  		v.reset(OpLsh32x32)
   931  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
   932  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
   933  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   934  		v2.AddArg(y)
   935  		v1.AddArg(v2)
   936  		v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   937  		v3.AddArg(y)
   938  		v0.AddArg2(v1, v3)
   939  		v.AddArg2(x, v0)
   940  		return true
   941  	}
   942  }
   943  func rewriteValuedec64_OpLsh64x16(v *Value) bool {
   944  	v_1 := v.Args[1]
   945  	v_0 := v.Args[0]
   946  	b := v.Block
   947  	typ := &b.Func.Config.Types
   948  	// match: (Lsh64x16 x s)
   949  	// result: (Int64Make (Or32 <typ.UInt32> (Or32 <typ.UInt32> (Lsh32x16 <typ.UInt32> (Int64Hi x) s) (Rsh32Ux16 <typ.UInt32> (Int64Lo x) (Sub16 <typ.UInt16> (Const16 <typ.UInt16> [32]) s))) (Lsh32x16 <typ.UInt32> (Int64Lo x) (Sub16 <typ.UInt16> s (Const16 <typ.UInt16> [32])))) (Lsh32x16 <typ.UInt32> (Int64Lo x) s))
   950  	for {
   951  		x := v_0
   952  		s := v_1
   953  		v.reset(OpInt64Make)
   954  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
   955  		v1 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
   956  		v2 := b.NewValue0(v.Pos, OpLsh32x16, typ.UInt32)
   957  		v3 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   958  		v3.AddArg(x)
   959  		v2.AddArg2(v3, s)
   960  		v4 := b.NewValue0(v.Pos, OpRsh32Ux16, typ.UInt32)
   961  		v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   962  		v5.AddArg(x)
   963  		v6 := b.NewValue0(v.Pos, OpSub16, typ.UInt16)
   964  		v7 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
   965  		v7.AuxInt = int16ToAuxInt(32)
   966  		v6.AddArg2(v7, s)
   967  		v4.AddArg2(v5, v6)
   968  		v1.AddArg2(v2, v4)
   969  		v8 := b.NewValue0(v.Pos, OpLsh32x16, typ.UInt32)
   970  		v9 := b.NewValue0(v.Pos, OpSub16, typ.UInt16)
   971  		v9.AddArg2(s, v7)
   972  		v8.AddArg2(v5, v9)
   973  		v0.AddArg2(v1, v8)
   974  		v10 := b.NewValue0(v.Pos, OpLsh32x16, typ.UInt32)
   975  		v10.AddArg2(v5, s)
   976  		v.AddArg2(v0, v10)
   977  		return true
   978  	}
   979  }
   980  func rewriteValuedec64_OpLsh64x32(v *Value) bool {
   981  	v_1 := v.Args[1]
   982  	v_0 := v.Args[0]
   983  	b := v.Block
   984  	typ := &b.Func.Config.Types
   985  	// match: (Lsh64x32 x s)
   986  	// result: (Int64Make (Or32 <typ.UInt32> (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Hi x) s) (Rsh32Ux32 <typ.UInt32> (Int64Lo x) (Sub32 <typ.UInt32> (Const32 <typ.UInt32> [32]) s))) (Lsh32x32 <typ.UInt32> (Int64Lo x) (Sub32 <typ.UInt32> s (Const32 <typ.UInt32> [32])))) (Lsh32x32 <typ.UInt32> (Int64Lo x) s))
   987  	for {
   988  		x := v_0
   989  		s := v_1
   990  		v.reset(OpInt64Make)
   991  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
   992  		v1 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
   993  		v2 := b.NewValue0(v.Pos, OpLsh32x32, typ.UInt32)
   994  		v3 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   995  		v3.AddArg(x)
   996  		v2.AddArg2(v3, s)
   997  		v4 := b.NewValue0(v.Pos, OpRsh32Ux32, typ.UInt32)
   998  		v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   999  		v5.AddArg(x)
  1000  		v6 := b.NewValue0(v.Pos, OpSub32, typ.UInt32)
  1001  		v7 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  1002  		v7.AuxInt = int32ToAuxInt(32)
  1003  		v6.AddArg2(v7, s)
  1004  		v4.AddArg2(v5, v6)
  1005  		v1.AddArg2(v2, v4)
  1006  		v8 := b.NewValue0(v.Pos, OpLsh32x32, typ.UInt32)
  1007  		v9 := b.NewValue0(v.Pos, OpSub32, typ.UInt32)
  1008  		v9.AddArg2(s, v7)
  1009  		v8.AddArg2(v5, v9)
  1010  		v0.AddArg2(v1, v8)
  1011  		v10 := b.NewValue0(v.Pos, OpLsh32x32, typ.UInt32)
  1012  		v10.AddArg2(v5, s)
  1013  		v.AddArg2(v0, v10)
  1014  		return true
  1015  	}
  1016  }
  1017  func rewriteValuedec64_OpLsh64x64(v *Value) bool {
  1018  	v_1 := v.Args[1]
  1019  	v_0 := v.Args[0]
  1020  	b := v.Block
  1021  	typ := &b.Func.Config.Types
  1022  	// match: (Lsh64x64 _ (Int64Make (Const32 [c]) _))
  1023  	// cond: c != 0
  1024  	// result: (Const64 [0])
  1025  	for {
  1026  		if v_1.Op != OpInt64Make {
  1027  			break
  1028  		}
  1029  		v_1_0 := v_1.Args[0]
  1030  		if v_1_0.Op != OpConst32 {
  1031  			break
  1032  		}
  1033  		c := auxIntToInt32(v_1_0.AuxInt)
  1034  		if !(c != 0) {
  1035  			break
  1036  		}
  1037  		v.reset(OpConst64)
  1038  		v.AuxInt = int64ToAuxInt(0)
  1039  		return true
  1040  	}
  1041  	// match: (Lsh64x64 [c] x (Int64Make (Const32 [0]) lo))
  1042  	// result: (Lsh64x32 [c] x lo)
  1043  	for {
  1044  		c := auxIntToBool(v.AuxInt)
  1045  		x := v_0
  1046  		if v_1.Op != OpInt64Make {
  1047  			break
  1048  		}
  1049  		lo := v_1.Args[1]
  1050  		v_1_0 := v_1.Args[0]
  1051  		if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 {
  1052  			break
  1053  		}
  1054  		v.reset(OpLsh64x32)
  1055  		v.AuxInt = boolToAuxInt(c)
  1056  		v.AddArg2(x, lo)
  1057  		return true
  1058  	}
  1059  	// match: (Lsh64x64 x (Int64Make hi lo))
  1060  	// cond: hi.Op != OpConst32
  1061  	// result: (Lsh64x32 x (Or32 <typ.UInt32> (Zeromask hi) lo))
  1062  	for {
  1063  		x := v_0
  1064  		if v_1.Op != OpInt64Make {
  1065  			break
  1066  		}
  1067  		lo := v_1.Args[1]
  1068  		hi := v_1.Args[0]
  1069  		if !(hi.Op != OpConst32) {
  1070  			break
  1071  		}
  1072  		v.reset(OpLsh64x32)
  1073  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1074  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  1075  		v1.AddArg(hi)
  1076  		v0.AddArg2(v1, lo)
  1077  		v.AddArg2(x, v0)
  1078  		return true
  1079  	}
  1080  	// match: (Lsh64x64 x y)
  1081  	// result: (Lsh64x32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))
  1082  	for {
  1083  		x := v_0
  1084  		y := v_1
  1085  		v.reset(OpLsh64x32)
  1086  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1087  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  1088  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1089  		v2.AddArg(y)
  1090  		v1.AddArg(v2)
  1091  		v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1092  		v3.AddArg(y)
  1093  		v0.AddArg2(v1, v3)
  1094  		v.AddArg2(x, v0)
  1095  		return true
  1096  	}
  1097  }
  1098  func rewriteValuedec64_OpLsh64x8(v *Value) bool {
  1099  	v_1 := v.Args[1]
  1100  	v_0 := v.Args[0]
  1101  	b := v.Block
  1102  	typ := &b.Func.Config.Types
  1103  	// match: (Lsh64x8 x s)
  1104  	// result: (Int64Make (Or32 <typ.UInt32> (Or32 <typ.UInt32> (Lsh32x8 <typ.UInt32> (Int64Hi x) s) (Rsh32Ux8 <typ.UInt32> (Int64Lo x) (Sub8 <typ.UInt8> (Const8 <typ.UInt8> [32]) s))) (Lsh32x8 <typ.UInt32> (Int64Lo x) (Sub8 <typ.UInt8> s (Const8 <typ.UInt8> [32])))) (Lsh32x8 <typ.UInt32> (Int64Lo x) s))
  1105  	for {
  1106  		x := v_0
  1107  		s := v_1
  1108  		v.reset(OpInt64Make)
  1109  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1110  		v1 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1111  		v2 := b.NewValue0(v.Pos, OpLsh32x8, typ.UInt32)
  1112  		v3 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1113  		v3.AddArg(x)
  1114  		v2.AddArg2(v3, s)
  1115  		v4 := b.NewValue0(v.Pos, OpRsh32Ux8, typ.UInt32)
  1116  		v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1117  		v5.AddArg(x)
  1118  		v6 := b.NewValue0(v.Pos, OpSub8, typ.UInt8)
  1119  		v7 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
  1120  		v7.AuxInt = int8ToAuxInt(32)
  1121  		v6.AddArg2(v7, s)
  1122  		v4.AddArg2(v5, v6)
  1123  		v1.AddArg2(v2, v4)
  1124  		v8 := b.NewValue0(v.Pos, OpLsh32x8, typ.UInt32)
  1125  		v9 := b.NewValue0(v.Pos, OpSub8, typ.UInt8)
  1126  		v9.AddArg2(s, v7)
  1127  		v8.AddArg2(v5, v9)
  1128  		v0.AddArg2(v1, v8)
  1129  		v10 := b.NewValue0(v.Pos, OpLsh32x8, typ.UInt32)
  1130  		v10.AddArg2(v5, s)
  1131  		v.AddArg2(v0, v10)
  1132  		return true
  1133  	}
  1134  }
  1135  func rewriteValuedec64_OpLsh8x64(v *Value) bool {
  1136  	v_1 := v.Args[1]
  1137  	v_0 := v.Args[0]
  1138  	b := v.Block
  1139  	typ := &b.Func.Config.Types
  1140  	// match: (Lsh8x64 _ (Int64Make (Const32 [c]) _))
  1141  	// cond: c != 0
  1142  	// result: (Const32 [0])
  1143  	for {
  1144  		if v_1.Op != OpInt64Make {
  1145  			break
  1146  		}
  1147  		v_1_0 := v_1.Args[0]
  1148  		if v_1_0.Op != OpConst32 {
  1149  			break
  1150  		}
  1151  		c := auxIntToInt32(v_1_0.AuxInt)
  1152  		if !(c != 0) {
  1153  			break
  1154  		}
  1155  		v.reset(OpConst32)
  1156  		v.AuxInt = int32ToAuxInt(0)
  1157  		return true
  1158  	}
  1159  	// match: (Lsh8x64 [c] x (Int64Make (Const32 [0]) lo))
  1160  	// result: (Lsh8x32 [c] x lo)
  1161  	for {
  1162  		c := auxIntToBool(v.AuxInt)
  1163  		x := v_0
  1164  		if v_1.Op != OpInt64Make {
  1165  			break
  1166  		}
  1167  		lo := v_1.Args[1]
  1168  		v_1_0 := v_1.Args[0]
  1169  		if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 {
  1170  			break
  1171  		}
  1172  		v.reset(OpLsh8x32)
  1173  		v.AuxInt = boolToAuxInt(c)
  1174  		v.AddArg2(x, lo)
  1175  		return true
  1176  	}
  1177  	// match: (Lsh8x64 x (Int64Make hi lo))
  1178  	// cond: hi.Op != OpConst32
  1179  	// result: (Lsh8x32 x (Or32 <typ.UInt32> (Zeromask hi) lo))
  1180  	for {
  1181  		x := v_0
  1182  		if v_1.Op != OpInt64Make {
  1183  			break
  1184  		}
  1185  		lo := v_1.Args[1]
  1186  		hi := v_1.Args[0]
  1187  		if !(hi.Op != OpConst32) {
  1188  			break
  1189  		}
  1190  		v.reset(OpLsh8x32)
  1191  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1192  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  1193  		v1.AddArg(hi)
  1194  		v0.AddArg2(v1, lo)
  1195  		v.AddArg2(x, v0)
  1196  		return true
  1197  	}
  1198  	// match: (Lsh8x64 x y)
  1199  	// result: (Lsh8x32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))
  1200  	for {
  1201  		x := v_0
  1202  		y := v_1
  1203  		v.reset(OpLsh8x32)
  1204  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1205  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  1206  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1207  		v2.AddArg(y)
  1208  		v1.AddArg(v2)
  1209  		v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1210  		v3.AddArg(y)
  1211  		v0.AddArg2(v1, v3)
  1212  		v.AddArg2(x, v0)
  1213  		return true
  1214  	}
  1215  }
  1216  func rewriteValuedec64_OpMul64(v *Value) bool {
  1217  	v_1 := v.Args[1]
  1218  	v_0 := v.Args[0]
  1219  	b := v.Block
  1220  	typ := &b.Func.Config.Types
  1221  	// match: (Mul64 <t> x y)
  1222  	// result: (Last <t> x0: (Int64Lo x) x1: (Int64Hi x) y0: (Int64Lo y) y1: (Int64Hi y) x0y0: (Mul32uhilo x0 y0) x0y0Hi: (Select0 <typ.UInt32> x0y0) x0y0Lo: (Select1 <typ.UInt32> x0y0) (Int64Make (Add32 <typ.UInt32> x0y0Hi (Add32 <typ.UInt32> (Mul32 <typ.UInt32> x0 y1) (Mul32 <typ.UInt32> x1 y0))) x0y0Lo))
  1223  	for {
  1224  		t := v.Type
  1225  		x := v_0
  1226  		y := v_1
  1227  		v.reset(OpLast)
  1228  		v.Type = t
  1229  		x0 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1230  		x0.AddArg(x)
  1231  		x1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1232  		x1.AddArg(x)
  1233  		y0 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1234  		y0.AddArg(y)
  1235  		y1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1236  		y1.AddArg(y)
  1237  		x0y0 := b.NewValue0(v.Pos, OpMul32uhilo, types.NewTuple(typ.UInt32, typ.UInt32))
  1238  		x0y0.AddArg2(x0, y0)
  1239  		x0y0Hi := b.NewValue0(v.Pos, OpSelect0, typ.UInt32)
  1240  		x0y0Hi.AddArg(x0y0)
  1241  		x0y0Lo := b.NewValue0(v.Pos, OpSelect1, typ.UInt32)
  1242  		x0y0Lo.AddArg(x0y0)
  1243  		v7 := b.NewValue0(v.Pos, OpInt64Make, typ.UInt64)
  1244  		v8 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
  1245  		v9 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
  1246  		v10 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
  1247  		v10.AddArg2(x0, y1)
  1248  		v11 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
  1249  		v11.AddArg2(x1, y0)
  1250  		v9.AddArg2(v10, v11)
  1251  		v8.AddArg2(x0y0Hi, v9)
  1252  		v7.AddArg2(v8, x0y0Lo)
  1253  		v.AddArgs(x0, x1, y0, y1, x0y0, x0y0Hi, x0y0Lo, v7)
  1254  		return true
  1255  	}
  1256  }
  1257  func rewriteValuedec64_OpMul64uhilo(v *Value) bool {
  1258  	v_1 := v.Args[1]
  1259  	v_0 := v.Args[0]
  1260  	b := v.Block
  1261  	typ := &b.Func.Config.Types
  1262  	// match: (Mul64uhilo <t> x y)
  1263  	// result: (Last <t> x0: (Int64Lo x) x1: (Int64Hi x) y0: (Int64Lo y) y1: (Int64Hi y) x0y0: (Mul32uhilo x0 y0) x0y1: (Mul32uhilo x0 y1) x1y0: (Mul32uhilo x1 y0) x1y1: (Mul32uhilo x1 y1) x0y0Hi: (Select0 <typ.UInt32> x0y0) x0y0Lo: (Select1 <typ.UInt32> x0y0) x0y1Hi: (Select0 <typ.UInt32> x0y1) x0y1Lo: (Select1 <typ.UInt32> x0y1) x1y0Hi: (Select0 <typ.UInt32> x1y0) x1y0Lo: (Select1 <typ.UInt32> x1y0) x1y1Hi: (Select0 <typ.UInt32> x1y1) x1y1Lo: (Select1 <typ.UInt32> x1y1) w1a: (Add32carry x0y0Hi x0y1Lo) w2a: (Add32carrywithcarry x0y1Hi x1y0Hi (Select1 <types.TypeFlags> w1a)) w3a: (Add32withcarry <typ.UInt32> x1y1Hi (Const32 <typ.UInt32> [0]) (Select1 <types.TypeFlags> w2a)) w1b: (Add32carry x1y0Lo (Select0 <typ.UInt32> w1a)) w2b: (Add32carrywithcarry x1y1Lo (Select0 <typ.UInt32> w2a) (Select1 <types.TypeFlags> w1b)) w3b: (Add32withcarry <typ.UInt32> w3a (Const32 <typ.UInt32> [0]) (Select1 <types.TypeFlags> w2b)) (MakeTuple <types.NewTuple(typ.UInt64,typ.UInt64)> (Int64Make w3b (Select0 <typ.UInt32> w2b)) (Int64Make (Select0 <typ.UInt32> w1b) x0y0Lo)))
  1264  	for {
  1265  		t := v.Type
  1266  		x := v_0
  1267  		y := v_1
  1268  		v.reset(OpLast)
  1269  		v.Type = t
  1270  		x0 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1271  		x0.AddArg(x)
  1272  		x1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1273  		x1.AddArg(x)
  1274  		y0 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1275  		y0.AddArg(y)
  1276  		y1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1277  		y1.AddArg(y)
  1278  		x0y0 := b.NewValue0(v.Pos, OpMul32uhilo, types.NewTuple(typ.UInt32, typ.UInt32))
  1279  		x0y0.AddArg2(x0, y0)
  1280  		x0y1 := b.NewValue0(v.Pos, OpMul32uhilo, types.NewTuple(typ.UInt32, typ.UInt32))
  1281  		x0y1.AddArg2(x0, y1)
  1282  		x1y0 := b.NewValue0(v.Pos, OpMul32uhilo, types.NewTuple(typ.UInt32, typ.UInt32))
  1283  		x1y0.AddArg2(x1, y0)
  1284  		x1y1 := b.NewValue0(v.Pos, OpMul32uhilo, types.NewTuple(typ.UInt32, typ.UInt32))
  1285  		x1y1.AddArg2(x1, y1)
  1286  		x0y0Hi := b.NewValue0(v.Pos, OpSelect0, typ.UInt32)
  1287  		x0y0Hi.AddArg(x0y0)
  1288  		x0y0Lo := b.NewValue0(v.Pos, OpSelect1, typ.UInt32)
  1289  		x0y0Lo.AddArg(x0y0)
  1290  		x0y1Hi := b.NewValue0(v.Pos, OpSelect0, typ.UInt32)
  1291  		x0y1Hi.AddArg(x0y1)
  1292  		x0y1Lo := b.NewValue0(v.Pos, OpSelect1, typ.UInt32)
  1293  		x0y1Lo.AddArg(x0y1)
  1294  		x1y0Hi := b.NewValue0(v.Pos, OpSelect0, typ.UInt32)
  1295  		x1y0Hi.AddArg(x1y0)
  1296  		x1y0Lo := b.NewValue0(v.Pos, OpSelect1, typ.UInt32)
  1297  		x1y0Lo.AddArg(x1y0)
  1298  		x1y1Hi := b.NewValue0(v.Pos, OpSelect0, typ.UInt32)
  1299  		x1y1Hi.AddArg(x1y1)
  1300  		x1y1Lo := b.NewValue0(v.Pos, OpSelect1, typ.UInt32)
  1301  		x1y1Lo.AddArg(x1y1)
  1302  		w1a := b.NewValue0(v.Pos, OpAdd32carry, types.NewTuple(typ.UInt32, types.TypeFlags))
  1303  		w1a.AddArg2(x0y0Hi, x0y1Lo)
  1304  		w2a := b.NewValue0(v.Pos, OpAdd32carrywithcarry, types.NewTuple(typ.UInt32, types.TypeFlags))
  1305  		v18 := b.NewValue0(v.Pos, OpSelect1, types.TypeFlags)
  1306  		v18.AddArg(w1a)
  1307  		w2a.AddArg3(x0y1Hi, x1y0Hi, v18)
  1308  		w3a := b.NewValue0(v.Pos, OpAdd32withcarry, typ.UInt32)
  1309  		v20 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  1310  		v20.AuxInt = int32ToAuxInt(0)
  1311  		v21 := b.NewValue0(v.Pos, OpSelect1, types.TypeFlags)
  1312  		v21.AddArg(w2a)
  1313  		w3a.AddArg3(x1y1Hi, v20, v21)
  1314  		w1b := b.NewValue0(v.Pos, OpAdd32carry, types.NewTuple(typ.UInt32, types.TypeFlags))
  1315  		v23 := b.NewValue0(v.Pos, OpSelect0, typ.UInt32)
  1316  		v23.AddArg(w1a)
  1317  		w1b.AddArg2(x1y0Lo, v23)
  1318  		w2b := b.NewValue0(v.Pos, OpAdd32carrywithcarry, types.NewTuple(typ.UInt32, types.TypeFlags))
  1319  		v25 := b.NewValue0(v.Pos, OpSelect0, typ.UInt32)
  1320  		v25.AddArg(w2a)
  1321  		v26 := b.NewValue0(v.Pos, OpSelect1, types.TypeFlags)
  1322  		v26.AddArg(w1b)
  1323  		w2b.AddArg3(x1y1Lo, v25, v26)
  1324  		w3b := b.NewValue0(v.Pos, OpAdd32withcarry, typ.UInt32)
  1325  		v28 := b.NewValue0(v.Pos, OpSelect1, types.TypeFlags)
  1326  		v28.AddArg(w2b)
  1327  		w3b.AddArg3(w3a, v20, v28)
  1328  		v29 := b.NewValue0(v.Pos, OpMakeTuple, types.NewTuple(typ.UInt64, typ.UInt64))
  1329  		v30 := b.NewValue0(v.Pos, OpInt64Make, typ.UInt64)
  1330  		v31 := b.NewValue0(v.Pos, OpSelect0, typ.UInt32)
  1331  		v31.AddArg(w2b)
  1332  		v30.AddArg2(w3b, v31)
  1333  		v32 := b.NewValue0(v.Pos, OpInt64Make, typ.UInt64)
  1334  		v33 := b.NewValue0(v.Pos, OpSelect0, typ.UInt32)
  1335  		v33.AddArg(w1b)
  1336  		v32.AddArg2(v33, x0y0Lo)
  1337  		v29.AddArg2(v30, v32)
  1338  		v.AddArgs(x0, x1, y0, y1, x0y0, x0y1, x1y0, x1y1, x0y0Hi, x0y0Lo, x0y1Hi, x0y1Lo, x1y0Hi, x1y0Lo, x1y1Hi, x1y1Lo, w1a, w2a, w3a, w1b, w2b, w3b, v29)
  1339  		return true
  1340  	}
  1341  }
  1342  func rewriteValuedec64_OpNeg64(v *Value) bool {
  1343  	v_0 := v.Args[0]
  1344  	b := v.Block
  1345  	// match: (Neg64 <t> x)
  1346  	// result: (Sub64 (Const64 <t> [0]) x)
  1347  	for {
  1348  		t := v.Type
  1349  		x := v_0
  1350  		v.reset(OpSub64)
  1351  		v0 := b.NewValue0(v.Pos, OpConst64, t)
  1352  		v0.AuxInt = int64ToAuxInt(0)
  1353  		v.AddArg2(v0, x)
  1354  		return true
  1355  	}
  1356  }
  1357  func rewriteValuedec64_OpNeq64(v *Value) bool {
  1358  	v_1 := v.Args[1]
  1359  	v_0 := v.Args[0]
  1360  	b := v.Block
  1361  	typ := &b.Func.Config.Types
  1362  	// match: (Neq64 x y)
  1363  	// result: (OrB (Neq32 (Int64Hi x) (Int64Hi y)) (Neq32 (Int64Lo x) (Int64Lo y)))
  1364  	for {
  1365  		x := v_0
  1366  		y := v_1
  1367  		v.reset(OpOrB)
  1368  		v0 := b.NewValue0(v.Pos, OpNeq32, typ.Bool)
  1369  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1370  		v1.AddArg(x)
  1371  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1372  		v2.AddArg(y)
  1373  		v0.AddArg2(v1, v2)
  1374  		v3 := b.NewValue0(v.Pos, OpNeq32, typ.Bool)
  1375  		v4 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1376  		v4.AddArg(x)
  1377  		v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1378  		v5.AddArg(y)
  1379  		v3.AddArg2(v4, v5)
  1380  		v.AddArg2(v0, v3)
  1381  		return true
  1382  	}
  1383  }
  1384  func rewriteValuedec64_OpOr32(v *Value) bool {
  1385  	v_1 := v.Args[1]
  1386  	v_0 := v.Args[0]
  1387  	b := v.Block
  1388  	typ := &b.Func.Config.Types
  1389  	// match: (Or32 <typ.UInt32> (Zeromask (Const32 [c])) y)
  1390  	// cond: c == 0
  1391  	// result: y
  1392  	for {
  1393  		if v.Type != typ.UInt32 {
  1394  			break
  1395  		}
  1396  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  1397  			if v_0.Op != OpZeromask {
  1398  				continue
  1399  			}
  1400  			v_0_0 := v_0.Args[0]
  1401  			if v_0_0.Op != OpConst32 {
  1402  				continue
  1403  			}
  1404  			c := auxIntToInt32(v_0_0.AuxInt)
  1405  			y := v_1
  1406  			if !(c == 0) {
  1407  				continue
  1408  			}
  1409  			v.copyOf(y)
  1410  			return true
  1411  		}
  1412  		break
  1413  	}
  1414  	// match: (Or32 <typ.UInt32> (Zeromask (Const32 [c])) y)
  1415  	// cond: c != 0
  1416  	// result: (Const32 <typ.UInt32> [-1])
  1417  	for {
  1418  		if v.Type != typ.UInt32 {
  1419  			break
  1420  		}
  1421  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  1422  			if v_0.Op != OpZeromask {
  1423  				continue
  1424  			}
  1425  			v_0_0 := v_0.Args[0]
  1426  			if v_0_0.Op != OpConst32 {
  1427  				continue
  1428  			}
  1429  			c := auxIntToInt32(v_0_0.AuxInt)
  1430  			if !(c != 0) {
  1431  				continue
  1432  			}
  1433  			v.reset(OpConst32)
  1434  			v.Type = typ.UInt32
  1435  			v.AuxInt = int32ToAuxInt(-1)
  1436  			return true
  1437  		}
  1438  		break
  1439  	}
  1440  	return false
  1441  }
  1442  func rewriteValuedec64_OpOr64(v *Value) bool {
  1443  	v_1 := v.Args[1]
  1444  	v_0 := v.Args[0]
  1445  	b := v.Block
  1446  	typ := &b.Func.Config.Types
  1447  	// match: (Or64 x y)
  1448  	// result: (Int64Make (Or32 <typ.UInt32> (Int64Hi x) (Int64Hi y)) (Or32 <typ.UInt32> (Int64Lo x) (Int64Lo y)))
  1449  	for {
  1450  		x := v_0
  1451  		y := v_1
  1452  		v.reset(OpInt64Make)
  1453  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1454  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1455  		v1.AddArg(x)
  1456  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1457  		v2.AddArg(y)
  1458  		v0.AddArg2(v1, v2)
  1459  		v3 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1460  		v4 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1461  		v4.AddArg(x)
  1462  		v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1463  		v5.AddArg(y)
  1464  		v3.AddArg2(v4, v5)
  1465  		v.AddArg2(v0, v3)
  1466  		return true
  1467  	}
  1468  }
  1469  func rewriteValuedec64_OpRotateLeft16(v *Value) bool {
  1470  	v_1 := v.Args[1]
  1471  	v_0 := v.Args[0]
  1472  	// match: (RotateLeft16 x (Int64Make hi lo))
  1473  	// result: (RotateLeft16 x lo)
  1474  	for {
  1475  		x := v_0
  1476  		if v_1.Op != OpInt64Make {
  1477  			break
  1478  		}
  1479  		lo := v_1.Args[1]
  1480  		v.reset(OpRotateLeft16)
  1481  		v.AddArg2(x, lo)
  1482  		return true
  1483  	}
  1484  	return false
  1485  }
  1486  func rewriteValuedec64_OpRotateLeft32(v *Value) bool {
  1487  	v_1 := v.Args[1]
  1488  	v_0 := v.Args[0]
  1489  	// match: (RotateLeft32 x (Int64Make hi lo))
  1490  	// result: (RotateLeft32 x lo)
  1491  	for {
  1492  		x := v_0
  1493  		if v_1.Op != OpInt64Make {
  1494  			break
  1495  		}
  1496  		lo := v_1.Args[1]
  1497  		v.reset(OpRotateLeft32)
  1498  		v.AddArg2(x, lo)
  1499  		return true
  1500  	}
  1501  	return false
  1502  }
  1503  func rewriteValuedec64_OpRotateLeft64(v *Value) bool {
  1504  	v_1 := v.Args[1]
  1505  	v_0 := v.Args[0]
  1506  	b := v.Block
  1507  	typ := &b.Func.Config.Types
  1508  	// match: (RotateLeft64 x (Int64Make hi lo))
  1509  	// result: (RotateLeft64 x lo)
  1510  	for {
  1511  		x := v_0
  1512  		if v_1.Op != OpInt64Make {
  1513  			break
  1514  		}
  1515  		lo := v_1.Args[1]
  1516  		v.reset(OpRotateLeft64)
  1517  		v.AddArg2(x, lo)
  1518  		return true
  1519  	}
  1520  	// match: (RotateLeft64 <t> x (Const64 [c]))
  1521  	// cond: c&63 == 0
  1522  	// result: x
  1523  	for {
  1524  		x := v_0
  1525  		if v_1.Op != OpConst64 {
  1526  			break
  1527  		}
  1528  		c := auxIntToInt64(v_1.AuxInt)
  1529  		if !(c&63 == 0) {
  1530  			break
  1531  		}
  1532  		v.copyOf(x)
  1533  		return true
  1534  	}
  1535  	// match: (RotateLeft64 <t> x (Const32 [c]))
  1536  	// cond: c&63 == 0
  1537  	// result: x
  1538  	for {
  1539  		x := v_0
  1540  		if v_1.Op != OpConst32 {
  1541  			break
  1542  		}
  1543  		c := auxIntToInt32(v_1.AuxInt)
  1544  		if !(c&63 == 0) {
  1545  			break
  1546  		}
  1547  		v.copyOf(x)
  1548  		return true
  1549  	}
  1550  	// match: (RotateLeft64 <t> x (Const16 [c]))
  1551  	// cond: c&63 == 0
  1552  	// result: x
  1553  	for {
  1554  		x := v_0
  1555  		if v_1.Op != OpConst16 {
  1556  			break
  1557  		}
  1558  		c := auxIntToInt16(v_1.AuxInt)
  1559  		if !(c&63 == 0) {
  1560  			break
  1561  		}
  1562  		v.copyOf(x)
  1563  		return true
  1564  	}
  1565  	// match: (RotateLeft64 <t> x (Const8 [c]))
  1566  	// cond: c&63 == 0
  1567  	// result: x
  1568  	for {
  1569  		x := v_0
  1570  		if v_1.Op != OpConst8 {
  1571  			break
  1572  		}
  1573  		c := auxIntToInt8(v_1.AuxInt)
  1574  		if !(c&63 == 0) {
  1575  			break
  1576  		}
  1577  		v.copyOf(x)
  1578  		return true
  1579  	}
  1580  	// match: (RotateLeft64 <t> x (Const64 [c]))
  1581  	// cond: c&63 == 32
  1582  	// result: (Int64Make <t> (Int64Lo x) (Int64Hi x))
  1583  	for {
  1584  		t := v.Type
  1585  		x := v_0
  1586  		if v_1.Op != OpConst64 {
  1587  			break
  1588  		}
  1589  		c := auxIntToInt64(v_1.AuxInt)
  1590  		if !(c&63 == 32) {
  1591  			break
  1592  		}
  1593  		v.reset(OpInt64Make)
  1594  		v.Type = t
  1595  		v0 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1596  		v0.AddArg(x)
  1597  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1598  		v1.AddArg(x)
  1599  		v.AddArg2(v0, v1)
  1600  		return true
  1601  	}
  1602  	// match: (RotateLeft64 <t> x (Const32 [c]))
  1603  	// cond: c&63 == 32
  1604  	// result: (Int64Make <t> (Int64Lo x) (Int64Hi x))
  1605  	for {
  1606  		t := v.Type
  1607  		x := v_0
  1608  		if v_1.Op != OpConst32 {
  1609  			break
  1610  		}
  1611  		c := auxIntToInt32(v_1.AuxInt)
  1612  		if !(c&63 == 32) {
  1613  			break
  1614  		}
  1615  		v.reset(OpInt64Make)
  1616  		v.Type = t
  1617  		v0 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1618  		v0.AddArg(x)
  1619  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1620  		v1.AddArg(x)
  1621  		v.AddArg2(v0, v1)
  1622  		return true
  1623  	}
  1624  	// match: (RotateLeft64 <t> x (Const16 [c]))
  1625  	// cond: c&63 == 32
  1626  	// result: (Int64Make <t> (Int64Lo x) (Int64Hi x))
  1627  	for {
  1628  		t := v.Type
  1629  		x := v_0
  1630  		if v_1.Op != OpConst16 {
  1631  			break
  1632  		}
  1633  		c := auxIntToInt16(v_1.AuxInt)
  1634  		if !(c&63 == 32) {
  1635  			break
  1636  		}
  1637  		v.reset(OpInt64Make)
  1638  		v.Type = t
  1639  		v0 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1640  		v0.AddArg(x)
  1641  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1642  		v1.AddArg(x)
  1643  		v.AddArg2(v0, v1)
  1644  		return true
  1645  	}
  1646  	// match: (RotateLeft64 <t> x (Const8 [c]))
  1647  	// cond: c&63 == 32
  1648  	// result: (Int64Make <t> (Int64Lo x) (Int64Hi x))
  1649  	for {
  1650  		t := v.Type
  1651  		x := v_0
  1652  		if v_1.Op != OpConst8 {
  1653  			break
  1654  		}
  1655  		c := auxIntToInt8(v_1.AuxInt)
  1656  		if !(c&63 == 32) {
  1657  			break
  1658  		}
  1659  		v.reset(OpInt64Make)
  1660  		v.Type = t
  1661  		v0 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1662  		v0.AddArg(x)
  1663  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1664  		v1.AddArg(x)
  1665  		v.AddArg2(v0, v1)
  1666  		return true
  1667  	}
  1668  	// match: (RotateLeft64 <t> x (Const64 [c]))
  1669  	// cond: 0 < c&63 && c&63 < 32
  1670  	// result: (Int64Make <t> (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(c&31)])) (Rsh32Ux32 <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(32-c&31)]))) (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(c&31)])) (Rsh32Ux32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(32-c&31)]))))
  1671  	for {
  1672  		t := v.Type
  1673  		x := v_0
  1674  		if v_1.Op != OpConst64 {
  1675  			break
  1676  		}
  1677  		c := auxIntToInt64(v_1.AuxInt)
  1678  		if !(0 < c&63 && c&63 < 32) {
  1679  			break
  1680  		}
  1681  		v.reset(OpInt64Make)
  1682  		v.Type = t
  1683  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1684  		v1 := b.NewValue0(v.Pos, OpLsh32x32, typ.UInt32)
  1685  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1686  		v2.AddArg(x)
  1687  		v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  1688  		v3.AuxInt = int32ToAuxInt(int32(c & 31))
  1689  		v1.AddArg2(v2, v3)
  1690  		v4 := b.NewValue0(v.Pos, OpRsh32Ux32, typ.UInt32)
  1691  		v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1692  		v5.AddArg(x)
  1693  		v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  1694  		v6.AuxInt = int32ToAuxInt(int32(32 - c&31))
  1695  		v4.AddArg2(v5, v6)
  1696  		v0.AddArg2(v1, v4)
  1697  		v7 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1698  		v8 := b.NewValue0(v.Pos, OpLsh32x32, typ.UInt32)
  1699  		v8.AddArg2(v5, v3)
  1700  		v9 := b.NewValue0(v.Pos, OpRsh32Ux32, typ.UInt32)
  1701  		v9.AddArg2(v2, v6)
  1702  		v7.AddArg2(v8, v9)
  1703  		v.AddArg2(v0, v7)
  1704  		return true
  1705  	}
  1706  	// match: (RotateLeft64 <t> x (Const32 [c]))
  1707  	// cond: 0 < c&63 && c&63 < 32
  1708  	// result: (Int64Make <t> (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(c&31)])) (Rsh32Ux32 <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(32-c&31)]))) (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(c&31)])) (Rsh32Ux32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(32-c&31)]))))
  1709  	for {
  1710  		t := v.Type
  1711  		x := v_0
  1712  		if v_1.Op != OpConst32 {
  1713  			break
  1714  		}
  1715  		c := auxIntToInt32(v_1.AuxInt)
  1716  		if !(0 < c&63 && c&63 < 32) {
  1717  			break
  1718  		}
  1719  		v.reset(OpInt64Make)
  1720  		v.Type = t
  1721  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1722  		v1 := b.NewValue0(v.Pos, OpLsh32x32, typ.UInt32)
  1723  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1724  		v2.AddArg(x)
  1725  		v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  1726  		v3.AuxInt = int32ToAuxInt(int32(c & 31))
  1727  		v1.AddArg2(v2, v3)
  1728  		v4 := b.NewValue0(v.Pos, OpRsh32Ux32, typ.UInt32)
  1729  		v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1730  		v5.AddArg(x)
  1731  		v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  1732  		v6.AuxInt = int32ToAuxInt(int32(32 - c&31))
  1733  		v4.AddArg2(v5, v6)
  1734  		v0.AddArg2(v1, v4)
  1735  		v7 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1736  		v8 := b.NewValue0(v.Pos, OpLsh32x32, typ.UInt32)
  1737  		v8.AddArg2(v5, v3)
  1738  		v9 := b.NewValue0(v.Pos, OpRsh32Ux32, typ.UInt32)
  1739  		v9.AddArg2(v2, v6)
  1740  		v7.AddArg2(v8, v9)
  1741  		v.AddArg2(v0, v7)
  1742  		return true
  1743  	}
  1744  	// match: (RotateLeft64 <t> x (Const16 [c]))
  1745  	// cond: 0 < c&63 && c&63 < 32
  1746  	// result: (Int64Make <t> (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(c&31)])) (Rsh32Ux32 <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(32-c&31)]))) (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(c&31)])) (Rsh32Ux32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(32-c&31)]))))
  1747  	for {
  1748  		t := v.Type
  1749  		x := v_0
  1750  		if v_1.Op != OpConst16 {
  1751  			break
  1752  		}
  1753  		c := auxIntToInt16(v_1.AuxInt)
  1754  		if !(0 < c&63 && c&63 < 32) {
  1755  			break
  1756  		}
  1757  		v.reset(OpInt64Make)
  1758  		v.Type = t
  1759  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1760  		v1 := b.NewValue0(v.Pos, OpLsh32x32, typ.UInt32)
  1761  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1762  		v2.AddArg(x)
  1763  		v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  1764  		v3.AuxInt = int32ToAuxInt(int32(c & 31))
  1765  		v1.AddArg2(v2, v3)
  1766  		v4 := b.NewValue0(v.Pos, OpRsh32Ux32, typ.UInt32)
  1767  		v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1768  		v5.AddArg(x)
  1769  		v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  1770  		v6.AuxInt = int32ToAuxInt(int32(32 - c&31))
  1771  		v4.AddArg2(v5, v6)
  1772  		v0.AddArg2(v1, v4)
  1773  		v7 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1774  		v8 := b.NewValue0(v.Pos, OpLsh32x32, typ.UInt32)
  1775  		v8.AddArg2(v5, v3)
  1776  		v9 := b.NewValue0(v.Pos, OpRsh32Ux32, typ.UInt32)
  1777  		v9.AddArg2(v2, v6)
  1778  		v7.AddArg2(v8, v9)
  1779  		v.AddArg2(v0, v7)
  1780  		return true
  1781  	}
  1782  	// match: (RotateLeft64 <t> x (Const8 [c]))
  1783  	// cond: 0 < c&63 && c&63 < 32
  1784  	// result: (Int64Make <t> (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(c&31)])) (Rsh32Ux32 <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(32-c&31)]))) (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(c&31)])) (Rsh32Ux32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(32-c&31)]))))
  1785  	for {
  1786  		t := v.Type
  1787  		x := v_0
  1788  		if v_1.Op != OpConst8 {
  1789  			break
  1790  		}
  1791  		c := auxIntToInt8(v_1.AuxInt)
  1792  		if !(0 < c&63 && c&63 < 32) {
  1793  			break
  1794  		}
  1795  		v.reset(OpInt64Make)
  1796  		v.Type = t
  1797  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1798  		v1 := b.NewValue0(v.Pos, OpLsh32x32, typ.UInt32)
  1799  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1800  		v2.AddArg(x)
  1801  		v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  1802  		v3.AuxInt = int32ToAuxInt(int32(c & 31))
  1803  		v1.AddArg2(v2, v3)
  1804  		v4 := b.NewValue0(v.Pos, OpRsh32Ux32, typ.UInt32)
  1805  		v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1806  		v5.AddArg(x)
  1807  		v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  1808  		v6.AuxInt = int32ToAuxInt(int32(32 - c&31))
  1809  		v4.AddArg2(v5, v6)
  1810  		v0.AddArg2(v1, v4)
  1811  		v7 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1812  		v8 := b.NewValue0(v.Pos, OpLsh32x32, typ.UInt32)
  1813  		v8.AddArg2(v5, v3)
  1814  		v9 := b.NewValue0(v.Pos, OpRsh32Ux32, typ.UInt32)
  1815  		v9.AddArg2(v2, v6)
  1816  		v7.AddArg2(v8, v9)
  1817  		v.AddArg2(v0, v7)
  1818  		return true
  1819  	}
  1820  	// match: (RotateLeft64 <t> x (Const64 [c]))
  1821  	// cond: 32 < c&63 && c&63 < 64
  1822  	// result: (Int64Make <t> (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(c&31)])) (Rsh32Ux32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(32-c&31)]))) (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(c&31)])) (Rsh32Ux32 <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(32-c&31)]))))
  1823  	for {
  1824  		t := v.Type
  1825  		x := v_0
  1826  		if v_1.Op != OpConst64 {
  1827  			break
  1828  		}
  1829  		c := auxIntToInt64(v_1.AuxInt)
  1830  		if !(32 < c&63 && c&63 < 64) {
  1831  			break
  1832  		}
  1833  		v.reset(OpInt64Make)
  1834  		v.Type = t
  1835  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1836  		v1 := b.NewValue0(v.Pos, OpLsh32x32, typ.UInt32)
  1837  		v2 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1838  		v2.AddArg(x)
  1839  		v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  1840  		v3.AuxInt = int32ToAuxInt(int32(c & 31))
  1841  		v1.AddArg2(v2, v3)
  1842  		v4 := b.NewValue0(v.Pos, OpRsh32Ux32, typ.UInt32)
  1843  		v5 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1844  		v5.AddArg(x)
  1845  		v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  1846  		v6.AuxInt = int32ToAuxInt(int32(32 - c&31))
  1847  		v4.AddArg2(v5, v6)
  1848  		v0.AddArg2(v1, v4)
  1849  		v7 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1850  		v8 := b.NewValue0(v.Pos, OpLsh32x32, typ.UInt32)
  1851  		v8.AddArg2(v5, v3)
  1852  		v9 := b.NewValue0(v.Pos, OpRsh32Ux32, typ.UInt32)
  1853  		v9.AddArg2(v2, v6)
  1854  		v7.AddArg2(v8, v9)
  1855  		v.AddArg2(v0, v7)
  1856  		return true
  1857  	}
  1858  	// match: (RotateLeft64 <t> x (Const32 [c]))
  1859  	// cond: 32 < c&63 && c&63 < 64
  1860  	// result: (Int64Make <t> (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(c&31)])) (Rsh32Ux32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(32-c&31)]))) (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(c&31)])) (Rsh32Ux32 <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(32-c&31)]))))
  1861  	for {
  1862  		t := v.Type
  1863  		x := v_0
  1864  		if v_1.Op != OpConst32 {
  1865  			break
  1866  		}
  1867  		c := auxIntToInt32(v_1.AuxInt)
  1868  		if !(32 < c&63 && c&63 < 64) {
  1869  			break
  1870  		}
  1871  		v.reset(OpInt64Make)
  1872  		v.Type = t
  1873  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1874  		v1 := b.NewValue0(v.Pos, OpLsh32x32, typ.UInt32)
  1875  		v2 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1876  		v2.AddArg(x)
  1877  		v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  1878  		v3.AuxInt = int32ToAuxInt(int32(c & 31))
  1879  		v1.AddArg2(v2, v3)
  1880  		v4 := b.NewValue0(v.Pos, OpRsh32Ux32, typ.UInt32)
  1881  		v5 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1882  		v5.AddArg(x)
  1883  		v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  1884  		v6.AuxInt = int32ToAuxInt(int32(32 - c&31))
  1885  		v4.AddArg2(v5, v6)
  1886  		v0.AddArg2(v1, v4)
  1887  		v7 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1888  		v8 := b.NewValue0(v.Pos, OpLsh32x32, typ.UInt32)
  1889  		v8.AddArg2(v5, v3)
  1890  		v9 := b.NewValue0(v.Pos, OpRsh32Ux32, typ.UInt32)
  1891  		v9.AddArg2(v2, v6)
  1892  		v7.AddArg2(v8, v9)
  1893  		v.AddArg2(v0, v7)
  1894  		return true
  1895  	}
  1896  	// match: (RotateLeft64 <t> x (Const16 [c]))
  1897  	// cond: 32 < c&63 && c&63 < 64
  1898  	// result: (Int64Make <t> (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(c&31)])) (Rsh32Ux32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(32-c&31)]))) (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(c&31)])) (Rsh32Ux32 <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(32-c&31)]))))
  1899  	for {
  1900  		t := v.Type
  1901  		x := v_0
  1902  		if v_1.Op != OpConst16 {
  1903  			break
  1904  		}
  1905  		c := auxIntToInt16(v_1.AuxInt)
  1906  		if !(32 < c&63 && c&63 < 64) {
  1907  			break
  1908  		}
  1909  		v.reset(OpInt64Make)
  1910  		v.Type = t
  1911  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1912  		v1 := b.NewValue0(v.Pos, OpLsh32x32, typ.UInt32)
  1913  		v2 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1914  		v2.AddArg(x)
  1915  		v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  1916  		v3.AuxInt = int32ToAuxInt(int32(c & 31))
  1917  		v1.AddArg2(v2, v3)
  1918  		v4 := b.NewValue0(v.Pos, OpRsh32Ux32, typ.UInt32)
  1919  		v5 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1920  		v5.AddArg(x)
  1921  		v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  1922  		v6.AuxInt = int32ToAuxInt(int32(32 - c&31))
  1923  		v4.AddArg2(v5, v6)
  1924  		v0.AddArg2(v1, v4)
  1925  		v7 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1926  		v8 := b.NewValue0(v.Pos, OpLsh32x32, typ.UInt32)
  1927  		v8.AddArg2(v5, v3)
  1928  		v9 := b.NewValue0(v.Pos, OpRsh32Ux32, typ.UInt32)
  1929  		v9.AddArg2(v2, v6)
  1930  		v7.AddArg2(v8, v9)
  1931  		v.AddArg2(v0, v7)
  1932  		return true
  1933  	}
  1934  	// match: (RotateLeft64 <t> x (Const8 [c]))
  1935  	// cond: 32 < c&63 && c&63 < 64
  1936  	// result: (Int64Make <t> (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(c&31)])) (Rsh32Ux32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(32-c&31)]))) (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(c&31)])) (Rsh32Ux32 <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(32-c&31)]))))
  1937  	for {
  1938  		t := v.Type
  1939  		x := v_0
  1940  		if v_1.Op != OpConst8 {
  1941  			break
  1942  		}
  1943  		c := auxIntToInt8(v_1.AuxInt)
  1944  		if !(32 < c&63 && c&63 < 64) {
  1945  			break
  1946  		}
  1947  		v.reset(OpInt64Make)
  1948  		v.Type = t
  1949  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1950  		v1 := b.NewValue0(v.Pos, OpLsh32x32, typ.UInt32)
  1951  		v2 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1952  		v2.AddArg(x)
  1953  		v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  1954  		v3.AuxInt = int32ToAuxInt(int32(c & 31))
  1955  		v1.AddArg2(v2, v3)
  1956  		v4 := b.NewValue0(v.Pos, OpRsh32Ux32, typ.UInt32)
  1957  		v5 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1958  		v5.AddArg(x)
  1959  		v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  1960  		v6.AuxInt = int32ToAuxInt(int32(32 - c&31))
  1961  		v4.AddArg2(v5, v6)
  1962  		v0.AddArg2(v1, v4)
  1963  		v7 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1964  		v8 := b.NewValue0(v.Pos, OpLsh32x32, typ.UInt32)
  1965  		v8.AddArg2(v5, v3)
  1966  		v9 := b.NewValue0(v.Pos, OpRsh32Ux32, typ.UInt32)
  1967  		v9.AddArg2(v2, v6)
  1968  		v7.AddArg2(v8, v9)
  1969  		v.AddArg2(v0, v7)
  1970  		return true
  1971  	}
  1972  	return false
  1973  }
  1974  func rewriteValuedec64_OpRotateLeft8(v *Value) bool {
  1975  	v_1 := v.Args[1]
  1976  	v_0 := v.Args[0]
  1977  	// match: (RotateLeft8 x (Int64Make hi lo))
  1978  	// result: (RotateLeft8 x lo)
  1979  	for {
  1980  		x := v_0
  1981  		if v_1.Op != OpInt64Make {
  1982  			break
  1983  		}
  1984  		lo := v_1.Args[1]
  1985  		v.reset(OpRotateLeft8)
  1986  		v.AddArg2(x, lo)
  1987  		return true
  1988  	}
  1989  	return false
  1990  }
  1991  func rewriteValuedec64_OpRsh16Ux64(v *Value) bool {
  1992  	v_1 := v.Args[1]
  1993  	v_0 := v.Args[0]
  1994  	b := v.Block
  1995  	typ := &b.Func.Config.Types
  1996  	// match: (Rsh16Ux64 _ (Int64Make (Const32 [c]) _))
  1997  	// cond: c != 0
  1998  	// result: (Const32 [0])
  1999  	for {
  2000  		if v_1.Op != OpInt64Make {
  2001  			break
  2002  		}
  2003  		v_1_0 := v_1.Args[0]
  2004  		if v_1_0.Op != OpConst32 {
  2005  			break
  2006  		}
  2007  		c := auxIntToInt32(v_1_0.AuxInt)
  2008  		if !(c != 0) {
  2009  			break
  2010  		}
  2011  		v.reset(OpConst32)
  2012  		v.AuxInt = int32ToAuxInt(0)
  2013  		return true
  2014  	}
  2015  	// match: (Rsh16Ux64 [c] x (Int64Make (Const32 [0]) lo))
  2016  	// result: (Rsh16Ux32 [c] x lo)
  2017  	for {
  2018  		c := auxIntToBool(v.AuxInt)
  2019  		x := v_0
  2020  		if v_1.Op != OpInt64Make {
  2021  			break
  2022  		}
  2023  		lo := v_1.Args[1]
  2024  		v_1_0 := v_1.Args[0]
  2025  		if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 {
  2026  			break
  2027  		}
  2028  		v.reset(OpRsh16Ux32)
  2029  		v.AuxInt = boolToAuxInt(c)
  2030  		v.AddArg2(x, lo)
  2031  		return true
  2032  	}
  2033  	// match: (Rsh16Ux64 x (Int64Make hi lo))
  2034  	// cond: hi.Op != OpConst32
  2035  	// result: (Rsh16Ux32 x (Or32 <typ.UInt32> (Zeromask hi) lo))
  2036  	for {
  2037  		x := v_0
  2038  		if v_1.Op != OpInt64Make {
  2039  			break
  2040  		}
  2041  		lo := v_1.Args[1]
  2042  		hi := v_1.Args[0]
  2043  		if !(hi.Op != OpConst32) {
  2044  			break
  2045  		}
  2046  		v.reset(OpRsh16Ux32)
  2047  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2048  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  2049  		v1.AddArg(hi)
  2050  		v0.AddArg2(v1, lo)
  2051  		v.AddArg2(x, v0)
  2052  		return true
  2053  	}
  2054  	// match: (Rsh16Ux64 x y)
  2055  	// result: (Rsh16Ux32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))
  2056  	for {
  2057  		x := v_0
  2058  		y := v_1
  2059  		v.reset(OpRsh16Ux32)
  2060  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2061  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  2062  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  2063  		v2.AddArg(y)
  2064  		v1.AddArg(v2)
  2065  		v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  2066  		v3.AddArg(y)
  2067  		v0.AddArg2(v1, v3)
  2068  		v.AddArg2(x, v0)
  2069  		return true
  2070  	}
  2071  }
  2072  func rewriteValuedec64_OpRsh16x64(v *Value) bool {
  2073  	v_1 := v.Args[1]
  2074  	v_0 := v.Args[0]
  2075  	b := v.Block
  2076  	typ := &b.Func.Config.Types
  2077  	// match: (Rsh16x64 x (Int64Make (Const32 [c]) _))
  2078  	// cond: c != 0
  2079  	// result: (Signmask (SignExt16to32 x))
  2080  	for {
  2081  		x := v_0
  2082  		if v_1.Op != OpInt64Make {
  2083  			break
  2084  		}
  2085  		v_1_0 := v_1.Args[0]
  2086  		if v_1_0.Op != OpConst32 {
  2087  			break
  2088  		}
  2089  		c := auxIntToInt32(v_1_0.AuxInt)
  2090  		if !(c != 0) {
  2091  			break
  2092  		}
  2093  		v.reset(OpSignmask)
  2094  		v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
  2095  		v0.AddArg(x)
  2096  		v.AddArg(v0)
  2097  		return true
  2098  	}
  2099  	// match: (Rsh16x64 [c] x (Int64Make (Const32 [0]) lo))
  2100  	// result: (Rsh16x32 [c] x lo)
  2101  	for {
  2102  		c := auxIntToBool(v.AuxInt)
  2103  		x := v_0
  2104  		if v_1.Op != OpInt64Make {
  2105  			break
  2106  		}
  2107  		lo := v_1.Args[1]
  2108  		v_1_0 := v_1.Args[0]
  2109  		if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 {
  2110  			break
  2111  		}
  2112  		v.reset(OpRsh16x32)
  2113  		v.AuxInt = boolToAuxInt(c)
  2114  		v.AddArg2(x, lo)
  2115  		return true
  2116  	}
  2117  	// match: (Rsh16x64 x (Int64Make hi lo))
  2118  	// cond: hi.Op != OpConst32
  2119  	// result: (Rsh16x32 x (Or32 <typ.UInt32> (Zeromask hi) lo))
  2120  	for {
  2121  		x := v_0
  2122  		if v_1.Op != OpInt64Make {
  2123  			break
  2124  		}
  2125  		lo := v_1.Args[1]
  2126  		hi := v_1.Args[0]
  2127  		if !(hi.Op != OpConst32) {
  2128  			break
  2129  		}
  2130  		v.reset(OpRsh16x32)
  2131  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2132  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  2133  		v1.AddArg(hi)
  2134  		v0.AddArg2(v1, lo)
  2135  		v.AddArg2(x, v0)
  2136  		return true
  2137  	}
  2138  	// match: (Rsh16x64 x y)
  2139  	// result: (Rsh16x32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))
  2140  	for {
  2141  		x := v_0
  2142  		y := v_1
  2143  		v.reset(OpRsh16x32)
  2144  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2145  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  2146  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  2147  		v2.AddArg(y)
  2148  		v1.AddArg(v2)
  2149  		v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  2150  		v3.AddArg(y)
  2151  		v0.AddArg2(v1, v3)
  2152  		v.AddArg2(x, v0)
  2153  		return true
  2154  	}
  2155  }
  2156  func rewriteValuedec64_OpRsh32Ux64(v *Value) bool {
  2157  	v_1 := v.Args[1]
  2158  	v_0 := v.Args[0]
  2159  	b := v.Block
  2160  	typ := &b.Func.Config.Types
  2161  	// match: (Rsh32Ux64 _ (Int64Make (Const32 [c]) _))
  2162  	// cond: c != 0
  2163  	// result: (Const32 [0])
  2164  	for {
  2165  		if v_1.Op != OpInt64Make {
  2166  			break
  2167  		}
  2168  		v_1_0 := v_1.Args[0]
  2169  		if v_1_0.Op != OpConst32 {
  2170  			break
  2171  		}
  2172  		c := auxIntToInt32(v_1_0.AuxInt)
  2173  		if !(c != 0) {
  2174  			break
  2175  		}
  2176  		v.reset(OpConst32)
  2177  		v.AuxInt = int32ToAuxInt(0)
  2178  		return true
  2179  	}
  2180  	// match: (Rsh32Ux64 [c] x (Int64Make (Const32 [0]) lo))
  2181  	// result: (Rsh32Ux32 [c] x lo)
  2182  	for {
  2183  		c := auxIntToBool(v.AuxInt)
  2184  		x := v_0
  2185  		if v_1.Op != OpInt64Make {
  2186  			break
  2187  		}
  2188  		lo := v_1.Args[1]
  2189  		v_1_0 := v_1.Args[0]
  2190  		if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 {
  2191  			break
  2192  		}
  2193  		v.reset(OpRsh32Ux32)
  2194  		v.AuxInt = boolToAuxInt(c)
  2195  		v.AddArg2(x, lo)
  2196  		return true
  2197  	}
  2198  	// match: (Rsh32Ux64 x (Int64Make hi lo))
  2199  	// cond: hi.Op != OpConst32
  2200  	// result: (Rsh32Ux32 x (Or32 <typ.UInt32> (Zeromask hi) lo))
  2201  	for {
  2202  		x := v_0
  2203  		if v_1.Op != OpInt64Make {
  2204  			break
  2205  		}
  2206  		lo := v_1.Args[1]
  2207  		hi := v_1.Args[0]
  2208  		if !(hi.Op != OpConst32) {
  2209  			break
  2210  		}
  2211  		v.reset(OpRsh32Ux32)
  2212  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2213  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  2214  		v1.AddArg(hi)
  2215  		v0.AddArg2(v1, lo)
  2216  		v.AddArg2(x, v0)
  2217  		return true
  2218  	}
  2219  	// match: (Rsh32Ux64 x y)
  2220  	// result: (Rsh32Ux32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))
  2221  	for {
  2222  		x := v_0
  2223  		y := v_1
  2224  		v.reset(OpRsh32Ux32)
  2225  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2226  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  2227  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  2228  		v2.AddArg(y)
  2229  		v1.AddArg(v2)
  2230  		v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  2231  		v3.AddArg(y)
  2232  		v0.AddArg2(v1, v3)
  2233  		v.AddArg2(x, v0)
  2234  		return true
  2235  	}
  2236  }
  2237  func rewriteValuedec64_OpRsh32x64(v *Value) bool {
  2238  	v_1 := v.Args[1]
  2239  	v_0 := v.Args[0]
  2240  	b := v.Block
  2241  	typ := &b.Func.Config.Types
  2242  	// match: (Rsh32x64 x (Int64Make (Const32 [c]) _))
  2243  	// cond: c != 0
  2244  	// result: (Signmask x)
  2245  	for {
  2246  		x := v_0
  2247  		if v_1.Op != OpInt64Make {
  2248  			break
  2249  		}
  2250  		v_1_0 := v_1.Args[0]
  2251  		if v_1_0.Op != OpConst32 {
  2252  			break
  2253  		}
  2254  		c := auxIntToInt32(v_1_0.AuxInt)
  2255  		if !(c != 0) {
  2256  			break
  2257  		}
  2258  		v.reset(OpSignmask)
  2259  		v.AddArg(x)
  2260  		return true
  2261  	}
  2262  	// match: (Rsh32x64 [c] x (Int64Make (Const32 [0]) lo))
  2263  	// result: (Rsh32x32 [c] x lo)
  2264  	for {
  2265  		c := auxIntToBool(v.AuxInt)
  2266  		x := v_0
  2267  		if v_1.Op != OpInt64Make {
  2268  			break
  2269  		}
  2270  		lo := v_1.Args[1]
  2271  		v_1_0 := v_1.Args[0]
  2272  		if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 {
  2273  			break
  2274  		}
  2275  		v.reset(OpRsh32x32)
  2276  		v.AuxInt = boolToAuxInt(c)
  2277  		v.AddArg2(x, lo)
  2278  		return true
  2279  	}
  2280  	// match: (Rsh32x64 x (Int64Make hi lo))
  2281  	// cond: hi.Op != OpConst32
  2282  	// result: (Rsh32x32 x (Or32 <typ.UInt32> (Zeromask hi) lo))
  2283  	for {
  2284  		x := v_0
  2285  		if v_1.Op != OpInt64Make {
  2286  			break
  2287  		}
  2288  		lo := v_1.Args[1]
  2289  		hi := v_1.Args[0]
  2290  		if !(hi.Op != OpConst32) {
  2291  			break
  2292  		}
  2293  		v.reset(OpRsh32x32)
  2294  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2295  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  2296  		v1.AddArg(hi)
  2297  		v0.AddArg2(v1, lo)
  2298  		v.AddArg2(x, v0)
  2299  		return true
  2300  	}
  2301  	// match: (Rsh32x64 x y)
  2302  	// result: (Rsh32x32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))
  2303  	for {
  2304  		x := v_0
  2305  		y := v_1
  2306  		v.reset(OpRsh32x32)
  2307  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2308  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  2309  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  2310  		v2.AddArg(y)
  2311  		v1.AddArg(v2)
  2312  		v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  2313  		v3.AddArg(y)
  2314  		v0.AddArg2(v1, v3)
  2315  		v.AddArg2(x, v0)
  2316  		return true
  2317  	}
  2318  }
  2319  func rewriteValuedec64_OpRsh64Ux16(v *Value) bool {
  2320  	v_1 := v.Args[1]
  2321  	v_0 := v.Args[0]
  2322  	b := v.Block
  2323  	typ := &b.Func.Config.Types
  2324  	// match: (Rsh64Ux16 x s)
  2325  	// result: (Int64Make (Rsh32Ux16 <typ.UInt32> (Int64Hi x) s) (Or32 <typ.UInt32> (Or32 <typ.UInt32> (Rsh32Ux16 <typ.UInt32> (Int64Lo x) s) (Lsh32x16 <typ.UInt32> (Int64Hi x) (Sub16 <typ.UInt16> (Const16 <typ.UInt16> [32]) s))) (Rsh32Ux16 <typ.UInt32> (Int64Hi x) (Sub16 <typ.UInt16> s (Const16 <typ.UInt16> [32])))))
  2326  	for {
  2327  		x := v_0
  2328  		s := v_1
  2329  		v.reset(OpInt64Make)
  2330  		v0 := b.NewValue0(v.Pos, OpRsh32Ux16, typ.UInt32)
  2331  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  2332  		v1.AddArg(x)
  2333  		v0.AddArg2(v1, s)
  2334  		v2 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2335  		v3 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2336  		v4 := b.NewValue0(v.Pos, OpRsh32Ux16, typ.UInt32)
  2337  		v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  2338  		v5.AddArg(x)
  2339  		v4.AddArg2(v5, s)
  2340  		v6 := b.NewValue0(v.Pos, OpLsh32x16, typ.UInt32)
  2341  		v7 := b.NewValue0(v.Pos, OpSub16, typ.UInt16)
  2342  		v8 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  2343  		v8.AuxInt = int16ToAuxInt(32)
  2344  		v7.AddArg2(v8, s)
  2345  		v6.AddArg2(v1, v7)
  2346  		v3.AddArg2(v4, v6)
  2347  		v9 := b.NewValue0(v.Pos, OpRsh32Ux16, typ.UInt32)
  2348  		v10 := b.NewValue0(v.Pos, OpSub16, typ.UInt16)
  2349  		v10.AddArg2(s, v8)
  2350  		v9.AddArg2(v1, v10)
  2351  		v2.AddArg2(v3, v9)
  2352  		v.AddArg2(v0, v2)
  2353  		return true
  2354  	}
  2355  }
  2356  func rewriteValuedec64_OpRsh64Ux32(v *Value) bool {
  2357  	v_1 := v.Args[1]
  2358  	v_0 := v.Args[0]
  2359  	b := v.Block
  2360  	typ := &b.Func.Config.Types
  2361  	// match: (Rsh64Ux32 x s)
  2362  	// result: (Int64Make (Rsh32Ux32 <typ.UInt32> (Int64Hi x) s) (Or32 <typ.UInt32> (Or32 <typ.UInt32> (Rsh32Ux32 <typ.UInt32> (Int64Lo x) s) (Lsh32x32 <typ.UInt32> (Int64Hi x) (Sub32 <typ.UInt32> (Const32 <typ.UInt32> [32]) s))) (Rsh32Ux32 <typ.UInt32> (Int64Hi x) (Sub32 <typ.UInt32> s (Const32 <typ.UInt32> [32])))))
  2363  	for {
  2364  		x := v_0
  2365  		s := v_1
  2366  		v.reset(OpInt64Make)
  2367  		v0 := b.NewValue0(v.Pos, OpRsh32Ux32, typ.UInt32)
  2368  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  2369  		v1.AddArg(x)
  2370  		v0.AddArg2(v1, s)
  2371  		v2 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2372  		v3 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2373  		v4 := b.NewValue0(v.Pos, OpRsh32Ux32, typ.UInt32)
  2374  		v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  2375  		v5.AddArg(x)
  2376  		v4.AddArg2(v5, s)
  2377  		v6 := b.NewValue0(v.Pos, OpLsh32x32, typ.UInt32)
  2378  		v7 := b.NewValue0(v.Pos, OpSub32, typ.UInt32)
  2379  		v8 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  2380  		v8.AuxInt = int32ToAuxInt(32)
  2381  		v7.AddArg2(v8, s)
  2382  		v6.AddArg2(v1, v7)
  2383  		v3.AddArg2(v4, v6)
  2384  		v9 := b.NewValue0(v.Pos, OpRsh32Ux32, typ.UInt32)
  2385  		v10 := b.NewValue0(v.Pos, OpSub32, typ.UInt32)
  2386  		v10.AddArg2(s, v8)
  2387  		v9.AddArg2(v1, v10)
  2388  		v2.AddArg2(v3, v9)
  2389  		v.AddArg2(v0, v2)
  2390  		return true
  2391  	}
  2392  }
  2393  func rewriteValuedec64_OpRsh64Ux64(v *Value) bool {
  2394  	v_1 := v.Args[1]
  2395  	v_0 := v.Args[0]
  2396  	b := v.Block
  2397  	typ := &b.Func.Config.Types
  2398  	// match: (Rsh64Ux64 _ (Int64Make (Const32 [c]) _))
  2399  	// cond: c != 0
  2400  	// result: (Const64 [0])
  2401  	for {
  2402  		if v_1.Op != OpInt64Make {
  2403  			break
  2404  		}
  2405  		v_1_0 := v_1.Args[0]
  2406  		if v_1_0.Op != OpConst32 {
  2407  			break
  2408  		}
  2409  		c := auxIntToInt32(v_1_0.AuxInt)
  2410  		if !(c != 0) {
  2411  			break
  2412  		}
  2413  		v.reset(OpConst64)
  2414  		v.AuxInt = int64ToAuxInt(0)
  2415  		return true
  2416  	}
  2417  	// match: (Rsh64Ux64 [c] x (Int64Make (Const32 [0]) lo))
  2418  	// result: (Rsh64Ux32 [c] x lo)
  2419  	for {
  2420  		c := auxIntToBool(v.AuxInt)
  2421  		x := v_0
  2422  		if v_1.Op != OpInt64Make {
  2423  			break
  2424  		}
  2425  		lo := v_1.Args[1]
  2426  		v_1_0 := v_1.Args[0]
  2427  		if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 {
  2428  			break
  2429  		}
  2430  		v.reset(OpRsh64Ux32)
  2431  		v.AuxInt = boolToAuxInt(c)
  2432  		v.AddArg2(x, lo)
  2433  		return true
  2434  	}
  2435  	// match: (Rsh64Ux64 x (Int64Make hi lo))
  2436  	// cond: hi.Op != OpConst32
  2437  	// result: (Rsh64Ux32 x (Or32 <typ.UInt32> (Zeromask hi) lo))
  2438  	for {
  2439  		x := v_0
  2440  		if v_1.Op != OpInt64Make {
  2441  			break
  2442  		}
  2443  		lo := v_1.Args[1]
  2444  		hi := v_1.Args[0]
  2445  		if !(hi.Op != OpConst32) {
  2446  			break
  2447  		}
  2448  		v.reset(OpRsh64Ux32)
  2449  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2450  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  2451  		v1.AddArg(hi)
  2452  		v0.AddArg2(v1, lo)
  2453  		v.AddArg2(x, v0)
  2454  		return true
  2455  	}
  2456  	// match: (Rsh64Ux64 x y)
  2457  	// result: (Rsh64Ux32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))
  2458  	for {
  2459  		x := v_0
  2460  		y := v_1
  2461  		v.reset(OpRsh64Ux32)
  2462  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2463  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  2464  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  2465  		v2.AddArg(y)
  2466  		v1.AddArg(v2)
  2467  		v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  2468  		v3.AddArg(y)
  2469  		v0.AddArg2(v1, v3)
  2470  		v.AddArg2(x, v0)
  2471  		return true
  2472  	}
  2473  }
  2474  func rewriteValuedec64_OpRsh64Ux8(v *Value) bool {
  2475  	v_1 := v.Args[1]
  2476  	v_0 := v.Args[0]
  2477  	b := v.Block
  2478  	typ := &b.Func.Config.Types
  2479  	// match: (Rsh64Ux8 x s)
  2480  	// result: (Int64Make (Rsh32Ux8 <typ.UInt32> (Int64Hi x) s) (Or32 <typ.UInt32> (Or32 <typ.UInt32> (Rsh32Ux8 <typ.UInt32> (Int64Lo x) s) (Lsh32x8 <typ.UInt32> (Int64Hi x) (Sub8 <typ.UInt8> (Const8 <typ.UInt8> [32]) s))) (Rsh32Ux8 <typ.UInt32> (Int64Hi x) (Sub8 <typ.UInt8> s (Const8 <typ.UInt8> [32])))))
  2481  	for {
  2482  		x := v_0
  2483  		s := v_1
  2484  		v.reset(OpInt64Make)
  2485  		v0 := b.NewValue0(v.Pos, OpRsh32Ux8, typ.UInt32)
  2486  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  2487  		v1.AddArg(x)
  2488  		v0.AddArg2(v1, s)
  2489  		v2 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2490  		v3 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2491  		v4 := b.NewValue0(v.Pos, OpRsh32Ux8, typ.UInt32)
  2492  		v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  2493  		v5.AddArg(x)
  2494  		v4.AddArg2(v5, s)
  2495  		v6 := b.NewValue0(v.Pos, OpLsh32x8, typ.UInt32)
  2496  		v7 := b.NewValue0(v.Pos, OpSub8, typ.UInt8)
  2497  		v8 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
  2498  		v8.AuxInt = int8ToAuxInt(32)
  2499  		v7.AddArg2(v8, s)
  2500  		v6.AddArg2(v1, v7)
  2501  		v3.AddArg2(v4, v6)
  2502  		v9 := b.NewValue0(v.Pos, OpRsh32Ux8, typ.UInt32)
  2503  		v10 := b.NewValue0(v.Pos, OpSub8, typ.UInt8)
  2504  		v10.AddArg2(s, v8)
  2505  		v9.AddArg2(v1, v10)
  2506  		v2.AddArg2(v3, v9)
  2507  		v.AddArg2(v0, v2)
  2508  		return true
  2509  	}
  2510  }
  2511  func rewriteValuedec64_OpRsh64x16(v *Value) bool {
  2512  	v_1 := v.Args[1]
  2513  	v_0 := v.Args[0]
  2514  	b := v.Block
  2515  	typ := &b.Func.Config.Types
  2516  	// match: (Rsh64x16 x s)
  2517  	// result: (Int64Make (Rsh32x16 <typ.UInt32> (Int64Hi x) s) (Or32 <typ.UInt32> (Or32 <typ.UInt32> (Rsh32Ux16 <typ.UInt32> (Int64Lo x) s) (Lsh32x16 <typ.UInt32> (Int64Hi x) (Sub16 <typ.UInt16> (Const16 <typ.UInt16> [32]) s))) (And32 <typ.UInt32> (Rsh32x16 <typ.UInt32> (Int64Hi x) (Sub16 <typ.UInt16> s (Const16 <typ.UInt16> [32]))) (Zeromask (ZeroExt16to32 (Rsh16Ux32 <typ.UInt16> s (Const32 <typ.UInt32> [5])))))))
  2518  	for {
  2519  		x := v_0
  2520  		s := v_1
  2521  		v.reset(OpInt64Make)
  2522  		v0 := b.NewValue0(v.Pos, OpRsh32x16, typ.UInt32)
  2523  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  2524  		v1.AddArg(x)
  2525  		v0.AddArg2(v1, s)
  2526  		v2 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2527  		v3 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2528  		v4 := b.NewValue0(v.Pos, OpRsh32Ux16, typ.UInt32)
  2529  		v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  2530  		v5.AddArg(x)
  2531  		v4.AddArg2(v5, s)
  2532  		v6 := b.NewValue0(v.Pos, OpLsh32x16, typ.UInt32)
  2533  		v7 := b.NewValue0(v.Pos, OpSub16, typ.UInt16)
  2534  		v8 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  2535  		v8.AuxInt = int16ToAuxInt(32)
  2536  		v7.AddArg2(v8, s)
  2537  		v6.AddArg2(v1, v7)
  2538  		v3.AddArg2(v4, v6)
  2539  		v9 := b.NewValue0(v.Pos, OpAnd32, typ.UInt32)
  2540  		v10 := b.NewValue0(v.Pos, OpRsh32x16, typ.UInt32)
  2541  		v11 := b.NewValue0(v.Pos, OpSub16, typ.UInt16)
  2542  		v11.AddArg2(s, v8)
  2543  		v10.AddArg2(v1, v11)
  2544  		v12 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  2545  		v13 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
  2546  		v14 := b.NewValue0(v.Pos, OpRsh16Ux32, typ.UInt16)
  2547  		v15 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  2548  		v15.AuxInt = int32ToAuxInt(5)
  2549  		v14.AddArg2(s, v15)
  2550  		v13.AddArg(v14)
  2551  		v12.AddArg(v13)
  2552  		v9.AddArg2(v10, v12)
  2553  		v2.AddArg2(v3, v9)
  2554  		v.AddArg2(v0, v2)
  2555  		return true
  2556  	}
  2557  }
  2558  func rewriteValuedec64_OpRsh64x32(v *Value) bool {
  2559  	v_1 := v.Args[1]
  2560  	v_0 := v.Args[0]
  2561  	b := v.Block
  2562  	typ := &b.Func.Config.Types
  2563  	// match: (Rsh64x32 x s)
  2564  	// result: (Int64Make (Rsh32x32 <typ.UInt32> (Int64Hi x) s) (Or32 <typ.UInt32> (Or32 <typ.UInt32> (Rsh32Ux32 <typ.UInt32> (Int64Lo x) s) (Lsh32x32 <typ.UInt32> (Int64Hi x) (Sub32 <typ.UInt32> (Const32 <typ.UInt32> [32]) s))) (And32 <typ.UInt32> (Rsh32x32 <typ.UInt32> (Int64Hi x) (Sub32 <typ.UInt32> s (Const32 <typ.UInt32> [32]))) (Zeromask (Rsh32Ux32 <typ.UInt32> s (Const32 <typ.UInt32> [5]))))))
  2565  	for {
  2566  		x := v_0
  2567  		s := v_1
  2568  		v.reset(OpInt64Make)
  2569  		v0 := b.NewValue0(v.Pos, OpRsh32x32, typ.UInt32)
  2570  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  2571  		v1.AddArg(x)
  2572  		v0.AddArg2(v1, s)
  2573  		v2 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2574  		v3 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2575  		v4 := b.NewValue0(v.Pos, OpRsh32Ux32, typ.UInt32)
  2576  		v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  2577  		v5.AddArg(x)
  2578  		v4.AddArg2(v5, s)
  2579  		v6 := b.NewValue0(v.Pos, OpLsh32x32, typ.UInt32)
  2580  		v7 := b.NewValue0(v.Pos, OpSub32, typ.UInt32)
  2581  		v8 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  2582  		v8.AuxInt = int32ToAuxInt(32)
  2583  		v7.AddArg2(v8, s)
  2584  		v6.AddArg2(v1, v7)
  2585  		v3.AddArg2(v4, v6)
  2586  		v9 := b.NewValue0(v.Pos, OpAnd32, typ.UInt32)
  2587  		v10 := b.NewValue0(v.Pos, OpRsh32x32, typ.UInt32)
  2588  		v11 := b.NewValue0(v.Pos, OpSub32, typ.UInt32)
  2589  		v11.AddArg2(s, v8)
  2590  		v10.AddArg2(v1, v11)
  2591  		v12 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  2592  		v13 := b.NewValue0(v.Pos, OpRsh32Ux32, typ.UInt32)
  2593  		v14 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  2594  		v14.AuxInt = int32ToAuxInt(5)
  2595  		v13.AddArg2(s, v14)
  2596  		v12.AddArg(v13)
  2597  		v9.AddArg2(v10, v12)
  2598  		v2.AddArg2(v3, v9)
  2599  		v.AddArg2(v0, v2)
  2600  		return true
  2601  	}
  2602  }
  2603  func rewriteValuedec64_OpRsh64x64(v *Value) bool {
  2604  	v_1 := v.Args[1]
  2605  	v_0 := v.Args[0]
  2606  	b := v.Block
  2607  	typ := &b.Func.Config.Types
  2608  	// match: (Rsh64x64 x (Int64Make (Const32 [c]) _))
  2609  	// cond: c != 0
  2610  	// result: (Int64Make (Signmask (Int64Hi x)) (Signmask (Int64Hi x)))
  2611  	for {
  2612  		x := v_0
  2613  		if v_1.Op != OpInt64Make {
  2614  			break
  2615  		}
  2616  		v_1_0 := v_1.Args[0]
  2617  		if v_1_0.Op != OpConst32 {
  2618  			break
  2619  		}
  2620  		c := auxIntToInt32(v_1_0.AuxInt)
  2621  		if !(c != 0) {
  2622  			break
  2623  		}
  2624  		v.reset(OpInt64Make)
  2625  		v0 := b.NewValue0(v.Pos, OpSignmask, typ.Int32)
  2626  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  2627  		v1.AddArg(x)
  2628  		v0.AddArg(v1)
  2629  		v.AddArg2(v0, v0)
  2630  		return true
  2631  	}
  2632  	// match: (Rsh64x64 [c] x (Int64Make (Const32 [0]) lo))
  2633  	// result: (Rsh64x32 [c] x lo)
  2634  	for {
  2635  		c := auxIntToBool(v.AuxInt)
  2636  		x := v_0
  2637  		if v_1.Op != OpInt64Make {
  2638  			break
  2639  		}
  2640  		lo := v_1.Args[1]
  2641  		v_1_0 := v_1.Args[0]
  2642  		if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 {
  2643  			break
  2644  		}
  2645  		v.reset(OpRsh64x32)
  2646  		v.AuxInt = boolToAuxInt(c)
  2647  		v.AddArg2(x, lo)
  2648  		return true
  2649  	}
  2650  	// match: (Rsh64x64 x (Int64Make hi lo))
  2651  	// cond: hi.Op != OpConst32
  2652  	// result: (Rsh64x32 x (Or32 <typ.UInt32> (Zeromask hi) lo))
  2653  	for {
  2654  		x := v_0
  2655  		if v_1.Op != OpInt64Make {
  2656  			break
  2657  		}
  2658  		lo := v_1.Args[1]
  2659  		hi := v_1.Args[0]
  2660  		if !(hi.Op != OpConst32) {
  2661  			break
  2662  		}
  2663  		v.reset(OpRsh64x32)
  2664  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2665  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  2666  		v1.AddArg(hi)
  2667  		v0.AddArg2(v1, lo)
  2668  		v.AddArg2(x, v0)
  2669  		return true
  2670  	}
  2671  	// match: (Rsh64x64 x y)
  2672  	// result: (Rsh64x32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))
  2673  	for {
  2674  		x := v_0
  2675  		y := v_1
  2676  		v.reset(OpRsh64x32)
  2677  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2678  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  2679  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  2680  		v2.AddArg(y)
  2681  		v1.AddArg(v2)
  2682  		v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  2683  		v3.AddArg(y)
  2684  		v0.AddArg2(v1, v3)
  2685  		v.AddArg2(x, v0)
  2686  		return true
  2687  	}
  2688  }
  2689  func rewriteValuedec64_OpRsh64x8(v *Value) bool {
  2690  	v_1 := v.Args[1]
  2691  	v_0 := v.Args[0]
  2692  	b := v.Block
  2693  	typ := &b.Func.Config.Types
  2694  	// match: (Rsh64x8 x s)
  2695  	// result: (Int64Make (Rsh32x8 <typ.UInt32> (Int64Hi x) s) (Or32 <typ.UInt32> (Or32 <typ.UInt32> (Rsh32Ux8 <typ.UInt32> (Int64Lo x) s) (Lsh32x8 <typ.UInt32> (Int64Hi x) (Sub8 <typ.UInt8> (Const8 <typ.UInt8> [32]) s))) (And32 <typ.UInt32> (Rsh32x8 <typ.UInt32> (Int64Hi x) (Sub8 <typ.UInt8> s (Const8 <typ.UInt8> [32]))) (Zeromask (ZeroExt8to32 (Rsh8Ux32 <typ.UInt8> s (Const32 <typ.UInt32> [5])))))))
  2696  	for {
  2697  		x := v_0
  2698  		s := v_1
  2699  		v.reset(OpInt64Make)
  2700  		v0 := b.NewValue0(v.Pos, OpRsh32x8, typ.UInt32)
  2701  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  2702  		v1.AddArg(x)
  2703  		v0.AddArg2(v1, s)
  2704  		v2 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2705  		v3 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2706  		v4 := b.NewValue0(v.Pos, OpRsh32Ux8, typ.UInt32)
  2707  		v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  2708  		v5.AddArg(x)
  2709  		v4.AddArg2(v5, s)
  2710  		v6 := b.NewValue0(v.Pos, OpLsh32x8, typ.UInt32)
  2711  		v7 := b.NewValue0(v.Pos, OpSub8, typ.UInt8)
  2712  		v8 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
  2713  		v8.AuxInt = int8ToAuxInt(32)
  2714  		v7.AddArg2(v8, s)
  2715  		v6.AddArg2(v1, v7)
  2716  		v3.AddArg2(v4, v6)
  2717  		v9 := b.NewValue0(v.Pos, OpAnd32, typ.UInt32)
  2718  		v10 := b.NewValue0(v.Pos, OpRsh32x8, typ.UInt32)
  2719  		v11 := b.NewValue0(v.Pos, OpSub8, typ.UInt8)
  2720  		v11.AddArg2(s, v8)
  2721  		v10.AddArg2(v1, v11)
  2722  		v12 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  2723  		v13 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
  2724  		v14 := b.NewValue0(v.Pos, OpRsh8Ux32, typ.UInt8)
  2725  		v15 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  2726  		v15.AuxInt = int32ToAuxInt(5)
  2727  		v14.AddArg2(s, v15)
  2728  		v13.AddArg(v14)
  2729  		v12.AddArg(v13)
  2730  		v9.AddArg2(v10, v12)
  2731  		v2.AddArg2(v3, v9)
  2732  		v.AddArg2(v0, v2)
  2733  		return true
  2734  	}
  2735  }
  2736  func rewriteValuedec64_OpRsh8Ux64(v *Value) bool {
  2737  	v_1 := v.Args[1]
  2738  	v_0 := v.Args[0]
  2739  	b := v.Block
  2740  	typ := &b.Func.Config.Types
  2741  	// match: (Rsh8Ux64 _ (Int64Make (Const32 [c]) _))
  2742  	// cond: c != 0
  2743  	// result: (Const32 [0])
  2744  	for {
  2745  		if v_1.Op != OpInt64Make {
  2746  			break
  2747  		}
  2748  		v_1_0 := v_1.Args[0]
  2749  		if v_1_0.Op != OpConst32 {
  2750  			break
  2751  		}
  2752  		c := auxIntToInt32(v_1_0.AuxInt)
  2753  		if !(c != 0) {
  2754  			break
  2755  		}
  2756  		v.reset(OpConst32)
  2757  		v.AuxInt = int32ToAuxInt(0)
  2758  		return true
  2759  	}
  2760  	// match: (Rsh8Ux64 [c] x (Int64Make (Const32 [0]) lo))
  2761  	// result: (Rsh8Ux32 [c] x lo)
  2762  	for {
  2763  		c := auxIntToBool(v.AuxInt)
  2764  		x := v_0
  2765  		if v_1.Op != OpInt64Make {
  2766  			break
  2767  		}
  2768  		lo := v_1.Args[1]
  2769  		v_1_0 := v_1.Args[0]
  2770  		if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 {
  2771  			break
  2772  		}
  2773  		v.reset(OpRsh8Ux32)
  2774  		v.AuxInt = boolToAuxInt(c)
  2775  		v.AddArg2(x, lo)
  2776  		return true
  2777  	}
  2778  	// match: (Rsh8Ux64 x (Int64Make hi lo))
  2779  	// cond: hi.Op != OpConst32
  2780  	// result: (Rsh8Ux32 x (Or32 <typ.UInt32> (Zeromask hi) lo))
  2781  	for {
  2782  		x := v_0
  2783  		if v_1.Op != OpInt64Make {
  2784  			break
  2785  		}
  2786  		lo := v_1.Args[1]
  2787  		hi := v_1.Args[0]
  2788  		if !(hi.Op != OpConst32) {
  2789  			break
  2790  		}
  2791  		v.reset(OpRsh8Ux32)
  2792  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2793  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  2794  		v1.AddArg(hi)
  2795  		v0.AddArg2(v1, lo)
  2796  		v.AddArg2(x, v0)
  2797  		return true
  2798  	}
  2799  	// match: (Rsh8Ux64 x y)
  2800  	// result: (Rsh8Ux32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))
  2801  	for {
  2802  		x := v_0
  2803  		y := v_1
  2804  		v.reset(OpRsh8Ux32)
  2805  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2806  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  2807  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  2808  		v2.AddArg(y)
  2809  		v1.AddArg(v2)
  2810  		v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  2811  		v3.AddArg(y)
  2812  		v0.AddArg2(v1, v3)
  2813  		v.AddArg2(x, v0)
  2814  		return true
  2815  	}
  2816  }
  2817  func rewriteValuedec64_OpRsh8x64(v *Value) bool {
  2818  	v_1 := v.Args[1]
  2819  	v_0 := v.Args[0]
  2820  	b := v.Block
  2821  	typ := &b.Func.Config.Types
  2822  	// match: (Rsh8x64 x (Int64Make (Const32 [c]) _))
  2823  	// cond: c != 0
  2824  	// result: (Signmask (SignExt8to32 x))
  2825  	for {
  2826  		x := v_0
  2827  		if v_1.Op != OpInt64Make {
  2828  			break
  2829  		}
  2830  		v_1_0 := v_1.Args[0]
  2831  		if v_1_0.Op != OpConst32 {
  2832  			break
  2833  		}
  2834  		c := auxIntToInt32(v_1_0.AuxInt)
  2835  		if !(c != 0) {
  2836  			break
  2837  		}
  2838  		v.reset(OpSignmask)
  2839  		v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
  2840  		v0.AddArg(x)
  2841  		v.AddArg(v0)
  2842  		return true
  2843  	}
  2844  	// match: (Rsh8x64 [c] x (Int64Make (Const32 [0]) lo))
  2845  	// result: (Rsh8x32 [c] x lo)
  2846  	for {
  2847  		c := auxIntToBool(v.AuxInt)
  2848  		x := v_0
  2849  		if v_1.Op != OpInt64Make {
  2850  			break
  2851  		}
  2852  		lo := v_1.Args[1]
  2853  		v_1_0 := v_1.Args[0]
  2854  		if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 {
  2855  			break
  2856  		}
  2857  		v.reset(OpRsh8x32)
  2858  		v.AuxInt = boolToAuxInt(c)
  2859  		v.AddArg2(x, lo)
  2860  		return true
  2861  	}
  2862  	// match: (Rsh8x64 x (Int64Make hi lo))
  2863  	// cond: hi.Op != OpConst32
  2864  	// result: (Rsh8x32 x (Or32 <typ.UInt32> (Zeromask hi) lo))
  2865  	for {
  2866  		x := v_0
  2867  		if v_1.Op != OpInt64Make {
  2868  			break
  2869  		}
  2870  		lo := v_1.Args[1]
  2871  		hi := v_1.Args[0]
  2872  		if !(hi.Op != OpConst32) {
  2873  			break
  2874  		}
  2875  		v.reset(OpRsh8x32)
  2876  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2877  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  2878  		v1.AddArg(hi)
  2879  		v0.AddArg2(v1, lo)
  2880  		v.AddArg2(x, v0)
  2881  		return true
  2882  	}
  2883  	// match: (Rsh8x64 x y)
  2884  	// result: (Rsh8x32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))
  2885  	for {
  2886  		x := v_0
  2887  		y := v_1
  2888  		v.reset(OpRsh8x32)
  2889  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2890  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  2891  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  2892  		v2.AddArg(y)
  2893  		v1.AddArg(v2)
  2894  		v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  2895  		v3.AddArg(y)
  2896  		v0.AddArg2(v1, v3)
  2897  		v.AddArg2(x, v0)
  2898  		return true
  2899  	}
  2900  }
  2901  func rewriteValuedec64_OpSelect0(v *Value) bool {
  2902  	v_0 := v.Args[0]
  2903  	// match: (Select0 (MakeTuple x y))
  2904  	// result: x
  2905  	for {
  2906  		if v_0.Op != OpMakeTuple {
  2907  			break
  2908  		}
  2909  		x := v_0.Args[0]
  2910  		v.copyOf(x)
  2911  		return true
  2912  	}
  2913  	return false
  2914  }
  2915  func rewriteValuedec64_OpSelect1(v *Value) bool {
  2916  	v_0 := v.Args[0]
  2917  	// match: (Select1 (MakeTuple x y))
  2918  	// result: y
  2919  	for {
  2920  		if v_0.Op != OpMakeTuple {
  2921  			break
  2922  		}
  2923  		y := v_0.Args[1]
  2924  		v.copyOf(y)
  2925  		return true
  2926  	}
  2927  	return false
  2928  }
  2929  func rewriteValuedec64_OpSignExt16to64(v *Value) bool {
  2930  	v_0 := v.Args[0]
  2931  	b := v.Block
  2932  	typ := &b.Func.Config.Types
  2933  	// match: (SignExt16to64 x)
  2934  	// result: (SignExt32to64 (SignExt16to32 x))
  2935  	for {
  2936  		x := v_0
  2937  		v.reset(OpSignExt32to64)
  2938  		v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
  2939  		v0.AddArg(x)
  2940  		v.AddArg(v0)
  2941  		return true
  2942  	}
  2943  }
  2944  func rewriteValuedec64_OpSignExt32to64(v *Value) bool {
  2945  	v_0 := v.Args[0]
  2946  	b := v.Block
  2947  	typ := &b.Func.Config.Types
  2948  	// match: (SignExt32to64 x)
  2949  	// result: (Int64Make (Signmask x) x)
  2950  	for {
  2951  		x := v_0
  2952  		v.reset(OpInt64Make)
  2953  		v0 := b.NewValue0(v.Pos, OpSignmask, typ.Int32)
  2954  		v0.AddArg(x)
  2955  		v.AddArg2(v0, x)
  2956  		return true
  2957  	}
  2958  }
  2959  func rewriteValuedec64_OpSignExt8to64(v *Value) bool {
  2960  	v_0 := v.Args[0]
  2961  	b := v.Block
  2962  	typ := &b.Func.Config.Types
  2963  	// match: (SignExt8to64 x)
  2964  	// result: (SignExt32to64 (SignExt8to32 x))
  2965  	for {
  2966  		x := v_0
  2967  		v.reset(OpSignExt32to64)
  2968  		v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
  2969  		v0.AddArg(x)
  2970  		v.AddArg(v0)
  2971  		return true
  2972  	}
  2973  }
  2974  func rewriteValuedec64_OpStore(v *Value) bool {
  2975  	v_2 := v.Args[2]
  2976  	v_1 := v.Args[1]
  2977  	v_0 := v.Args[0]
  2978  	b := v.Block
  2979  	config := b.Func.Config
  2980  	// match: (Store {t} dst (Int64Make hi lo) mem)
  2981  	// cond: t.Size() == 8 && !config.BigEndian
  2982  	// result: (Store {hi.Type} (OffPtr <hi.Type.PtrTo()> [4] dst) hi (Store {lo.Type} dst lo mem))
  2983  	for {
  2984  		t := auxToType(v.Aux)
  2985  		dst := v_0
  2986  		if v_1.Op != OpInt64Make {
  2987  			break
  2988  		}
  2989  		lo := v_1.Args[1]
  2990  		hi := v_1.Args[0]
  2991  		mem := v_2
  2992  		if !(t.Size() == 8 && !config.BigEndian) {
  2993  			break
  2994  		}
  2995  		v.reset(OpStore)
  2996  		v.Aux = typeToAux(hi.Type)
  2997  		v0 := b.NewValue0(v.Pos, OpOffPtr, hi.Type.PtrTo())
  2998  		v0.AuxInt = int64ToAuxInt(4)
  2999  		v0.AddArg(dst)
  3000  		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
  3001  		v1.Aux = typeToAux(lo.Type)
  3002  		v1.AddArg3(dst, lo, mem)
  3003  		v.AddArg3(v0, hi, v1)
  3004  		return true
  3005  	}
  3006  	// match: (Store {t} dst (Int64Make hi lo) mem)
  3007  	// cond: t.Size() == 8 && config.BigEndian
  3008  	// result: (Store {lo.Type} (OffPtr <lo.Type.PtrTo()> [4] dst) lo (Store {hi.Type} dst hi mem))
  3009  	for {
  3010  		t := auxToType(v.Aux)
  3011  		dst := v_0
  3012  		if v_1.Op != OpInt64Make {
  3013  			break
  3014  		}
  3015  		lo := v_1.Args[1]
  3016  		hi := v_1.Args[0]
  3017  		mem := v_2
  3018  		if !(t.Size() == 8 && config.BigEndian) {
  3019  			break
  3020  		}
  3021  		v.reset(OpStore)
  3022  		v.Aux = typeToAux(lo.Type)
  3023  		v0 := b.NewValue0(v.Pos, OpOffPtr, lo.Type.PtrTo())
  3024  		v0.AuxInt = int64ToAuxInt(4)
  3025  		v0.AddArg(dst)
  3026  		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
  3027  		v1.Aux = typeToAux(hi.Type)
  3028  		v1.AddArg3(dst, hi, mem)
  3029  		v.AddArg3(v0, lo, v1)
  3030  		return true
  3031  	}
  3032  	return false
  3033  }
  3034  func rewriteValuedec64_OpSub64(v *Value) bool {
  3035  	v_1 := v.Args[1]
  3036  	v_0 := v.Args[0]
  3037  	b := v.Block
  3038  	typ := &b.Func.Config.Types
  3039  	// match: (Sub64 <t> x y)
  3040  	// result: (Last <t> x0: (Int64Lo x) x1: (Int64Hi x) y0: (Int64Lo y) y1: (Int64Hi y) sub: (Sub32carry x0 y0) (Int64Make (Sub32withcarry <typ.UInt32> x1 y1 (Select1 <types.TypeFlags> sub)) (Select0 <typ.UInt32> sub)))
  3041  	for {
  3042  		t := v.Type
  3043  		x := v_0
  3044  		y := v_1
  3045  		v.reset(OpLast)
  3046  		v.Type = t
  3047  		x0 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  3048  		x0.AddArg(x)
  3049  		x1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  3050  		x1.AddArg(x)
  3051  		y0 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  3052  		y0.AddArg(y)
  3053  		y1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  3054  		y1.AddArg(y)
  3055  		sub := b.NewValue0(v.Pos, OpSub32carry, types.NewTuple(typ.UInt32, types.TypeFlags))
  3056  		sub.AddArg2(x0, y0)
  3057  		v5 := b.NewValue0(v.Pos, OpInt64Make, typ.UInt64)
  3058  		v6 := b.NewValue0(v.Pos, OpSub32withcarry, typ.UInt32)
  3059  		v7 := b.NewValue0(v.Pos, OpSelect1, types.TypeFlags)
  3060  		v7.AddArg(sub)
  3061  		v6.AddArg3(x1, y1, v7)
  3062  		v8 := b.NewValue0(v.Pos, OpSelect0, typ.UInt32)
  3063  		v8.AddArg(sub)
  3064  		v5.AddArg2(v6, v8)
  3065  		v.AddArg6(x0, x1, y0, y1, sub, v5)
  3066  		return true
  3067  	}
  3068  }
  3069  func rewriteValuedec64_OpTrunc64to16(v *Value) bool {
  3070  	v_0 := v.Args[0]
  3071  	b := v.Block
  3072  	typ := &b.Func.Config.Types
  3073  	// match: (Trunc64to16 (Int64Make _ lo))
  3074  	// result: (Trunc32to16 lo)
  3075  	for {
  3076  		if v_0.Op != OpInt64Make {
  3077  			break
  3078  		}
  3079  		lo := v_0.Args[1]
  3080  		v.reset(OpTrunc32to16)
  3081  		v.AddArg(lo)
  3082  		return true
  3083  	}
  3084  	// match: (Trunc64to16 x)
  3085  	// result: (Trunc32to16 (Int64Lo x))
  3086  	for {
  3087  		x := v_0
  3088  		v.reset(OpTrunc32to16)
  3089  		v0 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  3090  		v0.AddArg(x)
  3091  		v.AddArg(v0)
  3092  		return true
  3093  	}
  3094  }
  3095  func rewriteValuedec64_OpTrunc64to32(v *Value) bool {
  3096  	v_0 := v.Args[0]
  3097  	// match: (Trunc64to32 (Int64Make _ lo))
  3098  	// result: lo
  3099  	for {
  3100  		if v_0.Op != OpInt64Make {
  3101  			break
  3102  		}
  3103  		lo := v_0.Args[1]
  3104  		v.copyOf(lo)
  3105  		return true
  3106  	}
  3107  	// match: (Trunc64to32 x)
  3108  	// result: (Int64Lo x)
  3109  	for {
  3110  		x := v_0
  3111  		v.reset(OpInt64Lo)
  3112  		v.AddArg(x)
  3113  		return true
  3114  	}
  3115  }
  3116  func rewriteValuedec64_OpTrunc64to8(v *Value) bool {
  3117  	v_0 := v.Args[0]
  3118  	b := v.Block
  3119  	typ := &b.Func.Config.Types
  3120  	// match: (Trunc64to8 (Int64Make _ lo))
  3121  	// result: (Trunc32to8 lo)
  3122  	for {
  3123  		if v_0.Op != OpInt64Make {
  3124  			break
  3125  		}
  3126  		lo := v_0.Args[1]
  3127  		v.reset(OpTrunc32to8)
  3128  		v.AddArg(lo)
  3129  		return true
  3130  	}
  3131  	// match: (Trunc64to8 x)
  3132  	// result: (Trunc32to8 (Int64Lo x))
  3133  	for {
  3134  		x := v_0
  3135  		v.reset(OpTrunc32to8)
  3136  		v0 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  3137  		v0.AddArg(x)
  3138  		v.AddArg(v0)
  3139  		return true
  3140  	}
  3141  }
  3142  func rewriteValuedec64_OpXor64(v *Value) bool {
  3143  	v_1 := v.Args[1]
  3144  	v_0 := v.Args[0]
  3145  	b := v.Block
  3146  	typ := &b.Func.Config.Types
  3147  	// match: (Xor64 x y)
  3148  	// result: (Int64Make (Xor32 <typ.UInt32> (Int64Hi x) (Int64Hi y)) (Xor32 <typ.UInt32> (Int64Lo x) (Int64Lo y)))
  3149  	for {
  3150  		x := v_0
  3151  		y := v_1
  3152  		v.reset(OpInt64Make)
  3153  		v0 := b.NewValue0(v.Pos, OpXor32, typ.UInt32)
  3154  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  3155  		v1.AddArg(x)
  3156  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  3157  		v2.AddArg(y)
  3158  		v0.AddArg2(v1, v2)
  3159  		v3 := b.NewValue0(v.Pos, OpXor32, typ.UInt32)
  3160  		v4 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  3161  		v4.AddArg(x)
  3162  		v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  3163  		v5.AddArg(y)
  3164  		v3.AddArg2(v4, v5)
  3165  		v.AddArg2(v0, v3)
  3166  		return true
  3167  	}
  3168  }
  3169  func rewriteValuedec64_OpZeroExt16to64(v *Value) bool {
  3170  	v_0 := v.Args[0]
  3171  	b := v.Block
  3172  	typ := &b.Func.Config.Types
  3173  	// match: (ZeroExt16to64 x)
  3174  	// result: (ZeroExt32to64 (ZeroExt16to32 x))
  3175  	for {
  3176  		x := v_0
  3177  		v.reset(OpZeroExt32to64)
  3178  		v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
  3179  		v0.AddArg(x)
  3180  		v.AddArg(v0)
  3181  		return true
  3182  	}
  3183  }
  3184  func rewriteValuedec64_OpZeroExt32to64(v *Value) bool {
  3185  	v_0 := v.Args[0]
  3186  	b := v.Block
  3187  	typ := &b.Func.Config.Types
  3188  	// match: (ZeroExt32to64 x)
  3189  	// result: (Int64Make (Const32 <typ.UInt32> [0]) x)
  3190  	for {
  3191  		x := v_0
  3192  		v.reset(OpInt64Make)
  3193  		v0 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  3194  		v0.AuxInt = int32ToAuxInt(0)
  3195  		v.AddArg2(v0, x)
  3196  		return true
  3197  	}
  3198  }
  3199  func rewriteValuedec64_OpZeroExt8to64(v *Value) bool {
  3200  	v_0 := v.Args[0]
  3201  	b := v.Block
  3202  	typ := &b.Func.Config.Types
  3203  	// match: (ZeroExt8to64 x)
  3204  	// result: (ZeroExt32to64 (ZeroExt8to32 x))
  3205  	for {
  3206  		x := v_0
  3207  		v.reset(OpZeroExt32to64)
  3208  		v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
  3209  		v0.AddArg(x)
  3210  		v.AddArg(v0)
  3211  		return true
  3212  	}
  3213  }
  3214  func rewriteBlockdec64(b *Block) bool {
  3215  	return false
  3216  }
  3217  

View as plain text