== 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:
  1 <START>
    v(b: Boolean)
    magic[FAKE_INITIALIZER](b: Boolean) -> <v0>
    w(b|<v0>)
  2 mark({ var u: String if (b) { u = "s" } doSmth(u) var r: String if (b) { r = "s" } else { r = "t" } doSmth(r) })
    v(var u: String)
    mark(if (b) { u = "s" })
    r(b) -> <v1>
    jf(L2|<v1>)                                                                                                         NEXT:[read (Unit), mark({ u = "s" })]
  3 mark({ u = "s" })
    mark("s")
    r("s") -> <v2>
    w(u|<v2>)
  2 jmp(L3)                                                                                                             NEXT:[merge(if (b) { u = "s" }|!<v3>) -> <v4>]
L2 [else branch]:
    read (Unit)                                                                                                         PREV:[jf(L2|<v1>)]
L3 ['if' expression result]:
    merge(if (b) { u = "s" }|!<v3>) -> <v4>                                                                             PREV:[jmp(L3), read (Unit)]
    r(u) -> <v5>
    mark(doSmth(u))
    call(doSmth(u), doSmth|<v5>) -> <v6>
    v(var r: String)
    mark(if (b) { r = "s" } else { r = "t" })
    r(b) -> <v7>
    jf(L4|<v7>)                                                                                                         NEXT:[mark({ r = "t" }), mark({ r = "s" })]
  3 mark({ r = "s" })
    mark("s")
    r("s") -> <v8>
    w(r|<v8>)
  2 jmp(L5)                                                                                                             NEXT:[merge(if (b) { r = "s" } else { r = "t" }|!<v9>, !<v11>) -> <v12>]
L4 [else branch]:
  3 mark({ r = "t" })                                                                                                   PREV:[jf(L4|<v7>)]
    mark("t")
    r("t") -> <v10>
    w(r|<v10>)
L5 ['if' expression result]:
  2 merge(if (b) { r = "s" } else { r = "t" }|!<v9>, !<v11>) -> <v12>                                                   PREV:[jmp(L5), w(r|<v10>)]
    r(r) -> <v13>
    mark(doSmth(r))
    call(doSmth(r), doSmth|<v13>) -> <v14>
L1:
  1 <END>                                                                                                               NEXT:[<SINK>]
error:
    <ERROR>                                                                                                             PREV:[]
sink:
    <SINK>                                                                                                              PREV:[<ERROR>, <END>]
=====================
== t2 ==
fun t2(b: Boolean) {
    val i = 3
    if (b) {
        return;
    }
    doSmth(i)
    if (i is Int) {
        return;
    }
}
---------------------
L0:
  1 <START>
    v(b: Boolean)
    magic[FAKE_INITIALIZER](b: Boolean) -> <v0>
    w(b|<v0>)
  2 mark({ val i = 3 if (b) { return; } doSmth(i) if (i is Int) { return; } })
    v(val i = 3)
    r(3) -> <v1>
    w(i|<v1>)
    mark(if (b) { return; })
    r(b) -> <v2>
    jf(L2|<v2>)                                                                   NEXT:[read (Unit), mark({ return; })]
  3 mark({ return; })
    ret L1                                                                        NEXT:[<END>]
- 2 jmp(L3)                                                                       NEXT:[merge(if (b) { return; }|!<v3>) -> <v4>]                                       PREV:[]
L2 [else branch]:
    read (Unit)                                                                   PREV:[jf(L2|<v2>)]
L3 ['if' expression result]:
    merge(if (b) { return; }|!<v3>) -> <v4>
    r(i) -> <v5>
    mark(doSmth(i))
    call(doSmth(i), doSmth|<v5>) -> <v6>
    mark(if (i is Int) { return; })
    mark(i is Int)
    r(i) -> <v7>
    magic[IS](i is Int|<v7>) -> <v8>
    jf(L4|<v8>)                                                                   NEXT:[read (Unit), mark({ return; })]
  3 mark({ return; })
    ret L1                                                                        NEXT:[<END>]
- 2 jmp(L5)                                                                       NEXT:[merge(if (i is Int) { return; }|!<v9>) -> <v10>]                               PREV:[]
L4 [else branch]:
    read (Unit)                                                                   PREV:[jf(L4|<v8>)]
L5 ['if' expression result]:
    merge(if (i is Int) { return; }|!<v9>) -> <v10>
L1:
  1 <END>                                                                         NEXT:[<SINK>]                                                                        PREV:[ret L1, ret L1, merge(if (i is Int) { return; }|!<v9>) -> <v10>]
error:
    <ERROR>                                                                       PREV:[]
sink:
    <SINK>                                                                        PREV:[<ERROR>, <END>]
=====================
== doSmth ==
fun doSmth(s: String) {}
---------------------
L0:
  1 <START>
    v(s: String)
    magic[FAKE_INITIALIZER](s: String) -> <v0>
    w(s|<v0>)
  2 mark({})
    read (Unit)
L1:
  1 <END>                                         NEXT:[<SINK>]
error:
    <ERROR>                                       PREV:[]
sink:
    <SINK>                                        PREV:[<ERROR>, <END>]
=====================