if !ok {
			err = fmt.Errorf("item not found for the key: %v; should not happen;", key)
			return
		}
		orderedItems = append(orderedItems, item)
		delete(b.items, key)
	}

	b.keys = b.keys[:0]

	return
}

// GetByKey will get the batch item by the provided key
func (b *Batch[K, T]) GetByKey(key K) (T, bool) {
	b.Lock()
	defer b.Unlock()

	item, ok := b.items[key]
	return item, ok
}

// ExerciseIface calls mostly a1 and m1.
//
//go:noinline
func ExerciseIface(iter int, a1, a2 Adder, m1, m2 mult.Multiplier) int {
	// The call below must evaluate selectA() to determine the receiver to
	// use. This should happen exactly once per iteration. Assert that is
	// the case to ensure the IR manipulation does not result in over- or
	// under-evaluation.
	selectI := 0
	selectA := func(gotI int) Adder {
		if gotI != selectI {

	// are registered (in n.registeredHandlers); this can cause the dynamic filtering to miss events
	reg, err := n.informer.AddEventHandler(fh)
	if err != nil {
		// Should only happen if its already stopped. We should exit early.
		return
	}
	n.registeredHandlers = append(n.registeredHandlers, handlerRegistration{registration: reg, handler: h})
}

func (n *informerClient[T]) HasSynced() bool {
	if !n.informer.HasSynced() {
		return false

	return ok && (major > 4 || major == 4 && minor >= 11)
}

func doinit() {
	if err := readHWCAP(); err != nil {
		// We failed to read /proc/self/auxv. This can happen if the binary has
		// been given extra capabilities(7) with /bin/setcap.
		//
		// When this happens, we have two options. If the Linux kernel is new
		// enough (4.11+), we can read the arm64 registers directly which'll
		// trap into the kernel and then return back to userspace.

	// trying different nodes. This should not happen when it has
	// full knowledge about resource availability (=
	// PodSchedulingContext.*.UnsuitableNodes is complete) but may happen
	// when it doesn't (= PodSchedulingContext.*.UnsuitableNodes had to be
	// truncated).
	//
	// Truncation only happens for very large clusters and then may slow

  - type: textarea
    id: current-behavior
    attributes:
      label: Current Behavior
      description: Tell us what happens
    validations:
      required: true
  - type: textarea
    id: expected-behavior
    attributes:
      label: Expected Behavior
      description: Tell us what should happen
    validations:
      required: true
  - type: textarea
    id: context
    attributes:

    }

    public void buildFinished(@Nullable Throwable buildFailure) {
        if (adapter != null) {
            adapter.buildFinished(buildFailure);
        }
    }

    /**
     * This should never happen due to the auto apply behavior.
     * It's only here as a kind of safeguard or fallback.
     */
    public void registerMissingPluginWarning(GradleInternal gradle) {
        if (gradle.isRootBuild()) {

	i := x.b.abs.bytes(buf)
	j := x.a.abs.bytes(buf[:i])
	n := i - j
	if int(uint32(n)) != n {
		// this should never happen
		return nil, errors.New("Rat.GobEncode: numerator too large")
	}
	byteorder.BePutUint32(buf[j-4:j], uint32(n))
	j -= 1 + 4
	b := ratGobVersion << 1 // make space for sign bit
	if x.a.neg {
		b |= 1
	}

                }
            }
        }

        // The file names passed to -cp are canonicalised by the JVM when it creates the system classloader, and so the file names are
        // lost if they happen to refer to links, for example, into the Gradle artifact cache. Try to reconstitute the file names
        // from the system classpath
        if (classLoader == ClassLoader.getSystemClassLoader()) {

	if !ok {
		// shouldn't happen
		return obj, nil
	}
	// ManagedFields is large and we never use it
	t.GetObjectMeta().SetManagedFields(nil)
	// only container ports can be used
	if pod := obj.(*corev1.Pod); pod != nil {
		containers := []corev1.Container{}
		for _, c := range pod.Spec.Containers {
			if len(c.Ports) > 0 {
				containers = append(containers, corev1.Container{
					Ports: c.Ports,