== Test ==
class Test {
  var x : Int;
}
---------------------
L0:
  1 <START>
    v(var x : Int;)
L1:
    <END>              NEXT:[<SINK>]
error:
    <ERROR>            PREV:[]
sink:
    <SINK>             PREV:[<ERROR>, <END>]
=====================
== assignments ==
fun assignments() : Unit {
    var x = 1
    x = 2
    x += 2

    x = if (true) 1 else 2

    val y = true && false
    val z = false && true

    val t = Test();
    t.x = 1
    t.x += 1
}
---------------------
L0:
  1 <START>
  2 mark({ var x = 1 x = 2 x += 2 x = if (true) 1 else 2 val y = true && false val z = false && true val t = Test(); t.x = 1 t.x += 1 })
    v(var x = 1)
    r(1) -> <v0>
    w(x|<v0>)
    r(2) -> <v1>
    w(x|<v1>)
    r(x) -> <v2>
    r(2) -> <v3>
    mark(x += 2)
    call(x += 2, plus|<v2>, <v3>) -> <v4>
    w(x|<v4>)
    mark(if (true) 1 else 2)
    r(true) -> <v5>
    jf(L2|<v5>)                                                                                                                             NEXT:[r(2) -> <v7>, r(1) -> <v6>]
    r(1) -> <v6>
    jmp(L3)                                                                                                                                 NEXT:[merge(if (true) 1 else 2|<v6>, <v7>) -> <v8>]
L2 [else branch]:
    r(2) -> <v7>                                                                                                                            PREV:[jf(L2|<v5>)]
L3 ['if' expression result]:
    merge(if (true) 1 else 2|<v6>, <v7>) -> <v8>                                                                                            PREV:[jmp(L3), r(2) -> <v7>]
    w(x|<v8>)
    v(val y = true && false)
    r(true) -> <v9>
    jf(L4|<v9>)                                                                                                                             NEXT:[magic[AND](true && false|<v9>, <v10>) -> <v11>, r(false) -> <v10>]
    r(false) -> <v10>
L4 [result of boolean operation]:
    magic[AND](true && false|<v9>, <v10>) -> <v11>                                                                                          PREV:[jf(L4|<v9>), r(false) -> <v10>]
    w(y|<v11>)
    v(val z = false && true)
    r(false) -> <v12>
    jf(L5|<v12>)                                                                                                                            NEXT:[magic[AND](false && true|<v12>, <v13>) -> <v14>, r(true) -> <v13>]
    r(true) -> <v13>
L5 [result of boolean operation]:
    magic[AND](false && true|<v12>, <v13>) -> <v14>                                                                                         PREV:[jf(L5|<v12>), r(true) -> <v13>]
    w(z|<v14>)
    v(val t = Test())
    mark(Test())
    call(Test(), <init>) -> <v15>
    w(t|<v15>)
    r(t) -> <v16>
    r(1) -> <v17>
    w(t.x|<v16>, <v17>)
    mark(t.x)
    r(t) -> <v18>
    r(x|<v18>) -> <v19>
    r(1) -> <v20>
    mark(t.x += 1)
    call(t.x += 1, plus|<v19>, <v20>) -> <v21>
    w(t.x|<v18>, <v21>)
L1:
  1 <END>                                                                                                                                   NEXT:[<SINK>]
error:
    <ERROR>                                                                                                                                 PREV:[]
sink:
    <SINK>                                                                                                                                  PREV:[<ERROR>, <END>]
=====================