for (Value fetch_operand : fetch.getOperands()) {
    if (mlir::isa<mlir::tf_executor::ControlType>(fetch_operand.getType())) {
      Operation* defining_op =
          GetIslandInnerOpOrSelf(fetch_operand.getDefiningOp());
      auto node_it = nodes_.find(defining_op);
      TF_RET_CHECK(node_it != nodes_.end());
      control_ret_nodes->insert(node_it->second);
    }
  }
  return absl::OkStatus();
}

// returns an error.
LogicalResult GetConstShapeValue(Value shape_value,
                                 llvm::SmallVector<int64_t, 8>* shape) {
  auto shape_op = shape_value.getDefiningOp();
  if (!shape_op) return failure();
  auto shape_const_op = llvm::dyn_cast<TF::ConstOp>(shape_op);
  if (!shape_const_op) return failure();
  for (const auto& v : shape_const_op.getValue().getValues<APInt>()) {

    if (!buffer_ty.hasStaticShape()) {
      mlir::Value return_val = return_op->getOperand(idx);
      if (auto owner = mlir::dyn_cast_or_null<mlir::tensor::CastOp>(
              return_val.getDefiningOp())) {
        // For bounded dynamic type, get a static size by taking bounds as the
        // dimensions. These dimensions are marked as dynamic in xla::Shape
        // below.

  // If `value` is produced by tf.Dequantize op, then return the Dequantize op's
  // input. Otherwise return `value`.
  auto get_real_input_value = [](Value value) -> Value {
    Operation* defining_op = value.getDefiningOp();
    if (auto dequantize = dyn_cast_or_null<TF::DequantizeOp>(defining_op)) {
      return dequantize.getInput();
    } else if (auto dequantize =
                   dyn_cast_or_null<TFL::DequantizeOp>(defining_op)) {

  // Extend tuple if `value` is a tuple.
  // If `value` is an op result and the owner is a `mhlo.tuple`, simply unpack
  // the tuple.
  if (auto tuple_op = value.getDefiningOp<TupleOp>()) {
    auto tuple_operands = llvm::to_vector(tuple_op.getOperands());
    tuple_operands.push_back(token);
    return {create_tuple(tuple_operands)};
  }

      Operation::operand_range &input, IntegerAttr &num_bits,
      BoolAttr &narrow_range,
      ::llvm::SmallVector<Operation *, 4> &target_ops) const {
    auto *defining_op = (*casted_op.getODSOperands(0).begin()).getDefiningOp();
    if (!(defining_op)) {
      return rewriter.notifyMatchFailure(casted_op, [&](Diagnostic &diag) {
        diag << "There's no operation that defines operand 0 of casted_op";
      });
    }

                                 int dst_input) {
  // Get the NextIteration.Source operation from the token operand of the sink.
  mlir::Operation* source = sink->getOperand(0).getDefiningOp();

  // Adds the "source" to the operands of the dst by creating a new dst
  // operation.
  mlir::OperationState state(dst->getLoc(), dst->getName());
  auto num_operands = dst->getNumOperands();

                         input_shape_attr.getValues<int32_t>().begin(),
                         input_shape_attr.getValues<int32_t>().end());
    } else {
      auto pack = op.getInputSizes().template getDefiningOp<TF::PackOp>();
      if (!pack || pack.getAxis() != 0) return failure();
      auto pack_ty = mlir::dyn_cast<RankedTensorType>(pack.getType());
      if (!pack_ty || pack_ty.getRank() != 1) return failure();