if existing.Status == condition.Status {
		if existing.Message == condition.Message &&
			existing.ObservedGeneration == condition.ObservedGeneration {
			// Skip update, no changes
			return conditions
		}
		// retain LastTransitionTime if status is not changed
		condition.LastTransitionTime = existing.LastTransitionTime
	}
	*existing = condition

	return ret
}

 *
 * Implementations can assume that their getters will be called at-most-once.
 *
 * The lifecycle of details and result objects are effectively undetermined.
 * The build scan plugin will retain the objects for a short time after the operation has
 * completed, in order to "process" them on a separate thread.
 * It can be assumed that this processing happens relatively quickly,

      readTheListUninterruptibly()
    } else {
      try {
        readCompleteLatch.await()
      } catch (_: InterruptedException) {
        Thread.currentThread().interrupt() // Retain interrupted status.
      }
    }

    check(::publicSuffixListBytes.isInitialized) {
      // May have failed with an IOException
      "Unable to load $PUBLIC_SUFFIX_RESOURCE resource from the classpath."

            effectiveScope = Artifact.SCOPE_SYSTEM;
        } else if (Artifact.SCOPE_COMPILE.equals(originalScope) && Artifact.SCOPE_COMPILE.equals(inheritedScope)) {
            // added to retain compile scope. Remove if you want compile inherited as runtime
            effectiveScope = Artifact.SCOPE_COMPILE;
        } else if (Artifact.SCOPE_TEST.equals(inheritedScope)) {
            effectiveScope = Artifact.SCOPE_TEST;

    Map<K, V> delegateMap = Maps.newHashMapWithExpectedSize(n);
    // If duplicates are allowed, this map will track the last value for each duplicated key.
    // A second pass will retain only the first entry for that key, but with this last value. The
    // value will then be replaced by null, signaling that later entries with the same key should
    // be deleted.
    Map<K, @Nullable V> duplicates = null;

[exec:patch] cmp go.sum go.sum.tidyResult

go list -m all
cmp stdout m_all.txt

go mod edit -go=1.16
go list -m all
cmp stdout m_all.txt


# If we explicitly drop compatibility with 1.16, we retain fewer checksums,
# which gives a cleaner go.sum file but causes 1.16 to fail in readonly mode.

cp go.mod.orig go.mod
go mod tidy -compat=1.17
cmp go.mod go.mod.orig

# Make sure that -diff behaves the same as tidy.

	GetPreviousValue(previousRootHash, key string) (result string, err error)
}

type smtLedger struct {
	tree *smt
}

// Make returns a Ledger which will retain previous nodes after they are deleted.
func Make(retention time.Duration) Ledger {
	return smtLedger{tree: newSMT(hasher, nil, retention)}
}

            calibrated_type.getMin(), calibrated_type.getMax(),
            /*narrowRange=*/false, calibrated_type.getExpressedType(),
            /*isSigned=*/this->quant_specs_.IsSignedInferenceType());
        if (this->quant_specs_.legacy_float_scale) {
          qtype = mlir::cast<UniformQuantizedType>(
              quant::DownCastScale(qtype, calibrated_type.getMin(),

		verifyOwnerRefs := func(claim *v1.PersistentVolumeClaim, condemned bool) {
			podName := getClaimPodName(set, claim)
			const retain = apps.RetainPersistentVolumeClaimRetentionPolicyType
			const delete = apps.DeletePersistentVolumeClaimRetentionPolicyType
			switch {
			case scaledownPolicy == retain && deletionPolicy == retain:
				if hasNamedOwnerRef(claim, podName) || hasNamedOwnerRef(claim, set.Name) {

            return null;
        } else if (Artifact.SCOPE_COMPILE.equals(scope) && Artifact.SCOPE_COMPILE.equals(inheritedScope)) {
            // added to retain compile artifactScope. Remove if you want compile inherited as runtime
            desiredScope = Artifact.SCOPE_COMPILE;
        }

        if (Artifact.SCOPE_TEST.equals(inheritedScope)) {