Added fragments. Added bitmap spiral test.

src/main/fragment/vdsz1=vdsz1_rol_3.asm

@@ -0,0 +1,12 @@
+asl {z1}
+rol {z1}+1
+rol {z1}+2
+rol {z1}+3
+asl {z1}
+rol {z1}+1
+rol {z1}+2
+rol {z1}+3
+asl {z1}
+rol {z1}+1
+rol {z1}+2
+rol {z1}+3

src/main/fragment/vdsz1=vdsz1_rol_4.asm

@@ -0,0 +1,16 @@
+asl {z1}
+rol {z1}+1
+rol {z1}+2
+rol {z1}+3
+asl {z1}
+rol {z1}+1
+rol {z1}+2
+rol {z1}+3
+asl {z1}
+rol {z1}+1
+rol {z1}+2
+rol {z1}+3
+asl {z1}
+rol {z1}+1
+rol {z1}+2
+rol {z1}+3

src/main/fragment/vdsz1=vdsz2_rol_4.asm

@@ -0,0 +1,24 @@
+lda {z2}
+sta {z1}
+lda {z2}+1
+sta {z1}+1
+lda {z2}+2
+sta {z1}+2
+lda {z2}+3
+sta {z1}+3
+asl {z1}
+rol {z1}+1
+rol {z1}+2
+rol {z1}+3
+asl {z1}
+rol {z1}+1
+rol {z1}+2
+rol {z1}+3
+asl {z1}
+rol {z1}+1
+rol {z1}+2
+rol {z1}+3
+asl {z1}
+rol {z1}+1
+rol {z1}+2
+rol {z1}+3

src/main/fragment/vdsz1=vdsz2_ror_1.asm

@@ -0,0 +1,13 @@
+lda {z2}+3
+cmp #$80
+ror
+sta {z1}+3
+lda {z2}+2
+ror
+sta {z1}+2
+lda {z2}+1
+ror
+sta {z1}+1
+lda {z2}
+ror
+sta {z1}

src/main/fragment/vwsz1=_deref_pwsc1.asm

@@ -0,0 +1,4 @@
+lda {c1}
+sta {z1}
+lda {c1}+1
+sta {z1}+1

src/main/fragment/vwsz1=_deref_pwsz1_plus_vwsc1.asm

@@ -0,0 +1,11 @@
+ldy #0
+lda ({z1}),y
+clc
+adc #<{c1}
+pha
+iny
+lda ({z1}),y
+adc #>{c1}
+sta {z1}+1
+pla
+sta {z1}

src/main/fragment/vwsz1=_deref_pwsz2_plus_vwsc1.asm

@@ -0,0 +1,9 @@
+ldy #0
+lda ({z2}),y
+clc
+adc #<{c1}
+sta {z1}
+iny
+lda ({z2}),y
+adc #>{c1}
+sta {z1}+1

src/main/fragment/vwsz1=vwsz1_plus_vbuz2.asm

@@ -0,0 +1,7 @@
+clc
+lda {z1}
+adc {z1}
+sta {z1}
+lda {z1}+1
+adc #0
+sta {z1}+1

src/main/fragment/vwsz1=vwsz1_ror_2.asm

@@ -0,0 +1,9 @@
+lda {z1}+1
+cmp #$80
+ror {z1}+1
+ror {z1}
+lda {z1}+1
+cmp #$80
+ror {z1}+1
+ror {z1}
+

src/main/fragment/vwsz1=vwsz1_ror_4.asm

@@ -0,0 +1,17 @@
+lda {z1}+1
+cmp #$80
+ror {z1}+1
+ror {z1}
+lda {z1}+1
+cmp #$80
+ror {z1}+1
+ror {z1}
+lda {z1}+1
+cmp #$80
+ror {z1}+1
+ror {z1}
+lda {z1}+1
+cmp #$80
+ror {z1}+1
+ror {z1}
+

src/main/fragment/vwsz1=vwsz1_ror_5.asm

@@ -0,0 +1,21 @@
+lda {z1}+1
+cmp #$80
+ror {z1}+1
+ror {z1}
+lda {z1}+1
+cmp #$80
+ror {z1}+1
+ror {z1}
+lda {z1}+1
+cmp #$80
+ror {z1}+1
+ror {z1}
+lda {z1}+1
+cmp #$80
+ror {z1}+1
+ror {z1}
+lda {z1}+1
+cmp #$80
+ror {z1}+1
+ror {z1}
+

src/main/fragment/vwsz1=vwsz2_ror_2.asm

@@ -0,0 +1,11 @@
+lda {z2}+1
+cmp #$80
+ror
+sta {z1}+1
+lda {z2}
+ror
+sta {z1}
+lda {z1}+1
+cmp #$80
+ror {z1}+1
+ror {z1}

src/main/fragment/vwsz1_lt_vwsc1_then_la1.asm

@@ -0,0 +1,8 @@
+lda {z1}
+cmp #<{c1}
+lda {z1}+1
+sbc #>{c1}
+bvc !+
+eor #$80
+!:
+bmi {la1}

src/main/fragment/vwuz1=vwuc1_plus__hi_vdsz2.asm

@@ -0,0 +1,7 @@
+clc
+lda #<{c1}
+adc {z2}+2
+sta {z1}
+lda #>{c1}
+adc {z2}+3
+sta {z1}+1

src/main/fragment/vwuz1=vwuc1_plus__hi_vduz2.asm

@@ -0,0 +1,7 @@
+clc
+lda #<{c1}
+adc {z2}+2
+sta {z1}
+lda #>{c1}
+adc {z2}+3
+sta {z1}+1

src/main/fragment/vwuz1=vwuz1_ror_5.asm

@@ -0,0 +1,10 @@
+lsr {z1}+1
+ror {z1}
+lsr {z1}+1
+ror {z1}
+lsr {z1}+1
+ror {z1}
+lsr {z1}+1
+ror {z1}
+lsr {z1}+1
+ror {z1}

src/main/fragment/vwuz1=vwuz2_rol_5.asm

@@ -0,0 +1,14 @@
+lda {z2}
+asl
+sta {z1}
+lda {z2}+1
+rol
+sta {z1}+1
+asl {z1}
+rol {z1}+1
+asl {z1}
+rol {z1}+1
+asl {z1}
+rol {z1}+1
+asl {z1}
+rol {z1}+1

src/main/fragment/vwuz1=vwuz2_ror_4.asm

@@ -1,10 +1,12 @@
 lda {z2}+1
+lsr
 sta {z1}+1
 lda {z2}
+ror
 sta {z1}
-ldy #4
-!:
 lsr {z1}+1
 ror {z1}
-dey
-bne !-
+lsr {z1}+1
+ror {z1}
+lsr {z1}+1
+ror {z1}

src/main/fragment/vwuz1=vwuz2_ror_5.asm

@@ -0,0 +1,14 @@
+lda {z2}+1
+lsr
+sta {z1}+1
+lda {z2}
+ror
+sta {z1}
+lsr {z1}+1
+ror {z1}
+lsr {z1}+1
+ror {z1}
+lsr {z1}+1
+ror {z1}
+lsr {z1}+1
+ror {z1}

src/main/fragment/vwuz1=vwuz2_ror_6.asm

@@ -1,10 +1,16 @@
 lda {z2}+1
+lsr
 sta {z1}+1
 lda {z2}
+ror
 sta {z1}
-ldy #6
-!:
 lsr {z1}+1
 ror {z1}
-dey
-bne !-
+lsr {z1}+1
+ror {z1}
+lsr {z1}+1
+ror {z1}
+lsr {z1}+1
+ror {z1}
+lsr {z1}+1
+ror {z1}

src/test/java/dk/camelot64/kickc/test/TestPrograms.java

@@ -36,8 +36,18 @@ public class TestPrograms {
    }
 
    @Test
-   public void testBitmapPlot() throws IOException, URISyntaxException {
-      compileAndCompare("bitmap-plot", log());
+   public void testBitmapPlot2() throws IOException, URISyntaxException {
+      compileAndCompare("bitmap-plot-2", log());
+   }
+
+   @Test
+   public void testBitmapPlot1() throws IOException, URISyntaxException {
+      compileAndCompare("bitmap-plot-1");
+   }
+
+   @Test
+   public void testBitmapPlot0() throws IOException, URISyntaxException {
+      compileAndCompare("bitmap-plot-0");
    }
 
    @Test

src/test/kc/bitmap-plot-0.kc

@@ -1,4 +1,5 @@
 // Tests the simple bitmap plotter - and counts plots per frame in an IRQ
+// Plots simple plots
 import "c64"
 import "bitmap2"
 

src/test/kc/bitmap-plot-1.kc

@@ -0,0 +1,66 @@
+// Tests the simple bitmap plotter - and counts plots per frame in an IRQ
+// Plots a fullscreen elipsis
+import "c64"
+import "sinus"
+import "multiply"
+import "bitmap2"
+
+byte* BITMAP = 0x2000;
+byte* SCREEN = 0x0400;
+
+byte[0x100] plots_per_frame;
+
+align(0x100) signed word[512] SINUS;
+
+void main() {
+    sin16s_gen2(SINUS, 512, -0x1001, 0x1001);
+    bitmap_init(BITMAP, SCREEN);
+    bitmap_clear(BLACK, WHITE);
+    *D011 = VIC_BMM|VIC_DEN|VIC_RSEL|3;
+    *D018 = toD018(SCREEN, BITMAP);
+    init_irq();
+    word idx_x = 0;
+    word idx_y = 0x80;
+    while(true) {
+        signed word cos_x = SINUS[idx_x];
+        signed dword xpos = mul16s(160, cos_x);
+        word x = (word)(160 + >(xpos<<4));
+        signed word sin_y = SINUS[idx_y];
+        signed dword ypos = mul16s(100, sin_y);
+        word y = (word)(100 + >(ypos<<4));
+        bitmap_plot(x, (byte)y);
+        if(++idx_x==512) idx_x = 0;
+        if(++idx_y==512) idx_y = 0;
+        plots_per_frame[frame_cnt]++;
+    }
+}
+
+// Counts frames - updated by the IRQ
+volatile byte frame_cnt = 1;
+
+// Setup the IRQ
+void init_irq() {
+    asm { sei }
+    // Disable kernal & basic
+    *PROCPORT_DDR = PROCPORT_DDR_MEMORY_MASK;
+    *PROCPORT = PROCPORT_RAM_IO;
+    // Disable CIA 1 Timer IRQ
+    *CIA1_INTERRUPT = CIA_INTERRUPT_CLEAR;
+    // Set raster line to $100
+    *VIC_CONTROL |=$80;
+    *RASTER = $00;
+    // Enable Raster Interrupt
+    *IRQ_ENABLE = IRQ_RASTER;
+    // Set the IRQ routine
+    *HARDWARE_IRQ = &irq;
+    asm { cli }
+}
+
+// Interrupt Routine counting frames
+interrupt(hardware_clobber) void irq() {
+    *BGCOL = WHITE;
+    if(frame_cnt) frame_cnt++;
+    *BGCOL = BLACK;
+    // Acknowledge the IRQ
+    *IRQ_STATUS = IRQ_RASTER;
+}

src/test/kc/bitmap-plot-2.kc

@@ -0,0 +1,75 @@
+// Tests the simple bitmap plotter - and counts plots per frame in an IRQ
+// Plots a spiral
+import "c64"
+import "sinus"
+import "multiply"
+import "bitmap2"
+
+byte* BITMAP = 0x2000;
+byte* SCREEN = 0x0400;
+
+byte[0x100] plots_per_frame;
+
+align(0x100) signed word[512] SINUS;
+
+void main() {
+    sin16s_gen2(SINUS, 512, -0x1001, 0x1001);
+    bitmap_init(BITMAP, SCREEN);
+    bitmap_clear(BLACK, WHITE);
+    *D011 = VIC_BMM|VIC_DEN|VIC_RSEL|3;
+    *D018 = toD018(SCREEN, BITMAP);
+    init_irq();
+    word idx_x = 0;
+    word idx_y = 0x80;
+    signed word r = 0;
+    byte r_add = 4;
+    while(true) {
+        signed word cos_x = SINUS[idx_x];
+        signed dword xpos = mul16s(r, cos_x);
+        word x = (word)(160 + ((signed word)>xpos)>>2);
+        signed word sin_y = SINUS[idx_y];
+        signed dword ypos = mul16s(r, sin_y);
+        word y = (word)(100 + ((signed word)>ypos)>>2);
+        bitmap_plot(x, (byte)y);
+        plots_per_frame[frame_cnt]++;
+        idx_x += r_add;
+        if(idx_x>=512) idx_x = 0;
+        idx_y += r_add;
+        if(idx_y>=512) idx_y = 0;
+        r += r_add;
+        //if((idx_x==0) && (r_add!=1)) r_add /= 2;
+        if(r>=512*12+256) break;
+    }
+    while(true)
+        (*BORDERCOL)++;
+}
+
+// Counts frames - updated by the IRQ
+volatile byte frame_cnt = 1;
+
+// Setup the IRQ
+void init_irq() {
+    asm { sei }
+    // Disable kernal & basic
+    *PROCPORT_DDR = PROCPORT_DDR_MEMORY_MASK;
+    *PROCPORT = PROCPORT_RAM_IO;
+    // Disable CIA 1 Timer IRQ
+    *CIA1_INTERRUPT = CIA_INTERRUPT_CLEAR;
+    // Set raster line to $100
+    *VIC_CONTROL |=$80;
+    *RASTER = $00;
+    // Enable Raster Interrupt
+    *IRQ_ENABLE = IRQ_RASTER;
+    // Set the IRQ routine
+    *HARDWARE_IRQ = &irq;
+    asm { cli }
+}
+
+// Interrupt Routine counting frames
+interrupt(hardware_clobber) void irq() {
+    *BGCOL = WHITE;
+    if(frame_cnt) frame_cnt++;
+    *BGCOL = BLACK;
+    // Acknowledge the IRQ
+    *IRQ_STATUS = IRQ_RASTER;
+}

src/test/kc/examples/sinplotter/sine-plotter.kc

@@ -30,9 +30,8 @@ void main() {
     *D016 = VIC_CSEL;
     *D018 = toD018(SCREEN, BITMAP);
 
-    memset(SCREEN, WHITE, 1000);
-    bitmap_init(BITMAP);
-    bitmap_clear();
+    bitmap_init(BITMAP, SCREEN);
+    bitmap_clear(BLACK, WHITE);
     sin16s_gen2(sin, SIN_SIZE, -320, 320);
     render_sine();
     while(true) {

src/test/ref/bitmap-plot-0.asm

@@ -1,4 +1,5 @@
 // Tests the simple bitmap plotter - and counts plots per frame in an IRQ
+// Plots simple plots
 .pc = $801 "Basic"
 :BasicUpstart(bbegin)
 .pc = $80d "Program"

src/test/ref/bitmap-plot-0.log

@@ -1830,6 +1830,7 @@ Allocated zp ZP_BYTE:36 [ bitmap_init::$6 ]
 INITIAL ASM
 //SEG0 File Comments
 // Tests the simple bitmap plotter - and counts plots per frame in an IRQ
+// Plots simple plots
 //SEG1 Basic Upstart
 .pc = $801 "Basic"
 :BasicUpstart(bbegin)
@@ -2586,6 +2587,7 @@ Removing interrupt register storage ldy #00 in SEG162 [85] return  - exit interr
 ASSEMBLER BEFORE OPTIMIZATION
 //SEG0 File Comments
 // Tests the simple bitmap plotter - and counts plots per frame in an IRQ
+// Plots simple plots
 //SEG1 Basic Upstart
 .pc = $801 "Basic"
 :BasicUpstart(bbegin)
@@ -3450,6 +3452,7 @@ Score: 3136
 
 //SEG0 File Comments
 // Tests the simple bitmap plotter - and counts plots per frame in an IRQ
+// Plots simple plots
 //SEG1 Basic Upstart
 .pc = $801 "Basic"
 :BasicUpstart(bbegin)

src/test/ref/bitmap-plot-2.asm

@@ -0,0 +1,934 @@
+// Tests the simple bitmap plotter - and counts plots per frame in an IRQ
+// Plots a spiral
+.pc = $801 "Basic"
+:BasicUpstart(bbegin)
+.pc = $80d "Program"
+  .const SIZEOF_SIGNED_WORD = 2
+  // Processor port data direction register
+  .label PROCPORT_DDR = 0
+  // Mask for PROCESSOR_PORT_DDR which allows only memory configuration to be written
+  .const PROCPORT_DDR_MEMORY_MASK = 7
+  // Processor Port Register controlling RAM/ROM configuration and the datasette
+  .label PROCPORT = 1
+  // RAM in $A000, $E000 I/O in $D000
+  .const PROCPORT_RAM_IO = $35
+  .label RASTER = $d012
+  .label BORDERCOL = $d020
+  .label BGCOL = $d021
+  .label VIC_CONTROL = $d011
+  .label D011 = $d011
+  .const VIC_BMM = $20
+  .const VIC_DEN = $10
+  .const VIC_RSEL = 8
+  .label D018 = $d018
+  // VIC II IRQ Status Register
+  .label IRQ_STATUS = $d019
+  // VIC II IRQ Enable Register
+  .label IRQ_ENABLE = $d01a
+  // Bits for the IRQ Status/Enable Registers
+  .const IRQ_RASTER = 1
+  // CIA#1 Interrupt Status & Control Register
+  .label CIA1_INTERRUPT = $dc0d
+  // Value that disables all CIA interrupts when stored to the CIA Interrupt registers
+  .const CIA_INTERRUPT_CLEAR = $7f
+  // The vector used when the HARDWARE serves IRQ interrupts
+  .label HARDWARE_IRQ = $fffe
+  // The colors of the C64
+  .const BLACK = 0
+  .const WHITE = 1
+  // 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
+  .label BITMAP = $2000
+  .label SCREEN = $400
+  .label rem16u = $2b
+  .label frame_cnt = $31
+bbegin:
+  // Counts frames - updated by the IRQ
+  lda #1
+  sta frame_cnt
+  jsr main
+  rts
+main: {
+    .const r_add = 4
+    .const toD0181_return = (>(SCREEN&$3fff)*4)|(>BITMAP)/4&$f
+    .label _9 = $32
+    .label _11 = $32
+    .label _15 = $34
+    .label _17 = $34
+    .label _18 = $34
+    .label _28 = 8
+    .label _29 = 8
+    .label cos_x = 8
+    .label xpos = $a
+    .label sin_y = 8
+    .label ypos = $a
+    .label idx_x = 2
+    .label idx_y = 6
+    .label r = 4
+    .label _30 = 8
+    .label _31 = 8
+    jsr sin16s_gen2
+    jsr bitmap_init
+    jsr bitmap_clear
+    lda #VIC_BMM|VIC_DEN|VIC_RSEL|3
+    sta D011
+    lda #toD0181_return
+    sta D018
+    jsr init_irq
+    lda #$80
+    sta idx_y
+    lda #0
+    sta idx_y+1
+    sta r
+    sta r+1
+    sta idx_x
+    sta idx_x+1
+  b2:
+    lda idx_x
+    asl
+    sta _28
+    lda idx_x+1
+    rol
+    sta _28+1
+    clc
+    lda _30
+    adc #<SINUS
+    sta _30
+    lda _30+1
+    adc #>SINUS
+    sta _30+1
+    ldy #0
+    lda (cos_x),y
+    tax
+    iny
+    lda (cos_x),y
+    stx cos_x
+    sta cos_x+1
+    jsr mul16s
+    lda xpos+2
+    sta _9
+    lda xpos+3
+    sta _9+1
+    lda _11+1
+    cmp #$80
+    ror _11+1
+    ror _11
+    lda _11+1
+    cmp #$80
+    ror _11+1
+    ror _11
+    clc
+    lda bitmap_plot.x
+    adc #<$a0
+    sta bitmap_plot.x
+    lda bitmap_plot.x+1
+    adc #>$a0
+    sta bitmap_plot.x+1
+    lda idx_y
+    asl
+    sta _29
+    lda idx_y+1
+    rol
+    sta _29+1
+    clc
+    lda _31
+    adc #<SINUS
+    sta _31
+    lda _31+1
+    adc #>SINUS
+    sta _31+1
+    ldy #0
+    lda (sin_y),y
+    tax
+    iny
+    lda (sin_y),y
+    stx sin_y
+    sta sin_y+1
+    jsr mul16s
+    lda ypos+2
+    sta _15
+    lda ypos+3
+    sta _15+1
+    lda _17+1
+    cmp #$80
+    ror _17+1
+    ror _17
+    lda _17+1
+    cmp #$80
+    ror _17+1
+    ror _17
+    lda #$64
+    sta $fe
+    ora #$7f
+    bmi !+
+    lda #0
+  !:
+    sta $ff
+    clc
+    lda _18
+    adc $fe
+    sta _18
+    lda _18+1
+    adc $ff
+    sta _18+1
+    lda _18
+    jsr bitmap_plot
+    ldx frame_cnt
+    inc plots_per_frame,x
+    lda #r_add
+    clc
+    adc idx_x
+    sta idx_x
+    bcc !+
+    inc idx_x+1
+  !:
+    lda idx_x+1
+    cmp #>$200
+    bcc b3
+    bne !+
+    lda idx_x
+    cmp #<$200
+    bcc b3
+  !:
+    lda #0
+    sta idx_x
+    sta idx_x+1
+  b3:
+    lda #r_add
+    clc
+    adc idx_y
+    sta idx_y
+    bcc !+
+    inc idx_y+1
+  !:
+    lda idx_y+1
+    cmp #>$200
+    bcc b4
+    bne !+
+    lda idx_y
+    cmp #<$200
+    bcc b4
+  !:
+    lda #0
+    sta idx_y
+    sta idx_y+1
+  b4:
+    lda #r_add
+    sta $fe
+    ora #$7f
+    bmi !+
+    lda #0
+  !:
+    sta $ff
+    clc
+    lda r
+    adc $fe
+    sta r
+    lda r+1
+    adc $ff
+    sta r+1
+    lda r
+    cmp #<$200*$c+$100
+    lda r+1
+    sbc #>$200*$c+$100
+    bvc !+
+    eor #$80
+  !:
+    bpl b5
+    jmp b2
+  b5:
+    inc BORDERCOL
+    jmp b5
+}
+// Plot a single dot in the bitmap
+// bitmap_plot(signed word zeropage($32) x, byte register(A) y)
+bitmap_plot: {
+    .label _1 = $38
+    .label plotter = $36
+    .label x = $32
+    .label _3 = $36
+    tay
+    lda bitmap_plot_yhi,y
+    sta _3+1
+    lda bitmap_plot_ylo,y
+    sta _3
+    lda x
+    and #<$fff8
+    sta _1
+    lda x+1
+    and #>$fff8
+    sta _1+1
+    lda plotter
+    clc
+    adc _1
+    sta plotter
+    lda plotter+1
+    adc _1+1
+    sta plotter+1
+    lda x
+    tay
+    lda bitmap_plot_bit,y
+    ldy #0
+    ora (plotter),y
+    sta (plotter),y
+    rts
+}
+// Multiply of two signed words to a signed double word
+// Fixes offsets introduced by using unsigned multiplication
+// mul16s(signed word zeropage(4) a, signed word zeropage(8) b)
+mul16s: {
+    .label _9 = $3a
+    .label _13 = $3c
+    .label _16 = $3a
+    .label _17 = $3c
+    .label m = $a
+    .label return = $a
+    .label a = 4
+    .label b = 8
+    lda b
+    sta mul16u.mb
+    lda b+1
+    sta mul16u.mb+1
+    lda #0
+    sta mul16u.mb+2
+    sta mul16u.mb+3
+    lda a
+    sta mul16u.a
+    lda a+1
+    sta mul16u.a+1
+    jsr mul16u
+    lda a+1
+    bpl b1
+    lda m+2
+    sta _9
+    lda m+3
+    sta _9+1
+    lda _16
+    sec
+    sbc b
+    sta _16
+    lda _16+1
+    sbc b+1
+    sta _16+1
+    lda _16
+    sta m+2
+    lda _16+1
+    sta m+3
+  b1:
+    lda b+1
+    bpl b2
+    lda m+2
+    sta _13
+    lda m+3
+    sta _13+1
+    lda _17
+    sec
+    sbc a
+    sta _17
+    lda _17+1
+    sbc a+1
+    sta _17+1
+    lda _17
+    sta m+2
+    lda _17+1
+    sta m+3
+  b2:
+    rts
+}
+// Perform binary multiplication of two unsigned 16-bit words into a 32-bit unsigned double word
+// mul16u(word zeropage($10) a, word zeropage($e) b)
+mul16u: {
+    .label mb = $12
+    .label a = $10
+    .label res = $a
+    .label return = $a
+    .label b = $e
+    lda #0
+    sta res
+    sta res+1
+    sta res+2
+    sta res+3
+  b1:
+    lda a
+    bne b2
+    lda a+1
+    bne b2
+    rts
+  b2:
+    lda a
+    and #1
+    cmp #0
+    beq b3
+    lda res
+    clc
+    adc mb
+    sta res
+    lda res+1
+    adc mb+1
+    sta res+1
+    lda res+2
+    adc mb+2
+    sta res+2
+    lda res+3
+    adc mb+3
+    sta res+3
+  b3:
+    lsr a+1
+    ror a
+    asl mb
+    rol mb+1
+    rol mb+2
+    rol mb+3
+    jmp b1
+}
+// Setup the IRQ
+init_irq: {
+    sei
+    // Disable kernal & basic
+    lda #PROCPORT_DDR_MEMORY_MASK
+    sta PROCPORT_DDR
+    lda #PROCPORT_RAM_IO
+    sta PROCPORT
+    // Disable CIA 1 Timer IRQ
+    lda #CIA_INTERRUPT_CLEAR
+    sta CIA1_INTERRUPT
+    // Set raster line to $100
+    lda #$80
+    ora VIC_CONTROL
+    sta VIC_CONTROL
+    lda #0
+    sta RASTER
+    // Enable Raster Interrupt
+    lda #IRQ_RASTER
+    sta IRQ_ENABLE
+    // Set the IRQ routine
+    lda #<irq
+    sta HARDWARE_IRQ
+    lda #>irq
+    sta HARDWARE_IRQ+1
+    cli
+    rts
+}
+// Clear all graphics on the bitmap
+// bgcol - the background color to fill the screen with
+// fgcol - the foreground color to fill the screen with
+bitmap_clear: {
+    .const col = WHITE*$10
+    ldx #col
+    lda #<$3e8
+    sta memset.num
+    lda #>$3e8
+    sta memset.num+1
+    lda #<SCREEN
+    sta memset.str
+    lda #>SCREEN
+    sta memset.str+1
+    jsr memset
+    ldx #0
+    lda #<$1f40
+    sta memset.num
+    lda #>$1f40
+    sta memset.num+1
+    lda #<BITMAP
+    sta memset.str
+    lda #>BITMAP
+    sta memset.str+1
+    jsr memset
+    rts
+}
+// Copies the character c (an unsigned char) to the first num characters of the object pointed to by the argument str.
+// memset(void* zeropage($16) str, byte register(X) c, word zeropage($18) num)
+memset: {
+    .label end = $18
+    .label dst = $16
+    .label str = $16
+    .label num = $18
+    lda end
+    clc
+    adc str
+    sta end
+    lda end+1
+    adc str+1
+    sta end+1
+  b1:
+    txa
+    ldy #0
+    sta (dst),y
+    inc dst
+    bne !+
+    inc dst+1
+  !:
+    lda dst+1
+    cmp end+1
+    bne b1
+    lda dst
+    cmp end
+    bne b1
+    rts
+}
+// Initialize bitmap plotting tables
+bitmap_init: {
+    .label _7 = $3e
+    .label yoffs = $1a
+    ldx #0
+    lda #$80
+  b1:
+    sta bitmap_plot_bit,x
+    lsr
+    cmp #0
+    bne b2
+    lda #$80
+  b2:
+    inx
+    cpx #0
+    bne b1
+    lda #<BITMAP
+    sta yoffs
+    lda #>BITMAP
+    sta yoffs+1
+    ldx #0
+  b3:
+    lda #7
+    sax _7
+    lda yoffs
+    ora _7
+    sta bitmap_plot_ylo,x
+    lda yoffs+1
+    sta bitmap_plot_yhi,x
+    lda #7
+    cmp _7
+    bne b4
+    clc
+    lda yoffs
+    adc #<$28*8
+    sta yoffs
+    lda yoffs+1
+    adc #>$28*8
+    sta yoffs+1
+  b4:
+    inx
+    cpx #0
+    bne b3
+    rts
+}
+// Generate signed word sinus table - with values in the range min-max.
+// sintab - the table to generate into
+// wavelength - the number of sinus points in a total sinus wavelength (the size of the table)
+// sin16s_gen2(signed word* zeropage($20) sintab)
+sin16s_gen2: {
+    .label wavelength = $200
+    .const min = -$1001
+    .const max = $1001
+    .const ampl = max-min
+    .label _5 = $a
+    .label _6 = $43
+    .label step = $3f
+    .label sintab = $20
+    .label x = $1c
+    .label i = $22
+    jsr div32u16u
+    lda #0
+    sta i
+    sta i+1
+    lda #<SINUS
+    sta sintab
+    lda #>SINUS
+    sta sintab+1
+    lda #0
+    sta x
+    sta x+1
+    sta x+2
+    sta x+3
+  // u[4.28]
+  b1:
+    lda x
+    sta sin16s.x
+    lda x+1
+    sta sin16s.x+1
+    lda x+2
+    sta sin16s.x+2
+    lda x+3
+    sta sin16s.x+3
+    jsr sin16s
+    lda #<ampl
+    sta mul16s.b
+    lda #>ampl
+    sta mul16s.b+1
+    jsr mul16s
+    lda _5+2
+    sta _6
+    lda _5+3
+    sta _6+1
+    ldy #0
+    lda _6
+    sta (sintab),y
+    iny
+    lda _6+1
+    sta (sintab),y
+    lda #SIZEOF_SIGNED_WORD
+    clc
+    adc sintab
+    sta sintab
+    bcc !+
+    inc sintab+1
+  !:
+    lda x
+    clc
+    adc step
+    sta x
+    lda x+1
+    adc step+1
+    sta x+1
+    lda x+2
+    adc step+2
+    sta x+2
+    lda x+3
+    adc step+3
+    sta x+3
+    inc i
+    bne !+
+    inc i+1
+  !:
+    lda i+1
+    cmp #>wavelength
+    bcc b1
+    bne !+
+    lda i
+    cmp #<wavelength
+    bcc b1
+  !:
+    rts
+}
+// 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 zeropage($25) x)
+sin16s: {
+    .label _4 = $25
+    .label x = $25
+    .label return = 4
+    .label x1 = $45
+    .label x2 = $29
+    .label x3 = $29
+    .label x3_6 = $47
+    .label usinx = 4
+    .label x4 = $29
+    .label x5 = $47
+    .label x5_128 = $47
+    .label sinx = 4
+    .label isUpper = $24
+    lda x+3
+    cmp #>PI_u4f28>>$10
+    bcc b4
+    bne !+
+    lda x+2
+    cmp #<PI_u4f28>>$10
+    bcc b4
+    bne !+
+    lda x+1
+    cmp #>PI_u4f28
+    bcc b4
+    bne !+
+    lda x
+    cmp #<PI_u4f28
+    bcc b4
+  !:
+    lda x
+    sec
+    sbc #<PI_u4f28
+    sta x
+    lda x+1
+    sbc #>PI_u4f28
+    sta x+1
+    lda x+2
+    sbc #<PI_u4f28>>$10
+    sta x+2
+    lda x+3
+    sbc #>PI_u4f28>>$10
+    sta x+3
+    lda #1
+    sta isUpper
+    jmp b1
+  b4:
+    lda #0
+    sta isUpper
+  b1:
+    lda x+3
+    cmp #>PI_HALF_u4f28>>$10
+    bcc b2
+    bne !+
+    lda x+2
+    cmp #<PI_HALF_u4f28>>$10
+    bcc b2
+    bne !+
+    lda x+1
+    cmp #>PI_HALF_u4f28
+    bcc b2
+    bne !+
+    lda x
+    cmp #<PI_HALF_u4f28
+    bcc b2
+  !:
+    lda #<PI_u4f28
+    sec
+    sbc x
+    sta x
+    lda #>PI_u4f28
+    sbc x+1
+    sta x+1
+    lda #<PI_u4f28>>$10
+    sbc x+2
+    sta x+2
+    lda #>PI_u4f28>>$10
+    sbc x+3
+    sta x+3
+  b2:
+    ldy #3
+  !:
+    asl _4
+    rol _4+1
+    rol _4+2
+    rol _4+3
+    dey
+    bne !-
+    lda _4+2
+    sta x1
+    lda _4+3
+    sta x1+1
+    lda x1
+    sta mulu16_sel.v1
+    lda x1+1
+    sta mulu16_sel.v1+1
+    lda x1
+    sta mulu16_sel.v2
+    lda x1+1
+    sta mulu16_sel.v2+1
+    ldx #0
+    jsr mulu16_sel
+    lda mulu16_sel.return
+    sta x2
+    lda mulu16_sel.return+1
+    sta x2+1
+    lda x1
+    sta mulu16_sel.v2
+    lda x1+1
+    sta mulu16_sel.v2+1
+    ldx #1
+    jsr mulu16_sel
+    lda mulu16_sel.return
+    sta mulu16_sel.return_1
+    lda mulu16_sel.return+1
+    sta mulu16_sel.return_1+1
+    ldx #1
+    lda #<$10000/6
+    sta mulu16_sel.v2
+    lda #>$10000/6
+    sta mulu16_sel.v2+1
+    jsr mulu16_sel
+    lda x1
+    sec
+    sbc x3_6
+    sta usinx
+    lda x1+1
+    sbc x3_6+1
+    sta usinx+1
+    lda x1
+    sta mulu16_sel.v2
+    lda x1+1
+    sta mulu16_sel.v2+1
+    ldx #0
+    jsr mulu16_sel
+    lda mulu16_sel.return
+    sta mulu16_sel.return_10
+    lda mulu16_sel.return+1
+    sta mulu16_sel.return_10+1
+    lda x1
+    sta mulu16_sel.v2
+    lda x1+1
+    sta mulu16_sel.v2+1
+    ldx #0
+    jsr mulu16_sel
+    lsr x5_128+1
+    ror x5_128
+    lsr x5_128+1
+    ror x5_128
+    lsr x5_128+1
+    ror x5_128
+    lsr x5_128+1
+    ror x5_128
+    lda usinx
+    clc
+    adc x5_128
+    sta usinx
+    lda usinx+1
+    adc x5_128+1
+    sta usinx+1
+    lda isUpper
+    cmp #0
+    beq b3
+    sec
+    lda #0
+    sbc sinx
+    sta sinx
+    lda #0
+    sbc sinx+1
+    sta sinx+1
+  b3:
+    rts
+}
+// 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 zeropage($29) v1, word zeropage($e) v2, byte register(X) select)
+mulu16_sel: {
+    .label _0 = $a
+    .label _1 = $a
+    .label v1 = $29
+    .label v2 = $e
+    .label return = $47
+    .label return_1 = $29
+    .label return_10 = $29
+    lda v1
+    sta mul16u.a
+    lda v1+1
+    sta mul16u.a+1
+    lda mul16u.b
+    sta mul16u.mb
+    lda mul16u.b+1
+    sta mul16u.mb+1
+    lda #0
+    sta mul16u.mb+2
+    sta mul16u.mb+3
+    jsr mul16u
+    cpx #0
+    beq !e+
+  !:
+    asl _1
+    rol _1+1
+    rol _1+2
+    rol _1+3
+    dex
+    bne !-
+  !e:
+    lda _1+2
+    sta return
+    lda _1+3
+    sta return+1
+    rts
+}
+// 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 = $49
+    .label quotient_lo = $2f
+    .label return = $3f
+    lda #<PI2_u4f28>>$10
+    sta divr16u.dividend
+    lda #>PI2_u4f28>>$10
+    sta divr16u.dividend+1
+    lda #0
+    sta divr16u.rem
+    sta divr16u.rem+1
+    jsr divr16u
+    lda divr16u.return
+    sta quotient_hi
+    lda divr16u.return+1
+    sta quotient_hi+1
+    lda #<PI2_u4f28&$ffff
+    sta divr16u.dividend
+    lda #>PI2_u4f28&$ffff
+    sta divr16u.dividend+1
+    jsr divr16u
+    lda quotient_hi
+    sta return+2
+    lda quotient_hi+1
+    sta return+3
+    lda quotient_lo
+    sta return
+    lda quotient_lo+1
+    sta return+1
+    rts
+}
+// 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 zeropage($2d) dividend, word zeropage($2b) rem)
+divr16u: {
+    .label rem = $2b
+    .label dividend = $2d
+    .label quotient = $2f
+    .label return = $2f
+    ldx #0
+    txa
+    sta quotient
+    sta quotient+1
+  b1:
+    asl rem
+    rol rem+1
+    lda dividend+1
+    and #$80
+    cmp #0
+    beq b2
+    lda #1
+    ora rem
+    sta rem
+  b2:
+    asl dividend
+    rol dividend+1
+    asl quotient
+    rol quotient+1
+    lda rem+1
+    cmp #>sin16s_gen2.wavelength
+    bcc b3
+    bne !+
+    lda rem
+    cmp #<sin16s_gen2.wavelength
+    bcc b3
+  !:
+    inc quotient
+    bne !+
+    inc quotient+1
+  !:
+    lda rem
+    sec
+    sbc #<sin16s_gen2.wavelength
+    sta rem
+    lda rem+1
+    sbc #>sin16s_gen2.wavelength
+    sta rem+1
+  b3:
+    inx
+    cpx #$10
+    bne b1
+    rts
+}
+// Interrupt Routine counting frames
+irq: {
+    sta rega+1
+    lda #WHITE
+    sta BGCOL
+    lda #0
+    cmp frame_cnt
+    beq b1
+    inc frame_cnt
+  b1:
+    lda #BLACK
+    sta BGCOL
+    // Acknowledge the IRQ
+    lda #IRQ_RASTER
+    sta IRQ_STATUS
+  rega:
+    lda #00
+    rti
+}
+  // Tables for the plotter - initialized by calling bitmap_init();
+  bitmap_plot_ylo: .fill $100, 0
+  bitmap_plot_yhi: .fill $100, 0
+  bitmap_plot_bit: .fill $100, 0
+  plots_per_frame: .fill $100, 0
+  .align $100
+  SINUS: .fill 2*$200, 0

src/test/ref/bitmap-plot-2.cfg

@@ -0,0 +1,433 @@
+@begin: scope:[]  from
+  [0] phi()
+  to:@1
+@1: scope:[]  from @begin
+  [1] (byte) frame_cnt#0 ← (byte) 1
+  to:@2
+@2: scope:[]  from @1
+  [2] phi()
+  [3] call main 
+  to:@end
+@end: scope:[]  from @2
+  [4] phi()
+main: scope:[main]  from @2
+  [5] phi()
+  [6] call sin16s_gen2 
+  to:main::@7
+main::@7: scope:[main]  from main
+  [7] phi()
+  [8] call bitmap_init 
+  to:main::@8
+main::@8: scope:[main]  from main::@7
+  [9] phi()
+  [10] call bitmap_clear 
+  to:main::@9
+main::@9: scope:[main]  from main::@8
+  [11] *((const byte*) D011#0) ← (const byte) VIC_BMM#0|(const byte) VIC_DEN#0|(const byte) VIC_RSEL#0|(byte) 3
+  to:main::toD0181
+main::toD0181: scope:[main]  from main::@9
+  [12] phi()
+  to:main::@6
+main::@6: scope:[main]  from main::toD0181
+  [13] *((const byte*) D018#0) ← (const byte) main::toD0181_return#0
+  [14] call init_irq 
+  to:main::@1
+main::@1: scope:[main]  from main::@4 main::@6
+  [15] (word) main::idx_y#3 ← phi( main::@6/(byte) $80 main::@4/(word) main::idx_y#10 )
+  [15] (signed word) main::r#10 ← phi( main::@6/(signed byte) 0 main::@4/(signed word) main::r#1 )
+  [15] (word) main::idx_x#3 ← phi( main::@6/(byte) 0 main::@4/(word) main::idx_x#10 )
+  to:main::@2
+main::@2: scope:[main]  from main::@1
+  [16] (word~) main::$28 ← (word) main::idx_x#3 << (byte) 1
+  [17] (signed word*~) main::$30 ← (const signed word[$200]) SINUS#0 + (word~) main::$28
+  [18] (signed word) main::cos_x#0 ← *((signed word*~) main::$30)
+  [19] (signed word) mul16s::a#1 ← (signed word) main::r#10
+  [20] (signed word) mul16s::b#1 ← (signed word) main::cos_x#0
+  [21] call mul16s 
+  [22] (signed dword) mul16s::return#3 ← (signed dword) mul16s::return#0
+  to:main::@10
+main::@10: scope:[main]  from main::@2
+  [23] (signed dword) main::xpos#0 ← (signed dword) mul16s::return#3
+  [24] (word~) main::$9 ← > (signed dword) main::xpos#0
+  [25] (signed word~) main::$11 ← (signed word)(word~) main::$9 >> (signed byte) 2
+  [26] (signed word) bitmap_plot::x#0 ← (signed word) $a0 + (signed word~) main::$11
+  [27] (word~) main::$29 ← (word) main::idx_y#3 << (byte) 1
+  [28] (signed word*~) main::$31 ← (const signed word[$200]) SINUS#0 + (word~) main::$29
+  [29] (signed word) main::sin_y#0 ← *((signed word*~) main::$31)
+  [30] (signed word) mul16s::a#2 ← (signed word) main::r#10
+  [31] (signed word) mul16s::b#2 ← (signed word) main::sin_y#0
+  [32] call mul16s 
+  [33] (signed dword) mul16s::return#4 ← (signed dword) mul16s::return#0
+  to:main::@11
+main::@11: scope:[main]  from main::@10
+  [34] (signed dword) main::ypos#0 ← (signed dword) mul16s::return#4
+  [35] (word~) main::$15 ← > (signed dword) main::ypos#0
+  [36] (signed word~) main::$17 ← (signed word)(word~) main::$15 >> (signed byte) 2
+  [37] (signed word~) main::$18 ← (signed byte) $64 + (signed word~) main::$17
+  [38] (byte) bitmap_plot::y#0 ← (byte)(word)(signed word~) main::$18
+  [39] call bitmap_plot 
+  to:main::@12
+main::@12: scope:[main]  from main::@11
+  [40] *((const byte[$100]) plots_per_frame#0 + (byte) frame_cnt#0) ← ++ *((const byte[$100]) plots_per_frame#0 + (byte) frame_cnt#0)
+  [41] (word) main::idx_x#1 ← (word) main::idx_x#3 + (const byte) main::r_add#0
+  [42] if((word) main::idx_x#1<(word) $200) goto main::@13
+  to:main::@3
+main::@13: scope:[main]  from main::@12
+  [43] phi()
+  to:main::@3
+main::@3: scope:[main]  from main::@12 main::@13
+  [44] (word) main::idx_x#10 ← phi( main::@12/(byte) 0 main::@13/(word) main::idx_x#1 )
+  [45] (word) main::idx_y#1 ← (word) main::idx_y#3 + (const byte) main::r_add#0
+  [46] if((word) main::idx_y#1<(word) $200) goto main::@14
+  to:main::@4
+main::@14: scope:[main]  from main::@3
+  [47] phi()
+  to:main::@4
+main::@4: scope:[main]  from main::@14 main::@3
+  [48] (word) main::idx_y#10 ← phi( main::@3/(byte) 0 main::@14/(word) main::idx_y#1 )
+  [49] (signed word) main::r#1 ← (signed word) main::r#10 + (const byte) main::r_add#0
+  [50] if((signed word) main::r#1>=(signed word)(number) $200*(number) $c+(number) $100) goto main::@5
+  to:main::@1
+main::@5: scope:[main]  from main::@4 main::@5
+  [51] *((const byte*) BORDERCOL#0) ← ++ *((const byte*) BORDERCOL#0)
+  to:main::@5
+bitmap_plot: scope:[bitmap_plot]  from main::@11
+  [52] (word~) bitmap_plot::$3 ← *((const byte[$100]) bitmap_plot_yhi#0 + (byte) bitmap_plot::y#0) w= *((const byte[$100]) bitmap_plot_ylo#0 + (byte) bitmap_plot::y#0)
+  [53] (word~) bitmap_plot::$1 ← (word)(signed word) bitmap_plot::x#0 & (word) $fff8
+  [54] (byte*) bitmap_plot::plotter#1 ← (byte*)(word~) bitmap_plot::$3 + (word~) bitmap_plot::$1
+  [55] (byte~) bitmap_plot::$2 ← < (word)(signed word) bitmap_plot::x#0
+  [56] *((byte*) bitmap_plot::plotter#1) ← *((byte*) bitmap_plot::plotter#1) | *((const byte[$100]) bitmap_plot_bit#0 + (byte~) bitmap_plot::$2)
+  to:bitmap_plot::@return
+bitmap_plot::@return: scope:[bitmap_plot]  from bitmap_plot
+  [57] return 
+  to:@return
+mul16s: scope:[mul16s]  from main::@10 main::@2 sin16s_gen2::@3
+  [58] (signed word) mul16s::b#3 ← phi( main::@2/(signed word) mul16s::b#1 main::@10/(signed word) mul16s::b#2 sin16s_gen2::@3/(const signed word) sin16s_gen2::ampl#0 )
+  [58] (signed word) mul16s::a#3 ← phi( main::@2/(signed word) mul16s::a#1 main::@10/(signed word) mul16s::a#2 sin16s_gen2::@3/(signed word) mul16s::a#0 )
+  [59] (dword~) mul16u::mb#6 ← (word)(signed word) mul16s::b#3
+  [60] (word~) mul16u::a#8 ← (word)(signed word) mul16s::a#3
+  [61] call mul16u 
+  [62] (dword) mul16u::return#2 ← (dword) mul16u::res#2
+  to:mul16s::@5
+mul16s::@5: scope:[mul16s]  from mul16s
+  [63] (dword) mul16s::m#0 ← (dword) mul16u::return#2
+  [64] if((signed word) mul16s::a#3>=(signed byte) 0) goto mul16s::@1
+  to:mul16s::@3
+mul16s::@3: scope:[mul16s]  from mul16s::@5
+  [65] (word~) mul16s::$9 ← > (dword) mul16s::m#0
+  [66] (word~) mul16s::$16 ← (word~) mul16s::$9 - (word)(signed word) mul16s::b#3
+  [67] (dword) mul16s::m#1 ← (dword) mul16s::m#0 hi= (word~) mul16s::$16
+  to:mul16s::@1
+mul16s::@1: scope:[mul16s]  from mul16s::@3 mul16s::@5
+  [68] (dword) mul16s::m#5 ← phi( mul16s::@3/(dword) mul16s::m#1 mul16s::@5/(dword) mul16s::m#0 )
+  [69] if((signed word) mul16s::b#3>=(signed byte) 0) goto mul16s::@2
+  to:mul16s::@4
+mul16s::@4: scope:[mul16s]  from mul16s::@1
+  [70] (word~) mul16s::$13 ← > (dword) mul16s::m#5
+  [71] (word~) mul16s::$17 ← (word~) mul16s::$13 - (word)(signed word) mul16s::a#3
+  [72] (dword) mul16s::m#2 ← (dword) mul16s::m#5 hi= (word~) mul16s::$17
+  to:mul16s::@2
+mul16s::@2: scope:[mul16s]  from mul16s::@1 mul16s::@4
+  [73] (dword) mul16s::m#4 ← phi( mul16s::@1/(dword) mul16s::m#5 mul16s::@4/(dword) mul16s::m#2 )
+  [74] (signed dword) mul16s::return#0 ← (signed dword)(dword) mul16s::m#4
+  to:mul16s::@return
+mul16s::@return: scope:[mul16s]  from mul16s::@2
+  [75] return 
+  to:@return
+mul16u: scope:[mul16u]  from mul16s mulu16_sel
+  [76] (word) mul16u::a#6 ← phi( mul16s/(word~) mul16u::a#8 mulu16_sel/(word) mul16u::a#2 )
+  [76] (dword) mul16u::mb#0 ← phi( mul16s/(dword~) mul16u::mb#6 mulu16_sel/(word) mul16u::b#1 )
+  to:mul16u::@1
+mul16u::@1: scope:[mul16u]  from mul16u mul16u::@3
+  [77] (dword) mul16u::mb#2 ← phi( mul16u/(dword) mul16u::mb#0 mul16u::@3/(dword) mul16u::mb#1 )
+  [77] (dword) mul16u::res#2 ← phi( mul16u/(byte) 0 mul16u::@3/(dword) mul16u::res#6 )
+  [77] (word) mul16u::a#3 ← phi( mul16u/(word) mul16u::a#6 mul16u::@3/(word) mul16u::a#0 )
+  [78] if((word) mul16u::a#3!=(byte) 0) goto mul16u::@2
+  to:mul16u::@return
+mul16u::@return: scope:[mul16u]  from mul16u::@1
+  [79] return 
+  to:@return
+mul16u::@2: scope:[mul16u]  from mul16u::@1
+  [80] (byte~) mul16u::$1 ← (word) mul16u::a#3 & (byte) 1
+  [81] if((byte~) mul16u::$1==(byte) 0) goto mul16u::@3
+  to:mul16u::@4
+mul16u::@4: scope:[mul16u]  from mul16u::@2
+  [82] (dword) mul16u::res#1 ← (dword) mul16u::res#2 + (dword) mul16u::mb#2
+  to:mul16u::@3
+mul16u::@3: scope:[mul16u]  from mul16u::@2 mul16u::@4
+  [83] (dword) mul16u::res#6 ← phi( mul16u::@2/(dword) mul16u::res#2 mul16u::@4/(dword) mul16u::res#1 )
+  [84] (word) mul16u::a#0 ← (word) mul16u::a#3 >> (byte) 1
+  [85] (dword) mul16u::mb#1 ← (dword) mul16u::mb#2 << (byte) 1
+  to:mul16u::@1
+init_irq: scope:[init_irq]  from main::@6
+  asm { sei  }
+  [87] *((const byte*) PROCPORT_DDR#0) ← (const byte) PROCPORT_DDR_MEMORY_MASK#0
+  [88] *((const byte*) PROCPORT#0) ← (const byte) PROCPORT_RAM_IO#0
+  [89] *((const byte*) CIA1_INTERRUPT#0) ← (const byte) CIA_INTERRUPT_CLEAR#0
+  [90] *((const byte*) VIC_CONTROL#0) ← *((const byte*) VIC_CONTROL#0) | (byte) $80
+  [91] *((const byte*) RASTER#0) ← (byte) 0
+  [92] *((const byte*) IRQ_ENABLE#0) ← (const byte) IRQ_RASTER#0
+  [93] *((const void()**) HARDWARE_IRQ#0) ← &interrupt(HARDWARE_CLOBBER)(void()) irq()
+  asm { cli  }
+  to:init_irq::@return
+init_irq::@return: scope:[init_irq]  from init_irq
+  [95] return 
+  to:@return
+bitmap_clear: scope:[bitmap_clear]  from main::@8
+  [96] phi()
+  [97] call memset 
+  to:bitmap_clear::@1
+bitmap_clear::@1: scope:[bitmap_clear]  from bitmap_clear
+  [98] phi()
+  [99] call memset 
+  to:bitmap_clear::@return
+bitmap_clear::@return: scope:[bitmap_clear]  from bitmap_clear::@1
+  [100] return 
+  to:@return
+memset: scope:[memset]  from bitmap_clear bitmap_clear::@1
+  [101] (byte) memset::c#3 ← phi( bitmap_clear/(const byte) bitmap_clear::col#0 bitmap_clear::@1/(byte) 0 )
+  [101] (word) memset::num#2 ← phi( bitmap_clear/(word) $3e8 bitmap_clear::@1/(word) $1f40 )
+  [101] (void*) memset::str#2 ← phi( bitmap_clear/(void*)(const byte*) SCREEN#0 bitmap_clear::@1/(void*)(const byte*) BITMAP#0 )
+  [102] (byte*) memset::end#0 ← (byte*)(void*) memset::str#2 + (word) memset::num#2
+  [103] (byte*~) memset::dst#3 ← (byte*)(void*) memset::str#2
+  to:memset::@1
+memset::@1: scope:[memset]  from memset memset::@1
+  [104] (byte*) memset::dst#2 ← phi( memset/(byte*~) memset::dst#3 memset::@1/(byte*) memset::dst#1 )
+  [105] *((byte*) memset::dst#2) ← (byte) memset::c#3
+  [106] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2
+  [107] if((byte*) memset::dst#1!=(byte*) memset::end#0) goto memset::@1
+  to:memset::@return
+memset::@return: scope:[memset]  from memset::@1
+  [108] return 
+  to:@return
+bitmap_init: scope:[bitmap_init]  from main::@7
+  [109] phi()
+  to:bitmap_init::@1
+bitmap_init::@1: scope:[bitmap_init]  from bitmap_init bitmap_init::@2
+  [110] (byte) bitmap_init::x#2 ← phi( bitmap_init/(byte) 0 bitmap_init::@2/(byte) bitmap_init::x#1 )
+  [110] (byte) bitmap_init::bits#3 ← phi( bitmap_init/(byte) $80 bitmap_init::@2/(byte) bitmap_init::bits#4 )
+  [111] *((const byte[$100]) bitmap_plot_bit#0 + (byte) bitmap_init::x#2) ← (byte) bitmap_init::bits#3
+  [112] (byte) bitmap_init::bits#1 ← (byte) bitmap_init::bits#3 >> (byte) 1
+  [113] if((byte) bitmap_init::bits#1!=(byte) 0) goto bitmap_init::@6
+  to:bitmap_init::@2
+bitmap_init::@6: scope:[bitmap_init]  from bitmap_init::@1
+  [114] phi()
+  to:bitmap_init::@2
+bitmap_init::@2: scope:[bitmap_init]  from bitmap_init::@1 bitmap_init::@6
+  [115] (byte) bitmap_init::bits#4 ← phi( bitmap_init::@6/(byte) bitmap_init::bits#1 bitmap_init::@1/(byte) $80 )
+  [116] (byte) bitmap_init::x#1 ← ++ (byte) bitmap_init::x#2
+  [117] if((byte) bitmap_init::x#1!=(byte) 0) goto bitmap_init::@1
+  to:bitmap_init::@3
+bitmap_init::@3: scope:[bitmap_init]  from bitmap_init::@2 bitmap_init::@4
+  [118] (byte*) bitmap_init::yoffs#2 ← phi( bitmap_init::@2/(const byte*) BITMAP#0 bitmap_init::@4/(byte*) bitmap_init::yoffs#4 )
+  [118] (byte) bitmap_init::y#2 ← phi( bitmap_init::@2/(byte) 0 bitmap_init::@4/(byte) bitmap_init::y#1 )
+  [119] (byte~) bitmap_init::$7 ← (byte) bitmap_init::y#2 & (byte) 7
+  [120] (byte~) bitmap_init::$4 ← < (byte*) bitmap_init::yoffs#2
+  [121] (byte~) bitmap_init::$5 ← (byte~) bitmap_init::$7 | (byte~) bitmap_init::$4
+  [122] *((const byte[$100]) bitmap_plot_ylo#0 + (byte) bitmap_init::y#2) ← (byte~) bitmap_init::$5
+  [123] (byte~) bitmap_init::$6 ← > (byte*) bitmap_init::yoffs#2
+  [124] *((const byte[$100]) bitmap_plot_yhi#0 + (byte) bitmap_init::y#2) ← (byte~) bitmap_init::$6
+  [125] if((byte~) bitmap_init::$7!=(byte) 7) goto bitmap_init::@4
+  to:bitmap_init::@5
+bitmap_init::@5: scope:[bitmap_init]  from bitmap_init::@3
+  [126] (byte*) bitmap_init::yoffs#1 ← (byte*) bitmap_init::yoffs#2 + (word)(number) $28*(number) 8
+  to:bitmap_init::@4
+bitmap_init::@4: scope:[bitmap_init]  from bitmap_init::@3 bitmap_init::@5
+  [127] (byte*) bitmap_init::yoffs#4 ← phi( bitmap_init::@3/(byte*) bitmap_init::yoffs#2 bitmap_init::@5/(byte*) bitmap_init::yoffs#1 )
+  [128] (byte) bitmap_init::y#1 ← ++ (byte) bitmap_init::y#2
+  [129] if((byte) bitmap_init::y#1!=(byte) 0) goto bitmap_init::@3
+  to:bitmap_init::@return
+bitmap_init::@return: scope:[bitmap_init]  from bitmap_init::@4
+  [130] return 
+  to:@return
+sin16s_gen2: scope:[sin16s_gen2]  from main
+  [131] phi()
+  [132] call div32u16u 
+  [133] (dword) div32u16u::return#2 ← (dword) div32u16u::return#0
+  to:sin16s_gen2::@2
+sin16s_gen2::@2: scope:[sin16s_gen2]  from sin16s_gen2
+  [134] (dword) sin16s_gen2::step#0 ← (dword) div32u16u::return#2
+  to:sin16s_gen2::@1
+sin16s_gen2::@1: scope:[sin16s_gen2]  from sin16s_gen2::@2 sin16s_gen2::@4
+  [135] (word) sin16s_gen2::i#2 ← phi( sin16s_gen2::@2/(byte) 0 sin16s_gen2::@4/(word) sin16s_gen2::i#1 )
+  [135] (signed word*) sin16s_gen2::sintab#2 ← phi( sin16s_gen2::@2/(const signed word[$200]) SINUS#0 sin16s_gen2::@4/(signed word*) sin16s_gen2::sintab#0 )
+  [135] (dword) sin16s_gen2::x#2 ← phi( sin16s_gen2::@2/(byte) 0 sin16s_gen2::@4/(dword) sin16s_gen2::x#1 )
+  [136] (dword) sin16s::x#0 ← (dword) sin16s_gen2::x#2
+  [137] call sin16s 
+  [138] (signed word) sin16s::return#0 ← (signed word) sin16s::return#1
+  to:sin16s_gen2::@3
+sin16s_gen2::@3: scope:[sin16s_gen2]  from sin16s_gen2::@1
+  [139] (signed word) mul16s::a#0 ← (signed word) sin16s::return#0
+  [140] call mul16s 
+  [141] (signed dword) mul16s::return#2 ← (signed dword) mul16s::return#0
+  to:sin16s_gen2::@4
+sin16s_gen2::@4: scope:[sin16s_gen2]  from sin16s_gen2::@3
+  [142] (signed dword~) sin16s_gen2::$5 ← (signed dword) mul16s::return#2
+  [143] (word~) sin16s_gen2::$6 ← > (signed dword~) sin16s_gen2::$5
+  [144] *((signed word*) sin16s_gen2::sintab#2) ← (signed word)(word~) sin16s_gen2::$6
+  [145] (signed word*) sin16s_gen2::sintab#0 ← (signed word*) sin16s_gen2::sintab#2 + (const byte) SIZEOF_SIGNED_WORD
+  [146] (dword) sin16s_gen2::x#1 ← (dword) sin16s_gen2::x#2 + (dword) sin16s_gen2::step#0
+  [147] (word) sin16s_gen2::i#1 ← ++ (word) sin16s_gen2::i#2
+  [148] if((word) sin16s_gen2::i#1<(const word) sin16s_gen2::wavelength#0) goto sin16s_gen2::@1
+  to:sin16s_gen2::@return
+sin16s_gen2::@return: scope:[sin16s_gen2]  from sin16s_gen2::@4
+  [149] return 
+  to:@return
+sin16s: scope:[sin16s]  from sin16s_gen2::@1
+  [150] if((dword) sin16s::x#0<(const dword) PI_u4f28#0) goto sin16s::@1
+  to:sin16s::@4
+sin16s::@4: scope:[sin16s]  from sin16s
+  [151] (dword) sin16s::x#1 ← (dword) sin16s::x#0 - (const dword) PI_u4f28#0
+  to:sin16s::@1
+sin16s::@1: scope:[sin16s]  from sin16s sin16s::@4
+  [152] (byte) sin16s::isUpper#2 ← phi( sin16s/(byte) 0 sin16s::@4/(byte) 1 )
+  [152] (dword) sin16s::x#4 ← phi( sin16s/(dword) sin16s::x#0 sin16s::@4/(dword) sin16s::x#1 )
+  [153] if((dword) sin16s::x#4<(const dword) PI_HALF_u4f28#0) goto sin16s::@2
+  to:sin16s::@5
+sin16s::@5: scope:[sin16s]  from sin16s::@1
+  [154] (dword) sin16s::x#2 ← (const dword) PI_u4f28#0 - (dword) sin16s::x#4
+  to:sin16s::@2
+sin16s::@2: scope:[sin16s]  from sin16s::@1 sin16s::@5
+  [155] (dword) sin16s::x#6 ← phi( sin16s::@1/(dword) sin16s::x#4 sin16s::@5/(dword) sin16s::x#2 )
+  [156] (dword~) sin16s::$4 ← (dword) sin16s::x#6 << (byte) 3
+  [157] (word) sin16s::x1#0 ← > (dword~) sin16s::$4
+  [158] (word) mulu16_sel::v1#0 ← (word) sin16s::x1#0
+  [159] (word) mulu16_sel::v2#0 ← (word) sin16s::x1#0
+  [160] call mulu16_sel 
+  [161] (word) mulu16_sel::return#0 ← (word) mulu16_sel::return#12
+  to:sin16s::@7
+sin16s::@7: scope:[sin16s]  from sin16s::@2
+  [162] (word) sin16s::x2#0 ← (word) mulu16_sel::return#0
+  [163] (word) mulu16_sel::v1#1 ← (word) sin16s::x2#0
+  [164] (word) mulu16_sel::v2#1 ← (word) sin16s::x1#0
+  [165] call mulu16_sel 
+  [166] (word) mulu16_sel::return#1 ← (word) mulu16_sel::return#12
+  to:sin16s::@8
+sin16s::@8: scope:[sin16s]  from sin16s::@7
+  [167] (word) sin16s::x3#0 ← (word) mulu16_sel::return#1
+  [168] (word) mulu16_sel::v1#2 ← (word) sin16s::x3#0
+  [169] call mulu16_sel 
+  [170] (word) mulu16_sel::return#2 ← (word) mulu16_sel::return#12
+  to:sin16s::@9
+sin16s::@9: scope:[sin16s]  from sin16s::@8
+  [171] (word) sin16s::x3_6#0 ← (word) mulu16_sel::return#2
+  [172] (word) sin16s::usinx#0 ← (word) sin16s::x1#0 - (word) sin16s::x3_6#0
+  [173] (word) mulu16_sel::v1#3 ← (word) sin16s::x3#0
+  [174] (word) mulu16_sel::v2#3 ← (word) sin16s::x1#0
+  [175] call mulu16_sel 
+  [176] (word) mulu16_sel::return#10 ← (word) mulu16_sel::return#12
+  to:sin16s::@10
+sin16s::@10: scope:[sin16s]  from sin16s::@9
+  [177] (word) sin16s::x4#0 ← (word) mulu16_sel::return#10
+  [178] (word) mulu16_sel::v1#4 ← (word) sin16s::x4#0
+  [179] (word) mulu16_sel::v2#4 ← (word) sin16s::x1#0
+  [180] call mulu16_sel 
+  [181] (word) mulu16_sel::return#11 ← (word) mulu16_sel::return#12
+  to:sin16s::@11
+sin16s::@11: scope:[sin16s]  from sin16s::@10
+  [182] (word) sin16s::x5#0 ← (word) mulu16_sel::return#11
+  [183] (word) sin16s::x5_128#0 ← (word) sin16s::x5#0 >> (byte) 4
+  [184] (word) sin16s::usinx#1 ← (word) sin16s::usinx#0 + (word) sin16s::x5_128#0
+  [185] if((byte) sin16s::isUpper#2==(byte) 0) goto sin16s::@12
+  to:sin16s::@6
+sin16s::@6: scope:[sin16s]  from sin16s::@11
+  [186] (signed word) sin16s::sinx#1 ← - (signed word)(word) sin16s::usinx#1
+  to:sin16s::@3
+sin16s::@3: scope:[sin16s]  from sin16s::@12 sin16s::@6
+  [187] (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
+  [188] return 
+  to:@return
+sin16s::@12: scope:[sin16s]  from sin16s::@11
+  [189] (signed word~) sin16s::return#5 ← (signed word)(word) sin16s::usinx#1
+  to:sin16s::@3
+mulu16_sel: scope:[mulu16_sel]  from sin16s::@10 sin16s::@2 sin16s::@7 sin16s::@8 sin16s::@9
+  [190] (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 )
+  [190] (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 )
+  [190] (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 )
+  [191] (word) mul16u::a#2 ← (word) mulu16_sel::v1#5
+  [192] (word) mul16u::b#1 ← (word) mulu16_sel::v2#5
+  [193] call mul16u 
+  [194] (dword) mul16u::return#3 ← (dword) mul16u::res#2
+  to:mulu16_sel::@1
+mulu16_sel::@1: scope:[mulu16_sel]  from mulu16_sel
+  [195] (dword~) mulu16_sel::$0 ← (dword) mul16u::return#3
+  [196] (dword~) mulu16_sel::$1 ← (dword~) mulu16_sel::$0 << (byte) mulu16_sel::select#5
+  [197] (word) mulu16_sel::return#12 ← > (dword~) mulu16_sel::$1
+  to:mulu16_sel::@return
+mulu16_sel::@return: scope:[mulu16_sel]  from mulu16_sel::@1
+  [198] return 
+  to:@return
+div32u16u: scope:[div32u16u]  from sin16s_gen2
+  [199] phi()
+  [200] call divr16u 
+  [201] (word) divr16u::return#2 ← (word) divr16u::return#0
+  to:div32u16u::@1
+div32u16u::@1: scope:[div32u16u]  from div32u16u
+  [202] (word) div32u16u::quotient_hi#0 ← (word) divr16u::return#2
+  [203] (word) divr16u::rem#4 ← (word) rem16u#1
+  [204] call divr16u 
+  [205] (word) divr16u::return#3 ← (word) divr16u::return#0
+  to:div32u16u::@2
+div32u16u::@2: scope:[div32u16u]  from div32u16u::@1
+  [206] (word) div32u16u::quotient_lo#0 ← (word) divr16u::return#3
+  [207] (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
+  [208] return 
+  to:@return
+divr16u: scope:[divr16u]  from div32u16u div32u16u::@1
+  [209] (word) divr16u::dividend#5 ← phi( div32u16u/>(const dword) PI2_u4f28#0 div32u16u::@1/<(const dword) PI2_u4f28#0 )
+  [209] (word) divr16u::rem#10 ← phi( div32u16u/(byte) 0 div32u16u::@1/(word) divr16u::rem#4 )
+  to:divr16u::@1
+divr16u::@1: scope:[divr16u]  from divr16u divr16u::@3
+  [210] (byte) divr16u::i#2 ← phi( divr16u/(byte) 0 divr16u::@3/(byte) divr16u::i#1 )
+  [210] (word) divr16u::quotient#3 ← phi( divr16u/(byte) 0 divr16u::@3/(word) divr16u::return#0 )
+  [210] (word) divr16u::dividend#3 ← phi( divr16u/(word) divr16u::dividend#5 divr16u::@3/(word) divr16u::dividend#0 )
+  [210] (word) divr16u::rem#5 ← phi( divr16u/(word) divr16u::rem#10 divr16u::@3/(word) divr16u::rem#11 )
+  [211] (word) divr16u::rem#0 ← (word) divr16u::rem#5 << (byte) 1
+  [212] (byte~) divr16u::$1 ← > (word) divr16u::dividend#3
+  [213] (byte~) divr16u::$2 ← (byte~) divr16u::$1 & (byte) $80
+  [214] if((byte~) divr16u::$2==(byte) 0) goto divr16u::@2
+  to:divr16u::@4
+divr16u::@4: scope:[divr16u]  from divr16u::@1
+  [215] (word) divr16u::rem#1 ← (word) divr16u::rem#0 | (byte) 1
+  to:divr16u::@2
+divr16u::@2: scope:[divr16u]  from divr16u::@1 divr16u::@4
+  [216] (word) divr16u::rem#6 ← phi( divr16u::@1/(word) divr16u::rem#0 divr16u::@4/(word) divr16u::rem#1 )
+  [217] (word) divr16u::dividend#0 ← (word) divr16u::dividend#3 << (byte) 1
+  [218] (word) divr16u::quotient#1 ← (word) divr16u::quotient#3 << (byte) 1
+  [219] if((word) divr16u::rem#6<(const word) sin16s_gen2::wavelength#0) goto divr16u::@3
+  to:divr16u::@5
+divr16u::@5: scope:[divr16u]  from divr16u::@2
+  [220] (word) divr16u::quotient#2 ← ++ (word) divr16u::quotient#1
+  [221] (word) divr16u::rem#2 ← (word) divr16u::rem#6 - (const word) sin16s_gen2::wavelength#0
+  to:divr16u::@3
+divr16u::@3: scope:[divr16u]  from divr16u::@2 divr16u::@5
+  [222] (word) divr16u::return#0 ← phi( divr16u::@2/(word) divr16u::quotient#1 divr16u::@5/(word) divr16u::quotient#2 )
+  [222] (word) divr16u::rem#11 ← phi( divr16u::@2/(word) divr16u::rem#6 divr16u::@5/(word) divr16u::rem#2 )
+  [223] (byte) divr16u::i#1 ← ++ (byte) divr16u::i#2
+  [224] if((byte) divr16u::i#1!=(byte) $10) goto divr16u::@1
+  to:divr16u::@6
+divr16u::@6: scope:[divr16u]  from divr16u::@3
+  [225] (word) rem16u#1 ← (word) divr16u::rem#11
+  to:divr16u::@return
+divr16u::@return: scope:[divr16u]  from divr16u::@6
+  [226] return 
+  to:@return
+irq: scope:[irq]  from
+  [227] *((const byte*) BGCOL#0) ← (const byte) WHITE#0
+  [228] if((byte) 0==(byte) frame_cnt#0) goto irq::@1
+  to:irq::@2
+irq::@2: scope:[irq]  from irq
+  [229] (byte) frame_cnt#1 ← ++ (byte) frame_cnt#0
+  to:irq::@1
+irq::@1: scope:[irq]  from irq irq::@2
+  [230] (byte) frame_cnt#2 ← phi( irq/(byte) frame_cnt#0 irq::@2/(byte) frame_cnt#1 )
+  [231] *((const byte*) BGCOL#0) ← (const byte) BLACK#0
+  [232] *((const byte*) IRQ_STATUS#0) ← (const byte) IRQ_RASTER#0
+  to:irq::@return
+irq::@return: scope:[irq]  from irq::@1
+  [233] return 
+  to:@return

src/test/ref/bitmap-plot-2.sym

@@ -0,0 +1,460 @@
+(label) @1
+(label) @2
+(label) @begin
+(label) @end
+(byte*) BGCOL
+(const byte*) BGCOL#0 BGCOL = (byte*) 53281
+(byte*) BITMAP
+(const byte*) BITMAP#0 BITMAP = (byte*) 8192
+(byte) BLACK
+(const byte) BLACK#0 BLACK = (byte) 0
+(byte*) BORDERCOL
+(const byte*) BORDERCOL#0 BORDERCOL = (byte*) 53280
+(byte*) CIA1_INTERRUPT
+(const byte*) CIA1_INTERRUPT#0 CIA1_INTERRUPT = (byte*) 56333
+(byte) CIA_INTERRUPT_CLEAR
+(const byte) CIA_INTERRUPT_CLEAR#0 CIA_INTERRUPT_CLEAR = (byte) $7f
+(byte*) D011
+(const byte*) D011#0 D011 = (byte*) 53265
+(byte*) D018
+(const byte*) D018#0 D018 = (byte*) 53272
+(void()**) HARDWARE_IRQ
+(const void()**) HARDWARE_IRQ#0 HARDWARE_IRQ = (void()**) 65534
+(byte*) IRQ_ENABLE
+(const byte*) IRQ_ENABLE#0 IRQ_ENABLE = (byte*) 53274
+(byte) IRQ_RASTER
+(const byte) IRQ_RASTER#0 IRQ_RASTER = (byte) 1
+(byte*) IRQ_STATUS
+(const byte*) IRQ_STATUS#0 IRQ_STATUS = (byte*) 53273
+(dword) PI2_u4f28
+(const dword) PI2_u4f28#0 PI2_u4f28 = (dword) $6487ed51
+(dword) PI_HALF_u4f28
+(const dword) PI_HALF_u4f28#0 PI_HALF_u4f28 = (dword) $1921fb54
+(dword) PI_u4f28
+(const dword) PI_u4f28#0 PI_u4f28 = (dword) $3243f6a9
+(byte*) PROCPORT
+(const byte*) PROCPORT#0 PROCPORT = (byte*) 1
+(byte*) PROCPORT_DDR
+(const byte*) PROCPORT_DDR#0 PROCPORT_DDR = (byte*) 0
+(byte) PROCPORT_DDR_MEMORY_MASK
+(const byte) PROCPORT_DDR_MEMORY_MASK#0 PROCPORT_DDR_MEMORY_MASK = (byte) 7
+(byte) PROCPORT_RAM_IO
+(const byte) PROCPORT_RAM_IO#0 PROCPORT_RAM_IO = (byte) $35
+(byte*) RASTER
+(const byte*) RASTER#0 RASTER = (byte*) 53266
+(byte*) SCREEN
+(const byte*) SCREEN#0 SCREEN = (byte*) 1024
+(signed word[$200]) SINUS
+(const signed word[$200]) SINUS#0 SINUS = { fill( $200, 0) }
+(const byte) SIZEOF_SIGNED_WORD SIZEOF_SIGNED_WORD = (byte) 2
+(byte) VIC_BMM
+(const byte) VIC_BMM#0 VIC_BMM = (byte) $20
+(byte*) VIC_CONTROL
+(const byte*) VIC_CONTROL#0 VIC_CONTROL = (byte*) 53265
+(byte) VIC_DEN
+(const byte) VIC_DEN#0 VIC_DEN = (byte) $10
+(byte) VIC_RSEL
+(const byte) VIC_RSEL#0 VIC_RSEL = (byte) 8
+(byte) WHITE
+(const byte) WHITE#0 WHITE = (byte) 1
+(void()) bitmap_clear((byte) bitmap_clear::bgcol , (byte) bitmap_clear::fgcol)
+(label) bitmap_clear::@1
+(label) bitmap_clear::@return
+(byte) bitmap_clear::bgcol
+(byte) bitmap_clear::col
+(const byte) bitmap_clear::col#0 col = (const byte) WHITE#0*(byte) $10
+(byte) bitmap_clear::fgcol
+(byte*) bitmap_gfx
+(void()) bitmap_init((byte*) bitmap_init::gfx , (byte*) bitmap_init::screen)
+(byte~) bitmap_init::$4 reg byte a 22.0
+(byte~) bitmap_init::$5 reg byte a 22.0
+(byte~) bitmap_init::$6 reg byte a 22.0
+(byte~) bitmap_init::$7 $7 zp ZP_BYTE:62 5.5
+(label) bitmap_init::@1
+(label) bitmap_init::@2
+(label) bitmap_init::@3
+(label) bitmap_init::@4
+(label) bitmap_init::@5
+(label) bitmap_init::@6
+(label) bitmap_init::@return
+(byte) bitmap_init::bits
+(byte) bitmap_init::bits#1 reg byte a 11.0
+(byte) bitmap_init::bits#3 reg byte a 16.5
+(byte) bitmap_init::bits#4 reg byte a 7.333333333333333
+(byte*) bitmap_init::gfx
+(byte*) bitmap_init::screen
+(byte) bitmap_init::x
+(byte) bitmap_init::x#1 reg byte x 16.5
+(byte) bitmap_init::x#2 reg byte x 5.5
+(byte) bitmap_init::y
+(byte) bitmap_init::y#1 reg byte x 16.5
+(byte) bitmap_init::y#2 reg byte x 5.5
+(byte*) bitmap_init::yoffs
+(byte*) bitmap_init::yoffs#1 yoffs zp ZP_WORD:26 22.0
+(byte*) bitmap_init::yoffs#2 yoffs zp ZP_WORD:26 6.875
+(byte*) bitmap_init::yoffs#4 yoffs zp ZP_WORD:26 11.0
+(void()) bitmap_plot((word) bitmap_plot::x , (byte) bitmap_plot::y)
+(word~) bitmap_plot::$1 $1 zp ZP_WORD:56 4.0
+(byte~) bitmap_plot::$2 reg byte a 4.0
+(word~) bitmap_plot::$3 $3 zp ZP_WORD:54 1.0
+(label) bitmap_plot::@return
+(byte*) bitmap_plot::plotter
+(byte*) bitmap_plot::plotter#1 plotter zp ZP_WORD:54 3.0
+(word) bitmap_plot::x
+(signed word) bitmap_plot::x#0 x zp ZP_WORD:50 0.6875
+(byte) bitmap_plot::y
+(byte) bitmap_plot::y#0 reg byte a 15.0
+(byte[$100]) bitmap_plot_bit
+(const byte[$100]) bitmap_plot_bit#0 bitmap_plot_bit = { fill( $100, 0) }
+(byte[$100]) bitmap_plot_yhi
+(const byte[$100]) bitmap_plot_yhi#0 bitmap_plot_yhi = { fill( $100, 0) }
+(byte[$100]) bitmap_plot_ylo
+(const byte[$100]) bitmap_plot_ylo#0 bitmap_plot_ylo = { fill( $100, 0) }
+(byte*) bitmap_screen
+(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 ZP_WORD:73 0.8
+(word) div32u16u::quotient_lo
+(word) div32u16u::quotient_lo#0 quotient_lo zp ZP_WORD:47 4.0
+(dword) div32u16u::return
+(dword) div32u16u::return#0 return zp ZP_DWORD:63 1.3333333333333333
+(dword) div32u16u::return#2 return zp ZP_DWORD:63 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 ZP_WORD:45 2.75
+(word) divr16u::dividend#3 dividend zp ZP_WORD:45 5.0
+(word) divr16u::dividend#5 dividend zp ZP_WORD:45 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 ZP_WORD:47 16.5
+(word) divr16u::quotient#2 quotient zp ZP_WORD:47 11.0
+(word) divr16u::quotient#3 quotient zp ZP_WORD:47 2.75
+(word) divr16u::rem
+(word) divr16u::rem#0 rem zp ZP_WORD:43 8.25
+(word) divr16u::rem#1 rem zp ZP_WORD:43 22.0
+(word) divr16u::rem#10 rem zp ZP_WORD:43 4.0
+(word) divr16u::rem#11 rem zp ZP_WORD:43 11.666666666666666
+(word) divr16u::rem#2 rem zp ZP_WORD:43 22.0
+(word) divr16u::rem#4 rem zp ZP_WORD:43 4.0
+(word) divr16u::rem#5 rem zp ZP_WORD:43 24.0
+(word) divr16u::rem#6 rem zp ZP_WORD:43 11.0
+(word) divr16u::return
+(word) divr16u::return#0 return zp ZP_WORD:47 5.285714285714286
+(word) divr16u::return#2 return zp ZP_WORD:47 4.0
+(word) divr16u::return#3 return zp ZP_WORD:47 4.0
+(byte) frame_cnt
+(byte) frame_cnt#0 frame_cnt zp ZP_BYTE:49 0.6000000000000001
+(byte) frame_cnt#1 frame_cnt zp ZP_BYTE:49 4.0
+(byte) frame_cnt#2 frame_cnt zp ZP_BYTE:49 40.0
+(void()) init_irq()
+(label) init_irq::@return
+interrupt(HARDWARE_CLOBBER)(void()) irq()
+(label) irq::@1
+(label) irq::@2
+(label) irq::@return
+(void()) main()
+(signed word~) main::$11 $11 zp ZP_WORD:50 22.0
+(word~) main::$15 $15 zp ZP_WORD:52 11.0
+(signed word~) main::$17 $17 zp ZP_WORD:52 22.0
+(signed word~) main::$18 $18 zp ZP_WORD:52 11.0
+(word~) main::$28 $28 zp ZP_WORD:8 22.0
+(word~) main::$29 $29 zp ZP_WORD:8 22.0
+(signed word*~) main::$30 $30 zp ZP_WORD:8 22.0
+(signed word*~) main::$31 $31 zp ZP_WORD:8 22.0
+(word~) main::$9 $9 zp ZP_WORD:50 11.0
+(label) main::@1
+(label) main::@10
+(label) main::@11
+(label) main::@12
+(label) main::@13
+(label) main::@14
+(label) main::@2
+(label) main::@3
+(label) main::@4
+(label) main::@5
+(label) main::@6
+(label) main::@7
+(label) main::@8
+(label) main::@9
+(signed word) main::cos_x
+(signed word) main::cos_x#0 cos_x zp ZP_WORD:8 11.0
+(word) main::idx_x
+(word) main::idx_x#1 idx_x zp ZP_WORD:2 11.0
+(word) main::idx_x#10 idx_x zp ZP_WORD:2 3.142857142857143
+(word) main::idx_x#3 idx_x zp ZP_WORD:2 1.2692307692307692
+(word) main::idx_y
+(word) main::idx_y#1 idx_y zp ZP_WORD:6 11.0
+(word) main::idx_y#10 idx_y zp ZP_WORD:6 7.333333333333333
+(word) main::idx_y#3 idx_y zp ZP_WORD:6 1.0999999999999999
+(signed word) main::r
+(signed word) main::r#1 r zp ZP_WORD:4 16.5
+(signed word) main::r#10 r zp ZP_WORD:4 1.2941176470588236
+(byte) main::r_add
+(const byte) main::r_add#0 r_add = (byte) 4
+(signed word) main::sin_y
+(signed word) main::sin_y#0 sin_y zp ZP_WORD:8 11.0
+(label) main::toD0181
+(word~) main::toD0181_$0
+(number~) main::toD0181_$1
+(number~) main::toD0181_$2
+(number~) main::toD0181_$3
+(word~) main::toD0181_$4
+(byte~) main::toD0181_$5
+(number~) main::toD0181_$6
+(number~) main::toD0181_$7
+(number~) main::toD0181_$8
+(byte*) main::toD0181_gfx
+(byte) main::toD0181_return
+(const byte) main::toD0181_return#0 toD0181_return = >(word)(const byte*) SCREEN#0&(word) $3fff*(byte) 4|>(word)(const byte*) BITMAP#0/(byte) 4&(byte) $f
+(byte*) main::toD0181_screen
+(word) main::x
+(signed dword) main::xpos
+(signed dword) main::xpos#0 xpos zp ZP_DWORD:10 22.0
+(word) main::y
+(signed dword) main::ypos
+(signed dword) main::ypos#0 ypos zp ZP_DWORD:10 22.0
+(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num)
+(label) memset::@1
+(label) memset::@return
+(byte) memset::c
+(byte) memset::c#3 reg byte x 1.5714285714285714
+(byte*) memset::dst
+(byte*) memset::dst#1 dst zp ZP_WORD:22 16.5
+(byte*) memset::dst#2 dst zp ZP_WORD:22 17.5
+(byte*~) memset::dst#3 dst zp ZP_WORD:22 4.0
+(byte*) memset::end
+(byte*) memset::end#0 end zp ZP_WORD:24 2.1666666666666665
+(word) memset::num
+(word) memset::num#2 num zp ZP_WORD:24 2.0
+(void*) memset::return
+(void*) memset::str
+(void*) memset::str#2 str zp ZP_WORD:22
+(signed dword()) mul16s((signed word) mul16s::a , (signed word) mul16s::b)
+(word~) mul16s::$13 $13 zp ZP_WORD:60 4.0
+(word~) mul16s::$16 $16 zp ZP_WORD:58 4.0
+(word~) mul16s::$17 $17 zp ZP_WORD:60 4.0
+(word~) mul16s::$9 $9 zp ZP_WORD:58 4.0
+(label) mul16s::@1
+(label) mul16s::@2
+(label) mul16s::@3
+(label) mul16s::@4
+(label) mul16s::@5
+(label) mul16s::@return
+(signed word) mul16s::a
+(signed word) mul16s::a#0 a zp ZP_WORD:4 22.0
+(signed word) mul16s::a#1 a zp ZP_WORD:4 11.0
+(signed word) mul16s::a#2 a zp ZP_WORD:4 11.0
+(signed word) mul16s::a#3 a zp ZP_WORD:4 2.692307692307692
+(signed word) mul16s::b
+(signed word) mul16s::b#1 b zp ZP_WORD:8 22.0
+(signed word) mul16s::b#2 b zp ZP_WORD:8 22.0
+(signed word) mul16s::b#3 b zp ZP_WORD:8 2.1818181818181817
+(dword) mul16s::m
+(dword) mul16s::m#0 m zp ZP_DWORD:10 2.0
+(dword) mul16s::m#1 m zp ZP_DWORD:10 4.0
+(dword) mul16s::m#2 m zp ZP_DWORD:10 4.0
+(dword) mul16s::m#4 m zp ZP_DWORD:10 4.0
+(dword) mul16s::m#5 m zp ZP_DWORD:10 2.5
+(signed dword) mul16s::return
+(signed dword) mul16s::return#0 return zp ZP_DWORD:10 7.000000000000001
+(signed dword) mul16s::return#2 return zp ZP_DWORD:10 22.0
+(signed dword) mul16s::return#3 return zp ZP_DWORD:10 22.0
+(signed dword) mul16s::return#4 return zp ZP_DWORD:10 22.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 ZP_WORD:16 101.0
+(word) mul16u::a#2 a zp ZP_WORD:16 2.0
+(word) mul16u::a#3 a zp ZP_WORD:16 67.66666666666666
+(word) mul16u::a#6 a zp ZP_WORD:16 6.0
+(word~) mul16u::a#8 a zp ZP_WORD:16 4.0
+(word) mul16u::b
+(word) mul16u::b#1 b zp ZP_WORD:14 4.0
+(dword) mul16u::mb
+(dword) mul16u::mb#0 mb zp ZP_DWORD:18 6.0
+(dword) mul16u::mb#1 mb zp ZP_DWORD:18 202.0
+(dword) mul16u::mb#2 mb zp ZP_DWORD:18 43.57142857142858
+(dword~) mul16u::mb#6 mb zp ZP_DWORD:18 2.0
+(dword) mul16u::res
+(dword) mul16u::res#1 res zp ZP_DWORD:10 202.0
+(dword) mul16u::res#2 res zp ZP_DWORD:10 43.85714285714286
+(dword) mul16u::res#6 res zp ZP_DWORD:10 101.0
+(dword) mul16u::return
+(dword) mul16u::return#2 return zp ZP_DWORD:10 4.0
+(dword) mul16u::return#3 return zp ZP_DWORD:10 4.0
+(word()) mulu16_sel((word) mulu16_sel::v1 , (word) mulu16_sel::v2 , (byte) mulu16_sel::select)
+(dword~) mulu16_sel::$0 $0 zp ZP_DWORD:10 4.0
+(dword~) mulu16_sel::$1 $1 zp ZP_DWORD:10 4.0
+(label) mulu16_sel::@1
+(label) mulu16_sel::@return
+(word) mulu16_sel::return
+(word) mulu16_sel::return#0 return zp ZP_WORD:71 4.0
+(word) mulu16_sel::return#1 return#1 zp ZP_WORD:41 4.0
+(word) mulu16_sel::return#10 return#10 zp ZP_WORD:41 4.0
+(word) mulu16_sel::return#11 return zp ZP_WORD:71 4.0
+(word) mulu16_sel::return#12 return zp ZP_WORD:71 1.714285714285714
+(word) mulu16_sel::return#2 return zp ZP_WORD:71 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 ZP_WORD:41 2.0
+(word) mulu16_sel::v1#1 v1 zp ZP_WORD:41 2.0
+(word) mulu16_sel::v1#2 v1 zp ZP_WORD:41 4.0
+(word) mulu16_sel::v1#3 v1 zp ZP_WORD:41 2.0
+(word) mulu16_sel::v1#4 v1 zp ZP_WORD:41 2.0
+(word) mulu16_sel::v1#5 v1 zp ZP_WORD:41 12.0
+(word) mulu16_sel::v2
+(word) mulu16_sel::v2#0 v2 zp ZP_WORD:14 4.0
+(word) mulu16_sel::v2#1 v2 zp ZP_WORD:14 4.0
+(word) mulu16_sel::v2#3 v2 zp ZP_WORD:14 4.0
+(word) mulu16_sel::v2#4 v2 zp ZP_WORD:14 4.0
+(word) mulu16_sel::v2#5 v2 zp ZP_WORD:14 5.0
+(byte[$100]) plots_per_frame
+(const byte[$100]) plots_per_frame#0 plots_per_frame = { fill( $100, 0) }
+(word) rem16u
+(word) rem16u#1 rem16u zp ZP_WORD:43 0.8
+(signed word()) sin16s((dword) sin16s::x)
+(dword~) sin16s::$4 $4 zp ZP_DWORD:37 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 isUpper zp ZP_BYTE:36 0.06060606060606061
+(signed word) sin16s::return
+(signed word) sin16s::return#0 return zp ZP_WORD:4 22.0
+(signed word) sin16s::return#1 return zp ZP_WORD:4 5.0
+(signed word~) sin16s::return#5 return zp ZP_WORD:4 4.0
+(signed word) sin16s::sinx
+(signed word) sin16s::sinx#1 sinx zp ZP_WORD:4 4.0
+(word) sin16s::usinx
+(word) sin16s::usinx#0 usinx zp ZP_WORD:4 0.3333333333333333
+(word) sin16s::usinx#1 usinx zp ZP_WORD:4 1.0
+(dword) sin16s::x
+(dword) sin16s::x#0 x zp ZP_DWORD:37 8.5
+(dword) sin16s::x#1 x zp ZP_DWORD:37 4.0
+(dword) sin16s::x#2 x zp ZP_DWORD:37 4.0
+(dword) sin16s::x#4 x zp ZP_DWORD:37 5.0
+(dword) sin16s::x#6 x zp ZP_DWORD:37 6.0
+(word) sin16s::x1
+(word) sin16s::x1#0 x1 zp ZP_WORD:69 0.6363636363636365
+(word) sin16s::x2
+(word) sin16s::x2#0 x2 zp ZP_WORD:41 4.0
+(word) sin16s::x3
+(word) sin16s::x3#0 x3 zp ZP_WORD:41 1.0
+(word) sin16s::x3_6
+(word) sin16s::x3_6#0 x3_6 zp ZP_WORD:71 4.0
+(word) sin16s::x4
+(word) sin16s::x4#0 x4 zp ZP_WORD:41 4.0
+(word) sin16s::x5
+(word) sin16s::x5#0 x5 zp ZP_WORD:71 4.0
+(word) sin16s::x5_128
+(word) sin16s::x5_128#0 x5_128 zp ZP_WORD:71 4.0
+(void()) sin16s_gen2((signed word*) sin16s_gen2::sintab , (word) sin16s_gen2::wavelength , (signed word) sin16s_gen2::min , (signed word) sin16s_gen2::max)
+(signed dword~) sin16s_gen2::$5 $5 zp ZP_DWORD:10 22.0
+(word~) sin16s_gen2::$6 $6 zp ZP_WORD:67 11.0
+(label) sin16s_gen2::@1
+(label) sin16s_gen2::@2
+(label) sin16s_gen2::@3
+(label) sin16s_gen2::@4
+(label) sin16s_gen2::@return
+(signed word) sin16s_gen2::ampl
+(const signed word) sin16s_gen2::ampl#0 ampl = (const signed word) sin16s_gen2::max#0-(const signed word) sin16s_gen2::min#0
+(word) sin16s_gen2::i
+(word) sin16s_gen2::i#1 i zp ZP_WORD:34 16.5
+(word) sin16s_gen2::i#2 i zp ZP_WORD:34 1.8333333333333333
+(signed word) sin16s_gen2::max
+(const signed word) sin16s_gen2::max#0 max = (signed word) $1001
+(signed word) sin16s_gen2::min
+(const signed word) sin16s_gen2::min#0 min = (signed word) -$1001
+(signed word) sin16s_gen2::offs
+(signed word*) sin16s_gen2::sintab
+(signed word*) sin16s_gen2::sintab#0 sintab zp ZP_WORD:32 5.5
+(signed word*) sin16s_gen2::sintab#2 sintab zp ZP_WORD:32 3.3000000000000003
+(dword) sin16s_gen2::step
+(dword) sin16s_gen2::step#0 step zp ZP_DWORD:63 0.8666666666666666
+(word) sin16s_gen2::wavelength
+(const word) sin16s_gen2::wavelength#0 wavelength = (word) $200
+(dword) sin16s_gen2::x
+(dword) sin16s_gen2::x#1 x zp ZP_DWORD:28 7.333333333333333
+(dword) sin16s_gen2::x#2 x zp ZP_DWORD:28 3.0
+
+zp ZP_WORD:2 [ main::idx_x#3 main::idx_x#10 main::idx_x#1 ]
+zp ZP_WORD:4 [ main::r#10 main::r#1 mul16s::a#3 mul16s::a#1 mul16s::a#2 mul16s::a#0 sin16s::return#1 sin16s::return#5 sin16s::sinx#1 sin16s::usinx#1 sin16s::return#0 sin16s::usinx#0 ]
+zp ZP_WORD:6 [ main::idx_y#3 main::idx_y#10 main::idx_y#1 ]
+zp ZP_WORD:8 [ mul16s::b#3 mul16s::b#1 mul16s::b#2 main::cos_x#0 main::sin_y#0 main::$28 main::$30 main::$29 main::$31 ]
+zp ZP_DWORD:10 [ mul16s::m#4 mul16s::m#5 mul16s::m#1 mul16s::m#0 mul16s::m#2 mul16u::return#2 mul16s::return#0 mul16u::res#2 mul16u::res#6 mul16u::res#1 mul16u::return#3 mul16s::return#3 main::xpos#0 mul16s::return#4 main::ypos#0 mul16s::return#2 sin16s_gen2::$5 mulu16_sel::$0 mulu16_sel::$1 ]
+zp ZP_WORD:14 [ mul16u::b#1 mulu16_sel::v2#5 mulu16_sel::v2#3 mulu16_sel::v2#4 mulu16_sel::v2#0 mulu16_sel::v2#1 ]
+zp ZP_WORD:16 [ mul16u::a#3 mul16u::a#6 mul16u::a#8 mul16u::a#2 mul16u::a#0 ]
+zp ZP_DWORD:18 [ mul16u::mb#2 mul16u::mb#0 mul16u::mb#6 mul16u::mb#1 ]
+zp ZP_WORD:22 [ memset::str#2 memset::dst#2 memset::dst#3 memset::dst#1 ]
+zp ZP_WORD:24 [ memset::num#2 memset::end#0 ]
+reg byte x [ memset::c#3 ]
+reg byte a [ bitmap_init::bits#3 bitmap_init::bits#4 bitmap_init::bits#1 ]
+reg byte x [ bitmap_init::x#2 bitmap_init::x#1 ]
+reg byte x [ bitmap_init::y#2 bitmap_init::y#1 ]
+zp ZP_WORD:26 [ bitmap_init::yoffs#2 bitmap_init::yoffs#4 bitmap_init::yoffs#1 ]
+zp ZP_DWORD:28 [ sin16s_gen2::x#2 sin16s_gen2::x#1 ]
+zp ZP_WORD:32 [ sin16s_gen2::sintab#2 sin16s_gen2::sintab#0 ]
+zp ZP_WORD:34 [ sin16s_gen2::i#2 sin16s_gen2::i#1 ]
+zp ZP_BYTE:36 [ sin16s::isUpper#2 ]
+zp ZP_DWORD:37 [ sin16s::x#6 sin16s::x#4 sin16s::x#0 sin16s::x#1 sin16s::x#2 sin16s::$4 ]
+zp ZP_WORD:41 [ 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 [ mulu16_sel::select#5 ]
+zp ZP_WORD:43 [ divr16u::rem#5 divr16u::rem#10 divr16u::rem#4 divr16u::rem#11 divr16u::rem#6 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 rem16u#1 ]
+zp ZP_WORD:45 [ divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#0 ]
+zp ZP_WORD:47 [ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 divr16u::return#2 divr16u::return#3 div32u16u::quotient_lo#0 ]
+reg byte x [ divr16u::i#2 divr16u::i#1 ]
+zp ZP_BYTE:49 [ frame_cnt#2 frame_cnt#0 frame_cnt#1 ]
+zp ZP_WORD:50 [ main::$9 main::$11 bitmap_plot::x#0 ]
+zp ZP_WORD:52 [ main::$15 main::$17 main::$18 ]
+reg byte a [ bitmap_plot::y#0 ]
+zp ZP_WORD:54 [ bitmap_plot::$3 bitmap_plot::plotter#1 ]
+zp ZP_WORD:56 [ bitmap_plot::$1 ]
+reg byte a [ bitmap_plot::$2 ]
+zp ZP_WORD:58 [ mul16s::$9 mul16s::$16 ]
+zp ZP_WORD:60 [ mul16s::$13 mul16s::$17 ]
+reg byte a [ mul16u::$1 ]
+zp ZP_BYTE:62 [ bitmap_init::$7 ]
+reg byte a [ bitmap_init::$4 ]
+reg byte a [ bitmap_init::$5 ]
+reg byte a [ bitmap_init::$6 ]
+zp ZP_DWORD:63 [ div32u16u::return#2 sin16s_gen2::step#0 div32u16u::return#0 ]
+zp ZP_WORD:67 [ sin16s_gen2::$6 ]
+zp ZP_WORD:69 [ sin16s::x1#0 ]
+zp ZP_WORD:71 [ 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 ]
+zp ZP_WORD:73 [ div32u16u::quotient_hi#0 ]
+reg byte a [ divr16u::$1 ]
+reg byte a [ divr16u::$2 ]

src/test/ref/c64dtv-gfxexplorer.log

@@ -15896,15 +15896,21 @@ gfx_mode: {
     sta _54+1
   //SEG159 [97] (word~) gfx_mode::$55 ← (word~) gfx_mode::$54 >> (byte) 6 -- vwuz1=vwuz2_ror_6 
     lda _54+1
+    lsr
     sta _55+1
     lda _54
+    ror
     sta _55
-    ldy #6
-  !:
     lsr _55+1
     ror _55
-    dey
-    bne !-
+    lsr _55+1
+    ror _55
+    lsr _55+1
+    ror _55
+    lsr _55+1
+    ror _55
+    lsr _55+1
+    ror _55
   //SEG160 [98] (byte~) gfx_mode::$56 ← (byte)(word~) gfx_mode::$55 -- vbuz1=_byte_vwuz2 
     lda _55
     sta _56
@@ -21030,10 +21036,7 @@ Statement [91] *((const byte*) CIA2_PORT_A#0) ← (byte) 3^(byte)(word)(const by
 Statement [94] (byte*) get_vic_screen::return#10 ← (byte*) get_vic_screen::return#5 [ keyboard_events_size#24 get_vic_screen::return#10 ] ( main:2::gfx_mode:15 [ form_cursor_count#16 form_field_idx#18 keyboard_events_size#24 get_vic_screen::return#10 ] ) always clobbers reg byte a 
 Statement [95] (byte*~) gfx_mode::$53 ← (byte*) get_vic_screen::return#10 [ keyboard_events_size#24 gfx_mode::$53 ] ( main:2::gfx_mode:15 [ form_cursor_count#16 form_field_idx#18 keyboard_events_size#24 gfx_mode::$53 ] ) always clobbers reg byte a 
 Statement [96] (word~) gfx_mode::$54 ← (word)(byte*~) gfx_mode::$53 & (word) $3fff [ keyboard_events_size#24 gfx_mode::$54 ] ( main:2::gfx_mode:15 [ form_cursor_count#16 form_field_idx#18 keyboard_events_size#24 gfx_mode::$54 ] ) always clobbers reg byte a 
-Statement [97] (word~) gfx_mode::$55 ← (word~) gfx_mode::$54 >> (byte) 6 [ keyboard_events_size#24 gfx_mode::$55 ] ( main:2::gfx_mode:15 [ form_cursor_count#16 form_field_idx#18 keyboard_events_size#24 gfx_mode::$55 ] ) always clobbers reg byte a reg byte y 
-Removing always clobbered register reg byte y as potential for zp ZP_BYTE:31 [ form_cursor_count#21 form_cursor_count#1 form_cursor_count#16 form_cursor_count#15 form_cursor_count#5 ]
-Removing always clobbered register reg byte y as potential for zp ZP_BYTE:32 [ form_field_idx#28 form_field_idx#1 form_field_idx#18 form_field_idx#31 form_field_idx#6 form_field_idx#5 ]
-Removing always clobbered register reg byte y as potential for zp ZP_BYTE:18 [ keyboard_events_size#18 keyboard_events_size#109 keyboard_events_size#99 keyboard_events_size#47 keyboard_events_size#27 keyboard_events_size#24 keyboard_events_size#100 keyboard_events_size#4 keyboard_events_size#108 keyboard_events_size#1 keyboard_events_size#2 ]
+Statement [97] (word~) gfx_mode::$55 ← (word~) gfx_mode::$54 >> (byte) 6 [ keyboard_events_size#24 gfx_mode::$55 ] ( main:2::gfx_mode:15 [ form_cursor_count#16 form_field_idx#18 keyboard_events_size#24 gfx_mode::$55 ] ) always clobbers reg byte a 
 Statement [98] (byte~) gfx_mode::$56 ← (byte)(word~) gfx_mode::$55 [ keyboard_events_size#24 gfx_mode::$56 ] ( main:2::gfx_mode:15 [ form_cursor_count#16 form_field_idx#18 keyboard_events_size#24 gfx_mode::$56 ] ) always clobbers reg byte a 
 Statement [101] (byte*) get_vic_charset::return#4 ← (byte*) get_vic_charset::return#2 [ keyboard_events_size#24 gfx_mode::$56 get_vic_charset::return#4 ] ( main:2::gfx_mode:15 [ form_cursor_count#16 form_field_idx#18 keyboard_events_size#24 gfx_mode::$56 get_vic_charset::return#4 ] ) always clobbers reg byte a 
 Removing always clobbered register reg byte a as potential for zp ZP_BYTE:216 [ gfx_mode::$56 ]
@@ -21044,6 +21047,9 @@ Statement [105] (byte~) gfx_mode::$61 ← (byte~) gfx_mode::$60 >> (byte) 2 [ ke
 Statement [110] (byte*) get_vic_screen::return#11 ← (byte*) get_vic_screen::return#5 [ keyboard_events_size#24 get_vic_screen::return#11 ] ( main:2::gfx_mode:15 [ form_cursor_count#16 form_field_idx#18 keyboard_events_size#24 get_vic_screen::return#11 ] ) always clobbers reg byte a 
 Statement [111] (byte*) gfx_mode::vic_colors#0 ← (byte*) get_vic_screen::return#11 [ keyboard_events_size#24 gfx_mode::vic_colors#0 ] ( main:2::gfx_mode:15 [ form_cursor_count#16 form_field_idx#18 keyboard_events_size#24 gfx_mode::vic_colors#0 ] ) always clobbers reg byte a 
 Statement [114] *((byte*) gfx_mode::col#2) ← *((byte*) gfx_mode::vic_colors#2) [ keyboard_events_size#24 gfx_mode::cy#4 gfx_mode::vic_colors#2 gfx_mode::col#2 gfx_mode::cx#2 ] ( main:2::gfx_mode:15 [ form_cursor_count#16 form_field_idx#18 keyboard_events_size#24 gfx_mode::cy#4 gfx_mode::vic_colors#2 gfx_mode::col#2 gfx_mode::cx#2 ] ) always clobbers reg byte a reg byte y 
+Removing always clobbered register reg byte y as potential for zp ZP_BYTE:31 [ form_cursor_count#21 form_cursor_count#1 form_cursor_count#16 form_cursor_count#15 form_cursor_count#5 ]
+Removing always clobbered register reg byte y as potential for zp ZP_BYTE:32 [ form_field_idx#28 form_field_idx#1 form_field_idx#18 form_field_idx#31 form_field_idx#6 form_field_idx#5 ]
+Removing always clobbered register reg byte y as potential for zp ZP_BYTE:18 [ keyboard_events_size#18 keyboard_events_size#109 keyboard_events_size#99 keyboard_events_size#47 keyboard_events_size#27 keyboard_events_size#24 keyboard_events_size#100 keyboard_events_size#4 keyboard_events_size#108 keyboard_events_size#1 keyboard_events_size#2 ]
 Removing always clobbered register reg byte a as potential for zp ZP_BYTE:5 [ gfx_mode::cy#4 gfx_mode::cy#1 ]
 Removing always clobbered register reg byte y as potential for zp ZP_BYTE:5 [ gfx_mode::cy#4 gfx_mode::cy#1 ]
 Removing always clobbered register reg byte a as potential for zp ZP_BYTE:10 [ gfx_mode::cx#2 gfx_mode::cx#1 ]
@@ -21384,7 +21390,7 @@ Statement [91] *((const byte*) CIA2_PORT_A#0) ← (byte) 3^(byte)(word)(const by
 Statement [94] (byte*) get_vic_screen::return#10 ← (byte*) get_vic_screen::return#5 [ keyboard_events_size#24 get_vic_screen::return#10 ] ( main:2::gfx_mode:15 [ form_cursor_count#16 form_field_idx#18 keyboard_events_size#24 get_vic_screen::return#10 ] ) always clobbers reg byte a 
 Statement [95] (byte*~) gfx_mode::$53 ← (byte*) get_vic_screen::return#10 [ keyboard_events_size#24 gfx_mode::$53 ] ( main:2::gfx_mode:15 [ form_cursor_count#16 form_field_idx#18 keyboard_events_size#24 gfx_mode::$53 ] ) always clobbers reg byte a 
 Statement [96] (word~) gfx_mode::$54 ← (word)(byte*~) gfx_mode::$53 & (word) $3fff [ keyboard_events_size#24 gfx_mode::$54 ] ( main:2::gfx_mode:15 [ form_cursor_count#16 form_field_idx#18 keyboard_events_size#24 gfx_mode::$54 ] ) always clobbers reg byte a 
-Statement [97] (word~) gfx_mode::$55 ← (word~) gfx_mode::$54 >> (byte) 6 [ keyboard_events_size#24 gfx_mode::$55 ] ( main:2::gfx_mode:15 [ form_cursor_count#16 form_field_idx#18 keyboard_events_size#24 gfx_mode::$55 ] ) always clobbers reg byte a reg byte y 
+Statement [97] (word~) gfx_mode::$55 ← (word~) gfx_mode::$54 >> (byte) 6 [ keyboard_events_size#24 gfx_mode::$55 ] ( main:2::gfx_mode:15 [ form_cursor_count#16 form_field_idx#18 keyboard_events_size#24 gfx_mode::$55 ] ) always clobbers reg byte a 
 Statement [98] (byte~) gfx_mode::$56 ← (byte)(word~) gfx_mode::$55 [ keyboard_events_size#24 gfx_mode::$56 ] ( main:2::gfx_mode:15 [ form_cursor_count#16 form_field_idx#18 keyboard_events_size#24 gfx_mode::$56 ] ) always clobbers reg byte a 
 Statement [101] (byte*) get_vic_charset::return#4 ← (byte*) get_vic_charset::return#2 [ keyboard_events_size#24 gfx_mode::$56 get_vic_charset::return#4 ] ( main:2::gfx_mode:15 [ form_cursor_count#16 form_field_idx#18 keyboard_events_size#24 gfx_mode::$56 get_vic_charset::return#4 ] ) always clobbers reg byte a 
 Statement [102] (byte*~) gfx_mode::$58 ← (byte*) get_vic_charset::return#4 [ keyboard_events_size#24 gfx_mode::$56 gfx_mode::$58 ] ( main:2::gfx_mode:15 [ form_cursor_count#16 form_field_idx#18 keyboard_events_size#24 gfx_mode::$56 gfx_mode::$58 ] ) always clobbers reg byte a 
@@ -21599,7 +21605,7 @@ Statement [91] *((const byte*) CIA2_PORT_A#0) ← (byte) 3^(byte)(word)(const by
 Statement [94] (byte*) get_vic_screen::return#10 ← (byte*) get_vic_screen::return#5 [ keyboard_events_size#24 get_vic_screen::return#10 ] ( main:2::gfx_mode:15 [ form_cursor_count#16 form_field_idx#18 keyboard_events_size#24 get_vic_screen::return#10 ] ) always clobbers reg byte a 
 Statement [95] (byte*~) gfx_mode::$53 ← (byte*) get_vic_screen::return#10 [ keyboard_events_size#24 gfx_mode::$53 ] ( main:2::gfx_mode:15 [ form_cursor_count#16 form_field_idx#18 keyboard_events_size#24 gfx_mode::$53 ] ) always clobbers reg byte a 
 Statement [96] (word~) gfx_mode::$54 ← (word)(byte*~) gfx_mode::$53 & (word) $3fff [ keyboard_events_size#24 gfx_mode::$54 ] ( main:2::gfx_mode:15 [ form_cursor_count#16 form_field_idx#18 keyboard_events_size#24 gfx_mode::$54 ] ) always clobbers reg byte a 
-Statement [97] (word~) gfx_mode::$55 ← (word~) gfx_mode::$54 >> (byte) 6 [ keyboard_events_size#24 gfx_mode::$55 ] ( main:2::gfx_mode:15 [ form_cursor_count#16 form_field_idx#18 keyboard_events_size#24 gfx_mode::$55 ] ) always clobbers reg byte a reg byte y 
+Statement [97] (word~) gfx_mode::$55 ← (word~) gfx_mode::$54 >> (byte) 6 [ keyboard_events_size#24 gfx_mode::$55 ] ( main:2::gfx_mode:15 [ form_cursor_count#16 form_field_idx#18 keyboard_events_size#24 gfx_mode::$55 ] ) always clobbers reg byte a 
 Statement [98] (byte~) gfx_mode::$56 ← (byte)(word~) gfx_mode::$55 [ keyboard_events_size#24 gfx_mode::$56 ] ( main:2::gfx_mode:15 [ form_cursor_count#16 form_field_idx#18 keyboard_events_size#24 gfx_mode::$56 ] ) always clobbers reg byte a 
 Statement [101] (byte*) get_vic_charset::return#4 ← (byte*) get_vic_charset::return#2 [ keyboard_events_size#24 gfx_mode::$56 get_vic_charset::return#4 ] ( main:2::gfx_mode:15 [ form_cursor_count#16 form_field_idx#18 keyboard_events_size#24 gfx_mode::$56 get_vic_charset::return#4 ] ) always clobbers reg byte a 
 Statement [102] (byte*~) gfx_mode::$58 ← (byte*) get_vic_charset::return#4 [ keyboard_events_size#24 gfx_mode::$56 gfx_mode::$58 ] ( main:2::gfx_mode:15 [ form_cursor_count#16 form_field_idx#18 keyboard_events_size#24 gfx_mode::$56 gfx_mode::$58 ] ) always clobbers reg byte a 
@@ -22070,356 +22076,356 @@ Uplift Scope [gfx_init_plane_vertical2]
 Uplift Scope [gfx_init_plane_blank] 
 Uplift Scope [gfx_init_plane_full] 
 
-Uplifting [keyboard_event_scan] best 15485397 combination reg byte a [ keyboard_event_scan::$15 ] reg byte a [ keyboard_event_scan::$16 ] zp ZP_BYTE:252 [ keyboard_event_scan::event_type#0 ] zp ZP_BYTE:253 [ keyboard_event_scan::$23 ] zp ZP_BYTE:16 [ keyboard_event_scan::col#2 keyboard_event_scan::col#1 ] zp ZP_BYTE:17 [ keyboard_event_scan::keycode#10 keyboard_event_scan::keycode#11 keyboard_event_scan::keycode#13 keyboard_event_scan::keycode#14 keyboard_event_scan::keycode#1 ] zp ZP_BYTE:14 [ keyboard_event_scan::row#2 keyboard_event_scan::row#1 ] zp ZP_BYTE:241 [ keyboard_event_scan::row_scan#0 ] zp ZP_BYTE:243 [ keyboard_event_scan::$0 ] zp ZP_BYTE:245 [ keyboard_event_scan::$3 ] zp ZP_BYTE:247 [ keyboard_event_scan::$6 ] zp ZP_BYTE:249 [ keyboard_event_scan::$9 ] 
+Uplifting [keyboard_event_scan] best 15485435 combination reg byte a [ keyboard_event_scan::$15 ] reg byte a [ keyboard_event_scan::$16 ] zp ZP_BYTE:252 [ keyboard_event_scan::event_type#0 ] zp ZP_BYTE:253 [ keyboard_event_scan::$23 ] zp ZP_BYTE:16 [ keyboard_event_scan::col#2 keyboard_event_scan::col#1 ] zp ZP_BYTE:17 [ keyboard_event_scan::keycode#10 keyboard_event_scan::keycode#11 keyboard_event_scan::keycode#13 keyboard_event_scan::keycode#14 keyboard_event_scan::keycode#1 ] zp ZP_BYTE:14 [ keyboard_event_scan::row#2 keyboard_event_scan::row#1 ] zp ZP_BYTE:241 [ keyboard_event_scan::row_scan#0 ] zp ZP_BYTE:243 [ keyboard_event_scan::$0 ] zp ZP_BYTE:245 [ keyboard_event_scan::$3 ] zp ZP_BYTE:247 [ keyboard_event_scan::$6 ] zp ZP_BYTE:249 [ keyboard_event_scan::$9 ] 
 Limited combination testing to 10 combinations of 5308416 possible.
-Uplifting [] best 15485379 combination zp ZP_BYTE:18 [ keyboard_events_size#18 keyboard_events_size#109 keyboard_events_size#99 keyboard_events_size#47 keyboard_events_size#27 keyboard_events_size#24 keyboard_events_size#100 keyboard_events_size#4 keyboard_events_size#108 keyboard_events_size#1 keyboard_events_size#2 ] zp ZP_WORD:52 [ print_char_cursor#20 print_char_cursor#22 print_char_cursor#73 print_char_cursor#74 print_char_cursor#38 print_char_cursor#1 ] zp ZP_WORD:54 [ print_line_cursor#21 print_line_cursor#2 print_set_screen::screen#2 print_line_cursor#22 ] zp ZP_BYTE:31 [ form_cursor_count#21 form_cursor_count#1 form_cursor_count#16 form_cursor_count#15 form_cursor_count#5 ] zp ZP_BYTE:32 [ form_field_idx#28 form_field_idx#1 form_field_idx#18 form_field_idx#31 form_field_idx#6 form_field_idx#5 ] reg byte x [ keyboard_modifiers#21 keyboard_modifiers#20 keyboard_modifiers#19 keyboard_modifiers#18 keyboard_modifiers#3 keyboard_modifiers#4 keyboard_modifiers#5 ] 
+Uplifting [] best 15485417 combination zp ZP_BYTE:18 [ keyboard_events_size#18 keyboard_events_size#109 keyboard_events_size#99 keyboard_events_size#47 keyboard_events_size#27 keyboard_events_size#24 keyboard_events_size#100 keyboard_events_size#4 keyboard_events_size#108 keyboard_events_size#1 keyboard_events_size#2 ] zp ZP_WORD:52 [ print_char_cursor#20 print_char_cursor#22 print_char_cursor#73 print_char_cursor#74 print_char_cursor#38 print_char_cursor#1 ] zp ZP_WORD:54 [ print_line_cursor#21 print_line_cursor#2 print_set_screen::screen#2 print_line_cursor#22 ] zp ZP_BYTE:31 [ form_cursor_count#21 form_cursor_count#1 form_cursor_count#16 form_cursor_count#15 form_cursor_count#5 ] zp ZP_BYTE:32 [ form_field_idx#28 form_field_idx#1 form_field_idx#18 form_field_idx#31 form_field_idx#6 form_field_idx#5 ] reg byte x [ keyboard_modifiers#21 keyboard_modifiers#20 keyboard_modifiers#19 keyboard_modifiers#18 keyboard_modifiers#3 keyboard_modifiers#4 keyboard_modifiers#5 ] 
 Limited combination testing to 10 combinations of 16 possible.
-Uplifting [keyboard_matrix_read] best 15395376 combination reg byte a [ keyboard_matrix_read::return#2 ] reg byte x [ keyboard_matrix_read::rowid#0 ] zp ZP_BYTE:258 [ keyboard_matrix_read::return#0 ] 
+Uplifting [keyboard_matrix_read] best 15395414 combination reg byte a [ keyboard_matrix_read::return#2 ] reg byte x [ keyboard_matrix_read::rowid#0 ] zp ZP_BYTE:258 [ keyboard_matrix_read::return#0 ] 
 Limited combination testing to 10 combinations of 64 possible.
-Uplifting [gfx_init_plane_charset8] best 15380376 combination reg byte a [ gfx_init_plane_charset8::c#2 gfx_init_plane_charset8::c#3 ] reg byte a [ gfx_init_plane_charset8::$7 ] zp ZP_BYTE:88 [ gfx_init_plane_charset8::cp#2 gfx_init_plane_charset8::cp#1 ] zp ZP_BYTE:84 [ gfx_init_plane_charset8::bits#2 gfx_init_plane_charset8::bits#0 gfx_init_plane_charset8::bits#1 ] zp ZP_WORD:85 [ gfx_init_plane_charset8::gfxa#2 gfx_init_plane_charset8::gfxa#5 gfx_init_plane_charset8::gfxa#6 gfx_init_plane_charset8::gfxa#1 ] zp ZP_BYTE:87 [ gfx_init_plane_charset8::col#2 gfx_init_plane_charset8::col#5 gfx_init_plane_charset8::col#6 gfx_init_plane_charset8::col#1 ] zp ZP_WORD:81 [ gfx_init_plane_charset8::chargen#2 gfx_init_plane_charset8::chargen#3 gfx_init_plane_charset8::chargen#1 ] zp ZP_BYTE:83 [ gfx_init_plane_charset8::cr#6 gfx_init_plane_charset8::cr#1 ] zp ZP_BYTE:80 [ gfx_init_plane_charset8::ch#8 gfx_init_plane_charset8::ch#1 ] 
+Uplifting [gfx_init_plane_charset8] best 15380414 combination reg byte a [ gfx_init_plane_charset8::c#2 gfx_init_plane_charset8::c#3 ] reg byte a [ gfx_init_plane_charset8::$7 ] zp ZP_BYTE:88 [ gfx_init_plane_charset8::cp#2 gfx_init_plane_charset8::cp#1 ] zp ZP_BYTE:84 [ gfx_init_plane_charset8::bits#2 gfx_init_plane_charset8::bits#0 gfx_init_plane_charset8::bits#1 ] zp ZP_WORD:85 [ gfx_init_plane_charset8::gfxa#2 gfx_init_plane_charset8::gfxa#5 gfx_init_plane_charset8::gfxa#6 gfx_init_plane_charset8::gfxa#1 ] zp ZP_BYTE:87 [ gfx_init_plane_charset8::col#2 gfx_init_plane_charset8::col#5 gfx_init_plane_charset8::col#6 gfx_init_plane_charset8::col#1 ] zp ZP_WORD:81 [ gfx_init_plane_charset8::chargen#2 gfx_init_plane_charset8::chargen#3 gfx_init_plane_charset8::chargen#1 ] zp ZP_BYTE:83 [ gfx_init_plane_charset8::cr#6 gfx_init_plane_charset8::cr#1 ] zp ZP_BYTE:80 [ gfx_init_plane_charset8::ch#8 gfx_init_plane_charset8::ch#1 ] 
 Limited combination testing to 10 combinations of 1152 possible.
-Uplifting [print_str_at] best 15380376 combination zp ZP_WORD:37 [ print_str_at::str#2 print_str_at::str#1 print_str_at::str#0 ] zp ZP_WORD:39 [ print_str_at::at#2 print_str_at::at#0 ] 
-Uplifting [apply_preset] best 15368043 combination reg byte y [ apply_preset::i#2 apply_preset::i#1 ] zp ZP_WORD:43 [ apply_preset::preset#14 ] reg byte a [ apply_preset::idx#0 ] 
+Uplifting [print_str_at] best 15380414 combination zp ZP_WORD:37 [ print_str_at::str#2 print_str_at::str#1 print_str_at::str#0 ] zp ZP_WORD:39 [ print_str_at::at#2 print_str_at::at#0 ] 
+Uplifting [apply_preset] best 15368081 combination reg byte y [ apply_preset::i#2 apply_preset::i#1 ] zp ZP_WORD:43 [ apply_preset::preset#14 ] reg byte a [ apply_preset::idx#0 ] 
 Limited combination testing to 10 combinations of 12 possible.
-Uplifting [print_str_lines] best 15356043 combination zp ZP_WORD:50 [ print_str_lines::str#4 print_str_lines::str#3 print_str_lines::str#5 print_str_lines::str#0 ] reg byte a [ print_str_lines::ch#0 ] 
-Uplifting [form_mode] best 15348843 combination reg byte a [ form_mode::$36 ] reg byte x [ form_mode::i#2 form_mode::i#1 ] zp ZP_BYTE:33 [ form_mode::preset_current#6 form_mode::preset_current#0 form_mode::preset_current#1 ] 
+Uplifting [print_str_lines] best 15356081 combination zp ZP_WORD:50 [ print_str_lines::str#4 print_str_lines::str#3 print_str_lines::str#5 print_str_lines::str#0 ] reg byte a [ print_str_lines::ch#0 ] 
+Uplifting [form_mode] best 15348881 combination reg byte a [ form_mode::$36 ] reg byte x [ form_mode::i#2 form_mode::i#1 ] zp ZP_BYTE:33 [ form_mode::preset_current#6 form_mode::preset_current#0 form_mode::preset_current#1 ] 
 Limited combination testing to 10 combinations of 24 possible.
-Uplifting [form_render_values] best 15333843 combination reg byte x [ form_render_values::idx#2 form_render_values::idx#1 ] 
-Uplifting [form_field_ptr] best 15330830 combination reg byte x [ form_field_ptr::field_idx#2 form_field_ptr::field_idx#1 form_field_ptr::field_idx#0 ] zp ZP_BYTE:265 [ form_field_ptr::x#0 ] reg byte a [ form_field_ptr::y#0 ] zp ZP_WORD:263 [ form_field_ptr::line#0 ] 
+Uplifting [form_render_values] best 15333881 combination reg byte x [ form_render_values::idx#2 form_render_values::idx#1 ] 
+Uplifting [form_field_ptr] best 15330868 combination reg byte x [ form_field_ptr::field_idx#2 form_field_ptr::field_idx#1 form_field_ptr::field_idx#0 ] zp ZP_BYTE:265 [ form_field_ptr::x#0 ] reg byte a [ form_field_ptr::y#0 ] zp ZP_WORD:263 [ form_field_ptr::line#0 ] 
 Limited combination testing to 10 combinations of 24 possible.
-Uplifting [form_control] best 15323821 combination reg byte a [ form_control::return#0 ] reg byte x [ form_control::return#2 ] zp ZP_BYTE:266 [ form_control::$13 ] zp ZP_BYTE:269 [ form_control::$15 ] zp ZP_BYTE:270 [ form_control::$16 ] zp ZP_BYTE:271 [ form_control::$24 ] zp ZP_BYTE:272 [ form_control::$14 ] zp ZP_BYTE:268 [ form_control::key_event#0 ] 
+Uplifting [form_control] best 15323859 combination reg byte a [ form_control::return#0 ] reg byte x [ form_control::return#2 ] zp ZP_BYTE:266 [ form_control::$13 ] zp ZP_BYTE:269 [ form_control::$15 ] zp ZP_BYTE:270 [ form_control::$16 ] zp ZP_BYTE:271 [ form_control::$24 ] zp ZP_BYTE:272 [ form_control::$14 ] zp ZP_BYTE:268 [ form_control::key_event#0 ] 
 Limited combination testing to 10 combinations of 65536 possible.
-Uplifting [bitmap_plot] best 15321412 combination reg byte y [ bitmap_plot::y#4 bitmap_plot::y#1 bitmap_plot::y#0 bitmap_plot::y#3 bitmap_plot::y#2 ] reg byte x [ bitmap_plot::x#4 bitmap_plot::x#1 bitmap_plot::x#0 bitmap_plot::x#3 bitmap_plot::x#2 ] zp ZP_WORD:311 [ bitmap_plot::plotter_y#0 ] zp ZP_BYTE:315 [ bitmap_plot::$1 ] zp ZP_WORD:309 [ bitmap_plot::plotter_x#0 ] zp ZP_WORD:313 [ bitmap_plot::plotter#0 ] 
+Uplifting [bitmap_plot] best 15321450 combination reg byte y [ bitmap_plot::y#4 bitmap_plot::y#1 bitmap_plot::y#0 bitmap_plot::y#3 bitmap_plot::y#2 ] reg byte x [ bitmap_plot::x#4 bitmap_plot::x#1 bitmap_plot::x#0 bitmap_plot::x#3 bitmap_plot::x#2 ] zp ZP_WORD:311 [ bitmap_plot::plotter_y#0 ] zp ZP_BYTE:315 [ bitmap_plot::$1 ] zp ZP_WORD:309 [ bitmap_plot::plotter_x#0 ] zp ZP_WORD:313 [ bitmap_plot::plotter#0 ] 
 Limited combination testing to 10 combinations of 36 possible.
-Uplifting [gfx_init_screen2] best 15320212 combination reg byte a [ gfx_init_screen2::$0 ] reg byte a [ gfx_init_screen2::$3 ] zp ZP_BYTE:334 [ gfx_init_screen2::$4 ] zp ZP_BYTE:147 [ gfx_init_screen2::cx#2 gfx_init_screen2::cx#1 ] zp ZP_BYTE:331 [ gfx_init_screen2::col#0 ] zp ZP_WORD:148 [ gfx_init_screen2::ch#2 gfx_init_screen2::ch#3 gfx_init_screen2::ch#1 ] zp ZP_BYTE:332 [ gfx_init_screen2::col2#0 ] zp ZP_BYTE:146 [ gfx_init_screen2::cy#4 gfx_init_screen2::cy#1 ] 
+Uplifting [gfx_init_screen2] best 15320250 combination reg byte a [ gfx_init_screen2::$0 ] reg byte a [ gfx_init_screen2::$3 ] zp ZP_BYTE:334 [ gfx_init_screen2::$4 ] zp ZP_BYTE:147 [ gfx_init_screen2::cx#2 gfx_init_screen2::cx#1 ] zp ZP_BYTE:331 [ gfx_init_screen2::col#0 ] zp ZP_WORD:148 [ gfx_init_screen2::ch#2 gfx_init_screen2::ch#3 gfx_init_screen2::ch#1 ] zp ZP_BYTE:332 [ gfx_init_screen2::col2#0 ] zp ZP_BYTE:146 [ gfx_init_screen2::cy#4 gfx_init_screen2::cy#1 ] 
 Limited combination testing to 10 combinations of 2304 possible.
-Uplifting [gfx_init_plane_8bppchunky] best 15318982 combination reg byte x [ gfx_init_plane_8bppchunky::gfxbCpuBank#4 gfx_init_plane_8bppchunky::gfxbCpuBank#7 gfx_init_plane_8bppchunky::gfxbCpuBank#8 gfx_init_plane_8bppchunky::gfxbCpuBank#2 ] zp ZP_WORD:94 [ gfx_init_plane_8bppchunky::gfxb#4 gfx_init_plane_8bppchunky::gfxb#3 gfx_init_plane_8bppchunky::gfxb#5 gfx_init_plane_8bppchunky::gfxb#1 ] reg byte a [ gfx_init_plane_8bppchunky::c#0 ] zp ZP_WORD:91 [ gfx_init_plane_8bppchunky::x#2 gfx_init_plane_8bppchunky::x#1 ] zp ZP_WORD:295 [ gfx_init_plane_8bppchunky::$8 ] zp ZP_BYTE:90 [ gfx_init_plane_8bppchunky::y#6 gfx_init_plane_8bppchunky::y#1 ] 
+Uplifting [gfx_init_plane_8bppchunky] best 15319020 combination reg byte x [ gfx_init_plane_8bppchunky::gfxbCpuBank#4 gfx_init_plane_8bppchunky::gfxbCpuBank#7 gfx_init_plane_8bppchunky::gfxbCpuBank#8 gfx_init_plane_8bppchunky::gfxbCpuBank#2 ] zp ZP_WORD:94 [ gfx_init_plane_8bppchunky::gfxb#4 gfx_init_plane_8bppchunky::gfxb#3 gfx_init_plane_8bppchunky::gfxb#5 gfx_init_plane_8bppchunky::gfxb#1 ] reg byte a [ gfx_init_plane_8bppchunky::c#0 ] zp ZP_WORD:91 [ gfx_init_plane_8bppchunky::x#2 gfx_init_plane_8bppchunky::x#1 ] zp ZP_WORD:295 [ gfx_init_plane_8bppchunky::$8 ] zp ZP_BYTE:90 [ gfx_init_plane_8bppchunky::y#6 gfx_init_plane_8bppchunky::y#1 ] 
 Limited combination testing to 10 combinations of 16 possible.
-Uplifting [bitmap_line_xdyi] best 15318382 combination zp ZP_BYTE:102 [ bitmap_line_xdyi::e#3 bitmap_line_xdyi::e#0 bitmap_line_xdyi::e#6 bitmap_line_xdyi::e#2 bitmap_line_xdyi::e#1 ] zp ZP_BYTE:101 [ bitmap_line_xdyi::y#3 bitmap_line_xdyi::y#5 bitmap_line_xdyi::y#0 bitmap_line_xdyi::y#1 bitmap_line_xdyi::y#6 bitmap_line_xdyi::y#2 ] reg byte x [ bitmap_line_xdyi::$6 ] zp ZP_BYTE:100 [ bitmap_line_xdyi::x#3 bitmap_line_xdyi::x#6 bitmap_line_xdyi::x#0 bitmap_line_xdyi::x#1 bitmap_line_xdyi::x#2 ] zp ZP_BYTE:98 [ bitmap_line_xdyi::xd#5 bitmap_line_xdyi::xd#0 bitmap_line_xdyi::xd#1 ] zp ZP_BYTE:97 [ bitmap_line_xdyi::yd#2 bitmap_line_xdyi::yd#0 bitmap_line_xdyi::yd#1 ] zp ZP_BYTE:99 [ bitmap_line_xdyi::x1#6 bitmap_line_xdyi::x1#0 bitmap_line_xdyi::x1#1 ] 
+Uplifting [bitmap_line_xdyi] best 15318420 combination zp ZP_BYTE:102 [ bitmap_line_xdyi::e#3 bitmap_line_xdyi::e#0 bitmap_line_xdyi::e#6 bitmap_line_xdyi::e#2 bitmap_line_xdyi::e#1 ] zp ZP_BYTE:101 [ bitmap_line_xdyi::y#3 bitmap_line_xdyi::y#5 bitmap_line_xdyi::y#0 bitmap_line_xdyi::y#1 bitmap_line_xdyi::y#6 bitmap_line_xdyi::y#2 ] reg byte x [ bitmap_line_xdyi::$6 ] zp ZP_BYTE:100 [ bitmap_line_xdyi::x#3 bitmap_line_xdyi::x#6 bitmap_line_xdyi::x#0 bitmap_line_xdyi::x#1 bitmap_line_xdyi::x#2 ] zp ZP_BYTE:98 [ bitmap_line_xdyi::xd#5 bitmap_line_xdyi::xd#0 bitmap_line_xdyi::xd#1 ] zp ZP_BYTE:97 [ bitmap_line_xdyi::yd#2 bitmap_line_xdyi::yd#0 bitmap_line_xdyi::yd#1 ] zp ZP_BYTE:99 [ bitmap_line_xdyi::x1#6 bitmap_line_xdyi::x1#0 bitmap_line_xdyi::x1#1 ] 
 Limited combination testing to 10 combinations of 256 possible.
-Uplifting [bitmap_line_xdyd] best 15317782 combination zp ZP_BYTE:116 [ bitmap_line_xdyd::e#3 bitmap_line_xdyd::e#0 bitmap_line_xdyd::e#6 bitmap_line_xdyd::e#2 bitmap_line_xdyd::e#1 ] zp ZP_BYTE:115 [ bitmap_line_xdyd::y#3 bitmap_line_xdyd::y#5 bitmap_line_xdyd::y#0 bitmap_line_xdyd::y#1 bitmap_line_xdyd::y#6 bitmap_line_xdyd::y#2 ] reg byte x [ bitmap_line_xdyd::$6 ] zp ZP_BYTE:114 [ bitmap_line_xdyd::x#3 bitmap_line_xdyd::x#6 bitmap_line_xdyd::x#0 bitmap_line_xdyd::x#1 bitmap_line_xdyd::x#2 ] zp ZP_BYTE:112 [ bitmap_line_xdyd::xd#5 bitmap_line_xdyd::xd#0 bitmap_line_xdyd::xd#1 ] zp ZP_BYTE:111 [ bitmap_line_xdyd::yd#2 bitmap_line_xdyd::yd#0 bitmap_line_xdyd::yd#1 ] zp ZP_BYTE:113 [ bitmap_line_xdyd::x1#6 bitmap_line_xdyd::x1#0 bitmap_line_xdyd::x1#1 ] 
+Uplifting [bitmap_line_xdyd] best 15317820 combination zp ZP_BYTE:116 [ bitmap_line_xdyd::e#3 bitmap_line_xdyd::e#0 bitmap_line_xdyd::e#6 bitmap_line_xdyd::e#2 bitmap_line_xdyd::e#1 ] zp ZP_BYTE:115 [ bitmap_line_xdyd::y#3 bitmap_line_xdyd::y#5 bitmap_line_xdyd::y#0 bitmap_line_xdyd::y#1 bitmap_line_xdyd::y#6 bitmap_line_xdyd::y#2 ] reg byte x [ bitmap_line_xdyd::$6 ] zp ZP_BYTE:114 [ bitmap_line_xdyd::x#3 bitmap_line_xdyd::x#6 bitmap_line_xdyd::x#0 bitmap_line_xdyd::x#1 bitmap_line_xdyd::x#2 ] zp ZP_BYTE:112 [ bitmap_line_xdyd::xd#5 bitmap_line_xdyd::xd#0 bitmap_line_xdyd::xd#1 ] zp ZP_BYTE:111 [ bitmap_line_xdyd::yd#2 bitmap_line_xdyd::yd#0 bitmap_line_xdyd::yd#1 ] zp ZP_BYTE:113 [ bitmap_line_xdyd::x1#6 bitmap_line_xdyd::x1#0 bitmap_line_xdyd::x1#1 ] 
 Limited combination testing to 10 combinations of 256 possible.
-Uplifting [bitmap_line_ydxi] best 15316776 combination zp ZP_BYTE:110 [ bitmap_line_ydxi::e#3 bitmap_line_ydxi::e#0 bitmap_line_ydxi::e#6 bitmap_line_ydxi::e#2 bitmap_line_ydxi::e#1 ] reg byte x [ bitmap_line_ydxi::x#3 bitmap_line_ydxi::x#5 bitmap_line_ydxi::x#1 bitmap_line_ydxi::x#0 bitmap_line_ydxi::x#6 bitmap_line_ydxi::x#2 ] reg byte a [ bitmap_line_ydxi::$6 ] zp ZP_BYTE:109 [ bitmap_line_ydxi::y#3 bitmap_line_ydxi::y#6 bitmap_line_ydxi::y#1 bitmap_line_ydxi::y#0 bitmap_line_ydxi::y#2 ] zp ZP_BYTE:106 [ bitmap_line_ydxi::yd#5 bitmap_line_ydxi::yd#1 bitmap_line_ydxi::yd#0 ] zp ZP_BYTE:105 [ bitmap_line_ydxi::xd#2 bitmap_line_ydxi::xd#1 bitmap_line_ydxi::xd#0 ] zp ZP_BYTE:107 [ bitmap_line_ydxi::y1#6 bitmap_line_ydxi::y1#1 bitmap_line_ydxi::y1#0 ] 
+Uplifting [bitmap_line_ydxi] best 15316814 combination zp ZP_BYTE:110 [ bitmap_line_ydxi::e#3 bitmap_line_ydxi::e#0 bitmap_line_ydxi::e#6 bitmap_line_ydxi::e#2 bitmap_line_ydxi::e#1 ] reg byte x [ bitmap_line_ydxi::x#3 bitmap_line_ydxi::x#5 bitmap_line_ydxi::x#1 bitmap_line_ydxi::x#0 bitmap_line_ydxi::x#6 bitmap_line_ydxi::x#2 ] reg byte a [ bitmap_line_ydxi::$6 ] zp ZP_BYTE:109 [ bitmap_line_ydxi::y#3 bitmap_line_ydxi::y#6 bitmap_line_ydxi::y#1 bitmap_line_ydxi::y#0 bitmap_line_ydxi::y#2 ] zp ZP_BYTE:106 [ bitmap_line_ydxi::yd#5 bitmap_line_ydxi::yd#1 bitmap_line_ydxi::yd#0 ] zp ZP_BYTE:105 [ bitmap_line_ydxi::xd#2 bitmap_line_ydxi::xd#1 bitmap_line_ydxi::xd#0 ] zp ZP_BYTE:107 [ bitmap_line_ydxi::y1#6 bitmap_line_ydxi::y1#1 bitmap_line_ydxi::y1#0 ] 
 Limited combination testing to 10 combinations of 256 possible.
-Uplifting [bitmap_line_ydxd] best 15315770 combination zp ZP_BYTE:122 [ bitmap_line_ydxd::e#3 bitmap_line_ydxd::e#0 bitmap_line_ydxd::e#6 bitmap_line_ydxd::e#2 bitmap_line_ydxd::e#1 ] reg byte x [ bitmap_line_ydxd::x#3 bitmap_line_ydxd::x#5 bitmap_line_ydxd::x#0 bitmap_line_ydxd::x#1 bitmap_line_ydxd::x#6 bitmap_line_ydxd::x#2 ] reg byte a [ bitmap_line_ydxd::$6 ] zp ZP_BYTE:121 [ bitmap_line_ydxd::y#2 bitmap_line_ydxd::y#7 bitmap_line_ydxd::y#0 bitmap_line_ydxd::y#1 bitmap_line_ydxd::y#3 ] zp ZP_BYTE:118 [ bitmap_line_ydxd::yd#5 bitmap_line_ydxd::yd#0 bitmap_line_ydxd::yd#1 ] zp ZP_BYTE:117 [ bitmap_line_ydxd::xd#2 bitmap_line_ydxd::xd#0 bitmap_line_ydxd::xd#1 ] zp ZP_BYTE:119 [ bitmap_line_ydxd::y1#6 bitmap_line_ydxd::y1#0 bitmap_line_ydxd::y1#1 ] 
+Uplifting [bitmap_line_ydxd] best 15315808 combination zp ZP_BYTE:122 [ bitmap_line_ydxd::e#3 bitmap_line_ydxd::e#0 bitmap_line_ydxd::e#6 bitmap_line_ydxd::e#2 bitmap_line_ydxd::e#1 ] reg byte x [ bitmap_line_ydxd::x#3 bitmap_line_ydxd::x#5 bitmap_line_ydxd::x#0 bitmap_line_ydxd::x#1 bitmap_line_ydxd::x#6 bitmap_line_ydxd::x#2 ] reg byte a [ bitmap_line_ydxd::$6 ] zp ZP_BYTE:121 [ bitmap_line_ydxd::y#2 bitmap_line_ydxd::y#7 bitmap_line_ydxd::y#0 bitmap_line_ydxd::y#1 bitmap_line_ydxd::y#3 ] zp ZP_BYTE:118 [ bitmap_line_ydxd::yd#5 bitmap_line_ydxd::yd#0 bitmap_line_ydxd::yd#1 ] zp ZP_BYTE:117 [ bitmap_line_ydxd::xd#2 bitmap_line_ydxd::xd#0 bitmap_line_ydxd::xd#1 ] zp ZP_BYTE:119 [ bitmap_line_ydxd::y1#6 bitmap_line_ydxd::y1#0 bitmap_line_ydxd::y1#1 ] 
 Limited combination testing to 10 combinations of 256 possible.
-Uplifting [gfx_init_screen0] best 15314570 combination reg byte a [ gfx_init_screen0::$0 ] reg byte a [ gfx_init_screen0::$2 ] zp ZP_BYTE:340 [ gfx_init_screen0::$3 ] zp ZP_BYTE:155 [ gfx_init_screen0::cx#2 gfx_init_screen0::cx#1 ] zp ZP_WORD:156 [ gfx_init_screen0::ch#2 gfx_init_screen0::ch#3 gfx_init_screen0::ch#1 ] zp ZP_BYTE:338 [ gfx_init_screen0::$1 ] zp ZP_BYTE:154 [ gfx_init_screen0::cy#4 gfx_init_screen0::cy#1 ] 
+Uplifting [gfx_init_screen0] best 15314608 combination reg byte a [ gfx_init_screen0::$0 ] reg byte a [ gfx_init_screen0::$2 ] zp ZP_BYTE:340 [ gfx_init_screen0::$3 ] zp ZP_BYTE:155 [ gfx_init_screen0::cx#2 gfx_init_screen0::cx#1 ] zp ZP_WORD:156 [ gfx_init_screen0::ch#2 gfx_init_screen0::ch#3 gfx_init_screen0::ch#1 ] zp ZP_BYTE:338 [ gfx_init_screen0::$1 ] zp ZP_BYTE:154 [ gfx_init_screen0::cy#4 gfx_init_screen0::cy#1 ] 
 Limited combination testing to 10 combinations of 768 possible.
-Uplifting [gfx_init_screen3] best 15313370 combination reg byte a [ gfx_init_screen3::$0 ] reg byte a [ gfx_init_screen3::$2 ] zp ZP_BYTE:329 [ gfx_init_screen3::$3 ] zp ZP_BYTE:143 [ gfx_init_screen3::cx#2 gfx_init_screen3::cx#1 ] zp ZP_WORD:144 [ gfx_init_screen3::ch#2 gfx_init_screen3::ch#3 gfx_init_screen3::ch#1 ] zp ZP_BYTE:327 [ gfx_init_screen3::$1 ] zp ZP_BYTE:142 [ gfx_init_screen3::cy#4 gfx_init_screen3::cy#1 ] 
+Uplifting [gfx_init_screen3] best 15313408 combination reg byte a [ gfx_init_screen3::$0 ] reg byte a [ gfx_init_screen3::$2 ] zp ZP_BYTE:329 [ gfx_init_screen3::$3 ] zp ZP_BYTE:143 [ gfx_init_screen3::cx#2 gfx_init_screen3::cx#1 ] zp ZP_WORD:144 [ gfx_init_screen3::ch#2 gfx_init_screen3::ch#3 gfx_init_screen3::ch#1 ] zp ZP_BYTE:327 [ gfx_init_screen3::$1 ] zp ZP_BYTE:142 [ gfx_init_screen3::cy#4 gfx_init_screen3::cy#1 ] 
 Limited combination testing to 10 combinations of 768 possible.
-Uplifting [gfx_init_plane_horisontal] best 15311870 combination zp ZP_WORD:77 [ gfx_init_plane_horisontal::gfxa#3 gfx_init_plane_horisontal::gfxa#6 gfx_init_plane_horisontal::gfxa#7 gfx_init_plane_horisontal::gfxa#1 gfx_init_plane_horisontal::gfxa#2 ] reg byte a [ gfx_init_plane_horisontal::$7 ] reg byte x [ gfx_init_plane_horisontal::ax#2 gfx_init_plane_horisontal::ax#1 ] zp ZP_BYTE:76 [ gfx_init_plane_horisontal::ay#4 gfx_init_plane_horisontal::ay#1 ] 
+Uplifting [gfx_init_plane_horisontal] best 15311908 combination zp ZP_WORD:77 [ gfx_init_plane_horisontal::gfxa#3 gfx_init_plane_horisontal::gfxa#6 gfx_init_plane_horisontal::gfxa#7 gfx_init_plane_horisontal::gfxa#1 gfx_init_plane_horisontal::gfxa#2 ] reg byte a [ gfx_init_plane_horisontal::$7 ] reg byte x [ gfx_init_plane_horisontal::ax#2 gfx_init_plane_horisontal::ax#1 ] zp ZP_BYTE:76 [ gfx_init_plane_horisontal::ay#4 gfx_init_plane_horisontal::ay#1 ] 
 Limited combination testing to 10 combinations of 16 possible.
-Uplifting [gfx_init_screen1] best 15310270 combination reg byte x [ gfx_init_screen1::cx#2 gfx_init_screen1::cx#1 ] reg byte a [ gfx_init_screen1::$0 ] zp ZP_BYTE:336 [ gfx_init_screen1::$1 ] zp ZP_WORD:152 [ gfx_init_screen1::ch#2 gfx_init_screen1::ch#3 gfx_init_screen1::ch#1 ] zp ZP_BYTE:150 [ gfx_init_screen1::cy#4 gfx_init_screen1::cy#1 ] 
+Uplifting [gfx_init_screen1] best 15310308 combination reg byte x [ gfx_init_screen1::cx#2 gfx_init_screen1::cx#1 ] reg byte a [ gfx_init_screen1::$0 ] zp ZP_BYTE:336 [ gfx_init_screen1::$1 ] zp ZP_WORD:152 [ gfx_init_screen1::ch#2 gfx_init_screen1::ch#3 gfx_init_screen1::ch#1 ] zp ZP_BYTE:150 [ gfx_init_screen1::cy#4 gfx_init_screen1::cy#1 ] 
 Limited combination testing to 10 combinations of 64 possible.
-Uplifting [form_set_screen] best 15308170 combination reg byte x [ form_set_screen::y#2 form_set_screen::y#1 ] reg byte a [ form_set_screen::$0 ] zp ZP_BYTE:274 [ form_set_screen::$1 ] zp ZP_WORD:47 [ form_set_screen::line#2 form_set_screen::line#1 ] 
+Uplifting [form_set_screen] best 15308208 combination reg byte x [ form_set_screen::y#2 form_set_screen::y#1 ] reg byte a [ form_set_screen::$0 ] zp ZP_BYTE:274 [ form_set_screen::$1 ] zp ZP_WORD:47 [ form_set_screen::line#2 form_set_screen::line#1 ] 
 Limited combination testing to 10 combinations of 48 possible.
-Uplifting [gfx_init_plane_horisontal2] best 15307170 combination reg byte a [ gfx_init_plane_horisontal2::$7 ] reg byte a [ gfx_init_plane_horisontal2::row#0 ] zp ZP_BYTE:71 [ gfx_init_plane_horisontal2::ax#2 gfx_init_plane_horisontal2::ax#1 ] zp ZP_WORD:69 [ gfx_init_plane_horisontal2::gfxa#2 gfx_init_plane_horisontal2::gfxa#3 gfx_init_plane_horisontal2::gfxa#1 ] zp ZP_BYTE:68 [ gfx_init_plane_horisontal2::ay#4 gfx_init_plane_horisontal2::ay#1 ] 
+Uplifting [gfx_init_plane_horisontal2] best 15307208 combination reg byte a [ gfx_init_plane_horisontal2::$7 ] reg byte a [ gfx_init_plane_horisontal2::row#0 ] zp ZP_BYTE:71 [ gfx_init_plane_horisontal2::ax#2 gfx_init_plane_horisontal2::ax#1 ] zp ZP_WORD:69 [ gfx_init_plane_horisontal2::gfxa#2 gfx_init_plane_horisontal2::gfxa#3 gfx_init_plane_horisontal2::gfxa#1 ] zp ZP_BYTE:68 [ gfx_init_plane_horisontal2::ay#4 gfx_init_plane_horisontal2::ay#1 ] 
 Limited combination testing to 10 combinations of 64 possible.
-Uplifting [gfx_init_charset] best 15306270 combination zp ZP_WORD:135 [ gfx_init_charset::charset#2 gfx_init_charset::charset#3 gfx_init_charset::charset#1 ] reg byte x [ gfx_init_charset::l#2 gfx_init_charset::l#1 ] zp ZP_WORD:133 [ gfx_init_charset::chargen#2 gfx_init_charset::chargen#3 gfx_init_charset::chargen#1 ] zp ZP_BYTE:132 [ gfx_init_charset::c#4 gfx_init_charset::c#1 ] 
-Uplifting [gfx_init_plane_fill] best 15305364 combination zp ZP_WORD:64 [ gfx_init_plane_fill::gfxb#2 gfx_init_plane_fill::gfxb#3 gfx_init_plane_fill::gfxb#1 gfx_init_plane_fill::gfxb#6 ] reg byte x [ gfx_init_plane_fill::bx#2 gfx_init_plane_fill::bx#1 ] zp ZP_BYTE:63 [ gfx_init_plane_fill::by#4 gfx_init_plane_fill::by#1 ] zp ZP_BYTE:62 [ gfx_init_plane_fill::fill#6 ] zp ZP_DWORD:278 [ gfx_init_plane_fill::$0 ] zp ZP_WORD:282 [ gfx_init_plane_fill::$1 ] reg byte a [ gfx_init_plane_fill::gfxbCpuBank#0 ] zp ZP_WORD:285 [ gfx_init_plane_fill::$4 ] zp ZP_WORD:287 [ gfx_init_plane_fill::$5 ] zp ZP_WORD:289 [ gfx_init_plane_fill::gfxb#0 ] zp ZP_DWORD:58 [ gfx_init_plane_fill::plane_addr#3 ] 
+Uplifting [gfx_init_charset] best 15306308 combination zp ZP_WORD:135 [ gfx_init_charset::charset#2 gfx_init_charset::charset#3 gfx_init_charset::charset#1 ] reg byte x [ gfx_init_charset::l#2 gfx_init_charset::l#1 ] zp ZP_WORD:133 [ gfx_init_charset::chargen#2 gfx_init_charset::chargen#3 gfx_init_charset::chargen#1 ] zp ZP_BYTE:132 [ gfx_init_charset::c#4 gfx_init_charset::c#1 ] 
+Uplifting [gfx_init_plane_fill] best 15305402 combination zp ZP_WORD:64 [ gfx_init_plane_fill::gfxb#2 gfx_init_plane_fill::gfxb#3 gfx_init_plane_fill::gfxb#1 gfx_init_plane_fill::gfxb#6 ] reg byte x [ gfx_init_plane_fill::bx#2 gfx_init_plane_fill::bx#1 ] zp ZP_BYTE:63 [ gfx_init_plane_fill::by#4 gfx_init_plane_fill::by#1 ] zp ZP_BYTE:62 [ gfx_init_plane_fill::fill#6 ] zp ZP_DWORD:278 [ gfx_init_plane_fill::$0 ] zp ZP_WORD:282 [ gfx_init_plane_fill::$1 ] reg byte a [ gfx_init_plane_fill::gfxbCpuBank#0 ] zp ZP_WORD:285 [ gfx_init_plane_fill::$4 ] zp ZP_WORD:287 [ gfx_init_plane_fill::$5 ] zp ZP_WORD:289 [ gfx_init_plane_fill::gfxb#0 ] zp ZP_DWORD:58 [ gfx_init_plane_fill::plane_addr#3 ] 
 Limited combination testing to 10 combinations of 32 possible.
-Uplifting [bitmap_clear] best 15304464 combination zp ZP_WORD:124 [ bitmap_clear::bitmap#2 bitmap_clear::bitmap#3 bitmap_clear::bitmap#5 bitmap_clear::bitmap#1 ] reg byte x [ bitmap_clear::x#2 bitmap_clear::x#1 ] zp ZP_BYTE:123 [ bitmap_clear::y#4 bitmap_clear::y#1 ] zp ZP_WORD:319 [ bitmap_clear::bitmap#0 ] 
-Uplifting [gfx_init_screen4] best 15303564 combination zp ZP_WORD:139 [ gfx_init_screen4::ch#2 gfx_init_screen4::ch#3 gfx_init_screen4::ch#1 ] reg byte x [ gfx_init_screen4::cx#2 gfx_init_screen4::cx#1 ] zp ZP_BYTE:138 [ gfx_init_screen4::cy#4 gfx_init_screen4::cy#1 ] 
-Uplifting [gfx_init_plane_vertical] best 15302664 combination zp ZP_WORD:73 [ gfx_init_plane_vertical::gfxb#2 gfx_init_plane_vertical::gfxb#3 gfx_init_plane_vertical::gfxb#1 ] reg byte x [ gfx_init_plane_vertical::bx#2 gfx_init_plane_vertical::bx#1 ] zp ZP_BYTE:72 [ gfx_init_plane_vertical::by#4 gfx_init_plane_vertical::by#1 ] 
-Uplifting [print_cls] best 15302664 combination zp ZP_WORD:56 [ print_cls::sc#2 print_cls::sc#0 print_cls::sc#1 ] zp ZP_WORD:276 [ print_cls::$0 ] 
-Uplifting [dtvSetCpuBankSegment1] best 15302525 combination reg byte a [ dtvSetCpuBankSegment1::cpuBankIdx#13 dtvSetCpuBankSegment1::cpuBankIdx#1 dtvSetCpuBankSegment1::cpuBankIdx#11 ] 
-Uplifting [keyboard_event_get] best 15301616 combination reg byte a [ keyboard_event_get::return#3 ] reg byte a [ keyboard_event_get::return#2 keyboard_event_get::return#1 ] zp ZP_BYTE:267 [ keyboard_event_get::return#4 ] 
+Uplifting [bitmap_clear] best 15304502 combination zp ZP_WORD:124 [ bitmap_clear::bitmap#2 bitmap_clear::bitmap#3 bitmap_clear::bitmap#5 bitmap_clear::bitmap#1 ] reg byte x [ bitmap_clear::x#2 bitmap_clear::x#1 ] zp ZP_BYTE:123 [ bitmap_clear::y#4 bitmap_clear::y#1 ] zp ZP_WORD:319 [ bitmap_clear::bitmap#0 ] 
+Uplifting [gfx_init_screen4] best 15303602 combination zp ZP_WORD:139 [ gfx_init_screen4::ch#2 gfx_init_screen4::ch#3 gfx_init_screen4::ch#1 ] reg byte x [ gfx_init_screen4::cx#2 gfx_init_screen4::cx#1 ] zp ZP_BYTE:138 [ gfx_init_screen4::cy#4 gfx_init_screen4::cy#1 ] 
+Uplifting [gfx_init_plane_vertical] best 15302702 combination zp ZP_WORD:73 [ gfx_init_plane_vertical::gfxb#2 gfx_init_plane_vertical::gfxb#3 gfx_init_plane_vertical::gfxb#1 ] reg byte x [ gfx_init_plane_vertical::bx#2 gfx_init_plane_vertical::bx#1 ] zp ZP_BYTE:72 [ gfx_init_plane_vertical::by#4 gfx_init_plane_vertical::by#1 ] 
+Uplifting [print_cls] best 15302702 combination zp ZP_WORD:56 [ print_cls::sc#2 print_cls::sc#0 print_cls::sc#1 ] zp ZP_WORD:276 [ print_cls::$0 ] 
+Uplifting [dtvSetCpuBankSegment1] best 15302563 combination reg byte a [ dtvSetCpuBankSegment1::cpuBankIdx#13 dtvSetCpuBankSegment1::cpuBankIdx#1 dtvSetCpuBankSegment1::cpuBankIdx#11 ] 
+Uplifting [keyboard_event_get] best 15301654 combination reg byte a [ keyboard_event_get::return#3 ] reg byte a [ keyboard_event_get::return#2 keyboard_event_get::return#1 ] zp ZP_BYTE:267 [ keyboard_event_get::return#4 ] 
 Limited combination testing to 10 combinations of 64 possible.
-Uplifting [render_preset_name] best 15301280 combination reg byte a [ render_preset_name::idx#10 render_preset_name::idx#0 render_preset_name::idx#1 ] zp ZP_WORD:35 [ render_preset_name::name#13 ] 
-Uplifting [bitmap_init] best 15300980 combination zp ZP_WORD:130 [ bitmap_init::yoffs#2 bitmap_init::yoffs#4 bitmap_init::yoffs#1 ] reg byte y [ bitmap_init::bits#3 bitmap_init::bits#4 bitmap_init::bits#1 ] reg byte x [ bitmap_init::x#2 bitmap_init::x#1 ] zp ZP_BYTE:129 [ bitmap_init::y#2 bitmap_init::y#1 ] zp ZP_BYTE:321 [ bitmap_init::$0 ] zp ZP_BYTE:323 [ bitmap_init::$7 ] zp ZP_BYTE:324 [ bitmap_init::$8 ] zp ZP_BYTE:325 [ bitmap_init::$9 ] zp ZP_BYTE:322 [ bitmap_init::$10 ] 
+Uplifting [render_preset_name] best 15301318 combination reg byte a [ render_preset_name::idx#10 render_preset_name::idx#0 render_preset_name::idx#1 ] zp ZP_WORD:35 [ render_preset_name::name#13 ] 
+Uplifting [bitmap_init] best 15301018 combination zp ZP_WORD:130 [ bitmap_init::yoffs#2 bitmap_init::yoffs#4 bitmap_init::yoffs#1 ] reg byte y [ bitmap_init::bits#3 bitmap_init::bits#4 bitmap_init::bits#1 ] reg byte x [ bitmap_init::x#2 bitmap_init::x#1 ] zp ZP_BYTE:129 [ bitmap_init::y#2 bitmap_init::y#1 ] zp ZP_BYTE:321 [ bitmap_init::$0 ] zp ZP_BYTE:323 [ bitmap_init::$7 ] zp ZP_BYTE:324 [ bitmap_init::$8 ] zp ZP_BYTE:325 [ bitmap_init::$9 ] zp ZP_BYTE:322 [ bitmap_init::$10 ] 
 Limited combination testing to 10 combinations of 34560 possible.
-Uplifting [keyboard_event_pressed] best 15300968 combination reg byte a [ keyboard_event_pressed::return#0 ] reg byte a [ keyboard_event_pressed::return#1 ] zp ZP_BYTE:246 [ keyboard_event_pressed::return#2 ] zp ZP_BYTE:248 [ keyboard_event_pressed::return#3 ] zp ZP_BYTE:254 [ keyboard_event_pressed::$0 ] zp ZP_BYTE:256 [ keyboard_event_pressed::$1 ] zp ZP_BYTE:255 [ keyboard_event_pressed::row_bits#0 ] zp ZP_BYTE:257 [ keyboard_event_pressed::return#10 ] zp ZP_BYTE:19 [ keyboard_event_pressed::keycode#4 ] 
+Uplifting [keyboard_event_pressed] best 15301006 combination reg byte a [ keyboard_event_pressed::return#0 ] reg byte a [ keyboard_event_pressed::return#1 ] zp ZP_BYTE:246 [ keyboard_event_pressed::return#2 ] zp ZP_BYTE:248 [ keyboard_event_pressed::return#3 ] zp ZP_BYTE:254 [ keyboard_event_pressed::$0 ] zp ZP_BYTE:256 [ keyboard_event_pressed::$1 ] zp ZP_BYTE:255 [ keyboard_event_pressed::row_bits#0 ] zp ZP_BYTE:257 [ keyboard_event_pressed::return#10 ] zp ZP_BYTE:19 [ keyboard_event_pressed::keycode#4 ] 
 Limited combination testing to 10 combinations of 147456 possible.
-Uplifting [gfx_init_vic_bitmap] best 15300968 combination zp ZP_BYTE:96 [ gfx_init_vic_bitmap::l#2 gfx_init_vic_bitmap::l#1 ] 
-Uplifting [get_vic_screen] best 15300947 combination reg byte a [ get_vic_screen::idx#2 get_vic_screen::idx#0 get_vic_screen::idx#1 ] zp ZP_WORD:208 [ get_vic_screen::return#10 ] zp ZP_WORD:227 [ get_vic_screen::return#11 ] zp ZP_WORD:21 [ get_vic_screen::return#5 ] 
-Uplifting [get_plane] best 15300899 combination reg byte a [ get_plane::idx#10 get_plane::idx#1 get_plane::idx#0 ] zp ZP_DWORD:160 [ get_plane::return#16 ] zp ZP_DWORD:185 [ get_plane::return#17 ] zp ZP_DWORD:26 [ get_plane::return#14 ] 
-Uplifting [bitmap_line] best 15300853 combination zp ZP_BYTE:301 [ bitmap_line::y1#0 ] zp ZP_BYTE:300 [ bitmap_line::y0#0 ] reg byte x [ bitmap_line::x1#0 ] zp ZP_BYTE:298 [ bitmap_line::x0#0 ] zp ZP_BYTE:303 [ bitmap_line::yd#2 ] zp ZP_BYTE:304 [ bitmap_line::yd#1 ] zp ZP_BYTE:306 [ bitmap_line::yd#10 ] zp ZP_BYTE:307 [ bitmap_line::yd#11 ] zp ZP_BYTE:302 [ bitmap_line::xd#2 ] zp ZP_BYTE:305 [ bitmap_line::xd#1 ] 
+Uplifting [gfx_init_vic_bitmap] best 15301006 combination zp ZP_BYTE:96 [ gfx_init_vic_bitmap::l#2 gfx_init_vic_bitmap::l#1 ] 
+Uplifting [get_vic_screen] best 15300985 combination reg byte a [ get_vic_screen::idx#2 get_vic_screen::idx#0 get_vic_screen::idx#1 ] zp ZP_WORD:208 [ get_vic_screen::return#10 ] zp ZP_WORD:227 [ get_vic_screen::return#11 ] zp ZP_WORD:21 [ get_vic_screen::return#5 ] 
+Uplifting [get_plane] best 15300937 combination reg byte a [ get_plane::idx#10 get_plane::idx#1 get_plane::idx#0 ] zp ZP_DWORD:160 [ get_plane::return#16 ] zp ZP_DWORD:185 [ get_plane::return#17 ] zp ZP_DWORD:26 [ get_plane::return#14 ] 
+Uplifting [bitmap_line] best 15300891 combination zp ZP_BYTE:301 [ bitmap_line::y1#0 ] zp ZP_BYTE:300 [ bitmap_line::y0#0 ] reg byte x [ bitmap_line::x1#0 ] zp ZP_BYTE:298 [ bitmap_line::x0#0 ] zp ZP_BYTE:303 [ bitmap_line::yd#2 ] zp ZP_BYTE:304 [ bitmap_line::yd#1 ] zp ZP_BYTE:306 [ bitmap_line::yd#10 ] zp ZP_BYTE:307 [ bitmap_line::yd#11 ] zp ZP_BYTE:302 [ bitmap_line::xd#2 ] zp ZP_BYTE:305 [ bitmap_line::xd#1 ] 
 Limited combination testing to 10 combinations of 186624 possible.
-Uplifting [get_vic_charset] best 15300844 combination zp ZP_WORD:218 [ get_vic_charset::return#4 ] reg byte a [ get_vic_charset::idx#0 ] zp ZP_WORD:23 [ get_vic_charset::return#2 ] 
-Uplifting [print_ln] best 15300844 combination 
-Uplifting [print_set_screen] best 15300844 combination 
-Uplifting [keyboard_init] best 15300844 combination 
-Uplifting [main] best 15300844 combination 
-Uplifting [gfx_init] best 15300844 combination 
-Uplifting [gfx_init_plane_vertical2] best 15300844 combination 
-Uplifting [gfx_init_plane_blank] best 15300844 combination 
-Uplifting [gfx_init_plane_full] best 15300844 combination 
+Uplifting [get_vic_charset] best 15300882 combination zp ZP_WORD:218 [ get_vic_charset::return#4 ] reg byte a [ get_vic_charset::idx#0 ] zp ZP_WORD:23 [ get_vic_charset::return#2 ] 
+Uplifting [print_ln] best 15300882 combination 
+Uplifting [print_set_screen] best 15300882 combination 
+Uplifting [keyboard_init] best 15300882 combination 
+Uplifting [main] best 15300882 combination 
+Uplifting [gfx_init] best 15300882 combination 
+Uplifting [gfx_init_plane_vertical2] best 15300882 combination 
+Uplifting [gfx_init_plane_blank] best 15300882 combination 
+Uplifting [gfx_init_plane_full] best 15300882 combination 
 Attempting to uplift remaining variables inzp ZP_BYTE:18 [ keyboard_events_size#18 keyboard_events_size#109 keyboard_events_size#99 keyboard_events_size#47 keyboard_events_size#27 keyboard_events_size#24 keyboard_events_size#100 keyboard_events_size#4 keyboard_events_size#108 keyboard_events_size#1 keyboard_events_size#2 ]
-Uplifting [] best 15300844 combination zp ZP_BYTE:18 [ keyboard_events_size#18 keyboard_events_size#109 keyboard_events_size#99 keyboard_events_size#47 keyboard_events_size#27 keyboard_events_size#24 keyboard_events_size#100 keyboard_events_size#4 keyboard_events_size#108 keyboard_events_size#1 keyboard_events_size#2 ] 
+Uplifting [] best 15300882 combination zp ZP_BYTE:18 [ keyboard_events_size#18 keyboard_events_size#109 keyboard_events_size#99 keyboard_events_size#47 keyboard_events_size#27 keyboard_events_size#24 keyboard_events_size#100 keyboard_events_size#4 keyboard_events_size#108 keyboard_events_size#1 keyboard_events_size#2 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:252 [ keyboard_event_scan::event_type#0 ]
-Uplifting [keyboard_event_scan] best 14700844 combination reg byte a [ keyboard_event_scan::event_type#0 ] 
+Uplifting [keyboard_event_scan] best 14700882 combination reg byte a [ keyboard_event_scan::event_type#0 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:253 [ keyboard_event_scan::$23 ]
-Uplifting [keyboard_event_scan] best 14100844 combination reg byte a [ keyboard_event_scan::$23 ] 
+Uplifting [keyboard_event_scan] best 14100882 combination reg byte a [ keyboard_event_scan::$23 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:16 [ keyboard_event_scan::col#2 keyboard_event_scan::col#1 ]
-Uplifting [keyboard_event_scan] best 12600844 combination reg byte x [ keyboard_event_scan::col#2 keyboard_event_scan::col#1 ] 
+Uplifting [keyboard_event_scan] best 12600882 combination reg byte x [ keyboard_event_scan::col#2 keyboard_event_scan::col#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:17 [ keyboard_event_scan::keycode#10 keyboard_event_scan::keycode#11 keyboard_event_scan::keycode#13 keyboard_event_scan::keycode#14 keyboard_event_scan::keycode#1 ]
-Uplifting [keyboard_event_scan] best 12600844 combination zp ZP_BYTE:17 [ keyboard_event_scan::keycode#10 keyboard_event_scan::keycode#11 keyboard_event_scan::keycode#13 keyboard_event_scan::keycode#14 keyboard_event_scan::keycode#1 ] 
+Uplifting [keyboard_event_scan] best 12600882 combination zp ZP_BYTE:17 [ keyboard_event_scan::keycode#10 keyboard_event_scan::keycode#11 keyboard_event_scan::keycode#13 keyboard_event_scan::keycode#14 keyboard_event_scan::keycode#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:14 [ keyboard_event_scan::row#2 keyboard_event_scan::row#1 ]
-Uplifting [keyboard_event_scan] best 12600844 combination zp ZP_BYTE:14 [ keyboard_event_scan::row#2 keyboard_event_scan::row#1 ] 
+Uplifting [keyboard_event_scan] best 12600882 combination zp ZP_BYTE:14 [ keyboard_event_scan::row#2 keyboard_event_scan::row#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:241 [ keyboard_event_scan::row_scan#0 ]
-Uplifting [keyboard_event_scan] best 12600844 combination zp ZP_BYTE:241 [ keyboard_event_scan::row_scan#0 ] 
+Uplifting [keyboard_event_scan] best 12600882 combination zp ZP_BYTE:241 [ keyboard_event_scan::row_scan#0 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:258 [ keyboard_matrix_read::return#0 ]
-Uplifting [keyboard_matrix_read] best 12570841 combination reg byte a [ keyboard_matrix_read::return#0 ] 
+Uplifting [keyboard_matrix_read] best 12570879 combination reg byte a [ keyboard_matrix_read::return#0 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:10 [ gfx_mode::cx#2 gfx_mode::cx#1 ]
-Uplifting [gfx_mode] best 12561841 combination reg byte x [ gfx_mode::cx#2 gfx_mode::cx#1 ] 
+Uplifting [gfx_mode] best 12561879 combination reg byte x [ gfx_mode::cx#2 gfx_mode::cx#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:88 [ gfx_init_plane_charset8::cp#2 gfx_init_plane_charset8::cp#1 ]
-Uplifting [gfx_init_plane_charset8] best 12552841 combination reg byte x [ gfx_init_plane_charset8::cp#2 gfx_init_plane_charset8::cp#1 ] 
+Uplifting [gfx_init_plane_charset8] best 12552879 combination reg byte x [ gfx_init_plane_charset8::cp#2 gfx_init_plane_charset8::cp#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:84 [ gfx_init_plane_charset8::bits#2 gfx_init_plane_charset8::bits#0 gfx_init_plane_charset8::bits#1 ]
-Uplifting [gfx_init_plane_charset8] best 12552841 combination zp ZP_BYTE:84 [ gfx_init_plane_charset8::bits#2 gfx_init_plane_charset8::bits#0 gfx_init_plane_charset8::bits#1 ] 
+Uplifting [gfx_init_plane_charset8] best 12552879 combination zp ZP_BYTE:84 [ gfx_init_plane_charset8::bits#2 gfx_init_plane_charset8::bits#0 gfx_init_plane_charset8::bits#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:87 [ gfx_init_plane_charset8::col#2 gfx_init_plane_charset8::col#5 gfx_init_plane_charset8::col#6 gfx_init_plane_charset8::col#1 ]
-Uplifting [gfx_init_plane_charset8] best 12552841 combination zp ZP_BYTE:87 [ gfx_init_plane_charset8::col#2 gfx_init_plane_charset8::col#5 gfx_init_plane_charset8::col#6 gfx_init_plane_charset8::col#1 ] 
+Uplifting [gfx_init_plane_charset8] best 12552879 combination zp ZP_BYTE:87 [ gfx_init_plane_charset8::col#2 gfx_init_plane_charset8::col#5 gfx_init_plane_charset8::col#6 gfx_init_plane_charset8::col#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:102 [ bitmap_line_xdyi::e#3 bitmap_line_xdyi::e#0 bitmap_line_xdyi::e#6 bitmap_line_xdyi::e#2 bitmap_line_xdyi::e#1 ]
-Uplifting [bitmap_line_xdyi] best 12552841 combination zp ZP_BYTE:102 [ bitmap_line_xdyi::e#3 bitmap_line_xdyi::e#0 bitmap_line_xdyi::e#6 bitmap_line_xdyi::e#2 bitmap_line_xdyi::e#1 ] 
+Uplifting [bitmap_line_xdyi] best 12552879 combination zp ZP_BYTE:102 [ bitmap_line_xdyi::e#3 bitmap_line_xdyi::e#0 bitmap_line_xdyi::e#6 bitmap_line_xdyi::e#2 bitmap_line_xdyi::e#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:110 [ bitmap_line_ydxi::e#3 bitmap_line_ydxi::e#0 bitmap_line_ydxi::e#6 bitmap_line_ydxi::e#2 bitmap_line_ydxi::e#1 ]
-Uplifting [bitmap_line_ydxi] best 12552841 combination zp ZP_BYTE:110 [ bitmap_line_ydxi::e#3 bitmap_line_ydxi::e#0 bitmap_line_ydxi::e#6 bitmap_line_ydxi::e#2 bitmap_line_ydxi::e#1 ] 
+Uplifting [bitmap_line_ydxi] best 12552879 combination zp ZP_BYTE:110 [ bitmap_line_ydxi::e#3 bitmap_line_ydxi::e#0 bitmap_line_ydxi::e#6 bitmap_line_ydxi::e#2 bitmap_line_ydxi::e#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:116 [ bitmap_line_xdyd::e#3 bitmap_line_xdyd::e#0 bitmap_line_xdyd::e#6 bitmap_line_xdyd::e#2 bitmap_line_xdyd::e#1 ]
-Uplifting [bitmap_line_xdyd] best 12552841 combination zp ZP_BYTE:116 [ bitmap_line_xdyd::e#3 bitmap_line_xdyd::e#0 bitmap_line_xdyd::e#6 bitmap_line_xdyd::e#2 bitmap_line_xdyd::e#1 ] 
+Uplifting [bitmap_line_xdyd] best 12552879 combination zp ZP_BYTE:116 [ bitmap_line_xdyd::e#3 bitmap_line_xdyd::e#0 bitmap_line_xdyd::e#6 bitmap_line_xdyd::e#2 bitmap_line_xdyd::e#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:122 [ bitmap_line_ydxd::e#3 bitmap_line_ydxd::e#0 bitmap_line_ydxd::e#6 bitmap_line_ydxd::e#2 bitmap_line_ydxd::e#1 ]
-Uplifting [bitmap_line_ydxd] best 12552841 combination zp ZP_BYTE:122 [ bitmap_line_ydxd::e#3 bitmap_line_ydxd::e#0 bitmap_line_ydxd::e#6 bitmap_line_ydxd::e#2 bitmap_line_ydxd::e#1 ] 
+Uplifting [bitmap_line_ydxd] best 12552879 combination zp ZP_BYTE:122 [ bitmap_line_ydxd::e#3 bitmap_line_ydxd::e#0 bitmap_line_ydxd::e#6 bitmap_line_ydxd::e#2 bitmap_line_ydxd::e#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:11 [ gfx_mode::j#2 gfx_mode::j#1 ]
-Uplifting [gfx_mode] best 12551641 combination reg byte x [ gfx_mode::j#2 gfx_mode::j#1 ] 
+Uplifting [gfx_mode] best 12551679 combination reg byte x [ gfx_mode::j#2 gfx_mode::j#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:12 [ gfx_mode::i#2 gfx_mode::i#1 ]
-Uplifting [gfx_mode] best 12550441 combination reg byte x [ gfx_mode::i#2 gfx_mode::i#1 ] 
+Uplifting [gfx_mode] best 12550479 combination reg byte x [ gfx_mode::i#2 gfx_mode::i#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:31 [ form_cursor_count#21 form_cursor_count#1 form_cursor_count#16 form_cursor_count#15 form_cursor_count#5 ]
-Uplifting [] best 12550441 combination zp ZP_BYTE:31 [ form_cursor_count#21 form_cursor_count#1 form_cursor_count#16 form_cursor_count#15 form_cursor_count#5 ] 
+Uplifting [] best 12550479 combination zp ZP_BYTE:31 [ form_cursor_count#21 form_cursor_count#1 form_cursor_count#16 form_cursor_count#15 form_cursor_count#5 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:101 [ bitmap_line_xdyi::y#3 bitmap_line_xdyi::y#5 bitmap_line_xdyi::y#0 bitmap_line_xdyi::y#1 bitmap_line_xdyi::y#6 bitmap_line_xdyi::y#2 ]
-Uplifting [bitmap_line_xdyi] best 12550441 combination zp ZP_BYTE:101 [ bitmap_line_xdyi::y#3 bitmap_line_xdyi::y#5 bitmap_line_xdyi::y#0 bitmap_line_xdyi::y#1 bitmap_line_xdyi::y#6 bitmap_line_xdyi::y#2 ] 
+Uplifting [bitmap_line_xdyi] best 12550479 combination zp ZP_BYTE:101 [ bitmap_line_xdyi::y#3 bitmap_line_xdyi::y#5 bitmap_line_xdyi::y#0 bitmap_line_xdyi::y#1 bitmap_line_xdyi::y#6 bitmap_line_xdyi::y#2 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:115 [ bitmap_line_xdyd::y#3 bitmap_line_xdyd::y#5 bitmap_line_xdyd::y#0 bitmap_line_xdyd::y#1 bitmap_line_xdyd::y#6 bitmap_line_xdyd::y#2 ]
-Uplifting [bitmap_line_xdyd] best 12550441 combination zp ZP_BYTE:115 [ bitmap_line_xdyd::y#3 bitmap_line_xdyd::y#5 bitmap_line_xdyd::y#0 bitmap_line_xdyd::y#1 bitmap_line_xdyd::y#6 bitmap_line_xdyd::y#2 ] 
+Uplifting [bitmap_line_xdyd] best 12550479 combination zp ZP_BYTE:115 [ bitmap_line_xdyd::y#3 bitmap_line_xdyd::y#5 bitmap_line_xdyd::y#0 bitmap_line_xdyd::y#1 bitmap_line_xdyd::y#6 bitmap_line_xdyd::y#2 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:33 [ form_mode::preset_current#6 form_mode::preset_current#0 form_mode::preset_current#1 ]
-Uplifting [form_mode] best 12550441 combination zp ZP_BYTE:33 [ form_mode::preset_current#6 form_mode::preset_current#0 form_mode::preset_current#1 ] 
+Uplifting [form_mode] best 12550479 combination zp ZP_BYTE:33 [ form_mode::preset_current#6 form_mode::preset_current#0 form_mode::preset_current#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:238 [ gfx_mode::keyboard_event#0 ]
-Uplifting [gfx_mode] best 12549841 combination reg byte a [ gfx_mode::keyboard_event#0 ] 
+Uplifting [gfx_mode] best 12549879 combination reg byte a [ gfx_mode::keyboard_event#0 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:274 [ form_set_screen::$1 ]
-Uplifting [form_set_screen] best 12549241 combination reg byte a [ form_set_screen::$1 ] 
+Uplifting [form_set_screen] best 12549279 combination reg byte a [ form_set_screen::$1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:329 [ gfx_init_screen3::$3 ]
-Uplifting [gfx_init_screen3] best 12548641 combination reg byte a [ gfx_init_screen3::$3 ] 
+Uplifting [gfx_init_screen3] best 12548679 combination reg byte a [ gfx_init_screen3::$3 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:334 [ gfx_init_screen2::$4 ]
-Uplifting [gfx_init_screen2] best 12548041 combination reg byte a [ gfx_init_screen2::$4 ] 
+Uplifting [gfx_init_screen2] best 12548079 combination reg byte a [ gfx_init_screen2::$4 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:336 [ gfx_init_screen1::$1 ]
-Uplifting [gfx_init_screen1] best 12547441 combination reg byte a [ gfx_init_screen1::$1 ] 
+Uplifting [gfx_init_screen1] best 12547479 combination reg byte a [ gfx_init_screen1::$1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:340 [ gfx_init_screen0::$3 ]
-Uplifting [gfx_init_screen0] best 12546841 combination reg byte a [ gfx_init_screen0::$3 ] 
+Uplifting [gfx_init_screen0] best 12546879 combination reg byte a [ gfx_init_screen0::$3 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:143 [ gfx_init_screen3::cx#2 gfx_init_screen3::cx#1 ]
-Uplifting [gfx_init_screen3] best 12545841 combination reg byte x [ gfx_init_screen3::cx#2 gfx_init_screen3::cx#1 ] 
+Uplifting [gfx_init_screen3] best 12545879 combination reg byte x [ gfx_init_screen3::cx#2 gfx_init_screen3::cx#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:155 [ gfx_init_screen0::cx#2 gfx_init_screen0::cx#1 ]
-Uplifting [gfx_init_screen0] best 12544841 combination reg byte x [ gfx_init_screen0::cx#2 gfx_init_screen0::cx#1 ] 
+Uplifting [gfx_init_screen0] best 12544879 combination reg byte x [ gfx_init_screen0::cx#2 gfx_init_screen0::cx#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:71 [ gfx_init_plane_horisontal2::ax#2 gfx_init_plane_horisontal2::ax#1 ]
-Uplifting [gfx_init_plane_horisontal2] best 12543941 combination reg byte x [ gfx_init_plane_horisontal2::ax#2 gfx_init_plane_horisontal2::ax#1 ] 
+Uplifting [gfx_init_plane_horisontal2] best 12543979 combination reg byte x [ gfx_init_plane_horisontal2::ax#2 gfx_init_plane_horisontal2::ax#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:147 [ gfx_init_screen2::cx#2 gfx_init_screen2::cx#1 ]
-Uplifting [gfx_init_screen2] best 12542941 combination reg byte x [ gfx_init_screen2::cx#2 gfx_init_screen2::cx#1 ] 
+Uplifting [gfx_init_screen2] best 12542979 combination reg byte x [ gfx_init_screen2::cx#2 gfx_init_screen2::cx#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:5 [ gfx_mode::cy#4 gfx_mode::cy#1 ]
-Uplifting [gfx_mode] best 12542941 combination zp ZP_BYTE:5 [ gfx_mode::cy#4 gfx_mode::cy#1 ] 
+Uplifting [gfx_mode] best 12542979 combination zp ZP_BYTE:5 [ gfx_mode::cy#4 gfx_mode::cy#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:83 [ gfx_init_plane_charset8::cr#6 gfx_init_plane_charset8::cr#1 ]
-Uplifting [gfx_init_plane_charset8] best 12542941 combination zp ZP_BYTE:83 [ gfx_init_plane_charset8::cr#6 gfx_init_plane_charset8::cr#1 ] 
+Uplifting [gfx_init_plane_charset8] best 12542979 combination zp ZP_BYTE:83 [ gfx_init_plane_charset8::cr#6 gfx_init_plane_charset8::cr#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:331 [ gfx_init_screen2::col#0 ]
-Uplifting [gfx_init_screen2] best 12542841 combination reg byte y [ gfx_init_screen2::col#0 ] 
+Uplifting [gfx_init_screen2] best 12542879 combination reg byte y [ gfx_init_screen2::col#0 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:100 [ bitmap_line_xdyi::x#3 bitmap_line_xdyi::x#6 bitmap_line_xdyi::x#0 bitmap_line_xdyi::x#1 bitmap_line_xdyi::x#2 ]
-Uplifting [bitmap_line_xdyi] best 12542841 combination zp ZP_BYTE:100 [ bitmap_line_xdyi::x#3 bitmap_line_xdyi::x#6 bitmap_line_xdyi::x#0 bitmap_line_xdyi::x#1 bitmap_line_xdyi::x#2 ] 
+Uplifting [bitmap_line_xdyi] best 12542879 combination zp ZP_BYTE:100 [ bitmap_line_xdyi::x#3 bitmap_line_xdyi::x#6 bitmap_line_xdyi::x#0 bitmap_line_xdyi::x#1 bitmap_line_xdyi::x#2 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:109 [ bitmap_line_ydxi::y#3 bitmap_line_ydxi::y#6 bitmap_line_ydxi::y#1 bitmap_line_ydxi::y#0 bitmap_line_ydxi::y#2 ]
-Uplifting [bitmap_line_ydxi] best 12542841 combination zp ZP_BYTE:109 [ bitmap_line_ydxi::y#3 bitmap_line_ydxi::y#6 bitmap_line_ydxi::y#1 bitmap_line_ydxi::y#0 bitmap_line_ydxi::y#2 ] 
+Uplifting [bitmap_line_ydxi] best 12542879 combination zp ZP_BYTE:109 [ bitmap_line_ydxi::y#3 bitmap_line_ydxi::y#6 bitmap_line_ydxi::y#1 bitmap_line_ydxi::y#0 bitmap_line_ydxi::y#2 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:114 [ bitmap_line_xdyd::x#3 bitmap_line_xdyd::x#6 bitmap_line_xdyd::x#0 bitmap_line_xdyd::x#1 bitmap_line_xdyd::x#2 ]
-Uplifting [bitmap_line_xdyd] best 12542841 combination zp ZP_BYTE:114 [ bitmap_line_xdyd::x#3 bitmap_line_xdyd::x#6 bitmap_line_xdyd::x#0 bitmap_line_xdyd::x#1 bitmap_line_xdyd::x#2 ] 
+Uplifting [bitmap_line_xdyd] best 12542879 combination zp ZP_BYTE:114 [ bitmap_line_xdyd::x#3 bitmap_line_xdyd::x#6 bitmap_line_xdyd::x#0 bitmap_line_xdyd::x#1 bitmap_line_xdyd::x#2 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:121 [ bitmap_line_ydxd::y#2 bitmap_line_ydxd::y#7 bitmap_line_ydxd::y#0 bitmap_line_ydxd::y#1 bitmap_line_ydxd::y#3 ]
-Uplifting [bitmap_line_ydxd] best 12542841 combination zp ZP_BYTE:121 [ bitmap_line_ydxd::y#2 bitmap_line_ydxd::y#7 bitmap_line_ydxd::y#0 bitmap_line_ydxd::y#1 bitmap_line_ydxd::y#3 ] 
+Uplifting [bitmap_line_ydxd] best 12542879 combination zp ZP_BYTE:121 [ bitmap_line_ydxd::y#2 bitmap_line_ydxd::y#7 bitmap_line_ydxd::y#0 bitmap_line_ydxd::y#1 bitmap_line_ydxd::y#3 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:32 [ form_field_idx#28 form_field_idx#1 form_field_idx#18 form_field_idx#31 form_field_idx#6 form_field_idx#5 ]
-Uplifting [] best 12542841 combination zp ZP_BYTE:32 [ form_field_idx#28 form_field_idx#1 form_field_idx#18 form_field_idx#31 form_field_idx#6 form_field_idx#5 ] 
+Uplifting [] best 12542879 combination zp ZP_BYTE:32 [ form_field_idx#28 form_field_idx#1 form_field_idx#18 form_field_idx#31 form_field_idx#6 form_field_idx#5 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:327 [ gfx_init_screen3::$1 ]
-Uplifting [gfx_init_screen3] best 12542841 combination zp ZP_BYTE:327 [ gfx_init_screen3::$1 ] 
+Uplifting [gfx_init_screen3] best 12542879 combination zp ZP_BYTE:327 [ gfx_init_screen3::$1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:332 [ gfx_init_screen2::col2#0 ]
-Uplifting [gfx_init_screen2] best 12542841 combination zp ZP_BYTE:332 [ gfx_init_screen2::col2#0 ] 
+Uplifting [gfx_init_screen2] best 12542879 combination zp ZP_BYTE:332 [ gfx_init_screen2::col2#0 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:338 [ gfx_init_screen0::$1 ]
-Uplifting [gfx_init_screen0] best 12542841 combination zp ZP_BYTE:338 [ gfx_init_screen0::$1 ] 
+Uplifting [gfx_init_screen0] best 12542879 combination zp ZP_BYTE:338 [ gfx_init_screen0::$1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:2 [ gfx_mode::dtv_control#12 gfx_mode::dtv_control#6 gfx_mode::dtv_control#13 gfx_mode::dtv_control#5 gfx_mode::dtv_control#11 gfx_mode::dtv_control#4 gfx_mode::dtv_control#10 gfx_mode::dtv_control#3 gfx_mode::dtv_control#15 gfx_mode::dtv_control#14 gfx_mode::dtv_control#2 ]
-Uplifting [gfx_mode] best 12542822 combination reg byte x [ gfx_mode::dtv_control#12 gfx_mode::dtv_control#6 gfx_mode::dtv_control#13 gfx_mode::dtv_control#5 gfx_mode::dtv_control#11 gfx_mode::dtv_control#4 gfx_mode::dtv_control#10 gfx_mode::dtv_control#3 gfx_mode::dtv_control#15 gfx_mode::dtv_control#14 gfx_mode::dtv_control#2 ] 
+Uplifting [gfx_mode] best 12542860 combination reg byte x [ gfx_mode::dtv_control#12 gfx_mode::dtv_control#6 gfx_mode::dtv_control#13 gfx_mode::dtv_control#5 gfx_mode::dtv_control#11 gfx_mode::dtv_control#4 gfx_mode::dtv_control#10 gfx_mode::dtv_control#3 gfx_mode::dtv_control#15 gfx_mode::dtv_control#14 gfx_mode::dtv_control#2 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:265 [ form_field_ptr::x#0 ]
-Uplifting [form_field_ptr] best 12542822 combination zp ZP_BYTE:265 [ form_field_ptr::x#0 ] 
+Uplifting [form_field_ptr] best 12542860 combination zp ZP_BYTE:265 [ form_field_ptr::x#0 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:68 [ gfx_init_plane_horisontal2::ay#4 gfx_init_plane_horisontal2::ay#1 ]
-Uplifting [gfx_init_plane_horisontal2] best 12542822 combination zp ZP_BYTE:68 [ gfx_init_plane_horisontal2::ay#4 gfx_init_plane_horisontal2::ay#1 ] 
+Uplifting [gfx_init_plane_horisontal2] best 12542860 combination zp ZP_BYTE:68 [ gfx_init_plane_horisontal2::ay#4 gfx_init_plane_horisontal2::ay#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:150 [ gfx_init_screen1::cy#4 gfx_init_screen1::cy#1 ]
-Uplifting [gfx_init_screen1] best 12542822 combination zp ZP_BYTE:150 [ gfx_init_screen1::cy#4 gfx_init_screen1::cy#1 ] 
+Uplifting [gfx_init_screen1] best 12542860 combination zp ZP_BYTE:150 [ gfx_init_screen1::cy#4 gfx_init_screen1::cy#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:142 [ gfx_init_screen3::cy#4 gfx_init_screen3::cy#1 ]
-Uplifting [gfx_init_screen3] best 12542822 combination zp ZP_BYTE:142 [ gfx_init_screen3::cy#4 gfx_init_screen3::cy#1 ] 
+Uplifting [gfx_init_screen3] best 12542860 combination zp ZP_BYTE:142 [ gfx_init_screen3::cy#4 gfx_init_screen3::cy#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:154 [ gfx_init_screen0::cy#4 gfx_init_screen0::cy#1 ]
-Uplifting [gfx_init_screen0] best 12542822 combination zp ZP_BYTE:154 [ gfx_init_screen0::cy#4 gfx_init_screen0::cy#1 ] 
+Uplifting [gfx_init_screen0] best 12542860 combination zp ZP_BYTE:154 [ gfx_init_screen0::cy#4 gfx_init_screen0::cy#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:76 [ gfx_init_plane_horisontal::ay#4 gfx_init_plane_horisontal::ay#1 ]
-Uplifting [gfx_init_plane_horisontal] best 12542822 combination zp ZP_BYTE:76 [ gfx_init_plane_horisontal::ay#4 gfx_init_plane_horisontal::ay#1 ] 
+Uplifting [gfx_init_plane_horisontal] best 12542860 combination zp ZP_BYTE:76 [ gfx_init_plane_horisontal::ay#4 gfx_init_plane_horisontal::ay#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:146 [ gfx_init_screen2::cy#4 gfx_init_screen2::cy#1 ]
-Uplifting [gfx_init_screen2] best 12542822 combination zp ZP_BYTE:146 [ gfx_init_screen2::cy#4 gfx_init_screen2::cy#1 ] 
+Uplifting [gfx_init_screen2] best 12542860 combination zp ZP_BYTE:146 [ gfx_init_screen2::cy#4 gfx_init_screen2::cy#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:96 [ gfx_init_vic_bitmap::l#2 gfx_init_vic_bitmap::l#1 ]
-Uplifting [gfx_init_vic_bitmap] best 12542822 combination zp ZP_BYTE:96 [ gfx_init_vic_bitmap::l#2 gfx_init_vic_bitmap::l#1 ] 
+Uplifting [gfx_init_vic_bitmap] best 12542860 combination zp ZP_BYTE:96 [ gfx_init_vic_bitmap::l#2 gfx_init_vic_bitmap::l#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:90 [ gfx_init_plane_8bppchunky::y#6 gfx_init_plane_8bppchunky::y#1 ]
-Uplifting [gfx_init_plane_8bppchunky] best 12542822 combination zp ZP_BYTE:90 [ gfx_init_plane_8bppchunky::y#6 gfx_init_plane_8bppchunky::y#1 ] 
+Uplifting [gfx_init_plane_8bppchunky] best 12542860 combination zp ZP_BYTE:90 [ gfx_init_plane_8bppchunky::y#6 gfx_init_plane_8bppchunky::y#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:129 [ bitmap_init::y#2 bitmap_init::y#1 ]
-Uplifting [bitmap_init] best 12542642 combination reg byte x [ bitmap_init::y#2 bitmap_init::y#1 ] 
+Uplifting [bitmap_init] best 12542680 combination reg byte x [ bitmap_init::y#2 bitmap_init::y#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:321 [ bitmap_init::$0 ]
-Uplifting [bitmap_init] best 12542602 combination reg byte a [ bitmap_init::$0 ] 
+Uplifting [bitmap_init] best 12542640 combination reg byte a [ bitmap_init::$0 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:323 [ bitmap_init::$7 ]
-Uplifting [bitmap_init] best 12542542 combination reg byte a [ bitmap_init::$7 ] 
+Uplifting [bitmap_init] best 12542580 combination reg byte a [ bitmap_init::$7 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:324 [ bitmap_init::$8 ]
-Uplifting [bitmap_init] best 12542482 combination reg byte a [ bitmap_init::$8 ] 
+Uplifting [bitmap_init] best 12542520 combination reg byte a [ bitmap_init::$8 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:325 [ bitmap_init::$9 ]
-Uplifting [bitmap_init] best 12542422 combination reg byte a [ bitmap_init::$9 ] 
+Uplifting [bitmap_init] best 12542460 combination reg byte a [ bitmap_init::$9 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:63 [ gfx_init_plane_fill::by#4 gfx_init_plane_fill::by#1 ]
-Uplifting [gfx_init_plane_fill] best 12542422 combination zp ZP_BYTE:63 [ gfx_init_plane_fill::by#4 gfx_init_plane_fill::by#1 ] 
+Uplifting [gfx_init_plane_fill] best 12542460 combination zp ZP_BYTE:63 [ gfx_init_plane_fill::by#4 gfx_init_plane_fill::by#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:72 [ gfx_init_plane_vertical::by#4 gfx_init_plane_vertical::by#1 ]
-Uplifting [gfx_init_plane_vertical] best 12542422 combination zp ZP_BYTE:72 [ gfx_init_plane_vertical::by#4 gfx_init_plane_vertical::by#1 ] 
+Uplifting [gfx_init_plane_vertical] best 12542460 combination zp ZP_BYTE:72 [ gfx_init_plane_vertical::by#4 gfx_init_plane_vertical::by#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:123 [ bitmap_clear::y#4 bitmap_clear::y#1 ]
-Uplifting [bitmap_clear] best 12542422 combination zp ZP_BYTE:123 [ bitmap_clear::y#4 bitmap_clear::y#1 ] 
+Uplifting [bitmap_clear] best 12542460 combination zp ZP_BYTE:123 [ bitmap_clear::y#4 bitmap_clear::y#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:138 [ gfx_init_screen4::cy#4 gfx_init_screen4::cy#1 ]
-Uplifting [gfx_init_screen4] best 12542422 combination zp ZP_BYTE:138 [ gfx_init_screen4::cy#4 gfx_init_screen4::cy#1 ] 
+Uplifting [gfx_init_screen4] best 12542460 combination zp ZP_BYTE:138 [ gfx_init_screen4::cy#4 gfx_init_screen4::cy#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:132 [ gfx_init_charset::c#4 gfx_init_charset::c#1 ]
-Uplifting [gfx_init_charset] best 12542422 combination zp ZP_BYTE:132 [ gfx_init_charset::c#4 gfx_init_charset::c#1 ] 
+Uplifting [gfx_init_charset] best 12542460 combination zp ZP_BYTE:132 [ gfx_init_charset::c#4 gfx_init_charset::c#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:98 [ bitmap_line_xdyi::xd#5 bitmap_line_xdyi::xd#0 bitmap_line_xdyi::xd#1 ]
-Uplifting [bitmap_line_xdyi] best 12542422 combination zp ZP_BYTE:98 [ bitmap_line_xdyi::xd#5 bitmap_line_xdyi::xd#0 bitmap_line_xdyi::xd#1 ] 
+Uplifting [bitmap_line_xdyi] best 12542460 combination zp ZP_BYTE:98 [ bitmap_line_xdyi::xd#5 bitmap_line_xdyi::xd#0 bitmap_line_xdyi::xd#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:106 [ bitmap_line_ydxi::yd#5 bitmap_line_ydxi::yd#1 bitmap_line_ydxi::yd#0 ]
-Uplifting [bitmap_line_ydxi] best 12542422 combination zp ZP_BYTE:106 [ bitmap_line_ydxi::yd#5 bitmap_line_ydxi::yd#1 bitmap_line_ydxi::yd#0 ] 
+Uplifting [bitmap_line_ydxi] best 12542460 combination zp ZP_BYTE:106 [ bitmap_line_ydxi::yd#5 bitmap_line_ydxi::yd#1 bitmap_line_ydxi::yd#0 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:112 [ bitmap_line_xdyd::xd#5 bitmap_line_xdyd::xd#0 bitmap_line_xdyd::xd#1 ]
-Uplifting [bitmap_line_xdyd] best 12542422 combination zp ZP_BYTE:112 [ bitmap_line_xdyd::xd#5 bitmap_line_xdyd::xd#0 bitmap_line_xdyd::xd#1 ] 
+Uplifting [bitmap_line_xdyd] best 12542460 combination zp ZP_BYTE:112 [ bitmap_line_xdyd::xd#5 bitmap_line_xdyd::xd#0 bitmap_line_xdyd::xd#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:118 [ bitmap_line_ydxd::yd#5 bitmap_line_ydxd::yd#0 bitmap_line_ydxd::yd#1 ]
-Uplifting [bitmap_line_ydxd] best 12542422 combination zp ZP_BYTE:118 [ bitmap_line_ydxd::yd#5 bitmap_line_ydxd::yd#0 bitmap_line_ydxd::yd#1 ] 
+Uplifting [bitmap_line_ydxd] best 12542460 combination zp ZP_BYTE:118 [ bitmap_line_ydxd::yd#5 bitmap_line_ydxd::yd#0 bitmap_line_ydxd::yd#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:80 [ gfx_init_plane_charset8::ch#8 gfx_init_plane_charset8::ch#1 ]
-Uplifting [gfx_init_plane_charset8] best 12542422 combination zp ZP_BYTE:80 [ gfx_init_plane_charset8::ch#8 gfx_init_plane_charset8::ch#1 ] 
+Uplifting [gfx_init_plane_charset8] best 12542460 combination zp ZP_BYTE:80 [ gfx_init_plane_charset8::ch#8 gfx_init_plane_charset8::ch#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:97 [ bitmap_line_xdyi::yd#2 bitmap_line_xdyi::yd#0 bitmap_line_xdyi::yd#1 ]
-Uplifting [bitmap_line_xdyi] best 12542422 combination zp ZP_BYTE:97 [ bitmap_line_xdyi::yd#2 bitmap_line_xdyi::yd#0 bitmap_line_xdyi::yd#1 ] 
+Uplifting [bitmap_line_xdyi] best 12542460 combination zp ZP_BYTE:97 [ bitmap_line_xdyi::yd#2 bitmap_line_xdyi::yd#0 bitmap_line_xdyi::yd#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:105 [ bitmap_line_ydxi::xd#2 bitmap_line_ydxi::xd#1 bitmap_line_ydxi::xd#0 ]
-Uplifting [bitmap_line_ydxi] best 12542422 combination zp ZP_BYTE:105 [ bitmap_line_ydxi::xd#2 bitmap_line_ydxi::xd#1 bitmap_line_ydxi::xd#0 ] 
+Uplifting [bitmap_line_ydxi] best 12542460 combination zp ZP_BYTE:105 [ bitmap_line_ydxi::xd#2 bitmap_line_ydxi::xd#1 bitmap_line_ydxi::xd#0 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:111 [ bitmap_line_xdyd::yd#2 bitmap_line_xdyd::yd#0 bitmap_line_xdyd::yd#1 ]
-Uplifting [bitmap_line_xdyd] best 12542422 combination zp ZP_BYTE:111 [ bitmap_line_xdyd::yd#2 bitmap_line_xdyd::yd#0 bitmap_line_xdyd::yd#1 ] 
+Uplifting [bitmap_line_xdyd] best 12542460 combination zp ZP_BYTE:111 [ bitmap_line_xdyd::yd#2 bitmap_line_xdyd::yd#0 bitmap_line_xdyd::yd#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:117 [ bitmap_line_ydxd::xd#2 bitmap_line_ydxd::xd#0 bitmap_line_ydxd::xd#1 ]
-Uplifting [bitmap_line_ydxd] best 12542422 combination zp ZP_BYTE:117 [ bitmap_line_ydxd::xd#2 bitmap_line_ydxd::xd#0 bitmap_line_ydxd::xd#1 ] 
+Uplifting [bitmap_line_ydxd] best 12542460 combination zp ZP_BYTE:117 [ bitmap_line_ydxd::xd#2 bitmap_line_ydxd::xd#0 bitmap_line_ydxd::xd#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:3 [ gfx_mode::vic_control#4 gfx_mode::vic_control#2 gfx_mode::vic_control#5 ]
-Uplifting [gfx_mode] best 12542411 combination reg byte x [ gfx_mode::vic_control#4 gfx_mode::vic_control#2 gfx_mode::vic_control#5 ] 
+Uplifting [gfx_mode] best 12542449 combination reg byte x [ gfx_mode::vic_control#4 gfx_mode::vic_control#2 gfx_mode::vic_control#5 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:99 [ bitmap_line_xdyi::x1#6 bitmap_line_xdyi::x1#0 bitmap_line_xdyi::x1#1 ]
-Uplifting [bitmap_line_xdyi] best 12542411 combination zp ZP_BYTE:99 [ bitmap_line_xdyi::x1#6 bitmap_line_xdyi::x1#0 bitmap_line_xdyi::x1#1 ] 
+Uplifting [bitmap_line_xdyi] best 12542449 combination zp ZP_BYTE:99 [ bitmap_line_xdyi::x1#6 bitmap_line_xdyi::x1#0 bitmap_line_xdyi::x1#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:107 [ bitmap_line_ydxi::y1#6 bitmap_line_ydxi::y1#1 bitmap_line_ydxi::y1#0 ]
-Uplifting [bitmap_line_ydxi] best 12542411 combination zp ZP_BYTE:107 [ bitmap_line_ydxi::y1#6 bitmap_line_ydxi::y1#1 bitmap_line_ydxi::y1#0 ] 
+Uplifting [bitmap_line_ydxi] best 12542449 combination zp ZP_BYTE:107 [ bitmap_line_ydxi::y1#6 bitmap_line_ydxi::y1#1 bitmap_line_ydxi::y1#0 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:113 [ bitmap_line_xdyd::x1#6 bitmap_line_xdyd::x1#0 bitmap_line_xdyd::x1#1 ]
-Uplifting [bitmap_line_xdyd] best 12542411 combination zp ZP_BYTE:113 [ bitmap_line_xdyd::x1#6 bitmap_line_xdyd::x1#0 bitmap_line_xdyd::x1#1 ] 
+Uplifting [bitmap_line_xdyd] best 12542449 combination zp ZP_BYTE:113 [ bitmap_line_xdyd::x1#6 bitmap_line_xdyd::x1#0 bitmap_line_xdyd::x1#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:119 [ bitmap_line_ydxd::y1#6 bitmap_line_ydxd::y1#0 bitmap_line_ydxd::y1#1 ]
-Uplifting [bitmap_line_ydxd] best 12542411 combination zp ZP_BYTE:119 [ bitmap_line_ydxd::y1#6 bitmap_line_ydxd::y1#0 bitmap_line_ydxd::y1#1 ] 
+Uplifting [bitmap_line_ydxd] best 12542449 combination zp ZP_BYTE:119 [ bitmap_line_ydxd::y1#6 bitmap_line_ydxd::y1#0 bitmap_line_ydxd::y1#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:62 [ gfx_init_plane_fill::fill#6 ]
-Uplifting [gfx_init_plane_fill] best 12542411 combination zp ZP_BYTE:62 [ gfx_init_plane_fill::fill#6 ] 
+Uplifting [gfx_init_plane_fill] best 12542449 combination zp ZP_BYTE:62 [ gfx_init_plane_fill::fill#6 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:322 [ bitmap_init::$10 ]
-Uplifting [bitmap_init] best 12542411 combination zp ZP_BYTE:322 [ bitmap_init::$10 ] 
+Uplifting [bitmap_init] best 12542449 combination zp ZP_BYTE:322 [ bitmap_init::$10 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:158 [ gfx_mode::$20 ]
-Uplifting [gfx_mode] best 12542405 combination reg byte a [ gfx_mode::$20 ] 
+Uplifting [gfx_mode] best 12542443 combination reg byte a [ gfx_mode::$20 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:174 [ gfx_mode::$25 ]
-Uplifting [gfx_mode] best 12542399 combination reg byte a [ gfx_mode::$25 ] 
+Uplifting [gfx_mode] best 12542437 combination reg byte a [ gfx_mode::$25 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:175 [ gfx_mode::$27 ]
-Uplifting [gfx_mode] best 12542393 combination reg byte a [ gfx_mode::$27 ] 
+Uplifting [gfx_mode] best 12542431 combination reg byte a [ gfx_mode::$27 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:178 [ gfx_mode::$29 ]
-Uplifting [gfx_mode] best 12542387 combination reg byte a [ gfx_mode::$29 ] 
+Uplifting [gfx_mode] best 12542425 combination reg byte a [ gfx_mode::$29 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:179 [ gfx_mode::$30 ]
-Uplifting [gfx_mode] best 12542381 combination reg byte a [ gfx_mode::$30 ] 
+Uplifting [gfx_mode] best 12542419 combination reg byte a [ gfx_mode::$30 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:180 [ gfx_mode::$31 ]
-Uplifting [gfx_mode] best 12542375 combination reg byte a [ gfx_mode::$31 ] 
+Uplifting [gfx_mode] best 12542413 combination reg byte a [ gfx_mode::$31 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:181 [ gfx_mode::$32 ]
-Uplifting [gfx_mode] best 12542369 combination reg byte a [ gfx_mode::$32 ] 
+Uplifting [gfx_mode] best 12542407 combination reg byte a [ gfx_mode::$32 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:182 [ gfx_mode::$33 ]
-Uplifting [gfx_mode] best 12542363 combination reg byte a [ gfx_mode::$33 ] 
+Uplifting [gfx_mode] best 12542401 combination reg byte a [ gfx_mode::$33 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:183 [ gfx_mode::$34 ]
-Uplifting [gfx_mode] best 12542357 combination reg byte a [ gfx_mode::$34 ] 
+Uplifting [gfx_mode] best 12542395 combination reg byte a [ gfx_mode::$34 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:199 [ gfx_mode::$39 ]
-Uplifting [gfx_mode] best 12542351 combination reg byte a [ gfx_mode::$39 ] 
+Uplifting [gfx_mode] best 12542389 combination reg byte a [ gfx_mode::$39 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:200 [ gfx_mode::$41 ]
-Uplifting [gfx_mode] best 12542345 combination reg byte a [ gfx_mode::$41 ] 
+Uplifting [gfx_mode] best 12542383 combination reg byte a [ gfx_mode::$41 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:203 [ gfx_mode::$43 ]
-Uplifting [gfx_mode] best 12542339 combination reg byte a [ gfx_mode::$43 ] 
+Uplifting [gfx_mode] best 12542377 combination reg byte a [ gfx_mode::$43 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:204 [ gfx_mode::$44 ]
-Uplifting [gfx_mode] best 12542333 combination reg byte a [ gfx_mode::$44 ] 
+Uplifting [gfx_mode] best 12542371 combination reg byte a [ gfx_mode::$44 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:205 [ gfx_mode::$45 ]
-Uplifting [gfx_mode] best 12542327 combination reg byte a [ gfx_mode::$45 ] 
+Uplifting [gfx_mode] best 12542365 combination reg byte a [ gfx_mode::$45 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:206 [ gfx_mode::$46 ]
-Uplifting [gfx_mode] best 12542321 combination reg byte a [ gfx_mode::$46 ] 
+Uplifting [gfx_mode] best 12542359 combination reg byte a [ gfx_mode::$46 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:207 [ gfx_mode::$47 ]
-Uplifting [gfx_mode] best 12542315 combination reg byte a [ gfx_mode::$47 ] 
+Uplifting [gfx_mode] best 12542353 combination reg byte a [ gfx_mode::$47 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:224 [ gfx_mode::$60 ]
-Uplifting [gfx_mode] best 12542309 combination reg byte a [ gfx_mode::$60 ] 
+Uplifting [gfx_mode] best 12542347 combination reg byte a [ gfx_mode::$60 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:225 [ gfx_mode::$61 ]
-Uplifting [gfx_mode] best 12542303 combination reg byte a [ gfx_mode::$61 ] 
+Uplifting [gfx_mode] best 12542341 combination reg byte a [ gfx_mode::$61 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:226 [ gfx_mode::$62 ]
-Uplifting [gfx_mode] best 12542297 combination reg byte a [ gfx_mode::$62 ] 
+Uplifting [gfx_mode] best 12542335 combination reg byte a [ gfx_mode::$62 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:229 [ gfx_mode::$64 ]
-Uplifting [gfx_mode] best 12542291 combination reg byte a [ gfx_mode::$64 ] 
+Uplifting [gfx_mode] best 12542329 combination reg byte a [ gfx_mode::$64 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:230 [ gfx_mode::$65 ]
-Uplifting [gfx_mode] best 12542285 combination reg byte a [ gfx_mode::$65 ] 
+Uplifting [gfx_mode] best 12542323 combination reg byte a [ gfx_mode::$65 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:231 [ gfx_mode::$66 ]
-Uplifting [gfx_mode] best 12542279 combination reg byte a [ gfx_mode::$66 ] 
+Uplifting [gfx_mode] best 12542317 combination reg byte a [ gfx_mode::$66 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:232 [ gfx_mode::$67 ]
-Uplifting [gfx_mode] best 12542273 combination reg byte a [ gfx_mode::$67 ] 
+Uplifting [gfx_mode] best 12542311 combination reg byte a [ gfx_mode::$67 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:233 [ gfx_mode::$68 ]
-Uplifting [gfx_mode] best 12542267 combination reg byte a [ gfx_mode::$68 ] 
+Uplifting [gfx_mode] best 12542305 combination reg byte a [ gfx_mode::$68 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:234 [ gfx_mode::$69 ]
-Uplifting [gfx_mode] best 12542261 combination reg byte a [ gfx_mode::$69 ] 
+Uplifting [gfx_mode] best 12542299 combination reg byte a [ gfx_mode::$69 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:235 [ gfx_mode::$70 ]
-Uplifting [gfx_mode] best 12542255 combination reg byte a [ gfx_mode::$70 ] 
+Uplifting [gfx_mode] best 12542293 combination reg byte a [ gfx_mode::$70 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:236 [ gfx_mode::$71 ]
-Uplifting [gfx_mode] best 12542249 combination reg byte a [ gfx_mode::$71 ] 
+Uplifting [gfx_mode] best 12542287 combination reg byte a [ gfx_mode::$71 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:243 [ keyboard_event_scan::$0 ]
-Uplifting [keyboard_event_scan] best 12542243 combination reg byte a [ keyboard_event_scan::$0 ] 
+Uplifting [keyboard_event_scan] best 12542281 combination reg byte a [ keyboard_event_scan::$0 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:245 [ keyboard_event_scan::$3 ]
-Uplifting [keyboard_event_scan] best 12542237 combination reg byte a [ keyboard_event_scan::$3 ] 
+Uplifting [keyboard_event_scan] best 12542275 combination reg byte a [ keyboard_event_scan::$3 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:246 [ keyboard_event_pressed::return#2 ]
-Uplifting [keyboard_event_pressed] best 12542231 combination reg byte a [ keyboard_event_pressed::return#2 ] 
+Uplifting [keyboard_event_pressed] best 12542269 combination reg byte a [ keyboard_event_pressed::return#2 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:247 [ keyboard_event_scan::$6 ]
-Uplifting [keyboard_event_scan] best 12542225 combination reg byte a [ keyboard_event_scan::$6 ] 
+Uplifting [keyboard_event_scan] best 12542263 combination reg byte a [ keyboard_event_scan::$6 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:248 [ keyboard_event_pressed::return#3 ]
-Uplifting [keyboard_event_pressed] best 12542219 combination reg byte a [ keyboard_event_pressed::return#3 ] 
+Uplifting [keyboard_event_pressed] best 12542257 combination reg byte a [ keyboard_event_pressed::return#3 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:249 [ keyboard_event_scan::$9 ]
-Uplifting [keyboard_event_scan] best 12542213 combination reg byte a [ keyboard_event_scan::$9 ] 
+Uplifting [keyboard_event_scan] best 12542251 combination reg byte a [ keyboard_event_scan::$9 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:254 [ keyboard_event_pressed::$0 ]
-Uplifting [keyboard_event_pressed] best 12542209 combination reg byte a [ keyboard_event_pressed::$0 ] 
+Uplifting [keyboard_event_pressed] best 12542247 combination reg byte a [ keyboard_event_pressed::$0 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:256 [ keyboard_event_pressed::$1 ]
-Uplifting [keyboard_event_pressed] best 12542205 combination reg byte a [ keyboard_event_pressed::$1 ] 
+Uplifting [keyboard_event_pressed] best 12542243 combination reg byte a [ keyboard_event_pressed::$1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:266 [ form_control::$13 ]
-Uplifting [form_control] best 12542199 combination reg byte a [ form_control::$13 ] 
+Uplifting [form_control] best 12542237 combination reg byte a [ form_control::$13 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:267 [ keyboard_event_get::return#4 ]
-Uplifting [keyboard_event_get] best 12542193 combination reg byte a [ keyboard_event_get::return#4 ] 
+Uplifting [keyboard_event_get] best 12542231 combination reg byte a [ keyboard_event_get::return#4 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:269 [ form_control::$15 ]
-Uplifting [form_control] best 12542187 combination reg byte a [ form_control::$15 ] 
+Uplifting [form_control] best 12542225 combination reg byte a [ form_control::$15 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:270 [ form_control::$16 ]
-Uplifting [form_control] best 12542183 combination reg byte a [ form_control::$16 ] 
+Uplifting [form_control] best 12542221 combination reg byte a [ form_control::$16 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:271 [ form_control::$24 ]
-Uplifting [form_control] best 12542179 combination reg byte a [ form_control::$24 ] 
+Uplifting [form_control] best 12542217 combination reg byte a [ form_control::$24 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:272 [ form_control::$14 ]
-Uplifting [form_control] best 12542173 combination reg byte a [ form_control::$14 ] 
+Uplifting [form_control] best 12542211 combination reg byte a [ form_control::$14 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:315 [ bitmap_plot::$1 ]
-Uplifting [bitmap_plot] best 12542167 combination reg byte a [ bitmap_plot::$1 ] 
+Uplifting [bitmap_plot] best 12542205 combination reg byte a [ bitmap_plot::$1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:268 [ form_control::key_event#0 ]
-Uplifting [form_control] best 12542155 combination reg byte a [ form_control::key_event#0 ] 
+Uplifting [form_control] best 12542193 combination reg byte a [ form_control::key_event#0 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:4 [ gfx_mode::vic_control2#2 ]
-Uplifting [gfx_mode] best 12542146 combination reg byte a [ gfx_mode::vic_control2#2 ] 
+Uplifting [gfx_mode] best 12542184 combination reg byte a [ gfx_mode::vic_control2#2 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:255 [ keyboard_event_pressed::row_bits#0 ]
-Uplifting [keyboard_event_pressed] best 12542146 combination zp ZP_BYTE:255 [ keyboard_event_pressed::row_bits#0 ] 
+Uplifting [keyboard_event_pressed] best 12542184 combination zp ZP_BYTE:255 [ keyboard_event_pressed::row_bits#0 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:301 [ bitmap_line::y1#0 ]
-Uplifting [bitmap_line] best 12542146 combination zp ZP_BYTE:301 [ bitmap_line::y1#0 ] 
+Uplifting [bitmap_line] best 12542184 combination zp ZP_BYTE:301 [ bitmap_line::y1#0 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:300 [ bitmap_line::y0#0 ]
-Uplifting [bitmap_line] best 12542146 combination zp ZP_BYTE:300 [ bitmap_line::y0#0 ] 
+Uplifting [bitmap_line] best 12542184 combination zp ZP_BYTE:300 [ bitmap_line::y0#0 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:257 [ keyboard_event_pressed::return#10 ]
-Uplifting [keyboard_event_pressed] best 12542131 combination reg byte a [ keyboard_event_pressed::return#10 ] 
+Uplifting [keyboard_event_pressed] best 12542169 combination reg byte a [ keyboard_event_pressed::return#10 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:19 [ keyboard_event_pressed::keycode#4 ]
-Uplifting [keyboard_event_pressed] best 12542131 combination zp ZP_BYTE:19 [ keyboard_event_pressed::keycode#4 ] 
+Uplifting [keyboard_event_pressed] best 12542169 combination zp ZP_BYTE:19 [ keyboard_event_pressed::keycode#4 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:298 [ bitmap_line::x0#0 ]
-Uplifting [bitmap_line] best 12542131 combination zp ZP_BYTE:298 [ bitmap_line::x0#0 ] 
+Uplifting [bitmap_line] best 12542169 combination zp ZP_BYTE:298 [ bitmap_line::x0#0 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:303 [ bitmap_line::yd#2 ]
-Uplifting [bitmap_line] best 12542121 combination reg byte y [ bitmap_line::yd#2 ] 
+Uplifting [bitmap_line] best 12542159 combination reg byte y [ bitmap_line::yd#2 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:304 [ bitmap_line::yd#1 ]
-Uplifting [bitmap_line] best 12542111 combination reg byte y [ bitmap_line::yd#1 ] 
+Uplifting [bitmap_line] best 12542149 combination reg byte y [ bitmap_line::yd#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:306 [ bitmap_line::yd#10 ]
-Uplifting [bitmap_line] best 12542101 combination reg byte y [ bitmap_line::yd#10 ] 
+Uplifting [bitmap_line] best 12542139 combination reg byte y [ bitmap_line::yd#10 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:307 [ bitmap_line::yd#11 ]
-Uplifting [bitmap_line] best 12542091 combination reg byte y [ bitmap_line::yd#11 ] 
+Uplifting [bitmap_line] best 12542129 combination reg byte y [ bitmap_line::yd#11 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:159 [ gfx_mode::plane_a_offs#0 ]
-Uplifting [gfx_mode] best 12542089 combination reg byte x [ gfx_mode::plane_a_offs#0 ] 
+Uplifting [gfx_mode] best 12542127 combination reg byte x [ gfx_mode::plane_a_offs#0 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:184 [ gfx_mode::plane_b_offs#0 ]
-Uplifting [gfx_mode] best 12542087 combination reg byte x [ gfx_mode::plane_b_offs#0 ] 
+Uplifting [gfx_mode] best 12542125 combination reg byte x [ gfx_mode::plane_b_offs#0 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:302 [ bitmap_line::xd#2 ]
-Uplifting [bitmap_line] best 12542087 combination zp ZP_BYTE:302 [ bitmap_line::xd#2 ] 
+Uplifting [bitmap_line] best 12542125 combination zp ZP_BYTE:302 [ bitmap_line::xd#2 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:305 [ bitmap_line::xd#1 ]
-Uplifting [bitmap_line] best 12542087 combination zp ZP_BYTE:305 [ bitmap_line::xd#1 ] 
+Uplifting [bitmap_line] best 12542125 combination zp ZP_BYTE:305 [ bitmap_line::xd#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:216 [ gfx_mode::$56 ]
-Uplifting [gfx_mode] best 12542087 combination zp ZP_BYTE:216 [ gfx_mode::$56 ] 
+Uplifting [gfx_mode] best 12542125 combination zp ZP_BYTE:216 [ gfx_mode::$56 ] 
 Coalescing zero page register with common assignment [ zp ZP_WORD:6 [ gfx_mode::vic_colors#2 gfx_mode::vic_colors#3 gfx_mode::vic_colors#1 gfx_mode::vic_colors#0 ] ] with [ zp ZP_WORD:227 [ get_vic_screen::return#11 ] ] - score: 1
 Coalescing zero page register with common assignment [ zp ZP_WORD:21 [ get_vic_screen::return#5 ] ] with [ zp ZP_WORD:208 [ get_vic_screen::return#10 ] ] - score: 1
 Coalescing zero page register with common assignment [ zp ZP_WORD:23 [ get_vic_charset::return#2 ] ] with [ zp ZP_WORD:218 [ get_vic_charset::return#4 ] ] - score: 1

src/test/ref/examples/scrolllogo/scrolllogo.log

@@ -5590,15 +5590,17 @@ sin16s: {
     sta x5+1
   //SEG328 [170] (word) sin16s::x5_128#0 ← (word) sin16s::x5#0 >> (byte) 4 -- vwuz1=vwuz2_ror_4 
     lda x5+1
+    lsr
     sta x5_128+1
     lda x5
+    ror
     sta x5_128
-    ldy #4
-  !:
     lsr x5_128+1
     ror x5_128
-    dey
-    bne !-
+    lsr x5_128+1
+    ror x5_128
+    lsr x5_128+1
+    ror x5_128
   //SEG329 [171] (word) sin16s::usinx#1 ← (word) sin16s::usinx#0 + (word) sin16s::x5_128#0 -- vwuz1=vwuz2_plus_vwuz3 
     lda usinx
     clc
@@ -6083,7 +6085,7 @@ Statement [165] (word) mulu16_sel::v1#4 ← (word) sin16s::x4#0 [ sin16s::isUppe
 Statement [166] (word) mulu16_sel::v2#4 ← (word) sin16s::x1#0 [ sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::v1#4 mulu16_sel::v2#4 ] ( main:3::sin16s_gen2:21::sin16s:103 [ sin16s_gen2::step#0 sin16s_gen2::x#2 sin16s_gen2::sintab#2 sin16s_gen2::i#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::v1#4 mulu16_sel::v2#4 ] ) always clobbers reg byte a 
 Statement [168] (word) mulu16_sel::return#11 ← (word) mulu16_sel::return#12 [ sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::return#11 ] ( main:3::sin16s_gen2:21::sin16s:103 [ sin16s_gen2::step#0 sin16s_gen2::x#2 sin16s_gen2::sintab#2 sin16s_gen2::i#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::return#11 ] ) always clobbers reg byte a 
 Statement [169] (word) sin16s::x5#0 ← (word) mulu16_sel::return#11 [ sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5#0 ] ( main:3::sin16s_gen2:21::sin16s:103 [ sin16s_gen2::step#0 sin16s_gen2::x#2 sin16s_gen2::sintab#2 sin16s_gen2::i#2 sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5#0 ] ) always clobbers reg byte a 
-Statement [170] (word) sin16s::x5_128#0 ← (word) sin16s::x5#0 >> (byte) 4 [ sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5_128#0 ] ( main:3::sin16s_gen2:21::sin16s:103 [ sin16s_gen2::step#0 sin16s_gen2::x#2 sin16s_gen2::sintab#2 sin16s_gen2::i#2 sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5_128#0 ] ) always clobbers reg byte a reg byte y 
+Statement [170] (word) sin16s::x5_128#0 ← (word) sin16s::x5#0 >> (byte) 4 [ sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5_128#0 ] ( main:3::sin16s_gen2:21::sin16s:103 [ sin16s_gen2::step#0 sin16s_gen2::x#2 sin16s_gen2::sintab#2 sin16s_gen2::i#2 sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5_128#0 ] ) always clobbers reg byte a 
 Statement [171] (word) sin16s::usinx#1 ← (word) sin16s::usinx#0 + (word) sin16s::x5_128#0 [ sin16s::isUpper#2 sin16s::usinx#1 ] ( main:3::sin16s_gen2:21::sin16s:103 [ sin16s_gen2::step#0 sin16s_gen2::x#2 sin16s_gen2::sintab#2 sin16s_gen2::i#2 sin16s::isUpper#2 sin16s::usinx#1 ] ) always clobbers reg byte a 
 Statement [173] (signed word) sin16s::sinx#1 ← - (signed word)(word) sin16s::usinx#1 [ sin16s::sinx#1 ] ( main:3::sin16s_gen2:21::sin16s:103 [ sin16s_gen2::step#0 sin16s_gen2::x#2 sin16s_gen2::sintab#2 sin16s_gen2::i#2 sin16s::sinx#1 ] ) always clobbers reg byte a 
 Statement [176] (signed word~) sin16s::return#5 ← (signed word)(word) sin16s::usinx#1 [ sin16s::return#5 ] ( main:3::sin16s_gen2:21::sin16s:103 [ sin16s_gen2::step#0 sin16s_gen2::x#2 sin16s_gen2::sintab#2 sin16s_gen2::i#2 sin16s::return#5 ] ) always clobbers reg byte a 
@@ -6190,7 +6192,7 @@ Statement [165] (word) mulu16_sel::v1#4 ← (word) sin16s::x4#0 [ sin16s::isUppe
 Statement [166] (word) mulu16_sel::v2#4 ← (word) sin16s::x1#0 [ sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::v1#4 mulu16_sel::v2#4 ] ( main:3::sin16s_gen2:21::sin16s:103 [ sin16s_gen2::step#0 sin16s_gen2::x#2 sin16s_gen2::sintab#2 sin16s_gen2::i#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::v1#4 mulu16_sel::v2#4 ] ) always clobbers reg byte a 
 Statement [168] (word) mulu16_sel::return#11 ← (word) mulu16_sel::return#12 [ sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::return#11 ] ( main:3::sin16s_gen2:21::sin16s:103 [ sin16s_gen2::step#0 sin16s_gen2::x#2 sin16s_gen2::sintab#2 sin16s_gen2::i#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::return#11 ] ) always clobbers reg byte a 
 Statement [169] (word) sin16s::x5#0 ← (word) mulu16_sel::return#11 [ sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5#0 ] ( main:3::sin16s_gen2:21::sin16s:103 [ sin16s_gen2::step#0 sin16s_gen2::x#2 sin16s_gen2::sintab#2 sin16s_gen2::i#2 sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5#0 ] ) always clobbers reg byte a 
-Statement [170] (word) sin16s::x5_128#0 ← (word) sin16s::x5#0 >> (byte) 4 [ sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5_128#0 ] ( main:3::sin16s_gen2:21::sin16s:103 [ sin16s_gen2::step#0 sin16s_gen2::x#2 sin16s_gen2::sintab#2 sin16s_gen2::i#2 sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5_128#0 ] ) always clobbers reg byte a reg byte y 
+Statement [170] (word) sin16s::x5_128#0 ← (word) sin16s::x5#0 >> (byte) 4 [ sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5_128#0 ] ( main:3::sin16s_gen2:21::sin16s:103 [ sin16s_gen2::step#0 sin16s_gen2::x#2 sin16s_gen2::sintab#2 sin16s_gen2::i#2 sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5_128#0 ] ) always clobbers reg byte a 
 Statement [171] (word) sin16s::usinx#1 ← (word) sin16s::usinx#0 + (word) sin16s::x5_128#0 [ sin16s::isUpper#2 sin16s::usinx#1 ] ( main:3::sin16s_gen2:21::sin16s:103 [ sin16s_gen2::step#0 sin16s_gen2::x#2 sin16s_gen2::sintab#2 sin16s_gen2::i#2 sin16s::isUpper#2 sin16s::usinx#1 ] ) always clobbers reg byte a 
 Statement [173] (signed word) sin16s::sinx#1 ← - (signed word)(word) sin16s::usinx#1 [ sin16s::sinx#1 ] ( main:3::sin16s_gen2:21::sin16s:103 [ sin16s_gen2::step#0 sin16s_gen2::x#2 sin16s_gen2::sintab#2 sin16s_gen2::i#2 sin16s::sinx#1 ] ) always clobbers reg byte a 
 Statement [176] (signed word~) sin16s::return#5 ← (signed word)(word) sin16s::usinx#1 [ sin16s::return#5 ] ( main:3::sin16s_gen2:21::sin16s:103 [ sin16s_gen2::step#0 sin16s_gen2::x#2 sin16s_gen2::sintab#2 sin16s_gen2::i#2 sin16s::return#5 ] ) always clobbers reg byte a 
@@ -6317,57 +6319,57 @@ Uplift Scope [main] 38.5: zp ZP_BYTE:2 [ main::ch#2 main::ch#1 ]
 Uplift Scope [] 26.12: zp ZP_WORD:3 [ xsin_idx#11 xsin_idx#19 xsin_idx#3 ] 0.8: zp ZP_WORD:177 [ rem16u#1 ] 
 Uplift Scope [div32u16u] 4: zp ZP_DWORD:82 [ div32u16u::return#2 ] 4: zp ZP_WORD:169 [ div32u16u::quotient_lo#0 ] 1.33: zp ZP_DWORD:171 [ div32u16u::return#0 ] 0.8: zp ZP_WORD:165 [ div32u16u::quotient_hi#0 ] 
 
-Uplifting [mul16u] best 74974 combination zp ZP_DWORD:25 [ mul16u::res#2 mul16u::res#6 mul16u::res#1 ] zp ZP_DWORD:29 [ mul16u::mb#2 mul16u::mb#0 mul16u::mb#1 ] reg byte a [ mul16u::$1 ] zp ZP_WORD:23 [ mul16u::a#3 mul16u::a#6 mul16u::a#8 mul16u::a#2 mul16u::a#0 ] zp ZP_WORD:21 [ mul16u::b#1 ] zp ZP_DWORD:104 [ mul16u::return#2 ] zp ZP_DWORD:149 [ mul16u::return#3 ] 
-Uplifting [divr16u] best 74764 combination zp ZP_WORD:45 [ divr16u::rem#5 divr16u::rem#10 divr16u::rem#4 divr16u::rem#11 divr16u::rem#6 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 ] zp ZP_WORD:49 [ 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 ZP_WORD:47 [ divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#0 ] zp ZP_WORD:163 [ divr16u::return#2 ] zp ZP_WORD:167 [ divr16u::return#3 ] 
-Uplifting [sin16s] best 74764 combination zp ZP_DWORD:34 [ sin16s::x#6 sin16s::x#4 sin16s::x#0 sin16s::x#1 sin16s::x#2 ] zp ZP_WORD:90 [ sin16s::return#0 ] zp ZP_WORD:38 [ sin16s::return#1 sin16s::return#5 sin16s::sinx#1 ] zp ZP_DWORD:117 [ sin16s::$4 ] zp ZP_WORD:125 [ sin16s::x2#0 ] zp ZP_WORD:133 [ sin16s::x3_6#0 ] zp ZP_WORD:139 [ sin16s::x4#0 ] zp ZP_WORD:143 [ sin16s::x5#0 ] zp ZP_WORD:145 [ sin16s::x5_128#0 ] zp ZP_WORD:129 [ sin16s::x3#0 ] zp ZP_WORD:147 [ sin16s::usinx#1 ] zp ZP_WORD:121 [ sin16s::x1#0 ] zp ZP_WORD:135 [ sin16s::usinx#0 ] zp ZP_BYTE:33 [ sin16s::isUpper#2 ] 
-Uplifting [mulu16_sel] best 74748 combination zp ZP_WORD:40 [ 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 ZP_WORD:42 [ mulu16_sel::v2#5 mulu16_sel::v2#3 mulu16_sel::v2#4 mulu16_sel::v2#0 mulu16_sel::v2#1 ] zp ZP_WORD:123 [ mulu16_sel::return#0 ] zp ZP_WORD:127 [ mulu16_sel::return#1 ] zp ZP_WORD:131 [ mulu16_sel::return#2 ] zp ZP_WORD:137 [ mulu16_sel::return#10 ] zp ZP_WORD:141 [ mulu16_sel::return#11 ] zp ZP_DWORD:153 [ mulu16_sel::$0 ] zp ZP_DWORD:157 [ mulu16_sel::$1 ] zp ZP_WORD:161 [ mulu16_sel::return#12 ] reg byte x [ mulu16_sel::select#5 ] 
-Uplifting [sin16s_gen2] best 74748 combination zp ZP_DWORD:98 [ sin16s_gen2::$5 ] zp ZP_WORD:15 [ sin16s_gen2::i#2 sin16s_gen2::i#1 ] zp ZP_WORD:102 [ sin16s_gen2::$6 ] zp ZP_DWORD:9 [ sin16s_gen2::x#2 sin16s_gen2::x#1 ] zp ZP_WORD:13 [ sin16s_gen2::sintab#2 sin16s_gen2::sintab#0 ] zp ZP_DWORD:86 [ sin16s_gen2::step#0 ] 
-Uplifting [loop] best 74748 combination zp ZP_WORD:57 [ loop::$5 ] zp ZP_WORD:59 [ loop::$1 ] zp ZP_WORD:61 [ loop::xpos#0 ] 
-Uplifting [mul16s] best 74748 combination zp ZP_DWORD:94 [ mul16s::return#2 ] zp ZP_DWORD:17 [ mul16s::m#4 mul16s::m#1 mul16s::m#0 ] zp ZP_DWORD:112 [ mul16s::return#0 ] zp ZP_WORD:108 [ mul16s::$9 ] zp ZP_WORD:110 [ mul16s::$16 ] zp ZP_WORD:92 [ mul16s::a#0 ] 
-Uplifting [memset] best 74732 combination zp ZP_WORD:55 [ memset::dst#2 memset::dst#3 memset::dst#1 ] zp ZP_WORD:179 [ memset::end#0 ] reg byte x [ memset::c#3 ] zp ZP_WORD:52 [ memset::str#2 ] 
-Uplifting [main] best 74612 combination reg byte x [ main::ch#2 main::ch#1 ] 
-Uplifting [] best 74612 combination zp ZP_WORD:3 [ xsin_idx#11 xsin_idx#19 xsin_idx#3 ] zp ZP_WORD:177 [ rem16u#1 ] 
-Uplifting [div32u16u] best 74612 combination zp ZP_DWORD:82 [ div32u16u::return#2 ] zp ZP_WORD:169 [ div32u16u::quotient_lo#0 ] zp ZP_DWORD:171 [ div32u16u::return#0 ] zp ZP_WORD:165 [ div32u16u::quotient_hi#0 ] 
+Uplifting [mul16u] best 74992 combination zp ZP_DWORD:25 [ mul16u::res#2 mul16u::res#6 mul16u::res#1 ] zp ZP_DWORD:29 [ mul16u::mb#2 mul16u::mb#0 mul16u::mb#1 ] reg byte a [ mul16u::$1 ] zp ZP_WORD:23 [ mul16u::a#3 mul16u::a#6 mul16u::a#8 mul16u::a#2 mul16u::a#0 ] zp ZP_WORD:21 [ mul16u::b#1 ] zp ZP_DWORD:104 [ mul16u::return#2 ] zp ZP_DWORD:149 [ mul16u::return#3 ] 
+Uplifting [divr16u] best 74782 combination zp ZP_WORD:45 [ divr16u::rem#5 divr16u::rem#10 divr16u::rem#4 divr16u::rem#11 divr16u::rem#6 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 ] zp ZP_WORD:49 [ 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 ZP_WORD:47 [ divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#0 ] zp ZP_WORD:163 [ divr16u::return#2 ] zp ZP_WORD:167 [ divr16u::return#3 ] 
+Uplifting [sin16s] best 74782 combination zp ZP_DWORD:34 [ sin16s::x#6 sin16s::x#4 sin16s::x#0 sin16s::x#1 sin16s::x#2 ] zp ZP_WORD:90 [ sin16s::return#0 ] zp ZP_WORD:38 [ sin16s::return#1 sin16s::return#5 sin16s::sinx#1 ] zp ZP_DWORD:117 [ sin16s::$4 ] zp ZP_WORD:125 [ sin16s::x2#0 ] zp ZP_WORD:133 [ sin16s::x3_6#0 ] zp ZP_WORD:139 [ sin16s::x4#0 ] zp ZP_WORD:143 [ sin16s::x5#0 ] zp ZP_WORD:145 [ sin16s::x5_128#0 ] zp ZP_WORD:129 [ sin16s::x3#0 ] zp ZP_WORD:147 [ sin16s::usinx#1 ] zp ZP_WORD:121 [ sin16s::x1#0 ] zp ZP_WORD:135 [ sin16s::usinx#0 ] zp ZP_BYTE:33 [ sin16s::isUpper#2 ] 
+Uplifting [mulu16_sel] best 74766 combination zp ZP_WORD:40 [ 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 ZP_WORD:42 [ mulu16_sel::v2#5 mulu16_sel::v2#3 mulu16_sel::v2#4 mulu16_sel::v2#0 mulu16_sel::v2#1 ] zp ZP_WORD:123 [ mulu16_sel::return#0 ] zp ZP_WORD:127 [ mulu16_sel::return#1 ] zp ZP_WORD:131 [ mulu16_sel::return#2 ] zp ZP_WORD:137 [ mulu16_sel::return#10 ] zp ZP_WORD:141 [ mulu16_sel::return#11 ] zp ZP_DWORD:153 [ mulu16_sel::$0 ] zp ZP_DWORD:157 [ mulu16_sel::$1 ] zp ZP_WORD:161 [ mulu16_sel::return#12 ] reg byte x [ mulu16_sel::select#5 ] 
+Uplifting [sin16s_gen2] best 74766 combination zp ZP_DWORD:98 [ sin16s_gen2::$5 ] zp ZP_WORD:15 [ sin16s_gen2::i#2 sin16s_gen2::i#1 ] zp ZP_WORD:102 [ sin16s_gen2::$6 ] zp ZP_DWORD:9 [ sin16s_gen2::x#2 sin16s_gen2::x#1 ] zp ZP_WORD:13 [ sin16s_gen2::sintab#2 sin16s_gen2::sintab#0 ] zp ZP_DWORD:86 [ sin16s_gen2::step#0 ] 
+Uplifting [loop] best 74766 combination zp ZP_WORD:57 [ loop::$5 ] zp ZP_WORD:59 [ loop::$1 ] zp ZP_WORD:61 [ loop::xpos#0 ] 
+Uplifting [mul16s] best 74766 combination zp ZP_DWORD:94 [ mul16s::return#2 ] zp ZP_DWORD:17 [ mul16s::m#4 mul16s::m#1 mul16s::m#0 ] zp ZP_DWORD:112 [ mul16s::return#0 ] zp ZP_WORD:108 [ mul16s::$9 ] zp ZP_WORD:110 [ mul16s::$16 ] zp ZP_WORD:92 [ mul16s::a#0 ] 
+Uplifting [memset] best 74750 combination zp ZP_WORD:55 [ memset::dst#2 memset::dst#3 memset::dst#1 ] zp ZP_WORD:179 [ memset::end#0 ] reg byte x [ memset::c#3 ] zp ZP_WORD:52 [ memset::str#2 ] 
+Uplifting [main] best 74630 combination reg byte x [ main::ch#2 main::ch#1 ] 
+Uplifting [] best 74630 combination zp ZP_WORD:3 [ xsin_idx#11 xsin_idx#19 xsin_idx#3 ] zp ZP_WORD:177 [ rem16u#1 ] 
+Uplifting [div32u16u] best 74630 combination zp ZP_DWORD:82 [ div32u16u::return#2 ] zp ZP_WORD:169 [ div32u16u::quotient_lo#0 ] zp ZP_DWORD:171 [ div32u16u::return#0 ] zp ZP_WORD:165 [ div32u16u::quotient_hi#0 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:5 [ render_logo::screen_idx#10 render_logo::screen_idx#4 render_logo::screen_idx#18 render_logo::screen_idx#3 ]
-Uplifting [render_logo] best 69512 combination reg byte y [ render_logo::screen_idx#10 render_logo::screen_idx#4 render_logo::screen_idx#18 render_logo::screen_idx#3 ] 
+Uplifting [render_logo] best 69530 combination reg byte y [ render_logo::screen_idx#10 render_logo::screen_idx#4 render_logo::screen_idx#18 render_logo::screen_idx#3 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:8 [ render_logo::screen_idx#15 render_logo::screen_idx#21 render_logo::screen_idx#5 render_logo::screen_idx#6 ]
-Uplifting [render_logo] best 64712 combination reg byte y [ render_logo::screen_idx#15 render_logo::screen_idx#21 render_logo::screen_idx#5 render_logo::screen_idx#6 ] 
+Uplifting [render_logo] best 64730 combination reg byte y [ render_logo::screen_idx#15 render_logo::screen_idx#21 render_logo::screen_idx#5 render_logo::screen_idx#6 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:7 [ render_logo::logo_idx#11 render_logo::logo_idx#14 render_logo::logo_idx#4 ]
-Uplifting [render_logo] best 64712 combination zp ZP_BYTE:7 [ render_logo::logo_idx#11 render_logo::logo_idx#14 render_logo::logo_idx#4 ] 
+Uplifting [render_logo] best 64730 combination zp ZP_BYTE:7 [ render_logo::logo_idx#11 render_logo::logo_idx#14 render_logo::logo_idx#4 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:6 [ render_logo::logo_idx#10 render_logo::logo_idx#3 ]
-Uplifting [render_logo] best 64712 combination zp ZP_BYTE:6 [ render_logo::logo_idx#10 render_logo::logo_idx#3 ] 
+Uplifting [render_logo] best 64730 combination zp ZP_BYTE:6 [ render_logo::logo_idx#10 render_logo::logo_idx#3 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:71 [ render_logo::$33 ]
-Uplifting [render_logo] best 64312 combination reg byte a [ render_logo::$33 ] 
+Uplifting [render_logo] best 64330 combination reg byte a [ render_logo::$33 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:72 [ render_logo::$36 ]
-Uplifting [render_logo] best 63912 combination reg byte a [ render_logo::$36 ] 
+Uplifting [render_logo] best 63930 combination reg byte a [ render_logo::$36 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:73 [ render_logo::$39 ]
-Uplifting [render_logo] best 63512 combination reg byte a [ render_logo::$39 ] 
+Uplifting [render_logo] best 63530 combination reg byte a [ render_logo::$39 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:74 [ render_logo::$42 ]
-Uplifting [render_logo] best 63112 combination reg byte a [ render_logo::$42 ] 
+Uplifting [render_logo] best 63130 combination reg byte a [ render_logo::$42 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:75 [ render_logo::$45 ]
-Uplifting [render_logo] best 62712 combination reg byte a [ render_logo::$45 ] 
+Uplifting [render_logo] best 62730 combination reg byte a [ render_logo::$45 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:77 [ render_logo::$73 ]
-Uplifting [render_logo] best 62312 combination reg byte a [ render_logo::$73 ] 
+Uplifting [render_logo] best 62330 combination reg byte a [ render_logo::$73 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:78 [ render_logo::$76 ]
-Uplifting [render_logo] best 61912 combination reg byte a [ render_logo::$76 ] 
+Uplifting [render_logo] best 61930 combination reg byte a [ render_logo::$76 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:79 [ render_logo::$79 ]
-Uplifting [render_logo] best 61512 combination reg byte a [ render_logo::$79 ] 
+Uplifting [render_logo] best 61530 combination reg byte a [ render_logo::$79 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:80 [ render_logo::$82 ]
-Uplifting [render_logo] best 61112 combination reg byte a [ render_logo::$82 ] 
+Uplifting [render_logo] best 61130 combination reg byte a [ render_logo::$82 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:81 [ render_logo::$85 ]
-Uplifting [render_logo] best 60712 combination reg byte a [ render_logo::$85 ] 
+Uplifting [render_logo] best 60730 combination reg byte a [ render_logo::$85 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:65 [ render_logo::$0 ]
-Uplifting [render_logo] best 60706 combination reg byte a [ render_logo::$0 ] 
+Uplifting [render_logo] best 60724 combination reg byte a [ render_logo::$0 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:66 [ render_logo::$1 ]
-Uplifting [render_logo] best 60700 combination reg byte a [ render_logo::$1 ] 
+Uplifting [render_logo] best 60718 combination reg byte a [ render_logo::$1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:67 [ render_logo::$2 ]
-Uplifting [render_logo] best 60694 combination reg byte a [ render_logo::$2 ] 
+Uplifting [render_logo] best 60712 combination reg byte a [ render_logo::$2 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:76 [ render_logo::$17 ]
-Uplifting [render_logo] best 60688 combination reg byte a [ render_logo::$17 ] 
+Uplifting [render_logo] best 60706 combination reg byte a [ render_logo::$17 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:70 [ render_logo::x_char#0 ]
-Uplifting [render_logo] best 60688 combination zp ZP_BYTE:70 [ render_logo::x_char#0 ] 
+Uplifting [render_logo] best 60706 combination zp ZP_BYTE:70 [ render_logo::x_char#0 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:33 [ sin16s::isUpper#2 ]
-Uplifting [sin16s] best 60688 combination zp ZP_BYTE:33 [ sin16s::isUpper#2 ] 
+Uplifting [sin16s] best 60706 combination zp ZP_BYTE:33 [ sin16s::isUpper#2 ] 
 Coalescing zero page register with common assignment [ zp ZP_WORD:38 [ sin16s::return#1 sin16s::return#5 sin16s::sinx#1 ] ] with [ zp ZP_WORD:147 [ sin16s::usinx#1 ] ] - score: 2
 Coalescing zero page register with common assignment [ zp ZP_WORD:40 [ 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 ZP_WORD:129 [ sin16s::x3#0 ] ] - score: 2
 Coalescing zero page register with common assignment [ zp ZP_WORD:45 [ divr16u::rem#5 divr16u::rem#10 divr16u::rem#4 divr16u::rem#11 divr16u::rem#6 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 ] ] with [ zp ZP_WORD:177 [ rem16u#1 ] ] - score: 2

src/test/ref/examples/sinplotter/sine-plotter.asm

@@ -55,7 +55,6 @@ main: {
     sta D016
     lda #toD0181_return
     sta D018
-    jsr memset
     jsr bitmap_init
     jsr bitmap_clear
     jsr sin16s_gen2
@@ -174,10 +173,10 @@ render_sine: {
 // Plot a single dot in the bitmap
 // bitmap_plot(word zeropage(4) x, byte register(X) y)
 bitmap_plot: {
-    .label _1 = $34
-    .label plotter = $32
+    .label _1 = $33
+    .label plotter = $31
     .label x = 4
-    .label _3 = $32
+    .label _3 = $31
     lda bitmap_plot_yhi,x
     sta _3+1
     lda bitmap_plot_ylo,x
@@ -248,8 +247,8 @@ sin16s_gen2: {
     .const max = $140
     .label ampl = max-min
     .label _5 = $10
-    .label _6 = $3a
-    .label step = $36
+    .label _6 = $39
+    .label step = $35
     .label sintab = $c
     .label x = 8
     .label i = $e
@@ -326,8 +325,8 @@ sin16s_gen2: {
 // Fixes offsets introduced by using unsigned multiplication
 // mul16s(signed word zeropage($21) a)
 mul16s: {
-    .label _9 = $3c
-    .label _16 = $3c
+    .label _9 = $3b
+    .label _16 = $3b
     .label m = $10
     .label return = $10
     .label a = $21
@@ -418,14 +417,14 @@ sin16s: {
     .label _4 = $1d
     .label x = $1d
     .label return = $21
-    .label x1 = $3e
+    .label x1 = $3d
     .label x2 = $23
     .label x3 = $23
-    .label x3_6 = $40
+    .label x3_6 = $3f
     .label usinx = $21
     .label x4 = $23
-    .label x5 = $40
-    .label x5_128 = $40
+    .label x5 = $3f
+    .label x5_128 = $3f
     .label sinx = $21
     .label isUpper = $1c
     lda x+3
@@ -578,13 +577,11 @@ sin16s: {
     cmp #0
     beq b3
     sec
-    lda sinx
-    eor #$ff
-    adc #0
+    lda #0
+    sbc sinx
     sta sinx
-    lda sinx+1
-    eor #$ff
-    adc #0
+    lda #0
+    sbc sinx+1
     sta sinx+1
   b3:
     rts
@@ -597,7 +594,7 @@ mulu16_sel: {
     .label _1 = $10
     .label v1 = $23
     .label v2 = $14
-    .label return = $40
+    .label return = $3f
     .label return_1 = $23
     .label return_10 = $23
     lda v1
@@ -631,9 +628,9 @@ mulu16_sel: {
 // 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 = $42
+    .label quotient_hi = $41
     .label quotient_lo = $29
-    .label return = $36
+    .label return = $35
     lda #<PI2_u4f28>>$10
     sta divr16u.dividend
     lda #>PI2_u4f28>>$10
@@ -716,39 +713,66 @@ divr16u: {
     rts
 }
 // Clear all graphics on the bitmap
+// bgcol - the background color to fill the screen with
+// fgcol - the foreground color to fill the screen with
 bitmap_clear: {
-    .label bitmap = $2c
-    .label y = $2b
-    .label _3 = $2c
-    lda bitmap_plot_ylo
-    sta _3
-    lda bitmap_plot_yhi
-    sta _3+1
-    lda #0
-    sta y
-  b1:
+    .const col = WHITE*$10
+    ldx #col
+    lda #<$3e8
+    sta memset.num
+    lda #>$3e8
+    sta memset.num+1
+    lda #<SCREEN
+    sta memset.str
+    lda #>SCREEN
+    sta memset.str+1
+    jsr memset
     ldx #0
-  b2:
-    lda #0
-    tay
-    sta (bitmap),y
-    inc bitmap
+    lda #<$1f40
+    sta memset.num
+    lda #>$1f40
+    sta memset.num+1
+    lda #<BITMAP
+    sta memset.str
+    lda #>BITMAP
+    sta memset.str+1
+    jsr memset
+    rts
+}
+// Copies the character c (an unsigned char) to the first num characters of the object pointed to by the argument str.
+// memset(void* zeropage($2b) str, byte register(X) c, word zeropage($2d) num)
+memset: {
+    .label end = $2d
+    .label dst = $2b
+    .label str = $2b
+    .label num = $2d
+    lda end
+    clc
+    adc str
+    sta end
+    lda end+1
+    adc str+1
+    sta end+1
+  b1:
+    txa
+    ldy #0
+    sta (dst),y
+    inc dst
     bne !+
-    inc bitmap+1
+    inc dst+1
   !:
-    inx
-    cpx #$c8
-    bne b2
-    inc y
-    lda #$28
-    cmp y
+    lda dst+1
+    cmp end+1
+    bne b1
+    lda dst
+    cmp end
     bne b1
     rts
 }
 // Initialize bitmap plotting tables
 bitmap_init: {
-    .label _7 = $44
-    .label yoffs = $2e
+    .label _7 = $43
+    .label yoffs = $2f
     ldx #0
     lda #$80
   b1:
@@ -789,32 +813,6 @@ bitmap_init: {
     cpx #0
     bne b3
     rts
-}
-// Copies the character c (an unsigned char) to the first num characters of the object pointed to by the argument str.
-memset: {
-    .const num = $3e8
-    .label str = SCREEN
-    .label end = str+num
-    .label dst = $30
-    lda #<str
-    sta dst
-    lda #>str
-    sta dst+1
-  b1:
-    lda #WHITE
-    ldy #0
-    sta (dst),y
-    inc dst
-    bne !+
-    inc dst+1
-  !:
-    lda dst+1
-    cmp #>end
-    bne b1
-    lda dst
-    cmp #<end
-    bne b1
-    rts
 }
   // Tables for the plotter - initialized by calling bitmap_init();
   bitmap_plot_ylo: .fill $100, 0

src/test/ref/examples/sinplotter/sine-plotter.cfg

@@ -36,358 +36,358 @@ main::toD0181: scope:[main]  from main::@2
   to:main::@3
 main::@3: scope:[main]  from main::toD0181
   [14] *((const byte*) D018#0) ← (const byte) main::toD0181_return#0
-  [15] call memset 
+  [15] call bitmap_init 
   to:main::@4
 main::@4: scope:[main]  from main::@3
   [16] phi()
-  [17] call bitmap_init 
+  [17] call bitmap_clear 
   to:main::@5
 main::@5: scope:[main]  from main::@4
   [18] phi()
-  [19] call bitmap_clear 
+  [19] call sin16s_gen2 
   to:main::@6
 main::@6: scope:[main]  from main::@5
   [20] phi()
-  [21] call sin16s_gen2 
-  to:main::@7
-main::@7: scope:[main]  from main::@6
-  [22] phi()
-  [23] call render_sine 
+  [21] call render_sine 
   to:main::@1
-main::@1: scope:[main]  from main::@1 main::@7
-  [24] *((const byte*) BGCOL#0) ← ++ *((const byte*) BGCOL#0)
+main::@1: scope:[main]  from main::@1 main::@6
+  [22] *((const byte*) BGCOL#0) ← ++ *((const byte*) BGCOL#0)
   to:main::@1
-render_sine: scope:[render_sine]  from main::@7
-  [25] phi()
+render_sine: scope:[render_sine]  from main::@6
+  [23] phi()
   to:render_sine::@1
 render_sine::@1: scope:[render_sine]  from render_sine render_sine::@2
-  [26] (word) render_sine::xpos#3 ← phi( render_sine/(byte) 0 render_sine::@2/(word) render_sine::xpos#8 )
-  [26] (word) render_sine::sin_idx#2 ← phi( render_sine/(byte) 0 render_sine::@2/(word) render_sine::sin_idx#1 )
-  [27] (word~) render_sine::$10 ← (word) render_sine::sin_idx#2 << (byte) 1
-  [28] (signed word*~) render_sine::$0 ← (const signed word[$200]) sin#0 + (word~) render_sine::$10
-  [29] (signed word) render_sine::sin_val#0 ← *((signed word*~) render_sine::$0)
-  [30] (signed word) wrap_y::y#0 ← (signed word) render_sine::sin_val#0
-  [31] call wrap_y 
-  [32] (byte) wrap_y::return#0 ← (byte) wrap_y::return#2
+  [24] (word) render_sine::xpos#3 ← phi( render_sine/(byte) 0 render_sine::@2/(word) render_sine::xpos#8 )
+  [24] (word) render_sine::sin_idx#2 ← phi( render_sine/(byte) 0 render_sine::@2/(word) render_sine::sin_idx#1 )
+  [25] (word~) render_sine::$10 ← (word) render_sine::sin_idx#2 << (byte) 1
+  [26] (signed word*~) render_sine::$0 ← (const signed word[$200]) sin#0 + (word~) render_sine::$10
+  [27] (signed word) render_sine::sin_val#0 ← *((signed word*~) render_sine::$0)
+  [28] (signed word) wrap_y::y#0 ← (signed word) render_sine::sin_val#0
+  [29] call wrap_y 
+  [30] (byte) wrap_y::return#0 ← (byte) wrap_y::return#2
   to:render_sine::@3
 render_sine::@3: scope:[render_sine]  from render_sine::@1
-  [33] (byte) render_sine::ypos#0 ← (byte) wrap_y::return#0
-  [34] (word) bitmap_plot::x#0 ← (word) render_sine::xpos#3
-  [35] (byte) bitmap_plot::y#0 ← (byte) render_sine::ypos#0
-  [36] call bitmap_plot 
+  [31] (byte) render_sine::ypos#0 ← (byte) wrap_y::return#0
+  [32] (word) bitmap_plot::x#0 ← (word) render_sine::xpos#3
+  [33] (byte) bitmap_plot::y#0 ← (byte) render_sine::ypos#0
+  [34] call bitmap_plot 
   to:render_sine::@4
 render_sine::@4: scope:[render_sine]  from render_sine::@3
-  [37] (word~) render_sine::$11 ← (word) render_sine::sin_idx#2 << (byte) 1
-  [38] (signed word*~) render_sine::$3 ← (const signed word*) sin2#0 + (word~) render_sine::$11
-  [39] (signed word) render_sine::sin2_val#0 ← *((signed word*~) render_sine::$3)
-  [40] (signed word) wrap_y::y#1 ← (signed word) render_sine::sin2_val#0 + (signed byte) $a
-  [41] call wrap_y 
-  [42] (byte) wrap_y::return#1 ← (byte) wrap_y::return#2
+  [35] (word~) render_sine::$11 ← (word) render_sine::sin_idx#2 << (byte) 1
+  [36] (signed word*~) render_sine::$3 ← (const signed word*) sin2#0 + (word~) render_sine::$11
+  [37] (signed word) render_sine::sin2_val#0 ← *((signed word*~) render_sine::$3)
+  [38] (signed word) wrap_y::y#1 ← (signed word) render_sine::sin2_val#0 + (signed byte) $a
+  [39] call wrap_y 
+  [40] (byte) wrap_y::return#1 ← (byte) wrap_y::return#2
   to:render_sine::@5
 render_sine::@5: scope:[render_sine]  from render_sine::@4
-  [43] (byte) render_sine::ypos2#0 ← (byte) wrap_y::return#1
-  [44] (word) bitmap_plot::x#1 ← (word) render_sine::xpos#3
-  [45] (byte) bitmap_plot::y#1 ← (byte) render_sine::ypos2#0
-  [46] call bitmap_plot 
+  [41] (byte) render_sine::ypos2#0 ← (byte) wrap_y::return#1
+  [42] (word) bitmap_plot::x#1 ← (word) render_sine::xpos#3
+  [43] (byte) bitmap_plot::y#1 ← (byte) render_sine::ypos2#0
+  [44] call bitmap_plot 
   to:render_sine::@6
 render_sine::@6: scope:[render_sine]  from render_sine::@5
-  [47] (word) render_sine::xpos#1 ← ++ (word) render_sine::xpos#3
-  [48] if((word) render_sine::xpos#1!=(word) $140) goto render_sine::@7
+  [45] (word) render_sine::xpos#1 ← ++ (word) render_sine::xpos#3
+  [46] if((word) render_sine::xpos#1!=(word) $140) goto render_sine::@7
   to:render_sine::@2
 render_sine::@7: scope:[render_sine]  from render_sine::@6
-  [49] phi()
+  [47] phi()
   to:render_sine::@2
 render_sine::@2: scope:[render_sine]  from render_sine::@6 render_sine::@7
-  [50] (word) render_sine::xpos#8 ← phi( render_sine::@6/(byte) 0 render_sine::@7/(word) render_sine::xpos#1 )
-  [51] (word) render_sine::sin_idx#1 ← ++ (word) render_sine::sin_idx#2
-  [52] if((word) render_sine::sin_idx#1<(const word) SIN_SIZE#0) goto render_sine::@1
+  [48] (word) render_sine::xpos#8 ← phi( render_sine::@6/(byte) 0 render_sine::@7/(word) render_sine::xpos#1 )
+  [49] (word) render_sine::sin_idx#1 ← ++ (word) render_sine::sin_idx#2
+  [50] if((word) render_sine::sin_idx#1<(const word) SIN_SIZE#0) goto render_sine::@1
   to:render_sine::@return
 render_sine::@return: scope:[render_sine]  from render_sine::@2
-  [53] return 
+  [51] return 
   to:@return
 bitmap_plot: scope:[bitmap_plot]  from render_sine::@3 render_sine::@5
-  [54] (word) bitmap_plot::x#2 ← phi( render_sine::@3/(word) bitmap_plot::x#0 render_sine::@5/(word) bitmap_plot::x#1 )
-  [54] (byte) bitmap_plot::y#2 ← phi( render_sine::@3/(byte) bitmap_plot::y#0 render_sine::@5/(byte) bitmap_plot::y#1 )
-  [55] (word~) bitmap_plot::$3 ← *((const byte[$100]) bitmap_plot_yhi#0 + (byte) bitmap_plot::y#2) w= *((const byte[$100]) bitmap_plot_ylo#0 + (byte) bitmap_plot::y#2)
-  [56] (word~) bitmap_plot::$1 ← (word) bitmap_plot::x#2 & (word) $fff8
-  [57] (byte*) bitmap_plot::plotter#1 ← (byte*)(word~) bitmap_plot::$3 + (word~) bitmap_plot::$1
-  [58] (byte~) bitmap_plot::$2 ← < (word) bitmap_plot::x#2
-  [59] *((byte*) bitmap_plot::plotter#1) ← *((byte*) bitmap_plot::plotter#1) | *((const byte[$100]) bitmap_plot_bit#0 + (byte~) bitmap_plot::$2)
+  [52] (word) bitmap_plot::x#2 ← phi( render_sine::@3/(word) bitmap_plot::x#0 render_sine::@5/(word) bitmap_plot::x#1 )
+  [52] (byte) bitmap_plot::y#2 ← phi( render_sine::@3/(byte) bitmap_plot::y#0 render_sine::@5/(byte) bitmap_plot::y#1 )
+  [53] (word~) bitmap_plot::$3 ← *((const byte[$100]) bitmap_plot_yhi#0 + (byte) bitmap_plot::y#2) w= *((const byte[$100]) bitmap_plot_ylo#0 + (byte) bitmap_plot::y#2)
+  [54] (word~) bitmap_plot::$1 ← (word) bitmap_plot::x#2 & (word) $fff8
+  [55] (byte*) bitmap_plot::plotter#1 ← (byte*)(word~) bitmap_plot::$3 + (word~) bitmap_plot::$1
+  [56] (byte~) bitmap_plot::$2 ← < (word) bitmap_plot::x#2
+  [57] *((byte*) bitmap_plot::plotter#1) ← *((byte*) bitmap_plot::plotter#1) | *((const byte[$100]) bitmap_plot_bit#0 + (byte~) bitmap_plot::$2)
   to:bitmap_plot::@return
 bitmap_plot::@return: scope:[bitmap_plot]  from bitmap_plot
-  [60] return 
+  [58] return 
   to:@return
 wrap_y: scope:[wrap_y]  from render_sine::@1 render_sine::@4
-  [61] (signed word) wrap_y::y#9 ← phi( render_sine::@1/(signed word) wrap_y::y#0 render_sine::@4/(signed word) wrap_y::y#1 )
+  [59] (signed word) wrap_y::y#9 ← phi( render_sine::@1/(signed word) wrap_y::y#0 render_sine::@4/(signed word) wrap_y::y#1 )
   to:wrap_y::@1
 wrap_y::@1: scope:[wrap_y]  from wrap_y wrap_y::@2
-  [62] (signed word) wrap_y::y#4 ← phi( wrap_y/(signed word) wrap_y::y#9 wrap_y::@2/(signed word) wrap_y::y#2 )
-  [63] if((signed word) wrap_y::y#4>=(signed word) $c8) goto wrap_y::@2
+  [60] (signed word) wrap_y::y#4 ← phi( wrap_y/(signed word) wrap_y::y#9 wrap_y::@2/(signed word) wrap_y::y#2 )
+  [61] if((signed word) wrap_y::y#4>=(signed word) $c8) goto wrap_y::@2
   to:wrap_y::@3
 wrap_y::@3: scope:[wrap_y]  from wrap_y::@1 wrap_y::@4
-  [64] (signed word) wrap_y::y#6 ← phi( wrap_y::@1/(signed word) wrap_y::y#4 wrap_y::@4/(signed word) wrap_y::y#3 )
-  [65] if((signed word) wrap_y::y#6<(signed byte) 0) goto wrap_y::@4
+  [62] (signed word) wrap_y::y#6 ← phi( wrap_y::@1/(signed word) wrap_y::y#4 wrap_y::@4/(signed word) wrap_y::y#3 )
+  [63] if((signed word) wrap_y::y#6<(signed byte) 0) goto wrap_y::@4
   to:wrap_y::@5
 wrap_y::@5: scope:[wrap_y]  from wrap_y::@3
-  [66] (byte) wrap_y::return#2 ← (byte)(signed word) wrap_y::y#6
+  [64] (byte) wrap_y::return#2 ← (byte)(signed word) wrap_y::y#6
   to:wrap_y::@return
 wrap_y::@return: scope:[wrap_y]  from wrap_y::@5
-  [67] return 
+  [65] return 
   to:@return
 wrap_y::@4: scope:[wrap_y]  from wrap_y::@3
-  [68] (signed word) wrap_y::y#3 ← (signed word) wrap_y::y#6 + (signed word) $c8
+  [66] (signed word) wrap_y::y#3 ← (signed word) wrap_y::y#6 + (signed word) $c8
   to:wrap_y::@3
 wrap_y::@2: scope:[wrap_y]  from wrap_y::@1
-  [69] (signed word) wrap_y::y#2 ← (signed word) wrap_y::y#4 - (signed word) $c8
+  [67] (signed word) wrap_y::y#2 ← (signed word) wrap_y::y#4 - (signed word) $c8
   to:wrap_y::@1
-sin16s_gen2: scope:[sin16s_gen2]  from main::@6
-  [70] phi()
-  [71] call div32u16u 
-  [72] (dword) div32u16u::return#2 ← (dword) div32u16u::return#0
+sin16s_gen2: scope:[sin16s_gen2]  from main::@5
+  [68] phi()
+  [69] call div32u16u 
+  [70] (dword) div32u16u::return#2 ← (dword) div32u16u::return#0
   to:sin16s_gen2::@2
 sin16s_gen2::@2: scope:[sin16s_gen2]  from sin16s_gen2
-  [73] (dword) sin16s_gen2::step#0 ← (dword) div32u16u::return#2
+  [71] (dword) sin16s_gen2::step#0 ← (dword) div32u16u::return#2
   to:sin16s_gen2::@1
 sin16s_gen2::@1: scope:[sin16s_gen2]  from sin16s_gen2::@2 sin16s_gen2::@4
-  [74] (word) sin16s_gen2::i#2 ← phi( sin16s_gen2::@2/(byte) 0 sin16s_gen2::@4/(word) sin16s_gen2::i#1 )
-  [74] (signed word*) sin16s_gen2::sintab#2 ← phi( sin16s_gen2::@2/(const signed word[$200]) sin#0 sin16s_gen2::@4/(signed word*) sin16s_gen2::sintab#0 )
-  [74] (dword) sin16s_gen2::x#2 ← phi( sin16s_gen2::@2/(byte) 0 sin16s_gen2::@4/(dword) sin16s_gen2::x#1 )
-  [75] (dword) sin16s::x#0 ← (dword) sin16s_gen2::x#2
-  [76] call sin16s 
-  [77] (signed word) sin16s::return#0 ← (signed word) sin16s::return#1
+  [72] (word) sin16s_gen2::i#2 ← phi( sin16s_gen2::@2/(byte) 0 sin16s_gen2::@4/(word) sin16s_gen2::i#1 )
+  [72] (signed word*) sin16s_gen2::sintab#2 ← phi( sin16s_gen2::@2/(const signed word[$200]) sin#0 sin16s_gen2::@4/(signed word*) sin16s_gen2::sintab#0 )
+  [72] (dword) sin16s_gen2::x#2 ← phi( sin16s_gen2::@2/(byte) 0 sin16s_gen2::@4/(dword) sin16s_gen2::x#1 )
+  [73] (dword) sin16s::x#0 ← (dword) sin16s_gen2::x#2
+  [74] call sin16s 
+  [75] (signed word) sin16s::return#0 ← (signed word) sin16s::return#1
   to:sin16s_gen2::@3
 sin16s_gen2::@3: scope:[sin16s_gen2]  from sin16s_gen2::@1
-  [78] (signed word) mul16s::a#0 ← (signed word) sin16s::return#0
-  [79] call mul16s 
-  [80] (signed dword) mul16s::return#2 ← (signed dword) mul16s::return#0
+  [76] (signed word) mul16s::a#0 ← (signed word) sin16s::return#0
+  [77] call mul16s 
+  [78] (signed dword) mul16s::return#2 ← (signed dword) mul16s::return#0
   to:sin16s_gen2::@4
 sin16s_gen2::@4: scope:[sin16s_gen2]  from sin16s_gen2::@3
-  [81] (signed dword~) sin16s_gen2::$5 ← (signed dword) mul16s::return#2
-  [82] (word~) sin16s_gen2::$6 ← > (signed dword~) sin16s_gen2::$5
-  [83] *((signed word*) sin16s_gen2::sintab#2) ← (signed word)(word~) sin16s_gen2::$6
-  [84] (signed word*) sin16s_gen2::sintab#0 ← (signed word*) sin16s_gen2::sintab#2 + (const byte) SIZEOF_SIGNED_WORD
-  [85] (dword) sin16s_gen2::x#1 ← (dword) sin16s_gen2::x#2 + (dword) sin16s_gen2::step#0
-  [86] (word) sin16s_gen2::i#1 ← ++ (word) sin16s_gen2::i#2
-  [87] if((word) sin16s_gen2::i#1<(const word) SIN_SIZE#0) goto sin16s_gen2::@1
+  [79] (signed dword~) sin16s_gen2::$5 ← (signed dword) mul16s::return#2
+  [80] (word~) sin16s_gen2::$6 ← > (signed dword~) sin16s_gen2::$5
+  [81] *((signed word*) sin16s_gen2::sintab#2) ← (signed word)(word~) sin16s_gen2::$6
+  [82] (signed word*) sin16s_gen2::sintab#0 ← (signed word*) sin16s_gen2::sintab#2 + (const byte) SIZEOF_SIGNED_WORD
+  [83] (dword) sin16s_gen2::x#1 ← (dword) sin16s_gen2::x#2 + (dword) sin16s_gen2::step#0
+  [84] (word) sin16s_gen2::i#1 ← ++ (word) sin16s_gen2::i#2
+  [85] if((word) sin16s_gen2::i#1<(const word) SIN_SIZE#0) goto sin16s_gen2::@1
   to:sin16s_gen2::@return
 sin16s_gen2::@return: scope:[sin16s_gen2]  from sin16s_gen2::@4
-  [88] return 
+  [86] return 
   to:@return
 mul16s: scope:[mul16s]  from sin16s_gen2::@3
-  [89] (word~) mul16u::a#8 ← (word)(signed word) mul16s::a#0
-  [90] call mul16u 
-  [91] (dword) mul16u::return#2 ← (dword) mul16u::res#2
+  [87] (word~) mul16u::a#8 ← (word)(signed word) mul16s::a#0
+  [88] call mul16u 
+  [89] (dword) mul16u::return#2 ← (dword) mul16u::res#2
   to:mul16s::@4
 mul16s::@4: scope:[mul16s]  from mul16s
-  [92] (dword) mul16s::m#0 ← (dword) mul16u::return#2
-  [93] if((signed word) mul16s::a#0>=(signed byte) 0) goto mul16s::@1
+  [90] (dword) mul16s::m#0 ← (dword) mul16u::return#2
+  [91] if((signed word) mul16s::a#0>=(signed byte) 0) goto mul16s::@1
   to:mul16s::@3
 mul16s::@3: scope:[mul16s]  from mul16s::@4
-  [94] (word~) mul16s::$9 ← > (dword) mul16s::m#0
-  [95] (word~) mul16s::$16 ← (word~) mul16s::$9 - (word)(const signed word) sin16s_gen2::ampl#0
-  [96] (dword) mul16s::m#1 ← (dword) mul16s::m#0 hi= (word~) mul16s::$16
+  [92] (word~) mul16s::$9 ← > (dword) mul16s::m#0
+  [93] (word~) mul16s::$16 ← (word~) mul16s::$9 - (word)(const signed word) sin16s_gen2::ampl#0
+  [94] (dword) mul16s::m#1 ← (dword) mul16s::m#0 hi= (word~) mul16s::$16
   to:mul16s::@1
 mul16s::@1: scope:[mul16s]  from mul16s::@3 mul16s::@4
-  [97] (dword) mul16s::m#4 ← phi( mul16s::@3/(dword) mul16s::m#1 mul16s::@4/(dword) mul16s::m#0 )
+  [95] (dword) mul16s::m#4 ← phi( mul16s::@3/(dword) mul16s::m#1 mul16s::@4/(dword) mul16s::m#0 )
   to:mul16s::@2
 mul16s::@2: scope:[mul16s]  from mul16s::@1
-  [98] (signed dword) mul16s::return#0 ← (signed dword)(dword) mul16s::m#4
+  [96] (signed dword) mul16s::return#0 ← (signed dword)(dword) mul16s::m#4
   to:mul16s::@return
 mul16s::@return: scope:[mul16s]  from mul16s::@2
-  [99] return 
+  [97] return 
   to:@return
 mul16u: scope:[mul16u]  from mul16s mulu16_sel
-  [100] (word) mul16u::a#6 ← phi( mul16s/(word~) mul16u::a#8 mulu16_sel/(word) mul16u::a#2 )
-  [100] (dword) mul16u::mb#0 ← phi( mul16s/(word)(const signed word) sin16s_gen2::ampl#0 mulu16_sel/(word) mul16u::b#1 )
+  [98] (word) mul16u::a#6 ← phi( mul16s/(word~) mul16u::a#8 mulu16_sel/(word) mul16u::a#2 )
+  [98] (dword) mul16u::mb#0 ← phi( mul16s/(word)(const signed word) sin16s_gen2::ampl#0 mulu16_sel/(word) mul16u::b#1 )
   to:mul16u::@1
 mul16u::@1: scope:[mul16u]  from mul16u mul16u::@3
-  [101] (dword) mul16u::mb#2 ← phi( mul16u/(dword) mul16u::mb#0 mul16u::@3/(dword) mul16u::mb#1 )
-  [101] (dword) mul16u::res#2 ← phi( mul16u/(byte) 0 mul16u::@3/(dword) mul16u::res#6 )
-  [101] (word) mul16u::a#3 ← phi( mul16u/(word) mul16u::a#6 mul16u::@3/(word) mul16u::a#0 )
-  [102] if((word) mul16u::a#3!=(byte) 0) goto mul16u::@2
+  [99] (dword) mul16u::mb#2 ← phi( mul16u/(dword) mul16u::mb#0 mul16u::@3/(dword) mul16u::mb#1 )
+  [99] (dword) mul16u::res#2 ← phi( mul16u/(byte) 0 mul16u::@3/(dword) mul16u::res#6 )
+  [99] (word) mul16u::a#3 ← phi( mul16u/(word) mul16u::a#6 mul16u::@3/(word) mul16u::a#0 )
+  [100] if((word) mul16u::a#3!=(byte) 0) goto mul16u::@2
   to:mul16u::@return
 mul16u::@return: scope:[mul16u]  from mul16u::@1
-  [103] return 
+  [101] return 
   to:@return
 mul16u::@2: scope:[mul16u]  from mul16u::@1
-  [104] (byte~) mul16u::$1 ← (word) mul16u::a#3 & (byte) 1
-  [105] if((byte~) mul16u::$1==(byte) 0) goto mul16u::@3
+  [102] (byte~) mul16u::$1 ← (word) mul16u::a#3 & (byte) 1
+  [103] if((byte~) mul16u::$1==(byte) 0) goto mul16u::@3
   to:mul16u::@4
 mul16u::@4: scope:[mul16u]  from mul16u::@2
-  [106] (dword) mul16u::res#1 ← (dword) mul16u::res#2 + (dword) mul16u::mb#2
+  [104] (dword) mul16u::res#1 ← (dword) mul16u::res#2 + (dword) mul16u::mb#2
   to:mul16u::@3
 mul16u::@3: scope:[mul16u]  from mul16u::@2 mul16u::@4
-  [107] (dword) mul16u::res#6 ← phi( mul16u::@2/(dword) mul16u::res#2 mul16u::@4/(dword) mul16u::res#1 )
-  [108] (word) mul16u::a#0 ← (word) mul16u::a#3 >> (byte) 1
-  [109] (dword) mul16u::mb#1 ← (dword) mul16u::mb#2 << (byte) 1
+  [105] (dword) mul16u::res#6 ← phi( mul16u::@2/(dword) mul16u::res#2 mul16u::@4/(dword) mul16u::res#1 )
+  [106] (word) mul16u::a#0 ← (word) mul16u::a#3 >> (byte) 1
+  [107] (dword) mul16u::mb#1 ← (dword) mul16u::mb#2 << (byte) 1
   to:mul16u::@1
 sin16s: scope:[sin16s]  from sin16s_gen2::@1
-  [110] if((dword) sin16s::x#0<(const dword) PI_u4f28#0) goto sin16s::@1
+  [108] if((dword) sin16s::x#0<(const dword) PI_u4f28#0) goto sin16s::@1
   to:sin16s::@4
 sin16s::@4: scope:[sin16s]  from sin16s
-  [111] (dword) sin16s::x#1 ← (dword) sin16s::x#0 - (const dword) PI_u4f28#0
+  [109] (dword) sin16s::x#1 ← (dword) sin16s::x#0 - (const dword) PI_u4f28#0
   to:sin16s::@1
 sin16s::@1: scope:[sin16s]  from sin16s sin16s::@4
-  [112] (byte) sin16s::isUpper#2 ← phi( sin16s/(byte) 0 sin16s::@4/(byte) 1 )
-  [112] (dword) sin16s::x#4 ← phi( sin16s/(dword) sin16s::x#0 sin16s::@4/(dword) sin16s::x#1 )
-  [113] if((dword) sin16s::x#4<(const dword) PI_HALF_u4f28#0) goto sin16s::@2
+  [110] (byte) sin16s::isUpper#2 ← phi( sin16s/(byte) 0 sin16s::@4/(byte) 1 )
+  [110] (dword) sin16s::x#4 ← phi( sin16s/(dword) sin16s::x#0 sin16s::@4/(dword) sin16s::x#1 )
+  [111] if((dword) sin16s::x#4<(const dword) PI_HALF_u4f28#0) goto sin16s::@2
   to:sin16s::@5
 sin16s::@5: scope:[sin16s]  from sin16s::@1
-  [114] (dword) sin16s::x#2 ← (const dword) PI_u4f28#0 - (dword) sin16s::x#4
+  [112] (dword) sin16s::x#2 ← (const dword) PI_u4f28#0 - (dword) sin16s::x#4
   to:sin16s::@2
 sin16s::@2: scope:[sin16s]  from sin16s::@1 sin16s::@5
-  [115] (dword) sin16s::x#6 ← phi( sin16s::@1/(dword) sin16s::x#4 sin16s::@5/(dword) sin16s::x#2 )
-  [116] (dword~) sin16s::$4 ← (dword) sin16s::x#6 << (byte) 3
-  [117] (word) sin16s::x1#0 ← > (dword~) sin16s::$4
-  [118] (word) mulu16_sel::v1#0 ← (word) sin16s::x1#0
-  [119] (word) mulu16_sel::v2#0 ← (word) sin16s::x1#0
-  [120] call mulu16_sel 
-  [121] (word) mulu16_sel::return#0 ← (word) mulu16_sel::return#12
+  [113] (dword) sin16s::x#6 ← phi( sin16s::@1/(dword) sin16s::x#4 sin16s::@5/(dword) sin16s::x#2 )
+  [114] (dword~) sin16s::$4 ← (dword) sin16s::x#6 << (byte) 3
+  [115] (word) sin16s::x1#0 ← > (dword~) sin16s::$4
+  [116] (word) mulu16_sel::v1#0 ← (word) sin16s::x1#0
+  [117] (word) mulu16_sel::v2#0 ← (word) sin16s::x1#0
+  [118] call mulu16_sel 
+  [119] (word) mulu16_sel::return#0 ← (word) mulu16_sel::return#12
   to:sin16s::@7
 sin16s::@7: scope:[sin16s]  from sin16s::@2
-  [122] (word) sin16s::x2#0 ← (word) mulu16_sel::return#0
-  [123] (word) mulu16_sel::v1#1 ← (word) sin16s::x2#0
-  [124] (word) mulu16_sel::v2#1 ← (word) sin16s::x1#0
-  [125] call mulu16_sel 
-  [126] (word) mulu16_sel::return#1 ← (word) mulu16_sel::return#12
+  [120] (word) sin16s::x2#0 ← (word) mulu16_sel::return#0
+  [121] (word) mulu16_sel::v1#1 ← (word) sin16s::x2#0
+  [122] (word) mulu16_sel::v2#1 ← (word) sin16s::x1#0
+  [123] call mulu16_sel 
+  [124] (word) mulu16_sel::return#1 ← (word) mulu16_sel::return#12
   to:sin16s::@8
 sin16s::@8: scope:[sin16s]  from sin16s::@7
-  [127] (word) sin16s::x3#0 ← (word) mulu16_sel::return#1
-  [128] (word) mulu16_sel::v1#2 ← (word) sin16s::x3#0
-  [129] call mulu16_sel 
-  [130] (word) mulu16_sel::return#2 ← (word) mulu16_sel::return#12
+  [125] (word) sin16s::x3#0 ← (word) mulu16_sel::return#1
+  [126] (word) mulu16_sel::v1#2 ← (word) sin16s::x3#0
+  [127] call mulu16_sel 
+  [128] (word) mulu16_sel::return#2 ← (word) mulu16_sel::return#12
   to:sin16s::@9
 sin16s::@9: scope:[sin16s]  from sin16s::@8
-  [131] (word) sin16s::x3_6#0 ← (word) mulu16_sel::return#2
-  [132] (word) sin16s::usinx#0 ← (word) sin16s::x1#0 - (word) sin16s::x3_6#0
-  [133] (word) mulu16_sel::v1#3 ← (word) sin16s::x3#0
-  [134] (word) mulu16_sel::v2#3 ← (word) sin16s::x1#0
-  [135] call mulu16_sel 
-  [136] (word) mulu16_sel::return#10 ← (word) mulu16_sel::return#12
+  [129] (word) sin16s::x3_6#0 ← (word) mulu16_sel::return#2
+  [130] (word) sin16s::usinx#0 ← (word) sin16s::x1#0 - (word) sin16s::x3_6#0
+  [131] (word) mulu16_sel::v1#3 ← (word) sin16s::x3#0
+  [132] (word) mulu16_sel::v2#3 ← (word) sin16s::x1#0
+  [133] call mulu16_sel 
+  [134] (word) mulu16_sel::return#10 ← (word) mulu16_sel::return#12
   to:sin16s::@10
 sin16s::@10: scope:[sin16s]  from sin16s::@9
-  [137] (word) sin16s::x4#0 ← (word) mulu16_sel::return#10
-  [138] (word) mulu16_sel::v1#4 ← (word) sin16s::x4#0
-  [139] (word) mulu16_sel::v2#4 ← (word) sin16s::x1#0
-  [140] call mulu16_sel 
-  [141] (word) mulu16_sel::return#11 ← (word) mulu16_sel::return#12
+  [135] (word) sin16s::x4#0 ← (word) mulu16_sel::return#10
+  [136] (word) mulu16_sel::v1#4 ← (word) sin16s::x4#0
+  [137] (word) mulu16_sel::v2#4 ← (word) sin16s::x1#0
+  [138] call mulu16_sel 
+  [139] (word) mulu16_sel::return#11 ← (word) mulu16_sel::return#12
   to:sin16s::@11
 sin16s::@11: scope:[sin16s]  from sin16s::@10
-  [142] (word) sin16s::x5#0 ← (word) mulu16_sel::return#11
-  [143] (word) sin16s::x5_128#0 ← (word) sin16s::x5#0 >> (byte) 4
-  [144] (word) sin16s::usinx#1 ← (word) sin16s::usinx#0 + (word) sin16s::x5_128#0
-  [145] if((byte) sin16s::isUpper#2==(byte) 0) goto sin16s::@12
+  [140] (word) sin16s::x5#0 ← (word) mulu16_sel::return#11
+  [141] (word) sin16s::x5_128#0 ← (word) sin16s::x5#0 >> (byte) 4
+  [142] (word) sin16s::usinx#1 ← (word) sin16s::usinx#0 + (word) sin16s::x5_128#0
+  [143] if((byte) sin16s::isUpper#2==(byte) 0) goto sin16s::@12
   to:sin16s::@6
 sin16s::@6: scope:[sin16s]  from sin16s::@11
-  [146] (signed word) sin16s::sinx#1 ← - (signed word)(word) sin16s::usinx#1
+  [144] (signed word) sin16s::sinx#1 ← - (signed word)(word) sin16s::usinx#1
   to:sin16s::@3
 sin16s::@3: scope:[sin16s]  from sin16s::@12 sin16s::@6
-  [147] (signed word) sin16s::return#1 ← phi( sin16s::@12/(signed word~) sin16s::return#5 sin16s::@6/(signed word) sin16s::sinx#1 )
+  [145] (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
-  [148] return 
+  [146] return 
   to:@return
 sin16s::@12: scope:[sin16s]  from sin16s::@11
-  [149] (signed word~) sin16s::return#5 ← (signed word)(word) sin16s::usinx#1
+  [147] (signed word~) sin16s::return#5 ← (signed word)(word) sin16s::usinx#1
   to:sin16s::@3
 mulu16_sel: scope:[mulu16_sel]  from sin16s::@10 sin16s::@2 sin16s::@7 sin16s::@8 sin16s::@9
-  [150] (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 )
-  [150] (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 )
-  [150] (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 )
-  [151] (word) mul16u::a#2 ← (word) mulu16_sel::v1#5
-  [152] (word) mul16u::b#1 ← (word) mulu16_sel::v2#5
-  [153] call mul16u 
-  [154] (dword) mul16u::return#3 ← (dword) mul16u::res#2
+  [148] (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 )
+  [148] (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 )
+  [148] (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 )
+  [149] (word) mul16u::a#2 ← (word) mulu16_sel::v1#5
+  [150] (word) mul16u::b#1 ← (word) mulu16_sel::v2#5
+  [151] call mul16u 
+  [152] (dword) mul16u::return#3 ← (dword) mul16u::res#2
   to:mulu16_sel::@1
 mulu16_sel::@1: scope:[mulu16_sel]  from mulu16_sel
-  [155] (dword~) mulu16_sel::$0 ← (dword) mul16u::return#3
-  [156] (dword~) mulu16_sel::$1 ← (dword~) mulu16_sel::$0 << (byte) mulu16_sel::select#5
-  [157] (word) mulu16_sel::return#12 ← > (dword~) mulu16_sel::$1
+  [153] (dword~) mulu16_sel::$0 ← (dword) mul16u::return#3
+  [154] (dword~) mulu16_sel::$1 ← (dword~) mulu16_sel::$0 << (byte) mulu16_sel::select#5
+  [155] (word) mulu16_sel::return#12 ← > (dword~) mulu16_sel::$1
   to:mulu16_sel::@return
 mulu16_sel::@return: scope:[mulu16_sel]  from mulu16_sel::@1
-  [158] return 
+  [156] return 
   to:@return
 div32u16u: scope:[div32u16u]  from sin16s_gen2
-  [159] phi()
-  [160] call divr16u 
-  [161] (word) divr16u::return#2 ← (word) divr16u::return#0
+  [157] phi()
+  [158] call divr16u 
+  [159] (word) divr16u::return#2 ← (word) divr16u::return#0
   to:div32u16u::@1
 div32u16u::@1: scope:[div32u16u]  from div32u16u
-  [162] (word) div32u16u::quotient_hi#0 ← (word) divr16u::return#2
-  [163] (word) divr16u::rem#4 ← (word) rem16u#1
-  [164] call divr16u 
-  [165] (word) divr16u::return#3 ← (word) divr16u::return#0
+  [160] (word) div32u16u::quotient_hi#0 ← (word) divr16u::return#2
+  [161] (word) divr16u::rem#4 ← (word) rem16u#1
+  [162] call divr16u 
+  [163] (word) divr16u::return#3 ← (word) divr16u::return#0
   to:div32u16u::@2
 div32u16u::@2: scope:[div32u16u]  from div32u16u::@1
-  [166] (word) div32u16u::quotient_lo#0 ← (word) divr16u::return#3
-  [167] (dword) div32u16u::return#0 ← (word) div32u16u::quotient_hi#0 dw= (word) div32u16u::quotient_lo#0
+  [164] (word) div32u16u::quotient_lo#0 ← (word) divr16u::return#3
+  [165] (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
-  [168] return 
+  [166] return 
   to:@return
 divr16u: scope:[divr16u]  from div32u16u div32u16u::@1
-  [169] (word) divr16u::dividend#5 ← phi( div32u16u/>(const dword) PI2_u4f28#0 div32u16u::@1/<(const dword) PI2_u4f28#0 )
-  [169] (word) divr16u::rem#10 ← phi( div32u16u/(byte) 0 div32u16u::@1/(word) divr16u::rem#4 )
+  [167] (word) divr16u::dividend#5 ← phi( div32u16u/>(const dword) PI2_u4f28#0 div32u16u::@1/<(const dword) PI2_u4f28#0 )
+  [167] (word) divr16u::rem#10 ← phi( div32u16u/(byte) 0 div32u16u::@1/(word) divr16u::rem#4 )
   to:divr16u::@1
 divr16u::@1: scope:[divr16u]  from divr16u divr16u::@3
-  [170] (byte) divr16u::i#2 ← phi( divr16u/(byte) 0 divr16u::@3/(byte) divr16u::i#1 )
-  [170] (word) divr16u::quotient#3 ← phi( divr16u/(byte) 0 divr16u::@3/(word) divr16u::return#0 )
-  [170] (word) divr16u::dividend#3 ← phi( divr16u/(word) divr16u::dividend#5 divr16u::@3/(word) divr16u::dividend#0 )
-  [170] (word) divr16u::rem#5 ← phi( divr16u/(word) divr16u::rem#10 divr16u::@3/(word) divr16u::rem#11 )
-  [171] (word) divr16u::rem#0 ← (word) divr16u::rem#5 << (byte) 1
-  [172] (byte~) divr16u::$1 ← > (word) divr16u::dividend#3
-  [173] (byte~) divr16u::$2 ← (byte~) divr16u::$1 & (byte) $80
-  [174] if((byte~) divr16u::$2==(byte) 0) goto divr16u::@2
+  [168] (byte) divr16u::i#2 ← phi( divr16u/(byte) 0 divr16u::@3/(byte) divr16u::i#1 )
+  [168] (word) divr16u::quotient#3 ← phi( divr16u/(byte) 0 divr16u::@3/(word) divr16u::return#0 )
+  [168] (word) divr16u::dividend#3 ← phi( divr16u/(word) divr16u::dividend#5 divr16u::@3/(word) divr16u::dividend#0 )
+  [168] (word) divr16u::rem#5 ← phi( divr16u/(word) divr16u::rem#10 divr16u::@3/(word) divr16u::rem#11 )
+  [169] (word) divr16u::rem#0 ← (word) divr16u::rem#5 << (byte) 1
+  [170] (byte~) divr16u::$1 ← > (word) divr16u::dividend#3
+  [171] (byte~) divr16u::$2 ← (byte~) divr16u::$1 & (byte) $80
+  [172] if((byte~) divr16u::$2==(byte) 0) goto divr16u::@2
   to:divr16u::@4
 divr16u::@4: scope:[divr16u]  from divr16u::@1
-  [175] (word) divr16u::rem#1 ← (word) divr16u::rem#0 | (byte) 1
+  [173] (word) divr16u::rem#1 ← (word) divr16u::rem#0 | (byte) 1
   to:divr16u::@2
 divr16u::@2: scope:[divr16u]  from divr16u::@1 divr16u::@4
-  [176] (word) divr16u::rem#6 ← phi( divr16u::@1/(word) divr16u::rem#0 divr16u::@4/(word) divr16u::rem#1 )
-  [177] (word) divr16u::dividend#0 ← (word) divr16u::dividend#3 << (byte) 1
-  [178] (word) divr16u::quotient#1 ← (word) divr16u::quotient#3 << (byte) 1
-  [179] if((word) divr16u::rem#6<(const word) SIN_SIZE#0) goto divr16u::@3
+  [174] (word) divr16u::rem#6 ← phi( divr16u::@1/(word) divr16u::rem#0 divr16u::@4/(word) divr16u::rem#1 )
+  [175] (word) divr16u::dividend#0 ← (word) divr16u::dividend#3 << (byte) 1
+  [176] (word) divr16u::quotient#1 ← (word) divr16u::quotient#3 << (byte) 1
+  [177] if((word) divr16u::rem#6<(const word) SIN_SIZE#0) goto divr16u::@3
   to:divr16u::@5
 divr16u::@5: scope:[divr16u]  from divr16u::@2
-  [180] (word) divr16u::quotient#2 ← ++ (word) divr16u::quotient#1
-  [181] (word) divr16u::rem#2 ← (word) divr16u::rem#6 - (const word) SIN_SIZE#0
+  [178] (word) divr16u::quotient#2 ← ++ (word) divr16u::quotient#1
+  [179] (word) divr16u::rem#2 ← (word) divr16u::rem#6 - (const word) SIN_SIZE#0
   to:divr16u::@3
 divr16u::@3: scope:[divr16u]  from divr16u::@2 divr16u::@5
-  [182] (word) divr16u::return#0 ← phi( divr16u::@2/(word) divr16u::quotient#1 divr16u::@5/(word) divr16u::quotient#2 )
-  [182] (word) divr16u::rem#11 ← phi( divr16u::@2/(word) divr16u::rem#6 divr16u::@5/(word) divr16u::rem#2 )
-  [183] (byte) divr16u::i#1 ← ++ (byte) divr16u::i#2
-  [184] if((byte) divr16u::i#1!=(byte) $10) goto divr16u::@1
+  [180] (word) divr16u::return#0 ← phi( divr16u::@2/(word) divr16u::quotient#1 divr16u::@5/(word) divr16u::quotient#2 )
+  [180] (word) divr16u::rem#11 ← phi( divr16u::@2/(word) divr16u::rem#6 divr16u::@5/(word) divr16u::rem#2 )
+  [181] (byte) divr16u::i#1 ← ++ (byte) divr16u::i#2
+  [182] if((byte) divr16u::i#1!=(byte) $10) goto divr16u::@1
   to:divr16u::@6
 divr16u::@6: scope:[divr16u]  from divr16u::@3
-  [185] (word) rem16u#1 ← (word) divr16u::rem#11
+  [183] (word) rem16u#1 ← (word) divr16u::rem#11
   to:divr16u::@return
 divr16u::@return: scope:[divr16u]  from divr16u::@6
-  [186] return 
+  [184] return 
   to:@return
-bitmap_clear: scope:[bitmap_clear]  from main::@5
-  [187] (word~) bitmap_clear::$3 ← *((const byte[$100]) bitmap_plot_yhi#0) w= *((const byte[$100]) bitmap_plot_ylo#0)
-  [188] (byte*~) bitmap_clear::bitmap#5 ← (byte*)(word~) bitmap_clear::$3
+bitmap_clear: scope:[bitmap_clear]  from main::@4
+  [185] phi()
+  [186] call memset 
   to:bitmap_clear::@1
-bitmap_clear::@1: scope:[bitmap_clear]  from bitmap_clear bitmap_clear::@3
-  [189] (byte) bitmap_clear::y#4 ← phi( bitmap_clear/(byte) 0 bitmap_clear::@3/(byte) bitmap_clear::y#1 )
-  [189] (byte*) bitmap_clear::bitmap#3 ← phi( bitmap_clear/(byte*~) bitmap_clear::bitmap#5 bitmap_clear::@3/(byte*) bitmap_clear::bitmap#1 )
-  to:bitmap_clear::@2
-bitmap_clear::@2: scope:[bitmap_clear]  from bitmap_clear::@1 bitmap_clear::@2
-  [190] (byte) bitmap_clear::x#2 ← phi( bitmap_clear::@1/(byte) 0 bitmap_clear::@2/(byte) bitmap_clear::x#1 )
-  [190] (byte*) bitmap_clear::bitmap#2 ← phi( bitmap_clear::@1/(byte*) bitmap_clear::bitmap#3 bitmap_clear::@2/(byte*) bitmap_clear::bitmap#1 )
-  [191] *((byte*) bitmap_clear::bitmap#2) ← (byte) 0
-  [192] (byte*) bitmap_clear::bitmap#1 ← ++ (byte*) bitmap_clear::bitmap#2
-  [193] (byte) bitmap_clear::x#1 ← ++ (byte) bitmap_clear::x#2
-  [194] if((byte) bitmap_clear::x#1!=(byte) $c8) goto bitmap_clear::@2
-  to:bitmap_clear::@3
-bitmap_clear::@3: scope:[bitmap_clear]  from bitmap_clear::@2
-  [195] (byte) bitmap_clear::y#1 ← ++ (byte) bitmap_clear::y#4
-  [196] if((byte) bitmap_clear::y#1!=(byte) $28) goto bitmap_clear::@1
+bitmap_clear::@1: scope:[bitmap_clear]  from bitmap_clear
+  [187] phi()
+  [188] call memset 
   to:bitmap_clear::@return
-bitmap_clear::@return: scope:[bitmap_clear]  from bitmap_clear::@3
+bitmap_clear::@return: scope:[bitmap_clear]  from bitmap_clear::@1
+  [189] return 
+  to:@return
+memset: scope:[memset]  from bitmap_clear bitmap_clear::@1
+  [190] (byte) memset::c#3 ← phi( bitmap_clear/(const byte) bitmap_clear::col#0 bitmap_clear::@1/(byte) 0 )
+  [190] (word) memset::num#2 ← phi( bitmap_clear/(word) $3e8 bitmap_clear::@1/(word) $1f40 )
+  [190] (void*) memset::str#2 ← phi( bitmap_clear/(void*)(const byte*) SCREEN#0 bitmap_clear::@1/(void*)(const byte*) BITMAP#0 )
+  [191] (byte*) memset::end#0 ← (byte*)(void*) memset::str#2 + (word) memset::num#2
+  [192] (byte*~) memset::dst#3 ← (byte*)(void*) memset::str#2
+  to:memset::@1
+memset::@1: scope:[memset]  from memset memset::@1
+  [193] (byte*) memset::dst#2 ← phi( memset/(byte*~) memset::dst#3 memset::@1/(byte*) memset::dst#1 )
+  [194] *((byte*) memset::dst#2) ← (byte) memset::c#3
+  [195] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2
+  [196] if((byte*) memset::dst#1!=(byte*) memset::end#0) goto memset::@1
+  to:memset::@return
+memset::@return: scope:[memset]  from memset::@1
   [197] return 
   to:@return
-bitmap_init: scope:[bitmap_init]  from main::@4
+bitmap_init: scope:[bitmap_init]  from main::@3
   [198] phi()
   to:bitmap_init::@1
 bitmap_init::@1: scope:[bitmap_init]  from bitmap_init bitmap_init::@2
@@ -427,15 +427,3 @@ bitmap_init::@4: scope:[bitmap_init]  from bitmap_init::@3 bitmap_init::@5
 bitmap_init::@return: scope:[bitmap_init]  from bitmap_init::@4
   [219] return 
   to:@return
-memset: scope:[memset]  from main::@3
-  [220] phi()
-  to:memset::@1
-memset::@1: scope:[memset]  from memset memset::@1
-  [221] (byte*) memset::dst#2 ← phi( memset/(byte*)(const void*) memset::str#0 memset::@1/(byte*) memset::dst#1 )
-  [222] *((byte*) memset::dst#2) ← (const byte) WHITE#0
-  [223] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2
-  [224] if((byte*) memset::dst#1!=(const byte*) memset::end#0) goto memset::@1
-  to:memset::@return
-memset::@return: scope:[memset]  from memset::@1
-  [225] return 
-  to:@return

src/test/ref/examples/sinplotter/sine-plotter.sym

@@ -6,6 +6,7 @@
 (const byte*) BGCOL#0 BGCOL = (byte*) 53281
 (byte*) BITMAP
 (const byte*) BITMAP#0 BITMAP = (byte*) 8192
+(byte) BLACK
 (byte*) CIA2_PORT_A
 (const byte*) CIA2_PORT_A#0 CIA2_PORT_A = (byte*) 56576
 (byte*) CIA2_PORT_A_DDR
@@ -45,28 +46,19 @@
 (const byte) VIC_RSEL#0 VIC_RSEL = (byte) 8
 (byte) WHITE
 (const byte) WHITE#0 WHITE = (byte) 1
-(void()) bitmap_clear()
-(word~) bitmap_clear::$3 $3 zp ZP_WORD:44 2.0
+(void()) bitmap_clear((byte) bitmap_clear::bgcol , (byte) bitmap_clear::fgcol)
 (label) bitmap_clear::@1
-(label) bitmap_clear::@2
-(label) bitmap_clear::@3
 (label) bitmap_clear::@return
-(byte*) bitmap_clear::bitmap
-(byte*) bitmap_clear::bitmap#1 bitmap zp ZP_WORD:44 42.599999999999994
-(byte*) bitmap_clear::bitmap#2 bitmap zp ZP_WORD:44 157.0
-(byte*) bitmap_clear::bitmap#3 bitmap zp ZP_WORD:44 24.0
-(byte*~) bitmap_clear::bitmap#5 bitmap zp ZP_WORD:44 4.0
-(byte) bitmap_clear::x
-(byte) bitmap_clear::x#1 reg byte x 151.5
-(byte) bitmap_clear::x#2 reg byte x 67.33333333333333
-(byte) bitmap_clear::y
-(byte) bitmap_clear::y#1 y zp ZP_BYTE:43 16.5
-(byte) bitmap_clear::y#4 y zp ZP_BYTE:43 3.6666666666666665
-(void()) bitmap_init((byte*) bitmap_init::bitmap)
+(byte) bitmap_clear::bgcol
+(byte) bitmap_clear::col
+(const byte) bitmap_clear::col#0 col = (const byte) WHITE#0*(byte) $10
+(byte) bitmap_clear::fgcol
+(byte*) bitmap_gfx
+(void()) bitmap_init((byte*) bitmap_init::gfx , (byte*) bitmap_init::screen)
 (byte~) bitmap_init::$4 reg byte a 22.0
 (byte~) bitmap_init::$5 reg byte a 22.0
 (byte~) bitmap_init::$6 reg byte a 22.0
-(byte~) bitmap_init::$7 $7 zp ZP_BYTE:68 5.5
+(byte~) bitmap_init::$7 $7 zp ZP_BYTE:67 5.5
 (label) bitmap_init::@1
 (label) bitmap_init::@2
 (label) bitmap_init::@3
@@ -74,11 +66,12 @@
 (label) bitmap_init::@5
 (label) bitmap_init::@6
 (label) bitmap_init::@return
-(byte*) bitmap_init::bitmap
 (byte) bitmap_init::bits
 (byte) bitmap_init::bits#1 reg byte a 11.0
 (byte) bitmap_init::bits#3 reg byte a 16.5
 (byte) bitmap_init::bits#4 reg byte a 7.333333333333333
+(byte*) bitmap_init::gfx
+(byte*) bitmap_init::screen
 (byte) bitmap_init::x
 (byte) bitmap_init::x#1 reg byte x 16.5
 (byte) bitmap_init::x#2 reg byte x 5.5
@@ -86,16 +79,16 @@
 (byte) bitmap_init::y#1 reg byte x 16.5
 (byte) bitmap_init::y#2 reg byte x 5.5
 (byte*) bitmap_init::yoffs
-(byte*) bitmap_init::yoffs#1 yoffs zp ZP_WORD:46 22.0
-(byte*) bitmap_init::yoffs#2 yoffs zp ZP_WORD:46 6.875
-(byte*) bitmap_init::yoffs#4 yoffs zp ZP_WORD:46 11.0
+(byte*) bitmap_init::yoffs#1 yoffs zp ZP_WORD:47 22.0
+(byte*) bitmap_init::yoffs#2 yoffs zp ZP_WORD:47 6.875
+(byte*) bitmap_init::yoffs#4 yoffs zp ZP_WORD:47 11.0
 (void()) bitmap_plot((word) bitmap_plot::x , (byte) bitmap_plot::y)
-(word~) bitmap_plot::$1 $1 zp ZP_WORD:52 4.0
+(word~) bitmap_plot::$1 $1 zp ZP_WORD:51 4.0
 (byte~) bitmap_plot::$2 reg byte a 4.0
-(word~) bitmap_plot::$3 $3 zp ZP_WORD:50 1.0
+(word~) bitmap_plot::$3 $3 zp ZP_WORD:49 1.0
 (label) bitmap_plot::@return
 (byte*) bitmap_plot::plotter
-(byte*) bitmap_plot::plotter#1 plotter zp ZP_WORD:50 3.0
+(byte*) bitmap_plot::plotter#1 plotter zp ZP_WORD:49 3.0
 (word) bitmap_plot::x
 (word) bitmap_plot::x#0 x zp ZP_WORD:4 11.0
 (word) bitmap_plot::x#1 x zp ZP_WORD:4 11.0
@@ -110,6 +103,7 @@
 (const byte[$100]) bitmap_plot_yhi#0 bitmap_plot_yhi = { fill( $100, 0) }
 (byte[$100]) bitmap_plot_ylo
 (const byte[$100]) bitmap_plot_ylo#0 bitmap_plot_ylo = { fill( $100, 0) }
+(byte*) bitmap_screen
 (dword()) div32u16u((dword) div32u16u::dividend , (word) div32u16u::divisor)
 (label) div32u16u::@1
 (label) div32u16u::@2
@@ -118,12 +112,12 @@
 (word) div32u16u::divisor
 (dword) div32u16u::quotient
 (word) div32u16u::quotient_hi
-(word) div32u16u::quotient_hi#0 quotient_hi zp ZP_WORD:66 0.8
+(word) div32u16u::quotient_hi#0 quotient_hi zp ZP_WORD:65 0.8
 (word) div32u16u::quotient_lo
 (word) div32u16u::quotient_lo#0 quotient_lo zp ZP_WORD:41 4.0
 (dword) div32u16u::return
-(dword) div32u16u::return#0 return zp ZP_DWORD:54 1.3333333333333333
-(dword) div32u16u::return#2 return zp ZP_DWORD:54 4.0
+(dword) div32u16u::return#0 return zp ZP_DWORD:53 1.3333333333333333
+(dword) div32u16u::return#2 return zp ZP_DWORD:53 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
@@ -166,7 +160,6 @@
 (label) main::@4
 (label) main::@5
 (label) main::@6
-(label) main::@7
 (label) main::toD0181
 (word~) main::toD0181_$0
 (number~) main::toD0181_$1
@@ -197,19 +190,21 @@
 (label) memset::@1
 (label) memset::@return
 (byte) memset::c
+(byte) memset::c#3 reg byte x 1.5714285714285714
 (byte*) memset::dst
-(byte*) memset::dst#1 dst zp ZP_WORD:48 16.5
-(byte*) memset::dst#2 dst zp ZP_WORD:48 16.5
+(byte*) memset::dst#1 dst zp ZP_WORD:43 16.5
+(byte*) memset::dst#2 dst zp ZP_WORD:43 17.5
+(byte*~) memset::dst#3 dst zp ZP_WORD:43 4.0
 (byte*) memset::end
-(const byte*) memset::end#0 end = (byte*)(const void*) memset::str#0+(const word) memset::num#0
+(byte*) memset::end#0 end zp ZP_WORD:45 2.1666666666666665
 (word) memset::num
-(const word) memset::num#0 num = (word) $3e8
+(word) memset::num#2 num zp ZP_WORD:45 2.0
 (void*) memset::return
 (void*) memset::str
-(const void*) memset::str#0 str = (void*)(const byte*) SCREEN#0
+(void*) memset::str#2 str zp ZP_WORD:43
 (signed dword()) mul16s((signed word) mul16s::a , (signed word) mul16s::b)
-(word~) mul16s::$16 $16 zp ZP_WORD:60 4.0
-(word~) mul16s::$9 $9 zp ZP_WORD:60 4.0
+(word~) mul16s::$16 $16 zp ZP_WORD:59 4.0
+(word~) mul16s::$9 $9 zp ZP_WORD:59 4.0
 (label) mul16s::@1
 (label) mul16s::@2
 (label) mul16s::@3
@@ -257,12 +252,12 @@
 (label) mulu16_sel::@1
 (label) mulu16_sel::@return
 (word) mulu16_sel::return
-(word) mulu16_sel::return#0 return zp ZP_WORD:64 4.0
+(word) mulu16_sel::return#0 return zp ZP_WORD:63 4.0
 (word) mulu16_sel::return#1 return#1 zp ZP_WORD:35 4.0
 (word) mulu16_sel::return#10 return#10 zp ZP_WORD:35 4.0
-(word) mulu16_sel::return#11 return zp ZP_WORD:64 4.0
-(word) mulu16_sel::return#12 return zp ZP_WORD:64 1.714285714285714
-(word) mulu16_sel::return#2 return zp ZP_WORD:64 4.0
+(word) mulu16_sel::return#11 return zp ZP_WORD:63 4.0
+(word) mulu16_sel::return#12 return zp ZP_WORD:63 1.714285714285714
+(word) mulu16_sel::return#2 return zp ZP_WORD:63 4.0
 (byte) mulu16_sel::select
 (byte) mulu16_sel::select#5 reg byte x 0.3333333333333333
 (word) mulu16_sel::v1
@@ -343,22 +338,22 @@
 (dword) sin16s::x#4 x zp ZP_DWORD:29 5.0
 (dword) sin16s::x#6 x zp ZP_DWORD:29 6.0
 (word) sin16s::x1
-(word) sin16s::x1#0 x1 zp ZP_WORD:62 0.6363636363636365
+(word) sin16s::x1#0 x1 zp ZP_WORD:61 0.6363636363636365
 (word) sin16s::x2
 (word) sin16s::x2#0 x2 zp ZP_WORD:35 4.0
 (word) sin16s::x3
 (word) sin16s::x3#0 x3 zp ZP_WORD:35 1.0
 (word) sin16s::x3_6
-(word) sin16s::x3_6#0 x3_6 zp ZP_WORD:64 4.0
+(word) sin16s::x3_6#0 x3_6 zp ZP_WORD:63 4.0
 (word) sin16s::x4
 (word) sin16s::x4#0 x4 zp ZP_WORD:35 4.0
 (word) sin16s::x5
-(word) sin16s::x5#0 x5 zp ZP_WORD:64 4.0
+(word) sin16s::x5#0 x5 zp ZP_WORD:63 4.0
 (word) sin16s::x5_128
-(word) sin16s::x5_128#0 x5_128 zp ZP_WORD:64 4.0
+(word) sin16s::x5_128#0 x5_128 zp ZP_WORD:63 4.0
 (void()) sin16s_gen2((signed word*) sin16s_gen2::sintab , (word) sin16s_gen2::wavelength , (signed word) sin16s_gen2::min , (signed word) sin16s_gen2::max)
 (signed dword~) sin16s_gen2::$5 $5 zp ZP_DWORD:16 22.0
-(word~) sin16s_gen2::$6 $6 zp ZP_WORD:58 11.0
+(word~) sin16s_gen2::$6 $6 zp ZP_WORD:57 11.0
 (label) sin16s_gen2::@1
 (label) sin16s_gen2::@2
 (label) sin16s_gen2::@3
@@ -378,7 +373,7 @@
 (signed word*) sin16s_gen2::sintab#0 sintab zp ZP_WORD:12 5.5
 (signed word*) sin16s_gen2::sintab#2 sintab zp ZP_WORD:12 3.3000000000000003
 (dword) sin16s_gen2::step
-(dword) sin16s_gen2::step#0 step zp ZP_DWORD:54 0.8666666666666666
+(dword) sin16s_gen2::step#0 step zp ZP_DWORD:53 0.8666666666666666
 (word) sin16s_gen2::wavelength
 (dword) sin16s_gen2::x
 (dword) sin16s_gen2::x#1 x zp ZP_DWORD:8 7.333333333333333
@@ -425,32 +420,31 @@ zp ZP_WORD:37 [ divr16u::rem#5 divr16u::rem#10 divr16u::rem#4 divr16u::rem#11 di
 zp ZP_WORD:39 [ divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#0 ]
 zp ZP_WORD:41 [ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 divr16u::return#2 divr16u::return#3 div32u16u::quotient_lo#0 ]
 reg byte x [ divr16u::i#2 divr16u::i#1 ]
-zp ZP_BYTE:43 [ bitmap_clear::y#4 bitmap_clear::y#1 ]
-zp ZP_WORD:44 [ bitmap_clear::bitmap#2 bitmap_clear::bitmap#3 bitmap_clear::bitmap#5 bitmap_clear::bitmap#1 bitmap_clear::$3 ]
-reg byte x [ bitmap_clear::x#2 bitmap_clear::x#1 ]
+zp ZP_WORD:43 [ memset::str#2 memset::dst#2 memset::dst#3 memset::dst#1 ]
+zp ZP_WORD:45 [ memset::num#2 memset::end#0 ]
+reg byte x [ memset::c#3 ]
 reg byte a [ bitmap_init::bits#3 bitmap_init::bits#4 bitmap_init::bits#1 ]
 reg byte x [ bitmap_init::x#2 bitmap_init::x#1 ]
 reg byte x [ bitmap_init::y#2 bitmap_init::y#1 ]
-zp ZP_WORD:46 [ bitmap_init::yoffs#2 bitmap_init::yoffs#4 bitmap_init::yoffs#1 ]
-zp ZP_WORD:48 [ memset::dst#2 memset::dst#1 ]
+zp ZP_WORD:47 [ bitmap_init::yoffs#2 bitmap_init::yoffs#4 bitmap_init::yoffs#1 ]
 reg byte a [ wrap_y::return#0 ]
 reg byte x [ render_sine::ypos#0 ]
 reg byte a [ wrap_y::return#1 ]
 reg byte x [ render_sine::ypos2#0 ]
-zp ZP_WORD:50 [ bitmap_plot::$3 bitmap_plot::plotter#1 ]
-zp ZP_WORD:52 [ bitmap_plot::$1 ]
+zp ZP_WORD:49 [ bitmap_plot::$3 bitmap_plot::plotter#1 ]
+zp ZP_WORD:51 [ bitmap_plot::$1 ]
 reg byte a [ bitmap_plot::$2 ]
 reg byte a [ wrap_y::return#2 ]
-zp ZP_DWORD:54 [ div32u16u::return#2 sin16s_gen2::step#0 div32u16u::return#0 ]
-zp ZP_WORD:58 [ sin16s_gen2::$6 ]
-zp ZP_WORD:60 [ mul16s::$9 mul16s::$16 ]
+zp ZP_DWORD:53 [ div32u16u::return#2 sin16s_gen2::step#0 div32u16u::return#0 ]
+zp ZP_WORD:57 [ sin16s_gen2::$6 ]
+zp ZP_WORD:59 [ mul16s::$9 mul16s::$16 ]
 reg byte a [ mul16u::$1 ]
-zp ZP_WORD:62 [ sin16s::x1#0 ]
-zp ZP_WORD:64 [ 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 ]
-zp ZP_WORD:66 [ div32u16u::quotient_hi#0 ]
+zp ZP_WORD:61 [ sin16s::x1#0 ]
+zp ZP_WORD:63 [ 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 ]
+zp ZP_WORD:65 [ div32u16u::quotient_hi#0 ]
 reg byte a [ divr16u::$1 ]
 reg byte a [ divr16u::$2 ]
-zp ZP_BYTE:68 [ bitmap_init::$7 ]
+zp ZP_BYTE:67 [ bitmap_init::$7 ]
 reg byte a [ bitmap_init::$4 ]
 reg byte a [ bitmap_init::$5 ]
 reg byte a [ bitmap_init::$6 ]

src/test/ref/sandbox.asm

@@ -594,15 +594,17 @@ div10: {
     lda val_1+1
     adc val+1
     sta val_1+1
+    lsr
     sta _3+1
     lda val_1
+    ror
     sta _3
-    ldy #4
-  !:
     lsr _3+1
     ror _3
-    dey
-    bne !-
+    lsr _3+1
+    ror _3
+    lsr _3+1
+    ror _3
     lda val_2
     clc
     adc val_1

src/test/ref/sandbox.log

@@ -5658,15 +5658,17 @@ div10: {
     sta val_1+1
   //SEG416 [186] (word~) div10::$3 ← (word) div10::val#1 >> (byte) 4 -- vwuz1=vwuz2_ror_4 
     lda val_1+1
+    lsr
     sta _3+1
     lda val_1
+    ror
     sta _3
-    ldy #4
-  !:
     lsr _3+1
     ror _3
-    dey
-    bne !-
+    lsr _3+1
+    ror _3
+    lsr _3+1
+    ror _3
   //SEG417 [187] (word) div10::val#2 ← (word) div10::val#1 + (word~) div10::$3 -- vwuz1=vwuz2_plus_vwuz3 
     lda val_1
     clc
@@ -5699,15 +5701,17 @@ div10: {
     sta val_3+1
   //SEG420 [190] (word) div10::return#0 ← (word) div10::val#3 >> (byte) 4 -- vwuz1=vwuz2_ror_4 
     lda val_3+1
+    lsr
     sta return+1
     lda val_3
+    ror
     sta return
-    ldy #4
-  !:
     lsr return+1
     ror return
-    dey
-    bne !-
+    lsr return+1
+    ror return
+    lsr return+1
+    ror return
     jmp breturn
   //SEG421 div10::@return
   breturn:
@@ -5976,11 +5980,11 @@ Statement [182] (word~) div10::$0 ← (word) div10::val#4 >> (byte) 1 [ div10::$
 Statement [183] (word) div10::val#0 ← (word~) div10::$0 + (byte) 1 [ div10::val#0 ] ( main:2::div10:34 [ main::u#15 div10::val#0 ] ) always clobbers reg byte a 
 Statement [184] (word~) div10::$2 ← (word) div10::val#0 << (byte) 1 [ div10::val#0 div10::$2 ] ( main:2::div10:34 [ main::u#15 div10::val#0 div10::$2 ] ) always clobbers reg byte a 
 Statement [185] (word) div10::val#1 ← (word) div10::val#0 + (word~) div10::$2 [ div10::val#1 ] ( main:2::div10:34 [ main::u#15 div10::val#1 ] ) always clobbers reg byte a 
-Statement [186] (word~) div10::$3 ← (word) div10::val#1 >> (byte) 4 [ div10::val#1 div10::$3 ] ( main:2::div10:34 [ main::u#15 div10::val#1 div10::$3 ] ) always clobbers reg byte a reg byte y 
+Statement [186] (word~) div10::$3 ← (word) div10::val#1 >> (byte) 4 [ div10::val#1 div10::$3 ] ( main:2::div10:34 [ main::u#15 div10::val#1 div10::$3 ] ) always clobbers reg byte a 
 Statement [187] (word) div10::val#2 ← (word) div10::val#1 + (word~) div10::$3 [ div10::val#2 ] ( main:2::div10:34 [ main::u#15 div10::val#2 ] ) always clobbers reg byte a 
 Statement [188] (word~) div10::$4 ← (word) div10::val#2 >> (byte) 8 [ div10::val#2 div10::$4 ] ( main:2::div10:34 [ main::u#15 div10::val#2 div10::$4 ] ) always clobbers reg byte a reg byte y 
 Statement [189] (word) div10::val#3 ← (word) div10::val#2 + (word~) div10::$4 [ div10::val#3 ] ( main:2::div10:34 [ main::u#15 div10::val#3 ] ) always clobbers reg byte a 
-Statement [190] (word) div10::return#0 ← (word) div10::val#3 >> (byte) 4 [ div10::return#0 ] ( main:2::div10:34 [ main::u#15 div10::return#0 ] ) always clobbers reg byte a reg byte y 
+Statement [190] (word) div10::return#0 ← (word) div10::val#3 >> (byte) 4 [ div10::return#0 ] ( main:2::div10:34 [ main::u#15 div10::return#0 ] ) always clobbers reg byte a 
 Statement [192] (word) divr16u::dividend#1 ← (word) div16u::dividend#0 [ divr16u::dividend#1 ] ( main:2::div16u:11 [ main::u#11 divr16u::dividend#1 ] ) always clobbers reg byte a 
 Statement [194] (word) divr16u::return#2 ← (word) divr16u::return#0 [ divr16u::return#2 ] ( main:2::div16u:11 [ main::u#11 divr16u::return#2 ] ) always clobbers reg byte a 
 Statement [195] (word) div16u::return#0 ← (word) divr16u::return#2 [ div16u::return#0 ] ( main:2::div16u:11 [ main::u#11 div16u::return#0 ] ) always clobbers reg byte a 
@@ -6071,11 +6075,11 @@ Statement [182] (word~) div10::$0 ← (word) div10::val#4 >> (byte) 1 [ div10::$
 Statement [183] (word) div10::val#0 ← (word~) div10::$0 + (byte) 1 [ div10::val#0 ] ( main:2::div10:34 [ main::u#15 div10::val#0 ] ) always clobbers reg byte a 
 Statement [184] (word~) div10::$2 ← (word) div10::val#0 << (byte) 1 [ div10::val#0 div10::$2 ] ( main:2::div10:34 [ main::u#15 div10::val#0 div10::$2 ] ) always clobbers reg byte a 
 Statement [185] (word) div10::val#1 ← (word) div10::val#0 + (word~) div10::$2 [ div10::val#1 ] ( main:2::div10:34 [ main::u#15 div10::val#1 ] ) always clobbers reg byte a 
-Statement [186] (word~) div10::$3 ← (word) div10::val#1 >> (byte) 4 [ div10::val#1 div10::$3 ] ( main:2::div10:34 [ main::u#15 div10::val#1 div10::$3 ] ) always clobbers reg byte a reg byte y 
+Statement [186] (word~) div10::$3 ← (word) div10::val#1 >> (byte) 4 [ div10::val#1 div10::$3 ] ( main:2::div10:34 [ main::u#15 div10::val#1 div10::$3 ] ) always clobbers reg byte a 
 Statement [187] (word) div10::val#2 ← (word) div10::val#1 + (word~) div10::$3 [ div10::val#2 ] ( main:2::div10:34 [ main::u#15 div10::val#2 ] ) always clobbers reg byte a 
 Statement [188] (word~) div10::$4 ← (word) div10::val#2 >> (byte) 8 [ div10::val#2 div10::$4 ] ( main:2::div10:34 [ main::u#15 div10::val#2 div10::$4 ] ) always clobbers reg byte a reg byte y 
 Statement [189] (word) div10::val#3 ← (word) div10::val#2 + (word~) div10::$4 [ div10::val#3 ] ( main:2::div10:34 [ main::u#15 div10::val#3 ] ) always clobbers reg byte a 
-Statement [190] (word) div10::return#0 ← (word) div10::val#3 >> (byte) 4 [ div10::return#0 ] ( main:2::div10:34 [ main::u#15 div10::return#0 ] ) always clobbers reg byte a reg byte y 
+Statement [190] (word) div10::return#0 ← (word) div10::val#3 >> (byte) 4 [ div10::return#0 ] ( main:2::div10:34 [ main::u#15 div10::return#0 ] ) always clobbers reg byte a 
 Statement [192] (word) divr16u::dividend#1 ← (word) div16u::dividend#0 [ divr16u::dividend#1 ] ( main:2::div16u:11 [ main::u#11 divr16u::dividend#1 ] ) always clobbers reg byte a 
 Statement [194] (word) divr16u::return#2 ← (word) divr16u::return#0 [ divr16u::return#2 ] ( main:2::div16u:11 [ main::u#11 divr16u::return#2 ] ) always clobbers reg byte a 
 Statement [195] (word) div16u::return#0 ← (word) divr16u::return#2 [ div16u::return#0 ] ( main:2::div16u:11 [ main::u#11 div16u::return#0 ] ) always clobbers reg byte a 
@@ -6165,56 +6169,56 @@ Uplift Scope [utoa] 57.17: zp ZP_WORD:29 [ utoa::value#12 utoa::value#3 utoa::va
 Uplift Scope [Print] 
 Uplift Scope [] 
 
-Uplifting [divr16u] best 466472 combination zp ZP_WORD:39 [ divr16u::rem#4 divr16u::rem#9 divr16u::rem#5 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 ] zp ZP_WORD:43 [ 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 ZP_WORD:41 [ divr16u::dividend#2 divr16u::dividend#1 divr16u::dividend#0 ] zp ZP_WORD:109 [ divr16u::return#2 ] 
-Uplifting [append] best 466472 combination zp ZP_WORD:37 [ append::value#5 append::value#8 append::value#1 append::value#2 append::value#3 append::value#4 append::value#0 ] zp ZP_WORD:33 [ append::dst#4 append::dst#1 append::dst#2 append::dst#3 ] zp ZP_WORD:35 [ append::sub#6 ] zp ZP_WORD:83 [ append::return#10 ] zp ZP_WORD:85 [ append::return#4 ] zp ZP_WORD:87 [ append::return#3 ] zp ZP_WORD:89 [ append::return#2 ] 
-Uplifting [div10] best 466472 combination zp ZP_WORD:60 [ div10::return#2 ] zp ZP_WORD:58 [ div10::val#4 ] zp ZP_WORD:107 [ div10::return#0 ] zp ZP_WORD:91 [ div10::$0 ] zp ZP_WORD:95 [ div10::$2 ] zp ZP_WORD:99 [ div10::$3 ] zp ZP_WORD:103 [ div10::$4 ] zp ZP_WORD:105 [ div10::val#3 ] zp ZP_WORD:93 [ div10::val#0 ] zp ZP_WORD:97 [ div10::val#1 ] zp ZP_WORD:101 [ div10::val#2 ] 
-Uplifting [div16u] best 466472 combination zp ZP_WORD:48 [ div16u::return#2 ] zp ZP_WORD:46 [ div16u::dividend#0 ] zp ZP_WORD:111 [ div16u::return#0 ] 
-Uplifting [main] best 466472 combination zp ZP_WORD:52 [ main::$2 ] zp ZP_WORD:56 [ main::$4 ] zp ZP_WORD:64 [ main::$11 ] zp ZP_WORD:68 [ main::$13 ] zp ZP_WORD:2 [ main::u#11 main::u#2 ] zp ZP_WORD:4 [ main::u#15 main::u#4 ] zp ZP_WORD:50 [ main::v#1 ] zp ZP_WORD:62 [ main::v#2 ] zp ZP_WORD:54 [ main::$3 ] zp ZP_WORD:66 [ main::$12 ] 
-Uplifting [utoa] best 466441 combination zp ZP_WORD:29 [ utoa::value#12 utoa::value#3 utoa::value#10 utoa::value#2 utoa::value#11 utoa::value#6 utoa::value#4 utoa::value#0 utoa::value#1 ] zp ZP_WORD:31 [ utoa::dst#12 utoa::dst#4 utoa::dst#13 utoa::dst#2 utoa::dst#10 utoa::dst#16 utoa::dst#1 ] reg byte x [ utoa::bStarted#7 utoa::bStarted#6 utoa::bStarted#5 ] reg byte a [ utoa::$16 ] reg byte a [ utoa::$17 ] zp ZP_WORD:81 [ utoa::dst#3 ] 
-Uplifting [Print] best 466441 combination 
-Uplifting [] best 466441 combination 
+Uplifting [divr16u] best 466508 combination zp ZP_WORD:39 [ divr16u::rem#4 divr16u::rem#9 divr16u::rem#5 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 ] zp ZP_WORD:43 [ 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 ZP_WORD:41 [ divr16u::dividend#2 divr16u::dividend#1 divr16u::dividend#0 ] zp ZP_WORD:109 [ divr16u::return#2 ] 
+Uplifting [append] best 466508 combination zp ZP_WORD:37 [ append::value#5 append::value#8 append::value#1 append::value#2 append::value#3 append::value#4 append::value#0 ] zp ZP_WORD:33 [ append::dst#4 append::dst#1 append::dst#2 append::dst#3 ] zp ZP_WORD:35 [ append::sub#6 ] zp ZP_WORD:83 [ append::return#10 ] zp ZP_WORD:85 [ append::return#4 ] zp ZP_WORD:87 [ append::return#3 ] zp ZP_WORD:89 [ append::return#2 ] 
+Uplifting [div10] best 466508 combination zp ZP_WORD:60 [ div10::return#2 ] zp ZP_WORD:58 [ div10::val#4 ] zp ZP_WORD:107 [ div10::return#0 ] zp ZP_WORD:91 [ div10::$0 ] zp ZP_WORD:95 [ div10::$2 ] zp ZP_WORD:99 [ div10::$3 ] zp ZP_WORD:103 [ div10::$4 ] zp ZP_WORD:105 [ div10::val#3 ] zp ZP_WORD:93 [ div10::val#0 ] zp ZP_WORD:97 [ div10::val#1 ] zp ZP_WORD:101 [ div10::val#2 ] 
+Uplifting [div16u] best 466508 combination zp ZP_WORD:48 [ div16u::return#2 ] zp ZP_WORD:46 [ div16u::dividend#0 ] zp ZP_WORD:111 [ div16u::return#0 ] 
+Uplifting [main] best 466508 combination zp ZP_WORD:52 [ main::$2 ] zp ZP_WORD:56 [ main::$4 ] zp ZP_WORD:64 [ main::$11 ] zp ZP_WORD:68 [ main::$13 ] zp ZP_WORD:2 [ main::u#11 main::u#2 ] zp ZP_WORD:4 [ main::u#15 main::u#4 ] zp ZP_WORD:50 [ main::v#1 ] zp ZP_WORD:62 [ main::v#2 ] zp ZP_WORD:54 [ main::$3 ] zp ZP_WORD:66 [ main::$12 ] 
+Uplifting [utoa] best 466477 combination zp ZP_WORD:29 [ utoa::value#12 utoa::value#3 utoa::value#10 utoa::value#2 utoa::value#11 utoa::value#6 utoa::value#4 utoa::value#0 utoa::value#1 ] zp ZP_WORD:31 [ utoa::dst#12 utoa::dst#4 utoa::dst#13 utoa::dst#2 utoa::dst#10 utoa::dst#16 utoa::dst#1 ] reg byte x [ utoa::bStarted#7 utoa::bStarted#6 utoa::bStarted#5 ] reg byte a [ utoa::$16 ] reg byte a [ utoa::$17 ] zp ZP_WORD:81 [ utoa::dst#3 ] 
+Uplifting [Print] best 466477 combination 
+Uplifting [] best 466477 combination 
 Attempting to uplift remaining variables inzp ZP_BYTE:24 [ myprintf::bLen#11 myprintf::bLen#13 myprintf::bLen#12 myprintf::bLen#23 myprintf::bLen#14 myprintf::return#0 myprintf::bLen#28 myprintf::bLen#7 myprintf::bLen#3 myprintf::bLen#24 myprintf::bLen#6 myprintf::bLen#1 myprintf::bLen#4 ]
-Uplifting [myprintf] best 466441 combination zp ZP_BYTE:24 [ myprintf::bLen#11 myprintf::bLen#13 myprintf::bLen#12 myprintf::bLen#23 myprintf::bLen#14 myprintf::return#0 myprintf::bLen#28 myprintf::bLen#7 myprintf::bLen#3 myprintf::bLen#24 myprintf::bLen#6 myprintf::bLen#1 myprintf::bLen#4 ] 
+Uplifting [myprintf] best 466477 combination zp ZP_BYTE:24 [ myprintf::bLen#11 myprintf::bLen#13 myprintf::bLen#12 myprintf::bLen#23 myprintf::bLen#14 myprintf::return#0 myprintf::bLen#28 myprintf::bLen#7 myprintf::bLen#3 myprintf::bLen#24 myprintf::bLen#6 myprintf::bLen#1 myprintf::bLen#4 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:25 [ myprintf::bDigits#10 myprintf::bDigits#8 myprintf::bDigits#14 myprintf::bDigits#24 myprintf::bDigits#25 myprintf::bDigits#1 myprintf::bDigits#16 myprintf::bDigits#3 myprintf::bDigits#2 ]
-Uplifting [myprintf] best 466441 combination zp ZP_BYTE:25 [ myprintf::bDigits#10 myprintf::bDigits#8 myprintf::bDigits#14 myprintf::bDigits#24 myprintf::bDigits#25 myprintf::bDigits#1 myprintf::bDigits#16 myprintf::bDigits#3 myprintf::bDigits#2 ] 
+Uplifting [myprintf] best 466477 combination zp ZP_BYTE:25 [ myprintf::bDigits#10 myprintf::bDigits#8 myprintf::bDigits#14 myprintf::bDigits#24 myprintf::bDigits#25 myprintf::bDigits#1 myprintf::bDigits#16 myprintf::bDigits#3 myprintf::bDigits#2 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:23 [ myprintf::digit#3 myprintf::digit#2 ]
-Uplifting [myprintf] best 454441 combination reg byte x [ myprintf::digit#3 myprintf::digit#2 ] 
+Uplifting [myprintf] best 454477 combination reg byte x [ myprintf::digit#3 myprintf::digit#2 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:22 [ myprintf::b#17 myprintf::b#5 ]
-Uplifting [myprintf] best 454441 combination zp ZP_BYTE:22 [ myprintf::b#17 myprintf::b#5 ] 
+Uplifting [myprintf] best 454477 combination zp ZP_BYTE:22 [ myprintf::b#17 myprintf::b#5 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:26 [ myprintf::$41 ]
-Uplifting [myprintf] best 445441 combination reg byte a [ myprintf::$41 ] 
+Uplifting [myprintf] best 445477 combination reg byte a [ myprintf::$41 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:27 [ myprintf::b#25 myprintf::b#1 myprintf::b#6 ]
-Uplifting [myprintf] best 441691 combination reg byte x [ myprintf::b#25 myprintf::b#1 myprintf::b#6 ] 
+Uplifting [myprintf] best 441727 combination reg byte x [ myprintf::b#25 myprintf::b#1 myprintf::b#6 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:15 [ myprintf::bArg#12 myprintf::bArg#10 myprintf::bArg#1 ]
-Uplifting [myprintf] best 441691 combination zp ZP_BYTE:15 [ myprintf::bArg#12 myprintf::bArg#10 myprintf::bArg#1 ] 
+Uplifting [myprintf] best 441727 combination zp ZP_BYTE:15 [ myprintf::bArg#12 myprintf::bArg#10 myprintf::bArg#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:14 [ myprintf::bFormat#10 myprintf::bFormat#4 ]
-Uplifting [myprintf] best 441691 combination zp ZP_BYTE:14 [ myprintf::bFormat#10 myprintf::bFormat#4 ] 
+Uplifting [myprintf] best 441727 combination zp ZP_BYTE:14 [ myprintf::bFormat#10 myprintf::bFormat#4 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:70 [ myprintf::$17 ]
-Uplifting [myprintf] best 441091 combination reg byte a [ myprintf::$17 ] 
+Uplifting [myprintf] best 441127 combination reg byte a [ myprintf::$17 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:71 [ myprintf::$18 ]
-Uplifting [myprintf] best 440491 combination reg byte a [ myprintf::$18 ] 
+Uplifting [myprintf] best 440527 combination reg byte a [ myprintf::$18 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:73 [ myprintf::$24 ]
-Uplifting [myprintf] best 439891 combination reg byte a [ myprintf::$24 ] 
+Uplifting [myprintf] best 439927 combination reg byte a [ myprintf::$24 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:75 [ myprintf::$25 ]
-Uplifting [myprintf] best 439291 combination reg byte a [ myprintf::$25 ] 
+Uplifting [myprintf] best 439327 combination reg byte a [ myprintf::$25 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:77 [ myprintf::$31 ]
-Uplifting [myprintf] best 438691 combination reg byte a [ myprintf::$31 ] 
+Uplifting [myprintf] best 438727 combination reg byte a [ myprintf::$31 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:78 [ myprintf::$49 ]
-Uplifting [myprintf] best 438091 combination reg byte a [ myprintf::$49 ] 
+Uplifting [myprintf] best 438127 combination reg byte a [ myprintf::$49 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:19 [ myprintf::bLeadZero#10 myprintf::bLeadZero#18 ]
-Uplifting [myprintf] best 438091 combination zp ZP_BYTE:19 [ myprintf::bLeadZero#10 myprintf::bLeadZero#18 ] 
+Uplifting [myprintf] best 438127 combination zp ZP_BYTE:19 [ myprintf::bLeadZero#10 myprintf::bLeadZero#18 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:18 [ myprintf::bTrailing#10 myprintf::bTrailing#21 ]
-Uplifting [myprintf] best 438091 combination zp ZP_BYTE:18 [ myprintf::bTrailing#10 myprintf::bTrailing#21 ] 
+Uplifting [myprintf] best 438127 combination zp ZP_BYTE:18 [ myprintf::bTrailing#10 myprintf::bTrailing#21 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:20 [ myprintf::$23 ]
-Uplifting [myprintf] best 437191 combination reg byte a [ myprintf::$23 ] 
+Uplifting [myprintf] best 437227 combination reg byte a [ myprintf::$23 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:21 [ myprintf::$30 ]
-Uplifting [myprintf] best 436291 combination reg byte a [ myprintf::$30 ] 
+Uplifting [myprintf] best 436327 combination reg byte a [ myprintf::$30 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:72 [ myprintf::b#15 ]
-Uplifting [myprintf] best 436191 combination reg byte x [ myprintf::b#15 ] 
+Uplifting [myprintf] best 436227 combination reg byte x [ myprintf::b#15 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:76 [ myprintf::b#16 ]
-Uplifting [myprintf] best 436091 combination reg byte x [ myprintf::b#16 ] 
+Uplifting [myprintf] best 436127 combination reg byte x [ myprintf::b#16 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:74 [ myprintf::bLen#10 ]
-Uplifting [myprintf] best 435191 combination reg byte y [ myprintf::bLen#10 ] 
+Uplifting [myprintf] best 435227 combination reg byte y [ myprintf::bLen#10 ] 
 Coalescing zero page register with common assignment [ zp ZP_WORD:29 [ utoa::value#12 utoa::value#3 utoa::value#10 utoa::value#2 utoa::value#11 utoa::value#6 utoa::value#4 utoa::value#0 utoa::value#1 ] ] with [ zp ZP_WORD:37 [ append::value#5 append::value#8 append::value#1 append::value#2 append::value#3 append::value#4 append::value#0 ] ] - score: 4
 Coalescing zero page register with common assignment [ zp ZP_WORD:31 [ utoa::dst#12 utoa::dst#4 utoa::dst#13 utoa::dst#2 utoa::dst#10 utoa::dst#16 utoa::dst#1 ] ] with [ zp ZP_WORD:33 [ append::dst#4 append::dst#1 append::dst#2 append::dst#3 ] ] - score: 3
 Coalescing zero page register with common assignment [ zp ZP_WORD:2 [ main::u#11 main::u#2 ] ] with [ zp ZP_WORD:6 [ myprintf::w1#6 myprintf::w1#0 myprintf::w1#1 ] ] - score: 1
@@ -7455,15 +7459,17 @@ div10: {
     sta val_1+1
   //SEG416 [186] (word~) div10::$3 ← (word) div10::val#1 >> (byte) 4 -- vwuz1=vwuz2_ror_4 
     lda val_1+1
+    lsr
     sta _3+1
     lda val_1
+    ror
     sta _3
-    ldy #4
-  !:
     lsr _3+1
     ror _3
-    dey
-    bne !-
+    lsr _3+1
+    ror _3
+    lsr _3+1
+    ror _3
   //SEG417 [187] (word) div10::val#2 ← (word) div10::val#1 + (word~) div10::$3 -- vwuz1=vwuz2_plus_vwuz1 
     lda val_2
     clc
@@ -8280,7 +8286,7 @@ reg byte a [ divr16u::$2 ]
 
 
 FINAL ASSEMBLER
-Score: 354937
+Score: 354955
 
 //SEG0 File Comments
 //SEG1 Basic Upstart
@@ -9295,15 +9301,17 @@ div10: {
     adc val+1
     sta val_1+1
   //SEG416 [186] (word~) div10::$3 ← (word) div10::val#1 >> (byte) 4 -- vwuz1=vwuz2_ror_4 
+    lsr
     sta _3+1
     lda val_1
+    ror
     sta _3
-    ldy #4
-  !:
     lsr _3+1
     ror _3
-    dey
-    bne !-
+    lsr _3+1
+    ror _3
+    lsr _3+1
+    ror _3
   //SEG417 [187] (word) div10::val#2 ← (word) div10::val#1 + (word~) div10::$3 -- vwuz1=vwuz2_plus_vwuz1 
     lda val_2
     clc

src/test/ref/sinusgen16.log

@@ -3406,15 +3406,17 @@ sin16s: {
     sta x5+1
   //SEG219 [106] (word) sin16s::x5_128#0 ← (word) sin16s::x5#0 >> (byte) 4 -- vwuz1=vwuz2_ror_4 
     lda x5+1
+    lsr
     sta x5_128+1
     lda x5
+    ror
     sta x5_128
-    ldy #4
-  !:
     lsr x5_128+1
     ror x5_128
-    dey
-    bne !-
+    lsr x5_128+1
+    ror x5_128
+    lsr x5_128+1
+    ror x5_128
   //SEG220 [107] (word) sin16s::usinx#1 ← (word) sin16s::usinx#0 + (word) sin16s::x5_128#0 -- vwuz1=vwuz2_plus_vwuz3 
     lda usinx
     clc
@@ -3892,7 +3894,7 @@ Statement [101] (word) mulu16_sel::v1#4 ← (word) sin16s::x4#0 [ sin16s::isUppe
 Statement [102] (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:5::sin16s:64 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::v1#4 mulu16_sel::v2#4 ] ) always clobbers reg byte a 
 Statement [104] (word) mulu16_sel::return#11 ← (word) mulu16_sel::return#12 [ sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::return#11 ] ( main:2::sin16s_gen:5::sin16s:64 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::return#11 ] ) always clobbers reg byte a 
 Statement [105] (word) sin16s::x5#0 ← (word) mulu16_sel::return#11 [ sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5#0 ] ( main:2::sin16s_gen:5::sin16s:64 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5#0 ] ) always clobbers reg byte a 
-Statement [106] (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:5::sin16s:64 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5_128#0 ] ) always clobbers reg byte a reg byte y 
+Statement [106] (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:5::sin16s:64 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5_128#0 ] ) always clobbers reg byte a 
 Statement [107] (word) sin16s::usinx#1 ← (word) sin16s::usinx#0 + (word) sin16s::x5_128#0 [ sin16s::isUpper#2 sin16s::usinx#1 ] ( main:2::sin16s_gen:5::sin16s:64 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::isUpper#2 sin16s::usinx#1 ] ) always clobbers reg byte a 
 Statement [109] (signed word) sin16s::sinx#1 ← - (signed word)(word) sin16s::usinx#1 [ sin16s::sinx#1 ] ( main:2::sin16s_gen:5::sin16s:64 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::sinx#1 ] ) always clobbers reg byte a 
 Statement [112] (signed word~) sin16s::return#5 ← (signed word)(word) sin16s::usinx#1 [ sin16s::return#5 ] ( main:2::sin16s_gen:5::sin16s:64 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::return#5 ] ) always clobbers reg byte a 
@@ -3969,7 +3971,7 @@ Statement [101] (word) mulu16_sel::v1#4 ← (word) sin16s::x4#0 [ sin16s::isUppe
 Statement [102] (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:5::sin16s:64 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::v1#4 mulu16_sel::v2#4 ] ) always clobbers reg byte a 
 Statement [104] (word) mulu16_sel::return#11 ← (word) mulu16_sel::return#12 [ sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::return#11 ] ( main:2::sin16s_gen:5::sin16s:64 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::return#11 ] ) always clobbers reg byte a 
 Statement [105] (word) sin16s::x5#0 ← (word) mulu16_sel::return#11 [ sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5#0 ] ( main:2::sin16s_gen:5::sin16s:64 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5#0 ] ) always clobbers reg byte a 
-Statement [106] (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:5::sin16s:64 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5_128#0 ] ) always clobbers reg byte a reg byte y 
+Statement [106] (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:5::sin16s:64 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5_128#0 ] ) always clobbers reg byte a 
 Statement [107] (word) sin16s::usinx#1 ← (word) sin16s::usinx#0 + (word) sin16s::x5_128#0 [ sin16s::isUpper#2 sin16s::usinx#1 ] ( main:2::sin16s_gen:5::sin16s:64 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::isUpper#2 sin16s::usinx#1 ] ) always clobbers reg byte a 
 Statement [109] (signed word) sin16s::sinx#1 ← - (signed word)(word) sin16s::usinx#1 [ sin16s::sinx#1 ] ( main:2::sin16s_gen:5::sin16s:64 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::sinx#1 ] ) always clobbers reg byte a 
 Statement [112] (signed word~) sin16s::return#5 ← (signed word)(word) sin16s::usinx#1 [ sin16s::return#5 ] ( main:2::sin16s_gen:5::sin16s:64 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::return#5 ] ) always clobbers reg byte a 
@@ -4069,22 +4071,22 @@ Uplift Scope [div32u16u] 4: zp ZP_DWORD:57 [ div32u16u::return#2 ] 4: zp ZP_WORD
 Uplift Scope [print_sword] 9.58: zp ZP_WORD:6 [ print_sword::w#3 print_sword::w#1 print_sword::w#0 ] 
 Uplift Scope [print_word] 
 
-Uplifting [mul16u] best 26841 combination zp ZP_DWORD:36 [ mul16u::res#2 mul16u::res#6 mul16u::res#1 ] zp ZP_DWORD:40 [ mul16u::mb#2 mul16u::mb#1 ] reg byte a [ mul16u::$1 ] zp ZP_WORD:34 [ mul16u::a#2 mul16u::a#1 mul16u::a#0 ] zp ZP_DWORD:101 [ mul16u::return#2 ] zp ZP_WORD:44 [ mul16u::b#0 ] 
-Uplifting [print_str] best 26841 combination zp ZP_WORD:4 [ print_str::str#3 print_str::str#5 print_str::str#0 ] 
-Uplifting [divr16u] best 26631 combination zp ZP_WORD:46 [ divr16u::rem#5 divr16u::rem#10 divr16u::rem#4 divr16u::rem#11 divr16u::rem#6 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 ] zp ZP_WORD:50 [ 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 ZP_WORD:48 [ divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#0 ] zp ZP_WORD:116 [ divr16u::return#2 ] zp ZP_WORD:120 [ divr16u::return#3 ] 
-Uplifting [] best 26631 combination zp ZP_WORD:10 [ print_char_cursor#33 print_char_cursor#46 print_char_cursor#43 print_char_cursor#51 print_char_cursor#48 print_char_cursor#49 print_char_cursor#2 print_char_cursor#12 print_char_cursor#1 ] zp ZP_WORD:130 [ rem16u#1 ] 
-Uplifting [sin16s] best 26631 combination zp ZP_DWORD:23 [ sin16s::x#6 sin16s::x#4 sin16s::x#0 sin16s::x#1 sin16s::x#2 ] zp ZP_WORD:65 [ sin16s::return#0 ] zp ZP_WORD:27 [ sin16s::return#1 sin16s::return#5 sin16s::sinx#1 ] zp ZP_DWORD:69 [ sin16s::$4 ] zp ZP_WORD:77 [ sin16s::x2#0 ] zp ZP_WORD:85 [ sin16s::x3_6#0 ] zp ZP_WORD:91 [ sin16s::x4#0 ] zp ZP_WORD:95 [ sin16s::x5#0 ] zp ZP_WORD:97 [ sin16s::x5_128#0 ] zp ZP_WORD:81 [ sin16s::x3#0 ] zp ZP_WORD:99 [ sin16s::usinx#1 ] zp ZP_WORD:73 [ sin16s::x1#0 ] zp ZP_WORD:87 [ sin16s::usinx#0 ] zp ZP_BYTE:22 [ sin16s::isUpper#2 ] 
-Uplifting [mulu16_sel] best 26615 combination zp ZP_WORD:29 [ 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 ZP_WORD:31 [ mulu16_sel::v2#5 mulu16_sel::v2#3 mulu16_sel::v2#4 mulu16_sel::v2#0 mulu16_sel::v2#1 ] zp ZP_WORD:75 [ mulu16_sel::return#0 ] zp ZP_WORD:79 [ mulu16_sel::return#1 ] zp ZP_WORD:83 [ mulu16_sel::return#2 ] zp ZP_WORD:89 [ mulu16_sel::return#10 ] zp ZP_WORD:93 [ mulu16_sel::return#11 ] zp ZP_DWORD:105 [ mulu16_sel::$0 ] zp ZP_DWORD:109 [ mulu16_sel::$1 ] zp ZP_WORD:113 [ mulu16_sel::return#12 ] reg byte x [ mulu16_sel::select#5 ] 
-Uplifting [sin16s_gen] best 26615 combination zp ZP_WORD:67 [ sin16s_gen::$1 ] zp ZP_WORD:20 [ sin16s_gen::i#2 sin16s_gen::i#1 ] zp ZP_DWORD:14 [ sin16s_gen::x#2 sin16s_gen::x#1 ] zp ZP_WORD:18 [ sin16s_gen::sintab#2 sin16s_gen::sintab#0 ] zp ZP_DWORD:61 [ sin16s_gen::step#0 ] 
-Uplifting [print_cls] best 26615 combination zp ZP_WORD:12 [ print_cls::sc#2 print_cls::sc#1 ] 
-Uplifting [main] best 26615 combination zp ZP_WORD:2 [ main::st1#2 main::st1#1 ] zp ZP_WORD:53 [ main::sw#0 ] 
-Uplifting [print_byte] best 26601 combination reg byte x [ print_byte::b#2 print_byte::b#0 print_byte::b#1 ] reg byte a [ print_byte::$0 ] reg byte x [ print_byte::$2 ] 
-Uplifting [print_char] best 26589 combination reg byte a [ print_char::ch#3 print_char::ch#1 print_char::ch#2 ] 
-Uplifting [div32u16u] best 26589 combination zp ZP_DWORD:57 [ div32u16u::return#2 ] zp ZP_WORD:122 [ div32u16u::quotient_lo#0 ] zp ZP_DWORD:124 [ div32u16u::return#0 ] zp ZP_WORD:118 [ div32u16u::quotient_hi#0 ] 
-Uplifting [print_sword] best 26589 combination zp ZP_WORD:6 [ print_sword::w#3 print_sword::w#1 print_sword::w#0 ] 
-Uplifting [print_word] best 26589 combination 
+Uplifting [mul16u] best 26859 combination zp ZP_DWORD:36 [ mul16u::res#2 mul16u::res#6 mul16u::res#1 ] zp ZP_DWORD:40 [ mul16u::mb#2 mul16u::mb#1 ] reg byte a [ mul16u::$1 ] zp ZP_WORD:34 [ mul16u::a#2 mul16u::a#1 mul16u::a#0 ] zp ZP_DWORD:101 [ mul16u::return#2 ] zp ZP_WORD:44 [ mul16u::b#0 ] 
+Uplifting [print_str] best 26859 combination zp ZP_WORD:4 [ print_str::str#3 print_str::str#5 print_str::str#0 ] 
+Uplifting [divr16u] best 26649 combination zp ZP_WORD:46 [ divr16u::rem#5 divr16u::rem#10 divr16u::rem#4 divr16u::rem#11 divr16u::rem#6 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 ] zp ZP_WORD:50 [ 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 ZP_WORD:48 [ divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#0 ] zp ZP_WORD:116 [ divr16u::return#2 ] zp ZP_WORD:120 [ divr16u::return#3 ] 
+Uplifting [] best 26649 combination zp ZP_WORD:10 [ print_char_cursor#33 print_char_cursor#46 print_char_cursor#43 print_char_cursor#51 print_char_cursor#48 print_char_cursor#49 print_char_cursor#2 print_char_cursor#12 print_char_cursor#1 ] zp ZP_WORD:130 [ rem16u#1 ] 
+Uplifting [sin16s] best 26649 combination zp ZP_DWORD:23 [ sin16s::x#6 sin16s::x#4 sin16s::x#0 sin16s::x#1 sin16s::x#2 ] zp ZP_WORD:65 [ sin16s::return#0 ] zp ZP_WORD:27 [ sin16s::return#1 sin16s::return#5 sin16s::sinx#1 ] zp ZP_DWORD:69 [ sin16s::$4 ] zp ZP_WORD:77 [ sin16s::x2#0 ] zp ZP_WORD:85 [ sin16s::x3_6#0 ] zp ZP_WORD:91 [ sin16s::x4#0 ] zp ZP_WORD:95 [ sin16s::x5#0 ] zp ZP_WORD:97 [ sin16s::x5_128#0 ] zp ZP_WORD:81 [ sin16s::x3#0 ] zp ZP_WORD:99 [ sin16s::usinx#1 ] zp ZP_WORD:73 [ sin16s::x1#0 ] zp ZP_WORD:87 [ sin16s::usinx#0 ] zp ZP_BYTE:22 [ sin16s::isUpper#2 ] 
+Uplifting [mulu16_sel] best 26633 combination zp ZP_WORD:29 [ 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 ZP_WORD:31 [ mulu16_sel::v2#5 mulu16_sel::v2#3 mulu16_sel::v2#4 mulu16_sel::v2#0 mulu16_sel::v2#1 ] zp ZP_WORD:75 [ mulu16_sel::return#0 ] zp ZP_WORD:79 [ mulu16_sel::return#1 ] zp ZP_WORD:83 [ mulu16_sel::return#2 ] zp ZP_WORD:89 [ mulu16_sel::return#10 ] zp ZP_WORD:93 [ mulu16_sel::return#11 ] zp ZP_DWORD:105 [ mulu16_sel::$0 ] zp ZP_DWORD:109 [ mulu16_sel::$1 ] zp ZP_WORD:113 [ mulu16_sel::return#12 ] reg byte x [ mulu16_sel::select#5 ] 
+Uplifting [sin16s_gen] best 26633 combination zp ZP_WORD:67 [ sin16s_gen::$1 ] zp ZP_WORD:20 [ sin16s_gen::i#2 sin16s_gen::i#1 ] zp ZP_DWORD:14 [ sin16s_gen::x#2 sin16s_gen::x#1 ] zp ZP_WORD:18 [ sin16s_gen::sintab#2 sin16s_gen::sintab#0 ] zp ZP_DWORD:61 [ sin16s_gen::step#0 ] 
+Uplifting [print_cls] best 26633 combination zp ZP_WORD:12 [ print_cls::sc#2 print_cls::sc#1 ] 
+Uplifting [main] best 26633 combination zp ZP_WORD:2 [ main::st1#2 main::st1#1 ] zp ZP_WORD:53 [ main::sw#0 ] 
+Uplifting [print_byte] best 26619 combination reg byte x [ print_byte::b#2 print_byte::b#0 print_byte::b#1 ] reg byte a [ print_byte::$0 ] reg byte x [ print_byte::$2 ] 
+Uplifting [print_char] best 26607 combination reg byte a [ print_char::ch#3 print_char::ch#1 print_char::ch#2 ] 
+Uplifting [div32u16u] best 26607 combination zp ZP_DWORD:57 [ div32u16u::return#2 ] zp ZP_WORD:122 [ div32u16u::quotient_lo#0 ] zp ZP_DWORD:124 [ div32u16u::return#0 ] zp ZP_WORD:118 [ div32u16u::quotient_hi#0 ] 
+Uplifting [print_sword] best 26607 combination zp ZP_WORD:6 [ print_sword::w#3 print_sword::w#1 print_sword::w#0 ] 
+Uplifting [print_word] best 26607 combination 
 Attempting to uplift remaining variables inzp ZP_BYTE:22 [ sin16s::isUpper#2 ]
-Uplifting [sin16s] best 26589 combination zp ZP_BYTE:22 [ sin16s::isUpper#2 ] 
+Uplifting [sin16s] best 26607 combination zp ZP_BYTE:22 [ sin16s::isUpper#2 ] 
 Coalescing zero page register with common assignment [ zp ZP_WORD:27 [ sin16s::return#1 sin16s::return#5 sin16s::sinx#1 ] ] with [ zp ZP_WORD:99 [ sin16s::usinx#1 ] ] - score: 2
 Coalescing zero page register with common assignment [ zp ZP_WORD:29 [ 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 ZP_WORD:81 [ sin16s::x3#0 ] ] - score: 2
 Coalescing zero page register with common assignment [ zp ZP_WORD:46 [ divr16u::rem#5 divr16u::rem#10 divr16u::rem#4 divr16u::rem#11 divr16u::rem#6 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 ] ] with [ zp ZP_WORD:130 [ rem16u#1 ] ] - score: 2

src/test/ref/sinusgen16b.asm

@@ -14,7 +14,7 @@
   // PI/2 in u[4.12] format
   .const PI_HALF_u4f12 = $1922
   .label print_line_cursor = $400
-  .label rem16u = $2a
+  .label rem16u = $29
   .label print_char_cursor = $b
 main: {
     .label wavelength = $78
@@ -194,8 +194,8 @@ print_cls: {
 // wavelength - the number of sinus points in a total sinus wavelength (the size of the table)
 // sin16s_genb(signed word* zeropage($13) sintab)
 sin16s_genb: {
-    .label _2 = $1a
-    .label step = $3f
+    .label _2 = $19
+    .label step = $3e
     .label sintab = $13
     .label x = $f
     .label i = $15
@@ -262,20 +262,19 @@ sin16s_genb: {
 // 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
-// sin16sb(word zeropage($18) x)
+// sin16sb(word zeropage($17) x)
 sin16sb: {
-    .label x = $18
-    .label return = $1a
-    .label x1 = $18
-    .label x2 = $1c
-    .label x3 = $1c
-    .label x3_6 = $43
-    .label usinx = $1a
-    .label x4 = $1c
-    .label x5 = $43
-    .label x5_128 = $43
-    .label sinx = $1a
-    .label isUpper = $17
+    .label x = $17
+    .label return = $19
+    .label x1 = $17
+    .label x2 = $1b
+    .label x3 = $1b
+    .label x3_6 = $42
+    .label usinx = $19
+    .label x4 = $1b
+    .label x5 = $42
+    .label x5_128 = $42
+    .label sinx = $19
     lda x+1
     cmp #>PI_u4f12
     bcc b4
@@ -291,12 +290,10 @@ sin16sb: {
     lda x+1
     sbc #>PI_u4f12
     sta x+1
-    lda #1
-    sta isUpper
+    ldy #1
     jmp b1
   b4:
-    lda #0
-    sta isUpper
+    ldy #0
   b1:
     lda x+1
     cmp #>PI_HALF_u4f12
@@ -388,8 +385,7 @@ sin16sb: {
     lda usinx+1
     adc x5_128+1
     sta usinx+1
-    lda isUpper
-    cmp #0
+    cpy #0
     beq b3
     sec
     lda #0
@@ -403,19 +399,19 @@ sin16sb: {
 }
 // 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 zeropage($1c) v1, word zeropage($1e) v2, byte register(X) select)
+// mulu16_sel(word zeropage($1b) v1, word zeropage($1d) v2, byte register(X) select)
 mulu16_sel: {
-    .label _0 = $22
-    .label _1 = $22
-    .label v1 = $1c
-    .label v2 = $1e
-    .label return = $1c
-    .label return_11 = $43
-    .label return_14 = $43
-    .label return_16 = $43
-    .label return_17 = $43
-    .label return_18 = $43
-    .label return_20 = $43
+    .label _0 = $21
+    .label _1 = $21
+    .label v1 = $1b
+    .label v2 = $1d
+    .label return = $1b
+    .label return_11 = $42
+    .label return_14 = $42
+    .label return_16 = $42
+    .label return_17 = $42
+    .label return_18 = $42
+    .label return_20 = $42
     lda v1
     sta mul16u.a
     lda v1+1
@@ -438,13 +434,13 @@ mulu16_sel: {
     rts
 }
 // Perform binary multiplication of two unsigned 16-bit words into a 32-bit unsigned double word
-// mul16u(word zeropage($20) a, word zeropage($1e) b)
+// mul16u(word zeropage($1f) a, word zeropage($1d) b)
 mul16u: {
-    .label a = $20
-    .label mb = $26
-    .label res = $22
-    .label b = $1e
-    .label return = $22
+    .label a = $1f
+    .label mb = $25
+    .label res = $21
+    .label b = $1d
+    .label return = $21
     lda b
     sta mb
     lda b+1
@@ -492,9 +488,9 @@ mul16u: {
 // 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 = $45
-    .label quotient_lo = $2e
-    .label return = $3f
+    .label quotient_hi = $44
+    .label quotient_lo = $2d
+    .label return = $3e
     lda #<PI2_u4f28>>$10
     sta divr16u.dividend
     lda #>PI2_u4f28>>$10
@@ -526,12 +522,12 @@ div32u16u: {
 // Returns the quotient dividend/divisor.
 // The final remainder will be set into the global variable rem16u
 // Implemented using simple binary division
-// divr16u(word zeropage($2c) dividend, word zeropage($2a) rem)
+// divr16u(word zeropage($2b) dividend, word zeropage($29) rem)
 divr16u: {
-    .label rem = $2a
-    .label dividend = $2c
-    .label quotient = $2e
-    .label return = $2e
+    .label rem = $29
+    .label dividend = $2b
+    .label quotient = $2d
+    .label return = $2d
     ldx #0
     txa
     sta quotient
@@ -579,13 +575,13 @@ divr16u: {
 // 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* zeropage($34) sintab)
+// sin16s_gen(signed word* zeropage($33) sintab)
 sin16s_gen: {
-    .label _1 = $3d
-    .label step = $3f
-    .label sintab = $34
-    .label x = $30
-    .label i = $36
+    .label _1 = $3c
+    .label step = $3e
+    .label sintab = $33
+    .label x = $2f
+    .label i = $35
     jsr div32u16u
     lda #0
     sta i
@@ -653,21 +649,21 @@ sin16s_gen: {
 // 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 zeropage($39) x)
+// sin16s(dword zeropage($38) x)
 sin16s: {
-    .label _4 = $39
-    .label x = $39
-    .label return = $3d
-    .label x1 = $47
-    .label x2 = $1c
-    .label x3 = $1c
-    .label x3_6 = $43
-    .label usinx = $3d
-    .label x4 = $1c
-    .label x5 = $43
-    .label x5_128 = $43
-    .label sinx = $3d
-    .label isUpper = $38
+    .label _4 = $38
+    .label x = $38
+    .label return = $3c
+    .label x1 = $46
+    .label x2 = $1b
+    .label x3 = $1b
+    .label x3_6 = $42
+    .label usinx = $3c
+    .label x4 = $1b
+    .label x5 = $42
+    .label x5_128 = $42
+    .label sinx = $3c
+    .label isUpper = $37
     lda x+3
     cmp #>PI_u4f28>>$10
     bcc b4

src/test/ref/sinusgen16b.log

@@ -4269,15 +4269,17 @@ sin16sb: {
     sta x5+1
   //SEG228 [109] (word) sin16sb::x5_128#0 ← (word) sin16sb::x5#0 >> (byte) 4 -- vwuz1=vwuz2_ror_4 
     lda x5+1
+    lsr
     sta x5_128+1
     lda x5
+    ror
     sta x5_128
-    ldy #4
-  !:
     lsr x5_128+1
     ror x5_128
-    dey
-    bne !-
+    lsr x5_128+1
+    ror x5_128
+    lsr x5_128+1
+    ror x5_128
   //SEG229 [110] (word) sin16sb::usinx#1 ← (word) sin16sb::usinx#0 + (word) sin16sb::x5_128#0 -- vwuz1=vwuz2_plus_vwuz3 
     lda usinx
     clc
@@ -5144,15 +5146,17 @@ sin16s: {
     sta x5+1
   //SEG427 [211] (word) sin16s::x5_128#0 ← (word) sin16s::x5#0 >> (byte) 4 -- vwuz1=vwuz2_ror_4 
     lda x5+1
+    lsr
     sta x5_128+1
     lda x5
+    ror
     sta x5_128
-    ldy #4
-  !:
     lsr x5_128+1
     ror x5_128
-    dey
-    bne !-
+    lsr x5_128+1
+    ror x5_128
+    lsr x5_128+1
+    ror x5_128
   //SEG428 [212] (word) sin16s::usinx#1 ← (word) sin16s::usinx#0 + (word) sin16s::x5_128#0 -- vwuz1=vwuz2_plus_vwuz3 
     lda usinx
     clc
@@ -5256,8 +5260,7 @@ Statement [104] (word) mulu16_sel::v1#9 ← (word) sin16sb::x4#0 [ sin16sb::isUp
 Statement [105] (word) mulu16_sel::v2#9 ← (word) sin16sb::x1#0 [ sin16sb::isUpper#2 sin16sb::usinx#0 mulu16_sel::v1#9 mulu16_sel::v2#9 ] ( main:2::sin16s_genb:7::sin16sb:68 [ sin16s_genb::step#0 sin16s_genb::x#2 sin16s_genb::sintab#2 sin16s_genb::i#2 sin16sb::isUpper#2 sin16sb::usinx#0 mulu16_sel::v1#9 mulu16_sel::v2#9 ] ) always clobbers reg byte a 
 Statement [107] (word) mulu16_sel::return#11 ← (word) mulu16_sel::return#17 [ sin16sb::isUpper#2 sin16sb::usinx#0 mulu16_sel::return#11 ] ( main:2::sin16s_genb:7::sin16sb:68 [ sin16s_genb::step#0 sin16s_genb::x#2 sin16s_genb::sintab#2 sin16s_genb::i#2 sin16sb::isUpper#2 sin16sb::usinx#0 mulu16_sel::return#11 ] ) always clobbers reg byte a 
 Statement [108] (word) sin16sb::x5#0 ← (word) mulu16_sel::return#11 [ sin16sb::isUpper#2 sin16sb::usinx#0 sin16sb::x5#0 ] ( main:2::sin16s_genb:7::sin16sb:68 [ sin16s_genb::step#0 sin16s_genb::x#2 sin16s_genb::sintab#2 sin16s_genb::i#2 sin16sb::isUpper#2 sin16sb::usinx#0 sin16sb::x5#0 ] ) always clobbers reg byte a 
-Statement [109] (word) sin16sb::x5_128#0 ← (word) sin16sb::x5#0 >> (byte) 4 [ sin16sb::isUpper#2 sin16sb::usinx#0 sin16sb::x5_128#0 ] ( main:2::sin16s_genb:7::sin16sb:68 [ sin16s_genb::step#0 sin16s_genb::x#2 sin16s_genb::sintab#2 sin16s_genb::i#2 sin16sb::isUpper#2 sin16sb::usinx#0 sin16sb::x5_128#0 ] ) always clobbers reg byte a reg byte y 
-Removing always clobbered register reg byte y as potential for zp ZP_BYTE:25 [ sin16sb::isUpper#2 ]
+Statement [109] (word) sin16sb::x5_128#0 ← (word) sin16sb::x5#0 >> (byte) 4 [ sin16sb::isUpper#2 sin16sb::usinx#0 sin16sb::x5_128#0 ] ( main:2::sin16s_genb:7::sin16sb:68 [ sin16s_genb::step#0 sin16s_genb::x#2 sin16s_genb::sintab#2 sin16s_genb::i#2 sin16sb::isUpper#2 sin16sb::usinx#0 sin16sb::x5_128#0 ] ) always clobbers reg byte a 
 Statement [110] (word) sin16sb::usinx#1 ← (word) sin16sb::usinx#0 + (word) sin16sb::x5_128#0 [ sin16sb::isUpper#2 sin16sb::usinx#1 ] ( main:2::sin16s_genb:7::sin16sb:68 [ sin16s_genb::step#0 sin16s_genb::x#2 sin16s_genb::sintab#2 sin16s_genb::i#2 sin16sb::isUpper#2 sin16sb::usinx#1 ] ) always clobbers reg byte a 
 Statement [112] (signed word) sin16sb::sinx#1 ← - (signed word)(word) sin16sb::usinx#1 [ sin16sb::sinx#1 ] ( main:2::sin16s_genb:7::sin16sb:68 [ sin16s_genb::step#0 sin16s_genb::x#2 sin16s_genb::sintab#2 sin16s_genb::i#2 sin16sb::sinx#1 ] ) always clobbers reg byte a 
 Statement [115] (signed word~) sin16sb::return#5 ← (signed word)(word) sin16sb::usinx#1 [ sin16sb::return#5 ] ( main:2::sin16s_genb:7::sin16sb:68 [ sin16s_genb::step#0 sin16s_genb::x#2 sin16s_genb::sintab#2 sin16s_genb::i#2 sin16sb::return#5 ] ) always clobbers reg byte a 
@@ -5320,7 +5323,7 @@ Statement [206] (word) mulu16_sel::v1#4 ← (word) sin16s::x4#0 [ mulu16_sel::v1
 Statement [207] (word) mulu16_sel::v2#4 ← (word) sin16s::x1#0 [ mulu16_sel::v1#4 mulu16_sel::v2#4 sin16s::isUpper#2 sin16s::usinx#0 ] ( main:2::sin16s_gen:5::sin16s:169 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 mulu16_sel::v1#4 mulu16_sel::v2#4 sin16s::isUpper#2 sin16s::usinx#0 ] ) always clobbers reg byte a 
 Statement [209] (word) mulu16_sel::return#16 ← (word) mulu16_sel::return#17 [ sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::return#16 ] ( main:2::sin16s_gen:5::sin16s:169 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::return#16 ] ) always clobbers reg byte a 
 Statement [210] (word) sin16s::x5#0 ← (word) mulu16_sel::return#16 [ sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5#0 ] ( main:2::sin16s_gen:5::sin16s:169 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5#0 ] ) always clobbers reg byte a 
-Statement [211] (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:5::sin16s:169 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5_128#0 ] ) always clobbers reg byte a reg byte y 
+Statement [211] (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:5::sin16s:169 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5_128#0 ] ) always clobbers reg byte a 
 Statement [212] (word) sin16s::usinx#1 ← (word) sin16s::usinx#0 + (word) sin16s::x5_128#0 [ sin16s::isUpper#2 sin16s::usinx#1 ] ( main:2::sin16s_gen:5::sin16s:169 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::isUpper#2 sin16s::usinx#1 ] ) always clobbers reg byte a 
 Statement [214] (signed word) sin16s::sinx#1 ← - (signed word)(word) sin16s::usinx#1 [ sin16s::sinx#1 ] ( main:2::sin16s_gen:5::sin16s:169 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::sinx#1 ] ) always clobbers reg byte a 
 Statement [217] (signed word~) sin16s::return#5 ← (signed word)(word) sin16s::usinx#1 [ sin16s::return#5 ] ( main:2::sin16s_gen:5::sin16s:169 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::return#5 ] ) always clobbers reg byte a 
@@ -5374,7 +5377,7 @@ Statement [104] (word) mulu16_sel::v1#9 ← (word) sin16sb::x4#0 [ sin16sb::isUp
 Statement [105] (word) mulu16_sel::v2#9 ← (word) sin16sb::x1#0 [ sin16sb::isUpper#2 sin16sb::usinx#0 mulu16_sel::v1#9 mulu16_sel::v2#9 ] ( main:2::sin16s_genb:7::sin16sb:68 [ sin16s_genb::step#0 sin16s_genb::x#2 sin16s_genb::sintab#2 sin16s_genb::i#2 sin16sb::isUpper#2 sin16sb::usinx#0 mulu16_sel::v1#9 mulu16_sel::v2#9 ] ) always clobbers reg byte a 
 Statement [107] (word) mulu16_sel::return#11 ← (word) mulu16_sel::return#17 [ sin16sb::isUpper#2 sin16sb::usinx#0 mulu16_sel::return#11 ] ( main:2::sin16s_genb:7::sin16sb:68 [ sin16s_genb::step#0 sin16s_genb::x#2 sin16s_genb::sintab#2 sin16s_genb::i#2 sin16sb::isUpper#2 sin16sb::usinx#0 mulu16_sel::return#11 ] ) always clobbers reg byte a 
 Statement [108] (word) sin16sb::x5#0 ← (word) mulu16_sel::return#11 [ sin16sb::isUpper#2 sin16sb::usinx#0 sin16sb::x5#0 ] ( main:2::sin16s_genb:7::sin16sb:68 [ sin16s_genb::step#0 sin16s_genb::x#2 sin16s_genb::sintab#2 sin16s_genb::i#2 sin16sb::isUpper#2 sin16sb::usinx#0 sin16sb::x5#0 ] ) always clobbers reg byte a 
-Statement [109] (word) sin16sb::x5_128#0 ← (word) sin16sb::x5#0 >> (byte) 4 [ sin16sb::isUpper#2 sin16sb::usinx#0 sin16sb::x5_128#0 ] ( main:2::sin16s_genb:7::sin16sb:68 [ sin16s_genb::step#0 sin16s_genb::x#2 sin16s_genb::sintab#2 sin16s_genb::i#2 sin16sb::isUpper#2 sin16sb::usinx#0 sin16sb::x5_128#0 ] ) always clobbers reg byte a reg byte y 
+Statement [109] (word) sin16sb::x5_128#0 ← (word) sin16sb::x5#0 >> (byte) 4 [ sin16sb::isUpper#2 sin16sb::usinx#0 sin16sb::x5_128#0 ] ( main:2::sin16s_genb:7::sin16sb:68 [ sin16s_genb::step#0 sin16s_genb::x#2 sin16s_genb::sintab#2 sin16s_genb::i#2 sin16sb::isUpper#2 sin16sb::usinx#0 sin16sb::x5_128#0 ] ) always clobbers reg byte a 
 Statement [110] (word) sin16sb::usinx#1 ← (word) sin16sb::usinx#0 + (word) sin16sb::x5_128#0 [ sin16sb::isUpper#2 sin16sb::usinx#1 ] ( main:2::sin16s_genb:7::sin16sb:68 [ sin16s_genb::step#0 sin16s_genb::x#2 sin16s_genb::sintab#2 sin16s_genb::i#2 sin16sb::isUpper#2 sin16sb::usinx#1 ] ) always clobbers reg byte a 
 Statement [112] (signed word) sin16sb::sinx#1 ← - (signed word)(word) sin16sb::usinx#1 [ sin16sb::sinx#1 ] ( main:2::sin16s_genb:7::sin16sb:68 [ sin16s_genb::step#0 sin16s_genb::x#2 sin16s_genb::sintab#2 sin16s_genb::i#2 sin16sb::sinx#1 ] ) always clobbers reg byte a 
 Statement [115] (signed word~) sin16sb::return#5 ← (signed word)(word) sin16sb::usinx#1 [ sin16sb::return#5 ] ( main:2::sin16s_genb:7::sin16sb:68 [ sin16s_genb::step#0 sin16s_genb::x#2 sin16s_genb::sintab#2 sin16s_genb::i#2 sin16sb::return#5 ] ) always clobbers reg byte a 
@@ -5433,7 +5436,7 @@ Statement [206] (word) mulu16_sel::v1#4 ← (word) sin16s::x4#0 [ mulu16_sel::v1
 Statement [207] (word) mulu16_sel::v2#4 ← (word) sin16s::x1#0 [ mulu16_sel::v1#4 mulu16_sel::v2#4 sin16s::isUpper#2 sin16s::usinx#0 ] ( main:2::sin16s_gen:5::sin16s:169 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 mulu16_sel::v1#4 mulu16_sel::v2#4 sin16s::isUpper#2 sin16s::usinx#0 ] ) always clobbers reg byte a 
 Statement [209] (word) mulu16_sel::return#16 ← (word) mulu16_sel::return#17 [ sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::return#16 ] ( main:2::sin16s_gen:5::sin16s:169 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::return#16 ] ) always clobbers reg byte a 
 Statement [210] (word) sin16s::x5#0 ← (word) mulu16_sel::return#16 [ sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5#0 ] ( main:2::sin16s_gen:5::sin16s:169 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5#0 ] ) always clobbers reg byte a 
-Statement [211] (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:5::sin16s:169 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5_128#0 ] ) always clobbers reg byte a reg byte y 
+Statement [211] (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:5::sin16s:169 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5_128#0 ] ) always clobbers reg byte a 
 Statement [212] (word) sin16s::usinx#1 ← (word) sin16s::usinx#0 + (word) sin16s::x5_128#0 [ sin16s::isUpper#2 sin16s::usinx#1 ] ( main:2::sin16s_gen:5::sin16s:169 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::isUpper#2 sin16s::usinx#1 ] ) always clobbers reg byte a 
 Statement [214] (signed word) sin16s::sinx#1 ← - (signed word)(word) sin16s::usinx#1 [ sin16s::sinx#1 ] ( main:2::sin16s_gen:5::sin16s:169 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::sinx#1 ] ) always clobbers reg byte a 
 Statement [217] (signed word~) sin16s::return#5 ← (signed word)(word) sin16s::usinx#1 [ sin16s::return#5 ] ( main:2::sin16s_gen:5::sin16s:169 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::return#5 ] ) always clobbers reg byte a 
@@ -5449,7 +5452,7 @@ Potential registers zp ZP_WORD:15 [ print_cls::sc#2 print_cls::sc#1 ] : zp ZP_WO
 Potential registers zp ZP_DWORD:17 [ sin16s_genb::x#2 sin16s_genb::x#1 ] : zp ZP_DWORD:17 , 
 Potential registers zp ZP_WORD:21 [ sin16s_genb::sintab#2 sin16s_genb::sintab#0 ] : zp ZP_WORD:21 , 
 Potential registers zp ZP_WORD:23 [ sin16s_genb::i#2 sin16s_genb::i#1 ] : zp ZP_WORD:23 , 
-Potential registers zp ZP_BYTE:25 [ sin16sb::isUpper#2 ] : zp ZP_BYTE:25 , reg byte x , 
+Potential registers zp ZP_BYTE:25 [ sin16sb::isUpper#2 ] : zp ZP_BYTE:25 , reg byte x , reg byte y , 
 Potential registers zp ZP_WORD:26 [ sin16sb::x#6 sin16sb::x#4 sin16sb::x#0 sin16sb::x#1 sin16sb::x#2 ] : zp ZP_WORD:26 , 
 Potential registers zp ZP_WORD:28 [ sin16sb::return#1 sin16sb::return#5 sin16sb::sinx#1 ] : zp ZP_WORD:28 , 
 Potential registers zp ZP_WORD:30 [ mulu16_sel::v1#10 mulu16_sel::v1#3 mulu16_sel::v1#4 mulu16_sel::v1#0 mulu16_sel::v1#1 mulu16_sel::v1#2 mulu16_sel::v1#8 mulu16_sel::v1#9 mulu16_sel::v1#5 mulu16_sel::v1#6 mulu16_sel::v1#7 ] : zp ZP_WORD:30 , 
@@ -5541,28 +5544,26 @@ Uplift Scope [print_char] 14: zp ZP_BYTE:12 [ print_char::ch#3 print_char::ch#1
 Uplift Scope [print_sword] 9.58: zp ZP_WORD:9 [ print_sword::w#3 print_sword::w#1 print_sword::w#0 ] 
 Uplift Scope [print_word] 
 
-Uplifting [mul16u] best 29882 combination zp ZP_DWORD:37 [ mul16u::res#2 mul16u::res#6 mul16u::res#1 ] zp ZP_DWORD:41 [ mul16u::mb#2 mul16u::mb#1 ] reg byte a [ mul16u::$1 ] zp ZP_WORD:35 [ mul16u::a#2 mul16u::a#1 mul16u::a#0 ] zp ZP_DWORD:113 [ mul16u::return#2 ] zp ZP_WORD:45 [ mul16u::b#0 ] 
-Uplifting [print_str] best 29882 combination zp ZP_WORD:7 [ print_str::str#3 print_str::str#5 print_str::str#0 ] 
-Uplifting [divr16u] best 29672 combination zp ZP_WORD:47 [ divr16u::rem#5 divr16u::rem#10 divr16u::rem#4 divr16u::rem#11 divr16u::rem#6 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 ] zp ZP_WORD:51 [ 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 ZP_WORD:49 [ divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#0 ] zp ZP_WORD:128 [ divr16u::return#2 ] zp ZP_WORD:132 [ divr16u::return#3 ] 
-Uplifting [] best 29672 combination zp ZP_WORD:13 [ print_char_cursor#33 print_char_cursor#46 print_char_cursor#43 print_char_cursor#51 print_char_cursor#48 print_char_cursor#49 print_char_cursor#2 print_char_cursor#12 print_char_cursor#1 ] zp ZP_WORD:142 [ rem16u#1 ] 
-Uplifting [mulu16_sel] best 29641 combination zp ZP_WORD:30 [ mulu16_sel::v1#10 mulu16_sel::v1#3 mulu16_sel::v1#4 mulu16_sel::v1#0 mulu16_sel::v1#1 mulu16_sel::v1#2 mulu16_sel::v1#8 mulu16_sel::v1#9 mulu16_sel::v1#5 mulu16_sel::v1#6 mulu16_sel::v1#7 ] zp ZP_WORD:32 [ mulu16_sel::v2#10 mulu16_sel::v2#3 mulu16_sel::v2#4 mulu16_sel::v2#0 mulu16_sel::v2#1 mulu16_sel::v2#8 mulu16_sel::v2#9 mulu16_sel::v2#5 mulu16_sel::v2#6 ] zp ZP_WORD:87 [ mulu16_sel::return#18 ] zp ZP_WORD:91 [ mulu16_sel::return#19 ] zp ZP_WORD:95 [ mulu16_sel::return#20 ] zp ZP_WORD:101 [ mulu16_sel::return#10 ] zp ZP_WORD:105 [ mulu16_sel::return#11 ] zp ZP_DWORD:117 [ mulu16_sel::$0 ] zp ZP_DWORD:121 [ mulu16_sel::$1 ] zp ZP_WORD:162 [ mulu16_sel::return#0 ] zp ZP_WORD:166 [ mulu16_sel::return#1 ] zp ZP_WORD:170 [ mulu16_sel::return#14 ] zp ZP_WORD:176 [ mulu16_sel::return#15 ] zp ZP_WORD:180 [ mulu16_sel::return#16 ] zp ZP_WORD:125 [ mulu16_sel::return#17 ] reg byte x [ mulu16_sel::select#10 ] 
-Uplifting [sin16s] best 29641 combination zp ZP_DWORD:63 [ sin16s::x#6 sin16s::x#4 sin16s::x#0 sin16s::x#1 sin16s::x#2 ] zp ZP_WORD:152 [ sin16s::return#0 ] zp ZP_WORD:67 [ sin16s::return#1 sin16s::return#5 sin16s::sinx#1 ] zp ZP_DWORD:156 [ sin16s::$4 ] zp ZP_WORD:164 [ sin16s::x2#0 ] zp ZP_WORD:172 [ sin16s::x3_6#0 ] zp ZP_WORD:178 [ sin16s::x4#0 ] zp ZP_WORD:182 [ sin16s::x5#0 ] zp ZP_WORD:184 [ sin16s::x5_128#0 ] zp ZP_WORD:168 [ sin16s::x3#0 ] zp ZP_WORD:186 [ sin16s::usinx#1 ] zp ZP_WORD:160 [ sin16s::x1#0 ] zp ZP_WORD:174 [ sin16s::usinx#0 ] zp ZP_BYTE:62 [ sin16s::isUpper#2 ] 
-Uplifting [sin16sb] best 29641 combination zp ZP_WORD:26 [ sin16sb::x#6 sin16sb::x#4 sin16sb::x#0 sin16sb::x#1 sin16sb::x#2 ] zp ZP_WORD:81 [ sin16sb::return#0 ] zp ZP_WORD:28 [ sin16sb::return#1 sin16sb::return#5 sin16sb::sinx#1 ] zp ZP_WORD:89 [ sin16sb::x2#0 ] zp ZP_WORD:97 [ sin16sb::x3_6#0 ] zp ZP_WORD:103 [ sin16sb::x4#0 ] zp ZP_WORD:107 [ sin16sb::x5#0 ] zp ZP_WORD:109 [ sin16sb::x5_128#0 ] zp ZP_WORD:93 [ sin16sb::x3#0 ] zp ZP_WORD:111 [ sin16sb::usinx#1 ] zp ZP_WORD:85 [ sin16sb::x1#0 ] zp ZP_WORD:99 [ sin16sb::usinx#0 ] zp ZP_BYTE:25 [ sin16sb::isUpper#2 ] 
-Uplifting [sin16s_gen] best 29641 combination zp ZP_WORD:154 [ sin16s_gen::$1 ] zp ZP_WORD:60 [ sin16s_gen::i#2 sin16s_gen::i#1 ] zp ZP_DWORD:54 [ sin16s_gen::x#2 sin16s_gen::x#1 ] zp ZP_WORD:58 [ sin16s_gen::sintab#2 sin16s_gen::sintab#0 ] zp ZP_DWORD:148 [ sin16s_gen::step#0 ] 
-Uplifting [sin16s_genb] best 29641 combination zp ZP_WORD:83 [ sin16s_genb::$2 ] zp ZP_WORD:23 [ sin16s_genb::i#2 sin16s_genb::i#1 ] zp ZP_DWORD:17 [ sin16s_genb::x#2 sin16s_genb::x#1 ] zp ZP_WORD:21 [ sin16s_genb::sintab#2 sin16s_genb::sintab#0 ] zp ZP_DWORD:77 [ sin16s_genb::step#0 ] 
-Uplifting [main] best 29551 combination reg byte x [ main::i#2 main::i#1 ] zp ZP_WORD:4 [ main::st2#2 main::st2#1 ] zp ZP_WORD:2 [ main::st1#2 main::st1#1 ] zp ZP_WORD:69 [ main::sw#0 ] 
-Uplifting [print_cls] best 29551 combination zp ZP_WORD:15 [ print_cls::sc#2 print_cls::sc#1 ] 
-Uplifting [print_byte] best 29543 combination zp ZP_BYTE:11 [ print_byte::b#2 print_byte::b#0 print_byte::b#1 ] reg byte a [ print_byte::$0 ] reg byte a [ print_byte::$2 ] 
-Uplifting [div32u16u] best 29543 combination zp ZP_DWORD:73 [ div32u16u::return#3 ] zp ZP_WORD:134 [ div32u16u::quotient_lo#0 ] zp ZP_DWORD:144 [ div32u16u::return#2 ] zp ZP_DWORD:136 [ div32u16u::return#0 ] zp ZP_WORD:130 [ div32u16u::quotient_hi#0 ] 
-Uplifting [print_char] best 29531 combination reg byte a [ print_char::ch#3 print_char::ch#1 print_char::ch#2 ] 
-Uplifting [print_sword] best 29531 combination zp ZP_WORD:9 [ print_sword::w#3 print_sword::w#1 print_sword::w#0 ] 
-Uplifting [print_word] best 29531 combination 
+Uplifting [mul16u] best 29918 combination zp ZP_DWORD:37 [ mul16u::res#2 mul16u::res#6 mul16u::res#1 ] zp ZP_DWORD:41 [ mul16u::mb#2 mul16u::mb#1 ] reg byte a [ mul16u::$1 ] zp ZP_WORD:35 [ mul16u::a#2 mul16u::a#1 mul16u::a#0 ] zp ZP_DWORD:113 [ mul16u::return#2 ] zp ZP_WORD:45 [ mul16u::b#0 ] 
+Uplifting [print_str] best 29918 combination zp ZP_WORD:7 [ print_str::str#3 print_str::str#5 print_str::str#0 ] 
+Uplifting [divr16u] best 29708 combination zp ZP_WORD:47 [ divr16u::rem#5 divr16u::rem#10 divr16u::rem#4 divr16u::rem#11 divr16u::rem#6 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 ] zp ZP_WORD:51 [ 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 ZP_WORD:49 [ divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#0 ] zp ZP_WORD:128 [ divr16u::return#2 ] zp ZP_WORD:132 [ divr16u::return#3 ] 
+Uplifting [] best 29708 combination zp ZP_WORD:13 [ print_char_cursor#33 print_char_cursor#46 print_char_cursor#43 print_char_cursor#51 print_char_cursor#48 print_char_cursor#49 print_char_cursor#2 print_char_cursor#12 print_char_cursor#1 ] zp ZP_WORD:142 [ rem16u#1 ] 
+Uplifting [mulu16_sel] best 29677 combination zp ZP_WORD:30 [ mulu16_sel::v1#10 mulu16_sel::v1#3 mulu16_sel::v1#4 mulu16_sel::v1#0 mulu16_sel::v1#1 mulu16_sel::v1#2 mulu16_sel::v1#8 mulu16_sel::v1#9 mulu16_sel::v1#5 mulu16_sel::v1#6 mulu16_sel::v1#7 ] zp ZP_WORD:32 [ mulu16_sel::v2#10 mulu16_sel::v2#3 mulu16_sel::v2#4 mulu16_sel::v2#0 mulu16_sel::v2#1 mulu16_sel::v2#8 mulu16_sel::v2#9 mulu16_sel::v2#5 mulu16_sel::v2#6 ] zp ZP_WORD:87 [ mulu16_sel::return#18 ] zp ZP_WORD:91 [ mulu16_sel::return#19 ] zp ZP_WORD:95 [ mulu16_sel::return#20 ] zp ZP_WORD:101 [ mulu16_sel::return#10 ] zp ZP_WORD:105 [ mulu16_sel::return#11 ] zp ZP_DWORD:117 [ mulu16_sel::$0 ] zp ZP_DWORD:121 [ mulu16_sel::$1 ] zp ZP_WORD:162 [ mulu16_sel::return#0 ] zp ZP_WORD:166 [ mulu16_sel::return#1 ] zp ZP_WORD:170 [ mulu16_sel::return#14 ] zp ZP_WORD:176 [ mulu16_sel::return#15 ] zp ZP_WORD:180 [ mulu16_sel::return#16 ] zp ZP_WORD:125 [ mulu16_sel::return#17 ] reg byte x [ mulu16_sel::select#10 ] 
+Uplifting [sin16s] best 29677 combination zp ZP_DWORD:63 [ sin16s::x#6 sin16s::x#4 sin16s::x#0 sin16s::x#1 sin16s::x#2 ] zp ZP_WORD:152 [ sin16s::return#0 ] zp ZP_WORD:67 [ sin16s::return#1 sin16s::return#5 sin16s::sinx#1 ] zp ZP_DWORD:156 [ sin16s::$4 ] zp ZP_WORD:164 [ sin16s::x2#0 ] zp ZP_WORD:172 [ sin16s::x3_6#0 ] zp ZP_WORD:178 [ sin16s::x4#0 ] zp ZP_WORD:182 [ sin16s::x5#0 ] zp ZP_WORD:184 [ sin16s::x5_128#0 ] zp ZP_WORD:168 [ sin16s::x3#0 ] zp ZP_WORD:186 [ sin16s::usinx#1 ] zp ZP_WORD:160 [ sin16s::x1#0 ] zp ZP_WORD:174 [ sin16s::usinx#0 ] zp ZP_BYTE:62 [ sin16s::isUpper#2 ] 
+Uplifting [sin16sb] best 29668 combination zp ZP_WORD:26 [ sin16sb::x#6 sin16sb::x#4 sin16sb::x#0 sin16sb::x#1 sin16sb::x#2 ] zp ZP_WORD:81 [ sin16sb::return#0 ] zp ZP_WORD:28 [ sin16sb::return#1 sin16sb::return#5 sin16sb::sinx#1 ] zp ZP_WORD:89 [ sin16sb::x2#0 ] zp ZP_WORD:97 [ sin16sb::x3_6#0 ] zp ZP_WORD:103 [ sin16sb::x4#0 ] zp ZP_WORD:107 [ sin16sb::x5#0 ] zp ZP_WORD:109 [ sin16sb::x5_128#0 ] zp ZP_WORD:93 [ sin16sb::x3#0 ] zp ZP_WORD:111 [ sin16sb::usinx#1 ] zp ZP_WORD:85 [ sin16sb::x1#0 ] zp ZP_WORD:99 [ sin16sb::usinx#0 ] reg byte y [ sin16sb::isUpper#2 ] 
+Uplifting [sin16s_gen] best 29668 combination zp ZP_WORD:154 [ sin16s_gen::$1 ] zp ZP_WORD:60 [ sin16s_gen::i#2 sin16s_gen::i#1 ] zp ZP_DWORD:54 [ sin16s_gen::x#2 sin16s_gen::x#1 ] zp ZP_WORD:58 [ sin16s_gen::sintab#2 sin16s_gen::sintab#0 ] zp ZP_DWORD:148 [ sin16s_gen::step#0 ] 
+Uplifting [sin16s_genb] best 29668 combination zp ZP_WORD:83 [ sin16s_genb::$2 ] zp ZP_WORD:23 [ sin16s_genb::i#2 sin16s_genb::i#1 ] zp ZP_DWORD:17 [ sin16s_genb::x#2 sin16s_genb::x#1 ] zp ZP_WORD:21 [ sin16s_genb::sintab#2 sin16s_genb::sintab#0 ] zp ZP_DWORD:77 [ sin16s_genb::step#0 ] 
+Uplifting [main] best 29578 combination reg byte x [ main::i#2 main::i#1 ] zp ZP_WORD:4 [ main::st2#2 main::st2#1 ] zp ZP_WORD:2 [ main::st1#2 main::st1#1 ] zp ZP_WORD:69 [ main::sw#0 ] 
+Uplifting [print_cls] best 29578 combination zp ZP_WORD:15 [ print_cls::sc#2 print_cls::sc#1 ] 
+Uplifting [print_byte] best 29570 combination zp ZP_BYTE:11 [ print_byte::b#2 print_byte::b#0 print_byte::b#1 ] reg byte a [ print_byte::$0 ] reg byte a [ print_byte::$2 ] 
+Uplifting [div32u16u] best 29570 combination zp ZP_DWORD:73 [ div32u16u::return#3 ] zp ZP_WORD:134 [ div32u16u::quotient_lo#0 ] zp ZP_DWORD:144 [ div32u16u::return#2 ] zp ZP_DWORD:136 [ div32u16u::return#0 ] zp ZP_WORD:130 [ div32u16u::quotient_hi#0 ] 
+Uplifting [print_char] best 29558 combination reg byte a [ print_char::ch#3 print_char::ch#1 print_char::ch#2 ] 
+Uplifting [print_sword] best 29558 combination zp ZP_WORD:9 [ print_sword::w#3 print_sword::w#1 print_sword::w#0 ] 
+Uplifting [print_word] best 29558 combination 
 Attempting to uplift remaining variables inzp ZP_BYTE:11 [ print_byte::b#2 print_byte::b#0 print_byte::b#1 ]
-Uplifting [print_byte] best 29531 combination zp ZP_BYTE:11 [ print_byte::b#2 print_byte::b#0 print_byte::b#1 ] 
-Attempting to uplift remaining variables inzp ZP_BYTE:25 [ sin16sb::isUpper#2 ]
-Uplifting [sin16sb] best 29531 combination zp ZP_BYTE:25 [ sin16sb::isUpper#2 ] 
+Uplifting [print_byte] best 29558 combination zp ZP_BYTE:11 [ print_byte::b#2 print_byte::b#0 print_byte::b#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:62 [ sin16s::isUpper#2 ]
-Uplifting [sin16s] best 29531 combination zp ZP_BYTE:62 [ sin16s::isUpper#2 ] 
+Uplifting [sin16s] best 29558 combination zp ZP_BYTE:62 [ sin16s::isUpper#2 ] 
 Coalescing zero page register with common assignment [ zp ZP_WORD:28 [ sin16sb::return#1 sin16sb::return#5 sin16sb::sinx#1 ] ] with [ zp ZP_WORD:111 [ sin16sb::usinx#1 ] ] - score: 2
 Coalescing zero page register with common assignment [ zp ZP_WORD:30 [ mulu16_sel::v1#10 mulu16_sel::v1#3 mulu16_sel::v1#4 mulu16_sel::v1#0 mulu16_sel::v1#1 mulu16_sel::v1#2 mulu16_sel::v1#8 mulu16_sel::v1#9 mulu16_sel::v1#5 mulu16_sel::v1#6 mulu16_sel::v1#7 ] ] with [ zp ZP_WORD:93 [ sin16sb::x3#0 ] ] - score: 2
 Coalescing zero page register with common assignment [ zp ZP_WORD:30 [ mulu16_sel::v1#10 mulu16_sel::v1#3 mulu16_sel::v1#4 mulu16_sel::v1#0 mulu16_sel::v1#1 mulu16_sel::v1#2 mulu16_sel::v1#8 mulu16_sel::v1#9 mulu16_sel::v1#5 mulu16_sel::v1#6 mulu16_sel::v1#7 sin16sb::x3#0 ] ] with [ zp ZP_WORD:168 [ sin16s::x3#0 ] ] - score: 2
@@ -5616,27 +5617,26 @@ Allocated (was zp ZP_WORD:15) zp ZP_WORD:13 [ print_cls::sc#2 print_cls::sc#1 ]
 Allocated (was zp ZP_DWORD:17) zp ZP_DWORD:15 [ sin16s_genb::x#2 sin16s_genb::x#1 ]
 Allocated (was zp ZP_WORD:21) zp ZP_WORD:19 [ sin16s_genb::sintab#2 sin16s_genb::sintab#0 ]
 Allocated (was zp ZP_WORD:23) zp ZP_WORD:21 [ sin16s_genb::i#2 sin16s_genb::i#1 ]
-Allocated (was zp ZP_BYTE:25) zp ZP_BYTE:23 [ sin16sb::isUpper#2 ]
-Allocated (was zp ZP_WORD:26) zp ZP_WORD:24 [ sin16sb::x#6 sin16sb::x#4 sin16sb::x#0 sin16sb::x#1 sin16sb::x#2 sin16sb::x1#0 ]
-Allocated (was zp ZP_WORD:28) zp ZP_WORD:26 [ sin16sb::return#1 sin16sb::return#5 sin16sb::sinx#1 sin16sb::usinx#1 sin16sb::return#0 sin16s_genb::$2 sin16sb::usinx#0 ]
-Allocated (was zp ZP_WORD:30) zp ZP_WORD:28 [ mulu16_sel::v1#10 mulu16_sel::v1#3 mulu16_sel::v1#4 mulu16_sel::v1#0 mulu16_sel::v1#1 mulu16_sel::v1#2 mulu16_sel::v1#8 mulu16_sel::v1#9 mulu16_sel::v1#5 mulu16_sel::v1#6 mulu16_sel::v1#7 sin16sb::x3#0 sin16s::x3#0 sin16sb::x2#0 sin16sb::x4#0 sin16s::x2#0 sin16s::x4#0 mulu16_sel::return#19 mulu16_sel::return#10 mulu16_sel::return#0 mulu16_sel::return#1 mulu16_sel::return#15 ]
-Allocated (was zp ZP_WORD:32) zp ZP_WORD:30 [ mulu16_sel::v2#10 mulu16_sel::v2#3 mulu16_sel::v2#4 mulu16_sel::v2#0 mulu16_sel::v2#1 mulu16_sel::v2#8 mulu16_sel::v2#9 mulu16_sel::v2#5 mulu16_sel::v2#6 mul16u::b#0 ]
-Allocated (was zp ZP_WORD:35) zp ZP_WORD:32 [ mul16u::a#2 mul16u::a#1 mul16u::a#0 ]
-Allocated (was zp ZP_DWORD:37) zp ZP_DWORD:34 [ mul16u::res#2 mul16u::res#6 mul16u::res#1 mul16u::return#2 mulu16_sel::$0 mulu16_sel::$1 ]
-Allocated (was zp ZP_DWORD:41) zp ZP_DWORD:38 [ mul16u::mb#2 mul16u::mb#1 ]
-Allocated (was zp ZP_WORD:47) zp ZP_WORD:42 [ divr16u::rem#5 divr16u::rem#10 divr16u::rem#4 divr16u::rem#11 divr16u::rem#6 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 rem16u#1 ]
-Allocated (was zp ZP_WORD:49) zp ZP_WORD:44 [ divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#0 ]
-Allocated (was zp ZP_WORD:51) zp ZP_WORD:46 [ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 divr16u::return#2 divr16u::return#3 div32u16u::quotient_lo#0 ]
-Allocated (was zp ZP_DWORD:54) zp ZP_DWORD:48 [ sin16s_gen::x#2 sin16s_gen::x#1 ]
-Allocated (was zp ZP_WORD:58) zp ZP_WORD:52 [ sin16s_gen::sintab#2 sin16s_gen::sintab#0 ]
-Allocated (was zp ZP_WORD:60) zp ZP_WORD:54 [ sin16s_gen::i#2 sin16s_gen::i#1 ]
-Allocated (was zp ZP_BYTE:62) zp ZP_BYTE:56 [ sin16s::isUpper#2 ]
-Allocated (was zp ZP_DWORD:63) zp ZP_DWORD:57 [ sin16s::x#6 sin16s::x#4 sin16s::x#0 sin16s::x#1 sin16s::x#2 sin16s::$4 ]
-Allocated (was zp ZP_WORD:67) zp ZP_WORD:61 [ sin16s::return#1 sin16s::return#5 sin16s::sinx#1 sin16s::usinx#1 sin16s::return#0 sin16s_gen::$1 sin16s::usinx#0 ]
-Allocated (was zp ZP_DWORD:73) zp ZP_DWORD:63 [ div32u16u::return#3 sin16s_genb::step#0 div32u16u::return#0 div32u16u::return#2 sin16s_gen::step#0 ]
-Allocated (was zp ZP_WORD:87) zp ZP_WORD:67 [ mulu16_sel::return#18 mulu16_sel::return#17 mulu16_sel::return#20 sin16sb::x3_6#0 mulu16_sel::return#11 sin16sb::x5#0 mulu16_sel::return#14 sin16s::x3_6#0 mulu16_sel::return#16 sin16s::x5#0 sin16sb::x5_128#0 sin16s::x5_128#0 ]
-Allocated (was zp ZP_WORD:130) zp ZP_WORD:69 [ div32u16u::quotient_hi#0 ]
-Allocated (was zp ZP_WORD:160) zp ZP_WORD:71 [ sin16s::x1#0 ]
+Allocated (was zp ZP_WORD:26) zp ZP_WORD:23 [ sin16sb::x#6 sin16sb::x#4 sin16sb::x#0 sin16sb::x#1 sin16sb::x#2 sin16sb::x1#0 ]
+Allocated (was zp ZP_WORD:28) zp ZP_WORD:25 [ sin16sb::return#1 sin16sb::return#5 sin16sb::sinx#1 sin16sb::usinx#1 sin16sb::return#0 sin16s_genb::$2 sin16sb::usinx#0 ]
+Allocated (was zp ZP_WORD:30) zp ZP_WORD:27 [ mulu16_sel::v1#10 mulu16_sel::v1#3 mulu16_sel::v1#4 mulu16_sel::v1#0 mulu16_sel::v1#1 mulu16_sel::v1#2 mulu16_sel::v1#8 mulu16_sel::v1#9 mulu16_sel::v1#5 mulu16_sel::v1#6 mulu16_sel::v1#7 sin16sb::x3#0 sin16s::x3#0 sin16sb::x2#0 sin16sb::x4#0 sin16s::x2#0 sin16s::x4#0 mulu16_sel::return#19 mulu16_sel::return#10 mulu16_sel::return#0 mulu16_sel::return#1 mulu16_sel::return#15 ]
+Allocated (was zp ZP_WORD:32) zp ZP_WORD:29 [ mulu16_sel::v2#10 mulu16_sel::v2#3 mulu16_sel::v2#4 mulu16_sel::v2#0 mulu16_sel::v2#1 mulu16_sel::v2#8 mulu16_sel::v2#9 mulu16_sel::v2#5 mulu16_sel::v2#6 mul16u::b#0 ]
+Allocated (was zp ZP_WORD:35) zp ZP_WORD:31 [ mul16u::a#2 mul16u::a#1 mul16u::a#0 ]
+Allocated (was zp ZP_DWORD:37) zp ZP_DWORD:33 [ mul16u::res#2 mul16u::res#6 mul16u::res#1 mul16u::return#2 mulu16_sel::$0 mulu16_sel::$1 ]
+Allocated (was zp ZP_DWORD:41) zp ZP_DWORD:37 [ mul16u::mb#2 mul16u::mb#1 ]
+Allocated (was zp ZP_WORD:47) zp ZP_WORD:41 [ divr16u::rem#5 divr16u::rem#10 divr16u::rem#4 divr16u::rem#11 divr16u::rem#6 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 rem16u#1 ]
+Allocated (was zp ZP_WORD:49) zp ZP_WORD:43 [ divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#0 ]
+Allocated (was zp ZP_WORD:51) zp ZP_WORD:45 [ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 divr16u::return#2 divr16u::return#3 div32u16u::quotient_lo#0 ]
+Allocated (was zp ZP_DWORD:54) zp ZP_DWORD:47 [ sin16s_gen::x#2 sin16s_gen::x#1 ]
+Allocated (was zp ZP_WORD:58) zp ZP_WORD:51 [ sin16s_gen::sintab#2 sin16s_gen::sintab#0 ]
+Allocated (was zp ZP_WORD:60) zp ZP_WORD:53 [ sin16s_gen::i#2 sin16s_gen::i#1 ]
+Allocated (was zp ZP_BYTE:62) zp ZP_BYTE:55 [ sin16s::isUpper#2 ]
+Allocated (was zp ZP_DWORD:63) zp ZP_DWORD:56 [ sin16s::x#6 sin16s::x#4 sin16s::x#0 sin16s::x#1 sin16s::x#2 sin16s::$4 ]
+Allocated (was zp ZP_WORD:67) zp ZP_WORD:60 [ sin16s::return#1 sin16s::return#5 sin16s::sinx#1 sin16s::usinx#1 sin16s::return#0 sin16s_gen::$1 sin16s::usinx#0 ]
+Allocated (was zp ZP_DWORD:73) zp ZP_DWORD:62 [ div32u16u::return#3 sin16s_genb::step#0 div32u16u::return#0 div32u16u::return#2 sin16s_gen::step#0 ]
+Allocated (was zp ZP_WORD:87) zp ZP_WORD:66 [ mulu16_sel::return#18 mulu16_sel::return#17 mulu16_sel::return#20 sin16sb::x3_6#0 mulu16_sel::return#11 sin16sb::x5#0 mulu16_sel::return#14 sin16s::x3_6#0 mulu16_sel::return#16 sin16s::x5#0 sin16sb::x5_128#0 sin16s::x5_128#0 ]
+Allocated (was zp ZP_WORD:130) zp ZP_WORD:68 [ div32u16u::quotient_hi#0 ]
+Allocated (was zp ZP_WORD:160) zp ZP_WORD:70 [ sin16s::x1#0 ]
 
 ASSEMBLER BEFORE OPTIMIZATION
 //SEG0 File Comments
@@ -5658,7 +5658,7 @@ ASSEMBLER BEFORE OPTIMIZATION
   // PI/2 in u[4.12] format
   .const PI_HALF_u4f12 = $1922
   .label print_line_cursor = $400
-  .label rem16u = $2a
+  .label rem16u = $29
   .label print_char_cursor = $b
 //SEG3 @begin
 bbegin:
@@ -6044,8 +6044,8 @@ print_cls: {
 // wavelength - the number of sinus points in a total sinus wavelength (the size of the table)
 // sin16s_genb(signed word* zeropage($13) sintab)
 sin16s_genb: {
-    .label _2 = $1a
-    .label step = $3f
+    .label _2 = $19
+    .label step = $3e
     .label sintab = $13
     .label x = $f
     .label i = $15
@@ -6152,20 +6152,19 @@ sin16s_genb: {
 // 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
-// sin16sb(word zeropage($18) x)
+// sin16sb(word zeropage($17) x)
 sin16sb: {
-    .label x = $18
-    .label return = $1a
-    .label x1 = $18
-    .label x2 = $1c
-    .label x3 = $1c
-    .label x3_6 = $43
-    .label usinx = $1a
-    .label x4 = $1c
-    .label x5 = $43
-    .label x5_128 = $43
-    .label sinx = $1a
-    .label isUpper = $17
+    .label x = $17
+    .label return = $19
+    .label x1 = $17
+    .label x2 = $1b
+    .label x3 = $1b
+    .label x3_6 = $42
+    .label usinx = $19
+    .label x4 = $1b
+    .label x5 = $42
+    .label x5_128 = $42
+    .label sinx = $19
   //SEG161 [77] if((word) sin16sb::x#0<(const word) PI_u4f12#0) goto sin16sb::@1 -- vwuz1_lt_vwuc1_then_la1 
     lda x+1
     cmp #>PI_u4f12
@@ -6188,16 +6187,14 @@ sin16sb: {
     sta x+1
   //SEG164 [79] phi from sin16sb::@4 to sin16sb::@1 [phi:sin16sb::@4->sin16sb::@1]
   b1_from_b4:
-  //SEG165 [79] phi (byte) sin16sb::isUpper#2 = (byte) 1 [phi:sin16sb::@4->sin16sb::@1#0] -- vbuz1=vbuc1 
-    lda #1
-    sta isUpper
+  //SEG165 [79] phi (byte) sin16sb::isUpper#2 = (byte) 1 [phi:sin16sb::@4->sin16sb::@1#0] -- vbuyy=vbuc1 
+    ldy #1
   //SEG166 [79] phi (word) sin16sb::x#4 = (word) sin16sb::x#1 [phi:sin16sb::@4->sin16sb::@1#1] -- register_copy 
     jmp b1
   //SEG167 [79] phi from sin16sb to sin16sb::@1 [phi:sin16sb->sin16sb::@1]
   b1_from_sin16sb:
-  //SEG168 [79] phi (byte) sin16sb::isUpper#2 = (byte) 0 [phi:sin16sb->sin16sb::@1#0] -- vbuz1=vbuc1 
-    lda #0
-    sta isUpper
+  //SEG168 [79] phi (byte) sin16sb::isUpper#2 = (byte) 0 [phi:sin16sb->sin16sb::@1#0] -- vbuyy=vbuc1 
+    ldy #0
   //SEG169 [79] phi (word) sin16sb::x#4 = (word) sin16sb::x#0 [phi:sin16sb->sin16sb::@1#1] -- register_copy 
     jmp b1
   //SEG170 sin16sb::@1
@@ -6371,9 +6368,8 @@ sin16sb: {
     lda usinx+1
     adc x5_128+1
     sta usinx+1
-  //SEG230 [111] if((byte) sin16sb::isUpper#2==(byte) 0) goto sin16sb::@12 -- vbuz1_eq_0_then_la1 
-    lda isUpper
-    cmp #0
+  //SEG230 [111] if((byte) sin16sb::isUpper#2==(byte) 0) goto sin16sb::@12 -- vbuyy_eq_0_then_la1 
+    cpy #0
     beq b12
     jmp b6
   //SEG231 sin16sb::@6
@@ -6406,19 +6402,19 @@ sin16sb: {
 //SEG240 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 zeropage($1c) v1, word zeropage($1e) v2, byte register(X) select)
+// mulu16_sel(word zeropage($1b) v1, word zeropage($1d) v2, byte register(X) select)
 mulu16_sel: {
-    .label _0 = $22
-    .label _1 = $22
-    .label v1 = $1c
-    .label v2 = $1e
-    .label return = $1c
-    .label return_11 = $43
-    .label return_14 = $43
-    .label return_16 = $43
-    .label return_17 = $43
-    .label return_18 = $43
-    .label return_20 = $43
+    .label _0 = $21
+    .label _1 = $21
+    .label v1 = $1b
+    .label v2 = $1d
+    .label return = $1b
+    .label return_11 = $42
+    .label return_14 = $42
+    .label return_16 = $42
+    .label return_17 = $42
+    .label return_18 = $42
+    .label return_20 = $42
   //SEG241 [117] (word) mul16u::a#1 ← (word) mulu16_sel::v1#10 -- vwuz1=vwuz2 
     lda v1
     sta mul16u.a
@@ -6458,13 +6454,13 @@ mulu16_sel: {
 }
 //SEG252 mul16u
 // Perform binary multiplication of two unsigned 16-bit words into a 32-bit unsigned double word
-// mul16u(word zeropage($20) a, word zeropage($1e) b)
+// mul16u(word zeropage($1f) a, word zeropage($1d) b)
 mul16u: {
-    .label a = $20
-    .label mb = $26
-    .label res = $22
-    .label b = $1e
-    .label return = $22
+    .label a = $1f
+    .label mb = $25
+    .label res = $21
+    .label b = $1d
+    .label return = $21
   //SEG253 [126] phi from mul16u to mul16u::@1 [phi:mul16u->mul16u::@1]
   b1_from_mul16u:
   //SEG254 [126] phi (dword) mul16u::mb#2 = (word) mul16u::b#0 [phi:mul16u->mul16u::@1#0] -- vduz1=vwuz2 
@@ -6547,9 +6543,9 @@ mul16u: {
 // 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 = $45
-    .label quotient_lo = $2e
-    .label return = $3f
+    .label quotient_hi = $44
+    .label quotient_lo = $2d
+    .label return = $3e
   //SEG276 [136] call divr16u 
   //SEG277 [145] phi from div32u16u to divr16u [phi:div32u16u->divr16u]
   divr16u_from_div32u16u:
@@ -6609,12 +6605,12 @@ div32u16u: {
 // Returns the quotient dividend/divisor.
 // The final remainder will be set into the global variable rem16u
 // Implemented using simple binary division
-// divr16u(word zeropage($2c) dividend, word zeropage($2a) rem)
+// divr16u(word zeropage($2b) dividend, word zeropage($29) rem)
 divr16u: {
-    .label rem = $2a
-    .label dividend = $2c
-    .label quotient = $2e
-    .label return = $2e
+    .label rem = $29
+    .label dividend = $2b
+    .label quotient = $2d
+    .label return = $2d
   //SEG295 [146] phi from divr16u to divr16u::@1 [phi:divr16u->divr16u::@1]
   b1_from_divr16u:
   //SEG296 [146] phi (byte) divr16u::i#2 = (byte) 0 [phi:divr16u->divr16u::@1#0] -- vbuxx=vbuc1 
@@ -6718,13 +6714,13 @@ divr16u: {
 // 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* zeropage($34) sintab)
+// sin16s_gen(signed word* zeropage($33) sintab)
 sin16s_gen: {
-    .label _1 = $3d
-    .label step = $3f
-    .label sintab = $34
-    .label x = $30
-    .label i = $36
+    .label _1 = $3c
+    .label step = $3e
+    .label sintab = $33
+    .label x = $2f
+    .label i = $35
   //SEG332 [164] call div32u16u 
   //SEG333 [135] phi from sin16s_gen to div32u16u [phi:sin16s_gen->div32u16u]
   div32u16u_from_sin16s_gen:
@@ -6832,21 +6828,21 @@ sin16s_gen: {
 // 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 zeropage($39) x)
+// sin16s(dword zeropage($38) x)
 sin16s: {
-    .label _4 = $39
-    .label x = $39
-    .label return = $3d
-    .label x1 = $47
-    .label x2 = $1c
-    .label x3 = $1c
-    .label x3_6 = $43
-    .label usinx = $3d
-    .label x4 = $1c
-    .label x5 = $43
-    .label x5_128 = $43
-    .label sinx = $3d
-    .label isUpper = $38
+    .label _4 = $38
+    .label x = $38
+    .label return = $3c
+    .label x1 = $46
+    .label x2 = $1b
+    .label x3 = $1b
+    .label x3_6 = $42
+    .label usinx = $3c
+    .label x4 = $1b
+    .label x5 = $42
+    .label x5_128 = $42
+    .label sinx = $3c
+    .label isUpper = $37
   //SEG359 [178] if((dword) sin16s::x#0<(const dword) PI_u4f28#0) goto sin16s::@1 -- vduz1_lt_vduc1_then_la1 
     lda x+3
     cmp #>PI_u4f28>>$10
@@ -7400,13 +7396,13 @@ FINAL SYMBOL TABLE
 (word) div32u16u::divisor
 (dword) div32u16u::quotient
 (word) div32u16u::quotient_hi
-(word) div32u16u::quotient_hi#0 quotient_hi zp ZP_WORD:69 0.8
+(word) div32u16u::quotient_hi#0 quotient_hi zp ZP_WORD:68 0.8
 (word) div32u16u::quotient_lo
-(word) div32u16u::quotient_lo#0 quotient_lo zp ZP_WORD:46 4.0
+(word) div32u16u::quotient_lo#0 quotient_lo zp ZP_WORD:45 4.0
 (dword) div32u16u::return
-(dword) div32u16u::return#0 return zp ZP_DWORD:63 1.5
-(dword) div32u16u::return#2 return zp ZP_DWORD:63 4.0
-(dword) div32u16u::return#3 return zp ZP_DWORD:63 4.0
+(dword) div32u16u::return#0 return zp ZP_DWORD:62 1.5
+(dword) div32u16u::return#2 return zp ZP_DWORD:62 4.0
+(dword) div32u16u::return#3 return zp ZP_DWORD:62 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
@@ -7418,30 +7414,30 @@ FINAL SYMBOL TABLE
 (label) divr16u::@6
 (label) divr16u::@return
 (word) divr16u::dividend
-(word) divr16u::dividend#0 dividend zp ZP_WORD:44 2.75
-(word) divr16u::dividend#3 dividend zp ZP_WORD:44 5.0
-(word) divr16u::dividend#5 dividend zp ZP_WORD:44 2.0
+(word) divr16u::dividend#0 dividend zp ZP_WORD:43 2.75
+(word) divr16u::dividend#3 dividend zp ZP_WORD:43 5.0
+(word) divr16u::dividend#5 dividend zp ZP_WORD:43 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 ZP_WORD:46 16.5
-(word) divr16u::quotient#2 quotient zp ZP_WORD:46 11.0
-(word) divr16u::quotient#3 quotient zp ZP_WORD:46 2.75
+(word) divr16u::quotient#1 quotient zp ZP_WORD:45 16.5
+(word) divr16u::quotient#2 quotient zp ZP_WORD:45 11.0
+(word) divr16u::quotient#3 quotient zp ZP_WORD:45 2.75
 (word) divr16u::rem
-(word) divr16u::rem#0 rem zp ZP_WORD:42 8.25
-(word) divr16u::rem#1 rem zp ZP_WORD:42 22.0
-(word) divr16u::rem#10 rem zp ZP_WORD:42 4.0
-(word) divr16u::rem#11 rem zp ZP_WORD:42 11.666666666666666
-(word) divr16u::rem#2 rem zp ZP_WORD:42 22.0
-(word) divr16u::rem#4 rem zp ZP_WORD:42 4.0
-(word) divr16u::rem#5 rem zp ZP_WORD:42 24.0
-(word) divr16u::rem#6 rem zp ZP_WORD:42 11.0
+(word) divr16u::rem#0 rem zp ZP_WORD:41 8.25
+(word) divr16u::rem#1 rem zp ZP_WORD:41 22.0
+(word) divr16u::rem#10 rem zp ZP_WORD:41 4.0
+(word) divr16u::rem#11 rem zp ZP_WORD:41 11.666666666666666
+(word) divr16u::rem#2 rem zp ZP_WORD:41 22.0
+(word) divr16u::rem#4 rem zp ZP_WORD:41 4.0
+(word) divr16u::rem#5 rem zp ZP_WORD:41 24.0
+(word) divr16u::rem#6 rem zp ZP_WORD:41 11.0
 (word) divr16u::return
-(word) divr16u::return#0 return zp ZP_WORD:46 5.285714285714286
-(word) divr16u::return#2 return zp ZP_WORD:46 4.0
-(word) divr16u::return#3 return zp ZP_WORD:46 4.0
+(word) divr16u::return#0 return zp ZP_WORD:45 5.285714285714286
+(word) divr16u::return#2 return zp ZP_WORD:45 4.0
+(word) divr16u::return#3 return zp ZP_WORD:45 4.0
 (void()) main()
 (label) main::@1
 (label) main::@2
@@ -7478,61 +7474,61 @@ FINAL SYMBOL TABLE
 (label) mul16u::@4
 (label) mul16u::@return
 (word) mul16u::a
-(word) mul16u::a#0 a zp ZP_WORD:32 101.0
-(word) mul16u::a#1 a zp ZP_WORD:32 1.3333333333333333
-(word) mul16u::a#2 a zp ZP_WORD:32 67.66666666666666
+(word) mul16u::a#0 a zp ZP_WORD:31 101.0
+(word) mul16u::a#1 a zp ZP_WORD:31 1.3333333333333333
+(word) mul16u::a#2 a zp ZP_WORD:31 67.66666666666666
 (word) mul16u::b
-(word) mul16u::b#0 b zp ZP_WORD:30 2.0
+(word) mul16u::b#0 b zp ZP_WORD:29 2.0
 (dword) mul16u::mb
-(dword) mul16u::mb#1 mb zp ZP_DWORD:38 202.0
-(dword) mul16u::mb#2 mb zp ZP_DWORD:38 43.57142857142858
+(dword) mul16u::mb#1 mb zp ZP_DWORD:37 202.0
+(dword) mul16u::mb#2 mb zp ZP_DWORD:37 43.57142857142858
 (dword) mul16u::res
-(dword) mul16u::res#1 res zp ZP_DWORD:34 202.0
-(dword) mul16u::res#2 res zp ZP_DWORD:34 50.83333333333333
-(dword) mul16u::res#6 res zp ZP_DWORD:34 101.0
+(dword) mul16u::res#1 res zp ZP_DWORD:33 202.0
+(dword) mul16u::res#2 res zp ZP_DWORD:33 50.83333333333333
+(dword) mul16u::res#6 res zp ZP_DWORD:33 101.0
 (dword) mul16u::return
-(dword) mul16u::return#2 return zp ZP_DWORD:34 4.0
+(dword) mul16u::return#2 return zp ZP_DWORD:33 4.0
 (word()) mulu16_sel((word) mulu16_sel::v1 , (word) mulu16_sel::v2 , (byte) mulu16_sel::select)
-(dword~) mulu16_sel::$0 $0 zp ZP_DWORD:34 4.0
-(dword~) mulu16_sel::$1 $1 zp ZP_DWORD:34 4.0
+(dword~) mulu16_sel::$0 $0 zp ZP_DWORD:33 4.0
+(dword~) mulu16_sel::$1 $1 zp ZP_DWORD:33 4.0
 (label) mulu16_sel::@1
 (label) mulu16_sel::@return
 (word) mulu16_sel::return
-(word) mulu16_sel::return#0 return zp ZP_WORD:28 4.0
-(word) mulu16_sel::return#1 return zp ZP_WORD:28 4.0
-(word) mulu16_sel::return#10 return zp ZP_WORD:28 4.0
-(word) mulu16_sel::return#11 return#11 zp ZP_WORD:67 4.0
-(word) mulu16_sel::return#14 return#14 zp ZP_WORD:67 4.0
-(word) mulu16_sel::return#15 return zp ZP_WORD:28 4.0
-(word) mulu16_sel::return#16 return#16 zp ZP_WORD:67 4.0
-(word) mulu16_sel::return#17 return#17 zp ZP_WORD:67 1.8333333333333335
-(word) mulu16_sel::return#18 return#18 zp ZP_WORD:67 4.0
-(word) mulu16_sel::return#19 return zp ZP_WORD:28 4.0
-(word) mulu16_sel::return#20 return#20 zp ZP_WORD:67 4.0
+(word) mulu16_sel::return#0 return zp ZP_WORD:27 4.0
+(word) mulu16_sel::return#1 return zp ZP_WORD:27 4.0
+(word) mulu16_sel::return#10 return zp ZP_WORD:27 4.0
+(word) mulu16_sel::return#11 return#11 zp ZP_WORD:66 4.0
+(word) mulu16_sel::return#14 return#14 zp ZP_WORD:66 4.0
+(word) mulu16_sel::return#15 return zp ZP_WORD:27 4.0
+(word) mulu16_sel::return#16 return#16 zp ZP_WORD:66 4.0
+(word) mulu16_sel::return#17 return#17 zp ZP_WORD:66 1.8333333333333335
+(word) mulu16_sel::return#18 return#18 zp ZP_WORD:66 4.0
+(word) mulu16_sel::return#19 return zp ZP_WORD:27 4.0
+(word) mulu16_sel::return#20 return#20 zp ZP_WORD:66 4.0
 (byte) mulu16_sel::select
 (byte) mulu16_sel::select#10 reg byte x 0.3333333333333333
 (word) mulu16_sel::v1
-(word) mulu16_sel::v1#0 v1 zp ZP_WORD:28 2.0
-(word) mulu16_sel::v1#1 v1 zp ZP_WORD:28 2.0
-(word) mulu16_sel::v1#10 v1 zp ZP_WORD:28 22.0
-(word) mulu16_sel::v1#2 v1 zp ZP_WORD:28 4.0
-(word) mulu16_sel::v1#3 v1 zp ZP_WORD:28 2.0
-(word) mulu16_sel::v1#4 v1 zp ZP_WORD:28 2.0
-(word) mulu16_sel::v1#5 v1 zp ZP_WORD:28 2.0
-(word) mulu16_sel::v1#6 v1 zp ZP_WORD:28 2.0
-(word) mulu16_sel::v1#7 v1 zp ZP_WORD:28 4.0
-(word) mulu16_sel::v1#8 v1 zp ZP_WORD:28 2.0
-(word) mulu16_sel::v1#9 v1 zp ZP_WORD:28 2.0
+(word) mulu16_sel::v1#0 v1 zp ZP_WORD:27 2.0
+(word) mulu16_sel::v1#1 v1 zp ZP_WORD:27 2.0
+(word) mulu16_sel::v1#10 v1 zp ZP_WORD:27 22.0
+(word) mulu16_sel::v1#2 v1 zp ZP_WORD:27 4.0
+(word) mulu16_sel::v1#3 v1 zp ZP_WORD:27 2.0
+(word) mulu16_sel::v1#4 v1 zp ZP_WORD:27 2.0
+(word) mulu16_sel::v1#5 v1 zp ZP_WORD:27 2.0
+(word) mulu16_sel::v1#6 v1 zp ZP_WORD:27 2.0
+(word) mulu16_sel::v1#7 v1 zp ZP_WORD:27 4.0
+(word) mulu16_sel::v1#8 v1 zp ZP_WORD:27 2.0
+(word) mulu16_sel::v1#9 v1 zp ZP_WORD:27 2.0
 (word) mulu16_sel::v2
-(word) mulu16_sel::v2#0 v2 zp ZP_WORD:30 4.0
-(word) mulu16_sel::v2#1 v2 zp ZP_WORD:30 4.0
-(word) mulu16_sel::v2#10 v2 zp ZP_WORD:30 9.0
-(word) mulu16_sel::v2#3 v2 zp ZP_WORD:30 4.0
-(word) mulu16_sel::v2#4 v2 zp ZP_WORD:30 4.0
-(word) mulu16_sel::v2#5 v2 zp ZP_WORD:30 4.0
-(word) mulu16_sel::v2#6 v2 zp ZP_WORD:30 4.0
-(word) mulu16_sel::v2#8 v2 zp ZP_WORD:30 4.0
-(word) mulu16_sel::v2#9 v2 zp ZP_WORD:30 4.0
+(word) mulu16_sel::v2#0 v2 zp ZP_WORD:29 4.0
+(word) mulu16_sel::v2#1 v2 zp ZP_WORD:29 4.0
+(word) mulu16_sel::v2#10 v2 zp ZP_WORD:29 9.0
+(word) mulu16_sel::v2#3 v2 zp ZP_WORD:29 4.0
+(word) mulu16_sel::v2#4 v2 zp ZP_WORD:29 4.0
+(word) mulu16_sel::v2#5 v2 zp ZP_WORD:29 4.0
+(word) mulu16_sel::v2#6 v2 zp ZP_WORD:29 4.0
+(word) mulu16_sel::v2#8 v2 zp ZP_WORD:29 4.0
+(word) mulu16_sel::v2#9 v2 zp ZP_WORD:29 4.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
@@ -7591,9 +7587,9 @@ FINAL SYMBOL TABLE
 (label) print_word::@return
 (word) print_word::w
 (word) rem16u
-(word) rem16u#1 rem16u zp ZP_WORD:42 0.8
+(word) rem16u#1 rem16u zp ZP_WORD:41 0.8
 (signed word()) sin16s((dword) sin16s::x)
-(dword~) sin16s::$4 $4 zp ZP_DWORD:57 4.0
+(dword~) sin16s::$4 $4 zp ZP_DWORD:56 4.0
 (label) sin16s::@1
 (label) sin16s::@10
 (label) sin16s::@11
@@ -7608,56 +7604,56 @@ FINAL SYMBOL TABLE
 (label) sin16s::@9
 (label) sin16s::@return
 (byte) sin16s::isUpper
-(byte) sin16s::isUpper#2 isUpper zp ZP_BYTE:56 0.06060606060606061
+(byte) sin16s::isUpper#2 isUpper zp ZP_BYTE:55 0.06060606060606061
 (signed word) sin16s::return
-(signed word) sin16s::return#0 return zp ZP_WORD:61 22.0
-(signed word) sin16s::return#1 return zp ZP_WORD:61 5.0
-(signed word~) sin16s::return#5 return zp ZP_WORD:61 4.0
+(signed word) sin16s::return#0 return zp ZP_WORD:60 22.0
+(signed word) sin16s::return#1 return zp ZP_WORD:60 5.0
+(signed word~) sin16s::return#5 return zp ZP_WORD:60 4.0
 (signed word) sin16s::sinx
-(signed word) sin16s::sinx#1 sinx zp ZP_WORD:61 4.0
+(signed word) sin16s::sinx#1 sinx zp ZP_WORD:60 4.0
 (word) sin16s::usinx
-(word) sin16s::usinx#0 usinx zp ZP_WORD:61 0.3333333333333333
-(word) sin16s::usinx#1 usinx zp ZP_WORD:61 1.0
+(word) sin16s::usinx#0 usinx zp ZP_WORD:60 0.3333333333333333
+(word) sin16s::usinx#1 usinx zp ZP_WORD:60 1.0
 (dword) sin16s::x
-(dword) sin16s::x#0 x zp ZP_DWORD:57 8.5
-(dword) sin16s::x#1 x zp ZP_DWORD:57 4.0
-(dword) sin16s::x#2 x zp ZP_DWORD:57 4.0
-(dword) sin16s::x#4 x zp ZP_DWORD:57 5.0
-(dword) sin16s::x#6 x zp ZP_DWORD:57 6.0
+(dword) sin16s::x#0 x zp ZP_DWORD:56 8.5
+(dword) sin16s::x#1 x zp ZP_DWORD:56 4.0
+(dword) sin16s::x#2 x zp ZP_DWORD:56 4.0
+(dword) sin16s::x#4 x zp ZP_DWORD:56 5.0
+(dword) sin16s::x#6 x zp ZP_DWORD:56 6.0
 (word) sin16s::x1
-(word) sin16s::x1#0 x1 zp ZP_WORD:71 0.6363636363636365
+(word) sin16s::x1#0 x1 zp ZP_WORD:70 0.6363636363636365
 (word) sin16s::x2
-(word) sin16s::x2#0 x2 zp ZP_WORD:28 4.0
+(word) sin16s::x2#0 x2 zp ZP_WORD:27 4.0
 (word) sin16s::x3
-(word) sin16s::x3#0 x3 zp ZP_WORD:28 1.0
+(word) sin16s::x3#0 x3 zp ZP_WORD:27 1.0
 (word) sin16s::x3_6
-(word) sin16s::x3_6#0 x3_6 zp ZP_WORD:67 4.0
+(word) sin16s::x3_6#0 x3_6 zp ZP_WORD:66 4.0
 (word) sin16s::x4
-(word) sin16s::x4#0 x4 zp ZP_WORD:28 4.0
+(word) sin16s::x4#0 x4 zp ZP_WORD:27 4.0
 (word) sin16s::x5
-(word) sin16s::x5#0 x5 zp ZP_WORD:67 4.0
+(word) sin16s::x5#0 x5 zp ZP_WORD:66 4.0
 (word) sin16s::x5_128
-(word) sin16s::x5_128#0 x5_128 zp ZP_WORD:67 4.0
+(word) sin16s::x5_128#0 x5_128 zp ZP_WORD:66 4.0
 (void()) sin16s_gen((signed word*) sin16s_gen::sintab , (word) sin16s_gen::wavelength)
-(signed word~) sin16s_gen::$1 $1 zp ZP_WORD:61 22.0
+(signed word~) sin16s_gen::$1 $1 zp ZP_WORD:60 22.0
 (label) sin16s_gen::@1
 (label) sin16s_gen::@2
 (label) sin16s_gen::@3
 (label) sin16s_gen::@return
 (word) sin16s_gen::i
-(word) sin16s_gen::i#1 i zp ZP_WORD:54 16.5
-(word) sin16s_gen::i#2 i zp ZP_WORD:54 2.75
+(word) sin16s_gen::i#1 i zp ZP_WORD:53 16.5
+(word) sin16s_gen::i#2 i zp ZP_WORD:53 2.75
 (signed word*) sin16s_gen::sintab
-(signed word*) sin16s_gen::sintab#0 sintab zp ZP_WORD:52 5.5
-(signed word*) sin16s_gen::sintab#2 sintab zp ZP_WORD:52 5.5
+(signed word*) sin16s_gen::sintab#0 sintab zp ZP_WORD:51 5.5
+(signed word*) sin16s_gen::sintab#2 sintab zp ZP_WORD:51 5.5
 (dword) sin16s_gen::step
-(dword) sin16s_gen::step#0 step zp ZP_DWORD:63 1.1818181818181819
+(dword) sin16s_gen::step#0 step zp ZP_DWORD:62 1.1818181818181819
 (word) sin16s_gen::wavelength
 (dword) sin16s_gen::x
-(dword) sin16s_gen::x#1 x zp ZP_DWORD:48 7.333333333333333
-(dword) sin16s_gen::x#2 x zp ZP_DWORD:48 4.714285714285714
+(dword) sin16s_gen::x#1 x zp ZP_DWORD:47 7.333333333333333
+(dword) sin16s_gen::x#2 x zp ZP_DWORD:47 4.714285714285714
 (void()) sin16s_genb((signed word*) sin16s_genb::sintab , (word) sin16s_genb::wavelength)
-(signed word~) sin16s_genb::$2 $2 zp ZP_WORD:26 22.0
+(signed word~) sin16s_genb::$2 $2 zp ZP_WORD:25 22.0
 (label) sin16s_genb::@1
 (label) sin16s_genb::@2
 (label) sin16s_genb::@3
@@ -7669,7 +7665,7 @@ FINAL SYMBOL TABLE
 (signed word*) sin16s_genb::sintab#0 sintab zp ZP_WORD:19 5.5
 (signed word*) sin16s_genb::sintab#2 sintab zp ZP_WORD:19 5.5
 (dword) sin16s_genb::step
-(dword) sin16s_genb::step#0 step zp ZP_DWORD:63 1.1818181818181819
+(dword) sin16s_genb::step#0 step zp ZP_DWORD:62 1.1818181818181819
 (word) sin16s_genb::wavelength
 (dword) sin16s_genb::x
 (dword) sin16s_genb::x#1 x zp ZP_DWORD:15 7.333333333333333
@@ -7689,36 +7685,36 @@ FINAL SYMBOL TABLE
 (label) sin16sb::@9
 (label) sin16sb::@return
 (byte) sin16sb::isUpper
-(byte) sin16sb::isUpper#2 isUpper zp ZP_BYTE:23 0.0625
+(byte) sin16sb::isUpper#2 reg byte y 0.0625
 (signed word) sin16sb::return
-(signed word) sin16sb::return#0 return zp ZP_WORD:26 22.0
-(signed word) sin16sb::return#1 return zp ZP_WORD:26 5.0
-(signed word~) sin16sb::return#5 return zp ZP_WORD:26 4.0
+(signed word) sin16sb::return#0 return zp ZP_WORD:25 22.0
+(signed word) sin16sb::return#1 return zp ZP_WORD:25 5.0
+(signed word~) sin16sb::return#5 return zp ZP_WORD:25 4.0
 (signed word) sin16sb::sinx
-(signed word) sin16sb::sinx#1 sinx zp ZP_WORD:26 4.0
+(signed word) sin16sb::sinx#1 sinx zp ZP_WORD:25 4.0
 (word) sin16sb::usinx
-(word) sin16sb::usinx#0 usinx zp ZP_WORD:26 0.3333333333333333
-(word) sin16sb::usinx#1 usinx zp ZP_WORD:26 1.0
+(word) sin16sb::usinx#0 usinx zp ZP_WORD:25 0.3333333333333333
+(word) sin16sb::usinx#1 usinx zp ZP_WORD:25 1.0
 (word) sin16sb::x
-(word) sin16sb::x#0 x zp ZP_WORD:24 8.5
-(word) sin16sb::x#1 x zp ZP_WORD:24 4.0
-(word) sin16sb::x#2 x zp ZP_WORD:24 4.0
-(word) sin16sb::x#4 x zp ZP_WORD:24 5.0
-(word) sin16sb::x#6 x zp ZP_WORD:24 6.0
+(word) sin16sb::x#0 x zp ZP_WORD:23 8.5
+(word) sin16sb::x#1 x zp ZP_WORD:23 4.0
+(word) sin16sb::x#2 x zp ZP_WORD:23 4.0
+(word) sin16sb::x#4 x zp ZP_WORD:23 5.0
+(word) sin16sb::x#6 x zp ZP_WORD:23 6.0
 (word) sin16sb::x1
-(word) sin16sb::x1#0 x1 zp ZP_WORD:24 0.6363636363636365
+(word) sin16sb::x1#0 x1 zp ZP_WORD:23 0.6363636363636365
 (word) sin16sb::x2
-(word) sin16sb::x2#0 x2 zp ZP_WORD:28 4.0
+(word) sin16sb::x2#0 x2 zp ZP_WORD:27 4.0
 (word) sin16sb::x3
-(word) sin16sb::x3#0 x3 zp ZP_WORD:28 1.0
+(word) sin16sb::x3#0 x3 zp ZP_WORD:27 1.0
 (word) sin16sb::x3_6
-(word) sin16sb::x3_6#0 x3_6 zp ZP_WORD:67 4.0
+(word) sin16sb::x3_6#0 x3_6 zp ZP_WORD:66 4.0
 (word) sin16sb::x4
-(word) sin16sb::x4#0 x4 zp ZP_WORD:28 4.0
+(word) sin16sb::x4#0 x4 zp ZP_WORD:27 4.0
 (word) sin16sb::x5
-(word) sin16sb::x5#0 x5 zp ZP_WORD:67 4.0
+(word) sin16sb::x5#0 x5 zp ZP_WORD:66 4.0
 (word) sin16sb::x5_128
-(word) sin16sb::x5_128#0 x5_128 zp ZP_WORD:67 4.0
+(word) sin16sb::x5_128#0 x5_128 zp ZP_WORD:66 4.0
 
 zp ZP_WORD:2 [ main::st1#2 main::st1#1 ]
 zp ZP_WORD:4 [ main::st2#2 main::st2#1 ]
@@ -7732,38 +7728,38 @@ zp ZP_WORD:13 [ print_cls::sc#2 print_cls::sc#1 ]
 zp ZP_DWORD:15 [ sin16s_genb::x#2 sin16s_genb::x#1 ]
 zp ZP_WORD:19 [ sin16s_genb::sintab#2 sin16s_genb::sintab#0 ]
 zp ZP_WORD:21 [ sin16s_genb::i#2 sin16s_genb::i#1 ]
-zp ZP_BYTE:23 [ sin16sb::isUpper#2 ]
-zp ZP_WORD:24 [ sin16sb::x#6 sin16sb::x#4 sin16sb::x#0 sin16sb::x#1 sin16sb::x#2 sin16sb::x1#0 ]
-zp ZP_WORD:26 [ sin16sb::return#1 sin16sb::return#5 sin16sb::sinx#1 sin16sb::usinx#1 sin16sb::return#0 sin16s_genb::$2 sin16sb::usinx#0 ]
-zp ZP_WORD:28 [ mulu16_sel::v1#10 mulu16_sel::v1#3 mulu16_sel::v1#4 mulu16_sel::v1#0 mulu16_sel::v1#1 mulu16_sel::v1#2 mulu16_sel::v1#8 mulu16_sel::v1#9 mulu16_sel::v1#5 mulu16_sel::v1#6 mulu16_sel::v1#7 sin16sb::x3#0 sin16s::x3#0 sin16sb::x2#0 sin16sb::x4#0 sin16s::x2#0 sin16s::x4#0 mulu16_sel::return#19 mulu16_sel::return#10 mulu16_sel::return#0 mulu16_sel::return#1 mulu16_sel::return#15 ]
-zp ZP_WORD:30 [ mulu16_sel::v2#10 mulu16_sel::v2#3 mulu16_sel::v2#4 mulu16_sel::v2#0 mulu16_sel::v2#1 mulu16_sel::v2#8 mulu16_sel::v2#9 mulu16_sel::v2#5 mulu16_sel::v2#6 mul16u::b#0 ]
+reg byte y [ sin16sb::isUpper#2 ]
+zp ZP_WORD:23 [ sin16sb::x#6 sin16sb::x#4 sin16sb::x#0 sin16sb::x#1 sin16sb::x#2 sin16sb::x1#0 ]
+zp ZP_WORD:25 [ sin16sb::return#1 sin16sb::return#5 sin16sb::sinx#1 sin16sb::usinx#1 sin16sb::return#0 sin16s_genb::$2 sin16sb::usinx#0 ]
+zp ZP_WORD:27 [ mulu16_sel::v1#10 mulu16_sel::v1#3 mulu16_sel::v1#4 mulu16_sel::v1#0 mulu16_sel::v1#1 mulu16_sel::v1#2 mulu16_sel::v1#8 mulu16_sel::v1#9 mulu16_sel::v1#5 mulu16_sel::v1#6 mulu16_sel::v1#7 sin16sb::x3#0 sin16s::x3#0 sin16sb::x2#0 sin16sb::x4#0 sin16s::x2#0 sin16s::x4#0 mulu16_sel::return#19 mulu16_sel::return#10 mulu16_sel::return#0 mulu16_sel::return#1 mulu16_sel::return#15 ]
+zp ZP_WORD:29 [ mulu16_sel::v2#10 mulu16_sel::v2#3 mulu16_sel::v2#4 mulu16_sel::v2#0 mulu16_sel::v2#1 mulu16_sel::v2#8 mulu16_sel::v2#9 mulu16_sel::v2#5 mulu16_sel::v2#6 mul16u::b#0 ]
 reg byte x [ mulu16_sel::select#10 ]
-zp ZP_WORD:32 [ mul16u::a#2 mul16u::a#1 mul16u::a#0 ]
-zp ZP_DWORD:34 [ mul16u::res#2 mul16u::res#6 mul16u::res#1 mul16u::return#2 mulu16_sel::$0 mulu16_sel::$1 ]
-zp ZP_DWORD:38 [ mul16u::mb#2 mul16u::mb#1 ]
-zp ZP_WORD:42 [ divr16u::rem#5 divr16u::rem#10 divr16u::rem#4 divr16u::rem#11 divr16u::rem#6 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 rem16u#1 ]
-zp ZP_WORD:44 [ divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#0 ]
-zp ZP_WORD:46 [ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 divr16u::return#2 divr16u::return#3 div32u16u::quotient_lo#0 ]
+zp ZP_WORD:31 [ mul16u::a#2 mul16u::a#1 mul16u::a#0 ]
+zp ZP_DWORD:33 [ mul16u::res#2 mul16u::res#6 mul16u::res#1 mul16u::return#2 mulu16_sel::$0 mulu16_sel::$1 ]
+zp ZP_DWORD:37 [ mul16u::mb#2 mul16u::mb#1 ]
+zp ZP_WORD:41 [ divr16u::rem#5 divr16u::rem#10 divr16u::rem#4 divr16u::rem#11 divr16u::rem#6 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 rem16u#1 ]
+zp ZP_WORD:43 [ divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#0 ]
+zp ZP_WORD:45 [ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 divr16u::return#2 divr16u::return#3 div32u16u::quotient_lo#0 ]
 reg byte x [ divr16u::i#2 divr16u::i#1 ]
-zp ZP_DWORD:48 [ sin16s_gen::x#2 sin16s_gen::x#1 ]
-zp ZP_WORD:52 [ sin16s_gen::sintab#2 sin16s_gen::sintab#0 ]
-zp ZP_WORD:54 [ sin16s_gen::i#2 sin16s_gen::i#1 ]
-zp ZP_BYTE:56 [ sin16s::isUpper#2 ]
-zp ZP_DWORD:57 [ sin16s::x#6 sin16s::x#4 sin16s::x#0 sin16s::x#1 sin16s::x#2 sin16s::$4 ]
-zp ZP_WORD:61 [ sin16s::return#1 sin16s::return#5 sin16s::sinx#1 sin16s::usinx#1 sin16s::return#0 sin16s_gen::$1 sin16s::usinx#0 ]
+zp ZP_DWORD:47 [ sin16s_gen::x#2 sin16s_gen::x#1 ]
+zp ZP_WORD:51 [ sin16s_gen::sintab#2 sin16s_gen::sintab#0 ]
+zp ZP_WORD:53 [ sin16s_gen::i#2 sin16s_gen::i#1 ]
+zp ZP_BYTE:55 [ sin16s::isUpper#2 ]
+zp ZP_DWORD:56 [ sin16s::x#6 sin16s::x#4 sin16s::x#0 sin16s::x#1 sin16s::x#2 sin16s::$4 ]
+zp ZP_WORD:60 [ sin16s::return#1 sin16s::return#5 sin16s::sinx#1 sin16s::usinx#1 sin16s::return#0 sin16s_gen::$1 sin16s::usinx#0 ]
 reg byte a [ print_byte::$0 ]
 reg byte a [ print_byte::$2 ]
-zp ZP_DWORD:63 [ div32u16u::return#3 sin16s_genb::step#0 div32u16u::return#0 div32u16u::return#2 sin16s_gen::step#0 ]
-zp ZP_WORD:67 [ mulu16_sel::return#18 mulu16_sel::return#17 mulu16_sel::return#20 sin16sb::x3_6#0 mulu16_sel::return#11 sin16sb::x5#0 mulu16_sel::return#14 sin16s::x3_6#0 mulu16_sel::return#16 sin16s::x5#0 sin16sb::x5_128#0 sin16s::x5_128#0 ]
+zp ZP_DWORD:62 [ div32u16u::return#3 sin16s_genb::step#0 div32u16u::return#0 div32u16u::return#2 sin16s_gen::step#0 ]
+zp ZP_WORD:66 [ mulu16_sel::return#18 mulu16_sel::return#17 mulu16_sel::return#20 sin16sb::x3_6#0 mulu16_sel::return#11 sin16sb::x5#0 mulu16_sel::return#14 sin16s::x3_6#0 mulu16_sel::return#16 sin16s::x5#0 sin16sb::x5_128#0 sin16s::x5_128#0 ]
 reg byte a [ mul16u::$1 ]
-zp ZP_WORD:69 [ div32u16u::quotient_hi#0 ]
+zp ZP_WORD:68 [ div32u16u::quotient_hi#0 ]
 reg byte a [ divr16u::$1 ]
 reg byte a [ divr16u::$2 ]
-zp ZP_WORD:71 [ sin16s::x1#0 ]
+zp ZP_WORD:70 [ sin16s::x1#0 ]
 
 
 FINAL ASSEMBLER
-Score: 24941
+Score: 24932
 
 //SEG0 File Comments
 // Generates a 16-bit signed sinus
@@ -7784,7 +7780,7 @@ Score: 24941
   // PI/2 in u[4.12] format
   .const PI_HALF_u4f12 = $1922
   .label print_line_cursor = $400
-  .label rem16u = $2a
+  .label rem16u = $29
   .label print_char_cursor = $b
 //SEG3 @begin
 //SEG4 [1] phi from @begin to @1 [phi:@begin->@1]
@@ -8095,8 +8091,8 @@ print_cls: {
 // wavelength - the number of sinus points in a total sinus wavelength (the size of the table)
 // sin16s_genb(signed word* zeropage($13) sintab)
 sin16s_genb: {
-    .label _2 = $1a
-    .label step = $3f
+    .label _2 = $19
+    .label step = $3e
     .label sintab = $13
     .label x = $f
     .label i = $15
@@ -8190,20 +8186,19 @@ sin16s_genb: {
 // 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
-// sin16sb(word zeropage($18) x)
+// sin16sb(word zeropage($17) x)
 sin16sb: {
-    .label x = $18
-    .label return = $1a
-    .label x1 = $18
-    .label x2 = $1c
-    .label x3 = $1c
-    .label x3_6 = $43
-    .label usinx = $1a
-    .label x4 = $1c
-    .label x5 = $43
-    .label x5_128 = $43
-    .label sinx = $1a
-    .label isUpper = $17
+    .label x = $17
+    .label return = $19
+    .label x1 = $17
+    .label x2 = $1b
+    .label x3 = $1b
+    .label x3_6 = $42
+    .label usinx = $19
+    .label x4 = $1b
+    .label x5 = $42
+    .label x5_128 = $42
+    .label sinx = $19
   //SEG161 [77] if((word) sin16sb::x#0<(const word) PI_u4f12#0) goto sin16sb::@1 -- vwuz1_lt_vwuc1_then_la1 
     lda x+1
     cmp #>PI_u4f12
@@ -8223,16 +8218,14 @@ sin16sb: {
     sbc #>PI_u4f12
     sta x+1
   //SEG164 [79] phi from sin16sb::@4 to sin16sb::@1 [phi:sin16sb::@4->sin16sb::@1]
-  //SEG165 [79] phi (byte) sin16sb::isUpper#2 = (byte) 1 [phi:sin16sb::@4->sin16sb::@1#0] -- vbuz1=vbuc1 
-    lda #1
-    sta isUpper
+  //SEG165 [79] phi (byte) sin16sb::isUpper#2 = (byte) 1 [phi:sin16sb::@4->sin16sb::@1#0] -- vbuyy=vbuc1 
+    ldy #1
   //SEG166 [79] phi (word) sin16sb::x#4 = (word) sin16sb::x#1 [phi:sin16sb::@4->sin16sb::@1#1] -- register_copy 
     jmp b1
   //SEG167 [79] phi from sin16sb to sin16sb::@1 [phi:sin16sb->sin16sb::@1]
   b4:
-  //SEG168 [79] phi (byte) sin16sb::isUpper#2 = (byte) 0 [phi:sin16sb->sin16sb::@1#0] -- vbuz1=vbuc1 
-    lda #0
-    sta isUpper
+  //SEG168 [79] phi (byte) sin16sb::isUpper#2 = (byte) 0 [phi:sin16sb->sin16sb::@1#0] -- vbuyy=vbuc1 
+    ldy #0
   //SEG169 [79] phi (word) sin16sb::x#4 = (word) sin16sb::x#0 [phi:sin16sb->sin16sb::@1#1] -- register_copy 
   //SEG170 sin16sb::@1
   b1:
@@ -8385,9 +8378,8 @@ sin16sb: {
     lda usinx+1
     adc x5_128+1
     sta usinx+1
-  //SEG230 [111] if((byte) sin16sb::isUpper#2==(byte) 0) goto sin16sb::@12 -- vbuz1_eq_0_then_la1 
-    lda isUpper
-    cmp #0
+  //SEG230 [111] if((byte) sin16sb::isUpper#2==(byte) 0) goto sin16sb::@12 -- vbuyy_eq_0_then_la1 
+    cpy #0
     beq b3
   //SEG231 sin16sb::@6
   //SEG232 [112] (signed word) sin16sb::sinx#1 ← - (signed word)(word) sin16sb::usinx#1 -- vwsz1=_neg_vwsz1 
@@ -8411,19 +8403,19 @@ sin16sb: {
 //SEG240 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 zeropage($1c) v1, word zeropage($1e) v2, byte register(X) select)
+// mulu16_sel(word zeropage($1b) v1, word zeropage($1d) v2, byte register(X) select)
 mulu16_sel: {
-    .label _0 = $22
-    .label _1 = $22
-    .label v1 = $1c
-    .label v2 = $1e
-    .label return = $1c
-    .label return_11 = $43
-    .label return_14 = $43
-    .label return_16 = $43
-    .label return_17 = $43
-    .label return_18 = $43
-    .label return_20 = $43
+    .label _0 = $21
+    .label _1 = $21
+    .label v1 = $1b
+    .label v2 = $1d
+    .label return = $1b
+    .label return_11 = $42
+    .label return_14 = $42
+    .label return_16 = $42
+    .label return_17 = $42
+    .label return_18 = $42
+    .label return_20 = $42
   //SEG241 [117] (word) mul16u::a#1 ← (word) mulu16_sel::v1#10 -- vwuz1=vwuz2 
     lda v1
     sta mul16u.a
@@ -8458,13 +8450,13 @@ mulu16_sel: {
 }
 //SEG252 mul16u
 // Perform binary multiplication of two unsigned 16-bit words into a 32-bit unsigned double word
-// mul16u(word zeropage($20) a, word zeropage($1e) b)
+// mul16u(word zeropage($1f) a, word zeropage($1d) b)
 mul16u: {
-    .label a = $20
-    .label mb = $26
-    .label res = $22
-    .label b = $1e
-    .label return = $22
+    .label a = $1f
+    .label mb = $25
+    .label res = $21
+    .label b = $1d
+    .label return = $21
   //SEG253 [126] phi from mul16u to mul16u::@1 [phi:mul16u->mul16u::@1]
   //SEG254 [126] phi (dword) mul16u::mb#2 = (word) mul16u::b#0 [phi:mul16u->mul16u::@1#0] -- vduz1=vwuz2 
     lda b
@@ -8535,9 +8527,9 @@ mul16u: {
 // 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 = $45
-    .label quotient_lo = $2e
-    .label return = $3f
+    .label quotient_hi = $44
+    .label quotient_lo = $2d
+    .label return = $3e
   //SEG276 [136] call divr16u 
   //SEG277 [145] phi from div32u16u to divr16u [phi:div32u16u->divr16u]
   //SEG278 [145] phi (word) divr16u::dividend#5 = >(const dword) PI2_u4f28#0 [phi:div32u16u->divr16u#0] -- vwuz1=vwuc1 
@@ -8588,12 +8580,12 @@ div32u16u: {
 // Returns the quotient dividend/divisor.
 // The final remainder will be set into the global variable rem16u
 // Implemented using simple binary division
-// divr16u(word zeropage($2c) dividend, word zeropage($2a) rem)
+// divr16u(word zeropage($2b) dividend, word zeropage($29) rem)
 divr16u: {
-    .label rem = $2a
-    .label dividend = $2c
-    .label quotient = $2e
-    .label return = $2e
+    .label rem = $29
+    .label dividend = $2b
+    .label quotient = $2d
+    .label return = $2d
   //SEG295 [146] phi from divr16u to divr16u::@1 [phi:divr16u->divr16u::@1]
   //SEG296 [146] phi (byte) divr16u::i#2 = (byte) 0 [phi:divr16u->divr16u::@1#0] -- vbuxx=vbuc1 
     ldx #0
@@ -8678,13 +8670,13 @@ divr16u: {
 // 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* zeropage($34) sintab)
+// sin16s_gen(signed word* zeropage($33) sintab)
 sin16s_gen: {
-    .label _1 = $3d
-    .label step = $3f
-    .label sintab = $34
-    .label x = $30
-    .label i = $36
+    .label _1 = $3c
+    .label step = $3e
+    .label sintab = $33
+    .label x = $2f
+    .label i = $35
   //SEG332 [164] call div32u16u 
   //SEG333 [135] phi from sin16s_gen to div32u16u [phi:sin16s_gen->div32u16u]
     jsr div32u16u
@@ -8779,21 +8771,21 @@ sin16s_gen: {
 // 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 zeropage($39) x)
+// sin16s(dword zeropage($38) x)
 sin16s: {
-    .label _4 = $39
-    .label x = $39
-    .label return = $3d
-    .label x1 = $47
-    .label x2 = $1c
-    .label x3 = $1c
-    .label x3_6 = $43
-    .label usinx = $3d
-    .label x4 = $1c
-    .label x5 = $43
-    .label x5_128 = $43
-    .label sinx = $3d
-    .label isUpper = $38
+    .label _4 = $38
+    .label x = $38
+    .label return = $3c
+    .label x1 = $46
+    .label x2 = $1b
+    .label x3 = $1b
+    .label x3_6 = $42
+    .label usinx = $3c
+    .label x4 = $1b
+    .label x5 = $42
+    .label x5_128 = $42
+    .label sinx = $3c
+    .label isUpper = $37
   //SEG359 [178] if((dword) sin16s::x#0<(const dword) PI_u4f28#0) goto sin16s::@1 -- vduz1_lt_vduc1_then_la1 
     lda x+3
     cmp #>PI_u4f28>>$10

src/test/ref/sinusgen16b.sym

@@ -20,13 +20,13 @@
 (word) div32u16u::divisor
 (dword) div32u16u::quotient
 (word) div32u16u::quotient_hi
-(word) div32u16u::quotient_hi#0 quotient_hi zp ZP_WORD:69 0.8
+(word) div32u16u::quotient_hi#0 quotient_hi zp ZP_WORD:68 0.8
 (word) div32u16u::quotient_lo
-(word) div32u16u::quotient_lo#0 quotient_lo zp ZP_WORD:46 4.0
+(word) div32u16u::quotient_lo#0 quotient_lo zp ZP_WORD:45 4.0
 (dword) div32u16u::return
-(dword) div32u16u::return#0 return zp ZP_DWORD:63 1.5
-(dword) div32u16u::return#2 return zp ZP_DWORD:63 4.0
-(dword) div32u16u::return#3 return zp ZP_DWORD:63 4.0
+(dword) div32u16u::return#0 return zp ZP_DWORD:62 1.5
+(dword) div32u16u::return#2 return zp ZP_DWORD:62 4.0
+(dword) div32u16u::return#3 return zp ZP_DWORD:62 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
@@ -38,30 +38,30 @@
 (label) divr16u::@6
 (label) divr16u::@return
 (word) divr16u::dividend
-(word) divr16u::dividend#0 dividend zp ZP_WORD:44 2.75
-(word) divr16u::dividend#3 dividend zp ZP_WORD:44 5.0
-(word) divr16u::dividend#5 dividend zp ZP_WORD:44 2.0
+(word) divr16u::dividend#0 dividend zp ZP_WORD:43 2.75
+(word) divr16u::dividend#3 dividend zp ZP_WORD:43 5.0
+(word) divr16u::dividend#5 dividend zp ZP_WORD:43 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 ZP_WORD:46 16.5
-(word) divr16u::quotient#2 quotient zp ZP_WORD:46 11.0
-(word) divr16u::quotient#3 quotient zp ZP_WORD:46 2.75
+(word) divr16u::quotient#1 quotient zp ZP_WORD:45 16.5
+(word) divr16u::quotient#2 quotient zp ZP_WORD:45 11.0
+(word) divr16u::quotient#3 quotient zp ZP_WORD:45 2.75
 (word) divr16u::rem
-(word) divr16u::rem#0 rem zp ZP_WORD:42 8.25
-(word) divr16u::rem#1 rem zp ZP_WORD:42 22.0
-(word) divr16u::rem#10 rem zp ZP_WORD:42 4.0
-(word) divr16u::rem#11 rem zp ZP_WORD:42 11.666666666666666
-(word) divr16u::rem#2 rem zp ZP_WORD:42 22.0
-(word) divr16u::rem#4 rem zp ZP_WORD:42 4.0
-(word) divr16u::rem#5 rem zp ZP_WORD:42 24.0
-(word) divr16u::rem#6 rem zp ZP_WORD:42 11.0
+(word) divr16u::rem#0 rem zp ZP_WORD:41 8.25
+(word) divr16u::rem#1 rem zp ZP_WORD:41 22.0
+(word) divr16u::rem#10 rem zp ZP_WORD:41 4.0
+(word) divr16u::rem#11 rem zp ZP_WORD:41 11.666666666666666
+(word) divr16u::rem#2 rem zp ZP_WORD:41 22.0
+(word) divr16u::rem#4 rem zp ZP_WORD:41 4.0
+(word) divr16u::rem#5 rem zp ZP_WORD:41 24.0
+(word) divr16u::rem#6 rem zp ZP_WORD:41 11.0
 (word) divr16u::return
-(word) divr16u::return#0 return zp ZP_WORD:46 5.285714285714286
-(word) divr16u::return#2 return zp ZP_WORD:46 4.0
-(word) divr16u::return#3 return zp ZP_WORD:46 4.0
+(word) divr16u::return#0 return zp ZP_WORD:45 5.285714285714286
+(word) divr16u::return#2 return zp ZP_WORD:45 4.0
+(word) divr16u::return#3 return zp ZP_WORD:45 4.0
 (void()) main()
 (label) main::@1
 (label) main::@2
@@ -98,61 +98,61 @@
 (label) mul16u::@4
 (label) mul16u::@return
 (word) mul16u::a
-(word) mul16u::a#0 a zp ZP_WORD:32 101.0
-(word) mul16u::a#1 a zp ZP_WORD:32 1.3333333333333333
-(word) mul16u::a#2 a zp ZP_WORD:32 67.66666666666666
+(word) mul16u::a#0 a zp ZP_WORD:31 101.0
+(word) mul16u::a#1 a zp ZP_WORD:31 1.3333333333333333
+(word) mul16u::a#2 a zp ZP_WORD:31 67.66666666666666
 (word) mul16u::b
-(word) mul16u::b#0 b zp ZP_WORD:30 2.0
+(word) mul16u::b#0 b zp ZP_WORD:29 2.0
 (dword) mul16u::mb
-(dword) mul16u::mb#1 mb zp ZP_DWORD:38 202.0
-(dword) mul16u::mb#2 mb zp ZP_DWORD:38 43.57142857142858
+(dword) mul16u::mb#1 mb zp ZP_DWORD:37 202.0
+(dword) mul16u::mb#2 mb zp ZP_DWORD:37 43.57142857142858
 (dword) mul16u::res
-(dword) mul16u::res#1 res zp ZP_DWORD:34 202.0
-(dword) mul16u::res#2 res zp ZP_DWORD:34 50.83333333333333
-(dword) mul16u::res#6 res zp ZP_DWORD:34 101.0
+(dword) mul16u::res#1 res zp ZP_DWORD:33 202.0
+(dword) mul16u::res#2 res zp ZP_DWORD:33 50.83333333333333
+(dword) mul16u::res#6 res zp ZP_DWORD:33 101.0
 (dword) mul16u::return
-(dword) mul16u::return#2 return zp ZP_DWORD:34 4.0
+(dword) mul16u::return#2 return zp ZP_DWORD:33 4.0
 (word()) mulu16_sel((word) mulu16_sel::v1 , (word) mulu16_sel::v2 , (byte) mulu16_sel::select)
-(dword~) mulu16_sel::$0 $0 zp ZP_DWORD:34 4.0
-(dword~) mulu16_sel::$1 $1 zp ZP_DWORD:34 4.0
+(dword~) mulu16_sel::$0 $0 zp ZP_DWORD:33 4.0
+(dword~) mulu16_sel::$1 $1 zp ZP_DWORD:33 4.0
 (label) mulu16_sel::@1
 (label) mulu16_sel::@return
 (word) mulu16_sel::return
-(word) mulu16_sel::return#0 return zp ZP_WORD:28 4.0
-(word) mulu16_sel::return#1 return zp ZP_WORD:28 4.0
-(word) mulu16_sel::return#10 return zp ZP_WORD:28 4.0
-(word) mulu16_sel::return#11 return#11 zp ZP_WORD:67 4.0
-(word) mulu16_sel::return#14 return#14 zp ZP_WORD:67 4.0
-(word) mulu16_sel::return#15 return zp ZP_WORD:28 4.0
-(word) mulu16_sel::return#16 return#16 zp ZP_WORD:67 4.0
-(word) mulu16_sel::return#17 return#17 zp ZP_WORD:67 1.8333333333333335
-(word) mulu16_sel::return#18 return#18 zp ZP_WORD:67 4.0
-(word) mulu16_sel::return#19 return zp ZP_WORD:28 4.0
-(word) mulu16_sel::return#20 return#20 zp ZP_WORD:67 4.0
+(word) mulu16_sel::return#0 return zp ZP_WORD:27 4.0
+(word) mulu16_sel::return#1 return zp ZP_WORD:27 4.0
+(word) mulu16_sel::return#10 return zp ZP_WORD:27 4.0
+(word) mulu16_sel::return#11 return#11 zp ZP_WORD:66 4.0
+(word) mulu16_sel::return#14 return#14 zp ZP_WORD:66 4.0
+(word) mulu16_sel::return#15 return zp ZP_WORD:27 4.0
+(word) mulu16_sel::return#16 return#16 zp ZP_WORD:66 4.0
+(word) mulu16_sel::return#17 return#17 zp ZP_WORD:66 1.8333333333333335
+(word) mulu16_sel::return#18 return#18 zp ZP_WORD:66 4.0
+(word) mulu16_sel::return#19 return zp ZP_WORD:27 4.0
+(word) mulu16_sel::return#20 return#20 zp ZP_WORD:66 4.0
 (byte) mulu16_sel::select
 (byte) mulu16_sel::select#10 reg byte x 0.3333333333333333
 (word) mulu16_sel::v1
-(word) mulu16_sel::v1#0 v1 zp ZP_WORD:28 2.0
-(word) mulu16_sel::v1#1 v1 zp ZP_WORD:28 2.0
-(word) mulu16_sel::v1#10 v1 zp ZP_WORD:28 22.0
-(word) mulu16_sel::v1#2 v1 zp ZP_WORD:28 4.0
-(word) mulu16_sel::v1#3 v1 zp ZP_WORD:28 2.0
-(word) mulu16_sel::v1#4 v1 zp ZP_WORD:28 2.0
-(word) mulu16_sel::v1#5 v1 zp ZP_WORD:28 2.0
-(word) mulu16_sel::v1#6 v1 zp ZP_WORD:28 2.0
-(word) mulu16_sel::v1#7 v1 zp ZP_WORD:28 4.0
-(word) mulu16_sel::v1#8 v1 zp ZP_WORD:28 2.0
-(word) mulu16_sel::v1#9 v1 zp ZP_WORD:28 2.0
+(word) mulu16_sel::v1#0 v1 zp ZP_WORD:27 2.0
+(word) mulu16_sel::v1#1 v1 zp ZP_WORD:27 2.0
+(word) mulu16_sel::v1#10 v1 zp ZP_WORD:27 22.0
+(word) mulu16_sel::v1#2 v1 zp ZP_WORD:27 4.0
+(word) mulu16_sel::v1#3 v1 zp ZP_WORD:27 2.0
+(word) mulu16_sel::v1#4 v1 zp ZP_WORD:27 2.0
+(word) mulu16_sel::v1#5 v1 zp ZP_WORD:27 2.0
+(word) mulu16_sel::v1#6 v1 zp ZP_WORD:27 2.0
+(word) mulu16_sel::v1#7 v1 zp ZP_WORD:27 4.0
+(word) mulu16_sel::v1#8 v1 zp ZP_WORD:27 2.0
+(word) mulu16_sel::v1#9 v1 zp ZP_WORD:27 2.0
 (word) mulu16_sel::v2
-(word) mulu16_sel::v2#0 v2 zp ZP_WORD:30 4.0
-(word) mulu16_sel::v2#1 v2 zp ZP_WORD:30 4.0
-(word) mulu16_sel::v2#10 v2 zp ZP_WORD:30 9.0
-(word) mulu16_sel::v2#3 v2 zp ZP_WORD:30 4.0
-(word) mulu16_sel::v2#4 v2 zp ZP_WORD:30 4.0
-(word) mulu16_sel::v2#5 v2 zp ZP_WORD:30 4.0
-(word) mulu16_sel::v2#6 v2 zp ZP_WORD:30 4.0
-(word) mulu16_sel::v2#8 v2 zp ZP_WORD:30 4.0
-(word) mulu16_sel::v2#9 v2 zp ZP_WORD:30 4.0
+(word) mulu16_sel::v2#0 v2 zp ZP_WORD:29 4.0
+(word) mulu16_sel::v2#1 v2 zp ZP_WORD:29 4.0
+(word) mulu16_sel::v2#10 v2 zp ZP_WORD:29 9.0
+(word) mulu16_sel::v2#3 v2 zp ZP_WORD:29 4.0
+(word) mulu16_sel::v2#4 v2 zp ZP_WORD:29 4.0
+(word) mulu16_sel::v2#5 v2 zp ZP_WORD:29 4.0
+(word) mulu16_sel::v2#6 v2 zp ZP_WORD:29 4.0
+(word) mulu16_sel::v2#8 v2 zp ZP_WORD:29 4.0
+(word) mulu16_sel::v2#9 v2 zp ZP_WORD:29 4.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
@@ -211,9 +211,9 @@
 (label) print_word::@return
 (word) print_word::w
 (word) rem16u
-(word) rem16u#1 rem16u zp ZP_WORD:42 0.8
+(word) rem16u#1 rem16u zp ZP_WORD:41 0.8
 (signed word()) sin16s((dword) sin16s::x)
-(dword~) sin16s::$4 $4 zp ZP_DWORD:57 4.0
+(dword~) sin16s::$4 $4 zp ZP_DWORD:56 4.0
 (label) sin16s::@1
 (label) sin16s::@10
 (label) sin16s::@11
@@ -228,56 +228,56 @@
 (label) sin16s::@9
 (label) sin16s::@return
 (byte) sin16s::isUpper
-(byte) sin16s::isUpper#2 isUpper zp ZP_BYTE:56 0.06060606060606061
+(byte) sin16s::isUpper#2 isUpper zp ZP_BYTE:55 0.06060606060606061
 (signed word) sin16s::return
-(signed word) sin16s::return#0 return zp ZP_WORD:61 22.0
-(signed word) sin16s::return#1 return zp ZP_WORD:61 5.0
-(signed word~) sin16s::return#5 return zp ZP_WORD:61 4.0
+(signed word) sin16s::return#0 return zp ZP_WORD:60 22.0
+(signed word) sin16s::return#1 return zp ZP_WORD:60 5.0
+(signed word~) sin16s::return#5 return zp ZP_WORD:60 4.0
 (signed word) sin16s::sinx
-(signed word) sin16s::sinx#1 sinx zp ZP_WORD:61 4.0
+(signed word) sin16s::sinx#1 sinx zp ZP_WORD:60 4.0
 (word) sin16s::usinx
-(word) sin16s::usinx#0 usinx zp ZP_WORD:61 0.3333333333333333
-(word) sin16s::usinx#1 usinx zp ZP_WORD:61 1.0
+(word) sin16s::usinx#0 usinx zp ZP_WORD:60 0.3333333333333333
+(word) sin16s::usinx#1 usinx zp ZP_WORD:60 1.0
 (dword) sin16s::x
-(dword) sin16s::x#0 x zp ZP_DWORD:57 8.5
-(dword) sin16s::x#1 x zp ZP_DWORD:57 4.0
-(dword) sin16s::x#2 x zp ZP_DWORD:57 4.0
-(dword) sin16s::x#4 x zp ZP_DWORD:57 5.0
-(dword) sin16s::x#6 x zp ZP_DWORD:57 6.0
+(dword) sin16s::x#0 x zp ZP_DWORD:56 8.5
+(dword) sin16s::x#1 x zp ZP_DWORD:56 4.0
+(dword) sin16s::x#2 x zp ZP_DWORD:56 4.0
+(dword) sin16s::x#4 x zp ZP_DWORD:56 5.0
+(dword) sin16s::x#6 x zp ZP_DWORD:56 6.0
 (word) sin16s::x1
-(word) sin16s::x1#0 x1 zp ZP_WORD:71 0.6363636363636365
+(word) sin16s::x1#0 x1 zp ZP_WORD:70 0.6363636363636365
 (word) sin16s::x2
-(word) sin16s::x2#0 x2 zp ZP_WORD:28 4.0
+(word) sin16s::x2#0 x2 zp ZP_WORD:27 4.0
 (word) sin16s::x3
-(word) sin16s::x3#0 x3 zp ZP_WORD:28 1.0
+(word) sin16s::x3#0 x3 zp ZP_WORD:27 1.0
 (word) sin16s::x3_6
-(word) sin16s::x3_6#0 x3_6 zp ZP_WORD:67 4.0
+(word) sin16s::x3_6#0 x3_6 zp ZP_WORD:66 4.0
 (word) sin16s::x4
-(word) sin16s::x4#0 x4 zp ZP_WORD:28 4.0
+(word) sin16s::x4#0 x4 zp ZP_WORD:27 4.0
 (word) sin16s::x5
-(word) sin16s::x5#0 x5 zp ZP_WORD:67 4.0
+(word) sin16s::x5#0 x5 zp ZP_WORD:66 4.0
 (word) sin16s::x5_128
-(word) sin16s::x5_128#0 x5_128 zp ZP_WORD:67 4.0
+(word) sin16s::x5_128#0 x5_128 zp ZP_WORD:66 4.0
 (void()) sin16s_gen((signed word*) sin16s_gen::sintab , (word) sin16s_gen::wavelength)
-(signed word~) sin16s_gen::$1 $1 zp ZP_WORD:61 22.0
+(signed word~) sin16s_gen::$1 $1 zp ZP_WORD:60 22.0
 (label) sin16s_gen::@1
 (label) sin16s_gen::@2
 (label) sin16s_gen::@3
 (label) sin16s_gen::@return
 (word) sin16s_gen::i
-(word) sin16s_gen::i#1 i zp ZP_WORD:54 16.5
-(word) sin16s_gen::i#2 i zp ZP_WORD:54 2.75
+(word) sin16s_gen::i#1 i zp ZP_WORD:53 16.5
+(word) sin16s_gen::i#2 i zp ZP_WORD:53 2.75
 (signed word*) sin16s_gen::sintab
-(signed word*) sin16s_gen::sintab#0 sintab zp ZP_WORD:52 5.5
-(signed word*) sin16s_gen::sintab#2 sintab zp ZP_WORD:52 5.5
+(signed word*) sin16s_gen::sintab#0 sintab zp ZP_WORD:51 5.5
+(signed word*) sin16s_gen::sintab#2 sintab zp ZP_WORD:51 5.5
 (dword) sin16s_gen::step
-(dword) sin16s_gen::step#0 step zp ZP_DWORD:63 1.1818181818181819
+(dword) sin16s_gen::step#0 step zp ZP_DWORD:62 1.1818181818181819
 (word) sin16s_gen::wavelength
 (dword) sin16s_gen::x
-(dword) sin16s_gen::x#1 x zp ZP_DWORD:48 7.333333333333333
-(dword) sin16s_gen::x#2 x zp ZP_DWORD:48 4.714285714285714
+(dword) sin16s_gen::x#1 x zp ZP_DWORD:47 7.333333333333333
+(dword) sin16s_gen::x#2 x zp ZP_DWORD:47 4.714285714285714
 (void()) sin16s_genb((signed word*) sin16s_genb::sintab , (word) sin16s_genb::wavelength)
-(signed word~) sin16s_genb::$2 $2 zp ZP_WORD:26 22.0
+(signed word~) sin16s_genb::$2 $2 zp ZP_WORD:25 22.0
 (label) sin16s_genb::@1
 (label) sin16s_genb::@2
 (label) sin16s_genb::@3
@@ -289,7 +289,7 @@
 (signed word*) sin16s_genb::sintab#0 sintab zp ZP_WORD:19 5.5
 (signed word*) sin16s_genb::sintab#2 sintab zp ZP_WORD:19 5.5
 (dword) sin16s_genb::step
-(dword) sin16s_genb::step#0 step zp ZP_DWORD:63 1.1818181818181819
+(dword) sin16s_genb::step#0 step zp ZP_DWORD:62 1.1818181818181819
 (word) sin16s_genb::wavelength
 (dword) sin16s_genb::x
 (dword) sin16s_genb::x#1 x zp ZP_DWORD:15 7.333333333333333
@@ -309,36 +309,36 @@
 (label) sin16sb::@9
 (label) sin16sb::@return
 (byte) sin16sb::isUpper
-(byte) sin16sb::isUpper#2 isUpper zp ZP_BYTE:23 0.0625
+(byte) sin16sb::isUpper#2 reg byte y 0.0625
 (signed word) sin16sb::return
-(signed word) sin16sb::return#0 return zp ZP_WORD:26 22.0
-(signed word) sin16sb::return#1 return zp ZP_WORD:26 5.0
-(signed word~) sin16sb::return#5 return zp ZP_WORD:26 4.0
+(signed word) sin16sb::return#0 return zp ZP_WORD:25 22.0
+(signed word) sin16sb::return#1 return zp ZP_WORD:25 5.0
+(signed word~) sin16sb::return#5 return zp ZP_WORD:25 4.0
 (signed word) sin16sb::sinx
-(signed word) sin16sb::sinx#1 sinx zp ZP_WORD:26 4.0
+(signed word) sin16sb::sinx#1 sinx zp ZP_WORD:25 4.0
 (word) sin16sb::usinx
-(word) sin16sb::usinx#0 usinx zp ZP_WORD:26 0.3333333333333333
-(word) sin16sb::usinx#1 usinx zp ZP_WORD:26 1.0
+(word) sin16sb::usinx#0 usinx zp ZP_WORD:25 0.3333333333333333
+(word) sin16sb::usinx#1 usinx zp ZP_WORD:25 1.0
 (word) sin16sb::x
-(word) sin16sb::x#0 x zp ZP_WORD:24 8.5
-(word) sin16sb::x#1 x zp ZP_WORD:24 4.0
-(word) sin16sb::x#2 x zp ZP_WORD:24 4.0
-(word) sin16sb::x#4 x zp ZP_WORD:24 5.0
-(word) sin16sb::x#6 x zp ZP_WORD:24 6.0
+(word) sin16sb::x#0 x zp ZP_WORD:23 8.5
+(word) sin16sb::x#1 x zp ZP_WORD:23 4.0
+(word) sin16sb::x#2 x zp ZP_WORD:23 4.0
+(word) sin16sb::x#4 x zp ZP_WORD:23 5.0
+(word) sin16sb::x#6 x zp ZP_WORD:23 6.0
 (word) sin16sb::x1
-(word) sin16sb::x1#0 x1 zp ZP_WORD:24 0.6363636363636365
+(word) sin16sb::x1#0 x1 zp ZP_WORD:23 0.6363636363636365
 (word) sin16sb::x2
-(word) sin16sb::x2#0 x2 zp ZP_WORD:28 4.0
+(word) sin16sb::x2#0 x2 zp ZP_WORD:27 4.0
 (word) sin16sb::x3
-(word) sin16sb::x3#0 x3 zp ZP_WORD:28 1.0
+(word) sin16sb::x3#0 x3 zp ZP_WORD:27 1.0
 (word) sin16sb::x3_6
-(word) sin16sb::x3_6#0 x3_6 zp ZP_WORD:67 4.0
+(word) sin16sb::x3_6#0 x3_6 zp ZP_WORD:66 4.0
 (word) sin16sb::x4
-(word) sin16sb::x4#0 x4 zp ZP_WORD:28 4.0
+(word) sin16sb::x4#0 x4 zp ZP_WORD:27 4.0
 (word) sin16sb::x5
-(word) sin16sb::x5#0 x5 zp ZP_WORD:67 4.0
+(word) sin16sb::x5#0 x5 zp ZP_WORD:66 4.0
 (word) sin16sb::x5_128
-(word) sin16sb::x5_128#0 x5_128 zp ZP_WORD:67 4.0
+(word) sin16sb::x5_128#0 x5_128 zp ZP_WORD:66 4.0
 
 zp ZP_WORD:2 [ main::st1#2 main::st1#1 ]
 zp ZP_WORD:4 [ main::st2#2 main::st2#1 ]
@@ -352,31 +352,31 @@ zp ZP_WORD:13 [ print_cls::sc#2 print_cls::sc#1 ]
 zp ZP_DWORD:15 [ sin16s_genb::x#2 sin16s_genb::x#1 ]
 zp ZP_WORD:19 [ sin16s_genb::sintab#2 sin16s_genb::sintab#0 ]
 zp ZP_WORD:21 [ sin16s_genb::i#2 sin16s_genb::i#1 ]
-zp ZP_BYTE:23 [ sin16sb::isUpper#2 ]
-zp ZP_WORD:24 [ sin16sb::x#6 sin16sb::x#4 sin16sb::x#0 sin16sb::x#1 sin16sb::x#2 sin16sb::x1#0 ]
-zp ZP_WORD:26 [ sin16sb::return#1 sin16sb::return#5 sin16sb::sinx#1 sin16sb::usinx#1 sin16sb::return#0 sin16s_genb::$2 sin16sb::usinx#0 ]
-zp ZP_WORD:28 [ mulu16_sel::v1#10 mulu16_sel::v1#3 mulu16_sel::v1#4 mulu16_sel::v1#0 mulu16_sel::v1#1 mulu16_sel::v1#2 mulu16_sel::v1#8 mulu16_sel::v1#9 mulu16_sel::v1#5 mulu16_sel::v1#6 mulu16_sel::v1#7 sin16sb::x3#0 sin16s::x3#0 sin16sb::x2#0 sin16sb::x4#0 sin16s::x2#0 sin16s::x4#0 mulu16_sel::return#19 mulu16_sel::return#10 mulu16_sel::return#0 mulu16_sel::return#1 mulu16_sel::return#15 ]
-zp ZP_WORD:30 [ mulu16_sel::v2#10 mulu16_sel::v2#3 mulu16_sel::v2#4 mulu16_sel::v2#0 mulu16_sel::v2#1 mulu16_sel::v2#8 mulu16_sel::v2#9 mulu16_sel::v2#5 mulu16_sel::v2#6 mul16u::b#0 ]
+reg byte y [ sin16sb::isUpper#2 ]
+zp ZP_WORD:23 [ sin16sb::x#6 sin16sb::x#4 sin16sb::x#0 sin16sb::x#1 sin16sb::x#2 sin16sb::x1#0 ]
+zp ZP_WORD:25 [ sin16sb::return#1 sin16sb::return#5 sin16sb::sinx#1 sin16sb::usinx#1 sin16sb::return#0 sin16s_genb::$2 sin16sb::usinx#0 ]
+zp ZP_WORD:27 [ mulu16_sel::v1#10 mulu16_sel::v1#3 mulu16_sel::v1#4 mulu16_sel::v1#0 mulu16_sel::v1#1 mulu16_sel::v1#2 mulu16_sel::v1#8 mulu16_sel::v1#9 mulu16_sel::v1#5 mulu16_sel::v1#6 mulu16_sel::v1#7 sin16sb::x3#0 sin16s::x3#0 sin16sb::x2#0 sin16sb::x4#0 sin16s::x2#0 sin16s::x4#0 mulu16_sel::return#19 mulu16_sel::return#10 mulu16_sel::return#0 mulu16_sel::return#1 mulu16_sel::return#15 ]
+zp ZP_WORD:29 [ mulu16_sel::v2#10 mulu16_sel::v2#3 mulu16_sel::v2#4 mulu16_sel::v2#0 mulu16_sel::v2#1 mulu16_sel::v2#8 mulu16_sel::v2#9 mulu16_sel::v2#5 mulu16_sel::v2#6 mul16u::b#0 ]
 reg byte x [ mulu16_sel::select#10 ]
-zp ZP_WORD:32 [ mul16u::a#2 mul16u::a#1 mul16u::a#0 ]
-zp ZP_DWORD:34 [ mul16u::res#2 mul16u::res#6 mul16u::res#1 mul16u::return#2 mulu16_sel::$0 mulu16_sel::$1 ]
-zp ZP_DWORD:38 [ mul16u::mb#2 mul16u::mb#1 ]
-zp ZP_WORD:42 [ divr16u::rem#5 divr16u::rem#10 divr16u::rem#4 divr16u::rem#11 divr16u::rem#6 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 rem16u#1 ]
-zp ZP_WORD:44 [ divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#0 ]
-zp ZP_WORD:46 [ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 divr16u::return#2 divr16u::return#3 div32u16u::quotient_lo#0 ]
+zp ZP_WORD:31 [ mul16u::a#2 mul16u::a#1 mul16u::a#0 ]
+zp ZP_DWORD:33 [ mul16u::res#2 mul16u::res#6 mul16u::res#1 mul16u::return#2 mulu16_sel::$0 mulu16_sel::$1 ]
+zp ZP_DWORD:37 [ mul16u::mb#2 mul16u::mb#1 ]
+zp ZP_WORD:41 [ divr16u::rem#5 divr16u::rem#10 divr16u::rem#4 divr16u::rem#11 divr16u::rem#6 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 rem16u#1 ]
+zp ZP_WORD:43 [ divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#0 ]
+zp ZP_WORD:45 [ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 divr16u::return#2 divr16u::return#3 div32u16u::quotient_lo#0 ]
 reg byte x [ divr16u::i#2 divr16u::i#1 ]
-zp ZP_DWORD:48 [ sin16s_gen::x#2 sin16s_gen::x#1 ]
-zp ZP_WORD:52 [ sin16s_gen::sintab#2 sin16s_gen::sintab#0 ]
-zp ZP_WORD:54 [ sin16s_gen::i#2 sin16s_gen::i#1 ]
-zp ZP_BYTE:56 [ sin16s::isUpper#2 ]
-zp ZP_DWORD:57 [ sin16s::x#6 sin16s::x#4 sin16s::x#0 sin16s::x#1 sin16s::x#2 sin16s::$4 ]
-zp ZP_WORD:61 [ sin16s::return#1 sin16s::return#5 sin16s::sinx#1 sin16s::usinx#1 sin16s::return#0 sin16s_gen::$1 sin16s::usinx#0 ]
+zp ZP_DWORD:47 [ sin16s_gen::x#2 sin16s_gen::x#1 ]
+zp ZP_WORD:51 [ sin16s_gen::sintab#2 sin16s_gen::sintab#0 ]
+zp ZP_WORD:53 [ sin16s_gen::i#2 sin16s_gen::i#1 ]
+zp ZP_BYTE:55 [ sin16s::isUpper#2 ]
+zp ZP_DWORD:56 [ sin16s::x#6 sin16s::x#4 sin16s::x#0 sin16s::x#1 sin16s::x#2 sin16s::$4 ]
+zp ZP_WORD:60 [ sin16s::return#1 sin16s::return#5 sin16s::sinx#1 sin16s::usinx#1 sin16s::return#0 sin16s_gen::$1 sin16s::usinx#0 ]
 reg byte a [ print_byte::$0 ]
 reg byte a [ print_byte::$2 ]
-zp ZP_DWORD:63 [ div32u16u::return#3 sin16s_genb::step#0 div32u16u::return#0 div32u16u::return#2 sin16s_gen::step#0 ]
-zp ZP_WORD:67 [ mulu16_sel::return#18 mulu16_sel::return#17 mulu16_sel::return#20 sin16sb::x3_6#0 mulu16_sel::return#11 sin16sb::x5#0 mulu16_sel::return#14 sin16s::x3_6#0 mulu16_sel::return#16 sin16s::x5#0 sin16sb::x5_128#0 sin16s::x5_128#0 ]
+zp ZP_DWORD:62 [ div32u16u::return#3 sin16s_genb::step#0 div32u16u::return#0 div32u16u::return#2 sin16s_gen::step#0 ]
+zp ZP_WORD:66 [ mulu16_sel::return#18 mulu16_sel::return#17 mulu16_sel::return#20 sin16sb::x3_6#0 mulu16_sel::return#11 sin16sb::x5#0 mulu16_sel::return#14 sin16s::x3_6#0 mulu16_sel::return#16 sin16s::x5#0 sin16sb::x5_128#0 sin16s::x5_128#0 ]
 reg byte a [ mul16u::$1 ]
-zp ZP_WORD:69 [ div32u16u::quotient_hi#0 ]
+zp ZP_WORD:68 [ div32u16u::quotient_hi#0 ]
 reg byte a [ divr16u::$1 ]
 reg byte a [ divr16u::$2 ]
-zp ZP_WORD:71 [ sin16s::x1#0 ]
+zp ZP_WORD:70 [ sin16s::x1#0 ]

src/test/ref/sinusgen8b.log

@@ -4560,15 +4560,17 @@ sin16s: {
     sta x5+1
   //SEG211 [106] (word) sin16s::x5_128#0 ← (word) sin16s::x5#0 >> (byte) 4 -- vwuz1=vwuz2_ror_4 
     lda x5+1
+    lsr
     sta x5_128+1
     lda x5
+    ror
     sta x5_128
-    ldy #4
-  !:
     lsr x5_128+1
     ror x5_128
-    dey
-    bne !-
+    lsr x5_128+1
+    ror x5_128
+    lsr x5_128+1
+    ror x5_128
   //SEG212 [107] (word) sin16s::usinx#1 ← (word) sin16s::usinx#0 + (word) sin16s::x5_128#0 -- vwuz1=vwuz2_plus_vwuz3 
     lda usinx
     clc
@@ -5621,7 +5623,7 @@ Statement [101] (word) mulu16_sel::v1#4 ← (word) sin16s::x4#0 [ sin16s::isUppe
 Statement [102] (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:64 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::v1#4 mulu16_sel::v2#4 ] ) always clobbers reg byte a 
 Statement [104] (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:64 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::return#11 ] ) always clobbers reg byte a 
 Statement [105] (word) sin16s::x5#0 ← (word) mulu16_sel::return#11 [ sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5#0 ] ( main:2::sin16s_gen:7::sin16s:64 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5#0 ] ) always clobbers reg byte a 
-Statement [106] (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:64 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5_128#0 ] ) always clobbers reg byte a reg byte y 
+Statement [106] (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:64 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5_128#0 ] ) always clobbers reg byte a 
 Statement [107] (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:64 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::isUpper#2 sin16s::usinx#1 ] ) always clobbers reg byte a 
 Statement [109] (signed word) sin16s::sinx#1 ← - (signed word)(word) sin16s::usinx#1 [ sin16s::sinx#1 ] ( main:2::sin16s_gen:7::sin16s:64 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::sinx#1 ] ) always clobbers reg byte a 
 Statement [112] (signed word~) sin16s::return#5 ← (signed word)(word) sin16s::usinx#1 [ sin16s::return#5 ] ( main:2::sin16s_gen:7::sin16s:64 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::return#5 ] ) always clobbers reg byte a 
@@ -5725,7 +5727,7 @@ Statement [101] (word) mulu16_sel::v1#4 ← (word) sin16s::x4#0 [ sin16s::isUppe
 Statement [102] (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:64 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::v1#4 mulu16_sel::v2#4 ] ) always clobbers reg byte a 
 Statement [104] (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:64 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::isUpper#2 sin16s::usinx#0 mulu16_sel::return#11 ] ) always clobbers reg byte a 
 Statement [105] (word) sin16s::x5#0 ← (word) mulu16_sel::return#11 [ sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5#0 ] ( main:2::sin16s_gen:7::sin16s:64 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5#0 ] ) always clobbers reg byte a 
-Statement [106] (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:64 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5_128#0 ] ) always clobbers reg byte a reg byte y 
+Statement [106] (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:64 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::isUpper#2 sin16s::usinx#0 sin16s::x5_128#0 ] ) always clobbers reg byte a 
 Statement [107] (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:64 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::isUpper#2 sin16s::usinx#1 ] ) always clobbers reg byte a 
 Statement [109] (signed word) sin16s::sinx#1 ← - (signed word)(word) sin16s::usinx#1 [ sin16s::sinx#1 ] ( main:2::sin16s_gen:7::sin16s:64 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::sinx#1 ] ) always clobbers reg byte a 
 Statement [112] (signed word~) sin16s::return#5 ← (signed word)(word) sin16s::usinx#1 [ sin16s::return#5 ] ( main:2::sin16s_gen:7::sin16s:64 [ sin16s_gen::step#0 sin16s_gen::x#2 sin16s_gen::sintab#2 sin16s_gen::i#2 sin16s::return#5 ] ) always clobbers reg byte a 
@@ -5897,60 +5899,60 @@ Uplift Scope [print_byte] 4: zp ZP_BYTE:81 [ print_byte::$0 ] 4: zp ZP_BYTE:82 [
 Uplift Scope [print_sbyte] 7.83: zp ZP_BYTE:5 [ print_sbyte::b#4 print_sbyte::b#0 print_sbyte::b#1 ] 
 Uplift Scope [div16u] 4: zp ZP_WORD:158 [ div16u::return#2 ] 1.33: zp ZP_WORD:189 [ div16u::return#0 ] 
 
-Uplifting [mul8u] best 38972 combination zp ZP_WORD:65 [ mul8u::res#2 mul8u::res#6 mul8u::res#1 ] zp ZP_WORD:67 [ mul8u::mb#2 mul8u::mb#1 ] reg byte a [ mul8u::$1 ] reg byte x [ mul8u::a#2 mul8u::a#1 mul8u::a#0 ] zp ZP_WORD:179 [ mul8u::return#2 ] reg byte a [ mul8u::b#0 ] 
-Uplifting [mul16u] best 38372 combination zp ZP_DWORD:33 [ mul16u::res#2 mul16u::res#6 mul16u::res#1 ] zp ZP_DWORD:37 [ mul16u::mb#2 mul16u::mb#1 ] reg byte a [ mul16u::$1 ] zp ZP_WORD:31 [ mul16u::a#2 mul16u::a#1 mul16u::a#0 ] zp ZP_DWORD:127 [ mul16u::return#2 ] zp ZP_WORD:41 [ mul16u::b#0 ] 
-Uplifting [print_str] best 38372 combination zp ZP_WORD:3 [ print_str::str#2 print_str::str#0 ] 
-Uplifting [divr16u] best 38162 combination zp ZP_WORD:43 [ 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 ZP_WORD:47 [ 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 ZP_WORD:45 [ divr16u::dividend#4 divr16u::dividend#6 divr16u::dividend#0 ] zp ZP_WORD:142 [ divr16u::return#3 ] zp ZP_WORD:146 [ divr16u::return#4 ] zp ZP_WORD:187 [ divr16u::return#2 ] 
-Uplifting [] best 38162 combination zp ZP_WORD:7 [ print_char_cursor#28 print_char_cursor#42 print_char_cursor#19 print_char_cursor#10 print_char_cursor#1 ] zp ZP_WORD:156 [ rem16u#1 ] 
-Uplifting [main] best 37932 combination zp ZP_WORD:71 [ main::$3 ] zp ZP_WORD:73 [ main::$11 ] zp ZP_WORD:75 [ main::$4 ] zp ZP_WORD:77 [ main::sw#0 ] reg byte a [ main::sd#0 ] reg byte x [ main::i#2 main::i#1 ] reg byte a [ main::$5 ] zp ZP_BYTE:70 [ main::sb#0 ] 
-Uplifting [sin8s] best 37827 combination zp ZP_WORD:57 [ 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 ZP_WORD:164 [ sin8s::$4 ] zp ZP_BYTE:168 [ sin8s::x2#0 ] zp ZP_BYTE:172 [ sin8s::x3_6#0 ] zp ZP_BYTE:175 [ sin8s::x4#0 ] zp ZP_BYTE:177 [ sin8s::x5#0 ] zp ZP_BYTE:178 [ sin8s::x5_128#0 ] zp ZP_BYTE:170 [ sin8s::x3#0 ] zp ZP_BYTE:166 [ sin8s::x1#0 ] zp ZP_BYTE:173 [ sin8s::usinx#0 ] zp ZP_BYTE:56 [ sin8s::isUpper#10 ] 
+Uplifting [mul8u] best 38990 combination zp ZP_WORD:65 [ mul8u::res#2 mul8u::res#6 mul8u::res#1 ] zp ZP_WORD:67 [ mul8u::mb#2 mul8u::mb#1 ] reg byte a [ mul8u::$1 ] reg byte x [ mul8u::a#2 mul8u::a#1 mul8u::a#0 ] zp ZP_WORD:179 [ mul8u::return#2 ] reg byte a [ mul8u::b#0 ] 
+Uplifting [mul16u] best 38390 combination zp ZP_DWORD:33 [ mul16u::res#2 mul16u::res#6 mul16u::res#1 ] zp ZP_DWORD:37 [ mul16u::mb#2 mul16u::mb#1 ] reg byte a [ mul16u::$1 ] zp ZP_WORD:31 [ mul16u::a#2 mul16u::a#1 mul16u::a#0 ] zp ZP_DWORD:127 [ mul16u::return#2 ] zp ZP_WORD:41 [ mul16u::b#0 ] 
+Uplifting [print_str] best 38390 combination zp ZP_WORD:3 [ print_str::str#2 print_str::str#0 ] 
+Uplifting [divr16u] best 38180 combination zp ZP_WORD:43 [ 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 ZP_WORD:47 [ 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 ZP_WORD:45 [ divr16u::dividend#4 divr16u::dividend#6 divr16u::dividend#0 ] zp ZP_WORD:142 [ divr16u::return#3 ] zp ZP_WORD:146 [ divr16u::return#4 ] zp ZP_WORD:187 [ divr16u::return#2 ] 
+Uplifting [] best 38180 combination zp ZP_WORD:7 [ print_char_cursor#28 print_char_cursor#42 print_char_cursor#19 print_char_cursor#10 print_char_cursor#1 ] zp ZP_WORD:156 [ rem16u#1 ] 
+Uplifting [main] best 37950 combination zp ZP_WORD:71 [ main::$3 ] zp ZP_WORD:73 [ main::$11 ] zp ZP_WORD:75 [ main::$4 ] zp ZP_WORD:77 [ main::sw#0 ] reg byte a [ main::sd#0 ] reg byte x [ main::i#2 main::i#1 ] reg byte a [ main::$5 ] zp ZP_BYTE:70 [ main::sb#0 ] 
+Uplifting [sin8s] best 37845 combination zp ZP_WORD:57 [ 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 ZP_WORD:164 [ sin8s::$4 ] zp ZP_BYTE:168 [ sin8s::x2#0 ] zp ZP_BYTE:172 [ sin8s::x3_6#0 ] zp ZP_BYTE:175 [ sin8s::x4#0 ] zp ZP_BYTE:177 [ sin8s::x5#0 ] zp ZP_BYTE:178 [ sin8s::x5_128#0 ] zp ZP_BYTE:170 [ sin8s::x3#0 ] zp ZP_BYTE:166 [ sin8s::x1#0 ] zp ZP_BYTE:173 [ sin8s::usinx#0 ] zp ZP_BYTE:56 [ sin8s::isUpper#10 ] 
 Limited combination testing to 100 combinations of 5308416 possible.
-Uplifting [sin16s] best 37827 combination zp ZP_DWORD:20 [ sin16s::x#6 sin16s::x#4 sin16s::x#0 sin16s::x#1 sin16s::x#2 ] zp ZP_WORD:91 [ sin16s::return#0 ] zp ZP_WORD:24 [ sin16s::return#1 sin16s::return#5 sin16s::sinx#1 ] zp ZP_DWORD:95 [ sin16s::$4 ] zp ZP_WORD:103 [ sin16s::x2#0 ] zp ZP_WORD:111 [ sin16s::x3_6#0 ] zp ZP_WORD:117 [ sin16s::x4#0 ] zp ZP_WORD:121 [ sin16s::x5#0 ] zp ZP_WORD:123 [ sin16s::x5_128#0 ] zp ZP_WORD:107 [ sin16s::x3#0 ] zp ZP_WORD:125 [ sin16s::usinx#1 ] zp ZP_WORD:99 [ sin16s::x1#0 ] zp ZP_WORD:113 [ sin16s::usinx#0 ] zp ZP_BYTE:19 [ sin16s::isUpper#2 ] 
-Uplifting [mulu16_sel] best 37811 combination zp ZP_WORD: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 ZP_WORD:28 [ mulu16_sel::v2#5 mulu16_sel::v2#3 mulu16_sel::v2#4 mulu16_sel::v2#0 mulu16_sel::v2#1 ] zp ZP_WORD:101 [ mulu16_sel::return#0 ] zp ZP_WORD:105 [ mulu16_sel::return#1 ] zp ZP_WORD:109 [ mulu16_sel::return#2 ] zp ZP_WORD:115 [ mulu16_sel::return#10 ] zp ZP_WORD:119 [ mulu16_sel::return#11 ] zp ZP_DWORD:131 [ mulu16_sel::$0 ] zp ZP_DWORD:135 [ mulu16_sel::$1 ] zp ZP_WORD:139 [ mulu16_sel::return#12 ] reg byte x [ mulu16_sel::select#5 ] 
-Uplifting [mulu8_sel] best 37765 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 ZP_BYTE:171 [ mulu8_sel::return#2 ] zp ZP_BYTE:174 [ mulu8_sel::return#10 ] zp ZP_BYTE:176 [ mulu8_sel::return#11 ] zp ZP_WORD:181 [ mulu8_sel::$0 ] zp ZP_WORD:183 [ mulu8_sel::$1 ] zp ZP_BYTE:185 [ mulu8_sel::return#12 ] zp ZP_BYTE:63 [ mulu8_sel::select#5 ] 
+Uplifting [sin16s] best 37845 combination zp ZP_DWORD:20 [ sin16s::x#6 sin16s::x#4 sin16s::x#0 sin16s::x#1 sin16s::x#2 ] zp ZP_WORD:91 [ sin16s::return#0 ] zp ZP_WORD:24 [ sin16s::return#1 sin16s::return#5 sin16s::sinx#1 ] zp ZP_DWORD:95 [ sin16s::$4 ] zp ZP_WORD:103 [ sin16s::x2#0 ] zp ZP_WORD:111 [ sin16s::x3_6#0 ] zp ZP_WORD:117 [ sin16s::x4#0 ] zp ZP_WORD:121 [ sin16s::x5#0 ] zp ZP_WORD:123 [ sin16s::x5_128#0 ] zp ZP_WORD:107 [ sin16s::x3#0 ] zp ZP_WORD:125 [ sin16s::usinx#1 ] zp ZP_WORD:99 [ sin16s::x1#0 ] zp ZP_WORD:113 [ sin16s::usinx#0 ] zp ZP_BYTE:19 [ sin16s::isUpper#2 ] 
+Uplifting [mulu16_sel] best 37829 combination zp ZP_WORD: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 ZP_WORD:28 [ mulu16_sel::v2#5 mulu16_sel::v2#3 mulu16_sel::v2#4 mulu16_sel::v2#0 mulu16_sel::v2#1 ] zp ZP_WORD:101 [ mulu16_sel::return#0 ] zp ZP_WORD:105 [ mulu16_sel::return#1 ] zp ZP_WORD:109 [ mulu16_sel::return#2 ] zp ZP_WORD:115 [ mulu16_sel::return#10 ] zp ZP_WORD:119 [ mulu16_sel::return#11 ] zp ZP_DWORD:131 [ mulu16_sel::$0 ] zp ZP_DWORD:135 [ mulu16_sel::$1 ] zp ZP_WORD:139 [ mulu16_sel::return#12 ] reg byte x [ mulu16_sel::select#5 ] 
+Uplifting [mulu8_sel] best 37783 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 ZP_BYTE:171 [ mulu8_sel::return#2 ] zp ZP_BYTE:174 [ mulu8_sel::return#10 ] zp ZP_BYTE:176 [ mulu8_sel::return#11 ] zp ZP_WORD:181 [ mulu8_sel::$0 ] zp ZP_WORD:183 [ mulu8_sel::$1 ] zp ZP_BYTE:185 [ mulu8_sel::return#12 ] zp ZP_BYTE:63 [ mulu8_sel::select#5 ] 
 Limited combination testing to 100 combinations of 196608 possible.
-Uplifting [sin16s_gen] best 37765 combination zp ZP_WORD:93 [ sin16s_gen::$1 ] zp ZP_WORD:17 [ sin16s_gen::i#2 sin16s_gen::i#1 ] zp ZP_DWORD:11 [ sin16s_gen::x#2 sin16s_gen::x#1 ] zp ZP_WORD:15 [ sin16s_gen::sintab#2 sin16s_gen::sintab#0 ] zp ZP_DWORD:87 [ sin16s_gen::step#0 ] 
-Uplifting [sin8s_gen] best 37705 combination reg byte a [ sin8s_gen::$1 ] zp ZP_WORD:54 [ sin8s_gen::i#2 sin8s_gen::i#1 ] zp ZP_WORD:50 [ sin8s_gen::x#2 sin8s_gen::x#1 ] zp ZP_WORD:52 [ sin8s_gen::sintab#2 sin8s_gen::sintab#0 ] zp ZP_WORD:160 [ sin8s_gen::step#0 ] 
-Uplifting [print_cls] best 37705 combination zp ZP_WORD:9 [ print_cls::sc#2 print_cls::sc#1 ] 
-Uplifting [print_char] best 37690 combination reg byte a [ print_char::ch#4 print_char::ch#2 print_char::ch#3 ] 
-Uplifting [div32u16u] best 37690 combination zp ZP_DWORD:83 [ div32u16u::return#2 ] zp ZP_WORD:148 [ div32u16u::quotient_lo#0 ] zp ZP_DWORD:150 [ div32u16u::return#0 ] zp ZP_WORD:144 [ div32u16u::quotient_hi#0 ] 
-Uplifting [print_byte] best 37682 combination reg byte a [ print_byte::$0 ] reg byte a [ print_byte::$2 ] 
-Uplifting [print_sbyte] best 37682 combination zp ZP_BYTE:5 [ print_sbyte::b#4 print_sbyte::b#0 print_sbyte::b#1 ] 
-Uplifting [div16u] best 37682 combination zp ZP_WORD:158 [ div16u::return#2 ] zp ZP_WORD:189 [ div16u::return#0 ] 
+Uplifting [sin16s_gen] best 37783 combination zp ZP_WORD:93 [ sin16s_gen::$1 ] zp ZP_WORD:17 [ sin16s_gen::i#2 sin16s_gen::i#1 ] zp ZP_DWORD:11 [ sin16s_gen::x#2 sin16s_gen::x#1 ] zp ZP_WORD:15 [ sin16s_gen::sintab#2 sin16s_gen::sintab#0 ] zp ZP_DWORD:87 [ sin16s_gen::step#0 ] 
+Uplifting [sin8s_gen] best 37723 combination reg byte a [ sin8s_gen::$1 ] zp ZP_WORD:54 [ sin8s_gen::i#2 sin8s_gen::i#1 ] zp ZP_WORD:50 [ sin8s_gen::x#2 sin8s_gen::x#1 ] zp ZP_WORD:52 [ sin8s_gen::sintab#2 sin8s_gen::sintab#0 ] zp ZP_WORD:160 [ sin8s_gen::step#0 ] 
+Uplifting [print_cls] best 37723 combination zp ZP_WORD:9 [ print_cls::sc#2 print_cls::sc#1 ] 
+Uplifting [print_char] best 37708 combination reg byte a [ print_char::ch#4 print_char::ch#2 print_char::ch#3 ] 
+Uplifting [div32u16u] best 37708 combination zp ZP_DWORD:83 [ div32u16u::return#2 ] zp ZP_WORD:148 [ div32u16u::quotient_lo#0 ] zp ZP_DWORD:150 [ div32u16u::return#0 ] zp ZP_WORD:144 [ div32u16u::quotient_hi#0 ] 
+Uplifting [print_byte] best 37700 combination reg byte a [ print_byte::$0 ] reg byte a [ print_byte::$2 ] 
+Uplifting [print_sbyte] best 37700 combination zp ZP_BYTE:5 [ print_sbyte::b#4 print_sbyte::b#0 print_sbyte::b#1 ] 
+Uplifting [div16u] best 37700 combination zp ZP_WORD:158 [ div16u::return#2 ] zp ZP_WORD:189 [ div16u::return#0 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:5 [ print_sbyte::b#4 print_sbyte::b#0 print_sbyte::b#1 ]
-Uplifting [print_sbyte] best 37682 combination zp ZP_BYTE:5 [ print_sbyte::b#4 print_sbyte::b#0 print_sbyte::b#1 ] 
+Uplifting [print_sbyte] best 37700 combination zp ZP_BYTE:5 [ print_sbyte::b#4 print_sbyte::b#0 print_sbyte::b#1 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:168 [ sin8s::x2#0 ]
-Uplifting [sin8s] best 37678 combination reg byte a [ sin8s::x2#0 ] 
+Uplifting [sin8s] best 37696 combination reg byte a [ sin8s::x2#0 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:171 [ mulu8_sel::return#2 ]
-Uplifting [mulu8_sel] best 37672 combination reg byte a [ mulu8_sel::return#2 ] 
+Uplifting [mulu8_sel] best 37690 combination reg byte a [ mulu8_sel::return#2 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:172 [ sin8s::x3_6#0 ]
-Uplifting [sin8s] best 37668 combination reg byte a [ sin8s::x3_6#0 ] 
+Uplifting [sin8s] best 37686 combination reg byte a [ sin8s::x3_6#0 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:174 [ mulu8_sel::return#10 ]
-Uplifting [mulu8_sel] best 37662 combination reg byte a [ mulu8_sel::return#10 ] 
+Uplifting [mulu8_sel] best 37680 combination reg byte a [ mulu8_sel::return#10 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:175 [ sin8s::x4#0 ]
-Uplifting [sin8s] best 37658 combination reg byte a [ sin8s::x4#0 ] 
+Uplifting [sin8s] best 37676 combination reg byte a [ sin8s::x4#0 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:176 [ mulu8_sel::return#11 ]
-Uplifting [mulu8_sel] best 37652 combination reg byte a [ mulu8_sel::return#11 ] 
+Uplifting [mulu8_sel] best 37670 combination reg byte a [ mulu8_sel::return#11 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:177 [ sin8s::x5#0 ]
-Uplifting [sin8s] best 37646 combination reg byte a [ sin8s::x5#0 ] 
+Uplifting [sin8s] best 37664 combination reg byte a [ sin8s::x5#0 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:178 [ sin8s::x5_128#0 ]
-Uplifting [sin8s] best 37640 combination reg byte a [ sin8s::x5_128#0 ] 
+Uplifting [sin8s] best 37658 combination reg byte a [ sin8s::x5_128#0 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:70 [ main::sb#0 ]
-Uplifting [main] best 37640 combination zp ZP_BYTE:70 [ main::sb#0 ] 
+Uplifting [main] best 37658 combination zp ZP_BYTE:70 [ main::sb#0 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:185 [ mulu8_sel::return#12 ]
-Uplifting [mulu8_sel] best 37622 combination reg byte a [ mulu8_sel::return#12 ] 
+Uplifting [mulu8_sel] best 37640 combination reg byte a [ mulu8_sel::return#12 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:170 [ sin8s::x3#0 ]
-Uplifting [sin8s] best 37622 combination zp ZP_BYTE:170 [ sin8s::x3#0 ] 
+Uplifting [sin8s] best 37640 combination zp ZP_BYTE:170 [ sin8s::x3#0 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:166 [ sin8s::x1#0 ]
-Uplifting [sin8s] best 37622 combination zp ZP_BYTE:166 [ sin8s::x1#0 ] 
+Uplifting [sin8s] best 37640 combination zp ZP_BYTE:166 [ sin8s::x1#0 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:63 [ mulu8_sel::select#5 ]
-Uplifting [mulu8_sel] best 37622 combination zp ZP_BYTE:63 [ mulu8_sel::select#5 ] 
+Uplifting [mulu8_sel] best 37640 combination zp ZP_BYTE:63 [ mulu8_sel::select#5 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:173 [ sin8s::usinx#0 ]
-Uplifting [sin8s] best 37622 combination zp ZP_BYTE:173 [ sin8s::usinx#0 ] 
+Uplifting [sin8s] best 37640 combination zp ZP_BYTE:173 [ sin8s::usinx#0 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:19 [ sin16s::isUpper#2 ]
-Uplifting [sin16s] best 37622 combination zp ZP_BYTE:19 [ sin16s::isUpper#2 ] 
+Uplifting [sin16s] best 37640 combination zp ZP_BYTE:19 [ sin16s::isUpper#2 ] 
 Attempting to uplift remaining variables inzp ZP_BYTE:56 [ sin8s::isUpper#10 ]
-Uplifting [sin8s] best 37622 combination zp ZP_BYTE:56 [ sin8s::isUpper#10 ] 
+Uplifting [sin8s] best 37640 combination zp ZP_BYTE:56 [ sin8s::isUpper#10 ] 
 Coalescing zero page register with common assignment [ zp ZP_WORD:24 [ sin16s::return#1 sin16s::return#5 sin16s::sinx#1 ] ] with [ zp ZP_WORD:125 [ sin16s::usinx#1 ] ] - score: 2
 Coalescing zero page register with common assignment [ zp ZP_WORD: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 ZP_WORD:107 [ sin16s::x3#0 ] ] - score: 2
 Coalescing zero page register with common assignment [ zp ZP_WORD:43 [ 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 ZP_WORD:156 [ rem16u#1 ] ] - score: 2