
void main()
main: scope:[main]  from
  [0] *(PRIMES+1*SIZEOF_UNSIGNED_INT) = 2
  [1] *(PRIMES+2*SIZEOF_UNSIGNED_INT) = 3
  to:main::@1
main::@1: scope:[main]  from main main::@11
  [2] print_char_cursor#34 = phi( main/print_screen#0, main::@11/print_char_cursor#17 )
  [2] prime_idx#17 = phi( main/2, main::@11/prime_idx#1 )
  [2] potential#15 = phi( main/3, main::@11/potential#11 )
  [2] test_last#13 = phi( main/2, main::@11/test_last#19 )
  [3] main::$12 = test_last#13 << 1
  [4] main::p#0 = (char)PRIMES[main::$12]
  [5] mul8u::a#1 = main::p#0
  [6] mul8u::b#0 = main::p#0
  [7] call mul8u
  [8] mul8u::return#2 = mul8u::res#2
  to:main::@8
main::@8: scope:[main]  from main::@1
  [9] main::$0 = mul8u::return#2
  [10] if(potential#15<=main::$0) goto main::@2
  to:main::@7
main::@7: scope:[main]  from main::@8
  [11] test_last#1 = ++ test_last#13
  to:main::@2
main::@2: scope:[main]  from main::@7 main::@8
  [12] test_last#19 = phi( main::@7/test_last#1, main::@8/test_last#13 )
  [13] potential#1 = potential#15 + 2
  to:main::@3
main::@3: scope:[main]  from main::@2 main::@4
  [14] potential#10 = phi( main::@2/potential#1, main::@4/potential#11 )
  [14] test_idx#7 = phi( main::@2/2, main::@4/test_idx#10 )
  [15] main::$13 = test_idx#7 << 1
  [16] div16u8u::dividend#0 = potential#10
  [17] div16u8u::divisor#0 = (char)PRIMES[main::$13]
  [18] call div16u8u
  to:main::@9
main::@9: scope:[main]  from main::@3
  [19] test_idx#1 = ++ test_idx#7
  [20] if(rem8u#0!=0) goto main::@4
  to:main::@5
main::@5: scope:[main]  from main::@9
  [21] potential#2 = potential#10 + 2
  to:main::@4
main::@4: scope:[main]  from main::@5 main::@9
  [22] potential#11 = phi( main::@5/potential#2, main::@9/potential#10 )
  [22] test_idx#10 = phi( main::@5/2, main::@9/test_idx#1 )
  [23] if(test_idx#10<=test_last#19) goto main::@3
  to:main::@6
main::@6: scope:[main]  from main::@4
  [24] prime_idx#1 = ++ prime_idx#17
  [25] main::$14 = prime_idx#1 << 1
  [26] main::$15 = PRIMES + main::$14
  [27] *main::$15 = potential#11
  [28] print_uint_decimal::w#0 = potential#11
  [29] call print_uint_decimal
  to:main::@10
main::@10: scope:[main]  from main::@6
  [30] phi()
  [31] call print_char
  to:main::@11
main::@11: scope:[main]  from main::@10
  [32] if(prime_idx#1<$3e8) goto main::@1
  to:main::@return
main::@return: scope:[main]  from main::@11
  [33] return 
  to:@return

unsigned int mul8u(char a , char b)
mul8u: scope:[mul8u]  from main::@1
  [34] mul8u::mb#0 = (unsigned int)mul8u::b#0
  to:mul8u::@1
mul8u::@1: scope:[mul8u]  from mul8u mul8u::@3
  [35] mul8u::mb#2 = phi( mul8u/mul8u::mb#0, mul8u::@3/mul8u::mb#1 )
  [35] mul8u::res#2 = phi( mul8u/0, mul8u::@3/mul8u::res#6 )
  [35] mul8u::a#2 = phi( mul8u/mul8u::a#1, mul8u::@3/mul8u::a#0 )
  [36] if(mul8u::a#2!=0) goto mul8u::@2
  to:mul8u::@return
mul8u::@return: scope:[mul8u]  from mul8u::@1
  [37] return 
  to:@return
mul8u::@2: scope:[mul8u]  from mul8u::@1
  [38] mul8u::$1 = mul8u::a#2 & 1
  [39] if(mul8u::$1==0) goto mul8u::@3
  to:mul8u::@4
mul8u::@4: scope:[mul8u]  from mul8u::@2
  [40] mul8u::res#1 = mul8u::res#2 + mul8u::mb#2
  to:mul8u::@3
mul8u::@3: scope:[mul8u]  from mul8u::@2 mul8u::@4
  [41] mul8u::res#6 = phi( mul8u::@2/mul8u::res#2, mul8u::@4/mul8u::res#1 )
  [42] mul8u::a#0 = mul8u::a#2 >> 1
  [43] mul8u::mb#1 = mul8u::mb#2 << 1
  to:mul8u::@1

unsigned int div16u8u(unsigned int dividend , char divisor)
div16u8u: scope:[div16u8u]  from main::@3
  [44] divr8u::dividend#1 = byte1  div16u8u::dividend#0
  [45] divr8u::divisor#0 = div16u8u::divisor#0
  [46] call divr8u
  to:div16u8u::@1
div16u8u::@1: scope:[div16u8u]  from div16u8u
  [47] divr8u::dividend#2 = byte0  div16u8u::dividend#0
  [48] divr8u::divisor#1 = div16u8u::divisor#0
  [49] divr8u::rem#4 = rem8u#0
  [50] call divr8u
  to:div16u8u::@return
div16u8u::@return: scope:[div16u8u]  from div16u8u::@1
  [51] return 
  to:@return

void print_uint_decimal(unsigned int w)
print_uint_decimal: scope:[print_uint_decimal]  from main::@6
  [52] utoa::value#0 = print_uint_decimal::w#0
  [53] call utoa
  to:print_uint_decimal::@1
print_uint_decimal::@1: scope:[print_uint_decimal]  from print_uint_decimal
  [54] phi()
  [55] call print_str
  to:print_uint_decimal::@return
print_uint_decimal::@return: scope:[print_uint_decimal]  from print_uint_decimal::@1
  [56] return 
  to:@return

void print_char(char ch)
print_char: scope:[print_char]  from main::@10 print_str::@2
  [57] print_char::ch#2 = phi( main::@10/' ', print_str::@2/print_char::ch#0 )
  [58] *print_char_cursor#1 = print_char::ch#2
  [59] print_char_cursor#17 = ++ print_char_cursor#1
  to:print_char::@return
print_char::@return: scope:[print_char]  from print_char
  [60] return 
  to:@return

char divr8u(char dividend , char divisor , char rem)
divr8u: scope:[divr8u]  from div16u8u div16u8u::@1
  [61] divr8u::divisor#6 = phi( div16u8u/divr8u::divisor#0, div16u8u::@1/divr8u::divisor#1 )
  [61] divr8u::dividend#5 = phi( div16u8u/divr8u::dividend#1, div16u8u::@1/divr8u::dividend#2 )
  [61] divr8u::rem#10 = phi( div16u8u/0, div16u8u::@1/divr8u::rem#4 )
  to:divr8u::@1
divr8u::@1: scope:[divr8u]  from divr8u divr8u::@3
  [62] divr8u::i#2 = phi( divr8u/0, divr8u::@3/divr8u::i#1 )
  [62] divr8u::quotient#3 = phi( divr8u/0, divr8u::@3/divr8u::return#0 )
  [62] divr8u::dividend#3 = phi( divr8u/divr8u::dividend#5, divr8u::@3/divr8u::dividend#0 )
  [62] divr8u::rem#5 = phi( divr8u/divr8u::rem#10, divr8u::@3/divr8u::rem#11 )
  [63] divr8u::rem#0 = divr8u::rem#5 << 1
  [64] divr8u::$1 = divr8u::dividend#3 & $80
  [65] if(divr8u::$1==0) goto divr8u::@2
  to:divr8u::@4
divr8u::@4: scope:[divr8u]  from divr8u::@1
  [66] divr8u::rem#1 = divr8u::rem#0 | 1
  to:divr8u::@2
divr8u::@2: scope:[divr8u]  from divr8u::@1 divr8u::@4
  [67] divr8u::rem#6 = phi( divr8u::@1/divr8u::rem#0, divr8u::@4/divr8u::rem#1 )
  [68] divr8u::dividend#0 = divr8u::dividend#3 << 1
  [69] divr8u::quotient#1 = divr8u::quotient#3 << 1
  [70] if(divr8u::rem#6<divr8u::divisor#6) goto divr8u::@3
  to:divr8u::@5
divr8u::@5: scope:[divr8u]  from divr8u::@2
  [71] divr8u::quotient#2 = ++ divr8u::quotient#1
  [72] divr8u::rem#2 = divr8u::rem#6 - divr8u::divisor#6
  to:divr8u::@3
divr8u::@3: scope:[divr8u]  from divr8u::@2 divr8u::@5
  [73] divr8u::return#0 = phi( divr8u::@2/divr8u::quotient#1, divr8u::@5/divr8u::quotient#2 )
  [73] divr8u::rem#11 = phi( divr8u::@2/divr8u::rem#6, divr8u::@5/divr8u::rem#2 )
  [74] divr8u::i#1 = ++ divr8u::i#2
  [75] if(divr8u::i#1!=8) goto divr8u::@1
  to:divr8u::@6
divr8u::@6: scope:[divr8u]  from divr8u::@3
  [76] rem8u#0 = divr8u::rem#11
  to:divr8u::@return
divr8u::@return: scope:[divr8u]  from divr8u::@6
  [77] return 
  to:@return

void utoa(unsigned int value , char *buffer , char radix)
utoa: scope:[utoa]  from print_uint_decimal
  [78] phi()
  to:utoa::@1
utoa::@1: scope:[utoa]  from utoa utoa::@4
  [79] utoa::buffer#11 = phi( utoa::@4/utoa::buffer#14, utoa/decimal_digits )
  [79] utoa::started#2 = phi( utoa::@4/utoa::started#4, utoa/0 )
  [79] utoa::value#2 = phi( utoa::@4/utoa::value#6, utoa/utoa::value#0 )
  [79] utoa::digit#2 = phi( utoa::@4/utoa::digit#1, utoa/0 )
  [80] if(utoa::digit#2<utoa::max_digits#1-1) goto utoa::@2
  to:utoa::@3
utoa::@3: scope:[utoa]  from utoa::@1
  [81] utoa::$11 = (char)utoa::value#2
  [82] *utoa::buffer#11 = DIGITS[utoa::$11]
  [83] utoa::buffer#4 = ++ utoa::buffer#11
  [84] *utoa::buffer#4 = 0
  to:utoa::@return
utoa::@return: scope:[utoa]  from utoa::@3
  [85] return 
  to:@return
utoa::@2: scope:[utoa]  from utoa::@1
  [86] utoa::$10 = utoa::digit#2 << 1
  [87] utoa::digit_value#0 = RADIX_DECIMAL_VALUES[utoa::$10]
  [88] if(0!=utoa::started#2) goto utoa::@5
  to:utoa::@7
utoa::@7: scope:[utoa]  from utoa::@2
  [89] if(utoa::value#2>=utoa::digit_value#0) goto utoa::@5
  to:utoa::@4
utoa::@4: scope:[utoa]  from utoa::@6 utoa::@7
  [90] utoa::buffer#14 = phi( utoa::@7/utoa::buffer#11, utoa::@6/utoa::buffer#5 )
  [90] utoa::started#4 = phi( utoa::@7/utoa::started#2, utoa::@6/1 )
  [90] utoa::value#6 = phi( utoa::@7/utoa::value#2, utoa::@6/utoa::value#1 )
  [91] utoa::digit#1 = ++ utoa::digit#2
  to:utoa::@1
utoa::@5: scope:[utoa]  from utoa::@2 utoa::@7
  [92] utoa_append::buffer#0 = utoa::buffer#11
  [93] utoa_append::value#0 = utoa::value#2
  [94] utoa_append::sub#0 = utoa::digit_value#0
  [95] call utoa_append
  [96] utoa_append::return#0 = utoa_append::value#2
  to:utoa::@6
utoa::@6: scope:[utoa]  from utoa::@5
  [97] utoa::value#1 = utoa_append::return#0
  [98] utoa::buffer#5 = ++ utoa::buffer#11
  to:utoa::@4

void print_str(char *str)
print_str: scope:[print_str]  from print_uint_decimal::@1
  [99] phi()
  to:print_str::@1
print_str::@1: scope:[print_str]  from print_str print_str::@3
  [100] print_char_cursor#1 = phi( print_str/print_char_cursor#34, print_str::@3/print_char_cursor#17 )
  [100] print_str::str#2 = phi( print_str/decimal_digits, print_str::@3/print_str::str#0 )
  [101] if(0!=*print_str::str#2) goto print_str::@2
  to:print_str::@return
print_str::@return: scope:[print_str]  from print_str::@1
  [102] return 
  to:@return
print_str::@2: scope:[print_str]  from print_str::@1
  [103] print_char::ch#0 = *print_str::str#2
  [104] call print_char
  to:print_str::@3
print_str::@3: scope:[print_str]  from print_str::@2
  [105] print_str::str#0 = ++ print_str::str#2
  to:print_str::@1

unsigned int utoa_append(char *buffer , unsigned int value , unsigned int sub)
utoa_append: scope:[utoa_append]  from utoa::@5
  [106] phi()
  to:utoa_append::@1
utoa_append::@1: scope:[utoa_append]  from utoa_append utoa_append::@2
  [107] utoa_append::digit#2 = phi( utoa_append/0, utoa_append::@2/utoa_append::digit#1 )
  [107] utoa_append::value#2 = phi( utoa_append/utoa_append::value#0, utoa_append::@2/utoa_append::value#1 )
  [108] if(utoa_append::value#2>=utoa_append::sub#0) goto utoa_append::@2
  to:utoa_append::@3
utoa_append::@3: scope:[utoa_append]  from utoa_append::@1
  [109] *utoa_append::buffer#0 = DIGITS[utoa_append::digit#2]
  to:utoa_append::@return
utoa_append::@return: scope:[utoa_append]  from utoa_append::@3
  [110] return 
  to:@return
utoa_append::@2: scope:[utoa_append]  from utoa_append::@1
  [111] utoa_append::digit#1 = ++ utoa_append::digit#2
  [112] utoa_append::value#1 = utoa_append::value#2 - utoa_append::sub#0
  to:utoa_append::@1
