operands.push_back(operand);
  auto new_op = builder->create<OpT>(op->getLoc(), op->getResultTypes(),
                                     operands, attr.getAttrs());
  op->replaceAllUsesWith(new_op.getOperation()->getResults());
  op->erase();
  return new_op;
}

// Returns success if the function has at most one op of the template type and
// assigns it to `result`, if present. If there are multiple such ops, returns

    func.getAllResultAttrs(tmp);

    for (const auto& res : tmp) {
      result_attrs.push_back(res.getValue().vec());
    }
  }

  mlir::Builder builder(func.getOperation());

  for (OpOperand& operand : fetch.getOperation()->getOpOperands()) {
    if (mlir::isa<tf_executor::ControlType>(operand.get().getType())) break;
    auto it = value_to_device.find(operand.get());
    if (it != value_to_device.end()) {

  auto parallel_execute = llvm::dyn_cast<tf_device::ParallelExecuteOp>(
      execute_launch->getParentOp());
  Operation* execute_parent =
      parallel_execute ? parallel_execute.getOperation() : execute_launch;
  // Collect all operands of `execute` whose defining ops are variable reads
  // that might get merged, and add relevant information to `var_access_info`.

    llvm::SmallDenseMap<ResourceHandle, int64_t> &resource_handle_id_map,
    int64_t &next_id) {
  llvm::SmallVector<ResourceHandleValueAndId, 4> resource_vec;
  llvm::StringRef device = GetDeviceOrEmpty(getOperation());

  for (const auto &iter : llvm::enumerate(getResults())) {
    auto index = iter.index();
    if (mlir::isa<TF::ResourceType>(
            getElementTypeOrSelf(iter.value().getType()))) {

    }
    // Use the min/max from the operands and the num_bits and narrow_range
    // attribute to create the quantization parameter for the new quantize op.
    rewriter.setInsertionPointAfter(tf_op.getOperation());
    IntegerAttr num_bits = rewriter.getI64IntegerAttr(tf_op.getNumBits());
    BoolAttr narrow_range = rewriter.getBoolAttr(tf_op.getNarrowRange());
    Type res_type = tf_op.getType();

#include "tensorflow/compiler/mlir/quantization/stablehlo/passes/bridge/optimize.inc"

void OptimizeIntGraph::runOnOperation() {
  RewritePatternSet patterns(&getContext());
  populateWithGenerated(patterns);
  auto func = getOperation();
  if (failed(applyPatternsAndFoldGreedily(func, std::move(patterns)))) {
    signalPassFailure();
  }
}

}  // namespace

std::unique_ptr<OperationPass<func::FuncOp>> CreateOptimizeIntGraphPass() {

        new_ewise_op->getLoc(), op->getResult(0).getType(),
        new_ewise_op->getResults()[0], perm);
    rewriter.replaceOp(op, out_tpose_op.getOperation());
    return success();
  }
};

void PushTransposeThroughEwisePass::runOnOperation() {
  auto module = getOperation();
  RewritePatternSet patterns(&getContext());

  patterns.add<CommuteTransposeWithEwiseOps>(&getContext());

  // to yield.
  ReplaceRegionWithCall(GetName(while_op.getOperation(), "_cond"),
                        while_op.getCond(), false, num_loop_carried,
                        extern_values, types, while_op.getLoc());
  ReplaceRegionWithCall(GetName(while_op.getOperation(), "_body"),
                        while_op.getBody(), true, num_loop_carried,

  if (auto block_arg = mlir::dyn_cast<BlockArgument>(value))
    return block_arg.getOwner()->getParentOp();

  return value.getDefiningOp();
}

void TPUAnnotateDynamicShapeInputsPass::runOnOperation() {
  getOperation().walk([&](tf_device::ClusterFuncOp cluster_func_op) {
    Builder builder(cluster_func_op->getContext());
    // Skip non-tpu device cluster_func.
    auto cluster_id =

  // TODO: b/304003568 - Add TF_TransposeOp folding logic to tflite.
  target.addIllegalOp<mhlo::DotGeneralOp, mhlo::DotOp, mhlo::TransposeOp>();
  if (failed(applyPartialConversion(getOperation(), target,
                                    std::move(patterns)))) {
    getOperation().emitError("mhlo to TFLite legalization failed.");
    signalPassFailure();
  }
}
}  // namespace