for (auto operand : replicated_input.getInputs()) {
    Operation* pi = operand.getDefiningOp();
    for (unsigned core_id = 0; core_id < num_cores_per_replica; ++core_id) {
      const auto pi_operand =
          packed_input ? pi->getOperand(0) : pi->getOperand(core_id);
      operands_per_replica_per_core[core_id].push_back(pi_operand);
    }
  }

  // Create new `tf.TPUReplicatedInput` ops feeding into one

  }
  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

// logical device id. TPUExecute op for different logical device may have
// different outputs depending on the output sharding configuration.
mlir::LogicalResult GetOutputTypesForLogicalDeviceComputation(
    int core_id, llvm::ArrayRef<xla::OpSharding> output_sharding_config,
    mlir::tf_device::ClusterFuncOp cluster_func,
    llvm::SmallVectorImpl<mlir::Type>* output_types,
    llvm::SmallVectorImpl<int>* cluster_to_core_index);

  }

  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();

				coreIDs = append(coreIDs, info.CoreID)
			}
		}
	}
	return cpuset.New(coreIDs...)
}

// CoresInSockets returns all of the core IDs associated with the given socket
// IDs in this CPUDetails.
func (d CPUDetails) CoresInSockets(ids ...int) cpuset.CPUSet {
	var coreIDs []int
	for _, id := range ids {
		for _, info := range d {
			if info.SocketID == id {
				coreIDs = append(coreIDs, info.CoreID)

					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(),

constexpr absl::string_view kMultiplePathsToChild = R"(
nodes {
  children {
    node_id: 1
    local_name: "foo"
  }
  children {
    node_id: 2
    local_name: "bar"
  }
  children {
    node_id: 3
    local_name: "signatures"
  }
  user_object {
    identifier: "_generic_user_object"
    version {
      producer: 1