// mapped to X and Z dimension.
      std::iter_swap(permute.begin() + input_rank - 1,
                     permute.begin() + input_rank - 2);
      auto permutation_tensor_op = rewriter.create<arith::ConstantOp>(
          bmm_op->getLoc(), permuation_tensor_type,
          DenseElementsAttr::get(permuation_tensor_type, permute));

      auto input_shape = input_type.getShape();

  // output gate bias is 0 since it is out of bounds of the bias tensor, so
  // we set its value as a const tensor of specified size and value 0.
  EXPECT_TRUE(
      mlir::cast<ElementsAttr>(mlir::cast<mlir::arith::ConstantOp>(
                                   it->getOpOperand(15).get().getDefiningOp())
                                   .getValue())
          .getValues<FloatAttr>()[0]
          .getValue()

      Value input = op.getOperand(index);

      if (input.getDefiningOp() == nullptr) continue;

      // TODO(b/172517537): make this work with non-PTQ case.
      if (llvm::isa<func::ConstantOp, arith::ConstantOp, TFL::ConstOp>(
              input.getDefiningOp())) {
        // Tensors with derived scale are biases, and handled in propagation.
        if (tensor_property.use_derived_scale) continue;

  }

  auto scalar_type = RankedTensorType::get(/*shape=*/{}, fp_type);
  auto epsilon_tensor_attr = DenseElementsAttr::get(
      scalar_type, {mlir::cast<Attribute>(epsilon_attr)});
  Value epsilon = b.create<mhlo::ConstantOp>(epsilon_tensor_attr);
  auto dims_type = RankedTensorType::get(/*shape=*/{0}, b.getIntegerType(64));
  auto dims = DenseIntElementsAttr::get(dims_type, SmallVector<int64_t, 1>{});
  if (broadcast_to_type.hasStaticShape()) {

    auto new_shape_const_attr =
        DenseElementsAttr::get(shape_spec_type, new_shape.getShape());
    rewriter.setInsertionPointAfter(weight_op);
    auto new_shape_const = rewriter.create<arith::ConstantOp>(
        weight_op->getLoc(), shape_spec_type, new_shape_const_attr);
    auto reshape_op = rewriter.create<TF::ReshapeOp>(
        weight_op->getLoc(), new_shape, weight_op->getResult(0),
        new_shape_const);

      scales, zero_points, quant_dim, qtype.getStorageTypeMin(),
      qtype.getStorageTypeMax());
}

}  // namespace

bool IsOpQuantizable(Operation* op) {
  if (isa<func::ConstantOp, arith::ConstantOp, quantfork::StatisticsOp>(op)) {
    // Constant ops do not have QuantizableResult attribute but they can deal
    // with quantized tensors.
    return true;
  } else if (op->hasTrait<OpTrait::IsTerminator>() ||

}

static bool IsConst(Operation* op) {
  return isa<mlir::func::ConstantOp, mlir::arith::ConstantOp, mlir::TF::ConstOp,
             tfl::ConstOp, tfl::QConstOp, tfl::SparseConstOp,
             tfl::SparseQConstOp, mlir::TFL::NoValueOp,
             mlir::stablehlo::ConstantOp, mlir::vhlo::ConstantOpV1>(op);
}

static bool IsTFResourceOp(Operation* op) {

  }

  auto dense_attr_or = GetDenseAttrFromTensorProtoAttr(
      tensor_proto_attr.getValue(), new_operand_type);
  if (failed(dense_attr_or)) return failure();

  return Value(rewriter.create<mhlo::ConstantOp>(op->getLoc(), new_operand_type,
                                                 *dense_attr_or));
}

xla::ConvolutionDimensionNumbers ConvertConvolutionDimensionNumbers(

      // Use mhlo.Constant when it is consumed by the lowering passes since they
      // can't lower tf.Const.
      Value cst;
      if (use_mhlo_const) {
        cst = builder.create<mhlo::ConstantOp>(func_op->getLoc(), attrs);
      } else {
        cst = builder.create<TF::ConstOp>(func_op->getLoc(), attrs);
      }
      func_op.getArgument(i).replaceAllUsesWith(cst);
    }
    return module_op;
  }

  LogicalResult matchAndRewrite(ConstOp const_op,
                                PatternRewriter& rewriter) const override {
    if (arith::ConstantOp::isBuildableWith(const_op.getValue(),
                                           const_op.getType())) {
      rewriter.replaceOpWithNewOp<arith::ConstantOp>(const_op,
                                                     const_op.getValue());
      return success();