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

(void()) main()
main: scope:[main]  from @1
  [4] phi()
  [5] call print_cls 
  to:main::@1
main::@1: scope:[main]  from main main::@16
  [6] (byte*) print_char_cursor#31 ← phi( main::@16/(byte*) print_line_cursor#1 main/(byte*) 1024 )
  [6] (byte*) print_line_cursor#15 ← phi( main::@16/(byte*) print_line_cursor#37 main/(byte*) 1024 )
  [6] (dword) main::dw#10 ← phi( main::@16/(dword) main::dw#1 main/(dword) $12345678 )
  [7] if((dword) main::dw#10!=(dword) $12345690) goto main::@2
  to:main::@return
main::@return: scope:[main]  from main::@1
  [8] return 
  to:@return
main::@2: scope:[main]  from main::@1
  [9] (word~) main::$3 ← > (dword) main::dw#10
  [10] (word~) main::$32 ← (word~) main::$3 + (word) $1111
  [11] (dword) main::dw2#1 ← (dword) main::dw#10 hi= (word~) main::$32
  [12] (word~) main::$6 ← < (dword) main::dw#10
  [13] (word~) main::$33 ← (word~) main::$6 + (word) $1111
  [14] (dword) main::dw2#10 ← (dword) main::dw2#1 lo= (word~) main::$33
  [15] (dword) print_dword::dw#0 ← (dword) main::dw2#10
  [16] call print_dword 
  to:main::@3
main::@3: scope:[main]  from main::@2
  [17] phi()
  [18] call print_char 
  to:main::@4
main::@4: scope:[main]  from main::@3
  [19] (word) print_word::w#2 ← > (dword) main::dw2#10
  [20] call print_word 
  to:main::@5
main::@5: scope:[main]  from main::@4
  [21] phi()
  [22] call print_char 
  to:main::@6
main::@6: scope:[main]  from main::@5
  [23] (word) print_word::w#3 ← < (dword) main::dw2#10
  [24] call print_word 
  to:main::@7
main::@7: scope:[main]  from main::@6
  [25] phi()
  [26] call print_char 
  to:main::@8
main::@8: scope:[main]  from main::@7
  [27] (word~) main::$16 ← > (dword) main::dw2#10
  [28] (byte) print_byte::b#2 ← > (word~) main::$16
  [29] call print_byte 
  to:main::@9
main::@9: scope:[main]  from main::@8
  [30] phi()
  [31] call print_char 
  to:main::@10
main::@10: scope:[main]  from main::@9
  [32] (word~) main::$20 ← > (dword) main::dw2#10
  [33] (byte) print_byte::b#3 ← < (word~) main::$20
  [34] call print_byte 
  to:main::@11
main::@11: scope:[main]  from main::@10
  [35] phi()
  [36] call print_char 
  to:main::@12
main::@12: scope:[main]  from main::@11
  [37] (word~) main::$24 ← < (dword) main::dw2#10
  [38] (byte) print_byte::b#4 ← > (word~) main::$24
  [39] call print_byte 
  to:main::@13
main::@13: scope:[main]  from main::@12
  [40] phi()
  [41] call print_char 
  to:main::@14
main::@14: scope:[main]  from main::@13
  [42] (word~) main::$28 ← < (dword) main::dw2#10
  [43] (byte) print_byte::b#5 ← < (word~) main::$28
  [44] call print_byte 
  to:main::@15
main::@15: scope:[main]  from main::@14
  [45] phi()
  [46] call print_ln 
  to:main::@16
main::@16: scope:[main]  from main::@15
  [47] (dword) main::dw#1 ← ++ (dword) main::dw#10
  [48] (byte*) print_line_cursor#37 ← (byte*) print_line_cursor#1
  to:main::@1

(void()) print_ln()
print_ln: scope:[print_ln]  from main::@15
  [49] phi()
  to:print_ln::@1
print_ln::@1: scope:[print_ln]  from print_ln print_ln::@2
  [50] (byte*) print_line_cursor#9 ← phi( print_ln/(byte*) print_line_cursor#15 print_ln::@2/(byte*) print_line_cursor#36 )
  [51] (byte*) print_line_cursor#1 ← (byte*) print_line_cursor#9 + (byte) $28
  [52] if((byte*) print_line_cursor#1<(byte*) print_char_cursor#12) goto print_ln::@2
  to:print_ln::@return
print_ln::@return: scope:[print_ln]  from print_ln::@1
  [53] return 
  to:@return
print_ln::@2: scope:[print_ln]  from print_ln::@1
  [54] (byte*) print_line_cursor#36 ← (byte*) print_line_cursor#1
  to:print_ln::@1

(void()) print_byte((byte) print_byte::b)
print_byte: scope:[print_byte]  from main::@10 main::@12 main::@14 main::@8 print_word print_word::@1
  [55] (byte*) print_char_cursor#67 ← phi( main::@8/(byte*) print_char_cursor#12 main::@10/(byte*) print_char_cursor#12 main::@12/(byte*) print_char_cursor#12 main::@14/(byte*) print_char_cursor#12 print_word/(byte*) print_char_cursor#65 print_word::@1/(byte*) print_char_cursor#12 )
  [55] (byte) print_byte::b#6 ← phi( main::@8/(byte) print_byte::b#2 main::@10/(byte) print_byte::b#3 main::@12/(byte) print_byte::b#4 main::@14/(byte) print_byte::b#5 print_word/(byte) print_byte::b#0 print_word::@1/(byte) print_byte::b#1 )
  [56] (byte~) print_byte::$0 ← (byte) print_byte::b#6 >> (byte) 4
  [57] (byte) print_char::ch#0 ← *((const byte*) print_hextab + (byte~) print_byte::$0)
  [58] call print_char 
  to:print_byte::@1
print_byte::@1: scope:[print_byte]  from print_byte
  [59] (byte~) print_byte::$2 ← (byte) print_byte::b#6 & (byte) $f
  [60] (byte) print_char::ch#1 ← *((const byte*) print_hextab + (byte~) print_byte::$2)
  [61] call print_char 
  to:print_byte::@return
print_byte::@return: scope:[print_byte]  from print_byte::@1
  [62] return 
  to:@return

(void()) print_char((byte) print_char::ch)
print_char: scope:[print_char]  from main::@11 main::@13 main::@3 main::@5 main::@7 main::@9 print_byte print_byte::@1
  [63] (byte*) print_char_cursor#44 ← phi( main::@5/(byte*) print_char_cursor#12 main::@7/(byte*) print_char_cursor#12 main::@9/(byte*) print_char_cursor#12 main::@11/(byte*) print_char_cursor#12 main::@13/(byte*) print_char_cursor#12 main::@3/(byte*) print_char_cursor#12 print_byte/(byte*) print_char_cursor#67 print_byte::@1/(byte*) print_char_cursor#12 )
  [63] (byte) print_char::ch#8 ← phi( main::@5/(byte) ' ' main::@7/(byte) ' ' main::@9/(byte) ' ' main::@11/(byte) ' ' main::@13/(byte) ' ' main::@3/(byte) ' ' print_byte/(byte) print_char::ch#0 print_byte::@1/(byte) print_char::ch#1 )
  [64] *((byte*) print_char_cursor#44) ← (byte) print_char::ch#8
  [65] (byte*) print_char_cursor#12 ← ++ (byte*) print_char_cursor#44
  to:print_char::@return
print_char::@return: scope:[print_char]  from print_char
  [66] return 
  to:@return

(void()) print_word((word) print_word::w)
print_word: scope:[print_word]  from main::@4 main::@6 print_dword print_dword::@1
  [67] (byte*) print_char_cursor#65 ← phi( main::@6/(byte*) print_char_cursor#12 main::@4/(byte*) print_char_cursor#12 print_dword/(byte*) print_char_cursor#74 print_dword::@1/(byte*) print_char_cursor#12 )
  [67] (word) print_word::w#4 ← phi( main::@6/(word) print_word::w#3 main::@4/(word) print_word::w#2 print_dword/(word) print_word::w#0 print_dword::@1/(word) print_word::w#1 )
  [68] (byte) print_byte::b#0 ← > (word) print_word::w#4
  [69] call print_byte 
  to:print_word::@1
print_word::@1: scope:[print_word]  from print_word
  [70] (byte) print_byte::b#1 ← < (word) print_word::w#4
  [71] call print_byte 
  to:print_word::@return
print_word::@return: scope:[print_word]  from print_word::@1
  [72] return 
  to:@return

(void()) print_dword((dword) print_dword::dw)
print_dword: scope:[print_dword]  from main::@2
  [73] (word) print_word::w#0 ← > (dword) print_dword::dw#0
  [74] (byte*) print_char_cursor#74 ← (byte*) print_char_cursor#31
  [75] call print_word 
  to:print_dword::@1
print_dword::@1: scope:[print_dword]  from print_dword
  [76] (word) print_word::w#1 ← < (dword) print_dword::dw#0
  [77] call print_word 
  to:print_dword::@return
print_dword::@return: scope:[print_dword]  from print_dword::@1
  [78] return 
  to:@return

(void()) print_cls()
print_cls: scope:[print_cls]  from main
  [79] phi()
  [80] call memset 
  to:print_cls::@return
print_cls::@return: scope:[print_cls]  from print_cls
  [81] return 
  to:@return

(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num)
memset: scope:[memset]  from print_cls
  [82] phi()
  to:memset::@1
memset::@1: scope:[memset]  from memset memset::@2
  [83] (byte*) memset::dst#2 ← phi( memset/(byte*)(const void*) memset::str#0 memset::@2/(byte*) memset::dst#1 )
  [84] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2
  to:memset::@return
memset::@return: scope:[memset]  from memset::@1
  [85] return 
  to:@return
memset::@2: scope:[memset]  from memset::@1
  [86] *((byte*) memset::dst#2) ← (const byte) memset::c#0
  [87] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2
  to:memset::@1
