@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 lin16u_gen 
  to:main::@4
main::@4: scope:[main]  from main
  [6] phi()
  [7] call lin16u_gen 
  to:main::@5
main::@5: scope:[main]  from main::@4
  [8] phi()
  [9] call lin16u_gen 
  to:main::@6
main::@6: scope:[main]  from main::@5
  [10] phi()
  [11] call print_cls 
  to:main::@7
main::@7: scope:[main]  from main::@6
  [12] phi()
  [13] call print_str 
  to:main::@8
main::@8: scope:[main]  from main::@7
  [14] phi()
  [15] call print_word 
  to:main::@9
main::@9: scope:[main]  from main::@8
  [16] phi()
  [17] call print_str 
  to:main::@10
main::@10: scope:[main]  from main::@9
  [18] phi()
  [19] call print_word 
  to:main::@11
main::@11: scope:[main]  from main::@10
  [20] phi()
  [21] call print_str 
  to:main::@12
main::@12: scope:[main]  from main::@11
  [22] phi()
  [23] call print_word 
  to:main::@13
main::@13: scope:[main]  from main::@12
  [24] phi()
  [25] call print_ln 
  to:main::@2
main::@2: scope:[main]  from main::@1 main::@13
  [26] (byte) main::i#12 ← phi( main::@1/(byte) main::i#1 main::@13/(byte) 0 )
  [27] (byte) print_byte::b#2 ← (byte) main::i#12
  [28] (byte*~) print_char_cursor#102 ← (byte*) print_line_cursor#1
  [29] call print_byte 
  to:main::@14
main::@14: scope:[main]  from main::@2
  [30] phi()
  [31] call print_str 
  to:main::@15
main::@15: scope:[main]  from main::@14
  [32] (byte~) main::$27 ← (byte) main::i#12 << (byte) 1
  [33] (word) print_word::w#3 ← *((const word[$14]) main::lintab1#0 + (byte~) main::$27)
  [34] call print_word 
  to:main::@16
main::@16: scope:[main]  from main::@15
  [35] phi()
  [36] call print_str 
  to:main::@17
main::@17: scope:[main]  from main::@16
  [37] (byte~) main::$28 ← (byte) main::i#12 << (byte) 1
  [38] (word) print_word::w#4 ← *((const word[$14]) main::lintab2#0 + (byte~) main::$28)
  [39] call print_word 
  to:main::@18
main::@18: scope:[main]  from main::@17
  [40] phi()
  [41] call print_str 
  to:main::@19
main::@19: scope:[main]  from main::@18
  [42] (byte~) main::$29 ← (byte) main::i#12 << (byte) 1
  [43] (word) print_word::w#5 ← *((const word[$14]) main::lintab3#0 + (byte~) main::$29)
  [44] call print_word 
  to:main::@20
main::@20: scope:[main]  from main::@19
  [45] phi()
  [46] call print_ln 
  to:main::@21
main::@21: scope:[main]  from main::@20
  [47] (byte) main::i#1 ← ++ (byte) main::i#12
  to:main::@1
main::@1: scope:[main]  from main::@21
  [48] if((byte) main::i#1<(byte) $14) goto main::@2
  to:main::@3
main::@3: scope:[main]  from main::@1
  [49] (byte*~) print_char_cursor#99 ← (byte*) print_line_cursor#1
  [50] call print_str 
  to:main::@22
main::@22: scope:[main]  from main::@3
  [51] phi()
  [52] call print_word 
  to:main::@23
main::@23: scope:[main]  from main::@22
  [53] phi()
  [54] call print_str 
  to:main::@24
main::@24: scope:[main]  from main::@23
  [55] phi()
  [56] call print_word 
  to:main::@25
main::@25: scope:[main]  from main::@24
  [57] phi()
  [58] call print_str 
  to:main::@26
main::@26: scope:[main]  from main::@25
  [59] phi()
  [60] call print_word 
  to:main::@27
main::@27: scope:[main]  from main::@26
  [61] phi()
  [62] call print_ln 
  to:main::@return
main::@return: scope:[main]  from main::@27
  [63] return 
  to:@return
print_ln: scope:[print_ln]  from main::@13 main::@20 main::@27
  [64] (byte*) print_line_cursor#21 ← phi( main::@13/(byte*) 1024 main::@20/(byte*) print_line_cursor#1 main::@27/(byte*) print_line_cursor#1 )
  to:print_ln::@1
print_ln::@1: scope:[print_ln]  from print_ln print_ln::@1
  [65] (byte*) print_line_cursor#11 ← phi( print_ln/(byte*) print_line_cursor#21 print_ln::@1/(byte*) print_line_cursor#1 )
  [66] (byte*) print_line_cursor#1 ← (byte*) print_line_cursor#11 + (byte) $28
  [67] if((byte*) print_line_cursor#1<(byte*) print_char_cursor#11) goto print_ln::@1
  to:print_ln::@return
print_ln::@return: scope:[print_ln]  from print_ln::@1
  [68] return 
  to:@return
print_word: scope:[print_word]  from main::@10 main::@12 main::@15 main::@17 main::@19 main::@22 main::@24 main::@26 main::@8
  [69] (word) print_word::w#10 ← phi( main::@8/(word) $22d main::@10/(word) $79cb main::@12/(byte) 0 main::@15/(word) print_word::w#3 main::@17/(word) print_word::w#4 main::@19/(word) print_word::w#5 main::@22/(word) $7461 main::@24/(word) $f781 main::@26/(word) $6488 )
  [70] (byte) print_byte::b#0 ← > (word) print_word::w#10
  [71] call print_byte 
  to:print_word::@1
print_word::@1: scope:[print_word]  from print_word
  [72] (byte) print_byte::b#1 ← < (word) print_word::w#10
  [73] call print_byte 
  to:print_word::@return
print_word::@return: scope:[print_word]  from print_word::@1
  [74] return 
  to:@return
print_byte: scope:[print_byte]  from main::@2 print_word print_word::@1
  [75] (byte*) print_char_cursor#81 ← phi( main::@2/(byte*~) print_char_cursor#102 print_word/(byte*) print_char_cursor#2 print_word::@1/(byte*) print_char_cursor#11 )
  [75] (byte) print_byte::b#3 ← phi( main::@2/(byte) print_byte::b#2 print_word/(byte) print_byte::b#0 print_word::@1/(byte) print_byte::b#1 )
  [76] (byte~) print_byte::$0 ← (byte) print_byte::b#3 >> (byte) 4
  [77] (byte) print_char::ch#0 ← *((const byte[]) print_hextab#0 + (byte~) print_byte::$0)
  [78] call print_char 
  to:print_byte::@1
print_byte::@1: scope:[print_byte]  from print_byte
  [79] (byte~) print_byte::$2 ← (byte) print_byte::b#3 & (byte) $f
  [80] (byte) print_char::ch#1 ← *((const byte[]) print_hextab#0 + (byte~) print_byte::$2)
  [81] call print_char 
  to:print_byte::@return
print_byte::@return: scope:[print_byte]  from print_byte::@1
  [82] return 
  to:@return
print_char: scope:[print_char]  from print_byte print_byte::@1
  [83] (byte*) print_char_cursor#50 ← phi( print_byte/(byte*) print_char_cursor#81 print_byte::@1/(byte*) print_char_cursor#11 )
  [83] (byte) print_char::ch#2 ← phi( print_byte/(byte) print_char::ch#0 print_byte::@1/(byte) print_char::ch#1 )
  [84] *((byte*) print_char_cursor#50) ← (byte) print_char::ch#2
  [85] (byte*) print_char_cursor#11 ← ++ (byte*) print_char_cursor#50
  to:print_char::@return
print_char::@return: scope:[print_char]  from print_char
  [86] return 
  to:@return
print_str: scope:[print_str]  from main::@11 main::@14 main::@16 main::@18 main::@23 main::@25 main::@3 main::@7 main::@9
  [87] (byte*) print_char_cursor#86 ← phi( main::@7/(byte*) 1024 main::@9/(byte*) print_char_cursor#11 main::@11/(byte*) print_char_cursor#11 main::@14/(byte*) print_char_cursor#11 main::@16/(byte*) print_char_cursor#11 main::@18/(byte*) print_char_cursor#11 main::@23/(byte*) print_char_cursor#11 main::@25/(byte*) print_char_cursor#11 main::@3/(byte*~) print_char_cursor#99 )
  [87] (byte*) print_str::str#12 ← phi( main::@7/(const string) main::str main::@9/(const string) main::str1 main::@11/(const string) main::str1 main::@14/(const string) main::str1 main::@16/(const string) main::str1 main::@18/(const string) main::str1 main::@23/(const string) main::str1 main::@25/(const string) main::str1 main::@3/(const string) main::str )
  to:print_str::@1
print_str::@1: scope:[print_str]  from print_str print_str::@2
  [88] (byte*) print_char_cursor#2 ← phi( print_str/(byte*) print_char_cursor#86 print_str::@2/(byte*) print_char_cursor#1 )
  [88] (byte*) print_str::str#10 ← phi( print_str/(byte*) print_str::str#12 print_str::@2/(byte*) print_str::str#0 )
  [89] 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
  [90] return 
  to:@return
print_str::@2: scope:[print_str]  from print_str::@1
  [91] *((byte*) print_char_cursor#2) ← *((byte*) print_str::str#10)
  [92] (byte*) print_char_cursor#1 ← ++ (byte*) print_char_cursor#2
  [93] (byte*) print_str::str#0 ← ++ (byte*) print_str::str#10
  to:print_str::@1
print_cls: scope:[print_cls]  from main::@6
  [94] phi()
  [95] call memset 
  to:print_cls::@return
print_cls::@return: scope:[print_cls]  from print_cls
  [96] return 
  to:@return
memset: scope:[memset]  from print_cls
  [97] phi()
  to:memset::@2
memset::@2: scope:[memset]  from memset memset::@1
  [98] (byte*) memset::dst#4 ← phi( memset::@1/(byte*) memset::dst#1 memset/(byte*)(const void*) memset::str#0 )
  [99] *((byte*) memset::dst#4) ← (const byte) memset::c#0
  [100] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#4
  to:memset::@1
memset::@1: scope:[memset]  from memset::@2
  [101] if((byte*) memset::dst#1!=(const byte*) memset::end#0) goto memset::@2
  to:memset::@return
memset::@return: scope:[memset]  from memset::@1
  [102] return 
  to:@return
lin16u_gen: scope:[lin16u_gen]  from main main::@4 main::@5
  [103] (word*) lin16u_gen::lintab#10 ← phi( main/(const word[$14]) main::lintab1#0 main::@4/(const word[$14]) main::lintab2#0 main::@5/(const word[$14]) main::lintab3#0 )
  [103] (word) lin16u_gen::min#3 ← phi( main/(word) $22d main::@4/(word) $79cb main::@5/(byte) 0 )
  [103] (word) lin16u_gen::max#3 ← phi( main/(word) $7461 main::@4/(word) $f781 main::@5/(word) $6488 )
  [104] (word) lin16u_gen::ampl#0 ← (word) lin16u_gen::max#3 - (word) lin16u_gen::min#3
  [105] (word) divr16u::dividend#1 ← (word) lin16u_gen::ampl#0
  [106] call divr16u 
  [107] (word) divr16u::return#2 ← (word) divr16u::return#0
  to:lin16u_gen::@3
lin16u_gen::@3: scope:[lin16u_gen]  from lin16u_gen
  [108] (word) lin16u_gen::stepi#0 ← (word) divr16u::return#2
  [109] (word) divr16u::rem#4 ← (word) rem16u#1
  [110] call divr16u 
  [111] (word) divr16u::return#3 ← (word) divr16u::return#0
  to:lin16u_gen::@4
lin16u_gen::@4: scope:[lin16u_gen]  from lin16u_gen::@3
  [112] (word) lin16u_gen::stepf#0 ← (word) divr16u::return#3
  [113] (dword) lin16u_gen::step#0 ← (word) lin16u_gen::stepi#0 dw= (word) lin16u_gen::stepf#0
  [114] (dword) lin16u_gen::val#0 ← (word) lin16u_gen::min#3 dw= (word) 0
  to:lin16u_gen::@2
lin16u_gen::@2: scope:[lin16u_gen]  from lin16u_gen::@1 lin16u_gen::@4
  [115] (word*) lin16u_gen::lintab#9 ← phi( lin16u_gen::@1/(word*) lin16u_gen::lintab#3 lin16u_gen::@4/(word*) lin16u_gen::lintab#10 )
  [115] (dword) lin16u_gen::val#4 ← phi( lin16u_gen::@1/(dword) lin16u_gen::val#1 lin16u_gen::@4/(dword) lin16u_gen::val#0 )
  [115] (word) lin16u_gen::i#4 ← phi( lin16u_gen::@1/(word) lin16u_gen::i#1 lin16u_gen::@4/(byte) 0 )
  [116] (word~) lin16u_gen::$6 ← > (dword) lin16u_gen::val#4
  [117] *((word*) lin16u_gen::lintab#9) ← (word~) lin16u_gen::$6
  [118] (dword) lin16u_gen::val#1 ← (dword) lin16u_gen::val#4 + (dword) lin16u_gen::step#0
  [119] (word*) lin16u_gen::lintab#3 ← (word*) lin16u_gen::lintab#9 + (const byte) SIZEOF_WORD
  [120] (word) lin16u_gen::i#1 ← ++ (word) lin16u_gen::i#4
  to:lin16u_gen::@1
lin16u_gen::@1: scope:[lin16u_gen]  from lin16u_gen::@2
  [121] if((word) lin16u_gen::i#1<(byte) $14) goto lin16u_gen::@2
  to:lin16u_gen::@return
lin16u_gen::@return: scope:[lin16u_gen]  from lin16u_gen::@1
  [122] return 
  to:@return
divr16u: scope:[divr16u]  from lin16u_gen lin16u_gen::@3
  [123] (word) divr16u::divisor#6 ← phi( lin16u_gen/(byte) $14-(byte) 1 lin16u_gen::@3/(byte) $14-(byte) 1 )
  [123] (word) divr16u::dividend#5 ← phi( lin16u_gen/(word) divr16u::dividend#1 lin16u_gen::@3/(byte) 0 )
  [123] (word) divr16u::rem#10 ← phi( lin16u_gen/(byte) 0 lin16u_gen::@3/(word) divr16u::rem#4 )
  to:divr16u::@1
divr16u::@1: scope:[divr16u]  from divr16u divr16u::@3
  [124] (byte) divr16u::i#2 ← phi( divr16u/(byte) 0 divr16u::@3/(byte) divr16u::i#1 )
  [124] (word) divr16u::quotient#3 ← phi( divr16u/(byte) 0 divr16u::@3/(word) divr16u::return#0 )
  [124] (word) divr16u::dividend#3 ← phi( divr16u/(word) divr16u::dividend#5 divr16u::@3/(word) divr16u::dividend#0 )
  [124] (word) divr16u::rem#5 ← phi( divr16u/(word) divr16u::rem#10 divr16u::@3/(word) divr16u::rem#11 )
  [125] (word) divr16u::rem#0 ← (word) divr16u::rem#5 << (byte) 1
  [126] (byte~) divr16u::$1 ← > (word) divr16u::dividend#3
  [127] (byte~) divr16u::$2 ← (byte~) divr16u::$1 & (byte) $80
  [128] if((byte~) divr16u::$2==(byte) 0) goto divr16u::@2
  to:divr16u::@4
divr16u::@4: scope:[divr16u]  from divr16u::@1
  [129] (word) divr16u::rem#1 ← (word) divr16u::rem#0 | (byte) 1
  to:divr16u::@2
divr16u::@2: scope:[divr16u]  from divr16u::@1 divr16u::@4
  [130] (word) divr16u::rem#6 ← phi( divr16u::@1/(word) divr16u::rem#0 divr16u::@4/(word) divr16u::rem#1 )
  [131] (word) divr16u::dividend#0 ← (word) divr16u::dividend#3 << (byte) 1
  [132] (word) divr16u::quotient#1 ← (word) divr16u::quotient#3 << (byte) 1
  [133] if((word) divr16u::rem#6<(word) divr16u::divisor#6) goto divr16u::@3
  to:divr16u::@5
divr16u::@5: scope:[divr16u]  from divr16u::@2
  [134] (word) divr16u::quotient#2 ← ++ (word) divr16u::quotient#1
  [135] (word) divr16u::rem#2 ← (word) divr16u::rem#6 - (word) divr16u::divisor#6
  to:divr16u::@3
divr16u::@3: scope:[divr16u]  from divr16u::@2 divr16u::@5
  [136] (word) divr16u::return#0 ← phi( divr16u::@2/(word) divr16u::quotient#1 divr16u::@5/(word) divr16u::quotient#2 )
  [136] (word) divr16u::rem#11 ← phi( divr16u::@2/(word) divr16u::rem#6 divr16u::@5/(word) divr16u::rem#2 )
  [137] (byte) divr16u::i#1 ← ++ (byte) divr16u::i#2
  [138] if((byte) divr16u::i#1!=(byte) $10) goto divr16u::@1
  to:divr16u::@6
divr16u::@6: scope:[divr16u]  from divr16u::@3
  [139] (word) rem16u#1 ← (word) divr16u::rem#11
  to:divr16u::@return
divr16u::@return: scope:[divr16u]  from divr16u::@6
  [140] return 
  to:@return
