.Case<TF::Qint8Type>(
          [&type](Type) { return IntegerType::get(type.getContext(), 8); })
      .Case<TF::Qint16Type>(
          [&type](Type) { return IntegerType::get(type.getContext(), 16); })
      .Case<TF::Qint32Type>(
          [&type](Type) { return IntegerType::get(type.getContext(), 32); })
      .Case<TF::Quint8Type>([&type](Type) {
        return IntegerType::get(type.getContext(), 8,

      {1, 2}, DT_UINT8,
      mlir::IntegerType::get(
          &context, 8, mlir::IntegerType::SignednessSemantics::Unsigned)));
  ASSERT_NO_FATAL_FAILURE(VerifyConversion<uint16>(
      {1, 2}, DT_UINT16,
      mlir::IntegerType::get(
          &context, 16, mlir::IntegerType::SignednessSemantics::Unsigned)));
  ASSERT_NO_FATAL_FAILURE(VerifyConversion<uint32>(
      {1, 2}, DT_UINT32,
      mlir::IntegerType::get(

            BFloat16Type::get(context.get()));

  EXPECT_EQ(ToBfloat16Type(IntegerType::get(context.get(), 8)),
            IntegerType::get(context.get(), 8));
  EXPECT_EQ(ToBfloat16Type(IntegerType::get(context.get(), 16)),
            IntegerType::get(context.get(), 16));
  EXPECT_EQ(ToBfloat16Type(IntegerType::get(context.get(), 32)),
            IntegerType::get(context.get(), 32));
}

TEST(ToBfloat16TypeTest, tensors) {

  EXPECT_TRUE(llvm::isa<IntegerType>(type));
  EXPECT_EQ(mlir::dyn_cast<IntegerType>(type).getWidth(), 8);
  EXPECT_FALSE(mlir::dyn_cast<IntegerType>(type).isSigned());
  EXPECT_FALSE(mlir::dyn_cast<IntegerType>(type).isUnsigned());

  type = GetIntTypeFromTFQint(TF::Qint16Type::get(context.get()));
  EXPECT_TRUE(llvm::isa<IntegerType>(type));
  EXPECT_EQ(mlir::dyn_cast<IntegerType>(type).getWidth(), 16);

                                                     const bool narrow_range) {
  return UniformQuantizedType::getChecked(
      loc, /*flags=*/QuantizationFlags::Signed,
      /*storageType=*/IntegerType::get(&context, /*width=*/8),
      /*expressedType=*/FloatType::getF32(&context), scale, zero_point,
      /*storageTypeMin=*/llvm::minIntN(8) + (narrow_range ? 1 : 0),
      /*storageTypeMax=*/llvm::maxIntN(8));
}

	float32 | float64
} // ERRORx "expected declaration|non-declaration statement"

type IntegerType interface {
	int8 | int16 | int32 | int64 | int |
		uint8 | uint16 | uint32 | uint64 | uint
}

type ComplexType interface {
	complex64 | complex128
}

type Number interface {
	FloatType | IntegerType | ComplexType
}

func GetDefaultNumber[T Number](value, defaultValue T) T {
	if value == 0 {

				"a": objectType(map[string]schema.Structural{
					"b": integerType,
					"c": integerType,
					"d": withNullable(true, integerType),
				}),
				"a1": objectType(map[string]schema.Structural{
					"b1": objectType(map[string]schema.Structural{
						"c1": integerType,
					}),
					"d2": objectType(map[string]schema.Structural{
						"e2": integerType,
					}),
				}),
			}),

				"true": integerType, "false": integerType, "null": integerType, "in": integerType, "as": integerType,
				"break": integerType, "const": integerType, "continue": integerType, "else": integerType,
				"for": integerType, "function": integerType, "if": integerType, "import": integerType,
				"let": integerType, "loop": integerType, "package": integerType, "namespace": integerType,

  bool is_signed = true;
  if (tensor.type == tflite::TensorType_UINT8) {
    is_signed = false;
    storage_type = mlir::IntegerType::get(builder.getContext(), 8);
  }

  if (!storage_type) {
    const mlir::Type raw_elem_type = ConvertElementType(tensor.type, builder);
    if (!mlir::isa<mlir::IntegerType>(raw_elem_type)) {
      return absl::InvalidArgumentError(
          "Quantized tensors must be stored as integers");
    }

  // Hard-coded type mapping from TFLite.
  if (numBits <= 4) {
    storageType = IntegerType::get(ctx, 4);
    if (isSigned) {
      qmin = -8;
      qmax = 7;
    } else {
      qmin = 0;
      qmax = 15;
    }
  } else if (numBits <= 8) {
    storageType = IntegerType::get(ctx, 8);
    if (isSigned) {
      qmin = -128;
      qmax = 127;
    } else {
      qmin = 0;