== lazyBooleans ==
fun lazyBooleans(a : Boolean, b : Boolean) : Unit {
    if (a) {
      1
    }
    else {
      2
    }
    3
    if (a && b) 5 else 6
    7
    if (a || b) 8 else 9
    10
    if (a) 11
    12
    if (a) else 13
    14
}
---------------------
L0:
  1 <START>
    v(a : Boolean)
    magic[FAKE_INITIALIZER](a : Boolean) -> <v0>
    w(a|<v0>)
    v(b : Boolean)
    magic[FAKE_INITIALIZER](b : Boolean) -> <v1>
    w(b|<v1>)
  2 mark({ if (a) { 1 } else { 2 } 3 if (a && b) 5 else 6 7 if (a || b) 8 else 9 10 if (a) 11 12 if (a) else 13 14 })
    mark(if (a) { 1 } else { 2 })
    r(a) -> <v2>
    jf(L2|<v2>)                                                                                                          NEXT:[mark({ 2 }), mark({ 1 })]
  3 mark({ 1 })
    r(1) -> <v3>
  2 jmp(L3)                                                                                                              NEXT:[merge(if (a) { 1 } else { 2 }|<v3>, <v4>) -> <v5>]
L2 [else branch]:
  3 mark({ 2 })                                                                                                          PREV:[jf(L2|<v2>)]
    r(2) -> <v4>
L3 ['if' expression result]:
  2 merge(if (a) { 1 } else { 2 }|<v3>, <v4>) -> <v5>                                                                    PREV:[jmp(L3), r(2) -> <v4>]
    r(3) -> <v6>
    mark(if (a && b) 5 else 6)
    r(a) -> <v7>
    jf(L4|<v7>)                                                                                                          NEXT:[magic[AND](a && b|<v7>, <v8>) -> <v9>, r(b) -> <v8>]
    r(b) -> <v8>
L4 [result of boolean operation]:
    magic[AND](a && b|<v7>, <v8>) -> <v9>                                                                                PREV:[jf(L4|<v7>), r(b) -> <v8>]
    jf(L5|<v9>)                                                                                                          NEXT:[r(6) -> <v11>, r(5) -> <v10>]
    r(5) -> <v10>
    jmp(L6)                                                                                                              NEXT:[merge(if (a && b) 5 else 6|<v10>, <v11>) -> <v12>]
L5 [else branch]:
    r(6) -> <v11>                                                                                                        PREV:[jf(L5|<v9>)]
L6 ['if' expression result]:
    merge(if (a && b) 5 else 6|<v10>, <v11>) -> <v12>                                                                    PREV:[jmp(L6), r(6) -> <v11>]
    r(7) -> <v13>
    mark(if (a || b) 8 else 9)
    r(a) -> <v14>
    jt(L7|<v14>)                                                                                                         NEXT:[r(b) -> <v15>, magic[OR](a || b|<v14>, <v15>) -> <v16>]
    r(b) -> <v15>
L7 [result of boolean operation]:
    magic[OR](a || b|<v14>, <v15>) -> <v16>                                                                              PREV:[jt(L7|<v14>), r(b) -> <v15>]
    jf(L8|<v16>)                                                                                                         NEXT:[r(9) -> <v18>, r(8) -> <v17>]
    r(8) -> <v17>
    jmp(L9)                                                                                                              NEXT:[merge(if (a || b) 8 else 9|<v17>, <v18>) -> <v19>]
L8 [else branch]:
    r(9) -> <v18>                                                                                                        PREV:[jf(L8|<v16>)]
L9 ['if' expression result]:
    merge(if (a || b) 8 else 9|<v17>, <v18>) -> <v19>                                                                    PREV:[jmp(L9), r(9) -> <v18>]
    r(10) -> <v20>
    mark(if (a) 11)
    r(a) -> <v21>
    jf(L10|<v21>)                                                                                                        NEXT:[read (Unit), r(11) -> <v22>]
    r(11) -> <v22>
    jmp(L11)                                                                                                             NEXT:[merge(if (a) 11|<v22>) -> <v23>]
L10 [else branch]:
    read (Unit)                                                                                                          PREV:[jf(L10|<v21>)]
L11 ['if' expression result]:
    merge(if (a) 11|<v22>) -> <v23>                                                                                      PREV:[jmp(L11), read (Unit)]
    r(12) -> <v24>
    mark(if (a) else 13)
    r(a) -> <v25>
    jf(L12|<v25>)                                                                                                        NEXT:[r(13) -> <v26>, read (Unit)]
    read (Unit)
    jmp(L13)                                                                                                             NEXT:[merge(if (a) else 13|<v26>) -> <v27>]
L12 [else branch]:
    r(13) -> <v26>                                                                                                       PREV:[jf(L12|<v25>)]
L13 ['if' expression result]:
    merge(if (a) else 13|<v26>) -> <v27>                                                                                 PREV:[jmp(L13), r(13) -> <v26>]
    r(14) -> <v28>
L1:
  1 <END>                                                                                                                NEXT:[<SINK>]
error:
    <ERROR>                                                                                                              PREV:[]
sink:
    <SINK>                                                                                                               PREV:[<ERROR>, <END>]
=====================