doLast {
                            def projects = []
                            def builds = []
                            registry.visitBuilds { b ->
                                builds.add(b.identityPath.path)
                                if (b.projectsLoaded) {

	@echo "Verify resolving inconsistent versions build with race"
	@(env bash $(PWD)/buildscripts/resolve-right-versions.sh)

build-debugging:
	@(env bash $(PWD)/docs/debugging/build.sh)

build: checks build-debugging ## builds minio to $(PWD)
	@echo "Building minio binary to './minio'"
	@CGO_ENABLED=0 go build -tags kqueue -trimpath --ldflags "$(LDFLAGS)" -o $(PWD)/minio 1>/dev/null

hotfix-vars:

TIP: To understand the Daemon's impact on your builds, you can profile your build with `--profile`.

In between builds, the Daemon waits idly for the next build.
As a result, your machine only loads Gradle into memory once for multiple builds instead of once per build.
This is a significant performance optimization.

=== Runtime Code Optimizations

    default DependencyResolverResult collect(@Nonnull Session session, @Nonnull DependencyCoordinate root) {
        return collect(DependencyResolverRequest.build(session, DependencyResolverRequest.RequestType.COLLECT, root));
    }

    /**
     * Collects the transitive dependencies of some artifacts and builds a dependency graph. Note that this operation is

     * These services are closed at the end of the build invocation.
     *
     * <p>{@link Build} and parent scope services are visible to {@link Gradle} scope services, but not vice versa.</p>
     */
    interface Gradle extends Build {}

    /**
     * These services are created once per project per build invocation.
     * These services are closed at the end of the build invocation.
     *

        val builds = mutableMapOf<BuildState, BuildToStore>()
        host.visitBuilds { build ->
            val state = build.state
            builds[state] = BuildToStore(build, build.hasScheduledWork, build.isRootBuild)
            if (build.hasScheduledWork && state is StandAloneNestedBuild) {
                // Also require the owner of a buildSrc build

					"jacoco",
					"launcher",
					"plugins-java",
					"antlr",
					"base-services",
					"build-cache",
					"build-cache-http",
					"build-cache-local",
					"build-cache-spi",
					"build-configuration",
					"build-events",
					"build-init",
					"build-profile",
					"composite-builds",
					"configuration-cache",
					"core",
					"core-api",
					"declarative-dsl-core",

}

// You can have a faster feedback loop by running `configuration-cache-report` as an included build
// See https://github.com/gradle/configuration-cache-report#development-with-gradlegradle-and-composite-build
dependencies {
    configurationCacheReportPath(libs.configurationCacheReport)
}

tasks.processResources {

    api(project(":build-events"))
    api(project(":build-operations"))
    api(project(":core"))
    api(project(":daemon-protocol"))
    api(project(":enterprise-operations"))
    api(project(":stdlib-java-extensions"))
    api(project(":problems-api"))
    api(project(":service-provider"))
    api(project(":tooling-api"))

    runtimeOnly(project(":composite-builds"))
    runtimeOnly(libs.groovy) // for 'Closure'

#     dbg:              Build with debug info
#
# TF version options;
#     v2: Build TF v2
#
# Feature and Third party library support options:
#     xla:          Build TF with XLA
#     tpu:          Build TF with TPU support
#     cuda:         Build with CUDA support.
#     cuda_clang    Build with CUDA Clang support.
#     rocm:         Build with AMD GPU support (rocm)