Fixing pointer addition (word*~) bsearch16u::$7 ← (word*) bsearch16u::items + (byte~) bsearch16u::$6
Fixing pointer addition (word*~) bsearch16u::$15 ← (word*) bsearch16u::pivot + (number) 1
Fixing pointer addition (word*~) bsearch16u::$1 ← (word*) bsearch16u::items - (number) 1
Fixing pointer increment (word*) lin16u_gen::lintab ← ++ (word*) lin16u_gen::lintab
Fixing pointer array-indexing *((word*) utoa::digit_values + (byte) utoa::digit)
Fixing pointer array-indexing *((dword*) ultoa::digit_values + (byte) ultoa::digit)
Fixing pointer array-indexing *((const word*) main::lintab1 + (byte) main::i)
Fixing pointer array-indexing *((const word*) main::lintab2 + (byte) main::i)
Fixing pointer array-indexing *((const word*) main::lintab3 + (byte) main::i)
Warning! Adding boolean cast to non-boolean condition *((byte*) strcpy::src)
Warning! Adding boolean cast to non-boolean condition *((byte*) strlen::str)
Warning! Adding boolean cast to non-boolean condition *((byte*) print_str_lines::str)
Warning! Adding boolean cast to non-boolean condition (byte) print_str_lines::ch
Warning! Adding boolean cast to non-boolean condition *((byte*) print_str::str)
Warning! Adding boolean cast to non-boolean condition *((byte*) print_str_at::str)
Warning! Adding boolean cast to non-boolean sub-expression (byte) print_str_lines::ch
Identified constant variable (byte*) HEAP_TOP
Culled Empty Block (label) @1
Culled Empty Block (label) divr16u::@7
Culled Empty Block (label) @3
Culled Empty Block (label) @4
Culled Empty Block (label) @5
Culled Empty Block (label) @6
Culled Empty Block (label) @7
Culled Empty Block (label) @8
Culled Empty Block (label) @9
Culled Empty Block (label) @10
Culled Empty Block (label) memset::@7
Culled Empty Block (label) memset::@6
Culled Empty Block (label) memset::@8
Culled Empty Block (label) memset::@9
Culled Empty Block (label) memset::@3
Culled Empty Block (label) @11
Culled Empty Block (label) @12
Culled Empty Block (label) @13
Culled Empty Block (label) @14
Culled Empty Block (label) @15
Culled Empty Block (label) @16
Culled Empty Block (label) @17
Culled Empty Block (label) @18
Culled Empty Block (label) @19
Culled Empty Block (label) @20
Culled Empty Block (label) @22
Culled Empty Block (label) @23
Culled Empty Block (label) print_str::@4
Culled Empty Block (label) print_str::@3
Culled Empty Block (label) print_str::@5
Culled Empty Block (label) print_str::@6
Culled Empty Block (label) @24
Culled Empty Block (label) @25
Culled Empty Block (label) @26
Culled Empty Block (label) @27
Culled Empty Block (label) @28
Culled Empty Block (label) @29
Culled Empty Block (label) @30
Culled Empty Block (label) @31
Culled Empty Block (label) @32
Culled Empty Block (label) @33
Culled Empty Block (label) @34
Culled Empty Block (label) @35
Culled Empty Block (label) @36
Culled Empty Block (label) @37
Culled Empty Block (label) @38
Culled Empty Block (label) @39
Culled Empty Block (label) @40
Culled Empty Block (label) @41
Culled Empty Block (label) @42
Culled Empty Block (label) @43
Culled Empty Block (label) @44
Culled Empty Block (label) @45
Culled Empty Block (label) main::@4
Culled Empty Block (label) main::@5
Culled Empty Block (label) main::@6
Culled Empty Block (label) @46
Culled Empty Block (label) lin16u_gen::@4
Culled Empty Block (label) lin16u_gen::@3
Culled Empty Block (label) lin16u_gen::@5
Culled Empty Block (label) lin16u_gen::@6

CONTROL FLOW GRAPH SSA
@begin: scope:[]  from
  to:@2
@2: scope:[]  from @begin
  (word) rem16u#0 ← (word) 0
  to:@21

(word()) divr16u((word) divr16u::dividend , (word) divr16u::divisor , (word) divr16u::rem)
divr16u: scope:[divr16u]  from lin16u_gen lin16u_gen::@7
  (word) divr16u::divisor#6 ← phi( lin16u_gen/(word) divr16u::divisor#0 lin16u_gen::@7/(word) divr16u::divisor#1 )
  (word) divr16u::dividend#5 ← phi( lin16u_gen/(word) divr16u::dividend#1 lin16u_gen::@7/(word) divr16u::dividend#2 )
  (word) divr16u::rem#10 ← phi( lin16u_gen/(word) divr16u::rem#3 lin16u_gen::@7/(word) divr16u::rem#4 )
  (word) divr16u::quotient#0 ← (word) 0
  (byte) divr16u::i#0 ← (byte) 0
  to:divr16u::@1
divr16u::@1: scope:[divr16u]  from divr16u divr16u::@3
  (byte) divr16u::i#5 ← phi( divr16u/(byte) divr16u::i#0 divr16u::@3/(byte) divr16u::i#1 )
  (word) divr16u::divisor#4 ← phi( divr16u/(word) divr16u::divisor#6 divr16u::@3/(word) divr16u::divisor#7 )
  (word) divr16u::quotient#6 ← phi( divr16u/(word) divr16u::quotient#0 divr16u::@3/(word) divr16u::quotient#8 )
  (word) divr16u::dividend#3 ← phi( divr16u/(word) divr16u::dividend#5 divr16u::@3/(word) divr16u::dividend#6 )
  (word) divr16u::rem#5 ← phi( divr16u/(word) divr16u::rem#10 divr16u::@3/(word) divr16u::rem#11 )
  (word~) divr16u::$0 ← (word) divr16u::rem#5 << (number) 1
  (word) divr16u::rem#0 ← (word~) divr16u::$0
  (byte~) divr16u::$1 ← > (word) divr16u::dividend#3
  (number~) divr16u::$2 ← (byte~) divr16u::$1 & (number) $80
  (bool~) divr16u::$3 ← (number~) divr16u::$2 != (number) 0
  (bool~) divr16u::$4 ← ! (bool~) divr16u::$3
  if((bool~) divr16u::$4) goto divr16u::@2
  to:divr16u::@4
divr16u::@2: scope:[divr16u]  from divr16u::@1 divr16u::@4
  (byte) divr16u::i#3 ← phi( divr16u::@1/(byte) divr16u::i#5 divr16u::@4/(byte) divr16u::i#6 )
  (word) divr16u::divisor#2 ← phi( divr16u::@1/(word) divr16u::divisor#4 divr16u::@4/(word) divr16u::divisor#5 )
  (word) divr16u::rem#6 ← phi( divr16u::@1/(word) divr16u::rem#0 divr16u::@4/(word) divr16u::rem#1 )
  (word) divr16u::quotient#3 ← phi( divr16u::@1/(word) divr16u::quotient#6 divr16u::@4/(word) divr16u::quotient#7 )
  (word) divr16u::dividend#4 ← phi( divr16u::@1/(word) divr16u::dividend#3 divr16u::@4/(word) divr16u::dividend#7 )
  (word~) divr16u::$6 ← (word) divr16u::dividend#4 << (number) 1
  (word) divr16u::dividend#0 ← (word~) divr16u::$6
  (word~) divr16u::$7 ← (word) divr16u::quotient#3 << (number) 1
  (word) divr16u::quotient#1 ← (word~) divr16u::$7
  (bool~) divr16u::$8 ← (word) divr16u::rem#6 >= (word) divr16u::divisor#2
  (bool~) divr16u::$9 ← ! (bool~) divr16u::$8
  if((bool~) divr16u::$9) goto divr16u::@3
  to:divr16u::@5
divr16u::@4: scope:[divr16u]  from divr16u::@1
  (byte) divr16u::i#6 ← phi( divr16u::@1/(byte) divr16u::i#5 )
  (word) divr16u::divisor#5 ← phi( divr16u::@1/(word) divr16u::divisor#4 )
  (word) divr16u::quotient#7 ← phi( divr16u::@1/(word) divr16u::quotient#6 )
  (word) divr16u::dividend#7 ← phi( divr16u::@1/(word) divr16u::dividend#3 )
  (word) divr16u::rem#7 ← phi( divr16u::@1/(word) divr16u::rem#0 )
  (number~) divr16u::$5 ← (word) divr16u::rem#7 | (number) 1
  (word) divr16u::rem#1 ← (number~) divr16u::$5
  to:divr16u::@2
divr16u::@3: scope:[divr16u]  from divr16u::@2 divr16u::@5
  (word) divr16u::divisor#7 ← phi( divr16u::@2/(word) divr16u::divisor#2 divr16u::@5/(word) divr16u::divisor#3 )
  (word) divr16u::quotient#8 ← phi( divr16u::@2/(word) divr16u::quotient#1 divr16u::@5/(word) divr16u::quotient#2 )
  (word) divr16u::dividend#6 ← phi( divr16u::@2/(word) divr16u::dividend#0 divr16u::@5/(word) divr16u::dividend#8 )
  (word) divr16u::rem#11 ← phi( divr16u::@2/(word) divr16u::rem#6 divr16u::@5/(word) divr16u::rem#2 )
  (byte) divr16u::i#2 ← phi( divr16u::@2/(byte) divr16u::i#3 divr16u::@5/(byte) divr16u::i#4 )
  (byte) divr16u::i#1 ← (byte) divr16u::i#2 + rangenext(0,$f)
  (bool~) divr16u::$11 ← (byte) divr16u::i#1 != rangelast(0,$f)
  if((bool~) divr16u::$11) goto divr16u::@1
  to:divr16u::@6
divr16u::@5: scope:[divr16u]  from divr16u::@2
  (word) divr16u::dividend#8 ← phi( divr16u::@2/(word) divr16u::dividend#0 )
  (byte) divr16u::i#4 ← phi( divr16u::@2/(byte) divr16u::i#3 )
  (word) divr16u::divisor#3 ← phi( divr16u::@2/(word) divr16u::divisor#2 )
  (word) divr16u::rem#8 ← phi( divr16u::@2/(word) divr16u::rem#6 )
  (word) divr16u::quotient#4 ← phi( divr16u::@2/(word) divr16u::quotient#1 )
  (word) divr16u::quotient#2 ← ++ (word) divr16u::quotient#4
  (word~) divr16u::$10 ← (word) divr16u::rem#8 - (word) divr16u::divisor#3
  (word) divr16u::rem#2 ← (word~) divr16u::$10
  to:divr16u::@3
divr16u::@6: scope:[divr16u]  from divr16u::@3
  (word) divr16u::quotient#5 ← phi( divr16u::@3/(word) divr16u::quotient#8 )
  (word) divr16u::rem#9 ← phi( divr16u::@3/(word) divr16u::rem#11 )
  (word) rem16u#1 ← (word) divr16u::rem#9
  (word) divr16u::return#0 ← (word) divr16u::quotient#5
  to:divr16u::@return
divr16u::@return: scope:[divr16u]  from divr16u::@6
  (word) rem16u#11 ← phi( divr16u::@6/(word) rem16u#1 )
  (word) divr16u::return#4 ← phi( divr16u::@6/(word) divr16u::return#0 )
  (word) divr16u::return#1 ← (word) divr16u::return#4
  (word) rem16u#2 ← (word) rem16u#11
  return 
  to:@return

(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num)
memset: scope:[memset]  from print_cls
  (byte) memset::c#4 ← phi( print_cls/(byte) memset::c#0 )
  (void*) memset::str#3 ← phi( print_cls/(void*) memset::str#0 )
  (word) memset::num#1 ← phi( print_cls/(word) memset::num#0 )
  (bool~) memset::$0 ← (word) memset::num#1 > (number) 0
  (bool~) memset::$1 ← ! (bool~) memset::$0
  if((bool~) memset::$1) goto memset::@1
  to:memset::@2
memset::@1: scope:[memset]  from memset memset::@4
  (void*) memset::str#1 ← phi( memset/(void*) memset::str#3 memset::@4/(void*) memset::str#4 )
  (void*) memset::return#0 ← (void*) memset::str#1
  to:memset::@return
memset::@2: scope:[memset]  from memset
  (byte) memset::c#3 ← phi( memset/(byte) memset::c#4 )
  (word) memset::num#2 ← phi( memset/(word) memset::num#1 )
  (void*) memset::str#2 ← phi( memset/(void*) memset::str#3 )
  (byte*~) memset::$2 ← ((byte*)) (void*) memset::str#2
  (byte*~) memset::$3 ← (byte*~) memset::$2 + (word) memset::num#2
  (byte*) memset::end#0 ← (byte*~) memset::$3
  (byte*) memset::dst#0 ← ((byte*)) (void*) memset::str#2
  to:memset::@4
memset::@4: scope:[memset]  from memset::@2 memset::@5
  (byte) memset::c#2 ← phi( memset::@2/(byte) memset::c#3 memset::@5/(byte) memset::c#1 )
  (void*) memset::str#4 ← phi( memset::@2/(void*) memset::str#2 memset::@5/(void*) memset::str#5 )
  (byte*) memset::end#1 ← phi( memset::@2/(byte*) memset::end#0 memset::@5/(byte*) memset::end#2 )
  (byte*) memset::dst#2 ← phi( memset::@2/(byte*) memset::dst#0 memset::@5/(byte*) memset::dst#1 )
  (bool~) memset::$4 ← (byte*) memset::dst#2 != (byte*) memset::end#1
  if((bool~) memset::$4) goto memset::@5
  to:memset::@1
memset::@5: scope:[memset]  from memset::@4
  (void*) memset::str#5 ← phi( memset::@4/(void*) memset::str#4 )
  (byte*) memset::end#2 ← phi( memset::@4/(byte*) memset::end#1 )
  (byte*) memset::dst#3 ← phi( memset::@4/(byte*) memset::dst#2 )
  (byte) memset::c#1 ← phi( memset::@4/(byte) memset::c#2 )
  *((byte*) memset::dst#3) ← (byte) memset::c#1
  (byte*) memset::dst#1 ← ++ (byte*) memset::dst#3
  to:memset::@4
memset::@return: scope:[memset]  from memset::@1
  (void*) memset::return#3 ← phi( memset::@1/(void*) memset::return#0 )
  (void*) memset::return#1 ← (void*) memset::return#3
  return 
  to:@return
@21: scope:[]  from @2
  (word) rem16u#27 ← phi( @2/(word) rem16u#0 )
  (byte*) print_screen#0 ← (byte*)(number) $400
  (byte*) print_line_cursor#0 ← (byte*) print_screen#0
  (byte*) print_char_cursor#0 ← (byte*) print_line_cursor#0
  to:@47

(void()) print_str((byte*) print_str::str)
print_str: scope:[print_str]  from main::@10 main::@12 main::@14 main::@18 main::@20 main::@22 main::@27 main::@29 main::@3
  (byte*) print_char_cursor#86 ← phi( main::@10/(byte*) print_char_cursor#15 main::@12/(byte*) print_char_cursor#17 main::@14/(byte*) print_char_cursor#19 main::@18/(byte*) print_char_cursor#23 main::@20/(byte*) print_char_cursor#25 main::@22/(byte*) print_char_cursor#27 main::@27/(byte*) print_char_cursor#32 main::@29/(byte*) print_char_cursor#34 main::@3/(byte*) print_char_cursor#84 )
  (byte*) print_str::str#12 ← phi( main::@10/(byte*) print_str::str#1 main::@12/(byte*) print_str::str#2 main::@14/(byte*) print_str::str#3 main::@18/(byte*) print_str::str#4 main::@20/(byte*) print_str::str#5 main::@22/(byte*) print_str::str#6 main::@27/(byte*) print_str::str#8 main::@29/(byte*) print_str::str#9 main::@3/(byte*) print_str::str#7 )
  to:print_str::@1
print_str::@1: scope:[print_str]  from print_str print_str::@2
  (byte*) print_char_cursor#78 ← phi( print_str/(byte*) print_char_cursor#86 print_str::@2/(byte*) print_char_cursor#1 )
  (byte*) print_str::str#10 ← phi( print_str/(byte*) print_str::str#12 print_str::@2/(byte*) print_str::str#0 )
  (bool~) print_str::$0 ← (number) 0 != *((byte*) print_str::str#10)
  if((bool~) print_str::$0) goto print_str::@2
  to:print_str::@return
print_str::@2: scope:[print_str]  from print_str::@1
  (byte*) print_char_cursor#40 ← phi( print_str::@1/(byte*) print_char_cursor#78 )
  (byte*) print_str::str#11 ← phi( print_str::@1/(byte*) print_str::str#10 )
  *((byte*) print_char_cursor#40) ← *((byte*) print_str::str#11)
  (byte*) print_char_cursor#1 ← ++ (byte*) print_char_cursor#40
  (byte*) print_str::str#0 ← ++ (byte*) print_str::str#11
  to:print_str::@1
print_str::@return: scope:[print_str]  from print_str::@1
  (byte*) print_char_cursor#41 ← phi( print_str::@1/(byte*) print_char_cursor#78 )
  (byte*) print_char_cursor#2 ← (byte*) print_char_cursor#41
  return 
  to:@return

(void()) print_ln()
print_ln: scope:[print_ln]  from main::@16 main::@24 main::@31
  (byte*) print_char_cursor#79 ← phi( main::@16/(byte*) print_char_cursor#21 main::@24/(byte*) print_char_cursor#29 main::@31/(byte*) print_char_cursor#36 )
  (byte*) print_line_cursor#21 ← phi( main::@16/(byte*) print_line_cursor#23 main::@24/(byte*) print_line_cursor#24 main::@31/(byte*) print_line_cursor#25 )
  to:print_ln::@1
print_ln::@1: scope:[print_ln]  from print_ln print_ln::@1
  (byte*) print_char_cursor#42 ← phi( print_ln/(byte*) print_char_cursor#79 print_ln::@1/(byte*) print_char_cursor#42 )
  (byte*) print_line_cursor#11 ← phi( print_ln/(byte*) print_line_cursor#21 print_ln::@1/(byte*) print_line_cursor#1 )
  (byte*~) print_ln::$0 ← (byte*) print_line_cursor#11 + (number) $28
  (byte*) print_line_cursor#1 ← (byte*~) print_ln::$0
  (bool~) print_ln::$1 ← (byte*) print_line_cursor#1 < (byte*) print_char_cursor#42
  if((bool~) print_ln::$1) goto print_ln::@1
  to:print_ln::@2
print_ln::@2: scope:[print_ln]  from print_ln::@1
  (byte*) print_line_cursor#12 ← phi( print_ln::@1/(byte*) print_line_cursor#1 )
  (byte*) print_char_cursor#3 ← (byte*) print_line_cursor#12
  to:print_ln::@return
print_ln::@return: scope:[print_ln]  from print_ln::@2
  (byte*) print_char_cursor#43 ← phi( print_ln::@2/(byte*) print_char_cursor#3 )
  (byte*) print_line_cursor#13 ← phi( print_ln::@2/(byte*) print_line_cursor#12 )
  (byte*) print_line_cursor#2 ← (byte*) print_line_cursor#13
  (byte*) print_char_cursor#4 ← (byte*) print_char_cursor#43
  return 
  to:@return

(void()) print_word((word) print_word::w)
print_word: scope:[print_word]  from main::@11 main::@13 main::@15 main::@19 main::@21 main::@23 main::@26 main::@28 main::@30
  (byte*) print_char_cursor#80 ← phi( main::@11/(byte*) print_char_cursor#16 main::@13/(byte*) print_char_cursor#18 main::@15/(byte*) print_char_cursor#20 main::@19/(byte*) print_char_cursor#24 main::@21/(byte*) print_char_cursor#26 main::@23/(byte*) print_char_cursor#28 main::@26/(byte*) print_char_cursor#31 main::@28/(byte*) print_char_cursor#33 main::@30/(byte*) print_char_cursor#35 )
  (word) print_word::w#9 ← phi( main::@11/(word) print_word::w#0 main::@13/(word) print_word::w#1 main::@15/(word) print_word::w#2 main::@19/(word) print_word::w#3 main::@21/(word) print_word::w#4 main::@23/(word) print_word::w#5 main::@26/(word) print_word::w#6 main::@28/(word) print_word::w#7 main::@30/(word) print_word::w#8 )
  (byte~) print_word::$0 ← > (word) print_word::w#9
  (byte) print_byte::b#0 ← (byte~) print_word::$0
  call print_byte 
  to:print_word::@1
print_word::@1: scope:[print_word]  from print_word
  (word) print_word::w#10 ← phi( print_word/(word) print_word::w#9 )
  (byte*) print_char_cursor#44 ← phi( print_word/(byte*) print_char_cursor#10 )
  (byte*) print_char_cursor#5 ← (byte*) print_char_cursor#44
  (byte~) print_word::$2 ← < (word) print_word::w#10
  (byte) print_byte::b#1 ← (byte~) print_word::$2
  call print_byte 
  to:print_word::@2
print_word::@2: scope:[print_word]  from print_word::@1
  (byte*) print_char_cursor#45 ← phi( print_word::@1/(byte*) print_char_cursor#10 )
  (byte*) print_char_cursor#6 ← (byte*) print_char_cursor#45
  to:print_word::@return
print_word::@return: scope:[print_word]  from print_word::@2
  (byte*) print_char_cursor#46 ← phi( print_word::@2/(byte*) print_char_cursor#6 )
  (byte*) print_char_cursor#7 ← (byte*) print_char_cursor#46
  return 
  to:@return

(void()) print_byte((byte) print_byte::b)
print_byte: scope:[print_byte]  from main::@2 print_word print_word::@1
  (byte*) print_char_cursor#81 ← phi( main::@2/(byte*) print_char_cursor#83 print_word/(byte*) print_char_cursor#80 print_word::@1/(byte*) print_char_cursor#5 )
  (byte) print_byte::b#3 ← phi( main::@2/(byte) print_byte::b#2 print_word/(byte) print_byte::b#0 print_word::@1/(byte) print_byte::b#1 )
  (byte~) print_byte::$0 ← (byte) print_byte::b#3 >> (number) 4
  (byte) print_char::ch#0 ← *((const byte*) print_hextab + (byte~) print_byte::$0)
  call print_char 
  to:print_byte::@1
print_byte::@1: scope:[print_byte]  from print_byte
  (byte) print_byte::b#4 ← phi( print_byte/(byte) print_byte::b#3 )
  (byte*) print_char_cursor#47 ← phi( print_byte/(byte*) print_char_cursor#12 )
  (byte*) print_char_cursor#8 ← (byte*) print_char_cursor#47
  (number~) print_byte::$2 ← (byte) print_byte::b#4 & (number) $f
  (byte) print_char::ch#1 ← *((const byte*) print_hextab + (number~) print_byte::$2)
  call print_char 
  to:print_byte::@2
print_byte::@2: scope:[print_byte]  from print_byte::@1
  (byte*) print_char_cursor#48 ← phi( print_byte::@1/(byte*) print_char_cursor#12 )
  (byte*) print_char_cursor#9 ← (byte*) print_char_cursor#48
  to:print_byte::@return
print_byte::@return: scope:[print_byte]  from print_byte::@2
  (byte*) print_char_cursor#49 ← phi( print_byte::@2/(byte*) print_char_cursor#9 )
  (byte*) print_char_cursor#10 ← (byte*) print_char_cursor#49
  return 
  to:@return

(void()) print_char((byte) print_char::ch)
print_char: scope:[print_char]  from print_byte print_byte::@1
  (byte*) print_char_cursor#50 ← phi( print_byte/(byte*) print_char_cursor#81 print_byte::@1/(byte*) print_char_cursor#8 )
  (byte) print_char::ch#2 ← phi( print_byte/(byte) print_char::ch#0 print_byte::@1/(byte) print_char::ch#1 )
  *((byte*) print_char_cursor#50) ← (byte) print_char::ch#2
  (byte*) print_char_cursor#11 ← ++ (byte*) print_char_cursor#50
  to:print_char::@return
print_char::@return: scope:[print_char]  from print_char
  (byte*) print_char_cursor#51 ← phi( print_char/(byte*) print_char_cursor#11 )
  (byte*) print_char_cursor#12 ← (byte*) print_char_cursor#51
  return 
  to:@return

(void()) print_cls()
print_cls: scope:[print_cls]  from main::@9
  (byte*) print_screen#1 ← phi( main::@9/(byte*) print_screen#3 )
  (void*) memset::str#0 ← (void*)(byte*) print_screen#1
  (byte) memset::c#0 ← (byte) ' '
  (word) memset::num#0 ← (number) $3e8
  call memset 
  (void*) memset::return#2 ← (void*) memset::return#1
  to:print_cls::@1
print_cls::@1: scope:[print_cls]  from print_cls
  (byte*) print_screen#2 ← phi( print_cls/(byte*) print_screen#1 )
  (byte*) print_line_cursor#3 ← (byte*) print_screen#2
  (byte*) print_char_cursor#13 ← (byte*) print_line_cursor#3
  to:print_cls::@return
print_cls::@return: scope:[print_cls]  from print_cls::@1
  (byte*) print_char_cursor#52 ← phi( print_cls::@1/(byte*) print_char_cursor#13 )
  (byte*) print_line_cursor#14 ← phi( print_cls::@1/(byte*) print_line_cursor#3 )
  (byte*) print_line_cursor#4 ← (byte*) print_line_cursor#14
  (byte*) print_char_cursor#14 ← (byte*) print_char_cursor#52
  return 
  to:@return

(void()) main()
main: scope:[main]  from @47
  (byte*) print_char_cursor#90 ← phi( @47/(byte*) print_char_cursor#85 )
  (byte*) print_line_cursor#35 ← phi( @47/(byte*) print_line_cursor#26 )
  (byte*) print_screen#6 ← phi( @47/(byte*) print_screen#7 )
  (word) rem16u#20 ← phi( @47/(word) rem16u#24 )
  (word) lin16u_gen::min#0 ← (number) $22d
  (word) lin16u_gen::max#0 ← (number) $7461
  (word*) lin16u_gen::lintab#0 ← (const word*) main::lintab1
  (word) lin16u_gen::length#0 ← (number) $14
  call lin16u_gen 
  to:main::@7
main::@7: scope:[main]  from main
  (byte*) print_char_cursor#89 ← phi( main/(byte*) print_char_cursor#90 )
  (byte*) print_line_cursor#31 ← phi( main/(byte*) print_line_cursor#35 )
  (byte*) print_screen#5 ← phi( main/(byte*) print_screen#6 )
  (word) rem16u#12 ← phi( main/(word) rem16u#9 )
  (word) rem16u#3 ← (word) rem16u#12
  (word) lin16u_gen::min#1 ← (number) $79cb
  (word) lin16u_gen::max#1 ← (number) $f781
  (word*) lin16u_gen::lintab#1 ← (const word*) main::lintab2
  (word) lin16u_gen::length#1 ← (number) $14
  call lin16u_gen 
  to:main::@8
main::@8: scope:[main]  from main::@7
  (byte*) print_char_cursor#87 ← phi( main::@7/(byte*) print_char_cursor#89 )
  (byte*) print_line_cursor#27 ← phi( main::@7/(byte*) print_line_cursor#31 )
  (byte*) print_screen#4 ← phi( main::@7/(byte*) print_screen#5 )
  (word) rem16u#13 ← phi( main::@7/(word) rem16u#9 )
  (word) rem16u#4 ← (word) rem16u#13
  (word) lin16u_gen::min#2 ← (number) 0
  (word) lin16u_gen::max#2 ← (number) $6488
  (word*) lin16u_gen::lintab#2 ← (const word*) main::lintab3
  (word) lin16u_gen::length#2 ← (number) $14
  call lin16u_gen 
  to:main::@9
main::@9: scope:[main]  from main::@8
  (byte*) print_char_cursor#82 ← phi( main::@8/(byte*) print_char_cursor#87 )
  (byte*) print_line_cursor#22 ← phi( main::@8/(byte*) print_line_cursor#27 )
  (byte*) print_screen#3 ← phi( main::@8/(byte*) print_screen#4 )
  (word) rem16u#14 ← phi( main::@8/(word) rem16u#9 )
  (word) rem16u#5 ← (word) rem16u#14
  call print_cls 
  to:main::@10
main::@10: scope:[main]  from main::@9
  (word) rem16u#49 ← phi( main::@9/(word) rem16u#5 )
  (byte*) print_char_cursor#53 ← phi( main::@9/(byte*) print_char_cursor#14 )
  (byte*) print_line_cursor#15 ← phi( main::@9/(byte*) print_line_cursor#4 )
  (byte*) print_line_cursor#5 ← (byte*) print_line_cursor#15
  (byte*) print_char_cursor#15 ← (byte*) print_char_cursor#53
  (byte*) print_str::str#1 ← (const byte*) main::str
  call print_str 
  to:main::@11
main::@11: scope:[main]  from main::@10
  (word) rem16u#47 ← phi( main::@10/(word) rem16u#49 )
  (byte*) print_line_cursor#42 ← phi( main::@10/(byte*) print_line_cursor#5 )
  (byte*) print_char_cursor#54 ← phi( main::@10/(byte*) print_char_cursor#2 )
  (byte*) print_char_cursor#16 ← (byte*) print_char_cursor#54
  (word) print_word::w#0 ← (number) $22d
  call print_word 
  to:main::@12
main::@12: scope:[main]  from main::@11
  (word) rem16u#45 ← phi( main::@11/(word) rem16u#47 )
  (byte*) print_line_cursor#39 ← phi( main::@11/(byte*) print_line_cursor#42 )
  (byte*) print_char_cursor#55 ← phi( main::@11/(byte*) print_char_cursor#7 )
  (byte*) print_char_cursor#17 ← (byte*) print_char_cursor#55
  (byte*) print_str::str#2 ← (const byte*) main::str1
  call print_str 
  to:main::@13
main::@13: scope:[main]  from main::@12
  (word) rem16u#43 ← phi( main::@12/(word) rem16u#45 )
  (byte*) print_line_cursor#36 ← phi( main::@12/(byte*) print_line_cursor#39 )
  (byte*) print_char_cursor#56 ← phi( main::@12/(byte*) print_char_cursor#2 )
  (byte*) print_char_cursor#18 ← (byte*) print_char_cursor#56
  (word) print_word::w#1 ← (number) $79cb
  call print_word 
  to:main::@14
main::@14: scope:[main]  from main::@13
  (word) rem16u#41 ← phi( main::@13/(word) rem16u#43 )
  (byte*) print_line_cursor#32 ← phi( main::@13/(byte*) print_line_cursor#36 )
  (byte*) print_char_cursor#57 ← phi( main::@13/(byte*) print_char_cursor#7 )
  (byte*) print_char_cursor#19 ← (byte*) print_char_cursor#57
  (byte*) print_str::str#3 ← (const byte*) main::str2
  call print_str 
  to:main::@15
main::@15: scope:[main]  from main::@14
  (word) rem16u#39 ← phi( main::@14/(word) rem16u#41 )
  (byte*) print_line_cursor#28 ← phi( main::@14/(byte*) print_line_cursor#32 )
  (byte*) print_char_cursor#58 ← phi( main::@14/(byte*) print_char_cursor#2 )
  (byte*) print_char_cursor#20 ← (byte*) print_char_cursor#58
  (word) print_word::w#2 ← (number) 0
  call print_word 
  to:main::@16
main::@16: scope:[main]  from main::@15
  (word) rem16u#37 ← phi( main::@15/(word) rem16u#39 )
  (byte*) print_line_cursor#23 ← phi( main::@15/(byte*) print_line_cursor#28 )
  (byte*) print_char_cursor#59 ← phi( main::@15/(byte*) print_char_cursor#7 )
  (byte*) print_char_cursor#21 ← (byte*) print_char_cursor#59
  call print_ln 
  to:main::@17
main::@17: scope:[main]  from main::@16
  (word) rem16u#35 ← phi( main::@16/(word) rem16u#37 )
  (byte*) print_char_cursor#60 ← phi( main::@16/(byte*) print_char_cursor#4 )
  (byte*) print_line_cursor#16 ← phi( main::@16/(byte*) print_line_cursor#2 )
  (byte*) print_line_cursor#6 ← (byte*) print_line_cursor#16
  (byte*) print_char_cursor#22 ← (byte*) print_char_cursor#60
  (byte) main::i#0 ← (byte) 0
  to:main::@1
main::@1: scope:[main]  from main::@17 main::@25
  (word) rem16u#34 ← phi( main::@17/(word) rem16u#35 main::@25/(word) rem16u#36 )
  (byte*) print_line_cursor#48 ← phi( main::@17/(byte*) print_line_cursor#6 main::@25/(byte*) print_line_cursor#7 )
  (byte*) print_char_cursor#88 ← phi( main::@17/(byte*) print_char_cursor#22 main::@25/(byte*) print_char_cursor#30 )
  (byte) main::i#2 ← phi( main::@17/(byte) main::i#0 main::@25/(byte) main::i#1 )
  (bool~) main::$18 ← (byte) main::i#2 < (number) $14
  if((bool~) main::$18) goto main::@2
  to:main::@3
main::@2: scope:[main]  from main::@1
  (word) rem16u#51 ← phi( main::@1/(word) rem16u#34 )
  (byte*) print_line_cursor#47 ← phi( main::@1/(byte*) print_line_cursor#48 )
  (byte*) print_char_cursor#83 ← phi( main::@1/(byte*) print_char_cursor#88 )
  (byte) main::i#3 ← phi( main::@1/(byte) main::i#2 )
  (byte) print_byte::b#2 ← (byte) main::i#3
  call print_byte 
  to:main::@18
main::@18: scope:[main]  from main::@2
  (word) rem16u#50 ← phi( main::@2/(word) rem16u#51 )
  (byte*) print_line_cursor#45 ← phi( main::@2/(byte*) print_line_cursor#47 )
  (byte) main::i#8 ← phi( main::@2/(byte) main::i#3 )
  (byte*) print_char_cursor#61 ← phi( main::@2/(byte*) print_char_cursor#10 )
  (byte*) print_char_cursor#23 ← (byte*) print_char_cursor#61
  (byte*) print_str::str#4 ← (const byte*) main::str3
  call print_str 
  to:main::@19
main::@19: scope:[main]  from main::@18
  (word) rem16u#48 ← phi( main::@18/(word) rem16u#50 )
  (byte*) print_line_cursor#43 ← phi( main::@18/(byte*) print_line_cursor#45 )
  (byte) main::i#4 ← phi( main::@18/(byte) main::i#8 )
  (byte*) print_char_cursor#62 ← phi( main::@18/(byte*) print_char_cursor#2 )
  (byte*) print_char_cursor#24 ← (byte*) print_char_cursor#62
  (byte~) main::$27 ← (byte) main::i#4 * (const byte) SIZEOF_WORD
  (word) print_word::w#3 ← *((const word*) main::lintab1 + (byte~) main::$27)
  call print_word 
  to:main::@20
main::@20: scope:[main]  from main::@19
  (word) rem16u#46 ← phi( main::@19/(word) rem16u#48 )
  (byte*) print_line_cursor#40 ← phi( main::@19/(byte*) print_line_cursor#43 )
  (byte) main::i#9 ← phi( main::@19/(byte) main::i#4 )
  (byte*) print_char_cursor#63 ← phi( main::@19/(byte*) print_char_cursor#7 )
  (byte*) print_char_cursor#25 ← (byte*) print_char_cursor#63
  (byte*) print_str::str#5 ← (const byte*) main::str4
  call print_str 
  to:main::@21
main::@21: scope:[main]  from main::@20
  (word) rem16u#44 ← phi( main::@20/(word) rem16u#46 )
  (byte*) print_line_cursor#37 ← phi( main::@20/(byte*) print_line_cursor#40 )
  (byte) main::i#5 ← phi( main::@20/(byte) main::i#9 )
  (byte*) print_char_cursor#64 ← phi( main::@20/(byte*) print_char_cursor#2 )
  (byte*) print_char_cursor#26 ← (byte*) print_char_cursor#64
  (byte~) main::$28 ← (byte) main::i#5 * (const byte) SIZEOF_WORD
  (word) print_word::w#4 ← *((const word*) main::lintab2 + (byte~) main::$28)
  call print_word 
  to:main::@22
main::@22: scope:[main]  from main::@21
  (word) rem16u#42 ← phi( main::@21/(word) rem16u#44 )
  (byte*) print_line_cursor#33 ← phi( main::@21/(byte*) print_line_cursor#37 )
  (byte) main::i#10 ← phi( main::@21/(byte) main::i#5 )
  (byte*) print_char_cursor#65 ← phi( main::@21/(byte*) print_char_cursor#7 )
  (byte*) print_char_cursor#27 ← (byte*) print_char_cursor#65
  (byte*) print_str::str#6 ← (const byte*) main::str5
  call print_str 
  to:main::@23
main::@23: scope:[main]  from main::@22
  (word) rem16u#40 ← phi( main::@22/(word) rem16u#42 )
  (byte*) print_line_cursor#29 ← phi( main::@22/(byte*) print_line_cursor#33 )
  (byte) main::i#6 ← phi( main::@22/(byte) main::i#10 )
  (byte*) print_char_cursor#66 ← phi( main::@22/(byte*) print_char_cursor#2 )
  (byte*) print_char_cursor#28 ← (byte*) print_char_cursor#66
  (byte~) main::$29 ← (byte) main::i#6 * (const byte) SIZEOF_WORD
  (word) print_word::w#5 ← *((const word*) main::lintab3 + (byte~) main::$29)
  call print_word 
  to:main::@24
main::@24: scope:[main]  from main::@23
  (word) rem16u#38 ← phi( main::@23/(word) rem16u#40 )
  (byte) main::i#11 ← phi( main::@23/(byte) main::i#6 )
  (byte*) print_line_cursor#24 ← phi( main::@23/(byte*) print_line_cursor#29 )
  (byte*) print_char_cursor#67 ← phi( main::@23/(byte*) print_char_cursor#7 )
  (byte*) print_char_cursor#29 ← (byte*) print_char_cursor#67
  call print_ln 
  to:main::@25
main::@25: scope:[main]  from main::@24
  (word) rem16u#36 ← phi( main::@24/(word) rem16u#38 )
  (byte) main::i#7 ← phi( main::@24/(byte) main::i#11 )
  (byte*) print_char_cursor#68 ← phi( main::@24/(byte*) print_char_cursor#4 )
  (byte*) print_line_cursor#17 ← phi( main::@24/(byte*) print_line_cursor#2 )
  (byte*) print_line_cursor#7 ← (byte*) print_line_cursor#17
  (byte*) print_char_cursor#30 ← (byte*) print_char_cursor#68
  (byte) main::i#1 ← ++ (byte) main::i#7
  to:main::@1
main::@3: scope:[main]  from main::@1
  (word) rem16u#33 ← phi( main::@1/(word) rem16u#34 )
  (byte*) print_line_cursor#46 ← phi( main::@1/(byte*) print_line_cursor#48 )
  (byte*) print_char_cursor#84 ← phi( main::@1/(byte*) print_char_cursor#88 )
  (byte*) print_str::str#7 ← (const byte*) main::str6
  call print_str 
  to:main::@26
main::@26: scope:[main]  from main::@3
  (word) rem16u#32 ← phi( main::@3/(word) rem16u#33 )
  (byte*) print_line_cursor#44 ← phi( main::@3/(byte*) print_line_cursor#46 )
  (byte*) print_char_cursor#69 ← phi( main::@3/(byte*) print_char_cursor#2 )
  (byte*) print_char_cursor#31 ← (byte*) print_char_cursor#69
  (word) print_word::w#6 ← (number) $7461
  call print_word 
  to:main::@27
main::@27: scope:[main]  from main::@26
  (word) rem16u#31 ← phi( main::@26/(word) rem16u#32 )
  (byte*) print_line_cursor#41 ← phi( main::@26/(byte*) print_line_cursor#44 )
  (byte*) print_char_cursor#70 ← phi( main::@26/(byte*) print_char_cursor#7 )
  (byte*) print_char_cursor#32 ← (byte*) print_char_cursor#70
  (byte*) print_str::str#8 ← (const byte*) main::str7
  call print_str 
  to:main::@28
main::@28: scope:[main]  from main::@27
  (word) rem16u#30 ← phi( main::@27/(word) rem16u#31 )
  (byte*) print_line_cursor#38 ← phi( main::@27/(byte*) print_line_cursor#41 )
  (byte*) print_char_cursor#71 ← phi( main::@27/(byte*) print_char_cursor#2 )
  (byte*) print_char_cursor#33 ← (byte*) print_char_cursor#71
  (word) print_word::w#7 ← (number) $f781
  call print_word 
  to:main::@29
main::@29: scope:[main]  from main::@28
  (word) rem16u#29 ← phi( main::@28/(word) rem16u#30 )
  (byte*) print_line_cursor#34 ← phi( main::@28/(byte*) print_line_cursor#38 )
  (byte*) print_char_cursor#72 ← phi( main::@28/(byte*) print_char_cursor#7 )
  (byte*) print_char_cursor#34 ← (byte*) print_char_cursor#72
  (byte*) print_str::str#9 ← (const byte*) main::str8
  call print_str 
  to:main::@30
main::@30: scope:[main]  from main::@29
  (word) rem16u#28 ← phi( main::@29/(word) rem16u#29 )
  (byte*) print_line_cursor#30 ← phi( main::@29/(byte*) print_line_cursor#34 )
  (byte*) print_char_cursor#73 ← phi( main::@29/(byte*) print_char_cursor#2 )
  (byte*) print_char_cursor#35 ← (byte*) print_char_cursor#73
  (word) print_word::w#8 ← (number) $6488
  call print_word 
  to:main::@31
main::@31: scope:[main]  from main::@30
  (word) rem16u#25 ← phi( main::@30/(word) rem16u#28 )
  (byte*) print_line_cursor#25 ← phi( main::@30/(byte*) print_line_cursor#30 )
  (byte*) print_char_cursor#74 ← phi( main::@30/(byte*) print_char_cursor#7 )
  (byte*) print_char_cursor#36 ← (byte*) print_char_cursor#74
  call print_ln 
  to:main::@32
main::@32: scope:[main]  from main::@31
  (word) rem16u#21 ← phi( main::@31/(word) rem16u#25 )
  (byte*) print_char_cursor#75 ← phi( main::@31/(byte*) print_char_cursor#4 )
  (byte*) print_line_cursor#18 ← phi( main::@31/(byte*) print_line_cursor#2 )
  (byte*) print_line_cursor#8 ← (byte*) print_line_cursor#18
  (byte*) print_char_cursor#37 ← (byte*) print_char_cursor#75
  to:main::@return
main::@return: scope:[main]  from main::@32
  (byte*) print_char_cursor#76 ← phi( main::@32/(byte*) print_char_cursor#37 )
  (byte*) print_line_cursor#19 ← phi( main::@32/(byte*) print_line_cursor#8 )
  (word) rem16u#15 ← phi( main::@32/(word) rem16u#21 )
  (word) rem16u#6 ← (word) rem16u#15
  (byte*) print_line_cursor#9 ← (byte*) print_line_cursor#19
  (byte*) print_char_cursor#38 ← (byte*) print_char_cursor#76
  return 
  to:@return

(void()) lin16u_gen((word) lin16u_gen::min , (word) lin16u_gen::max , (word*) lin16u_gen::lintab , (word) lin16u_gen::length)
lin16u_gen: scope:[lin16u_gen]  from main main::@7 main::@8
  (word*) lin16u_gen::lintab#8 ← phi( main/(word*) lin16u_gen::lintab#0 main::@7/(word*) lin16u_gen::lintab#1 main::@8/(word*) lin16u_gen::lintab#2 )
  (word) rem16u#22 ← phi( main/(word) rem16u#20 main::@7/(word) rem16u#3 main::@8/(word) rem16u#4 )
  (word) lin16u_gen::length#3 ← phi( main/(word) lin16u_gen::length#0 main::@7/(word) lin16u_gen::length#1 main::@8/(word) lin16u_gen::length#2 )
  (word) lin16u_gen::min#3 ← phi( main/(word) lin16u_gen::min#0 main::@7/(word) lin16u_gen::min#1 main::@8/(word) lin16u_gen::min#2 )
  (word) lin16u_gen::max#3 ← phi( main/(word) lin16u_gen::max#0 main::@7/(word) lin16u_gen::max#1 main::@8/(word) lin16u_gen::max#2 )
  (word~) lin16u_gen::$0 ← (word) lin16u_gen::max#3 - (word) lin16u_gen::min#3
  (word) lin16u_gen::ampl#0 ← (word~) lin16u_gen::$0
  (number~) lin16u_gen::$1 ← (word) lin16u_gen::length#3 - (number) 1
  (word) divr16u::dividend#1 ← (word) lin16u_gen::ampl#0
  (word) divr16u::divisor#0 ← (number~) lin16u_gen::$1
  (word) divr16u::rem#3 ← (number) 0
  call divr16u 
  (word) divr16u::return#2 ← (word) divr16u::return#1
  to:lin16u_gen::@7
lin16u_gen::@7: scope:[lin16u_gen]  from lin16u_gen
  (word*) lin16u_gen::lintab#7 ← phi( lin16u_gen/(word*) lin16u_gen::lintab#8 )
  (word) lin16u_gen::min#5 ← phi( lin16u_gen/(word) lin16u_gen::min#3 )
  (word) lin16u_gen::length#4 ← phi( lin16u_gen/(word) lin16u_gen::length#3 )
  (word) rem16u#16 ← phi( lin16u_gen/(word) rem16u#2 )
  (word) divr16u::return#5 ← phi( lin16u_gen/(word) divr16u::return#2 )
  (word~) lin16u_gen::$2 ← (word) divr16u::return#5
  (word) rem16u#7 ← (word) rem16u#16
  (word) lin16u_gen::stepi#0 ← (word~) lin16u_gen::$2
  (number~) lin16u_gen::$3 ← (word) lin16u_gen::length#4 - (number) 1
  (word) divr16u::dividend#2 ← (number) 0
  (word) divr16u::divisor#1 ← (number~) lin16u_gen::$3
  (word) divr16u::rem#4 ← (word) rem16u#7
  call divr16u 
  (word) divr16u::return#3 ← (word) divr16u::return#1
  to:lin16u_gen::@8
lin16u_gen::@8: scope:[lin16u_gen]  from lin16u_gen::@7
  (word*) lin16u_gen::lintab#6 ← phi( lin16u_gen::@7/(word*) lin16u_gen::lintab#7 )
  (word) lin16u_gen::length#7 ← phi( lin16u_gen::@7/(word) lin16u_gen::length#4 )
  (word) lin16u_gen::min#4 ← phi( lin16u_gen::@7/(word) lin16u_gen::min#5 )
  (word) lin16u_gen::stepi#1 ← phi( lin16u_gen::@7/(word) lin16u_gen::stepi#0 )
  (word) rem16u#17 ← phi( lin16u_gen::@7/(word) rem16u#2 )
  (word) divr16u::return#6 ← phi( lin16u_gen::@7/(word) divr16u::return#3 )
  (word~) lin16u_gen::$4 ← (word) divr16u::return#6
  (word) rem16u#8 ← (word) rem16u#17
  (word) lin16u_gen::stepf#0 ← (word~) lin16u_gen::$4
  (dword) lin16u_gen::step#0 ← (dword){ (word) lin16u_gen::stepi#1, (word) lin16u_gen::stepf#0 }
  (dword) lin16u_gen::val#0 ← (dword){ (word) lin16u_gen::min#4, (word) 0 }
  (word) lin16u_gen::i#0 ← (word) 0
  to:lin16u_gen::@1
lin16u_gen::@1: scope:[lin16u_gen]  from lin16u_gen::@2 lin16u_gen::@8
  (word) rem16u#23 ← phi( lin16u_gen::@2/(word) rem16u#26 lin16u_gen::@8/(word) rem16u#8 )
  (dword) lin16u_gen::step#2 ← phi( lin16u_gen::@2/(dword) lin16u_gen::step#1 lin16u_gen::@8/(dword) lin16u_gen::step#0 )
  (word*) lin16u_gen::lintab#5 ← phi( lin16u_gen::@2/(word*) lin16u_gen::lintab#3 lin16u_gen::@8/(word*) lin16u_gen::lintab#6 )
  (dword) lin16u_gen::val#3 ← phi( lin16u_gen::@2/(dword) lin16u_gen::val#1 lin16u_gen::@8/(dword) lin16u_gen::val#0 )
  (word) lin16u_gen::length#5 ← phi( lin16u_gen::@2/(word) lin16u_gen::length#6 lin16u_gen::@8/(word) lin16u_gen::length#7 )
  (word) lin16u_gen::i#2 ← phi( lin16u_gen::@2/(word) lin16u_gen::i#1 lin16u_gen::@8/(word) lin16u_gen::i#0 )
  (bool~) lin16u_gen::$5 ← (word) lin16u_gen::i#2 < (word) lin16u_gen::length#5
  if((bool~) lin16u_gen::$5) goto lin16u_gen::@2
  to:lin16u_gen::@return
lin16u_gen::@2: scope:[lin16u_gen]  from lin16u_gen::@1
  (word) rem16u#26 ← phi( lin16u_gen::@1/(word) rem16u#23 )
  (word) lin16u_gen::length#6 ← phi( lin16u_gen::@1/(word) lin16u_gen::length#5 )
  (word) lin16u_gen::i#3 ← phi( lin16u_gen::@1/(word) lin16u_gen::i#2 )
  (dword) lin16u_gen::step#1 ← phi( lin16u_gen::@1/(dword) lin16u_gen::step#2 )
  (word*) lin16u_gen::lintab#4 ← phi( lin16u_gen::@1/(word*) lin16u_gen::lintab#5 )
  (dword) lin16u_gen::val#2 ← phi( lin16u_gen::@1/(dword) lin16u_gen::val#3 )
  (word~) lin16u_gen::$6 ← > (dword) lin16u_gen::val#2
  *((word*) lin16u_gen::lintab#4) ← (word~) lin16u_gen::$6
  (dword~) lin16u_gen::$7 ← (dword) lin16u_gen::val#2 + (dword) lin16u_gen::step#1
  (dword) lin16u_gen::val#1 ← (dword~) lin16u_gen::$7
  (word*) lin16u_gen::lintab#3 ← (word*) lin16u_gen::lintab#4 + (const byte) SIZEOF_WORD
  (word) lin16u_gen::i#1 ← ++ (word) lin16u_gen::i#3
  to:lin16u_gen::@1
lin16u_gen::@return: scope:[lin16u_gen]  from lin16u_gen::@1
  (word) rem16u#18 ← phi( lin16u_gen::@1/(word) rem16u#23 )
  (word) rem16u#9 ← (word) rem16u#18
  return 
  to:@return
@47: scope:[]  from @21
  (byte*) print_screen#7 ← phi( @21/(byte*) print_screen#0 )
  (byte*) print_char_cursor#85 ← phi( @21/(byte*) print_char_cursor#0 )
  (byte*) print_line_cursor#26 ← phi( @21/(byte*) print_line_cursor#0 )
  (word) rem16u#24 ← phi( @21/(word) rem16u#27 )
  call main 
  to:@48
@48: scope:[]  from @47
  (byte*) print_char_cursor#77 ← phi( @47/(byte*) print_char_cursor#38 )
  (byte*) print_line_cursor#20 ← phi( @47/(byte*) print_line_cursor#9 )
  (word) rem16u#19 ← phi( @47/(word) rem16u#6 )
  (word) rem16u#10 ← (word) rem16u#19
  (byte*) print_line_cursor#10 ← (byte*) print_line_cursor#20
  (byte*) print_char_cursor#39 ← (byte*) print_char_cursor#77
  to:@end
@end: scope:[]  from @48

SYMBOL TABLE SSA
(label) @2
(label) @21
(label) @47
(label) @48
(label) @begin
(label) @end
(const byte) RADIX::BINARY = (number) 2
(const byte) RADIX::DECIMAL = (number) $a
(const byte) RADIX::HEXADECIMAL = (number) $10
(const byte) RADIX::OCTAL = (number) 8
(const byte) SIZEOF_WORD = (byte) 2
(word()) divr16u((word) divr16u::dividend , (word) divr16u::divisor , (word) divr16u::rem)
(word~) divr16u::$0
(byte~) divr16u::$1
(word~) divr16u::$10
(bool~) divr16u::$11
(number~) divr16u::$2
(bool~) divr16u::$3
(bool~) divr16u::$4
(number~) divr16u::$5
(word~) divr16u::$6
(word~) divr16u::$7
(bool~) divr16u::$8
(bool~) divr16u::$9
(label) divr16u::@1
(label) divr16u::@2
(label) divr16u::@3
(label) divr16u::@4
(label) divr16u::@5
(label) divr16u::@6
(label) divr16u::@return
(word) divr16u::dividend
(word) divr16u::dividend#0
(word) divr16u::dividend#1
(word) divr16u::dividend#2
(word) divr16u::dividend#3
(word) divr16u::dividend#4
(word) divr16u::dividend#5
(word) divr16u::dividend#6
(word) divr16u::dividend#7
(word) divr16u::dividend#8
(word) divr16u::divisor
(word) divr16u::divisor#0
(word) divr16u::divisor#1
(word) divr16u::divisor#2
(word) divr16u::divisor#3
(word) divr16u::divisor#4
(word) divr16u::divisor#5
(word) divr16u::divisor#6
(word) divr16u::divisor#7
(byte) divr16u::i
(byte) divr16u::i#0
(byte) divr16u::i#1
(byte) divr16u::i#2
(byte) divr16u::i#3
(byte) divr16u::i#4
(byte) divr16u::i#5
(byte) divr16u::i#6
(word) divr16u::quotient
(word) divr16u::quotient#0
(word) divr16u::quotient#1
(word) divr16u::quotient#2
(word) divr16u::quotient#3
(word) divr16u::quotient#4
(word) divr16u::quotient#5
(word) divr16u::quotient#6
(word) divr16u::quotient#7
(word) divr16u::quotient#8
(word) divr16u::rem
(word) divr16u::rem#0
(word) divr16u::rem#1
(word) divr16u::rem#10
(word) divr16u::rem#11
(word) divr16u::rem#2
(word) divr16u::rem#3
(word) divr16u::rem#4
(word) divr16u::rem#5
(word) divr16u::rem#6
(word) divr16u::rem#7
(word) divr16u::rem#8
(word) divr16u::rem#9
(word) divr16u::return
(word) divr16u::return#0
(word) divr16u::return#1
(word) divr16u::return#2
(word) divr16u::return#3
(word) divr16u::return#4
(word) divr16u::return#5
(word) divr16u::return#6
(void()) lin16u_gen((word) lin16u_gen::min , (word) lin16u_gen::max , (word*) lin16u_gen::lintab , (word) lin16u_gen::length)
(word~) lin16u_gen::$0
(number~) lin16u_gen::$1
(word~) lin16u_gen::$2
(number~) lin16u_gen::$3
(word~) lin16u_gen::$4
(bool~) lin16u_gen::$5
(word~) lin16u_gen::$6
(dword~) lin16u_gen::$7
(label) lin16u_gen::@1
(label) lin16u_gen::@2
(label) lin16u_gen::@7
(label) lin16u_gen::@8
(label) lin16u_gen::@return
(word) lin16u_gen::ampl
(word) lin16u_gen::ampl#0
(word) lin16u_gen::i
(word) lin16u_gen::i#0
(word) lin16u_gen::i#1
(word) lin16u_gen::i#2
(word) lin16u_gen::i#3
(word) lin16u_gen::length
(word) lin16u_gen::length#0
(word) lin16u_gen::length#1
(word) lin16u_gen::length#2
(word) lin16u_gen::length#3
(word) lin16u_gen::length#4
(word) lin16u_gen::length#5
(word) lin16u_gen::length#6
(word) lin16u_gen::length#7
(word*) lin16u_gen::lintab
(word*) lin16u_gen::lintab#0
(word*) lin16u_gen::lintab#1
(word*) lin16u_gen::lintab#2
(word*) lin16u_gen::lintab#3
(word*) lin16u_gen::lintab#4
(word*) lin16u_gen::lintab#5
(word*) lin16u_gen::lintab#6
(word*) lin16u_gen::lintab#7
(word*) lin16u_gen::lintab#8
(word) lin16u_gen::max
(word) lin16u_gen::max#0
(word) lin16u_gen::max#1
(word) lin16u_gen::max#2
(word) lin16u_gen::max#3
(word) lin16u_gen::min
(word) lin16u_gen::min#0
(word) lin16u_gen::min#1
(word) lin16u_gen::min#2
(word) lin16u_gen::min#3
(word) lin16u_gen::min#4
(word) lin16u_gen::min#5
(dword) lin16u_gen::step
(dword) lin16u_gen::step#0
(dword) lin16u_gen::step#1
(dword) lin16u_gen::step#2
(word) lin16u_gen::stepf
(word) lin16u_gen::stepf#0
(word) lin16u_gen::stepi
(word) lin16u_gen::stepi#0
(word) lin16u_gen::stepi#1
(dword) lin16u_gen::val
(dword) lin16u_gen::val#0
(dword) lin16u_gen::val#1
(dword) lin16u_gen::val#2
(dword) lin16u_gen::val#3
(void()) main()
(bool~) main::$18
(byte~) main::$27
(byte~) main::$28
(byte~) main::$29
(label) main::@1
(label) main::@10
(label) main::@11
(label) main::@12
(label) main::@13
(label) main::@14
(label) main::@15
(label) main::@16
(label) main::@17
(label) main::@18
(label) main::@19
(label) main::@2
(label) main::@20
(label) main::@21
(label) main::@22
(label) main::@23
(label) main::@24
(label) main::@25
(label) main::@26
(label) main::@27
(label) main::@28
(label) main::@29
(label) main::@3
(label) main::@30
(label) main::@31
(label) main::@32
(label) main::@7
(label) main::@8
(label) main::@9
(label) main::@return
(byte) main::i
(byte) main::i#0
(byte) main::i#1
(byte) main::i#10
(byte) main::i#11
(byte) main::i#2
(byte) main::i#3
(byte) main::i#4
(byte) main::i#5
(byte) main::i#6
(byte) main::i#7
(byte) main::i#8
(byte) main::i#9
(const word*) main::lintab1[(number) $14]  = { fill( $14, 0) }
(const word*) main::lintab2[(number) $14]  = { fill( $14, 0) }
(const word*) main::lintab3[(number) $14]  = { fill( $14, 0) }
(const byte*) main::str[(byte) 4]  = (byte*) "   "
(const byte*) main::str1[(byte) 2]  = (byte*) " "
(const byte*) main::str2[(byte) 2]  = (byte*) " "
(const byte*) main::str3[(byte) 2]  = (byte*) " "
(const byte*) main::str4[(byte) 2]  = (byte*) " "
(const byte*) main::str5[(byte) 2]  = (byte*) " "
(const byte*) main::str6[(byte) 4]  = (byte*) "   "
(const byte*) main::str7[(byte) 2]  = (byte*) " "
(const byte*) main::str8[(byte) 2]  = (byte*) " "
(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num)
(bool~) memset::$0
(bool~) memset::$1
(byte*~) memset::$2
(byte*~) memset::$3
(bool~) memset::$4
(label) memset::@1
(label) memset::@2
(label) memset::@4
(label) memset::@5
(label) memset::@return
(byte) memset::c
(byte) memset::c#0
(byte) memset::c#1
(byte) memset::c#2
(byte) memset::c#3
(byte) memset::c#4
(byte*) memset::dst
(byte*) memset::dst#0
(byte*) memset::dst#1
(byte*) memset::dst#2
(byte*) memset::dst#3
(byte*) memset::end
(byte*) memset::end#0
(byte*) memset::end#1
(byte*) memset::end#2
(word) memset::num
(word) memset::num#0
(word) memset::num#1
(word) memset::num#2
(void*) memset::return
(void*) memset::return#0
(void*) memset::return#1
(void*) memset::return#2
(void*) memset::return#3
(void*) memset::str
(void*) memset::str#0
(void*) memset::str#1
(void*) memset::str#2
(void*) memset::str#3
(void*) memset::str#4
(void*) memset::str#5
(void()) print_byte((byte) print_byte::b)
(byte~) print_byte::$0
(number~) print_byte::$2
(label) print_byte::@1
(label) print_byte::@2
(label) print_byte::@return
(byte) print_byte::b
(byte) print_byte::b#0
(byte) print_byte::b#1
(byte) print_byte::b#2
(byte) print_byte::b#3
(byte) print_byte::b#4
(void()) print_char((byte) print_char::ch)
(label) print_char::@return
(byte) print_char::ch
(byte) print_char::ch#0
(byte) print_char::ch#1
(byte) print_char::ch#2
(byte*) print_char_cursor
(byte*) print_char_cursor#0
(byte*) print_char_cursor#1
(byte*) print_char_cursor#10
(byte*) print_char_cursor#11
(byte*) print_char_cursor#12
(byte*) print_char_cursor#13
(byte*) print_char_cursor#14
(byte*) print_char_cursor#15
(byte*) print_char_cursor#16
(byte*) print_char_cursor#17
(byte*) print_char_cursor#18
(byte*) print_char_cursor#19
(byte*) print_char_cursor#2
(byte*) print_char_cursor#20
(byte*) print_char_cursor#21
(byte*) print_char_cursor#22
(byte*) print_char_cursor#23
(byte*) print_char_cursor#24
(byte*) print_char_cursor#25
(byte*) print_char_cursor#26
(byte*) print_char_cursor#27
(byte*) print_char_cursor#28
(byte*) print_char_cursor#29
(byte*) print_char_cursor#3
(byte*) print_char_cursor#30
(byte*) print_char_cursor#31
(byte*) print_char_cursor#32
(byte*) print_char_cursor#33
(byte*) print_char_cursor#34
(byte*) print_char_cursor#35
(byte*) print_char_cursor#36
(byte*) print_char_cursor#37
(byte*) print_char_cursor#38
(byte*) print_char_cursor#39
(byte*) print_char_cursor#4
(byte*) print_char_cursor#40
(byte*) print_char_cursor#41
(byte*) print_char_cursor#42
(byte*) print_char_cursor#43
(byte*) print_char_cursor#44
(byte*) print_char_cursor#45
(byte*) print_char_cursor#46
(byte*) print_char_cursor#47
(byte*) print_char_cursor#48
(byte*) print_char_cursor#49
(byte*) print_char_cursor#5
(byte*) print_char_cursor#50
(byte*) print_char_cursor#51
(byte*) print_char_cursor#52
(byte*) print_char_cursor#53
(byte*) print_char_cursor#54
(byte*) print_char_cursor#55
(byte*) print_char_cursor#56
(byte*) print_char_cursor#57
(byte*) print_char_cursor#58
(byte*) print_char_cursor#59
(byte*) print_char_cursor#6
(byte*) print_char_cursor#60
(byte*) print_char_cursor#61
(byte*) print_char_cursor#62
(byte*) print_char_cursor#63
(byte*) print_char_cursor#64
(byte*) print_char_cursor#65
(byte*) print_char_cursor#66
(byte*) print_char_cursor#67
(byte*) print_char_cursor#68
(byte*) print_char_cursor#69
(byte*) print_char_cursor#7
(byte*) print_char_cursor#70
(byte*) print_char_cursor#71
(byte*) print_char_cursor#72
(byte*) print_char_cursor#73
(byte*) print_char_cursor#74
(byte*) print_char_cursor#75
(byte*) print_char_cursor#76
(byte*) print_char_cursor#77
(byte*) print_char_cursor#78
(byte*) print_char_cursor#79
(byte*) print_char_cursor#8
(byte*) print_char_cursor#80
(byte*) print_char_cursor#81
(byte*) print_char_cursor#82
(byte*) print_char_cursor#83
(byte*) print_char_cursor#84
(byte*) print_char_cursor#85
(byte*) print_char_cursor#86
(byte*) print_char_cursor#87
(byte*) print_char_cursor#88
(byte*) print_char_cursor#89
(byte*) print_char_cursor#9
(byte*) print_char_cursor#90
(void()) print_cls()
(label) print_cls::@1
(label) print_cls::@return
(const byte*) print_hextab[]  = (byte*) "0123456789abcdef"z
(byte*) print_line_cursor
(byte*) print_line_cursor#0
(byte*) print_line_cursor#1
(byte*) print_line_cursor#10
(byte*) print_line_cursor#11
(byte*) print_line_cursor#12
(byte*) print_line_cursor#13
(byte*) print_line_cursor#14
(byte*) print_line_cursor#15
(byte*) print_line_cursor#16
(byte*) print_line_cursor#17
(byte*) print_line_cursor#18
(byte*) print_line_cursor#19
(byte*) print_line_cursor#2
(byte*) print_line_cursor#20
(byte*) print_line_cursor#21
(byte*) print_line_cursor#22
(byte*) print_line_cursor#23
(byte*) print_line_cursor#24
(byte*) print_line_cursor#25
(byte*) print_line_cursor#26
(byte*) print_line_cursor#27
(byte*) print_line_cursor#28
(byte*) print_line_cursor#29
(byte*) print_line_cursor#3
(byte*) print_line_cursor#30
(byte*) print_line_cursor#31
(byte*) print_line_cursor#32
(byte*) print_line_cursor#33
(byte*) print_line_cursor#34
(byte*) print_line_cursor#35
(byte*) print_line_cursor#36
(byte*) print_line_cursor#37
(byte*) print_line_cursor#38
(byte*) print_line_cursor#39
(byte*) print_line_cursor#4
(byte*) print_line_cursor#40
(byte*) print_line_cursor#41
(byte*) print_line_cursor#42
(byte*) print_line_cursor#43
(byte*) print_line_cursor#44
(byte*) print_line_cursor#45
(byte*) print_line_cursor#46
(byte*) print_line_cursor#47
(byte*) print_line_cursor#48
(byte*) print_line_cursor#5
(byte*) print_line_cursor#6
(byte*) print_line_cursor#7
(byte*) print_line_cursor#8
(byte*) print_line_cursor#9
(void()) print_ln()
(byte*~) print_ln::$0
(bool~) print_ln::$1
(label) print_ln::@1
(label) print_ln::@2
(label) print_ln::@return
(byte*) print_screen
(byte*) print_screen#0
(byte*) print_screen#1
(byte*) print_screen#2
(byte*) print_screen#3
(byte*) print_screen#4
(byte*) print_screen#5
(byte*) print_screen#6
(byte*) print_screen#7
(void()) print_str((byte*) print_str::str)
(bool~) print_str::$0
(label) print_str::@1
(label) print_str::@2
(label) print_str::@return
(byte*) print_str::str
(byte*) print_str::str#0
(byte*) print_str::str#1
(byte*) print_str::str#10
(byte*) print_str::str#11
(byte*) print_str::str#12
(byte*) print_str::str#2
(byte*) print_str::str#3
(byte*) print_str::str#4
(byte*) print_str::str#5
(byte*) print_str::str#6
(byte*) print_str::str#7
(byte*) print_str::str#8
(byte*) print_str::str#9
(void()) print_word((word) print_word::w)
(byte~) print_word::$0
(byte~) print_word::$2
(label) print_word::@1
(label) print_word::@2
(label) print_word::@return
(word) print_word::w
(word) print_word::w#0
(word) print_word::w#1
(word) print_word::w#10
(word) print_word::w#2
(word) print_word::w#3
(word) print_word::w#4
(word) print_word::w#5
(word) print_word::w#6
(word) print_word::w#7
(word) print_word::w#8
(word) print_word::w#9
(word) rem16u
(word) rem16u#0
(word) rem16u#1
(word) rem16u#10
(word) rem16u#11
(word) rem16u#12
(word) rem16u#13
(word) rem16u#14
(word) rem16u#15
(word) rem16u#16
(word) rem16u#17
(word) rem16u#18
(word) rem16u#19
(word) rem16u#2
(word) rem16u#20
(word) rem16u#21
(word) rem16u#22
(word) rem16u#23
(word) rem16u#24
(word) rem16u#25
(word) rem16u#26
(word) rem16u#27
(word) rem16u#28
(word) rem16u#29
(word) rem16u#3
(word) rem16u#30
(word) rem16u#31
(word) rem16u#32
(word) rem16u#33
(word) rem16u#34
(word) rem16u#35
(word) rem16u#36
(word) rem16u#37
(word) rem16u#38
(word) rem16u#39
(word) rem16u#4
(word) rem16u#40
(word) rem16u#41
(word) rem16u#42
(word) rem16u#43
(word) rem16u#44
(word) rem16u#45
(word) rem16u#46
(word) rem16u#47
(word) rem16u#48
(word) rem16u#49
(word) rem16u#5
(word) rem16u#50
(word) rem16u#51
(word) rem16u#6
(word) rem16u#7
(word) rem16u#8
(word) rem16u#9

Fixing inline constructor with lin16u_gen::$8 ← (word)lin16u_gen::stepi#1 dw= (word)lin16u_gen::stepf#0
Fixing inline constructor with lin16u_gen::$9 ← (word)lin16u_gen::min#4 dw= (word)0
Successful SSA optimization Pass2FixInlineConstructors
Adding number conversion cast (unumber) 1 in (word~) divr16u::$0 ← (word) divr16u::rem#5 << (number) 1
Adding number conversion cast (unumber) $80 in (number~) divr16u::$2 ← (byte~) divr16u::$1 & (number) $80
Adding number conversion cast (unumber) divr16u::$2 in (number~) divr16u::$2 ← (byte~) divr16u::$1 & (unumber)(number) $80
Adding number conversion cast (unumber) 0 in (bool~) divr16u::$3 ← (unumber~) divr16u::$2 != (number) 0
Adding number conversion cast (unumber) 1 in (word~) divr16u::$6 ← (word) divr16u::dividend#4 << (number) 1
Adding number conversion cast (unumber) 1 in (word~) divr16u::$7 ← (word) divr16u::quotient#3 << (number) 1
Adding number conversion cast (unumber) 1 in (number~) divr16u::$5 ← (word) divr16u::rem#7 | (number) 1
Adding number conversion cast (unumber) divr16u::$5 in (number~) divr16u::$5 ← (word) divr16u::rem#7 | (unumber)(number) 1
Adding number conversion cast (unumber) 0 in (bool~) memset::$0 ← (word) memset::num#1 > (number) 0
Adding number conversion cast (unumber) 0 in (bool~) print_str::$0 ← (number) 0 != *((byte*) print_str::str#10)
Adding number conversion cast (unumber) $28 in (byte*~) print_ln::$0 ← (byte*) print_line_cursor#11 + (number) $28
Adding number conversion cast (unumber) 4 in (byte~) print_byte::$0 ← (byte) print_byte::b#3 >> (number) 4
Adding number conversion cast (unumber) $f in (number~) print_byte::$2 ← (byte) print_byte::b#4 & (number) $f
Adding number conversion cast (unumber) print_byte::$2 in (number~) print_byte::$2 ← (byte) print_byte::b#4 & (unumber)(number) $f
Adding number conversion cast (unumber) $3e8 in (word) memset::num#0 ← (number) $3e8
Adding number conversion cast (unumber) $22d in (word) lin16u_gen::min#0 ← (number) $22d
Adding number conversion cast (unumber) $7461 in (word) lin16u_gen::max#0 ← (number) $7461
Adding number conversion cast (unumber) $14 in (word) lin16u_gen::length#0 ← (number) $14
Adding number conversion cast (unumber) $79cb in (word) lin16u_gen::min#1 ← (number) $79cb
Adding number conversion cast (unumber) $f781 in (word) lin16u_gen::max#1 ← (number) $f781
Adding number conversion cast (unumber) $14 in (word) lin16u_gen::length#1 ← (number) $14
Adding number conversion cast (unumber) 0 in (word) lin16u_gen::min#2 ← (number) 0
Adding number conversion cast (unumber) $6488 in (word) lin16u_gen::max#2 ← (number) $6488
Adding number conversion cast (unumber) $14 in (word) lin16u_gen::length#2 ← (number) $14
Adding number conversion cast (unumber) $22d in (word) print_word::w#0 ← (number) $22d
Adding number conversion cast (unumber) $79cb in (word) print_word::w#1 ← (number) $79cb
Adding number conversion cast (unumber) 0 in (word) print_word::w#2 ← (number) 0
Adding number conversion cast (unumber) $14 in (bool~) main::$18 ← (byte) main::i#2 < (number) $14
Adding number conversion cast (unumber) $7461 in (word) print_word::w#6 ← (number) $7461
Adding number conversion cast (unumber) $f781 in (word) print_word::w#7 ← (number) $f781
Adding number conversion cast (unumber) $6488 in (word) print_word::w#8 ← (number) $6488
Adding number conversion cast (unumber) 1 in (number~) lin16u_gen::$1 ← (word) lin16u_gen::length#3 - (number) 1
Adding number conversion cast (unumber) lin16u_gen::$1 in (number~) lin16u_gen::$1 ← (word) lin16u_gen::length#3 - (unumber)(number) 1
Adding number conversion cast (unumber) 0 in (word) divr16u::rem#3 ← (number) 0
Adding number conversion cast (unumber) 1 in (number~) lin16u_gen::$3 ← (word) lin16u_gen::length#4 - (number) 1
Adding number conversion cast (unumber) lin16u_gen::$3 in (number~) lin16u_gen::$3 ← (word) lin16u_gen::length#4 - (unumber)(number) 1
Adding number conversion cast (unumber) 0 in (word) divr16u::dividend#2 ← (number) 0
Successful SSA optimization PassNAddNumberTypeConversions
Inlining cast (byte*~) memset::$2 ← (byte*)(void*) memset::str#2
Inlining cast (byte*) memset::dst#0 ← (byte*)(void*) memset::str#2
Inlining cast (word) memset::num#0 ← (unumber)(number) $3e8
Inlining cast (word) lin16u_gen::min#0 ← (unumber)(number) $22d
Inlining cast (word) lin16u_gen::max#0 ← (unumber)(number) $7461
Inlining cast (word) lin16u_gen::length#0 ← (unumber)(number) $14
Inlining cast (word) lin16u_gen::min#1 ← (unumber)(number) $79cb
Inlining cast (word) lin16u_gen::max#1 ← (unumber)(number) $f781
Inlining cast (word) lin16u_gen::length#1 ← (unumber)(number) $14
Inlining cast (word) lin16u_gen::min#2 ← (unumber)(number) 0
Inlining cast (word) lin16u_gen::max#2 ← (unumber)(number) $6488
Inlining cast (word) lin16u_gen::length#2 ← (unumber)(number) $14
Inlining cast (word) print_word::w#0 ← (unumber)(number) $22d
Inlining cast (word) print_word::w#1 ← (unumber)(number) $79cb
Inlining cast (word) print_word::w#2 ← (unumber)(number) 0
Inlining cast (word) print_word::w#6 ← (unumber)(number) $7461
Inlining cast (word) print_word::w#7 ← (unumber)(number) $f781
Inlining cast (word) print_word::w#8 ← (unumber)(number) $6488
Inlining cast (word) divr16u::rem#3 ← (unumber)(number) 0
Inlining cast (word) divr16u::dividend#2 ← (unumber)(number) 0
Successful SSA optimization Pass2InlineCast
Simplifying constant integer cast 1
Simplifying constant integer cast $80
Simplifying constant integer cast 0
Simplifying constant integer cast 1
Simplifying constant integer cast 1
Simplifying constant integer cast 1
Simplifying constant integer cast 0
Simplifying constant pointer cast (byte*) 1024
Simplifying constant integer cast 0
Simplifying constant integer cast $28
Simplifying constant integer cast 4
Simplifying constant integer cast $f
Simplifying constant integer cast $3e8
Simplifying constant integer cast $22d
Simplifying constant integer cast $7461
Simplifying constant integer cast $14
Simplifying constant integer cast $79cb
Simplifying constant integer cast $f781
Simplifying constant integer cast $14
Simplifying constant integer cast 0
Simplifying constant integer cast $6488
Simplifying constant integer cast $14
Simplifying constant integer cast $22d
Simplifying constant integer cast $79cb
Simplifying constant integer cast 0
Simplifying constant integer cast $14
Simplifying constant integer cast $7461
Simplifying constant integer cast $f781
Simplifying constant integer cast $6488
Simplifying constant integer cast 1
Simplifying constant integer cast 0
Simplifying constant integer cast 1
Simplifying constant integer cast 0
Simplifying constant integer cast (word) lin16u_gen::stepi#1
Simplifying constant integer cast (word) lin16u_gen::stepf#0
Simplifying constant integer cast (word) lin16u_gen::min#4
Simplifying constant integer cast (word) 0
Successful SSA optimization PassNCastSimplification
Finalized unsigned number type (byte) 1
Finalized unsigned number type (byte) $80
Finalized unsigned number type (byte) 0
Finalized unsigned number type (byte) 1
Finalized unsigned number type (byte) 1
Finalized unsigned number type (byte) 1
Finalized unsigned number type (byte) 0
Finalized unsigned number type (byte) 0
Finalized unsigned number type (byte) $28
Finalized unsigned number type (byte) 4
Finalized unsigned number type (byte) $f
Finalized unsigned number type (word) $3e8
Finalized unsigned number type (word) $22d
Finalized unsigned number type (word) $7461
Finalized unsigned number type (byte) $14
Finalized unsigned number type (word) $79cb
Finalized unsigned number type (word) $f781
Finalized unsigned number type (byte) $14
Finalized unsigned number type (byte) 0
Finalized unsigned number type (word) $6488
Finalized unsigned number type (byte) $14
Finalized unsigned number type (word) $22d
Finalized unsigned number type (word) $79cb
Finalized unsigned number type (byte) 0
Finalized unsigned number type (byte) $14
Finalized unsigned number type (word) $7461
Finalized unsigned number type (word) $f781
Finalized unsigned number type (word) $6488
Finalized unsigned number type (byte) 1
Finalized unsigned number type (byte) 0
Finalized unsigned number type (byte) 1
Finalized unsigned number type (byte) 0
Successful SSA optimization PassNFinalizeNumberTypeConversions
Inferred type updated to byte in (unumber~) divr16u::$2 ← (byte~) divr16u::$1 & (byte) $80
Inferred type updated to word in (unumber~) divr16u::$5 ← (word) divr16u::rem#7 | (byte) 1
Inferred type updated to byte in (unumber~) print_byte::$2 ← (byte) print_byte::b#4 & (byte) $f
Inferred type updated to word in (unumber~) lin16u_gen::$1 ← (word) lin16u_gen::length#3 - (byte) 1
Inferred type updated to word in (unumber~) lin16u_gen::$3 ← (word) lin16u_gen::length#4 - (byte) 1
Inversing boolean not [10] (bool~) divr16u::$4 ← (byte~) divr16u::$2 == (byte) 0 from [9] (bool~) divr16u::$3 ← (byte~) divr16u::$2 != (byte) 0
Inversing boolean not [18] (bool~) divr16u::$9 ← (word) divr16u::rem#6 < (word) divr16u::divisor#2 from [17] (bool~) divr16u::$8 ← (word) divr16u::rem#6 >= (word) divr16u::divisor#2
Inversing boolean not [40] (bool~) memset::$1 ← (word) memset::num#1 <= (byte) 0 from [39] (bool~) memset::$0 ← (word) memset::num#1 > (byte) 0
Successful SSA optimization Pass2UnaryNotSimplification
Alias (word) divr16u::rem#0 = (word~) divr16u::$0 (word) divr16u::rem#7 
Alias (word) divr16u::dividend#0 = (word~) divr16u::$6 (word) divr16u::dividend#8 
Alias (word) divr16u::quotient#1 = (word~) divr16u::$7 (word) divr16u::quotient#4 
Alias (word) divr16u::dividend#3 = (word) divr16u::dividend#7 
Alias (word) divr16u::quotient#6 = (word) divr16u::quotient#7 
Alias (word) divr16u::divisor#4 = (word) divr16u::divisor#5 
Alias (byte) divr16u::i#5 = (byte) divr16u::i#6 
Alias (word) divr16u::rem#1 = (word~) divr16u::$5 
Alias (word) divr16u::rem#6 = (word) divr16u::rem#8 
Alias (word) divr16u::divisor#2 = (word) divr16u::divisor#3 
Alias (byte) divr16u::i#3 = (byte) divr16u::i#4 
Alias (word) divr16u::rem#2 = (word~) divr16u::$10 
Alias (word) divr16u::rem#11 = (word) divr16u::rem#9 
Alias (word) divr16u::return#0 = (word) divr16u::quotient#5 (word) divr16u::quotient#8 (word) divr16u::return#4 (word) divr16u::return#1 
Alias (word) rem16u#1 = (word) rem16u#11 (word) rem16u#2 
Alias (void*) memset::return#0 = (void*) memset::str#1 (void*) memset::return#3 (void*) memset::return#1 
Alias (void*) memset::str#2 = (void*) memset::str#3 
Alias (word) memset::num#1 = (word) memset::num#2 
Alias (byte) memset::c#3 = (byte) memset::c#4 
Alias (byte*) memset::end#0 = (byte*~) memset::$3 
Alias (byte) memset::c#1 = (byte) memset::c#2 
Alias (byte*) memset::dst#2 = (byte*) memset::dst#3 
Alias (byte*) memset::end#1 = (byte*) memset::end#2 
Alias (void*) memset::str#4 = (void*) memset::str#5 
Alias (word) rem16u#0 = (word) rem16u#27 (word) rem16u#24 
Alias (byte*) print_line_cursor#0 = (byte*) print_screen#0 (byte*) print_char_cursor#0 (byte*) print_line_cursor#26 (byte*) print_char_cursor#85 (byte*) print_screen#7 
Alias (byte*) print_str::str#10 = (byte*) print_str::str#11 
Alias (byte*) print_char_cursor#2 = (byte*) print_char_cursor#40 (byte*) print_char_cursor#78 (byte*) print_char_cursor#41 
Alias (byte*) print_line_cursor#1 = (byte*~) print_ln::$0 (byte*) print_line_cursor#12 (byte*) print_char_cursor#3 (byte*) print_line_cursor#13 (byte*) print_char_cursor#43 (byte*) print_line_cursor#2 (byte*) print_char_cursor#4 
Alias (byte) print_byte::b#0 = (byte~) print_word::$0 
Alias (word) print_word::w#10 = (word) print_word::w#9 
Alias (byte*) print_char_cursor#44 = (byte*) print_char_cursor#5 
Alias (byte) print_byte::b#1 = (byte~) print_word::$2 
Alias (byte*) print_char_cursor#45 = (byte*) print_char_cursor#6 (byte*) print_char_cursor#46 (byte*) print_char_cursor#7 
Alias (byte) print_byte::b#3 = (byte) print_byte::b#4 
Alias (byte*) print_char_cursor#47 = (byte*) print_char_cursor#8 
Alias (byte*) print_char_cursor#10 = (byte*) print_char_cursor#9 (byte*) print_char_cursor#48 (byte*) print_char_cursor#49 
Alias (byte*) print_char_cursor#11 = (byte*) print_char_cursor#51 (byte*) print_char_cursor#12 
Alias (byte*) print_line_cursor#14 = (byte*) print_screen#2 (byte*) print_screen#1 (byte*) print_line_cursor#3 (byte*) print_char_cursor#13 (byte*) print_char_cursor#52 (byte*) print_line_cursor#4 (byte*) print_char_cursor#14 
Alias (byte*) print_screen#3 = (byte*) print_screen#5 (byte*) print_screen#6 (byte*) print_screen#4 
Alias (byte*) print_line_cursor#22 = (byte*) print_line_cursor#31 (byte*) print_line_cursor#35 (byte*) print_line_cursor#27 
Alias (byte*) print_char_cursor#82 = (byte*) print_char_cursor#89 (byte*) print_char_cursor#90 (byte*) print_char_cursor#87 
Alias (word) rem16u#12 = (word) rem16u#3 
Alias (word) rem16u#13 = (word) rem16u#4 
Alias (word) rem16u#14 = (word) rem16u#5 (word) rem16u#49 (word) rem16u#47 (word) rem16u#45 (word) rem16u#43 (word) rem16u#41 (word) rem16u#39 (word) rem16u#37 (word) rem16u#35 
Alias (byte*) print_line_cursor#15 = (byte*) print_line_cursor#5 (byte*) print_line_cursor#42 (byte*) print_line_cursor#39 (byte*) print_line_cursor#36 (byte*) print_line_cursor#32 (byte*) print_line_cursor#28 (byte*) print_line_cursor#23 
Alias (byte*) print_char_cursor#15 = (byte*) print_char_cursor#53 
Alias (byte*) print_char_cursor#16 = (byte*) print_char_cursor#54 
Alias (byte*) print_char_cursor#17 = (byte*) print_char_cursor#55 
Alias (byte*) print_char_cursor#18 = (byte*) print_char_cursor#56 
Alias (byte*) print_char_cursor#19 = (byte*) print_char_cursor#57 
Alias (byte*) print_char_cursor#20 = (byte*) print_char_cursor#58 
Alias (byte*) print_char_cursor#21 = (byte*) print_char_cursor#59 
Alias (byte*) print_line_cursor#16 = (byte*) print_line_cursor#6 
Alias (byte*) print_char_cursor#22 = (byte*) print_char_cursor#60 
Alias (byte) main::i#10 = (byte) main::i#3 (byte) main::i#2 (byte) main::i#8 (byte) main::i#4 (byte) main::i#9 (byte) main::i#5 (byte) main::i#6 (byte) main::i#11 (byte) main::i#7 
Alias (byte*) print_char_cursor#83 = (byte*) print_char_cursor#88 (byte*) print_char_cursor#84 
Alias (byte*) print_line_cursor#24 = (byte*) print_line_cursor#47 (byte*) print_line_cursor#48 (byte*) print_line_cursor#45 (byte*) print_line_cursor#43 (byte*) print_line_cursor#40 (byte*) print_line_cursor#37 (byte*) print_line_cursor#33 (byte*) print_line_cursor#29 (byte*) print_line_cursor#46 (byte*) print_line_cursor#44 (byte*) print_line_cursor#41 (byte*) print_line_cursor#38 (byte*) print_line_cursor#34 (byte*) print_line_cursor#30 (byte*) print_line_cursor#25 
Alias (word) rem16u#15 = (word) rem16u#51 (word) rem16u#34 (word) rem16u#50 (word) rem16u#48 (word) rem16u#46 (word) rem16u#44 (word) rem16u#42 (word) rem16u#40 (word) rem16u#38 (word) rem16u#36 (word) rem16u#33 (word) rem16u#32 (word) rem16u#31 (word) rem16u#30 (word) rem16u#29 (word) rem16u#28 (word) rem16u#25 (word) rem16u#21 (word) rem16u#6 
Alias (byte*) print_char_cursor#23 = (byte*) print_char_cursor#61 
Alias (byte*) print_char_cursor#24 = (byte*) print_char_cursor#62 
Alias (byte*) print_char_cursor#25 = (byte*) print_char_cursor#63 
Alias (byte*) print_char_cursor#26 = (byte*) print_char_cursor#64 
Alias (byte*) print_char_cursor#27 = (byte*) print_char_cursor#65 
Alias (byte*) print_char_cursor#28 = (byte*) print_char_cursor#66 
Alias (byte*) print_char_cursor#29 = (byte*) print_char_cursor#67 
Alias (byte*) print_line_cursor#17 = (byte*) print_line_cursor#7 
Alias (byte*) print_char_cursor#30 = (byte*) print_char_cursor#68 
Alias (byte*) print_char_cursor#31 = (byte*) print_char_cursor#69 
Alias (byte*) print_char_cursor#32 = (byte*) print_char_cursor#70 
Alias (byte*) print_char_cursor#33 = (byte*) print_char_cursor#71 
Alias (byte*) print_char_cursor#34 = (byte*) print_char_cursor#72 
Alias (byte*) print_char_cursor#35 = (byte*) print_char_cursor#73 
Alias (byte*) print_char_cursor#36 = (byte*) print_char_cursor#74 
Alias (byte*) print_line_cursor#18 = (byte*) print_line_cursor#8 (byte*) print_line_cursor#19 (byte*) print_line_cursor#9 
Alias (byte*) print_char_cursor#37 = (byte*) print_char_cursor#75 (byte*) print_char_cursor#76 (byte*) print_char_cursor#38 
Alias (word) lin16u_gen::ampl#0 = (word~) lin16u_gen::$0 
Alias (word) divr16u::divisor#0 = (word~) lin16u_gen::$1 
Alias (word) divr16u::return#2 = (word) divr16u::return#5 
Alias (word) lin16u_gen::length#3 = (word) lin16u_gen::length#4 (word) lin16u_gen::length#7 
Alias (word) lin16u_gen::min#3 = (word) lin16u_gen::min#5 (word) lin16u_gen::min#4 
Alias (word*) lin16u_gen::lintab#6 = (word*) lin16u_gen::lintab#7 (word*) lin16u_gen::lintab#8 
Alias (word) rem16u#16 = (word) rem16u#7 
Alias (word) lin16u_gen::stepi#0 = (word~) lin16u_gen::$2 (word) lin16u_gen::stepi#1 
Alias (word) divr16u::divisor#1 = (word~) lin16u_gen::$3 
Alias (word) divr16u::return#3 = (word) divr16u::return#6 
Alias (word) rem16u#17 = (word) rem16u#8 
Alias (word) lin16u_gen::stepf#0 = (word~) lin16u_gen::$4 
Alias (dword) lin16u_gen::step#0 = (dword~) lin16u_gen::$8 
Alias (dword) lin16u_gen::val#0 = (dword~) lin16u_gen::$9 
Alias (dword) lin16u_gen::val#2 = (dword) lin16u_gen::val#3 
Alias (word*) lin16u_gen::lintab#4 = (word*) lin16u_gen::lintab#5 
Alias (dword) lin16u_gen::step#1 = (dword) lin16u_gen::step#2 
Alias (word) lin16u_gen::i#2 = (word) lin16u_gen::i#3 
Alias (word) lin16u_gen::length#5 = (word) lin16u_gen::length#6 
Alias (word) rem16u#18 = (word) rem16u#26 (word) rem16u#23 (word) rem16u#9 
Alias (dword) lin16u_gen::val#1 = (dword~) lin16u_gen::$7 
Alias (word) rem16u#10 = (word) rem16u#19 
Alias (byte*) print_line_cursor#10 = (byte*) print_line_cursor#20 
Alias (byte*) print_char_cursor#39 = (byte*) print_char_cursor#77 
Successful SSA optimization Pass2AliasElimination
Alias (word) divr16u::dividend#3 = (word) divr16u::dividend#4 
Alias (word) divr16u::quotient#3 = (word) divr16u::quotient#6 
Alias (word) divr16u::divisor#2 = (word) divr16u::divisor#4 (word) divr16u::divisor#7 
Alias (byte) divr16u::i#2 = (byte) divr16u::i#3 (byte) divr16u::i#5 
Alias (word) divr16u::dividend#0 = (word) divr16u::dividend#6 
Successful SSA optimization Pass2AliasElimination
Identical Phi Values (word) divr16u::divisor#2 (word) divr16u::divisor#6
Identical Phi Values (word) memset::num#1 (word) memset::num#0
Identical Phi Values (void*) memset::str#2 (void*) memset::str#0
Identical Phi Values (byte) memset::c#3 (byte) memset::c#0
Identical Phi Values (byte*) memset::end#1 (byte*) memset::end#0
Identical Phi Values (void*) memset::str#4 (void*) memset::str#2
Identical Phi Values (byte) memset::c#1 (byte) memset::c#3
Identical Phi Values (byte*) print_char_cursor#42 (byte*) print_char_cursor#79
Identical Phi Values (byte*) print_char_cursor#44 (byte*) print_char_cursor#10
Identical Phi Values (byte*) print_char_cursor#45 (byte*) print_char_cursor#10
Identical Phi Values (byte*) print_char_cursor#47 (byte*) print_char_cursor#11
Identical Phi Values (byte*) print_char_cursor#10 (byte*) print_char_cursor#11
Identical Phi Values (byte*) print_line_cursor#14 (byte*) print_screen#3
Identical Phi Values (word) rem16u#20 (word) rem16u#0
Identical Phi Values (byte*) print_screen#3 (byte*) print_line_cursor#0
Identical Phi Values (byte*) print_line_cursor#22 (byte*) print_line_cursor#0
Identical Phi Values (byte*) print_char_cursor#82 (byte*) print_line_cursor#0
Identical Phi Values (word) rem16u#12 (word) rem16u#18
Identical Phi Values (word) rem16u#13 (word) rem16u#18
Identical Phi Values (word) rem16u#14 (word) rem16u#18
Identical Phi Values (byte*) print_line_cursor#15 (byte*) print_line_cursor#14
Identical Phi Values (byte*) print_char_cursor#15 (byte*) print_line_cursor#14
Identical Phi Values (byte*) print_char_cursor#16 (byte*) print_char_cursor#2
Identical Phi Values (byte*) print_char_cursor#17 (byte*) print_char_cursor#45
Identical Phi Values (byte*) print_char_cursor#18 (byte*) print_char_cursor#2
Identical Phi Values (byte*) print_char_cursor#19 (byte*) print_char_cursor#45
Identical Phi Values (byte*) print_char_cursor#20 (byte*) print_char_cursor#2
Identical Phi Values (byte*) print_char_cursor#21 (byte*) print_char_cursor#45
Identical Phi Values (byte*) print_line_cursor#16 (byte*) print_line_cursor#1
Identical Phi Values (byte*) print_char_cursor#22 (byte*) print_line_cursor#1
Identical Phi Values (word) rem16u#15 (word) rem16u#14
Identical Phi Values (byte*) print_char_cursor#23 (byte*) print_char_cursor#10
Identical Phi Values (byte*) print_char_cursor#24 (byte*) print_char_cursor#2
Identical Phi Values (byte*) print_char_cursor#25 (byte*) print_char_cursor#45
Identical Phi Values (byte*) print_char_cursor#26 (byte*) print_char_cursor#2
Identical Phi Values (byte*) print_char_cursor#27 (byte*) print_char_cursor#45
Identical Phi Values (byte*) print_char_cursor#28 (byte*) print_char_cursor#2
Identical Phi Values (byte*) print_char_cursor#29 (byte*) print_char_cursor#45
Identical Phi Values (byte*) print_line_cursor#17 (byte*) print_line_cursor#1
Identical Phi Values (byte*) print_char_cursor#30 (byte*) print_line_cursor#1
Identical Phi Values (byte*) print_char_cursor#31 (byte*) print_char_cursor#2
Identical Phi Values (byte*) print_char_cursor#32 (byte*) print_char_cursor#45
Identical Phi Values (byte*) print_char_cursor#33 (byte*) print_char_cursor#2
Identical Phi Values (byte*) print_char_cursor#34 (byte*) print_char_cursor#45
Identical Phi Values (byte*) print_char_cursor#35 (byte*) print_char_cursor#2
Identical Phi Values (byte*) print_char_cursor#36 (byte*) print_char_cursor#45
Identical Phi Values (byte*) print_line_cursor#18 (byte*) print_line_cursor#1
Identical Phi Values (byte*) print_char_cursor#37 (byte*) print_line_cursor#1
Identical Phi Values (word) rem16u#16 (word) rem16u#1
Identical Phi Values (word) rem16u#17 (word) rem16u#1
Identical Phi Values (word) lin16u_gen::length#5 (word) lin16u_gen::length#3
Identical Phi Values (dword) lin16u_gen::step#1 (dword) lin16u_gen::step#0
Identical Phi Values (word) rem16u#18 (word) rem16u#17
Identical Phi Values (word) rem16u#10 (word) rem16u#15
Identical Phi Values (byte*) print_line_cursor#10 (byte*) print_line_cursor#18
Identical Phi Values (byte*) print_char_cursor#39 (byte*) print_char_cursor#37
Successful SSA optimization Pass2IdenticalPhiElimination
Identical Phi Values (void*) memset::return#0 (void*) memset::str#0
Identical Phi Values (byte*) print_char_cursor#79 (byte*) print_char_cursor#11
Identical Phi Values (byte*) print_char_cursor#80 (byte*) print_char_cursor#2
Identical Phi Values (byte*) print_char_cursor#83 (byte*) print_line_cursor#1
Identical Phi Values (byte*) print_line_cursor#24 (byte*) print_line_cursor#1
Successful SSA optimization Pass2IdenticalPhiElimination
Simple Condition (bool~) divr16u::$4 [9] if((byte~) divr16u::$2==(byte) 0) goto divr16u::@2
Simple Condition (bool~) divr16u::$9 [14] if((word) divr16u::rem#6<(word) divr16u::divisor#6) goto divr16u::@3
Simple Condition (bool~) divr16u::$11 [19] if((byte) divr16u::i#1!=rangelast(0,$f)) goto divr16u::@1
Simple Condition (bool~) memset::$1 [26] if((word) memset::num#0<=(byte) 0) goto memset::@1
Simple Condition (bool~) memset::$4 [33] if((byte*) memset::dst#2!=(byte*) memset::end#0) goto memset::@5
Simple Condition (bool~) print_str::$0 [41] if((byte) 0!=*((byte*) print_str::str#10)) goto print_str::@2
Simple Condition (bool~) print_ln::$1 [50] if((byte*) print_line_cursor#1<(byte*) print_char_cursor#11) goto print_ln::@1
Simple Condition (bool~) main::$18 [125] if((byte) main::i#10<(byte) $14) goto main::@2
Simple Condition (bool~) lin16u_gen::$5 [195] if((word) lin16u_gen::i#2<(word) lin16u_gen::length#3) goto lin16u_gen::@2
Successful SSA optimization Pass2ConditionalJumpSimplification
Constant (const word) rem16u#0 = 0
Constant (const word) divr16u::quotient#0 = 0
Constant (const byte) divr16u::i#0 = 0
Constant (const byte*) print_line_cursor#0 = (byte*) 1024
Constant (const byte) memset::c#0 = ' '
Constant (const word) memset::num#0 = $3e8
Constant (const word) lin16u_gen::min#0 = $22d
Constant (const word) lin16u_gen::max#0 = $7461
Constant (const word*) lin16u_gen::lintab#0 = main::lintab1
Constant (const word) lin16u_gen::length#0 = $14
Constant (const word) lin16u_gen::min#1 = $79cb
Constant (const word) lin16u_gen::max#1 = $f781
Constant (const word*) lin16u_gen::lintab#1 = main::lintab2
Constant (const word) lin16u_gen::length#1 = $14
Constant (const word) lin16u_gen::min#2 = 0
Constant (const word) lin16u_gen::max#2 = $6488
Constant (const word*) lin16u_gen::lintab#2 = main::lintab3
Constant (const word) lin16u_gen::length#2 = $14
Constant (const byte*) print_str::str#1 = main::str
Constant (const word) print_word::w#0 = $22d
Constant (const byte*) print_str::str#2 = main::str1
Constant (const word) print_word::w#1 = $79cb
Constant (const byte*) print_str::str#3 = main::str2
Constant (const word) print_word::w#2 = 0
Constant (const byte) main::i#0 = 0
Constant (const byte*) print_str::str#4 = main::str3
Constant (const byte*) print_str::str#5 = main::str4
Constant (const byte*) print_str::str#6 = main::str5
Constant (const byte*) print_str::str#7 = main::str6
Constant (const word) print_word::w#6 = $7461
Constant (const byte*) print_str::str#8 = main::str7
Constant (const word) print_word::w#7 = $f781
Constant (const byte*) print_str::str#9 = main::str8
Constant (const word) print_word::w#8 = $6488
Constant (const word) divr16u::rem#3 = 0
Constant (const word) divr16u::dividend#2 = 0
Constant (const word) lin16u_gen::i#0 = 0
Successful SSA optimization Pass2ConstantIdentification
Constant (const void*) memset::str#0 = (void*)print_line_cursor#0
Successful SSA optimization Pass2ConstantIdentification
Constant (const byte*) memset::$2 = (byte*)memset::str#0
Constant (const byte*) memset::dst#0 = (byte*)memset::str#0
Constant (const void*) memset::return#2 = memset::str#0
Successful SSA optimization Pass2ConstantIdentification
if() condition always false - eliminating [26] if((const word) memset::num#0<=(byte) 0) goto memset::@1
Successful SSA optimization Pass2ConstantIfs
Consolidated constant strings into (const byte*) main::str
Consolidated constant strings into (const byte*) main::str1
Successful SSA optimization Pass2ConstantStringConsolidation
Resolved ranged next value [17] divr16u::i#1 ← ++ divr16u::i#2 to ++
Resolved ranged comparison value [19] if(divr16u::i#1!=rangelast(0,$f)) goto divr16u::@1 to (number) $10
Eliminating unused variable - keeping the phi block (word) rem16u#22
Eliminating unused constant (const void*) memset::return#2
Successful SSA optimization PassNEliminateUnusedVars
Eliminating unused constant (const word) rem16u#0
Successful SSA optimization PassNEliminateUnusedVars
Adding number conversion cast (unumber) $10 in if((byte) divr16u::i#1!=(number) $10) goto divr16u::@1
Successful SSA optimization PassNAddNumberTypeConversions
Simplifying constant integer cast $10
Successful SSA optimization PassNCastSimplification
Finalized unsigned number type (byte) $10
Successful SSA optimization PassNFinalizeNumberTypeConversions
Constant right-side identified [18] (byte*) memset::end#0 ← (const byte*) memset::$2 + (const word) memset::num#0
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) memset::end#0 = memset::$2+memset::num#0
Successful SSA optimization Pass2ConstantIdentification
Rewriting multiplication to use shift [71] (byte~) main::$27 ← (byte) main::i#10 * (const byte) SIZEOF_WORD
Rewriting multiplication to use shift [75] (byte~) main::$28 ← (byte) main::i#10 * (const byte) SIZEOF_WORD
Rewriting multiplication to use shift [79] (byte~) main::$29 ← (byte) main::i#10 * (const byte) SIZEOF_WORD
Successful SSA optimization Pass2MultiplyToShiftRewriting
Inlining constant with var siblings (const word) divr16u::quotient#0
Inlining constant with var siblings (const byte) divr16u::i#0
Inlining constant with var siblings (const word) divr16u::rem#3
Inlining constant with var siblings (const word) divr16u::dividend#2
Inlining constant with var siblings (const byte*) memset::dst#0
Inlining constant with var siblings (const byte*) print_str::str#1
Inlining constant with var siblings (const byte*) print_str::str#2
Inlining constant with var siblings (const byte*) print_str::str#3
Inlining constant with var siblings (const byte*) print_str::str#4
Inlining constant with var siblings (const byte*) print_str::str#5
Inlining constant with var siblings (const byte*) print_str::str#6
Inlining constant with var siblings (const byte*) print_str::str#7
Inlining constant with var siblings (const byte*) print_str::str#8
Inlining constant with var siblings (const byte*) print_str::str#9
Inlining constant with var siblings (const word) print_word::w#0
Inlining constant with var siblings (const word) print_word::w#1
Inlining constant with var siblings (const word) print_word::w#2
Inlining constant with var siblings (const word) print_word::w#6
Inlining constant with var siblings (const word) print_word::w#7
Inlining constant with var siblings (const word) print_word::w#8
Inlining constant with var siblings (const byte) main::i#0
Inlining constant with var siblings (const word) lin16u_gen::min#0
Inlining constant with var siblings (const word) lin16u_gen::max#0
Inlining constant with var siblings (const word*) lin16u_gen::lintab#0
Inlining constant with var siblings (const word) lin16u_gen::length#0
Inlining constant with var siblings (const word) lin16u_gen::min#1
Inlining constant with var siblings (const word) lin16u_gen::max#1
Inlining constant with var siblings (const word*) lin16u_gen::lintab#1
Inlining constant with var siblings (const word) lin16u_gen::length#1
Inlining constant with var siblings (const word) lin16u_gen::min#2
Inlining constant with var siblings (const word) lin16u_gen::max#2
Inlining constant with var siblings (const word*) lin16u_gen::lintab#2
Inlining constant with var siblings (const word) lin16u_gen::length#2
Inlining constant with var siblings (const word) lin16u_gen::i#0
Inlining constant with var siblings (const byte*) print_line_cursor#0
Constant inlined main::str4 = (const byte*) main::str1
Constant inlined main::str5 = (const byte*) main::str1
Constant inlined divr16u::rem#3 = (byte) 0
Constant inlined main::str6 = (const byte*) main::str
Constant inlined main::str7 = (const byte*) main::str1
Constant inlined divr16u::i#0 = (byte) 0
Constant inlined main::str2 = (const byte*) main::str1
Constant inlined main::str3 = (const byte*) main::str1
Constant inlined lin16u_gen::max#0 = (word) $7461
Constant inlined lin16u_gen::max#2 = (word) $6488
Constant inlined lin16u_gen::max#1 = (word) $f781
Constant inlined memset::$2 = (byte*)(const void*) memset::str#0
Constant inlined divr16u::quotient#0 = (word) 0
Constant inlined main::i#0 = (byte) 0
Constant inlined lin16u_gen::min#0 = (word) $22d
Constant inlined print_line_cursor#0 = (byte*) 1024
Constant inlined print_word::w#1 = (word) $79cb
Constant inlined print_word::w#0 = (word) $22d
Constant inlined print_word::w#2 = (byte) 0
Constant inlined divr16u::dividend#2 = (byte) 0
Constant inlined print_word::w#7 = (word) $f781
Constant inlined print_word::w#6 = (word) $7461
Constant inlined print_word::w#8 = (word) $6488
Constant inlined lin16u_gen::length#2 = (byte) $14
Constant inlined print_str::str#9 = (const byte*) main::str1
Constant inlined lin16u_gen::length#1 = (byte) $14
Constant inlined lin16u_gen::length#0 = (byte) $14
Constant inlined print_str::str#4 = (const byte*) main::str1
Constant inlined print_str::str#3 = (const byte*) main::str1
Constant inlined print_str::str#2 = (const byte*) main::str1
Constant inlined memset::dst#0 = (byte*)(const void*) memset::str#0
Constant inlined print_str::str#1 = (const byte*) main::str
Constant inlined print_str::str#8 = (const byte*) main::str1
Constant inlined main::str8 = (const byte*) main::str1
Constant inlined lin16u_gen::lintab#2 = (const word*) main::lintab3
Constant inlined lin16u_gen::min#1 = (word) $79cb
Constant inlined lin16u_gen::i#0 = (word) 0
Constant inlined print_str::str#7 = (const byte*) main::str
Constant inlined lin16u_gen::lintab#1 = (const word*) main::lintab2
Constant inlined lin16u_gen::min#2 = (byte) 0
Constant inlined print_str::str#6 = (const byte*) main::str1
Constant inlined lin16u_gen::lintab#0 = (const word*) main::lintab1
Constant inlined print_str::str#5 = (const byte*) main::str1
Successful SSA optimization Pass2ConstantInlining
Identical Phi Values (word) lin16u_gen::length#3 (byte) $14
Successful SSA optimization Pass2IdenticalPhiElimination
Constant right-side identified [94] (word) divr16u::divisor#0 ← (byte) $14 - (byte) 1
Constant right-side identified [99] (word) divr16u::divisor#1 ← (byte) $14 - (byte) 1
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const word) divr16u::divisor#0 = $14-1
Constant (const word) divr16u::divisor#1 = $14-1
Successful SSA optimization Pass2ConstantIdentification
Inlining constant with var siblings (const word) divr16u::divisor#0
Inlining constant with var siblings (const word) divr16u::divisor#1
Constant inlined divr16u::divisor#1 = (byte) $14-(byte) 1
Constant inlined divr16u::divisor#0 = (byte) $14-(byte) 1
Successful SSA optimization Pass2ConstantInlining
Added new block during phi lifting divr16u::@8(between divr16u::@3 and divr16u::@1)
Added new block during phi lifting divr16u::@9(between divr16u::@1 and divr16u::@2)
Added new block during phi lifting divr16u::@10(between divr16u::@2 and divr16u::@3)
Added new block during phi lifting print_ln::@3(between print_ln::@1 and print_ln::@1)
Adding NOP phi() at start of @begin
Adding NOP phi() at start of @2
Adding NOP phi() at start of @21
Adding NOP phi() at start of @47
Adding NOP phi() at start of @48
Adding NOP phi() at start of @end
Adding NOP phi() at start of main
Adding NOP phi() at start of main::@7
Adding NOP phi() at start of main::@8
Adding NOP phi() at start of main::@9
Adding NOP phi() at start of main::@10
Adding NOP phi() at start of main::@11
Adding NOP phi() at start of main::@13
Adding NOP phi() at start of main::@15
Adding NOP phi() at start of main::@16
Adding NOP phi() at start of main::@17
Adding NOP phi() at start of main::@26
Adding NOP phi() at start of main::@28
Adding NOP phi() at start of main::@30
Adding NOP phi() at start of main::@32
Adding NOP phi() at start of print_ln::@2
Adding NOP phi() at start of print_word::@2
Adding NOP phi() at start of print_byte::@2
Adding NOP phi() at start of print_cls
Adding NOP phi() at start of print_cls::@1
Adding NOP phi() at start of memset
Adding NOP phi() at start of memset::@2
Adding NOP phi() at start of memset::@1
CALL GRAPH
Calls in [] to main:4 
Calls in [main] to lin16u_gen:8 lin16u_gen:10 lin16u_gen:12 print_cls:14 print_str:16 print_word:18 print_str:20 print_word:22 print_str:24 print_word:26 print_ln:28 print_str:33 print_word:35 print_str:37 print_word:39 print_str:41 print_word:43 print_ln:45 print_byte:51 print_str:53 print_word:57 print_str:59 print_word:63 print_str:65 print_word:69 print_ln:71 
Calls in [print_word] to print_byte:86 print_byte:90 
Calls in [print_byte] to print_char:98 print_char:103 
Calls in [print_cls] to memset:122 
Calls in [lin16u_gen] to divr16u:138 divr16u:143 

Created 29 initial phi equivalence classes
Coalesced [19] print_char_cursor#91 ← print_char_cursor#11
Coalesced (already) [23] print_char_cursor#92 ← print_char_cursor#11
Not coalescing [32] print_char_cursor#98 ← print_line_cursor#1
Coalesced (already) [36] print_char_cursor#96 ← print_char_cursor#11
Coalesced (already) [40] print_char_cursor#97 ← print_char_cursor#11
Coalesced [44] print_line_cursor#50 ← print_line_cursor#1
Coalesced [49] print_byte::b#5 ← print_byte::b#2
Not coalescing [50] print_char_cursor#101 ← print_line_cursor#1
Coalesced (already) [52] print_char_cursor#93 ← print_char_cursor#11
Coalesced [56] print_word::w#11 ← print_word::w#3
Coalesced (already) [58] print_char_cursor#94 ← print_char_cursor#11
Coalesced [62] print_word::w#12 ← print_word::w#4
Coalesced (already) [64] print_char_cursor#95 ← print_char_cursor#11
Coalesced [68] print_word::w#13 ← print_word::w#5
Coalesced (already) [70] print_line_cursor#49 ← print_line_cursor#1
Coalesced [73] main::i#12 ← main::i#1
Coalesced [75] print_line_cursor#51 ← print_line_cursor#21
Coalesced (already) [81] print_line_cursor#52 ← print_line_cursor#1
Coalesced [84] print_byte::b#6 ← print_byte::b#0
Coalesced [85] print_char_cursor#102 ← print_char_cursor#2
Coalesced [88] print_byte::b#7 ← print_byte::b#1
Coalesced [89] print_char_cursor#103 ← print_char_cursor#11
Coalesced [96] print_char::ch#3 ← print_char::ch#0
Coalesced [97] print_char_cursor#104 ← print_char_cursor#81
Coalesced [101] print_char::ch#4 ← print_char::ch#1
Coalesced (already) [102] print_char_cursor#105 ← print_char_cursor#11
Coalesced [111] print_str::str#13 ← print_str::str#12
Coalesced (already) [112] print_char_cursor#99 ← print_char_cursor#86
Coalesced [119] print_str::str#14 ← print_str::str#0
Coalesced [120] print_char_cursor#100 ← print_char_cursor#1
Coalesced [133] memset::dst#4 ← memset::dst#1
Coalesced [137] divr16u::dividend#9 ← divr16u::dividend#1
Coalesced [142] divr16u::rem#12 ← divr16u::rem#4
Coalesced [148] lin16u_gen::val#5 ← lin16u_gen::val#0
Coalesced [149] lin16u_gen::lintab#10 ← lin16u_gen::lintab#6
Coalesced [158] lin16u_gen::i#4 ← lin16u_gen::i#1
Coalesced [159] lin16u_gen::val#4 ← lin16u_gen::val#1
Coalesced [160] lin16u_gen::lintab#9 ← lin16u_gen::lintab#3
Coalesced [162] divr16u::rem#13 ← divr16u::rem#10
Coalesced [163] divr16u::dividend#10 ← divr16u::dividend#5
Coalesced [170] divr16u::rem#16 ← divr16u::rem#1
Coalesced [177] divr16u::rem#18 ← divr16u::rem#2
Coalesced [178] divr16u::return#8 ← divr16u::quotient#2
Coalesced [184] divr16u::rem#14 ← divr16u::rem#11
Coalesced [185] divr16u::dividend#11 ← divr16u::dividend#0
Coalesced [186] divr16u::quotient#9 ← divr16u::return#0
Coalesced [187] divr16u::i#7 ← divr16u::i#1
Coalesced [188] divr16u::rem#17 ← divr16u::rem#6
Coalesced [189] divr16u::return#7 ← divr16u::quotient#1
Coalesced [190] divr16u::rem#15 ← divr16u::rem#0
Coalesced down to 18 phi equivalence classes
Culled Empty Block (label) @2
Culled Empty Block (label) @21
Culled Empty Block (label) @48
Culled Empty Block (label) main::@17
Culled Empty Block (label) main::@32
Culled Empty Block (label) print_ln::@2
Culled Empty Block (label) print_ln::@3
Culled Empty Block (label) print_word::@2
Culled Empty Block (label) print_byte::@2
Culled Empty Block (label) print_cls::@1
Culled Empty Block (label) memset::@2
Culled Empty Block (label) memset::@1
Culled Empty Block (label) divr16u::@8
Culled Empty Block (label) divr16u::@10
Culled Empty Block (label) divr16u::@9
Renumbering block @47 to @1
Renumbering block memset::@4 to memset::@1
Renumbering block memset::@5 to memset::@2
Renumbering block main::@7 to main::@4
Renumbering block main::@8 to main::@5
Renumbering block main::@9 to main::@6
Renumbering block main::@10 to main::@7
Renumbering block main::@11 to main::@8
Renumbering block main::@12 to main::@9
Renumbering block main::@13 to main::@10
Renumbering block main::@14 to main::@11
Renumbering block main::@15 to main::@12
Renumbering block main::@16 to main::@13
Renumbering block main::@18 to main::@14
Renumbering block main::@19 to main::@15
Renumbering block main::@20 to main::@16
Renumbering block main::@21 to main::@17
Renumbering block main::@22 to main::@18
Renumbering block main::@23 to main::@19
Renumbering block main::@24 to main::@20
Renumbering block main::@25 to main::@21
Renumbering block main::@26 to main::@22
Renumbering block main::@27 to main::@23
Renumbering block main::@28 to main::@24
Renumbering block main::@29 to main::@25
Renumbering block main::@30 to main::@26
Renumbering block main::@31 to main::@27
Renumbering block lin16u_gen::@7 to lin16u_gen::@3
Renumbering block lin16u_gen::@8 to lin16u_gen::@4
Adding NOP phi() at start of @begin
Adding NOP phi() at start of @1
Adding NOP phi() at start of @end
Adding NOP phi() at start of main
Adding NOP phi() at start of main::@4
Adding NOP phi() at start of main::@5
Adding NOP phi() at start of main::@6
Adding NOP phi() at start of main::@7
Adding NOP phi() at start of main::@8
Adding NOP phi() at start of main::@9
Adding NOP phi() at start of main::@10
Adding NOP phi() at start of main::@11
Adding NOP phi() at start of main::@12
Adding NOP phi() at start of main::@13
Adding NOP phi() at start of main::@22
Adding NOP phi() at start of main::@23
Adding NOP phi() at start of main::@24
Adding NOP phi() at start of main::@25
Adding NOP phi() at start of main::@26
Adding NOP phi() at start of main::@27
Adding NOP phi() at start of main::@14
Adding NOP phi() at start of main::@16
Adding NOP phi() at start of main::@18
Adding NOP phi() at start of main::@20
Adding NOP phi() at start of print_cls
Adding NOP phi() at start of memset

FINAL CONTROL FLOW GRAPH
@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 lin16u_gen 
  to:main::@4
main::@4: scope:[main]  from main
  [6] phi()
  [7] call lin16u_gen 
  to:main::@5
main::@5: scope:[main]  from main::@4
  [8] phi()
  [9] call lin16u_gen 
  to:main::@6
main::@6: scope:[main]  from main::@5
  [10] phi()
  [11] call print_cls 
  to:main::@7
main::@7: scope:[main]  from main::@6
  [12] phi()
  [13] call print_str 
  to:main::@8
main::@8: scope:[main]  from main::@7
  [14] phi()
  [15] call print_word 
  to:main::@9
main::@9: scope:[main]  from main::@8
  [16] phi()
  [17] call print_str 
  to:main::@10
main::@10: scope:[main]  from main::@9
  [18] phi()
  [19] call print_word 
  to:main::@11
main::@11: scope:[main]  from main::@10
  [20] phi()
  [21] call print_str 
  to:main::@12
main::@12: scope:[main]  from main::@11
  [22] phi()
  [23] call print_word 
  to:main::@13
main::@13: scope:[main]  from main::@12
  [24] phi()
  [25] call print_ln 
  to:main::@1
main::@1: scope:[main]  from main::@13 main::@21
  [26] (byte) main::i#10 ← phi( main::@13/(byte) 0 main::@21/(byte) main::i#1 )
  [27] if((byte) main::i#10<(byte) $14) goto main::@2
  to:main::@3
main::@3: scope:[main]  from main::@1
  [28] (byte*) print_char_cursor#98 ← (byte*) print_line_cursor#1
  [29] call print_str 
  to:main::@22
main::@22: scope:[main]  from main::@3
  [30] phi()
  [31] call print_word 
  to:main::@23
main::@23: scope:[main]  from main::@22
  [32] phi()
  [33] call print_str 
  to:main::@24
main::@24: scope:[main]  from main::@23
  [34] phi()
  [35] call print_word 
  to:main::@25
main::@25: scope:[main]  from main::@24
  [36] phi()
  [37] call print_str 
  to:main::@26
main::@26: scope:[main]  from main::@25
  [38] phi()
  [39] call print_word 
  to:main::@27
main::@27: scope:[main]  from main::@26
  [40] phi()
  [41] call print_ln 
  to:main::@return
main::@return: scope:[main]  from main::@27
  [42] return 
  to:@return
main::@2: scope:[main]  from main::@1
  [43] (byte) print_byte::b#2 ← (byte) main::i#10
  [44] (byte*) print_char_cursor#101 ← (byte*) print_line_cursor#1
  [45] call print_byte 
  to:main::@14
main::@14: scope:[main]  from main::@2
  [46] phi()
  [47] call print_str 
  to:main::@15
main::@15: scope:[main]  from main::@14
  [48] (byte~) main::$27 ← (byte) main::i#10 << (byte) 1
  [49] (word) print_word::w#3 ← *((const word*) main::lintab1 + (byte~) main::$27)
  [50] call print_word 
  to:main::@16
main::@16: scope:[main]  from main::@15
  [51] phi()
  [52] call print_str 
  to:main::@17
main::@17: scope:[main]  from main::@16
  [53] (byte~) main::$28 ← (byte) main::i#10 << (byte) 1
  [54] (word) print_word::w#4 ← *((const word*) main::lintab2 + (byte~) main::$28)
  [55] call print_word 
  to:main::@18
main::@18: scope:[main]  from main::@17
  [56] phi()
  [57] call print_str 
  to:main::@19
main::@19: scope:[main]  from main::@18
  [58] (byte~) main::$29 ← (byte) main::i#10 << (byte) 1
  [59] (word) print_word::w#5 ← *((const word*) main::lintab3 + (byte~) main::$29)
  [60] call print_word 
  to:main::@20
main::@20: scope:[main]  from main::@19
  [61] phi()
  [62] call print_ln 
  to:main::@21
main::@21: scope:[main]  from main::@20
  [63] (byte) main::i#1 ← ++ (byte) main::i#10
  to:main::@1

(void()) print_ln()
print_ln: scope:[print_ln]  from main::@13 main::@20 main::@27
  [64] (byte*) print_line_cursor#21 ← phi( main::@13/(byte*) 1024 main::@20/(byte*) print_line_cursor#1 main::@27/(byte*) print_line_cursor#1 )
  to:print_ln::@1
print_ln::@1: scope:[print_ln]  from print_ln print_ln::@1
  [65] (byte*) print_line_cursor#11 ← phi( print_ln/(byte*) print_line_cursor#21 print_ln::@1/(byte*) print_line_cursor#1 )
  [66] (byte*) print_line_cursor#1 ← (byte*) print_line_cursor#11 + (byte) $28
  [67] if((byte*) print_line_cursor#1<(byte*) print_char_cursor#11) goto print_ln::@1
  to:print_ln::@return
print_ln::@return: scope:[print_ln]  from print_ln::@1
  [68] return 
  to:@return

(void()) print_word((word) print_word::w)
print_word: scope:[print_word]  from main::@10 main::@12 main::@15 main::@17 main::@19 main::@22 main::@24 main::@26 main::@8
  [69] (word) print_word::w#10 ← phi( main::@8/(word) $22d main::@10/(word) $79cb main::@12/(byte) 0 main::@15/(word) print_word::w#3 main::@17/(word) print_word::w#4 main::@19/(word) print_word::w#5 main::@22/(word) $7461 main::@24/(word) $f781 main::@26/(word) $6488 )
  [70] (byte) print_byte::b#0 ← > (word) print_word::w#10
  [71] call print_byte 
  to:print_word::@1
print_word::@1: scope:[print_word]  from print_word
  [72] (byte) print_byte::b#1 ← < (word) print_word::w#10
  [73] call print_byte 
  to:print_word::@return
print_word::@return: scope:[print_word]  from print_word::@1
  [74] return 
  to:@return

(void()) print_byte((byte) print_byte::b)
print_byte: scope:[print_byte]  from main::@2 print_word print_word::@1
  [75] (byte*) print_char_cursor#81 ← phi( main::@2/(byte*) print_char_cursor#101 print_word/(byte*) print_char_cursor#2 print_word::@1/(byte*) print_char_cursor#11 )
  [75] (byte) print_byte::b#3 ← phi( main::@2/(byte) print_byte::b#2 print_word/(byte) print_byte::b#0 print_word::@1/(byte) print_byte::b#1 )
  [76] (byte~) print_byte::$0 ← (byte) print_byte::b#3 >> (byte) 4
  [77] (byte) print_char::ch#0 ← *((const byte*) print_hextab + (byte~) print_byte::$0)
  [78] call print_char 
  to:print_byte::@1
print_byte::@1: scope:[print_byte]  from print_byte
  [79] (byte~) print_byte::$2 ← (byte) print_byte::b#3 & (byte) $f
  [80] (byte) print_char::ch#1 ← *((const byte*) print_hextab + (byte~) print_byte::$2)
  [81] call print_char 
  to:print_byte::@return
print_byte::@return: scope:[print_byte]  from print_byte::@1
  [82] return 
  to:@return

(void()) print_char((byte) print_char::ch)
print_char: scope:[print_char]  from print_byte print_byte::@1
  [83] (byte*) print_char_cursor#50 ← phi( print_byte/(byte*) print_char_cursor#81 print_byte::@1/(byte*) print_char_cursor#11 )
  [83] (byte) print_char::ch#2 ← phi( print_byte/(byte) print_char::ch#0 print_byte::@1/(byte) print_char::ch#1 )
  [84] *((byte*) print_char_cursor#50) ← (byte) print_char::ch#2
  [85] (byte*) print_char_cursor#11 ← ++ (byte*) print_char_cursor#50
  to:print_char::@return
print_char::@return: scope:[print_char]  from print_char
  [86] return 
  to:@return

(void()) print_str((byte*) print_str::str)
print_str: scope:[print_str]  from main::@11 main::@14 main::@16 main::@18 main::@23 main::@25 main::@3 main::@7 main::@9
  [87] (byte*) print_char_cursor#86 ← phi( main::@7/(byte*) 1024 main::@9/(byte*) print_char_cursor#11 main::@11/(byte*) print_char_cursor#11 main::@14/(byte*) print_char_cursor#11 main::@16/(byte*) print_char_cursor#11 main::@18/(byte*) print_char_cursor#11 main::@23/(byte*) print_char_cursor#11 main::@25/(byte*) print_char_cursor#11 main::@3/(byte*) print_char_cursor#98 )
  [87] (byte*) print_str::str#12 ← phi( main::@7/(const byte*) main::str main::@9/(const byte*) main::str1 main::@11/(const byte*) main::str1 main::@14/(const byte*) main::str1 main::@16/(const byte*) main::str1 main::@18/(const byte*) main::str1 main::@23/(const byte*) main::str1 main::@25/(const byte*) main::str1 main::@3/(const byte*) main::str )
  to:print_str::@1
print_str::@1: scope:[print_str]  from print_str print_str::@2
  [88] (byte*) print_char_cursor#2 ← phi( print_str/(byte*) print_char_cursor#86 print_str::@2/(byte*) print_char_cursor#1 )
  [88] (byte*) print_str::str#10 ← phi( print_str/(byte*) print_str::str#12 print_str::@2/(byte*) print_str::str#0 )
  [89] if((byte) 0!=*((byte*) print_str::str#10)) goto print_str::@2
  to:print_str::@return
print_str::@return: scope:[print_str]  from print_str::@1
  [90] return 
  to:@return
print_str::@2: scope:[print_str]  from print_str::@1
  [91] *((byte*) print_char_cursor#2) ← *((byte*) print_str::str#10)
  [92] (byte*) print_char_cursor#1 ← ++ (byte*) print_char_cursor#2
  [93] (byte*) print_str::str#0 ← ++ (byte*) print_str::str#10
  to:print_str::@1

(void()) print_cls()
print_cls: scope:[print_cls]  from main::@6
  [94] phi()
  [95] call memset 
  to:print_cls::@return
print_cls::@return: scope:[print_cls]  from print_cls
  [96] return 
  to:@return

(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num)
memset: scope:[memset]  from print_cls
  [97] phi()
  to:memset::@1
memset::@1: scope:[memset]  from memset memset::@2
  [98] (byte*) memset::dst#2 ← phi( memset/(byte*)(const void*) memset::str#0 memset::@2/(byte*) memset::dst#1 )
  [99] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2
  to:memset::@return
memset::@return: scope:[memset]  from memset::@1
  [100] return 
  to:@return
memset::@2: scope:[memset]  from memset::@1
  [101] *((byte*) memset::dst#2) ← (const byte) memset::c#0
  [102] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2
  to:memset::@1

(void()) lin16u_gen((word) lin16u_gen::min , (word) lin16u_gen::max , (word*) lin16u_gen::lintab , (word) lin16u_gen::length)
lin16u_gen: scope:[lin16u_gen]  from main main::@4 main::@5
  [103] (word*) lin16u_gen::lintab#6 ← phi( main/(const word*) main::lintab1 main::@4/(const word*) main::lintab2 main::@5/(const word*) main::lintab3 )
  [103] (word) lin16u_gen::min#3 ← phi( main/(word) $22d main::@4/(word) $79cb main::@5/(byte) 0 )
  [103] (word) lin16u_gen::max#3 ← phi( main/(word) $7461 main::@4/(word) $f781 main::@5/(word) $6488 )
  [104] (word) lin16u_gen::ampl#0 ← (word) lin16u_gen::max#3 - (word) lin16u_gen::min#3
  [105] (word) divr16u::dividend#1 ← (word) lin16u_gen::ampl#0
  [106] call divr16u 
  [107] (word) divr16u::return#2 ← (word) divr16u::return#0
  to:lin16u_gen::@3
lin16u_gen::@3: scope:[lin16u_gen]  from lin16u_gen
  [108] (word) lin16u_gen::stepi#0 ← (word) divr16u::return#2
  [109] (word) divr16u::rem#4 ← (word) rem16u#1
  [110] call divr16u 
  [111] (word) divr16u::return#3 ← (word) divr16u::return#0
  to:lin16u_gen::@4
lin16u_gen::@4: scope:[lin16u_gen]  from lin16u_gen::@3
  [112] (word) lin16u_gen::stepf#0 ← (word) divr16u::return#3
  [113] (dword) lin16u_gen::step#0 ← (word) lin16u_gen::stepi#0 dw= (word) lin16u_gen::stepf#0
  [114] (dword) lin16u_gen::val#0 ← (word) lin16u_gen::min#3 dw= (word) 0
  to:lin16u_gen::@1
lin16u_gen::@1: scope:[lin16u_gen]  from lin16u_gen::@2 lin16u_gen::@4
  [115] (word*) lin16u_gen::lintab#4 ← phi( lin16u_gen::@2/(word*) lin16u_gen::lintab#3 lin16u_gen::@4/(word*) lin16u_gen::lintab#6 )
  [115] (dword) lin16u_gen::val#2 ← phi( lin16u_gen::@2/(dword) lin16u_gen::val#1 lin16u_gen::@4/(dword) lin16u_gen::val#0 )
  [115] (word) lin16u_gen::i#2 ← phi( lin16u_gen::@2/(word) lin16u_gen::i#1 lin16u_gen::@4/(word) 0 )
  [116] if((word) lin16u_gen::i#2<(byte) $14) goto lin16u_gen::@2
  to:lin16u_gen::@return
lin16u_gen::@return: scope:[lin16u_gen]  from lin16u_gen::@1
  [117] return 
  to:@return
lin16u_gen::@2: scope:[lin16u_gen]  from lin16u_gen::@1
  [118] (word~) lin16u_gen::$6 ← > (dword) lin16u_gen::val#2
  [119] *((word*) lin16u_gen::lintab#4) ← (word~) lin16u_gen::$6
  [120] (dword) lin16u_gen::val#1 ← (dword) lin16u_gen::val#2 + (dword) lin16u_gen::step#0
  [121] (word*) lin16u_gen::lintab#3 ← (word*) lin16u_gen::lintab#4 + (const byte) SIZEOF_WORD
  [122] (word) lin16u_gen::i#1 ← ++ (word) lin16u_gen::i#2
  to:lin16u_gen::@1

(word()) divr16u((word) divr16u::dividend , (word) divr16u::divisor , (word) divr16u::rem)
divr16u: scope:[divr16u]  from lin16u_gen lin16u_gen::@3
  [123] (word) divr16u::divisor#6 ← phi( lin16u_gen/(byte) $14-(byte) 1 lin16u_gen::@3/(byte) $14-(byte) 1 )
  [123] (word) divr16u::dividend#5 ← phi( lin16u_gen/(word) divr16u::dividend#1 lin16u_gen::@3/(byte) 0 )
  [123] (word) divr16u::rem#10 ← phi( lin16u_gen/(byte) 0 lin16u_gen::@3/(word) divr16u::rem#4 )
  to:divr16u::@1
divr16u::@1: scope:[divr16u]  from divr16u divr16u::@3
  [124] (byte) divr16u::i#2 ← phi( divr16u/(byte) 0 divr16u::@3/(byte) divr16u::i#1 )
  [124] (word) divr16u::quotient#3 ← phi( divr16u/(word) 0 divr16u::@3/(word) divr16u::return#0 )
  [124] (word) divr16u::dividend#3 ← phi( divr16u/(word) divr16u::dividend#5 divr16u::@3/(word) divr16u::dividend#0 )
  [124] (word) divr16u::rem#5 ← phi( divr16u/(word) divr16u::rem#10 divr16u::@3/(word) divr16u::rem#11 )
  [125] (word) divr16u::rem#0 ← (word) divr16u::rem#5 << (byte) 1
  [126] (byte~) divr16u::$1 ← > (word) divr16u::dividend#3
  [127] (byte~) divr16u::$2 ← (byte~) divr16u::$1 & (byte) $80
  [128] if((byte~) divr16u::$2==(byte) 0) goto divr16u::@2
  to:divr16u::@4
divr16u::@4: scope:[divr16u]  from divr16u::@1
  [129] (word) divr16u::rem#1 ← (word) divr16u::rem#0 | (byte) 1
  to:divr16u::@2
divr16u::@2: scope:[divr16u]  from divr16u::@1 divr16u::@4
  [130] (word) divr16u::rem#6 ← phi( divr16u::@1/(word) divr16u::rem#0 divr16u::@4/(word) divr16u::rem#1 )
  [131] (word) divr16u::dividend#0 ← (word) divr16u::dividend#3 << (byte) 1
  [132] (word) divr16u::quotient#1 ← (word) divr16u::quotient#3 << (byte) 1
  [133] if((word) divr16u::rem#6<(word) divr16u::divisor#6) goto divr16u::@3
  to:divr16u::@5
divr16u::@5: scope:[divr16u]  from divr16u::@2
  [134] (word) divr16u::quotient#2 ← ++ (word) divr16u::quotient#1
  [135] (word) divr16u::rem#2 ← (word) divr16u::rem#6 - (word) divr16u::divisor#6
  to:divr16u::@3
divr16u::@3: scope:[divr16u]  from divr16u::@2 divr16u::@5
  [136] (word) divr16u::return#0 ← phi( divr16u::@2/(word) divr16u::quotient#1 divr16u::@5/(word) divr16u::quotient#2 )
  [136] (word) divr16u::rem#11 ← phi( divr16u::@2/(word) divr16u::rem#6 divr16u::@5/(word) divr16u::rem#2 )
  [137] (byte) divr16u::i#1 ← ++ (byte) divr16u::i#2
  [138] if((byte) divr16u::i#1!=(byte) $10) goto divr16u::@1
  to:divr16u::@6
divr16u::@6: scope:[divr16u]  from divr16u::@3
  [139] (word) rem16u#1 ← (word) divr16u::rem#11
  to:divr16u::@return
divr16u::@return: scope:[divr16u]  from divr16u::@6
  [140] return 
  to:@return


VARIABLE REGISTER WEIGHTS
(word()) divr16u((word) divr16u::dividend , (word) divr16u::divisor , (word) divr16u::rem)
(byte~) divr16u::$1 22.0
(byte~) divr16u::$2 22.0
(word) divr16u::dividend
(word) divr16u::dividend#0 2.75
(word) divr16u::dividend#1 4.0
(word) divr16u::dividend#3 5.0
(word) divr16u::dividend#5 4.0
(word) divr16u::divisor
(word) divr16u::divisor#6 1.375
(byte) divr16u::i
(byte) divr16u::i#1 16.5
(byte) divr16u::i#2 1.6923076923076923
(word) divr16u::quotient
(word) divr16u::quotient#1 16.5
(word) divr16u::quotient#2 11.0
(word) divr16u::quotient#3 2.75
(word) divr16u::rem
(word) divr16u::rem#0 8.25
(word) divr16u::rem#1 22.0
(word) divr16u::rem#10 4.0
(word) divr16u::rem#11 11.666666666666666
(word) divr16u::rem#2 22.0
(word) divr16u::rem#4 4.0
(word) divr16u::rem#5 24.0
(word) divr16u::rem#6 11.0
(word) divr16u::return
(word) divr16u::return#0 5.285714285714286
(word) divr16u::return#2 4.0
(word) divr16u::return#3 4.0
(void()) lin16u_gen((word) lin16u_gen::min , (word) lin16u_gen::max , (word*) lin16u_gen::lintab , (word) lin16u_gen::length)
(word~) lin16u_gen::$6 22.0
(word) lin16u_gen::ampl
(word) lin16u_gen::ampl#0 4.0
(word) lin16u_gen::i
(word) lin16u_gen::i#1 22.0
(word) lin16u_gen::i#2 5.5
(word) lin16u_gen::length
(word*) lin16u_gen::lintab
(word*) lin16u_gen::lintab#3 11.0
(word*) lin16u_gen::lintab#4 7.000000000000001
(word*) lin16u_gen::lintab#6 0.16666666666666666
(word) lin16u_gen::max
(word) lin16u_gen::max#3 2.0
(word) lin16u_gen::min
(word) lin16u_gen::min#3 0.36363636363636365
(dword) lin16u_gen::step
(dword) lin16u_gen::step#0 1.4444444444444446
(word) lin16u_gen::stepf
(word) lin16u_gen::stepf#0 4.0
(word) lin16u_gen::stepi
(word) lin16u_gen::stepi#0 0.8
(dword) lin16u_gen::val
(dword) lin16u_gen::val#0 4.0
(dword) lin16u_gen::val#1 7.333333333333333
(dword) lin16u_gen::val#2 8.75
(void()) main()
(byte~) main::$27 22.0
(byte~) main::$28 22.0
(byte~) main::$29 22.0
(byte) main::i
(byte) main::i#1 22.0
(byte) main::i#10 3.5
(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num)
(byte) memset::c
(byte*) memset::dst
(byte*) memset::dst#1 22.0
(byte*) memset::dst#2 14.666666666666666
(byte*) memset::end
(word) memset::num
(void*) memset::return
(void*) memset::str
(void()) print_byte((byte) print_byte::b)
(byte~) print_byte::$0 4.0
(byte~) print_byte::$2 4.0
(byte) print_byte::b
(byte) print_byte::b#0 4.0
(byte) print_byte::b#1 4.0
(byte) print_byte::b#2 11.0
(byte) print_byte::b#3 4.75
(void()) print_char((byte) print_char::ch)
(byte) print_char::ch
(byte) print_char::ch#0 4.0
(byte) print_char::ch#1 4.0
(byte) print_char::ch#2 6.0
(byte*) print_char_cursor
(byte*) print_char_cursor#1 101.0
(byte*) print_char_cursor#101 22.0
(byte*) print_char_cursor#11 4.228571428571427
(byte*) print_char_cursor#2 11.37037037037037
(byte*) print_char_cursor#50 4.0
(byte*) print_char_cursor#81 5.666666666666667
(byte*) print_char_cursor#86 45.0
(byte*) print_char_cursor#98 4.0
(void()) print_cls()
(byte*) print_line_cursor
(byte*) print_line_cursor#1 8.225
(byte*) print_line_cursor#11 204.0
(byte*) print_line_cursor#21 15.0
(void()) print_ln()
(byte*) print_screen
(void()) print_str((byte*) print_str::str)
(byte*) print_str::str
(byte*) print_str::str#0 202.0
(byte*) print_str::str#10 101.5
(byte*) print_str::str#12 2.0
(void()) print_word((word) print_word::w)
(word) print_word::w
(word) print_word::w#10 12.333333333333332
(word) print_word::w#3 22.0
(word) print_word::w#4 22.0
(word) print_word::w#5 22.0
(word) rem16u
(word) rem16u#1 0.8

Initial phi equivalence classes
[ main::i#10 main::i#1 ]
[ print_line_cursor#11 print_line_cursor#21 print_line_cursor#1 ]
[ print_word::w#10 print_word::w#3 print_word::w#4 print_word::w#5 ]
[ print_byte::b#3 print_byte::b#2 print_byte::b#0 print_byte::b#1 ]
[ print_char::ch#2 print_char::ch#0 print_char::ch#1 ]
[ print_char_cursor#86 print_char_cursor#50 print_char_cursor#81 print_char_cursor#101 print_char_cursor#2 print_char_cursor#11 print_char_cursor#98 print_char_cursor#1 ]
[ print_str::str#10 print_str::str#12 print_str::str#0 ]
[ memset::dst#2 memset::dst#1 ]
[ lin16u_gen::max#3 ]
[ lin16u_gen::min#3 ]
[ lin16u_gen::i#2 lin16u_gen::i#1 ]
[ lin16u_gen::val#2 lin16u_gen::val#1 lin16u_gen::val#0 ]
[ lin16u_gen::lintab#4 lin16u_gen::lintab#3 lin16u_gen::lintab#6 ]
[ divr16u::divisor#6 ]
[ divr16u::rem#5 divr16u::rem#10 divr16u::rem#4 divr16u::rem#11 divr16u::rem#6 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 ]
[ divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#1 divr16u::dividend#0 ]
[ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 ]
[ divr16u::i#2 divr16u::i#1 ]
Added variable main::$27 to live range equivalence class [ main::$27 ]
Added variable main::$28 to live range equivalence class [ main::$28 ]
Added variable main::$29 to live range equivalence class [ main::$29 ]
Added variable print_byte::$0 to live range equivalence class [ print_byte::$0 ]
Added variable print_byte::$2 to live range equivalence class [ print_byte::$2 ]
Added variable lin16u_gen::ampl#0 to live range equivalence class [ lin16u_gen::ampl#0 ]
Added variable divr16u::return#2 to live range equivalence class [ divr16u::return#2 ]
Added variable lin16u_gen::stepi#0 to live range equivalence class [ lin16u_gen::stepi#0 ]
Added variable divr16u::return#3 to live range equivalence class [ divr16u::return#3 ]
Added variable lin16u_gen::stepf#0 to live range equivalence class [ lin16u_gen::stepf#0 ]
Added variable lin16u_gen::step#0 to live range equivalence class [ lin16u_gen::step#0 ]
Added variable lin16u_gen::$6 to live range equivalence class [ lin16u_gen::$6 ]
Added variable divr16u::$1 to live range equivalence class [ divr16u::$1 ]
Added variable divr16u::$2 to live range equivalence class [ divr16u::$2 ]
Added variable rem16u#1 to live range equivalence class [ rem16u#1 ]
Complete equivalence classes
[ main::i#10 main::i#1 ]
[ print_line_cursor#11 print_line_cursor#21 print_line_cursor#1 ]
[ print_word::w#10 print_word::w#3 print_word::w#4 print_word::w#5 ]
[ print_byte::b#3 print_byte::b#2 print_byte::b#0 print_byte::b#1 ]
[ print_char::ch#2 print_char::ch#0 print_char::ch#1 ]
[ print_char_cursor#86 print_char_cursor#50 print_char_cursor#81 print_char_cursor#101 print_char_cursor#2 print_char_cursor#11 print_char_cursor#98 print_char_cursor#1 ]
[ print_str::str#10 print_str::str#12 print_str::str#0 ]
[ memset::dst#2 memset::dst#1 ]
[ lin16u_gen::max#3 ]
[ lin16u_gen::min#3 ]
[ lin16u_gen::i#2 lin16u_gen::i#1 ]
[ lin16u_gen::val#2 lin16u_gen::val#1 lin16u_gen::val#0 ]
[ lin16u_gen::lintab#4 lin16u_gen::lintab#3 lin16u_gen::lintab#6 ]
[ divr16u::divisor#6 ]
[ divr16u::rem#5 divr16u::rem#10 divr16u::rem#4 divr16u::rem#11 divr16u::rem#6 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 ]
[ divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#1 divr16u::dividend#0 ]
[ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 ]
[ divr16u::i#2 divr16u::i#1 ]
[ main::$27 ]
[ main::$28 ]
[ main::$29 ]
[ print_byte::$0 ]
[ print_byte::$2 ]
[ lin16u_gen::ampl#0 ]
[ divr16u::return#2 ]
[ lin16u_gen::stepi#0 ]
[ divr16u::return#3 ]
[ lin16u_gen::stepf#0 ]
[ lin16u_gen::step#0 ]
[ lin16u_gen::$6 ]
[ divr16u::$1 ]
[ divr16u::$2 ]
[ rem16u#1 ]
Allocated zp[1]:2 [ main::i#10 main::i#1 ]
Allocated zp[2]:3 [ print_line_cursor#11 print_line_cursor#21 print_line_cursor#1 ]
Allocated zp[2]:5 [ print_word::w#10 print_word::w#3 print_word::w#4 print_word::w#5 ]
Allocated zp[1]:7 [ print_byte::b#3 print_byte::b#2 print_byte::b#0 print_byte::b#1 ]
Allocated zp[1]:8 [ print_char::ch#2 print_char::ch#0 print_char::ch#1 ]
Allocated zp[2]:9 [ print_char_cursor#86 print_char_cursor#50 print_char_cursor#81 print_char_cursor#101 print_char_cursor#2 print_char_cursor#11 print_char_cursor#98 print_char_cursor#1 ]
Allocated zp[2]:11 [ print_str::str#10 print_str::str#12 print_str::str#0 ]
Allocated zp[2]:13 [ memset::dst#2 memset::dst#1 ]
Allocated zp[2]:15 [ lin16u_gen::max#3 ]
Allocated zp[2]:17 [ lin16u_gen::min#3 ]
Allocated zp[2]:19 [ lin16u_gen::i#2 lin16u_gen::i#1 ]
Allocated zp[4]:21 [ lin16u_gen::val#2 lin16u_gen::val#1 lin16u_gen::val#0 ]
Allocated zp[2]:25 [ lin16u_gen::lintab#4 lin16u_gen::lintab#3 lin16u_gen::lintab#6 ]
Allocated zp[2]:27 [ divr16u::divisor#6 ]
Allocated zp[2]:29 [ divr16u::rem#5 divr16u::rem#10 divr16u::rem#4 divr16u::rem#11 divr16u::rem#6 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 ]
Allocated zp[2]:31 [ divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#1 divr16u::dividend#0 ]
Allocated zp[2]:33 [ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 ]
Allocated zp[1]:35 [ divr16u::i#2 divr16u::i#1 ]
Allocated zp[1]:36 [ main::$27 ]
Allocated zp[1]:37 [ main::$28 ]
Allocated zp[1]:38 [ main::$29 ]
Allocated zp[1]:39 [ print_byte::$0 ]
Allocated zp[1]:40 [ print_byte::$2 ]
Allocated zp[2]:41 [ lin16u_gen::ampl#0 ]
Allocated zp[2]:43 [ divr16u::return#2 ]
Allocated zp[2]:45 [ lin16u_gen::stepi#0 ]
Allocated zp[2]:47 [ divr16u::return#3 ]
Allocated zp[2]:49 [ lin16u_gen::stepf#0 ]
Allocated zp[4]:51 [ lin16u_gen::step#0 ]
Allocated zp[2]:55 [ lin16u_gen::$6 ]
Allocated zp[1]:57 [ divr16u::$1 ]
Allocated zp[1]:58 [ divr16u::$2 ]
Allocated zp[2]:59 [ rem16u#1 ]

INITIAL ASM
Target platform is c64basic / MOS6502X
  // File Comments
// Linear table generator
// Work in progress towards a sinus generator
  // Upstart
.pc = $801 "Basic"
:BasicUpstart(__bbegin)
.pc = $80d "Program"
  // Global Constants & labels
  .const SIZEOF_WORD = 2
  // Remainder after unsigned 16-bit division
  .label rem16u = $3b
  .label print_char_cursor = 9
  .label print_line_cursor = 3
  // @begin
__bbegin:
  // [1] phi from @begin to @1 [phi:@begin->@1]
__b1_from___bbegin:
  jmp __b1
  // @1
__b1:
  // [2] call main 
  // [4] phi from @1 to main [phi:@1->main]
main_from___b1:
  jsr main
  // [3] phi from @1 to @end [phi:@1->@end]
__bend_from___b1:
  jmp __bend
  // @end
__bend:
  // main
main: {
    .label __27 = $24
    .label __28 = $25
    .label __29 = $26
    .label i = 2
    // [5] call lin16u_gen 
    // [103] phi from main to lin16u_gen [phi:main->lin16u_gen]
  lin16u_gen_from_main:
    // [103] phi (word*) lin16u_gen::lintab#6 = (const word*) main::lintab1 [phi:main->lin16u_gen#0] -- pwuz1=pwuc1 
    lda #<lintab1
    sta.z lin16u_gen.lintab
    lda #>lintab1
    sta.z lin16u_gen.lintab+1
    // [103] phi (word) lin16u_gen::min#3 = (word) $22d [phi:main->lin16u_gen#1] -- vwuz1=vwuc1 
    lda #<$22d
    sta.z lin16u_gen.min
    lda #>$22d
    sta.z lin16u_gen.min+1
    // [103] phi (word) lin16u_gen::max#3 = (word) $7461 [phi:main->lin16u_gen#2] -- vwuz1=vwuc1 
    lda #<$7461
    sta.z lin16u_gen.max
    lda #>$7461
    sta.z lin16u_gen.max+1
    jsr lin16u_gen
    // [6] phi from main to main::@4 [phi:main->main::@4]
  __b4_from_main:
    jmp __b4
    // main::@4
  __b4:
    // [7] call lin16u_gen 
    // [103] phi from main::@4 to lin16u_gen [phi:main::@4->lin16u_gen]
  lin16u_gen_from___b4:
    // [103] phi (word*) lin16u_gen::lintab#6 = (const word*) main::lintab2 [phi:main::@4->lin16u_gen#0] -- pwuz1=pwuc1 
    lda #<lintab2
    sta.z lin16u_gen.lintab
    lda #>lintab2
    sta.z lin16u_gen.lintab+1
    // [103] phi (word) lin16u_gen::min#3 = (word) $79cb [phi:main::@4->lin16u_gen#1] -- vwuz1=vwuc1 
    lda #<$79cb
    sta.z lin16u_gen.min
    lda #>$79cb
    sta.z lin16u_gen.min+1
    // [103] phi (word) lin16u_gen::max#3 = (word) $f781 [phi:main::@4->lin16u_gen#2] -- vwuz1=vwuc1 
    lda #<$f781
    sta.z lin16u_gen.max
    lda #>$f781
    sta.z lin16u_gen.max+1
    jsr lin16u_gen
    // [8] phi from main::@4 to main::@5 [phi:main::@4->main::@5]
  __b5_from___b4:
    jmp __b5
    // main::@5
  __b5:
    // [9] call lin16u_gen 
    // [103] phi from main::@5 to lin16u_gen [phi:main::@5->lin16u_gen]
  lin16u_gen_from___b5:
    // [103] phi (word*) lin16u_gen::lintab#6 = (const word*) main::lintab3 [phi:main::@5->lin16u_gen#0] -- pwuz1=pwuc1 
    lda #<lintab3
    sta.z lin16u_gen.lintab
    lda #>lintab3
    sta.z lin16u_gen.lintab+1
    // [103] phi (word) lin16u_gen::min#3 = (byte) 0 [phi:main::@5->lin16u_gen#1] -- vwuz1=vbuc1 
    lda #<0
    sta.z lin16u_gen.min
    lda #>0
    sta.z lin16u_gen.min+1
    // [103] phi (word) lin16u_gen::max#3 = (word) $6488 [phi:main::@5->lin16u_gen#2] -- vwuz1=vwuc1 
    lda #<$6488
    sta.z lin16u_gen.max
    lda #>$6488
    sta.z lin16u_gen.max+1
    jsr lin16u_gen
    // [10] phi from main::@5 to main::@6 [phi:main::@5->main::@6]
  __b6_from___b5:
    jmp __b6
    // main::@6
  __b6:
    // [11] call print_cls 
    // [94] phi from main::@6 to print_cls [phi:main::@6->print_cls]
  print_cls_from___b6:
    jsr print_cls
    // [12] phi from main::@6 to main::@7 [phi:main::@6->main::@7]
  __b7_from___b6:
    jmp __b7
    // main::@7
  __b7:
    // [13] call print_str 
    // [87] phi from main::@7 to print_str [phi:main::@7->print_str]
  print_str_from___b7:
    // [87] phi (byte*) print_char_cursor#86 = (byte*) 1024 [phi:main::@7->print_str#0] -- pbuz1=pbuc1 
    lda #<$400
    sta.z print_char_cursor
    lda #>$400
    sta.z print_char_cursor+1
    // [87] phi (byte*) print_str::str#12 = (const byte*) main::str [phi:main::@7->print_str#1] -- pbuz1=pbuc1 
    lda #<str
    sta.z print_str.str
    lda #>str
    sta.z print_str.str+1
    jsr print_str
    // [14] phi from main::@7 to main::@8 [phi:main::@7->main::@8]
  __b8_from___b7:
    jmp __b8
    // main::@8
  __b8:
    // [15] call print_word 
    // [69] phi from main::@8 to print_word [phi:main::@8->print_word]
  print_word_from___b8:
    // [69] phi (word) print_word::w#10 = (word) $22d [phi:main::@8->print_word#0] -- vwuz1=vwuc1 
    lda #<$22d
    sta.z print_word.w
    lda #>$22d
    sta.z print_word.w+1
    jsr print_word
    // [16] phi from main::@8 to main::@9 [phi:main::@8->main::@9]
  __b9_from___b8:
    jmp __b9
    // main::@9
  __b9:
    // [17] call print_str 
    // [87] phi from main::@9 to print_str [phi:main::@9->print_str]
  print_str_from___b9:
    // [87] phi (byte*) print_char_cursor#86 = (byte*) print_char_cursor#11 [phi:main::@9->print_str#0] -- register_copy 
    // [87] phi (byte*) print_str::str#12 = (const byte*) main::str1 [phi:main::@9->print_str#1] -- pbuz1=pbuc1 
    lda #<str1
    sta.z print_str.str
    lda #>str1
    sta.z print_str.str+1
    jsr print_str
    // [18] phi from main::@9 to main::@10 [phi:main::@9->main::@10]
  __b10_from___b9:
    jmp __b10
    // main::@10
  __b10:
    // [19] call print_word 
    // [69] phi from main::@10 to print_word [phi:main::@10->print_word]
  print_word_from___b10:
    // [69] phi (word) print_word::w#10 = (word) $79cb [phi:main::@10->print_word#0] -- vwuz1=vwuc1 
    lda #<$79cb
    sta.z print_word.w
    lda #>$79cb
    sta.z print_word.w+1
    jsr print_word
    // [20] phi from main::@10 to main::@11 [phi:main::@10->main::@11]
  __b11_from___b10:
    jmp __b11
    // main::@11
  __b11:
    // [21] call print_str 
    // [87] phi from main::@11 to print_str [phi:main::@11->print_str]
  print_str_from___b11:
    // [87] phi (byte*) print_char_cursor#86 = (byte*) print_char_cursor#11 [phi:main::@11->print_str#0] -- register_copy 
    // [87] phi (byte*) print_str::str#12 = (const byte*) main::str1 [phi:main::@11->print_str#1] -- pbuz1=pbuc1 
    lda #<str1
    sta.z print_str.str
    lda #>str1
    sta.z print_str.str+1
    jsr print_str
    // [22] phi from main::@11 to main::@12 [phi:main::@11->main::@12]
  __b12_from___b11:
    jmp __b12
    // main::@12
  __b12:
    // [23] call print_word 
    // [69] phi from main::@12 to print_word [phi:main::@12->print_word]
  print_word_from___b12:
    // [69] phi (word) print_word::w#10 = (byte) 0 [phi:main::@12->print_word#0] -- vwuz1=vbuc1 
    lda #<0
    sta.z print_word.w
    lda #>0
    sta.z print_word.w+1
    jsr print_word
    // [24] phi from main::@12 to main::@13 [phi:main::@12->main::@13]
  __b13_from___b12:
    jmp __b13
    // main::@13
  __b13:
    // [25] call print_ln 
    // [64] phi from main::@13 to print_ln [phi:main::@13->print_ln]
  print_ln_from___b13:
    // [64] phi (byte*) print_line_cursor#21 = (byte*) 1024 [phi:main::@13->print_ln#0] -- pbuz1=pbuc1 
    lda #<$400
    sta.z print_line_cursor
    lda #>$400
    sta.z print_line_cursor+1
    jsr print_ln
    // [26] phi from main::@13 to main::@1 [phi:main::@13->main::@1]
  __b1_from___b13:
    // [26] phi (byte) main::i#10 = (byte) 0 [phi:main::@13->main::@1#0] -- vbuz1=vbuc1 
    lda #0
    sta.z i
    jmp __b1
    // main::@1
  __b1:
    // [27] if((byte) main::i#10<(byte) $14) goto main::@2 -- vbuz1_lt_vbuc1_then_la1 
    lda.z i
    cmp #$14
    bcc __b2
    jmp __b3
    // main::@3
  __b3:
    // [28] (byte*) print_char_cursor#98 ← (byte*) print_line_cursor#1 -- pbuz1=pbuz2 
    lda.z print_line_cursor
    sta.z print_char_cursor
    lda.z print_line_cursor+1
    sta.z print_char_cursor+1
    // [29] call print_str 
    // [87] phi from main::@3 to print_str [phi:main::@3->print_str]
  print_str_from___b3:
    // [87] phi (byte*) print_char_cursor#86 = (byte*) print_char_cursor#98 [phi:main::@3->print_str#0] -- register_copy 
    // [87] phi (byte*) print_str::str#12 = (const byte*) main::str [phi:main::@3->print_str#1] -- pbuz1=pbuc1 
    lda #<str
    sta.z print_str.str
    lda #>str
    sta.z print_str.str+1
    jsr print_str
    // [30] phi from main::@3 to main::@22 [phi:main::@3->main::@22]
  __b22_from___b3:
    jmp __b22
    // main::@22
  __b22:
    // [31] call print_word 
    // [69] phi from main::@22 to print_word [phi:main::@22->print_word]
  print_word_from___b22:
    // [69] phi (word) print_word::w#10 = (word) $7461 [phi:main::@22->print_word#0] -- vwuz1=vwuc1 
    lda #<$7461
    sta.z print_word.w
    lda #>$7461
    sta.z print_word.w+1
    jsr print_word
    // [32] phi from main::@22 to main::@23 [phi:main::@22->main::@23]
  __b23_from___b22:
    jmp __b23
    // main::@23
  __b23:
    // [33] call print_str 
    // [87] phi from main::@23 to print_str [phi:main::@23->print_str]
  print_str_from___b23:
    // [87] phi (byte*) print_char_cursor#86 = (byte*) print_char_cursor#11 [phi:main::@23->print_str#0] -- register_copy 
    // [87] phi (byte*) print_str::str#12 = (const byte*) main::str1 [phi:main::@23->print_str#1] -- pbuz1=pbuc1 
    lda #<str1
    sta.z print_str.str
    lda #>str1
    sta.z print_str.str+1
    jsr print_str
    // [34] phi from main::@23 to main::@24 [phi:main::@23->main::@24]
  __b24_from___b23:
    jmp __b24
    // main::@24
  __b24:
    // [35] call print_word 
    // [69] phi from main::@24 to print_word [phi:main::@24->print_word]
  print_word_from___b24:
    // [69] phi (word) print_word::w#10 = (word) $f781 [phi:main::@24->print_word#0] -- vwuz1=vwuc1 
    lda #<$f781
    sta.z print_word.w
    lda #>$f781
    sta.z print_word.w+1
    jsr print_word
    // [36] phi from main::@24 to main::@25 [phi:main::@24->main::@25]
  __b25_from___b24:
    jmp __b25
    // main::@25
  __b25:
    // [37] call print_str 
    // [87] phi from main::@25 to print_str [phi:main::@25->print_str]
  print_str_from___b25:
    // [87] phi (byte*) print_char_cursor#86 = (byte*) print_char_cursor#11 [phi:main::@25->print_str#0] -- register_copy 
    // [87] phi (byte*) print_str::str#12 = (const byte*) main::str1 [phi:main::@25->print_str#1] -- pbuz1=pbuc1 
    lda #<str1
    sta.z print_str.str
    lda #>str1
    sta.z print_str.str+1
    jsr print_str
    // [38] phi from main::@25 to main::@26 [phi:main::@25->main::@26]
  __b26_from___b25:
    jmp __b26
    // main::@26
  __b26:
    // [39] call print_word 
    // [69] phi from main::@26 to print_word [phi:main::@26->print_word]
  print_word_from___b26:
    // [69] phi (word) print_word::w#10 = (word) $6488 [phi:main::@26->print_word#0] -- vwuz1=vwuc1 
    lda #<$6488
    sta.z print_word.w
    lda #>$6488
    sta.z print_word.w+1
    jsr print_word
    // [40] phi from main::@26 to main::@27 [phi:main::@26->main::@27]
  __b27_from___b26:
    jmp __b27
    // main::@27
  __b27:
    // [41] call print_ln 
    // [64] phi from main::@27 to print_ln [phi:main::@27->print_ln]
  print_ln_from___b27:
    // [64] phi (byte*) print_line_cursor#21 = (byte*) print_line_cursor#1 [phi:main::@27->print_ln#0] -- register_copy 
    jsr print_ln
    jmp __breturn
    // main::@return
  __breturn:
    // [42] return 
    rts
    // main::@2
  __b2:
    // [43] (byte) print_byte::b#2 ← (byte) main::i#10 -- vbuz1=vbuz2 
    lda.z i
    sta.z print_byte.b
    // [44] (byte*) print_char_cursor#101 ← (byte*) print_line_cursor#1 -- pbuz1=pbuz2 
    lda.z print_line_cursor
    sta.z print_char_cursor
    lda.z print_line_cursor+1
    sta.z print_char_cursor+1
    // [45] call print_byte 
    // [75] phi from main::@2 to print_byte [phi:main::@2->print_byte]
  print_byte_from___b2:
    // [75] phi (byte*) print_char_cursor#81 = (byte*) print_char_cursor#101 [phi:main::@2->print_byte#0] -- register_copy 
    // [75] phi (byte) print_byte::b#3 = (byte) print_byte::b#2 [phi:main::@2->print_byte#1] -- register_copy 
    jsr print_byte
    // [46] phi from main::@2 to main::@14 [phi:main::@2->main::@14]
  __b14_from___b2:
    jmp __b14
    // main::@14
  __b14:
    // [47] call print_str 
    // [87] phi from main::@14 to print_str [phi:main::@14->print_str]
  print_str_from___b14:
    // [87] phi (byte*) print_char_cursor#86 = (byte*) print_char_cursor#11 [phi:main::@14->print_str#0] -- register_copy 
    // [87] phi (byte*) print_str::str#12 = (const byte*) main::str1 [phi:main::@14->print_str#1] -- pbuz1=pbuc1 
    lda #<str1
    sta.z print_str.str
    lda #>str1
    sta.z print_str.str+1
    jsr print_str
    jmp __b15
    // main::@15
  __b15:
    // [48] (byte~) main::$27 ← (byte) main::i#10 << (byte) 1 -- vbuz1=vbuz2_rol_1 
    lda.z i
    asl
    sta.z __27
    // [49] (word) print_word::w#3 ← *((const word*) main::lintab1 + (byte~) main::$27) -- vwuz1=pwuc1_derefidx_vbuz2 
    ldy.z __27
    lda lintab1,y
    sta.z print_word.w
    lda lintab1+1,y
    sta.z print_word.w+1
    // [50] call print_word 
    // [69] phi from main::@15 to print_word [phi:main::@15->print_word]
  print_word_from___b15:
    // [69] phi (word) print_word::w#10 = (word) print_word::w#3 [phi:main::@15->print_word#0] -- register_copy 
    jsr print_word
    // [51] phi from main::@15 to main::@16 [phi:main::@15->main::@16]
  __b16_from___b15:
    jmp __b16
    // main::@16
  __b16:
    // [52] call print_str 
    // [87] phi from main::@16 to print_str [phi:main::@16->print_str]
  print_str_from___b16:
    // [87] phi (byte*) print_char_cursor#86 = (byte*) print_char_cursor#11 [phi:main::@16->print_str#0] -- register_copy 
    // [87] phi (byte*) print_str::str#12 = (const byte*) main::str1 [phi:main::@16->print_str#1] -- pbuz1=pbuc1 
    lda #<str1
    sta.z print_str.str
    lda #>str1
    sta.z print_str.str+1
    jsr print_str
    jmp __b17
    // main::@17
  __b17:
    // [53] (byte~) main::$28 ← (byte) main::i#10 << (byte) 1 -- vbuz1=vbuz2_rol_1 
    lda.z i
    asl
    sta.z __28
    // [54] (word) print_word::w#4 ← *((const word*) main::lintab2 + (byte~) main::$28) -- vwuz1=pwuc1_derefidx_vbuz2 
    ldy.z __28
    lda lintab2,y
    sta.z print_word.w
    lda lintab2+1,y
    sta.z print_word.w+1
    // [55] call print_word 
    // [69] phi from main::@17 to print_word [phi:main::@17->print_word]
  print_word_from___b17:
    // [69] phi (word) print_word::w#10 = (word) print_word::w#4 [phi:main::@17->print_word#0] -- register_copy 
    jsr print_word
    // [56] phi from main::@17 to main::@18 [phi:main::@17->main::@18]
  __b18_from___b17:
    jmp __b18
    // main::@18
  __b18:
    // [57] call print_str 
    // [87] phi from main::@18 to print_str [phi:main::@18->print_str]
  print_str_from___b18:
    // [87] phi (byte*) print_char_cursor#86 = (byte*) print_char_cursor#11 [phi:main::@18->print_str#0] -- register_copy 
    // [87] phi (byte*) print_str::str#12 = (const byte*) main::str1 [phi:main::@18->print_str#1] -- pbuz1=pbuc1 
    lda #<str1
    sta.z print_str.str
    lda #>str1
    sta.z print_str.str+1
    jsr print_str
    jmp __b19
    // main::@19
  __b19:
    // [58] (byte~) main::$29 ← (byte) main::i#10 << (byte) 1 -- vbuz1=vbuz2_rol_1 
    lda.z i
    asl
    sta.z __29
    // [59] (word) print_word::w#5 ← *((const word*) main::lintab3 + (byte~) main::$29) -- vwuz1=pwuc1_derefidx_vbuz2 
    ldy.z __29
    lda lintab3,y
    sta.z print_word.w
    lda lintab3+1,y
    sta.z print_word.w+1
    // [60] call print_word 
    // [69] phi from main::@19 to print_word [phi:main::@19->print_word]
  print_word_from___b19:
    // [69] phi (word) print_word::w#10 = (word) print_word::w#5 [phi:main::@19->print_word#0] -- register_copy 
    jsr print_word
    // [61] phi from main::@19 to main::@20 [phi:main::@19->main::@20]
  __b20_from___b19:
    jmp __b20
    // main::@20
  __b20:
    // [62] call print_ln 
    // [64] phi from main::@20 to print_ln [phi:main::@20->print_ln]
  print_ln_from___b20:
    // [64] phi (byte*) print_line_cursor#21 = (byte*) print_line_cursor#1 [phi:main::@20->print_ln#0] -- register_copy 
    jsr print_ln
    jmp __b21
    // main::@21
  __b21:
    // [63] (byte) main::i#1 ← ++ (byte) main::i#10 -- vbuz1=_inc_vbuz1 
    inc.z i
    // [26] phi from main::@21 to main::@1 [phi:main::@21->main::@1]
  __b1_from___b21:
    // [26] phi (byte) main::i#10 = (byte) main::i#1 [phi:main::@21->main::@1#0] -- register_copy 
    jmp __b1
    lintab1: .fill 2*$14, 0
    lintab2: .fill 2*$14, 0
    lintab3: .fill 2*$14, 0
    str: .text "   "
    .byte 0
    str1: .text " "
    .byte 0
}
  // print_ln
// Print a newline
print_ln: {
    // [65] phi from print_ln print_ln::@1 to print_ln::@1 [phi:print_ln/print_ln::@1->print_ln::@1]
  __b1_from_print_ln:
  __b1_from___b1:
    // [65] phi (byte*) print_line_cursor#11 = (byte*) print_line_cursor#21 [phi:print_ln/print_ln::@1->print_ln::@1#0] -- register_copy 
    jmp __b1
    // print_ln::@1
  __b1:
    // [66] (byte*) print_line_cursor#1 ← (byte*) print_line_cursor#11 + (byte) $28 -- pbuz1=pbuz1_plus_vbuc1 
    lda #$28
    clc
    adc.z print_line_cursor
    sta.z print_line_cursor
    bcc !+
    inc.z print_line_cursor+1
  !:
    // [67] if((byte*) print_line_cursor#1<(byte*) print_char_cursor#11) goto print_ln::@1 -- pbuz1_lt_pbuz2_then_la1 
    lda.z print_line_cursor+1
    cmp.z print_char_cursor+1
    bcc __b1_from___b1
    bne !+
    lda.z print_line_cursor
    cmp.z print_char_cursor
    bcc __b1_from___b1
  !:
    jmp __breturn
    // print_ln::@return
  __breturn:
    // [68] return 
    rts
}
  // print_word
// Print a word as HEX
// print_word(word zp(5) w)
print_word: {
    .label w = 5
    // [70] (byte) print_byte::b#0 ← > (word) print_word::w#10 -- vbuz1=_hi_vwuz2 
    lda.z w+1
    sta.z print_byte.b
    // [71] call print_byte 
    // [75] phi from print_word to print_byte [phi:print_word->print_byte]
  print_byte_from_print_word:
    // [75] phi (byte*) print_char_cursor#81 = (byte*) print_char_cursor#2 [phi:print_word->print_byte#0] -- register_copy 
    // [75] phi (byte) print_byte::b#3 = (byte) print_byte::b#0 [phi:print_word->print_byte#1] -- register_copy 
    jsr print_byte
    jmp __b1
    // print_word::@1
  __b1:
    // [72] (byte) print_byte::b#1 ← < (word) print_word::w#10 -- vbuz1=_lo_vwuz2 
    lda.z w
    sta.z print_byte.b
    // [73] call print_byte 
    // [75] phi from print_word::@1 to print_byte [phi:print_word::@1->print_byte]
  print_byte_from___b1:
    // [75] phi (byte*) print_char_cursor#81 = (byte*) print_char_cursor#11 [phi:print_word::@1->print_byte#0] -- register_copy 
    // [75] phi (byte) print_byte::b#3 = (byte) print_byte::b#1 [phi:print_word::@1->print_byte#1] -- register_copy 
    jsr print_byte
    jmp __breturn
    // print_word::@return
  __breturn:
    // [74] return 
    rts
}
  // print_byte
// Print a byte as HEX
// print_byte(byte zp(7) b)
print_byte: {
    .label __0 = $27
    .label __2 = $28
    .label b = 7
    // [76] (byte~) print_byte::$0 ← (byte) print_byte::b#3 >> (byte) 4 -- vbuz1=vbuz2_ror_4 
    lda.z b
    lsr
    lsr
    lsr
    lsr
    sta.z __0
    // [77] (byte) print_char::ch#0 ← *((const byte*) print_hextab + (byte~) print_byte::$0) -- vbuz1=pbuc1_derefidx_vbuz2 
    ldy.z __0
    lda print_hextab,y
    sta.z print_char.ch
    // [78] call print_char 
    // [83] phi from print_byte to print_char [phi:print_byte->print_char]
  print_char_from_print_byte:
    // [83] phi (byte*) print_char_cursor#50 = (byte*) print_char_cursor#81 [phi:print_byte->print_char#0] -- register_copy 
    // [83] phi (byte) print_char::ch#2 = (byte) print_char::ch#0 [phi:print_byte->print_char#1] -- register_copy 
    jsr print_char
    jmp __b1
    // print_byte::@1
  __b1:
    // [79] (byte~) print_byte::$2 ← (byte) print_byte::b#3 & (byte) $f -- vbuz1=vbuz2_band_vbuc1 
    lda #$f
    and.z b
    sta.z __2
    // [80] (byte) print_char::ch#1 ← *((const byte*) print_hextab + (byte~) print_byte::$2) -- vbuz1=pbuc1_derefidx_vbuz2 
    ldy.z __2
    lda print_hextab,y
    sta.z print_char.ch
    // [81] call print_char 
    // [83] phi from print_byte::@1 to print_char [phi:print_byte::@1->print_char]
  print_char_from___b1:
    // [83] phi (byte*) print_char_cursor#50 = (byte*) print_char_cursor#11 [phi:print_byte::@1->print_char#0] -- register_copy 
    // [83] phi (byte) print_char::ch#2 = (byte) print_char::ch#1 [phi:print_byte::@1->print_char#1] -- register_copy 
    jsr print_char
    jmp __breturn
    // print_byte::@return
  __breturn:
    // [82] return 
    rts
}
  // print_char
// Print a single char
// print_char(byte zp(8) ch)
print_char: {
    .label ch = 8
    // [84] *((byte*) print_char_cursor#50) ← (byte) print_char::ch#2 -- _deref_pbuz1=vbuz2 
    lda.z ch
    ldy #0
    sta (print_char_cursor),y
    // [85] (byte*) print_char_cursor#11 ← ++ (byte*) print_char_cursor#50 -- pbuz1=_inc_pbuz1 
    inc.z print_char_cursor
    bne !+
    inc.z print_char_cursor+1
  !:
    jmp __breturn
    // print_char::@return
  __breturn:
    // [86] return 
    rts
}
  // print_str
// Print a zero-terminated string
// print_str(byte* zp($b) str)
print_str: {
    .label str = $b
    // [88] phi from print_str print_str::@2 to print_str::@1 [phi:print_str/print_str::@2->print_str::@1]
  __b1_from_print_str:
  __b1_from___b2:
    // [88] phi (byte*) print_char_cursor#2 = (byte*) print_char_cursor#86 [phi:print_str/print_str::@2->print_str::@1#0] -- register_copy 
    // [88] phi (byte*) print_str::str#10 = (byte*) print_str::str#12 [phi:print_str/print_str::@2->print_str::@1#1] -- register_copy 
    jmp __b1
    // print_str::@1
  __b1:
    // [89] if((byte) 0!=*((byte*) print_str::str#10)) goto print_str::@2 -- vbuc1_neq__deref_pbuz1_then_la1 
    ldy #0
    lda (str),y
    cmp #0
    bne __b2
    jmp __breturn
    // print_str::@return
  __breturn:
    // [90] return 
    rts
    // print_str::@2
  __b2:
    // [91] *((byte*) print_char_cursor#2) ← *((byte*) print_str::str#10) -- _deref_pbuz1=_deref_pbuz2 
    ldy #0
    lda (str),y
    ldy #0
    sta (print_char_cursor),y
    // [92] (byte*) print_char_cursor#1 ← ++ (byte*) print_char_cursor#2 -- pbuz1=_inc_pbuz1 
    inc.z print_char_cursor
    bne !+
    inc.z print_char_cursor+1
  !:
    // [93] (byte*) print_str::str#0 ← ++ (byte*) print_str::str#10 -- pbuz1=_inc_pbuz1 
    inc.z str
    bne !+
    inc.z str+1
  !:
    jmp __b1_from___b2
}
  // print_cls
// Clear the screen. Also resets current line/char cursor.
print_cls: {
    // [95] call memset 
    // [97] phi from print_cls to memset [phi:print_cls->memset]
  memset_from_print_cls:
    jsr memset
    jmp __breturn
    // print_cls::@return
  __breturn:
    // [96] return 
    rts
}
  // memset
// Copies the character c (an unsigned char) to the first num characters of the object pointed to by the argument str.
memset: {
    .const c = ' '
    .const num = $3e8
    .label str = $400
    .label end = str+num
    .label dst = $d
    // [98] phi from memset to memset::@1 [phi:memset->memset::@1]
  __b1_from_memset:
    // [98] phi (byte*) memset::dst#2 = (byte*)(const void*) memset::str#0 [phi:memset->memset::@1#0] -- pbuz1=pbuc1 
    lda #<str
    sta.z dst
    lda #>str
    sta.z dst+1
    jmp __b1
    // memset::@1
  __b1:
    // [99] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 -- pbuz1_neq_pbuc1_then_la1 
    lda.z dst+1
    cmp #>end
    bne __b2
    lda.z dst
    cmp #<end
    bne __b2
    jmp __breturn
    // memset::@return
  __breturn:
    // [100] return 
    rts
    // memset::@2
  __b2:
    // [101] *((byte*) memset::dst#2) ← (const byte) memset::c#0 -- _deref_pbuz1=vbuc1 
    lda #c
    ldy #0
    sta (dst),y
    // [102] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2 -- pbuz1=_inc_pbuz1 
    inc.z dst
    bne !+
    inc.z dst+1
  !:
    // [98] phi from memset::@2 to memset::@1 [phi:memset::@2->memset::@1]
  __b1_from___b2:
    // [98] phi (byte*) memset::dst#2 = (byte*) memset::dst#1 [phi:memset::@2->memset::@1#0] -- register_copy 
    jmp __b1
}
  // lin16u_gen
// Generate word linear table
// lintab - the table to generate into
// length - the number of points in a total sinus wavelength (the size of the table)
// lin16u_gen(word zp($11) min, word zp($f) max, word* zp($19) lintab)
lin16u_gen: {
    .label __6 = $37
    .label ampl = $29
    .label stepi = $2d
    .label stepf = $31
    .label step = $33
    .label val = $15
    .label lintab = $19
    .label i = $13
    .label max = $f
    .label min = $11
    // [104] (word) lin16u_gen::ampl#0 ← (word) lin16u_gen::max#3 - (word) lin16u_gen::min#3 -- vwuz1=vwuz2_minus_vwuz3 
    lda.z max
    sec
    sbc.z min
    sta.z ampl
    lda.z max+1
    sbc.z min+1
    sta.z ampl+1
    // [105] (word) divr16u::dividend#1 ← (word) lin16u_gen::ampl#0 -- vwuz1=vwuz2 
    lda.z ampl
    sta.z divr16u.dividend
    lda.z ampl+1
    sta.z divr16u.dividend+1
    // [106] call divr16u 
    // [123] phi from lin16u_gen to divr16u [phi:lin16u_gen->divr16u]
  divr16u_from_lin16u_gen:
    // [123] phi (word) divr16u::divisor#6 = (byte) $14-(byte) 1 [phi:lin16u_gen->divr16u#0] -- vwuz1=vbuc1 
    lda #<$14-1
    sta.z divr16u.divisor
    lda #>$14-1
    sta.z divr16u.divisor+1
    // [123] phi (word) divr16u::dividend#5 = (word) divr16u::dividend#1 [phi:lin16u_gen->divr16u#1] -- register_copy 
    // [123] phi (word) divr16u::rem#10 = (byte) 0 [phi:lin16u_gen->divr16u#2] -- vwuz1=vbuc1 
    lda #<0
    sta.z divr16u.rem
    lda #>0
    sta.z divr16u.rem+1
    jsr divr16u
    // [107] (word) divr16u::return#2 ← (word) divr16u::return#0 -- vwuz1=vwuz2 
    lda.z divr16u.return
    sta.z divr16u.return_1
    lda.z divr16u.return+1
    sta.z divr16u.return_1+1
    jmp __b3
    // lin16u_gen::@3
  __b3:
    // [108] (word) lin16u_gen::stepi#0 ← (word) divr16u::return#2 -- vwuz1=vwuz2 
    lda.z divr16u.return_1
    sta.z stepi
    lda.z divr16u.return_1+1
    sta.z stepi+1
    // [109] (word) divr16u::rem#4 ← (word) rem16u#1 -- vwuz1=vwuz2 
    lda.z rem16u
    sta.z divr16u.rem
    lda.z rem16u+1
    sta.z divr16u.rem+1
    // [110] call divr16u 
    // [123] phi from lin16u_gen::@3 to divr16u [phi:lin16u_gen::@3->divr16u]
  divr16u_from___b3:
    // [123] phi (word) divr16u::divisor#6 = (byte) $14-(byte) 1 [phi:lin16u_gen::@3->divr16u#0] -- vwuz1=vbuc1 
    lda #<$14-1
    sta.z divr16u.divisor
    lda #>$14-1
    sta.z divr16u.divisor+1
    // [123] phi (word) divr16u::dividend#5 = (byte) 0 [phi:lin16u_gen::@3->divr16u#1] -- vwuz1=vbuc1 
    lda #<0
    sta.z divr16u.dividend
    lda #>0
    sta.z divr16u.dividend+1
    // [123] phi (word) divr16u::rem#10 = (word) divr16u::rem#4 [phi:lin16u_gen::@3->divr16u#2] -- register_copy 
    jsr divr16u
    // [111] (word) divr16u::return#3 ← (word) divr16u::return#0 -- vwuz1=vwuz2 
    lda.z divr16u.return
    sta.z divr16u.return_2
    lda.z divr16u.return+1
    sta.z divr16u.return_2+1
    jmp __b4
    // lin16u_gen::@4
  __b4:
    // [112] (word) lin16u_gen::stepf#0 ← (word) divr16u::return#3 -- vwuz1=vwuz2 
    lda.z divr16u.return_2
    sta.z stepf
    lda.z divr16u.return_2+1
    sta.z stepf+1
    // [113] (dword) lin16u_gen::step#0 ← (word) lin16u_gen::stepi#0 dw= (word) lin16u_gen::stepf#0 -- vduz1=vwuz2_dword_vwuz3 
    lda.z stepi
    sta.z step+2
    lda.z stepi+1
    sta.z step+3
    lda.z stepf
    sta.z step
    lda.z stepf+1
    sta.z step+1
    // [114] (dword) lin16u_gen::val#0 ← (word) lin16u_gen::min#3 dw= (word) 0 -- vduz1=vwuz2_dword_vwuc1 
    lda #<0
    sta.z val
    lda #>0
    sta.z val+1
    lda.z min
    sta.z val+2
    lda.z min+1
    sta.z val+3
    // [115] phi from lin16u_gen::@4 to lin16u_gen::@1 [phi:lin16u_gen::@4->lin16u_gen::@1]
  __b1_from___b4:
    // [115] phi (word*) lin16u_gen::lintab#4 = (word*) lin16u_gen::lintab#6 [phi:lin16u_gen::@4->lin16u_gen::@1#0] -- register_copy 
    // [115] phi (dword) lin16u_gen::val#2 = (dword) lin16u_gen::val#0 [phi:lin16u_gen::@4->lin16u_gen::@1#1] -- register_copy 
    // [115] phi (word) lin16u_gen::i#2 = (word) 0 [phi:lin16u_gen::@4->lin16u_gen::@1#2] -- vwuz1=vwuc1 
    lda #<0
    sta.z i
    lda #>0
    sta.z i+1
    jmp __b1
    // lin16u_gen::@1
  __b1:
    // [116] if((word) lin16u_gen::i#2<(byte) $14) goto lin16u_gen::@2 -- vwuz1_lt_vbuc1_then_la1 
    lda.z i+1
    cmp #>$14
    bcc __b2
    bne !+
    lda.z i
    cmp #<$14
    bcc __b2
  !:
    jmp __breturn
    // lin16u_gen::@return
  __breturn:
    // [117] return 
    rts
    // lin16u_gen::@2
  __b2:
    // [118] (word~) lin16u_gen::$6 ← > (dword) lin16u_gen::val#2 -- vwuz1=_hi_vduz2 
    lda.z val+2
    sta.z __6
    lda.z val+3
    sta.z __6+1
    // [119] *((word*) lin16u_gen::lintab#4) ← (word~) lin16u_gen::$6 -- _deref_pwuz1=vwuz2 
    ldy #0
    lda.z __6
    sta (lintab),y
    iny
    lda.z __6+1
    sta (lintab),y
    // [120] (dword) lin16u_gen::val#1 ← (dword) lin16u_gen::val#2 + (dword) lin16u_gen::step#0 -- vduz1=vduz1_plus_vduz2 
    lda.z val
    clc
    adc.z step
    sta.z val
    lda.z val+1
    adc.z step+1
    sta.z val+1
    lda.z val+2
    adc.z step+2
    sta.z val+2
    lda.z val+3
    adc.z step+3
    sta.z val+3
    // [121] (word*) lin16u_gen::lintab#3 ← (word*) lin16u_gen::lintab#4 + (const byte) SIZEOF_WORD -- pwuz1=pwuz1_plus_vbuc1 
    lda #SIZEOF_WORD
    clc
    adc.z lintab
    sta.z lintab
    bcc !+
    inc.z lintab+1
  !:
    // [122] (word) lin16u_gen::i#1 ← ++ (word) lin16u_gen::i#2 -- vwuz1=_inc_vwuz1 
    inc.z i
    bne !+
    inc.z i+1
  !:
    // [115] phi from lin16u_gen::@2 to lin16u_gen::@1 [phi:lin16u_gen::@2->lin16u_gen::@1]
  __b1_from___b2:
    // [115] phi (word*) lin16u_gen::lintab#4 = (word*) lin16u_gen::lintab#3 [phi:lin16u_gen::@2->lin16u_gen::@1#0] -- register_copy 
    // [115] phi (dword) lin16u_gen::val#2 = (dword) lin16u_gen::val#1 [phi:lin16u_gen::@2->lin16u_gen::@1#1] -- register_copy 
    // [115] phi (word) lin16u_gen::i#2 = (word) lin16u_gen::i#1 [phi:lin16u_gen::@2->lin16u_gen::@1#2] -- register_copy 
    jmp __b1
}
  // divr16u
// Performs division on two 16 bit unsigned words and an initial remainder
// Returns the quotient dividend/divisor.
// The final remainder will be set into the global variable rem16u
// Implemented using simple binary division
// divr16u(word zp($1f) dividend, word zp($1b) divisor, word zp($1d) rem)
divr16u: {
    .label __1 = $39
    .label __2 = $3a
    .label rem = $1d
    .label dividend = $1f
    .label quotient = $21
    .label i = $23
    .label return = $21
    .label return_1 = $2b
    .label return_2 = $2f
    .label divisor = $1b
    // [124] phi from divr16u to divr16u::@1 [phi:divr16u->divr16u::@1]
  __b1_from_divr16u:
    // [124] phi (byte) divr16u::i#2 = (byte) 0 [phi:divr16u->divr16u::@1#0] -- vbuz1=vbuc1 
    lda #0
    sta.z i
    // [124] phi (word) divr16u::quotient#3 = (word) 0 [phi:divr16u->divr16u::@1#1] -- vwuz1=vwuc1 
    lda #<0
    sta.z quotient
    lda #>0
    sta.z quotient+1
    // [124] phi (word) divr16u::dividend#3 = (word) divr16u::dividend#5 [phi:divr16u->divr16u::@1#2] -- register_copy 
    // [124] phi (word) divr16u::rem#5 = (word) divr16u::rem#10 [phi:divr16u->divr16u::@1#3] -- register_copy 
    jmp __b1
    // [124] phi from divr16u::@3 to divr16u::@1 [phi:divr16u::@3->divr16u::@1]
  __b1_from___b3:
    // [124] phi (byte) divr16u::i#2 = (byte) divr16u::i#1 [phi:divr16u::@3->divr16u::@1#0] -- register_copy 
    // [124] phi (word) divr16u::quotient#3 = (word) divr16u::return#0 [phi:divr16u::@3->divr16u::@1#1] -- register_copy 
    // [124] phi (word) divr16u::dividend#3 = (word) divr16u::dividend#0 [phi:divr16u::@3->divr16u::@1#2] -- register_copy 
    // [124] phi (word) divr16u::rem#5 = (word) divr16u::rem#11 [phi:divr16u::@3->divr16u::@1#3] -- register_copy 
    jmp __b1
    // divr16u::@1
  __b1:
    // [125] (word) divr16u::rem#0 ← (word) divr16u::rem#5 << (byte) 1 -- vwuz1=vwuz1_rol_1 
    asl.z rem
    rol.z rem+1
    // [126] (byte~) divr16u::$1 ← > (word) divr16u::dividend#3 -- vbuz1=_hi_vwuz2 
    lda.z dividend+1
    sta.z __1
    // [127] (byte~) divr16u::$2 ← (byte~) divr16u::$1 & (byte) $80 -- vbuz1=vbuz2_band_vbuc1 
    lda #$80
    and.z __1
    sta.z __2
    // [128] if((byte~) divr16u::$2==(byte) 0) goto divr16u::@2 -- vbuz1_eq_0_then_la1 
    lda.z __2
    cmp #0
    beq __b2_from___b1
    jmp __b4
    // divr16u::@4
  __b4:
    // [129] (word) divr16u::rem#1 ← (word) divr16u::rem#0 | (byte) 1 -- vwuz1=vwuz1_bor_vbuc1 
    lda #1
    ora.z rem
    sta.z rem
    // [130] phi from divr16u::@1 divr16u::@4 to divr16u::@2 [phi:divr16u::@1/divr16u::@4->divr16u::@2]
  __b2_from___b1:
  __b2_from___b4:
    // [130] phi (word) divr16u::rem#6 = (word) divr16u::rem#0 [phi:divr16u::@1/divr16u::@4->divr16u::@2#0] -- register_copy 
    jmp __b2
    // divr16u::@2
  __b2:
    // [131] (word) divr16u::dividend#0 ← (word) divr16u::dividend#3 << (byte) 1 -- vwuz1=vwuz1_rol_1 
    asl.z dividend
    rol.z dividend+1
    // [132] (word) divr16u::quotient#1 ← (word) divr16u::quotient#3 << (byte) 1 -- vwuz1=vwuz1_rol_1 
    asl.z quotient
    rol.z quotient+1
    // [133] if((word) divr16u::rem#6<(word) divr16u::divisor#6) goto divr16u::@3 -- vwuz1_lt_vwuz2_then_la1 
    lda.z rem+1
    cmp.z divisor+1
    bcc __b3_from___b2
    bne !+
    lda.z rem
    cmp.z divisor
    bcc __b3_from___b2
  !:
    jmp __b5
    // divr16u::@5
  __b5:
    // [134] (word) divr16u::quotient#2 ← ++ (word) divr16u::quotient#1 -- vwuz1=_inc_vwuz1 
    inc.z quotient
    bne !+
    inc.z quotient+1
  !:
    // [135] (word) divr16u::rem#2 ← (word) divr16u::rem#6 - (word) divr16u::divisor#6 -- vwuz1=vwuz1_minus_vwuz2 
    lda.z rem
    sec
    sbc.z divisor
    sta.z rem
    lda.z rem+1
    sbc.z divisor+1
    sta.z rem+1
    // [136] phi from divr16u::@2 divr16u::@5 to divr16u::@3 [phi:divr16u::@2/divr16u::@5->divr16u::@3]
  __b3_from___b2:
  __b3_from___b5:
    // [136] phi (word) divr16u::return#0 = (word) divr16u::quotient#1 [phi:divr16u::@2/divr16u::@5->divr16u::@3#0] -- register_copy 
    // [136] phi (word) divr16u::rem#11 = (word) divr16u::rem#6 [phi:divr16u::@2/divr16u::@5->divr16u::@3#1] -- register_copy 
    jmp __b3
    // divr16u::@3
  __b3:
    // [137] (byte) divr16u::i#1 ← ++ (byte) divr16u::i#2 -- vbuz1=_inc_vbuz1 
    inc.z i
    // [138] if((byte) divr16u::i#1!=(byte) $10) goto divr16u::@1 -- vbuz1_neq_vbuc1_then_la1 
    lda #$10
    cmp.z i
    bne __b1_from___b3
    jmp __b6
    // divr16u::@6
  __b6:
    // [139] (word) rem16u#1 ← (word) divr16u::rem#11 -- vwuz1=vwuz2 
    lda.z rem
    sta.z rem16u
    lda.z rem+1
    sta.z rem16u+1
    jmp __breturn
    // divr16u::@return
  __breturn:
    // [140] return 
    rts
}
  // File Data
  print_hextab: .text "0123456789abcdef"

REGISTER UPLIFT POTENTIAL REGISTERS
Statement [28] (byte*) print_char_cursor#98 ← (byte*) print_line_cursor#1 [ print_char_cursor#98 print_line_cursor#1 ] ( main:2 [ print_char_cursor#98 print_line_cursor#1 ] ) always clobbers reg byte a 
Statement [44] (byte*) print_char_cursor#101 ← (byte*) print_line_cursor#1 [ main::i#10 print_line_cursor#1 print_byte::b#2 print_char_cursor#101 ] ( main:2 [ main::i#10 print_line_cursor#1 print_byte::b#2 print_char_cursor#101 ] ) always clobbers reg byte a 
Removing always clobbered register reg byte a as potential for zp[1]:2 [ main::i#10 main::i#1 ]
Removing always clobbered register reg byte a as potential for zp[1]:7 [ print_byte::b#3 print_byte::b#2 print_byte::b#0 print_byte::b#1 ]
Statement [48] (byte~) main::$27 ← (byte) main::i#10 << (byte) 1 [ main::i#10 print_line_cursor#1 main::$27 print_char_cursor#2 ] ( main:2 [ main::i#10 print_line_cursor#1 main::$27 print_char_cursor#2 ] ) always clobbers reg byte a 
Statement [49] (word) print_word::w#3 ← *((const word*) main::lintab1 + (byte~) main::$27) [ main::i#10 print_line_cursor#1 print_word::w#3 print_char_cursor#2 ] ( main:2 [ main::i#10 print_line_cursor#1 print_word::w#3 print_char_cursor#2 ] ) always clobbers reg byte a 
Statement [53] (byte~) main::$28 ← (byte) main::i#10 << (byte) 1 [ main::i#10 print_line_cursor#1 main::$28 print_char_cursor#2 ] ( main:2 [ main::i#10 print_line_cursor#1 main::$28 print_char_cursor#2 ] ) always clobbers reg byte a 
Statement [54] (word) print_word::w#4 ← *((const word*) main::lintab2 + (byte~) main::$28) [ main::i#10 print_line_cursor#1 print_word::w#4 print_char_cursor#2 ] ( main:2 [ main::i#10 print_line_cursor#1 print_word::w#4 print_char_cursor#2 ] ) always clobbers reg byte a 
Statement [58] (byte~) main::$29 ← (byte) main::i#10 << (byte) 1 [ main::i#10 print_line_cursor#1 main::$29 print_char_cursor#2 ] ( main:2 [ main::i#10 print_line_cursor#1 main::$29 print_char_cursor#2 ] ) always clobbers reg byte a 
Statement [59] (word) print_word::w#5 ← *((const word*) main::lintab3 + (byte~) main::$29) [ main::i#10 print_line_cursor#1 print_word::w#5 print_char_cursor#2 ] ( main:2 [ main::i#10 print_line_cursor#1 print_word::w#5 print_char_cursor#2 ] ) always clobbers reg byte a 
Statement [66] (byte*) print_line_cursor#1 ← (byte*) print_line_cursor#11 + (byte) $28 [ print_line_cursor#1 print_char_cursor#11 ] ( main:2::print_ln:25 [ print_line_cursor#1 print_char_cursor#11 ] main:2::print_ln:41 [ print_line_cursor#1 print_char_cursor#11 ] main:2::print_ln:62 [ main::i#10 print_line_cursor#1 print_char_cursor#11 ] ) always clobbers reg byte a 
Statement [67] if((byte*) print_line_cursor#1<(byte*) print_char_cursor#11) goto print_ln::@1 [ print_line_cursor#1 print_char_cursor#11 ] ( main:2::print_ln:25 [ print_line_cursor#1 print_char_cursor#11 ] main:2::print_ln:41 [ print_line_cursor#1 print_char_cursor#11 ] main:2::print_ln:62 [ main::i#10 print_line_cursor#1 print_char_cursor#11 ] ) always clobbers reg byte a 
Statement [70] (byte) print_byte::b#0 ← > (word) print_word::w#10 [ print_word::w#10 print_byte::b#0 print_char_cursor#2 ] ( main:2::print_word:15 [ print_word::w#10 print_byte::b#0 print_char_cursor#2 ] main:2::print_word:19 [ print_word::w#10 print_byte::b#0 print_char_cursor#2 ] main:2::print_word:23 [ print_word::w#10 print_byte::b#0 print_char_cursor#2 ] main:2::print_word:31 [ print_line_cursor#1 print_word::w#10 print_byte::b#0 print_char_cursor#2 ] main:2::print_word:35 [ print_line_cursor#1 print_word::w#10 print_byte::b#0 print_char_cursor#2 ] main:2::print_word:39 [ print_line_cursor#1 print_word::w#10 print_byte::b#0 print_char_cursor#2 ] main:2::print_word:50 [ main::i#10 print_line_cursor#1 print_word::w#10 print_byte::b#0 print_char_cursor#2 ] main:2::print_word:55 [ main::i#10 print_line_cursor#1 print_word::w#10 print_byte::b#0 print_char_cursor#2 ] main:2::print_word:60 [ main::i#10 print_line_cursor#1 print_word::w#10 print_byte::b#0 print_char_cursor#2 ] ) always clobbers reg byte a 
Statement [72] (byte) print_byte::b#1 ← < (word) print_word::w#10 [ print_char_cursor#11 print_byte::b#1 ] ( main:2::print_word:15 [ print_char_cursor#11 print_byte::b#1 ] main:2::print_word:19 [ print_char_cursor#11 print_byte::b#1 ] main:2::print_word:23 [ print_char_cursor#11 print_byte::b#1 ] main:2::print_word:31 [ print_line_cursor#1 print_char_cursor#11 print_byte::b#1 ] main:2::print_word:35 [ print_line_cursor#1 print_char_cursor#11 print_byte::b#1 ] main:2::print_word:39 [ print_line_cursor#1 print_char_cursor#11 print_byte::b#1 ] main:2::print_word:50 [ main::i#10 print_line_cursor#1 print_char_cursor#11 print_byte::b#1 ] main:2::print_word:55 [ main::i#10 print_line_cursor#1 print_char_cursor#11 print_byte::b#1 ] main:2::print_word:60 [ main::i#10 print_line_cursor#1 print_char_cursor#11 print_byte::b#1 ] ) always clobbers reg byte a 
Statement [76] (byte~) print_byte::$0 ← (byte) print_byte::b#3 >> (byte) 4 [ print_byte::b#3 print_char_cursor#81 print_byte::$0 ] ( main:2::print_byte:45 [ main::i#10 print_line_cursor#1 print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:15::print_byte:71 [ print_word::w#10 print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:19::print_byte:71 [ print_word::w#10 print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:23::print_byte:71 [ print_word::w#10 print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:31::print_byte:71 [ print_line_cursor#1 print_word::w#10 print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:35::print_byte:71 [ print_line_cursor#1 print_word::w#10 print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:39::print_byte:71 [ print_line_cursor#1 print_word::w#10 print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:50::print_byte:71 [ main::i#10 print_line_cursor#1 print_word::w#10 print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:55::print_byte:71 [ main::i#10 print_line_cursor#1 print_word::w#10 print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:60::print_byte:71 [ main::i#10 print_line_cursor#1 print_word::w#10 print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:15::print_byte:73 [ print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:19::print_byte:73 [ print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:23::print_byte:73 [ print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:31::print_byte:73 [ print_line_cursor#1 print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:35::print_byte:73 [ print_line_cursor#1 print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:39::print_byte:73 [ print_line_cursor#1 print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:50::print_byte:73 [ main::i#10 print_line_cursor#1 print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:55::print_byte:73 [ main::i#10 print_line_cursor#1 print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:60::print_byte:73 [ main::i#10 print_line_cursor#1 print_byte::b#3 print_char_cursor#81 print_byte::$0 ] ) always clobbers reg byte a 
Statement [79] (byte~) print_byte::$2 ← (byte) print_byte::b#3 & (byte) $f [ print_char_cursor#11 print_byte::$2 ] ( main:2::print_byte:45 [ main::i#10 print_line_cursor#1 print_char_cursor#11 print_byte::$2 ] main:2::print_word:15::print_byte:71 [ print_word::w#10 print_char_cursor#11 print_byte::$2 ] main:2::print_word:19::print_byte:71 [ print_word::w#10 print_char_cursor#11 print_byte::$2 ] main:2::print_word:23::print_byte:71 [ print_word::w#10 print_char_cursor#11 print_byte::$2 ] main:2::print_word:31::print_byte:71 [ print_line_cursor#1 print_word::w#10 print_char_cursor#11 print_byte::$2 ] main:2::print_word:35::print_byte:71 [ print_line_cursor#1 print_word::w#10 print_char_cursor#11 print_byte::$2 ] main:2::print_word:39::print_byte:71 [ print_line_cursor#1 print_word::w#10 print_char_cursor#11 print_byte::$2 ] main:2::print_word:50::print_byte:71 [ main::i#10 print_line_cursor#1 print_word::w#10 print_char_cursor#11 print_byte::$2 ] main:2::print_word:55::print_byte:71 [ main::i#10 print_line_cursor#1 print_word::w#10 print_char_cursor#11 print_byte::$2 ] main:2::print_word:60::print_byte:71 [ main::i#10 print_line_cursor#1 print_word::w#10 print_char_cursor#11 print_byte::$2 ] main:2::print_word:15::print_byte:73 [ print_char_cursor#11 print_byte::$2 ] main:2::print_word:19::print_byte:73 [ print_char_cursor#11 print_byte::$2 ] main:2::print_word:23::print_byte:73 [ print_char_cursor#11 print_byte::$2 ] main:2::print_word:31::print_byte:73 [ print_line_cursor#1 print_char_cursor#11 print_byte::$2 ] main:2::print_word:35::print_byte:73 [ print_line_cursor#1 print_char_cursor#11 print_byte::$2 ] main:2::print_word:39::print_byte:73 [ print_line_cursor#1 print_char_cursor#11 print_byte::$2 ] main:2::print_word:50::print_byte:73 [ main::i#10 print_line_cursor#1 print_char_cursor#11 print_byte::$2 ] main:2::print_word:55::print_byte:73 [ main::i#10 print_line_cursor#1 print_char_cursor#11 print_byte::$2 ] main:2::print_word:60::print_byte:73 [ main::i#10 print_line_cursor#1 print_char_cursor#11 print_byte::$2 ] ) always clobbers reg byte a 
Statement [84] *((byte*) print_char_cursor#50) ← (byte) print_char::ch#2 [ print_char_cursor#50 ] ( main:2::print_byte:45::print_char:78 [ main::i#10 print_line_cursor#1 print_byte::b#3 print_char_cursor#50 ] main:2::print_word:15::print_byte:71::print_char:78 [ print_word::w#10 print_byte::b#3 print_char_cursor#50 ] main:2::print_word:19::print_byte:71::print_char:78 [ print_word::w#10 print_byte::b#3 print_char_cursor#50 ] main:2::print_word:23::print_byte:71::print_char:78 [ print_word::w#10 print_byte::b#3 print_char_cursor#50 ] main:2::print_word:31::print_byte:71::print_char:78 [ print_line_cursor#1 print_word::w#10 print_byte::b#3 print_char_cursor#50 ] main:2::print_word:35::print_byte:71::print_char:78 [ print_line_cursor#1 print_word::w#10 print_byte::b#3 print_char_cursor#50 ] main:2::print_word:39::print_byte:71::print_char:78 [ print_line_cursor#1 print_word::w#10 print_byte::b#3 print_char_cursor#50 ] main:2::print_word:50::print_byte:71::print_char:78 [ main::i#10 print_line_cursor#1 print_word::w#10 print_byte::b#3 print_char_cursor#50 ] main:2::print_word:55::print_byte:71::print_char:78 [ main::i#10 print_line_cursor#1 print_word::w#10 print_byte::b#3 print_char_cursor#50 ] main:2::print_word:60::print_byte:71::print_char:78 [ main::i#10 print_line_cursor#1 print_word::w#10 print_byte::b#3 print_char_cursor#50 ] main:2::print_word:15::print_byte:73::print_char:78 [ print_byte::b#3 print_char_cursor#50 ] main:2::print_word:19::print_byte:73::print_char:78 [ print_byte::b#3 print_char_cursor#50 ] main:2::print_word:23::print_byte:73::print_char:78 [ print_byte::b#3 print_char_cursor#50 ] main:2::print_word:31::print_byte:73::print_char:78 [ print_line_cursor#1 print_byte::b#3 print_char_cursor#50 ] main:2::print_word:35::print_byte:73::print_char:78 [ print_line_cursor#1 print_byte::b#3 print_char_cursor#50 ] main:2::print_word:39::print_byte:73::print_char:78 [ print_line_cursor#1 print_byte::b#3 print_char_cursor#50 ] main:2::print_word:50::print_byte:73::print_char:78 [ main::i#10 print_line_cursor#1 print_byte::b#3 print_char_cursor#50 ] main:2::print_word:55::print_byte:73::print_char:78 [ main::i#10 print_line_cursor#1 print_byte::b#3 print_char_cursor#50 ] main:2::print_word:60::print_byte:73::print_char:78 [ main::i#10 print_line_cursor#1 print_byte::b#3 print_char_cursor#50 ] main:2::print_byte:45::print_char:81 [ main::i#10 print_line_cursor#1 print_char_cursor#50 ] main:2::print_word:15::print_byte:71::print_char:81 [ print_word::w#10 print_char_cursor#50 ] main:2::print_word:19::print_byte:71::print_char:81 [ print_word::w#10 print_char_cursor#50 ] main:2::print_word:23::print_byte:71::print_char:81 [ print_word::w#10 print_char_cursor#50 ] main:2::print_word:31::print_byte:71::print_char:81 [ print_line_cursor#1 print_word::w#10 print_char_cursor#50 ] main:2::print_word:35::print_byte:71::print_char:81 [ print_line_cursor#1 print_word::w#10 print_char_cursor#50 ] main:2::print_word:39::print_byte:71::print_char:81 [ print_line_cursor#1 print_word::w#10 print_char_cursor#50 ] main:2::print_word:50::print_byte:71::print_char:81 [ main::i#10 print_line_cursor#1 print_word::w#10 print_char_cursor#50 ] main:2::print_word:55::print_byte:71::print_char:81 [ main::i#10 print_line_cursor#1 print_word::w#10 print_char_cursor#50 ] main:2::print_word:60::print_byte:71::print_char:81 [ main::i#10 print_line_cursor#1 print_word::w#10 print_char_cursor#50 ] main:2::print_word:15::print_byte:73::print_char:81 [ print_char_cursor#50 ] main:2::print_word:19::print_byte:73::print_char:81 [ print_char_cursor#50 ] main:2::print_word:23::print_byte:73::print_char:81 [ print_char_cursor#50 ] main:2::print_word:31::print_byte:73::print_char:81 [ print_line_cursor#1 print_char_cursor#50 ] main:2::print_word:35::print_byte:73::print_char:81 [ print_line_cursor#1 print_char_cursor#50 ] main:2::print_word:39::print_byte:73::print_char:81 [ print_line_cursor#1 print_char_cursor#50 ] main:2::print_word:50::print_byte:73::print_char:81 [ main::i#10 print_line_cursor#1 print_char_cursor#50 ] main:2::print_word:55::print_byte:73::print_char:81 [ main::i#10 print_line_cursor#1 print_char_cursor#50 ] main:2::print_word:60::print_byte:73::print_char:81 [ main::i#10 print_line_cursor#1 print_char_cursor#50 ] ) always clobbers reg byte y 
Removing always clobbered register reg byte y as potential for zp[1]:2 [ main::i#10 main::i#1 ]
Removing always clobbered register reg byte y as potential for zp[1]:7 [ print_byte::b#3 print_byte::b#2 print_byte::b#0 print_byte::b#1 ]
Statement [89] if((byte) 0!=*((byte*) print_str::str#10)) goto print_str::@2 [ print_char_cursor#2 print_str::str#10 ] ( main:2::print_str:13 [ print_char_cursor#2 print_str::str#10 ] main:2::print_str:17 [ print_char_cursor#2 print_str::str#10 ] main:2::print_str:21 [ print_char_cursor#2 print_str::str#10 ] main:2::print_str:29 [ print_line_cursor#1 print_char_cursor#2 print_str::str#10 ] main:2::print_str:33 [ print_line_cursor#1 print_char_cursor#2 print_str::str#10 ] main:2::print_str:37 [ print_line_cursor#1 print_char_cursor#2 print_str::str#10 ] main:2::print_str:47 [ main::i#10 print_line_cursor#1 print_char_cursor#2 print_str::str#10 ] main:2::print_str:52 [ main::i#10 print_line_cursor#1 print_char_cursor#2 print_str::str#10 ] main:2::print_str:57 [ main::i#10 print_line_cursor#1 print_char_cursor#2 print_str::str#10 ] ) always clobbers reg byte a reg byte y 
Statement [91] *((byte*) print_char_cursor#2) ← *((byte*) print_str::str#10) [ print_char_cursor#2 print_str::str#10 ] ( main:2::print_str:13 [ print_char_cursor#2 print_str::str#10 ] main:2::print_str:17 [ print_char_cursor#2 print_str::str#10 ] main:2::print_str:21 [ print_char_cursor#2 print_str::str#10 ] main:2::print_str:29 [ print_line_cursor#1 print_char_cursor#2 print_str::str#10 ] main:2::print_str:33 [ print_line_cursor#1 print_char_cursor#2 print_str::str#10 ] main:2::print_str:37 [ print_line_cursor#1 print_char_cursor#2 print_str::str#10 ] main:2::print_str:47 [ main::i#10 print_line_cursor#1 print_char_cursor#2 print_str::str#10 ] main:2::print_str:52 [ main::i#10 print_line_cursor#1 print_char_cursor#2 print_str::str#10 ] main:2::print_str:57 [ main::i#10 print_line_cursor#1 print_char_cursor#2 print_str::str#10 ] ) always clobbers reg byte a reg byte y 
Statement [99] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 [ memset::dst#2 ] ( main:2::print_cls:11::memset:95 [ memset::dst#2 ] ) always clobbers reg byte a 
Statement [101] *((byte*) memset::dst#2) ← (const byte) memset::c#0 [ memset::dst#2 ] ( main:2::print_cls:11::memset:95 [ memset::dst#2 ] ) always clobbers reg byte a reg byte y 
Statement [104] (word) lin16u_gen::ampl#0 ← (word) lin16u_gen::max#3 - (word) lin16u_gen::min#3 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::ampl#0 ] ( main:2::lin16u_gen:5 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::ampl#0 ] main:2::lin16u_gen:7 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::ampl#0 ] main:2::lin16u_gen:9 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::ampl#0 ] ) always clobbers reg byte a 
Statement [105] (word) divr16u::dividend#1 ← (word) lin16u_gen::ampl#0 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::dividend#1 ] ( main:2::lin16u_gen:5 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::dividend#1 ] main:2::lin16u_gen:7 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::dividend#1 ] main:2::lin16u_gen:9 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::dividend#1 ] ) always clobbers reg byte a 
Statement [107] (word) divr16u::return#2 ← (word) divr16u::return#0 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::return#2 rem16u#1 ] ( main:2::lin16u_gen:5 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::return#2 rem16u#1 ] main:2::lin16u_gen:7 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::return#2 rem16u#1 ] main:2::lin16u_gen:9 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::return#2 rem16u#1 ] ) always clobbers reg byte a 
Statement [108] (word) lin16u_gen::stepi#0 ← (word) divr16u::return#2 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 rem16u#1 ] ( main:2::lin16u_gen:5 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 rem16u#1 ] main:2::lin16u_gen:7 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 rem16u#1 ] main:2::lin16u_gen:9 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 rem16u#1 ] ) always clobbers reg byte a 
Statement [109] (word) divr16u::rem#4 ← (word) rem16u#1 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::rem#4 ] ( main:2::lin16u_gen:5 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::rem#4 ] main:2::lin16u_gen:7 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::rem#4 ] main:2::lin16u_gen:9 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::rem#4 ] ) always clobbers reg byte a 
Statement [111] (word) divr16u::return#3 ← (word) divr16u::return#0 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::return#3 ] ( main:2::lin16u_gen:5 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::return#3 ] main:2::lin16u_gen:7 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::return#3 ] main:2::lin16u_gen:9 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::return#3 ] ) always clobbers reg byte a 
Statement [112] (word) lin16u_gen::stepf#0 ← (word) divr16u::return#3 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 lin16u_gen::stepf#0 ] ( main:2::lin16u_gen:5 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 lin16u_gen::stepf#0 ] main:2::lin16u_gen:7 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 lin16u_gen::stepf#0 ] main:2::lin16u_gen:9 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 lin16u_gen::stepf#0 ] ) always clobbers reg byte a 
Statement [113] (dword) lin16u_gen::step#0 ← (word) lin16u_gen::stepi#0 dw= (word) lin16u_gen::stepf#0 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::step#0 ] ( main:2::lin16u_gen:5 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::step#0 ] main:2::lin16u_gen:7 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::step#0 ] main:2::lin16u_gen:9 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::step#0 ] ) always clobbers reg byte a 
Statement [114] (dword) lin16u_gen::val#0 ← (word) lin16u_gen::min#3 dw= (word) 0 [ lin16u_gen::lintab#6 lin16u_gen::step#0 lin16u_gen::val#0 ] ( main:2::lin16u_gen:5 [ lin16u_gen::lintab#6 lin16u_gen::step#0 lin16u_gen::val#0 ] main:2::lin16u_gen:7 [ lin16u_gen::lintab#6 lin16u_gen::step#0 lin16u_gen::val#0 ] main:2::lin16u_gen:9 [ lin16u_gen::lintab#6 lin16u_gen::step#0 lin16u_gen::val#0 ] ) always clobbers reg byte a 
Statement [116] if((word) lin16u_gen::i#2<(byte) $14) goto lin16u_gen::@2 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::val#2 lin16u_gen::lintab#4 ] ( main:2::lin16u_gen:5 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::val#2 lin16u_gen::lintab#4 ] main:2::lin16u_gen:7 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::val#2 lin16u_gen::lintab#4 ] main:2::lin16u_gen:9 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::val#2 lin16u_gen::lintab#4 ] ) always clobbers reg byte a 
Statement [118] (word~) lin16u_gen::$6 ← > (dword) lin16u_gen::val#2 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::val#2 lin16u_gen::lintab#4 lin16u_gen::$6 ] ( main:2::lin16u_gen:5 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::val#2 lin16u_gen::lintab#4 lin16u_gen::$6 ] main:2::lin16u_gen:7 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::val#2 lin16u_gen::lintab#4 lin16u_gen::$6 ] main:2::lin16u_gen:9 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::val#2 lin16u_gen::lintab#4 lin16u_gen::$6 ] ) always clobbers reg byte a 
Statement [119] *((word*) lin16u_gen::lintab#4) ← (word~) lin16u_gen::$6 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::val#2 lin16u_gen::lintab#4 ] ( main:2::lin16u_gen:5 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::val#2 lin16u_gen::lintab#4 ] main:2::lin16u_gen:7 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::val#2 lin16u_gen::lintab#4 ] main:2::lin16u_gen:9 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::val#2 lin16u_gen::lintab#4 ] ) always clobbers reg byte a reg byte y 
Statement [120] (dword) lin16u_gen::val#1 ← (dword) lin16u_gen::val#2 + (dword) lin16u_gen::step#0 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::lintab#4 lin16u_gen::val#1 ] ( main:2::lin16u_gen:5 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::lintab#4 lin16u_gen::val#1 ] main:2::lin16u_gen:7 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::lintab#4 lin16u_gen::val#1 ] main:2::lin16u_gen:9 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::lintab#4 lin16u_gen::val#1 ] ) always clobbers reg byte a 
Statement [121] (word*) lin16u_gen::lintab#3 ← (word*) lin16u_gen::lintab#4 + (const byte) SIZEOF_WORD [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::val#1 lin16u_gen::lintab#3 ] ( main:2::lin16u_gen:5 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::val#1 lin16u_gen::lintab#3 ] main:2::lin16u_gen:7 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::val#1 lin16u_gen::lintab#3 ] main:2::lin16u_gen:9 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::val#1 lin16u_gen::lintab#3 ] ) always clobbers reg byte a 
Statement [126] (byte~) divr16u::$1 ← > (word) divr16u::dividend#3 [ divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#0 divr16u::$1 ] ( main:2::lin16u_gen:5::divr16u:106 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#0 divr16u::$1 ] main:2::lin16u_gen:7::divr16u:106 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#0 divr16u::$1 ] main:2::lin16u_gen:9::divr16u:106 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#0 divr16u::$1 ] main:2::lin16u_gen:5::divr16u:110 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#0 divr16u::$1 ] main:2::lin16u_gen:7::divr16u:110 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#0 divr16u::$1 ] main:2::lin16u_gen:9::divr16u:110 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#0 divr16u::$1 ] ) always clobbers reg byte a 
Removing always clobbered register reg byte a as potential for zp[1]:35 [ divr16u::i#2 divr16u::i#1 ]
Statement [129] (word) divr16u::rem#1 ← (word) divr16u::rem#0 | (byte) 1 [ divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#1 ] ( main:2::lin16u_gen:5::divr16u:106 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#1 ] main:2::lin16u_gen:7::divr16u:106 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#1 ] main:2::lin16u_gen:9::divr16u:106 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#1 ] main:2::lin16u_gen:5::divr16u:110 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#1 ] main:2::lin16u_gen:7::divr16u:110 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#1 ] main:2::lin16u_gen:9::divr16u:110 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#1 ] ) always clobbers reg byte a 
Statement [133] if((word) divr16u::rem#6<(word) divr16u::divisor#6) goto divr16u::@3 [ divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::rem#6 divr16u::quotient#1 ] ( main:2::lin16u_gen:5::divr16u:106 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::rem#6 divr16u::quotient#1 ] main:2::lin16u_gen:7::divr16u:106 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::rem#6 divr16u::quotient#1 ] main:2::lin16u_gen:9::divr16u:106 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::rem#6 divr16u::quotient#1 ] main:2::lin16u_gen:5::divr16u:110 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::rem#6 divr16u::quotient#1 ] main:2::lin16u_gen:7::divr16u:110 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::rem#6 divr16u::quotient#1 ] main:2::lin16u_gen:9::divr16u:110 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::rem#6 divr16u::quotient#1 ] ) always clobbers reg byte a 
Statement [135] (word) divr16u::rem#2 ← (word) divr16u::rem#6 - (word) divr16u::divisor#6 [ divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::quotient#2 divr16u::rem#2 ] ( main:2::lin16u_gen:5::divr16u:106 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::quotient#2 divr16u::rem#2 ] main:2::lin16u_gen:7::divr16u:106 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::quotient#2 divr16u::rem#2 ] main:2::lin16u_gen:9::divr16u:106 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::quotient#2 divr16u::rem#2 ] main:2::lin16u_gen:5::divr16u:110 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::quotient#2 divr16u::rem#2 ] main:2::lin16u_gen:7::divr16u:110 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::quotient#2 divr16u::rem#2 ] main:2::lin16u_gen:9::divr16u:110 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::quotient#2 divr16u::rem#2 ] ) always clobbers reg byte a 
Statement [139] (word) rem16u#1 ← (word) divr16u::rem#11 [ divr16u::return#0 rem16u#1 ] ( main:2::lin16u_gen:5::divr16u:106 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::return#0 rem16u#1 ] main:2::lin16u_gen:7::divr16u:106 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::return#0 rem16u#1 ] main:2::lin16u_gen:9::divr16u:106 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::return#0 rem16u#1 ] main:2::lin16u_gen:5::divr16u:110 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::return#0 rem16u#1 ] main:2::lin16u_gen:7::divr16u:110 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::return#0 rem16u#1 ] main:2::lin16u_gen:9::divr16u:110 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::return#0 rem16u#1 ] ) always clobbers reg byte a 
Statement [28] (byte*) print_char_cursor#98 ← (byte*) print_line_cursor#1 [ print_char_cursor#98 print_line_cursor#1 ] ( main:2 [ print_char_cursor#98 print_line_cursor#1 ] ) always clobbers reg byte a 
Statement [44] (byte*) print_char_cursor#101 ← (byte*) print_line_cursor#1 [ main::i#10 print_line_cursor#1 print_byte::b#2 print_char_cursor#101 ] ( main:2 [ main::i#10 print_line_cursor#1 print_byte::b#2 print_char_cursor#101 ] ) always clobbers reg byte a 
Statement [48] (byte~) main::$27 ← (byte) main::i#10 << (byte) 1 [ main::i#10 print_line_cursor#1 main::$27 print_char_cursor#2 ] ( main:2 [ main::i#10 print_line_cursor#1 main::$27 print_char_cursor#2 ] ) always clobbers reg byte a 
Statement [49] (word) print_word::w#3 ← *((const word*) main::lintab1 + (byte~) main::$27) [ main::i#10 print_line_cursor#1 print_word::w#3 print_char_cursor#2 ] ( main:2 [ main::i#10 print_line_cursor#1 print_word::w#3 print_char_cursor#2 ] ) always clobbers reg byte a 
Statement [53] (byte~) main::$28 ← (byte) main::i#10 << (byte) 1 [ main::i#10 print_line_cursor#1 main::$28 print_char_cursor#2 ] ( main:2 [ main::i#10 print_line_cursor#1 main::$28 print_char_cursor#2 ] ) always clobbers reg byte a 
Statement [54] (word) print_word::w#4 ← *((const word*) main::lintab2 + (byte~) main::$28) [ main::i#10 print_line_cursor#1 print_word::w#4 print_char_cursor#2 ] ( main:2 [ main::i#10 print_line_cursor#1 print_word::w#4 print_char_cursor#2 ] ) always clobbers reg byte a 
Statement [58] (byte~) main::$29 ← (byte) main::i#10 << (byte) 1 [ main::i#10 print_line_cursor#1 main::$29 print_char_cursor#2 ] ( main:2 [ main::i#10 print_line_cursor#1 main::$29 print_char_cursor#2 ] ) always clobbers reg byte a 
Statement [59] (word) print_word::w#5 ← *((const word*) main::lintab3 + (byte~) main::$29) [ main::i#10 print_line_cursor#1 print_word::w#5 print_char_cursor#2 ] ( main:2 [ main::i#10 print_line_cursor#1 print_word::w#5 print_char_cursor#2 ] ) always clobbers reg byte a 
Statement [66] (byte*) print_line_cursor#1 ← (byte*) print_line_cursor#11 + (byte) $28 [ print_line_cursor#1 print_char_cursor#11 ] ( main:2::print_ln:25 [ print_line_cursor#1 print_char_cursor#11 ] main:2::print_ln:41 [ print_line_cursor#1 print_char_cursor#11 ] main:2::print_ln:62 [ main::i#10 print_line_cursor#1 print_char_cursor#11 ] ) always clobbers reg byte a 
Statement [67] if((byte*) print_line_cursor#1<(byte*) print_char_cursor#11) goto print_ln::@1 [ print_line_cursor#1 print_char_cursor#11 ] ( main:2::print_ln:25 [ print_line_cursor#1 print_char_cursor#11 ] main:2::print_ln:41 [ print_line_cursor#1 print_char_cursor#11 ] main:2::print_ln:62 [ main::i#10 print_line_cursor#1 print_char_cursor#11 ] ) always clobbers reg byte a 
Statement [70] (byte) print_byte::b#0 ← > (word) print_word::w#10 [ print_word::w#10 print_byte::b#0 print_char_cursor#2 ] ( main:2::print_word:15 [ print_word::w#10 print_byte::b#0 print_char_cursor#2 ] main:2::print_word:19 [ print_word::w#10 print_byte::b#0 print_char_cursor#2 ] main:2::print_word:23 [ print_word::w#10 print_byte::b#0 print_char_cursor#2 ] main:2::print_word:31 [ print_line_cursor#1 print_word::w#10 print_byte::b#0 print_char_cursor#2 ] main:2::print_word:35 [ print_line_cursor#1 print_word::w#10 print_byte::b#0 print_char_cursor#2 ] main:2::print_word:39 [ print_line_cursor#1 print_word::w#10 print_byte::b#0 print_char_cursor#2 ] main:2::print_word:50 [ main::i#10 print_line_cursor#1 print_word::w#10 print_byte::b#0 print_char_cursor#2 ] main:2::print_word:55 [ main::i#10 print_line_cursor#1 print_word::w#10 print_byte::b#0 print_char_cursor#2 ] main:2::print_word:60 [ main::i#10 print_line_cursor#1 print_word::w#10 print_byte::b#0 print_char_cursor#2 ] ) always clobbers reg byte a 
Statement [72] (byte) print_byte::b#1 ← < (word) print_word::w#10 [ print_char_cursor#11 print_byte::b#1 ] ( main:2::print_word:15 [ print_char_cursor#11 print_byte::b#1 ] main:2::print_word:19 [ print_char_cursor#11 print_byte::b#1 ] main:2::print_word:23 [ print_char_cursor#11 print_byte::b#1 ] main:2::print_word:31 [ print_line_cursor#1 print_char_cursor#11 print_byte::b#1 ] main:2::print_word:35 [ print_line_cursor#1 print_char_cursor#11 print_byte::b#1 ] main:2::print_word:39 [ print_line_cursor#1 print_char_cursor#11 print_byte::b#1 ] main:2::print_word:50 [ main::i#10 print_line_cursor#1 print_char_cursor#11 print_byte::b#1 ] main:2::print_word:55 [ main::i#10 print_line_cursor#1 print_char_cursor#11 print_byte::b#1 ] main:2::print_word:60 [ main::i#10 print_line_cursor#1 print_char_cursor#11 print_byte::b#1 ] ) always clobbers reg byte a 
Statement [76] (byte~) print_byte::$0 ← (byte) print_byte::b#3 >> (byte) 4 [ print_byte::b#3 print_char_cursor#81 print_byte::$0 ] ( main:2::print_byte:45 [ main::i#10 print_line_cursor#1 print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:15::print_byte:71 [ print_word::w#10 print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:19::print_byte:71 [ print_word::w#10 print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:23::print_byte:71 [ print_word::w#10 print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:31::print_byte:71 [ print_line_cursor#1 print_word::w#10 print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:35::print_byte:71 [ print_line_cursor#1 print_word::w#10 print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:39::print_byte:71 [ print_line_cursor#1 print_word::w#10 print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:50::print_byte:71 [ main::i#10 print_line_cursor#1 print_word::w#10 print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:55::print_byte:71 [ main::i#10 print_line_cursor#1 print_word::w#10 print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:60::print_byte:71 [ main::i#10 print_line_cursor#1 print_word::w#10 print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:15::print_byte:73 [ print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:19::print_byte:73 [ print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:23::print_byte:73 [ print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:31::print_byte:73 [ print_line_cursor#1 print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:35::print_byte:73 [ print_line_cursor#1 print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:39::print_byte:73 [ print_line_cursor#1 print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:50::print_byte:73 [ main::i#10 print_line_cursor#1 print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:55::print_byte:73 [ main::i#10 print_line_cursor#1 print_byte::b#3 print_char_cursor#81 print_byte::$0 ] main:2::print_word:60::print_byte:73 [ main::i#10 print_line_cursor#1 print_byte::b#3 print_char_cursor#81 print_byte::$0 ] ) always clobbers reg byte a 
Statement [79] (byte~) print_byte::$2 ← (byte) print_byte::b#3 & (byte) $f [ print_char_cursor#11 print_byte::$2 ] ( main:2::print_byte:45 [ main::i#10 print_line_cursor#1 print_char_cursor#11 print_byte::$2 ] main:2::print_word:15::print_byte:71 [ print_word::w#10 print_char_cursor#11 print_byte::$2 ] main:2::print_word:19::print_byte:71 [ print_word::w#10 print_char_cursor#11 print_byte::$2 ] main:2::print_word:23::print_byte:71 [ print_word::w#10 print_char_cursor#11 print_byte::$2 ] main:2::print_word:31::print_byte:71 [ print_line_cursor#1 print_word::w#10 print_char_cursor#11 print_byte::$2 ] main:2::print_word:35::print_byte:71 [ print_line_cursor#1 print_word::w#10 print_char_cursor#11 print_byte::$2 ] main:2::print_word:39::print_byte:71 [ print_line_cursor#1 print_word::w#10 print_char_cursor#11 print_byte::$2 ] main:2::print_word:50::print_byte:71 [ main::i#10 print_line_cursor#1 print_word::w#10 print_char_cursor#11 print_byte::$2 ] main:2::print_word:55::print_byte:71 [ main::i#10 print_line_cursor#1 print_word::w#10 print_char_cursor#11 print_byte::$2 ] main:2::print_word:60::print_byte:71 [ main::i#10 print_line_cursor#1 print_word::w#10 print_char_cursor#11 print_byte::$2 ] main:2::print_word:15::print_byte:73 [ print_char_cursor#11 print_byte::$2 ] main:2::print_word:19::print_byte:73 [ print_char_cursor#11 print_byte::$2 ] main:2::print_word:23::print_byte:73 [ print_char_cursor#11 print_byte::$2 ] main:2::print_word:31::print_byte:73 [ print_line_cursor#1 print_char_cursor#11 print_byte::$2 ] main:2::print_word:35::print_byte:73 [ print_line_cursor#1 print_char_cursor#11 print_byte::$2 ] main:2::print_word:39::print_byte:73 [ print_line_cursor#1 print_char_cursor#11 print_byte::$2 ] main:2::print_word:50::print_byte:73 [ main::i#10 print_line_cursor#1 print_char_cursor#11 print_byte::$2 ] main:2::print_word:55::print_byte:73 [ main::i#10 print_line_cursor#1 print_char_cursor#11 print_byte::$2 ] main:2::print_word:60::print_byte:73 [ main::i#10 print_line_cursor#1 print_char_cursor#11 print_byte::$2 ] ) always clobbers reg byte a 
Statement [84] *((byte*) print_char_cursor#50) ← (byte) print_char::ch#2 [ print_char_cursor#50 ] ( main:2::print_byte:45::print_char:78 [ main::i#10 print_line_cursor#1 print_byte::b#3 print_char_cursor#50 ] main:2::print_word:15::print_byte:71::print_char:78 [ print_word::w#10 print_byte::b#3 print_char_cursor#50 ] main:2::print_word:19::print_byte:71::print_char:78 [ print_word::w#10 print_byte::b#3 print_char_cursor#50 ] main:2::print_word:23::print_byte:71::print_char:78 [ print_word::w#10 print_byte::b#3 print_char_cursor#50 ] main:2::print_word:31::print_byte:71::print_char:78 [ print_line_cursor#1 print_word::w#10 print_byte::b#3 print_char_cursor#50 ] main:2::print_word:35::print_byte:71::print_char:78 [ print_line_cursor#1 print_word::w#10 print_byte::b#3 print_char_cursor#50 ] main:2::print_word:39::print_byte:71::print_char:78 [ print_line_cursor#1 print_word::w#10 print_byte::b#3 print_char_cursor#50 ] main:2::print_word:50::print_byte:71::print_char:78 [ main::i#10 print_line_cursor#1 print_word::w#10 print_byte::b#3 print_char_cursor#50 ] main:2::print_word:55::print_byte:71::print_char:78 [ main::i#10 print_line_cursor#1 print_word::w#10 print_byte::b#3 print_char_cursor#50 ] main:2::print_word:60::print_byte:71::print_char:78 [ main::i#10 print_line_cursor#1 print_word::w#10 print_byte::b#3 print_char_cursor#50 ] main:2::print_word:15::print_byte:73::print_char:78 [ print_byte::b#3 print_char_cursor#50 ] main:2::print_word:19::print_byte:73::print_char:78 [ print_byte::b#3 print_char_cursor#50 ] main:2::print_word:23::print_byte:73::print_char:78 [ print_byte::b#3 print_char_cursor#50 ] main:2::print_word:31::print_byte:73::print_char:78 [ print_line_cursor#1 print_byte::b#3 print_char_cursor#50 ] main:2::print_word:35::print_byte:73::print_char:78 [ print_line_cursor#1 print_byte::b#3 print_char_cursor#50 ] main:2::print_word:39::print_byte:73::print_char:78 [ print_line_cursor#1 print_byte::b#3 print_char_cursor#50 ] main:2::print_word:50::print_byte:73::print_char:78 [ main::i#10 print_line_cursor#1 print_byte::b#3 print_char_cursor#50 ] main:2::print_word:55::print_byte:73::print_char:78 [ main::i#10 print_line_cursor#1 print_byte::b#3 print_char_cursor#50 ] main:2::print_word:60::print_byte:73::print_char:78 [ main::i#10 print_line_cursor#1 print_byte::b#3 print_char_cursor#50 ] main:2::print_byte:45::print_char:81 [ main::i#10 print_line_cursor#1 print_char_cursor#50 ] main:2::print_word:15::print_byte:71::print_char:81 [ print_word::w#10 print_char_cursor#50 ] main:2::print_word:19::print_byte:71::print_char:81 [ print_word::w#10 print_char_cursor#50 ] main:2::print_word:23::print_byte:71::print_char:81 [ print_word::w#10 print_char_cursor#50 ] main:2::print_word:31::print_byte:71::print_char:81 [ print_line_cursor#1 print_word::w#10 print_char_cursor#50 ] main:2::print_word:35::print_byte:71::print_char:81 [ print_line_cursor#1 print_word::w#10 print_char_cursor#50 ] main:2::print_word:39::print_byte:71::print_char:81 [ print_line_cursor#1 print_word::w#10 print_char_cursor#50 ] main:2::print_word:50::print_byte:71::print_char:81 [ main::i#10 print_line_cursor#1 print_word::w#10 print_char_cursor#50 ] main:2::print_word:55::print_byte:71::print_char:81 [ main::i#10 print_line_cursor#1 print_word::w#10 print_char_cursor#50 ] main:2::print_word:60::print_byte:71::print_char:81 [ main::i#10 print_line_cursor#1 print_word::w#10 print_char_cursor#50 ] main:2::print_word:15::print_byte:73::print_char:81 [ print_char_cursor#50 ] main:2::print_word:19::print_byte:73::print_char:81 [ print_char_cursor#50 ] main:2::print_word:23::print_byte:73::print_char:81 [ print_char_cursor#50 ] main:2::print_word:31::print_byte:73::print_char:81 [ print_line_cursor#1 print_char_cursor#50 ] main:2::print_word:35::print_byte:73::print_char:81 [ print_line_cursor#1 print_char_cursor#50 ] main:2::print_word:39::print_byte:73::print_char:81 [ print_line_cursor#1 print_char_cursor#50 ] main:2::print_word:50::print_byte:73::print_char:81 [ main::i#10 print_line_cursor#1 print_char_cursor#50 ] main:2::print_word:55::print_byte:73::print_char:81 [ main::i#10 print_line_cursor#1 print_char_cursor#50 ] main:2::print_word:60::print_byte:73::print_char:81 [ main::i#10 print_line_cursor#1 print_char_cursor#50 ] ) always clobbers reg byte y 
Statement [89] if((byte) 0!=*((byte*) print_str::str#10)) goto print_str::@2 [ print_char_cursor#2 print_str::str#10 ] ( main:2::print_str:13 [ print_char_cursor#2 print_str::str#10 ] main:2::print_str:17 [ print_char_cursor#2 print_str::str#10 ] main:2::print_str:21 [ print_char_cursor#2 print_str::str#10 ] main:2::print_str:29 [ print_line_cursor#1 print_char_cursor#2 print_str::str#10 ] main:2::print_str:33 [ print_line_cursor#1 print_char_cursor#2 print_str::str#10 ] main:2::print_str:37 [ print_line_cursor#1 print_char_cursor#2 print_str::str#10 ] main:2::print_str:47 [ main::i#10 print_line_cursor#1 print_char_cursor#2 print_str::str#10 ] main:2::print_str:52 [ main::i#10 print_line_cursor#1 print_char_cursor#2 print_str::str#10 ] main:2::print_str:57 [ main::i#10 print_line_cursor#1 print_char_cursor#2 print_str::str#10 ] ) always clobbers reg byte a reg byte y 
Statement [91] *((byte*) print_char_cursor#2) ← *((byte*) print_str::str#10) [ print_char_cursor#2 print_str::str#10 ] ( main:2::print_str:13 [ print_char_cursor#2 print_str::str#10 ] main:2::print_str:17 [ print_char_cursor#2 print_str::str#10 ] main:2::print_str:21 [ print_char_cursor#2 print_str::str#10 ] main:2::print_str:29 [ print_line_cursor#1 print_char_cursor#2 print_str::str#10 ] main:2::print_str:33 [ print_line_cursor#1 print_char_cursor#2 print_str::str#10 ] main:2::print_str:37 [ print_line_cursor#1 print_char_cursor#2 print_str::str#10 ] main:2::print_str:47 [ main::i#10 print_line_cursor#1 print_char_cursor#2 print_str::str#10 ] main:2::print_str:52 [ main::i#10 print_line_cursor#1 print_char_cursor#2 print_str::str#10 ] main:2::print_str:57 [ main::i#10 print_line_cursor#1 print_char_cursor#2 print_str::str#10 ] ) always clobbers reg byte a reg byte y 
Statement [99] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 [ memset::dst#2 ] ( main:2::print_cls:11::memset:95 [ memset::dst#2 ] ) always clobbers reg byte a 
Statement [101] *((byte*) memset::dst#2) ← (const byte) memset::c#0 [ memset::dst#2 ] ( main:2::print_cls:11::memset:95 [ memset::dst#2 ] ) always clobbers reg byte a reg byte y 
Statement [104] (word) lin16u_gen::ampl#0 ← (word) lin16u_gen::max#3 - (word) lin16u_gen::min#3 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::ampl#0 ] ( main:2::lin16u_gen:5 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::ampl#0 ] main:2::lin16u_gen:7 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::ampl#0 ] main:2::lin16u_gen:9 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::ampl#0 ] ) always clobbers reg byte a 
Statement [105] (word) divr16u::dividend#1 ← (word) lin16u_gen::ampl#0 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::dividend#1 ] ( main:2::lin16u_gen:5 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::dividend#1 ] main:2::lin16u_gen:7 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::dividend#1 ] main:2::lin16u_gen:9 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::dividend#1 ] ) always clobbers reg byte a 
Statement [107] (word) divr16u::return#2 ← (word) divr16u::return#0 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::return#2 rem16u#1 ] ( main:2::lin16u_gen:5 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::return#2 rem16u#1 ] main:2::lin16u_gen:7 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::return#2 rem16u#1 ] main:2::lin16u_gen:9 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::return#2 rem16u#1 ] ) always clobbers reg byte a 
Statement [108] (word) lin16u_gen::stepi#0 ← (word) divr16u::return#2 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 rem16u#1 ] ( main:2::lin16u_gen:5 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 rem16u#1 ] main:2::lin16u_gen:7 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 rem16u#1 ] main:2::lin16u_gen:9 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 rem16u#1 ] ) always clobbers reg byte a 
Statement [109] (word) divr16u::rem#4 ← (word) rem16u#1 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::rem#4 ] ( main:2::lin16u_gen:5 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::rem#4 ] main:2::lin16u_gen:7 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::rem#4 ] main:2::lin16u_gen:9 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::rem#4 ] ) always clobbers reg byte a 
Statement [111] (word) divr16u::return#3 ← (word) divr16u::return#0 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::return#3 ] ( main:2::lin16u_gen:5 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::return#3 ] main:2::lin16u_gen:7 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::return#3 ] main:2::lin16u_gen:9 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::return#3 ] ) always clobbers reg byte a 
Statement [112] (word) lin16u_gen::stepf#0 ← (word) divr16u::return#3 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 lin16u_gen::stepf#0 ] ( main:2::lin16u_gen:5 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 lin16u_gen::stepf#0 ] main:2::lin16u_gen:7 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 lin16u_gen::stepf#0 ] main:2::lin16u_gen:9 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 lin16u_gen::stepf#0 ] ) always clobbers reg byte a 
Statement [113] (dword) lin16u_gen::step#0 ← (word) lin16u_gen::stepi#0 dw= (word) lin16u_gen::stepf#0 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::step#0 ] ( main:2::lin16u_gen:5 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::step#0 ] main:2::lin16u_gen:7 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::step#0 ] main:2::lin16u_gen:9 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::step#0 ] ) always clobbers reg byte a 
Statement [114] (dword) lin16u_gen::val#0 ← (word) lin16u_gen::min#3 dw= (word) 0 [ lin16u_gen::lintab#6 lin16u_gen::step#0 lin16u_gen::val#0 ] ( main:2::lin16u_gen:5 [ lin16u_gen::lintab#6 lin16u_gen::step#0 lin16u_gen::val#0 ] main:2::lin16u_gen:7 [ lin16u_gen::lintab#6 lin16u_gen::step#0 lin16u_gen::val#0 ] main:2::lin16u_gen:9 [ lin16u_gen::lintab#6 lin16u_gen::step#0 lin16u_gen::val#0 ] ) always clobbers reg byte a 
Statement [116] if((word) lin16u_gen::i#2<(byte) $14) goto lin16u_gen::@2 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::val#2 lin16u_gen::lintab#4 ] ( main:2::lin16u_gen:5 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::val#2 lin16u_gen::lintab#4 ] main:2::lin16u_gen:7 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::val#2 lin16u_gen::lintab#4 ] main:2::lin16u_gen:9 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::val#2 lin16u_gen::lintab#4 ] ) always clobbers reg byte a 
Statement [118] (word~) lin16u_gen::$6 ← > (dword) lin16u_gen::val#2 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::val#2 lin16u_gen::lintab#4 lin16u_gen::$6 ] ( main:2::lin16u_gen:5 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::val#2 lin16u_gen::lintab#4 lin16u_gen::$6 ] main:2::lin16u_gen:7 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::val#2 lin16u_gen::lintab#4 lin16u_gen::$6 ] main:2::lin16u_gen:9 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::val#2 lin16u_gen::lintab#4 lin16u_gen::$6 ] ) always clobbers reg byte a 
Statement [119] *((word*) lin16u_gen::lintab#4) ← (word~) lin16u_gen::$6 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::val#2 lin16u_gen::lintab#4 ] ( main:2::lin16u_gen:5 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::val#2 lin16u_gen::lintab#4 ] main:2::lin16u_gen:7 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::val#2 lin16u_gen::lintab#4 ] main:2::lin16u_gen:9 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::val#2 lin16u_gen::lintab#4 ] ) always clobbers reg byte a reg byte y 
Statement [120] (dword) lin16u_gen::val#1 ← (dword) lin16u_gen::val#2 + (dword) lin16u_gen::step#0 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::lintab#4 lin16u_gen::val#1 ] ( main:2::lin16u_gen:5 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::lintab#4 lin16u_gen::val#1 ] main:2::lin16u_gen:7 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::lintab#4 lin16u_gen::val#1 ] main:2::lin16u_gen:9 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::lintab#4 lin16u_gen::val#1 ] ) always clobbers reg byte a 
Statement [121] (word*) lin16u_gen::lintab#3 ← (word*) lin16u_gen::lintab#4 + (const byte) SIZEOF_WORD [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::val#1 lin16u_gen::lintab#3 ] ( main:2::lin16u_gen:5 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::val#1 lin16u_gen::lintab#3 ] main:2::lin16u_gen:7 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::val#1 lin16u_gen::lintab#3 ] main:2::lin16u_gen:9 [ lin16u_gen::step#0 lin16u_gen::i#2 lin16u_gen::val#1 lin16u_gen::lintab#3 ] ) always clobbers reg byte a 
Statement [126] (byte~) divr16u::$1 ← > (word) divr16u::dividend#3 [ divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#0 divr16u::$1 ] ( main:2::lin16u_gen:5::divr16u:106 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#0 divr16u::$1 ] main:2::lin16u_gen:7::divr16u:106 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#0 divr16u::$1 ] main:2::lin16u_gen:9::divr16u:106 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#0 divr16u::$1 ] main:2::lin16u_gen:5::divr16u:110 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#0 divr16u::$1 ] main:2::lin16u_gen:7::divr16u:110 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#0 divr16u::$1 ] main:2::lin16u_gen:9::divr16u:110 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#0 divr16u::$1 ] ) always clobbers reg byte a 
Statement [129] (word) divr16u::rem#1 ← (word) divr16u::rem#0 | (byte) 1 [ divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#1 ] ( main:2::lin16u_gen:5::divr16u:106 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#1 ] main:2::lin16u_gen:7::divr16u:106 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#1 ] main:2::lin16u_gen:9::divr16u:106 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#1 ] main:2::lin16u_gen:5::divr16u:110 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#1 ] main:2::lin16u_gen:7::divr16u:110 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#1 ] main:2::lin16u_gen:9::divr16u:110 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#1 ] ) always clobbers reg byte a 
Statement [133] if((word) divr16u::rem#6<(word) divr16u::divisor#6) goto divr16u::@3 [ divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::rem#6 divr16u::quotient#1 ] ( main:2::lin16u_gen:5::divr16u:106 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::rem#6 divr16u::quotient#1 ] main:2::lin16u_gen:7::divr16u:106 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::rem#6 divr16u::quotient#1 ] main:2::lin16u_gen:9::divr16u:106 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::rem#6 divr16u::quotient#1 ] main:2::lin16u_gen:5::divr16u:110 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::rem#6 divr16u::quotient#1 ] main:2::lin16u_gen:7::divr16u:110 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::rem#6 divr16u::quotient#1 ] main:2::lin16u_gen:9::divr16u:110 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::rem#6 divr16u::quotient#1 ] ) always clobbers reg byte a 
Statement [135] (word) divr16u::rem#2 ← (word) divr16u::rem#6 - (word) divr16u::divisor#6 [ divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::quotient#2 divr16u::rem#2 ] ( main:2::lin16u_gen:5::divr16u:106 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::quotient#2 divr16u::rem#2 ] main:2::lin16u_gen:7::divr16u:106 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::quotient#2 divr16u::rem#2 ] main:2::lin16u_gen:9::divr16u:106 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::quotient#2 divr16u::rem#2 ] main:2::lin16u_gen:5::divr16u:110 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::quotient#2 divr16u::rem#2 ] main:2::lin16u_gen:7::divr16u:110 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::quotient#2 divr16u::rem#2 ] main:2::lin16u_gen:9::divr16u:110 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::quotient#2 divr16u::rem#2 ] ) always clobbers reg byte a 
Statement [139] (word) rem16u#1 ← (word) divr16u::rem#11 [ divr16u::return#0 rem16u#1 ] ( main:2::lin16u_gen:5::divr16u:106 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::return#0 rem16u#1 ] main:2::lin16u_gen:7::divr16u:106 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::return#0 rem16u#1 ] main:2::lin16u_gen:9::divr16u:106 [ lin16u_gen::min#3 lin16u_gen::lintab#6 divr16u::return#0 rem16u#1 ] main:2::lin16u_gen:5::divr16u:110 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::return#0 rem16u#1 ] main:2::lin16u_gen:7::divr16u:110 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::return#0 rem16u#1 ] main:2::lin16u_gen:9::divr16u:110 [ lin16u_gen::min#3 lin16u_gen::lintab#6 lin16u_gen::stepi#0 divr16u::return#0 rem16u#1 ] ) always clobbers reg byte a 
Potential registers zp[1]:2 [ main::i#10 main::i#1 ] : zp[1]:2 , reg byte x , 
Potential registers zp[2]:3 [ print_line_cursor#11 print_line_cursor#21 print_line_cursor#1 ] : zp[2]:3 , 
Potential registers zp[2]:5 [ print_word::w#10 print_word::w#3 print_word::w#4 print_word::w#5 ] : zp[2]:5 , 
Potential registers zp[1]:7 [ print_byte::b#3 print_byte::b#2 print_byte::b#0 print_byte::b#1 ] : zp[1]:7 , reg byte x , 
Potential registers zp[1]:8 [ print_char::ch#2 print_char::ch#0 print_char::ch#1 ] : zp[1]:8 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[2]:9 [ print_char_cursor#86 print_char_cursor#50 print_char_cursor#81 print_char_cursor#101 print_char_cursor#2 print_char_cursor#11 print_char_cursor#98 print_char_cursor#1 ] : zp[2]:9 , 
Potential registers zp[2]:11 [ print_str::str#10 print_str::str#12 print_str::str#0 ] : zp[2]:11 , 
Potential registers zp[2]:13 [ memset::dst#2 memset::dst#1 ] : zp[2]:13 , 
Potential registers zp[2]:15 [ lin16u_gen::max#3 ] : zp[2]:15 , 
Potential registers zp[2]:17 [ lin16u_gen::min#3 ] : zp[2]:17 , 
Potential registers zp[2]:19 [ lin16u_gen::i#2 lin16u_gen::i#1 ] : zp[2]:19 , 
Potential registers zp[4]:21 [ lin16u_gen::val#2 lin16u_gen::val#1 lin16u_gen::val#0 ] : zp[4]:21 , 
Potential registers zp[2]:25 [ lin16u_gen::lintab#4 lin16u_gen::lintab#3 lin16u_gen::lintab#6 ] : zp[2]:25 , 
Potential registers zp[2]:27 [ divr16u::divisor#6 ] : zp[2]:27 , 
Potential registers zp[2]:29 [ divr16u::rem#5 divr16u::rem#10 divr16u::rem#4 divr16u::rem#11 divr16u::rem#6 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 ] : zp[2]:29 , 
Potential registers zp[2]:31 [ divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#1 divr16u::dividend#0 ] : zp[2]:31 , 
Potential registers zp[2]:33 [ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 ] : zp[2]:33 , 
Potential registers zp[1]:35 [ divr16u::i#2 divr16u::i#1 ] : zp[1]:35 , reg byte x , reg byte y , 
Potential registers zp[1]:36 [ main::$27 ] : zp[1]:36 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:37 [ main::$28 ] : zp[1]:37 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:38 [ main::$29 ] : zp[1]:38 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:39 [ print_byte::$0 ] : zp[1]:39 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:40 [ print_byte::$2 ] : zp[1]:40 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[2]:41 [ lin16u_gen::ampl#0 ] : zp[2]:41 , 
Potential registers zp[2]:43 [ divr16u::return#2 ] : zp[2]:43 , 
Potential registers zp[2]:45 [ lin16u_gen::stepi#0 ] : zp[2]:45 , 
Potential registers zp[2]:47 [ divr16u::return#3 ] : zp[2]:47 , 
Potential registers zp[2]:49 [ lin16u_gen::stepf#0 ] : zp[2]:49 , 
Potential registers zp[4]:51 [ lin16u_gen::step#0 ] : zp[4]:51 , 
Potential registers zp[2]:55 [ lin16u_gen::$6 ] : zp[2]:55 , 
Potential registers zp[1]:57 [ divr16u::$1 ] : zp[1]:57 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:58 [ divr16u::$2 ] : zp[1]:58 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[2]:59 [ rem16u#1 ] : zp[2]:59 , 

REGISTER UPLIFT SCOPES
Uplift Scope [] 227.22: zp[2]:3 [ print_line_cursor#11 print_line_cursor#21 print_line_cursor#1 ] 197.27: zp[2]:9 [ print_char_cursor#86 print_char_cursor#50 print_char_cursor#81 print_char_cursor#101 print_char_cursor#2 print_char_cursor#11 print_char_cursor#98 print_char_cursor#1 ] 0.8: zp[2]:59 [ rem16u#1 ] 
Uplift Scope [print_str] 305.5: zp[2]:11 [ print_str::str#10 print_str::str#12 print_str::str#0 ] 
Uplift Scope [divr16u] 106.92: zp[2]:29 [ divr16u::rem#5 divr16u::rem#10 divr16u::rem#4 divr16u::rem#11 divr16u::rem#6 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 ] 35.54: zp[2]:33 [ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 ] 22: zp[1]:57 [ divr16u::$1 ] 22: zp[1]:58 [ divr16u::$2 ] 18.19: zp[1]:35 [ divr16u::i#2 divr16u::i#1 ] 15.75: zp[2]:31 [ divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#1 divr16u::dividend#0 ] 4: zp[2]:43 [ divr16u::return#2 ] 4: zp[2]:47 [ divr16u::return#3 ] 1.38: zp[2]:27 [ divr16u::divisor#6 ] 
Uplift Scope [lin16u_gen] 27.5: zp[2]:19 [ lin16u_gen::i#2 lin16u_gen::i#1 ] 22: zp[2]:55 [ lin16u_gen::$6 ] 20.08: zp[4]:21 [ lin16u_gen::val#2 lin16u_gen::val#1 lin16u_gen::val#0 ] 18.17: zp[2]:25 [ lin16u_gen::lintab#4 lin16u_gen::lintab#3 lin16u_gen::lintab#6 ] 4: zp[2]:41 [ lin16u_gen::ampl#0 ] 4: zp[2]:49 [ lin16u_gen::stepf#0 ] 2: zp[2]:15 [ lin16u_gen::max#3 ] 1.44: zp[4]:51 [ lin16u_gen::step#0 ] 0.8: zp[2]:45 [ lin16u_gen::stepi#0 ] 0.36: zp[2]:17 [ lin16u_gen::min#3 ] 
Uplift Scope [main] 25.5: zp[1]:2 [ main::i#10 main::i#1 ] 22: zp[1]:36 [ main::$27 ] 22: zp[1]:37 [ main::$28 ] 22: zp[1]:38 [ main::$29 ] 
Uplift Scope [print_word] 78.33: zp[2]:5 [ print_word::w#10 print_word::w#3 print_word::w#4 print_word::w#5 ] 
Uplift Scope [memset] 36.67: zp[2]:13 [ memset::dst#2 memset::dst#1 ] 
Uplift Scope [print_byte] 23.75: zp[1]:7 [ print_byte::b#3 print_byte::b#2 print_byte::b#0 print_byte::b#1 ] 4: zp[1]:39 [ print_byte::$0 ] 4: zp[1]:40 [ print_byte::$2 ] 
Uplift Scope [print_char] 14: zp[1]:8 [ print_char::ch#2 print_char::ch#0 print_char::ch#1 ] 
Uplift Scope [RADIX] 
Uplift Scope [print_ln] 
Uplift Scope [print_cls] 

Uplifting [] best 16244 combination zp[2]:3 [ print_line_cursor#11 print_line_cursor#21 print_line_cursor#1 ] zp[2]:9 [ print_char_cursor#86 print_char_cursor#50 print_char_cursor#81 print_char_cursor#101 print_char_cursor#2 print_char_cursor#11 print_char_cursor#98 print_char_cursor#1 ] zp[2]:59 [ rem16u#1 ] 
Uplifting [print_str] best 16244 combination zp[2]:11 [ print_str::str#10 print_str::str#12 print_str::str#0 ] 
Uplifting [divr16u] best 16034 combination zp[2]:29 [ divr16u::rem#5 divr16u::rem#10 divr16u::rem#4 divr16u::rem#11 divr16u::rem#6 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 ] zp[2]:33 [ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 ] reg byte a [ divr16u::$1 ] reg byte a [ divr16u::$2 ] reg byte x [ divr16u::i#2 divr16u::i#1 ] zp[2]:31 [ divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#1 divr16u::dividend#0 ] zp[2]:43 [ divr16u::return#2 ] zp[2]:47 [ divr16u::return#3 ] zp[2]:27 [ divr16u::divisor#6 ] 
Uplifting [lin16u_gen] best 16034 combination zp[2]:19 [ lin16u_gen::i#2 lin16u_gen::i#1 ] zp[2]:55 [ lin16u_gen::$6 ] zp[4]:21 [ lin16u_gen::val#2 lin16u_gen::val#1 lin16u_gen::val#0 ] zp[2]:25 [ lin16u_gen::lintab#4 lin16u_gen::lintab#3 lin16u_gen::lintab#6 ] zp[2]:41 [ lin16u_gen::ampl#0 ] zp[2]:49 [ lin16u_gen::stepf#0 ] zp[2]:15 [ lin16u_gen::max#3 ] zp[4]:51 [ lin16u_gen::step#0 ] zp[2]:45 [ lin16u_gen::stepi#0 ] zp[2]:17 [ lin16u_gen::min#3 ] 
Uplifting [main] best 15764 combination reg byte x [ main::i#10 main::i#1 ] reg byte a [ main::$27 ] reg byte a [ main::$28 ] reg byte a [ main::$29 ] 
Limited combination testing to 100 combinations of 128 possible.
Uplifting [print_word] best 15764 combination zp[2]:5 [ print_word::w#10 print_word::w#3 print_word::w#4 print_word::w#5 ] 
Uplifting [memset] best 15764 combination zp[2]:13 [ memset::dst#2 memset::dst#1 ] 
Uplifting [print_byte] best 15756 combination zp[1]:7 [ print_byte::b#3 print_byte::b#2 print_byte::b#0 print_byte::b#1 ] reg byte a [ print_byte::$0 ] reg byte a [ print_byte::$2 ] 
Uplifting [print_char] best 15747 combination reg byte a [ print_char::ch#2 print_char::ch#0 print_char::ch#1 ] 
Uplifting [RADIX] best 15747 combination 
Uplifting [print_ln] best 15747 combination 
Uplifting [print_cls] best 15747 combination 
Attempting to uplift remaining variables inzp[1]:7 [ print_byte::b#3 print_byte::b#2 print_byte::b#0 print_byte::b#1 ]
Uplifting [print_byte] best 15747 combination zp[1]:7 [ print_byte::b#3 print_byte::b#2 print_byte::b#0 print_byte::b#1 ] 
Coalescing zero page register [ zp[2]:29 [ divr16u::rem#5 divr16u::rem#10 divr16u::rem#4 divr16u::rem#11 divr16u::rem#6 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 ] ] with [ zp[2]:59 [ rem16u#1 ] ] - score: 2
Coalescing zero page register [ zp[2]:15 [ lin16u_gen::max#3 ] ] with [ zp[2]:41 [ lin16u_gen::ampl#0 ] ] - score: 1
Coalescing zero page register [ zp[2]:33 [ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 ] ] with [ zp[2]:43 [ divr16u::return#2 ] ] - score: 1
Coalescing zero page register [ zp[2]:33 [ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 divr16u::return#2 ] ] with [ zp[2]:47 [ divr16u::return#3 ] ] - score: 1
Coalescing zero page register [ zp[2]:15 [ lin16u_gen::max#3 lin16u_gen::ampl#0 ] ] with [ zp[2]:31 [ divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#1 divr16u::dividend#0 ] ] - score: 1
Coalescing zero page register [ zp[2]:33 [ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 divr16u::return#2 divr16u::return#3 ] ] with [ zp[2]:49 [ lin16u_gen::stepf#0 ] ] - score: 1
Coalescing zero page register [ zp[2]:11 [ print_str::str#10 print_str::str#12 print_str::str#0 ] ] with [ zp[2]:5 [ print_word::w#10 print_word::w#3 print_word::w#4 print_word::w#5 ] ]
Coalescing zero page register [ zp[2]:13 [ memset::dst#2 memset::dst#1 ] ] with [ zp[2]:3 [ print_line_cursor#11 print_line_cursor#21 print_line_cursor#1 ] ]
Coalescing zero page register [ zp[2]:15 [ lin16u_gen::max#3 lin16u_gen::ampl#0 divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#1 divr16u::dividend#0 ] ] with [ zp[2]:9 [ print_char_cursor#86 print_char_cursor#50 print_char_cursor#81 print_char_cursor#101 print_char_cursor#2 print_char_cursor#11 print_char_cursor#98 print_char_cursor#1 ] ]
Coalescing zero page register [ zp[2]:27 [ divr16u::divisor#6 ] ] with [ zp[2]:19 [ lin16u_gen::i#2 lin16u_gen::i#1 ] ]
Coalescing zero page register [ zp[2]:55 [ lin16u_gen::$6 ] ] with [ zp[2]:29 [ divr16u::rem#5 divr16u::rem#10 divr16u::rem#4 divr16u::rem#11 divr16u::rem#6 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 rem16u#1 ] ]
Coalescing zero page register [ zp[2]:17 [ lin16u_gen::min#3 ] ] with [ zp[2]:11 [ print_str::str#10 print_str::str#12 print_str::str#0 print_word::w#10 print_word::w#3 print_word::w#4 print_word::w#5 ] ]
Coalescing zero page register [ zp[2]:25 [ lin16u_gen::lintab#4 lin16u_gen::lintab#3 lin16u_gen::lintab#6 ] ] with [ zp[2]:13 [ memset::dst#2 memset::dst#1 print_line_cursor#11 print_line_cursor#21 print_line_cursor#1 ] ]
Allocated (was zp[1]:7) zp[1]:2 [ print_byte::b#3 print_byte::b#2 print_byte::b#0 print_byte::b#1 ]
Allocated (was zp[2]:15) zp[2]:3 [ lin16u_gen::max#3 lin16u_gen::ampl#0 divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#1 divr16u::dividend#0 print_char_cursor#86 print_char_cursor#50 print_char_cursor#81 print_char_cursor#101 print_char_cursor#2 print_char_cursor#11 print_char_cursor#98 print_char_cursor#1 ]
Allocated (was zp[2]:17) zp[2]:5 [ lin16u_gen::min#3 print_str::str#10 print_str::str#12 print_str::str#0 print_word::w#10 print_word::w#3 print_word::w#4 print_word::w#5 ]
Allocated (was zp[4]:21) zp[4]:7 [ lin16u_gen::val#2 lin16u_gen::val#1 lin16u_gen::val#0 ]
Allocated (was zp[2]:25) zp[2]:11 [ lin16u_gen::lintab#4 lin16u_gen::lintab#3 lin16u_gen::lintab#6 memset::dst#2 memset::dst#1 print_line_cursor#11 print_line_cursor#21 print_line_cursor#1 ]
Allocated (was zp[2]:27) zp[2]:13 [ divr16u::divisor#6 lin16u_gen::i#2 lin16u_gen::i#1 ]
Allocated (was zp[2]:33) zp[2]:15 [ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 divr16u::return#2 divr16u::return#3 lin16u_gen::stepf#0 ]
Allocated (was zp[2]:45) zp[2]:17 [ lin16u_gen::stepi#0 ]
Allocated (was zp[4]:51) zp[4]:19 [ lin16u_gen::step#0 ]
Allocated (was zp[2]:55) zp[2]:23 [ lin16u_gen::$6 divr16u::rem#5 divr16u::rem#10 divr16u::rem#4 divr16u::rem#11 divr16u::rem#6 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 rem16u#1 ]

ASSEMBLER BEFORE OPTIMIZATION
  // File Comments
// Linear table generator
// Work in progress towards a sinus generator
  // Upstart
.pc = $801 "Basic"
:BasicUpstart(__bbegin)
.pc = $80d "Program"
  // Global Constants & labels
  .const SIZEOF_WORD = 2
  // Remainder after unsigned 16-bit division
  .label rem16u = $17
  .label print_char_cursor = 3
  .label print_line_cursor = $b
  // @begin
__bbegin:
  // [1] phi from @begin to @1 [phi:@begin->@1]
__b1_from___bbegin:
  jmp __b1
  // @1
__b1:
  // [2] call main 
  // [4] phi from @1 to main [phi:@1->main]
main_from___b1:
  jsr main
  // [3] phi from @1 to @end [phi:@1->@end]
__bend_from___b1:
  jmp __bend
  // @end
__bend:
  // main
main: {
    // [5] call lin16u_gen 
    // [103] phi from main to lin16u_gen [phi:main->lin16u_gen]
  lin16u_gen_from_main:
    // [103] phi (word*) lin16u_gen::lintab#6 = (const word*) main::lintab1 [phi:main->lin16u_gen#0] -- pwuz1=pwuc1 
    lda #<lintab1
    sta.z lin16u_gen.lintab
    lda #>lintab1
    sta.z lin16u_gen.lintab+1
    // [103] phi (word) lin16u_gen::min#3 = (word) $22d [phi:main->lin16u_gen#1] -- vwuz1=vwuc1 
    lda #<$22d
    sta.z lin16u_gen.min
    lda #>$22d
    sta.z lin16u_gen.min+1
    // [103] phi (word) lin16u_gen::max#3 = (word) $7461 [phi:main->lin16u_gen#2] -- vwuz1=vwuc1 
    lda #<$7461
    sta.z lin16u_gen.max
    lda #>$7461
    sta.z lin16u_gen.max+1
    jsr lin16u_gen
    // [6] phi from main to main::@4 [phi:main->main::@4]
  __b4_from_main:
    jmp __b4
    // main::@4
  __b4:
    // [7] call lin16u_gen 
    // [103] phi from main::@4 to lin16u_gen [phi:main::@4->lin16u_gen]
  lin16u_gen_from___b4:
    // [103] phi (word*) lin16u_gen::lintab#6 = (const word*) main::lintab2 [phi:main::@4->lin16u_gen#0] -- pwuz1=pwuc1 
    lda #<lintab2
    sta.z lin16u_gen.lintab
    lda #>lintab2
    sta.z lin16u_gen.lintab+1
    // [103] phi (word) lin16u_gen::min#3 = (word) $79cb [phi:main::@4->lin16u_gen#1] -- vwuz1=vwuc1 
    lda #<$79cb
    sta.z lin16u_gen.min
    lda #>$79cb
    sta.z lin16u_gen.min+1
    // [103] phi (word) lin16u_gen::max#3 = (word) $f781 [phi:main::@4->lin16u_gen#2] -- vwuz1=vwuc1 
    lda #<$f781
    sta.z lin16u_gen.max
    lda #>$f781
    sta.z lin16u_gen.max+1
    jsr lin16u_gen
    // [8] phi from main::@4 to main::@5 [phi:main::@4->main::@5]
  __b5_from___b4:
    jmp __b5
    // main::@5
  __b5:
    // [9] call lin16u_gen 
    // [103] phi from main::@5 to lin16u_gen [phi:main::@5->lin16u_gen]
  lin16u_gen_from___b5:
    // [103] phi (word*) lin16u_gen::lintab#6 = (const word*) main::lintab3 [phi:main::@5->lin16u_gen#0] -- pwuz1=pwuc1 
    lda #<lintab3
    sta.z lin16u_gen.lintab
    lda #>lintab3
    sta.z lin16u_gen.lintab+1
    // [103] phi (word) lin16u_gen::min#3 = (byte) 0 [phi:main::@5->lin16u_gen#1] -- vwuz1=vbuc1 
    lda #<0
    sta.z lin16u_gen.min
    lda #>0
    sta.z lin16u_gen.min+1
    // [103] phi (word) lin16u_gen::max#3 = (word) $6488 [phi:main::@5->lin16u_gen#2] -- vwuz1=vwuc1 
    lda #<$6488
    sta.z lin16u_gen.max
    lda #>$6488
    sta.z lin16u_gen.max+1
    jsr lin16u_gen
    // [10] phi from main::@5 to main::@6 [phi:main::@5->main::@6]
  __b6_from___b5:
    jmp __b6
    // main::@6
  __b6:
    // [11] call print_cls 
    // [94] phi from main::@6 to print_cls [phi:main::@6->print_cls]
  print_cls_from___b6:
    jsr print_cls
    // [12] phi from main::@6 to main::@7 [phi:main::@6->main::@7]
  __b7_from___b6:
    jmp __b7
    // main::@7
  __b7:
    // [13] call print_str 
    // [87] phi from main::@7 to print_str [phi:main::@7->print_str]
  print_str_from___b7:
    // [87] phi (byte*) print_char_cursor#86 = (byte*) 1024 [phi:main::@7->print_str#0] -- pbuz1=pbuc1 
    lda #<$400
    sta.z print_char_cursor
    lda #>$400
    sta.z print_char_cursor+1
    // [87] phi (byte*) print_str::str#12 = (const byte*) main::str [phi:main::@7->print_str#1] -- pbuz1=pbuc1 
    lda #<str
    sta.z print_str.str
    lda #>str
    sta.z print_str.str+1
    jsr print_str
    // [14] phi from main::@7 to main::@8 [phi:main::@7->main::@8]
  __b8_from___b7:
    jmp __b8
    // main::@8
  __b8:
    // [15] call print_word 
    // [69] phi from main::@8 to print_word [phi:main::@8->print_word]
  print_word_from___b8:
    // [69] phi (word) print_word::w#10 = (word) $22d [phi:main::@8->print_word#0] -- vwuz1=vwuc1 
    lda #<$22d
    sta.z print_word.w
    lda #>$22d
    sta.z print_word.w+1
    jsr print_word
    // [16] phi from main::@8 to main::@9 [phi:main::@8->main::@9]
  __b9_from___b8:
    jmp __b9
    // main::@9
  __b9:
    // [17] call print_str 
    // [87] phi from main::@9 to print_str [phi:main::@9->print_str]
  print_str_from___b9:
    // [87] phi (byte*) print_char_cursor#86 = (byte*) print_char_cursor#11 [phi:main::@9->print_str#0] -- register_copy 
    // [87] phi (byte*) print_str::str#12 = (const byte*) main::str1 [phi:main::@9->print_str#1] -- pbuz1=pbuc1 
    lda #<str1
    sta.z print_str.str
    lda #>str1
    sta.z print_str.str+1
    jsr print_str
    // [18] phi from main::@9 to main::@10 [phi:main::@9->main::@10]
  __b10_from___b9:
    jmp __b10
    // main::@10
  __b10:
    // [19] call print_word 
    // [69] phi from main::@10 to print_word [phi:main::@10->print_word]
  print_word_from___b10:
    // [69] phi (word) print_word::w#10 = (word) $79cb [phi:main::@10->print_word#0] -- vwuz1=vwuc1 
    lda #<$79cb
    sta.z print_word.w
    lda #>$79cb
    sta.z print_word.w+1
    jsr print_word
    // [20] phi from main::@10 to main::@11 [phi:main::@10->main::@11]
  __b11_from___b10:
    jmp __b11
    // main::@11
  __b11:
    // [21] call print_str 
    // [87] phi from main::@11 to print_str [phi:main::@11->print_str]
  print_str_from___b11:
    // [87] phi (byte*) print_char_cursor#86 = (byte*) print_char_cursor#11 [phi:main::@11->print_str#0] -- register_copy 
    // [87] phi (byte*) print_str::str#12 = (const byte*) main::str1 [phi:main::@11->print_str#1] -- pbuz1=pbuc1 
    lda #<str1
    sta.z print_str.str
    lda #>str1
    sta.z print_str.str+1
    jsr print_str
    // [22] phi from main::@11 to main::@12 [phi:main::@11->main::@12]
  __b12_from___b11:
    jmp __b12
    // main::@12
  __b12:
    // [23] call print_word 
    // [69] phi from main::@12 to print_word [phi:main::@12->print_word]
  print_word_from___b12:
    // [69] phi (word) print_word::w#10 = (byte) 0 [phi:main::@12->print_word#0] -- vwuz1=vbuc1 
    lda #<0
    sta.z print_word.w
    lda #>0
    sta.z print_word.w+1
    jsr print_word
    // [24] phi from main::@12 to main::@13 [phi:main::@12->main::@13]
  __b13_from___b12:
    jmp __b13
    // main::@13
  __b13:
    // [25] call print_ln 
    // [64] phi from main::@13 to print_ln [phi:main::@13->print_ln]
  print_ln_from___b13:
    // [64] phi (byte*) print_line_cursor#21 = (byte*) 1024 [phi:main::@13->print_ln#0] -- pbuz1=pbuc1 
    lda #<$400
    sta.z print_line_cursor
    lda #>$400
    sta.z print_line_cursor+1
    jsr print_ln
    // [26] phi from main::@13 to main::@1 [phi:main::@13->main::@1]
  __b1_from___b13:
    // [26] phi (byte) main::i#10 = (byte) 0 [phi:main::@13->main::@1#0] -- vbuxx=vbuc1 
    ldx #0
    jmp __b1
    // main::@1
  __b1:
    // [27] if((byte) main::i#10<(byte) $14) goto main::@2 -- vbuxx_lt_vbuc1_then_la1 
    cpx #$14
    bcc __b2
    jmp __b3
    // main::@3
  __b3:
    // [28] (byte*) print_char_cursor#98 ← (byte*) print_line_cursor#1 -- pbuz1=pbuz2 
    lda.z print_line_cursor
    sta.z print_char_cursor
    lda.z print_line_cursor+1
    sta.z print_char_cursor+1
    // [29] call print_str 
    // [87] phi from main::@3 to print_str [phi:main::@3->print_str]
  print_str_from___b3:
    // [87] phi (byte*) print_char_cursor#86 = (byte*) print_char_cursor#98 [phi:main::@3->print_str#0] -- register_copy 
    // [87] phi (byte*) print_str::str#12 = (const byte*) main::str [phi:main::@3->print_str#1] -- pbuz1=pbuc1 
    lda #<str
    sta.z print_str.str
    lda #>str
    sta.z print_str.str+1
    jsr print_str
    // [30] phi from main::@3 to main::@22 [phi:main::@3->main::@22]
  __b22_from___b3:
    jmp __b22
    // main::@22
  __b22:
    // [31] call print_word 
    // [69] phi from main::@22 to print_word [phi:main::@22->print_word]
  print_word_from___b22:
    // [69] phi (word) print_word::w#10 = (word) $7461 [phi:main::@22->print_word#0] -- vwuz1=vwuc1 
    lda #<$7461
    sta.z print_word.w
    lda #>$7461
    sta.z print_word.w+1
    jsr print_word
    // [32] phi from main::@22 to main::@23 [phi:main::@22->main::@23]
  __b23_from___b22:
    jmp __b23
    // main::@23
  __b23:
    // [33] call print_str 
    // [87] phi from main::@23 to print_str [phi:main::@23->print_str]
  print_str_from___b23:
    // [87] phi (byte*) print_char_cursor#86 = (byte*) print_char_cursor#11 [phi:main::@23->print_str#0] -- register_copy 
    // [87] phi (byte*) print_str::str#12 = (const byte*) main::str1 [phi:main::@23->print_str#1] -- pbuz1=pbuc1 
    lda #<str1
    sta.z print_str.str
    lda #>str1
    sta.z print_str.str+1
    jsr print_str
    // [34] phi from main::@23 to main::@24 [phi:main::@23->main::@24]
  __b24_from___b23:
    jmp __b24
    // main::@24
  __b24:
    // [35] call print_word 
    // [69] phi from main::@24 to print_word [phi:main::@24->print_word]
  print_word_from___b24:
    // [69] phi (word) print_word::w#10 = (word) $f781 [phi:main::@24->print_word#0] -- vwuz1=vwuc1 
    lda #<$f781
    sta.z print_word.w
    lda #>$f781
    sta.z print_word.w+1
    jsr print_word
    // [36] phi from main::@24 to main::@25 [phi:main::@24->main::@25]
  __b25_from___b24:
    jmp __b25
    // main::@25
  __b25:
    // [37] call print_str 
    // [87] phi from main::@25 to print_str [phi:main::@25->print_str]
  print_str_from___b25:
    // [87] phi (byte*) print_char_cursor#86 = (byte*) print_char_cursor#11 [phi:main::@25->print_str#0] -- register_copy 
    // [87] phi (byte*) print_str::str#12 = (const byte*) main::str1 [phi:main::@25->print_str#1] -- pbuz1=pbuc1 
    lda #<str1
    sta.z print_str.str
    lda #>str1
    sta.z print_str.str+1
    jsr print_str
    // [38] phi from main::@25 to main::@26 [phi:main::@25->main::@26]
  __b26_from___b25:
    jmp __b26
    // main::@26
  __b26:
    // [39] call print_word 
    // [69] phi from main::@26 to print_word [phi:main::@26->print_word]
  print_word_from___b26:
    // [69] phi (word) print_word::w#10 = (word) $6488 [phi:main::@26->print_word#0] -- vwuz1=vwuc1 
    lda #<$6488
    sta.z print_word.w
    lda #>$6488
    sta.z print_word.w+1
    jsr print_word
    // [40] phi from main::@26 to main::@27 [phi:main::@26->main::@27]
  __b27_from___b26:
    jmp __b27
    // main::@27
  __b27:
    // [41] call print_ln 
    // [64] phi from main::@27 to print_ln [phi:main::@27->print_ln]
  print_ln_from___b27:
    // [64] phi (byte*) print_line_cursor#21 = (byte*) print_line_cursor#1 [phi:main::@27->print_ln#0] -- register_copy 
    jsr print_ln
    jmp __breturn
    // main::@return
  __breturn:
    // [42] return 
    rts
    // main::@2
  __b2:
    // [43] (byte) print_byte::b#2 ← (byte) main::i#10 -- vbuz1=vbuxx 
    stx.z print_byte.b
    // [44] (byte*) print_char_cursor#101 ← (byte*) print_line_cursor#1 -- pbuz1=pbuz2 
    lda.z print_line_cursor
    sta.z print_char_cursor
    lda.z print_line_cursor+1
    sta.z print_char_cursor+1
    // [45] call print_byte 
    // [75] phi from main::@2 to print_byte [phi:main::@2->print_byte]
  print_byte_from___b2:
    // [75] phi (byte*) print_char_cursor#81 = (byte*) print_char_cursor#101 [phi:main::@2->print_byte#0] -- register_copy 
    // [75] phi (byte) print_byte::b#3 = (byte) print_byte::b#2 [phi:main::@2->print_byte#1] -- register_copy 
    jsr print_byte
    // [46] phi from main::@2 to main::@14 [phi:main::@2->main::@14]
  __b14_from___b2:
    jmp __b14
    // main::@14
  __b14:
    // [47] call print_str 
    // [87] phi from main::@14 to print_str [phi:main::@14->print_str]
  print_str_from___b14:
    // [87] phi (byte*) print_char_cursor#86 = (byte*) print_char_cursor#11 [phi:main::@14->print_str#0] -- register_copy 
    // [87] phi (byte*) print_str::str#12 = (const byte*) main::str1 [phi:main::@14->print_str#1] -- pbuz1=pbuc1 
    lda #<str1
    sta.z print_str.str
    lda #>str1
    sta.z print_str.str+1
    jsr print_str
    jmp __b15
    // main::@15
  __b15:
    // [48] (byte~) main::$27 ← (byte) main::i#10 << (byte) 1 -- vbuaa=vbuxx_rol_1 
    txa
    asl
    // [49] (word) print_word::w#3 ← *((const word*) main::lintab1 + (byte~) main::$27) -- vwuz1=pwuc1_derefidx_vbuaa 
    tay
    lda lintab1,y
    sta.z print_word.w
    lda lintab1+1,y
    sta.z print_word.w+1
    // [50] call print_word 
    // [69] phi from main::@15 to print_word [phi:main::@15->print_word]
  print_word_from___b15:
    // [69] phi (word) print_word::w#10 = (word) print_word::w#3 [phi:main::@15->print_word#0] -- register_copy 
    jsr print_word
    // [51] phi from main::@15 to main::@16 [phi:main::@15->main::@16]
  __b16_from___b15:
    jmp __b16
    // main::@16
  __b16:
    // [52] call print_str 
    // [87] phi from main::@16 to print_str [phi:main::@16->print_str]
  print_str_from___b16:
    // [87] phi (byte*) print_char_cursor#86 = (byte*) print_char_cursor#11 [phi:main::@16->print_str#0] -- register_copy 
    // [87] phi (byte*) print_str::str#12 = (const byte*) main::str1 [phi:main::@16->print_str#1] -- pbuz1=pbuc1 
    lda #<str1
    sta.z print_str.str
    lda #>str1
    sta.z print_str.str+1
    jsr print_str
    jmp __b17
    // main::@17
  __b17:
    // [53] (byte~) main::$28 ← (byte) main::i#10 << (byte) 1 -- vbuaa=vbuxx_rol_1 
    txa
    asl
    // [54] (word) print_word::w#4 ← *((const word*) main::lintab2 + (byte~) main::$28) -- vwuz1=pwuc1_derefidx_vbuaa 
    tay
    lda lintab2,y
    sta.z print_word.w
    lda lintab2+1,y
    sta.z print_word.w+1
    // [55] call print_word 
    // [69] phi from main::@17 to print_word [phi:main::@17->print_word]
  print_word_from___b17:
    // [69] phi (word) print_word::w#10 = (word) print_word::w#4 [phi:main::@17->print_word#0] -- register_copy 
    jsr print_word
    // [56] phi from main::@17 to main::@18 [phi:main::@17->main::@18]
  __b18_from___b17:
    jmp __b18
    // main::@18
  __b18:
    // [57] call print_str 
    // [87] phi from main::@18 to print_str [phi:main::@18->print_str]
  print_str_from___b18:
    // [87] phi (byte*) print_char_cursor#86 = (byte*) print_char_cursor#11 [phi:main::@18->print_str#0] -- register_copy 
    // [87] phi (byte*) print_str::str#12 = (const byte*) main::str1 [phi:main::@18->print_str#1] -- pbuz1=pbuc1 
    lda #<str1
    sta.z print_str.str
    lda #>str1
    sta.z print_str.str+1
    jsr print_str
    jmp __b19
    // main::@19
  __b19:
    // [58] (byte~) main::$29 ← (byte) main::i#10 << (byte) 1 -- vbuaa=vbuxx_rol_1 
    txa
    asl
    // [59] (word) print_word::w#5 ← *((const word*) main::lintab3 + (byte~) main::$29) -- vwuz1=pwuc1_derefidx_vbuaa 
    tay
    lda lintab3,y
    sta.z print_word.w
    lda lintab3+1,y
    sta.z print_word.w+1
    // [60] call print_word 
    // [69] phi from main::@19 to print_word [phi:main::@19->print_word]
  print_word_from___b19:
    // [69] phi (word) print_word::w#10 = (word) print_word::w#5 [phi:main::@19->print_word#0] -- register_copy 
    jsr print_word
    // [61] phi from main::@19 to main::@20 [phi:main::@19->main::@20]
  __b20_from___b19:
    jmp __b20
    // main::@20
  __b20:
    // [62] call print_ln 
    // [64] phi from main::@20 to print_ln [phi:main::@20->print_ln]
  print_ln_from___b20:
    // [64] phi (byte*) print_line_cursor#21 = (byte*) print_line_cursor#1 [phi:main::@20->print_ln#0] -- register_copy 
    jsr print_ln
    jmp __b21
    // main::@21
  __b21:
    // [63] (byte) main::i#1 ← ++ (byte) main::i#10 -- vbuxx=_inc_vbuxx 
    inx
    // [26] phi from main::@21 to main::@1 [phi:main::@21->main::@1]
  __b1_from___b21:
    // [26] phi (byte) main::i#10 = (byte) main::i#1 [phi:main::@21->main::@1#0] -- register_copy 
    jmp __b1
    lintab1: .fill 2*$14, 0
    lintab2: .fill 2*$14, 0
    lintab3: .fill 2*$14, 0
    str: .text "   "
    .byte 0
    str1: .text " "
    .byte 0
}
  // print_ln
// Print a newline
print_ln: {
    // [65] phi from print_ln print_ln::@1 to print_ln::@1 [phi:print_ln/print_ln::@1->print_ln::@1]
  __b1_from_print_ln:
  __b1_from___b1:
    // [65] phi (byte*) print_line_cursor#11 = (byte*) print_line_cursor#21 [phi:print_ln/print_ln::@1->print_ln::@1#0] -- register_copy 
    jmp __b1
    // print_ln::@1
  __b1:
    // [66] (byte*) print_line_cursor#1 ← (byte*) print_line_cursor#11 + (byte) $28 -- pbuz1=pbuz1_plus_vbuc1 
    lda #$28
    clc
    adc.z print_line_cursor
    sta.z print_line_cursor
    bcc !+
    inc.z print_line_cursor+1
  !:
    // [67] if((byte*) print_line_cursor#1<(byte*) print_char_cursor#11) goto print_ln::@1 -- pbuz1_lt_pbuz2_then_la1 
    lda.z print_line_cursor+1
    cmp.z print_char_cursor+1
    bcc __b1_from___b1
    bne !+
    lda.z print_line_cursor
    cmp.z print_char_cursor
    bcc __b1_from___b1
  !:
    jmp __breturn
    // print_ln::@return
  __breturn:
    // [68] return 
    rts
}
  // print_word
// Print a word as HEX
// print_word(word zp(5) w)
print_word: {
    .label w = 5
    // [70] (byte) print_byte::b#0 ← > (word) print_word::w#10 -- vbuz1=_hi_vwuz2 
    lda.z w+1
    sta.z print_byte.b
    // [71] call print_byte 
    // [75] phi from print_word to print_byte [phi:print_word->print_byte]
  print_byte_from_print_word:
    // [75] phi (byte*) print_char_cursor#81 = (byte*) print_char_cursor#2 [phi:print_word->print_byte#0] -- register_copy 
    // [75] phi (byte) print_byte::b#3 = (byte) print_byte::b#0 [phi:print_word->print_byte#1] -- register_copy 
    jsr print_byte
    jmp __b1
    // print_word::@1
  __b1:
    // [72] (byte) print_byte::b#1 ← < (word) print_word::w#10 -- vbuz1=_lo_vwuz2 
    lda.z w
    sta.z print_byte.b
    // [73] call print_byte 
    // [75] phi from print_word::@1 to print_byte [phi:print_word::@1->print_byte]
  print_byte_from___b1:
    // [75] phi (byte*) print_char_cursor#81 = (byte*) print_char_cursor#11 [phi:print_word::@1->print_byte#0] -- register_copy 
    // [75] phi (byte) print_byte::b#3 = (byte) print_byte::b#1 [phi:print_word::@1->print_byte#1] -- register_copy 
    jsr print_byte
    jmp __breturn
    // print_word::@return
  __breturn:
    // [74] return 
    rts
}
  // print_byte
// Print a byte as HEX
// print_byte(byte zp(2) b)
print_byte: {
    .label b = 2
    // [76] (byte~) print_byte::$0 ← (byte) print_byte::b#3 >> (byte) 4 -- vbuaa=vbuz1_ror_4 
    lda.z b
    lsr
    lsr
    lsr
    lsr
    // [77] (byte) print_char::ch#0 ← *((const byte*) print_hextab + (byte~) print_byte::$0) -- vbuaa=pbuc1_derefidx_vbuaa 
    tay
    lda print_hextab,y
    // [78] call print_char 
    // [83] phi from print_byte to print_char [phi:print_byte->print_char]
  print_char_from_print_byte:
    // [83] phi (byte*) print_char_cursor#50 = (byte*) print_char_cursor#81 [phi:print_byte->print_char#0] -- register_copy 
    // [83] phi (byte) print_char::ch#2 = (byte) print_char::ch#0 [phi:print_byte->print_char#1] -- register_copy 
    jsr print_char
    jmp __b1
    // print_byte::@1
  __b1:
    // [79] (byte~) print_byte::$2 ← (byte) print_byte::b#3 & (byte) $f -- vbuaa=vbuz1_band_vbuc1 
    lda #$f
    and.z b
    // [80] (byte) print_char::ch#1 ← *((const byte*) print_hextab + (byte~) print_byte::$2) -- vbuaa=pbuc1_derefidx_vbuaa 
    tay
    lda print_hextab,y
    // [81] call print_char 
    // [83] phi from print_byte::@1 to print_char [phi:print_byte::@1->print_char]
  print_char_from___b1:
    // [83] phi (byte*) print_char_cursor#50 = (byte*) print_char_cursor#11 [phi:print_byte::@1->print_char#0] -- register_copy 
    // [83] phi (byte) print_char::ch#2 = (byte) print_char::ch#1 [phi:print_byte::@1->print_char#1] -- register_copy 
    jsr print_char
    jmp __breturn
    // print_byte::@return
  __breturn:
    // [82] return 
    rts
}
  // print_char
// Print a single char
// print_char(byte register(A) ch)
print_char: {
    // [84] *((byte*) print_char_cursor#50) ← (byte) print_char::ch#2 -- _deref_pbuz1=vbuaa 
    ldy #0
    sta (print_char_cursor),y
    // [85] (byte*) print_char_cursor#11 ← ++ (byte*) print_char_cursor#50 -- pbuz1=_inc_pbuz1 
    inc.z print_char_cursor
    bne !+
    inc.z print_char_cursor+1
  !:
    jmp __breturn
    // print_char::@return
  __breturn:
    // [86] return 
    rts
}
  // print_str
// Print a zero-terminated string
// print_str(byte* zp(5) str)
print_str: {
    .label str = 5
    // [88] phi from print_str print_str::@2 to print_str::@1 [phi:print_str/print_str::@2->print_str::@1]
  __b1_from_print_str:
  __b1_from___b2:
    // [88] phi (byte*) print_char_cursor#2 = (byte*) print_char_cursor#86 [phi:print_str/print_str::@2->print_str::@1#0] -- register_copy 
    // [88] phi (byte*) print_str::str#10 = (byte*) print_str::str#12 [phi:print_str/print_str::@2->print_str::@1#1] -- register_copy 
    jmp __b1
    // print_str::@1
  __b1:
    // [89] if((byte) 0!=*((byte*) print_str::str#10)) goto print_str::@2 -- vbuc1_neq__deref_pbuz1_then_la1 
    ldy #0
    lda (str),y
    cmp #0
    bne __b2
    jmp __breturn
    // print_str::@return
  __breturn:
    // [90] return 
    rts
    // print_str::@2
  __b2:
    // [91] *((byte*) print_char_cursor#2) ← *((byte*) print_str::str#10) -- _deref_pbuz1=_deref_pbuz2 
    ldy #0
    lda (str),y
    ldy #0
    sta (print_char_cursor),y
    // [92] (byte*) print_char_cursor#1 ← ++ (byte*) print_char_cursor#2 -- pbuz1=_inc_pbuz1 
    inc.z print_char_cursor
    bne !+
    inc.z print_char_cursor+1
  !:
    // [93] (byte*) print_str::str#0 ← ++ (byte*) print_str::str#10 -- pbuz1=_inc_pbuz1 
    inc.z str
    bne !+
    inc.z str+1
  !:
    jmp __b1_from___b2
}
  // print_cls
// Clear the screen. Also resets current line/char cursor.
print_cls: {
    // [95] call memset 
    // [97] phi from print_cls to memset [phi:print_cls->memset]
  memset_from_print_cls:
    jsr memset
    jmp __breturn
    // print_cls::@return
  __breturn:
    // [96] return 
    rts
}
  // memset
// Copies the character c (an unsigned char) to the first num characters of the object pointed to by the argument str.
memset: {
    .const c = ' '
    .const num = $3e8
    .label str = $400
    .label end = str+num
    .label dst = $b
    // [98] phi from memset to memset::@1 [phi:memset->memset::@1]
  __b1_from_memset:
    // [98] phi (byte*) memset::dst#2 = (byte*)(const void*) memset::str#0 [phi:memset->memset::@1#0] -- pbuz1=pbuc1 
    lda #<str
    sta.z dst
    lda #>str
    sta.z dst+1
    jmp __b1
    // memset::@1
  __b1:
    // [99] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 -- pbuz1_neq_pbuc1_then_la1 
    lda.z dst+1
    cmp #>end
    bne __b2
    lda.z dst
    cmp #<end
    bne __b2
    jmp __breturn
    // memset::@return
  __breturn:
    // [100] return 
    rts
    // memset::@2
  __b2:
    // [101] *((byte*) memset::dst#2) ← (const byte) memset::c#0 -- _deref_pbuz1=vbuc1 
    lda #c
    ldy #0
    sta (dst),y
    // [102] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2 -- pbuz1=_inc_pbuz1 
    inc.z dst
    bne !+
    inc.z dst+1
  !:
    // [98] phi from memset::@2 to memset::@1 [phi:memset::@2->memset::@1]
  __b1_from___b2:
    // [98] phi (byte*) memset::dst#2 = (byte*) memset::dst#1 [phi:memset::@2->memset::@1#0] -- register_copy 
    jmp __b1
}
  // lin16u_gen
// Generate word linear table
// lintab - the table to generate into
// length - the number of points in a total sinus wavelength (the size of the table)
// lin16u_gen(word zp(5) min, word zp(3) max, word* zp($b) lintab)
lin16u_gen: {
    .label __6 = $17
    .label ampl = 3
    .label stepi = $11
    .label stepf = $f
    .label step = $13
    .label val = 7
    .label lintab = $b
    .label i = $d
    .label max = 3
    .label min = 5
    // [104] (word) lin16u_gen::ampl#0 ← (word) lin16u_gen::max#3 - (word) lin16u_gen::min#3 -- vwuz1=vwuz1_minus_vwuz2 
    lda.z ampl
    sec
    sbc.z min
    sta.z ampl
    lda.z ampl+1
    sbc.z min+1
    sta.z ampl+1
    // [105] (word) divr16u::dividend#1 ← (word) lin16u_gen::ampl#0
    // [106] call divr16u 
    // [123] phi from lin16u_gen to divr16u [phi:lin16u_gen->divr16u]
  divr16u_from_lin16u_gen:
    // [123] phi (word) divr16u::divisor#6 = (byte) $14-(byte) 1 [phi:lin16u_gen->divr16u#0] -- vwuz1=vbuc1 
    lda #<$14-1
    sta.z divr16u.divisor
    lda #>$14-1
    sta.z divr16u.divisor+1
    // [123] phi (word) divr16u::dividend#5 = (word) divr16u::dividend#1 [phi:lin16u_gen->divr16u#1] -- register_copy 
    // [123] phi (word) divr16u::rem#10 = (byte) 0 [phi:lin16u_gen->divr16u#2] -- vwuz1=vbuc1 
    lda #<0
    sta.z divr16u.rem
    lda #>0
    sta.z divr16u.rem+1
    jsr divr16u
    // [107] (word) divr16u::return#2 ← (word) divr16u::return#0
    jmp __b3
    // lin16u_gen::@3
  __b3:
    // [108] (word) lin16u_gen::stepi#0 ← (word) divr16u::return#2 -- vwuz1=vwuz2 
    lda.z divr16u.return
    sta.z stepi
    lda.z divr16u.return+1
    sta.z stepi+1
    // [109] (word) divr16u::rem#4 ← (word) rem16u#1
    // [110] call divr16u 
    // [123] phi from lin16u_gen::@3 to divr16u [phi:lin16u_gen::@3->divr16u]
  divr16u_from___b3:
    // [123] phi (word) divr16u::divisor#6 = (byte) $14-(byte) 1 [phi:lin16u_gen::@3->divr16u#0] -- vwuz1=vbuc1 
    lda #<$14-1
    sta.z divr16u.divisor
    lda #>$14-1
    sta.z divr16u.divisor+1
    // [123] phi (word) divr16u::dividend#5 = (byte) 0 [phi:lin16u_gen::@3->divr16u#1] -- vwuz1=vbuc1 
    lda #<0
    sta.z divr16u.dividend
    lda #>0
    sta.z divr16u.dividend+1
    // [123] phi (word) divr16u::rem#10 = (word) divr16u::rem#4 [phi:lin16u_gen::@3->divr16u#2] -- register_copy 
    jsr divr16u
    // [111] (word) divr16u::return#3 ← (word) divr16u::return#0
    jmp __b4
    // lin16u_gen::@4
  __b4:
    // [112] (word) lin16u_gen::stepf#0 ← (word) divr16u::return#3
    // [113] (dword) lin16u_gen::step#0 ← (word) lin16u_gen::stepi#0 dw= (word) lin16u_gen::stepf#0 -- vduz1=vwuz2_dword_vwuz3 
    lda.z stepi
    sta.z step+2
    lda.z stepi+1
    sta.z step+3
    lda.z stepf
    sta.z step
    lda.z stepf+1
    sta.z step+1
    // [114] (dword) lin16u_gen::val#0 ← (word) lin16u_gen::min#3 dw= (word) 0 -- vduz1=vwuz2_dword_vwuc1 
    lda #<0
    sta.z val
    lda #>0
    sta.z val+1
    lda.z min
    sta.z val+2
    lda.z min+1
    sta.z val+3
    // [115] phi from lin16u_gen::@4 to lin16u_gen::@1 [phi:lin16u_gen::@4->lin16u_gen::@1]
  __b1_from___b4:
    // [115] phi (word*) lin16u_gen::lintab#4 = (word*) lin16u_gen::lintab#6 [phi:lin16u_gen::@4->lin16u_gen::@1#0] -- register_copy 
    // [115] phi (dword) lin16u_gen::val#2 = (dword) lin16u_gen::val#0 [phi:lin16u_gen::@4->lin16u_gen::@1#1] -- register_copy 
    // [115] phi (word) lin16u_gen::i#2 = (word) 0 [phi:lin16u_gen::@4->lin16u_gen::@1#2] -- vwuz1=vwuc1 
    lda #<0
    sta.z i
    lda #>0
    sta.z i+1
    jmp __b1
    // lin16u_gen::@1
  __b1:
    // [116] if((word) lin16u_gen::i#2<(byte) $14) goto lin16u_gen::@2 -- vwuz1_lt_vbuc1_then_la1 
    lda.z i+1
    cmp #>$14
    bcc __b2
    bne !+
    lda.z i
    cmp #<$14
    bcc __b2
  !:
    jmp __breturn
    // lin16u_gen::@return
  __breturn:
    // [117] return 
    rts
    // lin16u_gen::@2
  __b2:
    // [118] (word~) lin16u_gen::$6 ← > (dword) lin16u_gen::val#2 -- vwuz1=_hi_vduz2 
    lda.z val+2
    sta.z __6
    lda.z val+3
    sta.z __6+1
    // [119] *((word*) lin16u_gen::lintab#4) ← (word~) lin16u_gen::$6 -- _deref_pwuz1=vwuz2 
    ldy #0
    lda.z __6
    sta (lintab),y
    iny
    lda.z __6+1
    sta (lintab),y
    // [120] (dword) lin16u_gen::val#1 ← (dword) lin16u_gen::val#2 + (dword) lin16u_gen::step#0 -- vduz1=vduz1_plus_vduz2 
    lda.z val
    clc
    adc.z step
    sta.z val
    lda.z val+1
    adc.z step+1
    sta.z val+1
    lda.z val+2
    adc.z step+2
    sta.z val+2
    lda.z val+3
    adc.z step+3
    sta.z val+3
    // [121] (word*) lin16u_gen::lintab#3 ← (word*) lin16u_gen::lintab#4 + (const byte) SIZEOF_WORD -- pwuz1=pwuz1_plus_vbuc1 
    lda #SIZEOF_WORD
    clc
    adc.z lintab
    sta.z lintab
    bcc !+
    inc.z lintab+1
  !:
    // [122] (word) lin16u_gen::i#1 ← ++ (word) lin16u_gen::i#2 -- vwuz1=_inc_vwuz1 
    inc.z i
    bne !+
    inc.z i+1
  !:
    // [115] phi from lin16u_gen::@2 to lin16u_gen::@1 [phi:lin16u_gen::@2->lin16u_gen::@1]
  __b1_from___b2:
    // [115] phi (word*) lin16u_gen::lintab#4 = (word*) lin16u_gen::lintab#3 [phi:lin16u_gen::@2->lin16u_gen::@1#0] -- register_copy 
    // [115] phi (dword) lin16u_gen::val#2 = (dword) lin16u_gen::val#1 [phi:lin16u_gen::@2->lin16u_gen::@1#1] -- register_copy 
    // [115] phi (word) lin16u_gen::i#2 = (word) lin16u_gen::i#1 [phi:lin16u_gen::@2->lin16u_gen::@1#2] -- register_copy 
    jmp __b1
}
  // divr16u
// Performs division on two 16 bit unsigned words and an initial remainder
// Returns the quotient dividend/divisor.
// The final remainder will be set into the global variable rem16u
// Implemented using simple binary division
// divr16u(word zp(3) dividend, word zp($d) divisor, word zp($17) rem)
divr16u: {
    .label rem = $17
    .label dividend = 3
    .label quotient = $f
    .label return = $f
    .label divisor = $d
    // [124] phi from divr16u to divr16u::@1 [phi:divr16u->divr16u::@1]
  __b1_from_divr16u:
    // [124] phi (byte) divr16u::i#2 = (byte) 0 [phi:divr16u->divr16u::@1#0] -- vbuxx=vbuc1 
    ldx #0
    // [124] phi (word) divr16u::quotient#3 = (word) 0 [phi:divr16u->divr16u::@1#1] -- vwuz1=vwuc1 
    lda #<0
    sta.z quotient
    lda #>0
    sta.z quotient+1
    // [124] phi (word) divr16u::dividend#3 = (word) divr16u::dividend#5 [phi:divr16u->divr16u::@1#2] -- register_copy 
    // [124] phi (word) divr16u::rem#5 = (word) divr16u::rem#10 [phi:divr16u->divr16u::@1#3] -- register_copy 
    jmp __b1
    // [124] phi from divr16u::@3 to divr16u::@1 [phi:divr16u::@3->divr16u::@1]
  __b1_from___b3:
    // [124] phi (byte) divr16u::i#2 = (byte) divr16u::i#1 [phi:divr16u::@3->divr16u::@1#0] -- register_copy 
    // [124] phi (word) divr16u::quotient#3 = (word) divr16u::return#0 [phi:divr16u::@3->divr16u::@1#1] -- register_copy 
    // [124] phi (word) divr16u::dividend#3 = (word) divr16u::dividend#0 [phi:divr16u::@3->divr16u::@1#2] -- register_copy 
    // [124] phi (word) divr16u::rem#5 = (word) divr16u::rem#11 [phi:divr16u::@3->divr16u::@1#3] -- register_copy 
    jmp __b1
    // divr16u::@1
  __b1:
    // [125] (word) divr16u::rem#0 ← (word) divr16u::rem#5 << (byte) 1 -- vwuz1=vwuz1_rol_1 
    asl.z rem
    rol.z rem+1
    // [126] (byte~) divr16u::$1 ← > (word) divr16u::dividend#3 -- vbuaa=_hi_vwuz1 
    lda.z dividend+1
    // [127] (byte~) divr16u::$2 ← (byte~) divr16u::$1 & (byte) $80 -- vbuaa=vbuaa_band_vbuc1 
    and #$80
    // [128] if((byte~) divr16u::$2==(byte) 0) goto divr16u::@2 -- vbuaa_eq_0_then_la1 
    cmp #0
    beq __b2_from___b1
    jmp __b4
    // divr16u::@4
  __b4:
    // [129] (word) divr16u::rem#1 ← (word) divr16u::rem#0 | (byte) 1 -- vwuz1=vwuz1_bor_vbuc1 
    lda #1
    ora.z rem
    sta.z rem
    // [130] phi from divr16u::@1 divr16u::@4 to divr16u::@2 [phi:divr16u::@1/divr16u::@4->divr16u::@2]
  __b2_from___b1:
  __b2_from___b4:
    // [130] phi (word) divr16u::rem#6 = (word) divr16u::rem#0 [phi:divr16u::@1/divr16u::@4->divr16u::@2#0] -- register_copy 
    jmp __b2
    // divr16u::@2
  __b2:
    // [131] (word) divr16u::dividend#0 ← (word) divr16u::dividend#3 << (byte) 1 -- vwuz1=vwuz1_rol_1 
    asl.z dividend
    rol.z dividend+1
    // [132] (word) divr16u::quotient#1 ← (word) divr16u::quotient#3 << (byte) 1 -- vwuz1=vwuz1_rol_1 
    asl.z quotient
    rol.z quotient+1
    // [133] if((word) divr16u::rem#6<(word) divr16u::divisor#6) goto divr16u::@3 -- vwuz1_lt_vwuz2_then_la1 
    lda.z rem+1
    cmp.z divisor+1
    bcc __b3_from___b2
    bne !+
    lda.z rem
    cmp.z divisor
    bcc __b3_from___b2
  !:
    jmp __b5
    // divr16u::@5
  __b5:
    // [134] (word) divr16u::quotient#2 ← ++ (word) divr16u::quotient#1 -- vwuz1=_inc_vwuz1 
    inc.z quotient
    bne !+
    inc.z quotient+1
  !:
    // [135] (word) divr16u::rem#2 ← (word) divr16u::rem#6 - (word) divr16u::divisor#6 -- vwuz1=vwuz1_minus_vwuz2 
    lda.z rem
    sec
    sbc.z divisor
    sta.z rem
    lda.z rem+1
    sbc.z divisor+1
    sta.z rem+1
    // [136] phi from divr16u::@2 divr16u::@5 to divr16u::@3 [phi:divr16u::@2/divr16u::@5->divr16u::@3]
  __b3_from___b2:
  __b3_from___b5:
    // [136] phi (word) divr16u::return#0 = (word) divr16u::quotient#1 [phi:divr16u::@2/divr16u::@5->divr16u::@3#0] -- register_copy 
    // [136] phi (word) divr16u::rem#11 = (word) divr16u::rem#6 [phi:divr16u::@2/divr16u::@5->divr16u::@3#1] -- register_copy 
    jmp __b3
    // divr16u::@3
  __b3:
    // [137] (byte) divr16u::i#1 ← ++ (byte) divr16u::i#2 -- vbuxx=_inc_vbuxx 
    inx
    // [138] if((byte) divr16u::i#1!=(byte) $10) goto divr16u::@1 -- vbuxx_neq_vbuc1_then_la1 
    cpx #$10
    bne __b1_from___b3
    jmp __b6
    // divr16u::@6
  __b6:
    // [139] (word) rem16u#1 ← (word) divr16u::rem#11
    jmp __breturn
    // divr16u::@return
  __breturn:
    // [140] return 
    rts
}
  // File Data
  print_hextab: .text "0123456789abcdef"

ASSEMBLER OPTIMIZATIONS
Removing instruction jmp __b1
Removing instruction jmp __bend
Removing instruction jmp __b4
Removing instruction jmp __b5
Removing instruction jmp __b6
Removing instruction jmp __b7
Removing instruction jmp __b8
Removing instruction jmp __b9
Removing instruction jmp __b10
Removing instruction jmp __b11
Removing instruction jmp __b12
Removing instruction jmp __b13
Removing instruction jmp __b1
Removing instruction jmp __b3
Removing instruction jmp __b22
Removing instruction jmp __b23
Removing instruction jmp __b24
Removing instruction jmp __b25
Removing instruction jmp __b26
Removing instruction jmp __b27
Removing instruction jmp __breturn
Removing instruction jmp __b14
Removing instruction jmp __b15
Removing instruction jmp __b16
Removing instruction jmp __b17
Removing instruction jmp __b18
Removing instruction jmp __b19
Removing instruction jmp __b20
Removing instruction jmp __b21
Removing instruction jmp __b1
Removing instruction jmp __breturn
Removing instruction jmp __b1
Removing instruction jmp __breturn
Removing instruction jmp __b1
Removing instruction jmp __breturn
Removing instruction jmp __breturn
Removing instruction jmp __b1
Removing instruction jmp __breturn
Removing instruction jmp __breturn
Removing instruction jmp __b1
Removing instruction jmp __breturn
Removing instruction jmp __b3
Removing instruction jmp __b4
Removing instruction jmp __b1
Removing instruction jmp __breturn
Removing instruction jmp __b1
Removing instruction jmp __b4
Removing instruction jmp __b2
Removing instruction jmp __b5
Removing instruction jmp __b3
Removing instruction jmp __b6
Removing instruction jmp __breturn
Succesful ASM optimization Pass5NextJumpElimination
Removing instruction lda #>0
Removing instruction lda #>0
Removing instruction ldy #0
Removing instruction lda #>0
Removing instruction lda #>0
Removing instruction lda #>0
Removing instruction lda #>0
Replacing instruction lda #<0 with TXA
Removing instruction lda #>0
Succesful ASM optimization Pass5UnnecesaryLoadElimination
Replacing label __bbegin with __b1
Replacing label __b1_from___b1 with __b1
Replacing label __b1_from___b1 with __b1
Replacing label __b1_from___b2 with __b1
Replacing label __b2_from___b1 with __b2
Replacing label __b3_from___b2 with __b3
Replacing label __b3_from___b2 with __b3
Replacing label __b1_from___b3 with __b1
Removing instruction __bbegin:
Removing instruction __b1_from___bbegin:
Removing instruction main_from___b1:
Removing instruction __bend_from___b1:
Removing instruction __b4_from_main:
Removing instruction lin16u_gen_from___b4:
Removing instruction __b5_from___b4:
Removing instruction lin16u_gen_from___b5:
Removing instruction __b6_from___b5:
Removing instruction print_cls_from___b6:
Removing instruction __b7_from___b6:
Removing instruction print_str_from___b7:
Removing instruction __b8_from___b7:
Removing instruction print_word_from___b8:
Removing instruction __b9_from___b8:
Removing instruction print_str_from___b9:
Removing instruction __b10_from___b9:
Removing instruction print_word_from___b10:
Removing instruction __b11_from___b10:
Removing instruction print_str_from___b11:
Removing instruction __b12_from___b11:
Removing instruction print_word_from___b12:
Removing instruction __b13_from___b12:
Removing instruction print_ln_from___b13:
Removing instruction __b22_from___b3:
Removing instruction print_word_from___b22:
Removing instruction __b23_from___b22:
Removing instruction print_str_from___b23:
Removing instruction __b24_from___b23:
Removing instruction print_word_from___b24:
Removing instruction __b25_from___b24:
Removing instruction print_str_from___b25:
Removing instruction __b26_from___b25:
Removing instruction print_word_from___b26:
Removing instruction __b27_from___b26:
Removing instruction print_ln_from___b27:
Removing instruction __b14_from___b2:
Removing instruction print_str_from___b14:
Removing instruction __b16_from___b15:
Removing instruction print_str_from___b16:
Removing instruction __b18_from___b17:
Removing instruction print_str_from___b18:
Removing instruction __b20_from___b19:
Removing instruction print_ln_from___b20:
Removing instruction __b1_from_print_ln:
Removing instruction __b1_from___b1:
Removing instruction __b1_from_print_str:
Removing instruction __b1_from___b2:
Removing instruction __b1_from___b3:
Removing instruction __b2_from___b1:
Removing instruction __b2_from___b4:
Removing instruction __b3_from___b2:
Removing instruction __b3_from___b5:
Removing instruction __breturn:
Succesful ASM optimization Pass5RedundantLabelElimination
Removing instruction __bend:
Removing instruction lin16u_gen_from_main:
Removing instruction __b4:
Removing instruction __b5:
Removing instruction __b6:
Removing instruction __b7:
Removing instruction __b8:
Removing instruction __b9:
Removing instruction __b10:
Removing instruction __b11:
Removing instruction __b12:
Removing instruction __b13:
Removing instruction __b1_from___b13:
Removing instruction __b3:
Removing instruction print_str_from___b3:
Removing instruction __b22:
Removing instruction __b23:
Removing instruction __b24:
Removing instruction __b25:
Removing instruction __b26:
Removing instruction __b27:
Removing instruction __breturn:
Removing instruction print_byte_from___b2:
Removing instruction __b14:
Removing instruction __b15:
Removing instruction print_word_from___b15:
Removing instruction __b16:
Removing instruction __b17:
Removing instruction print_word_from___b17:
Removing instruction __b18:
Removing instruction __b19:
Removing instruction print_word_from___b19:
Removing instruction __b20:
Removing instruction __b21:
Removing instruction __b1_from___b21:
Removing instruction __breturn:
Removing instruction print_byte_from_print_word:
Removing instruction __b1:
Removing instruction print_byte_from___b1:
Removing instruction __breturn:
Removing instruction print_char_from_print_byte:
Removing instruction __b1:
Removing instruction print_char_from___b1:
Removing instruction __breturn:
Removing instruction __breturn:
Removing instruction __breturn:
Removing instruction memset_from_print_cls:
Removing instruction __breturn:
Removing instruction __b1_from_memset:
Removing instruction __breturn:
Removing instruction __b1_from___b2:
Removing instruction divr16u_from_lin16u_gen:
Removing instruction __b3:
Removing instruction divr16u_from___b3:
Removing instruction __b4:
Removing instruction __b1_from___b4:
Removing instruction __breturn:
Removing instruction __b1_from___b2:
Removing instruction __b1_from_divr16u:
Removing instruction __b4:
Removing instruction __b5:
Removing instruction __b6:
Succesful ASM optimization Pass5UnusedLabelElimination
Updating BasicUpstart to call main directly
Removing instruction jsr main
Succesful ASM optimization Pass5SkipBegin
Removing instruction jmp __b1
Succesful ASM optimization Pass5NextJumpElimination
Removing instruction __b1:
Succesful ASM optimization Pass5UnusedLabelElimination

FINAL SYMBOL TABLE
(label) @1
(label) @begin
(label) @end
(const byte) RADIX::BINARY = (number) 2
(const byte) RADIX::DECIMAL = (number) $a
(const byte) RADIX::HEXADECIMAL = (number) $10
(const byte) RADIX::OCTAL = (number) 8
(const byte) SIZEOF_WORD = (byte) 2
(word()) divr16u((word) divr16u::dividend , (word) divr16u::divisor , (word) divr16u::rem)
(byte~) divr16u::$1 reg byte a 22.0
(byte~) divr16u::$2 reg byte a 22.0
(label) divr16u::@1
(label) divr16u::@2
(label) divr16u::@3
(label) divr16u::@4
(label) divr16u::@5
(label) divr16u::@6
(label) divr16u::@return
(word) divr16u::dividend
(word) divr16u::dividend#0 dividend zp[2]:3 2.75
(word) divr16u::dividend#1 dividend zp[2]:3 4.0
(word) divr16u::dividend#3 dividend zp[2]:3 5.0
(word) divr16u::dividend#5 dividend zp[2]:3 4.0
(word) divr16u::divisor
(word) divr16u::divisor#6 divisor zp[2]:13 1.375
(byte) divr16u::i
(byte) divr16u::i#1 reg byte x 16.5
(byte) divr16u::i#2 reg byte x 1.6923076923076923
(word) divr16u::quotient
(word) divr16u::quotient#1 quotient zp[2]:15 16.5
(word) divr16u::quotient#2 quotient zp[2]:15 11.0
(word) divr16u::quotient#3 quotient zp[2]:15 2.75
(word) divr16u::rem
(word) divr16u::rem#0 rem zp[2]:23 8.25
(word) divr16u::rem#1 rem zp[2]:23 22.0
(word) divr16u::rem#10 rem zp[2]:23 4.0
(word) divr16u::rem#11 rem zp[2]:23 11.666666666666666
(word) divr16u::rem#2 rem zp[2]:23 22.0
(word) divr16u::rem#4 rem zp[2]:23 4.0
(word) divr16u::rem#5 rem zp[2]:23 24.0
(word) divr16u::rem#6 rem zp[2]:23 11.0
(word) divr16u::return
(word) divr16u::return#0 return zp[2]:15 5.285714285714286
(word) divr16u::return#2 return zp[2]:15 4.0
(word) divr16u::return#3 return zp[2]:15 4.0
(void()) lin16u_gen((word) lin16u_gen::min , (word) lin16u_gen::max , (word*) lin16u_gen::lintab , (word) lin16u_gen::length)
(word~) lin16u_gen::$6 zp[2]:23 22.0
(label) lin16u_gen::@1
(label) lin16u_gen::@2
(label) lin16u_gen::@3
(label) lin16u_gen::@4
(label) lin16u_gen::@return
(word) lin16u_gen::ampl
(word) lin16u_gen::ampl#0 ampl zp[2]:3 4.0
(word) lin16u_gen::i
(word) lin16u_gen::i#1 i zp[2]:13 22.0
(word) lin16u_gen::i#2 i zp[2]:13 5.5
(word) lin16u_gen::length
(word*) lin16u_gen::lintab
(word*) lin16u_gen::lintab#3 lintab zp[2]:11 11.0
(word*) lin16u_gen::lintab#4 lintab zp[2]:11 7.000000000000001
(word*) lin16u_gen::lintab#6 lintab zp[2]:11 0.16666666666666666
(word) lin16u_gen::max
(word) lin16u_gen::max#3 max zp[2]:3 2.0
(word) lin16u_gen::min
(word) lin16u_gen::min#3 min zp[2]:5 0.36363636363636365
(dword) lin16u_gen::step
(dword) lin16u_gen::step#0 step zp[4]:19 1.4444444444444446
(word) lin16u_gen::stepf
(word) lin16u_gen::stepf#0 stepf zp[2]:15 4.0
(word) lin16u_gen::stepi
(word) lin16u_gen::stepi#0 stepi zp[2]:17 0.8
(dword) lin16u_gen::val
(dword) lin16u_gen::val#0 val zp[4]:7 4.0
(dword) lin16u_gen::val#1 val zp[4]:7 7.333333333333333
(dword) lin16u_gen::val#2 val zp[4]:7 8.75
(void()) main()
(byte~) main::$27 reg byte a 22.0
(byte~) main::$28 reg byte a 22.0
(byte~) main::$29 reg byte a 22.0
(label) main::@1
(label) main::@10
(label) main::@11
(label) main::@12
(label) main::@13
(label) main::@14
(label) main::@15
(label) main::@16
(label) main::@17
(label) main::@18
(label) main::@19
(label) main::@2
(label) main::@20
(label) main::@21
(label) main::@22
(label) main::@23
(label) main::@24
(label) main::@25
(label) main::@26
(label) main::@27
(label) main::@3
(label) main::@4
(label) main::@5
(label) main::@6
(label) main::@7
(label) main::@8
(label) main::@9
(label) main::@return
(byte) main::i
(byte) main::i#1 reg byte x 22.0
(byte) main::i#10 reg byte x 3.5
(const word*) main::lintab1[(number) $14]  = { fill( $14, 0) }
(const word*) main::lintab2[(number) $14]  = { fill( $14, 0) }
(const word*) main::lintab3[(number) $14]  = { fill( $14, 0) }
(const byte*) main::str[(byte) 4]  = (byte*) "   "
(const byte*) main::str1[(byte) 2]  = (byte*) " "
(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num)
(label) memset::@1
(label) memset::@2
(label) memset::@return
(byte) memset::c
(const byte) memset::c#0 c = (byte) ' '
(byte*) memset::dst
(byte*) memset::dst#1 dst zp[2]:11 22.0
(byte*) memset::dst#2 dst zp[2]:11 14.666666666666666
(byte*) memset::end
(const byte*) memset::end#0 end = (byte*)(const void*) memset::str#0+(const word) memset::num#0
(word) memset::num
(const word) memset::num#0 num = (word) $3e8
(void*) memset::return
(void*) memset::str
(const void*) memset::str#0 str = (void*)(byte*) 1024
(void()) print_byte((byte) print_byte::b)
(byte~) print_byte::$0 reg byte a 4.0
(byte~) print_byte::$2 reg byte a 4.0
(label) print_byte::@1
(label) print_byte::@return
(byte) print_byte::b
(byte) print_byte::b#0 b zp[1]:2 4.0
(byte) print_byte::b#1 b zp[1]:2 4.0
(byte) print_byte::b#2 b zp[1]:2 11.0
(byte) print_byte::b#3 b zp[1]:2 4.75
(void()) print_char((byte) print_char::ch)
(label) print_char::@return
(byte) print_char::ch
(byte) print_char::ch#0 reg byte a 4.0
(byte) print_char::ch#1 reg byte a 4.0
(byte) print_char::ch#2 reg byte a 6.0
(byte*) print_char_cursor
(byte*) print_char_cursor#1 print_char_cursor zp[2]:3 101.0
(byte*) print_char_cursor#101 print_char_cursor zp[2]:3 22.0
(byte*) print_char_cursor#11 print_char_cursor zp[2]:3 4.228571428571427
(byte*) print_char_cursor#2 print_char_cursor zp[2]:3 11.37037037037037
(byte*) print_char_cursor#50 print_char_cursor zp[2]:3 4.0
(byte*) print_char_cursor#81 print_char_cursor zp[2]:3 5.666666666666667
(byte*) print_char_cursor#86 print_char_cursor zp[2]:3 45.0
(byte*) print_char_cursor#98 print_char_cursor zp[2]:3 4.0
(void()) print_cls()
(label) print_cls::@return
(const byte*) print_hextab[]  = (byte*) "0123456789abcdef"z
(byte*) print_line_cursor
(byte*) print_line_cursor#1 print_line_cursor zp[2]:11 8.225
(byte*) print_line_cursor#11 print_line_cursor zp[2]:11 204.0
(byte*) print_line_cursor#21 print_line_cursor zp[2]:11 15.0
(void()) print_ln()
(label) print_ln::@1
(label) print_ln::@return
(byte*) print_screen
(void()) print_str((byte*) print_str::str)
(label) print_str::@1
(label) print_str::@2
(label) print_str::@return
(byte*) print_str::str
(byte*) print_str::str#0 str zp[2]:5 202.0
(byte*) print_str::str#10 str zp[2]:5 101.5
(byte*) print_str::str#12 str zp[2]:5 2.0
(void()) print_word((word) print_word::w)
(label) print_word::@1
(label) print_word::@return
(word) print_word::w
(word) print_word::w#10 w zp[2]:5 12.333333333333332
(word) print_word::w#3 w zp[2]:5 22.0
(word) print_word::w#4 w zp[2]:5 22.0
(word) print_word::w#5 w zp[2]:5 22.0
(word) rem16u
(word) rem16u#1 rem16u zp[2]:23 0.8

reg byte x [ main::i#10 main::i#1 ]
zp[1]:2 [ print_byte::b#3 print_byte::b#2 print_byte::b#0 print_byte::b#1 ]
reg byte a [ print_char::ch#2 print_char::ch#0 print_char::ch#1 ]
zp[2]:3 [ lin16u_gen::max#3 lin16u_gen::ampl#0 divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#1 divr16u::dividend#0 print_char_cursor#86 print_char_cursor#50 print_char_cursor#81 print_char_cursor#101 print_char_cursor#2 print_char_cursor#11 print_char_cursor#98 print_char_cursor#1 ]
zp[2]:5 [ lin16u_gen::min#3 print_str::str#10 print_str::str#12 print_str::str#0 print_word::w#10 print_word::w#3 print_word::w#4 print_word::w#5 ]
zp[4]:7 [ lin16u_gen::val#2 lin16u_gen::val#1 lin16u_gen::val#0 ]
zp[2]:11 [ lin16u_gen::lintab#4 lin16u_gen::lintab#3 lin16u_gen::lintab#6 memset::dst#2 memset::dst#1 print_line_cursor#11 print_line_cursor#21 print_line_cursor#1 ]
zp[2]:13 [ divr16u::divisor#6 lin16u_gen::i#2 lin16u_gen::i#1 ]
zp[2]:15 [ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 divr16u::return#2 divr16u::return#3 lin16u_gen::stepf#0 ]
reg byte x [ divr16u::i#2 divr16u::i#1 ]
reg byte a [ main::$27 ]
reg byte a [ main::$28 ]
reg byte a [ main::$29 ]
reg byte a [ print_byte::$0 ]
reg byte a [ print_byte::$2 ]
zp[2]:17 [ lin16u_gen::stepi#0 ]
zp[4]:19 [ lin16u_gen::step#0 ]
zp[2]:23 [ lin16u_gen::$6 divr16u::rem#5 divr16u::rem#10 divr16u::rem#4 divr16u::rem#11 divr16u::rem#6 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 rem16u#1 ]
reg byte a [ divr16u::$1 ]
reg byte a [ divr16u::$2 ]


FINAL ASSEMBLER
Score: 13613

  // File Comments
// Linear table generator
// Work in progress towards a sinus generator
  // Upstart
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
  // Global Constants & labels
  .const SIZEOF_WORD = 2
  // Remainder after unsigned 16-bit division
  .label rem16u = $17
  .label print_char_cursor = 3
  .label print_line_cursor = $b
  // @begin
  // [1] phi from @begin to @1 [phi:@begin->@1]
  // @1
  // [2] call main 
  // [4] phi from @1 to main [phi:@1->main]
  // [3] phi from @1 to @end [phi:@1->@end]
  // @end
  // main
main: {
    // lin16u_gen(557, 29793, lintab1, 20)
    // [5] call lin16u_gen 
    // [103] phi from main to lin16u_gen [phi:main->lin16u_gen]
    // [103] phi (word*) lin16u_gen::lintab#6 = (const word*) main::lintab1 [phi:main->lin16u_gen#0] -- pwuz1=pwuc1 
    lda #<lintab1
    sta.z lin16u_gen.lintab
    lda #>lintab1
    sta.z lin16u_gen.lintab+1
    // [103] phi (word) lin16u_gen::min#3 = (word) $22d [phi:main->lin16u_gen#1] -- vwuz1=vwuc1 
    lda #<$22d
    sta.z lin16u_gen.min
    lda #>$22d
    sta.z lin16u_gen.min+1
    // [103] phi (word) lin16u_gen::max#3 = (word) $7461 [phi:main->lin16u_gen#2] -- vwuz1=vwuc1 
    lda #<$7461
    sta.z lin16u_gen.max
    lda #>$7461
    sta.z lin16u_gen.max+1
    jsr lin16u_gen
    // [6] phi from main to main::@4 [phi:main->main::@4]
    // main::@4
    // lin16u_gen(31179, 63361, lintab2, 20)
    // [7] call lin16u_gen 
    // [103] phi from main::@4 to lin16u_gen [phi:main::@4->lin16u_gen]
    // [103] phi (word*) lin16u_gen::lintab#6 = (const word*) main::lintab2 [phi:main::@4->lin16u_gen#0] -- pwuz1=pwuc1 
    lda #<lintab2
    sta.z lin16u_gen.lintab
    lda #>lintab2
    sta.z lin16u_gen.lintab+1
    // [103] phi (word) lin16u_gen::min#3 = (word) $79cb [phi:main::@4->lin16u_gen#1] -- vwuz1=vwuc1 
    lda #<$79cb
    sta.z lin16u_gen.min
    lda #>$79cb
    sta.z lin16u_gen.min+1
    // [103] phi (word) lin16u_gen::max#3 = (word) $f781 [phi:main::@4->lin16u_gen#2] -- vwuz1=vwuc1 
    lda #<$f781
    sta.z lin16u_gen.max
    lda #>$f781
    sta.z lin16u_gen.max+1
    jsr lin16u_gen
    // [8] phi from main::@4 to main::@5 [phi:main::@4->main::@5]
    // main::@5
    // lin16u_gen(0, $6488, lintab3, 20)
    // [9] call lin16u_gen 
    // [103] phi from main::@5 to lin16u_gen [phi:main::@5->lin16u_gen]
    // [103] phi (word*) lin16u_gen::lintab#6 = (const word*) main::lintab3 [phi:main::@5->lin16u_gen#0] -- pwuz1=pwuc1 
    lda #<lintab3
    sta.z lin16u_gen.lintab
    lda #>lintab3
    sta.z lin16u_gen.lintab+1
    // [103] phi (word) lin16u_gen::min#3 = (byte) 0 [phi:main::@5->lin16u_gen#1] -- vwuz1=vbuc1 
    lda #<0
    sta.z lin16u_gen.min
    sta.z lin16u_gen.min+1
    // [103] phi (word) lin16u_gen::max#3 = (word) $6488 [phi:main::@5->lin16u_gen#2] -- vwuz1=vwuc1 
    lda #<$6488
    sta.z lin16u_gen.max
    lda #>$6488
    sta.z lin16u_gen.max+1
    jsr lin16u_gen
    // [10] phi from main::@5 to main::@6 [phi:main::@5->main::@6]
    // main::@6
    // print_cls()
    // [11] call print_cls 
    // [94] phi from main::@6 to print_cls [phi:main::@6->print_cls]
    jsr print_cls
    // [12] phi from main::@6 to main::@7 [phi:main::@6->main::@7]
    // main::@7
    // print_str("   ")
    // [13] call print_str 
    // [87] phi from main::@7 to print_str [phi:main::@7->print_str]
    // [87] phi (byte*) print_char_cursor#86 = (byte*) 1024 [phi:main::@7->print_str#0] -- pbuz1=pbuc1 
    lda #<$400
    sta.z print_char_cursor
    lda #>$400
    sta.z print_char_cursor+1
    // [87] phi (byte*) print_str::str#12 = (const byte*) main::str [phi:main::@7->print_str#1] -- pbuz1=pbuc1 
    lda #<str
    sta.z print_str.str
    lda #>str
    sta.z print_str.str+1
    jsr print_str
    // [14] phi from main::@7 to main::@8 [phi:main::@7->main::@8]
    // main::@8
    // print_word(557)
    // [15] call print_word 
    // [69] phi from main::@8 to print_word [phi:main::@8->print_word]
    // [69] phi (word) print_word::w#10 = (word) $22d [phi:main::@8->print_word#0] -- vwuz1=vwuc1 
    lda #<$22d
    sta.z print_word.w
    lda #>$22d
    sta.z print_word.w+1
    jsr print_word
    // [16] phi from main::@8 to main::@9 [phi:main::@8->main::@9]
    // main::@9
    // print_str(" ")
    // [17] call print_str 
    // [87] phi from main::@9 to print_str [phi:main::@9->print_str]
    // [87] phi (byte*) print_char_cursor#86 = (byte*) print_char_cursor#11 [phi:main::@9->print_str#0] -- register_copy 
    // [87] phi (byte*) print_str::str#12 = (const byte*) main::str1 [phi:main::@9->print_str#1] -- pbuz1=pbuc1 
    lda #<str1
    sta.z print_str.str
    lda #>str1
    sta.z print_str.str+1
    jsr print_str
    // [18] phi from main::@9 to main::@10 [phi:main::@9->main::@10]
    // main::@10
    // print_word(31179)
    // [19] call print_word 
    // [69] phi from main::@10 to print_word [phi:main::@10->print_word]
    // [69] phi (word) print_word::w#10 = (word) $79cb [phi:main::@10->print_word#0] -- vwuz1=vwuc1 
    lda #<$79cb
    sta.z print_word.w
    lda #>$79cb
    sta.z print_word.w+1
    jsr print_word
    // [20] phi from main::@10 to main::@11 [phi:main::@10->main::@11]
    // main::@11
    // print_str(" ")
    // [21] call print_str 
    // [87] phi from main::@11 to print_str [phi:main::@11->print_str]
    // [87] phi (byte*) print_char_cursor#86 = (byte*) print_char_cursor#11 [phi:main::@11->print_str#0] -- register_copy 
    // [87] phi (byte*) print_str::str#12 = (const byte*) main::str1 [phi:main::@11->print_str#1] -- pbuz1=pbuc1 
    lda #<str1
    sta.z print_str.str
    lda #>str1
    sta.z print_str.str+1
    jsr print_str
    // [22] phi from main::@11 to main::@12 [phi:main::@11->main::@12]
    // main::@12
    // print_word(0)
    // [23] call print_word 
    // [69] phi from main::@12 to print_word [phi:main::@12->print_word]
    // [69] phi (word) print_word::w#10 = (byte) 0 [phi:main::@12->print_word#0] -- vwuz1=vbuc1 
    lda #<0
    sta.z print_word.w
    sta.z print_word.w+1
    jsr print_word
    // [24] phi from main::@12 to main::@13 [phi:main::@12->main::@13]
    // main::@13
    // print_ln()
    // [25] call print_ln 
    // [64] phi from main::@13 to print_ln [phi:main::@13->print_ln]
    // [64] phi (byte*) print_line_cursor#21 = (byte*) 1024 [phi:main::@13->print_ln#0] -- pbuz1=pbuc1 
    lda #<$400
    sta.z print_line_cursor
    lda #>$400
    sta.z print_line_cursor+1
    jsr print_ln
    // [26] phi from main::@13 to main::@1 [phi:main::@13->main::@1]
    // [26] phi (byte) main::i#10 = (byte) 0 [phi:main::@13->main::@1#0] -- vbuxx=vbuc1 
    ldx #0
    // main::@1
  __b1:
    // for(byte i=0; i<20; i++)
    // [27] if((byte) main::i#10<(byte) $14) goto main::@2 -- vbuxx_lt_vbuc1_then_la1 
    cpx #$14
    bcc __b2
    // main::@3
    // [28] (byte*) print_char_cursor#98 ← (byte*) print_line_cursor#1 -- pbuz1=pbuz2 
    lda.z print_line_cursor
    sta.z print_char_cursor
    lda.z print_line_cursor+1
    sta.z print_char_cursor+1
    // print_str("   ")
    // [29] call print_str 
    // [87] phi from main::@3 to print_str [phi:main::@3->print_str]
    // [87] phi (byte*) print_char_cursor#86 = (byte*) print_char_cursor#98 [phi:main::@3->print_str#0] -- register_copy 
    // [87] phi (byte*) print_str::str#12 = (const byte*) main::str [phi:main::@3->print_str#1] -- pbuz1=pbuc1 
    lda #<str
    sta.z print_str.str
    lda #>str
    sta.z print_str.str+1
    jsr print_str
    // [30] phi from main::@3 to main::@22 [phi:main::@3->main::@22]
    // main::@22
    // print_word(29793)
    // [31] call print_word 
    // [69] phi from main::@22 to print_word [phi:main::@22->print_word]
    // [69] phi (word) print_word::w#10 = (word) $7461 [phi:main::@22->print_word#0] -- vwuz1=vwuc1 
    lda #<$7461
    sta.z print_word.w
    lda #>$7461
    sta.z print_word.w+1
    jsr print_word
    // [32] phi from main::@22 to main::@23 [phi:main::@22->main::@23]
    // main::@23
    // print_str(" ")
    // [33] call print_str 
    // [87] phi from main::@23 to print_str [phi:main::@23->print_str]
    // [87] phi (byte*) print_char_cursor#86 = (byte*) print_char_cursor#11 [phi:main::@23->print_str#0] -- register_copy 
    // [87] phi (byte*) print_str::str#12 = (const byte*) main::str1 [phi:main::@23->print_str#1] -- pbuz1=pbuc1 
    lda #<str1
    sta.z print_str.str
    lda #>str1
    sta.z print_str.str+1
    jsr print_str
    // [34] phi from main::@23 to main::@24 [phi:main::@23->main::@24]
    // main::@24
    // print_word(63361)
    // [35] call print_word 
    // [69] phi from main::@24 to print_word [phi:main::@24->print_word]
    // [69] phi (word) print_word::w#10 = (word) $f781 [phi:main::@24->print_word#0] -- vwuz1=vwuc1 
    lda #<$f781
    sta.z print_word.w
    lda #>$f781
    sta.z print_word.w+1
    jsr print_word
    // [36] phi from main::@24 to main::@25 [phi:main::@24->main::@25]
    // main::@25
    // print_str(" ")
    // [37] call print_str 
    // [87] phi from main::@25 to print_str [phi:main::@25->print_str]
    // [87] phi (byte*) print_char_cursor#86 = (byte*) print_char_cursor#11 [phi:main::@25->print_str#0] -- register_copy 
    // [87] phi (byte*) print_str::str#12 = (const byte*) main::str1 [phi:main::@25->print_str#1] -- pbuz1=pbuc1 
    lda #<str1
    sta.z print_str.str
    lda #>str1
    sta.z print_str.str+1
    jsr print_str
    // [38] phi from main::@25 to main::@26 [phi:main::@25->main::@26]
    // main::@26
    // print_word($6488)
    // [39] call print_word 
    // [69] phi from main::@26 to print_word [phi:main::@26->print_word]
    // [69] phi (word) print_word::w#10 = (word) $6488 [phi:main::@26->print_word#0] -- vwuz1=vwuc1 
    lda #<$6488
    sta.z print_word.w
    lda #>$6488
    sta.z print_word.w+1
    jsr print_word
    // [40] phi from main::@26 to main::@27 [phi:main::@26->main::@27]
    // main::@27
    // print_ln()
    // [41] call print_ln 
    // [64] phi from main::@27 to print_ln [phi:main::@27->print_ln]
    // [64] phi (byte*) print_line_cursor#21 = (byte*) print_line_cursor#1 [phi:main::@27->print_ln#0] -- register_copy 
    jsr print_ln
    // main::@return
    // }
    // [42] return 
    rts
    // main::@2
  __b2:
    // print_byte(i)
    // [43] (byte) print_byte::b#2 ← (byte) main::i#10 -- vbuz1=vbuxx 
    stx.z print_byte.b
    // [44] (byte*) print_char_cursor#101 ← (byte*) print_line_cursor#1 -- pbuz1=pbuz2 
    lda.z print_line_cursor
    sta.z print_char_cursor
    lda.z print_line_cursor+1
    sta.z print_char_cursor+1
    // print_byte(i)
    // [45] call print_byte 
    // [75] phi from main::@2 to print_byte [phi:main::@2->print_byte]
    // [75] phi (byte*) print_char_cursor#81 = (byte*) print_char_cursor#101 [phi:main::@2->print_byte#0] -- register_copy 
    // [75] phi (byte) print_byte::b#3 = (byte) print_byte::b#2 [phi:main::@2->print_byte#1] -- register_copy 
    jsr print_byte
    // [46] phi from main::@2 to main::@14 [phi:main::@2->main::@14]
    // main::@14
    // print_str(" ")
    // [47] call print_str 
    // [87] phi from main::@14 to print_str [phi:main::@14->print_str]
    // [87] phi (byte*) print_char_cursor#86 = (byte*) print_char_cursor#11 [phi:main::@14->print_str#0] -- register_copy 
    // [87] phi (byte*) print_str::str#12 = (const byte*) main::str1 [phi:main::@14->print_str#1] -- pbuz1=pbuc1 
    lda #<str1
    sta.z print_str.str
    lda #>str1
    sta.z print_str.str+1
    jsr print_str
    // main::@15
    // print_word(lintab1[i])
    // [48] (byte~) main::$27 ← (byte) main::i#10 << (byte) 1 -- vbuaa=vbuxx_rol_1 
    txa
    asl
    // [49] (word) print_word::w#3 ← *((const word*) main::lintab1 + (byte~) main::$27) -- vwuz1=pwuc1_derefidx_vbuaa 
    tay
    lda lintab1,y
    sta.z print_word.w
    lda lintab1+1,y
    sta.z print_word.w+1
    // [50] call print_word 
    // [69] phi from main::@15 to print_word [phi:main::@15->print_word]
    // [69] phi (word) print_word::w#10 = (word) print_word::w#3 [phi:main::@15->print_word#0] -- register_copy 
    jsr print_word
    // [51] phi from main::@15 to main::@16 [phi:main::@15->main::@16]
    // main::@16
    // print_str(" ")
    // [52] call print_str 
    // [87] phi from main::@16 to print_str [phi:main::@16->print_str]
    // [87] phi (byte*) print_char_cursor#86 = (byte*) print_char_cursor#11 [phi:main::@16->print_str#0] -- register_copy 
    // [87] phi (byte*) print_str::str#12 = (const byte*) main::str1 [phi:main::@16->print_str#1] -- pbuz1=pbuc1 
    lda #<str1
    sta.z print_str.str
    lda #>str1
    sta.z print_str.str+1
    jsr print_str
    // main::@17
    // print_word(lintab2[i])
    // [53] (byte~) main::$28 ← (byte) main::i#10 << (byte) 1 -- vbuaa=vbuxx_rol_1 
    txa
    asl
    // [54] (word) print_word::w#4 ← *((const word*) main::lintab2 + (byte~) main::$28) -- vwuz1=pwuc1_derefidx_vbuaa 
    tay
    lda lintab2,y
    sta.z print_word.w
    lda lintab2+1,y
    sta.z print_word.w+1
    // [55] call print_word 
    // [69] phi from main::@17 to print_word [phi:main::@17->print_word]
    // [69] phi (word) print_word::w#10 = (word) print_word::w#4 [phi:main::@17->print_word#0] -- register_copy 
    jsr print_word
    // [56] phi from main::@17 to main::@18 [phi:main::@17->main::@18]
    // main::@18
    // print_str(" ")
    // [57] call print_str 
    // [87] phi from main::@18 to print_str [phi:main::@18->print_str]
    // [87] phi (byte*) print_char_cursor#86 = (byte*) print_char_cursor#11 [phi:main::@18->print_str#0] -- register_copy 
    // [87] phi (byte*) print_str::str#12 = (const byte*) main::str1 [phi:main::@18->print_str#1] -- pbuz1=pbuc1 
    lda #<str1
    sta.z print_str.str
    lda #>str1
    sta.z print_str.str+1
    jsr print_str
    // main::@19
    // print_word(lintab3[i])
    // [58] (byte~) main::$29 ← (byte) main::i#10 << (byte) 1 -- vbuaa=vbuxx_rol_1 
    txa
    asl
    // [59] (word) print_word::w#5 ← *((const word*) main::lintab3 + (byte~) main::$29) -- vwuz1=pwuc1_derefidx_vbuaa 
    tay
    lda lintab3,y
    sta.z print_word.w
    lda lintab3+1,y
    sta.z print_word.w+1
    // [60] call print_word 
    // [69] phi from main::@19 to print_word [phi:main::@19->print_word]
    // [69] phi (word) print_word::w#10 = (word) print_word::w#5 [phi:main::@19->print_word#0] -- register_copy 
    jsr print_word
    // [61] phi from main::@19 to main::@20 [phi:main::@19->main::@20]
    // main::@20
    // print_ln()
    // [62] call print_ln 
    // [64] phi from main::@20 to print_ln [phi:main::@20->print_ln]
    // [64] phi (byte*) print_line_cursor#21 = (byte*) print_line_cursor#1 [phi:main::@20->print_ln#0] -- register_copy 
    jsr print_ln
    // main::@21
    // for(byte i=0; i<20; i++)
    // [63] (byte) main::i#1 ← ++ (byte) main::i#10 -- vbuxx=_inc_vbuxx 
    inx
    // [26] phi from main::@21 to main::@1 [phi:main::@21->main::@1]
    // [26] phi (byte) main::i#10 = (byte) main::i#1 [phi:main::@21->main::@1#0] -- register_copy 
    jmp __b1
    lintab1: .fill 2*$14, 0
    lintab2: .fill 2*$14, 0
    lintab3: .fill 2*$14, 0
    str: .text "   "
    .byte 0
    str1: .text " "
    .byte 0
}
  // print_ln
// Print a newline
print_ln: {
    // [65] phi from print_ln print_ln::@1 to print_ln::@1 [phi:print_ln/print_ln::@1->print_ln::@1]
    // [65] phi (byte*) print_line_cursor#11 = (byte*) print_line_cursor#21 [phi:print_ln/print_ln::@1->print_ln::@1#0] -- register_copy 
    // print_ln::@1
  __b1:
    // print_line_cursor + $28
    // [66] (byte*) print_line_cursor#1 ← (byte*) print_line_cursor#11 + (byte) $28 -- pbuz1=pbuz1_plus_vbuc1 
    lda #$28
    clc
    adc.z print_line_cursor
    sta.z print_line_cursor
    bcc !+
    inc.z print_line_cursor+1
  !:
    // while (print_line_cursor<print_char_cursor)
    // [67] if((byte*) print_line_cursor#1<(byte*) print_char_cursor#11) goto print_ln::@1 -- pbuz1_lt_pbuz2_then_la1 
    lda.z print_line_cursor+1
    cmp.z print_char_cursor+1
    bcc __b1
    bne !+
    lda.z print_line_cursor
    cmp.z print_char_cursor
    bcc __b1
  !:
    // print_ln::@return
    // }
    // [68] return 
    rts
}
  // print_word
// Print a word as HEX
// print_word(word zp(5) w)
print_word: {
    .label w = 5
    // print_byte(>w)
    // [70] (byte) print_byte::b#0 ← > (word) print_word::w#10 -- vbuz1=_hi_vwuz2 
    lda.z w+1
    sta.z print_byte.b
    // [71] call print_byte 
    // [75] phi from print_word to print_byte [phi:print_word->print_byte]
    // [75] phi (byte*) print_char_cursor#81 = (byte*) print_char_cursor#2 [phi:print_word->print_byte#0] -- register_copy 
    // [75] phi (byte) print_byte::b#3 = (byte) print_byte::b#0 [phi:print_word->print_byte#1] -- register_copy 
    jsr print_byte
    // print_word::@1
    // print_byte(<w)
    // [72] (byte) print_byte::b#1 ← < (word) print_word::w#10 -- vbuz1=_lo_vwuz2 
    lda.z w
    sta.z print_byte.b
    // [73] call print_byte 
    // [75] phi from print_word::@1 to print_byte [phi:print_word::@1->print_byte]
    // [75] phi (byte*) print_char_cursor#81 = (byte*) print_char_cursor#11 [phi:print_word::@1->print_byte#0] -- register_copy 
    // [75] phi (byte) print_byte::b#3 = (byte) print_byte::b#1 [phi:print_word::@1->print_byte#1] -- register_copy 
    jsr print_byte
    // print_word::@return
    // }
    // [74] return 
    rts
}
  // print_byte
// Print a byte as HEX
// print_byte(byte zp(2) b)
print_byte: {
    .label b = 2
    // b>>4
    // [76] (byte~) print_byte::$0 ← (byte) print_byte::b#3 >> (byte) 4 -- vbuaa=vbuz1_ror_4 
    lda.z b
    lsr
    lsr
    lsr
    lsr
    // print_char(print_hextab[b>>4])
    // [77] (byte) print_char::ch#0 ← *((const byte*) print_hextab + (byte~) print_byte::$0) -- vbuaa=pbuc1_derefidx_vbuaa 
    tay
    lda print_hextab,y
    // [78] call print_char 
    // [83] phi from print_byte to print_char [phi:print_byte->print_char]
    // [83] phi (byte*) print_char_cursor#50 = (byte*) print_char_cursor#81 [phi:print_byte->print_char#0] -- register_copy 
    // [83] phi (byte) print_char::ch#2 = (byte) print_char::ch#0 [phi:print_byte->print_char#1] -- register_copy 
    jsr print_char
    // print_byte::@1
    // b&$f
    // [79] (byte~) print_byte::$2 ← (byte) print_byte::b#3 & (byte) $f -- vbuaa=vbuz1_band_vbuc1 
    lda #$f
    and.z b
    // print_char(print_hextab[b&$f])
    // [80] (byte) print_char::ch#1 ← *((const byte*) print_hextab + (byte~) print_byte::$2) -- vbuaa=pbuc1_derefidx_vbuaa 
    tay
    lda print_hextab,y
    // [81] call print_char 
    // [83] phi from print_byte::@1 to print_char [phi:print_byte::@1->print_char]
    // [83] phi (byte*) print_char_cursor#50 = (byte*) print_char_cursor#11 [phi:print_byte::@1->print_char#0] -- register_copy 
    // [83] phi (byte) print_char::ch#2 = (byte) print_char::ch#1 [phi:print_byte::@1->print_char#1] -- register_copy 
    jsr print_char
    // print_byte::@return
    // }
    // [82] return 
    rts
}
  // print_char
// Print a single char
// print_char(byte register(A) ch)
print_char: {
    // *(print_char_cursor++) = ch
    // [84] *((byte*) print_char_cursor#50) ← (byte) print_char::ch#2 -- _deref_pbuz1=vbuaa 
    ldy #0
    sta (print_char_cursor),y
    // *(print_char_cursor++) = ch;
    // [85] (byte*) print_char_cursor#11 ← ++ (byte*) print_char_cursor#50 -- pbuz1=_inc_pbuz1 
    inc.z print_char_cursor
    bne !+
    inc.z print_char_cursor+1
  !:
    // print_char::@return
    // }
    // [86] return 
    rts
}
  // print_str
// Print a zero-terminated string
// print_str(byte* zp(5) str)
print_str: {
    .label str = 5
    // [88] phi from print_str print_str::@2 to print_str::@1 [phi:print_str/print_str::@2->print_str::@1]
    // [88] phi (byte*) print_char_cursor#2 = (byte*) print_char_cursor#86 [phi:print_str/print_str::@2->print_str::@1#0] -- register_copy 
    // [88] phi (byte*) print_str::str#10 = (byte*) print_str::str#12 [phi:print_str/print_str::@2->print_str::@1#1] -- register_copy 
    // print_str::@1
  __b1:
    // while(*str)
    // [89] if((byte) 0!=*((byte*) print_str::str#10)) goto print_str::@2 -- vbuc1_neq__deref_pbuz1_then_la1 
    ldy #0
    lda (str),y
    cmp #0
    bne __b2
    // print_str::@return
    // }
    // [90] return 
    rts
    // print_str::@2
  __b2:
    // *(print_char_cursor++) = *(str++)
    // [91] *((byte*) print_char_cursor#2) ← *((byte*) print_str::str#10) -- _deref_pbuz1=_deref_pbuz2 
    ldy #0
    lda (str),y
    sta (print_char_cursor),y
    // *(print_char_cursor++) = *(str++);
    // [92] (byte*) print_char_cursor#1 ← ++ (byte*) print_char_cursor#2 -- pbuz1=_inc_pbuz1 
    inc.z print_char_cursor
    bne !+
    inc.z print_char_cursor+1
  !:
    // [93] (byte*) print_str::str#0 ← ++ (byte*) print_str::str#10 -- pbuz1=_inc_pbuz1 
    inc.z str
    bne !+
    inc.z str+1
  !:
    jmp __b1
}
  // print_cls
// Clear the screen. Also resets current line/char cursor.
print_cls: {
    // memset(print_screen, ' ', 1000)
    // [95] call memset 
    // [97] phi from print_cls to memset [phi:print_cls->memset]
    jsr memset
    // print_cls::@return
    // }
    // [96] return 
    rts
}
  // memset
// Copies the character c (an unsigned char) to the first num characters of the object pointed to by the argument str.
memset: {
    .const c = ' '
    .const num = $3e8
    .label str = $400
    .label end = str+num
    .label dst = $b
    // [98] phi from memset to memset::@1 [phi:memset->memset::@1]
    // [98] phi (byte*) memset::dst#2 = (byte*)(const void*) memset::str#0 [phi:memset->memset::@1#0] -- pbuz1=pbuc1 
    lda #<str
    sta.z dst
    lda #>str
    sta.z dst+1
    // memset::@1
  __b1:
    // for(char* dst = str; dst!=end; dst++)
    // [99] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 -- pbuz1_neq_pbuc1_then_la1 
    lda.z dst+1
    cmp #>end
    bne __b2
    lda.z dst
    cmp #<end
    bne __b2
    // memset::@return
    // }
    // [100] return 
    rts
    // memset::@2
  __b2:
    // *dst = c
    // [101] *((byte*) memset::dst#2) ← (const byte) memset::c#0 -- _deref_pbuz1=vbuc1 
    lda #c
    ldy #0
    sta (dst),y
    // for(char* dst = str; dst!=end; dst++)
    // [102] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2 -- pbuz1=_inc_pbuz1 
    inc.z dst
    bne !+
    inc.z dst+1
  !:
    // [98] phi from memset::@2 to memset::@1 [phi:memset::@2->memset::@1]
    // [98] phi (byte*) memset::dst#2 = (byte*) memset::dst#1 [phi:memset::@2->memset::@1#0] -- register_copy 
    jmp __b1
}
  // lin16u_gen
// Generate word linear table
// lintab - the table to generate into
// length - the number of points in a total sinus wavelength (the size of the table)
// lin16u_gen(word zp(5) min, word zp(3) max, word* zp($b) lintab)
lin16u_gen: {
    .label __6 = $17
    .label ampl = 3
    .label stepi = $11
    .label stepf = $f
    .label step = $13
    .label val = 7
    .label lintab = $b
    .label i = $d
    .label max = 3
    .label min = 5
    // ampl = max-min
    // [104] (word) lin16u_gen::ampl#0 ← (word) lin16u_gen::max#3 - (word) lin16u_gen::min#3 -- vwuz1=vwuz1_minus_vwuz2 
    lda.z ampl
    sec
    sbc.z min
    sta.z ampl
    lda.z ampl+1
    sbc.z min+1
    sta.z ampl+1
    // divr16u(ampl, length-1, 0)
    // [105] (word) divr16u::dividend#1 ← (word) lin16u_gen::ampl#0
    // [106] call divr16u 
    // [123] phi from lin16u_gen to divr16u [phi:lin16u_gen->divr16u]
    // [123] phi (word) divr16u::divisor#6 = (byte) $14-(byte) 1 [phi:lin16u_gen->divr16u#0] -- vwuz1=vbuc1 
    lda #<$14-1
    sta.z divr16u.divisor
    lda #>$14-1
    sta.z divr16u.divisor+1
    // [123] phi (word) divr16u::dividend#5 = (word) divr16u::dividend#1 [phi:lin16u_gen->divr16u#1] -- register_copy 
    // [123] phi (word) divr16u::rem#10 = (byte) 0 [phi:lin16u_gen->divr16u#2] -- vwuz1=vbuc1 
    lda #<0
    sta.z divr16u.rem
    sta.z divr16u.rem+1
    jsr divr16u
    // divr16u(ampl, length-1, 0)
    // [107] (word) divr16u::return#2 ← (word) divr16u::return#0
    // lin16u_gen::@3
    // stepi = divr16u(ampl, length-1, 0)
    // [108] (word) lin16u_gen::stepi#0 ← (word) divr16u::return#2 -- vwuz1=vwuz2 
    lda.z divr16u.return
    sta.z stepi
    lda.z divr16u.return+1
    sta.z stepi+1
    // divr16u(0, length-1, rem16u)
    // [109] (word) divr16u::rem#4 ← (word) rem16u#1
    // [110] call divr16u 
    // [123] phi from lin16u_gen::@3 to divr16u [phi:lin16u_gen::@3->divr16u]
    // [123] phi (word) divr16u::divisor#6 = (byte) $14-(byte) 1 [phi:lin16u_gen::@3->divr16u#0] -- vwuz1=vbuc1 
    lda #<$14-1
    sta.z divr16u.divisor
    lda #>$14-1
    sta.z divr16u.divisor+1
    // [123] phi (word) divr16u::dividend#5 = (byte) 0 [phi:lin16u_gen::@3->divr16u#1] -- vwuz1=vbuc1 
    lda #<0
    sta.z divr16u.dividend
    sta.z divr16u.dividend+1
    // [123] phi (word) divr16u::rem#10 = (word) divr16u::rem#4 [phi:lin16u_gen::@3->divr16u#2] -- register_copy 
    jsr divr16u
    // divr16u(0, length-1, rem16u)
    // [111] (word) divr16u::return#3 ← (word) divr16u::return#0
    // lin16u_gen::@4
    // stepf = divr16u(0, length-1, rem16u)
    // [112] (word) lin16u_gen::stepf#0 ← (word) divr16u::return#3
    // step = { stepi, stepf }
    // [113] (dword) lin16u_gen::step#0 ← (word) lin16u_gen::stepi#0 dw= (word) lin16u_gen::stepf#0 -- vduz1=vwuz2_dword_vwuz3 
    lda.z stepi
    sta.z step+2
    lda.z stepi+1
    sta.z step+3
    lda.z stepf
    sta.z step
    lda.z stepf+1
    sta.z step+1
    // val = { min, 0 }
    // [114] (dword) lin16u_gen::val#0 ← (word) lin16u_gen::min#3 dw= (word) 0 -- vduz1=vwuz2_dword_vwuc1 
    lda #<0
    sta.z val
    sta.z val+1
    lda.z min
    sta.z val+2
    lda.z min+1
    sta.z val+3
    // [115] phi from lin16u_gen::@4 to lin16u_gen::@1 [phi:lin16u_gen::@4->lin16u_gen::@1]
    // [115] phi (word*) lin16u_gen::lintab#4 = (word*) lin16u_gen::lintab#6 [phi:lin16u_gen::@4->lin16u_gen::@1#0] -- register_copy 
    // [115] phi (dword) lin16u_gen::val#2 = (dword) lin16u_gen::val#0 [phi:lin16u_gen::@4->lin16u_gen::@1#1] -- register_copy 
    // [115] phi (word) lin16u_gen::i#2 = (word) 0 [phi:lin16u_gen::@4->lin16u_gen::@1#2] -- vwuz1=vwuc1 
    lda #<0
    sta.z i
    sta.z i+1
    // lin16u_gen::@1
  __b1:
    // for(word i=0; i<length; i++)
    // [116] if((word) lin16u_gen::i#2<(byte) $14) goto lin16u_gen::@2 -- vwuz1_lt_vbuc1_then_la1 
    lda.z i+1
    cmp #>$14
    bcc __b2
    bne !+
    lda.z i
    cmp #<$14
    bcc __b2
  !:
    // lin16u_gen::@return
    // }
    // [117] return 
    rts
    // lin16u_gen::@2
  __b2:
    // >val
    // [118] (word~) lin16u_gen::$6 ← > (dword) lin16u_gen::val#2 -- vwuz1=_hi_vduz2 
    lda.z val+2
    sta.z __6
    lda.z val+3
    sta.z __6+1
    // *lintab = >val
    // [119] *((word*) lin16u_gen::lintab#4) ← (word~) lin16u_gen::$6 -- _deref_pwuz1=vwuz2 
    ldy #0
    lda.z __6
    sta (lintab),y
    iny
    lda.z __6+1
    sta (lintab),y
    // val = val + step
    // [120] (dword) lin16u_gen::val#1 ← (dword) lin16u_gen::val#2 + (dword) lin16u_gen::step#0 -- vduz1=vduz1_plus_vduz2 
    lda.z val
    clc
    adc.z step
    sta.z val
    lda.z val+1
    adc.z step+1
    sta.z val+1
    lda.z val+2
    adc.z step+2
    sta.z val+2
    lda.z val+3
    adc.z step+3
    sta.z val+3
    // lintab++;
    // [121] (word*) lin16u_gen::lintab#3 ← (word*) lin16u_gen::lintab#4 + (const byte) SIZEOF_WORD -- pwuz1=pwuz1_plus_vbuc1 
    lda #SIZEOF_WORD
    clc
    adc.z lintab
    sta.z lintab
    bcc !+
    inc.z lintab+1
  !:
    // for(word i=0; i<length; i++)
    // [122] (word) lin16u_gen::i#1 ← ++ (word) lin16u_gen::i#2 -- vwuz1=_inc_vwuz1 
    inc.z i
    bne !+
    inc.z i+1
  !:
    // [115] phi from lin16u_gen::@2 to lin16u_gen::@1 [phi:lin16u_gen::@2->lin16u_gen::@1]
    // [115] phi (word*) lin16u_gen::lintab#4 = (word*) lin16u_gen::lintab#3 [phi:lin16u_gen::@2->lin16u_gen::@1#0] -- register_copy 
    // [115] phi (dword) lin16u_gen::val#2 = (dword) lin16u_gen::val#1 [phi:lin16u_gen::@2->lin16u_gen::@1#1] -- register_copy 
    // [115] phi (word) lin16u_gen::i#2 = (word) lin16u_gen::i#1 [phi:lin16u_gen::@2->lin16u_gen::@1#2] -- register_copy 
    jmp __b1
}
  // divr16u
// Performs division on two 16 bit unsigned words and an initial remainder
// Returns the quotient dividend/divisor.
// The final remainder will be set into the global variable rem16u
// Implemented using simple binary division
// divr16u(word zp(3) dividend, word zp($d) divisor, word zp($17) rem)
divr16u: {
    .label rem = $17
    .label dividend = 3
    .label quotient = $f
    .label return = $f
    .label divisor = $d
    // [124] phi from divr16u to divr16u::@1 [phi:divr16u->divr16u::@1]
    // [124] phi (byte) divr16u::i#2 = (byte) 0 [phi:divr16u->divr16u::@1#0] -- vbuxx=vbuc1 
    ldx #0
    // [124] phi (word) divr16u::quotient#3 = (word) 0 [phi:divr16u->divr16u::@1#1] -- vwuz1=vwuc1 
    txa
    sta.z quotient
    sta.z quotient+1
    // [124] phi (word) divr16u::dividend#3 = (word) divr16u::dividend#5 [phi:divr16u->divr16u::@1#2] -- register_copy 
    // [124] phi (word) divr16u::rem#5 = (word) divr16u::rem#10 [phi:divr16u->divr16u::@1#3] -- register_copy 
    // [124] phi from divr16u::@3 to divr16u::@1 [phi:divr16u::@3->divr16u::@1]
    // [124] phi (byte) divr16u::i#2 = (byte) divr16u::i#1 [phi:divr16u::@3->divr16u::@1#0] -- register_copy 
    // [124] phi (word) divr16u::quotient#3 = (word) divr16u::return#0 [phi:divr16u::@3->divr16u::@1#1] -- register_copy 
    // [124] phi (word) divr16u::dividend#3 = (word) divr16u::dividend#0 [phi:divr16u::@3->divr16u::@1#2] -- register_copy 
    // [124] phi (word) divr16u::rem#5 = (word) divr16u::rem#11 [phi:divr16u::@3->divr16u::@1#3] -- register_copy 
    // divr16u::@1
  __b1:
    // rem = rem << 1
    // [125] (word) divr16u::rem#0 ← (word) divr16u::rem#5 << (byte) 1 -- vwuz1=vwuz1_rol_1 
    asl.z rem
    rol.z rem+1
    // >dividend
    // [126] (byte~) divr16u::$1 ← > (word) divr16u::dividend#3 -- vbuaa=_hi_vwuz1 
    lda.z dividend+1
    // >dividend & $80
    // [127] (byte~) divr16u::$2 ← (byte~) divr16u::$1 & (byte) $80 -- vbuaa=vbuaa_band_vbuc1 
    and #$80
    // if( (>dividend & $80) != 0 )
    // [128] if((byte~) divr16u::$2==(byte) 0) goto divr16u::@2 -- vbuaa_eq_0_then_la1 
    cmp #0
    beq __b2
    // divr16u::@4
    // rem = rem | 1
    // [129] (word) divr16u::rem#1 ← (word) divr16u::rem#0 | (byte) 1 -- vwuz1=vwuz1_bor_vbuc1 
    lda #1
    ora.z rem
    sta.z rem
    // [130] phi from divr16u::@1 divr16u::@4 to divr16u::@2 [phi:divr16u::@1/divr16u::@4->divr16u::@2]
    // [130] phi (word) divr16u::rem#6 = (word) divr16u::rem#0 [phi:divr16u::@1/divr16u::@4->divr16u::@2#0] -- register_copy 
    // divr16u::@2
  __b2:
    // dividend = dividend << 1
    // [131] (word) divr16u::dividend#0 ← (word) divr16u::dividend#3 << (byte) 1 -- vwuz1=vwuz1_rol_1 
    asl.z dividend
    rol.z dividend+1
    // quotient = quotient << 1
    // [132] (word) divr16u::quotient#1 ← (word) divr16u::quotient#3 << (byte) 1 -- vwuz1=vwuz1_rol_1 
    asl.z quotient
    rol.z quotient+1
    // if(rem>=divisor)
    // [133] if((word) divr16u::rem#6<(word) divr16u::divisor#6) goto divr16u::@3 -- vwuz1_lt_vwuz2_then_la1 
    lda.z rem+1
    cmp.z divisor+1
    bcc __b3
    bne !+
    lda.z rem
    cmp.z divisor
    bcc __b3
  !:
    // divr16u::@5
    // quotient++;
    // [134] (word) divr16u::quotient#2 ← ++ (word) divr16u::quotient#1 -- vwuz1=_inc_vwuz1 
    inc.z quotient
    bne !+
    inc.z quotient+1
  !:
    // rem = rem - divisor
    // [135] (word) divr16u::rem#2 ← (word) divr16u::rem#6 - (word) divr16u::divisor#6 -- vwuz1=vwuz1_minus_vwuz2 
    lda.z rem
    sec
    sbc.z divisor
    sta.z rem
    lda.z rem+1
    sbc.z divisor+1
    sta.z rem+1
    // [136] phi from divr16u::@2 divr16u::@5 to divr16u::@3 [phi:divr16u::@2/divr16u::@5->divr16u::@3]
    // [136] phi (word) divr16u::return#0 = (word) divr16u::quotient#1 [phi:divr16u::@2/divr16u::@5->divr16u::@3#0] -- register_copy 
    // [136] phi (word) divr16u::rem#11 = (word) divr16u::rem#6 [phi:divr16u::@2/divr16u::@5->divr16u::@3#1] -- register_copy 
    // divr16u::@3
  __b3:
    // for( byte i : 0..15)
    // [137] (byte) divr16u::i#1 ← ++ (byte) divr16u::i#2 -- vbuxx=_inc_vbuxx 
    inx
    // [138] if((byte) divr16u::i#1!=(byte) $10) goto divr16u::@1 -- vbuxx_neq_vbuc1_then_la1 
    cpx #$10
    bne __b1
    // divr16u::@6
    // rem16u = rem
    // [139] (word) rem16u#1 ← (word) divr16u::rem#11
    // divr16u::@return
    // }
    // [140] return 
    rts
}
  // File Data
  print_hextab: .text "0123456789abcdef"

