@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()
  to:main::toD0181
main::toD0181: scope:[main]  from main
  [5] phi()
  to:main::@14
main::@14: scope:[main]  from main::toD0181
  [6] *((const byte*) D018#0) ← (const byte) main::toD0181_return#0
  [7] call print_cls 
  to:main::@15
main::@15: scope:[main]  from main::@14
  [8] phi()
  [9] call print_str 
  to:main::@16
main::@16: scope:[main]  from main::@15
  [10] phi()
  [11] call print_ln 
  to:main::@17
main::@17: scope:[main]  from main::@16
  [12] (byte*~) print_char_cursor#94 ← (byte*) print_line_cursor#1
  [13] call print_str 
  to:main::@18
main::@18: scope:[main]  from main::@17
  [14] phi()
  [15] call print_word_decimal 
  to:main::@19
main::@19: scope:[main]  from main::@18
  [16] phi()
  [17] call print_ln 
  to:main::@20
main::@20: scope:[main]  from main::@19
  [18] phi()
  [19] call memset 
  to:main::@21
main::@21: scope:[main]  from main::@20
  [20] phi()
  [21] call clock_start 
  to:main::@2
main::@2: scope:[main]  from main::@1 main::@21
  [22] (byte*) main::sieve_i#11 ← phi( main::@1/(byte*) main::sieve_i#1 main::@21/(const byte*) sieve#0+(byte) 2 )
  [22] (word) main::i#17 ← phi( main::@1/(word) main::i#12 main::@21/(byte) 2 )
  [23] if((byte) 0!=*((byte*) main::sieve_i#11)) goto main::@4
  to:main::@7
main::@7: scope:[main]  from main::@2
  [24] (word) main::j#0 ← (word) main::i#17 << (byte) 1
  [25] (byte*) main::s#0 ← (const byte*) sieve#0 + (word) main::j#0
  to:main::@5
main::@5: scope:[main]  from main::@6 main::@7
  [26] (byte*) main::s#2 ← phi( main::@7/(byte*) main::s#0 main::@6/(byte*) main::s#1 )
  [26] (word) main::j#2 ← phi( main::@7/(word) main::j#0 main::@6/(word) main::j#1 )
  [27] if((word) main::j#2<(const word) COUNT#0) goto main::@6
  to:main::@4
main::@4: scope:[main]  from main::@2 main::@5
  [28] (word) main::i#12 ← ++ (word) main::i#17
  [29] (byte*) main::sieve_i#1 ← ++ (byte*) main::sieve_i#11
  to:main::@1
main::@1: scope:[main]  from main::@4
  [30] if((word) main::i#12<(const byte) SQRT_COUNT#0) goto main::@2
  to:main::@3
main::@3: scope:[main]  from main::@1
  [31] phi()
  [32] call clock 
  [33] (dword) clock::return#2 ← (dword) clock::return#0
  to:main::@22
main::@22: scope:[main]  from main::@3
  [34] (dword~) main::$10 ← (dword) clock::return#2
  [35] (dword) main::cyclecount#0 ← (dword~) main::$10 - (const dword) CLOCKS_PER_INIT#0
  [36] (dword) div32u16u::dividend#0 ← (dword) main::cyclecount#0
  [37] call div32u16u 
  [38] (dword) div32u16u::return#2 ← (dword) div32u16u::return#0
  to:main::@23
main::@23: scope:[main]  from main::@22
  [39] (dword~) main::$14 ← (dword) div32u16u::return#2
  [40] (word) main::sec100s#0 ← (word)(dword~) main::$14
  [41] (byte*~) print_char_cursor#95 ← (byte*) print_line_cursor#1
  [42] call print_str 
  to:main::@24
main::@24: scope:[main]  from main::@23
  [43] (word) print_word_decimal::w#1 ← (word) main::sec100s#0
  [44] call print_word_decimal 
  to:main::@25
main::@25: scope:[main]  from main::@24
  [45] phi()
  [46] call print_str 
  to:main::@26
main::@26: scope:[main]  from main::@25
  [47] (dword) print_dword_decimal::w#0 ← (dword) main::cyclecount#0
  [48] call print_dword_decimal 
  to:main::@27
main::@27: scope:[main]  from main::@26
  [49] phi()
  [50] call print_ln 
  to:main::@9
main::@9: scope:[main]  from main::@27 main::@29
  [51] (byte*) print_char_cursor#90 ← phi( main::@29/(byte*~) print_char_cursor#104 main::@27/(byte*) print_line_cursor#1 )
  [51] (word) main::i#22 ← phi( main::@29/(word) main::i#10 main::@27/(byte) 2 )
  [52] (byte*~) main::$38 ← (const byte*) sieve#0 + (word) main::i#22
  [53] if((byte) 0!=*((byte*~) main::$38)) goto main::@30
  to:main::@12
main::@12: scope:[main]  from main::@9
  [54] (word) print_word_decimal::w#2 ← (word) main::i#22
  [55] (byte*~) print_char_cursor#101 ← (byte*) print_char_cursor#90
  [56] call print_word_decimal 
  to:main::@28
main::@28: scope:[main]  from main::@12
  [57] phi()
  [58] call print_char 
  to:main::@11
main::@11: scope:[main]  from main::@28 main::@30
  [59] (byte*) print_char_cursor#62 ← phi( main::@30/(byte*~) print_char_cursor#106 main::@28/(byte*) print_char_cursor#10 )
  [60] (word) main::i#10 ← ++ (word) main::i#22
  to:main::@8
main::@8: scope:[main]  from main::@11
  [61] if((word) main::i#10<(word) $514) goto main::@29
  to:main::@10
main::@10: scope:[main]  from main::@8
  [62] phi()
  [63] call print_str 
  to:main::@13
main::@13: scope:[main]  from main::@10 main::@13
  [64] *((const byte*) SCREEN#0+(word) $3e7) ← ++ *((const byte*) SCREEN#0+(word) $3e7)
  to:main::@13
main::@29: scope:[main]  from main::@8
  [65] (byte*~) print_char_cursor#104 ← (byte*) print_char_cursor#62
  to:main::@9
main::@30: scope:[main]  from main::@9
  [66] (byte*~) print_char_cursor#106 ← (byte*) print_char_cursor#90
  to:main::@11
main::@6: scope:[main]  from main::@5
  [67] *((byte*) main::s#2) ← (byte) 1
  [68] (byte*) main::s#1 ← (byte*) main::s#2 + (word) main::i#17
  [69] (word) main::j#1 ← (word) main::j#2 + (word) main::i#17
  to:main::@5
print_str: scope:[print_str]  from main::@10 main::@15 main::@17 main::@23 main::@25 print_dword_decimal::@1 print_word_decimal::@1
  [70] (byte*) print_char_cursor#66 ← phi( main::@10/(byte*) print_char_cursor#62 main::@15/(byte*) 1024 main::@17/(byte*~) print_char_cursor#94 main::@23/(byte*~) print_char_cursor#95 main::@25/(byte*) print_char_cursor#2 print_dword_decimal::@1/(byte*) print_char_cursor#2 print_word_decimal::@1/(byte*) print_char_cursor#58 )
  [70] (byte*) print_str::str#10 ← phi( main::@10/(const string) main::str4 main::@15/(const string) main::str main::@17/(const string) main::str1 main::@23/(const string) main::str2 main::@25/(const string) main::str3 print_dword_decimal::@1/(const byte[$b]) decimal_digits_long#0 print_word_decimal::@1/(const byte[6]) decimal_digits#0 )
  to:print_str::@1
print_str::@1: scope:[print_str]  from print_str print_str::@2
  [71] (byte*) print_char_cursor#2 ← phi( print_str/(byte*) print_char_cursor#66 print_str::@2/(byte*) print_char_cursor#1 )
  [71] (byte*) print_str::str#8 ← phi( print_str/(byte*) print_str::str#10 print_str::@2/(byte*) print_str::str#0 )
  [72] if((byte) 0!=*((byte*) print_str::str#8)) 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#2) ← *((byte*) print_str::str#8)
  [75] (byte*) print_char_cursor#1 ← ++ (byte*) print_char_cursor#2
  [76] (byte*) print_str::str#0 ← ++ (byte*) print_str::str#8
  to:print_str::@1
print_char: scope:[print_char]  from main::@28
  [77] *((byte*) print_char_cursor#2) ← (const byte) print_char::ch#0
  [78] (byte*) print_char_cursor#10 ← ++ (byte*) print_char_cursor#2
  to:print_char::@return
print_char::@return: scope:[print_char]  from print_char
  [79] return 
  to:@return
print_word_decimal: scope:[print_word_decimal]  from main::@12 main::@18 main::@24
  [80] (byte*) print_char_cursor#58 ← phi( main::@12/(byte*~) print_char_cursor#101 main::@18/(byte*) print_char_cursor#2 main::@24/(byte*) print_char_cursor#2 )
  [80] (word) print_word_decimal::w#3 ← phi( main::@12/(word) print_word_decimal::w#2 main::@18/(const word) COUNT#0 main::@24/(word) print_word_decimal::w#1 )
  [81] (word) utoa::value#1 ← (word) print_word_decimal::w#3
  [82] call utoa 
  to:print_word_decimal::@1
print_word_decimal::@1: scope:[print_word_decimal]  from print_word_decimal
  [83] phi()
  [84] call print_str 
  to:print_word_decimal::@return
print_word_decimal::@return: scope:[print_word_decimal]  from print_word_decimal::@1
  [85] return 
  to:@return
utoa: scope:[utoa]  from print_word_decimal
  [86] phi()
  to:utoa::@19_1
utoa::@19_1: scope:[utoa]  from utoa
  [87] (word) utoa::digit_value#4 ← *((const word[]) RADIX_DECIMAL_VALUES#0)
  to:utoa::@7
utoa::@7: scope:[utoa]  from utoa::@19_1 utoa::@2
  [88] (word) utoa::digit_value#3 ← phi( utoa::@2/(word) utoa::digit_value#0 utoa::@19_1/(word) utoa::digit_value#4 )
  [88] (byte*) utoa::buffer#28 ← phi( utoa::@2/(byte*) utoa::buffer#11 utoa::@19_1/(const byte[6]) decimal_digits#0 )
  [88] (byte) utoa::started#8 ← phi( utoa::@2/(byte) utoa::started#2 utoa::@19_1/(byte) 0 )
  [88] (word) utoa::value#21 ← phi( utoa::@2/(word) utoa::value#16 utoa::@19_1/(word) utoa::value#1 )
  [88] (byte) utoa::digit#15 ← phi( utoa::@2/(byte) utoa::digit#1 utoa::@19_1/(byte) 0 )
  [89] if((word) utoa::value#21>=(word) utoa::digit_value#3) goto utoa::@5
  to:utoa::@4
utoa::@4: scope:[utoa]  from utoa::@6 utoa::@7
  [90] (byte) utoa::digit#13 ← phi( utoa::@6/(byte) utoa::digit#14 utoa::@7/(byte) utoa::digit#15 )
  [90] (byte*) utoa::buffer#11 ← phi( utoa::@7/(byte*) utoa::buffer#28 utoa::@6/(byte*) utoa::buffer#4 )
  [90] (byte) utoa::started#2 ← phi( utoa::@7/(byte) utoa::started#8 utoa::@6/(byte) 1 )
  [90] (word) utoa::value#16 ← phi( utoa::@7/(word) utoa::value#21 utoa::@6/(word) utoa::value#0 )
  [91] (byte) utoa::digit#1 ← ++ (byte) utoa::digit#13
  to:utoa::@1
utoa::@1: scope:[utoa]  from utoa::@4
  [92] if((byte) utoa::digit#1<(const byte) utoa::max_digits#1-(byte) 1) goto utoa::@2
  to:utoa::@3
utoa::@3: scope:[utoa]  from utoa::@1
  [93] (byte~) utoa::$4 ← (byte)(word) utoa::value#16
  [94] *((byte*) utoa::buffer#11) ← *((const byte[]) DIGITS#0 + (byte~) utoa::$4)
  [95] (byte*) utoa::buffer#3 ← ++ (byte*) utoa::buffer#11
  [96] *((byte*) utoa::buffer#3) ← (byte) 0
  to:utoa::@return
utoa::@return: scope:[utoa]  from utoa::@3
  [97] return 
  to:@return
utoa::@2: scope:[utoa]  from utoa::@1
  [98] (byte~) utoa::$11 ← (byte) utoa::digit#1 << (byte) 1
  [99] (word) utoa::digit_value#0 ← *((const word[]) RADIX_DECIMAL_VALUES#0 + (byte~) utoa::$11)
  [100] if((byte) 0!=(byte) utoa::started#2) goto utoa::@5
  to:utoa::@7
utoa::@5: scope:[utoa]  from utoa::@2 utoa::@7
  [101] (word) utoa::digit_value#2 ← phi( utoa::@2/(word) utoa::digit_value#0 utoa::@7/(word) utoa::digit_value#3 )
  [101] (byte*) utoa::buffer#29 ← phi( utoa::@2/(byte*) utoa::buffer#11 utoa::@7/(byte*) utoa::buffer#28 )
  [101] (word) utoa::value#22 ← phi( utoa::@2/(word) utoa::value#16 utoa::@7/(word) utoa::value#21 )
  [101] (byte) utoa::digit#14 ← phi( utoa::@2/(byte) utoa::digit#1 utoa::@7/(byte) utoa::digit#15 )
  [102] (byte*) utoa_append::buffer#0 ← (byte*) utoa::buffer#29
  [103] (word) utoa_append::value#0 ← (word) utoa::value#22
  [104] (word) utoa_append::sub#0 ← (word) utoa::digit_value#2
  [105] call utoa_append 
  [106] (word) utoa_append::return#0 ← (word) utoa_append::value#2
  to:utoa::@6
utoa::@6: scope:[utoa]  from utoa::@5
  [107] (word) utoa::value#0 ← (word) utoa_append::return#0
  [108] (byte*) utoa::buffer#4 ← ++ (byte*) utoa::buffer#29
  to:utoa::@4
utoa_append: scope:[utoa_append]  from utoa::@5
  [109] phi()
  to:utoa_append::@1
utoa_append::@1: scope:[utoa_append]  from utoa_append utoa_append::@2
  [110] (byte) utoa_append::digit#2 ← phi( utoa_append/(byte) 0 utoa_append::@2/(byte) utoa_append::digit#1 )
  [110] (word) utoa_append::value#2 ← phi( utoa_append/(word) utoa_append::value#0 utoa_append::@2/(word) utoa_append::value#1 )
  [111] if((word) utoa_append::value#2>=(word) utoa_append::sub#0) goto utoa_append::@2
  to:utoa_append::@3
utoa_append::@3: scope:[utoa_append]  from utoa_append::@1
  [112] *((byte*) utoa_append::buffer#0) ← *((const byte[]) DIGITS#0 + (byte) utoa_append::digit#2)
  to:utoa_append::@return
utoa_append::@return: scope:[utoa_append]  from utoa_append::@3
  [113] return 
  to:@return
utoa_append::@2: scope:[utoa_append]  from utoa_append::@1
  [114] (byte) utoa_append::digit#1 ← ++ (byte) utoa_append::digit#2
  [115] (word) utoa_append::value#1 ← (word) utoa_append::value#2 - (word) utoa_append::sub#0
  to:utoa_append::@1
print_ln: scope:[print_ln]  from main::@16 main::@19 main::@27
  [116] (byte*) print_line_cursor#21 ← phi( main::@16/(byte*) 1024 main::@19/(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
  [117] (byte*) print_line_cursor#11 ← phi( print_ln/(byte*) print_line_cursor#21 print_ln::@1/(byte*) print_line_cursor#1 )
  [118] (byte*) print_line_cursor#1 ← (byte*) print_line_cursor#11 + (byte) $28
  [119] 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
  [120] return 
  to:@return
print_dword_decimal: scope:[print_dword_decimal]  from main::@26
  [121] (dword) ultoa::value#1 ← (dword) print_dword_decimal::w#0
  [122] call ultoa 
  to:print_dword_decimal::@1
print_dword_decimal::@1: scope:[print_dword_decimal]  from print_dword_decimal
  [123] phi()
  [124] call print_str 
  to:print_dword_decimal::@return
print_dword_decimal::@return: scope:[print_dword_decimal]  from print_dword_decimal::@1
  [125] return 
  to:@return
ultoa: scope:[ultoa]  from print_dword_decimal
  [126] phi()
  to:ultoa::@19_1
ultoa::@19_1: scope:[ultoa]  from ultoa
  [127] (dword) ultoa::digit_value#4 ← *((const dword[]) RADIX_DECIMAL_VALUES_LONG#0)
  to:ultoa::@7
ultoa::@7: scope:[ultoa]  from ultoa::@19_1 ultoa::@2
  [128] (dword) ultoa::digit_value#3 ← phi( ultoa::@2/(dword) ultoa::digit_value#0 ultoa::@19_1/(dword) ultoa::digit_value#4 )
  [128] (byte*) ultoa::buffer#28 ← phi( ultoa::@2/(byte*) ultoa::buffer#11 ultoa::@19_1/(const byte[$b]) decimal_digits_long#0 )
  [128] (byte) ultoa::started#8 ← phi( ultoa::@2/(byte) ultoa::started#2 ultoa::@19_1/(byte) 0 )
  [128] (dword) ultoa::value#21 ← phi( ultoa::@2/(dword) ultoa::value#16 ultoa::@19_1/(dword) ultoa::value#1 )
  [128] (byte) ultoa::digit#15 ← phi( ultoa::@2/(byte) ultoa::digit#1 ultoa::@19_1/(byte) 0 )
  [129] if((dword) ultoa::value#21>=(dword) ultoa::digit_value#3) goto ultoa::@5
  to:ultoa::@4
ultoa::@4: scope:[ultoa]  from ultoa::@6 ultoa::@7
  [130] (byte) ultoa::digit#13 ← phi( ultoa::@6/(byte) ultoa::digit#14 ultoa::@7/(byte) ultoa::digit#15 )
  [130] (byte*) ultoa::buffer#11 ← phi( ultoa::@7/(byte*) ultoa::buffer#28 ultoa::@6/(byte*) ultoa::buffer#4 )
  [130] (byte) ultoa::started#2 ← phi( ultoa::@7/(byte) ultoa::started#8 ultoa::@6/(byte) 1 )
  [130] (dword) ultoa::value#16 ← phi( ultoa::@7/(dword) ultoa::value#21 ultoa::@6/(dword) ultoa::value#0 )
  [131] (byte) ultoa::digit#1 ← ++ (byte) ultoa::digit#13
  to:ultoa::@1
ultoa::@1: scope:[ultoa]  from ultoa::@4
  [132] if((byte) ultoa::digit#1<(const byte) ultoa::max_digits#1-(byte) 1) goto ultoa::@2
  to:ultoa::@3
ultoa::@3: scope:[ultoa]  from ultoa::@1
  [133] (byte~) ultoa::$4 ← (byte)(dword) ultoa::value#16
  [134] *((byte*) ultoa::buffer#11) ← *((const byte[]) DIGITS#0 + (byte~) ultoa::$4)
  [135] (byte*) ultoa::buffer#3 ← ++ (byte*) ultoa::buffer#11
  [136] *((byte*) ultoa::buffer#3) ← (byte) 0
  to:ultoa::@return
ultoa::@return: scope:[ultoa]  from ultoa::@3
  [137] return 
  to:@return
ultoa::@2: scope:[ultoa]  from ultoa::@1
  [138] (byte~) ultoa::$11 ← (byte) ultoa::digit#1 << (byte) 2
  [139] (dword) ultoa::digit_value#0 ← *((const dword[]) RADIX_DECIMAL_VALUES_LONG#0 + (byte~) ultoa::$11)
  [140] if((byte) 0!=(byte) ultoa::started#2) goto ultoa::@5
  to:ultoa::@7
ultoa::@5: scope:[ultoa]  from ultoa::@2 ultoa::@7
  [141] (dword) ultoa::digit_value#2 ← phi( ultoa::@2/(dword) ultoa::digit_value#0 ultoa::@7/(dword) ultoa::digit_value#3 )
  [141] (byte*) ultoa::buffer#29 ← phi( ultoa::@2/(byte*) ultoa::buffer#11 ultoa::@7/(byte*) ultoa::buffer#28 )
  [141] (dword) ultoa::value#22 ← phi( ultoa::@2/(dword) ultoa::value#16 ultoa::@7/(dword) ultoa::value#21 )
  [141] (byte) ultoa::digit#14 ← phi( ultoa::@2/(byte) ultoa::digit#1 ultoa::@7/(byte) ultoa::digit#15 )
  [142] (byte*) ultoa_append::buffer#0 ← (byte*) ultoa::buffer#29
  [143] (dword) ultoa_append::value#0 ← (dword) ultoa::value#22
  [144] (dword) ultoa_append::sub#0 ← (dword) ultoa::digit_value#2
  [145] call ultoa_append 
  [146] (dword) ultoa_append::return#0 ← (dword) ultoa_append::value#2
  to:ultoa::@6
ultoa::@6: scope:[ultoa]  from ultoa::@5
  [147] (dword) ultoa::value#0 ← (dword) ultoa_append::return#0
  [148] (byte*) ultoa::buffer#4 ← ++ (byte*) ultoa::buffer#29
  to:ultoa::@4
ultoa_append: scope:[ultoa_append]  from ultoa::@5
  [149] phi()
  to:ultoa_append::@1
ultoa_append::@1: scope:[ultoa_append]  from ultoa_append ultoa_append::@2
  [150] (byte) ultoa_append::digit#2 ← phi( ultoa_append/(byte) 0 ultoa_append::@2/(byte) ultoa_append::digit#1 )
  [150] (dword) ultoa_append::value#2 ← phi( ultoa_append/(dword) ultoa_append::value#0 ultoa_append::@2/(dword) ultoa_append::value#1 )
  [151] if((dword) ultoa_append::value#2>=(dword) ultoa_append::sub#0) goto ultoa_append::@2
  to:ultoa_append::@3
ultoa_append::@3: scope:[ultoa_append]  from ultoa_append::@1
  [152] *((byte*) ultoa_append::buffer#0) ← *((const byte[]) DIGITS#0 + (byte) ultoa_append::digit#2)
  to:ultoa_append::@return
ultoa_append::@return: scope:[ultoa_append]  from ultoa_append::@3
  [153] return 
  to:@return
ultoa_append::@2: scope:[ultoa_append]  from ultoa_append::@1
  [154] (byte) ultoa_append::digit#1 ← ++ (byte) ultoa_append::digit#2
  [155] (dword) ultoa_append::value#1 ← (dword) ultoa_append::value#2 - (dword) ultoa_append::sub#0
  to:ultoa_append::@1
div32u16u: scope:[div32u16u]  from main::@22
  [156] (word) divr16u::dividend#1 ← > (dword) div32u16u::dividend#0
  [157] call divr16u 
  [158] (word) divr16u::return#2 ← (word) divr16u::return#0
  to:div32u16u::@1
div32u16u::@1: scope:[div32u16u]  from div32u16u
  [159] (word) div32u16u::quotient_hi#0 ← (word) divr16u::return#2
  [160] (word) divr16u::dividend#2 ← < (dword) div32u16u::dividend#0
  [161] (word) divr16u::rem#4 ← (word) rem16u#1
  [162] call divr16u 
  [163] (word) divr16u::return#3 ← (word) divr16u::return#0
  to:div32u16u::@2
div32u16u::@2: scope:[div32u16u]  from div32u16u::@1
  [164] (word) div32u16u::quotient_lo#0 ← (word) divr16u::return#3
  [165] (dword) div32u16u::return#0 ← (word) div32u16u::quotient_hi#0 dw= (word) div32u16u::quotient_lo#0
  to:div32u16u::@return
div32u16u::@return: scope:[div32u16u]  from div32u16u::@2
  [166] return 
  to:@return
divr16u: scope:[divr16u]  from div32u16u div32u16u::@1
  [167] (word) divr16u::dividend#5 ← phi( div32u16u/(word) divr16u::dividend#1 div32u16u::@1/(word) divr16u::dividend#2 )
  [167] (word) divr16u::rem#10 ← phi( div32u16u/(byte) 0 div32u16u::@1/(word) divr16u::rem#4 )
  to:divr16u::@1
divr16u::@1: scope:[divr16u]  from divr16u divr16u::@3
  [168] (byte) divr16u::i#2 ← phi( divr16u/(byte) 0 divr16u::@3/(byte) divr16u::i#1 )
  [168] (word) divr16u::quotient#3 ← phi( divr16u/(byte) 0 divr16u::@3/(word) divr16u::return#0 )
  [168] (word) divr16u::dividend#3 ← phi( divr16u/(word) divr16u::dividend#5 divr16u::@3/(word) divr16u::dividend#0 )
  [168] (word) divr16u::rem#5 ← phi( divr16u/(word) divr16u::rem#10 divr16u::@3/(word) divr16u::rem#11 )
  [169] (word) divr16u::rem#0 ← (word) divr16u::rem#5 << (byte) 1
  [170] (byte~) divr16u::$1 ← > (word) divr16u::dividend#3
  [171] (byte~) divr16u::$2 ← (byte~) divr16u::$1 & (byte) $80
  [172] if((byte~) divr16u::$2==(byte) 0) goto divr16u::@2
  to:divr16u::@4
divr16u::@4: scope:[divr16u]  from divr16u::@1
  [173] (word) divr16u::rem#1 ← (word) divr16u::rem#0 | (byte) 1
  to:divr16u::@2
divr16u::@2: scope:[divr16u]  from divr16u::@1 divr16u::@4
  [174] (word) divr16u::rem#6 ← phi( divr16u::@1/(word) divr16u::rem#0 divr16u::@4/(word) divr16u::rem#1 )
  [175] (word) divr16u::dividend#0 ← (word) divr16u::dividend#3 << (byte) 1
  [176] (word) divr16u::quotient#1 ← (word) divr16u::quotient#3 << (byte) 1
  [177] if((word) divr16u::rem#6<(const word) div32u16u::divisor#0) goto divr16u::@3
  to:divr16u::@5
divr16u::@5: scope:[divr16u]  from divr16u::@2
  [178] (word) divr16u::quotient#2 ← ++ (word) divr16u::quotient#1
  [179] (word) divr16u::rem#2 ← (word) divr16u::rem#6 - (const word) div32u16u::divisor#0
  to:divr16u::@3
divr16u::@3: scope:[divr16u]  from divr16u::@2 divr16u::@5
  [180] (word) divr16u::return#0 ← phi( divr16u::@2/(word) divr16u::quotient#1 divr16u::@5/(word) divr16u::quotient#2 )
  [180] (word) divr16u::rem#11 ← phi( divr16u::@2/(word) divr16u::rem#6 divr16u::@5/(word) divr16u::rem#2 )
  [181] (byte) divr16u::i#1 ← ++ (byte) divr16u::i#2
  [182] if((byte) divr16u::i#1!=(byte) $10) goto divr16u::@1
  to:divr16u::@6
divr16u::@6: scope:[divr16u]  from divr16u::@3
  [183] (word) rem16u#1 ← (word) divr16u::rem#11
  to:divr16u::@return
divr16u::@return: scope:[divr16u]  from divr16u::@6
  [184] return 
  to:@return
clock: scope:[clock]  from main::@3
  [185] (dword) clock::return#0 ← (dword) $ffffffff - *((const dword*) CIA2_TIMER_AB#0)
  to:clock::@return
clock::@return: scope:[clock]  from clock
  [186] return 
  to:@return
clock_start: scope:[clock_start]  from main::@21
  [187] *((const byte*) CIA2_TIMER_A_CONTROL#0) ← (const byte) CIA_TIMER_CONTROL_CONTINUOUS#0
  [188] *((const byte*) CIA2_TIMER_B_CONTROL#0) ← (const byte) CIA_TIMER_CONTROL_B_COUNT_UNDERFLOW_A#0
  [189] *((const dword*) CIA2_TIMER_AB#0) ← (dword) $ffffffff
  [190] *((const byte*) CIA2_TIMER_B_CONTROL#0) ← (const byte) CIA_TIMER_CONTROL_START#0|(const byte) CIA_TIMER_CONTROL_B_COUNT_UNDERFLOW_A#0
  [191] *((const byte*) CIA2_TIMER_A_CONTROL#0) ← (const byte) CIA_TIMER_CONTROL_START#0
  to:clock_start::@return
clock_start::@return: scope:[clock_start]  from clock_start
  [192] return 
  to:@return
memset: scope:[memset]  from main::@20 print_cls
  [193] (byte) memset::c#4 ← phi( main::@20/(byte) 0 print_cls/(byte) ' ' )
  [193] (void*) memset::str#3 ← phi( main::@20/(void*)(const byte*) sieve#0 print_cls/(void*)(byte*) 1024 )
  [193] (word) memset::num#2 ← phi( main::@20/(const word) COUNT#0 print_cls/(word) $3e8 )
  [194] if((word) memset::num#2<=(byte) 0) goto memset::@return
  to:memset::@1
memset::@1: scope:[memset]  from memset
  [195] (byte*) memset::end#0 ← (byte*)(void*) memset::str#3 + (word) memset::num#2
  [196] (byte*~) memset::dst#4 ← (byte*)(void*) memset::str#3
  to:memset::@2
memset::@2: scope:[memset]  from memset::@1 memset::@3
  [197] (byte*) memset::dst#2 ← phi( memset::@1/(byte*~) memset::dst#4 memset::@3/(byte*) memset::dst#1 )
  [198] if((byte*) memset::dst#2!=(byte*) memset::end#0) goto memset::@3
  to:memset::@return
memset::@return: scope:[memset]  from memset memset::@2
  [199] return 
  to:@return
memset::@3: scope:[memset]  from memset::@2
  [200] *((byte*) memset::dst#2) ← (byte) memset::c#4
  [201] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2
  to:memset::@2
print_cls: scope:[print_cls]  from main::@14
  [202] phi()
  [203] call memset 
  to:print_cls::@return
print_cls::@return: scope:[print_cls]  from print_cls
  [204] return 
  to:@return
