// Builds XlaSendFromHost node, and replaces all _Retval nodes with it.
absl::StatusOr<Node*> ReplaceRetNodesWithSendFromHostNode(
    Graph* g, const string& oc_cluster_name,
    std::vector<DataType>* send_from_host_dtypes, Node* key_placeholder) {
  // TODO(b/77601805): use in nodes for sink node, instead of traversing all
  // nodes.
  std::vector<Node*> ret_nodes = GatherNodesWithType(*g, "_Retval");

var ncalls = 0

func getvar(p *int) *int {
	ncalls++
	return p
}

func iter2(list ...int) func(func(int, int) bool) {
	return func(yield func(int, int) bool) {
		for i, x := range list {
			if !yield(i, x) {
				return
			}
		}
	}
}

func testcalls() {
	var i, v int
	ncalls = 0
	si := 0
	sv := 0
	for *getvar(&i), *getvar(&v) = range iter2(1, 2) {
		si += i

			HTTPGet: &apimirror.HTTPGetAction{
				Path: "/hello/sunnyvale",
				Port: apimirror.IntOrString{IntVal: int32(appPort)},
			},
		},
		"/app-health/hello-world/livez": &Prober{
			HTTPGet: &apimirror.HTTPGetAction{
				Port: apimirror.IntOrString{IntVal: int32(appPort)},
			},
		},
	}
	simpleTCPConfig := KubeAppProbers{
		"/app-health/hello-world/readyz": &Prober{

								Protocol: v1.ProtocolUDP,
								TargetPort: intstr.IntOrString{
									Type:   0,
									IntVal: 53,
								},
							},
							{
								Name:     "dns-tcp",
								Port:     53,
								Protocol: v1.ProtocolTCP,
								TargetPort: intstr.IntOrString{
									Type:   0,
									IntVal: 53,
								},
							},
						},
						Selector: map[string]string{

      // CHECK-NEXT: }

      tf_executor.fetch %outputs_10#0 : tensor<?x2xi64>
    }
    func.return %0#0 : tensor<?x2xi64>
    // CHECK:      name: "ParseExample/ParseExampleV2"
    // CHECK-NEXT: op: "_Retval"
    // CHECK-NEXT: input: "ParseExample"

  }

  auto a = ops::_Arg(scope.WithOpName("A"), DT_INT32, 0);
  auto b = ops::_Arg(scope.WithOpName("B"), DT_INT32, 1);
  auto c = ops::Add(scope.WithOpName("C"), a, b);
  auto d = ops::_Retval(scope.WithOpName("D"), c, 0);
  TF_RETURN_IF_ERROR(scope.ToGraph(graph.get()));
  return graph;
}

StatusOr<FunctionDef> SampleFuntionAddXY(const std::string& name) {
  TF_ASSIGN_OR_RETURN(auto graph, SampleGraphAddXY());

// following steps:
//
// 1. Add a XLA computation key placeholder node (it will be used as input for
//    XlaRecvAtHost and XlaSendFromHost);
// 2. Replace all _Arg nodes with one single XlaRecvAtHost node;
// 3. Replace all _Retval nodes with one single XlaSendFromHost node;
// 4. Mark all nodes except key placeholder with attr `xla_cluster_attr_name`
//    and `outside_compilation_attr_name`;

	switch rval := result.(type) {
	case string:
		return FromString(rval), nil
	case float64:
		return FromFloat(rval), nil
	case int64:
		return FromInt(rval), nil
	case uint64:
		if rval <= math.MaxInt64 {
			return FromInt(int64(rval)), nil
		}
		return FromFloat(float64(rval)), nil
	case bool:
		return FromBool(rval), nil
	case jstream.KVS:

      count: 4
    }
  }
  unclustered_op_histogram {
    op: "NoOp"
    count: 2
  }
  unclustered_op_histogram {
    op: "_Arg"
    count: 1
  }
  unclustered_op_histogram {
    op: "_Retval"
    count: 1
  }
}
)",
      &expected_auto_clustering_activity);
  EXPECT_EQ(listener()->auto_clustering_activity().DebugString(),
            expected_auto_clustering_activity.DebugString());

                             int* num_retvals) override {
    std::vector<TFE_TensorHandle*> outputs(*num_retvals);
    TF_Status status;
    device_.execute(tensorflow::wrap(op), num_retvals, outputs.data(), &status,
                    info_);
    if (status.status.ok()) {
      for (int i = 0; i < *num_retvals; ++i) {
        retvals[i] = tensorflow::unwrap(outputs[i]);