namespace {

// Helper method that returns an op from 'transpose_ops' that match criteria
// for an 'operand' and 'permutation'
TransposeOp ReuseExistingTranspose(const OpOperand* operand,
                                   const SmallVector<int64_t, 4>& permutation,
                                   Operation* op, ConstOp permutation_op,
                                   SmallVector<TransposeOp, 2>* transpose_ops) {

        transpose_op.getLoc(), transpose_op.getType().getShape(), new_qtype);
    rewriter.setInsertionPointAfter(transpose_op);
    auto new_q_op = rewriter.create<quantfork::QuantizeCastOp>(
        transpose_op.getLoc(), new_tensor_type, q_op.getArg());
    auto new_dq_op = rewriter.create<quantfork::DequantizeCastOp>(
        new_q_op.getLoc(), transpose_op.getResult().getType(),
        new_q_op.getResult());

using ::mlir::stablehlo::TransposeOp;

// Returns `success()` if `op` is a `TransposeOp` with permutation attribute
// equivalent to `permuation`.
LogicalResult IsTransposeOpWithPermuation(absl::Nullable<Operation*> op,
                                          const ArrayRef<int64_t> permutation) {
  auto transpose_op = dyn_cast_or_null<TransposeOp>(op);
  return success(transpose_op != nullptr && transpose_op.getPermutation() ==

    RankedTensorType pad_type = pad_op.getType().cast<RankedTensorType>();

    auto transpose_op = pad_input.getDefiningOp<stablehlo::TransposeOp>();
    if (!transpose_op || !transpose_op->hasOneUse()) return failure();
    Value transpose_input = transpose_op.getOperand();

    ArrayRef<int64_t> transpose_perm = transpose_op.getPermutation();
    SmallVector<int64_t> new_padding_low =

    ),
    $bmm_rhs, ConstBoolAttrTrue, $transpose_rhs,
    $asymmetric_quantize_inputs_bmm
  ),
  (TFL_BatchMatMulOp
    (TFL_BatchMatMulOp $fc_rhs, $fc_lhs, ConstBoolAttrFalse, ConstBoolAttrFalse,
                       $asymmetric_quantize_inputs_fc,
                       (returnType (TransposeFCLastTwoDims $fc_output))
    ),
    $bmm_rhs, ConstBoolAttrFalse, $transpose_rhs,
    $asymmetric_quantize_inputs_bmm
  ),

  EXPECT_EQ(fused_lstm_func_.getFunctionType().getNumResults(), 1);

  auto transpose_op = fused_lstm_func_.getBody().front().begin();
  transpose_op++;
  EXPECT_EQ(mlir::cast<RankedTensorType>(transpose_op->getOperand(0).getType())
                .getDimSize(0),
            3);
  EXPECT_EQ(mlir::cast<RankedTensorType>(transpose_op->getOperand(0).getType())
                .getDimSize(1),
            12);

  // Transpose.
  auto transpose_op = GetTransposeOpForConv2DFilter(&builder, reshape_op);

  // Reshape Back.
  SmallVector<int64_t, 4> final_shape = {
      height / block_size, width / block_size,
      channel * block_size * block_size, out_channel};
  auto final_reshape_op =
      GetReshapeOpForConv2DFilter(final_shape, transpose_op, &builder);
  // Update filter of Conv2D.

    if (any_blargs) {
      return failure();
    }

    TFL::TransposeOp tpose_arg = nullptr;
    Operation *cst_arg = nullptr;

    for (Value opr : op->getOperands()) {
      auto *defining_op = opr.getDefiningOp();
      if (llvm::isa<TFL::TransposeOp>(defining_op) && !tpose_arg) {
        tpose_arg = llvm::dyn_cast<TFL::TransposeOp>(defining_op);
        continue;
      }

      return failure();
    }

    auto transpose_op = reshape_op_1.getInput().getDefiningOp<TransposeOp>();
    if (!transpose_op) {
      return failure();
    }
    DenseIntElementsAttr transpose_perm_1;
    if (!matchPattern(transpose_op.getPerm(), m_Constant(&transpose_perm_1)) ||
        !TransposeFirstTwoDimToLast(transpose_perm_1)) {

  SmallVector<int64_t> permutation_;
};

class FoldTransposedConstantOp
    : public OpRewritePattern<mlir::stablehlo::TransposeOp> {
 public:
  using OpRewritePattern<mlir::stablehlo::TransposeOp>::OpRewritePattern;

  LogicalResult match(mlir::stablehlo::TransposeOp op) const override {
    Value operand = op.getOperand();
    auto const_op =