Collection<Ref> refs = getRemoteRefs(gitSpec, true, false);
        Set<VersionRef> versions = new HashSet<>();
        for (Ref ref : refs) {
            GitVersionRef gitRef = GitVersionRef.from(ref);
            versions.add(gitRef);
        }
        return versions;
    }

    @Override
    public VersionRef getDefaultBranch(VersionControlSpec spec) {
        GitVersionControlSpec gitSpec = cast(spec);

 */
func addlibpath(ctxt *Link, srcref, objref, file, pkg, shlib string, fingerprint goobj.FingerprintType) *sym.Library {
	if l := ctxt.LibraryByPkg[pkg]; l != nil {
		return l
	}

	if ctxt.Debugvlog > 1 {
		ctxt.Logf("addlibpath: srcref: %s objref: %s file: %s pkg: %s shlib: %s fingerprint: %x\n", srcref, objref, file, pkg, shlib, fingerprint)
	}

	l := &sym.Library{}
	ctxt.LibraryByPkg[pkg] = l

	s.SetSiz(12345)
	s.SetAlign(8)
	s.Write(w)

	var r Reloc
	r.SetOff(12)
	r.SetSiz(4)
	r.SetType(uint16(objabi.R_ADDR))
	r.SetAdd(54321)
	r.SetSym(SymRef{11, 22})
	r.Write(w)

	var a Aux
	a.SetType(AuxFuncInfo)
	a.SetSym(SymRef{33, 44})
	a.Write(w)

	w.wr.Flush()

	// Read them back and check.
	b := buf.Bytes()
	var s2 Sym
	s2.fromBytes(b)

        @Override
        public void write(Encoder encoder, VersionRef value) throws Exception {
            GitVersionRef gitRef = (GitVersionRef) value;
            encoder.writeString(gitRef.getVersion());
            encoder.writeString(gitRef.getCanonicalId());
        }

        @Override
        public VersionRef read(Decoder decoder) throws Exception {

	// see https://github.com/kubernetes/kubernetes/issues/106387
	// For kube-openapi, allOf is only used for wrapping a Ref.
	for _, allOf := range schema.AllOf {
		if ref, isRef := refOf(&allOf); isRef {
			return ref, isRef
		}
	}
	return "", false

        mlir::cast<NameLoc>(locations.front()).getName().strref();
    StringRef op_type =
        op_type_with_suffix.substr(0, op_type_with_suffix.size() - 1);
    new_unit.set_op_type(op_type.str());

    if (isa<NameLoc>(locations.back())) {
      StringRef name_loc_id =
          mlir::cast<NameLoc>(locations.back()).getName().strref();
      set_node_and_func_name(new_unit, name_loc_id);
    } else {

  return *ops;
}

void CollectAllowedAttrs(CallOp src, NamedAttrList* attrs) {
  for (auto& attr : src->getAttrs()) {
    if (GetAllowedAttributes().contains(attr.getName().strref())) {
      attrs->append(attr);
    }
  }
}

// Adds `attrs` to all the operations between `begin` and `end` in the same
// block. Does not include `end`.

    for (NamedAttribute a : attrs) {
      if (a.getName().strref().starts_with("tf_saved_model.")) {
        f.removeArgAttr(i, a.getName());
      }
    }
  }
  for (int i = 0; i < f.getNumResults(); ++i) {
    for (NamedAttribute a : f.getResultAttrs(i)) {
      if (a.getName().strref().starts_with("tf_saved_model.")) {
        f.removeResultAttr(i, a.getName());
      }
    }
  }
}

	return result
}

// InlTreeNode is the serialized form of FileInfo.InlTree.
type InlTreeNode struct {
	Parent   int32
	File     CUFileIndex
	Line     int32
	Func     SymRef
	ParentPC int32
}

func (inl *InlTreeNode) Write(w *bytes.Buffer) {
	var b [4]byte
	writeUint32 := func(x uint32) {
		binary.LittleEndian.PutUint32(b[:], x)
		w.Write(b[:])
	}

  auto callsite_loc = llvm::dyn_cast<CallSiteLoc>(attr);

  if (!mlir::isa<NameLoc>(callsite_loc.getCaller())) return false;
  StringRef caller_name =
      mlir::cast<NameLoc>(callsite_loc.getCaller()).getName().strref();
  return caller_name.starts_with(kQuantizationUnitPrefix) &&
         caller_name.ends_with(kQuantizationUnitSuffix);
}

std::optional<QuantizationUnitLoc::QuantizationUnit>
FindQuantizationUnitFromLoc(Location loc) {