host_context_->Await(results);

  // Check that all results are available.
  llvm::SmallVector<Tensor> ret_values;
  for (unsigned i = 1; i < results.size(); ++i) {
    if (auto* error = results[i]->GetErrorIfPresent())
      LOG(FATAL) << "Failed to execute a function: " << error->message();
    ret_values.push_back(results[i]->get<tfrt_stub::FallbackTensor>().tensor());
  }

  // Deallocate arguments.

      %new_value = "tf.ReadVariableOp"(%resource_handle)
      tf_device.return %new_value
    })
    ```

    After this pass, the computation would become:

    ```mlir
    %resource_handle = "tf.VarHandleOp"()
    %init_value = "tf.ReadVariableOp"(%resource_handle)
    %1:2 = "tf_device.cluster"() ( {
      %new_value = "tf.AddV2"(%init_value, %init_value)

    for (int i : llvm::seq<int>(0, metadata.results.size())) {
      Value original_value = metadata.results[i];
      Value new_value = cloned_remote_run_op->getResult(i);
      original_value.replaceAllUsesWith(new_value);
      mapping.map(original_value, new_value);
    }
  }
}

#define GEN_PASS_DEF_CLUSTERTFOPSBYHOSTPASS
#include "tensorflow/compiler/mlir/tensorflow/transforms/tf_passes.h.inc"

	r := NewTestREST(testResponse{result: probe.Success, data: "ok"})
	opts := metainternalversion.ListOptions{
		LabelSelector: labels.SelectorFromSet(map[string]string{
			"testLabel": "testValue",
		}),
	}
	got, err := r.List(genericapirequest.NewContext(), &opts)
	if err != nil {
		t.Fatalf("Unexpected error: %v", err)
	}
	expect := &api.ComponentStatusList{
		Items: []api.ComponentStatus{},

            valueFrom:
              fieldRef:
                apiVersion: v1
                fieldPath: new.path
          - name: GODEBUG
            value: gctrace=111
          - name: NEW_VAR
            value: new_value
        hpaSpec:
          maxReplicas: 333
          scaleTargetRef:
            name: istio-pilot
          metrics:
            - type: Resource
              resource:
                name: cpu

inline std::optional<InferenceDeviceType> GetInferenceDeviceTypeForOp(
    Operation* op) {
  auto hardware = GetTargetAnnotation(op);
  if (!hardware.has_value()) return std::nullopt;

  auto inference_type = GetInferenceTypeAnnotation(op);
  if (!inference_type.has_value()) return std::nullopt;

  InferenceDeviceType inference_device_type;
  inference_device_type.hardware = hardware.value();

    | org.gradle.libraryelements | jar          |           |
    | org.gradle.status          | release      |           |
    | org.gradle.usage           | java-runtime |           |
    | custom                     | dep_value    | dep_value |

org:testA:1.0
\\--- conf

org:testB:1.0
  Variant runtime:
    | Attribute Name             | Provided     | Requested |
    |----------------------------|--------------|-----------|

        int n = replicate.getN();
        new_value = parent->getResult(operand.getOperandNumber() * n);
      } else {
        parent->emitOpError("Unsupported wrapper op.");
        return nullptr;
      }
    }
    if (!new_value) {
      return nullptr;
    } else {
      value = new_value;
    }
  }
  return value;
}

  if (n->type_string() != "Slice") {
    return false;
  }

  if (!GetXlaClusterForNode(*n).has_value()) {
    // There is no need to change slice ops outside XLA clusters.
    return false;
  }

  TF_ASSIGN_OR_RETURN(std::optional<SliceInputs> slice_inputs,
                      GetSliceInputs(n));
  if (!slice_inputs.has_value()) {
    return false;
  }

		podSum := int64(0)
		missing := len(m.Containers) == 0
		for _, c := range m.Containers {
			resValue, found := c.Usage[resource]
			if !found {
				missing = true
				klog.FromContext(ctx).V(2).Info("Missing resource metric", "resourceMetric", resource, "pod", klog.KRef(m.Namespace, m.Name))
				break
			}
			podSum += resValue.MilliValue()
		}
		if !missing {
			res[m.Name] = PodMetric{
				Timestamp: m.Timestamp.Time,