@begin: scope:[]  from
  [0] phi()
  to:@24
@24: scope:[]  from @begin
  [1] phi()
  [2] call main 
  to:@end
@end: scope:[]  from @24
  [3] phi()
main: scope:[main]  from @24
  [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/(byte/signed byte/word/signed word/dword/signed dword) 0 test_sbytes::@1/(byte/signed byte/word/signed word/dword/signed dword) 2 test_sbytes::@2/-(byte/signed byte/word/signed word/dword/signed dword) 2 test_sbytes::@3/(byte/signed byte/word/signed word/dword/signed dword) 2 test_sbytes::@4/(byte/signed byte/word/signed word/dword/signed dword) 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#87 ← (byte*) print_line_cursor#1
  [25] call print_str 
  to:assert_sbyte::@5
assert_sbyte::@5: scope:[assert_sbyte]  from assert_sbyte
  [26] phi()
  [27] call print_str 
  to:assert_sbyte::@6
assert_sbyte::@6: scope:[assert_sbyte]  from assert_sbyte::@5
  [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::@6
  [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::@6
  [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::@5 assert_sbyte assert_sbyte::@1 assert_sbyte::@3 assert_sbyte::@5
  [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::@5/(byte*) print_char_cursor#2 assert_sbyte/(byte*~) print_char_cursor#87 assert_sbyte::@1/(byte*) print_char_cursor#2 assert_sbyte::@3/(byte*) print_char_cursor#2 assert_sbyte::@5/(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::@5/(const string) str assert_sbyte/(byte*) print_str::str#5 assert_sbyte::@1/(const string) str1 assert_sbyte::@3/(const string) str2 assert_sbyte::@5/(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*) print_str::str#10)!=(byte) '@') 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/signed byte/word/signed word/dword/signed dword) 40
  [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#93 ← (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#94 ← (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*))(word/signed word/dword/signed dword) 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/signed byte/word/signed word/dword/signed dword) 0 test_bytes::@1/(byte/signed byte/word/signed word/dword/signed dword) 2 test_bytes::@2/(byte/word/signed word/dword/signed dword) 254 )
  [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*))(word/signed word/dword/signed dword) 1024 test_bytes::@1/(byte*~) print_char_cursor#93 test_bytes::@2/(byte*~) print_char_cursor#94 )
  [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::@5
assert_byte::@5: scope:[assert_byte]  from assert_byte
  [58] phi()
  [59] call print_str 
  to:assert_byte::@6
assert_byte::@6: scope:[assert_byte]  from assert_byte::@5
  [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::@6
  [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::@6
  [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()
  to:print_cls::@1
print_cls::@1: scope:[print_cls]  from print_cls print_cls::@1
  [69] (byte*) print_cls::sc#2 ← phi( print_cls/((byte*))(word/signed word/dword/signed dword) 1024 print_cls::@1/(byte*) print_cls::sc#1 )
  [70] *((byte*) print_cls::sc#2) ← (byte) ' '
  [71] (byte*) print_cls::sc#1 ← ++ (byte*) print_cls::sc#2
  [72] if((byte*) print_cls::sc#1!=((byte*))(word/signed word/dword/signed dword) 1024+(word/signed word/dword/signed dword) 1000) goto print_cls::@1
  to:print_cls::@return
print_cls::@return: scope:[print_cls]  from print_cls::@1
  [73] return 
  to:@return
