@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 memset 
  to:main::@1
main::@1: scope:[main]  from main main::@3
  [6] (byte*) main::sieve_i#2 ← phi( main/(const byte*) sieve+(word) 2 main::@3/(byte*) main::sieve_i#1 )
  [6] (word) main::i#12 ← phi( main/(word) 2 main::@3/(word) main::i#2 )
  [7] if((word) main::i#12<(const byte) SQRT_COUNT) goto main::@2
  to:main::@7
main::@7: scope:[main]  from main::@1 main::@9
  [8] (byte*) print_char_cursor#27 ← phi( main::@9/(byte*) print_char_cursor#33 main::@1/(byte*) 1024 )
  [8] (word) main::i#10 ← phi( main::@9/(word) main::i#3 main::@1/(byte) 2 )
  [9] if((word) main::i#10<(word) $4c7) goto main::@8
  to:main::@11
main::@11: scope:[main]  from main::@11 main::@7
  [10] *((const byte*) SCREEN+(word) $3e7) ← ++ *((const byte*) SCREEN+(word) $3e7)
  to:main::@11
main::@8: scope:[main]  from main::@7
  [11] (byte*~) main::$16 ← (const byte*) sieve + (word) main::i#10
  [12] if((byte) 0!=*((byte*~) main::$16)) goto main::@9
  to:main::@10
main::@10: scope:[main]  from main::@8
  [13] (word) print_word::w#0 ← (word) main::i#10
  [14] call print_word 
  to:main::@12
main::@12: scope:[main]  from main::@10
  [15] phi()
  [16] call print_char 
  to:main::@9
main::@9: scope:[main]  from main::@12 main::@8
  [17] (byte*) print_char_cursor#33 ← phi( main::@8/(byte*) print_char_cursor#27 main::@12/(byte*) print_char_cursor#20 )
  [18] (word) main::i#3 ← ++ (word) main::i#10
  to:main::@7
main::@2: scope:[main]  from main::@1
  [19] if((byte) 0!=*((byte*) main::sieve_i#2)) goto main::@3
  to:main::@6
main::@6: scope:[main]  from main::@2
  [20] (word) main::j#0 ← (word) main::i#12 << (byte) 1
  [21] (byte*) main::s#0 ← (const byte*) sieve + (word) main::j#0
  to:main::@4
main::@4: scope:[main]  from main::@5 main::@6
  [22] (byte*) main::s#2 ← phi( main::@6/(byte*) main::s#0 main::@5/(byte*) main::s#1 )
  [22] (word) main::j#2 ← phi( main::@6/(word) main::j#0 main::@5/(word) main::j#1 )
  [23] if((word) main::j#2<(const word) COUNT) goto main::@5
  to:main::@3
main::@3: scope:[main]  from main::@2 main::@4
  [24] (word) main::i#2 ← ++ (word) main::i#12
  [25] (byte*) main::sieve_i#1 ← ++ (byte*) main::sieve_i#2
  to:main::@1
main::@5: scope:[main]  from main::@4
  [26] *((byte*) main::s#2) ← (byte) 1
  [27] (byte*) main::s#1 ← (byte*) main::s#2 + (word) main::i#12
  [28] (word) main::j#1 ← (word) main::j#2 + (word) main::i#12
  to:main::@4

(void()) print_char((byte) print_char::ch)
print_char: scope:[print_char]  from main::@12 print_byte print_byte::@1
  [29] (byte*) print_char_cursor#19 ← phi( main::@12/(byte*) print_char_cursor#20 print_byte/(byte*) print_char_cursor#26 print_byte::@1/(byte*) print_char_cursor#20 )
  [29] (byte) print_char::ch#3 ← phi( main::@12/(byte) ' ' print_byte/(byte) print_char::ch#0 print_byte::@1/(byte) print_char::ch#1 )
  [30] *((byte*) print_char_cursor#19) ← (byte) print_char::ch#3
  [31] (byte*) print_char_cursor#20 ← ++ (byte*) print_char_cursor#19
  to:print_char::@return
print_char::@return: scope:[print_char]  from print_char
  [32] return 
  to:@return

(void()) print_word((word) print_word::w)
print_word: scope:[print_word]  from main::@10
  [33] (byte) print_byte::b#0 ← > (word) print_word::w#0
  [34] call print_byte 
  to:print_word::@1
print_word::@1: scope:[print_word]  from print_word
  [35] (byte) print_byte::b#1 ← < (word) print_word::w#0
  [36] call print_byte 
  to:print_word::@return
print_word::@return: scope:[print_word]  from print_word::@1
  [37] return 
  to:@return

(void()) print_byte((byte) print_byte::b)
print_byte: scope:[print_byte]  from print_word print_word::@1
  [38] (byte*) print_char_cursor#26 ← phi( print_word/(byte*) print_char_cursor#27 print_word::@1/(byte*) print_char_cursor#20 )
  [38] (byte) print_byte::b#2 ← phi( print_word/(byte) print_byte::b#0 print_word::@1/(byte) print_byte::b#1 )
  [39] (byte~) print_byte::$0 ← (byte) print_byte::b#2 >> (byte) 4
  [40] (byte) print_char::ch#0 ← *((const byte*) print_hextab + (byte~) print_byte::$0)
  [41] call print_char 
  to:print_byte::@1
print_byte::@1: scope:[print_byte]  from print_byte
  [42] (byte~) print_byte::$2 ← (byte) print_byte::b#2 & (byte) $f
  [43] (byte) print_char::ch#1 ← *((const byte*) print_hextab + (byte~) print_byte::$2)
  [44] call print_char 
  to:print_byte::@return
print_byte::@return: scope:[print_byte]  from print_byte::@1
  [45] return 
  to:@return

(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num)
memset: scope:[memset]  from main
  [46] phi()
  to:memset::@1
memset::@1: scope:[memset]  from memset memset::@2
  [47] (byte*) memset::dst#2 ← phi( memset/(byte*)(const void*) memset::str#0 memset::@2/(byte*) memset::dst#1 )
  [48] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2
  to:memset::@return
memset::@return: scope:[memset]  from memset::@1
  [49] return 
  to:@return
memset::@2: scope:[memset]  from memset::@1
  [50] *((byte*) memset::dst#2) ← (const byte) memset::c#0
  [51] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2
  to:memset::@1
