FSQuotaAccounting QuotaType = 1 << iota
	// FSQuotaEnforcing for quotas for enforcement
	FSQuotaEnforcing QuotaType = 1 << iota
)

// FirstQuota is the quota ID we start with.
// XXXXXXX Need a better way of doing this...
var FirstQuota QuotaID = 1048577

// MountsFile is the location of the system mount data
var MountsFile = "/proc/self/mounts"

// MountParseRegexp parses out /proc/sys/self/mounts

# Testcase inspired by issue #58770, intended to verify that we're
# doing the right thing when running "go test -coverpkg=./... ./..."
# on a collection of packages where some have init functions and some
# do not, some have tests and some do not.

[short] skip
[!GOEXPERIMENT:coverageredesign] skip

# Verify correct statements percentages. We have a total of 10
# statements in the packages matched by "./..."; package "a" (for

            drop:
            - ALL
            add: # See https://man7.org/linux/man-pages/man7/capabilities.7.html
            - NET_ADMIN # Required for TPROXY and setsockopt
            - SYS_ADMIN # Required for `setns` - doing things in other netns
            - NET_RAW # Required for RAW/PACKET sockets, TPROXY
          readOnlyRootFilesystem: true
          runAsGroup: 1337
          runAsNonRoot: false
          runAsUser: 0

     */
    public void setDelete(Object target) {
        this.paths.setFrom(target);
    }

    /**
     * Returns if symlinks should be followed when doing a delete.
     *
     * @return true if symlinks will be followed.
     */
    @Input
    public boolean isFollowSymlinks() {
        return followSymlinks;
    }

    /**

or by having a new failing test, given the current slow feedback cycle, it can
be difficult to track the exact commit that triggered the regression.

The most convenient way to find the commit is to use `git bisect`. Before doing so
you need to
 1. identify the test that exposes the regression
 2. set up the test to search only for the regression you are looking after to speed up the search for the regression.

calls. While in general the number of recursive calls can change the time
analysis, in this case doing three calls does not change the analysis:

	T(n) = 3T(n/2) + O(n) + O(n^log₂3)

ends up being T(n) = O(n^log₂3). Because the Karatsuba multiplication taking
time O(n^log₂3) is itself doing 3 half-sized recursions, doing three for the
division does not hurt the asymptotic performance. Of course, it is likely

====
include::sample[dir="kotlin",files="settings.gradle.kts[]"]
include::sample[dir="groovy",files="settings.gradle[]"]
====

After doing so, you can reference any tasks in the included builds directly on the command line in order to execute.

```
gradle :my-app:app:run
```

    compileOnly(libs.eclipseSisuPlexus) {
        exclude(module = "cdi-api") // To respect the Maven exclusion
    }
    compileOnly(libs.maven3Compat)

    // 3 dependencies below are recommended as implementation but doing so adds them to the distribution
    // TODO Check why we reference them and if so, why they don't need to be in the distribution
    compileOnly(libs.maven3Artifact)
    compileOnly(libs.mavenResolverApi)

        //
        // Note that we are not capturing this value in the actual inputs of the work; doing so would cause unnecessary cache misses.
        // This is why the hash is captured here and not in visitIdentityInputs().
        FileSystemLocationSnapshot inputArtifactSnapshot = fileSystemAccess.read(inputArtifact.getAbsolutePath());

  # module.
  #
  # If there is a call to an exported function, we create a wrapper function
  # that forwards to the other function and put the tf_saved_model attributes on
  # the wrapper.
  #
  # The reason for doing this is so that later interprocedural passes don't have
  # to worry about what to do with these attributes.
  # An example of where this would happen is when converting to XLA, which