mlir::Value padding_value = tf_matrix_diag_v2_or_v3_op.getPaddingValue();
  mlir::Type element_type =
      mlir::cast<ShapedType>(padding_value.getType()).getElementType();
  if (mlir::isa<FloatType>(element_type)) {
    DenseFPElementsAttr padding_attr;
    if (!matchPattern(padding_value, m_Constant(&padding_attr)) ||
        !padding_attr.isSplat() ||
        !padding_attr.getSplatValue<APFloat>().isZero()) {

    if (!attr) return false;
    auto splat = mlir::dyn_cast<SplatElementsAttr>(attr);
    if (!splat) return false;
    Type element_ty = splat.getType().getElementType();
    if (mlir::isa<FloatType>(element_ty))
      return splat.getSplatValue<llvm::APFloat>().isZero();
    if (mlir::isa<IntegerType>(element_ty))
      return splat.getSplatValue<llvm::APInt>().getSExtValue() == 0;
    return false;
  };

          if (!quantizing_op->getResult(i)
                   .getType()
                   .cast<ShapedType>()
                   .getElementType()
                   .isa<FloatType>()) {
            continue;
          }
          CreateVerifier<VerifierT>(quantizing_op, quantized_op, rewriter, i,
                                    quant_params_);

          if (enable_whole_model_verify) {

		case 1 + signedDelta:
			t.Go = c.int8
		case 2 + signedDelta:
			t.Go = c.int16
		case 4 + signedDelta:
			t.Go = c.int32
		case 8 + signedDelta:
			t.Go = c.int64
		}

	case *dwarf.FloatType:
		switch t.Size {
		default:
			fatalf("%s: unexpected: %d-byte float type - %s", lineno(pos), t.Size, dtype)
		case 4:
			t.Go = c.float32
		case 8:
			t.Go = c.float64
		}

// Checks if the param passed is a float ElementsAttr.
def FloatElementsAttr : ElementsAttrBase<
  CPred<"$_self.isa<ElementsAttr>() && $_self.cast<ElementsAttr>().getShapedType().getElementType().isa<FloatType>()">,
        "float constant tensor">;

def ExtractSingleElementAsFloat : NativeCodeCall<
    "ExtractSingleElementAsFloat($_self.cast<ElementsAttr>())">;

// Checks if the value has rank at most 'n'.

                                      delta_attr.getInt());
    }
    return BuildConstRangeTensor(elem_type, num_elements, start_attr,
                                 delta_attr);
  } else if (elem_type.isa<FloatType>()) {
    auto start_attr = start_tensor.getValues<FloatAttr>()[0];
    auto limit_attr = limit_tensor.getValues<FloatAttr>()[0];
    auto delta_attr = delta_tensor.getValues<FloatAttr>()[0];

		{"(*Entry).Val", Method, 0},
		{"(*EnumType).Common", Method, 0},
		{"(*EnumType).Size", Method, 0},
		{"(*EnumType).String", Method, 0},
		{"(*FloatType).Basic", Method, 0},
		{"(*FloatType).Common", Method, 0},
		{"(*FloatType).Size", Method, 0},
		{"(*FloatType).String", Method, 0},
		{"(*FuncType).Common", Method, 0},
		{"(*FuncType).Size", Method, 0},
		{"(*FuncType).String", Method, 0},

// to `raw_value`.
template <typename T>
bool IsConstantValueOf(mlir::TypedAttr value, T raw_value) {
  auto element_type = mlir::cast<ShapedType>(value.getType()).getElementType();

  if (mlir::isa<FloatType>(element_type)) {
    return FloatValueEquals(value, raw_value);
  } else if (mlir::isa<IntegerType>(element_type)) {
    auto int_attr = mlir::dyn_cast_or_null<DenseIntElementsAttr>(value);
    if (!int_attr) return false;