// Function return values are all the terminator operands + pass through
  // extern values (if enabled).
  auto return_values = llvm::to_vector<4>(terminator->getOperands());
  if (only_one_return_value) {
    return_values.resize(1);
  }
  if (extern_values_passthrough)
    return_values.insert(return_values.end(),
                         first_block.args_begin() + num_region_arguments,

  llvm::SetVector<Value> return_values;
  llvm::SmallVector<Type> return_types;

  for (Operation *op : cluster.operations)
    for (OpOperand &use : op->getUses()) {
      // User is inside the cluster.
      if (in_cluster.contains(use.getOwner())) continue;
      // Do not return the same value multiple times.
      if (return_values.contains(use.get())) continue;

  }
  for (Operation* op : cloning_ops) {
    builder.clone(*op, mapping);
  }

  SmallVector<Value> return_values;
  for (Value result : results) {
    return_values.push_back(mapping.lookupOrNull(result));
  }
  builder.create<func::ReturnOp>(location, return_values);

  // Create a function call to the newly created function.
  StringAttr new_func_name =

        tensorflow::XlaExpression::CastExpressionFromTensor(*output);
    output_values.push_back(expr->AsXlaOp(&xla_builder_));
  }

  absl::Span<const xla::XlaOp> return_values(output_values);
  xla::XlaOp root_value = xla::Tuple(&xla_builder_, return_values);

  TF_ASSIGN_OR_RETURN(XlaComputation computation,
                      xla_builder_.Build(root_value,

    String result =
        timeLimiter.callWithTimeout(
            Callables.returning(RETURN_VALUE), DELAY_MS, TimeUnit.MILLISECONDS);

    assertThat(result).isEqualTo(RETURN_VALUE);
  }

  public void testCallWithTimeout_wrapsCheckedException() throws Exception {
    Exception exception = new SampleCheckedException();
    ExecutionException e =
        assertThrows(

    String result =
        timeLimiter.callWithTimeout(
            Callables.returning(RETURN_VALUE), DELAY_MS, TimeUnit.MILLISECONDS);

    assertThat(result).isEqualTo(RETURN_VALUE);
  }

  public void testCallWithTimeout_wrapsCheckedException() throws Exception {
    Exception exception = new SampleCheckedException();
    ExecutionException e =
        assertThrows(

      b.create<SelectOp>(index_type, compare_dt, lhs_index, rhs_index);
  Value selected_index =
      b.create<SelectOp>(index_type, compare_eq, min_index, min_val_index);

  Value return_values[] = {selected_input, selected_index};
  b.create<ReturnOp>(return_values);
}

//===----------------------------------------------------------------------===//
// PartitionedCall op utilities.

library {
  function {
    signature {
      name: "foo"
      input_arg {
        name: "arg"
        type: DT_INT32
      }
      output_arg {
        name: "return_value"
        type: DT_INT32
      }
    }
    ret {
      key: "return_value"
      value: "arg"
    }
  }
}
versions {
  producer: 62
  min_consumer: 12
}

    public T withBackoffAndRetry(Callable<T> operation) {
        int backoff = initialBackOff;
        int retries = 0;
        T returnValue = null;
        while (retries < maxDeployAttempts) {
            retries++;
            Throwable failure;
            try {
                returnValue = operation.call();
                if (retries > 1) {

  IRMapping new_op_mapper;
  for (Operation& op : function_body.getOps()) {
    if (llvm::isa<func::ReturnOp>(op)) {
      for (auto [call_result, return_value] :
           llvm::zip_equal(call_op.getResults(), op.getOperands())) {
        Value new_result = new_op_mapper.lookup(return_value);

        call_result.replaceAllUsesWith(new_result);
      }
      continue;
    }