cloned_fetch_op.erase();
  };

  return llvm::to_vector(cloned_fetch_op.getFetches());
}

// Creates a new `IslandOp` that wraps a `TF::NoOp`. The `IslandOp` has control
// dependencies to the values provided.
IslandOp CreateNoOpWithControlDependencies(
    const Location loc, GraphOp main_graph_op,
    const ArrayRef<Value> control_dependencies) {

// for the associated replica island.
LogicalResult ExpandReplicateIntoReplicas(
    const Dialect* tf_dialect, OpBuilder& builder,
    tf_executor::IslandOp island_op, tf_device::ReplicateOp replicate_op,
    int num_replicas, llvm::SmallVectorImpl<tf_executor::IslandOp>& replicas,
    bool legacy_graph_export, int replica_group_idx) {
  replicas.reserve(num_replicas);
  auto devices = replicate_op.getDevices();

  cloned_fetch_op.erase();

  return control_fetch;
}

// Creates a new `IdentityOp` wrapped by an `IslandOp`. The identity op returns
// the `main_file_prefix_arg` and has control dependencies to `control_inputs`.
IslandOp CreateFilePrefixIdentityOp(const BlockArgument main_file_prefix_arg,
                                    const ArrayRef<Value> control_inputs,

    return ops_have_same_device(sink.GetSource(), sink);
  }

  return llvm::isa<tf_executor::EnterOp, tf_executor::ExitOp,
                   tf_executor::IslandOp, tf_executor::MergeOp,
                   tf_executor::SwitchOp>(op);
}

// Assigns all data results to a specified device.
void PopulateDeviceForOpResults(
    Operation& op, llvm::StringRef device,

#include "tensorflow/compiler/mlir/tensorflow/ir/tf_ops.h"

namespace mlir {
namespace quant {
namespace {

using ::mlir::tf_executor::GraphOp;
using ::mlir::tf_executor::IslandOp;

constexpr StringRef kSharedNameAttr = "shared_name";

class MergeDuplicateResourceOpsPass
    : public PassWrapper<MergeDuplicateResourceOpsPass,
                         OperationPass<func::FuncOp>> {
 public:

  SymbolTable outlined_symbol_table(outlined_module);

  // Find every island that contains a TPU node and extract it into a new module
  // to run the V1 bridge there.
  llvm::SmallVector<IslandOp, 8> islands_to_outline;
  getOperation().walk([&](IslandOp island_op) {
    auto parent_func = island_op->getParentOfType<func::FuncOp>();
    auto skip_island_outlining =
        parent_func->getAttrOfType<BoolAttr>(mlir::TF::kSkipIslandOutlining);

#include "tensorflow/compiler/mlir/tensorflow/ir/tf_executor.h"

namespace mlir {
namespace TF {

// Converts a single island into multiple islands (one for each op).
void SplitIsland(mlir::tf_executor::IslandOp island_op,
                 mlir::tf_executor::ControlType control_type);

}  // namespace TF
}  // namespace mlir

    // violate the invariant imposed by the GraphExport pipeline that every
    // IslandOp perfectly wraps a single op.
    auto control_type =
        mlir::tf_executor::ControlType::get(tf_dialect->getContext());
    getOperation().walk(
        [&control_type](mlir::tf_executor::IslandOp curr_island) {
          mlir::TF::SplitIsland(curr_island, control_type);
        });
  }
}

  auto graph_position = graph.getOperation()->getIterator();
  Block* parent_block = graph.getOperation()->getBlock();
  for (Operation& op : graph.GetBody().without_terminator()) {
    auto island_op = llvm::dyn_cast<tf_executor::IslandOp>(op);
    if (!island_op)
      return op.emitOpError()
             << "is not supported for lifting out of tf_executor.graph, "
                "expected tf_executor.island";

          auto result = graph.getResult(arg.getOperandNumber());
          this->join(getLatticeElement(result), *getLatticeElement(arg.get()));
        }
      }
    } else if (auto island = dyn_cast<tf_executor::IslandOp>(op)) {
      for (auto &arg : island.GetYield()->getOpOperands()) {
        auto result = island.getResult(arg.getOperandNumber());
        this->join(getLatticeElement(result), *getLatticeElement(arg.get()));
      }