* }
 *
 * The calls to {@link #isSubtype} and {@link #notSubtype} tells the framework what assertions need
 * to be made.
 *
 * <p>The declaration methods must be public.
 */
@AndroidIncompatible // only used by android incompatible tests.
@NullUnmarked
abstract class SubtypeTester implements Cloneable {

  /** Annotates a public method that declares subtype assertion. */
  @RequiredModifiers(modifier = Modifier.PUBLIC)

                return o instanceof DefaultModelBuilderRequest that
                        && locationTracking == that.locationTracking
                        && recursive == that.recursive
                        && requestType == that.requestType
                        && Objects.equals(source, that.source)
                        && Objects.equals(profiles, that.profiles)

_tf2.enable()

# API IMPORTS PLACEHOLDER

# WRAPPER_PLACEHOLDER

# Make sure directory containing top level submodules is in
# the __path__ so that "from tensorflow.foo import bar" works.
# We're using bitwise, but there's nothing special about that.
_API_MODULE = _sys.modules[__name__].bitwise
_tf_api_dir = _os.path.dirname(_os.path.dirname(_API_MODULE.__file__))
_current_module = _sys.modules[__name__]

/**
 * A collection that supports order-independent equality, like {@link Set}, but may have duplicate
 * elements. A multiset is also sometimes called a <i>bag</i>.
 *
 * <p>Elements of a multiset that are equal to one another are referred to as <i>occurrences</i> of
 * the same single element. The total number of occurrences of an element in a multiset is called

 * API</h2>
 *
 * <p>The successor to Guava's caching API is <a
 * href="https://github.com/ben-manes/caffeine/wiki">Caffeine</a>. Its API is designed to make it a
 * nearly drop-in replacement. Note that it is not available for Android or GWT/J2CL and that it may
 * have <a href="https://github.com/ben-manes/caffeine/wiki/Guava">different (usually better)
 * behavior</a> when multiple threads attempt concurrent mutations. Its equivalent to {@code

### Gradle runtimes

Gradle is also made up of several different processes that work together to "run the build", such as the Gradle daemon and the `gradlew` command.

Each process, or "runtime", applies different constraints to the code that runs in that process.
For example, each process has different supported JVMs and a different set of services available for dependency injection.

 *
 * <p>Example usage of {@code ComparisonChain}:
 *
 * {@snippet :
 * public int compareTo(Foo that) {
 *   return ComparisonChain.start()
 *       .compare(this.aString, that.aString)
 *       .compare(this.anInt, that.anInt)
 *       .compare(this.anEnum, that.anEnum, Ordering.natural().nullsLast())
 *       .result();
 * }
 * }
 *

            if (obj instanceof CacheKey that) {
                return Objects.equals(this.artifactId, that.artifactId)
                        && Objects.equals(this.groupId, that.groupId)
                        && Objects.equals(this.version, that.version)
                        && Objects.equals(this.localRepo, that.localRepo)
                        && Objects.equals(this.workspace, that.workspace)

 * extends {@code AbstractPackageSanityTests}. Currently sanity checks include {@link
 * NullPointerTester}, {@link EqualsTester} and {@link SerializableTester}. For example:
 *
 * <pre>
 * public class PackageSanityTests extends AbstractPackageSanityTests {}
 * </pre>
 *
 * <p>Note that only top-level classes with either a non-private constructor or a non-private static

     *
     * @param service The service that failed.
     */
    public void failure(Service service) {}
  }

  /**
   * An encapsulation of all of the state that is accessed by the {@linkplain ServiceListener
   * service listeners}. This is extracted into its own object so that {@link ServiceListener} could