== f ==
fun f(a : Boolean) : Unit {
    1
    a
    2.toLong()
    foo(a, 3)
    genfun<Any>()
    flfun {1}
    3.equals(4)

    3 equals 4

    1 + 2

    a && true
    a || false

}
---------------------
                                                                                                         <v0>: Boolean          NEW: magic[FAKE_INITIALIZER](a : Boolean) -> <v0>
1                                                                                                        <v1>: *                NEW: r(1) -> <v1>
a                                                                                                        <v2>: *                NEW: r(a) -> <v2>
2                                                                                                        <v3>: {<: Number}      NEW: r(2) -> <v3>
toLong()                                                                                                 <v4>: *                NEW: call(toLong(), toLong|<v3>) -> <v4>
2.toLong()                                                                                               <v4>: *                COPY
a                                                                                                        <v5>: Boolean          NEW: r(a) -> <v5>
3                                                                                                        <v6>: Int              NEW: r(3) -> <v6>
foo(a, 3)                                                                                                <v7>: *                NEW: call(foo(a, 3), foo|<v5>, <v6>) -> <v7>
genfun<Any>()                                                                                            <v8>: *                NEW: call(genfun<Any>(), genfun) -> <v8>
{1}                                                                                                      <v9>: {<: () -> Any}   NEW: r({1}) -> <v9>
flfun {1}                                                                                                <v10>: *               NEW: call(flfun {1}, flfun|<v9>) -> <v10>
3                                                                                                        <v11>: {<: Any}        NEW: r(3) -> <v11>
4                                                                                                        <v12>: *               NEW: r(4) -> <v12>
equals(4)                                                                                                <v13>: *               NEW: call(equals(4), equals|<v11>, <v12>) -> <v13>
3.equals(4)                                                                                              <v13>: *               COPY
3                                                                                                        <v14>: {<: Any}        NEW: r(3) -> <v14>
4                                                                                                        <v15>: *               NEW: r(4) -> <v15>
3 equals 4                                                                                               <v16>: *               NEW: call(3 equals 4, equals|<v14>, <v15>) -> <v16>
1                                                                                                        <v17>: Int             NEW: r(1) -> <v17>
2                                                                                                        <v18>: Int             NEW: r(2) -> <v18>
1 + 2                                                                                                    <v19>: *               NEW: call(1 + 2, plus|<v17>, <v18>) -> <v19>
a                                                                                                        <v20>: Boolean         NEW: r(a) -> <v20>
true                                                                                                     <v21>: Boolean         NEW: r(true) -> <v21>
a && true                                                                                                <v22>: *               NEW: magic[AND](a && true|<v20>, <v21>) -> <v22>
a                                                                                                        <v23>: Boolean         NEW: r(a) -> <v23>
false                                                                                                    <v24>: Boolean         NEW: r(false) -> <v24>
a || false                                                                                               <v25>: *               NEW: magic[OR](a || false|<v23>, <v24>) -> <v25>
{ 1 a 2.toLong() foo(a, 3) genfun<Any>() flfun {1} 3.equals(4) 3 equals 4 1 + 2 a && true a || false }   <v25>: *               COPY
=====================
== anonymous_0 ==
{1}
---------------------
1   <v0>: {<: Any}   NEW: r(1) -> <v0>
1   <v0>: {<: Any}   COPY
=====================
== foo ==
fun foo(a : Boolean, b : Int) : Unit {}
---------------------
    <v0>: Boolean   NEW: magic[FAKE_INITIALIZER](a : Boolean) -> <v0>
    <v1>: Int       NEW: magic[FAKE_INITIALIZER](b : Int) -> <v1>
=====================
== genfun ==
fun <T> genfun() : Unit {}
---------------------
=====================
== flfun ==
fun flfun(f : () -> Any) : Unit {}
---------------------
    <v0>: {<: () -> Any}   NEW: magic[FAKE_INITIALIZER](f : () -> Any) -> <v0>
=====================