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)) {

class RewriteQuantizedTransposeOp
    : public OpRewritePattern<stablehlo::TransposeOp> {
 public:
  using OpRewritePattern<stablehlo::TransposeOp>::OpRewritePattern;

  LogicalResult match(stablehlo::TransposeOp op) const override {
    return success(IsOpFullyQuantized(op));
  }

  void rewrite(stablehlo::TransposeOp op,
               PatternRewriter& rewriter) const override {

  }

  return success();
}

//===----------------------------------------------------------------------===//
// TransposeOp
//===----------------------------------------------------------------------===//

LogicalResult TransposeOp::verify() {
  TransposeOp op = *this;
  auto perm_type = op.getPerm().getType().dyn_cast<RankedTensorType>();
  auto x_type = op.getX().getType().dyn_cast<RankedTensorType>();

              dnums.getOutputFeatureDimension(),
              *dnums.getOutputSpatialDimensions().begin(), num_spatial_dims,
              conv_output_type, rewriter);
      output = rewriter.create<mhlo::TransposeOp>(
          conv_op.getLoc(), conv_op.getType(), output, permutation);
    }
    rewriter.replaceOp(conv_op, {output});
  }
};

// Convert a 1-D convolution into a 2-D convolution (which TF supports) so that

    }
  }
}

}  // namespace

void TransposeOp::getCanonicalizationPatterns(RewritePatternSet& results,
                                              MLIRContext* context) {
  results.add<ConvertTransposeToDecreaseRank>(context);
}

OpFoldResult TransposeOp::fold(FoldAdaptor adaptor) {
  auto operands = adaptor.getOperands();

class TFL_OperandHasRankAtMost<int n, int m> :
  PredOpTrait<"operand " # n # " is at most " # m # "-D",
    TFL_OperandHasRankAtMostPred<n, m>>;

// Not all dimentions in the tensor will contribute to the data move in a
// TransposeOp. Effective rank is the number of dimentions != 1
class TFL_TransposeOperandHasEffectiveRankAtMost<int n, int m> :
  PredOpTrait<"operand " # n # " is at most " # m # "-D",
    Or<[TFL_OperandIsUnrankedPred<n>,