// symbols for a given primary symbol are placed following it in the
// array, e.g.
//
//	...
//	k+0:  regular sym k
//	k+1:    1st aux symbol for k
//	k+2:    2nd aux symbol for k
//	k+3:  regular sym k+3
//	k+4:    1st aux symbol for k+3
//	k+5:  regular sym k+5
//	k+6:  regular sym k+6
//
// The PE format allows for several possible aux symbol formats. For
// more info see:
//

Cherry Mui <******@****.***> 1632249337 -0400

     *
     * In the class scope of `B`, there is a callable symbol `foo` that takes a `String`. This symbol is derived from the original symbol
     * in `A` that takes the type parameter `T` (fake override). Given such a fake override symbol, [unwrapFakeOverrides] recovers the
     * original declared symbol.
     *
     * Such situation can also happen for intersection symbols (in case of multiple super types containing symbols with identical signature

            return KaSuperTypesFilter { analysisSession, superType, symbol -> predicate(analysisSession, superType, symbol) }
        }
    }
}

    }

    protected static boolean isRead(String unixSymbolic) {
        char symbol = unixSymbolic.charAt(0);
        if (symbol == 'r') {
            return true;
        } else if (symbol == '-') {
            return false;
        } else {
            throw new IllegalArgumentException("'" + symbol + "' is not a valid Unix permission READ flag, must be 'r' or '-'.");
        }
    }

    override fun <S : KaFunctionLikeSymbol> asSignature(symbol: S): KaFunctionLikeSignature<S> {
        return KaFe10FunctionLikeSignature(symbol, symbol.returnType, symbol.receiverType, symbol.valueParameters.map { asSignature(it) })
    }

    override fun <S : KaVariableLikeSymbol> asSignature(symbol: S): KaVariableLikeSignature<S> {
        return KaFe10VariableLikeSignature(symbol, symbol.returnType, symbol.receiverType)
    }

                if (symbol is KaPossibleMultiplatformSymbol) {
                    if (symbol.isActual) add(KtTokens.ACTUAL_KEYWORD)
                    if (symbol.isExpect) add(KtTokens.EXPECT_KEYWORD)
                }

                if (symbol is KaFunctionSymbol) {
                    if (symbol.isExternal) add(KtTokens.EXTERNAL_KEYWORD)
                    if (symbol.isOverride) add(KtTokens.OVERRIDE_KEYWORD)

        val platform = getContainingModule(symbol).platform
        if (!platform.has<JvmPlatform>()) return null

        val containingSymbolOrSelf = when (symbol) {
            is KaValueParameterSymbol -> {
                getContainingDeclaration(symbol) as? KaFunctionLikeSymbol ?: symbol
            }
            is KaPropertyAccessorSymbol -> {

    override fun getDeprecation(symbol: KaSymbol): DeprecationInfo? {
        if (symbol is KaFirPackageSymbol || symbol is KaReceiverParameterSymbol) return null
        require(symbol is KaFirSymbol<*>) { "${this::class}" }

        // Optimization: Avoid building `firSymbol` of `KtFirPsiJavaClassSymbol` if it definitely isn't deprecated.
        if (symbol is KaFirPsiJavaClassSymbol && !symbol.mayHaveDeprecation()) {
            return null

				err = pkgError
				return
			}
			panic(e)
		}()

		switch {
		case symbol == "":
			pkg.packageDoc() // The package exists, so we got some output.
			return
		case method == "":
			if pkg.symbolDoc(symbol) {
				return
			}
		case pkg.printMethodDoc(symbol, method):
			return
		case pkg.printFieldDoc(symbol, method):
			return
		}
	}
}