github.com/euank/go@v0.0.0-20160829210321-495514729181/src/cmd/compile/internal/ssa/rewritedec64.go (about)

     1  // autogenerated from gen/dec64.rules: do not edit!
     2  // generated with: cd gen; go run *.go
     3  
     4  package ssa
     5  
     6  import "math"
     7  
     8  var _ = math.MinInt8 // in case not otherwise used
     9  func rewriteValuedec64(v *Value, config *Config) bool {
    10  	switch v.Op {
    11  	case OpAdd64:
    12  		return rewriteValuedec64_OpAdd64(v, config)
    13  	case OpAnd64:
    14  		return rewriteValuedec64_OpAnd64(v, config)
    15  	case OpArg:
    16  		return rewriteValuedec64_OpArg(v, config)
    17  	case OpCom64:
    18  		return rewriteValuedec64_OpCom64(v, config)
    19  	case OpConst64:
    20  		return rewriteValuedec64_OpConst64(v, config)
    21  	case OpEq64:
    22  		return rewriteValuedec64_OpEq64(v, config)
    23  	case OpGeq64:
    24  		return rewriteValuedec64_OpGeq64(v, config)
    25  	case OpGeq64U:
    26  		return rewriteValuedec64_OpGeq64U(v, config)
    27  	case OpGreater64:
    28  		return rewriteValuedec64_OpGreater64(v, config)
    29  	case OpGreater64U:
    30  		return rewriteValuedec64_OpGreater64U(v, config)
    31  	case OpInt64Hi:
    32  		return rewriteValuedec64_OpInt64Hi(v, config)
    33  	case OpInt64Lo:
    34  		return rewriteValuedec64_OpInt64Lo(v, config)
    35  	case OpLeq64:
    36  		return rewriteValuedec64_OpLeq64(v, config)
    37  	case OpLeq64U:
    38  		return rewriteValuedec64_OpLeq64U(v, config)
    39  	case OpLess64:
    40  		return rewriteValuedec64_OpLess64(v, config)
    41  	case OpLess64U:
    42  		return rewriteValuedec64_OpLess64U(v, config)
    43  	case OpLoad:
    44  		return rewriteValuedec64_OpLoad(v, config)
    45  	case OpLrot64:
    46  		return rewriteValuedec64_OpLrot64(v, config)
    47  	case OpLsh16x64:
    48  		return rewriteValuedec64_OpLsh16x64(v, config)
    49  	case OpLsh32x64:
    50  		return rewriteValuedec64_OpLsh32x64(v, config)
    51  	case OpLsh64x16:
    52  		return rewriteValuedec64_OpLsh64x16(v, config)
    53  	case OpLsh64x32:
    54  		return rewriteValuedec64_OpLsh64x32(v, config)
    55  	case OpLsh64x64:
    56  		return rewriteValuedec64_OpLsh64x64(v, config)
    57  	case OpLsh64x8:
    58  		return rewriteValuedec64_OpLsh64x8(v, config)
    59  	case OpLsh8x64:
    60  		return rewriteValuedec64_OpLsh8x64(v, config)
    61  	case OpMul64:
    62  		return rewriteValuedec64_OpMul64(v, config)
    63  	case OpNeg64:
    64  		return rewriteValuedec64_OpNeg64(v, config)
    65  	case OpNeq64:
    66  		return rewriteValuedec64_OpNeq64(v, config)
    67  	case OpOr64:
    68  		return rewriteValuedec64_OpOr64(v, config)
    69  	case OpRsh16Ux64:
    70  		return rewriteValuedec64_OpRsh16Ux64(v, config)
    71  	case OpRsh16x64:
    72  		return rewriteValuedec64_OpRsh16x64(v, config)
    73  	case OpRsh32Ux64:
    74  		return rewriteValuedec64_OpRsh32Ux64(v, config)
    75  	case OpRsh32x64:
    76  		return rewriteValuedec64_OpRsh32x64(v, config)
    77  	case OpRsh64Ux16:
    78  		return rewriteValuedec64_OpRsh64Ux16(v, config)
    79  	case OpRsh64Ux32:
    80  		return rewriteValuedec64_OpRsh64Ux32(v, config)
    81  	case OpRsh64Ux64:
    82  		return rewriteValuedec64_OpRsh64Ux64(v, config)
    83  	case OpRsh64Ux8:
    84  		return rewriteValuedec64_OpRsh64Ux8(v, config)
    85  	case OpRsh64x16:
    86  		return rewriteValuedec64_OpRsh64x16(v, config)
    87  	case OpRsh64x32:
    88  		return rewriteValuedec64_OpRsh64x32(v, config)
    89  	case OpRsh64x64:
    90  		return rewriteValuedec64_OpRsh64x64(v, config)
    91  	case OpRsh64x8:
    92  		return rewriteValuedec64_OpRsh64x8(v, config)
    93  	case OpRsh8Ux64:
    94  		return rewriteValuedec64_OpRsh8Ux64(v, config)
    95  	case OpRsh8x64:
    96  		return rewriteValuedec64_OpRsh8x64(v, config)
    97  	case OpSignExt16to64:
    98  		return rewriteValuedec64_OpSignExt16to64(v, config)
    99  	case OpSignExt32to64:
   100  		return rewriteValuedec64_OpSignExt32to64(v, config)
   101  	case OpSignExt8to64:
   102  		return rewriteValuedec64_OpSignExt8to64(v, config)
   103  	case OpStore:
   104  		return rewriteValuedec64_OpStore(v, config)
   105  	case OpSub64:
   106  		return rewriteValuedec64_OpSub64(v, config)
   107  	case OpTrunc64to16:
   108  		return rewriteValuedec64_OpTrunc64to16(v, config)
   109  	case OpTrunc64to32:
   110  		return rewriteValuedec64_OpTrunc64to32(v, config)
   111  	case OpTrunc64to8:
   112  		return rewriteValuedec64_OpTrunc64to8(v, config)
   113  	case OpXor64:
   114  		return rewriteValuedec64_OpXor64(v, config)
   115  	case OpZeroExt16to64:
   116  		return rewriteValuedec64_OpZeroExt16to64(v, config)
   117  	case OpZeroExt32to64:
   118  		return rewriteValuedec64_OpZeroExt32to64(v, config)
   119  	case OpZeroExt8to64:
   120  		return rewriteValuedec64_OpZeroExt8to64(v, config)
   121  	}
   122  	return false
   123  }
   124  func rewriteValuedec64_OpAdd64(v *Value, config *Config) bool {
   125  	b := v.Block
   126  	_ = b
   127  	// match: (Add64 x y)
   128  	// cond:
   129  	// result: (Int64Make 		(Add32withcarry <config.fe.TypeInt32()> 			(Int64Hi x) 			(Int64Hi y) 			(Select1 <TypeFlags> (Add32carry (Int64Lo x) (Int64Lo y)))) 		(Select0 <config.fe.TypeUInt32()> (Add32carry (Int64Lo x) (Int64Lo y))))
   130  	for {
   131  		x := v.Args[0]
   132  		y := v.Args[1]
   133  		v.reset(OpInt64Make)
   134  		v0 := b.NewValue0(v.Line, OpAdd32withcarry, config.fe.TypeInt32())
   135  		v1 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   136  		v1.AddArg(x)
   137  		v0.AddArg(v1)
   138  		v2 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   139  		v2.AddArg(y)
   140  		v0.AddArg(v2)
   141  		v3 := b.NewValue0(v.Line, OpSelect1, TypeFlags)
   142  		v4 := b.NewValue0(v.Line, OpAdd32carry, MakeTuple(config.fe.TypeUInt32(), TypeFlags))
   143  		v5 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
   144  		v5.AddArg(x)
   145  		v4.AddArg(v5)
   146  		v6 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
   147  		v6.AddArg(y)
   148  		v4.AddArg(v6)
   149  		v3.AddArg(v4)
   150  		v0.AddArg(v3)
   151  		v.AddArg(v0)
   152  		v7 := b.NewValue0(v.Line, OpSelect0, config.fe.TypeUInt32())
   153  		v8 := b.NewValue0(v.Line, OpAdd32carry, MakeTuple(config.fe.TypeUInt32(), TypeFlags))
   154  		v9 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
   155  		v9.AddArg(x)
   156  		v8.AddArg(v9)
   157  		v10 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
   158  		v10.AddArg(y)
   159  		v8.AddArg(v10)
   160  		v7.AddArg(v8)
   161  		v.AddArg(v7)
   162  		return true
   163  	}
   164  }
   165  func rewriteValuedec64_OpAnd64(v *Value, config *Config) bool {
   166  	b := v.Block
   167  	_ = b
   168  	// match: (And64 x y)
   169  	// cond:
   170  	// result: (Int64Make 		(And32 <config.fe.TypeUInt32()> (Int64Hi x) (Int64Hi y)) 		(And32 <config.fe.TypeUInt32()> (Int64Lo x) (Int64Lo y)))
   171  	for {
   172  		x := v.Args[0]
   173  		y := v.Args[1]
   174  		v.reset(OpInt64Make)
   175  		v0 := b.NewValue0(v.Line, OpAnd32, config.fe.TypeUInt32())
   176  		v1 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   177  		v1.AddArg(x)
   178  		v0.AddArg(v1)
   179  		v2 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   180  		v2.AddArg(y)
   181  		v0.AddArg(v2)
   182  		v.AddArg(v0)
   183  		v3 := b.NewValue0(v.Line, OpAnd32, config.fe.TypeUInt32())
   184  		v4 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
   185  		v4.AddArg(x)
   186  		v3.AddArg(v4)
   187  		v5 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
   188  		v5.AddArg(y)
   189  		v3.AddArg(v5)
   190  		v.AddArg(v3)
   191  		return true
   192  	}
   193  }
   194  func rewriteValuedec64_OpArg(v *Value, config *Config) bool {
   195  	b := v.Block
   196  	_ = b
   197  	// match: (Arg {n} [off])
   198  	// cond: is64BitInt(v.Type) && v.Type.IsSigned()
   199  	// result: (Int64Make     (Arg <config.fe.TypeInt32()> {n} [off+4])     (Arg <config.fe.TypeUInt32()> {n} [off]))
   200  	for {
   201  		off := v.AuxInt
   202  		n := v.Aux
   203  		if !(is64BitInt(v.Type) && v.Type.IsSigned()) {
   204  			break
   205  		}
   206  		v.reset(OpInt64Make)
   207  		v0 := b.NewValue0(v.Line, OpArg, config.fe.TypeInt32())
   208  		v0.AuxInt = off + 4
   209  		v0.Aux = n
   210  		v.AddArg(v0)
   211  		v1 := b.NewValue0(v.Line, OpArg, config.fe.TypeUInt32())
   212  		v1.AuxInt = off
   213  		v1.Aux = n
   214  		v.AddArg(v1)
   215  		return true
   216  	}
   217  	// match: (Arg {n} [off])
   218  	// cond: is64BitInt(v.Type) && !v.Type.IsSigned()
   219  	// result: (Int64Make     (Arg <config.fe.TypeUInt32()> {n} [off+4])     (Arg <config.fe.TypeUInt32()> {n} [off]))
   220  	for {
   221  		off := v.AuxInt
   222  		n := v.Aux
   223  		if !(is64BitInt(v.Type) && !v.Type.IsSigned()) {
   224  			break
   225  		}
   226  		v.reset(OpInt64Make)
   227  		v0 := b.NewValue0(v.Line, OpArg, config.fe.TypeUInt32())
   228  		v0.AuxInt = off + 4
   229  		v0.Aux = n
   230  		v.AddArg(v0)
   231  		v1 := b.NewValue0(v.Line, OpArg, config.fe.TypeUInt32())
   232  		v1.AuxInt = off
   233  		v1.Aux = n
   234  		v.AddArg(v1)
   235  		return true
   236  	}
   237  	return false
   238  }
   239  func rewriteValuedec64_OpCom64(v *Value, config *Config) bool {
   240  	b := v.Block
   241  	_ = b
   242  	// match: (Com64 x)
   243  	// cond:
   244  	// result: (Int64Make 		(Com32 <config.fe.TypeUInt32()> (Int64Hi x)) 		(Com32 <config.fe.TypeUInt32()> (Int64Lo x)))
   245  	for {
   246  		x := v.Args[0]
   247  		v.reset(OpInt64Make)
   248  		v0 := b.NewValue0(v.Line, OpCom32, config.fe.TypeUInt32())
   249  		v1 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   250  		v1.AddArg(x)
   251  		v0.AddArg(v1)
   252  		v.AddArg(v0)
   253  		v2 := b.NewValue0(v.Line, OpCom32, config.fe.TypeUInt32())
   254  		v3 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
   255  		v3.AddArg(x)
   256  		v2.AddArg(v3)
   257  		v.AddArg(v2)
   258  		return true
   259  	}
   260  }
   261  func rewriteValuedec64_OpConst64(v *Value, config *Config) bool {
   262  	b := v.Block
   263  	_ = b
   264  	// match: (Const64 <t> [c])
   265  	// cond: t.IsSigned()
   266  	// result: (Int64Make (Const32 <config.fe.TypeInt32()> [c>>32]) (Const32 <config.fe.TypeUInt32()> [int64(int32(c))]))
   267  	for {
   268  		t := v.Type
   269  		c := v.AuxInt
   270  		if !(t.IsSigned()) {
   271  			break
   272  		}
   273  		v.reset(OpInt64Make)
   274  		v0 := b.NewValue0(v.Line, OpConst32, config.fe.TypeInt32())
   275  		v0.AuxInt = c >> 32
   276  		v.AddArg(v0)
   277  		v1 := b.NewValue0(v.Line, OpConst32, config.fe.TypeUInt32())
   278  		v1.AuxInt = int64(int32(c))
   279  		v.AddArg(v1)
   280  		return true
   281  	}
   282  	// match: (Const64 <t> [c])
   283  	// cond: !t.IsSigned()
   284  	// result: (Int64Make (Const32 <config.fe.TypeUInt32()> [c>>32]) (Const32 <config.fe.TypeUInt32()> [int64(int32(c))]))
   285  	for {
   286  		t := v.Type
   287  		c := v.AuxInt
   288  		if !(!t.IsSigned()) {
   289  			break
   290  		}
   291  		v.reset(OpInt64Make)
   292  		v0 := b.NewValue0(v.Line, OpConst32, config.fe.TypeUInt32())
   293  		v0.AuxInt = c >> 32
   294  		v.AddArg(v0)
   295  		v1 := b.NewValue0(v.Line, OpConst32, config.fe.TypeUInt32())
   296  		v1.AuxInt = int64(int32(c))
   297  		v.AddArg(v1)
   298  		return true
   299  	}
   300  	return false
   301  }
   302  func rewriteValuedec64_OpEq64(v *Value, config *Config) bool {
   303  	b := v.Block
   304  	_ = b
   305  	// match: (Eq64 x y)
   306  	// cond:
   307  	// result: (AndB 		(Eq32 (Int64Hi x) (Int64Hi y)) 		(Eq32 (Int64Lo x) (Int64Lo y)))
   308  	for {
   309  		x := v.Args[0]
   310  		y := v.Args[1]
   311  		v.reset(OpAndB)
   312  		v0 := b.NewValue0(v.Line, OpEq32, config.fe.TypeBool())
   313  		v1 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   314  		v1.AddArg(x)
   315  		v0.AddArg(v1)
   316  		v2 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   317  		v2.AddArg(y)
   318  		v0.AddArg(v2)
   319  		v.AddArg(v0)
   320  		v3 := b.NewValue0(v.Line, OpEq32, config.fe.TypeBool())
   321  		v4 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
   322  		v4.AddArg(x)
   323  		v3.AddArg(v4)
   324  		v5 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
   325  		v5.AddArg(y)
   326  		v3.AddArg(v5)
   327  		v.AddArg(v3)
   328  		return true
   329  	}
   330  }
   331  func rewriteValuedec64_OpGeq64(v *Value, config *Config) bool {
   332  	b := v.Block
   333  	_ = b
   334  	// match: (Geq64 x y)
   335  	// cond:
   336  	// result: (OrB 		(Greater32 (Int64Hi x) (Int64Hi y)) 		(AndB 			(Eq32 (Int64Hi x) (Int64Hi y)) 			(Geq32U (Int64Lo x) (Int64Lo y))))
   337  	for {
   338  		x := v.Args[0]
   339  		y := v.Args[1]
   340  		v.reset(OpOrB)
   341  		v0 := b.NewValue0(v.Line, OpGreater32, config.fe.TypeBool())
   342  		v1 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   343  		v1.AddArg(x)
   344  		v0.AddArg(v1)
   345  		v2 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   346  		v2.AddArg(y)
   347  		v0.AddArg(v2)
   348  		v.AddArg(v0)
   349  		v3 := b.NewValue0(v.Line, OpAndB, config.fe.TypeBool())
   350  		v4 := b.NewValue0(v.Line, OpEq32, config.fe.TypeBool())
   351  		v5 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   352  		v5.AddArg(x)
   353  		v4.AddArg(v5)
   354  		v6 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   355  		v6.AddArg(y)
   356  		v4.AddArg(v6)
   357  		v3.AddArg(v4)
   358  		v7 := b.NewValue0(v.Line, OpGeq32U, config.fe.TypeBool())
   359  		v8 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
   360  		v8.AddArg(x)
   361  		v7.AddArg(v8)
   362  		v9 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
   363  		v9.AddArg(y)
   364  		v7.AddArg(v9)
   365  		v3.AddArg(v7)
   366  		v.AddArg(v3)
   367  		return true
   368  	}
   369  }
   370  func rewriteValuedec64_OpGeq64U(v *Value, config *Config) bool {
   371  	b := v.Block
   372  	_ = b
   373  	// match: (Geq64U x y)
   374  	// cond:
   375  	// result: (OrB 		(Greater32U (Int64Hi x) (Int64Hi y)) 		(AndB 			(Eq32 (Int64Hi x) (Int64Hi y)) 			(Geq32U (Int64Lo x) (Int64Lo y))))
   376  	for {
   377  		x := v.Args[0]
   378  		y := v.Args[1]
   379  		v.reset(OpOrB)
   380  		v0 := b.NewValue0(v.Line, OpGreater32U, config.fe.TypeBool())
   381  		v1 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   382  		v1.AddArg(x)
   383  		v0.AddArg(v1)
   384  		v2 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   385  		v2.AddArg(y)
   386  		v0.AddArg(v2)
   387  		v.AddArg(v0)
   388  		v3 := b.NewValue0(v.Line, OpAndB, config.fe.TypeBool())
   389  		v4 := b.NewValue0(v.Line, OpEq32, config.fe.TypeBool())
   390  		v5 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   391  		v5.AddArg(x)
   392  		v4.AddArg(v5)
   393  		v6 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   394  		v6.AddArg(y)
   395  		v4.AddArg(v6)
   396  		v3.AddArg(v4)
   397  		v7 := b.NewValue0(v.Line, OpGeq32U, config.fe.TypeBool())
   398  		v8 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
   399  		v8.AddArg(x)
   400  		v7.AddArg(v8)
   401  		v9 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
   402  		v9.AddArg(y)
   403  		v7.AddArg(v9)
   404  		v3.AddArg(v7)
   405  		v.AddArg(v3)
   406  		return true
   407  	}
   408  }
   409  func rewriteValuedec64_OpGreater64(v *Value, config *Config) bool {
   410  	b := v.Block
   411  	_ = b
   412  	// match: (Greater64 x y)
   413  	// cond:
   414  	// result: (OrB 		(Greater32 (Int64Hi x) (Int64Hi y)) 		(AndB 			(Eq32 (Int64Hi x) (Int64Hi y)) 			(Greater32U (Int64Lo x) (Int64Lo y))))
   415  	for {
   416  		x := v.Args[0]
   417  		y := v.Args[1]
   418  		v.reset(OpOrB)
   419  		v0 := b.NewValue0(v.Line, OpGreater32, config.fe.TypeBool())
   420  		v1 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   421  		v1.AddArg(x)
   422  		v0.AddArg(v1)
   423  		v2 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   424  		v2.AddArg(y)
   425  		v0.AddArg(v2)
   426  		v.AddArg(v0)
   427  		v3 := b.NewValue0(v.Line, OpAndB, config.fe.TypeBool())
   428  		v4 := b.NewValue0(v.Line, OpEq32, config.fe.TypeBool())
   429  		v5 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   430  		v5.AddArg(x)
   431  		v4.AddArg(v5)
   432  		v6 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   433  		v6.AddArg(y)
   434  		v4.AddArg(v6)
   435  		v3.AddArg(v4)
   436  		v7 := b.NewValue0(v.Line, OpGreater32U, config.fe.TypeBool())
   437  		v8 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
   438  		v8.AddArg(x)
   439  		v7.AddArg(v8)
   440  		v9 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
   441  		v9.AddArg(y)
   442  		v7.AddArg(v9)
   443  		v3.AddArg(v7)
   444  		v.AddArg(v3)
   445  		return true
   446  	}
   447  }
   448  func rewriteValuedec64_OpGreater64U(v *Value, config *Config) bool {
   449  	b := v.Block
   450  	_ = b
   451  	// match: (Greater64U x y)
   452  	// cond:
   453  	// result: (OrB 		(Greater32U (Int64Hi x) (Int64Hi y)) 		(AndB 			(Eq32 (Int64Hi x) (Int64Hi y)) 			(Greater32U (Int64Lo x) (Int64Lo y))))
   454  	for {
   455  		x := v.Args[0]
   456  		y := v.Args[1]
   457  		v.reset(OpOrB)
   458  		v0 := b.NewValue0(v.Line, OpGreater32U, config.fe.TypeBool())
   459  		v1 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   460  		v1.AddArg(x)
   461  		v0.AddArg(v1)
   462  		v2 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   463  		v2.AddArg(y)
   464  		v0.AddArg(v2)
   465  		v.AddArg(v0)
   466  		v3 := b.NewValue0(v.Line, OpAndB, config.fe.TypeBool())
   467  		v4 := b.NewValue0(v.Line, OpEq32, config.fe.TypeBool())
   468  		v5 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   469  		v5.AddArg(x)
   470  		v4.AddArg(v5)
   471  		v6 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   472  		v6.AddArg(y)
   473  		v4.AddArg(v6)
   474  		v3.AddArg(v4)
   475  		v7 := b.NewValue0(v.Line, OpGreater32U, config.fe.TypeBool())
   476  		v8 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
   477  		v8.AddArg(x)
   478  		v7.AddArg(v8)
   479  		v9 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
   480  		v9.AddArg(y)
   481  		v7.AddArg(v9)
   482  		v3.AddArg(v7)
   483  		v.AddArg(v3)
   484  		return true
   485  	}
   486  }
   487  func rewriteValuedec64_OpInt64Hi(v *Value, config *Config) bool {
   488  	b := v.Block
   489  	_ = b
   490  	// match: (Int64Hi (Int64Make hi _))
   491  	// cond:
   492  	// result: hi
   493  	for {
   494  		v_0 := v.Args[0]
   495  		if v_0.Op != OpInt64Make {
   496  			break
   497  		}
   498  		hi := v_0.Args[0]
   499  		v.reset(OpCopy)
   500  		v.Type = hi.Type
   501  		v.AddArg(hi)
   502  		return true
   503  	}
   504  	return false
   505  }
   506  func rewriteValuedec64_OpInt64Lo(v *Value, config *Config) bool {
   507  	b := v.Block
   508  	_ = b
   509  	// match: (Int64Lo (Int64Make _ lo))
   510  	// cond:
   511  	// result: lo
   512  	for {
   513  		v_0 := v.Args[0]
   514  		if v_0.Op != OpInt64Make {
   515  			break
   516  		}
   517  		lo := v_0.Args[1]
   518  		v.reset(OpCopy)
   519  		v.Type = lo.Type
   520  		v.AddArg(lo)
   521  		return true
   522  	}
   523  	return false
   524  }
   525  func rewriteValuedec64_OpLeq64(v *Value, config *Config) bool {
   526  	b := v.Block
   527  	_ = b
   528  	// match: (Leq64 x y)
   529  	// cond:
   530  	// result: (OrB 		(Less32 (Int64Hi x) (Int64Hi y)) 		(AndB 			(Eq32 (Int64Hi x) (Int64Hi y)) 			(Leq32U (Int64Lo x) (Int64Lo y))))
   531  	for {
   532  		x := v.Args[0]
   533  		y := v.Args[1]
   534  		v.reset(OpOrB)
   535  		v0 := b.NewValue0(v.Line, OpLess32, config.fe.TypeBool())
   536  		v1 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   537  		v1.AddArg(x)
   538  		v0.AddArg(v1)
   539  		v2 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   540  		v2.AddArg(y)
   541  		v0.AddArg(v2)
   542  		v.AddArg(v0)
   543  		v3 := b.NewValue0(v.Line, OpAndB, config.fe.TypeBool())
   544  		v4 := b.NewValue0(v.Line, OpEq32, config.fe.TypeBool())
   545  		v5 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   546  		v5.AddArg(x)
   547  		v4.AddArg(v5)
   548  		v6 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   549  		v6.AddArg(y)
   550  		v4.AddArg(v6)
   551  		v3.AddArg(v4)
   552  		v7 := b.NewValue0(v.Line, OpLeq32U, config.fe.TypeBool())
   553  		v8 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
   554  		v8.AddArg(x)
   555  		v7.AddArg(v8)
   556  		v9 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
   557  		v9.AddArg(y)
   558  		v7.AddArg(v9)
   559  		v3.AddArg(v7)
   560  		v.AddArg(v3)
   561  		return true
   562  	}
   563  }
   564  func rewriteValuedec64_OpLeq64U(v *Value, config *Config) bool {
   565  	b := v.Block
   566  	_ = b
   567  	// match: (Leq64U x y)
   568  	// cond:
   569  	// result: (OrB 		(Less32U (Int64Hi x) (Int64Hi y)) 		(AndB 			(Eq32 (Int64Hi x) (Int64Hi y)) 			(Leq32U (Int64Lo x) (Int64Lo y))))
   570  	for {
   571  		x := v.Args[0]
   572  		y := v.Args[1]
   573  		v.reset(OpOrB)
   574  		v0 := b.NewValue0(v.Line, OpLess32U, config.fe.TypeBool())
   575  		v1 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   576  		v1.AddArg(x)
   577  		v0.AddArg(v1)
   578  		v2 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   579  		v2.AddArg(y)
   580  		v0.AddArg(v2)
   581  		v.AddArg(v0)
   582  		v3 := b.NewValue0(v.Line, OpAndB, config.fe.TypeBool())
   583  		v4 := b.NewValue0(v.Line, OpEq32, config.fe.TypeBool())
   584  		v5 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   585  		v5.AddArg(x)
   586  		v4.AddArg(v5)
   587  		v6 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   588  		v6.AddArg(y)
   589  		v4.AddArg(v6)
   590  		v3.AddArg(v4)
   591  		v7 := b.NewValue0(v.Line, OpLeq32U, config.fe.TypeBool())
   592  		v8 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
   593  		v8.AddArg(x)
   594  		v7.AddArg(v8)
   595  		v9 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
   596  		v9.AddArg(y)
   597  		v7.AddArg(v9)
   598  		v3.AddArg(v7)
   599  		v.AddArg(v3)
   600  		return true
   601  	}
   602  }
   603  func rewriteValuedec64_OpLess64(v *Value, config *Config) bool {
   604  	b := v.Block
   605  	_ = b
   606  	// match: (Less64 x y)
   607  	// cond:
   608  	// result: (OrB 		(Less32 (Int64Hi x) (Int64Hi y)) 		(AndB 			(Eq32 (Int64Hi x) (Int64Hi y)) 			(Less32U (Int64Lo x) (Int64Lo y))))
   609  	for {
   610  		x := v.Args[0]
   611  		y := v.Args[1]
   612  		v.reset(OpOrB)
   613  		v0 := b.NewValue0(v.Line, OpLess32, config.fe.TypeBool())
   614  		v1 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   615  		v1.AddArg(x)
   616  		v0.AddArg(v1)
   617  		v2 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   618  		v2.AddArg(y)
   619  		v0.AddArg(v2)
   620  		v.AddArg(v0)
   621  		v3 := b.NewValue0(v.Line, OpAndB, config.fe.TypeBool())
   622  		v4 := b.NewValue0(v.Line, OpEq32, config.fe.TypeBool())
   623  		v5 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   624  		v5.AddArg(x)
   625  		v4.AddArg(v5)
   626  		v6 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   627  		v6.AddArg(y)
   628  		v4.AddArg(v6)
   629  		v3.AddArg(v4)
   630  		v7 := b.NewValue0(v.Line, OpLess32U, config.fe.TypeBool())
   631  		v8 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
   632  		v8.AddArg(x)
   633  		v7.AddArg(v8)
   634  		v9 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
   635  		v9.AddArg(y)
   636  		v7.AddArg(v9)
   637  		v3.AddArg(v7)
   638  		v.AddArg(v3)
   639  		return true
   640  	}
   641  }
   642  func rewriteValuedec64_OpLess64U(v *Value, config *Config) bool {
   643  	b := v.Block
   644  	_ = b
   645  	// match: (Less64U x y)
   646  	// cond:
   647  	// result: (OrB 		(Less32U (Int64Hi x) (Int64Hi y)) 		(AndB 			(Eq32 (Int64Hi x) (Int64Hi y)) 			(Less32U (Int64Lo x) (Int64Lo y))))
   648  	for {
   649  		x := v.Args[0]
   650  		y := v.Args[1]
   651  		v.reset(OpOrB)
   652  		v0 := b.NewValue0(v.Line, OpLess32U, config.fe.TypeBool())
   653  		v1 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   654  		v1.AddArg(x)
   655  		v0.AddArg(v1)
   656  		v2 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   657  		v2.AddArg(y)
   658  		v0.AddArg(v2)
   659  		v.AddArg(v0)
   660  		v3 := b.NewValue0(v.Line, OpAndB, config.fe.TypeBool())
   661  		v4 := b.NewValue0(v.Line, OpEq32, config.fe.TypeBool())
   662  		v5 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   663  		v5.AddArg(x)
   664  		v4.AddArg(v5)
   665  		v6 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
   666  		v6.AddArg(y)
   667  		v4.AddArg(v6)
   668  		v3.AddArg(v4)
   669  		v7 := b.NewValue0(v.Line, OpLess32U, config.fe.TypeBool())
   670  		v8 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
   671  		v8.AddArg(x)
   672  		v7.AddArg(v8)
   673  		v9 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
   674  		v9.AddArg(y)
   675  		v7.AddArg(v9)
   676  		v3.AddArg(v7)
   677  		v.AddArg(v3)
   678  		return true
   679  	}
   680  }
   681  func rewriteValuedec64_OpLoad(v *Value, config *Config) bool {
   682  	b := v.Block
   683  	_ = b
   684  	// match: (Load <t> ptr mem)
   685  	// cond: is64BitInt(t) && t.IsSigned()
   686  	// result: (Int64Make 		(Load <config.fe.TypeInt32()> (OffPtr <config.fe.TypeInt32().PtrTo()> [4] ptr) mem) 		(Load <config.fe.TypeUInt32()> ptr mem))
   687  	for {
   688  		t := v.Type
   689  		ptr := v.Args[0]
   690  		mem := v.Args[1]
   691  		if !(is64BitInt(t) && t.IsSigned()) {
   692  			break
   693  		}
   694  		v.reset(OpInt64Make)
   695  		v0 := b.NewValue0(v.Line, OpLoad, config.fe.TypeInt32())
   696  		v1 := b.NewValue0(v.Line, OpOffPtr, config.fe.TypeInt32().PtrTo())
   697  		v1.AuxInt = 4
   698  		v1.AddArg(ptr)
   699  		v0.AddArg(v1)
   700  		v0.AddArg(mem)
   701  		v.AddArg(v0)
   702  		v2 := b.NewValue0(v.Line, OpLoad, config.fe.TypeUInt32())
   703  		v2.AddArg(ptr)
   704  		v2.AddArg(mem)
   705  		v.AddArg(v2)
   706  		return true
   707  	}
   708  	// match: (Load <t> ptr mem)
   709  	// cond: is64BitInt(t) && !t.IsSigned()
   710  	// result: (Int64Make 		(Load <config.fe.TypeUInt32()> (OffPtr <config.fe.TypeUInt32().PtrTo()> [4] ptr) mem) 		(Load <config.fe.TypeUInt32()> ptr mem))
   711  	for {
   712  		t := v.Type
   713  		ptr := v.Args[0]
   714  		mem := v.Args[1]
   715  		if !(is64BitInt(t) && !t.IsSigned()) {
   716  			break
   717  		}
   718  		v.reset(OpInt64Make)
   719  		v0 := b.NewValue0(v.Line, OpLoad, config.fe.TypeUInt32())
   720  		v1 := b.NewValue0(v.Line, OpOffPtr, config.fe.TypeUInt32().PtrTo())
   721  		v1.AuxInt = 4
   722  		v1.AddArg(ptr)
   723  		v0.AddArg(v1)
   724  		v0.AddArg(mem)
   725  		v.AddArg(v0)
   726  		v2 := b.NewValue0(v.Line, OpLoad, config.fe.TypeUInt32())
   727  		v2.AddArg(ptr)
   728  		v2.AddArg(mem)
   729  		v.AddArg(v2)
   730  		return true
   731  	}
   732  	return false
   733  }
   734  func rewriteValuedec64_OpLrot64(v *Value, config *Config) bool {
   735  	b := v.Block
   736  	_ = b
   737  	// match: (Lrot64 (Int64Make hi lo) [c])
   738  	// cond: c <= 32
   739  	// result: (Int64Make 		(Or32 <config.fe.TypeUInt32()> 			(Lsh32x32 <config.fe.TypeUInt32()> hi (Const32 <config.fe.TypeUInt32()> [c])) 			(Rsh32Ux32 <config.fe.TypeUInt32()> lo (Const32 <config.fe.TypeUInt32()> [32-c]))) 		(Or32 <config.fe.TypeUInt32()> 			(Lsh32x32 <config.fe.TypeUInt32()> lo (Const32 <config.fe.TypeUInt32()> [c])) 			(Rsh32Ux32 <config.fe.TypeUInt32()> hi (Const32 <config.fe.TypeUInt32()> [32-c]))))
   740  	for {
   741  		c := v.AuxInt
   742  		v_0 := v.Args[0]
   743  		if v_0.Op != OpInt64Make {
   744  			break
   745  		}
   746  		hi := v_0.Args[0]
   747  		lo := v_0.Args[1]
   748  		if !(c <= 32) {
   749  			break
   750  		}
   751  		v.reset(OpInt64Make)
   752  		v0 := b.NewValue0(v.Line, OpOr32, config.fe.TypeUInt32())
   753  		v1 := b.NewValue0(v.Line, OpLsh32x32, config.fe.TypeUInt32())
   754  		v1.AddArg(hi)
   755  		v2 := b.NewValue0(v.Line, OpConst32, config.fe.TypeUInt32())
   756  		v2.AuxInt = c
   757  		v1.AddArg(v2)
   758  		v0.AddArg(v1)
   759  		v3 := b.NewValue0(v.Line, OpRsh32Ux32, config.fe.TypeUInt32())
   760  		v3.AddArg(lo)
   761  		v4 := b.NewValue0(v.Line, OpConst32, config.fe.TypeUInt32())
   762  		v4.AuxInt = 32 - c
   763  		v3.AddArg(v4)
   764  		v0.AddArg(v3)
   765  		v.AddArg(v0)
   766  		v5 := b.NewValue0(v.Line, OpOr32, config.fe.TypeUInt32())
   767  		v6 := b.NewValue0(v.Line, OpLsh32x32, config.fe.TypeUInt32())
   768  		v6.AddArg(lo)
   769  		v7 := b.NewValue0(v.Line, OpConst32, config.fe.TypeUInt32())
   770  		v7.AuxInt = c
   771  		v6.AddArg(v7)
   772  		v5.AddArg(v6)
   773  		v8 := b.NewValue0(v.Line, OpRsh32Ux32, config.fe.TypeUInt32())
   774  		v8.AddArg(hi)
   775  		v9 := b.NewValue0(v.Line, OpConst32, config.fe.TypeUInt32())
   776  		v9.AuxInt = 32 - c
   777  		v8.AddArg(v9)
   778  		v5.AddArg(v8)
   779  		v.AddArg(v5)
   780  		return true
   781  	}
   782  	// match: (Lrot64 (Int64Make hi lo) [c])
   783  	// cond: c > 32
   784  	// result: (Lrot64 (Int64Make lo hi) [c-32])
   785  	for {
   786  		c := v.AuxInt
   787  		v_0 := v.Args[0]
   788  		if v_0.Op != OpInt64Make {
   789  			break
   790  		}
   791  		hi := v_0.Args[0]
   792  		lo := v_0.Args[1]
   793  		if !(c > 32) {
   794  			break
   795  		}
   796  		v.reset(OpLrot64)
   797  		v.AuxInt = c - 32
   798  		v0 := b.NewValue0(v.Line, OpInt64Make, config.fe.TypeUInt64())
   799  		v0.AddArg(lo)
   800  		v0.AddArg(hi)
   801  		v.AddArg(v0)
   802  		return true
   803  	}
   804  	return false
   805  }
   806  func rewriteValuedec64_OpLsh16x64(v *Value, config *Config) bool {
   807  	b := v.Block
   808  	_ = b
   809  	// match: (Lsh16x64 _ (Int64Make (Const32 [c]) _))
   810  	// cond: c != 0
   811  	// result: (Const32 [0])
   812  	for {
   813  		v_1 := v.Args[1]
   814  		if v_1.Op != OpInt64Make {
   815  			break
   816  		}
   817  		v_1_0 := v_1.Args[0]
   818  		if v_1_0.Op != OpConst32 {
   819  			break
   820  		}
   821  		c := v_1_0.AuxInt
   822  		if !(c != 0) {
   823  			break
   824  		}
   825  		v.reset(OpConst32)
   826  		v.AuxInt = 0
   827  		return true
   828  	}
   829  	// match: (Lsh16x64 x (Int64Make (Const32 [0]) lo))
   830  	// cond:
   831  	// result: (Lsh16x32 x lo)
   832  	for {
   833  		x := v.Args[0]
   834  		v_1 := v.Args[1]
   835  		if v_1.Op != OpInt64Make {
   836  			break
   837  		}
   838  		v_1_0 := v_1.Args[0]
   839  		if v_1_0.Op != OpConst32 {
   840  			break
   841  		}
   842  		if v_1_0.AuxInt != 0 {
   843  			break
   844  		}
   845  		lo := v_1.Args[1]
   846  		v.reset(OpLsh16x32)
   847  		v.AddArg(x)
   848  		v.AddArg(lo)
   849  		return true
   850  	}
   851  	// match: (Lsh16x64 x (Int64Make hi lo))
   852  	// cond: hi.Op != OpConst32
   853  	// result: (Lsh16x32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo))
   854  	for {
   855  		x := v.Args[0]
   856  		v_1 := v.Args[1]
   857  		if v_1.Op != OpInt64Make {
   858  			break
   859  		}
   860  		hi := v_1.Args[0]
   861  		lo := v_1.Args[1]
   862  		if !(hi.Op != OpConst32) {
   863  			break
   864  		}
   865  		v.reset(OpLsh16x32)
   866  		v.AddArg(x)
   867  		v0 := b.NewValue0(v.Line, OpOr32, config.fe.TypeUInt32())
   868  		v1 := b.NewValue0(v.Line, OpZeromask, config.fe.TypeUInt32())
   869  		v1.AddArg(hi)
   870  		v0.AddArg(v1)
   871  		v0.AddArg(lo)
   872  		v.AddArg(v0)
   873  		return true
   874  	}
   875  	return false
   876  }
   877  func rewriteValuedec64_OpLsh32x64(v *Value, config *Config) bool {
   878  	b := v.Block
   879  	_ = b
   880  	// match: (Lsh32x64 _ (Int64Make (Const32 [c]) _))
   881  	// cond: c != 0
   882  	// result: (Const32 [0])
   883  	for {
   884  		v_1 := v.Args[1]
   885  		if v_1.Op != OpInt64Make {
   886  			break
   887  		}
   888  		v_1_0 := v_1.Args[0]
   889  		if v_1_0.Op != OpConst32 {
   890  			break
   891  		}
   892  		c := v_1_0.AuxInt
   893  		if !(c != 0) {
   894  			break
   895  		}
   896  		v.reset(OpConst32)
   897  		v.AuxInt = 0
   898  		return true
   899  	}
   900  	// match: (Lsh32x64 x (Int64Make (Const32 [0]) lo))
   901  	// cond:
   902  	// result: (Lsh32x32 x lo)
   903  	for {
   904  		x := v.Args[0]
   905  		v_1 := v.Args[1]
   906  		if v_1.Op != OpInt64Make {
   907  			break
   908  		}
   909  		v_1_0 := v_1.Args[0]
   910  		if v_1_0.Op != OpConst32 {
   911  			break
   912  		}
   913  		if v_1_0.AuxInt != 0 {
   914  			break
   915  		}
   916  		lo := v_1.Args[1]
   917  		v.reset(OpLsh32x32)
   918  		v.AddArg(x)
   919  		v.AddArg(lo)
   920  		return true
   921  	}
   922  	// match: (Lsh32x64 x (Int64Make hi lo))
   923  	// cond: hi.Op != OpConst32
   924  	// result: (Lsh32x32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo))
   925  	for {
   926  		x := v.Args[0]
   927  		v_1 := v.Args[1]
   928  		if v_1.Op != OpInt64Make {
   929  			break
   930  		}
   931  		hi := v_1.Args[0]
   932  		lo := v_1.Args[1]
   933  		if !(hi.Op != OpConst32) {
   934  			break
   935  		}
   936  		v.reset(OpLsh32x32)
   937  		v.AddArg(x)
   938  		v0 := b.NewValue0(v.Line, OpOr32, config.fe.TypeUInt32())
   939  		v1 := b.NewValue0(v.Line, OpZeromask, config.fe.TypeUInt32())
   940  		v1.AddArg(hi)
   941  		v0.AddArg(v1)
   942  		v0.AddArg(lo)
   943  		v.AddArg(v0)
   944  		return true
   945  	}
   946  	return false
   947  }
   948  func rewriteValuedec64_OpLsh64x16(v *Value, config *Config) bool {
   949  	b := v.Block
   950  	_ = b
   951  	// match: (Lsh64x16 (Int64Make hi lo) s)
   952  	// cond:
   953  	// result: (Int64Make 		(Or32 <config.fe.TypeUInt32()> 			(Or32 <config.fe.TypeUInt32()> 				(Lsh32x16 <config.fe.TypeUInt32()> hi s) 				(Rsh32Ux16 <config.fe.TypeUInt32()> 					lo 					(Sub16 <config.fe.TypeUInt16()> (Const16 <config.fe.TypeUInt16()> [32]) s))) 			(Lsh32x16 <config.fe.TypeUInt32()> 				lo 				(Sub16 <config.fe.TypeUInt16()> s (Const16 <config.fe.TypeUInt16()> [32])))) 		(Lsh32x16 <config.fe.TypeUInt32()> lo s))
   954  	for {
   955  		v_0 := v.Args[0]
   956  		if v_0.Op != OpInt64Make {
   957  			break
   958  		}
   959  		hi := v_0.Args[0]
   960  		lo := v_0.Args[1]
   961  		s := v.Args[1]
   962  		v.reset(OpInt64Make)
   963  		v0 := b.NewValue0(v.Line, OpOr32, config.fe.TypeUInt32())
   964  		v1 := b.NewValue0(v.Line, OpOr32, config.fe.TypeUInt32())
   965  		v2 := b.NewValue0(v.Line, OpLsh32x16, config.fe.TypeUInt32())
   966  		v2.AddArg(hi)
   967  		v2.AddArg(s)
   968  		v1.AddArg(v2)
   969  		v3 := b.NewValue0(v.Line, OpRsh32Ux16, config.fe.TypeUInt32())
   970  		v3.AddArg(lo)
   971  		v4 := b.NewValue0(v.Line, OpSub16, config.fe.TypeUInt16())
   972  		v5 := b.NewValue0(v.Line, OpConst16, config.fe.TypeUInt16())
   973  		v5.AuxInt = 32
   974  		v4.AddArg(v5)
   975  		v4.AddArg(s)
   976  		v3.AddArg(v4)
   977  		v1.AddArg(v3)
   978  		v0.AddArg(v1)
   979  		v6 := b.NewValue0(v.Line, OpLsh32x16, config.fe.TypeUInt32())
   980  		v6.AddArg(lo)
   981  		v7 := b.NewValue0(v.Line, OpSub16, config.fe.TypeUInt16())
   982  		v7.AddArg(s)
   983  		v8 := b.NewValue0(v.Line, OpConst16, config.fe.TypeUInt16())
   984  		v8.AuxInt = 32
   985  		v7.AddArg(v8)
   986  		v6.AddArg(v7)
   987  		v0.AddArg(v6)
   988  		v.AddArg(v0)
   989  		v9 := b.NewValue0(v.Line, OpLsh32x16, config.fe.TypeUInt32())
   990  		v9.AddArg(lo)
   991  		v9.AddArg(s)
   992  		v.AddArg(v9)
   993  		return true
   994  	}
   995  	return false
   996  }
   997  func rewriteValuedec64_OpLsh64x32(v *Value, config *Config) bool {
   998  	b := v.Block
   999  	_ = b
  1000  	// match: (Lsh64x32 (Int64Make hi lo) s)
  1001  	// cond:
  1002  	// result: (Int64Make 		(Or32 <config.fe.TypeUInt32()> 			(Or32 <config.fe.TypeUInt32()> 				(Lsh32x32 <config.fe.TypeUInt32()> hi s) 				(Rsh32Ux32 <config.fe.TypeUInt32()> 					lo 					(Sub32 <config.fe.TypeUInt32()> (Const32 <config.fe.TypeUInt32()> [32]) s))) 			(Lsh32x32 <config.fe.TypeUInt32()> 				lo 				(Sub32 <config.fe.TypeUInt32()> s (Const32 <config.fe.TypeUInt32()> [32])))) 		(Lsh32x32 <config.fe.TypeUInt32()> lo s))
  1003  	for {
  1004  		v_0 := v.Args[0]
  1005  		if v_0.Op != OpInt64Make {
  1006  			break
  1007  		}
  1008  		hi := v_0.Args[0]
  1009  		lo := v_0.Args[1]
  1010  		s := v.Args[1]
  1011  		v.reset(OpInt64Make)
  1012  		v0 := b.NewValue0(v.Line, OpOr32, config.fe.TypeUInt32())
  1013  		v1 := b.NewValue0(v.Line, OpOr32, config.fe.TypeUInt32())
  1014  		v2 := b.NewValue0(v.Line, OpLsh32x32, config.fe.TypeUInt32())
  1015  		v2.AddArg(hi)
  1016  		v2.AddArg(s)
  1017  		v1.AddArg(v2)
  1018  		v3 := b.NewValue0(v.Line, OpRsh32Ux32, config.fe.TypeUInt32())
  1019  		v3.AddArg(lo)
  1020  		v4 := b.NewValue0(v.Line, OpSub32, config.fe.TypeUInt32())
  1021  		v5 := b.NewValue0(v.Line, OpConst32, config.fe.TypeUInt32())
  1022  		v5.AuxInt = 32
  1023  		v4.AddArg(v5)
  1024  		v4.AddArg(s)
  1025  		v3.AddArg(v4)
  1026  		v1.AddArg(v3)
  1027  		v0.AddArg(v1)
  1028  		v6 := b.NewValue0(v.Line, OpLsh32x32, config.fe.TypeUInt32())
  1029  		v6.AddArg(lo)
  1030  		v7 := b.NewValue0(v.Line, OpSub32, config.fe.TypeUInt32())
  1031  		v7.AddArg(s)
  1032  		v8 := b.NewValue0(v.Line, OpConst32, config.fe.TypeUInt32())
  1033  		v8.AuxInt = 32
  1034  		v7.AddArg(v8)
  1035  		v6.AddArg(v7)
  1036  		v0.AddArg(v6)
  1037  		v.AddArg(v0)
  1038  		v9 := b.NewValue0(v.Line, OpLsh32x32, config.fe.TypeUInt32())
  1039  		v9.AddArg(lo)
  1040  		v9.AddArg(s)
  1041  		v.AddArg(v9)
  1042  		return true
  1043  	}
  1044  	return false
  1045  }
  1046  func rewriteValuedec64_OpLsh64x64(v *Value, config *Config) bool {
  1047  	b := v.Block
  1048  	_ = b
  1049  	// match: (Lsh64x64 _ (Int64Make (Const32 [c]) _))
  1050  	// cond: c != 0
  1051  	// result: (Const64 [0])
  1052  	for {
  1053  		v_1 := v.Args[1]
  1054  		if v_1.Op != OpInt64Make {
  1055  			break
  1056  		}
  1057  		v_1_0 := v_1.Args[0]
  1058  		if v_1_0.Op != OpConst32 {
  1059  			break
  1060  		}
  1061  		c := v_1_0.AuxInt
  1062  		if !(c != 0) {
  1063  			break
  1064  		}
  1065  		v.reset(OpConst64)
  1066  		v.AuxInt = 0
  1067  		return true
  1068  	}
  1069  	// match: (Lsh64x64 x (Int64Make (Const32 [0]) lo))
  1070  	// cond:
  1071  	// result: (Lsh64x32 x lo)
  1072  	for {
  1073  		x := v.Args[0]
  1074  		v_1 := v.Args[1]
  1075  		if v_1.Op != OpInt64Make {
  1076  			break
  1077  		}
  1078  		v_1_0 := v_1.Args[0]
  1079  		if v_1_0.Op != OpConst32 {
  1080  			break
  1081  		}
  1082  		if v_1_0.AuxInt != 0 {
  1083  			break
  1084  		}
  1085  		lo := v_1.Args[1]
  1086  		v.reset(OpLsh64x32)
  1087  		v.AddArg(x)
  1088  		v.AddArg(lo)
  1089  		return true
  1090  	}
  1091  	// match: (Lsh64x64 x (Int64Make hi lo))
  1092  	// cond: hi.Op != OpConst32
  1093  	// result: (Lsh64x32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo))
  1094  	for {
  1095  		x := v.Args[0]
  1096  		v_1 := v.Args[1]
  1097  		if v_1.Op != OpInt64Make {
  1098  			break
  1099  		}
  1100  		hi := v_1.Args[0]
  1101  		lo := v_1.Args[1]
  1102  		if !(hi.Op != OpConst32) {
  1103  			break
  1104  		}
  1105  		v.reset(OpLsh64x32)
  1106  		v.AddArg(x)
  1107  		v0 := b.NewValue0(v.Line, OpOr32, config.fe.TypeUInt32())
  1108  		v1 := b.NewValue0(v.Line, OpZeromask, config.fe.TypeUInt32())
  1109  		v1.AddArg(hi)
  1110  		v0.AddArg(v1)
  1111  		v0.AddArg(lo)
  1112  		v.AddArg(v0)
  1113  		return true
  1114  	}
  1115  	return false
  1116  }
  1117  func rewriteValuedec64_OpLsh64x8(v *Value, config *Config) bool {
  1118  	b := v.Block
  1119  	_ = b
  1120  	// match: (Lsh64x8 (Int64Make hi lo) s)
  1121  	// cond:
  1122  	// result: (Int64Make 		(Or32 <config.fe.TypeUInt32()> 			(Or32 <config.fe.TypeUInt32()> 				(Lsh32x8 <config.fe.TypeUInt32()> hi s) 				(Rsh32Ux8 <config.fe.TypeUInt32()> 					lo 					(Sub8 <config.fe.TypeUInt8()> (Const8 <config.fe.TypeUInt8()> [32]) s))) 			(Lsh32x8 <config.fe.TypeUInt32()> 				lo 				(Sub8 <config.fe.TypeUInt8()> s (Const8 <config.fe.TypeUInt8()> [32])))) 		(Lsh32x8 <config.fe.TypeUInt32()> lo s))
  1123  	for {
  1124  		v_0 := v.Args[0]
  1125  		if v_0.Op != OpInt64Make {
  1126  			break
  1127  		}
  1128  		hi := v_0.Args[0]
  1129  		lo := v_0.Args[1]
  1130  		s := v.Args[1]
  1131  		v.reset(OpInt64Make)
  1132  		v0 := b.NewValue0(v.Line, OpOr32, config.fe.TypeUInt32())
  1133  		v1 := b.NewValue0(v.Line, OpOr32, config.fe.TypeUInt32())
  1134  		v2 := b.NewValue0(v.Line, OpLsh32x8, config.fe.TypeUInt32())
  1135  		v2.AddArg(hi)
  1136  		v2.AddArg(s)
  1137  		v1.AddArg(v2)
  1138  		v3 := b.NewValue0(v.Line, OpRsh32Ux8, config.fe.TypeUInt32())
  1139  		v3.AddArg(lo)
  1140  		v4 := b.NewValue0(v.Line, OpSub8, config.fe.TypeUInt8())
  1141  		v5 := b.NewValue0(v.Line, OpConst8, config.fe.TypeUInt8())
  1142  		v5.AuxInt = 32
  1143  		v4.AddArg(v5)
  1144  		v4.AddArg(s)
  1145  		v3.AddArg(v4)
  1146  		v1.AddArg(v3)
  1147  		v0.AddArg(v1)
  1148  		v6 := b.NewValue0(v.Line, OpLsh32x8, config.fe.TypeUInt32())
  1149  		v6.AddArg(lo)
  1150  		v7 := b.NewValue0(v.Line, OpSub8, config.fe.TypeUInt8())
  1151  		v7.AddArg(s)
  1152  		v8 := b.NewValue0(v.Line, OpConst8, config.fe.TypeUInt8())
  1153  		v8.AuxInt = 32
  1154  		v7.AddArg(v8)
  1155  		v6.AddArg(v7)
  1156  		v0.AddArg(v6)
  1157  		v.AddArg(v0)
  1158  		v9 := b.NewValue0(v.Line, OpLsh32x8, config.fe.TypeUInt32())
  1159  		v9.AddArg(lo)
  1160  		v9.AddArg(s)
  1161  		v.AddArg(v9)
  1162  		return true
  1163  	}
  1164  	return false
  1165  }
  1166  func rewriteValuedec64_OpLsh8x64(v *Value, config *Config) bool {
  1167  	b := v.Block
  1168  	_ = b
  1169  	// match: (Lsh8x64 _ (Int64Make (Const32 [c]) _))
  1170  	// cond: c != 0
  1171  	// result: (Const32 [0])
  1172  	for {
  1173  		v_1 := v.Args[1]
  1174  		if v_1.Op != OpInt64Make {
  1175  			break
  1176  		}
  1177  		v_1_0 := v_1.Args[0]
  1178  		if v_1_0.Op != OpConst32 {
  1179  			break
  1180  		}
  1181  		c := v_1_0.AuxInt
  1182  		if !(c != 0) {
  1183  			break
  1184  		}
  1185  		v.reset(OpConst32)
  1186  		v.AuxInt = 0
  1187  		return true
  1188  	}
  1189  	// match: (Lsh8x64 x (Int64Make (Const32 [0]) lo))
  1190  	// cond:
  1191  	// result: (Lsh8x32 x lo)
  1192  	for {
  1193  		x := v.Args[0]
  1194  		v_1 := v.Args[1]
  1195  		if v_1.Op != OpInt64Make {
  1196  			break
  1197  		}
  1198  		v_1_0 := v_1.Args[0]
  1199  		if v_1_0.Op != OpConst32 {
  1200  			break
  1201  		}
  1202  		if v_1_0.AuxInt != 0 {
  1203  			break
  1204  		}
  1205  		lo := v_1.Args[1]
  1206  		v.reset(OpLsh8x32)
  1207  		v.AddArg(x)
  1208  		v.AddArg(lo)
  1209  		return true
  1210  	}
  1211  	// match: (Lsh8x64 x (Int64Make hi lo))
  1212  	// cond: hi.Op != OpConst32
  1213  	// result: (Lsh8x32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo))
  1214  	for {
  1215  		x := v.Args[0]
  1216  		v_1 := v.Args[1]
  1217  		if v_1.Op != OpInt64Make {
  1218  			break
  1219  		}
  1220  		hi := v_1.Args[0]
  1221  		lo := v_1.Args[1]
  1222  		if !(hi.Op != OpConst32) {
  1223  			break
  1224  		}
  1225  		v.reset(OpLsh8x32)
  1226  		v.AddArg(x)
  1227  		v0 := b.NewValue0(v.Line, OpOr32, config.fe.TypeUInt32())
  1228  		v1 := b.NewValue0(v.Line, OpZeromask, config.fe.TypeUInt32())
  1229  		v1.AddArg(hi)
  1230  		v0.AddArg(v1)
  1231  		v0.AddArg(lo)
  1232  		v.AddArg(v0)
  1233  		return true
  1234  	}
  1235  	return false
  1236  }
  1237  func rewriteValuedec64_OpMul64(v *Value, config *Config) bool {
  1238  	b := v.Block
  1239  	_ = b
  1240  	// match: (Mul64 x y)
  1241  	// cond:
  1242  	// result: (Int64Make 		(Add32 <config.fe.TypeUInt32()> 			(Mul32 <config.fe.TypeUInt32()> (Int64Lo x) (Int64Hi y)) 			(Add32 <config.fe.TypeUInt32()> 				(Mul32 <config.fe.TypeUInt32()> (Int64Hi x) (Int64Lo y)) 				(Select0 <config.fe.TypeUInt32()> (Mul32uhilo (Int64Lo x) (Int64Lo y))))) 		(Select1 <config.fe.TypeUInt32()> (Mul32uhilo (Int64Lo x) (Int64Lo y))))
  1243  	for {
  1244  		x := v.Args[0]
  1245  		y := v.Args[1]
  1246  		v.reset(OpInt64Make)
  1247  		v0 := b.NewValue0(v.Line, OpAdd32, config.fe.TypeUInt32())
  1248  		v1 := b.NewValue0(v.Line, OpMul32, config.fe.TypeUInt32())
  1249  		v2 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
  1250  		v2.AddArg(x)
  1251  		v1.AddArg(v2)
  1252  		v3 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
  1253  		v3.AddArg(y)
  1254  		v1.AddArg(v3)
  1255  		v0.AddArg(v1)
  1256  		v4 := b.NewValue0(v.Line, OpAdd32, config.fe.TypeUInt32())
  1257  		v5 := b.NewValue0(v.Line, OpMul32, config.fe.TypeUInt32())
  1258  		v6 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
  1259  		v6.AddArg(x)
  1260  		v5.AddArg(v6)
  1261  		v7 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
  1262  		v7.AddArg(y)
  1263  		v5.AddArg(v7)
  1264  		v4.AddArg(v5)
  1265  		v8 := b.NewValue0(v.Line, OpSelect0, config.fe.TypeUInt32())
  1266  		v9 := b.NewValue0(v.Line, OpMul32uhilo, MakeTuple(config.fe.TypeUInt32(), config.fe.TypeUInt32()))
  1267  		v10 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
  1268  		v10.AddArg(x)
  1269  		v9.AddArg(v10)
  1270  		v11 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
  1271  		v11.AddArg(y)
  1272  		v9.AddArg(v11)
  1273  		v8.AddArg(v9)
  1274  		v4.AddArg(v8)
  1275  		v0.AddArg(v4)
  1276  		v.AddArg(v0)
  1277  		v12 := b.NewValue0(v.Line, OpSelect1, config.fe.TypeUInt32())
  1278  		v13 := b.NewValue0(v.Line, OpMul32uhilo, MakeTuple(config.fe.TypeUInt32(), config.fe.TypeUInt32()))
  1279  		v14 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
  1280  		v14.AddArg(x)
  1281  		v13.AddArg(v14)
  1282  		v15 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
  1283  		v15.AddArg(y)
  1284  		v13.AddArg(v15)
  1285  		v12.AddArg(v13)
  1286  		v.AddArg(v12)
  1287  		return true
  1288  	}
  1289  }
  1290  func rewriteValuedec64_OpNeg64(v *Value, config *Config) bool {
  1291  	b := v.Block
  1292  	_ = b
  1293  	// match: (Neg64 <t> x)
  1294  	// cond:
  1295  	// result: (Sub64 (Const64 <t> [0]) x)
  1296  	for {
  1297  		t := v.Type
  1298  		x := v.Args[0]
  1299  		v.reset(OpSub64)
  1300  		v0 := b.NewValue0(v.Line, OpConst64, t)
  1301  		v0.AuxInt = 0
  1302  		v.AddArg(v0)
  1303  		v.AddArg(x)
  1304  		return true
  1305  	}
  1306  }
  1307  func rewriteValuedec64_OpNeq64(v *Value, config *Config) bool {
  1308  	b := v.Block
  1309  	_ = b
  1310  	// match: (Neq64 x y)
  1311  	// cond:
  1312  	// result: (OrB 		(Neq32 (Int64Hi x) (Int64Hi y)) 		(Neq32 (Int64Lo x) (Int64Lo y)))
  1313  	for {
  1314  		x := v.Args[0]
  1315  		y := v.Args[1]
  1316  		v.reset(OpOrB)
  1317  		v0 := b.NewValue0(v.Line, OpNeq32, config.fe.TypeBool())
  1318  		v1 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
  1319  		v1.AddArg(x)
  1320  		v0.AddArg(v1)
  1321  		v2 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
  1322  		v2.AddArg(y)
  1323  		v0.AddArg(v2)
  1324  		v.AddArg(v0)
  1325  		v3 := b.NewValue0(v.Line, OpNeq32, config.fe.TypeBool())
  1326  		v4 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
  1327  		v4.AddArg(x)
  1328  		v3.AddArg(v4)
  1329  		v5 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
  1330  		v5.AddArg(y)
  1331  		v3.AddArg(v5)
  1332  		v.AddArg(v3)
  1333  		return true
  1334  	}
  1335  }
  1336  func rewriteValuedec64_OpOr64(v *Value, config *Config) bool {
  1337  	b := v.Block
  1338  	_ = b
  1339  	// match: (Or64 x y)
  1340  	// cond:
  1341  	// result: (Int64Make 		(Or32 <config.fe.TypeUInt32()> (Int64Hi x) (Int64Hi y)) 		(Or32 <config.fe.TypeUInt32()> (Int64Lo x) (Int64Lo y)))
  1342  	for {
  1343  		x := v.Args[0]
  1344  		y := v.Args[1]
  1345  		v.reset(OpInt64Make)
  1346  		v0 := b.NewValue0(v.Line, OpOr32, config.fe.TypeUInt32())
  1347  		v1 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
  1348  		v1.AddArg(x)
  1349  		v0.AddArg(v1)
  1350  		v2 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
  1351  		v2.AddArg(y)
  1352  		v0.AddArg(v2)
  1353  		v.AddArg(v0)
  1354  		v3 := b.NewValue0(v.Line, OpOr32, config.fe.TypeUInt32())
  1355  		v4 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
  1356  		v4.AddArg(x)
  1357  		v3.AddArg(v4)
  1358  		v5 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
  1359  		v5.AddArg(y)
  1360  		v3.AddArg(v5)
  1361  		v.AddArg(v3)
  1362  		return true
  1363  	}
  1364  }
  1365  func rewriteValuedec64_OpRsh16Ux64(v *Value, config *Config) bool {
  1366  	b := v.Block
  1367  	_ = b
  1368  	// match: (Rsh16Ux64 _ (Int64Make (Const32 [c]) _))
  1369  	// cond: c != 0
  1370  	// result: (Const32 [0])
  1371  	for {
  1372  		v_1 := v.Args[1]
  1373  		if v_1.Op != OpInt64Make {
  1374  			break
  1375  		}
  1376  		v_1_0 := v_1.Args[0]
  1377  		if v_1_0.Op != OpConst32 {
  1378  			break
  1379  		}
  1380  		c := v_1_0.AuxInt
  1381  		if !(c != 0) {
  1382  			break
  1383  		}
  1384  		v.reset(OpConst32)
  1385  		v.AuxInt = 0
  1386  		return true
  1387  	}
  1388  	// match: (Rsh16Ux64 x (Int64Make (Const32 [0]) lo))
  1389  	// cond:
  1390  	// result: (Rsh16Ux32 x lo)
  1391  	for {
  1392  		x := v.Args[0]
  1393  		v_1 := v.Args[1]
  1394  		if v_1.Op != OpInt64Make {
  1395  			break
  1396  		}
  1397  		v_1_0 := v_1.Args[0]
  1398  		if v_1_0.Op != OpConst32 {
  1399  			break
  1400  		}
  1401  		if v_1_0.AuxInt != 0 {
  1402  			break
  1403  		}
  1404  		lo := v_1.Args[1]
  1405  		v.reset(OpRsh16Ux32)
  1406  		v.AddArg(x)
  1407  		v.AddArg(lo)
  1408  		return true
  1409  	}
  1410  	// match: (Rsh16Ux64 x (Int64Make hi lo))
  1411  	// cond: hi.Op != OpConst32
  1412  	// result: (Rsh16Ux32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo))
  1413  	for {
  1414  		x := v.Args[0]
  1415  		v_1 := v.Args[1]
  1416  		if v_1.Op != OpInt64Make {
  1417  			break
  1418  		}
  1419  		hi := v_1.Args[0]
  1420  		lo := v_1.Args[1]
  1421  		if !(hi.Op != OpConst32) {
  1422  			break
  1423  		}
  1424  		v.reset(OpRsh16Ux32)
  1425  		v.AddArg(x)
  1426  		v0 := b.NewValue0(v.Line, OpOr32, config.fe.TypeUInt32())
  1427  		v1 := b.NewValue0(v.Line, OpZeromask, config.fe.TypeUInt32())
  1428  		v1.AddArg(hi)
  1429  		v0.AddArg(v1)
  1430  		v0.AddArg(lo)
  1431  		v.AddArg(v0)
  1432  		return true
  1433  	}
  1434  	return false
  1435  }
  1436  func rewriteValuedec64_OpRsh16x64(v *Value, config *Config) bool {
  1437  	b := v.Block
  1438  	_ = b
  1439  	// match: (Rsh16x64 x (Int64Make (Const32 [c]) _))
  1440  	// cond: c != 0
  1441  	// result: (Signmask (SignExt16to32 x))
  1442  	for {
  1443  		x := v.Args[0]
  1444  		v_1 := v.Args[1]
  1445  		if v_1.Op != OpInt64Make {
  1446  			break
  1447  		}
  1448  		v_1_0 := v_1.Args[0]
  1449  		if v_1_0.Op != OpConst32 {
  1450  			break
  1451  		}
  1452  		c := v_1_0.AuxInt
  1453  		if !(c != 0) {
  1454  			break
  1455  		}
  1456  		v.reset(OpSignmask)
  1457  		v0 := b.NewValue0(v.Line, OpSignExt16to32, config.fe.TypeInt32())
  1458  		v0.AddArg(x)
  1459  		v.AddArg(v0)
  1460  		return true
  1461  	}
  1462  	// match: (Rsh16x64 x (Int64Make (Const32 [0]) lo))
  1463  	// cond:
  1464  	// result: (Rsh16x32 x lo)
  1465  	for {
  1466  		x := v.Args[0]
  1467  		v_1 := v.Args[1]
  1468  		if v_1.Op != OpInt64Make {
  1469  			break
  1470  		}
  1471  		v_1_0 := v_1.Args[0]
  1472  		if v_1_0.Op != OpConst32 {
  1473  			break
  1474  		}
  1475  		if v_1_0.AuxInt != 0 {
  1476  			break
  1477  		}
  1478  		lo := v_1.Args[1]
  1479  		v.reset(OpRsh16x32)
  1480  		v.AddArg(x)
  1481  		v.AddArg(lo)
  1482  		return true
  1483  	}
  1484  	// match: (Rsh16x64 x (Int64Make hi lo))
  1485  	// cond: hi.Op != OpConst32
  1486  	// result: (Rsh16x32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo))
  1487  	for {
  1488  		x := v.Args[0]
  1489  		v_1 := v.Args[1]
  1490  		if v_1.Op != OpInt64Make {
  1491  			break
  1492  		}
  1493  		hi := v_1.Args[0]
  1494  		lo := v_1.Args[1]
  1495  		if !(hi.Op != OpConst32) {
  1496  			break
  1497  		}
  1498  		v.reset(OpRsh16x32)
  1499  		v.AddArg(x)
  1500  		v0 := b.NewValue0(v.Line, OpOr32, config.fe.TypeUInt32())
  1501  		v1 := b.NewValue0(v.Line, OpZeromask, config.fe.TypeUInt32())
  1502  		v1.AddArg(hi)
  1503  		v0.AddArg(v1)
  1504  		v0.AddArg(lo)
  1505  		v.AddArg(v0)
  1506  		return true
  1507  	}
  1508  	return false
  1509  }
  1510  func rewriteValuedec64_OpRsh32Ux64(v *Value, config *Config) bool {
  1511  	b := v.Block
  1512  	_ = b
  1513  	// match: (Rsh32Ux64 _ (Int64Make (Const32 [c]) _))
  1514  	// cond: c != 0
  1515  	// result: (Const32 [0])
  1516  	for {
  1517  		v_1 := v.Args[1]
  1518  		if v_1.Op != OpInt64Make {
  1519  			break
  1520  		}
  1521  		v_1_0 := v_1.Args[0]
  1522  		if v_1_0.Op != OpConst32 {
  1523  			break
  1524  		}
  1525  		c := v_1_0.AuxInt
  1526  		if !(c != 0) {
  1527  			break
  1528  		}
  1529  		v.reset(OpConst32)
  1530  		v.AuxInt = 0
  1531  		return true
  1532  	}
  1533  	// match: (Rsh32Ux64 x (Int64Make (Const32 [0]) lo))
  1534  	// cond:
  1535  	// result: (Rsh32Ux32 x lo)
  1536  	for {
  1537  		x := v.Args[0]
  1538  		v_1 := v.Args[1]
  1539  		if v_1.Op != OpInt64Make {
  1540  			break
  1541  		}
  1542  		v_1_0 := v_1.Args[0]
  1543  		if v_1_0.Op != OpConst32 {
  1544  			break
  1545  		}
  1546  		if v_1_0.AuxInt != 0 {
  1547  			break
  1548  		}
  1549  		lo := v_1.Args[1]
  1550  		v.reset(OpRsh32Ux32)
  1551  		v.AddArg(x)
  1552  		v.AddArg(lo)
  1553  		return true
  1554  	}
  1555  	// match: (Rsh32Ux64 x (Int64Make hi lo))
  1556  	// cond: hi.Op != OpConst32
  1557  	// result: (Rsh32Ux32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo))
  1558  	for {
  1559  		x := v.Args[0]
  1560  		v_1 := v.Args[1]
  1561  		if v_1.Op != OpInt64Make {
  1562  			break
  1563  		}
  1564  		hi := v_1.Args[0]
  1565  		lo := v_1.Args[1]
  1566  		if !(hi.Op != OpConst32) {
  1567  			break
  1568  		}
  1569  		v.reset(OpRsh32Ux32)
  1570  		v.AddArg(x)
  1571  		v0 := b.NewValue0(v.Line, OpOr32, config.fe.TypeUInt32())
  1572  		v1 := b.NewValue0(v.Line, OpZeromask, config.fe.TypeUInt32())
  1573  		v1.AddArg(hi)
  1574  		v0.AddArg(v1)
  1575  		v0.AddArg(lo)
  1576  		v.AddArg(v0)
  1577  		return true
  1578  	}
  1579  	return false
  1580  }
  1581  func rewriteValuedec64_OpRsh32x64(v *Value, config *Config) bool {
  1582  	b := v.Block
  1583  	_ = b
  1584  	// match: (Rsh32x64 x (Int64Make (Const32 [c]) _))
  1585  	// cond: c != 0
  1586  	// result: (Signmask x)
  1587  	for {
  1588  		x := v.Args[0]
  1589  		v_1 := v.Args[1]
  1590  		if v_1.Op != OpInt64Make {
  1591  			break
  1592  		}
  1593  		v_1_0 := v_1.Args[0]
  1594  		if v_1_0.Op != OpConst32 {
  1595  			break
  1596  		}
  1597  		c := v_1_0.AuxInt
  1598  		if !(c != 0) {
  1599  			break
  1600  		}
  1601  		v.reset(OpSignmask)
  1602  		v.AddArg(x)
  1603  		return true
  1604  	}
  1605  	// match: (Rsh32x64 x (Int64Make (Const32 [0]) lo))
  1606  	// cond:
  1607  	// result: (Rsh32x32 x lo)
  1608  	for {
  1609  		x := v.Args[0]
  1610  		v_1 := v.Args[1]
  1611  		if v_1.Op != OpInt64Make {
  1612  			break
  1613  		}
  1614  		v_1_0 := v_1.Args[0]
  1615  		if v_1_0.Op != OpConst32 {
  1616  			break
  1617  		}
  1618  		if v_1_0.AuxInt != 0 {
  1619  			break
  1620  		}
  1621  		lo := v_1.Args[1]
  1622  		v.reset(OpRsh32x32)
  1623  		v.AddArg(x)
  1624  		v.AddArg(lo)
  1625  		return true
  1626  	}
  1627  	// match: (Rsh32x64 x (Int64Make hi lo))
  1628  	// cond: hi.Op != OpConst32
  1629  	// result: (Rsh32x32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo))
  1630  	for {
  1631  		x := v.Args[0]
  1632  		v_1 := v.Args[1]
  1633  		if v_1.Op != OpInt64Make {
  1634  			break
  1635  		}
  1636  		hi := v_1.Args[0]
  1637  		lo := v_1.Args[1]
  1638  		if !(hi.Op != OpConst32) {
  1639  			break
  1640  		}
  1641  		v.reset(OpRsh32x32)
  1642  		v.AddArg(x)
  1643  		v0 := b.NewValue0(v.Line, OpOr32, config.fe.TypeUInt32())
  1644  		v1 := b.NewValue0(v.Line, OpZeromask, config.fe.TypeUInt32())
  1645  		v1.AddArg(hi)
  1646  		v0.AddArg(v1)
  1647  		v0.AddArg(lo)
  1648  		v.AddArg(v0)
  1649  		return true
  1650  	}
  1651  	return false
  1652  }
  1653  func rewriteValuedec64_OpRsh64Ux16(v *Value, config *Config) bool {
  1654  	b := v.Block
  1655  	_ = b
  1656  	// match: (Rsh64Ux16 (Int64Make hi lo) s)
  1657  	// cond:
  1658  	// result: (Int64Make 		(Rsh32Ux16 <config.fe.TypeUInt32()> hi s) 		(Or32 <config.fe.TypeUInt32()> 			(Or32 <config.fe.TypeUInt32()> 				(Rsh32Ux16 <config.fe.TypeUInt32()> lo s) 				(Lsh32x16 <config.fe.TypeUInt32()> 					hi 					(Sub16 <config.fe.TypeUInt16()> (Const16 <config.fe.TypeUInt16()> [32]) s))) 			(Rsh32Ux16 <config.fe.TypeUInt32()> 				hi 				(Sub16 <config.fe.TypeUInt16()> s (Const16 <config.fe.TypeUInt16()> [32])))))
  1659  	for {
  1660  		v_0 := v.Args[0]
  1661  		if v_0.Op != OpInt64Make {
  1662  			break
  1663  		}
  1664  		hi := v_0.Args[0]
  1665  		lo := v_0.Args[1]
  1666  		s := v.Args[1]
  1667  		v.reset(OpInt64Make)
  1668  		v0 := b.NewValue0(v.Line, OpRsh32Ux16, config.fe.TypeUInt32())
  1669  		v0.AddArg(hi)
  1670  		v0.AddArg(s)
  1671  		v.AddArg(v0)
  1672  		v1 := b.NewValue0(v.Line, OpOr32, config.fe.TypeUInt32())
  1673  		v2 := b.NewValue0(v.Line, OpOr32, config.fe.TypeUInt32())
  1674  		v3 := b.NewValue0(v.Line, OpRsh32Ux16, config.fe.TypeUInt32())
  1675  		v3.AddArg(lo)
  1676  		v3.AddArg(s)
  1677  		v2.AddArg(v3)
  1678  		v4 := b.NewValue0(v.Line, OpLsh32x16, config.fe.TypeUInt32())
  1679  		v4.AddArg(hi)
  1680  		v5 := b.NewValue0(v.Line, OpSub16, config.fe.TypeUInt16())
  1681  		v6 := b.NewValue0(v.Line, OpConst16, config.fe.TypeUInt16())
  1682  		v6.AuxInt = 32
  1683  		v5.AddArg(v6)
  1684  		v5.AddArg(s)
  1685  		v4.AddArg(v5)
  1686  		v2.AddArg(v4)
  1687  		v1.AddArg(v2)
  1688  		v7 := b.NewValue0(v.Line, OpRsh32Ux16, config.fe.TypeUInt32())
  1689  		v7.AddArg(hi)
  1690  		v8 := b.NewValue0(v.Line, OpSub16, config.fe.TypeUInt16())
  1691  		v8.AddArg(s)
  1692  		v9 := b.NewValue0(v.Line, OpConst16, config.fe.TypeUInt16())
  1693  		v9.AuxInt = 32
  1694  		v8.AddArg(v9)
  1695  		v7.AddArg(v8)
  1696  		v1.AddArg(v7)
  1697  		v.AddArg(v1)
  1698  		return true
  1699  	}
  1700  	return false
  1701  }
  1702  func rewriteValuedec64_OpRsh64Ux32(v *Value, config *Config) bool {
  1703  	b := v.Block
  1704  	_ = b
  1705  	// match: (Rsh64Ux32 (Int64Make hi lo) s)
  1706  	// cond:
  1707  	// result: (Int64Make 		(Rsh32Ux32 <config.fe.TypeUInt32()> hi s) 		(Or32 <config.fe.TypeUInt32()> 			(Or32 <config.fe.TypeUInt32()> 				(Rsh32Ux32 <config.fe.TypeUInt32()> lo s) 				(Lsh32x32 <config.fe.TypeUInt32()> 					hi 					(Sub32 <config.fe.TypeUInt32()> (Const32 <config.fe.TypeUInt32()> [32]) s))) 			(Rsh32Ux32 <config.fe.TypeUInt32()> 				hi 				(Sub32 <config.fe.TypeUInt32()> s (Const32 <config.fe.TypeUInt32()> [32])))))
  1708  	for {
  1709  		v_0 := v.Args[0]
  1710  		if v_0.Op != OpInt64Make {
  1711  			break
  1712  		}
  1713  		hi := v_0.Args[0]
  1714  		lo := v_0.Args[1]
  1715  		s := v.Args[1]
  1716  		v.reset(OpInt64Make)
  1717  		v0 := b.NewValue0(v.Line, OpRsh32Ux32, config.fe.TypeUInt32())
  1718  		v0.AddArg(hi)
  1719  		v0.AddArg(s)
  1720  		v.AddArg(v0)
  1721  		v1 := b.NewValue0(v.Line, OpOr32, config.fe.TypeUInt32())
  1722  		v2 := b.NewValue0(v.Line, OpOr32, config.fe.TypeUInt32())
  1723  		v3 := b.NewValue0(v.Line, OpRsh32Ux32, config.fe.TypeUInt32())
  1724  		v3.AddArg(lo)
  1725  		v3.AddArg(s)
  1726  		v2.AddArg(v3)
  1727  		v4 := b.NewValue0(v.Line, OpLsh32x32, config.fe.TypeUInt32())
  1728  		v4.AddArg(hi)
  1729  		v5 := b.NewValue0(v.Line, OpSub32, config.fe.TypeUInt32())
  1730  		v6 := b.NewValue0(v.Line, OpConst32, config.fe.TypeUInt32())
  1731  		v6.AuxInt = 32
  1732  		v5.AddArg(v6)
  1733  		v5.AddArg(s)
  1734  		v4.AddArg(v5)
  1735  		v2.AddArg(v4)
  1736  		v1.AddArg(v2)
  1737  		v7 := b.NewValue0(v.Line, OpRsh32Ux32, config.fe.TypeUInt32())
  1738  		v7.AddArg(hi)
  1739  		v8 := b.NewValue0(v.Line, OpSub32, config.fe.TypeUInt32())
  1740  		v8.AddArg(s)
  1741  		v9 := b.NewValue0(v.Line, OpConst32, config.fe.TypeUInt32())
  1742  		v9.AuxInt = 32
  1743  		v8.AddArg(v9)
  1744  		v7.AddArg(v8)
  1745  		v1.AddArg(v7)
  1746  		v.AddArg(v1)
  1747  		return true
  1748  	}
  1749  	return false
  1750  }
  1751  func rewriteValuedec64_OpRsh64Ux64(v *Value, config *Config) bool {
  1752  	b := v.Block
  1753  	_ = b
  1754  	// match: (Rsh64Ux64 _ (Int64Make (Const32 [c]) _))
  1755  	// cond: c != 0
  1756  	// result: (Const64 [0])
  1757  	for {
  1758  		v_1 := v.Args[1]
  1759  		if v_1.Op != OpInt64Make {
  1760  			break
  1761  		}
  1762  		v_1_0 := v_1.Args[0]
  1763  		if v_1_0.Op != OpConst32 {
  1764  			break
  1765  		}
  1766  		c := v_1_0.AuxInt
  1767  		if !(c != 0) {
  1768  			break
  1769  		}
  1770  		v.reset(OpConst64)
  1771  		v.AuxInt = 0
  1772  		return true
  1773  	}
  1774  	// match: (Rsh64Ux64 x (Int64Make (Const32 [0]) lo))
  1775  	// cond:
  1776  	// result: (Rsh64Ux32 x lo)
  1777  	for {
  1778  		x := v.Args[0]
  1779  		v_1 := v.Args[1]
  1780  		if v_1.Op != OpInt64Make {
  1781  			break
  1782  		}
  1783  		v_1_0 := v_1.Args[0]
  1784  		if v_1_0.Op != OpConst32 {
  1785  			break
  1786  		}
  1787  		if v_1_0.AuxInt != 0 {
  1788  			break
  1789  		}
  1790  		lo := v_1.Args[1]
  1791  		v.reset(OpRsh64Ux32)
  1792  		v.AddArg(x)
  1793  		v.AddArg(lo)
  1794  		return true
  1795  	}
  1796  	// match: (Rsh64Ux64 x (Int64Make hi lo))
  1797  	// cond: hi.Op != OpConst32
  1798  	// result: (Rsh64Ux32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo))
  1799  	for {
  1800  		x := v.Args[0]
  1801  		v_1 := v.Args[1]
  1802  		if v_1.Op != OpInt64Make {
  1803  			break
  1804  		}
  1805  		hi := v_1.Args[0]
  1806  		lo := v_1.Args[1]
  1807  		if !(hi.Op != OpConst32) {
  1808  			break
  1809  		}
  1810  		v.reset(OpRsh64Ux32)
  1811  		v.AddArg(x)
  1812  		v0 := b.NewValue0(v.Line, OpOr32, config.fe.TypeUInt32())
  1813  		v1 := b.NewValue0(v.Line, OpZeromask, config.fe.TypeUInt32())
  1814  		v1.AddArg(hi)
  1815  		v0.AddArg(v1)
  1816  		v0.AddArg(lo)
  1817  		v.AddArg(v0)
  1818  		return true
  1819  	}
  1820  	return false
  1821  }
  1822  func rewriteValuedec64_OpRsh64Ux8(v *Value, config *Config) bool {
  1823  	b := v.Block
  1824  	_ = b
  1825  	// match: (Rsh64Ux8 (Int64Make hi lo) s)
  1826  	// cond:
  1827  	// result: (Int64Make 		(Rsh32Ux8 <config.fe.TypeUInt32()> hi s) 		(Or32 <config.fe.TypeUInt32()> 			(Or32 <config.fe.TypeUInt32()> 				(Rsh32Ux8 <config.fe.TypeUInt32()> lo s) 				(Lsh32x8 <config.fe.TypeUInt32()> 					hi 					(Sub8 <config.fe.TypeUInt8()> (Const8 <config.fe.TypeUInt8()> [32]) s))) 			(Rsh32Ux8 <config.fe.TypeUInt32()> 				hi 				(Sub8 <config.fe.TypeUInt8()> s (Const8 <config.fe.TypeUInt8()> [32])))))
  1828  	for {
  1829  		v_0 := v.Args[0]
  1830  		if v_0.Op != OpInt64Make {
  1831  			break
  1832  		}
  1833  		hi := v_0.Args[0]
  1834  		lo := v_0.Args[1]
  1835  		s := v.Args[1]
  1836  		v.reset(OpInt64Make)
  1837  		v0 := b.NewValue0(v.Line, OpRsh32Ux8, config.fe.TypeUInt32())
  1838  		v0.AddArg(hi)
  1839  		v0.AddArg(s)
  1840  		v.AddArg(v0)
  1841  		v1 := b.NewValue0(v.Line, OpOr32, config.fe.TypeUInt32())
  1842  		v2 := b.NewValue0(v.Line, OpOr32, config.fe.TypeUInt32())
  1843  		v3 := b.NewValue0(v.Line, OpRsh32Ux8, config.fe.TypeUInt32())
  1844  		v3.AddArg(lo)
  1845  		v3.AddArg(s)
  1846  		v2.AddArg(v3)
  1847  		v4 := b.NewValue0(v.Line, OpLsh32x8, config.fe.TypeUInt32())
  1848  		v4.AddArg(hi)
  1849  		v5 := b.NewValue0(v.Line, OpSub8, config.fe.TypeUInt8())
  1850  		v6 := b.NewValue0(v.Line, OpConst8, config.fe.TypeUInt8())
  1851  		v6.AuxInt = 32
  1852  		v5.AddArg(v6)
  1853  		v5.AddArg(s)
  1854  		v4.AddArg(v5)
  1855  		v2.AddArg(v4)
  1856  		v1.AddArg(v2)
  1857  		v7 := b.NewValue0(v.Line, OpRsh32Ux8, config.fe.TypeUInt32())
  1858  		v7.AddArg(hi)
  1859  		v8 := b.NewValue0(v.Line, OpSub8, config.fe.TypeUInt8())
  1860  		v8.AddArg(s)
  1861  		v9 := b.NewValue0(v.Line, OpConst8, config.fe.TypeUInt8())
  1862  		v9.AuxInt = 32
  1863  		v8.AddArg(v9)
  1864  		v7.AddArg(v8)
  1865  		v1.AddArg(v7)
  1866  		v.AddArg(v1)
  1867  		return true
  1868  	}
  1869  	return false
  1870  }
  1871  func rewriteValuedec64_OpRsh64x16(v *Value, config *Config) bool {
  1872  	b := v.Block
  1873  	_ = b
  1874  	// match: (Rsh64x16 (Int64Make hi lo) s)
  1875  	// cond:
  1876  	// result: (Int64Make 		(Rsh32x16 <config.fe.TypeUInt32()> hi s) 		(Or32 <config.fe.TypeUInt32()> 			(Or32 <config.fe.TypeUInt32()> 				(Rsh32Ux16 <config.fe.TypeUInt32()> lo s) 				(Lsh32x16 <config.fe.TypeUInt32()> 					hi 					(Sub16 <config.fe.TypeUInt16()> (Const16 <config.fe.TypeUInt16()> [32]) s))) 			(And32 <config.fe.TypeUInt32()> 				(Rsh32x16 <config.fe.TypeUInt32()> 					hi 					(Sub16 <config.fe.TypeUInt16()> s (Const16 <config.fe.TypeUInt16()> [32]))) 				(Zeromask 					(ZeroExt16to32 						(Rsh16Ux32 <config.fe.TypeUInt16()> s (Const32 <config.fe.TypeUInt32()> [5])))))))
  1877  	for {
  1878  		v_0 := v.Args[0]
  1879  		if v_0.Op != OpInt64Make {
  1880  			break
  1881  		}
  1882  		hi := v_0.Args[0]
  1883  		lo := v_0.Args[1]
  1884  		s := v.Args[1]
  1885  		v.reset(OpInt64Make)
  1886  		v0 := b.NewValue0(v.Line, OpRsh32x16, config.fe.TypeUInt32())
  1887  		v0.AddArg(hi)
  1888  		v0.AddArg(s)
  1889  		v.AddArg(v0)
  1890  		v1 := b.NewValue0(v.Line, OpOr32, config.fe.TypeUInt32())
  1891  		v2 := b.NewValue0(v.Line, OpOr32, config.fe.TypeUInt32())
  1892  		v3 := b.NewValue0(v.Line, OpRsh32Ux16, config.fe.TypeUInt32())
  1893  		v3.AddArg(lo)
  1894  		v3.AddArg(s)
  1895  		v2.AddArg(v3)
  1896  		v4 := b.NewValue0(v.Line, OpLsh32x16, config.fe.TypeUInt32())
  1897  		v4.AddArg(hi)
  1898  		v5 := b.NewValue0(v.Line, OpSub16, config.fe.TypeUInt16())
  1899  		v6 := b.NewValue0(v.Line, OpConst16, config.fe.TypeUInt16())
  1900  		v6.AuxInt = 32
  1901  		v5.AddArg(v6)
  1902  		v5.AddArg(s)
  1903  		v4.AddArg(v5)
  1904  		v2.AddArg(v4)
  1905  		v1.AddArg(v2)
  1906  		v7 := b.NewValue0(v.Line, OpAnd32, config.fe.TypeUInt32())
  1907  		v8 := b.NewValue0(v.Line, OpRsh32x16, config.fe.TypeUInt32())
  1908  		v8.AddArg(hi)
  1909  		v9 := b.NewValue0(v.Line, OpSub16, config.fe.TypeUInt16())
  1910  		v9.AddArg(s)
  1911  		v10 := b.NewValue0(v.Line, OpConst16, config.fe.TypeUInt16())
  1912  		v10.AuxInt = 32
  1913  		v9.AddArg(v10)
  1914  		v8.AddArg(v9)
  1915  		v7.AddArg(v8)
  1916  		v11 := b.NewValue0(v.Line, OpZeromask, config.fe.TypeUInt32())
  1917  		v12 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32())
  1918  		v13 := b.NewValue0(v.Line, OpRsh16Ux32, config.fe.TypeUInt16())
  1919  		v13.AddArg(s)
  1920  		v14 := b.NewValue0(v.Line, OpConst32, config.fe.TypeUInt32())
  1921  		v14.AuxInt = 5
  1922  		v13.AddArg(v14)
  1923  		v12.AddArg(v13)
  1924  		v11.AddArg(v12)
  1925  		v7.AddArg(v11)
  1926  		v1.AddArg(v7)
  1927  		v.AddArg(v1)
  1928  		return true
  1929  	}
  1930  	return false
  1931  }
  1932  func rewriteValuedec64_OpRsh64x32(v *Value, config *Config) bool {
  1933  	b := v.Block
  1934  	_ = b
  1935  	// match: (Rsh64x32 (Int64Make hi lo) s)
  1936  	// cond:
  1937  	// result: (Int64Make 		(Rsh32x32 <config.fe.TypeUInt32()> hi s) 		(Or32 <config.fe.TypeUInt32()> 			(Or32 <config.fe.TypeUInt32()> 				(Rsh32Ux32 <config.fe.TypeUInt32()> lo s) 				(Lsh32x32 <config.fe.TypeUInt32()> 					hi 					(Sub32 <config.fe.TypeUInt32()> (Const32 <config.fe.TypeUInt32()> [32]) s))) 			(And32 <config.fe.TypeUInt32()> 				(Rsh32x32 <config.fe.TypeUInt32()> 					hi 					(Sub32 <config.fe.TypeUInt32()> s (Const32 <config.fe.TypeUInt32()> [32]))) 				(Zeromask 					(Rsh32Ux32 <config.fe.TypeUInt32()> s (Const32 <config.fe.TypeUInt32()> [5]))))))
  1938  	for {
  1939  		v_0 := v.Args[0]
  1940  		if v_0.Op != OpInt64Make {
  1941  			break
  1942  		}
  1943  		hi := v_0.Args[0]
  1944  		lo := v_0.Args[1]
  1945  		s := v.Args[1]
  1946  		v.reset(OpInt64Make)
  1947  		v0 := b.NewValue0(v.Line, OpRsh32x32, config.fe.TypeUInt32())
  1948  		v0.AddArg(hi)
  1949  		v0.AddArg(s)
  1950  		v.AddArg(v0)
  1951  		v1 := b.NewValue0(v.Line, OpOr32, config.fe.TypeUInt32())
  1952  		v2 := b.NewValue0(v.Line, OpOr32, config.fe.TypeUInt32())
  1953  		v3 := b.NewValue0(v.Line, OpRsh32Ux32, config.fe.TypeUInt32())
  1954  		v3.AddArg(lo)
  1955  		v3.AddArg(s)
  1956  		v2.AddArg(v3)
  1957  		v4 := b.NewValue0(v.Line, OpLsh32x32, config.fe.TypeUInt32())
  1958  		v4.AddArg(hi)
  1959  		v5 := b.NewValue0(v.Line, OpSub32, config.fe.TypeUInt32())
  1960  		v6 := b.NewValue0(v.Line, OpConst32, config.fe.TypeUInt32())
  1961  		v6.AuxInt = 32
  1962  		v5.AddArg(v6)
  1963  		v5.AddArg(s)
  1964  		v4.AddArg(v5)
  1965  		v2.AddArg(v4)
  1966  		v1.AddArg(v2)
  1967  		v7 := b.NewValue0(v.Line, OpAnd32, config.fe.TypeUInt32())
  1968  		v8 := b.NewValue0(v.Line, OpRsh32x32, config.fe.TypeUInt32())
  1969  		v8.AddArg(hi)
  1970  		v9 := b.NewValue0(v.Line, OpSub32, config.fe.TypeUInt32())
  1971  		v9.AddArg(s)
  1972  		v10 := b.NewValue0(v.Line, OpConst32, config.fe.TypeUInt32())
  1973  		v10.AuxInt = 32
  1974  		v9.AddArg(v10)
  1975  		v8.AddArg(v9)
  1976  		v7.AddArg(v8)
  1977  		v11 := b.NewValue0(v.Line, OpZeromask, config.fe.TypeUInt32())
  1978  		v12 := b.NewValue0(v.Line, OpRsh32Ux32, config.fe.TypeUInt32())
  1979  		v12.AddArg(s)
  1980  		v13 := b.NewValue0(v.Line, OpConst32, config.fe.TypeUInt32())
  1981  		v13.AuxInt = 5
  1982  		v12.AddArg(v13)
  1983  		v11.AddArg(v12)
  1984  		v7.AddArg(v11)
  1985  		v1.AddArg(v7)
  1986  		v.AddArg(v1)
  1987  		return true
  1988  	}
  1989  	return false
  1990  }
  1991  func rewriteValuedec64_OpRsh64x64(v *Value, config *Config) bool {
  1992  	b := v.Block
  1993  	_ = b
  1994  	// match: (Rsh64x64 x (Int64Make (Const32 [c]) _))
  1995  	// cond: c != 0
  1996  	// result: (Int64Make (Signmask (Int64Hi x)) (Signmask (Int64Hi x)))
  1997  	for {
  1998  		x := v.Args[0]
  1999  		v_1 := v.Args[1]
  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 := v_1_0.AuxInt
  2008  		if !(c != 0) {
  2009  			break
  2010  		}
  2011  		v.reset(OpInt64Make)
  2012  		v0 := b.NewValue0(v.Line, OpSignmask, config.fe.TypeInt32())
  2013  		v1 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
  2014  		v1.AddArg(x)
  2015  		v0.AddArg(v1)
  2016  		v.AddArg(v0)
  2017  		v2 := b.NewValue0(v.Line, OpSignmask, config.fe.TypeInt32())
  2018  		v3 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
  2019  		v3.AddArg(x)
  2020  		v2.AddArg(v3)
  2021  		v.AddArg(v2)
  2022  		return true
  2023  	}
  2024  	// match: (Rsh64x64 x (Int64Make (Const32 [0]) lo))
  2025  	// cond:
  2026  	// result: (Rsh64x32 x lo)
  2027  	for {
  2028  		x := v.Args[0]
  2029  		v_1 := v.Args[1]
  2030  		if v_1.Op != OpInt64Make {
  2031  			break
  2032  		}
  2033  		v_1_0 := v_1.Args[0]
  2034  		if v_1_0.Op != OpConst32 {
  2035  			break
  2036  		}
  2037  		if v_1_0.AuxInt != 0 {
  2038  			break
  2039  		}
  2040  		lo := v_1.Args[1]
  2041  		v.reset(OpRsh64x32)
  2042  		v.AddArg(x)
  2043  		v.AddArg(lo)
  2044  		return true
  2045  	}
  2046  	// match: (Rsh64x64 x (Int64Make hi lo))
  2047  	// cond: hi.Op != OpConst32
  2048  	// result: (Rsh64x32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo))
  2049  	for {
  2050  		x := v.Args[0]
  2051  		v_1 := v.Args[1]
  2052  		if v_1.Op != OpInt64Make {
  2053  			break
  2054  		}
  2055  		hi := v_1.Args[0]
  2056  		lo := v_1.Args[1]
  2057  		if !(hi.Op != OpConst32) {
  2058  			break
  2059  		}
  2060  		v.reset(OpRsh64x32)
  2061  		v.AddArg(x)
  2062  		v0 := b.NewValue0(v.Line, OpOr32, config.fe.TypeUInt32())
  2063  		v1 := b.NewValue0(v.Line, OpZeromask, config.fe.TypeUInt32())
  2064  		v1.AddArg(hi)
  2065  		v0.AddArg(v1)
  2066  		v0.AddArg(lo)
  2067  		v.AddArg(v0)
  2068  		return true
  2069  	}
  2070  	return false
  2071  }
  2072  func rewriteValuedec64_OpRsh64x8(v *Value, config *Config) bool {
  2073  	b := v.Block
  2074  	_ = b
  2075  	// match: (Rsh64x8 (Int64Make hi lo) s)
  2076  	// cond:
  2077  	// result: (Int64Make 		(Rsh32x8 <config.fe.TypeUInt32()> hi s) 		(Or32 <config.fe.TypeUInt32()> 			(Or32 <config.fe.TypeUInt32()> 				(Rsh32Ux8 <config.fe.TypeUInt32()> lo s) 				(Lsh32x8 <config.fe.TypeUInt32()> 					hi 					(Sub8 <config.fe.TypeUInt8()> (Const8 <config.fe.TypeUInt8()> [32]) s))) 			(And32 <config.fe.TypeUInt32()> 				(Rsh32x8 <config.fe.TypeUInt32()> 					hi 					(Sub8 <config.fe.TypeUInt8()> s (Const8 <config.fe.TypeUInt8()> [32]))) 				(Zeromask 					(ZeroExt8to32 						(Rsh8Ux32 <config.fe.TypeUInt8()> s (Const32 <config.fe.TypeUInt32()> [5])))))))
  2078  	for {
  2079  		v_0 := v.Args[0]
  2080  		if v_0.Op != OpInt64Make {
  2081  			break
  2082  		}
  2083  		hi := v_0.Args[0]
  2084  		lo := v_0.Args[1]
  2085  		s := v.Args[1]
  2086  		v.reset(OpInt64Make)
  2087  		v0 := b.NewValue0(v.Line, OpRsh32x8, config.fe.TypeUInt32())
  2088  		v0.AddArg(hi)
  2089  		v0.AddArg(s)
  2090  		v.AddArg(v0)
  2091  		v1 := b.NewValue0(v.Line, OpOr32, config.fe.TypeUInt32())
  2092  		v2 := b.NewValue0(v.Line, OpOr32, config.fe.TypeUInt32())
  2093  		v3 := b.NewValue0(v.Line, OpRsh32Ux8, config.fe.TypeUInt32())
  2094  		v3.AddArg(lo)
  2095  		v3.AddArg(s)
  2096  		v2.AddArg(v3)
  2097  		v4 := b.NewValue0(v.Line, OpLsh32x8, config.fe.TypeUInt32())
  2098  		v4.AddArg(hi)
  2099  		v5 := b.NewValue0(v.Line, OpSub8, config.fe.TypeUInt8())
  2100  		v6 := b.NewValue0(v.Line, OpConst8, config.fe.TypeUInt8())
  2101  		v6.AuxInt = 32
  2102  		v5.AddArg(v6)
  2103  		v5.AddArg(s)
  2104  		v4.AddArg(v5)
  2105  		v2.AddArg(v4)
  2106  		v1.AddArg(v2)
  2107  		v7 := b.NewValue0(v.Line, OpAnd32, config.fe.TypeUInt32())
  2108  		v8 := b.NewValue0(v.Line, OpRsh32x8, config.fe.TypeUInt32())
  2109  		v8.AddArg(hi)
  2110  		v9 := b.NewValue0(v.Line, OpSub8, config.fe.TypeUInt8())
  2111  		v9.AddArg(s)
  2112  		v10 := b.NewValue0(v.Line, OpConst8, config.fe.TypeUInt8())
  2113  		v10.AuxInt = 32
  2114  		v9.AddArg(v10)
  2115  		v8.AddArg(v9)
  2116  		v7.AddArg(v8)
  2117  		v11 := b.NewValue0(v.Line, OpZeromask, config.fe.TypeUInt32())
  2118  		v12 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32())
  2119  		v13 := b.NewValue0(v.Line, OpRsh8Ux32, config.fe.TypeUInt8())
  2120  		v13.AddArg(s)
  2121  		v14 := b.NewValue0(v.Line, OpConst32, config.fe.TypeUInt32())
  2122  		v14.AuxInt = 5
  2123  		v13.AddArg(v14)
  2124  		v12.AddArg(v13)
  2125  		v11.AddArg(v12)
  2126  		v7.AddArg(v11)
  2127  		v1.AddArg(v7)
  2128  		v.AddArg(v1)
  2129  		return true
  2130  	}
  2131  	return false
  2132  }
  2133  func rewriteValuedec64_OpRsh8Ux64(v *Value, config *Config) bool {
  2134  	b := v.Block
  2135  	_ = b
  2136  	// match: (Rsh8Ux64 _ (Int64Make (Const32 [c]) _))
  2137  	// cond: c != 0
  2138  	// result: (Const32 [0])
  2139  	for {
  2140  		v_1 := v.Args[1]
  2141  		if v_1.Op != OpInt64Make {
  2142  			break
  2143  		}
  2144  		v_1_0 := v_1.Args[0]
  2145  		if v_1_0.Op != OpConst32 {
  2146  			break
  2147  		}
  2148  		c := v_1_0.AuxInt
  2149  		if !(c != 0) {
  2150  			break
  2151  		}
  2152  		v.reset(OpConst32)
  2153  		v.AuxInt = 0
  2154  		return true
  2155  	}
  2156  	// match: (Rsh8Ux64 x (Int64Make (Const32 [0]) lo))
  2157  	// cond:
  2158  	// result: (Rsh8Ux32 x lo)
  2159  	for {
  2160  		x := v.Args[0]
  2161  		v_1 := v.Args[1]
  2162  		if v_1.Op != OpInt64Make {
  2163  			break
  2164  		}
  2165  		v_1_0 := v_1.Args[0]
  2166  		if v_1_0.Op != OpConst32 {
  2167  			break
  2168  		}
  2169  		if v_1_0.AuxInt != 0 {
  2170  			break
  2171  		}
  2172  		lo := v_1.Args[1]
  2173  		v.reset(OpRsh8Ux32)
  2174  		v.AddArg(x)
  2175  		v.AddArg(lo)
  2176  		return true
  2177  	}
  2178  	// match: (Rsh8Ux64 x (Int64Make hi lo))
  2179  	// cond: hi.Op != OpConst32
  2180  	// result: (Rsh8Ux32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo))
  2181  	for {
  2182  		x := v.Args[0]
  2183  		v_1 := v.Args[1]
  2184  		if v_1.Op != OpInt64Make {
  2185  			break
  2186  		}
  2187  		hi := v_1.Args[0]
  2188  		lo := v_1.Args[1]
  2189  		if !(hi.Op != OpConst32) {
  2190  			break
  2191  		}
  2192  		v.reset(OpRsh8Ux32)
  2193  		v.AddArg(x)
  2194  		v0 := b.NewValue0(v.Line, OpOr32, config.fe.TypeUInt32())
  2195  		v1 := b.NewValue0(v.Line, OpZeromask, config.fe.TypeUInt32())
  2196  		v1.AddArg(hi)
  2197  		v0.AddArg(v1)
  2198  		v0.AddArg(lo)
  2199  		v.AddArg(v0)
  2200  		return true
  2201  	}
  2202  	return false
  2203  }
  2204  func rewriteValuedec64_OpRsh8x64(v *Value, config *Config) bool {
  2205  	b := v.Block
  2206  	_ = b
  2207  	// match: (Rsh8x64 x (Int64Make (Const32 [c]) _))
  2208  	// cond: c != 0
  2209  	// result: (Signmask (SignExt8to32 x))
  2210  	for {
  2211  		x := v.Args[0]
  2212  		v_1 := v.Args[1]
  2213  		if v_1.Op != OpInt64Make {
  2214  			break
  2215  		}
  2216  		v_1_0 := v_1.Args[0]
  2217  		if v_1_0.Op != OpConst32 {
  2218  			break
  2219  		}
  2220  		c := v_1_0.AuxInt
  2221  		if !(c != 0) {
  2222  			break
  2223  		}
  2224  		v.reset(OpSignmask)
  2225  		v0 := b.NewValue0(v.Line, OpSignExt8to32, config.fe.TypeInt32())
  2226  		v0.AddArg(x)
  2227  		v.AddArg(v0)
  2228  		return true
  2229  	}
  2230  	// match: (Rsh8x64 x (Int64Make (Const32 [0]) lo))
  2231  	// cond:
  2232  	// result: (Rsh8x32 x lo)
  2233  	for {
  2234  		x := v.Args[0]
  2235  		v_1 := v.Args[1]
  2236  		if v_1.Op != OpInt64Make {
  2237  			break
  2238  		}
  2239  		v_1_0 := v_1.Args[0]
  2240  		if v_1_0.Op != OpConst32 {
  2241  			break
  2242  		}
  2243  		if v_1_0.AuxInt != 0 {
  2244  			break
  2245  		}
  2246  		lo := v_1.Args[1]
  2247  		v.reset(OpRsh8x32)
  2248  		v.AddArg(x)
  2249  		v.AddArg(lo)
  2250  		return true
  2251  	}
  2252  	// match: (Rsh8x64 x (Int64Make hi lo))
  2253  	// cond: hi.Op != OpConst32
  2254  	// result: (Rsh8x32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo))
  2255  	for {
  2256  		x := v.Args[0]
  2257  		v_1 := v.Args[1]
  2258  		if v_1.Op != OpInt64Make {
  2259  			break
  2260  		}
  2261  		hi := v_1.Args[0]
  2262  		lo := v_1.Args[1]
  2263  		if !(hi.Op != OpConst32) {
  2264  			break
  2265  		}
  2266  		v.reset(OpRsh8x32)
  2267  		v.AddArg(x)
  2268  		v0 := b.NewValue0(v.Line, OpOr32, config.fe.TypeUInt32())
  2269  		v1 := b.NewValue0(v.Line, OpZeromask, config.fe.TypeUInt32())
  2270  		v1.AddArg(hi)
  2271  		v0.AddArg(v1)
  2272  		v0.AddArg(lo)
  2273  		v.AddArg(v0)
  2274  		return true
  2275  	}
  2276  	return false
  2277  }
  2278  func rewriteValuedec64_OpSignExt16to64(v *Value, config *Config) bool {
  2279  	b := v.Block
  2280  	_ = b
  2281  	// match: (SignExt16to64 x)
  2282  	// cond:
  2283  	// result: (SignExt32to64 (SignExt16to32 x))
  2284  	for {
  2285  		x := v.Args[0]
  2286  		v.reset(OpSignExt32to64)
  2287  		v0 := b.NewValue0(v.Line, OpSignExt16to32, config.fe.TypeInt32())
  2288  		v0.AddArg(x)
  2289  		v.AddArg(v0)
  2290  		return true
  2291  	}
  2292  }
  2293  func rewriteValuedec64_OpSignExt32to64(v *Value, config *Config) bool {
  2294  	b := v.Block
  2295  	_ = b
  2296  	// match: (SignExt32to64 x)
  2297  	// cond:
  2298  	// result: (Int64Make (Signmask x) x)
  2299  	for {
  2300  		x := v.Args[0]
  2301  		v.reset(OpInt64Make)
  2302  		v0 := b.NewValue0(v.Line, OpSignmask, config.fe.TypeInt32())
  2303  		v0.AddArg(x)
  2304  		v.AddArg(v0)
  2305  		v.AddArg(x)
  2306  		return true
  2307  	}
  2308  }
  2309  func rewriteValuedec64_OpSignExt8to64(v *Value, config *Config) bool {
  2310  	b := v.Block
  2311  	_ = b
  2312  	// match: (SignExt8to64 x)
  2313  	// cond:
  2314  	// result: (SignExt32to64 (SignExt8to32 x))
  2315  	for {
  2316  		x := v.Args[0]
  2317  		v.reset(OpSignExt32to64)
  2318  		v0 := b.NewValue0(v.Line, OpSignExt8to32, config.fe.TypeInt32())
  2319  		v0.AddArg(x)
  2320  		v.AddArg(v0)
  2321  		return true
  2322  	}
  2323  }
  2324  func rewriteValuedec64_OpStore(v *Value, config *Config) bool {
  2325  	b := v.Block
  2326  	_ = b
  2327  	// match: (Store [8] dst (Int64Make hi lo) mem)
  2328  	// cond:
  2329  	// result: (Store [4] 		(OffPtr <hi.Type.PtrTo()> [4] dst) 		hi 		(Store [4] dst lo mem))
  2330  	for {
  2331  		if v.AuxInt != 8 {
  2332  			break
  2333  		}
  2334  		dst := v.Args[0]
  2335  		v_1 := v.Args[1]
  2336  		if v_1.Op != OpInt64Make {
  2337  			break
  2338  		}
  2339  		hi := v_1.Args[0]
  2340  		lo := v_1.Args[1]
  2341  		mem := v.Args[2]
  2342  		v.reset(OpStore)
  2343  		v.AuxInt = 4
  2344  		v0 := b.NewValue0(v.Line, OpOffPtr, hi.Type.PtrTo())
  2345  		v0.AuxInt = 4
  2346  		v0.AddArg(dst)
  2347  		v.AddArg(v0)
  2348  		v.AddArg(hi)
  2349  		v1 := b.NewValue0(v.Line, OpStore, TypeMem)
  2350  		v1.AuxInt = 4
  2351  		v1.AddArg(dst)
  2352  		v1.AddArg(lo)
  2353  		v1.AddArg(mem)
  2354  		v.AddArg(v1)
  2355  		return true
  2356  	}
  2357  	return false
  2358  }
  2359  func rewriteValuedec64_OpSub64(v *Value, config *Config) bool {
  2360  	b := v.Block
  2361  	_ = b
  2362  	// match: (Sub64 x y)
  2363  	// cond:
  2364  	// result: (Int64Make 		(Sub32withcarry <config.fe.TypeInt32()> 			(Int64Hi x) 			(Int64Hi y) 			(Select1 <TypeFlags> (Sub32carry (Int64Lo x) (Int64Lo y)))) 		(Select0 <config.fe.TypeUInt32()> (Sub32carry (Int64Lo x) (Int64Lo y))))
  2365  	for {
  2366  		x := v.Args[0]
  2367  		y := v.Args[1]
  2368  		v.reset(OpInt64Make)
  2369  		v0 := b.NewValue0(v.Line, OpSub32withcarry, config.fe.TypeInt32())
  2370  		v1 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
  2371  		v1.AddArg(x)
  2372  		v0.AddArg(v1)
  2373  		v2 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
  2374  		v2.AddArg(y)
  2375  		v0.AddArg(v2)
  2376  		v3 := b.NewValue0(v.Line, OpSelect1, TypeFlags)
  2377  		v4 := b.NewValue0(v.Line, OpSub32carry, MakeTuple(config.fe.TypeUInt32(), TypeFlags))
  2378  		v5 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
  2379  		v5.AddArg(x)
  2380  		v4.AddArg(v5)
  2381  		v6 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
  2382  		v6.AddArg(y)
  2383  		v4.AddArg(v6)
  2384  		v3.AddArg(v4)
  2385  		v0.AddArg(v3)
  2386  		v.AddArg(v0)
  2387  		v7 := b.NewValue0(v.Line, OpSelect0, config.fe.TypeUInt32())
  2388  		v8 := b.NewValue0(v.Line, OpSub32carry, MakeTuple(config.fe.TypeUInt32(), TypeFlags))
  2389  		v9 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
  2390  		v9.AddArg(x)
  2391  		v8.AddArg(v9)
  2392  		v10 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
  2393  		v10.AddArg(y)
  2394  		v8.AddArg(v10)
  2395  		v7.AddArg(v8)
  2396  		v.AddArg(v7)
  2397  		return true
  2398  	}
  2399  }
  2400  func rewriteValuedec64_OpTrunc64to16(v *Value, config *Config) bool {
  2401  	b := v.Block
  2402  	_ = b
  2403  	// match: (Trunc64to16 (Int64Make _ lo))
  2404  	// cond:
  2405  	// result: (Trunc32to16 lo)
  2406  	for {
  2407  		v_0 := v.Args[0]
  2408  		if v_0.Op != OpInt64Make {
  2409  			break
  2410  		}
  2411  		lo := v_0.Args[1]
  2412  		v.reset(OpTrunc32to16)
  2413  		v.AddArg(lo)
  2414  		return true
  2415  	}
  2416  	return false
  2417  }
  2418  func rewriteValuedec64_OpTrunc64to32(v *Value, config *Config) bool {
  2419  	b := v.Block
  2420  	_ = b
  2421  	// match: (Trunc64to32 (Int64Make _ lo))
  2422  	// cond:
  2423  	// result: lo
  2424  	for {
  2425  		v_0 := v.Args[0]
  2426  		if v_0.Op != OpInt64Make {
  2427  			break
  2428  		}
  2429  		lo := v_0.Args[1]
  2430  		v.reset(OpCopy)
  2431  		v.Type = lo.Type
  2432  		v.AddArg(lo)
  2433  		return true
  2434  	}
  2435  	return false
  2436  }
  2437  func rewriteValuedec64_OpTrunc64to8(v *Value, config *Config) bool {
  2438  	b := v.Block
  2439  	_ = b
  2440  	// match: (Trunc64to8 (Int64Make _ lo))
  2441  	// cond:
  2442  	// result: (Trunc32to8 lo)
  2443  	for {
  2444  		v_0 := v.Args[0]
  2445  		if v_0.Op != OpInt64Make {
  2446  			break
  2447  		}
  2448  		lo := v_0.Args[1]
  2449  		v.reset(OpTrunc32to8)
  2450  		v.AddArg(lo)
  2451  		return true
  2452  	}
  2453  	return false
  2454  }
  2455  func rewriteValuedec64_OpXor64(v *Value, config *Config) bool {
  2456  	b := v.Block
  2457  	_ = b
  2458  	// match: (Xor64 x y)
  2459  	// cond:
  2460  	// result: (Int64Make 		(Xor32 <config.fe.TypeUInt32()> (Int64Hi x) (Int64Hi y)) 		(Xor32 <config.fe.TypeUInt32()> (Int64Lo x) (Int64Lo y)))
  2461  	for {
  2462  		x := v.Args[0]
  2463  		y := v.Args[1]
  2464  		v.reset(OpInt64Make)
  2465  		v0 := b.NewValue0(v.Line, OpXor32, config.fe.TypeUInt32())
  2466  		v1 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
  2467  		v1.AddArg(x)
  2468  		v0.AddArg(v1)
  2469  		v2 := b.NewValue0(v.Line, OpInt64Hi, config.fe.TypeUInt32())
  2470  		v2.AddArg(y)
  2471  		v0.AddArg(v2)
  2472  		v.AddArg(v0)
  2473  		v3 := b.NewValue0(v.Line, OpXor32, config.fe.TypeUInt32())
  2474  		v4 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
  2475  		v4.AddArg(x)
  2476  		v3.AddArg(v4)
  2477  		v5 := b.NewValue0(v.Line, OpInt64Lo, config.fe.TypeUInt32())
  2478  		v5.AddArg(y)
  2479  		v3.AddArg(v5)
  2480  		v.AddArg(v3)
  2481  		return true
  2482  	}
  2483  }
  2484  func rewriteValuedec64_OpZeroExt16to64(v *Value, config *Config) bool {
  2485  	b := v.Block
  2486  	_ = b
  2487  	// match: (ZeroExt16to64 x)
  2488  	// cond:
  2489  	// result: (ZeroExt32to64 (ZeroExt16to32 x))
  2490  	for {
  2491  		x := v.Args[0]
  2492  		v.reset(OpZeroExt32to64)
  2493  		v0 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32())
  2494  		v0.AddArg(x)
  2495  		v.AddArg(v0)
  2496  		return true
  2497  	}
  2498  }
  2499  func rewriteValuedec64_OpZeroExt32to64(v *Value, config *Config) bool {
  2500  	b := v.Block
  2501  	_ = b
  2502  	// match: (ZeroExt32to64 x)
  2503  	// cond:
  2504  	// result: (Int64Make (Const32 <config.fe.TypeUInt32()> [0]) x)
  2505  	for {
  2506  		x := v.Args[0]
  2507  		v.reset(OpInt64Make)
  2508  		v0 := b.NewValue0(v.Line, OpConst32, config.fe.TypeUInt32())
  2509  		v0.AuxInt = 0
  2510  		v.AddArg(v0)
  2511  		v.AddArg(x)
  2512  		return true
  2513  	}
  2514  }
  2515  func rewriteValuedec64_OpZeroExt8to64(v *Value, config *Config) bool {
  2516  	b := v.Block
  2517  	_ = b
  2518  	// match: (ZeroExt8to64 x)
  2519  	// cond:
  2520  	// result: (ZeroExt32to64 (ZeroExt8to32 x))
  2521  	for {
  2522  		x := v.Args[0]
  2523  		v.reset(OpZeroExt32to64)
  2524  		v0 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32())
  2525  		v0.AddArg(x)
  2526  		v.AddArg(v0)
  2527  		return true
  2528  	}
  2529  }
  2530  func rewriteBlockdec64(b *Block) bool {
  2531  	switch b.Kind {
  2532  	}
  2533  	return false
  2534  }