(LoweredMove [s] dst src mem)

// Lowering Zero instructions
(Zero [0] _ mem) => mem
(Zero [1] destptr mem) => (I64Store8 destptr (I64Const [0]) mem)
(Zero [2] destptr mem) => (I64Store16 destptr (I64Const [0]) mem)
(Zero [4] destptr mem) => (I64Store32 destptr (I64Const [0]) mem)
(Zero [8] destptr mem) => (I64Store destptr (I64Const [0]) mem)

(Zero [3] destptr mem) =>
	(I64Store8 [2] destptr (I64Const [0])

     */
    private
    fun <C : Closeable, T : Closeable> safeWrap(innerSupplier: () -> C, unsafeWrapper: (C) -> T): T {
        // fine if we fail here
        val innerCloseable = innerSupplier()
        val outerCloseable = try {
            // but if we fail here, we need to ensure we close
            // the inner closeable, or else it will leak
            unsafeWrapper(innerCloseable)
        } catch (e: Throwable) {

            val firStatement = firLeaf.statements[0]
            if (firStatement is FirExpression && firStatement.resolvedType == firLeaf.resolvedType) {
                // Trivial blocks might not appear in the CFG, so here we include their content
                return firStatement
            }
        }

        return firLeaf
    }

    private fun computeCommonParent(statements: List<KtElement>): FirElement {

            if (hasParentPsi(symbol)) {
                // getSymbol(ClassId) returns a symbol from the original file, so here we avoid using it
                return getContainingDeclarationByPsi(symbol)
            }
        }

        when (symbol) {
            is KaLocalVariableSymbol,
            is KaAnonymousFunctionSymbol,

    }

    @Test
    fun `keeps empty lines in line number counting`() {
        val results = parse(
            """
            import a.b.c

            // start of actual script content is here -- imports are counted separately because of the workarounds

            f(x)


            a = 1
            """.trimIndent()
        )

        val expected = """

            // as parentheses for the purpose of this analysis.
            is KtContainerNode ->
                // !!!!CAUTION!!!! Not `parentUse(parent.parent, _parent_)`
                // Here we assume the parent (e.g. If condition) statement
                // ignores the ContainerNode when accessing child
                doesParentUseChild(parent.parent, child)

        // If an element in the array has the same type as the containing array, it's a spread component that needs
        // to be expanded here. (It should have the array element type instead.)
        (constantValue as ArrayValue).value.expandArrayAnnotationValue(containingArrayType, analysisContext)
    } else {

could even be mouse-clicks or menu items--whatever suits your program.

You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here is a sample; alter the names:

    Yoyodyne, Inc., hereby disclaims all copyright interest in the
    program `Gnomovision' (which makes passes at compilers) written by
    James Hacker.

        // When you call a method from Java with type arguments, in FIR they are currently represented as flexible types.
        // TODO Consider handling other non-ConeLookupTagBasedType types here (see KT-66418)
        val type = getDeclaredType()?.lowerBoundIfFlexible() as? ConeLookupTagBasedType

        return type?.toTargetSymbol(session, symbolBuilder) ?: run {

    const val performanceTestResultsJsonName = "perf-results.json"
    const val performanceTestResultsJson = "performance-tests/$performanceTestResultsJsonName"

    // Android Studio Jellyfish 2023.3.1
    // Find all references here https://developer.android.com/studio/archive
    // Update verification-metadata.xml
    const val performanceTestAndroidStudioVersion = "2023.3.1.18"
    val performanceTestAndroidStudioJvmArgs = listOf("-Xms256m", "-Xmx4096m")
}