const auto [iter, inserted] = source_uses.emplace(
          itensor,
          TensorUse{/*first_use=*/ioperation, /*last_use=*/ioperation});
      if (!inserted) {
        // Otherwise, update last_use.
        iter->second.last_use = ioperation;
      }
    }
  }

  deltas.reserve(2 * source_uses.size());

  for (const auto& [itensor, source] : source_uses) {

    // The operation that makes the first use of this tensor.
    int first_use() const { return *operations.begin(); }

    // The operation that makes the last use of this tensor.
    int last_use() const { return *operations.rbegin(); }
  };

  // The operators.
  struct Operation {
    bool is_stateful = false;  // Results of an Operation can be rematerialized

        this.lastBusy = -1; // Will be overwritten by setIdle if not idle.
        setState(state);
    }

    private DaemonInfo(Address address, DaemonContext context, byte[] token, State state, long lastBusy) {
        this.address = address;
        this.context = context;
        this.token = token;
        this.state = state;
        this.lastBusy = lastBusy;
        this.clock = Time.clock();
    }

		buf                            strings.Builder
		lastCase, nextCase, nextNumber bool // upper case == true
		curCase                        = value[0] <= 'Z' && value[0] >= 'A'
	)

	for i, v := range value[:len(value)-1] {
		nextCase = value[i+1] <= 'Z' && value[i+1] >= 'A'
		nextNumber = value[i+1] >= '0' && value[i+1] <= '9'

		if curCase {
			if lastCase && (nextCase || nextNumber) {
				buf.WriteRune(v + 32)

	require.True(t, ok)
	assert.Equal(zero, container1.firstDetected)
	assert.Equal(zero, container1.lastUsed)
	container2, ok := manager.getImageRecord(imageID(1))
	require.True(t, ok)
	assert.Equal(zero, container2.firstDetected)
	assert.True(container2.lastUsed.Equal(withContainer.lastUsed))
}

func TestDetectImagesWithRemovedImages(t *testing.T) {
	ctx := context.Background()

		// Images that are currently in used were given a newer lastUsed.
		if image.lastUsed.Equal(freeTime) || image.lastUsed.After(freeTime) {
			klog.V(5).InfoS("Image ID was used too recently, not eligible for garbage collection", "imageID", image.id, "lastUsed", image.lastUsed, "freeTime", freeTime)
			continue
		}

		// Avoid garbage collect the image if the image is not old enough.

		// since the legacy token starts to track.
		lastUsed, ok := secret.Labels[serviceaccount.LastUsedLabelKey]
		if ok {
			_, err := time.Parse(dateFormat, lastUsed)
			if err != nil {
				// the lastUsed value is not well-formed thus we cannot determine it
				logger.Error(err, "Parsing lastUsed time", "secret", klog.KRef(secret.Namespace, secret.Name))
				continue
			}
			if lastUsed >= preserveUsedOnOrAfter {
				continue
			}

	now := time.Now().UTC()
	today := now.Format("2006-01-02")
	tomorrow := now.AddDate(0, 0, 1).Format("2006-01-02")
	lastUsed := secret.Labels[LastUsedLabelKey]
	if lastUsed != today && lastUsed != tomorrow {
		patchContent, err := json.Marshal(applyv1.Secret(secret.Name, secret.Namespace).WithUID(secret.UID).WithLabels(map[string]string{LastUsedLabelKey: today}))
		if err != nil {

                )
            }
        }
    }

    GradleDistDirs versionedDistDirs(String version, MarkerFileType lastUsed, String customDistName) {
        def distVersion = GradleVersion.version(version)
        return new GradleDistDirs(
            createVersionSpecificCacheDir(distVersion, lastUsed),
            createDistributionChecksumDir(distVersion).parentFile,

	// allocated.
	//
	// Only the first 10 bits are used.
	inUse uint16

	// lastInUse indicates how many pages in this chunk were allocated
	// when we transitioned from gen-1 to gen.
	//
	// Only the first 10 bits are used.
	lastInUse uint16

	// gen is the generation counter from a scavengeIndex from the
	// last time this scavChunkData was updated.
	gen uint32