renderAnnotationDebug(annotation.annotationClass?.classId, namedValues, printer)
    }

    private fun renderAnnotationDebug(classId: ClassId?, namedValues: List<KtNamedAnnotationValue>, printer: PrettyPrinter) {
        with(printer) {
            append("@")

            if (classId != null) {
                append("R|")
                renderFqName(classId.asSingleFqName(), printer)
                append("|")

                    val classId = coneType.lookupTag.classId
                    val type = builder.typeBuilder.buildKtType(coneType)
                    KtKClassAnnotationValue(type, classId, sourcePsi, token)
                } else {
                    val classId = computeErrorCallClassId(this)

    get() {
        return toResolvedCallableSymbol()
    }

/**
 * Referenced [ClassId], even if it is not completely correctly resolved.
 */
private val FirResolvedTypeRef.resolvedClassId: ClassId?
    get() {
        if (this !is FirErrorTypeRef) return type.classId

        val candidateSymbols = diagnostic.getCandidateSymbols()

import okio.BufferedSource
import okio.ByteString.Companion.encodeUtf8
import okio.Options

class ServerSentEventReader(
  private val source: BufferedSource,
  private val callback: Callback,
) {
  private var lastId: String? = null

  interface Callback {
    fun onEvent(
      id: String?,
      type: String?,
      data: String,
    )

    fun onRetryChange(timeMs: Long)
  }

  /**

            if (parentFir is FirResolvedQualifier) {
                var classId = parentFir.classId
                while (unresolvedCounter > 0) {
                    unresolvedCounter--
                    classId = classId?.outerClassId
                }
                return listOfNotNull(classId?.toTargetPsi(session, symbolBuilder))
            }

    override val annotationClassIds: Collection<ClassId>
        get() {
            withValidityAssertion {
                val result = mutableListOf<ClassId>()
                for (annotation in fe10Annotations) {
                    val classId = annotation.classIdForAnnotation ?: continue
                    if (classId in annotationsToIgnore) continue
                    result += classId
                }

                return result

        consumer.addIfNotNull(symbol)
    }

    private fun KtAnalysisSession.collectSymbolsByClassId(classId: ClassId, consumer: MutableCollection<KtSymbol>) {
        val symbol = getClassOrObjectSymbolByClassId(classId) ?: getTypeAliasByClassId(classId)
        consumer.addIfNotNull(symbol)
    }

    private fun KtAnalysisSession.collectSymbolsByFqNameInterpretationAsCallableId(

        KtPsiBasedSymbolPointer.createForSymbolFromSource<KtSamConstructorSymbol>(this)?.let {
            return it
        }

        val classId = descriptor.baseDescriptorForSynthetic.classId
        if (classId != null) {
            return KtFe10DescSamConstructorSymbolPointer(classId)
        }

        return KtFe10NeverRestoringSymbolPointer()
    }

    override fun equals(other: Any?): Boolean = isEqualTo(other)

        }

    override fun hasAnnotation(classId: ClassId, useSiteTargetFilter: AnnotationUseSiteTargetFilter): Boolean = withValidityAssertion {
        hasAnnotation(firSymbol, classId, useSiteTargetFilter, useSiteSession)
    }

    override fun annotationsByClassId(
        classId: ClassId,
        useSiteTargetFilter: AnnotationUseSiteTargetFilter,

	// within the hour since l.UpdatedAt
	if since < 1 {
		return
	}

	idx, lastIdx := t.Hour(), l.UpdatedAt.Hour()

	l.UpdatedAt = t // update to the latest time index

	if since >= 24 {
		l.Bins = [24]tierStats{}
		return
	}

	for lastIdx != idx {
		lastIdx = (lastIdx + 1) % 24
		l.Bins[lastIdx] = tierStats{}
	}
}

func (l *lastDayTierStats) clone() lastDayTierStats {