Fixing pointer increment (signed word*) sin16s_gen::sintab ← ++ (signed word*) sin16s_gen::sintab
Fixing pointer increment (signed word*) sin16s_gen2::sintab ← ++ (signed word*) sin16s_gen2::sintab
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 addition (signed word*~) main::$4 ← (const signed word*) main::sintabw + (word~) main::$3
Fixing pointer array-indexing *((word*) utoa::digit_values + (byte) utoa::digit)
Fixing pointer array-indexing *((dword*) ultoa::digit_values + (byte) ultoa::digit)
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
Identified constant variable (word) main::wavelength
Culled Empty Block (label) @1
Culled Empty Block (label) divr16u::@7
Culled Empty Block (label) @3
Culled Empty Block (label) div16u::@1
Culled Empty Block (label) @4
Culled Empty Block (label) div32u16u::@1
Culled Empty Block (label) @5
Culled Empty Block (label) @6
Culled Empty Block (label) @7
Culled Empty Block (label) @8
Culled Empty Block (label) mul8u::@5
Culled Empty Block (label) mul8u::@6
Culled Empty Block (label) mul8u::@8
Culled Empty Block (label) mul8u::@9
Culled Empty Block (label) @9
Culled Empty Block (label) @10
Culled Empty Block (label) @11
Culled Empty Block (label) mul16u::@5
Culled Empty Block (label) mul16u::@6
Culled Empty Block (label) mul16u::@8
Culled Empty Block (label) mul16u::@9
Culled Empty Block (label) @12
Culled Empty Block (label) @13
Culled Empty Block (label) sin16s_gen::@4
Culled Empty Block (label) sin16s_gen::@3
Culled Empty Block (label) sin16s_gen::@5
Culled Empty Block (label) sin16s_gen::@6
Culled Empty Block (label) @14
Culled Empty Block (label) @15
Culled Empty Block (label) sin8s_gen::@4
Culled Empty Block (label) sin8s_gen::@3
Culled Empty Block (label) sin8s_gen::@5
Culled Empty Block (label) sin8s_gen::@6
Culled Empty Block (label) @16
Culled Empty Block (label) sin16s::@7
Culled Empty Block (label) @17
Culled Empty Block (label) sin8s::@9
Culled Empty Block (label) @18
Culled Empty Block (label) mulu16_sel::@1
Culled Empty Block (label) @19
Culled Empty Block (label) mulu8_sel::@1
Culled Empty Block (label) @20
Culled Empty Block (label) @21
Culled Empty Block (label) @22
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) @23
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) @34
Culled Empty Block (label) @35
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) @36
Culled Empty Block (label) @37
Culled Empty Block (label) @38
Culled Empty Block (label) @39
Culled Empty Block (label) print_sbyte::@4
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) @46
Culled Empty Block (label) @47
Culled Empty Block (label) @48
Culled Empty Block (label) @49
Culled Empty Block (label) @50
Culled Empty Block (label) @51
Culled Empty Block (label) @52
Culled Empty Block (label) @53
Culled Empty Block (label) @54
Culled Empty Block (label) @55
Culled Empty Block (label) @56
Culled Empty Block (label) @57
Culled Empty Block (label) main::@2

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

(word()) divr16u((word) divr16u::dividend , (word) divr16u::divisor , (word) divr16u::rem)
divr16u: scope:[divr16u]  from div16u div32u16u div32u16u::@2
  (word) divr16u::divisor#7 ← phi( div16u/(word) divr16u::divisor#0 div32u16u/(word) divr16u::divisor#1 div32u16u::@2/(word) divr16u::divisor#2 )
  (word) divr16u::dividend#6 ← phi( div16u/(word) divr16u::dividend#1 div32u16u/(word) divr16u::dividend#2 div32u16u::@2/(word) divr16u::dividend#3 )
  (word) divr16u::rem#11 ← phi( div16u/(word) divr16u::rem#3 div32u16u/(word) divr16u::rem#4 div32u16u::@2/(word) divr16u::rem#5 )
  (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#5 ← phi( divr16u/(word) divr16u::divisor#7 divr16u::@3/(word) divr16u::divisor#8 )
  (word) divr16u::quotient#6 ← phi( divr16u/(word) divr16u::quotient#0 divr16u::@3/(word) divr16u::quotient#8 )
  (word) divr16u::dividend#4 ← phi( divr16u/(word) divr16u::dividend#6 divr16u::@3/(word) divr16u::dividend#7 )
  (word) divr16u::rem#6 ← phi( divr16u/(word) divr16u::rem#11 divr16u::@3/(word) divr16u::rem#12 )
  (word~) divr16u::$0 ← (word) divr16u::rem#6 << (number) 1
  (word) divr16u::rem#0 ← (word~) divr16u::$0
  (byte~) divr16u::$1 ← > (word) divr16u::dividend#4
  (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#3 ← phi( divr16u::@1/(word) divr16u::divisor#5 divr16u::@4/(word) divr16u::divisor#6 )
  (word) divr16u::rem#7 ← 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#5 ← phi( divr16u::@1/(word) divr16u::dividend#4 divr16u::@4/(word) divr16u::dividend#8 )
  (word~) divr16u::$6 ← (word) divr16u::dividend#5 << (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#7 >= (word) divr16u::divisor#3
  (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#6 ← phi( divr16u::@1/(word) divr16u::divisor#5 )
  (word) divr16u::quotient#7 ← phi( divr16u::@1/(word) divr16u::quotient#6 )
  (word) divr16u::dividend#8 ← phi( divr16u::@1/(word) divr16u::dividend#4 )
  (word) divr16u::rem#8 ← phi( divr16u::@1/(word) divr16u::rem#0 )
  (number~) divr16u::$5 ← (word) divr16u::rem#8 | (number) 1
  (word) divr16u::rem#1 ← (number~) divr16u::$5
  to:divr16u::@2
divr16u::@3: scope:[divr16u]  from divr16u::@2 divr16u::@5
  (word) divr16u::divisor#8 ← phi( divr16u::@2/(word) divr16u::divisor#3 divr16u::@5/(word) divr16u::divisor#4 )
  (word) divr16u::quotient#8 ← phi( divr16u::@2/(word) divr16u::quotient#1 divr16u::@5/(word) divr16u::quotient#2 )
  (word) divr16u::dividend#7 ← phi( divr16u::@2/(word) divr16u::dividend#0 divr16u::@5/(word) divr16u::dividend#9 )
  (word) divr16u::rem#12 ← phi( divr16u::@2/(word) divr16u::rem#7 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#9 ← phi( divr16u::@2/(word) divr16u::dividend#0 )
  (byte) divr16u::i#4 ← phi( divr16u::@2/(byte) divr16u::i#3 )
  (word) divr16u::divisor#4 ← phi( divr16u::@2/(word) divr16u::divisor#3 )
  (word) divr16u::rem#9 ← phi( divr16u::@2/(word) divr16u::rem#7 )
  (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#9 - (word) divr16u::divisor#4
  (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#10 ← phi( divr16u::@3/(word) divr16u::rem#12 )
  (word) rem16u#1 ← (word) divr16u::rem#10
  (word) divr16u::return#0 ← (word) divr16u::quotient#5
  to:divr16u::@return
divr16u::@return: scope:[divr16u]  from divr16u::@6
  (word) rem16u#16 ← phi( divr16u::@6/(word) rem16u#1 )
  (word) divr16u::return#5 ← phi( divr16u::@6/(word) divr16u::return#0 )
  (word) divr16u::return#1 ← (word) divr16u::return#5
  (word) rem16u#2 ← (word) rem16u#16
  return 
  to:@return

(word()) div16u((word) div16u::dividend , (word) div16u::divisor)
div16u: scope:[div16u]  from sin8s_gen
  (word) rem16u#30 ← phi( sin8s_gen/(word) rem16u#34 )
  (word) div16u::divisor#1 ← phi( sin8s_gen/(word) div16u::divisor#0 )
  (word) div16u::dividend#1 ← phi( sin8s_gen/(word) div16u::dividend#0 )
  (word) divr16u::dividend#1 ← (word) div16u::dividend#1
  (word) divr16u::divisor#0 ← (word) div16u::divisor#1
  (word) divr16u::rem#3 ← (number) 0
  call divr16u 
  (word) divr16u::return#2 ← (word) divr16u::return#1
  to:div16u::@2
div16u::@2: scope:[div16u]  from div16u
  (word) rem16u#17 ← phi( div16u/(word) rem16u#2 )
  (word) divr16u::return#6 ← phi( div16u/(word) divr16u::return#2 )
  (word~) div16u::$0 ← (word) divr16u::return#6
  (word) rem16u#3 ← (word) rem16u#17
  (word) div16u::return#0 ← (word~) div16u::$0
  to:div16u::@return
div16u::@return: scope:[div16u]  from div16u::@2
  (word) rem16u#18 ← phi( div16u::@2/(word) rem16u#3 )
  (word) div16u::return#3 ← phi( div16u::@2/(word) div16u::return#0 )
  (word) div16u::return#1 ← (word) div16u::return#3
  (word) rem16u#4 ← (word) rem16u#18
  return 
  to:@return

(dword()) div32u16u((dword) div32u16u::dividend , (word) div32u16u::divisor)
div32u16u: scope:[div32u16u]  from sin16s_gen
  (word) rem16u#31 ← phi( sin16s_gen/(word) rem16u#32 )
  (word) div32u16u::divisor#1 ← phi( sin16s_gen/(word) div32u16u::divisor#0 )
  (dword) div32u16u::dividend#1 ← phi( sin16s_gen/(dword) div32u16u::dividend#0 )
  (word~) div32u16u::$0 ← > (dword) div32u16u::dividend#1
  (word) divr16u::dividend#2 ← (word~) div32u16u::$0
  (word) divr16u::divisor#1 ← (word) div32u16u::divisor#1
  (word) divr16u::rem#4 ← (number) 0
  call divr16u 
  (word) divr16u::return#3 ← (word) divr16u::return#1
  to:div32u16u::@2
div32u16u::@2: scope:[div32u16u]  from div32u16u
  (word) div32u16u::divisor#2 ← phi( div32u16u/(word) div32u16u::divisor#1 )
  (dword) div32u16u::dividend#2 ← phi( div32u16u/(dword) div32u16u::dividend#1 )
  (word) rem16u#19 ← phi( div32u16u/(word) rem16u#2 )
  (word) divr16u::return#7 ← phi( div32u16u/(word) divr16u::return#3 )
  (word~) div32u16u::$1 ← (word) divr16u::return#7
  (word) rem16u#5 ← (word) rem16u#19
  (word) div32u16u::quotient_hi#0 ← (word~) div32u16u::$1
  (word~) div32u16u::$2 ← < (dword) div32u16u::dividend#2
  (word) divr16u::dividend#3 ← (word~) div32u16u::$2
  (word) divr16u::divisor#2 ← (word) div32u16u::divisor#2
  (word) divr16u::rem#5 ← (word) rem16u#5
  call divr16u 
  (word) divr16u::return#4 ← (word) divr16u::return#1
  to:div32u16u::@3
div32u16u::@3: scope:[div32u16u]  from div32u16u::@2
  (word) div32u16u::quotient_hi#1 ← phi( div32u16u::@2/(word) div32u16u::quotient_hi#0 )
  (word) rem16u#20 ← phi( div32u16u::@2/(word) rem16u#2 )
  (word) divr16u::return#8 ← phi( div32u16u::@2/(word) divr16u::return#4 )
  (word~) div32u16u::$3 ← (word) divr16u::return#8
  (word) rem16u#6 ← (word) rem16u#20
  (word) div32u16u::quotient_lo#0 ← (word~) div32u16u::$3
  (dword) div32u16u::quotient#0 ← (dword){ (word) div32u16u::quotient_hi#1, (word) div32u16u::quotient_lo#0 }
  (dword) div32u16u::return#0 ← (dword) div32u16u::quotient#0
  to:div32u16u::@return
div32u16u::@return: scope:[div32u16u]  from div32u16u::@3
  (word) rem16u#21 ← phi( div32u16u::@3/(word) rem16u#6 )
  (dword) div32u16u::return#3 ← phi( div32u16u::@3/(dword) div32u16u::return#0 )
  (dword) div32u16u::return#1 ← (dword) div32u16u::return#3
  (word) rem16u#7 ← (word) rem16u#21
  return 
  to:@return

(word()) mul8u((byte) mul8u::a , (byte) mul8u::b)
mul8u: scope:[mul8u]  from mulu8_sel
  (byte) mul8u::a#5 ← phi( mulu8_sel/(byte) mul8u::a#1 )
  (byte) mul8u::b#1 ← phi( mulu8_sel/(byte) mul8u::b#0 )
  (word) mul8u::res#0 ← (word) 0
  (word) mul8u::mb#0 ← (word)(byte) mul8u::b#1
  to:mul8u::@1
mul8u::@1: scope:[mul8u]  from mul8u mul8u::@4
  (word) mul8u::mb#5 ← phi( mul8u/(word) mul8u::mb#0 mul8u::@4/(word) mul8u::mb#1 )
  (word) mul8u::res#4 ← phi( mul8u/(word) mul8u::res#0 mul8u::@4/(word) mul8u::res#6 )
  (byte) mul8u::a#2 ← phi( mul8u/(byte) mul8u::a#5 mul8u::@4/(byte) mul8u::a#0 )
  (bool~) mul8u::$0 ← (byte) mul8u::a#2 != (number) 0
  if((bool~) mul8u::$0) goto mul8u::@2
  to:mul8u::@3
mul8u::@2: scope:[mul8u]  from mul8u::@1
  (word) mul8u::res#5 ← phi( mul8u::@1/(word) mul8u::res#4 )
  (word) mul8u::mb#4 ← phi( mul8u::@1/(word) mul8u::mb#5 )
  (byte) mul8u::a#3 ← phi( mul8u::@1/(byte) mul8u::a#2 )
  (number~) mul8u::$1 ← (byte) mul8u::a#3 & (number) 1
  (bool~) mul8u::$2 ← (number~) mul8u::$1 != (number) 0
  (bool~) mul8u::$3 ← ! (bool~) mul8u::$2
  if((bool~) mul8u::$3) goto mul8u::@4
  to:mul8u::@7
mul8u::@3: scope:[mul8u]  from mul8u::@1
  (word) mul8u::res#2 ← phi( mul8u::@1/(word) mul8u::res#4 )
  (word) mul8u::return#0 ← (word) mul8u::res#2
  to:mul8u::@return
mul8u::@4: scope:[mul8u]  from mul8u::@2 mul8u::@7
  (word) mul8u::res#6 ← phi( mul8u::@2/(word) mul8u::res#5 mul8u::@7/(word) mul8u::res#1 )
  (word) mul8u::mb#2 ← phi( mul8u::@2/(word) mul8u::mb#4 mul8u::@7/(word) mul8u::mb#3 )
  (byte) mul8u::a#4 ← phi( mul8u::@2/(byte) mul8u::a#3 mul8u::@7/(byte) mul8u::a#6 )
  (byte~) mul8u::$5 ← (byte) mul8u::a#4 >> (number) 1
  (byte) mul8u::a#0 ← (byte~) mul8u::$5
  (word~) mul8u::$6 ← (word) mul8u::mb#2 << (number) 1
  (word) mul8u::mb#1 ← (word~) mul8u::$6
  to:mul8u::@1
mul8u::@7: scope:[mul8u]  from mul8u::@2
  (byte) mul8u::a#6 ← phi( mul8u::@2/(byte) mul8u::a#3 )
  (word) mul8u::mb#3 ← phi( mul8u::@2/(word) mul8u::mb#4 )
  (word) mul8u::res#3 ← phi( mul8u::@2/(word) mul8u::res#5 )
  (word~) mul8u::$4 ← (word) mul8u::res#3 + (word) mul8u::mb#3
  (word) mul8u::res#1 ← (word~) mul8u::$4
  to:mul8u::@4
mul8u::@return: scope:[mul8u]  from mul8u::@3
  (word) mul8u::return#3 ← phi( mul8u::@3/(word) mul8u::return#0 )
  (word) mul8u::return#1 ← (word) mul8u::return#3
  return 
  to:@return

(dword()) mul16u((word) mul16u::a , (word) mul16u::b)
mul16u: scope:[mul16u]  from mulu16_sel
  (word) mul16u::a#5 ← phi( mulu16_sel/(word) mul16u::a#1 )
  (word) mul16u::b#1 ← phi( mulu16_sel/(word) mul16u::b#0 )
  (dword) mul16u::res#0 ← (dword) 0
  (dword) mul16u::mb#0 ← (dword)(word) mul16u::b#1
  to:mul16u::@1
mul16u::@1: scope:[mul16u]  from mul16u mul16u::@4
  (dword) mul16u::mb#5 ← phi( mul16u/(dword) mul16u::mb#0 mul16u::@4/(dword) mul16u::mb#1 )
  (dword) mul16u::res#4 ← phi( mul16u/(dword) mul16u::res#0 mul16u::@4/(dword) mul16u::res#6 )
  (word) mul16u::a#2 ← phi( mul16u/(word) mul16u::a#5 mul16u::@4/(word) mul16u::a#0 )
  (bool~) mul16u::$0 ← (word) mul16u::a#2 != (number) 0
  if((bool~) mul16u::$0) goto mul16u::@2
  to:mul16u::@3
mul16u::@2: scope:[mul16u]  from mul16u::@1
  (dword) mul16u::res#5 ← phi( mul16u::@1/(dword) mul16u::res#4 )
  (dword) mul16u::mb#4 ← phi( mul16u::@1/(dword) mul16u::mb#5 )
  (word) mul16u::a#3 ← phi( mul16u::@1/(word) mul16u::a#2 )
  (number~) mul16u::$1 ← (word) mul16u::a#3 & (number) 1
  (bool~) mul16u::$2 ← (number~) mul16u::$1 != (number) 0
  (bool~) mul16u::$3 ← ! (bool~) mul16u::$2
  if((bool~) mul16u::$3) goto mul16u::@4
  to:mul16u::@7
mul16u::@3: scope:[mul16u]  from mul16u::@1
  (dword) mul16u::res#2 ← phi( mul16u::@1/(dword) mul16u::res#4 )
  (dword) mul16u::return#0 ← (dword) mul16u::res#2
  to:mul16u::@return
mul16u::@4: scope:[mul16u]  from mul16u::@2 mul16u::@7
  (dword) mul16u::res#6 ← phi( mul16u::@2/(dword) mul16u::res#5 mul16u::@7/(dword) mul16u::res#1 )
  (dword) mul16u::mb#2 ← phi( mul16u::@2/(dword) mul16u::mb#4 mul16u::@7/(dword) mul16u::mb#3 )
  (word) mul16u::a#4 ← phi( mul16u::@2/(word) mul16u::a#3 mul16u::@7/(word) mul16u::a#6 )
  (word~) mul16u::$5 ← (word) mul16u::a#4 >> (number) 1
  (word) mul16u::a#0 ← (word~) mul16u::$5
  (dword~) mul16u::$6 ← (dword) mul16u::mb#2 << (number) 1
  (dword) mul16u::mb#1 ← (dword~) mul16u::$6
  to:mul16u::@1
mul16u::@7: scope:[mul16u]  from mul16u::@2
  (word) mul16u::a#6 ← phi( mul16u::@2/(word) mul16u::a#3 )
  (dword) mul16u::mb#3 ← phi( mul16u::@2/(dword) mul16u::mb#4 )
  (dword) mul16u::res#3 ← phi( mul16u::@2/(dword) mul16u::res#5 )
  (dword~) mul16u::$4 ← (dword) mul16u::res#3 + (dword) mul16u::mb#3
  (dword) mul16u::res#1 ← (dword~) mul16u::$4
  to:mul16u::@4
mul16u::@return: scope:[mul16u]  from mul16u::@3
  (dword) mul16u::return#3 ← phi( mul16u::@3/(dword) mul16u::return#0 )
  (dword) mul16u::return#1 ← (dword) mul16u::return#3
  return 
  to:@return

(void()) sin16s_gen((signed word*) sin16s_gen::sintab , (word) sin16s_gen::wavelength)
sin16s_gen: scope:[sin16s_gen]  from main::@3
  (signed word*) sin16s_gen::sintab#6 ← phi( main::@3/(signed word*) sin16s_gen::sintab#1 )
  (word) rem16u#32 ← phi( main::@3/(word) rem16u#12 )
  (word) sin16s_gen::wavelength#1 ← phi( main::@3/(word) sin16s_gen::wavelength#0 )
  (dword) div32u16u::dividend#0 ← (const dword) PI2_u4f28
  (word) div32u16u::divisor#0 ← (word) sin16s_gen::wavelength#1
  call div32u16u 
  (dword) div32u16u::return#2 ← (dword) div32u16u::return#1
  to:sin16s_gen::@7
sin16s_gen::@7: scope:[sin16s_gen]  from sin16s_gen
  (signed word*) sin16s_gen::sintab#5 ← phi( sin16s_gen/(signed word*) sin16s_gen::sintab#6 )
  (word) sin16s_gen::wavelength#3 ← phi( sin16s_gen/(word) sin16s_gen::wavelength#1 )
  (word) rem16u#22 ← phi( sin16s_gen/(word) rem16u#7 )
  (dword) div32u16u::return#4 ← phi( sin16s_gen/(dword) div32u16u::return#2 )
  (dword~) sin16s_gen::$0 ← (dword) div32u16u::return#4
  (word) rem16u#8 ← (word) rem16u#22
  (dword) sin16s_gen::step#0 ← (dword~) sin16s_gen::$0
  (dword) sin16s_gen::x#0 ← (dword) 0
  (word) sin16s_gen::i#0 ← (word) 0
  to:sin16s_gen::@1
sin16s_gen::@1: scope:[sin16s_gen]  from sin16s_gen::@7 sin16s_gen::@8
  (dword) sin16s_gen::step#3 ← phi( sin16s_gen::@7/(dword) sin16s_gen::step#0 sin16s_gen::@8/(dword) sin16s_gen::step#1 )
  (signed word*) sin16s_gen::sintab#4 ← phi( sin16s_gen::@7/(signed word*) sin16s_gen::sintab#5 sin16s_gen::@8/(signed word*) sin16s_gen::sintab#0 )
  (word) rem16u#33 ← phi( sin16s_gen::@7/(word) rem16u#8 sin16s_gen::@8/(word) rem16u#39 )
  (dword) sin16s_gen::x#4 ← phi( sin16s_gen::@7/(dword) sin16s_gen::x#0 sin16s_gen::@8/(dword) sin16s_gen::x#1 )
  (word) sin16s_gen::wavelength#2 ← phi( sin16s_gen::@7/(word) sin16s_gen::wavelength#3 sin16s_gen::@8/(word) sin16s_gen::wavelength#4 )
  (word) sin16s_gen::i#2 ← phi( sin16s_gen::@7/(word) sin16s_gen::i#0 sin16s_gen::@8/(word) sin16s_gen::i#1 )
  (bool~) sin16s_gen::$1 ← (word) sin16s_gen::i#2 < (word) sin16s_gen::wavelength#2
  if((bool~) sin16s_gen::$1) goto sin16s_gen::@2
  to:sin16s_gen::@return
sin16s_gen::@2: scope:[sin16s_gen]  from sin16s_gen::@1
  (word) rem16u#43 ← phi( sin16s_gen::@1/(word) rem16u#33 )
  (word) sin16s_gen::wavelength#5 ← phi( sin16s_gen::@1/(word) sin16s_gen::wavelength#2 )
  (word) sin16s_gen::i#4 ← phi( sin16s_gen::@1/(word) sin16s_gen::i#2 )
  (dword) sin16s_gen::step#2 ← phi( sin16s_gen::@1/(dword) sin16s_gen::step#3 )
  (signed word*) sin16s_gen::sintab#3 ← phi( sin16s_gen::@1/(signed word*) sin16s_gen::sintab#4 )
  (dword) sin16s_gen::x#2 ← phi( sin16s_gen::@1/(dword) sin16s_gen::x#4 )
  (dword) sin16s::x#0 ← (dword) sin16s_gen::x#2
  call sin16s 
  (signed word) sin16s::return#0 ← (signed word) sin16s::return#2
  to:sin16s_gen::@8
sin16s_gen::@8: scope:[sin16s_gen]  from sin16s_gen::@2
  (word) rem16u#39 ← phi( sin16s_gen::@2/(word) rem16u#43 )
  (word) sin16s_gen::wavelength#4 ← phi( sin16s_gen::@2/(word) sin16s_gen::wavelength#5 )
  (word) sin16s_gen::i#3 ← phi( sin16s_gen::@2/(word) sin16s_gen::i#4 )
  (dword) sin16s_gen::step#1 ← phi( sin16s_gen::@2/(dword) sin16s_gen::step#2 )
  (dword) sin16s_gen::x#3 ← phi( sin16s_gen::@2/(dword) sin16s_gen::x#2 )
  (signed word*) sin16s_gen::sintab#2 ← phi( sin16s_gen::@2/(signed word*) sin16s_gen::sintab#3 )
  (signed word) sin16s::return#3 ← phi( sin16s_gen::@2/(signed word) sin16s::return#0 )
  (signed word~) sin16s_gen::$2 ← (signed word) sin16s::return#3
  *((signed word*) sin16s_gen::sintab#2) ← (signed word~) sin16s_gen::$2
  (signed word*) sin16s_gen::sintab#0 ← (signed word*) sin16s_gen::sintab#2 + (const byte) SIZEOF_SIGNED_WORD
  (dword~) sin16s_gen::$3 ← (dword) sin16s_gen::x#3 + (dword) sin16s_gen::step#1
  (dword) sin16s_gen::x#1 ← (dword~) sin16s_gen::$3
  (word) sin16s_gen::i#1 ← ++ (word) sin16s_gen::i#3
  to:sin16s_gen::@1
sin16s_gen::@return: scope:[sin16s_gen]  from sin16s_gen::@1
  (word) rem16u#23 ← phi( sin16s_gen::@1/(word) rem16u#33 )
  (word) rem16u#9 ← (word) rem16u#23
  return 
  to:@return

(void()) sin8s_gen((signed byte*) sin8s_gen::sintab , (word) sin8s_gen::wavelength)
sin8s_gen: scope:[sin8s_gen]  from main
  (signed byte*) sin8s_gen::sintab#6 ← phi( main/(signed byte*) sin8s_gen::sintab#1 )
  (word) rem16u#34 ← phi( main/(word) rem16u#36 )
  (word) sin8s_gen::wavelength#1 ← phi( main/(word) sin8s_gen::wavelength#0 )
  (word) div16u::dividend#0 ← (const word) PI2_u4f12
  (word) div16u::divisor#0 ← (word) sin8s_gen::wavelength#1
  call div16u 
  (word) div16u::return#2 ← (word) div16u::return#1
  to:sin8s_gen::@7
sin8s_gen::@7: scope:[sin8s_gen]  from sin8s_gen
  (signed byte*) sin8s_gen::sintab#5 ← phi( sin8s_gen/(signed byte*) sin8s_gen::sintab#6 )
  (word) sin8s_gen::wavelength#3 ← phi( sin8s_gen/(word) sin8s_gen::wavelength#1 )
  (word) rem16u#24 ← phi( sin8s_gen/(word) rem16u#4 )
  (word) div16u::return#4 ← phi( sin8s_gen/(word) div16u::return#2 )
  (word~) sin8s_gen::$0 ← (word) div16u::return#4
  (word) rem16u#10 ← (word) rem16u#24
  (word) sin8s_gen::step#0 ← (word~) sin8s_gen::$0
  (word) sin8s_gen::x#0 ← (word) 0
  (word) sin8s_gen::i#0 ← (word) 0
  to:sin8s_gen::@1
sin8s_gen::@1: scope:[sin8s_gen]  from sin8s_gen::@7 sin8s_gen::@8
  (word) sin8s_gen::step#3 ← phi( sin8s_gen::@7/(word) sin8s_gen::step#0 sin8s_gen::@8/(word) sin8s_gen::step#1 )
  (signed byte*) sin8s_gen::sintab#4 ← phi( sin8s_gen::@7/(signed byte*) sin8s_gen::sintab#5 sin8s_gen::@8/(signed byte*) sin8s_gen::sintab#0 )
  (word) rem16u#35 ← phi( sin8s_gen::@7/(word) rem16u#10 sin8s_gen::@8/(word) rem16u#40 )
  (word) sin8s_gen::x#4 ← phi( sin8s_gen::@7/(word) sin8s_gen::x#0 sin8s_gen::@8/(word) sin8s_gen::x#1 )
  (word) sin8s_gen::wavelength#2 ← phi( sin8s_gen::@7/(word) sin8s_gen::wavelength#3 sin8s_gen::@8/(word) sin8s_gen::wavelength#4 )
  (word) sin8s_gen::i#2 ← phi( sin8s_gen::@7/(word) sin8s_gen::i#0 sin8s_gen::@8/(word) sin8s_gen::i#1 )
  (bool~) sin8s_gen::$1 ← (word) sin8s_gen::i#2 < (word) sin8s_gen::wavelength#2
  if((bool~) sin8s_gen::$1) goto sin8s_gen::@2
  to:sin8s_gen::@return
sin8s_gen::@2: scope:[sin8s_gen]  from sin8s_gen::@1
  (word) rem16u#44 ← phi( sin8s_gen::@1/(word) rem16u#35 )
  (word) sin8s_gen::wavelength#5 ← phi( sin8s_gen::@1/(word) sin8s_gen::wavelength#2 )
  (word) sin8s_gen::i#4 ← phi( sin8s_gen::@1/(word) sin8s_gen::i#2 )
  (word) sin8s_gen::step#2 ← phi( sin8s_gen::@1/(word) sin8s_gen::step#3 )
  (signed byte*) sin8s_gen::sintab#3 ← phi( sin8s_gen::@1/(signed byte*) sin8s_gen::sintab#4 )
  (word) sin8s_gen::x#2 ← phi( sin8s_gen::@1/(word) sin8s_gen::x#4 )
  (word) sin8s::x#0 ← (word) sin8s_gen::x#2
  call sin8s 
  (signed byte) sin8s::return#0 ← (signed byte) sin8s::return#2
  to:sin8s_gen::@8
sin8s_gen::@8: scope:[sin8s_gen]  from sin8s_gen::@2
  (word) rem16u#40 ← phi( sin8s_gen::@2/(word) rem16u#44 )
  (word) sin8s_gen::wavelength#4 ← phi( sin8s_gen::@2/(word) sin8s_gen::wavelength#5 )
  (word) sin8s_gen::i#3 ← phi( sin8s_gen::@2/(word) sin8s_gen::i#4 )
  (word) sin8s_gen::step#1 ← phi( sin8s_gen::@2/(word) sin8s_gen::step#2 )
  (word) sin8s_gen::x#3 ← phi( sin8s_gen::@2/(word) sin8s_gen::x#2 )
  (signed byte*) sin8s_gen::sintab#2 ← phi( sin8s_gen::@2/(signed byte*) sin8s_gen::sintab#3 )
  (signed byte) sin8s::return#3 ← phi( sin8s_gen::@2/(signed byte) sin8s::return#0 )
  (signed byte~) sin8s_gen::$2 ← (signed byte) sin8s::return#3
  *((signed byte*) sin8s_gen::sintab#2) ← (signed byte~) sin8s_gen::$2
  (signed byte*) sin8s_gen::sintab#0 ← ++ (signed byte*) sin8s_gen::sintab#2
  (word~) sin8s_gen::$3 ← (word) sin8s_gen::x#3 + (word) sin8s_gen::step#1
  (word) sin8s_gen::x#1 ← (word~) sin8s_gen::$3
  (word) sin8s_gen::i#1 ← ++ (word) sin8s_gen::i#3
  to:sin8s_gen::@1
sin8s_gen::@return: scope:[sin8s_gen]  from sin8s_gen::@1
  (word) rem16u#25 ← phi( sin8s_gen::@1/(word) rem16u#35 )
  (word) rem16u#11 ← (word) rem16u#25
  return 
  to:@return

(signed word()) sin16s((dword) sin16s::x)
sin16s: scope:[sin16s]  from sin16s_gen::@2
  (dword) sin16s::x#3 ← phi( sin16s_gen::@2/(dword) sin16s::x#0 )
  (byte) sin16s::isUpper#0 ← (byte) 0
  (bool~) sin16s::$0 ← (dword) sin16s::x#3 >= (const dword) PI_u4f28
  (bool~) sin16s::$1 ← ! (bool~) sin16s::$0
  if((bool~) sin16s::$1) goto sin16s::@1
  to:sin16s::@4
sin16s::@1: scope:[sin16s]  from sin16s sin16s::@4
  (byte) sin16s::isUpper#8 ← phi( sin16s/(byte) sin16s::isUpper#0 sin16s::@4/(byte) sin16s::isUpper#1 )
  (dword) sin16s::x#4 ← phi( sin16s/(dword) sin16s::x#3 sin16s::@4/(dword) sin16s::x#1 )
  (bool~) sin16s::$2 ← (dword) sin16s::x#4 >= (const dword) PI_HALF_u4f28
  (bool~) sin16s::$3 ← ! (bool~) sin16s::$2
  if((bool~) sin16s::$3) goto sin16s::@2
  to:sin16s::@5
sin16s::@4: scope:[sin16s]  from sin16s
  (dword) sin16s::x#5 ← phi( sin16s/(dword) sin16s::x#3 )
  (dword~) sin16s::$17 ← (dword) sin16s::x#5 - (const dword) PI_u4f28
  (dword) sin16s::x#1 ← (dword~) sin16s::$17
  (byte) sin16s::isUpper#1 ← (number) 1
  to:sin16s::@1
sin16s::@2: scope:[sin16s]  from sin16s::@1 sin16s::@5
  (byte) sin16s::isUpper#7 ← phi( sin16s::@1/(byte) sin16s::isUpper#8 sin16s::@5/(byte) sin16s::isUpper#9 )
  (dword) sin16s::x#6 ← phi( sin16s::@1/(dword) sin16s::x#4 sin16s::@5/(dword) sin16s::x#2 )
  (dword~) sin16s::$4 ← (dword) sin16s::x#6 << (number) 3
  (word~) sin16s::$5 ← > (dword~) sin16s::$4
  (word) sin16s::x1#0 ← (word~) sin16s::$5
  (word) mulu16_sel::v1#0 ← (word) sin16s::x1#0
  (word) mulu16_sel::v2#0 ← (word) sin16s::x1#0
  (byte) mulu16_sel::select#0 ← (number) 0
  call mulu16_sel 
  (word) mulu16_sel::return#0 ← (word) mulu16_sel::return#6
  to:sin16s::@8
sin16s::@8: scope:[sin16s]  from sin16s::@2
  (byte) sin16s::isUpper#6 ← phi( sin16s::@2/(byte) sin16s::isUpper#7 )
  (word) sin16s::x1#1 ← phi( sin16s::@2/(word) sin16s::x1#0 )
  (word) mulu16_sel::return#7 ← phi( sin16s::@2/(word) mulu16_sel::return#0 )
  (word~) sin16s::$6 ← (word) mulu16_sel::return#7
  (word) sin16s::x2#0 ← (word~) sin16s::$6
  (word) mulu16_sel::v1#1 ← (word) sin16s::x2#0
  (word) mulu16_sel::v2#1 ← (word) sin16s::x1#1
  (byte) mulu16_sel::select#1 ← (number) 1
  call mulu16_sel 
  (word) mulu16_sel::return#1 ← (word) mulu16_sel::return#6
  to:sin16s::@9
sin16s::@9: scope:[sin16s]  from sin16s::@8
  (byte) sin16s::isUpper#5 ← phi( sin16s::@8/(byte) sin16s::isUpper#6 )
  (word) sin16s::x1#4 ← phi( sin16s::@8/(word) sin16s::x1#1 )
  (word) mulu16_sel::return#8 ← phi( sin16s::@8/(word) mulu16_sel::return#1 )
  (word~) sin16s::$7 ← (word) mulu16_sel::return#8
  (word) sin16s::x3#0 ← (word~) sin16s::$7
  (word) mulu16_sel::v1#2 ← (word) sin16s::x3#0
  (word) mulu16_sel::v2#2 ← (number) $10000/(number) 6
  (byte) mulu16_sel::select#2 ← (number) 1
  call mulu16_sel 
  (word) mulu16_sel::return#2 ← (word) mulu16_sel::return#6
  to:sin16s::@10
sin16s::@10: scope:[sin16s]  from sin16s::@9
  (byte) sin16s::isUpper#4 ← phi( sin16s::@9/(byte) sin16s::isUpper#5 )
  (word) sin16s::x3#1 ← phi( sin16s::@9/(word) sin16s::x3#0 )
  (word) sin16s::x1#2 ← phi( sin16s::@9/(word) sin16s::x1#4 )
  (word) mulu16_sel::return#9 ← phi( sin16s::@9/(word) mulu16_sel::return#2 )
  (word~) sin16s::$8 ← (word) mulu16_sel::return#9
  (word) sin16s::x3_6#0 ← (word~) sin16s::$8
  (word~) sin16s::$9 ← (word) sin16s::x1#2 - (word) sin16s::x3_6#0
  (word) sin16s::usinx#0 ← (word~) sin16s::$9
  (word) mulu16_sel::v1#3 ← (word) sin16s::x3#1
  (word) mulu16_sel::v2#3 ← (word) sin16s::x1#2
  (byte) mulu16_sel::select#3 ← (number) 0
  call mulu16_sel 
  (word) mulu16_sel::return#3 ← (word) mulu16_sel::return#6
  to:sin16s::@11
sin16s::@11: scope:[sin16s]  from sin16s::@10
  (byte) sin16s::isUpper#3 ← phi( sin16s::@10/(byte) sin16s::isUpper#4 )
  (word) sin16s::usinx#4 ← phi( sin16s::@10/(word) sin16s::usinx#0 )
  (word) sin16s::x1#3 ← phi( sin16s::@10/(word) sin16s::x1#2 )
  (word) mulu16_sel::return#10 ← phi( sin16s::@10/(word) mulu16_sel::return#3 )
  (word~) sin16s::$10 ← (word) mulu16_sel::return#10
  (word) sin16s::x4#0 ← (word~) sin16s::$10
  (word) mulu16_sel::v1#4 ← (word) sin16s::x4#0
  (word) mulu16_sel::v2#4 ← (word) sin16s::x1#3
  (byte) mulu16_sel::select#4 ← (number) 0
  call mulu16_sel 
  (word) mulu16_sel::return#4 ← (word) mulu16_sel::return#6
  to:sin16s::@12
sin16s::@12: scope:[sin16s]  from sin16s::@11
  (byte) sin16s::isUpper#2 ← phi( sin16s::@11/(byte) sin16s::isUpper#3 )
  (word) sin16s::usinx#2 ← phi( sin16s::@11/(word) sin16s::usinx#4 )
  (word) mulu16_sel::return#11 ← phi( sin16s::@11/(word) mulu16_sel::return#4 )
  (word~) sin16s::$11 ← (word) mulu16_sel::return#11
  (word) sin16s::x5#0 ← (word~) sin16s::$11
  (word~) sin16s::$12 ← (word) sin16s::x5#0 >> (number) 4
  (word) sin16s::x5_128#0 ← (word~) sin16s::$12
  (word~) sin16s::$13 ← (word) sin16s::usinx#2 + (word) sin16s::x5_128#0
  (word) sin16s::usinx#1 ← (word~) sin16s::$13
  (signed word~) sin16s::$14 ← ((signed word)) (word) sin16s::usinx#1
  (signed word) sin16s::sinx#0 ← (signed word~) sin16s::$14
  (bool~) sin16s::$15 ← (byte) sin16s::isUpper#2 != (number) 0
  (bool~) sin16s::$16 ← ! (bool~) sin16s::$15
  if((bool~) sin16s::$16) goto sin16s::@3
  to:sin16s::@6
sin16s::@5: scope:[sin16s]  from sin16s::@1
  (byte) sin16s::isUpper#9 ← phi( sin16s::@1/(byte) sin16s::isUpper#8 )
  (dword) sin16s::x#7 ← phi( sin16s::@1/(dword) sin16s::x#4 )
  (dword~) sin16s::$18 ← (const dword) PI_u4f28 - (dword) sin16s::x#7
  (dword) sin16s::x#2 ← (dword~) sin16s::$18
  to:sin16s::@2
sin16s::@3: scope:[sin16s]  from sin16s::@12 sin16s::@6
  (signed word) sin16s::sinx#2 ← phi( sin16s::@12/(signed word) sin16s::sinx#0 sin16s::@6/(signed word) sin16s::sinx#1 )
  (signed word) sin16s::return#1 ← (signed word) sin16s::sinx#2
  to:sin16s::@return
sin16s::@6: scope:[sin16s]  from sin16s::@12
  (word) sin16s::usinx#3 ← phi( sin16s::@12/(word) sin16s::usinx#1 )
  (signed word~) sin16s::$19 ← ((signed word)) (word) sin16s::usinx#3
  (signed word~) sin16s::$20 ← - (signed word~) sin16s::$19
  (signed word) sin16s::sinx#1 ← (signed word~) sin16s::$20
  to:sin16s::@3
sin16s::@return: scope:[sin16s]  from sin16s::@3
  (signed word) sin16s::return#4 ← phi( sin16s::@3/(signed word) sin16s::return#1 )
  (signed word) sin16s::return#2 ← (signed word) sin16s::return#4
  return 
  to:@return

(signed byte()) sin8s((word) sin8s::x)
sin8s: scope:[sin8s]  from sin8s_gen::@2
  (word) sin8s::x#3 ← phi( sin8s_gen::@2/(word) sin8s::x#0 )
  (byte) sin8s::isUpper#0 ← (byte) 0
  (bool~) sin8s::$0 ← (word) sin8s::x#3 >= (const word) PI_u4f12
  (bool~) sin8s::$1 ← ! (bool~) sin8s::$0
  if((bool~) sin8s::$1) goto sin8s::@1
  to:sin8s::@5
sin8s::@1: scope:[sin8s]  from sin8s sin8s::@5
  (byte) sin8s::isUpper#10 ← phi( sin8s/(byte) sin8s::isUpper#0 sin8s::@5/(byte) sin8s::isUpper#1 )
  (word) sin8s::x#4 ← phi( sin8s/(word) sin8s::x#3 sin8s::@5/(word) sin8s::x#1 )
  (bool~) sin8s::$2 ← (word) sin8s::x#4 >= (const word) PI_HALF_u4f12
  (bool~) sin8s::$3 ← ! (bool~) sin8s::$2
  if((bool~) sin8s::$3) goto sin8s::@2
  to:sin8s::@6
sin8s::@5: scope:[sin8s]  from sin8s
  (word) sin8s::x#5 ← phi( sin8s/(word) sin8s::x#3 )
  (word~) sin8s::$19 ← (word) sin8s::x#5 - (const word) PI_u4f12
  (word) sin8s::x#1 ← (word~) sin8s::$19
  (byte) sin8s::isUpper#1 ← (number) 1
  to:sin8s::@1
sin8s::@2: scope:[sin8s]  from sin8s::@1 sin8s::@6
  (byte) sin8s::isUpper#9 ← phi( sin8s::@1/(byte) sin8s::isUpper#10 sin8s::@6/(byte) sin8s::isUpper#11 )
  (word) sin8s::x#6 ← phi( sin8s::@1/(word) sin8s::x#4 sin8s::@6/(word) sin8s::x#2 )
  (word~) sin8s::$4 ← (word) sin8s::x#6 << (number) 3
  (byte~) sin8s::$5 ← > (word~) sin8s::$4
  (byte) sin8s::x1#0 ← (byte~) sin8s::$5
  (byte) mulu8_sel::v1#0 ← (byte) sin8s::x1#0
  (byte) mulu8_sel::v2#0 ← (byte) sin8s::x1#0
  (byte) mulu8_sel::select#0 ← (number) 0
  call mulu8_sel 
  (byte) mulu8_sel::return#0 ← (byte) mulu8_sel::return#6
  to:sin8s::@10
sin8s::@10: scope:[sin8s]  from sin8s::@2
  (byte) sin8s::isUpper#8 ← phi( sin8s::@2/(byte) sin8s::isUpper#9 )
  (byte) sin8s::x1#1 ← phi( sin8s::@2/(byte) sin8s::x1#0 )
  (byte) mulu8_sel::return#7 ← phi( sin8s::@2/(byte) mulu8_sel::return#0 )
  (byte~) sin8s::$6 ← (byte) mulu8_sel::return#7
  (byte) sin8s::x2#0 ← (byte~) sin8s::$6
  (byte) mulu8_sel::v1#1 ← (byte) sin8s::x2#0
  (byte) mulu8_sel::v2#1 ← (byte) sin8s::x1#1
  (byte) mulu8_sel::select#1 ← (number) 1
  call mulu8_sel 
  (byte) mulu8_sel::return#1 ← (byte) mulu8_sel::return#6
  to:sin8s::@11
sin8s::@11: scope:[sin8s]  from sin8s::@10
  (byte) sin8s::isUpper#7 ← phi( sin8s::@10/(byte) sin8s::isUpper#8 )
  (byte) sin8s::x1#4 ← phi( sin8s::@10/(byte) sin8s::x1#1 )
  (byte) mulu8_sel::return#8 ← phi( sin8s::@10/(byte) mulu8_sel::return#1 )
  (byte~) sin8s::$7 ← (byte) mulu8_sel::return#8
  (byte) sin8s::x3#0 ← (byte~) sin8s::$7
  (byte) mulu8_sel::v1#2 ← (byte) sin8s::x3#0
  (byte) mulu8_sel::v2#2 ← (const byte) sin8s::DIV_6
  (byte) mulu8_sel::select#2 ← (number) 1
  call mulu8_sel 
  (byte) mulu8_sel::return#2 ← (byte) mulu8_sel::return#6
  to:sin8s::@12
sin8s::@12: scope:[sin8s]  from sin8s::@11
  (byte) sin8s::isUpper#6 ← phi( sin8s::@11/(byte) sin8s::isUpper#7 )
  (byte) sin8s::x3#1 ← phi( sin8s::@11/(byte) sin8s::x3#0 )
  (byte) sin8s::x1#2 ← phi( sin8s::@11/(byte) sin8s::x1#4 )
  (byte) mulu8_sel::return#9 ← phi( sin8s::@11/(byte) mulu8_sel::return#2 )
  (byte~) sin8s::$8 ← (byte) mulu8_sel::return#9
  (byte) sin8s::x3_6#0 ← (byte~) sin8s::$8
  (byte~) sin8s::$9 ← (byte) sin8s::x1#2 - (byte) sin8s::x3_6#0
  (byte) sin8s::usinx#0 ← (byte~) sin8s::$9
  (byte) mulu8_sel::v1#3 ← (byte) sin8s::x3#1
  (byte) mulu8_sel::v2#3 ← (byte) sin8s::x1#2
  (byte) mulu8_sel::select#3 ← (number) 0
  call mulu8_sel 
  (byte) mulu8_sel::return#3 ← (byte) mulu8_sel::return#6
  to:sin8s::@13
sin8s::@13: scope:[sin8s]  from sin8s::@12
  (byte) sin8s::isUpper#5 ← phi( sin8s::@12/(byte) sin8s::isUpper#6 )
  (byte) sin8s::usinx#7 ← phi( sin8s::@12/(byte) sin8s::usinx#0 )
  (byte) sin8s::x1#3 ← phi( sin8s::@12/(byte) sin8s::x1#2 )
  (byte) mulu8_sel::return#10 ← phi( sin8s::@12/(byte) mulu8_sel::return#3 )
  (byte~) sin8s::$10 ← (byte) mulu8_sel::return#10
  (byte) sin8s::x4#0 ← (byte~) sin8s::$10
  (byte) mulu8_sel::v1#4 ← (byte) sin8s::x4#0
  (byte) mulu8_sel::v2#4 ← (byte) sin8s::x1#3
  (byte) mulu8_sel::select#4 ← (number) 0
  call mulu8_sel 
  (byte) mulu8_sel::return#4 ← (byte) mulu8_sel::return#6
  to:sin8s::@14
sin8s::@14: scope:[sin8s]  from sin8s::@13
  (byte) sin8s::isUpper#3 ← phi( sin8s::@13/(byte) sin8s::isUpper#5 )
  (byte) sin8s::usinx#3 ← phi( sin8s::@13/(byte) sin8s::usinx#7 )
  (byte) mulu8_sel::return#11 ← phi( sin8s::@13/(byte) mulu8_sel::return#4 )
  (byte~) sin8s::$11 ← (byte) mulu8_sel::return#11
  (byte) sin8s::x5#0 ← (byte~) sin8s::$11
  (byte~) sin8s::$12 ← (byte) sin8s::x5#0 >> (number) 4
  (byte) sin8s::x5_128#0 ← (byte~) sin8s::$12
  (byte~) sin8s::$13 ← (byte) sin8s::usinx#3 + (byte) sin8s::x5_128#0
  (byte) sin8s::usinx#1 ← (byte~) sin8s::$13
  (bool~) sin8s::$14 ← (byte) sin8s::usinx#1 >= (number) $80
  (bool~) sin8s::$15 ← ! (bool~) sin8s::$14
  if((bool~) sin8s::$15) goto sin8s::@3
  to:sin8s::@7
sin8s::@6: scope:[sin8s]  from sin8s::@1
  (byte) sin8s::isUpper#11 ← phi( sin8s::@1/(byte) sin8s::isUpper#10 )
  (word) sin8s::x#7 ← phi( sin8s::@1/(word) sin8s::x#4 )
  (word~) sin8s::$20 ← (const word) PI_u4f12 - (word) sin8s::x#7
  (word) sin8s::x#2 ← (word~) sin8s::$20
  to:sin8s::@2
sin8s::@3: scope:[sin8s]  from sin8s::@14 sin8s::@7
  (byte) sin8s::isUpper#2 ← phi( sin8s::@14/(byte) sin8s::isUpper#3 sin8s::@7/(byte) sin8s::isUpper#4 )
  (byte) sin8s::usinx#4 ← phi( sin8s::@14/(byte) sin8s::usinx#1 sin8s::@7/(byte) sin8s::usinx#2 )
  (signed byte~) sin8s::$16 ← ((signed byte)) (byte) sin8s::usinx#4
  (signed byte) sin8s::sinx#0 ← (signed byte~) sin8s::$16
  (bool~) sin8s::$17 ← (byte) sin8s::isUpper#2 != (number) 0
  (bool~) sin8s::$18 ← ! (bool~) sin8s::$17
  if((bool~) sin8s::$18) goto sin8s::@4
  to:sin8s::@8
sin8s::@7: scope:[sin8s]  from sin8s::@14
  (byte) sin8s::isUpper#4 ← phi( sin8s::@14/(byte) sin8s::isUpper#3 )
  (byte) sin8s::usinx#5 ← phi( sin8s::@14/(byte) sin8s::usinx#1 )
  (byte) sin8s::usinx#2 ← -- (byte) sin8s::usinx#5
  to:sin8s::@3
sin8s::@4: scope:[sin8s]  from sin8s::@3 sin8s::@8
  (signed byte) sin8s::sinx#2 ← phi( sin8s::@3/(signed byte) sin8s::sinx#0 sin8s::@8/(signed byte) sin8s::sinx#1 )
  (signed byte) sin8s::return#1 ← (signed byte) sin8s::sinx#2
  to:sin8s::@return
sin8s::@8: scope:[sin8s]  from sin8s::@3
  (byte) sin8s::usinx#6 ← phi( sin8s::@3/(byte) sin8s::usinx#4 )
  (signed byte~) sin8s::$21 ← ((signed byte)) (byte) sin8s::usinx#6
  (signed byte~) sin8s::$22 ← - (signed byte~) sin8s::$21
  (signed byte) sin8s::sinx#1 ← (signed byte~) sin8s::$22
  to:sin8s::@4
sin8s::@return: scope:[sin8s]  from sin8s::@4
  (signed byte) sin8s::return#4 ← phi( sin8s::@4/(signed byte) sin8s::return#1 )
  (signed byte) sin8s::return#2 ← (signed byte) sin8s::return#4
  return 
  to:@return

(word()) mulu16_sel((word) mulu16_sel::v1 , (word) mulu16_sel::v2 , (byte) mulu16_sel::select)
mulu16_sel: scope:[mulu16_sel]  from sin16s::@10 sin16s::@11 sin16s::@2 sin16s::@8 sin16s::@9
  (byte) mulu16_sel::select#6 ← phi( sin16s::@10/(byte) mulu16_sel::select#3 sin16s::@11/(byte) mulu16_sel::select#4 sin16s::@2/(byte) mulu16_sel::select#0 sin16s::@8/(byte) mulu16_sel::select#1 sin16s::@9/(byte) mulu16_sel::select#2 )
  (word) mulu16_sel::v2#5 ← phi( sin16s::@10/(word) mulu16_sel::v2#3 sin16s::@11/(word) mulu16_sel::v2#4 sin16s::@2/(word) mulu16_sel::v2#0 sin16s::@8/(word) mulu16_sel::v2#1 sin16s::@9/(word) mulu16_sel::v2#2 )
  (word) mulu16_sel::v1#5 ← phi( sin16s::@10/(word) mulu16_sel::v1#3 sin16s::@11/(word) mulu16_sel::v1#4 sin16s::@2/(word) mulu16_sel::v1#0 sin16s::@8/(word) mulu16_sel::v1#1 sin16s::@9/(word) mulu16_sel::v1#2 )
  (word) mul16u::a#1 ← (word) mulu16_sel::v1#5
  (word) mul16u::b#0 ← (word) mulu16_sel::v2#5
  call mul16u 
  (dword) mul16u::return#2 ← (dword) mul16u::return#1
  to:mulu16_sel::@2
mulu16_sel::@2: scope:[mulu16_sel]  from mulu16_sel
  (byte) mulu16_sel::select#5 ← phi( mulu16_sel/(byte) mulu16_sel::select#6 )
  (dword) mul16u::return#4 ← phi( mulu16_sel/(dword) mul16u::return#2 )
  (dword~) mulu16_sel::$0 ← (dword) mul16u::return#4
  (dword~) mulu16_sel::$1 ← (dword~) mulu16_sel::$0 << (byte) mulu16_sel::select#5
  (word~) mulu16_sel::$2 ← > (dword~) mulu16_sel::$1
  (word) mulu16_sel::return#5 ← (word~) mulu16_sel::$2
  to:mulu16_sel::@return
mulu16_sel::@return: scope:[mulu16_sel]  from mulu16_sel::@2
  (word) mulu16_sel::return#12 ← phi( mulu16_sel::@2/(word) mulu16_sel::return#5 )
  (word) mulu16_sel::return#6 ← (word) mulu16_sel::return#12
  return 
  to:@return

(byte()) mulu8_sel((byte) mulu8_sel::v1 , (byte) mulu8_sel::v2 , (byte) mulu8_sel::select)
mulu8_sel: scope:[mulu8_sel]  from sin8s::@10 sin8s::@11 sin8s::@12 sin8s::@13 sin8s::@2
  (byte) mulu8_sel::select#6 ← phi( sin8s::@10/(byte) mulu8_sel::select#1 sin8s::@11/(byte) mulu8_sel::select#2 sin8s::@12/(byte) mulu8_sel::select#3 sin8s::@13/(byte) mulu8_sel::select#4 sin8s::@2/(byte) mulu8_sel::select#0 )
  (byte) mulu8_sel::v2#5 ← phi( sin8s::@10/(byte) mulu8_sel::v2#1 sin8s::@11/(byte) mulu8_sel::v2#2 sin8s::@12/(byte) mulu8_sel::v2#3 sin8s::@13/(byte) mulu8_sel::v2#4 sin8s::@2/(byte) mulu8_sel::v2#0 )
  (byte) mulu8_sel::v1#5 ← phi( sin8s::@10/(byte) mulu8_sel::v1#1 sin8s::@11/(byte) mulu8_sel::v1#2 sin8s::@12/(byte) mulu8_sel::v1#3 sin8s::@13/(byte) mulu8_sel::v1#4 sin8s::@2/(byte) mulu8_sel::v1#0 )
  (byte) mul8u::a#1 ← (byte) mulu8_sel::v1#5
  (byte) mul8u::b#0 ← (byte) mulu8_sel::v2#5
  call mul8u 
  (word) mul8u::return#2 ← (word) mul8u::return#1
  to:mulu8_sel::@2
mulu8_sel::@2: scope:[mulu8_sel]  from mulu8_sel
  (byte) mulu8_sel::select#5 ← phi( mulu8_sel/(byte) mulu8_sel::select#6 )
  (word) mul8u::return#4 ← phi( mulu8_sel/(word) mul8u::return#2 )
  (word~) mulu8_sel::$0 ← (word) mul8u::return#4
  (word~) mulu8_sel::$1 ← (word~) mulu8_sel::$0 << (byte) mulu8_sel::select#5
  (byte~) mulu8_sel::$2 ← > (word~) mulu8_sel::$1
  (byte) mulu8_sel::return#5 ← (byte~) mulu8_sel::$2
  to:mulu8_sel::@return
mulu8_sel::@return: scope:[mulu8_sel]  from mulu8_sel::@2
  (byte) mulu8_sel::return#12 ← phi( mulu8_sel::@2/(byte) mulu8_sel::return#5 )
  (byte) mulu8_sel::return#6 ← (byte) mulu8_sel::return#12
  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
@33: scope:[]  from @2
  (word) rem16u#42 ← 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:@58

(void()) print_str((byte*) print_str::str)
print_str: scope:[print_str]  from main::@6
  (byte*) print_char_cursor#44 ← phi( main::@6/(byte*) print_char_cursor#15 )
  (byte*) print_str::str#4 ← phi( main::@6/(byte*) print_str::str#1 )
  to:print_str::@1
print_str::@1: scope:[print_str]  from print_str print_str::@2
  (byte*) print_char_cursor#36 ← phi( print_str/(byte*) print_char_cursor#44 print_str::@2/(byte*) print_char_cursor#1 )
  (byte*) print_str::str#2 ← phi( print_str/(byte*) print_str::str#4 print_str::@2/(byte*) print_str::str#0 )
  (bool~) print_str::$0 ← (number) 0 != *((byte*) print_str::str#2)
  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#19 ← phi( print_str::@1/(byte*) print_char_cursor#36 )
  (byte*) print_str::str#3 ← phi( print_str::@1/(byte*) print_str::str#2 )
  *((byte*) print_char_cursor#19) ← *((byte*) print_str::str#3)
  (byte*) print_char_cursor#1 ← ++ (byte*) print_char_cursor#19
  (byte*) print_str::str#0 ← ++ (byte*) print_str::str#3
  to:print_str::@1
print_str::@return: scope:[print_str]  from print_str::@1
  (byte*) print_char_cursor#20 ← phi( print_str::@1/(byte*) print_char_cursor#36 )
  (byte*) print_char_cursor#2 ← (byte*) print_char_cursor#20
  return 
  to:@return

(void()) print_sbyte((signed byte) print_sbyte::b)
print_sbyte: scope:[print_sbyte]  from main::@1
  (byte*) print_char_cursor#45 ← phi( main::@1/(byte*) print_char_cursor#42 )
  (signed byte) print_sbyte::b#2 ← phi( main::@1/(signed byte) print_sbyte::b#1 )
  (bool~) print_sbyte::$0 ← (signed byte) print_sbyte::b#2 < (number) 0
  if((bool~) print_sbyte::$0) goto print_sbyte::@1
  to:print_sbyte::@3
print_sbyte::@1: scope:[print_sbyte]  from print_sbyte
  (signed byte) print_sbyte::b#5 ← phi( print_sbyte/(signed byte) print_sbyte::b#2 )
  (byte*) print_char_cursor#37 ← phi( print_sbyte/(byte*) print_char_cursor#45 )
  (byte) print_char::ch#0 ← (byte) '-'
  call print_char 
  to:print_sbyte::@5
print_sbyte::@5: scope:[print_sbyte]  from print_sbyte::@1
  (signed byte) print_sbyte::b#3 ← phi( print_sbyte::@1/(signed byte) print_sbyte::b#5 )
  (byte*) print_char_cursor#21 ← phi( print_sbyte::@1/(byte*) print_char_cursor#11 )
  (byte*) print_char_cursor#3 ← (byte*) print_char_cursor#21
  (signed byte~) print_sbyte::$5 ← - (signed byte) print_sbyte::b#3
  (signed byte) print_sbyte::b#0 ← (signed byte~) print_sbyte::$5
  to:print_sbyte::@2
print_sbyte::@3: scope:[print_sbyte]  from print_sbyte
  (signed byte) print_sbyte::b#7 ← phi( print_sbyte/(signed byte) print_sbyte::b#2 )
  (byte*) print_char_cursor#38 ← phi( print_sbyte/(byte*) print_char_cursor#45 )
  (byte) print_char::ch#1 ← (byte) ' '
  call print_char 
  to:print_sbyte::@6
print_sbyte::@6: scope:[print_sbyte]  from print_sbyte::@3
  (signed byte) print_sbyte::b#6 ← phi( print_sbyte::@3/(signed byte) print_sbyte::b#7 )
  (byte*) print_char_cursor#22 ← phi( print_sbyte::@3/(byte*) print_char_cursor#11 )
  (byte*) print_char_cursor#4 ← (byte*) print_char_cursor#22
  to:print_sbyte::@2
print_sbyte::@2: scope:[print_sbyte]  from print_sbyte::@5 print_sbyte::@6
  (byte*) print_char_cursor#39 ← phi( print_sbyte::@5/(byte*) print_char_cursor#3 print_sbyte::@6/(byte*) print_char_cursor#4 )
  (signed byte) print_sbyte::b#4 ← phi( print_sbyte::@5/(signed byte) print_sbyte::b#0 print_sbyte::@6/(signed byte) print_sbyte::b#6 )
  (byte~) print_sbyte::$1 ← ((byte)) (signed byte) print_sbyte::b#4
  (byte) print_byte::b#0 ← (byte~) print_sbyte::$1
  call print_byte 
  to:print_sbyte::@7
print_sbyte::@7: scope:[print_sbyte]  from print_sbyte::@2
  (byte*) print_char_cursor#23 ← phi( print_sbyte::@2/(byte*) print_char_cursor#9 )
  (byte*) print_char_cursor#5 ← (byte*) print_char_cursor#23
  to:print_sbyte::@return
print_sbyte::@return: scope:[print_sbyte]  from print_sbyte::@7
  (byte*) print_char_cursor#24 ← phi( print_sbyte::@7/(byte*) print_char_cursor#5 )
  (byte*) print_char_cursor#6 ← (byte*) print_char_cursor#24
  return 
  to:@return

(void()) print_byte((byte) print_byte::b)
print_byte: scope:[print_byte]  from print_sbyte::@2
  (byte*) print_char_cursor#40 ← phi( print_sbyte::@2/(byte*) print_char_cursor#39 )
  (byte) print_byte::b#1 ← phi( print_sbyte::@2/(byte) print_byte::b#0 )
  (byte~) print_byte::$0 ← (byte) print_byte::b#1 >> (number) 4
  (byte) print_char::ch#2 ← *((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#2 ← phi( print_byte/(byte) print_byte::b#1 )
  (byte*) print_char_cursor#25 ← phi( print_byte/(byte*) print_char_cursor#11 )
  (byte*) print_char_cursor#7 ← (byte*) print_char_cursor#25
  (number~) print_byte::$2 ← (byte) print_byte::b#2 & (number) $f
  (byte) print_char::ch#3 ← *((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#26 ← phi( print_byte::@1/(byte*) print_char_cursor#11 )
  (byte*) print_char_cursor#8 ← (byte*) print_char_cursor#26
  to:print_byte::@return
print_byte::@return: scope:[print_byte]  from print_byte::@2
  (byte*) print_char_cursor#27 ← phi( print_byte::@2/(byte*) print_char_cursor#8 )
  (byte*) print_char_cursor#9 ← (byte*) print_char_cursor#27
  return 
  to:@return

(void()) print_char((byte) print_char::ch)
print_char: scope:[print_char]  from print_byte print_byte::@1 print_sbyte::@1 print_sbyte::@3
  (byte*) print_char_cursor#28 ← phi( print_byte/(byte*) print_char_cursor#40 print_byte::@1/(byte*) print_char_cursor#7 print_sbyte::@1/(byte*) print_char_cursor#37 print_sbyte::@3/(byte*) print_char_cursor#38 )
  (byte) print_char::ch#4 ← phi( print_byte/(byte) print_char::ch#2 print_byte::@1/(byte) print_char::ch#3 print_sbyte::@1/(byte) print_char::ch#0 print_sbyte::@3/(byte) print_char::ch#1 )
  *((byte*) print_char_cursor#28) ← (byte) print_char::ch#4
  (byte*) print_char_cursor#10 ← ++ (byte*) print_char_cursor#28
  to:print_char::@return
print_char::@return: scope:[print_char]  from print_char
  (byte*) print_char_cursor#29 ← phi( print_char/(byte*) print_char_cursor#10 )
  (byte*) print_char_cursor#11 ← (byte*) print_char_cursor#29
  return 
  to:@return

(void()) print_cls()
print_cls: scope:[print_cls]  from main::@4
  (byte*) print_screen#1 ← phi( main::@4/(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#1 ← (byte*) print_screen#2
  (byte*) print_char_cursor#12 ← (byte*) print_line_cursor#1
  to:print_cls::@return
print_cls::@return: scope:[print_cls]  from print_cls::@1
  (byte*) print_char_cursor#30 ← phi( print_cls::@1/(byte*) print_char_cursor#12 )
  (byte*) print_line_cursor#6 ← phi( print_cls::@1/(byte*) print_line_cursor#1 )
  (byte*) print_line_cursor#2 ← (byte*) print_line_cursor#6
  (byte*) print_char_cursor#13 ← (byte*) print_char_cursor#30
  return 
  to:@return

(void()) main()
main: scope:[main]  from @58
  (byte*) print_char_cursor#47 ← phi( @58/(byte*) print_char_cursor#43 )
  (byte*) print_line_cursor#15 ← phi( @58/(byte*) print_line_cursor#12 )
  (byte*) print_screen#5 ← phi( @58/(byte*) print_screen#6 )
  (word) rem16u#36 ← phi( @58/(word) rem16u#38 )
  (signed byte*) sin8s_gen::sintab#1 ← (const signed byte*) main::sintabb
  (word) sin8s_gen::wavelength#0 ← (const word) main::wavelength
  call sin8s_gen 
  to:main::@3
main::@3: scope:[main]  from main
  (byte*) print_char_cursor#46 ← phi( main/(byte*) print_char_cursor#47 )
  (byte*) print_line_cursor#13 ← phi( main/(byte*) print_line_cursor#15 )
  (byte*) print_screen#4 ← phi( main/(byte*) print_screen#5 )
  (word) rem16u#26 ← phi( main/(word) rem16u#11 )
  (word) rem16u#12 ← (word) rem16u#26
  (signed word*) sin16s_gen::sintab#1 ← (const signed word*) main::sintabw
  (word) sin16s_gen::wavelength#0 ← (const word) main::wavelength
  call sin16s_gen 
  to:main::@4
main::@4: scope:[main]  from main::@3
  (byte*) print_char_cursor#41 ← phi( main::@3/(byte*) print_char_cursor#46 )
  (byte*) print_line_cursor#10 ← phi( main::@3/(byte*) print_line_cursor#13 )
  (byte*) print_screen#3 ← phi( main::@3/(byte*) print_screen#4 )
  (word) rem16u#27 ← phi( main::@3/(word) rem16u#9 )
  (word) rem16u#13 ← (word) rem16u#27
  call print_cls 
  to:main::@5
main::@5: scope:[main]  from main::@4
  (word) rem16u#46 ← phi( main::@4/(word) rem16u#13 )
  (byte*) print_char_cursor#31 ← phi( main::@4/(byte*) print_char_cursor#13 )
  (byte*) print_line_cursor#7 ← phi( main::@4/(byte*) print_line_cursor#2 )
  (byte*) print_line_cursor#3 ← (byte*) print_line_cursor#7
  (byte*) print_char_cursor#14 ← (byte*) print_char_cursor#31
  (byte) main::i#0 ← (byte) 0
  to:main::@1
main::@1: scope:[main]  from main::@5 main::@7
  (byte*) print_line_cursor#16 ← phi( main::@5/(byte*) print_line_cursor#3 main::@7/(byte*) print_line_cursor#11 )
  (word) rem16u#45 ← phi( main::@5/(word) rem16u#46 main::@7/(word) rem16u#37 )
  (byte*) print_char_cursor#42 ← phi( main::@5/(byte*) print_char_cursor#14 main::@7/(byte*) print_char_cursor#16 )
  (byte) main::i#2 ← phi( main::@5/(byte) main::i#0 main::@7/(byte) main::i#1 )
  (signed byte) main::sb#0 ← *((const signed byte*) main::sintabb + (byte) main::i#2)
  (word~) main::$3 ← ((word)) (byte) main::i#2
  (word~) main::$11 ← (word~) main::$3 * (const byte) SIZEOF_SIGNED_WORD
  (signed word*~) main::$4 ← (const signed word*) main::sintabw + (word~) main::$11
  (signed word) main::sw#0 ← *((signed word*~) main::$4)
  (byte~) main::$5 ← > (signed word) main::sw#0
  (signed byte~) main::$6 ← ((signed byte)) (byte~) main::$5
  (signed byte~) main::$7 ← (signed byte) main::sb#0 - (signed byte~) main::$6
  (signed byte) main::sd#0 ← (signed byte~) main::$7
  (signed byte) print_sbyte::b#1 ← (signed byte) main::sd#0
  call print_sbyte 
  to:main::@6
main::@6: scope:[main]  from main::@1
  (byte*) print_line_cursor#14 ← phi( main::@1/(byte*) print_line_cursor#16 )
  (word) rem16u#41 ← phi( main::@1/(word) rem16u#45 )
  (byte) main::i#4 ← phi( main::@1/(byte) main::i#2 )
  (byte*) print_char_cursor#32 ← phi( main::@1/(byte*) print_char_cursor#6 )
  (byte*) print_char_cursor#15 ← (byte*) print_char_cursor#32
  (byte*) print_str::str#1 ← (const byte*) main::str
  call print_str 
  to:main::@7
main::@7: scope:[main]  from main::@6
  (byte*) print_line_cursor#11 ← phi( main::@6/(byte*) print_line_cursor#14 )
  (word) rem16u#37 ← phi( main::@6/(word) rem16u#41 )
  (byte) main::i#3 ← phi( main::@6/(byte) main::i#4 )
  (byte*) print_char_cursor#33 ← phi( main::@6/(byte*) print_char_cursor#2 )
  (byte*) print_char_cursor#16 ← (byte*) print_char_cursor#33
  (byte) main::i#1 ← (byte) main::i#3 + rangenext(0,$bf)
  (bool~) main::$10 ← (byte) main::i#1 != rangelast(0,$bf)
  if((bool~) main::$10) goto main::@1
  to:main::@return
main::@return: scope:[main]  from main::@7
  (byte*) print_char_cursor#34 ← phi( main::@7/(byte*) print_char_cursor#16 )
  (byte*) print_line_cursor#8 ← phi( main::@7/(byte*) print_line_cursor#11 )
  (word) rem16u#28 ← phi( main::@7/(word) rem16u#37 )
  (word) rem16u#14 ← (word) rem16u#28
  (byte*) print_line_cursor#4 ← (byte*) print_line_cursor#8
  (byte*) print_char_cursor#17 ← (byte*) print_char_cursor#34
  return 
  to:@return
@58: scope:[]  from @33
  (byte*) print_screen#6 ← phi( @33/(byte*) print_screen#0 )
  (byte*) print_char_cursor#43 ← phi( @33/(byte*) print_char_cursor#0 )
  (byte*) print_line_cursor#12 ← phi( @33/(byte*) print_line_cursor#0 )
  (word) rem16u#38 ← phi( @33/(word) rem16u#42 )
  call main 
  to:@59
@59: scope:[]  from @58
  (byte*) print_char_cursor#35 ← phi( @58/(byte*) print_char_cursor#17 )
  (byte*) print_line_cursor#9 ← phi( @58/(byte*) print_line_cursor#4 )
  (word) rem16u#29 ← phi( @58/(word) rem16u#14 )
  (word) rem16u#15 ← (word) rem16u#29
  (byte*) print_line_cursor#5 ← (byte*) print_line_cursor#9
  (byte*) print_char_cursor#18 ← (byte*) print_char_cursor#35
  to:@end
@end: scope:[]  from @59

SYMBOL TABLE SSA
(label) @2
(label) @33
(label) @58
(label) @59
(label) @begin
(label) @end
(const word) PI2_u4f12 = (word) $6488
(const dword) PI2_u4f28 = (dword) $6487ed51
(const word) PI_HALF_u4f12 = (word) $1922
(const dword) PI_HALF_u4f28 = (dword) $1921fb54
(const word) PI_u4f12 = (word) $3244
(const dword) PI_u4f28 = (dword) $3243f6a9
(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_SIGNED_WORD = (byte) 2
(word()) div16u((word) div16u::dividend , (word) div16u::divisor)
(word~) div16u::$0
(label) div16u::@2
(label) div16u::@return
(word) div16u::dividend
(word) div16u::dividend#0
(word) div16u::dividend#1
(word) div16u::divisor
(word) div16u::divisor#0
(word) div16u::divisor#1
(word) div16u::return
(word) div16u::return#0
(word) div16u::return#1
(word) div16u::return#2
(word) div16u::return#3
(word) div16u::return#4
(dword()) div32u16u((dword) div32u16u::dividend , (word) div32u16u::divisor)
(word~) div32u16u::$0
(word~) div32u16u::$1
(word~) div32u16u::$2
(word~) div32u16u::$3
(label) div32u16u::@2
(label) div32u16u::@3
(label) div32u16u::@return
(dword) div32u16u::dividend
(dword) div32u16u::dividend#0
(dword) div32u16u::dividend#1
(dword) div32u16u::dividend#2
(word) div32u16u::divisor
(word) div32u16u::divisor#0
(word) div32u16u::divisor#1
(word) div32u16u::divisor#2
(dword) div32u16u::quotient
(dword) div32u16u::quotient#0
(word) div32u16u::quotient_hi
(word) div32u16u::quotient_hi#0
(word) div32u16u::quotient_hi#1
(word) div32u16u::quotient_lo
(word) div32u16u::quotient_lo#0
(dword) div32u16u::return
(dword) div32u16u::return#0
(dword) div32u16u::return#1
(dword) div32u16u::return#2
(dword) div32u16u::return#3
(dword) div32u16u::return#4
(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::dividend#9
(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
(word) divr16u::divisor#8
(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#12
(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
(word) divr16u::return#7
(word) divr16u::return#8
(void()) main()
(bool~) main::$10
(word~) main::$11
(word~) main::$3
(signed word*~) main::$4
(byte~) main::$5
(signed byte~) main::$6
(signed byte~) main::$7
(label) main::@1
(label) main::@3
(label) main::@4
(label) main::@5
(label) main::@6
(label) main::@7
(label) main::@return
(byte) main::i
(byte) main::i#0
(byte) main::i#1
(byte) main::i#2
(byte) main::i#3
(byte) main::i#4
(signed byte) main::sb
(signed byte) main::sb#0
(signed byte) main::sd
(signed byte) main::sd#0
(const signed byte*) main::sintabb[(number) $c0]  = { fill( $c0, 0) }
(const signed word*) main::sintabw[(number) $c0]  = { fill( $c0, 0) }
(const byte*) main::str[(byte) 3]  = (byte*) "  "
(signed word) main::sw
(signed word) main::sw#0
(const word) main::wavelength = (word) $c0
(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
(dword()) mul16u((word) mul16u::a , (word) mul16u::b)
(bool~) mul16u::$0
(number~) mul16u::$1
(bool~) mul16u::$2
(bool~) mul16u::$3
(dword~) mul16u::$4
(word~) mul16u::$5
(dword~) mul16u::$6
(label) mul16u::@1
(label) mul16u::@2
(label) mul16u::@3
(label) mul16u::@4
(label) mul16u::@7
(label) mul16u::@return
(word) mul16u::a
(word) mul16u::a#0
(word) mul16u::a#1
(word) mul16u::a#2
(word) mul16u::a#3
(word) mul16u::a#4
(word) mul16u::a#5
(word) mul16u::a#6
(word) mul16u::b
(word) mul16u::b#0
(word) mul16u::b#1
(dword) mul16u::mb
(dword) mul16u::mb#0
(dword) mul16u::mb#1
(dword) mul16u::mb#2
(dword) mul16u::mb#3
(dword) mul16u::mb#4
(dword) mul16u::mb#5
(dword) mul16u::res
(dword) mul16u::res#0
(dword) mul16u::res#1
(dword) mul16u::res#2
(dword) mul16u::res#3
(dword) mul16u::res#4
(dword) mul16u::res#5
(dword) mul16u::res#6
(dword) mul16u::return
(dword) mul16u::return#0
(dword) mul16u::return#1
(dword) mul16u::return#2
(dword) mul16u::return#3
(dword) mul16u::return#4
(word()) mul8u((byte) mul8u::a , (byte) mul8u::b)
(bool~) mul8u::$0
(number~) mul8u::$1
(bool~) mul8u::$2
(bool~) mul8u::$3
(word~) mul8u::$4
(byte~) mul8u::$5
(word~) mul8u::$6
(label) mul8u::@1
(label) mul8u::@2
(label) mul8u::@3
(label) mul8u::@4
(label) mul8u::@7
(label) mul8u::@return
(byte) mul8u::a
(byte) mul8u::a#0
(byte) mul8u::a#1
(byte) mul8u::a#2
(byte) mul8u::a#3
(byte) mul8u::a#4
(byte) mul8u::a#5
(byte) mul8u::a#6
(byte) mul8u::b
(byte) mul8u::b#0
(byte) mul8u::b#1
(word) mul8u::mb
(word) mul8u::mb#0
(word) mul8u::mb#1
(word) mul8u::mb#2
(word) mul8u::mb#3
(word) mul8u::mb#4
(word) mul8u::mb#5
(word) mul8u::res
(word) mul8u::res#0
(word) mul8u::res#1
(word) mul8u::res#2
(word) mul8u::res#3
(word) mul8u::res#4
(word) mul8u::res#5
(word) mul8u::res#6
(word) mul8u::return
(word) mul8u::return#0
(word) mul8u::return#1
(word) mul8u::return#2
(word) mul8u::return#3
(word) mul8u::return#4
(word()) mulu16_sel((word) mulu16_sel::v1 , (word) mulu16_sel::v2 , (byte) mulu16_sel::select)
(dword~) mulu16_sel::$0
(dword~) mulu16_sel::$1
(word~) mulu16_sel::$2
(label) mulu16_sel::@2
(label) mulu16_sel::@return
(word) mulu16_sel::return
(word) mulu16_sel::return#0
(word) mulu16_sel::return#1
(word) mulu16_sel::return#10
(word) mulu16_sel::return#11
(word) mulu16_sel::return#12
(word) mulu16_sel::return#2
(word) mulu16_sel::return#3
(word) mulu16_sel::return#4
(word) mulu16_sel::return#5
(word) mulu16_sel::return#6
(word) mulu16_sel::return#7
(word) mulu16_sel::return#8
(word) mulu16_sel::return#9
(byte) mulu16_sel::select
(byte) mulu16_sel::select#0
(byte) mulu16_sel::select#1
(byte) mulu16_sel::select#2
(byte) mulu16_sel::select#3
(byte) mulu16_sel::select#4
(byte) mulu16_sel::select#5
(byte) mulu16_sel::select#6
(word) mulu16_sel::v1
(word) mulu16_sel::v1#0
(word) mulu16_sel::v1#1
(word) mulu16_sel::v1#2
(word) mulu16_sel::v1#3
(word) mulu16_sel::v1#4
(word) mulu16_sel::v1#5
(word) mulu16_sel::v2
(word) mulu16_sel::v2#0
(word) mulu16_sel::v2#1
(word) mulu16_sel::v2#2
(word) mulu16_sel::v2#3
(word) mulu16_sel::v2#4
(word) mulu16_sel::v2#5
(byte()) mulu8_sel((byte) mulu8_sel::v1 , (byte) mulu8_sel::v2 , (byte) mulu8_sel::select)
(word~) mulu8_sel::$0
(word~) mulu8_sel::$1
(byte~) mulu8_sel::$2
(label) mulu8_sel::@2
(label) mulu8_sel::@return
(byte) mulu8_sel::return
(byte) mulu8_sel::return#0
(byte) mulu8_sel::return#1
(byte) mulu8_sel::return#10
(byte) mulu8_sel::return#11
(byte) mulu8_sel::return#12
(byte) mulu8_sel::return#2
(byte) mulu8_sel::return#3
(byte) mulu8_sel::return#4
(byte) mulu8_sel::return#5
(byte) mulu8_sel::return#6
(byte) mulu8_sel::return#7
(byte) mulu8_sel::return#8
(byte) mulu8_sel::return#9
(byte) mulu8_sel::select
(byte) mulu8_sel::select#0
(byte) mulu8_sel::select#1
(byte) mulu8_sel::select#2
(byte) mulu8_sel::select#3
(byte) mulu8_sel::select#4
(byte) mulu8_sel::select#5
(byte) mulu8_sel::select#6
(byte) mulu8_sel::v1
(byte) mulu8_sel::v1#0
(byte) mulu8_sel::v1#1
(byte) mulu8_sel::v1#2
(byte) mulu8_sel::v1#3
(byte) mulu8_sel::v1#4
(byte) mulu8_sel::v1#5
(byte) mulu8_sel::v2
(byte) mulu8_sel::v2#0
(byte) mulu8_sel::v2#1
(byte) mulu8_sel::v2#2
(byte) mulu8_sel::v2#3
(byte) mulu8_sel::v2#4
(byte) mulu8_sel::v2#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
(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::ch#3
(byte) print_char::ch#4
(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#5
(byte*) print_char_cursor#6
(byte*) print_char_cursor#7
(byte*) print_char_cursor#8
(byte*) print_char_cursor#9
(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#2
(byte*) print_line_cursor#3
(byte*) print_line_cursor#4
(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_sbyte((signed byte) print_sbyte::b)
(bool~) print_sbyte::$0
(byte~) print_sbyte::$1
(signed byte~) print_sbyte::$5
(label) print_sbyte::@1
(label) print_sbyte::@2
(label) print_sbyte::@3
(label) print_sbyte::@5
(label) print_sbyte::@6
(label) print_sbyte::@7
(label) print_sbyte::@return
(signed byte) print_sbyte::b
(signed byte) print_sbyte::b#0
(signed byte) print_sbyte::b#1
(signed byte) print_sbyte::b#2
(signed byte) print_sbyte::b#3
(signed byte) print_sbyte::b#4
(signed byte) print_sbyte::b#5
(signed byte) print_sbyte::b#6
(signed byte) print_sbyte::b#7
(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
(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#2
(byte*) print_str::str#3
(byte*) print_str::str#4
(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#5
(word) rem16u#6
(word) rem16u#7
(word) rem16u#8
(word) rem16u#9
(signed word()) sin16s((dword) sin16s::x)
(bool~) sin16s::$0
(bool~) sin16s::$1
(word~) sin16s::$10
(word~) sin16s::$11
(word~) sin16s::$12
(word~) sin16s::$13
(signed word~) sin16s::$14
(bool~) sin16s::$15
(bool~) sin16s::$16
(dword~) sin16s::$17
(dword~) sin16s::$18
(signed word~) sin16s::$19
(bool~) sin16s::$2
(signed word~) sin16s::$20
(bool~) sin16s::$3
(dword~) sin16s::$4
(word~) sin16s::$5
(word~) sin16s::$6
(word~) sin16s::$7
(word~) sin16s::$8
(word~) sin16s::$9
(label) sin16s::@1
(label) sin16s::@10
(label) sin16s::@11
(label) sin16s::@12
(label) sin16s::@2
(label) sin16s::@3
(label) sin16s::@4
(label) sin16s::@5
(label) sin16s::@6
(label) sin16s::@8
(label) sin16s::@9
(label) sin16s::@return
(byte) sin16s::isUpper
(byte) sin16s::isUpper#0
(byte) sin16s::isUpper#1
(byte) sin16s::isUpper#2
(byte) sin16s::isUpper#3
(byte) sin16s::isUpper#4
(byte) sin16s::isUpper#5
(byte) sin16s::isUpper#6
(byte) sin16s::isUpper#7
(byte) sin16s::isUpper#8
(byte) sin16s::isUpper#9
(signed word) sin16s::return
(signed word) sin16s::return#0
(signed word) sin16s::return#1
(signed word) sin16s::return#2
(signed word) sin16s::return#3
(signed word) sin16s::return#4
(signed word) sin16s::sinx
(signed word) sin16s::sinx#0
(signed word) sin16s::sinx#1
(signed word) sin16s::sinx#2
(word) sin16s::usinx
(word) sin16s::usinx#0
(word) sin16s::usinx#1
(word) sin16s::usinx#2
(word) sin16s::usinx#3
(word) sin16s::usinx#4
(dword) sin16s::x
(dword) sin16s::x#0
(dword) sin16s::x#1
(dword) sin16s::x#2
(dword) sin16s::x#3
(dword) sin16s::x#4
(dword) sin16s::x#5
(dword) sin16s::x#6
(dword) sin16s::x#7
(word) sin16s::x1
(word) sin16s::x1#0
(word) sin16s::x1#1
(word) sin16s::x1#2
(word) sin16s::x1#3
(word) sin16s::x1#4
(word) sin16s::x2
(word) sin16s::x2#0
(word) sin16s::x3
(word) sin16s::x3#0
(word) sin16s::x3#1
(word) sin16s::x3_6
(word) sin16s::x3_6#0
(word) sin16s::x4
(word) sin16s::x4#0
(word) sin16s::x5
(word) sin16s::x5#0
(word) sin16s::x5_128
(word) sin16s::x5_128#0
(void()) sin16s_gen((signed word*) sin16s_gen::sintab , (word) sin16s_gen::wavelength)
(dword~) sin16s_gen::$0
(bool~) sin16s_gen::$1
(signed word~) sin16s_gen::$2
(dword~) sin16s_gen::$3
(label) sin16s_gen::@1
(label) sin16s_gen::@2
(label) sin16s_gen::@7
(label) sin16s_gen::@8
(label) sin16s_gen::@return
(word) sin16s_gen::i
(word) sin16s_gen::i#0
(word) sin16s_gen::i#1
(word) sin16s_gen::i#2
(word) sin16s_gen::i#3
(word) sin16s_gen::i#4
(signed word*) sin16s_gen::sintab
(signed word*) sin16s_gen::sintab#0
(signed word*) sin16s_gen::sintab#1
(signed word*) sin16s_gen::sintab#2
(signed word*) sin16s_gen::sintab#3
(signed word*) sin16s_gen::sintab#4
(signed word*) sin16s_gen::sintab#5
(signed word*) sin16s_gen::sintab#6
(dword) sin16s_gen::step
(dword) sin16s_gen::step#0
(dword) sin16s_gen::step#1
(dword) sin16s_gen::step#2
(dword) sin16s_gen::step#3
(word) sin16s_gen::wavelength
(word) sin16s_gen::wavelength#0
(word) sin16s_gen::wavelength#1
(word) sin16s_gen::wavelength#2
(word) sin16s_gen::wavelength#3
(word) sin16s_gen::wavelength#4
(word) sin16s_gen::wavelength#5
(dword) sin16s_gen::x
(dword) sin16s_gen::x#0
(dword) sin16s_gen::x#1
(dword) sin16s_gen::x#2
(dword) sin16s_gen::x#3
(dword) sin16s_gen::x#4
(signed byte()) sin8s((word) sin8s::x)
(bool~) sin8s::$0
(bool~) sin8s::$1
(byte~) sin8s::$10
(byte~) sin8s::$11
(byte~) sin8s::$12
(byte~) sin8s::$13
(bool~) sin8s::$14
(bool~) sin8s::$15
(signed byte~) sin8s::$16
(bool~) sin8s::$17
(bool~) sin8s::$18
(word~) sin8s::$19
(bool~) sin8s::$2
(word~) sin8s::$20
(signed byte~) sin8s::$21
(signed byte~) sin8s::$22
(bool~) sin8s::$3
(word~) sin8s::$4
(byte~) sin8s::$5
(byte~) sin8s::$6
(byte~) sin8s::$7
(byte~) sin8s::$8
(byte~) sin8s::$9
(label) sin8s::@1
(label) sin8s::@10
(label) sin8s::@11
(label) sin8s::@12
(label) sin8s::@13
(label) sin8s::@14
(label) sin8s::@2
(label) sin8s::@3
(label) sin8s::@4
(label) sin8s::@5
(label) sin8s::@6
(label) sin8s::@7
(label) sin8s::@8
(label) sin8s::@return
(const byte) sin8s::DIV_6 = (byte) $2b
(byte) sin8s::isUpper
(byte) sin8s::isUpper#0
(byte) sin8s::isUpper#1
(byte) sin8s::isUpper#10
(byte) sin8s::isUpper#11
(byte) sin8s::isUpper#2
(byte) sin8s::isUpper#3
(byte) sin8s::isUpper#4
(byte) sin8s::isUpper#5
(byte) sin8s::isUpper#6
(byte) sin8s::isUpper#7
(byte) sin8s::isUpper#8
(byte) sin8s::isUpper#9
(signed byte) sin8s::return
(signed byte) sin8s::return#0
(signed byte) sin8s::return#1
(signed byte) sin8s::return#2
(signed byte) sin8s::return#3
(signed byte) sin8s::return#4
(signed byte) sin8s::sinx
(signed byte) sin8s::sinx#0
(signed byte) sin8s::sinx#1
(signed byte) sin8s::sinx#2
(byte) sin8s::usinx
(byte) sin8s::usinx#0
(byte) sin8s::usinx#1
(byte) sin8s::usinx#2
(byte) sin8s::usinx#3
(byte) sin8s::usinx#4
(byte) sin8s::usinx#5
(byte) sin8s::usinx#6
(byte) sin8s::usinx#7
(word) sin8s::x
(word) sin8s::x#0
(word) sin8s::x#1
(word) sin8s::x#2
(word) sin8s::x#3
(word) sin8s::x#4
(word) sin8s::x#5
(word) sin8s::x#6
(word) sin8s::x#7
(byte) sin8s::x1
(byte) sin8s::x1#0
(byte) sin8s::x1#1
(byte) sin8s::x1#2
(byte) sin8s::x1#3
(byte) sin8s::x1#4
(byte) sin8s::x2
(byte) sin8s::x2#0
(byte) sin8s::x3
(byte) sin8s::x3#0
(byte) sin8s::x3#1
(byte) sin8s::x3_6
(byte) sin8s::x3_6#0
(byte) sin8s::x4
(byte) sin8s::x4#0
(byte) sin8s::x5
(byte) sin8s::x5#0
(byte) sin8s::x5_128
(byte) sin8s::x5_128#0
(void()) sin8s_gen((signed byte*) sin8s_gen::sintab , (word) sin8s_gen::wavelength)
(word~) sin8s_gen::$0
(bool~) sin8s_gen::$1
(signed byte~) sin8s_gen::$2
(word~) sin8s_gen::$3
(label) sin8s_gen::@1
(label) sin8s_gen::@2
(label) sin8s_gen::@7
(label) sin8s_gen::@8
(label) sin8s_gen::@return
(word) sin8s_gen::i
(word) sin8s_gen::i#0
(word) sin8s_gen::i#1
(word) sin8s_gen::i#2
(word) sin8s_gen::i#3
(word) sin8s_gen::i#4
(signed byte*) sin8s_gen::sintab
(signed byte*) sin8s_gen::sintab#0
(signed byte*) sin8s_gen::sintab#1
(signed byte*) sin8s_gen::sintab#2
(signed byte*) sin8s_gen::sintab#3
(signed byte*) sin8s_gen::sintab#4
(signed byte*) sin8s_gen::sintab#5
(signed byte*) sin8s_gen::sintab#6
(word) sin8s_gen::step
(word) sin8s_gen::step#0
(word) sin8s_gen::step#1
(word) sin8s_gen::step#2
(word) sin8s_gen::step#3
(word) sin8s_gen::wavelength
(word) sin8s_gen::wavelength#0
(word) sin8s_gen::wavelength#1
(word) sin8s_gen::wavelength#2
(word) sin8s_gen::wavelength#3
(word) sin8s_gen::wavelength#4
(word) sin8s_gen::wavelength#5
(word) sin8s_gen::x
(word) sin8s_gen::x#0
(word) sin8s_gen::x#1
(word) sin8s_gen::x#2
(word) sin8s_gen::x#3
(word) sin8s_gen::x#4

Fixing inline constructor with div32u16u::$4 ← (word)div32u16u::quotient_hi#1 dw= (word)div32u16u::quotient_lo#0
Successful SSA optimization Pass2FixInlineConstructors
Adding number conversion cast (unumber) 1 in (word~) divr16u::$0 ← (word) divr16u::rem#6 << (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#5 << (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#8 | (number) 1
Adding number conversion cast (unumber) divr16u::$5 in (number~) divr16u::$5 ← (word) divr16u::rem#8 | (unumber)(number) 1
Adding number conversion cast (unumber) 0 in (word) divr16u::rem#3 ← (number) 0
Adding number conversion cast (unumber) 0 in (word) divr16u::rem#4 ← (number) 0
Adding number conversion cast (unumber) 0 in (bool~) mul8u::$0 ← (byte) mul8u::a#2 != (number) 0
Adding number conversion cast (unumber) 1 in (number~) mul8u::$1 ← (byte) mul8u::a#3 & (number) 1
Adding number conversion cast (unumber) mul8u::$1 in (number~) mul8u::$1 ← (byte) mul8u::a#3 & (unumber)(number) 1
Adding number conversion cast (unumber) 0 in (bool~) mul8u::$2 ← (unumber~) mul8u::$1 != (number) 0
Adding number conversion cast (unumber) 1 in (byte~) mul8u::$5 ← (byte) mul8u::a#4 >> (number) 1
Adding number conversion cast (unumber) 1 in (word~) mul8u::$6 ← (word) mul8u::mb#2 << (number) 1
Adding number conversion cast (unumber) 0 in (bool~) mul16u::$0 ← (word) mul16u::a#2 != (number) 0
Adding number conversion cast (unumber) 1 in (number~) mul16u::$1 ← (word) mul16u::a#3 & (number) 1
Adding number conversion cast (unumber) mul16u::$1 in (number~) mul16u::$1 ← (word) mul16u::a#3 & (unumber)(number) 1
Adding number conversion cast (unumber) 0 in (bool~) mul16u::$2 ← (unumber~) mul16u::$1 != (number) 0
Adding number conversion cast (unumber) 1 in (word~) mul16u::$5 ← (word) mul16u::a#4 >> (number) 1
Adding number conversion cast (unumber) 1 in (dword~) mul16u::$6 ← (dword) mul16u::mb#2 << (number) 1
Adding number conversion cast (unumber) 1 in (byte) sin16s::isUpper#1 ← (number) 1
Adding number conversion cast (unumber) 3 in (dword~) sin16s::$4 ← (dword) sin16s::x#6 << (number) 3
Adding number conversion cast (unumber) 0 in (byte) mulu16_sel::select#0 ← (number) 0
Adding number conversion cast (unumber) 1 in (byte) mulu16_sel::select#1 ← (number) 1
Adding number conversion cast (unumber) $10000/6 in (word) mulu16_sel::v2#2 ← (number) $10000/(number) 6
Adding number conversion cast (unumber) 1 in (byte) mulu16_sel::select#2 ← (number) 1
Adding number conversion cast (unumber) 0 in (byte) mulu16_sel::select#3 ← (number) 0
Adding number conversion cast (unumber) 0 in (byte) mulu16_sel::select#4 ← (number) 0
Adding number conversion cast (unumber) 4 in (word~) sin16s::$12 ← (word) sin16s::x5#0 >> (number) 4
Adding number conversion cast (unumber) 0 in (bool~) sin16s::$15 ← (byte) sin16s::isUpper#2 != (number) 0
Adding number conversion cast (unumber) 1 in (byte) sin8s::isUpper#1 ← (number) 1
Adding number conversion cast (unumber) 3 in (word~) sin8s::$4 ← (word) sin8s::x#6 << (number) 3
Adding number conversion cast (unumber) 0 in (byte) mulu8_sel::select#0 ← (number) 0
Adding number conversion cast (unumber) 1 in (byte) mulu8_sel::select#1 ← (number) 1
Adding number conversion cast (unumber) 1 in (byte) mulu8_sel::select#2 ← (number) 1
Adding number conversion cast (unumber) 0 in (byte) mulu8_sel::select#3 ← (number) 0
Adding number conversion cast (unumber) 0 in (byte) mulu8_sel::select#4 ← (number) 0
Adding number conversion cast (unumber) 4 in (byte~) sin8s::$12 ← (byte) sin8s::x5#0 >> (number) 4
Adding number conversion cast (unumber) $80 in (bool~) sin8s::$14 ← (byte) sin8s::usinx#1 >= (number) $80
Adding number conversion cast (unumber) 0 in (bool~) sin8s::$17 ← (byte) sin8s::isUpper#2 != (number) 0
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#2)
Adding number conversion cast (snumber) 0 in (bool~) print_sbyte::$0 ← (signed byte) print_sbyte::b#2 < (number) 0
Adding number conversion cast (unumber) 4 in (byte~) print_byte::$0 ← (byte) print_byte::b#1 >> (number) 4
Adding number conversion cast (unumber) $f in (number~) print_byte::$2 ← (byte) print_byte::b#2 & (number) $f
Adding number conversion cast (unumber) print_byte::$2 in (number~) print_byte::$2 ← (byte) print_byte::b#2 & (unumber)(number) $f
Adding number conversion cast (unumber) $3e8 in (word) memset::num#0 ← (number) $3e8
Successful SSA optimization PassNAddNumberTypeConversions
Inlining cast (word) divr16u::rem#3 ← (unumber)(number) 0
Inlining cast (word) divr16u::rem#4 ← (unumber)(number) 0
Inlining cast (byte) sin16s::isUpper#1 ← (unumber)(number) 1
Inlining cast (byte) mulu16_sel::select#0 ← (unumber)(number) 0
Inlining cast (byte) mulu16_sel::select#1 ← (unumber)(number) 1
Inlining cast (word) mulu16_sel::v2#2 ← (unumber)(number) $10000/(number) 6
Inlining cast (byte) mulu16_sel::select#2 ← (unumber)(number) 1
Inlining cast (byte) mulu16_sel::select#3 ← (unumber)(number) 0
Inlining cast (byte) mulu16_sel::select#4 ← (unumber)(number) 0
Inlining cast (signed word~) sin16s::$14 ← (signed word)(word) sin16s::usinx#1
Inlining cast (signed word~) sin16s::$19 ← (signed word)(word) sin16s::usinx#3
Inlining cast (byte) sin8s::isUpper#1 ← (unumber)(number) 1
Inlining cast (byte) mulu8_sel::select#0 ← (unumber)(number) 0
Inlining cast (byte) mulu8_sel::select#1 ← (unumber)(number) 1
Inlining cast (byte) mulu8_sel::select#2 ← (unumber)(number) 1
Inlining cast (byte) mulu8_sel::select#3 ← (unumber)(number) 0
Inlining cast (byte) mulu8_sel::select#4 ← (unumber)(number) 0
Inlining cast (signed byte~) sin8s::$16 ← (signed byte)(byte) sin8s::usinx#4
Inlining cast (signed byte~) sin8s::$21 ← (signed byte)(byte) sin8s::usinx#6
Inlining cast (byte*~) memset::$2 ← (byte*)(void*) memset::str#2
Inlining cast (byte*) memset::dst#0 ← (byte*)(void*) memset::str#2
Inlining cast (byte~) print_sbyte::$1 ← (byte)(signed byte) print_sbyte::b#4
Inlining cast (word) memset::num#0 ← (unumber)(number) $3e8
Inlining cast (word~) main::$3 ← (word)(byte) main::i#2
Inlining cast (signed byte~) main::$6 ← (signed byte)(byte~) main::$5
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 integer cast 0
Simplifying constant integer cast (word) div32u16u::quotient_hi#1
Simplifying constant integer cast (word) div32u16u::quotient_lo#0
Simplifying constant integer cast 0
Simplifying constant integer cast 1
Simplifying constant integer cast 0
Simplifying constant integer cast 1
Simplifying constant integer cast 1
Simplifying constant integer cast 0
Simplifying constant integer cast 1
Simplifying constant integer cast 0
Simplifying constant integer cast 1
Simplifying constant integer cast 1
Simplifying constant integer cast 1
Simplifying constant integer cast 3
Simplifying constant integer cast 0
Simplifying constant integer cast 1
Simplifying constant integer cast 1
Simplifying constant integer cast 0
Simplifying constant integer cast 0
Simplifying constant integer cast 4
Simplifying constant integer cast 0
Simplifying constant integer cast 1
Simplifying constant integer cast 3
Simplifying constant integer cast 0
Simplifying constant integer cast 1
Simplifying constant integer cast 1
Simplifying constant integer cast 0
Simplifying constant integer cast 0
Simplifying constant integer cast 4
Simplifying constant integer cast $80
Simplifying constant integer cast 0
Simplifying constant integer cast 0
Simplifying constant pointer cast (byte*) 1024
Simplifying constant integer cast 0
Simplifying constant integer cast 0
Simplifying constant integer cast 4
Simplifying constant integer cast $f
Simplifying constant integer cast $3e8
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) 0
Finalized unsigned number type (byte) 1
Finalized unsigned number type (byte) 0
Finalized unsigned number type (byte) 1
Finalized unsigned number type (byte) 1
Finalized unsigned number type (byte) 0
Finalized unsigned number type (byte) 1
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) 3
Finalized unsigned number type (byte) 0
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) 4
Finalized unsigned number type (byte) 0
Finalized unsigned number type (byte) 1
Finalized unsigned number type (byte) 3
Finalized unsigned number type (byte) 0
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) 4
Finalized unsigned number type (byte) $80
Finalized unsigned number type (byte) 0
Finalized unsigned number type (byte) 0
Finalized unsigned number type (byte) 0
Finalized signed number type (signed byte) 0
Finalized unsigned number type (byte) 4
Finalized unsigned number type (byte) $f
Finalized unsigned number type (word) $3e8
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#8 | (byte) 1
Inferred type updated to byte in (unumber~) mul8u::$1 ← (byte) mul8u::a#3 & (byte) 1
Inferred type updated to byte in (unumber~) mul16u::$1 ← (word) mul16u::a#3 & (byte) 1
Inferred type updated to byte in (unumber~) print_byte::$2 ← (byte) print_byte::b#2 & (byte) $f
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#7 < (word) divr16u::divisor#3 from [17] (bool~) divr16u::$8 ← (word) divr16u::rem#7 >= (word) divr16u::divisor#3
Inversing boolean not [89] (bool~) mul8u::$3 ← (byte~) mul8u::$1 == (byte) 0 from [88] (bool~) mul8u::$2 ← (byte~) mul8u::$1 != (byte) 0
Inversing boolean not [113] (bool~) mul16u::$3 ← (byte~) mul16u::$1 == (byte) 0 from [112] (bool~) mul16u::$2 ← (byte~) mul16u::$1 != (byte) 0
Inversing boolean not [187] (bool~) sin16s::$1 ← (dword) sin16s::x#3 < (const dword) PI_u4f28 from [186] (bool~) sin16s::$0 ← (dword) sin16s::x#3 >= (const dword) PI_u4f28
Inversing boolean not [191] (bool~) sin16s::$3 ← (dword) sin16s::x#4 < (const dword) PI_HALF_u4f28 from [190] (bool~) sin16s::$2 ← (dword) sin16s::x#4 >= (const dword) PI_HALF_u4f28
Inversing boolean not [250] (bool~) sin16s::$16 ← (byte) sin16s::isUpper#2 == (byte) 0 from [249] (bool~) sin16s::$15 ← (byte) sin16s::isUpper#2 != (byte) 0
Inversing boolean not [267] (bool~) sin8s::$1 ← (word) sin8s::x#3 < (const word) PI_u4f12 from [266] (bool~) sin8s::$0 ← (word) sin8s::x#3 >= (const word) PI_u4f12
Inversing boolean not [271] (bool~) sin8s::$3 ← (word) sin8s::x#4 < (const word) PI_HALF_u4f12 from [270] (bool~) sin8s::$2 ← (word) sin8s::x#4 >= (const word) PI_HALF_u4f12
Inversing boolean not [328] (bool~) sin8s::$15 ← (byte) sin8s::usinx#1 < (byte) $80 from [327] (bool~) sin8s::$14 ← (byte) sin8s::usinx#1 >= (byte) $80
Inversing boolean not [337] (bool~) sin8s::$18 ← (byte) sin8s::isUpper#2 == (byte) 0 from [336] (bool~) sin8s::$17 ← (byte) sin8s::isUpper#2 != (byte) 0
Inversing boolean not [378] (bool~) memset::$1 ← (word) memset::num#1 <= (byte) 0 from [377] (bool~) memset::$0 ← (word) memset::num#1 > (byte) 0
Successful SSA optimization Pass2UnaryNotSimplification
Alias (word) divr16u::rem#0 = (word~) divr16u::$0 (word) divr16u::rem#8 
Alias (word) divr16u::dividend#0 = (word~) divr16u::$6 (word) divr16u::dividend#9 
Alias (word) divr16u::quotient#1 = (word~) divr16u::$7 (word) divr16u::quotient#4 
Alias (word) divr16u::dividend#4 = (word) divr16u::dividend#8 
Alias (word) divr16u::quotient#6 = (word) divr16u::quotient#7 
Alias (word) divr16u::divisor#5 = (word) divr16u::divisor#6 
Alias (byte) divr16u::i#5 = (byte) divr16u::i#6 
Alias (word) divr16u::rem#1 = (word~) divr16u::$5 
Alias (word) divr16u::rem#7 = (word) divr16u::rem#9 
Alias (word) divr16u::divisor#3 = (word) divr16u::divisor#4 
Alias (byte) divr16u::i#3 = (byte) divr16u::i#4 
Alias (word) divr16u::rem#2 = (word~) divr16u::$10 
Alias (word) divr16u::rem#10 = (word) divr16u::rem#12 
Alias (word) divr16u::return#0 = (word) divr16u::quotient#5 (word) divr16u::quotient#8 (word) divr16u::return#5 (word) divr16u::return#1 
Alias (word) rem16u#1 = (word) rem16u#16 (word) rem16u#2 
Alias (word) divr16u::return#2 = (word) divr16u::return#6 
Alias (word) rem16u#17 = (word) rem16u#3 (word) rem16u#18 (word) rem16u#4 
Alias (word) div16u::return#0 = (word~) div16u::$0 (word) div16u::return#3 (word) div16u::return#1 
Alias (word) divr16u::dividend#2 = (word~) div32u16u::$0 
Alias (word) divr16u::return#3 = (word) divr16u::return#7 
Alias (dword) div32u16u::dividend#1 = (dword) div32u16u::dividend#2 
Alias (word) div32u16u::divisor#1 = (word) div32u16u::divisor#2 
Alias (word) rem16u#19 = (word) rem16u#5 
Alias (word) div32u16u::quotient_hi#0 = (word~) div32u16u::$1 (word) div32u16u::quotient_hi#1 
Alias (word) divr16u::dividend#3 = (word~) div32u16u::$2 
Alias (word) divr16u::return#4 = (word) divr16u::return#8 
Alias (word) rem16u#20 = (word) rem16u#6 (word) rem16u#21 (word) rem16u#7 
Alias (word) div32u16u::quotient_lo#0 = (word~) div32u16u::$3 
Alias (dword) div32u16u::return#0 = (dword) div32u16u::quotient#0 (dword~) div32u16u::$4 (dword) div32u16u::return#3 (dword) div32u16u::return#1 
Alias (byte) mul8u::a#2 = (byte) mul8u::a#3 (byte) mul8u::a#6 
Alias (word) mul8u::mb#3 = (word) mul8u::mb#4 (word) mul8u::mb#5 
Alias (word) mul8u::res#2 = (word) mul8u::res#5 (word) mul8u::res#4 (word) mul8u::return#0 (word) mul8u::res#3 (word) mul8u::return#3 (word) mul8u::return#1 
Alias (byte) mul8u::a#0 = (byte~) mul8u::$5 
Alias (word) mul8u::mb#1 = (word~) mul8u::$6 
Alias (word) mul8u::res#1 = (word~) mul8u::$4 
Alias (word) mul16u::a#2 = (word) mul16u::a#3 (word) mul16u::a#6 
Alias (dword) mul16u::mb#3 = (dword) mul16u::mb#4 (dword) mul16u::mb#5 
Alias (dword) mul16u::res#2 = (dword) mul16u::res#5 (dword) mul16u::res#4 (dword) mul16u::return#0 (dword) mul16u::res#3 (dword) mul16u::return#3 (dword) mul16u::return#1 
Alias (word) mul16u::a#0 = (word~) mul16u::$5 
Alias (dword) mul16u::mb#1 = (dword~) mul16u::$6 
Alias (dword) mul16u::res#1 = (dword~) mul16u::$4 
Alias (dword) div32u16u::return#2 = (dword) div32u16u::return#4 
Alias (word) sin16s_gen::wavelength#1 = (word) sin16s_gen::wavelength#3 
Alias (signed word*) sin16s_gen::sintab#5 = (signed word*) sin16s_gen::sintab#6 
Alias (word) rem16u#22 = (word) rem16u#8 
Alias (dword) sin16s_gen::step#0 = (dword~) sin16s_gen::$0 
Alias (dword) sin16s_gen::x#2 = (dword) sin16s_gen::x#4 (dword) sin16s_gen::x#3 
Alias (signed word*) sin16s_gen::sintab#2 = (signed word*) sin16s_gen::sintab#3 (signed word*) sin16s_gen::sintab#4 
Alias (dword) sin16s_gen::step#1 = (dword) sin16s_gen::step#2 (dword) sin16s_gen::step#3 
Alias (word) sin16s_gen::i#2 = (word) sin16s_gen::i#4 (word) sin16s_gen::i#3 
Alias (word) sin16s_gen::wavelength#2 = (word) sin16s_gen::wavelength#5 (word) sin16s_gen::wavelength#4 
Alias (word) rem16u#23 = (word) rem16u#43 (word) rem16u#33 (word) rem16u#39 (word) rem16u#9 
Alias (signed word) sin16s::return#0 = (signed word) sin16s::return#3 
Alias (dword) sin16s_gen::x#1 = (dword~) sin16s_gen::$3 
Alias (word) div16u::return#2 = (word) div16u::return#4 
Alias (word) sin8s_gen::wavelength#1 = (word) sin8s_gen::wavelength#3 
Alias (signed byte*) sin8s_gen::sintab#5 = (signed byte*) sin8s_gen::sintab#6 
Alias (word) rem16u#10 = (word) rem16u#24 
Alias (word) sin8s_gen::step#0 = (word~) sin8s_gen::$0 
Alias (word) sin8s_gen::x#2 = (word) sin8s_gen::x#4 (word) sin8s_gen::x#3 
Alias (signed byte*) sin8s_gen::sintab#2 = (signed byte*) sin8s_gen::sintab#3 (signed byte*) sin8s_gen::sintab#4 
Alias (word) sin8s_gen::step#1 = (word) sin8s_gen::step#2 (word) sin8s_gen::step#3 
Alias (word) sin8s_gen::i#2 = (word) sin8s_gen::i#4 (word) sin8s_gen::i#3 
Alias (word) sin8s_gen::wavelength#2 = (word) sin8s_gen::wavelength#5 (word) sin8s_gen::wavelength#4 
Alias (word) rem16u#11 = (word) rem16u#44 (word) rem16u#35 (word) rem16u#40 (word) rem16u#25 
Alias (signed byte) sin8s::return#0 = (signed byte) sin8s::return#3 
Alias (word) sin8s_gen::x#1 = (word~) sin8s_gen::$3 
Alias (dword) sin16s::x#3 = (dword) sin16s::x#5 
Alias (dword) sin16s::x#1 = (dword~) sin16s::$17 
Alias (word) sin16s::x1#0 = (word~) sin16s::$5 (word) sin16s::x1#1 (word) sin16s::x1#4 (word) sin16s::x1#2 (word) sin16s::x1#3 
Alias (word) mulu16_sel::return#0 = (word) mulu16_sel::return#7 
Alias (byte) sin16s::isUpper#2 = (byte) sin16s::isUpper#6 (byte) sin16s::isUpper#7 (byte) sin16s::isUpper#5 (byte) sin16s::isUpper#4 (byte) sin16s::isUpper#3 
Alias (word) sin16s::x2#0 = (word~) sin16s::$6 
Alias (word) mulu16_sel::return#1 = (word) mulu16_sel::return#8 
Alias (word) sin16s::x3#0 = (word~) sin16s::$7 (word) sin16s::x3#1 
Alias (word) mulu16_sel::return#2 = (word) mulu16_sel::return#9 
Alias (word) sin16s::x3_6#0 = (word~) sin16s::$8 
Alias (word) sin16s::usinx#0 = (word~) sin16s::$9 (word) sin16s::usinx#4 (word) sin16s::usinx#2 
Alias (word) mulu16_sel::return#10 = (word) mulu16_sel::return#3 
Alias (word) sin16s::x4#0 = (word~) sin16s::$10 
Alias (word) mulu16_sel::return#11 = (word) mulu16_sel::return#4 
Alias (word) sin16s::x5#0 = (word~) sin16s::$11 
Alias (word) sin16s::x5_128#0 = (word~) sin16s::$12 
Alias (word) sin16s::usinx#1 = (word~) sin16s::$13 (word) sin16s::usinx#3 
Alias (signed word) sin16s::sinx#0 = (signed word~) sin16s::$14 
Alias (dword) sin16s::x#4 = (dword) sin16s::x#7 
Alias (byte) sin16s::isUpper#8 = (byte) sin16s::isUpper#9 
Alias (dword) sin16s::x#2 = (dword~) sin16s::$18 
Alias (signed word) sin16s::return#1 = (signed word) sin16s::sinx#2 (signed word) sin16s::return#4 (signed word) sin16s::return#2 
Alias (signed word) sin16s::sinx#1 = (signed word~) sin16s::$20 
Alias (word) sin8s::x#3 = (word) sin8s::x#5 
Alias (word) sin8s::x#1 = (word~) sin8s::$19 
Alias (byte) sin8s::x1#0 = (byte~) sin8s::$5 (byte) sin8s::x1#1 (byte) sin8s::x1#4 (byte) sin8s::x1#2 (byte) sin8s::x1#3 
Alias (byte) mulu8_sel::return#0 = (byte) mulu8_sel::return#7 
Alias (byte) sin8s::isUpper#3 = (byte) sin8s::isUpper#8 (byte) sin8s::isUpper#9 (byte) sin8s::isUpper#7 (byte) sin8s::isUpper#6 (byte) sin8s::isUpper#5 (byte) sin8s::isUpper#4 
Alias (byte) sin8s::x2#0 = (byte~) sin8s::$6 
Alias (byte) mulu8_sel::return#1 = (byte) mulu8_sel::return#8 
Alias (byte) sin8s::x3#0 = (byte~) sin8s::$7 (byte) sin8s::x3#1 
Alias (byte) mulu8_sel::return#2 = (byte) mulu8_sel::return#9 
Alias (byte) sin8s::x3_6#0 = (byte~) sin8s::$8 
Alias (byte) sin8s::usinx#0 = (byte~) sin8s::$9 (byte) sin8s::usinx#7 (byte) sin8s::usinx#3 
Alias (byte) mulu8_sel::return#10 = (byte) mulu8_sel::return#3 
Alias (byte) sin8s::x4#0 = (byte~) sin8s::$10 
Alias (byte) mulu8_sel::return#11 = (byte) mulu8_sel::return#4 
Alias (byte) sin8s::x5#0 = (byte~) sin8s::$11 
Alias (byte) sin8s::x5_128#0 = (byte~) sin8s::$12 
Alias (byte) sin8s::usinx#1 = (byte~) sin8s::$13 (byte) sin8s::usinx#5 
Alias (word) sin8s::x#4 = (word) sin8s::x#7 
Alias (byte) sin8s::isUpper#10 = (byte) sin8s::isUpper#11 
Alias (word) sin8s::x#2 = (word~) sin8s::$20 
Alias (signed byte) sin8s::sinx#0 = (signed byte~) sin8s::$16 
Alias (signed byte) sin8s::return#1 = (signed byte) sin8s::sinx#2 (signed byte) sin8s::return#4 (signed byte) sin8s::return#2 
Alias (byte) sin8s::usinx#4 = (byte) sin8s::usinx#6 
Alias (signed byte) sin8s::sinx#1 = (signed byte~) sin8s::$22 
Alias (dword) mul16u::return#2 = (dword) mul16u::return#4 
Alias (byte) mulu16_sel::select#5 = (byte) mulu16_sel::select#6 
Alias (word) mulu16_sel::return#12 = (word) mulu16_sel::return#5 (word~) mulu16_sel::$2 (word) mulu16_sel::return#6 
Alias (word) mul8u::return#2 = (word) mul8u::return#4 
Alias (byte) mulu8_sel::select#5 = (byte) mulu8_sel::select#6 
Alias (byte) mulu8_sel::return#12 = (byte) mulu8_sel::return#5 (byte~) mulu8_sel::$2 (byte) mulu8_sel::return#6 
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#42 (word) rem16u#38 
Alias (byte*) print_line_cursor#0 = (byte*) print_screen#0 (byte*) print_char_cursor#0 (byte*) print_line_cursor#12 (byte*) print_char_cursor#43 (byte*) print_screen#6 
Alias (byte*) print_str::str#2 = (byte*) print_str::str#3 
Alias (byte*) print_char_cursor#19 = (byte*) print_char_cursor#36 (byte*) print_char_cursor#20 (byte*) print_char_cursor#2 
Alias (byte*) print_char_cursor#37 = (byte*) print_char_cursor#45 (byte*) print_char_cursor#38 
Alias (signed byte) print_sbyte::b#2 = (signed byte) print_sbyte::b#5 (signed byte) print_sbyte::b#3 (signed byte) print_sbyte::b#7 (signed byte) print_sbyte::b#6 
Alias (byte*) print_char_cursor#21 = (byte*) print_char_cursor#3 
Alias (signed byte) print_sbyte::b#0 = (signed byte~) print_sbyte::$5 
Alias (byte*) print_char_cursor#22 = (byte*) print_char_cursor#4 
Alias (byte) print_byte::b#0 = (byte~) print_sbyte::$1 
Alias (byte*) print_char_cursor#23 = (byte*) print_char_cursor#5 (byte*) print_char_cursor#24 (byte*) print_char_cursor#6 
Alias (byte) print_byte::b#1 = (byte) print_byte::b#2 
Alias (byte*) print_char_cursor#25 = (byte*) print_char_cursor#7 
Alias (byte*) print_char_cursor#26 = (byte*) print_char_cursor#8 (byte*) print_char_cursor#27 (byte*) print_char_cursor#9 
Alias (byte*) print_char_cursor#10 = (byte*) print_char_cursor#29 (byte*) print_char_cursor#11 
Alias (byte*) print_line_cursor#1 = (byte*) print_screen#2 (byte*) print_screen#1 (byte*) print_char_cursor#12 (byte*) print_line_cursor#6 (byte*) print_char_cursor#30 (byte*) print_line_cursor#2 (byte*) print_char_cursor#13 
Alias (byte*) print_screen#3 = (byte*) print_screen#4 (byte*) print_screen#5 
Alias (byte*) print_line_cursor#10 = (byte*) print_line_cursor#13 (byte*) print_line_cursor#15 
Alias (byte*) print_char_cursor#41 = (byte*) print_char_cursor#46 (byte*) print_char_cursor#47 
Alias (word) rem16u#12 = (word) rem16u#26 
Alias (word) rem16u#13 = (word) rem16u#27 (word) rem16u#46 
Alias (byte*) print_line_cursor#3 = (byte*) print_line_cursor#7 
Alias (byte*) print_char_cursor#14 = (byte*) print_char_cursor#31 
Alias (signed byte) main::sd#0 = (signed byte~) main::$7 
Alias (byte) main::i#2 = (byte) main::i#4 (byte) main::i#3 
Alias (word) rem16u#14 = (word) rem16u#41 (word) rem16u#45 (word) rem16u#37 (word) rem16u#28 
Alias (byte*) print_line_cursor#11 = (byte*) print_line_cursor#14 (byte*) print_line_cursor#16 (byte*) print_line_cursor#8 (byte*) print_line_cursor#4 
Alias (byte*) print_char_cursor#15 = (byte*) print_char_cursor#32 
Alias (byte*) print_char_cursor#16 = (byte*) print_char_cursor#33 (byte*) print_char_cursor#34 (byte*) print_char_cursor#17 
Alias (word) rem16u#15 = (word) rem16u#29 
Alias (byte*) print_line_cursor#5 = (byte*) print_line_cursor#9 
Alias (byte*) print_char_cursor#18 = (byte*) print_char_cursor#35 
Successful SSA optimization Pass2AliasElimination
Alias (word) divr16u::dividend#4 = (word) divr16u::dividend#5 
Alias (word) divr16u::quotient#3 = (word) divr16u::quotient#6 
Alias (word) divr16u::divisor#3 = (word) divr16u::divisor#5 (word) divr16u::divisor#8 
Alias (byte) divr16u::i#2 = (byte) divr16u::i#3 (byte) divr16u::i#5 
Alias (word) divr16u::dividend#0 = (word) divr16u::dividend#7 
Alias (byte) mul8u::a#2 = (byte) mul8u::a#4 
Alias (word) mul8u::mb#2 = (word) mul8u::mb#3 
Alias (word) mul16u::a#2 = (word) mul16u::a#4 
Alias (dword) mul16u::mb#2 = (dword) mul16u::mb#3 
Alias (byte) sin16s::isUpper#2 = (byte) sin16s::isUpper#8 
Alias (byte) sin8s::isUpper#10 = (byte) sin8s::isUpper#3 (byte) sin8s::isUpper#2 
Successful SSA optimization Pass2AliasElimination
Identical Phi Values (word) divr16u::divisor#3 (word) divr16u::divisor#7
Identical Phi Values (word) div16u::dividend#1 (word) div16u::dividend#0
Identical Phi Values (word) div16u::divisor#1 (word) div16u::divisor#0
Identical Phi Values (word) rem16u#30 (word) rem16u#34
Identical Phi Values (word) rem16u#17 (word) rem16u#1
Identical Phi Values (dword) div32u16u::dividend#1 (dword) div32u16u::dividend#0
Identical Phi Values (word) div32u16u::divisor#1 (word) div32u16u::divisor#0
Identical Phi Values (word) rem16u#31 (word) rem16u#32
Identical Phi Values (word) rem16u#19 (word) rem16u#1
Identical Phi Values (word) rem16u#20 (word) rem16u#1
Identical Phi Values (byte) mul8u::b#1 (byte) mul8u::b#0
Identical Phi Values (byte) mul8u::a#5 (byte) mul8u::a#1
Identical Phi Values (word) mul16u::b#1 (word) mul16u::b#0
Identical Phi Values (word) mul16u::a#5 (word) mul16u::a#1
Identical Phi Values (word) sin16s_gen::wavelength#1 (word) sin16s_gen::wavelength#0
Identical Phi Values (word) rem16u#32 (word) rem16u#12
Identical Phi Values (signed word*) sin16s_gen::sintab#5 (signed word*) sin16s_gen::sintab#1
Identical Phi Values (word) rem16u#22 (word) rem16u#20
Identical Phi Values (word) sin16s_gen::wavelength#2 (word) sin16s_gen::wavelength#1
Identical Phi Values (word) rem16u#23 (word) rem16u#22
Identical Phi Values (dword) sin16s_gen::step#1 (dword) sin16s_gen::step#0
Identical Phi Values (word) sin8s_gen::wavelength#1 (word) sin8s_gen::wavelength#0
Identical Phi Values (word) rem16u#34 (word) rem16u#36
Identical Phi Values (signed byte*) sin8s_gen::sintab#5 (signed byte*) sin8s_gen::sintab#1
Identical Phi Values (word) rem16u#10 (word) rem16u#17
Identical Phi Values (word) sin8s_gen::wavelength#2 (word) sin8s_gen::wavelength#1
Identical Phi Values (word) rem16u#11 (word) rem16u#10
Identical Phi Values (word) sin8s_gen::step#1 (word) sin8s_gen::step#0
Identical Phi Values (dword) sin16s::x#3 (dword) sin16s::x#0
Identical Phi Values (word) sin8s::x#3 (word) sin8s::x#0
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_str::str#4 (byte*) print_str::str#1
Identical Phi Values (byte*) print_char_cursor#44 (byte*) print_char_cursor#15
Identical Phi Values (signed byte) print_sbyte::b#2 (signed byte) print_sbyte::b#1
Identical Phi Values (byte*) print_char_cursor#37 (byte*) print_char_cursor#42
Identical Phi Values (byte*) print_char_cursor#21 (byte*) print_char_cursor#10
Identical Phi Values (byte*) print_char_cursor#22 (byte*) print_char_cursor#10
Identical Phi Values (byte*) print_char_cursor#23 (byte*) print_char_cursor#26
Identical Phi Values (byte) print_byte::b#1 (byte) print_byte::b#0
Identical Phi Values (byte*) print_char_cursor#40 (byte*) print_char_cursor#39
Identical Phi Values (byte*) print_char_cursor#25 (byte*) print_char_cursor#10
Identical Phi Values (byte*) print_char_cursor#26 (byte*) print_char_cursor#10
Identical Phi Values (byte*) print_line_cursor#1 (byte*) print_screen#3
Identical Phi Values (word) rem16u#36 (word) rem16u#0
Identical Phi Values (byte*) print_screen#3 (byte*) print_line_cursor#0
Identical Phi Values (byte*) print_line_cursor#10 (byte*) print_line_cursor#0
Identical Phi Values (byte*) print_char_cursor#41 (byte*) print_line_cursor#0
Identical Phi Values (word) rem16u#12 (word) rem16u#11
Identical Phi Values (word) rem16u#13 (word) rem16u#23
Identical Phi Values (byte*) print_line_cursor#3 (byte*) print_line_cursor#1
Identical Phi Values (byte*) print_char_cursor#14 (byte*) print_line_cursor#1
Identical Phi Values (word) rem16u#14 (word) rem16u#13
Identical Phi Values (byte*) print_line_cursor#11 (byte*) print_line_cursor#3
Identical Phi Values (byte*) print_char_cursor#15 (byte*) print_char_cursor#23
Identical Phi Values (byte*) print_char_cursor#16 (byte*) print_char_cursor#19
Identical Phi Values (word) rem16u#15 (word) rem16u#14
Identical Phi Values (byte*) print_line_cursor#5 (byte*) print_line_cursor#11
Identical Phi Values (byte*) print_char_cursor#18 (byte*) print_char_cursor#16
Successful SSA optimization Pass2IdenticalPhiElimination
Identical Phi Values (void*) memset::return#0 (void*) memset::str#0
Identical Phi Values (byte*) print_char_cursor#39 (byte*) print_char_cursor#10
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#7<(word) divr16u::divisor#7) goto divr16u::@3
Simple Condition (bool~) divr16u::$11 [19] if((byte) divr16u::i#1!=rangelast(0,$f)) goto divr16u::@1
Simple Condition (bool~) mul8u::$0 [55] if((byte) mul8u::a#2!=(byte) 0) goto mul8u::@2
Simple Condition (bool~) mul8u::$3 [58] if((byte~) mul8u::$1==(byte) 0) goto mul8u::@4
Simple Condition (bool~) mul16u::$0 [69] if((word) mul16u::a#2!=(byte) 0) goto mul16u::@2
Simple Condition (bool~) mul16u::$3 [72] if((byte~) mul16u::$1==(byte) 0) goto mul16u::@4
Simple Condition (bool~) sin16s_gen::$1 [89] if((word) sin16s_gen::i#2<(word) sin16s_gen::wavelength#0) goto sin16s_gen::@2
Simple Condition (bool~) sin8s_gen::$1 [110] if((word) sin8s_gen::i#2<(word) sin8s_gen::wavelength#0) goto sin8s_gen::@2
Simple Condition (bool~) sin16s::$1 [123] if((dword) sin16s::x#0<(const dword) PI_u4f28) goto sin16s::@1
Simple Condition (bool~) sin16s::$3 [126] if((dword) sin16s::x#4<(const dword) PI_HALF_u4f28) goto sin16s::@2
Simple Condition (bool~) sin16s::$16 [167] if((byte) sin16s::isUpper#2==(byte) 0) goto sin16s::@3
Simple Condition (bool~) sin8s::$1 [176] if((word) sin8s::x#0<(const word) PI_u4f12) goto sin8s::@1
Simple Condition (bool~) sin8s::$3 [179] if((word) sin8s::x#4<(const word) PI_HALF_u4f12) goto sin8s::@2
Simple Condition (bool~) sin8s::$15 [219] if((byte) sin8s::usinx#1<(byte) $80) goto sin8s::@3
Simple Condition (bool~) sin8s::$18 [224] if((byte) sin8s::isUpper#10==(byte) 0) goto sin8s::@4
Simple Condition (bool~) memset::$1 [250] if((word) memset::num#0<=(byte) 0) goto memset::@1
Simple Condition (bool~) memset::$4 [257] if((byte*) memset::dst#2!=(byte*) memset::end#0) goto memset::@5
Simple Condition (bool~) print_str::$0 [265] if((byte) 0!=*((byte*) print_str::str#2)) goto print_str::@2
Simple Condition (bool~) print_sbyte::$0 [272] if((signed byte) print_sbyte::b#1<(signed byte) 0) goto print_sbyte::@1
Simple Condition (bool~) main::$10 [335] if((byte) main::i#1!=rangelast(0,$bf)) goto main::@1
Successful SSA optimization Pass2ConditionalJumpSimplification
Constant right-side identified [145] (word) mulu16_sel::v2#2 ← (unumber)(number) $10000/(number) 6
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const word) rem16u#0 = 0
Constant (const word) divr16u::quotient#0 = 0
Constant (const byte) divr16u::i#0 = 0
Constant (const word) divr16u::rem#3 = 0
Constant (const word) divr16u::rem#4 = 0
Constant (const word) mul8u::res#0 = 0
Constant (const dword) mul16u::res#0 = 0
Constant (const dword) div32u16u::dividend#0 = PI2_u4f28
Constant (const dword) sin16s_gen::x#0 = 0
Constant (const word) sin16s_gen::i#0 = 0
Constant (const word) div16u::dividend#0 = PI2_u4f12
Constant (const word) sin8s_gen::x#0 = 0
Constant (const word) sin8s_gen::i#0 = 0
Constant (const byte) sin16s::isUpper#0 = 0
Constant (const byte) sin16s::isUpper#1 = 1
Constant (const byte) mulu16_sel::select#0 = 0
Constant (const byte) mulu16_sel::select#1 = 1
Constant (const word) mulu16_sel::v2#2 = (unumber)$10000/6
Constant (const byte) mulu16_sel::select#2 = 1
Constant (const byte) mulu16_sel::select#3 = 0
Constant (const byte) mulu16_sel::select#4 = 0
Constant (const byte) sin8s::isUpper#0 = 0
Constant (const byte) sin8s::isUpper#1 = 1
Constant (const byte) mulu8_sel::select#0 = 0
Constant (const byte) mulu8_sel::select#1 = 1
Constant (const byte) mulu8_sel::v2#2 = sin8s::DIV_6
Constant (const byte) mulu8_sel::select#2 = 1
Constant (const byte) mulu8_sel::select#3 = 0
Constant (const byte) mulu8_sel::select#4 = 0
Constant (const byte*) print_line_cursor#0 = (byte*) 1024
Constant (const byte) print_char::ch#0 = '-'
Constant (const byte) print_char::ch#1 = ' '
Constant (const byte) memset::c#0 = ' '
Constant (const word) memset::num#0 = $3e8
Constant (const signed byte*) sin8s_gen::sintab#1 = main::sintabb
Constant (const word) sin8s_gen::wavelength#0 = main::wavelength
Constant (const signed word*) sin16s_gen::sintab#1 = main::sintabw
Constant (const word) sin16s_gen::wavelength#0 = main::wavelength
Constant (const byte) main::i#0 = 0
Constant (const byte*) print_str::str#1 = main::str
Successful SSA optimization Pass2ConstantIdentification
Constant (const word) divr16u::dividend#1 = div16u::dividend#0
Constant (const word) div32u16u::divisor#0 = sin16s_gen::wavelength#0
Constant (const word) div16u::divisor#0 = sin8s_gen::wavelength#0
Constant (const void*) memset::str#0 = (void*)print_line_cursor#0
Successful SSA optimization Pass2ConstantIdentification
Constant (const word) divr16u::divisor#0 = div16u::divisor#0
Constant (const word) divr16u::divisor#1 = div32u16u::divisor#0
Constant (const word) divr16u::divisor#2 = div32u16u::divisor#0
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 [250] if((const word) memset::num#0<=(byte) 0) goto memset::@1
Successful SSA optimization Pass2ConstantIfs
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
Resolved ranged next value [333] main::i#1 ← ++ main::i#2 to ++
Resolved ranged comparison value [335] if(main::i#1!=rangelast(0,$bf)) goto main::@1 to (number) $c0
Eliminating unused constant (const void*) memset::return#2
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
Adding number conversion cast (unumber) $c0 in if((byte) main::i#1!=(number) $c0) goto main::@1
Successful SSA optimization PassNAddNumberTypeConversions
Simplifying constant integer cast $10
Simplifying constant integer cast $c0
Successful SSA optimization PassNCastSimplification
Finalized unsigned number type (byte) $10
Finalized unsigned number type (byte) $c0
Successful SSA optimization PassNFinalizeNumberTypeConversions
Constant right-side identified [22] (word) divr16u::dividend#2 ← > (const dword) div32u16u::dividend#0
Constant right-side identified [26] (word) divr16u::dividend#3 ← < (const dword) div32u16u::dividend#0
Constant right-side identified [184] (byte*) memset::end#0 ← (const byte*) memset::$2 + (const word) memset::num#0
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const word) divr16u::dividend#2 = >div32u16u::dividend#0
Constant (const word) divr16u::dividend#3 = <div32u16u::dividend#0
Constant (const byte*) memset::end#0 = memset::$2+memset::num#0
Successful SSA optimization Pass2ConstantIdentification
Inlining Noop Cast [113] (signed word) sin16s::sinx#0 ← (signed word)(word) sin16s::usinx#1 keeping sin16s::usinx#1
Inlining Noop Cast [117] (signed word~) sin16s::$19 ← (signed word)(word) sin16s::usinx#1 keeping sin16s::usinx#1
Inlining Noop Cast [157] (signed byte) sin8s::sinx#0 ← (signed byte)(byte) sin8s::usinx#4 keeping sin8s::usinx#4
Inlining Noop Cast [161] (signed byte~) sin8s::$21 ← (signed byte)(byte) sin8s::usinx#4 keeping sin8s::usinx#4
Successful SSA optimization Pass2NopCastInlining
Inlining Noop Cast [224] (signed byte~) main::$6 ← (signed byte)(byte~) main::$5 keeping main::$6
Successful SSA optimization Pass2NopCastInlining
Rewriting multiplication to use shift [220] (word~) main::$11 ← (word~) main::$3 * (const byte) SIZEOF_SIGNED_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::rem#4
Inlining constant with var siblings (const word) divr16u::dividend#1
Inlining constant with var siblings (const word) divr16u::divisor#0
Inlining constant with var siblings (const word) divr16u::divisor#1
Inlining constant with var siblings (const word) divr16u::divisor#2
Inlining constant with var siblings (const word) divr16u::dividend#2
Inlining constant with var siblings (const word) divr16u::dividend#3
Inlining constant with var siblings (const word) mul8u::res#0
Inlining constant with var siblings (const dword) mul16u::res#0
Inlining constant with var siblings (const dword) sin16s_gen::x#0
Inlining constant with var siblings (const word) sin16s_gen::i#0
Inlining constant with var siblings (const signed word*) sin16s_gen::sintab#1
Inlining constant with var siblings (const word) sin8s_gen::x#0
Inlining constant with var siblings (const word) sin8s_gen::i#0
Inlining constant with var siblings (const signed byte*) sin8s_gen::sintab#1
Inlining constant with var siblings (const byte) sin16s::isUpper#0
Inlining constant with var siblings (const byte) sin16s::isUpper#1
Inlining constant with var siblings (const byte) sin8s::isUpper#0
Inlining constant with var siblings (const byte) sin8s::isUpper#1
Inlining constant with var siblings (const byte) mulu16_sel::select#0
Inlining constant with var siblings (const byte) mulu16_sel::select#1
Inlining constant with var siblings (const word) mulu16_sel::v2#2
Inlining constant with var siblings (const byte) mulu16_sel::select#2
Inlining constant with var siblings (const byte) mulu16_sel::select#3
Inlining constant with var siblings (const byte) mulu16_sel::select#4
Inlining constant with var siblings (const byte) mulu8_sel::select#0
Inlining constant with var siblings (const byte) mulu8_sel::select#1
Inlining constant with var siblings (const byte) mulu8_sel::v2#2
Inlining constant with var siblings (const byte) mulu8_sel::select#2
Inlining constant with var siblings (const byte) mulu8_sel::select#3
Inlining constant with var siblings (const byte) mulu8_sel::select#4
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_char::ch#0
Inlining constant with var siblings (const byte) print_char::ch#1
Inlining constant with var siblings (const byte) main::i#0
Constant inlined divr16u::rem#3 = (byte) 0
Constant inlined divr16u::i#0 = (byte) 0
Constant inlined divr16u::rem#4 = (byte) 0
Constant inlined sin16s_gen::wavelength#0 = (const word) main::wavelength
Constant inlined div32u16u::dividend#0 = (const dword) PI2_u4f28
Constant inlined sin16s::isUpper#0 = (byte) 0
Constant inlined sin8s::isUpper#1 = (byte) 1
Constant inlined sin8s::isUpper#0 = (byte) 0
Constant inlined sin8s_gen::x#0 = (word) 0
Constant inlined mulu16_sel::select#4 = (byte) 0
Constant inlined memset::$2 = (byte*)(const void*) memset::str#0
Constant inlined divr16u::quotient#0 = (word) 0
Constant inlined mulu16_sel::select#2 = (byte) 1
Constant inlined mulu16_sel::select#3 = (byte) 0
Constant inlined mul16u::res#0 = (dword) 0
Constant inlined mulu16_sel::select#0 = (byte) 0
Constant inlined div16u::divisor#0 = (const word) main::wavelength
Constant inlined sin16s::isUpper#1 = (byte) 1
Constant inlined mulu16_sel::select#1 = (byte) 1
Constant inlined main::i#0 = (byte) 0
Constant inlined mulu8_sel::select#0 = (byte) 0
Constant inlined div16u::dividend#0 = (const word) PI2_u4f12
Constant inlined divr16u::divisor#1 = (const word) main::wavelength
Constant inlined mulu8_sel::select#2 = (byte) 1
Constant inlined divr16u::divisor#0 = (const word) main::wavelength
Constant inlined mulu8_sel::select#1 = (byte) 1
Constant inlined mulu8_sel::select#4 = (byte) 0
Constant inlined divr16u::divisor#2 = (const word) main::wavelength
Constant inlined mulu8_sel::select#3 = (byte) 0
Constant inlined sin16s_gen::i#0 = (word) 0
Constant inlined divr16u::dividend#1 = (const word) PI2_u4f12
Constant inlined divr16u::dividend#2 = >(const dword) PI2_u4f28
Constant inlined divr16u::dividend#3 = <(const dword) PI2_u4f28
Constant inlined sin16s_gen::sintab#1 = (const signed word*) main::sintabw
Constant inlined mulu8_sel::v2#2 = (const byte) sin8s::DIV_6
Constant inlined mul8u::res#0 = (word) 0
Constant inlined print_char::ch#1 = (byte) ' '
Constant inlined mulu16_sel::v2#2 = (word)(number) $10000/(number) 6
Constant inlined print_char::ch#0 = (byte) '-'
Constant inlined sin8s_gen::sintab#1 = (const signed byte*) main::sintabb
Constant inlined sin16s_gen::x#0 = (dword) 0
Constant inlined sin8s_gen::wavelength#0 = (const word) main::wavelength
Constant inlined memset::dst#0 = (byte*)(const void*) memset::str#0
Constant inlined div32u16u::divisor#0 = (const word) main::wavelength
Constant inlined print_str::str#1 = (const byte*) main::str
Constant inlined sin8s_gen::i#0 = (word) 0
Successful SSA optimization Pass2ConstantInlining
Identical Phi Values (word) divr16u::divisor#7 (const word) main::wavelength
Successful SSA optimization Pass2IdenticalPhiElimination
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 mul8u::@10(between mul8u::@2 and mul8u::@4)
Added new block during phi lifting mul16u::@10(between mul16u::@2 and mul16u::@4)
Added new block during phi lifting sin16s::@13(between sin16s and sin16s::@1)
Fixing phi predecessor for sin16s::isUpper#2 to new block ( sin16s -> sin16s::@13 ) during phi lifting.
Added new block during phi lifting sin16s::@14(between sin16s::@1 and sin16s::@2)
Added new block during phi lifting sin16s::@15(between sin16s::@12 and sin16s::@3)
Added new block during phi lifting sin8s::@15(between sin8s and sin8s::@1)
Fixing phi predecessor for sin8s::isUpper#10 to new block ( sin8s -> sin8s::@15 ) during phi lifting.
Added new block during phi lifting sin8s::@16(between sin8s::@1 and sin8s::@2)
Added new block during phi lifting sin8s::@17(between sin8s::@14 and sin8s::@3)
Added new block during phi lifting sin8s::@18(between sin8s::@3 and sin8s::@4)
Added new block during phi lifting main::@8(between main::@7 and main::@1)
Adding NOP phi() at start of @begin
Adding NOP phi() at start of @2
Adding NOP phi() at start of @33
Adding NOP phi() at start of @58
Adding NOP phi() at start of @59
Adding NOP phi() at start of @end
Adding NOP phi() at start of main
Adding NOP phi() at start of main::@3
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 print_sbyte::@7
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
Adding NOP phi() at start of sin16s_gen
Adding NOP phi() at start of mul16u::@3
Adding NOP phi() at start of div32u16u
Adding NOP phi() at start of sin8s_gen
Adding NOP phi() at start of mul8u::@3
Adding NOP phi() at start of div16u
CALL GRAPH
Calls in [] to main:4 
Calls in [main] to sin8s_gen:8 sin16s_gen:10 print_cls:12 print_sbyte:23 print_str:25 
Calls in [print_sbyte] to print_char:42 print_byte:46 print_char:50 
Calls in [print_byte] to print_char:61 print_char:66 
Calls in [print_cls] to memset:70 
Calls in [sin16s_gen] to div32u16u:83 sin16s:90 
Calls in [sin16s] to mulu16_sel:114 mulu16_sel:121 mulu16_sel:126 mulu16_sel:134 mulu16_sel:141 
Calls in [mulu16_sel] to mul16u:157 
Calls in [div32u16u] to divr16u:182 divr16u:187 
Calls in [sin8s_gen] to div16u:223 sin8s:230 
Calls in [sin8s] to mulu8_sel:254 mulu8_sel:261 mulu8_sel:266 mulu8_sel:274 mulu8_sel:281 
Calls in [mulu8_sel] to mul8u:302 
Calls in [div16u] to divr16u:327 

Created 46 initial phi equivalence classes
Coalesced [29] main::i#5 ← main::i#1
Coalesced [30] print_char_cursor#54 ← print_char_cursor#19
Coalesced [31] print_char_cursor#48 ← print_char_cursor#10
Coalesced [38] print_str::str#5 ← print_str::str#0
Coalesced [39] print_char_cursor#49 ← print_char_cursor#1
Coalesced [41] print_char_cursor#53 ← print_char_cursor#42
Coalesced [43] print_sbyte::b#9 ← print_sbyte::b#1
Coalesced (already) [49] print_char_cursor#52 ← print_char_cursor#42
Coalesced [52] print_sbyte::b#8 ← print_sbyte::b#0
Coalesced [59] print_char::ch#5 ← print_char::ch#2
Coalesced (already) [60] print_char_cursor#50 ← print_char_cursor#10
Coalesced [64] print_char::ch#6 ← print_char::ch#3
Coalesced (already) [65] print_char_cursor#51 ← print_char_cursor#10
Coalesced [81] memset::dst#4 ← memset::dst#1
Coalesced [97] sin16s_gen::i#5 ← sin16s_gen::i#1
Coalesced [98] sin16s_gen::x#5 ← sin16s_gen::x#1
Coalesced [99] sin16s_gen::sintab#7 ← sin16s_gen::sintab#0
Coalesced [102] sin16s::x#9 ← sin16s::x#1
Coalesced [106] sin16s::x#11 ← sin16s::x#2
Coalesced [112] mulu16_sel::v1#8 ← mulu16_sel::v1#0
Coalesced [113] mulu16_sel::v2#8 ← mulu16_sel::v2#0
Coalesced [119] mulu16_sel::v1#9 ← mulu16_sel::v1#1
Coalesced [120] mulu16_sel::v2#9 ← mulu16_sel::v2#1
Coalesced [125] mulu16_sel::v1#10 ← mulu16_sel::v1#2
Coalesced [132] mulu16_sel::v1#6 ← mulu16_sel::v1#3
Coalesced [133] mulu16_sel::v2#6 ← mulu16_sel::v2#3
Coalesced [139] mulu16_sel::v1#7 ← mulu16_sel::v1#4
Coalesced [140] mulu16_sel::v2#7 ← mulu16_sel::v2#4
Coalesced [148] sin16s::return#6 ← sin16s::sinx#1
Coalesced [152] sin16s::x#10 ← sin16s::x#4
Coalesced [153] sin16s::x#8 ← sin16s::x#0
Coalesced [164] mul16u::a#7 ← mul16u::a#1
Coalesced [165] mul16u::mb#6 ← mul16u::mb#0
Coalesced [173] mul16u::res#9 ← mul16u::res#1
Coalesced [177] mul16u::a#8 ← mul16u::a#0
Coalesced [178] mul16u::res#7 ← mul16u::res#6
Coalesced [179] mul16u::mb#7 ← mul16u::mb#1
Coalesced (already) [180] mul16u::res#8 ← mul16u::res#2
Coalesced [186] divr16u::rem#13 ← divr16u::rem#5
Coalesced [193] divr16u::rem#14 ← divr16u::rem#11
Coalesced [194] divr16u::dividend#10 ← divr16u::dividend#6
Coalesced [201] divr16u::rem#17 ← divr16u::rem#1
Coalesced [208] divr16u::rem#19 ← divr16u::rem#2
Coalesced [209] divr16u::return#10 ← divr16u::quotient#2
Coalesced [215] divr16u::rem#15 ← divr16u::rem#10
Coalesced [216] divr16u::dividend#11 ← divr16u::dividend#0
Coalesced [217] divr16u::quotient#9 ← divr16u::return#0
Coalesced [218] divr16u::i#7 ← divr16u::i#1
Coalesced [219] divr16u::rem#18 ← divr16u::rem#7
Coalesced [220] divr16u::return#9 ← divr16u::quotient#1
Coalesced [221] divr16u::rem#16 ← divr16u::rem#0
Coalesced [237] sin8s_gen::i#5 ← sin8s_gen::i#1
Coalesced [238] sin8s_gen::x#5 ← sin8s_gen::x#1
Coalesced [239] sin8s_gen::sintab#7 ← sin8s_gen::sintab#0
Coalesced [242] sin8s::x#9 ← sin8s::x#1
Coalesced [246] sin8s::x#11 ← sin8s::x#2
Coalesced [252] mulu8_sel::v1#10 ← mulu8_sel::v1#0
Coalesced [253] mulu8_sel::v2#9 ← mulu8_sel::v2#0
Coalesced [259] mulu8_sel::v1#6 ← mulu8_sel::v1#1
Coalesced [260] mulu8_sel::v2#6 ← mulu8_sel::v2#1
Coalesced [265] mulu8_sel::v1#7 ← mulu8_sel::v1#2
Coalesced [272] mulu8_sel::v1#8 ← mulu8_sel::v1#3
Coalesced [273] mulu8_sel::v2#7 ← mulu8_sel::v2#3
Coalesced [279] mulu8_sel::v1#9 ← mulu8_sel::v1#4
Coalesced [280] mulu8_sel::v2#8 ← mulu8_sel::v2#4
Coalesced [288] sin8s::usinx#9 ← sin8s::usinx#2
Coalesced [292] sin8s::return#6 ← sin8s::sinx#1
Coalesced [296] sin8s::usinx#8 ← sin8s::usinx#1
Coalesced [297] sin8s::x#10 ← sin8s::x#4
Coalesced [298] sin8s::x#8 ← sin8s::x#0
Coalesced [309] mul8u::a#7 ← mul8u::a#1
Coalesced [310] mul8u::mb#6 ← mul8u::mb#0
Coalesced [318] mul8u::res#9 ← mul8u::res#1
Coalesced [322] mul8u::a#8 ← mul8u::a#0
Coalesced [323] mul8u::res#7 ← mul8u::res#6
Coalesced [324] mul8u::mb#7 ← mul8u::mb#1
Coalesced (already) [325] mul8u::res#8 ← mul8u::res#2
Coalesced down to 35 phi equivalence classes
Culled Empty Block (label) @2
Culled Empty Block (label) @33
Culled Empty Block (label) @59
Culled Empty Block (label) main::@5
Culled Empty Block (label) main::@8
Culled Empty Block (label) print_sbyte::@6
Culled Empty Block (label) print_sbyte::@7
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) sin16s::@14
Culled Empty Block (label) sin16s::@13
Culled Empty Block (label) mul16u::@3
Culled Empty Block (label) mul16u::@10
Culled Empty Block (label) divr16u::@8
Culled Empty Block (label) divr16u::@10
Culled Empty Block (label) divr16u::@9
Culled Empty Block (label) sin8s::@17
Culled Empty Block (label) sin8s::@16
Culled Empty Block (label) sin8s::@15
Culled Empty Block (label) mul8u::@3
Culled Empty Block (label) mul8u::@10
Renumbering block @58 to @1
Renumbering block div16u::@2 to div16u::@1
Renumbering block div32u16u::@2 to div32u16u::@1
Renumbering block div32u16u::@3 to div32u16u::@2
Renumbering block mul8u::@4 to mul8u::@3
Renumbering block mul8u::@7 to mul8u::@4
Renumbering block mul16u::@4 to mul16u::@3
Renumbering block mul16u::@7 to mul16u::@4
Renumbering block sin16s_gen::@7 to sin16s_gen::@3
Renumbering block sin16s_gen::@8 to sin16s_gen::@4
Renumbering block sin8s_gen::@7 to sin8s_gen::@3
Renumbering block sin8s_gen::@8 to sin8s_gen::@4
Renumbering block sin16s::@8 to sin16s::@7
Renumbering block sin16s::@9 to sin16s::@8
Renumbering block sin16s::@10 to sin16s::@9
Renumbering block sin16s::@11 to sin16s::@10
Renumbering block sin16s::@12 to sin16s::@11
Renumbering block sin16s::@15 to sin16s::@12
Renumbering block sin8s::@10 to sin8s::@9
Renumbering block sin8s::@11 to sin8s::@10
Renumbering block sin8s::@12 to sin8s::@11
Renumbering block sin8s::@13 to sin8s::@12
Renumbering block sin8s::@14 to sin8s::@13
Renumbering block sin8s::@18 to sin8s::@14
Renumbering block mulu16_sel::@2 to mulu16_sel::@1
Renumbering block mulu8_sel::@2 to mulu8_sel::@1
Renumbering block memset::@4 to memset::@1
Renumbering block memset::@5 to memset::@2
Renumbering block print_sbyte::@5 to print_sbyte::@4
Renumbering block main::@3 to main::@2
Renumbering block main::@4 to main::@3
Renumbering block main::@6 to main::@4
Renumbering block main::@7 to main::@5
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::@2
Adding NOP phi() at start of main::@3
Adding NOP phi() at start of main::@4
Adding NOP phi() at start of print_str
Adding NOP phi() at start of print_sbyte::@3
Adding NOP phi() at start of print_sbyte::@1
Adding NOP phi() at start of print_cls
Adding NOP phi() at start of memset
Adding NOP phi() at start of sin16s_gen
Adding NOP phi() at start of div32u16u
Adding NOP phi() at start of sin8s_gen
Adding NOP phi() at start of div16u

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 sin8s_gen 
  to:main::@2
main::@2: scope:[main]  from main
  [6] phi()
  [7] call sin16s_gen 
  to:main::@3
main::@3: scope:[main]  from main::@2
  [8] phi()
  [9] call print_cls 
  to:main::@1
main::@1: scope:[main]  from main::@3 main::@5
  [10] (byte*) print_char_cursor#42 ← phi( main::@3/(const byte*) print_line_cursor#0 main::@5/(byte*) print_char_cursor#19 )
  [10] (byte) main::i#2 ← phi( main::@3/(byte) 0 main::@5/(byte) main::i#1 )
  [11] (signed byte) main::sb#0 ← *((const signed byte*) main::sintabb + (byte) main::i#2)
  [12] (word~) main::$3 ← (word)(byte) main::i#2
  [13] (word~) main::$11 ← (word~) main::$3 << (byte) 1
  [14] (signed word*~) main::$4 ← (const signed word*) main::sintabw + (word~) main::$11
  [15] (signed word) main::sw#0 ← *((signed word*~) main::$4)
  [16] (byte~) main::$6 ← > (signed word) main::sw#0
  [17] (signed byte) main::sd#0 ← (signed byte) main::sb#0 - (signed byte)(byte~) main::$6
  [18] (signed byte) print_sbyte::b#1 ← (signed byte) main::sd#0
  [19] call print_sbyte 
  to:main::@4
main::@4: scope:[main]  from main::@1
  [20] phi()
  [21] call print_str 
  to:main::@5
main::@5: scope:[main]  from main::@4
  [22] (byte) main::i#1 ← ++ (byte) main::i#2
  [23] if((byte) main::i#1!=(byte) $c0) goto main::@1
  to:main::@return
main::@return: scope:[main]  from main::@5
  [24] return 
  to:@return

(void()) print_str((byte*) print_str::str)
print_str: scope:[print_str]  from main::@4
  [25] phi()
  to:print_str::@1
print_str::@1: scope:[print_str]  from print_str print_str::@2
  [26] (byte*) print_char_cursor#19 ← phi( print_str/(byte*) print_char_cursor#10 print_str::@2/(byte*) print_char_cursor#1 )
  [26] (byte*) print_str::str#2 ← phi( print_str/(const byte*) main::str print_str::@2/(byte*) print_str::str#0 )
  [27] if((byte) 0!=*((byte*) print_str::str#2)) goto print_str::@2
  to:print_str::@return
print_str::@return: scope:[print_str]  from print_str::@1
  [28] return 
  to:@return
print_str::@2: scope:[print_str]  from print_str::@1
  [29] *((byte*) print_char_cursor#19) ← *((byte*) print_str::str#2)
  [30] (byte*) print_char_cursor#1 ← ++ (byte*) print_char_cursor#19
  [31] (byte*) print_str::str#0 ← ++ (byte*) print_str::str#2
  to:print_str::@1

(void()) print_sbyte((signed byte) print_sbyte::b)
print_sbyte: scope:[print_sbyte]  from main::@1
  [32] if((signed byte) print_sbyte::b#1<(signed byte) 0) goto print_sbyte::@1
  to:print_sbyte::@3
print_sbyte::@3: scope:[print_sbyte]  from print_sbyte
  [33] phi()
  [34] call print_char 
  to:print_sbyte::@2
print_sbyte::@2: scope:[print_sbyte]  from print_sbyte::@3 print_sbyte::@4
  [35] (signed byte) print_sbyte::b#4 ← phi( print_sbyte::@4/(signed byte) print_sbyte::b#0 print_sbyte::@3/(signed byte) print_sbyte::b#1 )
  [36] (byte) print_byte::b#0 ← (byte)(signed byte) print_sbyte::b#4
  [37] call print_byte 
  to:print_sbyte::@return
print_sbyte::@return: scope:[print_sbyte]  from print_sbyte::@2
  [38] return 
  to:@return
print_sbyte::@1: scope:[print_sbyte]  from print_sbyte
  [39] phi()
  [40] call print_char 
  to:print_sbyte::@4
print_sbyte::@4: scope:[print_sbyte]  from print_sbyte::@1
  [41] (signed byte) print_sbyte::b#0 ← - (signed byte) print_sbyte::b#1
  to:print_sbyte::@2

(void()) print_char((byte) print_char::ch)
print_char: scope:[print_char]  from print_byte print_byte::@1 print_sbyte::@1 print_sbyte::@3
  [42] (byte*) print_char_cursor#28 ← phi( print_byte/(byte*) print_char_cursor#10 print_byte::@1/(byte*) print_char_cursor#10 print_sbyte::@1/(byte*) print_char_cursor#42 print_sbyte::@3/(byte*) print_char_cursor#42 )
  [42] (byte) print_char::ch#4 ← phi( print_byte/(byte) print_char::ch#2 print_byte::@1/(byte) print_char::ch#3 print_sbyte::@1/(byte) '-' print_sbyte::@3/(byte) ' ' )
  [43] *((byte*) print_char_cursor#28) ← (byte) print_char::ch#4
  [44] (byte*) print_char_cursor#10 ← ++ (byte*) print_char_cursor#28
  to:print_char::@return
print_char::@return: scope:[print_char]  from print_char
  [45] return 
  to:@return

(void()) print_byte((byte) print_byte::b)
print_byte: scope:[print_byte]  from print_sbyte::@2
  [46] (byte~) print_byte::$0 ← (byte) print_byte::b#0 >> (byte) 4
  [47] (byte) print_char::ch#2 ← *((const byte*) print_hextab + (byte~) print_byte::$0)
  [48] call print_char 
  to:print_byte::@1
print_byte::@1: scope:[print_byte]  from print_byte
  [49] (byte~) print_byte::$2 ← (byte) print_byte::b#0 & (byte) $f
  [50] (byte) print_char::ch#3 ← *((const byte*) print_hextab + (byte~) print_byte::$2)
  [51] call print_char 
  to:print_byte::@return
print_byte::@return: scope:[print_byte]  from print_byte::@1
  [52] return 
  to:@return

(void()) print_cls()
print_cls: scope:[print_cls]  from main::@3
  [53] phi()
  [54] call memset 
  to:print_cls::@return
print_cls::@return: scope:[print_cls]  from print_cls
  [55] return 
  to:@return

(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num)
memset: scope:[memset]  from print_cls
  [56] phi()
  to:memset::@1
memset::@1: scope:[memset]  from memset memset::@2
  [57] (byte*) memset::dst#2 ← phi( memset/(byte*)(const void*) memset::str#0 memset::@2/(byte*) memset::dst#1 )
  [58] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2
  to:memset::@return
memset::@return: scope:[memset]  from memset::@1
  [59] return 
  to:@return
memset::@2: scope:[memset]  from memset::@1
  [60] *((byte*) memset::dst#2) ← (const byte) memset::c#0
  [61] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2
  to:memset::@1

(void()) sin16s_gen((signed word*) sin16s_gen::sintab , (word) sin16s_gen::wavelength)
sin16s_gen: scope:[sin16s_gen]  from main::@2
  [62] phi()
  [63] call div32u16u 
  [64] (dword) div32u16u::return#2 ← (dword) div32u16u::return#0
  to:sin16s_gen::@3
sin16s_gen::@3: scope:[sin16s_gen]  from sin16s_gen
  [65] (dword) sin16s_gen::step#0 ← (dword) div32u16u::return#2
  to:sin16s_gen::@1
sin16s_gen::@1: scope:[sin16s_gen]  from sin16s_gen::@3 sin16s_gen::@4
  [66] (signed word*) sin16s_gen::sintab#2 ← phi( sin16s_gen::@3/(const signed word*) main::sintabw sin16s_gen::@4/(signed word*) sin16s_gen::sintab#0 )
  [66] (dword) sin16s_gen::x#2 ← phi( sin16s_gen::@3/(dword) 0 sin16s_gen::@4/(dword) sin16s_gen::x#1 )
  [66] (word) sin16s_gen::i#2 ← phi( sin16s_gen::@3/(word) 0 sin16s_gen::@4/(word) sin16s_gen::i#1 )
  [67] if((word) sin16s_gen::i#2<(const word) main::wavelength) goto sin16s_gen::@2
  to:sin16s_gen::@return
sin16s_gen::@return: scope:[sin16s_gen]  from sin16s_gen::@1
  [68] return 
  to:@return
sin16s_gen::@2: scope:[sin16s_gen]  from sin16s_gen::@1
  [69] (dword) sin16s::x#0 ← (dword) sin16s_gen::x#2
  [70] call sin16s 
  [71] (signed word) sin16s::return#0 ← (signed word) sin16s::return#1
  to:sin16s_gen::@4
sin16s_gen::@4: scope:[sin16s_gen]  from sin16s_gen::@2
  [72] (signed word~) sin16s_gen::$2 ← (signed word) sin16s::return#0
  [73] *((signed word*) sin16s_gen::sintab#2) ← (signed word~) sin16s_gen::$2
  [74] (signed word*) sin16s_gen::sintab#0 ← (signed word*) sin16s_gen::sintab#2 + (const byte) SIZEOF_SIGNED_WORD
  [75] (dword) sin16s_gen::x#1 ← (dword) sin16s_gen::x#2 + (dword) sin16s_gen::step#0
  [76] (word) sin16s_gen::i#1 ← ++ (word) sin16s_gen::i#2
  to:sin16s_gen::@1

(signed word()) sin16s((dword) sin16s::x)
sin16s: scope:[sin16s]  from sin16s_gen::@2
  [77] if((dword) sin16s::x#0<(const dword) PI_u4f28) goto sin16s::@1
  to:sin16s::@4
sin16s::@4: scope:[sin16s]  from sin16s
  [78] (dword) sin16s::x#1 ← (dword) sin16s::x#0 - (const dword) PI_u4f28
  to:sin16s::@1
sin16s::@1: scope:[sin16s]  from sin16s sin16s::@4
  [79] (byte) sin16s::isUpper#2 ← phi( sin16s/(byte) 0 sin16s::@4/(byte) 1 )
  [79] (dword) sin16s::x#4 ← phi( sin16s/(dword) sin16s::x#0 sin16s::@4/(dword) sin16s::x#1 )
  [80] if((dword) sin16s::x#4<(const dword) PI_HALF_u4f28) goto sin16s::@2
  to:sin16s::@5
sin16s::@5: scope:[sin16s]  from sin16s::@1
  [81] (dword) sin16s::x#2 ← (const dword) PI_u4f28 - (dword) sin16s::x#4
  to:sin16s::@2
sin16s::@2: scope:[sin16s]  from sin16s::@1 sin16s::@5
  [82] (dword) sin16s::x#6 ← phi( sin16s::@1/(dword) sin16s::x#4 sin16s::@5/(dword) sin16s::x#2 )
  [83] (dword~) sin16s::$4 ← (dword) sin16s::x#6 << (byte) 3
  [84] (word) sin16s::x1#0 ← > (dword~) sin16s::$4
  [85] (word) mulu16_sel::v1#0 ← (word) sin16s::x1#0
  [86] (word) mulu16_sel::v2#0 ← (word) sin16s::x1#0
  [87] call mulu16_sel 
  [88] (word) mulu16_sel::return#0 ← (word) mulu16_sel::return#12
  to:sin16s::@7
sin16s::@7: scope:[sin16s]  from sin16s::@2
  [89] (word) sin16s::x2#0 ← (word) mulu16_sel::return#0
  [90] (word) mulu16_sel::v1#1 ← (word) sin16s::x2#0
  [91] (word) mulu16_sel::v2#1 ← (word) sin16s::x1#0
  [92] call mulu16_sel 
  [93] (word) mulu16_sel::return#1 ← (word) mulu16_sel::return#12
  to:sin16s::@8
sin16s::@8: scope:[sin16s]  from sin16s::@7
  [94] (word) sin16s::x3#0 ← (word) mulu16_sel::return#1
  [95] (word) mulu16_sel::v1#2 ← (word) sin16s::x3#0
  [96] call mulu16_sel 
  [97] (word) mulu16_sel::return#2 ← (word) mulu16_sel::return#12
  to:sin16s::@9
sin16s::@9: scope:[sin16s]  from sin16s::@8
  [98] (word) sin16s::x3_6#0 ← (word) mulu16_sel::return#2
  [99] (word) sin16s::usinx#0 ← (word) sin16s::x1#0 - (word) sin16s::x3_6#0
  [100] (word) mulu16_sel::v1#3 ← (word) sin16s::x3#0
  [101] (word) mulu16_sel::v2#3 ← (word) sin16s::x1#0
  [102] call mulu16_sel 
  [103] (word) mulu16_sel::return#10 ← (word) mulu16_sel::return#12
  to:sin16s::@10
sin16s::@10: scope:[sin16s]  from sin16s::@9
  [104] (word) sin16s::x4#0 ← (word) mulu16_sel::return#10
  [105] (word) mulu16_sel::v1#4 ← (word) sin16s::x4#0
  [106] (word) mulu16_sel::v2#4 ← (word) sin16s::x1#0
  [107] call mulu16_sel 
  [108] (word) mulu16_sel::return#11 ← (word) mulu16_sel::return#12
  to:sin16s::@11
sin16s::@11: scope:[sin16s]  from sin16s::@10
  [109] (word) sin16s::x5#0 ← (word) mulu16_sel::return#11
  [110] (word) sin16s::x5_128#0 ← (word) sin16s::x5#0 >> (byte) 4
  [111] (word) sin16s::usinx#1 ← (word) sin16s::usinx#0 + (word) sin16s::x5_128#0
  [112] if((byte) sin16s::isUpper#2==(byte) 0) goto sin16s::@12
  to:sin16s::@6
sin16s::@6: scope:[sin16s]  from sin16s::@11
  [113] (signed word) sin16s::sinx#1 ← - (signed word)(word) sin16s::usinx#1
  to:sin16s::@3
sin16s::@3: scope:[sin16s]  from sin16s::@12 sin16s::@6
  [114] (signed word) sin16s::return#1 ← phi( sin16s::@12/(signed word) sin16s::return#5 sin16s::@6/(signed word) sin16s::sinx#1 )
  to:sin16s::@return
sin16s::@return: scope:[sin16s]  from sin16s::@3
  [115] return 
  to:@return
sin16s::@12: scope:[sin16s]  from sin16s::@11
  [116] (signed word) sin16s::return#5 ← (signed word)(word) sin16s::usinx#1
  to:sin16s::@3

(word()) mulu16_sel((word) mulu16_sel::v1 , (word) mulu16_sel::v2 , (byte) mulu16_sel::select)
mulu16_sel: scope:[mulu16_sel]  from sin16s::@10 sin16s::@2 sin16s::@7 sin16s::@8 sin16s::@9
  [117] (byte) mulu16_sel::select#5 ← phi( sin16s::@9/(byte) 0 sin16s::@10/(byte) 0 sin16s::@2/(byte) 0 sin16s::@7/(byte) 1 sin16s::@8/(byte) 1 )
  [117] (word) mulu16_sel::v2#5 ← phi( sin16s::@9/(word) mulu16_sel::v2#3 sin16s::@10/(word) mulu16_sel::v2#4 sin16s::@2/(word) mulu16_sel::v2#0 sin16s::@7/(word) mulu16_sel::v2#1 sin16s::@8/(word)(number) $10000/(number) 6 )
  [117] (word) mulu16_sel::v1#5 ← phi( sin16s::@9/(word) mulu16_sel::v1#3 sin16s::@10/(word) mulu16_sel::v1#4 sin16s::@2/(word) mulu16_sel::v1#0 sin16s::@7/(word) mulu16_sel::v1#1 sin16s::@8/(word) mulu16_sel::v1#2 )
  [118] (word) mul16u::a#1 ← (word) mulu16_sel::v1#5
  [119] (word) mul16u::b#0 ← (word) mulu16_sel::v2#5
  [120] call mul16u 
  [121] (dword) mul16u::return#2 ← (dword) mul16u::res#2
  to:mulu16_sel::@1
mulu16_sel::@1: scope:[mulu16_sel]  from mulu16_sel
  [122] (dword~) mulu16_sel::$0 ← (dword) mul16u::return#2
  [123] (dword~) mulu16_sel::$1 ← (dword~) mulu16_sel::$0 << (byte) mulu16_sel::select#5
  [124] (word) mulu16_sel::return#12 ← > (dword~) mulu16_sel::$1
  to:mulu16_sel::@return
mulu16_sel::@return: scope:[mulu16_sel]  from mulu16_sel::@1
  [125] return 
  to:@return

(dword()) mul16u((word) mul16u::a , (word) mul16u::b)
mul16u: scope:[mul16u]  from mulu16_sel
  [126] (dword) mul16u::mb#0 ← (dword)(word) mul16u::b#0
  to:mul16u::@1
mul16u::@1: scope:[mul16u]  from mul16u mul16u::@3
  [127] (dword) mul16u::mb#2 ← phi( mul16u/(dword) mul16u::mb#0 mul16u::@3/(dword) mul16u::mb#1 )
  [127] (dword) mul16u::res#2 ← phi( mul16u/(dword) 0 mul16u::@3/(dword) mul16u::res#6 )
  [127] (word) mul16u::a#2 ← phi( mul16u/(word) mul16u::a#1 mul16u::@3/(word) mul16u::a#0 )
  [128] if((word) mul16u::a#2!=(byte) 0) goto mul16u::@2
  to:mul16u::@return
mul16u::@return: scope:[mul16u]  from mul16u::@1
  [129] return 
  to:@return
mul16u::@2: scope:[mul16u]  from mul16u::@1
  [130] (byte~) mul16u::$1 ← (word) mul16u::a#2 & (byte) 1
  [131] if((byte~) mul16u::$1==(byte) 0) goto mul16u::@3
  to:mul16u::@4
mul16u::@4: scope:[mul16u]  from mul16u::@2
  [132] (dword) mul16u::res#1 ← (dword) mul16u::res#2 + (dword) mul16u::mb#2
  to:mul16u::@3
mul16u::@3: scope:[mul16u]  from mul16u::@2 mul16u::@4
  [133] (dword) mul16u::res#6 ← phi( mul16u::@2/(dword) mul16u::res#2 mul16u::@4/(dword) mul16u::res#1 )
  [134] (word) mul16u::a#0 ← (word) mul16u::a#2 >> (byte) 1
  [135] (dword) mul16u::mb#1 ← (dword) mul16u::mb#2 << (byte) 1
  to:mul16u::@1

(dword()) div32u16u((dword) div32u16u::dividend , (word) div32u16u::divisor)
div32u16u: scope:[div32u16u]  from sin16s_gen
  [136] phi()
  [137] call divr16u 
  [138] (word) divr16u::return#3 ← (word) divr16u::return#0
  to:div32u16u::@1
div32u16u::@1: scope:[div32u16u]  from div32u16u
  [139] (word) div32u16u::quotient_hi#0 ← (word) divr16u::return#3
  [140] (word) divr16u::rem#5 ← (word) rem16u#1
  [141] call divr16u 
  [142] (word) divr16u::return#4 ← (word) divr16u::return#0
  to:div32u16u::@2
div32u16u::@2: scope:[div32u16u]  from div32u16u::@1
  [143] (word) div32u16u::quotient_lo#0 ← (word) divr16u::return#4
  [144] (dword) div32u16u::return#0 ← (word) div32u16u::quotient_hi#0 dw= (word) div32u16u::quotient_lo#0
  to:div32u16u::@return
div32u16u::@return: scope:[div32u16u]  from div32u16u::@2
  [145] return 
  to:@return

(word()) divr16u((word) divr16u::dividend , (word) divr16u::divisor , (word) divr16u::rem)
divr16u: scope:[divr16u]  from div16u div32u16u div32u16u::@1
  [146] (word) divr16u::dividend#6 ← phi( div16u/(const word) PI2_u4f12 div32u16u/>(const dword) PI2_u4f28 div32u16u::@1/<(const dword) PI2_u4f28 )
  [146] (word) divr16u::rem#11 ← phi( div16u/(byte) 0 div32u16u/(byte) 0 div32u16u::@1/(word) divr16u::rem#5 )
  to:divr16u::@1
divr16u::@1: scope:[divr16u]  from divr16u divr16u::@3
  [147] (byte) divr16u::i#2 ← phi( divr16u/(byte) 0 divr16u::@3/(byte) divr16u::i#1 )
  [147] (word) divr16u::quotient#3 ← phi( divr16u/(word) 0 divr16u::@3/(word) divr16u::return#0 )
  [147] (word) divr16u::dividend#4 ← phi( divr16u/(word) divr16u::dividend#6 divr16u::@3/(word) divr16u::dividend#0 )
  [147] (word) divr16u::rem#6 ← phi( divr16u/(word) divr16u::rem#11 divr16u::@3/(word) divr16u::rem#10 )
  [148] (word) divr16u::rem#0 ← (word) divr16u::rem#6 << (byte) 1
  [149] (byte~) divr16u::$1 ← > (word) divr16u::dividend#4
  [150] (byte~) divr16u::$2 ← (byte~) divr16u::$1 & (byte) $80
  [151] if((byte~) divr16u::$2==(byte) 0) goto divr16u::@2
  to:divr16u::@4
divr16u::@4: scope:[divr16u]  from divr16u::@1
  [152] (word) divr16u::rem#1 ← (word) divr16u::rem#0 | (byte) 1
  to:divr16u::@2
divr16u::@2: scope:[divr16u]  from divr16u::@1 divr16u::@4
  [153] (word) divr16u::rem#7 ← phi( divr16u::@1/(word) divr16u::rem#0 divr16u::@4/(word) divr16u::rem#1 )
  [154] (word) divr16u::dividend#0 ← (word) divr16u::dividend#4 << (byte) 1
  [155] (word) divr16u::quotient#1 ← (word) divr16u::quotient#3 << (byte) 1
  [156] if((word) divr16u::rem#7<(const word) main::wavelength) goto divr16u::@3
  to:divr16u::@5
divr16u::@5: scope:[divr16u]  from divr16u::@2
  [157] (word) divr16u::quotient#2 ← ++ (word) divr16u::quotient#1
  [158] (word) divr16u::rem#2 ← (word) divr16u::rem#7 - (const word) main::wavelength
  to:divr16u::@3
divr16u::@3: scope:[divr16u]  from divr16u::@2 divr16u::@5
  [159] (word) divr16u::return#0 ← phi( divr16u::@2/(word) divr16u::quotient#1 divr16u::@5/(word) divr16u::quotient#2 )
  [159] (word) divr16u::rem#10 ← phi( divr16u::@2/(word) divr16u::rem#7 divr16u::@5/(word) divr16u::rem#2 )
  [160] (byte) divr16u::i#1 ← ++ (byte) divr16u::i#2
  [161] if((byte) divr16u::i#1!=(byte) $10) goto divr16u::@1
  to:divr16u::@6
divr16u::@6: scope:[divr16u]  from divr16u::@3
  [162] (word) rem16u#1 ← (word) divr16u::rem#10
  to:divr16u::@return
divr16u::@return: scope:[divr16u]  from divr16u::@6
  [163] return 
  to:@return

(void()) sin8s_gen((signed byte*) sin8s_gen::sintab , (word) sin8s_gen::wavelength)
sin8s_gen: scope:[sin8s_gen]  from main
  [164] phi()
  [165] call div16u 
  [166] (word) div16u::return#2 ← (word) div16u::return#0
  to:sin8s_gen::@3
sin8s_gen::@3: scope:[sin8s_gen]  from sin8s_gen
  [167] (word) sin8s_gen::step#0 ← (word) div16u::return#2
  to:sin8s_gen::@1
sin8s_gen::@1: scope:[sin8s_gen]  from sin8s_gen::@3 sin8s_gen::@4
  [168] (signed byte*) sin8s_gen::sintab#2 ← phi( sin8s_gen::@3/(const signed byte*) main::sintabb sin8s_gen::@4/(signed byte*) sin8s_gen::sintab#0 )
  [168] (word) sin8s_gen::x#2 ← phi( sin8s_gen::@3/(word) 0 sin8s_gen::@4/(word) sin8s_gen::x#1 )
  [168] (word) sin8s_gen::i#2 ← phi( sin8s_gen::@3/(word) 0 sin8s_gen::@4/(word) sin8s_gen::i#1 )
  [169] if((word) sin8s_gen::i#2<(const word) main::wavelength) goto sin8s_gen::@2
  to:sin8s_gen::@return
sin8s_gen::@return: scope:[sin8s_gen]  from sin8s_gen::@1
  [170] return 
  to:@return
sin8s_gen::@2: scope:[sin8s_gen]  from sin8s_gen::@1
  [171] (word) sin8s::x#0 ← (word) sin8s_gen::x#2
  [172] call sin8s 
  [173] (signed byte) sin8s::return#0 ← (signed byte) sin8s::return#1
  to:sin8s_gen::@4
sin8s_gen::@4: scope:[sin8s_gen]  from sin8s_gen::@2
  [174] (signed byte~) sin8s_gen::$2 ← (signed byte) sin8s::return#0
  [175] *((signed byte*) sin8s_gen::sintab#2) ← (signed byte~) sin8s_gen::$2
  [176] (signed byte*) sin8s_gen::sintab#0 ← ++ (signed byte*) sin8s_gen::sintab#2
  [177] (word) sin8s_gen::x#1 ← (word) sin8s_gen::x#2 + (word) sin8s_gen::step#0
  [178] (word) sin8s_gen::i#1 ← ++ (word) sin8s_gen::i#2
  to:sin8s_gen::@1

(signed byte()) sin8s((word) sin8s::x)
sin8s: scope:[sin8s]  from sin8s_gen::@2
  [179] if((word) sin8s::x#0<(const word) PI_u4f12) goto sin8s::@1
  to:sin8s::@5
sin8s::@5: scope:[sin8s]  from sin8s
  [180] (word) sin8s::x#1 ← (word) sin8s::x#0 - (const word) PI_u4f12
  to:sin8s::@1
sin8s::@1: scope:[sin8s]  from sin8s sin8s::@5
  [181] (byte) sin8s::isUpper#10 ← phi( sin8s/(byte) 0 sin8s::@5/(byte) 1 )
  [181] (word) sin8s::x#4 ← phi( sin8s/(word) sin8s::x#0 sin8s::@5/(word) sin8s::x#1 )
  [182] if((word) sin8s::x#4<(const word) PI_HALF_u4f12) goto sin8s::@2
  to:sin8s::@6
sin8s::@6: scope:[sin8s]  from sin8s::@1
  [183] (word) sin8s::x#2 ← (const word) PI_u4f12 - (word) sin8s::x#4
  to:sin8s::@2
sin8s::@2: scope:[sin8s]  from sin8s::@1 sin8s::@6
  [184] (word) sin8s::x#6 ← phi( sin8s::@1/(word) sin8s::x#4 sin8s::@6/(word) sin8s::x#2 )
  [185] (word~) sin8s::$4 ← (word) sin8s::x#6 << (byte) 3
  [186] (byte) sin8s::x1#0 ← > (word~) sin8s::$4
  [187] (byte) mulu8_sel::v1#0 ← (byte) sin8s::x1#0
  [188] (byte) mulu8_sel::v2#0 ← (byte) sin8s::x1#0
  [189] call mulu8_sel 
  [190] (byte) mulu8_sel::return#0 ← (byte) mulu8_sel::return#12
  to:sin8s::@9
sin8s::@9: scope:[sin8s]  from sin8s::@2
  [191] (byte) sin8s::x2#0 ← (byte) mulu8_sel::return#0
  [192] (byte) mulu8_sel::v1#1 ← (byte) sin8s::x2#0
  [193] (byte) mulu8_sel::v2#1 ← (byte) sin8s::x1#0
  [194] call mulu8_sel 
  [195] (byte) mulu8_sel::return#1 ← (byte) mulu8_sel::return#12
  to:sin8s::@10
sin8s::@10: scope:[sin8s]  from sin8s::@9
  [196] (byte) sin8s::x3#0 ← (byte) mulu8_sel::return#1
  [197] (byte) mulu8_sel::v1#2 ← (byte) sin8s::x3#0
  [198] call mulu8_sel 
  [199] (byte) mulu8_sel::return#2 ← (byte) mulu8_sel::return#12
  to:sin8s::@11
sin8s::@11: scope:[sin8s]  from sin8s::@10
  [200] (byte) sin8s::x3_6#0 ← (byte) mulu8_sel::return#2
  [201] (byte) sin8s::usinx#0 ← (byte) sin8s::x1#0 - (byte) sin8s::x3_6#0
  [202] (byte) mulu8_sel::v1#3 ← (byte) sin8s::x3#0
  [203] (byte) mulu8_sel::v2#3 ← (byte) sin8s::x1#0
  [204] call mulu8_sel 
  [205] (byte) mulu8_sel::return#10 ← (byte) mulu8_sel::return#12
  to:sin8s::@12
sin8s::@12: scope:[sin8s]  from sin8s::@11
  [206] (byte) sin8s::x4#0 ← (byte) mulu8_sel::return#10
  [207] (byte) mulu8_sel::v1#4 ← (byte) sin8s::x4#0
  [208] (byte) mulu8_sel::v2#4 ← (byte) sin8s::x1#0
  [209] call mulu8_sel 
  [210] (byte) mulu8_sel::return#11 ← (byte) mulu8_sel::return#12
  to:sin8s::@13
sin8s::@13: scope:[sin8s]  from sin8s::@12
  [211] (byte) sin8s::x5#0 ← (byte) mulu8_sel::return#11
  [212] (byte) sin8s::x5_128#0 ← (byte) sin8s::x5#0 >> (byte) 4
  [213] (byte) sin8s::usinx#1 ← (byte) sin8s::usinx#0 + (byte) sin8s::x5_128#0
  [214] if((byte) sin8s::usinx#1<(byte) $80) goto sin8s::@3
  to:sin8s::@7
sin8s::@7: scope:[sin8s]  from sin8s::@13
  [215] (byte) sin8s::usinx#2 ← -- (byte) sin8s::usinx#1
  to:sin8s::@3
sin8s::@3: scope:[sin8s]  from sin8s::@13 sin8s::@7
  [216] (byte) sin8s::usinx#4 ← phi( sin8s::@13/(byte) sin8s::usinx#1 sin8s::@7/(byte) sin8s::usinx#2 )
  [217] if((byte) sin8s::isUpper#10==(byte) 0) goto sin8s::@14
  to:sin8s::@8
sin8s::@8: scope:[sin8s]  from sin8s::@3
  [218] (signed byte) sin8s::sinx#1 ← - (signed byte)(byte) sin8s::usinx#4
  to:sin8s::@4
sin8s::@4: scope:[sin8s]  from sin8s::@14 sin8s::@8
  [219] (signed byte) sin8s::return#1 ← phi( sin8s::@14/(signed byte) sin8s::return#5 sin8s::@8/(signed byte) sin8s::sinx#1 )
  to:sin8s::@return
sin8s::@return: scope:[sin8s]  from sin8s::@4
  [220] return 
  to:@return
sin8s::@14: scope:[sin8s]  from sin8s::@3
  [221] (signed byte) sin8s::return#5 ← (signed byte)(byte) sin8s::usinx#4
  to:sin8s::@4

(byte()) mulu8_sel((byte) mulu8_sel::v1 , (byte) mulu8_sel::v2 , (byte) mulu8_sel::select)
mulu8_sel: scope:[mulu8_sel]  from sin8s::@10 sin8s::@11 sin8s::@12 sin8s::@2 sin8s::@9
  [222] (byte) mulu8_sel::select#5 ← phi( sin8s::@9/(byte) 1 sin8s::@10/(byte) 1 sin8s::@11/(byte) 0 sin8s::@12/(byte) 0 sin8s::@2/(byte) 0 )
  [222] (byte) mulu8_sel::v2#5 ← phi( sin8s::@9/(byte) mulu8_sel::v2#1 sin8s::@10/(const byte) sin8s::DIV_6 sin8s::@11/(byte) mulu8_sel::v2#3 sin8s::@12/(byte) mulu8_sel::v2#4 sin8s::@2/(byte) mulu8_sel::v2#0 )
  [222] (byte) mulu8_sel::v1#5 ← phi( sin8s::@9/(byte) mulu8_sel::v1#1 sin8s::@10/(byte) mulu8_sel::v1#2 sin8s::@11/(byte) mulu8_sel::v1#3 sin8s::@12/(byte) mulu8_sel::v1#4 sin8s::@2/(byte) mulu8_sel::v1#0 )
  [223] (byte) mul8u::a#1 ← (byte) mulu8_sel::v1#5
  [224] (byte) mul8u::b#0 ← (byte) mulu8_sel::v2#5
  [225] call mul8u 
  [226] (word) mul8u::return#2 ← (word) mul8u::res#2
  to:mulu8_sel::@1
mulu8_sel::@1: scope:[mulu8_sel]  from mulu8_sel
  [227] (word~) mulu8_sel::$0 ← (word) mul8u::return#2
  [228] (word~) mulu8_sel::$1 ← (word~) mulu8_sel::$0 << (byte) mulu8_sel::select#5
  [229] (byte) mulu8_sel::return#12 ← > (word~) mulu8_sel::$1
  to:mulu8_sel::@return
mulu8_sel::@return: scope:[mulu8_sel]  from mulu8_sel::@1
  [230] return 
  to:@return

(word()) mul8u((byte) mul8u::a , (byte) mul8u::b)
mul8u: scope:[mul8u]  from mulu8_sel
  [231] (word) mul8u::mb#0 ← (word)(byte) mul8u::b#0
  to:mul8u::@1
mul8u::@1: scope:[mul8u]  from mul8u mul8u::@3
  [232] (word) mul8u::mb#2 ← phi( mul8u/(word) mul8u::mb#0 mul8u::@3/(word) mul8u::mb#1 )
  [232] (word) mul8u::res#2 ← phi( mul8u/(word) 0 mul8u::@3/(word) mul8u::res#6 )
  [232] (byte) mul8u::a#2 ← phi( mul8u/(byte) mul8u::a#1 mul8u::@3/(byte) mul8u::a#0 )
  [233] if((byte) mul8u::a#2!=(byte) 0) goto mul8u::@2
  to:mul8u::@return
mul8u::@return: scope:[mul8u]  from mul8u::@1
  [234] return 
  to:@return
mul8u::@2: scope:[mul8u]  from mul8u::@1
  [235] (byte~) mul8u::$1 ← (byte) mul8u::a#2 & (byte) 1
  [236] if((byte~) mul8u::$1==(byte) 0) goto mul8u::@3
  to:mul8u::@4
mul8u::@4: scope:[mul8u]  from mul8u::@2
  [237] (word) mul8u::res#1 ← (word) mul8u::res#2 + (word) mul8u::mb#2
  to:mul8u::@3
mul8u::@3: scope:[mul8u]  from mul8u::@2 mul8u::@4
  [238] (word) mul8u::res#6 ← phi( mul8u::@2/(word) mul8u::res#2 mul8u::@4/(word) mul8u::res#1 )
  [239] (byte) mul8u::a#0 ← (byte) mul8u::a#2 >> (byte) 1
  [240] (word) mul8u::mb#1 ← (word) mul8u::mb#2 << (byte) 1
  to:mul8u::@1

(word()) div16u((word) div16u::dividend , (word) div16u::divisor)
div16u: scope:[div16u]  from sin8s_gen
  [241] phi()
  [242] call divr16u 
  [243] (word) divr16u::return#2 ← (word) divr16u::return#0
  to:div16u::@1
div16u::@1: scope:[div16u]  from div16u
  [244] (word) div16u::return#0 ← (word) divr16u::return#2
  to:div16u::@return
div16u::@return: scope:[div16u]  from div16u::@1
  [245] return 
  to:@return


VARIABLE REGISTER WEIGHTS
(word()) div16u((word) div16u::dividend , (word) div16u::divisor)
(word) div16u::dividend
(word) div16u::divisor
(word) div16u::return
(word) div16u::return#0 1.3333333333333333
(word) div16u::return#2 4.0
(dword()) div32u16u((dword) div32u16u::dividend , (word) div32u16u::divisor)
(dword) div32u16u::dividend
(word) div32u16u::divisor
(dword) div32u16u::quotient
(word) div32u16u::quotient_hi
(word) div32u16u::quotient_hi#0 0.8
(word) div32u16u::quotient_lo
(word) div32u16u::quotient_lo#0 4.0
(dword) div32u16u::return
(dword) div32u16u::return#0 1.3333333333333333
(dword) div32u16u::return#2 4.0
(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#4 5.0
(word) divr16u::dividend#6 2.0
(word) divr16u::divisor
(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 11.666666666666666
(word) divr16u::rem#11 4.0
(word) divr16u::rem#2 22.0
(word) divr16u::rem#5 4.0
(word) divr16u::rem#6 24.0
(word) divr16u::rem#7 11.0
(word) divr16u::return
(word) divr16u::return#0 4.875
(word) divr16u::return#2 4.0
(word) divr16u::return#3 4.0
(word) divr16u::return#4 4.0
(void()) main()
(word~) main::$11 22.0
(word~) main::$3 22.0
(signed word*~) main::$4 22.0
(byte~) main::$6 11.0
(byte) main::i
(byte) main::i#1 16.5
(byte) main::i#2 2.75
(signed byte) main::sb
(signed byte) main::sb#0 3.6666666666666665
(signed byte) main::sd
(signed byte) main::sd#0 22.0
(signed word) main::sw
(signed word) main::sw#0 22.0
(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
(dword()) mul16u((word) mul16u::a , (word) mul16u::b)
(byte~) mul16u::$1 202.0
(word) mul16u::a
(word) mul16u::a#0 101.0
(word) mul16u::a#1 1.3333333333333333
(word) mul16u::a#2 67.66666666666666
(word) mul16u::b
(word) mul16u::b#0 2.0
(dword) mul16u::mb
(dword) mul16u::mb#0 4.0
(dword) mul16u::mb#1 202.0
(dword) mul16u::mb#2 43.57142857142858
(dword) mul16u::res
(dword) mul16u::res#1 202.0
(dword) mul16u::res#2 50.83333333333333
(dword) mul16u::res#6 101.0
(dword) mul16u::return
(dword) mul16u::return#2 4.0
(word()) mul8u((byte) mul8u::a , (byte) mul8u::b)
(byte~) mul8u::$1 202.0
(byte) mul8u::a
(byte) mul8u::a#0 101.0
(byte) mul8u::a#1 1.3333333333333333
(byte) mul8u::a#2 67.66666666666666
(byte) mul8u::b
(byte) mul8u::b#0 2.0
(word) mul8u::mb
(word) mul8u::mb#0 4.0
(word) mul8u::mb#1 202.0
(word) mul8u::mb#2 43.57142857142858
(word) mul8u::res
(word) mul8u::res#1 202.0
(word) mul8u::res#2 50.83333333333333
(word) mul8u::res#6 101.0
(word) mul8u::return
(word) mul8u::return#2 4.0
(word()) mulu16_sel((word) mulu16_sel::v1 , (word) mulu16_sel::v2 , (byte) mulu16_sel::select)
(dword~) mulu16_sel::$0 4.0
(dword~) mulu16_sel::$1 4.0
(word) mulu16_sel::return
(word) mulu16_sel::return#0 4.0
(word) mulu16_sel::return#1 4.0
(word) mulu16_sel::return#10 4.0
(word) mulu16_sel::return#11 4.0
(word) mulu16_sel::return#12 1.714285714285714
(word) mulu16_sel::return#2 4.0
(byte) mulu16_sel::select
(byte) mulu16_sel::select#5 0.3333333333333333
(word) mulu16_sel::v1
(word) mulu16_sel::v1#0 2.0
(word) mulu16_sel::v1#1 2.0
(word) mulu16_sel::v1#2 4.0
(word) mulu16_sel::v1#3 2.0
(word) mulu16_sel::v1#4 2.0
(word) mulu16_sel::v1#5 12.0
(word) mulu16_sel::v2
(word) mulu16_sel::v2#0 4.0
(word) mulu16_sel::v2#1 4.0
(word) mulu16_sel::v2#3 4.0
(word) mulu16_sel::v2#4 4.0
(word) mulu16_sel::v2#5 5.0
(byte()) mulu8_sel((byte) mulu8_sel::v1 , (byte) mulu8_sel::v2 , (byte) mulu8_sel::select)
(word~) mulu8_sel::$0 4.0
(word~) mulu8_sel::$1 4.0
(byte) mulu8_sel::return
(byte) mulu8_sel::return#0 4.0
(byte) mulu8_sel::return#1 4.0
(byte) mulu8_sel::return#10 4.0
(byte) mulu8_sel::return#11 4.0
(byte) mulu8_sel::return#12 1.714285714285714
(byte) mulu8_sel::return#2 4.0
(byte) mulu8_sel::select
(byte) mulu8_sel::select#5 0.3333333333333333
(byte) mulu8_sel::v1
(byte) mulu8_sel::v1#0 2.0
(byte) mulu8_sel::v1#1 2.0
(byte) mulu8_sel::v1#2 4.0
(byte) mulu8_sel::v1#3 2.0
(byte) mulu8_sel::v1#4 2.0
(byte) mulu8_sel::v1#5 12.0
(byte) mulu8_sel::v2
(byte) mulu8_sel::v2#0 4.0
(byte) mulu8_sel::v2#1 4.0
(byte) mulu8_sel::v2#3 4.0
(byte) mulu8_sel::v2#4 4.0
(byte) mulu8_sel::v2#5 5.0
(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 1.5
(void()) print_char((byte) print_char::ch)
(byte) print_char::ch
(byte) print_char::ch#2 4.0
(byte) print_char::ch#3 4.0
(byte) print_char::ch#4 6.0
(byte*) print_char_cursor
(byte*) print_char_cursor#1 101.0
(byte*) print_char_cursor#10 0.42105263157894735
(byte*) print_char_cursor#19 45.142857142857146
(byte*) print_char_cursor#28 6.0
(byte*) print_char_cursor#42 1.25
(void()) print_cls()
(byte*) print_line_cursor
(void()) print_sbyte((signed byte) print_sbyte::b)
(signed byte) print_sbyte::b
(signed byte) print_sbyte::b#0 4.0
(signed byte) print_sbyte::b#1 2.8333333333333335
(signed byte) print_sbyte::b#4 4.0
(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#2 101.0
(word) rem16u
(word) rem16u#1 0.8
(signed word()) sin16s((dword) sin16s::x)
(dword~) sin16s::$4 4.0
(byte) sin16s::isUpper
(byte) sin16s::isUpper#2 0.06060606060606061
(signed word) sin16s::return
(signed word) sin16s::return#0 22.0
(signed word) sin16s::return#1 5.0
(signed word) sin16s::return#5 4.0
(signed word) sin16s::sinx
(signed word) sin16s::sinx#1 4.0
(word) sin16s::usinx
(word) sin16s::usinx#0 0.3333333333333333
(word) sin16s::usinx#1 1.0
(dword) sin16s::x
(dword) sin16s::x#0 8.5
(dword) sin16s::x#1 4.0
(dword) sin16s::x#2 4.0
(dword) sin16s::x#4 5.0
(dword) sin16s::x#6 6.0
(word) sin16s::x1
(word) sin16s::x1#0 0.6363636363636365
(word) sin16s::x2
(word) sin16s::x2#0 4.0
(word) sin16s::x3
(word) sin16s::x3#0 1.0
(word) sin16s::x3_6
(word) sin16s::x3_6#0 4.0
(word) sin16s::x4
(word) sin16s::x4#0 4.0
(word) sin16s::x5
(word) sin16s::x5#0 4.0
(word) sin16s::x5_128
(word) sin16s::x5_128#0 4.0
(void()) sin16s_gen((signed word*) sin16s_gen::sintab , (word) sin16s_gen::wavelength)
(signed word~) sin16s_gen::$2 22.0
(word) sin16s_gen::i
(word) sin16s_gen::i#1 22.0
(word) sin16s_gen::i#2 3.666666666666667
(signed word*) sin16s_gen::sintab
(signed word*) sin16s_gen::sintab#0 7.333333333333333
(signed word*) sin16s_gen::sintab#2 4.714285714285714
(dword) sin16s_gen::step
(dword) sin16s_gen::step#0 1.1818181818181819
(word) sin16s_gen::wavelength
(dword) sin16s_gen::x
(dword) sin16s_gen::x#1 11.0
(dword) sin16s_gen::x#2 4.125
(signed byte()) sin8s((word) sin8s::x)
(word~) sin8s::$4 4.0
(byte) sin8s::isUpper
(byte) sin8s::isUpper#10 0.05555555555555555
(signed byte) sin8s::return
(signed byte) sin8s::return#0 22.0
(signed byte) sin8s::return#1 5.0
(signed byte) sin8s::return#5 4.0
(signed byte) sin8s::sinx
(signed byte) sin8s::sinx#1 4.0
(byte) sin8s::usinx
(byte) sin8s::usinx#0 0.3333333333333333
(byte) sin8s::usinx#1 4.0
(byte) sin8s::usinx#2 4.0
(byte) sin8s::usinx#4 2.0
(word) sin8s::x
(word) sin8s::x#0 8.5
(word) sin8s::x#1 4.0
(word) sin8s::x#2 4.0
(word) sin8s::x#4 5.0
(word) sin8s::x#6 6.0
(byte) sin8s::x1
(byte) sin8s::x1#0 0.6363636363636365
(byte) sin8s::x2
(byte) sin8s::x2#0 4.0
(byte) sin8s::x3
(byte) sin8s::x3#0 1.0
(byte) sin8s::x3_6
(byte) sin8s::x3_6#0 4.0
(byte) sin8s::x4
(byte) sin8s::x4#0 4.0
(byte) sin8s::x5
(byte) sin8s::x5#0 4.0
(byte) sin8s::x5_128
(byte) sin8s::x5_128#0 4.0
(void()) sin8s_gen((signed byte*) sin8s_gen::sintab , (word) sin8s_gen::wavelength)
(signed byte~) sin8s_gen::$2 22.0
(word) sin8s_gen::i
(word) sin8s_gen::i#1 22.0
(word) sin8s_gen::i#2 3.666666666666667
(signed byte*) sin8s_gen::sintab
(signed byte*) sin8s_gen::sintab#0 7.333333333333333
(signed byte*) sin8s_gen::sintab#2 4.714285714285714
(word) sin8s_gen::step
(word) sin8s_gen::step#0 1.1818181818181819
(word) sin8s_gen::wavelength
(word) sin8s_gen::x
(word) sin8s_gen::x#1 11.0
(word) sin8s_gen::x#2 4.125

Initial phi equivalence classes
[ main::i#2 main::i#1 ]
[ print_str::str#2 print_str::str#0 ]
[ print_sbyte::b#4 print_sbyte::b#0 print_sbyte::b#1 ]
[ print_char::ch#4 print_char::ch#2 print_char::ch#3 ]
[ print_char_cursor#28 print_char_cursor#42 print_char_cursor#19 print_char_cursor#10 print_char_cursor#1 ]
[ memset::dst#2 memset::dst#1 ]
[ sin16s_gen::i#2 sin16s_gen::i#1 ]
[ sin16s_gen::x#2 sin16s_gen::x#1 ]
[ sin16s_gen::sintab#2 sin16s_gen::sintab#0 ]
[ sin16s::isUpper#2 ]
[ sin16s::x#6 sin16s::x#4 sin16s::x#0 sin16s::x#1 sin16s::x#2 ]
[ sin16s::return#1 sin16s::return#5 sin16s::sinx#1 ]
[ mulu16_sel::v1#5 mulu16_sel::v1#3 mulu16_sel::v1#4 mulu16_sel::v1#0 mulu16_sel::v1#1 mulu16_sel::v1#2 ]
[ mulu16_sel::v2#5 mulu16_sel::v2#3 mulu16_sel::v2#4 mulu16_sel::v2#0 mulu16_sel::v2#1 ]
[ mulu16_sel::select#5 ]
[ mul16u::a#2 mul16u::a#1 mul16u::a#0 ]
[ mul16u::res#2 mul16u::res#6 mul16u::res#1 ]
[ mul16u::mb#2 mul16u::mb#0 mul16u::mb#1 ]
[ divr16u::rem#6 divr16u::rem#11 divr16u::rem#5 divr16u::rem#10 divr16u::rem#7 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 ]
[ divr16u::dividend#4 divr16u::dividend#6 divr16u::dividend#0 ]
[ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 ]
[ divr16u::i#2 divr16u::i#1 ]
[ sin8s_gen::i#2 sin8s_gen::i#1 ]
[ sin8s_gen::x#2 sin8s_gen::x#1 ]
[ sin8s_gen::sintab#2 sin8s_gen::sintab#0 ]
[ sin8s::isUpper#10 ]
[ sin8s::x#6 sin8s::x#4 sin8s::x#0 sin8s::x#1 sin8s::x#2 ]
[ sin8s::usinx#4 sin8s::usinx#1 sin8s::usinx#2 ]
[ sin8s::return#1 sin8s::return#5 sin8s::sinx#1 ]
[ mulu8_sel::v1#5 mulu8_sel::v1#1 mulu8_sel::v1#2 mulu8_sel::v1#3 mulu8_sel::v1#4 mulu8_sel::v1#0 ]
[ mulu8_sel::v2#5 mulu8_sel::v2#1 mulu8_sel::v2#3 mulu8_sel::v2#4 mulu8_sel::v2#0 ]
[ mulu8_sel::select#5 ]
[ mul8u::a#2 mul8u::a#1 mul8u::a#0 ]
[ mul8u::res#2 mul8u::res#6 mul8u::res#1 ]
[ mul8u::mb#2 mul8u::mb#0 mul8u::mb#1 ]
Added variable main::sb#0 to live range equivalence class [ main::sb#0 ]
Added variable main::$3 to live range equivalence class [ main::$3 ]
Added variable main::$11 to live range equivalence class [ main::$11 ]
Added variable main::$4 to live range equivalence class [ main::$4 ]
Added variable main::sw#0 to live range equivalence class [ main::sw#0 ]
Added variable main::$6 to live range equivalence class [ main::$6 ]
Added variable main::sd#0 to live range equivalence class [ main::sd#0 ]
Added variable print_byte::b#0 to live range equivalence class [ print_byte::b#0 ]
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 div32u16u::return#2 to live range equivalence class [ div32u16u::return#2 ]
Added variable sin16s_gen::step#0 to live range equivalence class [ sin16s_gen::step#0 ]
Added variable sin16s::return#0 to live range equivalence class [ sin16s::return#0 ]
Added variable sin16s_gen::$2 to live range equivalence class [ sin16s_gen::$2 ]
Added variable sin16s::$4 to live range equivalence class [ sin16s::$4 ]
Added variable sin16s::x1#0 to live range equivalence class [ sin16s::x1#0 ]
Added variable mulu16_sel::return#0 to live range equivalence class [ mulu16_sel::return#0 ]
Added variable sin16s::x2#0 to live range equivalence class [ sin16s::x2#0 ]
Added variable mulu16_sel::return#1 to live range equivalence class [ mulu16_sel::return#1 ]
Added variable sin16s::x3#0 to live range equivalence class [ sin16s::x3#0 ]
Added variable mulu16_sel::return#2 to live range equivalence class [ mulu16_sel::return#2 ]
Added variable sin16s::x3_6#0 to live range equivalence class [ sin16s::x3_6#0 ]
Added variable sin16s::usinx#0 to live range equivalence class [ sin16s::usinx#0 ]
Added variable mulu16_sel::return#10 to live range equivalence class [ mulu16_sel::return#10 ]
Added variable sin16s::x4#0 to live range equivalence class [ sin16s::x4#0 ]
Added variable mulu16_sel::return#11 to live range equivalence class [ mulu16_sel::return#11 ]
Added variable sin16s::x5#0 to live range equivalence class [ sin16s::x5#0 ]
Added variable sin16s::x5_128#0 to live range equivalence class [ sin16s::x5_128#0 ]
Added variable sin16s::usinx#1 to live range equivalence class [ sin16s::usinx#1 ]
Added variable mul16u::b#0 to live range equivalence class [ mul16u::b#0 ]
Added variable mul16u::return#2 to live range equivalence class [ mul16u::return#2 ]
Added variable mulu16_sel::$0 to live range equivalence class [ mulu16_sel::$0 ]
Added variable mulu16_sel::$1 to live range equivalence class [ mulu16_sel::$1 ]
Added variable mulu16_sel::return#12 to live range equivalence class [ mulu16_sel::return#12 ]
Added variable mul16u::$1 to live range equivalence class [ mul16u::$1 ]
Added variable divr16u::return#3 to live range equivalence class [ divr16u::return#3 ]
Added variable div32u16u::quotient_hi#0 to live range equivalence class [ div32u16u::quotient_hi#0 ]
Added variable divr16u::return#4 to live range equivalence class [ divr16u::return#4 ]
Added variable div32u16u::quotient_lo#0 to live range equivalence class [ div32u16u::quotient_lo#0 ]
Added variable div32u16u::return#0 to live range equivalence class [ div32u16u::return#0 ]
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 ]
Added variable div16u::return#2 to live range equivalence class [ div16u::return#2 ]
Added variable sin8s_gen::step#0 to live range equivalence class [ sin8s_gen::step#0 ]
Added variable sin8s::return#0 to live range equivalence class [ sin8s::return#0 ]
Added variable sin8s_gen::$2 to live range equivalence class [ sin8s_gen::$2 ]
Added variable sin8s::$4 to live range equivalence class [ sin8s::$4 ]
Added variable sin8s::x1#0 to live range equivalence class [ sin8s::x1#0 ]
Added variable mulu8_sel::return#0 to live range equivalence class [ mulu8_sel::return#0 ]
Added variable sin8s::x2#0 to live range equivalence class [ sin8s::x2#0 ]
Added variable mulu8_sel::return#1 to live range equivalence class [ mulu8_sel::return#1 ]
Added variable sin8s::x3#0 to live range equivalence class [ sin8s::x3#0 ]
Added variable mulu8_sel::return#2 to live range equivalence class [ mulu8_sel::return#2 ]
Added variable sin8s::x3_6#0 to live range equivalence class [ sin8s::x3_6#0 ]
Added variable sin8s::usinx#0 to live range equivalence class [ sin8s::usinx#0 ]
Added variable mulu8_sel::return#10 to live range equivalence class [ mulu8_sel::return#10 ]
Added variable sin8s::x4#0 to live range equivalence class [ sin8s::x4#0 ]
Added variable mulu8_sel::return#11 to live range equivalence class [ mulu8_sel::return#11 ]
Added variable sin8s::x5#0 to live range equivalence class [ sin8s::x5#0 ]
Added variable sin8s::x5_128#0 to live range equivalence class [ sin8s::x5_128#0 ]
Added variable mul8u::b#0 to live range equivalence class [ mul8u::b#0 ]
Added variable mul8u::return#2 to live range equivalence class [ mul8u::return#2 ]
Added variable mulu8_sel::$0 to live range equivalence class [ mulu8_sel::$0 ]
Added variable mulu8_sel::$1 to live range equivalence class [ mulu8_sel::$1 ]
Added variable mulu8_sel::return#12 to live range equivalence class [ mulu8_sel::return#12 ]
Added variable mul8u::$1 to live range equivalence class [ mul8u::$1 ]
Added variable divr16u::return#2 to live range equivalence class [ divr16u::return#2 ]
Added variable div16u::return#0 to live range equivalence class [ div16u::return#0 ]
Complete equivalence classes
[ main::i#2 main::i#1 ]
[ print_str::str#2 print_str::str#0 ]
[ print_sbyte::b#4 print_sbyte::b#0 print_sbyte::b#1 ]
[ print_char::ch#4 print_char::ch#2 print_char::ch#3 ]
[ print_char_cursor#28 print_char_cursor#42 print_char_cursor#19 print_char_cursor#10 print_char_cursor#1 ]
[ memset::dst#2 memset::dst#1 ]
[ sin16s_gen::i#2 sin16s_gen::i#1 ]
[ sin16s_gen::x#2 sin16s_gen::x#1 ]
[ sin16s_gen::sintab#2 sin16s_gen::sintab#0 ]
[ sin16s::isUpper#2 ]
[ sin16s::x#6 sin16s::x#4 sin16s::x#0 sin16s::x#1 sin16s::x#2 ]
[ sin16s::return#1 sin16s::return#5 sin16s::sinx#1 ]
[ mulu16_sel::v1#5 mulu16_sel::v1#3 mulu16_sel::v1#4 mulu16_sel::v1#0 mulu16_sel::v1#1 mulu16_sel::v1#2 ]
[ mulu16_sel::v2#5 mulu16_sel::v2#3 mulu16_sel::v2#4 mulu16_sel::v2#0 mulu16_sel::v2#1 ]
[ mulu16_sel::select#5 ]
[ mul16u::a#2 mul16u::a#1 mul16u::a#0 ]
[ mul16u::res#2 mul16u::res#6 mul16u::res#1 ]
[ mul16u::mb#2 mul16u::mb#0 mul16u::mb#1 ]
[ divr16u::rem#6 divr16u::rem#11 divr16u::rem#5 divr16u::rem#10 divr16u::rem#7 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 ]
[ divr16u::dividend#4 divr16u::dividend#6 divr16u::dividend#0 ]
[ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 ]
[ divr16u::i#2 divr16u::i#1 ]
[ sin8s_gen::i#2 sin8s_gen::i#1 ]
[ sin8s_gen::x#2 sin8s_gen::x#1 ]
[ sin8s_gen::sintab#2 sin8s_gen::sintab#0 ]
[ sin8s::isUpper#10 ]
[ sin8s::x#6 sin8s::x#4 sin8s::x#0 sin8s::x#1 sin8s::x#2 ]
[ sin8s::usinx#4 sin8s::usinx#1 sin8s::usinx#2 ]
[ sin8s::return#1 sin8s::return#5 sin8s::sinx#1 ]
[ mulu8_sel::v1#5 mulu8_sel::v1#1 mulu8_sel::v1#2 mulu8_sel::v1#3 mulu8_sel::v1#4 mulu8_sel::v1#0 ]
[ mulu8_sel::v2#5 mulu8_sel::v2#1 mulu8_sel::v2#3 mulu8_sel::v2#4 mulu8_sel::v2#0 ]
[ mulu8_sel::select#5 ]
[ mul8u::a#2 mul8u::a#1 mul8u::a#0 ]
[ mul8u::res#2 mul8u::res#6 mul8u::res#1 ]
[ mul8u::mb#2 mul8u::mb#0 mul8u::mb#1 ]
[ main::sb#0 ]
[ main::$3 ]
[ main::$11 ]
[ main::$4 ]
[ main::sw#0 ]
[ main::$6 ]
[ main::sd#0 ]
[ print_byte::b#0 ]
[ print_byte::$0 ]
[ print_byte::$2 ]
[ div32u16u::return#2 ]
[ sin16s_gen::step#0 ]
[ sin16s::return#0 ]
[ sin16s_gen::$2 ]
[ sin16s::$4 ]
[ sin16s::x1#0 ]
[ mulu16_sel::return#0 ]
[ sin16s::x2#0 ]
[ mulu16_sel::return#1 ]
[ sin16s::x3#0 ]
[ mulu16_sel::return#2 ]
[ sin16s::x3_6#0 ]
[ sin16s::usinx#0 ]
[ mulu16_sel::return#10 ]
[ sin16s::x4#0 ]
[ mulu16_sel::return#11 ]
[ sin16s::x5#0 ]
[ sin16s::x5_128#0 ]
[ sin16s::usinx#1 ]
[ mul16u::b#0 ]
[ mul16u::return#2 ]
[ mulu16_sel::$0 ]
[ mulu16_sel::$1 ]
[ mulu16_sel::return#12 ]
[ mul16u::$1 ]
[ divr16u::return#3 ]
[ div32u16u::quotient_hi#0 ]
[ divr16u::return#4 ]
[ div32u16u::quotient_lo#0 ]
[ div32u16u::return#0 ]
[ divr16u::$1 ]
[ divr16u::$2 ]
[ rem16u#1 ]
[ div16u::return#2 ]
[ sin8s_gen::step#0 ]
[ sin8s::return#0 ]
[ sin8s_gen::$2 ]
[ sin8s::$4 ]
[ sin8s::x1#0 ]
[ mulu8_sel::return#0 ]
[ sin8s::x2#0 ]
[ mulu8_sel::return#1 ]
[ sin8s::x3#0 ]
[ mulu8_sel::return#2 ]
[ sin8s::x3_6#0 ]
[ sin8s::usinx#0 ]
[ mulu8_sel::return#10 ]
[ sin8s::x4#0 ]
[ mulu8_sel::return#11 ]
[ sin8s::x5#0 ]
[ sin8s::x5_128#0 ]
[ mul8u::b#0 ]
[ mul8u::return#2 ]
[ mulu8_sel::$0 ]
[ mulu8_sel::$1 ]
[ mulu8_sel::return#12 ]
[ mul8u::$1 ]
[ divr16u::return#2 ]
[ div16u::return#0 ]
Allocated zp[1]:2 [ main::i#2 main::i#1 ]
Allocated zp[2]:3 [ print_str::str#2 print_str::str#0 ]
Allocated zp[1]:5 [ print_sbyte::b#4 print_sbyte::b#0 print_sbyte::b#1 ]
Allocated zp[1]:6 [ print_char::ch#4 print_char::ch#2 print_char::ch#3 ]
Allocated zp[2]:7 [ print_char_cursor#28 print_char_cursor#42 print_char_cursor#19 print_char_cursor#10 print_char_cursor#1 ]
Allocated zp[2]:9 [ memset::dst#2 memset::dst#1 ]
Allocated zp[2]:11 [ sin16s_gen::i#2 sin16s_gen::i#1 ]
Allocated zp[4]:13 [ sin16s_gen::x#2 sin16s_gen::x#1 ]
Allocated zp[2]:17 [ sin16s_gen::sintab#2 sin16s_gen::sintab#0 ]
Allocated zp[1]:19 [ sin16s::isUpper#2 ]
Allocated zp[4]:20 [ sin16s::x#6 sin16s::x#4 sin16s::x#0 sin16s::x#1 sin16s::x#2 ]
Allocated zp[2]:24 [ sin16s::return#1 sin16s::return#5 sin16s::sinx#1 ]
Allocated zp[2]:26 [ mulu16_sel::v1#5 mulu16_sel::v1#3 mulu16_sel::v1#4 mulu16_sel::v1#0 mulu16_sel::v1#1 mulu16_sel::v1#2 ]
Allocated zp[2]:28 [ mulu16_sel::v2#5 mulu16_sel::v2#3 mulu16_sel::v2#4 mulu16_sel::v2#0 mulu16_sel::v2#1 ]
Allocated zp[1]:30 [ mulu16_sel::select#5 ]
Allocated zp[2]:31 [ mul16u::a#2 mul16u::a#1 mul16u::a#0 ]
Allocated zp[4]:33 [ mul16u::res#2 mul16u::res#6 mul16u::res#1 ]
Allocated zp[4]:37 [ mul16u::mb#2 mul16u::mb#0 mul16u::mb#1 ]
Allocated zp[2]:41 [ divr16u::rem#6 divr16u::rem#11 divr16u::rem#5 divr16u::rem#10 divr16u::rem#7 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 ]
Allocated zp[2]:43 [ divr16u::dividend#4 divr16u::dividend#6 divr16u::dividend#0 ]
Allocated zp[2]:45 [ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 ]
Allocated zp[1]:47 [ divr16u::i#2 divr16u::i#1 ]
Allocated zp[2]:48 [ sin8s_gen::i#2 sin8s_gen::i#1 ]
Allocated zp[2]:50 [ sin8s_gen::x#2 sin8s_gen::x#1 ]
Allocated zp[2]:52 [ sin8s_gen::sintab#2 sin8s_gen::sintab#0 ]
Allocated zp[1]:54 [ sin8s::isUpper#10 ]
Allocated zp[2]:55 [ sin8s::x#6 sin8s::x#4 sin8s::x#0 sin8s::x#1 sin8s::x#2 ]
Allocated zp[1]:57 [ sin8s::usinx#4 sin8s::usinx#1 sin8s::usinx#2 ]
Allocated zp[1]:58 [ sin8s::return#1 sin8s::return#5 sin8s::sinx#1 ]
Allocated zp[1]:59 [ mulu8_sel::v1#5 mulu8_sel::v1#1 mulu8_sel::v1#2 mulu8_sel::v1#3 mulu8_sel::v1#4 mulu8_sel::v1#0 ]
Allocated zp[1]:60 [ mulu8_sel::v2#5 mulu8_sel::v2#1 mulu8_sel::v2#3 mulu8_sel::v2#4 mulu8_sel::v2#0 ]
Allocated zp[1]:61 [ mulu8_sel::select#5 ]
Allocated zp[1]:62 [ mul8u::a#2 mul8u::a#1 mul8u::a#0 ]
Allocated zp[2]:63 [ mul8u::res#2 mul8u::res#6 mul8u::res#1 ]
Allocated zp[2]:65 [ mul8u::mb#2 mul8u::mb#0 mul8u::mb#1 ]
Allocated zp[1]:67 [ main::sb#0 ]
Allocated zp[2]:68 [ main::$3 ]
Allocated zp[2]:70 [ main::$11 ]
Allocated zp[2]:72 [ main::$4 ]
Allocated zp[2]:74 [ main::sw#0 ]
Allocated zp[1]:76 [ main::$6 ]
Allocated zp[1]:77 [ main::sd#0 ]
Allocated zp[1]:78 [ print_byte::b#0 ]
Allocated zp[1]:79 [ print_byte::$0 ]
Allocated zp[1]:80 [ print_byte::$2 ]
Allocated zp[4]:81 [ div32u16u::return#2 ]
Allocated zp[4]:85 [ sin16s_gen::step#0 ]
Allocated zp[2]:89 [ sin16s::return#0 ]
Allocated zp[2]:91 [ sin16s_gen::$2 ]
Allocated zp[4]:93 [ sin16s::$4 ]
Allocated zp[2]:97 [ sin16s::x1#0 ]
Allocated zp[2]:99 [ mulu16_sel::return#0 ]
Allocated zp[2]:101 [ sin16s::x2#0 ]
Allocated zp[2]:103 [ mulu16_sel::return#1 ]
Allocated zp[2]:105 [ sin16s::x3#0 ]
Allocated zp[2]:107 [ mulu16_sel::return#2 ]
Allocated zp[2]:109 [ sin16s::x3_6#0 ]
Allocated zp[2]:111 [ sin16s::usinx#0 ]
Allocated zp[2]:113 [ mulu16_sel::return#10 ]
Allocated zp[2]:115 [ sin16s::x4#0 ]
Allocated zp[2]:117 [ mulu16_sel::return#11 ]
Allocated zp[2]:119 [ sin16s::x5#0 ]
Allocated zp[2]:121 [ sin16s::x5_128#0 ]
Allocated zp[2]:123 [ sin16s::usinx#1 ]
Allocated zp[2]:125 [ mul16u::b#0 ]
Allocated zp[4]:127 [ mul16u::return#2 ]
Allocated zp[4]:131 [ mulu16_sel::$0 ]
Allocated zp[4]:135 [ mulu16_sel::$1 ]
Allocated zp[2]:139 [ mulu16_sel::return#12 ]
Allocated zp[1]:141 [ mul16u::$1 ]
Allocated zp[2]:142 [ divr16u::return#3 ]
Allocated zp[2]:144 [ div32u16u::quotient_hi#0 ]
Allocated zp[2]:146 [ divr16u::return#4 ]
Allocated zp[2]:148 [ div32u16u::quotient_lo#0 ]
Allocated zp[4]:150 [ div32u16u::return#0 ]
Allocated zp[1]:154 [ divr16u::$1 ]
Allocated zp[1]:155 [ divr16u::$2 ]
Allocated zp[2]:156 [ rem16u#1 ]
Allocated zp[2]:158 [ div16u::return#2 ]
Allocated zp[2]:160 [ sin8s_gen::step#0 ]
Allocated zp[1]:162 [ sin8s::return#0 ]
Allocated zp[1]:163 [ sin8s_gen::$2 ]
Allocated zp[2]:164 [ sin8s::$4 ]
Allocated zp[1]:166 [ sin8s::x1#0 ]
Allocated zp[1]:167 [ mulu8_sel::return#0 ]
Allocated zp[1]:168 [ sin8s::x2#0 ]
Allocated zp[1]:169 [ mulu8_sel::return#1 ]
Allocated zp[1]:170 [ sin8s::x3#0 ]
Allocated zp[1]:171 [ mulu8_sel::return#2 ]
Allocated zp[1]:172 [ sin8s::x3_6#0 ]
Allocated zp[1]:173 [ sin8s::usinx#0 ]
Allocated zp[1]:174 [ mulu8_sel::return#10 ]
Allocated zp[1]:175 [ sin8s::x4#0 ]
Allocated zp[1]:176 [ mulu8_sel::return#11 ]
Allocated zp[1]:177 [ sin8s::x5#0 ]
Allocated zp[1]:178 [ sin8s::x5_128#0 ]
Allocated zp[1]:179 [ mul8u::b#0 ]
Allocated zp[2]:180 [ mul8u::return#2 ]
Allocated zp[2]:182 [ mulu8_sel::$0 ]
Allocated zp[2]:184 [ mulu8_sel::$1 ]
Allocated zp[1]:186 [ mulu8_sel::return#12 ]
Allocated zp[1]:187 [ mul8u::$1 ]
Allocated zp[2]:188 [ divr16u::return#2 ]
Allocated zp[2]:190 [ div16u::return#0 ]

INITIAL ASM
Target platform is c64basic / MOS6502X
  // File Comments
  // Upstart
.pc = $801 "Basic"
:BasicUpstart(__bbegin)
.pc = $80d "Program"
  // Global Constants & labels
  // PI*2 in u[4.28] format
  .const PI2_u4f28 = $6487ed51
  // PI in u[4.28] format
  .const PI_u4f28 = $3243f6a9
  // PI/2 in u[4.28] format
  .const PI_HALF_u4f28 = $1921fb54
  // PI*2 in u[4.12] format
  .const PI2_u4f12 = $6488
  // PI in u[4.12] format
  .const PI_u4f12 = $3244
  // PI/2 in u[4.12] format
  .const PI_HALF_u4f12 = $1922
  .const SIZEOF_SIGNED_WORD = 2
  .label print_line_cursor = $400
  // Remainder after unsigned 16-bit division
  .label rem16u = $9c
  .label print_char_cursor = 7
  // @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 wavelength = $c0
    .label __3 = $44
    .label __4 = $48
    .label __6 = $4c
    .label __11 = $46
    .label sb = $43
    .label sw = $4a
    .label sd = $4d
    .label i = 2
    // [5] call sin8s_gen 
    // [164] phi from main to sin8s_gen [phi:main->sin8s_gen]
  sin8s_gen_from_main:
    jsr sin8s_gen
    // [6] phi from main to main::@2 [phi:main->main::@2]
  __b2_from_main:
    jmp __b2
    // main::@2
  __b2:
    // [7] call sin16s_gen 
    // [62] phi from main::@2 to sin16s_gen [phi:main::@2->sin16s_gen]
  sin16s_gen_from___b2:
    jsr sin16s_gen
    // [8] phi from main::@2 to main::@3 [phi:main::@2->main::@3]
  __b3_from___b2:
    jmp __b3
    // main::@3
  __b3:
    // [9] call print_cls 
    // [53] phi from main::@3 to print_cls [phi:main::@3->print_cls]
  print_cls_from___b3:
    jsr print_cls
    // [10] phi from main::@3 to main::@1 [phi:main::@3->main::@1]
  __b1_from___b3:
    // [10] phi (byte*) print_char_cursor#42 = (const byte*) print_line_cursor#0 [phi:main::@3->main::@1#0] -- pbuz1=pbuc1 
    lda #<print_line_cursor
    sta.z print_char_cursor
    lda #>print_line_cursor
    sta.z print_char_cursor+1
    // [10] phi (byte) main::i#2 = (byte) 0 [phi:main::@3->main::@1#1] -- vbuz1=vbuc1 
    lda #0
    sta.z i
    jmp __b1
    // [10] phi from main::@5 to main::@1 [phi:main::@5->main::@1]
  __b1_from___b5:
    // [10] phi (byte*) print_char_cursor#42 = (byte*) print_char_cursor#19 [phi:main::@5->main::@1#0] -- register_copy 
    // [10] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@5->main::@1#1] -- register_copy 
    jmp __b1
    // main::@1
  __b1:
    // [11] (signed byte) main::sb#0 ← *((const signed byte*) main::sintabb + (byte) main::i#2) -- vbsz1=pbsc1_derefidx_vbuz2 
    ldy.z i
    lda sintabb,y
    sta.z sb
    // [12] (word~) main::$3 ← (word)(byte) main::i#2 -- vwuz1=_word_vbuz2 
    lda.z i
    sta.z __3
    lda #0
    sta.z __3+1
    // [13] (word~) main::$11 ← (word~) main::$3 << (byte) 1 -- vwuz1=vwuz2_rol_1 
    lda.z __3
    asl
    sta.z __11
    lda.z __3+1
    rol
    sta.z __11+1
    // [14] (signed word*~) main::$4 ← (const signed word*) main::sintabw + (word~) main::$11 -- pwsz1=pwsc1_plus_vwuz2 
    lda.z __11
    clc
    adc #<sintabw
    sta.z __4
    lda.z __11+1
    adc #>sintabw
    sta.z __4+1
    // [15] (signed word) main::sw#0 ← *((signed word*~) main::$4) -- vwsz1=_deref_pwsz2 
    ldy #0
    lda (__4),y
    sta.z sw
    iny
    lda (__4),y
    sta.z sw+1
    // [16] (byte~) main::$6 ← > (signed word) main::sw#0 -- vbuz1=_hi_vwsz2 
    lda.z sw+1
    sta.z __6
    // [17] (signed byte) main::sd#0 ← (signed byte) main::sb#0 - (signed byte)(byte~) main::$6 -- vbsz1=vbsz2_minus_vbsz3 
    lda.z sb
    sec
    sbc.z __6
    sta.z sd
    // [18] (signed byte) print_sbyte::b#1 ← (signed byte) main::sd#0 -- vbsz1=vbsz2 
    lda.z sd
    sta.z print_sbyte.b
    // [19] call print_sbyte 
    jsr print_sbyte
    // [20] phi from main::@1 to main::@4 [phi:main::@1->main::@4]
  __b4_from___b1:
    jmp __b4
    // main::@4
  __b4:
    // [21] call print_str 
    // [25] phi from main::@4 to print_str [phi:main::@4->print_str]
  print_str_from___b4:
    jsr print_str
    jmp __b5
    // main::@5
  __b5:
    // [22] (byte) main::i#1 ← ++ (byte) main::i#2 -- vbuz1=_inc_vbuz1 
    inc.z i
    // [23] if((byte) main::i#1!=(byte) $c0) goto main::@1 -- vbuz1_neq_vbuc1_then_la1 
    lda #$c0
    cmp.z i
    bne __b1_from___b5
    jmp __breturn
    // main::@return
  __breturn:
    // [24] return 
    rts
    sintabb: .fill $c0, 0
    sintabw: .fill 2*$c0, 0
    str: .text "  "
    .byte 0
}
  // print_str
// Print a zero-terminated string
// print_str(byte* zp(3) str)
print_str: {
    .label str = 3
    // [26] phi from print_str to print_str::@1 [phi:print_str->print_str::@1]
  __b1_from_print_str:
    // [26] phi (byte*) print_char_cursor#19 = (byte*) print_char_cursor#10 [phi:print_str->print_str::@1#0] -- register_copy 
    // [26] phi (byte*) print_str::str#2 = (const byte*) main::str [phi:print_str->print_str::@1#1] -- pbuz1=pbuc1 
    lda #<main.str
    sta.z str
    lda #>main.str
    sta.z str+1
    jmp __b1
    // print_str::@1
  __b1:
    // [27] if((byte) 0!=*((byte*) print_str::str#2)) 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:
    // [28] return 
    rts
    // print_str::@2
  __b2:
    // [29] *((byte*) print_char_cursor#19) ← *((byte*) print_str::str#2) -- _deref_pbuz1=_deref_pbuz2 
    ldy #0
    lda (str),y
    ldy #0
    sta (print_char_cursor),y
    // [30] (byte*) print_char_cursor#1 ← ++ (byte*) print_char_cursor#19 -- pbuz1=_inc_pbuz1 
    inc.z print_char_cursor
    bne !+
    inc.z print_char_cursor+1
  !:
    // [31] (byte*) print_str::str#0 ← ++ (byte*) print_str::str#2 -- pbuz1=_inc_pbuz1 
    inc.z str
    bne !+
    inc.z str+1
  !:
    // [26] phi from print_str::@2 to print_str::@1 [phi:print_str::@2->print_str::@1]
  __b1_from___b2:
    // [26] phi (byte*) print_char_cursor#19 = (byte*) print_char_cursor#1 [phi:print_str::@2->print_str::@1#0] -- register_copy 
    // [26] phi (byte*) print_str::str#2 = (byte*) print_str::str#0 [phi:print_str::@2->print_str::@1#1] -- register_copy 
    jmp __b1
}
  // print_sbyte
// Print a signed byte as HEX
// print_sbyte(signed byte zp(5) b)
print_sbyte: {
    .label b = 5
    // [32] if((signed byte) print_sbyte::b#1<(signed byte) 0) goto print_sbyte::@1 -- vbsz1_lt_0_then_la1 
    lda.z b
    bmi __b1_from_print_sbyte
    // [33] phi from print_sbyte to print_sbyte::@3 [phi:print_sbyte->print_sbyte::@3]
  __b3_from_print_sbyte:
    jmp __b3
    // print_sbyte::@3
  __b3:
    // [34] call print_char 
    // [42] phi from print_sbyte::@3 to print_char [phi:print_sbyte::@3->print_char]
  print_char_from___b3:
    // [42] phi (byte*) print_char_cursor#28 = (byte*) print_char_cursor#42 [phi:print_sbyte::@3->print_char#0] -- register_copy 
    // [42] phi (byte) print_char::ch#4 = (byte) ' ' [phi:print_sbyte::@3->print_char#1] -- vbuz1=vbuc1 
    lda #' '
    sta.z print_char.ch
    jsr print_char
    // [35] phi from print_sbyte::@3 print_sbyte::@4 to print_sbyte::@2 [phi:print_sbyte::@3/print_sbyte::@4->print_sbyte::@2]
  __b2_from___b3:
  __b2_from___b4:
    // [35] phi (signed byte) print_sbyte::b#4 = (signed byte) print_sbyte::b#1 [phi:print_sbyte::@3/print_sbyte::@4->print_sbyte::@2#0] -- register_copy 
    jmp __b2
    // print_sbyte::@2
  __b2:
    // [36] (byte) print_byte::b#0 ← (byte)(signed byte) print_sbyte::b#4 -- vbuz1=vbuz2 
    lda.z b
    sta.z print_byte.b
    // [37] call print_byte 
    jsr print_byte
    jmp __breturn
    // print_sbyte::@return
  __breturn:
    // [38] return 
    rts
    // [39] phi from print_sbyte to print_sbyte::@1 [phi:print_sbyte->print_sbyte::@1]
  __b1_from_print_sbyte:
    jmp __b1
    // print_sbyte::@1
  __b1:
    // [40] call print_char 
    // [42] phi from print_sbyte::@1 to print_char [phi:print_sbyte::@1->print_char]
  print_char_from___b1:
    // [42] phi (byte*) print_char_cursor#28 = (byte*) print_char_cursor#42 [phi:print_sbyte::@1->print_char#0] -- register_copy 
    // [42] phi (byte) print_char::ch#4 = (byte) '-' [phi:print_sbyte::@1->print_char#1] -- vbuz1=vbuc1 
    lda #'-'
    sta.z print_char.ch
    jsr print_char
    jmp __b4
    // print_sbyte::@4
  __b4:
    // [41] (signed byte) print_sbyte::b#0 ← - (signed byte) print_sbyte::b#1 -- vbsz1=_neg_vbsz1 
    lda.z b
    eor #$ff
    clc
    adc #1
    sta.z b
    jmp __b2_from___b4
}
  // print_char
// Print a single char
// print_char(byte zp(6) ch)
print_char: {
    .label ch = 6
    // [43] *((byte*) print_char_cursor#28) ← (byte) print_char::ch#4 -- _deref_pbuz1=vbuz2 
    lda.z ch
    ldy #0
    sta (print_char_cursor),y
    // [44] (byte*) print_char_cursor#10 ← ++ (byte*) print_char_cursor#28 -- pbuz1=_inc_pbuz1 
    inc.z print_char_cursor
    bne !+
    inc.z print_char_cursor+1
  !:
    jmp __breturn
    // print_char::@return
  __breturn:
    // [45] return 
    rts
}
  // print_byte
// Print a byte as HEX
// print_byte(byte zp($4e) b)
print_byte: {
    .label __0 = $4f
    .label __2 = $50
    .label b = $4e
    // [46] (byte~) print_byte::$0 ← (byte) print_byte::b#0 >> (byte) 4 -- vbuz1=vbuz2_ror_4 
    lda.z b
    lsr
    lsr
    lsr
    lsr
    sta.z __0
    // [47] (byte) print_char::ch#2 ← *((const byte*) print_hextab + (byte~) print_byte::$0) -- vbuz1=pbuc1_derefidx_vbuz2 
    ldy.z __0
    lda print_hextab,y
    sta.z print_char.ch
    // [48] call print_char 
    // [42] phi from print_byte to print_char [phi:print_byte->print_char]
  print_char_from_print_byte:
    // [42] phi (byte*) print_char_cursor#28 = (byte*) print_char_cursor#10 [phi:print_byte->print_char#0] -- register_copy 
    // [42] phi (byte) print_char::ch#4 = (byte) print_char::ch#2 [phi:print_byte->print_char#1] -- register_copy 
    jsr print_char
    jmp __b1
    // print_byte::@1
  __b1:
    // [49] (byte~) print_byte::$2 ← (byte) print_byte::b#0 & (byte) $f -- vbuz1=vbuz2_band_vbuc1 
    lda #$f
    and.z b
    sta.z __2
    // [50] (byte) print_char::ch#3 ← *((const byte*) print_hextab + (byte~) print_byte::$2) -- vbuz1=pbuc1_derefidx_vbuz2 
    ldy.z __2
    lda print_hextab,y
    sta.z print_char.ch
    // [51] call print_char 
    // [42] phi from print_byte::@1 to print_char [phi:print_byte::@1->print_char]
  print_char_from___b1:
    // [42] phi (byte*) print_char_cursor#28 = (byte*) print_char_cursor#10 [phi:print_byte::@1->print_char#0] -- register_copy 
    // [42] phi (byte) print_char::ch#4 = (byte) print_char::ch#3 [phi:print_byte::@1->print_char#1] -- register_copy 
    jsr print_char
    jmp __breturn
    // print_byte::@return
  __breturn:
    // [52] return 
    rts
}
  // print_cls
// Clear the screen. Also resets current line/char cursor.
print_cls: {
    // [54] call memset 
    // [56] phi from print_cls to memset [phi:print_cls->memset]
  memset_from_print_cls:
    jsr memset
    jmp __breturn
    // print_cls::@return
  __breturn:
    // [55] 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 = print_line_cursor
    .label end = str+num
    .label dst = 9
    // [57] phi from memset to memset::@1 [phi:memset->memset::@1]
  __b1_from_memset:
    // [57] 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:
    // [58] 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:
    // [59] return 
    rts
    // memset::@2
  __b2:
    // [60] *((byte*) memset::dst#2) ← (const byte) memset::c#0 -- _deref_pbuz1=vbuc1 
    lda #c
    ldy #0
    sta (dst),y
    // [61] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2 -- pbuz1=_inc_pbuz1 
    inc.z dst
    bne !+
    inc.z dst+1
  !:
    // [57] phi from memset::@2 to memset::@1 [phi:memset::@2->memset::@1]
  __b1_from___b2:
    // [57] phi (byte*) memset::dst#2 = (byte*) memset::dst#1 [phi:memset::@2->memset::@1#0] -- register_copy 
    jmp __b1
}
  // sin16s_gen
// Generate signed (large) word sinus table - on the full -$7fff - $7fff range
// sintab - the table to generate into
// wavelength - the number of sinus points in a total sinus wavelength (the size of the table)
// sin16s_gen(signed word* zp($11) sintab)
sin16s_gen: {
    .label __2 = $5b
    .label step = $55
    .label sintab = $11
    // u[4.28]
    // Iterate over the table
    .label x = $d
    .label i = $b
    // [63] call div32u16u 
    // [136] phi from sin16s_gen to div32u16u [phi:sin16s_gen->div32u16u]
  div32u16u_from_sin16s_gen:
    jsr div32u16u
    // [64] (dword) div32u16u::return#2 ← (dword) div32u16u::return#0 -- vduz1=vduz2 
    lda.z div32u16u.return
    sta.z div32u16u.return_1
    lda.z div32u16u.return+1
    sta.z div32u16u.return_1+1
    lda.z div32u16u.return+2
    sta.z div32u16u.return_1+2
    lda.z div32u16u.return+3
    sta.z div32u16u.return_1+3
    jmp __b3
    // sin16s_gen::@3
  __b3:
    // [65] (dword) sin16s_gen::step#0 ← (dword) div32u16u::return#2 -- vduz1=vduz2 
    lda.z div32u16u.return_1
    sta.z step
    lda.z div32u16u.return_1+1
    sta.z step+1
    lda.z div32u16u.return_1+2
    sta.z step+2
    lda.z div32u16u.return_1+3
    sta.z step+3
    // [66] phi from sin16s_gen::@3 to sin16s_gen::@1 [phi:sin16s_gen::@3->sin16s_gen::@1]
  __b1_from___b3:
    // [66] phi (signed word*) sin16s_gen::sintab#2 = (const signed word*) main::sintabw [phi:sin16s_gen::@3->sin16s_gen::@1#0] -- pwsz1=pwsc1 
    lda #<main.sintabw
    sta.z sintab
    lda #>main.sintabw
    sta.z sintab+1
    // [66] phi (dword) sin16s_gen::x#2 = (dword) 0 [phi:sin16s_gen::@3->sin16s_gen::@1#1] -- vduz1=vduc1 
    lda #<0
    sta.z x
    lda #>0
    sta.z x+1
    lda #<0>>$10
    sta.z x+2
    lda #>0>>$10
    sta.z x+3
    // [66] phi (word) sin16s_gen::i#2 = (word) 0 [phi:sin16s_gen::@3->sin16s_gen::@1#2] -- vwuz1=vwuc1 
    lda #<0
    sta.z i
    lda #>0
    sta.z i+1
    jmp __b1
  // u[4.28]
    // sin16s_gen::@1
  __b1:
    // [67] if((word) sin16s_gen::i#2<(const word) main::wavelength) goto sin16s_gen::@2 -- vwuz1_lt_vwuc1_then_la1 
    lda.z i+1
    cmp #>main.wavelength
    bcc __b2
    bne !+
    lda.z i
    cmp #<main.wavelength
    bcc __b2
  !:
    jmp __breturn
    // sin16s_gen::@return
  __breturn:
    // [68] return 
    rts
    // sin16s_gen::@2
  __b2:
    // [69] (dword) sin16s::x#0 ← (dword) sin16s_gen::x#2 -- vduz1=vduz2 
    lda.z x
    sta.z sin16s.x
    lda.z x+1
    sta.z sin16s.x+1
    lda.z x+2
    sta.z sin16s.x+2
    lda.z x+3
    sta.z sin16s.x+3
    // [70] call sin16s 
    jsr sin16s
    // [71] (signed word) sin16s::return#0 ← (signed word) sin16s::return#1 -- vwsz1=vwsz2 
    lda.z sin16s.return_1
    sta.z sin16s.return
    lda.z sin16s.return_1+1
    sta.z sin16s.return+1
    jmp __b4
    // sin16s_gen::@4
  __b4:
    // [72] (signed word~) sin16s_gen::$2 ← (signed word) sin16s::return#0 -- vwsz1=vwsz2 
    lda.z sin16s.return
    sta.z __2
    lda.z sin16s.return+1
    sta.z __2+1
    // [73] *((signed word*) sin16s_gen::sintab#2) ← (signed word~) sin16s_gen::$2 -- _deref_pwsz1=vwsz2 
    ldy #0
    lda.z __2
    sta (sintab),y
    iny
    lda.z __2+1
    sta (sintab),y
    // [74] (signed word*) sin16s_gen::sintab#0 ← (signed word*) sin16s_gen::sintab#2 + (const byte) SIZEOF_SIGNED_WORD -- pwsz1=pwsz1_plus_vbuc1 
    lda #SIZEOF_SIGNED_WORD
    clc
    adc.z sintab
    sta.z sintab
    bcc !+
    inc.z sintab+1
  !:
    // [75] (dword) sin16s_gen::x#1 ← (dword) sin16s_gen::x#2 + (dword) sin16s_gen::step#0 -- vduz1=vduz1_plus_vduz2 
    lda.z x
    clc
    adc.z step
    sta.z x
    lda.z x+1
    adc.z step+1
    sta.z x+1
    lda.z x+2
    adc.z step+2
    sta.z x+2
    lda.z x+3
    adc.z step+3
    sta.z x+3
    // [76] (word) sin16s_gen::i#1 ← ++ (word) sin16s_gen::i#2 -- vwuz1=_inc_vwuz1 
    inc.z i
    bne !+
    inc.z i+1
  !:
    // [66] phi from sin16s_gen::@4 to sin16s_gen::@1 [phi:sin16s_gen::@4->sin16s_gen::@1]
  __b1_from___b4:
    // [66] phi (signed word*) sin16s_gen::sintab#2 = (signed word*) sin16s_gen::sintab#0 [phi:sin16s_gen::@4->sin16s_gen::@1#0] -- register_copy 
    // [66] phi (dword) sin16s_gen::x#2 = (dword) sin16s_gen::x#1 [phi:sin16s_gen::@4->sin16s_gen::@1#1] -- register_copy 
    // [66] phi (word) sin16s_gen::i#2 = (word) sin16s_gen::i#1 [phi:sin16s_gen::@4->sin16s_gen::@1#2] -- register_copy 
    jmp __b1
}
  // sin16s
// Calculate signed word sinus sin(x)
// x: unsigned dword input u[4.28] in the interval $00000000 - PI2_u4f28
// result: signed word sin(x) s[0.15] - using the full range  -$7fff - $7fff
// sin16s(dword zp($14) x)
sin16s: {
    .label __4 = $5d
    .label x = $14
    .label return = $59
    .label x1 = $61
    .label x2 = $65
    .label x3 = $69
    .label x3_6 = $6d
    .label usinx = $6f
    .label x4 = $73
    .label x5 = $77
    .label x5_128 = $79
    .label usinx_1 = $7b
    .label return_1 = $18
    .label sinx = $18
    // Move x1 into the range 0-PI/2 using sinus mirror symmetries
    .label isUpper = $13
    // [77] if((dword) sin16s::x#0<(const dword) PI_u4f28) goto sin16s::@1 -- vduz1_lt_vduc1_then_la1 
    lda.z x+3
    cmp #>PI_u4f28>>$10
    bcc __b1_from_sin16s
    bne !+
    lda.z x+2
    cmp #<PI_u4f28>>$10
    bcc __b1_from_sin16s
    bne !+
    lda.z x+1
    cmp #>PI_u4f28
    bcc __b1_from_sin16s
    bne !+
    lda.z x
    cmp #<PI_u4f28
    bcc __b1_from_sin16s
  !:
    jmp __b4
    // sin16s::@4
  __b4:
    // [78] (dword) sin16s::x#1 ← (dword) sin16s::x#0 - (const dword) PI_u4f28 -- vduz1=vduz1_minus_vduc1 
    lda.z x
    sec
    sbc #<PI_u4f28
    sta.z x
    lda.z x+1
    sbc #>PI_u4f28
    sta.z x+1
    lda.z x+2
    sbc #<PI_u4f28>>$10
    sta.z x+2
    lda.z x+3
    sbc #>PI_u4f28>>$10
    sta.z x+3
    // [79] phi from sin16s::@4 to sin16s::@1 [phi:sin16s::@4->sin16s::@1]
  __b1_from___b4:
    // [79] phi (byte) sin16s::isUpper#2 = (byte) 1 [phi:sin16s::@4->sin16s::@1#0] -- vbuz1=vbuc1 
    lda #1
    sta.z isUpper
    // [79] phi (dword) sin16s::x#4 = (dword) sin16s::x#1 [phi:sin16s::@4->sin16s::@1#1] -- register_copy 
    jmp __b1
    // [79] phi from sin16s to sin16s::@1 [phi:sin16s->sin16s::@1]
  __b1_from_sin16s:
    // [79] phi (byte) sin16s::isUpper#2 = (byte) 0 [phi:sin16s->sin16s::@1#0] -- vbuz1=vbuc1 
    lda #0
    sta.z isUpper
    // [79] phi (dword) sin16s::x#4 = (dword) sin16s::x#0 [phi:sin16s->sin16s::@1#1] -- register_copy 
    jmp __b1
    // sin16s::@1
  __b1:
    // [80] if((dword) sin16s::x#4<(const dword) PI_HALF_u4f28) goto sin16s::@2 -- vduz1_lt_vduc1_then_la1 
    lda.z x+3
    cmp #>PI_HALF_u4f28>>$10
    bcc __b2_from___b1
    bne !+
    lda.z x+2
    cmp #<PI_HALF_u4f28>>$10
    bcc __b2_from___b1
    bne !+
    lda.z x+1
    cmp #>PI_HALF_u4f28
    bcc __b2_from___b1
    bne !+
    lda.z x
    cmp #<PI_HALF_u4f28
    bcc __b2_from___b1
  !:
    jmp __b5
    // sin16s::@5
  __b5:
    // [81] (dword) sin16s::x#2 ← (const dword) PI_u4f28 - (dword) sin16s::x#4 -- vduz1=vduc1_minus_vduz1 
    lda #<PI_u4f28
    sec
    sbc.z x
    sta.z x
    lda #>PI_u4f28
    sbc.z x+1
    sta.z x+1
    lda #<PI_u4f28>>$10
    sbc.z x+2
    sta.z x+2
    lda #>PI_u4f28>>$10
    sbc.z x+3
    sta.z x+3
    // [82] phi from sin16s::@1 sin16s::@5 to sin16s::@2 [phi:sin16s::@1/sin16s::@5->sin16s::@2]
  __b2_from___b1:
  __b2_from___b5:
    // [82] phi (dword) sin16s::x#6 = (dword) sin16s::x#4 [phi:sin16s::@1/sin16s::@5->sin16s::@2#0] -- register_copy 
    jmp __b2
    // sin16s::@2
  __b2:
    // [83] (dword~) sin16s::$4 ← (dword) sin16s::x#6 << (byte) 3 -- vduz1=vduz2_rol_3 
    lda.z x
    asl
    sta.z __4
    lda.z x+1
    rol
    sta.z __4+1
    lda.z x+2
    rol
    sta.z __4+2
    lda.z x+3
    rol
    sta.z __4+3
    asl.z __4
    rol.z __4+1
    rol.z __4+2
    rol.z __4+3
    asl.z __4
    rol.z __4+1
    rol.z __4+2
    rol.z __4+3
    // [84] (word) sin16s::x1#0 ← > (dword~) sin16s::$4 -- vwuz1=_hi_vduz2 
    lda.z __4+2
    sta.z x1
    lda.z __4+3
    sta.z x1+1
    // [85] (word) mulu16_sel::v1#0 ← (word) sin16s::x1#0 -- vwuz1=vwuz2 
    lda.z x1
    sta.z mulu16_sel.v1
    lda.z x1+1
    sta.z mulu16_sel.v1+1
    // [86] (word) mulu16_sel::v2#0 ← (word) sin16s::x1#0 -- vwuz1=vwuz2 
    lda.z x1
    sta.z mulu16_sel.v2
    lda.z x1+1
    sta.z mulu16_sel.v2+1
    // [87] call mulu16_sel 
    // [117] phi from sin16s::@2 to mulu16_sel [phi:sin16s::@2->mulu16_sel]
  mulu16_sel_from___b2:
    // [117] phi (byte) mulu16_sel::select#5 = (byte) 0 [phi:sin16s::@2->mulu16_sel#0] -- vbuz1=vbuc1 
    lda #0
    sta.z mulu16_sel.select
    // [117] phi (word) mulu16_sel::v2#5 = (word) mulu16_sel::v2#0 [phi:sin16s::@2->mulu16_sel#1] -- register_copy 
    // [117] phi (word) mulu16_sel::v1#5 = (word) mulu16_sel::v1#0 [phi:sin16s::@2->mulu16_sel#2] -- register_copy 
    jsr mulu16_sel
    // [88] (word) mulu16_sel::return#0 ← (word) mulu16_sel::return#12 -- vwuz1=vwuz2 
    lda.z mulu16_sel.return_5
    sta.z mulu16_sel.return
    lda.z mulu16_sel.return_5+1
    sta.z mulu16_sel.return+1
    jmp __b7
    // sin16s::@7
  __b7:
    // [89] (word) sin16s::x2#0 ← (word) mulu16_sel::return#0 -- vwuz1=vwuz2 
    lda.z mulu16_sel.return
    sta.z x2
    lda.z mulu16_sel.return+1
    sta.z x2+1
    // [90] (word) mulu16_sel::v1#1 ← (word) sin16s::x2#0 -- vwuz1=vwuz2 
    lda.z x2
    sta.z mulu16_sel.v1
    lda.z x2+1
    sta.z mulu16_sel.v1+1
    // [91] (word) mulu16_sel::v2#1 ← (word) sin16s::x1#0 -- vwuz1=vwuz2 
    lda.z x1
    sta.z mulu16_sel.v2
    lda.z x1+1
    sta.z mulu16_sel.v2+1
    // [92] call mulu16_sel 
    // [117] phi from sin16s::@7 to mulu16_sel [phi:sin16s::@7->mulu16_sel]
  mulu16_sel_from___b7:
    // [117] phi (byte) mulu16_sel::select#5 = (byte) 1 [phi:sin16s::@7->mulu16_sel#0] -- vbuz1=vbuc1 
    lda #1
    sta.z mulu16_sel.select
    // [117] phi (word) mulu16_sel::v2#5 = (word) mulu16_sel::v2#1 [phi:sin16s::@7->mulu16_sel#1] -- register_copy 
    // [117] phi (word) mulu16_sel::v1#5 = (word) mulu16_sel::v1#1 [phi:sin16s::@7->mulu16_sel#2] -- register_copy 
    jsr mulu16_sel
    // [93] (word) mulu16_sel::return#1 ← (word) mulu16_sel::return#12 -- vwuz1=vwuz2 
    lda.z mulu16_sel.return_5
    sta.z mulu16_sel.return_1
    lda.z mulu16_sel.return_5+1
    sta.z mulu16_sel.return_1+1
    jmp __b8
    // sin16s::@8
  __b8:
    // [94] (word) sin16s::x3#0 ← (word) mulu16_sel::return#1 -- vwuz1=vwuz2 
    lda.z mulu16_sel.return_1
    sta.z x3
    lda.z mulu16_sel.return_1+1
    sta.z x3+1
    // [95] (word) mulu16_sel::v1#2 ← (word) sin16s::x3#0 -- vwuz1=vwuz2 
    lda.z x3
    sta.z mulu16_sel.v1
    lda.z x3+1
    sta.z mulu16_sel.v1+1
    // [96] call mulu16_sel 
    // [117] phi from sin16s::@8 to mulu16_sel [phi:sin16s::@8->mulu16_sel]
  mulu16_sel_from___b8:
    // [117] phi (byte) mulu16_sel::select#5 = (byte) 1 [phi:sin16s::@8->mulu16_sel#0] -- vbuz1=vbuc1 
    lda #1
    sta.z mulu16_sel.select
    // [117] phi (word) mulu16_sel::v2#5 = (word)(number) $10000/(number) 6 [phi:sin16s::@8->mulu16_sel#1] -- vwuz1=vwuc1 
    lda #<$10000/6
    sta.z mulu16_sel.v2
    lda #>$10000/6
    sta.z mulu16_sel.v2+1
    // [117] phi (word) mulu16_sel::v1#5 = (word) mulu16_sel::v1#2 [phi:sin16s::@8->mulu16_sel#2] -- register_copy 
    jsr mulu16_sel
    // [97] (word) mulu16_sel::return#2 ← (word) mulu16_sel::return#12 -- vwuz1=vwuz2 
    lda.z mulu16_sel.return_5
    sta.z mulu16_sel.return_2
    lda.z mulu16_sel.return_5+1
    sta.z mulu16_sel.return_2+1
    jmp __b9
    // sin16s::@9
  __b9:
    // [98] (word) sin16s::x3_6#0 ← (word) mulu16_sel::return#2 -- vwuz1=vwuz2 
    lda.z mulu16_sel.return_2
    sta.z x3_6
    lda.z mulu16_sel.return_2+1
    sta.z x3_6+1
    // [99] (word) sin16s::usinx#0 ← (word) sin16s::x1#0 - (word) sin16s::x3_6#0 -- vwuz1=vwuz2_minus_vwuz3 
    lda.z x1
    sec
    sbc.z x3_6
    sta.z usinx
    lda.z x1+1
    sbc.z x3_6+1
    sta.z usinx+1
    // [100] (word) mulu16_sel::v1#3 ← (word) sin16s::x3#0 -- vwuz1=vwuz2 
    lda.z x3
    sta.z mulu16_sel.v1
    lda.z x3+1
    sta.z mulu16_sel.v1+1
    // [101] (word) mulu16_sel::v2#3 ← (word) sin16s::x1#0 -- vwuz1=vwuz2 
    lda.z x1
    sta.z mulu16_sel.v2
    lda.z x1+1
    sta.z mulu16_sel.v2+1
    // [102] call mulu16_sel 
    // [117] phi from sin16s::@9 to mulu16_sel [phi:sin16s::@9->mulu16_sel]
  mulu16_sel_from___b9:
    // [117] phi (byte) mulu16_sel::select#5 = (byte) 0 [phi:sin16s::@9->mulu16_sel#0] -- vbuz1=vbuc1 
    lda #0
    sta.z mulu16_sel.select
    // [117] phi (word) mulu16_sel::v2#5 = (word) mulu16_sel::v2#3 [phi:sin16s::@9->mulu16_sel#1] -- register_copy 
    // [117] phi (word) mulu16_sel::v1#5 = (word) mulu16_sel::v1#3 [phi:sin16s::@9->mulu16_sel#2] -- register_copy 
    jsr mulu16_sel
    // [103] (word) mulu16_sel::return#10 ← (word) mulu16_sel::return#12 -- vwuz1=vwuz2 
    lda.z mulu16_sel.return_5
    sta.z mulu16_sel.return_3
    lda.z mulu16_sel.return_5+1
    sta.z mulu16_sel.return_3+1
    jmp __b10
    // sin16s::@10
  __b10:
    // [104] (word) sin16s::x4#0 ← (word) mulu16_sel::return#10 -- vwuz1=vwuz2 
    lda.z mulu16_sel.return_3
    sta.z x4
    lda.z mulu16_sel.return_3+1
    sta.z x4+1
    // [105] (word) mulu16_sel::v1#4 ← (word) sin16s::x4#0 -- vwuz1=vwuz2 
    lda.z x4
    sta.z mulu16_sel.v1
    lda.z x4+1
    sta.z mulu16_sel.v1+1
    // [106] (word) mulu16_sel::v2#4 ← (word) sin16s::x1#0 -- vwuz1=vwuz2 
    lda.z x1
    sta.z mulu16_sel.v2
    lda.z x1+1
    sta.z mulu16_sel.v2+1
    // [107] call mulu16_sel 
    // [117] phi from sin16s::@10 to mulu16_sel [phi:sin16s::@10->mulu16_sel]
  mulu16_sel_from___b10:
    // [117] phi (byte) mulu16_sel::select#5 = (byte) 0 [phi:sin16s::@10->mulu16_sel#0] -- vbuz1=vbuc1 
    lda #0
    sta.z mulu16_sel.select
    // [117] phi (word) mulu16_sel::v2#5 = (word) mulu16_sel::v2#4 [phi:sin16s::@10->mulu16_sel#1] -- register_copy 
    // [117] phi (word) mulu16_sel::v1#5 = (word) mulu16_sel::v1#4 [phi:sin16s::@10->mulu16_sel#2] -- register_copy 
    jsr mulu16_sel
    // [108] (word) mulu16_sel::return#11 ← (word) mulu16_sel::return#12 -- vwuz1=vwuz2 
    lda.z mulu16_sel.return_5
    sta.z mulu16_sel.return_4
    lda.z mulu16_sel.return_5+1
    sta.z mulu16_sel.return_4+1
    jmp __b11
    // sin16s::@11
  __b11:
    // [109] (word) sin16s::x5#0 ← (word) mulu16_sel::return#11 -- vwuz1=vwuz2 
    lda.z mulu16_sel.return_4
    sta.z x5
    lda.z mulu16_sel.return_4+1
    sta.z x5+1
    // [110] (word) sin16s::x5_128#0 ← (word) sin16s::x5#0 >> (byte) 4 -- vwuz1=vwuz2_ror_4 
    lda.z x5+1
    lsr
    sta.z x5_128+1
    lda.z x5
    ror
    sta.z x5_128
    lsr.z x5_128+1
    ror.z x5_128
    lsr.z x5_128+1
    ror.z x5_128
    lsr.z x5_128+1
    ror.z x5_128
    // [111] (word) sin16s::usinx#1 ← (word) sin16s::usinx#0 + (word) sin16s::x5_128#0 -- vwuz1=vwuz2_plus_vwuz3 
    lda.z usinx
    clc
    adc.z x5_128
    sta.z usinx_1
    lda.z usinx+1
    adc.z x5_128+1
    sta.z usinx_1+1
    // [112] if((byte) sin16s::isUpper#2==(byte) 0) goto sin16s::@12 -- vbuz1_eq_0_then_la1 
    lda.z isUpper
    cmp #0
    beq __b12
    jmp __b6
    // sin16s::@6
  __b6:
    // [113] (signed word) sin16s::sinx#1 ← - (signed word)(word) sin16s::usinx#1 -- vwsz1=_neg_vwsz2 
    sec
    lda #0
    sbc.z usinx_1
    sta.z sinx
    lda #0
    sbc.z usinx_1+1
    sta.z sinx+1
    // [114] phi from sin16s::@12 sin16s::@6 to sin16s::@3 [phi:sin16s::@12/sin16s::@6->sin16s::@3]
  __b3_from___b12:
  __b3_from___b6:
    // [114] phi (signed word) sin16s::return#1 = (signed word) sin16s::return#5 [phi:sin16s::@12/sin16s::@6->sin16s::@3#0] -- register_copy 
    jmp __b3
    // sin16s::@3
  __b3:
    jmp __breturn
    // sin16s::@return
  __breturn:
    // [115] return 
    rts
    // sin16s::@12
  __b12:
    // [116] (signed word) sin16s::return#5 ← (signed word)(word) sin16s::usinx#1 -- vwsz1=vwsz2 
    lda.z usinx_1
    sta.z return_1
    lda.z usinx_1+1
    sta.z return_1+1
    jmp __b3_from___b12
}
  // mulu16_sel
// Calculate val*val for two unsigned word values - the result is 16 selected bits of the 32-bit result.
// The select parameter indicates how many of the highest bits of the 32-bit result to skip
// mulu16_sel(word zp($1a) v1, word zp($1c) v2, byte zp($1e) select)
mulu16_sel: {
    .label __0 = $83
    .label __1 = $87
    .label v1 = $1a
    .label v2 = $1c
    .label return = $63
    .label return_1 = $67
    .label return_2 = $6b
    .label return_3 = $71
    .label return_4 = $75
    .label select = $1e
    .label return_5 = $8b
    // [118] (word) mul16u::a#1 ← (word) mulu16_sel::v1#5 -- vwuz1=vwuz2 
    lda.z v1
    sta.z mul16u.a
    lda.z v1+1
    sta.z mul16u.a+1
    // [119] (word) mul16u::b#0 ← (word) mulu16_sel::v2#5 -- vwuz1=vwuz2 
    lda.z v2
    sta.z mul16u.b
    lda.z v2+1
    sta.z mul16u.b+1
    // [120] call mul16u 
    jsr mul16u
    // [121] (dword) mul16u::return#2 ← (dword) mul16u::res#2 -- vduz1=vduz2 
    lda.z mul16u.res
    sta.z mul16u.return
    lda.z mul16u.res+1
    sta.z mul16u.return+1
    lda.z mul16u.res+2
    sta.z mul16u.return+2
    lda.z mul16u.res+3
    sta.z mul16u.return+3
    jmp __b1
    // mulu16_sel::@1
  __b1:
    // [122] (dword~) mulu16_sel::$0 ← (dword) mul16u::return#2 -- vduz1=vduz2 
    lda.z mul16u.return
    sta.z __0
    lda.z mul16u.return+1
    sta.z __0+1
    lda.z mul16u.return+2
    sta.z __0+2
    lda.z mul16u.return+3
    sta.z __0+3
    // [123] (dword~) mulu16_sel::$1 ← (dword~) mulu16_sel::$0 << (byte) mulu16_sel::select#5 -- vduz1=vduz2_rol_vbuz3 
    lda.z __0
    sta.z __1
    lda.z __0+1
    sta.z __1+1
    lda.z __0+2
    sta.z __1+2
    lda.z __0+3
    sta.z __1+3
    ldx.z select
    beq !e+
  !:
    asl.z __1
    rol.z __1+1
    rol.z __1+2
    rol.z __1+3
    dex
    bne !-
  !e:
    // [124] (word) mulu16_sel::return#12 ← > (dword~) mulu16_sel::$1 -- vwuz1=_hi_vduz2 
    lda.z __1+2
    sta.z return_5
    lda.z __1+3
    sta.z return_5+1
    jmp __breturn
    // mulu16_sel::@return
  __breturn:
    // [125] return 
    rts
}
  // mul16u
// Perform binary multiplication of two unsigned 16-bit words into a 32-bit unsigned double word
// mul16u(word zp($1f) a, word zp($7d) b)
mul16u: {
    .label __1 = $8d
    .label mb = $25
    .label a = $1f
    .label res = $21
    .label b = $7d
    .label return = $7f
    // [126] (dword) mul16u::mb#0 ← (dword)(word) mul16u::b#0 -- vduz1=_dword_vwuz2 
    lda.z b
    sta.z mb
    lda.z b+1
    sta.z mb+1
    lda #0
    sta.z mb+2
    sta.z mb+3
    // [127] phi from mul16u to mul16u::@1 [phi:mul16u->mul16u::@1]
  __b1_from_mul16u:
    // [127] phi (dword) mul16u::mb#2 = (dword) mul16u::mb#0 [phi:mul16u->mul16u::@1#0] -- register_copy 
    // [127] phi (dword) mul16u::res#2 = (dword) 0 [phi:mul16u->mul16u::@1#1] -- vduz1=vduc1 
    lda #<0
    sta.z res
    lda #>0
    sta.z res+1
    lda #<0>>$10
    sta.z res+2
    lda #>0>>$10
    sta.z res+3
    // [127] phi (word) mul16u::a#2 = (word) mul16u::a#1 [phi:mul16u->mul16u::@1#2] -- register_copy 
    jmp __b1
    // mul16u::@1
  __b1:
    // [128] if((word) mul16u::a#2!=(byte) 0) goto mul16u::@2 -- vwuz1_neq_0_then_la1 
    lda.z a
    bne __b2
    lda.z a+1
    bne __b2
    jmp __breturn
    // mul16u::@return
  __breturn:
    // [129] return 
    rts
    // mul16u::@2
  __b2:
    // [130] (byte~) mul16u::$1 ← (word) mul16u::a#2 & (byte) 1 -- vbuz1=vwuz2_band_vbuc1 
    lda #1
    and.z a
    sta.z __1
    // [131] if((byte~) mul16u::$1==(byte) 0) goto mul16u::@3 -- vbuz1_eq_0_then_la1 
    lda.z __1
    cmp #0
    beq __b3_from___b2
    jmp __b4
    // mul16u::@4
  __b4:
    // [132] (dword) mul16u::res#1 ← (dword) mul16u::res#2 + (dword) mul16u::mb#2 -- vduz1=vduz1_plus_vduz2 
    lda.z res
    clc
    adc.z mb
    sta.z res
    lda.z res+1
    adc.z mb+1
    sta.z res+1
    lda.z res+2
    adc.z mb+2
    sta.z res+2
    lda.z res+3
    adc.z mb+3
    sta.z res+3
    // [133] phi from mul16u::@2 mul16u::@4 to mul16u::@3 [phi:mul16u::@2/mul16u::@4->mul16u::@3]
  __b3_from___b2:
  __b3_from___b4:
    // [133] phi (dword) mul16u::res#6 = (dword) mul16u::res#2 [phi:mul16u::@2/mul16u::@4->mul16u::@3#0] -- register_copy 
    jmp __b3
    // mul16u::@3
  __b3:
    // [134] (word) mul16u::a#0 ← (word) mul16u::a#2 >> (byte) 1 -- vwuz1=vwuz1_ror_1 
    lsr.z a+1
    ror.z a
    // [135] (dword) mul16u::mb#1 ← (dword) mul16u::mb#2 << (byte) 1 -- vduz1=vduz1_rol_1 
    asl.z mb
    rol.z mb+1
    rol.z mb+2
    rol.z mb+3
    // [127] phi from mul16u::@3 to mul16u::@1 [phi:mul16u::@3->mul16u::@1]
  __b1_from___b3:
    // [127] phi (dword) mul16u::mb#2 = (dword) mul16u::mb#1 [phi:mul16u::@3->mul16u::@1#0] -- register_copy 
    // [127] phi (dword) mul16u::res#2 = (dword) mul16u::res#6 [phi:mul16u::@3->mul16u::@1#1] -- register_copy 
    // [127] phi (word) mul16u::a#2 = (word) mul16u::a#0 [phi:mul16u::@3->mul16u::@1#2] -- register_copy 
    jmp __b1
}
  // div32u16u
// Divide unsigned 32-bit dword dividend with a 16-bit word divisor
// The 16-bit word remainder can be found in rem16u after the division
div32u16u: {
    .label quotient_hi = $90
    .label quotient_lo = $94
    .label return = $96
    .label return_1 = $51
    // [137] call divr16u 
    // [146] phi from div32u16u to divr16u [phi:div32u16u->divr16u]
  divr16u_from_div32u16u:
    // [146] phi (word) divr16u::dividend#6 = >(const dword) PI2_u4f28 [phi:div32u16u->divr16u#0] -- vwuz1=vwuc1 
    lda #<PI2_u4f28>>$10
    sta.z divr16u.dividend
    lda #>PI2_u4f28>>$10
    sta.z divr16u.dividend+1
    // [146] phi (word) divr16u::rem#11 = (byte) 0 [phi:div32u16u->divr16u#1] -- vwuz1=vbuc1 
    lda #<0
    sta.z divr16u.rem
    lda #>0
    sta.z divr16u.rem+1
    jsr divr16u
    // [138] (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 __b1
    // div32u16u::@1
  __b1:
    // [139] (word) div32u16u::quotient_hi#0 ← (word) divr16u::return#3 -- vwuz1=vwuz2 
    lda.z divr16u.return_2
    sta.z quotient_hi
    lda.z divr16u.return_2+1
    sta.z quotient_hi+1
    // [140] (word) divr16u::rem#5 ← (word) rem16u#1 -- vwuz1=vwuz2 
    lda.z rem16u
    sta.z divr16u.rem
    lda.z rem16u+1
    sta.z divr16u.rem+1
    // [141] call divr16u 
    // [146] phi from div32u16u::@1 to divr16u [phi:div32u16u::@1->divr16u]
  divr16u_from___b1:
    // [146] phi (word) divr16u::dividend#6 = <(const dword) PI2_u4f28 [phi:div32u16u::@1->divr16u#0] -- vwuz1=vwuc1 
    lda #<PI2_u4f28&$ffff
    sta.z divr16u.dividend
    lda #>PI2_u4f28&$ffff
    sta.z divr16u.dividend+1
    // [146] phi (word) divr16u::rem#11 = (word) divr16u::rem#5 [phi:div32u16u::@1->divr16u#1] -- register_copy 
    jsr divr16u
    // [142] (word) divr16u::return#4 ← (word) divr16u::return#0 -- vwuz1=vwuz2 
    lda.z divr16u.return
    sta.z divr16u.return_3
    lda.z divr16u.return+1
    sta.z divr16u.return_3+1
    jmp __b2
    // div32u16u::@2
  __b2:
    // [143] (word) div32u16u::quotient_lo#0 ← (word) divr16u::return#4 -- vwuz1=vwuz2 
    lda.z divr16u.return_3
    sta.z quotient_lo
    lda.z divr16u.return_3+1
    sta.z quotient_lo+1
    // [144] (dword) div32u16u::return#0 ← (word) div32u16u::quotient_hi#0 dw= (word) div32u16u::quotient_lo#0 -- vduz1=vwuz2_dword_vwuz3 
    lda.z quotient_hi
    sta.z return+2
    lda.z quotient_hi+1
    sta.z return+3
    lda.z quotient_lo
    sta.z return
    lda.z quotient_lo+1
    sta.z return+1
    jmp __breturn
    // div32u16u::@return
  __breturn:
    // [145] return 
    rts
}
  // 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($2b) dividend, word zp($29) rem)
divr16u: {
    .label __1 = $9a
    .label __2 = $9b
    .label rem = $29
    .label dividend = $2b
    .label quotient = $2d
    .label i = $2f
    .label return = $2d
    .label return_1 = $bc
    .label return_2 = $8e
    .label return_3 = $92
    // [147] phi from divr16u to divr16u::@1 [phi:divr16u->divr16u::@1]
  __b1_from_divr16u:
    // [147] phi (byte) divr16u::i#2 = (byte) 0 [phi:divr16u->divr16u::@1#0] -- vbuz1=vbuc1 
    lda #0
    sta.z i
    // [147] 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
    // [147] phi (word) divr16u::dividend#4 = (word) divr16u::dividend#6 [phi:divr16u->divr16u::@1#2] -- register_copy 
    // [147] phi (word) divr16u::rem#6 = (word) divr16u::rem#11 [phi:divr16u->divr16u::@1#3] -- register_copy 
    jmp __b1
    // [147] phi from divr16u::@3 to divr16u::@1 [phi:divr16u::@3->divr16u::@1]
  __b1_from___b3:
    // [147] phi (byte) divr16u::i#2 = (byte) divr16u::i#1 [phi:divr16u::@3->divr16u::@1#0] -- register_copy 
    // [147] phi (word) divr16u::quotient#3 = (word) divr16u::return#0 [phi:divr16u::@3->divr16u::@1#1] -- register_copy 
    // [147] phi (word) divr16u::dividend#4 = (word) divr16u::dividend#0 [phi:divr16u::@3->divr16u::@1#2] -- register_copy 
    // [147] phi (word) divr16u::rem#6 = (word) divr16u::rem#10 [phi:divr16u::@3->divr16u::@1#3] -- register_copy 
    jmp __b1
    // divr16u::@1
  __b1:
    // [148] (word) divr16u::rem#0 ← (word) divr16u::rem#6 << (byte) 1 -- vwuz1=vwuz1_rol_1 
    asl.z rem
    rol.z rem+1
    // [149] (byte~) divr16u::$1 ← > (word) divr16u::dividend#4 -- vbuz1=_hi_vwuz2 
    lda.z dividend+1
    sta.z __1
    // [150] (byte~) divr16u::$2 ← (byte~) divr16u::$1 & (byte) $80 -- vbuz1=vbuz2_band_vbuc1 
    lda #$80
    and.z __1
    sta.z __2
    // [151] 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:
    // [152] (word) divr16u::rem#1 ← (word) divr16u::rem#0 | (byte) 1 -- vwuz1=vwuz1_bor_vbuc1 
    lda #1
    ora.z rem
    sta.z rem
    // [153] phi from divr16u::@1 divr16u::@4 to divr16u::@2 [phi:divr16u::@1/divr16u::@4->divr16u::@2]
  __b2_from___b1:
  __b2_from___b4:
    // [153] phi (word) divr16u::rem#7 = (word) divr16u::rem#0 [phi:divr16u::@1/divr16u::@4->divr16u::@2#0] -- register_copy 
    jmp __b2
    // divr16u::@2
  __b2:
    // [154] (word) divr16u::dividend#0 ← (word) divr16u::dividend#4 << (byte) 1 -- vwuz1=vwuz1_rol_1 
    asl.z dividend
    rol.z dividend+1
    // [155] (word) divr16u::quotient#1 ← (word) divr16u::quotient#3 << (byte) 1 -- vwuz1=vwuz1_rol_1 
    asl.z quotient
    rol.z quotient+1
    // [156] if((word) divr16u::rem#7<(const word) main::wavelength) goto divr16u::@3 -- vwuz1_lt_vwuc1_then_la1 
    lda.z rem+1
    cmp #>main.wavelength
    bcc __b3_from___b2
    bne !+
    lda.z rem
    cmp #<main.wavelength
    bcc __b3_from___b2
  !:
    jmp __b5
    // divr16u::@5
  __b5:
    // [157] (word) divr16u::quotient#2 ← ++ (word) divr16u::quotient#1 -- vwuz1=_inc_vwuz1 
    inc.z quotient
    bne !+
    inc.z quotient+1
  !:
    // [158] (word) divr16u::rem#2 ← (word) divr16u::rem#7 - (const word) main::wavelength -- vwuz1=vwuz1_minus_vwuc1 
    lda.z rem
    sec
    sbc #<main.wavelength
    sta.z rem
    lda.z rem+1
    sbc #>main.wavelength
    sta.z rem+1
    // [159] phi from divr16u::@2 divr16u::@5 to divr16u::@3 [phi:divr16u::@2/divr16u::@5->divr16u::@3]
  __b3_from___b2:
  __b3_from___b5:
    // [159] phi (word) divr16u::return#0 = (word) divr16u::quotient#1 [phi:divr16u::@2/divr16u::@5->divr16u::@3#0] -- register_copy 
    // [159] phi (word) divr16u::rem#10 = (word) divr16u::rem#7 [phi:divr16u::@2/divr16u::@5->divr16u::@3#1] -- register_copy 
    jmp __b3
    // divr16u::@3
  __b3:
    // [160] (byte) divr16u::i#1 ← ++ (byte) divr16u::i#2 -- vbuz1=_inc_vbuz1 
    inc.z i
    // [161] 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:
    // [162] (word) rem16u#1 ← (word) divr16u::rem#10 -- vwuz1=vwuz2 
    lda.z rem
    sta.z rem16u
    lda.z rem+1
    sta.z rem16u+1
    jmp __breturn
    // divr16u::@return
  __breturn:
    // [163] return 
    rts
}
  // sin8s_gen
// Generate signed byte sinus table - on the full -$7f - $7f range
// sintab - the table to generate into
// wavelength - the number of sinus points in a total sinus wavelength (the size of the table)
// sin8s_gen(signed byte* zp($34) sintab)
sin8s_gen: {
    .label __2 = $a3
    .label step = $a0
    .label sintab = $34
    // u[4.12]
    // Iterate over the table
    .label x = $32
    .label i = $30
    // [165] call div16u 
    // [241] phi from sin8s_gen to div16u [phi:sin8s_gen->div16u]
  div16u_from_sin8s_gen:
    jsr div16u
    // [166] (word) div16u::return#2 ← (word) div16u::return#0 -- vwuz1=vwuz2 
    lda.z div16u.return
    sta.z div16u.return_1
    lda.z div16u.return+1
    sta.z div16u.return_1+1
    jmp __b3
    // sin8s_gen::@3
  __b3:
    // [167] (word) sin8s_gen::step#0 ← (word) div16u::return#2 -- vwuz1=vwuz2 
    lda.z div16u.return_1
    sta.z step
    lda.z div16u.return_1+1
    sta.z step+1
    // [168] phi from sin8s_gen::@3 to sin8s_gen::@1 [phi:sin8s_gen::@3->sin8s_gen::@1]
  __b1_from___b3:
    // [168] phi (signed byte*) sin8s_gen::sintab#2 = (const signed byte*) main::sintabb [phi:sin8s_gen::@3->sin8s_gen::@1#0] -- pbsz1=pbsc1 
    lda #<main.sintabb
    sta.z sintab
    lda #>main.sintabb
    sta.z sintab+1
    // [168] phi (word) sin8s_gen::x#2 = (word) 0 [phi:sin8s_gen::@3->sin8s_gen::@1#1] -- vwuz1=vwuc1 
    lda #<0
    sta.z x
    lda #>0
    sta.z x+1
    // [168] phi (word) sin8s_gen::i#2 = (word) 0 [phi:sin8s_gen::@3->sin8s_gen::@1#2] -- vwuz1=vwuc1 
    lda #<0
    sta.z i
    lda #>0
    sta.z i+1
    jmp __b1
  // u[4.12]
    // sin8s_gen::@1
  __b1:
    // [169] if((word) sin8s_gen::i#2<(const word) main::wavelength) goto sin8s_gen::@2 -- vwuz1_lt_vwuc1_then_la1 
    lda.z i+1
    cmp #>main.wavelength
    bcc __b2
    bne !+
    lda.z i
    cmp #<main.wavelength
    bcc __b2
  !:
    jmp __breturn
    // sin8s_gen::@return
  __breturn:
    // [170] return 
    rts
    // sin8s_gen::@2
  __b2:
    // [171] (word) sin8s::x#0 ← (word) sin8s_gen::x#2 -- vwuz1=vwuz2 
    lda.z x
    sta.z sin8s.x
    lda.z x+1
    sta.z sin8s.x+1
    // [172] call sin8s 
    jsr sin8s
    // [173] (signed byte) sin8s::return#0 ← (signed byte) sin8s::return#1 -- vbsz1=vbsz2 
    lda.z sin8s.return_1
    sta.z sin8s.return
    jmp __b4
    // sin8s_gen::@4
  __b4:
    // [174] (signed byte~) sin8s_gen::$2 ← (signed byte) sin8s::return#0 -- vbsz1=vbsz2 
    lda.z sin8s.return
    sta.z __2
    // [175] *((signed byte*) sin8s_gen::sintab#2) ← (signed byte~) sin8s_gen::$2 -- _deref_pbsz1=vbsz2 
    lda.z __2
    ldy #0
    sta (sintab),y
    // [176] (signed byte*) sin8s_gen::sintab#0 ← ++ (signed byte*) sin8s_gen::sintab#2 -- pbsz1=_inc_pbsz1 
    inc.z sintab
    bne !+
    inc.z sintab+1
  !:
    // [177] (word) sin8s_gen::x#1 ← (word) sin8s_gen::x#2 + (word) sin8s_gen::step#0 -- vwuz1=vwuz1_plus_vwuz2 
    lda.z x
    clc
    adc.z step
    sta.z x
    lda.z x+1
    adc.z step+1
    sta.z x+1
    // [178] (word) sin8s_gen::i#1 ← ++ (word) sin8s_gen::i#2 -- vwuz1=_inc_vwuz1 
    inc.z i
    bne !+
    inc.z i+1
  !:
    // [168] phi from sin8s_gen::@4 to sin8s_gen::@1 [phi:sin8s_gen::@4->sin8s_gen::@1]
  __b1_from___b4:
    // [168] phi (signed byte*) sin8s_gen::sintab#2 = (signed byte*) sin8s_gen::sintab#0 [phi:sin8s_gen::@4->sin8s_gen::@1#0] -- register_copy 
    // [168] phi (word) sin8s_gen::x#2 = (word) sin8s_gen::x#1 [phi:sin8s_gen::@4->sin8s_gen::@1#1] -- register_copy 
    // [168] phi (word) sin8s_gen::i#2 = (word) sin8s_gen::i#1 [phi:sin8s_gen::@4->sin8s_gen::@1#2] -- register_copy 
    jmp __b1
}
  // sin8s
// Calculate signed byte sinus sin(x)
// x: unsigned word input u[4.12] in the interval $0000 - PI2_u4f12
// result: signed byte sin(x) s[0.7] - using the full range  -$7f - $7f
// sin8s(word zp($37) x)
sin8s: {
    // u[2.6] x^3
    .const DIV_6 = $2b
    .label __4 = $a4
    .label x = $37
    .label return = $a2
    .label x1 = $a6
    .label x2 = $a8
    .label x3 = $aa
    .label x3_6 = $ac
    .label usinx = $ad
    .label x4 = $af
    .label x5 = $b1
    .label x5_128 = $b2
    .label usinx_1 = $39
    .label return_1 = $3a
    .label sinx = $3a
    // Move x1 into the range 0-PI/2 using sinus mirror symmetries
    .label isUpper = $36
    // [179] if((word) sin8s::x#0<(const word) PI_u4f12) goto sin8s::@1 -- vwuz1_lt_vwuc1_then_la1 
    lda.z x+1
    cmp #>PI_u4f12
    bcc __b1_from_sin8s
    bne !+
    lda.z x
    cmp #<PI_u4f12
    bcc __b1_from_sin8s
  !:
    jmp __b5
    // sin8s::@5
  __b5:
    // [180] (word) sin8s::x#1 ← (word) sin8s::x#0 - (const word) PI_u4f12 -- vwuz1=vwuz1_minus_vwuc1 
    lda.z x
    sec
    sbc #<PI_u4f12
    sta.z x
    lda.z x+1
    sbc #>PI_u4f12
    sta.z x+1
    // [181] phi from sin8s::@5 to sin8s::@1 [phi:sin8s::@5->sin8s::@1]
  __b1_from___b5:
    // [181] phi (byte) sin8s::isUpper#10 = (byte) 1 [phi:sin8s::@5->sin8s::@1#0] -- vbuz1=vbuc1 
    lda #1
    sta.z isUpper
    // [181] phi (word) sin8s::x#4 = (word) sin8s::x#1 [phi:sin8s::@5->sin8s::@1#1] -- register_copy 
    jmp __b1
    // [181] phi from sin8s to sin8s::@1 [phi:sin8s->sin8s::@1]
  __b1_from_sin8s:
    // [181] phi (byte) sin8s::isUpper#10 = (byte) 0 [phi:sin8s->sin8s::@1#0] -- vbuz1=vbuc1 
    lda #0
    sta.z isUpper
    // [181] phi (word) sin8s::x#4 = (word) sin8s::x#0 [phi:sin8s->sin8s::@1#1] -- register_copy 
    jmp __b1
    // sin8s::@1
  __b1:
    // [182] if((word) sin8s::x#4<(const word) PI_HALF_u4f12) goto sin8s::@2 -- vwuz1_lt_vwuc1_then_la1 
    lda.z x+1
    cmp #>PI_HALF_u4f12
    bcc __b2_from___b1
    bne !+
    lda.z x
    cmp #<PI_HALF_u4f12
    bcc __b2_from___b1
  !:
    jmp __b6
    // sin8s::@6
  __b6:
    // [183] (word) sin8s::x#2 ← (const word) PI_u4f12 - (word) sin8s::x#4 -- vwuz1=vwuc1_minus_vwuz1 
    sec
    lda #<PI_u4f12
    sbc.z x
    sta.z x
    lda #>PI_u4f12
    sbc.z x+1
    sta.z x+1
    // [184] phi from sin8s::@1 sin8s::@6 to sin8s::@2 [phi:sin8s::@1/sin8s::@6->sin8s::@2]
  __b2_from___b1:
  __b2_from___b6:
    // [184] phi (word) sin8s::x#6 = (word) sin8s::x#4 [phi:sin8s::@1/sin8s::@6->sin8s::@2#0] -- register_copy 
    jmp __b2
    // sin8s::@2
  __b2:
    // [185] (word~) sin8s::$4 ← (word) sin8s::x#6 << (byte) 3 -- vwuz1=vwuz2_rol_3 
    lda.z x
    asl
    sta.z __4
    lda.z x+1
    rol
    sta.z __4+1
    asl.z __4
    rol.z __4+1
    asl.z __4
    rol.z __4+1
    // [186] (byte) sin8s::x1#0 ← > (word~) sin8s::$4 -- vbuz1=_hi_vwuz2 
    lda.z __4+1
    sta.z x1
    // [187] (byte) mulu8_sel::v1#0 ← (byte) sin8s::x1#0 -- vbuz1=vbuz2 
    lda.z x1
    sta.z mulu8_sel.v1
    // [188] (byte) mulu8_sel::v2#0 ← (byte) sin8s::x1#0 -- vbuz1=vbuz2 
    lda.z x1
    sta.z mulu8_sel.v2
    // [189] call mulu8_sel 
    // [222] phi from sin8s::@2 to mulu8_sel [phi:sin8s::@2->mulu8_sel]
  mulu8_sel_from___b2:
    // [222] phi (byte) mulu8_sel::select#5 = (byte) 0 [phi:sin8s::@2->mulu8_sel#0] -- vbuz1=vbuc1 
    lda #0
    sta.z mulu8_sel.select
    // [222] phi (byte) mulu8_sel::v2#5 = (byte) mulu8_sel::v2#0 [phi:sin8s::@2->mulu8_sel#1] -- register_copy 
    // [222] phi (byte) mulu8_sel::v1#5 = (byte) mulu8_sel::v1#0 [phi:sin8s::@2->mulu8_sel#2] -- register_copy 
    jsr mulu8_sel
    // [190] (byte) mulu8_sel::return#0 ← (byte) mulu8_sel::return#12 -- vbuz1=vbuz2 
    lda.z mulu8_sel.return_5
    sta.z mulu8_sel.return
    jmp __b9
    // sin8s::@9
  __b9:
    // [191] (byte) sin8s::x2#0 ← (byte) mulu8_sel::return#0 -- vbuz1=vbuz2 
    lda.z mulu8_sel.return
    sta.z x2
    // [192] (byte) mulu8_sel::v1#1 ← (byte) sin8s::x2#0 -- vbuz1=vbuz2 
    lda.z x2
    sta.z mulu8_sel.v1
    // [193] (byte) mulu8_sel::v2#1 ← (byte) sin8s::x1#0 -- vbuz1=vbuz2 
    lda.z x1
    sta.z mulu8_sel.v2
    // [194] call mulu8_sel 
    // [222] phi from sin8s::@9 to mulu8_sel [phi:sin8s::@9->mulu8_sel]
  mulu8_sel_from___b9:
    // [222] phi (byte) mulu8_sel::select#5 = (byte) 1 [phi:sin8s::@9->mulu8_sel#0] -- vbuz1=vbuc1 
    lda #1
    sta.z mulu8_sel.select
    // [222] phi (byte) mulu8_sel::v2#5 = (byte) mulu8_sel::v2#1 [phi:sin8s::@9->mulu8_sel#1] -- register_copy 
    // [222] phi (byte) mulu8_sel::v1#5 = (byte) mulu8_sel::v1#1 [phi:sin8s::@9->mulu8_sel#2] -- register_copy 
    jsr mulu8_sel
    // [195] (byte) mulu8_sel::return#1 ← (byte) mulu8_sel::return#12 -- vbuz1=vbuz2 
    lda.z mulu8_sel.return_5
    sta.z mulu8_sel.return_1
    jmp __b10
    // sin8s::@10
  __b10:
    // [196] (byte) sin8s::x3#0 ← (byte) mulu8_sel::return#1 -- vbuz1=vbuz2 
    lda.z mulu8_sel.return_1
    sta.z x3
    // [197] (byte) mulu8_sel::v1#2 ← (byte) sin8s::x3#0 -- vbuz1=vbuz2 
    lda.z x3
    sta.z mulu8_sel.v1
    // [198] call mulu8_sel 
    // [222] phi from sin8s::@10 to mulu8_sel [phi:sin8s::@10->mulu8_sel]
  mulu8_sel_from___b10:
    // [222] phi (byte) mulu8_sel::select#5 = (byte) 1 [phi:sin8s::@10->mulu8_sel#0] -- vbuz1=vbuc1 
    lda #1
    sta.z mulu8_sel.select
    // [222] phi (byte) mulu8_sel::v2#5 = (const byte) sin8s::DIV_6 [phi:sin8s::@10->mulu8_sel#1] -- vbuz1=vbuc1 
    lda #DIV_6
    sta.z mulu8_sel.v2
    // [222] phi (byte) mulu8_sel::v1#5 = (byte) mulu8_sel::v1#2 [phi:sin8s::@10->mulu8_sel#2] -- register_copy 
    jsr mulu8_sel
    // [199] (byte) mulu8_sel::return#2 ← (byte) mulu8_sel::return#12 -- vbuz1=vbuz2 
    lda.z mulu8_sel.return_5
    sta.z mulu8_sel.return_2
    jmp __b11
    // sin8s::@11
  __b11:
    // [200] (byte) sin8s::x3_6#0 ← (byte) mulu8_sel::return#2 -- vbuz1=vbuz2 
    lda.z mulu8_sel.return_2
    sta.z x3_6
    // [201] (byte) sin8s::usinx#0 ← (byte) sin8s::x1#0 - (byte) sin8s::x3_6#0 -- vbuz1=vbuz2_minus_vbuz3 
    lda.z x1
    sec
    sbc.z x3_6
    sta.z usinx
    // [202] (byte) mulu8_sel::v1#3 ← (byte) sin8s::x3#0 -- vbuz1=vbuz2 
    lda.z x3
    sta.z mulu8_sel.v1
    // [203] (byte) mulu8_sel::v2#3 ← (byte) sin8s::x1#0 -- vbuz1=vbuz2 
    lda.z x1
    sta.z mulu8_sel.v2
    // [204] call mulu8_sel 
    // [222] phi from sin8s::@11 to mulu8_sel [phi:sin8s::@11->mulu8_sel]
  mulu8_sel_from___b11:
    // [222] phi (byte) mulu8_sel::select#5 = (byte) 0 [phi:sin8s::@11->mulu8_sel#0] -- vbuz1=vbuc1 
    lda #0
    sta.z mulu8_sel.select
    // [222] phi (byte) mulu8_sel::v2#5 = (byte) mulu8_sel::v2#3 [phi:sin8s::@11->mulu8_sel#1] -- register_copy 
    // [222] phi (byte) mulu8_sel::v1#5 = (byte) mulu8_sel::v1#3 [phi:sin8s::@11->mulu8_sel#2] -- register_copy 
    jsr mulu8_sel
    // [205] (byte) mulu8_sel::return#10 ← (byte) mulu8_sel::return#12 -- vbuz1=vbuz2 
    lda.z mulu8_sel.return_5
    sta.z mulu8_sel.return_3
    jmp __b12
    // sin8s::@12
  __b12:
    // [206] (byte) sin8s::x4#0 ← (byte) mulu8_sel::return#10 -- vbuz1=vbuz2 
    lda.z mulu8_sel.return_3
    sta.z x4
    // [207] (byte) mulu8_sel::v1#4 ← (byte) sin8s::x4#0 -- vbuz1=vbuz2 
    lda.z x4
    sta.z mulu8_sel.v1
    // [208] (byte) mulu8_sel::v2#4 ← (byte) sin8s::x1#0 -- vbuz1=vbuz2 
    lda.z x1
    sta.z mulu8_sel.v2
    // [209] call mulu8_sel 
    // [222] phi from sin8s::@12 to mulu8_sel [phi:sin8s::@12->mulu8_sel]
  mulu8_sel_from___b12:
    // [222] phi (byte) mulu8_sel::select#5 = (byte) 0 [phi:sin8s::@12->mulu8_sel#0] -- vbuz1=vbuc1 
    lda #0
    sta.z mulu8_sel.select
    // [222] phi (byte) mulu8_sel::v2#5 = (byte) mulu8_sel::v2#4 [phi:sin8s::@12->mulu8_sel#1] -- register_copy 
    // [222] phi (byte) mulu8_sel::v1#5 = (byte) mulu8_sel::v1#4 [phi:sin8s::@12->mulu8_sel#2] -- register_copy 
    jsr mulu8_sel
    // [210] (byte) mulu8_sel::return#11 ← (byte) mulu8_sel::return#12 -- vbuz1=vbuz2 
    lda.z mulu8_sel.return_5
    sta.z mulu8_sel.return_4
    jmp __b13
    // sin8s::@13
  __b13:
    // [211] (byte) sin8s::x5#0 ← (byte) mulu8_sel::return#11 -- vbuz1=vbuz2 
    lda.z mulu8_sel.return_4
    sta.z x5
    // [212] (byte) sin8s::x5_128#0 ← (byte) sin8s::x5#0 >> (byte) 4 -- vbuz1=vbuz2_ror_4 
    lda.z x5
    lsr
    lsr
    lsr
    lsr
    sta.z x5_128
    // [213] (byte) sin8s::usinx#1 ← (byte) sin8s::usinx#0 + (byte) sin8s::x5_128#0 -- vbuz1=vbuz2_plus_vbuz3 
    lda.z usinx
    clc
    adc.z x5_128
    sta.z usinx_1
    // [214] if((byte) sin8s::usinx#1<(byte) $80) goto sin8s::@3 -- vbuz1_lt_vbuc1_then_la1 
    lda.z usinx_1
    cmp #$80
    bcc __b3_from___b13
    jmp __b7
    // sin8s::@7
  __b7:
    // [215] (byte) sin8s::usinx#2 ← -- (byte) sin8s::usinx#1 -- vbuz1=_dec_vbuz1 
    dec.z usinx_1
    // [216] phi from sin8s::@13 sin8s::@7 to sin8s::@3 [phi:sin8s::@13/sin8s::@7->sin8s::@3]
  __b3_from___b13:
  __b3_from___b7:
    // [216] phi (byte) sin8s::usinx#4 = (byte) sin8s::usinx#1 [phi:sin8s::@13/sin8s::@7->sin8s::@3#0] -- register_copy 
    jmp __b3
    // sin8s::@3
  __b3:
    // [217] if((byte) sin8s::isUpper#10==(byte) 0) goto sin8s::@14 -- vbuz1_eq_0_then_la1 
    lda.z isUpper
    cmp #0
    beq __b14
    jmp __b8
    // sin8s::@8
  __b8:
    // [218] (signed byte) sin8s::sinx#1 ← - (signed byte)(byte) sin8s::usinx#4 -- vbsz1=_neg_vbsz2 
    lda.z usinx_1
    eor #$ff
    clc
    adc #1
    sta.z sinx
    // [219] phi from sin8s::@14 sin8s::@8 to sin8s::@4 [phi:sin8s::@14/sin8s::@8->sin8s::@4]
  __b4_from___b14:
  __b4_from___b8:
    // [219] phi (signed byte) sin8s::return#1 = (signed byte) sin8s::return#5 [phi:sin8s::@14/sin8s::@8->sin8s::@4#0] -- register_copy 
    jmp __b4
    // sin8s::@4
  __b4:
    jmp __breturn
    // sin8s::@return
  __breturn:
    // [220] return 
    rts
    // sin8s::@14
  __b14:
    // [221] (signed byte) sin8s::return#5 ← (signed byte)(byte) sin8s::usinx#4 -- vbsz1=vbsz2 
    lda.z usinx_1
    sta.z return_1
    jmp __b4_from___b14
}
  // mulu8_sel
// Calculate val*val for two unsigned byte values - the result is 8 selected bits of the 16-bit result.
// The select parameter indicates how many of the highest bits of the 16-bit result to skip
// mulu8_sel(byte zp($3b) v1, byte zp($3c) v2, byte zp($3d) select)
mulu8_sel: {
    .label __0 = $b6
    .label __1 = $b8
    .label v1 = $3b
    .label v2 = $3c
    .label return = $a7
    .label return_1 = $a9
    .label return_2 = $ab
    .label return_3 = $ae
    .label return_4 = $b0
    .label select = $3d
    .label return_5 = $ba
    // [223] (byte) mul8u::a#1 ← (byte) mulu8_sel::v1#5 -- vbuz1=vbuz2 
    lda.z v1
    sta.z mul8u.a
    // [224] (byte) mul8u::b#0 ← (byte) mulu8_sel::v2#5 -- vbuz1=vbuz2 
    lda.z v2
    sta.z mul8u.b
    // [225] call mul8u 
    jsr mul8u
    // [226] (word) mul8u::return#2 ← (word) mul8u::res#2 -- vwuz1=vwuz2 
    lda.z mul8u.res
    sta.z mul8u.return
    lda.z mul8u.res+1
    sta.z mul8u.return+1
    jmp __b1
    // mulu8_sel::@1
  __b1:
    // [227] (word~) mulu8_sel::$0 ← (word) mul8u::return#2 -- vwuz1=vwuz2 
    lda.z mul8u.return
    sta.z __0
    lda.z mul8u.return+1
    sta.z __0+1
    // [228] (word~) mulu8_sel::$1 ← (word~) mulu8_sel::$0 << (byte) mulu8_sel::select#5 -- vwuz1=vwuz2_rol_vbuz3 
    lda.z __0
    sta.z __1
    lda.z __0+1
    sta.z __1+1
    ldy.z select
    beq !e+
  !:
    asl.z __1
    rol.z __1+1
    dey
    bne !-
  !e:
    // [229] (byte) mulu8_sel::return#12 ← > (word~) mulu8_sel::$1 -- vbuz1=_hi_vwuz2 
    lda.z __1+1
    sta.z return_5
    jmp __breturn
    // mulu8_sel::@return
  __breturn:
    // [230] return 
    rts
}
  // mul8u
// Perform binary multiplication of two unsigned 8-bit bytes into a 16-bit unsigned word
// mul8u(byte zp($3e) a, byte zp($b3) b)
mul8u: {
    .label __1 = $bb
    .label mb = $41
    .label a = $3e
    .label res = $3f
    .label b = $b3
    .label return = $b4
    // [231] (word) mul8u::mb#0 ← (word)(byte) mul8u::b#0 -- vwuz1=_word_vbuz2 
    lda.z b
    sta.z mb
    lda #0
    sta.z mb+1
    // [232] phi from mul8u to mul8u::@1 [phi:mul8u->mul8u::@1]
  __b1_from_mul8u:
    // [232] phi (word) mul8u::mb#2 = (word) mul8u::mb#0 [phi:mul8u->mul8u::@1#0] -- register_copy 
    // [232] phi (word) mul8u::res#2 = (word) 0 [phi:mul8u->mul8u::@1#1] -- vwuz1=vwuc1 
    lda #<0
    sta.z res
    lda #>0
    sta.z res+1
    // [232] phi (byte) mul8u::a#2 = (byte) mul8u::a#1 [phi:mul8u->mul8u::@1#2] -- register_copy 
    jmp __b1
    // mul8u::@1
  __b1:
    // [233] if((byte) mul8u::a#2!=(byte) 0) goto mul8u::@2 -- vbuz1_neq_0_then_la1 
    lda.z a
    cmp #0
    bne __b2
    jmp __breturn
    // mul8u::@return
  __breturn:
    // [234] return 
    rts
    // mul8u::@2
  __b2:
    // [235] (byte~) mul8u::$1 ← (byte) mul8u::a#2 & (byte) 1 -- vbuz1=vbuz2_band_vbuc1 
    lda #1
    and.z a
    sta.z __1
    // [236] if((byte~) mul8u::$1==(byte) 0) goto mul8u::@3 -- vbuz1_eq_0_then_la1 
    lda.z __1
    cmp #0
    beq __b3_from___b2
    jmp __b4
    // mul8u::@4
  __b4:
    // [237] (word) mul8u::res#1 ← (word) mul8u::res#2 + (word) mul8u::mb#2 -- vwuz1=vwuz1_plus_vwuz2 
    lda.z res
    clc
    adc.z mb
    sta.z res
    lda.z res+1
    adc.z mb+1
    sta.z res+1
    // [238] phi from mul8u::@2 mul8u::@4 to mul8u::@3 [phi:mul8u::@2/mul8u::@4->mul8u::@3]
  __b3_from___b2:
  __b3_from___b4:
    // [238] phi (word) mul8u::res#6 = (word) mul8u::res#2 [phi:mul8u::@2/mul8u::@4->mul8u::@3#0] -- register_copy 
    jmp __b3
    // mul8u::@3
  __b3:
    // [239] (byte) mul8u::a#0 ← (byte) mul8u::a#2 >> (byte) 1 -- vbuz1=vbuz1_ror_1 
    lsr.z a
    // [240] (word) mul8u::mb#1 ← (word) mul8u::mb#2 << (byte) 1 -- vwuz1=vwuz1_rol_1 
    asl.z mb
    rol.z mb+1
    // [232] phi from mul8u::@3 to mul8u::@1 [phi:mul8u::@3->mul8u::@1]
  __b1_from___b3:
    // [232] phi (word) mul8u::mb#2 = (word) mul8u::mb#1 [phi:mul8u::@3->mul8u::@1#0] -- register_copy 
    // [232] phi (word) mul8u::res#2 = (word) mul8u::res#6 [phi:mul8u::@3->mul8u::@1#1] -- register_copy 
    // [232] phi (byte) mul8u::a#2 = (byte) mul8u::a#0 [phi:mul8u::@3->mul8u::@1#2] -- register_copy 
    jmp __b1
}
  // div16u
// Performs division on two 16 bit unsigned words
// Returns the quotient dividend/divisor.
// The remainder will be set into the global variable rem16u
// Implemented using simple binary division
div16u: {
    .label return = $be
    .label return_1 = $9e
    // [242] call divr16u 
    // [146] phi from div16u to divr16u [phi:div16u->divr16u]
  divr16u_from_div16u:
    // [146] phi (word) divr16u::dividend#6 = (const word) PI2_u4f12 [phi:div16u->divr16u#0] -- vwuz1=vwuc1 
    lda #<PI2_u4f12
    sta.z divr16u.dividend
    lda #>PI2_u4f12
    sta.z divr16u.dividend+1
    // [146] phi (word) divr16u::rem#11 = (byte) 0 [phi:div16u->divr16u#1] -- vwuz1=vbuc1 
    lda #<0
    sta.z divr16u.rem
    lda #>0
    sta.z divr16u.rem+1
    jsr divr16u
    // [243] (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 __b1
    // div16u::@1
  __b1:
    // [244] (word) div16u::return#0 ← (word) divr16u::return#2 -- vwuz1=vwuz2 
    lda.z divr16u.return_1
    sta.z return
    lda.z divr16u.return_1+1
    sta.z return+1
    jmp __breturn
    // div16u::@return
  __breturn:
    // [245] return 
    rts
}
  // File Data
  print_hextab: .text "0123456789abcdef"

REGISTER UPLIFT POTENTIAL REGISTERS
Statement [12] (word~) main::$3 ← (word)(byte) main::i#2 [ main::i#2 print_char_cursor#42 main::sb#0 main::$3 ] ( main:2 [ main::i#2 print_char_cursor#42 main::sb#0 main::$3 ] ) always clobbers reg byte a 
Removing always clobbered register reg byte a as potential for zp[1]:2 [ main::i#2 main::i#1 ]
Removing always clobbered register reg byte a as potential for zp[1]:67 [ main::sb#0 ]
Statement [13] (word~) main::$11 ← (word~) main::$3 << (byte) 1 [ main::i#2 print_char_cursor#42 main::sb#0 main::$11 ] ( main:2 [ main::i#2 print_char_cursor#42 main::sb#0 main::$11 ] ) always clobbers reg byte a 
Statement [14] (signed word*~) main::$4 ← (const signed word*) main::sintabw + (word~) main::$11 [ main::i#2 print_char_cursor#42 main::sb#0 main::$4 ] ( main:2 [ main::i#2 print_char_cursor#42 main::sb#0 main::$4 ] ) always clobbers reg byte a 
Statement [15] (signed word) main::sw#0 ← *((signed word*~) main::$4) [ main::i#2 print_char_cursor#42 main::sb#0 main::sw#0 ] ( main:2 [ main::i#2 print_char_cursor#42 main::sb#0 main::sw#0 ] ) always clobbers reg byte a reg byte y 
Removing always clobbered register reg byte y as potential for zp[1]:2 [ main::i#2 main::i#1 ]
Removing always clobbered register reg byte y as potential for zp[1]:67 [ main::sb#0 ]
Statement [16] (byte~) main::$6 ← > (signed word) main::sw#0 [ main::i#2 print_char_cursor#42 main::sb#0 main::$6 ] ( main:2 [ main::i#2 print_char_cursor#42 main::sb#0 main::$6 ] ) always clobbers reg byte a 
Statement [17] (signed byte) main::sd#0 ← (signed byte) main::sb#0 - (signed byte)(byte~) main::$6 [ main::i#2 print_char_cursor#42 main::sd#0 ] ( main:2 [ main::i#2 print_char_cursor#42 main::sd#0 ] ) always clobbers reg byte a 
Statement [27] if((byte) 0!=*((byte*) print_str::str#2)) goto print_str::@2 [ print_char_cursor#19 print_str::str#2 ] ( main:2::print_str:21 [ main::i#2 print_char_cursor#19 print_str::str#2 ] ) always clobbers reg byte a reg byte y 
Statement [29] *((byte*) print_char_cursor#19) ← *((byte*) print_str::str#2) [ print_char_cursor#19 print_str::str#2 ] ( main:2::print_str:21 [ main::i#2 print_char_cursor#19 print_str::str#2 ] ) always clobbers reg byte a reg byte y 
Statement [41] (signed byte) print_sbyte::b#0 ← - (signed byte) print_sbyte::b#1 [ print_char_cursor#10 print_sbyte::b#0 ] ( main:2::print_sbyte:19 [ main::i#2 print_char_cursor#10 print_sbyte::b#0 ] ) always clobbers reg byte a 
Statement [43] *((byte*) print_char_cursor#28) ← (byte) print_char::ch#4 [ print_char_cursor#28 ] ( main:2::print_sbyte:19::print_char:34 [ main::i#2 print_sbyte::b#1 print_char_cursor#28 ] main:2::print_sbyte:19::print_char:40 [ main::i#2 print_sbyte::b#1 print_char_cursor#28 ] main:2::print_sbyte:19::print_byte:37::print_char:48 [ main::i#2 print_byte::b#0 print_char_cursor#28 ] main:2::print_sbyte:19::print_byte:37::print_char:51 [ main::i#2 print_char_cursor#28 ] ) always clobbers reg byte y 
Removing always clobbered register reg byte y as potential for zp[1]:5 [ print_sbyte::b#4 print_sbyte::b#0 print_sbyte::b#1 ]
Removing always clobbered register reg byte y as potential for zp[1]:78 [ print_byte::b#0 ]
Statement [46] (byte~) print_byte::$0 ← (byte) print_byte::b#0 >> (byte) 4 [ print_char_cursor#10 print_byte::b#0 print_byte::$0 ] ( main:2::print_sbyte:19::print_byte:37 [ main::i#2 print_char_cursor#10 print_byte::b#0 print_byte::$0 ] ) always clobbers reg byte a 
Removing always clobbered register reg byte a as potential for zp[1]:78 [ print_byte::b#0 ]
Statement [49] (byte~) print_byte::$2 ← (byte) print_byte::b#0 & (byte) $f [ print_char_cursor#10 print_byte::$2 ] ( main:2::print_sbyte:19::print_byte:37 [ main::i#2 print_char_cursor#10 print_byte::$2 ] ) always clobbers reg byte a 
Statement [58] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 [ memset::dst#2 ] ( main:2::print_cls:9::memset:54 [ memset::dst#2 ] ) always clobbers reg byte a 
Statement [60] *((byte*) memset::dst#2) ← (const byte) memset::c#0 [ memset::dst#2 ] ( main:2::print_cls:9::memset:54 [ memset::dst#2 ] ) always clobbers reg byte a reg byte y 
Statement [64] (dword) div32u16u::return#2 ← (dword) div32u16u::return#0 [ div32u16u::return#2 ] ( main:2::sin16s_gen:7 [ div32u16u::return#2 ] ) always clobbers reg byte a 
Statement [65] (dword) sin16s_gen::step#0 ← (dword) div32u16u::return#2 [ sin16s_gen::step#0 ] ( main:2::sin16s_gen:7 [ sin16s_gen::step#0 ] ) always clobbers reg byte a 
Statement [67] if((word) sin16s_gen::i#2<(const word) main::wavelength) goto sin16s_gen::@2 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 ] ( main:2::sin16s_gen:7 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 ] ) always clobbers reg byte a 
Statement [69] (dword) sin16s::x#0 ← (dword) sin16s_gen::x#2 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::x#0 ] ( main:2::sin16s_gen:7 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::x#0 ] ) always clobbers reg byte a 
Statement [71] (signed word) sin16s::return#0 ← (signed word) sin16s::return#1 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::return#0 ] ( main:2::sin16s_gen:7 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::return#0 ] ) always clobbers reg byte a 
Statement [72] (signed word~) sin16s_gen::$2 ← (signed word) sin16s::return#0 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::$2 ] ( main:2::sin16s_gen:7 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::$2 ] ) always clobbers reg byte a 
Statement [73] *((signed word*) sin16s_gen::sintab#2) ← (signed word~) sin16s_gen::$2 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 ] ( main:2::sin16s_gen:7 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 ] ) always clobbers reg byte a reg byte y 
Statement [74] (signed word*) sin16s_gen::sintab#0 ← (signed word*) sin16s_gen::sintab#2 + (const byte) SIZEOF_SIGNED_WORD [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#0 ] ( main:2::sin16s_gen:7 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#0 ] ) always clobbers reg byte a 
Statement [75] (dword) sin16s_gen::x#1 ← (dword) sin16s_gen::x#2 + (dword) sin16s_gen::step#0 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#1 sin16s_gen::sintab#0 ] ( main:2::sin16s_gen:7 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#1 sin16s_gen::sintab#0 ] ) always clobbers reg byte a 
Statement [77] if((dword) sin16s::x#0<(const dword) PI_u4f28) goto sin16s::@1 [ sin16s::x#0 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::x#0 ] ) always clobbers reg byte a 
Statement [78] (dword) sin16s::x#1 ← (dword) sin16s::x#0 - (const dword) PI_u4f28 [ sin16s::x#1 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::x#1 ] ) always clobbers reg byte a 
Statement [80] if((dword) sin16s::x#4<(const dword) PI_HALF_u4f28) goto sin16s::@2 [ sin16s::x#4 sin16s::isUpper#2 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::x#4 sin16s::isUpper#2 ] ) always clobbers reg byte a 
Removing always clobbered register reg byte a as potential for zp[1]:19 [ sin16s::isUpper#2 ]
Statement [81] (dword) sin16s::x#2 ← (const dword) PI_u4f28 - (dword) sin16s::x#4 [ sin16s::isUpper#2 sin16s::x#2 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x#2 ] ) always clobbers reg byte a 
Statement [83] (dword~) sin16s::$4 ← (dword) sin16s::x#6 << (byte) 3 [ sin16s::isUpper#2 sin16s::$4 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::$4 ] ) always clobbers reg byte a 
Statement [84] (word) sin16s::x1#0 ← > (dword~) sin16s::$4 [ sin16s::isUpper#2 sin16s::x1#0 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 ] ) always clobbers reg byte a 
Statement [85] (word) mulu16_sel::v1#0 ← (word) sin16s::x1#0 [ sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::v1#0 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::v1#0 ] ) always clobbers reg byte a 
Statement [86] (word) mulu16_sel::v2#0 ← (word) sin16s::x1#0 [ sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::v1#0 mulu16_sel::v2#0 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::v1#0 mulu16_sel::v2#0 ] ) always clobbers reg byte a 
Statement [88] (word) mulu16_sel::return#0 ← (word) mulu16_sel::return#12 [ sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::return#0 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::return#0 ] ) always clobbers reg byte a 
Statement [89] (word) sin16s::x2#0 ← (word) mulu16_sel::return#0 [ sin16s::isUpper#2 sin16s::x1#0 sin16s::x2#0 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::x2#0 ] ) always clobbers reg byte a 
Statement [90] (word) mulu16_sel::v1#1 ← (word) sin16s::x2#0 [ sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::v1#1 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::v1#1 ] ) always clobbers reg byte a 
Statement [91] (word) mulu16_sel::v2#1 ← (word) sin16s::x1#0 [ sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::v1#1 mulu16_sel::v2#1 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::v1#1 mulu16_sel::v2#1 ] ) always clobbers reg byte a 
Statement [93] (word) mulu16_sel::return#1 ← (word) mulu16_sel::return#12 [ sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::return#1 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::return#1 ] ) always clobbers reg byte a 
Statement [94] (word) sin16s::x3#0 ← (word) mulu16_sel::return#1 [ sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 ] ) always clobbers reg byte a 
Statement [95] (word) mulu16_sel::v1#2 ← (word) sin16s::x3#0 [ sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 mulu16_sel::v1#2 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 mulu16_sel::v1#2 ] ) always clobbers reg byte a 
Statement [97] (word) mulu16_sel::return#2 ← (word) mulu16_sel::return#12 [ sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 mulu16_sel::return#2 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 mulu16_sel::return#2 ] ) always clobbers reg byte a 
Statement [98] (word) sin16s::x3_6#0 ← (word) mulu16_sel::return#2 [ sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 sin16s::x3_6#0 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 sin16s::x3_6#0 ] ) always clobbers reg byte a 
Statement [99] (word) sin16s::usinx#0 ← (word) sin16s::x1#0 - (word) sin16s::x3_6#0 [ sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 sin16s::usinx#0 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 sin16s::usinx#0 ] ) always clobbers reg byte a 
Statement [100] (word) mulu16_sel::v1#3 ← (word) sin16s::x3#0 [ sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::v1#3 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::v1#3 ] ) always clobbers reg byte a 
Statement [101] (word) mulu16_sel::v2#3 ← (word) sin16s::x1#0 [ sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::v1#3 mulu16_sel::v2#3 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::v1#3 mulu16_sel::v2#3 ] ) always clobbers reg byte a 
Statement [103] (word) mulu16_sel::return#10 ← (word) mulu16_sel::return#12 [ sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::return#10 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::return#10 ] ) always clobbers reg byte a 
Statement [104] (word) sin16s::x4#0 ← (word) mulu16_sel::return#10 [ sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 sin16s::x4#0 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 sin16s::x4#0 ] ) always clobbers reg byte a 
Statement [105] (word) mulu16_sel::v1#4 ← (word) sin16s::x4#0 [ sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::v1#4 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::v1#4 ] ) always clobbers reg byte a 
Statement [106] (word) mulu16_sel::v2#4 ← (word) sin16s::x1#0 [ sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::v1#4 mulu16_sel::v2#4 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::v1#4 mulu16_sel::v2#4 ] ) always clobbers reg byte a 
Statement [108] (word) mulu16_sel::return#11 ← (word) mulu16_sel::return#12 [ sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::return#11 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::return#11 ] ) always clobbers reg byte a 
Statement [109] (word) sin16s::x5#0 ← (word) mulu16_sel::return#11 [ sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5#0 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5#0 ] ) always clobbers reg byte a 
Statement [110] (word) sin16s::x5_128#0 ← (word) sin16s::x5#0 >> (byte) 4 [ sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5_128#0 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5_128#0 ] ) always clobbers reg byte a 
Statement [111] (word) sin16s::usinx#1 ← (word) sin16s::usinx#0 + (word) sin16s::x5_128#0 [ sin16s::isUpper#2 sin16s::usinx#1 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::usinx#1 ] ) always clobbers reg byte a 
Statement [113] (signed word) sin16s::sinx#1 ← - (signed word)(word) sin16s::usinx#1 [ sin16s::sinx#1 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::sinx#1 ] ) always clobbers reg byte a 
Statement [116] (signed word) sin16s::return#5 ← (signed word)(word) sin16s::usinx#1 [ sin16s::return#5 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::return#5 ] ) always clobbers reg byte a 
Statement [118] (word) mul16u::a#1 ← (word) mulu16_sel::v1#5 [ mulu16_sel::v2#5 mulu16_sel::select#5 mul16u::a#1 ] ( main:2::sin16s_gen:7::sin16s:70::mulu16_sel:87 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::v2#5 mulu16_sel::select#5 mul16u::a#1 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:92 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::v2#5 mulu16_sel::select#5 mul16u::a#1 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:96 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 mulu16_sel::v2#5 mulu16_sel::select#5 mul16u::a#1 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:102 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::v2#5 mulu16_sel::select#5 mul16u::a#1 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:107 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::v2#5 mulu16_sel::select#5 mul16u::a#1 ] ) always clobbers reg byte a 
Removing always clobbered register reg byte a as potential for zp[1]:30 [ mulu16_sel::select#5 ]
Statement [119] (word) mul16u::b#0 ← (word) mulu16_sel::v2#5 [ mulu16_sel::select#5 mul16u::a#1 mul16u::b#0 ] ( main:2::sin16s_gen:7::sin16s:70::mulu16_sel:87 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::select#5 mul16u::a#1 mul16u::b#0 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:92 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::select#5 mul16u::a#1 mul16u::b#0 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:96 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 mulu16_sel::select#5 mul16u::a#1 mul16u::b#0 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:102 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::select#5 mul16u::a#1 mul16u::b#0 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:107 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::select#5 mul16u::a#1 mul16u::b#0 ] ) always clobbers reg byte a 
Statement [121] (dword) mul16u::return#2 ← (dword) mul16u::res#2 [ mulu16_sel::select#5 mul16u::return#2 ] ( main:2::sin16s_gen:7::sin16s:70::mulu16_sel:87 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::select#5 mul16u::return#2 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:92 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::select#5 mul16u::return#2 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:96 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 mulu16_sel::select#5 mul16u::return#2 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:102 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::select#5 mul16u::return#2 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:107 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::select#5 mul16u::return#2 ] ) always clobbers reg byte a 
Statement [122] (dword~) mulu16_sel::$0 ← (dword) mul16u::return#2 [ mulu16_sel::select#5 mulu16_sel::$0 ] ( main:2::sin16s_gen:7::sin16s:70::mulu16_sel:87 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::select#5 mulu16_sel::$0 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:92 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::select#5 mulu16_sel::$0 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:96 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 mulu16_sel::select#5 mulu16_sel::$0 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:102 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::select#5 mulu16_sel::$0 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:107 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::select#5 mulu16_sel::$0 ] ) always clobbers reg byte a 
Statement [123] (dword~) mulu16_sel::$1 ← (dword~) mulu16_sel::$0 << (byte) mulu16_sel::select#5 [ mulu16_sel::$1 ] ( main:2::sin16s_gen:7::sin16s:70::mulu16_sel:87 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::$1 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:92 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::$1 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:96 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 mulu16_sel::$1 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:102 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::$1 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:107 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::$1 ] ) always clobbers reg byte a 
Statement [124] (word) mulu16_sel::return#12 ← > (dword~) mulu16_sel::$1 [ mulu16_sel::return#12 ] ( main:2::sin16s_gen:7::sin16s:70::mulu16_sel:87 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::return#12 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:92 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::return#12 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:96 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 mulu16_sel::return#12 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:102 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::return#12 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:107 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::return#12 ] ) always clobbers reg byte a 
Statement [126] (dword) mul16u::mb#0 ← (dword)(word) mul16u::b#0 [ mul16u::a#1 mul16u::mb#0 ] ( main:2::sin16s_gen:7::sin16s:70::mulu16_sel:87::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::select#5 mul16u::a#1 mul16u::mb#0 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:92::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::select#5 mul16u::a#1 mul16u::mb#0 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:96::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 mulu16_sel::select#5 mul16u::a#1 mul16u::mb#0 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:102::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::select#5 mul16u::a#1 mul16u::mb#0 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:107::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::select#5 mul16u::a#1 mul16u::mb#0 ] ) always clobbers reg byte a 
Statement [128] if((word) mul16u::a#2!=(byte) 0) goto mul16u::@2 [ mul16u::res#2 mul16u::a#2 mul16u::mb#2 ] ( main:2::sin16s_gen:7::sin16s:70::mulu16_sel:87::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::select#5 mul16u::res#2 mul16u::a#2 mul16u::mb#2 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:92::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::select#5 mul16u::res#2 mul16u::a#2 mul16u::mb#2 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:96::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 mulu16_sel::select#5 mul16u::res#2 mul16u::a#2 mul16u::mb#2 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:102::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::select#5 mul16u::res#2 mul16u::a#2 mul16u::mb#2 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:107::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::select#5 mul16u::res#2 mul16u::a#2 mul16u::mb#2 ] ) always clobbers reg byte a 
Statement [130] (byte~) mul16u::$1 ← (word) mul16u::a#2 & (byte) 1 [ mul16u::res#2 mul16u::a#2 mul16u::mb#2 mul16u::$1 ] ( main:2::sin16s_gen:7::sin16s:70::mulu16_sel:87::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::select#5 mul16u::res#2 mul16u::a#2 mul16u::mb#2 mul16u::$1 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:92::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::select#5 mul16u::res#2 mul16u::a#2 mul16u::mb#2 mul16u::$1 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:96::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 mulu16_sel::select#5 mul16u::res#2 mul16u::a#2 mul16u::mb#2 mul16u::$1 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:102::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::select#5 mul16u::res#2 mul16u::a#2 mul16u::mb#2 mul16u::$1 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:107::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::select#5 mul16u::res#2 mul16u::a#2 mul16u::mb#2 mul16u::$1 ] ) always clobbers reg byte a 
Statement [132] (dword) mul16u::res#1 ← (dword) mul16u::res#2 + (dword) mul16u::mb#2 [ mul16u::a#2 mul16u::mb#2 mul16u::res#1 ] ( main:2::sin16s_gen:7::sin16s:70::mulu16_sel:87::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::select#5 mul16u::a#2 mul16u::mb#2 mul16u::res#1 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:92::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::select#5 mul16u::a#2 mul16u::mb#2 mul16u::res#1 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:96::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 mulu16_sel::select#5 mul16u::a#2 mul16u::mb#2 mul16u::res#1 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:102::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::select#5 mul16u::a#2 mul16u::mb#2 mul16u::res#1 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:107::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::select#5 mul16u::a#2 mul16u::mb#2 mul16u::res#1 ] ) always clobbers reg byte a 
Statement [138] (word) divr16u::return#3 ← (word) divr16u::return#0 [ divr16u::return#3 rem16u#1 ] ( main:2::sin16s_gen:7::div32u16u:63 [ divr16u::return#3 rem16u#1 ] ) always clobbers reg byte a 
Statement [139] (word) div32u16u::quotient_hi#0 ← (word) divr16u::return#3 [ div32u16u::quotient_hi#0 rem16u#1 ] ( main:2::sin16s_gen:7::div32u16u:63 [ div32u16u::quotient_hi#0 rem16u#1 ] ) always clobbers reg byte a 
Statement [140] (word) divr16u::rem#5 ← (word) rem16u#1 [ div32u16u::quotient_hi#0 divr16u::rem#5 ] ( main:2::sin16s_gen:7::div32u16u:63 [ div32u16u::quotient_hi#0 divr16u::rem#5 ] ) always clobbers reg byte a 
Statement [142] (word) divr16u::return#4 ← (word) divr16u::return#0 [ div32u16u::quotient_hi#0 divr16u::return#4 ] ( main:2::sin16s_gen:7::div32u16u:63 [ div32u16u::quotient_hi#0 divr16u::return#4 ] ) always clobbers reg byte a 
Statement [143] (word) div32u16u::quotient_lo#0 ← (word) divr16u::return#4 [ div32u16u::quotient_hi#0 div32u16u::quotient_lo#0 ] ( main:2::sin16s_gen:7::div32u16u:63 [ div32u16u::quotient_hi#0 div32u16u::quotient_lo#0 ] ) always clobbers reg byte a 
Statement [144] (dword) div32u16u::return#0 ← (word) div32u16u::quotient_hi#0 dw= (word) div32u16u::quotient_lo#0 [ div32u16u::return#0 ] ( main:2::sin16s_gen:7::div32u16u:63 [ div32u16u::return#0 ] ) always clobbers reg byte a 
Statement [149] (byte~) divr16u::$1 ← > (word) divr16u::dividend#4 [ divr16u::dividend#4 divr16u::quotient#3 divr16u::i#2 divr16u::rem#0 divr16u::$1 ] ( main:2::sin16s_gen:7::div32u16u:63::divr16u:137 [ divr16u::dividend#4 divr16u::quotient#3 divr16u::i#2 divr16u::rem#0 divr16u::$1 ] main:2::sin16s_gen:7::div32u16u:63::divr16u:141 [ div32u16u::quotient_hi#0 divr16u::dividend#4 divr16u::quotient#3 divr16u::i#2 divr16u::rem#0 divr16u::$1 ] main:2::sin8s_gen:5::div16u:165::divr16u:242 [ divr16u::dividend#4 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]:47 [ divr16u::i#2 divr16u::i#1 ]
Statement [152] (word) divr16u::rem#1 ← (word) divr16u::rem#0 | (byte) 1 [ divr16u::dividend#4 divr16u::quotient#3 divr16u::i#2 divr16u::rem#1 ] ( main:2::sin16s_gen:7::div32u16u:63::divr16u:137 [ divr16u::dividend#4 divr16u::quotient#3 divr16u::i#2 divr16u::rem#1 ] main:2::sin16s_gen:7::div32u16u:63::divr16u:141 [ div32u16u::quotient_hi#0 divr16u::dividend#4 divr16u::quotient#3 divr16u::i#2 divr16u::rem#1 ] main:2::sin8s_gen:5::div16u:165::divr16u:242 [ divr16u::dividend#4 divr16u::quotient#3 divr16u::i#2 divr16u::rem#1 ] ) always clobbers reg byte a 
Statement [156] if((word) divr16u::rem#7<(const word) main::wavelength) goto divr16u::@3 [ divr16u::i#2 divr16u::dividend#0 divr16u::rem#7 divr16u::quotient#1 ] ( main:2::sin16s_gen:7::div32u16u:63::divr16u:137 [ divr16u::i#2 divr16u::dividend#0 divr16u::rem#7 divr16u::quotient#1 ] main:2::sin16s_gen:7::div32u16u:63::divr16u:141 [ div32u16u::quotient_hi#0 divr16u::i#2 divr16u::dividend#0 divr16u::rem#7 divr16u::quotient#1 ] main:2::sin8s_gen:5::div16u:165::divr16u:242 [ divr16u::i#2 divr16u::dividend#0 divr16u::rem#7 divr16u::quotient#1 ] ) always clobbers reg byte a 
Statement [158] (word) divr16u::rem#2 ← (word) divr16u::rem#7 - (const word) main::wavelength [ divr16u::i#2 divr16u::dividend#0 divr16u::quotient#2 divr16u::rem#2 ] ( main:2::sin16s_gen:7::div32u16u:63::divr16u:137 [ divr16u::i#2 divr16u::dividend#0 divr16u::quotient#2 divr16u::rem#2 ] main:2::sin16s_gen:7::div32u16u:63::divr16u:141 [ div32u16u::quotient_hi#0 divr16u::i#2 divr16u::dividend#0 divr16u::quotient#2 divr16u::rem#2 ] main:2::sin8s_gen:5::div16u:165::divr16u:242 [ divr16u::i#2 divr16u::dividend#0 divr16u::quotient#2 divr16u::rem#2 ] ) always clobbers reg byte a 
Statement [162] (word) rem16u#1 ← (word) divr16u::rem#10 [ divr16u::return#0 rem16u#1 ] ( main:2::sin16s_gen:7::div32u16u:63::divr16u:137 [ divr16u::return#0 rem16u#1 ] main:2::sin16s_gen:7::div32u16u:63::divr16u:141 [ div32u16u::quotient_hi#0 divr16u::return#0 rem16u#1 ] main:2::sin8s_gen:5::div16u:165::divr16u:242 [ divr16u::return#0 rem16u#1 ] ) always clobbers reg byte a 
Statement [166] (word) div16u::return#2 ← (word) div16u::return#0 [ div16u::return#2 ] ( main:2::sin8s_gen:5 [ div16u::return#2 ] ) always clobbers reg byte a 
Statement [167] (word) sin8s_gen::step#0 ← (word) div16u::return#2 [ sin8s_gen::step#0 ] ( main:2::sin8s_gen:5 [ sin8s_gen::step#0 ] ) always clobbers reg byte a 
Statement [169] if((word) sin8s_gen::i#2<(const word) main::wavelength) goto sin8s_gen::@2 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 ] ( main:2::sin8s_gen:5 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 ] ) always clobbers reg byte a 
Statement [171] (word) sin8s::x#0 ← (word) sin8s_gen::x#2 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::x#0 ] ( main:2::sin8s_gen:5 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::x#0 ] ) always clobbers reg byte a 
Statement [175] *((signed byte*) sin8s_gen::sintab#2) ← (signed byte~) sin8s_gen::$2 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 ] ( main:2::sin8s_gen:5 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 ] ) always clobbers reg byte y 
Statement [177] (word) sin8s_gen::x#1 ← (word) sin8s_gen::x#2 + (word) sin8s_gen::step#0 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#1 sin8s_gen::sintab#0 ] ( main:2::sin8s_gen:5 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#1 sin8s_gen::sintab#0 ] ) always clobbers reg byte a 
Statement [179] if((word) sin8s::x#0<(const word) PI_u4f12) goto sin8s::@1 [ sin8s::x#0 ] ( main:2::sin8s_gen:5::sin8s:172 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::x#0 ] ) always clobbers reg byte a 
Statement [180] (word) sin8s::x#1 ← (word) sin8s::x#0 - (const word) PI_u4f12 [ sin8s::x#1 ] ( main:2::sin8s_gen:5::sin8s:172 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::x#1 ] ) always clobbers reg byte a 
Statement [182] if((word) sin8s::x#4<(const word) PI_HALF_u4f12) goto sin8s::@2 [ sin8s::x#4 sin8s::isUpper#10 ] ( main:2::sin8s_gen:5::sin8s:172 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::x#4 sin8s::isUpper#10 ] ) always clobbers reg byte a 
Removing always clobbered register reg byte a as potential for zp[1]:54 [ sin8s::isUpper#10 ]
Statement [183] (word) sin8s::x#2 ← (const word) PI_u4f12 - (word) sin8s::x#4 [ sin8s::isUpper#10 sin8s::x#2 ] ( main:2::sin8s_gen:5::sin8s:172 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x#2 ] ) always clobbers reg byte a 
Statement [185] (word~) sin8s::$4 ← (word) sin8s::x#6 << (byte) 3 [ sin8s::isUpper#10 sin8s::$4 ] ( main:2::sin8s_gen:5::sin8s:172 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::$4 ] ) always clobbers reg byte a 
Statement [186] (byte) sin8s::x1#0 ← > (word~) sin8s::$4 [ sin8s::isUpper#10 sin8s::x1#0 ] ( main:2::sin8s_gen:5::sin8s:172 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 ] ) always clobbers reg byte a 
Statement [201] (byte) sin8s::usinx#0 ← (byte) sin8s::x1#0 - (byte) sin8s::x3_6#0 [ sin8s::isUpper#10 sin8s::x1#0 sin8s::x3#0 sin8s::usinx#0 ] ( main:2::sin8s_gen:5::sin8s:172 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 sin8s::x3#0 sin8s::usinx#0 ] ) always clobbers reg byte a 
Removing always clobbered register reg byte a as potential for zp[1]:166 [ sin8s::x1#0 ]
Removing always clobbered register reg byte a as potential for zp[1]:170 [ sin8s::x3#0 ]
Statement [212] (byte) sin8s::x5_128#0 ← (byte) sin8s::x5#0 >> (byte) 4 [ sin8s::isUpper#10 sin8s::usinx#0 sin8s::x5_128#0 ] ( main:2::sin8s_gen:5::sin8s:172 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::usinx#0 sin8s::x5_128#0 ] ) always clobbers reg byte a 
Removing always clobbered register reg byte a as potential for zp[1]:173 [ sin8s::usinx#0 ]
Statement [213] (byte) sin8s::usinx#1 ← (byte) sin8s::usinx#0 + (byte) sin8s::x5_128#0 [ sin8s::isUpper#10 sin8s::usinx#1 ] ( main:2::sin8s_gen:5::sin8s:172 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::usinx#1 ] ) always clobbers reg byte a 
Statement [218] (signed byte) sin8s::sinx#1 ← - (signed byte)(byte) sin8s::usinx#4 [ sin8s::sinx#1 ] ( main:2::sin8s_gen:5::sin8s:172 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::sinx#1 ] ) always clobbers reg byte a 
Statement [226] (word) mul8u::return#2 ← (word) mul8u::res#2 [ mulu8_sel::select#5 mul8u::return#2 ] ( main:2::sin8s_gen:5::sin8s:172::mulu8_sel:189 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 mulu8_sel::select#5 mul8u::return#2 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:194 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 mulu8_sel::select#5 mul8u::return#2 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:198 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 sin8s::x3#0 mulu8_sel::select#5 mul8u::return#2 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:204 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 sin8s::usinx#0 mulu8_sel::select#5 mul8u::return#2 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:209 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::usinx#0 mulu8_sel::select#5 mul8u::return#2 ] ) always clobbers reg byte a 
Removing always clobbered register reg byte a as potential for zp[1]:61 [ mulu8_sel::select#5 ]
Statement [227] (word~) mulu8_sel::$0 ← (word) mul8u::return#2 [ mulu8_sel::select#5 mulu8_sel::$0 ] ( main:2::sin8s_gen:5::sin8s:172::mulu8_sel:189 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 mulu8_sel::select#5 mulu8_sel::$0 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:194 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 mulu8_sel::select#5 mulu8_sel::$0 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:198 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 sin8s::x3#0 mulu8_sel::select#5 mulu8_sel::$0 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:204 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 sin8s::usinx#0 mulu8_sel::select#5 mulu8_sel::$0 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:209 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::usinx#0 mulu8_sel::select#5 mulu8_sel::$0 ] ) always clobbers reg byte a 
Statement [228] (word~) mulu8_sel::$1 ← (word~) mulu8_sel::$0 << (byte) mulu8_sel::select#5 [ mulu8_sel::$1 ] ( main:2::sin8s_gen:5::sin8s:172::mulu8_sel:189 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 mulu8_sel::$1 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:194 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 mulu8_sel::$1 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:198 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 sin8s::x3#0 mulu8_sel::$1 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:204 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 sin8s::usinx#0 mulu8_sel::$1 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:209 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::usinx#0 mulu8_sel::$1 ] ) always clobbers reg byte a 
Statement [229] (byte) mulu8_sel::return#12 ← > (word~) mulu8_sel::$1 [ mulu8_sel::return#12 ] ( main:2::sin8s_gen:5::sin8s:172::mulu8_sel:189 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 mulu8_sel::return#12 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:194 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 mulu8_sel::return#12 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:198 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 sin8s::x3#0 mulu8_sel::return#12 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:204 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 sin8s::usinx#0 mulu8_sel::return#12 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:209 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::usinx#0 mulu8_sel::return#12 ] ) always clobbers reg byte a 
Statement [231] (word) mul8u::mb#0 ← (word)(byte) mul8u::b#0 [ mul8u::a#1 mul8u::mb#0 ] ( main:2::sin8s_gen:5::sin8s:172::mulu8_sel:189::mul8u:225 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 mulu8_sel::select#5 mul8u::a#1 mul8u::mb#0 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:194::mul8u:225 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 mulu8_sel::select#5 mul8u::a#1 mul8u::mb#0 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:198::mul8u:225 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 sin8s::x3#0 mulu8_sel::select#5 mul8u::a#1 mul8u::mb#0 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:204::mul8u:225 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 sin8s::usinx#0 mulu8_sel::select#5 mul8u::a#1 mul8u::mb#0 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:209::mul8u:225 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::usinx#0 mulu8_sel::select#5 mul8u::a#1 mul8u::mb#0 ] ) always clobbers reg byte a 
Removing always clobbered register reg byte a as potential for zp[1]:62 [ mul8u::a#2 mul8u::a#1 mul8u::a#0 ]
Statement [235] (byte~) mul8u::$1 ← (byte) mul8u::a#2 & (byte) 1 [ mul8u::res#2 mul8u::a#2 mul8u::mb#2 mul8u::$1 ] ( main:2::sin8s_gen:5::sin8s:172::mulu8_sel:189::mul8u:225 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 mulu8_sel::select#5 mul8u::res#2 mul8u::a#2 mul8u::mb#2 mul8u::$1 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:194::mul8u:225 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 mulu8_sel::select#5 mul8u::res#2 mul8u::a#2 mul8u::mb#2 mul8u::$1 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:198::mul8u:225 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 sin8s::x3#0 mulu8_sel::select#5 mul8u::res#2 mul8u::a#2 mul8u::mb#2 mul8u::$1 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:204::mul8u:225 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 sin8s::usinx#0 mulu8_sel::select#5 mul8u::res#2 mul8u::a#2 mul8u::mb#2 mul8u::$1 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:209::mul8u:225 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::usinx#0 mulu8_sel::select#5 mul8u::res#2 mul8u::a#2 mul8u::mb#2 mul8u::$1 ] ) always clobbers reg byte a 
Statement [237] (word) mul8u::res#1 ← (word) mul8u::res#2 + (word) mul8u::mb#2 [ mul8u::a#2 mul8u::mb#2 mul8u::res#1 ] ( main:2::sin8s_gen:5::sin8s:172::mulu8_sel:189::mul8u:225 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 mulu8_sel::select#5 mul8u::a#2 mul8u::mb#2 mul8u::res#1 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:194::mul8u:225 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 mulu8_sel::select#5 mul8u::a#2 mul8u::mb#2 mul8u::res#1 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:198::mul8u:225 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 sin8s::x3#0 mulu8_sel::select#5 mul8u::a#2 mul8u::mb#2 mul8u::res#1 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:204::mul8u:225 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 sin8s::usinx#0 mulu8_sel::select#5 mul8u::a#2 mul8u::mb#2 mul8u::res#1 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:209::mul8u:225 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::usinx#0 mulu8_sel::select#5 mul8u::a#2 mul8u::mb#2 mul8u::res#1 ] ) always clobbers reg byte a 
Statement [243] (word) divr16u::return#2 ← (word) divr16u::return#0 [ divr16u::return#2 ] ( main:2::sin8s_gen:5::div16u:165 [ divr16u::return#2 ] ) always clobbers reg byte a 
Statement [244] (word) div16u::return#0 ← (word) divr16u::return#2 [ div16u::return#0 ] ( main:2::sin8s_gen:5::div16u:165 [ div16u::return#0 ] ) always clobbers reg byte a 
Statement [12] (word~) main::$3 ← (word)(byte) main::i#2 [ main::i#2 print_char_cursor#42 main::sb#0 main::$3 ] ( main:2 [ main::i#2 print_char_cursor#42 main::sb#0 main::$3 ] ) always clobbers reg byte a 
Statement [13] (word~) main::$11 ← (word~) main::$3 << (byte) 1 [ main::i#2 print_char_cursor#42 main::sb#0 main::$11 ] ( main:2 [ main::i#2 print_char_cursor#42 main::sb#0 main::$11 ] ) always clobbers reg byte a 
Statement [14] (signed word*~) main::$4 ← (const signed word*) main::sintabw + (word~) main::$11 [ main::i#2 print_char_cursor#42 main::sb#0 main::$4 ] ( main:2 [ main::i#2 print_char_cursor#42 main::sb#0 main::$4 ] ) always clobbers reg byte a 
Statement [15] (signed word) main::sw#0 ← *((signed word*~) main::$4) [ main::i#2 print_char_cursor#42 main::sb#0 main::sw#0 ] ( main:2 [ main::i#2 print_char_cursor#42 main::sb#0 main::sw#0 ] ) always clobbers reg byte a reg byte y 
Statement [16] (byte~) main::$6 ← > (signed word) main::sw#0 [ main::i#2 print_char_cursor#42 main::sb#0 main::$6 ] ( main:2 [ main::i#2 print_char_cursor#42 main::sb#0 main::$6 ] ) always clobbers reg byte a 
Statement [17] (signed byte) main::sd#0 ← (signed byte) main::sb#0 - (signed byte)(byte~) main::$6 [ main::i#2 print_char_cursor#42 main::sd#0 ] ( main:2 [ main::i#2 print_char_cursor#42 main::sd#0 ] ) always clobbers reg byte a 
Statement [27] if((byte) 0!=*((byte*) print_str::str#2)) goto print_str::@2 [ print_char_cursor#19 print_str::str#2 ] ( main:2::print_str:21 [ main::i#2 print_char_cursor#19 print_str::str#2 ] ) always clobbers reg byte a reg byte y 
Statement [29] *((byte*) print_char_cursor#19) ← *((byte*) print_str::str#2) [ print_char_cursor#19 print_str::str#2 ] ( main:2::print_str:21 [ main::i#2 print_char_cursor#19 print_str::str#2 ] ) always clobbers reg byte a reg byte y 
Statement [41] (signed byte) print_sbyte::b#0 ← - (signed byte) print_sbyte::b#1 [ print_char_cursor#10 print_sbyte::b#0 ] ( main:2::print_sbyte:19 [ main::i#2 print_char_cursor#10 print_sbyte::b#0 ] ) always clobbers reg byte a 
Statement [43] *((byte*) print_char_cursor#28) ← (byte) print_char::ch#4 [ print_char_cursor#28 ] ( main:2::print_sbyte:19::print_char:34 [ main::i#2 print_sbyte::b#1 print_char_cursor#28 ] main:2::print_sbyte:19::print_char:40 [ main::i#2 print_sbyte::b#1 print_char_cursor#28 ] main:2::print_sbyte:19::print_byte:37::print_char:48 [ main::i#2 print_byte::b#0 print_char_cursor#28 ] main:2::print_sbyte:19::print_byte:37::print_char:51 [ main::i#2 print_char_cursor#28 ] ) always clobbers reg byte y 
Statement [46] (byte~) print_byte::$0 ← (byte) print_byte::b#0 >> (byte) 4 [ print_char_cursor#10 print_byte::b#0 print_byte::$0 ] ( main:2::print_sbyte:19::print_byte:37 [ main::i#2 print_char_cursor#10 print_byte::b#0 print_byte::$0 ] ) always clobbers reg byte a 
Statement [49] (byte~) print_byte::$2 ← (byte) print_byte::b#0 & (byte) $f [ print_char_cursor#10 print_byte::$2 ] ( main:2::print_sbyte:19::print_byte:37 [ main::i#2 print_char_cursor#10 print_byte::$2 ] ) always clobbers reg byte a 
Statement [58] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 [ memset::dst#2 ] ( main:2::print_cls:9::memset:54 [ memset::dst#2 ] ) always clobbers reg byte a 
Statement [60] *((byte*) memset::dst#2) ← (const byte) memset::c#0 [ memset::dst#2 ] ( main:2::print_cls:9::memset:54 [ memset::dst#2 ] ) always clobbers reg byte a reg byte y 
Statement [64] (dword) div32u16u::return#2 ← (dword) div32u16u::return#0 [ div32u16u::return#2 ] ( main:2::sin16s_gen:7 [ div32u16u::return#2 ] ) always clobbers reg byte a 
Statement [65] (dword) sin16s_gen::step#0 ← (dword) div32u16u::return#2 [ sin16s_gen::step#0 ] ( main:2::sin16s_gen:7 [ sin16s_gen::step#0 ] ) always clobbers reg byte a 
Statement [67] if((word) sin16s_gen::i#2<(const word) main::wavelength) goto sin16s_gen::@2 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 ] ( main:2::sin16s_gen:7 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 ] ) always clobbers reg byte a 
Statement [69] (dword) sin16s::x#0 ← (dword) sin16s_gen::x#2 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::x#0 ] ( main:2::sin16s_gen:7 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::x#0 ] ) always clobbers reg byte a 
Statement [71] (signed word) sin16s::return#0 ← (signed word) sin16s::return#1 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::return#0 ] ( main:2::sin16s_gen:7 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::return#0 ] ) always clobbers reg byte a 
Statement [72] (signed word~) sin16s_gen::$2 ← (signed word) sin16s::return#0 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::$2 ] ( main:2::sin16s_gen:7 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::$2 ] ) always clobbers reg byte a 
Statement [73] *((signed word*) sin16s_gen::sintab#2) ← (signed word~) sin16s_gen::$2 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 ] ( main:2::sin16s_gen:7 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 ] ) always clobbers reg byte a reg byte y 
Statement [74] (signed word*) sin16s_gen::sintab#0 ← (signed word*) sin16s_gen::sintab#2 + (const byte) SIZEOF_SIGNED_WORD [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#0 ] ( main:2::sin16s_gen:7 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#0 ] ) always clobbers reg byte a 
Statement [75] (dword) sin16s_gen::x#1 ← (dword) sin16s_gen::x#2 + (dword) sin16s_gen::step#0 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#1 sin16s_gen::sintab#0 ] ( main:2::sin16s_gen:7 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#1 sin16s_gen::sintab#0 ] ) always clobbers reg byte a 
Statement [77] if((dword) sin16s::x#0<(const dword) PI_u4f28) goto sin16s::@1 [ sin16s::x#0 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::x#0 ] ) always clobbers reg byte a 
Statement [78] (dword) sin16s::x#1 ← (dword) sin16s::x#0 - (const dword) PI_u4f28 [ sin16s::x#1 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::x#1 ] ) always clobbers reg byte a 
Statement [80] if((dword) sin16s::x#4<(const dword) PI_HALF_u4f28) goto sin16s::@2 [ sin16s::x#4 sin16s::isUpper#2 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::x#4 sin16s::isUpper#2 ] ) always clobbers reg byte a 
Statement [81] (dword) sin16s::x#2 ← (const dword) PI_u4f28 - (dword) sin16s::x#4 [ sin16s::isUpper#2 sin16s::x#2 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x#2 ] ) always clobbers reg byte a 
Statement [83] (dword~) sin16s::$4 ← (dword) sin16s::x#6 << (byte) 3 [ sin16s::isUpper#2 sin16s::$4 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::$4 ] ) always clobbers reg byte a 
Statement [84] (word) sin16s::x1#0 ← > (dword~) sin16s::$4 [ sin16s::isUpper#2 sin16s::x1#0 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 ] ) always clobbers reg byte a 
Statement [85] (word) mulu16_sel::v1#0 ← (word) sin16s::x1#0 [ sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::v1#0 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::v1#0 ] ) always clobbers reg byte a 
Statement [86] (word) mulu16_sel::v2#0 ← (word) sin16s::x1#0 [ sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::v1#0 mulu16_sel::v2#0 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::v1#0 mulu16_sel::v2#0 ] ) always clobbers reg byte a 
Statement [88] (word) mulu16_sel::return#0 ← (word) mulu16_sel::return#12 [ sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::return#0 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::return#0 ] ) always clobbers reg byte a 
Statement [89] (word) sin16s::x2#0 ← (word) mulu16_sel::return#0 [ sin16s::isUpper#2 sin16s::x1#0 sin16s::x2#0 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::x2#0 ] ) always clobbers reg byte a 
Statement [90] (word) mulu16_sel::v1#1 ← (word) sin16s::x2#0 [ sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::v1#1 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::v1#1 ] ) always clobbers reg byte a 
Statement [91] (word) mulu16_sel::v2#1 ← (word) sin16s::x1#0 [ sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::v1#1 mulu16_sel::v2#1 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::v1#1 mulu16_sel::v2#1 ] ) always clobbers reg byte a 
Statement [93] (word) mulu16_sel::return#1 ← (word) mulu16_sel::return#12 [ sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::return#1 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::return#1 ] ) always clobbers reg byte a 
Statement [94] (word) sin16s::x3#0 ← (word) mulu16_sel::return#1 [ sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 ] ) always clobbers reg byte a 
Statement [95] (word) mulu16_sel::v1#2 ← (word) sin16s::x3#0 [ sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 mulu16_sel::v1#2 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 mulu16_sel::v1#2 ] ) always clobbers reg byte a 
Statement [97] (word) mulu16_sel::return#2 ← (word) mulu16_sel::return#12 [ sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 mulu16_sel::return#2 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 mulu16_sel::return#2 ] ) always clobbers reg byte a 
Statement [98] (word) sin16s::x3_6#0 ← (word) mulu16_sel::return#2 [ sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 sin16s::x3_6#0 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 sin16s::x3_6#0 ] ) always clobbers reg byte a 
Statement [99] (word) sin16s::usinx#0 ← (word) sin16s::x1#0 - (word) sin16s::x3_6#0 [ sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 sin16s::usinx#0 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 sin16s::usinx#0 ] ) always clobbers reg byte a 
Statement [100] (word) mulu16_sel::v1#3 ← (word) sin16s::x3#0 [ sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::v1#3 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::v1#3 ] ) always clobbers reg byte a 
Statement [101] (word) mulu16_sel::v2#3 ← (word) sin16s::x1#0 [ sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::v1#3 mulu16_sel::v2#3 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::v1#3 mulu16_sel::v2#3 ] ) always clobbers reg byte a 
Statement [103] (word) mulu16_sel::return#10 ← (word) mulu16_sel::return#12 [ sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::return#10 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::return#10 ] ) always clobbers reg byte a 
Statement [104] (word) sin16s::x4#0 ← (word) mulu16_sel::return#10 [ sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 sin16s::x4#0 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 sin16s::x4#0 ] ) always clobbers reg byte a 
Statement [105] (word) mulu16_sel::v1#4 ← (word) sin16s::x4#0 [ sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::v1#4 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::v1#4 ] ) always clobbers reg byte a 
Statement [106] (word) mulu16_sel::v2#4 ← (word) sin16s::x1#0 [ sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::v1#4 mulu16_sel::v2#4 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::v1#4 mulu16_sel::v2#4 ] ) always clobbers reg byte a 
Statement [108] (word) mulu16_sel::return#11 ← (word) mulu16_sel::return#12 [ sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::return#11 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::return#11 ] ) always clobbers reg byte a 
Statement [109] (word) sin16s::x5#0 ← (word) mulu16_sel::return#11 [ sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5#0 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5#0 ] ) always clobbers reg byte a 
Statement [110] (word) sin16s::x5_128#0 ← (word) sin16s::x5#0 >> (byte) 4 [ sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5_128#0 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5_128#0 ] ) always clobbers reg byte a 
Statement [111] (word) sin16s::usinx#1 ← (word) sin16s::usinx#0 + (word) sin16s::x5_128#0 [ sin16s::isUpper#2 sin16s::usinx#1 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::usinx#1 ] ) always clobbers reg byte a 
Statement [113] (signed word) sin16s::sinx#1 ← - (signed word)(word) sin16s::usinx#1 [ sin16s::sinx#1 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::sinx#1 ] ) always clobbers reg byte a 
Statement [116] (signed word) sin16s::return#5 ← (signed word)(word) sin16s::usinx#1 [ sin16s::return#5 ] ( main:2::sin16s_gen:7::sin16s:70 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::return#5 ] ) always clobbers reg byte a 
Statement [118] (word) mul16u::a#1 ← (word) mulu16_sel::v1#5 [ mulu16_sel::v2#5 mulu16_sel::select#5 mul16u::a#1 ] ( main:2::sin16s_gen:7::sin16s:70::mulu16_sel:87 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::v2#5 mulu16_sel::select#5 mul16u::a#1 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:92 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::v2#5 mulu16_sel::select#5 mul16u::a#1 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:96 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 mulu16_sel::v2#5 mulu16_sel::select#5 mul16u::a#1 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:102 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::v2#5 mulu16_sel::select#5 mul16u::a#1 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:107 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::v2#5 mulu16_sel::select#5 mul16u::a#1 ] ) always clobbers reg byte a 
Statement [119] (word) mul16u::b#0 ← (word) mulu16_sel::v2#5 [ mulu16_sel::select#5 mul16u::a#1 mul16u::b#0 ] ( main:2::sin16s_gen:7::sin16s:70::mulu16_sel:87 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::select#5 mul16u::a#1 mul16u::b#0 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:92 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::select#5 mul16u::a#1 mul16u::b#0 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:96 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 mulu16_sel::select#5 mul16u::a#1 mul16u::b#0 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:102 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::select#5 mul16u::a#1 mul16u::b#0 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:107 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::select#5 mul16u::a#1 mul16u::b#0 ] ) always clobbers reg byte a 
Statement [121] (dword) mul16u::return#2 ← (dword) mul16u::res#2 [ mulu16_sel::select#5 mul16u::return#2 ] ( main:2::sin16s_gen:7::sin16s:70::mulu16_sel:87 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::select#5 mul16u::return#2 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:92 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::select#5 mul16u::return#2 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:96 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 mulu16_sel::select#5 mul16u::return#2 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:102 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::select#5 mul16u::return#2 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:107 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::select#5 mul16u::return#2 ] ) always clobbers reg byte a 
Statement [122] (dword~) mulu16_sel::$0 ← (dword) mul16u::return#2 [ mulu16_sel::select#5 mulu16_sel::$0 ] ( main:2::sin16s_gen:7::sin16s:70::mulu16_sel:87 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::select#5 mulu16_sel::$0 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:92 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::select#5 mulu16_sel::$0 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:96 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 mulu16_sel::select#5 mulu16_sel::$0 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:102 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::select#5 mulu16_sel::$0 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:107 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::select#5 mulu16_sel::$0 ] ) always clobbers reg byte a 
Statement [123] (dword~) mulu16_sel::$1 ← (dword~) mulu16_sel::$0 << (byte) mulu16_sel::select#5 [ mulu16_sel::$1 ] ( main:2::sin16s_gen:7::sin16s:70::mulu16_sel:87 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::$1 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:92 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::$1 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:96 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 mulu16_sel::$1 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:102 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::$1 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:107 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::$1 ] ) always clobbers reg byte a 
Statement [124] (word) mulu16_sel::return#12 ← > (dword~) mulu16_sel::$1 [ mulu16_sel::return#12 ] ( main:2::sin16s_gen:7::sin16s:70::mulu16_sel:87 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::return#12 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:92 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::return#12 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:96 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 mulu16_sel::return#12 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:102 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::return#12 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:107 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::return#12 ] ) always clobbers reg byte a 
Statement [126] (dword) mul16u::mb#0 ← (dword)(word) mul16u::b#0 [ mul16u::a#1 mul16u::mb#0 ] ( main:2::sin16s_gen:7::sin16s:70::mulu16_sel:87::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::select#5 mul16u::a#1 mul16u::mb#0 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:92::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::select#5 mul16u::a#1 mul16u::mb#0 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:96::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 mulu16_sel::select#5 mul16u::a#1 mul16u::mb#0 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:102::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::select#5 mul16u::a#1 mul16u::mb#0 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:107::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::select#5 mul16u::a#1 mul16u::mb#0 ] ) always clobbers reg byte a 
Statement [128] if((word) mul16u::a#2!=(byte) 0) goto mul16u::@2 [ mul16u::res#2 mul16u::a#2 mul16u::mb#2 ] ( main:2::sin16s_gen:7::sin16s:70::mulu16_sel:87::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::select#5 mul16u::res#2 mul16u::a#2 mul16u::mb#2 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:92::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::select#5 mul16u::res#2 mul16u::a#2 mul16u::mb#2 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:96::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 mulu16_sel::select#5 mul16u::res#2 mul16u::a#2 mul16u::mb#2 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:102::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::select#5 mul16u::res#2 mul16u::a#2 mul16u::mb#2 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:107::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::select#5 mul16u::res#2 mul16u::a#2 mul16u::mb#2 ] ) always clobbers reg byte a 
Statement [130] (byte~) mul16u::$1 ← (word) mul16u::a#2 & (byte) 1 [ mul16u::res#2 mul16u::a#2 mul16u::mb#2 mul16u::$1 ] ( main:2::sin16s_gen:7::sin16s:70::mulu16_sel:87::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::select#5 mul16u::res#2 mul16u::a#2 mul16u::mb#2 mul16u::$1 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:92::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::select#5 mul16u::res#2 mul16u::a#2 mul16u::mb#2 mul16u::$1 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:96::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 mulu16_sel::select#5 mul16u::res#2 mul16u::a#2 mul16u::mb#2 mul16u::$1 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:102::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::select#5 mul16u::res#2 mul16u::a#2 mul16u::mb#2 mul16u::$1 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:107::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::select#5 mul16u::res#2 mul16u::a#2 mul16u::mb#2 mul16u::$1 ] ) always clobbers reg byte a 
Statement [132] (dword) mul16u::res#1 ← (dword) mul16u::res#2 + (dword) mul16u::mb#2 [ mul16u::a#2 mul16u::mb#2 mul16u::res#1 ] ( main:2::sin16s_gen:7::sin16s:70::mulu16_sel:87::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::select#5 mul16u::a#2 mul16u::mb#2 mul16u::res#1 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:92::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 mulu16_sel::select#5 mul16u::a#2 mul16u::mb#2 mul16u::res#1 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:96::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::x3#0 mulu16_sel::select#5 mul16u::a#2 mul16u::mb#2 mul16u::res#1 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:102::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::x1#0 sin16s::usinx#0 mulu16_sel::select#5 mul16u::a#2 mul16u::mb#2 mul16u::res#1 ] main:2::sin16s_gen:7::sin16s:70::mulu16_sel:107::mul16u:120 [ sin16s_gen::step#0 sin16s_gen::i#2 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::select#5 mul16u::a#2 mul16u::mb#2 mul16u::res#1 ] ) always clobbers reg byte a 
Statement [138] (word) divr16u::return#3 ← (word) divr16u::return#0 [ divr16u::return#3 rem16u#1 ] ( main:2::sin16s_gen:7::div32u16u:63 [ divr16u::return#3 rem16u#1 ] ) always clobbers reg byte a 
Statement [139] (word) div32u16u::quotient_hi#0 ← (word) divr16u::return#3 [ div32u16u::quotient_hi#0 rem16u#1 ] ( main:2::sin16s_gen:7::div32u16u:63 [ div32u16u::quotient_hi#0 rem16u#1 ] ) always clobbers reg byte a 
Statement [140] (word) divr16u::rem#5 ← (word) rem16u#1 [ div32u16u::quotient_hi#0 divr16u::rem#5 ] ( main:2::sin16s_gen:7::div32u16u:63 [ div32u16u::quotient_hi#0 divr16u::rem#5 ] ) always clobbers reg byte a 
Statement [142] (word) divr16u::return#4 ← (word) divr16u::return#0 [ div32u16u::quotient_hi#0 divr16u::return#4 ] ( main:2::sin16s_gen:7::div32u16u:63 [ div32u16u::quotient_hi#0 divr16u::return#4 ] ) always clobbers reg byte a 
Statement [143] (word) div32u16u::quotient_lo#0 ← (word) divr16u::return#4 [ div32u16u::quotient_hi#0 div32u16u::quotient_lo#0 ] ( main:2::sin16s_gen:7::div32u16u:63 [ div32u16u::quotient_hi#0 div32u16u::quotient_lo#0 ] ) always clobbers reg byte a 
Statement [144] (dword) div32u16u::return#0 ← (word) div32u16u::quotient_hi#0 dw= (word) div32u16u::quotient_lo#0 [ div32u16u::return#0 ] ( main:2::sin16s_gen:7::div32u16u:63 [ div32u16u::return#0 ] ) always clobbers reg byte a 
Statement [149] (byte~) divr16u::$1 ← > (word) divr16u::dividend#4 [ divr16u::dividend#4 divr16u::quotient#3 divr16u::i#2 divr16u::rem#0 divr16u::$1 ] ( main:2::sin16s_gen:7::div32u16u:63::divr16u:137 [ divr16u::dividend#4 divr16u::quotient#3 divr16u::i#2 divr16u::rem#0 divr16u::$1 ] main:2::sin16s_gen:7::div32u16u:63::divr16u:141 [ div32u16u::quotient_hi#0 divr16u::dividend#4 divr16u::quotient#3 divr16u::i#2 divr16u::rem#0 divr16u::$1 ] main:2::sin8s_gen:5::div16u:165::divr16u:242 [ divr16u::dividend#4 divr16u::quotient#3 divr16u::i#2 divr16u::rem#0 divr16u::$1 ] ) always clobbers reg byte a 
Statement [152] (word) divr16u::rem#1 ← (word) divr16u::rem#0 | (byte) 1 [ divr16u::dividend#4 divr16u::quotient#3 divr16u::i#2 divr16u::rem#1 ] ( main:2::sin16s_gen:7::div32u16u:63::divr16u:137 [ divr16u::dividend#4 divr16u::quotient#3 divr16u::i#2 divr16u::rem#1 ] main:2::sin16s_gen:7::div32u16u:63::divr16u:141 [ div32u16u::quotient_hi#0 divr16u::dividend#4 divr16u::quotient#3 divr16u::i#2 divr16u::rem#1 ] main:2::sin8s_gen:5::div16u:165::divr16u:242 [ divr16u::dividend#4 divr16u::quotient#3 divr16u::i#2 divr16u::rem#1 ] ) always clobbers reg byte a 
Statement [156] if((word) divr16u::rem#7<(const word) main::wavelength) goto divr16u::@3 [ divr16u::i#2 divr16u::dividend#0 divr16u::rem#7 divr16u::quotient#1 ] ( main:2::sin16s_gen:7::div32u16u:63::divr16u:137 [ divr16u::i#2 divr16u::dividend#0 divr16u::rem#7 divr16u::quotient#1 ] main:2::sin16s_gen:7::div32u16u:63::divr16u:141 [ div32u16u::quotient_hi#0 divr16u::i#2 divr16u::dividend#0 divr16u::rem#7 divr16u::quotient#1 ] main:2::sin8s_gen:5::div16u:165::divr16u:242 [ divr16u::i#2 divr16u::dividend#0 divr16u::rem#7 divr16u::quotient#1 ] ) always clobbers reg byte a 
Statement [158] (word) divr16u::rem#2 ← (word) divr16u::rem#7 - (const word) main::wavelength [ divr16u::i#2 divr16u::dividend#0 divr16u::quotient#2 divr16u::rem#2 ] ( main:2::sin16s_gen:7::div32u16u:63::divr16u:137 [ divr16u::i#2 divr16u::dividend#0 divr16u::quotient#2 divr16u::rem#2 ] main:2::sin16s_gen:7::div32u16u:63::divr16u:141 [ div32u16u::quotient_hi#0 divr16u::i#2 divr16u::dividend#0 divr16u::quotient#2 divr16u::rem#2 ] main:2::sin8s_gen:5::div16u:165::divr16u:242 [ divr16u::i#2 divr16u::dividend#0 divr16u::quotient#2 divr16u::rem#2 ] ) always clobbers reg byte a 
Statement [162] (word) rem16u#1 ← (word) divr16u::rem#10 [ divr16u::return#0 rem16u#1 ] ( main:2::sin16s_gen:7::div32u16u:63::divr16u:137 [ divr16u::return#0 rem16u#1 ] main:2::sin16s_gen:7::div32u16u:63::divr16u:141 [ div32u16u::quotient_hi#0 divr16u::return#0 rem16u#1 ] main:2::sin8s_gen:5::div16u:165::divr16u:242 [ divr16u::return#0 rem16u#1 ] ) always clobbers reg byte a 
Statement [166] (word) div16u::return#2 ← (word) div16u::return#0 [ div16u::return#2 ] ( main:2::sin8s_gen:5 [ div16u::return#2 ] ) always clobbers reg byte a 
Statement [167] (word) sin8s_gen::step#0 ← (word) div16u::return#2 [ sin8s_gen::step#0 ] ( main:2::sin8s_gen:5 [ sin8s_gen::step#0 ] ) always clobbers reg byte a 
Statement [169] if((word) sin8s_gen::i#2<(const word) main::wavelength) goto sin8s_gen::@2 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 ] ( main:2::sin8s_gen:5 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 ] ) always clobbers reg byte a 
Statement [171] (word) sin8s::x#0 ← (word) sin8s_gen::x#2 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::x#0 ] ( main:2::sin8s_gen:5 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::x#0 ] ) always clobbers reg byte a 
Statement [175] *((signed byte*) sin8s_gen::sintab#2) ← (signed byte~) sin8s_gen::$2 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 ] ( main:2::sin8s_gen:5 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 ] ) always clobbers reg byte y 
Statement [177] (word) sin8s_gen::x#1 ← (word) sin8s_gen::x#2 + (word) sin8s_gen::step#0 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#1 sin8s_gen::sintab#0 ] ( main:2::sin8s_gen:5 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#1 sin8s_gen::sintab#0 ] ) always clobbers reg byte a 
Statement [179] if((word) sin8s::x#0<(const word) PI_u4f12) goto sin8s::@1 [ sin8s::x#0 ] ( main:2::sin8s_gen:5::sin8s:172 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::x#0 ] ) always clobbers reg byte a 
Statement [180] (word) sin8s::x#1 ← (word) sin8s::x#0 - (const word) PI_u4f12 [ sin8s::x#1 ] ( main:2::sin8s_gen:5::sin8s:172 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::x#1 ] ) always clobbers reg byte a 
Statement [182] if((word) sin8s::x#4<(const word) PI_HALF_u4f12) goto sin8s::@2 [ sin8s::x#4 sin8s::isUpper#10 ] ( main:2::sin8s_gen:5::sin8s:172 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::x#4 sin8s::isUpper#10 ] ) always clobbers reg byte a 
Statement [183] (word) sin8s::x#2 ← (const word) PI_u4f12 - (word) sin8s::x#4 [ sin8s::isUpper#10 sin8s::x#2 ] ( main:2::sin8s_gen:5::sin8s:172 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x#2 ] ) always clobbers reg byte a 
Statement [185] (word~) sin8s::$4 ← (word) sin8s::x#6 << (byte) 3 [ sin8s::isUpper#10 sin8s::$4 ] ( main:2::sin8s_gen:5::sin8s:172 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::$4 ] ) always clobbers reg byte a 
Statement [186] (byte) sin8s::x1#0 ← > (word~) sin8s::$4 [ sin8s::isUpper#10 sin8s::x1#0 ] ( main:2::sin8s_gen:5::sin8s:172 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 ] ) always clobbers reg byte a 
Statement [201] (byte) sin8s::usinx#0 ← (byte) sin8s::x1#0 - (byte) sin8s::x3_6#0 [ sin8s::isUpper#10 sin8s::x1#0 sin8s::x3#0 sin8s::usinx#0 ] ( main:2::sin8s_gen:5::sin8s:172 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 sin8s::x3#0 sin8s::usinx#0 ] ) always clobbers reg byte a 
Statement [212] (byte) sin8s::x5_128#0 ← (byte) sin8s::x5#0 >> (byte) 4 [ sin8s::isUpper#10 sin8s::usinx#0 sin8s::x5_128#0 ] ( main:2::sin8s_gen:5::sin8s:172 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::usinx#0 sin8s::x5_128#0 ] ) always clobbers reg byte a 
Statement [213] (byte) sin8s::usinx#1 ← (byte) sin8s::usinx#0 + (byte) sin8s::x5_128#0 [ sin8s::isUpper#10 sin8s::usinx#1 ] ( main:2::sin8s_gen:5::sin8s:172 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::usinx#1 ] ) always clobbers reg byte a 
Statement [218] (signed byte) sin8s::sinx#1 ← - (signed byte)(byte) sin8s::usinx#4 [ sin8s::sinx#1 ] ( main:2::sin8s_gen:5::sin8s:172 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::sinx#1 ] ) always clobbers reg byte a 
Statement [226] (word) mul8u::return#2 ← (word) mul8u::res#2 [ mulu8_sel::select#5 mul8u::return#2 ] ( main:2::sin8s_gen:5::sin8s:172::mulu8_sel:189 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 mulu8_sel::select#5 mul8u::return#2 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:194 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 mulu8_sel::select#5 mul8u::return#2 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:198 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 sin8s::x3#0 mulu8_sel::select#5 mul8u::return#2 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:204 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 sin8s::usinx#0 mulu8_sel::select#5 mul8u::return#2 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:209 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::usinx#0 mulu8_sel::select#5 mul8u::return#2 ] ) always clobbers reg byte a 
Statement [227] (word~) mulu8_sel::$0 ← (word) mul8u::return#2 [ mulu8_sel::select#5 mulu8_sel::$0 ] ( main:2::sin8s_gen:5::sin8s:172::mulu8_sel:189 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 mulu8_sel::select#5 mulu8_sel::$0 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:194 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 mulu8_sel::select#5 mulu8_sel::$0 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:198 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 sin8s::x3#0 mulu8_sel::select#5 mulu8_sel::$0 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:204 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 sin8s::usinx#0 mulu8_sel::select#5 mulu8_sel::$0 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:209 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::usinx#0 mulu8_sel::select#5 mulu8_sel::$0 ] ) always clobbers reg byte a 
Statement [228] (word~) mulu8_sel::$1 ← (word~) mulu8_sel::$0 << (byte) mulu8_sel::select#5 [ mulu8_sel::$1 ] ( main:2::sin8s_gen:5::sin8s:172::mulu8_sel:189 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 mulu8_sel::$1 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:194 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 mulu8_sel::$1 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:198 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 sin8s::x3#0 mulu8_sel::$1 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:204 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 sin8s::usinx#0 mulu8_sel::$1 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:209 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::usinx#0 mulu8_sel::$1 ] ) always clobbers reg byte a 
Statement [229] (byte) mulu8_sel::return#12 ← > (word~) mulu8_sel::$1 [ mulu8_sel::return#12 ] ( main:2::sin8s_gen:5::sin8s:172::mulu8_sel:189 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 mulu8_sel::return#12 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:194 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 mulu8_sel::return#12 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:198 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 sin8s::x3#0 mulu8_sel::return#12 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:204 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 sin8s::usinx#0 mulu8_sel::return#12 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:209 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::usinx#0 mulu8_sel::return#12 ] ) always clobbers reg byte a 
Statement [231] (word) mul8u::mb#0 ← (word)(byte) mul8u::b#0 [ mul8u::a#1 mul8u::mb#0 ] ( main:2::sin8s_gen:5::sin8s:172::mulu8_sel:189::mul8u:225 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 mulu8_sel::select#5 mul8u::a#1 mul8u::mb#0 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:194::mul8u:225 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 mulu8_sel::select#5 mul8u::a#1 mul8u::mb#0 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:198::mul8u:225 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 sin8s::x3#0 mulu8_sel::select#5 mul8u::a#1 mul8u::mb#0 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:204::mul8u:225 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 sin8s::usinx#0 mulu8_sel::select#5 mul8u::a#1 mul8u::mb#0 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:209::mul8u:225 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::usinx#0 mulu8_sel::select#5 mul8u::a#1 mul8u::mb#0 ] ) always clobbers reg byte a 
Statement [235] (byte~) mul8u::$1 ← (byte) mul8u::a#2 & (byte) 1 [ mul8u::res#2 mul8u::a#2 mul8u::mb#2 mul8u::$1 ] ( main:2::sin8s_gen:5::sin8s:172::mulu8_sel:189::mul8u:225 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 mulu8_sel::select#5 mul8u::res#2 mul8u::a#2 mul8u::mb#2 mul8u::$1 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:194::mul8u:225 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 mulu8_sel::select#5 mul8u::res#2 mul8u::a#2 mul8u::mb#2 mul8u::$1 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:198::mul8u:225 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 sin8s::x3#0 mulu8_sel::select#5 mul8u::res#2 mul8u::a#2 mul8u::mb#2 mul8u::$1 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:204::mul8u:225 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 sin8s::usinx#0 mulu8_sel::select#5 mul8u::res#2 mul8u::a#2 mul8u::mb#2 mul8u::$1 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:209::mul8u:225 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::usinx#0 mulu8_sel::select#5 mul8u::res#2 mul8u::a#2 mul8u::mb#2 mul8u::$1 ] ) always clobbers reg byte a 
Statement [237] (word) mul8u::res#1 ← (word) mul8u::res#2 + (word) mul8u::mb#2 [ mul8u::a#2 mul8u::mb#2 mul8u::res#1 ] ( main:2::sin8s_gen:5::sin8s:172::mulu8_sel:189::mul8u:225 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 mulu8_sel::select#5 mul8u::a#2 mul8u::mb#2 mul8u::res#1 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:194::mul8u:225 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 mulu8_sel::select#5 mul8u::a#2 mul8u::mb#2 mul8u::res#1 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:198::mul8u:225 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 sin8s::x3#0 mulu8_sel::select#5 mul8u::a#2 mul8u::mb#2 mul8u::res#1 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:204::mul8u:225 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::x1#0 sin8s::usinx#0 mulu8_sel::select#5 mul8u::a#2 mul8u::mb#2 mul8u::res#1 ] main:2::sin8s_gen:5::sin8s:172::mulu8_sel:209::mul8u:225 [ sin8s_gen::step#0 sin8s_gen::i#2 sin8s_gen::x#2 sin8s_gen::sintab#2 sin8s::isUpper#10 sin8s::usinx#0 mulu8_sel::select#5 mul8u::a#2 mul8u::mb#2 mul8u::res#1 ] ) always clobbers reg byte a 
Statement [243] (word) divr16u::return#2 ← (word) divr16u::return#0 [ divr16u::return#2 ] ( main:2::sin8s_gen:5::div16u:165 [ divr16u::return#2 ] ) always clobbers reg byte a 
Statement [244] (word) div16u::return#0 ← (word) divr16u::return#2 [ div16u::return#0 ] ( main:2::sin8s_gen:5::div16u:165 [ div16u::return#0 ] ) always clobbers reg byte a 
Potential registers zp[1]:2 [ main::i#2 main::i#1 ] : zp[1]:2 , reg byte x , 
Potential registers zp[2]:3 [ print_str::str#2 print_str::str#0 ] : zp[2]:3 , 
Potential registers zp[1]:5 [ print_sbyte::b#4 print_sbyte::b#0 print_sbyte::b#1 ] : zp[1]:5 , reg byte a , reg byte x , 
Potential registers zp[1]:6 [ print_char::ch#4 print_char::ch#2 print_char::ch#3 ] : zp[1]:6 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[2]:7 [ print_char_cursor#28 print_char_cursor#42 print_char_cursor#19 print_char_cursor#10 print_char_cursor#1 ] : zp[2]:7 , 
Potential registers zp[2]:9 [ memset::dst#2 memset::dst#1 ] : zp[2]:9 , 
Potential registers zp[2]:11 [ sin16s_gen::i#2 sin16s_gen::i#1 ] : zp[2]:11 , 
Potential registers zp[4]:13 [ sin16s_gen::x#2 sin16s_gen::x#1 ] : zp[4]:13 , 
Potential registers zp[2]:17 [ sin16s_gen::sintab#2 sin16s_gen::sintab#0 ] : zp[2]:17 , 
Potential registers zp[1]:19 [ sin16s::isUpper#2 ] : zp[1]:19 , reg byte x , reg byte y , 
Potential registers zp[4]:20 [ sin16s::x#6 sin16s::x#4 sin16s::x#0 sin16s::x#1 sin16s::x#2 ] : zp[4]:20 , 
Potential registers zp[2]:24 [ sin16s::return#1 sin16s::return#5 sin16s::sinx#1 ] : zp[2]:24 , 
Potential registers zp[2]:26 [ mulu16_sel::v1#5 mulu16_sel::v1#3 mulu16_sel::v1#4 mulu16_sel::v1#0 mulu16_sel::v1#1 mulu16_sel::v1#2 ] : zp[2]:26 , 
Potential registers zp[2]:28 [ mulu16_sel::v2#5 mulu16_sel::v2#3 mulu16_sel::v2#4 mulu16_sel::v2#0 mulu16_sel::v2#1 ] : zp[2]:28 , 
Potential registers zp[1]:30 [ mulu16_sel::select#5 ] : zp[1]:30 , reg byte x , reg byte y , 
Potential registers zp[2]:31 [ mul16u::a#2 mul16u::a#1 mul16u::a#0 ] : zp[2]:31 , 
Potential registers zp[4]:33 [ mul16u::res#2 mul16u::res#6 mul16u::res#1 ] : zp[4]:33 , 
Potential registers zp[4]:37 [ mul16u::mb#2 mul16u::mb#0 mul16u::mb#1 ] : zp[4]:37 , 
Potential registers zp[2]:41 [ divr16u::rem#6 divr16u::rem#11 divr16u::rem#5 divr16u::rem#10 divr16u::rem#7 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 ] : zp[2]:41 , 
Potential registers zp[2]:43 [ divr16u::dividend#4 divr16u::dividend#6 divr16u::dividend#0 ] : zp[2]:43 , 
Potential registers zp[2]:45 [ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 ] : zp[2]:45 , 
Potential registers zp[1]:47 [ divr16u::i#2 divr16u::i#1 ] : zp[1]:47 , reg byte x , reg byte y , 
Potential registers zp[2]:48 [ sin8s_gen::i#2 sin8s_gen::i#1 ] : zp[2]:48 , 
Potential registers zp[2]:50 [ sin8s_gen::x#2 sin8s_gen::x#1 ] : zp[2]:50 , 
Potential registers zp[2]:52 [ sin8s_gen::sintab#2 sin8s_gen::sintab#0 ] : zp[2]:52 , 
Potential registers zp[1]:54 [ sin8s::isUpper#10 ] : zp[1]:54 , reg byte x , reg byte y , 
Potential registers zp[2]:55 [ sin8s::x#6 sin8s::x#4 sin8s::x#0 sin8s::x#1 sin8s::x#2 ] : zp[2]:55 , 
Potential registers zp[1]:57 [ sin8s::usinx#4 sin8s::usinx#1 sin8s::usinx#2 ] : zp[1]:57 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:58 [ sin8s::return#1 sin8s::return#5 sin8s::sinx#1 ] : zp[1]:58 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:59 [ mulu8_sel::v1#5 mulu8_sel::v1#1 mulu8_sel::v1#2 mulu8_sel::v1#3 mulu8_sel::v1#4 mulu8_sel::v1#0 ] : zp[1]:59 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:60 [ mulu8_sel::v2#5 mulu8_sel::v2#1 mulu8_sel::v2#3 mulu8_sel::v2#4 mulu8_sel::v2#0 ] : zp[1]:60 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:61 [ mulu8_sel::select#5 ] : zp[1]:61 , reg byte x , reg byte y , 
Potential registers zp[1]:62 [ mul8u::a#2 mul8u::a#1 mul8u::a#0 ] : zp[1]:62 , reg byte x , reg byte y , 
Potential registers zp[2]:63 [ mul8u::res#2 mul8u::res#6 mul8u::res#1 ] : zp[2]:63 , 
Potential registers zp[2]:65 [ mul8u::mb#2 mul8u::mb#0 mul8u::mb#1 ] : zp[2]:65 , 
Potential registers zp[1]:67 [ main::sb#0 ] : zp[1]:67 , reg byte x , 
Potential registers zp[2]:68 [ main::$3 ] : zp[2]:68 , 
Potential registers zp[2]:70 [ main::$11 ] : zp[2]:70 , 
Potential registers zp[2]:72 [ main::$4 ] : zp[2]:72 , 
Potential registers zp[2]:74 [ main::sw#0 ] : zp[2]:74 , 
Potential registers zp[1]:76 [ main::$6 ] : zp[1]:76 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:77 [ main::sd#0 ] : zp[1]:77 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:78 [ print_byte::b#0 ] : zp[1]:78 , reg byte x , 
Potential registers zp[1]:79 [ print_byte::$0 ] : zp[1]:79 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:80 [ print_byte::$2 ] : zp[1]:80 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[4]:81 [ div32u16u::return#2 ] : zp[4]:81 , 
Potential registers zp[4]:85 [ sin16s_gen::step#0 ] : zp[4]:85 , 
Potential registers zp[2]:89 [ sin16s::return#0 ] : zp[2]:89 , 
Potential registers zp[2]:91 [ sin16s_gen::$2 ] : zp[2]:91 , 
Potential registers zp[4]:93 [ sin16s::$4 ] : zp[4]:93 , 
Potential registers zp[2]:97 [ sin16s::x1#0 ] : zp[2]:97 , 
Potential registers zp[2]:99 [ mulu16_sel::return#0 ] : zp[2]:99 , 
Potential registers zp[2]:101 [ sin16s::x2#0 ] : zp[2]:101 , 
Potential registers zp[2]:103 [ mulu16_sel::return#1 ] : zp[2]:103 , 
Potential registers zp[2]:105 [ sin16s::x3#0 ] : zp[2]:105 , 
Potential registers zp[2]:107 [ mulu16_sel::return#2 ] : zp[2]:107 , 
Potential registers zp[2]:109 [ sin16s::x3_6#0 ] : zp[2]:109 , 
Potential registers zp[2]:111 [ sin16s::usinx#0 ] : zp[2]:111 , 
Potential registers zp[2]:113 [ mulu16_sel::return#10 ] : zp[2]:113 , 
Potential registers zp[2]:115 [ sin16s::x4#0 ] : zp[2]:115 , 
Potential registers zp[2]:117 [ mulu16_sel::return#11 ] : zp[2]:117 , 
Potential registers zp[2]:119 [ sin16s::x5#0 ] : zp[2]:119 , 
Potential registers zp[2]:121 [ sin16s::x5_128#0 ] : zp[2]:121 , 
Potential registers zp[2]:123 [ sin16s::usinx#1 ] : zp[2]:123 , 
Potential registers zp[2]:125 [ mul16u::b#0 ] : zp[2]:125 , 
Potential registers zp[4]:127 [ mul16u::return#2 ] : zp[4]:127 , 
Potential registers zp[4]:131 [ mulu16_sel::$0 ] : zp[4]:131 , 
Potential registers zp[4]:135 [ mulu16_sel::$1 ] : zp[4]:135 , 
Potential registers zp[2]:139 [ mulu16_sel::return#12 ] : zp[2]:139 , 
Potential registers zp[1]:141 [ mul16u::$1 ] : zp[1]:141 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[2]:142 [ divr16u::return#3 ] : zp[2]:142 , 
Potential registers zp[2]:144 [ div32u16u::quotient_hi#0 ] : zp[2]:144 , 
Potential registers zp[2]:146 [ divr16u::return#4 ] : zp[2]:146 , 
Potential registers zp[2]:148 [ div32u16u::quotient_lo#0 ] : zp[2]:148 , 
Potential registers zp[4]:150 [ div32u16u::return#0 ] : zp[4]:150 , 
Potential registers zp[1]:154 [ divr16u::$1 ] : zp[1]:154 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:155 [ divr16u::$2 ] : zp[1]:155 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[2]:156 [ rem16u#1 ] : zp[2]:156 , 
Potential registers zp[2]:158 [ div16u::return#2 ] : zp[2]:158 , 
Potential registers zp[2]:160 [ sin8s_gen::step#0 ] : zp[2]:160 , 
Potential registers zp[1]:162 [ sin8s::return#0 ] : zp[1]:162 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:163 [ sin8s_gen::$2 ] : zp[1]:163 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[2]:164 [ sin8s::$4 ] : zp[2]:164 , 
Potential registers zp[1]:166 [ sin8s::x1#0 ] : zp[1]:166 , reg byte x , reg byte y , 
Potential registers zp[1]:167 [ mulu8_sel::return#0 ] : zp[1]:167 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:168 [ sin8s::x2#0 ] : zp[1]:168 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:169 [ mulu8_sel::return#1 ] : zp[1]:169 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:170 [ sin8s::x3#0 ] : zp[1]:170 , reg byte x , reg byte y , 
Potential registers zp[1]:171 [ mulu8_sel::return#2 ] : zp[1]:171 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:172 [ sin8s::x3_6#0 ] : zp[1]:172 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:173 [ sin8s::usinx#0 ] : zp[1]:173 , reg byte x , reg byte y , 
Potential registers zp[1]:174 [ mulu8_sel::return#10 ] : zp[1]:174 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:175 [ sin8s::x4#0 ] : zp[1]:175 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:176 [ mulu8_sel::return#11 ] : zp[1]:176 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:177 [ sin8s::x5#0 ] : zp[1]:177 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:178 [ sin8s::x5_128#0 ] : zp[1]:178 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:179 [ mul8u::b#0 ] : zp[1]:179 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[2]:180 [ mul8u::return#2 ] : zp[2]:180 , 
Potential registers zp[2]:182 [ mulu8_sel::$0 ] : zp[2]:182 , 
Potential registers zp[2]:184 [ mulu8_sel::$1 ] : zp[2]:184 , 
Potential registers zp[1]:186 [ mulu8_sel::return#12 ] : zp[1]:186 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:187 [ mul8u::$1 ] : zp[1]:187 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[2]:188 [ divr16u::return#2 ] : zp[2]:188 , 
Potential registers zp[2]:190 [ div16u::return#0 ] : zp[2]:190 , 

REGISTER UPLIFT SCOPES
Uplift Scope [mul8u] 353.83: zp[2]:63 [ mul8u::res#2 mul8u::res#6 mul8u::res#1 ] 249.57: zp[2]:65 [ mul8u::mb#2 mul8u::mb#0 mul8u::mb#1 ] 202: zp[1]:187 [ mul8u::$1 ] 170: zp[1]:62 [ mul8u::a#2 mul8u::a#1 mul8u::a#0 ] 4: zp[2]:180 [ mul8u::return#2 ] 2: zp[1]:179 [ mul8u::b#0 ] 
Uplift Scope [mul16u] 353.83: zp[4]:33 [ mul16u::res#2 mul16u::res#6 mul16u::res#1 ] 249.57: zp[4]:37 [ mul16u::mb#2 mul16u::mb#0 mul16u::mb#1 ] 202: zp[1]:141 [ mul16u::$1 ] 170: zp[2]:31 [ mul16u::a#2 mul16u::a#1 mul16u::a#0 ] 4: zp[4]:127 [ mul16u::return#2 ] 2: zp[2]:125 [ mul16u::b#0 ] 
Uplift Scope [print_str] 303: zp[2]:3 [ print_str::str#2 print_str::str#0 ] 
Uplift Scope [divr16u] 106.92: zp[2]:41 [ divr16u::rem#6 divr16u::rem#11 divr16u::rem#5 divr16u::rem#10 divr16u::rem#7 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 ] 35.12: zp[2]:45 [ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 ] 22: zp[1]:154 [ divr16u::$1 ] 22: zp[1]:155 [ divr16u::$2 ] 18.19: zp[1]:47 [ divr16u::i#2 divr16u::i#1 ] 9.75: zp[2]:43 [ divr16u::dividend#4 divr16u::dividend#6 divr16u::dividend#0 ] 4: zp[2]:142 [ divr16u::return#3 ] 4: zp[2]:146 [ divr16u::return#4 ] 4: zp[2]:188 [ divr16u::return#2 ] 
Uplift Scope [] 153.81: zp[2]:7 [ print_char_cursor#28 print_char_cursor#42 print_char_cursor#19 print_char_cursor#10 print_char_cursor#1 ] 0.8: zp[2]:156 [ rem16u#1 ] 
Uplift Scope [main] 22: zp[2]:68 [ main::$3 ] 22: zp[2]:70 [ main::$11 ] 22: zp[2]:72 [ main::$4 ] 22: zp[2]:74 [ main::sw#0 ] 22: zp[1]:77 [ main::sd#0 ] 19.25: zp[1]:2 [ main::i#2 main::i#1 ] 11: zp[1]:76 [ main::$6 ] 3.67: zp[1]:67 [ main::sb#0 ] 
Uplift Scope [sin8s] 27.5: zp[2]:55 [ sin8s::x#6 sin8s::x#4 sin8s::x#0 sin8s::x#1 sin8s::x#2 ] 22: zp[1]:162 [ sin8s::return#0 ] 13: zp[1]:58 [ sin8s::return#1 sin8s::return#5 sin8s::sinx#1 ] 10: zp[1]:57 [ sin8s::usinx#4 sin8s::usinx#1 sin8s::usinx#2 ] 4: zp[2]:164 [ sin8s::$4 ] 4: zp[1]:168 [ sin8s::x2#0 ] 4: zp[1]:172 [ sin8s::x3_6#0 ] 4: zp[1]:175 [ sin8s::x4#0 ] 4: zp[1]:177 [ sin8s::x5#0 ] 4: zp[1]:178 [ sin8s::x5_128#0 ] 1: zp[1]:170 [ sin8s::x3#0 ] 0.64: zp[1]:166 [ sin8s::x1#0 ] 0.33: zp[1]:173 [ sin8s::usinx#0 ] 0.06: zp[1]:54 [ sin8s::isUpper#10 ] 
Uplift Scope [sin16s] 27.5: zp[4]:20 [ sin16s::x#6 sin16s::x#4 sin16s::x#0 sin16s::x#1 sin16s::x#2 ] 22: zp[2]:89 [ sin16s::return#0 ] 13: zp[2]:24 [ sin16s::return#1 sin16s::return#5 sin16s::sinx#1 ] 4: zp[4]:93 [ sin16s::$4 ] 4: zp[2]:101 [ sin16s::x2#0 ] 4: zp[2]:109 [ sin16s::x3_6#0 ] 4: zp[2]:115 [ sin16s::x4#0 ] 4: zp[2]:119 [ sin16s::x5#0 ] 4: zp[2]:121 [ sin16s::x5_128#0 ] 1: zp[2]:105 [ sin16s::x3#0 ] 1: zp[2]:123 [ sin16s::usinx#1 ] 0.64: zp[2]:97 [ sin16s::x1#0 ] 0.33: zp[2]:111 [ sin16s::usinx#0 ] 0.06: zp[1]:19 [ sin16s::isUpper#2 ] 
Uplift Scope [sin16s_gen] 25.67: zp[2]:11 [ sin16s_gen::i#2 sin16s_gen::i#1 ] 22: zp[2]:91 [ sin16s_gen::$2 ] 15.12: zp[4]:13 [ sin16s_gen::x#2 sin16s_gen::x#1 ] 12.05: zp[2]:17 [ sin16s_gen::sintab#2 sin16s_gen::sintab#0 ] 1.18: zp[4]:85 [ sin16s_gen::step#0 ] 
Uplift Scope [sin8s_gen] 25.67: zp[2]:48 [ sin8s_gen::i#2 sin8s_gen::i#1 ] 22: zp[1]:163 [ sin8s_gen::$2 ] 15.12: zp[2]:50 [ sin8s_gen::x#2 sin8s_gen::x#1 ] 12.05: zp[2]:52 [ sin8s_gen::sintab#2 sin8s_gen::sintab#0 ] 1.18: zp[2]:160 [ sin8s_gen::step#0 ] 
Uplift Scope [mulu16_sel] 24: zp[2]:26 [ mulu16_sel::v1#5 mulu16_sel::v1#3 mulu16_sel::v1#4 mulu16_sel::v1#0 mulu16_sel::v1#1 mulu16_sel::v1#2 ] 21: zp[2]:28 [ mulu16_sel::v2#5 mulu16_sel::v2#3 mulu16_sel::v2#4 mulu16_sel::v2#0 mulu16_sel::v2#1 ] 4: zp[2]:99 [ mulu16_sel::return#0 ] 4: zp[2]:103 [ mulu16_sel::return#1 ] 4: zp[2]:107 [ mulu16_sel::return#2 ] 4: zp[2]:113 [ mulu16_sel::return#10 ] 4: zp[2]:117 [ mulu16_sel::return#11 ] 4: zp[4]:131 [ mulu16_sel::$0 ] 4: zp[4]:135 [ mulu16_sel::$1 ] 1.71: zp[2]:139 [ mulu16_sel::return#12 ] 0.33: zp[1]:30 [ mulu16_sel::select#5 ] 
Uplift Scope [mulu8_sel] 24: zp[1]:59 [ mulu8_sel::v1#5 mulu8_sel::v1#1 mulu8_sel::v1#2 mulu8_sel::v1#3 mulu8_sel::v1#4 mulu8_sel::v1#0 ] 21: zp[1]:60 [ mulu8_sel::v2#5 mulu8_sel::v2#1 mulu8_sel::v2#3 mulu8_sel::v2#4 mulu8_sel::v2#0 ] 4: zp[1]:167 [ mulu8_sel::return#0 ] 4: zp[1]:169 [ mulu8_sel::return#1 ] 4: zp[1]:171 [ mulu8_sel::return#2 ] 4: zp[1]:174 [ mulu8_sel::return#10 ] 4: zp[1]:176 [ mulu8_sel::return#11 ] 4: zp[2]:182 [ mulu8_sel::$0 ] 4: zp[2]:184 [ mulu8_sel::$1 ] 1.71: zp[1]:186 [ mulu8_sel::return#12 ] 0.33: zp[1]:61 [ mulu8_sel::select#5 ] 
Uplift Scope [memset] 36.67: zp[2]:9 [ memset::dst#2 memset::dst#1 ] 
Uplift Scope [print_char] 14: zp[1]:6 [ print_char::ch#4 print_char::ch#2 print_char::ch#3 ] 
Uplift Scope [print_sbyte] 10.83: zp[1]:5 [ print_sbyte::b#4 print_sbyte::b#0 print_sbyte::b#1 ] 
Uplift Scope [div32u16u] 4: zp[4]:81 [ div32u16u::return#2 ] 4: zp[2]:148 [ div32u16u::quotient_lo#0 ] 1.33: zp[4]:150 [ div32u16u::return#0 ] 0.8: zp[2]:144 [ div32u16u::quotient_hi#0 ] 
Uplift Scope [print_byte] 4: zp[1]:79 [ print_byte::$0 ] 4: zp[1]:80 [ print_byte::$2 ] 1.5: zp[1]:78 [ print_byte::b#0 ] 
Uplift Scope [div16u] 4: zp[2]:158 [ div16u::return#2 ] 1.33: zp[2]:190 [ div16u::return#0 ] 
Uplift Scope [RADIX] 
Uplift Scope [print_cls] 

Uplifting [mul8u] best 36701 combination zp[2]:63 [ mul8u::res#2 mul8u::res#6 mul8u::res#1 ] zp[2]:65 [ mul8u::mb#2 mul8u::mb#0 mul8u::mb#1 ] reg byte a [ mul8u::$1 ] reg byte x [ mul8u::a#2 mul8u::a#1 mul8u::a#0 ] zp[2]:180 [ mul8u::return#2 ] reg byte a [ mul8u::b#0 ] 
Uplifting [mul16u] best 36101 combination zp[4]:33 [ mul16u::res#2 mul16u::res#6 mul16u::res#1 ] zp[4]:37 [ mul16u::mb#2 mul16u::mb#0 mul16u::mb#1 ] reg byte a [ mul16u::$1 ] zp[2]:31 [ mul16u::a#2 mul16u::a#1 mul16u::a#0 ] zp[4]:127 [ mul16u::return#2 ] zp[2]:125 [ mul16u::b#0 ] 
Uplifting [print_str] best 36101 combination zp[2]:3 [ print_str::str#2 print_str::str#0 ] 
Uplifting [divr16u] best 35891 combination zp[2]:41 [ divr16u::rem#6 divr16u::rem#11 divr16u::rem#5 divr16u::rem#10 divr16u::rem#7 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 ] zp[2]:45 [ 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]:43 [ divr16u::dividend#4 divr16u::dividend#6 divr16u::dividend#0 ] zp[2]:142 [ divr16u::return#3 ] zp[2]:146 [ divr16u::return#4 ] zp[2]:188 [ divr16u::return#2 ] 
Uplifting [] best 35891 combination zp[2]:7 [ print_char_cursor#28 print_char_cursor#42 print_char_cursor#19 print_char_cursor#10 print_char_cursor#1 ] zp[2]:156 [ rem16u#1 ] 
Uplifting [main] best 35661 combination zp[2]:68 [ main::$3 ] zp[2]:70 [ main::$11 ] zp[2]:72 [ main::$4 ] zp[2]:74 [ main::sw#0 ] reg byte a [ main::sd#0 ] reg byte x [ main::i#2 main::i#1 ] reg byte a [ main::$6 ] zp[1]:67 [ main::sb#0 ] 
Uplifting [sin8s] best 35556 combination zp[2]:55 [ sin8s::x#6 sin8s::x#4 sin8s::x#0 sin8s::x#1 sin8s::x#2 ] reg byte a [ sin8s::return#0 ] reg byte a [ sin8s::return#1 sin8s::return#5 sin8s::sinx#1 ] reg byte x [ sin8s::usinx#4 sin8s::usinx#1 sin8s::usinx#2 ] zp[2]:164 [ sin8s::$4 ] zp[1]:168 [ sin8s::x2#0 ] zp[1]:172 [ sin8s::x3_6#0 ] zp[1]:175 [ sin8s::x4#0 ] zp[1]:177 [ sin8s::x5#0 ] zp[1]:178 [ sin8s::x5_128#0 ] zp[1]:170 [ sin8s::x3#0 ] zp[1]:166 [ sin8s::x1#0 ] zp[1]:173 [ sin8s::usinx#0 ] zp[1]:54 [ sin8s::isUpper#10 ] 
Limited combination testing to 100 combinations of 5308416 possible.
Uplifting [sin16s] best 35547 combination zp[4]:20 [ sin16s::x#6 sin16s::x#4 sin16s::x#0 sin16s::x#1 sin16s::x#2 ] zp[2]:89 [ sin16s::return#0 ] zp[2]:24 [ sin16s::return#1 sin16s::return#5 sin16s::sinx#1 ] zp[4]:93 [ sin16s::$4 ] zp[2]:101 [ sin16s::x2#0 ] zp[2]:109 [ sin16s::x3_6#0 ] zp[2]:115 [ sin16s::x4#0 ] zp[2]:119 [ sin16s::x5#0 ] zp[2]:121 [ sin16s::x5_128#0 ] zp[2]:105 [ sin16s::x3#0 ] zp[2]:123 [ sin16s::usinx#1 ] zp[2]:97 [ sin16s::x1#0 ] zp[2]:111 [ sin16s::usinx#0 ] reg byte y [ sin16s::isUpper#2 ] 
Uplifting [sin16s_gen] best 35547 combination zp[2]:11 [ sin16s_gen::i#2 sin16s_gen::i#1 ] zp[2]:91 [ sin16s_gen::$2 ] zp[4]:13 [ sin16s_gen::x#2 sin16s_gen::x#1 ] zp[2]:17 [ sin16s_gen::sintab#2 sin16s_gen::sintab#0 ] zp[4]:85 [ sin16s_gen::step#0 ] 
Uplifting [sin8s_gen] best 35487 combination zp[2]:48 [ sin8s_gen::i#2 sin8s_gen::i#1 ] reg byte a [ sin8s_gen::$2 ] zp[2]:50 [ sin8s_gen::x#2 sin8s_gen::x#1 ] zp[2]:52 [ sin8s_gen::sintab#2 sin8s_gen::sintab#0 ] zp[2]:160 [ sin8s_gen::step#0 ] 
Uplifting [mulu16_sel] best 35471 combination zp[2]:26 [ mulu16_sel::v1#5 mulu16_sel::v1#3 mulu16_sel::v1#4 mulu16_sel::v1#0 mulu16_sel::v1#1 mulu16_sel::v1#2 ] zp[2]:28 [ mulu16_sel::v2#5 mulu16_sel::v2#3 mulu16_sel::v2#4 mulu16_sel::v2#0 mulu16_sel::v2#1 ] zp[2]:99 [ mulu16_sel::return#0 ] zp[2]:103 [ mulu16_sel::return#1 ] zp[2]:107 [ mulu16_sel::return#2 ] zp[2]:113 [ mulu16_sel::return#10 ] zp[2]:117 [ mulu16_sel::return#11 ] zp[4]:131 [ mulu16_sel::$0 ] zp[4]:135 [ mulu16_sel::$1 ] zp[2]:139 [ mulu16_sel::return#12 ] reg byte x [ mulu16_sel::select#5 ] 
Uplifting [mulu8_sel] best 35425 combination reg byte x [ mulu8_sel::v1#5 mulu8_sel::v1#1 mulu8_sel::v1#2 mulu8_sel::v1#3 mulu8_sel::v1#4 mulu8_sel::v1#0 ] reg byte y [ mulu8_sel::v2#5 mulu8_sel::v2#1 mulu8_sel::v2#3 mulu8_sel::v2#4 mulu8_sel::v2#0 ] reg byte a [ mulu8_sel::return#0 ] reg byte a [ mulu8_sel::return#1 ] zp[1]:171 [ mulu8_sel::return#2 ] zp[1]:174 [ mulu8_sel::return#10 ] zp[1]:176 [ mulu8_sel::return#11 ] zp[2]:182 [ mulu8_sel::$0 ] zp[2]:184 [ mulu8_sel::$1 ] zp[1]:186 [ mulu8_sel::return#12 ] zp[1]:61 [ mulu8_sel::select#5 ] 
Limited combination testing to 100 combinations of 196608 possible.
Uplifting [memset] best 35425 combination zp[2]:9 [ memset::dst#2 memset::dst#1 ] 
Uplifting [print_char] best 35410 combination reg byte a [ print_char::ch#4 print_char::ch#2 print_char::ch#3 ] 
Uplifting [print_sbyte] best 35410 combination zp[1]:5 [ print_sbyte::b#4 print_sbyte::b#0 print_sbyte::b#1 ] 
Uplifting [div32u16u] best 35410 combination zp[4]:81 [ div32u16u::return#2 ] zp[2]:148 [ div32u16u::quotient_lo#0 ] zp[4]:150 [ div32u16u::return#0 ] zp[2]:144 [ div32u16u::quotient_hi#0 ] 
Uplifting [print_byte] best 35402 combination reg byte a [ print_byte::$0 ] reg byte a [ print_byte::$2 ] zp[1]:78 [ print_byte::b#0 ] 
Uplifting [div16u] best 35402 combination zp[2]:158 [ div16u::return#2 ] zp[2]:190 [ div16u::return#0 ] 
Uplifting [RADIX] best 35402 combination 
Uplifting [print_cls] best 35402 combination 
Attempting to uplift remaining variables inzp[1]:5 [ print_sbyte::b#4 print_sbyte::b#0 print_sbyte::b#1 ]
Uplifting [print_sbyte] best 35402 combination zp[1]:5 [ print_sbyte::b#4 print_sbyte::b#0 print_sbyte::b#1 ] 
Attempting to uplift remaining variables inzp[1]:168 [ sin8s::x2#0 ]
Uplifting [sin8s] best 35398 combination reg byte a [ sin8s::x2#0 ] 
Attempting to uplift remaining variables inzp[1]:171 [ mulu8_sel::return#2 ]
Uplifting [mulu8_sel] best 35392 combination reg byte a [ mulu8_sel::return#2 ] 
Attempting to uplift remaining variables inzp[1]:172 [ sin8s::x3_6#0 ]
Uplifting [sin8s] best 35388 combination reg byte a [ sin8s::x3_6#0 ] 
Attempting to uplift remaining variables inzp[1]:174 [ mulu8_sel::return#10 ]
Uplifting [mulu8_sel] best 35382 combination reg byte a [ mulu8_sel::return#10 ] 
Attempting to uplift remaining variables inzp[1]:175 [ sin8s::x4#0 ]
Uplifting [sin8s] best 35378 combination reg byte a [ sin8s::x4#0 ] 
Attempting to uplift remaining variables inzp[1]:176 [ mulu8_sel::return#11 ]
Uplifting [mulu8_sel] best 35372 combination reg byte a [ mulu8_sel::return#11 ] 
Attempting to uplift remaining variables inzp[1]:177 [ sin8s::x5#0 ]
Uplifting [sin8s] best 35366 combination reg byte a [ sin8s::x5#0 ] 
Attempting to uplift remaining variables inzp[1]:178 [ sin8s::x5_128#0 ]
Uplifting [sin8s] best 35360 combination reg byte a [ sin8s::x5_128#0 ] 
Attempting to uplift remaining variables inzp[1]:67 [ main::sb#0 ]
Uplifting [main] best 35360 combination zp[1]:67 [ main::sb#0 ] 
Attempting to uplift remaining variables inzp[1]:186 [ mulu8_sel::return#12 ]
Uplifting [mulu8_sel] best 35342 combination reg byte a [ mulu8_sel::return#12 ] 
Attempting to uplift remaining variables inzp[1]:78 [ print_byte::b#0 ]
Uplifting [print_byte] best 35342 combination zp[1]:78 [ print_byte::b#0 ] 
Attempting to uplift remaining variables inzp[1]:170 [ sin8s::x3#0 ]
Uplifting [sin8s] best 35342 combination zp[1]:170 [ sin8s::x3#0 ] 
Attempting to uplift remaining variables inzp[1]:166 [ sin8s::x1#0 ]
Uplifting [sin8s] best 35342 combination zp[1]:166 [ sin8s::x1#0 ] 
Attempting to uplift remaining variables inzp[1]:61 [ mulu8_sel::select#5 ]
Uplifting [mulu8_sel] best 35342 combination zp[1]:61 [ mulu8_sel::select#5 ] 
Attempting to uplift remaining variables inzp[1]:173 [ sin8s::usinx#0 ]
Uplifting [sin8s] best 35342 combination zp[1]:173 [ sin8s::usinx#0 ] 
Attempting to uplift remaining variables inzp[1]:54 [ sin8s::isUpper#10 ]
Uplifting [sin8s] best 35342 combination zp[1]:54 [ sin8s::isUpper#10 ] 
Coalescing zero page register [ zp[2]:24 [ sin16s::return#1 sin16s::return#5 sin16s::sinx#1 ] ] with [ zp[2]:123 [ sin16s::usinx#1 ] ] - score: 2
Coalescing zero page register [ zp[2]:26 [ mulu16_sel::v1#5 mulu16_sel::v1#3 mulu16_sel::v1#4 mulu16_sel::v1#0 mulu16_sel::v1#1 mulu16_sel::v1#2 ] ] with [ zp[2]:105 [ sin16s::x3#0 ] ] - score: 2
Coalescing zero page register [ zp[2]:41 [ divr16u::rem#6 divr16u::rem#11 divr16u::rem#5 divr16u::rem#10 divr16u::rem#7 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 ] ] with [ zp[2]:156 [ rem16u#1 ] ] - score: 2
Coalescing zero page register [ zp[1]:5 [ print_sbyte::b#4 print_sbyte::b#0 print_sbyte::b#1 ] ] with [ zp[1]:78 [ print_byte::b#0 ] ] - score: 1
Coalescing zero page register [ zp[2]:24 [ sin16s::return#1 sin16s::return#5 sin16s::sinx#1 sin16s::usinx#1 ] ] with [ zp[2]:89 [ sin16s::return#0 ] ] - score: 1
Coalescing zero page register [ zp[2]:26 [ mulu16_sel::v1#5 mulu16_sel::v1#3 mulu16_sel::v1#4 mulu16_sel::v1#0 mulu16_sel::v1#1 mulu16_sel::v1#2 sin16s::x3#0 ] ] with [ zp[2]:101 [ sin16s::x2#0 ] ] - score: 1
Coalescing zero page register [ zp[2]:26 [ mulu16_sel::v1#5 mulu16_sel::v1#3 mulu16_sel::v1#4 mulu16_sel::v1#0 mulu16_sel::v1#1 mulu16_sel::v1#2 sin16s::x3#0 sin16s::x2#0 ] ] with [ zp[2]:115 [ sin16s::x4#0 ] ] - score: 1
Coalescing zero page register [ zp[2]:28 [ mulu16_sel::v2#5 mulu16_sel::v2#3 mulu16_sel::v2#4 mulu16_sel::v2#0 mulu16_sel::v2#1 ] ] with [ zp[2]:125 [ mul16u::b#0 ] ] - score: 1
Coalescing zero page register [ zp[4]:33 [ mul16u::res#2 mul16u::res#6 mul16u::res#1 ] ] with [ zp[4]:127 [ mul16u::return#2 ] ] - score: 1
Coalescing zero page register [ zp[2]:45 [ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 ] ] with [ zp[2]:142 [ divr16u::return#3 ] ] - score: 1
Coalescing zero page register [ zp[2]:45 [ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 divr16u::return#3 ] ] with [ zp[2]:146 [ divr16u::return#4 ] ] - score: 1
Coalescing zero page register [ zp[2]:45 [ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 divr16u::return#3 divr16u::return#4 ] ] with [ zp[2]:188 [ divr16u::return#2 ] ] - score: 1
Coalescing zero page register [ zp[2]:55 [ sin8s::x#6 sin8s::x#4 sin8s::x#0 sin8s::x#1 sin8s::x#2 ] ] with [ zp[2]:164 [ sin8s::$4 ] ] - score: 1
Coalescing zero page register [ zp[2]:63 [ mul8u::res#2 mul8u::res#6 mul8u::res#1 ] ] with [ zp[2]:180 [ mul8u::return#2 ] ] - score: 1
Coalescing zero page register [ zp[2]:68 [ main::$3 ] ] with [ zp[2]:70 [ main::$11 ] ] - score: 1
Coalescing zero page register [ zp[2]:72 [ main::$4 ] ] with [ zp[2]:74 [ main::sw#0 ] ] - score: 1
Coalescing zero page register [ zp[4]:81 [ div32u16u::return#2 ] ] with [ zp[4]:85 [ sin16s_gen::step#0 ] ] - score: 1
Coalescing zero page register [ zp[4]:81 [ div32u16u::return#2 sin16s_gen::step#0 ] ] with [ zp[4]:150 [ div32u16u::return#0 ] ] - score: 1
Coalescing zero page register [ zp[2]:99 [ mulu16_sel::return#0 ] ] with [ zp[2]:139 [ mulu16_sel::return#12 ] ] - score: 1
Coalescing zero page register [ zp[2]:107 [ mulu16_sel::return#2 ] ] with [ zp[2]:109 [ sin16s::x3_6#0 ] ] - score: 1
Coalescing zero page register [ zp[2]:117 [ mulu16_sel::return#11 ] ] with [ zp[2]:119 [ sin16s::x5#0 ] ] - score: 1
Coalescing zero page register [ zp[4]:131 [ mulu16_sel::$0 ] ] with [ zp[4]:135 [ mulu16_sel::$1 ] ] - score: 1
Coalescing zero page register [ zp[2]:158 [ div16u::return#2 ] ] with [ zp[2]:160 [ sin8s_gen::step#0 ] ] - score: 1
Coalescing zero page register [ zp[2]:158 [ div16u::return#2 sin8s_gen::step#0 ] ] with [ zp[2]:190 [ div16u::return#0 ] ] - score: 1
Coalescing zero page register [ zp[2]:182 [ mulu8_sel::$0 ] ] with [ zp[2]:184 [ mulu8_sel::$1 ] ] - score: 1
Coalescing zero page register [ zp[2]:24 [ sin16s::return#1 sin16s::return#5 sin16s::sinx#1 sin16s::usinx#1 sin16s::return#0 ] ] with [ zp[2]:91 [ sin16s_gen::$2 ] ] - score: 1
Coalescing zero page register [ zp[2]:24 [ sin16s::return#1 sin16s::return#5 sin16s::sinx#1 sin16s::usinx#1 sin16s::return#0 sin16s_gen::$2 ] ] with [ zp[2]:111 [ sin16s::usinx#0 ] ] - score: 1
Coalescing zero page register [ zp[2]:26 [ mulu16_sel::v1#5 mulu16_sel::v1#3 mulu16_sel::v1#4 mulu16_sel::v1#0 mulu16_sel::v1#1 mulu16_sel::v1#2 sin16s::x3#0 sin16s::x2#0 sin16s::x4#0 ] ] with [ zp[2]:103 [ mulu16_sel::return#1 ] ] - score: 1
Coalescing zero page register [ zp[2]:26 [ mulu16_sel::v1#5 mulu16_sel::v1#3 mulu16_sel::v1#4 mulu16_sel::v1#0 mulu16_sel::v1#1 mulu16_sel::v1#2 sin16s::x3#0 sin16s::x2#0 sin16s::x4#0 mulu16_sel::return#1 ] ] with [ zp[2]:113 [ mulu16_sel::return#10 ] ] - score: 1
Coalescing zero page register [ zp[4]:33 [ mul16u::res#2 mul16u::res#6 mul16u::res#1 mul16u::return#2 ] ] with [ zp[4]:131 [ mulu16_sel::$0 mulu16_sel::$1 ] ] - score: 1
Coalescing zero page register [ zp[2]:45 [ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 divr16u::return#3 divr16u::return#4 divr16u::return#2 ] ] with [ zp[2]:148 [ div32u16u::quotient_lo#0 ] ] - score: 1
Coalescing zero page register [ zp[2]:45 [ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 divr16u::return#3 divr16u::return#4 divr16u::return#2 div32u16u::quotient_lo#0 ] ] with [ zp[2]:158 [ div16u::return#2 sin8s_gen::step#0 div16u::return#0 ] ] - score: 1
Coalescing zero page register [ zp[2]:63 [ mul8u::res#2 mul8u::res#6 mul8u::res#1 mul8u::return#2 ] ] with [ zp[2]:182 [ mulu8_sel::$0 mulu8_sel::$1 ] ] - score: 1
Coalescing zero page register [ zp[2]:68 [ main::$3 main::$11 ] ] with [ zp[2]:72 [ main::$4 main::sw#0 ] ] - score: 1
Coalescing zero page register [ zp[2]:99 [ mulu16_sel::return#0 mulu16_sel::return#12 ] ] with [ zp[2]:107 [ mulu16_sel::return#2 sin16s::x3_6#0 ] ] - score: 1
Coalescing zero page register [ zp[2]:99 [ mulu16_sel::return#0 mulu16_sel::return#12 mulu16_sel::return#2 sin16s::x3_6#0 ] ] with [ zp[2]:117 [ mulu16_sel::return#11 sin16s::x5#0 ] ] - score: 1
Coalescing zero page register [ zp[2]:99 [ mulu16_sel::return#0 mulu16_sel::return#12 mulu16_sel::return#2 sin16s::x3_6#0 mulu16_sel::return#11 sin16s::x5#0 ] ] with [ zp[2]:121 [ sin16s::x5_128#0 ] ] - score: 1
Coalescing zero page register [ zp[2]:9 [ memset::dst#2 memset::dst#1 ] ] with [ zp[2]:3 [ print_str::str#2 print_str::str#0 ] ]
Coalescing zero page register [ zp[2]:11 [ sin16s_gen::i#2 sin16s_gen::i#1 ] ] with [ zp[2]:7 [ print_char_cursor#28 print_char_cursor#42 print_char_cursor#19 print_char_cursor#10 print_char_cursor#1 ] ]
Coalescing zero page register [ zp[4]:33 [ mul16u::res#2 mul16u::res#6 mul16u::res#1 mul16u::return#2 mulu16_sel::$0 mulu16_sel::$1 ] ] with [ zp[4]:20 [ sin16s::x#6 sin16s::x#4 sin16s::x#0 sin16s::x#1 sin16s::x#2 ] ]
Coalescing zero page register [ zp[2]:41 [ divr16u::rem#6 divr16u::rem#11 divr16u::rem#5 divr16u::rem#10 divr16u::rem#7 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 rem16u#1 ] ] with [ zp[2]:17 [ sin16s_gen::sintab#2 sin16s_gen::sintab#0 ] ]
Coalescing zero page register [ zp[2]:43 [ divr16u::dividend#4 divr16u::dividend#6 divr16u::dividend#0 ] ] with [ zp[2]:24 [ sin16s::return#1 sin16s::return#5 sin16s::sinx#1 sin16s::usinx#1 sin16s::return#0 sin16s_gen::$2 sin16s::usinx#0 ] ]
Coalescing zero page register [ zp[2]:45 [ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 divr16u::return#3 divr16u::return#4 divr16u::return#2 div32u16u::quotient_lo#0 div16u::return#2 sin8s_gen::step#0 div16u::return#0 ] ] with [ zp[2]:26 [ mulu16_sel::v1#5 mulu16_sel::v1#3 mulu16_sel::v1#4 mulu16_sel::v1#0 mulu16_sel::v1#1 mulu16_sel::v1#2 sin16s::x3#0 sin16s::x2#0 sin16s::x4#0 mulu16_sel::return#1 mulu16_sel::return#10 ] ]
Coalescing zero page register [ zp[2]:48 [ sin8s_gen::i#2 sin8s_gen::i#1 ] ] with [ zp[2]:28 [ mulu16_sel::v2#5 mulu16_sel::v2#3 mulu16_sel::v2#4 mulu16_sel::v2#0 mulu16_sel::v2#1 mul16u::b#0 ] ]
Coalescing zero page register [ zp[2]:50 [ sin8s_gen::x#2 sin8s_gen::x#1 ] ] with [ zp[2]:31 [ mul16u::a#2 mul16u::a#1 mul16u::a#0 ] ]
Coalescing zero page register [ zp[1]:54 [ sin8s::isUpper#10 ] ] with [ zp[1]:5 [ print_sbyte::b#4 print_sbyte::b#0 print_sbyte::b#1 print_byte::b#0 ] ]
Coalescing zero page register [ zp[2]:63 [ mul8u::res#2 mul8u::res#6 mul8u::res#1 mul8u::return#2 mulu8_sel::$0 mulu8_sel::$1 ] ] with [ zp[2]:55 [ sin8s::x#6 sin8s::x#4 sin8s::x#0 sin8s::x#1 sin8s::x#2 sin8s::$4 ] ]
Coalescing zero page register [ zp[1]:67 [ main::sb#0 ] ] with [ zp[1]:61 [ mulu8_sel::select#5 ] ]
Coalescing zero page register [ zp[2]:68 [ main::$3 main::$11 main::$4 main::sw#0 ] ] with [ zp[2]:52 [ sin8s_gen::sintab#2 sin8s_gen::sintab#0 ] ]
Coalescing zero page register [ zp[4]:93 [ sin16s::$4 ] ] with [ zp[4]:37 [ mul16u::mb#2 mul16u::mb#0 mul16u::mb#1 ] ]
Coalescing zero page register [ zp[2]:97 [ sin16s::x1#0 ] ] with [ zp[2]:65 [ mul8u::mb#2 mul8u::mb#0 mul8u::mb#1 ] ]
Coalescing zero page register [ zp[2]:144 [ div32u16u::quotient_hi#0 ] ] with [ zp[2]:99 [ mulu16_sel::return#0 mulu16_sel::return#12 mulu16_sel::return#2 sin16s::x3_6#0 mulu16_sel::return#11 sin16s::x5#0 sin16s::x5_128#0 ] ]
Coalescing zero page register [ zp[2]:41 [ divr16u::rem#6 divr16u::rem#11 divr16u::rem#5 divr16u::rem#10 divr16u::rem#7 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 rem16u#1 sin16s_gen::sintab#2 sin16s_gen::sintab#0 ] ] with [ zp[2]:9 [ memset::dst#2 memset::dst#1 print_str::str#2 print_str::str#0 ] ]
Coalescing zero page register [ zp[2]:63 [ mul8u::res#2 mul8u::res#6 mul8u::res#1 mul8u::return#2 mulu8_sel::$0 mulu8_sel::$1 sin8s::x#6 sin8s::x#4 sin8s::x#0 sin8s::x#1 sin8s::x#2 sin8s::$4 ] ] with [ zp[2]:11 [ sin16s_gen::i#2 sin16s_gen::i#1 print_char_cursor#28 print_char_cursor#42 print_char_cursor#19 print_char_cursor#10 print_char_cursor#1 ] ]
Coalescing zero page register [ zp[2]:68 [ main::$3 main::$11 main::$4 main::sw#0 sin8s_gen::sintab#2 sin8s_gen::sintab#0 ] ] with [ zp[2]:43 [ divr16u::dividend#4 divr16u::dividend#6 divr16u::dividend#0 sin16s::return#1 sin16s::return#5 sin16s::sinx#1 sin16s::usinx#1 sin16s::return#0 sin16s_gen::$2 sin16s::usinx#0 ] ]
Coalescing zero page register [ zp[2]:144 [ div32u16u::quotient_hi#0 mulu16_sel::return#0 mulu16_sel::return#12 mulu16_sel::return#2 sin16s::x3_6#0 mulu16_sel::return#11 sin16s::x5#0 sin16s::x5_128#0 ] ] with [ zp[2]:50 [ sin8s_gen::x#2 sin8s_gen::x#1 mul16u::a#2 mul16u::a#1 mul16u::a#0 ] ]
Allocated (was zp[4]:13) zp[4]:2 [ sin16s_gen::x#2 sin16s_gen::x#1 ]
Allocated (was zp[4]:33) zp[4]:6 [ mul16u::res#2 mul16u::res#6 mul16u::res#1 mul16u::return#2 mulu16_sel::$0 mulu16_sel::$1 sin16s::x#6 sin16s::x#4 sin16s::x#0 sin16s::x#1 sin16s::x#2 ]
Allocated (was zp[2]:41) zp[2]:10 [ divr16u::rem#6 divr16u::rem#11 divr16u::rem#5 divr16u::rem#10 divr16u::rem#7 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 rem16u#1 sin16s_gen::sintab#2 sin16s_gen::sintab#0 memset::dst#2 memset::dst#1 print_str::str#2 print_str::str#0 ]
Allocated (was zp[2]:45) zp[2]:12 [ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 divr16u::return#3 divr16u::return#4 divr16u::return#2 div32u16u::quotient_lo#0 div16u::return#2 sin8s_gen::step#0 div16u::return#0 mulu16_sel::v1#5 mulu16_sel::v1#3 mulu16_sel::v1#4 mulu16_sel::v1#0 mulu16_sel::v1#1 mulu16_sel::v1#2 sin16s::x3#0 sin16s::x2#0 sin16s::x4#0 mulu16_sel::return#1 mulu16_sel::return#10 ]
Allocated (was zp[2]:48) zp[2]:14 [ sin8s_gen::i#2 sin8s_gen::i#1 mulu16_sel::v2#5 mulu16_sel::v2#3 mulu16_sel::v2#4 mulu16_sel::v2#0 mulu16_sel::v2#1 mul16u::b#0 ]
Allocated (was zp[1]:54) zp[1]:16 [ sin8s::isUpper#10 print_sbyte::b#4 print_sbyte::b#0 print_sbyte::b#1 print_byte::b#0 ]
Allocated (was zp[2]:63) zp[2]:17 [ mul8u::res#2 mul8u::res#6 mul8u::res#1 mul8u::return#2 mulu8_sel::$0 mulu8_sel::$1 sin8s::x#6 sin8s::x#4 sin8s::x#0 sin8s::x#1 sin8s::x#2 sin8s::$4 sin16s_gen::i#2 sin16s_gen::i#1 print_char_cursor#28 print_char_cursor#42 print_char_cursor#19 print_char_cursor#10 print_char_cursor#1 ]
Allocated (was zp[1]:67) zp[1]:19 [ main::sb#0 mulu8_sel::select#5 ]
Allocated (was zp[2]:68) zp[2]:20 [ main::$3 main::$11 main::$4 main::sw#0 sin8s_gen::sintab#2 sin8s_gen::sintab#0 divr16u::dividend#4 divr16u::dividend#6 divr16u::dividend#0 sin16s::return#1 sin16s::return#5 sin16s::sinx#1 sin16s::usinx#1 sin16s::return#0 sin16s_gen::$2 sin16s::usinx#0 ]
Allocated (was zp[4]:81) zp[4]:22 [ div32u16u::return#2 sin16s_gen::step#0 div32u16u::return#0 ]
Allocated (was zp[4]:93) zp[4]:26 [ sin16s::$4 mul16u::mb#2 mul16u::mb#0 mul16u::mb#1 ]
Allocated (was zp[2]:97) zp[2]:30 [ sin16s::x1#0 mul8u::mb#2 mul8u::mb#0 mul8u::mb#1 ]
Allocated (was zp[2]:144) zp[2]:32 [ div32u16u::quotient_hi#0 mulu16_sel::return#0 mulu16_sel::return#12 mulu16_sel::return#2 sin16s::x3_6#0 mulu16_sel::return#11 sin16s::x5#0 sin16s::x5_128#0 sin8s_gen::x#2 sin8s_gen::x#1 mul16u::a#2 mul16u::a#1 mul16u::a#0 ]
Allocated (was zp[1]:166) zp[1]:34 [ sin8s::x1#0 ]
Allocated (was zp[1]:170) zp[1]:35 [ sin8s::x3#0 ]
Allocated (was zp[1]:173) zp[1]:36 [ sin8s::usinx#0 ]

ASSEMBLER BEFORE OPTIMIZATION
  // File Comments
  // Upstart
.pc = $801 "Basic"
:BasicUpstart(__bbegin)
.pc = $80d "Program"
  // Global Constants & labels
  // PI*2 in u[4.28] format
  .const PI2_u4f28 = $6487ed51
  // PI in u[4.28] format
  .const PI_u4f28 = $3243f6a9
  // PI/2 in u[4.28] format
  .const PI_HALF_u4f28 = $1921fb54
  // PI*2 in u[4.12] format
  .const PI2_u4f12 = $6488
  // PI in u[4.12] format
  .const PI_u4f12 = $3244
  // PI/2 in u[4.12] format
  .const PI_HALF_u4f12 = $1922
  .const SIZEOF_SIGNED_WORD = 2
  .label print_line_cursor = $400
  // Remainder after unsigned 16-bit division
  .label rem16u = $a
  .label print_char_cursor = $11
  // @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 wavelength = $c0
    .label __3 = $14
    .label __4 = $14
    .label __11 = $14
    .label sb = $13
    .label sw = $14
    // [5] call sin8s_gen 
    // [164] phi from main to sin8s_gen [phi:main->sin8s_gen]
  sin8s_gen_from_main:
    jsr sin8s_gen
    // [6] phi from main to main::@2 [phi:main->main::@2]
  __b2_from_main:
    jmp __b2
    // main::@2
  __b2:
    // [7] call sin16s_gen 
    // [62] phi from main::@2 to sin16s_gen [phi:main::@2->sin16s_gen]
  sin16s_gen_from___b2:
    jsr sin16s_gen
    // [8] phi from main::@2 to main::@3 [phi:main::@2->main::@3]
  __b3_from___b2:
    jmp __b3
    // main::@3
  __b3:
    // [9] call print_cls 
    // [53] phi from main::@3 to print_cls [phi:main::@3->print_cls]
  print_cls_from___b3:
    jsr print_cls
    // [10] phi from main::@3 to main::@1 [phi:main::@3->main::@1]
  __b1_from___b3:
    // [10] phi (byte*) print_char_cursor#42 = (const byte*) print_line_cursor#0 [phi:main::@3->main::@1#0] -- pbuz1=pbuc1 
    lda #<print_line_cursor
    sta.z print_char_cursor
    lda #>print_line_cursor
    sta.z print_char_cursor+1
    // [10] phi (byte) main::i#2 = (byte) 0 [phi:main::@3->main::@1#1] -- vbuxx=vbuc1 
    ldx #0
    jmp __b1
    // [10] phi from main::@5 to main::@1 [phi:main::@5->main::@1]
  __b1_from___b5:
    // [10] phi (byte*) print_char_cursor#42 = (byte*) print_char_cursor#19 [phi:main::@5->main::@1#0] -- register_copy 
    // [10] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@5->main::@1#1] -- register_copy 
    jmp __b1
    // main::@1
  __b1:
    // [11] (signed byte) main::sb#0 ← *((const signed byte*) main::sintabb + (byte) main::i#2) -- vbsz1=pbsc1_derefidx_vbuxx 
    lda sintabb,x
    sta.z sb
    // [12] (word~) main::$3 ← (word)(byte) main::i#2 -- vwuz1=_word_vbuxx 
    txa
    sta.z __3
    lda #0
    sta.z __3+1
    // [13] (word~) main::$11 ← (word~) main::$3 << (byte) 1 -- vwuz1=vwuz1_rol_1 
    asl.z __11
    rol.z __11+1
    // [14] (signed word*~) main::$4 ← (const signed word*) main::sintabw + (word~) main::$11 -- pwsz1=pwsc1_plus_vwuz1 
    clc
    lda.z __4
    adc #<sintabw
    sta.z __4
    lda.z __4+1
    adc #>sintabw
    sta.z __4+1
    // [15] (signed word) main::sw#0 ← *((signed word*~) main::$4) -- vwsz1=_deref_pwsz1 
    ldy #0
    lda (sw),y
    pha
    iny
    lda (sw),y
    sta.z sw+1
    pla
    sta.z sw
    // [16] (byte~) main::$6 ← > (signed word) main::sw#0 -- vbuaa=_hi_vwsz1 
    lda.z sw+1
    // [17] (signed byte) main::sd#0 ← (signed byte) main::sb#0 - (signed byte)(byte~) main::$6 -- vbsaa=vbsz1_minus_vbsaa 
    eor #$ff
    sec
    adc.z sb
    // [18] (signed byte) print_sbyte::b#1 ← (signed byte) main::sd#0 -- vbsz1=vbsaa 
    sta.z print_sbyte.b
    // [19] call print_sbyte 
    jsr print_sbyte
    // [20] phi from main::@1 to main::@4 [phi:main::@1->main::@4]
  __b4_from___b1:
    jmp __b4
    // main::@4
  __b4:
    // [21] call print_str 
    // [25] phi from main::@4 to print_str [phi:main::@4->print_str]
  print_str_from___b4:
    jsr print_str
    jmp __b5
    // main::@5
  __b5:
    // [22] (byte) main::i#1 ← ++ (byte) main::i#2 -- vbuxx=_inc_vbuxx 
    inx
    // [23] if((byte) main::i#1!=(byte) $c0) goto main::@1 -- vbuxx_neq_vbuc1_then_la1 
    cpx #$c0
    bne __b1_from___b5
    jmp __breturn
    // main::@return
  __breturn:
    // [24] return 
    rts
    sintabb: .fill $c0, 0
    sintabw: .fill 2*$c0, 0
    str: .text "  "
    .byte 0
}
  // print_str
// Print a zero-terminated string
// print_str(byte* zp($a) str)
print_str: {
    .label str = $a
    // [26] phi from print_str to print_str::@1 [phi:print_str->print_str::@1]
  __b1_from_print_str:
    // [26] phi (byte*) print_char_cursor#19 = (byte*) print_char_cursor#10 [phi:print_str->print_str::@1#0] -- register_copy 
    // [26] phi (byte*) print_str::str#2 = (const byte*) main::str [phi:print_str->print_str::@1#1] -- pbuz1=pbuc1 
    lda #<main.str
    sta.z str
    lda #>main.str
    sta.z str+1
    jmp __b1
    // print_str::@1
  __b1:
    // [27] if((byte) 0!=*((byte*) print_str::str#2)) 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:
    // [28] return 
    rts
    // print_str::@2
  __b2:
    // [29] *((byte*) print_char_cursor#19) ← *((byte*) print_str::str#2) -- _deref_pbuz1=_deref_pbuz2 
    ldy #0
    lda (str),y
    ldy #0
    sta (print_char_cursor),y
    // [30] (byte*) print_char_cursor#1 ← ++ (byte*) print_char_cursor#19 -- pbuz1=_inc_pbuz1 
    inc.z print_char_cursor
    bne !+
    inc.z print_char_cursor+1
  !:
    // [31] (byte*) print_str::str#0 ← ++ (byte*) print_str::str#2 -- pbuz1=_inc_pbuz1 
    inc.z str
    bne !+
    inc.z str+1
  !:
    // [26] phi from print_str::@2 to print_str::@1 [phi:print_str::@2->print_str::@1]
  __b1_from___b2:
    // [26] phi (byte*) print_char_cursor#19 = (byte*) print_char_cursor#1 [phi:print_str::@2->print_str::@1#0] -- register_copy 
    // [26] phi (byte*) print_str::str#2 = (byte*) print_str::str#0 [phi:print_str::@2->print_str::@1#1] -- register_copy 
    jmp __b1
}
  // print_sbyte
// Print a signed byte as HEX
// print_sbyte(signed byte zp($10) b)
print_sbyte: {
    .label b = $10
    // [32] if((signed byte) print_sbyte::b#1<(signed byte) 0) goto print_sbyte::@1 -- vbsz1_lt_0_then_la1 
    lda.z b
    bmi __b1_from_print_sbyte
    // [33] phi from print_sbyte to print_sbyte::@3 [phi:print_sbyte->print_sbyte::@3]
  __b3_from_print_sbyte:
    jmp __b3
    // print_sbyte::@3
  __b3:
    // [34] call print_char 
    // [42] phi from print_sbyte::@3 to print_char [phi:print_sbyte::@3->print_char]
  print_char_from___b3:
    // [42] phi (byte*) print_char_cursor#28 = (byte*) print_char_cursor#42 [phi:print_sbyte::@3->print_char#0] -- register_copy 
    // [42] phi (byte) print_char::ch#4 = (byte) ' ' [phi:print_sbyte::@3->print_char#1] -- vbuaa=vbuc1 
    lda #' '
    jsr print_char
    // [35] phi from print_sbyte::@3 print_sbyte::@4 to print_sbyte::@2 [phi:print_sbyte::@3/print_sbyte::@4->print_sbyte::@2]
  __b2_from___b3:
  __b2_from___b4:
    // [35] phi (signed byte) print_sbyte::b#4 = (signed byte) print_sbyte::b#1 [phi:print_sbyte::@3/print_sbyte::@4->print_sbyte::@2#0] -- register_copy 
    jmp __b2
    // print_sbyte::@2
  __b2:
    // [36] (byte) print_byte::b#0 ← (byte)(signed byte) print_sbyte::b#4
    // [37] call print_byte 
    jsr print_byte
    jmp __breturn
    // print_sbyte::@return
  __breturn:
    // [38] return 
    rts
    // [39] phi from print_sbyte to print_sbyte::@1 [phi:print_sbyte->print_sbyte::@1]
  __b1_from_print_sbyte:
    jmp __b1
    // print_sbyte::@1
  __b1:
    // [40] call print_char 
    // [42] phi from print_sbyte::@1 to print_char [phi:print_sbyte::@1->print_char]
  print_char_from___b1:
    // [42] phi (byte*) print_char_cursor#28 = (byte*) print_char_cursor#42 [phi:print_sbyte::@1->print_char#0] -- register_copy 
    // [42] phi (byte) print_char::ch#4 = (byte) '-' [phi:print_sbyte::@1->print_char#1] -- vbuaa=vbuc1 
    lda #'-'
    jsr print_char
    jmp __b4
    // print_sbyte::@4
  __b4:
    // [41] (signed byte) print_sbyte::b#0 ← - (signed byte) print_sbyte::b#1 -- vbsz1=_neg_vbsz1 
    lda.z b
    eor #$ff
    clc
    adc #1
    sta.z b
    jmp __b2_from___b4
}
  // print_char
// Print a single char
// print_char(byte register(A) ch)
print_char: {
    // [43] *((byte*) print_char_cursor#28) ← (byte) print_char::ch#4 -- _deref_pbuz1=vbuaa 
    ldy #0
    sta (print_char_cursor),y
    // [44] (byte*) print_char_cursor#10 ← ++ (byte*) print_char_cursor#28 -- pbuz1=_inc_pbuz1 
    inc.z print_char_cursor
    bne !+
    inc.z print_char_cursor+1
  !:
    jmp __breturn
    // print_char::@return
  __breturn:
    // [45] return 
    rts
}
  // print_byte
// Print a byte as HEX
// print_byte(byte zp($10) b)
print_byte: {
    .label b = $10
    // [46] (byte~) print_byte::$0 ← (byte) print_byte::b#0 >> (byte) 4 -- vbuaa=vbuz1_ror_4 
    lda.z b
    lsr
    lsr
    lsr
    lsr
    // [47] (byte) print_char::ch#2 ← *((const byte*) print_hextab + (byte~) print_byte::$0) -- vbuaa=pbuc1_derefidx_vbuaa 
    tay
    lda print_hextab,y
    // [48] call print_char 
    // [42] phi from print_byte to print_char [phi:print_byte->print_char]
  print_char_from_print_byte:
    // [42] phi (byte*) print_char_cursor#28 = (byte*) print_char_cursor#10 [phi:print_byte->print_char#0] -- register_copy 
    // [42] phi (byte) print_char::ch#4 = (byte) print_char::ch#2 [phi:print_byte->print_char#1] -- register_copy 
    jsr print_char
    jmp __b1
    // print_byte::@1
  __b1:
    // [49] (byte~) print_byte::$2 ← (byte) print_byte::b#0 & (byte) $f -- vbuaa=vbuz1_band_vbuc1 
    lda #$f
    and.z b
    // [50] (byte) print_char::ch#3 ← *((const byte*) print_hextab + (byte~) print_byte::$2) -- vbuaa=pbuc1_derefidx_vbuaa 
    tay
    lda print_hextab,y
    // [51] call print_char 
    // [42] phi from print_byte::@1 to print_char [phi:print_byte::@1->print_char]
  print_char_from___b1:
    // [42] phi (byte*) print_char_cursor#28 = (byte*) print_char_cursor#10 [phi:print_byte::@1->print_char#0] -- register_copy 
    // [42] phi (byte) print_char::ch#4 = (byte) print_char::ch#3 [phi:print_byte::@1->print_char#1] -- register_copy 
    jsr print_char
    jmp __breturn
    // print_byte::@return
  __breturn:
    // [52] return 
    rts
}
  // print_cls
// Clear the screen. Also resets current line/char cursor.
print_cls: {
    // [54] call memset 
    // [56] phi from print_cls to memset [phi:print_cls->memset]
  memset_from_print_cls:
    jsr memset
    jmp __breturn
    // print_cls::@return
  __breturn:
    // [55] 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 = print_line_cursor
    .label end = str+num
    .label dst = $a
    // [57] phi from memset to memset::@1 [phi:memset->memset::@1]
  __b1_from_memset:
    // [57] 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:
    // [58] 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:
    // [59] return 
    rts
    // memset::@2
  __b2:
    // [60] *((byte*) memset::dst#2) ← (const byte) memset::c#0 -- _deref_pbuz1=vbuc1 
    lda #c
    ldy #0
    sta (dst),y
    // [61] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2 -- pbuz1=_inc_pbuz1 
    inc.z dst
    bne !+
    inc.z dst+1
  !:
    // [57] phi from memset::@2 to memset::@1 [phi:memset::@2->memset::@1]
  __b1_from___b2:
    // [57] phi (byte*) memset::dst#2 = (byte*) memset::dst#1 [phi:memset::@2->memset::@1#0] -- register_copy 
    jmp __b1
}
  // sin16s_gen
// Generate signed (large) word sinus table - on the full -$7fff - $7fff range
// sintab - the table to generate into
// wavelength - the number of sinus points in a total sinus wavelength (the size of the table)
// sin16s_gen(signed word* zp($a) sintab)
sin16s_gen: {
    .label __2 = $14
    .label step = $16
    .label sintab = $a
    // u[4.28]
    // Iterate over the table
    .label x = 2
    .label i = $11
    // [63] call div32u16u 
    // [136] phi from sin16s_gen to div32u16u [phi:sin16s_gen->div32u16u]
  div32u16u_from_sin16s_gen:
    jsr div32u16u
    // [64] (dword) div32u16u::return#2 ← (dword) div32u16u::return#0
    jmp __b3
    // sin16s_gen::@3
  __b3:
    // [65] (dword) sin16s_gen::step#0 ← (dword) div32u16u::return#2
    // [66] phi from sin16s_gen::@3 to sin16s_gen::@1 [phi:sin16s_gen::@3->sin16s_gen::@1]
  __b1_from___b3:
    // [66] phi (signed word*) sin16s_gen::sintab#2 = (const signed word*) main::sintabw [phi:sin16s_gen::@3->sin16s_gen::@1#0] -- pwsz1=pwsc1 
    lda #<main.sintabw
    sta.z sintab
    lda #>main.sintabw
    sta.z sintab+1
    // [66] phi (dword) sin16s_gen::x#2 = (dword) 0 [phi:sin16s_gen::@3->sin16s_gen::@1#1] -- vduz1=vduc1 
    lda #<0
    sta.z x
    lda #>0
    sta.z x+1
    lda #<0>>$10
    sta.z x+2
    lda #>0>>$10
    sta.z x+3
    // [66] phi (word) sin16s_gen::i#2 = (word) 0 [phi:sin16s_gen::@3->sin16s_gen::@1#2] -- vwuz1=vwuc1 
    lda #<0
    sta.z i
    lda #>0
    sta.z i+1
    jmp __b1
  // u[4.28]
    // sin16s_gen::@1
  __b1:
    // [67] if((word) sin16s_gen::i#2<(const word) main::wavelength) goto sin16s_gen::@2 -- vwuz1_lt_vwuc1_then_la1 
    lda.z i+1
    cmp #>main.wavelength
    bcc __b2
    bne !+
    lda.z i
    cmp #<main.wavelength
    bcc __b2
  !:
    jmp __breturn
    // sin16s_gen::@return
  __breturn:
    // [68] return 
    rts
    // sin16s_gen::@2
  __b2:
    // [69] (dword) sin16s::x#0 ← (dword) sin16s_gen::x#2 -- vduz1=vduz2 
    lda.z x
    sta.z sin16s.x
    lda.z x+1
    sta.z sin16s.x+1
    lda.z x+2
    sta.z sin16s.x+2
    lda.z x+3
    sta.z sin16s.x+3
    // [70] call sin16s 
    jsr sin16s
    // [71] (signed word) sin16s::return#0 ← (signed word) sin16s::return#1
    jmp __b4
    // sin16s_gen::@4
  __b4:
    // [72] (signed word~) sin16s_gen::$2 ← (signed word) sin16s::return#0
    // [73] *((signed word*) sin16s_gen::sintab#2) ← (signed word~) sin16s_gen::$2 -- _deref_pwsz1=vwsz2 
    ldy #0
    lda.z __2
    sta (sintab),y
    iny
    lda.z __2+1
    sta (sintab),y
    // [74] (signed word*) sin16s_gen::sintab#0 ← (signed word*) sin16s_gen::sintab#2 + (const byte) SIZEOF_SIGNED_WORD -- pwsz1=pwsz1_plus_vbuc1 
    lda #SIZEOF_SIGNED_WORD
    clc
    adc.z sintab
    sta.z sintab
    bcc !+
    inc.z sintab+1
  !:
    // [75] (dword) sin16s_gen::x#1 ← (dword) sin16s_gen::x#2 + (dword) sin16s_gen::step#0 -- vduz1=vduz1_plus_vduz2 
    lda.z x
    clc
    adc.z step
    sta.z x
    lda.z x+1
    adc.z step+1
    sta.z x+1
    lda.z x+2
    adc.z step+2
    sta.z x+2
    lda.z x+3
    adc.z step+3
    sta.z x+3
    // [76] (word) sin16s_gen::i#1 ← ++ (word) sin16s_gen::i#2 -- vwuz1=_inc_vwuz1 
    inc.z i
    bne !+
    inc.z i+1
  !:
    // [66] phi from sin16s_gen::@4 to sin16s_gen::@1 [phi:sin16s_gen::@4->sin16s_gen::@1]
  __b1_from___b4:
    // [66] phi (signed word*) sin16s_gen::sintab#2 = (signed word*) sin16s_gen::sintab#0 [phi:sin16s_gen::@4->sin16s_gen::@1#0] -- register_copy 
    // [66] phi (dword) sin16s_gen::x#2 = (dword) sin16s_gen::x#1 [phi:sin16s_gen::@4->sin16s_gen::@1#1] -- register_copy 
    // [66] phi (word) sin16s_gen::i#2 = (word) sin16s_gen::i#1 [phi:sin16s_gen::@4->sin16s_gen::@1#2] -- register_copy 
    jmp __b1
}
  // sin16s
// Calculate signed word sinus sin(x)
// x: unsigned dword input u[4.28] in the interval $00000000 - PI2_u4f28
// result: signed word sin(x) s[0.15] - using the full range  -$7fff - $7fff
// sin16s(dword zp(6) x)
sin16s: {
    .label __4 = $1a
    .label x = 6
    .label return = $14
    .label x1 = $1e
    .label x2 = $c
    .label x3 = $c
    .label x3_6 = $20
    .label usinx = $14
    .label x4 = $c
    .label x5 = $20
    .label x5_128 = $20
    .label sinx = $14
    // [77] if((dword) sin16s::x#0<(const dword) PI_u4f28) goto sin16s::@1 -- vduz1_lt_vduc1_then_la1 
    lda.z x+3
    cmp #>PI_u4f28>>$10
    bcc __b1_from_sin16s
    bne !+
    lda.z x+2
    cmp #<PI_u4f28>>$10
    bcc __b1_from_sin16s
    bne !+
    lda.z x+1
    cmp #>PI_u4f28
    bcc __b1_from_sin16s
    bne !+
    lda.z x
    cmp #<PI_u4f28
    bcc __b1_from_sin16s
  !:
    jmp __b4
    // sin16s::@4
  __b4:
    // [78] (dword) sin16s::x#1 ← (dword) sin16s::x#0 - (const dword) PI_u4f28 -- vduz1=vduz1_minus_vduc1 
    lda.z x
    sec
    sbc #<PI_u4f28
    sta.z x
    lda.z x+1
    sbc #>PI_u4f28
    sta.z x+1
    lda.z x+2
    sbc #<PI_u4f28>>$10
    sta.z x+2
    lda.z x+3
    sbc #>PI_u4f28>>$10
    sta.z x+3
    // [79] phi from sin16s::@4 to sin16s::@1 [phi:sin16s::@4->sin16s::@1]
  __b1_from___b4:
    // [79] phi (byte) sin16s::isUpper#2 = (byte) 1 [phi:sin16s::@4->sin16s::@1#0] -- vbuyy=vbuc1 
    ldy #1
    // [79] phi (dword) sin16s::x#4 = (dword) sin16s::x#1 [phi:sin16s::@4->sin16s::@1#1] -- register_copy 
    jmp __b1
    // [79] phi from sin16s to sin16s::@1 [phi:sin16s->sin16s::@1]
  __b1_from_sin16s:
    // [79] phi (byte) sin16s::isUpper#2 = (byte) 0 [phi:sin16s->sin16s::@1#0] -- vbuyy=vbuc1 
    ldy #0
    // [79] phi (dword) sin16s::x#4 = (dword) sin16s::x#0 [phi:sin16s->sin16s::@1#1] -- register_copy 
    jmp __b1
    // sin16s::@1
  __b1:
    // [80] if((dword) sin16s::x#4<(const dword) PI_HALF_u4f28) goto sin16s::@2 -- vduz1_lt_vduc1_then_la1 
    lda.z x+3
    cmp #>PI_HALF_u4f28>>$10
    bcc __b2_from___b1
    bne !+
    lda.z x+2
    cmp #<PI_HALF_u4f28>>$10
    bcc __b2_from___b1
    bne !+
    lda.z x+1
    cmp #>PI_HALF_u4f28
    bcc __b2_from___b1
    bne !+
    lda.z x
    cmp #<PI_HALF_u4f28
    bcc __b2_from___b1
  !:
    jmp __b5
    // sin16s::@5
  __b5:
    // [81] (dword) sin16s::x#2 ← (const dword) PI_u4f28 - (dword) sin16s::x#4 -- vduz1=vduc1_minus_vduz1 
    lda #<PI_u4f28
    sec
    sbc.z x
    sta.z x
    lda #>PI_u4f28
    sbc.z x+1
    sta.z x+1
    lda #<PI_u4f28>>$10
    sbc.z x+2
    sta.z x+2
    lda #>PI_u4f28>>$10
    sbc.z x+3
    sta.z x+3
    // [82] phi from sin16s::@1 sin16s::@5 to sin16s::@2 [phi:sin16s::@1/sin16s::@5->sin16s::@2]
  __b2_from___b1:
  __b2_from___b5:
    // [82] phi (dword) sin16s::x#6 = (dword) sin16s::x#4 [phi:sin16s::@1/sin16s::@5->sin16s::@2#0] -- register_copy 
    jmp __b2
    // sin16s::@2
  __b2:
    // [83] (dword~) sin16s::$4 ← (dword) sin16s::x#6 << (byte) 3 -- vduz1=vduz2_rol_3 
    lda.z x
    asl
    sta.z __4
    lda.z x+1
    rol
    sta.z __4+1
    lda.z x+2
    rol
    sta.z __4+2
    lda.z x+3
    rol
    sta.z __4+3
    asl.z __4
    rol.z __4+1
    rol.z __4+2
    rol.z __4+3
    asl.z __4
    rol.z __4+1
    rol.z __4+2
    rol.z __4+3
    // [84] (word) sin16s::x1#0 ← > (dword~) sin16s::$4 -- vwuz1=_hi_vduz2 
    lda.z __4+2
    sta.z x1
    lda.z __4+3
    sta.z x1+1
    // [85] (word) mulu16_sel::v1#0 ← (word) sin16s::x1#0 -- vwuz1=vwuz2 
    lda.z x1
    sta.z mulu16_sel.v1
    lda.z x1+1
    sta.z mulu16_sel.v1+1
    // [86] (word) mulu16_sel::v2#0 ← (word) sin16s::x1#0 -- vwuz1=vwuz2 
    lda.z x1
    sta.z mulu16_sel.v2
    lda.z x1+1
    sta.z mulu16_sel.v2+1
    // [87] call mulu16_sel 
    // [117] phi from sin16s::@2 to mulu16_sel [phi:sin16s::@2->mulu16_sel]
  mulu16_sel_from___b2:
    // [117] phi (byte) mulu16_sel::select#5 = (byte) 0 [phi:sin16s::@2->mulu16_sel#0] -- vbuxx=vbuc1 
    ldx #0
    // [117] phi (word) mulu16_sel::v2#5 = (word) mulu16_sel::v2#0 [phi:sin16s::@2->mulu16_sel#1] -- register_copy 
    // [117] phi (word) mulu16_sel::v1#5 = (word) mulu16_sel::v1#0 [phi:sin16s::@2->mulu16_sel#2] -- register_copy 
    jsr mulu16_sel
    // [88] (word) mulu16_sel::return#0 ← (word) mulu16_sel::return#12
    jmp __b7
    // sin16s::@7
  __b7:
    // [89] (word) sin16s::x2#0 ← (word) mulu16_sel::return#0 -- vwuz1=vwuz2 
    lda.z mulu16_sel.return
    sta.z x2
    lda.z mulu16_sel.return+1
    sta.z x2+1
    // [90] (word) mulu16_sel::v1#1 ← (word) sin16s::x2#0
    // [91] (word) mulu16_sel::v2#1 ← (word) sin16s::x1#0 -- vwuz1=vwuz2 
    lda.z x1
    sta.z mulu16_sel.v2
    lda.z x1+1
    sta.z mulu16_sel.v2+1
    // [92] call mulu16_sel 
    // [117] phi from sin16s::@7 to mulu16_sel [phi:sin16s::@7->mulu16_sel]
  mulu16_sel_from___b7:
    // [117] phi (byte) mulu16_sel::select#5 = (byte) 1 [phi:sin16s::@7->mulu16_sel#0] -- vbuxx=vbuc1 
    ldx #1
    // [117] phi (word) mulu16_sel::v2#5 = (word) mulu16_sel::v2#1 [phi:sin16s::@7->mulu16_sel#1] -- register_copy 
    // [117] phi (word) mulu16_sel::v1#5 = (word) mulu16_sel::v1#1 [phi:sin16s::@7->mulu16_sel#2] -- register_copy 
    jsr mulu16_sel
    // [93] (word) mulu16_sel::return#1 ← (word) mulu16_sel::return#12 -- vwuz1=vwuz2 
    lda.z mulu16_sel.return
    sta.z mulu16_sel.return_1
    lda.z mulu16_sel.return+1
    sta.z mulu16_sel.return_1+1
    jmp __b8
    // sin16s::@8
  __b8:
    // [94] (word) sin16s::x3#0 ← (word) mulu16_sel::return#1
    // [95] (word) mulu16_sel::v1#2 ← (word) sin16s::x3#0
    // [96] call mulu16_sel 
    // [117] phi from sin16s::@8 to mulu16_sel [phi:sin16s::@8->mulu16_sel]
  mulu16_sel_from___b8:
    // [117] phi (byte) mulu16_sel::select#5 = (byte) 1 [phi:sin16s::@8->mulu16_sel#0] -- vbuxx=vbuc1 
    ldx #1
    // [117] phi (word) mulu16_sel::v2#5 = (word)(number) $10000/(number) 6 [phi:sin16s::@8->mulu16_sel#1] -- vwuz1=vwuc1 
    lda #<$10000/6
    sta.z mulu16_sel.v2
    lda #>$10000/6
    sta.z mulu16_sel.v2+1
    // [117] phi (word) mulu16_sel::v1#5 = (word) mulu16_sel::v1#2 [phi:sin16s::@8->mulu16_sel#2] -- register_copy 
    jsr mulu16_sel
    // [97] (word) mulu16_sel::return#2 ← (word) mulu16_sel::return#12
    jmp __b9
    // sin16s::@9
  __b9:
    // [98] (word) sin16s::x3_6#0 ← (word) mulu16_sel::return#2
    // [99] (word) sin16s::usinx#0 ← (word) sin16s::x1#0 - (word) sin16s::x3_6#0 -- vwuz1=vwuz2_minus_vwuz3 
    lda.z x1
    sec
    sbc.z x3_6
    sta.z usinx
    lda.z x1+1
    sbc.z x3_6+1
    sta.z usinx+1
    // [100] (word) mulu16_sel::v1#3 ← (word) sin16s::x3#0
    // [101] (word) mulu16_sel::v2#3 ← (word) sin16s::x1#0 -- vwuz1=vwuz2 
    lda.z x1
    sta.z mulu16_sel.v2
    lda.z x1+1
    sta.z mulu16_sel.v2+1
    // [102] call mulu16_sel 
    // [117] phi from sin16s::@9 to mulu16_sel [phi:sin16s::@9->mulu16_sel]
  mulu16_sel_from___b9:
    // [117] phi (byte) mulu16_sel::select#5 = (byte) 0 [phi:sin16s::@9->mulu16_sel#0] -- vbuxx=vbuc1 
    ldx #0
    // [117] phi (word) mulu16_sel::v2#5 = (word) mulu16_sel::v2#3 [phi:sin16s::@9->mulu16_sel#1] -- register_copy 
    // [117] phi (word) mulu16_sel::v1#5 = (word) mulu16_sel::v1#3 [phi:sin16s::@9->mulu16_sel#2] -- register_copy 
    jsr mulu16_sel
    // [103] (word) mulu16_sel::return#10 ← (word) mulu16_sel::return#12 -- vwuz1=vwuz2 
    lda.z mulu16_sel.return
    sta.z mulu16_sel.return_1
    lda.z mulu16_sel.return+1
    sta.z mulu16_sel.return_1+1
    jmp __b10
    // sin16s::@10
  __b10:
    // [104] (word) sin16s::x4#0 ← (word) mulu16_sel::return#10
    // [105] (word) mulu16_sel::v1#4 ← (word) sin16s::x4#0
    // [106] (word) mulu16_sel::v2#4 ← (word) sin16s::x1#0 -- vwuz1=vwuz2 
    lda.z x1
    sta.z mulu16_sel.v2
    lda.z x1+1
    sta.z mulu16_sel.v2+1
    // [107] call mulu16_sel 
    // [117] phi from sin16s::@10 to mulu16_sel [phi:sin16s::@10->mulu16_sel]
  mulu16_sel_from___b10:
    // [117] phi (byte) mulu16_sel::select#5 = (byte) 0 [phi:sin16s::@10->mulu16_sel#0] -- vbuxx=vbuc1 
    ldx #0
    // [117] phi (word) mulu16_sel::v2#5 = (word) mulu16_sel::v2#4 [phi:sin16s::@10->mulu16_sel#1] -- register_copy 
    // [117] phi (word) mulu16_sel::v1#5 = (word) mulu16_sel::v1#4 [phi:sin16s::@10->mulu16_sel#2] -- register_copy 
    jsr mulu16_sel
    // [108] (word) mulu16_sel::return#11 ← (word) mulu16_sel::return#12
    jmp __b11
    // sin16s::@11
  __b11:
    // [109] (word) sin16s::x5#0 ← (word) mulu16_sel::return#11
    // [110] (word) sin16s::x5_128#0 ← (word) sin16s::x5#0 >> (byte) 4 -- vwuz1=vwuz1_ror_4 
    lsr.z x5_128+1
    ror.z x5_128
    lsr.z x5_128+1
    ror.z x5_128
    lsr.z x5_128+1
    ror.z x5_128
    lsr.z x5_128+1
    ror.z x5_128
    // [111] (word) sin16s::usinx#1 ← (word) sin16s::usinx#0 + (word) sin16s::x5_128#0 -- vwuz1=vwuz1_plus_vwuz2 
    lda.z usinx
    clc
    adc.z x5_128
    sta.z usinx
    lda.z usinx+1
    adc.z x5_128+1
    sta.z usinx+1
    // [112] if((byte) sin16s::isUpper#2==(byte) 0) goto sin16s::@12 -- vbuyy_eq_0_then_la1 
    cpy #0
    beq __b12
    jmp __b6
    // sin16s::@6
  __b6:
    // [113] (signed word) sin16s::sinx#1 ← - (signed word)(word) sin16s::usinx#1 -- vwsz1=_neg_vwsz1 
    sec
    lda #0
    sbc.z sinx
    sta.z sinx
    lda #0
    sbc.z sinx+1
    sta.z sinx+1
    // [114] phi from sin16s::@12 sin16s::@6 to sin16s::@3 [phi:sin16s::@12/sin16s::@6->sin16s::@3]
  __b3_from___b12:
  __b3_from___b6:
    // [114] phi (signed word) sin16s::return#1 = (signed word) sin16s::return#5 [phi:sin16s::@12/sin16s::@6->sin16s::@3#0] -- register_copy 
    jmp __b3
    // sin16s::@3
  __b3:
    jmp __breturn
    // sin16s::@return
  __breturn:
    // [115] return 
    rts
    // sin16s::@12
  __b12:
    // [116] (signed word) sin16s::return#5 ← (signed word)(word) sin16s::usinx#1
    jmp __b3_from___b12
}
  // mulu16_sel
// Calculate val*val for two unsigned word values - the result is 16 selected bits of the 32-bit result.
// The select parameter indicates how many of the highest bits of the 32-bit result to skip
// mulu16_sel(word zp($c) v1, word zp($e) v2, byte register(X) select)
mulu16_sel: {
    .label __0 = 6
    .label __1 = 6
    .label v1 = $c
    .label v2 = $e
    .label return = $20
    .label return_1 = $c
    // [118] (word) mul16u::a#1 ← (word) mulu16_sel::v1#5 -- vwuz1=vwuz2 
    lda.z v1
    sta.z mul16u.a
    lda.z v1+1
    sta.z mul16u.a+1
    // [119] (word) mul16u::b#0 ← (word) mulu16_sel::v2#5
    // [120] call mul16u 
    jsr mul16u
    // [121] (dword) mul16u::return#2 ← (dword) mul16u::res#2
    jmp __b1
    // mulu16_sel::@1
  __b1:
    // [122] (dword~) mulu16_sel::$0 ← (dword) mul16u::return#2
    // [123] (dword~) mulu16_sel::$1 ← (dword~) mulu16_sel::$0 << (byte) mulu16_sel::select#5 -- vduz1=vduz1_rol_vbuxx 
    cpx #0
    beq !e+
  !:
    asl.z __1
    rol.z __1+1
    rol.z __1+2
    rol.z __1+3
    dex
    bne !-
  !e:
    // [124] (word) mulu16_sel::return#12 ← > (dword~) mulu16_sel::$1 -- vwuz1=_hi_vduz2 
    lda.z __1+2
    sta.z return
    lda.z __1+3
    sta.z return+1
    jmp __breturn
    // mulu16_sel::@return
  __breturn:
    // [125] return 
    rts
}
  // mul16u
// Perform binary multiplication of two unsigned 16-bit words into a 32-bit unsigned double word
// mul16u(word zp($20) a, word zp($e) b)
mul16u: {
    .label mb = $1a
    .label a = $20
    .label res = 6
    .label b = $e
    .label return = 6
    // [126] (dword) mul16u::mb#0 ← (dword)(word) mul16u::b#0 -- vduz1=_dword_vwuz2 
    lda.z b
    sta.z mb
    lda.z b+1
    sta.z mb+1
    lda #0
    sta.z mb+2
    sta.z mb+3
    // [127] phi from mul16u to mul16u::@1 [phi:mul16u->mul16u::@1]
  __b1_from_mul16u:
    // [127] phi (dword) mul16u::mb#2 = (dword) mul16u::mb#0 [phi:mul16u->mul16u::@1#0] -- register_copy 
    // [127] phi (dword) mul16u::res#2 = (dword) 0 [phi:mul16u->mul16u::@1#1] -- vduz1=vduc1 
    lda #<0
    sta.z res
    lda #>0
    sta.z res+1
    lda #<0>>$10
    sta.z res+2
    lda #>0>>$10
    sta.z res+3
    // [127] phi (word) mul16u::a#2 = (word) mul16u::a#1 [phi:mul16u->mul16u::@1#2] -- register_copy 
    jmp __b1
    // mul16u::@1
  __b1:
    // [128] if((word) mul16u::a#2!=(byte) 0) goto mul16u::@2 -- vwuz1_neq_0_then_la1 
    lda.z a
    bne __b2
    lda.z a+1
    bne __b2
    jmp __breturn
    // mul16u::@return
  __breturn:
    // [129] return 
    rts
    // mul16u::@2
  __b2:
    // [130] (byte~) mul16u::$1 ← (word) mul16u::a#2 & (byte) 1 -- vbuaa=vwuz1_band_vbuc1 
    lda #1
    and.z a
    // [131] if((byte~) mul16u::$1==(byte) 0) goto mul16u::@3 -- vbuaa_eq_0_then_la1 
    cmp #0
    beq __b3_from___b2
    jmp __b4
    // mul16u::@4
  __b4:
    // [132] (dword) mul16u::res#1 ← (dword) mul16u::res#2 + (dword) mul16u::mb#2 -- vduz1=vduz1_plus_vduz2 
    lda.z res
    clc
    adc.z mb
    sta.z res
    lda.z res+1
    adc.z mb+1
    sta.z res+1
    lda.z res+2
    adc.z mb+2
    sta.z res+2
    lda.z res+3
    adc.z mb+3
    sta.z res+3
    // [133] phi from mul16u::@2 mul16u::@4 to mul16u::@3 [phi:mul16u::@2/mul16u::@4->mul16u::@3]
  __b3_from___b2:
  __b3_from___b4:
    // [133] phi (dword) mul16u::res#6 = (dword) mul16u::res#2 [phi:mul16u::@2/mul16u::@4->mul16u::@3#0] -- register_copy 
    jmp __b3
    // mul16u::@3
  __b3:
    // [134] (word) mul16u::a#0 ← (word) mul16u::a#2 >> (byte) 1 -- vwuz1=vwuz1_ror_1 
    lsr.z a+1
    ror.z a
    // [135] (dword) mul16u::mb#1 ← (dword) mul16u::mb#2 << (byte) 1 -- vduz1=vduz1_rol_1 
    asl.z mb
    rol.z mb+1
    rol.z mb+2
    rol.z mb+3
    // [127] phi from mul16u::@3 to mul16u::@1 [phi:mul16u::@3->mul16u::@1]
  __b1_from___b3:
    // [127] phi (dword) mul16u::mb#2 = (dword) mul16u::mb#1 [phi:mul16u::@3->mul16u::@1#0] -- register_copy 
    // [127] phi (dword) mul16u::res#2 = (dword) mul16u::res#6 [phi:mul16u::@3->mul16u::@1#1] -- register_copy 
    // [127] phi (word) mul16u::a#2 = (word) mul16u::a#0 [phi:mul16u::@3->mul16u::@1#2] -- register_copy 
    jmp __b1
}
  // div32u16u
// Divide unsigned 32-bit dword dividend with a 16-bit word divisor
// The 16-bit word remainder can be found in rem16u after the division
div32u16u: {
    .label quotient_hi = $20
    .label quotient_lo = $c
    .label return = $16
    // [137] call divr16u 
    // [146] phi from div32u16u to divr16u [phi:div32u16u->divr16u]
  divr16u_from_div32u16u:
    // [146] phi (word) divr16u::dividend#6 = >(const dword) PI2_u4f28 [phi:div32u16u->divr16u#0] -- vwuz1=vwuc1 
    lda #<PI2_u4f28>>$10
    sta.z divr16u.dividend
    lda #>PI2_u4f28>>$10
    sta.z divr16u.dividend+1
    // [146] phi (word) divr16u::rem#11 = (byte) 0 [phi:div32u16u->divr16u#1] -- vwuz1=vbuc1 
    lda #<0
    sta.z divr16u.rem
    lda #>0
    sta.z divr16u.rem+1
    jsr divr16u
    // [138] (word) divr16u::return#3 ← (word) divr16u::return#0
    jmp __b1
    // div32u16u::@1
  __b1:
    // [139] (word) div32u16u::quotient_hi#0 ← (word) divr16u::return#3 -- vwuz1=vwuz2 
    lda.z divr16u.return
    sta.z quotient_hi
    lda.z divr16u.return+1
    sta.z quotient_hi+1
    // [140] (word) divr16u::rem#5 ← (word) rem16u#1
    // [141] call divr16u 
    // [146] phi from div32u16u::@1 to divr16u [phi:div32u16u::@1->divr16u]
  divr16u_from___b1:
    // [146] phi (word) divr16u::dividend#6 = <(const dword) PI2_u4f28 [phi:div32u16u::@1->divr16u#0] -- vwuz1=vwuc1 
    lda #<PI2_u4f28&$ffff
    sta.z divr16u.dividend
    lda #>PI2_u4f28&$ffff
    sta.z divr16u.dividend+1
    // [146] phi (word) divr16u::rem#11 = (word) divr16u::rem#5 [phi:div32u16u::@1->divr16u#1] -- register_copy 
    jsr divr16u
    // [142] (word) divr16u::return#4 ← (word) divr16u::return#0
    jmp __b2
    // div32u16u::@2
  __b2:
    // [143] (word) div32u16u::quotient_lo#0 ← (word) divr16u::return#4
    // [144] (dword) div32u16u::return#0 ← (word) div32u16u::quotient_hi#0 dw= (word) div32u16u::quotient_lo#0 -- vduz1=vwuz2_dword_vwuz3 
    lda.z quotient_hi
    sta.z return+2
    lda.z quotient_hi+1
    sta.z return+3
    lda.z quotient_lo
    sta.z return
    lda.z quotient_lo+1
    sta.z return+1
    jmp __breturn
    // div32u16u::@return
  __breturn:
    // [145] return 
    rts
}
  // 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($14) dividend, word zp($a) rem)
divr16u: {
    .label rem = $a
    .label dividend = $14
    .label quotient = $c
    .label return = $c
    // [147] phi from divr16u to divr16u::@1 [phi:divr16u->divr16u::@1]
  __b1_from_divr16u:
    // [147] phi (byte) divr16u::i#2 = (byte) 0 [phi:divr16u->divr16u::@1#0] -- vbuxx=vbuc1 
    ldx #0
    // [147] 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
    // [147] phi (word) divr16u::dividend#4 = (word) divr16u::dividend#6 [phi:divr16u->divr16u::@1#2] -- register_copy 
    // [147] phi (word) divr16u::rem#6 = (word) divr16u::rem#11 [phi:divr16u->divr16u::@1#3] -- register_copy 
    jmp __b1
    // [147] phi from divr16u::@3 to divr16u::@1 [phi:divr16u::@3->divr16u::@1]
  __b1_from___b3:
    // [147] phi (byte) divr16u::i#2 = (byte) divr16u::i#1 [phi:divr16u::@3->divr16u::@1#0] -- register_copy 
    // [147] phi (word) divr16u::quotient#3 = (word) divr16u::return#0 [phi:divr16u::@3->divr16u::@1#1] -- register_copy 
    // [147] phi (word) divr16u::dividend#4 = (word) divr16u::dividend#0 [phi:divr16u::@3->divr16u::@1#2] -- register_copy 
    // [147] phi (word) divr16u::rem#6 = (word) divr16u::rem#10 [phi:divr16u::@3->divr16u::@1#3] -- register_copy 
    jmp __b1
    // divr16u::@1
  __b1:
    // [148] (word) divr16u::rem#0 ← (word) divr16u::rem#6 << (byte) 1 -- vwuz1=vwuz1_rol_1 
    asl.z rem
    rol.z rem+1
    // [149] (byte~) divr16u::$1 ← > (word) divr16u::dividend#4 -- vbuaa=_hi_vwuz1 
    lda.z dividend+1
    // [150] (byte~) divr16u::$2 ← (byte~) divr16u::$1 & (byte) $80 -- vbuaa=vbuaa_band_vbuc1 
    and #$80
    // [151] 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:
    // [152] (word) divr16u::rem#1 ← (word) divr16u::rem#0 | (byte) 1 -- vwuz1=vwuz1_bor_vbuc1 
    lda #1
    ora.z rem
    sta.z rem
    // [153] phi from divr16u::@1 divr16u::@4 to divr16u::@2 [phi:divr16u::@1/divr16u::@4->divr16u::@2]
  __b2_from___b1:
  __b2_from___b4:
    // [153] phi (word) divr16u::rem#7 = (word) divr16u::rem#0 [phi:divr16u::@1/divr16u::@4->divr16u::@2#0] -- register_copy 
    jmp __b2
    // divr16u::@2
  __b2:
    // [154] (word) divr16u::dividend#0 ← (word) divr16u::dividend#4 << (byte) 1 -- vwuz1=vwuz1_rol_1 
    asl.z dividend
    rol.z dividend+1
    // [155] (word) divr16u::quotient#1 ← (word) divr16u::quotient#3 << (byte) 1 -- vwuz1=vwuz1_rol_1 
    asl.z quotient
    rol.z quotient+1
    // [156] if((word) divr16u::rem#7<(const word) main::wavelength) goto divr16u::@3 -- vwuz1_lt_vwuc1_then_la1 
    lda.z rem+1
    cmp #>main.wavelength
    bcc __b3_from___b2
    bne !+
    lda.z rem
    cmp #<main.wavelength
    bcc __b3_from___b2
  !:
    jmp __b5
    // divr16u::@5
  __b5:
    // [157] (word) divr16u::quotient#2 ← ++ (word) divr16u::quotient#1 -- vwuz1=_inc_vwuz1 
    inc.z quotient
    bne !+
    inc.z quotient+1
  !:
    // [158] (word) divr16u::rem#2 ← (word) divr16u::rem#7 - (const word) main::wavelength -- vwuz1=vwuz1_minus_vwuc1 
    lda.z rem
    sec
    sbc #<main.wavelength
    sta.z rem
    lda.z rem+1
    sbc #>main.wavelength
    sta.z rem+1
    // [159] phi from divr16u::@2 divr16u::@5 to divr16u::@3 [phi:divr16u::@2/divr16u::@5->divr16u::@3]
  __b3_from___b2:
  __b3_from___b5:
    // [159] phi (word) divr16u::return#0 = (word) divr16u::quotient#1 [phi:divr16u::@2/divr16u::@5->divr16u::@3#0] -- register_copy 
    // [159] phi (word) divr16u::rem#10 = (word) divr16u::rem#7 [phi:divr16u::@2/divr16u::@5->divr16u::@3#1] -- register_copy 
    jmp __b3
    // divr16u::@3
  __b3:
    // [160] (byte) divr16u::i#1 ← ++ (byte) divr16u::i#2 -- vbuxx=_inc_vbuxx 
    inx
    // [161] 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:
    // [162] (word) rem16u#1 ← (word) divr16u::rem#10
    jmp __breturn
    // divr16u::@return
  __breturn:
    // [163] return 
    rts
}
  // sin8s_gen
// Generate signed byte sinus table - on the full -$7f - $7f range
// sintab - the table to generate into
// wavelength - the number of sinus points in a total sinus wavelength (the size of the table)
// sin8s_gen(signed byte* zp($14) sintab)
sin8s_gen: {
    .label step = $c
    .label sintab = $14
    // u[4.12]
    // Iterate over the table
    .label x = $20
    .label i = $e
    // [165] call div16u 
    // [241] phi from sin8s_gen to div16u [phi:sin8s_gen->div16u]
  div16u_from_sin8s_gen:
    jsr div16u
    // [166] (word) div16u::return#2 ← (word) div16u::return#0
    jmp __b3
    // sin8s_gen::@3
  __b3:
    // [167] (word) sin8s_gen::step#0 ← (word) div16u::return#2
    // [168] phi from sin8s_gen::@3 to sin8s_gen::@1 [phi:sin8s_gen::@3->sin8s_gen::@1]
  __b1_from___b3:
    // [168] phi (signed byte*) sin8s_gen::sintab#2 = (const signed byte*) main::sintabb [phi:sin8s_gen::@3->sin8s_gen::@1#0] -- pbsz1=pbsc1 
    lda #<main.sintabb
    sta.z sintab
    lda #>main.sintabb
    sta.z sintab+1
    // [168] phi (word) sin8s_gen::x#2 = (word) 0 [phi:sin8s_gen::@3->sin8s_gen::@1#1] -- vwuz1=vwuc1 
    lda #<0
    sta.z x
    lda #>0
    sta.z x+1
    // [168] phi (word) sin8s_gen::i#2 = (word) 0 [phi:sin8s_gen::@3->sin8s_gen::@1#2] -- vwuz1=vwuc1 
    lda #<0
    sta.z i
    lda #>0
    sta.z i+1
    jmp __b1
  // u[4.12]
    // sin8s_gen::@1
  __b1:
    // [169] if((word) sin8s_gen::i#2<(const word) main::wavelength) goto sin8s_gen::@2 -- vwuz1_lt_vwuc1_then_la1 
    lda.z i+1
    cmp #>main.wavelength
    bcc __b2
    bne !+
    lda.z i
    cmp #<main.wavelength
    bcc __b2
  !:
    jmp __breturn
    // sin8s_gen::@return
  __breturn:
    // [170] return 
    rts
    // sin8s_gen::@2
  __b2:
    // [171] (word) sin8s::x#0 ← (word) sin8s_gen::x#2 -- vwuz1=vwuz2 
    lda.z x
    sta.z sin8s.x
    lda.z x+1
    sta.z sin8s.x+1
    // [172] call sin8s 
    jsr sin8s
    // [173] (signed byte) sin8s::return#0 ← (signed byte) sin8s::return#1
    jmp __b4
    // sin8s_gen::@4
  __b4:
    // [174] (signed byte~) sin8s_gen::$2 ← (signed byte) sin8s::return#0
    // [175] *((signed byte*) sin8s_gen::sintab#2) ← (signed byte~) sin8s_gen::$2 -- _deref_pbsz1=vbsaa 
    ldy #0
    sta (sintab),y
    // [176] (signed byte*) sin8s_gen::sintab#0 ← ++ (signed byte*) sin8s_gen::sintab#2 -- pbsz1=_inc_pbsz1 
    inc.z sintab
    bne !+
    inc.z sintab+1
  !:
    // [177] (word) sin8s_gen::x#1 ← (word) sin8s_gen::x#2 + (word) sin8s_gen::step#0 -- vwuz1=vwuz1_plus_vwuz2 
    lda.z x
    clc
    adc.z step
    sta.z x
    lda.z x+1
    adc.z step+1
    sta.z x+1
    // [178] (word) sin8s_gen::i#1 ← ++ (word) sin8s_gen::i#2 -- vwuz1=_inc_vwuz1 
    inc.z i
    bne !+
    inc.z i+1
  !:
    // [168] phi from sin8s_gen::@4 to sin8s_gen::@1 [phi:sin8s_gen::@4->sin8s_gen::@1]
  __b1_from___b4:
    // [168] phi (signed byte*) sin8s_gen::sintab#2 = (signed byte*) sin8s_gen::sintab#0 [phi:sin8s_gen::@4->sin8s_gen::@1#0] -- register_copy 
    // [168] phi (word) sin8s_gen::x#2 = (word) sin8s_gen::x#1 [phi:sin8s_gen::@4->sin8s_gen::@1#1] -- register_copy 
    // [168] phi (word) sin8s_gen::i#2 = (word) sin8s_gen::i#1 [phi:sin8s_gen::@4->sin8s_gen::@1#2] -- register_copy 
    jmp __b1
}
  // sin8s
// Calculate signed byte sinus sin(x)
// x: unsigned word input u[4.12] in the interval $0000 - PI2_u4f12
// result: signed byte sin(x) s[0.7] - using the full range  -$7f - $7f
// sin8s(word zp($11) x)
sin8s: {
    // u[2.6] x^3
    .const DIV_6 = $2b
    .label __4 = $11
    .label x = $11
    .label x1 = $22
    .label x3 = $23
    .label usinx = $24
    // Move x1 into the range 0-PI/2 using sinus mirror symmetries
    .label isUpper = $10
    // [179] if((word) sin8s::x#0<(const word) PI_u4f12) goto sin8s::@1 -- vwuz1_lt_vwuc1_then_la1 
    lda.z x+1
    cmp #>PI_u4f12
    bcc __b1_from_sin8s
    bne !+
    lda.z x
    cmp #<PI_u4f12
    bcc __b1_from_sin8s
  !:
    jmp __b5
    // sin8s::@5
  __b5:
    // [180] (word) sin8s::x#1 ← (word) sin8s::x#0 - (const word) PI_u4f12 -- vwuz1=vwuz1_minus_vwuc1 
    lda.z x
    sec
    sbc #<PI_u4f12
    sta.z x
    lda.z x+1
    sbc #>PI_u4f12
    sta.z x+1
    // [181] phi from sin8s::@5 to sin8s::@1 [phi:sin8s::@5->sin8s::@1]
  __b1_from___b5:
    // [181] phi (byte) sin8s::isUpper#10 = (byte) 1 [phi:sin8s::@5->sin8s::@1#0] -- vbuz1=vbuc1 
    lda #1
    sta.z isUpper
    // [181] phi (word) sin8s::x#4 = (word) sin8s::x#1 [phi:sin8s::@5->sin8s::@1#1] -- register_copy 
    jmp __b1
    // [181] phi from sin8s to sin8s::@1 [phi:sin8s->sin8s::@1]
  __b1_from_sin8s:
    // [181] phi (byte) sin8s::isUpper#10 = (byte) 0 [phi:sin8s->sin8s::@1#0] -- vbuz1=vbuc1 
    lda #0
    sta.z isUpper
    // [181] phi (word) sin8s::x#4 = (word) sin8s::x#0 [phi:sin8s->sin8s::@1#1] -- register_copy 
    jmp __b1
    // sin8s::@1
  __b1:
    // [182] if((word) sin8s::x#4<(const word) PI_HALF_u4f12) goto sin8s::@2 -- vwuz1_lt_vwuc1_then_la1 
    lda.z x+1
    cmp #>PI_HALF_u4f12
    bcc __b2_from___b1
    bne !+
    lda.z x
    cmp #<PI_HALF_u4f12
    bcc __b2_from___b1
  !:
    jmp __b6
    // sin8s::@6
  __b6:
    // [183] (word) sin8s::x#2 ← (const word) PI_u4f12 - (word) sin8s::x#4 -- vwuz1=vwuc1_minus_vwuz1 
    sec
    lda #<PI_u4f12
    sbc.z x
    sta.z x
    lda #>PI_u4f12
    sbc.z x+1
    sta.z x+1
    // [184] phi from sin8s::@1 sin8s::@6 to sin8s::@2 [phi:sin8s::@1/sin8s::@6->sin8s::@2]
  __b2_from___b1:
  __b2_from___b6:
    // [184] phi (word) sin8s::x#6 = (word) sin8s::x#4 [phi:sin8s::@1/sin8s::@6->sin8s::@2#0] -- register_copy 
    jmp __b2
    // sin8s::@2
  __b2:
    // [185] (word~) sin8s::$4 ← (word) sin8s::x#6 << (byte) 3 -- vwuz1=vwuz1_rol_3 
    asl.z __4
    rol.z __4+1
    asl.z __4
    rol.z __4+1
    asl.z __4
    rol.z __4+1
    // [186] (byte) sin8s::x1#0 ← > (word~) sin8s::$4 -- vbuz1=_hi_vwuz2 
    lda.z __4+1
    sta.z x1
    // [187] (byte) mulu8_sel::v1#0 ← (byte) sin8s::x1#0 -- vbuxx=vbuz1 
    ldx.z x1
    // [188] (byte) mulu8_sel::v2#0 ← (byte) sin8s::x1#0 -- vbuyy=vbuz1 
    ldy.z x1
    // [189] call mulu8_sel 
    // [222] phi from sin8s::@2 to mulu8_sel [phi:sin8s::@2->mulu8_sel]
  mulu8_sel_from___b2:
    // [222] phi (byte) mulu8_sel::select#5 = (byte) 0 [phi:sin8s::@2->mulu8_sel#0] -- vbuz1=vbuc1 
    lda #0
    sta.z mulu8_sel.select
    // [222] phi (byte) mulu8_sel::v2#5 = (byte) mulu8_sel::v2#0 [phi:sin8s::@2->mulu8_sel#1] -- register_copy 
    // [222] phi (byte) mulu8_sel::v1#5 = (byte) mulu8_sel::v1#0 [phi:sin8s::@2->mulu8_sel#2] -- register_copy 
    jsr mulu8_sel
    // [190] (byte) mulu8_sel::return#0 ← (byte) mulu8_sel::return#12
    jmp __b9
    // sin8s::@9
  __b9:
    // [191] (byte) sin8s::x2#0 ← (byte) mulu8_sel::return#0
    // [192] (byte) mulu8_sel::v1#1 ← (byte) sin8s::x2#0 -- vbuxx=vbuaa 
    tax
    // [193] (byte) mulu8_sel::v2#1 ← (byte) sin8s::x1#0 -- vbuyy=vbuz1 
    ldy.z x1
    // [194] call mulu8_sel 
    // [222] phi from sin8s::@9 to mulu8_sel [phi:sin8s::@9->mulu8_sel]
  mulu8_sel_from___b9:
    // [222] phi (byte) mulu8_sel::select#5 = (byte) 1 [phi:sin8s::@9->mulu8_sel#0] -- vbuz1=vbuc1 
    lda #1
    sta.z mulu8_sel.select
    // [222] phi (byte) mulu8_sel::v2#5 = (byte) mulu8_sel::v2#1 [phi:sin8s::@9->mulu8_sel#1] -- register_copy 
    // [222] phi (byte) mulu8_sel::v1#5 = (byte) mulu8_sel::v1#1 [phi:sin8s::@9->mulu8_sel#2] -- register_copy 
    jsr mulu8_sel
    // [195] (byte) mulu8_sel::return#1 ← (byte) mulu8_sel::return#12
    jmp __b10
    // sin8s::@10
  __b10:
    // [196] (byte) sin8s::x3#0 ← (byte) mulu8_sel::return#1 -- vbuz1=vbuaa 
    sta.z x3
    // [197] (byte) mulu8_sel::v1#2 ← (byte) sin8s::x3#0 -- vbuxx=vbuz1 
    ldx.z x3
    // [198] call mulu8_sel 
    // [222] phi from sin8s::@10 to mulu8_sel [phi:sin8s::@10->mulu8_sel]
  mulu8_sel_from___b10:
    // [222] phi (byte) mulu8_sel::select#5 = (byte) 1 [phi:sin8s::@10->mulu8_sel#0] -- vbuz1=vbuc1 
    lda #1
    sta.z mulu8_sel.select
    // [222] phi (byte) mulu8_sel::v2#5 = (const byte) sin8s::DIV_6 [phi:sin8s::@10->mulu8_sel#1] -- vbuyy=vbuc1 
    ldy #DIV_6
    // [222] phi (byte) mulu8_sel::v1#5 = (byte) mulu8_sel::v1#2 [phi:sin8s::@10->mulu8_sel#2] -- register_copy 
    jsr mulu8_sel
    // [199] (byte) mulu8_sel::return#2 ← (byte) mulu8_sel::return#12
    jmp __b11
    // sin8s::@11
  __b11:
    // [200] (byte) sin8s::x3_6#0 ← (byte) mulu8_sel::return#2
    // [201] (byte) sin8s::usinx#0 ← (byte) sin8s::x1#0 - (byte) sin8s::x3_6#0 -- vbuz1=vbuz2_minus_vbuaa 
    eor #$ff
    sec
    adc.z x1
    sta.z usinx
    // [202] (byte) mulu8_sel::v1#3 ← (byte) sin8s::x3#0 -- vbuxx=vbuz1 
    ldx.z x3
    // [203] (byte) mulu8_sel::v2#3 ← (byte) sin8s::x1#0 -- vbuyy=vbuz1 
    ldy.z x1
    // [204] call mulu8_sel 
    // [222] phi from sin8s::@11 to mulu8_sel [phi:sin8s::@11->mulu8_sel]
  mulu8_sel_from___b11:
    // [222] phi (byte) mulu8_sel::select#5 = (byte) 0 [phi:sin8s::@11->mulu8_sel#0] -- vbuz1=vbuc1 
    lda #0
    sta.z mulu8_sel.select
    // [222] phi (byte) mulu8_sel::v2#5 = (byte) mulu8_sel::v2#3 [phi:sin8s::@11->mulu8_sel#1] -- register_copy 
    // [222] phi (byte) mulu8_sel::v1#5 = (byte) mulu8_sel::v1#3 [phi:sin8s::@11->mulu8_sel#2] -- register_copy 
    jsr mulu8_sel
    // [205] (byte) mulu8_sel::return#10 ← (byte) mulu8_sel::return#12
    jmp __b12
    // sin8s::@12
  __b12:
    // [206] (byte) sin8s::x4#0 ← (byte) mulu8_sel::return#10
    // [207] (byte) mulu8_sel::v1#4 ← (byte) sin8s::x4#0 -- vbuxx=vbuaa 
    tax
    // [208] (byte) mulu8_sel::v2#4 ← (byte) sin8s::x1#0 -- vbuyy=vbuz1 
    ldy.z x1
    // [209] call mulu8_sel 
    // [222] phi from sin8s::@12 to mulu8_sel [phi:sin8s::@12->mulu8_sel]
  mulu8_sel_from___b12:
    // [222] phi (byte) mulu8_sel::select#5 = (byte) 0 [phi:sin8s::@12->mulu8_sel#0] -- vbuz1=vbuc1 
    lda #0
    sta.z mulu8_sel.select
    // [222] phi (byte) mulu8_sel::v2#5 = (byte) mulu8_sel::v2#4 [phi:sin8s::@12->mulu8_sel#1] -- register_copy 
    // [222] phi (byte) mulu8_sel::v1#5 = (byte) mulu8_sel::v1#4 [phi:sin8s::@12->mulu8_sel#2] -- register_copy 
    jsr mulu8_sel
    // [210] (byte) mulu8_sel::return#11 ← (byte) mulu8_sel::return#12
    jmp __b13
    // sin8s::@13
  __b13:
    // [211] (byte) sin8s::x5#0 ← (byte) mulu8_sel::return#11
    // [212] (byte) sin8s::x5_128#0 ← (byte) sin8s::x5#0 >> (byte) 4 -- vbuaa=vbuaa_ror_4 
    lsr
    lsr
    lsr
    lsr
    // [213] (byte) sin8s::usinx#1 ← (byte) sin8s::usinx#0 + (byte) sin8s::x5_128#0 -- vbuxx=vbuz1_plus_vbuaa 
    clc
    adc.z usinx
    tax
    // [214] if((byte) sin8s::usinx#1<(byte) $80) goto sin8s::@3 -- vbuxx_lt_vbuc1_then_la1 
    cpx #$80
    bcc __b3_from___b13
    jmp __b7
    // sin8s::@7
  __b7:
    // [215] (byte) sin8s::usinx#2 ← -- (byte) sin8s::usinx#1 -- vbuxx=_dec_vbuxx 
    dex
    // [216] phi from sin8s::@13 sin8s::@7 to sin8s::@3 [phi:sin8s::@13/sin8s::@7->sin8s::@3]
  __b3_from___b13:
  __b3_from___b7:
    // [216] phi (byte) sin8s::usinx#4 = (byte) sin8s::usinx#1 [phi:sin8s::@13/sin8s::@7->sin8s::@3#0] -- register_copy 
    jmp __b3
    // sin8s::@3
  __b3:
    // [217] if((byte) sin8s::isUpper#10==(byte) 0) goto sin8s::@14 -- vbuz1_eq_0_then_la1 
    lda.z isUpper
    cmp #0
    beq __b14
    jmp __b8
    // sin8s::@8
  __b8:
    // [218] (signed byte) sin8s::sinx#1 ← - (signed byte)(byte) sin8s::usinx#4 -- vbsaa=_neg_vbsxx 
    txa
    eor #$ff
    clc
    adc #1
    // [219] phi from sin8s::@14 sin8s::@8 to sin8s::@4 [phi:sin8s::@14/sin8s::@8->sin8s::@4]
  __b4_from___b14:
  __b4_from___b8:
    // [219] phi (signed byte) sin8s::return#1 = (signed byte) sin8s::return#5 [phi:sin8s::@14/sin8s::@8->sin8s::@4#0] -- register_copy 
    jmp __b4
    // sin8s::@4
  __b4:
    jmp __breturn
    // sin8s::@return
  __breturn:
    // [220] return 
    rts
    // sin8s::@14
  __b14:
    // [221] (signed byte) sin8s::return#5 ← (signed byte)(byte) sin8s::usinx#4 -- vbsaa=vbsxx 
    txa
    jmp __b4_from___b14
}
  // mulu8_sel
// Calculate val*val for two unsigned byte values - the result is 8 selected bits of the 16-bit result.
// The select parameter indicates how many of the highest bits of the 16-bit result to skip
// mulu8_sel(byte register(X) v1, byte register(Y) v2, byte zp($13) select)
mulu8_sel: {
    .label __0 = $11
    .label __1 = $11
    .label select = $13
    // [223] (byte) mul8u::a#1 ← (byte) mulu8_sel::v1#5
    // [224] (byte) mul8u::b#0 ← (byte) mulu8_sel::v2#5 -- vbuaa=vbuyy 
    tya
    // [225] call mul8u 
    jsr mul8u
    // [226] (word) mul8u::return#2 ← (word) mul8u::res#2
    jmp __b1
    // mulu8_sel::@1
  __b1:
    // [227] (word~) mulu8_sel::$0 ← (word) mul8u::return#2
    // [228] (word~) mulu8_sel::$1 ← (word~) mulu8_sel::$0 << (byte) mulu8_sel::select#5 -- vwuz1=vwuz1_rol_vbuz2 
    ldy.z select
    beq !e+
  !:
    asl.z __1
    rol.z __1+1
    dey
    bne !-
  !e:
    // [229] (byte) mulu8_sel::return#12 ← > (word~) mulu8_sel::$1 -- vbuaa=_hi_vwuz1 
    lda.z __1+1
    jmp __breturn
    // mulu8_sel::@return
  __breturn:
    // [230] return 
    rts
}
  // mul8u
// Perform binary multiplication of two unsigned 8-bit bytes into a 16-bit unsigned word
// mul8u(byte register(X) a, byte register(A) b)
mul8u: {
    .label mb = $1e
    .label res = $11
    .label return = $11
    // [231] (word) mul8u::mb#0 ← (word)(byte) mul8u::b#0 -- vwuz1=_word_vbuaa 
    sta.z mb
    lda #0
    sta.z mb+1
    // [232] phi from mul8u to mul8u::@1 [phi:mul8u->mul8u::@1]
  __b1_from_mul8u:
    // [232] phi (word) mul8u::mb#2 = (word) mul8u::mb#0 [phi:mul8u->mul8u::@1#0] -- register_copy 
    // [232] phi (word) mul8u::res#2 = (word) 0 [phi:mul8u->mul8u::@1#1] -- vwuz1=vwuc1 
    lda #<0
    sta.z res
    lda #>0
    sta.z res+1
    // [232] phi (byte) mul8u::a#2 = (byte) mul8u::a#1 [phi:mul8u->mul8u::@1#2] -- register_copy 
    jmp __b1
    // mul8u::@1
  __b1:
    // [233] if((byte) mul8u::a#2!=(byte) 0) goto mul8u::@2 -- vbuxx_neq_0_then_la1 
    cpx #0
    bne __b2
    jmp __breturn
    // mul8u::@return
  __breturn:
    // [234] return 
    rts
    // mul8u::@2
  __b2:
    // [235] (byte~) mul8u::$1 ← (byte) mul8u::a#2 & (byte) 1 -- vbuaa=vbuxx_band_vbuc1 
    txa
    and #1
    // [236] if((byte~) mul8u::$1==(byte) 0) goto mul8u::@3 -- vbuaa_eq_0_then_la1 
    cmp #0
    beq __b3_from___b2
    jmp __b4
    // mul8u::@4
  __b4:
    // [237] (word) mul8u::res#1 ← (word) mul8u::res#2 + (word) mul8u::mb#2 -- vwuz1=vwuz1_plus_vwuz2 
    lda.z res
    clc
    adc.z mb
    sta.z res
    lda.z res+1
    adc.z mb+1
    sta.z res+1
    // [238] phi from mul8u::@2 mul8u::@4 to mul8u::@3 [phi:mul8u::@2/mul8u::@4->mul8u::@3]
  __b3_from___b2:
  __b3_from___b4:
    // [238] phi (word) mul8u::res#6 = (word) mul8u::res#2 [phi:mul8u::@2/mul8u::@4->mul8u::@3#0] -- register_copy 
    jmp __b3
    // mul8u::@3
  __b3:
    // [239] (byte) mul8u::a#0 ← (byte) mul8u::a#2 >> (byte) 1 -- vbuxx=vbuxx_ror_1 
    txa
    lsr
    tax
    // [240] (word) mul8u::mb#1 ← (word) mul8u::mb#2 << (byte) 1 -- vwuz1=vwuz1_rol_1 
    asl.z mb
    rol.z mb+1
    // [232] phi from mul8u::@3 to mul8u::@1 [phi:mul8u::@3->mul8u::@1]
  __b1_from___b3:
    // [232] phi (word) mul8u::mb#2 = (word) mul8u::mb#1 [phi:mul8u::@3->mul8u::@1#0] -- register_copy 
    // [232] phi (word) mul8u::res#2 = (word) mul8u::res#6 [phi:mul8u::@3->mul8u::@1#1] -- register_copy 
    // [232] phi (byte) mul8u::a#2 = (byte) mul8u::a#0 [phi:mul8u::@3->mul8u::@1#2] -- register_copy 
    jmp __b1
}
  // div16u
// Performs division on two 16 bit unsigned words
// Returns the quotient dividend/divisor.
// The remainder will be set into the global variable rem16u
// Implemented using simple binary division
div16u: {
    .label return = $c
    // [242] call divr16u 
    // [146] phi from div16u to divr16u [phi:div16u->divr16u]
  divr16u_from_div16u:
    // [146] phi (word) divr16u::dividend#6 = (const word) PI2_u4f12 [phi:div16u->divr16u#0] -- vwuz1=vwuc1 
    lda #<PI2_u4f12
    sta.z divr16u.dividend
    lda #>PI2_u4f12
    sta.z divr16u.dividend+1
    // [146] phi (word) divr16u::rem#11 = (byte) 0 [phi:div16u->divr16u#1] -- vwuz1=vbuc1 
    lda #<0
    sta.z divr16u.rem
    lda #>0
    sta.z divr16u.rem+1
    jsr divr16u
    // [243] (word) divr16u::return#2 ← (word) divr16u::return#0
    jmp __b1
    // div16u::@1
  __b1:
    // [244] (word) div16u::return#0 ← (word) divr16u::return#2
    jmp __breturn
    // div16u::@return
  __breturn:
    // [245] return 
    rts
}
  // File Data
  print_hextab: .text "0123456789abcdef"

ASSEMBLER OPTIMIZATIONS
Removing instruction jmp __b1
Removing instruction jmp __bend
Removing instruction jmp __b2
Removing instruction jmp __b3
Removing instruction jmp __b1
Removing instruction jmp __b4
Removing instruction jmp __b5
Removing instruction jmp __breturn
Removing instruction jmp __b1
Removing instruction jmp __breturn
Removing instruction jmp __b3
Removing instruction jmp __b2
Removing instruction jmp __breturn
Removing instruction jmp __b1
Removing instruction jmp __b4
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 __b1
Removing instruction jmp __breturn
Removing instruction jmp __b4
Removing instruction jmp __b4
Removing instruction jmp __b1
Removing instruction jmp __b5
Removing instruction jmp __b2
Removing instruction jmp __b7
Removing instruction jmp __b8
Removing instruction jmp __b9
Removing instruction jmp __b10
Removing instruction jmp __b11
Removing instruction jmp __b6
Removing instruction jmp __b3
Removing instruction jmp __breturn
Removing instruction jmp __b1
Removing instruction jmp __breturn
Removing instruction jmp __b1
Removing instruction jmp __breturn
Removing instruction jmp __b4
Removing instruction jmp __b3
Removing instruction jmp __b1
Removing instruction jmp __b2
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
Removing instruction jmp __b3
Removing instruction jmp __b1
Removing instruction jmp __breturn
Removing instruction jmp __b4
Removing instruction jmp __b5
Removing instruction jmp __b1
Removing instruction jmp __b6
Removing instruction jmp __b2
Removing instruction jmp __b9
Removing instruction jmp __b10
Removing instruction jmp __b11
Removing instruction jmp __b12
Removing instruction jmp __b13
Removing instruction jmp __b7
Removing instruction jmp __b3
Removing instruction jmp __b8
Removing instruction jmp __b4
Removing instruction jmp __breturn
Removing instruction jmp __b1
Removing instruction jmp __breturn
Removing instruction jmp __b1
Removing instruction jmp __breturn
Removing instruction jmp __b4
Removing instruction jmp __b3
Removing instruction jmp __b1
Removing instruction jmp __breturn
Succesful ASM optimization Pass5NextJumpElimination
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
Removing instruction lda #>0
Removing instruction lda #<0
Removing instruction lda #>0
Replacing instruction ldx.z x1 with TAX
Replacing instruction ldy.z x1 with TAY
Replacing instruction ldx.z x3 with TAX
Removing instruction lda #>0
Removing instruction lda #>0
Succesful ASM optimization Pass5UnnecesaryLoadElimination
Replacing label __bbegin with __b1
Replacing label __b1_from___b5 with __b1
Replacing label __b1_from_print_sbyte with __b1
Replacing label __b2_from___b4 with __b2
Replacing label __b2_from___b1 with __b2
Replacing label __b2_from___b1 with __b2
Replacing label __b2_from___b1 with __b2
Replacing label __b2_from___b1 with __b2
Replacing label __b3_from___b12 with __b3
Replacing label __b3_from___b2 with __b3
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
Replacing label __b2_from___b1 with __b2
Replacing label __b2_from___b1 with __b2
Replacing label __b3_from___b13 with __b3
Replacing label __b4_from___b14 with __b4
Replacing label __b3_from___b2 with __b3
Removing instruction __bbegin:
Removing instruction __b1_from___bbegin:
Removing instruction main_from___b1:
Removing instruction __bend_from___b1:
Removing instruction __b2_from_main:
Removing instruction sin16s_gen_from___b2:
Removing instruction __b3_from___b2:
Removing instruction print_cls_from___b3:
Removing instruction __b1_from___b5:
Removing instruction __b4_from___b1:
Removing instruction print_str_from___b4:
Removing instruction __b3_from_print_sbyte:
Removing instruction print_char_from___b3:
Removing instruction __b2_from___b3:
Removing instruction __b2_from___b4:
Removing instruction __b1_from_print_sbyte:
Removing instruction print_char_from___b1:
Removing instruction __b1_from___b3:
Removing instruction __b2_from___b1:
Removing instruction __b2_from___b5:
Removing instruction mulu16_sel_from___b8:
Removing instruction __b3_from___b12:
Removing instruction __b3_from___b6:
Removing instruction __breturn:
Removing instruction __b3_from___b2:
Removing instruction __b3_from___b4:
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:
Removing instruction __b1_from___b3:
Removing instruction __b2_from___b1:
Removing instruction __b2_from___b6:
Removing instruction __b3_from___b13:
Removing instruction __b3_from___b7:
Removing instruction __b4_from___b14:
Removing instruction __b4_from___b8:
Removing instruction __breturn:
Removing instruction __b3_from___b2:
Removing instruction __b3_from___b4:
Removing instruction __breturn:
Succesful ASM optimization Pass5RedundantLabelElimination
Removing instruction __bend:
Removing instruction sin8s_gen_from_main:
Removing instruction __b2:
Removing instruction __b3:
Removing instruction __b1_from___b3:
Removing instruction __b4:
Removing instruction __b5:
Removing instruction __breturn:
Removing instruction __b1_from_print_str:
Removing instruction __breturn:
Removing instruction __b1_from___b2:
Removing instruction __b3:
Removing instruction __breturn:
Removing instruction __b4:
Removing instruction __breturn:
Removing instruction print_char_from_print_byte:
Removing instruction __b1:
Removing instruction print_char_from___b1:
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 div32u16u_from_sin16s_gen:
Removing instruction __b3:
Removing instruction __breturn:
Removing instruction __b4:
Removing instruction __b1_from___b4:
Removing instruction __b4:
Removing instruction __b1_from___b4:
Removing instruction __b5:
Removing instruction mulu16_sel_from___b2:
Removing instruction __b7:
Removing instruction mulu16_sel_from___b7:
Removing instruction __b8:
Removing instruction __b9:
Removing instruction mulu16_sel_from___b9:
Removing instruction __b10:
Removing instruction mulu16_sel_from___b10:
Removing instruction __b11:
Removing instruction __b6:
Removing instruction __b1:
Removing instruction __breturn:
Removing instruction __b1_from_mul16u:
Removing instruction __breturn:
Removing instruction __b4:
Removing instruction __b1_from___b3:
Removing instruction divr16u_from_div32u16u:
Removing instruction __b1:
Removing instruction divr16u_from___b1:
Removing instruction __b2:
Removing instruction __breturn:
Removing instruction __b1_from_divr16u:
Removing instruction __b4:
Removing instruction __b5:
Removing instruction __b6:
Removing instruction div16u_from_sin8s_gen:
Removing instruction __b3:
Removing instruction __breturn:
Removing instruction __b4:
Removing instruction __b1_from___b4:
Removing instruction __b5:
Removing instruction __b1_from___b5:
Removing instruction __b6:
Removing instruction mulu8_sel_from___b2:
Removing instruction __b9:
Removing instruction mulu8_sel_from___b9:
Removing instruction __b10:
Removing instruction mulu8_sel_from___b10:
Removing instruction __b11:
Removing instruction mulu8_sel_from___b11:
Removing instruction __b12:
Removing instruction mulu8_sel_from___b12:
Removing instruction __b13:
Removing instruction __b7:
Removing instruction __b8:
Removing instruction __b1:
Removing instruction __breturn:
Removing instruction __b1_from_mul8u:
Removing instruction __breturn:
Removing instruction __b4:
Removing instruction __b1_from___b3:
Removing instruction divr16u_from_div16u:
Removing instruction __b1:
Succesful ASM optimization Pass5UnusedLabelElimination
Updating BasicUpstart to call main directly
Removing instruction jsr main
Succesful ASM optimization Pass5SkipBegin
Skipping double jump to __b3 in beq __b12
Replacing jump to rts with rts in jmp __b3
Replacing jump to rts with rts in jmp __b4
Succesful ASM optimization Pass5DoubleJumpElimination
Relabelling long label __b1_from_sin16s to b1
Relabelling long label __b1_from_sin8s to b1
Succesful ASM optimization Pass5RelabelLongLabels
Removing instruction jmp __b1
Removing instruction jmp __b1
Succesful ASM optimization Pass5NextJumpElimination
Removing instruction lda #<0
Removing instruction lda #<0
Succesful ASM optimization Pass5UnnecesaryLoadElimination
Removing instruction __b1:
Removing instruction __b12:
Removing instruction __b4:
Succesful ASM optimization Pass5UnusedLabelElimination
Removing unreachable instruction rts
Succesful ASM optimization Pass5UnreachableCodeElimination

FINAL SYMBOL TABLE
(label) @1
(label) @begin
(label) @end
(const word) PI2_u4f12 = (word) $6488
(const dword) PI2_u4f28 = (dword) $6487ed51
(const word) PI_HALF_u4f12 = (word) $1922
(const dword) PI_HALF_u4f28 = (dword) $1921fb54
(const word) PI_u4f12 = (word) $3244
(const dword) PI_u4f28 = (dword) $3243f6a9
(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_SIGNED_WORD = (byte) 2
(word()) div16u((word) div16u::dividend , (word) div16u::divisor)
(label) div16u::@1
(label) div16u::@return
(word) div16u::dividend
(word) div16u::divisor
(word) div16u::return
(word) div16u::return#0 return zp[2]:12 1.3333333333333333
(word) div16u::return#2 return zp[2]:12 4.0
(dword()) div32u16u((dword) div32u16u::dividend , (word) div32u16u::divisor)
(label) div32u16u::@1
(label) div32u16u::@2
(label) div32u16u::@return
(dword) div32u16u::dividend
(word) div32u16u::divisor
(dword) div32u16u::quotient
(word) div32u16u::quotient_hi
(word) div32u16u::quotient_hi#0 quotient_hi zp[2]:32 0.8
(word) div32u16u::quotient_lo
(word) div32u16u::quotient_lo#0 quotient_lo zp[2]:12 4.0
(dword) div32u16u::return
(dword) div32u16u::return#0 return zp[4]:22 1.3333333333333333
(dword) div32u16u::return#2 return zp[4]:22 4.0
(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]:20 2.75
(word) divr16u::dividend#4 dividend zp[2]:20 5.0
(word) divr16u::dividend#6 dividend zp[2]:20 2.0
(word) divr16u::divisor
(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]:12 16.5
(word) divr16u::quotient#2 quotient zp[2]:12 11.0
(word) divr16u::quotient#3 quotient zp[2]:12 2.75
(word) divr16u::rem
(word) divr16u::rem#0 rem zp[2]:10 8.25
(word) divr16u::rem#1 rem zp[2]:10 22.0
(word) divr16u::rem#10 rem zp[2]:10 11.666666666666666
(word) divr16u::rem#11 rem zp[2]:10 4.0
(word) divr16u::rem#2 rem zp[2]:10 22.0
(word) divr16u::rem#5 rem zp[2]:10 4.0
(word) divr16u::rem#6 rem zp[2]:10 24.0
(word) divr16u::rem#7 rem zp[2]:10 11.0
(word) divr16u::return
(word) divr16u::return#0 return zp[2]:12 4.875
(word) divr16u::return#2 return zp[2]:12 4.0
(word) divr16u::return#3 return zp[2]:12 4.0
(word) divr16u::return#4 return zp[2]:12 4.0
(void()) main()
(word~) main::$11 zp[2]:20 22.0
(word~) main::$3 zp[2]:20 22.0
(signed word*~) main::$4 zp[2]:20 22.0
(byte~) main::$6 reg byte a 11.0
(label) main::@1
(label) main::@2
(label) main::@3
(label) main::@4
(label) main::@5
(label) main::@return
(byte) main::i
(byte) main::i#1 reg byte x 16.5
(byte) main::i#2 reg byte x 2.75
(signed byte) main::sb
(signed byte) main::sb#0 sb zp[1]:19 3.6666666666666665
(signed byte) main::sd
(signed byte) main::sd#0 reg byte a 22.0
(const signed byte*) main::sintabb[(number) $c0]  = { fill( $c0, 0) }
(const signed word*) main::sintabw[(number) $c0]  = { fill( $c0, 0) }
(const byte*) main::str[(byte) 3]  = (byte*) "  "
(signed word) main::sw
(signed word) main::sw#0 sw zp[2]:20 22.0
(const word) main::wavelength = (word) $c0
(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]:10 22.0
(byte*) memset::dst#2 dst zp[2]:10 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*)(const byte*) print_line_cursor#0
(dword()) mul16u((word) mul16u::a , (word) mul16u::b)
(byte~) mul16u::$1 reg byte a 202.0
(label) mul16u::@1
(label) mul16u::@2
(label) mul16u::@3
(label) mul16u::@4
(label) mul16u::@return
(word) mul16u::a
(word) mul16u::a#0 a zp[2]:32 101.0
(word) mul16u::a#1 a zp[2]:32 1.3333333333333333
(word) mul16u::a#2 a zp[2]:32 67.66666666666666
(word) mul16u::b
(word) mul16u::b#0 b zp[2]:14 2.0
(dword) mul16u::mb
(dword) mul16u::mb#0 mb zp[4]:26 4.0
(dword) mul16u::mb#1 mb zp[4]:26 202.0
(dword) mul16u::mb#2 mb zp[4]:26 43.57142857142858
(dword) mul16u::res
(dword) mul16u::res#1 res zp[4]:6 202.0
(dword) mul16u::res#2 res zp[4]:6 50.83333333333333
(dword) mul16u::res#6 res zp[4]:6 101.0
(dword) mul16u::return
(dword) mul16u::return#2 return zp[4]:6 4.0
(word()) mul8u((byte) mul8u::a , (byte) mul8u::b)
(byte~) mul8u::$1 reg byte a 202.0
(label) mul8u::@1
(label) mul8u::@2
(label) mul8u::@3
(label) mul8u::@4
(label) mul8u::@return
(byte) mul8u::a
(byte) mul8u::a#0 reg byte x 101.0
(byte) mul8u::a#1 reg byte x 1.3333333333333333
(byte) mul8u::a#2 reg byte x 67.66666666666666
(byte) mul8u::b
(byte) mul8u::b#0 reg byte a 2.0
(word) mul8u::mb
(word) mul8u::mb#0 mb zp[2]:30 4.0
(word) mul8u::mb#1 mb zp[2]:30 202.0
(word) mul8u::mb#2 mb zp[2]:30 43.57142857142858
(word) mul8u::res
(word) mul8u::res#1 res zp[2]:17 202.0
(word) mul8u::res#2 res zp[2]:17 50.83333333333333
(word) mul8u::res#6 res zp[2]:17 101.0
(word) mul8u::return
(word) mul8u::return#2 return zp[2]:17 4.0
(word()) mulu16_sel((word) mulu16_sel::v1 , (word) mulu16_sel::v2 , (byte) mulu16_sel::select)
(dword~) mulu16_sel::$0 zp[4]:6 4.0
(dword~) mulu16_sel::$1 zp[4]:6 4.0
(label) mulu16_sel::@1
(label) mulu16_sel::@return
(word) mulu16_sel::return
(word) mulu16_sel::return#0 return zp[2]:32 4.0
(word) mulu16_sel::return#1 return_1 zp[2]:12 4.0
(word) mulu16_sel::return#10 return_1 zp[2]:12 4.0
(word) mulu16_sel::return#11 return zp[2]:32 4.0
(word) mulu16_sel::return#12 return zp[2]:32 1.714285714285714
(word) mulu16_sel::return#2 return zp[2]:32 4.0
(byte) mulu16_sel::select
(byte) mulu16_sel::select#5 reg byte x 0.3333333333333333
(word) mulu16_sel::v1
(word) mulu16_sel::v1#0 v1 zp[2]:12 2.0
(word) mulu16_sel::v1#1 v1 zp[2]:12 2.0
(word) mulu16_sel::v1#2 v1 zp[2]:12 4.0
(word) mulu16_sel::v1#3 v1 zp[2]:12 2.0
(word) mulu16_sel::v1#4 v1 zp[2]:12 2.0
(word) mulu16_sel::v1#5 v1 zp[2]:12 12.0
(word) mulu16_sel::v2
(word) mulu16_sel::v2#0 v2 zp[2]:14 4.0
(word) mulu16_sel::v2#1 v2 zp[2]:14 4.0
(word) mulu16_sel::v2#3 v2 zp[2]:14 4.0
(word) mulu16_sel::v2#4 v2 zp[2]:14 4.0
(word) mulu16_sel::v2#5 v2 zp[2]:14 5.0
(byte()) mulu8_sel((byte) mulu8_sel::v1 , (byte) mulu8_sel::v2 , (byte) mulu8_sel::select)
(word~) mulu8_sel::$0 zp[2]:17 4.0
(word~) mulu8_sel::$1 zp[2]:17 4.0
(label) mulu8_sel::@1
(label) mulu8_sel::@return
(byte) mulu8_sel::return
(byte) mulu8_sel::return#0 reg byte a 4.0
(byte) mulu8_sel::return#1 reg byte a 4.0
(byte) mulu8_sel::return#10 reg byte a 4.0
(byte) mulu8_sel::return#11 reg byte a 4.0
(byte) mulu8_sel::return#12 reg byte a 1.714285714285714
(byte) mulu8_sel::return#2 reg byte a 4.0
(byte) mulu8_sel::select
(byte) mulu8_sel::select#5 select zp[1]:19 0.3333333333333333
(byte) mulu8_sel::v1
(byte) mulu8_sel::v1#0 reg byte x 2.0
(byte) mulu8_sel::v1#1 reg byte x 2.0
(byte) mulu8_sel::v1#2 reg byte x 4.0
(byte) mulu8_sel::v1#3 reg byte x 2.0
(byte) mulu8_sel::v1#4 reg byte x 2.0
(byte) mulu8_sel::v1#5 reg byte x 12.0
(byte) mulu8_sel::v2
(byte) mulu8_sel::v2#0 reg byte y 4.0
(byte) mulu8_sel::v2#1 reg byte y 4.0
(byte) mulu8_sel::v2#3 reg byte y 4.0
(byte) mulu8_sel::v2#4 reg byte y 4.0
(byte) mulu8_sel::v2#5 reg byte y 5.0
(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]:16 1.5
(void()) print_char((byte) print_char::ch)
(label) print_char::@return
(byte) print_char::ch
(byte) print_char::ch#2 reg byte a 4.0
(byte) print_char::ch#3 reg byte a 4.0
(byte) print_char::ch#4 reg byte a 6.0
(byte*) print_char_cursor
(byte*) print_char_cursor#1 print_char_cursor zp[2]:17 101.0
(byte*) print_char_cursor#10 print_char_cursor zp[2]:17 0.42105263157894735
(byte*) print_char_cursor#19 print_char_cursor zp[2]:17 45.142857142857146
(byte*) print_char_cursor#28 print_char_cursor zp[2]:17 6.0
(byte*) print_char_cursor#42 print_char_cursor zp[2]:17 1.25
(void()) print_cls()
(label) print_cls::@return
(const byte*) print_hextab[]  = (byte*) "0123456789abcdef"z
(byte*) print_line_cursor
(const byte*) print_line_cursor#0 print_line_cursor = (byte*) 1024
(void()) print_sbyte((signed byte) print_sbyte::b)
(label) print_sbyte::@1
(label) print_sbyte::@2
(label) print_sbyte::@3
(label) print_sbyte::@4
(label) print_sbyte::@return
(signed byte) print_sbyte::b
(signed byte) print_sbyte::b#0 b zp[1]:16 4.0
(signed byte) print_sbyte::b#1 b zp[1]:16 2.8333333333333335
(signed byte) print_sbyte::b#4 b zp[1]:16 4.0
(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]:10 202.0
(byte*) print_str::str#2 str zp[2]:10 101.0
(word) rem16u
(word) rem16u#1 rem16u zp[2]:10 0.8
(signed word()) sin16s((dword) sin16s::x)
(dword~) sin16s::$4 zp[4]:26 4.0
(label) sin16s::@1
(label) sin16s::@10
(label) sin16s::@11
(label) sin16s::@12
(label) sin16s::@2
(label) sin16s::@3
(label) sin16s::@4
(label) sin16s::@5
(label) sin16s::@6
(label) sin16s::@7
(label) sin16s::@8
(label) sin16s::@9
(label) sin16s::@return
(byte) sin16s::isUpper
(byte) sin16s::isUpper#2 reg byte y 0.06060606060606061
(signed word) sin16s::return
(signed word) sin16s::return#0 return zp[2]:20 22.0
(signed word) sin16s::return#1 return zp[2]:20 5.0
(signed word) sin16s::return#5 return zp[2]:20 4.0
(signed word) sin16s::sinx
(signed word) sin16s::sinx#1 sinx zp[2]:20 4.0
(word) sin16s::usinx
(word) sin16s::usinx#0 usinx zp[2]:20 0.3333333333333333
(word) sin16s::usinx#1 usinx zp[2]:20 1.0
(dword) sin16s::x
(dword) sin16s::x#0 x zp[4]:6 8.5
(dword) sin16s::x#1 x zp[4]:6 4.0
(dword) sin16s::x#2 x zp[4]:6 4.0
(dword) sin16s::x#4 x zp[4]:6 5.0
(dword) sin16s::x#6 x zp[4]:6 6.0
(word) sin16s::x1
(word) sin16s::x1#0 x1 zp[2]:30 0.6363636363636365
(word) sin16s::x2
(word) sin16s::x2#0 x2 zp[2]:12 4.0
(word) sin16s::x3
(word) sin16s::x3#0 x3 zp[2]:12 1.0
(word) sin16s::x3_6
(word) sin16s::x3_6#0 x3_6 zp[2]:32 4.0
(word) sin16s::x4
(word) sin16s::x4#0 x4 zp[2]:12 4.0
(word) sin16s::x5
(word) sin16s::x5#0 x5 zp[2]:32 4.0
(word) sin16s::x5_128
(word) sin16s::x5_128#0 x5_128 zp[2]:32 4.0
(void()) sin16s_gen((signed word*) sin16s_gen::sintab , (word) sin16s_gen::wavelength)
(signed word~) sin16s_gen::$2 zp[2]:20 22.0
(label) sin16s_gen::@1
(label) sin16s_gen::@2
(label) sin16s_gen::@3
(label) sin16s_gen::@4
(label) sin16s_gen::@return
(word) sin16s_gen::i
(word) sin16s_gen::i#1 i zp[2]:17 22.0
(word) sin16s_gen::i#2 i zp[2]:17 3.666666666666667
(signed word*) sin16s_gen::sintab
(signed word*) sin16s_gen::sintab#0 sintab zp[2]:10 7.333333333333333
(signed word*) sin16s_gen::sintab#2 sintab zp[2]:10 4.714285714285714
(dword) sin16s_gen::step
(dword) sin16s_gen::step#0 step zp[4]:22 1.1818181818181819
(word) sin16s_gen::wavelength
(dword) sin16s_gen::x
(dword) sin16s_gen::x#1 x zp[4]:2 11.0
(dword) sin16s_gen::x#2 x zp[4]:2 4.125
(signed byte()) sin8s((word) sin8s::x)
(word~) sin8s::$4 zp[2]:17 4.0
(label) sin8s::@1
(label) sin8s::@10
(label) sin8s::@11
(label) sin8s::@12
(label) sin8s::@13
(label) sin8s::@14
(label) sin8s::@2
(label) sin8s::@3
(label) sin8s::@4
(label) sin8s::@5
(label) sin8s::@6
(label) sin8s::@7
(label) sin8s::@8
(label) sin8s::@9
(label) sin8s::@return
(const byte) sin8s::DIV_6 = (byte) $2b
(byte) sin8s::isUpper
(byte) sin8s::isUpper#10 isUpper zp[1]:16 0.05555555555555555
(signed byte) sin8s::return
(signed byte) sin8s::return#0 reg byte a 22.0
(signed byte) sin8s::return#1 reg byte a 5.0
(signed byte) sin8s::return#5 reg byte a 4.0
(signed byte) sin8s::sinx
(signed byte) sin8s::sinx#1 reg byte a 4.0
(byte) sin8s::usinx
(byte) sin8s::usinx#0 usinx zp[1]:36 0.3333333333333333
(byte) sin8s::usinx#1 reg byte x 4.0
(byte) sin8s::usinx#2 reg byte x 4.0
(byte) sin8s::usinx#4 reg byte x 2.0
(word) sin8s::x
(word) sin8s::x#0 x zp[2]:17 8.5
(word) sin8s::x#1 x zp[2]:17 4.0
(word) sin8s::x#2 x zp[2]:17 4.0
(word) sin8s::x#4 x zp[2]:17 5.0
(word) sin8s::x#6 x zp[2]:17 6.0
(byte) sin8s::x1
(byte) sin8s::x1#0 x1 zp[1]:34 0.6363636363636365
(byte) sin8s::x2
(byte) sin8s::x2#0 reg byte a 4.0
(byte) sin8s::x3
(byte) sin8s::x3#0 x3 zp[1]:35 1.0
(byte) sin8s::x3_6
(byte) sin8s::x3_6#0 reg byte a 4.0
(byte) sin8s::x4
(byte) sin8s::x4#0 reg byte a 4.0
(byte) sin8s::x5
(byte) sin8s::x5#0 reg byte a 4.0
(byte) sin8s::x5_128
(byte) sin8s::x5_128#0 reg byte a 4.0
(void()) sin8s_gen((signed byte*) sin8s_gen::sintab , (word) sin8s_gen::wavelength)
(signed byte~) sin8s_gen::$2 reg byte a 22.0
(label) sin8s_gen::@1
(label) sin8s_gen::@2
(label) sin8s_gen::@3
(label) sin8s_gen::@4
(label) sin8s_gen::@return
(word) sin8s_gen::i
(word) sin8s_gen::i#1 i zp[2]:14 22.0
(word) sin8s_gen::i#2 i zp[2]:14 3.666666666666667
(signed byte*) sin8s_gen::sintab
(signed byte*) sin8s_gen::sintab#0 sintab zp[2]:20 7.333333333333333
(signed byte*) sin8s_gen::sintab#2 sintab zp[2]:20 4.714285714285714
(word) sin8s_gen::step
(word) sin8s_gen::step#0 step zp[2]:12 1.1818181818181819
(word) sin8s_gen::wavelength
(word) sin8s_gen::x
(word) sin8s_gen::x#1 x zp[2]:32 11.0
(word) sin8s_gen::x#2 x zp[2]:32 4.125

reg byte x [ main::i#2 main::i#1 ]
reg byte a [ print_char::ch#4 print_char::ch#2 print_char::ch#3 ]
zp[4]:2 [ sin16s_gen::x#2 sin16s_gen::x#1 ]
reg byte y [ sin16s::isUpper#2 ]
reg byte x [ mulu16_sel::select#5 ]
zp[4]:6 [ mul16u::res#2 mul16u::res#6 mul16u::res#1 mul16u::return#2 mulu16_sel::$0 mulu16_sel::$1 sin16s::x#6 sin16s::x#4 sin16s::x#0 sin16s::x#1 sin16s::x#2 ]
zp[2]:10 [ divr16u::rem#6 divr16u::rem#11 divr16u::rem#5 divr16u::rem#10 divr16u::rem#7 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 rem16u#1 sin16s_gen::sintab#2 sin16s_gen::sintab#0 memset::dst#2 memset::dst#1 print_str::str#2 print_str::str#0 ]
zp[2]:12 [ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 divr16u::return#3 divr16u::return#4 divr16u::return#2 div32u16u::quotient_lo#0 div16u::return#2 sin8s_gen::step#0 div16u::return#0 mulu16_sel::v1#5 mulu16_sel::v1#3 mulu16_sel::v1#4 mulu16_sel::v1#0 mulu16_sel::v1#1 mulu16_sel::v1#2 sin16s::x3#0 sin16s::x2#0 sin16s::x4#0 mulu16_sel::return#1 mulu16_sel::return#10 ]
reg byte x [ divr16u::i#2 divr16u::i#1 ]
zp[2]:14 [ sin8s_gen::i#2 sin8s_gen::i#1 mulu16_sel::v2#5 mulu16_sel::v2#3 mulu16_sel::v2#4 mulu16_sel::v2#0 mulu16_sel::v2#1 mul16u::b#0 ]
zp[1]:16 [ sin8s::isUpper#10 print_sbyte::b#4 print_sbyte::b#0 print_sbyte::b#1 print_byte::b#0 ]
reg byte x [ sin8s::usinx#4 sin8s::usinx#1 sin8s::usinx#2 ]
reg byte a [ sin8s::return#1 sin8s::return#5 sin8s::sinx#1 ]
reg byte x [ mulu8_sel::v1#5 mulu8_sel::v1#1 mulu8_sel::v1#2 mulu8_sel::v1#3 mulu8_sel::v1#4 mulu8_sel::v1#0 ]
reg byte y [ mulu8_sel::v2#5 mulu8_sel::v2#1 mulu8_sel::v2#3 mulu8_sel::v2#4 mulu8_sel::v2#0 ]
reg byte x [ mul8u::a#2 mul8u::a#1 mul8u::a#0 ]
zp[2]:17 [ mul8u::res#2 mul8u::res#6 mul8u::res#1 mul8u::return#2 mulu8_sel::$0 mulu8_sel::$1 sin8s::x#6 sin8s::x#4 sin8s::x#0 sin8s::x#1 sin8s::x#2 sin8s::$4 sin16s_gen::i#2 sin16s_gen::i#1 print_char_cursor#28 print_char_cursor#42 print_char_cursor#19 print_char_cursor#10 print_char_cursor#1 ]
zp[1]:19 [ main::sb#0 mulu8_sel::select#5 ]
zp[2]:20 [ main::$3 main::$11 main::$4 main::sw#0 sin8s_gen::sintab#2 sin8s_gen::sintab#0 divr16u::dividend#4 divr16u::dividend#6 divr16u::dividend#0 sin16s::return#1 sin16s::return#5 sin16s::sinx#1 sin16s::usinx#1 sin16s::return#0 sin16s_gen::$2 sin16s::usinx#0 ]
reg byte a [ main::$6 ]
reg byte a [ main::sd#0 ]
reg byte a [ print_byte::$0 ]
reg byte a [ print_byte::$2 ]
zp[4]:22 [ div32u16u::return#2 sin16s_gen::step#0 div32u16u::return#0 ]
zp[4]:26 [ sin16s::$4 mul16u::mb#2 mul16u::mb#0 mul16u::mb#1 ]
zp[2]:30 [ sin16s::x1#0 mul8u::mb#2 mul8u::mb#0 mul8u::mb#1 ]
reg byte a [ mul16u::$1 ]
zp[2]:32 [ div32u16u::quotient_hi#0 mulu16_sel::return#0 mulu16_sel::return#12 mulu16_sel::return#2 sin16s::x3_6#0 mulu16_sel::return#11 sin16s::x5#0 sin16s::x5_128#0 sin8s_gen::x#2 sin8s_gen::x#1 mul16u::a#2 mul16u::a#1 mul16u::a#0 ]
reg byte a [ divr16u::$1 ]
reg byte a [ divr16u::$2 ]
reg byte a [ sin8s::return#0 ]
reg byte a [ sin8s_gen::$2 ]
zp[1]:34 [ sin8s::x1#0 ]
reg byte a [ mulu8_sel::return#0 ]
reg byte a [ sin8s::x2#0 ]
reg byte a [ mulu8_sel::return#1 ]
zp[1]:35 [ sin8s::x3#0 ]
reg byte a [ mulu8_sel::return#2 ]
reg byte a [ sin8s::x3_6#0 ]
zp[1]:36 [ sin8s::usinx#0 ]
reg byte a [ mulu8_sel::return#10 ]
reg byte a [ sin8s::x4#0 ]
reg byte a [ mulu8_sel::return#11 ]
reg byte a [ sin8s::x5#0 ]
reg byte a [ sin8s::x5_128#0 ]
reg byte a [ mul8u::b#0 ]
reg byte a [ mulu8_sel::return#12 ]
reg byte a [ mul8u::$1 ]


FINAL ASSEMBLER
Score: 29761

  // File Comments
  // Upstart
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
  // Global Constants & labels
  // PI*2 in u[4.28] format
  .const PI2_u4f28 = $6487ed51
  // PI in u[4.28] format
  .const PI_u4f28 = $3243f6a9
  // PI/2 in u[4.28] format
  .const PI_HALF_u4f28 = $1921fb54
  // PI*2 in u[4.12] format
  .const PI2_u4f12 = $6488
  // PI in u[4.12] format
  .const PI_u4f12 = $3244
  // PI/2 in u[4.12] format
  .const PI_HALF_u4f12 = $1922
  .const SIZEOF_SIGNED_WORD = 2
  .label print_line_cursor = $400
  // Remainder after unsigned 16-bit division
  .label rem16u = $a
  .label print_char_cursor = $11
  // @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: {
    .label wavelength = $c0
    .label __3 = $14
    .label __4 = $14
    .label __11 = $14
    .label sb = $13
    .label sw = $14
    // sin8s_gen(sintabb, wavelength)
    // [5] call sin8s_gen 
    // [164] phi from main to sin8s_gen [phi:main->sin8s_gen]
    jsr sin8s_gen
    // [6] phi from main to main::@2 [phi:main->main::@2]
    // main::@2
    // sin16s_gen(sintabw, wavelength)
    // [7] call sin16s_gen 
    // [62] phi from main::@2 to sin16s_gen [phi:main::@2->sin16s_gen]
    jsr sin16s_gen
    // [8] phi from main::@2 to main::@3 [phi:main::@2->main::@3]
    // main::@3
    // print_cls()
    // [9] call print_cls 
    // [53] phi from main::@3 to print_cls [phi:main::@3->print_cls]
    jsr print_cls
    // [10] phi from main::@3 to main::@1 [phi:main::@3->main::@1]
    // [10] phi (byte*) print_char_cursor#42 = (const byte*) print_line_cursor#0 [phi:main::@3->main::@1#0] -- pbuz1=pbuc1 
    lda #<print_line_cursor
    sta.z print_char_cursor
    lda #>print_line_cursor
    sta.z print_char_cursor+1
    // [10] phi (byte) main::i#2 = (byte) 0 [phi:main::@3->main::@1#1] -- vbuxx=vbuc1 
    ldx #0
    // [10] phi from main::@5 to main::@1 [phi:main::@5->main::@1]
    // [10] phi (byte*) print_char_cursor#42 = (byte*) print_char_cursor#19 [phi:main::@5->main::@1#0] -- register_copy 
    // [10] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@5->main::@1#1] -- register_copy 
    // main::@1
  __b1:
    // sb = sintabb[i]
    // [11] (signed byte) main::sb#0 ← *((const signed byte*) main::sintabb + (byte) main::i#2) -- vbsz1=pbsc1_derefidx_vbuxx 
    lda sintabb,x
    sta.z sb
    // (word)i
    // [12] (word~) main::$3 ← (word)(byte) main::i#2 -- vwuz1=_word_vbuxx 
    txa
    sta.z __3
    lda #0
    sta.z __3+1
    // sintabw+(word)i
    // [13] (word~) main::$11 ← (word~) main::$3 << (byte) 1 -- vwuz1=vwuz1_rol_1 
    asl.z __11
    rol.z __11+1
    // [14] (signed word*~) main::$4 ← (const signed word*) main::sintabw + (word~) main::$11 -- pwsz1=pwsc1_plus_vwuz1 
    clc
    lda.z __4
    adc #<sintabw
    sta.z __4
    lda.z __4+1
    adc #>sintabw
    sta.z __4+1
    // sw = *(sintabw+(word)i)
    // [15] (signed word) main::sw#0 ← *((signed word*~) main::$4) -- vwsz1=_deref_pwsz1 
    ldy #0
    lda (sw),y
    pha
    iny
    lda (sw),y
    sta.z sw+1
    pla
    sta.z sw
    // >sw
    // [16] (byte~) main::$6 ← > (signed word) main::sw#0 -- vbuaa=_hi_vwsz1 
    lda.z sw+1
    // sd = sb-(signed byte)>sw
    // [17] (signed byte) main::sd#0 ← (signed byte) main::sb#0 - (signed byte)(byte~) main::$6 -- vbsaa=vbsz1_minus_vbsaa 
    eor #$ff
    sec
    adc.z sb
    // print_sbyte(sd)
    // [18] (signed byte) print_sbyte::b#1 ← (signed byte) main::sd#0 -- vbsz1=vbsaa 
    sta.z print_sbyte.b
    // [19] call print_sbyte 
    jsr print_sbyte
    // [20] phi from main::@1 to main::@4 [phi:main::@1->main::@4]
    // main::@4
    // print_str("  ")
    // [21] call print_str 
    // [25] phi from main::@4 to print_str [phi:main::@4->print_str]
    jsr print_str
    // main::@5
    // for(byte i: 0..191)
    // [22] (byte) main::i#1 ← ++ (byte) main::i#2 -- vbuxx=_inc_vbuxx 
    inx
    // [23] if((byte) main::i#1!=(byte) $c0) goto main::@1 -- vbuxx_neq_vbuc1_then_la1 
    cpx #$c0
    bne __b1
    // main::@return
    // }
    // [24] return 
    rts
    sintabb: .fill $c0, 0
    sintabw: .fill 2*$c0, 0
    str: .text "  "
    .byte 0
}
  // print_str
// Print a zero-terminated string
// print_str(byte* zp($a) str)
print_str: {
    .label str = $a
    // [26] phi from print_str to print_str::@1 [phi:print_str->print_str::@1]
    // [26] phi (byte*) print_char_cursor#19 = (byte*) print_char_cursor#10 [phi:print_str->print_str::@1#0] -- register_copy 
    // [26] phi (byte*) print_str::str#2 = (const byte*) main::str [phi:print_str->print_str::@1#1] -- pbuz1=pbuc1 
    lda #<main.str
    sta.z str
    lda #>main.str
    sta.z str+1
    // print_str::@1
  __b1:
    // while(*str)
    // [27] if((byte) 0!=*((byte*) print_str::str#2)) goto print_str::@2 -- vbuc1_neq__deref_pbuz1_then_la1 
    ldy #0
    lda (str),y
    cmp #0
    bne __b2
    // print_str::@return
    // }
    // [28] return 
    rts
    // print_str::@2
  __b2:
    // *(print_char_cursor++) = *(str++)
    // [29] *((byte*) print_char_cursor#19) ← *((byte*) print_str::str#2) -- _deref_pbuz1=_deref_pbuz2 
    ldy #0
    lda (str),y
    sta (print_char_cursor),y
    // *(print_char_cursor++) = *(str++);
    // [30] (byte*) print_char_cursor#1 ← ++ (byte*) print_char_cursor#19 -- pbuz1=_inc_pbuz1 
    inc.z print_char_cursor
    bne !+
    inc.z print_char_cursor+1
  !:
    // [31] (byte*) print_str::str#0 ← ++ (byte*) print_str::str#2 -- pbuz1=_inc_pbuz1 
    inc.z str
    bne !+
    inc.z str+1
  !:
    // [26] phi from print_str::@2 to print_str::@1 [phi:print_str::@2->print_str::@1]
    // [26] phi (byte*) print_char_cursor#19 = (byte*) print_char_cursor#1 [phi:print_str::@2->print_str::@1#0] -- register_copy 
    // [26] phi (byte*) print_str::str#2 = (byte*) print_str::str#0 [phi:print_str::@2->print_str::@1#1] -- register_copy 
    jmp __b1
}
  // print_sbyte
// Print a signed byte as HEX
// print_sbyte(signed byte zp($10) b)
print_sbyte: {
    .label b = $10
    // if(b<0)
    // [32] if((signed byte) print_sbyte::b#1<(signed byte) 0) goto print_sbyte::@1 -- vbsz1_lt_0_then_la1 
    lda.z b
    bmi __b1
    // [33] phi from print_sbyte to print_sbyte::@3 [phi:print_sbyte->print_sbyte::@3]
    // print_sbyte::@3
    // print_char(' ')
    // [34] call print_char 
    // [42] phi from print_sbyte::@3 to print_char [phi:print_sbyte::@3->print_char]
    // [42] phi (byte*) print_char_cursor#28 = (byte*) print_char_cursor#42 [phi:print_sbyte::@3->print_char#0] -- register_copy 
    // [42] phi (byte) print_char::ch#4 = (byte) ' ' [phi:print_sbyte::@3->print_char#1] -- vbuaa=vbuc1 
    lda #' '
    jsr print_char
    // [35] phi from print_sbyte::@3 print_sbyte::@4 to print_sbyte::@2 [phi:print_sbyte::@3/print_sbyte::@4->print_sbyte::@2]
    // [35] phi (signed byte) print_sbyte::b#4 = (signed byte) print_sbyte::b#1 [phi:print_sbyte::@3/print_sbyte::@4->print_sbyte::@2#0] -- register_copy 
    // print_sbyte::@2
  __b2:
    // print_byte((byte)b)
    // [36] (byte) print_byte::b#0 ← (byte)(signed byte) print_sbyte::b#4
    // [37] call print_byte 
    jsr print_byte
    // print_sbyte::@return
    // }
    // [38] return 
    rts
    // [39] phi from print_sbyte to print_sbyte::@1 [phi:print_sbyte->print_sbyte::@1]
    // print_sbyte::@1
  __b1:
    // print_char('-')
    // [40] call print_char 
    // [42] phi from print_sbyte::@1 to print_char [phi:print_sbyte::@1->print_char]
    // [42] phi (byte*) print_char_cursor#28 = (byte*) print_char_cursor#42 [phi:print_sbyte::@1->print_char#0] -- register_copy 
    // [42] phi (byte) print_char::ch#4 = (byte) '-' [phi:print_sbyte::@1->print_char#1] -- vbuaa=vbuc1 
    lda #'-'
    jsr print_char
    // print_sbyte::@4
    // b = -b
    // [41] (signed byte) print_sbyte::b#0 ← - (signed byte) print_sbyte::b#1 -- vbsz1=_neg_vbsz1 
    lda.z b
    eor #$ff
    clc
    adc #1
    sta.z b
    jmp __b2
}
  // print_char
// Print a single char
// print_char(byte register(A) ch)
print_char: {
    // *(print_char_cursor++) = ch
    // [43] *((byte*) print_char_cursor#28) ← (byte) print_char::ch#4 -- _deref_pbuz1=vbuaa 
    ldy #0
    sta (print_char_cursor),y
    // *(print_char_cursor++) = ch;
    // [44] (byte*) print_char_cursor#10 ← ++ (byte*) print_char_cursor#28 -- pbuz1=_inc_pbuz1 
    inc.z print_char_cursor
    bne !+
    inc.z print_char_cursor+1
  !:
    // print_char::@return
    // }
    // [45] return 
    rts
}
  // print_byte
// Print a byte as HEX
// print_byte(byte zp($10) b)
print_byte: {
    .label b = $10
    // b>>4
    // [46] (byte~) print_byte::$0 ← (byte) print_byte::b#0 >> (byte) 4 -- vbuaa=vbuz1_ror_4 
    lda.z b
    lsr
    lsr
    lsr
    lsr
    // print_char(print_hextab[b>>4])
    // [47] (byte) print_char::ch#2 ← *((const byte*) print_hextab + (byte~) print_byte::$0) -- vbuaa=pbuc1_derefidx_vbuaa 
    tay
    lda print_hextab,y
    // [48] call print_char 
    // [42] phi from print_byte to print_char [phi:print_byte->print_char]
    // [42] phi (byte*) print_char_cursor#28 = (byte*) print_char_cursor#10 [phi:print_byte->print_char#0] -- register_copy 
    // [42] phi (byte) print_char::ch#4 = (byte) print_char::ch#2 [phi:print_byte->print_char#1] -- register_copy 
    jsr print_char
    // print_byte::@1
    // b&$f
    // [49] (byte~) print_byte::$2 ← (byte) print_byte::b#0 & (byte) $f -- vbuaa=vbuz1_band_vbuc1 
    lda #$f
    and.z b
    // print_char(print_hextab[b&$f])
    // [50] (byte) print_char::ch#3 ← *((const byte*) print_hextab + (byte~) print_byte::$2) -- vbuaa=pbuc1_derefidx_vbuaa 
    tay
    lda print_hextab,y
    // [51] call print_char 
    // [42] phi from print_byte::@1 to print_char [phi:print_byte::@1->print_char]
    // [42] phi (byte*) print_char_cursor#28 = (byte*) print_char_cursor#10 [phi:print_byte::@1->print_char#0] -- register_copy 
    // [42] phi (byte) print_char::ch#4 = (byte) print_char::ch#3 [phi:print_byte::@1->print_char#1] -- register_copy 
    jsr print_char
    // print_byte::@return
    // }
    // [52] return 
    rts
}
  // print_cls
// Clear the screen. Also resets current line/char cursor.
print_cls: {
    // memset(print_screen, ' ', 1000)
    // [54] call memset 
    // [56] phi from print_cls to memset [phi:print_cls->memset]
    jsr memset
    // print_cls::@return
    // }
    // [55] 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 = print_line_cursor
    .label end = str+num
    .label dst = $a
    // [57] phi from memset to memset::@1 [phi:memset->memset::@1]
    // [57] 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++)
    // [58] 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
    // }
    // [59] return 
    rts
    // memset::@2
  __b2:
    // *dst = c
    // [60] *((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++)
    // [61] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2 -- pbuz1=_inc_pbuz1 
    inc.z dst
    bne !+
    inc.z dst+1
  !:
    // [57] phi from memset::@2 to memset::@1 [phi:memset::@2->memset::@1]
    // [57] phi (byte*) memset::dst#2 = (byte*) memset::dst#1 [phi:memset::@2->memset::@1#0] -- register_copy 
    jmp __b1
}
  // sin16s_gen
// Generate signed (large) word sinus table - on the full -$7fff - $7fff range
// sintab - the table to generate into
// wavelength - the number of sinus points in a total sinus wavelength (the size of the table)
// sin16s_gen(signed word* zp($a) sintab)
sin16s_gen: {
    .label __2 = $14
    .label step = $16
    .label sintab = $a
    // u[4.28]
    // Iterate over the table
    .label x = 2
    .label i = $11
    // div32u16u(PI2_u4f28, wavelength)
    // [63] call div32u16u 
    // [136] phi from sin16s_gen to div32u16u [phi:sin16s_gen->div32u16u]
    jsr div32u16u
    // div32u16u(PI2_u4f28, wavelength)
    // [64] (dword) div32u16u::return#2 ← (dword) div32u16u::return#0
    // sin16s_gen::@3
    // step = div32u16u(PI2_u4f28, wavelength)
    // [65] (dword) sin16s_gen::step#0 ← (dword) div32u16u::return#2
    // [66] phi from sin16s_gen::@3 to sin16s_gen::@1 [phi:sin16s_gen::@3->sin16s_gen::@1]
    // [66] phi (signed word*) sin16s_gen::sintab#2 = (const signed word*) main::sintabw [phi:sin16s_gen::@3->sin16s_gen::@1#0] -- pwsz1=pwsc1 
    lda #<main.sintabw
    sta.z sintab
    lda #>main.sintabw
    sta.z sintab+1
    // [66] phi (dword) sin16s_gen::x#2 = (dword) 0 [phi:sin16s_gen::@3->sin16s_gen::@1#1] -- vduz1=vduc1 
    lda #<0
    sta.z x
    sta.z x+1
    lda #<0>>$10
    sta.z x+2
    lda #>0>>$10
    sta.z x+3
    // [66] phi (word) sin16s_gen::i#2 = (word) 0 [phi:sin16s_gen::@3->sin16s_gen::@1#2] -- vwuz1=vwuc1 
    lda #<0
    sta.z i
    sta.z i+1
  // u[4.28]
    // sin16s_gen::@1
  __b1:
    // for( word i=0; i<wavelength; i++)
    // [67] if((word) sin16s_gen::i#2<(const word) main::wavelength) goto sin16s_gen::@2 -- vwuz1_lt_vwuc1_then_la1 
    lda.z i+1
    cmp #>main.wavelength
    bcc __b2
    bne !+
    lda.z i
    cmp #<main.wavelength
    bcc __b2
  !:
    // sin16s_gen::@return
    // }
    // [68] return 
    rts
    // sin16s_gen::@2
  __b2:
    // sin16s(x)
    // [69] (dword) sin16s::x#0 ← (dword) sin16s_gen::x#2 -- vduz1=vduz2 
    lda.z x
    sta.z sin16s.x
    lda.z x+1
    sta.z sin16s.x+1
    lda.z x+2
    sta.z sin16s.x+2
    lda.z x+3
    sta.z sin16s.x+3
    // [70] call sin16s 
    jsr sin16s
    // [71] (signed word) sin16s::return#0 ← (signed word) sin16s::return#1
    // sin16s_gen::@4
    // [72] (signed word~) sin16s_gen::$2 ← (signed word) sin16s::return#0
    // *sintab++ = sin16s(x)
    // [73] *((signed word*) sin16s_gen::sintab#2) ← (signed word~) sin16s_gen::$2 -- _deref_pwsz1=vwsz2 
    ldy #0
    lda.z __2
    sta (sintab),y
    iny
    lda.z __2+1
    sta (sintab),y
    // *sintab++ = sin16s(x);
    // [74] (signed word*) sin16s_gen::sintab#0 ← (signed word*) sin16s_gen::sintab#2 + (const byte) SIZEOF_SIGNED_WORD -- pwsz1=pwsz1_plus_vbuc1 
    lda #SIZEOF_SIGNED_WORD
    clc
    adc.z sintab
    sta.z sintab
    bcc !+
    inc.z sintab+1
  !:
    // x = x + step
    // [75] (dword) sin16s_gen::x#1 ← (dword) sin16s_gen::x#2 + (dword) sin16s_gen::step#0 -- vduz1=vduz1_plus_vduz2 
    lda.z x
    clc
    adc.z step
    sta.z x
    lda.z x+1
    adc.z step+1
    sta.z x+1
    lda.z x+2
    adc.z step+2
    sta.z x+2
    lda.z x+3
    adc.z step+3
    sta.z x+3
    // for( word i=0; i<wavelength; i++)
    // [76] (word) sin16s_gen::i#1 ← ++ (word) sin16s_gen::i#2 -- vwuz1=_inc_vwuz1 
    inc.z i
    bne !+
    inc.z i+1
  !:
    // [66] phi from sin16s_gen::@4 to sin16s_gen::@1 [phi:sin16s_gen::@4->sin16s_gen::@1]
    // [66] phi (signed word*) sin16s_gen::sintab#2 = (signed word*) sin16s_gen::sintab#0 [phi:sin16s_gen::@4->sin16s_gen::@1#0] -- register_copy 
    // [66] phi (dword) sin16s_gen::x#2 = (dword) sin16s_gen::x#1 [phi:sin16s_gen::@4->sin16s_gen::@1#1] -- register_copy 
    // [66] phi (word) sin16s_gen::i#2 = (word) sin16s_gen::i#1 [phi:sin16s_gen::@4->sin16s_gen::@1#2] -- register_copy 
    jmp __b1
}
  // sin16s
// Calculate signed word sinus sin(x)
// x: unsigned dword input u[4.28] in the interval $00000000 - PI2_u4f28
// result: signed word sin(x) s[0.15] - using the full range  -$7fff - $7fff
// sin16s(dword zp(6) x)
sin16s: {
    .label __4 = $1a
    .label x = 6
    .label return = $14
    .label x1 = $1e
    .label x2 = $c
    .label x3 = $c
    .label x3_6 = $20
    .label usinx = $14
    .label x4 = $c
    .label x5 = $20
    .label x5_128 = $20
    .label sinx = $14
    // if(x >= PI_u4f28 )
    // [77] if((dword) sin16s::x#0<(const dword) PI_u4f28) goto sin16s::@1 -- vduz1_lt_vduc1_then_la1 
    lda.z x+3
    cmp #>PI_u4f28>>$10
    bcc b1
    bne !+
    lda.z x+2
    cmp #<PI_u4f28>>$10
    bcc b1
    bne !+
    lda.z x+1
    cmp #>PI_u4f28
    bcc b1
    bne !+
    lda.z x
    cmp #<PI_u4f28
    bcc b1
  !:
    // sin16s::@4
    // x = x - PI_u4f28
    // [78] (dword) sin16s::x#1 ← (dword) sin16s::x#0 - (const dword) PI_u4f28 -- vduz1=vduz1_minus_vduc1 
    lda.z x
    sec
    sbc #<PI_u4f28
    sta.z x
    lda.z x+1
    sbc #>PI_u4f28
    sta.z x+1
    lda.z x+2
    sbc #<PI_u4f28>>$10
    sta.z x+2
    lda.z x+3
    sbc #>PI_u4f28>>$10
    sta.z x+3
    // [79] phi from sin16s::@4 to sin16s::@1 [phi:sin16s::@4->sin16s::@1]
    // [79] phi (byte) sin16s::isUpper#2 = (byte) 1 [phi:sin16s::@4->sin16s::@1#0] -- vbuyy=vbuc1 
    ldy #1
    // [79] phi (dword) sin16s::x#4 = (dword) sin16s::x#1 [phi:sin16s::@4->sin16s::@1#1] -- register_copy 
    jmp __b1
    // [79] phi from sin16s to sin16s::@1 [phi:sin16s->sin16s::@1]
  b1:
    // [79] phi (byte) sin16s::isUpper#2 = (byte) 0 [phi:sin16s->sin16s::@1#0] -- vbuyy=vbuc1 
    ldy #0
    // [79] phi (dword) sin16s::x#4 = (dword) sin16s::x#0 [phi:sin16s->sin16s::@1#1] -- register_copy 
    // sin16s::@1
  __b1:
    // if(x >= PI_HALF_u4f28 )
    // [80] if((dword) sin16s::x#4<(const dword) PI_HALF_u4f28) goto sin16s::@2 -- vduz1_lt_vduc1_then_la1 
    lda.z x+3
    cmp #>PI_HALF_u4f28>>$10
    bcc __b2
    bne !+
    lda.z x+2
    cmp #<PI_HALF_u4f28>>$10
    bcc __b2
    bne !+
    lda.z x+1
    cmp #>PI_HALF_u4f28
    bcc __b2
    bne !+
    lda.z x
    cmp #<PI_HALF_u4f28
    bcc __b2
  !:
    // sin16s::@5
    // x = PI_u4f28 - x
    // [81] (dword) sin16s::x#2 ← (const dword) PI_u4f28 - (dword) sin16s::x#4 -- vduz1=vduc1_minus_vduz1 
    lda #<PI_u4f28
    sec
    sbc.z x
    sta.z x
    lda #>PI_u4f28
    sbc.z x+1
    sta.z x+1
    lda #<PI_u4f28>>$10
    sbc.z x+2
    sta.z x+2
    lda #>PI_u4f28>>$10
    sbc.z x+3
    sta.z x+3
    // [82] phi from sin16s::@1 sin16s::@5 to sin16s::@2 [phi:sin16s::@1/sin16s::@5->sin16s::@2]
    // [82] phi (dword) sin16s::x#6 = (dword) sin16s::x#4 [phi:sin16s::@1/sin16s::@5->sin16s::@2#0] -- register_copy 
    // sin16s::@2
  __b2:
    // x<<3
    // [83] (dword~) sin16s::$4 ← (dword) sin16s::x#6 << (byte) 3 -- vduz1=vduz2_rol_3 
    lda.z x
    asl
    sta.z __4
    lda.z x+1
    rol
    sta.z __4+1
    lda.z x+2
    rol
    sta.z __4+2
    lda.z x+3
    rol
    sta.z __4+3
    asl.z __4
    rol.z __4+1
    rol.z __4+2
    rol.z __4+3
    asl.z __4
    rol.z __4+1
    rol.z __4+2
    rol.z __4+3
    // x1 = >x<<3
    // [84] (word) sin16s::x1#0 ← > (dword~) sin16s::$4 -- vwuz1=_hi_vduz2 
    lda.z __4+2
    sta.z x1
    lda.z __4+3
    sta.z x1+1
    // mulu16_sel(x1, x1, 0)
    // [85] (word) mulu16_sel::v1#0 ← (word) sin16s::x1#0 -- vwuz1=vwuz2 
    lda.z x1
    sta.z mulu16_sel.v1
    lda.z x1+1
    sta.z mulu16_sel.v1+1
    // [86] (word) mulu16_sel::v2#0 ← (word) sin16s::x1#0 -- vwuz1=vwuz2 
    lda.z x1
    sta.z mulu16_sel.v2
    lda.z x1+1
    sta.z mulu16_sel.v2+1
    // [87] call mulu16_sel 
    // [117] phi from sin16s::@2 to mulu16_sel [phi:sin16s::@2->mulu16_sel]
    // [117] phi (byte) mulu16_sel::select#5 = (byte) 0 [phi:sin16s::@2->mulu16_sel#0] -- vbuxx=vbuc1 
    ldx #0
    // [117] phi (word) mulu16_sel::v2#5 = (word) mulu16_sel::v2#0 [phi:sin16s::@2->mulu16_sel#1] -- register_copy 
    // [117] phi (word) mulu16_sel::v1#5 = (word) mulu16_sel::v1#0 [phi:sin16s::@2->mulu16_sel#2] -- register_copy 
    jsr mulu16_sel
    // mulu16_sel(x1, x1, 0)
    // [88] (word) mulu16_sel::return#0 ← (word) mulu16_sel::return#12
    // sin16s::@7
    // x2 = mulu16_sel(x1, x1, 0)
    // [89] (word) sin16s::x2#0 ← (word) mulu16_sel::return#0 -- vwuz1=vwuz2 
    lda.z mulu16_sel.return
    sta.z x2
    lda.z mulu16_sel.return+1
    sta.z x2+1
    // mulu16_sel(x2, x1, 1)
    // [90] (word) mulu16_sel::v1#1 ← (word) sin16s::x2#0
    // [91] (word) mulu16_sel::v2#1 ← (word) sin16s::x1#0 -- vwuz1=vwuz2 
    lda.z x1
    sta.z mulu16_sel.v2
    lda.z x1+1
    sta.z mulu16_sel.v2+1
    // [92] call mulu16_sel 
    // [117] phi from sin16s::@7 to mulu16_sel [phi:sin16s::@7->mulu16_sel]
    // [117] phi (byte) mulu16_sel::select#5 = (byte) 1 [phi:sin16s::@7->mulu16_sel#0] -- vbuxx=vbuc1 
    ldx #1
    // [117] phi (word) mulu16_sel::v2#5 = (word) mulu16_sel::v2#1 [phi:sin16s::@7->mulu16_sel#1] -- register_copy 
    // [117] phi (word) mulu16_sel::v1#5 = (word) mulu16_sel::v1#1 [phi:sin16s::@7->mulu16_sel#2] -- register_copy 
    jsr mulu16_sel
    // mulu16_sel(x2, x1, 1)
    // [93] (word) mulu16_sel::return#1 ← (word) mulu16_sel::return#12 -- vwuz1=vwuz2 
    lda.z mulu16_sel.return
    sta.z mulu16_sel.return_1
    lda.z mulu16_sel.return+1
    sta.z mulu16_sel.return_1+1
    // sin16s::@8
    // x3 = mulu16_sel(x2, x1, 1)
    // [94] (word) sin16s::x3#0 ← (word) mulu16_sel::return#1
    // mulu16_sel(x3, $10000/6, 1)
    // [95] (word) mulu16_sel::v1#2 ← (word) sin16s::x3#0
    // [96] call mulu16_sel 
    // [117] phi from sin16s::@8 to mulu16_sel [phi:sin16s::@8->mulu16_sel]
    // [117] phi (byte) mulu16_sel::select#5 = (byte) 1 [phi:sin16s::@8->mulu16_sel#0] -- vbuxx=vbuc1 
    ldx #1
    // [117] phi (word) mulu16_sel::v2#5 = (word)(number) $10000/(number) 6 [phi:sin16s::@8->mulu16_sel#1] -- vwuz1=vwuc1 
    lda #<$10000/6
    sta.z mulu16_sel.v2
    lda #>$10000/6
    sta.z mulu16_sel.v2+1
    // [117] phi (word) mulu16_sel::v1#5 = (word) mulu16_sel::v1#2 [phi:sin16s::@8->mulu16_sel#2] -- register_copy 
    jsr mulu16_sel
    // mulu16_sel(x3, $10000/6, 1)
    // [97] (word) mulu16_sel::return#2 ← (word) mulu16_sel::return#12
    // sin16s::@9
    // x3_6 = mulu16_sel(x3, $10000/6, 1)
    // [98] (word) sin16s::x3_6#0 ← (word) mulu16_sel::return#2
    // usinx = x1 - x3_6
    // [99] (word) sin16s::usinx#0 ← (word) sin16s::x1#0 - (word) sin16s::x3_6#0 -- vwuz1=vwuz2_minus_vwuz3 
    lda.z x1
    sec
    sbc.z x3_6
    sta.z usinx
    lda.z x1+1
    sbc.z x3_6+1
    sta.z usinx+1
    // mulu16_sel(x3, x1, 0)
    // [100] (word) mulu16_sel::v1#3 ← (word) sin16s::x3#0
    // [101] (word) mulu16_sel::v2#3 ← (word) sin16s::x1#0 -- vwuz1=vwuz2 
    lda.z x1
    sta.z mulu16_sel.v2
    lda.z x1+1
    sta.z mulu16_sel.v2+1
    // [102] call mulu16_sel 
    // [117] phi from sin16s::@9 to mulu16_sel [phi:sin16s::@9->mulu16_sel]
    // [117] phi (byte) mulu16_sel::select#5 = (byte) 0 [phi:sin16s::@9->mulu16_sel#0] -- vbuxx=vbuc1 
    ldx #0
    // [117] phi (word) mulu16_sel::v2#5 = (word) mulu16_sel::v2#3 [phi:sin16s::@9->mulu16_sel#1] -- register_copy 
    // [117] phi (word) mulu16_sel::v1#5 = (word) mulu16_sel::v1#3 [phi:sin16s::@9->mulu16_sel#2] -- register_copy 
    jsr mulu16_sel
    // mulu16_sel(x3, x1, 0)
    // [103] (word) mulu16_sel::return#10 ← (word) mulu16_sel::return#12 -- vwuz1=vwuz2 
    lda.z mulu16_sel.return
    sta.z mulu16_sel.return_1
    lda.z mulu16_sel.return+1
    sta.z mulu16_sel.return_1+1
    // sin16s::@10
    // x4 = mulu16_sel(x3, x1, 0)
    // [104] (word) sin16s::x4#0 ← (word) mulu16_sel::return#10
    // mulu16_sel(x4, x1, 0)
    // [105] (word) mulu16_sel::v1#4 ← (word) sin16s::x4#0
    // [106] (word) mulu16_sel::v2#4 ← (word) sin16s::x1#0 -- vwuz1=vwuz2 
    lda.z x1
    sta.z mulu16_sel.v2
    lda.z x1+1
    sta.z mulu16_sel.v2+1
    // [107] call mulu16_sel 
    // [117] phi from sin16s::@10 to mulu16_sel [phi:sin16s::@10->mulu16_sel]
    // [117] phi (byte) mulu16_sel::select#5 = (byte) 0 [phi:sin16s::@10->mulu16_sel#0] -- vbuxx=vbuc1 
    ldx #0
    // [117] phi (word) mulu16_sel::v2#5 = (word) mulu16_sel::v2#4 [phi:sin16s::@10->mulu16_sel#1] -- register_copy 
    // [117] phi (word) mulu16_sel::v1#5 = (word) mulu16_sel::v1#4 [phi:sin16s::@10->mulu16_sel#2] -- register_copy 
    jsr mulu16_sel
    // mulu16_sel(x4, x1, 0)
    // [108] (word) mulu16_sel::return#11 ← (word) mulu16_sel::return#12
    // sin16s::@11
    // x5 = mulu16_sel(x4, x1, 0)
    // [109] (word) sin16s::x5#0 ← (word) mulu16_sel::return#11
    // x5_128 = x5>>4
    // [110] (word) sin16s::x5_128#0 ← (word) sin16s::x5#0 >> (byte) 4 -- vwuz1=vwuz1_ror_4 
    lsr.z x5_128+1
    ror.z x5_128
    lsr.z x5_128+1
    ror.z x5_128
    lsr.z x5_128+1
    ror.z x5_128
    lsr.z x5_128+1
    ror.z x5_128
    // usinx = usinx + x5_128
    // [111] (word) sin16s::usinx#1 ← (word) sin16s::usinx#0 + (word) sin16s::x5_128#0 -- vwuz1=vwuz1_plus_vwuz2 
    lda.z usinx
    clc
    adc.z x5_128
    sta.z usinx
    lda.z usinx+1
    adc.z x5_128+1
    sta.z usinx+1
    // if(isUpper!=0)
    // [112] if((byte) sin16s::isUpper#2==(byte) 0) goto sin16s::@12 -- vbuyy_eq_0_then_la1 
    cpy #0
    beq __b3
    // sin16s::@6
    // sinx = -(signed word)usinx
    // [113] (signed word) sin16s::sinx#1 ← - (signed word)(word) sin16s::usinx#1 -- vwsz1=_neg_vwsz1 
    sec
    lda #0
    sbc.z sinx
    sta.z sinx
    lda #0
    sbc.z sinx+1
    sta.z sinx+1
    // [114] phi from sin16s::@12 sin16s::@6 to sin16s::@3 [phi:sin16s::@12/sin16s::@6->sin16s::@3]
    // [114] phi (signed word) sin16s::return#1 = (signed word) sin16s::return#5 [phi:sin16s::@12/sin16s::@6->sin16s::@3#0] -- register_copy 
    // sin16s::@3
  __b3:
    // sin16s::@return
    // }
    // [115] return 
    rts
    // sin16s::@12
    // [116] (signed word) sin16s::return#5 ← (signed word)(word) sin16s::usinx#1
}
  // mulu16_sel
// Calculate val*val for two unsigned word values - the result is 16 selected bits of the 32-bit result.
// The select parameter indicates how many of the highest bits of the 32-bit result to skip
// mulu16_sel(word zp($c) v1, word zp($e) v2, byte register(X) select)
mulu16_sel: {
    .label __0 = 6
    .label __1 = 6
    .label v1 = $c
    .label v2 = $e
    .label return = $20
    .label return_1 = $c
    // mul16u(v1, v2)
    // [118] (word) mul16u::a#1 ← (word) mulu16_sel::v1#5 -- vwuz1=vwuz2 
    lda.z v1
    sta.z mul16u.a
    lda.z v1+1
    sta.z mul16u.a+1
    // [119] (word) mul16u::b#0 ← (word) mulu16_sel::v2#5
    // [120] call mul16u 
    jsr mul16u
    // [121] (dword) mul16u::return#2 ← (dword) mul16u::res#2
    // mulu16_sel::@1
    // [122] (dword~) mulu16_sel::$0 ← (dword) mul16u::return#2
    // mul16u(v1, v2)<<select
    // [123] (dword~) mulu16_sel::$1 ← (dword~) mulu16_sel::$0 << (byte) mulu16_sel::select#5 -- vduz1=vduz1_rol_vbuxx 
    cpx #0
    beq !e+
  !:
    asl.z __1
    rol.z __1+1
    rol.z __1+2
    rol.z __1+3
    dex
    bne !-
  !e:
    // >mul16u(v1, v2)<<select
    // [124] (word) mulu16_sel::return#12 ← > (dword~) mulu16_sel::$1 -- vwuz1=_hi_vduz2 
    lda.z __1+2
    sta.z return
    lda.z __1+3
    sta.z return+1
    // mulu16_sel::@return
    // }
    // [125] return 
    rts
}
  // mul16u
// Perform binary multiplication of two unsigned 16-bit words into a 32-bit unsigned double word
// mul16u(word zp($20) a, word zp($e) b)
mul16u: {
    .label mb = $1a
    .label a = $20
    .label res = 6
    .label b = $e
    .label return = 6
    // mb = b
    // [126] (dword) mul16u::mb#0 ← (dword)(word) mul16u::b#0 -- vduz1=_dword_vwuz2 
    lda.z b
    sta.z mb
    lda.z b+1
    sta.z mb+1
    lda #0
    sta.z mb+2
    sta.z mb+3
    // [127] phi from mul16u to mul16u::@1 [phi:mul16u->mul16u::@1]
    // [127] phi (dword) mul16u::mb#2 = (dword) mul16u::mb#0 [phi:mul16u->mul16u::@1#0] -- register_copy 
    // [127] phi (dword) mul16u::res#2 = (dword) 0 [phi:mul16u->mul16u::@1#1] -- vduz1=vduc1 
    sta.z res
    sta.z res+1
    lda #<0>>$10
    sta.z res+2
    lda #>0>>$10
    sta.z res+3
    // [127] phi (word) mul16u::a#2 = (word) mul16u::a#1 [phi:mul16u->mul16u::@1#2] -- register_copy 
    // mul16u::@1
  __b1:
    // while(a!=0)
    // [128] if((word) mul16u::a#2!=(byte) 0) goto mul16u::@2 -- vwuz1_neq_0_then_la1 
    lda.z a
    bne __b2
    lda.z a+1
    bne __b2
    // mul16u::@return
    // }
    // [129] return 
    rts
    // mul16u::@2
  __b2:
    // a&1
    // [130] (byte~) mul16u::$1 ← (word) mul16u::a#2 & (byte) 1 -- vbuaa=vwuz1_band_vbuc1 
    lda #1
    and.z a
    // if( (a&1) != 0)
    // [131] if((byte~) mul16u::$1==(byte) 0) goto mul16u::@3 -- vbuaa_eq_0_then_la1 
    cmp #0
    beq __b3
    // mul16u::@4
    // res = res + mb
    // [132] (dword) mul16u::res#1 ← (dword) mul16u::res#2 + (dword) mul16u::mb#2 -- vduz1=vduz1_plus_vduz2 
    lda.z res
    clc
    adc.z mb
    sta.z res
    lda.z res+1
    adc.z mb+1
    sta.z res+1
    lda.z res+2
    adc.z mb+2
    sta.z res+2
    lda.z res+3
    adc.z mb+3
    sta.z res+3
    // [133] phi from mul16u::@2 mul16u::@4 to mul16u::@3 [phi:mul16u::@2/mul16u::@4->mul16u::@3]
    // [133] phi (dword) mul16u::res#6 = (dword) mul16u::res#2 [phi:mul16u::@2/mul16u::@4->mul16u::@3#0] -- register_copy 
    // mul16u::@3
  __b3:
    // a = a>>1
    // [134] (word) mul16u::a#0 ← (word) mul16u::a#2 >> (byte) 1 -- vwuz1=vwuz1_ror_1 
    lsr.z a+1
    ror.z a
    // mb = mb<<1
    // [135] (dword) mul16u::mb#1 ← (dword) mul16u::mb#2 << (byte) 1 -- vduz1=vduz1_rol_1 
    asl.z mb
    rol.z mb+1
    rol.z mb+2
    rol.z mb+3
    // [127] phi from mul16u::@3 to mul16u::@1 [phi:mul16u::@3->mul16u::@1]
    // [127] phi (dword) mul16u::mb#2 = (dword) mul16u::mb#1 [phi:mul16u::@3->mul16u::@1#0] -- register_copy 
    // [127] phi (dword) mul16u::res#2 = (dword) mul16u::res#6 [phi:mul16u::@3->mul16u::@1#1] -- register_copy 
    // [127] phi (word) mul16u::a#2 = (word) mul16u::a#0 [phi:mul16u::@3->mul16u::@1#2] -- register_copy 
    jmp __b1
}
  // div32u16u
// Divide unsigned 32-bit dword dividend with a 16-bit word divisor
// The 16-bit word remainder can be found in rem16u after the division
div32u16u: {
    .label quotient_hi = $20
    .label quotient_lo = $c
    .label return = $16
    // divr16u(>dividend, divisor, 0)
    // [137] call divr16u 
    // [146] phi from div32u16u to divr16u [phi:div32u16u->divr16u]
    // [146] phi (word) divr16u::dividend#6 = >(const dword) PI2_u4f28 [phi:div32u16u->divr16u#0] -- vwuz1=vwuc1 
    lda #<PI2_u4f28>>$10
    sta.z divr16u.dividend
    lda #>PI2_u4f28>>$10
    sta.z divr16u.dividend+1
    // [146] phi (word) divr16u::rem#11 = (byte) 0 [phi:div32u16u->divr16u#1] -- vwuz1=vbuc1 
    lda #<0
    sta.z divr16u.rem
    sta.z divr16u.rem+1
    jsr divr16u
    // divr16u(>dividend, divisor, 0)
    // [138] (word) divr16u::return#3 ← (word) divr16u::return#0
    // div32u16u::@1
    // quotient_hi = divr16u(>dividend, divisor, 0)
    // [139] (word) div32u16u::quotient_hi#0 ← (word) divr16u::return#3 -- vwuz1=vwuz2 
    lda.z divr16u.return
    sta.z quotient_hi
    lda.z divr16u.return+1
    sta.z quotient_hi+1
    // divr16u(<dividend, divisor, rem16u)
    // [140] (word) divr16u::rem#5 ← (word) rem16u#1
    // [141] call divr16u 
    // [146] phi from div32u16u::@1 to divr16u [phi:div32u16u::@1->divr16u]
    // [146] phi (word) divr16u::dividend#6 = <(const dword) PI2_u4f28 [phi:div32u16u::@1->divr16u#0] -- vwuz1=vwuc1 
    lda #<PI2_u4f28&$ffff
    sta.z divr16u.dividend
    lda #>PI2_u4f28&$ffff
    sta.z divr16u.dividend+1
    // [146] phi (word) divr16u::rem#11 = (word) divr16u::rem#5 [phi:div32u16u::@1->divr16u#1] -- register_copy 
    jsr divr16u
    // divr16u(<dividend, divisor, rem16u)
    // [142] (word) divr16u::return#4 ← (word) divr16u::return#0
    // div32u16u::@2
    // quotient_lo = divr16u(<dividend, divisor, rem16u)
    // [143] (word) div32u16u::quotient_lo#0 ← (word) divr16u::return#4
    // quotient = { quotient_hi, quotient_lo}
    // [144] (dword) div32u16u::return#0 ← (word) div32u16u::quotient_hi#0 dw= (word) div32u16u::quotient_lo#0 -- vduz1=vwuz2_dword_vwuz3 
    lda.z quotient_hi
    sta.z return+2
    lda.z quotient_hi+1
    sta.z return+3
    lda.z quotient_lo
    sta.z return
    lda.z quotient_lo+1
    sta.z return+1
    // div32u16u::@return
    // }
    // [145] return 
    rts
}
  // 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($14) dividend, word zp($a) rem)
divr16u: {
    .label rem = $a
    .label dividend = $14
    .label quotient = $c
    .label return = $c
    // [147] phi from divr16u to divr16u::@1 [phi:divr16u->divr16u::@1]
    // [147] phi (byte) divr16u::i#2 = (byte) 0 [phi:divr16u->divr16u::@1#0] -- vbuxx=vbuc1 
    ldx #0
    // [147] phi (word) divr16u::quotient#3 = (word) 0 [phi:divr16u->divr16u::@1#1] -- vwuz1=vwuc1 
    txa
    sta.z quotient
    sta.z quotient+1
    // [147] phi (word) divr16u::dividend#4 = (word) divr16u::dividend#6 [phi:divr16u->divr16u::@1#2] -- register_copy 
    // [147] phi (word) divr16u::rem#6 = (word) divr16u::rem#11 [phi:divr16u->divr16u::@1#3] -- register_copy 
    // [147] phi from divr16u::@3 to divr16u::@1 [phi:divr16u::@3->divr16u::@1]
    // [147] phi (byte) divr16u::i#2 = (byte) divr16u::i#1 [phi:divr16u::@3->divr16u::@1#0] -- register_copy 
    // [147] phi (word) divr16u::quotient#3 = (word) divr16u::return#0 [phi:divr16u::@3->divr16u::@1#1] -- register_copy 
    // [147] phi (word) divr16u::dividend#4 = (word) divr16u::dividend#0 [phi:divr16u::@3->divr16u::@1#2] -- register_copy 
    // [147] phi (word) divr16u::rem#6 = (word) divr16u::rem#10 [phi:divr16u::@3->divr16u::@1#3] -- register_copy 
    // divr16u::@1
  __b1:
    // rem = rem << 1
    // [148] (word) divr16u::rem#0 ← (word) divr16u::rem#6 << (byte) 1 -- vwuz1=vwuz1_rol_1 
    asl.z rem
    rol.z rem+1
    // >dividend
    // [149] (byte~) divr16u::$1 ← > (word) divr16u::dividend#4 -- vbuaa=_hi_vwuz1 
    lda.z dividend+1
    // >dividend & $80
    // [150] (byte~) divr16u::$2 ← (byte~) divr16u::$1 & (byte) $80 -- vbuaa=vbuaa_band_vbuc1 
    and #$80
    // if( (>dividend & $80) != 0 )
    // [151] if((byte~) divr16u::$2==(byte) 0) goto divr16u::@2 -- vbuaa_eq_0_then_la1 
    cmp #0
    beq __b2
    // divr16u::@4
    // rem = rem | 1
    // [152] (word) divr16u::rem#1 ← (word) divr16u::rem#0 | (byte) 1 -- vwuz1=vwuz1_bor_vbuc1 
    lda #1
    ora.z rem
    sta.z rem
    // [153] phi from divr16u::@1 divr16u::@4 to divr16u::@2 [phi:divr16u::@1/divr16u::@4->divr16u::@2]
    // [153] phi (word) divr16u::rem#7 = (word) divr16u::rem#0 [phi:divr16u::@1/divr16u::@4->divr16u::@2#0] -- register_copy 
    // divr16u::@2
  __b2:
    // dividend = dividend << 1
    // [154] (word) divr16u::dividend#0 ← (word) divr16u::dividend#4 << (byte) 1 -- vwuz1=vwuz1_rol_1 
    asl.z dividend
    rol.z dividend+1
    // quotient = quotient << 1
    // [155] (word) divr16u::quotient#1 ← (word) divr16u::quotient#3 << (byte) 1 -- vwuz1=vwuz1_rol_1 
    asl.z quotient
    rol.z quotient+1
    // if(rem>=divisor)
    // [156] if((word) divr16u::rem#7<(const word) main::wavelength) goto divr16u::@3 -- vwuz1_lt_vwuc1_then_la1 
    lda.z rem+1
    cmp #>main.wavelength
    bcc __b3
    bne !+
    lda.z rem
    cmp #<main.wavelength
    bcc __b3
  !:
    // divr16u::@5
    // quotient++;
    // [157] (word) divr16u::quotient#2 ← ++ (word) divr16u::quotient#1 -- vwuz1=_inc_vwuz1 
    inc.z quotient
    bne !+
    inc.z quotient+1
  !:
    // rem = rem - divisor
    // [158] (word) divr16u::rem#2 ← (word) divr16u::rem#7 - (const word) main::wavelength -- vwuz1=vwuz1_minus_vwuc1 
    lda.z rem
    sec
    sbc #<main.wavelength
    sta.z rem
    lda.z rem+1
    sbc #>main.wavelength
    sta.z rem+1
    // [159] phi from divr16u::@2 divr16u::@5 to divr16u::@3 [phi:divr16u::@2/divr16u::@5->divr16u::@3]
    // [159] phi (word) divr16u::return#0 = (word) divr16u::quotient#1 [phi:divr16u::@2/divr16u::@5->divr16u::@3#0] -- register_copy 
    // [159] phi (word) divr16u::rem#10 = (word) divr16u::rem#7 [phi:divr16u::@2/divr16u::@5->divr16u::@3#1] -- register_copy 
    // divr16u::@3
  __b3:
    // for( byte i : 0..15)
    // [160] (byte) divr16u::i#1 ← ++ (byte) divr16u::i#2 -- vbuxx=_inc_vbuxx 
    inx
    // [161] if((byte) divr16u::i#1!=(byte) $10) goto divr16u::@1 -- vbuxx_neq_vbuc1_then_la1 
    cpx #$10
    bne __b1
    // divr16u::@6
    // rem16u = rem
    // [162] (word) rem16u#1 ← (word) divr16u::rem#10
    // divr16u::@return
    // }
    // [163] return 
    rts
}
  // sin8s_gen
// Generate signed byte sinus table - on the full -$7f - $7f range
// sintab - the table to generate into
// wavelength - the number of sinus points in a total sinus wavelength (the size of the table)
// sin8s_gen(signed byte* zp($14) sintab)
sin8s_gen: {
    .label step = $c
    .label sintab = $14
    // u[4.12]
    // Iterate over the table
    .label x = $20
    .label i = $e
    // div16u(PI2_u4f12, wavelength)
    // [165] call div16u 
    // [241] phi from sin8s_gen to div16u [phi:sin8s_gen->div16u]
    jsr div16u
    // div16u(PI2_u4f12, wavelength)
    // [166] (word) div16u::return#2 ← (word) div16u::return#0
    // sin8s_gen::@3
    // step = div16u(PI2_u4f12, wavelength)
    // [167] (word) sin8s_gen::step#0 ← (word) div16u::return#2
    // [168] phi from sin8s_gen::@3 to sin8s_gen::@1 [phi:sin8s_gen::@3->sin8s_gen::@1]
    // [168] phi (signed byte*) sin8s_gen::sintab#2 = (const signed byte*) main::sintabb [phi:sin8s_gen::@3->sin8s_gen::@1#0] -- pbsz1=pbsc1 
    lda #<main.sintabb
    sta.z sintab
    lda #>main.sintabb
    sta.z sintab+1
    // [168] phi (word) sin8s_gen::x#2 = (word) 0 [phi:sin8s_gen::@3->sin8s_gen::@1#1] -- vwuz1=vwuc1 
    lda #<0
    sta.z x
    sta.z x+1
    // [168] phi (word) sin8s_gen::i#2 = (word) 0 [phi:sin8s_gen::@3->sin8s_gen::@1#2] -- vwuz1=vwuc1 
    sta.z i
    sta.z i+1
  // u[4.12]
    // sin8s_gen::@1
  __b1:
    // for( word i=0; i<wavelength; i++)
    // [169] if((word) sin8s_gen::i#2<(const word) main::wavelength) goto sin8s_gen::@2 -- vwuz1_lt_vwuc1_then_la1 
    lda.z i+1
    cmp #>main.wavelength
    bcc __b2
    bne !+
    lda.z i
    cmp #<main.wavelength
    bcc __b2
  !:
    // sin8s_gen::@return
    // }
    // [170] return 
    rts
    // sin8s_gen::@2
  __b2:
    // sin8s(x)
    // [171] (word) sin8s::x#0 ← (word) sin8s_gen::x#2 -- vwuz1=vwuz2 
    lda.z x
    sta.z sin8s.x
    lda.z x+1
    sta.z sin8s.x+1
    // [172] call sin8s 
    jsr sin8s
    // [173] (signed byte) sin8s::return#0 ← (signed byte) sin8s::return#1
    // sin8s_gen::@4
    // [174] (signed byte~) sin8s_gen::$2 ← (signed byte) sin8s::return#0
    // *sintab++ = sin8s(x)
    // [175] *((signed byte*) sin8s_gen::sintab#2) ← (signed byte~) sin8s_gen::$2 -- _deref_pbsz1=vbsaa 
    ldy #0
    sta (sintab),y
    // *sintab++ = sin8s(x);
    // [176] (signed byte*) sin8s_gen::sintab#0 ← ++ (signed byte*) sin8s_gen::sintab#2 -- pbsz1=_inc_pbsz1 
    inc.z sintab
    bne !+
    inc.z sintab+1
  !:
    // x = x + step
    // [177] (word) sin8s_gen::x#1 ← (word) sin8s_gen::x#2 + (word) sin8s_gen::step#0 -- vwuz1=vwuz1_plus_vwuz2 
    lda.z x
    clc
    adc.z step
    sta.z x
    lda.z x+1
    adc.z step+1
    sta.z x+1
    // for( word i=0; i<wavelength; i++)
    // [178] (word) sin8s_gen::i#1 ← ++ (word) sin8s_gen::i#2 -- vwuz1=_inc_vwuz1 
    inc.z i
    bne !+
    inc.z i+1
  !:
    // [168] phi from sin8s_gen::@4 to sin8s_gen::@1 [phi:sin8s_gen::@4->sin8s_gen::@1]
    // [168] phi (signed byte*) sin8s_gen::sintab#2 = (signed byte*) sin8s_gen::sintab#0 [phi:sin8s_gen::@4->sin8s_gen::@1#0] -- register_copy 
    // [168] phi (word) sin8s_gen::x#2 = (word) sin8s_gen::x#1 [phi:sin8s_gen::@4->sin8s_gen::@1#1] -- register_copy 
    // [168] phi (word) sin8s_gen::i#2 = (word) sin8s_gen::i#1 [phi:sin8s_gen::@4->sin8s_gen::@1#2] -- register_copy 
    jmp __b1
}
  // sin8s
// Calculate signed byte sinus sin(x)
// x: unsigned word input u[4.12] in the interval $0000 - PI2_u4f12
// result: signed byte sin(x) s[0.7] - using the full range  -$7f - $7f
// sin8s(word zp($11) x)
sin8s: {
    // u[2.6] x^3
    .const DIV_6 = $2b
    .label __4 = $11
    .label x = $11
    .label x1 = $22
    .label x3 = $23
    .label usinx = $24
    // Move x1 into the range 0-PI/2 using sinus mirror symmetries
    .label isUpper = $10
    // if(x >= PI_u4f12 )
    // [179] if((word) sin8s::x#0<(const word) PI_u4f12) goto sin8s::@1 -- vwuz1_lt_vwuc1_then_la1 
    lda.z x+1
    cmp #>PI_u4f12
    bcc b1
    bne !+
    lda.z x
    cmp #<PI_u4f12
    bcc b1
  !:
    // sin8s::@5
    // x = x - PI_u4f12
    // [180] (word) sin8s::x#1 ← (word) sin8s::x#0 - (const word) PI_u4f12 -- vwuz1=vwuz1_minus_vwuc1 
    lda.z x
    sec
    sbc #<PI_u4f12
    sta.z x
    lda.z x+1
    sbc #>PI_u4f12
    sta.z x+1
    // [181] phi from sin8s::@5 to sin8s::@1 [phi:sin8s::@5->sin8s::@1]
    // [181] phi (byte) sin8s::isUpper#10 = (byte) 1 [phi:sin8s::@5->sin8s::@1#0] -- vbuz1=vbuc1 
    lda #1
    sta.z isUpper
    // [181] phi (word) sin8s::x#4 = (word) sin8s::x#1 [phi:sin8s::@5->sin8s::@1#1] -- register_copy 
    jmp __b1
    // [181] phi from sin8s to sin8s::@1 [phi:sin8s->sin8s::@1]
  b1:
    // [181] phi (byte) sin8s::isUpper#10 = (byte) 0 [phi:sin8s->sin8s::@1#0] -- vbuz1=vbuc1 
    lda #0
    sta.z isUpper
    // [181] phi (word) sin8s::x#4 = (word) sin8s::x#0 [phi:sin8s->sin8s::@1#1] -- register_copy 
    // sin8s::@1
  __b1:
    // if(x >= PI_HALF_u4f12 )
    // [182] if((word) sin8s::x#4<(const word) PI_HALF_u4f12) goto sin8s::@2 -- vwuz1_lt_vwuc1_then_la1 
    lda.z x+1
    cmp #>PI_HALF_u4f12
    bcc __b2
    bne !+
    lda.z x
    cmp #<PI_HALF_u4f12
    bcc __b2
  !:
    // sin8s::@6
    // x = PI_u4f12 - x
    // [183] (word) sin8s::x#2 ← (const word) PI_u4f12 - (word) sin8s::x#4 -- vwuz1=vwuc1_minus_vwuz1 
    sec
    lda #<PI_u4f12
    sbc.z x
    sta.z x
    lda #>PI_u4f12
    sbc.z x+1
    sta.z x+1
    // [184] phi from sin8s::@1 sin8s::@6 to sin8s::@2 [phi:sin8s::@1/sin8s::@6->sin8s::@2]
    // [184] phi (word) sin8s::x#6 = (word) sin8s::x#4 [phi:sin8s::@1/sin8s::@6->sin8s::@2#0] -- register_copy 
    // sin8s::@2
  __b2:
    // x<<3
    // [185] (word~) sin8s::$4 ← (word) sin8s::x#6 << (byte) 3 -- vwuz1=vwuz1_rol_3 
    asl.z __4
    rol.z __4+1
    asl.z __4
    rol.z __4+1
    asl.z __4
    rol.z __4+1
    // x1 = >x<<3
    // [186] (byte) sin8s::x1#0 ← > (word~) sin8s::$4 -- vbuz1=_hi_vwuz2 
    lda.z __4+1
    sta.z x1
    // mulu8_sel(x1, x1, 0)
    // [187] (byte) mulu8_sel::v1#0 ← (byte) sin8s::x1#0 -- vbuxx=vbuz1 
    tax
    // [188] (byte) mulu8_sel::v2#0 ← (byte) sin8s::x1#0 -- vbuyy=vbuz1 
    tay
    // [189] call mulu8_sel 
    // [222] phi from sin8s::@2 to mulu8_sel [phi:sin8s::@2->mulu8_sel]
    // [222] phi (byte) mulu8_sel::select#5 = (byte) 0 [phi:sin8s::@2->mulu8_sel#0] -- vbuz1=vbuc1 
    lda #0
    sta.z mulu8_sel.select
    // [222] phi (byte) mulu8_sel::v2#5 = (byte) mulu8_sel::v2#0 [phi:sin8s::@2->mulu8_sel#1] -- register_copy 
    // [222] phi (byte) mulu8_sel::v1#5 = (byte) mulu8_sel::v1#0 [phi:sin8s::@2->mulu8_sel#2] -- register_copy 
    jsr mulu8_sel
    // mulu8_sel(x1, x1, 0)
    // [190] (byte) mulu8_sel::return#0 ← (byte) mulu8_sel::return#12
    // sin8s::@9
    // x2 = mulu8_sel(x1, x1, 0)
    // [191] (byte) sin8s::x2#0 ← (byte) mulu8_sel::return#0
    // mulu8_sel(x2, x1, 1)
    // [192] (byte) mulu8_sel::v1#1 ← (byte) sin8s::x2#0 -- vbuxx=vbuaa 
    tax
    // [193] (byte) mulu8_sel::v2#1 ← (byte) sin8s::x1#0 -- vbuyy=vbuz1 
    ldy.z x1
    // [194] call mulu8_sel 
    // [222] phi from sin8s::@9 to mulu8_sel [phi:sin8s::@9->mulu8_sel]
    // [222] phi (byte) mulu8_sel::select#5 = (byte) 1 [phi:sin8s::@9->mulu8_sel#0] -- vbuz1=vbuc1 
    lda #1
    sta.z mulu8_sel.select
    // [222] phi (byte) mulu8_sel::v2#5 = (byte) mulu8_sel::v2#1 [phi:sin8s::@9->mulu8_sel#1] -- register_copy 
    // [222] phi (byte) mulu8_sel::v1#5 = (byte) mulu8_sel::v1#1 [phi:sin8s::@9->mulu8_sel#2] -- register_copy 
    jsr mulu8_sel
    // mulu8_sel(x2, x1, 1)
    // [195] (byte) mulu8_sel::return#1 ← (byte) mulu8_sel::return#12
    // sin8s::@10
    // x3 = mulu8_sel(x2, x1, 1)
    // [196] (byte) sin8s::x3#0 ← (byte) mulu8_sel::return#1 -- vbuz1=vbuaa 
    sta.z x3
    // mulu8_sel(x3, DIV_6, 1)
    // [197] (byte) mulu8_sel::v1#2 ← (byte) sin8s::x3#0 -- vbuxx=vbuz1 
    tax
    // [198] call mulu8_sel 
    // [222] phi from sin8s::@10 to mulu8_sel [phi:sin8s::@10->mulu8_sel]
    // [222] phi (byte) mulu8_sel::select#5 = (byte) 1 [phi:sin8s::@10->mulu8_sel#0] -- vbuz1=vbuc1 
    lda #1
    sta.z mulu8_sel.select
    // [222] phi (byte) mulu8_sel::v2#5 = (const byte) sin8s::DIV_6 [phi:sin8s::@10->mulu8_sel#1] -- vbuyy=vbuc1 
    ldy #DIV_6
    // [222] phi (byte) mulu8_sel::v1#5 = (byte) mulu8_sel::v1#2 [phi:sin8s::@10->mulu8_sel#2] -- register_copy 
    jsr mulu8_sel
    // mulu8_sel(x3, DIV_6, 1)
    // [199] (byte) mulu8_sel::return#2 ← (byte) mulu8_sel::return#12
    // sin8s::@11
    // x3_6 = mulu8_sel(x3, DIV_6, 1)
    // [200] (byte) sin8s::x3_6#0 ← (byte) mulu8_sel::return#2
    // usinx = x1 - x3_6
    // [201] (byte) sin8s::usinx#0 ← (byte) sin8s::x1#0 - (byte) sin8s::x3_6#0 -- vbuz1=vbuz2_minus_vbuaa 
    eor #$ff
    sec
    adc.z x1
    sta.z usinx
    // mulu8_sel(x3, x1, 0)
    // [202] (byte) mulu8_sel::v1#3 ← (byte) sin8s::x3#0 -- vbuxx=vbuz1 
    ldx.z x3
    // [203] (byte) mulu8_sel::v2#3 ← (byte) sin8s::x1#0 -- vbuyy=vbuz1 
    ldy.z x1
    // [204] call mulu8_sel 
    // [222] phi from sin8s::@11 to mulu8_sel [phi:sin8s::@11->mulu8_sel]
    // [222] phi (byte) mulu8_sel::select#5 = (byte) 0 [phi:sin8s::@11->mulu8_sel#0] -- vbuz1=vbuc1 
    lda #0
    sta.z mulu8_sel.select
    // [222] phi (byte) mulu8_sel::v2#5 = (byte) mulu8_sel::v2#3 [phi:sin8s::@11->mulu8_sel#1] -- register_copy 
    // [222] phi (byte) mulu8_sel::v1#5 = (byte) mulu8_sel::v1#3 [phi:sin8s::@11->mulu8_sel#2] -- register_copy 
    jsr mulu8_sel
    // mulu8_sel(x3, x1, 0)
    // [205] (byte) mulu8_sel::return#10 ← (byte) mulu8_sel::return#12
    // sin8s::@12
    // x4 = mulu8_sel(x3, x1, 0)
    // [206] (byte) sin8s::x4#0 ← (byte) mulu8_sel::return#10
    // mulu8_sel(x4, x1, 0)
    // [207] (byte) mulu8_sel::v1#4 ← (byte) sin8s::x4#0 -- vbuxx=vbuaa 
    tax
    // [208] (byte) mulu8_sel::v2#4 ← (byte) sin8s::x1#0 -- vbuyy=vbuz1 
    ldy.z x1
    // [209] call mulu8_sel 
    // [222] phi from sin8s::@12 to mulu8_sel [phi:sin8s::@12->mulu8_sel]
    // [222] phi (byte) mulu8_sel::select#5 = (byte) 0 [phi:sin8s::@12->mulu8_sel#0] -- vbuz1=vbuc1 
    lda #0
    sta.z mulu8_sel.select
    // [222] phi (byte) mulu8_sel::v2#5 = (byte) mulu8_sel::v2#4 [phi:sin8s::@12->mulu8_sel#1] -- register_copy 
    // [222] phi (byte) mulu8_sel::v1#5 = (byte) mulu8_sel::v1#4 [phi:sin8s::@12->mulu8_sel#2] -- register_copy 
    jsr mulu8_sel
    // mulu8_sel(x4, x1, 0)
    // [210] (byte) mulu8_sel::return#11 ← (byte) mulu8_sel::return#12
    // sin8s::@13
    // x5 = mulu8_sel(x4, x1, 0)
    // [211] (byte) sin8s::x5#0 ← (byte) mulu8_sel::return#11
    // x5_128 = x5>>4
    // [212] (byte) sin8s::x5_128#0 ← (byte) sin8s::x5#0 >> (byte) 4 -- vbuaa=vbuaa_ror_4 
    lsr
    lsr
    lsr
    lsr
    // usinx = usinx + x5_128
    // [213] (byte) sin8s::usinx#1 ← (byte) sin8s::usinx#0 + (byte) sin8s::x5_128#0 -- vbuxx=vbuz1_plus_vbuaa 
    clc
    adc.z usinx
    tax
    // if(usinx>=128)
    // [214] if((byte) sin8s::usinx#1<(byte) $80) goto sin8s::@3 -- vbuxx_lt_vbuc1_then_la1 
    cpx #$80
    bcc __b3
    // sin8s::@7
    // usinx--;
    // [215] (byte) sin8s::usinx#2 ← -- (byte) sin8s::usinx#1 -- vbuxx=_dec_vbuxx 
    dex
    // [216] phi from sin8s::@13 sin8s::@7 to sin8s::@3 [phi:sin8s::@13/sin8s::@7->sin8s::@3]
    // [216] phi (byte) sin8s::usinx#4 = (byte) sin8s::usinx#1 [phi:sin8s::@13/sin8s::@7->sin8s::@3#0] -- register_copy 
    // sin8s::@3
  __b3:
    // if(isUpper!=0)
    // [217] if((byte) sin8s::isUpper#10==(byte) 0) goto sin8s::@14 -- vbuz1_eq_0_then_la1 
    lda.z isUpper
    cmp #0
    beq __b14
    // sin8s::@8
    // sinx = -(signed byte)usinx
    // [218] (signed byte) sin8s::sinx#1 ← - (signed byte)(byte) sin8s::usinx#4 -- vbsaa=_neg_vbsxx 
    txa
    eor #$ff
    clc
    adc #1
    // [219] phi from sin8s::@14 sin8s::@8 to sin8s::@4 [phi:sin8s::@14/sin8s::@8->sin8s::@4]
    // [219] phi (signed byte) sin8s::return#1 = (signed byte) sin8s::return#5 [phi:sin8s::@14/sin8s::@8->sin8s::@4#0] -- register_copy 
    // sin8s::@4
    // sin8s::@return
    // }
    // [220] return 
    rts
    // sin8s::@14
  __b14:
    // [221] (signed byte) sin8s::return#5 ← (signed byte)(byte) sin8s::usinx#4 -- vbsaa=vbsxx 
    txa
    rts
}
  // mulu8_sel
// Calculate val*val for two unsigned byte values - the result is 8 selected bits of the 16-bit result.
// The select parameter indicates how many of the highest bits of the 16-bit result to skip
// mulu8_sel(byte register(X) v1, byte register(Y) v2, byte zp($13) select)
mulu8_sel: {
    .label __0 = $11
    .label __1 = $11
    .label select = $13
    // mul8u(v1, v2)
    // [223] (byte) mul8u::a#1 ← (byte) mulu8_sel::v1#5
    // [224] (byte) mul8u::b#0 ← (byte) mulu8_sel::v2#5 -- vbuaa=vbuyy 
    tya
    // [225] call mul8u 
    jsr mul8u
    // [226] (word) mul8u::return#2 ← (word) mul8u::res#2
    // mulu8_sel::@1
    // [227] (word~) mulu8_sel::$0 ← (word) mul8u::return#2
    // mul8u(v1, v2)<<select
    // [228] (word~) mulu8_sel::$1 ← (word~) mulu8_sel::$0 << (byte) mulu8_sel::select#5 -- vwuz1=vwuz1_rol_vbuz2 
    ldy.z select
    beq !e+
  !:
    asl.z __1
    rol.z __1+1
    dey
    bne !-
  !e:
    // >mul8u(v1, v2)<<select
    // [229] (byte) mulu8_sel::return#12 ← > (word~) mulu8_sel::$1 -- vbuaa=_hi_vwuz1 
    lda.z __1+1
    // mulu8_sel::@return
    // }
    // [230] return 
    rts
}
  // mul8u
// Perform binary multiplication of two unsigned 8-bit bytes into a 16-bit unsigned word
// mul8u(byte register(X) a, byte register(A) b)
mul8u: {
    .label mb = $1e
    .label res = $11
    .label return = $11
    // mb = b
    // [231] (word) mul8u::mb#0 ← (word)(byte) mul8u::b#0 -- vwuz1=_word_vbuaa 
    sta.z mb
    lda #0
    sta.z mb+1
    // [232] phi from mul8u to mul8u::@1 [phi:mul8u->mul8u::@1]
    // [232] phi (word) mul8u::mb#2 = (word) mul8u::mb#0 [phi:mul8u->mul8u::@1#0] -- register_copy 
    // [232] phi (word) mul8u::res#2 = (word) 0 [phi:mul8u->mul8u::@1#1] -- vwuz1=vwuc1 
    sta.z res
    sta.z res+1
    // [232] phi (byte) mul8u::a#2 = (byte) mul8u::a#1 [phi:mul8u->mul8u::@1#2] -- register_copy 
    // mul8u::@1
  __b1:
    // while(a!=0)
    // [233] if((byte) mul8u::a#2!=(byte) 0) goto mul8u::@2 -- vbuxx_neq_0_then_la1 
    cpx #0
    bne __b2
    // mul8u::@return
    // }
    // [234] return 
    rts
    // mul8u::@2
  __b2:
    // a&1
    // [235] (byte~) mul8u::$1 ← (byte) mul8u::a#2 & (byte) 1 -- vbuaa=vbuxx_band_vbuc1 
    txa
    and #1
    // if( (a&1) != 0)
    // [236] if((byte~) mul8u::$1==(byte) 0) goto mul8u::@3 -- vbuaa_eq_0_then_la1 
    cmp #0
    beq __b3
    // mul8u::@4
    // res = res + mb
    // [237] (word) mul8u::res#1 ← (word) mul8u::res#2 + (word) mul8u::mb#2 -- vwuz1=vwuz1_plus_vwuz2 
    lda.z res
    clc
    adc.z mb
    sta.z res
    lda.z res+1
    adc.z mb+1
    sta.z res+1
    // [238] phi from mul8u::@2 mul8u::@4 to mul8u::@3 [phi:mul8u::@2/mul8u::@4->mul8u::@3]
    // [238] phi (word) mul8u::res#6 = (word) mul8u::res#2 [phi:mul8u::@2/mul8u::@4->mul8u::@3#0] -- register_copy 
    // mul8u::@3
  __b3:
    // a = a>>1
    // [239] (byte) mul8u::a#0 ← (byte) mul8u::a#2 >> (byte) 1 -- vbuxx=vbuxx_ror_1 
    txa
    lsr
    tax
    // mb = mb<<1
    // [240] (word) mul8u::mb#1 ← (word) mul8u::mb#2 << (byte) 1 -- vwuz1=vwuz1_rol_1 
    asl.z mb
    rol.z mb+1
    // [232] phi from mul8u::@3 to mul8u::@1 [phi:mul8u::@3->mul8u::@1]
    // [232] phi (word) mul8u::mb#2 = (word) mul8u::mb#1 [phi:mul8u::@3->mul8u::@1#0] -- register_copy 
    // [232] phi (word) mul8u::res#2 = (word) mul8u::res#6 [phi:mul8u::@3->mul8u::@1#1] -- register_copy 
    // [232] phi (byte) mul8u::a#2 = (byte) mul8u::a#0 [phi:mul8u::@3->mul8u::@1#2] -- register_copy 
    jmp __b1
}
  // div16u
// Performs division on two 16 bit unsigned words
// Returns the quotient dividend/divisor.
// The remainder will be set into the global variable rem16u
// Implemented using simple binary division
div16u: {
    .label return = $c
    // divr16u(dividend, divisor, 0)
    // [242] call divr16u 
    // [146] phi from div16u to divr16u [phi:div16u->divr16u]
    // [146] phi (word) divr16u::dividend#6 = (const word) PI2_u4f12 [phi:div16u->divr16u#0] -- vwuz1=vwuc1 
    lda #<PI2_u4f12
    sta.z divr16u.dividend
    lda #>PI2_u4f12
    sta.z divr16u.dividend+1
    // [146] phi (word) divr16u::rem#11 = (byte) 0 [phi:div16u->divr16u#1] -- vwuz1=vbuc1 
    lda #<0
    sta.z divr16u.rem
    sta.z divr16u.rem+1
    jsr divr16u
    // divr16u(dividend, divisor, 0)
    // [243] (word) divr16u::return#2 ← (word) divr16u::return#0
    // div16u::@1
    // [244] (word) div16u::return#0 ← (word) divr16u::return#2
    // div16u::@return
    // }
    // [245] return 
    rts
}
  // File Data
  print_hextab: .text "0123456789abcdef"

