@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 setFAC 
  to:main::@2
main::@2: scope:[main]  from main
  [6] phi()
  [7] call divFACby10 
  to:main::@3
main::@3: scope:[main]  from main::@2
  [8] phi()
  [9] call setMEMtoFAC 
  to:main::@1
main::@1: scope:[main]  from main::@15 main::@3
  [10] (byte*) print_line_cursor#13 ← phi( main::@15/(byte*) print_line_cursor#1 main::@3/(byte*) 1024 )
  [10] (byte*) print_char_cursor#32 ← phi( main::@15/(byte*) print_char_cursor#51 main::@3/(byte*) 1024 )
  [10] (byte) main::i#10 ← phi( main::@15/(byte) main::i#1 main::@3/(byte) 1 )
  [11] (word) setFAC::w#1 ← (word)(byte) main::i#10
  [12] call setFAC 
  to:main::@4
main::@4: scope:[main]  from main::@1
  [13] phi()
  [14] call mulFACbyMEM 
  to:main::@5
main::@5: scope:[main]  from main::@4
  [15] phi()
  [16] call setMEMtoFAC 
  to:main::@6
main::@6: scope:[main]  from main::@5
  [17] phi()
  [18] call setFAC 
  to:main::@7
main::@7: scope:[main]  from main::@6
  [19] phi()
  [20] call divMEMbyFAC 
  to:main::@8
main::@8: scope:[main]  from main::@7
  [21] phi()
  [22] call sinFAC 
  to:main::@9
main::@9: scope:[main]  from main::@8
  [23] phi()
  [24] call mulFACbyMEM 
  to:main::@10
main::@10: scope:[main]  from main::@9
  [25] phi()
  [26] call addMEMtoFAC 
  to:main::@11
main::@11: scope:[main]  from main::@10
  [27] phi()
  [28] call getFAC 
  [29] (word) getFAC::return#2 ← (word) getFAC::return#0
  to:main::@12
main::@12: scope:[main]  from main::@11
  [30] (word) print_word::w#0 ← (word) getFAC::return#2
  [31] call print_word 
  to:main::@13
main::@13: scope:[main]  from main::@12
  [32] phi()
  [33] call print_ln 
  to:main::@14
main::@14: scope:[main]  from main::@13
  [34] (byte) main::i#1 ← ++ (byte) main::i#10
  [35] if((byte) main::i#1!=(byte) $1a) goto main::@15
  to:main::@return
main::@return: scope:[main]  from main::@14
  [36] return 
  to:@return
main::@15: scope:[main]  from main::@14
  [37] (byte*) print_char_cursor#51 ← (byte*) print_line_cursor#1
  to:main::@1

(void()) print_ln()
print_ln: scope:[print_ln]  from main::@13
  [38] phi()
  to:print_ln::@1
print_ln::@1: scope:[print_ln]  from print_ln print_ln::@1
  [39] (byte*) print_line_cursor#6 ← phi( print_ln/(byte*) print_line_cursor#13 print_ln::@1/(byte*) print_line_cursor#1 )
  [40] (byte*) print_line_cursor#1 ← (byte*) print_line_cursor#6 + (byte) $28
  [41] if((byte*) print_line_cursor#1<(byte*) print_char_cursor#10) goto print_ln::@1
  to:print_ln::@return
print_ln::@return: scope:[print_ln]  from print_ln::@1
  [42] return 
  to:@return

(void()) print_word((word) print_word::w)
print_word: scope:[print_word]  from main::@12
  [43] (byte) print_byte::b#0 ← > (word) print_word::w#0
  [44] call print_byte 
  to:print_word::@1
print_word::@1: scope:[print_word]  from print_word
  [45] (byte) print_byte::b#1 ← < (word) print_word::w#0
  [46] call print_byte 
  to:print_word::@return
print_word::@return: scope:[print_word]  from print_word::@1
  [47] return 
  to:@return

(void()) print_byte((byte) print_byte::b)
print_byte: scope:[print_byte]  from print_word print_word::@1
  [48] (byte*) print_char_cursor#31 ← phi( print_word/(byte*) print_char_cursor#32 print_word::@1/(byte*) print_char_cursor#10 )
  [48] (byte) print_byte::b#2 ← phi( print_word/(byte) print_byte::b#0 print_word::@1/(byte) print_byte::b#1 )
  [49] (byte~) print_byte::$0 ← (byte) print_byte::b#2 >> (byte) 4
  [50] (byte) print_char::ch#0 ← *((const byte*) print_hextab + (byte~) print_byte::$0)
  [51] call print_char 
  to:print_byte::@1
print_byte::@1: scope:[print_byte]  from print_byte
  [52] (byte~) print_byte::$2 ← (byte) print_byte::b#2 & (byte) $f
  [53] (byte) print_char::ch#1 ← *((const byte*) print_hextab + (byte~) print_byte::$2)
  [54] call print_char 
  to:print_byte::@return
print_byte::@return: scope:[print_byte]  from print_byte::@1
  [55] return 
  to:@return

(void()) print_char((byte) print_char::ch)
print_char: scope:[print_char]  from print_byte print_byte::@1
  [56] (byte*) print_char_cursor#23 ← phi( print_byte/(byte*) print_char_cursor#31 print_byte::@1/(byte*) print_char_cursor#10 )
  [56] (byte) print_char::ch#2 ← phi( print_byte/(byte) print_char::ch#0 print_byte::@1/(byte) print_char::ch#1 )
  [57] *((byte*) print_char_cursor#23) ← (byte) print_char::ch#2
  [58] (byte*) print_char_cursor#10 ← ++ (byte*) print_char_cursor#23
  to:print_char::@return
print_char::@return: scope:[print_char]  from print_char
  [59] return 
  to:@return

(word()) getFAC()
getFAC: scope:[getFAC]  from main::@11
  asm { jsr$b1aa stymemLo stamemHi  }
  [61] (word) getFAC::return#0 ← *((const byte*) memHi) w= *((const byte*) memLo)
  to:getFAC::@return
getFAC::@return: scope:[getFAC]  from getFAC
  [62] return 
  to:@return

(void()) addMEMtoFAC((byte*) addMEMtoFAC::mem)
addMEMtoFAC: scope:[addMEMtoFAC]  from main::@10
  [63] phi()
  to:addMEMtoFAC::prepareMEM1
addMEMtoFAC::prepareMEM1: scope:[addMEMtoFAC]  from addMEMtoFAC
  [64] *((const byte*) memLo) ← <(const word) addMEMtoFAC::prepareMEM1_mem#0
  [65] *((const byte*) memHi) ← >(const word) addMEMtoFAC::prepareMEM1_mem#0
  to:addMEMtoFAC::@1
addMEMtoFAC::@1: scope:[addMEMtoFAC]  from addMEMtoFAC::prepareMEM1
  asm { ldamemLo ldymemHi jsr$b867  }
  to:addMEMtoFAC::@return
addMEMtoFAC::@return: scope:[addMEMtoFAC]  from addMEMtoFAC::@1
  [67] return 
  to:@return

(void()) mulFACbyMEM((byte*) mulFACbyMEM::mem)
mulFACbyMEM: scope:[mulFACbyMEM]  from main::@4 main::@9
  [68] (byte*) mulFACbyMEM::mem#2 ← phi( main::@9/(const byte*) main::f_127 main::@4/(const byte*) main::f_2pi )
  to:mulFACbyMEM::prepareMEM1
mulFACbyMEM::prepareMEM1: scope:[mulFACbyMEM]  from mulFACbyMEM
  [69] (byte~) mulFACbyMEM::prepareMEM1_$0 ← < (word)(byte*) mulFACbyMEM::mem#2
  [70] *((const byte*) memLo) ← (byte~) mulFACbyMEM::prepareMEM1_$0
  [71] (byte~) mulFACbyMEM::prepareMEM1_$1 ← > (word)(byte*) mulFACbyMEM::mem#2
  [72] *((const byte*) memHi) ← (byte~) mulFACbyMEM::prepareMEM1_$1
  to:mulFACbyMEM::@1
mulFACbyMEM::@1: scope:[mulFACbyMEM]  from mulFACbyMEM::prepareMEM1
  asm { ldamemLo ldymemHi jsr$ba28  }
  to:mulFACbyMEM::@return
mulFACbyMEM::@return: scope:[mulFACbyMEM]  from mulFACbyMEM::@1
  [74] return 
  to:@return

(void()) sinFAC()
sinFAC: scope:[sinFAC]  from main::@8
  asm { jsr$e26b  }
  to:sinFAC::@return
sinFAC::@return: scope:[sinFAC]  from sinFAC
  [76] return 
  to:@return

(void()) divMEMbyFAC((byte*) divMEMbyFAC::mem)
divMEMbyFAC: scope:[divMEMbyFAC]  from main::@7
  [77] phi()
  to:divMEMbyFAC::prepareMEM1
divMEMbyFAC::prepareMEM1: scope:[divMEMbyFAC]  from divMEMbyFAC
  [78] *((const byte*) memLo) ← <(const word) divMEMbyFAC::prepareMEM1_mem#0
  [79] *((const byte*) memHi) ← >(const word) divMEMbyFAC::prepareMEM1_mem#0
  to:divMEMbyFAC::@1
divMEMbyFAC::@1: scope:[divMEMbyFAC]  from divMEMbyFAC::prepareMEM1
  asm { ldamemLo ldymemHi jsr$bb0f  }
  to:divMEMbyFAC::@return
divMEMbyFAC::@return: scope:[divMEMbyFAC]  from divMEMbyFAC::@1
  [81] return 
  to:@return

(void()) setFAC((word) setFAC::w)
setFAC: scope:[setFAC]  from main main::@1 main::@6
  [82] (word) setFAC::prepareMEM1_mem#0 ← phi( main/(word) $4fb main::@1/(word) setFAC::w#1 main::@6/(byte) $19 )
  to:setFAC::prepareMEM1
setFAC::prepareMEM1: scope:[setFAC]  from setFAC
  [83] (byte~) setFAC::prepareMEM1_$0 ← < (word) setFAC::prepareMEM1_mem#0
  [84] *((const byte*) memLo) ← (byte~) setFAC::prepareMEM1_$0
  [85] (byte~) setFAC::prepareMEM1_$1 ← > (word) setFAC::prepareMEM1_mem#0
  [86] *((const byte*) memHi) ← (byte~) setFAC::prepareMEM1_$1
  to:setFAC::@1
setFAC::@1: scope:[setFAC]  from setFAC::prepareMEM1
  asm { ldymemLo ldamemHi jsr$b391  }
  to:setFAC::@return
setFAC::@return: scope:[setFAC]  from setFAC::@1
  [88] return 
  to:@return

(void()) setMEMtoFAC((byte*) setMEMtoFAC::mem)
setMEMtoFAC: scope:[setMEMtoFAC]  from main::@3 main::@5
  [89] (byte*) setMEMtoFAC::mem#2 ← phi( main::@3/(const byte*) main::f_127 main::@5/(const byte*) main::f_i )
  to:setMEMtoFAC::prepareMEM1
setMEMtoFAC::prepareMEM1: scope:[setMEMtoFAC]  from setMEMtoFAC
  [90] (byte~) setMEMtoFAC::prepareMEM1_$0 ← < (word)(byte*) setMEMtoFAC::mem#2
  [91] *((const byte*) memLo) ← (byte~) setMEMtoFAC::prepareMEM1_$0
  [92] (byte~) setMEMtoFAC::prepareMEM1_$1 ← > (word)(byte*) setMEMtoFAC::mem#2
  [93] *((const byte*) memHi) ← (byte~) setMEMtoFAC::prepareMEM1_$1
  to:setMEMtoFAC::@1
setMEMtoFAC::@1: scope:[setMEMtoFAC]  from setMEMtoFAC::prepareMEM1
  asm { ldxmemLo ldymemHi jsr$bbd4  }
  to:setMEMtoFAC::@return
setMEMtoFAC::@return: scope:[setMEMtoFAC]  from setMEMtoFAC::@1
  [95] return 
  to:@return

(void()) divFACby10()
divFACby10: scope:[divFACby10]  from main::@2
  asm { jsr$bafe  }
  to:divFACby10::@return
divFACby10::@return: scope:[divFACby10]  from divFACby10
  [97] return 
  to:@return
