@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
  asm { sei  }
  [5] call init 
  to:main::@1
main::@1: scope:[main]  from main
  [6] phi()
  [7] call loop 
  to:main::@2
main::@2: scope:[main]  from main::@1
  [8] phi()
  [9] call exit 
  to:main::@3
main::@3: scope:[main]  from main::@2
  asm { cli  }
  to:main::@return
main::@return: scope:[main]  from main::@3
  [11] return 
  to:@return

(void()) exit()
exit: scope:[exit]  from main::@2
  [12] phi()
  to:exit::@1
exit::@1: scope:[exit]  from exit exit::@2
  [13] phi()
  [14] call keyboard_key_pressed 
  [15] (byte) keyboard_key_pressed::return#2 ← (byte) keyboard_key_pressed::return#0
  to:exit::@2
exit::@2: scope:[exit]  from exit::@1
  [16] (byte~) exit::$0 ← (byte) keyboard_key_pressed::return#2
  [17] if((byte) 0!=(byte~) exit::$0) goto exit::@1
  to:exit::@return
exit::@return: scope:[exit]  from exit::@2
  [18] return 
  to:@return

(byte()) keyboard_key_pressed((byte) keyboard_key_pressed::key)
keyboard_key_pressed: scope:[keyboard_key_pressed]  from exit::@1 loop::@10
  [19] phi()
  [20] call keyboard_matrix_read 
  [21] (byte) keyboard_matrix_read::return#2 ← (byte) keyboard_matrix_read::return#0
  to:keyboard_key_pressed::@1
keyboard_key_pressed::@1: scope:[keyboard_key_pressed]  from keyboard_key_pressed
  [22] (byte~) keyboard_key_pressed::$2 ← (byte) keyboard_matrix_read::return#2
  [23] (byte) keyboard_key_pressed::return#0 ← (byte~) keyboard_key_pressed::$2 & *((const byte*) keyboard_matrix_col_bitmask+(const byte) keyboard_key_pressed::colidx#0)
  to:keyboard_key_pressed::@return
keyboard_key_pressed::@return: scope:[keyboard_key_pressed]  from keyboard_key_pressed::@1
  [24] return 
  to:@return

(byte()) keyboard_matrix_read((byte) keyboard_matrix_read::rowid)
keyboard_matrix_read: scope:[keyboard_matrix_read]  from keyboard_key_pressed
  [25] *((const byte*) CIA1_PORT_A) ← *((const byte*) keyboard_matrix_row_bitmask+(const byte) keyboard_key_pressed::rowidx#0)
  [26] (byte) keyboard_matrix_read::return#0 ← ~ *((const byte*) CIA1_PORT_B)
  to:keyboard_matrix_read::@return
keyboard_matrix_read::@return: scope:[keyboard_matrix_read]  from keyboard_matrix_read
  [27] return 
  to:@return

(void()) loop()
loop: scope:[loop]  from main::@1
  [28] phi()
  to:loop::@1
loop::@1: scope:[loop]  from loop loop::@15
  [29] (byte) loop::angle#6 ← phi( loop/(byte) 0 loop::@15/(byte) loop::angle#1 )
  to:loop::@2
loop::@2: scope:[loop]  from loop::@1 loop::@2
  [30] if(*((const byte*) RASTER)<(byte) $d8) goto loop::@2
  to:loop::@3
loop::@3: scope:[loop]  from loop::@2
  [31] *((const byte*) BORDERCOL) ← (byte) $f
  [32] (byte) loop::a#6 ← (byte) loop::angle#6
  to:loop::@4
loop::@4: scope:[loop]  from loop::@12 loop::@3
  [33] (byte) loop::i#2 ← phi( loop::@12/(byte) loop::i#1 loop::@3/(byte) 0 )
  [33] (byte) loop::a#2 ← phi( loop::@12/(byte) loop::a#1 loop::@3/(byte) loop::a#6 )
  [33] (signed byte) loop::r#2 ← phi( loop::@12/(signed byte) loop::r#1 loop::@3/(signed byte) $1e )
  [34] *((const byte*) BORDERCOL) ← (byte) 6
  [35] (signed byte) mulf8s::a#0 ← (signed byte) loop::r#2
  [36] (signed byte) mulf8s::b#0 ← *((const signed byte*) COS + (byte) loop::a#2)
  [37] call mulf8s 
  [38] (signed word) mulf8s::return#2 ← (signed word) mulf8s::return#0
  to:loop::@11
loop::@11: scope:[loop]  from loop::@4
  [39] (signed word~) loop::$1 ← (signed word) mulf8s::return#2
  [40] (signed word~) loop::$2 ← (signed word~) loop::$1 << (byte) 1
  [41] (signed word) loop::x#0 ← (signed word~) loop::$2 + (signed word)(number) $7d*(number) $100
  [42] (byte~) loop::$4 ← > (signed word) loop::x#0
  [43] (byte~) loop::$20 ← (byte) loop::i#2 << (byte) 1
  [44] *((const word*) PLEX_XPOS + (byte~) loop::$20) ← (byte~) loop::$4
  [45] (signed byte) mulf8s::a#1 ← (signed byte) loop::r#2
  [46] (signed byte) mulf8s::b#1 ← *((const signed byte*) SIN + (byte) loop::a#2)
  [47] call mulf8s 
  [48] (signed word) mulf8s::return#3 ← (signed word) mulf8s::return#0
  to:loop::@12
loop::@12: scope:[loop]  from loop::@11
  [49] (signed word~) loop::$5 ← (signed word) mulf8s::return#3
  [50] (signed word~) loop::$6 ← (signed word~) loop::$5 << (byte) 1
  [51] (signed word) loop::y#0 ← (signed word~) loop::$6 + (signed word)(number) $7d*(number) $100
  [52] (byte~) loop::$8 ← > (signed word) loop::y#0
  [53] *((const byte*) PLEX_YPOS + (byte) loop::i#2) ← (byte~) loop::$8
  [54] (byte) loop::a#1 ← (byte) loop::a#2 + (byte) $62
  [55] (signed byte) loop::r#1 ← (signed byte) loop::r#2 + (signed byte) 3
  [56] (byte) loop::i#1 ← ++ (byte) loop::i#2
  [57] if((byte) loop::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto loop::@4
  to:loop::@5
loop::@5: scope:[loop]  from loop::@12
  [58] *((const byte*) BORDERCOL) ← (byte) 3
  [59] call plexSort 
  to:loop::@13
loop::@13: scope:[loop]  from loop::@5
  [60] (byte) loop::angle#1 ← (byte) loop::angle#6 + (byte) 3
  [61] *((const byte*) BORDERCOL) ← (const byte) BLACK
  to:loop::@6
loop::@6: scope:[loop]  from loop::@13 loop::@6
  [62] (byte~) loop::$11 ← *((const byte*) D011) & (const byte) VIC_RST8
  [63] if((byte~) loop::$11!=(byte) 0) goto loop::@6
  to:loop::@7
loop::@7: scope:[loop]  from loop::@14 loop::@6
  [64] (byte) loop::i1#5 ← phi( loop::@6/(byte) 0 loop::@14/(byte) loop::i1#1 )
  [64] (byte) plex_sprite_msb#43 ← phi( loop::@6/(byte) 1 loop::@14/(byte) plex_sprite_msb#16 )
  [64] (byte) plex_show_idx#43 ← phi( loop::@6/(byte) 0 loop::@14/(byte) plex_show_idx#15 )
  [64] (byte) plex_sprite_idx#43 ← phi( loop::@6/(byte) 0 loop::@14/(byte) plex_sprite_idx#15 )
  [64] (byte) plex_free_next#17 ← phi( loop::@6/(byte) 0 loop::@14/(byte) plex_free_next#13 )
  [65] *((const byte*) BORDERCOL) ← (const byte) BLACK
  to:loop::plexFreeNextYpos1
loop::plexFreeNextYpos1: scope:[loop]  from loop::@7
  [66] (byte) loop::plexFreeNextYpos1_return#0 ← *((const byte*) PLEX_FREE_YPOS + (byte) plex_free_next#17)
  to:loop::@8
loop::@8: scope:[loop]  from loop::@8 loop::plexFreeNextYpos1
  [67] if(*((const byte*) RASTER)<(byte) loop::plexFreeNextYpos1_return#0) goto loop::@8
  to:loop::@9
loop::@9: scope:[loop]  from loop::@8
  [68] *((const byte*) BORDERCOL) ← ++ *((const byte*) BORDERCOL)
  [69] call plexShowSprite 
  to:loop::@14
loop::@14: scope:[loop]  from loop::@9
  [70] (byte) loop::i1#1 ← ++ (byte) loop::i1#5
  [71] if((byte) loop::i1#1!=(const byte) PLEX_COUNT-(byte) 1+(byte) 1) goto loop::@7
  to:loop::@10
loop::@10: scope:[loop]  from loop::@14
  [72] *((const byte*) BORDERCOL) ← (const byte) BLACK
  [73] call keyboard_key_pressed 
  [74] (byte) keyboard_key_pressed::return#3 ← (byte) keyboard_key_pressed::return#0
  to:loop::@15
loop::@15: scope:[loop]  from loop::@10
  [75] (byte~) loop::$18 ← (byte) keyboard_key_pressed::return#3
  [76] if((byte) 0!=(byte~) loop::$18) goto loop::@return
  to:loop::@1
loop::@return: scope:[loop]  from loop::@15
  [77] return 
  to:@return

(void()) plexShowSprite()
plexShowSprite: scope:[plexShowSprite]  from loop::@9
  [78] (byte) plexShowSprite::plex_sprite_idx2#0 ← (byte) plex_sprite_idx#43 << (byte) 1
  [79] (byte) plexShowSprite::plexFreeAdd1_ypos#0 ← *((const byte*) PLEX_YPOS + *((const byte*) PLEX_SORTED_IDX + (byte) plex_show_idx#43))
  [80] *((const byte*) SPRITES_YPOS + (byte) plexShowSprite::plex_sprite_idx2#0) ← (byte) plexShowSprite::plexFreeAdd1_ypos#0
  to:plexShowSprite::plexFreeAdd1
plexShowSprite::plexFreeAdd1: scope:[plexShowSprite]  from plexShowSprite
  [81] (byte~) plexShowSprite::plexFreeAdd1_$0 ← (byte) plexShowSprite::plexFreeAdd1_ypos#0 + (byte) $15
  [82] *((const byte*) PLEX_FREE_YPOS + (byte) plex_free_next#17) ← (byte~) plexShowSprite::plexFreeAdd1_$0
  [83] (byte~) plexShowSprite::plexFreeAdd1_$1 ← (byte) plex_free_next#17 + (byte) 1
  [84] (byte) plex_free_next#13 ← (byte~) plexShowSprite::plexFreeAdd1_$1 & (byte) 7
  to:plexShowSprite::@4
plexShowSprite::@4: scope:[plexShowSprite]  from plexShowSprite::plexFreeAdd1
  [85] *((const byte*) PLEX_SCREEN_PTR#1 + (byte) plex_sprite_idx#43) ← *((const byte*) PLEX_PTR + *((const byte*) PLEX_SORTED_IDX + (byte) plex_show_idx#43))
  [86] (byte) plexShowSprite::xpos_idx#0 ← *((const byte*) PLEX_SORTED_IDX + (byte) plex_show_idx#43)
  [87] (byte~) plexShowSprite::$11 ← (byte) plexShowSprite::xpos_idx#0 << (byte) 1
  [88] (byte~) plexShowSprite::$2 ← < *((const word*) PLEX_XPOS + (byte~) plexShowSprite::$11)
  [89] *((const byte*) SPRITES_XPOS + (byte) plexShowSprite::plex_sprite_idx2#0) ← (byte~) plexShowSprite::$2
  [90] (byte~) plexShowSprite::$3 ← > *((const word*) PLEX_XPOS + (byte~) plexShowSprite::$11)
  [91] if((byte~) plexShowSprite::$3!=(byte) 0) goto plexShowSprite::@1
  to:plexShowSprite::@3
plexShowSprite::@3: scope:[plexShowSprite]  from plexShowSprite::@4
  [92] (byte~) plexShowSprite::$9 ← (byte) $ff ^ (byte) plex_sprite_msb#43
  [93] *((const byte*) SPRITES_XMSB) ← *((const byte*) SPRITES_XMSB) & (byte~) plexShowSprite::$9
  to:plexShowSprite::@2
plexShowSprite::@2: scope:[plexShowSprite]  from plexShowSprite::@1 plexShowSprite::@3
  [94] (byte~) plexShowSprite::$5 ← (byte) plex_sprite_idx#43 + (byte) 1
  [95] (byte) plex_sprite_idx#15 ← (byte~) plexShowSprite::$5 & (byte) 7
  [96] (byte) plex_show_idx#15 ← ++ (byte) plex_show_idx#43
  [97] (byte) plex_sprite_msb#3 ← (byte) plex_sprite_msb#43 << (byte) 1
  [98] if((byte) plex_sprite_msb#3!=(byte) 0) goto plexShowSprite::@5
  to:plexShowSprite::@return
plexShowSprite::@5: scope:[plexShowSprite]  from plexShowSprite::@2
  [99] phi()
  to:plexShowSprite::@return
plexShowSprite::@return: scope:[plexShowSprite]  from plexShowSprite::@2 plexShowSprite::@5
  [100] (byte) plex_sprite_msb#16 ← phi( plexShowSprite::@5/(byte) plex_sprite_msb#3 plexShowSprite::@2/(byte) 1 )
  [101] return 
  to:@return
plexShowSprite::@1: scope:[plexShowSprite]  from plexShowSprite::@4
  [102] *((const byte*) SPRITES_XMSB) ← *((const byte*) SPRITES_XMSB) | (byte) plex_sprite_msb#43
  to:plexShowSprite::@2

(void()) plexSort()
plexSort: scope:[plexSort]  from loop::@5
  [103] phi()
  to:plexSort::@1
plexSort::@1: scope:[plexSort]  from plexSort plexSort::@2
  [104] (byte) plexSort::m#2 ← phi( plexSort/(byte) 0 plexSort::@2/(byte) plexSort::m#1 )
  [105] (byte) plexSort::nxt_idx#0 ← *((const byte*) PLEX_SORTED_IDX+(byte) 1 + (byte) plexSort::m#2)
  [106] (byte) plexSort::nxt_y#0 ← *((const byte*) PLEX_YPOS + (byte) plexSort::nxt_idx#0)
  [107] if((byte) plexSort::nxt_y#0>=*((const byte*) PLEX_YPOS + *((const byte*) PLEX_SORTED_IDX + (byte) plexSort::m#2))) goto plexSort::@2
  to:plexSort::@5
plexSort::@5: scope:[plexSort]  from plexSort::@1
  [108] (byte) plexSort::s#6 ← (byte) plexSort::m#2
  to:plexSort::@3
plexSort::@3: scope:[plexSort]  from plexSort::@5 plexSort::@6
  [109] (byte) plexSort::s#3 ← phi( plexSort::@6/(byte) plexSort::s#1 plexSort::@5/(byte) plexSort::s#6 )
  [110] *((const byte*) PLEX_SORTED_IDX+(byte) 1 + (byte) plexSort::s#3) ← *((const byte*) PLEX_SORTED_IDX + (byte) plexSort::s#3)
  [111] (byte) plexSort::s#1 ← -- (byte) plexSort::s#3
  [112] if((byte) plexSort::s#1==(byte) $ff) goto plexSort::@4
  to:plexSort::@6
plexSort::@6: scope:[plexSort]  from plexSort::@3
  [113] if((byte) plexSort::nxt_y#0<*((const byte*) PLEX_YPOS + *((const byte*) PLEX_SORTED_IDX + (byte) plexSort::s#1))) goto plexSort::@3
  to:plexSort::@4
plexSort::@4: scope:[plexSort]  from plexSort::@3 plexSort::@6
  [114] (byte) plexSort::s#2 ← ++ (byte) plexSort::s#1
  [115] *((const byte*) PLEX_SORTED_IDX + (byte) plexSort::s#2) ← (byte) plexSort::nxt_idx#0
  to:plexSort::@2
plexSort::@2: scope:[plexSort]  from plexSort::@1 plexSort::@4
  [116] (byte) plexSort::m#1 ← ++ (byte) plexSort::m#2
  [117] if((byte) plexSort::m#1!=(const byte) PLEX_COUNT-(byte) 2+(byte) 1) goto plexSort::@1
  to:plexSort::plexFreePrepare1
plexSort::plexFreePrepare1: scope:[plexSort]  from plexSort::@2
  [118] phi()
  to:plexSort::plexFreePrepare1_@1
plexSort::plexFreePrepare1_@1: scope:[plexSort]  from plexSort::plexFreePrepare1 plexSort::plexFreePrepare1_@1
  [119] (byte) plexSort::plexFreePrepare1_s#2 ← phi( plexSort::plexFreePrepare1/(byte) 0 plexSort::plexFreePrepare1_@1/(byte) plexSort::plexFreePrepare1_s#1 )
  [120] *((const byte*) PLEX_FREE_YPOS + (byte) plexSort::plexFreePrepare1_s#2) ← (byte) 0
  [121] (byte) plexSort::plexFreePrepare1_s#1 ← ++ (byte) plexSort::plexFreePrepare1_s#2
  [122] if((byte) plexSort::plexFreePrepare1_s#1!=(byte) 8) goto plexSort::plexFreePrepare1_@1
  to:plexSort::@return
plexSort::@return: scope:[plexSort]  from plexSort::plexFreePrepare1_@1
  [123] return 
  to:@return

(signed word()) mulf8s((signed byte) mulf8s::a , (signed byte) mulf8s::b)
mulf8s: scope:[mulf8s]  from loop::@11 loop::@4
  [124] (signed byte) mulf8s::b#2 ← phi( loop::@11/(signed byte) mulf8s::b#1 loop::@4/(signed byte) mulf8s::b#0 )
  [124] (signed byte) mulf8s::mulf8s_prepare1_a#0 ← phi( loop::@11/(signed byte) mulf8s::a#1 loop::@4/(signed byte) mulf8s::a#0 )
  to:mulf8s::mulf8s_prepare1
mulf8s::mulf8s_prepare1: scope:[mulf8s]  from mulf8s
  [125] (byte) mulf8u_prepare::a#0 ← (byte)(signed byte) mulf8s::mulf8s_prepare1_a#0
  [126] call mulf8u_prepare 
  to:mulf8s::@1
mulf8s::@1: scope:[mulf8s]  from mulf8s::mulf8s_prepare1
  [127] (signed byte) mulf8s_prepared::b#0 ← (signed byte) mulf8s::b#2
  [128] call mulf8s_prepared 
  to:mulf8s::@2
mulf8s::@2: scope:[mulf8s]  from mulf8s::@1
  [129] (signed word) mulf8s::return#0 ← (signed word)(word) mulf8s_prepared::m#4
  to:mulf8s::@return
mulf8s::@return: scope:[mulf8s]  from mulf8s::@2
  [130] return 
  to:@return

(signed word()) mulf8s_prepared((signed byte) mulf8s_prepared::b)
mulf8s_prepared: scope:[mulf8s_prepared]  from mulf8s::@1
  [131] (byte) mulf8u_prepared::b#0 ← (byte)(signed byte) mulf8s_prepared::b#0
  [132] call mulf8u_prepared 
  [133] (word) mulf8u_prepared::return#2 ← (word) mulf8u_prepared::return#0
  to:mulf8s_prepared::@5
mulf8s_prepared::@5: scope:[mulf8s_prepared]  from mulf8s_prepared
  [134] (word) mulf8s_prepared::m#0 ← (word) mulf8u_prepared::return#2
  [135] if(*((const signed byte*) mulf8s_prepared::memA)>=(signed byte) 0) goto mulf8s_prepared::@1
  to:mulf8s_prepared::@3
mulf8s_prepared::@3: scope:[mulf8s_prepared]  from mulf8s_prepared::@5
  [136] (byte~) mulf8s_prepared::$8 ← > (word) mulf8s_prepared::m#0
  [137] (byte~) mulf8s_prepared::$15 ← (byte~) mulf8s_prepared::$8 - (byte)(signed byte) mulf8s_prepared::b#0
  [138] (word) mulf8s_prepared::m#1 ← (word) mulf8s_prepared::m#0 hi= (byte~) mulf8s_prepared::$15
  to:mulf8s_prepared::@1
mulf8s_prepared::@1: scope:[mulf8s_prepared]  from mulf8s_prepared::@3 mulf8s_prepared::@5
  [139] (word) mulf8s_prepared::m#5 ← phi( mulf8s_prepared::@3/(word) mulf8s_prepared::m#1 mulf8s_prepared::@5/(word) mulf8s_prepared::m#0 )
  [140] if((signed byte) mulf8s_prepared::b#0>=(signed byte) 0) goto mulf8s_prepared::@2
  to:mulf8s_prepared::@4
mulf8s_prepared::@4: scope:[mulf8s_prepared]  from mulf8s_prepared::@1
  [141] (byte~) mulf8s_prepared::$12 ← > (word) mulf8s_prepared::m#5
  [142] (byte~) mulf8s_prepared::$16 ← (byte~) mulf8s_prepared::$12 - (byte)*((const signed byte*) mulf8s_prepared::memA)
  [143] (word) mulf8s_prepared::m#2 ← (word) mulf8s_prepared::m#5 hi= (byte~) mulf8s_prepared::$16
  to:mulf8s_prepared::@2
mulf8s_prepared::@2: scope:[mulf8s_prepared]  from mulf8s_prepared::@1 mulf8s_prepared::@4
  [144] (word) mulf8s_prepared::m#4 ← phi( mulf8s_prepared::@1/(word) mulf8s_prepared::m#5 mulf8s_prepared::@4/(word) mulf8s_prepared::m#2 )
  to:mulf8s_prepared::@return
mulf8s_prepared::@return: scope:[mulf8s_prepared]  from mulf8s_prepared::@2
  [145] return 
  to:@return

(word()) mulf8u_prepared((byte) mulf8u_prepared::b)
mulf8u_prepared: scope:[mulf8u_prepared]  from mulf8s_prepared
  [146] *((const byte*) mulf8u_prepared::memB) ← (byte) mulf8u_prepared::b#0
  asm { ldxmemB sec sm1: ldamulf_sqr1_lo,x sm2: sbcmulf_sqr2_lo,x staresL sm3: ldamulf_sqr1_hi,x sm4: sbcmulf_sqr2_hi,x stamemB  }
  [148] (word) mulf8u_prepared::return#0 ← *((const byte*) mulf8u_prepared::memB) w= *((const byte*) mulf8u_prepared::resL)
  to:mulf8u_prepared::@return
mulf8u_prepared::@return: scope:[mulf8u_prepared]  from mulf8u_prepared
  [149] return 
  to:@return

(void()) mulf8u_prepare((byte) mulf8u_prepare::a)
mulf8u_prepare: scope:[mulf8u_prepare]  from mulf8s::mulf8s_prepare1
  [150] *((const byte*) mulf8u_prepare::memA) ← (byte) mulf8u_prepare::a#0
  asm { ldamemA stamulf8u_prepared.sm1+1 stamulf8u_prepared.sm3+1 eor#$ff stamulf8u_prepared.sm2+1 stamulf8u_prepared.sm4+1  }
  to:mulf8u_prepare::@return
mulf8u_prepare::@return: scope:[mulf8u_prepare]  from mulf8u_prepare
  [152] return 
  to:@return

(void()) init()
init: scope:[init]  from main
  [153] *((const byte*) D011) ← (const byte) VIC_DEN|(const byte) VIC_RSEL|(byte) 3
  [154] call plexInit 
  to:init::@1
init::@1: scope:[init]  from init init::@1
  [155] (byte) init::i#2 ← phi( init::@1/(byte) init::i#1 init/(byte) 0 )
  [156] *((const byte*) PLEX_PTR + (byte) init::i#2) ← (byte)(const byte*) SPRITE/(byte) $40
  [157] (byte~) init::$10 ← (byte) init::i#2 << (byte) 2
  [158] (byte~) init::$3 ← (byte~) init::$10 + (byte) init::i#2
  [159] (byte~) init::$4 ← (byte) $18 + (byte~) init::$3
  [160] (byte~) init::$9 ← (byte) init::i#2 << (byte) 1
  [161] *((const word*) PLEX_XPOS + (byte~) init::$9) ← (byte~) init::$4
  [162] (byte~) init::$5 ← (byte) init::i#2 << (byte) 3
  [163] (byte~) init::$6 ← (byte) $32 + (byte~) init::$5
  [164] *((const byte*) PLEX_YPOS + (byte) init::i#2) ← (byte~) init::$6
  [165] (byte) init::i#1 ← ++ (byte) init::i#2
  [166] if((byte) init::i#1!=(const byte) PLEX_COUNT-(byte) 1+(byte) 1) goto init::@1
  to:init::@2
init::@2: scope:[init]  from init::@1
  [167] *((const byte*) SPRITES_ENABLE) ← (byte) $ff
  to:init::@3
init::@3: scope:[init]  from init::@2 init::@3
  [168] (byte) init::i1#2 ← phi( init::@2/(byte) 0 init::@3/(byte) init::i1#1 )
  [169] *((const byte*) SPRITES_COLS + (byte) init::i1#2) ← (const byte) GREEN
  [170] (byte) init::i1#1 ← ++ (byte) init::i1#2
  [171] if((byte) init::i1#1!=(byte) 8) goto init::@3
  to:init::@4
init::@4: scope:[init]  from init::@3
  [172] phi()
  [173] call mulf_init 
  to:init::@5
init::@5: scope:[init]  from init::@4
  [174] phi()
  [175] call memset 
  to:init::@return
init::@return: scope:[init]  from init::@5
  [176] return 
  to:@return

(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num)
memset: scope:[memset]  from init::@5
  [177] phi()
  to:memset::@1
memset::@1: scope:[memset]  from memset memset::@2
  [178] (byte*) memset::dst#2 ← phi( memset/(byte*)(const void*) memset::str#0 memset::@2/(byte*) memset::dst#1 )
  [179] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2
  to:memset::@return
memset::@return: scope:[memset]  from memset::@1
  [180] return 
  to:@return
memset::@2: scope:[memset]  from memset::@1
  [181] *((byte*) memset::dst#2) ← (const byte) memset::c#0
  [182] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2
  to:memset::@1

(void()) mulf_init()
mulf_init: scope:[mulf_init]  from init::@4
  [183] phi()
  to:mulf_init::@1
mulf_init::@1: scope:[mulf_init]  from mulf_init mulf_init::@3
  [184] (byte) mulf_init::x_2#3 ← phi( mulf_init/(byte) 0 mulf_init::@3/(byte) mulf_init::x_2#2 )
  [184] (byte*) mulf_init::sqr1_hi#2 ← phi( mulf_init/(const byte*) mulf_sqr1_hi+(byte) 1 mulf_init::@3/(byte*) mulf_init::sqr1_hi#1 )
  [184] (word) mulf_init::sqr#4 ← phi( mulf_init/(word) 0 mulf_init::@3/(word) mulf_init::sqr#1 )
  [184] (byte) mulf_init::c#2 ← phi( mulf_init/(byte) 0 mulf_init::@3/(byte) mulf_init::c#1 )
  [184] (byte*) mulf_init::sqr1_lo#2 ← phi( mulf_init/(const byte*) mulf_sqr1_lo+(byte) 1 mulf_init::@3/(byte*) mulf_init::sqr1_lo#1 )
  [185] if((byte*) mulf_init::sqr1_lo#2!=(const byte*) mulf_sqr1_lo+(word) $200) goto mulf_init::@2
  to:mulf_init::@5
mulf_init::@5: scope:[mulf_init]  from mulf_init::@1 mulf_init::@8
  [186] (byte) mulf_init::dir#2 ← phi( mulf_init::@8/(byte) mulf_init::dir#4 mulf_init::@1/(byte) $ff )
  [186] (byte*) mulf_init::sqr2_hi#2 ← phi( mulf_init::@8/(byte*) mulf_init::sqr2_hi#1 mulf_init::@1/(const byte*) mulf_sqr2_hi )
  [186] (byte) mulf_init::x_255#2 ← phi( mulf_init::@8/(byte) mulf_init::x_255#1 mulf_init::@1/(byte) -1 )
  [186] (byte*) mulf_init::sqr2_lo#2 ← phi( mulf_init::@8/(byte*) mulf_init::sqr2_lo#1 mulf_init::@1/(const byte*) mulf_sqr2_lo )
  [187] if((byte*) mulf_init::sqr2_lo#2!=(const byte*) mulf_sqr2_lo+(word) $1ff) goto mulf_init::@6
  to:mulf_init::@7
mulf_init::@7: scope:[mulf_init]  from mulf_init::@5
  [188] *((const byte*) mulf_sqr2_lo+(word) $1ff) ← *((const byte*) mulf_sqr1_lo+(word) $100)
  [189] *((const byte*) mulf_sqr2_hi+(word) $1ff) ← *((const byte*) mulf_sqr1_hi+(word) $100)
  to:mulf_init::@return
mulf_init::@return: scope:[mulf_init]  from mulf_init::@7
  [190] return 
  to:@return
mulf_init::@6: scope:[mulf_init]  from mulf_init::@5
  [191] *((byte*) mulf_init::sqr2_lo#2) ← *((const byte*) mulf_sqr1_lo + (byte) mulf_init::x_255#2)
  [192] *((byte*) mulf_init::sqr2_hi#2) ← *((const byte*) mulf_sqr1_hi + (byte) mulf_init::x_255#2)
  [193] (byte*) mulf_init::sqr2_hi#1 ← ++ (byte*) mulf_init::sqr2_hi#2
  [194] (byte) mulf_init::x_255#1 ← (byte) mulf_init::x_255#2 + (byte) mulf_init::dir#2
  [195] if((byte) mulf_init::x_255#1!=(byte) 0) goto mulf_init::@9
  to:mulf_init::@8
mulf_init::@9: scope:[mulf_init]  from mulf_init::@6
  [196] phi()
  to:mulf_init::@8
mulf_init::@8: scope:[mulf_init]  from mulf_init::@6 mulf_init::@9
  [197] (byte) mulf_init::dir#4 ← phi( mulf_init::@9/(byte) mulf_init::dir#2 mulf_init::@6/(byte) 1 )
  [198] (byte*) mulf_init::sqr2_lo#1 ← ++ (byte*) mulf_init::sqr2_lo#2
  to:mulf_init::@5
mulf_init::@2: scope:[mulf_init]  from mulf_init::@1
  [199] (byte) mulf_init::c#1 ← ++ (byte) mulf_init::c#2
  [200] (byte~) mulf_init::$1 ← (byte) mulf_init::c#1 & (byte) 1
  [201] if((byte~) mulf_init::$1!=(byte) 0) goto mulf_init::@3
  to:mulf_init::@4
mulf_init::@4: scope:[mulf_init]  from mulf_init::@2
  [202] (byte) mulf_init::x_2#1 ← ++ (byte) mulf_init::x_2#3
  [203] (word) mulf_init::sqr#2 ← ++ (word) mulf_init::sqr#4
  to:mulf_init::@3
mulf_init::@3: scope:[mulf_init]  from mulf_init::@2 mulf_init::@4
  [204] (byte) mulf_init::x_2#2 ← phi( mulf_init::@2/(byte) mulf_init::x_2#3 mulf_init::@4/(byte) mulf_init::x_2#1 )
  [204] (word) mulf_init::sqr#3 ← phi( mulf_init::@2/(word) mulf_init::sqr#4 mulf_init::@4/(word) mulf_init::sqr#2 )
  [205] (byte~) mulf_init::$4 ← < (word) mulf_init::sqr#3
  [206] *((byte*) mulf_init::sqr1_lo#2) ← (byte~) mulf_init::$4
  [207] (byte~) mulf_init::$5 ← > (word) mulf_init::sqr#3
  [208] *((byte*) mulf_init::sqr1_hi#2) ← (byte~) mulf_init::$5
  [209] (byte*) mulf_init::sqr1_hi#1 ← ++ (byte*) mulf_init::sqr1_hi#2
  [210] (word) mulf_init::sqr#1 ← (word) mulf_init::sqr#3 + (byte) mulf_init::x_2#2
  [211] (byte*) mulf_init::sqr1_lo#1 ← ++ (byte*) mulf_init::sqr1_lo#2
  to:mulf_init::@1

(void()) plexInit((byte*) plexInit::screen)
plexInit: scope:[plexInit]  from init
  [212] phi()
  to:plexInit::plexSetScreen1
plexInit::plexSetScreen1: scope:[plexInit]  from plexInit
  [213] phi()
  to:plexInit::@1
plexInit::@1: scope:[plexInit]  from plexInit::@1 plexInit::plexSetScreen1
  [214] (byte) plexInit::i#2 ← phi( plexInit::@1/(byte) plexInit::i#1 plexInit::plexSetScreen1/(byte) 0 )
  [215] *((const byte*) PLEX_SORTED_IDX + (byte) plexInit::i#2) ← (byte) plexInit::i#2
  [216] (byte) plexInit::i#1 ← ++ (byte) plexInit::i#2
  [217] if((byte) plexInit::i#1!=(const byte) PLEX_COUNT-(byte) 1+(byte) 1) goto plexInit::@1
  to:plexInit::@return
plexInit::@return: scope:[plexInit]  from plexInit::@1
  [218] return 
  to:@return
