output_ranges->push_back(CalculateQuantizedRange(
      o_spec.getScale(), o_spec.getZeroPoint(),
      (min ? std::optional<double>(min.getValueAsDouble()) : std::nullopt),
      (max ? std::optional<double>(max.getValueAsDouble()) : std::nullopt),
      o_spec.getStorageTypeMin(), o_spec.getStorageTypeMax()));

  return success();
}

LogicalResult DeviceTarget::DecomposeSameScale(

    ElementsAttr layer_stats = DenseFPElementsAttr::get(
        RankedTensorType::get({2}, rewriter.getF32Type()),
        {static_cast<float>(min.getValueAsDouble()),
         static_cast<float>(max.getValueAsDouble())});
    ElementsAttr axis_stats;
    IntegerAttr axis;

    quantfork::StatisticsOp stats_op = rewriter.create<quantfork::StatisticsOp>(

    min.reserve(fqOp.getMin().size());
    max.reserve(fqOp.getMax().size());
    for (auto m : fqOp.getMin())
      min.push_back(cast<FloatAttr>(m).getValueAsDouble());
    for (auto m : fqOp.getMax())
      max.push_back(cast<FloatAttr>(m).getValueAsDouble());

    return fakeQuantAttrsToType(fqOp.getLoc(), fqOp.getNumBits(),
                                fqOp.getAxis(), min, max, fqOp.getNarrowRange(),

inline bool GetCostOnOp(Operation* op, float* cost) {
  auto cost_type = op->getAttrOfType<FloatAttr>(kCost);
  if (cost_type == nullptr) {
    return false;
  }

  *cost = cost_type.getValueAsDouble();
  return true;
}

}  // namespace tac
}  // namespace TFL
}  // namespace mlir

      min_value.push_back(FloatAttr::getValueAsDouble(*it));
    }
    for (auto it = maxs.begin(); it != maxs.end(); ++it) {
      max_value.push_back(FloatAttr::getValueAsDouble(*it));
    }
  } else {
    const auto fmin = dyn_cast<FloatAttr>(min);
    const auto fmax = dyn_cast<FloatAttr>(max);
    if (fmin && fmax) {
      min_value.push_back(fmin.getValueAsDouble());

    fbb->Int(key, mlir::dyn_cast<mlir::IntegerAttr>(attr).getInt());
    return success();
  }

  if (mlir::isa<::mlir::FloatAttr>(attr)) {
    fbb->Double(key, mlir::dyn_cast<mlir::FloatAttr>(attr).getValueAsDouble());
    return success();
  }

  return op->emitWarning("serialization not supported for : ") << key;
}

TFL::CustomOp BuildCustomOp(stablehlo::CompositeOp composite,

      stats_op.emitError("Stats should have 2 values.");
      return failure();
    }
    quant::QuantizedType quant_type;
    double min = FloatAttr::getValueAsDouble(stats.getValues<APFloat>()[0]);
    double max = FloatAttr::getValueAsDouble(stats.getValues<APFloat>()[1]);
    // Make sure the range includes zero.
    min = std::min(min, 0.0);
    max = std::max(max, 0.0);

      if (!stats) return failure();

      for (auto it = stats.begin(), e = stats.end(); it != e; ++it) {
        double rmin = FloatAttr::getValueAsDouble(*it++);
        double rmax = FloatAttr::getValueAsDouble(*it);
        // The default nudging implementation of mlir quant library might cause
        // clamping during inference if the calibration range isn't wide enough.

    auto cost_attr = device_costs_attr.getNamed(kv.first);
    if (!cost_attr.has_value()) return std::nullopt;
    float cost = mlir::dyn_cast_or_null<mlir::FloatAttr>(cost_attr->getValue())
                     .getValueAsDouble();
    device_costs[kv.second] = cost;
  }
  return device_costs;
}

flatbuffers::Offset<SubgraphMetadata> CreateSubgraphMetadata(
    const std::map<std::string, uint8_t>& hardware_map, mlir::Region* Region,

  value->set_i(attr.getInt());
  return absl::OkStatus();
}

Status ConvertAttribute(const mlir::FloatAttr& attr, AttrValue* value) {
  value->set_f(attr.getValueAsDouble());
  return absl::OkStatus();
}

Status ConvertAttribute(const mlir::ElementsAttr& attr, AttrValue* value) {
  return ConvertToTensorProto(attr, value->mutable_tensor());
}