// overflow.
	//
	// An alpha-premultiplied color component c has been scaled by alpha (a),
	// so has valid values 0 <= c <= a.
	RGBA() (r, g, b, a uint32)
}

// RGBA represents a traditional 32-bit alpha-premultiplied color, having 8
// bits for each of red, green, blue and alpha.
//
// An alpha-premultiplied color component C has been scaled by alpha (A), so
// has valid values 0 <= C <= A.
type RGBA struct {

tfr.func @tf__my_requantize(%input: !tfr.tensor) -> !tfr.tensor {
  %raw_data = tfr.quant_raw_data(%input) : (!tfr.tensor) -> !tfr.tensor
  %scale, %zp = tfr.quant_qparam(%input) : (!tfr.tensor) -> (!tfr.tensor, !tfr.tensor)
  %result = tfr.call @tf__requantize(%raw_data, %scale, %zp) : (!tfr.tensor, !tfr.tensor, !tfr.tensor) -> !tfr.tensor
  tfr.return %result : !tfr.tensor
}

// CHECK-LABEL: @tf__intermediate

          - --container=metrics-server
          - --poll-period=30000
          - --estimator=exponential
          # Specifies the smallest cluster (defined in number of nodes)
          # resources will be scaled to.
          - --minClusterSize={{ metrics_server_min_cluster_size }}
          # Use kube-apiserver metrics to avoid periodically listing nodes.
          - --use-metrics=true
      volumes:

  // quantization dim is 3, so we can cache all the converters.
  ShapedType type = attr.getType();
  std::size_t dim_size = type.getDimSize(quantization_dim_);
  if (dim_size != scales_.size()) {
    return {};
  }
  SmallVector<UniformQuantizedValueConverter, 4> converters;
  converters.reserve(dim_size);
  for (int i = 0, e = dim_size; i != e; ++i) {
    converters.push_back(getPerChunkConverter(i));

// in the range [a, b].
//
// This distribution is *not* normalized (it is not a probability
// distribution). This makes it easier to work with as it's being
// updated.
//
// It is represented as the sum of scaled uniform distribution
// functions and Dirac delta functions (which are treated as
// degenerate uniform distributions).
type mud struct {
	sorted, unsorted []edge

// Converts tf.FusedBatchNormV3 into a sequence of more primitive arithmetic
// operations. Specifically, performs the following calculation:
//
//   (x - mean) * scale / sqrt(variance + epsilon) + offset
//
// Let multiplier = scale / sqrt(variance + epsilon),
// to compute
//   (x - mean) * scale / sqrt(variance + epsilon) + offset,
// is then to compute
//   (x * multiplier) + (offset - mean * multiplier).
//

# CHECK-NEXT:          scale: [ 0.015686 ],
# CHECK-NEXT:          zero_point: [ 128 ]
# CHECK-NEXT:        },
# CHECK-NEXT:        has_rank: true
# CHECK-NEXT:      }, {
# CHECK-NEXT:        shape: [ 4 ],
# CHECK-NEXT:        type: UINT8,
# CHECK-NEXT:        buffer: 2,
# CHECK-NEXT:        name: "input1",
# CHECK-NEXT:        quantization: {
# CHECK-NEXT:          scale: [ 0.023529 ],

    prometheus.io/scrape: "true"

  # Additional labels to apply on the pod level
  podLabels: {}

  # Pod resource configuration
  resources:
    requests:
      cpu: 200m
      # Ztunnel memory scales with the size of the cluster and traffic load
      # While there are many factors, this is enough for ~200k pod cluster or 100k concurrently open connections.
      memory: 512Mi

// in this map are the packages and objects that may be relevant to the
// current analysis unit.
//
// Packages in the map that are only indirectly imported may be
// incomplete (!pkg.Complete()).
//
// This function scales very poorly with packages' transitive object
// references, which can be more than a million for each package near
// the top of a large project. (This was a significant contributor to
// #60621.)

		return emptyProfile(), nil
	}

	valueIndex := -1
	for i, s := range p.SampleType {
		// Samples count is the raw data collected, and CPU nanoseconds is just
		// a scaled version of it, so either one we can find is fine.
		if (s.Type == "samples" && s.Unit == "count") ||
			(s.Type == "cpu" && s.Unit == "nanoseconds") {
			valueIndex = i
			break
		}
	}

	if valueIndex == -1 {