onAccess("container")
            return delegate.container(type)
        }

        override fun <T : Any?> container(type: Class<T>, factory: NamedDomainObjectFactory<T>): NamedDomainObjectContainer<T> {
            onAccess("container")
            return delegate.container(type, factory)
        }

        override fun <T : Any?> container(type: Class<T>, factoryClosure: Closure<*>): NamedDomainObjectContainer<T> {

	"k8s.io/apiserver/pkg/storage"
	cacherstorage "k8s.io/apiserver/pkg/storage/cacher"
	etcd3testing "k8s.io/apiserver/pkg/storage/etcd3/testing"
	"k8s.io/apiserver/pkg/storage/names"
	"k8s.io/apiserver/pkg/storage/storagebackend/factory"
	storagetesting "k8s.io/apiserver/pkg/storage/testing"
	utilfeature "k8s.io/apiserver/pkg/util/feature"
	"k8s.io/client-go/tools/cache"
	featuregatetesting "k8s.io/component-base/featuregate/testing"
)

    @SuppressWarnings("unused")
    public void failsToCheckNull(String s) {}
  }

  private static class NoPublicStaticMethods {
    @SuppressWarnings("unused") // To test non-public factory isn't used.
    static String notPublic() {
      return "";
    }
  }

  @interface MyAnnotation {}

Class <org.gradle.internal.actor.Actor> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (Actor.java:0)
Class <org.gradle.internal.actor.ActorFactory> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (ActorFactory.java:0)

    Arg<TF_NumberTensor, [{Must be a scalar.}]>:$beta1_power,
    Arg<TF_NumberTensor, [{Scaling factor. Must be a scalar.}]>:$lr,
    Arg<TF_NumberTensor, [{Momentum factor. Must be a scalar.}]>:$beta1,
    Arg<TF_NumberTensor, [{Momentum factor. Must be a scalar.}]>:$beta2,
    Arg<TF_NumberTensor, [{Ridge term. Must be a scalar.}]>:$epsilon,
    Arg<TF_NumberTensor, [{The gradient.}]>:$grad,

        verify_size(window_strides.size(), "window strides") &&
        verify_size(padding.size(), "padding entries") &&
        verify_size(lhs_dilation.size(), "lhs dilation factors") &&
        verify_size(rhs_dilation.size(), "rhs dilation factors")))
    return std::nullopt;

  xla::Window window;
  for (size_t i = 0; i < window_dimensions.size(); i++) {
    auto dim = window.add_dimensions();

		return true // eliminates special-casing 2.
	} else if (x & 1) == 0 {
		return false // eliminates even numbers >2.
	}

	limit := uint64(math.Sqrt(float64(x)))
	for factor := uint64(3); factor <= limit; factor += 2 {
		if (x % factor) == 0 {
			return false
		}
	}
	return true
}

func validateSubset(subset *networking.Subset) error {
	return appendErrors(validateSubsetName(subset.Name),

 *       anything about how the property is tested. To find out, read the code.
 *   <li>These tests are "conformance tests", and do not attempt to test throughput, latency,
 *       scalability or other performance factors (see the separate "jtreg" tests for a set intended
 *       to check these for the most central aspects of functionality.) So, most tests use the
 *       smallest sensible numbers of threads, collection sizes, etc needed to check basic

	// Ensure that if we have at least one type parameter, it is in x
	// (the earlier swap checks for _recorded_ type parameters only).
	// This ensures that the switch switches on the type parameter.
	//
	// TODO(gri) Factor out type parameter handling from the switch.
	if isTypeParam(y) {
		if traceInference {
			u.tracef("%s ≡ %s\t// swap", y, x)
		}
		x, y = y, x
	}

	// Ensure that if we have at least one type parameter, it is in x
	// (the earlier swap checks for _recorded_ type parameters only).
	// This ensures that the switch switches on the type parameter.
	//
	// TODO(gri) Factor out type parameter handling from the switch.
	if isTypeParam(y) {
		if traceInference {
			u.tracef("%s ≡ %s\t// swap", y, x)
		}
		x, y = y, x
	}