- [artifactId] tells maven what the artifact name is for this particular
       project. Each project should have a distinct artifactId.

   - [version] tells maven what release of this artifact we're trying to produce.
       The fact that a project has a distinct pom.xml should indicate a separate
       release cycle that is also distinct to that project, so a concrete version
       declaration is required.

# This is the official list of TensorFlow authors for copyright purposes.
# This file is distinct from the CONTRIBUTORS files.
# See the latter for an explanation.

# Names should be added to this file as:
# Name or Organization <email address>
# The email address is not required for organizations.

Google Inc.
Yuan Tang <******@****.***>

        }
        val descriptor = getSymbolDescriptor(callableSymbol) as? CallableMemberDescriptor ?: return emptyList()
        return getOverriddenDescriptors(descriptor, true).mapNotNull { it.toKtCallableSymbol(analysisContext) }.distinct()
    }

    override fun <T : KtSymbol> getDirectlyOverriddenSymbols(callableSymbol: T): List<KtCallableSymbol> {
        if (callableSymbol is KtValueParameterSymbol) {

        val previousVersions = (listOf(latestRelease) + releasedVersions.finalReleases).filter { it.gradleVersion() >= lowestInterestingVersion && it.gradleVersion().baseVersion < currentBaseVersion }.distinct()
        allPreviousVersions = previousVersions.map { it.gradleVersion() }
        mostRecentRelease = previousVersions.first().gradleVersion()
        mostRecentSnapshot = releasedVersions.latestReleaseSnapshot.gradleVersion()

copies of a package at different versions if the package is
imported normally and vendored by the standard library.

Vendored packages are internally renamed with a "vendor/" prefix
to preserve the invariant that all packages have distinct paths.
This is necessary to avoid compiler and linker conflicts. Adding
a "vendor/" prefix also maintains the invariant that standard
library packages begin with a dotless path element.

    findTests(listOf(testSelector))
      .filter { it.isContainer }
      .mapNotNull { (it as? ClassBasedTestDescriptor)?.testClass?.name }
      .filterNot { it in avoidedTests }
      .sorted()
      .distinct()
  knownTestFile.writeText(testClasses.joinToString("\n"))

                )
            )
        )
    }

    override val importsToAdd: List<String>
        get() = (mappingConversionForKeys.importsToAdd + mappingConversionForValues.importsToAdd).distinct()
}

class HLPairParameterConversion(
    private val mappingConversionFirst: HLParameterConversion,
    private val mappingConversionSecond: HLParameterConversion,
) : HLParameterConversion() {

                    add(entry.value.firstOrNull { !it.contains("-") })
                    add(entry.value.first())
                }
            }
            add(minimumSupported)
        }.filterNotNull().distinct().sorted()
        return latests.subList(latests.indexOf(minimumSupported), latests.size)
    }

            .flatMap { node ->
                node.followingNodes
                    .filter { it !is StubNode }
                    .map { it.unwrap() }
                    .distinct()
                    .sortedBy { it.id }
            }.distinct()

        return exitPoints.size > 1
    }

    private fun CFGNode<*>.unwrap(): CFGNode<*> {
        var current = this

        while (current.isExitNode()) {

# > on the host machine. If we don't have --distinct_host_configuration=false,
# > the core TensorFlow code will be built once for the host and once for the
# > target platform.
# See also https://docs.bazel.build/versions/master/guide.html#build-configurations-and-cross-compilation
build --distinct_host_configuration=false

# Disable clang extension that rejects type definitions within offsetof.