// CHECK-NEXT: op: "Identity"
// CHECK-NEXT: input: "bar"
// CHECK: name: "[[BAR_ID_1:.*]]"
// CHECK-NEXT: op: "Identity"
// CHECK-NEXT: input: "[[BAR_ID_0]]"
// CHECK: name: "Add"
// CHECK-NEXT: op: "_Retval"

      %control_23 = "tf_executor.island"() ({
        "tf._Retval"(%output) {T = f32, device = "/job:localhost/replica:0/task:0/device:CPU:0", index = 0 : i64} : (tensor<*xf32>) -> ()
        "tf_executor.yield"() : () -> ()
      }) : () -> !tf_executor.control

          dim {
            size: 1
          }
        }
      }
    }
  }
}
# Return value to ensure not pruned if we want to run passes post.
node {
  name: "rets_0"
  op: "_Retval"
  input: "RaggedToTensor"
  attr {
    key: "T"
    value {
      type: DT_STRING
    }
  }
  attr {
    key: "index"
    value {
      i: 0
    }
  }
}

// CHECK-NEXT:     value {
// CHECK-NEXT:       list {
// CHECK-NEXT:         shape {
// CHECK-NEXT:           dim {
// CHECK-NEXT:             size: 10
// CHECK:        name: "output0"
// CHECK-NEXT:   op: "_Retval"
// CHECK-NEXT:   input: "input0"
// CHECK-NEXT:   attr {
// CHECK-NEXT:     key: "T"
// CHECK-NEXT:     value {
// CHECK-NEXT:       type: DT_INT32
// CHECK-NEXT:     }
// CHECK-NEXT:   }
// CHECK-NEXT:   attr {

  // Computes the permutation to produce the correct retval order, and update
  // the argument indices.
  for (int i = 0; i < num_retvals; ++i) {
    int index;
    TF_RETURN_IF_ERROR(GetIndexAttr(*retvals[i], num_retvals, &index));
    (*output_permutation)[index] = i;
    retvals[i]->AddAttr("index", i);
  }

  AddNodeAttr(kXlaClusterIdAttr, call_def->name(), call_def);

    }
  }
}
node {
  name: "identity"
  op: "Identity"
  input: "arg0"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
}
node {
  name: "ret"
  op: "_Retval"
  input: "identity"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "index"
    value {
      i: 0
    }
  }
}
versions {

// 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");

  EXPECT_EQ(arg_node->op_def().name(), "_Arg");
  EXPECT_EQ(arg_node->attrs().FindByString("T")->type(), DT_FLOAT);

  const Node* retval_node = node_name_index.at("_retval0");
  EXPECT_EQ(retval_node->op_def().name(), "_Retval");
  EXPECT_EQ(retval_node->attrs().FindByString("T")->type(), DT_FLOAT);

  EXPECT_EQ(identity_node->num_outputs(), 1);
  EXPECT_EQ(retval_node->num_inputs(), 1);

        const Edge* edge,
        const absl::flat_hash_map<const Node*, Node*>& node_images);

    // Creates a _Retval node for the src node of edge, and add it to results_,
    // if none exists yet. If a new _Retval node is created, also adds the edge
    // within the subgraph from the src to the _Retval node.
    Status RecordResult(
        const Edge* edge,
        const absl::flat_hash_map<const Node*, Node*>& node_images);

    key: "N"
    value {
      i: 2
    }
  }
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
}
node {
  name: "__inference_run_240_RetVal"
  op: "_Retval"
  input: "Case/merge/_9"
  device: "/job:localhost/replica:0/task:0/device:CPU:0"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "index"
    value {