}

  mlir::Attribute convertEncoding(mlir::Attribute attr) const final {
    // Must be VHLO encoding, or convertible to VHLO encoding.
    if (attr.getDialect().getNamespace() ==
        mlir::vhlo::VhloDialect::getDialectNamespace())
      return attr;

    if (auto stablehloAttr =
            mlir::dyn_cast_or_null<mlir::stablehlo::TypeExtensionsAttr>(attr)) {

}

const wzURL = "https://raw.githubusercontent.com/unicode-org/cldr/main/common/supplemental/windowsZones.xml"

type MapZone struct {
	Other     string `xml:"other,attr"`
	Territory string `xml:"territory,attr"`
	Type      string `xml:"type,attr"`
}

type SupplementalData struct {
	Zones []MapZone `xml:"windowsZones>mapTimezones>mapZone"`
}

func readWindowsZones() ([]*zone, error) {
	r, err := http.Get(wzURL)

Attribute DefaultOrNullAttr(OpBuilder& builder, const Attribute& attr) {
  if (attr) return attr;
  return builder.getStringAttr(kNullAttributeValue);
}

// Checks whether the value of a constant equals the given float, regardless
// of the tensor dimension.
bool FloatValueEquals(const Attribute& attr, const double value) {
  const auto fp_attr = mlir::dyn_cast_or_null<DenseFPElementsAttr>(attr);
  if (!fp_attr) return false;

            String tag = h23element.tagName();
            String name = h23element.text();
            String anchor = h23element.attr("id");
            if(!name.startsWith("Table") && tag.equals("h2")){
                toc.append("<li class=\"mainTopic\"><a/></li>").children().last().select("a").first().text(name).attr("href", "#" + anchor);
            } else if(!name.startsWith("Table") && tag.equals("h3")){

using ::tensorflow::calibrator::CalibrationStatisticsMap;

}  // namespace

REGISTER_OP("CalibrationStatisticsSaver")
    .Input("args: Tin")
    .Attr("Tin: list(type) >= 0")
    .Attr("ids: list(string) >= 1")
    .Attr("calibration_methods: list(int) >= 1")
    .Attr("output_file_path: string")
    .SetIsStateful()
    .Doc(R"doc(
Aggregates and saves the calibration statistics data.

  std::vector<Item> attrs(node_def.attr().begin(), node_def.attr().end());
  std::sort(attrs.begin(), attrs.end(),
            [](Item& p1, Item& p2) -> bool { return p1.first < p2.first; });
  for (const Item& pair : attrs) {
    const char* key = pair.first.c_str();
    const ::tensorflow::AttrValue& attr = pair.second;
    switch (attr.value_case()) {
      case ::tensorflow::AttrValue::kS:

			return ""
		}
		b.WriteString(strings.ToLower(major))
		b.WriteByte('/')
		b.WriteString(strings.ToLower(sub))
	}

	attrs := make([]string, 0, len(param))
	for a := range param {
		attrs = append(attrs, a)
	}
	slices.Sort(attrs)

	for _, attribute := range attrs {
		value := param[attribute]
		b.WriteByte(';')
		b.WriteByte(' ')
		if !isToken(attribute) {
			return ""
		}

                                                          int64_t rank) {
  DenseIntElementsAttr attrs;
  if (!matchPattern(value, m_Constant(&attrs)) ||
      attrs.getType().getRank() != 0) {
    return std::nullopt;
  }
  int64_t axis = attrs.getValues<IntegerAttr>()[0].getInt();
  return axis < 0 ? axis + rank : axis;
}

        op_code.custom_code, custom_options, builder, loc, &attrs);
    if (!status.ok()) {
      return emitError(loc, status.ToString()), status;
    }
  } else {
    mlir::BuiltinOptionsToAttributes(op.builtin_options, builder, attrs);
    mlir::BuiltinOptions2ToAttributes(op.builtin_options_2, builder, attrs);
  }

  if (builtin_code == tflite::BuiltinOperator_STABLEHLO_COMPOSITE) {

    all_arguments_.push_back(OpArgumentView(arg));
  }
  for (const auto& arg : op_.Outputs()) {
    all_arguments_.push_back(OpArgumentView(arg));
  }
  for (const auto& attr : op.Attributes()) {
    all_arguments_.push_back(OpArgumentView(attr));
  }
  all_arguments_.push_back(OpArgumentView("const char*", "name", "nullptr"));
  all_arguments_.push_back(
      OpArgumentView("const char*", "raw_device_name", "nullptr"));
}