continue
				}
				var v any
				if row.Counter != nil {
					cv := *row.Counter.Value
					key := toMetricKey(row, metric)
					if delta, f := m.deltas[key]; f {
						cv -= delta
					}
					v = cv
				} else if row.Gauge != nil {
					v = *row.Gauge.Value
				} else if row.Histogram != nil {
					v = row.Histogram
				}
				err := compare(v)

	// Create a YCbCr image m, whose bounds are r translated by (delta.X, delta.Y).
	r1 := r.Add(delta)
	m := NewYCbCr(r1, subsampleRatio)

	// Test that the image buffer is reasonably small even if (delta.X, delta.Y) is far from the origin.
	if len(m.Y) > 100*100 {
		t.Errorf("r=%v, subsampleRatio=%v, delta=%v: image buffer is too large",
			r, subsampleRatio, delta)
		return
	}

const DefaultPhysPageSize = goarch.DefaultPhysPageSize

// PCQuantum is the minimal unit for a program counter (1 on x86, 4 on most other systems).
// The various PC tables record PC deltas pre-divided by PCQuantum.
const PCQuantum = goarch.PCQuantum

// Int64Align is the required alignment for a 64-bit integer (4 on 32-bit systems, 8 on 64-bit).
const Int64Align = goarch.PtrSize

const DefaultPhysPageSize = _DefaultPhysPageSize

// PCQuantum is the minimal unit for a program counter (1 on x86, 4 on most other systems).
// The various PC tables record PC deltas pre-divided by PCQuantum.
const PCQuantum = _PCQuantum

// Int64Align is the required alignment for a 64-bit integer (4 on 32-bit systems, 8 on 64-bit).
const Int64Align = PtrSize

  int64_t max_micros = 0;  // Maximum microseconds to run, ignored if <= 0.
};

// Stats holds statistics collected during benchmarking.
struct Stats {
  std::vector<int64_t> per_iter_us;  // Per-iteration deltas in us.
  int64_t total_us;                  // Total time in us.

  Stats() : total_us(0) { per_iter_us.reserve(5000); }
};

// DumpStatsToStdout printfs to stdout stats in a multi-line human-friendly
// form.

		return nil, model.DefaultXdsLogDetails, nil
	}
	clusters, logs := c.ConfigGenerator.BuildClusters(proxy, req)
	return clusters, logs, nil
}

// GenerateDeltas for CDS currently only builds deltas when services change. todo implement changes for DestinationRule, etc
func (c CdsGenerator) GenerateDeltas(proxy *model.Proxy, req *model.PushRequest,
	w *model.WatchedResource,

	_ = complex128(maxUint64)
)

// TODO(gri) find smaller deltas below

const delta32 = maxFloat32/(1 << 23)

const (
	_ float32 = - /* ERROR "overflow" */ (maxFloat32 + delta32)
	_ float32 = -maxFloat32
	_ float32 = maxFloat32
	_ float32 = maxFloat32 /* ERROR "overflow" */ + delta32

	_ = float32(- /* ERROR "cannot convert" */ (maxFloat32 + delta32))
	_ = float32(-maxFloat32)
	_ = float32(maxFloat32)

        "run again after ${formatDuration(executeNanoTime - now)}"
      } else {
        "scheduled after ${formatDuration(executeNanoTime - now)}"
      }
    }

    // Insert in chronological order. Always compare deltas because nanoTime() is permitted to wrap.
    var insertAt = futureTasks.indexOfFirst { it.nextExecuteNanoTime - now > delayNanos }
    if (insertAt == -1) insertAt = futureTasks.size
    futureTasks.add(insertAt, task)

  }

  /** Returns a new bias. */
  private fun adapt(
    delta: Int,
    numpoints: Int,
    first: Boolean,
  ): Int {
    var delta =
      when {
        first -> delta / DAMP
        else -> delta / 2
      }
    delta += (delta / numpoints)
    var k = 0
    while (delta > ((BASE - TMIN) * TMAX) / 2) {
      delta /= (BASE - TMIN)
      k += BASE
    }

issue:
  - 47949
releaseNotes:
  - |
    **Enabled** [Delta xDS](https://www.envoyproxy.io/docs/envoy/latest/api-docs/xds_protocol#incremental-xds) by default. See upgrade notes for more information.
upgradeNotes:
  - title: Delta xDS on by default
    content: |
      In previous versions, Istio used the "State of the world" xDS protocol to configure Envoy.