== t1 ==
fun t1(b: Boolean) {
    var u: String
    if (b) {
        u = "s"
    }
    doSmth(u)

    var r: String
    if (b) {
        r = "s"
    }
    else {
        r = "t"
    }
    doSmth(r)
}
---------------------
l0:
    <START>             NEXT:[v(b: Boolean)]          PREV:[]
    v(b: Boolean)       NEXT:[w(b)]                   PREV:[<START>]
    w(b)                NEXT:[v(var u: String)]       PREV:[v(b: Boolean)]
    v(var u: String)    NEXT:[r(b)]                   PREV:[w(b)]
    r(b)                NEXT:[jf(l2)]                 PREV:[v(var u: String)]
    jf(l2)              NEXT:[read (Unit), r("s")]    PREV:[r(b)]
    r("s")              NEXT:[w(u)]                   PREV:[jf(l2)]
    w(u)                NEXT:[jmp(l3)]                PREV:[r("s")]
    jmp(l3)             NEXT:[r(u)]                   PREV:[w(u)]
l2:
    read (Unit)         NEXT:[r(u)]                   PREV:[jf(l2)]
l3:
    r(u)                NEXT:[r(doSmth)]              PREV:[jmp(l3), read (Unit)]
    r(doSmth)           NEXT:[r(doSmth(u))]           PREV:[r(u)]
    r(doSmth(u))        NEXT:[v(var r: String)]       PREV:[r(doSmth)]
    v(var r: String)    NEXT:[r(b)]                   PREV:[r(doSmth(u))]
    r(b)                NEXT:[jf(l4)]                 PREV:[v(var r: String)]
    jf(l4)              NEXT:[r("t"), r("s")]         PREV:[r(b)]
    r("s")              NEXT:[w(r)]                   PREV:[jf(l4)]
    w(r)                NEXT:[jmp(l5)]                PREV:[r("s")]
    jmp(l5)             NEXT:[r(r)]                   PREV:[w(r)]
l4:
    r("t")              NEXT:[w(r)]                   PREV:[jf(l4)]
    w(r)                NEXT:[r(r)]                   PREV:[r("t")]
l5:
    r(r)                NEXT:[r(doSmth)]              PREV:[jmp(l5), w(r)]
    r(doSmth)           NEXT:[r(doSmth(r))]           PREV:[r(r)]
    r(doSmth(r))        NEXT:[<END>]                  PREV:[r(doSmth)]
l1:
    <END>               NEXT:[<SINK>]                 PREV:[r(doSmth(r))]
error:
    <ERROR>             NEXT:[]                       PREV:[]
sink:
    <SINK>              NEXT:[]                       PREV:[<END>]
=====================
== t2 ==
fun t2(b: Boolean) {
    val i = 3
    if (b) {
        return;
    }
    doSmth(i)
    if (i is Int) {
        return;
    }
}
---------------------
l0:
    <START>          NEXT:[v(b: Boolean)]          PREV:[]
    v(b: Boolean)    NEXT:[w(b)]                   PREV:[<START>]
    w(b)             NEXT:[v(val i = 3)]           PREV:[v(b: Boolean)]
    v(val i = 3)     NEXT:[r(3)]                   PREV:[w(b)]
    r(3)             NEXT:[w(i)]                   PREV:[v(val i = 3)]
    w(i)             NEXT:[r(b)]                   PREV:[r(3)]
    r(b)             NEXT:[jf(l2)]                 PREV:[w(i)]
    jf(l2)           NEXT:[read (Unit), ret l1]    PREV:[r(b)]
    ret l1           NEXT:[<END>]                  PREV:[jf(l2)]
*   jmp(l3)          NEXT:[r(i)]                   PREV:[]
l2:
    read (Unit)      NEXT:[r(i)]                   PREV:[jf(l2)]
l3:
    r(i)             NEXT:[r(doSmth)]              PREV:[read (Unit)]
    r(doSmth)        NEXT:[r(doSmth(i))]           PREV:[r(i)]
    r(doSmth(i))     NEXT:[r(i)]                   PREV:[r(doSmth)]
    r(i)             NEXT:[r(i is Int)]            PREV:[r(doSmth(i))]
    r(i is Int)      NEXT:[jf(l4)]                 PREV:[r(i)]
    jf(l4)           NEXT:[read (Unit), ret l1]    PREV:[r(i is Int)]
    ret l1           NEXT:[<END>]                  PREV:[jf(l4)]
*   jmp(l5)          NEXT:[<END>]                  PREV:[]
l4:
    read (Unit)      NEXT:[<END>]                  PREV:[jf(l4)]
l1:
l5:
    <END>            NEXT:[<SINK>]                 PREV:[ret l1, ret l1, read (Unit)]
error:
    <ERROR>          NEXT:[]                       PREV:[]
sink:
    <SINK>           NEXT:[]                       PREV:[<END>]
=====================
== doSmth ==
fun doSmth(s: String) {}
---------------------
l0:
    <START>         NEXT:[v(s: String)]    PREV:[]
    v(s: String)    NEXT:[w(s)]            PREV:[<START>]
    w(s)            NEXT:[read (Unit)]     PREV:[v(s: String)]
    read (Unit)     NEXT:[<END>]           PREV:[w(s)]
l1:
    <END>           NEXT:[<SINK>]          PREV:[read (Unit)]
error:
    <ERROR>         NEXT:[]                PREV:[]
sink:
    <SINK>          NEXT:[]                PREV:[<END>]
=====================