@begin: scope:[]  from
  [0] phi()
  to:@1
@1: scope:[]  from @begin
  kickasm(location (const byte*) SPRITE) {{ .var pic = LoadPicture("balloon.png", List().add($000000, $ffffff))
    .for (var y=0; y<21; y++)
        .for (var x=0;x<3; x++)
            .byte pic.getSinglecolorByte(x,y)
 }}
  [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 anim 
  to:main::@return
main::@return: scope:[main]  from main::@1
  [8] return 
  to:@return

(void()) anim()
anim: scope:[anim]  from main::@1
  [9] phi()
  to:anim::@1
anim::@1: scope:[anim]  from anim anim::@15
  [10] (byte) anim::angle#9 ← phi( anim/(byte) 0 anim::@15/(byte) anim::angle#1 )
  to:anim::@2
anim::@2: scope:[anim]  from anim::@1 anim::@2
  [11] if(*((const byte*) RASTER)!=(byte) $ff) goto anim::@2
  to:anim::@3
anim::@3: scope:[anim]  from anim::@2
  [12] *((const byte*) BORDERCOL) ← ++ *((const byte*) BORDERCOL)
  [13] call clock_start 
  to:anim::@4
anim::@4: scope:[anim]  from anim::@3 anim::@5
  [14] (byte) anim::sprite_msb#10 ← phi( anim::@5/(byte) anim::sprite_msb#5 anim::@3/(byte) 0 )
  [14] (byte) anim::i#10 ← phi( anim::@5/(byte) anim::i#1 anim::@3/(byte) 0 )
  [15] (signed byte) anim::x#0 ← *((const signed byte*) xs + (byte) anim::i#10)
  [16] (signed byte) anim::y#0 ← *((const signed byte*) ys + (byte) anim::i#10)
  to:anim::mulf8s_prepare1
anim::mulf8s_prepare1: scope:[anim]  from anim::@4
  [17] (byte) mulf8u_prepare::a#3 ← (byte)(signed byte)*((const byte*) COS + (byte) anim::angle#9)
  [18] call mulf8u_prepare 
  to:anim::@8
anim::@8: scope:[anim]  from anim::mulf8s_prepare1
  [19] (signed byte) mulf8s_prepared::b#0 ← (signed byte) anim::x#0
  [20] call mulf8s_prepared 
  to:anim::@10
anim::@10: scope:[anim]  from anim::@8
  [21] (signed word~) anim::$6 ← (signed word)(word) mulf8s_prepared::m#4
  [22] (signed word) anim::xr#0 ← (signed word~) anim::$6 << (byte) 1
  [23] (signed byte) mulf8s_prepared::b#1 ← (signed byte) anim::y#0
  [24] call mulf8s_prepared 
  to:anim::@11
anim::@11: scope:[anim]  from anim::@10
  [25] (signed word~) anim::$8 ← (signed word)(word) mulf8s_prepared::m#4
  [26] (signed word) anim::yr#0 ← (signed word~) anim::$8 << (byte) 1
  to:anim::mulf8s_prepare2
anim::mulf8s_prepare2: scope:[anim]  from anim::@11
  [27] (byte) mulf8u_prepare::a#4 ← (byte)(signed byte)*((const byte*) SIN + (byte) anim::angle#9)
  [28] call mulf8u_prepare 
  to:anim::@9
anim::@9: scope:[anim]  from anim::mulf8s_prepare2
  [29] (signed byte) mulf8s_prepared::b#2 ← (signed byte) anim::y#0
  [30] call mulf8s_prepared 
  to:anim::@12
anim::@12: scope:[anim]  from anim::@9
  [31] (signed word~) anim::$11 ← (signed word)(word) mulf8s_prepared::m#4
  [32] (signed word~) anim::$12 ← (signed word~) anim::$11 << (byte) 1
  [33] (signed word) anim::xr#1 ← (signed word) anim::xr#0 - (signed word~) anim::$12
  [34] (signed byte) mulf8s_prepared::b#3 ← (signed byte) anim::x#0
  [35] call mulf8s_prepared 
  to:anim::@13
anim::@13: scope:[anim]  from anim::@12
  [36] (signed word~) anim::$13 ← (signed word)(word) mulf8s_prepared::m#4
  [37] (signed word~) anim::$14 ← (signed word~) anim::$13 << (byte) 1
  [38] (signed word) anim::yr#1 ← (signed word) anim::yr#0 + (signed word~) anim::$14
  [39] (byte~) anim::$17 ← > (signed word) anim::xr#1
  [40] (signed word) anim::xpos#0 ← (signed byte)(byte~) anim::$17 + (signed byte) $18+(signed word) $95
  [41] (byte) anim::sprite_msb#1 ← (byte) anim::sprite_msb#10 >> (byte) 1
  [42] (byte~) anim::$20 ← > (signed word) anim::xpos#0
  [43] if((byte~) anim::$20==(byte) 0) goto anim::@5
  to:anim::@6
anim::@6: scope:[anim]  from anim::@13
  [44] (byte) anim::sprite_msb#2 ← (byte) anim::sprite_msb#1 | (byte) $80
  to:anim::@5
anim::@5: scope:[anim]  from anim::@13 anim::@6
  [45] (byte) anim::sprite_msb#5 ← phi( anim::@6/(byte) anim::sprite_msb#2 anim::@13/(byte) anim::sprite_msb#1 )
  [46] (byte~) anim::$24 ← > (signed word) anim::yr#1
  [47] (byte) anim::ypos#0 ← (byte~) anim::$24 + (byte) $59+(byte) $33
  [48] (byte) anim::i2#0 ← (byte) anim::i#10 << (byte) 1
  [49] (byte~) anim::$27 ← < (signed word) anim::xpos#0
  [50] *((const byte*) SPRITES_XPOS + (byte) anim::i2#0) ← (byte~) anim::$27
  [51] *((const byte*) SPRITES_YPOS + (byte) anim::i2#0) ← (byte) anim::ypos#0
  [52] (byte) anim::i#1 ← ++ (byte) anim::i#10
  [53] if((byte) anim::i#1!=(byte) 8) goto anim::@4
  to:anim::@7
anim::@7: scope:[anim]  from anim::@5
  [54] *((const byte*) SPRITES_XMSB) ← (byte) anim::sprite_msb#5
  [55] (byte) anim::angle#1 ← ++ (byte) anim::angle#9
  [56] call clock 
  [57] (dword) clock::return#2 ← (dword) clock::return#0
  to:anim::@14
anim::@14: scope:[anim]  from anim::@7
  [58] (dword~) anim::$29 ← (dword) clock::return#2
  [59] (dword) anim::cyclecount#0 ← (dword~) anim::$29 - (const dword) CLOCKS_PER_INIT
  [60] (dword) print_dword_at::dw#0 ← (dword) anim::cyclecount#0
  [61] call print_dword_at 
  to:anim::@15
anim::@15: scope:[anim]  from anim::@14
  [62] *((const byte*) BORDERCOL) ← (const byte) LIGHT_BLUE
  to:anim::@1

(void()) print_dword_at((dword) print_dword_at::dw , (byte*) print_dword_at::at)
print_dword_at: scope:[print_dword_at]  from anim::@14
  [63] (word) print_word_at::w#0 ← > (dword) print_dword_at::dw#0
  [64] call print_word_at 
  to:print_dword_at::@1
print_dword_at::@1: scope:[print_dword_at]  from print_dword_at
  [65] (word) print_word_at::w#1 ← < (dword) print_dword_at::dw#0
  [66] call print_word_at 
  to:print_dword_at::@return
print_dword_at::@return: scope:[print_dword_at]  from print_dword_at::@1
  [67] return 
  to:@return

(void()) print_word_at((word) print_word_at::w , (byte*) print_word_at::at)
print_word_at: scope:[print_word_at]  from print_dword_at print_dword_at::@1
  [68] (byte*) print_word_at::at#2 ← phi( print_dword_at/(const byte*) SCREEN print_dword_at::@1/(const byte*) SCREEN+(byte) 4 )
  [68] (word) print_word_at::w#2 ← phi( print_dword_at/(word) print_word_at::w#0 print_dword_at::@1/(word) print_word_at::w#1 )
  [69] (byte) print_byte_at::b#0 ← > (word) print_word_at::w#2
  [70] (byte*) print_byte_at::at#0 ← (byte*) print_word_at::at#2
  [71] call print_byte_at 
  to:print_word_at::@1
print_word_at::@1: scope:[print_word_at]  from print_word_at
  [72] (byte) print_byte_at::b#1 ← < (word) print_word_at::w#2
  [73] (byte*) print_byte_at::at#1 ← (byte*) print_word_at::at#2 + (byte) 2
  [74] call print_byte_at 
  to:print_word_at::@return
print_word_at::@return: scope:[print_word_at]  from print_word_at::@1
  [75] return 
  to:@return

(void()) print_byte_at((byte) print_byte_at::b , (byte*) print_byte_at::at)
print_byte_at: scope:[print_byte_at]  from print_word_at print_word_at::@1
  [76] (byte*) print_byte_at::at#2 ← phi( print_word_at/(byte*) print_byte_at::at#0 print_word_at::@1/(byte*) print_byte_at::at#1 )
  [76] (byte) print_byte_at::b#2 ← phi( print_word_at/(byte) print_byte_at::b#0 print_word_at::@1/(byte) print_byte_at::b#1 )
  [77] (byte~) print_byte_at::$0 ← (byte) print_byte_at::b#2 >> (byte) 4
  [78] (byte) print_char_at::ch#0 ← *((const byte*) print_hextab + (byte~) print_byte_at::$0)
  [79] (byte*) print_char_at::at#0 ← (byte*) print_byte_at::at#2
  [80] call print_char_at 
  to:print_byte_at::@1
print_byte_at::@1: scope:[print_byte_at]  from print_byte_at
  [81] (byte~) print_byte_at::$2 ← (byte) print_byte_at::b#2 & (byte) $f
  [82] (byte*) print_char_at::at#1 ← (byte*) print_byte_at::at#2 + (byte) 1
  [83] (byte) print_char_at::ch#1 ← *((const byte*) print_hextab + (byte~) print_byte_at::$2)
  [84] call print_char_at 
  to:print_byte_at::@return
print_byte_at::@return: scope:[print_byte_at]  from print_byte_at::@1
  [85] return 
  to:@return

(void()) print_char_at((byte) print_char_at::ch , (byte*) print_char_at::at)
print_char_at: scope:[print_char_at]  from print_byte_at print_byte_at::@1
  [86] (byte*) print_char_at::at#2 ← phi( print_byte_at/(byte*) print_char_at::at#0 print_byte_at::@1/(byte*) print_char_at::at#1 )
  [86] (byte) print_char_at::ch#2 ← phi( print_byte_at/(byte) print_char_at::ch#0 print_byte_at::@1/(byte) print_char_at::ch#1 )
  [87] *((byte*) print_char_at::at#2) ← (byte) print_char_at::ch#2
  to:print_char_at::@return
print_char_at::@return: scope:[print_char_at]  from print_char_at
  [88] return 
  to:@return

(dword()) clock()
clock: scope:[clock]  from anim::@7
  [89] (dword) clock::return#0 ← (dword) $ffffffff - *((const dword*) CIA2_TIMER_AB)
  to:clock::@return
clock::@return: scope:[clock]  from clock
  [90] return 
  to:@return

(signed word()) mulf8s_prepared((signed byte) mulf8s_prepared::b)
mulf8s_prepared: scope:[mulf8s_prepared]  from anim::@10 anim::@12 anim::@8 anim::@9
  [91] (signed byte) mulf8s_prepared::b#4 ← phi( anim::@8/(signed byte) mulf8s_prepared::b#0 anim::@9/(signed byte) mulf8s_prepared::b#2 anim::@10/(signed byte) mulf8s_prepared::b#1 anim::@12/(signed byte) mulf8s_prepared::b#3 )
  [92] (byte) mulf8u_prepared::b#0 ← (byte)(signed byte) mulf8s_prepared::b#4
  [93] call mulf8u_prepared 
  [94] (word) mulf8u_prepared::return#2 ← (word) mulf8u_prepared::return#0
  to:mulf8s_prepared::@5
mulf8s_prepared::@5: scope:[mulf8s_prepared]  from mulf8s_prepared
  [95] (word) mulf8s_prepared::m#0 ← (word) mulf8u_prepared::return#2
  [96] 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
  [97] (byte~) mulf8s_prepared::$8 ← > (word) mulf8s_prepared::m#0
  [98] (byte~) mulf8s_prepared::$15 ← (byte~) mulf8s_prepared::$8 - (byte)(signed byte) mulf8s_prepared::b#4
  [99] (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
  [100] (word) mulf8s_prepared::m#5 ← phi( mulf8s_prepared::@3/(word) mulf8s_prepared::m#1 mulf8s_prepared::@5/(word) mulf8s_prepared::m#0 )
  [101] if((signed byte) mulf8s_prepared::b#4>=(signed byte) 0) goto mulf8s_prepared::@2
  to:mulf8s_prepared::@4
mulf8s_prepared::@4: scope:[mulf8s_prepared]  from mulf8s_prepared::@1
  [102] (byte~) mulf8s_prepared::$12 ← > (word) mulf8s_prepared::m#5
  [103] (byte~) mulf8s_prepared::$16 ← (byte~) mulf8s_prepared::$12 - (byte)*((const signed byte*) mulf8s_prepared::memA)
  [104] (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
  [105] (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
  [106] return 
  to:@return

(word()) mulf8u_prepared((byte) mulf8u_prepared::b)
mulf8u_prepared: scope:[mulf8u_prepared]  from mulf8s_prepared
  [107] *((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  }
  [109] (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
  [110] return 
  to:@return

(void()) mulf8u_prepare((byte) mulf8u_prepare::a)
mulf8u_prepare: scope:[mulf8u_prepare]  from anim::mulf8s_prepare1 anim::mulf8s_prepare2
  [111] (byte) mulf8u_prepare::a#2 ← phi( anim::mulf8s_prepare1/(byte) mulf8u_prepare::a#3 anim::mulf8s_prepare2/(byte) mulf8u_prepare::a#4 )
  [112] *((const byte*) mulf8u_prepare::memA) ← (byte) mulf8u_prepare::a#2
  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
  [114] return 
  to:@return

(void()) clock_start()
clock_start: scope:[clock_start]  from anim::@3
  [115] *((const byte*) CIA2_TIMER_A_CONTROL) ← (byte) 0
  [116] *((const byte*) CIA2_TIMER_B_CONTROL) ← (const byte) CIA_TIMER_CONTROL_B_COUNT_UNDERFLOW_A
  [117] *((const dword*) CIA2_TIMER_AB) ← (dword) $ffffffff
  [118] *((const byte*) CIA2_TIMER_B_CONTROL) ← (const byte) CIA_TIMER_CONTROL_START|(const byte) CIA_TIMER_CONTROL_B_COUNT_UNDERFLOW_A
  [119] *((const byte*) CIA2_TIMER_A_CONTROL) ← (const byte) CIA_TIMER_CONTROL_START
  to:clock_start::@return
clock_start::@return: scope:[clock_start]  from clock_start
  [120] return 
  to:@return

(void()) init()
init: scope:[init]  from main
  [121] phi()
  [122] call mulf_init 
  to:init::@2
init::@2: scope:[init]  from init
  [123] *((const byte*) SPRITES_ENABLE) ← (byte) $ff
  to:init::@1
init::@1: scope:[init]  from init::@1 init::@2
  [124] (byte) init::i#2 ← phi( init::@1/(byte) init::i#1 init::@2/(byte) 0 )
  [125] *((const byte*) init::sprites_ptr#0 + (byte) init::i#2) ← (byte)(const byte*) SPRITE/(byte) $40
  [126] *((const byte*) SPRITES_COLS + (byte) init::i#2) ← (const byte) GREEN
  [127] (byte) init::i#1 ← ++ (byte) init::i#2
  [128] if((byte) init::i#1!=(byte) 8) goto init::@1
  to:init::@return
init::@return: scope:[init]  from init::@1
  [129] return 
  to:@return

(void()) mulf_init()
mulf_init: scope:[mulf_init]  from init
  [130] phi()
  to:mulf_init::@1
mulf_init::@1: scope:[mulf_init]  from mulf_init mulf_init::@3
  [131] (byte) mulf_init::x_2#3 ← phi( mulf_init/(byte) 0 mulf_init::@3/(byte) mulf_init::x_2#2 )
  [131] (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 )
  [131] (word) mulf_init::sqr#4 ← phi( mulf_init/(word) 0 mulf_init::@3/(word) mulf_init::sqr#1 )
  [131] (byte) mulf_init::c#2 ← phi( mulf_init/(byte) 0 mulf_init::@3/(byte) mulf_init::c#1 )
  [131] (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 )
  [132] 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
  [133] (byte) mulf_init::dir#2 ← phi( mulf_init::@8/(byte) mulf_init::dir#4 mulf_init::@1/(byte) $ff )
  [133] (byte*) mulf_init::sqr2_hi#2 ← phi( mulf_init::@8/(byte*) mulf_init::sqr2_hi#1 mulf_init::@1/(const byte*) mulf_sqr2_hi )
  [133] (byte) mulf_init::x_255#2 ← phi( mulf_init::@8/(byte) mulf_init::x_255#1 mulf_init::@1/(byte) -1 )
  [133] (byte*) mulf_init::sqr2_lo#2 ← phi( mulf_init::@8/(byte*) mulf_init::sqr2_lo#1 mulf_init::@1/(const byte*) mulf_sqr2_lo )
  [134] 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
  [135] *((const byte*) mulf_sqr2_lo+(word) $1ff) ← *((const byte*) mulf_sqr1_lo+(word) $100)
  [136] *((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
  [137] return 
  to:@return
mulf_init::@6: scope:[mulf_init]  from mulf_init::@5
  [138] *((byte*) mulf_init::sqr2_lo#2) ← *((const byte*) mulf_sqr1_lo + (byte) mulf_init::x_255#2)
  [139] *((byte*) mulf_init::sqr2_hi#2) ← *((const byte*) mulf_sqr1_hi + (byte) mulf_init::x_255#2)
  [140] (byte*) mulf_init::sqr2_hi#1 ← ++ (byte*) mulf_init::sqr2_hi#2
  [141] (byte) mulf_init::x_255#1 ← (byte) mulf_init::x_255#2 + (byte) mulf_init::dir#2
  [142] 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
  [143] phi()
  to:mulf_init::@8
mulf_init::@8: scope:[mulf_init]  from mulf_init::@6 mulf_init::@9
  [144] (byte) mulf_init::dir#4 ← phi( mulf_init::@9/(byte) mulf_init::dir#2 mulf_init::@6/(byte) 1 )
  [145] (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
  [146] (byte) mulf_init::c#1 ← ++ (byte) mulf_init::c#2
  [147] (byte~) mulf_init::$1 ← (byte) mulf_init::c#1 & (byte) 1
  [148] 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
  [149] (byte) mulf_init::x_2#1 ← ++ (byte) mulf_init::x_2#3
  [150] (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
  [151] (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 )
  [151] (word) mulf_init::sqr#3 ← phi( mulf_init::@2/(word) mulf_init::sqr#4 mulf_init::@4/(word) mulf_init::sqr#2 )
  [152] (byte~) mulf_init::$4 ← < (word) mulf_init::sqr#3
  [153] *((byte*) mulf_init::sqr1_lo#2) ← (byte~) mulf_init::$4
  [154] (byte~) mulf_init::$5 ← > (word) mulf_init::sqr#3
  [155] *((byte*) mulf_init::sqr1_hi#2) ← (byte~) mulf_init::$5
  [156] (byte*) mulf_init::sqr1_hi#1 ← ++ (byte*) mulf_init::sqr1_hi#2
  [157] (word) mulf_init::sqr#1 ← (word) mulf_init::sqr#3 + (byte) mulf_init::x_2#2
  [158] (byte*) mulf_init::sqr1_lo#1 ← ++ (byte*) mulf_init::sqr1_lo#2
  to:mulf_init::@1
