return failure();
    }
    for (Value input : op->getOperands()) {
      if (getElementTypeOrSelf(input).isBF16()) {
        return success();
      }
    }
    for (Value value : op->getResults()) {
      if (getElementTypeOrSelf(value).isBF16()) {
        return success();
      }
    }
    return failure();
  }

		{src: "tsan7.go", needsRuntime: true},
		{src: "tsan8.go"},
		{src: "tsan9.go"},
		{src: "tsan10.go", needsRuntime: true},
		{src: "tsan11.go", needsRuntime: true},
		{src: "tsan12.go", needsRuntime: true},
		{src: "tsan13.go", needsRuntime: true},
		{src: "tsan14.go", needsRuntime: true},
		{src: "tsan15.go", needsRuntime: true},
	}
	for _, tc := range cases {
		tc := tc
		name := strings.TrimSuffix(tc.src, ".go")

        description: "Language of the book"
      author:
        type: "string"
        description: "Author of the book"
      ISBN-10:
        type: "string"
        description: "ISBN-10 of the book"
      ISBN-13:
        type: "string"
        description: "ISBN-13 of the book"
      year:
        type: "integer"
        format: "int32"
        description: "Year the book was first published in"

<book>
	<meta name="title" content="The Go Programming Language"/>
	<meta name="authors" content="Alan Donovan and Brian Kernighan"/>
	<meta name="published" content="2015-10-26"/>
	<meta name="isbn" content="978-0134190440"/>
	<data>...</data>
</book>
`

	var b bytes.Buffer

	// Compress the data using the specially crafted dictionary.

    auto floatAttr = mlir::FloatAttr::get(floatType, static_cast<float>(value));
    std::vector<Attribute> floatValues({floatAttr});
    return DenseElementsAttr::get(shaped_type, floatValues);
  } else if (element_type.isBF16()) {
    auto floatType = mlir::FloatType::getBF16(element_type.getContext());
    auto floatAttr = mlir::FloatAttr::get(floatType, static_cast<float>(value));
    std::vector<Attribute> floatValues({floatAttr});

inline bool TFTypeIsBFloat16Tensor(Value value) {
  auto tensorType = mlir::dyn_cast<TensorType>(value.getType());
  if (!tensorType) return false;
  return tensorType.getElementType().isBF16();
}

// Returns true iff the given value is a f16 tensor.
inline bool TFTypeIsHalfTensor(Value value) {
  auto tensorType = mlir::dyn_cast<TensorType>(value.getType());
  if (!tensorType) return false;

  auto type = mlir::dyn_cast<ShapedType>(val.getType());
  if (!type) return false;
  // Supported original tensor data types.
  if (type.getElementType().isF32() || type.getElementType().isBF16())
    return true;
  return false;
}

std::optional<tensorflow::quantization::QuantizationComponentSpec>
GetWeightComponentSpec(
    const tensorflow::quantization::QuantizationOptions& quantization_options) {

    return absl::OkStatus();
  } else if (type.isF32()) {
    *dtype = DT_FLOAT;
    return absl::OkStatus();
  } else if (type.isF64()) {
    *dtype = DT_DOUBLE;
    return absl::OkStatus();
  } else if (type.isBF16()) {
    *dtype = DT_BFLOAT16;
    return absl::OkStatus();
  } else if (type.isFloat8E4M3FN()) {
    *dtype = DT_FLOAT8_E4M3FN;
    return absl::OkStatus();
  } else if (type.isFloat8E5M2()) {

using absl::StatusOr;

namespace errors = tensorflow::errors;

tflite::TensorType ConvertTypeToTensorType(mlir::Type type) {
  if (type.isF16()) {
    return tflite::TensorType_FLOAT16;
  } else if (type.isBF16()) {
    return tflite::TensorType_BFLOAT16;
  } else if (type.isF32()) {
    return tflite::TensorType_FLOAT32;
  } else if (type.isF64()) {
    return tflite::TensorType_FLOAT64;

def IsF32ElementType : Constraint<
  CPred<"getElementTypeOrSelf($0).isF32()">>;

// Checks if the value has the type of bfloat16.
def IsBF16ElementType : Constraint<
  CPred<"getElementTypeOrSelf($0).isBF16()">>;

// Checks if the value has the type of UniformQuantizedType.
def IsUniformQuantizedType : Constraint<
  CPred<"getElementTypeOrSelf($0).isa<mlir::quant::UniformQuantizedType>()">>;