@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
  [6] phi()
  [7] call testChar 
  to:main::@2
main::@2: scope:[main]  from main::@1
  [8] phi()
  [9] call testShort 
  to:main::@3
main::@3: scope:[main]  from main::@2
  [10] phi()
  [11] call testInt 
  to:main::@4
main::@4: scope:[main]  from main::@3
  [12] phi()
  [13] call testLong 
  to:main::@return
main::@return: scope:[main]  from main::@4
  [14] return 
  to:@return

(void()) testLong()
testLong: scope:[testLong]  from main::@4
  [15] (byte*) print_char_cursor#161 ← (byte*) print_line_cursor#1
  [16] call print_str 
  to:testLong::@1
testLong::@1: scope:[testLong]  from testLong
  [17] phi()
  [18] call print_dword 
  to:testLong::@2
testLong::@2: scope:[testLong]  from testLong::@1
  [19] phi()
  [20] call print_char 
  to:testLong::@3
testLong::@3: scope:[testLong]  from testLong::@2
  [21] phi()
  [22] call print_sdword 
  to:testLong::@4
testLong::@4: scope:[testLong]  from testLong::@3
  [23] phi()
  [24] call print_char 
  to:testLong::@5
testLong::@5: scope:[testLong]  from testLong::@4
  [25] phi()
  [26] call print_sdword 
  to:testLong::@6
testLong::@6: scope:[testLong]  from testLong::@5
  [27] phi()
  [28] call print_ln 
  to:testLong::@return
testLong::@return: scope:[testLong]  from testLong::@6
  [29] return 
  to:@return

(void()) print_ln()
print_ln: scope:[print_ln]  from testChar::@6 testInt::@6 testLong::@6 testShort::@6
  [30] (byte*) print_line_cursor#39 ← phi( testChar::@6/(byte*) 1024 testInt::@6/(byte*) print_line_cursor#1 testLong::@6/(byte*) print_line_cursor#1 testShort::@6/(byte*) print_line_cursor#1 )
  to:print_ln::@1
print_ln::@1: scope:[print_ln]  from print_ln print_ln::@1
  [31] (byte*) print_line_cursor#20 ← phi( print_ln/(byte*) print_line_cursor#39 print_ln::@1/(byte*) print_line_cursor#1 )
  [32] (byte*) print_line_cursor#1 ← (byte*) print_line_cursor#20 + (byte) $28
  [33] if((byte*) print_line_cursor#1<(byte*) print_char_cursor#26) goto print_ln::@1
  to:print_ln::@return
print_ln::@return: scope:[print_ln]  from print_ln::@1
  [34] return 
  to:@return

(void()) print_sdword((signed dword) print_sdword::dw)
print_sdword: scope:[print_sdword]  from testLong::@3 testLong::@5
  [35] (signed dword) print_sdword::dw#3 ← phi( testLong::@3/(const signed dword) testLong::n testLong::@5/(const signed dword) testLong::s )
  [36] if((signed dword) print_sdword::dw#3<(signed byte) 0) goto print_sdword::@1
  to:print_sdword::@3
print_sdword::@3: scope:[print_sdword]  from print_sdword
  [37] phi()
  [38] call print_char 
  to:print_sdword::@2
print_sdword::@2: scope:[print_sdword]  from print_sdword::@3 print_sdword::@4
  [39] (signed dword) print_sdword::dw#5 ← phi( print_sdword::@4/(signed dword) print_sdword::dw#0 print_sdword::@3/(signed dword) print_sdword::dw#3 )
  [40] (dword) print_dword::dw#0 ← (dword)(signed dword) print_sdword::dw#5
  [41] call print_dword 
  to:print_sdword::@return
print_sdword::@return: scope:[print_sdword]  from print_sdword::@2
  [42] return 
  to:@return
print_sdword::@1: scope:[print_sdword]  from print_sdword
  [43] phi()
  [44] call print_char 
  to:print_sdword::@4
print_sdword::@4: scope:[print_sdword]  from print_sdword::@1
  [45] (signed dword) print_sdword::dw#0 ← - (signed dword) print_sdword::dw#3
  to:print_sdword::@2

(void()) print_char((byte) print_char::ch)
print_char: scope:[print_char]  from print_byte print_byte::@1 print_sbyte::@1 print_sdword::@1 print_sdword::@3 print_sword::@1 print_sword::@3 testChar::@2 testChar::@4 testInt::@2 testInt::@4 testLong::@2 testLong::@4 testShort::@2 testShort::@4
  [46] (byte*) print_char_cursor#94 ← phi( print_byte/(byte*) print_char_cursor#149 print_byte::@1/(byte*) print_char_cursor#26 print_sbyte::@1/(byte*) print_char_cursor#26 print_sdword::@1/(byte*) print_char_cursor#26 print_sdword::@3/(byte*) print_char_cursor#26 print_sword::@1/(byte*) print_char_cursor#26 print_sword::@3/(byte*) print_char_cursor#26 testChar::@2/(byte*) print_char_cursor#26 testChar::@4/(byte*) print_char_cursor#26 testInt::@2/(byte*) print_char_cursor#26 testInt::@4/(byte*) print_char_cursor#26 testLong::@2/(byte*) print_char_cursor#26 testLong::@4/(byte*) print_char_cursor#26 testShort::@2/(byte*) print_char_cursor#26 testShort::@4/(byte*) print_char_cursor#26 )
  [46] (byte) print_char::ch#16 ← phi( print_byte/(byte) print_char::ch#6 print_byte::@1/(byte) print_char::ch#7 print_sbyte::@1/(byte) '-' print_sdword::@1/(byte) '-' print_sdword::@3/(byte) ' ' print_sword::@1/(byte) '-' print_sword::@3/(byte) ' ' testChar::@2/(byte) ' ' testChar::@4/(byte) ' ' testInt::@2/(byte) ' ' testInt::@4/(byte) ' ' testLong::@2/(byte) ' ' testLong::@4/(byte) ' ' testShort::@2/(byte) ' ' testShort::@4/(byte) ' ' )
  [47] *((byte*) print_char_cursor#94) ← (byte) print_char::ch#16
  [48] (byte*) print_char_cursor#26 ← ++ (byte*) print_char_cursor#94
  to:print_char::@return
print_char::@return: scope:[print_char]  from print_char
  [49] return 
  to:@return

(void()) print_dword((dword) print_dword::dw)
print_dword: scope:[print_dword]  from print_sdword::@2 testLong::@1
  [50] (byte*) print_char_cursor#145 ← phi( print_sdword::@2/(byte*) print_char_cursor#26 testLong::@1/(byte*) print_char_cursor#136 )
  [50] (dword) print_dword::dw#2 ← phi( print_sdword::@2/(dword) print_dword::dw#0 testLong::@1/(const dword) testLong::u )
  [51] (word) print_word::w#1 ← > (dword) print_dword::dw#2
  [52] call print_word 
  to:print_dword::@1
print_dword::@1: scope:[print_dword]  from print_dword
  [53] (word) print_word::w#2 ← < (dword) print_dword::dw#2
  [54] call print_word 
  to:print_dword::@return
print_dword::@return: scope:[print_dword]  from print_dword::@1
  [55] return 
  to:@return

(void()) print_word((word) print_word::w)
print_word: scope:[print_word]  from print_dword print_dword::@1 print_sword::@2 testInt::@1 testShort::@1
  [56] (byte*) print_char_cursor#144 ← phi( print_dword/(byte*) print_char_cursor#145 print_dword::@1/(byte*) print_char_cursor#26 print_sword::@2/(byte*) print_char_cursor#26 testInt::@1/(byte*) print_char_cursor#136 testShort::@1/(byte*) print_char_cursor#136 )
  [56] (word) print_word::w#5 ← phi( print_dword/(word) print_word::w#1 print_dword::@1/(word) print_word::w#2 print_sword::@2/(word) print_word::w#0 testInt::@1/(const word) testInt::u testShort::@1/(const word) testShort::u )
  [57] (byte) print_byte::b#1 ← > (word) print_word::w#5
  [58] call print_byte 
  to:print_word::@1
print_word::@1: scope:[print_word]  from print_word
  [59] (byte) print_byte::b#2 ← < (word) print_word::w#5
  [60] call print_byte 
  to:print_word::@return
print_word::@return: scope:[print_word]  from print_word::@1
  [61] return 
  to:@return

(void()) print_byte((byte) print_byte::b)
print_byte: scope:[print_byte]  from print_sbyte::@2 print_word print_word::@1 testChar::@1 testChar::@3
  [62] (byte*) print_char_cursor#149 ← phi( print_sbyte::@2/(byte*) print_char_cursor#26 print_word/(byte*) print_char_cursor#144 print_word::@1/(byte*) print_char_cursor#26 testChar::@1/(byte*) print_char_cursor#136 testChar::@3/(byte*) print_char_cursor#26 )
  [62] (byte) print_byte::b#5 ← phi( print_sbyte::@2/(byte)(const signed byte) print_sbyte::b#0 print_word/(byte) print_byte::b#1 print_word::@1/(byte) print_byte::b#2 testChar::@1/(const byte) testChar::u testChar::@3/(const byte) testChar::n )
  [63] (byte~) print_byte::$0 ← (byte) print_byte::b#5 >> (byte) 4
  [64] (byte) print_char::ch#6 ← *((const byte*) print_hextab + (byte~) print_byte::$0)
  [65] call print_char 
  to:print_byte::@1
print_byte::@1: scope:[print_byte]  from print_byte
  [66] (byte~) print_byte::$2 ← (byte) print_byte::b#5 & (byte) $f
  [67] (byte) print_char::ch#7 ← *((const byte*) print_hextab + (byte~) print_byte::$2)
  [68] call print_char 
  to:print_byte::@return
print_byte::@return: scope:[print_byte]  from print_byte::@1
  [69] return 
  to:@return

(void()) print_str((byte*) print_str::str)
print_str: scope:[print_str]  from testChar testInt testLong testShort
  [70] (byte*) print_char_cursor#156 ← phi( testChar/(byte*) 1024 testInt/(byte*) print_char_cursor#160 testLong/(byte*) print_char_cursor#161 testShort/(byte*) print_char_cursor#162 )
  [70] (byte*) print_str::str#7 ← phi( testChar/(const string) testChar::str testInt/(const string) testInt::str testLong/(const string) testLong::str testShort/(const string) testShort::str )
  to:print_str::@1
print_str::@1: scope:[print_str]  from print_str print_str::@2
  [71] (byte*) print_char_cursor#136 ← phi( print_str/(byte*) print_char_cursor#156 print_str::@2/(byte*) print_char_cursor#1 )
  [71] (byte*) print_str::str#5 ← phi( print_str/(byte*) print_str::str#7 print_str::@2/(byte*) print_str::str#0 )
  [72] if((byte) 0!=*((byte*) print_str::str#5)) goto print_str::@2
  to:print_str::@return
print_str::@return: scope:[print_str]  from print_str::@1
  [73] return 
  to:@return
print_str::@2: scope:[print_str]  from print_str::@1
  [74] *((byte*) print_char_cursor#136) ← *((byte*) print_str::str#5)
  [75] (byte*) print_char_cursor#1 ← ++ (byte*) print_char_cursor#136
  [76] (byte*) print_str::str#0 ← ++ (byte*) print_str::str#5
  to:print_str::@1

(void()) testInt()
testInt: scope:[testInt]  from main::@3
  [77] (byte*) print_char_cursor#160 ← (byte*) print_line_cursor#1
  [78] call print_str 
  to:testInt::@1
testInt::@1: scope:[testInt]  from testInt
  [79] phi()
  [80] call print_word 
  to:testInt::@2
testInt::@2: scope:[testInt]  from testInt::@1
  [81] phi()
  [82] call print_char 
  to:testInt::@3
testInt::@3: scope:[testInt]  from testInt::@2
  [83] phi()
  [84] call print_sword 
  to:testInt::@4
testInt::@4: scope:[testInt]  from testInt::@3
  [85] phi()
  [86] call print_char 
  to:testInt::@5
testInt::@5: scope:[testInt]  from testInt::@4
  [87] phi()
  [88] call print_sword 
  to:testInt::@6
testInt::@6: scope:[testInt]  from testInt::@5
  [89] phi()
  [90] call print_ln 
  to:testInt::@return
testInt::@return: scope:[testInt]  from testInt::@6
  [91] return 
  to:@return

(void()) print_sword((signed word) print_sword::w)
print_sword: scope:[print_sword]  from testInt::@3 testInt::@5 testShort::@3 testShort::@5
  [92] (signed word) print_sword::w#10 ← phi( testInt::@3/(const signed word) testInt::n testInt::@5/(const signed word) testInt::s testShort::@3/(const signed word) testShort::n testShort::@5/(const signed word) testShort::s )
  [93] if((signed word) print_sword::w#10<(signed byte) 0) goto print_sword::@1
  to:print_sword::@3
print_sword::@3: scope:[print_sword]  from print_sword
  [94] phi()
  [95] call print_char 
  to:print_sword::@2
print_sword::@2: scope:[print_sword]  from print_sword::@3 print_sword::@4
  [96] (signed word) print_sword::w#7 ← phi( print_sword::@4/(signed word) print_sword::w#0 print_sword::@3/(signed word) print_sword::w#10 )
  [97] (word) print_word::w#0 ← (word)(signed word) print_sword::w#7
  [98] call print_word 
  to:print_sword::@return
print_sword::@return: scope:[print_sword]  from print_sword::@2
  [99] return 
  to:@return
print_sword::@1: scope:[print_sword]  from print_sword
  [100] phi()
  [101] call print_char 
  to:print_sword::@4
print_sword::@4: scope:[print_sword]  from print_sword::@1
  [102] (signed word) print_sword::w#0 ← - (signed word) print_sword::w#10
  to:print_sword::@2

(void()) testShort()
testShort: scope:[testShort]  from main::@2
  [103] (byte*) print_char_cursor#162 ← (byte*) print_line_cursor#1
  [104] call print_str 
  to:testShort::@1
testShort::@1: scope:[testShort]  from testShort
  [105] phi()
  [106] call print_word 
  to:testShort::@2
testShort::@2: scope:[testShort]  from testShort::@1
  [107] phi()
  [108] call print_char 
  to:testShort::@3
testShort::@3: scope:[testShort]  from testShort::@2
  [109] phi()
  [110] call print_sword 
  to:testShort::@4
testShort::@4: scope:[testShort]  from testShort::@3
  [111] phi()
  [112] call print_char 
  to:testShort::@5
testShort::@5: scope:[testShort]  from testShort::@4
  [113] phi()
  [114] call print_sword 
  to:testShort::@6
testShort::@6: scope:[testShort]  from testShort::@5
  [115] phi()
  [116] call print_ln 
  to:testShort::@return
testShort::@return: scope:[testShort]  from testShort::@6
  [117] return 
  to:@return

(void()) testChar()
testChar: scope:[testChar]  from main::@1
  [118] phi()
  [119] call print_str 
  to:testChar::@1
testChar::@1: scope:[testChar]  from testChar
  [120] phi()
  [121] call print_byte 
  to:testChar::@2
testChar::@2: scope:[testChar]  from testChar::@1
  [122] phi()
  [123] call print_char 
  to:testChar::@3
testChar::@3: scope:[testChar]  from testChar::@2
  [124] phi()
  [125] call print_byte 
  to:testChar::@4
testChar::@4: scope:[testChar]  from testChar::@3
  [126] phi()
  [127] call print_char 
  to:testChar::@5
testChar::@5: scope:[testChar]  from testChar::@4
  [128] phi()
  [129] call print_sbyte 
  to:testChar::@6
testChar::@6: scope:[testChar]  from testChar::@5
  [130] phi()
  [131] call print_ln 
  to:testChar::@return
testChar::@return: scope:[testChar]  from testChar::@6
  [132] return 
  to:@return

(void()) print_sbyte((signed byte) print_sbyte::b)
print_sbyte: scope:[print_sbyte]  from testChar::@5
  [133] phi()
  to:print_sbyte::@1
print_sbyte::@1: scope:[print_sbyte]  from print_sbyte
  [134] phi()
  [135] call print_char 
  to:print_sbyte::@2
print_sbyte::@2: scope:[print_sbyte]  from print_sbyte::@1
  [136] phi()
  [137] call print_byte 
  to:print_sbyte::@return
print_sbyte::@return: scope:[print_sbyte]  from print_sbyte::@2
  [138] return 
  to:@return

(void()) print_cls()
print_cls: scope:[print_cls]  from main
  [139] phi()
  [140] call memset 
  to:print_cls::@return
print_cls::@return: scope:[print_cls]  from print_cls
  [141] return 
  to:@return

(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num)
memset: scope:[memset]  from print_cls
  [142] phi()
  to:memset::@1
memset::@1: scope:[memset]  from memset memset::@2
  [143] (byte*) memset::dst#2 ← phi( memset/(byte*)(const void*) memset::str#0 memset::@2/(byte*) memset::dst#1 )
  [144] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2
  to:memset::@return
memset::@return: scope:[memset]  from memset::@1
  [145] return 
  to:@return
memset::@2: scope:[memset]  from memset::@1
  [146] *((byte*) memset::dst#2) ← (const byte) memset::c#0
  [147] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2
  to:memset::@1
