@begin: scope:[]  from
  [0] phi()
  to:@1
@1: scope:[]  from @begin
  [1] phi()
  [2] call main 
  to:@end
@end: scope:[]  from @1
  [3] phi()

(signed word()) main()
main: scope:[main]  from @1
  [4] *((byte**)(const struct fileentry*) files) ← (byte*) 16384
  [5] *(*((byte**)(const struct fileentry*) files) + (byte) 3) ← (byte) $aa
  [6] (byte*~) main::$0 ← *((byte**)(const struct fileentry*) files)
  [7] *((byte*~) main::$0 + (byte) 4) ← (byte) $cc
  [8] call print_cls 
  to:main::@1
main::@1: scope:[main]  from main
  [9] phi()
  [10] call print_str 
  to:main::@2
main::@2: scope:[main]  from main::@1
  [11] (byte) print_byte::b#0 ← *((byte*) 0)
  [12] call print_byte 
  to:main::@3
main::@3: scope:[main]  from main::@2
  [13] phi()
  [14] call print_ln 
  to:main::@4
main::@4: scope:[main]  from main::@3
  [15] (byte*) print_char_cursor#47 ← (byte*) print_line_cursor#1
  [16] call print_str 
  to:main::@5
main::@5: scope:[main]  from main::@4
  [17] (byte) print_byte::b#1 ← *((byte*) 16388)
  [18] call print_byte 
  to:main::@6
main::@6: scope:[main]  from main::@5
  [19] phi()
  [20] call print_ln 
  to:main::@return
main::@return: scope:[main]  from main::@6
  [21] return 
  to:@return

(void()) print_ln()
print_ln: scope:[print_ln]  from main::@3 main::@6
  [22] (byte*) print_line_cursor#19 ← phi( main::@3/(byte*) 1024 main::@6/(byte*) print_line_cursor#1 )
  to:print_ln::@1
print_ln::@1: scope:[print_ln]  from print_ln print_ln::@1
  [23] (byte*) print_line_cursor#10 ← phi( print_ln/(byte*) print_line_cursor#19 print_ln::@1/(byte*) print_line_cursor#1 )
  [24] (byte*) print_line_cursor#1 ← (byte*) print_line_cursor#10 + (byte) $28
  [25] if((byte*) print_line_cursor#1<(byte*) print_char_cursor#29) goto print_ln::@1
  to:print_ln::@return
print_ln::@return: scope:[print_ln]  from print_ln::@1
  [26] return 
  to:@return

(void()) print_byte((byte) print_byte::b)
print_byte: scope:[print_byte]  from main::@2 main::@5
  [27] (byte) print_byte::b#2 ← phi( main::@2/(byte) print_byte::b#0 main::@5/(byte) print_byte::b#1 )
  [28] (byte~) print_byte::$0 ← (byte) print_byte::b#2 >> (byte) 4
  [29] (byte) print_char::ch#0 ← *((const byte*) print_hextab + (byte~) print_byte::$0)
  [30] call print_char 
  to:print_byte::@1
print_byte::@1: scope:[print_byte]  from print_byte
  [31] (byte~) print_byte::$2 ← (byte) print_byte::b#2 & (byte) $f
  [32] (byte) print_char::ch#1 ← *((const byte*) print_hextab + (byte~) print_byte::$2)
  [33] call print_char 
  to:print_byte::@return
print_byte::@return: scope:[print_byte]  from print_byte::@1
  [34] return 
  to:@return

(void()) print_char((byte) print_char::ch)
print_char: scope:[print_char]  from print_byte print_byte::@1
  [35] (byte*) print_char_cursor#28 ← phi( print_byte/(byte*) print_char_cursor#2 print_byte::@1/(byte*) print_char_cursor#29 )
  [35] (byte) print_char::ch#2 ← phi( print_byte/(byte) print_char::ch#0 print_byte::@1/(byte) print_char::ch#1 )
  [36] *((byte*) print_char_cursor#28) ← (byte) print_char::ch#2
  [37] (byte*) print_char_cursor#29 ← ++ (byte*) print_char_cursor#28
  to:print_char::@return
print_char::@return: scope:[print_char]  from print_char
  [38] return 
  to:@return

(void()) print_str((byte*) print_str::str)
print_str: scope:[print_str]  from main::@1 main::@4
  [39] (byte*) print_char_cursor#45 ← phi( main::@1/(byte*) 1024 main::@4/(byte*) print_char_cursor#47 )
  [39] (byte*) print_str::str#5 ← phi( main::@1/(const byte*) main::str main::@4/(const byte*) main::str1 )
  to:print_str::@1
print_str::@1: scope:[print_str]  from print_str print_str::@2
  [40] (byte*) print_char_cursor#2 ← phi( print_str/(byte*) print_char_cursor#45 print_str::@2/(byte*) print_char_cursor#1 )
  [40] (byte*) print_str::str#3 ← phi( print_str/(byte*) print_str::str#5 print_str::@2/(byte*) print_str::str#0 )
  [41] if((byte) 0!=*((byte*) print_str::str#3)) goto print_str::@2
  to:print_str::@return
print_str::@return: scope:[print_str]  from print_str::@1
  [42] return 
  to:@return
print_str::@2: scope:[print_str]  from print_str::@1
  [43] *((byte*) print_char_cursor#2) ← *((byte*) print_str::str#3)
  [44] (byte*) print_char_cursor#1 ← ++ (byte*) print_char_cursor#2
  [45] (byte*) print_str::str#0 ← ++ (byte*) print_str::str#3
  to:print_str::@1

(void()) print_cls()
print_cls: scope:[print_cls]  from main
  [46] phi()
  [47] call memset 
  to:print_cls::@return
print_cls::@return: scope:[print_cls]  from print_cls
  [48] return 
  to:@return

(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num)
memset: scope:[memset]  from print_cls
  [49] phi()
  to:memset::@1
memset::@1: scope:[memset]  from memset memset::@2
  [50] (byte*) memset::dst#2 ← phi( memset/(byte*)(const void*) memset::str#0 memset::@2/(byte*) memset::dst#1 )
  [51] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2
  to:memset::@return
memset::@return: scope:[memset]  from memset::@1
  [52] return 
  to:@return
memset::@2: scope:[memset]  from memset::@1
  [53] *((byte*) memset::dst#2) ← (const byte) memset::c#0
  [54] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2
  to:memset::@1
