}
  return mlir::success();
}

namespace {

bool IsAssignedToLogicalDevice(const int core_id,
                               const xla::OpSharding& sharding) {
  return sharding.type() == xla::OpSharding::MAXIMAL &&
         sharding.tile_assignment_devices(0) == core_id;
}

// Returns the index of the return value of region in
// `tf_device.parallel_execute` that represents cluster func output at

  }

  replicate->setAttr(kDevicesAttr, builder->getDictionaryAttr(device_attrs));
}

// Creates a `tf.TPUExecute` op that executes TPU program.
LogicalResult BuildExecuteOp(
    const int core_id, llvm::ArrayRef<xla::OpSharding> output_sharding_config,
    llvm::ArrayRef<Value> inputs, tf_device::ClusterFuncOp cluster_func,
    OpBuilder* builder, TF::TPUExecuteOp* execute_op) {

      for (auto [core_id, result] :
           llvm::enumerate(partitioned_output->getResults())) {
        // outputs from replicate op are interleaved:
        // [(replica:0,core:0), (replica:1,core:0), ...,
        //  (replica:0,core:1), (replica:1,core:1), ...]
        uint64_t output_id =
            core_id * num_replicas + replica_id + results.size();

					45: {CoreID: 5, SocketID: 0, NUMANodeID: 0},
					46: {CoreID: 6, SocketID: 0, NUMANodeID: 0},
					47: {CoreID: 7, SocketID: 0, NUMANodeID: 0},
					48: {CoreID: 8, SocketID: 0, NUMANodeID: 0},
					49: {CoreID: 9, SocketID: 0, NUMANodeID: 0},
					50: {CoreID: 10, SocketID: 0, NUMANodeID: 1},
					51: {CoreID: 11, SocketID: 0, NUMANodeID: 1},
					52: {CoreID: 12, SocketID: 0, NUMANodeID: 1},

			1:  {CoreID: 0, SocketID: 1, NUMANodeID: 1},
			2:  {CoreID: 1, SocketID: 1, NUMANodeID: 1},
			3:  {CoreID: 1, SocketID: 1, NUMANodeID: 1},
			4:  {CoreID: 2, SocketID: 1, NUMANodeID: 1},
			5:  {CoreID: 2, SocketID: 1, NUMANodeID: 1},
			6:  {CoreID: 3, SocketID: 0, NUMANodeID: 0},
			7:  {CoreID: 3, SocketID: 0, NUMANodeID: 0},
			8:  {CoreID: 4, SocketID: 0, NUMANodeID: 0},
			9:  {CoreID: 4, SocketID: 0, NUMANodeID: 0},

			NumSockets: 2,
			NumCores:   4,
			CPUDetails: map[int]topology.CPUInfo{
				0: {CoreID: 0, SocketID: 0},
				1: {CoreID: 1, SocketID: 0},
				2: {CoreID: 2, SocketID: 0},
				3: {CoreID: 3, SocketID: 0},
				4: {CoreID: 0, SocketID: 1},
				5: {CoreID: 1, SocketID: 1},
				6: {CoreID: 2, SocketID: 1},
				7: {CoreID: 3, SocketID: 1},
			},
		},
		0,
		cpuset.New(),
		topologymanager.NewFakeManager(),

        });
    if (child_node_iter == current_node->children().end()) {
      return absl::nullopt;
    }

    node_id = child_node_iter->node_id();
    current_node = &nodes.Get(node_id);
  }

  return node_id;
}

gtl::FlatMap<StringPiece, const AttrValueMap*, StringPieceHasher> NodeToAttrMap(
    const tensorflow::GraphDef& graphdef) {

}

// Retrieves the TensorHandle associated with `node_id` from `obj_graph`, and
// set `*handle` to point to it.
Status TensorHandleFromNode(int node_id, const SavedObjectGraph& obj_graph,
                            const PartiallyRevivedObjects& objects,
                            ImmediateExecutionTensorHandle** handle) {
  const SavedObject& node = obj_graph.nodes(node_id);
  SavedObject::KindCase kind = node.kind_case();

                    }
                }
            }
        """)
        File(coreDir, "src/main/java/org/gradle/api").mkdirs()
        File(coreDir, "src/main/java/org/gradle/api").mkdirs()
        File(coreDir, "src/main/java/org/gradle/internal/instrumentation").mkdirs()
        File(coreDir, "src/main/java/org/gradle/api/Task.java").writeText("""
            package org.gradle.api;

Status TFSavedModelAPI::GetFunctions(
    int node_id,
    absl::flat_hash_map<std::string, ConcreteFunction*>* functions) {
  const auto& nodes = bundle_.saved_object_graph().nodes();
  if (node_id >= nodes.size()) {
    return errors::OutOfRange(
        "node_id ", node_id,
        " not found.  Maximum node ID: ", nodes.size() - 1);
  }
  const SavedObject* current_node = &nodes.Get(node_id);