->getResult(0);
}

// Transform pad(transpose(x)) to transpose(pad(x))
struct TransposeCommuteWithPad : public OpRewritePattern<stablehlo::PadOp> {
  using OpRewritePattern<stablehlo::PadOp>::OpRewritePattern;

  LogicalResult matchAndRewrite(stablehlo::PadOp pad_op,
                                PatternRewriter& rewriter) const override {
    Value pad_input = pad_op.getOperand();

// Current supported ops between convolution input and the block arguments are
// PadOp and CastOp.
std::optional<BlockArgumentInfo> GetInputBlockArgNum(Value input) {
  auto block_arg_num = GetBlockArgNum(input);
  if (block_arg_num.has_value()) return block_arg_num;

  Value next_input = input;
  auto pad_op = dyn_cast_or_null<TF::PadOp>(next_input.getDefiningOp());

                mlir::stablehlo::PadOp, mlir::stablehlo::ReduceWindowOp,
                mlir::stablehlo::ReshapeOp, mlir::stablehlo::SelectOp,
                mlir::stablehlo::SliceOp, mlir::stablehlo::TransposeOp>(op)) {
    scale_spec->has_same_scale_requirement = true;
  }
  if (llvm::isa<mlir::stablehlo::DynamicSliceOp, mlir::stablehlo::GatherOp,
                mlir::stablehlo::PadOp, mlir::stablehlo::SliceOp>(op)) {

                           ConstOp::getOperationName(),
                           LessOp::getOperationName(),
                           MulOp::getOperationName(),
                           PadOp::getOperationName(),
                           PackOp::getOperationName(),
                           ReadVariableOp::getOperationName(),
                           SelectV2Op::getOperationName(),

    return rewriter.notifyMatchFailure(
        stb_op, "result for current op has more than 1 use");
  }

  // Pad op.
  TF::PadOp pad_op;
  ElementsAttr pad_attr;
  if (llvm::isa<TF::PadOp>(consumer_op)) {
    pad_op = llvm::cast<TF::PadOp>(consumer_op);
    if (!pad_op.getResult().hasOneUse()) {
      return rewriter.notifyMatchFailure(
          pad_op, "result for current op has more than 1 use");

//  %y1 = pad(%x, pad_val, (p1_1,p1_2,p1_3, ...))
//  %y2 = pad(%y1, pad_val, (p2_1,p2_2,p2_3, ...))
// To:
//  %z = pad(%x, pad_val, (p1_1 + p2_1, p1_2 + p2_2, p1_3 + p2_3, ...))
LogicalResult MergeConsecutivePad(mhlo::PadOp pad_op,
                                  PatternRewriter &rewriter) {
  // Fail for non-static shapes
  if (!pad_op.getOperand().getType().hasStaticShape() ||
      !pad_op.getResult().getType().hasStaticShape() ||

TAC_REGISTER_GPU_OP(MaximumOp, CreateBasicOpNoCost);
TAC_REGISTER_GPU_OP(MinimumOp, CreateBasicOpNoCost);
TAC_REGISTER_GPU_OP(MeanOp, CreateBasicOpNoCost);
TAC_REGISTER_GPU_OP(CustomOp, CreateBasicOpNoCost);
TAC_REGISTER_GPU_OP(PadOp, CreateBasicOpNoCost);
TAC_REGISTER_GPU_OP(PowOp, CreateBasicOpNoCost);
TAC_REGISTER_GPU_OP(PReluOp, CreateBasicOpNoCost);
TAC_REGISTER_GPU_OP(ReluOp, CreateBasicOpNoCost);
TAC_REGISTER_GPU_OP(Relu6Op, CreateBasicOpNoCost);

class RewriteQuantizedPadOp : public OpRewritePattern<stablehlo::PadOp> {
 public:
  using OpRewritePattern<stablehlo::PadOp>::OpRewritePattern;

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

  void rewrite(stablehlo::PadOp op, PatternRewriter& rewriter) const override {
    Value input = op.getOperand();

          TF::MaximumOp::getOperationName().str(),
          TF::MeanOp::getOperationName().str(),
          TF::MinimumOp::getOperationName().str(),
          TF::MulOp::getOperationName().str(),
          TF::PadOp::getOperationName().str(),
          TF::PadV2Op::getOperationName().str(),
          TF::Relu6Op::getOperationName().str(),
          TF::ReluOp::getOperationName().str(),
          TF::ReshapeOp::getOperationName().str(),

      // $max_output_size
      CompileTimeConstantOperand<TF::NonMaxSuppressionV4Op, 2>,
      CompileTimeConstantOperand<TF::OneHotOp, 1>,  // $depth
      CompileTimeConstantOperand<TF::PadOp, 1>,     // $paddings
      CompileTimeConstantOperand<TF::PadV2Op, 1>,   // $paddings
      // $shape
      CompileTimeConstantOperand<TF::ParameterizedTruncatedNormalOp, 0>,