@begin: scope:[]  from
  [0] phi()
  to:@1
@1: scope:[]  from @begin
  [1] phi()
  [2] call main 
  to:@end
@end: scope:[]  from @1
  [3] phi()
main: scope:[main]  from @1
  [4] phi()
  [5] call print_cls 
  to:main::@1
main::@1: scope:[main]  from main
  [6] *((const byte*) BGCOL#0) ← (const byte) GREEN#0
  [7] call test_bytes 
  to:main::@2
main::@2: scope:[main]  from main::@1
  [8] phi()
  [9] call test_sbytes 
  to:main::@return
main::@return: scope:[main]  from main::@2
  [10] return 
  to:@return
test_sbytes: scope:[test_sbytes]  from main::@2
  [11] phi()
  [12] call assert_sbyte 
  to:test_sbytes::@1
test_sbytes::@1: scope:[test_sbytes]  from test_sbytes
  [13] phi()
  [14] call assert_sbyte 
  to:test_sbytes::@2
test_sbytes::@2: scope:[test_sbytes]  from test_sbytes::@1
  [15] phi()
  [16] call assert_sbyte 
  to:test_sbytes::@3
test_sbytes::@3: scope:[test_sbytes]  from test_sbytes::@2
  [17] phi()
  [18] call assert_sbyte 
  to:test_sbytes::@4
test_sbytes::@4: scope:[test_sbytes]  from test_sbytes::@3
  [19] phi()
  [20] call assert_sbyte 
  to:test_sbytes::@return
test_sbytes::@return: scope:[test_sbytes]  from test_sbytes::@4
  [21] return 
  to:@return
assert_sbyte: scope:[assert_sbyte]  from test_sbytes test_sbytes::@1 test_sbytes::@2 test_sbytes::@3 test_sbytes::@4
  [22] (signed byte) assert_sbyte::c#5 ← phi( test_sbytes/(signed byte) 0 test_sbytes::@1/(signed byte) 2 test_sbytes::@2/(signed byte) -2 test_sbytes::@3/(signed byte) 2 test_sbytes::@4/(signed byte) 2 )
  [22] (signed byte) assert_sbyte::b#5 ← phi( test_sbytes/(const signed byte) test_sbytes::bb#0 test_sbytes::@1/(const signed byte) test_sbytes::bc#0 test_sbytes::@2/(const signed byte) test_sbytes::bd#0 test_sbytes::@3/(const signed byte) test_sbytes::be#0 test_sbytes::@4/(const signed byte) test_sbytes::bf#0 )
  [22] (byte*) assert_sbyte::msg#5 ← phi( test_sbytes/(const string) msg test_sbytes::@1/(const string) msg1 test_sbytes::@2/(const string) test_sbytes::msg2 test_sbytes::@3/(const string) test_sbytes::msg3 test_sbytes::@4/(const string) test_sbytes::msg4 )
  [23] (byte*) print_str::str#5 ← (byte*) assert_sbyte::msg#5
  [24] (byte*~) print_char_cursor#86 ← (byte*) print_line_cursor#1
  [25] call print_str 
  to:assert_sbyte::@4
assert_sbyte::@4: scope:[assert_sbyte]  from assert_sbyte
  [26] phi()
  [27] call print_str 
  to:assert_sbyte::@5
assert_sbyte::@5: scope:[assert_sbyte]  from assert_sbyte::@4
  [28] if((signed byte) assert_sbyte::b#5!=(signed byte) assert_sbyte::c#5) goto assert_sbyte::@1
  to:assert_sbyte::@3
assert_sbyte::@3: scope:[assert_sbyte]  from assert_sbyte::@5
  [29] phi()
  [30] call print_str 
  to:assert_sbyte::@2
assert_sbyte::@2: scope:[assert_sbyte]  from assert_sbyte::@1 assert_sbyte::@3
  [31] phi()
  [32] call print_ln 
  to:assert_sbyte::@return
assert_sbyte::@return: scope:[assert_sbyte]  from assert_sbyte::@2
  [33] return 
  to:@return
assert_sbyte::@1: scope:[assert_sbyte]  from assert_sbyte::@5
  [34] *((const byte*) BGCOL#0) ← (const byte) RED#0
  [35] call print_str 
  to:assert_sbyte::@2
print_str: scope:[print_str]  from assert_byte assert_byte::@1 assert_byte::@3 assert_byte::@4 assert_sbyte assert_sbyte::@1 assert_sbyte::@3 assert_sbyte::@4
  [36] (byte*) print_char_cursor#80 ← phi( assert_byte/(byte*) print_char_cursor#70 assert_byte::@1/(byte*) print_char_cursor#2 assert_byte::@3/(byte*) print_char_cursor#2 assert_byte::@4/(byte*) print_char_cursor#2 assert_sbyte/(byte*~) print_char_cursor#86 assert_sbyte::@1/(byte*) print_char_cursor#2 assert_sbyte::@3/(byte*) print_char_cursor#2 assert_sbyte::@4/(byte*) print_char_cursor#2 )
  [36] (byte*) print_str::str#11 ← phi( assert_byte/(byte*) print_str::str#1 assert_byte::@1/(const string) str1 assert_byte::@3/(const string) str2 assert_byte::@4/(const string) str assert_sbyte/(byte*) print_str::str#5 assert_sbyte::@1/(const string) str1 assert_sbyte::@3/(const string) str2 assert_sbyte::@4/(const string) str )
  to:print_str::@1
print_str::@1: scope:[print_str]  from print_str print_str::@2
  [37] (byte*) print_char_cursor#2 ← phi( print_str/(byte*) print_char_cursor#80 print_str::@2/(byte*) print_char_cursor#1 )
  [37] (byte*) print_str::str#10 ← phi( print_str/(byte*) print_str::str#11 print_str::@2/(byte*) print_str::str#0 )
  [38] if((byte) 0!=*((byte*) print_str::str#10)) goto print_str::@2
  to:print_str::@return
print_str::@return: scope:[print_str]  from print_str::@1
  [39] return 
  to:@return
print_str::@2: scope:[print_str]  from print_str::@1
  [40] *((byte*) print_char_cursor#2) ← *((byte*) print_str::str#10)
  [41] (byte*) print_char_cursor#1 ← ++ (byte*) print_char_cursor#2
  [42] (byte*) print_str::str#0 ← ++ (byte*) print_str::str#10
  to:print_str::@1
print_ln: scope:[print_ln]  from assert_byte::@2 assert_sbyte::@2
  [43] (byte*) print_line_cursor#47 ← phi( assert_byte::@2/(byte*) print_line_cursor#50 assert_sbyte::@2/(byte*) print_line_cursor#1 )
  to:print_ln::@1
print_ln::@1: scope:[print_ln]  from print_ln print_ln::@1
  [44] (byte*) print_line_cursor#24 ← phi( print_ln/(byte*) print_line_cursor#47 print_ln::@1/(byte*) print_line_cursor#1 )
  [45] (byte*) print_line_cursor#1 ← (byte*) print_line_cursor#24 + (byte) $28
  [46] if((byte*) print_line_cursor#1<(byte*) print_char_cursor#2) goto print_ln::@1
  to:print_ln::@return
print_ln::@return: scope:[print_ln]  from print_ln::@1
  [47] return 
  to:@return
test_bytes: scope:[test_bytes]  from main::@1
  [48] phi()
  [49] call assert_byte 
  to:test_bytes::@1
test_bytes::@1: scope:[test_bytes]  from test_bytes
  [50] (byte*~) print_char_cursor#92 ← (byte*) print_line_cursor#1
  [51] call assert_byte 
  to:test_bytes::@2
test_bytes::@2: scope:[test_bytes]  from test_bytes::@1
  [52] (byte*~) print_char_cursor#93 ← (byte*) print_line_cursor#1
  [53] call assert_byte 
  to:test_bytes::@return
test_bytes::@return: scope:[test_bytes]  from test_bytes::@2
  [54] return 
  to:@return
assert_byte: scope:[assert_byte]  from test_bytes test_bytes::@1 test_bytes::@2
  [55] (byte*) print_line_cursor#50 ← phi( test_bytes/(byte*) 1024 test_bytes::@1/(byte*) print_line_cursor#1 test_bytes::@2/(byte*) print_line_cursor#1 )
  [55] (byte) assert_byte::c#3 ← phi( test_bytes/(byte) 0 test_bytes::@1/(byte) 2 test_bytes::@2/(byte) $fe )
  [55] (byte) assert_byte::b#3 ← phi( test_bytes/(const byte) test_bytes::bb#0 test_bytes::@1/(const byte) test_bytes::bc#0 test_bytes::@2/(const byte) test_bytes::bd#0 )
  [55] (byte*) print_char_cursor#70 ← phi( test_bytes/(byte*) 1024 test_bytes::@1/(byte*~) print_char_cursor#92 test_bytes::@2/(byte*~) print_char_cursor#93 )
  [55] (byte*) assert_byte::msg#3 ← phi( test_bytes/(const string) msg test_bytes::@1/(const string) msg1 test_bytes::@2/(const string) test_bytes::msg2 )
  [56] (byte*) print_str::str#1 ← (byte*) assert_byte::msg#3
  [57] call print_str 
  to:assert_byte::@4
assert_byte::@4: scope:[assert_byte]  from assert_byte
  [58] phi()
  [59] call print_str 
  to:assert_byte::@5
assert_byte::@5: scope:[assert_byte]  from assert_byte::@4
  [60] if((byte) assert_byte::b#3!=(byte) assert_byte::c#3) goto assert_byte::@1
  to:assert_byte::@3
assert_byte::@3: scope:[assert_byte]  from assert_byte::@5
  [61] phi()
  [62] call print_str 
  to:assert_byte::@2
assert_byte::@2: scope:[assert_byte]  from assert_byte::@1 assert_byte::@3
  [63] phi()
  [64] call print_ln 
  to:assert_byte::@return
assert_byte::@return: scope:[assert_byte]  from assert_byte::@2
  [65] return 
  to:@return
assert_byte::@1: scope:[assert_byte]  from assert_byte::@5
  [66] *((const byte*) BGCOL#0) ← (const byte) RED#0
  [67] call print_str 
  to:assert_byte::@2
print_cls: scope:[print_cls]  from main
  [68] phi()
  [69] call memset 
  to:print_cls::@return
print_cls::@return: scope:[print_cls]  from print_cls
  [70] return 
  to:@return
memset: scope:[memset]  from print_cls
  [71] phi()
  to:memset::@2
memset::@2: scope:[memset]  from memset memset::@1
  [72] (byte*) memset::dst#4 ← phi( memset::@1/(byte*) memset::dst#1 memset/(byte*)(const void*) memset::str#0 )
  [73] *((byte*) memset::dst#4) ← (const byte) memset::c#0
  [74] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#4
  to:memset::@1
memset::@1: scope:[memset]  from memset::@2
  [75] if((byte*) memset::dst#1!=(const byte*) memset::end#0) goto memset::@2
  to:memset::@return
memset::@return: scope:[memset]  from memset::@1
  [76] return 
  to:@return
