.groupBy { it.take(3) }
            .toSortedMap()
        val latests = buildList {
            versionsByMinor.entries.forEachIndexed { idx, entry ->
                add(entry.value.lastOrNull { !it.contains("-") })
                if (idx < versionsByMinor.size - 1) {
                    add(entry.value.first())
                } else {
                    add(entry.value.firstOrNull { !it.contains("-") })

   * The type hint for the current object. Used to pick adapters based on other fields, such as
   * in extensions which have different types depending on their extension ID.
   */
  var typeHint: Any?
    get() = typeHintStack.lastOrNull()
    set(value) {
      typeHintStack[typeHintStack.size - 1] = value
    }

  /** Names leading to the current location in the ASN.1 document. */
  private val path = mutableListOf<String>()

  /**

        if (assignment.operationToken !in KtTokens.ALL_ASSIGNMENTS) return null
        if (assignment.left != expression) return null
        val setTargetParameterType = fir.argumentsToSubstitutedValueParameters()?.values?.lastOrNull()?.substitutedType ?: return null
        return setTargetParameterType.asKtType()
    }

    private data class SubstitutedValueParameter(val parameter: FirValueParameter, val substitutedType: ConeKotlinType)

                    return kotlinType?.toKtNonErrorType(analysisContext)
                }
            }

            is KtBlockExpression -> {
                if (expression == parentExpression.statements.lastOrNull()) {
                    val functionLiteral = parentExpression.parent as? KtFunctionLiteral
                    if (functionLiteral != null) {

   * The type hint for the current object. Used to pick adapters based on other fields, such as
   * in extensions which have different types depending on their extension ID.
   */
  var typeHint: Any?
    get() = typeHintStack.lastOrNull()
    set(value) {
      typeHintStack[typeHintStack.size - 1] = value
    }

  /** Names leading to the current location in the ASN.1 document. */
  private val path = mutableListOf<String>()

                false

            // The last expression of a block is considered used iff the block itself is used.
            is KtBlockExpression ->
                parent.statements.lastOrNull() == child && isUsed(parent)

            // Destructuring declarations use their initializer.
            is KtDestructuringDeclaration ->
                parent.initializer == child

        for (i in 1..<statements.size) {
            require(statements[i].parent == parent)
        }

        val firContainer = collectUseSiteContainers(parent, firResolveSession)?.lastOrNull()
        if (firContainer != null) {
            firContainer.lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)
            return firContainer
        }

        return parent.parentsWithSelf

        // The last argument of `set` is the new value to be set. This value should be a call to the respective `plus`, `minus`,
        // `times`, `div`, or `rem` function.
        val operationCall = fir.arguments.lastOrNull() as? FirFunctionCall ?: return null

        // The explicit receiver in this case is a synthetic FirFunctionCall to `get`, which does not have a corresponding PSI. So
        // we use the `leftOperandPsi` as the supplement.

        val implicitReceivers = towerContextProvider.getClosestAvailableParentContext(psi)?.implicitReceiverStack ?: return false
        val closestImplicitReceiver = implicitReceivers.lastOrNull() ?: return false

        return boundSymbol == closestImplicitReceiver.boundSymbol
    }

    private fun canBePossibleToDropLabel(thisReference: FirThisReference): Boolean {