String desiredScope = Artifact.SCOPE_RUNTIME;

        if (inheritedScope == null) {
            desiredScope = scope;
        } else if (Artifact.SCOPE_TEST.equals(scope) || Artifact.SCOPE_PROVIDED.equals(scope)) {
            return null;
        } else if (Artifact.SCOPE_COMPILE.equals(scope) && Artifact.SCOPE_COMPILE.equals(inheritedScope)) {

                    validateMinimumSupported(minimumSupported, gradleMajor)
                    gradleMajor
                }

                else -> {
                    val gradlePreviousMajor = VersionNumber.version(gradleMajor.major - 1)
                    validateMinimumSupported(minimumSupported, gradlePreviousMajor)

                        ssn.setAttribute("NtlmHttpChal", chal);
                    }
                    dc = chal.dc;
                    challenge = chal.challenge;
                } else {
                    dc = UniAddress.getByName(domainController, true);
                    challenge = SmbSession.getChallenge(dc);
                }

                ntlm = NtlmSsp.authenticate(req, resp, challenge);

      double populationCovariance = stats.populationCovariance();
      if (values.hasAnyNonFinite()) {
        assertWithMessage("population covariance of %s", values).that(populationCovariance).isNaN();
      } else {
        assertWithMessage("population covariance of %s", values)
            .that(populationCovariance)
            .isWithin(ALLOWED_ERROR)
            .of(MANY_VALUES_SUM_OF_PRODUCTS_OF_DELTAS / MANY_VALUES_COUNT);

    Count frequency = backingMap.get(element);
    int oldCount;
    if (frequency == null) {
      oldCount = 0;
      backingMap.put(element, new Count(occurrences));
    } else {
      oldCount = frequency.get();
      long newCount = (long) oldCount + (long) occurrences;
      checkArgument(newCount <= Integer.MAX_VALUE, "too many occurrences: %s", newCount);
      frequency.add(occurrences);

      double populationCovariance = stats.populationCovariance();
      if (values.hasAnyNonFinite()) {
        assertWithMessage("population covariance of %s", values).that(populationCovariance).isNaN();
      } else {
        assertWithMessage("population covariance of %s", values)
            .that(populationCovariance)
            .isWithin(ALLOWED_ERROR)
            .of(MANY_VALUES_SUM_OF_PRODUCTS_OF_DELTAS / MANY_VALUES_COUNT);

			sourceFailed = true
		} else if srcSize != srcCtnt.Size {
			fmt.Printf("unreadable on source - size differs upon read: %s\n", srcCtnt.Key)
			sourceFailed = true
		}
	}()
	go func() {
		defer wg.Done()
		tgtSize, err := io.Copy(tgtSha256, tobj)
		if err != nil {
			fmt.Printf("unreadable on target: %s (%s)\n", tgtCtnt.Key, err)
			targetFailed = true
		} else if tgtSize != tgtCtnt.Size {

# public read-only cache.
# The cache configs are different for MacOS and Linux
if [[ $(uname -s) == "Darwin" ]]; then
  TFCI_BAZEL_COMMON_ARGS="$TFCI_BAZEL_COMMON_ARGS --config tf_public_macos_cache_push"
else
  TFCI_BAZEL_COMMON_ARGS="$TFCI_BAZEL_COMMON_ARGS --config tf_public_cache_push"

			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Parts")
				return
			}
			if cap(z.Parts) >= int(zb0002) {
				z.Parts = (z.Parts)[:zb0002]
			} else {
				z.Parts = make([]CompletePart, zb0002)
			}
			for za0001 := range z.Parts {
				bts, err = z.Parts[za0001].UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "Parts", za0001)
					return

func (update Update) Build(builder Builder) {
	if update.Modifier != "" {
		builder.WriteString(update.Modifier)
		builder.WriteByte(' ')
	}

	if update.Table.Name == "" {
		builder.WriteQuoted(currentTable)
	} else {
		builder.WriteQuoted(update.Table)
	}
}

// MergeClause merge update clause
func (update Update) MergeClause(clause *Clause) {
	if v, ok := clause.Expression.(Update); ok {
		if update.Modifier == "" {