{name: "Add64F", argLength: 2, commutative: true},

	{name: "Sub8", argLength: 2}, // arg0 - arg1
	{name: "Sub16", argLength: 2},
	{name: "Sub32", argLength: 2},
	{name: "Sub64", argLength: 2},
	{name: "SubPtr", argLength: 2},
	{name: "Sub32F", argLength: 2},
	{name: "Sub64F", argLength: 2},

	{name: "Mul8", argLength: 2, commutative: true}, // arg0 * arg1
	{name: "Mul16", argLength: 2, commutative: true},

	if want, got = a+c32s, add32s(a); got != want {
		panic(fmt.Sprintf("add32s(%x) = %x, want %x", a, got, want))
	}
	if want, got = a-c32a, sub32a(a); got != want {
		panic(fmt.Sprintf("sub32a(%x) = %x, want %x", a, got, want))
	}
	if want, got = a-c32s, sub32s(a); got != want {
		panic(fmt.Sprintf("sub32s(%x) = %x, want %x", a, got, want))
	}
	if want, got = a|c32a, or32(a); got != want {

// x - (C - z) -> x + (z - C) -> (x + z) - C
(Sub64 x (Sub64 i:(Const64 <t>) z)) && (z.Op != OpConst64 && x.Op != OpConst64) => (Sub64 (Add64 <t> x z) i)
(Sub32 x (Sub32 i:(Const32 <t>) z)) && (z.Op != OpConst32 && x.Op != OpConst32) => (Sub32 (Add32 <t> x z) i)
(Sub16 x (Sub16 i:(Const16 <t>) z)) && (z.Op != OpConst16 && x.Op != OpConst16) => (Sub16 (Add16 <t> x z) i)

// and will not run on earlier targets.
//
(Add(Ptr|64|32|16|8) ...) => (ADD ...)
(Add64F ...) => (FADD ...)
(Add32F ...) => (FADDS ...)

(Sub(Ptr|64|32|16|8) ...) => (SUB ...)
(Sub32F ...) => (FSUBS ...)
(Sub64F ...) => (FSUB ...)

(Min(32|64)F x y) && buildcfg.GOPPC64 >= 9 => (XSMINJDP x y)
(Max(32|64)F x y) && buildcfg.GOPPC64 >= 9 => (XSMAXJDP x y)

// Combine 64 bit integer multiply and adds

(Add(64|Ptr) ...) => (ADD ...)
(Add(32|16|8) ...) => (ADDW ...)
(Add32F x y) => (Select0 (FADDS x y))
(Add64F x y) => (Select0 (FADD x y))

(Sub(64|Ptr) ...) => (SUB ...)
(Sub(32|16|8) ...) => (SUBW ...)
(Sub32F x y) => (Select0 (FSUBS x y))
(Sub64F x y) => (Select0 (FSUB x y))

(Mul64 ...) => (MULLD ...)
(Mul(32|16|8) ...) => (MULLW ...)
(Mul32F ...) => (FMULS ...)
(Mul64F ...) => (FMUL ...)
(Mul64uhilo ...) => (MLGR ...)

func ExampleSub32() {
	// First number is 33<<32 + 23
	n1 := []uint32{33, 23}
	// Second number is 21<<32 + 12
	n2 := []uint32{21, 12}
	// Sub them together without producing carry.
	d1, carry := bits.Sub32(n1[1], n2[1], 0)
	d0, _ := bits.Sub32(n1[0], n2[0], carry)
	nsum := []uint32{d0, d1}
	fmt.Printf("%v - %v = %v (carry bit was %v)\n", n1, n2, nsum, carry)

	// First number is 3<<32 + 2147483647
	n1 = []uint32{3, 0x7fffffff}

	(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))
(Lsh64x16 x s) =>
	(Int64Make
		(Or32 <typ.UInt32>
			(Or32 <typ.UInt32>

	inf := 1.0 / zero
	negZero := -1 / inf
	if 1/add32(negZero) != inf {
		panic("negZero+0 != posZero (32 bit)")
	}
}

//go:noinline
func sub32(x float32) float32 {
	return x - 0
}

func testSub32() {
	var zero float32
	inf := 1.0 / zero
	negZero := -1 / inf
	if 1/sub32(negZero) != -inf {
		panic("negZero-0 != negZero (32 bit)")
	}
}

//go:noinline
func neg32(x float32) float32 {
	return -x
}

func Sub(x, y, borrow uint) (diff, borrowOut uint) {
	if UintSize == 32 {
		d32, b32 := Sub32(uint32(x), uint32(y), uint32(borrow))
		return uint(d32), uint(b32)
	}
	d64, b64 := Sub64(uint64(x), uint64(y), uint64(borrow))
	return uint(d64), uint(b64)
}

// Sub32 returns the difference of x, y and borrow, diff = x - y - borrow.
// The borrow input must be 0 or 1; otherwise the behavior is undefined.

			return true
		}
		break
	}
	// match: (Sub32 (Sub32 x y) x)
	// result: (Neg32 y)
	for {
		if v_0.Op != OpSub32 {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		if x != v_1 {
			break
		}
		v.reset(OpNeg32)
		v.AddArg(y)
		return true
	}
	// match: (Sub32 x (Add32 x y))
	// result: (Neg32 y)
	for {
		x := v_0