is KaAnonymousFunctionSymbol -> anonymousFunctionRenderer.renderSymbol(analysisSession, symbol, this, printer)
            is KaConstructorSymbol -> constructorRenderer.renderSymbol(analysisSession, symbol, this, printer)
            is KaFunctionSymbol -> functionSymbolRenderer.renderSymbol(analysisSession, symbol, this, printer)

        ) {
            printer {
                val superTypesToRender = symbol.superTypes
                    .filter { declarationRenderer.superTypesFilter.filter(analysisSession, it, symbol) }.ifEmpty { return }

                printCollection(superTypesToRender) { type ->
                    declarationRenderer.superTypeRenderer.renderSuperType(analysisSession, type, symbol, declarationRenderer, printer)

                    // Rendering a containing symbol is prone to stack overflow.
                    // * function symbol will render its value parameter symbol(s)
                    //   whose containing symbol is that function symbol.
                    // * property symbol contains accessor symbol(s) and/or backing field symbol
                    //   whose containing symbol is that property symbol.
                    it.name == "getContainingSymbol"

    public fun renderSymbol(
        analysisSession: KaSession,
        symbol: KaValueParameterSymbol,
        declarationRenderer: KaDeclarationRenderer,
        printer: PrettyPrinter,
    )

    public object AS_SOURCE : KaValueParameterSymbolRenderer {
        override fun renderSymbol(
            analysisSession: KaSession,
            symbol: KaValueParameterSymbol,
            declarationRenderer: KaDeclarationRenderer,

    override fun getContainingDeclaration(symbol: KaSymbol): KaDeclarationSymbol? {
        if (symbol is KaSymbolWithKind && symbol.symbolKind == KaSymbolKind.TOP_LEVEL) {
            return null
        }

        return when (symbol) {
            is KaBackingFieldSymbol -> symbol.owningProperty
            is KaPropertyAccessorSymbol -> {

                }
                else -> error("Unexpected symbol ${symbol::class}")
            }
            additionalInfo(symbol)?.let { append(" [$it]") }
        }
    }

    @Suppress("unused")// KaSession receiver
    private fun KaSession.symbolContainerFqName(symbol: KaSymbol): String? {
        if (symbol is KaPackageSymbol || symbol is KaValueParameterSymbol) return null
        val nonLocalFqName = when (symbol) {

        return asSignature(symbol).substitute(substitutor)
    }

    override fun <S : KaCallableSymbol> asSignature(symbol: S): KaCallableSignature<S> {
        return when (symbol) {
            is KaFunctionLikeSymbol -> asSignature(symbol)
            is KaVariableLikeSymbol -> asSignature(symbol)
            else -> unexpectedElementError("symbol", symbol)
        }
    }

        override fun renderAccessors(
            analysisSession: KaSession,
            symbol: KaPropertySymbol,
            declarationRenderer: KaDeclarationRenderer,
            printer: PrettyPrinter,
        ): Unit = printer {
            val toRender = listOfNotNull(symbol.getter, symbol.setter)
                .filter { !it.isDefault || it.annotations.isNotEmpty() }
                .ifEmpty { return }

	SSUBTYP_DWMAC   = 0xB0000 // DWARF macros section
)

// Symbol Table Entry.
type SymEnt32 struct {
	Nname   [8]byte // Symbol name
	Nvalue  uint32  // Symbol value
	Nscnum  uint16  // Section number of symbol
	Ntype   uint16  // Basic and derived type specification
	Nsclass uint8   // Storage class of symbol
	Nnumaux uint8   // Number of auxiliary entries
}

type SymEnt64 struct {

// by starting with an initial list of symbols and references symbols by their
// index into that list. When a symbol is referenced, it's moved to the front
// of the list. Thus, a repeated symbol ends up being encoded with many zeros,
// as the symbol will be at the front of the list after the first access.
type moveToFrontDecoder []byte