FILE: lambda.kt
    public final? data class Tuple : R|kotlin/Any| {
        public? [ContainingClassKey=Tuple] constructor([CorrespondingProperty=/Tuple.x] x: Int, [CorrespondingProperty=/Tuple.y] y: Int): R|Tuple| {
            super<R|kotlin/Any|>()
        }

        public? final? [ComponentFunctionSymbolKey=/Tuple.component1, IsFromPrimaryConstructor=true] val x: Int = R|<local>/x|
            public? [ContainingClassKey=Tuple] get(): Int

        public? final? [ComponentFunctionSymbolKey=/Tuple.component2, IsFromPrimaryConstructor=true] val y: Int = R|<local>/y|
            public? [ContainingClassKey=Tuple] get(): Int

        public? final operator fun component1(): Int

        public? final operator fun component2(): Int

        public? final fun copy(x: Int = this@R|/Tuple|.R|/Tuple.x|, y: Int = this@R|/Tuple|.R|/Tuple.y|): R|Tuple|

    }
    public? final? inline fun use(f: ( (Tuple) -> Int )): <implicit> {
        ^use f#(Tuple#(IntegerLiteral(1), IntegerLiteral(2)))
    }
    public? final? fun foo(): Int {
        lval l1: <implicit> = fun <implicit>.<anonymous>(t: Tuple): <implicit> <inline=Unknown>  {
            lval x: <implicit> = t#.x#
            lval y: <implicit> = t#.y#
            x#.plus#(y#)
        }

        use#(<L> = use@fun <implicit>.<anonymous>(<destruct>: <implicit>): <implicit> <inline=Unknown>  {
            lval x: <implicit> = R|<local>/<destruct>|.component1#()
            lval y: <implicit> = R|<local>/<destruct>|.component2#()
             {
                x#.plus#(y#)
            }

        }
        )
        ^foo use#(<L> = use@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
            when () {
                ==(it#.x#, IntegerLiteral(0)) ->  {
                    ^foo IntegerLiteral(0)
                }
            }

            ^@use it#.y#
        }
        )
    }
    public? final? fun bar(): Int {
        ^bar use#(<L> = lambda@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
            when () {
                ==(it#.x#, IntegerLiteral(0)) ->  {
                    ^bar IntegerLiteral(0)
                }
            }

            ^@lambda it#.y#
        }
        )
    }
    public? final? fun test(list: List<Int>): R|kotlin/Unit| {
        lval map: <implicit> = mutableMapOf#<Int, String>()
        list#.forEach#(<L> = forEach@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
            +=(map#.getOrPut#(it#, getOrPut@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
                mutableListOf#()
            }
            ), String())
        }
        )
    }
    public? final? val simple: <implicit> = fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
        ^ Unit
    }

        public? get(): <implicit>
    public? final? val simpleWithArrow: <implicit> = fun <implicit>.<anonymous>(<no-parameters>)(): <implicit> <inline=Unknown>  {
        ^ Unit
    }

        public? get(): <implicit>
    public? final? val another: <implicit> = fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
        IntegerLiteral(42)
    }

        public? get(): <implicit>
