pad_beg, pad_end, 0,       0};
  auto paddings = DenseIntElementsAttr::get(padding_type, values);
  // Update pad_op paddings.
  op.setOperand(1, builder.create<TF::ConstOp>(loc, paddings));

  // Set input type.
  auto input = op.getOperand(0);
  SmallVector<int64_t, 4> transform_shape = {
      pad_input_shape[0], pad_input_shape[1] / block_size,

Value CreateScalarConst(int32_t value, OpBuilder builder, Location loc) {
  auto attr = DenseIntElementsAttr::get(
      tensorflow::GetTypeFromTFTensorShape({}, builder.getI32Type()), value);
  return builder.create<TF::ConstOp>(loc, attr);
}

Value GetR1Const(ArrayRef<int64_t> r1, OpBuilder builder, Location loc,
                 int bitwidth) {
  llvm::SmallVector<APInt, 4> values;
  int64_t rank = r1.size();
  values.reserve(rank);

include "tensorflow/compiler/mlir/tensorflow/ir/tf_ops.td"
include "mlir/IR/OpBase.td"
include "mlir/Dialect/Arith/IR/ArithOps.td"

def ConstDenseElementsI32ZeroAttr
  : NativeCodeCall<"$_builder.create<TFL::ConstOp>($_loc, DenseElementsAttr::get(RankedTensorType::get({}, $_builder.getI32Type()), {0}))">;

def Size1InputRange : NativeCodeCall<
  "SmallVector<Value, 1>{$0}">;

def Size2InputRange : NativeCodeCall<

#include "tensorflow/compiler/mlir/tensorflow/ir/tf_ops.h"

namespace mlir {
namespace quant {

std::optional<TF::PartitionedCallOp> ApplyUniformQuantization(
    PatternRewriter& rewriter, TF::ConstOp op,
    tensorflow::quantization::QuantizationComponentSpec& weight_spec);

}  // namespace quant
}  // namespace mlir

    q_op->replaceAllUsesWith(new_qcast);
    return success();
  }
};

class ConvertTFConstOpToArithConstOp : public OpRewritePattern<TF::ConstOp> {
 public:
  using OpRewritePattern::OpRewritePattern;
  LogicalResult matchAndRewrite(TF::ConstOp op,
                                PatternRewriter& rewriter) const override {
    rewriter.replaceOpWithNewOp<arith::ConstantOp>(op, op.getValue());
    return success();

  tensorflow::Algorithm tensorflow_rng =
      tensorflow::ToTensorflowAlgorithm(xla_rng);

  OpBuilder opbuilder(get_alg_op);

  auto tf_const = opbuilder.create<TF::ConstOp>(
      get_alg_op->getLoc(), opbuilder.getI32IntegerAttr((int)tensorflow_rng));

  get_alg_op->replaceAllUsesWith(tf_const);
  get_alg_op->erase();
  return success();
}

  quant_spec.set_tensor_type(QuantizationComponentSpec::TENSORTYPE_INT_8);

  std::optional<TF::PartitionedCallOp> dequantize_op = ApplyUniformQuantization(
      pattern_rewriter, cast<TF::ConstOp>(value.getDefiningOp()), quant_spec);
  EXPECT_TRUE(dequantize_op.has_value());
  EXPECT_EQ(dequantize_op.value().func().getName().str(),
            "composite_dequantize_uniform");
}

}  // namespace

#include "tensorflow/compiler/mlir/tensorflow/ir/tf_ops.h"

namespace tflite {
namespace {

bool IsConst(mlir::Operation* op) {
  return llvm::isa<mlir::arith::ConstantOp, mlir::TF::ConstOp,
                   mlir::TFL::ConstOp, mlir::TFL::QConstOp>(op);
}

bool IsOpSupported(mlir::Operation* op, const std::string& hardware) {
  auto* devce_hardware = mlir::TFL::tac::GetTargetHardware(hardware);

}

Value BuildIntConstOp(ImplicitLocOpBuilder& builder,
                      ConversionPatternRewriter& rewriter, int64_t const_value,
                      Type type) {
  Value result_const =
      builder.create<TF::ConstOp>(rewriter.getIntegerAttr(type, const_value));
  return result_const;
}

Value BuildIntArrayConstOp(ImplicitLocOpBuilder& builder,
                           ConversionPatternRewriter& rewriter,

      /*add_passes_func=*/
      [](mlir::PassManager &pm) {
        pm.addPass(mlir::quant::CreateInsertRestoreOpPass());
        pm.addPass(mlir::quant::CreateInsertSaveOpPass());
        // Initialization by `tf.ConstOp` is no longer required as there is
        // a `tf.RestoreV2Op` now.
        pm.addPass(
            mlir::quant::CreateRemoveVariableInitializationByConstPass());
      },
      ctx, module_op);
}