} else if (function_name.contains("dot_general")) {
      const auto module_op = call_op->getParentOfType<ModuleOp>();

      const SymbolTable symbol_table(module_op);
      auto entry_func_op =
          dyn_cast_or_null<func::FuncOp>(symbol_table.lookup(function_name));
      auto dot_general_op = *entry_func_op.getOps<DotGeneralOp>().begin();
      if (auto optional_dim = GetDotGeneralQuantizationDim(dot_general_op);

  Value max_output_size = func_.getArgument(2);
  Value iou_threshold = func_.getArgument(3);
  Value score_threshold = func_.getArgument(4);
  auto output_type0 = func_.getFunctionType().getResult(0);
  auto output_type1 = func_.getFunctionType().getResult(1);

  OpBuilder builder(func_.getBody());
  auto op = builder.create<mlir::TFL::NonMaxSuppressionV4Op>(
      func_.getLoc(), output_type0, output_type1, boxes, scores,

template <typename OpT>
OpT AddOperandAndRewriteAs(Operation* op, Value operand, NamedAttrList attr,
                           OpBuilder* builder) {
  builder->setInsertionPoint(op);
  auto operands = llvm::to_vector<4>(op->getOperands());
  operands.push_back(operand);
  auto new_op = builder->create<OpT>(op->getLoc(), op->getResultTypes(),
                                     operands, attr.getAttrs());

        rewriter.getFusedLoc({const_op.getLoc(), op.getLoc()});
    auto new_value_type =
        RankedTensorType::getChecked(combined_loc, transposer.GetTargetShape(),
                                     /*elementType=*/rewriter.getF32Type());
    auto new_value_attr =
        DenseFPElementsAttr::get(new_value_type, std::move(transposed_values));
    auto new_const_op = rewriter.create<mlir::stablehlo::ConstantOp>(

           << func_.getFunctionType().getNumResults();
  }

  auto attrs = attr_.getAttrs();

  if (failed(HasIntegerArrayWithSize(&func_, attrs, "pool_size", 2))) {
    return failure();
  }

  if (failed(HasIntegerArrayWithSize(&func_, attrs, "strides", 2))) {
    return failure();
  }

  // Retrieves padding.
  auto padding = mlir::dyn_cast_or_null<StringAttr>(attrs.get("padding"));
  if (!padding) {

        if (auto symbol_ref =
                mlir::dyn_cast<FlatSymbolRefAttr>(attr.getValue())) {
          MoveFuncOp(symbol_ref, symbol_table, outlined_symbol_table);
          continue;
        }
        if (auto array_attr = mlir::dyn_cast<ArrayAttr>(attr.getValue())) {
          for (const Attribute &attribute : array_attr) {
            auto symbol_ref = mlir::dyn_cast<FlatSymbolRefAttr>(attribute);

  auto lhs_type = mlir::cast<ShapedType>(arithmetic_op.getX().getType());
  auto rhs_type = mlir::cast<ShapedType>(arithmetic_op.getY().getType());
  auto result_type =
      mlir::cast<ShapedType>(arithmetic_op.getResult().getType());

  // We can fold arithmetic operation only of we can prove that we will not
  // accidentally hide a broadcasting error.

  }

  auto result = getOperation()->walk([&num_cores_per_replica](Operation* op) {
    std::optional<LogicalResult> status;
    if (auto partitioned_input =
            llvm::dyn_cast_or_null<TF::TPUPartitionedInputOp>(op)) {
      status = ReplacePartitionedOp(num_cores_per_replica, partitioned_input);
    } else if (auto partitioned_output =

          }
          auto new_call = mutable_location->mutable_call()->Add();
          ExtractFileLine(loc, new_call->mutable_source());
        })
        .Case<NameLoc>([&](NameLoc loc) {
          if (!mutable_location->has_type()) {
            mutable_location->set_type(ConverterErrorData::NAMELOC);
          }

          auto new_call = mutable_location->mutable_call()->Add();

                       [](const auto& attr_def) {
                         return attr_def.name() == "use_node_name_sharing" &&
                                attr_def.type() == "bool";
                       }))
        return false;
    }

    if (!std::any_of(op_def.attr().begin(), op_def.attr().end(),
                     [](const auto& attr_def) {