// Rewrite the original launch op with smaller set of returns.
  CreateReducedLaunchOp(builder, old_block, original_launch_op, device);

  original_launch_op->erase();
  return success();
}

LogicalResult MoveStandalonePreprocessingOp(OpBuilder* builder,
                                            func::FuncOp func_op,

      // The quantization parameters haven't been propagated to any operands
      // or results. Skip this node for now.
      if (!params) {
        quantized_.erase(op);
        continue;
      }

      // If this is a QDQ conversion only, the op could have a same-scale
      // requirement for the floating point kernel but allow per-axis

      compilation_op, loop_body_func, "sc_backward", &backwards_pass_caller);
  if (failed(result)) return signalPassFailure();

  metadata_op->erase();
  compilation_op->erase();

  LOG(INFO) << "EmbeddingSequencingPass::runOnOperation done.";
}

}  // namespace

std::unique_ptr<OperationPass<mlir::ModuleOp>> CreateEmbeddingSequencingPass() {

void PrepareDynamicRangeQuantizePass::removeAllStatsOp(func::FuncOp func) {
  func.walk([&](quantfork::StatisticsOp stats_op) {
    stats_op.replaceAllUsesWith(stats_op.getArg());
    stats_op.erase();
  });
}

void PrepareDynamicRangeQuantizePass::runOnOperation() {
  func::FuncOp func = getOperation();
  MLIRContext* ctx = func.getContext();

  if (enable_float16_quantization_) {

        groupedOutput.taskCount == 3
        groupedOutput.task(':1:log').output == 'Output from 1'
        groupedOutput.task(':2:log').output == 'Output from 2'
    }

    def "handles task outputs with erase to end of line chars"() {
        given:
        def consoleOutput = """

			t.Fatalf("expect private key provider in secret")
		}
		if privateKeyProvider.GetFallback() {
			t.Fatalf("expect fallback for private key provider in secret as false")
		}
	}

	// erase private key provider in proxy-config
	secrets, _, _ = gen.Generate(s.SetupProxy(rawProxy), &model.WatchedResource{ResourceNames: []string{"kubernetes://generic"}}, fullPush)

  for (IslandOp island : merged_island.islands)
    island.getControl().replaceAllUsesWith(new_island.getControl());
  for (IslandOp island : merged_island.islands) island->erase();
}

// Takes the inputs to tf_executor.fetch, make a new island that just yields
// them, and replace the fetch's input operands with the new yielded values.
//

    auto input_op = q.getArg().getDefiningOp();
    if (auto stats = dyn_cast_or_null<quantfork::StatisticsOp>(input_op)) {
      q.setOperand(stats.getArg());
      if (stats.use_empty()) stats.erase();
    }
  });

  // Step 1: forward pass: propagate any value scales which are not produces
  // by `SameOperandsAndResultsScale`. Additionally, remove the value scales

  }

  for (int i = 0; i < tuple_result->getNumOperands(); i++) {
    outputs.push_back(tuple_result->getOperand(i));
  }

  tuple_result.getOperation()->erase();
  return success();
}

mlir::LogicalResult Tf2XlaRewriter::GetKernelOutputs(
    tensorflow::OpKernelContext& op_context, mhlo::TupleOp tuple_results,
    llvm::SmallVector<Value>& outputs) {

  }
  for (auto& op : llvm::make_early_inc_range(replicate.GetBody())) {
    op.moveBefore(&new_replicate.GetBody(), new_replicate.GetBody().end());
  }
  replicate.replaceAllUsesWith(new_replicate);
  replicate.erase();
  return new_replicate;
}

// Creates the per-device variables that represent the formatting state of each
// device.
llvm::SmallVector<TF::VarHandleOp, 4> CreateStateVars(