auto element_type = attr.getType().getElementType();
    if (attr.getNumElements() != 1 || !element_type.isIntOrFloat())
      return false;
    if (mlir::isa<FloatType>(element_type)) {
      auto value = *attr.value_begin<APFloat>();
      return value.isNegative() && value.isInfinity();
    } else if (element_type.isInteger(1)) {
      auto value = *attr.value_begin<APInt>();

  ShapedType type = mlir::dyn_cast<ShapedType>(op.getType());
  Type etype = type.getElementType();
  Attribute result = {};
  if (mlir::isa<FloatType>(etype)) {
    result =
        BinaryFolder<mhlo::MulOp, FloatType, APFloat, std::multiplies<APFloat>>(
            &op);
  } else if (mlir::isa<IntegerType>(etype)) {
    result =

#include "mlir/Support/LLVM.h"  // from @llvm-project

namespace mlir::quant::stablehlo {

bool IsLargeFloatType(Type type) {
  type = getElementTypeOrSelf(type);
  return isa<FloatType>(type) && type.getIntOrFloatBitWidth() > 16;
}

Type ToBfloat16Type(Type type) {
  if (auto shaped = mlir::dyn_cast<ShapedType>(type)) {
    const Type elem = shaped.getElementType();
    if (IsLargeFloatType(elem)) {

			Type:   cadvisorapiv1.MetricGauge,
			Format: cadvisorapiv1.IntType,
			Units:  "per second",
		},
		{
			Name:   "cpuLoad",
			Type:   cadvisorapiv1.MetricCumulative,
			Format: cadvisorapiv1.FloatType,
			Units:  "count",
		},
	}
	timestamp1 := time.Now()
	timestamp2 := time.Now().Add(time.Minute)
	metrics := map[string][]cadvisorapiv1.MetricVal{
		"qos": {
			{
				Timestamp: timestamp1,

  return success();
}

LogicalResult ModifyIONodesPass::ModifyInputNodes(
    func::FuncOp func, llvm::SmallVectorImpl<Type>& new_input_types,
    OpBuilder builder) {
  if (mlir::isa<FloatType>(input_type)) {
    return success();
  }

  Block& block = func.front();
  builder.setInsertionPointToStart(&block);

  for (int i = 0; i != block.getNumArguments(); ++i) {

    override val short: KaType by cachedBuiltin(builtinTypes.shortType)
    override val byte: KaType by cachedBuiltin(builtinTypes.byteType)

    override val float: KaType by cachedBuiltin(builtinTypes.floatType)
    override val double: KaType by cachedBuiltin(builtinTypes.doubleType)

    override val char: KaType by cachedBuiltin(builtinTypes.charType)
    override val boolean: KaType by cachedBuiltin(builtinTypes.booleanType)

    if (isa<func::ReturnOp>(quantizable_op)) {
      return;
    }

    TensorType old_result_type =
        mlir::dyn_cast<TensorType>(op.getResult().getType());
    const FloatType quantized_type = FloatType::getF16(op.getContext());
    const ShapedType new_result_type = old_result_type.clone(quantized_type);

    // Insert ConvertOp if it does not exist yet. Otherwise, just rewire without

// tests via GoogleTest's TypedTests:
// https://github.com/google/googletest/blob/e589a337170554c48bc658cc857cf15080c9eacc/googletest/docs/advanced.md#typed-tests
struct FloatType {
  using type = float;
  static constexpr TF_DataType kDType = TF_FLOAT;
};

struct DoubleType {
  using type = double;
  static constexpr TF_DataType kDType = TF_DOUBLE;
};

struct Int32Type {

	return escaper + strings.ReplaceAll(string(v), escaper, escaper+escaper) + escaper
}

func TestExplainSQL(t *testing.T) {
	type role string
	type password []byte
	type intType int
	type floatType float64
	var (
		tt                 = now.MustParse("2020-02-23 11:10:10")
		myrole             = role("admin")
		pwd                = password("pass")
		jsVal              = []byte(`{"Name":"test","Val":"test"}`)

            static_cast<double>(uniform_type.getStorageTypeMax()),
            uniform_type.getStorageTypeIntegralWidth(),
            uniform_type.isSigned()) {
    assert(isa<FloatType>(uniform_type.getExpressedType()));
    assert(uniform_type.getStorageType().isSignlessInteger());
  }

  UniformQuantizedValueConverter(double scale, double zero_point,