{0x2, "PF_W"},
	{0x4, "PF_R"},
}

func (i ProgFlag) String() string   { return flagName(uint32(i), pfStrings, false) }
func (i ProgFlag) GoString() string { return flagName(uint32(i), pfStrings, true) }

// Dyn.Tag
type DynTag int

const (
	DT_NULL         DynTag = 0  /* Terminating entry. */
	DT_NEEDED       DynTag = 1  /* String table offset of a needed shared library. */

	if isComplex(Vu) && isComplex(Tu) {
		return true
	}

	// "V is an integer or a slice of bytes or runes and T is a string type"
	if (isInteger(Vu) || isBytesOrRunes(Vu)) && isString(Tu) {
		return true
	}

	// "V is a string and T is a slice of bytes or runes"
	if isString(Vu) && isBytesOrRunes(Tu) {
		return true
	}

	// package unsafe:

            analysisSession: KaSession,
            name: Name,
            owner: KaType,
            typeRenderer: KaTypeRenderer,
            printer: PrettyPrinter,
        ) {
            printer.append(name.asString())
        }
    }
}

            is Name -> printer.append(value.asString())
            is FqName -> printer.append(value.asString())
            is ClassId -> printer.append(value.asString())
            is DeprecationInfo -> renderDeprecationInfo(value, printer)
            is Visibility -> printer.append(value::class.java.simpleName)
            // Unsigned integers
            is UByte -> printer.append(value.toString())

                }?.fqNameForClassNameWithoutDollars?.asString()
            }
            else -> {
                return if (containingSymbolOrSelf.symbolKind == KaSymbolKind.TOP_LEVEL) {
                    descriptor?.let(DescriptorToSourceUtils::getContainingFile)
                        ?.takeUnless { it.isScript() }
                        ?.javaFileFacadeFqName?.asString()
                } else {

        return KaFirPsiJavaClassSymbol(psiClass, analysisSession)
    }

    private fun PsiClass.isKotlinCompiledClass() =
        this is ClsElementImpl && hasAnnotation(JvmAnnotationNames.METADATA_FQ_NAME.asString())

    override fun getCallableSymbol(callable: PsiMember): KaCallableSymbol? {
        if (callable !is PsiMethod && callable !is PsiField) return null
        val name = callable.name?.let(Name::identifier) ?: return null

        }
    }

    private fun render(symbol: KaSymbol): String {
        val qualifiedName = when (symbol) {
            is KaCallableSymbol -> symbol.callableId?.toString()
            is KaClassLikeSymbol -> symbol.classId?.toString()
            else -> null
        }

        return qualifiedName ?: (symbol as? KaNamedSymbol)?.name?.asString() ?: "Unnamed"
    }

        ) {
            if (symbol is KaClassOrObjectSymbol && symbol.classKind == KaClassKind.COMPANION_OBJECT && symbol.name == SpecialNames.DEFAULT_NAME_FOR_COMPANION_OBJECT)
                return
            printer.append(name.asString())
        }
    }
}

                            for (function in functions) {
                                val signature = function.substitute(substitutor)
                                append(signature.callableId!!.callableName.asString())
                                printCollection(signature.valueParameters, prefix = "(", postfix = ")") {
                                    append(it.returnType.render(typeRenderer, position = Variance.IN_VARIANCE))

            val getter = descriptor.getter ?: return SpecialNames.NO_NAME_PROVIDED
            return Name.identifier(DescriptorUtils.getJvmName(getter) ?: JvmAbi.getterName(descriptor.name.asString()))
        }

        val ktPropertyName = (symbol.psi as? KtProperty)?.name ?: return SpecialNames.NO_NAME_PROVIDED
        return Name.identifier(JvmAbi.getterName(ktPropertyName))
    }