implementation(projects.flowServices)
    implementation(projects.functional)
    implementation(projects.graphSerialization)
    implementation(projects.guavaSerializationCodecs)
    implementation(projects.hashing)
    implementation(projects.inputTracking)
    implementation(projects.instrumentationAgentServices)
    implementation(projects.logging)
    implementation(projects.persistentCache)
    implementation(projects.problemsApi)

		HostSelectionRetryMaxAttempts: 5,
	}
	return &policy
}

// DefaultConsistentHashPolicy gets a copy of the default retry policy without previous host predicate.
// When Consistent Hashing is enabled, we don't want to use other hosts during retries.
func DefaultConsistentHashPolicy() *route.RetryPolicy {
	return defaultPolicy()
}

// ConvertPolicy converts the given Istio retry policy to an Envoy policy.
//

	// RFC 4122 conformance (see RFC 4122 Sections 4.2.2, 4.1.3). We
	// want the "version" of this UUID to appear as 'hashed' as opposed
	// to random or time-based.  This is something of a fiction since
	// we're not actually hashing using MD5 or SHA1, but it seems better
	// to use this UUID flavor than any of the others. This is similar
	// to how other linkers handle this (for example this code in lld:

            return delegate.hash(file, length, lastModified)
        }

        private void checkIfAllowed() {
            if (!hashingAllowed) {
                throw new UnsupportedOperationException("Hashing is currently not allowed")
            }
        }

        void allowHashing(boolean allowed) {
            this.hashingAllowed = allowed
        }
    }

import org.gradle.test.preconditions.IntegTestPreconditions
import org.gradle.wrapper.WrapperExecutor
import org.junit.Rule
import spock.lang.Shared

import static org.gradle.internal.hash.Hashing.sha256

@Requires(value = IntegTestPreconditions.NotEmbeddedExecutor, reason = NOT_EMBEDDED_REASON)
@LocalOnly(because = "https://github.com/gradle/gradle-private/issues/3799")

import java.util.Set;
import java.util.function.Supplier;

import static org.gradle.api.internal.cache.CacheConfigurationsInternal.DEFAULT_MAX_AGE_IN_DAYS_FOR_CREATED_CACHE_ENTRIES;
import static org.gradle.internal.hash.Hashing.hashString;
import static org.gradle.internal.time.TimestampSuppliers.daysAgo;

public class DefaultVersionControlRepositoryFactory implements VersionControlRepositoryConnectionFactory, Stoppable {

    api(project(":enterprise-operations"))
    api(project(":execution"))
    api(project(":file-collections"))
    api(project(":file-temp"))
    api(project(":files"))
    api(project(":functional"))
    api(project(":hashing"))
    api(project(":logging"))
    api(project(":messaging"))
    api(project(":model-core"))
    api(project(":persistent-cache"))
    api(project(":problems-api"))
    api(project(":resources"))

//  - short-circuit instantiation cycles
//
// For the latter purpose, we must always have a context during instantiation,
// whether or not it is supplied by the user. For both purposes, it must be the
// case that hashing a pointer-identical type produces consistent results
// (somewhat obviously).
//
// However, neither of these purposes require that our hash is perfect, and so

    api(project(":build-operations"))
    api(project(":concurrent"))
    api(project(":core"))
    api(project(":core-api"))
    api(project(":dependency-management"))
    api(project(":hashing"))
    api(project(":internal-testing")) {
        because("Part of the public API")
    }
    api(project(":stdlib-java-extensions"))
    api(project(":jvm-services")) {

#define TENSORFLOW_COMPILER_MLIR_LITE_QUANTIZATION_DEVICE_TARGET_H_

#include <functional>
#include <optional>

#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/Hashing.h"
#include "llvm/ADT/MapVector.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/ErrorHandling.h"