// nlzX returns the number of leading zeros.
func nlz64(x int64) int { return bits.LeadingZeros64(uint64(x)) }
func nlz32(x int32) int { return bits.LeadingZeros32(uint32(x)) }
func nlz16(x int16) int { return bits.LeadingZeros16(uint16(x)) }
func nlz8(x int8) int   { return bits.LeadingZeros8(uint8(x)) }

// ntzX returns the number of trailing zeros.
func ntz64(x int64) int { return bits.TrailingZeros64(uint64(x)) }

		// job setup
		parallelism           int32
		completions           int32
		activeDeadlineSeconds int64
		startTime             int64
		backoffLimit          int32
		suspend               bool

		// pod setup
		activePods    int
		succeededPods int
		failedPods    int

		// expectations
		expectedDeletions       int32
		expectedActive          int32
		expectedSucceeded       int32

func cont0Mask64U(x uint64) uint64 {
	// s390x:"RISBGZ\t[$]48, [$]15, [$]0,"
	return x & 0xffff00000000ffff
}

func issue44228a(a []int64, i int) bool {
	// amd64: "BTQ", -"SHL"
	return a[i>>6]&(1<<(i&63)) != 0
}
func issue44228b(a []int32, i int) bool {
	// amd64: "BTL", -"SHL"
	return a[i>>5]&(1<<(i&31)) != 0
}

func issue48467(x, y uint64) uint64 {
	// arm64: -"NEG"

					SucceededIndexes: ptr.To("3-6"),
					SucceededCount:   ptr.To[int32](2),
				}},
			},
		},
		"rules.succeededIndexes is specified; succeededIndexes are nothing": {
			completions:      10,
			succeededIndexes: orderedIntervals{},
			successPolicy: &batch.SuccessPolicy{
				Rules: []batch.SuccessPolicyRule{{
					SucceededCount: ptr.To[int32](4),
				}},
			},
		},

// and a map for looking up indices by *Node.
func getvariables(fn *ir.Func) ([]*ir.Name, map[*ir.Name]int32) {
	var vars []*ir.Name
	for _, n := range fn.Dcl {
		if shouldTrack(n) {
			vars = append(vars, n)
		}
	}
	idx := make(map[*ir.Name]int32, len(vars))
	for i, n := range vars {
		idx[n] = int32(i)
	}
	return vars, idx
}

func (lv *liveness) initcache() {
	if lv.cache.initialized {

(CMPWconst (MOVDconst [x]) [y]) && int32(x)==int32(y) => (FlagEQ)
(CMPWconst (MOVDconst [x]) [y]) && int32(x)<int32(y)  => (FlagLT)
(CMPWconst (MOVDconst [x]) [y]) && int32(x)>int32(y)  => (FlagGT)

(CMPconst (MOVDconst [x]) [y]) && x==y => (FlagEQ)
(CMPconst (MOVDconst [x]) [y]) && x<y  => (FlagLT)
(CMPconst (MOVDconst [x]) [y]) && x>y  => (FlagGT)

(CMPWUconst (MOVDconst [x]) [y]) && int32(x)==int32(y)  => (FlagEQ)

// See the WaitGroup example.
func (wg *WaitGroup) Add(delta int) {
	if race.Enabled {
		if delta < 0 {
			// Synchronize decrements with Wait.
			race.ReleaseMerge(unsafe.Pointer(wg))
		}
		race.Disable()
		defer race.Enable()
	}
	state := wg.state.Add(uint64(delta) << 32)
	v := int32(state >> 32)
	w := uint32(state)
	if race.Enabled && delta > 0 && v == int32(delta) {
		// The first increment must be synchronized with Wait.

			db.RowsAffected++
			db.AddError(rows.Scan(values...))

			mapValue := map[string]interface{}{}
			scanIntoMap(mapValue, values, columns)
			*dest = append(*dest, mapValue)
		}
	case *int, *int8, *int16, *int32, *int64,
		*uint, *uint8, *uint16, *uint32, *uint64, *uintptr,
		*float32, *float64,
		*bool, *string, *time.Time,
		*sql.NullInt32, *sql.NullInt64, *sql.NullFloat64,

	select {}
}

// HollowKubeletOptions contains settable parameters for hollow kubelet.
type HollowKubeletOptions struct {
	NodeName            string
	KubeletPort         int
	KubeletReadOnlyPort int
	MaxPods             int
	PodsPerCore         int
	NodeLabels          map[string]string
	RegisterWithTaints  []v1.Taint
}

// Builds a KubeletConfiguration for the HollowKubelet, ensuring that the

	// cond: int32(x)==int32(y)
	// result: (FlagEQ)
	for {
		y := auxIntToInt32(v.AuxInt)
		if v_0.Op != OpPPC64MOVDconst {
			break
		}
		x := auxIntToInt64(v_0.AuxInt)
		if !(int32(x) == int32(y)) {
			break
		}
		v.reset(OpPPC64FlagEQ)
		return true
	}
	// match: (CMPWconst (MOVDconst [x]) [y])
	// cond: int32(x)<int32(y)
	// result: (FlagLT)
	for {