return ipnet.IP.String()
			}
		}
	}
	return ""
}

type topic struct {
	Name string
	URL  string
}

func getTopics() []topic {
	topicMutex.Lock()
	defer topicMutex.Unlock()

	topics := make([]topic, 0, len(allTopics))
	for _, t := range allTopics {
		topics = append(topics, topic{Name: t.Title(), URL: "/" + t.Prefix() + "z/"})
	}

	return topics
}

import org.jetbrains.kotlin.analysis.api.resolution.KaSymbolBasedReference

@OptIn(KaAnalysisApiInternals::class)
@Deprecated(
    "The API has been moved into `org.jetbrains.kotlin.analysis.api.resolution` package",
    level = DeprecationLevel.HIDDEN,
)
public typealias KaSymbolBasedReference = KaSymbolBasedReference

@OptIn(KaAnalysisApiInternals::class)

    />
  </extensions>

  <projectListeners>
    <listener
        class="org.jetbrains.kotlin.analysis.api.fir.KaFirSessionProvider$SessionInvalidationListener"
        topic="org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirSessionInvalidationListener"
    />
  </projectListeners>

        get() = withValidityAssertion {
            descriptor?.let { KaFe10AnnotationList.create(it.annotations, analysisContext) } ?: KaEmptyAnnotationList(token)
        }

    @OptIn(KaAnalysisApiInternals::class)
    override fun createPointer(): KaSymbolPointer<KaPropertySetterSymbol> = withValidityAssertion {

        withFirEntry("annotation", annotation)
        withClassEntry("annotationTypeRef", annotation.annotationTypeRef)
        @OptIn(UnresolvedExpressionTypeAccess::class)
        withClassEntry("coneTypeOrNull", annotation.coneTypeOrNull)
        @OptIn(UnsafeExpressionUtility::class)
        annotation.toReferenceUnsafe()?.let { withClassEntry("calleeReference", it) }
    }

internal object KaFirReferenceResolver : ResolveCache.PolyVariantResolver<KtReference> {
    class KotlinResolveResult(element: PsiElement) : PsiElementResolveResult(element)

    @OptIn(KaAllowAnalysisOnEdt::class, KaAllowAnalysisFromWriteAction::class)
    override fun resolve(ref: KtReference, incompleteCode: Boolean): Array<ResolveResult> {

    override val annotations: KaAnnotationList
        get() = withValidityAssertion {
            KaFirAnnotationListForDeclaration.create(firSymbol, builder)
        }

    @OptIn(UnexpandedTypeCheck::class)
    override val upperBounds: List<KaType> by cached {
        firSymbol.resolvedBounds.mapNotNull { type ->
            if (type.isNullableAny) return@mapNotNull null

        get() = withValidityAssertion { coneType.functionTypeKind(builder.rootSession)?.isReflectType == true }

    override val arity: Int get() = withValidityAssertion { parameterTypes.size }

    @OptIn(KaAnalysisApiInternals::class)
    override val contextReceivers: List<KaContextReceiver> by cached {
        coneType.contextReceiversTypes(builder.rootSession)
            .map {

        }
    }

    override val typeParameters = withValidityAssertion {
        firSymbol.createRegularKtTypeParameters(builder)
    }

    @OptIn(KaAnalysisApiInternals::class)
    override val classKind: KaClassKind
        get() = withValidityAssertion {
            firSymbol.classKind.toKtClassKind(isCompanionObject = firSymbol.isCompanion)
        }

    override val valueParameters: List<KaValueParameterSymbol> get() = withValidityAssertion { emptyList() }

    override val hasStableParameterNames: Boolean
        get() = withValidityAssertion { true }

    @OptIn(KaAnalysisApiInternals::class)
    override fun createPointer(): KaSymbolPointer<KaPropertyGetterSymbol> = withValidityAssertion {
        KaPsiBasedSymbolPointer.createForSymbolFromSource<KaPropertyGetterSymbol>(this)