// Code generated from _gen/generic.rules using 'go generate'; DO NOT EDIT.

package rewritegeneric

import "math"
import "math/bits"
import "cmd/internal/obj"
import "cmd/compile/internal/types"
import "cmd/compile/internal/ir"
import "cmd/compile/internal/ssa/block"
import "cmd/compile/internal/ssa/ssaop"
import "cmd/compile/internal/ssa"

func RewriteValue(v *ssa.Value) bool {
	switch v.Op {
	case ssaop.OpAdd16:
		return rewriteValue_OpAdd16(v)
	case ssaop.OpAdd32:
		return rewriteValue_OpAdd32(v)
	case ssaop.OpAdd32F:
		return rewriteValue_OpAdd32F(v)
	case ssaop.OpAdd64:
		return rewriteValue_OpAdd64(v)
	case ssaop.OpAdd64F:
		return rewriteValue_OpAdd64F(v)
	case ssaop.OpAdd64carry:
		return rewriteValue_OpAdd64carry(v)
	case ssaop.OpAdd8:
		return rewriteValue_OpAdd8(v)
	case ssaop.OpAddPtr:
		return rewriteValue_OpAddPtr(v)
	case ssaop.OpAnd16:
		return rewriteValue_OpAnd16(v)
	case ssaop.OpAnd32:
		return rewriteValue_OpAnd32(v)
	case ssaop.OpAnd64:
		return rewriteValue_OpAnd64(v)
	case ssaop.OpAnd8:
		return rewriteValue_OpAnd8(v)
	case ssaop.OpAndB:
		return rewriteValue_OpAndB(v)
	case ssaop.OpArraySelect:
		return rewriteValue_OpArraySelect(v)
	case ssaop.OpBitLen16:
		return rewriteValue_OpBitLen16(v)
	case ssaop.OpBitLen32:
		return rewriteValue_OpBitLen32(v)
	case ssaop.OpBitLen64:
		return rewriteValue_OpBitLen64(v)
	case ssaop.OpBitLen8:
		return rewriteValue_OpBitLen8(v)
	case ssaop.OpBitRev16:
		return rewriteValue_OpBitRev16(v)
	case ssaop.OpBitRev32:
		return rewriteValue_OpBitRev32(v)
	case ssaop.OpBitRev64:
		return rewriteValue_OpBitRev64(v)
	case ssaop.OpBitRev8:
		return rewriteValue_OpBitRev8(v)
	case ssaop.OpBswap16:
		return rewriteValue_OpBswap16(v)
	case ssaop.OpBswap32:
		return rewriteValue_OpBswap32(v)
	case ssaop.OpBswap64:
		return rewriteValue_OpBswap64(v)
	case ssaop.OpCeil:
		return rewriteValue_OpCeil(v)
	case ssaop.OpCom16:
		return rewriteValue_OpCom16(v)
	case ssaop.OpCom32:
		return rewriteValue_OpCom32(v)
	case ssaop.OpCom64:
		return rewriteValue_OpCom64(v)
	case ssaop.OpCom8:
		return rewriteValue_OpCom8(v)
	case ssaop.OpCondSelect:
		return rewriteValue_OpCondSelect(v)
	case ssaop.OpConstInterface:
		return rewriteValue_OpConstInterface(v)
	case ssaop.OpConstSlice:
		return rewriteValue_OpConstSlice(v)
	case ssaop.OpConstString:
		return rewriteValue_OpConstString(v)
	case ssaop.OpConvert:
		return rewriteValue_OpConvert(v)
	case ssaop.OpCtz16:
		return rewriteValue_OpCtz16(v)
	case ssaop.OpCtz32:
		return rewriteValue_OpCtz32(v)
	case ssaop.OpCtz64:
		return rewriteValue_OpCtz64(v)
	case ssaop.OpCtz8:
		return rewriteValue_OpCtz8(v)
	case ssaop.OpCvt32Fto32:
		return rewriteValue_OpCvt32Fto32(v)
	case ssaop.OpCvt32Fto64:
		return rewriteValue_OpCvt32Fto64(v)
	case ssaop.OpCvt32Fto64F:
		return rewriteValue_OpCvt32Fto64F(v)
	case ssaop.OpCvt32to32F:
		return rewriteValue_OpCvt32to32F(v)
	case ssaop.OpCvt32to64F:
		return rewriteValue_OpCvt32to64F(v)
	case ssaop.OpCvt64Fto32:
		return rewriteValue_OpCvt64Fto32(v)
	case ssaop.OpCvt64Fto32F:
		return rewriteValue_OpCvt64Fto32F(v)
	case ssaop.OpCvt64Fto64:
		return rewriteValue_OpCvt64Fto64(v)
	case ssaop.OpCvt64to32F:
		return rewriteValue_OpCvt64to32F(v)
	case ssaop.OpCvt64to64F:
		return rewriteValue_OpCvt64to64F(v)
	case ssaop.OpCvtBoolToUint8:
		return rewriteValue_OpCvtBoolToUint8(v)
	case ssaop.OpDiv128u:
		return rewriteValue_OpDiv128u(v)
	case ssaop.OpDiv16:
		return rewriteValue_OpDiv16(v)
	case ssaop.OpDiv16u:
		return rewriteValue_OpDiv16u(v)
	case ssaop.OpDiv32:
		return rewriteValue_OpDiv32(v)
	case ssaop.OpDiv32F:
		return rewriteValue_OpDiv32F(v)
	case ssaop.OpDiv32u:
		return rewriteValue_OpDiv32u(v)
	case ssaop.OpDiv64:
		return rewriteValue_OpDiv64(v)
	case ssaop.OpDiv64F:
		return rewriteValue_OpDiv64F(v)
	case ssaop.OpDiv64u:
		return rewriteValue_OpDiv64u(v)
	case ssaop.OpDiv8:
		return rewriteValue_OpDiv8(v)
	case ssaop.OpDiv8u:
		return rewriteValue_OpDiv8u(v)
	case ssaop.OpEq16:
		return rewriteValue_OpEq16(v)
	case ssaop.OpEq32:
		return rewriteValue_OpEq32(v)
	case ssaop.OpEq32F:
		return rewriteValue_OpEq32F(v)
	case ssaop.OpEq64:
		return rewriteValue_OpEq64(v)
	case ssaop.OpEq64F:
		return rewriteValue_OpEq64F(v)
	case ssaop.OpEq8:
		return rewriteValue_OpEq8(v)
	case ssaop.OpEqB:
		return rewriteValue_OpEqB(v)
	case ssaop.OpEqInter:
		return rewriteValue_OpEqInter(v)
	case ssaop.OpEqPtr:
		return rewriteValue_OpEqPtr(v)
	case ssaop.OpEqSlice:
		return rewriteValue_OpEqSlice(v)
	case ssaop.OpFloor:
		return rewriteValue_OpFloor(v)
	case ssaop.OpIMake:
		return rewriteValue_OpIMake(v)
	case ssaop.OpInterLECall:
		return rewriteValue_OpInterLECall(v)
	case ssaop.OpIsInBounds:
		return rewriteValue_OpIsInBounds(v)
	case ssaop.OpIsNonNil:
		return rewriteValue_OpIsNonNil(v)
	case ssaop.OpIsSliceInBounds:
		return rewriteValue_OpIsSliceInBounds(v)
	case ssaop.OpLeq16:
		return rewriteValue_OpLeq16(v)
	case ssaop.OpLeq16U:
		return rewriteValue_OpLeq16U(v)
	case ssaop.OpLeq32:
		return rewriteValue_OpLeq32(v)
	case ssaop.OpLeq32F:
		return rewriteValue_OpLeq32F(v)
	case ssaop.OpLeq32U:
		return rewriteValue_OpLeq32U(v)
	case ssaop.OpLeq64:
		return rewriteValue_OpLeq64(v)
	case ssaop.OpLeq64F:
		return rewriteValue_OpLeq64F(v)
	case ssaop.OpLeq64U:
		return rewriteValue_OpLeq64U(v)
	case ssaop.OpLeq8:
		return rewriteValue_OpLeq8(v)
	case ssaop.OpLeq8U:
		return rewriteValue_OpLeq8U(v)
	case ssaop.OpLess16:
		return rewriteValue_OpLess16(v)
	case ssaop.OpLess16U:
		return rewriteValue_OpLess16U(v)
	case ssaop.OpLess32:
		return rewriteValue_OpLess32(v)
	case ssaop.OpLess32F:
		return rewriteValue_OpLess32F(v)
	case ssaop.OpLess32U:
		return rewriteValue_OpLess32U(v)
	case ssaop.OpLess64:
		return rewriteValue_OpLess64(v)
	case ssaop.OpLess64F:
		return rewriteValue_OpLess64F(v)
	case ssaop.OpLess64U:
		return rewriteValue_OpLess64U(v)
	case ssaop.OpLess8:
		return rewriteValue_OpLess8(v)
	case ssaop.OpLess8U:
		return rewriteValue_OpLess8U(v)
	case ssaop.OpLoad:
		return rewriteValue_OpLoad(v)
	case ssaop.OpLsh16x16:
		return rewriteValue_OpLsh16x16(v)
	case ssaop.OpLsh16x32:
		return rewriteValue_OpLsh16x32(v)
	case ssaop.OpLsh16x64:
		return rewriteValue_OpLsh16x64(v)
	case ssaop.OpLsh16x8:
		return rewriteValue_OpLsh16x8(v)
	case ssaop.OpLsh32x16:
		return rewriteValue_OpLsh32x16(v)
	case ssaop.OpLsh32x32:
		return rewriteValue_OpLsh32x32(v)
	case ssaop.OpLsh32x64:
		return rewriteValue_OpLsh32x64(v)
	case ssaop.OpLsh32x8:
		return rewriteValue_OpLsh32x8(v)
	case ssaop.OpLsh64x16:
		return rewriteValue_OpLsh64x16(v)
	case ssaop.OpLsh64x32:
		return rewriteValue_OpLsh64x32(v)
	case ssaop.OpLsh64x64:
		return rewriteValue_OpLsh64x64(v)
	case ssaop.OpLsh64x8:
		return rewriteValue_OpLsh64x8(v)
	case ssaop.OpLsh8x16:
		return rewriteValue_OpLsh8x16(v)
	case ssaop.OpLsh8x32:
		return rewriteValue_OpLsh8x32(v)
	case ssaop.OpLsh8x64:
		return rewriteValue_OpLsh8x64(v)
	case ssaop.OpLsh8x8:
		return rewriteValue_OpLsh8x8(v)
	case ssaop.OpMemEq:
		return rewriteValue_OpMemEq(v)
	case ssaop.OpMod16:
		return rewriteValue_OpMod16(v)
	case ssaop.OpMod16u:
		return rewriteValue_OpMod16u(v)
	case ssaop.OpMod32:
		return rewriteValue_OpMod32(v)
	case ssaop.OpMod32u:
		return rewriteValue_OpMod32u(v)
	case ssaop.OpMod64:
		return rewriteValue_OpMod64(v)
	case ssaop.OpMod64u:
		return rewriteValue_OpMod64u(v)
	case ssaop.OpMod8:
		return rewriteValue_OpMod8(v)
	case ssaop.OpMod8u:
		return rewriteValue_OpMod8u(v)
	case ssaop.OpMove:
		return rewriteValue_OpMove(v)
	case ssaop.OpMul16:
		return rewriteValue_OpMul16(v)
	case ssaop.OpMul32:
		return rewriteValue_OpMul32(v)
	case ssaop.OpMul32F:
		return rewriteValue_OpMul32F(v)
	case ssaop.OpMul32uhilo:
		return rewriteValue_OpMul32uhilo(v)
	case ssaop.OpMul32uover:
		return rewriteValue_OpMul32uover(v)
	case ssaop.OpMul64:
		return rewriteValue_OpMul64(v)
	case ssaop.OpMul64F:
		return rewriteValue_OpMul64F(v)
	case ssaop.OpMul64uhilo:
		return rewriteValue_OpMul64uhilo(v)
	case ssaop.OpMul64uover:
		return rewriteValue_OpMul64uover(v)
	case ssaop.OpMul8:
		return rewriteValue_OpMul8(v)
	case ssaop.OpNeg16:
		return rewriteValue_OpNeg16(v)
	case ssaop.OpNeg32:
		return rewriteValue_OpNeg32(v)
	case ssaop.OpNeg32F:
		return rewriteValue_OpNeg32F(v)
	case ssaop.OpNeg64:
		return rewriteValue_OpNeg64(v)
	case ssaop.OpNeg64F:
		return rewriteValue_OpNeg64F(v)
	case ssaop.OpNeg8:
		return rewriteValue_OpNeg8(v)
	case ssaop.OpNeq16:
		return rewriteValue_OpNeq16(v)
	case ssaop.OpNeq32:
		return rewriteValue_OpNeq32(v)
	case ssaop.OpNeq32F:
		return rewriteValue_OpNeq32F(v)
	case ssaop.OpNeq64:
		return rewriteValue_OpNeq64(v)
	case ssaop.OpNeq64F:
		return rewriteValue_OpNeq64F(v)
	case ssaop.OpNeq8:
		return rewriteValue_OpNeq8(v)
	case ssaop.OpNeqB:
		return rewriteValue_OpNeqB(v)
	case ssaop.OpNeqInter:
		return rewriteValue_OpNeqInter(v)
	case ssaop.OpNeqPtr:
		return rewriteValue_OpNeqPtr(v)
	case ssaop.OpNeqSlice:
		return rewriteValue_OpNeqSlice(v)
	case ssaop.OpNilCheck:
		return rewriteValue_OpNilCheck(v)
	case ssaop.OpNot:
		return rewriteValue_OpNot(v)
	case ssaop.OpOffPtr:
		return rewriteValue_OpOffPtr(v)
	case ssaop.OpOr16:
		return rewriteValue_OpOr16(v)
	case ssaop.OpOr32:
		return rewriteValue_OpOr32(v)
	case ssaop.OpOr64:
		return rewriteValue_OpOr64(v)
	case ssaop.OpOr8:
		return rewriteValue_OpOr8(v)
	case ssaop.OpOrB:
		return rewriteValue_OpOrB(v)
	case ssaop.OpPhi:
		return rewriteValue_OpPhi(v)
	case ssaop.OpPopCount16:
		return rewriteValue_OpPopCount16(v)
	case ssaop.OpPopCount32:
		return rewriteValue_OpPopCount32(v)
	case ssaop.OpPopCount64:
		return rewriteValue_OpPopCount64(v)
	case ssaop.OpPopCount8:
		return rewriteValue_OpPopCount8(v)
	case ssaop.OpPtrIndex:
		return rewriteValue_OpPtrIndex(v)
	case ssaop.OpRotateLeft16:
		return rewriteValue_OpRotateLeft16(v)
	case ssaop.OpRotateLeft32:
		return rewriteValue_OpRotateLeft32(v)
	case ssaop.OpRotateLeft64:
		return rewriteValue_OpRotateLeft64(v)
	case ssaop.OpRotateLeft8:
		return rewriteValue_OpRotateLeft8(v)
	case ssaop.OpRound32F:
		return rewriteValue_OpRound32F(v)
	case ssaop.OpRound64F:
		return rewriteValue_OpRound64F(v)
	case ssaop.OpRoundToEven:
		return rewriteValue_OpRoundToEven(v)
	case ssaop.OpRsh16Ux16:
		return rewriteValue_OpRsh16Ux16(v)
	case ssaop.OpRsh16Ux32:
		return rewriteValue_OpRsh16Ux32(v)
	case ssaop.OpRsh16Ux64:
		return rewriteValue_OpRsh16Ux64(v)
	case ssaop.OpRsh16Ux8:
		return rewriteValue_OpRsh16Ux8(v)
	case ssaop.OpRsh16x16:
		return rewriteValue_OpRsh16x16(v)
	case ssaop.OpRsh16x32:
		return rewriteValue_OpRsh16x32(v)
	case ssaop.OpRsh16x64:
		return rewriteValue_OpRsh16x64(v)
	case ssaop.OpRsh16x8:
		return rewriteValue_OpRsh16x8(v)
	case ssaop.OpRsh32Ux16:
		return rewriteValue_OpRsh32Ux16(v)
	case ssaop.OpRsh32Ux32:
		return rewriteValue_OpRsh32Ux32(v)
	case ssaop.OpRsh32Ux64:
		return rewriteValue_OpRsh32Ux64(v)
	case ssaop.OpRsh32Ux8:
		return rewriteValue_OpRsh32Ux8(v)
	case ssaop.OpRsh32x16:
		return rewriteValue_OpRsh32x16(v)
	case ssaop.OpRsh32x32:
		return rewriteValue_OpRsh32x32(v)
	case ssaop.OpRsh32x64:
		return rewriteValue_OpRsh32x64(v)
	case ssaop.OpRsh32x8:
		return rewriteValue_OpRsh32x8(v)
	case ssaop.OpRsh64Ux16:
		return rewriteValue_OpRsh64Ux16(v)
	case ssaop.OpRsh64Ux32:
		return rewriteValue_OpRsh64Ux32(v)
	case ssaop.OpRsh64Ux64:
		return rewriteValue_OpRsh64Ux64(v)
	case ssaop.OpRsh64Ux8:
		return rewriteValue_OpRsh64Ux8(v)
	case ssaop.OpRsh64x16:
		return rewriteValue_OpRsh64x16(v)
	case ssaop.OpRsh64x32:
		return rewriteValue_OpRsh64x32(v)
	case ssaop.OpRsh64x64:
		return rewriteValue_OpRsh64x64(v)
	case ssaop.OpRsh64x8:
		return rewriteValue_OpRsh64x8(v)
	case ssaop.OpRsh8Ux16:
		return rewriteValue_OpRsh8Ux16(v)
	case ssaop.OpRsh8Ux32:
		return rewriteValue_OpRsh8Ux32(v)
	case ssaop.OpRsh8Ux64:
		return rewriteValue_OpRsh8Ux64(v)
	case ssaop.OpRsh8Ux8:
		return rewriteValue_OpRsh8Ux8(v)
	case ssaop.OpRsh8x16:
		return rewriteValue_OpRsh8x16(v)
	case ssaop.OpRsh8x32:
		return rewriteValue_OpRsh8x32(v)
	case ssaop.OpRsh8x64:
		return rewriteValue_OpRsh8x64(v)
	case ssaop.OpRsh8x8:
		return rewriteValue_OpRsh8x8(v)
	case ssaop.OpSelect0:
		return rewriteValue_OpSelect0(v)
	case ssaop.OpSelect1:
		return rewriteValue_OpSelect1(v)
	case ssaop.OpSelectN:
		return rewriteValue_OpSelectN(v)
	case ssaop.OpSignExt16to32:
		return rewriteValue_OpSignExt16to32(v)
	case ssaop.OpSignExt16to64:
		return rewriteValue_OpSignExt16to64(v)
	case ssaop.OpSignExt32to64:
		return rewriteValue_OpSignExt32to64(v)
	case ssaop.OpSignExt8to16:
		return rewriteValue_OpSignExt8to16(v)
	case ssaop.OpSignExt8to32:
		return rewriteValue_OpSignExt8to32(v)
	case ssaop.OpSignExt8to64:
		return rewriteValue_OpSignExt8to64(v)
	case ssaop.OpSliceCap:
		return rewriteValue_OpSliceCap(v)
	case ssaop.OpSliceLen:
		return rewriteValue_OpSliceLen(v)
	case ssaop.OpSliceMake:
		return rewriteValue_OpSliceMake(v)
	case ssaop.OpSlicePtr:
		return rewriteValue_OpSlicePtr(v)
	case ssaop.OpSlicemask:
		return rewriteValue_OpSlicemask(v)
	case ssaop.OpSqrt:
		return rewriteValue_OpSqrt(v)
	case ssaop.OpStaticCall:
		return rewriteValue_OpStaticCall(v)
	case ssaop.OpStaticLECall:
		return rewriteValue_OpStaticLECall(v)
	case ssaop.OpStore:
		return rewriteValue_OpStore(v)
	case ssaop.OpStringLen:
		return rewriteValue_OpStringLen(v)
	case ssaop.OpStringPtr:
		return rewriteValue_OpStringPtr(v)
	case ssaop.OpStructSelect:
		return rewriteValue_OpStructSelect(v)
	case ssaop.OpSub16:
		return rewriteValue_OpSub16(v)
	case ssaop.OpSub32:
		return rewriteValue_OpSub32(v)
	case ssaop.OpSub32F:
		return rewriteValue_OpSub32F(v)
	case ssaop.OpSub64:
		return rewriteValue_OpSub64(v)
	case ssaop.OpSub64F:
		return rewriteValue_OpSub64F(v)
	case ssaop.OpSub64borrow:
		return rewriteValue_OpSub64borrow(v)
	case ssaop.OpSub8:
		return rewriteValue_OpSub8(v)
	case ssaop.OpTrunc:
		return rewriteValue_OpTrunc(v)
	case ssaop.OpTrunc16to8:
		return rewriteValue_OpTrunc16to8(v)
	case ssaop.OpTrunc32to16:
		return rewriteValue_OpTrunc32to16(v)
	case ssaop.OpTrunc32to8:
		return rewriteValue_OpTrunc32to8(v)
	case ssaop.OpTrunc64to16:
		return rewriteValue_OpTrunc64to16(v)
	case ssaop.OpTrunc64to32:
		return rewriteValue_OpTrunc64to32(v)
	case ssaop.OpTrunc64to8:
		return rewriteValue_OpTrunc64to8(v)
	case ssaop.OpXor16:
		return rewriteValue_OpXor16(v)
	case ssaop.OpXor32:
		return rewriteValue_OpXor32(v)
	case ssaop.OpXor64:
		return rewriteValue_OpXor64(v)
	case ssaop.OpXor8:
		return rewriteValue_OpXor8(v)
	case ssaop.OpZero:
		return rewriteValue_OpZero(v)
	case ssaop.OpZeroExt16to32:
		return rewriteValue_OpZeroExt16to32(v)
	case ssaop.OpZeroExt16to64:
		return rewriteValue_OpZeroExt16to64(v)
	case ssaop.OpZeroExt32to64:
		return rewriteValue_OpZeroExt32to64(v)
	case ssaop.OpZeroExt8to16:
		return rewriteValue_OpZeroExt8to16(v)
	case ssaop.OpZeroExt8to32:
		return rewriteValue_OpZeroExt8to32(v)
	case ssaop.OpZeroExt8to64:
		return rewriteValue_OpZeroExt8to64(v)
	}
	return false
}
func rewriteValue_OpAdd16(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	// match: (Add16 (Const16 [c]) (Const16 [d]))
	// result: (Const16 [c+d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst16 {
				continue
			}
			d := ssa.AuxIntToInt16(v_1.AuxInt)
			v.Reset(ssaop.OpConst16)
			v.AuxInt = ssa.Int16ToAuxInt(c + d)
			return true
		}
		break
	}
	// match: (Add16 <t> (Mul16 x y) (Mul16 x z))
	// result: (Mul16 x (Add16 <t> y z))
	for {
		t := v.Type
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpMul16 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				x := v_0_0
				y := v_0_1
				if v_1.Op != ssaop.OpMul16 {
					continue
				}
				_ = v_1.Args[1]
				v_1_0 := v_1.Args[0]
				v_1_1 := v_1.Args[1]
				for _i2 := 0; _i2 <= 1; _i2, v_1_0, v_1_1 = _i2+1, v_1_1, v_1_0 {
					if x != v_1_0 {
						continue
					}
					z := v_1_1
					v.Reset(ssaop.OpMul16)
					v0 := b.NewValue0(v.Pos, ssaop.OpAdd16, t)
					v0.AddArg2(y, z)
					v.AddArg2(x, v0)
					return true
				}
			}
		}
		break
	}
	// match: (Add16 x x)
	// result: (Lsh16x64 x (Const64 <types.Types[types.TUINT64]> [1]))
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.Reset(ssaop.OpLsh16x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(1)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Add16 (Const16 [0]) x)
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 {
				continue
			}
			x := v_1
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (Add16 x (Neg16 y))
	// result: (Sub16 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpNeg16 {
				continue
			}
			y := v_1.Args[0]
			v.Reset(ssaop.OpSub16)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Add16 (Com16 x) x)
	// result: (Const16 [-1])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpCom16 {
				continue
			}
			x := v_0.Args[0]
			if x != v_1 {
				continue
			}
			v.Reset(ssaop.OpConst16)
			v.AuxInt = ssa.Int16ToAuxInt(-1)
			return true
		}
		break
	}
	// match: (Add16 (Sub16 x t) (Add16 t y))
	// result: (Add16 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpSub16 {
				continue
			}
			t := v_0.Args[1]
			x := v_0.Args[0]
			if v_1.Op != ssaop.OpAdd16 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if t != v_1_0 {
					continue
				}
				y := v_1_1
				v.Reset(ssaop.OpAdd16)
				v.AddArg2(x, y)
				return true
			}
		}
		break
	}
	// match: (Add16 (Const16 [1]) (Com16 x))
	// result: (Neg16 x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 1 || v_1.Op != ssaop.OpCom16 {
				continue
			}
			x := v_1.Args[0]
			v.Reset(ssaop.OpNeg16)
			v.AddArg(x)
			return true
		}
		break
	}
	// match: (Add16 x (Sub16 y x))
	// result: y
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpSub16 {
				continue
			}
			_ = v_1.Args[1]
			y := v_1.Args[0]
			if x != v_1.Args[1] {
				continue
			}
			v.CopyOf(y)
			return true
		}
		break
	}
	// match: (Add16 x (Add16 y (Sub16 z x)))
	// result: (Add16 y z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpAdd16 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				y := v_1_0
				if v_1_1.Op != ssaop.OpSub16 {
					continue
				}
				_ = v_1_1.Args[1]
				z := v_1_1.Args[0]
				if x != v_1_1.Args[1] {
					continue
				}
				v.Reset(ssaop.OpAdd16)
				v.AddArg2(y, z)
				return true
			}
		}
		break
	}
	// match: (Add16 x (Sub16 y (Sub16 x z)))
	// result: (Add16 y z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpSub16 {
				continue
			}
			_ = v_1.Args[1]
			y := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpSub16 {
				continue
			}
			z := v_1_1.Args[1]
			if x != v_1_1.Args[0] {
				continue
			}
			v.Reset(ssaop.OpAdd16)
			v.AddArg2(y, z)
			return true
		}
		break
	}
	// match: (Add16 (Add16 i:(Const16 <t>) z) x)
	// cond: (z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16)
	// result: (Add16 i (Add16 <t> z x))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpAdd16 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				i := v_0_0
				if i.Op != ssaop.OpConst16 {
					continue
				}
				t := i.Type
				z := v_0_1
				x := v_1
				if !(z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16) {
					continue
				}
				v.Reset(ssaop.OpAdd16)
				v0 := b.NewValue0(v.Pos, ssaop.OpAdd16, t)
				v0.AddArg2(z, x)
				v.AddArg2(i, v0)
				return true
			}
		}
		break
	}
	// match: (Add16 (Sub16 i:(Const16 <t>) z) x)
	// cond: (z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16)
	// result: (Add16 i (Sub16 <t> x z))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpSub16 {
				continue
			}
			z := v_0.Args[1]
			i := v_0.Args[0]
			if i.Op != ssaop.OpConst16 {
				continue
			}
			t := i.Type
			x := v_1
			if !(z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16) {
				continue
			}
			v.Reset(ssaop.OpAdd16)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub16, t)
			v0.AddArg2(x, z)
			v.AddArg2(i, v0)
			return true
		}
		break
	}
	// match: (Add16 (Const16 <t> [c]) (Add16 (Const16 <t> [d]) x))
	// result: (Add16 (Const16 <t> [c+d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt16(v_0.AuxInt)
			if v_1.Op != ssaop.OpAdd16 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if v_1_0.Op != ssaop.OpConst16 || v_1_0.Type != t {
					continue
				}
				d := ssa.AuxIntToInt16(v_1_0.AuxInt)
				x := v_1_1
				v.Reset(ssaop.OpAdd16)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
				v0.AuxInt = ssa.Int16ToAuxInt(c + d)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Add16 (Const16 <t> [c]) (Sub16 (Const16 <t> [d]) x))
	// result: (Sub16 (Const16 <t> [c+d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt16(v_0.AuxInt)
			if v_1.Op != ssaop.OpSub16 {
				continue
			}
			x := v_1.Args[1]
			v_1_0 := v_1.Args[0]
			if v_1_0.Op != ssaop.OpConst16 || v_1_0.Type != t {
				continue
			}
			d := ssa.AuxIntToInt16(v_1_0.AuxInt)
			v.Reset(ssaop.OpSub16)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
			v0.AuxInt = ssa.Int16ToAuxInt(c + d)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Add16 (Lsh16x64 x z:(Const64 <t> [c])) (Rsh16Ux64 x (Const64 [d])))
	// cond: c < 16 && d == 16-c && canRotate(config, 16)
	// result: (RotateLeft16 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLsh16x64 {
				continue
			}
			_ = v_0.Args[1]
			x := v_0.Args[0]
			z := v_0.Args[1]
			if z.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(z.AuxInt)
			if v_1.Op != ssaop.OpRsh16Ux64 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(c < 16 && d == 16-c && canRotate(config, 16)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Add16 left:(Lsh16x64 x y) right:(Rsh16Ux64 x (Sub64 (Const64 [16]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)
	// result: (RotateLeft16 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh16x64 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh16Ux64 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub64 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(right_1_0.AuxInt) != 16 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Add16 left:(Lsh16x32 x y) right:(Rsh16Ux32 x (Sub32 (Const32 [16]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)
	// result: (RotateLeft16 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh16x32 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh16Ux32 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub32 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(right_1_0.AuxInt) != 16 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Add16 left:(Lsh16x16 x y) right:(Rsh16Ux16 x (Sub16 (Const16 [16]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)
	// result: (RotateLeft16 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh16x16 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh16Ux16 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub16 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(right_1_0.AuxInt) != 16 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Add16 left:(Lsh16x8 x y) right:(Rsh16Ux8 x (Sub8 (Const8 [16]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)
	// result: (RotateLeft16 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh16x8 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh16Ux8 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub8 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(right_1_0.AuxInt) != 16 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Add16 right:(Rsh16Ux64 x y) left:(Lsh16x64 x z:(Sub64 (Const64 [16]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)
	// result: (RotateLeft16 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh16Ux64 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh16x64 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub64 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(z_0.AuxInt) != 16 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Add16 right:(Rsh16Ux32 x y) left:(Lsh16x32 x z:(Sub32 (Const32 [16]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)
	// result: (RotateLeft16 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh16Ux32 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh16x32 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub32 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(z_0.AuxInt) != 16 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Add16 right:(Rsh16Ux16 x y) left:(Lsh16x16 x z:(Sub16 (Const16 [16]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)
	// result: (RotateLeft16 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh16Ux16 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh16x16 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub16 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(z_0.AuxInt) != 16 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Add16 right:(Rsh16Ux8 x y) left:(Lsh16x8 x z:(Sub8 (Const8 [16]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)
	// result: (RotateLeft16 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh16Ux8 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh16x8 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub8 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(z_0.AuxInt) != 16 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpAdd32(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	// match: (Add32 (Const32 [c]) (Const32 [d]))
	// result: (Const32 [c+d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(v_1.AuxInt)
			v.Reset(ssaop.OpConst32)
			v.AuxInt = ssa.Int32ToAuxInt(c + d)
			return true
		}
		break
	}
	// match: (Add32 <t> (Mul32 x y) (Mul32 x z))
	// result: (Mul32 x (Add32 <t> y z))
	for {
		t := v.Type
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpMul32 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				x := v_0_0
				y := v_0_1
				if v_1.Op != ssaop.OpMul32 {
					continue
				}
				_ = v_1.Args[1]
				v_1_0 := v_1.Args[0]
				v_1_1 := v_1.Args[1]
				for _i2 := 0; _i2 <= 1; _i2, v_1_0, v_1_1 = _i2+1, v_1_1, v_1_0 {
					if x != v_1_0 {
						continue
					}
					z := v_1_1
					v.Reset(ssaop.OpMul32)
					v0 := b.NewValue0(v.Pos, ssaop.OpAdd32, t)
					v0.AddArg2(y, z)
					v.AddArg2(x, v0)
					return true
				}
			}
		}
		break
	}
	// match: (Add32 x x)
	// result: (Lsh32x64 x (Const64 <types.Types[types.TUINT64]> [1]))
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.Reset(ssaop.OpLsh32x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(1)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Add32 (Const32 [0]) x)
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 {
				continue
			}
			x := v_1
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (Add32 x (Neg32 y))
	// result: (Sub32 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpNeg32 {
				continue
			}
			y := v_1.Args[0]
			v.Reset(ssaop.OpSub32)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Add32 (Com32 x) x)
	// result: (Const32 [-1])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpCom32 {
				continue
			}
			x := v_0.Args[0]
			if x != v_1 {
				continue
			}
			v.Reset(ssaop.OpConst32)
			v.AuxInt = ssa.Int32ToAuxInt(-1)
			return true
		}
		break
	}
	// match: (Add32 (Sub32 x t) (Add32 t y))
	// result: (Add32 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpSub32 {
				continue
			}
			t := v_0.Args[1]
			x := v_0.Args[0]
			if v_1.Op != ssaop.OpAdd32 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if t != v_1_0 {
					continue
				}
				y := v_1_1
				v.Reset(ssaop.OpAdd32)
				v.AddArg2(x, y)
				return true
			}
		}
		break
	}
	// match: (Add32 (Const32 [1]) (Com32 x))
	// result: (Neg32 x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 1 || v_1.Op != ssaop.OpCom32 {
				continue
			}
			x := v_1.Args[0]
			v.Reset(ssaop.OpNeg32)
			v.AddArg(x)
			return true
		}
		break
	}
	// match: (Add32 x (Sub32 y x))
	// result: y
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpSub32 {
				continue
			}
			_ = v_1.Args[1]
			y := v_1.Args[0]
			if x != v_1.Args[1] {
				continue
			}
			v.CopyOf(y)
			return true
		}
		break
	}
	// match: (Add32 x (Add32 y (Sub32 z x)))
	// result: (Add32 y z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpAdd32 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				y := v_1_0
				if v_1_1.Op != ssaop.OpSub32 {
					continue
				}
				_ = v_1_1.Args[1]
				z := v_1_1.Args[0]
				if x != v_1_1.Args[1] {
					continue
				}
				v.Reset(ssaop.OpAdd32)
				v.AddArg2(y, z)
				return true
			}
		}
		break
	}
	// match: (Add32 x (Sub32 y (Sub32 x z)))
	// result: (Add32 y z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpSub32 {
				continue
			}
			_ = v_1.Args[1]
			y := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpSub32 {
				continue
			}
			z := v_1_1.Args[1]
			if x != v_1_1.Args[0] {
				continue
			}
			v.Reset(ssaop.OpAdd32)
			v.AddArg2(y, z)
			return true
		}
		break
	}
	// match: (Add32 (Add32 i:(Const32 <t>) z) x)
	// cond: (z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32)
	// result: (Add32 i (Add32 <t> z x))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpAdd32 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				i := v_0_0
				if i.Op != ssaop.OpConst32 {
					continue
				}
				t := i.Type
				z := v_0_1
				x := v_1
				if !(z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32) {
					continue
				}
				v.Reset(ssaop.OpAdd32)
				v0 := b.NewValue0(v.Pos, ssaop.OpAdd32, t)
				v0.AddArg2(z, x)
				v.AddArg2(i, v0)
				return true
			}
		}
		break
	}
	// match: (Add32 (Sub32 i:(Const32 <t>) z) x)
	// cond: (z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32)
	// result: (Add32 i (Sub32 <t> x z))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpSub32 {
				continue
			}
			z := v_0.Args[1]
			i := v_0.Args[0]
			if i.Op != ssaop.OpConst32 {
				continue
			}
			t := i.Type
			x := v_1
			if !(z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32) {
				continue
			}
			v.Reset(ssaop.OpAdd32)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub32, t)
			v0.AddArg2(x, z)
			v.AddArg2(i, v0)
			return true
		}
		break
	}
	// match: (Add32 (Const32 <t> [c]) (Add32 (Const32 <t> [d]) x))
	// result: (Add32 (Const32 <t> [c+d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt32(v_0.AuxInt)
			if v_1.Op != ssaop.OpAdd32 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if v_1_0.Op != ssaop.OpConst32 || v_1_0.Type != t {
					continue
				}
				d := ssa.AuxIntToInt32(v_1_0.AuxInt)
				x := v_1_1
				v.Reset(ssaop.OpAdd32)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
				v0.AuxInt = ssa.Int32ToAuxInt(c + d)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Add32 (Const32 <t> [c]) (Sub32 (Const32 <t> [d]) x))
	// result: (Sub32 (Const32 <t> [c+d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt32(v_0.AuxInt)
			if v_1.Op != ssaop.OpSub32 {
				continue
			}
			x := v_1.Args[1]
			v_1_0 := v_1.Args[0]
			if v_1_0.Op != ssaop.OpConst32 || v_1_0.Type != t {
				continue
			}
			d := ssa.AuxIntToInt32(v_1_0.AuxInt)
			v.Reset(ssaop.OpSub32)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
			v0.AuxInt = ssa.Int32ToAuxInt(c + d)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Add32 (Lsh32x64 x z:(Const64 <t> [c])) (Rsh32Ux64 x (Const64 [d])))
	// cond: c < 32 && d == 32-c && canRotate(config, 32)
	// result: (RotateLeft32 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLsh32x64 {
				continue
			}
			_ = v_0.Args[1]
			x := v_0.Args[0]
			z := v_0.Args[1]
			if z.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(z.AuxInt)
			if v_1.Op != ssaop.OpRsh32Ux64 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(c < 32 && d == 32-c && canRotate(config, 32)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Add32 left:(Lsh32x64 x y) right:(Rsh32Ux64 x (Sub64 (Const64 [32]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)
	// result: (RotateLeft32 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh32x64 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh32Ux64 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub64 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(right_1_0.AuxInt) != 32 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Add32 left:(Lsh32x32 x y) right:(Rsh32Ux32 x (Sub32 (Const32 [32]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)
	// result: (RotateLeft32 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh32x32 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh32Ux32 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub32 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(right_1_0.AuxInt) != 32 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Add32 left:(Lsh32x16 x y) right:(Rsh32Ux16 x (Sub16 (Const16 [32]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)
	// result: (RotateLeft32 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh32x16 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh32Ux16 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub16 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(right_1_0.AuxInt) != 32 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Add32 left:(Lsh32x8 x y) right:(Rsh32Ux8 x (Sub8 (Const8 [32]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)
	// result: (RotateLeft32 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh32x8 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh32Ux8 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub8 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(right_1_0.AuxInt) != 32 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Add32 right:(Rsh32Ux64 x y) left:(Lsh32x64 x z:(Sub64 (Const64 [32]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)
	// result: (RotateLeft32 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh32Ux64 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh32x64 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub64 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(z_0.AuxInt) != 32 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Add32 right:(Rsh32Ux32 x y) left:(Lsh32x32 x z:(Sub32 (Const32 [32]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)
	// result: (RotateLeft32 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh32Ux32 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh32x32 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub32 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(z_0.AuxInt) != 32 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Add32 right:(Rsh32Ux16 x y) left:(Lsh32x16 x z:(Sub16 (Const16 [32]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)
	// result: (RotateLeft32 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh32Ux16 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh32x16 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub16 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(z_0.AuxInt) != 32 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Add32 right:(Rsh32Ux8 x y) left:(Lsh32x8 x z:(Sub8 (Const8 [32]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)
	// result: (RotateLeft32 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh32Ux8 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh32x8 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub8 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(z_0.AuxInt) != 32 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpAdd32F(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	// match: (Add32F (Const32F [c]) (Const32F [d]))
	// cond: c+d == c+d
	// result: (Const32F [c+d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32F {
				continue
			}
			c := ssa.AuxIntToFloat32(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst32F {
				continue
			}
			d := ssa.AuxIntToFloat32(v_1.AuxInt)
			if !(c+d == c+d) {
				continue
			}
			v.Reset(ssaop.OpConst32F)
			v.AuxInt = ssa.Float32ToAuxInt(c + d)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpAdd64(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	// match: (Add64 (Const64 [c]) (Const64 [d]))
	// result: (Const64 [c+d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1.AuxInt)
			v.Reset(ssaop.OpConst64)
			v.AuxInt = ssa.Int64ToAuxInt(c + d)
			return true
		}
		break
	}
	// match: (Add64 <t> (Mul64 x y) (Mul64 x z))
	// result: (Mul64 x (Add64 <t> y z))
	for {
		t := v.Type
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpMul64 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				x := v_0_0
				y := v_0_1
				if v_1.Op != ssaop.OpMul64 {
					continue
				}
				_ = v_1.Args[1]
				v_1_0 := v_1.Args[0]
				v_1_1 := v_1.Args[1]
				for _i2 := 0; _i2 <= 1; _i2, v_1_0, v_1_1 = _i2+1, v_1_1, v_1_0 {
					if x != v_1_0 {
						continue
					}
					z := v_1_1
					v.Reset(ssaop.OpMul64)
					v0 := b.NewValue0(v.Pos, ssaop.OpAdd64, t)
					v0.AddArg2(y, z)
					v.AddArg2(x, v0)
					return true
				}
			}
		}
		break
	}
	// match: (Add64 x x)
	// result: (Lsh64x64 x (Const64 <types.Types[types.TUINT64]> [1]))
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.Reset(ssaop.OpLsh64x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(1)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Add64 (Const64 [0]) x)
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 {
				continue
			}
			x := v_1
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (Add64 x (Neg64 y))
	// result: (Sub64 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpNeg64 {
				continue
			}
			y := v_1.Args[0]
			v.Reset(ssaop.OpSub64)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Add64 (Com64 x) x)
	// result: (Const64 [-1])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpCom64 {
				continue
			}
			x := v_0.Args[0]
			if x != v_1 {
				continue
			}
			v.Reset(ssaop.OpConst64)
			v.AuxInt = ssa.Int64ToAuxInt(-1)
			return true
		}
		break
	}
	// match: (Add64 (Sub64 x t) (Add64 t y))
	// result: (Add64 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpSub64 {
				continue
			}
			t := v_0.Args[1]
			x := v_0.Args[0]
			if v_1.Op != ssaop.OpAdd64 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if t != v_1_0 {
					continue
				}
				y := v_1_1
				v.Reset(ssaop.OpAdd64)
				v.AddArg2(x, y)
				return true
			}
		}
		break
	}
	// match: (Add64 (Const64 [1]) (Com64 x))
	// result: (Neg64 x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 1 || v_1.Op != ssaop.OpCom64 {
				continue
			}
			x := v_1.Args[0]
			v.Reset(ssaop.OpNeg64)
			v.AddArg(x)
			return true
		}
		break
	}
	// match: (Add64 x (Sub64 y x))
	// result: y
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpSub64 {
				continue
			}
			_ = v_1.Args[1]
			y := v_1.Args[0]
			if x != v_1.Args[1] {
				continue
			}
			v.CopyOf(y)
			return true
		}
		break
	}
	// match: (Add64 x (Add64 y (Sub64 z x)))
	// result: (Add64 y z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpAdd64 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				y := v_1_0
				if v_1_1.Op != ssaop.OpSub64 {
					continue
				}
				_ = v_1_1.Args[1]
				z := v_1_1.Args[0]
				if x != v_1_1.Args[1] {
					continue
				}
				v.Reset(ssaop.OpAdd64)
				v.AddArg2(y, z)
				return true
			}
		}
		break
	}
	// match: (Add64 x (Sub64 y (Sub64 x z)))
	// result: (Add64 y z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpSub64 {
				continue
			}
			_ = v_1.Args[1]
			y := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpSub64 {
				continue
			}
			z := v_1_1.Args[1]
			if x != v_1_1.Args[0] {
				continue
			}
			v.Reset(ssaop.OpAdd64)
			v.AddArg2(y, z)
			return true
		}
		break
	}
	// match: (Add64 (Add64 i:(Const64 <t>) z) x)
	// cond: (z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64)
	// result: (Add64 i (Add64 <t> z x))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpAdd64 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				i := v_0_0
				if i.Op != ssaop.OpConst64 {
					continue
				}
				t := i.Type
				z := v_0_1
				x := v_1
				if !(z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64) {
					continue
				}
				v.Reset(ssaop.OpAdd64)
				v0 := b.NewValue0(v.Pos, ssaop.OpAdd64, t)
				v0.AddArg2(z, x)
				v.AddArg2(i, v0)
				return true
			}
		}
		break
	}
	// match: (Add64 (Sub64 i:(Const64 <t>) z) x)
	// cond: (z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64)
	// result: (Add64 i (Sub64 <t> x z))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpSub64 {
				continue
			}
			z := v_0.Args[1]
			i := v_0.Args[0]
			if i.Op != ssaop.OpConst64 {
				continue
			}
			t := i.Type
			x := v_1
			if !(z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64) {
				continue
			}
			v.Reset(ssaop.OpAdd64)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub64, t)
			v0.AddArg2(x, z)
			v.AddArg2(i, v0)
			return true
		}
		break
	}
	// match: (Add64 (Const64 <t> [c]) (Add64 (Const64 <t> [d]) x))
	// result: (Add64 (Const64 <t> [c+d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt64(v_0.AuxInt)
			if v_1.Op != ssaop.OpAdd64 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if v_1_0.Op != ssaop.OpConst64 || v_1_0.Type != t {
					continue
				}
				d := ssa.AuxIntToInt64(v_1_0.AuxInt)
				x := v_1_1
				v.Reset(ssaop.OpAdd64)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
				v0.AuxInt = ssa.Int64ToAuxInt(c + d)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Add64 (Const64 <t> [c]) (Sub64 (Const64 <t> [d]) x))
	// result: (Sub64 (Const64 <t> [c+d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt64(v_0.AuxInt)
			if v_1.Op != ssaop.OpSub64 {
				continue
			}
			x := v_1.Args[1]
			v_1_0 := v_1.Args[0]
			if v_1_0.Op != ssaop.OpConst64 || v_1_0.Type != t {
				continue
			}
			d := ssa.AuxIntToInt64(v_1_0.AuxInt)
			v.Reset(ssaop.OpSub64)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
			v0.AuxInt = ssa.Int64ToAuxInt(c + d)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Add64 (Lsh64x64 x z:(Const64 <t> [c])) (Rsh64Ux64 x (Const64 [d])))
	// cond: c < 64 && d == 64-c && canRotate(config, 64)
	// result: (RotateLeft64 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLsh64x64 {
				continue
			}
			_ = v_0.Args[1]
			x := v_0.Args[0]
			z := v_0.Args[1]
			if z.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(z.AuxInt)
			if v_1.Op != ssaop.OpRsh64Ux64 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(c < 64 && d == 64-c && canRotate(config, 64)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Add64 left:(Lsh64x64 x y) right:(Rsh64Ux64 x (Sub64 (Const64 [64]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)
	// result: (RotateLeft64 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh64x64 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh64Ux64 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub64 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(right_1_0.AuxInt) != 64 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Add64 left:(Lsh64x32 x y) right:(Rsh64Ux32 x (Sub32 (Const32 [64]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)
	// result: (RotateLeft64 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh64x32 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh64Ux32 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub32 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(right_1_0.AuxInt) != 64 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Add64 left:(Lsh64x16 x y) right:(Rsh64Ux16 x (Sub16 (Const16 [64]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)
	// result: (RotateLeft64 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh64x16 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh64Ux16 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub16 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(right_1_0.AuxInt) != 64 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Add64 left:(Lsh64x8 x y) right:(Rsh64Ux8 x (Sub8 (Const8 [64]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)
	// result: (RotateLeft64 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh64x8 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh64Ux8 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub8 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(right_1_0.AuxInt) != 64 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Add64 right:(Rsh64Ux64 x y) left:(Lsh64x64 x z:(Sub64 (Const64 [64]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)
	// result: (RotateLeft64 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh64Ux64 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh64x64 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub64 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(z_0.AuxInt) != 64 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Add64 right:(Rsh64Ux32 x y) left:(Lsh64x32 x z:(Sub32 (Const32 [64]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)
	// result: (RotateLeft64 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh64Ux32 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh64x32 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub32 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(z_0.AuxInt) != 64 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Add64 right:(Rsh64Ux16 x y) left:(Lsh64x16 x z:(Sub16 (Const16 [64]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)
	// result: (RotateLeft64 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh64Ux16 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh64x16 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub16 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(z_0.AuxInt) != 64 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Add64 right:(Rsh64Ux8 x y) left:(Lsh64x8 x z:(Sub8 (Const8 [64]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)
	// result: (RotateLeft64 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh64Ux8 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh64x8 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub8 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(z_0.AuxInt) != 64 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpAdd64F(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	// match: (Add64F (Const64F [c]) (Const64F [d]))
	// cond: c+d == c+d
	// result: (Const64F [c+d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64F {
				continue
			}
			c := ssa.AuxIntToFloat64(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst64F {
				continue
			}
			d := ssa.AuxIntToFloat64(v_1.AuxInt)
			if !(c+d == c+d) {
				continue
			}
			v.Reset(ssaop.OpConst64F)
			v.AuxInt = ssa.Float64ToAuxInt(c + d)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpAdd64carry(v *ssa.Value) bool {
	v_2 := v.Args[2]
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Add64carry (Const64 <t> [x]) (Const64 [y]) (Const64 [c]))
	// cond: c >= 0 && c <= 1
	// result: (MakeTuple (Const64 <t> [bitsAdd64(x, y, c).sum]) (Const64 <t> [bitsAdd64(x, y, c).carry]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			t := v_0.Type
			x := ssa.AuxIntToInt64(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			y := ssa.AuxIntToInt64(v_1.AuxInt)
			if v_2.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_2.AuxInt)
			if !(c >= 0 && c <= 1) {
				continue
			}
			v.Reset(ssaop.OpMakeTuple)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
			v0.AuxInt = ssa.Int64ToAuxInt(bitsAdd64(x, y, c).sum)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
			v1.AuxInt = ssa.Int64ToAuxInt(bitsAdd64(x, y, c).carry)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpAdd8(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	// match: (Add8 (Const8 [c]) (Const8 [d]))
	// result: (Const8 [c+d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst8 {
				continue
			}
			d := ssa.AuxIntToInt8(v_1.AuxInt)
			v.Reset(ssaop.OpConst8)
			v.AuxInt = ssa.Int8ToAuxInt(c + d)
			return true
		}
		break
	}
	// match: (Add8 <t> (Mul8 x y) (Mul8 x z))
	// result: (Mul8 x (Add8 <t> y z))
	for {
		t := v.Type
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpMul8 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				x := v_0_0
				y := v_0_1
				if v_1.Op != ssaop.OpMul8 {
					continue
				}
				_ = v_1.Args[1]
				v_1_0 := v_1.Args[0]
				v_1_1 := v_1.Args[1]
				for _i2 := 0; _i2 <= 1; _i2, v_1_0, v_1_1 = _i2+1, v_1_1, v_1_0 {
					if x != v_1_0 {
						continue
					}
					z := v_1_1
					v.Reset(ssaop.OpMul8)
					v0 := b.NewValue0(v.Pos, ssaop.OpAdd8, t)
					v0.AddArg2(y, z)
					v.AddArg2(x, v0)
					return true
				}
			}
		}
		break
	}
	// match: (Add8 x x)
	// result: (Lsh8x64 x (Const64 <types.Types[types.TUINT64]> [1]))
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.Reset(ssaop.OpLsh8x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(1)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Add8 (Const8 [0]) x)
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 {
				continue
			}
			x := v_1
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (Add8 x (Neg8 y))
	// result: (Sub8 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpNeg8 {
				continue
			}
			y := v_1.Args[0]
			v.Reset(ssaop.OpSub8)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Add8 (Com8 x) x)
	// result: (Const8 [-1])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpCom8 {
				continue
			}
			x := v_0.Args[0]
			if x != v_1 {
				continue
			}
			v.Reset(ssaop.OpConst8)
			v.AuxInt = ssa.Int8ToAuxInt(-1)
			return true
		}
		break
	}
	// match: (Add8 (Sub8 x t) (Add8 t y))
	// result: (Add8 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpSub8 {
				continue
			}
			t := v_0.Args[1]
			x := v_0.Args[0]
			if v_1.Op != ssaop.OpAdd8 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if t != v_1_0 {
					continue
				}
				y := v_1_1
				v.Reset(ssaop.OpAdd8)
				v.AddArg2(x, y)
				return true
			}
		}
		break
	}
	// match: (Add8 (Const8 [1]) (Com8 x))
	// result: (Neg8 x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 1 || v_1.Op != ssaop.OpCom8 {
				continue
			}
			x := v_1.Args[0]
			v.Reset(ssaop.OpNeg8)
			v.AddArg(x)
			return true
		}
		break
	}
	// match: (Add8 x (Sub8 y x))
	// result: y
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpSub8 {
				continue
			}
			_ = v_1.Args[1]
			y := v_1.Args[0]
			if x != v_1.Args[1] {
				continue
			}
			v.CopyOf(y)
			return true
		}
		break
	}
	// match: (Add8 x (Add8 y (Sub8 z x)))
	// result: (Add8 y z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpAdd8 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				y := v_1_0
				if v_1_1.Op != ssaop.OpSub8 {
					continue
				}
				_ = v_1_1.Args[1]
				z := v_1_1.Args[0]
				if x != v_1_1.Args[1] {
					continue
				}
				v.Reset(ssaop.OpAdd8)
				v.AddArg2(y, z)
				return true
			}
		}
		break
	}
	// match: (Add8 x (Sub8 y (Sub8 x z)))
	// result: (Add8 y z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpSub8 {
				continue
			}
			_ = v_1.Args[1]
			y := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpSub8 {
				continue
			}
			z := v_1_1.Args[1]
			if x != v_1_1.Args[0] {
				continue
			}
			v.Reset(ssaop.OpAdd8)
			v.AddArg2(y, z)
			return true
		}
		break
	}
	// match: (Add8 (Add8 i:(Const8 <t>) z) x)
	// cond: (z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8)
	// result: (Add8 i (Add8 <t> z x))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpAdd8 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				i := v_0_0
				if i.Op != ssaop.OpConst8 {
					continue
				}
				t := i.Type
				z := v_0_1
				x := v_1
				if !(z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8) {
					continue
				}
				v.Reset(ssaop.OpAdd8)
				v0 := b.NewValue0(v.Pos, ssaop.OpAdd8, t)
				v0.AddArg2(z, x)
				v.AddArg2(i, v0)
				return true
			}
		}
		break
	}
	// match: (Add8 (Sub8 i:(Const8 <t>) z) x)
	// cond: (z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8)
	// result: (Add8 i (Sub8 <t> x z))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpSub8 {
				continue
			}
			z := v_0.Args[1]
			i := v_0.Args[0]
			if i.Op != ssaop.OpConst8 {
				continue
			}
			t := i.Type
			x := v_1
			if !(z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8) {
				continue
			}
			v.Reset(ssaop.OpAdd8)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub8, t)
			v0.AddArg2(x, z)
			v.AddArg2(i, v0)
			return true
		}
		break
	}
	// match: (Add8 (Const8 <t> [c]) (Add8 (Const8 <t> [d]) x))
	// result: (Add8 (Const8 <t> [c+d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt8(v_0.AuxInt)
			if v_1.Op != ssaop.OpAdd8 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if v_1_0.Op != ssaop.OpConst8 || v_1_0.Type != t {
					continue
				}
				d := ssa.AuxIntToInt8(v_1_0.AuxInt)
				x := v_1_1
				v.Reset(ssaop.OpAdd8)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
				v0.AuxInt = ssa.Int8ToAuxInt(c + d)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Add8 (Const8 <t> [c]) (Sub8 (Const8 <t> [d]) x))
	// result: (Sub8 (Const8 <t> [c+d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt8(v_0.AuxInt)
			if v_1.Op != ssaop.OpSub8 {
				continue
			}
			x := v_1.Args[1]
			v_1_0 := v_1.Args[0]
			if v_1_0.Op != ssaop.OpConst8 || v_1_0.Type != t {
				continue
			}
			d := ssa.AuxIntToInt8(v_1_0.AuxInt)
			v.Reset(ssaop.OpSub8)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
			v0.AuxInt = ssa.Int8ToAuxInt(c + d)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Add8 (Lsh8x64 x z:(Const64 <t> [c])) (Rsh8Ux64 x (Const64 [d])))
	// cond: c < 8 && d == 8-c && canRotate(config, 8)
	// result: (RotateLeft8 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLsh8x64 {
				continue
			}
			_ = v_0.Args[1]
			x := v_0.Args[0]
			z := v_0.Args[1]
			if z.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(z.AuxInt)
			if v_1.Op != ssaop.OpRsh8Ux64 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(c < 8 && d == 8-c && canRotate(config, 8)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Add8 left:(Lsh8x64 x y) right:(Rsh8Ux64 x (Sub64 (Const64 [8]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)
	// result: (RotateLeft8 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh8x64 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh8Ux64 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub64 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(right_1_0.AuxInt) != 8 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Add8 left:(Lsh8x32 x y) right:(Rsh8Ux32 x (Sub32 (Const32 [8]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)
	// result: (RotateLeft8 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh8x32 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh8Ux32 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub32 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(right_1_0.AuxInt) != 8 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Add8 left:(Lsh8x16 x y) right:(Rsh8Ux16 x (Sub16 (Const16 [8]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)
	// result: (RotateLeft8 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh8x16 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh8Ux16 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub16 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(right_1_0.AuxInt) != 8 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Add8 left:(Lsh8x8 x y) right:(Rsh8Ux8 x (Sub8 (Const8 [8]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)
	// result: (RotateLeft8 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh8x8 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh8Ux8 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub8 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(right_1_0.AuxInt) != 8 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Add8 right:(Rsh8Ux64 x y) left:(Lsh8x64 x z:(Sub64 (Const64 [8]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)
	// result: (RotateLeft8 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh8Ux64 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh8x64 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub64 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(z_0.AuxInt) != 8 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Add8 right:(Rsh8Ux32 x y) left:(Lsh8x32 x z:(Sub32 (Const32 [8]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)
	// result: (RotateLeft8 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh8Ux32 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh8x32 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub32 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(z_0.AuxInt) != 8 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Add8 right:(Rsh8Ux16 x y) left:(Lsh8x16 x z:(Sub16 (Const16 [8]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)
	// result: (RotateLeft8 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh8Ux16 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh8x16 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub16 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(z_0.AuxInt) != 8 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Add8 right:(Rsh8Ux8 x y) left:(Lsh8x8 x z:(Sub8 (Const8 [8]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)
	// result: (RotateLeft8 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh8Ux8 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh8x8 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub8 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(z_0.AuxInt) != 8 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpAddPtr(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	// match: (AddPtr <t> x (Const64 [c]))
	// result: (OffPtr <t> x [c])
	for {
		t := v.Type
		x := v_0
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_1.AuxInt)
		v.Reset(ssaop.OpOffPtr)
		v.Type = t
		v.AuxInt = ssa.Int64ToAuxInt(c)
		v.AddArg(x)
		return true
	}
	// match: (AddPtr <t> x (Const32 [c]))
	// result: (OffPtr <t> x [int64(c)])
	for {
		t := v.Type
		x := v_0
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_1.AuxInt)
		v.Reset(ssaop.OpOffPtr)
		v.Type = t
		v.AuxInt = ssa.Int64ToAuxInt(int64(c))
		v.AddArg(x)
		return true
	}
	return false
}
func rewriteValue_OpAnd16(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (And16 (Const16 [c]) (Const16 [d]))
	// result: (Const16 [c&d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst16 {
				continue
			}
			d := ssa.AuxIntToInt16(v_1.AuxInt)
			v.Reset(ssaop.OpConst16)
			v.AuxInt = ssa.Int16ToAuxInt(c & d)
			return true
		}
		break
	}
	// match: (And16 <t> (Com16 x) (Com16 y))
	// result: (Com16 (Or16 <t> x y))
	for {
		t := v.Type
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpCom16 {
				continue
			}
			x := v_0.Args[0]
			if v_1.Op != ssaop.OpCom16 {
				continue
			}
			y := v_1.Args[0]
			v.Reset(ssaop.OpCom16)
			v0 := b.NewValue0(v.Pos, ssaop.OpOr16, t)
			v0.AddArg2(x, y)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (And16 x (Or16 x y))
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpOr16 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if x != v_1_0 {
					continue
				}
				v.CopyOf(x)
				return true
			}
		}
		break
	}
	// match: (And16 (Const16 [m]) (Rsh16Ux64 _ (Const64 [c])))
	// cond: c >= int64(16-ntz16(m))
	// result: (Const16 [0])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 {
				continue
			}
			m := ssa.AuxIntToInt16(v_0.AuxInt)
			if v_1.Op != ssaop.OpRsh16Ux64 {
				continue
			}
			_ = v_1.Args[1]
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(c >= int64(16-ntz16(m))) {
				continue
			}
			v.Reset(ssaop.OpConst16)
			v.AuxInt = ssa.Int16ToAuxInt(0)
			return true
		}
		break
	}
	// match: (And16 (Const16 [m]) (Lsh16x64 _ (Const64 [c])))
	// cond: c >= int64(16-nlz16(m))
	// result: (Const16 [0])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 {
				continue
			}
			m := ssa.AuxIntToInt16(v_0.AuxInt)
			if v_1.Op != ssaop.OpLsh16x64 {
				continue
			}
			_ = v_1.Args[1]
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(c >= int64(16-nlz16(m))) {
				continue
			}
			v.Reset(ssaop.OpConst16)
			v.AuxInt = ssa.Int16ToAuxInt(0)
			return true
		}
		break
	}
	// match: (And16 x x)
	// result: x
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (And16 (Const16 [-1]) x)
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != -1 {
				continue
			}
			x := v_1
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (And16 (Const16 [0]) _)
	// result: (Const16 [0])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 {
				continue
			}
			v.Reset(ssaop.OpConst16)
			v.AuxInt = ssa.Int16ToAuxInt(0)
			return true
		}
		break
	}
	// match: (And16 (Com16 x) x)
	// result: (Const16 [0])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpCom16 {
				continue
			}
			x := v_0.Args[0]
			if x != v_1 {
				continue
			}
			v.Reset(ssaop.OpConst16)
			v.AuxInt = ssa.Int16ToAuxInt(0)
			return true
		}
		break
	}
	// match: (And16 x (And16 x y))
	// result: (And16 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpAnd16 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if x != v_1_0 {
					continue
				}
				y := v_1_1
				v.Reset(ssaop.OpAnd16)
				v.AddArg2(x, y)
				return true
			}
		}
		break
	}
	// match: (And16 (And16 i:(Const16 <t>) z) x)
	// cond: (z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16)
	// result: (And16 i (And16 <t> z x))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpAnd16 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				i := v_0_0
				if i.Op != ssaop.OpConst16 {
					continue
				}
				t := i.Type
				z := v_0_1
				x := v_1
				if !(z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16) {
					continue
				}
				v.Reset(ssaop.OpAnd16)
				v0 := b.NewValue0(v.Pos, ssaop.OpAnd16, t)
				v0.AddArg2(z, x)
				v.AddArg2(i, v0)
				return true
			}
		}
		break
	}
	// match: (And16 (Const16 <t> [c]) (And16 (Const16 <t> [d]) x))
	// result: (And16 (Const16 <t> [c&d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt16(v_0.AuxInt)
			if v_1.Op != ssaop.OpAnd16 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if v_1_0.Op != ssaop.OpConst16 || v_1_0.Type != t {
					continue
				}
				d := ssa.AuxIntToInt16(v_1_0.AuxInt)
				x := v_1_1
				v.Reset(ssaop.OpAnd16)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
				v0.AuxInt = ssa.Int16ToAuxInt(c & d)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	return false
}
func rewriteValue_OpAnd32(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (And32 (Const32 [c]) (Const32 [d]))
	// result: (Const32 [c&d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(v_1.AuxInt)
			v.Reset(ssaop.OpConst32)
			v.AuxInt = ssa.Int32ToAuxInt(c & d)
			return true
		}
		break
	}
	// match: (And32 <t> (Com32 x) (Com32 y))
	// result: (Com32 (Or32 <t> x y))
	for {
		t := v.Type
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpCom32 {
				continue
			}
			x := v_0.Args[0]
			if v_1.Op != ssaop.OpCom32 {
				continue
			}
			y := v_1.Args[0]
			v.Reset(ssaop.OpCom32)
			v0 := b.NewValue0(v.Pos, ssaop.OpOr32, t)
			v0.AddArg2(x, y)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (And32 x (Or32 x y))
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpOr32 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if x != v_1_0 {
					continue
				}
				v.CopyOf(x)
				return true
			}
		}
		break
	}
	// match: (And32 (Const32 [m]) (Rsh32Ux64 _ (Const64 [c])))
	// cond: c >= int64(32-ntz32(m))
	// result: (Const32 [0])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 {
				continue
			}
			m := ssa.AuxIntToInt32(v_0.AuxInt)
			if v_1.Op != ssaop.OpRsh32Ux64 {
				continue
			}
			_ = v_1.Args[1]
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(c >= int64(32-ntz32(m))) {
				continue
			}
			v.Reset(ssaop.OpConst32)
			v.AuxInt = ssa.Int32ToAuxInt(0)
			return true
		}
		break
	}
	// match: (And32 (Const32 [m]) (Lsh32x64 _ (Const64 [c])))
	// cond: c >= int64(32-nlz32(m))
	// result: (Const32 [0])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 {
				continue
			}
			m := ssa.AuxIntToInt32(v_0.AuxInt)
			if v_1.Op != ssaop.OpLsh32x64 {
				continue
			}
			_ = v_1.Args[1]
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(c >= int64(32-nlz32(m))) {
				continue
			}
			v.Reset(ssaop.OpConst32)
			v.AuxInt = ssa.Int32ToAuxInt(0)
			return true
		}
		break
	}
	// match: (And32 x x)
	// result: x
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (And32 (Const32 [-1]) x)
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != -1 {
				continue
			}
			x := v_1
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (And32 (Const32 [0]) _)
	// result: (Const32 [0])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 {
				continue
			}
			v.Reset(ssaop.OpConst32)
			v.AuxInt = ssa.Int32ToAuxInt(0)
			return true
		}
		break
	}
	// match: (And32 (Com32 x) x)
	// result: (Const32 [0])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpCom32 {
				continue
			}
			x := v_0.Args[0]
			if x != v_1 {
				continue
			}
			v.Reset(ssaop.OpConst32)
			v.AuxInt = ssa.Int32ToAuxInt(0)
			return true
		}
		break
	}
	// match: (And32 x (And32 x y))
	// result: (And32 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpAnd32 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if x != v_1_0 {
					continue
				}
				y := v_1_1
				v.Reset(ssaop.OpAnd32)
				v.AddArg2(x, y)
				return true
			}
		}
		break
	}
	// match: (And32 (And32 i:(Const32 <t>) z) x)
	// cond: (z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32)
	// result: (And32 i (And32 <t> z x))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpAnd32 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				i := v_0_0
				if i.Op != ssaop.OpConst32 {
					continue
				}
				t := i.Type
				z := v_0_1
				x := v_1
				if !(z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32) {
					continue
				}
				v.Reset(ssaop.OpAnd32)
				v0 := b.NewValue0(v.Pos, ssaop.OpAnd32, t)
				v0.AddArg2(z, x)
				v.AddArg2(i, v0)
				return true
			}
		}
		break
	}
	// match: (And32 (Const32 <t> [c]) (And32 (Const32 <t> [d]) x))
	// result: (And32 (Const32 <t> [c&d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt32(v_0.AuxInt)
			if v_1.Op != ssaop.OpAnd32 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if v_1_0.Op != ssaop.OpConst32 || v_1_0.Type != t {
					continue
				}
				d := ssa.AuxIntToInt32(v_1_0.AuxInt)
				x := v_1_1
				v.Reset(ssaop.OpAnd32)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
				v0.AuxInt = ssa.Int32ToAuxInt(c & d)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	return false
}
func rewriteValue_OpAnd64(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (And64 (Const64 [c]) (Const64 [d]))
	// result: (Const64 [c&d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1.AuxInt)
			v.Reset(ssaop.OpConst64)
			v.AuxInt = ssa.Int64ToAuxInt(c & d)
			return true
		}
		break
	}
	// match: (And64 <t> (Com64 x) (Com64 y))
	// result: (Com64 (Or64 <t> x y))
	for {
		t := v.Type
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpCom64 {
				continue
			}
			x := v_0.Args[0]
			if v_1.Op != ssaop.OpCom64 {
				continue
			}
			y := v_1.Args[0]
			v.Reset(ssaop.OpCom64)
			v0 := b.NewValue0(v.Pos, ssaop.OpOr64, t)
			v0.AddArg2(x, y)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (And64 x (Or64 x y))
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpOr64 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if x != v_1_0 {
					continue
				}
				v.CopyOf(x)
				return true
			}
		}
		break
	}
	// match: (And64 (Const64 [m]) (Rsh64Ux64 _ (Const64 [c])))
	// cond: c >= int64(64-ssa.Ntz64(m))
	// result: (Const64 [0])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			m := ssa.AuxIntToInt64(v_0.AuxInt)
			if v_1.Op != ssaop.OpRsh64Ux64 {
				continue
			}
			_ = v_1.Args[1]
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(c >= int64(64-ssa.Ntz64(m))) {
				continue
			}
			v.Reset(ssaop.OpConst64)
			v.AuxInt = ssa.Int64ToAuxInt(0)
			return true
		}
		break
	}
	// match: (And64 (Const64 [m]) (Lsh64x64 _ (Const64 [c])))
	// cond: c >= int64(64-nlz64(m))
	// result: (Const64 [0])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			m := ssa.AuxIntToInt64(v_0.AuxInt)
			if v_1.Op != ssaop.OpLsh64x64 {
				continue
			}
			_ = v_1.Args[1]
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(c >= int64(64-nlz64(m))) {
				continue
			}
			v.Reset(ssaop.OpConst64)
			v.AuxInt = ssa.Int64ToAuxInt(0)
			return true
		}
		break
	}
	// match: (And64 x x)
	// result: x
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (And64 (Const64 [-1]) x)
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != -1 {
				continue
			}
			x := v_1
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (And64 (Const64 [0]) _)
	// result: (Const64 [0])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 {
				continue
			}
			v.Reset(ssaop.OpConst64)
			v.AuxInt = ssa.Int64ToAuxInt(0)
			return true
		}
		break
	}
	// match: (And64 (Com64 x) x)
	// result: (Const64 [0])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpCom64 {
				continue
			}
			x := v_0.Args[0]
			if x != v_1 {
				continue
			}
			v.Reset(ssaop.OpConst64)
			v.AuxInt = ssa.Int64ToAuxInt(0)
			return true
		}
		break
	}
	// match: (And64 x (And64 x y))
	// result: (And64 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpAnd64 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if x != v_1_0 {
					continue
				}
				y := v_1_1
				v.Reset(ssaop.OpAnd64)
				v.AddArg2(x, y)
				return true
			}
		}
		break
	}
	// match: (And64 (And64 i:(Const64 <t>) z) x)
	// cond: (z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64)
	// result: (And64 i (And64 <t> z x))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpAnd64 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				i := v_0_0
				if i.Op != ssaop.OpConst64 {
					continue
				}
				t := i.Type
				z := v_0_1
				x := v_1
				if !(z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64) {
					continue
				}
				v.Reset(ssaop.OpAnd64)
				v0 := b.NewValue0(v.Pos, ssaop.OpAnd64, t)
				v0.AddArg2(z, x)
				v.AddArg2(i, v0)
				return true
			}
		}
		break
	}
	// match: (And64 (Const64 <t> [c]) (And64 (Const64 <t> [d]) x))
	// result: (And64 (Const64 <t> [c&d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt64(v_0.AuxInt)
			if v_1.Op != ssaop.OpAnd64 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if v_1_0.Op != ssaop.OpConst64 || v_1_0.Type != t {
					continue
				}
				d := ssa.AuxIntToInt64(v_1_0.AuxInt)
				x := v_1_1
				v.Reset(ssaop.OpAnd64)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
				v0.AuxInt = ssa.Int64ToAuxInt(c & d)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	return false
}
func rewriteValue_OpAnd8(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (And8 (Const8 [c]) (Const8 [d]))
	// result: (Const8 [c&d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst8 {
				continue
			}
			d := ssa.AuxIntToInt8(v_1.AuxInt)
			v.Reset(ssaop.OpConst8)
			v.AuxInt = ssa.Int8ToAuxInt(c & d)
			return true
		}
		break
	}
	// match: (And8 <t> (Com8 x) (Com8 y))
	// result: (Com8 (Or8 <t> x y))
	for {
		t := v.Type
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpCom8 {
				continue
			}
			x := v_0.Args[0]
			if v_1.Op != ssaop.OpCom8 {
				continue
			}
			y := v_1.Args[0]
			v.Reset(ssaop.OpCom8)
			v0 := b.NewValue0(v.Pos, ssaop.OpOr8, t)
			v0.AddArg2(x, y)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (And8 x (Or8 x y))
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpOr8 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if x != v_1_0 {
					continue
				}
				v.CopyOf(x)
				return true
			}
		}
		break
	}
	// match: (And8 (Const8 [m]) (Rsh8Ux64 _ (Const64 [c])))
	// cond: c >= int64(8-ntz8(m))
	// result: (Const8 [0])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 {
				continue
			}
			m := ssa.AuxIntToInt8(v_0.AuxInt)
			if v_1.Op != ssaop.OpRsh8Ux64 {
				continue
			}
			_ = v_1.Args[1]
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(c >= int64(8-ntz8(m))) {
				continue
			}
			v.Reset(ssaop.OpConst8)
			v.AuxInt = ssa.Int8ToAuxInt(0)
			return true
		}
		break
	}
	// match: (And8 (Const8 [m]) (Lsh8x64 _ (Const64 [c])))
	// cond: c >= int64(8-nlz8(m))
	// result: (Const8 [0])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 {
				continue
			}
			m := ssa.AuxIntToInt8(v_0.AuxInt)
			if v_1.Op != ssaop.OpLsh8x64 {
				continue
			}
			_ = v_1.Args[1]
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(c >= int64(8-nlz8(m))) {
				continue
			}
			v.Reset(ssaop.OpConst8)
			v.AuxInt = ssa.Int8ToAuxInt(0)
			return true
		}
		break
	}
	// match: (And8 x x)
	// result: x
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (And8 (Const8 [-1]) x)
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != -1 {
				continue
			}
			x := v_1
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (And8 (Const8 [0]) _)
	// result: (Const8 [0])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 {
				continue
			}
			v.Reset(ssaop.OpConst8)
			v.AuxInt = ssa.Int8ToAuxInt(0)
			return true
		}
		break
	}
	// match: (And8 (Com8 x) x)
	// result: (Const8 [0])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpCom8 {
				continue
			}
			x := v_0.Args[0]
			if x != v_1 {
				continue
			}
			v.Reset(ssaop.OpConst8)
			v.AuxInt = ssa.Int8ToAuxInt(0)
			return true
		}
		break
	}
	// match: (And8 x (And8 x y))
	// result: (And8 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpAnd8 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if x != v_1_0 {
					continue
				}
				y := v_1_1
				v.Reset(ssaop.OpAnd8)
				v.AddArg2(x, y)
				return true
			}
		}
		break
	}
	// match: (And8 (And8 i:(Const8 <t>) z) x)
	// cond: (z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8)
	// result: (And8 i (And8 <t> z x))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpAnd8 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				i := v_0_0
				if i.Op != ssaop.OpConst8 {
					continue
				}
				t := i.Type
				z := v_0_1
				x := v_1
				if !(z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8) {
					continue
				}
				v.Reset(ssaop.OpAnd8)
				v0 := b.NewValue0(v.Pos, ssaop.OpAnd8, t)
				v0.AddArg2(z, x)
				v.AddArg2(i, v0)
				return true
			}
		}
		break
	}
	// match: (And8 (Const8 <t> [c]) (And8 (Const8 <t> [d]) x))
	// result: (And8 (Const8 <t> [c&d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt8(v_0.AuxInt)
			if v_1.Op != ssaop.OpAnd8 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if v_1_0.Op != ssaop.OpConst8 || v_1_0.Type != t {
					continue
				}
				d := ssa.AuxIntToInt8(v_1_0.AuxInt)
				x := v_1_1
				v.Reset(ssaop.OpAnd8)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
				v0.AuxInt = ssa.Int8ToAuxInt(c & d)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	return false
}
func rewriteValue_OpAndB(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (AndB (ConstBool [c]) (ConstBool [d]))
	// result: (ConstBool [c&&d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConstBool {
				continue
			}
			c := ssa.AuxIntToBool(v_0.AuxInt)
			if v_1.Op != ssaop.OpConstBool {
				continue
			}
			d := ssa.AuxIntToBool(v_1.AuxInt)
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(c && d)
			return true
		}
		break
	}
	// match: (AndB (Leq64 (Const64 [c]) x) (Less64 x (Const64 [d])))
	// cond: d >= c
	// result: (Less64U (Sub64 <x.Type> x (Const64 <x.Type> [c])) (Const64 <x.Type> [d-c]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLeq64 {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLess64 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(d >= c) {
				continue
			}
			v.Reset(ssaop.OpLess64U)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
			v1.AuxInt = ssa.Int64ToAuxInt(c)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
			v2.AuxInt = ssa.Int64ToAuxInt(d - c)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (AndB (Leq64 (Const64 [c]) x) (Leq64 x (Const64 [d])))
	// cond: d >= c
	// result: (Leq64U (Sub64 <x.Type> x (Const64 <x.Type> [c])) (Const64 <x.Type> [d-c]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLeq64 {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLeq64 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(d >= c) {
				continue
			}
			v.Reset(ssaop.OpLeq64U)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
			v1.AuxInt = ssa.Int64ToAuxInt(c)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
			v2.AuxInt = ssa.Int64ToAuxInt(d - c)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (AndB (Leq32 (Const32 [c]) x) (Less32 x (Const32 [d])))
	// cond: d >= c
	// result: (Less32U (Sub32 <x.Type> x (Const32 <x.Type> [c])) (Const32 <x.Type> [d-c]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLeq32 {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLess32 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(v_1_1.AuxInt)
			if !(d >= c) {
				continue
			}
			v.Reset(ssaop.OpLess32U)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
			v1.AuxInt = ssa.Int32ToAuxInt(c)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
			v2.AuxInt = ssa.Int32ToAuxInt(d - c)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (AndB (Leq32 (Const32 [c]) x) (Leq32 x (Const32 [d])))
	// cond: d >= c
	// result: (Leq32U (Sub32 <x.Type> x (Const32 <x.Type> [c])) (Const32 <x.Type> [d-c]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLeq32 {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLeq32 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(v_1_1.AuxInt)
			if !(d >= c) {
				continue
			}
			v.Reset(ssaop.OpLeq32U)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
			v1.AuxInt = ssa.Int32ToAuxInt(c)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
			v2.AuxInt = ssa.Int32ToAuxInt(d - c)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (AndB (Leq16 (Const16 [c]) x) (Less16 x (Const16 [d])))
	// cond: d >= c
	// result: (Less16U (Sub16 <x.Type> x (Const16 <x.Type> [c])) (Const16 <x.Type> [d-c]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLeq16 {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLess16 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst16 {
				continue
			}
			d := ssa.AuxIntToInt16(v_1_1.AuxInt)
			if !(d >= c) {
				continue
			}
			v.Reset(ssaop.OpLess16U)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
			v1.AuxInt = ssa.Int16ToAuxInt(c)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
			v2.AuxInt = ssa.Int16ToAuxInt(d - c)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (AndB (Leq16 (Const16 [c]) x) (Leq16 x (Const16 [d])))
	// cond: d >= c
	// result: (Leq16U (Sub16 <x.Type> x (Const16 <x.Type> [c])) (Const16 <x.Type> [d-c]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLeq16 {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLeq16 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst16 {
				continue
			}
			d := ssa.AuxIntToInt16(v_1_1.AuxInt)
			if !(d >= c) {
				continue
			}
			v.Reset(ssaop.OpLeq16U)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
			v1.AuxInt = ssa.Int16ToAuxInt(c)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
			v2.AuxInt = ssa.Int16ToAuxInt(d - c)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (AndB (Leq8 (Const8 [c]) x) (Less8 x (Const8 [d])))
	// cond: d >= c
	// result: (Less8U (Sub8 <x.Type> x (Const8 <x.Type> [c])) (Const8 <x.Type> [d-c]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLeq8 {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLess8 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst8 {
				continue
			}
			d := ssa.AuxIntToInt8(v_1_1.AuxInt)
			if !(d >= c) {
				continue
			}
			v.Reset(ssaop.OpLess8U)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
			v1.AuxInt = ssa.Int8ToAuxInt(c)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
			v2.AuxInt = ssa.Int8ToAuxInt(d - c)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (AndB (Leq8 (Const8 [c]) x) (Leq8 x (Const8 [d])))
	// cond: d >= c
	// result: (Leq8U (Sub8 <x.Type> x (Const8 <x.Type> [c])) (Const8 <x.Type> [d-c]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLeq8 {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLeq8 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst8 {
				continue
			}
			d := ssa.AuxIntToInt8(v_1_1.AuxInt)
			if !(d >= c) {
				continue
			}
			v.Reset(ssaop.OpLeq8U)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
			v1.AuxInt = ssa.Int8ToAuxInt(c)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
			v2.AuxInt = ssa.Int8ToAuxInt(d - c)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (AndB (Less64 (Const64 [c]) x) (Less64 x (Const64 [d])))
	// cond: d >= c+1 && c+1 > c
	// result: (Less64U (Sub64 <x.Type> x (Const64 <x.Type> [c+1])) (Const64 <x.Type> [d-c-1]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLess64 {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLess64 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(d >= c+1 && c+1 > c) {
				continue
			}
			v.Reset(ssaop.OpLess64U)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
			v1.AuxInt = ssa.Int64ToAuxInt(c + 1)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
			v2.AuxInt = ssa.Int64ToAuxInt(d - c - 1)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (AndB (Less64 (Const64 [c]) x) (Leq64 x (Const64 [d])))
	// cond: d >= c+1 && c+1 > c
	// result: (Leq64U (Sub64 <x.Type> x (Const64 <x.Type> [c+1])) (Const64 <x.Type> [d-c-1]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLess64 {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLeq64 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(d >= c+1 && c+1 > c) {
				continue
			}
			v.Reset(ssaop.OpLeq64U)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
			v1.AuxInt = ssa.Int64ToAuxInt(c + 1)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
			v2.AuxInt = ssa.Int64ToAuxInt(d - c - 1)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (AndB (Less32 (Const32 [c]) x) (Less32 x (Const32 [d])))
	// cond: d >= c+1 && c+1 > c
	// result: (Less32U (Sub32 <x.Type> x (Const32 <x.Type> [c+1])) (Const32 <x.Type> [d-c-1]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLess32 {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLess32 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(v_1_1.AuxInt)
			if !(d >= c+1 && c+1 > c) {
				continue
			}
			v.Reset(ssaop.OpLess32U)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
			v1.AuxInt = ssa.Int32ToAuxInt(c + 1)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
			v2.AuxInt = ssa.Int32ToAuxInt(d - c - 1)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (AndB (Less32 (Const32 [c]) x) (Leq32 x (Const32 [d])))
	// cond: d >= c+1 && c+1 > c
	// result: (Leq32U (Sub32 <x.Type> x (Const32 <x.Type> [c+1])) (Const32 <x.Type> [d-c-1]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLess32 {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLeq32 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(v_1_1.AuxInt)
			if !(d >= c+1 && c+1 > c) {
				continue
			}
			v.Reset(ssaop.OpLeq32U)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
			v1.AuxInt = ssa.Int32ToAuxInt(c + 1)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
			v2.AuxInt = ssa.Int32ToAuxInt(d - c - 1)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (AndB (Less16 (Const16 [c]) x) (Less16 x (Const16 [d])))
	// cond: d >= c+1 && c+1 > c
	// result: (Less16U (Sub16 <x.Type> x (Const16 <x.Type> [c+1])) (Const16 <x.Type> [d-c-1]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLess16 {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLess16 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst16 {
				continue
			}
			d := ssa.AuxIntToInt16(v_1_1.AuxInt)
			if !(d >= c+1 && c+1 > c) {
				continue
			}
			v.Reset(ssaop.OpLess16U)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
			v1.AuxInt = ssa.Int16ToAuxInt(c + 1)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
			v2.AuxInt = ssa.Int16ToAuxInt(d - c - 1)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (AndB (Less16 (Const16 [c]) x) (Leq16 x (Const16 [d])))
	// cond: d >= c+1 && c+1 > c
	// result: (Leq16U (Sub16 <x.Type> x (Const16 <x.Type> [c+1])) (Const16 <x.Type> [d-c-1]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLess16 {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLeq16 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst16 {
				continue
			}
			d := ssa.AuxIntToInt16(v_1_1.AuxInt)
			if !(d >= c+1 && c+1 > c) {
				continue
			}
			v.Reset(ssaop.OpLeq16U)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
			v1.AuxInt = ssa.Int16ToAuxInt(c + 1)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
			v2.AuxInt = ssa.Int16ToAuxInt(d - c - 1)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (AndB (Less8 (Const8 [c]) x) (Less8 x (Const8 [d])))
	// cond: d >= c+1 && c+1 > c
	// result: (Less8U (Sub8 <x.Type> x (Const8 <x.Type> [c+1])) (Const8 <x.Type> [d-c-1]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLess8 {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLess8 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst8 {
				continue
			}
			d := ssa.AuxIntToInt8(v_1_1.AuxInt)
			if !(d >= c+1 && c+1 > c) {
				continue
			}
			v.Reset(ssaop.OpLess8U)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
			v1.AuxInt = ssa.Int8ToAuxInt(c + 1)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
			v2.AuxInt = ssa.Int8ToAuxInt(d - c - 1)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (AndB (Less8 (Const8 [c]) x) (Leq8 x (Const8 [d])))
	// cond: d >= c+1 && c+1 > c
	// result: (Leq8U (Sub8 <x.Type> x (Const8 <x.Type> [c+1])) (Const8 <x.Type> [d-c-1]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLess8 {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLeq8 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst8 {
				continue
			}
			d := ssa.AuxIntToInt8(v_1_1.AuxInt)
			if !(d >= c+1 && c+1 > c) {
				continue
			}
			v.Reset(ssaop.OpLeq8U)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
			v1.AuxInt = ssa.Int8ToAuxInt(c + 1)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
			v2.AuxInt = ssa.Int8ToAuxInt(d - c - 1)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (AndB (Leq64U (Const64 [c]) x) (Less64U x (Const64 [d])))
	// cond: uint64(d) >= uint64(c)
	// result: (Less64U (Sub64 <x.Type> x (Const64 <x.Type> [c])) (Const64 <x.Type> [d-c]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLeq64U {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLess64U {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(uint64(d) >= uint64(c)) {
				continue
			}
			v.Reset(ssaop.OpLess64U)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
			v1.AuxInt = ssa.Int64ToAuxInt(c)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
			v2.AuxInt = ssa.Int64ToAuxInt(d - c)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (AndB (Leq64U (Const64 [c]) x) (Leq64U x (Const64 [d])))
	// cond: uint64(d) >= uint64(c)
	// result: (Leq64U (Sub64 <x.Type> x (Const64 <x.Type> [c])) (Const64 <x.Type> [d-c]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLeq64U {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLeq64U {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(uint64(d) >= uint64(c)) {
				continue
			}
			v.Reset(ssaop.OpLeq64U)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
			v1.AuxInt = ssa.Int64ToAuxInt(c)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
			v2.AuxInt = ssa.Int64ToAuxInt(d - c)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (AndB (Leq32U (Const32 [c]) x) (Less32U x (Const32 [d])))
	// cond: uint32(d) >= uint32(c)
	// result: (Less32U (Sub32 <x.Type> x (Const32 <x.Type> [c])) (Const32 <x.Type> [d-c]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLeq32U {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLess32U {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(v_1_1.AuxInt)
			if !(uint32(d) >= uint32(c)) {
				continue
			}
			v.Reset(ssaop.OpLess32U)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
			v1.AuxInt = ssa.Int32ToAuxInt(c)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
			v2.AuxInt = ssa.Int32ToAuxInt(d - c)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (AndB (Leq32U (Const32 [c]) x) (Leq32U x (Const32 [d])))
	// cond: uint32(d) >= uint32(c)
	// result: (Leq32U (Sub32 <x.Type> x (Const32 <x.Type> [c])) (Const32 <x.Type> [d-c]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLeq32U {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLeq32U {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(v_1_1.AuxInt)
			if !(uint32(d) >= uint32(c)) {
				continue
			}
			v.Reset(ssaop.OpLeq32U)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
			v1.AuxInt = ssa.Int32ToAuxInt(c)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
			v2.AuxInt = ssa.Int32ToAuxInt(d - c)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (AndB (Leq16U (Const16 [c]) x) (Less16U x (Const16 [d])))
	// cond: uint16(d) >= uint16(c)
	// result: (Less16U (Sub16 <x.Type> x (Const16 <x.Type> [c])) (Const16 <x.Type> [d-c]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLeq16U {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLess16U {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst16 {
				continue
			}
			d := ssa.AuxIntToInt16(v_1_1.AuxInt)
			if !(uint16(d) >= uint16(c)) {
				continue
			}
			v.Reset(ssaop.OpLess16U)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
			v1.AuxInt = ssa.Int16ToAuxInt(c)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
			v2.AuxInt = ssa.Int16ToAuxInt(d - c)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (AndB (Leq16U (Const16 [c]) x) (Leq16U x (Const16 [d])))
	// cond: uint16(d) >= uint16(c)
	// result: (Leq16U (Sub16 <x.Type> x (Const16 <x.Type> [c])) (Const16 <x.Type> [d-c]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLeq16U {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLeq16U {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst16 {
				continue
			}
			d := ssa.AuxIntToInt16(v_1_1.AuxInt)
			if !(uint16(d) >= uint16(c)) {
				continue
			}
			v.Reset(ssaop.OpLeq16U)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
			v1.AuxInt = ssa.Int16ToAuxInt(c)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
			v2.AuxInt = ssa.Int16ToAuxInt(d - c)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (AndB (Leq8U (Const8 [c]) x) (Less8U x (Const8 [d])))
	// cond: uint8(d) >= uint8(c)
	// result: (Less8U (Sub8 <x.Type> x (Const8 <x.Type> [c])) (Const8 <x.Type> [d-c]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLeq8U {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLess8U {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst8 {
				continue
			}
			d := ssa.AuxIntToInt8(v_1_1.AuxInt)
			if !(uint8(d) >= uint8(c)) {
				continue
			}
			v.Reset(ssaop.OpLess8U)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
			v1.AuxInt = ssa.Int8ToAuxInt(c)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
			v2.AuxInt = ssa.Int8ToAuxInt(d - c)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (AndB (Leq8U (Const8 [c]) x) (Leq8U x (Const8 [d])))
	// cond: uint8(d) >= uint8(c)
	// result: (Leq8U (Sub8 <x.Type> x (Const8 <x.Type> [c])) (Const8 <x.Type> [d-c]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLeq8U {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLeq8U {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst8 {
				continue
			}
			d := ssa.AuxIntToInt8(v_1_1.AuxInt)
			if !(uint8(d) >= uint8(c)) {
				continue
			}
			v.Reset(ssaop.OpLeq8U)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
			v1.AuxInt = ssa.Int8ToAuxInt(c)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
			v2.AuxInt = ssa.Int8ToAuxInt(d - c)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (AndB (Less64U (Const64 [c]) x) (Less64U x (Const64 [d])))
	// cond: uint64(d) >= uint64(c+1) && uint64(c+1) > uint64(c)
	// result: (Less64U (Sub64 <x.Type> x (Const64 <x.Type> [c+1])) (Const64 <x.Type> [d-c-1]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLess64U {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLess64U {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(uint64(d) >= uint64(c+1) && uint64(c+1) > uint64(c)) {
				continue
			}
			v.Reset(ssaop.OpLess64U)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
			v1.AuxInt = ssa.Int64ToAuxInt(c + 1)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
			v2.AuxInt = ssa.Int64ToAuxInt(d - c - 1)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (AndB (Less64U (Const64 [c]) x) (Leq64U x (Const64 [d])))
	// cond: uint64(d) >= uint64(c+1) && uint64(c+1) > uint64(c)
	// result: (Leq64U (Sub64 <x.Type> x (Const64 <x.Type> [c+1])) (Const64 <x.Type> [d-c-1]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLess64U {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLeq64U {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(uint64(d) >= uint64(c+1) && uint64(c+1) > uint64(c)) {
				continue
			}
			v.Reset(ssaop.OpLeq64U)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
			v1.AuxInt = ssa.Int64ToAuxInt(c + 1)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
			v2.AuxInt = ssa.Int64ToAuxInt(d - c - 1)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (AndB (Less32U (Const32 [c]) x) (Less32U x (Const32 [d])))
	// cond: uint32(d) >= uint32(c+1) && uint32(c+1) > uint32(c)
	// result: (Less32U (Sub32 <x.Type> x (Const32 <x.Type> [c+1])) (Const32 <x.Type> [d-c-1]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLess32U {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLess32U {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(v_1_1.AuxInt)
			if !(uint32(d) >= uint32(c+1) && uint32(c+1) > uint32(c)) {
				continue
			}
			v.Reset(ssaop.OpLess32U)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
			v1.AuxInt = ssa.Int32ToAuxInt(c + 1)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
			v2.AuxInt = ssa.Int32ToAuxInt(d - c - 1)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (AndB (Less32U (Const32 [c]) x) (Leq32U x (Const32 [d])))
	// cond: uint32(d) >= uint32(c+1) && uint32(c+1) > uint32(c)
	// result: (Leq32U (Sub32 <x.Type> x (Const32 <x.Type> [c+1])) (Const32 <x.Type> [d-c-1]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLess32U {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLeq32U {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(v_1_1.AuxInt)
			if !(uint32(d) >= uint32(c+1) && uint32(c+1) > uint32(c)) {
				continue
			}
			v.Reset(ssaop.OpLeq32U)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
			v1.AuxInt = ssa.Int32ToAuxInt(c + 1)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
			v2.AuxInt = ssa.Int32ToAuxInt(d - c - 1)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (AndB (Less16U (Const16 [c]) x) (Less16U x (Const16 [d])))
	// cond: uint16(d) >= uint16(c+1) && uint16(c+1) > uint16(c)
	// result: (Less16U (Sub16 <x.Type> x (Const16 <x.Type> [c+1])) (Const16 <x.Type> [d-c-1]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLess16U {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLess16U {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst16 {
				continue
			}
			d := ssa.AuxIntToInt16(v_1_1.AuxInt)
			if !(uint16(d) >= uint16(c+1) && uint16(c+1) > uint16(c)) {
				continue
			}
			v.Reset(ssaop.OpLess16U)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
			v1.AuxInt = ssa.Int16ToAuxInt(c + 1)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
			v2.AuxInt = ssa.Int16ToAuxInt(d - c - 1)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (AndB (Less16U (Const16 [c]) x) (Leq16U x (Const16 [d])))
	// cond: uint16(d) >= uint16(c+1) && uint16(c+1) > uint16(c)
	// result: (Leq16U (Sub16 <x.Type> x (Const16 <x.Type> [c+1])) (Const16 <x.Type> [d-c-1]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLess16U {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLeq16U {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst16 {
				continue
			}
			d := ssa.AuxIntToInt16(v_1_1.AuxInt)
			if !(uint16(d) >= uint16(c+1) && uint16(c+1) > uint16(c)) {
				continue
			}
			v.Reset(ssaop.OpLeq16U)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
			v1.AuxInt = ssa.Int16ToAuxInt(c + 1)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
			v2.AuxInt = ssa.Int16ToAuxInt(d - c - 1)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (AndB (Less8U (Const8 [c]) x) (Less8U x (Const8 [d])))
	// cond: uint8(d) >= uint8(c+1) && uint8(c+1) > uint8(c)
	// result: (Less8U (Sub8 <x.Type> x (Const8 <x.Type> [c+1])) (Const8 <x.Type> [d-c-1]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLess8U {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLess8U {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst8 {
				continue
			}
			d := ssa.AuxIntToInt8(v_1_1.AuxInt)
			if !(uint8(d) >= uint8(c+1) && uint8(c+1) > uint8(c)) {
				continue
			}
			v.Reset(ssaop.OpLess8U)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
			v1.AuxInt = ssa.Int8ToAuxInt(c + 1)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
			v2.AuxInt = ssa.Int8ToAuxInt(d - c - 1)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (AndB (Less8U (Const8 [c]) x) (Leq8U x (Const8 [d])))
	// cond: uint8(d) >= uint8(c+1) && uint8(c+1) > uint8(c)
	// result: (Leq8U (Sub8 <x.Type> x (Const8 <x.Type> [c+1])) (Const8 <x.Type> [d-c-1]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLess8U {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLeq8U {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst8 {
				continue
			}
			d := ssa.AuxIntToInt8(v_1_1.AuxInt)
			if !(uint8(d) >= uint8(c+1) && uint8(c+1) > uint8(c)) {
				continue
			}
			v.Reset(ssaop.OpLeq8U)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
			v1.AuxInt = ssa.Int8ToAuxInt(c + 1)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
			v2.AuxInt = ssa.Int8ToAuxInt(d - c - 1)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (AndB (Neq64 x (Const64 [0])) (Less64U x (Const64 [d])))
	// cond: uint64(d) >= 1
	// result: (Less64U (Sub64 <x.Type> x (Const64 <x.Type> [1])) (Const64 <x.Type> [d-1]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeq64 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				x := v_0_0
				if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 0 || v_1.Op != ssaop.OpLess64U {
					continue
				}
				_ = v_1.Args[1]
				if x != v_1.Args[0] {
					continue
				}
				v_1_1 := v_1.Args[1]
				if v_1_1.Op != ssaop.OpConst64 {
					continue
				}
				d := ssa.AuxIntToInt64(v_1_1.AuxInt)
				if !(uint64(d) >= 1) {
					continue
				}
				v.Reset(ssaop.OpLess64U)
				v0 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type)
				v1 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
				v1.AuxInt = ssa.Int64ToAuxInt(1)
				v0.AddArg2(x, v1)
				v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
				v2.AuxInt = ssa.Int64ToAuxInt(d - 1)
				v.AddArg2(v0, v2)
				return true
			}
		}
		break
	}
	// match: (AndB (Neq64 x (Const64 [0])) (Leq64U x (Const64 [d])))
	// cond: uint64(d) >= 1
	// result: (Leq64U (Sub64 <x.Type> x (Const64 <x.Type> [1])) (Const64 <x.Type> [d-1]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeq64 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				x := v_0_0
				if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 0 || v_1.Op != ssaop.OpLeq64U {
					continue
				}
				_ = v_1.Args[1]
				if x != v_1.Args[0] {
					continue
				}
				v_1_1 := v_1.Args[1]
				if v_1_1.Op != ssaop.OpConst64 {
					continue
				}
				d := ssa.AuxIntToInt64(v_1_1.AuxInt)
				if !(uint64(d) >= 1) {
					continue
				}
				v.Reset(ssaop.OpLeq64U)
				v0 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type)
				v1 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
				v1.AuxInt = ssa.Int64ToAuxInt(1)
				v0.AddArg2(x, v1)
				v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
				v2.AuxInt = ssa.Int64ToAuxInt(d - 1)
				v.AddArg2(v0, v2)
				return true
			}
		}
		break
	}
	// match: (AndB (Neq32 x (Const32 [0])) (Less32U x (Const32 [d])))
	// cond: uint32(d) >= 1
	// result: (Less32U (Sub32 <x.Type> x (Const32 <x.Type> [1])) (Const32 <x.Type> [d-1]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeq32 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				x := v_0_0
				if v_0_1.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0_1.AuxInt) != 0 || v_1.Op != ssaop.OpLess32U {
					continue
				}
				_ = v_1.Args[1]
				if x != v_1.Args[0] {
					continue
				}
				v_1_1 := v_1.Args[1]
				if v_1_1.Op != ssaop.OpConst32 {
					continue
				}
				d := ssa.AuxIntToInt32(v_1_1.AuxInt)
				if !(uint32(d) >= 1) {
					continue
				}
				v.Reset(ssaop.OpLess32U)
				v0 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type)
				v1 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
				v1.AuxInt = ssa.Int32ToAuxInt(1)
				v0.AddArg2(x, v1)
				v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
				v2.AuxInt = ssa.Int32ToAuxInt(d - 1)
				v.AddArg2(v0, v2)
				return true
			}
		}
		break
	}
	// match: (AndB (Neq32 x (Const32 [0])) (Leq32U x (Const32 [d])))
	// cond: uint32(d) >= 1
	// result: (Leq32U (Sub32 <x.Type> x (Const32 <x.Type> [1])) (Const32 <x.Type> [d-1]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeq32 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				x := v_0_0
				if v_0_1.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0_1.AuxInt) != 0 || v_1.Op != ssaop.OpLeq32U {
					continue
				}
				_ = v_1.Args[1]
				if x != v_1.Args[0] {
					continue
				}
				v_1_1 := v_1.Args[1]
				if v_1_1.Op != ssaop.OpConst32 {
					continue
				}
				d := ssa.AuxIntToInt32(v_1_1.AuxInt)
				if !(uint32(d) >= 1) {
					continue
				}
				v.Reset(ssaop.OpLeq32U)
				v0 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type)
				v1 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
				v1.AuxInt = ssa.Int32ToAuxInt(1)
				v0.AddArg2(x, v1)
				v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
				v2.AuxInt = ssa.Int32ToAuxInt(d - 1)
				v.AddArg2(v0, v2)
				return true
			}
		}
		break
	}
	// match: (AndB (Neq16 x (Const16 [0])) (Less16U x (Const16 [d])))
	// cond: uint16(d) >= 1
	// result: (Less16U (Sub16 <x.Type> x (Const16 <x.Type> [1])) (Const16 <x.Type> [d-1]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeq16 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				x := v_0_0
				if v_0_1.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0_1.AuxInt) != 0 || v_1.Op != ssaop.OpLess16U {
					continue
				}
				_ = v_1.Args[1]
				if x != v_1.Args[0] {
					continue
				}
				v_1_1 := v_1.Args[1]
				if v_1_1.Op != ssaop.OpConst16 {
					continue
				}
				d := ssa.AuxIntToInt16(v_1_1.AuxInt)
				if !(uint16(d) >= 1) {
					continue
				}
				v.Reset(ssaop.OpLess16U)
				v0 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type)
				v1 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
				v1.AuxInt = ssa.Int16ToAuxInt(1)
				v0.AddArg2(x, v1)
				v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
				v2.AuxInt = ssa.Int16ToAuxInt(d - 1)
				v.AddArg2(v0, v2)
				return true
			}
		}
		break
	}
	// match: (AndB (Neq16 x (Const16 [0])) (Leq16U x (Const16 [d])))
	// cond: uint16(d) >= 1
	// result: (Leq16U (Sub16 <x.Type> x (Const16 <x.Type> [1])) (Const16 <x.Type> [d-1]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeq16 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				x := v_0_0
				if v_0_1.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0_1.AuxInt) != 0 || v_1.Op != ssaop.OpLeq16U {
					continue
				}
				_ = v_1.Args[1]
				if x != v_1.Args[0] {
					continue
				}
				v_1_1 := v_1.Args[1]
				if v_1_1.Op != ssaop.OpConst16 {
					continue
				}
				d := ssa.AuxIntToInt16(v_1_1.AuxInt)
				if !(uint16(d) >= 1) {
					continue
				}
				v.Reset(ssaop.OpLeq16U)
				v0 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type)
				v1 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
				v1.AuxInt = ssa.Int16ToAuxInt(1)
				v0.AddArg2(x, v1)
				v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
				v2.AuxInt = ssa.Int16ToAuxInt(d - 1)
				v.AddArg2(v0, v2)
				return true
			}
		}
		break
	}
	// match: (AndB (Neq8 x (Const8 [0])) (Less8U x (Const8 [d])))
	// cond: uint8(d) >= 1
	// result: (Less8U (Sub8 <x.Type> x (Const8 <x.Type> [1])) (Const8 <x.Type> [d-1]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeq8 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				x := v_0_0
				if v_0_1.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0_1.AuxInt) != 0 || v_1.Op != ssaop.OpLess8U {
					continue
				}
				_ = v_1.Args[1]
				if x != v_1.Args[0] {
					continue
				}
				v_1_1 := v_1.Args[1]
				if v_1_1.Op != ssaop.OpConst8 {
					continue
				}
				d := ssa.AuxIntToInt8(v_1_1.AuxInt)
				if !(uint8(d) >= 1) {
					continue
				}
				v.Reset(ssaop.OpLess8U)
				v0 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type)
				v1 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
				v1.AuxInt = ssa.Int8ToAuxInt(1)
				v0.AddArg2(x, v1)
				v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
				v2.AuxInt = ssa.Int8ToAuxInt(d - 1)
				v.AddArg2(v0, v2)
				return true
			}
		}
		break
	}
	// match: (AndB (Neq8 x (Const8 [0])) (Leq8U x (Const8 [d])))
	// cond: uint8(d) >= 1
	// result: (Leq8U (Sub8 <x.Type> x (Const8 <x.Type> [1])) (Const8 <x.Type> [d-1]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeq8 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				x := v_0_0
				if v_0_1.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0_1.AuxInt) != 0 || v_1.Op != ssaop.OpLeq8U {
					continue
				}
				_ = v_1.Args[1]
				if x != v_1.Args[0] {
					continue
				}
				v_1_1 := v_1.Args[1]
				if v_1_1.Op != ssaop.OpConst8 {
					continue
				}
				d := ssa.AuxIntToInt8(v_1_1.AuxInt)
				if !(uint8(d) >= 1) {
					continue
				}
				v.Reset(ssaop.OpLeq8U)
				v0 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type)
				v1 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
				v1.AuxInt = ssa.Int8ToAuxInt(1)
				v0.AddArg2(x, v1)
				v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
				v2.AuxInt = ssa.Int8ToAuxInt(d - 1)
				v.AddArg2(v0, v2)
				return true
			}
		}
		break
	}
	// match: (AndB (Neq64 x cv:(Const64 [c])) (Neq64 x (Const64 [d])))
	// cond: c|d == c && ssa.OneBit(c^d)
	// result: (Neq64 (Or64 <x.Type> x (Const64 <x.Type> [c^d])) cv)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeq64 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				x := v_0_0
				cv := v_0_1
				if cv.Op != ssaop.OpConst64 {
					continue
				}
				c := ssa.AuxIntToInt64(cv.AuxInt)
				if v_1.Op != ssaop.OpNeq64 {
					continue
				}
				_ = v_1.Args[1]
				v_1_0 := v_1.Args[0]
				v_1_1 := v_1.Args[1]
				for _i2 := 0; _i2 <= 1; _i2, v_1_0, v_1_1 = _i2+1, v_1_1, v_1_0 {
					if x != v_1_0 || v_1_1.Op != ssaop.OpConst64 {
						continue
					}
					d := ssa.AuxIntToInt64(v_1_1.AuxInt)
					if !(c|d == c && ssa.OneBit(c^d)) {
						continue
					}
					v.Reset(ssaop.OpNeq64)
					v0 := b.NewValue0(v.Pos, ssaop.OpOr64, x.Type)
					v1 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
					v1.AuxInt = ssa.Int64ToAuxInt(c ^ d)
					v0.AddArg2(x, v1)
					v.AddArg2(v0, cv)
					return true
				}
			}
		}
		break
	}
	// match: (AndB (Neq32 x cv:(Const32 [c])) (Neq32 x (Const32 [d])))
	// cond: c|d == c && ssa.OneBit(c^d)
	// result: (Neq32 (Or32 <x.Type> x (Const32 <x.Type> [c^d])) cv)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeq32 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				x := v_0_0
				cv := v_0_1
				if cv.Op != ssaop.OpConst32 {
					continue
				}
				c := ssa.AuxIntToInt32(cv.AuxInt)
				if v_1.Op != ssaop.OpNeq32 {
					continue
				}
				_ = v_1.Args[1]
				v_1_0 := v_1.Args[0]
				v_1_1 := v_1.Args[1]
				for _i2 := 0; _i2 <= 1; _i2, v_1_0, v_1_1 = _i2+1, v_1_1, v_1_0 {
					if x != v_1_0 || v_1_1.Op != ssaop.OpConst32 {
						continue
					}
					d := ssa.AuxIntToInt32(v_1_1.AuxInt)
					if !(c|d == c && ssa.OneBit(c^d)) {
						continue
					}
					v.Reset(ssaop.OpNeq32)
					v0 := b.NewValue0(v.Pos, ssaop.OpOr32, x.Type)
					v1 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
					v1.AuxInt = ssa.Int32ToAuxInt(c ^ d)
					v0.AddArg2(x, v1)
					v.AddArg2(v0, cv)
					return true
				}
			}
		}
		break
	}
	// match: (AndB (Neq16 x cv:(Const16 [c])) (Neq16 x (Const16 [d])))
	// cond: c|d == c && ssa.OneBit(c^d)
	// result: (Neq16 (Or16 <x.Type> x (Const16 <x.Type> [c^d])) cv)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeq16 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				x := v_0_0
				cv := v_0_1
				if cv.Op != ssaop.OpConst16 {
					continue
				}
				c := ssa.AuxIntToInt16(cv.AuxInt)
				if v_1.Op != ssaop.OpNeq16 {
					continue
				}
				_ = v_1.Args[1]
				v_1_0 := v_1.Args[0]
				v_1_1 := v_1.Args[1]
				for _i2 := 0; _i2 <= 1; _i2, v_1_0, v_1_1 = _i2+1, v_1_1, v_1_0 {
					if x != v_1_0 || v_1_1.Op != ssaop.OpConst16 {
						continue
					}
					d := ssa.AuxIntToInt16(v_1_1.AuxInt)
					if !(c|d == c && ssa.OneBit(c^d)) {
						continue
					}
					v.Reset(ssaop.OpNeq16)
					v0 := b.NewValue0(v.Pos, ssaop.OpOr16, x.Type)
					v1 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
					v1.AuxInt = ssa.Int16ToAuxInt(c ^ d)
					v0.AddArg2(x, v1)
					v.AddArg2(v0, cv)
					return true
				}
			}
		}
		break
	}
	// match: (AndB (Neq8 x cv:(Const8 [c])) (Neq8 x (Const8 [d])))
	// cond: c|d == c && ssa.OneBit(c^d)
	// result: (Neq8 (Or8 <x.Type> x (Const8 <x.Type> [c^d])) cv)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeq8 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				x := v_0_0
				cv := v_0_1
				if cv.Op != ssaop.OpConst8 {
					continue
				}
				c := ssa.AuxIntToInt8(cv.AuxInt)
				if v_1.Op != ssaop.OpNeq8 {
					continue
				}
				_ = v_1.Args[1]
				v_1_0 := v_1.Args[0]
				v_1_1 := v_1.Args[1]
				for _i2 := 0; _i2 <= 1; _i2, v_1_0, v_1_1 = _i2+1, v_1_1, v_1_0 {
					if x != v_1_0 || v_1_1.Op != ssaop.OpConst8 {
						continue
					}
					d := ssa.AuxIntToInt8(v_1_1.AuxInt)
					if !(c|d == c && ssa.OneBit(c^d)) {
						continue
					}
					v.Reset(ssaop.OpNeq8)
					v0 := b.NewValue0(v.Pos, ssaop.OpOr8, x.Type)
					v1 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
					v1.AuxInt = ssa.Int8ToAuxInt(c ^ d)
					v0.AddArg2(x, v1)
					v.AddArg2(v0, cv)
					return true
				}
			}
		}
		break
	}
	// match: (AndB x x)
	// result: x
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (AndB (ConstBool [true]) x)
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConstBool || ssa.AuxIntToBool(v_0.AuxInt) != true {
				continue
			}
			x := v_1
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (AndB (ConstBool [false]) _)
	// result: (ConstBool [false])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConstBool || ssa.AuxIntToBool(v_0.AuxInt) != false {
				continue
			}
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(false)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpArraySelect(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (ArraySelect (ArrayMake1 x))
	// result: x
	for {
		if v_0.Op != ssaop.OpArrayMake1 {
			break
		}
		x := v_0.Args[0]
		v.CopyOf(x)
		return true
	}
	// match: (ArraySelect [0] (IData x))
	// result: (IData x)
	for {
		if ssa.AuxIntToInt64(v.AuxInt) != 0 || v_0.Op != ssaop.OpIData {
			break
		}
		x := v_0.Args[0]
		v.Reset(ssaop.OpIData)
		v.AddArg(x)
		return true
	}
	return false
}
func rewriteValue_OpBitLen16(v *ssa.Value) bool {
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	// match: (BitLen16 (Const16 [c]))
	// cond: config.PtrSize == 8
	// result: (Const64 [int64(bits.Len16(uint16(c)))])
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_0.AuxInt)
		if !(config.PtrSize == 8) {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(int64(bits.Len16(uint16(c))))
		return true
	}
	// match: (BitLen16 (Const16 [c]))
	// cond: config.PtrSize == 4
	// result: (Const32 [int32(bits.Len16(uint16(c)))])
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_0.AuxInt)
		if !(config.PtrSize == 4) {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(int32(bits.Len16(uint16(c))))
		return true
	}
	return false
}
func rewriteValue_OpBitLen32(v *ssa.Value) bool {
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	// match: (BitLen32 (Const32 [c]))
	// cond: config.PtrSize == 8
	// result: (Const64 [int64(bits.Len32(uint32(c)))])
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_0.AuxInt)
		if !(config.PtrSize == 8) {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(int64(bits.Len32(uint32(c))))
		return true
	}
	// match: (BitLen32 (Const32 [c]))
	// cond: config.PtrSize == 4
	// result: (Const32 [int32(bits.Len32(uint32(c)))])
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_0.AuxInt)
		if !(config.PtrSize == 4) {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(int32(bits.Len32(uint32(c))))
		return true
	}
	return false
}
func rewriteValue_OpBitLen64(v *ssa.Value) bool {
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	// match: (BitLen64 (Const64 [c]))
	// cond: config.PtrSize == 8
	// result: (Const64 [int64(bits.Len64(uint64(c)))])
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0.AuxInt)
		if !(config.PtrSize == 8) {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(int64(bits.Len64(uint64(c))))
		return true
	}
	// match: (BitLen64 (Const64 [c]))
	// cond: config.PtrSize == 4
	// result: (Const32 [int32(bits.Len64(uint64(c)))])
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0.AuxInt)
		if !(config.PtrSize == 4) {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(int32(bits.Len64(uint64(c))))
		return true
	}
	return false
}
func rewriteValue_OpBitLen8(v *ssa.Value) bool {
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	// match: (BitLen8 (Const8 [c]))
	// cond: config.PtrSize == 8
	// result: (Const64 [int64(bits.Len8(uint8(c)))])
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_0.AuxInt)
		if !(config.PtrSize == 8) {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(int64(bits.Len8(uint8(c))))
		return true
	}
	// match: (BitLen8 (Const8 [c]))
	// cond: config.PtrSize == 4
	// result: (Const32 [int32(bits.Len8(uint8(c)))])
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_0.AuxInt)
		if !(config.PtrSize == 4) {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(int32(bits.Len8(uint8(c))))
		return true
	}
	return false
}
func rewriteValue_OpBitRev16(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (BitRev16 (Const16 [c]))
	// result: (Const16 [int16(bits.Reverse16(uint16(c)))])
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_0.AuxInt)
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(int16(bits.Reverse16(uint16(c))))
		return true
	}
	return false
}
func rewriteValue_OpBitRev32(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (BitRev32 (Const32 [c]))
	// result: (Const32 [int32(bits.Reverse32(uint32(c)))])
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_0.AuxInt)
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(int32(bits.Reverse32(uint32(c))))
		return true
	}
	return false
}
func rewriteValue_OpBitRev64(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (BitRev64 (Const64 [c]))
	// result: (Const64 [int64(bits.Reverse64(uint64(c)))])
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0.AuxInt)
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(int64(bits.Reverse64(uint64(c))))
		return true
	}
	return false
}
func rewriteValue_OpBitRev8(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (BitRev8 (Const8 [c]))
	// result: (Const8 [int8(bits.Reverse8(uint8(c)))])
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_0.AuxInt)
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(int8(bits.Reverse8(uint8(c))))
		return true
	}
	return false
}
func rewriteValue_OpBswap16(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (Bswap16 (Const16 [c]))
	// result: (Const16 [int16(bits.ReverseBytes16(uint16(c)))])
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_0.AuxInt)
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(int16(bits.ReverseBytes16(uint16(c))))
		return true
	}
	return false
}
func rewriteValue_OpBswap32(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (Bswap32 (Const32 [c]))
	// result: (Const32 [int32(bits.ReverseBytes32(uint32(c)))])
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_0.AuxInt)
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(int32(bits.ReverseBytes32(uint32(c))))
		return true
	}
	return false
}
func rewriteValue_OpBswap64(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (Bswap64 (Const64 [c]))
	// result: (Const64 [int64(bits.ReverseBytes64(uint64(c)))])
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0.AuxInt)
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(int64(bits.ReverseBytes64(uint64(c))))
		return true
	}
	return false
}
func rewriteValue_OpCeil(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (Ceil (Const64F [c]))
	// result: (Const64F [math.Ceil(c)])
	for {
		if v_0.Op != ssaop.OpConst64F {
			break
		}
		c := ssa.AuxIntToFloat64(v_0.AuxInt)
		v.Reset(ssaop.OpConst64F)
		v.AuxInt = ssa.Float64ToAuxInt(math.Ceil(c))
		return true
	}
	return false
}
func rewriteValue_OpCom16(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (Com16 (Com16 x))
	// result: x
	for {
		if v_0.Op != ssaop.OpCom16 {
			break
		}
		x := v_0.Args[0]
		v.CopyOf(x)
		return true
	}
	// match: (Com16 (Const16 [c]))
	// result: (Const16 [^c])
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_0.AuxInt)
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(^c)
		return true
	}
	// match: (Com16 (Add16 (Const16 [-1]) x))
	// result: (Neg16 x)
	for {
		if v_0.Op != ssaop.OpAdd16 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			if v_0_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0_0.AuxInt) != -1 {
				continue
			}
			x := v_0_1
			v.Reset(ssaop.OpNeg16)
			v.AddArg(x)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpCom32(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (Com32 (Com32 x))
	// result: x
	for {
		if v_0.Op != ssaop.OpCom32 {
			break
		}
		x := v_0.Args[0]
		v.CopyOf(x)
		return true
	}
	// match: (Com32 (Const32 [c]))
	// result: (Const32 [^c])
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_0.AuxInt)
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(^c)
		return true
	}
	// match: (Com32 (Add32 (Const32 [-1]) x))
	// result: (Neg32 x)
	for {
		if v_0.Op != ssaop.OpAdd32 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			if v_0_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0_0.AuxInt) != -1 {
				continue
			}
			x := v_0_1
			v.Reset(ssaop.OpNeg32)
			v.AddArg(x)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpCom64(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (Com64 (Com64 x))
	// result: x
	for {
		if v_0.Op != ssaop.OpCom64 {
			break
		}
		x := v_0.Args[0]
		v.CopyOf(x)
		return true
	}
	// match: (Com64 (Const64 [c]))
	// result: (Const64 [^c])
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0.AuxInt)
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(^c)
		return true
	}
	// match: (Com64 (Add64 (Const64 [-1]) x))
	// result: (Neg64 x)
	for {
		if v_0.Op != ssaop.OpAdd64 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			if v_0_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_0.AuxInt) != -1 {
				continue
			}
			x := v_0_1
			v.Reset(ssaop.OpNeg64)
			v.AddArg(x)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpCom8(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (Com8 (Com8 x))
	// result: x
	for {
		if v_0.Op != ssaop.OpCom8 {
			break
		}
		x := v_0.Args[0]
		v.CopyOf(x)
		return true
	}
	// match: (Com8 (Const8 [c]))
	// result: (Const8 [^c])
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_0.AuxInt)
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(^c)
		return true
	}
	// match: (Com8 (Add8 (Const8 [-1]) x))
	// result: (Neg8 x)
	for {
		if v_0.Op != ssaop.OpAdd8 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			if v_0_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0_0.AuxInt) != -1 {
				continue
			}
			x := v_0_1
			v.Reset(ssaop.OpNeg8)
			v.AddArg(x)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpCondSelect(v *ssa.Value) bool {
	v_2 := v.Args[2]
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	// match: (CondSelect x _ (ConstBool [true ]))
	// result: x
	for {
		x := v_0
		if v_2.Op != ssaop.OpConstBool || ssa.AuxIntToBool(v_2.AuxInt) != true {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (CondSelect _ y (ConstBool [false]))
	// result: y
	for {
		y := v_1
		if v_2.Op != ssaop.OpConstBool || ssa.AuxIntToBool(v_2.AuxInt) != false {
			break
		}
		v.CopyOf(y)
		return true
	}
	// match: (CondSelect x x _)
	// result: x
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (CondSelect op1:(Add8 <t> x c:(Const8)) x bool)
	// cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)
	// result: (Add8 x (Mul8 <t> c (CvtBoolToUint8 <t> bool)))
	for {
		op1 := v_0
		if op1.Op != ssaop.OpAdd8 {
			break
		}
		t := op1.Type
		_ = op1.Args[1]
		op1_0 := op1.Args[0]
		op1_1 := op1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 {
			x := op1_0
			c := op1_1
			if c.Op != ssaop.OpConst8 || x != v_1 {
				continue
			}
			bool := v_2
			if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) {
				continue
			}
			v.Reset(ssaop.OpAdd8)
			v0 := b.NewValue0(v.Pos, ssaop.OpMul8, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, t)
			v1.AddArg(bool)
			v0.AddArg2(c, v1)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (CondSelect op1:(Add64 <t> x c:(Const64)) x bool)
	// cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)
	// result: (Add64 x (Mul64 <t> c (ZeroExt8to64 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> bool))))
	for {
		op1 := v_0
		if op1.Op != ssaop.OpAdd64 {
			break
		}
		t := op1.Type
		_ = op1.Args[1]
		op1_0 := op1.Args[0]
		op1_1 := op1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 {
			x := op1_0
			c := op1_1
			if c.Op != ssaop.OpConst64 || x != v_1 {
				continue
			}
			bool := v_2
			if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) {
				continue
			}
			v.Reset(ssaop.OpAdd64)
			v0 := b.NewValue0(v.Pos, ssaop.OpMul64, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to64, t)
			v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
			v2.AddArg(bool)
			v1.AddArg(v2)
			v0.AddArg2(c, v1)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (CondSelect op1:(Add32 <t> x c:(Const32)) x bool)
	// cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)
	// result: (Add32 x (Mul32 <t> c (ZeroExt8to32 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> bool))))
	for {
		op1 := v_0
		if op1.Op != ssaop.OpAdd32 {
			break
		}
		t := op1.Type
		_ = op1.Args[1]
		op1_0 := op1.Args[0]
		op1_1 := op1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 {
			x := op1_0
			c := op1_1
			if c.Op != ssaop.OpConst32 || x != v_1 {
				continue
			}
			bool := v_2
			if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) {
				continue
			}
			v.Reset(ssaop.OpAdd32)
			v0 := b.NewValue0(v.Pos, ssaop.OpMul32, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to32, t)
			v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
			v2.AddArg(bool)
			v1.AddArg(v2)
			v0.AddArg2(c, v1)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (CondSelect op1:(Add16 <t> x c:(Const16)) x bool)
	// cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)
	// result: (Add16 x (Mul16 <t> c (ZeroExt8to16 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> bool))))
	for {
		op1 := v_0
		if op1.Op != ssaop.OpAdd16 {
			break
		}
		t := op1.Type
		_ = op1.Args[1]
		op1_0 := op1.Args[0]
		op1_1 := op1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 {
			x := op1_0
			c := op1_1
			if c.Op != ssaop.OpConst16 || x != v_1 {
				continue
			}
			bool := v_2
			if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) {
				continue
			}
			v.Reset(ssaop.OpAdd16)
			v0 := b.NewValue0(v.Pos, ssaop.OpMul16, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to16, t)
			v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
			v2.AddArg(bool)
			v1.AddArg(v2)
			v0.AddArg2(c, v1)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (CondSelect x op1:(Add8 <t> x c:(Const8)) bool)
	// cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)
	// result: (Add8 x (Mul8 <t> c (CvtBoolToUint8 <t> (Not <bool.Type> bool))))
	for {
		x := v_0
		op1 := v_1
		if op1.Op != ssaop.OpAdd8 {
			break
		}
		t := op1.Type
		_ = op1.Args[1]
		op1_0 := op1.Args[0]
		op1_1 := op1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 {
			if x != op1_0 {
				continue
			}
			c := op1_1
			if c.Op != ssaop.OpConst8 {
				continue
			}
			bool := v_2
			if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) {
				continue
			}
			v.Reset(ssaop.OpAdd8)
			v0 := b.NewValue0(v.Pos, ssaop.OpMul8, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, t)
			v2 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type)
			v2.AddArg(bool)
			v1.AddArg(v2)
			v0.AddArg2(c, v1)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (CondSelect x op1:(Add64 <t> x c:(Const64)) bool)
	// cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)
	// result: (Add64 x (Mul64 <t> c (ZeroExt8to64 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool)))))
	for {
		x := v_0
		op1 := v_1
		if op1.Op != ssaop.OpAdd64 {
			break
		}
		t := op1.Type
		_ = op1.Args[1]
		op1_0 := op1.Args[0]
		op1_1 := op1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 {
			if x != op1_0 {
				continue
			}
			c := op1_1
			if c.Op != ssaop.OpConst64 {
				continue
			}
			bool := v_2
			if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) {
				continue
			}
			v.Reset(ssaop.OpAdd64)
			v0 := b.NewValue0(v.Pos, ssaop.OpMul64, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to64, t)
			v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
			v3 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type)
			v3.AddArg(bool)
			v2.AddArg(v3)
			v1.AddArg(v2)
			v0.AddArg2(c, v1)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (CondSelect x op1:(Add32 <t> x c:(Const32)) bool)
	// cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)
	// result: (Add32 x (Mul32 <t> c (ZeroExt8to32 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool)))))
	for {
		x := v_0
		op1 := v_1
		if op1.Op != ssaop.OpAdd32 {
			break
		}
		t := op1.Type
		_ = op1.Args[1]
		op1_0 := op1.Args[0]
		op1_1 := op1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 {
			if x != op1_0 {
				continue
			}
			c := op1_1
			if c.Op != ssaop.OpConst32 {
				continue
			}
			bool := v_2
			if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) {
				continue
			}
			v.Reset(ssaop.OpAdd32)
			v0 := b.NewValue0(v.Pos, ssaop.OpMul32, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to32, t)
			v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
			v3 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type)
			v3.AddArg(bool)
			v2.AddArg(v3)
			v1.AddArg(v2)
			v0.AddArg2(c, v1)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (CondSelect x op1:(Add16 <t> x c:(Const16)) bool)
	// cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)
	// result: (Add16 x (Mul16 <t> c (ZeroExt8to16 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool)))))
	for {
		x := v_0
		op1 := v_1
		if op1.Op != ssaop.OpAdd16 {
			break
		}
		t := op1.Type
		_ = op1.Args[1]
		op1_0 := op1.Args[0]
		op1_1 := op1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 {
			if x != op1_0 {
				continue
			}
			c := op1_1
			if c.Op != ssaop.OpConst16 {
				continue
			}
			bool := v_2
			if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) {
				continue
			}
			v.Reset(ssaop.OpAdd16)
			v0 := b.NewValue0(v.Pos, ssaop.OpMul16, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to16, t)
			v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
			v3 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type)
			v3.AddArg(bool)
			v2.AddArg(v3)
			v1.AddArg(v2)
			v0.AddArg2(c, v1)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (CondSelect op1:(Add8 <t> x c:(Const8 [consT])) x bool)
	// cond: !rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) && rewriteCondSelectIntoMath(config, addToSub(op1.Op), -c.AuxInt)
	// result: (Sub8 x (Mul8 <t> (Const8 <t> [-consT]) (CvtBoolToUint8 <t> bool)))
	for {
		op1 := v_0
		if op1.Op != ssaop.OpAdd8 {
			break
		}
		t := op1.Type
		_ = op1.Args[1]
		op1_0 := op1.Args[0]
		op1_1 := op1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 {
			x := op1_0
			c := op1_1
			if c.Op != ssaop.OpConst8 {
				continue
			}
			consT := ssa.AuxIntToInt8(c.AuxInt)
			if x != v_1 {
				continue
			}
			bool := v_2
			if !(!rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) && rewriteCondSelectIntoMath(config, addToSub(op1.Op), -c.AuxInt)) {
				continue
			}
			v.Reset(ssaop.OpSub8)
			v0 := b.NewValue0(v.Pos, ssaop.OpMul8, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
			v1.AuxInt = ssa.Int8ToAuxInt(-consT)
			v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, t)
			v2.AddArg(bool)
			v0.AddArg2(v1, v2)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (CondSelect op1:(Add64 <t> x c:(Const64 [consT])) x bool)
	// cond: !rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) && rewriteCondSelectIntoMath(config, addToSub(op1.Op), -c.AuxInt)
	// result: (Sub64 x (Mul64 <t> (Const64 <t> [-consT]) (ZeroExt8to64 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> bool))))
	for {
		op1 := v_0
		if op1.Op != ssaop.OpAdd64 {
			break
		}
		t := op1.Type
		_ = op1.Args[1]
		op1_0 := op1.Args[0]
		op1_1 := op1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 {
			x := op1_0
			c := op1_1
			if c.Op != ssaop.OpConst64 {
				continue
			}
			consT := ssa.AuxIntToInt64(c.AuxInt)
			if x != v_1 {
				continue
			}
			bool := v_2
			if !(!rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) && rewriteCondSelectIntoMath(config, addToSub(op1.Op), -c.AuxInt)) {
				continue
			}
			v.Reset(ssaop.OpSub64)
			v0 := b.NewValue0(v.Pos, ssaop.OpMul64, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
			v1.AuxInt = ssa.Int64ToAuxInt(-consT)
			v2 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to64, t)
			v3 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
			v3.AddArg(bool)
			v2.AddArg(v3)
			v0.AddArg2(v1, v2)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (CondSelect op1:(Add32 <t> x c:(Const32 [consT])) x bool)
	// cond: !rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) && rewriteCondSelectIntoMath(config, addToSub(op1.Op), -c.AuxInt)
	// result: (Sub32 x (Mul32 <t> (Const32 <t> [-consT]) (ZeroExt8to32 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> bool))))
	for {
		op1 := v_0
		if op1.Op != ssaop.OpAdd32 {
			break
		}
		t := op1.Type
		_ = op1.Args[1]
		op1_0 := op1.Args[0]
		op1_1 := op1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 {
			x := op1_0
			c := op1_1
			if c.Op != ssaop.OpConst32 {
				continue
			}
			consT := ssa.AuxIntToInt32(c.AuxInt)
			if x != v_1 {
				continue
			}
			bool := v_2
			if !(!rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) && rewriteCondSelectIntoMath(config, addToSub(op1.Op), -c.AuxInt)) {
				continue
			}
			v.Reset(ssaop.OpSub32)
			v0 := b.NewValue0(v.Pos, ssaop.OpMul32, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
			v1.AuxInt = ssa.Int32ToAuxInt(-consT)
			v2 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to32, t)
			v3 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
			v3.AddArg(bool)
			v2.AddArg(v3)
			v0.AddArg2(v1, v2)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (CondSelect op1:(Add16 <t> x c:(Const16 [consT])) x bool)
	// cond: !rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) && rewriteCondSelectIntoMath(config, addToSub(op1.Op), -c.AuxInt)
	// result: (Sub16 x (Mul16 <t> (Const16 <t> [-consT]) (ZeroExt8to16 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> bool))))
	for {
		op1 := v_0
		if op1.Op != ssaop.OpAdd16 {
			break
		}
		t := op1.Type
		_ = op1.Args[1]
		op1_0 := op1.Args[0]
		op1_1 := op1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 {
			x := op1_0
			c := op1_1
			if c.Op != ssaop.OpConst16 {
				continue
			}
			consT := ssa.AuxIntToInt16(c.AuxInt)
			if x != v_1 {
				continue
			}
			bool := v_2
			if !(!rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) && rewriteCondSelectIntoMath(config, addToSub(op1.Op), -c.AuxInt)) {
				continue
			}
			v.Reset(ssaop.OpSub16)
			v0 := b.NewValue0(v.Pos, ssaop.OpMul16, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
			v1.AuxInt = ssa.Int16ToAuxInt(-consT)
			v2 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to16, t)
			v3 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
			v3.AddArg(bool)
			v2.AddArg(v3)
			v0.AddArg2(v1, v2)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (CondSelect x op1:(Add8 <t> x c:(Const8 [consT])) bool)
	// cond: !rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) && rewriteCondSelectIntoMath(config, addToSub(op1.Op), -c.AuxInt)
	// result: (Sub8 x (Mul8 <t> (Const8 <t> [-consT]) (CvtBoolToUint8 <t> (Not <bool.Type> bool))))
	for {
		x := v_0
		op1 := v_1
		if op1.Op != ssaop.OpAdd8 {
			break
		}
		t := op1.Type
		_ = op1.Args[1]
		op1_0 := op1.Args[0]
		op1_1 := op1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 {
			if x != op1_0 {
				continue
			}
			c := op1_1
			if c.Op != ssaop.OpConst8 {
				continue
			}
			consT := ssa.AuxIntToInt8(c.AuxInt)
			bool := v_2
			if !(!rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) && rewriteCondSelectIntoMath(config, addToSub(op1.Op), -c.AuxInt)) {
				continue
			}
			v.Reset(ssaop.OpSub8)
			v0 := b.NewValue0(v.Pos, ssaop.OpMul8, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
			v1.AuxInt = ssa.Int8ToAuxInt(-consT)
			v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, t)
			v3 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type)
			v3.AddArg(bool)
			v2.AddArg(v3)
			v0.AddArg2(v1, v2)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (CondSelect x op1:(Add64 <t> x c:(Const64 [consT])) bool)
	// cond: !rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) && rewriteCondSelectIntoMath(config, addToSub(op1.Op), -c.AuxInt)
	// result: (Sub64 x (Mul64 <t> (Const64 <t> [-consT]) (ZeroExt8to64 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool)))))
	for {
		x := v_0
		op1 := v_1
		if op1.Op != ssaop.OpAdd64 {
			break
		}
		t := op1.Type
		_ = op1.Args[1]
		op1_0 := op1.Args[0]
		op1_1 := op1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 {
			if x != op1_0 {
				continue
			}
			c := op1_1
			if c.Op != ssaop.OpConst64 {
				continue
			}
			consT := ssa.AuxIntToInt64(c.AuxInt)
			bool := v_2
			if !(!rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) && rewriteCondSelectIntoMath(config, addToSub(op1.Op), -c.AuxInt)) {
				continue
			}
			v.Reset(ssaop.OpSub64)
			v0 := b.NewValue0(v.Pos, ssaop.OpMul64, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
			v1.AuxInt = ssa.Int64ToAuxInt(-consT)
			v2 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to64, t)
			v3 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
			v4 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type)
			v4.AddArg(bool)
			v3.AddArg(v4)
			v2.AddArg(v3)
			v0.AddArg2(v1, v2)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (CondSelect x op1:(Add32 <t> x c:(Const32 [consT])) bool)
	// cond: !rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) && rewriteCondSelectIntoMath(config, addToSub(op1.Op), -c.AuxInt)
	// result: (Sub32 x (Mul32 <t> (Const32 <t> [-consT]) (ZeroExt8to32 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool)))))
	for {
		x := v_0
		op1 := v_1
		if op1.Op != ssaop.OpAdd32 {
			break
		}
		t := op1.Type
		_ = op1.Args[1]
		op1_0 := op1.Args[0]
		op1_1 := op1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 {
			if x != op1_0 {
				continue
			}
			c := op1_1
			if c.Op != ssaop.OpConst32 {
				continue
			}
			consT := ssa.AuxIntToInt32(c.AuxInt)
			bool := v_2
			if !(!rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) && rewriteCondSelectIntoMath(config, addToSub(op1.Op), -c.AuxInt)) {
				continue
			}
			v.Reset(ssaop.OpSub32)
			v0 := b.NewValue0(v.Pos, ssaop.OpMul32, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
			v1.AuxInt = ssa.Int32ToAuxInt(-consT)
			v2 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to32, t)
			v3 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
			v4 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type)
			v4.AddArg(bool)
			v3.AddArg(v4)
			v2.AddArg(v3)
			v0.AddArg2(v1, v2)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (CondSelect x op1:(Add16 <t> x c:(Const16 [consT])) bool)
	// cond: !rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) && rewriteCondSelectIntoMath(config, addToSub(op1.Op), -c.AuxInt)
	// result: (Sub16 x (Mul16 <t> (Const16 <t> [-consT]) (ZeroExt8to16 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool)))))
	for {
		x := v_0
		op1 := v_1
		if op1.Op != ssaop.OpAdd16 {
			break
		}
		t := op1.Type
		_ = op1.Args[1]
		op1_0 := op1.Args[0]
		op1_1 := op1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 {
			if x != op1_0 {
				continue
			}
			c := op1_1
			if c.Op != ssaop.OpConst16 {
				continue
			}
			consT := ssa.AuxIntToInt16(c.AuxInt)
			bool := v_2
			if !(!rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) && rewriteCondSelectIntoMath(config, addToSub(op1.Op), -c.AuxInt)) {
				continue
			}
			v.Reset(ssaop.OpSub16)
			v0 := b.NewValue0(v.Pos, ssaop.OpMul16, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
			v1.AuxInt = ssa.Int16ToAuxInt(-consT)
			v2 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to16, t)
			v3 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
			v4 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type)
			v4.AddArg(bool)
			v3.AddArg(v4)
			v2.AddArg(v3)
			v0.AddArg2(v1, v2)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (CondSelect (Lsh64x64 x (Const64 [1])) x bool)
	// result: (Lsh64x8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> bool))
	for {
		if v_0.Op != ssaop.OpLsh64x64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 1 || x != v_1 {
			break
		}
		bool := v_2
		v.Reset(ssaop.OpLsh64x8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
		v0.AddArg(bool)
		v.AddArg2(x, v0)
		return true
	}
	// match: (CondSelect (Lsh32x64 x (Const64 [1])) x bool)
	// result: (Lsh32x8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> bool))
	for {
		if v_0.Op != ssaop.OpLsh32x64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 1 || x != v_1 {
			break
		}
		bool := v_2
		v.Reset(ssaop.OpLsh32x8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
		v0.AddArg(bool)
		v.AddArg2(x, v0)
		return true
	}
	// match: (CondSelect (Lsh16x64 x (Const64 [1])) x bool)
	// result: (Lsh16x8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> bool))
	for {
		if v_0.Op != ssaop.OpLsh16x64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 1 || x != v_1 {
			break
		}
		bool := v_2
		v.Reset(ssaop.OpLsh16x8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
		v0.AddArg(bool)
		v.AddArg2(x, v0)
		return true
	}
	// match: (CondSelect (Lsh8x64 x (Const64 [1])) x bool)
	// result: (Lsh8x8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> bool))
	for {
		if v_0.Op != ssaop.OpLsh8x64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 1 || x != v_1 {
			break
		}
		bool := v_2
		v.Reset(ssaop.OpLsh8x8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
		v0.AddArg(bool)
		v.AddArg2(x, v0)
		return true
	}
	// match: (CondSelect x (Lsh64x64 x (Const64 [1])) bool)
	// result: (Lsh64x8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool)))
	for {
		x := v_0
		if v_1.Op != ssaop.OpLsh64x64 {
			break
		}
		_ = v_1.Args[1]
		if x != v_1.Args[0] {
			break
		}
		v_1_1 := v_1.Args[1]
		if v_1_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1_1.AuxInt) != 1 {
			break
		}
		bool := v_2
		v.Reset(ssaop.OpLsh64x8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
		v1 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type)
		v1.AddArg(bool)
		v0.AddArg(v1)
		v.AddArg2(x, v0)
		return true
	}
	// match: (CondSelect x (Lsh32x64 x (Const64 [1])) bool)
	// result: (Lsh32x8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool)))
	for {
		x := v_0
		if v_1.Op != ssaop.OpLsh32x64 {
			break
		}
		_ = v_1.Args[1]
		if x != v_1.Args[0] {
			break
		}
		v_1_1 := v_1.Args[1]
		if v_1_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1_1.AuxInt) != 1 {
			break
		}
		bool := v_2
		v.Reset(ssaop.OpLsh32x8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
		v1 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type)
		v1.AddArg(bool)
		v0.AddArg(v1)
		v.AddArg2(x, v0)
		return true
	}
	// match: (CondSelect x (Lsh16x64 x (Const64 [1])) bool)
	// result: (Lsh16x8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool)))
	for {
		x := v_0
		if v_1.Op != ssaop.OpLsh16x64 {
			break
		}
		_ = v_1.Args[1]
		if x != v_1.Args[0] {
			break
		}
		v_1_1 := v_1.Args[1]
		if v_1_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1_1.AuxInt) != 1 {
			break
		}
		bool := v_2
		v.Reset(ssaop.OpLsh16x8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
		v1 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type)
		v1.AddArg(bool)
		v0.AddArg(v1)
		v.AddArg2(x, v0)
		return true
	}
	// match: (CondSelect x (Lsh8x64 x (Const64 [1])) bool)
	// result: (Lsh8x8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool)))
	for {
		x := v_0
		if v_1.Op != ssaop.OpLsh8x64 {
			break
		}
		_ = v_1.Args[1]
		if x != v_1.Args[0] {
			break
		}
		v_1_1 := v_1.Args[1]
		if v_1_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1_1.AuxInt) != 1 {
			break
		}
		bool := v_2
		v.Reset(ssaop.OpLsh8x8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
		v1 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type)
		v1.AddArg(bool)
		v0.AddArg(v1)
		v.AddArg2(x, v0)
		return true
	}
	// match: (CondSelect (Rsh64x64 x (Const64 [1])) x bool)
	// result: (Rsh64x8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> bool))
	for {
		if v_0.Op != ssaop.OpRsh64x64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 1 || x != v_1 {
			break
		}
		bool := v_2
		v.Reset(ssaop.OpRsh64x8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
		v0.AddArg(bool)
		v.AddArg2(x, v0)
		return true
	}
	// match: (CondSelect (Rsh32x64 x (Const64 [1])) x bool)
	// result: (Rsh32x8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> bool))
	for {
		if v_0.Op != ssaop.OpRsh32x64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 1 || x != v_1 {
			break
		}
		bool := v_2
		v.Reset(ssaop.OpRsh32x8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
		v0.AddArg(bool)
		v.AddArg2(x, v0)
		return true
	}
	// match: (CondSelect (Rsh16x64 x (Const64 [1])) x bool)
	// result: (Rsh16x8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> bool))
	for {
		if v_0.Op != ssaop.OpRsh16x64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 1 || x != v_1 {
			break
		}
		bool := v_2
		v.Reset(ssaop.OpRsh16x8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
		v0.AddArg(bool)
		v.AddArg2(x, v0)
		return true
	}
	// match: (CondSelect (Rsh8x64 x (Const64 [1])) x bool)
	// result: (Rsh8x8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> bool))
	for {
		if v_0.Op != ssaop.OpRsh8x64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 1 || x != v_1 {
			break
		}
		bool := v_2
		v.Reset(ssaop.OpRsh8x8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
		v0.AddArg(bool)
		v.AddArg2(x, v0)
		return true
	}
	// match: (CondSelect (Rsh64Ux64 x (Const64 [1])) x bool)
	// result: (Rsh64Ux8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> bool))
	for {
		if v_0.Op != ssaop.OpRsh64Ux64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 1 || x != v_1 {
			break
		}
		bool := v_2
		v.Reset(ssaop.OpRsh64Ux8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
		v0.AddArg(bool)
		v.AddArg2(x, v0)
		return true
	}
	// match: (CondSelect (Rsh32Ux64 x (Const64 [1])) x bool)
	// result: (Rsh32Ux8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> bool))
	for {
		if v_0.Op != ssaop.OpRsh32Ux64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 1 || x != v_1 {
			break
		}
		bool := v_2
		v.Reset(ssaop.OpRsh32Ux8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
		v0.AddArg(bool)
		v.AddArg2(x, v0)
		return true
	}
	// match: (CondSelect (Rsh16Ux64 x (Const64 [1])) x bool)
	// result: (Rsh16Ux8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> bool))
	for {
		if v_0.Op != ssaop.OpRsh16Ux64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 1 || x != v_1 {
			break
		}
		bool := v_2
		v.Reset(ssaop.OpRsh16Ux8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
		v0.AddArg(bool)
		v.AddArg2(x, v0)
		return true
	}
	// match: (CondSelect (Rsh8Ux64 x (Const64 [1])) x bool)
	// result: (Rsh8Ux8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> bool))
	for {
		if v_0.Op != ssaop.OpRsh8Ux64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 1 || x != v_1 {
			break
		}
		bool := v_2
		v.Reset(ssaop.OpRsh8Ux8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
		v0.AddArg(bool)
		v.AddArg2(x, v0)
		return true
	}
	// match: (CondSelect x (Rsh64x64 x (Const64 [1])) bool)
	// result: (Rsh64x8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool)))
	for {
		x := v_0
		if v_1.Op != ssaop.OpRsh64x64 {
			break
		}
		_ = v_1.Args[1]
		if x != v_1.Args[0] {
			break
		}
		v_1_1 := v_1.Args[1]
		if v_1_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1_1.AuxInt) != 1 {
			break
		}
		bool := v_2
		v.Reset(ssaop.OpRsh64x8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
		v1 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type)
		v1.AddArg(bool)
		v0.AddArg(v1)
		v.AddArg2(x, v0)
		return true
	}
	// match: (CondSelect x (Rsh32x64 x (Const64 [1])) bool)
	// result: (Rsh32x8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool)))
	for {
		x := v_0
		if v_1.Op != ssaop.OpRsh32x64 {
			break
		}
		_ = v_1.Args[1]
		if x != v_1.Args[0] {
			break
		}
		v_1_1 := v_1.Args[1]
		if v_1_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1_1.AuxInt) != 1 {
			break
		}
		bool := v_2
		v.Reset(ssaop.OpRsh32x8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
		v1 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type)
		v1.AddArg(bool)
		v0.AddArg(v1)
		v.AddArg2(x, v0)
		return true
	}
	// match: (CondSelect x (Rsh16x64 x (Const64 [1])) bool)
	// result: (Rsh16x8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool)))
	for {
		x := v_0
		if v_1.Op != ssaop.OpRsh16x64 {
			break
		}
		_ = v_1.Args[1]
		if x != v_1.Args[0] {
			break
		}
		v_1_1 := v_1.Args[1]
		if v_1_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1_1.AuxInt) != 1 {
			break
		}
		bool := v_2
		v.Reset(ssaop.OpRsh16x8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
		v1 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type)
		v1.AddArg(bool)
		v0.AddArg(v1)
		v.AddArg2(x, v0)
		return true
	}
	// match: (CondSelect x (Rsh8x64 x (Const64 [1])) bool)
	// result: (Rsh8x8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool)))
	for {
		x := v_0
		if v_1.Op != ssaop.OpRsh8x64 {
			break
		}
		_ = v_1.Args[1]
		if x != v_1.Args[0] {
			break
		}
		v_1_1 := v_1.Args[1]
		if v_1_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1_1.AuxInt) != 1 {
			break
		}
		bool := v_2
		v.Reset(ssaop.OpRsh8x8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
		v1 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type)
		v1.AddArg(bool)
		v0.AddArg(v1)
		v.AddArg2(x, v0)
		return true
	}
	// match: (CondSelect x (Rsh64Ux64 x (Const64 [1])) bool)
	// result: (Rsh64Ux8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool)))
	for {
		x := v_0
		if v_1.Op != ssaop.OpRsh64Ux64 {
			break
		}
		_ = v_1.Args[1]
		if x != v_1.Args[0] {
			break
		}
		v_1_1 := v_1.Args[1]
		if v_1_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1_1.AuxInt) != 1 {
			break
		}
		bool := v_2
		v.Reset(ssaop.OpRsh64Ux8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
		v1 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type)
		v1.AddArg(bool)
		v0.AddArg(v1)
		v.AddArg2(x, v0)
		return true
	}
	// match: (CondSelect x (Rsh32Ux64 x (Const64 [1])) bool)
	// result: (Rsh32Ux8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool)))
	for {
		x := v_0
		if v_1.Op != ssaop.OpRsh32Ux64 {
			break
		}
		_ = v_1.Args[1]
		if x != v_1.Args[0] {
			break
		}
		v_1_1 := v_1.Args[1]
		if v_1_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1_1.AuxInt) != 1 {
			break
		}
		bool := v_2
		v.Reset(ssaop.OpRsh32Ux8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
		v1 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type)
		v1.AddArg(bool)
		v0.AddArg(v1)
		v.AddArg2(x, v0)
		return true
	}
	// match: (CondSelect x (Rsh16Ux64 x (Const64 [1])) bool)
	// result: (Rsh16Ux8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool)))
	for {
		x := v_0
		if v_1.Op != ssaop.OpRsh16Ux64 {
			break
		}
		_ = v_1.Args[1]
		if x != v_1.Args[0] {
			break
		}
		v_1_1 := v_1.Args[1]
		if v_1_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1_1.AuxInt) != 1 {
			break
		}
		bool := v_2
		v.Reset(ssaop.OpRsh16Ux8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
		v1 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type)
		v1.AddArg(bool)
		v0.AddArg(v1)
		v.AddArg2(x, v0)
		return true
	}
	// match: (CondSelect x (Rsh8Ux64 x (Const64 [1])) bool)
	// result: (Rsh8Ux8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool)))
	for {
		x := v_0
		if v_1.Op != ssaop.OpRsh8Ux64 {
			break
		}
		_ = v_1.Args[1]
		if x != v_1.Args[0] {
			break
		}
		v_1_1 := v_1.Args[1]
		if v_1_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1_1.AuxInt) != 1 {
			break
		}
		bool := v_2
		v.Reset(ssaop.OpRsh8Ux8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
		v1 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type)
		v1.AddArg(bool)
		v0.AddArg(v1)
		v.AddArg2(x, v0)
		return true
	}
	// match: (CondSelect op1:(Or8 <t> x c:(Const8)) x bool)
	// cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)
	// result: (Or8 x (Mul8 <t> c (CvtBoolToUint8 <t> bool)))
	for {
		op1 := v_0
		if op1.Op != ssaop.OpOr8 {
			break
		}
		t := op1.Type
		_ = op1.Args[1]
		op1_0 := op1.Args[0]
		op1_1 := op1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 {
			x := op1_0
			c := op1_1
			if c.Op != ssaop.OpConst8 || x != v_1 {
				continue
			}
			bool := v_2
			if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) {
				continue
			}
			v.Reset(ssaop.OpOr8)
			v0 := b.NewValue0(v.Pos, ssaop.OpMul8, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, t)
			v1.AddArg(bool)
			v0.AddArg2(c, v1)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (CondSelect op1:(Or64 <t> x c:(Const64)) x bool)
	// cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)
	// result: (Or64 x (Mul64 <t> c (ZeroExt8to64 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> bool))))
	for {
		op1 := v_0
		if op1.Op != ssaop.OpOr64 {
			break
		}
		t := op1.Type
		_ = op1.Args[1]
		op1_0 := op1.Args[0]
		op1_1 := op1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 {
			x := op1_0
			c := op1_1
			if c.Op != ssaop.OpConst64 || x != v_1 {
				continue
			}
			bool := v_2
			if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) {
				continue
			}
			v.Reset(ssaop.OpOr64)
			v0 := b.NewValue0(v.Pos, ssaop.OpMul64, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to64, t)
			v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
			v2.AddArg(bool)
			v1.AddArg(v2)
			v0.AddArg2(c, v1)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (CondSelect op1:(Or32 <t> x c:(Const32)) x bool)
	// cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)
	// result: (Or32 x (Mul32 <t> c (ZeroExt8to32 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> bool))))
	for {
		op1 := v_0
		if op1.Op != ssaop.OpOr32 {
			break
		}
		t := op1.Type
		_ = op1.Args[1]
		op1_0 := op1.Args[0]
		op1_1 := op1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 {
			x := op1_0
			c := op1_1
			if c.Op != ssaop.OpConst32 || x != v_1 {
				continue
			}
			bool := v_2
			if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) {
				continue
			}
			v.Reset(ssaop.OpOr32)
			v0 := b.NewValue0(v.Pos, ssaop.OpMul32, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to32, t)
			v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
			v2.AddArg(bool)
			v1.AddArg(v2)
			v0.AddArg2(c, v1)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (CondSelect op1:(Or16 <t> x c:(Const16)) x bool)
	// cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)
	// result: (Or16 x (Mul16 <t> c (ZeroExt8to16 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> bool))))
	for {
		op1 := v_0
		if op1.Op != ssaop.OpOr16 {
			break
		}
		t := op1.Type
		_ = op1.Args[1]
		op1_0 := op1.Args[0]
		op1_1 := op1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 {
			x := op1_0
			c := op1_1
			if c.Op != ssaop.OpConst16 || x != v_1 {
				continue
			}
			bool := v_2
			if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) {
				continue
			}
			v.Reset(ssaop.OpOr16)
			v0 := b.NewValue0(v.Pos, ssaop.OpMul16, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to16, t)
			v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
			v2.AddArg(bool)
			v1.AddArg(v2)
			v0.AddArg2(c, v1)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (CondSelect x op1:(Or8 <t> x c:(Const8)) bool)
	// cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)
	// result: (Or8 x (Mul8 <t> c (CvtBoolToUint8 <t> (Not <bool.Type> bool))))
	for {
		x := v_0
		op1 := v_1
		if op1.Op != ssaop.OpOr8 {
			break
		}
		t := op1.Type
		_ = op1.Args[1]
		op1_0 := op1.Args[0]
		op1_1 := op1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 {
			if x != op1_0 {
				continue
			}
			c := op1_1
			if c.Op != ssaop.OpConst8 {
				continue
			}
			bool := v_2
			if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) {
				continue
			}
			v.Reset(ssaop.OpOr8)
			v0 := b.NewValue0(v.Pos, ssaop.OpMul8, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, t)
			v2 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type)
			v2.AddArg(bool)
			v1.AddArg(v2)
			v0.AddArg2(c, v1)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (CondSelect x op1:(Or64 <t> x c:(Const64)) bool)
	// cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)
	// result: (Or64 x (Mul64 <t> c (ZeroExt8to64 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool)))))
	for {
		x := v_0
		op1 := v_1
		if op1.Op != ssaop.OpOr64 {
			break
		}
		t := op1.Type
		_ = op1.Args[1]
		op1_0 := op1.Args[0]
		op1_1 := op1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 {
			if x != op1_0 {
				continue
			}
			c := op1_1
			if c.Op != ssaop.OpConst64 {
				continue
			}
			bool := v_2
			if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) {
				continue
			}
			v.Reset(ssaop.OpOr64)
			v0 := b.NewValue0(v.Pos, ssaop.OpMul64, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to64, t)
			v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
			v3 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type)
			v3.AddArg(bool)
			v2.AddArg(v3)
			v1.AddArg(v2)
			v0.AddArg2(c, v1)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (CondSelect x op1:(Or32 <t> x c:(Const32)) bool)
	// cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)
	// result: (Or32 x (Mul32 <t> c (ZeroExt8to32 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool)))))
	for {
		x := v_0
		op1 := v_1
		if op1.Op != ssaop.OpOr32 {
			break
		}
		t := op1.Type
		_ = op1.Args[1]
		op1_0 := op1.Args[0]
		op1_1 := op1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 {
			if x != op1_0 {
				continue
			}
			c := op1_1
			if c.Op != ssaop.OpConst32 {
				continue
			}
			bool := v_2
			if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) {
				continue
			}
			v.Reset(ssaop.OpOr32)
			v0 := b.NewValue0(v.Pos, ssaop.OpMul32, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to32, t)
			v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
			v3 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type)
			v3.AddArg(bool)
			v2.AddArg(v3)
			v1.AddArg(v2)
			v0.AddArg2(c, v1)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (CondSelect x op1:(Or16 <t> x c:(Const16)) bool)
	// cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)
	// result: (Or16 x (Mul16 <t> c (ZeroExt8to16 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool)))))
	for {
		x := v_0
		op1 := v_1
		if op1.Op != ssaop.OpOr16 {
			break
		}
		t := op1.Type
		_ = op1.Args[1]
		op1_0 := op1.Args[0]
		op1_1 := op1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 {
			if x != op1_0 {
				continue
			}
			c := op1_1
			if c.Op != ssaop.OpConst16 {
				continue
			}
			bool := v_2
			if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) {
				continue
			}
			v.Reset(ssaop.OpOr16)
			v0 := b.NewValue0(v.Pos, ssaop.OpMul16, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to16, t)
			v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
			v3 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type)
			v3.AddArg(bool)
			v2.AddArg(v3)
			v1.AddArg(v2)
			v0.AddArg2(c, v1)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (CondSelect op1:(Xor8 <t> x c:(Const8)) x bool)
	// cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)
	// result: (Xor8 x (Mul8 <t> c (CvtBoolToUint8 <t> bool)))
	for {
		op1 := v_0
		if op1.Op != ssaop.OpXor8 {
			break
		}
		t := op1.Type
		_ = op1.Args[1]
		op1_0 := op1.Args[0]
		op1_1 := op1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 {
			x := op1_0
			c := op1_1
			if c.Op != ssaop.OpConst8 || x != v_1 {
				continue
			}
			bool := v_2
			if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) {
				continue
			}
			v.Reset(ssaop.OpXor8)
			v0 := b.NewValue0(v.Pos, ssaop.OpMul8, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, t)
			v1.AddArg(bool)
			v0.AddArg2(c, v1)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (CondSelect op1:(Xor64 <t> x c:(Const64)) x bool)
	// cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)
	// result: (Xor64 x (Mul64 <t> c (ZeroExt8to64 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> bool))))
	for {
		op1 := v_0
		if op1.Op != ssaop.OpXor64 {
			break
		}
		t := op1.Type
		_ = op1.Args[1]
		op1_0 := op1.Args[0]
		op1_1 := op1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 {
			x := op1_0
			c := op1_1
			if c.Op != ssaop.OpConst64 || x != v_1 {
				continue
			}
			bool := v_2
			if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) {
				continue
			}
			v.Reset(ssaop.OpXor64)
			v0 := b.NewValue0(v.Pos, ssaop.OpMul64, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to64, t)
			v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
			v2.AddArg(bool)
			v1.AddArg(v2)
			v0.AddArg2(c, v1)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (CondSelect op1:(Xor32 <t> x c:(Const32)) x bool)
	// cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)
	// result: (Xor32 x (Mul32 <t> c (ZeroExt8to32 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> bool))))
	for {
		op1 := v_0
		if op1.Op != ssaop.OpXor32 {
			break
		}
		t := op1.Type
		_ = op1.Args[1]
		op1_0 := op1.Args[0]
		op1_1 := op1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 {
			x := op1_0
			c := op1_1
			if c.Op != ssaop.OpConst32 || x != v_1 {
				continue
			}
			bool := v_2
			if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) {
				continue
			}
			v.Reset(ssaop.OpXor32)
			v0 := b.NewValue0(v.Pos, ssaop.OpMul32, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to32, t)
			v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
			v2.AddArg(bool)
			v1.AddArg(v2)
			v0.AddArg2(c, v1)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (CondSelect op1:(Xor16 <t> x c:(Const16)) x bool)
	// cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)
	// result: (Xor16 x (Mul16 <t> c (ZeroExt8to16 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> bool))))
	for {
		op1 := v_0
		if op1.Op != ssaop.OpXor16 {
			break
		}
		t := op1.Type
		_ = op1.Args[1]
		op1_0 := op1.Args[0]
		op1_1 := op1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 {
			x := op1_0
			c := op1_1
			if c.Op != ssaop.OpConst16 || x != v_1 {
				continue
			}
			bool := v_2
			if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) {
				continue
			}
			v.Reset(ssaop.OpXor16)
			v0 := b.NewValue0(v.Pos, ssaop.OpMul16, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to16, t)
			v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
			v2.AddArg(bool)
			v1.AddArg(v2)
			v0.AddArg2(c, v1)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (CondSelect x op1:(Xor8 <t> x c:(Const8)) bool)
	// cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)
	// result: (Xor8 x (Mul8 <t> c (CvtBoolToUint8 <t> (Not <bool.Type> bool))))
	for {
		x := v_0
		op1 := v_1
		if op1.Op != ssaop.OpXor8 {
			break
		}
		t := op1.Type
		_ = op1.Args[1]
		op1_0 := op1.Args[0]
		op1_1 := op1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 {
			if x != op1_0 {
				continue
			}
			c := op1_1
			if c.Op != ssaop.OpConst8 {
				continue
			}
			bool := v_2
			if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) {
				continue
			}
			v.Reset(ssaop.OpXor8)
			v0 := b.NewValue0(v.Pos, ssaop.OpMul8, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, t)
			v2 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type)
			v2.AddArg(bool)
			v1.AddArg(v2)
			v0.AddArg2(c, v1)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (CondSelect x op1:(Xor64 <t> x c:(Const64)) bool)
	// cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)
	// result: (Xor64 x (Mul64 <t> c (ZeroExt8to64 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool)))))
	for {
		x := v_0
		op1 := v_1
		if op1.Op != ssaop.OpXor64 {
			break
		}
		t := op1.Type
		_ = op1.Args[1]
		op1_0 := op1.Args[0]
		op1_1 := op1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 {
			if x != op1_0 {
				continue
			}
			c := op1_1
			if c.Op != ssaop.OpConst64 {
				continue
			}
			bool := v_2
			if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) {
				continue
			}
			v.Reset(ssaop.OpXor64)
			v0 := b.NewValue0(v.Pos, ssaop.OpMul64, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to64, t)
			v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
			v3 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type)
			v3.AddArg(bool)
			v2.AddArg(v3)
			v1.AddArg(v2)
			v0.AddArg2(c, v1)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (CondSelect x op1:(Xor32 <t> x c:(Const32)) bool)
	// cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)
	// result: (Xor32 x (Mul32 <t> c (ZeroExt8to32 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool)))))
	for {
		x := v_0
		op1 := v_1
		if op1.Op != ssaop.OpXor32 {
			break
		}
		t := op1.Type
		_ = op1.Args[1]
		op1_0 := op1.Args[0]
		op1_1 := op1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 {
			if x != op1_0 {
				continue
			}
			c := op1_1
			if c.Op != ssaop.OpConst32 {
				continue
			}
			bool := v_2
			if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) {
				continue
			}
			v.Reset(ssaop.OpXor32)
			v0 := b.NewValue0(v.Pos, ssaop.OpMul32, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to32, t)
			v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
			v3 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type)
			v3.AddArg(bool)
			v2.AddArg(v3)
			v1.AddArg(v2)
			v0.AddArg2(c, v1)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (CondSelect x op1:(Xor16 <t> x c:(Const16)) bool)
	// cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)
	// result: (Xor16 x (Mul16 <t> c (ZeroExt8to16 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool)))))
	for {
		x := v_0
		op1 := v_1
		if op1.Op != ssaop.OpXor16 {
			break
		}
		t := op1.Type
		_ = op1.Args[1]
		op1_0 := op1.Args[0]
		op1_1 := op1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 {
			if x != op1_0 {
				continue
			}
			c := op1_1
			if c.Op != ssaop.OpConst16 {
				continue
			}
			bool := v_2
			if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) {
				continue
			}
			v.Reset(ssaop.OpXor16)
			v0 := b.NewValue0(v.Pos, ssaop.OpMul16, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to16, t)
			v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8])
			v3 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type)
			v3.AddArg(bool)
			v2.AddArg(v3)
			v1.AddArg(v2)
			v0.AddArg2(c, v1)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpConstInterface(v *ssa.Value) bool {
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (ConstInterface)
	// result: (IMake (ConstNil <typ.Uintptr>) (ConstNil <typ.BytePtr>))
	for {
		v.Reset(ssaop.OpIMake)
		v0 := b.NewValue0(v.Pos, ssaop.OpConstNil, typ.Uintptr)
		v1 := b.NewValue0(v.Pos, ssaop.OpConstNil, typ.BytePtr)
		v.AddArg2(v0, v1)
		return true
	}
}
func rewriteValue_OpConstSlice(v *ssa.Value) bool {
	b := v.Block
	config := b.Func.Config
	typ := &b.Func.Config.Types
	// match: (ConstSlice)
	// cond: config.PtrSize == 4
	// result: (SliceMake (ConstNil <v.Type.Elem().PtrTo()>) (Const32 <typ.Int> [0]) (Const32 <typ.Int> [0]))
	for {
		if !(config.PtrSize == 4) {
			break
		}
		v.Reset(ssaop.OpSliceMake)
		v0 := b.NewValue0(v.Pos, ssaop.OpConstNil, v.Type.Elem().PtrTo())
		v1 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.Int)
		v1.AuxInt = ssa.Int32ToAuxInt(0)
		v.AddArg3(v0, v1, v1)
		return true
	}
	// match: (ConstSlice)
	// cond: config.PtrSize == 8
	// result: (SliceMake (ConstNil <v.Type.Elem().PtrTo()>) (Const64 <typ.Int> [0]) (Const64 <typ.Int> [0]))
	for {
		if !(config.PtrSize == 8) {
			break
		}
		v.Reset(ssaop.OpSliceMake)
		v0 := b.NewValue0(v.Pos, ssaop.OpConstNil, v.Type.Elem().PtrTo())
		v1 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int)
		v1.AuxInt = ssa.Int64ToAuxInt(0)
		v.AddArg3(v0, v1, v1)
		return true
	}
	return false
}
func rewriteValue_OpConstString(v *ssa.Value) bool {
	b := v.Block
	config := b.Func.Config
	fe := b.Func.Fe
	typ := &b.Func.Config.Types
	// match: (ConstString {str})
	// cond: config.PtrSize == 4 && str == ""
	// result: (StringMake (ConstNil) (Const32 <typ.Int> [0]))
	for {
		str := ssa.AuxToString(v.Aux)
		if !(config.PtrSize == 4 && str == "") {
			break
		}
		v.Reset(ssaop.OpStringMake)
		v0 := b.NewValue0(v.Pos, ssaop.OpConstNil, typ.BytePtr)
		v1 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.Int)
		v1.AuxInt = ssa.Int32ToAuxInt(0)
		v.AddArg2(v0, v1)
		return true
	}
	// match: (ConstString {str})
	// cond: config.PtrSize == 8 && str == ""
	// result: (StringMake (ConstNil) (Const64 <typ.Int> [0]))
	for {
		str := ssa.AuxToString(v.Aux)
		if !(config.PtrSize == 8 && str == "") {
			break
		}
		v.Reset(ssaop.OpStringMake)
		v0 := b.NewValue0(v.Pos, ssaop.OpConstNil, typ.BytePtr)
		v1 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int)
		v1.AuxInt = ssa.Int64ToAuxInt(0)
		v.AddArg2(v0, v1)
		return true
	}
	// match: (ConstString {str})
	// cond: config.PtrSize == 4 && str != ""
	// result: (StringMake (Addr <typ.BytePtr> {fe.StringData(str)} (SB)) (Const32 <typ.Int> [int32(len(str))]))
	for {
		str := ssa.AuxToString(v.Aux)
		if !(config.PtrSize == 4 && str != "") {
			break
		}
		v.Reset(ssaop.OpStringMake)
		v0 := b.NewValue0(v.Pos, ssaop.OpAddr, typ.BytePtr)
		v0.Aux = ssa.SymToAux(fe.StringData(str))
		v1 := b.NewValue0(v.Pos, ssaop.OpSB, typ.Uintptr)
		v0.AddArg(v1)
		v2 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.Int)
		v2.AuxInt = ssa.Int32ToAuxInt(int32(len(str)))
		v.AddArg2(v0, v2)
		return true
	}
	// match: (ConstString {str})
	// cond: config.PtrSize == 8 && str != ""
	// result: (StringMake (Addr <typ.BytePtr> {fe.StringData(str)} (SB)) (Const64 <typ.Int> [int64(len(str))]))
	for {
		str := ssa.AuxToString(v.Aux)
		if !(config.PtrSize == 8 && str != "") {
			break
		}
		v.Reset(ssaop.OpStringMake)
		v0 := b.NewValue0(v.Pos, ssaop.OpAddr, typ.BytePtr)
		v0.Aux = ssa.SymToAux(fe.StringData(str))
		v1 := b.NewValue0(v.Pos, ssaop.OpSB, typ.Uintptr)
		v0.AddArg(v1)
		v2 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int)
		v2.AuxInt = ssa.Int64ToAuxInt(int64(len(str)))
		v.AddArg2(v0, v2)
		return true
	}
	return false
}
func rewriteValue_OpConvert(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Convert (Add64 (Convert ptr mem) off) mem)
	// result: (AddPtr ptr off)
	for {
		if v_0.Op != ssaop.OpAdd64 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			if v_0_0.Op != ssaop.OpConvert {
				continue
			}
			mem := v_0_0.Args[1]
			ptr := v_0_0.Args[0]
			off := v_0_1
			if mem != v_1 {
				continue
			}
			v.Reset(ssaop.OpAddPtr)
			v.AddArg2(ptr, off)
			return true
		}
		break
	}
	// match: (Convert (Add32 (Convert ptr mem) off) mem)
	// result: (AddPtr ptr off)
	for {
		if v_0.Op != ssaop.OpAdd32 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			if v_0_0.Op != ssaop.OpConvert {
				continue
			}
			mem := v_0_0.Args[1]
			ptr := v_0_0.Args[0]
			off := v_0_1
			if mem != v_1 {
				continue
			}
			v.Reset(ssaop.OpAddPtr)
			v.AddArg2(ptr, off)
			return true
		}
		break
	}
	// match: (Convert (Convert ptr mem) mem)
	// result: ptr
	for {
		if v_0.Op != ssaop.OpConvert {
			break
		}
		mem := v_0.Args[1]
		ptr := v_0.Args[0]
		if mem != v_1 {
			break
		}
		v.CopyOf(ptr)
		return true
	}
	// match: (Convert a:(Add64 (Add64 (Convert ptr mem) off1) off2) mem)
	// result: (AddPtr ptr (Add64 <a.Type> off1 off2))
	for {
		a := v_0
		if a.Op != ssaop.OpAdd64 {
			break
		}
		_ = a.Args[1]
		a_0 := a.Args[0]
		a_1 := a.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, a_0, a_1 = _i0+1, a_1, a_0 {
			if a_0.Op != ssaop.OpAdd64 {
				continue
			}
			_ = a_0.Args[1]
			a_0_0 := a_0.Args[0]
			a_0_1 := a_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, a_0_0, a_0_1 = _i1+1, a_0_1, a_0_0 {
				if a_0_0.Op != ssaop.OpConvert {
					continue
				}
				mem := a_0_0.Args[1]
				ptr := a_0_0.Args[0]
				off1 := a_0_1
				off2 := a_1
				if mem != v_1 {
					continue
				}
				v.Reset(ssaop.OpAddPtr)
				v0 := b.NewValue0(v.Pos, ssaop.OpAdd64, a.Type)
				v0.AddArg2(off1, off2)
				v.AddArg2(ptr, v0)
				return true
			}
		}
		break
	}
	// match: (Convert a:(Add32 (Add32 (Convert ptr mem) off1) off2) mem)
	// result: (AddPtr ptr (Add32 <a.Type> off1 off2))
	for {
		a := v_0
		if a.Op != ssaop.OpAdd32 {
			break
		}
		_ = a.Args[1]
		a_0 := a.Args[0]
		a_1 := a.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, a_0, a_1 = _i0+1, a_1, a_0 {
			if a_0.Op != ssaop.OpAdd32 {
				continue
			}
			_ = a_0.Args[1]
			a_0_0 := a_0.Args[0]
			a_0_1 := a_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, a_0_0, a_0_1 = _i1+1, a_0_1, a_0_0 {
				if a_0_0.Op != ssaop.OpConvert {
					continue
				}
				mem := a_0_0.Args[1]
				ptr := a_0_0.Args[0]
				off1 := a_0_1
				off2 := a_1
				if mem != v_1 {
					continue
				}
				v.Reset(ssaop.OpAddPtr)
				v0 := b.NewValue0(v.Pos, ssaop.OpAdd32, a.Type)
				v0.AddArg2(off1, off2)
				v.AddArg2(ptr, v0)
				return true
			}
		}
		break
	}
	return false
}
func rewriteValue_OpCtz16(v *ssa.Value) bool {
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	// match: (Ctz16 (Const16 [c]))
	// cond: config.PtrSize == 4
	// result: (Const32 [int32(ntz16(c))])
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_0.AuxInt)
		if !(config.PtrSize == 4) {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(int32(ntz16(c)))
		return true
	}
	// match: (Ctz16 (Const16 [c]))
	// cond: config.PtrSize == 8
	// result: (Const64 [int64(ntz16(c))])
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_0.AuxInt)
		if !(config.PtrSize == 8) {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(int64(ntz16(c)))
		return true
	}
	return false
}
func rewriteValue_OpCtz32(v *ssa.Value) bool {
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	// match: (Ctz32 (Const32 [c]))
	// cond: config.PtrSize == 4
	// result: (Const32 [int32(ntz32(c))])
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_0.AuxInt)
		if !(config.PtrSize == 4) {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(int32(ntz32(c)))
		return true
	}
	// match: (Ctz32 (Const32 [c]))
	// cond: config.PtrSize == 8
	// result: (Const64 [int64(ntz32(c))])
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_0.AuxInt)
		if !(config.PtrSize == 8) {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(int64(ntz32(c)))
		return true
	}
	return false
}
func rewriteValue_OpCtz64(v *ssa.Value) bool {
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	// match: (Ctz64 (Const64 [c]))
	// cond: config.PtrSize == 4
	// result: (Const32 [int32(ssa.Ntz64(c))])
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0.AuxInt)
		if !(config.PtrSize == 4) {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(int32(ssa.Ntz64(c)))
		return true
	}
	// match: (Ctz64 (Const64 [c]))
	// cond: config.PtrSize == 8
	// result: (Const64 [int64(ssa.Ntz64(c))])
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0.AuxInt)
		if !(config.PtrSize == 8) {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(int64(ssa.Ntz64(c)))
		return true
	}
	return false
}
func rewriteValue_OpCtz8(v *ssa.Value) bool {
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	// match: (Ctz8 (Const8 [c]))
	// cond: config.PtrSize == 4
	// result: (Const32 [int32(ntz8(c))])
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_0.AuxInt)
		if !(config.PtrSize == 4) {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(int32(ntz8(c)))
		return true
	}
	// match: (Ctz8 (Const8 [c]))
	// cond: config.PtrSize == 8
	// result: (Const64 [int64(ntz8(c))])
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_0.AuxInt)
		if !(config.PtrSize == 8) {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(int64(ntz8(c)))
		return true
	}
	return false
}
func rewriteValue_OpCvt32Fto32(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (Cvt32Fto32 (Const32F [c]))
	// cond: c >= -1<<31 && c < 1<<31
	// result: (Const32 [int32(c)])
	for {
		if v_0.Op != ssaop.OpConst32F {
			break
		}
		c := ssa.AuxIntToFloat32(v_0.AuxInt)
		if !(c >= -1<<31 && c < 1<<31) {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(int32(c))
		return true
	}
	return false
}
func rewriteValue_OpCvt32Fto64(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (Cvt32Fto64 (Const32F [c]))
	// cond: c >= -1<<63 && c < 1<<63
	// result: (Const64 [int64(c)])
	for {
		if v_0.Op != ssaop.OpConst32F {
			break
		}
		c := ssa.AuxIntToFloat32(v_0.AuxInt)
		if !(c >= -1<<63 && c < 1<<63) {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(int64(c))
		return true
	}
	return false
}
func rewriteValue_OpCvt32Fto64F(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (Cvt32Fto64F (Const32F [c]))
	// result: (Const64F [float64(c)])
	for {
		if v_0.Op != ssaop.OpConst32F {
			break
		}
		c := ssa.AuxIntToFloat32(v_0.AuxInt)
		v.Reset(ssaop.OpConst64F)
		v.AuxInt = ssa.Float64ToAuxInt(float64(c))
		return true
	}
	return false
}
func rewriteValue_OpCvt32to32F(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (Cvt32to32F (Const32 [c]))
	// result: (Const32F [float32(c)])
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_0.AuxInt)
		v.Reset(ssaop.OpConst32F)
		v.AuxInt = ssa.Float32ToAuxInt(float32(c))
		return true
	}
	return false
}
func rewriteValue_OpCvt32to64F(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (Cvt32to64F (Const32 [c]))
	// result: (Const64F [float64(c)])
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_0.AuxInt)
		v.Reset(ssaop.OpConst64F)
		v.AuxInt = ssa.Float64ToAuxInt(float64(c))
		return true
	}
	return false
}
func rewriteValue_OpCvt64Fto32(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (Cvt64Fto32 (Const64F [c]))
	// cond: c >= -1<<31 && c < 1<<31
	// result: (Const32 [int32(c)])
	for {
		if v_0.Op != ssaop.OpConst64F {
			break
		}
		c := ssa.AuxIntToFloat64(v_0.AuxInt)
		if !(c >= -1<<31 && c < 1<<31) {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(int32(c))
		return true
	}
	return false
}
func rewriteValue_OpCvt64Fto32F(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (Cvt64Fto32F (Const64F [c]))
	// result: (Const32F [float32(c)])
	for {
		if v_0.Op != ssaop.OpConst64F {
			break
		}
		c := ssa.AuxIntToFloat64(v_0.AuxInt)
		v.Reset(ssaop.OpConst32F)
		v.AuxInt = ssa.Float32ToAuxInt(float32(c))
		return true
	}
	// match: (Cvt64Fto32F sqrt0:(Sqrt (Cvt32Fto64F x)))
	// cond: sqrt0.Uses==1
	// result: (Sqrt32 x)
	for {
		sqrt0 := v_0
		if sqrt0.Op != ssaop.OpSqrt {
			break
		}
		sqrt0_0 := sqrt0.Args[0]
		if sqrt0_0.Op != ssaop.OpCvt32Fto64F {
			break
		}
		x := sqrt0_0.Args[0]
		if !(sqrt0.Uses == 1) {
			break
		}
		v.Reset(ssaop.OpSqrt32)
		v.AddArg(x)
		return true
	}
	return false
}
func rewriteValue_OpCvt64Fto64(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (Cvt64Fto64 (Const64F [c]))
	// cond: c >= -1<<63 && c < 1<<63
	// result: (Const64 [int64(c)])
	for {
		if v_0.Op != ssaop.OpConst64F {
			break
		}
		c := ssa.AuxIntToFloat64(v_0.AuxInt)
		if !(c >= -1<<63 && c < 1<<63) {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(int64(c))
		return true
	}
	return false
}
func rewriteValue_OpCvt64to32F(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (Cvt64to32F (Const64 [c]))
	// result: (Const32F [float32(c)])
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0.AuxInt)
		v.Reset(ssaop.OpConst32F)
		v.AuxInt = ssa.Float32ToAuxInt(float32(c))
		return true
	}
	return false
}
func rewriteValue_OpCvt64to64F(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (Cvt64to64F (Const64 [c]))
	// result: (Const64F [float64(c)])
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0.AuxInt)
		v.Reset(ssaop.OpConst64F)
		v.AuxInt = ssa.Float64ToAuxInt(float64(c))
		return true
	}
	return false
}
func rewriteValue_OpCvtBoolToUint8(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (CvtBoolToUint8 (ConstBool [false]))
	// result: (Const8 [0])
	for {
		if v_0.Op != ssaop.OpConstBool || ssa.AuxIntToBool(v_0.AuxInt) != false {
			break
		}
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(0)
		return true
	}
	// match: (CvtBoolToUint8 (ConstBool [true]))
	// result: (Const8 [1])
	for {
		if v_0.Op != ssaop.OpConstBool || ssa.AuxIntToBool(v_0.AuxInt) != true {
			break
		}
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(1)
		return true
	}
	return false
}
func rewriteValue_OpDiv128u(v *ssa.Value) bool {
	v_2 := v.Args[2]
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Div128u <t> (Const64 [hi]) (Const64 [lo]) (Const64 [y]))
	// cond: y != 0 && uint64(hi) < uint64(y)
	// result: (MakeTuple (Const64 <t.FieldType(0)> [bitsDiv128u(hi, lo, y).quo]) (Const64 <t.FieldType(1)> [bitsDiv128u(hi, lo, y).rem]))
	for {
		t := v.Type
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		hi := ssa.AuxIntToInt64(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		lo := ssa.AuxIntToInt64(v_1.AuxInt)
		if v_2.Op != ssaop.OpConst64 {
			break
		}
		y := ssa.AuxIntToInt64(v_2.AuxInt)
		if !(y != 0 && uint64(hi) < uint64(y)) {
			break
		}
		v.Reset(ssaop.OpMakeTuple)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t.FieldType(0))
		v0.AuxInt = ssa.Int64ToAuxInt(bitsDiv128u(hi, lo, y).quo)
		v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t.FieldType(1))
		v1.AuxInt = ssa.Int64ToAuxInt(bitsDiv128u(hi, lo, y).rem)
		v.AddArg2(v0, v1)
		return true
	}
	// match: (Div128u <t> (Const64 [0]) lo y)
	// result: (MakeTuple (Div64u <t.FieldType(0)> lo y) (Mod64u <t.FieldType(1)> lo y))
	for {
		t := v.Type
		if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 {
			break
		}
		lo := v_1
		y := v_2
		v.Reset(ssaop.OpMakeTuple)
		v0 := b.NewValue0(v.Pos, ssaop.OpDiv64u, t.FieldType(0))
		v0.AddArg2(lo, y)
		v1 := b.NewValue0(v.Pos, ssaop.OpMod64u, t.FieldType(1))
		v1.AddArg2(lo, y)
		v.AddArg2(v0, v1)
		return true
	}
	return false
}
func rewriteValue_OpDiv16(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (Div16 (Const16 [c]) (Const16 [d]))
	// cond: d != 0
	// result: (Const16 [c/d])
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		d := ssa.AuxIntToInt16(v_1.AuxInt)
		if !(d != 0) {
			break
		}
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(c / d)
		return true
	}
	// match: (Div16 <t> n (Const16 [c]))
	// cond: c < 0 && c != -1<<15
	// result: (Neg16 (Div16 <t> n (Const16 <t> [-c])))
	for {
		t := v.Type
		n := v_0
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_1.AuxInt)
		if !(c < 0 && c != -1<<15) {
			break
		}
		v.Reset(ssaop.OpNeg16)
		v0 := b.NewValue0(v.Pos, ssaop.OpDiv16, t)
		v1 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
		v1.AuxInt = ssa.Int16ToAuxInt(-c)
		v0.AddArg2(n, v1)
		v.AddArg(v0)
		return true
	}
	// match: (Div16 <t> x (Const16 [-1<<15]))
	// result: (Rsh16Ux64 (And16 <t> x (Neg16 <t> x)) (Const64 <typ.UInt64> [15]))
	for {
		t := v.Type
		x := v_0
		if v_1.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_1.AuxInt) != -1<<15 {
			break
		}
		v.Reset(ssaop.OpRsh16Ux64)
		v0 := b.NewValue0(v.Pos, ssaop.OpAnd16, t)
		v1 := b.NewValue0(v.Pos, ssaop.OpNeg16, t)
		v1.AddArg(x)
		v0.AddArg2(x, v1)
		v2 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64)
		v2.AuxInt = ssa.Int64ToAuxInt(15)
		v.AddArg2(v0, v2)
		return true
	}
	return false
}
func rewriteValue_OpDiv16u(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (Div16u (Const16 [c]) (Const16 [d]))
	// cond: d != 0
	// result: (Const16 [int16(uint16(c)/uint16(d))])
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		d := ssa.AuxIntToInt16(v_1.AuxInt)
		if !(d != 0) {
			break
		}
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(int16(uint16(c) / uint16(d)))
		return true
	}
	// match: (Div16u n (Const16 [c]))
	// cond: ssa.IsPowerOfTwo(uint16(c))
	// result: (Rsh16Ux64 n (Const64 <typ.UInt64> [ssa.Log16u(uint16(c))]))
	for {
		n := v_0
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_1.AuxInt)
		if !(ssa.IsPowerOfTwo(uint16(c))) {
			break
		}
		v.Reset(ssaop.OpRsh16Ux64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64)
		v0.AuxInt = ssa.Int64ToAuxInt(ssa.Log16u(uint16(c)))
		v.AddArg2(n, v0)
		return true
	}
	return false
}
func rewriteValue_OpDiv32(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (Div32 (Const32 [c]) (Const32 [d]))
	// cond: d != 0
	// result: (Const32 [c/d])
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		d := ssa.AuxIntToInt32(v_1.AuxInt)
		if !(d != 0) {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(c / d)
		return true
	}
	// match: (Div32 <t> n (Const32 [c]))
	// cond: c < 0 && c != -1<<31
	// result: (Neg32 (Div32 <t> n (Const32 <t> [-c])))
	for {
		t := v.Type
		n := v_0
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_1.AuxInt)
		if !(c < 0 && c != -1<<31) {
			break
		}
		v.Reset(ssaop.OpNeg32)
		v0 := b.NewValue0(v.Pos, ssaop.OpDiv32, t)
		v1 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
		v1.AuxInt = ssa.Int32ToAuxInt(-c)
		v0.AddArg2(n, v1)
		v.AddArg(v0)
		return true
	}
	// match: (Div32 <t> x (Const32 [-1<<31]))
	// result: (Rsh32Ux64 (And32 <t> x (Neg32 <t> x)) (Const64 <typ.UInt64> [31]))
	for {
		t := v.Type
		x := v_0
		if v_1.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1.AuxInt) != -1<<31 {
			break
		}
		v.Reset(ssaop.OpRsh32Ux64)
		v0 := b.NewValue0(v.Pos, ssaop.OpAnd32, t)
		v1 := b.NewValue0(v.Pos, ssaop.OpNeg32, t)
		v1.AddArg(x)
		v0.AddArg2(x, v1)
		v2 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64)
		v2.AuxInt = ssa.Int64ToAuxInt(31)
		v.AddArg2(v0, v2)
		return true
	}
	return false
}
func rewriteValue_OpDiv32F(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Div32F (Const32F [c]) (Const32F [d]))
	// cond: c/d == c/d
	// result: (Const32F [c/d])
	for {
		if v_0.Op != ssaop.OpConst32F {
			break
		}
		c := ssa.AuxIntToFloat32(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst32F {
			break
		}
		d := ssa.AuxIntToFloat32(v_1.AuxInt)
		if !(c/d == c/d) {
			break
		}
		v.Reset(ssaop.OpConst32F)
		v.AuxInt = ssa.Float32ToAuxInt(c / d)
		return true
	}
	// match: (Div32F x (Const32F <t> [c]))
	// cond: reciprocalExact32(c)
	// result: (Mul32F x (Const32F <t> [1/c]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst32F {
			break
		}
		t := v_1.Type
		c := ssa.AuxIntToFloat32(v_1.AuxInt)
		if !(reciprocalExact32(c)) {
			break
		}
		v.Reset(ssaop.OpMul32F)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst32F, t)
		v0.AuxInt = ssa.Float32ToAuxInt(1 / c)
		v.AddArg2(x, v0)
		return true
	}
	return false
}
func rewriteValue_OpDiv32u(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (Div32u (Const32 [c]) (Const32 [d]))
	// cond: d != 0
	// result: (Const32 [int32(uint32(c)/uint32(d))])
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		d := ssa.AuxIntToInt32(v_1.AuxInt)
		if !(d != 0) {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(int32(uint32(c) / uint32(d)))
		return true
	}
	// match: (Div32u n (Const32 [c]))
	// cond: ssa.IsPowerOfTwo(uint32(c))
	// result: (Rsh32Ux64 n (Const64 <typ.UInt64> [ssa.Log32u(uint32(c))]))
	for {
		n := v_0
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_1.AuxInt)
		if !(ssa.IsPowerOfTwo(uint32(c))) {
			break
		}
		v.Reset(ssaop.OpRsh32Ux64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64)
		v0.AuxInt = ssa.Int64ToAuxInt(ssa.Log32u(uint32(c)))
		v.AddArg2(n, v0)
		return true
	}
	return false
}
func rewriteValue_OpDiv64(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (Div64 (Const64 [c]) (Const64 [d]))
	// cond: d != 0
	// result: (Const64 [c/d])
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(d != 0) {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(c / d)
		return true
	}
	// match: (Div64 <t> n (Const64 [c]))
	// cond: c < 0 && c != -1<<63
	// result: (Neg64 (Div64 <t> n (Const64 <t> [-c])))
	for {
		t := v.Type
		n := v_0
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(c < 0 && c != -1<<63) {
			break
		}
		v.Reset(ssaop.OpNeg64)
		v0 := b.NewValue0(v.Pos, ssaop.OpDiv64, t)
		v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v1.AuxInt = ssa.Int64ToAuxInt(-c)
		v0.AddArg2(n, v1)
		v.AddArg(v0)
		return true
	}
	// match: (Div64 x (Const64 [-1<<63]))
	// cond: isNonNegative(x)
	// result: (Const64 [0])
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != -1<<63 || !(isNonNegative(x)) {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(0)
		return true
	}
	// match: (Div64 <t> x (Const64 [-1<<63]))
	// result: (Rsh64Ux64 (And64 <t> x (Neg64 <t> x)) (Const64 <typ.UInt64> [63]))
	for {
		t := v.Type
		x := v_0
		if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != -1<<63 {
			break
		}
		v.Reset(ssaop.OpRsh64Ux64)
		v0 := b.NewValue0(v.Pos, ssaop.OpAnd64, t)
		v1 := b.NewValue0(v.Pos, ssaop.OpNeg64, t)
		v1.AddArg(x)
		v0.AddArg2(x, v1)
		v2 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64)
		v2.AuxInt = ssa.Int64ToAuxInt(63)
		v.AddArg2(v0, v2)
		return true
	}
	return false
}
func rewriteValue_OpDiv64F(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Div64F (Const64F [c]) (Const64F [d]))
	// cond: c/d == c/d
	// result: (Const64F [c/d])
	for {
		if v_0.Op != ssaop.OpConst64F {
			break
		}
		c := ssa.AuxIntToFloat64(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst64F {
			break
		}
		d := ssa.AuxIntToFloat64(v_1.AuxInt)
		if !(c/d == c/d) {
			break
		}
		v.Reset(ssaop.OpConst64F)
		v.AuxInt = ssa.Float64ToAuxInt(c / d)
		return true
	}
	// match: (Div64F x (Const64F <t> [c]))
	// cond: reciprocalExact64(c)
	// result: (Mul64F x (Const64F <t> [1/c]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst64F {
			break
		}
		t := v_1.Type
		c := ssa.AuxIntToFloat64(v_1.AuxInt)
		if !(reciprocalExact64(c)) {
			break
		}
		v.Reset(ssaop.OpMul64F)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64F, t)
		v0.AuxInt = ssa.Float64ToAuxInt(1 / c)
		v.AddArg2(x, v0)
		return true
	}
	return false
}
func rewriteValue_OpDiv64u(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (Div64u (Const64 [c]) (Const64 [d]))
	// cond: d != 0
	// result: (Const64 [int64(uint64(c)/uint64(d))])
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(d != 0) {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(int64(uint64(c) / uint64(d)))
		return true
	}
	// match: (Div64u n (Const64 [c]))
	// cond: ssa.IsPowerOfTwo(uint64(c))
	// result: (Rsh64Ux64 n (Const64 <typ.UInt64> [ssa.Log64u(uint64(c))]))
	for {
		n := v_0
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(ssa.IsPowerOfTwo(uint64(c))) {
			break
		}
		v.Reset(ssaop.OpRsh64Ux64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64)
		v0.AuxInt = ssa.Int64ToAuxInt(ssa.Log64u(uint64(c)))
		v.AddArg2(n, v0)
		return true
	}
	return false
}
func rewriteValue_OpDiv8(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (Div8 (Const8 [c]) (Const8 [d]))
	// cond: d != 0
	// result: (Const8 [c/d])
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		d := ssa.AuxIntToInt8(v_1.AuxInt)
		if !(d != 0) {
			break
		}
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(c / d)
		return true
	}
	// match: (Div8 <t> n (Const8 [c]))
	// cond: c < 0 && c != -1<<7
	// result: (Neg8 (Div8 <t> n (Const8 <t> [-c])))
	for {
		t := v.Type
		n := v_0
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_1.AuxInt)
		if !(c < 0 && c != -1<<7) {
			break
		}
		v.Reset(ssaop.OpNeg8)
		v0 := b.NewValue0(v.Pos, ssaop.OpDiv8, t)
		v1 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
		v1.AuxInt = ssa.Int8ToAuxInt(-c)
		v0.AddArg2(n, v1)
		v.AddArg(v0)
		return true
	}
	// match: (Div8 <t> x (Const8 [-1<<7 ]))
	// result: (Rsh8Ux64 (And8 <t> x (Neg8 <t> x)) (Const64 <typ.UInt64> [7 ]))
	for {
		t := v.Type
		x := v_0
		if v_1.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_1.AuxInt) != -1<<7 {
			break
		}
		v.Reset(ssaop.OpRsh8Ux64)
		v0 := b.NewValue0(v.Pos, ssaop.OpAnd8, t)
		v1 := b.NewValue0(v.Pos, ssaop.OpNeg8, t)
		v1.AddArg(x)
		v0.AddArg2(x, v1)
		v2 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64)
		v2.AuxInt = ssa.Int64ToAuxInt(7)
		v.AddArg2(v0, v2)
		return true
	}
	return false
}
func rewriteValue_OpDiv8u(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (Div8u (Const8 [c]) (Const8 [d]))
	// cond: d != 0
	// result: (Const8 [int8(uint8(c)/uint8(d))])
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		d := ssa.AuxIntToInt8(v_1.AuxInt)
		if !(d != 0) {
			break
		}
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(int8(uint8(c) / uint8(d)))
		return true
	}
	// match: (Div8u n (Const8 [c]))
	// cond: ssa.IsPowerOfTwo(uint8(c))
	// result: (Rsh8Ux64 n (Const64 <typ.UInt64> [ssa.Log8u(uint8(c))]))
	for {
		n := v_0
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_1.AuxInt)
		if !(ssa.IsPowerOfTwo(uint8(c))) {
			break
		}
		v.Reset(ssaop.OpRsh8Ux64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64)
		v0.AuxInt = ssa.Int64ToAuxInt(ssa.Log8u(uint8(c)))
		v.AddArg2(n, v0)
		return true
	}
	return false
}
func rewriteValue_OpEq16(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	typ := &b.Func.Config.Types
	// match: (Eq16 x x)
	// result: (ConstBool [true])
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (Eq16 (Const16 <t> [c]) o:(Add16 (Const16 [d]) x))
	// cond: o.Uses == 1
	// result: (Eq16 (Const16 <t> [c-d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt16(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpAdd16 {
				continue
			}
			_ = o.Args[1]
			o_0 := o.Args[0]
			o_1 := o.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 {
				if o_0.Op != ssaop.OpConst16 {
					continue
				}
				d := ssa.AuxIntToInt16(o_0.AuxInt)
				x := o_1
				if !(o.Uses == 1) {
					continue
				}
				v.Reset(ssaop.OpEq16)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
				v0.AuxInt = ssa.Int16ToAuxInt(c - d)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Eq16 (Const16 <t> [c]) o:(Sub16 x (Const16 [d])))
	// cond: o.Uses == 1
	// result: (Eq16 (Const16 <t> [c+d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt16(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpSub16 {
				continue
			}
			_ = o.Args[1]
			x := o.Args[0]
			o_1 := o.Args[1]
			if o_1.Op != ssaop.OpConst16 {
				continue
			}
			d := ssa.AuxIntToInt16(o_1.AuxInt)
			if !(o.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpEq16)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
			v0.AuxInt = ssa.Int16ToAuxInt(c + d)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Eq16 (Const16 <t> [c]) o:(Sub16 (Const16 [d]) x))
	// cond: o.Uses == 1
	// result: (Eq16 (Const16 <t> [d-c]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt16(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpSub16 {
				continue
			}
			x := o.Args[1]
			o_0 := o.Args[0]
			if o_0.Op != ssaop.OpConst16 {
				continue
			}
			d := ssa.AuxIntToInt16(o_0.AuxInt)
			if !(o.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpEq16)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
			v0.AuxInt = ssa.Int16ToAuxInt(d - c)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Eq16 (Const16 <t> [c]) o:(Xor16 (Const16 [d]) x))
	// cond: o.Uses == 1
	// result: (Eq16 (Const16 <t> [d^c]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt16(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpXor16 {
				continue
			}
			_ = o.Args[1]
			o_0 := o.Args[0]
			o_1 := o.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 {
				if o_0.Op != ssaop.OpConst16 {
					continue
				}
				d := ssa.AuxIntToInt16(o_0.AuxInt)
				x := o_1
				if !(o.Uses == 1) {
					continue
				}
				v.Reset(ssaop.OpEq16)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
				v0.AuxInt = ssa.Int16ToAuxInt(d ^ c)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Eq16 (Const16 <t> [c]) o:(Com16 x))
	// cond: o.Uses == 1
	// result: (Eq16 (Const16 <t> [^c]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt16(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpCom16 {
				continue
			}
			x := o.Args[0]
			if !(o.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpEq16)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
			v0.AuxInt = ssa.Int16ToAuxInt(^c)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Eq16 (Const16 <t> [c]) o:(Neg16 x))
	// cond: o.Uses == 1
	// result: (Eq16 (Const16 <t> [-c]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt16(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpNeg16 {
				continue
			}
			x := o.Args[0]
			if !(o.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpEq16)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
			v0.AuxInt = ssa.Int16ToAuxInt(-c)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Eq16 (Const16 <t> [c]) o:(Mul16 (Const16 [d]) x))
	// cond: uint16(d)%2 == 1 && o.Uses == 1
	// result: (Eq16 (Const16 <t> [int16(uint16(c) * uint16(modularMultiplicativeInverse(uint64(d))))]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt16(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpMul16 {
				continue
			}
			_ = o.Args[1]
			o_0 := o.Args[0]
			o_1 := o.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 {
				if o_0.Op != ssaop.OpConst16 {
					continue
				}
				d := ssa.AuxIntToInt16(o_0.AuxInt)
				x := o_1
				if !(uint16(d)%2 == 1 && o.Uses == 1) {
					continue
				}
				v.Reset(ssaop.OpEq16)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
				v0.AuxInt = ssa.Int16ToAuxInt(int16(uint16(c) * uint16(modularMultiplicativeInverse(uint64(d)))))
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Eq16 (Const16 [c]) (Const16 [d]))
	// result: (ConstBool [c == d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst16 {
				continue
			}
			d := ssa.AuxIntToInt16(v_1.AuxInt)
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(c == d)
			return true
		}
		break
	}
	// match: (Eq16 (Mod16u x (Const16 [c])) (Const16 [0]))
	// cond: x.Op != ssaop.OpConst16 && ssa.UdivisibleOK16(c) && !hasSmallRotate(config)
	// result: (Eq32 (Mod32u <typ.UInt32> (ZeroExt16to32 <typ.UInt32> x) (Const32 <typ.UInt32> [int32(uint16(c))])) (Const32 <typ.UInt32> [0]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpMod16u {
				continue
			}
			_ = v_0.Args[1]
			x := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			if v_0_1.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_0_1.AuxInt)
			if v_1.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_1.AuxInt) != 0 || !(x.Op != ssaop.OpConst16 && ssa.UdivisibleOK16(c) && !hasSmallRotate(config)) {
				continue
			}
			v.Reset(ssaop.OpEq32)
			v0 := b.NewValue0(v.Pos, ssaop.OpMod32u, typ.UInt32)
			v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt16to32, typ.UInt32)
			v1.AddArg(x)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32)
			v2.AuxInt = ssa.Int32ToAuxInt(int32(uint16(c)))
			v0.AddArg2(v1, v2)
			v3 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32)
			v3.AuxInt = ssa.Int32ToAuxInt(0)
			v.AddArg2(v0, v3)
			return true
		}
		break
	}
	// match: (Eq16 (Mod16 x (Const16 [c])) (Const16 [0]))
	// cond: x.Op != ssaop.OpConst16 && ssa.SdivisibleOK16(c) && !hasSmallRotate(config)
	// result: (Eq32 (Mod32 <typ.Int32> (SignExt16to32 <typ.Int32> x) (Const32 <typ.Int32> [int32(c)])) (Const32 <typ.Int32> [0]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpMod16 {
				continue
			}
			_ = v_0.Args[1]
			x := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			if v_0_1.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_0_1.AuxInt)
			if v_1.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_1.AuxInt) != 0 || !(x.Op != ssaop.OpConst16 && ssa.SdivisibleOK16(c) && !hasSmallRotate(config)) {
				continue
			}
			v.Reset(ssaop.OpEq32)
			v0 := b.NewValue0(v.Pos, ssaop.OpMod32, typ.Int32)
			v1 := b.NewValue0(v.Pos, ssaop.OpSignExt16to32, typ.Int32)
			v1.AddArg(x)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.Int32)
			v2.AuxInt = ssa.Int32ToAuxInt(int32(c))
			v0.AddArg2(v1, v2)
			v3 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.Int32)
			v3.AuxInt = ssa.Int32ToAuxInt(0)
			v.AddArg2(v0, v3)
			return true
		}
		break
	}
	// match: (Eq16 s:(Sub16 x y) (Const16 [0]))
	// cond: s.Uses == 1
	// result: (Eq16 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			s := v_0
			if s.Op != ssaop.OpSub16 {
				continue
			}
			y := s.Args[1]
			x := s.Args[0]
			if v_1.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_1.AuxInt) != 0 || !(s.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpEq16)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Eq16 (And16 <t> x (Const16 <t> [y])) (Const16 <t> [y]))
	// cond: ssa.OneBit(y)
	// result: (Neq16 (And16 <t> x (Const16 <t> [y])) (Const16 <t> [0]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpAnd16 {
				continue
			}
			t := v_0.Type
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				x := v_0_0
				if v_0_1.Op != ssaop.OpConst16 || v_0_1.Type != t {
					continue
				}
				y := ssa.AuxIntToInt16(v_0_1.AuxInt)
				if v_1.Op != ssaop.OpConst16 || v_1.Type != t || ssa.AuxIntToInt16(v_1.AuxInt) != y || !(ssa.OneBit(y)) {
					continue
				}
				v.Reset(ssaop.OpNeq16)
				v0 := b.NewValue0(v.Pos, ssaop.OpAnd16, t)
				v1 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
				v1.AuxInt = ssa.Int16ToAuxInt(y)
				v0.AddArg2(x, v1)
				v2 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
				v2.AuxInt = ssa.Int16ToAuxInt(0)
				v.AddArg2(v0, v2)
				return true
			}
		}
		break
	}
	// match: (Eq16 (ZeroExt8to16 (CvtBoolToUint8 x)) (Const16 [1]))
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpZeroExt8to16 {
				continue
			}
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpCvtBoolToUint8 {
				continue
			}
			x := v_0_0.Args[0]
			if v_1.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_1.AuxInt) != 1 {
				continue
			}
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (Eq16 (ZeroExt8to16 (CvtBoolToUint8 x)) (Const16 [0]))
	// result: (Not x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpZeroExt8to16 {
				continue
			}
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpCvtBoolToUint8 {
				continue
			}
			x := v_0_0.Args[0]
			if v_1.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_1.AuxInt) != 0 {
				continue
			}
			v.Reset(ssaop.OpNot)
			v.AddArg(x)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpEq32(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Eq32 x x)
	// result: (ConstBool [true])
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (Eq32 (Const32 <t> [c]) o:(Add32 (Const32 [d]) x))
	// cond: o.Uses == 1
	// result: (Eq32 (Const32 <t> [c-d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt32(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpAdd32 {
				continue
			}
			_ = o.Args[1]
			o_0 := o.Args[0]
			o_1 := o.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 {
				if o_0.Op != ssaop.OpConst32 {
					continue
				}
				d := ssa.AuxIntToInt32(o_0.AuxInt)
				x := o_1
				if !(o.Uses == 1) {
					continue
				}
				v.Reset(ssaop.OpEq32)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
				v0.AuxInt = ssa.Int32ToAuxInt(c - d)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Eq32 (Const32 <t> [c]) o:(Sub32 x (Const32 [d])))
	// cond: o.Uses == 1
	// result: (Eq32 (Const32 <t> [c+d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt32(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpSub32 {
				continue
			}
			_ = o.Args[1]
			x := o.Args[0]
			o_1 := o.Args[1]
			if o_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(o_1.AuxInt)
			if !(o.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpEq32)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
			v0.AuxInt = ssa.Int32ToAuxInt(c + d)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Eq32 (Const32 <t> [c]) o:(Sub32 (Const32 [d]) x))
	// cond: o.Uses == 1
	// result: (Eq32 (Const32 <t> [d-c]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt32(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpSub32 {
				continue
			}
			x := o.Args[1]
			o_0 := o.Args[0]
			if o_0.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(o_0.AuxInt)
			if !(o.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpEq32)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
			v0.AuxInt = ssa.Int32ToAuxInt(d - c)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Eq32 (Const32 <t> [c]) o:(Xor32 (Const32 [d]) x))
	// cond: o.Uses == 1
	// result: (Eq32 (Const32 <t> [d^c]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt32(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpXor32 {
				continue
			}
			_ = o.Args[1]
			o_0 := o.Args[0]
			o_1 := o.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 {
				if o_0.Op != ssaop.OpConst32 {
					continue
				}
				d := ssa.AuxIntToInt32(o_0.AuxInt)
				x := o_1
				if !(o.Uses == 1) {
					continue
				}
				v.Reset(ssaop.OpEq32)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
				v0.AuxInt = ssa.Int32ToAuxInt(d ^ c)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Eq32 (Const32 <t> [c]) o:(Com32 x))
	// cond: o.Uses == 1
	// result: (Eq32 (Const32 <t> [^c]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt32(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpCom32 {
				continue
			}
			x := o.Args[0]
			if !(o.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpEq32)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
			v0.AuxInt = ssa.Int32ToAuxInt(^c)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Eq32 (Const32 <t> [c]) o:(Neg32 x))
	// cond: o.Uses == 1
	// result: (Eq32 (Const32 <t> [-c]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt32(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpNeg32 {
				continue
			}
			x := o.Args[0]
			if !(o.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpEq32)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
			v0.AuxInt = ssa.Int32ToAuxInt(-c)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Eq32 (Const32 <t> [c]) o:(Mul32 (Const32 [d]) x))
	// cond: uint32(d)%2 == 1 && o.Uses == 1
	// result: (Eq32 (Const32 <t> [int32(uint32(c) * uint32(modularMultiplicativeInverse(uint64(d))))]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt32(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpMul32 {
				continue
			}
			_ = o.Args[1]
			o_0 := o.Args[0]
			o_1 := o.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 {
				if o_0.Op != ssaop.OpConst32 {
					continue
				}
				d := ssa.AuxIntToInt32(o_0.AuxInt)
				x := o_1
				if !(uint32(d)%2 == 1 && o.Uses == 1) {
					continue
				}
				v.Reset(ssaop.OpEq32)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
				v0.AuxInt = ssa.Int32ToAuxInt(int32(uint32(c) * uint32(modularMultiplicativeInverse(uint64(d)))))
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Eq32 (Const32 [c]) (Const32 [d]))
	// result: (ConstBool [c == d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(v_1.AuxInt)
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(c == d)
			return true
		}
		break
	}
	// match: (Eq32 s:(Sub32 x y) (Const32 [0]))
	// cond: s.Uses == 1
	// result: (Eq32 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			s := v_0
			if s.Op != ssaop.OpSub32 {
				continue
			}
			y := s.Args[1]
			x := s.Args[0]
			if v_1.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1.AuxInt) != 0 || !(s.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpEq32)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Eq32 (And32 <t> x (Const32 <t> [y])) (Const32 <t> [y]))
	// cond: ssa.OneBit(y)
	// result: (Neq32 (And32 <t> x (Const32 <t> [y])) (Const32 <t> [0]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpAnd32 {
				continue
			}
			t := v_0.Type
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				x := v_0_0
				if v_0_1.Op != ssaop.OpConst32 || v_0_1.Type != t {
					continue
				}
				y := ssa.AuxIntToInt32(v_0_1.AuxInt)
				if v_1.Op != ssaop.OpConst32 || v_1.Type != t || ssa.AuxIntToInt32(v_1.AuxInt) != y || !(ssa.OneBit(y)) {
					continue
				}
				v.Reset(ssaop.OpNeq32)
				v0 := b.NewValue0(v.Pos, ssaop.OpAnd32, t)
				v1 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
				v1.AuxInt = ssa.Int32ToAuxInt(y)
				v0.AddArg2(x, v1)
				v2 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
				v2.AuxInt = ssa.Int32ToAuxInt(0)
				v.AddArg2(v0, v2)
				return true
			}
		}
		break
	}
	// match: (Eq32 (ZeroExt8to32 (CvtBoolToUint8 x)) (Const32 [1]))
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpZeroExt8to32 {
				continue
			}
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpCvtBoolToUint8 {
				continue
			}
			x := v_0_0.Args[0]
			if v_1.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1.AuxInt) != 1 {
				continue
			}
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (Eq32 (ZeroExt8to32 (CvtBoolToUint8 x)) (Const32 [0]))
	// result: (Not x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpZeroExt8to32 {
				continue
			}
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpCvtBoolToUint8 {
				continue
			}
			x := v_0_0.Args[0]
			if v_1.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1.AuxInt) != 0 {
				continue
			}
			v.Reset(ssaop.OpNot)
			v.AddArg(x)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpEq32F(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	// match: (Eq32F (Const32F [c]) (Const32F [d]))
	// result: (ConstBool [c == d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32F {
				continue
			}
			c := ssa.AuxIntToFloat32(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst32F {
				continue
			}
			d := ssa.AuxIntToFloat32(v_1.AuxInt)
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(c == d)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpEq64(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Eq64 x x)
	// result: (ConstBool [true])
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (Eq64 (Const64 <t> [c]) o:(Add64 (Const64 [d]) x))
	// cond: o.Uses == 1
	// result: (Eq64 (Const64 <t> [c-d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt64(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpAdd64 {
				continue
			}
			_ = o.Args[1]
			o_0 := o.Args[0]
			o_1 := o.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 {
				if o_0.Op != ssaop.OpConst64 {
					continue
				}
				d := ssa.AuxIntToInt64(o_0.AuxInt)
				x := o_1
				if !(o.Uses == 1) {
					continue
				}
				v.Reset(ssaop.OpEq64)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
				v0.AuxInt = ssa.Int64ToAuxInt(c - d)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Eq64 (Const64 <t> [c]) o:(Sub64 x (Const64 [d])))
	// cond: o.Uses == 1
	// result: (Eq64 (Const64 <t> [c+d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt64(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpSub64 {
				continue
			}
			_ = o.Args[1]
			x := o.Args[0]
			o_1 := o.Args[1]
			if o_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(o_1.AuxInt)
			if !(o.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpEq64)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
			v0.AuxInt = ssa.Int64ToAuxInt(c + d)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Eq64 (Const64 <t> [c]) o:(Sub64 (Const64 [d]) x))
	// cond: o.Uses == 1
	// result: (Eq64 (Const64 <t> [d-c]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt64(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpSub64 {
				continue
			}
			x := o.Args[1]
			o_0 := o.Args[0]
			if o_0.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(o_0.AuxInt)
			if !(o.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpEq64)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
			v0.AuxInt = ssa.Int64ToAuxInt(d - c)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Eq64 (Const64 <t> [c]) o:(Xor64 (Const64 [d]) x))
	// cond: o.Uses == 1
	// result: (Eq64 (Const64 <t> [d^c]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt64(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpXor64 {
				continue
			}
			_ = o.Args[1]
			o_0 := o.Args[0]
			o_1 := o.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 {
				if o_0.Op != ssaop.OpConst64 {
					continue
				}
				d := ssa.AuxIntToInt64(o_0.AuxInt)
				x := o_1
				if !(o.Uses == 1) {
					continue
				}
				v.Reset(ssaop.OpEq64)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
				v0.AuxInt = ssa.Int64ToAuxInt(d ^ c)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Eq64 (Const64 <t> [c]) o:(Com64 x))
	// cond: o.Uses == 1
	// result: (Eq64 (Const64 <t> [^c]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt64(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpCom64 {
				continue
			}
			x := o.Args[0]
			if !(o.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpEq64)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
			v0.AuxInt = ssa.Int64ToAuxInt(^c)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Eq64 (Const64 <t> [c]) o:(Neg64 x))
	// cond: o.Uses == 1
	// result: (Eq64 (Const64 <t> [-c]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt64(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpNeg64 {
				continue
			}
			x := o.Args[0]
			if !(o.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpEq64)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
			v0.AuxInt = ssa.Int64ToAuxInt(-c)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Eq64 (Const64 <t> [c]) o:(Mul64 (Const64 [d]) x))
	// cond: uint64(d)%2 == 1 && o.Uses == 1
	// result: (Eq64 (Const64 <t> [int64(uint64(c) * modularMultiplicativeInverse(uint64(d))) ]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt64(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpMul64 {
				continue
			}
			_ = o.Args[1]
			o_0 := o.Args[0]
			o_1 := o.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 {
				if o_0.Op != ssaop.OpConst64 {
					continue
				}
				d := ssa.AuxIntToInt64(o_0.AuxInt)
				x := o_1
				if !(uint64(d)%2 == 1 && o.Uses == 1) {
					continue
				}
				v.Reset(ssaop.OpEq64)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
				v0.AuxInt = ssa.Int64ToAuxInt(int64(uint64(c) * modularMultiplicativeInverse(uint64(d))))
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Eq64 (Const64 [c]) (Const64 [d]))
	// result: (ConstBool [c == d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1.AuxInt)
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(c == d)
			return true
		}
		break
	}
	// match: (Eq64 s:(Sub64 x y) (Const64 [0]))
	// cond: s.Uses == 1
	// result: (Eq64 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			s := v_0
			if s.Op != ssaop.OpSub64 {
				continue
			}
			y := s.Args[1]
			x := s.Args[0]
			if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 || !(s.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpEq64)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Eq64 (And64 <t> x (Const64 <t> [y])) (Const64 <t> [y]))
	// cond: ssa.OneBit(y)
	// result: (Neq64 (And64 <t> x (Const64 <t> [y])) (Const64 <t> [0]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpAnd64 {
				continue
			}
			t := v_0.Type
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				x := v_0_0
				if v_0_1.Op != ssaop.OpConst64 || v_0_1.Type != t {
					continue
				}
				y := ssa.AuxIntToInt64(v_0_1.AuxInt)
				if v_1.Op != ssaop.OpConst64 || v_1.Type != t || ssa.AuxIntToInt64(v_1.AuxInt) != y || !(ssa.OneBit(y)) {
					continue
				}
				v.Reset(ssaop.OpNeq64)
				v0 := b.NewValue0(v.Pos, ssaop.OpAnd64, t)
				v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
				v1.AuxInt = ssa.Int64ToAuxInt(y)
				v0.AddArg2(x, v1)
				v2 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
				v2.AuxInt = ssa.Int64ToAuxInt(0)
				v.AddArg2(v0, v2)
				return true
			}
		}
		break
	}
	// match: (Eq64 (ZeroExt8to64 (CvtBoolToUint8 x)) (Const64 [1]))
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpZeroExt8to64 {
				continue
			}
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpCvtBoolToUint8 {
				continue
			}
			x := v_0_0.Args[0]
			if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 1 {
				continue
			}
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (Eq64 (ZeroExt8to64 (CvtBoolToUint8 x)) (Const64 [0]))
	// result: (Not x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpZeroExt8to64 {
				continue
			}
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpCvtBoolToUint8 {
				continue
			}
			x := v_0_0.Args[0]
			if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 {
				continue
			}
			v.Reset(ssaop.OpNot)
			v.AddArg(x)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpEq64F(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	// match: (Eq64F (Const64F [c]) (Const64F [d]))
	// result: (ConstBool [c == d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64F {
				continue
			}
			c := ssa.AuxIntToFloat64(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst64F {
				continue
			}
			d := ssa.AuxIntToFloat64(v_1.AuxInt)
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(c == d)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpEq8(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	typ := &b.Func.Config.Types
	// match: (Eq8 x x)
	// result: (ConstBool [true])
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (Eq8 (Const8 <t> [c]) o:(Add8 (Const8 [d]) x))
	// cond: o.Uses == 1
	// result: (Eq8 (Const8 <t> [c-d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt8(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpAdd8 {
				continue
			}
			_ = o.Args[1]
			o_0 := o.Args[0]
			o_1 := o.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 {
				if o_0.Op != ssaop.OpConst8 {
					continue
				}
				d := ssa.AuxIntToInt8(o_0.AuxInt)
				x := o_1
				if !(o.Uses == 1) {
					continue
				}
				v.Reset(ssaop.OpEq8)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
				v0.AuxInt = ssa.Int8ToAuxInt(c - d)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Eq8 (Const8 <t> [c]) o:(Sub8 x (Const8 [d])))
	// cond: o.Uses == 1
	// result: (Eq8 (Const8 <t> [c+d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt8(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpSub8 {
				continue
			}
			_ = o.Args[1]
			x := o.Args[0]
			o_1 := o.Args[1]
			if o_1.Op != ssaop.OpConst8 {
				continue
			}
			d := ssa.AuxIntToInt8(o_1.AuxInt)
			if !(o.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpEq8)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
			v0.AuxInt = ssa.Int8ToAuxInt(c + d)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Eq8 (Const8 <t> [c]) o:(Sub8 (Const8 [d]) x))
	// cond: o.Uses == 1
	// result: (Eq8 (Const8 <t> [d-c]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt8(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpSub8 {
				continue
			}
			x := o.Args[1]
			o_0 := o.Args[0]
			if o_0.Op != ssaop.OpConst8 {
				continue
			}
			d := ssa.AuxIntToInt8(o_0.AuxInt)
			if !(o.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpEq8)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
			v0.AuxInt = ssa.Int8ToAuxInt(d - c)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Eq8 (Const8 <t> [c]) o:(Xor8 (Const8 [d]) x))
	// cond: o.Uses == 1
	// result: (Eq8 (Const8 <t> [d^c]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt8(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpXor8 {
				continue
			}
			_ = o.Args[1]
			o_0 := o.Args[0]
			o_1 := o.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 {
				if o_0.Op != ssaop.OpConst8 {
					continue
				}
				d := ssa.AuxIntToInt8(o_0.AuxInt)
				x := o_1
				if !(o.Uses == 1) {
					continue
				}
				v.Reset(ssaop.OpEq8)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
				v0.AuxInt = ssa.Int8ToAuxInt(d ^ c)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Eq8 (Const8 <t> [c]) o:(Com8 x))
	// cond: o.Uses == 1
	// result: (Eq8 (Const8 <t> [^c]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt8(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpCom8 {
				continue
			}
			x := o.Args[0]
			if !(o.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpEq8)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
			v0.AuxInt = ssa.Int8ToAuxInt(^c)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Eq8 (Const8 <t> [c]) o:(Neg8 x))
	// cond: o.Uses == 1
	// result: (Eq8 (Const8 <t> [-c]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt8(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpNeg8 {
				continue
			}
			x := o.Args[0]
			if !(o.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpEq8)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
			v0.AuxInt = ssa.Int8ToAuxInt(-c)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Eq8 (Const8 <t> [c]) o:(Mul8 (Const8 [d]) x))
	// cond: uint8( d)%2 == 1 && o.Uses == 1
	// result: (Eq8 (Const8 <t> [int8( uint8( c) * uint8( modularMultiplicativeInverse(uint64(d))))]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt8(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpMul8 {
				continue
			}
			_ = o.Args[1]
			o_0 := o.Args[0]
			o_1 := o.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 {
				if o_0.Op != ssaop.OpConst8 {
					continue
				}
				d := ssa.AuxIntToInt8(o_0.AuxInt)
				x := o_1
				if !(uint8(d)%2 == 1 && o.Uses == 1) {
					continue
				}
				v.Reset(ssaop.OpEq8)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
				v0.AuxInt = ssa.Int8ToAuxInt(int8(uint8(c) * uint8(modularMultiplicativeInverse(uint64(d)))))
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Eq8 (Const8 [c]) (Const8 [d]))
	// result: (ConstBool [c == d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst8 {
				continue
			}
			d := ssa.AuxIntToInt8(v_1.AuxInt)
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(c == d)
			return true
		}
		break
	}
	// match: (Eq8 (Mod8u x (Const8 [c])) (Const8 [0]))
	// cond: x.Op != ssaop.OpConst8 && ssa.UdivisibleOK8(c) && !hasSmallRotate(config)
	// result: (Eq32 (Mod32u <typ.UInt32> (ZeroExt8to32 <typ.UInt32> x) (Const32 <typ.UInt32> [int32(uint8(c))])) (Const32 <typ.UInt32> [0]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpMod8u {
				continue
			}
			_ = v_0.Args[1]
			x := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			if v_0_1.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_0_1.AuxInt)
			if v_1.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_1.AuxInt) != 0 || !(x.Op != ssaop.OpConst8 && ssa.UdivisibleOK8(c) && !hasSmallRotate(config)) {
				continue
			}
			v.Reset(ssaop.OpEq32)
			v0 := b.NewValue0(v.Pos, ssaop.OpMod32u, typ.UInt32)
			v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to32, typ.UInt32)
			v1.AddArg(x)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32)
			v2.AuxInt = ssa.Int32ToAuxInt(int32(uint8(c)))
			v0.AddArg2(v1, v2)
			v3 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32)
			v3.AuxInt = ssa.Int32ToAuxInt(0)
			v.AddArg2(v0, v3)
			return true
		}
		break
	}
	// match: (Eq8 (Mod8 x (Const8 [c])) (Const8 [0]))
	// cond: x.Op != ssaop.OpConst8 && ssa.SdivisibleOK8(c) && !hasSmallRotate(config)
	// result: (Eq32 (Mod32 <typ.Int32> (SignExt8to32 <typ.Int32> x) (Const32 <typ.Int32> [int32(c)])) (Const32 <typ.Int32> [0]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpMod8 {
				continue
			}
			_ = v_0.Args[1]
			x := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			if v_0_1.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_0_1.AuxInt)
			if v_1.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_1.AuxInt) != 0 || !(x.Op != ssaop.OpConst8 && ssa.SdivisibleOK8(c) && !hasSmallRotate(config)) {
				continue
			}
			v.Reset(ssaop.OpEq32)
			v0 := b.NewValue0(v.Pos, ssaop.OpMod32, typ.Int32)
			v1 := b.NewValue0(v.Pos, ssaop.OpSignExt8to32, typ.Int32)
			v1.AddArg(x)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.Int32)
			v2.AuxInt = ssa.Int32ToAuxInt(int32(c))
			v0.AddArg2(v1, v2)
			v3 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.Int32)
			v3.AuxInt = ssa.Int32ToAuxInt(0)
			v.AddArg2(v0, v3)
			return true
		}
		break
	}
	// match: (Eq8 s:(Sub8 x y) (Const8 [0]))
	// cond: s.Uses == 1
	// result: (Eq8 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			s := v_0
			if s.Op != ssaop.OpSub8 {
				continue
			}
			y := s.Args[1]
			x := s.Args[0]
			if v_1.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_1.AuxInt) != 0 || !(s.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpEq8)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Eq8 (And8 <t> x (Const8 <t> [y])) (Const8 <t> [y]))
	// cond: ssa.OneBit(y)
	// result: (Neq8 (And8 <t> x (Const8 <t> [y])) (Const8 <t> [0]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpAnd8 {
				continue
			}
			t := v_0.Type
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				x := v_0_0
				if v_0_1.Op != ssaop.OpConst8 || v_0_1.Type != t {
					continue
				}
				y := ssa.AuxIntToInt8(v_0_1.AuxInt)
				if v_1.Op != ssaop.OpConst8 || v_1.Type != t || ssa.AuxIntToInt8(v_1.AuxInt) != y || !(ssa.OneBit(y)) {
					continue
				}
				v.Reset(ssaop.OpNeq8)
				v0 := b.NewValue0(v.Pos, ssaop.OpAnd8, t)
				v1 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
				v1.AuxInt = ssa.Int8ToAuxInt(y)
				v0.AddArg2(x, v1)
				v2 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
				v2.AuxInt = ssa.Int8ToAuxInt(0)
				v.AddArg2(v0, v2)
				return true
			}
		}
		break
	}
	// match: (Eq8 (CvtBoolToUint8 x) (Const8 [1]))
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpCvtBoolToUint8 {
				continue
			}
			x := v_0.Args[0]
			if v_1.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_1.AuxInt) != 1 {
				continue
			}
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (Eq8 (CvtBoolToUint8 x) (Const8 [0]))
	// result: (Not x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpCvtBoolToUint8 {
				continue
			}
			x := v_0.Args[0]
			if v_1.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_1.AuxInt) != 0 {
				continue
			}
			v.Reset(ssaop.OpNot)
			v.AddArg(x)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpEqB(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	// match: (EqB x x)
	// result: (ConstBool [true])
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (EqB (ConstBool [c]) (ConstBool [d]))
	// result: (ConstBool [c == d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConstBool {
				continue
			}
			c := ssa.AuxIntToBool(v_0.AuxInt)
			if v_1.Op != ssaop.OpConstBool {
				continue
			}
			d := ssa.AuxIntToBool(v_1.AuxInt)
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(c == d)
			return true
		}
		break
	}
	// match: (EqB (ConstBool [false]) x)
	// result: (Not x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConstBool || ssa.AuxIntToBool(v_0.AuxInt) != false {
				continue
			}
			x := v_1
			v.Reset(ssaop.OpNot)
			v.AddArg(x)
			return true
		}
		break
	}
	// match: (EqB (ConstBool [true]) x)
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConstBool || ssa.AuxIntToBool(v_0.AuxInt) != true {
				continue
			}
			x := v_1
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (EqB (Not x) y)
	// result: (NeqB x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNot {
				continue
			}
			x := v_0.Args[0]
			y := v_1
			v.Reset(ssaop.OpNeqB)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpEqInter(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (EqInter x y)
	// result: (EqPtr (ITab x) (ITab y))
	for {
		x := v_0
		y := v_1
		v.Reset(ssaop.OpEqPtr)
		v0 := b.NewValue0(v.Pos, ssaop.OpITab, typ.Uintptr)
		v0.AddArg(x)
		v1 := b.NewValue0(v.Pos, ssaop.OpITab, typ.Uintptr)
		v1.AddArg(y)
		v.AddArg2(v0, v1)
		return true
	}
}
func rewriteValue_OpEqPtr(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (EqPtr x x)
	// result: (ConstBool [true])
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (EqPtr (Addr {x} _) (Addr {y} _))
	// result: (ConstBool [x == y])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpAddr {
				continue
			}
			x := ssa.AuxToSym(v_0.Aux)
			if v_1.Op != ssaop.OpAddr {
				continue
			}
			y := ssa.AuxToSym(v_1.Aux)
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(x == y)
			return true
		}
		break
	}
	// match: (EqPtr (Addr {x} _) (OffPtr [o] (Addr {y} _)))
	// result: (ConstBool [x == y && o == 0])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpAddr {
				continue
			}
			x := ssa.AuxToSym(v_0.Aux)
			if v_1.Op != ssaop.OpOffPtr {
				continue
			}
			o := ssa.AuxIntToInt64(v_1.AuxInt)
			v_1_0 := v_1.Args[0]
			if v_1_0.Op != ssaop.OpAddr {
				continue
			}
			y := ssa.AuxToSym(v_1_0.Aux)
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(x == y && o == 0)
			return true
		}
		break
	}
	// match: (EqPtr (OffPtr [o1] (Addr {x} _)) (OffPtr [o2] (Addr {y} _)))
	// result: (ConstBool [x == y && o1 == o2])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpOffPtr {
				continue
			}
			o1 := ssa.AuxIntToInt64(v_0.AuxInt)
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpAddr {
				continue
			}
			x := ssa.AuxToSym(v_0_0.Aux)
			if v_1.Op != ssaop.OpOffPtr {
				continue
			}
			o2 := ssa.AuxIntToInt64(v_1.AuxInt)
			v_1_0 := v_1.Args[0]
			if v_1_0.Op != ssaop.OpAddr {
				continue
			}
			y := ssa.AuxToSym(v_1_0.Aux)
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(x == y && o1 == o2)
			return true
		}
		break
	}
	// match: (EqPtr (LocalAddr {x} _ _) (LocalAddr {y} _ _))
	// result: (ConstBool [x == y])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLocalAddr {
				continue
			}
			x := ssa.AuxToSym(v_0.Aux)
			if v_1.Op != ssaop.OpLocalAddr {
				continue
			}
			y := ssa.AuxToSym(v_1.Aux)
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(x == y)
			return true
		}
		break
	}
	// match: (EqPtr (LocalAddr {x} _ _) (OffPtr [o] (LocalAddr {y} _ _)))
	// result: (ConstBool [x == y && o == 0])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLocalAddr {
				continue
			}
			x := ssa.AuxToSym(v_0.Aux)
			if v_1.Op != ssaop.OpOffPtr {
				continue
			}
			o := ssa.AuxIntToInt64(v_1.AuxInt)
			v_1_0 := v_1.Args[0]
			if v_1_0.Op != ssaop.OpLocalAddr {
				continue
			}
			y := ssa.AuxToSym(v_1_0.Aux)
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(x == y && o == 0)
			return true
		}
		break
	}
	// match: (EqPtr (OffPtr [o1] (LocalAddr {x} _ _)) (OffPtr [o2] (LocalAddr {y} _ _)))
	// result: (ConstBool [x == y && o1 == o2])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpOffPtr {
				continue
			}
			o1 := ssa.AuxIntToInt64(v_0.AuxInt)
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpLocalAddr {
				continue
			}
			x := ssa.AuxToSym(v_0_0.Aux)
			if v_1.Op != ssaop.OpOffPtr {
				continue
			}
			o2 := ssa.AuxIntToInt64(v_1.AuxInt)
			v_1_0 := v_1.Args[0]
			if v_1_0.Op != ssaop.OpLocalAddr {
				continue
			}
			y := ssa.AuxToSym(v_1_0.Aux)
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(x == y && o1 == o2)
			return true
		}
		break
	}
	// match: (EqPtr (OffPtr [o1] p1) p2)
	// cond: ssa.IsSamePtr(p1, p2)
	// result: (ConstBool [o1 == 0])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpOffPtr {
				continue
			}
			o1 := ssa.AuxIntToInt64(v_0.AuxInt)
			p1 := v_0.Args[0]
			p2 := v_1
			if !(ssa.IsSamePtr(p1, p2)) {
				continue
			}
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(o1 == 0)
			return true
		}
		break
	}
	// match: (EqPtr (OffPtr [o1] p1) (OffPtr [o2] p2))
	// cond: ssa.IsSamePtr(p1, p2)
	// result: (ConstBool [o1 == o2])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpOffPtr {
				continue
			}
			o1 := ssa.AuxIntToInt64(v_0.AuxInt)
			p1 := v_0.Args[0]
			if v_1.Op != ssaop.OpOffPtr {
				continue
			}
			o2 := ssa.AuxIntToInt64(v_1.AuxInt)
			p2 := v_1.Args[0]
			if !(ssa.IsSamePtr(p1, p2)) {
				continue
			}
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(o1 == o2)
			return true
		}
		break
	}
	// match: (EqPtr (Const32 [c]) (Const32 [d]))
	// result: (ConstBool [c == d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(v_1.AuxInt)
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(c == d)
			return true
		}
		break
	}
	// match: (EqPtr (Const64 [c]) (Const64 [d]))
	// result: (ConstBool [c == d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1.AuxInt)
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(c == d)
			return true
		}
		break
	}
	// match: (EqPtr (Convert (Addr {x} _) _) (Addr {y} _))
	// result: (ConstBool [x==y])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConvert {
				continue
			}
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpAddr {
				continue
			}
			x := ssa.AuxToSym(v_0_0.Aux)
			if v_1.Op != ssaop.OpAddr {
				continue
			}
			y := ssa.AuxToSym(v_1.Aux)
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(x == y)
			return true
		}
		break
	}
	// match: (EqPtr (LocalAddr _ _) (Addr _))
	// result: (ConstBool [false])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLocalAddr || v_1.Op != ssaop.OpAddr {
				continue
			}
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(false)
			return true
		}
		break
	}
	// match: (EqPtr (OffPtr (LocalAddr _ _)) (Addr _))
	// result: (ConstBool [false])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpOffPtr {
				continue
			}
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpLocalAddr || v_1.Op != ssaop.OpAddr {
				continue
			}
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(false)
			return true
		}
		break
	}
	// match: (EqPtr (LocalAddr _ _) (OffPtr (Addr _)))
	// result: (ConstBool [false])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLocalAddr || v_1.Op != ssaop.OpOffPtr {
				continue
			}
			v_1_0 := v_1.Args[0]
			if v_1_0.Op != ssaop.OpAddr {
				continue
			}
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(false)
			return true
		}
		break
	}
	// match: (EqPtr (OffPtr (LocalAddr _ _)) (OffPtr (Addr _)))
	// result: (ConstBool [false])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpOffPtr {
				continue
			}
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpLocalAddr || v_1.Op != ssaop.OpOffPtr {
				continue
			}
			v_1_0 := v_1.Args[0]
			if v_1_0.Op != ssaop.OpAddr {
				continue
			}
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(false)
			return true
		}
		break
	}
	// match: (EqPtr (AddPtr p1 o1) p2)
	// cond: ssa.IsSamePtr(p1, p2)
	// result: (Not (IsNonNil o1))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpAddPtr {
				continue
			}
			o1 := v_0.Args[1]
			p1 := v_0.Args[0]
			p2 := v_1
			if !(ssa.IsSamePtr(p1, p2)) {
				continue
			}
			v.Reset(ssaop.OpNot)
			v0 := b.NewValue0(v.Pos, ssaop.OpIsNonNil, typ.Bool)
			v0.AddArg(o1)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (EqPtr (Const32 [0]) p)
	// result: (Not (IsNonNil p))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 {
				continue
			}
			p := v_1
			v.Reset(ssaop.OpNot)
			v0 := b.NewValue0(v.Pos, ssaop.OpIsNonNil, typ.Bool)
			v0.AddArg(p)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (EqPtr (Const64 [0]) p)
	// result: (Not (IsNonNil p))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 {
				continue
			}
			p := v_1
			v.Reset(ssaop.OpNot)
			v0 := b.NewValue0(v.Pos, ssaop.OpIsNonNil, typ.Bool)
			v0.AddArg(p)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (EqPtr (ConstNil) p)
	// result: (Not (IsNonNil p))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConstNil {
				continue
			}
			p := v_1
			v.Reset(ssaop.OpNot)
			v0 := b.NewValue0(v.Pos, ssaop.OpIsNonNil, typ.Bool)
			v0.AddArg(p)
			v.AddArg(v0)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpEqSlice(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (EqSlice x y)
	// result: (EqPtr (SlicePtr x) (SlicePtr y))
	for {
		x := v_0
		y := v_1
		v.Reset(ssaop.OpEqPtr)
		v0 := b.NewValue0(v.Pos, ssaop.OpSlicePtr, typ.BytePtr)
		v0.AddArg(x)
		v1 := b.NewValue0(v.Pos, ssaop.OpSlicePtr, typ.BytePtr)
		v1.AddArg(y)
		v.AddArg2(v0, v1)
		return true
	}
}
func rewriteValue_OpFloor(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (Floor (Const64F [c]))
	// result: (Const64F [math.Floor(c)])
	for {
		if v_0.Op != ssaop.OpConst64F {
			break
		}
		c := ssa.AuxIntToFloat64(v_0.AuxInt)
		v.Reset(ssaop.OpConst64F)
		v.AuxInt = ssa.Float64ToAuxInt(math.Floor(c))
		return true
	}
	return false
}
func rewriteValue_OpIMake(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	// match: (IMake _typ (StructMake ___))
	// result: ssa.ImakeOfStructMake(v)
	for {
		if v_1.Op != ssaop.OpStructMake {
			break
		}
		v.CopyOf(ssa.ImakeOfStructMake(v))
		return true
	}
	// match: (IMake _typ (ArrayMake1 val))
	// result: (IMake _typ val)
	for {
		_typ := v_0
		if v_1.Op != ssaop.OpArrayMake1 {
			break
		}
		val := v_1.Args[0]
		v.Reset(ssaop.OpIMake)
		v.AddArg2(_typ, val)
		return true
	}
	return false
}
func rewriteValue_OpInterLECall(v *ssa.Value) bool {
	// match: (InterLECall [argsize] {auxCall} (Addr {fn} (SB)) ___)
	// result: devirtLECall(v, fn.(*obj.LSym))
	for {
		if len(v.Args) < 1 {
			break
		}
		v_0 := v.Args[0]
		if v_0.Op != ssaop.OpAddr {
			break
		}
		fn := ssa.AuxToSym(v_0.Aux)
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpSB {
			break
		}
		v.CopyOf(devirtLECall(v, fn.(*obj.LSym)))
		return true
	}
	return false
}
func rewriteValue_OpIsInBounds(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	// match: (IsInBounds (ZeroExt8to32 _) (Const32 [c]))
	// cond: (1 << 8) <= c
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpZeroExt8to32 || v_1.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_1.AuxInt)
		if !((1 << 8) <= c) {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (IsInBounds (ZeroExt8to64 _) (Const64 [c]))
	// cond: (1 << 8) <= c
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpZeroExt8to64 || v_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_1.AuxInt)
		if !((1 << 8) <= c) {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (IsInBounds (ZeroExt16to32 _) (Const32 [c]))
	// cond: (1 << 16) <= c
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpZeroExt16to32 || v_1.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_1.AuxInt)
		if !((1 << 16) <= c) {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (IsInBounds (ZeroExt16to64 _) (Const64 [c]))
	// cond: (1 << 16) <= c
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpZeroExt16to64 || v_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_1.AuxInt)
		if !((1 << 16) <= c) {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (IsInBounds x x)
	// result: (ConstBool [false])
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(false)
		return true
	}
	// match: (IsInBounds (And8 (Const8 [c]) _) (Const8 [d]))
	// cond: 0 <= c && c < d
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpAnd8 {
			break
		}
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			if v_0_0.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpConst8 {
				continue
			}
			d := ssa.AuxIntToInt8(v_1.AuxInt)
			if !(0 <= c && c < d) {
				continue
			}
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(true)
			return true
		}
		break
	}
	// match: (IsInBounds (ZeroExt8to16 (And8 (Const8 [c]) _)) (Const16 [d]))
	// cond: 0 <= c && int16(c) < d
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpZeroExt8to16 {
			break
		}
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpAnd8 {
			break
		}
		v_0_0_0 := v_0_0.Args[0]
		v_0_0_1 := v_0_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0_0, v_0_0_1 = _i0+1, v_0_0_1, v_0_0_0 {
			if v_0_0_0.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_0_0_0.AuxInt)
			if v_1.Op != ssaop.OpConst16 {
				continue
			}
			d := ssa.AuxIntToInt16(v_1.AuxInt)
			if !(0 <= c && int16(c) < d) {
				continue
			}
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(true)
			return true
		}
		break
	}
	// match: (IsInBounds (ZeroExt8to32 (And8 (Const8 [c]) _)) (Const32 [d]))
	// cond: 0 <= c && int32(c) < d
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpZeroExt8to32 {
			break
		}
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpAnd8 {
			break
		}
		v_0_0_0 := v_0_0.Args[0]
		v_0_0_1 := v_0_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0_0, v_0_0_1 = _i0+1, v_0_0_1, v_0_0_0 {
			if v_0_0_0.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_0_0_0.AuxInt)
			if v_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(v_1.AuxInt)
			if !(0 <= c && int32(c) < d) {
				continue
			}
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(true)
			return true
		}
		break
	}
	// match: (IsInBounds (ZeroExt8to64 (And8 (Const8 [c]) _)) (Const64 [d]))
	// cond: 0 <= c && int64(c) < d
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpZeroExt8to64 {
			break
		}
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpAnd8 {
			break
		}
		v_0_0_0 := v_0_0.Args[0]
		v_0_0_1 := v_0_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0_0, v_0_0_1 = _i0+1, v_0_0_1, v_0_0_0 {
			if v_0_0_0.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_0_0_0.AuxInt)
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1.AuxInt)
			if !(0 <= c && int64(c) < d) {
				continue
			}
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(true)
			return true
		}
		break
	}
	// match: (IsInBounds (And16 (Const16 [c]) _) (Const16 [d]))
	// cond: 0 <= c && c < d
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpAnd16 {
			break
		}
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			if v_0_0.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpConst16 {
				continue
			}
			d := ssa.AuxIntToInt16(v_1.AuxInt)
			if !(0 <= c && c < d) {
				continue
			}
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(true)
			return true
		}
		break
	}
	// match: (IsInBounds (ZeroExt16to32 (And16 (Const16 [c]) _)) (Const32 [d]))
	// cond: 0 <= c && int32(c) < d
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpZeroExt16to32 {
			break
		}
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpAnd16 {
			break
		}
		v_0_0_0 := v_0_0.Args[0]
		v_0_0_1 := v_0_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0_0, v_0_0_1 = _i0+1, v_0_0_1, v_0_0_0 {
			if v_0_0_0.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_0_0_0.AuxInt)
			if v_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(v_1.AuxInt)
			if !(0 <= c && int32(c) < d) {
				continue
			}
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(true)
			return true
		}
		break
	}
	// match: (IsInBounds (ZeroExt16to64 (And16 (Const16 [c]) _)) (Const64 [d]))
	// cond: 0 <= c && int64(c) < d
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpZeroExt16to64 {
			break
		}
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpAnd16 {
			break
		}
		v_0_0_0 := v_0_0.Args[0]
		v_0_0_1 := v_0_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0_0, v_0_0_1 = _i0+1, v_0_0_1, v_0_0_0 {
			if v_0_0_0.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_0_0_0.AuxInt)
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1.AuxInt)
			if !(0 <= c && int64(c) < d) {
				continue
			}
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(true)
			return true
		}
		break
	}
	// match: (IsInBounds (And32 (Const32 [c]) _) (Const32 [d]))
	// cond: 0 <= c && c < d
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpAnd32 {
			break
		}
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			if v_0_0.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(v_1.AuxInt)
			if !(0 <= c && c < d) {
				continue
			}
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(true)
			return true
		}
		break
	}
	// match: (IsInBounds (ZeroExt32to64 (And32 (Const32 [c]) _)) (Const64 [d]))
	// cond: 0 <= c && int64(c) < d
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpZeroExt32to64 {
			break
		}
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpAnd32 {
			break
		}
		v_0_0_0 := v_0_0.Args[0]
		v_0_0_1 := v_0_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0_0, v_0_0_1 = _i0+1, v_0_0_1, v_0_0_0 {
			if v_0_0_0.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_0_0_0.AuxInt)
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1.AuxInt)
			if !(0 <= c && int64(c) < d) {
				continue
			}
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(true)
			return true
		}
		break
	}
	// match: (IsInBounds (And64 (Const64 [c]) _) (Const64 [d]))
	// cond: 0 <= c && c < d
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpAnd64 {
			break
		}
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			if v_0_0.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1.AuxInt)
			if !(0 <= c && c < d) {
				continue
			}
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(true)
			return true
		}
		break
	}
	// match: (IsInBounds (Const32 [c]) (Const32 [d]))
	// result: (ConstBool [0 <= c && c < d])
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		d := ssa.AuxIntToInt32(v_1.AuxInt)
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(0 <= c && c < d)
		return true
	}
	// match: (IsInBounds (Const64 [c]) (Const64 [d]))
	// result: (ConstBool [0 <= c && c < d])
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(0 <= c && c < d)
		return true
	}
	// match: (IsInBounds (Mod32u _ y) y)
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpMod32u {
			break
		}
		y := v_0.Args[1]
		if y != v_1 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (IsInBounds (Mod64u _ y) y)
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpMod64u {
			break
		}
		y := v_0.Args[1]
		if y != v_1 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (IsInBounds (ZeroExt8to64 (Rsh8Ux64 _ (Const64 [c]))) (Const64 [d]))
	// cond: 0 < c && c < 8 && 1<<uint( 8-c)-1 < d
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpZeroExt8to64 {
			break
		}
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpRsh8Ux64 {
			break
		}
		_ = v_0_0.Args[1]
		v_0_0_1 := v_0_0.Args[1]
		if v_0_0_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0_0_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(0 < c && c < 8 && 1<<uint(8-c)-1 < d) {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (IsInBounds (ZeroExt8to32 (Rsh8Ux64 _ (Const64 [c]))) (Const32 [d]))
	// cond: 0 < c && c < 8 && 1<<uint( 8-c)-1 < d
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpZeroExt8to32 {
			break
		}
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpRsh8Ux64 {
			break
		}
		_ = v_0_0.Args[1]
		v_0_0_1 := v_0_0.Args[1]
		if v_0_0_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0_0_1.AuxInt)
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		d := ssa.AuxIntToInt32(v_1.AuxInt)
		if !(0 < c && c < 8 && 1<<uint(8-c)-1 < d) {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (IsInBounds (ZeroExt8to16 (Rsh8Ux64 _ (Const64 [c]))) (Const16 [d]))
	// cond: 0 < c && c < 8 && 1<<uint( 8-c)-1 < d
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpZeroExt8to16 {
			break
		}
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpRsh8Ux64 {
			break
		}
		_ = v_0_0.Args[1]
		v_0_0_1 := v_0_0.Args[1]
		if v_0_0_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0_0_1.AuxInt)
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		d := ssa.AuxIntToInt16(v_1.AuxInt)
		if !(0 < c && c < 8 && 1<<uint(8-c)-1 < d) {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (IsInBounds (Rsh8Ux64 _ (Const64 [c])) (Const8 [d]))
	// cond: 0 < c && c < 8 && 1<<uint( 8-c)-1 < d
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpRsh8Ux64 {
			break
		}
		_ = v_0.Args[1]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0_1.AuxInt)
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		d := ssa.AuxIntToInt8(v_1.AuxInt)
		if !(0 < c && c < 8 && 1<<uint(8-c)-1 < d) {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (IsInBounds (ZeroExt16to64 (Rsh16Ux64 _ (Const64 [c]))) (Const64 [d]))
	// cond: 0 < c && c < 16 && 1<<uint(16-c)-1 < d
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpZeroExt16to64 {
			break
		}
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpRsh16Ux64 {
			break
		}
		_ = v_0_0.Args[1]
		v_0_0_1 := v_0_0.Args[1]
		if v_0_0_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0_0_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(0 < c && c < 16 && 1<<uint(16-c)-1 < d) {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (IsInBounds (ZeroExt16to32 (Rsh16Ux64 _ (Const64 [c]))) (Const32 [d]))
	// cond: 0 < c && c < 16 && 1<<uint(16-c)-1 < d
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpZeroExt16to32 {
			break
		}
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpRsh16Ux64 {
			break
		}
		_ = v_0_0.Args[1]
		v_0_0_1 := v_0_0.Args[1]
		if v_0_0_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0_0_1.AuxInt)
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		d := ssa.AuxIntToInt32(v_1.AuxInt)
		if !(0 < c && c < 16 && 1<<uint(16-c)-1 < d) {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (IsInBounds (Rsh16Ux64 _ (Const64 [c])) (Const16 [d]))
	// cond: 0 < c && c < 16 && 1<<uint(16-c)-1 < d
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpRsh16Ux64 {
			break
		}
		_ = v_0.Args[1]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0_1.AuxInt)
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		d := ssa.AuxIntToInt16(v_1.AuxInt)
		if !(0 < c && c < 16 && 1<<uint(16-c)-1 < d) {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (IsInBounds (ZeroExt32to64 (Rsh32Ux64 _ (Const64 [c]))) (Const64 [d]))
	// cond: 0 < c && c < 32 && 1<<uint(32-c)-1 < d
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpZeroExt32to64 {
			break
		}
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpRsh32Ux64 {
			break
		}
		_ = v_0_0.Args[1]
		v_0_0_1 := v_0_0.Args[1]
		if v_0_0_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0_0_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(0 < c && c < 32 && 1<<uint(32-c)-1 < d) {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (IsInBounds (Rsh32Ux64 _ (Const64 [c])) (Const32 [d]))
	// cond: 0 < c && c < 32 && 1<<uint(32-c)-1 < d
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpRsh32Ux64 {
			break
		}
		_ = v_0.Args[1]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0_1.AuxInt)
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		d := ssa.AuxIntToInt32(v_1.AuxInt)
		if !(0 < c && c < 32 && 1<<uint(32-c)-1 < d) {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (IsInBounds (Rsh64Ux64 _ (Const64 [c])) (Const64 [d]))
	// cond: 0 < c && c < 64 && 1<<uint(64-c)-1 < d
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpRsh64Ux64 {
			break
		}
		_ = v_0.Args[1]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(0 < c && c < 64 && 1<<uint(64-c)-1 < d) {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	return false
}
func rewriteValue_OpIsNonNil(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (IsNonNil (ConstNil))
	// result: (ConstBool [false])
	for {
		if v_0.Op != ssaop.OpConstNil {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(false)
		return true
	}
	// match: (IsNonNil (Const32 [c]))
	// result: (ConstBool [c != 0])
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_0.AuxInt)
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(c != 0)
		return true
	}
	// match: (IsNonNil (Const64 [c]))
	// result: (ConstBool [c != 0])
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0.AuxInt)
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(c != 0)
		return true
	}
	// match: (IsNonNil (Addr _) )
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpAddr {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (IsNonNil (Convert (Addr _) _))
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpConvert {
			break
		}
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpAddr {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (IsNonNil (LocalAddr _ _))
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpLocalAddr {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	return false
}
func rewriteValue_OpIsSliceInBounds(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	// match: (IsSliceInBounds x x)
	// result: (ConstBool [true])
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (IsSliceInBounds (And32 (Const32 [c]) _) (Const32 [d]))
	// cond: 0 <= c && c <= d
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpAnd32 {
			break
		}
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			if v_0_0.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(v_1.AuxInt)
			if !(0 <= c && c <= d) {
				continue
			}
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(true)
			return true
		}
		break
	}
	// match: (IsSliceInBounds (And64 (Const64 [c]) _) (Const64 [d]))
	// cond: 0 <= c && c <= d
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpAnd64 {
			break
		}
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			if v_0_0.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1.AuxInt)
			if !(0 <= c && c <= d) {
				continue
			}
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(true)
			return true
		}
		break
	}
	// match: (IsSliceInBounds (Const32 [0]) _)
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (IsSliceInBounds (Const64 [0]) _)
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (IsSliceInBounds (Const32 [c]) (Const32 [d]))
	// result: (ConstBool [0 <= c && c <= d])
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		d := ssa.AuxIntToInt32(v_1.AuxInt)
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(0 <= c && c <= d)
		return true
	}
	// match: (IsSliceInBounds (Const64 [c]) (Const64 [d]))
	// result: (ConstBool [0 <= c && c <= d])
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(0 <= c && c <= d)
		return true
	}
	// match: (IsSliceInBounds (SliceLen x) (SliceCap x))
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpSliceLen {
			break
		}
		x := v_0.Args[0]
		if v_1.Op != ssaop.OpSliceCap || x != v_1.Args[0] {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	return false
}
func rewriteValue_OpLeq16(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Leq16 (Const16 [c]) (Const16 [d]))
	// result: (ConstBool [c <= d])
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		d := ssa.AuxIntToInt16(v_1.AuxInt)
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(c <= d)
		return true
	}
	// match: (Leq16 (Const16 [0]) (And16 _ (Const16 [c])))
	// cond: c >= 0
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 || v_1.Op != ssaop.OpAnd16 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			if v_1_1.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_1_1.AuxInt)
			if !(c >= 0) {
				continue
			}
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(true)
			return true
		}
		break
	}
	// match: (Leq16 (Const16 [0]) (Rsh16Ux64 _ (Const64 [c])))
	// cond: c > 0
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 || v_1.Op != ssaop.OpRsh16Ux64 {
			break
		}
		_ = v_1.Args[1]
		v_1_1 := v_1.Args[1]
		if v_1_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_1_1.AuxInt)
		if !(c > 0) {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (Leq16 x (Const16 <t> [0]))
	// cond: isNonNegative(x)
	// result: (Eq16 (Const16 <t> [0]) x)
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		t := v_1.Type
		if ssa.AuxIntToInt16(v_1.AuxInt) != 0 || !(isNonNegative(x)) {
			break
		}
		v.Reset(ssaop.OpEq16)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
		v0.AuxInt = ssa.Int16ToAuxInt(0)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Leq16 x (Const16 <t> [-1]))
	// result: (Less16 x (Const16 <t> [0]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		t := v_1.Type
		if ssa.AuxIntToInt16(v_1.AuxInt) != -1 {
			break
		}
		v.Reset(ssaop.OpLess16)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
		v0.AuxInt = ssa.Int16ToAuxInt(0)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Leq16 (Const16 <t> [1]) x)
	// result: (Less16 (Const16 <t> [0]) x)
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		t := v_0.Type
		if ssa.AuxIntToInt16(v_0.AuxInt) != 1 {
			break
		}
		x := v_1
		v.Reset(ssaop.OpLess16)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
		v0.AuxInt = ssa.Int16ToAuxInt(0)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Leq16 (Const16 [math.MinInt16]) _)
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != math.MinInt16 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (Leq16 _ (Const16 [math.MaxInt16]))
	// result: (ConstBool [true])
	for {
		if v_1.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_1.AuxInt) != math.MaxInt16 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (Leq16 x c:(Const16 [math.MinInt16]))
	// result: (Eq16 x c)
	for {
		x := v_0
		c := v_1
		if c.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(c.AuxInt) != math.MinInt16 {
			break
		}
		v.Reset(ssaop.OpEq16)
		v.AddArg2(x, c)
		return true
	}
	// match: (Leq16 c:(Const16 [math.MaxInt16]) x)
	// result: (Eq16 x c)
	for {
		c := v_0
		if c.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(c.AuxInt) != math.MaxInt16 {
			break
		}
		x := v_1
		v.Reset(ssaop.OpEq16)
		v.AddArg2(x, c)
		return true
	}
	return false
}
func rewriteValue_OpLeq16U(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Leq16U (Const16 [c]) (Const16 [d]))
	// result: (ConstBool [uint16(c) <= uint16(d)])
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		d := ssa.AuxIntToInt16(v_1.AuxInt)
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(uint16(c) <= uint16(d))
		return true
	}
	// match: (Leq16U (Const16 <t> [1]) x)
	// result: (Neq16 (Const16 <t> [0]) x)
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		t := v_0.Type
		if ssa.AuxIntToInt16(v_0.AuxInt) != 1 {
			break
		}
		x := v_1
		v.Reset(ssaop.OpNeq16)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
		v0.AuxInt = ssa.Int16ToAuxInt(0)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Leq16U (Const16 [0]) _)
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (Leq16U _ (Const16 [-1]))
	// result: (ConstBool [true])
	for {
		if v_1.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_1.AuxInt) != -1 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (Leq16U x c:(Const16 [0]))
	// result: (Eq16 x c)
	for {
		x := v_0
		c := v_1
		if c.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(c.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpEq16)
		v.AddArg2(x, c)
		return true
	}
	// match: (Leq16U c:(Const16 [-1]) x)
	// result: (Eq16 x c)
	for {
		c := v_0
		if c.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(c.AuxInt) != -1 {
			break
		}
		x := v_1
		v.Reset(ssaop.OpEq16)
		v.AddArg2(x, c)
		return true
	}
	return false
}
func rewriteValue_OpLeq32(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Leq32 (Const32 [c]) (Const32 [d]))
	// result: (ConstBool [c <= d])
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		d := ssa.AuxIntToInt32(v_1.AuxInt)
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(c <= d)
		return true
	}
	// match: (Leq32 (Const32 [0]) (And32 _ (Const32 [c])))
	// cond: c >= 0
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 || v_1.Op != ssaop.OpAnd32 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			if v_1_1.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_1_1.AuxInt)
			if !(c >= 0) {
				continue
			}
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(true)
			return true
		}
		break
	}
	// match: (Leq32 (Const32 [0]) (Rsh32Ux64 _ (Const64 [c])))
	// cond: c > 0
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 || v_1.Op != ssaop.OpRsh32Ux64 {
			break
		}
		_ = v_1.Args[1]
		v_1_1 := v_1.Args[1]
		if v_1_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_1_1.AuxInt)
		if !(c > 0) {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (Leq32 x (Const32 <t> [0]))
	// cond: isNonNegative(x)
	// result: (Eq32 (Const32 <t> [0]) x)
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		t := v_1.Type
		if ssa.AuxIntToInt32(v_1.AuxInt) != 0 || !(isNonNegative(x)) {
			break
		}
		v.Reset(ssaop.OpEq32)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
		v0.AuxInt = ssa.Int32ToAuxInt(0)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Leq32 x (Const32 <t> [-1]))
	// result: (Less32 x (Const32 <t> [0]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		t := v_1.Type
		if ssa.AuxIntToInt32(v_1.AuxInt) != -1 {
			break
		}
		v.Reset(ssaop.OpLess32)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
		v0.AuxInt = ssa.Int32ToAuxInt(0)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Leq32 (Const32 <t> [1]) x)
	// result: (Less32 (Const32 <t> [0]) x)
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		t := v_0.Type
		if ssa.AuxIntToInt32(v_0.AuxInt) != 1 {
			break
		}
		x := v_1
		v.Reset(ssaop.OpLess32)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
		v0.AuxInt = ssa.Int32ToAuxInt(0)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Leq32 (Const32 [math.MinInt32]) _)
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != math.MinInt32 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (Leq32 _ (Const32 [math.MaxInt32]))
	// result: (ConstBool [true])
	for {
		if v_1.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1.AuxInt) != math.MaxInt32 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (Leq32 x c:(Const32 [math.MinInt32]))
	// result: (Eq32 x c)
	for {
		x := v_0
		c := v_1
		if c.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(c.AuxInt) != math.MinInt32 {
			break
		}
		v.Reset(ssaop.OpEq32)
		v.AddArg2(x, c)
		return true
	}
	// match: (Leq32 c:(Const32 [math.MaxInt32]) x)
	// result: (Eq32 x c)
	for {
		c := v_0
		if c.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(c.AuxInt) != math.MaxInt32 {
			break
		}
		x := v_1
		v.Reset(ssaop.OpEq32)
		v.AddArg2(x, c)
		return true
	}
	return false
}
func rewriteValue_OpLeq32F(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	// match: (Leq32F (Const32F [c]) (Const32F [d]))
	// result: (ConstBool [c <= d])
	for {
		if v_0.Op != ssaop.OpConst32F {
			break
		}
		c := ssa.AuxIntToFloat32(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst32F {
			break
		}
		d := ssa.AuxIntToFloat32(v_1.AuxInt)
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(c <= d)
		return true
	}
	return false
}
func rewriteValue_OpLeq32U(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Leq32U (Const32 [c]) (Const32 [d]))
	// result: (ConstBool [uint32(c) <= uint32(d)])
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		d := ssa.AuxIntToInt32(v_1.AuxInt)
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(uint32(c) <= uint32(d))
		return true
	}
	// match: (Leq32U (Const32 <t> [1]) x)
	// result: (Neq32 (Const32 <t> [0]) x)
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		t := v_0.Type
		if ssa.AuxIntToInt32(v_0.AuxInt) != 1 {
			break
		}
		x := v_1
		v.Reset(ssaop.OpNeq32)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
		v0.AuxInt = ssa.Int32ToAuxInt(0)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Leq32U (Const32 [0]) _)
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (Leq32U _ (Const32 [-1]))
	// result: (ConstBool [true])
	for {
		if v_1.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1.AuxInt) != -1 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (Leq32U x c:(Const32 [0]))
	// result: (Eq32 x c)
	for {
		x := v_0
		c := v_1
		if c.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(c.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpEq32)
		v.AddArg2(x, c)
		return true
	}
	// match: (Leq32U c:(Const32 [-1]) x)
	// result: (Eq32 x c)
	for {
		c := v_0
		if c.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(c.AuxInt) != -1 {
			break
		}
		x := v_1
		v.Reset(ssaop.OpEq32)
		v.AddArg2(x, c)
		return true
	}
	return false
}
func rewriteValue_OpLeq64(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Leq64 (Const64 [c]) (Const64 [d]))
	// result: (ConstBool [c <= d])
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(c <= d)
		return true
	}
	// match: (Leq64 (Const64 [0]) (And64 _ (Const64 [c])))
	// cond: c >= 0
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 || v_1.Op != ssaop.OpAnd64 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(c >= 0) {
				continue
			}
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(true)
			return true
		}
		break
	}
	// match: (Leq64 (Const64 [0]) (Rsh64Ux64 _ (Const64 [c])))
	// cond: c > 0
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 || v_1.Op != ssaop.OpRsh64Ux64 {
			break
		}
		_ = v_1.Args[1]
		v_1_1 := v_1.Args[1]
		if v_1_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_1_1.AuxInt)
		if !(c > 0) {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (Leq64 x (Const64 <t> [0]))
	// cond: isNonNegative(x)
	// result: (Eq64 (Const64 <t> [0]) x)
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		t := v_1.Type
		if ssa.AuxIntToInt64(v_1.AuxInt) != 0 || !(isNonNegative(x)) {
			break
		}
		v.Reset(ssaop.OpEq64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(0)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Leq64 x (Const64 <t> [-1]))
	// result: (Less64 x (Const64 <t> [0]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		t := v_1.Type
		if ssa.AuxIntToInt64(v_1.AuxInt) != -1 {
			break
		}
		v.Reset(ssaop.OpLess64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(0)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Leq64 (Const64 <t> [1]) x)
	// result: (Less64 (Const64 <t> [0]) x)
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		t := v_0.Type
		if ssa.AuxIntToInt64(v_0.AuxInt) != 1 {
			break
		}
		x := v_1
		v.Reset(ssaop.OpLess64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(0)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Leq64 (Const64 [math.MinInt64]) _)
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != math.MinInt64 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (Leq64 _ (Const64 [math.MaxInt64]))
	// result: (ConstBool [true])
	for {
		if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != math.MaxInt64 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (Leq64 x c:(Const64 [math.MinInt64]))
	// result: (Eq64 x c)
	for {
		x := v_0
		c := v_1
		if c.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(c.AuxInt) != math.MinInt64 {
			break
		}
		v.Reset(ssaop.OpEq64)
		v.AddArg2(x, c)
		return true
	}
	// match: (Leq64 c:(Const64 [math.MaxInt64]) x)
	// result: (Eq64 x c)
	for {
		c := v_0
		if c.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(c.AuxInt) != math.MaxInt64 {
			break
		}
		x := v_1
		v.Reset(ssaop.OpEq64)
		v.AddArg2(x, c)
		return true
	}
	return false
}
func rewriteValue_OpLeq64F(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	// match: (Leq64F (Const64F [c]) (Const64F [d]))
	// result: (ConstBool [c <= d])
	for {
		if v_0.Op != ssaop.OpConst64F {
			break
		}
		c := ssa.AuxIntToFloat64(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst64F {
			break
		}
		d := ssa.AuxIntToFloat64(v_1.AuxInt)
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(c <= d)
		return true
	}
	return false
}
func rewriteValue_OpLeq64U(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Leq64U (Const64 [c]) (Const64 [d]))
	// result: (ConstBool [uint64(c) <= uint64(d)])
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(uint64(c) <= uint64(d))
		return true
	}
	// match: (Leq64U (Const64 <t> [1]) x)
	// result: (Neq64 (Const64 <t> [0]) x)
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		t := v_0.Type
		if ssa.AuxIntToInt64(v_0.AuxInt) != 1 {
			break
		}
		x := v_1
		v.Reset(ssaop.OpNeq64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(0)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Leq64U (Const64 [0]) _)
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (Leq64U _ (Const64 [-1]))
	// result: (ConstBool [true])
	for {
		if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != -1 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (Leq64U x c:(Const64 [0]))
	// result: (Eq64 x c)
	for {
		x := v_0
		c := v_1
		if c.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(c.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpEq64)
		v.AddArg2(x, c)
		return true
	}
	// match: (Leq64U c:(Const64 [-1]) x)
	// result: (Eq64 x c)
	for {
		c := v_0
		if c.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(c.AuxInt) != -1 {
			break
		}
		x := v_1
		v.Reset(ssaop.OpEq64)
		v.AddArg2(x, c)
		return true
	}
	return false
}
func rewriteValue_OpLeq8(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Leq8 (Const8 [c]) (Const8 [d]))
	// result: (ConstBool [c <= d])
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		d := ssa.AuxIntToInt8(v_1.AuxInt)
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(c <= d)
		return true
	}
	// match: (Leq8 (Const8 [0]) (And8 _ (Const8 [c])))
	// cond: c >= 0
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 || v_1.Op != ssaop.OpAnd8 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			if v_1_1.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_1_1.AuxInt)
			if !(c >= 0) {
				continue
			}
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(true)
			return true
		}
		break
	}
	// match: (Leq8 (Const8 [0]) (Rsh8Ux64 _ (Const64 [c])))
	// cond: c > 0
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 || v_1.Op != ssaop.OpRsh8Ux64 {
			break
		}
		_ = v_1.Args[1]
		v_1_1 := v_1.Args[1]
		if v_1_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_1_1.AuxInt)
		if !(c > 0) {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (Leq8 x (Const8 <t> [0]))
	// cond: isNonNegative(x)
	// result: (Eq8 (Const8 <t> [0]) x)
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		t := v_1.Type
		if ssa.AuxIntToInt8(v_1.AuxInt) != 0 || !(isNonNegative(x)) {
			break
		}
		v.Reset(ssaop.OpEq8)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
		v0.AuxInt = ssa.Int8ToAuxInt(0)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Leq8 x (Const8 <t> [-1]))
	// result: (Less8 x (Const8 <t> [0]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		t := v_1.Type
		if ssa.AuxIntToInt8(v_1.AuxInt) != -1 {
			break
		}
		v.Reset(ssaop.OpLess8)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
		v0.AuxInt = ssa.Int8ToAuxInt(0)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Leq8 (Const8 <t> [1]) x)
	// result: (Less8 (Const8 <t> [0]) x)
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		t := v_0.Type
		if ssa.AuxIntToInt8(v_0.AuxInt) != 1 {
			break
		}
		x := v_1
		v.Reset(ssaop.OpLess8)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
		v0.AuxInt = ssa.Int8ToAuxInt(0)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Leq8 (Const8 [math.MinInt8 ]) _)
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != math.MinInt8 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (Leq8 _ (Const8 [math.MaxInt8 ]))
	// result: (ConstBool [true])
	for {
		if v_1.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_1.AuxInt) != math.MaxInt8 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (Leq8 x c:(Const8 [math.MinInt8 ]))
	// result: (Eq8 x c)
	for {
		x := v_0
		c := v_1
		if c.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(c.AuxInt) != math.MinInt8 {
			break
		}
		v.Reset(ssaop.OpEq8)
		v.AddArg2(x, c)
		return true
	}
	// match: (Leq8 c:(Const8 [math.MaxInt8 ]) x)
	// result: (Eq8 x c)
	for {
		c := v_0
		if c.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(c.AuxInt) != math.MaxInt8 {
			break
		}
		x := v_1
		v.Reset(ssaop.OpEq8)
		v.AddArg2(x, c)
		return true
	}
	return false
}
func rewriteValue_OpLeq8U(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Leq8U (Const8 [c]) (Const8 [d]))
	// result: (ConstBool [ uint8(c) <= uint8(d)])
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		d := ssa.AuxIntToInt8(v_1.AuxInt)
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(uint8(c) <= uint8(d))
		return true
	}
	// match: (Leq8U (Const8 <t> [1]) x)
	// result: (Neq8 (Const8 <t> [0]) x)
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		t := v_0.Type
		if ssa.AuxIntToInt8(v_0.AuxInt) != 1 {
			break
		}
		x := v_1
		v.Reset(ssaop.OpNeq8)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
		v0.AuxInt = ssa.Int8ToAuxInt(0)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Leq8U (Const8 [0]) _)
	// result: (ConstBool [true])
	for {
		if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (Leq8U _ (Const8 [-1]))
	// result: (ConstBool [true])
	for {
		if v_1.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_1.AuxInt) != -1 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (Leq8U x c:(Const8 [0]))
	// result: (Eq8 x c)
	for {
		x := v_0
		c := v_1
		if c.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(c.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpEq8)
		v.AddArg2(x, c)
		return true
	}
	// match: (Leq8U c:(Const8 [-1]) x)
	// result: (Eq8 x c)
	for {
		c := v_0
		if c.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(c.AuxInt) != -1 {
			break
		}
		x := v_1
		v.Reset(ssaop.OpEq8)
		v.AddArg2(x, c)
		return true
	}
	return false
}
func rewriteValue_OpLess16(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Less16 (Const16 [c]) (Const16 [d]))
	// result: (ConstBool [c < d])
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		d := ssa.AuxIntToInt16(v_1.AuxInt)
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(c < d)
		return true
	}
	// match: (Less16 (Const16 <t> [0]) x)
	// cond: isNonNegative(x)
	// result: (Neq16 (Const16 <t> [0]) x)
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		t := v_0.Type
		if ssa.AuxIntToInt16(v_0.AuxInt) != 0 {
			break
		}
		x := v_1
		if !(isNonNegative(x)) {
			break
		}
		v.Reset(ssaop.OpNeq16)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
		v0.AuxInt = ssa.Int16ToAuxInt(0)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Less16 x (Const16 <t> [1]))
	// result: (Leq16 x (Const16 <t> [0]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		t := v_1.Type
		if ssa.AuxIntToInt16(v_1.AuxInt) != 1 {
			break
		}
		v.Reset(ssaop.OpLeq16)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
		v0.AuxInt = ssa.Int16ToAuxInt(0)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Less16 (Const16 <t> [-1]) x)
	// result: (Leq16 (Const16 <t> [0]) x)
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		t := v_0.Type
		if ssa.AuxIntToInt16(v_0.AuxInt) != -1 {
			break
		}
		x := v_1
		v.Reset(ssaop.OpLeq16)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
		v0.AuxInt = ssa.Int16ToAuxInt(0)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Less16 _ (Const16 [math.MinInt16]))
	// result: (ConstBool [false])
	for {
		if v_1.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_1.AuxInt) != math.MinInt16 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(false)
		return true
	}
	// match: (Less16 (Const16 [math.MaxInt16]) _)
	// result: (ConstBool [false])
	for {
		if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != math.MaxInt16 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(false)
		return true
	}
	// match: (Less16 x (Const16 <t> [math.MinInt16+1]))
	// result: (Eq16 x (Const16 <t> [math.MinInt16]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		t := v_1.Type
		if ssa.AuxIntToInt16(v_1.AuxInt) != math.MinInt16+1 {
			break
		}
		v.Reset(ssaop.OpEq16)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
		v0.AuxInt = ssa.Int16ToAuxInt(math.MinInt16)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Less16 (Const16 <t> [math.MaxInt16-1]) x)
	// result: (Eq16 x (Const16 <t> [math.MaxInt16]))
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		t := v_0.Type
		if ssa.AuxIntToInt16(v_0.AuxInt) != math.MaxInt16-1 {
			break
		}
		x := v_1
		v.Reset(ssaop.OpEq16)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
		v0.AuxInt = ssa.Int16ToAuxInt(math.MaxInt16)
		v.AddArg2(x, v0)
		return true
	}
	return false
}
func rewriteValue_OpLess16U(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Less16U (Const16 [c]) (Const16 [d]))
	// result: (ConstBool [uint16(c) < uint16(d)])
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		d := ssa.AuxIntToInt16(v_1.AuxInt)
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(uint16(c) < uint16(d))
		return true
	}
	// match: (Less16U (Const16 <t> [0]) x)
	// result: (Neq16 (Const16 <t> [0]) x)
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		t := v_0.Type
		if ssa.AuxIntToInt16(v_0.AuxInt) != 0 {
			break
		}
		x := v_1
		v.Reset(ssaop.OpNeq16)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
		v0.AuxInt = ssa.Int16ToAuxInt(0)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Less16U x (Const16 <t> [1]))
	// result: (Eq16 (Const16 <t> [0]) x)
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		t := v_1.Type
		if ssa.AuxIntToInt16(v_1.AuxInt) != 1 {
			break
		}
		v.Reset(ssaop.OpEq16)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
		v0.AuxInt = ssa.Int16ToAuxInt(0)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Less16U _ (Const16 [0]))
	// result: (ConstBool [false])
	for {
		if v_1.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_1.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(false)
		return true
	}
	// match: (Less16U (Const16 [-1]) _)
	// result: (ConstBool [false])
	for {
		if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != -1 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(false)
		return true
	}
	// match: (Less16U x (Const16 <t> [1]))
	// result: (Eq16 x (Const16 <t> [0]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		t := v_1.Type
		if ssa.AuxIntToInt16(v_1.AuxInt) != 1 {
			break
		}
		v.Reset(ssaop.OpEq16)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
		v0.AuxInt = ssa.Int16ToAuxInt(0)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Less16U (Const16 <t> [-2]) x)
	// result: (Eq16 x (Const16 <t> [-1]))
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		t := v_0.Type
		if ssa.AuxIntToInt16(v_0.AuxInt) != -2 {
			break
		}
		x := v_1
		v.Reset(ssaop.OpEq16)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
		v0.AuxInt = ssa.Int16ToAuxInt(-1)
		v.AddArg2(x, v0)
		return true
	}
	return false
}
func rewriteValue_OpLess32(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Less32 (Const32 [c]) (Const32 [d]))
	// result: (ConstBool [c < d])
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		d := ssa.AuxIntToInt32(v_1.AuxInt)
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(c < d)
		return true
	}
	// match: (Less32 (Const32 <t> [0]) x)
	// cond: isNonNegative(x)
	// result: (Neq32 (Const32 <t> [0]) x)
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		t := v_0.Type
		if ssa.AuxIntToInt32(v_0.AuxInt) != 0 {
			break
		}
		x := v_1
		if !(isNonNegative(x)) {
			break
		}
		v.Reset(ssaop.OpNeq32)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
		v0.AuxInt = ssa.Int32ToAuxInt(0)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Less32 x (Const32 <t> [1]))
	// result: (Leq32 x (Const32 <t> [0]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		t := v_1.Type
		if ssa.AuxIntToInt32(v_1.AuxInt) != 1 {
			break
		}
		v.Reset(ssaop.OpLeq32)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
		v0.AuxInt = ssa.Int32ToAuxInt(0)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Less32 (Const32 <t> [-1]) x)
	// result: (Leq32 (Const32 <t> [0]) x)
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		t := v_0.Type
		if ssa.AuxIntToInt32(v_0.AuxInt) != -1 {
			break
		}
		x := v_1
		v.Reset(ssaop.OpLeq32)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
		v0.AuxInt = ssa.Int32ToAuxInt(0)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Less32 _ (Const32 [math.MinInt32]))
	// result: (ConstBool [false])
	for {
		if v_1.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1.AuxInt) != math.MinInt32 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(false)
		return true
	}
	// match: (Less32 (Const32 [math.MaxInt32]) _)
	// result: (ConstBool [false])
	for {
		if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != math.MaxInt32 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(false)
		return true
	}
	// match: (Less32 x (Const32 <t> [math.MinInt32+1]))
	// result: (Eq32 x (Const32 <t> [math.MinInt32]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		t := v_1.Type
		if ssa.AuxIntToInt32(v_1.AuxInt) != math.MinInt32+1 {
			break
		}
		v.Reset(ssaop.OpEq32)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
		v0.AuxInt = ssa.Int32ToAuxInt(math.MinInt32)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Less32 (Const32 <t> [math.MaxInt32-1]) x)
	// result: (Eq32 x (Const32 <t> [math.MaxInt32]))
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		t := v_0.Type
		if ssa.AuxIntToInt32(v_0.AuxInt) != math.MaxInt32-1 {
			break
		}
		x := v_1
		v.Reset(ssaop.OpEq32)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
		v0.AuxInt = ssa.Int32ToAuxInt(math.MaxInt32)
		v.AddArg2(x, v0)
		return true
	}
	return false
}
func rewriteValue_OpLess32F(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	// match: (Less32F (Const32F [c]) (Const32F [d]))
	// result: (ConstBool [c < d])
	for {
		if v_0.Op != ssaop.OpConst32F {
			break
		}
		c := ssa.AuxIntToFloat32(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst32F {
			break
		}
		d := ssa.AuxIntToFloat32(v_1.AuxInt)
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(c < d)
		return true
	}
	return false
}
func rewriteValue_OpLess32U(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Less32U (Const32 [c]) (Const32 [d]))
	// result: (ConstBool [uint32(c) < uint32(d)])
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		d := ssa.AuxIntToInt32(v_1.AuxInt)
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(uint32(c) < uint32(d))
		return true
	}
	// match: (Less32U (Const32 <t> [0]) x)
	// result: (Neq32 (Const32 <t> [0]) x)
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		t := v_0.Type
		if ssa.AuxIntToInt32(v_0.AuxInt) != 0 {
			break
		}
		x := v_1
		v.Reset(ssaop.OpNeq32)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
		v0.AuxInt = ssa.Int32ToAuxInt(0)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Less32U x (Const32 <t> [1]))
	// result: (Eq32 (Const32 <t> [0]) x)
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		t := v_1.Type
		if ssa.AuxIntToInt32(v_1.AuxInt) != 1 {
			break
		}
		v.Reset(ssaop.OpEq32)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
		v0.AuxInt = ssa.Int32ToAuxInt(0)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Less32U _ (Const32 [0]))
	// result: (ConstBool [false])
	for {
		if v_1.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(false)
		return true
	}
	// match: (Less32U (Const32 [-1]) _)
	// result: (ConstBool [false])
	for {
		if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != -1 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(false)
		return true
	}
	// match: (Less32U x (Const32 <t> [1]))
	// result: (Eq32 x (Const32 <t> [0]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		t := v_1.Type
		if ssa.AuxIntToInt32(v_1.AuxInt) != 1 {
			break
		}
		v.Reset(ssaop.OpEq32)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
		v0.AuxInt = ssa.Int32ToAuxInt(0)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Less32U (Const32 <t> [-2]) x)
	// result: (Eq32 x (Const32 <t> [-1]))
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		t := v_0.Type
		if ssa.AuxIntToInt32(v_0.AuxInt) != -2 {
			break
		}
		x := v_1
		v.Reset(ssaop.OpEq32)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
		v0.AuxInt = ssa.Int32ToAuxInt(-1)
		v.AddArg2(x, v0)
		return true
	}
	return false
}
func rewriteValue_OpLess64(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Less64 (Const64 [c]) (Const64 [d]))
	// result: (ConstBool [c < d])
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(c < d)
		return true
	}
	// match: (Less64 (Const64 <t> [0]) x)
	// cond: isNonNegative(x)
	// result: (Neq64 (Const64 <t> [0]) x)
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		t := v_0.Type
		if ssa.AuxIntToInt64(v_0.AuxInt) != 0 {
			break
		}
		x := v_1
		if !(isNonNegative(x)) {
			break
		}
		v.Reset(ssaop.OpNeq64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(0)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Less64 x (Const64 <t> [1]))
	// result: (Leq64 x (Const64 <t> [0]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		t := v_1.Type
		if ssa.AuxIntToInt64(v_1.AuxInt) != 1 {
			break
		}
		v.Reset(ssaop.OpLeq64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(0)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Less64 (Const64 <t> [-1]) x)
	// result: (Leq64 (Const64 <t> [0]) x)
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		t := v_0.Type
		if ssa.AuxIntToInt64(v_0.AuxInt) != -1 {
			break
		}
		x := v_1
		v.Reset(ssaop.OpLeq64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(0)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Less64 _ (Const64 [math.MinInt64]))
	// result: (ConstBool [false])
	for {
		if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != math.MinInt64 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(false)
		return true
	}
	// match: (Less64 (Const64 [math.MaxInt64]) _)
	// result: (ConstBool [false])
	for {
		if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != math.MaxInt64 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(false)
		return true
	}
	// match: (Less64 x (Const64 <t> [math.MinInt64+1]))
	// result: (Eq64 x (Const64 <t> [math.MinInt64]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		t := v_1.Type
		if ssa.AuxIntToInt64(v_1.AuxInt) != math.MinInt64+1 {
			break
		}
		v.Reset(ssaop.OpEq64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(math.MinInt64)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Less64 (Const64 <t> [math.MaxInt64-1]) x)
	// result: (Eq64 x (Const64 <t> [math.MaxInt64]))
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		t := v_0.Type
		if ssa.AuxIntToInt64(v_0.AuxInt) != math.MaxInt64-1 {
			break
		}
		x := v_1
		v.Reset(ssaop.OpEq64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(math.MaxInt64)
		v.AddArg2(x, v0)
		return true
	}
	return false
}
func rewriteValue_OpLess64F(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	// match: (Less64F (Const64F [c]) (Const64F [d]))
	// result: (ConstBool [c < d])
	for {
		if v_0.Op != ssaop.OpConst64F {
			break
		}
		c := ssa.AuxIntToFloat64(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst64F {
			break
		}
		d := ssa.AuxIntToFloat64(v_1.AuxInt)
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(c < d)
		return true
	}
	return false
}
func rewriteValue_OpLess64U(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Less64U (Const64 [c]) (Const64 [d]))
	// result: (ConstBool [uint64(c) < uint64(d)])
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(uint64(c) < uint64(d))
		return true
	}
	// match: (Less64U (Const64 <t> [0]) x)
	// result: (Neq64 (Const64 <t> [0]) x)
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		t := v_0.Type
		if ssa.AuxIntToInt64(v_0.AuxInt) != 0 {
			break
		}
		x := v_1
		v.Reset(ssaop.OpNeq64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(0)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Less64U x (Const64 <t> [1]))
	// result: (Eq64 (Const64 <t> [0]) x)
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		t := v_1.Type
		if ssa.AuxIntToInt64(v_1.AuxInt) != 1 {
			break
		}
		v.Reset(ssaop.OpEq64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(0)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Less64U _ (Const64 [0]))
	// result: (ConstBool [false])
	for {
		if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(false)
		return true
	}
	// match: (Less64U (Const64 [-1]) _)
	// result: (ConstBool [false])
	for {
		if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != -1 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(false)
		return true
	}
	// match: (Less64U x (Const64 <t> [1]))
	// result: (Eq64 x (Const64 <t> [0]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		t := v_1.Type
		if ssa.AuxIntToInt64(v_1.AuxInt) != 1 {
			break
		}
		v.Reset(ssaop.OpEq64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(0)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Less64U (Const64 <t> [-2]) x)
	// result: (Eq64 x (Const64 <t> [-1]))
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		t := v_0.Type
		if ssa.AuxIntToInt64(v_0.AuxInt) != -2 {
			break
		}
		x := v_1
		v.Reset(ssaop.OpEq64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(-1)
		v.AddArg2(x, v0)
		return true
	}
	return false
}
func rewriteValue_OpLess8(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Less8 (Const8 [c]) (Const8 [d]))
	// result: (ConstBool [c < d])
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		d := ssa.AuxIntToInt8(v_1.AuxInt)
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(c < d)
		return true
	}
	// match: (Less8 (Const8 <t> [0]) x)
	// cond: isNonNegative(x)
	// result: (Neq8 (Const8 <t> [0]) x)
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		t := v_0.Type
		if ssa.AuxIntToInt8(v_0.AuxInt) != 0 {
			break
		}
		x := v_1
		if !(isNonNegative(x)) {
			break
		}
		v.Reset(ssaop.OpNeq8)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
		v0.AuxInt = ssa.Int8ToAuxInt(0)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Less8 x (Const8 <t> [1]))
	// result: (Leq8 x (Const8 <t> [0]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		t := v_1.Type
		if ssa.AuxIntToInt8(v_1.AuxInt) != 1 {
			break
		}
		v.Reset(ssaop.OpLeq8)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
		v0.AuxInt = ssa.Int8ToAuxInt(0)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Less8 (Const8 <t> [-1]) x)
	// result: (Leq8 (Const8 <t> [0]) x)
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		t := v_0.Type
		if ssa.AuxIntToInt8(v_0.AuxInt) != -1 {
			break
		}
		x := v_1
		v.Reset(ssaop.OpLeq8)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
		v0.AuxInt = ssa.Int8ToAuxInt(0)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Less8 _ (Const8 [math.MinInt8 ]))
	// result: (ConstBool [false])
	for {
		if v_1.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_1.AuxInt) != math.MinInt8 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(false)
		return true
	}
	// match: (Less8 (Const8 [math.MaxInt8 ]) _)
	// result: (ConstBool [false])
	for {
		if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != math.MaxInt8 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(false)
		return true
	}
	// match: (Less8 x (Const8 <t> [math.MinInt8 +1]))
	// result: (Eq8 x (Const8 <t> [math.MinInt8 ]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		t := v_1.Type
		if ssa.AuxIntToInt8(v_1.AuxInt) != math.MinInt8+1 {
			break
		}
		v.Reset(ssaop.OpEq8)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
		v0.AuxInt = ssa.Int8ToAuxInt(math.MinInt8)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Less8 (Const8 <t> [math.MaxInt8 -1]) x)
	// result: (Eq8 x (Const8 <t> [math.MaxInt8 ]))
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		t := v_0.Type
		if ssa.AuxIntToInt8(v_0.AuxInt) != math.MaxInt8-1 {
			break
		}
		x := v_1
		v.Reset(ssaop.OpEq8)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
		v0.AuxInt = ssa.Int8ToAuxInt(math.MaxInt8)
		v.AddArg2(x, v0)
		return true
	}
	return false
}
func rewriteValue_OpLess8U(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Less8U (Const8 [c]) (Const8 [d]))
	// result: (ConstBool [ uint8(c) < uint8(d)])
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		d := ssa.AuxIntToInt8(v_1.AuxInt)
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(uint8(c) < uint8(d))
		return true
	}
	// match: (Less8U (Const8 <t> [0]) x)
	// result: (Neq8 (Const8 <t> [0]) x)
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		t := v_0.Type
		if ssa.AuxIntToInt8(v_0.AuxInt) != 0 {
			break
		}
		x := v_1
		v.Reset(ssaop.OpNeq8)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
		v0.AuxInt = ssa.Int8ToAuxInt(0)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Less8U x (Const8 <t> [1]))
	// result: (Eq8 (Const8 <t> [0]) x)
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		t := v_1.Type
		if ssa.AuxIntToInt8(v_1.AuxInt) != 1 {
			break
		}
		v.Reset(ssaop.OpEq8)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
		v0.AuxInt = ssa.Int8ToAuxInt(0)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Less8U _ (Const8 [0]))
	// result: (ConstBool [false])
	for {
		if v_1.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_1.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(false)
		return true
	}
	// match: (Less8U (Const8 [-1]) _)
	// result: (ConstBool [false])
	for {
		if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != -1 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(false)
		return true
	}
	// match: (Less8U x (Const8 <t> [1]))
	// result: (Eq8 x (Const8 <t> [0]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		t := v_1.Type
		if ssa.AuxIntToInt8(v_1.AuxInt) != 1 {
			break
		}
		v.Reset(ssaop.OpEq8)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
		v0.AuxInt = ssa.Int8ToAuxInt(0)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Less8U (Const8 <t> [-2]) x)
	// result: (Eq8 x (Const8 <t> [-1]))
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		t := v_0.Type
		if ssa.AuxIntToInt8(v_0.AuxInt) != -2 {
			break
		}
		x := v_1
		v.Reset(ssaop.OpEq8)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
		v0.AuxInt = ssa.Int8ToAuxInt(-1)
		v.AddArg2(x, v0)
		return true
	}
	return false
}
func rewriteValue_OpLoad(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	typ := &b.Func.Config.Types
	// match: (Load <t1> p1 (Store {t2} p2 x _))
	// cond: ssa.IsSamePtr(p1, p2) && copyCompatibleType(t1, x.Type) && t1.Size() == t2.Size()
	// result: x
	for {
		t1 := v.Type
		p1 := v_0
		if v_1.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(v_1.Aux)
		x := v_1.Args[1]
		p2 := v_1.Args[0]
		if !(ssa.IsSamePtr(p1, p2) && copyCompatibleType(t1, x.Type) && t1.Size() == t2.Size()) {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (Load <t1> p1 (Store {t2} p2 _ (Store {t3} p3 x _)))
	// cond: ssa.IsSamePtr(p1, p3) && copyCompatibleType(t1, x.Type) && t1.Size() == t3.Size() && ssa.Disjoint(p3, t3, p2, t2)
	// result: x
	for {
		t1 := v.Type
		p1 := v_0
		if v_1.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(v_1.Aux)
		_ = v_1.Args[2]
		p2 := v_1.Args[0]
		v_1_2 := v_1.Args[2]
		if v_1_2.Op != ssaop.OpStore {
			break
		}
		t3 := ssa.AuxToType(v_1_2.Aux)
		x := v_1_2.Args[1]
		p3 := v_1_2.Args[0]
		if !(ssa.IsSamePtr(p1, p3) && copyCompatibleType(t1, x.Type) && t1.Size() == t3.Size() && ssa.Disjoint(p3, t3, p2, t2)) {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (Load <t1> p1 (Store {t2} p2 _ (Store {t3} p3 _ (Store {t4} p4 x _))))
	// cond: ssa.IsSamePtr(p1, p4) && copyCompatibleType(t1, x.Type) && t1.Size() == t4.Size() && ssa.Disjoint(p4, t4, p2, t2) && ssa.Disjoint(p4, t4, p3, t3)
	// result: x
	for {
		t1 := v.Type
		p1 := v_0
		if v_1.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(v_1.Aux)
		_ = v_1.Args[2]
		p2 := v_1.Args[0]
		v_1_2 := v_1.Args[2]
		if v_1_2.Op != ssaop.OpStore {
			break
		}
		t3 := ssa.AuxToType(v_1_2.Aux)
		_ = v_1_2.Args[2]
		p3 := v_1_2.Args[0]
		v_1_2_2 := v_1_2.Args[2]
		if v_1_2_2.Op != ssaop.OpStore {
			break
		}
		t4 := ssa.AuxToType(v_1_2_2.Aux)
		x := v_1_2_2.Args[1]
		p4 := v_1_2_2.Args[0]
		if !(ssa.IsSamePtr(p1, p4) && copyCompatibleType(t1, x.Type) && t1.Size() == t4.Size() && ssa.Disjoint(p4, t4, p2, t2) && ssa.Disjoint(p4, t4, p3, t3)) {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (Load <t1> p1 (Store {t2} p2 _ (Store {t3} p3 _ (Store {t4} p4 _ (Store {t5} p5 x _)))))
	// cond: ssa.IsSamePtr(p1, p5) && copyCompatibleType(t1, x.Type) && t1.Size() == t5.Size() && ssa.Disjoint(p5, t5, p2, t2) && ssa.Disjoint(p5, t5, p3, t3) && ssa.Disjoint(p5, t5, p4, t4)
	// result: x
	for {
		t1 := v.Type
		p1 := v_0
		if v_1.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(v_1.Aux)
		_ = v_1.Args[2]
		p2 := v_1.Args[0]
		v_1_2 := v_1.Args[2]
		if v_1_2.Op != ssaop.OpStore {
			break
		}
		t3 := ssa.AuxToType(v_1_2.Aux)
		_ = v_1_2.Args[2]
		p3 := v_1_2.Args[0]
		v_1_2_2 := v_1_2.Args[2]
		if v_1_2_2.Op != ssaop.OpStore {
			break
		}
		t4 := ssa.AuxToType(v_1_2_2.Aux)
		_ = v_1_2_2.Args[2]
		p4 := v_1_2_2.Args[0]
		v_1_2_2_2 := v_1_2_2.Args[2]
		if v_1_2_2_2.Op != ssaop.OpStore {
			break
		}
		t5 := ssa.AuxToType(v_1_2_2_2.Aux)
		x := v_1_2_2_2.Args[1]
		p5 := v_1_2_2_2.Args[0]
		if !(ssa.IsSamePtr(p1, p5) && copyCompatibleType(t1, x.Type) && t1.Size() == t5.Size() && ssa.Disjoint(p5, t5, p2, t2) && ssa.Disjoint(p5, t5, p3, t3) && ssa.Disjoint(p5, t5, p4, t4)) {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (Load <t1> op1:(OffPtr [o1] p1) move:(Move [n] p2 src mem))
	// cond: o1 >= 0 && o1+t1.Size() <= n && ssa.IsSamePtr(p1, p2) && !ssa.IsVolatile(src)
	// result: @move.Block (Load <t1> (OffPtr <op1.Type> [o1] src) mem)
	for {
		t1 := v.Type
		op1 := v_0
		if op1.Op != ssaop.OpOffPtr {
			break
		}
		o1 := ssa.AuxIntToInt64(op1.AuxInt)
		p1 := op1.Args[0]
		move := v_1
		if move.Op != ssaop.OpMove {
			break
		}
		n := ssa.AuxIntToInt64(move.AuxInt)
		mem := move.Args[2]
		p2 := move.Args[0]
		src := move.Args[1]
		if !(o1 >= 0 && o1+t1.Size() <= n && ssa.IsSamePtr(p1, p2) && !ssa.IsVolatile(src)) {
			break
		}
		b = move.Block
		v0 := b.NewValue0(v.Pos, ssaop.OpLoad, t1)
		v.CopyOf(v0)
		v1 := b.NewValue0(v.Pos, ssaop.OpOffPtr, op1.Type)
		v1.AuxInt = ssa.Int64ToAuxInt(o1)
		v1.AddArg(src)
		v0.AddArg2(v1, mem)
		return true
	}
	// match: (Load <t1> p1 (Store {t2} p2 (Const64 [x]) _))
	// cond: ssa.IsSamePtr(p1,p2) && t2.Size() == 8 && ssa.Is64BitFloat(t1) && !math.IsNaN(math.Float64frombits(uint64(x)))
	// result: (Const64F [math.Float64frombits(uint64(x))])
	for {
		t1 := v.Type
		p1 := v_0
		if v_1.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(v_1.Aux)
		_ = v_1.Args[1]
		p2 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		if v_1_1.Op != ssaop.OpConst64 {
			break
		}
		x := ssa.AuxIntToInt64(v_1_1.AuxInt)
		if !(ssa.IsSamePtr(p1, p2) && t2.Size() == 8 && ssa.Is64BitFloat(t1) && !math.IsNaN(math.Float64frombits(uint64(x)))) {
			break
		}
		v.Reset(ssaop.OpConst64F)
		v.AuxInt = ssa.Float64ToAuxInt(math.Float64frombits(uint64(x)))
		return true
	}
	// match: (Load <t1> p1 (Store {t2} p2 (Const32 [x]) _))
	// cond: ssa.IsSamePtr(p1,p2) && t2.Size() == 4 && ssa.Is32BitFloat(t1) && !math.IsNaN(float64(math.Float32frombits(uint32(x))))
	// result: (Const32F [math.Float32frombits(uint32(x))])
	for {
		t1 := v.Type
		p1 := v_0
		if v_1.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(v_1.Aux)
		_ = v_1.Args[1]
		p2 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		if v_1_1.Op != ssaop.OpConst32 {
			break
		}
		x := ssa.AuxIntToInt32(v_1_1.AuxInt)
		if !(ssa.IsSamePtr(p1, p2) && t2.Size() == 4 && ssa.Is32BitFloat(t1) && !math.IsNaN(float64(math.Float32frombits(uint32(x))))) {
			break
		}
		v.Reset(ssaop.OpConst32F)
		v.AuxInt = ssa.Float32ToAuxInt(math.Float32frombits(uint32(x)))
		return true
	}
	// match: (Load <t1> p1 (Store {t2} p2 (Const64F [x]) _))
	// cond: ssa.IsSamePtr(p1,p2) && t2.Size() == 8 && ssa.Is64BitInt(t1)
	// result: (Const64 [int64(math.Float64bits(x))])
	for {
		t1 := v.Type
		p1 := v_0
		if v_1.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(v_1.Aux)
		_ = v_1.Args[1]
		p2 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		if v_1_1.Op != ssaop.OpConst64F {
			break
		}
		x := ssa.AuxIntToFloat64(v_1_1.AuxInt)
		if !(ssa.IsSamePtr(p1, p2) && t2.Size() == 8 && ssa.Is64BitInt(t1)) {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(int64(math.Float64bits(x)))
		return true
	}
	// match: (Load <t1> p1 (Store {t2} p2 (Const32F [x]) _))
	// cond: ssa.IsSamePtr(p1,p2) && t2.Size() == 4 && ssa.Is32BitInt(t1)
	// result: (Const32 [int32(math.Float32bits(x))])
	for {
		t1 := v.Type
		p1 := v_0
		if v_1.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(v_1.Aux)
		_ = v_1.Args[1]
		p2 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		if v_1_1.Op != ssaop.OpConst32F {
			break
		}
		x := ssa.AuxIntToFloat32(v_1_1.AuxInt)
		if !(ssa.IsSamePtr(p1, p2) && t2.Size() == 4 && ssa.Is32BitInt(t1)) {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(int32(math.Float32bits(x)))
		return true
	}
	// match: (Load <t1> op1:(OffPtr [o1] p1) (Store {t2} p2 _ mem:(Zero [n] p3 _)))
	// cond: o1 >= 0 && o1+t1.Size() <= n && ssa.IsSamePtr(p1, p3) && ssa.CanSSA(t1) && ssa.Disjoint(op1, t1, p2, t2)
	// result: @mem.Block (Load <t1> (OffPtr <op1.Type> [o1] p3) mem)
	for {
		t1 := v.Type
		op1 := v_0
		if op1.Op != ssaop.OpOffPtr {
			break
		}
		o1 := ssa.AuxIntToInt64(op1.AuxInt)
		p1 := op1.Args[0]
		if v_1.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(v_1.Aux)
		_ = v_1.Args[2]
		p2 := v_1.Args[0]
		mem := v_1.Args[2]
		if mem.Op != ssaop.OpZero {
			break
		}
		n := ssa.AuxIntToInt64(mem.AuxInt)
		p3 := mem.Args[0]
		if !(o1 >= 0 && o1+t1.Size() <= n && ssa.IsSamePtr(p1, p3) && ssa.CanSSA(t1) && ssa.Disjoint(op1, t1, p2, t2)) {
			break
		}
		b = mem.Block
		v0 := b.NewValue0(v.Pos, ssaop.OpLoad, t1)
		v.CopyOf(v0)
		v1 := b.NewValue0(v.Pos, ssaop.OpOffPtr, op1.Type)
		v1.AuxInt = ssa.Int64ToAuxInt(o1)
		v1.AddArg(p3)
		v0.AddArg2(v1, mem)
		return true
	}
	// match: (Load <t1> op1:(OffPtr [o1] p1) (Store {t2} p2 _ (Store {t3} p3 _ mem:(Zero [n] p4 _))))
	// cond: o1 >= 0 && o1+t1.Size() <= n && ssa.IsSamePtr(p1, p4) && ssa.CanSSA(t1) && ssa.Disjoint(op1, t1, p2, t2) && ssa.Disjoint(op1, t1, p3, t3)
	// result: @mem.Block (Load <t1> (OffPtr <op1.Type> [o1] p4) mem)
	for {
		t1 := v.Type
		op1 := v_0
		if op1.Op != ssaop.OpOffPtr {
			break
		}
		o1 := ssa.AuxIntToInt64(op1.AuxInt)
		p1 := op1.Args[0]
		if v_1.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(v_1.Aux)
		_ = v_1.Args[2]
		p2 := v_1.Args[0]
		v_1_2 := v_1.Args[2]
		if v_1_2.Op != ssaop.OpStore {
			break
		}
		t3 := ssa.AuxToType(v_1_2.Aux)
		_ = v_1_2.Args[2]
		p3 := v_1_2.Args[0]
		mem := v_1_2.Args[2]
		if mem.Op != ssaop.OpZero {
			break
		}
		n := ssa.AuxIntToInt64(mem.AuxInt)
		p4 := mem.Args[0]
		if !(o1 >= 0 && o1+t1.Size() <= n && ssa.IsSamePtr(p1, p4) && ssa.CanSSA(t1) && ssa.Disjoint(op1, t1, p2, t2) && ssa.Disjoint(op1, t1, p3, t3)) {
			break
		}
		b = mem.Block
		v0 := b.NewValue0(v.Pos, ssaop.OpLoad, t1)
		v.CopyOf(v0)
		v1 := b.NewValue0(v.Pos, ssaop.OpOffPtr, op1.Type)
		v1.AuxInt = ssa.Int64ToAuxInt(o1)
		v1.AddArg(p4)
		v0.AddArg2(v1, mem)
		return true
	}
	// match: (Load <t1> op1:(OffPtr [o1] p1) (Store {t2} p2 _ (Store {t3} p3 _ (Store {t4} p4 _ mem:(Zero [n] p5 _)))))
	// cond: o1 >= 0 && o1+t1.Size() <= n && ssa.IsSamePtr(p1, p5) && ssa.CanSSA(t1) && ssa.Disjoint(op1, t1, p2, t2) && ssa.Disjoint(op1, t1, p3, t3) && ssa.Disjoint(op1, t1, p4, t4)
	// result: @mem.Block (Load <t1> (OffPtr <op1.Type> [o1] p5) mem)
	for {
		t1 := v.Type
		op1 := v_0
		if op1.Op != ssaop.OpOffPtr {
			break
		}
		o1 := ssa.AuxIntToInt64(op1.AuxInt)
		p1 := op1.Args[0]
		if v_1.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(v_1.Aux)
		_ = v_1.Args[2]
		p2 := v_1.Args[0]
		v_1_2 := v_1.Args[2]
		if v_1_2.Op != ssaop.OpStore {
			break
		}
		t3 := ssa.AuxToType(v_1_2.Aux)
		_ = v_1_2.Args[2]
		p3 := v_1_2.Args[0]
		v_1_2_2 := v_1_2.Args[2]
		if v_1_2_2.Op != ssaop.OpStore {
			break
		}
		t4 := ssa.AuxToType(v_1_2_2.Aux)
		_ = v_1_2_2.Args[2]
		p4 := v_1_2_2.Args[0]
		mem := v_1_2_2.Args[2]
		if mem.Op != ssaop.OpZero {
			break
		}
		n := ssa.AuxIntToInt64(mem.AuxInt)
		p5 := mem.Args[0]
		if !(o1 >= 0 && o1+t1.Size() <= n && ssa.IsSamePtr(p1, p5) && ssa.CanSSA(t1) && ssa.Disjoint(op1, t1, p2, t2) && ssa.Disjoint(op1, t1, p3, t3) && ssa.Disjoint(op1, t1, p4, t4)) {
			break
		}
		b = mem.Block
		v0 := b.NewValue0(v.Pos, ssaop.OpLoad, t1)
		v.CopyOf(v0)
		v1 := b.NewValue0(v.Pos, ssaop.OpOffPtr, op1.Type)
		v1.AuxInt = ssa.Int64ToAuxInt(o1)
		v1.AddArg(p5)
		v0.AddArg2(v1, mem)
		return true
	}
	// match: (Load <t1> op1:(OffPtr [o1] p1) (Store {t2} p2 _ (Store {t3} p3 _ (Store {t4} p4 _ (Store {t5} p5 _ mem:(Zero [n] p6 _))))))
	// cond: o1 >= 0 && o1+t1.Size() <= n && ssa.IsSamePtr(p1, p6) && ssa.CanSSA(t1) && ssa.Disjoint(op1, t1, p2, t2) && ssa.Disjoint(op1, t1, p3, t3) && ssa.Disjoint(op1, t1, p4, t4) && ssa.Disjoint(op1, t1, p5, t5)
	// result: @mem.Block (Load <t1> (OffPtr <op1.Type> [o1] p6) mem)
	for {
		t1 := v.Type
		op1 := v_0
		if op1.Op != ssaop.OpOffPtr {
			break
		}
		o1 := ssa.AuxIntToInt64(op1.AuxInt)
		p1 := op1.Args[0]
		if v_1.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(v_1.Aux)
		_ = v_1.Args[2]
		p2 := v_1.Args[0]
		v_1_2 := v_1.Args[2]
		if v_1_2.Op != ssaop.OpStore {
			break
		}
		t3 := ssa.AuxToType(v_1_2.Aux)
		_ = v_1_2.Args[2]
		p3 := v_1_2.Args[0]
		v_1_2_2 := v_1_2.Args[2]
		if v_1_2_2.Op != ssaop.OpStore {
			break
		}
		t4 := ssa.AuxToType(v_1_2_2.Aux)
		_ = v_1_2_2.Args[2]
		p4 := v_1_2_2.Args[0]
		v_1_2_2_2 := v_1_2_2.Args[2]
		if v_1_2_2_2.Op != ssaop.OpStore {
			break
		}
		t5 := ssa.AuxToType(v_1_2_2_2.Aux)
		_ = v_1_2_2_2.Args[2]
		p5 := v_1_2_2_2.Args[0]
		mem := v_1_2_2_2.Args[2]
		if mem.Op != ssaop.OpZero {
			break
		}
		n := ssa.AuxIntToInt64(mem.AuxInt)
		p6 := mem.Args[0]
		if !(o1 >= 0 && o1+t1.Size() <= n && ssa.IsSamePtr(p1, p6) && ssa.CanSSA(t1) && ssa.Disjoint(op1, t1, p2, t2) && ssa.Disjoint(op1, t1, p3, t3) && ssa.Disjoint(op1, t1, p4, t4) && ssa.Disjoint(op1, t1, p5, t5)) {
			break
		}
		b = mem.Block
		v0 := b.NewValue0(v.Pos, ssaop.OpLoad, t1)
		v.CopyOf(v0)
		v1 := b.NewValue0(v.Pos, ssaop.OpOffPtr, op1.Type)
		v1.AuxInt = ssa.Int64ToAuxInt(o1)
		v1.AddArg(p6)
		v0.AddArg2(v1, mem)
		return true
	}
	// match: (Load <t1> (OffPtr [o] p1) (Zero [n] p2 _))
	// cond: t1.IsBoolean() && ssa.IsSamePtr(p1, p2) && n >= o + 1
	// result: (ConstBool [false])
	for {
		t1 := v.Type
		if v_0.Op != ssaop.OpOffPtr {
			break
		}
		o := ssa.AuxIntToInt64(v_0.AuxInt)
		p1 := v_0.Args[0]
		if v_1.Op != ssaop.OpZero {
			break
		}
		n := ssa.AuxIntToInt64(v_1.AuxInt)
		p2 := v_1.Args[0]
		if !(t1.IsBoolean() && ssa.IsSamePtr(p1, p2) && n >= o+1) {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(false)
		return true
	}
	// match: (Load <t1> (OffPtr [o] p1) (Zero [n] p2 _))
	// cond: ssa.Is8BitInt(t1) && ssa.IsSamePtr(p1, p2) && n >= o + 1
	// result: (Const8 [0])
	for {
		t1 := v.Type
		if v_0.Op != ssaop.OpOffPtr {
			break
		}
		o := ssa.AuxIntToInt64(v_0.AuxInt)
		p1 := v_0.Args[0]
		if v_1.Op != ssaop.OpZero {
			break
		}
		n := ssa.AuxIntToInt64(v_1.AuxInt)
		p2 := v_1.Args[0]
		if !(ssa.Is8BitInt(t1) && ssa.IsSamePtr(p1, p2) && n >= o+1) {
			break
		}
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(0)
		return true
	}
	// match: (Load <t1> (OffPtr [o] p1) (Zero [n] p2 _))
	// cond: ssa.Is16BitInt(t1) && ssa.IsSamePtr(p1, p2) && n >= o + 2
	// result: (Const16 [0])
	for {
		t1 := v.Type
		if v_0.Op != ssaop.OpOffPtr {
			break
		}
		o := ssa.AuxIntToInt64(v_0.AuxInt)
		p1 := v_0.Args[0]
		if v_1.Op != ssaop.OpZero {
			break
		}
		n := ssa.AuxIntToInt64(v_1.AuxInt)
		p2 := v_1.Args[0]
		if !(ssa.Is16BitInt(t1) && ssa.IsSamePtr(p1, p2) && n >= o+2) {
			break
		}
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(0)
		return true
	}
	// match: (Load <t1> (OffPtr [o] p1) (Zero [n] p2 _))
	// cond: ssa.Is32BitInt(t1) && ssa.IsSamePtr(p1, p2) && n >= o + 4
	// result: (Const32 [0])
	for {
		t1 := v.Type
		if v_0.Op != ssaop.OpOffPtr {
			break
		}
		o := ssa.AuxIntToInt64(v_0.AuxInt)
		p1 := v_0.Args[0]
		if v_1.Op != ssaop.OpZero {
			break
		}
		n := ssa.AuxIntToInt64(v_1.AuxInt)
		p2 := v_1.Args[0]
		if !(ssa.Is32BitInt(t1) && ssa.IsSamePtr(p1, p2) && n >= o+4) {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(0)
		return true
	}
	// match: (Load <t1> (OffPtr [o] p1) (Zero [n] p2 _))
	// cond: ssa.Is64BitInt(t1) && ssa.IsSamePtr(p1, p2) && n >= o + 8
	// result: (Const64 [0])
	for {
		t1 := v.Type
		if v_0.Op != ssaop.OpOffPtr {
			break
		}
		o := ssa.AuxIntToInt64(v_0.AuxInt)
		p1 := v_0.Args[0]
		if v_1.Op != ssaop.OpZero {
			break
		}
		n := ssa.AuxIntToInt64(v_1.AuxInt)
		p2 := v_1.Args[0]
		if !(ssa.Is64BitInt(t1) && ssa.IsSamePtr(p1, p2) && n >= o+8) {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(0)
		return true
	}
	// match: (Load <t1> (OffPtr [o] p1) (Zero [n] p2 _))
	// cond: ssa.Is32BitFloat(t1) && ssa.IsSamePtr(p1, p2) && n >= o + 4
	// result: (Const32F [0])
	for {
		t1 := v.Type
		if v_0.Op != ssaop.OpOffPtr {
			break
		}
		o := ssa.AuxIntToInt64(v_0.AuxInt)
		p1 := v_0.Args[0]
		if v_1.Op != ssaop.OpZero {
			break
		}
		n := ssa.AuxIntToInt64(v_1.AuxInt)
		p2 := v_1.Args[0]
		if !(ssa.Is32BitFloat(t1) && ssa.IsSamePtr(p1, p2) && n >= o+4) {
			break
		}
		v.Reset(ssaop.OpConst32F)
		v.AuxInt = ssa.Float32ToAuxInt(0)
		return true
	}
	// match: (Load <t1> (OffPtr [o] p1) (Zero [n] p2 _))
	// cond: ssa.Is64BitFloat(t1) && ssa.IsSamePtr(p1, p2) && n >= o + 8
	// result: (Const64F [0])
	for {
		t1 := v.Type
		if v_0.Op != ssaop.OpOffPtr {
			break
		}
		o := ssa.AuxIntToInt64(v_0.AuxInt)
		p1 := v_0.Args[0]
		if v_1.Op != ssaop.OpZero {
			break
		}
		n := ssa.AuxIntToInt64(v_1.AuxInt)
		p2 := v_1.Args[0]
		if !(ssa.Is64BitFloat(t1) && ssa.IsSamePtr(p1, p2) && n >= o+8) {
			break
		}
		v.Reset(ssaop.OpConst64F)
		v.AuxInt = ssa.Float64ToAuxInt(0)
		return true
	}
	// match: (Load <t> _ _)
	// cond: t.IsStruct() && t.Size() > 0 && ssa.CanSSA(t) && !t.IsSIMD()
	// result: rewriteStructLoad(v)
	for {
		t := v.Type
		if !(t.IsStruct() && t.Size() > 0 && ssa.CanSSA(t) && !t.IsSIMD()) {
			break
		}
		v.CopyOf(rewriteStructLoad(v))
		return true
	}
	// match: (Load <t> ptr mem)
	// cond: t.IsArray() && t.NumElem() == 1 && t.Size() > 0 && ssa.CanSSA(t)
	// result: (ArrayMake1 (Load <t.Elem()> ptr mem))
	for {
		t := v.Type
		ptr := v_0
		mem := v_1
		if !(t.IsArray() && t.NumElem() == 1 && t.Size() > 0 && ssa.CanSSA(t)) {
			break
		}
		v.Reset(ssaop.OpArrayMake1)
		v0 := b.NewValue0(v.Pos, ssaop.OpLoad, t.Elem())
		v0.AddArg2(ptr, mem)
		v.AddArg(v0)
		return true
	}
	// match: (Load <t> _ _)
	// cond: t.Size() == 0
	// result: (Empty)
	for {
		t := v.Type
		if !(t.Size() == 0) {
			break
		}
		v.Reset(ssaop.OpEmpty)
		return true
	}
	// match: (Load <typ.Int8> sptr:(Addr {scon} (SB)) mem)
	// cond: ssa.SymIsRO(scon)
	// result: (Const8 <typ.Int8> [int8(ssa.Read8(scon,0))])
	for {
		if v.Type != typ.Int8 {
			break
		}
		sptr := v_0
		if sptr.Op != ssaop.OpAddr {
			break
		}
		scon := ssa.AuxToSym(sptr.Aux)
		sptr_0 := sptr.Args[0]
		if sptr_0.Op != ssaop.OpSB {
			break
		}
		if !(ssa.SymIsRO(scon)) {
			break
		}
		v.Reset(ssaop.OpConst8)
		v.Type = typ.Int8
		v.AuxInt = ssa.Int8ToAuxInt(int8(ssa.Read8(scon, 0)))
		return true
	}
	// match: (Load <typ.Int16> sptr:(Addr {scon} (SB)) mem)
	// cond: ssa.SymIsRO(scon)
	// result: (Const16 <typ.Int16> [int16(ssa.Read16(scon,0,config.Ctxt.Arch.ByteOrder))])
	for {
		if v.Type != typ.Int16 {
			break
		}
		sptr := v_0
		if sptr.Op != ssaop.OpAddr {
			break
		}
		scon := ssa.AuxToSym(sptr.Aux)
		sptr_0 := sptr.Args[0]
		if sptr_0.Op != ssaop.OpSB {
			break
		}
		if !(ssa.SymIsRO(scon)) {
			break
		}
		v.Reset(ssaop.OpConst16)
		v.Type = typ.Int16
		v.AuxInt = ssa.Int16ToAuxInt(int16(ssa.Read16(scon, 0, config.Ctxt.Arch.ByteOrder)))
		return true
	}
	// match: (Load <typ.Int32> sptr:(Addr {scon} (SB)) mem)
	// cond: ssa.SymIsRO(scon)
	// result: (Const32 <typ.Int32> [int32(ssa.Read32(scon,0,config.Ctxt.Arch.ByteOrder))])
	for {
		if v.Type != typ.Int32 {
			break
		}
		sptr := v_0
		if sptr.Op != ssaop.OpAddr {
			break
		}
		scon := ssa.AuxToSym(sptr.Aux)
		sptr_0 := sptr.Args[0]
		if sptr_0.Op != ssaop.OpSB {
			break
		}
		if !(ssa.SymIsRO(scon)) {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.Type = typ.Int32
		v.AuxInt = ssa.Int32ToAuxInt(int32(ssa.Read32(scon, 0, config.Ctxt.Arch.ByteOrder)))
		return true
	}
	// match: (Load <typ.Int64> sptr:(Addr {scon} (SB)) mem)
	// cond: ssa.SymIsRO(scon)
	// result: (Const64 <typ.Int64> [int64(ssa.Read64(scon,0,config.Ctxt.Arch.ByteOrder))])
	for {
		if v.Type != typ.Int64 {
			break
		}
		sptr := v_0
		if sptr.Op != ssaop.OpAddr {
			break
		}
		scon := ssa.AuxToSym(sptr.Aux)
		sptr_0 := sptr.Args[0]
		if sptr_0.Op != ssaop.OpSB {
			break
		}
		if !(ssa.SymIsRO(scon)) {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.Type = typ.Int64
		v.AuxInt = ssa.Int64ToAuxInt(int64(ssa.Read64(scon, 0, config.Ctxt.Arch.ByteOrder)))
		return true
	}
	// match: (Load (Addr {s} sb) _)
	// cond: isFixedLoad(v, s, 0)
	// result: rewriteFixedLoad(v, s, sb, 0)
	for {
		if v_0.Op != ssaop.OpAddr {
			break
		}
		s := ssa.AuxToSym(v_0.Aux)
		sb := v_0.Args[0]
		if !(isFixedLoad(v, s, 0)) {
			break
		}
		v.CopyOf(rewriteFixedLoad(v, s, sb, 0))
		return true
	}
	// match: (Load (Convert (Addr {s} sb) _) _)
	// cond: isFixedLoad(v, s, 0)
	// result: rewriteFixedLoad(v, s, sb, 0)
	for {
		if v_0.Op != ssaop.OpConvert {
			break
		}
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpAddr {
			break
		}
		s := ssa.AuxToSym(v_0_0.Aux)
		sb := v_0_0.Args[0]
		if !(isFixedLoad(v, s, 0)) {
			break
		}
		v.CopyOf(rewriteFixedLoad(v, s, sb, 0))
		return true
	}
	// match: (Load (ITab (IMake (Addr {s} sb) _)) _)
	// cond: isFixedLoad(v, s, 0)
	// result: rewriteFixedLoad(v, s, sb, 0)
	for {
		if v_0.Op != ssaop.OpITab {
			break
		}
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpIMake {
			break
		}
		v_0_0_0 := v_0_0.Args[0]
		if v_0_0_0.Op != ssaop.OpAddr {
			break
		}
		s := ssa.AuxToSym(v_0_0_0.Aux)
		sb := v_0_0_0.Args[0]
		if !(isFixedLoad(v, s, 0)) {
			break
		}
		v.CopyOf(rewriteFixedLoad(v, s, sb, 0))
		return true
	}
	// match: (Load (ITab (IMake (Convert (Addr {s} sb) _) _)) _)
	// cond: isFixedLoad(v, s, 0)
	// result: rewriteFixedLoad(v, s, sb, 0)
	for {
		if v_0.Op != ssaop.OpITab {
			break
		}
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpIMake {
			break
		}
		v_0_0_0 := v_0_0.Args[0]
		if v_0_0_0.Op != ssaop.OpConvert {
			break
		}
		v_0_0_0_0 := v_0_0_0.Args[0]
		if v_0_0_0_0.Op != ssaop.OpAddr {
			break
		}
		s := ssa.AuxToSym(v_0_0_0_0.Aux)
		sb := v_0_0_0_0.Args[0]
		if !(isFixedLoad(v, s, 0)) {
			break
		}
		v.CopyOf(rewriteFixedLoad(v, s, sb, 0))
		return true
	}
	// match: (Load (OffPtr [off] (Addr {s} sb) ) _)
	// cond: isFixedLoad(v, s, off)
	// result: rewriteFixedLoad(v, s, sb, off)
	for {
		if v_0.Op != ssaop.OpOffPtr {
			break
		}
		off := ssa.AuxIntToInt64(v_0.AuxInt)
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpAddr {
			break
		}
		s := ssa.AuxToSym(v_0_0.Aux)
		sb := v_0_0.Args[0]
		if !(isFixedLoad(v, s, off)) {
			break
		}
		v.CopyOf(rewriteFixedLoad(v, s, sb, off))
		return true
	}
	// match: (Load (OffPtr [off] (Convert (Addr {s} sb) _) ) _)
	// cond: isFixedLoad(v, s, off)
	// result: rewriteFixedLoad(v, s, sb, off)
	for {
		if v_0.Op != ssaop.OpOffPtr {
			break
		}
		off := ssa.AuxIntToInt64(v_0.AuxInt)
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpConvert {
			break
		}
		v_0_0_0 := v_0_0.Args[0]
		if v_0_0_0.Op != ssaop.OpAddr {
			break
		}
		s := ssa.AuxToSym(v_0_0_0.Aux)
		sb := v_0_0_0.Args[0]
		if !(isFixedLoad(v, s, off)) {
			break
		}
		v.CopyOf(rewriteFixedLoad(v, s, sb, off))
		return true
	}
	// match: (Load (OffPtr [off] (ITab (IMake (Addr {s} sb) _))) _)
	// cond: isFixedLoad(v, s, off)
	// result: rewriteFixedLoad(v, s, sb, off)
	for {
		if v_0.Op != ssaop.OpOffPtr {
			break
		}
		off := ssa.AuxIntToInt64(v_0.AuxInt)
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpITab {
			break
		}
		v_0_0_0 := v_0_0.Args[0]
		if v_0_0_0.Op != ssaop.OpIMake {
			break
		}
		v_0_0_0_0 := v_0_0_0.Args[0]
		if v_0_0_0_0.Op != ssaop.OpAddr {
			break
		}
		s := ssa.AuxToSym(v_0_0_0_0.Aux)
		sb := v_0_0_0_0.Args[0]
		if !(isFixedLoad(v, s, off)) {
			break
		}
		v.CopyOf(rewriteFixedLoad(v, s, sb, off))
		return true
	}
	// match: (Load (OffPtr [off] (ITab (IMake (Convert (Addr {s} sb) _) _))) _)
	// cond: isFixedLoad(v, s, off)
	// result: rewriteFixedLoad(v, s, sb, off)
	for {
		if v_0.Op != ssaop.OpOffPtr {
			break
		}
		off := ssa.AuxIntToInt64(v_0.AuxInt)
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpITab {
			break
		}
		v_0_0_0 := v_0_0.Args[0]
		if v_0_0_0.Op != ssaop.OpIMake {
			break
		}
		v_0_0_0_0 := v_0_0_0.Args[0]
		if v_0_0_0_0.Op != ssaop.OpConvert {
			break
		}
		v_0_0_0_0_0 := v_0_0_0_0.Args[0]
		if v_0_0_0_0_0.Op != ssaop.OpAddr {
			break
		}
		s := ssa.AuxToSym(v_0_0_0_0_0.Aux)
		sb := v_0_0_0_0_0.Args[0]
		if !(isFixedLoad(v, s, off)) {
			break
		}
		v.CopyOf(rewriteFixedLoad(v, s, sb, off))
		return true
	}
	return false
}
func rewriteValue_OpLsh16x16(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Lsh16x16 x (Const16 [c]))
	// result: (Lsh16x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint16(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_1.AuxInt)
		v.Reset(ssaop.OpLsh16x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint16(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Lsh16x16 (Const16 [0]) _)
	// result: (Const16 [0])
	for {
		if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(0)
		return true
	}
	// match: (Lsh16x16 [false] x con:(Const16 [c]))
	// cond: 0 < c && c < 16
	// result: (Lsh16x16 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(con.AuxInt)
		if !(0 < c && c < 16) {
			break
		}
		v.Reset(ssaop.OpLsh16x16)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpLsh16x32(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Lsh16x32 x (Const32 [c]))
	// result: (Lsh16x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint32(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_1.AuxInt)
		v.Reset(ssaop.OpLsh16x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint32(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Lsh16x32 (Const16 [0]) _)
	// result: (Const16 [0])
	for {
		if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(0)
		return true
	}
	// match: (Lsh16x32 [false] x con:(Const32 [c]))
	// cond: 0 < c && c < 16
	// result: (Lsh16x32 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(con.AuxInt)
		if !(0 < c && c < 16) {
			break
		}
		v.Reset(ssaop.OpLsh16x32)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpLsh16x64(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (Lsh16x64 (Const16 [c]) (Const64 [d]))
	// result: (Const16 [c << uint64(d)])
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(c << uint64(d))
		return true
	}
	// match: (Lsh16x64 x (Const64 [0]))
	// result: x
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (Lsh16x64 (Const16 [0]) _)
	// result: (Const16 [0])
	for {
		if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(0)
		return true
	}
	// match: (Lsh16x64 _ (Const64 [c]))
	// cond: uint64(c) >= 16
	// result: (Const16 [0])
	for {
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(uint64(c) >= 16) {
			break
		}
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(0)
		return true
	}
	// match: (Lsh16x64 <t> (Lsh16x64 x (Const64 [c])) (Const64 [d]))
	// cond: !uaddOvf(c,d)
	// result: (Lsh16x64 x (Const64 <t> [c+d]))
	for {
		t := v.Type
		if v_0.Op != ssaop.OpLsh16x64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(!uaddOvf(c, d)) {
			break
		}
		v.Reset(ssaop.OpLsh16x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(c + d)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Lsh16x64 i:(Rsh16x64 x (Const64 [c])) (Const64 [c]))
	// cond: c >= 0 && c < 16 && i.Uses == 1
	// result: (And16 x (Const16 <v.Type> [int16(-1) << c]))
	for {
		i := v_0
		if i.Op != ssaop.OpRsh16x64 {
			break
		}
		_ = i.Args[1]
		x := i.Args[0]
		i_1 := i.Args[1]
		if i_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(i_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != c || !(c >= 0 && c < 16 && i.Uses == 1) {
			break
		}
		v.Reset(ssaop.OpAnd16)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst16, v.Type)
		v0.AuxInt = ssa.Int16ToAuxInt(int16(-1) << c)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Lsh16x64 i:(Rsh16Ux64 x (Const64 [c])) (Const64 [c]))
	// cond: c >= 0 && c < 16 && i.Uses == 1
	// result: (And16 x (Const16 <v.Type> [int16(-1) << c]))
	for {
		i := v_0
		if i.Op != ssaop.OpRsh16Ux64 {
			break
		}
		_ = i.Args[1]
		x := i.Args[0]
		i_1 := i.Args[1]
		if i_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(i_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != c || !(c >= 0 && c < 16 && i.Uses == 1) {
			break
		}
		v.Reset(ssaop.OpAnd16)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst16, v.Type)
		v0.AuxInt = ssa.Int16ToAuxInt(int16(-1) << c)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Lsh16x64 (Rsh16Ux64 (Lsh16x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
	// cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
	// result: (Lsh16x64 x (Const64 <typ.UInt64> [c1-c2+c3]))
	for {
		if v_0.Op != ssaop.OpRsh16Ux64 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpLsh16x64 {
			break
		}
		_ = v_0_0.Args[1]
		x := v_0_0.Args[0]
		v_0_0_1 := v_0_0.Args[1]
		if v_0_0_1.Op != ssaop.OpConst64 {
			break
		}
		c1 := ssa.AuxIntToInt64(v_0_0_1.AuxInt)
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 {
			break
		}
		c2 := ssa.AuxIntToInt64(v_0_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		c3 := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) {
			break
		}
		v.Reset(ssaop.OpLsh16x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64)
		v0.AuxInt = ssa.Int64ToAuxInt(c1 - c2 + c3)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Lsh16x64 (And16 (Rsh16x64 <t> x (Const64 <t2> [c])) (Const16 [d])) (Const64 [e]))
	// cond: c >= e
	// result: (And16 (Rsh16x64 <t> x (Const64 <t2> [c-e])) (Const16 <t> [d<<e]))
	for {
		if v_0.Op != ssaop.OpAnd16 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			if v_0_0.Op != ssaop.OpRsh16x64 {
				continue
			}
			t := v_0_0.Type
			_ = v_0_0.Args[1]
			x := v_0_0.Args[0]
			v_0_0_1 := v_0_0.Args[1]
			if v_0_0_1.Op != ssaop.OpConst64 {
				continue
			}
			t2 := v_0_0_1.Type
			c := ssa.AuxIntToInt64(v_0_0_1.AuxInt)
			if v_0_1.Op != ssaop.OpConst16 {
				continue
			}
			d := ssa.AuxIntToInt16(v_0_1.AuxInt)
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			e := ssa.AuxIntToInt64(v_1.AuxInt)
			if !(c >= e) {
				continue
			}
			v.Reset(ssaop.OpAnd16)
			v0 := b.NewValue0(v.Pos, ssaop.OpRsh16x64, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t2)
			v1.AuxInt = ssa.Int64ToAuxInt(c - e)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
			v2.AuxInt = ssa.Int16ToAuxInt(d << e)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (Lsh16x64 (And16 (Rsh16Ux64 <t> x (Const64 <t2> [c])) (Const16 [d])) (Const64 [e]))
	// cond: c >= e
	// result: (And16 (Rsh16Ux64 <t> x (Const64 <t2> [c-e])) (Const16 <t> [d<<e]))
	for {
		if v_0.Op != ssaop.OpAnd16 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			if v_0_0.Op != ssaop.OpRsh16Ux64 {
				continue
			}
			t := v_0_0.Type
			_ = v_0_0.Args[1]
			x := v_0_0.Args[0]
			v_0_0_1 := v_0_0.Args[1]
			if v_0_0_1.Op != ssaop.OpConst64 {
				continue
			}
			t2 := v_0_0_1.Type
			c := ssa.AuxIntToInt64(v_0_0_1.AuxInt)
			if v_0_1.Op != ssaop.OpConst16 {
				continue
			}
			d := ssa.AuxIntToInt16(v_0_1.AuxInt)
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			e := ssa.AuxIntToInt64(v_1.AuxInt)
			if !(c >= e) {
				continue
			}
			v.Reset(ssaop.OpAnd16)
			v0 := b.NewValue0(v.Pos, ssaop.OpRsh16Ux64, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t2)
			v1.AuxInt = ssa.Int64ToAuxInt(c - e)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
			v2.AuxInt = ssa.Int16ToAuxInt(d << e)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (Lsh16x64 (And16 (Rsh16x64 <t> x (Const64 <t2> [c])) (Const16 [d])) (Const64 [e]))
	// cond: c < e
	// result: (And16 (Lsh16x64 <t> x (Const64 <t2> [e-c])) (Const16 <t> [d<<e]))
	for {
		if v_0.Op != ssaop.OpAnd16 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			if v_0_0.Op != ssaop.OpRsh16x64 {
				continue
			}
			t := v_0_0.Type
			_ = v_0_0.Args[1]
			x := v_0_0.Args[0]
			v_0_0_1 := v_0_0.Args[1]
			if v_0_0_1.Op != ssaop.OpConst64 {
				continue
			}
			t2 := v_0_0_1.Type
			c := ssa.AuxIntToInt64(v_0_0_1.AuxInt)
			if v_0_1.Op != ssaop.OpConst16 {
				continue
			}
			d := ssa.AuxIntToInt16(v_0_1.AuxInt)
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			e := ssa.AuxIntToInt64(v_1.AuxInt)
			if !(c < e) {
				continue
			}
			v.Reset(ssaop.OpAnd16)
			v0 := b.NewValue0(v.Pos, ssaop.OpLsh16x64, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t2)
			v1.AuxInt = ssa.Int64ToAuxInt(e - c)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
			v2.AuxInt = ssa.Int16ToAuxInt(d << e)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (Lsh16x64 (And16 (Rsh16Ux64 <t> x (Const64 <t2> [c])) (Const16 [d])) (Const64 [e]))
	// cond: c < e
	// result: (And16 (Lsh16x64 <t> x (Const64 <t2> [e-c])) (Const16 <t> [d<<e]))
	for {
		if v_0.Op != ssaop.OpAnd16 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			if v_0_0.Op != ssaop.OpRsh16Ux64 {
				continue
			}
			t := v_0_0.Type
			_ = v_0_0.Args[1]
			x := v_0_0.Args[0]
			v_0_0_1 := v_0_0.Args[1]
			if v_0_0_1.Op != ssaop.OpConst64 {
				continue
			}
			t2 := v_0_0_1.Type
			c := ssa.AuxIntToInt64(v_0_0_1.AuxInt)
			if v_0_1.Op != ssaop.OpConst16 {
				continue
			}
			d := ssa.AuxIntToInt16(v_0_1.AuxInt)
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			e := ssa.AuxIntToInt64(v_1.AuxInt)
			if !(c < e) {
				continue
			}
			v.Reset(ssaop.OpAnd16)
			v0 := b.NewValue0(v.Pos, ssaop.OpLsh16x64, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t2)
			v1.AuxInt = ssa.Int64ToAuxInt(e - c)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
			v2.AuxInt = ssa.Int16ToAuxInt(d << e)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (Lsh16x64 [false] x con:(Const64 [c]))
	// cond: 0 < c && c < 16
	// result: (Lsh16x64 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(con.AuxInt)
		if !(0 < c && c < 16) {
			break
		}
		v.Reset(ssaop.OpLsh16x64)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpLsh16x8(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Lsh16x8 x (Const8 [c]))
	// result: (Lsh16x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint8(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_1.AuxInt)
		v.Reset(ssaop.OpLsh16x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint8(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Lsh16x8 (Const16 [0]) _)
	// result: (Const16 [0])
	for {
		if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(0)
		return true
	}
	// match: (Lsh16x8 [false] x con:(Const8 [c]))
	// cond: 0 < c && c < 16
	// result: (Lsh16x8 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(con.AuxInt)
		if !(0 < c && c < 16) {
			break
		}
		v.Reset(ssaop.OpLsh16x8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpLsh32x16(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Lsh32x16 x (Const16 [c]))
	// result: (Lsh32x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint16(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_1.AuxInt)
		v.Reset(ssaop.OpLsh32x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint16(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Lsh32x16 (Const32 [0]) _)
	// result: (Const32 [0])
	for {
		if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(0)
		return true
	}
	// match: (Lsh32x16 [false] x con:(Const16 [c]))
	// cond: 0 < c && c < 32
	// result: (Lsh32x16 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(con.AuxInt)
		if !(0 < c && c < 32) {
			break
		}
		v.Reset(ssaop.OpLsh32x16)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpLsh32x32(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Lsh32x32 x (Const32 [c]))
	// result: (Lsh32x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint32(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_1.AuxInt)
		v.Reset(ssaop.OpLsh32x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint32(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Lsh32x32 (Const32 [0]) _)
	// result: (Const32 [0])
	for {
		if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(0)
		return true
	}
	// match: (Lsh32x32 [false] x con:(Const32 [c]))
	// cond: 0 < c && c < 32
	// result: (Lsh32x32 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(con.AuxInt)
		if !(0 < c && c < 32) {
			break
		}
		v.Reset(ssaop.OpLsh32x32)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpLsh32x64(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (Lsh32x64 (Const32 [c]) (Const64 [d]))
	// result: (Const32 [c << uint64(d)])
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(c << uint64(d))
		return true
	}
	// match: (Lsh32x64 x (Const64 [0]))
	// result: x
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (Lsh32x64 (Const32 [0]) _)
	// result: (Const32 [0])
	for {
		if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(0)
		return true
	}
	// match: (Lsh32x64 _ (Const64 [c]))
	// cond: uint64(c) >= 32
	// result: (Const32 [0])
	for {
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(uint64(c) >= 32) {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(0)
		return true
	}
	// match: (Lsh32x64 <t> (Lsh32x64 x (Const64 [c])) (Const64 [d]))
	// cond: !uaddOvf(c,d)
	// result: (Lsh32x64 x (Const64 <t> [c+d]))
	for {
		t := v.Type
		if v_0.Op != ssaop.OpLsh32x64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(!uaddOvf(c, d)) {
			break
		}
		v.Reset(ssaop.OpLsh32x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(c + d)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Lsh32x64 i:(Rsh32x64 x (Const64 [c])) (Const64 [c]))
	// cond: c >= 0 && c < 32 && i.Uses == 1
	// result: (And32 x (Const32 <v.Type> [int32(-1) << c]))
	for {
		i := v_0
		if i.Op != ssaop.OpRsh32x64 {
			break
		}
		_ = i.Args[1]
		x := i.Args[0]
		i_1 := i.Args[1]
		if i_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(i_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != c || !(c >= 0 && c < 32 && i.Uses == 1) {
			break
		}
		v.Reset(ssaop.OpAnd32)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst32, v.Type)
		v0.AuxInt = ssa.Int32ToAuxInt(int32(-1) << c)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Lsh32x64 i:(Rsh32Ux64 x (Const64 [c])) (Const64 [c]))
	// cond: c >= 0 && c < 32 && i.Uses == 1
	// result: (And32 x (Const32 <v.Type> [int32(-1) << c]))
	for {
		i := v_0
		if i.Op != ssaop.OpRsh32Ux64 {
			break
		}
		_ = i.Args[1]
		x := i.Args[0]
		i_1 := i.Args[1]
		if i_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(i_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != c || !(c >= 0 && c < 32 && i.Uses == 1) {
			break
		}
		v.Reset(ssaop.OpAnd32)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst32, v.Type)
		v0.AuxInt = ssa.Int32ToAuxInt(int32(-1) << c)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Lsh32x64 (Rsh32Ux64 (Lsh32x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
	// cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
	// result: (Lsh32x64 x (Const64 <typ.UInt64> [c1-c2+c3]))
	for {
		if v_0.Op != ssaop.OpRsh32Ux64 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpLsh32x64 {
			break
		}
		_ = v_0_0.Args[1]
		x := v_0_0.Args[0]
		v_0_0_1 := v_0_0.Args[1]
		if v_0_0_1.Op != ssaop.OpConst64 {
			break
		}
		c1 := ssa.AuxIntToInt64(v_0_0_1.AuxInt)
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 {
			break
		}
		c2 := ssa.AuxIntToInt64(v_0_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		c3 := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) {
			break
		}
		v.Reset(ssaop.OpLsh32x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64)
		v0.AuxInt = ssa.Int64ToAuxInt(c1 - c2 + c3)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Lsh32x64 (And32 (Rsh32x64 <t> x (Const64 <t2> [c])) (Const32 [d])) (Const64 [e]))
	// cond: c >= e
	// result: (And32 (Rsh32x64 <t> x (Const64 <t2> [c-e])) (Const32 <t> [d<<e]))
	for {
		if v_0.Op != ssaop.OpAnd32 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			if v_0_0.Op != ssaop.OpRsh32x64 {
				continue
			}
			t := v_0_0.Type
			_ = v_0_0.Args[1]
			x := v_0_0.Args[0]
			v_0_0_1 := v_0_0.Args[1]
			if v_0_0_1.Op != ssaop.OpConst64 {
				continue
			}
			t2 := v_0_0_1.Type
			c := ssa.AuxIntToInt64(v_0_0_1.AuxInt)
			if v_0_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(v_0_1.AuxInt)
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			e := ssa.AuxIntToInt64(v_1.AuxInt)
			if !(c >= e) {
				continue
			}
			v.Reset(ssaop.OpAnd32)
			v0 := b.NewValue0(v.Pos, ssaop.OpRsh32x64, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t2)
			v1.AuxInt = ssa.Int64ToAuxInt(c - e)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
			v2.AuxInt = ssa.Int32ToAuxInt(d << e)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (Lsh32x64 (And32 (Rsh32Ux64 <t> x (Const64 <t2> [c])) (Const32 [d])) (Const64 [e]))
	// cond: c >= e
	// result: (And32 (Rsh32Ux64 <t> x (Const64 <t2> [c-e])) (Const32 <t> [d<<e]))
	for {
		if v_0.Op != ssaop.OpAnd32 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			if v_0_0.Op != ssaop.OpRsh32Ux64 {
				continue
			}
			t := v_0_0.Type
			_ = v_0_0.Args[1]
			x := v_0_0.Args[0]
			v_0_0_1 := v_0_0.Args[1]
			if v_0_0_1.Op != ssaop.OpConst64 {
				continue
			}
			t2 := v_0_0_1.Type
			c := ssa.AuxIntToInt64(v_0_0_1.AuxInt)
			if v_0_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(v_0_1.AuxInt)
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			e := ssa.AuxIntToInt64(v_1.AuxInt)
			if !(c >= e) {
				continue
			}
			v.Reset(ssaop.OpAnd32)
			v0 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux64, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t2)
			v1.AuxInt = ssa.Int64ToAuxInt(c - e)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
			v2.AuxInt = ssa.Int32ToAuxInt(d << e)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (Lsh32x64 (And32 (Rsh32x64 <t> x (Const64 <t2> [c])) (Const32 [d])) (Const64 [e]))
	// cond: c < e
	// result: (And32 (Lsh32x64 <t> x (Const64 <t2> [e-c])) (Const32 <t> [d<<e]))
	for {
		if v_0.Op != ssaop.OpAnd32 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			if v_0_0.Op != ssaop.OpRsh32x64 {
				continue
			}
			t := v_0_0.Type
			_ = v_0_0.Args[1]
			x := v_0_0.Args[0]
			v_0_0_1 := v_0_0.Args[1]
			if v_0_0_1.Op != ssaop.OpConst64 {
				continue
			}
			t2 := v_0_0_1.Type
			c := ssa.AuxIntToInt64(v_0_0_1.AuxInt)
			if v_0_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(v_0_1.AuxInt)
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			e := ssa.AuxIntToInt64(v_1.AuxInt)
			if !(c < e) {
				continue
			}
			v.Reset(ssaop.OpAnd32)
			v0 := b.NewValue0(v.Pos, ssaop.OpLsh32x64, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t2)
			v1.AuxInt = ssa.Int64ToAuxInt(e - c)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
			v2.AuxInt = ssa.Int32ToAuxInt(d << e)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (Lsh32x64 (And32 (Rsh32Ux64 <t> x (Const64 <t2> [c])) (Const32 [d])) (Const64 [e]))
	// cond: c < e
	// result: (And32 (Lsh32x64 <t> x (Const64 <t2> [e-c])) (Const32 <t> [d<<e]))
	for {
		if v_0.Op != ssaop.OpAnd32 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			if v_0_0.Op != ssaop.OpRsh32Ux64 {
				continue
			}
			t := v_0_0.Type
			_ = v_0_0.Args[1]
			x := v_0_0.Args[0]
			v_0_0_1 := v_0_0.Args[1]
			if v_0_0_1.Op != ssaop.OpConst64 {
				continue
			}
			t2 := v_0_0_1.Type
			c := ssa.AuxIntToInt64(v_0_0_1.AuxInt)
			if v_0_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(v_0_1.AuxInt)
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			e := ssa.AuxIntToInt64(v_1.AuxInt)
			if !(c < e) {
				continue
			}
			v.Reset(ssaop.OpAnd32)
			v0 := b.NewValue0(v.Pos, ssaop.OpLsh32x64, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t2)
			v1.AuxInt = ssa.Int64ToAuxInt(e - c)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
			v2.AuxInt = ssa.Int32ToAuxInt(d << e)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (Lsh32x64 [false] x con:(Const64 [c]))
	// cond: 0 < c && c < 32
	// result: (Lsh32x64 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(con.AuxInt)
		if !(0 < c && c < 32) {
			break
		}
		v.Reset(ssaop.OpLsh32x64)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpLsh32x8(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Lsh32x8 x (Const8 [c]))
	// result: (Lsh32x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint8(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_1.AuxInt)
		v.Reset(ssaop.OpLsh32x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint8(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Lsh32x8 (Const32 [0]) _)
	// result: (Const32 [0])
	for {
		if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(0)
		return true
	}
	// match: (Lsh32x8 [false] x con:(Const8 [c]))
	// cond: 0 < c && c < 32
	// result: (Lsh32x8 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(con.AuxInt)
		if !(0 < c && c < 32) {
			break
		}
		v.Reset(ssaop.OpLsh32x8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpLsh64x16(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Lsh64x16 x (Const16 [c]))
	// result: (Lsh64x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint16(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_1.AuxInt)
		v.Reset(ssaop.OpLsh64x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint16(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Lsh64x16 (Const64 [0]) _)
	// result: (Const64 [0])
	for {
		if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(0)
		return true
	}
	// match: (Lsh64x16 [false] x con:(Const16 [c]))
	// cond: 0 < c && c < 64
	// result: (Lsh64x16 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(con.AuxInt)
		if !(0 < c && c < 64) {
			break
		}
		v.Reset(ssaop.OpLsh64x16)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpLsh64x32(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Lsh64x32 x (Const32 [c]))
	// result: (Lsh64x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint32(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_1.AuxInt)
		v.Reset(ssaop.OpLsh64x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint32(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Lsh64x32 (Const64 [0]) _)
	// result: (Const64 [0])
	for {
		if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(0)
		return true
	}
	// match: (Lsh64x32 [false] x con:(Const32 [c]))
	// cond: 0 < c && c < 64
	// result: (Lsh64x32 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(con.AuxInt)
		if !(0 < c && c < 64) {
			break
		}
		v.Reset(ssaop.OpLsh64x32)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpLsh64x64(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (Lsh64x64 (Const64 [c]) (Const64 [d]))
	// result: (Const64 [c << uint64(d)])
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(c << uint64(d))
		return true
	}
	// match: (Lsh64x64 x (Const64 [0]))
	// result: x
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (Lsh64x64 (Const64 [0]) _)
	// result: (Const64 [0])
	for {
		if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(0)
		return true
	}
	// match: (Lsh64x64 _ (Const64 [c]))
	// cond: uint64(c) >= 64
	// result: (Const64 [0])
	for {
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(uint64(c) >= 64) {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(0)
		return true
	}
	// match: (Lsh64x64 <t> (Lsh64x64 x (Const64 [c])) (Const64 [d]))
	// cond: !uaddOvf(c,d)
	// result: (Lsh64x64 x (Const64 <t> [c+d]))
	for {
		t := v.Type
		if v_0.Op != ssaop.OpLsh64x64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(!uaddOvf(c, d)) {
			break
		}
		v.Reset(ssaop.OpLsh64x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(c + d)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Lsh64x64 i:(Rsh64x64 x (Const64 [c])) (Const64 [c]))
	// cond: c >= 0 && c < 64 && i.Uses == 1
	// result: (And64 x (Const64 <v.Type> [int64(-1) << c]))
	for {
		i := v_0
		if i.Op != ssaop.OpRsh64x64 {
			break
		}
		_ = i.Args[1]
		x := i.Args[0]
		i_1 := i.Args[1]
		if i_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(i_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != c || !(c >= 0 && c < 64 && i.Uses == 1) {
			break
		}
		v.Reset(ssaop.OpAnd64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, v.Type)
		v0.AuxInt = ssa.Int64ToAuxInt(int64(-1) << c)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Lsh64x64 i:(Rsh64Ux64 x (Const64 [c])) (Const64 [c]))
	// cond: c >= 0 && c < 64 && i.Uses == 1
	// result: (And64 x (Const64 <v.Type> [int64(-1) << c]))
	for {
		i := v_0
		if i.Op != ssaop.OpRsh64Ux64 {
			break
		}
		_ = i.Args[1]
		x := i.Args[0]
		i_1 := i.Args[1]
		if i_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(i_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != c || !(c >= 0 && c < 64 && i.Uses == 1) {
			break
		}
		v.Reset(ssaop.OpAnd64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, v.Type)
		v0.AuxInt = ssa.Int64ToAuxInt(int64(-1) << c)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Lsh64x64 (Rsh64Ux64 (Lsh64x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
	// cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
	// result: (Lsh64x64 x (Const64 <typ.UInt64> [c1-c2+c3]))
	for {
		if v_0.Op != ssaop.OpRsh64Ux64 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpLsh64x64 {
			break
		}
		_ = v_0_0.Args[1]
		x := v_0_0.Args[0]
		v_0_0_1 := v_0_0.Args[1]
		if v_0_0_1.Op != ssaop.OpConst64 {
			break
		}
		c1 := ssa.AuxIntToInt64(v_0_0_1.AuxInt)
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 {
			break
		}
		c2 := ssa.AuxIntToInt64(v_0_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		c3 := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) {
			break
		}
		v.Reset(ssaop.OpLsh64x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64)
		v0.AuxInt = ssa.Int64ToAuxInt(c1 - c2 + c3)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Lsh64x64 (And64 (Rsh64x64 <t> x (Const64 <t2> [c])) (Const64 [d])) (Const64 [e]))
	// cond: c >= e
	// result: (And64 (Rsh64x64 <t> x (Const64 <t2> [c-e])) (Const64 <t> [d<<e]))
	for {
		if v_0.Op != ssaop.OpAnd64 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			if v_0_0.Op != ssaop.OpRsh64x64 {
				continue
			}
			t := v_0_0.Type
			_ = v_0_0.Args[1]
			x := v_0_0.Args[0]
			v_0_0_1 := v_0_0.Args[1]
			if v_0_0_1.Op != ssaop.OpConst64 {
				continue
			}
			t2 := v_0_0_1.Type
			c := ssa.AuxIntToInt64(v_0_0_1.AuxInt)
			if v_0_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_0_1.AuxInt)
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			e := ssa.AuxIntToInt64(v_1.AuxInt)
			if !(c >= e) {
				continue
			}
			v.Reset(ssaop.OpAnd64)
			v0 := b.NewValue0(v.Pos, ssaop.OpRsh64x64, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t2)
			v1.AuxInt = ssa.Int64ToAuxInt(c - e)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
			v2.AuxInt = ssa.Int64ToAuxInt(d << e)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (Lsh64x64 (And64 (Rsh64Ux64 <t> x (Const64 <t2> [c])) (Const64 [d])) (Const64 [e]))
	// cond: c >= e
	// result: (And64 (Rsh64Ux64 <t> x (Const64 <t2> [c-e])) (Const64 <t> [d<<e]))
	for {
		if v_0.Op != ssaop.OpAnd64 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			if v_0_0.Op != ssaop.OpRsh64Ux64 {
				continue
			}
			t := v_0_0.Type
			_ = v_0_0.Args[1]
			x := v_0_0.Args[0]
			v_0_0_1 := v_0_0.Args[1]
			if v_0_0_1.Op != ssaop.OpConst64 {
				continue
			}
			t2 := v_0_0_1.Type
			c := ssa.AuxIntToInt64(v_0_0_1.AuxInt)
			if v_0_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_0_1.AuxInt)
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			e := ssa.AuxIntToInt64(v_1.AuxInt)
			if !(c >= e) {
				continue
			}
			v.Reset(ssaop.OpAnd64)
			v0 := b.NewValue0(v.Pos, ssaop.OpRsh64Ux64, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t2)
			v1.AuxInt = ssa.Int64ToAuxInt(c - e)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
			v2.AuxInt = ssa.Int64ToAuxInt(d << e)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (Lsh64x64 (And64 (Rsh64x64 <t> x (Const64 <t2> [c])) (Const64 [d])) (Const64 [e]))
	// cond: c < e
	// result: (And64 (Lsh64x64 <t> x (Const64 <t2> [e-c])) (Const64 <t> [d<<e]))
	for {
		if v_0.Op != ssaop.OpAnd64 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			if v_0_0.Op != ssaop.OpRsh64x64 {
				continue
			}
			t := v_0_0.Type
			_ = v_0_0.Args[1]
			x := v_0_0.Args[0]
			v_0_0_1 := v_0_0.Args[1]
			if v_0_0_1.Op != ssaop.OpConst64 {
				continue
			}
			t2 := v_0_0_1.Type
			c := ssa.AuxIntToInt64(v_0_0_1.AuxInt)
			if v_0_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_0_1.AuxInt)
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			e := ssa.AuxIntToInt64(v_1.AuxInt)
			if !(c < e) {
				continue
			}
			v.Reset(ssaop.OpAnd64)
			v0 := b.NewValue0(v.Pos, ssaop.OpLsh64x64, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t2)
			v1.AuxInt = ssa.Int64ToAuxInt(e - c)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
			v2.AuxInt = ssa.Int64ToAuxInt(d << e)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (Lsh64x64 (And64 (Rsh64Ux64 <t> x (Const64 <t2> [c])) (Const64 [d])) (Const64 [e]))
	// cond: c < e
	// result: (And64 (Lsh64x64 <t> x (Const64 <t2> [e-c])) (Const64 <t> [d<<e]))
	for {
		if v_0.Op != ssaop.OpAnd64 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			if v_0_0.Op != ssaop.OpRsh64Ux64 {
				continue
			}
			t := v_0_0.Type
			_ = v_0_0.Args[1]
			x := v_0_0.Args[0]
			v_0_0_1 := v_0_0.Args[1]
			if v_0_0_1.Op != ssaop.OpConst64 {
				continue
			}
			t2 := v_0_0_1.Type
			c := ssa.AuxIntToInt64(v_0_0_1.AuxInt)
			if v_0_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_0_1.AuxInt)
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			e := ssa.AuxIntToInt64(v_1.AuxInt)
			if !(c < e) {
				continue
			}
			v.Reset(ssaop.OpAnd64)
			v0 := b.NewValue0(v.Pos, ssaop.OpLsh64x64, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t2)
			v1.AuxInt = ssa.Int64ToAuxInt(e - c)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
			v2.AuxInt = ssa.Int64ToAuxInt(d << e)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (Lsh64x64 [false] x con:(Const64 [c]))
	// cond: 0 < c && c < 64
	// result: (Lsh64x64 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(con.AuxInt)
		if !(0 < c && c < 64) {
			break
		}
		v.Reset(ssaop.OpLsh64x64)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpLsh64x8(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Lsh64x8 x (Const8 [c]))
	// result: (Lsh64x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint8(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_1.AuxInt)
		v.Reset(ssaop.OpLsh64x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint8(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Lsh64x8 (Const64 [0]) _)
	// result: (Const64 [0])
	for {
		if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(0)
		return true
	}
	// match: (Lsh64x8 [false] x con:(Const8 [c]))
	// cond: 0 < c && c < 64
	// result: (Lsh64x8 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(con.AuxInt)
		if !(0 < c && c < 64) {
			break
		}
		v.Reset(ssaop.OpLsh64x8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpLsh8x16(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Lsh8x16 x (Const16 [c]))
	// result: (Lsh8x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint16(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_1.AuxInt)
		v.Reset(ssaop.OpLsh8x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint16(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Lsh8x16 (Const8 [0]) _)
	// result: (Const8 [0])
	for {
		if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(0)
		return true
	}
	// match: (Lsh8x16 [false] x con:(Const16 [c]))
	// cond: 0 < c && c < 8
	// result: (Lsh8x16 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(con.AuxInt)
		if !(0 < c && c < 8) {
			break
		}
		v.Reset(ssaop.OpLsh8x16)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpLsh8x32(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Lsh8x32 x (Const32 [c]))
	// result: (Lsh8x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint32(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_1.AuxInt)
		v.Reset(ssaop.OpLsh8x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint32(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Lsh8x32 (Const8 [0]) _)
	// result: (Const8 [0])
	for {
		if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(0)
		return true
	}
	// match: (Lsh8x32 [false] x con:(Const32 [c]))
	// cond: 0 < c && c < 8
	// result: (Lsh8x32 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(con.AuxInt)
		if !(0 < c && c < 8) {
			break
		}
		v.Reset(ssaop.OpLsh8x32)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpLsh8x64(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (Lsh8x64 (Const8 [c]) (Const64 [d]))
	// result: (Const8 [c << uint64(d)])
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(c << uint64(d))
		return true
	}
	// match: (Lsh8x64 x (Const64 [0]))
	// result: x
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (Lsh8x64 (Const8 [0]) _)
	// result: (Const8 [0])
	for {
		if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(0)
		return true
	}
	// match: (Lsh8x64 _ (Const64 [c]))
	// cond: uint64(c) >= 8
	// result: (Const8 [0])
	for {
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(uint64(c) >= 8) {
			break
		}
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(0)
		return true
	}
	// match: (Lsh8x64 <t> (Lsh8x64 x (Const64 [c])) (Const64 [d]))
	// cond: !uaddOvf(c,d)
	// result: (Lsh8x64 x (Const64 <t> [c+d]))
	for {
		t := v.Type
		if v_0.Op != ssaop.OpLsh8x64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(!uaddOvf(c, d)) {
			break
		}
		v.Reset(ssaop.OpLsh8x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(c + d)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Lsh8x64 i:(Rsh8x64 x (Const64 [c])) (Const64 [c]))
	// cond: c >= 0 && c < 8 && i.Uses == 1
	// result: (And8 x (Const8 <v.Type> [int8(-1) << c]))
	for {
		i := v_0
		if i.Op != ssaop.OpRsh8x64 {
			break
		}
		_ = i.Args[1]
		x := i.Args[0]
		i_1 := i.Args[1]
		if i_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(i_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != c || !(c >= 0 && c < 8 && i.Uses == 1) {
			break
		}
		v.Reset(ssaop.OpAnd8)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst8, v.Type)
		v0.AuxInt = ssa.Int8ToAuxInt(int8(-1) << c)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Lsh8x64 i:(Rsh8Ux64 x (Const64 [c])) (Const64 [c]))
	// cond: c >= 0 && c < 8 && i.Uses == 1
	// result: (And8 x (Const8 <v.Type> [int8(-1) << c]))
	for {
		i := v_0
		if i.Op != ssaop.OpRsh8Ux64 {
			break
		}
		_ = i.Args[1]
		x := i.Args[0]
		i_1 := i.Args[1]
		if i_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(i_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != c || !(c >= 0 && c < 8 && i.Uses == 1) {
			break
		}
		v.Reset(ssaop.OpAnd8)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst8, v.Type)
		v0.AuxInt = ssa.Int8ToAuxInt(int8(-1) << c)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Lsh8x64 (Rsh8Ux64 (Lsh8x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
	// cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
	// result: (Lsh8x64 x (Const64 <typ.UInt64> [c1-c2+c3]))
	for {
		if v_0.Op != ssaop.OpRsh8Ux64 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpLsh8x64 {
			break
		}
		_ = v_0_0.Args[1]
		x := v_0_0.Args[0]
		v_0_0_1 := v_0_0.Args[1]
		if v_0_0_1.Op != ssaop.OpConst64 {
			break
		}
		c1 := ssa.AuxIntToInt64(v_0_0_1.AuxInt)
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 {
			break
		}
		c2 := ssa.AuxIntToInt64(v_0_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		c3 := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) {
			break
		}
		v.Reset(ssaop.OpLsh8x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64)
		v0.AuxInt = ssa.Int64ToAuxInt(c1 - c2 + c3)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Lsh8x64 (And8 (Rsh8x64 <t> x (Const64 <t2> [c])) (Const8 [d])) (Const64 [e]))
	// cond: c >= e
	// result: (And8 (Rsh8x64 <t> x (Const64 <t2> [c-e])) (Const8 <t> [d<<e]))
	for {
		if v_0.Op != ssaop.OpAnd8 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			if v_0_0.Op != ssaop.OpRsh8x64 {
				continue
			}
			t := v_0_0.Type
			_ = v_0_0.Args[1]
			x := v_0_0.Args[0]
			v_0_0_1 := v_0_0.Args[1]
			if v_0_0_1.Op != ssaop.OpConst64 {
				continue
			}
			t2 := v_0_0_1.Type
			c := ssa.AuxIntToInt64(v_0_0_1.AuxInt)
			if v_0_1.Op != ssaop.OpConst8 {
				continue
			}
			d := ssa.AuxIntToInt8(v_0_1.AuxInt)
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			e := ssa.AuxIntToInt64(v_1.AuxInt)
			if !(c >= e) {
				continue
			}
			v.Reset(ssaop.OpAnd8)
			v0 := b.NewValue0(v.Pos, ssaop.OpRsh8x64, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t2)
			v1.AuxInt = ssa.Int64ToAuxInt(c - e)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
			v2.AuxInt = ssa.Int8ToAuxInt(d << e)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (Lsh8x64 (And8 (Rsh8Ux64 <t> x (Const64 <t2> [c])) (Const8 [d])) (Const64 [e]))
	// cond: c >= e
	// result: (And8 (Rsh8Ux64 <t> x (Const64 <t2> [c-e])) (Const8 <t> [d<<e]))
	for {
		if v_0.Op != ssaop.OpAnd8 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			if v_0_0.Op != ssaop.OpRsh8Ux64 {
				continue
			}
			t := v_0_0.Type
			_ = v_0_0.Args[1]
			x := v_0_0.Args[0]
			v_0_0_1 := v_0_0.Args[1]
			if v_0_0_1.Op != ssaop.OpConst64 {
				continue
			}
			t2 := v_0_0_1.Type
			c := ssa.AuxIntToInt64(v_0_0_1.AuxInt)
			if v_0_1.Op != ssaop.OpConst8 {
				continue
			}
			d := ssa.AuxIntToInt8(v_0_1.AuxInt)
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			e := ssa.AuxIntToInt64(v_1.AuxInt)
			if !(c >= e) {
				continue
			}
			v.Reset(ssaop.OpAnd8)
			v0 := b.NewValue0(v.Pos, ssaop.OpRsh8Ux64, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t2)
			v1.AuxInt = ssa.Int64ToAuxInt(c - e)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
			v2.AuxInt = ssa.Int8ToAuxInt(d << e)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (Lsh8x64 (And8 (Rsh8x64 <t> x (Const64 <t2> [c])) (Const8 [d])) (Const64 [e]))
	// cond: c < e
	// result: (And8 (Lsh8x64 <t> x (Const64 <t2> [e-c])) (Const8 <t> [d<<e]))
	for {
		if v_0.Op != ssaop.OpAnd8 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			if v_0_0.Op != ssaop.OpRsh8x64 {
				continue
			}
			t := v_0_0.Type
			_ = v_0_0.Args[1]
			x := v_0_0.Args[0]
			v_0_0_1 := v_0_0.Args[1]
			if v_0_0_1.Op != ssaop.OpConst64 {
				continue
			}
			t2 := v_0_0_1.Type
			c := ssa.AuxIntToInt64(v_0_0_1.AuxInt)
			if v_0_1.Op != ssaop.OpConst8 {
				continue
			}
			d := ssa.AuxIntToInt8(v_0_1.AuxInt)
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			e := ssa.AuxIntToInt64(v_1.AuxInt)
			if !(c < e) {
				continue
			}
			v.Reset(ssaop.OpAnd8)
			v0 := b.NewValue0(v.Pos, ssaop.OpLsh8x64, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t2)
			v1.AuxInt = ssa.Int64ToAuxInt(e - c)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
			v2.AuxInt = ssa.Int8ToAuxInt(d << e)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (Lsh8x64 (And8 (Rsh8Ux64 <t> x (Const64 <t2> [c])) (Const8 [d])) (Const64 [e]))
	// cond: c < e
	// result: (And8 (Lsh8x64 <t> x (Const64 <t2> [e-c])) (Const8 <t> [d<<e]))
	for {
		if v_0.Op != ssaop.OpAnd8 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			if v_0_0.Op != ssaop.OpRsh8Ux64 {
				continue
			}
			t := v_0_0.Type
			_ = v_0_0.Args[1]
			x := v_0_0.Args[0]
			v_0_0_1 := v_0_0.Args[1]
			if v_0_0_1.Op != ssaop.OpConst64 {
				continue
			}
			t2 := v_0_0_1.Type
			c := ssa.AuxIntToInt64(v_0_0_1.AuxInt)
			if v_0_1.Op != ssaop.OpConst8 {
				continue
			}
			d := ssa.AuxIntToInt8(v_0_1.AuxInt)
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			e := ssa.AuxIntToInt64(v_1.AuxInt)
			if !(c < e) {
				continue
			}
			v.Reset(ssaop.OpAnd8)
			v0 := b.NewValue0(v.Pos, ssaop.OpLsh8x64, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t2)
			v1.AuxInt = ssa.Int64ToAuxInt(e - c)
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
			v2.AuxInt = ssa.Int8ToAuxInt(d << e)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	// match: (Lsh8x64 [false] x con:(Const64 [c]))
	// cond: 0 < c && c < 8
	// result: (Lsh8x64 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(con.AuxInt)
		if !(0 < c && c < 8) {
			break
		}
		v.Reset(ssaop.OpLsh8x64)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpLsh8x8(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Lsh8x8 x (Const8 [c]))
	// result: (Lsh8x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint8(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_1.AuxInt)
		v.Reset(ssaop.OpLsh8x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint8(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Lsh8x8 (Const8 [0]) _)
	// result: (Const8 [0])
	for {
		if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(0)
		return true
	}
	// match: (Lsh8x8 [false] x con:(Const8 [c]))
	// cond: 0 < c && c < 8
	// result: (Lsh8x8 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(con.AuxInt)
		if !(0 < c && c < 8) {
			break
		}
		v.Reset(ssaop.OpLsh8x8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpMemEq(v *ssa.Value) bool {
	v_3 := v.Args[3]
	v_2 := v.Args[2]
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	typ := &b.Func.Config.Types
	// match: (MemEq sptr tptr (Const64 [1]) mem)
	// result: (Eq8 (Load <typ.Int8> sptr mem) (Load <typ.Int8> tptr mem))
	for {
		sptr := v_0
		tptr := v_1
		if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 1 {
			break
		}
		mem := v_3
		v.Reset(ssaop.OpEq8)
		v0 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int8)
		v0.AddArg2(sptr, mem)
		v1 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int8)
		v1.AddArg2(tptr, mem)
		v.AddArg2(v0, v1)
		return true
	}
	// match: (MemEq sptr tptr (Const64 [2]) mem)
	// cond: canLoadUnaligned(config)
	// result: (Eq16 (Load <typ.Int16> sptr mem) (Load <typ.Int16> tptr mem))
	for {
		sptr := v_0
		tptr := v_1
		if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 2 {
			break
		}
		mem := v_3
		if !(canLoadUnaligned(config)) {
			break
		}
		v.Reset(ssaop.OpEq16)
		v0 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int16)
		v0.AddArg2(sptr, mem)
		v1 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int16)
		v1.AddArg2(tptr, mem)
		v.AddArg2(v0, v1)
		return true
	}
	// match: (MemEq sptr tptr (Const64 [4]) mem)
	// cond: canLoadUnaligned(config)
	// result: (Eq32 (Load <typ.Int32> sptr mem) (Load <typ.Int32> tptr mem))
	for {
		sptr := v_0
		tptr := v_1
		if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 4 {
			break
		}
		mem := v_3
		if !(canLoadUnaligned(config)) {
			break
		}
		v.Reset(ssaop.OpEq32)
		v0 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int32)
		v0.AddArg2(sptr, mem)
		v1 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int32)
		v1.AddArg2(tptr, mem)
		v.AddArg2(v0, v1)
		return true
	}
	// match: (MemEq sptr tptr (Const64 [8]) mem)
	// cond: canLoadUnaligned(config) && config.PtrSize == 8
	// result: (Eq64 (Load <typ.Int64> sptr mem) (Load <typ.Int64> tptr mem))
	for {
		sptr := v_0
		tptr := v_1
		if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 8 {
			break
		}
		mem := v_3
		if !(canLoadUnaligned(config) && config.PtrSize == 8) {
			break
		}
		v.Reset(ssaop.OpEq64)
		v0 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int64)
		v0.AddArg2(sptr, mem)
		v1 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int64)
		v1.AddArg2(tptr, mem)
		v.AddArg2(v0, v1)
		return true
	}
	// match: (MemEq _ _ (Const64 [0]) _)
	// result: (ConstBool <typ.Bool> [true])
	for {
		if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.Type = typ.Bool
		v.AuxInt = ssa.BoolToAuxInt(true)
		return true
	}
	// match: (MemEq p q _ _)
	// cond: ssa.IsSamePtr(p, q)
	// result: (ConstBool <typ.Bool> [true])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			p := v_0
			q := v_1
			if !(ssa.IsSamePtr(p, q)) {
				continue
			}
			v.Reset(ssaop.OpConstBool)
			v.Type = typ.Bool
			v.AuxInt = ssa.BoolToAuxInt(true)
			return true
		}
		break
	}
	// match: (MemEq p q (Const64 [c]) mem)
	// cond: (c == 3 || c == 5 || c == 9 || c == 17) && canLoadUnaligned(config) && config.RegSize == 8
	// result: (AndB (MemEq p q (Const64 <typ.Int64> [c-1]) mem) (Eq8 (Load <typ.Int8> (OffPtr <p.Type> p [c-1]) mem) (Load <typ.Int8> (OffPtr <q.Type> q [c-1]) mem)))
	for {
		p := v_0
		q := v_1
		if v_2.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_2.AuxInt)
		mem := v_3
		if !((c == 3 || c == 5 || c == 9 || c == 17) && canLoadUnaligned(config) && config.RegSize == 8) {
			break
		}
		v.Reset(ssaop.OpAndB)
		v0 := b.NewValue0(v.Pos, ssaop.OpMemEq, typ.Bool)
		v1 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64)
		v1.AuxInt = ssa.Int64ToAuxInt(c - 1)
		v0.AddArg4(p, q, v1, mem)
		v2 := b.NewValue0(v.Pos, ssaop.OpEq8, typ.Bool)
		v3 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int8)
		v4 := b.NewValue0(v.Pos, ssaop.OpOffPtr, p.Type)
		v4.AuxInt = ssa.Int64ToAuxInt(c - 1)
		v4.AddArg(p)
		v3.AddArg2(v4, mem)
		v5 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int8)
		v6 := b.NewValue0(v.Pos, ssaop.OpOffPtr, q.Type)
		v6.AuxInt = ssa.Int64ToAuxInt(c - 1)
		v6.AddArg(q)
		v5.AddArg2(v6, mem)
		v2.AddArg2(v3, v5)
		v.AddArg2(v0, v2)
		return true
	}
	// match: (MemEq p q (Const64 [c]) mem)
	// cond: (c == 6 || c == 10 || c == 18) && canLoadUnaligned(config) && config.RegSize == 8
	// result: (AndB (MemEq p q (Const64 <typ.Int64> [c-2]) mem) (Eq16 (Load <typ.Int16> (OffPtr <p.Type> p [c-2]) mem) (Load <typ.Int16> (OffPtr <q.Type> q [c-2]) mem)))
	for {
		p := v_0
		q := v_1
		if v_2.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_2.AuxInt)
		mem := v_3
		if !((c == 6 || c == 10 || c == 18) && canLoadUnaligned(config) && config.RegSize == 8) {
			break
		}
		v.Reset(ssaop.OpAndB)
		v0 := b.NewValue0(v.Pos, ssaop.OpMemEq, typ.Bool)
		v1 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64)
		v1.AuxInt = ssa.Int64ToAuxInt(c - 2)
		v0.AddArg4(p, q, v1, mem)
		v2 := b.NewValue0(v.Pos, ssaop.OpEq16, typ.Bool)
		v3 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int16)
		v4 := b.NewValue0(v.Pos, ssaop.OpOffPtr, p.Type)
		v4.AuxInt = ssa.Int64ToAuxInt(c - 2)
		v4.AddArg(p)
		v3.AddArg2(v4, mem)
		v5 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int16)
		v6 := b.NewValue0(v.Pos, ssaop.OpOffPtr, q.Type)
		v6.AuxInt = ssa.Int64ToAuxInt(c - 2)
		v6.AddArg(q)
		v5.AddArg2(v6, mem)
		v2.AddArg2(v3, v5)
		v.AddArg2(v0, v2)
		return true
	}
	// match: (MemEq p q (Const64 [c]) mem)
	// cond: (c == 7 || c == 11 || c == 19 || c == 20) && canLoadUnaligned(config) && config.RegSize == 8
	// result: (AndB (MemEq p q (Const64 <typ.Int64> [min(c-3,16)]) mem) (Eq32 (Load <typ.Int32> (OffPtr <p.Type> p [c-4]) mem) (Load <typ.Int32> (OffPtr <q.Type> q [c-4]) mem)))
	for {
		p := v_0
		q := v_1
		if v_2.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_2.AuxInt)
		mem := v_3
		if !((c == 7 || c == 11 || c == 19 || c == 20) && canLoadUnaligned(config) && config.RegSize == 8) {
			break
		}
		v.Reset(ssaop.OpAndB)
		v0 := b.NewValue0(v.Pos, ssaop.OpMemEq, typ.Bool)
		v1 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64)
		v1.AuxInt = ssa.Int64ToAuxInt(min(c-3, 16))
		v0.AddArg4(p, q, v1, mem)
		v2 := b.NewValue0(v.Pos, ssaop.OpEq32, typ.Bool)
		v3 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int32)
		v4 := b.NewValue0(v.Pos, ssaop.OpOffPtr, p.Type)
		v4.AuxInt = ssa.Int64ToAuxInt(c - 4)
		v4.AddArg(p)
		v3.AddArg2(v4, mem)
		v5 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int32)
		v6 := b.NewValue0(v.Pos, ssaop.OpOffPtr, q.Type)
		v6.AuxInt = ssa.Int64ToAuxInt(c - 4)
		v6.AddArg(q)
		v5.AddArg2(v6, mem)
		v2.AddArg2(v3, v5)
		v.AddArg2(v0, v2)
		return true
	}
	// match: (MemEq p q (Const64 [c]) mem)
	// cond: ((c >= 12 && c <= 16) || (c >= 21 && c <= 24)) && canLoadUnaligned(config) && config.RegSize == 8
	// result: (AndB (MemEq p q (Const64 <typ.Int64> [8 + int64(bool2int(c>16))*8]) mem) (Eq64 (Load <typ.Int64> (OffPtr <p.Type> p [c-8]) mem) (Load <typ.Int64> (OffPtr <q.Type> q [c-8]) mem)))
	for {
		p := v_0
		q := v_1
		if v_2.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_2.AuxInt)
		mem := v_3
		if !(((c >= 12 && c <= 16) || (c >= 21 && c <= 24)) && canLoadUnaligned(config) && config.RegSize == 8) {
			break
		}
		v.Reset(ssaop.OpAndB)
		v0 := b.NewValue0(v.Pos, ssaop.OpMemEq, typ.Bool)
		v1 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64)
		v1.AuxInt = ssa.Int64ToAuxInt(8 + int64(bool2int(c > 16))*8)
		v0.AddArg4(p, q, v1, mem)
		v2 := b.NewValue0(v.Pos, ssaop.OpEq64, typ.Bool)
		v3 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int64)
		v4 := b.NewValue0(v.Pos, ssaop.OpOffPtr, p.Type)
		v4.AuxInt = ssa.Int64ToAuxInt(c - 8)
		v4.AddArg(p)
		v3.AddArg2(v4, mem)
		v5 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int64)
		v6 := b.NewValue0(v.Pos, ssaop.OpOffPtr, q.Type)
		v6.AuxInt = ssa.Int64ToAuxInt(c - 8)
		v6.AddArg(q)
		v5.AddArg2(v6, mem)
		v2.AddArg2(v3, v5)
		v.AddArg2(v0, v2)
		return true
	}
	// match: (MemEq p q (Const64 [c]) mem)
	// cond: c >= 25 && c <= 32 && canLoadUnaligned(config) && config.RegSize == 8
	// result: (AndB (MemEq p q (Const64 <typ.Int64> [16]) mem) (MemEq (OffPtr <p.Type> p [16]) (OffPtr <q.Type> q [16]) (Const64 <typ.Int64> [c-16]) mem))
	for {
		p := v_0
		q := v_1
		if v_2.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_2.AuxInt)
		mem := v_3
		if !(c >= 25 && c <= 32 && canLoadUnaligned(config) && config.RegSize == 8) {
			break
		}
		v.Reset(ssaop.OpAndB)
		v0 := b.NewValue0(v.Pos, ssaop.OpMemEq, typ.Bool)
		v1 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64)
		v1.AuxInt = ssa.Int64ToAuxInt(16)
		v0.AddArg4(p, q, v1, mem)
		v2 := b.NewValue0(v.Pos, ssaop.OpMemEq, typ.Bool)
		v3 := b.NewValue0(v.Pos, ssaop.OpOffPtr, p.Type)
		v3.AuxInt = ssa.Int64ToAuxInt(16)
		v3.AddArg(p)
		v4 := b.NewValue0(v.Pos, ssaop.OpOffPtr, q.Type)
		v4.AuxInt = ssa.Int64ToAuxInt(16)
		v4.AddArg(q)
		v5 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64)
		v5.AuxInt = ssa.Int64ToAuxInt(c - 16)
		v2.AddArg4(v3, v4, v5, mem)
		v.AddArg2(v0, v2)
		return true
	}
	return false
}
func rewriteValue_OpMod16(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Mod16 (Const16 [c]) (Const16 [d]))
	// cond: d != 0
	// result: (Const16 [c % d])
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		d := ssa.AuxIntToInt16(v_1.AuxInt)
		if !(d != 0) {
			break
		}
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(c % d)
		return true
	}
	// match: (Mod16 <t> n (Const16 [c]))
	// cond: isNonNegative(n) && ssa.IsPowerOfTwo(c)
	// result: (And16 n (Const16 <t> [c-1]))
	for {
		t := v.Type
		n := v_0
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_1.AuxInt)
		if !(isNonNegative(n) && ssa.IsPowerOfTwo(c)) {
			break
		}
		v.Reset(ssaop.OpAnd16)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
		v0.AuxInt = ssa.Int16ToAuxInt(c - 1)
		v.AddArg2(n, v0)
		return true
	}
	// match: (Mod16 <t> n (Const16 [c]))
	// cond: c < 0 && c != -1<<15
	// result: (Mod16 <t> n (Const16 <t> [-c]))
	for {
		t := v.Type
		n := v_0
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_1.AuxInt)
		if !(c < 0 && c != -1<<15) {
			break
		}
		v.Reset(ssaop.OpMod16)
		v.Type = t
		v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
		v0.AuxInt = ssa.Int16ToAuxInt(-c)
		v.AddArg2(n, v0)
		return true
	}
	// match: (Mod16 <t> x (Const16 [c]))
	// cond: x.Op != ssaop.OpConst16 && (c > 0 || c == -1<<15)
	// result: (Sub16 x (Mul16 <t> (Div16 <t> x (Const16 <t> [c])) (Const16 <t> [c])))
	for {
		t := v.Type
		x := v_0
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_1.AuxInt)
		if !(x.Op != ssaop.OpConst16 && (c > 0 || c == -1<<15)) {
			break
		}
		v.Reset(ssaop.OpSub16)
		v0 := b.NewValue0(v.Pos, ssaop.OpMul16, t)
		v1 := b.NewValue0(v.Pos, ssaop.OpDiv16, t)
		v2 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
		v2.AuxInt = ssa.Int16ToAuxInt(c)
		v1.AddArg2(x, v2)
		v0.AddArg2(v1, v2)
		v.AddArg2(x, v0)
		return true
	}
	return false
}
func rewriteValue_OpMod16u(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Mod16u (Const16 [c]) (Const16 [d]))
	// cond: d != 0
	// result: (Const16 [int16(uint16(c) % uint16(d))])
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		d := ssa.AuxIntToInt16(v_1.AuxInt)
		if !(d != 0) {
			break
		}
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(int16(uint16(c) % uint16(d)))
		return true
	}
	// match: (Mod16u <t> n (Const16 [c]))
	// cond: ssa.IsPowerOfTwo(uint16(c))
	// result: (And16 n (Const16 <t> [c-1]))
	for {
		t := v.Type
		n := v_0
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_1.AuxInt)
		if !(ssa.IsPowerOfTwo(uint16(c))) {
			break
		}
		v.Reset(ssaop.OpAnd16)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
		v0.AuxInt = ssa.Int16ToAuxInt(c - 1)
		v.AddArg2(n, v0)
		return true
	}
	// match: (Mod16u <t> x (Const16 [c]))
	// cond: x.Op != ssaop.OpConst16 && c != 0
	// result: (Sub16 x (Mul16 <t> (Div16u <t> x (Const16 <t> [c])) (Const16 <t> [c])))
	for {
		t := v.Type
		x := v_0
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_1.AuxInt)
		if !(x.Op != ssaop.OpConst16 && c != 0) {
			break
		}
		v.Reset(ssaop.OpSub16)
		v0 := b.NewValue0(v.Pos, ssaop.OpMul16, t)
		v1 := b.NewValue0(v.Pos, ssaop.OpDiv16u, t)
		v2 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
		v2.AuxInt = ssa.Int16ToAuxInt(c)
		v1.AddArg2(x, v2)
		v0.AddArg2(v1, v2)
		v.AddArg2(x, v0)
		return true
	}
	return false
}
func rewriteValue_OpMod32(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Mod32 (Const32 [c]) (Const32 [d]))
	// cond: d != 0
	// result: (Const32 [c % d])
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		d := ssa.AuxIntToInt32(v_1.AuxInt)
		if !(d != 0) {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(c % d)
		return true
	}
	// match: (Mod32 <t> n (Const32 [c]))
	// cond: isNonNegative(n) && ssa.IsPowerOfTwo(c)
	// result: (And32 n (Const32 <t> [c-1]))
	for {
		t := v.Type
		n := v_0
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_1.AuxInt)
		if !(isNonNegative(n) && ssa.IsPowerOfTwo(c)) {
			break
		}
		v.Reset(ssaop.OpAnd32)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
		v0.AuxInt = ssa.Int32ToAuxInt(c - 1)
		v.AddArg2(n, v0)
		return true
	}
	// match: (Mod32 <t> n (Const32 [c]))
	// cond: c < 0 && c != -1<<31
	// result: (Mod32 <t> n (Const32 <t> [-c]))
	for {
		t := v.Type
		n := v_0
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_1.AuxInt)
		if !(c < 0 && c != -1<<31) {
			break
		}
		v.Reset(ssaop.OpMod32)
		v.Type = t
		v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
		v0.AuxInt = ssa.Int32ToAuxInt(-c)
		v.AddArg2(n, v0)
		return true
	}
	// match: (Mod32 <t> x (Const32 [c]))
	// cond: x.Op != ssaop.OpConst32 && (c > 0 || c == -1<<31)
	// result: (Sub32 x (Mul32 <t> (Div32 <t> x (Const32 <t> [c])) (Const32 <t> [c])))
	for {
		t := v.Type
		x := v_0
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_1.AuxInt)
		if !(x.Op != ssaop.OpConst32 && (c > 0 || c == -1<<31)) {
			break
		}
		v.Reset(ssaop.OpSub32)
		v0 := b.NewValue0(v.Pos, ssaop.OpMul32, t)
		v1 := b.NewValue0(v.Pos, ssaop.OpDiv32, t)
		v2 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
		v2.AuxInt = ssa.Int32ToAuxInt(c)
		v1.AddArg2(x, v2)
		v0.AddArg2(v1, v2)
		v.AddArg2(x, v0)
		return true
	}
	return false
}
func rewriteValue_OpMod32u(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Mod32u (Const32 [c]) (Const32 [d]))
	// cond: d != 0
	// result: (Const32 [int32(uint32(c) % uint32(d))])
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		d := ssa.AuxIntToInt32(v_1.AuxInt)
		if !(d != 0) {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(int32(uint32(c) % uint32(d)))
		return true
	}
	// match: (Mod32u <t> n (Const32 [c]))
	// cond: ssa.IsPowerOfTwo(uint32(c))
	// result: (And32 n (Const32 <t> [c-1]))
	for {
		t := v.Type
		n := v_0
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_1.AuxInt)
		if !(ssa.IsPowerOfTwo(uint32(c))) {
			break
		}
		v.Reset(ssaop.OpAnd32)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
		v0.AuxInt = ssa.Int32ToAuxInt(c - 1)
		v.AddArg2(n, v0)
		return true
	}
	// match: (Mod32u <t> x (Const32 [c]))
	// cond: x.Op != ssaop.OpConst32 && c != 0
	// result: (Sub32 x (Mul32 <t> (Div32u <t> x (Const32 <t> [c])) (Const32 <t> [c])))
	for {
		t := v.Type
		x := v_0
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_1.AuxInt)
		if !(x.Op != ssaop.OpConst32 && c != 0) {
			break
		}
		v.Reset(ssaop.OpSub32)
		v0 := b.NewValue0(v.Pos, ssaop.OpMul32, t)
		v1 := b.NewValue0(v.Pos, ssaop.OpDiv32u, t)
		v2 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
		v2.AuxInt = ssa.Int32ToAuxInt(c)
		v1.AddArg2(x, v2)
		v0.AddArg2(v1, v2)
		v.AddArg2(x, v0)
		return true
	}
	return false
}
func rewriteValue_OpMod64(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Mod64 (Const64 [c]) (Const64 [d]))
	// cond: d != 0
	// result: (Const64 [c % d])
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(d != 0) {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(c % d)
		return true
	}
	// match: (Mod64 <t> n (Const64 [c]))
	// cond: isNonNegative(n) && ssa.IsPowerOfTwo(c)
	// result: (And64 n (Const64 <t> [c-1]))
	for {
		t := v.Type
		n := v_0
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(isNonNegative(n) && ssa.IsPowerOfTwo(c)) {
			break
		}
		v.Reset(ssaop.OpAnd64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(c - 1)
		v.AddArg2(n, v0)
		return true
	}
	// match: (Mod64 n (Const64 [-1<<63]))
	// cond: isNonNegative(n)
	// result: n
	for {
		n := v_0
		if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != -1<<63 || !(isNonNegative(n)) {
			break
		}
		v.CopyOf(n)
		return true
	}
	// match: (Mod64 <t> n (Const64 [c]))
	// cond: c < 0 && c != -1<<63
	// result: (Mod64 <t> n (Const64 <t> [-c]))
	for {
		t := v.Type
		n := v_0
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(c < 0 && c != -1<<63) {
			break
		}
		v.Reset(ssaop.OpMod64)
		v.Type = t
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(-c)
		v.AddArg2(n, v0)
		return true
	}
	// match: (Mod64 <t> x (Const64 [c]))
	// cond: x.Op != ssaop.OpConst64 && (c > 0 || c == -1<<63)
	// result: (Sub64 x (Mul64 <t> (Div64 <t> x (Const64 <t> [c])) (Const64 <t> [c])))
	for {
		t := v.Type
		x := v_0
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(x.Op != ssaop.OpConst64 && (c > 0 || c == -1<<63)) {
			break
		}
		v.Reset(ssaop.OpSub64)
		v0 := b.NewValue0(v.Pos, ssaop.OpMul64, t)
		v1 := b.NewValue0(v.Pos, ssaop.OpDiv64, t)
		v2 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v2.AuxInt = ssa.Int64ToAuxInt(c)
		v1.AddArg2(x, v2)
		v0.AddArg2(v1, v2)
		v.AddArg2(x, v0)
		return true
	}
	return false
}
func rewriteValue_OpMod64u(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Mod64u (Const64 [c]) (Const64 [d]))
	// cond: d != 0
	// result: (Const64 [int64(uint64(c) % uint64(d))])
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(d != 0) {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(int64(uint64(c) % uint64(d)))
		return true
	}
	// match: (Mod64u <t> n (Const64 [c]))
	// cond: ssa.IsPowerOfTwo(uint64(c))
	// result: (And64 n (Const64 <t> [c-1]))
	for {
		t := v.Type
		n := v_0
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(ssa.IsPowerOfTwo(uint64(c))) {
			break
		}
		v.Reset(ssaop.OpAnd64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(c - 1)
		v.AddArg2(n, v0)
		return true
	}
	// match: (Mod64u <t> x (Const64 [c]))
	// cond: x.Op != ssaop.OpConst64 && c != 0
	// result: (Sub64 x (Mul64 <t> (Div64u <t> x (Const64 <t> [c])) (Const64 <t> [c])))
	for {
		t := v.Type
		x := v_0
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(x.Op != ssaop.OpConst64 && c != 0) {
			break
		}
		v.Reset(ssaop.OpSub64)
		v0 := b.NewValue0(v.Pos, ssaop.OpMul64, t)
		v1 := b.NewValue0(v.Pos, ssaop.OpDiv64u, t)
		v2 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v2.AuxInt = ssa.Int64ToAuxInt(c)
		v1.AddArg2(x, v2)
		v0.AddArg2(v1, v2)
		v.AddArg2(x, v0)
		return true
	}
	return false
}
func rewriteValue_OpMod8(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Mod8 (Const8 [c]) (Const8 [d]))
	// cond: d != 0
	// result: (Const8 [c % d])
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		d := ssa.AuxIntToInt8(v_1.AuxInt)
		if !(d != 0) {
			break
		}
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(c % d)
		return true
	}
	// match: (Mod8 <t> n (Const8 [c]))
	// cond: isNonNegative(n) && ssa.IsPowerOfTwo(c)
	// result: (And8 n (Const8 <t> [c-1]))
	for {
		t := v.Type
		n := v_0
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_1.AuxInt)
		if !(isNonNegative(n) && ssa.IsPowerOfTwo(c)) {
			break
		}
		v.Reset(ssaop.OpAnd8)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
		v0.AuxInt = ssa.Int8ToAuxInt(c - 1)
		v.AddArg2(n, v0)
		return true
	}
	// match: (Mod8 <t> n (Const8 [c]))
	// cond: c < 0 && c != -1<<7
	// result: (Mod8 <t> n (Const8 <t> [-c]))
	for {
		t := v.Type
		n := v_0
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_1.AuxInt)
		if !(c < 0 && c != -1<<7) {
			break
		}
		v.Reset(ssaop.OpMod8)
		v.Type = t
		v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
		v0.AuxInt = ssa.Int8ToAuxInt(-c)
		v.AddArg2(n, v0)
		return true
	}
	// match: (Mod8 <t> x (Const8 [c]))
	// cond: x.Op != ssaop.OpConst8 && (c > 0 || c == -1<<7)
	// result: (Sub8 x (Mul8 <t> (Div8 <t> x (Const8 <t> [c])) (Const8 <t> [c])))
	for {
		t := v.Type
		x := v_0
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_1.AuxInt)
		if !(x.Op != ssaop.OpConst8 && (c > 0 || c == -1<<7)) {
			break
		}
		v.Reset(ssaop.OpSub8)
		v0 := b.NewValue0(v.Pos, ssaop.OpMul8, t)
		v1 := b.NewValue0(v.Pos, ssaop.OpDiv8, t)
		v2 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
		v2.AuxInt = ssa.Int8ToAuxInt(c)
		v1.AddArg2(x, v2)
		v0.AddArg2(v1, v2)
		v.AddArg2(x, v0)
		return true
	}
	return false
}
func rewriteValue_OpMod8u(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Mod8u (Const8 [c]) (Const8 [d]))
	// cond: d != 0
	// result: (Const8 [int8(uint8(c) % uint8(d))])
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		d := ssa.AuxIntToInt8(v_1.AuxInt)
		if !(d != 0) {
			break
		}
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(int8(uint8(c) % uint8(d)))
		return true
	}
	// match: (Mod8u <t> n (Const8 [c]))
	// cond: ssa.IsPowerOfTwo(uint8(c))
	// result: (And8 n (Const8 <t> [c-1]))
	for {
		t := v.Type
		n := v_0
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_1.AuxInt)
		if !(ssa.IsPowerOfTwo(uint8(c))) {
			break
		}
		v.Reset(ssaop.OpAnd8)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
		v0.AuxInt = ssa.Int8ToAuxInt(c - 1)
		v.AddArg2(n, v0)
		return true
	}
	// match: (Mod8u <t> x (Const8 [c]))
	// cond: x.Op != ssaop.OpConst8 && c != 0
	// result: (Sub8 x (Mul8 <t> (Div8u <t> x (Const8 <t> [c])) (Const8 <t> [c])))
	for {
		t := v.Type
		x := v_0
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_1.AuxInt)
		if !(x.Op != ssaop.OpConst8 && c != 0) {
			break
		}
		v.Reset(ssaop.OpSub8)
		v0 := b.NewValue0(v.Pos, ssaop.OpMul8, t)
		v1 := b.NewValue0(v.Pos, ssaop.OpDiv8u, t)
		v2 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
		v2.AuxInt = ssa.Int8ToAuxInt(c)
		v1.AddArg2(x, v2)
		v0.AddArg2(v1, v2)
		v.AddArg2(x, v0)
		return true
	}
	return false
}
func rewriteValue_OpMove(v *ssa.Value) bool {
	v_2 := v.Args[2]
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	// match: (Move {t} [n] dst1 src mem:(Zero {t} [n] dst2 _))
	// cond: ssa.IsSamePtr(src, dst2)
	// result: (Zero {t} [n] dst1 mem)
	for {
		n := ssa.AuxIntToInt64(v.AuxInt)
		t := ssa.AuxToType(v.Aux)
		dst1 := v_0
		src := v_1
		mem := v_2
		if mem.Op != ssaop.OpZero || ssa.AuxIntToInt64(mem.AuxInt) != n || ssa.AuxToType(mem.Aux) != t {
			break
		}
		dst2 := mem.Args[0]
		if !(ssa.IsSamePtr(src, dst2)) {
			break
		}
		v.Reset(ssaop.OpZero)
		v.AuxInt = ssa.Int64ToAuxInt(n)
		v.Aux = ssa.TypeToAux(t)
		v.AddArg2(dst1, mem)
		return true
	}
	// match: (Move {t} [n] dst1 src mem:(VarDef (Zero {t} [n] dst0 _)))
	// cond: ssa.IsSamePtr(src, dst0)
	// result: (Zero {t} [n] dst1 mem)
	for {
		n := ssa.AuxIntToInt64(v.AuxInt)
		t := ssa.AuxToType(v.Aux)
		dst1 := v_0
		src := v_1
		mem := v_2
		if mem.Op != ssaop.OpVarDef {
			break
		}
		mem_0 := mem.Args[0]
		if mem_0.Op != ssaop.OpZero || ssa.AuxIntToInt64(mem_0.AuxInt) != n || ssa.AuxToType(mem_0.Aux) != t {
			break
		}
		dst0 := mem_0.Args[0]
		if !(ssa.IsSamePtr(src, dst0)) {
			break
		}
		v.Reset(ssaop.OpZero)
		v.AuxInt = ssa.Int64ToAuxInt(n)
		v.Aux = ssa.TypeToAux(t)
		v.AddArg2(dst1, mem)
		return true
	}
	// match: (Move {t} [n] dst (Addr {sym} (SB)) mem)
	// cond: symIsROZero(sym)
	// result: (Zero {t} [n] dst mem)
	for {
		n := ssa.AuxIntToInt64(v.AuxInt)
		t := ssa.AuxToType(v.Aux)
		dst := v_0
		if v_1.Op != ssaop.OpAddr {
			break
		}
		sym := ssa.AuxToSym(v_1.Aux)
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpSB {
			break
		}
		mem := v_2
		if !(symIsROZero(sym)) {
			break
		}
		v.Reset(ssaop.OpZero)
		v.AuxInt = ssa.Int64ToAuxInt(n)
		v.Aux = ssa.TypeToAux(t)
		v.AddArg2(dst, mem)
		return true
	}
	// match: (Move {t1} [n] dst1 src1 store:(Store {t2} op1:(OffPtr [o2] dst2) _ mem))
	// cond: ssa.IsSamePtr(dst1, dst2) && store.Uses == 1 && n >= o2 + t2.Size() && ssa.Disjoint1(src1, n, op1, t2.Size()) && ssa.Clobber(store)
	// result: (Move {t1} [n] dst1 src1 mem)
	for {
		n := ssa.AuxIntToInt64(v.AuxInt)
		t1 := ssa.AuxToType(v.Aux)
		dst1 := v_0
		src1 := v_1
		store := v_2
		if store.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(store.Aux)
		mem := store.Args[2]
		op1 := store.Args[0]
		if op1.Op != ssaop.OpOffPtr {
			break
		}
		o2 := ssa.AuxIntToInt64(op1.AuxInt)
		dst2 := op1.Args[0]
		if !(ssa.IsSamePtr(dst1, dst2) && store.Uses == 1 && n >= o2+t2.Size() && ssa.Disjoint1(src1, n, op1, t2.Size()) && ssa.Clobber(store)) {
			break
		}
		v.Reset(ssaop.OpMove)
		v.AuxInt = ssa.Int64ToAuxInt(n)
		v.Aux = ssa.TypeToAux(t1)
		v.AddArg3(dst1, src1, mem)
		return true
	}
	// match: (Move {t} [n] dst1 src1 move:(Move {t} [n] dst2 _ mem))
	// cond: move.Uses == 1 && ssa.IsSamePtr(dst1, dst2) && ssa.Disjoint1(src1, n, dst2, n) && ssa.Clobber(move)
	// result: (Move {t} [n] dst1 src1 mem)
	for {
		n := ssa.AuxIntToInt64(v.AuxInt)
		t := ssa.AuxToType(v.Aux)
		dst1 := v_0
		src1 := v_1
		move := v_2
		if move.Op != ssaop.OpMove || ssa.AuxIntToInt64(move.AuxInt) != n || ssa.AuxToType(move.Aux) != t {
			break
		}
		mem := move.Args[2]
		dst2 := move.Args[0]
		if !(move.Uses == 1 && ssa.IsSamePtr(dst1, dst2) && ssa.Disjoint1(src1, n, dst2, n) && ssa.Clobber(move)) {
			break
		}
		v.Reset(ssaop.OpMove)
		v.AuxInt = ssa.Int64ToAuxInt(n)
		v.Aux = ssa.TypeToAux(t)
		v.AddArg3(dst1, src1, mem)
		return true
	}
	// match: (Move {t} [n] dst1 src1 vardef:(VarDef {x} move:(Move {t} [n] dst2 _ mem)))
	// cond: move.Uses == 1 && vardef.Uses == 1 && ssa.IsSamePtr(dst1, dst2) && ssa.Disjoint1(src1, n, dst2, n) && ssa.Clobber(move, vardef)
	// result: (Move {t} [n] dst1 src1 (VarDef {x} mem))
	for {
		n := ssa.AuxIntToInt64(v.AuxInt)
		t := ssa.AuxToType(v.Aux)
		dst1 := v_0
		src1 := v_1
		vardef := v_2
		if vardef.Op != ssaop.OpVarDef {
			break
		}
		x := ssa.AuxToSym(vardef.Aux)
		move := vardef.Args[0]
		if move.Op != ssaop.OpMove || ssa.AuxIntToInt64(move.AuxInt) != n || ssa.AuxToType(move.Aux) != t {
			break
		}
		mem := move.Args[2]
		dst2 := move.Args[0]
		if !(move.Uses == 1 && vardef.Uses == 1 && ssa.IsSamePtr(dst1, dst2) && ssa.Disjoint1(src1, n, dst2, n) && ssa.Clobber(move, vardef)) {
			break
		}
		v.Reset(ssaop.OpMove)
		v.AuxInt = ssa.Int64ToAuxInt(n)
		v.Aux = ssa.TypeToAux(t)
		v0 := b.NewValue0(v.Pos, ssaop.OpVarDef, types.TypeMem)
		v0.Aux = ssa.SymToAux(x)
		v0.AddArg(mem)
		v.AddArg3(dst1, src1, v0)
		return true
	}
	// match: (Move {t} [n] dst1 src1 zero:(Zero {t} [n] dst2 mem))
	// cond: zero.Uses == 1 && ssa.IsSamePtr(dst1, dst2) && ssa.Disjoint1(src1, n, dst2, n) && ssa.Clobber(zero)
	// result: (Move {t} [n] dst1 src1 mem)
	for {
		n := ssa.AuxIntToInt64(v.AuxInt)
		t := ssa.AuxToType(v.Aux)
		dst1 := v_0
		src1 := v_1
		zero := v_2
		if zero.Op != ssaop.OpZero || ssa.AuxIntToInt64(zero.AuxInt) != n || ssa.AuxToType(zero.Aux) != t {
			break
		}
		mem := zero.Args[1]
		dst2 := zero.Args[0]
		if !(zero.Uses == 1 && ssa.IsSamePtr(dst1, dst2) && ssa.Disjoint1(src1, n, dst2, n) && ssa.Clobber(zero)) {
			break
		}
		v.Reset(ssaop.OpMove)
		v.AuxInt = ssa.Int64ToAuxInt(n)
		v.Aux = ssa.TypeToAux(t)
		v.AddArg3(dst1, src1, mem)
		return true
	}
	// match: (Move {t} [n] dst1 src1 vardef:(VarDef {x} zero:(Zero {t} [n] dst2 mem)))
	// cond: zero.Uses == 1 && vardef.Uses == 1 && ssa.IsSamePtr(dst1, dst2) && ssa.Disjoint1(src1, n, dst2, n) && ssa.Clobber(zero, vardef)
	// result: (Move {t} [n] dst1 src1 (VarDef {x} mem))
	for {
		n := ssa.AuxIntToInt64(v.AuxInt)
		t := ssa.AuxToType(v.Aux)
		dst1 := v_0
		src1 := v_1
		vardef := v_2
		if vardef.Op != ssaop.OpVarDef {
			break
		}
		x := ssa.AuxToSym(vardef.Aux)
		zero := vardef.Args[0]
		if zero.Op != ssaop.OpZero || ssa.AuxIntToInt64(zero.AuxInt) != n || ssa.AuxToType(zero.Aux) != t {
			break
		}
		mem := zero.Args[1]
		dst2 := zero.Args[0]
		if !(zero.Uses == 1 && vardef.Uses == 1 && ssa.IsSamePtr(dst1, dst2) && ssa.Disjoint1(src1, n, dst2, n) && ssa.Clobber(zero, vardef)) {
			break
		}
		v.Reset(ssaop.OpMove)
		v.AuxInt = ssa.Int64ToAuxInt(n)
		v.Aux = ssa.TypeToAux(t)
		v0 := b.NewValue0(v.Pos, ssaop.OpVarDef, types.TypeMem)
		v0.Aux = ssa.SymToAux(x)
		v0.AddArg(mem)
		v.AddArg3(dst1, src1, v0)
		return true
	}
	// match: (Move {t1} [n] dst p1 mem:(Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Store {t3} op3:(OffPtr <tt3> [0] p3) d2 _)))
	// cond: ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && o2 == t3.Size() && n == t2.Size() + t3.Size()
	// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [0] dst) d2 mem))
	for {
		n := ssa.AuxIntToInt64(v.AuxInt)
		t1 := ssa.AuxToType(v.Aux)
		dst := v_0
		p1 := v_1
		mem := v_2
		if mem.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(mem.Aux)
		_ = mem.Args[2]
		op2 := mem.Args[0]
		if op2.Op != ssaop.OpOffPtr {
			break
		}
		tt2 := op2.Type
		o2 := ssa.AuxIntToInt64(op2.AuxInt)
		p2 := op2.Args[0]
		d1 := mem.Args[1]
		mem_2 := mem.Args[2]
		if mem_2.Op != ssaop.OpStore {
			break
		}
		t3 := ssa.AuxToType(mem_2.Aux)
		d2 := mem_2.Args[1]
		op3 := mem_2.Args[0]
		if op3.Op != ssaop.OpOffPtr {
			break
		}
		tt3 := op3.Type
		if ssa.AuxIntToInt64(op3.AuxInt) != 0 {
			break
		}
		p3 := op3.Args[0]
		if !(ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && o2 == t3.Size() && n == t2.Size()+t3.Size()) {
			break
		}
		v.Reset(ssaop.OpStore)
		v.Aux = ssa.TypeToAux(t2)
		v0 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt2)
		v0.AuxInt = ssa.Int64ToAuxInt(o2)
		v0.AddArg(dst)
		v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v1.Aux = ssa.TypeToAux(t3)
		v2 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt3)
		v2.AuxInt = ssa.Int64ToAuxInt(0)
		v2.AddArg(dst)
		v1.AddArg3(v2, d2, mem)
		v.AddArg3(v0, d1, v1)
		return true
	}
	// match: (Move {t1} [n] dst p1 mem:(Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Store {t3} op3:(OffPtr <tt3> [o3] p3) d2 (Store {t4} op4:(OffPtr <tt4> [0] p4) d3 _))))
	// cond: ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && o3 == t4.Size() && o2-o3 == t3.Size() && n == t2.Size() + t3.Size() + t4.Size()
	// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [0] dst) d3 mem)))
	for {
		n := ssa.AuxIntToInt64(v.AuxInt)
		t1 := ssa.AuxToType(v.Aux)
		dst := v_0
		p1 := v_1
		mem := v_2
		if mem.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(mem.Aux)
		_ = mem.Args[2]
		op2 := mem.Args[0]
		if op2.Op != ssaop.OpOffPtr {
			break
		}
		tt2 := op2.Type
		o2 := ssa.AuxIntToInt64(op2.AuxInt)
		p2 := op2.Args[0]
		d1 := mem.Args[1]
		mem_2 := mem.Args[2]
		if mem_2.Op != ssaop.OpStore {
			break
		}
		t3 := ssa.AuxToType(mem_2.Aux)
		_ = mem_2.Args[2]
		op3 := mem_2.Args[0]
		if op3.Op != ssaop.OpOffPtr {
			break
		}
		tt3 := op3.Type
		o3 := ssa.AuxIntToInt64(op3.AuxInt)
		p3 := op3.Args[0]
		d2 := mem_2.Args[1]
		mem_2_2 := mem_2.Args[2]
		if mem_2_2.Op != ssaop.OpStore {
			break
		}
		t4 := ssa.AuxToType(mem_2_2.Aux)
		d3 := mem_2_2.Args[1]
		op4 := mem_2_2.Args[0]
		if op4.Op != ssaop.OpOffPtr {
			break
		}
		tt4 := op4.Type
		if ssa.AuxIntToInt64(op4.AuxInt) != 0 {
			break
		}
		p4 := op4.Args[0]
		if !(ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && o3 == t4.Size() && o2-o3 == t3.Size() && n == t2.Size()+t3.Size()+t4.Size()) {
			break
		}
		v.Reset(ssaop.OpStore)
		v.Aux = ssa.TypeToAux(t2)
		v0 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt2)
		v0.AuxInt = ssa.Int64ToAuxInt(o2)
		v0.AddArg(dst)
		v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v1.Aux = ssa.TypeToAux(t3)
		v2 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt3)
		v2.AuxInt = ssa.Int64ToAuxInt(o3)
		v2.AddArg(dst)
		v3 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v3.Aux = ssa.TypeToAux(t4)
		v4 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt4)
		v4.AuxInt = ssa.Int64ToAuxInt(0)
		v4.AddArg(dst)
		v3.AddArg3(v4, d3, mem)
		v1.AddArg3(v2, d2, v3)
		v.AddArg3(v0, d1, v1)
		return true
	}
	// match: (Move {t1} [n] dst p1 mem:(Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Store {t3} op3:(OffPtr <tt3> [o3] p3) d2 (Store {t4} op4:(OffPtr <tt4> [o4] p4) d3 (Store {t5} op5:(OffPtr <tt5> [0] p5) d4 _)))))
	// cond: ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.IsSamePtr(p4, p5) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && t5.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && o4 == t5.Size() && o3-o4 == t4.Size() && o2-o3 == t3.Size() && n == t2.Size() + t3.Size() + t4.Size() + t5.Size()
	// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [o4] dst) d3 (Store {t5} (OffPtr <tt5> [0] dst) d4 mem))))
	for {
		n := ssa.AuxIntToInt64(v.AuxInt)
		t1 := ssa.AuxToType(v.Aux)
		dst := v_0
		p1 := v_1
		mem := v_2
		if mem.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(mem.Aux)
		_ = mem.Args[2]
		op2 := mem.Args[0]
		if op2.Op != ssaop.OpOffPtr {
			break
		}
		tt2 := op2.Type
		o2 := ssa.AuxIntToInt64(op2.AuxInt)
		p2 := op2.Args[0]
		d1 := mem.Args[1]
		mem_2 := mem.Args[2]
		if mem_2.Op != ssaop.OpStore {
			break
		}
		t3 := ssa.AuxToType(mem_2.Aux)
		_ = mem_2.Args[2]
		op3 := mem_2.Args[0]
		if op3.Op != ssaop.OpOffPtr {
			break
		}
		tt3 := op3.Type
		o3 := ssa.AuxIntToInt64(op3.AuxInt)
		p3 := op3.Args[0]
		d2 := mem_2.Args[1]
		mem_2_2 := mem_2.Args[2]
		if mem_2_2.Op != ssaop.OpStore {
			break
		}
		t4 := ssa.AuxToType(mem_2_2.Aux)
		_ = mem_2_2.Args[2]
		op4 := mem_2_2.Args[0]
		if op4.Op != ssaop.OpOffPtr {
			break
		}
		tt4 := op4.Type
		o4 := ssa.AuxIntToInt64(op4.AuxInt)
		p4 := op4.Args[0]
		d3 := mem_2_2.Args[1]
		mem_2_2_2 := mem_2_2.Args[2]
		if mem_2_2_2.Op != ssaop.OpStore {
			break
		}
		t5 := ssa.AuxToType(mem_2_2_2.Aux)
		d4 := mem_2_2_2.Args[1]
		op5 := mem_2_2_2.Args[0]
		if op5.Op != ssaop.OpOffPtr {
			break
		}
		tt5 := op5.Type
		if ssa.AuxIntToInt64(op5.AuxInt) != 0 {
			break
		}
		p5 := op5.Args[0]
		if !(ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.IsSamePtr(p4, p5) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && t5.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && o4 == t5.Size() && o3-o4 == t4.Size() && o2-o3 == t3.Size() && n == t2.Size()+t3.Size()+t4.Size()+t5.Size()) {
			break
		}
		v.Reset(ssaop.OpStore)
		v.Aux = ssa.TypeToAux(t2)
		v0 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt2)
		v0.AuxInt = ssa.Int64ToAuxInt(o2)
		v0.AddArg(dst)
		v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v1.Aux = ssa.TypeToAux(t3)
		v2 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt3)
		v2.AuxInt = ssa.Int64ToAuxInt(o3)
		v2.AddArg(dst)
		v3 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v3.Aux = ssa.TypeToAux(t4)
		v4 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt4)
		v4.AuxInt = ssa.Int64ToAuxInt(o4)
		v4.AddArg(dst)
		v5 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v5.Aux = ssa.TypeToAux(t5)
		v6 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt5)
		v6.AuxInt = ssa.Int64ToAuxInt(0)
		v6.AddArg(dst)
		v5.AddArg3(v6, d4, mem)
		v3.AddArg3(v4, d3, v5)
		v1.AddArg3(v2, d2, v3)
		v.AddArg3(v0, d1, v1)
		return true
	}
	// match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Store {t3} op3:(OffPtr <tt3> [0] p3) d2 _))))
	// cond: ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && o2 == t3.Size() && n == t2.Size() + t3.Size()
	// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [0] dst) d2 mem))
	for {
		n := ssa.AuxIntToInt64(v.AuxInt)
		t1 := ssa.AuxToType(v.Aux)
		dst := v_0
		p1 := v_1
		mem := v_2
		if mem.Op != ssaop.OpVarDef {
			break
		}
		mem_0 := mem.Args[0]
		if mem_0.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(mem_0.Aux)
		_ = mem_0.Args[2]
		op2 := mem_0.Args[0]
		if op2.Op != ssaop.OpOffPtr {
			break
		}
		tt2 := op2.Type
		o2 := ssa.AuxIntToInt64(op2.AuxInt)
		p2 := op2.Args[0]
		d1 := mem_0.Args[1]
		mem_0_2 := mem_0.Args[2]
		if mem_0_2.Op != ssaop.OpStore {
			break
		}
		t3 := ssa.AuxToType(mem_0_2.Aux)
		d2 := mem_0_2.Args[1]
		op3 := mem_0_2.Args[0]
		if op3.Op != ssaop.OpOffPtr {
			break
		}
		tt3 := op3.Type
		if ssa.AuxIntToInt64(op3.AuxInt) != 0 {
			break
		}
		p3 := op3.Args[0]
		if !(ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && o2 == t3.Size() && n == t2.Size()+t3.Size()) {
			break
		}
		v.Reset(ssaop.OpStore)
		v.Aux = ssa.TypeToAux(t2)
		v0 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt2)
		v0.AuxInt = ssa.Int64ToAuxInt(o2)
		v0.AddArg(dst)
		v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v1.Aux = ssa.TypeToAux(t3)
		v2 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt3)
		v2.AuxInt = ssa.Int64ToAuxInt(0)
		v2.AddArg(dst)
		v1.AddArg3(v2, d2, mem)
		v.AddArg3(v0, d1, v1)
		return true
	}
	// match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Store {t3} op3:(OffPtr <tt3> [o3] p3) d2 (Store {t4} op4:(OffPtr <tt4> [0] p4) d3 _)))))
	// cond: ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && o3 == t4.Size() && o2-o3 == t3.Size() && n == t2.Size() + t3.Size() + t4.Size()
	// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [0] dst) d3 mem)))
	for {
		n := ssa.AuxIntToInt64(v.AuxInt)
		t1 := ssa.AuxToType(v.Aux)
		dst := v_0
		p1 := v_1
		mem := v_2
		if mem.Op != ssaop.OpVarDef {
			break
		}
		mem_0 := mem.Args[0]
		if mem_0.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(mem_0.Aux)
		_ = mem_0.Args[2]
		op2 := mem_0.Args[0]
		if op2.Op != ssaop.OpOffPtr {
			break
		}
		tt2 := op2.Type
		o2 := ssa.AuxIntToInt64(op2.AuxInt)
		p2 := op2.Args[0]
		d1 := mem_0.Args[1]
		mem_0_2 := mem_0.Args[2]
		if mem_0_2.Op != ssaop.OpStore {
			break
		}
		t3 := ssa.AuxToType(mem_0_2.Aux)
		_ = mem_0_2.Args[2]
		op3 := mem_0_2.Args[0]
		if op3.Op != ssaop.OpOffPtr {
			break
		}
		tt3 := op3.Type
		o3 := ssa.AuxIntToInt64(op3.AuxInt)
		p3 := op3.Args[0]
		d2 := mem_0_2.Args[1]
		mem_0_2_2 := mem_0_2.Args[2]
		if mem_0_2_2.Op != ssaop.OpStore {
			break
		}
		t4 := ssa.AuxToType(mem_0_2_2.Aux)
		d3 := mem_0_2_2.Args[1]
		op4 := mem_0_2_2.Args[0]
		if op4.Op != ssaop.OpOffPtr {
			break
		}
		tt4 := op4.Type
		if ssa.AuxIntToInt64(op4.AuxInt) != 0 {
			break
		}
		p4 := op4.Args[0]
		if !(ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && o3 == t4.Size() && o2-o3 == t3.Size() && n == t2.Size()+t3.Size()+t4.Size()) {
			break
		}
		v.Reset(ssaop.OpStore)
		v.Aux = ssa.TypeToAux(t2)
		v0 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt2)
		v0.AuxInt = ssa.Int64ToAuxInt(o2)
		v0.AddArg(dst)
		v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v1.Aux = ssa.TypeToAux(t3)
		v2 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt3)
		v2.AuxInt = ssa.Int64ToAuxInt(o3)
		v2.AddArg(dst)
		v3 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v3.Aux = ssa.TypeToAux(t4)
		v4 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt4)
		v4.AuxInt = ssa.Int64ToAuxInt(0)
		v4.AddArg(dst)
		v3.AddArg3(v4, d3, mem)
		v1.AddArg3(v2, d2, v3)
		v.AddArg3(v0, d1, v1)
		return true
	}
	// match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Store {t3} op3:(OffPtr <tt3> [o3] p3) d2 (Store {t4} op4:(OffPtr <tt4> [o4] p4) d3 (Store {t5} op5:(OffPtr <tt5> [0] p5) d4 _))))))
	// cond: ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.IsSamePtr(p4, p5) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && t5.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && o4 == t5.Size() && o3-o4 == t4.Size() && o2-o3 == t3.Size() && n == t2.Size() + t3.Size() + t4.Size() + t5.Size()
	// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [o4] dst) d3 (Store {t5} (OffPtr <tt5> [0] dst) d4 mem))))
	for {
		n := ssa.AuxIntToInt64(v.AuxInt)
		t1 := ssa.AuxToType(v.Aux)
		dst := v_0
		p1 := v_1
		mem := v_2
		if mem.Op != ssaop.OpVarDef {
			break
		}
		mem_0 := mem.Args[0]
		if mem_0.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(mem_0.Aux)
		_ = mem_0.Args[2]
		op2 := mem_0.Args[0]
		if op2.Op != ssaop.OpOffPtr {
			break
		}
		tt2 := op2.Type
		o2 := ssa.AuxIntToInt64(op2.AuxInt)
		p2 := op2.Args[0]
		d1 := mem_0.Args[1]
		mem_0_2 := mem_0.Args[2]
		if mem_0_2.Op != ssaop.OpStore {
			break
		}
		t3 := ssa.AuxToType(mem_0_2.Aux)
		_ = mem_0_2.Args[2]
		op3 := mem_0_2.Args[0]
		if op3.Op != ssaop.OpOffPtr {
			break
		}
		tt3 := op3.Type
		o3 := ssa.AuxIntToInt64(op3.AuxInt)
		p3 := op3.Args[0]
		d2 := mem_0_2.Args[1]
		mem_0_2_2 := mem_0_2.Args[2]
		if mem_0_2_2.Op != ssaop.OpStore {
			break
		}
		t4 := ssa.AuxToType(mem_0_2_2.Aux)
		_ = mem_0_2_2.Args[2]
		op4 := mem_0_2_2.Args[0]
		if op4.Op != ssaop.OpOffPtr {
			break
		}
		tt4 := op4.Type
		o4 := ssa.AuxIntToInt64(op4.AuxInt)
		p4 := op4.Args[0]
		d3 := mem_0_2_2.Args[1]
		mem_0_2_2_2 := mem_0_2_2.Args[2]
		if mem_0_2_2_2.Op != ssaop.OpStore {
			break
		}
		t5 := ssa.AuxToType(mem_0_2_2_2.Aux)
		d4 := mem_0_2_2_2.Args[1]
		op5 := mem_0_2_2_2.Args[0]
		if op5.Op != ssaop.OpOffPtr {
			break
		}
		tt5 := op5.Type
		if ssa.AuxIntToInt64(op5.AuxInt) != 0 {
			break
		}
		p5 := op5.Args[0]
		if !(ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.IsSamePtr(p4, p5) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && t5.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && o4 == t5.Size() && o3-o4 == t4.Size() && o2-o3 == t3.Size() && n == t2.Size()+t3.Size()+t4.Size()+t5.Size()) {
			break
		}
		v.Reset(ssaop.OpStore)
		v.Aux = ssa.TypeToAux(t2)
		v0 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt2)
		v0.AuxInt = ssa.Int64ToAuxInt(o2)
		v0.AddArg(dst)
		v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v1.Aux = ssa.TypeToAux(t3)
		v2 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt3)
		v2.AuxInt = ssa.Int64ToAuxInt(o3)
		v2.AddArg(dst)
		v3 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v3.Aux = ssa.TypeToAux(t4)
		v4 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt4)
		v4.AuxInt = ssa.Int64ToAuxInt(o4)
		v4.AddArg(dst)
		v5 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v5.Aux = ssa.TypeToAux(t5)
		v6 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt5)
		v6.AuxInt = ssa.Int64ToAuxInt(0)
		v6.AddArg(dst)
		v5.AddArg3(v6, d4, mem)
		v3.AddArg3(v4, d3, v5)
		v1.AddArg3(v2, d2, v3)
		v.AddArg3(v0, d1, v1)
		return true
	}
	// match: (Move {t1} [n] dst p1 mem:(Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Zero {t3} [n] p3 _)))
	// cond: ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && registerizable(b, t2) && n >= o2 + t2.Size()
	// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Zero {t1} [n] dst mem))
	for {
		n := ssa.AuxIntToInt64(v.AuxInt)
		t1 := ssa.AuxToType(v.Aux)
		dst := v_0
		p1 := v_1
		mem := v_2
		if mem.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(mem.Aux)
		_ = mem.Args[2]
		op2 := mem.Args[0]
		if op2.Op != ssaop.OpOffPtr {
			break
		}
		tt2 := op2.Type
		o2 := ssa.AuxIntToInt64(op2.AuxInt)
		p2 := op2.Args[0]
		d1 := mem.Args[1]
		mem_2 := mem.Args[2]
		if mem_2.Op != ssaop.OpZero || ssa.AuxIntToInt64(mem_2.AuxInt) != n {
			break
		}
		t3 := ssa.AuxToType(mem_2.Aux)
		p3 := mem_2.Args[0]
		if !(ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && registerizable(b, t2) && n >= o2+t2.Size()) {
			break
		}
		v.Reset(ssaop.OpStore)
		v.Aux = ssa.TypeToAux(t2)
		v0 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt2)
		v0.AuxInt = ssa.Int64ToAuxInt(o2)
		v0.AddArg(dst)
		v1 := b.NewValue0(v.Pos, ssaop.OpZero, types.TypeMem)
		v1.AuxInt = ssa.Int64ToAuxInt(n)
		v1.Aux = ssa.TypeToAux(t1)
		v1.AddArg2(dst, mem)
		v.AddArg3(v0, d1, v1)
		return true
	}
	// match: (Move {t1} [n] dst p1 mem:(Store {t2} (OffPtr <tt2> [o2] p2) d1 (Store {t3} (OffPtr <tt3> [o3] p3) d2 (Zero {t4} [n] p4 _))))
	// cond: ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && n >= o2 + t2.Size() && n >= o3 + t3.Size()
	// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Zero {t1} [n] dst mem)))
	for {
		n := ssa.AuxIntToInt64(v.AuxInt)
		t1 := ssa.AuxToType(v.Aux)
		dst := v_0
		p1 := v_1
		mem := v_2
		if mem.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(mem.Aux)
		_ = mem.Args[2]
		mem_0 := mem.Args[0]
		if mem_0.Op != ssaop.OpOffPtr {
			break
		}
		tt2 := mem_0.Type
		o2 := ssa.AuxIntToInt64(mem_0.AuxInt)
		p2 := mem_0.Args[0]
		d1 := mem.Args[1]
		mem_2 := mem.Args[2]
		if mem_2.Op != ssaop.OpStore {
			break
		}
		t3 := ssa.AuxToType(mem_2.Aux)
		_ = mem_2.Args[2]
		mem_2_0 := mem_2.Args[0]
		if mem_2_0.Op != ssaop.OpOffPtr {
			break
		}
		tt3 := mem_2_0.Type
		o3 := ssa.AuxIntToInt64(mem_2_0.AuxInt)
		p3 := mem_2_0.Args[0]
		d2 := mem_2.Args[1]
		mem_2_2 := mem_2.Args[2]
		if mem_2_2.Op != ssaop.OpZero || ssa.AuxIntToInt64(mem_2_2.AuxInt) != n {
			break
		}
		t4 := ssa.AuxToType(mem_2_2.Aux)
		p4 := mem_2_2.Args[0]
		if !(ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && n >= o2+t2.Size() && n >= o3+t3.Size()) {
			break
		}
		v.Reset(ssaop.OpStore)
		v.Aux = ssa.TypeToAux(t2)
		v0 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt2)
		v0.AuxInt = ssa.Int64ToAuxInt(o2)
		v0.AddArg(dst)
		v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v1.Aux = ssa.TypeToAux(t3)
		v2 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt3)
		v2.AuxInt = ssa.Int64ToAuxInt(o3)
		v2.AddArg(dst)
		v3 := b.NewValue0(v.Pos, ssaop.OpZero, types.TypeMem)
		v3.AuxInt = ssa.Int64ToAuxInt(n)
		v3.Aux = ssa.TypeToAux(t1)
		v3.AddArg2(dst, mem)
		v1.AddArg3(v2, d2, v3)
		v.AddArg3(v0, d1, v1)
		return true
	}
	// match: (Move {t1} [n] dst p1 mem:(Store {t2} (OffPtr <tt2> [o2] p2) d1 (Store {t3} (OffPtr <tt3> [o3] p3) d2 (Store {t4} (OffPtr <tt4> [o4] p4) d3 (Zero {t5} [n] p5 _)))))
	// cond: ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.IsSamePtr(p4, p5) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && t5.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && n >= o2 + t2.Size() && n >= o3 + t3.Size() && n >= o4 + t4.Size()
	// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [o4] dst) d3 (Zero {t1} [n] dst mem))))
	for {
		n := ssa.AuxIntToInt64(v.AuxInt)
		t1 := ssa.AuxToType(v.Aux)
		dst := v_0
		p1 := v_1
		mem := v_2
		if mem.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(mem.Aux)
		_ = mem.Args[2]
		mem_0 := mem.Args[0]
		if mem_0.Op != ssaop.OpOffPtr {
			break
		}
		tt2 := mem_0.Type
		o2 := ssa.AuxIntToInt64(mem_0.AuxInt)
		p2 := mem_0.Args[0]
		d1 := mem.Args[1]
		mem_2 := mem.Args[2]
		if mem_2.Op != ssaop.OpStore {
			break
		}
		t3 := ssa.AuxToType(mem_2.Aux)
		_ = mem_2.Args[2]
		mem_2_0 := mem_2.Args[0]
		if mem_2_0.Op != ssaop.OpOffPtr {
			break
		}
		tt3 := mem_2_0.Type
		o3 := ssa.AuxIntToInt64(mem_2_0.AuxInt)
		p3 := mem_2_0.Args[0]
		d2 := mem_2.Args[1]
		mem_2_2 := mem_2.Args[2]
		if mem_2_2.Op != ssaop.OpStore {
			break
		}
		t4 := ssa.AuxToType(mem_2_2.Aux)
		_ = mem_2_2.Args[2]
		mem_2_2_0 := mem_2_2.Args[0]
		if mem_2_2_0.Op != ssaop.OpOffPtr {
			break
		}
		tt4 := mem_2_2_0.Type
		o4 := ssa.AuxIntToInt64(mem_2_2_0.AuxInt)
		p4 := mem_2_2_0.Args[0]
		d3 := mem_2_2.Args[1]
		mem_2_2_2 := mem_2_2.Args[2]
		if mem_2_2_2.Op != ssaop.OpZero || ssa.AuxIntToInt64(mem_2_2_2.AuxInt) != n {
			break
		}
		t5 := ssa.AuxToType(mem_2_2_2.Aux)
		p5 := mem_2_2_2.Args[0]
		if !(ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.IsSamePtr(p4, p5) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && t5.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && n >= o2+t2.Size() && n >= o3+t3.Size() && n >= o4+t4.Size()) {
			break
		}
		v.Reset(ssaop.OpStore)
		v.Aux = ssa.TypeToAux(t2)
		v0 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt2)
		v0.AuxInt = ssa.Int64ToAuxInt(o2)
		v0.AddArg(dst)
		v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v1.Aux = ssa.TypeToAux(t3)
		v2 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt3)
		v2.AuxInt = ssa.Int64ToAuxInt(o3)
		v2.AddArg(dst)
		v3 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v3.Aux = ssa.TypeToAux(t4)
		v4 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt4)
		v4.AuxInt = ssa.Int64ToAuxInt(o4)
		v4.AddArg(dst)
		v5 := b.NewValue0(v.Pos, ssaop.OpZero, types.TypeMem)
		v5.AuxInt = ssa.Int64ToAuxInt(n)
		v5.Aux = ssa.TypeToAux(t1)
		v5.AddArg2(dst, mem)
		v3.AddArg3(v4, d3, v5)
		v1.AddArg3(v2, d2, v3)
		v.AddArg3(v0, d1, v1)
		return true
	}
	// match: (Move {t1} [n] dst p1 mem:(Store {t2} (OffPtr <tt2> [o2] p2) d1 (Store {t3} (OffPtr <tt3> [o3] p3) d2 (Store {t4} (OffPtr <tt4> [o4] p4) d3 (Store {t5} (OffPtr <tt5> [o5] p5) d4 (Zero {t6} [n] p6 _))))))
	// cond: ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.IsSamePtr(p4, p5) && ssa.IsSamePtr(p5, p6) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && t5.Alignment() <= t1.Alignment() && t6.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && n >= o2 + t2.Size() && n >= o3 + t3.Size() && n >= o4 + t4.Size() && n >= o5 + t5.Size()
	// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [o4] dst) d3 (Store {t5} (OffPtr <tt5> [o5] dst) d4 (Zero {t1} [n] dst mem)))))
	for {
		n := ssa.AuxIntToInt64(v.AuxInt)
		t1 := ssa.AuxToType(v.Aux)
		dst := v_0
		p1 := v_1
		mem := v_2
		if mem.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(mem.Aux)
		_ = mem.Args[2]
		mem_0 := mem.Args[0]
		if mem_0.Op != ssaop.OpOffPtr {
			break
		}
		tt2 := mem_0.Type
		o2 := ssa.AuxIntToInt64(mem_0.AuxInt)
		p2 := mem_0.Args[0]
		d1 := mem.Args[1]
		mem_2 := mem.Args[2]
		if mem_2.Op != ssaop.OpStore {
			break
		}
		t3 := ssa.AuxToType(mem_2.Aux)
		_ = mem_2.Args[2]
		mem_2_0 := mem_2.Args[0]
		if mem_2_0.Op != ssaop.OpOffPtr {
			break
		}
		tt3 := mem_2_0.Type
		o3 := ssa.AuxIntToInt64(mem_2_0.AuxInt)
		p3 := mem_2_0.Args[0]
		d2 := mem_2.Args[1]
		mem_2_2 := mem_2.Args[2]
		if mem_2_2.Op != ssaop.OpStore {
			break
		}
		t4 := ssa.AuxToType(mem_2_2.Aux)
		_ = mem_2_2.Args[2]
		mem_2_2_0 := mem_2_2.Args[0]
		if mem_2_2_0.Op != ssaop.OpOffPtr {
			break
		}
		tt4 := mem_2_2_0.Type
		o4 := ssa.AuxIntToInt64(mem_2_2_0.AuxInt)
		p4 := mem_2_2_0.Args[0]
		d3 := mem_2_2.Args[1]
		mem_2_2_2 := mem_2_2.Args[2]
		if mem_2_2_2.Op != ssaop.OpStore {
			break
		}
		t5 := ssa.AuxToType(mem_2_2_2.Aux)
		_ = mem_2_2_2.Args[2]
		mem_2_2_2_0 := mem_2_2_2.Args[0]
		if mem_2_2_2_0.Op != ssaop.OpOffPtr {
			break
		}
		tt5 := mem_2_2_2_0.Type
		o5 := ssa.AuxIntToInt64(mem_2_2_2_0.AuxInt)
		p5 := mem_2_2_2_0.Args[0]
		d4 := mem_2_2_2.Args[1]
		mem_2_2_2_2 := mem_2_2_2.Args[2]
		if mem_2_2_2_2.Op != ssaop.OpZero || ssa.AuxIntToInt64(mem_2_2_2_2.AuxInt) != n {
			break
		}
		t6 := ssa.AuxToType(mem_2_2_2_2.Aux)
		p6 := mem_2_2_2_2.Args[0]
		if !(ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.IsSamePtr(p4, p5) && ssa.IsSamePtr(p5, p6) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && t5.Alignment() <= t1.Alignment() && t6.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && n >= o2+t2.Size() && n >= o3+t3.Size() && n >= o4+t4.Size() && n >= o5+t5.Size()) {
			break
		}
		v.Reset(ssaop.OpStore)
		v.Aux = ssa.TypeToAux(t2)
		v0 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt2)
		v0.AuxInt = ssa.Int64ToAuxInt(o2)
		v0.AddArg(dst)
		v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v1.Aux = ssa.TypeToAux(t3)
		v2 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt3)
		v2.AuxInt = ssa.Int64ToAuxInt(o3)
		v2.AddArg(dst)
		v3 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v3.Aux = ssa.TypeToAux(t4)
		v4 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt4)
		v4.AuxInt = ssa.Int64ToAuxInt(o4)
		v4.AddArg(dst)
		v5 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v5.Aux = ssa.TypeToAux(t5)
		v6 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt5)
		v6.AuxInt = ssa.Int64ToAuxInt(o5)
		v6.AddArg(dst)
		v7 := b.NewValue0(v.Pos, ssaop.OpZero, types.TypeMem)
		v7.AuxInt = ssa.Int64ToAuxInt(n)
		v7.Aux = ssa.TypeToAux(t1)
		v7.AddArg2(dst, mem)
		v5.AddArg3(v6, d4, v7)
		v3.AddArg3(v4, d3, v5)
		v1.AddArg3(v2, d2, v3)
		v.AddArg3(v0, d1, v1)
		return true
	}
	// match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Zero {t3} [n] p3 _))))
	// cond: ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && registerizable(b, t2) && n >= o2 + t2.Size()
	// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Zero {t1} [n] dst mem))
	for {
		n := ssa.AuxIntToInt64(v.AuxInt)
		t1 := ssa.AuxToType(v.Aux)
		dst := v_0
		p1 := v_1
		mem := v_2
		if mem.Op != ssaop.OpVarDef {
			break
		}
		mem_0 := mem.Args[0]
		if mem_0.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(mem_0.Aux)
		_ = mem_0.Args[2]
		op2 := mem_0.Args[0]
		if op2.Op != ssaop.OpOffPtr {
			break
		}
		tt2 := op2.Type
		o2 := ssa.AuxIntToInt64(op2.AuxInt)
		p2 := op2.Args[0]
		d1 := mem_0.Args[1]
		mem_0_2 := mem_0.Args[2]
		if mem_0_2.Op != ssaop.OpZero || ssa.AuxIntToInt64(mem_0_2.AuxInt) != n {
			break
		}
		t3 := ssa.AuxToType(mem_0_2.Aux)
		p3 := mem_0_2.Args[0]
		if !(ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && registerizable(b, t2) && n >= o2+t2.Size()) {
			break
		}
		v.Reset(ssaop.OpStore)
		v.Aux = ssa.TypeToAux(t2)
		v0 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt2)
		v0.AuxInt = ssa.Int64ToAuxInt(o2)
		v0.AddArg(dst)
		v1 := b.NewValue0(v.Pos, ssaop.OpZero, types.TypeMem)
		v1.AuxInt = ssa.Int64ToAuxInt(n)
		v1.Aux = ssa.TypeToAux(t1)
		v1.AddArg2(dst, mem)
		v.AddArg3(v0, d1, v1)
		return true
	}
	// match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} (OffPtr <tt2> [o2] p2) d1 (Store {t3} (OffPtr <tt3> [o3] p3) d2 (Zero {t4} [n] p4 _)))))
	// cond: ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && n >= o2 + t2.Size() && n >= o3 + t3.Size()
	// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Zero {t1} [n] dst mem)))
	for {
		n := ssa.AuxIntToInt64(v.AuxInt)
		t1 := ssa.AuxToType(v.Aux)
		dst := v_0
		p1 := v_1
		mem := v_2
		if mem.Op != ssaop.OpVarDef {
			break
		}
		mem_0 := mem.Args[0]
		if mem_0.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(mem_0.Aux)
		_ = mem_0.Args[2]
		mem_0_0 := mem_0.Args[0]
		if mem_0_0.Op != ssaop.OpOffPtr {
			break
		}
		tt2 := mem_0_0.Type
		o2 := ssa.AuxIntToInt64(mem_0_0.AuxInt)
		p2 := mem_0_0.Args[0]
		d1 := mem_0.Args[1]
		mem_0_2 := mem_0.Args[2]
		if mem_0_2.Op != ssaop.OpStore {
			break
		}
		t3 := ssa.AuxToType(mem_0_2.Aux)
		_ = mem_0_2.Args[2]
		mem_0_2_0 := mem_0_2.Args[0]
		if mem_0_2_0.Op != ssaop.OpOffPtr {
			break
		}
		tt3 := mem_0_2_0.Type
		o3 := ssa.AuxIntToInt64(mem_0_2_0.AuxInt)
		p3 := mem_0_2_0.Args[0]
		d2 := mem_0_2.Args[1]
		mem_0_2_2 := mem_0_2.Args[2]
		if mem_0_2_2.Op != ssaop.OpZero || ssa.AuxIntToInt64(mem_0_2_2.AuxInt) != n {
			break
		}
		t4 := ssa.AuxToType(mem_0_2_2.Aux)
		p4 := mem_0_2_2.Args[0]
		if !(ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && n >= o2+t2.Size() && n >= o3+t3.Size()) {
			break
		}
		v.Reset(ssaop.OpStore)
		v.Aux = ssa.TypeToAux(t2)
		v0 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt2)
		v0.AuxInt = ssa.Int64ToAuxInt(o2)
		v0.AddArg(dst)
		v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v1.Aux = ssa.TypeToAux(t3)
		v2 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt3)
		v2.AuxInt = ssa.Int64ToAuxInt(o3)
		v2.AddArg(dst)
		v3 := b.NewValue0(v.Pos, ssaop.OpZero, types.TypeMem)
		v3.AuxInt = ssa.Int64ToAuxInt(n)
		v3.Aux = ssa.TypeToAux(t1)
		v3.AddArg2(dst, mem)
		v1.AddArg3(v2, d2, v3)
		v.AddArg3(v0, d1, v1)
		return true
	}
	// match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} (OffPtr <tt2> [o2] p2) d1 (Store {t3} (OffPtr <tt3> [o3] p3) d2 (Store {t4} (OffPtr <tt4> [o4] p4) d3 (Zero {t5} [n] p5 _))))))
	// cond: ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.IsSamePtr(p4, p5) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && t5.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && n >= o2 + t2.Size() && n >= o3 + t3.Size() && n >= o4 + t4.Size()
	// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [o4] dst) d3 (Zero {t1} [n] dst mem))))
	for {
		n := ssa.AuxIntToInt64(v.AuxInt)
		t1 := ssa.AuxToType(v.Aux)
		dst := v_0
		p1 := v_1
		mem := v_2
		if mem.Op != ssaop.OpVarDef {
			break
		}
		mem_0 := mem.Args[0]
		if mem_0.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(mem_0.Aux)
		_ = mem_0.Args[2]
		mem_0_0 := mem_0.Args[0]
		if mem_0_0.Op != ssaop.OpOffPtr {
			break
		}
		tt2 := mem_0_0.Type
		o2 := ssa.AuxIntToInt64(mem_0_0.AuxInt)
		p2 := mem_0_0.Args[0]
		d1 := mem_0.Args[1]
		mem_0_2 := mem_0.Args[2]
		if mem_0_2.Op != ssaop.OpStore {
			break
		}
		t3 := ssa.AuxToType(mem_0_2.Aux)
		_ = mem_0_2.Args[2]
		mem_0_2_0 := mem_0_2.Args[0]
		if mem_0_2_0.Op != ssaop.OpOffPtr {
			break
		}
		tt3 := mem_0_2_0.Type
		o3 := ssa.AuxIntToInt64(mem_0_2_0.AuxInt)
		p3 := mem_0_2_0.Args[0]
		d2 := mem_0_2.Args[1]
		mem_0_2_2 := mem_0_2.Args[2]
		if mem_0_2_2.Op != ssaop.OpStore {
			break
		}
		t4 := ssa.AuxToType(mem_0_2_2.Aux)
		_ = mem_0_2_2.Args[2]
		mem_0_2_2_0 := mem_0_2_2.Args[0]
		if mem_0_2_2_0.Op != ssaop.OpOffPtr {
			break
		}
		tt4 := mem_0_2_2_0.Type
		o4 := ssa.AuxIntToInt64(mem_0_2_2_0.AuxInt)
		p4 := mem_0_2_2_0.Args[0]
		d3 := mem_0_2_2.Args[1]
		mem_0_2_2_2 := mem_0_2_2.Args[2]
		if mem_0_2_2_2.Op != ssaop.OpZero || ssa.AuxIntToInt64(mem_0_2_2_2.AuxInt) != n {
			break
		}
		t5 := ssa.AuxToType(mem_0_2_2_2.Aux)
		p5 := mem_0_2_2_2.Args[0]
		if !(ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.IsSamePtr(p4, p5) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && t5.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && n >= o2+t2.Size() && n >= o3+t3.Size() && n >= o4+t4.Size()) {
			break
		}
		v.Reset(ssaop.OpStore)
		v.Aux = ssa.TypeToAux(t2)
		v0 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt2)
		v0.AuxInt = ssa.Int64ToAuxInt(o2)
		v0.AddArg(dst)
		v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v1.Aux = ssa.TypeToAux(t3)
		v2 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt3)
		v2.AuxInt = ssa.Int64ToAuxInt(o3)
		v2.AddArg(dst)
		v3 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v3.Aux = ssa.TypeToAux(t4)
		v4 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt4)
		v4.AuxInt = ssa.Int64ToAuxInt(o4)
		v4.AddArg(dst)
		v5 := b.NewValue0(v.Pos, ssaop.OpZero, types.TypeMem)
		v5.AuxInt = ssa.Int64ToAuxInt(n)
		v5.Aux = ssa.TypeToAux(t1)
		v5.AddArg2(dst, mem)
		v3.AddArg3(v4, d3, v5)
		v1.AddArg3(v2, d2, v3)
		v.AddArg3(v0, d1, v1)
		return true
	}
	// match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} (OffPtr <tt2> [o2] p2) d1 (Store {t3} (OffPtr <tt3> [o3] p3) d2 (Store {t4} (OffPtr <tt4> [o4] p4) d3 (Store {t5} (OffPtr <tt5> [o5] p5) d4 (Zero {t6} [n] p6 _)))))))
	// cond: ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.IsSamePtr(p4, p5) && ssa.IsSamePtr(p5, p6) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && t5.Alignment() <= t1.Alignment() && t6.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && n >= o2 + t2.Size() && n >= o3 + t3.Size() && n >= o4 + t4.Size() && n >= o5 + t5.Size()
	// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [o4] dst) d3 (Store {t5} (OffPtr <tt5> [o5] dst) d4 (Zero {t1} [n] dst mem)))))
	for {
		n := ssa.AuxIntToInt64(v.AuxInt)
		t1 := ssa.AuxToType(v.Aux)
		dst := v_0
		p1 := v_1
		mem := v_2
		if mem.Op != ssaop.OpVarDef {
			break
		}
		mem_0 := mem.Args[0]
		if mem_0.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(mem_0.Aux)
		_ = mem_0.Args[2]
		mem_0_0 := mem_0.Args[0]
		if mem_0_0.Op != ssaop.OpOffPtr {
			break
		}
		tt2 := mem_0_0.Type
		o2 := ssa.AuxIntToInt64(mem_0_0.AuxInt)
		p2 := mem_0_0.Args[0]
		d1 := mem_0.Args[1]
		mem_0_2 := mem_0.Args[2]
		if mem_0_2.Op != ssaop.OpStore {
			break
		}
		t3 := ssa.AuxToType(mem_0_2.Aux)
		_ = mem_0_2.Args[2]
		mem_0_2_0 := mem_0_2.Args[0]
		if mem_0_2_0.Op != ssaop.OpOffPtr {
			break
		}
		tt3 := mem_0_2_0.Type
		o3 := ssa.AuxIntToInt64(mem_0_2_0.AuxInt)
		p3 := mem_0_2_0.Args[0]
		d2 := mem_0_2.Args[1]
		mem_0_2_2 := mem_0_2.Args[2]
		if mem_0_2_2.Op != ssaop.OpStore {
			break
		}
		t4 := ssa.AuxToType(mem_0_2_2.Aux)
		_ = mem_0_2_2.Args[2]
		mem_0_2_2_0 := mem_0_2_2.Args[0]
		if mem_0_2_2_0.Op != ssaop.OpOffPtr {
			break
		}
		tt4 := mem_0_2_2_0.Type
		o4 := ssa.AuxIntToInt64(mem_0_2_2_0.AuxInt)
		p4 := mem_0_2_2_0.Args[0]
		d3 := mem_0_2_2.Args[1]
		mem_0_2_2_2 := mem_0_2_2.Args[2]
		if mem_0_2_2_2.Op != ssaop.OpStore {
			break
		}
		t5 := ssa.AuxToType(mem_0_2_2_2.Aux)
		_ = mem_0_2_2_2.Args[2]
		mem_0_2_2_2_0 := mem_0_2_2_2.Args[0]
		if mem_0_2_2_2_0.Op != ssaop.OpOffPtr {
			break
		}
		tt5 := mem_0_2_2_2_0.Type
		o5 := ssa.AuxIntToInt64(mem_0_2_2_2_0.AuxInt)
		p5 := mem_0_2_2_2_0.Args[0]
		d4 := mem_0_2_2_2.Args[1]
		mem_0_2_2_2_2 := mem_0_2_2_2.Args[2]
		if mem_0_2_2_2_2.Op != ssaop.OpZero || ssa.AuxIntToInt64(mem_0_2_2_2_2.AuxInt) != n {
			break
		}
		t6 := ssa.AuxToType(mem_0_2_2_2_2.Aux)
		p6 := mem_0_2_2_2_2.Args[0]
		if !(ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.IsSamePtr(p4, p5) && ssa.IsSamePtr(p5, p6) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && t5.Alignment() <= t1.Alignment() && t6.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && n >= o2+t2.Size() && n >= o3+t3.Size() && n >= o4+t4.Size() && n >= o5+t5.Size()) {
			break
		}
		v.Reset(ssaop.OpStore)
		v.Aux = ssa.TypeToAux(t2)
		v0 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt2)
		v0.AuxInt = ssa.Int64ToAuxInt(o2)
		v0.AddArg(dst)
		v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v1.Aux = ssa.TypeToAux(t3)
		v2 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt3)
		v2.AuxInt = ssa.Int64ToAuxInt(o3)
		v2.AddArg(dst)
		v3 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v3.Aux = ssa.TypeToAux(t4)
		v4 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt4)
		v4.AuxInt = ssa.Int64ToAuxInt(o4)
		v4.AddArg(dst)
		v5 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v5.Aux = ssa.TypeToAux(t5)
		v6 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt5)
		v6.AuxInt = ssa.Int64ToAuxInt(o5)
		v6.AddArg(dst)
		v7 := b.NewValue0(v.Pos, ssaop.OpZero, types.TypeMem)
		v7.AuxInt = ssa.Int64ToAuxInt(n)
		v7.Aux = ssa.TypeToAux(t1)
		v7.AddArg2(dst, mem)
		v5.AddArg3(v6, d4, v7)
		v3.AddArg3(v4, d3, v5)
		v1.AddArg3(v2, d2, v3)
		v.AddArg3(v0, d1, v1)
		return true
	}
	// match: (Move {t1} [s] dst tmp1 midmem:(Move {t2} [s] tmp2 src _))
	// cond: t1.Compare(t2) == types.CMPeq && ssa.IsSamePtr(tmp1, tmp2) && isStackPtr(src) && !ssa.IsVolatile(src) && ssa.Disjoint1(src, s, tmp2, s) && (ssa.Disjoint1(src, s, dst, s) || ssa.IsInlinableMemmove(dst, src, s, config))
	// result: (Move {t1} [s] dst src midmem)
	for {
		s := ssa.AuxIntToInt64(v.AuxInt)
		t1 := ssa.AuxToType(v.Aux)
		dst := v_0
		tmp1 := v_1
		midmem := v_2
		if midmem.Op != ssaop.OpMove || ssa.AuxIntToInt64(midmem.AuxInt) != s {
			break
		}
		t2 := ssa.AuxToType(midmem.Aux)
		src := midmem.Args[1]
		tmp2 := midmem.Args[0]
		if !(t1.Compare(t2) == types.CMPeq && ssa.IsSamePtr(tmp1, tmp2) && isStackPtr(src) && !ssa.IsVolatile(src) && ssa.Disjoint1(src, s, tmp2, s) && (ssa.Disjoint1(src, s, dst, s) || ssa.IsInlinableMemmove(dst, src, s, config))) {
			break
		}
		v.Reset(ssaop.OpMove)
		v.AuxInt = ssa.Int64ToAuxInt(s)
		v.Aux = ssa.TypeToAux(t1)
		v.AddArg3(dst, src, midmem)
		return true
	}
	// match: (Move {t1} [s] dst tmp1 midmem:(VarDef (Move {t2} [s] tmp2 src _)))
	// cond: t1.Compare(t2) == types.CMPeq && ssa.IsSamePtr(tmp1, tmp2) && isStackPtr(src) && !ssa.IsVolatile(src) && ssa.Disjoint1(src, s, tmp2, s) && (ssa.Disjoint1(src, s, dst, s) || ssa.IsInlinableMemmove(dst, src, s, config))
	// result: (Move {t1} [s] dst src midmem)
	for {
		s := ssa.AuxIntToInt64(v.AuxInt)
		t1 := ssa.AuxToType(v.Aux)
		dst := v_0
		tmp1 := v_1
		midmem := v_2
		if midmem.Op != ssaop.OpVarDef {
			break
		}
		midmem_0 := midmem.Args[0]
		if midmem_0.Op != ssaop.OpMove || ssa.AuxIntToInt64(midmem_0.AuxInt) != s {
			break
		}
		t2 := ssa.AuxToType(midmem_0.Aux)
		src := midmem_0.Args[1]
		tmp2 := midmem_0.Args[0]
		if !(t1.Compare(t2) == types.CMPeq && ssa.IsSamePtr(tmp1, tmp2) && isStackPtr(src) && !ssa.IsVolatile(src) && ssa.Disjoint1(src, s, tmp2, s) && (ssa.Disjoint1(src, s, dst, s) || ssa.IsInlinableMemmove(dst, src, s, config))) {
			break
		}
		v.Reset(ssaop.OpMove)
		v.AuxInt = ssa.Int64ToAuxInt(s)
		v.Aux = ssa.TypeToAux(t1)
		v.AddArg3(dst, src, midmem)
		return true
	}
	// match: (Move dst src mem)
	// cond: ssa.IsSamePtr(dst, src)
	// result: mem
	for {
		dst := v_0
		src := v_1
		mem := v_2
		if !(ssa.IsSamePtr(dst, src)) {
			break
		}
		v.CopyOf(mem)
		return true
	}
	return false
}
func rewriteValue_OpMul16(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (Mul16 (Const16 [c]) (Const16 [d]))
	// result: (Const16 [c*d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst16 {
				continue
			}
			d := ssa.AuxIntToInt16(v_1.AuxInt)
			v.Reset(ssaop.OpConst16)
			v.AuxInt = ssa.Int16ToAuxInt(c * d)
			return true
		}
		break
	}
	// match: (Mul16 (Const16 [1]) x)
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 1 {
				continue
			}
			x := v_1
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (Mul16 (Const16 [-1]) x)
	// result: (Neg16 x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != -1 {
				continue
			}
			x := v_1
			v.Reset(ssaop.OpNeg16)
			v.AddArg(x)
			return true
		}
		break
	}
	// match: (Mul16 (Const16 <t> [c]) (Neg16 x))
	// result: (Mul16 x (Const16 <t> [-c]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt16(v_0.AuxInt)
			if v_1.Op != ssaop.OpNeg16 {
				continue
			}
			x := v_1.Args[0]
			v.Reset(ssaop.OpMul16)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
			v0.AuxInt = ssa.Int16ToAuxInt(-c)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (Mul16 (Neg16 x) (Neg16 y))
	// result: (Mul16 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeg16 {
				continue
			}
			x := v_0.Args[0]
			if v_1.Op != ssaop.OpNeg16 {
				continue
			}
			y := v_1.Args[0]
			v.Reset(ssaop.OpMul16)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Mul16 (Const16 <t> [c]) (Add16 <t> (Const16 <t> [d]) x))
	// cond: !ssa.IsPowerOfTwo(c)
	// result: (Add16 (Const16 <t> [c*d]) (Mul16 <t> (Const16 <t> [c]) x))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt16(v_0.AuxInt)
			if v_1.Op != ssaop.OpAdd16 || v_1.Type != t {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if v_1_0.Op != ssaop.OpConst16 || v_1_0.Type != t {
					continue
				}
				d := ssa.AuxIntToInt16(v_1_0.AuxInt)
				x := v_1_1
				if !(!ssa.IsPowerOfTwo(c)) {
					continue
				}
				v.Reset(ssaop.OpAdd16)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
				v0.AuxInt = ssa.Int16ToAuxInt(c * d)
				v1 := b.NewValue0(v.Pos, ssaop.OpMul16, t)
				v2 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
				v2.AuxInt = ssa.Int16ToAuxInt(c)
				v1.AddArg2(v2, x)
				v.AddArg2(v0, v1)
				return true
			}
		}
		break
	}
	// match: (Mul16 (Const16 [0]) _)
	// result: (Const16 [0])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 {
				continue
			}
			v.Reset(ssaop.OpConst16)
			v.AuxInt = ssa.Int16ToAuxInt(0)
			return true
		}
		break
	}
	// match: (Mul16 <t> x (Const16 [c]))
	// cond: ssa.IsPowerOfTwo(uint16(c)) && v.Block.Func.Pass.Name != "opt"
	// result: (Lsh16x64 <t> x (Const64 <typ.UInt64> [ssa.Log16u(uint16(c))]))
	for {
		t := v.Type
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_1.AuxInt)
			if !(ssa.IsPowerOfTwo(uint16(c)) && v.Block.Func.Pass.Name != "opt") {
				continue
			}
			v.Reset(ssaop.OpLsh16x64)
			v.Type = t
			v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64)
			v0.AuxInt = ssa.Int64ToAuxInt(ssa.Log16u(uint16(c)))
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (Mul16 <t> x (Const16 [c]))
	// cond: ssa.IsPowerOfTwo(uint16(-c)) && v.Block.Func.Pass.Name != "opt"
	// result: (Neg16 (Lsh16x64 <t> x (Const64 <typ.UInt64> [ssa.Log16u(uint16(-c))])))
	for {
		t := v.Type
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_1.AuxInt)
			if !(ssa.IsPowerOfTwo(uint16(-c)) && v.Block.Func.Pass.Name != "opt") {
				continue
			}
			v.Reset(ssaop.OpNeg16)
			v0 := b.NewValue0(v.Pos, ssaop.OpLsh16x64, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64)
			v1.AuxInt = ssa.Int64ToAuxInt(ssa.Log16u(uint16(-c)))
			v0.AddArg2(x, v1)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (Mul16 (Mul16 i:(Const16 <t>) z) x)
	// cond: (z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16)
	// result: (Mul16 i (Mul16 <t> x z))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpMul16 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				i := v_0_0
				if i.Op != ssaop.OpConst16 {
					continue
				}
				t := i.Type
				z := v_0_1
				x := v_1
				if !(z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16) {
					continue
				}
				v.Reset(ssaop.OpMul16)
				v0 := b.NewValue0(v.Pos, ssaop.OpMul16, t)
				v0.AddArg2(x, z)
				v.AddArg2(i, v0)
				return true
			}
		}
		break
	}
	// match: (Mul16 (Const16 <t> [c]) m:(Mul16 (Const16 <t> [d]) x))
	// cond: (!ssa.IsPowerOfTwo(c) || m.Uses == 1)
	// result: (Mul16 (Const16 <t> [c*d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt16(v_0.AuxInt)
			m := v_1
			if m.Op != ssaop.OpMul16 {
				continue
			}
			_ = m.Args[1]
			m_0 := m.Args[0]
			m_1 := m.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, m_0, m_1 = _i1+1, m_1, m_0 {
				if m_0.Op != ssaop.OpConst16 || m_0.Type != t {
					continue
				}
				d := ssa.AuxIntToInt16(m_0.AuxInt)
				x := m_1
				if !(!ssa.IsPowerOfTwo(c) || m.Uses == 1) {
					continue
				}
				v.Reset(ssaop.OpMul16)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
				v0.AuxInt = ssa.Int16ToAuxInt(c * d)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	return false
}
func rewriteValue_OpMul32(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (Mul32 (Const32 [c]) (Const32 [d]))
	// result: (Const32 [c*d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(v_1.AuxInt)
			v.Reset(ssaop.OpConst32)
			v.AuxInt = ssa.Int32ToAuxInt(c * d)
			return true
		}
		break
	}
	// match: (Mul32 (Const32 [1]) x)
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 1 {
				continue
			}
			x := v_1
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (Mul32 (Const32 [-1]) x)
	// result: (Neg32 x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != -1 {
				continue
			}
			x := v_1
			v.Reset(ssaop.OpNeg32)
			v.AddArg(x)
			return true
		}
		break
	}
	// match: (Mul32 (Const32 <t> [c]) (Neg32 x))
	// result: (Mul32 x (Const32 <t> [-c]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt32(v_0.AuxInt)
			if v_1.Op != ssaop.OpNeg32 {
				continue
			}
			x := v_1.Args[0]
			v.Reset(ssaop.OpMul32)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
			v0.AuxInt = ssa.Int32ToAuxInt(-c)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (Mul32 (Neg32 x) (Neg32 y))
	// result: (Mul32 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeg32 {
				continue
			}
			x := v_0.Args[0]
			if v_1.Op != ssaop.OpNeg32 {
				continue
			}
			y := v_1.Args[0]
			v.Reset(ssaop.OpMul32)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Mul32 (Const32 <t> [c]) (Add32 <t> (Const32 <t> [d]) x))
	// cond: !ssa.IsPowerOfTwo(c)
	// result: (Add32 (Const32 <t> [c*d]) (Mul32 <t> (Const32 <t> [c]) x))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt32(v_0.AuxInt)
			if v_1.Op != ssaop.OpAdd32 || v_1.Type != t {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if v_1_0.Op != ssaop.OpConst32 || v_1_0.Type != t {
					continue
				}
				d := ssa.AuxIntToInt32(v_1_0.AuxInt)
				x := v_1_1
				if !(!ssa.IsPowerOfTwo(c)) {
					continue
				}
				v.Reset(ssaop.OpAdd32)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
				v0.AuxInt = ssa.Int32ToAuxInt(c * d)
				v1 := b.NewValue0(v.Pos, ssaop.OpMul32, t)
				v2 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
				v2.AuxInt = ssa.Int32ToAuxInt(c)
				v1.AddArg2(v2, x)
				v.AddArg2(v0, v1)
				return true
			}
		}
		break
	}
	// match: (Mul32 (Const32 [0]) _)
	// result: (Const32 [0])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 {
				continue
			}
			v.Reset(ssaop.OpConst32)
			v.AuxInt = ssa.Int32ToAuxInt(0)
			return true
		}
		break
	}
	// match: (Mul32 <t> x (Const32 [c]))
	// cond: ssa.IsPowerOfTwo(uint32(c)) && v.Block.Func.Pass.Name != "opt"
	// result: (Lsh32x64 <t> x (Const64 <typ.UInt64> [ssa.Log32u(uint32(c))]))
	for {
		t := v.Type
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_1.AuxInt)
			if !(ssa.IsPowerOfTwo(uint32(c)) && v.Block.Func.Pass.Name != "opt") {
				continue
			}
			v.Reset(ssaop.OpLsh32x64)
			v.Type = t
			v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64)
			v0.AuxInt = ssa.Int64ToAuxInt(ssa.Log32u(uint32(c)))
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (Mul32 <t> x (Const32 [c]))
	// cond: ssa.IsPowerOfTwo(uint32(-c)) && v.Block.Func.Pass.Name != "opt"
	// result: (Neg32 (Lsh32x64 <t> x (Const64 <typ.UInt64> [ssa.Log32u(uint32(-c))])))
	for {
		t := v.Type
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_1.AuxInt)
			if !(ssa.IsPowerOfTwo(uint32(-c)) && v.Block.Func.Pass.Name != "opt") {
				continue
			}
			v.Reset(ssaop.OpNeg32)
			v0 := b.NewValue0(v.Pos, ssaop.OpLsh32x64, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64)
			v1.AuxInt = ssa.Int64ToAuxInt(ssa.Log32u(uint32(-c)))
			v0.AddArg2(x, v1)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (Mul32 (Mul32 i:(Const32 <t>) z) x)
	// cond: (z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32)
	// result: (Mul32 i (Mul32 <t> x z))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpMul32 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				i := v_0_0
				if i.Op != ssaop.OpConst32 {
					continue
				}
				t := i.Type
				z := v_0_1
				x := v_1
				if !(z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32) {
					continue
				}
				v.Reset(ssaop.OpMul32)
				v0 := b.NewValue0(v.Pos, ssaop.OpMul32, t)
				v0.AddArg2(x, z)
				v.AddArg2(i, v0)
				return true
			}
		}
		break
	}
	// match: (Mul32 (Const32 <t> [c]) m:(Mul32 (Const32 <t> [d]) x))
	// cond: (!ssa.IsPowerOfTwo(c) || m.Uses == 1)
	// result: (Mul32 (Const32 <t> [c*d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt32(v_0.AuxInt)
			m := v_1
			if m.Op != ssaop.OpMul32 {
				continue
			}
			_ = m.Args[1]
			m_0 := m.Args[0]
			m_1 := m.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, m_0, m_1 = _i1+1, m_1, m_0 {
				if m_0.Op != ssaop.OpConst32 || m_0.Type != t {
					continue
				}
				d := ssa.AuxIntToInt32(m_0.AuxInt)
				x := m_1
				if !(!ssa.IsPowerOfTwo(c) || m.Uses == 1) {
					continue
				}
				v.Reset(ssaop.OpMul32)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
				v0.AuxInt = ssa.Int32ToAuxInt(c * d)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	return false
}
func rewriteValue_OpMul32F(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	// match: (Mul32F (Const32F [c]) (Const32F [d]))
	// cond: c*d == c*d
	// result: (Const32F [c*d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32F {
				continue
			}
			c := ssa.AuxIntToFloat32(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst32F {
				continue
			}
			d := ssa.AuxIntToFloat32(v_1.AuxInt)
			if !(c*d == c*d) {
				continue
			}
			v.Reset(ssaop.OpConst32F)
			v.AuxInt = ssa.Float32ToAuxInt(c * d)
			return true
		}
		break
	}
	// match: (Mul32F x (Const32F [1]))
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpConst32F || ssa.AuxIntToFloat32(v_1.AuxInt) != 1 {
				continue
			}
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (Mul32F x (Const32F [-1]))
	// result: (Neg32F x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpConst32F || ssa.AuxIntToFloat32(v_1.AuxInt) != -1 {
				continue
			}
			v.Reset(ssaop.OpNeg32F)
			v.AddArg(x)
			return true
		}
		break
	}
	// match: (Mul32F x (Const32F [2]))
	// result: (Add32F x x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpConst32F || ssa.AuxIntToFloat32(v_1.AuxInt) != 2 {
				continue
			}
			v.Reset(ssaop.OpAdd32F)
			v.AddArg2(x, x)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpMul32uhilo(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (Mul32uhilo (Const32 [c]) (Const32 [d]))
	// result: (MakeTuple (Const32 <typ.UInt32> [bitsMulU32(c, d).hi]) (Const32 <typ.UInt32> [bitsMulU32(c,d).lo]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(v_1.AuxInt)
			v.Reset(ssaop.OpMakeTuple)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32)
			v0.AuxInt = ssa.Int32ToAuxInt(bitsMulU32(c, d).hi)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32)
			v1.AuxInt = ssa.Int32ToAuxInt(bitsMulU32(c, d).lo)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpMul32uover(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (Mul32uover (Const32 [c]) (Const32 [d]))
	// result: (MakeTuple (Const32 <typ.UInt32> [bitsMulU32(c, d).lo]) (ConstBool <typ.Bool> [bitsMulU32(c,d).hi != 0]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(v_1.AuxInt)
			v.Reset(ssaop.OpMakeTuple)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32)
			v0.AuxInt = ssa.Int32ToAuxInt(bitsMulU32(c, d).lo)
			v1 := b.NewValue0(v.Pos, ssaop.OpConstBool, typ.Bool)
			v1.AuxInt = ssa.BoolToAuxInt(bitsMulU32(c, d).hi != 0)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	// match: (Mul32uover <t> (Const32 [1]) x)
	// result: (MakeTuple x (ConstBool <t.FieldType(1)> [false]))
	for {
		t := v.Type
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 1 {
				continue
			}
			x := v_1
			v.Reset(ssaop.OpMakeTuple)
			v0 := b.NewValue0(v.Pos, ssaop.OpConstBool, t.FieldType(1))
			v0.AuxInt = ssa.BoolToAuxInt(false)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (Mul32uover <t> (Const32 [0]) x)
	// result: (MakeTuple (Const32 <t.FieldType(0)> [0]) (ConstBool <t.FieldType(1)> [false]))
	for {
		t := v.Type
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 {
				continue
			}
			v.Reset(ssaop.OpMakeTuple)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t.FieldType(0))
			v0.AuxInt = ssa.Int32ToAuxInt(0)
			v1 := b.NewValue0(v.Pos, ssaop.OpConstBool, t.FieldType(1))
			v1.AuxInt = ssa.BoolToAuxInt(false)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpMul64(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (Mul64 (Const64 [c]) (Const64 [d]))
	// result: (Const64 [c*d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1.AuxInt)
			v.Reset(ssaop.OpConst64)
			v.AuxInt = ssa.Int64ToAuxInt(c * d)
			return true
		}
		break
	}
	// match: (Mul64 (Const64 [1]) x)
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 1 {
				continue
			}
			x := v_1
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (Mul64 (Const64 [-1]) x)
	// result: (Neg64 x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != -1 {
				continue
			}
			x := v_1
			v.Reset(ssaop.OpNeg64)
			v.AddArg(x)
			return true
		}
		break
	}
	// match: (Mul64 (Const64 <t> [c]) (Neg64 x))
	// result: (Mul64 x (Const64 <t> [-c]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt64(v_0.AuxInt)
			if v_1.Op != ssaop.OpNeg64 {
				continue
			}
			x := v_1.Args[0]
			v.Reset(ssaop.OpMul64)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
			v0.AuxInt = ssa.Int64ToAuxInt(-c)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (Mul64 (Neg64 x) (Neg64 y))
	// result: (Mul64 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeg64 {
				continue
			}
			x := v_0.Args[0]
			if v_1.Op != ssaop.OpNeg64 {
				continue
			}
			y := v_1.Args[0]
			v.Reset(ssaop.OpMul64)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Mul64 (Const64 <t> [c]) (Add64 <t> (Const64 <t> [d]) x))
	// cond: !ssa.IsPowerOfTwo(c)
	// result: (Add64 (Const64 <t> [c*d]) (Mul64 <t> (Const64 <t> [c]) x))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt64(v_0.AuxInt)
			if v_1.Op != ssaop.OpAdd64 || v_1.Type != t {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if v_1_0.Op != ssaop.OpConst64 || v_1_0.Type != t {
					continue
				}
				d := ssa.AuxIntToInt64(v_1_0.AuxInt)
				x := v_1_1
				if !(!ssa.IsPowerOfTwo(c)) {
					continue
				}
				v.Reset(ssaop.OpAdd64)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
				v0.AuxInt = ssa.Int64ToAuxInt(c * d)
				v1 := b.NewValue0(v.Pos, ssaop.OpMul64, t)
				v2 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
				v2.AuxInt = ssa.Int64ToAuxInt(c)
				v1.AddArg2(v2, x)
				v.AddArg2(v0, v1)
				return true
			}
		}
		break
	}
	// match: (Mul64 (Const64 [0]) _)
	// result: (Const64 [0])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 {
				continue
			}
			v.Reset(ssaop.OpConst64)
			v.AuxInt = ssa.Int64ToAuxInt(0)
			return true
		}
		break
	}
	// match: (Mul64 <t> x (Const64 [c]))
	// cond: ssa.IsPowerOfTwo(uint64(c)) && v.Block.Func.Pass.Name != "opt"
	// result: (Lsh64x64 <t> x (Const64 <typ.UInt64> [ssa.Log64u(uint64(c))]))
	for {
		t := v.Type
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_1.AuxInt)
			if !(ssa.IsPowerOfTwo(uint64(c)) && v.Block.Func.Pass.Name != "opt") {
				continue
			}
			v.Reset(ssaop.OpLsh64x64)
			v.Type = t
			v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64)
			v0.AuxInt = ssa.Int64ToAuxInt(ssa.Log64u(uint64(c)))
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (Mul64 <t> x (Const64 [c]))
	// cond: ssa.IsPowerOfTwo(uint64(-c)) && v.Block.Func.Pass.Name != "opt"
	// result: (Neg64 (Lsh64x64 <t> x (Const64 <typ.UInt64> [ssa.Log64u(uint64(-c))])))
	for {
		t := v.Type
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_1.AuxInt)
			if !(ssa.IsPowerOfTwo(uint64(-c)) && v.Block.Func.Pass.Name != "opt") {
				continue
			}
			v.Reset(ssaop.OpNeg64)
			v0 := b.NewValue0(v.Pos, ssaop.OpLsh64x64, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64)
			v1.AuxInt = ssa.Int64ToAuxInt(ssa.Log64u(uint64(-c)))
			v0.AddArg2(x, v1)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (Mul64 (Mul64 i:(Const64 <t>) z) x)
	// cond: (z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64)
	// result: (Mul64 i (Mul64 <t> x z))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpMul64 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				i := v_0_0
				if i.Op != ssaop.OpConst64 {
					continue
				}
				t := i.Type
				z := v_0_1
				x := v_1
				if !(z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64) {
					continue
				}
				v.Reset(ssaop.OpMul64)
				v0 := b.NewValue0(v.Pos, ssaop.OpMul64, t)
				v0.AddArg2(x, z)
				v.AddArg2(i, v0)
				return true
			}
		}
		break
	}
	// match: (Mul64 (Const64 <t> [c]) m:(Mul64 (Const64 <t> [d]) x))
	// cond: (!ssa.IsPowerOfTwo(c) || m.Uses == 1)
	// result: (Mul64 (Const64 <t> [c*d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt64(v_0.AuxInt)
			m := v_1
			if m.Op != ssaop.OpMul64 {
				continue
			}
			_ = m.Args[1]
			m_0 := m.Args[0]
			m_1 := m.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, m_0, m_1 = _i1+1, m_1, m_0 {
				if m_0.Op != ssaop.OpConst64 || m_0.Type != t {
					continue
				}
				d := ssa.AuxIntToInt64(m_0.AuxInt)
				x := m_1
				if !(!ssa.IsPowerOfTwo(c) || m.Uses == 1) {
					continue
				}
				v.Reset(ssaop.OpMul64)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
				v0.AuxInt = ssa.Int64ToAuxInt(c * d)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	return false
}
func rewriteValue_OpMul64F(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	// match: (Mul64F (Const64F [c]) (Const64F [d]))
	// cond: c*d == c*d
	// result: (Const64F [c*d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64F {
				continue
			}
			c := ssa.AuxIntToFloat64(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst64F {
				continue
			}
			d := ssa.AuxIntToFloat64(v_1.AuxInt)
			if !(c*d == c*d) {
				continue
			}
			v.Reset(ssaop.OpConst64F)
			v.AuxInt = ssa.Float64ToAuxInt(c * d)
			return true
		}
		break
	}
	// match: (Mul64F x (Const64F [1]))
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpConst64F || ssa.AuxIntToFloat64(v_1.AuxInt) != 1 {
				continue
			}
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (Mul64F x (Const64F [-1]))
	// result: (Neg64F x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpConst64F || ssa.AuxIntToFloat64(v_1.AuxInt) != -1 {
				continue
			}
			v.Reset(ssaop.OpNeg64F)
			v.AddArg(x)
			return true
		}
		break
	}
	// match: (Mul64F x (Const64F [2]))
	// result: (Add64F x x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpConst64F || ssa.AuxIntToFloat64(v_1.AuxInt) != 2 {
				continue
			}
			v.Reset(ssaop.OpAdd64F)
			v.AddArg2(x, x)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpMul64uhilo(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (Mul64uhilo (Const64 [c]) (Const64 [d]))
	// result: (MakeTuple (Const64 <typ.UInt64> [bitsMulU64(c, d).hi]) (Const64 <typ.UInt64> [bitsMulU64(c,d).lo]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1.AuxInt)
			v.Reset(ssaop.OpMakeTuple)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64)
			v0.AuxInt = ssa.Int64ToAuxInt(bitsMulU64(c, d).hi)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64)
			v1.AuxInt = ssa.Int64ToAuxInt(bitsMulU64(c, d).lo)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	// match: (Mul64uhilo x (Const64 [c]))
	// cond: c > 0 && ssa.IsPowerOfTwo(uint64(c))
	// result: (MakeTuple (Rsh64Ux64 <typ.UInt64> x (Const64 <typ.UInt64> [64 - ssa.Log64u(uint64(c))])) (Lsh64x64 <typ.UInt64> x (Const64 <typ.UInt64> [ssa.Log64u(uint64(c))])))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_1.AuxInt)
			if !(c > 0 && ssa.IsPowerOfTwo(uint64(c))) {
				continue
			}
			v.Reset(ssaop.OpMakeTuple)
			v0 := b.NewValue0(v.Pos, ssaop.OpRsh64Ux64, typ.UInt64)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64)
			v1.AuxInt = ssa.Int64ToAuxInt(64 - ssa.Log64u(uint64(c)))
			v0.AddArg2(x, v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpLsh64x64, typ.UInt64)
			v3 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64)
			v3.AuxInt = ssa.Int64ToAuxInt(ssa.Log64u(uint64(c)))
			v2.AddArg2(x, v3)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpMul64uover(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (Mul64uover (Const64 [c]) (Const64 [d]))
	// result: (MakeTuple (Const64 <typ.UInt64> [bitsMulU64(c, d).lo]) (ConstBool <typ.Bool> [bitsMulU64(c,d).hi != 0]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1.AuxInt)
			v.Reset(ssaop.OpMakeTuple)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64)
			v0.AuxInt = ssa.Int64ToAuxInt(bitsMulU64(c, d).lo)
			v1 := b.NewValue0(v.Pos, ssaop.OpConstBool, typ.Bool)
			v1.AuxInt = ssa.BoolToAuxInt(bitsMulU64(c, d).hi != 0)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	// match: (Mul64uover <t> (Const64 [1]) x)
	// result: (MakeTuple x (ConstBool <t.FieldType(1)> [false]))
	for {
		t := v.Type
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 1 {
				continue
			}
			x := v_1
			v.Reset(ssaop.OpMakeTuple)
			v0 := b.NewValue0(v.Pos, ssaop.OpConstBool, t.FieldType(1))
			v0.AuxInt = ssa.BoolToAuxInt(false)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (Mul64uover <t> (Const64 [0]) x)
	// result: (MakeTuple (Const64 <t.FieldType(0)> [0]) (ConstBool <t.FieldType(1)> [false]))
	for {
		t := v.Type
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 {
				continue
			}
			v.Reset(ssaop.OpMakeTuple)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t.FieldType(0))
			v0.AuxInt = ssa.Int64ToAuxInt(0)
			v1 := b.NewValue0(v.Pos, ssaop.OpConstBool, t.FieldType(1))
			v1.AuxInt = ssa.BoolToAuxInt(false)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpMul8(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (Mul8 (Const8 [c]) (Const8 [d]))
	// result: (Const8 [c*d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst8 {
				continue
			}
			d := ssa.AuxIntToInt8(v_1.AuxInt)
			v.Reset(ssaop.OpConst8)
			v.AuxInt = ssa.Int8ToAuxInt(c * d)
			return true
		}
		break
	}
	// match: (Mul8 (Const8 [1]) x)
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 1 {
				continue
			}
			x := v_1
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (Mul8 (Const8 [-1]) x)
	// result: (Neg8 x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != -1 {
				continue
			}
			x := v_1
			v.Reset(ssaop.OpNeg8)
			v.AddArg(x)
			return true
		}
		break
	}
	// match: (Mul8 (Const8 <t> [c]) (Neg8 x))
	// result: (Mul8 x (Const8 <t> [-c]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt8(v_0.AuxInt)
			if v_1.Op != ssaop.OpNeg8 {
				continue
			}
			x := v_1.Args[0]
			v.Reset(ssaop.OpMul8)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
			v0.AuxInt = ssa.Int8ToAuxInt(-c)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (Mul8 (Neg8 x) (Neg8 y))
	// result: (Mul8 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeg8 {
				continue
			}
			x := v_0.Args[0]
			if v_1.Op != ssaop.OpNeg8 {
				continue
			}
			y := v_1.Args[0]
			v.Reset(ssaop.OpMul8)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Mul8 (Const8 <t> [c]) (Add8 <t> (Const8 <t> [d]) x))
	// cond: !ssa.IsPowerOfTwo(c)
	// result: (Add8 (Const8 <t> [c*d]) (Mul8 <t> (Const8 <t> [c]) x))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt8(v_0.AuxInt)
			if v_1.Op != ssaop.OpAdd8 || v_1.Type != t {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if v_1_0.Op != ssaop.OpConst8 || v_1_0.Type != t {
					continue
				}
				d := ssa.AuxIntToInt8(v_1_0.AuxInt)
				x := v_1_1
				if !(!ssa.IsPowerOfTwo(c)) {
					continue
				}
				v.Reset(ssaop.OpAdd8)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
				v0.AuxInt = ssa.Int8ToAuxInt(c * d)
				v1 := b.NewValue0(v.Pos, ssaop.OpMul8, t)
				v2 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
				v2.AuxInt = ssa.Int8ToAuxInt(c)
				v1.AddArg2(v2, x)
				v.AddArg2(v0, v1)
				return true
			}
		}
		break
	}
	// match: (Mul8 (Const8 [0]) _)
	// result: (Const8 [0])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 {
				continue
			}
			v.Reset(ssaop.OpConst8)
			v.AuxInt = ssa.Int8ToAuxInt(0)
			return true
		}
		break
	}
	// match: (Mul8 <t> x (Const8 [c]))
	// cond: ssa.IsPowerOfTwo(uint8(c)) && v.Block.Func.Pass.Name != "opt"
	// result: (Lsh8x64 <t> x (Const64 <typ.UInt64> [ssa.Log8u(uint8(c))]))
	for {
		t := v.Type
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_1.AuxInt)
			if !(ssa.IsPowerOfTwo(uint8(c)) && v.Block.Func.Pass.Name != "opt") {
				continue
			}
			v.Reset(ssaop.OpLsh8x64)
			v.Type = t
			v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64)
			v0.AuxInt = ssa.Int64ToAuxInt(ssa.Log8u(uint8(c)))
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (Mul8 <t> x (Const8 [c]))
	// cond: ssa.IsPowerOfTwo(uint8(-c)) && v.Block.Func.Pass.Name != "opt"
	// result: (Neg8 (Lsh8x64 <t> x (Const64 <typ.UInt64> [ssa.Log8u(uint8(-c))])))
	for {
		t := v.Type
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_1.AuxInt)
			if !(ssa.IsPowerOfTwo(uint8(-c)) && v.Block.Func.Pass.Name != "opt") {
				continue
			}
			v.Reset(ssaop.OpNeg8)
			v0 := b.NewValue0(v.Pos, ssaop.OpLsh8x64, t)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64)
			v1.AuxInt = ssa.Int64ToAuxInt(ssa.Log8u(uint8(-c)))
			v0.AddArg2(x, v1)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (Mul8 (Mul8 i:(Const8 <t>) z) x)
	// cond: (z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8)
	// result: (Mul8 i (Mul8 <t> x z))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpMul8 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				i := v_0_0
				if i.Op != ssaop.OpConst8 {
					continue
				}
				t := i.Type
				z := v_0_1
				x := v_1
				if !(z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8) {
					continue
				}
				v.Reset(ssaop.OpMul8)
				v0 := b.NewValue0(v.Pos, ssaop.OpMul8, t)
				v0.AddArg2(x, z)
				v.AddArg2(i, v0)
				return true
			}
		}
		break
	}
	// match: (Mul8 (Const8 <t> [c]) m:(Mul8 (Const8 <t> [d]) x))
	// cond: (!ssa.IsPowerOfTwo(c) || m.Uses == 1)
	// result: (Mul8 (Const8 <t> [c*d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt8(v_0.AuxInt)
			m := v_1
			if m.Op != ssaop.OpMul8 {
				continue
			}
			_ = m.Args[1]
			m_0 := m.Args[0]
			m_1 := m.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, m_0, m_1 = _i1+1, m_1, m_0 {
				if m_0.Op != ssaop.OpConst8 || m_0.Type != t {
					continue
				}
				d := ssa.AuxIntToInt8(m_0.AuxInt)
				x := m_1
				if !(!ssa.IsPowerOfTwo(c) || m.Uses == 1) {
					continue
				}
				v.Reset(ssaop.OpMul8)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
				v0.AuxInt = ssa.Int8ToAuxInt(c * d)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	return false
}
func rewriteValue_OpNeg16(v *ssa.Value) bool {
	v_0 := v.Args[0]
	b := v.Block
	// match: (Neg16 (Const16 [c]))
	// result: (Const16 [-c])
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_0.AuxInt)
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(-c)
		return true
	}
	// match: (Neg16 (Mul16 x (Const16 <t> [c])))
	// result: (Mul16 x (Const16 <t> [-c]))
	for {
		if v_0.Op != ssaop.OpMul16 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			x := v_0_0
			if v_0_1.Op != ssaop.OpConst16 {
				continue
			}
			t := v_0_1.Type
			c := ssa.AuxIntToInt16(v_0_1.AuxInt)
			v.Reset(ssaop.OpMul16)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
			v0.AuxInt = ssa.Int16ToAuxInt(-c)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (Neg16 (Mul16 x (Neg16 y)))
	// result: (Mul16 x y)
	for {
		if v_0.Op != ssaop.OpMul16 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			x := v_0_0
			if v_0_1.Op != ssaop.OpNeg16 {
				continue
			}
			y := v_0_1.Args[0]
			v.Reset(ssaop.OpMul16)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Neg16 (Sub16 x y))
	// result: (Sub16 y x)
	for {
		if v_0.Op != ssaop.OpSub16 {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpSub16)
		v.AddArg2(y, x)
		return true
	}
	// match: (Neg16 (Neg16 x))
	// result: x
	for {
		if v_0.Op != ssaop.OpNeg16 {
			break
		}
		x := v_0.Args[0]
		v.CopyOf(x)
		return true
	}
	// match: (Neg16 <t> (Com16 x))
	// result: (Add16 (Const16 <t> [1]) x)
	for {
		t := v.Type
		if v_0.Op != ssaop.OpCom16 {
			break
		}
		x := v_0.Args[0]
		v.Reset(ssaop.OpAdd16)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
		v0.AuxInt = ssa.Int16ToAuxInt(1)
		v.AddArg2(v0, x)
		return true
	}
	return false
}
func rewriteValue_OpNeg32(v *ssa.Value) bool {
	v_0 := v.Args[0]
	b := v.Block
	// match: (Neg32 (Const32 [c]))
	// result: (Const32 [-c])
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_0.AuxInt)
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(-c)
		return true
	}
	// match: (Neg32 (Mul32 x (Const32 <t> [c])))
	// result: (Mul32 x (Const32 <t> [-c]))
	for {
		if v_0.Op != ssaop.OpMul32 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			x := v_0_0
			if v_0_1.Op != ssaop.OpConst32 {
				continue
			}
			t := v_0_1.Type
			c := ssa.AuxIntToInt32(v_0_1.AuxInt)
			v.Reset(ssaop.OpMul32)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
			v0.AuxInt = ssa.Int32ToAuxInt(-c)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (Neg32 (Mul32 x (Neg32 y)))
	// result: (Mul32 x y)
	for {
		if v_0.Op != ssaop.OpMul32 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			x := v_0_0
			if v_0_1.Op != ssaop.OpNeg32 {
				continue
			}
			y := v_0_1.Args[0]
			v.Reset(ssaop.OpMul32)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Neg32 (Sub32 x y))
	// result: (Sub32 y x)
	for {
		if v_0.Op != ssaop.OpSub32 {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpSub32)
		v.AddArg2(y, x)
		return true
	}
	// match: (Neg32 (Neg32 x))
	// result: x
	for {
		if v_0.Op != ssaop.OpNeg32 {
			break
		}
		x := v_0.Args[0]
		v.CopyOf(x)
		return true
	}
	// match: (Neg32 <t> (Com32 x))
	// result: (Add32 (Const32 <t> [1]) x)
	for {
		t := v.Type
		if v_0.Op != ssaop.OpCom32 {
			break
		}
		x := v_0.Args[0]
		v.Reset(ssaop.OpAdd32)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
		v0.AuxInt = ssa.Int32ToAuxInt(1)
		v.AddArg2(v0, x)
		return true
	}
	return false
}
func rewriteValue_OpNeg32F(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (Neg32F (Const32F [c]))
	// cond: c != 0
	// result: (Const32F [-c])
	for {
		if v_0.Op != ssaop.OpConst32F {
			break
		}
		c := ssa.AuxIntToFloat32(v_0.AuxInt)
		if !(c != 0) {
			break
		}
		v.Reset(ssaop.OpConst32F)
		v.AuxInt = ssa.Float32ToAuxInt(-c)
		return true
	}
	return false
}
func rewriteValue_OpNeg64(v *ssa.Value) bool {
	v_0 := v.Args[0]
	b := v.Block
	// match: (Neg64 (Const64 [c]))
	// result: (Const64 [-c])
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0.AuxInt)
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(-c)
		return true
	}
	// match: (Neg64 (Mul64 x (Const64 <t> [c])))
	// result: (Mul64 x (Const64 <t> [-c]))
	for {
		if v_0.Op != ssaop.OpMul64 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			x := v_0_0
			if v_0_1.Op != ssaop.OpConst64 {
				continue
			}
			t := v_0_1.Type
			c := ssa.AuxIntToInt64(v_0_1.AuxInt)
			v.Reset(ssaop.OpMul64)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
			v0.AuxInt = ssa.Int64ToAuxInt(-c)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (Neg64 (Mul64 x (Neg64 y)))
	// result: (Mul64 x y)
	for {
		if v_0.Op != ssaop.OpMul64 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			x := v_0_0
			if v_0_1.Op != ssaop.OpNeg64 {
				continue
			}
			y := v_0_1.Args[0]
			v.Reset(ssaop.OpMul64)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Neg64 (Sub64 x y))
	// result: (Sub64 y x)
	for {
		if v_0.Op != ssaop.OpSub64 {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpSub64)
		v.AddArg2(y, x)
		return true
	}
	// match: (Neg64 (Neg64 x))
	// result: x
	for {
		if v_0.Op != ssaop.OpNeg64 {
			break
		}
		x := v_0.Args[0]
		v.CopyOf(x)
		return true
	}
	// match: (Neg64 <t> (Com64 x))
	// result: (Add64 (Const64 <t> [1]) x)
	for {
		t := v.Type
		if v_0.Op != ssaop.OpCom64 {
			break
		}
		x := v_0.Args[0]
		v.Reset(ssaop.OpAdd64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(1)
		v.AddArg2(v0, x)
		return true
	}
	return false
}
func rewriteValue_OpNeg64F(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (Neg64F (Const64F [c]))
	// cond: c != 0
	// result: (Const64F [-c])
	for {
		if v_0.Op != ssaop.OpConst64F {
			break
		}
		c := ssa.AuxIntToFloat64(v_0.AuxInt)
		if !(c != 0) {
			break
		}
		v.Reset(ssaop.OpConst64F)
		v.AuxInt = ssa.Float64ToAuxInt(-c)
		return true
	}
	return false
}
func rewriteValue_OpNeg8(v *ssa.Value) bool {
	v_0 := v.Args[0]
	b := v.Block
	// match: (Neg8 (Const8 [c]))
	// result: (Const8 [-c])
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_0.AuxInt)
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(-c)
		return true
	}
	// match: (Neg8 (Mul8 x (Const8 <t> [c])))
	// result: (Mul8 x (Const8 <t> [-c]))
	for {
		if v_0.Op != ssaop.OpMul8 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			x := v_0_0
			if v_0_1.Op != ssaop.OpConst8 {
				continue
			}
			t := v_0_1.Type
			c := ssa.AuxIntToInt8(v_0_1.AuxInt)
			v.Reset(ssaop.OpMul8)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
			v0.AuxInt = ssa.Int8ToAuxInt(-c)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (Neg8 (Mul8 x (Neg8 y)))
	// result: (Mul8 x y)
	for {
		if v_0.Op != ssaop.OpMul8 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			x := v_0_0
			if v_0_1.Op != ssaop.OpNeg8 {
				continue
			}
			y := v_0_1.Args[0]
			v.Reset(ssaop.OpMul8)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Neg8 (Sub8 x y))
	// result: (Sub8 y x)
	for {
		if v_0.Op != ssaop.OpSub8 {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpSub8)
		v.AddArg2(y, x)
		return true
	}
	// match: (Neg8 (Neg8 x))
	// result: x
	for {
		if v_0.Op != ssaop.OpNeg8 {
			break
		}
		x := v_0.Args[0]
		v.CopyOf(x)
		return true
	}
	// match: (Neg8 <t> (Com8 x))
	// result: (Add8 (Const8 <t> [1]) x)
	for {
		t := v.Type
		if v_0.Op != ssaop.OpCom8 {
			break
		}
		x := v_0.Args[0]
		v.Reset(ssaop.OpAdd8)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
		v0.AuxInt = ssa.Int8ToAuxInt(1)
		v.AddArg2(v0, x)
		return true
	}
	return false
}
func rewriteValue_OpNeq16(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Neq16 x x)
	// result: (ConstBool [false])
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(false)
		return true
	}
	// match: (Neq16 (Const16 <t> [c]) o:(Add16 (Const16 [d]) x))
	// cond: o.Uses == 1
	// result: (Neq16 (Const16 <t> [c-d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt16(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpAdd16 {
				continue
			}
			_ = o.Args[1]
			o_0 := o.Args[0]
			o_1 := o.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 {
				if o_0.Op != ssaop.OpConst16 {
					continue
				}
				d := ssa.AuxIntToInt16(o_0.AuxInt)
				x := o_1
				if !(o.Uses == 1) {
					continue
				}
				v.Reset(ssaop.OpNeq16)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
				v0.AuxInt = ssa.Int16ToAuxInt(c - d)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Neq16 (Const16 <t> [c]) o:(Sub16 x (Const16 [d])))
	// cond: o.Uses == 1
	// result: (Neq16 (Const16 <t> [c+d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt16(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpSub16 {
				continue
			}
			_ = o.Args[1]
			x := o.Args[0]
			o_1 := o.Args[1]
			if o_1.Op != ssaop.OpConst16 {
				continue
			}
			d := ssa.AuxIntToInt16(o_1.AuxInt)
			if !(o.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpNeq16)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
			v0.AuxInt = ssa.Int16ToAuxInt(c + d)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Neq16 (Const16 <t> [c]) o:(Sub16 (Const16 [d]) x))
	// cond: o.Uses == 1
	// result: (Neq16 (Const16 <t> [d-c]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt16(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpSub16 {
				continue
			}
			x := o.Args[1]
			o_0 := o.Args[0]
			if o_0.Op != ssaop.OpConst16 {
				continue
			}
			d := ssa.AuxIntToInt16(o_0.AuxInt)
			if !(o.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpNeq16)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
			v0.AuxInt = ssa.Int16ToAuxInt(d - c)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Neq16 (Const16 <t> [c]) o:(Xor16 (Const16 [d]) x))
	// cond: o.Uses == 1
	// result: (Neq16 (Const16 <t> [d^c]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt16(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpXor16 {
				continue
			}
			_ = o.Args[1]
			o_0 := o.Args[0]
			o_1 := o.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 {
				if o_0.Op != ssaop.OpConst16 {
					continue
				}
				d := ssa.AuxIntToInt16(o_0.AuxInt)
				x := o_1
				if !(o.Uses == 1) {
					continue
				}
				v.Reset(ssaop.OpNeq16)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
				v0.AuxInt = ssa.Int16ToAuxInt(d ^ c)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Neq16 (Const16 <t> [c]) o:(Com16 x))
	// cond: o.Uses == 1
	// result: (Neq16 (Const16 <t> [^c]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt16(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpCom16 {
				continue
			}
			x := o.Args[0]
			if !(o.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpNeq16)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
			v0.AuxInt = ssa.Int16ToAuxInt(^c)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Neq16 (Const16 <t> [c]) o:(Neg16 x))
	// cond: o.Uses == 1
	// result: (Neq16 (Const16 <t> [-c]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt16(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpNeg16 {
				continue
			}
			x := o.Args[0]
			if !(o.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpNeq16)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
			v0.AuxInt = ssa.Int16ToAuxInt(-c)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Neq16 (Const16 <t> [c]) o:(Mul16 (Const16 [d]) x))
	// cond: uint16(d)%2 == 1 && o.Uses == 1
	// result: (Neq16 (Const16 <t> [int16(uint16(c) * uint16(modularMultiplicativeInverse(uint64(d))))]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt16(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpMul16 {
				continue
			}
			_ = o.Args[1]
			o_0 := o.Args[0]
			o_1 := o.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 {
				if o_0.Op != ssaop.OpConst16 {
					continue
				}
				d := ssa.AuxIntToInt16(o_0.AuxInt)
				x := o_1
				if !(uint16(d)%2 == 1 && o.Uses == 1) {
					continue
				}
				v.Reset(ssaop.OpNeq16)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
				v0.AuxInt = ssa.Int16ToAuxInt(int16(uint16(c) * uint16(modularMultiplicativeInverse(uint64(d)))))
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Neq16 (Const16 [c]) (Const16 [d]))
	// result: (ConstBool [c != d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst16 {
				continue
			}
			d := ssa.AuxIntToInt16(v_1.AuxInt)
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(c != d)
			return true
		}
		break
	}
	// match: (Neq16 s:(Sub16 x y) (Const16 [0]))
	// cond: s.Uses == 1
	// result: (Neq16 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			s := v_0
			if s.Op != ssaop.OpSub16 {
				continue
			}
			y := s.Args[1]
			x := s.Args[0]
			if v_1.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_1.AuxInt) != 0 || !(s.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpNeq16)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Neq16 (And16 <t> x (Const16 <t> [y])) (Const16 <t> [y]))
	// cond: ssa.OneBit(y)
	// result: (Eq16 (And16 <t> x (Const16 <t> [y])) (Const16 <t> [0]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpAnd16 {
				continue
			}
			t := v_0.Type
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				x := v_0_0
				if v_0_1.Op != ssaop.OpConst16 || v_0_1.Type != t {
					continue
				}
				y := ssa.AuxIntToInt16(v_0_1.AuxInt)
				if v_1.Op != ssaop.OpConst16 || v_1.Type != t || ssa.AuxIntToInt16(v_1.AuxInt) != y || !(ssa.OneBit(y)) {
					continue
				}
				v.Reset(ssaop.OpEq16)
				v0 := b.NewValue0(v.Pos, ssaop.OpAnd16, t)
				v1 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
				v1.AuxInt = ssa.Int16ToAuxInt(y)
				v0.AddArg2(x, v1)
				v2 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
				v2.AuxInt = ssa.Int16ToAuxInt(0)
				v.AddArg2(v0, v2)
				return true
			}
		}
		break
	}
	// match: (Neq16 (ZeroExt8to16 (CvtBoolToUint8 x)) (Const16 [0]))
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpZeroExt8to16 {
				continue
			}
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpCvtBoolToUint8 {
				continue
			}
			x := v_0_0.Args[0]
			if v_1.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_1.AuxInt) != 0 {
				continue
			}
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (Neq16 (ZeroExt8to16 (CvtBoolToUint8 x)) (Const16 [1]))
	// result: (Not x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpZeroExt8to16 {
				continue
			}
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpCvtBoolToUint8 {
				continue
			}
			x := v_0_0.Args[0]
			if v_1.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_1.AuxInt) != 1 {
				continue
			}
			v.Reset(ssaop.OpNot)
			v.AddArg(x)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpNeq32(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Neq32 x x)
	// result: (ConstBool [false])
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(false)
		return true
	}
	// match: (Neq32 (Const32 <t> [c]) o:(Add32 (Const32 [d]) x))
	// cond: o.Uses == 1
	// result: (Neq32 (Const32 <t> [c-d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt32(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpAdd32 {
				continue
			}
			_ = o.Args[1]
			o_0 := o.Args[0]
			o_1 := o.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 {
				if o_0.Op != ssaop.OpConst32 {
					continue
				}
				d := ssa.AuxIntToInt32(o_0.AuxInt)
				x := o_1
				if !(o.Uses == 1) {
					continue
				}
				v.Reset(ssaop.OpNeq32)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
				v0.AuxInt = ssa.Int32ToAuxInt(c - d)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Neq32 (Const32 <t> [c]) o:(Sub32 x (Const32 [d])))
	// cond: o.Uses == 1
	// result: (Neq32 (Const32 <t> [c+d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt32(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpSub32 {
				continue
			}
			_ = o.Args[1]
			x := o.Args[0]
			o_1 := o.Args[1]
			if o_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(o_1.AuxInt)
			if !(o.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpNeq32)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
			v0.AuxInt = ssa.Int32ToAuxInt(c + d)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Neq32 (Const32 <t> [c]) o:(Sub32 (Const32 [d]) x))
	// cond: o.Uses == 1
	// result: (Neq32 (Const32 <t> [d-c]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt32(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpSub32 {
				continue
			}
			x := o.Args[1]
			o_0 := o.Args[0]
			if o_0.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(o_0.AuxInt)
			if !(o.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpNeq32)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
			v0.AuxInt = ssa.Int32ToAuxInt(d - c)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Neq32 (Const32 <t> [c]) o:(Xor32 (Const32 [d]) x))
	// cond: o.Uses == 1
	// result: (Neq32 (Const32 <t> [d^c]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt32(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpXor32 {
				continue
			}
			_ = o.Args[1]
			o_0 := o.Args[0]
			o_1 := o.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 {
				if o_0.Op != ssaop.OpConst32 {
					continue
				}
				d := ssa.AuxIntToInt32(o_0.AuxInt)
				x := o_1
				if !(o.Uses == 1) {
					continue
				}
				v.Reset(ssaop.OpNeq32)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
				v0.AuxInt = ssa.Int32ToAuxInt(d ^ c)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Neq32 (Const32 <t> [c]) o:(Com32 x))
	// cond: o.Uses == 1
	// result: (Neq32 (Const32 <t> [^c]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt32(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpCom32 {
				continue
			}
			x := o.Args[0]
			if !(o.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpNeq32)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
			v0.AuxInt = ssa.Int32ToAuxInt(^c)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Neq32 (Const32 <t> [c]) o:(Neg32 x))
	// cond: o.Uses == 1
	// result: (Neq32 (Const32 <t> [-c]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt32(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpNeg32 {
				continue
			}
			x := o.Args[0]
			if !(o.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpNeq32)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
			v0.AuxInt = ssa.Int32ToAuxInt(-c)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Neq32 (Const32 <t> [c]) o:(Mul32 (Const32 [d]) x))
	// cond: uint32(d)%2 == 1 && o.Uses == 1
	// result: (Neq32 (Const32 <t> [int32(uint32(c) * uint32(modularMultiplicativeInverse(uint64(d))))]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt32(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpMul32 {
				continue
			}
			_ = o.Args[1]
			o_0 := o.Args[0]
			o_1 := o.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 {
				if o_0.Op != ssaop.OpConst32 {
					continue
				}
				d := ssa.AuxIntToInt32(o_0.AuxInt)
				x := o_1
				if !(uint32(d)%2 == 1 && o.Uses == 1) {
					continue
				}
				v.Reset(ssaop.OpNeq32)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
				v0.AuxInt = ssa.Int32ToAuxInt(int32(uint32(c) * uint32(modularMultiplicativeInverse(uint64(d)))))
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Neq32 (Const32 [c]) (Const32 [d]))
	// result: (ConstBool [c != d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(v_1.AuxInt)
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(c != d)
			return true
		}
		break
	}
	// match: (Neq32 s:(Sub32 x y) (Const32 [0]))
	// cond: s.Uses == 1
	// result: (Neq32 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			s := v_0
			if s.Op != ssaop.OpSub32 {
				continue
			}
			y := s.Args[1]
			x := s.Args[0]
			if v_1.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1.AuxInt) != 0 || !(s.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpNeq32)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Neq32 (And32 <t> x (Const32 <t> [y])) (Const32 <t> [y]))
	// cond: ssa.OneBit(y)
	// result: (Eq32 (And32 <t> x (Const32 <t> [y])) (Const32 <t> [0]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpAnd32 {
				continue
			}
			t := v_0.Type
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				x := v_0_0
				if v_0_1.Op != ssaop.OpConst32 || v_0_1.Type != t {
					continue
				}
				y := ssa.AuxIntToInt32(v_0_1.AuxInt)
				if v_1.Op != ssaop.OpConst32 || v_1.Type != t || ssa.AuxIntToInt32(v_1.AuxInt) != y || !(ssa.OneBit(y)) {
					continue
				}
				v.Reset(ssaop.OpEq32)
				v0 := b.NewValue0(v.Pos, ssaop.OpAnd32, t)
				v1 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
				v1.AuxInt = ssa.Int32ToAuxInt(y)
				v0.AddArg2(x, v1)
				v2 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
				v2.AuxInt = ssa.Int32ToAuxInt(0)
				v.AddArg2(v0, v2)
				return true
			}
		}
		break
	}
	// match: (Neq32 (ZeroExt8to32 (CvtBoolToUint8 x)) (Const32 [0]))
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpZeroExt8to32 {
				continue
			}
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpCvtBoolToUint8 {
				continue
			}
			x := v_0_0.Args[0]
			if v_1.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1.AuxInt) != 0 {
				continue
			}
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (Neq32 (ZeroExt8to32 (CvtBoolToUint8 x)) (Const32 [1]))
	// result: (Not x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpZeroExt8to32 {
				continue
			}
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpCvtBoolToUint8 {
				continue
			}
			x := v_0_0.Args[0]
			if v_1.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1.AuxInt) != 1 {
				continue
			}
			v.Reset(ssaop.OpNot)
			v.AddArg(x)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpNeq32F(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	// match: (Neq32F (Const32F [c]) (Const32F [d]))
	// result: (ConstBool [c != d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32F {
				continue
			}
			c := ssa.AuxIntToFloat32(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst32F {
				continue
			}
			d := ssa.AuxIntToFloat32(v_1.AuxInt)
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(c != d)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpNeq64(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Neq64 x x)
	// result: (ConstBool [false])
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(false)
		return true
	}
	// match: (Neq64 (Const64 <t> [c]) o:(Add64 (Const64 [d]) x))
	// cond: o.Uses == 1
	// result: (Neq64 (Const64 <t> [c-d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt64(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpAdd64 {
				continue
			}
			_ = o.Args[1]
			o_0 := o.Args[0]
			o_1 := o.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 {
				if o_0.Op != ssaop.OpConst64 {
					continue
				}
				d := ssa.AuxIntToInt64(o_0.AuxInt)
				x := o_1
				if !(o.Uses == 1) {
					continue
				}
				v.Reset(ssaop.OpNeq64)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
				v0.AuxInt = ssa.Int64ToAuxInt(c - d)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Neq64 (Const64 <t> [c]) o:(Sub64 x (Const64 [d])))
	// cond: o.Uses == 1
	// result: (Neq64 (Const64 <t> [c+d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt64(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpSub64 {
				continue
			}
			_ = o.Args[1]
			x := o.Args[0]
			o_1 := o.Args[1]
			if o_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(o_1.AuxInt)
			if !(o.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpNeq64)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
			v0.AuxInt = ssa.Int64ToAuxInt(c + d)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Neq64 (Const64 <t> [c]) o:(Sub64 (Const64 [d]) x))
	// cond: o.Uses == 1
	// result: (Neq64 (Const64 <t> [d-c]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt64(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpSub64 {
				continue
			}
			x := o.Args[1]
			o_0 := o.Args[0]
			if o_0.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(o_0.AuxInt)
			if !(o.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpNeq64)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
			v0.AuxInt = ssa.Int64ToAuxInt(d - c)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Neq64 (Const64 <t> [c]) o:(Xor64 (Const64 [d]) x))
	// cond: o.Uses == 1
	// result: (Neq64 (Const64 <t> [d^c]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt64(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpXor64 {
				continue
			}
			_ = o.Args[1]
			o_0 := o.Args[0]
			o_1 := o.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 {
				if o_0.Op != ssaop.OpConst64 {
					continue
				}
				d := ssa.AuxIntToInt64(o_0.AuxInt)
				x := o_1
				if !(o.Uses == 1) {
					continue
				}
				v.Reset(ssaop.OpNeq64)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
				v0.AuxInt = ssa.Int64ToAuxInt(d ^ c)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Neq64 (Const64 <t> [c]) o:(Com64 x))
	// cond: o.Uses == 1
	// result: (Neq64 (Const64 <t> [^c]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt64(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpCom64 {
				continue
			}
			x := o.Args[0]
			if !(o.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpNeq64)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
			v0.AuxInt = ssa.Int64ToAuxInt(^c)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Neq64 (Const64 <t> [c]) o:(Neg64 x))
	// cond: o.Uses == 1
	// result: (Neq64 (Const64 <t> [-c]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt64(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpNeg64 {
				continue
			}
			x := o.Args[0]
			if !(o.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpNeq64)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
			v0.AuxInt = ssa.Int64ToAuxInt(-c)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Neq64 (Const64 <t> [c]) o:(Mul64 (Const64 [d]) x))
	// cond: uint64(d)%2 == 1 && o.Uses == 1
	// result: (Neq64 (Const64 <t> [int64(uint64(c) * modularMultiplicativeInverse(uint64(d))) ]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt64(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpMul64 {
				continue
			}
			_ = o.Args[1]
			o_0 := o.Args[0]
			o_1 := o.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 {
				if o_0.Op != ssaop.OpConst64 {
					continue
				}
				d := ssa.AuxIntToInt64(o_0.AuxInt)
				x := o_1
				if !(uint64(d)%2 == 1 && o.Uses == 1) {
					continue
				}
				v.Reset(ssaop.OpNeq64)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
				v0.AuxInt = ssa.Int64ToAuxInt(int64(uint64(c) * modularMultiplicativeInverse(uint64(d))))
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Neq64 (Const64 [c]) (Const64 [d]))
	// result: (ConstBool [c != d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1.AuxInt)
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(c != d)
			return true
		}
		break
	}
	// match: (Neq64 s:(Sub64 x y) (Const64 [0]))
	// cond: s.Uses == 1
	// result: (Neq64 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			s := v_0
			if s.Op != ssaop.OpSub64 {
				continue
			}
			y := s.Args[1]
			x := s.Args[0]
			if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 || !(s.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpNeq64)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Neq64 (And64 <t> x (Const64 <t> [y])) (Const64 <t> [y]))
	// cond: ssa.OneBit(y)
	// result: (Eq64 (And64 <t> x (Const64 <t> [y])) (Const64 <t> [0]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpAnd64 {
				continue
			}
			t := v_0.Type
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				x := v_0_0
				if v_0_1.Op != ssaop.OpConst64 || v_0_1.Type != t {
					continue
				}
				y := ssa.AuxIntToInt64(v_0_1.AuxInt)
				if v_1.Op != ssaop.OpConst64 || v_1.Type != t || ssa.AuxIntToInt64(v_1.AuxInt) != y || !(ssa.OneBit(y)) {
					continue
				}
				v.Reset(ssaop.OpEq64)
				v0 := b.NewValue0(v.Pos, ssaop.OpAnd64, t)
				v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
				v1.AuxInt = ssa.Int64ToAuxInt(y)
				v0.AddArg2(x, v1)
				v2 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
				v2.AuxInt = ssa.Int64ToAuxInt(0)
				v.AddArg2(v0, v2)
				return true
			}
		}
		break
	}
	// match: (Neq64 (ZeroExt8to64 (CvtBoolToUint8 x)) (Const64 [0]))
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpZeroExt8to64 {
				continue
			}
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpCvtBoolToUint8 {
				continue
			}
			x := v_0_0.Args[0]
			if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 {
				continue
			}
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (Neq64 (ZeroExt8to64 (CvtBoolToUint8 x)) (Const64 [1]))
	// result: (Not x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpZeroExt8to64 {
				continue
			}
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpCvtBoolToUint8 {
				continue
			}
			x := v_0_0.Args[0]
			if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 1 {
				continue
			}
			v.Reset(ssaop.OpNot)
			v.AddArg(x)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpNeq64F(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	// match: (Neq64F (Const64F [c]) (Const64F [d]))
	// result: (ConstBool [c != d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64F {
				continue
			}
			c := ssa.AuxIntToFloat64(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst64F {
				continue
			}
			d := ssa.AuxIntToFloat64(v_1.AuxInt)
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(c != d)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpNeq8(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Neq8 x x)
	// result: (ConstBool [false])
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(false)
		return true
	}
	// match: (Neq8 (Const8 <t> [c]) o:(Add8 (Const8 [d]) x))
	// cond: o.Uses == 1
	// result: (Neq8 (Const8 <t> [c-d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt8(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpAdd8 {
				continue
			}
			_ = o.Args[1]
			o_0 := o.Args[0]
			o_1 := o.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 {
				if o_0.Op != ssaop.OpConst8 {
					continue
				}
				d := ssa.AuxIntToInt8(o_0.AuxInt)
				x := o_1
				if !(o.Uses == 1) {
					continue
				}
				v.Reset(ssaop.OpNeq8)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
				v0.AuxInt = ssa.Int8ToAuxInt(c - d)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Neq8 (Const8 <t> [c]) o:(Sub8 x (Const8 [d])))
	// cond: o.Uses == 1
	// result: (Neq8 (Const8 <t> [c+d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt8(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpSub8 {
				continue
			}
			_ = o.Args[1]
			x := o.Args[0]
			o_1 := o.Args[1]
			if o_1.Op != ssaop.OpConst8 {
				continue
			}
			d := ssa.AuxIntToInt8(o_1.AuxInt)
			if !(o.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpNeq8)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
			v0.AuxInt = ssa.Int8ToAuxInt(c + d)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Neq8 (Const8 <t> [c]) o:(Sub8 (Const8 [d]) x))
	// cond: o.Uses == 1
	// result: (Neq8 (Const8 <t> [d-c]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt8(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpSub8 {
				continue
			}
			x := o.Args[1]
			o_0 := o.Args[0]
			if o_0.Op != ssaop.OpConst8 {
				continue
			}
			d := ssa.AuxIntToInt8(o_0.AuxInt)
			if !(o.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpNeq8)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
			v0.AuxInt = ssa.Int8ToAuxInt(d - c)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Neq8 (Const8 <t> [c]) o:(Xor8 (Const8 [d]) x))
	// cond: o.Uses == 1
	// result: (Neq8 (Const8 <t> [d^c]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt8(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpXor8 {
				continue
			}
			_ = o.Args[1]
			o_0 := o.Args[0]
			o_1 := o.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 {
				if o_0.Op != ssaop.OpConst8 {
					continue
				}
				d := ssa.AuxIntToInt8(o_0.AuxInt)
				x := o_1
				if !(o.Uses == 1) {
					continue
				}
				v.Reset(ssaop.OpNeq8)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
				v0.AuxInt = ssa.Int8ToAuxInt(d ^ c)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Neq8 (Const8 <t> [c]) o:(Com8 x))
	// cond: o.Uses == 1
	// result: (Neq8 (Const8 <t> [^c]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt8(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpCom8 {
				continue
			}
			x := o.Args[0]
			if !(o.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpNeq8)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
			v0.AuxInt = ssa.Int8ToAuxInt(^c)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Neq8 (Const8 <t> [c]) o:(Neg8 x))
	// cond: o.Uses == 1
	// result: (Neq8 (Const8 <t> [-c]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt8(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpNeg8 {
				continue
			}
			x := o.Args[0]
			if !(o.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpNeq8)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
			v0.AuxInt = ssa.Int8ToAuxInt(-c)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	// match: (Neq8 (Const8 <t> [c]) o:(Mul8 (Const8 [d]) x))
	// cond: uint8( d)%2 == 1 && o.Uses == 1
	// result: (Neq8 (Const8 <t> [int8( uint8( c) * uint8( modularMultiplicativeInverse(uint64(d))))]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt8(v_0.AuxInt)
			o := v_1
			if o.Op != ssaop.OpMul8 {
				continue
			}
			_ = o.Args[1]
			o_0 := o.Args[0]
			o_1 := o.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 {
				if o_0.Op != ssaop.OpConst8 {
					continue
				}
				d := ssa.AuxIntToInt8(o_0.AuxInt)
				x := o_1
				if !(uint8(d)%2 == 1 && o.Uses == 1) {
					continue
				}
				v.Reset(ssaop.OpNeq8)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
				v0.AuxInt = ssa.Int8ToAuxInt(int8(uint8(c) * uint8(modularMultiplicativeInverse(uint64(d)))))
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Neq8 (Const8 [c]) (Const8 [d]))
	// result: (ConstBool [c != d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst8 {
				continue
			}
			d := ssa.AuxIntToInt8(v_1.AuxInt)
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(c != d)
			return true
		}
		break
	}
	// match: (Neq8 s:(Sub8 x y) (Const8 [0]))
	// cond: s.Uses == 1
	// result: (Neq8 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			s := v_0
			if s.Op != ssaop.OpSub8 {
				continue
			}
			y := s.Args[1]
			x := s.Args[0]
			if v_1.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_1.AuxInt) != 0 || !(s.Uses == 1) {
				continue
			}
			v.Reset(ssaop.OpNeq8)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Neq8 (And8 <t> x (Const8 <t> [y])) (Const8 <t> [y]))
	// cond: ssa.OneBit(y)
	// result: (Eq8 (And8 <t> x (Const8 <t> [y])) (Const8 <t> [0]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpAnd8 {
				continue
			}
			t := v_0.Type
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				x := v_0_0
				if v_0_1.Op != ssaop.OpConst8 || v_0_1.Type != t {
					continue
				}
				y := ssa.AuxIntToInt8(v_0_1.AuxInt)
				if v_1.Op != ssaop.OpConst8 || v_1.Type != t || ssa.AuxIntToInt8(v_1.AuxInt) != y || !(ssa.OneBit(y)) {
					continue
				}
				v.Reset(ssaop.OpEq8)
				v0 := b.NewValue0(v.Pos, ssaop.OpAnd8, t)
				v1 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
				v1.AuxInt = ssa.Int8ToAuxInt(y)
				v0.AddArg2(x, v1)
				v2 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
				v2.AuxInt = ssa.Int8ToAuxInt(0)
				v.AddArg2(v0, v2)
				return true
			}
		}
		break
	}
	// match: (Neq8 (CvtBoolToUint8 x) (Const8 [0]))
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpCvtBoolToUint8 {
				continue
			}
			x := v_0.Args[0]
			if v_1.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_1.AuxInt) != 0 {
				continue
			}
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (Neq8 (CvtBoolToUint8 x) (Const8 [1]))
	// result: (Not x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpCvtBoolToUint8 {
				continue
			}
			x := v_0.Args[0]
			if v_1.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_1.AuxInt) != 1 {
				continue
			}
			v.Reset(ssaop.OpNot)
			v.AddArg(x)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpNeqB(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	// match: (NeqB x x)
	// result: (ConstBool [false])
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(false)
		return true
	}
	// match: (NeqB (ConstBool [c]) (ConstBool [d]))
	// result: (ConstBool [c != d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConstBool {
				continue
			}
			c := ssa.AuxIntToBool(v_0.AuxInt)
			if v_1.Op != ssaop.OpConstBool {
				continue
			}
			d := ssa.AuxIntToBool(v_1.AuxInt)
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(c != d)
			return true
		}
		break
	}
	// match: (NeqB (ConstBool [false]) x)
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConstBool || ssa.AuxIntToBool(v_0.AuxInt) != false {
				continue
			}
			x := v_1
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (NeqB (ConstBool [true]) x)
	// result: (Not x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConstBool || ssa.AuxIntToBool(v_0.AuxInt) != true {
				continue
			}
			x := v_1
			v.Reset(ssaop.OpNot)
			v.AddArg(x)
			return true
		}
		break
	}
	// match: (NeqB (Not x) y)
	// result: (EqB x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNot {
				continue
			}
			x := v_0.Args[0]
			y := v_1
			v.Reset(ssaop.OpEqB)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpNeqInter(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (NeqInter x y)
	// result: (NeqPtr (ITab x) (ITab y))
	for {
		x := v_0
		y := v_1
		v.Reset(ssaop.OpNeqPtr)
		v0 := b.NewValue0(v.Pos, ssaop.OpITab, typ.Uintptr)
		v0.AddArg(x)
		v1 := b.NewValue0(v.Pos, ssaop.OpITab, typ.Uintptr)
		v1.AddArg(y)
		v.AddArg2(v0, v1)
		return true
	}
}
func rewriteValue_OpNeqPtr(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	// match: (NeqPtr x x)
	// result: (ConstBool [false])
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(false)
		return true
	}
	// match: (NeqPtr (Addr {x} _) (Addr {y} _))
	// result: (ConstBool [x != y])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpAddr {
				continue
			}
			x := ssa.AuxToSym(v_0.Aux)
			if v_1.Op != ssaop.OpAddr {
				continue
			}
			y := ssa.AuxToSym(v_1.Aux)
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(x != y)
			return true
		}
		break
	}
	// match: (NeqPtr (Addr {x} _) (OffPtr [o] (Addr {y} _)))
	// result: (ConstBool [x != y || o != 0])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpAddr {
				continue
			}
			x := ssa.AuxToSym(v_0.Aux)
			if v_1.Op != ssaop.OpOffPtr {
				continue
			}
			o := ssa.AuxIntToInt64(v_1.AuxInt)
			v_1_0 := v_1.Args[0]
			if v_1_0.Op != ssaop.OpAddr {
				continue
			}
			y := ssa.AuxToSym(v_1_0.Aux)
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(x != y || o != 0)
			return true
		}
		break
	}
	// match: (NeqPtr (OffPtr [o1] (Addr {x} _)) (OffPtr [o2] (Addr {y} _)))
	// result: (ConstBool [x != y || o1 != o2])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpOffPtr {
				continue
			}
			o1 := ssa.AuxIntToInt64(v_0.AuxInt)
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpAddr {
				continue
			}
			x := ssa.AuxToSym(v_0_0.Aux)
			if v_1.Op != ssaop.OpOffPtr {
				continue
			}
			o2 := ssa.AuxIntToInt64(v_1.AuxInt)
			v_1_0 := v_1.Args[0]
			if v_1_0.Op != ssaop.OpAddr {
				continue
			}
			y := ssa.AuxToSym(v_1_0.Aux)
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(x != y || o1 != o2)
			return true
		}
		break
	}
	// match: (NeqPtr (LocalAddr {x} _ _) (LocalAddr {y} _ _))
	// result: (ConstBool [x != y])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLocalAddr {
				continue
			}
			x := ssa.AuxToSym(v_0.Aux)
			if v_1.Op != ssaop.OpLocalAddr {
				continue
			}
			y := ssa.AuxToSym(v_1.Aux)
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(x != y)
			return true
		}
		break
	}
	// match: (NeqPtr (LocalAddr {x} _ _) (OffPtr [o] (LocalAddr {y} _ _)))
	// result: (ConstBool [x != y || o != 0])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLocalAddr {
				continue
			}
			x := ssa.AuxToSym(v_0.Aux)
			if v_1.Op != ssaop.OpOffPtr {
				continue
			}
			o := ssa.AuxIntToInt64(v_1.AuxInt)
			v_1_0 := v_1.Args[0]
			if v_1_0.Op != ssaop.OpLocalAddr {
				continue
			}
			y := ssa.AuxToSym(v_1_0.Aux)
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(x != y || o != 0)
			return true
		}
		break
	}
	// match: (NeqPtr (OffPtr [o1] (LocalAddr {x} _ _)) (OffPtr [o2] (LocalAddr {y} _ _)))
	// result: (ConstBool [x != y || o1 != o2])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpOffPtr {
				continue
			}
			o1 := ssa.AuxIntToInt64(v_0.AuxInt)
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpLocalAddr {
				continue
			}
			x := ssa.AuxToSym(v_0_0.Aux)
			if v_1.Op != ssaop.OpOffPtr {
				continue
			}
			o2 := ssa.AuxIntToInt64(v_1.AuxInt)
			v_1_0 := v_1.Args[0]
			if v_1_0.Op != ssaop.OpLocalAddr {
				continue
			}
			y := ssa.AuxToSym(v_1_0.Aux)
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(x != y || o1 != o2)
			return true
		}
		break
	}
	// match: (NeqPtr (OffPtr [o1] p1) p2)
	// cond: ssa.IsSamePtr(p1, p2)
	// result: (ConstBool [o1 != 0])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpOffPtr {
				continue
			}
			o1 := ssa.AuxIntToInt64(v_0.AuxInt)
			p1 := v_0.Args[0]
			p2 := v_1
			if !(ssa.IsSamePtr(p1, p2)) {
				continue
			}
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(o1 != 0)
			return true
		}
		break
	}
	// match: (NeqPtr (OffPtr [o1] p1) (OffPtr [o2] p2))
	// cond: ssa.IsSamePtr(p1, p2)
	// result: (ConstBool [o1 != o2])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpOffPtr {
				continue
			}
			o1 := ssa.AuxIntToInt64(v_0.AuxInt)
			p1 := v_0.Args[0]
			if v_1.Op != ssaop.OpOffPtr {
				continue
			}
			o2 := ssa.AuxIntToInt64(v_1.AuxInt)
			p2 := v_1.Args[0]
			if !(ssa.IsSamePtr(p1, p2)) {
				continue
			}
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(o1 != o2)
			return true
		}
		break
	}
	// match: (NeqPtr (Const32 [c]) (Const32 [d]))
	// result: (ConstBool [c != d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(v_1.AuxInt)
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(c != d)
			return true
		}
		break
	}
	// match: (NeqPtr (Const64 [c]) (Const64 [d]))
	// result: (ConstBool [c != d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1.AuxInt)
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(c != d)
			return true
		}
		break
	}
	// match: (NeqPtr (Convert (Addr {x} _) _) (Addr {y} _))
	// result: (ConstBool [x!=y])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConvert {
				continue
			}
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpAddr {
				continue
			}
			x := ssa.AuxToSym(v_0_0.Aux)
			if v_1.Op != ssaop.OpAddr {
				continue
			}
			y := ssa.AuxToSym(v_1.Aux)
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(x != y)
			return true
		}
		break
	}
	// match: (NeqPtr (LocalAddr _ _) (Addr _))
	// result: (ConstBool [true])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLocalAddr || v_1.Op != ssaop.OpAddr {
				continue
			}
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(true)
			return true
		}
		break
	}
	// match: (NeqPtr (OffPtr (LocalAddr _ _)) (Addr _))
	// result: (ConstBool [true])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpOffPtr {
				continue
			}
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpLocalAddr || v_1.Op != ssaop.OpAddr {
				continue
			}
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(true)
			return true
		}
		break
	}
	// match: (NeqPtr (LocalAddr _ _) (OffPtr (Addr _)))
	// result: (ConstBool [true])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLocalAddr || v_1.Op != ssaop.OpOffPtr {
				continue
			}
			v_1_0 := v_1.Args[0]
			if v_1_0.Op != ssaop.OpAddr {
				continue
			}
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(true)
			return true
		}
		break
	}
	// match: (NeqPtr (OffPtr (LocalAddr _ _)) (OffPtr (Addr _)))
	// result: (ConstBool [true])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpOffPtr {
				continue
			}
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpLocalAddr || v_1.Op != ssaop.OpOffPtr {
				continue
			}
			v_1_0 := v_1.Args[0]
			if v_1_0.Op != ssaop.OpAddr {
				continue
			}
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(true)
			return true
		}
		break
	}
	// match: (NeqPtr (AddPtr p1 o1) p2)
	// cond: ssa.IsSamePtr(p1, p2)
	// result: (IsNonNil o1)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpAddPtr {
				continue
			}
			o1 := v_0.Args[1]
			p1 := v_0.Args[0]
			p2 := v_1
			if !(ssa.IsSamePtr(p1, p2)) {
				continue
			}
			v.Reset(ssaop.OpIsNonNil)
			v.AddArg(o1)
			return true
		}
		break
	}
	// match: (NeqPtr (Const32 [0]) p)
	// result: (IsNonNil p)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 {
				continue
			}
			p := v_1
			v.Reset(ssaop.OpIsNonNil)
			v.AddArg(p)
			return true
		}
		break
	}
	// match: (NeqPtr (Const64 [0]) p)
	// result: (IsNonNil p)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 {
				continue
			}
			p := v_1
			v.Reset(ssaop.OpIsNonNil)
			v.AddArg(p)
			return true
		}
		break
	}
	// match: (NeqPtr (ConstNil) p)
	// result: (IsNonNil p)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConstNil {
				continue
			}
			p := v_1
			v.Reset(ssaop.OpIsNonNil)
			v.AddArg(p)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpNeqSlice(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (NeqSlice x y)
	// result: (NeqPtr (SlicePtr x) (SlicePtr y))
	for {
		x := v_0
		y := v_1
		v.Reset(ssaop.OpNeqPtr)
		v0 := b.NewValue0(v.Pos, ssaop.OpSlicePtr, typ.BytePtr)
		v0.AddArg(x)
		v1 := b.NewValue0(v.Pos, ssaop.OpSlicePtr, typ.BytePtr)
		v1.AddArg(y)
		v.AddArg2(v0, v1)
		return true
	}
}
func rewriteValue_OpNilCheck(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	fe := b.Func.Fe
	// match: (NilCheck ptr:(GetG mem) mem)
	// result: ptr
	for {
		ptr := v_0
		if ptr.Op != ssaop.OpGetG {
			break
		}
		mem := ptr.Args[0]
		if mem != v_1 {
			break
		}
		v.CopyOf(ptr)
		return true
	}
	// match: (NilCheck ptr:(SelectN [0] call:(StaticLECall ___)) _)
	// cond: isMalloc(call.Aux) && warnRule(fe.Debug_checknil(), v, "removed nil check")
	// result: ptr
	for {
		ptr := v_0
		if ptr.Op != ssaop.OpSelectN || ssa.AuxIntToInt64(ptr.AuxInt) != 0 {
			break
		}
		call := ptr.Args[0]
		if call.Op != ssaop.OpStaticLECall {
			break
		}
		if !(isMalloc(call.Aux) && warnRule(fe.Debug_checknil(), v, "removed nil check")) {
			break
		}
		v.CopyOf(ptr)
		return true
	}
	// match: (NilCheck ptr:(OffPtr (SelectN [0] call:(StaticLECall ___))) _)
	// cond: isMalloc(call.Aux) && warnRule(fe.Debug_checknil(), v, "removed nil check")
	// result: ptr
	for {
		ptr := v_0
		if ptr.Op != ssaop.OpOffPtr {
			break
		}
		ptr_0 := ptr.Args[0]
		if ptr_0.Op != ssaop.OpSelectN || ssa.AuxIntToInt64(ptr_0.AuxInt) != 0 {
			break
		}
		call := ptr_0.Args[0]
		if call.Op != ssaop.OpStaticLECall {
			break
		}
		if !(isMalloc(call.Aux) && warnRule(fe.Debug_checknil(), v, "removed nil check")) {
			break
		}
		v.CopyOf(ptr)
		return true
	}
	// match: (NilCheck ptr:(Addr {_} (SB)) _)
	// result: ptr
	for {
		ptr := v_0
		if ptr.Op != ssaop.OpAddr {
			break
		}
		ptr_0 := ptr.Args[0]
		if ptr_0.Op != ssaop.OpSB {
			break
		}
		v.CopyOf(ptr)
		return true
	}
	// match: (NilCheck ptr:(Convert (Addr {_} (SB)) _) _)
	// result: ptr
	for {
		ptr := v_0
		if ptr.Op != ssaop.OpConvert {
			break
		}
		ptr_0 := ptr.Args[0]
		if ptr_0.Op != ssaop.OpAddr {
			break
		}
		ptr_0_0 := ptr_0.Args[0]
		if ptr_0_0.Op != ssaop.OpSB {
			break
		}
		v.CopyOf(ptr)
		return true
	}
	// match: (NilCheck ptr:(LocalAddr _ _) _)
	// cond: warnRule(fe.Debug_checknil(), v, "removed nil check")
	// result: ptr
	for {
		ptr := v_0
		if ptr.Op != ssaop.OpLocalAddr || !(warnRule(fe.Debug_checknil(), v, "removed nil check")) {
			break
		}
		v.CopyOf(ptr)
		return true
	}
	// match: (NilCheck ptr:(Arg {sym}) _)
	// cond: isDictArgSym(sym)
	// result: ptr
	for {
		ptr := v_0
		if ptr.Op != ssaop.OpArg {
			break
		}
		sym := ssa.AuxToSym(ptr.Aux)
		if !(isDictArgSym(sym)) {
			break
		}
		v.CopyOf(ptr)
		return true
	}
	// match: (NilCheck ptr:(NilCheck _ _) _ )
	// result: ptr
	for {
		ptr := v_0
		if ptr.Op != ssaop.OpNilCheck {
			break
		}
		v.CopyOf(ptr)
		return true
	}
	return false
}
func rewriteValue_OpNot(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (Not (ConstBool [c]))
	// result: (ConstBool [!c])
	for {
		if v_0.Op != ssaop.OpConstBool {
			break
		}
		c := ssa.AuxIntToBool(v_0.AuxInt)
		v.Reset(ssaop.OpConstBool)
		v.AuxInt = ssa.BoolToAuxInt(!c)
		return true
	}
	// match: (Not (Eq64 x y))
	// result: (Neq64 x y)
	for {
		if v_0.Op != ssaop.OpEq64 {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpNeq64)
		v.AddArg2(x, y)
		return true
	}
	// match: (Not (Eq32 x y))
	// result: (Neq32 x y)
	for {
		if v_0.Op != ssaop.OpEq32 {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpNeq32)
		v.AddArg2(x, y)
		return true
	}
	// match: (Not (Eq16 x y))
	// result: (Neq16 x y)
	for {
		if v_0.Op != ssaop.OpEq16 {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpNeq16)
		v.AddArg2(x, y)
		return true
	}
	// match: (Not (Eq8 x y))
	// result: (Neq8 x y)
	for {
		if v_0.Op != ssaop.OpEq8 {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpNeq8)
		v.AddArg2(x, y)
		return true
	}
	// match: (Not (EqB x y))
	// result: (NeqB x y)
	for {
		if v_0.Op != ssaop.OpEqB {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpNeqB)
		v.AddArg2(x, y)
		return true
	}
	// match: (Not (EqPtr x y))
	// result: (NeqPtr x y)
	for {
		if v_0.Op != ssaop.OpEqPtr {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpNeqPtr)
		v.AddArg2(x, y)
		return true
	}
	// match: (Not (Eq64F x y))
	// result: (Neq64F x y)
	for {
		if v_0.Op != ssaop.OpEq64F {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpNeq64F)
		v.AddArg2(x, y)
		return true
	}
	// match: (Not (Eq32F x y))
	// result: (Neq32F x y)
	for {
		if v_0.Op != ssaop.OpEq32F {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpNeq32F)
		v.AddArg2(x, y)
		return true
	}
	// match: (Not (Neq64 x y))
	// result: (Eq64 x y)
	for {
		if v_0.Op != ssaop.OpNeq64 {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpEq64)
		v.AddArg2(x, y)
		return true
	}
	// match: (Not (Neq32 x y))
	// result: (Eq32 x y)
	for {
		if v_0.Op != ssaop.OpNeq32 {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpEq32)
		v.AddArg2(x, y)
		return true
	}
	// match: (Not (Neq16 x y))
	// result: (Eq16 x y)
	for {
		if v_0.Op != ssaop.OpNeq16 {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpEq16)
		v.AddArg2(x, y)
		return true
	}
	// match: (Not (Neq8 x y))
	// result: (Eq8 x y)
	for {
		if v_0.Op != ssaop.OpNeq8 {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpEq8)
		v.AddArg2(x, y)
		return true
	}
	// match: (Not (NeqB x y))
	// result: (EqB x y)
	for {
		if v_0.Op != ssaop.OpNeqB {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpEqB)
		v.AddArg2(x, y)
		return true
	}
	// match: (Not (NeqPtr x y))
	// result: (EqPtr x y)
	for {
		if v_0.Op != ssaop.OpNeqPtr {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpEqPtr)
		v.AddArg2(x, y)
		return true
	}
	// match: (Not (Neq64F x y))
	// result: (Eq64F x y)
	for {
		if v_0.Op != ssaop.OpNeq64F {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpEq64F)
		v.AddArg2(x, y)
		return true
	}
	// match: (Not (Neq32F x y))
	// result: (Eq32F x y)
	for {
		if v_0.Op != ssaop.OpNeq32F {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpEq32F)
		v.AddArg2(x, y)
		return true
	}
	// match: (Not (Less64 x y))
	// result: (Leq64 y x)
	for {
		if v_0.Op != ssaop.OpLess64 {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpLeq64)
		v.AddArg2(y, x)
		return true
	}
	// match: (Not (Less32 x y))
	// result: (Leq32 y x)
	for {
		if v_0.Op != ssaop.OpLess32 {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpLeq32)
		v.AddArg2(y, x)
		return true
	}
	// match: (Not (Less16 x y))
	// result: (Leq16 y x)
	for {
		if v_0.Op != ssaop.OpLess16 {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpLeq16)
		v.AddArg2(y, x)
		return true
	}
	// match: (Not (Less8 x y))
	// result: (Leq8 y x)
	for {
		if v_0.Op != ssaop.OpLess8 {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpLeq8)
		v.AddArg2(y, x)
		return true
	}
	// match: (Not (Less64U x y))
	// result: (Leq64U y x)
	for {
		if v_0.Op != ssaop.OpLess64U {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpLeq64U)
		v.AddArg2(y, x)
		return true
	}
	// match: (Not (Less32U x y))
	// result: (Leq32U y x)
	for {
		if v_0.Op != ssaop.OpLess32U {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpLeq32U)
		v.AddArg2(y, x)
		return true
	}
	// match: (Not (Less16U x y))
	// result: (Leq16U y x)
	for {
		if v_0.Op != ssaop.OpLess16U {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpLeq16U)
		v.AddArg2(y, x)
		return true
	}
	// match: (Not (Less8U x y))
	// result: (Leq8U y x)
	for {
		if v_0.Op != ssaop.OpLess8U {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpLeq8U)
		v.AddArg2(y, x)
		return true
	}
	// match: (Not (Leq64 x y))
	// result: (Less64 y x)
	for {
		if v_0.Op != ssaop.OpLeq64 {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpLess64)
		v.AddArg2(y, x)
		return true
	}
	// match: (Not (Leq32 x y))
	// result: (Less32 y x)
	for {
		if v_0.Op != ssaop.OpLeq32 {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpLess32)
		v.AddArg2(y, x)
		return true
	}
	// match: (Not (Leq16 x y))
	// result: (Less16 y x)
	for {
		if v_0.Op != ssaop.OpLeq16 {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpLess16)
		v.AddArg2(y, x)
		return true
	}
	// match: (Not (Leq8 x y))
	// result: (Less8 y x)
	for {
		if v_0.Op != ssaop.OpLeq8 {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpLess8)
		v.AddArg2(y, x)
		return true
	}
	// match: (Not (Leq64U x y))
	// result: (Less64U y x)
	for {
		if v_0.Op != ssaop.OpLeq64U {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpLess64U)
		v.AddArg2(y, x)
		return true
	}
	// match: (Not (Leq32U x y))
	// result: (Less32U y x)
	for {
		if v_0.Op != ssaop.OpLeq32U {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpLess32U)
		v.AddArg2(y, x)
		return true
	}
	// match: (Not (Leq16U x y))
	// result: (Less16U y x)
	for {
		if v_0.Op != ssaop.OpLeq16U {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpLess16U)
		v.AddArg2(y, x)
		return true
	}
	// match: (Not (Leq8U x y))
	// result: (Less8U y x)
	for {
		if v_0.Op != ssaop.OpLeq8U {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		v.Reset(ssaop.OpLess8U)
		v.AddArg2(y, x)
		return true
	}
	return false
}
func rewriteValue_OpOffPtr(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (OffPtr (OffPtr p [y]) [x])
	// result: (OffPtr p [x+y])
	for {
		x := ssa.AuxIntToInt64(v.AuxInt)
		if v_0.Op != ssaop.OpOffPtr {
			break
		}
		y := ssa.AuxIntToInt64(v_0.AuxInt)
		p := v_0.Args[0]
		v.Reset(ssaop.OpOffPtr)
		v.AuxInt = ssa.Int64ToAuxInt(x + y)
		v.AddArg(p)
		return true
	}
	// match: (OffPtr p [0])
	// cond: v.Type.Compare(p.Type) == types.CMPeq
	// result: p
	for {
		if ssa.AuxIntToInt64(v.AuxInt) != 0 {
			break
		}
		p := v_0
		if !(v.Type.Compare(p.Type) == types.CMPeq) {
			break
		}
		v.CopyOf(p)
		return true
	}
	return false
}
func rewriteValue_OpOr16(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	// match: (Or16 (Const16 [c]) (Const16 [d]))
	// result: (Const16 [c|d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst16 {
				continue
			}
			d := ssa.AuxIntToInt16(v_1.AuxInt)
			v.Reset(ssaop.OpConst16)
			v.AuxInt = ssa.Int16ToAuxInt(c | d)
			return true
		}
		break
	}
	// match: (Or16 <t> (Com16 x) (Com16 y))
	// result: (Com16 (And16 <t> x y))
	for {
		t := v.Type
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpCom16 {
				continue
			}
			x := v_0.Args[0]
			if v_1.Op != ssaop.OpCom16 {
				continue
			}
			y := v_1.Args[0]
			v.Reset(ssaop.OpCom16)
			v0 := b.NewValue0(v.Pos, ssaop.OpAnd16, t)
			v0.AddArg2(x, y)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (Or16 x (And16 x y))
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpAnd16 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if x != v_1_0 {
					continue
				}
				v.CopyOf(x)
				return true
			}
		}
		break
	}
	// match: (Or16 x x)
	// result: x
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (Or16 (Const16 [0]) x)
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 {
				continue
			}
			x := v_1
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (Or16 (Const16 [-1]) _)
	// result: (Const16 [-1])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != -1 {
				continue
			}
			v.Reset(ssaop.OpConst16)
			v.AuxInt = ssa.Int16ToAuxInt(-1)
			return true
		}
		break
	}
	// match: (Or16 (Com16 x) x)
	// result: (Const16 [-1])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpCom16 {
				continue
			}
			x := v_0.Args[0]
			if x != v_1 {
				continue
			}
			v.Reset(ssaop.OpConst16)
			v.AuxInt = ssa.Int16ToAuxInt(-1)
			return true
		}
		break
	}
	// match: (Or16 x (Or16 x y))
	// result: (Or16 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpOr16 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if x != v_1_0 {
					continue
				}
				y := v_1_1
				v.Reset(ssaop.OpOr16)
				v.AddArg2(x, y)
				return true
			}
		}
		break
	}
	// match: (Or16 (And16 x (Const16 [c2])) (Const16 <t> [c1]))
	// cond: ^(c1 | c2) == 0
	// result: (Or16 (Const16 <t> [c1]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpAnd16 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				x := v_0_0
				if v_0_1.Op != ssaop.OpConst16 {
					continue
				}
				c2 := ssa.AuxIntToInt16(v_0_1.AuxInt)
				if v_1.Op != ssaop.OpConst16 {
					continue
				}
				t := v_1.Type
				c1 := ssa.AuxIntToInt16(v_1.AuxInt)
				if !(^(c1 | c2) == 0) {
					continue
				}
				v.Reset(ssaop.OpOr16)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
				v0.AuxInt = ssa.Int16ToAuxInt(c1)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Or16 (Or16 i:(Const16 <t>) z) x)
	// cond: (z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16)
	// result: (Or16 i (Or16 <t> z x))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpOr16 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				i := v_0_0
				if i.Op != ssaop.OpConst16 {
					continue
				}
				t := i.Type
				z := v_0_1
				x := v_1
				if !(z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16) {
					continue
				}
				v.Reset(ssaop.OpOr16)
				v0 := b.NewValue0(v.Pos, ssaop.OpOr16, t)
				v0.AddArg2(z, x)
				v.AddArg2(i, v0)
				return true
			}
		}
		break
	}
	// match: (Or16 (Const16 <t> [c]) (Or16 (Const16 <t> [d]) x))
	// result: (Or16 (Const16 <t> [c|d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt16(v_0.AuxInt)
			if v_1.Op != ssaop.OpOr16 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if v_1_0.Op != ssaop.OpConst16 || v_1_0.Type != t {
					continue
				}
				d := ssa.AuxIntToInt16(v_1_0.AuxInt)
				x := v_1_1
				v.Reset(ssaop.OpOr16)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
				v0.AuxInt = ssa.Int16ToAuxInt(c | d)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Or16 (Lsh16x64 x z:(Const64 <t> [c])) (Rsh16Ux64 x (Const64 [d])))
	// cond: c < 16 && d == 16-c && canRotate(config, 16)
	// result: (RotateLeft16 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLsh16x64 {
				continue
			}
			_ = v_0.Args[1]
			x := v_0.Args[0]
			z := v_0.Args[1]
			if z.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(z.AuxInt)
			if v_1.Op != ssaop.OpRsh16Ux64 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(c < 16 && d == 16-c && canRotate(config, 16)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Or16 left:(Lsh16x64 x y) right:(Rsh16Ux64 x (Sub64 (Const64 [16]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)
	// result: (RotateLeft16 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh16x64 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh16Ux64 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub64 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(right_1_0.AuxInt) != 16 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Or16 left:(Lsh16x32 x y) right:(Rsh16Ux32 x (Sub32 (Const32 [16]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)
	// result: (RotateLeft16 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh16x32 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh16Ux32 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub32 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(right_1_0.AuxInt) != 16 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Or16 left:(Lsh16x16 x y) right:(Rsh16Ux16 x (Sub16 (Const16 [16]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)
	// result: (RotateLeft16 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh16x16 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh16Ux16 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub16 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(right_1_0.AuxInt) != 16 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Or16 left:(Lsh16x8 x y) right:(Rsh16Ux8 x (Sub8 (Const8 [16]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)
	// result: (RotateLeft16 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh16x8 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh16Ux8 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub8 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(right_1_0.AuxInt) != 16 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Or16 right:(Rsh16Ux64 x y) left:(Lsh16x64 x z:(Sub64 (Const64 [16]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)
	// result: (RotateLeft16 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh16Ux64 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh16x64 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub64 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(z_0.AuxInt) != 16 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Or16 right:(Rsh16Ux32 x y) left:(Lsh16x32 x z:(Sub32 (Const32 [16]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)
	// result: (RotateLeft16 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh16Ux32 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh16x32 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub32 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(z_0.AuxInt) != 16 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Or16 right:(Rsh16Ux16 x y) left:(Lsh16x16 x z:(Sub16 (Const16 [16]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)
	// result: (RotateLeft16 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh16Ux16 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh16x16 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub16 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(z_0.AuxInt) != 16 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Or16 right:(Rsh16Ux8 x y) left:(Lsh16x8 x z:(Sub8 (Const8 [16]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)
	// result: (RotateLeft16 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh16Ux8 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh16x8 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub8 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(z_0.AuxInt) != 16 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpOr32(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	// match: (Or32 (Const32 [c]) (Const32 [d]))
	// result: (Const32 [c|d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(v_1.AuxInt)
			v.Reset(ssaop.OpConst32)
			v.AuxInt = ssa.Int32ToAuxInt(c | d)
			return true
		}
		break
	}
	// match: (Or32 <t> (Com32 x) (Com32 y))
	// result: (Com32 (And32 <t> x y))
	for {
		t := v.Type
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpCom32 {
				continue
			}
			x := v_0.Args[0]
			if v_1.Op != ssaop.OpCom32 {
				continue
			}
			y := v_1.Args[0]
			v.Reset(ssaop.OpCom32)
			v0 := b.NewValue0(v.Pos, ssaop.OpAnd32, t)
			v0.AddArg2(x, y)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (Or32 x (And32 x y))
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpAnd32 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if x != v_1_0 {
					continue
				}
				v.CopyOf(x)
				return true
			}
		}
		break
	}
	// match: (Or32 x x)
	// result: x
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (Or32 (Const32 [0]) x)
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 {
				continue
			}
			x := v_1
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (Or32 (Const32 [-1]) _)
	// result: (Const32 [-1])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != -1 {
				continue
			}
			v.Reset(ssaop.OpConst32)
			v.AuxInt = ssa.Int32ToAuxInt(-1)
			return true
		}
		break
	}
	// match: (Or32 (Com32 x) x)
	// result: (Const32 [-1])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpCom32 {
				continue
			}
			x := v_0.Args[0]
			if x != v_1 {
				continue
			}
			v.Reset(ssaop.OpConst32)
			v.AuxInt = ssa.Int32ToAuxInt(-1)
			return true
		}
		break
	}
	// match: (Or32 x (Or32 x y))
	// result: (Or32 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpOr32 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if x != v_1_0 {
					continue
				}
				y := v_1_1
				v.Reset(ssaop.OpOr32)
				v.AddArg2(x, y)
				return true
			}
		}
		break
	}
	// match: (Or32 (And32 x (Const32 [c2])) (Const32 <t> [c1]))
	// cond: ^(c1 | c2) == 0
	// result: (Or32 (Const32 <t> [c1]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpAnd32 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				x := v_0_0
				if v_0_1.Op != ssaop.OpConst32 {
					continue
				}
				c2 := ssa.AuxIntToInt32(v_0_1.AuxInt)
				if v_1.Op != ssaop.OpConst32 {
					continue
				}
				t := v_1.Type
				c1 := ssa.AuxIntToInt32(v_1.AuxInt)
				if !(^(c1 | c2) == 0) {
					continue
				}
				v.Reset(ssaop.OpOr32)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
				v0.AuxInt = ssa.Int32ToAuxInt(c1)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Or32 (Or32 i:(Const32 <t>) z) x)
	// cond: (z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32)
	// result: (Or32 i (Or32 <t> z x))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpOr32 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				i := v_0_0
				if i.Op != ssaop.OpConst32 {
					continue
				}
				t := i.Type
				z := v_0_1
				x := v_1
				if !(z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32) {
					continue
				}
				v.Reset(ssaop.OpOr32)
				v0 := b.NewValue0(v.Pos, ssaop.OpOr32, t)
				v0.AddArg2(z, x)
				v.AddArg2(i, v0)
				return true
			}
		}
		break
	}
	// match: (Or32 (Const32 <t> [c]) (Or32 (Const32 <t> [d]) x))
	// result: (Or32 (Const32 <t> [c|d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt32(v_0.AuxInt)
			if v_1.Op != ssaop.OpOr32 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if v_1_0.Op != ssaop.OpConst32 || v_1_0.Type != t {
					continue
				}
				d := ssa.AuxIntToInt32(v_1_0.AuxInt)
				x := v_1_1
				v.Reset(ssaop.OpOr32)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
				v0.AuxInt = ssa.Int32ToAuxInt(c | d)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Or32 (Lsh32x64 x z:(Const64 <t> [c])) (Rsh32Ux64 x (Const64 [d])))
	// cond: c < 32 && d == 32-c && canRotate(config, 32)
	// result: (RotateLeft32 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLsh32x64 {
				continue
			}
			_ = v_0.Args[1]
			x := v_0.Args[0]
			z := v_0.Args[1]
			if z.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(z.AuxInt)
			if v_1.Op != ssaop.OpRsh32Ux64 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(c < 32 && d == 32-c && canRotate(config, 32)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Or32 left:(Lsh32x64 x y) right:(Rsh32Ux64 x (Sub64 (Const64 [32]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)
	// result: (RotateLeft32 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh32x64 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh32Ux64 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub64 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(right_1_0.AuxInt) != 32 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Or32 left:(Lsh32x32 x y) right:(Rsh32Ux32 x (Sub32 (Const32 [32]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)
	// result: (RotateLeft32 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh32x32 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh32Ux32 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub32 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(right_1_0.AuxInt) != 32 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Or32 left:(Lsh32x16 x y) right:(Rsh32Ux16 x (Sub16 (Const16 [32]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)
	// result: (RotateLeft32 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh32x16 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh32Ux16 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub16 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(right_1_0.AuxInt) != 32 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Or32 left:(Lsh32x8 x y) right:(Rsh32Ux8 x (Sub8 (Const8 [32]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)
	// result: (RotateLeft32 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh32x8 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh32Ux8 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub8 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(right_1_0.AuxInt) != 32 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Or32 right:(Rsh32Ux64 x y) left:(Lsh32x64 x z:(Sub64 (Const64 [32]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)
	// result: (RotateLeft32 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh32Ux64 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh32x64 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub64 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(z_0.AuxInt) != 32 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Or32 right:(Rsh32Ux32 x y) left:(Lsh32x32 x z:(Sub32 (Const32 [32]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)
	// result: (RotateLeft32 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh32Ux32 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh32x32 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub32 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(z_0.AuxInt) != 32 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Or32 right:(Rsh32Ux16 x y) left:(Lsh32x16 x z:(Sub16 (Const16 [32]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)
	// result: (RotateLeft32 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh32Ux16 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh32x16 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub16 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(z_0.AuxInt) != 32 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Or32 right:(Rsh32Ux8 x y) left:(Lsh32x8 x z:(Sub8 (Const8 [32]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)
	// result: (RotateLeft32 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh32Ux8 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh32x8 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub8 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(z_0.AuxInt) != 32 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpOr64(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	// match: (Or64 (Const64 [c]) (Const64 [d]))
	// result: (Const64 [c|d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1.AuxInt)
			v.Reset(ssaop.OpConst64)
			v.AuxInt = ssa.Int64ToAuxInt(c | d)
			return true
		}
		break
	}
	// match: (Or64 <t> (Com64 x) (Com64 y))
	// result: (Com64 (And64 <t> x y))
	for {
		t := v.Type
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpCom64 {
				continue
			}
			x := v_0.Args[0]
			if v_1.Op != ssaop.OpCom64 {
				continue
			}
			y := v_1.Args[0]
			v.Reset(ssaop.OpCom64)
			v0 := b.NewValue0(v.Pos, ssaop.OpAnd64, t)
			v0.AddArg2(x, y)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (Or64 x (And64 x y))
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpAnd64 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if x != v_1_0 {
					continue
				}
				v.CopyOf(x)
				return true
			}
		}
		break
	}
	// match: (Or64 x x)
	// result: x
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (Or64 (Const64 [0]) x)
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 {
				continue
			}
			x := v_1
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (Or64 (Const64 [-1]) _)
	// result: (Const64 [-1])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != -1 {
				continue
			}
			v.Reset(ssaop.OpConst64)
			v.AuxInt = ssa.Int64ToAuxInt(-1)
			return true
		}
		break
	}
	// match: (Or64 (Com64 x) x)
	// result: (Const64 [-1])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpCom64 {
				continue
			}
			x := v_0.Args[0]
			if x != v_1 {
				continue
			}
			v.Reset(ssaop.OpConst64)
			v.AuxInt = ssa.Int64ToAuxInt(-1)
			return true
		}
		break
	}
	// match: (Or64 x (Or64 x y))
	// result: (Or64 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpOr64 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if x != v_1_0 {
					continue
				}
				y := v_1_1
				v.Reset(ssaop.OpOr64)
				v.AddArg2(x, y)
				return true
			}
		}
		break
	}
	// match: (Or64 (And64 x (Const64 [c2])) (Const64 <t> [c1]))
	// cond: ^(c1 | c2) == 0
	// result: (Or64 (Const64 <t> [c1]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpAnd64 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				x := v_0_0
				if v_0_1.Op != ssaop.OpConst64 {
					continue
				}
				c2 := ssa.AuxIntToInt64(v_0_1.AuxInt)
				if v_1.Op != ssaop.OpConst64 {
					continue
				}
				t := v_1.Type
				c1 := ssa.AuxIntToInt64(v_1.AuxInt)
				if !(^(c1 | c2) == 0) {
					continue
				}
				v.Reset(ssaop.OpOr64)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
				v0.AuxInt = ssa.Int64ToAuxInt(c1)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Or64 (Or64 i:(Const64 <t>) z) x)
	// cond: (z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64)
	// result: (Or64 i (Or64 <t> z x))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpOr64 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				i := v_0_0
				if i.Op != ssaop.OpConst64 {
					continue
				}
				t := i.Type
				z := v_0_1
				x := v_1
				if !(z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64) {
					continue
				}
				v.Reset(ssaop.OpOr64)
				v0 := b.NewValue0(v.Pos, ssaop.OpOr64, t)
				v0.AddArg2(z, x)
				v.AddArg2(i, v0)
				return true
			}
		}
		break
	}
	// match: (Or64 (Const64 <t> [c]) (Or64 (Const64 <t> [d]) x))
	// result: (Or64 (Const64 <t> [c|d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt64(v_0.AuxInt)
			if v_1.Op != ssaop.OpOr64 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if v_1_0.Op != ssaop.OpConst64 || v_1_0.Type != t {
					continue
				}
				d := ssa.AuxIntToInt64(v_1_0.AuxInt)
				x := v_1_1
				v.Reset(ssaop.OpOr64)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
				v0.AuxInt = ssa.Int64ToAuxInt(c | d)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Or64 (Lsh64x64 x z:(Const64 <t> [c])) (Rsh64Ux64 x (Const64 [d])))
	// cond: c < 64 && d == 64-c && canRotate(config, 64)
	// result: (RotateLeft64 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLsh64x64 {
				continue
			}
			_ = v_0.Args[1]
			x := v_0.Args[0]
			z := v_0.Args[1]
			if z.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(z.AuxInt)
			if v_1.Op != ssaop.OpRsh64Ux64 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(c < 64 && d == 64-c && canRotate(config, 64)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Or64 left:(Lsh64x64 x y) right:(Rsh64Ux64 x (Sub64 (Const64 [64]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)
	// result: (RotateLeft64 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh64x64 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh64Ux64 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub64 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(right_1_0.AuxInt) != 64 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Or64 left:(Lsh64x32 x y) right:(Rsh64Ux32 x (Sub32 (Const32 [64]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)
	// result: (RotateLeft64 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh64x32 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh64Ux32 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub32 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(right_1_0.AuxInt) != 64 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Or64 left:(Lsh64x16 x y) right:(Rsh64Ux16 x (Sub16 (Const16 [64]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)
	// result: (RotateLeft64 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh64x16 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh64Ux16 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub16 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(right_1_0.AuxInt) != 64 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Or64 left:(Lsh64x8 x y) right:(Rsh64Ux8 x (Sub8 (Const8 [64]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)
	// result: (RotateLeft64 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh64x8 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh64Ux8 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub8 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(right_1_0.AuxInt) != 64 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Or64 right:(Rsh64Ux64 x y) left:(Lsh64x64 x z:(Sub64 (Const64 [64]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)
	// result: (RotateLeft64 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh64Ux64 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh64x64 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub64 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(z_0.AuxInt) != 64 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Or64 right:(Rsh64Ux32 x y) left:(Lsh64x32 x z:(Sub32 (Const32 [64]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)
	// result: (RotateLeft64 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh64Ux32 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh64x32 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub32 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(z_0.AuxInt) != 64 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Or64 right:(Rsh64Ux16 x y) left:(Lsh64x16 x z:(Sub16 (Const16 [64]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)
	// result: (RotateLeft64 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh64Ux16 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh64x16 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub16 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(z_0.AuxInt) != 64 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Or64 right:(Rsh64Ux8 x y) left:(Lsh64x8 x z:(Sub8 (Const8 [64]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)
	// result: (RotateLeft64 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh64Ux8 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh64x8 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub8 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(z_0.AuxInt) != 64 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpOr8(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	// match: (Or8 (Const8 [c]) (Const8 [d]))
	// result: (Const8 [c|d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst8 {
				continue
			}
			d := ssa.AuxIntToInt8(v_1.AuxInt)
			v.Reset(ssaop.OpConst8)
			v.AuxInt = ssa.Int8ToAuxInt(c | d)
			return true
		}
		break
	}
	// match: (Or8 <t> (Com8 x) (Com8 y))
	// result: (Com8 (And8 <t> x y))
	for {
		t := v.Type
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpCom8 {
				continue
			}
			x := v_0.Args[0]
			if v_1.Op != ssaop.OpCom8 {
				continue
			}
			y := v_1.Args[0]
			v.Reset(ssaop.OpCom8)
			v0 := b.NewValue0(v.Pos, ssaop.OpAnd8, t)
			v0.AddArg2(x, y)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (Or8 x (And8 x y))
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpAnd8 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if x != v_1_0 {
					continue
				}
				v.CopyOf(x)
				return true
			}
		}
		break
	}
	// match: (Or8 x x)
	// result: x
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (Or8 (Const8 [0]) x)
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 {
				continue
			}
			x := v_1
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (Or8 (Const8 [-1]) _)
	// result: (Const8 [-1])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != -1 {
				continue
			}
			v.Reset(ssaop.OpConst8)
			v.AuxInt = ssa.Int8ToAuxInt(-1)
			return true
		}
		break
	}
	// match: (Or8 (Com8 x) x)
	// result: (Const8 [-1])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpCom8 {
				continue
			}
			x := v_0.Args[0]
			if x != v_1 {
				continue
			}
			v.Reset(ssaop.OpConst8)
			v.AuxInt = ssa.Int8ToAuxInt(-1)
			return true
		}
		break
	}
	// match: (Or8 x (Or8 x y))
	// result: (Or8 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpOr8 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if x != v_1_0 {
					continue
				}
				y := v_1_1
				v.Reset(ssaop.OpOr8)
				v.AddArg2(x, y)
				return true
			}
		}
		break
	}
	// match: (Or8 (And8 x (Const8 [c2])) (Const8 <t> [c1]))
	// cond: ^(c1 | c2) == 0
	// result: (Or8 (Const8 <t> [c1]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpAnd8 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				x := v_0_0
				if v_0_1.Op != ssaop.OpConst8 {
					continue
				}
				c2 := ssa.AuxIntToInt8(v_0_1.AuxInt)
				if v_1.Op != ssaop.OpConst8 {
					continue
				}
				t := v_1.Type
				c1 := ssa.AuxIntToInt8(v_1.AuxInt)
				if !(^(c1 | c2) == 0) {
					continue
				}
				v.Reset(ssaop.OpOr8)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
				v0.AuxInt = ssa.Int8ToAuxInt(c1)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Or8 (Or8 i:(Const8 <t>) z) x)
	// cond: (z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8)
	// result: (Or8 i (Or8 <t> z x))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpOr8 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				i := v_0_0
				if i.Op != ssaop.OpConst8 {
					continue
				}
				t := i.Type
				z := v_0_1
				x := v_1
				if !(z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8) {
					continue
				}
				v.Reset(ssaop.OpOr8)
				v0 := b.NewValue0(v.Pos, ssaop.OpOr8, t)
				v0.AddArg2(z, x)
				v.AddArg2(i, v0)
				return true
			}
		}
		break
	}
	// match: (Or8 (Const8 <t> [c]) (Or8 (Const8 <t> [d]) x))
	// result: (Or8 (Const8 <t> [c|d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt8(v_0.AuxInt)
			if v_1.Op != ssaop.OpOr8 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if v_1_0.Op != ssaop.OpConst8 || v_1_0.Type != t {
					continue
				}
				d := ssa.AuxIntToInt8(v_1_0.AuxInt)
				x := v_1_1
				v.Reset(ssaop.OpOr8)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
				v0.AuxInt = ssa.Int8ToAuxInt(c | d)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Or8 (Lsh8x64 x z:(Const64 <t> [c])) (Rsh8Ux64 x (Const64 [d])))
	// cond: c < 8 && d == 8-c && canRotate(config, 8)
	// result: (RotateLeft8 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLsh8x64 {
				continue
			}
			_ = v_0.Args[1]
			x := v_0.Args[0]
			z := v_0.Args[1]
			if z.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(z.AuxInt)
			if v_1.Op != ssaop.OpRsh8Ux64 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(c < 8 && d == 8-c && canRotate(config, 8)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Or8 left:(Lsh8x64 x y) right:(Rsh8Ux64 x (Sub64 (Const64 [8]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)
	// result: (RotateLeft8 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh8x64 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh8Ux64 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub64 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(right_1_0.AuxInt) != 8 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Or8 left:(Lsh8x32 x y) right:(Rsh8Ux32 x (Sub32 (Const32 [8]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)
	// result: (RotateLeft8 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh8x32 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh8Ux32 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub32 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(right_1_0.AuxInt) != 8 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Or8 left:(Lsh8x16 x y) right:(Rsh8Ux16 x (Sub16 (Const16 [8]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)
	// result: (RotateLeft8 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh8x16 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh8Ux16 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub16 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(right_1_0.AuxInt) != 8 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Or8 left:(Lsh8x8 x y) right:(Rsh8Ux8 x (Sub8 (Const8 [8]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)
	// result: (RotateLeft8 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh8x8 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh8Ux8 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub8 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(right_1_0.AuxInt) != 8 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Or8 right:(Rsh8Ux64 x y) left:(Lsh8x64 x z:(Sub64 (Const64 [8]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)
	// result: (RotateLeft8 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh8Ux64 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh8x64 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub64 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(z_0.AuxInt) != 8 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Or8 right:(Rsh8Ux32 x y) left:(Lsh8x32 x z:(Sub32 (Const32 [8]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)
	// result: (RotateLeft8 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh8Ux32 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh8x32 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub32 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(z_0.AuxInt) != 8 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Or8 right:(Rsh8Ux16 x y) left:(Lsh8x16 x z:(Sub16 (Const16 [8]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)
	// result: (RotateLeft8 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh8Ux16 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh8x16 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub16 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(z_0.AuxInt) != 8 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Or8 right:(Rsh8Ux8 x y) left:(Lsh8x8 x z:(Sub8 (Const8 [8]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)
	// result: (RotateLeft8 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh8Ux8 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh8x8 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub8 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(z_0.AuxInt) != 8 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpOrB(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (OrB (ConstBool [c]) (ConstBool [d]))
	// result: (ConstBool [c||d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConstBool {
				continue
			}
			c := ssa.AuxIntToBool(v_0.AuxInt)
			if v_1.Op != ssaop.OpConstBool {
				continue
			}
			d := ssa.AuxIntToBool(v_1.AuxInt)
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(c || d)
			return true
		}
		break
	}
	// match: (OrB (Less64 (Const64 [c]) x) (Less64 x (Const64 [d])))
	// cond: c >= d
	// result: (Less64U (Const64 <x.Type> [c-d]) (Sub64 <x.Type> x (Const64 <x.Type> [d])))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLess64 {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLess64 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(c >= d) {
				continue
			}
			v.Reset(ssaop.OpLess64U)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
			v0.AuxInt = ssa.Int64ToAuxInt(c - d)
			v1 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
			v2.AuxInt = ssa.Int64ToAuxInt(d)
			v1.AddArg2(x, v2)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	// match: (OrB (Leq64 (Const64 [c]) x) (Less64 x (Const64 [d])))
	// cond: c >= d
	// result: (Leq64U (Const64 <x.Type> [c-d]) (Sub64 <x.Type> x (Const64 <x.Type> [d])))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLeq64 {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLess64 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(c >= d) {
				continue
			}
			v.Reset(ssaop.OpLeq64U)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
			v0.AuxInt = ssa.Int64ToAuxInt(c - d)
			v1 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
			v2.AuxInt = ssa.Int64ToAuxInt(d)
			v1.AddArg2(x, v2)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	// match: (OrB (Less32 (Const32 [c]) x) (Less32 x (Const32 [d])))
	// cond: c >= d
	// result: (Less32U (Const32 <x.Type> [c-d]) (Sub32 <x.Type> x (Const32 <x.Type> [d])))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLess32 {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLess32 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(v_1_1.AuxInt)
			if !(c >= d) {
				continue
			}
			v.Reset(ssaop.OpLess32U)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
			v0.AuxInt = ssa.Int32ToAuxInt(c - d)
			v1 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
			v2.AuxInt = ssa.Int32ToAuxInt(d)
			v1.AddArg2(x, v2)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	// match: (OrB (Leq32 (Const32 [c]) x) (Less32 x (Const32 [d])))
	// cond: c >= d
	// result: (Leq32U (Const32 <x.Type> [c-d]) (Sub32 <x.Type> x (Const32 <x.Type> [d])))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLeq32 {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLess32 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(v_1_1.AuxInt)
			if !(c >= d) {
				continue
			}
			v.Reset(ssaop.OpLeq32U)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
			v0.AuxInt = ssa.Int32ToAuxInt(c - d)
			v1 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
			v2.AuxInt = ssa.Int32ToAuxInt(d)
			v1.AddArg2(x, v2)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	// match: (OrB (Less16 (Const16 [c]) x) (Less16 x (Const16 [d])))
	// cond: c >= d
	// result: (Less16U (Const16 <x.Type> [c-d]) (Sub16 <x.Type> x (Const16 <x.Type> [d])))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLess16 {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLess16 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst16 {
				continue
			}
			d := ssa.AuxIntToInt16(v_1_1.AuxInt)
			if !(c >= d) {
				continue
			}
			v.Reset(ssaop.OpLess16U)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
			v0.AuxInt = ssa.Int16ToAuxInt(c - d)
			v1 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
			v2.AuxInt = ssa.Int16ToAuxInt(d)
			v1.AddArg2(x, v2)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	// match: (OrB (Leq16 (Const16 [c]) x) (Less16 x (Const16 [d])))
	// cond: c >= d
	// result: (Leq16U (Const16 <x.Type> [c-d]) (Sub16 <x.Type> x (Const16 <x.Type> [d])))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLeq16 {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLess16 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst16 {
				continue
			}
			d := ssa.AuxIntToInt16(v_1_1.AuxInt)
			if !(c >= d) {
				continue
			}
			v.Reset(ssaop.OpLeq16U)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
			v0.AuxInt = ssa.Int16ToAuxInt(c - d)
			v1 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
			v2.AuxInt = ssa.Int16ToAuxInt(d)
			v1.AddArg2(x, v2)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	// match: (OrB (Less8 (Const8 [c]) x) (Less8 x (Const8 [d])))
	// cond: c >= d
	// result: (Less8U (Const8 <x.Type> [c-d]) (Sub8 <x.Type> x (Const8 <x.Type> [d])))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLess8 {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLess8 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst8 {
				continue
			}
			d := ssa.AuxIntToInt8(v_1_1.AuxInt)
			if !(c >= d) {
				continue
			}
			v.Reset(ssaop.OpLess8U)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
			v0.AuxInt = ssa.Int8ToAuxInt(c - d)
			v1 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
			v2.AuxInt = ssa.Int8ToAuxInt(d)
			v1.AddArg2(x, v2)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	// match: (OrB (Leq8 (Const8 [c]) x) (Less8 x (Const8 [d])))
	// cond: c >= d
	// result: (Leq8U (Const8 <x.Type> [c-d]) (Sub8 <x.Type> x (Const8 <x.Type> [d])))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLeq8 {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLess8 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst8 {
				continue
			}
			d := ssa.AuxIntToInt8(v_1_1.AuxInt)
			if !(c >= d) {
				continue
			}
			v.Reset(ssaop.OpLeq8U)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
			v0.AuxInt = ssa.Int8ToAuxInt(c - d)
			v1 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
			v2.AuxInt = ssa.Int8ToAuxInt(d)
			v1.AddArg2(x, v2)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	// match: (OrB (Less64 (Const64 [c]) x) (Leq64 x (Const64 [d])))
	// cond: c >= d+1 && d+1 > d
	// result: (Less64U (Const64 <x.Type> [c-d-1]) (Sub64 <x.Type> x (Const64 <x.Type> [d+1])))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLess64 {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLeq64 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(c >= d+1 && d+1 > d) {
				continue
			}
			v.Reset(ssaop.OpLess64U)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
			v0.AuxInt = ssa.Int64ToAuxInt(c - d - 1)
			v1 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
			v2.AuxInt = ssa.Int64ToAuxInt(d + 1)
			v1.AddArg2(x, v2)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	// match: (OrB (Leq64 (Const64 [c]) x) (Leq64 x (Const64 [d])))
	// cond: c >= d+1 && d+1 > d
	// result: (Leq64U (Const64 <x.Type> [c-d-1]) (Sub64 <x.Type> x (Const64 <x.Type> [d+1])))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLeq64 {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLeq64 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(c >= d+1 && d+1 > d) {
				continue
			}
			v.Reset(ssaop.OpLeq64U)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
			v0.AuxInt = ssa.Int64ToAuxInt(c - d - 1)
			v1 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
			v2.AuxInt = ssa.Int64ToAuxInt(d + 1)
			v1.AddArg2(x, v2)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	// match: (OrB (Less32 (Const32 [c]) x) (Leq32 x (Const32 [d])))
	// cond: c >= d+1 && d+1 > d
	// result: (Less32U (Const32 <x.Type> [c-d-1]) (Sub32 <x.Type> x (Const32 <x.Type> [d+1])))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLess32 {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLeq32 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(v_1_1.AuxInt)
			if !(c >= d+1 && d+1 > d) {
				continue
			}
			v.Reset(ssaop.OpLess32U)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
			v0.AuxInt = ssa.Int32ToAuxInt(c - d - 1)
			v1 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
			v2.AuxInt = ssa.Int32ToAuxInt(d + 1)
			v1.AddArg2(x, v2)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	// match: (OrB (Leq32 (Const32 [c]) x) (Leq32 x (Const32 [d])))
	// cond: c >= d+1 && d+1 > d
	// result: (Leq32U (Const32 <x.Type> [c-d-1]) (Sub32 <x.Type> x (Const32 <x.Type> [d+1])))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLeq32 {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLeq32 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(v_1_1.AuxInt)
			if !(c >= d+1 && d+1 > d) {
				continue
			}
			v.Reset(ssaop.OpLeq32U)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
			v0.AuxInt = ssa.Int32ToAuxInt(c - d - 1)
			v1 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
			v2.AuxInt = ssa.Int32ToAuxInt(d + 1)
			v1.AddArg2(x, v2)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	// match: (OrB (Less16 (Const16 [c]) x) (Leq16 x (Const16 [d])))
	// cond: c >= d+1 && d+1 > d
	// result: (Less16U (Const16 <x.Type> [c-d-1]) (Sub16 <x.Type> x (Const16 <x.Type> [d+1])))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLess16 {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLeq16 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst16 {
				continue
			}
			d := ssa.AuxIntToInt16(v_1_1.AuxInt)
			if !(c >= d+1 && d+1 > d) {
				continue
			}
			v.Reset(ssaop.OpLess16U)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
			v0.AuxInt = ssa.Int16ToAuxInt(c - d - 1)
			v1 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
			v2.AuxInt = ssa.Int16ToAuxInt(d + 1)
			v1.AddArg2(x, v2)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	// match: (OrB (Leq16 (Const16 [c]) x) (Leq16 x (Const16 [d])))
	// cond: c >= d+1 && d+1 > d
	// result: (Leq16U (Const16 <x.Type> [c-d-1]) (Sub16 <x.Type> x (Const16 <x.Type> [d+1])))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLeq16 {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLeq16 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst16 {
				continue
			}
			d := ssa.AuxIntToInt16(v_1_1.AuxInt)
			if !(c >= d+1 && d+1 > d) {
				continue
			}
			v.Reset(ssaop.OpLeq16U)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
			v0.AuxInt = ssa.Int16ToAuxInt(c - d - 1)
			v1 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
			v2.AuxInt = ssa.Int16ToAuxInt(d + 1)
			v1.AddArg2(x, v2)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	// match: (OrB (Less8 (Const8 [c]) x) (Leq8 x (Const8 [d])))
	// cond: c >= d+1 && d+1 > d
	// result: (Less8U (Const8 <x.Type> [c-d-1]) (Sub8 <x.Type> x (Const8 <x.Type> [d+1])))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLess8 {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLeq8 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst8 {
				continue
			}
			d := ssa.AuxIntToInt8(v_1_1.AuxInt)
			if !(c >= d+1 && d+1 > d) {
				continue
			}
			v.Reset(ssaop.OpLess8U)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
			v0.AuxInt = ssa.Int8ToAuxInt(c - d - 1)
			v1 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
			v2.AuxInt = ssa.Int8ToAuxInt(d + 1)
			v1.AddArg2(x, v2)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	// match: (OrB (Leq8 (Const8 [c]) x) (Leq8 x (Const8 [d])))
	// cond: c >= d+1 && d+1 > d
	// result: (Leq8U (Const8 <x.Type> [c-d-1]) (Sub8 <x.Type> x (Const8 <x.Type> [d+1])))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLeq8 {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLeq8 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst8 {
				continue
			}
			d := ssa.AuxIntToInt8(v_1_1.AuxInt)
			if !(c >= d+1 && d+1 > d) {
				continue
			}
			v.Reset(ssaop.OpLeq8U)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
			v0.AuxInt = ssa.Int8ToAuxInt(c - d - 1)
			v1 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
			v2.AuxInt = ssa.Int8ToAuxInt(d + 1)
			v1.AddArg2(x, v2)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	// match: (OrB (Less64U (Const64 [c]) x) (Less64U x (Const64 [d])))
	// cond: uint64(c) >= uint64(d)
	// result: (Less64U (Const64 <x.Type> [c-d]) (Sub64 <x.Type> x (Const64 <x.Type> [d])))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLess64U {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLess64U {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(uint64(c) >= uint64(d)) {
				continue
			}
			v.Reset(ssaop.OpLess64U)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
			v0.AuxInt = ssa.Int64ToAuxInt(c - d)
			v1 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
			v2.AuxInt = ssa.Int64ToAuxInt(d)
			v1.AddArg2(x, v2)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	// match: (OrB (Leq64U (Const64 [c]) x) (Less64U x (Const64 [d])))
	// cond: uint64(c) >= uint64(d)
	// result: (Leq64U (Const64 <x.Type> [c-d]) (Sub64 <x.Type> x (Const64 <x.Type> [d])))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLeq64U {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLess64U {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(uint64(c) >= uint64(d)) {
				continue
			}
			v.Reset(ssaop.OpLeq64U)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
			v0.AuxInt = ssa.Int64ToAuxInt(c - d)
			v1 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
			v2.AuxInt = ssa.Int64ToAuxInt(d)
			v1.AddArg2(x, v2)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	// match: (OrB (Less32U (Const32 [c]) x) (Less32U x (Const32 [d])))
	// cond: uint32(c) >= uint32(d)
	// result: (Less32U (Const32 <x.Type> [c-d]) (Sub32 <x.Type> x (Const32 <x.Type> [d])))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLess32U {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLess32U {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(v_1_1.AuxInt)
			if !(uint32(c) >= uint32(d)) {
				continue
			}
			v.Reset(ssaop.OpLess32U)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
			v0.AuxInt = ssa.Int32ToAuxInt(c - d)
			v1 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
			v2.AuxInt = ssa.Int32ToAuxInt(d)
			v1.AddArg2(x, v2)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	// match: (OrB (Leq32U (Const32 [c]) x) (Less32U x (Const32 [d])))
	// cond: uint32(c) >= uint32(d)
	// result: (Leq32U (Const32 <x.Type> [c-d]) (Sub32 <x.Type> x (Const32 <x.Type> [d])))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLeq32U {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLess32U {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(v_1_1.AuxInt)
			if !(uint32(c) >= uint32(d)) {
				continue
			}
			v.Reset(ssaop.OpLeq32U)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
			v0.AuxInt = ssa.Int32ToAuxInt(c - d)
			v1 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
			v2.AuxInt = ssa.Int32ToAuxInt(d)
			v1.AddArg2(x, v2)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	// match: (OrB (Less16U (Const16 [c]) x) (Less16U x (Const16 [d])))
	// cond: uint16(c) >= uint16(d)
	// result: (Less16U (Const16 <x.Type> [c-d]) (Sub16 <x.Type> x (Const16 <x.Type> [d])))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLess16U {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLess16U {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst16 {
				continue
			}
			d := ssa.AuxIntToInt16(v_1_1.AuxInt)
			if !(uint16(c) >= uint16(d)) {
				continue
			}
			v.Reset(ssaop.OpLess16U)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
			v0.AuxInt = ssa.Int16ToAuxInt(c - d)
			v1 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
			v2.AuxInt = ssa.Int16ToAuxInt(d)
			v1.AddArg2(x, v2)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	// match: (OrB (Leq16U (Const16 [c]) x) (Less16U x (Const16 [d])))
	// cond: uint16(c) >= uint16(d)
	// result: (Leq16U (Const16 <x.Type> [c-d]) (Sub16 <x.Type> x (Const16 <x.Type> [d])))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLeq16U {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLess16U {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst16 {
				continue
			}
			d := ssa.AuxIntToInt16(v_1_1.AuxInt)
			if !(uint16(c) >= uint16(d)) {
				continue
			}
			v.Reset(ssaop.OpLeq16U)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
			v0.AuxInt = ssa.Int16ToAuxInt(c - d)
			v1 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
			v2.AuxInt = ssa.Int16ToAuxInt(d)
			v1.AddArg2(x, v2)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	// match: (OrB (Less8U (Const8 [c]) x) (Less8U x (Const8 [d])))
	// cond: uint8(c) >= uint8(d)
	// result: (Less8U (Const8 <x.Type> [c-d]) (Sub8 <x.Type> x (Const8 <x.Type> [d])))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLess8U {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLess8U {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst8 {
				continue
			}
			d := ssa.AuxIntToInt8(v_1_1.AuxInt)
			if !(uint8(c) >= uint8(d)) {
				continue
			}
			v.Reset(ssaop.OpLess8U)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
			v0.AuxInt = ssa.Int8ToAuxInt(c - d)
			v1 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
			v2.AuxInt = ssa.Int8ToAuxInt(d)
			v1.AddArg2(x, v2)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	// match: (OrB (Leq8U (Const8 [c]) x) (Less8U x (Const8 [d])))
	// cond: uint8(c) >= uint8(d)
	// result: (Leq8U (Const8 <x.Type> [c-d]) (Sub8 <x.Type> x (Const8 <x.Type> [d])))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLeq8U {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLess8U {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst8 {
				continue
			}
			d := ssa.AuxIntToInt8(v_1_1.AuxInt)
			if !(uint8(c) >= uint8(d)) {
				continue
			}
			v.Reset(ssaop.OpLeq8U)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
			v0.AuxInt = ssa.Int8ToAuxInt(c - d)
			v1 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
			v2.AuxInt = ssa.Int8ToAuxInt(d)
			v1.AddArg2(x, v2)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	// match: (OrB (Less64U (Const64 [c]) x) (Leq64U x (Const64 [d])))
	// cond: uint64(c) >= uint64(d+1) && uint64(d+1) > uint64(d)
	// result: (Less64U (Const64 <x.Type> [c-d-1]) (Sub64 <x.Type> x (Const64 <x.Type> [d+1])))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLess64U {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLeq64U {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(uint64(c) >= uint64(d+1) && uint64(d+1) > uint64(d)) {
				continue
			}
			v.Reset(ssaop.OpLess64U)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
			v0.AuxInt = ssa.Int64ToAuxInt(c - d - 1)
			v1 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
			v2.AuxInt = ssa.Int64ToAuxInt(d + 1)
			v1.AddArg2(x, v2)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	// match: (OrB (Leq64U (Const64 [c]) x) (Leq64U x (Const64 [d])))
	// cond: uint64(c) >= uint64(d+1) && uint64(d+1) > uint64(d)
	// result: (Leq64U (Const64 <x.Type> [c-d-1]) (Sub64 <x.Type> x (Const64 <x.Type> [d+1])))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLeq64U {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLeq64U {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(uint64(c) >= uint64(d+1) && uint64(d+1) > uint64(d)) {
				continue
			}
			v.Reset(ssaop.OpLeq64U)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
			v0.AuxInt = ssa.Int64ToAuxInt(c - d - 1)
			v1 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
			v2.AuxInt = ssa.Int64ToAuxInt(d + 1)
			v1.AddArg2(x, v2)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	// match: (OrB (Less32U (Const32 [c]) x) (Leq32U x (Const32 [d])))
	// cond: uint32(c) >= uint32(d+1) && uint32(d+1) > uint32(d)
	// result: (Less32U (Const32 <x.Type> [c-d-1]) (Sub32 <x.Type> x (Const32 <x.Type> [d+1])))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLess32U {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLeq32U {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(v_1_1.AuxInt)
			if !(uint32(c) >= uint32(d+1) && uint32(d+1) > uint32(d)) {
				continue
			}
			v.Reset(ssaop.OpLess32U)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
			v0.AuxInt = ssa.Int32ToAuxInt(c - d - 1)
			v1 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
			v2.AuxInt = ssa.Int32ToAuxInt(d + 1)
			v1.AddArg2(x, v2)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	// match: (OrB (Leq32U (Const32 [c]) x) (Leq32U x (Const32 [d])))
	// cond: uint32(c) >= uint32(d+1) && uint32(d+1) > uint32(d)
	// result: (Leq32U (Const32 <x.Type> [c-d-1]) (Sub32 <x.Type> x (Const32 <x.Type> [d+1])))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLeq32U {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLeq32U {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(v_1_1.AuxInt)
			if !(uint32(c) >= uint32(d+1) && uint32(d+1) > uint32(d)) {
				continue
			}
			v.Reset(ssaop.OpLeq32U)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
			v0.AuxInt = ssa.Int32ToAuxInt(c - d - 1)
			v1 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
			v2.AuxInt = ssa.Int32ToAuxInt(d + 1)
			v1.AddArg2(x, v2)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	// match: (OrB (Less16U (Const16 [c]) x) (Leq16U x (Const16 [d])))
	// cond: uint16(c) >= uint16(d+1) && uint16(d+1) > uint16(d)
	// result: (Less16U (Const16 <x.Type> [c-d-1]) (Sub16 <x.Type> x (Const16 <x.Type> [d+1])))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLess16U {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLeq16U {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst16 {
				continue
			}
			d := ssa.AuxIntToInt16(v_1_1.AuxInt)
			if !(uint16(c) >= uint16(d+1) && uint16(d+1) > uint16(d)) {
				continue
			}
			v.Reset(ssaop.OpLess16U)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
			v0.AuxInt = ssa.Int16ToAuxInt(c - d - 1)
			v1 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
			v2.AuxInt = ssa.Int16ToAuxInt(d + 1)
			v1.AddArg2(x, v2)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	// match: (OrB (Leq16U (Const16 [c]) x) (Leq16U x (Const16 [d])))
	// cond: uint16(c) >= uint16(d+1) && uint16(d+1) > uint16(d)
	// result: (Leq16U (Const16 <x.Type> [c-d-1]) (Sub16 <x.Type> x (Const16 <x.Type> [d+1])))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLeq16U {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLeq16U {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst16 {
				continue
			}
			d := ssa.AuxIntToInt16(v_1_1.AuxInt)
			if !(uint16(c) >= uint16(d+1) && uint16(d+1) > uint16(d)) {
				continue
			}
			v.Reset(ssaop.OpLeq16U)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
			v0.AuxInt = ssa.Int16ToAuxInt(c - d - 1)
			v1 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
			v2.AuxInt = ssa.Int16ToAuxInt(d + 1)
			v1.AddArg2(x, v2)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	// match: (OrB (Less8U (Const8 [c]) x) (Leq8U x (Const8 [d])))
	// cond: uint8(c) >= uint8(d+1) && uint8(d+1) > uint8(d)
	// result: (Less8U (Const8 <x.Type> [c-d-1]) (Sub8 <x.Type> x (Const8 <x.Type> [d+1])))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLess8U {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLeq8U {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst8 {
				continue
			}
			d := ssa.AuxIntToInt8(v_1_1.AuxInt)
			if !(uint8(c) >= uint8(d+1) && uint8(d+1) > uint8(d)) {
				continue
			}
			v.Reset(ssaop.OpLess8U)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
			v0.AuxInt = ssa.Int8ToAuxInt(c - d - 1)
			v1 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
			v2.AuxInt = ssa.Int8ToAuxInt(d + 1)
			v1.AddArg2(x, v2)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	// match: (OrB (Leq8U (Const8 [c]) x) (Leq8U x (Const8 [d])))
	// cond: uint8(c) >= uint8(d+1) && uint8(d+1) > uint8(d)
	// result: (Leq8U (Const8 <x.Type> [c-d-1]) (Sub8 <x.Type> x (Const8 <x.Type> [d+1])))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLeq8U {
				continue
			}
			x := v_0.Args[1]
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_0_0.AuxInt)
			if v_1.Op != ssaop.OpLeq8U {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst8 {
				continue
			}
			d := ssa.AuxIntToInt8(v_1_1.AuxInt)
			if !(uint8(c) >= uint8(d+1) && uint8(d+1) > uint8(d)) {
				continue
			}
			v.Reset(ssaop.OpLeq8U)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
			v0.AuxInt = ssa.Int8ToAuxInt(c - d - 1)
			v1 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
			v2.AuxInt = ssa.Int8ToAuxInt(d + 1)
			v1.AddArg2(x, v2)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	// match: (OrB (Eq64 x cv:(Const64 [c])) (Eq64 x (Const64 [d])))
	// cond: c|d == c && ssa.OneBit(c^d)
	// result: (Eq64 (Or64 <x.Type> x (Const64 <x.Type> [c^d])) cv)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpEq64 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				x := v_0_0
				cv := v_0_1
				if cv.Op != ssaop.OpConst64 {
					continue
				}
				c := ssa.AuxIntToInt64(cv.AuxInt)
				if v_1.Op != ssaop.OpEq64 {
					continue
				}
				_ = v_1.Args[1]
				v_1_0 := v_1.Args[0]
				v_1_1 := v_1.Args[1]
				for _i2 := 0; _i2 <= 1; _i2, v_1_0, v_1_1 = _i2+1, v_1_1, v_1_0 {
					if x != v_1_0 || v_1_1.Op != ssaop.OpConst64 {
						continue
					}
					d := ssa.AuxIntToInt64(v_1_1.AuxInt)
					if !(c|d == c && ssa.OneBit(c^d)) {
						continue
					}
					v.Reset(ssaop.OpEq64)
					v0 := b.NewValue0(v.Pos, ssaop.OpOr64, x.Type)
					v1 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type)
					v1.AuxInt = ssa.Int64ToAuxInt(c ^ d)
					v0.AddArg2(x, v1)
					v.AddArg2(v0, cv)
					return true
				}
			}
		}
		break
	}
	// match: (OrB (Eq32 x cv:(Const32 [c])) (Eq32 x (Const32 [d])))
	// cond: c|d == c && ssa.OneBit(c^d)
	// result: (Eq32 (Or32 <x.Type> x (Const32 <x.Type> [c^d])) cv)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpEq32 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				x := v_0_0
				cv := v_0_1
				if cv.Op != ssaop.OpConst32 {
					continue
				}
				c := ssa.AuxIntToInt32(cv.AuxInt)
				if v_1.Op != ssaop.OpEq32 {
					continue
				}
				_ = v_1.Args[1]
				v_1_0 := v_1.Args[0]
				v_1_1 := v_1.Args[1]
				for _i2 := 0; _i2 <= 1; _i2, v_1_0, v_1_1 = _i2+1, v_1_1, v_1_0 {
					if x != v_1_0 || v_1_1.Op != ssaop.OpConst32 {
						continue
					}
					d := ssa.AuxIntToInt32(v_1_1.AuxInt)
					if !(c|d == c && ssa.OneBit(c^d)) {
						continue
					}
					v.Reset(ssaop.OpEq32)
					v0 := b.NewValue0(v.Pos, ssaop.OpOr32, x.Type)
					v1 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type)
					v1.AuxInt = ssa.Int32ToAuxInt(c ^ d)
					v0.AddArg2(x, v1)
					v.AddArg2(v0, cv)
					return true
				}
			}
		}
		break
	}
	// match: (OrB (Eq16 x cv:(Const16 [c])) (Eq16 x (Const16 [d])))
	// cond: c|d == c && ssa.OneBit(c^d)
	// result: (Eq16 (Or16 <x.Type> x (Const16 <x.Type> [c^d])) cv)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpEq16 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				x := v_0_0
				cv := v_0_1
				if cv.Op != ssaop.OpConst16 {
					continue
				}
				c := ssa.AuxIntToInt16(cv.AuxInt)
				if v_1.Op != ssaop.OpEq16 {
					continue
				}
				_ = v_1.Args[1]
				v_1_0 := v_1.Args[0]
				v_1_1 := v_1.Args[1]
				for _i2 := 0; _i2 <= 1; _i2, v_1_0, v_1_1 = _i2+1, v_1_1, v_1_0 {
					if x != v_1_0 || v_1_1.Op != ssaop.OpConst16 {
						continue
					}
					d := ssa.AuxIntToInt16(v_1_1.AuxInt)
					if !(c|d == c && ssa.OneBit(c^d)) {
						continue
					}
					v.Reset(ssaop.OpEq16)
					v0 := b.NewValue0(v.Pos, ssaop.OpOr16, x.Type)
					v1 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type)
					v1.AuxInt = ssa.Int16ToAuxInt(c ^ d)
					v0.AddArg2(x, v1)
					v.AddArg2(v0, cv)
					return true
				}
			}
		}
		break
	}
	// match: (OrB (Eq8 x cv:(Const8 [c])) (Eq8 x (Const8 [d])))
	// cond: c|d == c && ssa.OneBit(c^d)
	// result: (Eq8 (Or8 <x.Type> x (Const8 <x.Type> [c^d])) cv)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpEq8 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				x := v_0_0
				cv := v_0_1
				if cv.Op != ssaop.OpConst8 {
					continue
				}
				c := ssa.AuxIntToInt8(cv.AuxInt)
				if v_1.Op != ssaop.OpEq8 {
					continue
				}
				_ = v_1.Args[1]
				v_1_0 := v_1.Args[0]
				v_1_1 := v_1.Args[1]
				for _i2 := 0; _i2 <= 1; _i2, v_1_0, v_1_1 = _i2+1, v_1_1, v_1_0 {
					if x != v_1_0 || v_1_1.Op != ssaop.OpConst8 {
						continue
					}
					d := ssa.AuxIntToInt8(v_1_1.AuxInt)
					if !(c|d == c && ssa.OneBit(c^d)) {
						continue
					}
					v.Reset(ssaop.OpEq8)
					v0 := b.NewValue0(v.Pos, ssaop.OpOr8, x.Type)
					v1 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type)
					v1.AuxInt = ssa.Int8ToAuxInt(c ^ d)
					v0.AddArg2(x, v1)
					v.AddArg2(v0, cv)
					return true
				}
			}
		}
		break
	}
	// match: (OrB (Neq64F x x) (Less64F x y:(Const64F [c])))
	// result: (Not (Leq64F y x))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeq64F {
				continue
			}
			x := v_0.Args[1]
			if x != v_0.Args[0] || v_1.Op != ssaop.OpLess64F {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			y := v_1.Args[1]
			if y.Op != ssaop.OpConst64F {
				continue
			}
			v.Reset(ssaop.OpNot)
			v0 := b.NewValue0(v.Pos, ssaop.OpLeq64F, typ.Bool)
			v0.AddArg2(y, x)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (OrB (Neq64F x x) (Leq64F x y:(Const64F [c])))
	// result: (Not (Less64F y x))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeq64F {
				continue
			}
			x := v_0.Args[1]
			if x != v_0.Args[0] || v_1.Op != ssaop.OpLeq64F {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			y := v_1.Args[1]
			if y.Op != ssaop.OpConst64F {
				continue
			}
			v.Reset(ssaop.OpNot)
			v0 := b.NewValue0(v.Pos, ssaop.OpLess64F, typ.Bool)
			v0.AddArg2(y, x)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (OrB (Neq64F x x) (Less64F y:(Const64F [c]) x))
	// result: (Not (Leq64F x y))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeq64F {
				continue
			}
			x := v_0.Args[1]
			if x != v_0.Args[0] || v_1.Op != ssaop.OpLess64F {
				continue
			}
			_ = v_1.Args[1]
			y := v_1.Args[0]
			if y.Op != ssaop.OpConst64F {
				continue
			}
			if x != v_1.Args[1] {
				continue
			}
			v.Reset(ssaop.OpNot)
			v0 := b.NewValue0(v.Pos, ssaop.OpLeq64F, typ.Bool)
			v0.AddArg2(x, y)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (OrB (Neq64F x x) (Leq64F y:(Const64F [c]) x))
	// result: (Not (Less64F x y))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeq64F {
				continue
			}
			x := v_0.Args[1]
			if x != v_0.Args[0] || v_1.Op != ssaop.OpLeq64F {
				continue
			}
			_ = v_1.Args[1]
			y := v_1.Args[0]
			if y.Op != ssaop.OpConst64F {
				continue
			}
			if x != v_1.Args[1] {
				continue
			}
			v.Reset(ssaop.OpNot)
			v0 := b.NewValue0(v.Pos, ssaop.OpLess64F, typ.Bool)
			v0.AddArg2(x, y)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (OrB (Neq32F x x) (Less32F x y:(Const32F [c])))
	// result: (Not (Leq32F y x))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeq32F {
				continue
			}
			x := v_0.Args[1]
			if x != v_0.Args[0] || v_1.Op != ssaop.OpLess32F {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			y := v_1.Args[1]
			if y.Op != ssaop.OpConst32F {
				continue
			}
			v.Reset(ssaop.OpNot)
			v0 := b.NewValue0(v.Pos, ssaop.OpLeq32F, typ.Bool)
			v0.AddArg2(y, x)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (OrB (Neq32F x x) (Leq32F x y:(Const32F [c])))
	// result: (Not (Less32F y x))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeq32F {
				continue
			}
			x := v_0.Args[1]
			if x != v_0.Args[0] || v_1.Op != ssaop.OpLeq32F {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			y := v_1.Args[1]
			if y.Op != ssaop.OpConst32F {
				continue
			}
			v.Reset(ssaop.OpNot)
			v0 := b.NewValue0(v.Pos, ssaop.OpLess32F, typ.Bool)
			v0.AddArg2(y, x)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (OrB (Neq32F x x) (Less32F y:(Const32F [c]) x))
	// result: (Not (Leq32F x y))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeq32F {
				continue
			}
			x := v_0.Args[1]
			if x != v_0.Args[0] || v_1.Op != ssaop.OpLess32F {
				continue
			}
			_ = v_1.Args[1]
			y := v_1.Args[0]
			if y.Op != ssaop.OpConst32F {
				continue
			}
			if x != v_1.Args[1] {
				continue
			}
			v.Reset(ssaop.OpNot)
			v0 := b.NewValue0(v.Pos, ssaop.OpLeq32F, typ.Bool)
			v0.AddArg2(x, y)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (OrB (Neq32F x x) (Leq32F y:(Const32F [c]) x))
	// result: (Not (Less32F x y))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeq32F {
				continue
			}
			x := v_0.Args[1]
			if x != v_0.Args[0] || v_1.Op != ssaop.OpLeq32F {
				continue
			}
			_ = v_1.Args[1]
			y := v_1.Args[0]
			if y.Op != ssaop.OpConst32F {
				continue
			}
			if x != v_1.Args[1] {
				continue
			}
			v.Reset(ssaop.OpNot)
			v0 := b.NewValue0(v.Pos, ssaop.OpLess32F, typ.Bool)
			v0.AddArg2(x, y)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (OrB (Neq64F x x) (Less64F abs:(Abs x) y:(Const64F [c])))
	// result: (Not (Leq64F y abs))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeq64F {
				continue
			}
			x := v_0.Args[1]
			if x != v_0.Args[0] || v_1.Op != ssaop.OpLess64F {
				continue
			}
			_ = v_1.Args[1]
			abs := v_1.Args[0]
			if abs.Op != ssaop.OpAbs || x != abs.Args[0] {
				continue
			}
			y := v_1.Args[1]
			if y.Op != ssaop.OpConst64F {
				continue
			}
			v.Reset(ssaop.OpNot)
			v0 := b.NewValue0(v.Pos, ssaop.OpLeq64F, typ.Bool)
			v0.AddArg2(y, abs)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (OrB (Neq64F x x) (Leq64F abs:(Abs x) y:(Const64F [c])))
	// result: (Not (Less64F y abs))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeq64F {
				continue
			}
			x := v_0.Args[1]
			if x != v_0.Args[0] || v_1.Op != ssaop.OpLeq64F {
				continue
			}
			_ = v_1.Args[1]
			abs := v_1.Args[0]
			if abs.Op != ssaop.OpAbs || x != abs.Args[0] {
				continue
			}
			y := v_1.Args[1]
			if y.Op != ssaop.OpConst64F {
				continue
			}
			v.Reset(ssaop.OpNot)
			v0 := b.NewValue0(v.Pos, ssaop.OpLess64F, typ.Bool)
			v0.AddArg2(y, abs)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (OrB (Neq64F x x) (Less64F y:(Const64F [c]) abs:(Abs x)))
	// result: (Not (Leq64F abs y))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeq64F {
				continue
			}
			x := v_0.Args[1]
			if x != v_0.Args[0] || v_1.Op != ssaop.OpLess64F {
				continue
			}
			_ = v_1.Args[1]
			y := v_1.Args[0]
			if y.Op != ssaop.OpConst64F {
				continue
			}
			abs := v_1.Args[1]
			if abs.Op != ssaop.OpAbs || x != abs.Args[0] {
				continue
			}
			v.Reset(ssaop.OpNot)
			v0 := b.NewValue0(v.Pos, ssaop.OpLeq64F, typ.Bool)
			v0.AddArg2(abs, y)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (OrB (Neq64F x x) (Leq64F y:(Const64F [c]) abs:(Abs x)))
	// result: (Not (Less64F abs y))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeq64F {
				continue
			}
			x := v_0.Args[1]
			if x != v_0.Args[0] || v_1.Op != ssaop.OpLeq64F {
				continue
			}
			_ = v_1.Args[1]
			y := v_1.Args[0]
			if y.Op != ssaop.OpConst64F {
				continue
			}
			abs := v_1.Args[1]
			if abs.Op != ssaop.OpAbs || x != abs.Args[0] {
				continue
			}
			v.Reset(ssaop.OpNot)
			v0 := b.NewValue0(v.Pos, ssaop.OpLess64F, typ.Bool)
			v0.AddArg2(abs, y)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (OrB (Neq64F x x) (Less64F neg:(Neg64F x) y:(Const64F [c])))
	// result: (Not (Leq64F y neg))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeq64F {
				continue
			}
			x := v_0.Args[1]
			if x != v_0.Args[0] || v_1.Op != ssaop.OpLess64F {
				continue
			}
			_ = v_1.Args[1]
			neg := v_1.Args[0]
			if neg.Op != ssaop.OpNeg64F || x != neg.Args[0] {
				continue
			}
			y := v_1.Args[1]
			if y.Op != ssaop.OpConst64F {
				continue
			}
			v.Reset(ssaop.OpNot)
			v0 := b.NewValue0(v.Pos, ssaop.OpLeq64F, typ.Bool)
			v0.AddArg2(y, neg)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (OrB (Neq64F x x) (Leq64F neg:(Neg64F x) y:(Const64F [c])))
	// result: (Not (Less64F y neg))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeq64F {
				continue
			}
			x := v_0.Args[1]
			if x != v_0.Args[0] || v_1.Op != ssaop.OpLeq64F {
				continue
			}
			_ = v_1.Args[1]
			neg := v_1.Args[0]
			if neg.Op != ssaop.OpNeg64F || x != neg.Args[0] {
				continue
			}
			y := v_1.Args[1]
			if y.Op != ssaop.OpConst64F {
				continue
			}
			v.Reset(ssaop.OpNot)
			v0 := b.NewValue0(v.Pos, ssaop.OpLess64F, typ.Bool)
			v0.AddArg2(y, neg)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (OrB (Neq64F x x) (Less64F y:(Const64F [c]) neg:(Neg64F x)))
	// result: (Not (Leq64F neg y))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeq64F {
				continue
			}
			x := v_0.Args[1]
			if x != v_0.Args[0] || v_1.Op != ssaop.OpLess64F {
				continue
			}
			_ = v_1.Args[1]
			y := v_1.Args[0]
			if y.Op != ssaop.OpConst64F {
				continue
			}
			neg := v_1.Args[1]
			if neg.Op != ssaop.OpNeg64F || x != neg.Args[0] {
				continue
			}
			v.Reset(ssaop.OpNot)
			v0 := b.NewValue0(v.Pos, ssaop.OpLeq64F, typ.Bool)
			v0.AddArg2(neg, y)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (OrB (Neq64F x x) (Leq64F y:(Const64F [c]) neg:(Neg64F x)))
	// result: (Not (Less64F neg y))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeq64F {
				continue
			}
			x := v_0.Args[1]
			if x != v_0.Args[0] || v_1.Op != ssaop.OpLeq64F {
				continue
			}
			_ = v_1.Args[1]
			y := v_1.Args[0]
			if y.Op != ssaop.OpConst64F {
				continue
			}
			neg := v_1.Args[1]
			if neg.Op != ssaop.OpNeg64F || x != neg.Args[0] {
				continue
			}
			v.Reset(ssaop.OpNot)
			v0 := b.NewValue0(v.Pos, ssaop.OpLess64F, typ.Bool)
			v0.AddArg2(neg, y)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (OrB (Neq32F x x) (Less32F neg:(Neg32F x) y:(Const32F [c])))
	// result: (Not (Leq32F y neg))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeq32F {
				continue
			}
			x := v_0.Args[1]
			if x != v_0.Args[0] || v_1.Op != ssaop.OpLess32F {
				continue
			}
			_ = v_1.Args[1]
			neg := v_1.Args[0]
			if neg.Op != ssaop.OpNeg32F || x != neg.Args[0] {
				continue
			}
			y := v_1.Args[1]
			if y.Op != ssaop.OpConst32F {
				continue
			}
			v.Reset(ssaop.OpNot)
			v0 := b.NewValue0(v.Pos, ssaop.OpLeq32F, typ.Bool)
			v0.AddArg2(y, neg)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (OrB (Neq32F x x) (Leq32F neg:(Neg32F x) y:(Const32F [c])))
	// result: (Not (Less32F y neg))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeq32F {
				continue
			}
			x := v_0.Args[1]
			if x != v_0.Args[0] || v_1.Op != ssaop.OpLeq32F {
				continue
			}
			_ = v_1.Args[1]
			neg := v_1.Args[0]
			if neg.Op != ssaop.OpNeg32F || x != neg.Args[0] {
				continue
			}
			y := v_1.Args[1]
			if y.Op != ssaop.OpConst32F {
				continue
			}
			v.Reset(ssaop.OpNot)
			v0 := b.NewValue0(v.Pos, ssaop.OpLess32F, typ.Bool)
			v0.AddArg2(y, neg)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (OrB (Neq32F x x) (Less32F y:(Const32F [c]) neg:(Neg32F x)))
	// result: (Not (Leq32F neg y))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeq32F {
				continue
			}
			x := v_0.Args[1]
			if x != v_0.Args[0] || v_1.Op != ssaop.OpLess32F {
				continue
			}
			_ = v_1.Args[1]
			y := v_1.Args[0]
			if y.Op != ssaop.OpConst32F {
				continue
			}
			neg := v_1.Args[1]
			if neg.Op != ssaop.OpNeg32F || x != neg.Args[0] {
				continue
			}
			v.Reset(ssaop.OpNot)
			v0 := b.NewValue0(v.Pos, ssaop.OpLeq32F, typ.Bool)
			v0.AddArg2(neg, y)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (OrB (Neq32F x x) (Leq32F y:(Const32F [c]) neg:(Neg32F x)))
	// result: (Not (Less32F neg y))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpNeq32F {
				continue
			}
			x := v_0.Args[1]
			if x != v_0.Args[0] || v_1.Op != ssaop.OpLeq32F {
				continue
			}
			_ = v_1.Args[1]
			y := v_1.Args[0]
			if y.Op != ssaop.OpConst32F {
				continue
			}
			neg := v_1.Args[1]
			if neg.Op != ssaop.OpNeg32F || x != neg.Args[0] {
				continue
			}
			v.Reset(ssaop.OpNot)
			v0 := b.NewValue0(v.Pos, ssaop.OpLess32F, typ.Bool)
			v0.AddArg2(neg, y)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (OrB x x)
	// result: x
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (OrB (ConstBool [false]) x)
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConstBool || ssa.AuxIntToBool(v_0.AuxInt) != false {
				continue
			}
			x := v_1
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (OrB (ConstBool [true]) _)
	// result: (ConstBool [true])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConstBool || ssa.AuxIntToBool(v_0.AuxInt) != true {
				continue
			}
			v.Reset(ssaop.OpConstBool)
			v.AuxInt = ssa.BoolToAuxInt(true)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpPhi(v *ssa.Value) bool {
	b := v.Block
	// match: (Phi (Const8 [c]) (Const8 [c]))
	// result: (Const8 [c])
	for {
		if len(v.Args) != 2 {
			break
		}
		_ = v.Args[1]
		v_0 := v.Args[0]
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_0.AuxInt)
		v_1 := v.Args[1]
		if v_1.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_1.AuxInt) != c {
			break
		}
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(c)
		return true
	}
	// match: (Phi (Const16 [c]) (Const16 [c]))
	// result: (Const16 [c])
	for {
		if len(v.Args) != 2 {
			break
		}
		_ = v.Args[1]
		v_0 := v.Args[0]
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_0.AuxInt)
		v_1 := v.Args[1]
		if v_1.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_1.AuxInt) != c {
			break
		}
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(c)
		return true
	}
	// match: (Phi (Const32 [c]) (Const32 [c]))
	// result: (Const32 [c])
	for {
		if len(v.Args) != 2 {
			break
		}
		_ = v.Args[1]
		v_0 := v.Args[0]
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_0.AuxInt)
		v_1 := v.Args[1]
		if v_1.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1.AuxInt) != c {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(c)
		return true
	}
	// match: (Phi (Const64 [c]) (Const64 [c]))
	// result: (Const64 [c])
	for {
		if len(v.Args) != 2 {
			break
		}
		_ = v.Args[1]
		v_0 := v.Args[0]
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0.AuxInt)
		v_1 := v.Args[1]
		if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != c {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(c)
		return true
	}
	// match: (Phi <t> nx:(Not x) ny:(Not y))
	// cond: nx.Uses == 1 && ny.Uses == 1
	// result: (Not (Phi <t> x y))
	for {
		if len(v.Args) != 2 {
			break
		}
		t := v.Type
		_ = v.Args[1]
		nx := v.Args[0]
		if nx.Op != ssaop.OpNot {
			break
		}
		x := nx.Args[0]
		ny := v.Args[1]
		if ny.Op != ssaop.OpNot {
			break
		}
		y := ny.Args[0]
		if !(nx.Uses == 1 && ny.Uses == 1) {
			break
		}
		v.Reset(ssaop.OpNot)
		v0 := b.NewValue0(v.Pos, ssaop.OpPhi, t)
		v0.AddArg2(x, y)
		v.AddArg(v0)
		return true
	}
	return false
}
func rewriteValue_OpPopCount16(v *ssa.Value) bool {
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	// match: (PopCount16 (Const16 [c]))
	// cond: config.PtrSize == 8
	// result: (Const64 [int64(bits.OnesCount16(uint16(c)))])
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_0.AuxInt)
		if !(config.PtrSize == 8) {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(int64(bits.OnesCount16(uint16(c))))
		return true
	}
	// match: (PopCount16 (Const16 [c]))
	// cond: config.PtrSize == 4
	// result: (Const32 [int32(bits.OnesCount16(uint16(c)))])
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_0.AuxInt)
		if !(config.PtrSize == 4) {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(int32(bits.OnesCount16(uint16(c))))
		return true
	}
	return false
}
func rewriteValue_OpPopCount32(v *ssa.Value) bool {
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	// match: (PopCount32 (Const32 [c]))
	// cond: config.PtrSize == 8
	// result: (Const64 [int64(bits.OnesCount32(uint32(c)))])
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_0.AuxInt)
		if !(config.PtrSize == 8) {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(int64(bits.OnesCount32(uint32(c))))
		return true
	}
	// match: (PopCount32 (Const32 [c]))
	// cond: config.PtrSize == 4
	// result: (Const32 [int32(bits.OnesCount32(uint32(c)))])
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_0.AuxInt)
		if !(config.PtrSize == 4) {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(int32(bits.OnesCount32(uint32(c))))
		return true
	}
	return false
}
func rewriteValue_OpPopCount64(v *ssa.Value) bool {
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	// match: (PopCount64 (Const64 [c]))
	// cond: config.PtrSize == 8
	// result: (Const64 [int64(bits.OnesCount64(uint64(c)))])
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0.AuxInt)
		if !(config.PtrSize == 8) {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(int64(bits.OnesCount64(uint64(c))))
		return true
	}
	// match: (PopCount64 (Const64 [c]))
	// cond: config.PtrSize == 4
	// result: (Const32 [int32(bits.OnesCount64(uint64(c)))])
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0.AuxInt)
		if !(config.PtrSize == 4) {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(int32(bits.OnesCount64(uint64(c))))
		return true
	}
	return false
}
func rewriteValue_OpPopCount8(v *ssa.Value) bool {
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	// match: (PopCount8 (Const8 [c]))
	// cond: config.PtrSize == 8
	// result: (Const64 [int64(bits.OnesCount8(uint8(c)))])
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_0.AuxInt)
		if !(config.PtrSize == 8) {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(int64(bits.OnesCount8(uint8(c))))
		return true
	}
	// match: (PopCount8 (Const8 [c]))
	// cond: config.PtrSize == 4
	// result: (Const32 [int32(bits.OnesCount8(uint8(c)))])
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_0.AuxInt)
		if !(config.PtrSize == 4) {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(int32(bits.OnesCount8(uint8(c))))
		return true
	}
	return false
}
func rewriteValue_OpPtrIndex(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	typ := &b.Func.Config.Types
	// match: (PtrIndex <t> ptr idx)
	// cond: config.PtrSize == 4 && ssa.Is32Bit(t.Elem().Size())
	// result: (AddPtr ptr (Mul32 <typ.Int> idx (Const32 <typ.Int> [int32(t.Elem().Size())])))
	for {
		t := v.Type
		ptr := v_0
		idx := v_1
		if !(config.PtrSize == 4 && ssa.Is32Bit(t.Elem().Size())) {
			break
		}
		v.Reset(ssaop.OpAddPtr)
		v0 := b.NewValue0(v.Pos, ssaop.OpMul32, typ.Int)
		v1 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.Int)
		v1.AuxInt = ssa.Int32ToAuxInt(int32(t.Elem().Size()))
		v0.AddArg2(idx, v1)
		v.AddArg2(ptr, v0)
		return true
	}
	// match: (PtrIndex <t> ptr idx)
	// cond: config.PtrSize == 8
	// result: (AddPtr ptr (Mul64 <typ.Int> idx (Const64 <typ.Int> [t.Elem().Size()])))
	for {
		t := v.Type
		ptr := v_0
		idx := v_1
		if !(config.PtrSize == 8) {
			break
		}
		v.Reset(ssaop.OpAddPtr)
		v0 := b.NewValue0(v.Pos, ssaop.OpMul64, typ.Int)
		v1 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int)
		v1.AuxInt = ssa.Int64ToAuxInt(t.Elem().Size())
		v0.AddArg2(idx, v1)
		v.AddArg2(ptr, v0)
		return true
	}
	return false
}
func rewriteValue_OpRotateLeft16(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	// match: (RotateLeft16 (Const16 [x]) (Const64 [y]))
	// result: (Const16 [int16(bits.RotateLeft16(uint16(x), int(y)))])
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		x := ssa.AuxIntToInt16(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		y := ssa.AuxIntToInt64(v_1.AuxInt)
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(int16(bits.RotateLeft16(uint16(x), int(y))))
		return true
	}
	// match: (RotateLeft16 (Const16 [x]) (Const32 [y]))
	// result: (Const16 [int16(bits.RotateLeft16(uint16(x), int(y)))])
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		x := ssa.AuxIntToInt16(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		y := ssa.AuxIntToInt32(v_1.AuxInt)
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(int16(bits.RotateLeft16(uint16(x), int(y))))
		return true
	}
	// match: (RotateLeft16 x (Const16 [c]))
	// cond: c%16 == 0
	// result: x
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_1.AuxInt)
		if !(c%16 == 0) {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (RotateLeft16 x (And64 y (Const64 [c])))
	// cond: c&15 == 15
	// result: (RotateLeft16 x y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAnd64 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			y := v_1_0
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(c&15 == 15) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (RotateLeft16 x (And32 y (Const32 [c])))
	// cond: c&15 == 15
	// result: (RotateLeft16 x y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAnd32 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			y := v_1_0
			if v_1_1.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_1_1.AuxInt)
			if !(c&15 == 15) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (RotateLeft16 x (And16 y (Const16 [c])))
	// cond: c&15 == 15
	// result: (RotateLeft16 x y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAnd16 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			y := v_1_0
			if v_1_1.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_1_1.AuxInt)
			if !(c&15 == 15) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (RotateLeft16 x (And8 y (Const8 [c])))
	// cond: c&15 == 15
	// result: (RotateLeft16 x y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAnd8 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			y := v_1_0
			if v_1_1.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_1_1.AuxInt)
			if !(c&15 == 15) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (RotateLeft16 x (Neg64 (And64 y (Const64 [c]))))
	// cond: c&15 == 15
	// result: (RotateLeft16 x (Neg64 <y.Type> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpNeg64 {
			break
		}
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpAnd64 {
			break
		}
		_ = v_1_0.Args[1]
		v_1_0_0 := v_1_0.Args[0]
		v_1_0_1 := v_1_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0_0, v_1_0_1 = _i0+1, v_1_0_1, v_1_0_0 {
			y := v_1_0_0
			if v_1_0_1.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_1_0_1.AuxInt)
			if !(c&15 == 15) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v0 := b.NewValue0(v.Pos, ssaop.OpNeg64, y.Type)
			v0.AddArg(y)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (RotateLeft16 x (Neg32 (And32 y (Const32 [c]))))
	// cond: c&15 == 15
	// result: (RotateLeft16 x (Neg32 <y.Type> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpNeg32 {
			break
		}
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpAnd32 {
			break
		}
		_ = v_1_0.Args[1]
		v_1_0_0 := v_1_0.Args[0]
		v_1_0_1 := v_1_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0_0, v_1_0_1 = _i0+1, v_1_0_1, v_1_0_0 {
			y := v_1_0_0
			if v_1_0_1.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_1_0_1.AuxInt)
			if !(c&15 == 15) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v0 := b.NewValue0(v.Pos, ssaop.OpNeg32, y.Type)
			v0.AddArg(y)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (RotateLeft16 x (Neg16 (And16 y (Const16 [c]))))
	// cond: c&15 == 15
	// result: (RotateLeft16 x (Neg16 <y.Type> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpNeg16 {
			break
		}
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpAnd16 {
			break
		}
		_ = v_1_0.Args[1]
		v_1_0_0 := v_1_0.Args[0]
		v_1_0_1 := v_1_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0_0, v_1_0_1 = _i0+1, v_1_0_1, v_1_0_0 {
			y := v_1_0_0
			if v_1_0_1.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_1_0_1.AuxInt)
			if !(c&15 == 15) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v0 := b.NewValue0(v.Pos, ssaop.OpNeg16, y.Type)
			v0.AddArg(y)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (RotateLeft16 x (Neg8 (And8 y (Const8 [c]))))
	// cond: c&15 == 15
	// result: (RotateLeft16 x (Neg8 <y.Type> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpNeg8 {
			break
		}
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpAnd8 {
			break
		}
		_ = v_1_0.Args[1]
		v_1_0_0 := v_1_0.Args[0]
		v_1_0_1 := v_1_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0_0, v_1_0_1 = _i0+1, v_1_0_1, v_1_0_0 {
			y := v_1_0_0
			if v_1_0_1.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_1_0_1.AuxInt)
			if !(c&15 == 15) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v0 := b.NewValue0(v.Pos, ssaop.OpNeg8, y.Type)
			v0.AddArg(y)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (RotateLeft16 x (Add64 y (Const64 [c])))
	// cond: c&15 == 0
	// result: (RotateLeft16 x y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAdd64 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			y := v_1_0
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(c&15 == 0) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (RotateLeft16 x (Add32 y (Const32 [c])))
	// cond: c&15 == 0
	// result: (RotateLeft16 x y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAdd32 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			y := v_1_0
			if v_1_1.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_1_1.AuxInt)
			if !(c&15 == 0) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (RotateLeft16 x (Add16 y (Const16 [c])))
	// cond: c&15 == 0
	// result: (RotateLeft16 x y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAdd16 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			y := v_1_0
			if v_1_1.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_1_1.AuxInt)
			if !(c&15 == 0) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (RotateLeft16 x (Add8 y (Const8 [c])))
	// cond: c&15 == 0
	// result: (RotateLeft16 x y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAdd8 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			y := v_1_0
			if v_1_1.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_1_1.AuxInt)
			if !(c&15 == 0) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (RotateLeft16 x (Sub64 (Const64 [c]) y))
	// cond: c&15 == 0
	// result: (RotateLeft16 x (Neg64 <y.Type> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpSub64 {
			break
		}
		y := v_1.Args[1]
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_1_0.AuxInt)
		if !(c&15 == 0) {
			break
		}
		v.Reset(ssaop.OpRotateLeft16)
		v0 := b.NewValue0(v.Pos, ssaop.OpNeg64, y.Type)
		v0.AddArg(y)
		v.AddArg2(x, v0)
		return true
	}
	// match: (RotateLeft16 x (Sub32 (Const32 [c]) y))
	// cond: c&15 == 0
	// result: (RotateLeft16 x (Neg32 <y.Type> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpSub32 {
			break
		}
		y := v_1.Args[1]
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_1_0.AuxInt)
		if !(c&15 == 0) {
			break
		}
		v.Reset(ssaop.OpRotateLeft16)
		v0 := b.NewValue0(v.Pos, ssaop.OpNeg32, y.Type)
		v0.AddArg(y)
		v.AddArg2(x, v0)
		return true
	}
	// match: (RotateLeft16 x (Sub16 (Const16 [c]) y))
	// cond: c&15 == 0
	// result: (RotateLeft16 x (Neg16 <y.Type> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpSub16 {
			break
		}
		y := v_1.Args[1]
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_1_0.AuxInt)
		if !(c&15 == 0) {
			break
		}
		v.Reset(ssaop.OpRotateLeft16)
		v0 := b.NewValue0(v.Pos, ssaop.OpNeg16, y.Type)
		v0.AddArg(y)
		v.AddArg2(x, v0)
		return true
	}
	// match: (RotateLeft16 x (Sub8 (Const8 [c]) y))
	// cond: c&15 == 0
	// result: (RotateLeft16 x (Neg8 <y.Type> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpSub8 {
			break
		}
		y := v_1.Args[1]
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_1_0.AuxInt)
		if !(c&15 == 0) {
			break
		}
		v.Reset(ssaop.OpRotateLeft16)
		v0 := b.NewValue0(v.Pos, ssaop.OpNeg8, y.Type)
		v0.AddArg(y)
		v.AddArg2(x, v0)
		return true
	}
	// match: (RotateLeft16 x (Const64 <t> [c]))
	// cond: config.PtrSize == 4
	// result: (RotateLeft16 x (Const32 <t> [int32(c)]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		t := v_1.Type
		c := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(config.PtrSize == 4) {
			break
		}
		v.Reset(ssaop.OpRotateLeft16)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
		v0.AuxInt = ssa.Int32ToAuxInt(int32(c))
		v.AddArg2(x, v0)
		return true
	}
	// match: (RotateLeft16 (RotateLeft16 x c) d)
	// cond: c.Type.Size() == 8 && d.Type.Size() == 8
	// result: (RotateLeft16 x (Add64 <c.Type> c d))
	for {
		if v_0.Op != ssaop.OpRotateLeft16 {
			break
		}
		c := v_0.Args[1]
		x := v_0.Args[0]
		d := v_1
		if !(c.Type.Size() == 8 && d.Type.Size() == 8) {
			break
		}
		v.Reset(ssaop.OpRotateLeft16)
		v0 := b.NewValue0(v.Pos, ssaop.OpAdd64, c.Type)
		v0.AddArg2(c, d)
		v.AddArg2(x, v0)
		return true
	}
	// match: (RotateLeft16 (RotateLeft16 x c) d)
	// cond: c.Type.Size() == 4 && d.Type.Size() == 4
	// result: (RotateLeft16 x (Add32 <c.Type> c d))
	for {
		if v_0.Op != ssaop.OpRotateLeft16 {
			break
		}
		c := v_0.Args[1]
		x := v_0.Args[0]
		d := v_1
		if !(c.Type.Size() == 4 && d.Type.Size() == 4) {
			break
		}
		v.Reset(ssaop.OpRotateLeft16)
		v0 := b.NewValue0(v.Pos, ssaop.OpAdd32, c.Type)
		v0.AddArg2(c, d)
		v.AddArg2(x, v0)
		return true
	}
	// match: (RotateLeft16 (RotateLeft16 x c) d)
	// cond: c.Type.Size() == 2 && d.Type.Size() == 2
	// result: (RotateLeft16 x (Add16 <c.Type> c d))
	for {
		if v_0.Op != ssaop.OpRotateLeft16 {
			break
		}
		c := v_0.Args[1]
		x := v_0.Args[0]
		d := v_1
		if !(c.Type.Size() == 2 && d.Type.Size() == 2) {
			break
		}
		v.Reset(ssaop.OpRotateLeft16)
		v0 := b.NewValue0(v.Pos, ssaop.OpAdd16, c.Type)
		v0.AddArg2(c, d)
		v.AddArg2(x, v0)
		return true
	}
	// match: (RotateLeft16 (RotateLeft16 x c) d)
	// cond: c.Type.Size() == 1 && d.Type.Size() == 1
	// result: (RotateLeft16 x (Add8 <c.Type> c d))
	for {
		if v_0.Op != ssaop.OpRotateLeft16 {
			break
		}
		c := v_0.Args[1]
		x := v_0.Args[0]
		d := v_1
		if !(c.Type.Size() == 1 && d.Type.Size() == 1) {
			break
		}
		v.Reset(ssaop.OpRotateLeft16)
		v0 := b.NewValue0(v.Pos, ssaop.OpAdd8, c.Type)
		v0.AddArg2(c, d)
		v.AddArg2(x, v0)
		return true
	}
	return false
}
func rewriteValue_OpRotateLeft32(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	// match: (RotateLeft32 (Const32 [x]) (Const64 [y]))
	// result: (Const32 [int32(bits.RotateLeft32(uint32(x), int(y)))])
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		x := ssa.AuxIntToInt32(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		y := ssa.AuxIntToInt64(v_1.AuxInt)
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(int32(bits.RotateLeft32(uint32(x), int(y))))
		return true
	}
	// match: (RotateLeft32 (Const32 [x]) (Const32 [y]))
	// result: (Const32 [int32(bits.RotateLeft32(uint32(x), int(y)))])
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		x := ssa.AuxIntToInt32(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		y := ssa.AuxIntToInt32(v_1.AuxInt)
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(int32(bits.RotateLeft32(uint32(x), int(y))))
		return true
	}
	// match: (RotateLeft32 x (Const32 [c]))
	// cond: c%32 == 0
	// result: x
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_1.AuxInt)
		if !(c%32 == 0) {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (RotateLeft32 x (And64 y (Const64 [c])))
	// cond: c&31 == 31
	// result: (RotateLeft32 x y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAnd64 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			y := v_1_0
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(c&31 == 31) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (RotateLeft32 x (And32 y (Const32 [c])))
	// cond: c&31 == 31
	// result: (RotateLeft32 x y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAnd32 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			y := v_1_0
			if v_1_1.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_1_1.AuxInt)
			if !(c&31 == 31) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (RotateLeft32 x (And16 y (Const16 [c])))
	// cond: c&31 == 31
	// result: (RotateLeft32 x y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAnd16 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			y := v_1_0
			if v_1_1.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_1_1.AuxInt)
			if !(c&31 == 31) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (RotateLeft32 x (And8 y (Const8 [c])))
	// cond: c&31 == 31
	// result: (RotateLeft32 x y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAnd8 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			y := v_1_0
			if v_1_1.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_1_1.AuxInt)
			if !(c&31 == 31) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (RotateLeft32 x (Neg64 (And64 y (Const64 [c]))))
	// cond: c&31 == 31
	// result: (RotateLeft32 x (Neg64 <y.Type> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpNeg64 {
			break
		}
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpAnd64 {
			break
		}
		_ = v_1_0.Args[1]
		v_1_0_0 := v_1_0.Args[0]
		v_1_0_1 := v_1_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0_0, v_1_0_1 = _i0+1, v_1_0_1, v_1_0_0 {
			y := v_1_0_0
			if v_1_0_1.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_1_0_1.AuxInt)
			if !(c&31 == 31) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v0 := b.NewValue0(v.Pos, ssaop.OpNeg64, y.Type)
			v0.AddArg(y)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (RotateLeft32 x (Neg32 (And32 y (Const32 [c]))))
	// cond: c&31 == 31
	// result: (RotateLeft32 x (Neg32 <y.Type> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpNeg32 {
			break
		}
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpAnd32 {
			break
		}
		_ = v_1_0.Args[1]
		v_1_0_0 := v_1_0.Args[0]
		v_1_0_1 := v_1_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0_0, v_1_0_1 = _i0+1, v_1_0_1, v_1_0_0 {
			y := v_1_0_0
			if v_1_0_1.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_1_0_1.AuxInt)
			if !(c&31 == 31) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v0 := b.NewValue0(v.Pos, ssaop.OpNeg32, y.Type)
			v0.AddArg(y)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (RotateLeft32 x (Neg16 (And16 y (Const16 [c]))))
	// cond: c&31 == 31
	// result: (RotateLeft32 x (Neg16 <y.Type> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpNeg16 {
			break
		}
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpAnd16 {
			break
		}
		_ = v_1_0.Args[1]
		v_1_0_0 := v_1_0.Args[0]
		v_1_0_1 := v_1_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0_0, v_1_0_1 = _i0+1, v_1_0_1, v_1_0_0 {
			y := v_1_0_0
			if v_1_0_1.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_1_0_1.AuxInt)
			if !(c&31 == 31) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v0 := b.NewValue0(v.Pos, ssaop.OpNeg16, y.Type)
			v0.AddArg(y)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (RotateLeft32 x (Neg8 (And8 y (Const8 [c]))))
	// cond: c&31 == 31
	// result: (RotateLeft32 x (Neg8 <y.Type> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpNeg8 {
			break
		}
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpAnd8 {
			break
		}
		_ = v_1_0.Args[1]
		v_1_0_0 := v_1_0.Args[0]
		v_1_0_1 := v_1_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0_0, v_1_0_1 = _i0+1, v_1_0_1, v_1_0_0 {
			y := v_1_0_0
			if v_1_0_1.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_1_0_1.AuxInt)
			if !(c&31 == 31) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v0 := b.NewValue0(v.Pos, ssaop.OpNeg8, y.Type)
			v0.AddArg(y)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (RotateLeft32 x (Add64 y (Const64 [c])))
	// cond: c&31 == 0
	// result: (RotateLeft32 x y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAdd64 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			y := v_1_0
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(c&31 == 0) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (RotateLeft32 x (Add32 y (Const32 [c])))
	// cond: c&31 == 0
	// result: (RotateLeft32 x y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAdd32 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			y := v_1_0
			if v_1_1.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_1_1.AuxInt)
			if !(c&31 == 0) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (RotateLeft32 x (Add16 y (Const16 [c])))
	// cond: c&31 == 0
	// result: (RotateLeft32 x y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAdd16 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			y := v_1_0
			if v_1_1.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_1_1.AuxInt)
			if !(c&31 == 0) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (RotateLeft32 x (Add8 y (Const8 [c])))
	// cond: c&31 == 0
	// result: (RotateLeft32 x y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAdd8 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			y := v_1_0
			if v_1_1.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_1_1.AuxInt)
			if !(c&31 == 0) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (RotateLeft32 x (Sub64 (Const64 [c]) y))
	// cond: c&31 == 0
	// result: (RotateLeft32 x (Neg64 <y.Type> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpSub64 {
			break
		}
		y := v_1.Args[1]
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_1_0.AuxInt)
		if !(c&31 == 0) {
			break
		}
		v.Reset(ssaop.OpRotateLeft32)
		v0 := b.NewValue0(v.Pos, ssaop.OpNeg64, y.Type)
		v0.AddArg(y)
		v.AddArg2(x, v0)
		return true
	}
	// match: (RotateLeft32 x (Sub32 (Const32 [c]) y))
	// cond: c&31 == 0
	// result: (RotateLeft32 x (Neg32 <y.Type> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpSub32 {
			break
		}
		y := v_1.Args[1]
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_1_0.AuxInt)
		if !(c&31 == 0) {
			break
		}
		v.Reset(ssaop.OpRotateLeft32)
		v0 := b.NewValue0(v.Pos, ssaop.OpNeg32, y.Type)
		v0.AddArg(y)
		v.AddArg2(x, v0)
		return true
	}
	// match: (RotateLeft32 x (Sub16 (Const16 [c]) y))
	// cond: c&31 == 0
	// result: (RotateLeft32 x (Neg16 <y.Type> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpSub16 {
			break
		}
		y := v_1.Args[1]
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_1_0.AuxInt)
		if !(c&31 == 0) {
			break
		}
		v.Reset(ssaop.OpRotateLeft32)
		v0 := b.NewValue0(v.Pos, ssaop.OpNeg16, y.Type)
		v0.AddArg(y)
		v.AddArg2(x, v0)
		return true
	}
	// match: (RotateLeft32 x (Sub8 (Const8 [c]) y))
	// cond: c&31 == 0
	// result: (RotateLeft32 x (Neg8 <y.Type> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpSub8 {
			break
		}
		y := v_1.Args[1]
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_1_0.AuxInt)
		if !(c&31 == 0) {
			break
		}
		v.Reset(ssaop.OpRotateLeft32)
		v0 := b.NewValue0(v.Pos, ssaop.OpNeg8, y.Type)
		v0.AddArg(y)
		v.AddArg2(x, v0)
		return true
	}
	// match: (RotateLeft32 x (Const64 <t> [c]))
	// cond: config.PtrSize == 4
	// result: (RotateLeft32 x (Const32 <t> [int32(c)]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		t := v_1.Type
		c := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(config.PtrSize == 4) {
			break
		}
		v.Reset(ssaop.OpRotateLeft32)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
		v0.AuxInt = ssa.Int32ToAuxInt(int32(c))
		v.AddArg2(x, v0)
		return true
	}
	// match: (RotateLeft32 (RotateLeft32 x c) d)
	// cond: c.Type.Size() == 8 && d.Type.Size() == 8
	// result: (RotateLeft32 x (Add64 <c.Type> c d))
	for {
		if v_0.Op != ssaop.OpRotateLeft32 {
			break
		}
		c := v_0.Args[1]
		x := v_0.Args[0]
		d := v_1
		if !(c.Type.Size() == 8 && d.Type.Size() == 8) {
			break
		}
		v.Reset(ssaop.OpRotateLeft32)
		v0 := b.NewValue0(v.Pos, ssaop.OpAdd64, c.Type)
		v0.AddArg2(c, d)
		v.AddArg2(x, v0)
		return true
	}
	// match: (RotateLeft32 (RotateLeft32 x c) d)
	// cond: c.Type.Size() == 4 && d.Type.Size() == 4
	// result: (RotateLeft32 x (Add32 <c.Type> c d))
	for {
		if v_0.Op != ssaop.OpRotateLeft32 {
			break
		}
		c := v_0.Args[1]
		x := v_0.Args[0]
		d := v_1
		if !(c.Type.Size() == 4 && d.Type.Size() == 4) {
			break
		}
		v.Reset(ssaop.OpRotateLeft32)
		v0 := b.NewValue0(v.Pos, ssaop.OpAdd32, c.Type)
		v0.AddArg2(c, d)
		v.AddArg2(x, v0)
		return true
	}
	// match: (RotateLeft32 (RotateLeft32 x c) d)
	// cond: c.Type.Size() == 2 && d.Type.Size() == 2
	// result: (RotateLeft32 x (Add16 <c.Type> c d))
	for {
		if v_0.Op != ssaop.OpRotateLeft32 {
			break
		}
		c := v_0.Args[1]
		x := v_0.Args[0]
		d := v_1
		if !(c.Type.Size() == 2 && d.Type.Size() == 2) {
			break
		}
		v.Reset(ssaop.OpRotateLeft32)
		v0 := b.NewValue0(v.Pos, ssaop.OpAdd16, c.Type)
		v0.AddArg2(c, d)
		v.AddArg2(x, v0)
		return true
	}
	// match: (RotateLeft32 (RotateLeft32 x c) d)
	// cond: c.Type.Size() == 1 && d.Type.Size() == 1
	// result: (RotateLeft32 x (Add8 <c.Type> c d))
	for {
		if v_0.Op != ssaop.OpRotateLeft32 {
			break
		}
		c := v_0.Args[1]
		x := v_0.Args[0]
		d := v_1
		if !(c.Type.Size() == 1 && d.Type.Size() == 1) {
			break
		}
		v.Reset(ssaop.OpRotateLeft32)
		v0 := b.NewValue0(v.Pos, ssaop.OpAdd8, c.Type)
		v0.AddArg2(c, d)
		v.AddArg2(x, v0)
		return true
	}
	return false
}
func rewriteValue_OpRotateLeft64(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	// match: (RotateLeft64 (Const64 [x]) (Const64 [y]))
	// result: (Const64 [int64(bits.RotateLeft64(uint64(x), int(y)))])
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		x := ssa.AuxIntToInt64(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		y := ssa.AuxIntToInt64(v_1.AuxInt)
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(int64(bits.RotateLeft64(uint64(x), int(y))))
		return true
	}
	// match: (RotateLeft64 (Const64 [x]) (Const32 [y]))
	// result: (Const64 [int64(bits.RotateLeft64(uint64(x), int(y)))])
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		x := ssa.AuxIntToInt64(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		y := ssa.AuxIntToInt32(v_1.AuxInt)
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(int64(bits.RotateLeft64(uint64(x), int(y))))
		return true
	}
	// match: (RotateLeft64 x (Const64 [c]))
	// cond: c%64 == 0
	// result: x
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(c%64 == 0) {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (RotateLeft64 x (And64 y (Const64 [c])))
	// cond: c&63 == 63
	// result: (RotateLeft64 x y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAnd64 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			y := v_1_0
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(c&63 == 63) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (RotateLeft64 x (And32 y (Const32 [c])))
	// cond: c&63 == 63
	// result: (RotateLeft64 x y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAnd32 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			y := v_1_0
			if v_1_1.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_1_1.AuxInt)
			if !(c&63 == 63) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (RotateLeft64 x (And16 y (Const16 [c])))
	// cond: c&63 == 63
	// result: (RotateLeft64 x y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAnd16 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			y := v_1_0
			if v_1_1.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_1_1.AuxInt)
			if !(c&63 == 63) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (RotateLeft64 x (And8 y (Const8 [c])))
	// cond: c&63 == 63
	// result: (RotateLeft64 x y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAnd8 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			y := v_1_0
			if v_1_1.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_1_1.AuxInt)
			if !(c&63 == 63) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (RotateLeft64 x (Neg64 (And64 y (Const64 [c]))))
	// cond: c&63 == 63
	// result: (RotateLeft64 x (Neg64 <y.Type> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpNeg64 {
			break
		}
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpAnd64 {
			break
		}
		_ = v_1_0.Args[1]
		v_1_0_0 := v_1_0.Args[0]
		v_1_0_1 := v_1_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0_0, v_1_0_1 = _i0+1, v_1_0_1, v_1_0_0 {
			y := v_1_0_0
			if v_1_0_1.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_1_0_1.AuxInt)
			if !(c&63 == 63) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v0 := b.NewValue0(v.Pos, ssaop.OpNeg64, y.Type)
			v0.AddArg(y)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (RotateLeft64 x (Neg32 (And32 y (Const32 [c]))))
	// cond: c&63 == 63
	// result: (RotateLeft64 x (Neg32 <y.Type> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpNeg32 {
			break
		}
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpAnd32 {
			break
		}
		_ = v_1_0.Args[1]
		v_1_0_0 := v_1_0.Args[0]
		v_1_0_1 := v_1_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0_0, v_1_0_1 = _i0+1, v_1_0_1, v_1_0_0 {
			y := v_1_0_0
			if v_1_0_1.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_1_0_1.AuxInt)
			if !(c&63 == 63) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v0 := b.NewValue0(v.Pos, ssaop.OpNeg32, y.Type)
			v0.AddArg(y)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (RotateLeft64 x (Neg16 (And16 y (Const16 [c]))))
	// cond: c&63 == 63
	// result: (RotateLeft64 x (Neg16 <y.Type> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpNeg16 {
			break
		}
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpAnd16 {
			break
		}
		_ = v_1_0.Args[1]
		v_1_0_0 := v_1_0.Args[0]
		v_1_0_1 := v_1_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0_0, v_1_0_1 = _i0+1, v_1_0_1, v_1_0_0 {
			y := v_1_0_0
			if v_1_0_1.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_1_0_1.AuxInt)
			if !(c&63 == 63) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v0 := b.NewValue0(v.Pos, ssaop.OpNeg16, y.Type)
			v0.AddArg(y)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (RotateLeft64 x (Neg8 (And8 y (Const8 [c]))))
	// cond: c&63 == 63
	// result: (RotateLeft64 x (Neg8 <y.Type> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpNeg8 {
			break
		}
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpAnd8 {
			break
		}
		_ = v_1_0.Args[1]
		v_1_0_0 := v_1_0.Args[0]
		v_1_0_1 := v_1_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0_0, v_1_0_1 = _i0+1, v_1_0_1, v_1_0_0 {
			y := v_1_0_0
			if v_1_0_1.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_1_0_1.AuxInt)
			if !(c&63 == 63) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v0 := b.NewValue0(v.Pos, ssaop.OpNeg8, y.Type)
			v0.AddArg(y)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (RotateLeft64 x (Add64 y (Const64 [c])))
	// cond: c&63 == 0
	// result: (RotateLeft64 x y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAdd64 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			y := v_1_0
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(c&63 == 0) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (RotateLeft64 x (Add32 y (Const32 [c])))
	// cond: c&63 == 0
	// result: (RotateLeft64 x y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAdd32 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			y := v_1_0
			if v_1_1.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_1_1.AuxInt)
			if !(c&63 == 0) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (RotateLeft64 x (Add16 y (Const16 [c])))
	// cond: c&63 == 0
	// result: (RotateLeft64 x y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAdd16 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			y := v_1_0
			if v_1_1.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_1_1.AuxInt)
			if !(c&63 == 0) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (RotateLeft64 x (Add8 y (Const8 [c])))
	// cond: c&63 == 0
	// result: (RotateLeft64 x y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAdd8 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			y := v_1_0
			if v_1_1.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_1_1.AuxInt)
			if !(c&63 == 0) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (RotateLeft64 x (Sub64 (Const64 [c]) y))
	// cond: c&63 == 0
	// result: (RotateLeft64 x (Neg64 <y.Type> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpSub64 {
			break
		}
		y := v_1.Args[1]
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_1_0.AuxInt)
		if !(c&63 == 0) {
			break
		}
		v.Reset(ssaop.OpRotateLeft64)
		v0 := b.NewValue0(v.Pos, ssaop.OpNeg64, y.Type)
		v0.AddArg(y)
		v.AddArg2(x, v0)
		return true
	}
	// match: (RotateLeft64 x (Sub32 (Const32 [c]) y))
	// cond: c&63 == 0
	// result: (RotateLeft64 x (Neg32 <y.Type> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpSub32 {
			break
		}
		y := v_1.Args[1]
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_1_0.AuxInt)
		if !(c&63 == 0) {
			break
		}
		v.Reset(ssaop.OpRotateLeft64)
		v0 := b.NewValue0(v.Pos, ssaop.OpNeg32, y.Type)
		v0.AddArg(y)
		v.AddArg2(x, v0)
		return true
	}
	// match: (RotateLeft64 x (Sub16 (Const16 [c]) y))
	// cond: c&63 == 0
	// result: (RotateLeft64 x (Neg16 <y.Type> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpSub16 {
			break
		}
		y := v_1.Args[1]
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_1_0.AuxInt)
		if !(c&63 == 0) {
			break
		}
		v.Reset(ssaop.OpRotateLeft64)
		v0 := b.NewValue0(v.Pos, ssaop.OpNeg16, y.Type)
		v0.AddArg(y)
		v.AddArg2(x, v0)
		return true
	}
	// match: (RotateLeft64 x (Sub8 (Const8 [c]) y))
	// cond: c&63 == 0
	// result: (RotateLeft64 x (Neg8 <y.Type> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpSub8 {
			break
		}
		y := v_1.Args[1]
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_1_0.AuxInt)
		if !(c&63 == 0) {
			break
		}
		v.Reset(ssaop.OpRotateLeft64)
		v0 := b.NewValue0(v.Pos, ssaop.OpNeg8, y.Type)
		v0.AddArg(y)
		v.AddArg2(x, v0)
		return true
	}
	// match: (RotateLeft64 x (Const64 <t> [c]))
	// cond: config.PtrSize == 4
	// result: (RotateLeft64 x (Const32 <t> [int32(c)]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		t := v_1.Type
		c := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(config.PtrSize == 4) {
			break
		}
		v.Reset(ssaop.OpRotateLeft64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
		v0.AuxInt = ssa.Int32ToAuxInt(int32(c))
		v.AddArg2(x, v0)
		return true
	}
	// match: (RotateLeft64 (RotateLeft64 x c) d)
	// cond: c.Type.Size() == 8 && d.Type.Size() == 8
	// result: (RotateLeft64 x (Add64 <c.Type> c d))
	for {
		if v_0.Op != ssaop.OpRotateLeft64 {
			break
		}
		c := v_0.Args[1]
		x := v_0.Args[0]
		d := v_1
		if !(c.Type.Size() == 8 && d.Type.Size() == 8) {
			break
		}
		v.Reset(ssaop.OpRotateLeft64)
		v0 := b.NewValue0(v.Pos, ssaop.OpAdd64, c.Type)
		v0.AddArg2(c, d)
		v.AddArg2(x, v0)
		return true
	}
	// match: (RotateLeft64 (RotateLeft64 x c) d)
	// cond: c.Type.Size() == 4 && d.Type.Size() == 4
	// result: (RotateLeft64 x (Add32 <c.Type> c d))
	for {
		if v_0.Op != ssaop.OpRotateLeft64 {
			break
		}
		c := v_0.Args[1]
		x := v_0.Args[0]
		d := v_1
		if !(c.Type.Size() == 4 && d.Type.Size() == 4) {
			break
		}
		v.Reset(ssaop.OpRotateLeft64)
		v0 := b.NewValue0(v.Pos, ssaop.OpAdd32, c.Type)
		v0.AddArg2(c, d)
		v.AddArg2(x, v0)
		return true
	}
	// match: (RotateLeft64 (RotateLeft64 x c) d)
	// cond: c.Type.Size() == 2 && d.Type.Size() == 2
	// result: (RotateLeft64 x (Add16 <c.Type> c d))
	for {
		if v_0.Op != ssaop.OpRotateLeft64 {
			break
		}
		c := v_0.Args[1]
		x := v_0.Args[0]
		d := v_1
		if !(c.Type.Size() == 2 && d.Type.Size() == 2) {
			break
		}
		v.Reset(ssaop.OpRotateLeft64)
		v0 := b.NewValue0(v.Pos, ssaop.OpAdd16, c.Type)
		v0.AddArg2(c, d)
		v.AddArg2(x, v0)
		return true
	}
	// match: (RotateLeft64 (RotateLeft64 x c) d)
	// cond: c.Type.Size() == 1 && d.Type.Size() == 1
	// result: (RotateLeft64 x (Add8 <c.Type> c d))
	for {
		if v_0.Op != ssaop.OpRotateLeft64 {
			break
		}
		c := v_0.Args[1]
		x := v_0.Args[0]
		d := v_1
		if !(c.Type.Size() == 1 && d.Type.Size() == 1) {
			break
		}
		v.Reset(ssaop.OpRotateLeft64)
		v0 := b.NewValue0(v.Pos, ssaop.OpAdd8, c.Type)
		v0.AddArg2(c, d)
		v.AddArg2(x, v0)
		return true
	}
	return false
}
func rewriteValue_OpRotateLeft8(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	// match: (RotateLeft8 (Const8 [x]) (Const64 [y]))
	// result: (Const8 [int8(bits.RotateLeft8(uint8(x), int(y)))])
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		x := ssa.AuxIntToInt8(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		y := ssa.AuxIntToInt64(v_1.AuxInt)
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(int8(bits.RotateLeft8(uint8(x), int(y))))
		return true
	}
	// match: (RotateLeft8 (Const8 [x]) (Const32 [y]))
	// result: (Const8 [int8(bits.RotateLeft8(uint8(x), int(y)))])
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		x := ssa.AuxIntToInt8(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		y := ssa.AuxIntToInt32(v_1.AuxInt)
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(int8(bits.RotateLeft8(uint8(x), int(y))))
		return true
	}
	// match: (RotateLeft8 x (Const8 [c]))
	// cond: c%8 == 0
	// result: x
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_1.AuxInt)
		if !(c%8 == 0) {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (RotateLeft8 x (And64 y (Const64 [c])))
	// cond: c&7 == 7
	// result: (RotateLeft8 x y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAnd64 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			y := v_1_0
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(c&7 == 7) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (RotateLeft8 x (And32 y (Const32 [c])))
	// cond: c&7 == 7
	// result: (RotateLeft8 x y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAnd32 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			y := v_1_0
			if v_1_1.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_1_1.AuxInt)
			if !(c&7 == 7) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (RotateLeft8 x (And16 y (Const16 [c])))
	// cond: c&7 == 7
	// result: (RotateLeft8 x y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAnd16 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			y := v_1_0
			if v_1_1.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_1_1.AuxInt)
			if !(c&7 == 7) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (RotateLeft8 x (And8 y (Const8 [c])))
	// cond: c&7 == 7
	// result: (RotateLeft8 x y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAnd8 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			y := v_1_0
			if v_1_1.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_1_1.AuxInt)
			if !(c&7 == 7) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (RotateLeft8 x (Neg64 (And64 y (Const64 [c]))))
	// cond: c&7 == 7
	// result: (RotateLeft8 x (Neg64 <y.Type> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpNeg64 {
			break
		}
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpAnd64 {
			break
		}
		_ = v_1_0.Args[1]
		v_1_0_0 := v_1_0.Args[0]
		v_1_0_1 := v_1_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0_0, v_1_0_1 = _i0+1, v_1_0_1, v_1_0_0 {
			y := v_1_0_0
			if v_1_0_1.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_1_0_1.AuxInt)
			if !(c&7 == 7) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v0 := b.NewValue0(v.Pos, ssaop.OpNeg64, y.Type)
			v0.AddArg(y)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (RotateLeft8 x (Neg32 (And32 y (Const32 [c]))))
	// cond: c&7 == 7
	// result: (RotateLeft8 x (Neg32 <y.Type> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpNeg32 {
			break
		}
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpAnd32 {
			break
		}
		_ = v_1_0.Args[1]
		v_1_0_0 := v_1_0.Args[0]
		v_1_0_1 := v_1_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0_0, v_1_0_1 = _i0+1, v_1_0_1, v_1_0_0 {
			y := v_1_0_0
			if v_1_0_1.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_1_0_1.AuxInt)
			if !(c&7 == 7) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v0 := b.NewValue0(v.Pos, ssaop.OpNeg32, y.Type)
			v0.AddArg(y)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (RotateLeft8 x (Neg16 (And16 y (Const16 [c]))))
	// cond: c&7 == 7
	// result: (RotateLeft8 x (Neg16 <y.Type> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpNeg16 {
			break
		}
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpAnd16 {
			break
		}
		_ = v_1_0.Args[1]
		v_1_0_0 := v_1_0.Args[0]
		v_1_0_1 := v_1_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0_0, v_1_0_1 = _i0+1, v_1_0_1, v_1_0_0 {
			y := v_1_0_0
			if v_1_0_1.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_1_0_1.AuxInt)
			if !(c&7 == 7) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v0 := b.NewValue0(v.Pos, ssaop.OpNeg16, y.Type)
			v0.AddArg(y)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (RotateLeft8 x (Neg8 (And8 y (Const8 [c]))))
	// cond: c&7 == 7
	// result: (RotateLeft8 x (Neg8 <y.Type> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpNeg8 {
			break
		}
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpAnd8 {
			break
		}
		_ = v_1_0.Args[1]
		v_1_0_0 := v_1_0.Args[0]
		v_1_0_1 := v_1_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0_0, v_1_0_1 = _i0+1, v_1_0_1, v_1_0_0 {
			y := v_1_0_0
			if v_1_0_1.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_1_0_1.AuxInt)
			if !(c&7 == 7) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v0 := b.NewValue0(v.Pos, ssaop.OpNeg8, y.Type)
			v0.AddArg(y)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (RotateLeft8 x (Add64 y (Const64 [c])))
	// cond: c&7 == 0
	// result: (RotateLeft8 x y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAdd64 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			y := v_1_0
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(c&7 == 0) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (RotateLeft8 x (Add32 y (Const32 [c])))
	// cond: c&7 == 0
	// result: (RotateLeft8 x y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAdd32 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			y := v_1_0
			if v_1_1.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_1_1.AuxInt)
			if !(c&7 == 0) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (RotateLeft8 x (Add16 y (Const16 [c])))
	// cond: c&7 == 0
	// result: (RotateLeft8 x y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAdd16 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			y := v_1_0
			if v_1_1.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_1_1.AuxInt)
			if !(c&7 == 0) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (RotateLeft8 x (Add8 y (Const8 [c])))
	// cond: c&7 == 0
	// result: (RotateLeft8 x y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAdd8 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			y := v_1_0
			if v_1_1.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_1_1.AuxInt)
			if !(c&7 == 0) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (RotateLeft8 x (Sub64 (Const64 [c]) y))
	// cond: c&7 == 0
	// result: (RotateLeft8 x (Neg64 <y.Type> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpSub64 {
			break
		}
		y := v_1.Args[1]
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_1_0.AuxInt)
		if !(c&7 == 0) {
			break
		}
		v.Reset(ssaop.OpRotateLeft8)
		v0 := b.NewValue0(v.Pos, ssaop.OpNeg64, y.Type)
		v0.AddArg(y)
		v.AddArg2(x, v0)
		return true
	}
	// match: (RotateLeft8 x (Sub32 (Const32 [c]) y))
	// cond: c&7 == 0
	// result: (RotateLeft8 x (Neg32 <y.Type> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpSub32 {
			break
		}
		y := v_1.Args[1]
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_1_0.AuxInt)
		if !(c&7 == 0) {
			break
		}
		v.Reset(ssaop.OpRotateLeft8)
		v0 := b.NewValue0(v.Pos, ssaop.OpNeg32, y.Type)
		v0.AddArg(y)
		v.AddArg2(x, v0)
		return true
	}
	// match: (RotateLeft8 x (Sub16 (Const16 [c]) y))
	// cond: c&7 == 0
	// result: (RotateLeft8 x (Neg16 <y.Type> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpSub16 {
			break
		}
		y := v_1.Args[1]
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_1_0.AuxInt)
		if !(c&7 == 0) {
			break
		}
		v.Reset(ssaop.OpRotateLeft8)
		v0 := b.NewValue0(v.Pos, ssaop.OpNeg16, y.Type)
		v0.AddArg(y)
		v.AddArg2(x, v0)
		return true
	}
	// match: (RotateLeft8 x (Sub8 (Const8 [c]) y))
	// cond: c&7 == 0
	// result: (RotateLeft8 x (Neg8 <y.Type> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpSub8 {
			break
		}
		y := v_1.Args[1]
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_1_0.AuxInt)
		if !(c&7 == 0) {
			break
		}
		v.Reset(ssaop.OpRotateLeft8)
		v0 := b.NewValue0(v.Pos, ssaop.OpNeg8, y.Type)
		v0.AddArg(y)
		v.AddArg2(x, v0)
		return true
	}
	// match: (RotateLeft8 x (Const64 <t> [c]))
	// cond: config.PtrSize == 4
	// result: (RotateLeft8 x (Const32 <t> [int32(c)]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		t := v_1.Type
		c := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(config.PtrSize == 4) {
			break
		}
		v.Reset(ssaop.OpRotateLeft8)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
		v0.AuxInt = ssa.Int32ToAuxInt(int32(c))
		v.AddArg2(x, v0)
		return true
	}
	// match: (RotateLeft8 (RotateLeft8 x c) d)
	// cond: c.Type.Size() == 8 && d.Type.Size() == 8
	// result: (RotateLeft8 x (Add64 <c.Type> c d))
	for {
		if v_0.Op != ssaop.OpRotateLeft8 {
			break
		}
		c := v_0.Args[1]
		x := v_0.Args[0]
		d := v_1
		if !(c.Type.Size() == 8 && d.Type.Size() == 8) {
			break
		}
		v.Reset(ssaop.OpRotateLeft8)
		v0 := b.NewValue0(v.Pos, ssaop.OpAdd64, c.Type)
		v0.AddArg2(c, d)
		v.AddArg2(x, v0)
		return true
	}
	// match: (RotateLeft8 (RotateLeft8 x c) d)
	// cond: c.Type.Size() == 4 && d.Type.Size() == 4
	// result: (RotateLeft8 x (Add32 <c.Type> c d))
	for {
		if v_0.Op != ssaop.OpRotateLeft8 {
			break
		}
		c := v_0.Args[1]
		x := v_0.Args[0]
		d := v_1
		if !(c.Type.Size() == 4 && d.Type.Size() == 4) {
			break
		}
		v.Reset(ssaop.OpRotateLeft8)
		v0 := b.NewValue0(v.Pos, ssaop.OpAdd32, c.Type)
		v0.AddArg2(c, d)
		v.AddArg2(x, v0)
		return true
	}
	// match: (RotateLeft8 (RotateLeft8 x c) d)
	// cond: c.Type.Size() == 2 && d.Type.Size() == 2
	// result: (RotateLeft8 x (Add16 <c.Type> c d))
	for {
		if v_0.Op != ssaop.OpRotateLeft8 {
			break
		}
		c := v_0.Args[1]
		x := v_0.Args[0]
		d := v_1
		if !(c.Type.Size() == 2 && d.Type.Size() == 2) {
			break
		}
		v.Reset(ssaop.OpRotateLeft8)
		v0 := b.NewValue0(v.Pos, ssaop.OpAdd16, c.Type)
		v0.AddArg2(c, d)
		v.AddArg2(x, v0)
		return true
	}
	// match: (RotateLeft8 (RotateLeft8 x c) d)
	// cond: c.Type.Size() == 1 && d.Type.Size() == 1
	// result: (RotateLeft8 x (Add8 <c.Type> c d))
	for {
		if v_0.Op != ssaop.OpRotateLeft8 {
			break
		}
		c := v_0.Args[1]
		x := v_0.Args[0]
		d := v_1
		if !(c.Type.Size() == 1 && d.Type.Size() == 1) {
			break
		}
		v.Reset(ssaop.OpRotateLeft8)
		v0 := b.NewValue0(v.Pos, ssaop.OpAdd8, c.Type)
		v0.AddArg2(c, d)
		v.AddArg2(x, v0)
		return true
	}
	return false
}
func rewriteValue_OpRound32F(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (Round32F x:(Const32F))
	// result: x
	for {
		x := v_0
		if x.Op != ssaop.OpConst32F {
			break
		}
		v.CopyOf(x)
		return true
	}
	return false
}
func rewriteValue_OpRound64F(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (Round64F x:(Const64F))
	// result: x
	for {
		x := v_0
		if x.Op != ssaop.OpConst64F {
			break
		}
		v.CopyOf(x)
		return true
	}
	return false
}
func rewriteValue_OpRoundToEven(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (RoundToEven (Const64F [c]))
	// result: (Const64F [math.RoundToEven(c)])
	for {
		if v_0.Op != ssaop.OpConst64F {
			break
		}
		c := ssa.AuxIntToFloat64(v_0.AuxInt)
		v.Reset(ssaop.OpConst64F)
		v.AuxInt = ssa.Float64ToAuxInt(math.RoundToEven(c))
		return true
	}
	return false
}
func rewriteValue_OpRsh16Ux16(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Rsh16Ux16 x (Const16 [c]))
	// result: (Rsh16Ux64 x (Const64 <types.Types[types.TUINT64]> [int64(uint16(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_1.AuxInt)
		v.Reset(ssaop.OpRsh16Ux64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint16(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh16Ux16 (Const16 [0]) _)
	// result: (Const16 [0])
	for {
		if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(0)
		return true
	}
	// match: (Rsh16Ux16 [false] x con:(Const16 [c]))
	// cond: 0 < c && c < 16
	// result: (Rsh16Ux16 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(con.AuxInt)
		if !(0 < c && c < 16) {
			break
		}
		v.Reset(ssaop.OpRsh16Ux16)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpRsh16Ux32(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Rsh16Ux32 x (Const32 [c]))
	// result: (Rsh16Ux64 x (Const64 <types.Types[types.TUINT64]> [int64(uint32(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_1.AuxInt)
		v.Reset(ssaop.OpRsh16Ux64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint32(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh16Ux32 (Const16 [0]) _)
	// result: (Const16 [0])
	for {
		if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(0)
		return true
	}
	// match: (Rsh16Ux32 [false] x con:(Const32 [c]))
	// cond: 0 < c && c < 16
	// result: (Rsh16Ux32 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(con.AuxInt)
		if !(0 < c && c < 16) {
			break
		}
		v.Reset(ssaop.OpRsh16Ux32)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpRsh16Ux64(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (Rsh16Ux64 (Const16 [c]) (Const64 [d]))
	// result: (Const16 [int16(uint16(c) >> uint64(d))])
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(int16(uint16(c) >> uint64(d)))
		return true
	}
	// match: (Rsh16Ux64 x (Const64 [0]))
	// result: x
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (Rsh16Ux64 (Const16 [0]) _)
	// result: (Const16 [0])
	for {
		if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(0)
		return true
	}
	// match: (Rsh16Ux64 _ (Const64 [c]))
	// cond: uint64(c) >= 16
	// result: (Const16 [0])
	for {
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(uint64(c) >= 16) {
			break
		}
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(0)
		return true
	}
	// match: (Rsh16Ux64 <t> (Rsh16Ux64 x (Const64 [c])) (Const64 [d]))
	// cond: !uaddOvf(c,d)
	// result: (Rsh16Ux64 x (Const64 <t> [c+d]))
	for {
		t := v.Type
		if v_0.Op != ssaop.OpRsh16Ux64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(!uaddOvf(c, d)) {
			break
		}
		v.Reset(ssaop.OpRsh16Ux64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(c + d)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh16Ux64 (Rsh16x64 x _) (Const64 <t> [15]))
	// result: (Rsh16Ux64 x (Const64 <t> [15]))
	for {
		if v_0.Op != ssaop.OpRsh16x64 {
			break
		}
		x := v_0.Args[0]
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		t := v_1.Type
		if ssa.AuxIntToInt64(v_1.AuxInt) != 15 {
			break
		}
		v.Reset(ssaop.OpRsh16Ux64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(15)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh16Ux64 i:(Lsh16x64 x (Const64 [c])) (Const64 [c]))
	// cond: c >= 0 && c < 16 && i.Uses == 1
	// result: (And16 x (Const16 <v.Type> [int16(^uint16(0)>>c)]))
	for {
		i := v_0
		if i.Op != ssaop.OpLsh16x64 {
			break
		}
		_ = i.Args[1]
		x := i.Args[0]
		i_1 := i.Args[1]
		if i_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(i_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != c || !(c >= 0 && c < 16 && i.Uses == 1) {
			break
		}
		v.Reset(ssaop.OpAnd16)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst16, v.Type)
		v0.AuxInt = ssa.Int16ToAuxInt(int16(^uint16(0) >> c))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh16Ux64 (Lsh16x64 (Rsh16Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
	// cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
	// result: (Rsh16Ux64 x (Const64 <typ.UInt64> [c1-c2+c3]))
	for {
		if v_0.Op != ssaop.OpLsh16x64 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpRsh16Ux64 {
			break
		}
		_ = v_0_0.Args[1]
		x := v_0_0.Args[0]
		v_0_0_1 := v_0_0.Args[1]
		if v_0_0_1.Op != ssaop.OpConst64 {
			break
		}
		c1 := ssa.AuxIntToInt64(v_0_0_1.AuxInt)
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 {
			break
		}
		c2 := ssa.AuxIntToInt64(v_0_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		c3 := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) {
			break
		}
		v.Reset(ssaop.OpRsh16Ux64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64)
		v0.AuxInt = ssa.Int64ToAuxInt(c1 - c2 + c3)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh16Ux64 (Lsh16x64 x (Const64 [8])) (Const64 [8]))
	// result: (ZeroExt8to16 (Trunc16to8 <typ.UInt8> x))
	for {
		if v_0.Op != ssaop.OpLsh16x64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 8 || v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 8 {
			break
		}
		v.Reset(ssaop.OpZeroExt8to16)
		v0 := b.NewValue0(v.Pos, ssaop.OpTrunc16to8, typ.UInt8)
		v0.AddArg(x)
		v.AddArg(v0)
		return true
	}
	// match: (Rsh16Ux64 [false] x con:(Const64 [c]))
	// cond: 0 < c && c < 16
	// result: (Rsh16Ux64 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(con.AuxInt)
		if !(0 < c && c < 16) {
			break
		}
		v.Reset(ssaop.OpRsh16Ux64)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpRsh16Ux8(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Rsh16Ux8 x (Const8 [c]))
	// result: (Rsh16Ux64 x (Const64 <types.Types[types.TUINT64]> [int64(uint8(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_1.AuxInt)
		v.Reset(ssaop.OpRsh16Ux64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint8(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh16Ux8 (Const16 [0]) _)
	// result: (Const16 [0])
	for {
		if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(0)
		return true
	}
	// match: (Rsh16Ux8 [false] x con:(Const8 [c]))
	// cond: 0 < c && c < 16
	// result: (Rsh16Ux8 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(con.AuxInt)
		if !(0 < c && c < 16) {
			break
		}
		v.Reset(ssaop.OpRsh16Ux8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpRsh16x16(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Rsh16x16 x (Const16 [c]))
	// result: (Rsh16x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint16(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_1.AuxInt)
		v.Reset(ssaop.OpRsh16x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint16(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh16x16 (Const16 [0]) _)
	// result: (Const16 [0])
	for {
		if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(0)
		return true
	}
	// match: (Rsh16x16 [false] x con:(Const16 [c]))
	// cond: 0 < c && c < 16
	// result: (Rsh16x16 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(con.AuxInt)
		if !(0 < c && c < 16) {
			break
		}
		v.Reset(ssaop.OpRsh16x16)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpRsh16x32(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Rsh16x32 x (Const32 [c]))
	// result: (Rsh16x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint32(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_1.AuxInt)
		v.Reset(ssaop.OpRsh16x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint32(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh16x32 (Const16 [0]) _)
	// result: (Const16 [0])
	for {
		if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(0)
		return true
	}
	// match: (Rsh16x32 [false] x con:(Const32 [c]))
	// cond: 0 < c && c < 16
	// result: (Rsh16x32 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(con.AuxInt)
		if !(0 < c && c < 16) {
			break
		}
		v.Reset(ssaop.OpRsh16x32)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpRsh16x64(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (Rsh16x64 (Const16 [c]) (Const64 [d]))
	// result: (Const16 [c >> uint64(d)])
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(c >> uint64(d))
		return true
	}
	// match: (Rsh16x64 x (Const64 [0]))
	// result: x
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (Rsh16x64 (Const16 [0]) _)
	// result: (Const16 [0])
	for {
		if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(0)
		return true
	}
	// match: (Rsh16x64 <t> (Rsh16x64 x (Const64 [c])) (Const64 [d]))
	// cond: !uaddOvf(c,d)
	// result: (Rsh16x64 x (Const64 <t> [c+d]))
	for {
		t := v.Type
		if v_0.Op != ssaop.OpRsh16x64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(!uaddOvf(c, d)) {
			break
		}
		v.Reset(ssaop.OpRsh16x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(c + d)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh16x64 (Lsh16x64 x (Const64 [8])) (Const64 [8]))
	// result: (SignExt8to16 (Trunc16to8 <typ.Int8> x))
	for {
		if v_0.Op != ssaop.OpLsh16x64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 8 || v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 8 {
			break
		}
		v.Reset(ssaop.OpSignExt8to16)
		v0 := b.NewValue0(v.Pos, ssaop.OpTrunc16to8, typ.Int8)
		v0.AddArg(x)
		v.AddArg(v0)
		return true
	}
	// match: (Rsh16x64 [false] x con:(Const64 [c]))
	// cond: 0 < c && c < 16
	// result: (Rsh16x64 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(con.AuxInt)
		if !(0 < c && c < 16) {
			break
		}
		v.Reset(ssaop.OpRsh16x64)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpRsh16x8(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Rsh16x8 x (Const8 [c]))
	// result: (Rsh16x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint8(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_1.AuxInt)
		v.Reset(ssaop.OpRsh16x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint8(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh16x8 (Const16 [0]) _)
	// result: (Const16 [0])
	for {
		if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(0)
		return true
	}
	// match: (Rsh16x8 [false] x con:(Const8 [c]))
	// cond: 0 < c && c < 16
	// result: (Rsh16x8 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(con.AuxInt)
		if !(0 < c && c < 16) {
			break
		}
		v.Reset(ssaop.OpRsh16x8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpRsh32Ux16(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Rsh32Ux16 x (Const16 [c]))
	// result: (Rsh32Ux64 x (Const64 <types.Types[types.TUINT64]> [int64(uint16(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_1.AuxInt)
		v.Reset(ssaop.OpRsh32Ux64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint16(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh32Ux16 (Const32 [0]) _)
	// result: (Const32 [0])
	for {
		if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(0)
		return true
	}
	// match: (Rsh32Ux16 [false] x con:(Const16 [c]))
	// cond: 0 < c && c < 32
	// result: (Rsh32Ux16 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(con.AuxInt)
		if !(0 < c && c < 32) {
			break
		}
		v.Reset(ssaop.OpRsh32Ux16)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpRsh32Ux32(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Rsh32Ux32 x (Const32 [c]))
	// result: (Rsh32Ux64 x (Const64 <types.Types[types.TUINT64]> [int64(uint32(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_1.AuxInt)
		v.Reset(ssaop.OpRsh32Ux64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint32(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh32Ux32 (Const32 [0]) _)
	// result: (Const32 [0])
	for {
		if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(0)
		return true
	}
	// match: (Rsh32Ux32 [false] x con:(Const32 [c]))
	// cond: 0 < c && c < 32
	// result: (Rsh32Ux32 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(con.AuxInt)
		if !(0 < c && c < 32) {
			break
		}
		v.Reset(ssaop.OpRsh32Ux32)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpRsh32Ux64(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (Rsh32Ux64 (Const32 [c]) (Const64 [d]))
	// result: (Const32 [int32(uint32(c) >> uint64(d))])
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(int32(uint32(c) >> uint64(d)))
		return true
	}
	// match: (Rsh32Ux64 x (Const64 [0]))
	// result: x
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (Rsh32Ux64 (Const32 [0]) _)
	// result: (Const32 [0])
	for {
		if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(0)
		return true
	}
	// match: (Rsh32Ux64 _ (Const64 [c]))
	// cond: uint64(c) >= 32
	// result: (Const32 [0])
	for {
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(uint64(c) >= 32) {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(0)
		return true
	}
	// match: (Rsh32Ux64 <t> (Rsh32Ux64 x (Const64 [c])) (Const64 [d]))
	// cond: !uaddOvf(c,d)
	// result: (Rsh32Ux64 x (Const64 <t> [c+d]))
	for {
		t := v.Type
		if v_0.Op != ssaop.OpRsh32Ux64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(!uaddOvf(c, d)) {
			break
		}
		v.Reset(ssaop.OpRsh32Ux64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(c + d)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh32Ux64 (Rsh32x64 x _) (Const64 <t> [31]))
	// result: (Rsh32Ux64 x (Const64 <t> [31]))
	for {
		if v_0.Op != ssaop.OpRsh32x64 {
			break
		}
		x := v_0.Args[0]
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		t := v_1.Type
		if ssa.AuxIntToInt64(v_1.AuxInt) != 31 {
			break
		}
		v.Reset(ssaop.OpRsh32Ux64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(31)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh32Ux64 i:(Lsh32x64 x (Const64 [c])) (Const64 [c]))
	// cond: c >= 0 && c < 32 && i.Uses == 1
	// result: (And32 x (Const32 <v.Type> [int32(^uint32(0)>>c)]))
	for {
		i := v_0
		if i.Op != ssaop.OpLsh32x64 {
			break
		}
		_ = i.Args[1]
		x := i.Args[0]
		i_1 := i.Args[1]
		if i_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(i_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != c || !(c >= 0 && c < 32 && i.Uses == 1) {
			break
		}
		v.Reset(ssaop.OpAnd32)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst32, v.Type)
		v0.AuxInt = ssa.Int32ToAuxInt(int32(^uint32(0) >> c))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh32Ux64 (Lsh32x64 (Rsh32Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
	// cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
	// result: (Rsh32Ux64 x (Const64 <typ.UInt64> [c1-c2+c3]))
	for {
		if v_0.Op != ssaop.OpLsh32x64 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpRsh32Ux64 {
			break
		}
		_ = v_0_0.Args[1]
		x := v_0_0.Args[0]
		v_0_0_1 := v_0_0.Args[1]
		if v_0_0_1.Op != ssaop.OpConst64 {
			break
		}
		c1 := ssa.AuxIntToInt64(v_0_0_1.AuxInt)
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 {
			break
		}
		c2 := ssa.AuxIntToInt64(v_0_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		c3 := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) {
			break
		}
		v.Reset(ssaop.OpRsh32Ux64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64)
		v0.AuxInt = ssa.Int64ToAuxInt(c1 - c2 + c3)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh32Ux64 (Lsh32x64 x (Const64 [24])) (Const64 [24]))
	// result: (ZeroExt8to32 (Trunc32to8 <typ.UInt8> x))
	for {
		if v_0.Op != ssaop.OpLsh32x64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 24 || v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 24 {
			break
		}
		v.Reset(ssaop.OpZeroExt8to32)
		v0 := b.NewValue0(v.Pos, ssaop.OpTrunc32to8, typ.UInt8)
		v0.AddArg(x)
		v.AddArg(v0)
		return true
	}
	// match: (Rsh32Ux64 (Lsh32x64 x (Const64 [16])) (Const64 [16]))
	// result: (ZeroExt16to32 (Trunc32to16 <typ.UInt16> x))
	for {
		if v_0.Op != ssaop.OpLsh32x64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 16 || v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 16 {
			break
		}
		v.Reset(ssaop.OpZeroExt16to32)
		v0 := b.NewValue0(v.Pos, ssaop.OpTrunc32to16, typ.UInt16)
		v0.AddArg(x)
		v.AddArg(v0)
		return true
	}
	// match: (Rsh32Ux64 [false] x con:(Const64 [c]))
	// cond: 0 < c && c < 32
	// result: (Rsh32Ux64 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(con.AuxInt)
		if !(0 < c && c < 32) {
			break
		}
		v.Reset(ssaop.OpRsh32Ux64)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpRsh32Ux8(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Rsh32Ux8 x (Const8 [c]))
	// result: (Rsh32Ux64 x (Const64 <types.Types[types.TUINT64]> [int64(uint8(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_1.AuxInt)
		v.Reset(ssaop.OpRsh32Ux64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint8(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh32Ux8 (Const32 [0]) _)
	// result: (Const32 [0])
	for {
		if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(0)
		return true
	}
	// match: (Rsh32Ux8 [false] x con:(Const8 [c]))
	// cond: 0 < c && c < 32
	// result: (Rsh32Ux8 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(con.AuxInt)
		if !(0 < c && c < 32) {
			break
		}
		v.Reset(ssaop.OpRsh32Ux8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpRsh32x16(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Rsh32x16 x (Const16 [c]))
	// result: (Rsh32x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint16(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_1.AuxInt)
		v.Reset(ssaop.OpRsh32x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint16(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh32x16 (Const32 [0]) _)
	// result: (Const32 [0])
	for {
		if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(0)
		return true
	}
	// match: (Rsh32x16 [false] x con:(Const16 [c]))
	// cond: 0 < c && c < 32
	// result: (Rsh32x16 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(con.AuxInt)
		if !(0 < c && c < 32) {
			break
		}
		v.Reset(ssaop.OpRsh32x16)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpRsh32x32(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Rsh32x32 x (Const32 [c]))
	// result: (Rsh32x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint32(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_1.AuxInt)
		v.Reset(ssaop.OpRsh32x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint32(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh32x32 (Const32 [0]) _)
	// result: (Const32 [0])
	for {
		if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(0)
		return true
	}
	// match: (Rsh32x32 [false] x con:(Const32 [c]))
	// cond: 0 < c && c < 32
	// result: (Rsh32x32 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(con.AuxInt)
		if !(0 < c && c < 32) {
			break
		}
		v.Reset(ssaop.OpRsh32x32)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpRsh32x64(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (Rsh32x64 (Const32 [c]) (Const64 [d]))
	// result: (Const32 [c >> uint64(d)])
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(c >> uint64(d))
		return true
	}
	// match: (Rsh32x64 x (Const64 [0]))
	// result: x
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (Rsh32x64 (Const32 [0]) _)
	// result: (Const32 [0])
	for {
		if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(0)
		return true
	}
	// match: (Rsh32x64 <t> (Rsh32x64 x (Const64 [c])) (Const64 [d]))
	// cond: !uaddOvf(c,d)
	// result: (Rsh32x64 x (Const64 <t> [c+d]))
	for {
		t := v.Type
		if v_0.Op != ssaop.OpRsh32x64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(!uaddOvf(c, d)) {
			break
		}
		v.Reset(ssaop.OpRsh32x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(c + d)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh32x64 (Lsh32x64 x (Const64 [24])) (Const64 [24]))
	// result: (SignExt8to32 (Trunc32to8 <typ.Int8> x))
	for {
		if v_0.Op != ssaop.OpLsh32x64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 24 || v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 24 {
			break
		}
		v.Reset(ssaop.OpSignExt8to32)
		v0 := b.NewValue0(v.Pos, ssaop.OpTrunc32to8, typ.Int8)
		v0.AddArg(x)
		v.AddArg(v0)
		return true
	}
	// match: (Rsh32x64 (Lsh32x64 x (Const64 [16])) (Const64 [16]))
	// result: (SignExt16to32 (Trunc32to16 <typ.Int16> x))
	for {
		if v_0.Op != ssaop.OpLsh32x64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 16 || v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 16 {
			break
		}
		v.Reset(ssaop.OpSignExt16to32)
		v0 := b.NewValue0(v.Pos, ssaop.OpTrunc32to16, typ.Int16)
		v0.AddArg(x)
		v.AddArg(v0)
		return true
	}
	// match: (Rsh32x64 [false] x con:(Const64 [c]))
	// cond: 0 < c && c < 32
	// result: (Rsh32x64 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(con.AuxInt)
		if !(0 < c && c < 32) {
			break
		}
		v.Reset(ssaop.OpRsh32x64)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpRsh32x8(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Rsh32x8 x (Const8 [c]))
	// result: (Rsh32x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint8(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_1.AuxInt)
		v.Reset(ssaop.OpRsh32x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint8(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh32x8 (Const32 [0]) _)
	// result: (Const32 [0])
	for {
		if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(0)
		return true
	}
	// match: (Rsh32x8 [false] x con:(Const8 [c]))
	// cond: 0 < c && c < 32
	// result: (Rsh32x8 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(con.AuxInt)
		if !(0 < c && c < 32) {
			break
		}
		v.Reset(ssaop.OpRsh32x8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpRsh64Ux16(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Rsh64Ux16 x (Const16 [c]))
	// result: (Rsh64Ux64 x (Const64 <types.Types[types.TUINT64]> [int64(uint16(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_1.AuxInt)
		v.Reset(ssaop.OpRsh64Ux64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint16(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh64Ux16 (Const64 [0]) _)
	// result: (Const64 [0])
	for {
		if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(0)
		return true
	}
	// match: (Rsh64Ux16 [false] x con:(Const16 [c]))
	// cond: 0 < c && c < 64
	// result: (Rsh64Ux16 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(con.AuxInt)
		if !(0 < c && c < 64) {
			break
		}
		v.Reset(ssaop.OpRsh64Ux16)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpRsh64Ux32(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Rsh64Ux32 x (Const32 [c]))
	// result: (Rsh64Ux64 x (Const64 <types.Types[types.TUINT64]> [int64(uint32(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_1.AuxInt)
		v.Reset(ssaop.OpRsh64Ux64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint32(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh64Ux32 (Const64 [0]) _)
	// result: (Const64 [0])
	for {
		if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(0)
		return true
	}
	// match: (Rsh64Ux32 [false] x con:(Const32 [c]))
	// cond: 0 < c && c < 64
	// result: (Rsh64Ux32 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(con.AuxInt)
		if !(0 < c && c < 64) {
			break
		}
		v.Reset(ssaop.OpRsh64Ux32)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpRsh64Ux64(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (Rsh64Ux64 (Const64 [c]) (Const64 [d]))
	// result: (Const64 [int64(uint64(c) >> uint64(d))])
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(int64(uint64(c) >> uint64(d)))
		return true
	}
	// match: (Rsh64Ux64 x (Const64 [0]))
	// result: x
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (Rsh64Ux64 (Const64 [0]) _)
	// result: (Const64 [0])
	for {
		if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(0)
		return true
	}
	// match: (Rsh64Ux64 _ (Const64 [c]))
	// cond: uint64(c) >= 64
	// result: (Const64 [0])
	for {
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(uint64(c) >= 64) {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(0)
		return true
	}
	// match: (Rsh64Ux64 <t> (Rsh64Ux64 x (Const64 [c])) (Const64 [d]))
	// cond: !uaddOvf(c,d)
	// result: (Rsh64Ux64 x (Const64 <t> [c+d]))
	for {
		t := v.Type
		if v_0.Op != ssaop.OpRsh64Ux64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(!uaddOvf(c, d)) {
			break
		}
		v.Reset(ssaop.OpRsh64Ux64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(c + d)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh64Ux64 (Rsh64x64 x _) (Const64 <t> [63]))
	// result: (Rsh64Ux64 x (Const64 <t> [63]))
	for {
		if v_0.Op != ssaop.OpRsh64x64 {
			break
		}
		x := v_0.Args[0]
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		t := v_1.Type
		if ssa.AuxIntToInt64(v_1.AuxInt) != 63 {
			break
		}
		v.Reset(ssaop.OpRsh64Ux64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(63)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh64Ux64 i:(Lsh64x64 x (Const64 [c])) (Const64 [c]))
	// cond: c >= 0 && c < 64 && i.Uses == 1
	// result: (And64 x (Const64 <v.Type> [int64(^uint64(0)>>c)]))
	for {
		i := v_0
		if i.Op != ssaop.OpLsh64x64 {
			break
		}
		_ = i.Args[1]
		x := i.Args[0]
		i_1 := i.Args[1]
		if i_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(i_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != c || !(c >= 0 && c < 64 && i.Uses == 1) {
			break
		}
		v.Reset(ssaop.OpAnd64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, v.Type)
		v0.AuxInt = ssa.Int64ToAuxInt(int64(^uint64(0) >> c))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh64Ux64 (Lsh64x64 (Rsh64Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
	// cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
	// result: (Rsh64Ux64 x (Const64 <typ.UInt64> [c1-c2+c3]))
	for {
		if v_0.Op != ssaop.OpLsh64x64 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpRsh64Ux64 {
			break
		}
		_ = v_0_0.Args[1]
		x := v_0_0.Args[0]
		v_0_0_1 := v_0_0.Args[1]
		if v_0_0_1.Op != ssaop.OpConst64 {
			break
		}
		c1 := ssa.AuxIntToInt64(v_0_0_1.AuxInt)
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 {
			break
		}
		c2 := ssa.AuxIntToInt64(v_0_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		c3 := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) {
			break
		}
		v.Reset(ssaop.OpRsh64Ux64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64)
		v0.AuxInt = ssa.Int64ToAuxInt(c1 - c2 + c3)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh64Ux64 (Lsh64x64 x (Const64 [56])) (Const64 [56]))
	// result: (ZeroExt8to64 (Trunc64to8 <typ.UInt8> x))
	for {
		if v_0.Op != ssaop.OpLsh64x64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 56 || v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 56 {
			break
		}
		v.Reset(ssaop.OpZeroExt8to64)
		v0 := b.NewValue0(v.Pos, ssaop.OpTrunc64to8, typ.UInt8)
		v0.AddArg(x)
		v.AddArg(v0)
		return true
	}
	// match: (Rsh64Ux64 (Lsh64x64 x (Const64 [48])) (Const64 [48]))
	// result: (ZeroExt16to64 (Trunc64to16 <typ.UInt16> x))
	for {
		if v_0.Op != ssaop.OpLsh64x64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 48 || v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 48 {
			break
		}
		v.Reset(ssaop.OpZeroExt16to64)
		v0 := b.NewValue0(v.Pos, ssaop.OpTrunc64to16, typ.UInt16)
		v0.AddArg(x)
		v.AddArg(v0)
		return true
	}
	// match: (Rsh64Ux64 (Lsh64x64 x (Const64 [32])) (Const64 [32]))
	// result: (ZeroExt32to64 (Trunc64to32 <typ.UInt32> x))
	for {
		if v_0.Op != ssaop.OpLsh64x64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 32 || v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 32 {
			break
		}
		v.Reset(ssaop.OpZeroExt32to64)
		v0 := b.NewValue0(v.Pos, ssaop.OpTrunc64to32, typ.UInt32)
		v0.AddArg(x)
		v.AddArg(v0)
		return true
	}
	// match: (Rsh64Ux64 [false] x con:(Const64 [c]))
	// cond: 0 < c && c < 64
	// result: (Rsh64Ux64 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(con.AuxInt)
		if !(0 < c && c < 64) {
			break
		}
		v.Reset(ssaop.OpRsh64Ux64)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpRsh64Ux8(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Rsh64Ux8 x (Const8 [c]))
	// result: (Rsh64Ux64 x (Const64 <types.Types[types.TUINT64]> [int64(uint8(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_1.AuxInt)
		v.Reset(ssaop.OpRsh64Ux64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint8(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh64Ux8 (Const64 [0]) _)
	// result: (Const64 [0])
	for {
		if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(0)
		return true
	}
	// match: (Rsh64Ux8 [false] x con:(Const8 [c]))
	// cond: 0 < c && c < 64
	// result: (Rsh64Ux8 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(con.AuxInt)
		if !(0 < c && c < 64) {
			break
		}
		v.Reset(ssaop.OpRsh64Ux8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpRsh64x16(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Rsh64x16 x (Const16 [c]))
	// result: (Rsh64x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint16(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_1.AuxInt)
		v.Reset(ssaop.OpRsh64x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint16(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh64x16 (Const64 [0]) _)
	// result: (Const64 [0])
	for {
		if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(0)
		return true
	}
	// match: (Rsh64x16 [false] x con:(Const16 [c]))
	// cond: 0 < c && c < 64
	// result: (Rsh64x16 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(con.AuxInt)
		if !(0 < c && c < 64) {
			break
		}
		v.Reset(ssaop.OpRsh64x16)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpRsh64x32(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Rsh64x32 x (Const32 [c]))
	// result: (Rsh64x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint32(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_1.AuxInt)
		v.Reset(ssaop.OpRsh64x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint32(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh64x32 (Const64 [0]) _)
	// result: (Const64 [0])
	for {
		if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(0)
		return true
	}
	// match: (Rsh64x32 [false] x con:(Const32 [c]))
	// cond: 0 < c && c < 64
	// result: (Rsh64x32 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(con.AuxInt)
		if !(0 < c && c < 64) {
			break
		}
		v.Reset(ssaop.OpRsh64x32)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpRsh64x64(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (Rsh64x64 (Const64 [c]) (Const64 [d]))
	// result: (Const64 [c >> uint64(d)])
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(c >> uint64(d))
		return true
	}
	// match: (Rsh64x64 x (Const64 [0]))
	// result: x
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (Rsh64x64 (Const64 [0]) _)
	// result: (Const64 [0])
	for {
		if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(0)
		return true
	}
	// match: (Rsh64x64 <t> (Rsh64x64 x (Const64 [c])) (Const64 [d]))
	// cond: !uaddOvf(c,d)
	// result: (Rsh64x64 x (Const64 <t> [c+d]))
	for {
		t := v.Type
		if v_0.Op != ssaop.OpRsh64x64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(!uaddOvf(c, d)) {
			break
		}
		v.Reset(ssaop.OpRsh64x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(c + d)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh64x64 (Lsh64x64 x (Const64 [56])) (Const64 [56]))
	// result: (SignExt8to64 (Trunc64to8 <typ.Int8> x))
	for {
		if v_0.Op != ssaop.OpLsh64x64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 56 || v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 56 {
			break
		}
		v.Reset(ssaop.OpSignExt8to64)
		v0 := b.NewValue0(v.Pos, ssaop.OpTrunc64to8, typ.Int8)
		v0.AddArg(x)
		v.AddArg(v0)
		return true
	}
	// match: (Rsh64x64 (Lsh64x64 x (Const64 [48])) (Const64 [48]))
	// result: (SignExt16to64 (Trunc64to16 <typ.Int16> x))
	for {
		if v_0.Op != ssaop.OpLsh64x64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 48 || v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 48 {
			break
		}
		v.Reset(ssaop.OpSignExt16to64)
		v0 := b.NewValue0(v.Pos, ssaop.OpTrunc64to16, typ.Int16)
		v0.AddArg(x)
		v.AddArg(v0)
		return true
	}
	// match: (Rsh64x64 (Lsh64x64 x (Const64 [32])) (Const64 [32]))
	// result: (SignExt32to64 (Trunc64to32 <typ.Int32> x))
	for {
		if v_0.Op != ssaop.OpLsh64x64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 32 || v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 32 {
			break
		}
		v.Reset(ssaop.OpSignExt32to64)
		v0 := b.NewValue0(v.Pos, ssaop.OpTrunc64to32, typ.Int32)
		v0.AddArg(x)
		v.AddArg(v0)
		return true
	}
	// match: (Rsh64x64 [false] x con:(Const64 [c]))
	// cond: 0 < c && c < 64
	// result: (Rsh64x64 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(con.AuxInt)
		if !(0 < c && c < 64) {
			break
		}
		v.Reset(ssaop.OpRsh64x64)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpRsh64x8(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Rsh64x8 x (Const8 [c]))
	// result: (Rsh64x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint8(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_1.AuxInt)
		v.Reset(ssaop.OpRsh64x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint8(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh64x8 (Const64 [0]) _)
	// result: (Const64 [0])
	for {
		if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(0)
		return true
	}
	// match: (Rsh64x8 [false] x con:(Const8 [c]))
	// cond: 0 < c && c < 64
	// result: (Rsh64x8 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(con.AuxInt)
		if !(0 < c && c < 64) {
			break
		}
		v.Reset(ssaop.OpRsh64x8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpRsh8Ux16(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Rsh8Ux16 x (Const16 [c]))
	// result: (Rsh8Ux64 x (Const64 <types.Types[types.TUINT64]> [int64(uint16(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_1.AuxInt)
		v.Reset(ssaop.OpRsh8Ux64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint16(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh8Ux16 (Const8 [0]) _)
	// result: (Const8 [0])
	for {
		if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(0)
		return true
	}
	// match: (Rsh8Ux16 [false] x con:(Const16 [c]))
	// cond: 0 < c && c < 8
	// result: (Rsh8Ux16 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(con.AuxInt)
		if !(0 < c && c < 8) {
			break
		}
		v.Reset(ssaop.OpRsh8Ux16)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpRsh8Ux32(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Rsh8Ux32 x (Const32 [c]))
	// result: (Rsh8Ux64 x (Const64 <types.Types[types.TUINT64]> [int64(uint32(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_1.AuxInt)
		v.Reset(ssaop.OpRsh8Ux64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint32(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh8Ux32 (Const8 [0]) _)
	// result: (Const8 [0])
	for {
		if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(0)
		return true
	}
	// match: (Rsh8Ux32 [false] x con:(Const32 [c]))
	// cond: 0 < c && c < 8
	// result: (Rsh8Ux32 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(con.AuxInt)
		if !(0 < c && c < 8) {
			break
		}
		v.Reset(ssaop.OpRsh8Ux32)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpRsh8Ux64(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (Rsh8Ux64 (Const8 [c]) (Const64 [d]))
	// result: (Const8 [int8(uint8(c) >> uint64(d))])
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(int8(uint8(c) >> uint64(d)))
		return true
	}
	// match: (Rsh8Ux64 x (Const64 [0]))
	// result: x
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (Rsh8Ux64 (Const8 [0]) _)
	// result: (Const8 [0])
	for {
		if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(0)
		return true
	}
	// match: (Rsh8Ux64 _ (Const64 [c]))
	// cond: uint64(c) >= 8
	// result: (Const8 [0])
	for {
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(uint64(c) >= 8) {
			break
		}
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(0)
		return true
	}
	// match: (Rsh8Ux64 <t> (Rsh8Ux64 x (Const64 [c])) (Const64 [d]))
	// cond: !uaddOvf(c,d)
	// result: (Rsh8Ux64 x (Const64 <t> [c+d]))
	for {
		t := v.Type
		if v_0.Op != ssaop.OpRsh8Ux64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(!uaddOvf(c, d)) {
			break
		}
		v.Reset(ssaop.OpRsh8Ux64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(c + d)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh8Ux64 (Rsh8x64 x _) (Const64 <t> [7] ))
	// result: (Rsh8Ux64 x (Const64 <t> [7] ))
	for {
		if v_0.Op != ssaop.OpRsh8x64 {
			break
		}
		x := v_0.Args[0]
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		t := v_1.Type
		if ssa.AuxIntToInt64(v_1.AuxInt) != 7 {
			break
		}
		v.Reset(ssaop.OpRsh8Ux64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(7)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh8Ux64 i:(Lsh8x64 x (Const64 [c])) (Const64 [c]))
	// cond: c >= 0 && c < 8 && i.Uses == 1
	// result: (And8 x (Const8 <v.Type> [int8 (^uint8 (0)>>c)]))
	for {
		i := v_0
		if i.Op != ssaop.OpLsh8x64 {
			break
		}
		_ = i.Args[1]
		x := i.Args[0]
		i_1 := i.Args[1]
		if i_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(i_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != c || !(c >= 0 && c < 8 && i.Uses == 1) {
			break
		}
		v.Reset(ssaop.OpAnd8)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst8, v.Type)
		v0.AuxInt = ssa.Int8ToAuxInt(int8(^uint8(0) >> c))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh8Ux64 (Lsh8x64 (Rsh8Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
	// cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
	// result: (Rsh8Ux64 x (Const64 <typ.UInt64> [c1-c2+c3]))
	for {
		if v_0.Op != ssaop.OpLsh8x64 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpRsh8Ux64 {
			break
		}
		_ = v_0_0.Args[1]
		x := v_0_0.Args[0]
		v_0_0_1 := v_0_0.Args[1]
		if v_0_0_1.Op != ssaop.OpConst64 {
			break
		}
		c1 := ssa.AuxIntToInt64(v_0_0_1.AuxInt)
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 {
			break
		}
		c2 := ssa.AuxIntToInt64(v_0_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		c3 := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) {
			break
		}
		v.Reset(ssaop.OpRsh8Ux64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64)
		v0.AuxInt = ssa.Int64ToAuxInt(c1 - c2 + c3)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh8Ux64 [false] x con:(Const64 [c]))
	// cond: 0 < c && c < 8
	// result: (Rsh8Ux64 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(con.AuxInt)
		if !(0 < c && c < 8) {
			break
		}
		v.Reset(ssaop.OpRsh8Ux64)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpRsh8Ux8(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Rsh8Ux8 x (Const8 [c]))
	// result: (Rsh8Ux64 x (Const64 <types.Types[types.TUINT64]> [int64(uint8(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_1.AuxInt)
		v.Reset(ssaop.OpRsh8Ux64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint8(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh8Ux8 (Const8 [0]) _)
	// result: (Const8 [0])
	for {
		if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(0)
		return true
	}
	// match: (Rsh8Ux8 [false] x con:(Const8 [c]))
	// cond: 0 < c && c < 8
	// result: (Rsh8Ux8 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(con.AuxInt)
		if !(0 < c && c < 8) {
			break
		}
		v.Reset(ssaop.OpRsh8Ux8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpRsh8x16(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Rsh8x16 x (Const16 [c]))
	// result: (Rsh8x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint16(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_1.AuxInt)
		v.Reset(ssaop.OpRsh8x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint16(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh8x16 (Const8 [0]) _)
	// result: (Const8 [0])
	for {
		if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(0)
		return true
	}
	// match: (Rsh8x16 [false] x con:(Const16 [c]))
	// cond: 0 < c && c < 8
	// result: (Rsh8x16 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(con.AuxInt)
		if !(0 < c && c < 8) {
			break
		}
		v.Reset(ssaop.OpRsh8x16)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpRsh8x32(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Rsh8x32 x (Const32 [c]))
	// result: (Rsh8x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint32(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_1.AuxInt)
		v.Reset(ssaop.OpRsh8x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint32(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh8x32 (Const8 [0]) _)
	// result: (Const8 [0])
	for {
		if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(0)
		return true
	}
	// match: (Rsh8x32 [false] x con:(Const32 [c]))
	// cond: 0 < c && c < 8
	// result: (Rsh8x32 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(con.AuxInt)
		if !(0 < c && c < 8) {
			break
		}
		v.Reset(ssaop.OpRsh8x32)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpRsh8x64(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Rsh8x64 (Const8 [c]) (Const64 [d]))
	// result: (Const8 [c >> uint64(d)])
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(c >> uint64(d))
		return true
	}
	// match: (Rsh8x64 x (Const64 [0]))
	// result: x
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (Rsh8x64 (Const8 [0]) _)
	// result: (Const8 [0])
	for {
		if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(0)
		return true
	}
	// match: (Rsh8x64 <t> (Rsh8x64 x (Const64 [c])) (Const64 [d]))
	// cond: !uaddOvf(c,d)
	// result: (Rsh8x64 x (Const64 <t> [c+d]))
	for {
		t := v.Type
		if v_0.Op != ssaop.OpRsh8x64 {
			break
		}
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0_1.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(!uaddOvf(c, d)) {
			break
		}
		v.Reset(ssaop.OpRsh8x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(c + d)
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh8x64 [false] x con:(Const64 [c]))
	// cond: 0 < c && c < 8
	// result: (Rsh8x64 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(con.AuxInt)
		if !(0 < c && c < 8) {
			break
		}
		v.Reset(ssaop.OpRsh8x64)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpRsh8x8(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Rsh8x8 x (Const8 [c]))
	// result: (Rsh8x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint8(c))]))
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_1.AuxInt)
		v.Reset(ssaop.OpRsh8x64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64])
		v0.AuxInt = ssa.Int64ToAuxInt(int64(uint8(c)))
		v.AddArg2(x, v0)
		return true
	}
	// match: (Rsh8x8 (Const8 [0]) _)
	// result: (Const8 [0])
	for {
		if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(0)
		return true
	}
	// match: (Rsh8x8 [false] x con:(Const8 [c]))
	// cond: 0 < c && c < 8
	// result: (Rsh8x8 [true] x con)
	for {
		if ssa.AuxIntToBool(v.AuxInt) != false {
			break
		}
		x := v_0
		con := v_1
		if con.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(con.AuxInt)
		if !(0 < c && c < 8) {
			break
		}
		v.Reset(ssaop.OpRsh8x8)
		v.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(x, con)
		return true
	}
	return false
}
func rewriteValue_OpSelect0(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (Select0 a:(Add64carry x y (Const64 [0])))
	// cond: a.Uses == 1
	// result: (Add64 x y)
	for {
		a := v_0
		if a.Op != ssaop.OpAdd64carry {
			break
		}
		_ = a.Args[2]
		x := a.Args[0]
		y := a.Args[1]
		a_2 := a.Args[2]
		if a_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(a_2.AuxInt) != 0 || !(a.Uses == 1) {
			break
		}
		v.Reset(ssaop.OpAdd64)
		v.AddArg2(x, y)
		return true
	}
	// match: (Select0 (MakeTuple x y))
	// result: x
	for {
		if v_0.Op != ssaop.OpMakeTuple {
			break
		}
		x := v_0.Args[0]
		v.CopyOf(x)
		return true
	}
	return false
}
func rewriteValue_OpSelect1(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (Select1 (MakeTuple x y))
	// result: y
	for {
		if v_0.Op != ssaop.OpMakeTuple {
			break
		}
		y := v_0.Args[1]
		v.CopyOf(y)
		return true
	}
	return false
}
func rewriteValue_OpSelectN(v *ssa.Value) bool {
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	typ := &b.Func.Config.Types
	// match: (SelectN [n] m:(MakeResult ___))
	// result: m.Args[n]
	for {
		n := ssa.AuxIntToInt64(v.AuxInt)
		m := v_0
		if m.Op != ssaop.OpMakeResult {
			break
		}
		v.CopyOf(m.Args[n])
		return true
	}
	// match: (SelectN [0] call:(StaticCall {sym} sptr (Const64 [c]) mem))
	// cond: isInlinableMemclr(config, int64(c)) && ssa.IsSameCall(sym, "runtime.memclrNoHeapPointers") && call.Uses == 1 && ssa.Clobber(call)
	// result: (Zero {types.Types[types.TUINT8]} [int64(c)] sptr mem)
	for {
		if ssa.AuxIntToInt64(v.AuxInt) != 0 {
			break
		}
		call := v_0
		if call.Op != ssaop.OpStaticCall || len(call.Args) != 3 {
			break
		}
		sym := ssa.AuxToCall(call.Aux)
		mem := call.Args[2]
		sptr := call.Args[0]
		call_1 := call.Args[1]
		if call_1.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(call_1.AuxInt)
		if !(isInlinableMemclr(config, int64(c)) && ssa.IsSameCall(sym, "runtime.memclrNoHeapPointers") && call.Uses == 1 && ssa.Clobber(call)) {
			break
		}
		v.Reset(ssaop.OpZero)
		v.AuxInt = ssa.Int64ToAuxInt(int64(c))
		v.Aux = ssa.TypeToAux(types.Types[types.TUINT8])
		v.AddArg2(sptr, mem)
		return true
	}
	// match: (SelectN [0] call:(StaticCall {sym} sptr (Const32 [c]) mem))
	// cond: isInlinableMemclr(config, int64(c)) && ssa.IsSameCall(sym, "runtime.memclrNoHeapPointers") && call.Uses == 1 && ssa.Clobber(call)
	// result: (Zero {types.Types[types.TUINT8]} [int64(c)] sptr mem)
	for {
		if ssa.AuxIntToInt64(v.AuxInt) != 0 {
			break
		}
		call := v_0
		if call.Op != ssaop.OpStaticCall || len(call.Args) != 3 {
			break
		}
		sym := ssa.AuxToCall(call.Aux)
		mem := call.Args[2]
		sptr := call.Args[0]
		call_1 := call.Args[1]
		if call_1.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(call_1.AuxInt)
		if !(isInlinableMemclr(config, int64(c)) && ssa.IsSameCall(sym, "runtime.memclrNoHeapPointers") && call.Uses == 1 && ssa.Clobber(call)) {
			break
		}
		v.Reset(ssaop.OpZero)
		v.AuxInt = ssa.Int64ToAuxInt(int64(c))
		v.Aux = ssa.TypeToAux(types.Types[types.TUINT8])
		v.AddArg2(sptr, mem)
		return true
	}
	// match: (SelectN [0] call:(StaticCall {sym} s1:(Store _ (Const64 [sz]) s2:(Store _ src s3:(Store {t} _ dst mem)))))
	// cond: sz >= 0 && ssa.IsSameCall(sym, "runtime.memmove") && s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1 && ssa.IsInlinableMemmove(dst, src, int64(sz), config) && ssa.Clobber(s1, s2, s3, call)
	// result: (Move {types.Types[types.TUINT8]} [int64(sz)] dst src mem)
	for {
		if ssa.AuxIntToInt64(v.AuxInt) != 0 {
			break
		}
		call := v_0
		if call.Op != ssaop.OpStaticCall || len(call.Args) != 1 {
			break
		}
		sym := ssa.AuxToCall(call.Aux)
		s1 := call.Args[0]
		if s1.Op != ssaop.OpStore {
			break
		}
		_ = s1.Args[2]
		s1_1 := s1.Args[1]
		if s1_1.Op != ssaop.OpConst64 {
			break
		}
		sz := ssa.AuxIntToInt64(s1_1.AuxInt)
		s2 := s1.Args[2]
		if s2.Op != ssaop.OpStore {
			break
		}
		_ = s2.Args[2]
		src := s2.Args[1]
		s3 := s2.Args[2]
		if s3.Op != ssaop.OpStore {
			break
		}
		mem := s3.Args[2]
		dst := s3.Args[1]
		if !(sz >= 0 && ssa.IsSameCall(sym, "runtime.memmove") && s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1 && ssa.IsInlinableMemmove(dst, src, int64(sz), config) && ssa.Clobber(s1, s2, s3, call)) {
			break
		}
		v.Reset(ssaop.OpMove)
		v.AuxInt = ssa.Int64ToAuxInt(int64(sz))
		v.Aux = ssa.TypeToAux(types.Types[types.TUINT8])
		v.AddArg3(dst, src, mem)
		return true
	}
	// match: (SelectN [0] call:(StaticCall {sym} s1:(Store _ (Const32 [sz]) s2:(Store _ src s3:(Store {t} _ dst mem)))))
	// cond: sz >= 0 && ssa.IsSameCall(sym, "runtime.memmove") && s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1 && ssa.IsInlinableMemmove(dst, src, int64(sz), config) && ssa.Clobber(s1, s2, s3, call)
	// result: (Move {types.Types[types.TUINT8]} [int64(sz)] dst src mem)
	for {
		if ssa.AuxIntToInt64(v.AuxInt) != 0 {
			break
		}
		call := v_0
		if call.Op != ssaop.OpStaticCall || len(call.Args) != 1 {
			break
		}
		sym := ssa.AuxToCall(call.Aux)
		s1 := call.Args[0]
		if s1.Op != ssaop.OpStore {
			break
		}
		_ = s1.Args[2]
		s1_1 := s1.Args[1]
		if s1_1.Op != ssaop.OpConst32 {
			break
		}
		sz := ssa.AuxIntToInt32(s1_1.AuxInt)
		s2 := s1.Args[2]
		if s2.Op != ssaop.OpStore {
			break
		}
		_ = s2.Args[2]
		src := s2.Args[1]
		s3 := s2.Args[2]
		if s3.Op != ssaop.OpStore {
			break
		}
		mem := s3.Args[2]
		dst := s3.Args[1]
		if !(sz >= 0 && ssa.IsSameCall(sym, "runtime.memmove") && s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1 && ssa.IsInlinableMemmove(dst, src, int64(sz), config) && ssa.Clobber(s1, s2, s3, call)) {
			break
		}
		v.Reset(ssaop.OpMove)
		v.AuxInt = ssa.Int64ToAuxInt(int64(sz))
		v.Aux = ssa.TypeToAux(types.Types[types.TUINT8])
		v.AddArg3(dst, src, mem)
		return true
	}
	// match: (SelectN [0] call:(StaticCall {sym} dst src (Const64 [sz]) mem))
	// cond: sz >= 0 && call.Uses == 1 && ssa.IsSameCall(sym, "runtime.memmove") && ssa.IsInlinableMemmove(dst, src, int64(sz), config) && ssa.Clobber(call)
	// result: (Move {types.Types[types.TUINT8]} [int64(sz)] dst src mem)
	for {
		if ssa.AuxIntToInt64(v.AuxInt) != 0 {
			break
		}
		call := v_0
		if call.Op != ssaop.OpStaticCall || len(call.Args) != 4 {
			break
		}
		sym := ssa.AuxToCall(call.Aux)
		mem := call.Args[3]
		dst := call.Args[0]
		src := call.Args[1]
		call_2 := call.Args[2]
		if call_2.Op != ssaop.OpConst64 {
			break
		}
		sz := ssa.AuxIntToInt64(call_2.AuxInt)
		if !(sz >= 0 && call.Uses == 1 && ssa.IsSameCall(sym, "runtime.memmove") && ssa.IsInlinableMemmove(dst, src, int64(sz), config) && ssa.Clobber(call)) {
			break
		}
		v.Reset(ssaop.OpMove)
		v.AuxInt = ssa.Int64ToAuxInt(int64(sz))
		v.Aux = ssa.TypeToAux(types.Types[types.TUINT8])
		v.AddArg3(dst, src, mem)
		return true
	}
	// match: (SelectN [0] call:(StaticCall {sym} dst src (Const32 [sz]) mem))
	// cond: sz >= 0 && call.Uses == 1 && ssa.IsSameCall(sym, "runtime.memmove") && ssa.IsInlinableMemmove(dst, src, int64(sz), config) && ssa.Clobber(call)
	// result: (Move {types.Types[types.TUINT8]} [int64(sz)] dst src mem)
	for {
		if ssa.AuxIntToInt64(v.AuxInt) != 0 {
			break
		}
		call := v_0
		if call.Op != ssaop.OpStaticCall || len(call.Args) != 4 {
			break
		}
		sym := ssa.AuxToCall(call.Aux)
		mem := call.Args[3]
		dst := call.Args[0]
		src := call.Args[1]
		call_2 := call.Args[2]
		if call_2.Op != ssaop.OpConst32 {
			break
		}
		sz := ssa.AuxIntToInt32(call_2.AuxInt)
		if !(sz >= 0 && call.Uses == 1 && ssa.IsSameCall(sym, "runtime.memmove") && ssa.IsInlinableMemmove(dst, src, int64(sz), config) && ssa.Clobber(call)) {
			break
		}
		v.Reset(ssaop.OpMove)
		v.AuxInt = ssa.Int64ToAuxInt(int64(sz))
		v.Aux = ssa.TypeToAux(types.Types[types.TUINT8])
		v.AddArg3(dst, src, mem)
		return true
	}
	// match: (SelectN [0] call:(StaticLECall {sym} dst src (Const64 [sz]) mem))
	// cond: sz >= 0 && call.Uses == 1 && ssa.IsSameCall(sym, "runtime.memmove") && ssa.IsInlinableMemmove(dst, src, int64(sz), config) && ssa.Clobber(call)
	// result: (Move {types.Types[types.TUINT8]} [int64(sz)] dst src mem)
	for {
		if ssa.AuxIntToInt64(v.AuxInt) != 0 {
			break
		}
		call := v_0
		if call.Op != ssaop.OpStaticLECall || len(call.Args) != 4 {
			break
		}
		sym := ssa.AuxToCall(call.Aux)
		mem := call.Args[3]
		dst := call.Args[0]
		src := call.Args[1]
		call_2 := call.Args[2]
		if call_2.Op != ssaop.OpConst64 {
			break
		}
		sz := ssa.AuxIntToInt64(call_2.AuxInt)
		if !(sz >= 0 && call.Uses == 1 && ssa.IsSameCall(sym, "runtime.memmove") && ssa.IsInlinableMemmove(dst, src, int64(sz), config) && ssa.Clobber(call)) {
			break
		}
		v.Reset(ssaop.OpMove)
		v.AuxInt = ssa.Int64ToAuxInt(int64(sz))
		v.Aux = ssa.TypeToAux(types.Types[types.TUINT8])
		v.AddArg3(dst, src, mem)
		return true
	}
	// match: (SelectN [0] call:(StaticLECall {sym} dst src (Const32 [sz]) mem))
	// cond: sz >= 0 && call.Uses == 1 && ssa.IsSameCall(sym, "runtime.memmove") && ssa.IsInlinableMemmove(dst, src, int64(sz), config) && ssa.Clobber(call)
	// result: (Move {types.Types[types.TUINT8]} [int64(sz)] dst src mem)
	for {
		if ssa.AuxIntToInt64(v.AuxInt) != 0 {
			break
		}
		call := v_0
		if call.Op != ssaop.OpStaticLECall || len(call.Args) != 4 {
			break
		}
		sym := ssa.AuxToCall(call.Aux)
		mem := call.Args[3]
		dst := call.Args[0]
		src := call.Args[1]
		call_2 := call.Args[2]
		if call_2.Op != ssaop.OpConst32 {
			break
		}
		sz := ssa.AuxIntToInt32(call_2.AuxInt)
		if !(sz >= 0 && call.Uses == 1 && ssa.IsSameCall(sym, "runtime.memmove") && ssa.IsInlinableMemmove(dst, src, int64(sz), config) && ssa.Clobber(call)) {
			break
		}
		v.Reset(ssaop.OpMove)
		v.AuxInt = ssa.Int64ToAuxInt(int64(sz))
		v.Aux = ssa.TypeToAux(types.Types[types.TUINT8])
		v.AddArg3(dst, src, mem)
		return true
	}
	// match: (SelectN [0] call:(StaticLECall {sym} a x))
	// cond: needRaceCleanup(sym, call) && ssa.Clobber(call)
	// result: x
	for {
		if ssa.AuxIntToInt64(v.AuxInt) != 0 {
			break
		}
		call := v_0
		if call.Op != ssaop.OpStaticLECall || len(call.Args) != 2 {
			break
		}
		sym := ssa.AuxToCall(call.Aux)
		x := call.Args[1]
		if !(needRaceCleanup(sym, call) && ssa.Clobber(call)) {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (SelectN [0] call:(StaticLECall {sym} x))
	// cond: needRaceCleanup(sym, call) && ssa.Clobber(call)
	// result: x
	for {
		if ssa.AuxIntToInt64(v.AuxInt) != 0 {
			break
		}
		call := v_0
		if call.Op != ssaop.OpStaticLECall || len(call.Args) != 1 {
			break
		}
		sym := ssa.AuxToCall(call.Aux)
		x := call.Args[0]
		if !(needRaceCleanup(sym, call) && ssa.Clobber(call)) {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (SelectN [1] (StaticCall {sym} _ newLen:(Const64) _ _ _ _))
	// cond: v.Type.IsInteger() && (ssa.IsSameCall(sym, "runtime.growslice") || ssa.IsSameCall(sym, "runtime.growsliceNoAlias"))
	// result: newLen
	for {
		if ssa.AuxIntToInt64(v.AuxInt) != 1 || v_0.Op != ssaop.OpStaticCall || len(v_0.Args) != 6 {
			break
		}
		sym := ssa.AuxToCall(v_0.Aux)
		_ = v_0.Args[1]
		newLen := v_0.Args[1]
		if newLen.Op != ssaop.OpConst64 || !(v.Type.IsInteger() && (ssa.IsSameCall(sym, "runtime.growslice") || ssa.IsSameCall(sym, "runtime.growsliceNoAlias"))) {
			break
		}
		v.CopyOf(newLen)
		return true
	}
	// match: (SelectN [1] (StaticCall {sym} _ newLen:(Const32) _ _ _ _))
	// cond: v.Type.IsInteger() && (ssa.IsSameCall(sym, "runtime.growslice") || ssa.IsSameCall(sym, "runtime.growsliceNoAlias"))
	// result: newLen
	for {
		if ssa.AuxIntToInt64(v.AuxInt) != 1 || v_0.Op != ssaop.OpStaticCall || len(v_0.Args) != 6 {
			break
		}
		sym := ssa.AuxToCall(v_0.Aux)
		_ = v_0.Args[1]
		newLen := v_0.Args[1]
		if newLen.Op != ssaop.OpConst32 || !(v.Type.IsInteger() && (ssa.IsSameCall(sym, "runtime.growslice") || ssa.IsSameCall(sym, "runtime.growsliceNoAlias"))) {
			break
		}
		v.CopyOf(newLen)
		return true
	}
	// match: (SelectN [0] (StaticLECall {f} x y (SelectN [1] c:(StaticLECall {g} x y mem))))
	// cond: ssa.IsSameCall(f, "runtime.cmpstring") && ssa.IsSameCall(g, "runtime.cmpstring")
	// result: @c.Block (SelectN [0] <typ.Int> c)
	for {
		if ssa.AuxIntToInt64(v.AuxInt) != 0 || v_0.Op != ssaop.OpStaticLECall || len(v_0.Args) != 3 {
			break
		}
		f := ssa.AuxToCall(v_0.Aux)
		_ = v_0.Args[2]
		x := v_0.Args[0]
		y := v_0.Args[1]
		v_0_2 := v_0.Args[2]
		if v_0_2.Op != ssaop.OpSelectN || ssa.AuxIntToInt64(v_0_2.AuxInt) != 1 {
			break
		}
		c := v_0_2.Args[0]
		if c.Op != ssaop.OpStaticLECall || len(c.Args) != 3 {
			break
		}
		g := ssa.AuxToCall(c.Aux)
		if x != c.Args[0] || y != c.Args[1] || !(ssa.IsSameCall(f, "runtime.cmpstring") && ssa.IsSameCall(g, "runtime.cmpstring")) {
			break
		}
		b = c.Block
		v0 := b.NewValue0(v.Pos, ssaop.OpSelectN, typ.Int)
		v.CopyOf(v0)
		v0.AuxInt = ssa.Int64ToAuxInt(0)
		v0.AddArg(c)
		return true
	}
	// match: (SelectN [1] c:(StaticLECall {f} _ _ mem))
	// cond: c.Uses == 1 && ssa.IsSameCall(f, "runtime.cmpstring") && ssa.Clobber(c)
	// result: mem
	for {
		if ssa.AuxIntToInt64(v.AuxInt) != 1 {
			break
		}
		c := v_0
		if c.Op != ssaop.OpStaticLECall || len(c.Args) != 3 {
			break
		}
		f := ssa.AuxToCall(c.Aux)
		mem := c.Args[2]
		if !(c.Uses == 1 && ssa.IsSameCall(f, "runtime.cmpstring") && ssa.Clobber(c)) {
			break
		}
		v.CopyOf(mem)
		return true
	}
	return false
}
func rewriteValue_OpSignExt16to32(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (SignExt16to32 (Const16 [c]))
	// result: (Const32 [int32(c)])
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_0.AuxInt)
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(int32(c))
		return true
	}
	// match: (SignExt16to32 (Trunc32to16 x:(Rsh32x64 _ (Const64 [s]))))
	// cond: s >= 16
	// result: x
	for {
		if v_0.Op != ssaop.OpTrunc32to16 {
			break
		}
		x := v_0.Args[0]
		if x.Op != ssaop.OpRsh32x64 {
			break
		}
		_ = x.Args[1]
		x_1 := x.Args[1]
		if x_1.Op != ssaop.OpConst64 {
			break
		}
		s := ssa.AuxIntToInt64(x_1.AuxInt)
		if !(s >= 16) {
			break
		}
		v.CopyOf(x)
		return true
	}
	return false
}
func rewriteValue_OpSignExt16to64(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (SignExt16to64 (Const16 [c]))
	// result: (Const64 [int64(c)])
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_0.AuxInt)
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(int64(c))
		return true
	}
	// match: (SignExt16to64 (Trunc64to16 x:(Rsh64x64 _ (Const64 [s]))))
	// cond: s >= 48
	// result: x
	for {
		if v_0.Op != ssaop.OpTrunc64to16 {
			break
		}
		x := v_0.Args[0]
		if x.Op != ssaop.OpRsh64x64 {
			break
		}
		_ = x.Args[1]
		x_1 := x.Args[1]
		if x_1.Op != ssaop.OpConst64 {
			break
		}
		s := ssa.AuxIntToInt64(x_1.AuxInt)
		if !(s >= 48) {
			break
		}
		v.CopyOf(x)
		return true
	}
	return false
}
func rewriteValue_OpSignExt32to64(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (SignExt32to64 (Const32 [c]))
	// result: (Const64 [int64(c)])
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_0.AuxInt)
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(int64(c))
		return true
	}
	// match: (SignExt32to64 (Trunc64to32 x:(Rsh64x64 _ (Const64 [s]))))
	// cond: s >= 32
	// result: x
	for {
		if v_0.Op != ssaop.OpTrunc64to32 {
			break
		}
		x := v_0.Args[0]
		if x.Op != ssaop.OpRsh64x64 {
			break
		}
		_ = x.Args[1]
		x_1 := x.Args[1]
		if x_1.Op != ssaop.OpConst64 {
			break
		}
		s := ssa.AuxIntToInt64(x_1.AuxInt)
		if !(s >= 32) {
			break
		}
		v.CopyOf(x)
		return true
	}
	return false
}
func rewriteValue_OpSignExt8to16(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (SignExt8to16 (Const8 [c]))
	// result: (Const16 [int16(c)])
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_0.AuxInt)
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(int16(c))
		return true
	}
	// match: (SignExt8to16 (Trunc16to8 x:(Rsh16x64 _ (Const64 [s]))))
	// cond: s >= 8
	// result: x
	for {
		if v_0.Op != ssaop.OpTrunc16to8 {
			break
		}
		x := v_0.Args[0]
		if x.Op != ssaop.OpRsh16x64 {
			break
		}
		_ = x.Args[1]
		x_1 := x.Args[1]
		if x_1.Op != ssaop.OpConst64 {
			break
		}
		s := ssa.AuxIntToInt64(x_1.AuxInt)
		if !(s >= 8) {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (SignExt8to16 cvt:(CvtBoolToUint8 bool))
	// result: (ZeroExt8to16 cvt)
	for {
		cvt := v_0
		if cvt.Op != ssaop.OpCvtBoolToUint8 {
			break
		}
		v.Reset(ssaop.OpZeroExt8to16)
		v.AddArg(cvt)
		return true
	}
	return false
}
func rewriteValue_OpSignExt8to32(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (SignExt8to32 (Const8 [c]))
	// result: (Const32 [int32(c)])
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_0.AuxInt)
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(int32(c))
		return true
	}
	// match: (SignExt8to32 (Trunc32to8 x:(Rsh32x64 _ (Const64 [s]))))
	// cond: s >= 24
	// result: x
	for {
		if v_0.Op != ssaop.OpTrunc32to8 {
			break
		}
		x := v_0.Args[0]
		if x.Op != ssaop.OpRsh32x64 {
			break
		}
		_ = x.Args[1]
		x_1 := x.Args[1]
		if x_1.Op != ssaop.OpConst64 {
			break
		}
		s := ssa.AuxIntToInt64(x_1.AuxInt)
		if !(s >= 24) {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (SignExt8to32 cvt:(CvtBoolToUint8 bool))
	// result: (ZeroExt8to32 cvt)
	for {
		cvt := v_0
		if cvt.Op != ssaop.OpCvtBoolToUint8 {
			break
		}
		v.Reset(ssaop.OpZeroExt8to32)
		v.AddArg(cvt)
		return true
	}
	return false
}
func rewriteValue_OpSignExt8to64(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (SignExt8to64 (Const8 [c]))
	// result: (Const64 [int64(c)])
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_0.AuxInt)
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(int64(c))
		return true
	}
	// match: (SignExt8to64 (Trunc64to8 x:(Rsh64x64 _ (Const64 [s]))))
	// cond: s >= 56
	// result: x
	for {
		if v_0.Op != ssaop.OpTrunc64to8 {
			break
		}
		x := v_0.Args[0]
		if x.Op != ssaop.OpRsh64x64 {
			break
		}
		_ = x.Args[1]
		x_1 := x.Args[1]
		if x_1.Op != ssaop.OpConst64 {
			break
		}
		s := ssa.AuxIntToInt64(x_1.AuxInt)
		if !(s >= 56) {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (SignExt8to64 cvt:(CvtBoolToUint8 bool))
	// result: (ZeroExt8to64 cvt)
	for {
		cvt := v_0
		if cvt.Op != ssaop.OpCvtBoolToUint8 {
			break
		}
		v.Reset(ssaop.OpZeroExt8to64)
		v.AddArg(cvt)
		return true
	}
	return false
}
func rewriteValue_OpSliceCap(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (SliceCap (SliceMake _ _ (Const64 <t> [c])))
	// result: (Const64 <t> [c])
	for {
		if v_0.Op != ssaop.OpSliceMake {
			break
		}
		_ = v_0.Args[2]
		v_0_2 := v_0.Args[2]
		if v_0_2.Op != ssaop.OpConst64 {
			break
		}
		t := v_0_2.Type
		c := ssa.AuxIntToInt64(v_0_2.AuxInt)
		v.Reset(ssaop.OpConst64)
		v.Type = t
		v.AuxInt = ssa.Int64ToAuxInt(c)
		return true
	}
	// match: (SliceCap (SliceMake _ _ (Const32 <t> [c])))
	// result: (Const32 <t> [c])
	for {
		if v_0.Op != ssaop.OpSliceMake {
			break
		}
		_ = v_0.Args[2]
		v_0_2 := v_0.Args[2]
		if v_0_2.Op != ssaop.OpConst32 {
			break
		}
		t := v_0_2.Type
		c := ssa.AuxIntToInt32(v_0_2.AuxInt)
		v.Reset(ssaop.OpConst32)
		v.Type = t
		v.AuxInt = ssa.Int32ToAuxInt(c)
		return true
	}
	// match: (SliceCap (SliceMake _ _ (SliceCap x)))
	// result: (SliceCap x)
	for {
		if v_0.Op != ssaop.OpSliceMake {
			break
		}
		_ = v_0.Args[2]
		v_0_2 := v_0.Args[2]
		if v_0_2.Op != ssaop.OpSliceCap {
			break
		}
		x := v_0_2.Args[0]
		v.Reset(ssaop.OpSliceCap)
		v.AddArg(x)
		return true
	}
	// match: (SliceCap (SliceMake _ _ (SliceLen x)))
	// result: (SliceLen x)
	for {
		if v_0.Op != ssaop.OpSliceMake {
			break
		}
		_ = v_0.Args[2]
		v_0_2 := v_0.Args[2]
		if v_0_2.Op != ssaop.OpSliceLen {
			break
		}
		x := v_0_2.Args[0]
		v.Reset(ssaop.OpSliceLen)
		v.AddArg(x)
		return true
	}
	// match: (SliceCap (Phi (SliceMake _ _ x) (SliceMake _ _ x)))
	// result: x
	for {
		if v_0.Op != ssaop.OpPhi || len(v_0.Args) != 2 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpSliceMake {
			break
		}
		x := v_0_0.Args[2]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpSliceMake {
			break
		}
		_ = v_0_1.Args[2]
		if x != v_0_1.Args[2] {
			break
		}
		v.CopyOf(x)
		return true
	}
	return false
}
func rewriteValue_OpSliceLen(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (SliceLen (SliceMake _ (Const64 <t> [c]) _))
	// result: (Const64 <t> [c])
	for {
		if v_0.Op != ssaop.OpSliceMake {
			break
		}
		_ = v_0.Args[1]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 {
			break
		}
		t := v_0_1.Type
		c := ssa.AuxIntToInt64(v_0_1.AuxInt)
		v.Reset(ssaop.OpConst64)
		v.Type = t
		v.AuxInt = ssa.Int64ToAuxInt(c)
		return true
	}
	// match: (SliceLen (SliceMake _ (Const32 <t> [c]) _))
	// result: (Const32 <t> [c])
	for {
		if v_0.Op != ssaop.OpSliceMake {
			break
		}
		_ = v_0.Args[1]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst32 {
			break
		}
		t := v_0_1.Type
		c := ssa.AuxIntToInt32(v_0_1.AuxInt)
		v.Reset(ssaop.OpConst32)
		v.Type = t
		v.AuxInt = ssa.Int32ToAuxInt(c)
		return true
	}
	// match: (SliceLen (SliceMake _ (SliceLen x) _))
	// result: (SliceLen x)
	for {
		if v_0.Op != ssaop.OpSliceMake {
			break
		}
		_ = v_0.Args[1]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpSliceLen {
			break
		}
		x := v_0_1.Args[0]
		v.Reset(ssaop.OpSliceLen)
		v.AddArg(x)
		return true
	}
	// match: (SliceLen (Phi (SliceMake _ x _) (SliceMake _ x _)))
	// result: x
	for {
		if v_0.Op != ssaop.OpPhi || len(v_0.Args) != 2 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpSliceMake {
			break
		}
		x := v_0_0.Args[1]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpSliceMake {
			break
		}
		_ = v_0_1.Args[1]
		if x != v_0_1.Args[1] {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (SliceLen (SelectN [0] (StaticLECall {sym} _ newLen:(Const64) _ _ _ _)))
	// cond: (ssa.IsSameCall(sym, "runtime.growslice") || ssa.IsSameCall(sym, "runtime.growsliceNoAlias"))
	// result: newLen
	for {
		if v_0.Op != ssaop.OpSelectN || ssa.AuxIntToInt64(v_0.AuxInt) != 0 {
			break
		}
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpStaticLECall || len(v_0_0.Args) != 6 {
			break
		}
		sym := ssa.AuxToCall(v_0_0.Aux)
		_ = v_0_0.Args[1]
		newLen := v_0_0.Args[1]
		if newLen.Op != ssaop.OpConst64 || !(ssa.IsSameCall(sym, "runtime.growslice") || ssa.IsSameCall(sym, "runtime.growsliceNoAlias")) {
			break
		}
		v.CopyOf(newLen)
		return true
	}
	// match: (SliceLen (SelectN [0] (StaticLECall {sym} _ newLen:(Const32) _ _ _ _)))
	// cond: (ssa.IsSameCall(sym, "runtime.growslice") || ssa.IsSameCall(sym, "runtime.growsliceNoAlias"))
	// result: newLen
	for {
		if v_0.Op != ssaop.OpSelectN || ssa.AuxIntToInt64(v_0.AuxInt) != 0 {
			break
		}
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpStaticLECall || len(v_0_0.Args) != 6 {
			break
		}
		sym := ssa.AuxToCall(v_0_0.Aux)
		_ = v_0_0.Args[1]
		newLen := v_0_0.Args[1]
		if newLen.Op != ssaop.OpConst32 || !(ssa.IsSameCall(sym, "runtime.growslice") || ssa.IsSameCall(sym, "runtime.growsliceNoAlias")) {
			break
		}
		v.CopyOf(newLen)
		return true
	}
	return false
}
func rewriteValue_OpSliceMake(v *ssa.Value) bool {
	v_2 := v.Args[2]
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (SliceMake (AddPtr <t> x (And64 y (Slicemask _))) w:(Const64 [c]) z)
	// cond: c > 0
	// result: (SliceMake (AddPtr <t> x y) w z)
	for {
		if v_0.Op != ssaop.OpAddPtr {
			break
		}
		t := v_0.Type
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpAnd64 {
			break
		}
		_ = v_0_1.Args[1]
		v_0_1_0 := v_0_1.Args[0]
		v_0_1_1 := v_0_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_1_0, v_0_1_1 = _i0+1, v_0_1_1, v_0_1_0 {
			y := v_0_1_0
			if v_0_1_1.Op != ssaop.OpSlicemask {
				continue
			}
			w := v_1
			if w.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(w.AuxInt)
			z := v_2
			if !(c > 0) {
				continue
			}
			v.Reset(ssaop.OpSliceMake)
			v0 := b.NewValue0(v.Pos, ssaop.OpAddPtr, t)
			v0.AddArg2(x, y)
			v.AddArg3(v0, w, z)
			return true
		}
		break
	}
	// match: (SliceMake (AddPtr <t> x (And32 y (Slicemask _))) w:(Const32 [c]) z)
	// cond: c > 0
	// result: (SliceMake (AddPtr <t> x y) w z)
	for {
		if v_0.Op != ssaop.OpAddPtr {
			break
		}
		t := v_0.Type
		_ = v_0.Args[1]
		x := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpAnd32 {
			break
		}
		_ = v_0_1.Args[1]
		v_0_1_0 := v_0_1.Args[0]
		v_0_1_1 := v_0_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_1_0, v_0_1_1 = _i0+1, v_0_1_1, v_0_1_0 {
			y := v_0_1_0
			if v_0_1_1.Op != ssaop.OpSlicemask {
				continue
			}
			w := v_1
			if w.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(w.AuxInt)
			z := v_2
			if !(c > 0) {
				continue
			}
			v.Reset(ssaop.OpSliceMake)
			v0 := b.NewValue0(v.Pos, ssaop.OpAddPtr, t)
			v0.AddArg2(x, y)
			v.AddArg3(v0, w, z)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpSlicePtr(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (SlicePtr (SliceMake (SlicePtr x) _ _))
	// result: (SlicePtr x)
	for {
		if v_0.Op != ssaop.OpSliceMake {
			break
		}
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpSlicePtr {
			break
		}
		x := v_0_0.Args[0]
		v.Reset(ssaop.OpSlicePtr)
		v.AddArg(x)
		return true
	}
	return false
}
func rewriteValue_OpSlicemask(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (Slicemask (Const32 [x]))
	// cond: x > 0
	// result: (Const32 [-1])
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		x := ssa.AuxIntToInt32(v_0.AuxInt)
		if !(x > 0) {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(-1)
		return true
	}
	// match: (Slicemask (Const32 [0]))
	// result: (Const32 [0])
	for {
		if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(0)
		return true
	}
	// match: (Slicemask (Const64 [x]))
	// cond: x > 0
	// result: (Const64 [-1])
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		x := ssa.AuxIntToInt64(v_0.AuxInt)
		if !(x > 0) {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(-1)
		return true
	}
	// match: (Slicemask (Const64 [0]))
	// result: (Const64 [0])
	for {
		if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(0)
		return true
	}
	return false
}
func rewriteValue_OpSqrt(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (Sqrt (Const64F [c]))
	// cond: !math.IsNaN(math.Sqrt(c))
	// result: (Const64F [math.Sqrt(c)])
	for {
		if v_0.Op != ssaop.OpConst64F {
			break
		}
		c := ssa.AuxIntToFloat64(v_0.AuxInt)
		if !(!math.IsNaN(math.Sqrt(c))) {
			break
		}
		v.Reset(ssaop.OpConst64F)
		v.AuxInt = ssa.Float64ToAuxInt(math.Sqrt(c))
		return true
	}
	return false
}
func rewriteValue_OpStaticCall(v *ssa.Value) bool {
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (StaticCall {callAux} p q _ mem)
	// cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.IsSamePtr(p, q)
	// result: (MakeResult (ConstBool <typ.Bool> [true]) mem)
	for {
		if len(v.Args) != 4 {
			break
		}
		callAux := ssa.AuxToCall(v.Aux)
		mem := v.Args[3]
		p := v.Args[0]
		q := v.Args[1]
		if !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.IsSamePtr(p, q)) {
			break
		}
		v.Reset(ssaop.OpMakeResult)
		v0 := b.NewValue0(v.Pos, ssaop.OpConstBool, typ.Bool)
		v0.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(v0, mem)
		return true
	}
	return false
}
func rewriteValue_OpStaticLECall(v *ssa.Value) bool {
	b := v.Block
	config := b.Func.Config
	typ := &b.Func.Config.Types
	// match: (StaticLECall {callAux} sptr (Addr {scon} (SB)) (Const64 [1]) mem)
	// cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon)
	// result: (MakeResult (Eq8 (Load <typ.Int8> sptr mem) (Const8 <typ.Int8> [int8(ssa.Read8(scon,0))])) mem)
	for {
		if len(v.Args) != 4 {
			break
		}
		callAux := ssa.AuxToCall(v.Aux)
		mem := v.Args[3]
		sptr := v.Args[0]
		v_1 := v.Args[1]
		if v_1.Op != ssaop.OpAddr {
			break
		}
		scon := ssa.AuxToSym(v_1.Aux)
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpSB {
			break
		}
		v_2 := v.Args[2]
		if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 1 || !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon)) {
			break
		}
		v.Reset(ssaop.OpMakeResult)
		v0 := b.NewValue0(v.Pos, ssaop.OpEq8, typ.Bool)
		v1 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int8)
		v1.AddArg2(sptr, mem)
		v2 := b.NewValue0(v.Pos, ssaop.OpConst8, typ.Int8)
		v2.AuxInt = ssa.Int8ToAuxInt(int8(ssa.Read8(scon, 0)))
		v0.AddArg2(v1, v2)
		v.AddArg2(v0, mem)
		return true
	}
	// match: (StaticLECall {callAux} (Addr {scon} (SB)) sptr (Const64 [1]) mem)
	// cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon)
	// result: (MakeResult (Eq8 (Load <typ.Int8> sptr mem) (Const8 <typ.Int8> [int8(ssa.Read8(scon,0))])) mem)
	for {
		if len(v.Args) != 4 {
			break
		}
		callAux := ssa.AuxToCall(v.Aux)
		mem := v.Args[3]
		v_0 := v.Args[0]
		if v_0.Op != ssaop.OpAddr {
			break
		}
		scon := ssa.AuxToSym(v_0.Aux)
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpSB {
			break
		}
		sptr := v.Args[1]
		v_2 := v.Args[2]
		if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 1 || !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon)) {
			break
		}
		v.Reset(ssaop.OpMakeResult)
		v0 := b.NewValue0(v.Pos, ssaop.OpEq8, typ.Bool)
		v1 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int8)
		v1.AddArg2(sptr, mem)
		v2 := b.NewValue0(v.Pos, ssaop.OpConst8, typ.Int8)
		v2.AuxInt = ssa.Int8ToAuxInt(int8(ssa.Read8(scon, 0)))
		v0.AddArg2(v1, v2)
		v.AddArg2(v0, mem)
		return true
	}
	// match: (StaticLECall {callAux} sptr (Addr {scon} (SB)) (Const64 [2]) mem)
	// cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config)
	// result: (MakeResult (Eq16 (Load <typ.Int16> sptr mem) (Const16 <typ.Int16> [int16(ssa.Read16(scon,0,config.Ctxt.Arch.ByteOrder))])) mem)
	for {
		if len(v.Args) != 4 {
			break
		}
		callAux := ssa.AuxToCall(v.Aux)
		mem := v.Args[3]
		sptr := v.Args[0]
		v_1 := v.Args[1]
		if v_1.Op != ssaop.OpAddr {
			break
		}
		scon := ssa.AuxToSym(v_1.Aux)
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpSB {
			break
		}
		v_2 := v.Args[2]
		if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 2 || !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config)) {
			break
		}
		v.Reset(ssaop.OpMakeResult)
		v0 := b.NewValue0(v.Pos, ssaop.OpEq16, typ.Bool)
		v1 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int16)
		v1.AddArg2(sptr, mem)
		v2 := b.NewValue0(v.Pos, ssaop.OpConst16, typ.Int16)
		v2.AuxInt = ssa.Int16ToAuxInt(int16(ssa.Read16(scon, 0, config.Ctxt.Arch.ByteOrder)))
		v0.AddArg2(v1, v2)
		v.AddArg2(v0, mem)
		return true
	}
	// match: (StaticLECall {callAux} (Addr {scon} (SB)) sptr (Const64 [2]) mem)
	// cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config)
	// result: (MakeResult (Eq16 (Load <typ.Int16> sptr mem) (Const16 <typ.Int16> [int16(ssa.Read16(scon,0,config.Ctxt.Arch.ByteOrder))])) mem)
	for {
		if len(v.Args) != 4 {
			break
		}
		callAux := ssa.AuxToCall(v.Aux)
		mem := v.Args[3]
		v_0 := v.Args[0]
		if v_0.Op != ssaop.OpAddr {
			break
		}
		scon := ssa.AuxToSym(v_0.Aux)
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpSB {
			break
		}
		sptr := v.Args[1]
		v_2 := v.Args[2]
		if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 2 || !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config)) {
			break
		}
		v.Reset(ssaop.OpMakeResult)
		v0 := b.NewValue0(v.Pos, ssaop.OpEq16, typ.Bool)
		v1 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int16)
		v1.AddArg2(sptr, mem)
		v2 := b.NewValue0(v.Pos, ssaop.OpConst16, typ.Int16)
		v2.AuxInt = ssa.Int16ToAuxInt(int16(ssa.Read16(scon, 0, config.Ctxt.Arch.ByteOrder)))
		v0.AddArg2(v1, v2)
		v.AddArg2(v0, mem)
		return true
	}
	// match: (StaticLECall {callAux} sptr (Addr {scon} (SB)) (Const64 [4]) mem)
	// cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config)
	// result: (MakeResult (Eq32 (Load <typ.Int32> sptr mem) (Const32 <typ.Int32> [int32(ssa.Read32(scon,0,config.Ctxt.Arch.ByteOrder))])) mem)
	for {
		if len(v.Args) != 4 {
			break
		}
		callAux := ssa.AuxToCall(v.Aux)
		mem := v.Args[3]
		sptr := v.Args[0]
		v_1 := v.Args[1]
		if v_1.Op != ssaop.OpAddr {
			break
		}
		scon := ssa.AuxToSym(v_1.Aux)
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpSB {
			break
		}
		v_2 := v.Args[2]
		if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 4 || !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config)) {
			break
		}
		v.Reset(ssaop.OpMakeResult)
		v0 := b.NewValue0(v.Pos, ssaop.OpEq32, typ.Bool)
		v1 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int32)
		v1.AddArg2(sptr, mem)
		v2 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.Int32)
		v2.AuxInt = ssa.Int32ToAuxInt(int32(ssa.Read32(scon, 0, config.Ctxt.Arch.ByteOrder)))
		v0.AddArg2(v1, v2)
		v.AddArg2(v0, mem)
		return true
	}
	// match: (StaticLECall {callAux} (Addr {scon} (SB)) sptr (Const64 [4]) mem)
	// cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config)
	// result: (MakeResult (Eq32 (Load <typ.Int32> sptr mem) (Const32 <typ.Int32> [int32(ssa.Read32(scon,0,config.Ctxt.Arch.ByteOrder))])) mem)
	for {
		if len(v.Args) != 4 {
			break
		}
		callAux := ssa.AuxToCall(v.Aux)
		mem := v.Args[3]
		v_0 := v.Args[0]
		if v_0.Op != ssaop.OpAddr {
			break
		}
		scon := ssa.AuxToSym(v_0.Aux)
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpSB {
			break
		}
		sptr := v.Args[1]
		v_2 := v.Args[2]
		if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 4 || !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config)) {
			break
		}
		v.Reset(ssaop.OpMakeResult)
		v0 := b.NewValue0(v.Pos, ssaop.OpEq32, typ.Bool)
		v1 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int32)
		v1.AddArg2(sptr, mem)
		v2 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.Int32)
		v2.AuxInt = ssa.Int32ToAuxInt(int32(ssa.Read32(scon, 0, config.Ctxt.Arch.ByteOrder)))
		v0.AddArg2(v1, v2)
		v.AddArg2(v0, mem)
		return true
	}
	// match: (StaticLECall {callAux} sptr (Addr {scon} (SB)) (Const64 [8]) mem)
	// cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) && config.PtrSize == 8
	// result: (MakeResult (Eq64 (Load <typ.Int64> sptr mem) (Const64 <typ.Int64> [int64(ssa.Read64(scon,0,config.Ctxt.Arch.ByteOrder))])) mem)
	for {
		if len(v.Args) != 4 {
			break
		}
		callAux := ssa.AuxToCall(v.Aux)
		mem := v.Args[3]
		sptr := v.Args[0]
		v_1 := v.Args[1]
		if v_1.Op != ssaop.OpAddr {
			break
		}
		scon := ssa.AuxToSym(v_1.Aux)
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpSB {
			break
		}
		v_2 := v.Args[2]
		if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 8 || !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) && config.PtrSize == 8) {
			break
		}
		v.Reset(ssaop.OpMakeResult)
		v0 := b.NewValue0(v.Pos, ssaop.OpEq64, typ.Bool)
		v1 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int64)
		v1.AddArg2(sptr, mem)
		v2 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64)
		v2.AuxInt = ssa.Int64ToAuxInt(int64(ssa.Read64(scon, 0, config.Ctxt.Arch.ByteOrder)))
		v0.AddArg2(v1, v2)
		v.AddArg2(v0, mem)
		return true
	}
	// match: (StaticLECall {callAux} (Addr {scon} (SB)) sptr (Const64 [8]) mem)
	// cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) && config.PtrSize == 8
	// result: (MakeResult (Eq64 (Load <typ.Int64> sptr mem) (Const64 <typ.Int64> [int64(ssa.Read64(scon,0,config.Ctxt.Arch.ByteOrder))])) mem)
	for {
		if len(v.Args) != 4 {
			break
		}
		callAux := ssa.AuxToCall(v.Aux)
		mem := v.Args[3]
		v_0 := v.Args[0]
		if v_0.Op != ssaop.OpAddr {
			break
		}
		scon := ssa.AuxToSym(v_0.Aux)
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpSB {
			break
		}
		sptr := v.Args[1]
		v_2 := v.Args[2]
		if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 8 || !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) && config.PtrSize == 8) {
			break
		}
		v.Reset(ssaop.OpMakeResult)
		v0 := b.NewValue0(v.Pos, ssaop.OpEq64, typ.Bool)
		v1 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int64)
		v1.AddArg2(sptr, mem)
		v2 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64)
		v2.AuxInt = ssa.Int64ToAuxInt(int64(ssa.Read64(scon, 0, config.Ctxt.Arch.ByteOrder)))
		v0.AddArg2(v1, v2)
		v.AddArg2(v0, mem)
		return true
	}
	// match: (StaticLECall {callAux} sptr (Addr {scon} (SB)) (Const64 [3]) mem)
	// cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config)
	// result: (MakeResult (Eq32 (Or32 <typ.Int32> (ZeroExt16to32 <typ.Int32> (Load <typ.Int16> sptr mem)) (Lsh32x32 <typ.Int32> (ZeroExt8to32 <typ.Int32> (Load <typ.Int8> (OffPtr <typ.BytePtr> [2] sptr) mem)) (Const32 <typ.Int32> [16]))) (Const32 <typ.Int32> [int32(uint32(ssa.Read16(scon,0,config.Ctxt.Arch.ByteOrder))|(uint32(ssa.Read8(scon,2))<<16))])) mem)
	for {
		if len(v.Args) != 4 {
			break
		}
		callAux := ssa.AuxToCall(v.Aux)
		mem := v.Args[3]
		sptr := v.Args[0]
		v_1 := v.Args[1]
		if v_1.Op != ssaop.OpAddr {
			break
		}
		scon := ssa.AuxToSym(v_1.Aux)
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpSB {
			break
		}
		v_2 := v.Args[2]
		if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 3 || !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config)) {
			break
		}
		v.Reset(ssaop.OpMakeResult)
		v0 := b.NewValue0(v.Pos, ssaop.OpEq32, typ.Bool)
		v1 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.Int32)
		v2 := b.NewValue0(v.Pos, ssaop.OpZeroExt16to32, typ.Int32)
		v3 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int16)
		v3.AddArg2(sptr, mem)
		v2.AddArg(v3)
		v4 := b.NewValue0(v.Pos, ssaop.OpLsh32x32, typ.Int32)
		v5 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to32, typ.Int32)
		v6 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int8)
		v7 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.BytePtr)
		v7.AuxInt = ssa.Int64ToAuxInt(2)
		v7.AddArg(sptr)
		v6.AddArg2(v7, mem)
		v5.AddArg(v6)
		v8 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.Int32)
		v8.AuxInt = ssa.Int32ToAuxInt(16)
		v4.AddArg2(v5, v8)
		v1.AddArg2(v2, v4)
		v9 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.Int32)
		v9.AuxInt = ssa.Int32ToAuxInt(int32(uint32(ssa.Read16(scon, 0, config.Ctxt.Arch.ByteOrder)) | (uint32(ssa.Read8(scon, 2)) << 16)))
		v0.AddArg2(v1, v9)
		v.AddArg2(v0, mem)
		return true
	}
	// match: (StaticLECall {callAux} (Addr {scon} (SB)) sptr (Const64 [3]) mem)
	// cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config)
	// result: (MakeResult (Eq32 (Or32 <typ.Int32> (ZeroExt16to32 <typ.Int32> (Load <typ.Int16> sptr mem)) (Lsh32x32 <typ.Int32> (ZeroExt8to32 <typ.Int32> (Load <typ.Int8> (OffPtr <typ.BytePtr> [2] sptr) mem)) (Const32 <typ.Int32> [16]))) (Const32 <typ.Int32> [int32(uint32(ssa.Read16(scon,0,config.Ctxt.Arch.ByteOrder))|(uint32(ssa.Read8(scon,2))<<16))])) mem)
	for {
		if len(v.Args) != 4 {
			break
		}
		callAux := ssa.AuxToCall(v.Aux)
		mem := v.Args[3]
		v_0 := v.Args[0]
		if v_0.Op != ssaop.OpAddr {
			break
		}
		scon := ssa.AuxToSym(v_0.Aux)
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpSB {
			break
		}
		sptr := v.Args[1]
		v_2 := v.Args[2]
		if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 3 || !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config)) {
			break
		}
		v.Reset(ssaop.OpMakeResult)
		v0 := b.NewValue0(v.Pos, ssaop.OpEq32, typ.Bool)
		v1 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.Int32)
		v2 := b.NewValue0(v.Pos, ssaop.OpZeroExt16to32, typ.Int32)
		v3 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int16)
		v3.AddArg2(sptr, mem)
		v2.AddArg(v3)
		v4 := b.NewValue0(v.Pos, ssaop.OpLsh32x32, typ.Int32)
		v5 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to32, typ.Int32)
		v6 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int8)
		v7 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.BytePtr)
		v7.AuxInt = ssa.Int64ToAuxInt(2)
		v7.AddArg(sptr)
		v6.AddArg2(v7, mem)
		v5.AddArg(v6)
		v8 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.Int32)
		v8.AuxInt = ssa.Int32ToAuxInt(16)
		v4.AddArg2(v5, v8)
		v1.AddArg2(v2, v4)
		v9 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.Int32)
		v9.AuxInt = ssa.Int32ToAuxInt(int32(uint32(ssa.Read16(scon, 0, config.Ctxt.Arch.ByteOrder)) | (uint32(ssa.Read8(scon, 2)) << 16)))
		v0.AddArg2(v1, v9)
		v.AddArg2(v0, mem)
		return true
	}
	// match: (StaticLECall {callAux} sptr (Addr {scon} (SB)) (Const64 [5]) mem)
	// cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) && config.PtrSize == 8
	// result: (MakeResult (Eq64 (Or64 <typ.Int64> (ZeroExt32to64 <typ.Int64> (Load <typ.Int32> sptr mem)) (Lsh64x64 <typ.Int64> (ZeroExt8to64 <typ.Int64> (Load <typ.Int8> (OffPtr <typ.BytePtr> [4] sptr) mem)) (Const64 <typ.Int64> [32]))) (Const64 <typ.Int64> [int64(uint64(ssa.Read32(scon,0,config.Ctxt.Arch.ByteOrder))|(uint64(ssa.Read8(scon,4))<<32))])) mem)
	for {
		if len(v.Args) != 4 {
			break
		}
		callAux := ssa.AuxToCall(v.Aux)
		mem := v.Args[3]
		sptr := v.Args[0]
		v_1 := v.Args[1]
		if v_1.Op != ssaop.OpAddr {
			break
		}
		scon := ssa.AuxToSym(v_1.Aux)
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpSB {
			break
		}
		v_2 := v.Args[2]
		if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 5 || !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) && config.PtrSize == 8) {
			break
		}
		v.Reset(ssaop.OpMakeResult)
		v0 := b.NewValue0(v.Pos, ssaop.OpEq64, typ.Bool)
		v1 := b.NewValue0(v.Pos, ssaop.OpOr64, typ.Int64)
		v2 := b.NewValue0(v.Pos, ssaop.OpZeroExt32to64, typ.Int64)
		v3 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int32)
		v3.AddArg2(sptr, mem)
		v2.AddArg(v3)
		v4 := b.NewValue0(v.Pos, ssaop.OpLsh64x64, typ.Int64)
		v5 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to64, typ.Int64)
		v6 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int8)
		v7 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.BytePtr)
		v7.AuxInt = ssa.Int64ToAuxInt(4)
		v7.AddArg(sptr)
		v6.AddArg2(v7, mem)
		v5.AddArg(v6)
		v8 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64)
		v8.AuxInt = ssa.Int64ToAuxInt(32)
		v4.AddArg2(v5, v8)
		v1.AddArg2(v2, v4)
		v9 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64)
		v9.AuxInt = ssa.Int64ToAuxInt(int64(uint64(ssa.Read32(scon, 0, config.Ctxt.Arch.ByteOrder)) | (uint64(ssa.Read8(scon, 4)) << 32)))
		v0.AddArg2(v1, v9)
		v.AddArg2(v0, mem)
		return true
	}
	// match: (StaticLECall {callAux} (Addr {scon} (SB)) sptr (Const64 [5]) mem)
	// cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) && config.PtrSize == 8
	// result: (MakeResult (Eq64 (Or64 <typ.Int64> (ZeroExt32to64 <typ.Int64> (Load <typ.Int32> sptr mem)) (Lsh64x64 <typ.Int64> (ZeroExt8to64 <typ.Int64> (Load <typ.Int8> (OffPtr <typ.BytePtr> [4] sptr) mem)) (Const64 <typ.Int64> [32]))) (Const64 <typ.Int64> [int64(uint64(ssa.Read32(scon,0,config.Ctxt.Arch.ByteOrder))|(uint64(ssa.Read8(scon,4))<<32))])) mem)
	for {
		if len(v.Args) != 4 {
			break
		}
		callAux := ssa.AuxToCall(v.Aux)
		mem := v.Args[3]
		v_0 := v.Args[0]
		if v_0.Op != ssaop.OpAddr {
			break
		}
		scon := ssa.AuxToSym(v_0.Aux)
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpSB {
			break
		}
		sptr := v.Args[1]
		v_2 := v.Args[2]
		if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 5 || !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) && config.PtrSize == 8) {
			break
		}
		v.Reset(ssaop.OpMakeResult)
		v0 := b.NewValue0(v.Pos, ssaop.OpEq64, typ.Bool)
		v1 := b.NewValue0(v.Pos, ssaop.OpOr64, typ.Int64)
		v2 := b.NewValue0(v.Pos, ssaop.OpZeroExt32to64, typ.Int64)
		v3 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int32)
		v3.AddArg2(sptr, mem)
		v2.AddArg(v3)
		v4 := b.NewValue0(v.Pos, ssaop.OpLsh64x64, typ.Int64)
		v5 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to64, typ.Int64)
		v6 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int8)
		v7 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.BytePtr)
		v7.AuxInt = ssa.Int64ToAuxInt(4)
		v7.AddArg(sptr)
		v6.AddArg2(v7, mem)
		v5.AddArg(v6)
		v8 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64)
		v8.AuxInt = ssa.Int64ToAuxInt(32)
		v4.AddArg2(v5, v8)
		v1.AddArg2(v2, v4)
		v9 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64)
		v9.AuxInt = ssa.Int64ToAuxInt(int64(uint64(ssa.Read32(scon, 0, config.Ctxt.Arch.ByteOrder)) | (uint64(ssa.Read8(scon, 4)) << 32)))
		v0.AddArg2(v1, v9)
		v.AddArg2(v0, mem)
		return true
	}
	// match: (StaticLECall {callAux} sptr (Addr {scon} (SB)) (Const64 [6]) mem)
	// cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) && config.PtrSize == 8
	// result: (MakeResult (Eq64 (Or64 <typ.Int64> (ZeroExt32to64 <typ.Int64> (Load <typ.Int32> sptr mem)) (Lsh64x64 <typ.Int64> (ZeroExt16to64 <typ.Int64> (Load <typ.Int16> (OffPtr <typ.BytePtr> [4] sptr) mem)) (Const64 <typ.Int64> [32]))) (Const64 <typ.Int64> [int64(uint64(ssa.Read32(scon,0,config.Ctxt.Arch.ByteOrder))|(uint64(ssa.Read16(scon,4,config.Ctxt.Arch.ByteOrder))<<32))])) mem)
	for {
		if len(v.Args) != 4 {
			break
		}
		callAux := ssa.AuxToCall(v.Aux)
		mem := v.Args[3]
		sptr := v.Args[0]
		v_1 := v.Args[1]
		if v_1.Op != ssaop.OpAddr {
			break
		}
		scon := ssa.AuxToSym(v_1.Aux)
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpSB {
			break
		}
		v_2 := v.Args[2]
		if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 6 || !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) && config.PtrSize == 8) {
			break
		}
		v.Reset(ssaop.OpMakeResult)
		v0 := b.NewValue0(v.Pos, ssaop.OpEq64, typ.Bool)
		v1 := b.NewValue0(v.Pos, ssaop.OpOr64, typ.Int64)
		v2 := b.NewValue0(v.Pos, ssaop.OpZeroExt32to64, typ.Int64)
		v3 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int32)
		v3.AddArg2(sptr, mem)
		v2.AddArg(v3)
		v4 := b.NewValue0(v.Pos, ssaop.OpLsh64x64, typ.Int64)
		v5 := b.NewValue0(v.Pos, ssaop.OpZeroExt16to64, typ.Int64)
		v6 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int16)
		v7 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.BytePtr)
		v7.AuxInt = ssa.Int64ToAuxInt(4)
		v7.AddArg(sptr)
		v6.AddArg2(v7, mem)
		v5.AddArg(v6)
		v8 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64)
		v8.AuxInt = ssa.Int64ToAuxInt(32)
		v4.AddArg2(v5, v8)
		v1.AddArg2(v2, v4)
		v9 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64)
		v9.AuxInt = ssa.Int64ToAuxInt(int64(uint64(ssa.Read32(scon, 0, config.Ctxt.Arch.ByteOrder)) | (uint64(ssa.Read16(scon, 4, config.Ctxt.Arch.ByteOrder)) << 32)))
		v0.AddArg2(v1, v9)
		v.AddArg2(v0, mem)
		return true
	}
	// match: (StaticLECall {callAux} (Addr {scon} (SB)) sptr (Const64 [6]) mem)
	// cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) && config.PtrSize == 8
	// result: (MakeResult (Eq64 (Or64 <typ.Int64> (ZeroExt32to64 <typ.Int64> (Load <typ.Int32> sptr mem)) (Lsh64x64 <typ.Int64> (ZeroExt16to64 <typ.Int64> (Load <typ.Int16> (OffPtr <typ.BytePtr> [4] sptr) mem)) (Const64 <typ.Int64> [32]))) (Const64 <typ.Int64> [int64(uint64(ssa.Read32(scon,0,config.Ctxt.Arch.ByteOrder))|(uint64(ssa.Read16(scon,4,config.Ctxt.Arch.ByteOrder))<<32))])) mem)
	for {
		if len(v.Args) != 4 {
			break
		}
		callAux := ssa.AuxToCall(v.Aux)
		mem := v.Args[3]
		v_0 := v.Args[0]
		if v_0.Op != ssaop.OpAddr {
			break
		}
		scon := ssa.AuxToSym(v_0.Aux)
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpSB {
			break
		}
		sptr := v.Args[1]
		v_2 := v.Args[2]
		if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 6 || !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) && config.PtrSize == 8) {
			break
		}
		v.Reset(ssaop.OpMakeResult)
		v0 := b.NewValue0(v.Pos, ssaop.OpEq64, typ.Bool)
		v1 := b.NewValue0(v.Pos, ssaop.OpOr64, typ.Int64)
		v2 := b.NewValue0(v.Pos, ssaop.OpZeroExt32to64, typ.Int64)
		v3 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int32)
		v3.AddArg2(sptr, mem)
		v2.AddArg(v3)
		v4 := b.NewValue0(v.Pos, ssaop.OpLsh64x64, typ.Int64)
		v5 := b.NewValue0(v.Pos, ssaop.OpZeroExt16to64, typ.Int64)
		v6 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int16)
		v7 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.BytePtr)
		v7.AuxInt = ssa.Int64ToAuxInt(4)
		v7.AddArg(sptr)
		v6.AddArg2(v7, mem)
		v5.AddArg(v6)
		v8 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64)
		v8.AuxInt = ssa.Int64ToAuxInt(32)
		v4.AddArg2(v5, v8)
		v1.AddArg2(v2, v4)
		v9 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64)
		v9.AuxInt = ssa.Int64ToAuxInt(int64(uint64(ssa.Read32(scon, 0, config.Ctxt.Arch.ByteOrder)) | (uint64(ssa.Read16(scon, 4, config.Ctxt.Arch.ByteOrder)) << 32)))
		v0.AddArg2(v1, v9)
		v.AddArg2(v0, mem)
		return true
	}
	// match: (StaticLECall {callAux} sptr (Addr {scon} (SB)) (Const64 [7]) mem)
	// cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) && config.PtrSize == 8
	// result: (MakeResult (Eq64 (Or64 <typ.Int64> (ZeroExt32to64 <typ.Int64> (Load <typ.Int32> sptr mem)) (Lsh64x64 <typ.Int64> (ZeroExt32to64 <typ.Int64> (Load <typ.Int32> (OffPtr <typ.BytePtr> [3] sptr) mem)) (Const64 <typ.Int64> [32]))) (Const64 <typ.Int64> [int64(uint64(ssa.Read32(scon,0,config.Ctxt.Arch.ByteOrder))|(uint64(ssa.Read32(scon,3,config.Ctxt.Arch.ByteOrder))<<32))])) mem)
	for {
		if len(v.Args) != 4 {
			break
		}
		callAux := ssa.AuxToCall(v.Aux)
		mem := v.Args[3]
		sptr := v.Args[0]
		v_1 := v.Args[1]
		if v_1.Op != ssaop.OpAddr {
			break
		}
		scon := ssa.AuxToSym(v_1.Aux)
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpSB {
			break
		}
		v_2 := v.Args[2]
		if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 7 || !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) && config.PtrSize == 8) {
			break
		}
		v.Reset(ssaop.OpMakeResult)
		v0 := b.NewValue0(v.Pos, ssaop.OpEq64, typ.Bool)
		v1 := b.NewValue0(v.Pos, ssaop.OpOr64, typ.Int64)
		v2 := b.NewValue0(v.Pos, ssaop.OpZeroExt32to64, typ.Int64)
		v3 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int32)
		v3.AddArg2(sptr, mem)
		v2.AddArg(v3)
		v4 := b.NewValue0(v.Pos, ssaop.OpLsh64x64, typ.Int64)
		v5 := b.NewValue0(v.Pos, ssaop.OpZeroExt32to64, typ.Int64)
		v6 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int32)
		v7 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.BytePtr)
		v7.AuxInt = ssa.Int64ToAuxInt(3)
		v7.AddArg(sptr)
		v6.AddArg2(v7, mem)
		v5.AddArg(v6)
		v8 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64)
		v8.AuxInt = ssa.Int64ToAuxInt(32)
		v4.AddArg2(v5, v8)
		v1.AddArg2(v2, v4)
		v9 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64)
		v9.AuxInt = ssa.Int64ToAuxInt(int64(uint64(ssa.Read32(scon, 0, config.Ctxt.Arch.ByteOrder)) | (uint64(ssa.Read32(scon, 3, config.Ctxt.Arch.ByteOrder)) << 32)))
		v0.AddArg2(v1, v9)
		v.AddArg2(v0, mem)
		return true
	}
	// match: (StaticLECall {callAux} (Addr {scon} (SB)) sptr (Const64 [7]) mem)
	// cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) && config.PtrSize == 8
	// result: (MakeResult (Eq64 (Or64 <typ.Int64> (ZeroExt32to64 <typ.Int64> (Load <typ.Int32> sptr mem)) (Lsh64x64 <typ.Int64> (ZeroExt32to64 <typ.Int64> (Load <typ.Int32> (OffPtr <typ.BytePtr> [3] sptr) mem)) (Const64 <typ.Int64> [32]))) (Const64 <typ.Int64> [int64(uint64(ssa.Read32(scon,0,config.Ctxt.Arch.ByteOrder))|(uint64(ssa.Read32(scon,3,config.Ctxt.Arch.ByteOrder))<<32))])) mem)
	for {
		if len(v.Args) != 4 {
			break
		}
		callAux := ssa.AuxToCall(v.Aux)
		mem := v.Args[3]
		v_0 := v.Args[0]
		if v_0.Op != ssaop.OpAddr {
			break
		}
		scon := ssa.AuxToSym(v_0.Aux)
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpSB {
			break
		}
		sptr := v.Args[1]
		v_2 := v.Args[2]
		if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 7 || !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) && config.PtrSize == 8) {
			break
		}
		v.Reset(ssaop.OpMakeResult)
		v0 := b.NewValue0(v.Pos, ssaop.OpEq64, typ.Bool)
		v1 := b.NewValue0(v.Pos, ssaop.OpOr64, typ.Int64)
		v2 := b.NewValue0(v.Pos, ssaop.OpZeroExt32to64, typ.Int64)
		v3 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int32)
		v3.AddArg2(sptr, mem)
		v2.AddArg(v3)
		v4 := b.NewValue0(v.Pos, ssaop.OpLsh64x64, typ.Int64)
		v5 := b.NewValue0(v.Pos, ssaop.OpZeroExt32to64, typ.Int64)
		v6 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int32)
		v7 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.BytePtr)
		v7.AuxInt = ssa.Int64ToAuxInt(3)
		v7.AddArg(sptr)
		v6.AddArg2(v7, mem)
		v5.AddArg(v6)
		v8 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64)
		v8.AuxInt = ssa.Int64ToAuxInt(32)
		v4.AddArg2(v5, v8)
		v1.AddArg2(v2, v4)
		v9 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64)
		v9.AuxInt = ssa.Int64ToAuxInt(int64(uint64(ssa.Read32(scon, 0, config.Ctxt.Arch.ByteOrder)) | (uint64(ssa.Read32(scon, 3, config.Ctxt.Arch.ByteOrder)) << 32)))
		v0.AddArg2(v1, v9)
		v.AddArg2(v0, mem)
		return true
	}
	// match: (StaticLECall {callAux} _ _ (Const64 [0]) mem)
	// cond: ssa.IsSameCall(callAux, "runtime.memequal")
	// result: (MakeResult (ConstBool <typ.Bool> [true]) mem)
	for {
		if len(v.Args) != 4 {
			break
		}
		callAux := ssa.AuxToCall(v.Aux)
		mem := v.Args[3]
		v_2 := v.Args[2]
		if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 0 || !(ssa.IsSameCall(callAux, "runtime.memequal")) {
			break
		}
		v.Reset(ssaop.OpMakeResult)
		v0 := b.NewValue0(v.Pos, ssaop.OpConstBool, typ.Bool)
		v0.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(v0, mem)
		return true
	}
	// match: (StaticLECall {callAux} p q _ mem)
	// cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.IsSamePtr(p, q)
	// result: (MakeResult (ConstBool <typ.Bool> [true]) mem)
	for {
		if len(v.Args) != 4 {
			break
		}
		callAux := ssa.AuxToCall(v.Aux)
		mem := v.Args[3]
		p := v.Args[0]
		q := v.Args[1]
		if !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.IsSamePtr(p, q)) {
			break
		}
		v.Reset(ssaop.OpMakeResult)
		v0 := b.NewValue0(v.Pos, ssaop.OpConstBool, typ.Bool)
		v0.AuxInt = ssa.BoolToAuxInt(true)
		v.AddArg2(v0, mem)
		return true
	}
	// match: (StaticLECall {callAux} _ (Const64 [0]) (Const64 [0]) mem)
	// cond: ssa.IsSameCall(callAux, "runtime.makeslice")
	// result: (MakeResult (Addr <v.Type.FieldType(0)> {ir.Syms.Zerobase} (SB)) mem)
	for {
		if len(v.Args) != 4 {
			break
		}
		callAux := ssa.AuxToCall(v.Aux)
		mem := v.Args[3]
		v_1 := v.Args[1]
		if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 {
			break
		}
		v_2 := v.Args[2]
		if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 0 || !(ssa.IsSameCall(callAux, "runtime.makeslice")) {
			break
		}
		v.Reset(ssaop.OpMakeResult)
		v0 := b.NewValue0(v.Pos, ssaop.OpAddr, v.Type.FieldType(0))
		v0.Aux = ssa.SymToAux(ir.Syms.Zerobase)
		v1 := b.NewValue0(v.Pos, ssaop.OpSB, typ.Uintptr)
		v0.AddArg(v1)
		v.AddArg2(v0, mem)
		return true
	}
	// match: (StaticLECall {callAux} _ (Const32 [0]) (Const32 [0]) mem)
	// cond: ssa.IsSameCall(callAux, "runtime.makeslice")
	// result: (MakeResult (Addr <v.Type.FieldType(0)> {ir.Syms.Zerobase} (SB)) mem)
	for {
		if len(v.Args) != 4 {
			break
		}
		callAux := ssa.AuxToCall(v.Aux)
		mem := v.Args[3]
		v_1 := v.Args[1]
		if v_1.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1.AuxInt) != 0 {
			break
		}
		v_2 := v.Args[2]
		if v_2.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_2.AuxInt) != 0 || !(ssa.IsSameCall(callAux, "runtime.makeslice")) {
			break
		}
		v.Reset(ssaop.OpMakeResult)
		v0 := b.NewValue0(v.Pos, ssaop.OpAddr, v.Type.FieldType(0))
		v0.Aux = ssa.SymToAux(ir.Syms.Zerobase)
		v1 := b.NewValue0(v.Pos, ssaop.OpSB, typ.Uintptr)
		v0.AddArg(v1)
		v.AddArg2(v0, mem)
		return true
	}
	// match: (StaticLECall {f} typ_ x y mem)
	// cond: ssa.IsSameCall(f, "runtime.efaceeq") && isDirectAndComparableType(typ_) && ssa.Clobber(v)
	// result: (MakeResult (EqPtr x y) mem)
	for {
		if len(v.Args) != 4 {
			break
		}
		f := ssa.AuxToCall(v.Aux)
		mem := v.Args[3]
		typ_ := v.Args[0]
		x := v.Args[1]
		y := v.Args[2]
		if !(ssa.IsSameCall(f, "runtime.efaceeq") && isDirectAndComparableType(typ_) && ssa.Clobber(v)) {
			break
		}
		v.Reset(ssaop.OpMakeResult)
		v0 := b.NewValue0(v.Pos, ssaop.OpEqPtr, typ.Bool)
		v0.AddArg2(x, y)
		v.AddArg2(v0, mem)
		return true
	}
	// match: (StaticLECall {f} itab x y mem)
	// cond: ssa.IsSameCall(f, "runtime.ifaceeq") && isDirectAndComparableIface(itab) && ssa.Clobber(v)
	// result: (MakeResult (EqPtr x y) mem)
	for {
		if len(v.Args) != 4 {
			break
		}
		f := ssa.AuxToCall(v.Aux)
		mem := v.Args[3]
		itab := v.Args[0]
		x := v.Args[1]
		y := v.Args[2]
		if !(ssa.IsSameCall(f, "runtime.ifaceeq") && isDirectAndComparableIface(itab) && ssa.Clobber(v)) {
			break
		}
		v.Reset(ssaop.OpMakeResult)
		v0 := b.NewValue0(v.Pos, ssaop.OpEqPtr, typ.Bool)
		v0.AddArg2(x, y)
		v.AddArg2(v0, mem)
		return true
	}
	// match: (StaticLECall {f} [argsize] typ_ map_ key:(SelectN [0] sbts:(StaticLECall {g} _ ptr len mem)) m:(SelectN [1] sbts))
	// cond: (ssa.IsSameCall(f, "runtime.mapaccess1_faststr") || ssa.IsSameCall(f, "runtime.mapaccess2_faststr") || ssa.IsSameCall(f, "runtime.mapdelete_faststr")) && ssa.IsSameCall(g, "runtime.slicebytetostring") && key.Uses == 1 && sbts.Uses == 2 && resetCopy(m, mem) && ssa.Clobber(sbts) && ssa.Clobber(key)
	// result: (StaticLECall {f} [argsize] typ_ map_ (StringMake <typ.String> ptr len) mem)
	for {
		if len(v.Args) != 4 {
			break
		}
		argsize := ssa.AuxIntToInt32(v.AuxInt)
		f := ssa.AuxToCall(v.Aux)
		_ = v.Args[3]
		typ_ := v.Args[0]
		map_ := v.Args[1]
		key := v.Args[2]
		if key.Op != ssaop.OpSelectN || ssa.AuxIntToInt64(key.AuxInt) != 0 {
			break
		}
		sbts := key.Args[0]
		if sbts.Op != ssaop.OpStaticLECall || len(sbts.Args) != 4 {
			break
		}
		g := ssa.AuxToCall(sbts.Aux)
		mem := sbts.Args[3]
		ptr := sbts.Args[1]
		len := sbts.Args[2]
		m := v.Args[3]
		if m.Op != ssaop.OpSelectN || ssa.AuxIntToInt64(m.AuxInt) != 1 || sbts != m.Args[0] || !((ssa.IsSameCall(f, "runtime.mapaccess1_faststr") || ssa.IsSameCall(f, "runtime.mapaccess2_faststr") || ssa.IsSameCall(f, "runtime.mapdelete_faststr")) && ssa.IsSameCall(g, "runtime.slicebytetostring") && key.Uses == 1 && sbts.Uses == 2 && resetCopy(m, mem) && ssa.Clobber(sbts) && ssa.Clobber(key)) {
			break
		}
		v.Reset(ssaop.OpStaticLECall)
		v.AuxInt = ssa.Int32ToAuxInt(argsize)
		v.Aux = ssa.CallToAux(f)
		v0 := b.NewValue0(v.Pos, ssaop.OpStringMake, typ.String)
		v0.AddArg2(ptr, len)
		v.AddArg4(typ_, map_, v0, mem)
		return true
	}
	// match: (StaticLECall {f} [argsize] dict_ key:(SelectN [0] sbts:(StaticLECall {g} _ ptr len mem)) m:(SelectN [1] sbts))
	// cond: ssa.IsSameCall(f, "unique.Make[go.shape.string]") && ssa.IsSameCall(g, "runtime.slicebytetostring") && key.Uses == 1 && sbts.Uses == 2 && resetCopy(m, mem) && ssa.Clobber(sbts) && ssa.Clobber(key)
	// result: (StaticLECall {f} [argsize] dict_ (StringMake <typ.String> ptr len) mem)
	for {
		if len(v.Args) != 3 {
			break
		}
		argsize := ssa.AuxIntToInt32(v.AuxInt)
		f := ssa.AuxToCall(v.Aux)
		_ = v.Args[2]
		dict_ := v.Args[0]
		key := v.Args[1]
		if key.Op != ssaop.OpSelectN || ssa.AuxIntToInt64(key.AuxInt) != 0 {
			break
		}
		sbts := key.Args[0]
		if sbts.Op != ssaop.OpStaticLECall || len(sbts.Args) != 4 {
			break
		}
		g := ssa.AuxToCall(sbts.Aux)
		mem := sbts.Args[3]
		ptr := sbts.Args[1]
		len := sbts.Args[2]
		m := v.Args[2]
		if m.Op != ssaop.OpSelectN || ssa.AuxIntToInt64(m.AuxInt) != 1 || sbts != m.Args[0] || !(ssa.IsSameCall(f, "unique.Make[go.shape.string]") && ssa.IsSameCall(g, "runtime.slicebytetostring") && key.Uses == 1 && sbts.Uses == 2 && resetCopy(m, mem) && ssa.Clobber(sbts) && ssa.Clobber(key)) {
			break
		}
		v.Reset(ssaop.OpStaticLECall)
		v.AuxInt = ssa.Int32ToAuxInt(argsize)
		v.Aux = ssa.CallToAux(f)
		v0 := b.NewValue0(v.Pos, ssaop.OpStringMake, typ.String)
		v0.AddArg2(ptr, len)
		v.AddArg3(dict_, v0, mem)
		return true
	}
	return false
}
func rewriteValue_OpStore(v *ssa.Value) bool {
	v_2 := v.Args[2]
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Store {t1} p1 (Load <t2> p2 mem) mem)
	// cond: ssa.IsSamePtr(p1, p2) && t2.Size() == t1.Size()
	// result: mem
	for {
		t1 := ssa.AuxToType(v.Aux)
		p1 := v_0
		if v_1.Op != ssaop.OpLoad {
			break
		}
		t2 := v_1.Type
		mem := v_1.Args[1]
		p2 := v_1.Args[0]
		if mem != v_2 || !(ssa.IsSamePtr(p1, p2) && t2.Size() == t1.Size()) {
			break
		}
		v.CopyOf(mem)
		return true
	}
	// match: (Store {t1} p1 (Load <t2> p2 oldmem) mem:(Store {t3} p3 _ oldmem))
	// cond: ssa.IsSamePtr(p1, p2) && t2.Size() == t1.Size() && ssa.Disjoint(p1, t1, p3, t3)
	// result: mem
	for {
		t1 := ssa.AuxToType(v.Aux)
		p1 := v_0
		if v_1.Op != ssaop.OpLoad {
			break
		}
		t2 := v_1.Type
		oldmem := v_1.Args[1]
		p2 := v_1.Args[0]
		mem := v_2
		if mem.Op != ssaop.OpStore {
			break
		}
		t3 := ssa.AuxToType(mem.Aux)
		_ = mem.Args[2]
		p3 := mem.Args[0]
		if oldmem != mem.Args[2] || !(ssa.IsSamePtr(p1, p2) && t2.Size() == t1.Size() && ssa.Disjoint(p1, t1, p3, t3)) {
			break
		}
		v.CopyOf(mem)
		return true
	}
	// match: (Store {t1} p1 (Load <t2> p2 oldmem) mem:(Store {t3} p3 _ (Store {t4} p4 _ oldmem)))
	// cond: ssa.IsSamePtr(p1, p2) && t2.Size() == t1.Size() && ssa.Disjoint(p1, t1, p3, t3) && ssa.Disjoint(p1, t1, p4, t4)
	// result: mem
	for {
		t1 := ssa.AuxToType(v.Aux)
		p1 := v_0
		if v_1.Op != ssaop.OpLoad {
			break
		}
		t2 := v_1.Type
		oldmem := v_1.Args[1]
		p2 := v_1.Args[0]
		mem := v_2
		if mem.Op != ssaop.OpStore {
			break
		}
		t3 := ssa.AuxToType(mem.Aux)
		_ = mem.Args[2]
		p3 := mem.Args[0]
		mem_2 := mem.Args[2]
		if mem_2.Op != ssaop.OpStore {
			break
		}
		t4 := ssa.AuxToType(mem_2.Aux)
		_ = mem_2.Args[2]
		p4 := mem_2.Args[0]
		if oldmem != mem_2.Args[2] || !(ssa.IsSamePtr(p1, p2) && t2.Size() == t1.Size() && ssa.Disjoint(p1, t1, p3, t3) && ssa.Disjoint(p1, t1, p4, t4)) {
			break
		}
		v.CopyOf(mem)
		return true
	}
	// match: (Store {t1} p1 (Load <t2> p2 oldmem) mem:(Store {t3} p3 _ (Store {t4} p4 _ (Store {t5} p5 _ oldmem))))
	// cond: ssa.IsSamePtr(p1, p2) && t2.Size() == t1.Size() && ssa.Disjoint(p1, t1, p3, t3) && ssa.Disjoint(p1, t1, p4, t4) && ssa.Disjoint(p1, t1, p5, t5)
	// result: mem
	for {
		t1 := ssa.AuxToType(v.Aux)
		p1 := v_0
		if v_1.Op != ssaop.OpLoad {
			break
		}
		t2 := v_1.Type
		oldmem := v_1.Args[1]
		p2 := v_1.Args[0]
		mem := v_2
		if mem.Op != ssaop.OpStore {
			break
		}
		t3 := ssa.AuxToType(mem.Aux)
		_ = mem.Args[2]
		p3 := mem.Args[0]
		mem_2 := mem.Args[2]
		if mem_2.Op != ssaop.OpStore {
			break
		}
		t4 := ssa.AuxToType(mem_2.Aux)
		_ = mem_2.Args[2]
		p4 := mem_2.Args[0]
		mem_2_2 := mem_2.Args[2]
		if mem_2_2.Op != ssaop.OpStore {
			break
		}
		t5 := ssa.AuxToType(mem_2_2.Aux)
		_ = mem_2_2.Args[2]
		p5 := mem_2_2.Args[0]
		if oldmem != mem_2_2.Args[2] || !(ssa.IsSamePtr(p1, p2) && t2.Size() == t1.Size() && ssa.Disjoint(p1, t1, p3, t3) && ssa.Disjoint(p1, t1, p4, t4) && ssa.Disjoint(p1, t1, p5, t5)) {
			break
		}
		v.CopyOf(mem)
		return true
	}
	// match: (Store {t} (OffPtr [o] p1) x mem:(Zero [n] p2 _))
	// cond: ssa.IsConstZero(x) && o >= 0 && t.Size() + o <= n && ssa.IsSamePtr(p1, p2)
	// result: mem
	for {
		t := ssa.AuxToType(v.Aux)
		if v_0.Op != ssaop.OpOffPtr {
			break
		}
		o := ssa.AuxIntToInt64(v_0.AuxInt)
		p1 := v_0.Args[0]
		x := v_1
		mem := v_2
		if mem.Op != ssaop.OpZero {
			break
		}
		n := ssa.AuxIntToInt64(mem.AuxInt)
		p2 := mem.Args[0]
		if !(ssa.IsConstZero(x) && o >= 0 && t.Size()+o <= n && ssa.IsSamePtr(p1, p2)) {
			break
		}
		v.CopyOf(mem)
		return true
	}
	// match: (Store {t1} op1:(OffPtr [o1] p1) x mem:(Store {t2} p2 _ (Zero [n] p3 _)))
	// cond: ssa.IsConstZero(x) && o1 >= 0 && t1.Size() + o1 <= n && ssa.IsSamePtr(p1, p3) && ssa.Disjoint(op1, t1, p2, t2)
	// result: mem
	for {
		t1 := ssa.AuxToType(v.Aux)
		op1 := v_0
		if op1.Op != ssaop.OpOffPtr {
			break
		}
		o1 := ssa.AuxIntToInt64(op1.AuxInt)
		p1 := op1.Args[0]
		x := v_1
		mem := v_2
		if mem.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(mem.Aux)
		_ = mem.Args[2]
		p2 := mem.Args[0]
		mem_2 := mem.Args[2]
		if mem_2.Op != ssaop.OpZero {
			break
		}
		n := ssa.AuxIntToInt64(mem_2.AuxInt)
		p3 := mem_2.Args[0]
		if !(ssa.IsConstZero(x) && o1 >= 0 && t1.Size()+o1 <= n && ssa.IsSamePtr(p1, p3) && ssa.Disjoint(op1, t1, p2, t2)) {
			break
		}
		v.CopyOf(mem)
		return true
	}
	// match: (Store {t1} op1:(OffPtr [o1] p1) x mem:(Store {t2} p2 _ (Store {t3} p3 _ (Zero [n] p4 _))))
	// cond: ssa.IsConstZero(x) && o1 >= 0 && t1.Size() + o1 <= n && ssa.IsSamePtr(p1, p4) && ssa.Disjoint(op1, t1, p2, t2) && ssa.Disjoint(op1, t1, p3, t3)
	// result: mem
	for {
		t1 := ssa.AuxToType(v.Aux)
		op1 := v_0
		if op1.Op != ssaop.OpOffPtr {
			break
		}
		o1 := ssa.AuxIntToInt64(op1.AuxInt)
		p1 := op1.Args[0]
		x := v_1
		mem := v_2
		if mem.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(mem.Aux)
		_ = mem.Args[2]
		p2 := mem.Args[0]
		mem_2 := mem.Args[2]
		if mem_2.Op != ssaop.OpStore {
			break
		}
		t3 := ssa.AuxToType(mem_2.Aux)
		_ = mem_2.Args[2]
		p3 := mem_2.Args[0]
		mem_2_2 := mem_2.Args[2]
		if mem_2_2.Op != ssaop.OpZero {
			break
		}
		n := ssa.AuxIntToInt64(mem_2_2.AuxInt)
		p4 := mem_2_2.Args[0]
		if !(ssa.IsConstZero(x) && o1 >= 0 && t1.Size()+o1 <= n && ssa.IsSamePtr(p1, p4) && ssa.Disjoint(op1, t1, p2, t2) && ssa.Disjoint(op1, t1, p3, t3)) {
			break
		}
		v.CopyOf(mem)
		return true
	}
	// match: (Store {t1} op1:(OffPtr [o1] p1) x mem:(Store {t2} p2 _ (Store {t3} p3 _ (Store {t4} p4 _ (Zero [n] p5 _)))))
	// cond: ssa.IsConstZero(x) && o1 >= 0 && t1.Size() + o1 <= n && ssa.IsSamePtr(p1, p5) && ssa.Disjoint(op1, t1, p2, t2) && ssa.Disjoint(op1, t1, p3, t3) && ssa.Disjoint(op1, t1, p4, t4)
	// result: mem
	for {
		t1 := ssa.AuxToType(v.Aux)
		op1 := v_0
		if op1.Op != ssaop.OpOffPtr {
			break
		}
		o1 := ssa.AuxIntToInt64(op1.AuxInt)
		p1 := op1.Args[0]
		x := v_1
		mem := v_2
		if mem.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(mem.Aux)
		_ = mem.Args[2]
		p2 := mem.Args[0]
		mem_2 := mem.Args[2]
		if mem_2.Op != ssaop.OpStore {
			break
		}
		t3 := ssa.AuxToType(mem_2.Aux)
		_ = mem_2.Args[2]
		p3 := mem_2.Args[0]
		mem_2_2 := mem_2.Args[2]
		if mem_2_2.Op != ssaop.OpStore {
			break
		}
		t4 := ssa.AuxToType(mem_2_2.Aux)
		_ = mem_2_2.Args[2]
		p4 := mem_2_2.Args[0]
		mem_2_2_2 := mem_2_2.Args[2]
		if mem_2_2_2.Op != ssaop.OpZero {
			break
		}
		n := ssa.AuxIntToInt64(mem_2_2_2.AuxInt)
		p5 := mem_2_2_2.Args[0]
		if !(ssa.IsConstZero(x) && o1 >= 0 && t1.Size()+o1 <= n && ssa.IsSamePtr(p1, p5) && ssa.Disjoint(op1, t1, p2, t2) && ssa.Disjoint(op1, t1, p3, t3) && ssa.Disjoint(op1, t1, p4, t4)) {
			break
		}
		v.CopyOf(mem)
		return true
	}
	// match: (Store _ (StructMake ___) _)
	// result: ssa.RewriteStructStore(v)
	for {
		if v_1.Op != ssaop.OpStructMake {
			break
		}
		v.CopyOf(ssa.RewriteStructStore(v))
		return true
	}
	// match: (Store {t} dst (Load src mem) mem)
	// cond: !ssa.CanSSA(t)
	// result: (Move {t} [t.Size()] dst src mem)
	for {
		t := ssa.AuxToType(v.Aux)
		dst := v_0
		if v_1.Op != ssaop.OpLoad {
			break
		}
		mem := v_1.Args[1]
		src := v_1.Args[0]
		if mem != v_2 || !(!ssa.CanSSA(t)) {
			break
		}
		v.Reset(ssaop.OpMove)
		v.AuxInt = ssa.Int64ToAuxInt(t.Size())
		v.Aux = ssa.TypeToAux(t)
		v.AddArg3(dst, src, mem)
		return true
	}
	// match: (Store {t} dst (Load src mem) (VarDef {x} mem))
	// cond: !ssa.CanSSA(t)
	// result: (Move {t} [t.Size()] dst src (VarDef {x} mem))
	for {
		t := ssa.AuxToType(v.Aux)
		dst := v_0
		if v_1.Op != ssaop.OpLoad {
			break
		}
		mem := v_1.Args[1]
		src := v_1.Args[0]
		if v_2.Op != ssaop.OpVarDef {
			break
		}
		x := ssa.AuxToSym(v_2.Aux)
		if mem != v_2.Args[0] || !(!ssa.CanSSA(t)) {
			break
		}
		v.Reset(ssaop.OpMove)
		v.AuxInt = ssa.Int64ToAuxInt(t.Size())
		v.Aux = ssa.TypeToAux(t)
		v0 := b.NewValue0(v.Pos, ssaop.OpVarDef, types.TypeMem)
		v0.Aux = ssa.SymToAux(x)
		v0.AddArg(mem)
		v.AddArg3(dst, src, v0)
		return true
	}
	// match: (Store dst (ArrayMake1 e) mem)
	// result: (Store {e.Type} dst e mem)
	for {
		dst := v_0
		if v_1.Op != ssaop.OpArrayMake1 {
			break
		}
		e := v_1.Args[0]
		mem := v_2
		v.Reset(ssaop.OpStore)
		v.Aux = ssa.TypeToAux(e.Type)
		v.AddArg3(dst, e, mem)
		return true
	}
	// match: (Store _ (Empty) mem)
	// result: mem
	for {
		if v_1.Op != ssaop.OpEmpty {
			break
		}
		mem := v_2
		v.CopyOf(mem)
		return true
	}
	// match: (Store (SelectN [0] call:(StaticLECall ___)) x mem:(SelectN [1] call))
	// cond: ssa.IsConstZero(x) && isMalloc(call.Aux)
	// result: mem
	for {
		if v_0.Op != ssaop.OpSelectN || ssa.AuxIntToInt64(v_0.AuxInt) != 0 {
			break
		}
		call := v_0.Args[0]
		if call.Op != ssaop.OpStaticLECall {
			break
		}
		x := v_1
		mem := v_2
		if mem.Op != ssaop.OpSelectN || ssa.AuxIntToInt64(mem.AuxInt) != 1 || call != mem.Args[0] || !(ssa.IsConstZero(x) && isMalloc(call.Aux)) {
			break
		}
		v.CopyOf(mem)
		return true
	}
	// match: (Store (OffPtr (SelectN [0] call:(StaticLECall ___))) x mem:(SelectN [1] call))
	// cond: ssa.IsConstZero(x) && isMalloc(call.Aux)
	// result: mem
	for {
		if v_0.Op != ssaop.OpOffPtr {
			break
		}
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpSelectN || ssa.AuxIntToInt64(v_0_0.AuxInt) != 0 {
			break
		}
		call := v_0_0.Args[0]
		if call.Op != ssaop.OpStaticLECall {
			break
		}
		x := v_1
		mem := v_2
		if mem.Op != ssaop.OpSelectN || ssa.AuxIntToInt64(mem.AuxInt) != 1 || call != mem.Args[0] || !(ssa.IsConstZero(x) && isMalloc(call.Aux)) {
			break
		}
		v.CopyOf(mem)
		return true
	}
	// match: (Store {t1} op1:(OffPtr [o1] p1) d1 m2:(Store {t2} op2:(OffPtr [0] p2) d2 m3:(Move [n] p3 _ mem)))
	// cond: m2.Uses == 1 && m3.Uses == 1 && o1 == t2.Size() && n == t2.Size() + t1.Size() && ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.Clobber(m2, m3)
	// result: (Store {t1} op1 d1 (Store {t2} op2 d2 mem))
	for {
		t1 := ssa.AuxToType(v.Aux)
		op1 := v_0
		if op1.Op != ssaop.OpOffPtr {
			break
		}
		o1 := ssa.AuxIntToInt64(op1.AuxInt)
		p1 := op1.Args[0]
		d1 := v_1
		m2 := v_2
		if m2.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(m2.Aux)
		_ = m2.Args[2]
		op2 := m2.Args[0]
		if op2.Op != ssaop.OpOffPtr || ssa.AuxIntToInt64(op2.AuxInt) != 0 {
			break
		}
		p2 := op2.Args[0]
		d2 := m2.Args[1]
		m3 := m2.Args[2]
		if m3.Op != ssaop.OpMove {
			break
		}
		n := ssa.AuxIntToInt64(m3.AuxInt)
		mem := m3.Args[2]
		p3 := m3.Args[0]
		if !(m2.Uses == 1 && m3.Uses == 1 && o1 == t2.Size() && n == t2.Size()+t1.Size() && ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.Clobber(m2, m3)) {
			break
		}
		v.Reset(ssaop.OpStore)
		v.Aux = ssa.TypeToAux(t1)
		v0 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v0.Aux = ssa.TypeToAux(t2)
		v0.AddArg3(op2, d2, mem)
		v.AddArg3(op1, d1, v0)
		return true
	}
	// match: (Store {t1} op1:(OffPtr [o1] p1) d1 m2:(Store {t2} op2:(OffPtr [o2] p2) d2 m3:(Store {t3} op3:(OffPtr [0] p3) d3 m4:(Move [n] p4 _ mem))))
	// cond: m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && o2 == t3.Size() && o1-o2 == t2.Size() && n == t3.Size() + t2.Size() + t1.Size() && ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.Clobber(m2, m3, m4)
	// result: (Store {t1} op1 d1 (Store {t2} op2 d2 (Store {t3} op3 d3 mem)))
	for {
		t1 := ssa.AuxToType(v.Aux)
		op1 := v_0
		if op1.Op != ssaop.OpOffPtr {
			break
		}
		o1 := ssa.AuxIntToInt64(op1.AuxInt)
		p1 := op1.Args[0]
		d1 := v_1
		m2 := v_2
		if m2.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(m2.Aux)
		_ = m2.Args[2]
		op2 := m2.Args[0]
		if op2.Op != ssaop.OpOffPtr {
			break
		}
		o2 := ssa.AuxIntToInt64(op2.AuxInt)
		p2 := op2.Args[0]
		d2 := m2.Args[1]
		m3 := m2.Args[2]
		if m3.Op != ssaop.OpStore {
			break
		}
		t3 := ssa.AuxToType(m3.Aux)
		_ = m3.Args[2]
		op3 := m3.Args[0]
		if op3.Op != ssaop.OpOffPtr || ssa.AuxIntToInt64(op3.AuxInt) != 0 {
			break
		}
		p3 := op3.Args[0]
		d3 := m3.Args[1]
		m4 := m3.Args[2]
		if m4.Op != ssaop.OpMove {
			break
		}
		n := ssa.AuxIntToInt64(m4.AuxInt)
		mem := m4.Args[2]
		p4 := m4.Args[0]
		if !(m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && o2 == t3.Size() && o1-o2 == t2.Size() && n == t3.Size()+t2.Size()+t1.Size() && ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.Clobber(m2, m3, m4)) {
			break
		}
		v.Reset(ssaop.OpStore)
		v.Aux = ssa.TypeToAux(t1)
		v0 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v0.Aux = ssa.TypeToAux(t2)
		v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v1.Aux = ssa.TypeToAux(t3)
		v1.AddArg3(op3, d3, mem)
		v0.AddArg3(op2, d2, v1)
		v.AddArg3(op1, d1, v0)
		return true
	}
	// match: (Store {t1} op1:(OffPtr [o1] p1) d1 m2:(Store {t2} op2:(OffPtr [o2] p2) d2 m3:(Store {t3} op3:(OffPtr [o3] p3) d3 m4:(Store {t4} op4:(OffPtr [0] p4) d4 m5:(Move [n] p5 _ mem)))))
	// cond: m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && m5.Uses == 1 && o3 == t4.Size() && o2-o3 == t3.Size() && o1-o2 == t2.Size() && n == t4.Size() + t3.Size() + t2.Size() + t1.Size() && ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.IsSamePtr(p4, p5) && ssa.Clobber(m2, m3, m4, m5)
	// result: (Store {t1} op1 d1 (Store {t2} op2 d2 (Store {t3} op3 d3 (Store {t4} op4 d4 mem))))
	for {
		t1 := ssa.AuxToType(v.Aux)
		op1 := v_0
		if op1.Op != ssaop.OpOffPtr {
			break
		}
		o1 := ssa.AuxIntToInt64(op1.AuxInt)
		p1 := op1.Args[0]
		d1 := v_1
		m2 := v_2
		if m2.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(m2.Aux)
		_ = m2.Args[2]
		op2 := m2.Args[0]
		if op2.Op != ssaop.OpOffPtr {
			break
		}
		o2 := ssa.AuxIntToInt64(op2.AuxInt)
		p2 := op2.Args[0]
		d2 := m2.Args[1]
		m3 := m2.Args[2]
		if m3.Op != ssaop.OpStore {
			break
		}
		t3 := ssa.AuxToType(m3.Aux)
		_ = m3.Args[2]
		op3 := m3.Args[0]
		if op3.Op != ssaop.OpOffPtr {
			break
		}
		o3 := ssa.AuxIntToInt64(op3.AuxInt)
		p3 := op3.Args[0]
		d3 := m3.Args[1]
		m4 := m3.Args[2]
		if m4.Op != ssaop.OpStore {
			break
		}
		t4 := ssa.AuxToType(m4.Aux)
		_ = m4.Args[2]
		op4 := m4.Args[0]
		if op4.Op != ssaop.OpOffPtr || ssa.AuxIntToInt64(op4.AuxInt) != 0 {
			break
		}
		p4 := op4.Args[0]
		d4 := m4.Args[1]
		m5 := m4.Args[2]
		if m5.Op != ssaop.OpMove {
			break
		}
		n := ssa.AuxIntToInt64(m5.AuxInt)
		mem := m5.Args[2]
		p5 := m5.Args[0]
		if !(m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && m5.Uses == 1 && o3 == t4.Size() && o2-o3 == t3.Size() && o1-o2 == t2.Size() && n == t4.Size()+t3.Size()+t2.Size()+t1.Size() && ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.IsSamePtr(p4, p5) && ssa.Clobber(m2, m3, m4, m5)) {
			break
		}
		v.Reset(ssaop.OpStore)
		v.Aux = ssa.TypeToAux(t1)
		v0 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v0.Aux = ssa.TypeToAux(t2)
		v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v1.Aux = ssa.TypeToAux(t3)
		v2 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v2.Aux = ssa.TypeToAux(t4)
		v2.AddArg3(op4, d4, mem)
		v1.AddArg3(op3, d3, v2)
		v0.AddArg3(op2, d2, v1)
		v.AddArg3(op1, d1, v0)
		return true
	}
	// match: (Store {t1} op1:(OffPtr [o1] p1) d1 m2:(Store {t2} op2:(OffPtr [0] p2) d2 m3:(Zero [n] p3 mem)))
	// cond: m2.Uses == 1 && m3.Uses == 1 && o1 == t2.Size() && n == t2.Size() + t1.Size() && ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.Clobber(m2, m3)
	// result: (Store {t1} op1 d1 (Store {t2} op2 d2 mem))
	for {
		t1 := ssa.AuxToType(v.Aux)
		op1 := v_0
		if op1.Op != ssaop.OpOffPtr {
			break
		}
		o1 := ssa.AuxIntToInt64(op1.AuxInt)
		p1 := op1.Args[0]
		d1 := v_1
		m2 := v_2
		if m2.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(m2.Aux)
		_ = m2.Args[2]
		op2 := m2.Args[0]
		if op2.Op != ssaop.OpOffPtr || ssa.AuxIntToInt64(op2.AuxInt) != 0 {
			break
		}
		p2 := op2.Args[0]
		d2 := m2.Args[1]
		m3 := m2.Args[2]
		if m3.Op != ssaop.OpZero {
			break
		}
		n := ssa.AuxIntToInt64(m3.AuxInt)
		mem := m3.Args[1]
		p3 := m3.Args[0]
		if !(m2.Uses == 1 && m3.Uses == 1 && o1 == t2.Size() && n == t2.Size()+t1.Size() && ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.Clobber(m2, m3)) {
			break
		}
		v.Reset(ssaop.OpStore)
		v.Aux = ssa.TypeToAux(t1)
		v0 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v0.Aux = ssa.TypeToAux(t2)
		v0.AddArg3(op2, d2, mem)
		v.AddArg3(op1, d1, v0)
		return true
	}
	// match: (Store {t1} op1:(OffPtr [o1] p1) d1 m2:(Store {t2} op2:(OffPtr [o2] p2) d2 m3:(Store {t3} op3:(OffPtr [0] p3) d3 m4:(Zero [n] p4 mem))))
	// cond: m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && o2 == t3.Size() && o1-o2 == t2.Size() && n == t3.Size() + t2.Size() + t1.Size() && ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.Clobber(m2, m3, m4)
	// result: (Store {t1} op1 d1 (Store {t2} op2 d2 (Store {t3} op3 d3 mem)))
	for {
		t1 := ssa.AuxToType(v.Aux)
		op1 := v_0
		if op1.Op != ssaop.OpOffPtr {
			break
		}
		o1 := ssa.AuxIntToInt64(op1.AuxInt)
		p1 := op1.Args[0]
		d1 := v_1
		m2 := v_2
		if m2.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(m2.Aux)
		_ = m2.Args[2]
		op2 := m2.Args[0]
		if op2.Op != ssaop.OpOffPtr {
			break
		}
		o2 := ssa.AuxIntToInt64(op2.AuxInt)
		p2 := op2.Args[0]
		d2 := m2.Args[1]
		m3 := m2.Args[2]
		if m3.Op != ssaop.OpStore {
			break
		}
		t3 := ssa.AuxToType(m3.Aux)
		_ = m3.Args[2]
		op3 := m3.Args[0]
		if op3.Op != ssaop.OpOffPtr || ssa.AuxIntToInt64(op3.AuxInt) != 0 {
			break
		}
		p3 := op3.Args[0]
		d3 := m3.Args[1]
		m4 := m3.Args[2]
		if m4.Op != ssaop.OpZero {
			break
		}
		n := ssa.AuxIntToInt64(m4.AuxInt)
		mem := m4.Args[1]
		p4 := m4.Args[0]
		if !(m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && o2 == t3.Size() && o1-o2 == t2.Size() && n == t3.Size()+t2.Size()+t1.Size() && ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.Clobber(m2, m3, m4)) {
			break
		}
		v.Reset(ssaop.OpStore)
		v.Aux = ssa.TypeToAux(t1)
		v0 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v0.Aux = ssa.TypeToAux(t2)
		v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v1.Aux = ssa.TypeToAux(t3)
		v1.AddArg3(op3, d3, mem)
		v0.AddArg3(op2, d2, v1)
		v.AddArg3(op1, d1, v0)
		return true
	}
	// match: (Store {t1} op1:(OffPtr [o1] p1) d1 m2:(Store {t2} op2:(OffPtr [o2] p2) d2 m3:(Store {t3} op3:(OffPtr [o3] p3) d3 m4:(Store {t4} op4:(OffPtr [0] p4) d4 m5:(Zero [n] p5 mem)))))
	// cond: m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && m5.Uses == 1 && o3 == t4.Size() && o2-o3 == t3.Size() && o1-o2 == t2.Size() && n == t4.Size() + t3.Size() + t2.Size() + t1.Size() && ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.IsSamePtr(p4, p5) && ssa.Clobber(m2, m3, m4, m5)
	// result: (Store {t1} op1 d1 (Store {t2} op2 d2 (Store {t3} op3 d3 (Store {t4} op4 d4 mem))))
	for {
		t1 := ssa.AuxToType(v.Aux)
		op1 := v_0
		if op1.Op != ssaop.OpOffPtr {
			break
		}
		o1 := ssa.AuxIntToInt64(op1.AuxInt)
		p1 := op1.Args[0]
		d1 := v_1
		m2 := v_2
		if m2.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(m2.Aux)
		_ = m2.Args[2]
		op2 := m2.Args[0]
		if op2.Op != ssaop.OpOffPtr {
			break
		}
		o2 := ssa.AuxIntToInt64(op2.AuxInt)
		p2 := op2.Args[0]
		d2 := m2.Args[1]
		m3 := m2.Args[2]
		if m3.Op != ssaop.OpStore {
			break
		}
		t3 := ssa.AuxToType(m3.Aux)
		_ = m3.Args[2]
		op3 := m3.Args[0]
		if op3.Op != ssaop.OpOffPtr {
			break
		}
		o3 := ssa.AuxIntToInt64(op3.AuxInt)
		p3 := op3.Args[0]
		d3 := m3.Args[1]
		m4 := m3.Args[2]
		if m4.Op != ssaop.OpStore {
			break
		}
		t4 := ssa.AuxToType(m4.Aux)
		_ = m4.Args[2]
		op4 := m4.Args[0]
		if op4.Op != ssaop.OpOffPtr || ssa.AuxIntToInt64(op4.AuxInt) != 0 {
			break
		}
		p4 := op4.Args[0]
		d4 := m4.Args[1]
		m5 := m4.Args[2]
		if m5.Op != ssaop.OpZero {
			break
		}
		n := ssa.AuxIntToInt64(m5.AuxInt)
		mem := m5.Args[1]
		p5 := m5.Args[0]
		if !(m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && m5.Uses == 1 && o3 == t4.Size() && o2-o3 == t3.Size() && o1-o2 == t2.Size() && n == t4.Size()+t3.Size()+t2.Size()+t1.Size() && ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.IsSamePtr(p4, p5) && ssa.Clobber(m2, m3, m4, m5)) {
			break
		}
		v.Reset(ssaop.OpStore)
		v.Aux = ssa.TypeToAux(t1)
		v0 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v0.Aux = ssa.TypeToAux(t2)
		v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v1.Aux = ssa.TypeToAux(t3)
		v2 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v2.Aux = ssa.TypeToAux(t4)
		v2.AddArg3(op4, d4, mem)
		v1.AddArg3(op3, d3, v2)
		v0.AddArg3(op2, d2, v1)
		v.AddArg3(op1, d1, v0)
		return true
	}
	return false
}
func rewriteValue_OpStringLen(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (StringLen (StringMake _ (Const64 <t> [c])))
	// result: (Const64 <t> [c])
	for {
		if v_0.Op != ssaop.OpStringMake {
			break
		}
		_ = v_0.Args[1]
		v_0_1 := v_0.Args[1]
		if v_0_1.Op != ssaop.OpConst64 {
			break
		}
		t := v_0_1.Type
		c := ssa.AuxIntToInt64(v_0_1.AuxInt)
		v.Reset(ssaop.OpConst64)
		v.Type = t
		v.AuxInt = ssa.Int64ToAuxInt(c)
		return true
	}
	return false
}
func rewriteValue_OpStringPtr(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (StringPtr (StringMake (Addr <t> {s} base) _))
	// result: (Addr <t> {s} base)
	for {
		if v_0.Op != ssaop.OpStringMake {
			break
		}
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != ssaop.OpAddr {
			break
		}
		t := v_0_0.Type
		s := ssa.AuxToSym(v_0_0.Aux)
		base := v_0_0.Args[0]
		v.Reset(ssaop.OpAddr)
		v.Type = t
		v.Aux = ssa.SymToAux(s)
		v.AddArg(base)
		return true
	}
	return false
}
func rewriteValue_OpStructSelect(v *ssa.Value) bool {
	v_0 := v.Args[0]
	b := v.Block
	// match: (StructSelect [i] x:(StructMake ___))
	// result: x.Args[i]
	for {
		i := ssa.AuxIntToInt64(v.AuxInt)
		x := v_0
		if x.Op != ssaop.OpStructMake {
			break
		}
		v.CopyOf(x.Args[i])
		return true
	}
	// match: (StructSelect [i] x:(Load <t> ptr mem))
	// cond: !ssa.CanSSA(t)
	// result: @x.Block (Load <v.Type> (OffPtr <v.Type.PtrTo()> [t.FieldOff(int(i))] ptr) mem)
	for {
		i := ssa.AuxIntToInt64(v.AuxInt)
		x := v_0
		if x.Op != ssaop.OpLoad {
			break
		}
		t := x.Type
		mem := x.Args[1]
		ptr := x.Args[0]
		if !(!ssa.CanSSA(t)) {
			break
		}
		b = x.Block
		v0 := b.NewValue0(v.Pos, ssaop.OpLoad, v.Type)
		v.CopyOf(v0)
		v1 := b.NewValue0(v.Pos, ssaop.OpOffPtr, v.Type.PtrTo())
		v1.AuxInt = ssa.Int64ToAuxInt(t.FieldOff(int(i)))
		v1.AddArg(ptr)
		v0.AddArg2(v1, mem)
		return true
	}
	// match: (StructSelect (IData x))
	// cond: v.Type.Size() > 0
	// result: (IData x)
	for {
		if v_0.Op != ssaop.OpIData {
			break
		}
		x := v_0.Args[0]
		if !(v.Type.Size() > 0) {
			break
		}
		v.Reset(ssaop.OpIData)
		v.AddArg(x)
		return true
	}
	// match: (StructSelect (IData x))
	// cond: v.Type.Size() == 0
	// result: (Empty)
	for {
		if v_0.Op != ssaop.OpIData {
			break
		}
		if !(v.Type.Size() == 0) {
			break
		}
		v.Reset(ssaop.OpEmpty)
		return true
	}
	return false
}
func rewriteValue_OpSub16(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Sub16 (Const16 [c]) (Const16 [d]))
	// result: (Const16 [c-d])
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		d := ssa.AuxIntToInt16(v_1.AuxInt)
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(c - d)
		return true
	}
	// match: (Sub16 x (Const16 <t> [c]))
	// cond: x.Op != ssaop.OpConst16
	// result: (Add16 (Const16 <t> [-c]) x)
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst16 {
			break
		}
		t := v_1.Type
		c := ssa.AuxIntToInt16(v_1.AuxInt)
		if !(x.Op != ssaop.OpConst16) {
			break
		}
		v.Reset(ssaop.OpAdd16)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
		v0.AuxInt = ssa.Int16ToAuxInt(-c)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Sub16 <t> (Mul16 x y) (Mul16 x z))
	// result: (Mul16 x (Sub16 <t> y z))
	for {
		t := v.Type
		if v_0.Op != ssaop.OpMul16 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			x := v_0_0
			y := v_0_1
			if v_1.Op != ssaop.OpMul16 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if x != v_1_0 {
					continue
				}
				z := v_1_1
				v.Reset(ssaop.OpMul16)
				v0 := b.NewValue0(v.Pos, ssaop.OpSub16, t)
				v0.AddArg2(y, z)
				v.AddArg2(x, v0)
				return true
			}
		}
		break
	}
	// match: (Sub16 x x)
	// result: (Const16 [0])
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(0)
		return true
	}
	// match: (Sub16 (Neg16 x) (Com16 x))
	// result: (Const16 [1])
	for {
		if v_0.Op != ssaop.OpNeg16 {
			break
		}
		x := v_0.Args[0]
		if v_1.Op != ssaop.OpCom16 || x != v_1.Args[0] {
			break
		}
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(1)
		return true
	}
	// match: (Sub16 (Com16 x) (Neg16 x))
	// result: (Const16 [-1])
	for {
		if v_0.Op != ssaop.OpCom16 {
			break
		}
		x := v_0.Args[0]
		if v_1.Op != ssaop.OpNeg16 || x != v_1.Args[0] {
			break
		}
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(-1)
		return true
	}
	// match: (Sub16 (Add16 t x) (Add16 t y))
	// result: (Sub16 x y)
	for {
		if v_0.Op != ssaop.OpAdd16 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			t := v_0_0
			x := v_0_1
			if v_1.Op != ssaop.OpAdd16 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if t != v_1_0 {
					continue
				}
				y := v_1_1
				v.Reset(ssaop.OpSub16)
				v.AddArg2(x, y)
				return true
			}
		}
		break
	}
	// match: (Sub16 x (And16 <t> x y))
	// result: (And16 x (Com16 <t> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpAnd16 {
			break
		}
		t := v_1.Type
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			if x != v_1_0 {
				continue
			}
			y := v_1_1
			v.Reset(ssaop.OpAnd16)
			v0 := b.NewValue0(v.Pos, ssaop.OpCom16, t)
			v0.AddArg(y)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (Sub16 (Add16 x y) x)
	// result: y
	for {
		if v_0.Op != ssaop.OpAdd16 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			x := v_0_0
			y := v_0_1
			if x != v_1 {
				continue
			}
			v.CopyOf(y)
			return true
		}
		break
	}
	// match: (Sub16 (Add16 x y) y)
	// result: x
	for {
		if v_0.Op != ssaop.OpAdd16 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			x := v_0_0
			y := v_0_1
			if y != v_1 {
				continue
			}
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (Sub16 (Sub16 x y) x)
	// result: (Neg16 y)
	for {
		if v_0.Op != ssaop.OpSub16 {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		if x != v_1 {
			break
		}
		v.Reset(ssaop.OpNeg16)
		v.AddArg(y)
		return true
	}
	// match: (Sub16 x (Add16 x y))
	// result: (Neg16 y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAdd16 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			if x != v_1_0 {
				continue
			}
			y := v_1_1
			v.Reset(ssaop.OpNeg16)
			v.AddArg(y)
			return true
		}
		break
	}
	// match: (Sub16 x (Sub16 i:(Const16 <t>) z))
	// cond: (z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16)
	// result: (Sub16 (Add16 <t> x z) i)
	for {
		x := v_0
		if v_1.Op != ssaop.OpSub16 {
			break
		}
		z := v_1.Args[1]
		i := v_1.Args[0]
		if i.Op != ssaop.OpConst16 {
			break
		}
		t := i.Type
		if !(z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16) {
			break
		}
		v.Reset(ssaop.OpSub16)
		v0 := b.NewValue0(v.Pos, ssaop.OpAdd16, t)
		v0.AddArg2(x, z)
		v.AddArg2(v0, i)
		return true
	}
	// match: (Sub16 x (Add16 z i:(Const16 <t>)))
	// cond: (z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16)
	// result: (Sub16 (Sub16 <t> x z) i)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAdd16 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			z := v_1_0
			i := v_1_1
			if i.Op != ssaop.OpConst16 {
				continue
			}
			t := i.Type
			if !(z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16) {
				continue
			}
			v.Reset(ssaop.OpSub16)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub16, t)
			v0.AddArg2(x, z)
			v.AddArg2(v0, i)
			return true
		}
		break
	}
	// match: (Sub16 (Sub16 i:(Const16 <t>) z) x)
	// cond: (z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16)
	// result: (Sub16 i (Add16 <t> z x))
	for {
		if v_0.Op != ssaop.OpSub16 {
			break
		}
		z := v_0.Args[1]
		i := v_0.Args[0]
		if i.Op != ssaop.OpConst16 {
			break
		}
		t := i.Type
		x := v_1
		if !(z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16) {
			break
		}
		v.Reset(ssaop.OpSub16)
		v0 := b.NewValue0(v.Pos, ssaop.OpAdd16, t)
		v0.AddArg2(z, x)
		v.AddArg2(i, v0)
		return true
	}
	// match: (Sub16 (Add16 z i:(Const16 <t>)) x)
	// cond: (z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16)
	// result: (Add16 i (Sub16 <t> z x))
	for {
		if v_0.Op != ssaop.OpAdd16 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			z := v_0_0
			i := v_0_1
			if i.Op != ssaop.OpConst16 {
				continue
			}
			t := i.Type
			x := v_1
			if !(z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16) {
				continue
			}
			v.Reset(ssaop.OpAdd16)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub16, t)
			v0.AddArg2(z, x)
			v.AddArg2(i, v0)
			return true
		}
		break
	}
	// match: (Sub16 (Const16 <t> [c]) (Sub16 (Const16 <t> [d]) x))
	// result: (Add16 (Const16 <t> [c-d]) x)
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		t := v_0.Type
		c := ssa.AuxIntToInt16(v_0.AuxInt)
		if v_1.Op != ssaop.OpSub16 {
			break
		}
		x := v_1.Args[1]
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpConst16 || v_1_0.Type != t {
			break
		}
		d := ssa.AuxIntToInt16(v_1_0.AuxInt)
		v.Reset(ssaop.OpAdd16)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
		v0.AuxInt = ssa.Int16ToAuxInt(c - d)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Sub16 (Const16 <t> [c]) (Add16 (Const16 <t> [d]) x))
	// result: (Sub16 (Const16 <t> [c-d]) x)
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		t := v_0.Type
		c := ssa.AuxIntToInt16(v_0.AuxInt)
		if v_1.Op != ssaop.OpAdd16 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			if v_1_0.Op != ssaop.OpConst16 || v_1_0.Type != t {
				continue
			}
			d := ssa.AuxIntToInt16(v_1_0.AuxInt)
			x := v_1_1
			v.Reset(ssaop.OpSub16)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
			v0.AuxInt = ssa.Int16ToAuxInt(c - d)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpSub32(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Sub32 (Const32 [c]) (Const32 [d]))
	// result: (Const32 [c-d])
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		d := ssa.AuxIntToInt32(v_1.AuxInt)
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(c - d)
		return true
	}
	// match: (Sub32 x (Const32 <t> [c]))
	// cond: x.Op != ssaop.OpConst32
	// result: (Add32 (Const32 <t> [-c]) x)
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst32 {
			break
		}
		t := v_1.Type
		c := ssa.AuxIntToInt32(v_1.AuxInt)
		if !(x.Op != ssaop.OpConst32) {
			break
		}
		v.Reset(ssaop.OpAdd32)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
		v0.AuxInt = ssa.Int32ToAuxInt(-c)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Sub32 <t> (Mul32 x y) (Mul32 x z))
	// result: (Mul32 x (Sub32 <t> y z))
	for {
		t := v.Type
		if v_0.Op != ssaop.OpMul32 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			x := v_0_0
			y := v_0_1
			if v_1.Op != ssaop.OpMul32 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if x != v_1_0 {
					continue
				}
				z := v_1_1
				v.Reset(ssaop.OpMul32)
				v0 := b.NewValue0(v.Pos, ssaop.OpSub32, t)
				v0.AddArg2(y, z)
				v.AddArg2(x, v0)
				return true
			}
		}
		break
	}
	// match: (Sub32 x x)
	// result: (Const32 [0])
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(0)
		return true
	}
	// match: (Sub32 (Neg32 x) (Com32 x))
	// result: (Const32 [1])
	for {
		if v_0.Op != ssaop.OpNeg32 {
			break
		}
		x := v_0.Args[0]
		if v_1.Op != ssaop.OpCom32 || x != v_1.Args[0] {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(1)
		return true
	}
	// match: (Sub32 (Com32 x) (Neg32 x))
	// result: (Const32 [-1])
	for {
		if v_0.Op != ssaop.OpCom32 {
			break
		}
		x := v_0.Args[0]
		if v_1.Op != ssaop.OpNeg32 || x != v_1.Args[0] {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(-1)
		return true
	}
	// match: (Sub32 (Add32 t x) (Add32 t y))
	// result: (Sub32 x y)
	for {
		if v_0.Op != ssaop.OpAdd32 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			t := v_0_0
			x := v_0_1
			if v_1.Op != ssaop.OpAdd32 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if t != v_1_0 {
					continue
				}
				y := v_1_1
				v.Reset(ssaop.OpSub32)
				v.AddArg2(x, y)
				return true
			}
		}
		break
	}
	// match: (Sub32 x (And32 <t> x y))
	// result: (And32 x (Com32 <t> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpAnd32 {
			break
		}
		t := v_1.Type
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			if x != v_1_0 {
				continue
			}
			y := v_1_1
			v.Reset(ssaop.OpAnd32)
			v0 := b.NewValue0(v.Pos, ssaop.OpCom32, t)
			v0.AddArg(y)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (Sub32 (Add32 x y) x)
	// result: y
	for {
		if v_0.Op != ssaop.OpAdd32 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			x := v_0_0
			y := v_0_1
			if x != v_1 {
				continue
			}
			v.CopyOf(y)
			return true
		}
		break
	}
	// match: (Sub32 (Add32 x y) y)
	// result: x
	for {
		if v_0.Op != ssaop.OpAdd32 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			x := v_0_0
			y := v_0_1
			if y != v_1 {
				continue
			}
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (Sub32 (Sub32 x y) x)
	// result: (Neg32 y)
	for {
		if v_0.Op != ssaop.OpSub32 {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		if x != v_1 {
			break
		}
		v.Reset(ssaop.OpNeg32)
		v.AddArg(y)
		return true
	}
	// match: (Sub32 x (Add32 x y))
	// result: (Neg32 y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAdd32 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			if x != v_1_0 {
				continue
			}
			y := v_1_1
			v.Reset(ssaop.OpNeg32)
			v.AddArg(y)
			return true
		}
		break
	}
	// match: (Sub32 x (Sub32 i:(Const32 <t>) z))
	// cond: (z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32)
	// result: (Sub32 (Add32 <t> x z) i)
	for {
		x := v_0
		if v_1.Op != ssaop.OpSub32 {
			break
		}
		z := v_1.Args[1]
		i := v_1.Args[0]
		if i.Op != ssaop.OpConst32 {
			break
		}
		t := i.Type
		if !(z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32) {
			break
		}
		v.Reset(ssaop.OpSub32)
		v0 := b.NewValue0(v.Pos, ssaop.OpAdd32, t)
		v0.AddArg2(x, z)
		v.AddArg2(v0, i)
		return true
	}
	// match: (Sub32 x (Add32 z i:(Const32 <t>)))
	// cond: (z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32)
	// result: (Sub32 (Sub32 <t> x z) i)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAdd32 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			z := v_1_0
			i := v_1_1
			if i.Op != ssaop.OpConst32 {
				continue
			}
			t := i.Type
			if !(z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32) {
				continue
			}
			v.Reset(ssaop.OpSub32)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub32, t)
			v0.AddArg2(x, z)
			v.AddArg2(v0, i)
			return true
		}
		break
	}
	// match: (Sub32 (Sub32 i:(Const32 <t>) z) x)
	// cond: (z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32)
	// result: (Sub32 i (Add32 <t> z x))
	for {
		if v_0.Op != ssaop.OpSub32 {
			break
		}
		z := v_0.Args[1]
		i := v_0.Args[0]
		if i.Op != ssaop.OpConst32 {
			break
		}
		t := i.Type
		x := v_1
		if !(z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32) {
			break
		}
		v.Reset(ssaop.OpSub32)
		v0 := b.NewValue0(v.Pos, ssaop.OpAdd32, t)
		v0.AddArg2(z, x)
		v.AddArg2(i, v0)
		return true
	}
	// match: (Sub32 (Add32 z i:(Const32 <t>)) x)
	// cond: (z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32)
	// result: (Add32 i (Sub32 <t> z x))
	for {
		if v_0.Op != ssaop.OpAdd32 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			z := v_0_0
			i := v_0_1
			if i.Op != ssaop.OpConst32 {
				continue
			}
			t := i.Type
			x := v_1
			if !(z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32) {
				continue
			}
			v.Reset(ssaop.OpAdd32)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub32, t)
			v0.AddArg2(z, x)
			v.AddArg2(i, v0)
			return true
		}
		break
	}
	// match: (Sub32 (Const32 <t> [c]) (Sub32 (Const32 <t> [d]) x))
	// result: (Add32 (Const32 <t> [c-d]) x)
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		t := v_0.Type
		c := ssa.AuxIntToInt32(v_0.AuxInt)
		if v_1.Op != ssaop.OpSub32 {
			break
		}
		x := v_1.Args[1]
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpConst32 || v_1_0.Type != t {
			break
		}
		d := ssa.AuxIntToInt32(v_1_0.AuxInt)
		v.Reset(ssaop.OpAdd32)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
		v0.AuxInt = ssa.Int32ToAuxInt(c - d)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Sub32 (Const32 <t> [c]) (Add32 (Const32 <t> [d]) x))
	// result: (Sub32 (Const32 <t> [c-d]) x)
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		t := v_0.Type
		c := ssa.AuxIntToInt32(v_0.AuxInt)
		if v_1.Op != ssaop.OpAdd32 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			if v_1_0.Op != ssaop.OpConst32 || v_1_0.Type != t {
				continue
			}
			d := ssa.AuxIntToInt32(v_1_0.AuxInt)
			x := v_1_1
			v.Reset(ssaop.OpSub32)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
			v0.AuxInt = ssa.Int32ToAuxInt(c - d)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpSub32F(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	// match: (Sub32F (Const32F [c]) (Const32F [d]))
	// cond: c-d == c-d
	// result: (Const32F [c-d])
	for {
		if v_0.Op != ssaop.OpConst32F {
			break
		}
		c := ssa.AuxIntToFloat32(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst32F {
			break
		}
		d := ssa.AuxIntToFloat32(v_1.AuxInt)
		if !(c-d == c-d) {
			break
		}
		v.Reset(ssaop.OpConst32F)
		v.AuxInt = ssa.Float32ToAuxInt(c - d)
		return true
	}
	return false
}
func rewriteValue_OpSub64(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Sub64 (Const64 [c]) (Const64 [d]))
	// result: (Const64 [c-d])
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		d := ssa.AuxIntToInt64(v_1.AuxInt)
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(c - d)
		return true
	}
	// match: (Sub64 x (Const64 <t> [c]))
	// cond: x.Op != ssaop.OpConst64
	// result: (Add64 (Const64 <t> [-c]) x)
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		t := v_1.Type
		c := ssa.AuxIntToInt64(v_1.AuxInt)
		if !(x.Op != ssaop.OpConst64) {
			break
		}
		v.Reset(ssaop.OpAdd64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(-c)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Sub64 <t> (Mul64 x y) (Mul64 x z))
	// result: (Mul64 x (Sub64 <t> y z))
	for {
		t := v.Type
		if v_0.Op != ssaop.OpMul64 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			x := v_0_0
			y := v_0_1
			if v_1.Op != ssaop.OpMul64 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if x != v_1_0 {
					continue
				}
				z := v_1_1
				v.Reset(ssaop.OpMul64)
				v0 := b.NewValue0(v.Pos, ssaop.OpSub64, t)
				v0.AddArg2(y, z)
				v.AddArg2(x, v0)
				return true
			}
		}
		break
	}
	// match: (Sub64 x x)
	// result: (Const64 [0])
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(0)
		return true
	}
	// match: (Sub64 (Neg64 x) (Com64 x))
	// result: (Const64 [1])
	for {
		if v_0.Op != ssaop.OpNeg64 {
			break
		}
		x := v_0.Args[0]
		if v_1.Op != ssaop.OpCom64 || x != v_1.Args[0] {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(1)
		return true
	}
	// match: (Sub64 (Com64 x) (Neg64 x))
	// result: (Const64 [-1])
	for {
		if v_0.Op != ssaop.OpCom64 {
			break
		}
		x := v_0.Args[0]
		if v_1.Op != ssaop.OpNeg64 || x != v_1.Args[0] {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(-1)
		return true
	}
	// match: (Sub64 (Add64 t x) (Add64 t y))
	// result: (Sub64 x y)
	for {
		if v_0.Op != ssaop.OpAdd64 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			t := v_0_0
			x := v_0_1
			if v_1.Op != ssaop.OpAdd64 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if t != v_1_0 {
					continue
				}
				y := v_1_1
				v.Reset(ssaop.OpSub64)
				v.AddArg2(x, y)
				return true
			}
		}
		break
	}
	// match: (Sub64 x (And64 <t> x y))
	// result: (And64 x (Com64 <t> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpAnd64 {
			break
		}
		t := v_1.Type
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			if x != v_1_0 {
				continue
			}
			y := v_1_1
			v.Reset(ssaop.OpAnd64)
			v0 := b.NewValue0(v.Pos, ssaop.OpCom64, t)
			v0.AddArg(y)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (Sub64 (Add64 x y) x)
	// result: y
	for {
		if v_0.Op != ssaop.OpAdd64 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			x := v_0_0
			y := v_0_1
			if x != v_1 {
				continue
			}
			v.CopyOf(y)
			return true
		}
		break
	}
	// match: (Sub64 (Add64 x y) y)
	// result: x
	for {
		if v_0.Op != ssaop.OpAdd64 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			x := v_0_0
			y := v_0_1
			if y != v_1 {
				continue
			}
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (Sub64 (Sub64 x y) x)
	// result: (Neg64 y)
	for {
		if v_0.Op != ssaop.OpSub64 {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		if x != v_1 {
			break
		}
		v.Reset(ssaop.OpNeg64)
		v.AddArg(y)
		return true
	}
	// match: (Sub64 x (Add64 x y))
	// result: (Neg64 y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAdd64 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			if x != v_1_0 {
				continue
			}
			y := v_1_1
			v.Reset(ssaop.OpNeg64)
			v.AddArg(y)
			return true
		}
		break
	}
	// match: (Sub64 x (Sub64 i:(Const64 <t>) z))
	// cond: (z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64)
	// result: (Sub64 (Add64 <t> x z) i)
	for {
		x := v_0
		if v_1.Op != ssaop.OpSub64 {
			break
		}
		z := v_1.Args[1]
		i := v_1.Args[0]
		if i.Op != ssaop.OpConst64 {
			break
		}
		t := i.Type
		if !(z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64) {
			break
		}
		v.Reset(ssaop.OpSub64)
		v0 := b.NewValue0(v.Pos, ssaop.OpAdd64, t)
		v0.AddArg2(x, z)
		v.AddArg2(v0, i)
		return true
	}
	// match: (Sub64 x (Add64 z i:(Const64 <t>)))
	// cond: (z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64)
	// result: (Sub64 (Sub64 <t> x z) i)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAdd64 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			z := v_1_0
			i := v_1_1
			if i.Op != ssaop.OpConst64 {
				continue
			}
			t := i.Type
			if !(z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64) {
				continue
			}
			v.Reset(ssaop.OpSub64)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub64, t)
			v0.AddArg2(x, z)
			v.AddArg2(v0, i)
			return true
		}
		break
	}
	// match: (Sub64 (Sub64 i:(Const64 <t>) z) x)
	// cond: (z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64)
	// result: (Sub64 i (Add64 <t> z x))
	for {
		if v_0.Op != ssaop.OpSub64 {
			break
		}
		z := v_0.Args[1]
		i := v_0.Args[0]
		if i.Op != ssaop.OpConst64 {
			break
		}
		t := i.Type
		x := v_1
		if !(z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64) {
			break
		}
		v.Reset(ssaop.OpSub64)
		v0 := b.NewValue0(v.Pos, ssaop.OpAdd64, t)
		v0.AddArg2(z, x)
		v.AddArg2(i, v0)
		return true
	}
	// match: (Sub64 (Add64 z i:(Const64 <t>)) x)
	// cond: (z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64)
	// result: (Add64 i (Sub64 <t> z x))
	for {
		if v_0.Op != ssaop.OpAdd64 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			z := v_0_0
			i := v_0_1
			if i.Op != ssaop.OpConst64 {
				continue
			}
			t := i.Type
			x := v_1
			if !(z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64) {
				continue
			}
			v.Reset(ssaop.OpAdd64)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub64, t)
			v0.AddArg2(z, x)
			v.AddArg2(i, v0)
			return true
		}
		break
	}
	// match: (Sub64 (Const64 <t> [c]) (Sub64 (Const64 <t> [d]) x))
	// result: (Add64 (Const64 <t> [c-d]) x)
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		t := v_0.Type
		c := ssa.AuxIntToInt64(v_0.AuxInt)
		if v_1.Op != ssaop.OpSub64 {
			break
		}
		x := v_1.Args[1]
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpConst64 || v_1_0.Type != t {
			break
		}
		d := ssa.AuxIntToInt64(v_1_0.AuxInt)
		v.Reset(ssaop.OpAdd64)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(c - d)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Sub64 (Const64 <t> [c]) (Add64 (Const64 <t> [d]) x))
	// result: (Sub64 (Const64 <t> [c-d]) x)
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		t := v_0.Type
		c := ssa.AuxIntToInt64(v_0.AuxInt)
		if v_1.Op != ssaop.OpAdd64 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			if v_1_0.Op != ssaop.OpConst64 || v_1_0.Type != t {
				continue
			}
			d := ssa.AuxIntToInt64(v_1_0.AuxInt)
			x := v_1_1
			v.Reset(ssaop.OpSub64)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
			v0.AuxInt = ssa.Int64ToAuxInt(c - d)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpSub64F(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	// match: (Sub64F (Const64F [c]) (Const64F [d]))
	// cond: c-d == c-d
	// result: (Const64F [c-d])
	for {
		if v_0.Op != ssaop.OpConst64F {
			break
		}
		c := ssa.AuxIntToFloat64(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst64F {
			break
		}
		d := ssa.AuxIntToFloat64(v_1.AuxInt)
		if !(c-d == c-d) {
			break
		}
		v.Reset(ssaop.OpConst64F)
		v.AuxInt = ssa.Float64ToAuxInt(c - d)
		return true
	}
	return false
}
func rewriteValue_OpSub64borrow(v *ssa.Value) bool {
	v_2 := v.Args[2]
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Sub64borrow (Const64 <t> [x]) (Const64 [y]) (Const64 [borrowVal]))
	// cond: borrowVal >= 0 && borrowVal <= 1
	// result: (MakeTuple (Const64 <t> [bitsSub64(x, y, borrowVal).diff]) (Const64 <t> [bitsSub64(x, y, borrowVal).borrow]))
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		t := v_0.Type
		x := ssa.AuxIntToInt64(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst64 {
			break
		}
		y := ssa.AuxIntToInt64(v_1.AuxInt)
		if v_2.Op != ssaop.OpConst64 {
			break
		}
		borrowVal := ssa.AuxIntToInt64(v_2.AuxInt)
		if !(borrowVal >= 0 && borrowVal <= 1) {
			break
		}
		v.Reset(ssaop.OpMakeTuple)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v0.AuxInt = ssa.Int64ToAuxInt(bitsSub64(x, y, borrowVal).diff)
		v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
		v1.AuxInt = ssa.Int64ToAuxInt(bitsSub64(x, y, borrowVal).borrow)
		v.AddArg2(v0, v1)
		return true
	}
	return false
}
func rewriteValue_OpSub8(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Sub8 (Const8 [c]) (Const8 [d]))
	// result: (Const8 [c-d])
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_0.AuxInt)
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		d := ssa.AuxIntToInt8(v_1.AuxInt)
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(c - d)
		return true
	}
	// match: (Sub8 x (Const8 <t> [c]))
	// cond: x.Op != ssaop.OpConst8
	// result: (Add8 (Const8 <t> [-c]) x)
	for {
		x := v_0
		if v_1.Op != ssaop.OpConst8 {
			break
		}
		t := v_1.Type
		c := ssa.AuxIntToInt8(v_1.AuxInt)
		if !(x.Op != ssaop.OpConst8) {
			break
		}
		v.Reset(ssaop.OpAdd8)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
		v0.AuxInt = ssa.Int8ToAuxInt(-c)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Sub8 <t> (Mul8 x y) (Mul8 x z))
	// result: (Mul8 x (Sub8 <t> y z))
	for {
		t := v.Type
		if v_0.Op != ssaop.OpMul8 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			x := v_0_0
			y := v_0_1
			if v_1.Op != ssaop.OpMul8 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if x != v_1_0 {
					continue
				}
				z := v_1_1
				v.Reset(ssaop.OpMul8)
				v0 := b.NewValue0(v.Pos, ssaop.OpSub8, t)
				v0.AddArg2(y, z)
				v.AddArg2(x, v0)
				return true
			}
		}
		break
	}
	// match: (Sub8 x x)
	// result: (Const8 [0])
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(0)
		return true
	}
	// match: (Sub8 (Neg8 x) (Com8 x))
	// result: (Const8 [1])
	for {
		if v_0.Op != ssaop.OpNeg8 {
			break
		}
		x := v_0.Args[0]
		if v_1.Op != ssaop.OpCom8 || x != v_1.Args[0] {
			break
		}
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(1)
		return true
	}
	// match: (Sub8 (Com8 x) (Neg8 x))
	// result: (Const8 [-1])
	for {
		if v_0.Op != ssaop.OpCom8 {
			break
		}
		x := v_0.Args[0]
		if v_1.Op != ssaop.OpNeg8 || x != v_1.Args[0] {
			break
		}
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(-1)
		return true
	}
	// match: (Sub8 (Add8 t x) (Add8 t y))
	// result: (Sub8 x y)
	for {
		if v_0.Op != ssaop.OpAdd8 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			t := v_0_0
			x := v_0_1
			if v_1.Op != ssaop.OpAdd8 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if t != v_1_0 {
					continue
				}
				y := v_1_1
				v.Reset(ssaop.OpSub8)
				v.AddArg2(x, y)
				return true
			}
		}
		break
	}
	// match: (Sub8 x (And8 <t> x y))
	// result: (And8 x (Com8 <t> y))
	for {
		x := v_0
		if v_1.Op != ssaop.OpAnd8 {
			break
		}
		t := v_1.Type
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			if x != v_1_0 {
				continue
			}
			y := v_1_1
			v.Reset(ssaop.OpAnd8)
			v0 := b.NewValue0(v.Pos, ssaop.OpCom8, t)
			v0.AddArg(y)
			v.AddArg2(x, v0)
			return true
		}
		break
	}
	// match: (Sub8 (Add8 x y) x)
	// result: y
	for {
		if v_0.Op != ssaop.OpAdd8 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			x := v_0_0
			y := v_0_1
			if x != v_1 {
				continue
			}
			v.CopyOf(y)
			return true
		}
		break
	}
	// match: (Sub8 (Add8 x y) y)
	// result: x
	for {
		if v_0.Op != ssaop.OpAdd8 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			x := v_0_0
			y := v_0_1
			if y != v_1 {
				continue
			}
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (Sub8 (Sub8 x y) x)
	// result: (Neg8 y)
	for {
		if v_0.Op != ssaop.OpSub8 {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		if x != v_1 {
			break
		}
		v.Reset(ssaop.OpNeg8)
		v.AddArg(y)
		return true
	}
	// match: (Sub8 x (Add8 x y))
	// result: (Neg8 y)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAdd8 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			if x != v_1_0 {
				continue
			}
			y := v_1_1
			v.Reset(ssaop.OpNeg8)
			v.AddArg(y)
			return true
		}
		break
	}
	// match: (Sub8 x (Sub8 i:(Const8 <t>) z))
	// cond: (z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8)
	// result: (Sub8 (Add8 <t> x z) i)
	for {
		x := v_0
		if v_1.Op != ssaop.OpSub8 {
			break
		}
		z := v_1.Args[1]
		i := v_1.Args[0]
		if i.Op != ssaop.OpConst8 {
			break
		}
		t := i.Type
		if !(z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8) {
			break
		}
		v.Reset(ssaop.OpSub8)
		v0 := b.NewValue0(v.Pos, ssaop.OpAdd8, t)
		v0.AddArg2(x, z)
		v.AddArg2(v0, i)
		return true
	}
	// match: (Sub8 x (Add8 z i:(Const8 <t>)))
	// cond: (z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8)
	// result: (Sub8 (Sub8 <t> x z) i)
	for {
		x := v_0
		if v_1.Op != ssaop.OpAdd8 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			z := v_1_0
			i := v_1_1
			if i.Op != ssaop.OpConst8 {
				continue
			}
			t := i.Type
			if !(z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8) {
				continue
			}
			v.Reset(ssaop.OpSub8)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub8, t)
			v0.AddArg2(x, z)
			v.AddArg2(v0, i)
			return true
		}
		break
	}
	// match: (Sub8 (Sub8 i:(Const8 <t>) z) x)
	// cond: (z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8)
	// result: (Sub8 i (Add8 <t> z x))
	for {
		if v_0.Op != ssaop.OpSub8 {
			break
		}
		z := v_0.Args[1]
		i := v_0.Args[0]
		if i.Op != ssaop.OpConst8 {
			break
		}
		t := i.Type
		x := v_1
		if !(z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8) {
			break
		}
		v.Reset(ssaop.OpSub8)
		v0 := b.NewValue0(v.Pos, ssaop.OpAdd8, t)
		v0.AddArg2(z, x)
		v.AddArg2(i, v0)
		return true
	}
	// match: (Sub8 (Add8 z i:(Const8 <t>)) x)
	// cond: (z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8)
	// result: (Add8 i (Sub8 <t> z x))
	for {
		if v_0.Op != ssaop.OpAdd8 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			z := v_0_0
			i := v_0_1
			if i.Op != ssaop.OpConst8 {
				continue
			}
			t := i.Type
			x := v_1
			if !(z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8) {
				continue
			}
			v.Reset(ssaop.OpAdd8)
			v0 := b.NewValue0(v.Pos, ssaop.OpSub8, t)
			v0.AddArg2(z, x)
			v.AddArg2(i, v0)
			return true
		}
		break
	}
	// match: (Sub8 (Const8 <t> [c]) (Sub8 (Const8 <t> [d]) x))
	// result: (Add8 (Const8 <t> [c-d]) x)
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		t := v_0.Type
		c := ssa.AuxIntToInt8(v_0.AuxInt)
		if v_1.Op != ssaop.OpSub8 {
			break
		}
		x := v_1.Args[1]
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != ssaop.OpConst8 || v_1_0.Type != t {
			break
		}
		d := ssa.AuxIntToInt8(v_1_0.AuxInt)
		v.Reset(ssaop.OpAdd8)
		v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
		v0.AuxInt = ssa.Int8ToAuxInt(c - d)
		v.AddArg2(v0, x)
		return true
	}
	// match: (Sub8 (Const8 <t> [c]) (Add8 (Const8 <t> [d]) x))
	// result: (Sub8 (Const8 <t> [c-d]) x)
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		t := v_0.Type
		c := ssa.AuxIntToInt8(v_0.AuxInt)
		if v_1.Op != ssaop.OpAdd8 {
			break
		}
		_ = v_1.Args[1]
		v_1_0 := v_1.Args[0]
		v_1_1 := v_1.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 {
			if v_1_0.Op != ssaop.OpConst8 || v_1_0.Type != t {
				continue
			}
			d := ssa.AuxIntToInt8(v_1_0.AuxInt)
			x := v_1_1
			v.Reset(ssaop.OpSub8)
			v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
			v0.AuxInt = ssa.Int8ToAuxInt(c - d)
			v.AddArg2(v0, x)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpTrunc(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (Trunc (Const64F [c]))
	// result: (Const64F [math.Trunc(c)])
	for {
		if v_0.Op != ssaop.OpConst64F {
			break
		}
		c := ssa.AuxIntToFloat64(v_0.AuxInt)
		v.Reset(ssaop.OpConst64F)
		v.AuxInt = ssa.Float64ToAuxInt(math.Trunc(c))
		return true
	}
	return false
}
func rewriteValue_OpTrunc16to8(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (Trunc16to8 (Const16 [c]))
	// result: (Const8 [int8(c)])
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_0.AuxInt)
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(int8(c))
		return true
	}
	// match: (Trunc16to8 (ZeroExt8to16 x))
	// result: x
	for {
		if v_0.Op != ssaop.OpZeroExt8to16 {
			break
		}
		x := v_0.Args[0]
		v.CopyOf(x)
		return true
	}
	// match: (Trunc16to8 (SignExt8to16 x))
	// result: x
	for {
		if v_0.Op != ssaop.OpSignExt8to16 {
			break
		}
		x := v_0.Args[0]
		v.CopyOf(x)
		return true
	}
	// match: (Trunc16to8 (And16 (Const16 [y]) x))
	// cond: y&0xFF == 0xFF
	// result: (Trunc16to8 x)
	for {
		if v_0.Op != ssaop.OpAnd16 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			if v_0_0.Op != ssaop.OpConst16 {
				continue
			}
			y := ssa.AuxIntToInt16(v_0_0.AuxInt)
			x := v_0_1
			if !(y&0xFF == 0xFF) {
				continue
			}
			v.Reset(ssaop.OpTrunc16to8)
			v.AddArg(x)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpTrunc32to16(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (Trunc32to16 (Const32 [c]))
	// result: (Const16 [int16(c)])
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_0.AuxInt)
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(int16(c))
		return true
	}
	// match: (Trunc32to16 (ZeroExt8to32 x))
	// result: (ZeroExt8to16 x)
	for {
		if v_0.Op != ssaop.OpZeroExt8to32 {
			break
		}
		x := v_0.Args[0]
		v.Reset(ssaop.OpZeroExt8to16)
		v.AddArg(x)
		return true
	}
	// match: (Trunc32to16 (ZeroExt16to32 x))
	// result: x
	for {
		if v_0.Op != ssaop.OpZeroExt16to32 {
			break
		}
		x := v_0.Args[0]
		v.CopyOf(x)
		return true
	}
	// match: (Trunc32to16 (SignExt8to32 x))
	// result: (SignExt8to16 x)
	for {
		if v_0.Op != ssaop.OpSignExt8to32 {
			break
		}
		x := v_0.Args[0]
		v.Reset(ssaop.OpSignExt8to16)
		v.AddArg(x)
		return true
	}
	// match: (Trunc32to16 (SignExt16to32 x))
	// result: x
	for {
		if v_0.Op != ssaop.OpSignExt16to32 {
			break
		}
		x := v_0.Args[0]
		v.CopyOf(x)
		return true
	}
	// match: (Trunc32to16 (And32 (Const32 [y]) x))
	// cond: y&0xFFFF == 0xFFFF
	// result: (Trunc32to16 x)
	for {
		if v_0.Op != ssaop.OpAnd32 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			if v_0_0.Op != ssaop.OpConst32 {
				continue
			}
			y := ssa.AuxIntToInt32(v_0_0.AuxInt)
			x := v_0_1
			if !(y&0xFFFF == 0xFFFF) {
				continue
			}
			v.Reset(ssaop.OpTrunc32to16)
			v.AddArg(x)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpTrunc32to8(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (Trunc32to8 (Const32 [c]))
	// result: (Const8 [int8(c)])
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_0.AuxInt)
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(int8(c))
		return true
	}
	// match: (Trunc32to8 (ZeroExt8to32 x))
	// result: x
	for {
		if v_0.Op != ssaop.OpZeroExt8to32 {
			break
		}
		x := v_0.Args[0]
		v.CopyOf(x)
		return true
	}
	// match: (Trunc32to8 (SignExt8to32 x))
	// result: x
	for {
		if v_0.Op != ssaop.OpSignExt8to32 {
			break
		}
		x := v_0.Args[0]
		v.CopyOf(x)
		return true
	}
	// match: (Trunc32to8 (And32 (Const32 [y]) x))
	// cond: y&0xFF == 0xFF
	// result: (Trunc32to8 x)
	for {
		if v_0.Op != ssaop.OpAnd32 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			if v_0_0.Op != ssaop.OpConst32 {
				continue
			}
			y := ssa.AuxIntToInt32(v_0_0.AuxInt)
			x := v_0_1
			if !(y&0xFF == 0xFF) {
				continue
			}
			v.Reset(ssaop.OpTrunc32to8)
			v.AddArg(x)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpTrunc64to16(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (Trunc64to16 (Const64 [c]))
	// result: (Const16 [int16(c)])
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0.AuxInt)
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(int16(c))
		return true
	}
	// match: (Trunc64to16 (ZeroExt8to64 x))
	// result: (ZeroExt8to16 x)
	for {
		if v_0.Op != ssaop.OpZeroExt8to64 {
			break
		}
		x := v_0.Args[0]
		v.Reset(ssaop.OpZeroExt8to16)
		v.AddArg(x)
		return true
	}
	// match: (Trunc64to16 (ZeroExt16to64 x))
	// result: x
	for {
		if v_0.Op != ssaop.OpZeroExt16to64 {
			break
		}
		x := v_0.Args[0]
		v.CopyOf(x)
		return true
	}
	// match: (Trunc64to16 (SignExt8to64 x))
	// result: (SignExt8to16 x)
	for {
		if v_0.Op != ssaop.OpSignExt8to64 {
			break
		}
		x := v_0.Args[0]
		v.Reset(ssaop.OpSignExt8to16)
		v.AddArg(x)
		return true
	}
	// match: (Trunc64to16 (SignExt16to64 x))
	// result: x
	for {
		if v_0.Op != ssaop.OpSignExt16to64 {
			break
		}
		x := v_0.Args[0]
		v.CopyOf(x)
		return true
	}
	// match: (Trunc64to16 (And64 (Const64 [y]) x))
	// cond: y&0xFFFF == 0xFFFF
	// result: (Trunc64to16 x)
	for {
		if v_0.Op != ssaop.OpAnd64 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			if v_0_0.Op != ssaop.OpConst64 {
				continue
			}
			y := ssa.AuxIntToInt64(v_0_0.AuxInt)
			x := v_0_1
			if !(y&0xFFFF == 0xFFFF) {
				continue
			}
			v.Reset(ssaop.OpTrunc64to16)
			v.AddArg(x)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpTrunc64to32(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (Trunc64to32 (Const64 [c]))
	// result: (Const32 [int32(c)])
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0.AuxInt)
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(int32(c))
		return true
	}
	// match: (Trunc64to32 (ZeroExt8to64 x))
	// result: (ZeroExt8to32 x)
	for {
		if v_0.Op != ssaop.OpZeroExt8to64 {
			break
		}
		x := v_0.Args[0]
		v.Reset(ssaop.OpZeroExt8to32)
		v.AddArg(x)
		return true
	}
	// match: (Trunc64to32 (ZeroExt16to64 x))
	// result: (ZeroExt16to32 x)
	for {
		if v_0.Op != ssaop.OpZeroExt16to64 {
			break
		}
		x := v_0.Args[0]
		v.Reset(ssaop.OpZeroExt16to32)
		v.AddArg(x)
		return true
	}
	// match: (Trunc64to32 (ZeroExt32to64 x))
	// result: x
	for {
		if v_0.Op != ssaop.OpZeroExt32to64 {
			break
		}
		x := v_0.Args[0]
		v.CopyOf(x)
		return true
	}
	// match: (Trunc64to32 (SignExt8to64 x))
	// result: (SignExt8to32 x)
	for {
		if v_0.Op != ssaop.OpSignExt8to64 {
			break
		}
		x := v_0.Args[0]
		v.Reset(ssaop.OpSignExt8to32)
		v.AddArg(x)
		return true
	}
	// match: (Trunc64to32 (SignExt16to64 x))
	// result: (SignExt16to32 x)
	for {
		if v_0.Op != ssaop.OpSignExt16to64 {
			break
		}
		x := v_0.Args[0]
		v.Reset(ssaop.OpSignExt16to32)
		v.AddArg(x)
		return true
	}
	// match: (Trunc64to32 (SignExt32to64 x))
	// result: x
	for {
		if v_0.Op != ssaop.OpSignExt32to64 {
			break
		}
		x := v_0.Args[0]
		v.CopyOf(x)
		return true
	}
	// match: (Trunc64to32 (And64 (Const64 [y]) x))
	// cond: y&0xFFFFFFFF == 0xFFFFFFFF
	// result: (Trunc64to32 x)
	for {
		if v_0.Op != ssaop.OpAnd64 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			if v_0_0.Op != ssaop.OpConst64 {
				continue
			}
			y := ssa.AuxIntToInt64(v_0_0.AuxInt)
			x := v_0_1
			if !(y&0xFFFFFFFF == 0xFFFFFFFF) {
				continue
			}
			v.Reset(ssaop.OpTrunc64to32)
			v.AddArg(x)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpTrunc64to8(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (Trunc64to8 (Const64 [c]))
	// result: (Const8 [int8(c)])
	for {
		if v_0.Op != ssaop.OpConst64 {
			break
		}
		c := ssa.AuxIntToInt64(v_0.AuxInt)
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(int8(c))
		return true
	}
	// match: (Trunc64to8 (ZeroExt8to64 x))
	// result: x
	for {
		if v_0.Op != ssaop.OpZeroExt8to64 {
			break
		}
		x := v_0.Args[0]
		v.CopyOf(x)
		return true
	}
	// match: (Trunc64to8 (SignExt8to64 x))
	// result: x
	for {
		if v_0.Op != ssaop.OpSignExt8to64 {
			break
		}
		x := v_0.Args[0]
		v.CopyOf(x)
		return true
	}
	// match: (Trunc64to8 (And64 (Const64 [y]) x))
	// cond: y&0xFF == 0xFF
	// result: (Trunc64to8 x)
	for {
		if v_0.Op != ssaop.OpAnd64 {
			break
		}
		_ = v_0.Args[1]
		v_0_0 := v_0.Args[0]
		v_0_1 := v_0.Args[1]
		for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
			if v_0_0.Op != ssaop.OpConst64 {
				continue
			}
			y := ssa.AuxIntToInt64(v_0_0.AuxInt)
			x := v_0_1
			if !(y&0xFF == 0xFF) {
				continue
			}
			v.Reset(ssaop.OpTrunc64to8)
			v.AddArg(x)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpXor16(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	typ := &b.Func.Config.Types
	// match: (Xor16 (Const16 [c]) (Const16 [d]))
	// result: (Const16 [c^d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 {
				continue
			}
			c := ssa.AuxIntToInt16(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst16 {
				continue
			}
			d := ssa.AuxIntToInt16(v_1.AuxInt)
			v.Reset(ssaop.OpConst16)
			v.AuxInt = ssa.Int16ToAuxInt(c ^ d)
			return true
		}
		break
	}
	// match: (Xor16 x x)
	// result: (Const16 [0])
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(0)
		return true
	}
	// match: (Xor16 (Const16 [0]) x)
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 {
				continue
			}
			x := v_1
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (Xor16 (Com16 x) x)
	// result: (Const16 [-1])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpCom16 {
				continue
			}
			x := v_0.Args[0]
			if x != v_1 {
				continue
			}
			v.Reset(ssaop.OpConst16)
			v.AuxInt = ssa.Int16ToAuxInt(-1)
			return true
		}
		break
	}
	// match: (Xor16 (Const16 [-1]) x)
	// result: (Com16 x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != -1 {
				continue
			}
			x := v_1
			v.Reset(ssaop.OpCom16)
			v.AddArg(x)
			return true
		}
		break
	}
	// match: (Xor16 x (Xor16 x y))
	// result: y
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpXor16 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if x != v_1_0 {
					continue
				}
				y := v_1_1
				v.CopyOf(y)
				return true
			}
		}
		break
	}
	// match: (Xor16 (Xor16 i:(Const16 <t>) z) x)
	// cond: (z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16)
	// result: (Xor16 i (Xor16 <t> z x))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpXor16 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				i := v_0_0
				if i.Op != ssaop.OpConst16 {
					continue
				}
				t := i.Type
				z := v_0_1
				x := v_1
				if !(z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16) {
					continue
				}
				v.Reset(ssaop.OpXor16)
				v0 := b.NewValue0(v.Pos, ssaop.OpXor16, t)
				v0.AddArg2(z, x)
				v.AddArg2(i, v0)
				return true
			}
		}
		break
	}
	// match: (Xor16 (Const16 <t> [c]) (Xor16 (Const16 <t> [d]) x))
	// result: (Xor16 (Const16 <t> [c^d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst16 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt16(v_0.AuxInt)
			if v_1.Op != ssaop.OpXor16 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if v_1_0.Op != ssaop.OpConst16 || v_1_0.Type != t {
					continue
				}
				d := ssa.AuxIntToInt16(v_1_0.AuxInt)
				x := v_1_1
				v.Reset(ssaop.OpXor16)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t)
				v0.AuxInt = ssa.Int16ToAuxInt(c ^ d)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Xor16 (Lsh16x64 x z:(Const64 <t> [c])) (Rsh16Ux64 x (Const64 [d])))
	// cond: c < 16 && d == 16-c && canRotate(config, 16)
	// result: (RotateLeft16 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLsh16x64 {
				continue
			}
			_ = v_0.Args[1]
			x := v_0.Args[0]
			z := v_0.Args[1]
			if z.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(z.AuxInt)
			if v_1.Op != ssaop.OpRsh16Ux64 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(c < 16 && d == 16-c && canRotate(config, 16)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Xor16 left:(Lsh16x64 x y) right:(Rsh16Ux64 x (Sub64 (Const64 [16]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)
	// result: (RotateLeft16 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh16x64 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh16Ux64 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub64 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(right_1_0.AuxInt) != 16 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Xor16 left:(Lsh16x32 x y) right:(Rsh16Ux32 x (Sub32 (Const32 [16]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)
	// result: (RotateLeft16 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh16x32 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh16Ux32 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub32 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(right_1_0.AuxInt) != 16 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Xor16 left:(Lsh16x16 x y) right:(Rsh16Ux16 x (Sub16 (Const16 [16]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)
	// result: (RotateLeft16 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh16x16 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh16Ux16 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub16 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(right_1_0.AuxInt) != 16 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Xor16 left:(Lsh16x8 x y) right:(Rsh16Ux8 x (Sub8 (Const8 [16]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)
	// result: (RotateLeft16 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh16x8 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh16Ux8 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub8 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(right_1_0.AuxInt) != 16 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Xor16 right:(Rsh16Ux64 x y) left:(Lsh16x64 x z:(Sub64 (Const64 [16]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)
	// result: (RotateLeft16 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh16Ux64 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh16x64 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub64 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(z_0.AuxInt) != 16 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Xor16 right:(Rsh16Ux32 x y) left:(Lsh16x32 x z:(Sub32 (Const32 [16]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)
	// result: (RotateLeft16 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh16Ux32 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh16x32 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub32 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(z_0.AuxInt) != 16 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Xor16 right:(Rsh16Ux16 x y) left:(Lsh16x16 x z:(Sub16 (Const16 [16]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)
	// result: (RotateLeft16 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh16Ux16 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh16x16 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub16 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(z_0.AuxInt) != 16 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Xor16 right:(Rsh16Ux8 x y) left:(Lsh16x8 x z:(Sub8 (Const8 [16]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)
	// result: (RotateLeft16 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh16Ux8 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh16x8 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub8 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(z_0.AuxInt) != 16 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft16)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Xor16 (ZeroExt8to16 (CvtBoolToUint8 <cvtT> bool)) (Const16 [1]))
	// cond: invertibleBool(bool.Op)
	// result: (ZeroExt8to16 (CvtBoolToUint8 <cvtT> (Not <bool.Type> bool)))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpZeroExt8to16 {
				continue
			}
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpCvtBoolToUint8 {
				continue
			}
			cvtT := v_0_0.Type
			bool := v_0_0.Args[0]
			if v_1.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_1.AuxInt) != 1 || !(invertibleBool(bool.Op)) {
				continue
			}
			v.Reset(ssaop.OpZeroExt8to16)
			v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, cvtT)
			v1 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type)
			v1.AddArg(bool)
			v0.AddArg(v1)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (Xor16 (ZeroExt8to16 (CvtBoolToUint8 <cvtT> (Not bool))) (Const16 <constT> [c]))
	// cond: c != 1
	// result: (Xor16 (ZeroExt8to16 (CvtBoolToUint8 <cvtT> bool)) (Const16 <constT> [c^1]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpZeroExt8to16 {
				continue
			}
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpCvtBoolToUint8 {
				continue
			}
			cvtT := v_0_0.Type
			v_0_0_0 := v_0_0.Args[0]
			if v_0_0_0.Op != ssaop.OpNot {
				continue
			}
			bool := v_0_0_0.Args[0]
			if v_1.Op != ssaop.OpConst16 {
				continue
			}
			constT := v_1.Type
			c := ssa.AuxIntToInt16(v_1.AuxInt)
			if !(c != 1) {
				continue
			}
			v.Reset(ssaop.OpXor16)
			v0 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to16, typ.UInt16)
			v1 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, cvtT)
			v1.AddArg(bool)
			v0.AddArg(v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst16, constT)
			v2.AuxInt = ssa.Int16ToAuxInt(c ^ 1)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpXor32(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	typ := &b.Func.Config.Types
	// match: (Xor32 (Const32 [c]) (Const32 [d]))
	// result: (Const32 [c^d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 {
				continue
			}
			c := ssa.AuxIntToInt32(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst32 {
				continue
			}
			d := ssa.AuxIntToInt32(v_1.AuxInt)
			v.Reset(ssaop.OpConst32)
			v.AuxInt = ssa.Int32ToAuxInt(c ^ d)
			return true
		}
		break
	}
	// match: (Xor32 x x)
	// result: (Const32 [0])
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(0)
		return true
	}
	// match: (Xor32 (Const32 [0]) x)
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 {
				continue
			}
			x := v_1
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (Xor32 (Com32 x) x)
	// result: (Const32 [-1])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpCom32 {
				continue
			}
			x := v_0.Args[0]
			if x != v_1 {
				continue
			}
			v.Reset(ssaop.OpConst32)
			v.AuxInt = ssa.Int32ToAuxInt(-1)
			return true
		}
		break
	}
	// match: (Xor32 (Const32 [-1]) x)
	// result: (Com32 x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != -1 {
				continue
			}
			x := v_1
			v.Reset(ssaop.OpCom32)
			v.AddArg(x)
			return true
		}
		break
	}
	// match: (Xor32 x (Xor32 x y))
	// result: y
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpXor32 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if x != v_1_0 {
					continue
				}
				y := v_1_1
				v.CopyOf(y)
				return true
			}
		}
		break
	}
	// match: (Xor32 (Xor32 i:(Const32 <t>) z) x)
	// cond: (z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32)
	// result: (Xor32 i (Xor32 <t> z x))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpXor32 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				i := v_0_0
				if i.Op != ssaop.OpConst32 {
					continue
				}
				t := i.Type
				z := v_0_1
				x := v_1
				if !(z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32) {
					continue
				}
				v.Reset(ssaop.OpXor32)
				v0 := b.NewValue0(v.Pos, ssaop.OpXor32, t)
				v0.AddArg2(z, x)
				v.AddArg2(i, v0)
				return true
			}
		}
		break
	}
	// match: (Xor32 (Const32 <t> [c]) (Xor32 (Const32 <t> [d]) x))
	// result: (Xor32 (Const32 <t> [c^d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst32 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt32(v_0.AuxInt)
			if v_1.Op != ssaop.OpXor32 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if v_1_0.Op != ssaop.OpConst32 || v_1_0.Type != t {
					continue
				}
				d := ssa.AuxIntToInt32(v_1_0.AuxInt)
				x := v_1_1
				v.Reset(ssaop.OpXor32)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t)
				v0.AuxInt = ssa.Int32ToAuxInt(c ^ d)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Xor32 (Lsh32x64 x z:(Const64 <t> [c])) (Rsh32Ux64 x (Const64 [d])))
	// cond: c < 32 && d == 32-c && canRotate(config, 32)
	// result: (RotateLeft32 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLsh32x64 {
				continue
			}
			_ = v_0.Args[1]
			x := v_0.Args[0]
			z := v_0.Args[1]
			if z.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(z.AuxInt)
			if v_1.Op != ssaop.OpRsh32Ux64 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(c < 32 && d == 32-c && canRotate(config, 32)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Xor32 left:(Lsh32x64 x y) right:(Rsh32Ux64 x (Sub64 (Const64 [32]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)
	// result: (RotateLeft32 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh32x64 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh32Ux64 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub64 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(right_1_0.AuxInt) != 32 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Xor32 left:(Lsh32x32 x y) right:(Rsh32Ux32 x (Sub32 (Const32 [32]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)
	// result: (RotateLeft32 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh32x32 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh32Ux32 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub32 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(right_1_0.AuxInt) != 32 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Xor32 left:(Lsh32x16 x y) right:(Rsh32Ux16 x (Sub16 (Const16 [32]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)
	// result: (RotateLeft32 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh32x16 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh32Ux16 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub16 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(right_1_0.AuxInt) != 32 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Xor32 left:(Lsh32x8 x y) right:(Rsh32Ux8 x (Sub8 (Const8 [32]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)
	// result: (RotateLeft32 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh32x8 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh32Ux8 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub8 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(right_1_0.AuxInt) != 32 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Xor32 right:(Rsh32Ux64 x y) left:(Lsh32x64 x z:(Sub64 (Const64 [32]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)
	// result: (RotateLeft32 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh32Ux64 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh32x64 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub64 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(z_0.AuxInt) != 32 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Xor32 right:(Rsh32Ux32 x y) left:(Lsh32x32 x z:(Sub32 (Const32 [32]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)
	// result: (RotateLeft32 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh32Ux32 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh32x32 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub32 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(z_0.AuxInt) != 32 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Xor32 right:(Rsh32Ux16 x y) left:(Lsh32x16 x z:(Sub16 (Const16 [32]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)
	// result: (RotateLeft32 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh32Ux16 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh32x16 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub16 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(z_0.AuxInt) != 32 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Xor32 right:(Rsh32Ux8 x y) left:(Lsh32x8 x z:(Sub8 (Const8 [32]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)
	// result: (RotateLeft32 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh32Ux8 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh32x8 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub8 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(z_0.AuxInt) != 32 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft32)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Xor32 (ZeroExt8to32 (CvtBoolToUint8 <cvtT> bool)) (Const32 [1]))
	// cond: invertibleBool(bool.Op)
	// result: (ZeroExt8to32 (CvtBoolToUint8 <cvtT> (Not <bool.Type> bool)))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpZeroExt8to32 {
				continue
			}
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpCvtBoolToUint8 {
				continue
			}
			cvtT := v_0_0.Type
			bool := v_0_0.Args[0]
			if v_1.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1.AuxInt) != 1 || !(invertibleBool(bool.Op)) {
				continue
			}
			v.Reset(ssaop.OpZeroExt8to32)
			v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, cvtT)
			v1 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type)
			v1.AddArg(bool)
			v0.AddArg(v1)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (Xor32 (ZeroExt8to32 (CvtBoolToUint8 <cvtT> (Not bool))) (Const32 <constT> [c]))
	// cond: c != 1
	// result: (Xor32 (ZeroExt8to32 (CvtBoolToUint8 <cvtT> bool)) (Const32 <constT> [c^1]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpZeroExt8to32 {
				continue
			}
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpCvtBoolToUint8 {
				continue
			}
			cvtT := v_0_0.Type
			v_0_0_0 := v_0_0.Args[0]
			if v_0_0_0.Op != ssaop.OpNot {
				continue
			}
			bool := v_0_0_0.Args[0]
			if v_1.Op != ssaop.OpConst32 {
				continue
			}
			constT := v_1.Type
			c := ssa.AuxIntToInt32(v_1.AuxInt)
			if !(c != 1) {
				continue
			}
			v.Reset(ssaop.OpXor32)
			v0 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to32, typ.UInt32)
			v1 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, cvtT)
			v1.AddArg(bool)
			v0.AddArg(v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst32, constT)
			v2.AuxInt = ssa.Int32ToAuxInt(c ^ 1)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpXor64(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	typ := &b.Func.Config.Types
	// match: (Xor64 (Const64 [c]) (Const64 [d]))
	// result: (Const64 [c^d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1.AuxInt)
			v.Reset(ssaop.OpConst64)
			v.AuxInt = ssa.Int64ToAuxInt(c ^ d)
			return true
		}
		break
	}
	// match: (Xor64 x x)
	// result: (Const64 [0])
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(0)
		return true
	}
	// match: (Xor64 (Const64 [0]) x)
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 {
				continue
			}
			x := v_1
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (Xor64 (Com64 x) x)
	// result: (Const64 [-1])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpCom64 {
				continue
			}
			x := v_0.Args[0]
			if x != v_1 {
				continue
			}
			v.Reset(ssaop.OpConst64)
			v.AuxInt = ssa.Int64ToAuxInt(-1)
			return true
		}
		break
	}
	// match: (Xor64 (Const64 [-1]) x)
	// result: (Com64 x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != -1 {
				continue
			}
			x := v_1
			v.Reset(ssaop.OpCom64)
			v.AddArg(x)
			return true
		}
		break
	}
	// match: (Xor64 x (Xor64 x y))
	// result: y
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpXor64 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if x != v_1_0 {
					continue
				}
				y := v_1_1
				v.CopyOf(y)
				return true
			}
		}
		break
	}
	// match: (Xor64 (Xor64 i:(Const64 <t>) z) x)
	// cond: (z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64)
	// result: (Xor64 i (Xor64 <t> z x))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpXor64 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				i := v_0_0
				if i.Op != ssaop.OpConst64 {
					continue
				}
				t := i.Type
				z := v_0_1
				x := v_1
				if !(z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64) {
					continue
				}
				v.Reset(ssaop.OpXor64)
				v0 := b.NewValue0(v.Pos, ssaop.OpXor64, t)
				v0.AddArg2(z, x)
				v.AddArg2(i, v0)
				return true
			}
		}
		break
	}
	// match: (Xor64 (Const64 <t> [c]) (Xor64 (Const64 <t> [d]) x))
	// result: (Xor64 (Const64 <t> [c^d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst64 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt64(v_0.AuxInt)
			if v_1.Op != ssaop.OpXor64 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if v_1_0.Op != ssaop.OpConst64 || v_1_0.Type != t {
					continue
				}
				d := ssa.AuxIntToInt64(v_1_0.AuxInt)
				x := v_1_1
				v.Reset(ssaop.OpXor64)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t)
				v0.AuxInt = ssa.Int64ToAuxInt(c ^ d)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Xor64 (Lsh64x64 x z:(Const64 <t> [c])) (Rsh64Ux64 x (Const64 [d])))
	// cond: c < 64 && d == 64-c && canRotate(config, 64)
	// result: (RotateLeft64 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLsh64x64 {
				continue
			}
			_ = v_0.Args[1]
			x := v_0.Args[0]
			z := v_0.Args[1]
			if z.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(z.AuxInt)
			if v_1.Op != ssaop.OpRsh64Ux64 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(c < 64 && d == 64-c && canRotate(config, 64)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Xor64 left:(Lsh64x64 x y) right:(Rsh64Ux64 x (Sub64 (Const64 [64]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)
	// result: (RotateLeft64 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh64x64 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh64Ux64 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub64 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(right_1_0.AuxInt) != 64 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Xor64 left:(Lsh64x32 x y) right:(Rsh64Ux32 x (Sub32 (Const32 [64]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)
	// result: (RotateLeft64 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh64x32 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh64Ux32 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub32 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(right_1_0.AuxInt) != 64 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Xor64 left:(Lsh64x16 x y) right:(Rsh64Ux16 x (Sub16 (Const16 [64]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)
	// result: (RotateLeft64 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh64x16 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh64Ux16 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub16 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(right_1_0.AuxInt) != 64 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Xor64 left:(Lsh64x8 x y) right:(Rsh64Ux8 x (Sub8 (Const8 [64]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)
	// result: (RotateLeft64 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh64x8 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh64Ux8 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub8 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(right_1_0.AuxInt) != 64 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Xor64 right:(Rsh64Ux64 x y) left:(Lsh64x64 x z:(Sub64 (Const64 [64]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)
	// result: (RotateLeft64 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh64Ux64 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh64x64 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub64 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(z_0.AuxInt) != 64 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Xor64 right:(Rsh64Ux32 x y) left:(Lsh64x32 x z:(Sub32 (Const32 [64]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)
	// result: (RotateLeft64 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh64Ux32 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh64x32 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub32 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(z_0.AuxInt) != 64 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Xor64 right:(Rsh64Ux16 x y) left:(Lsh64x16 x z:(Sub16 (Const16 [64]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)
	// result: (RotateLeft64 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh64Ux16 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh64x16 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub16 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(z_0.AuxInt) != 64 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Xor64 right:(Rsh64Ux8 x y) left:(Lsh64x8 x z:(Sub8 (Const8 [64]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)
	// result: (RotateLeft64 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh64Ux8 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh64x8 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub8 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(z_0.AuxInt) != 64 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft64)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Xor64 (ZeroExt8to64 (CvtBoolToUint8 <cvtT> bool)) (Const64 [1]))
	// cond: invertibleBool(bool.Op)
	// result: (ZeroExt8to64 (CvtBoolToUint8 <cvtT> (Not <bool.Type> bool)))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpZeroExt8to64 {
				continue
			}
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpCvtBoolToUint8 {
				continue
			}
			cvtT := v_0_0.Type
			bool := v_0_0.Args[0]
			if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 1 || !(invertibleBool(bool.Op)) {
				continue
			}
			v.Reset(ssaop.OpZeroExt8to64)
			v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, cvtT)
			v1 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type)
			v1.AddArg(bool)
			v0.AddArg(v1)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (Xor64 (ZeroExt8to64 (CvtBoolToUint8 <cvtT> (Not bool))) (Const64 <constT> [c]))
	// cond: c != 1
	// result: (Xor64 (ZeroExt8to64 (CvtBoolToUint8 <cvtT> bool)) (Const64 <constT> [c^1]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpZeroExt8to64 {
				continue
			}
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpCvtBoolToUint8 {
				continue
			}
			cvtT := v_0_0.Type
			v_0_0_0 := v_0_0.Args[0]
			if v_0_0_0.Op != ssaop.OpNot {
				continue
			}
			bool := v_0_0_0.Args[0]
			if v_1.Op != ssaop.OpConst64 {
				continue
			}
			constT := v_1.Type
			c := ssa.AuxIntToInt64(v_1.AuxInt)
			if !(c != 1) {
				continue
			}
			v.Reset(ssaop.OpXor64)
			v0 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to64, typ.UInt64)
			v1 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, cvtT)
			v1.AddArg(bool)
			v0.AddArg(v1)
			v2 := b.NewValue0(v.Pos, ssaop.OpConst64, constT)
			v2.AuxInt = ssa.Int64ToAuxInt(c ^ 1)
			v.AddArg2(v0, v2)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpXor8(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	// match: (Xor8 (Const8 [c]) (Const8 [d]))
	// result: (Const8 [c^d])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 {
				continue
			}
			c := ssa.AuxIntToInt8(v_0.AuxInt)
			if v_1.Op != ssaop.OpConst8 {
				continue
			}
			d := ssa.AuxIntToInt8(v_1.AuxInt)
			v.Reset(ssaop.OpConst8)
			v.AuxInt = ssa.Int8ToAuxInt(c ^ d)
			return true
		}
		break
	}
	// match: (Xor8 x x)
	// result: (Const8 [0])
	for {
		x := v_0
		if x != v_1 {
			break
		}
		v.Reset(ssaop.OpConst8)
		v.AuxInt = ssa.Int8ToAuxInt(0)
		return true
	}
	// match: (Xor8 (Const8 [0]) x)
	// result: x
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 {
				continue
			}
			x := v_1
			v.CopyOf(x)
			return true
		}
		break
	}
	// match: (Xor8 (Com8 x) x)
	// result: (Const8 [-1])
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpCom8 {
				continue
			}
			x := v_0.Args[0]
			if x != v_1 {
				continue
			}
			v.Reset(ssaop.OpConst8)
			v.AuxInt = ssa.Int8ToAuxInt(-1)
			return true
		}
		break
	}
	// match: (Xor8 (Const8 [-1]) x)
	// result: (Com8 x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != -1 {
				continue
			}
			x := v_1
			v.Reset(ssaop.OpCom8)
			v.AddArg(x)
			return true
		}
		break
	}
	// match: (Xor8 x (Xor8 x y))
	// result: y
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != ssaop.OpXor8 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if x != v_1_0 {
					continue
				}
				y := v_1_1
				v.CopyOf(y)
				return true
			}
		}
		break
	}
	// match: (Xor8 (Xor8 i:(Const8 <t>) z) x)
	// cond: (z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8)
	// result: (Xor8 i (Xor8 <t> z x))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpXor8 {
				continue
			}
			_ = v_0.Args[1]
			v_0_0 := v_0.Args[0]
			v_0_1 := v_0.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 {
				i := v_0_0
				if i.Op != ssaop.OpConst8 {
					continue
				}
				t := i.Type
				z := v_0_1
				x := v_1
				if !(z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8) {
					continue
				}
				v.Reset(ssaop.OpXor8)
				v0 := b.NewValue0(v.Pos, ssaop.OpXor8, t)
				v0.AddArg2(z, x)
				v.AddArg2(i, v0)
				return true
			}
		}
		break
	}
	// match: (Xor8 (Const8 <t> [c]) (Xor8 (Const8 <t> [d]) x))
	// result: (Xor8 (Const8 <t> [c^d]) x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpConst8 {
				continue
			}
			t := v_0.Type
			c := ssa.AuxIntToInt8(v_0.AuxInt)
			if v_1.Op != ssaop.OpXor8 {
				continue
			}
			_ = v_1.Args[1]
			v_1_0 := v_1.Args[0]
			v_1_1 := v_1.Args[1]
			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {
				if v_1_0.Op != ssaop.OpConst8 || v_1_0.Type != t {
					continue
				}
				d := ssa.AuxIntToInt8(v_1_0.AuxInt)
				x := v_1_1
				v.Reset(ssaop.OpXor8)
				v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t)
				v0.AuxInt = ssa.Int8ToAuxInt(c ^ d)
				v.AddArg2(v0, x)
				return true
			}
		}
		break
	}
	// match: (Xor8 (Lsh8x64 x z:(Const64 <t> [c])) (Rsh8Ux64 x (Const64 [d])))
	// cond: c < 8 && d == 8-c && canRotate(config, 8)
	// result: (RotateLeft8 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpLsh8x64 {
				continue
			}
			_ = v_0.Args[1]
			x := v_0.Args[0]
			z := v_0.Args[1]
			if z.Op != ssaop.OpConst64 {
				continue
			}
			c := ssa.AuxIntToInt64(z.AuxInt)
			if v_1.Op != ssaop.OpRsh8Ux64 {
				continue
			}
			_ = v_1.Args[1]
			if x != v_1.Args[0] {
				continue
			}
			v_1_1 := v_1.Args[1]
			if v_1_1.Op != ssaop.OpConst64 {
				continue
			}
			d := ssa.AuxIntToInt64(v_1_1.AuxInt)
			if !(c < 8 && d == 8-c && canRotate(config, 8)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Xor8 left:(Lsh8x64 x y) right:(Rsh8Ux64 x (Sub64 (Const64 [8]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)
	// result: (RotateLeft8 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh8x64 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh8Ux64 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub64 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(right_1_0.AuxInt) != 8 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Xor8 left:(Lsh8x32 x y) right:(Rsh8Ux32 x (Sub32 (Const32 [8]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)
	// result: (RotateLeft8 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh8x32 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh8Ux32 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub32 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(right_1_0.AuxInt) != 8 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Xor8 left:(Lsh8x16 x y) right:(Rsh8Ux16 x (Sub16 (Const16 [8]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)
	// result: (RotateLeft8 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh8x16 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh8Ux16 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub16 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(right_1_0.AuxInt) != 8 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Xor8 left:(Lsh8x8 x y) right:(Rsh8Ux8 x (Sub8 (Const8 [8]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)
	// result: (RotateLeft8 x y)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			left := v_0
			if left.Op != ssaop.OpLsh8x8 {
				continue
			}
			y := left.Args[1]
			x := left.Args[0]
			right := v_1
			if right.Op != ssaop.OpRsh8Ux8 {
				continue
			}
			_ = right.Args[1]
			if x != right.Args[0] {
				continue
			}
			right_1 := right.Args[1]
			if right_1.Op != ssaop.OpSub8 {
				continue
			}
			_ = right_1.Args[1]
			right_1_0 := right_1.Args[0]
			if right_1_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(right_1_0.AuxInt) != 8 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v.AddArg2(x, y)
			return true
		}
		break
	}
	// match: (Xor8 right:(Rsh8Ux64 x y) left:(Lsh8x64 x z:(Sub64 (Const64 [8]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)
	// result: (RotateLeft8 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh8Ux64 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh8x64 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub64 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(z_0.AuxInt) != 8 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Xor8 right:(Rsh8Ux32 x y) left:(Lsh8x32 x z:(Sub32 (Const32 [8]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)
	// result: (RotateLeft8 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh8Ux32 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh8x32 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub32 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(z_0.AuxInt) != 8 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Xor8 right:(Rsh8Ux16 x y) left:(Lsh8x16 x z:(Sub16 (Const16 [8]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)
	// result: (RotateLeft8 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh8Ux16 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh8x16 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub16 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(z_0.AuxInt) != 8 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Xor8 right:(Rsh8Ux8 x y) left:(Lsh8x8 x z:(Sub8 (Const8 [8]) y)))
	// cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)
	// result: (RotateLeft8 x z)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			right := v_0
			if right.Op != ssaop.OpRsh8Ux8 {
				continue
			}
			y := right.Args[1]
			x := right.Args[0]
			left := v_1
			if left.Op != ssaop.OpLsh8x8 {
				continue
			}
			_ = left.Args[1]
			if x != left.Args[0] {
				continue
			}
			z := left.Args[1]
			if z.Op != ssaop.OpSub8 {
				continue
			}
			_ = z.Args[1]
			z_0 := z.Args[0]
			if z_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(z_0.AuxInt) != 8 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) {
				continue
			}
			v.Reset(ssaop.OpRotateLeft8)
			v.AddArg2(x, z)
			return true
		}
		break
	}
	// match: (Xor8 (CvtBoolToUint8 bool) (Const8 [1]))
	// cond: invertibleBool(bool.Op)
	// result: (CvtBoolToUint8 (Not <bool.Type> bool))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpCvtBoolToUint8 {
				continue
			}
			bool := v_0.Args[0]
			if v_1.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_1.AuxInt) != 1 || !(invertibleBool(bool.Op)) {
				continue
			}
			v.Reset(ssaop.OpCvtBoolToUint8)
			v0 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type)
			v0.AddArg(bool)
			v.AddArg(v0)
			return true
		}
		break
	}
	// match: (Xor8 (CvtBoolToUint8 <cvtT> (Not bool)) (Const8 <constT> [c]))
	// cond: c != 1
	// result: (Xor8 (CvtBoolToUint8 <cvtT> bool) (Const8 <constT> [c^1]))
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			if v_0.Op != ssaop.OpCvtBoolToUint8 {
				continue
			}
			cvtT := v_0.Type
			v_0_0 := v_0.Args[0]
			if v_0_0.Op != ssaop.OpNot {
				continue
			}
			bool := v_0_0.Args[0]
			if v_1.Op != ssaop.OpConst8 {
				continue
			}
			constT := v_1.Type
			c := ssa.AuxIntToInt8(v_1.AuxInt)
			if !(c != 1) {
				continue
			}
			v.Reset(ssaop.OpXor8)
			v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, cvtT)
			v0.AddArg(bool)
			v1 := b.NewValue0(v.Pos, ssaop.OpConst8, constT)
			v1.AuxInt = ssa.Int8ToAuxInt(c ^ 1)
			v.AddArg2(v0, v1)
			return true
		}
		break
	}
	return false
}
func rewriteValue_OpZero(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	// match: (Zero (SelectN [0] call:(StaticLECall ___)) mem:(SelectN [1] call))
	// cond: isMalloc(call.Aux)
	// result: mem
	for {
		if v_0.Op != ssaop.OpSelectN || ssa.AuxIntToInt64(v_0.AuxInt) != 0 {
			break
		}
		call := v_0.Args[0]
		if call.Op != ssaop.OpStaticLECall {
			break
		}
		mem := v_1
		if mem.Op != ssaop.OpSelectN || ssa.AuxIntToInt64(mem.AuxInt) != 1 || call != mem.Args[0] || !(isMalloc(call.Aux)) {
			break
		}
		v.CopyOf(mem)
		return true
	}
	// match: (Zero {t1} [n] p1 store:(Store {t2} (OffPtr [o2] p2) _ mem))
	// cond: ssa.IsSamePtr(p1, p2) && store.Uses == 1 && n >= o2 + t2.Size() && ssa.Clobber(store)
	// result: (Zero {t1} [n] p1 mem)
	for {
		n := ssa.AuxIntToInt64(v.AuxInt)
		t1 := ssa.AuxToType(v.Aux)
		p1 := v_0
		store := v_1
		if store.Op != ssaop.OpStore {
			break
		}
		t2 := ssa.AuxToType(store.Aux)
		mem := store.Args[2]
		store_0 := store.Args[0]
		if store_0.Op != ssaop.OpOffPtr {
			break
		}
		o2 := ssa.AuxIntToInt64(store_0.AuxInt)
		p2 := store_0.Args[0]
		if !(ssa.IsSamePtr(p1, p2) && store.Uses == 1 && n >= o2+t2.Size() && ssa.Clobber(store)) {
			break
		}
		v.Reset(ssaop.OpZero)
		v.AuxInt = ssa.Int64ToAuxInt(n)
		v.Aux = ssa.TypeToAux(t1)
		v.AddArg2(p1, mem)
		return true
	}
	// match: (Zero {t} [n] dst1 move:(Move {t} [n] dst2 _ mem))
	// cond: move.Uses == 1 && ssa.IsSamePtr(dst1, dst2) && ssa.Clobber(move)
	// result: (Zero {t} [n] dst1 mem)
	for {
		n := ssa.AuxIntToInt64(v.AuxInt)
		t := ssa.AuxToType(v.Aux)
		dst1 := v_0
		move := v_1
		if move.Op != ssaop.OpMove || ssa.AuxIntToInt64(move.AuxInt) != n || ssa.AuxToType(move.Aux) != t {
			break
		}
		mem := move.Args[2]
		dst2 := move.Args[0]
		if !(move.Uses == 1 && ssa.IsSamePtr(dst1, dst2) && ssa.Clobber(move)) {
			break
		}
		v.Reset(ssaop.OpZero)
		v.AuxInt = ssa.Int64ToAuxInt(n)
		v.Aux = ssa.TypeToAux(t)
		v.AddArg2(dst1, mem)
		return true
	}
	// match: (Zero {t} [n] dst1 vardef:(VarDef {x} move:(Move {t} [n] dst2 _ mem)))
	// cond: move.Uses == 1 && vardef.Uses == 1 && ssa.IsSamePtr(dst1, dst2) && ssa.Clobber(move, vardef)
	// result: (Zero {t} [n] dst1 (VarDef {x} mem))
	for {
		n := ssa.AuxIntToInt64(v.AuxInt)
		t := ssa.AuxToType(v.Aux)
		dst1 := v_0
		vardef := v_1
		if vardef.Op != ssaop.OpVarDef {
			break
		}
		x := ssa.AuxToSym(vardef.Aux)
		move := vardef.Args[0]
		if move.Op != ssaop.OpMove || ssa.AuxIntToInt64(move.AuxInt) != n || ssa.AuxToType(move.Aux) != t {
			break
		}
		mem := move.Args[2]
		dst2 := move.Args[0]
		if !(move.Uses == 1 && vardef.Uses == 1 && ssa.IsSamePtr(dst1, dst2) && ssa.Clobber(move, vardef)) {
			break
		}
		v.Reset(ssaop.OpZero)
		v.AuxInt = ssa.Int64ToAuxInt(n)
		v.Aux = ssa.TypeToAux(t)
		v0 := b.NewValue0(v.Pos, ssaop.OpVarDef, types.TypeMem)
		v0.Aux = ssa.SymToAux(x)
		v0.AddArg(mem)
		v.AddArg2(dst1, v0)
		return true
	}
	// match: (Zero {t} [s] dst1 zero:(Zero {t} [s] dst2 _))
	// cond: ssa.IsSamePtr(dst1, dst2)
	// result: zero
	for {
		s := ssa.AuxIntToInt64(v.AuxInt)
		t := ssa.AuxToType(v.Aux)
		dst1 := v_0
		zero := v_1
		if zero.Op != ssaop.OpZero || ssa.AuxIntToInt64(zero.AuxInt) != s || ssa.AuxToType(zero.Aux) != t {
			break
		}
		dst2 := zero.Args[0]
		if !(ssa.IsSamePtr(dst1, dst2)) {
			break
		}
		v.CopyOf(zero)
		return true
	}
	// match: (Zero {t} [s] dst1 vardef:(VarDef (Zero {t} [s] dst2 _)))
	// cond: ssa.IsSamePtr(dst1, dst2)
	// result: vardef
	for {
		s := ssa.AuxIntToInt64(v.AuxInt)
		t := ssa.AuxToType(v.Aux)
		dst1 := v_0
		vardef := v_1
		if vardef.Op != ssaop.OpVarDef {
			break
		}
		vardef_0 := vardef.Args[0]
		if vardef_0.Op != ssaop.OpZero || ssa.AuxIntToInt64(vardef_0.AuxInt) != s || ssa.AuxToType(vardef_0.Aux) != t {
			break
		}
		dst2 := vardef_0.Args[0]
		if !(ssa.IsSamePtr(dst1, dst2)) {
			break
		}
		v.CopyOf(vardef)
		return true
	}
	return false
}
func rewriteValue_OpZeroExt16to32(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (ZeroExt16to32 (Const16 [c]))
	// result: (Const32 [int32(uint16(c))])
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_0.AuxInt)
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(int32(uint16(c)))
		return true
	}
	// match: (ZeroExt16to32 (Trunc32to16 x:(Rsh32Ux64 _ (Const64 [s]))))
	// cond: s >= 16
	// result: x
	for {
		if v_0.Op != ssaop.OpTrunc32to16 {
			break
		}
		x := v_0.Args[0]
		if x.Op != ssaop.OpRsh32Ux64 {
			break
		}
		_ = x.Args[1]
		x_1 := x.Args[1]
		if x_1.Op != ssaop.OpConst64 {
			break
		}
		s := ssa.AuxIntToInt64(x_1.AuxInt)
		if !(s >= 16) {
			break
		}
		v.CopyOf(x)
		return true
	}
	return false
}
func rewriteValue_OpZeroExt16to64(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (ZeroExt16to64 (Const16 [c]))
	// result: (Const64 [int64(uint16(c))])
	for {
		if v_0.Op != ssaop.OpConst16 {
			break
		}
		c := ssa.AuxIntToInt16(v_0.AuxInt)
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(int64(uint16(c)))
		return true
	}
	// match: (ZeroExt16to64 (Trunc64to16 x:(Rsh64Ux64 _ (Const64 [s]))))
	// cond: s >= 48
	// result: x
	for {
		if v_0.Op != ssaop.OpTrunc64to16 {
			break
		}
		x := v_0.Args[0]
		if x.Op != ssaop.OpRsh64Ux64 {
			break
		}
		_ = x.Args[1]
		x_1 := x.Args[1]
		if x_1.Op != ssaop.OpConst64 {
			break
		}
		s := ssa.AuxIntToInt64(x_1.AuxInt)
		if !(s >= 48) {
			break
		}
		v.CopyOf(x)
		return true
	}
	return false
}
func rewriteValue_OpZeroExt32to64(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (ZeroExt32to64 (Const32 [c]))
	// result: (Const64 [int64(uint32(c))])
	for {
		if v_0.Op != ssaop.OpConst32 {
			break
		}
		c := ssa.AuxIntToInt32(v_0.AuxInt)
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(int64(uint32(c)))
		return true
	}
	// match: (ZeroExt32to64 (Trunc64to32 x:(Rsh64Ux64 _ (Const64 [s]))))
	// cond: s >= 32
	// result: x
	for {
		if v_0.Op != ssaop.OpTrunc64to32 {
			break
		}
		x := v_0.Args[0]
		if x.Op != ssaop.OpRsh64Ux64 {
			break
		}
		_ = x.Args[1]
		x_1 := x.Args[1]
		if x_1.Op != ssaop.OpConst64 {
			break
		}
		s := ssa.AuxIntToInt64(x_1.AuxInt)
		if !(s >= 32) {
			break
		}
		v.CopyOf(x)
		return true
	}
	return false
}
func rewriteValue_OpZeroExt8to16(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (ZeroExt8to16 (Const8 [c]))
	// result: (Const16 [int16( uint8(c))])
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_0.AuxInt)
		v.Reset(ssaop.OpConst16)
		v.AuxInt = ssa.Int16ToAuxInt(int16(uint8(c)))
		return true
	}
	// match: (ZeroExt8to16 (Trunc16to8 x:(Rsh16Ux64 _ (Const64 [s]))))
	// cond: s >= 8
	// result: x
	for {
		if v_0.Op != ssaop.OpTrunc16to8 {
			break
		}
		x := v_0.Args[0]
		if x.Op != ssaop.OpRsh16Ux64 {
			break
		}
		_ = x.Args[1]
		x_1 := x.Args[1]
		if x_1.Op != ssaop.OpConst64 {
			break
		}
		s := ssa.AuxIntToInt64(x_1.AuxInt)
		if !(s >= 8) {
			break
		}
		v.CopyOf(x)
		return true
	}
	return false
}
func rewriteValue_OpZeroExt8to32(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (ZeroExt8to32 (Const8 [c]))
	// result: (Const32 [int32( uint8(c))])
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_0.AuxInt)
		v.Reset(ssaop.OpConst32)
		v.AuxInt = ssa.Int32ToAuxInt(int32(uint8(c)))
		return true
	}
	// match: (ZeroExt8to32 (Trunc32to8 x:(Rsh32Ux64 _ (Const64 [s]))))
	// cond: s >= 24
	// result: x
	for {
		if v_0.Op != ssaop.OpTrunc32to8 {
			break
		}
		x := v_0.Args[0]
		if x.Op != ssaop.OpRsh32Ux64 {
			break
		}
		_ = x.Args[1]
		x_1 := x.Args[1]
		if x_1.Op != ssaop.OpConst64 {
			break
		}
		s := ssa.AuxIntToInt64(x_1.AuxInt)
		if !(s >= 24) {
			break
		}
		v.CopyOf(x)
		return true
	}
	return false
}
func rewriteValue_OpZeroExt8to64(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (ZeroExt8to64 (Const8 [c]))
	// result: (Const64 [int64( uint8(c))])
	for {
		if v_0.Op != ssaop.OpConst8 {
			break
		}
		c := ssa.AuxIntToInt8(v_0.AuxInt)
		v.Reset(ssaop.OpConst64)
		v.AuxInt = ssa.Int64ToAuxInt(int64(uint8(c)))
		return true
	}
	// match: (ZeroExt8to64 (Trunc64to8 x:(Rsh64Ux64 _ (Const64 [s]))))
	// cond: s >= 56
	// result: x
	for {
		if v_0.Op != ssaop.OpTrunc64to8 {
			break
		}
		x := v_0.Args[0]
		if x.Op != ssaop.OpRsh64Ux64 {
			break
		}
		_ = x.Args[1]
		x_1 := x.Args[1]
		if x_1.Op != ssaop.OpConst64 {
			break
		}
		s := ssa.AuxIntToInt64(x_1.AuxInt)
		if !(s >= 56) {
			break
		}
		v.CopyOf(x)
		return true
	}
	return false
}
func RewriteBlock(b *ssa.Block) bool {
	switch b.Kind {
	case block.BlockIf:
		// match: (If (Not cond) yes no)
		// result: (If cond no yes)
		for b.Controls[0].Op == ssaop.OpNot {
			v_0 := b.Controls[0]
			cond := v_0.Args[0]
			b.ResetWithControl(block.BlockIf, cond)
			b.SwapSuccessors()
			return true
		}
		// match: (If (ConstBool [c]) yes no)
		// cond: c
		// result: (First yes no)
		for b.Controls[0].Op == ssaop.OpConstBool {
			v_0 := b.Controls[0]
			c := ssa.AuxIntToBool(v_0.AuxInt)
			if !(c) {
				break
			}
			b.Reset(block.BlockFirst)
			return true
		}
		// match: (If (ConstBool [c]) yes no)
		// cond: !c
		// result: (First no yes)
		for b.Controls[0].Op == ssaop.OpConstBool {
			v_0 := b.Controls[0]
			c := ssa.AuxIntToBool(v_0.AuxInt)
			if !(!c) {
				break
			}
			b.Reset(block.BlockFirst)
			b.SwapSuccessors()
			return true
		}
	}
	return false
}