diff --git a/src/main/fragment/mos6502-common/vbuaa_eq_pbuz1_derefidx_vbuyy_then_la1.asm b/src/main/fragment/mos6502-common/vbuaa_eq_pbuz1_derefidx_vbuyy_then_la1.asm new file mode 100644 index 000000000..579697a6c --- /dev/null +++ b/src/main/fragment/mos6502-common/vbuaa_eq_pbuz1_derefidx_vbuyy_then_la1.asm @@ -0,0 +1,2 @@ +cmp ({z1}),y +beq {la1} \ No newline at end of file diff --git a/src/test/java/dk/camelot64/kickc/test/TestPrograms.java b/src/test/java/dk/camelot64/kickc/test/TestPrograms.java index 18d911b8e..8d5fbef86 100644 --- a/src/test/java/dk/camelot64/kickc/test/TestPrograms.java +++ b/src/test/java/dk/camelot64/kickc/test/TestPrograms.java @@ -37,6 +37,11 @@ public class TestPrograms { public TestPrograms() { } + @Test + public void testGridBobs() throws IOException, URISyntaxException { + compileAndCompare("complex/prebob/grid-bobs"); + } + @Test public void testVogelBobs() throws IOException, URISyntaxException { compileAndCompare("complex/prebob/vogel-bobs"); diff --git a/src/test/kc/complex/prebob/grid-bobs.kc b/src/test/kc/complex/prebob/grid-bobs.kc new file mode 100644 index 000000000..34d7dcc94 --- /dev/null +++ b/src/test/kc/complex/prebob/grid-bobs.kc @@ -0,0 +1,265 @@ +// Pre-calculated bobs inside a charset (pre-moved to all x/y-combinations) +import "c64" +import "string" +import "keyboard" +import "time" +import "print" +import "fastmultiply" + +// The prototype BOB (a 3x3 char image with a bob image in the upper 2x2 chars) +// The chars are layout as follows with data in chars 0, 1, 3, 4 initially +// 0 3 6 +// 1 4 7 +// 2 5 8 +const char[3*3*8] PROTO_BOB = kickasm(resource "smiley.png") {{ + .var pic = LoadPicture("smiley.png", List().add($000000, $ffffff)) + .for (var x=0;x<3; x++) + .for (var y=0; y<24; y++) + .byte pic.getSinglecolorByte(x,y) +}}; + +// Sine and Cosine tables +// Angles: $00=0, $80=PI,$100=2*PI +// Sine/Cosine: signed fixed [-$7f,$7f] +signed char[0x140] align(0x40) SIN = kickasm {{ + .for(var i=0;i<$140;i++) + .byte >round($7fff*sin(i*2*PI/256)) +}}; + +signed char* COS = SIN+$40; // sin(x) = cos(x+PI/2) + +// The BASIC screen +const char* SCREEN_BASIC = 0x0400; +// The BASIC charset +const char* CHARSET_BASIC = 0x1000; +// The BOB screen +const char* BOB_SCREEN = 0x2800; +// The BOB charset +const char* BOB_CHARSET = 0x2000; + +// Tables containing the char to use for a specific cell of a shifted BOB. +// char_id = BOB_TABLES[cell*BOB_SUBTABLE_SIZE + shift_y*BOB_SHIFTS_X + shift_x]; +char[9*8*4] BOB_TABLES; +// The number of different X-shifts +const char BOB_SHIFTS_X = 4; +// The number of different Y-shifts +const char BOB_SHIFTS_Y = 8; +// The size of a sub-table of BOB_TABLES +const char BOB_SUBTABLE_SIZE = BOB_SHIFTS_X*BOB_SHIFTS_Y; + +// The number of BOBs to render +const char NUM_BOBS = 20; + +void main() { + mulf_init(); + prepareBobs(); + renderBobInit(); + vicSelectGfxBank(BOB_SCREEN); + *D018 = toD018(BOB_SCREEN, BOB_CHARSET); + // Clear screen + memset(BOB_SCREEN, 0x00, 1000); + // Render Rotated BOBs + char angle = 0; + while(true) { + do { } while (*RASTER<$f8); + *BORDERCOL = 0xf; + renderBobCleanup(); + signed char r = 30; + char a = angle; + for(char i: 0..NUM_BOBS-1) { + //kickasm {{ .break }} + *BORDERCOL = 1; + int x = mulf8s(r, COS[a]) + 75*0x100; + int y = mulf8s(r, SIN[a])*2 + 90*0x100; + *BORDERCOL = 2; + a += 98; + r += 3; + renderBob(>x, >y); + } + angle += 3; + *BORDERCOL = 0; + if(keyboard_key_pressed(KEY_SPACE)) { + break; + } + } + // Wait for space release + while(keyboard_key_pressed(KEY_SPACE)) {} + // Return to BASIC + vicSelectGfxBank(SCREEN_BASIC); + *D018 = toD018(SCREEN_BASIC, CHARSET_BASIC); +} + +// Table used for deleting rendered BOB's. Contains pointers to first char of each BOB. +char*[NUM_BOBS] RENDERBOB_CLEANUP; + +// Pointer to the next clean-up to add +char** renderBobCleanupNext; + +// *40 Table unsigned int[0x20] MUL40 = { ((unsigned int)i)*40 }; +unsigned int[0x20] MUL40; + +// Initialize the tables used by renderBob() +void renderBobInit() { + for(char y: 0..0x1f) + MUL40[y] = ((unsigned int)y)*40; + for(char i: 0..NUM_BOBS-1) + RENDERBOB_CLEANUP[i] = BOB_SCREEN; +} + +// Render a single BOB at a given x/y-position +// X-position is 0-151. Each x-position is 2 pixels wide. +// Y-position is 0-183. Each y-position is 1 pixel high. +void renderBob(char xpos, char ypos) { + char x_char_offset = xpos/BOB_SHIFTS_X; + char y_char_offset = ypos/BOB_SHIFTS_Y; + unsigned int y_offset = MUL40[y_char_offset]; + char* screen = BOB_SCREEN+y_offset+x_char_offset; + char bob_table_idx = (ypos&7)*BOB_SHIFTS_X+(xpos&3); + *renderBobCleanupNext++ = screen; + screen[0] = (BOB_TABLES+0*BOB_SUBTABLE_SIZE)[bob_table_idx]; + screen[40] = (BOB_TABLES+1*BOB_SUBTABLE_SIZE)[bob_table_idx]; + screen[80] = (BOB_TABLES+2*BOB_SUBTABLE_SIZE)[bob_table_idx]; + screen[1] = (BOB_TABLES+3*BOB_SUBTABLE_SIZE)[bob_table_idx]; + screen[41] = (BOB_TABLES+4*BOB_SUBTABLE_SIZE)[bob_table_idx]; + screen[81] = (BOB_TABLES+5*BOB_SUBTABLE_SIZE)[bob_table_idx]; + screen[2] = (BOB_TABLES+6*BOB_SUBTABLE_SIZE)[bob_table_idx]; + screen[42] = (BOB_TABLES+7*BOB_SUBTABLE_SIZE)[bob_table_idx]; + screen[82] = (BOB_TABLES+8*BOB_SUBTABLE_SIZE)[bob_table_idx]; +} + +// Clean Up the rendered BOB's +void renderBobCleanup() { + for(char i: 0..NUM_BOBS-1) { + char* screen = RENDERBOB_CLEANUP[i]; + screen[0] = 0; + screen[40] = 0; + screen[80] = 0; + screen[1] = 0; + screen[41] = 0; + screen[81] = 0; + screen[2] = 0; + screen[42] = 0; + screen[82] = 0; + } + // Prepare for next clean-up + renderBobCleanupNext = RENDERBOB_CLEANUP; +} + +// Creates the pre-shifted bobs into BOB_CHARSET and populates the BOB_TABLES +// Modifies PROTO_BOB by shifting it around +void prepareBobs() { + progress_init(SCREEN_BASIC); + bob_charset_next_id = 0; + // Ensure that glyph #0 is empty + charsetFindOrAddGlyph(PROTO_BOB+48, BOB_CHARSET); + char bob_table_idx = 0; + for(char shift_y=0;shift_y>1; + // Update carry + carry = new_carry; + // Increment j to iterate over the PROTO_BOB left-to-right, top-to-bottom (0, 24, 48, 1, 25, 49, ...) + if(j>=48) { + j-=47; + } else { + j+=24; + } + } +} + +// Shift PROTO_BOB down one Y pixel +// At the same time restore PROTO_BOB X by shifting 8 pixels left +void protoBobShiftDown() { + for(char i=23;i>0;i--) { + PROTO_BOB[i] = (PROTO_BOB+23)[i]; + (PROTO_BOB+24)[i] = (PROTO_BOB+47)[i]; + (PROTO_BOB+48)[i] = 0x00; + } + PROTO_BOB[0] = 0; + PROTO_BOB[24] = 0; + PROTO_BOB[48] = 0; +} + +// BOB charset ID of the next glyph to be added +char bob_charset_next_id; + +// Looks through a charset to find a glyph if present. If not present it is added. +// Returns the glyph ID +char charsetFindOrAddGlyph(char* glyph, char* charset) { + char* glyph_cursor = charset; + char glyph_id = 0; + while(glyph_id!=bob_charset_next_id) { + char found = 1; + for(char i=0;i<8;i++) { + if(glyph_cursor[i]!=glyph[i]) { + found = 0; + break; + } + } + if(found) return glyph_id; + glyph_id++; + glyph_cursor +=8; + } + // Not found - add it + for(char i=0;i<8;i++) + glyph_cursor[i]=glyph[i]; + bob_charset_next_id++; + return glyph_id; +} + +// Current position of the progress cursor +char* progress_cursor; +// Current index within the progress cursor (0-7) +char progress_idx; + +// Initialize the PETSCII progress bar +void progress_init(char* line) { + progress_cursor = line; + progress_idx = 0; +} + +// Increase PETSCII progress one bit +// Done by increasing the character until the idx is 8 and then moving to the next char +void progress_inc() { + // Progress characters + const char[] progress_chars = { 0x20, 0x65, 0x74, 0x75, 0x61, 0xf6, 0xe7, 0xea, 0xe0 }; + if(++progress_idx==8) { + *progress_cursor = progress_chars[8]; + progress_cursor++; + progress_idx = 0; + } + *progress_cursor = progress_chars[progress_idx]; +} + diff --git a/src/test/kc/complex/prebob/vogel-bobs.kc b/src/test/kc/complex/prebob/vogel-bobs.kc index 31ae9409a..5cc48761a 100644 --- a/src/test/kc/complex/prebob/vogel-bobs.kc +++ b/src/test/kc/complex/prebob/vogel-bobs.kc @@ -28,14 +28,11 @@ signed char[0x140] align(0x40) SIN = kickasm {{ signed char* COS = SIN+$40; // sin(x) = cos(x+PI/2) -// Constants for KickAsm Vogel Sunflower -kickasm {{ - .const PHI = (1+sqrt(5))/2 - -}} - // Vogel Sunflower polar coordinates -align(0x100) const char[] VOGEL_THETA = kickasm {{ .fill 100, round(mod(256*i/(PHI*PHI),256)) }}; +align(0x100) const char[] VOGEL_THETA = kickasm {{ + .const PHI = (1+sqrt(5))/2 + .fill 100, round(mod(256*i/(PHI*PHI),256)) +}}; align(0x100) const char[] VOGEL_R = kickasm {{ .fill 100, round(sqrt(i)*15) }}; // The BASIC screen diff --git a/src/test/ref/complex/prebob/grid-bobs.asm b/src/test/ref/complex/prebob/grid-bobs.asm new file mode 100644 index 000000000..84bfb6adc --- /dev/null +++ b/src/test/ref/complex/prebob/grid-bobs.asm @@ -0,0 +1,866 @@ +// Pre-calculated bobs inside a charset (pre-moved to all x/y-combinations) +.pc = $801 "Basic" +:BasicUpstart(main) +.pc = $80d "Program" + .label RASTER = $d012 + .label BORDERCOL = $d020 + .label D018 = $d018 + // CIA#1 Port A: keyboard matrix columns and joystick #2 + .label CIA1_PORT_A = $dc00 + // CIA#1 Port B: keyboard matrix rows and joystick #1. + .label CIA1_PORT_B = $dc01 + // CIA#2 Port A: Serial bus, RS-232, VIC memory bank + .label CIA2_PORT_A = $dd00 + // CIA #2 Port A data direction register. + .label CIA2_PORT_A_DDR = $dd02 + .const KEY_SPACE = $3c + // The BASIC screen + .label SCREEN_BASIC = $400 + // The BASIC charset + .label CHARSET_BASIC = $1000 + // The BOB screen + .label BOB_SCREEN = $2800 + // The BOB charset + .label BOB_CHARSET = $2000 + // The number of different X-shifts + .const BOB_SHIFTS_X = 4 + // The number of different Y-shifts + .const BOB_SHIFTS_Y = 8 + // The size of a sub-table of BOB_TABLES + .const BOB_SUBTABLE_SIZE = BOB_SHIFTS_X*BOB_SHIFTS_Y + // The number of BOBs to render + .const NUM_BOBS = $14 + .const SIZEOF_POINTER = 2 + .label COS = SIN+$40 + // BOB charset ID of the next glyph to be added + .label bob_charset_next_id = $d + // Current index within the progress cursor (0-7) + .label progress_idx = 3 + // Current position of the progress cursor + .label progress_cursor = $b + // Pointer to the next clean-up to add + // Prepare for next clean-up + .label renderBobCleanupNext = 6 +main: { + .const vicSelectGfxBank1_toDd001_return = 3 + .const vicSelectGfxBank2_toDd001_return = 3 + .const toD0181_return = (>(BOB_SCREEN&$3fff)*4)|(>BOB_CHARSET)/4&$f + .const toD0182_return = (>(SCREEN_BASIC&$3fff)*4)|(>CHARSET_BASIC)/4&$f + .label __10 = $b + .label __12 = $b + .label __13 = $b + .label x = 8 + .label y = $b + .label a = 4 + .label r = 3 + .label i = 5 + // Render Rotated BOBs + .label angle = 2 + jsr mulf_init + jsr prepareBobs + jsr renderBobInit + lda #3 + sta CIA2_PORT_A_DDR + lda #vicSelectGfxBank1_toDd001_return + sta CIA2_PORT_A + lda #toD0181_return + sta D018 + jsr memset + lda #0 + sta.z angle + __b2: + lda RASTER + cmp #$f8 + bcc __b2 + lda #$f + sta BORDERCOL + jsr renderBobCleanup + lda.z angle + sta.z a + lda #0 + sta.z i + lda #RENDERBOB_CLEANUP + sta.z renderBobCleanupNext+1 + lda #$1e + sta.z r + __b4: + //kickasm {{ .break }} + lda #1 + sta BORDERCOL + lda.z r + ldy.z a + ldx COS,y + jsr mulf8s + lda.z __10 + clc + adc #<$4b*$100 + sta.z x + lda.z __10+1 + adc #>$4b*$100 + sta.z x+1 + lda.z r + ldy.z a + ldx SIN,y + jsr mulf8s + asl.z __13 + rol.z __13+1 + clc + lda.z y + adc #<$5a*$100 + sta.z y + lda.z y+1 + adc #>$5a*$100 + sta.z y+1 + lda #2 + sta BORDERCOL + lax.z a + axs #-[$62] + stx.z a + lax.z r + axs #-[3] + stx.z r + lda.z x+1 + sta.z renderBob.xpos + lda.z y+1 + tax + jsr renderBob + inc.z i + lda #NUM_BOBS-1+1 + cmp.z i + bne __b4 + lax.z angle + axs #-[3] + stx.z angle + lda #0 + sta BORDERCOL + jsr keyboard_key_pressed + cmp #0 + bne __b6 + jmp __b2 + // Wait for space release + __b6: + jsr keyboard_key_pressed + cmp #0 + bne __b6 + lda #3 + sta CIA2_PORT_A_DDR + lda #vicSelectGfxBank2_toDd001_return + sta CIA2_PORT_A + lda #toD0182_return + sta D018 + rts +} +// Determines whether a specific key is currently pressed by accessing the matrix directly +// The key is a keyboard code defined from the keyboard matrix by %00rrrccc, where rrr is the row ID (0-7) and ccc is the column ID (0-7) +// All keys exist as as KEY_XXX constants. +// Returns zero if the key is not pressed and a non-zero value if the key is currently pressed +keyboard_key_pressed: { + .const colidx = KEY_SPACE&7 + .label rowidx = KEY_SPACE>>3 + jsr keyboard_matrix_read + and keyboard_matrix_col_bitmask+colidx + rts +} +// Read a single row of the keyboard matrix +// The row ID (0-7) of the keyboard matrix row to read. See the C64 key matrix for row IDs. +// Returns the keys pressed on the row as bits according to the C64 key matrix. +// Notice: If the C64 normal interrupt is still running it will occasionally interrupt right between the read & write +// leading to erroneous readings. You must disable kill the normal interrupt or sei/cli around calls to the keyboard matrix reader. +keyboard_matrix_read: { + lda keyboard_matrix_row_bitmask+keyboard_key_pressed.rowidx + sta CIA1_PORT_A + lda CIA1_PORT_B + eor #$ff + rts +} +// Render a single BOB at a given x/y-position +// X-position is 0-151. Each x-position is 2 pixels wide. +// Y-position is 0-183. Each y-position is 1 pixel high. +// renderBob(byte zeropage($e) xpos, byte register(X) ypos) +renderBob: { + .label __2 = $b + .label __5 = $d + .label xpos = $e + .label x_char_offset = $a + .label y_offset = $b + .label screen = $b + lda.z xpos + lsr + lsr + sta.z x_char_offset + txa + lsr + lsr + lsr + asl + tay + lda MUL40,y + sta.z y_offset + lda MUL40+1,y + sta.z y_offset+1 + clc + lda.z __2 + adc #BOB_SCREEN + sta.z __2+1 + lda.z x_char_offset + clc + adc.z screen + sta.z screen + bcc !+ + inc.z screen+1 + !: + txa + and #7 + asl + asl + sta.z __5 + lda #3 + and.z xpos + clc + adc.z __5 + tax + ldy #0 + lda.z screen + sta (renderBobCleanupNext),y + iny + lda.z screen+1 + sta (renderBobCleanupNext),y + lda #SIZEOF_POINTER + clc + adc.z renderBobCleanupNext + sta.z renderBobCleanupNext + bcc !+ + inc.z renderBobCleanupNext+1 + !: + lda BOB_TABLES,x + ldy #0 + sta (screen),y + lda BOB_TABLES+1*BOB_SUBTABLE_SIZE,x + ldy #$28 + sta (screen),y + lda BOB_TABLES+2*BOB_SUBTABLE_SIZE,x + ldy #$50 + sta (screen),y + lda BOB_TABLES+3*BOB_SUBTABLE_SIZE,x + ldy #1 + sta (screen),y + lda BOB_TABLES+4*BOB_SUBTABLE_SIZE,x + ldy #$29 + sta (screen),y + lda BOB_TABLES+5*BOB_SUBTABLE_SIZE,x + ldy #$51 + sta (screen),y + lda BOB_TABLES+6*BOB_SUBTABLE_SIZE,x + ldy #2 + sta (screen),y + lda BOB_TABLES+7*BOB_SUBTABLE_SIZE,x + ldy #$2a + sta (screen),y + lda BOB_TABLES+8*BOB_SUBTABLE_SIZE,x + ldy #$52 + sta (screen),y + rts +} +// Fast multiply two signed bytes to a word result +// mulf8s(signed byte register(A) a, signed byte register(X) b) +mulf8s: { + .label return = $b + jsr mulf8u_prepare + stx.z mulf8s_prepared.b + jsr mulf8s_prepared + rts +} +// Calculate fast multiply with a prepared unsigned byte to a word result +// The prepared number is set by calling mulf8s_prepare(byte a) +// mulf8s_prepared(signed byte zeropage($e) b) +mulf8s_prepared: { + .label memA = $fd + .label m = $b + .label b = $e + lda.z b + jsr mulf8u_prepared + lda memA + cmp #0 + bpl __b1 + lda.z m+1 + sec + sbc.z b + sta.z m+1 + __b1: + lda.z b + cmp #0 + bpl __b2 + lda.z m+1 + sec + sbc memA + sta.z m+1 + __b2: + rts +} +// Calculate fast multiply with a prepared unsigned byte to a word result +// The prepared number is set by calling mulf8u_prepare(byte a) +// mulf8u_prepared(byte register(A) b) +mulf8u_prepared: { + .label resL = $fe + .label memB = $ff + .label return = $b + sta memB + tax + sec + sm1: + lda mulf_sqr1_lo,x + sm2: + sbc mulf_sqr2_lo,x + sta resL + sm3: + lda mulf_sqr1_hi,x + sm4: + sbc mulf_sqr2_hi,x + sta memB + lda resL + sta.z return + lda memB + sta.z return+1 + rts +} +// Prepare for fast multiply with an unsigned byte to a word result +// mulf8u_prepare(byte register(A) a) +mulf8u_prepare: { + .label memA = $fd + sta memA + sta mulf8u_prepared.sm1+1 + sta mulf8u_prepared.sm3+1 + eor #$ff + sta mulf8u_prepared.sm2+1 + sta mulf8u_prepared.sm4+1 + rts +} +// Clean Up the rendered BOB's +renderBobCleanup: { + .label screen = $f + ldx #0 + __b1: + txa + asl + tay + lda RENDERBOB_CLEANUP,y + sta.z screen + lda RENDERBOB_CLEANUP+1,y + sta.z screen+1 + lda #0 + tay + sta (screen),y + ldy #$28 + sta (screen),y + ldy #$50 + sta (screen),y + ldy #1 + sta (screen),y + ldy #$29 + sta (screen),y + ldy #$51 + sta (screen),y + ldy #2 + sta (screen),y + ldy #$2a + sta (screen),y + ldy #$52 + sta (screen),y + inx + cpx #NUM_BOBS-1+1 + bne __b1 + rts +} +// Copies the character c (an unsigned char) to the first num characters of the object pointed to by the argument str. +memset: { + .label str = BOB_SCREEN + .const c = 0 + .const num = $3e8 + .label end = str+num + .label dst = 6 + lda #str + sta.z dst+1 + __b1: + lda.z dst+1 + cmp #>end + bne __b2 + lda.z dst + cmp #BOB_SCREEN + sta RENDERBOB_CLEANUP+1,y + inx + cpx #NUM_BOBS-1+1 + bne __b2 + rts +} +// Creates the pre-shifted bobs into BOB_CHARSET and populates the BOB_TABLES +// Modifies PROTO_BOB by shifting it around +prepareBobs: { + .label bob_table = $f + .label shift_y = 2 + // Populate charset and tables + .label bob_glyph = 6 + .label cell = $a + .label bob_table_idx = 4 + .label shift_x = 5 + jsr progress_init + lda #PROTO_BOB+$30 + sta.z charsetFindOrAddGlyph.glyph+1 + lda #0 + sta.z bob_charset_next_id + jsr charsetFindOrAddGlyph + lda #0 + sta.z bob_table_idx + sta.z progress_idx + lda #SCREEN_BASIC + sta.z progress_cursor+1 + lda #0 + sta.z shift_y + __b1: + lda.z shift_y + cmp #BOB_SHIFTS_Y + bcc b1 + rts + b1: + lda #0 + sta.z shift_x + __b2: + lda.z shift_x + cmp #BOB_SHIFTS_X + bcc __b3 + jsr protoBobShiftDown + inc.z shift_y + jmp __b1 + __b3: + lda.z bob_table_idx + clc + adc #BOB_TABLES + adc #0 + sta.z bob_table+1 + lda #PROTO_BOB + sta.z bob_glyph+1 + lda #0 + sta.z cell + __b5: + lda.z cell + cmp #9 + bcc __b6 + inc.z bob_table_idx + jsr protoBobShiftRight + jsr protoBobShiftRight + inc.z shift_x + jmp __b2 + __b6: + jsr charsetFindOrAddGlyph + txa + // Look for an existing char in BOB_CHARSET + ldy #0 + sta (bob_table),y + // Move to the next glyph + lda #8 + clc + adc.z bob_glyph + sta.z bob_glyph + bcc !+ + inc.z bob_glyph+1 + !: + // Move to the next sub-table + lda #BOB_SHIFTS_X*BOB_SHIFTS_Y + clc + adc.z bob_table + sta.z bob_table + bcc !+ + inc.z bob_table+1 + !: + jsr progress_inc + inc.z cell + jmp __b5 +} +// Increase PETSCII progress one bit +// Done by increasing the character until the idx is 8 and then moving to the next char +progress_inc: { + inc.z progress_idx + lda #8 + cmp.z progress_idx + bne __b1 + lda progress_chars+8 + ldy #0 + sta (progress_cursor),y + inc.z progress_cursor + bne !+ + inc.z progress_cursor+1 + !: + lda #0 + sta.z progress_idx + __b1: + ldy.z progress_idx + lda progress_chars,y + ldy #0 + sta (progress_cursor),y + rts + // Progress characters + progress_chars: .byte $20, $65, $74, $75, $61, $f6, $e7, $ea, $e0 +} +// Looks through a charset to find a glyph if present. If not present it is added. +// Returns the glyph ID +// charsetFindOrAddGlyph(byte* zeropage(6) glyph) +charsetFindOrAddGlyph: { + .label glyph = 6 + .label glyph_cursor = $11 + lda #BOB_CHARSET + sta.z glyph_cursor+1 + ldx #0 + __b1: + cpx.z bob_charset_next_id + bne b1 + ldy #0 + // Not found - add it + __b7: + cpy #8 + bcc __b8 + inc.z bob_charset_next_id + rts + __b8: + lda (glyph),y + sta (glyph_cursor),y + iny + jmp __b7 + b1: + ldy #0 + __b2: + cpy #8 + bcc __b3 + lda #1 + jmp __b5 + __b3: + lda (glyph_cursor),y + cmp (glyph),y + beq __b4 + lda #0 + __b5: + cmp #0 + beq __b6 + rts + __b6: + inx + lda #8 + clc + adc.z glyph_cursor + sta.z glyph_cursor + bcc !+ + inc.z glyph_cursor+1 + !: + jmp __b1 + __b4: + iny + jmp __b2 +} +// Shift PROTO_BOB right one X pixel +protoBobShiftRight: { + .label carry = $e + .label i = $a + ldy #0 + ldx #0 + txa + sta.z i + __b1: + lda.z i + cmp #3*3*8 + bcc __b2 + rts + __b2: + lda #1 + and PROTO_BOB,x + cmp #0 + bne __b3 + lda #0 + sta.z carry + jmp __b4 + __b3: + lda #$80 + sta.z carry + __b4: + lda PROTO_BOB,x + lsr + sty.z $ff + ora.z $ff + // Shift value and add old carry + sta PROTO_BOB,x + // Increment j to iterate over the PROTO_BOB left-to-right, top-to-bottom (0, 24, 48, 1, 25, 49, ...) + cpx #$30 + bcs __b5 + txa + axs #-[$18] + __b6: + inc.z i + ldy.z carry + jmp __b1 + __b5: + txa + axs #$2f + jmp __b6 +} +// Shift PROTO_BOB down one Y pixel +// At the same time restore PROTO_BOB X by shifting 8 pixels left +protoBobShiftDown: { + ldx #$17 + __b1: + cpx #0 + bne __b2 + lda #0 + sta PROTO_BOB + sta PROTO_BOB+$18 + sta PROTO_BOB+$30 + rts + __b2: + lda PROTO_BOB+$17,x + sta PROTO_BOB,x + lda PROTO_BOB+$2f,x + sta PROTO_BOB+$18,x + lda #0 + sta PROTO_BOB+$30,x + dex + jmp __b1 +} +// Initialize the PETSCII progress bar +progress_init: { + rts +} +// Initialize the mulf_sqr multiplication tables with f(x)=int(x*x/4) +mulf_init: { + // x/2 + .label c = $d + // Counter used for determining x%2==0 + .label sqr1_hi = $f + // Fill mulf_sqr1 = f(x) = int(x*x/4): If f(x) = x*x/4 then f(x+1) = f(x) + x/2 + 1/4 + .label sqr = $b + .label sqr1_lo = 6 + // Decrease or increase x_255 - initially we decrease + .label sqr2_hi = 8 + .label sqr2_lo = $11 + //Start with g(0)=f(255) + .label dir = $e + ldx #0 + lda #mulf_sqr1_hi+1 + sta.z sqr1_hi+1 + txa + sta.z sqr + sta.z sqr+1 + sta.z c + lda #mulf_sqr1_lo+1 + sta.z sqr1_lo+1 + __b1: + lda.z sqr1_lo+1 + cmp #>mulf_sqr1_lo+$200 + bne __b2 + lda.z sqr1_lo + cmp #mulf_sqr2_hi + sta.z sqr2_hi+1 + ldx #-1 + lda #mulf_sqr2_lo + sta.z sqr2_lo+1 + __b5: + lda.z sqr2_lo+1 + cmp #>mulf_sqr2_lo+$1ff + bne __b6 + lda.z sqr2_lo + cmp #f(x) = >(( x * x )/4) + .align $100 + mulf_sqr1_hi: .fill $200, 0 + // g(x) = >((( x - 255) * ( x - 255 ))/4) + .align $100 + mulf_sqr2_hi: .fill $200, 0 + // The prototype BOB (a 3x3 char image with a bob image in the upper 2x2 chars) + // The chars are layout as follows with data in chars 0, 1, 3, 4 initially + // 0 3 6 + // 1 4 7 + // 2 5 8 +PROTO_BOB: +.var pic = LoadPicture("smiley.png", List().add($000000, $ffffff)) + .for (var x=0;x<3; x++) + .for (var y=0; y<24; y++) + .byte pic.getSinglecolorByte(x,y) + + // Sine and Cosine tables + // Angles: $00=0, $80=PI,$100=2*PI + // Sine/Cosine: signed fixed [-$7f,$7f] + .align $40 +SIN: +.for(var i=0;i<$140;i++) + .byte >round($7fff*sin(i*2*PI/256)) + + // Tables containing the char to use for a specific cell of a shifted BOB. + // char_id = BOB_TABLES[cell*BOB_SUBTABLE_SIZE + shift_y*BOB_SHIFTS_X + shift_x]; + BOB_TABLES: .fill 9*8*4, 0 + // Table used for deleting rendered BOB's. Contains pointers to first char of each BOB. + RENDERBOB_CLEANUP: .fill 2*NUM_BOBS, 0 + // *40 Table unsigned int[0x20] MUL40 = { ((unsigned int)i)*40 }; + MUL40: .fill 2*$20, 0 diff --git a/src/test/ref/complex/prebob/grid-bobs.cfg b/src/test/ref/complex/prebob/grid-bobs.cfg new file mode 100644 index 000000000..5dc29688c --- /dev/null +++ b/src/test/ref/complex/prebob/grid-bobs.cfg @@ -0,0 +1,577 @@ +@begin: scope:[] from + [0] phi() + to:@1 +@1: scope:[] from @begin + [1] phi() + [2] call main + to:@end +@end: scope:[] from @1 + [3] phi() + +(void()) main() +main: scope:[main] from @1 + [4] phi() + [5] call mulf_init + to:main::@9 +main::@9: scope:[main] from main + [6] phi() + [7] call prepareBobs + to:main::@10 +main::@10: scope:[main] from main::@9 + [8] phi() + [9] call renderBobInit + to:main::vicSelectGfxBank1 +main::vicSelectGfxBank1: scope:[main] from main::@10 + [10] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 + to:main::vicSelectGfxBank1_toDd001 +main::vicSelectGfxBank1_toDd001: scope:[main] from main::vicSelectGfxBank1 + [11] phi() + to:main::vicSelectGfxBank1_@1 +main::vicSelectGfxBank1_@1: scope:[main] from main::vicSelectGfxBank1_toDd001 + [12] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank1_toDd001_return#0 + to:main::toD0181 +main::toD0181: scope:[main] from main::vicSelectGfxBank1_@1 + [13] phi() + to:main::@7 +main::@7: scope:[main] from main::toD0181 + [14] *((const byte*) D018) ← (const byte) main::toD0181_return#0 + [15] call memset + to:main::@1 +main::@1: scope:[main] from main::@15 main::@7 + [16] (byte) main::angle#8 ← phi( main::@7/(byte) 0 main::@15/(byte) main::angle#1 ) + to:main::@2 +main::@2: scope:[main] from main::@1 main::@2 + [17] if(*((const byte*) RASTER)<(byte) $f8) goto main::@2 + to:main::@3 +main::@3: scope:[main] from main::@2 + [18] *((const byte*) BORDERCOL) ← (byte) $f + [19] call renderBobCleanup + to:main::@11 +main::@11: scope:[main] from main::@3 + [20] (byte) main::a#6 ← (byte) main::angle#8 + to:main::@4 +main::@4: scope:[main] from main::@11 main::@14 + [21] (byte) main::i#2 ← phi( main::@11/(byte) 0 main::@14/(byte) main::i#1 ) + [21] (byte**) renderBobCleanupNext#17 ← phi( main::@11/(const byte**) RENDERBOB_CLEANUP main::@14/(byte**) renderBobCleanupNext#13 ) + [21] (byte) main::a#2 ← phi( main::@11/(byte) main::a#6 main::@14/(byte) main::a#1 ) + [21] (signed byte) main::r#2 ← phi( main::@11/(signed byte) $1e main::@14/(signed byte) main::r#1 ) + [22] *((const byte*) BORDERCOL) ← (byte) 1 + [23] (signed byte) mulf8s::a#0 ← (signed byte) main::r#2 + [24] (signed byte) mulf8s::b#0 ← *((const signed byte*) COS + (byte) main::a#2) + [25] call mulf8s + [26] (signed word) mulf8s::return#2 ← (signed word) mulf8s::return#0 + to:main::@12 +main::@12: scope:[main] from main::@4 + [27] (signed word~) main::$10 ← (signed word) mulf8s::return#2 + [28] (signed word) main::x#0 ← (signed word~) main::$10 + (signed word)(number) $4b*(number) $100 + [29] (signed byte) mulf8s::a#1 ← (signed byte) main::r#2 + [30] (signed byte) mulf8s::b#1 ← *((const signed byte*) SIN + (byte) main::a#2) + [31] call mulf8s + [32] (signed word) mulf8s::return#3 ← (signed word) mulf8s::return#0 + to:main::@13 +main::@13: scope:[main] from main::@12 + [33] (signed word~) main::$12 ← (signed word) mulf8s::return#3 + [34] (signed word~) main::$13 ← (signed word~) main::$12 << (byte) 1 + [35] (signed word) main::y#0 ← (signed word~) main::$13 + (signed word)(number) $5a*(number) $100 + [36] *((const byte*) BORDERCOL) ← (byte) 2 + [37] (byte) main::a#1 ← (byte) main::a#2 + (byte) $62 + [38] (signed byte) main::r#1 ← (signed byte) main::r#2 + (signed byte) 3 + [39] (byte) renderBob::xpos#0 ← > (signed word) main::x#0 + [40] (byte) renderBob::ypos#0 ← > (signed word) main::y#0 + [41] call renderBob + to:main::@14 +main::@14: scope:[main] from main::@13 + [42] (byte) main::i#1 ← ++ (byte) main::i#2 + [43] if((byte) main::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto main::@4 + to:main::@5 +main::@5: scope:[main] from main::@14 + [44] (byte) main::angle#1 ← (byte) main::angle#8 + (byte) 3 + [45] *((const byte*) BORDERCOL) ← (byte) 0 + [46] call keyboard_key_pressed + [47] (byte) keyboard_key_pressed::return#2 ← (byte) keyboard_key_pressed::return#0 + to:main::@15 +main::@15: scope:[main] from main::@5 + [48] (byte~) main::$19 ← (byte) keyboard_key_pressed::return#2 + [49] if((byte) 0!=(byte~) main::$19) goto main::@6 + to:main::@1 +main::@6: scope:[main] from main::@15 main::@16 + [50] phi() + [51] call keyboard_key_pressed + [52] (byte) keyboard_key_pressed::return#3 ← (byte) keyboard_key_pressed::return#0 + to:main::@16 +main::@16: scope:[main] from main::@6 + [53] (byte~) main::$21 ← (byte) keyboard_key_pressed::return#3 + [54] if((byte) 0!=(byte~) main::$21) goto main::@6 + to:main::vicSelectGfxBank2 +main::vicSelectGfxBank2: scope:[main] from main::@16 + [55] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 + to:main::vicSelectGfxBank2_toDd001 +main::vicSelectGfxBank2_toDd001: scope:[main] from main::vicSelectGfxBank2 + [56] phi() + to:main::vicSelectGfxBank2_@1 +main::vicSelectGfxBank2_@1: scope:[main] from main::vicSelectGfxBank2_toDd001 + [57] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank2_toDd001_return#0 + to:main::toD0182 +main::toD0182: scope:[main] from main::vicSelectGfxBank2_@1 + [58] phi() + to:main::@8 +main::@8: scope:[main] from main::toD0182 + [59] *((const byte*) D018) ← (const byte) main::toD0182_return#0 + to:main::@return +main::@return: scope:[main] from main::@8 + [60] return + to:@return + +(byte()) keyboard_key_pressed((byte) keyboard_key_pressed::key) +keyboard_key_pressed: scope:[keyboard_key_pressed] from main::@5 main::@6 + [61] phi() + [62] call keyboard_matrix_read + [63] (byte) keyboard_matrix_read::return#2 ← (byte) keyboard_matrix_read::return#0 + to:keyboard_key_pressed::@1 +keyboard_key_pressed::@1: scope:[keyboard_key_pressed] from keyboard_key_pressed + [64] (byte~) keyboard_key_pressed::$2 ← (byte) keyboard_matrix_read::return#2 + [65] (byte) keyboard_key_pressed::return#0 ← (byte~) keyboard_key_pressed::$2 & *((const byte*) keyboard_matrix_col_bitmask+(const byte) keyboard_key_pressed::colidx#0) + to:keyboard_key_pressed::@return +keyboard_key_pressed::@return: scope:[keyboard_key_pressed] from keyboard_key_pressed::@1 + [66] return + to:@return + +(byte()) keyboard_matrix_read((byte) keyboard_matrix_read::rowid) +keyboard_matrix_read: scope:[keyboard_matrix_read] from keyboard_key_pressed + [67] *((const byte*) CIA1_PORT_A) ← *((const byte*) keyboard_matrix_row_bitmask+(const byte) keyboard_key_pressed::rowidx#0) + [68] (byte) keyboard_matrix_read::return#0 ← ~ *((const byte*) CIA1_PORT_B) + to:keyboard_matrix_read::@return +keyboard_matrix_read::@return: scope:[keyboard_matrix_read] from keyboard_matrix_read + [69] return + to:@return + +(void()) renderBob((byte) renderBob::xpos , (byte) renderBob::ypos) +renderBob: scope:[renderBob] from main::@13 + [70] (byte) renderBob::x_char_offset#0 ← (byte) renderBob::xpos#0 >> (byte) 2 + [71] (byte) renderBob::y_char_offset#0 ← (byte) renderBob::ypos#0 >> (byte) 3 + [72] (byte~) renderBob::$8 ← (byte) renderBob::y_char_offset#0 << (byte) 1 + [73] (word) renderBob::y_offset#0 ← *((const word*) MUL40 + (byte~) renderBob::$8) + [74] (byte*~) renderBob::$2 ← (const byte*) BOB_SCREEN + (word) renderBob::y_offset#0 + [75] (byte*) renderBob::screen#0 ← (byte*~) renderBob::$2 + (byte) renderBob::x_char_offset#0 + [76] (byte~) renderBob::$4 ← (byte) renderBob::ypos#0 & (byte) 7 + [77] (byte~) renderBob::$5 ← (byte~) renderBob::$4 << (byte) 2 + [78] (byte~) renderBob::$6 ← (byte) renderBob::xpos#0 & (byte) 3 + [79] (byte) renderBob::bob_table_idx#0 ← (byte~) renderBob::$5 + (byte~) renderBob::$6 + [80] *((byte**) renderBobCleanupNext#17) ← (byte*) renderBob::screen#0 + [81] (byte**) renderBobCleanupNext#13 ← (byte**) renderBobCleanupNext#17 + (const byte) SIZEOF_POINTER + [82] *((byte*) renderBob::screen#0) ← *((const byte*) BOB_TABLES + (byte) renderBob::bob_table_idx#0) + [83] *((byte*) renderBob::screen#0 + (byte) $28) ← *((const byte*) BOB_TABLES+(byte) 1*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + [84] *((byte*) renderBob::screen#0 + (byte) $50) ← *((const byte*) BOB_TABLES+(byte) 2*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + [85] *((byte*) renderBob::screen#0 + (byte) 1) ← *((const byte*) BOB_TABLES+(byte) 3*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + [86] *((byte*) renderBob::screen#0 + (byte) $29) ← *((const byte*) BOB_TABLES+(byte) 4*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + [87] *((byte*) renderBob::screen#0 + (byte) $51) ← *((const byte*) BOB_TABLES+(byte) 5*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + [88] *((byte*) renderBob::screen#0 + (byte) 2) ← *((const byte*) BOB_TABLES+(byte) 6*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + [89] *((byte*) renderBob::screen#0 + (byte) $2a) ← *((const byte*) BOB_TABLES+(byte) 7*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + [90] *((byte*) renderBob::screen#0 + (byte) $52) ← *((const byte*) BOB_TABLES+(byte) 8*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + to:renderBob::@return +renderBob::@return: scope:[renderBob] from renderBob + [91] return + to:@return + +(signed word()) mulf8s((signed byte) mulf8s::a , (signed byte) mulf8s::b) +mulf8s: scope:[mulf8s] from main::@12 main::@4 + [92] (signed byte) mulf8s::b#2 ← phi( main::@12/(signed byte) mulf8s::b#1 main::@4/(signed byte) mulf8s::b#0 ) + [92] (signed byte) mulf8s::mulf8s_prepare1_a#0 ← phi( main::@12/(signed byte) mulf8s::a#1 main::@4/(signed byte) mulf8s::a#0 ) + to:mulf8s::mulf8s_prepare1 +mulf8s::mulf8s_prepare1: scope:[mulf8s] from mulf8s + [93] (byte) mulf8u_prepare::a#0 ← (byte)(signed byte) mulf8s::mulf8s_prepare1_a#0 + [94] call mulf8u_prepare + to:mulf8s::@1 +mulf8s::@1: scope:[mulf8s] from mulf8s::mulf8s_prepare1 + [95] (signed byte) mulf8s_prepared::b#0 ← (signed byte) mulf8s::b#2 + [96] call mulf8s_prepared + to:mulf8s::@2 +mulf8s::@2: scope:[mulf8s] from mulf8s::@1 + [97] (signed word) mulf8s::return#0 ← (signed word)(word) mulf8s_prepared::m#4 + to:mulf8s::@return +mulf8s::@return: scope:[mulf8s] from mulf8s::@2 + [98] return + to:@return + +(signed word()) mulf8s_prepared((signed byte) mulf8s_prepared::b) +mulf8s_prepared: scope:[mulf8s_prepared] from mulf8s::@1 + [99] (byte) mulf8u_prepared::b#0 ← (byte)(signed byte) mulf8s_prepared::b#0 + [100] call mulf8u_prepared + [101] (word) mulf8u_prepared::return#2 ← (word) mulf8u_prepared::return#0 + to:mulf8s_prepared::@5 +mulf8s_prepared::@5: scope:[mulf8s_prepared] from mulf8s_prepared + [102] (word) mulf8s_prepared::m#0 ← (word) mulf8u_prepared::return#2 + [103] if(*((const signed byte*) mulf8s_prepared::memA)>=(signed byte) 0) goto mulf8s_prepared::@1 + to:mulf8s_prepared::@3 +mulf8s_prepared::@3: scope:[mulf8s_prepared] from mulf8s_prepared::@5 + [104] (byte~) mulf8s_prepared::$8 ← > (word) mulf8s_prepared::m#0 + [105] (byte~) mulf8s_prepared::$15 ← (byte~) mulf8s_prepared::$8 - (byte)(signed byte) mulf8s_prepared::b#0 + [106] (word) mulf8s_prepared::m#1 ← (word) mulf8s_prepared::m#0 hi= (byte~) mulf8s_prepared::$15 + to:mulf8s_prepared::@1 +mulf8s_prepared::@1: scope:[mulf8s_prepared] from mulf8s_prepared::@3 mulf8s_prepared::@5 + [107] (word) mulf8s_prepared::m#5 ← phi( mulf8s_prepared::@3/(word) mulf8s_prepared::m#1 mulf8s_prepared::@5/(word) mulf8s_prepared::m#0 ) + [108] if((signed byte) mulf8s_prepared::b#0>=(signed byte) 0) goto mulf8s_prepared::@2 + to:mulf8s_prepared::@4 +mulf8s_prepared::@4: scope:[mulf8s_prepared] from mulf8s_prepared::@1 + [109] (byte~) mulf8s_prepared::$12 ← > (word) mulf8s_prepared::m#5 + [110] (byte~) mulf8s_prepared::$16 ← (byte~) mulf8s_prepared::$12 - (byte)*((const signed byte*) mulf8s_prepared::memA) + [111] (word) mulf8s_prepared::m#2 ← (word) mulf8s_prepared::m#5 hi= (byte~) mulf8s_prepared::$16 + to:mulf8s_prepared::@2 +mulf8s_prepared::@2: scope:[mulf8s_prepared] from mulf8s_prepared::@1 mulf8s_prepared::@4 + [112] (word) mulf8s_prepared::m#4 ← phi( mulf8s_prepared::@1/(word) mulf8s_prepared::m#5 mulf8s_prepared::@4/(word) mulf8s_prepared::m#2 ) + to:mulf8s_prepared::@return +mulf8s_prepared::@return: scope:[mulf8s_prepared] from mulf8s_prepared::@2 + [113] return + to:@return + +(word()) mulf8u_prepared((byte) mulf8u_prepared::b) +mulf8u_prepared: scope:[mulf8u_prepared] from mulf8s_prepared + [114] *((const byte*) mulf8u_prepared::memB) ← (byte) mulf8u_prepared::b#0 + asm { ldxmemB sec sm1: ldamulf_sqr1_lo,x sm2: sbcmulf_sqr2_lo,x staresL sm3: ldamulf_sqr1_hi,x sm4: sbcmulf_sqr2_hi,x stamemB } + [116] (word) mulf8u_prepared::return#0 ← *((const byte*) mulf8u_prepared::memB) w= *((const byte*) mulf8u_prepared::resL) + to:mulf8u_prepared::@return +mulf8u_prepared::@return: scope:[mulf8u_prepared] from mulf8u_prepared + [117] return + to:@return + +(void()) mulf8u_prepare((byte) mulf8u_prepare::a) +mulf8u_prepare: scope:[mulf8u_prepare] from mulf8s::mulf8s_prepare1 + [118] *((const byte*) mulf8u_prepare::memA) ← (byte) mulf8u_prepare::a#0 + asm { ldamemA stamulf8u_prepared.sm1+1 stamulf8u_prepared.sm3+1 eor#$ff stamulf8u_prepared.sm2+1 stamulf8u_prepared.sm4+1 } + to:mulf8u_prepare::@return +mulf8u_prepare::@return: scope:[mulf8u_prepare] from mulf8u_prepare + [120] return + to:@return + +(void()) renderBobCleanup() +renderBobCleanup: scope:[renderBobCleanup] from main::@3 + [121] phi() + to:renderBobCleanup::@1 +renderBobCleanup::@1: scope:[renderBobCleanup] from renderBobCleanup renderBobCleanup::@1 + [122] (byte) renderBobCleanup::i#2 ← phi( renderBobCleanup/(byte) 0 renderBobCleanup::@1/(byte) renderBobCleanup::i#1 ) + [123] (byte~) renderBobCleanup::$1 ← (byte) renderBobCleanup::i#2 << (byte) 1 + [124] (byte*) renderBobCleanup::screen#0 ← *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobCleanup::$1) + [125] *((byte*) renderBobCleanup::screen#0) ← (byte) 0 + [126] *((byte*) renderBobCleanup::screen#0 + (byte) $28) ← (byte) 0 + [127] *((byte*) renderBobCleanup::screen#0 + (byte) $50) ← (byte) 0 + [128] *((byte*) renderBobCleanup::screen#0 + (byte) 1) ← (byte) 0 + [129] *((byte*) renderBobCleanup::screen#0 + (byte) $29) ← (byte) 0 + [130] *((byte*) renderBobCleanup::screen#0 + (byte) $51) ← (byte) 0 + [131] *((byte*) renderBobCleanup::screen#0 + (byte) 2) ← (byte) 0 + [132] *((byte*) renderBobCleanup::screen#0 + (byte) $2a) ← (byte) 0 + [133] *((byte*) renderBobCleanup::screen#0 + (byte) $52) ← (byte) 0 + [134] (byte) renderBobCleanup::i#1 ← ++ (byte) renderBobCleanup::i#2 + [135] if((byte) renderBobCleanup::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto renderBobCleanup::@1 + to:renderBobCleanup::@return +renderBobCleanup::@return: scope:[renderBobCleanup] from renderBobCleanup::@1 + [136] return + to:@return + +(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num) +memset: scope:[memset] from main::@7 + [137] phi() + to:memset::@1 +memset::@1: scope:[memset] from memset memset::@2 + [138] (byte*) memset::dst#2 ← phi( memset/(byte*)(const void*) memset::str#0 memset::@2/(byte*) memset::dst#1 ) + [139] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 + to:memset::@return +memset::@return: scope:[memset] from memset::@1 + [140] return + to:@return +memset::@2: scope:[memset] from memset::@1 + [141] *((byte*) memset::dst#2) ← (const byte) memset::c#0 + [142] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2 + to:memset::@1 + +(void()) renderBobInit() +renderBobInit: scope:[renderBobInit] from main::@10 + [143] phi() + to:renderBobInit::@1 +renderBobInit::@1: scope:[renderBobInit] from renderBobInit renderBobInit::@1 + [144] (byte) renderBobInit::y#2 ← phi( renderBobInit/(byte) 0 renderBobInit::@1/(byte) renderBobInit::y#1 ) + [145] (word~) renderBobInit::$0 ← (word)(byte) renderBobInit::y#2 + [146] (word~) renderBobInit::$6 ← (word~) renderBobInit::$0 << (byte) 2 + [147] (word~) renderBobInit::$7 ← (word~) renderBobInit::$6 + (word~) renderBobInit::$0 + [148] (word~) renderBobInit::$1 ← (word~) renderBobInit::$7 << (byte) 3 + [149] (byte~) renderBobInit::$4 ← (byte) renderBobInit::y#2 << (byte) 1 + [150] *((const word*) MUL40 + (byte~) renderBobInit::$4) ← (word~) renderBobInit::$1 + [151] (byte) renderBobInit::y#1 ← ++ (byte) renderBobInit::y#2 + [152] if((byte) renderBobInit::y#1!=(byte) $20) goto renderBobInit::@1 + to:renderBobInit::@2 +renderBobInit::@2: scope:[renderBobInit] from renderBobInit::@1 renderBobInit::@2 + [153] (byte) renderBobInit::i#2 ← phi( renderBobInit::@1/(byte) 0 renderBobInit::@2/(byte) renderBobInit::i#1 ) + [154] (byte~) renderBobInit::$5 ← (byte) renderBobInit::i#2 << (byte) 1 + [155] *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobInit::$5) ← (const byte*) BOB_SCREEN + [156] (byte) renderBobInit::i#1 ← ++ (byte) renderBobInit::i#2 + [157] if((byte) renderBobInit::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto renderBobInit::@2 + to:renderBobInit::@return +renderBobInit::@return: scope:[renderBobInit] from renderBobInit::@2 + [158] return + to:@return + +(void()) prepareBobs() +prepareBobs: scope:[prepareBobs] from main::@9 + [159] phi() + [160] call progress_init + to:prepareBobs::@8 +prepareBobs::@8: scope:[prepareBobs] from prepareBobs + [161] phi() + [162] call charsetFindOrAddGlyph + to:prepareBobs::@1 +prepareBobs::@1: scope:[prepareBobs] from prepareBobs::@8 prepareBobs::@9 + [163] (byte) prepareBobs::bob_table_idx#6 ← phi( prepareBobs::@8/(byte) 0 prepareBobs::@9/(byte) prepareBobs::bob_table_idx#12 ) + [163] (byte) bob_charset_next_id#14 ← phi( prepareBobs::@8/(byte) bob_charset_next_id#16 prepareBobs::@9/(byte) bob_charset_next_id#30 ) + [163] (byte) progress_idx#16 ← phi( prepareBobs::@8/(byte) 0 prepareBobs::@9/(byte) progress_idx#31 ) + [163] (byte*) progress_cursor#15 ← phi( prepareBobs::@8/(const byte*) SCREEN_BASIC prepareBobs::@9/(byte*) progress_cursor#31 ) + [163] (byte) prepareBobs::shift_y#2 ← phi( prepareBobs::@8/(byte) 0 prepareBobs::@9/(byte) prepareBobs::shift_y#1 ) + [164] if((byte) prepareBobs::shift_y#2<(const byte) BOB_SHIFTS_Y) goto prepareBobs::@2 + to:prepareBobs::@return +prepareBobs::@return: scope:[prepareBobs] from prepareBobs::@1 + [165] return + to:@return +prepareBobs::@2: scope:[prepareBobs] from prepareBobs::@1 prepareBobs::@13 + [166] (byte) progress_idx#31 ← phi( prepareBobs::@1/(byte) progress_idx#16 prepareBobs::@13/(byte) progress_idx#25 ) + [166] (byte*) progress_cursor#31 ← phi( prepareBobs::@1/(byte*) progress_cursor#15 prepareBobs::@13/(byte*) progress_cursor#24 ) + [166] (byte) bob_charset_next_id#30 ← phi( prepareBobs::@1/(byte) bob_charset_next_id#14 prepareBobs::@13/(byte) bob_charset_next_id#21 ) + [166] (byte) prepareBobs::bob_table_idx#12 ← phi( prepareBobs::@1/(byte) prepareBobs::bob_table_idx#6 prepareBobs::@13/(byte) prepareBobs::bob_table_idx#1 ) + [166] (byte) prepareBobs::shift_x#2 ← phi( prepareBobs::@1/(byte) 0 prepareBobs::@13/(byte) prepareBobs::shift_x#1 ) + [167] if((byte) prepareBobs::shift_x#2<(const byte) BOB_SHIFTS_X) goto prepareBobs::@3 + to:prepareBobs::@4 +prepareBobs::@4: scope:[prepareBobs] from prepareBobs::@2 + [168] phi() + [169] call protoBobShiftDown + to:prepareBobs::@9 +prepareBobs::@9: scope:[prepareBobs] from prepareBobs::@4 + [170] (byte) prepareBobs::shift_y#1 ← ++ (byte) prepareBobs::shift_y#2 + to:prepareBobs::@1 +prepareBobs::@3: scope:[prepareBobs] from prepareBobs::@2 + [171] (byte*) prepareBobs::bob_table#0 ← (const byte*) BOB_TABLES + (byte) prepareBobs::bob_table_idx#12 + to:prepareBobs::@5 +prepareBobs::@5: scope:[prepareBobs] from prepareBobs::@11 prepareBobs::@3 + [172] (byte*) progress_cursor#24 ← phi( prepareBobs::@11/(byte*) progress_cursor#17 prepareBobs::@3/(byte*) progress_cursor#31 ) + [172] (byte) progress_idx#25 ← phi( prepareBobs::@11/(byte) progress_idx#10 prepareBobs::@3/(byte) progress_idx#31 ) + [172] (byte*) prepareBobs::bob_table#2 ← phi( prepareBobs::@11/(byte*) prepareBobs::bob_table#1 prepareBobs::@3/(byte*) prepareBobs::bob_table#0 ) + [172] (byte) bob_charset_next_id#21 ← phi( prepareBobs::@11/(byte) bob_charset_next_id#16 prepareBobs::@3/(byte) bob_charset_next_id#30 ) + [172] (byte*) prepareBobs::bob_glyph#2 ← phi( prepareBobs::@11/(byte*) prepareBobs::bob_glyph#1 prepareBobs::@3/(const byte*) PROTO_BOB ) + [172] (byte) prepareBobs::cell#2 ← phi( prepareBobs::@11/(byte) prepareBobs::cell#1 prepareBobs::@3/(byte) 0 ) + [173] if((byte) prepareBobs::cell#2<(byte) 9) goto prepareBobs::@6 + to:prepareBobs::@7 +prepareBobs::@7: scope:[prepareBobs] from prepareBobs::@5 + [174] (byte) prepareBobs::bob_table_idx#1 ← ++ (byte) prepareBobs::bob_table_idx#12 + [175] call protoBobShiftRight + to:prepareBobs::@12 +prepareBobs::@12: scope:[prepareBobs] from prepareBobs::@7 + [176] phi() + [177] call protoBobShiftRight + to:prepareBobs::@13 +prepareBobs::@13: scope:[prepareBobs] from prepareBobs::@12 + [178] (byte) prepareBobs::shift_x#1 ← ++ (byte) prepareBobs::shift_x#2 + to:prepareBobs::@2 +prepareBobs::@6: scope:[prepareBobs] from prepareBobs::@5 + [179] (byte*) charsetFindOrAddGlyph::glyph#1 ← (byte*) prepareBobs::bob_glyph#2 + [180] call charsetFindOrAddGlyph + [181] (byte) charsetFindOrAddGlyph::return#1 ← (byte) charsetFindOrAddGlyph::glyph_id#11 + to:prepareBobs::@10 +prepareBobs::@10: scope:[prepareBobs] from prepareBobs::@6 + [182] (byte~) prepareBobs::$6 ← (byte) charsetFindOrAddGlyph::return#1 + [183] *((byte*) prepareBobs::bob_table#2) ← (byte~) prepareBobs::$6 + [184] (byte*) prepareBobs::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 + (byte) 8 + [185] (byte*) prepareBobs::bob_table#1 ← (byte*) prepareBobs::bob_table#2 + (const byte) BOB_SHIFTS_X*(const byte) BOB_SHIFTS_Y + [186] call progress_inc + to:prepareBobs::@11 +prepareBobs::@11: scope:[prepareBobs] from prepareBobs::@10 + [187] (byte) prepareBobs::cell#1 ← ++ (byte) prepareBobs::cell#2 + to:prepareBobs::@5 + +(void()) progress_inc() +progress_inc: scope:[progress_inc] from prepareBobs::@10 + [188] (byte) progress_idx#8 ← ++ (byte) progress_idx#25 + [189] if((byte) progress_idx#8!=(byte) 8) goto progress_inc::@1 + to:progress_inc::@2 +progress_inc::@2: scope:[progress_inc] from progress_inc + [190] *((byte*) progress_cursor#24) ← *((const byte*) progress_inc::progress_chars+(byte) 8) + [191] (byte*) progress_cursor#8 ← ++ (byte*) progress_cursor#24 + to:progress_inc::@1 +progress_inc::@1: scope:[progress_inc] from progress_inc progress_inc::@2 + [192] (byte*) progress_cursor#17 ← phi( progress_inc/(byte*) progress_cursor#24 progress_inc::@2/(byte*) progress_cursor#8 ) + [192] (byte) progress_idx#10 ← phi( progress_inc/(byte) progress_idx#8 progress_inc::@2/(byte) 0 ) + [193] *((byte*) progress_cursor#17) ← *((const byte*) progress_inc::progress_chars + (byte) progress_idx#10) + to:progress_inc::@return +progress_inc::@return: scope:[progress_inc] from progress_inc::@1 + [194] return + to:@return + +(byte()) charsetFindOrAddGlyph((byte*) charsetFindOrAddGlyph::glyph , (byte*) charsetFindOrAddGlyph::charset) +charsetFindOrAddGlyph: scope:[charsetFindOrAddGlyph] from prepareBobs::@6 prepareBobs::@8 + [195] (byte*) charsetFindOrAddGlyph::glyph#10 ← phi( prepareBobs::@8/(const byte*) PROTO_BOB+(byte) $30 prepareBobs::@6/(byte*) charsetFindOrAddGlyph::glyph#1 ) + [195] (byte) bob_charset_next_id#23 ← phi( prepareBobs::@8/(byte) 0 prepareBobs::@6/(byte) bob_charset_next_id#21 ) + to:charsetFindOrAddGlyph::@1 +charsetFindOrAddGlyph::@1: scope:[charsetFindOrAddGlyph] from charsetFindOrAddGlyph charsetFindOrAddGlyph::@6 + [196] (byte*) charsetFindOrAddGlyph::glyph_cursor#11 ← phi( charsetFindOrAddGlyph/(const byte*) BOB_CHARSET charsetFindOrAddGlyph::@6/(byte*) charsetFindOrAddGlyph::glyph_cursor#1 ) + [196] (byte) charsetFindOrAddGlyph::glyph_id#11 ← phi( charsetFindOrAddGlyph/(byte) 0 charsetFindOrAddGlyph::@6/(byte) charsetFindOrAddGlyph::glyph_id#1 ) + [197] if((byte) charsetFindOrAddGlyph::glyph_id#11!=(byte) bob_charset_next_id#23) goto charsetFindOrAddGlyph::@2 + to:charsetFindOrAddGlyph::@7 +charsetFindOrAddGlyph::@7: scope:[charsetFindOrAddGlyph] from charsetFindOrAddGlyph::@1 charsetFindOrAddGlyph::@8 + [198] (byte) charsetFindOrAddGlyph::i1#2 ← phi( charsetFindOrAddGlyph::@8/(byte) charsetFindOrAddGlyph::i1#1 charsetFindOrAddGlyph::@1/(byte) 0 ) + [199] if((byte) charsetFindOrAddGlyph::i1#2<(byte) 8) goto charsetFindOrAddGlyph::@8 + to:charsetFindOrAddGlyph::@9 +charsetFindOrAddGlyph::@9: scope:[charsetFindOrAddGlyph] from charsetFindOrAddGlyph::@7 + [200] (byte) bob_charset_next_id#8 ← ++ (byte) bob_charset_next_id#23 + to:charsetFindOrAddGlyph::@return +charsetFindOrAddGlyph::@return: scope:[charsetFindOrAddGlyph] from charsetFindOrAddGlyph::@5 charsetFindOrAddGlyph::@9 + [201] (byte) bob_charset_next_id#16 ← phi( charsetFindOrAddGlyph::@5/(byte) bob_charset_next_id#23 charsetFindOrAddGlyph::@9/(byte) bob_charset_next_id#8 ) + [202] return + to:@return +charsetFindOrAddGlyph::@8: scope:[charsetFindOrAddGlyph] from charsetFindOrAddGlyph::@7 + [203] *((byte*) charsetFindOrAddGlyph::glyph_cursor#11 + (byte) charsetFindOrAddGlyph::i1#2) ← *((byte*) charsetFindOrAddGlyph::glyph#10 + (byte) charsetFindOrAddGlyph::i1#2) + [204] (byte) charsetFindOrAddGlyph::i1#1 ← ++ (byte) charsetFindOrAddGlyph::i1#2 + to:charsetFindOrAddGlyph::@7 +charsetFindOrAddGlyph::@2: scope:[charsetFindOrAddGlyph] from charsetFindOrAddGlyph::@1 charsetFindOrAddGlyph::@4 + [205] (byte) charsetFindOrAddGlyph::i#2 ← phi( charsetFindOrAddGlyph::@1/(byte) 0 charsetFindOrAddGlyph::@4/(byte) charsetFindOrAddGlyph::i#1 ) + [206] if((byte) charsetFindOrAddGlyph::i#2<(byte) 8) goto charsetFindOrAddGlyph::@3 + to:charsetFindOrAddGlyph::@5 +charsetFindOrAddGlyph::@3: scope:[charsetFindOrAddGlyph] from charsetFindOrAddGlyph::@2 + [207] if(*((byte*) charsetFindOrAddGlyph::glyph_cursor#11 + (byte) charsetFindOrAddGlyph::i#2)==*((byte*) charsetFindOrAddGlyph::glyph#10 + (byte) charsetFindOrAddGlyph::i#2)) goto charsetFindOrAddGlyph::@4 + to:charsetFindOrAddGlyph::@5 +charsetFindOrAddGlyph::@5: scope:[charsetFindOrAddGlyph] from charsetFindOrAddGlyph::@2 charsetFindOrAddGlyph::@3 + [208] (byte) charsetFindOrAddGlyph::found#2 ← phi( charsetFindOrAddGlyph::@3/(byte) 0 charsetFindOrAddGlyph::@2/(byte) 1 ) + [209] if((byte) 0==(byte) charsetFindOrAddGlyph::found#2) goto charsetFindOrAddGlyph::@6 + to:charsetFindOrAddGlyph::@return +charsetFindOrAddGlyph::@6: scope:[charsetFindOrAddGlyph] from charsetFindOrAddGlyph::@5 + [210] (byte) charsetFindOrAddGlyph::glyph_id#1 ← ++ (byte) charsetFindOrAddGlyph::glyph_id#11 + [211] (byte*) charsetFindOrAddGlyph::glyph_cursor#1 ← (byte*) charsetFindOrAddGlyph::glyph_cursor#11 + (byte) 8 + to:charsetFindOrAddGlyph::@1 +charsetFindOrAddGlyph::@4: scope:[charsetFindOrAddGlyph] from charsetFindOrAddGlyph::@3 + [212] (byte) charsetFindOrAddGlyph::i#1 ← ++ (byte) charsetFindOrAddGlyph::i#2 + to:charsetFindOrAddGlyph::@2 + +(void()) protoBobShiftRight() +protoBobShiftRight: scope:[protoBobShiftRight] from prepareBobs::@12 prepareBobs::@7 + [213] phi() + to:protoBobShiftRight::@1 +protoBobShiftRight::@1: scope:[protoBobShiftRight] from protoBobShiftRight protoBobShiftRight::@6 + [214] (byte) protoBobShiftRight::carry#2 ← phi( protoBobShiftRight/(byte) 0 protoBobShiftRight::@6/(byte) protoBobShiftRight::carry#10 ) + [214] (byte) protoBobShiftRight::j#3 ← phi( protoBobShiftRight/(byte) 0 protoBobShiftRight::@6/(byte) protoBobShiftRight::j#10 ) + [214] (byte) protoBobShiftRight::i#2 ← phi( protoBobShiftRight/(byte) 0 protoBobShiftRight::@6/(byte) protoBobShiftRight::i#1 ) + [215] if((byte) protoBobShiftRight::i#2<(byte)(number) 3*(number) 3*(number) 8) goto protoBobShiftRight::@2 + to:protoBobShiftRight::@return +protoBobShiftRight::@return: scope:[protoBobShiftRight] from protoBobShiftRight::@1 + [216] return + to:@return +protoBobShiftRight::@2: scope:[protoBobShiftRight] from protoBobShiftRight::@1 + [217] (byte~) protoBobShiftRight::$1 ← *((const byte*) PROTO_BOB + (byte) protoBobShiftRight::j#3) & (byte) 1 + [218] if((byte) 0!=(byte~) protoBobShiftRight::$1) goto protoBobShiftRight::@3 + to:protoBobShiftRight::@4 +protoBobShiftRight::@3: scope:[protoBobShiftRight] from protoBobShiftRight::@2 + [219] phi() + to:protoBobShiftRight::@4 +protoBobShiftRight::@4: scope:[protoBobShiftRight] from protoBobShiftRight::@2 protoBobShiftRight::@3 + [220] (byte) protoBobShiftRight::carry#1 ← phi( protoBobShiftRight::@3/(byte) $80 protoBobShiftRight::@2/(byte) 0 ) + [221] (byte~) protoBobShiftRight::$5 ← *((const byte*) PROTO_BOB + (byte) protoBobShiftRight::j#3) >> (byte) 1 + [222] (byte~) protoBobShiftRight::$6 ← (byte) protoBobShiftRight::carry#2 | (byte~) protoBobShiftRight::$5 + [223] *((const byte*) PROTO_BOB + (byte) protoBobShiftRight::j#3) ← (byte~) protoBobShiftRight::$6 + [224] if((byte) protoBobShiftRight::j#3>=(byte) $30) goto protoBobShiftRight::@5 + to:protoBobShiftRight::@7 +protoBobShiftRight::@7: scope:[protoBobShiftRight] from protoBobShiftRight::@4 + [225] (byte) protoBobShiftRight::j#2 ← (byte) protoBobShiftRight::j#3 + (byte) $18 + to:protoBobShiftRight::@6 +protoBobShiftRight::@6: scope:[protoBobShiftRight] from protoBobShiftRight::@5 protoBobShiftRight::@7 + [226] (byte) protoBobShiftRight::j#10 ← phi( protoBobShiftRight::@7/(byte) protoBobShiftRight::j#2 protoBobShiftRight::@5/(byte) protoBobShiftRight::j#1 ) + [227] (byte) protoBobShiftRight::i#1 ← ++ (byte) protoBobShiftRight::i#2 + [228] (byte) protoBobShiftRight::carry#10 ← (byte) protoBobShiftRight::carry#1 + to:protoBobShiftRight::@1 +protoBobShiftRight::@5: scope:[protoBobShiftRight] from protoBobShiftRight::@4 + [229] (byte) protoBobShiftRight::j#1 ← (byte) protoBobShiftRight::j#3 - (byte) $2f + to:protoBobShiftRight::@6 + +(void()) protoBobShiftDown() +protoBobShiftDown: scope:[protoBobShiftDown] from prepareBobs::@4 + [230] phi() + to:protoBobShiftDown::@1 +protoBobShiftDown::@1: scope:[protoBobShiftDown] from protoBobShiftDown protoBobShiftDown::@2 + [231] (byte) protoBobShiftDown::i#2 ← phi( protoBobShiftDown/(byte) $17 protoBobShiftDown::@2/(byte) protoBobShiftDown::i#1 ) + [232] if((byte) protoBobShiftDown::i#2>(byte) 0) goto protoBobShiftDown::@2 + to:protoBobShiftDown::@3 +protoBobShiftDown::@3: scope:[protoBobShiftDown] from protoBobShiftDown::@1 + [233] *((const byte*) PROTO_BOB) ← (byte) 0 + [234] *((const byte*) PROTO_BOB+(byte) $18) ← (byte) 0 + [235] *((const byte*) PROTO_BOB+(byte) $30) ← (byte) 0 + to:protoBobShiftDown::@return +protoBobShiftDown::@return: scope:[protoBobShiftDown] from protoBobShiftDown::@3 + [236] return + to:@return +protoBobShiftDown::@2: scope:[protoBobShiftDown] from protoBobShiftDown::@1 + [237] *((const byte*) PROTO_BOB + (byte) protoBobShiftDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $17 + (byte) protoBobShiftDown::i#2) + [238] *((const byte*) PROTO_BOB+(byte) $18 + (byte) protoBobShiftDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $2f + (byte) protoBobShiftDown::i#2) + [239] *((const byte*) PROTO_BOB+(byte) $30 + (byte) protoBobShiftDown::i#2) ← (byte) 0 + [240] (byte) protoBobShiftDown::i#1 ← -- (byte) protoBobShiftDown::i#2 + to:protoBobShiftDown::@1 + +(void()) progress_init((byte*) progress_init::line) +progress_init: scope:[progress_init] from prepareBobs + [241] phi() + to:progress_init::@return +progress_init::@return: scope:[progress_init] from progress_init + [242] return + to:@return + +(void()) mulf_init() +mulf_init: scope:[mulf_init] from main + [243] phi() + to:mulf_init::@1 +mulf_init::@1: scope:[mulf_init] from mulf_init mulf_init::@3 + [244] (byte) mulf_init::x_2#3 ← phi( mulf_init/(byte) 0 mulf_init::@3/(byte) mulf_init::x_2#2 ) + [244] (byte*) mulf_init::sqr1_hi#2 ← phi( mulf_init/(const byte*) mulf_sqr1_hi+(byte) 1 mulf_init::@3/(byte*) mulf_init::sqr1_hi#1 ) + [244] (word) mulf_init::sqr#4 ← phi( mulf_init/(byte) 0 mulf_init::@3/(word) mulf_init::sqr#1 ) + [244] (byte) mulf_init::c#2 ← phi( mulf_init/(byte) 0 mulf_init::@3/(byte) mulf_init::c#1 ) + [244] (byte*) mulf_init::sqr1_lo#2 ← phi( mulf_init/(const byte*) mulf_sqr1_lo+(byte) 1 mulf_init::@3/(byte*) mulf_init::sqr1_lo#1 ) + [245] if((byte*) mulf_init::sqr1_lo#2!=(const byte*) mulf_sqr1_lo+(word) $200) goto mulf_init::@2 + to:mulf_init::@5 +mulf_init::@5: scope:[mulf_init] from mulf_init::@1 mulf_init::@8 + [246] (byte) mulf_init::dir#2 ← phi( mulf_init::@8/(byte) mulf_init::dir#4 mulf_init::@1/(byte) $ff ) + [246] (byte*) mulf_init::sqr2_hi#2 ← phi( mulf_init::@8/(byte*) mulf_init::sqr2_hi#1 mulf_init::@1/(const byte*) mulf_sqr2_hi ) + [246] (byte) mulf_init::x_255#2 ← phi( mulf_init::@8/(byte) mulf_init::x_255#1 mulf_init::@1/(byte) -1 ) + [246] (byte*) mulf_init::sqr2_lo#2 ← phi( mulf_init::@8/(byte*) mulf_init::sqr2_lo#1 mulf_init::@1/(const byte*) mulf_sqr2_lo ) + [247] if((byte*) mulf_init::sqr2_lo#2!=(const byte*) mulf_sqr2_lo+(word) $1ff) goto mulf_init::@6 + to:mulf_init::@7 +mulf_init::@7: scope:[mulf_init] from mulf_init::@5 + [248] *((const byte*) mulf_sqr2_lo+(word) $1ff) ← *((const byte*) mulf_sqr1_lo+(word) $100) + [249] *((const byte*) mulf_sqr2_hi+(word) $1ff) ← *((const byte*) mulf_sqr1_hi+(word) $100) + to:mulf_init::@return +mulf_init::@return: scope:[mulf_init] from mulf_init::@7 + [250] return + to:@return +mulf_init::@6: scope:[mulf_init] from mulf_init::@5 + [251] *((byte*) mulf_init::sqr2_lo#2) ← *((const byte*) mulf_sqr1_lo + (byte) mulf_init::x_255#2) + [252] *((byte*) mulf_init::sqr2_hi#2) ← *((const byte*) mulf_sqr1_hi + (byte) mulf_init::x_255#2) + [253] (byte*) mulf_init::sqr2_hi#1 ← ++ (byte*) mulf_init::sqr2_hi#2 + [254] (byte) mulf_init::x_255#1 ← (byte) mulf_init::x_255#2 + (byte) mulf_init::dir#2 + [255] if((byte) mulf_init::x_255#1!=(byte) 0) goto mulf_init::@9 + to:mulf_init::@8 +mulf_init::@9: scope:[mulf_init] from mulf_init::@6 + [256] phi() + to:mulf_init::@8 +mulf_init::@8: scope:[mulf_init] from mulf_init::@6 mulf_init::@9 + [257] (byte) mulf_init::dir#4 ← phi( mulf_init::@9/(byte) mulf_init::dir#2 mulf_init::@6/(byte) 1 ) + [258] (byte*) mulf_init::sqr2_lo#1 ← ++ (byte*) mulf_init::sqr2_lo#2 + to:mulf_init::@5 +mulf_init::@2: scope:[mulf_init] from mulf_init::@1 + [259] (byte) mulf_init::c#1 ← ++ (byte) mulf_init::c#2 + [260] (byte~) mulf_init::$1 ← (byte) mulf_init::c#1 & (byte) 1 + [261] if((byte~) mulf_init::$1!=(byte) 0) goto mulf_init::@3 + to:mulf_init::@4 +mulf_init::@4: scope:[mulf_init] from mulf_init::@2 + [262] (byte) mulf_init::x_2#1 ← ++ (byte) mulf_init::x_2#3 + [263] (word) mulf_init::sqr#2 ← ++ (word) mulf_init::sqr#4 + to:mulf_init::@3 +mulf_init::@3: scope:[mulf_init] from mulf_init::@2 mulf_init::@4 + [264] (byte) mulf_init::x_2#2 ← phi( mulf_init::@2/(byte) mulf_init::x_2#3 mulf_init::@4/(byte) mulf_init::x_2#1 ) + [264] (word) mulf_init::sqr#3 ← phi( mulf_init::@2/(word) mulf_init::sqr#4 mulf_init::@4/(word) mulf_init::sqr#2 ) + [265] (byte~) mulf_init::$4 ← < (word) mulf_init::sqr#3 + [266] *((byte*) mulf_init::sqr1_lo#2) ← (byte~) mulf_init::$4 + [267] (byte~) mulf_init::$5 ← > (word) mulf_init::sqr#3 + [268] *((byte*) mulf_init::sqr1_hi#2) ← (byte~) mulf_init::$5 + [269] (byte*) mulf_init::sqr1_hi#1 ← ++ (byte*) mulf_init::sqr1_hi#2 + [270] (word) mulf_init::sqr#1 ← (word) mulf_init::sqr#3 + (byte) mulf_init::x_2#2 + [271] (byte*) mulf_init::sqr1_lo#1 ← ++ (byte*) mulf_init::sqr1_lo#2 + to:mulf_init::@1 diff --git a/src/test/ref/complex/prebob/grid-bobs.log b/src/test/ref/complex/prebob/grid-bobs.log new file mode 100644 index 000000000..92dba5ee5 --- /dev/null +++ b/src/test/ref/complex/prebob/grid-bobs.log @@ -0,0 +1,11543 @@ +Resolved forward reference bob_charset_next_id to (byte) bob_charset_next_id +Fixing pointer addition (word*~) bsearch16u::$7 ← (word*) bsearch16u::items + (byte~) bsearch16u::$6 +Fixing pointer addition (word*~) bsearch16u::$15 ← (word*) bsearch16u::pivot + (number) 1 +Fixing pointer addition (word*~) bsearch16u::$1 ← (word*) bsearch16u::items - (number) 1 +Fixing pointer increment (byte**) renderBobCleanupNext ← ++ (byte**) renderBobCleanupNext +Fixing pointer array-indexing *((word*) utoa::digit_values + (byte) utoa::digit) +Fixing pointer array-indexing *((dword*) ultoa::digit_values + (byte) ultoa::digit) +Fixing pointer array-indexing *((const word*) MUL40 + (byte) renderBobInit::y) +Fixing pointer array-indexing *((const byte**) RENDERBOB_CLEANUP + (byte) renderBobInit::i) +Fixing pointer array-indexing *((const word*) MUL40 + (byte) renderBob::y_char_offset) +Fixing pointer array-indexing *((const byte**) RENDERBOB_CLEANUP + (byte) renderBobCleanup::i) +Warning! Adding boolean cast to non-boolean condition *((byte*) strcpy::src) +Warning! Adding boolean cast to non-boolean condition *((byte*) print_str_lines::str) +Warning! Adding boolean cast to non-boolean condition (byte) print_str_lines::ch +Warning! Adding boolean cast to non-boolean condition *((byte*) print_str::str) +Warning! Adding boolean cast to non-boolean condition *((byte*) print_str_at::str) +Warning! Adding boolean cast to non-boolean condition (byte~) main::$21 +Warning! Adding boolean cast to non-boolean condition (number~) protoBobShiftRight::$1 +Warning! Adding boolean cast to non-boolean sub-expression (byte) print_str_lines::ch +Warning! Adding boolean cast to non-boolean sub-expression (byte~) main::$19 +Warning! Adding boolean cast to non-boolean sub-expression (byte) charsetFindOrAddGlyph::found +Identified constant variable (byte*) HEAP_TOP +Identified constant variable (signed byte*) COS +Inlined call (byte~) vicSelectGfxBank::$0 ← call toDd00 (byte*) vicSelectGfxBank::gfx +Inlined call call mulf8s_prepare (signed byte) mulf8s::a +Inlined call call vicSelectGfxBank (const byte*) BOB_SCREEN +Inlined call (byte~) main::$4 ← call toD018 (const byte*) BOB_SCREEN (const byte*) BOB_CHARSET +Inlined call call vicSelectGfxBank (const byte*) SCREEN_BASIC +Inlined call (byte~) main::$7 ← call toD018 (const byte*) SCREEN_BASIC (const byte*) CHARSET_BASIC +Culled Empty Block (label) @1 +Culled Empty Block (label) @2 +Culled Empty Block (label) @3 +Culled Empty Block (label) @4 +Culled Empty Block (label) @5 +Culled Empty Block (label) @6 +Culled Empty Block (label) memset::@7 +Culled Empty Block (label) memset::@6 +Culled Empty Block (label) memset::@8 +Culled Empty Block (label) memset::@9 +Culled Empty Block (label) memset::@3 +Culled Empty Block (label) @7 +Culled Empty Block (label) @8 +Culled Empty Block (label) @9 +Culled Empty Block (label) keyboard_matrix_read::@1 +Culled Empty Block (label) @10 +Culled Empty Block (label) keyboard_key_pressed::@1 +Culled Empty Block (label) @11 +Culled Empty Block (label) @12 +Culled Empty Block (label) @13 +Culled Empty Block (label) @14 +Culled Empty Block (label) @15 +Culled Empty Block (label) @16 +Culled Empty Block (label) @17 +Culled Empty Block (label) @18 +Culled Empty Block (label) @19 +Culled Empty Block (label) @20 +Culled Empty Block (label) @21 +Culled Empty Block (label) @22 +Culled Empty Block (label) @23 +Culled Empty Block (label) @24 +Culled Empty Block (label) @25 +Culled Empty Block (label) @26 +Culled Empty Block (label) @27 +Culled Empty Block (label) @28 +Culled Empty Block (label) @29 +Culled Empty Block (label) @30 +Culled Empty Block (label) @31 +Culled Empty Block (label) @32 +Culled Empty Block (label) @33 +Culled Empty Block (label) @34 +Culled Empty Block (label) @35 +Culled Empty Block (label) @36 +Culled Empty Block (label) @37 +Culled Empty Block (label) @38 +Culled Empty Block (label) @39 +Culled Empty Block (label) @40 +Culled Empty Block (label) @41 +Culled Empty Block (label) @42 +Culled Empty Block (label) @43 +Culled Empty Block (label) @44 +Culled Empty Block (label) @45 +Culled Empty Block (label) @46 +Culled Empty Block (label) @47 +Culled Empty Block (label) @48 +Culled Empty Block (label) @49 +Culled Empty Block (label) mulf_init::@5 +Culled Empty Block (label) mulf_init::@6 +Culled Empty Block (label) mulf_init::@8 +Culled Empty Block (label) mulf_init::@13 +Culled Empty Block (label) mulf_init::@14 +Culled Empty Block (label) mulf_init::@16 +Culled Empty Block (label) @50 +Culled Empty Block (label) @51 +Culled Empty Block (label) mulf8u_prepared::@1 +Culled Empty Block (label) @52 +Culled Empty Block (label) @53 +Culled Empty Block (label) @54 +Culled Empty Block (label) mulf8s_prepared::@5 +Culled Empty Block (label) @55 +Culled Empty Block (label) mulf8s::mulf8s_prepare1_@return +Culled Empty Block (label) mulf8s::@1 +Culled Empty Block (label) @56 +Culled Empty Block (label) @57 +Culled Empty Block (label) @58 +Culled Empty Block (label) main::vicSelectGfxBank1_toDd001_@1 +Culled Empty Block (label) main::vicSelectGfxBank1_@return +Culled Empty Block (label) main::toD0181_@1 +Culled Empty Block (label) main::@2 +Culled Empty Block (label) main::@12 +Culled Empty Block (label) main::@3 +Culled Empty Block (label) main::@13 +Culled Empty Block (label) main::@10 +Culled Empty Block (label) main::@8 +Culled Empty Block (label) main::@11 +Culled Empty Block (label) main::@9 +Culled Empty Block (label) main::@14 +Culled Empty Block (label) main::@16 +Culled Empty Block (label) main::@18 +Culled Empty Block (label) main::vicSelectGfxBank2_toDd001_@1 +Culled Empty Block (label) main::vicSelectGfxBank2_@return +Culled Empty Block (label) main::toD0182_@1 +Culled Empty Block (label) main::@19 +Culled Empty Block (label) main::@20 +Culled Empty Block (label) renderBobInit::@4 +Culled Empty Block (label) @60 +Culled Empty Block (label) @61 +Culled Empty Block (label) @62 +Culled Empty Block (label) prepareBobs::@17 +Culled Empty Block (label) prepareBobs::@3 +Culled Empty Block (label) prepareBobs::@18 +Culled Empty Block (label) prepareBobs::@14 +Culled Empty Block (label) prepareBobs::@15 +Culled Empty Block (label) prepareBobs::@10 +Culled Empty Block (label) prepareBobs::@11 +Culled Empty Block (label) prepareBobs::@12 +Culled Empty Block (label) prepareBobs::@13 +Culled Empty Block (label) prepareBobs::@16 +Culled Empty Block (label) @63 +Culled Empty Block (label) protoBobShiftRight::@9 +Culled Empty Block (label) protoBobShiftRight::@3 +Culled Empty Block (label) protoBobShiftRight::@10 +Culled Empty Block (label) protoBobShiftRight::@11 +Culled Empty Block (label) protoBobShiftRight::@12 +Culled Empty Block (label) protoBobShiftRight::@14 +Culled Empty Block (label) protoBobShiftRight::@15 +Culled Empty Block (label) @64 +Culled Empty Block (label) protoBobShiftDown::@4 +Culled Empty Block (label) protoBobShiftDown::@5 +Culled Empty Block (label) protoBobShiftDown::@6 +Culled Empty Block (label) charsetFindOrAddGlyph::@17 +Culled Empty Block (label) charsetFindOrAddGlyph::@18 +Culled Empty Block (label) charsetFindOrAddGlyph::@9 +Culled Empty Block (label) charsetFindOrAddGlyph::@6 +Culled Empty Block (label) charsetFindOrAddGlyph::@10 +Culled Empty Block (label) charsetFindOrAddGlyph::@12 +Culled Empty Block (label) charsetFindOrAddGlyph::@13 +Culled Empty Block (label) charsetFindOrAddGlyph::@15 +Culled Empty Block (label) charsetFindOrAddGlyph::@19 +Culled Empty Block (label) charsetFindOrAddGlyph::@23 +Culled Empty Block (label) charsetFindOrAddGlyph::@24 +Culled Empty Block (label) charsetFindOrAddGlyph::@25 +Culled Empty Block (label) charsetFindOrAddGlyph::@26 +Culled Empty Block (label) @67 + +CONTROL FLOW GRAPH SSA +@begin: scope:[] from + to:@59 + +(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num) +memset: scope:[memset] from main::@22 + (byte) memset::c#4 ← phi( main::@22/(byte) memset::c#0 ) + (void*) memset::str#3 ← phi( main::@22/(void*) memset::str#0 ) + (word) memset::num#1 ← phi( main::@22/(word) memset::num#0 ) + (bool~) memset::$0 ← (word) memset::num#1 > (number) 0 + (bool~) memset::$1 ← ! (bool~) memset::$0 + if((bool~) memset::$1) goto memset::@1 + to:memset::@2 +memset::@1: scope:[memset] from memset memset::@4 + (void*) memset::str#1 ← phi( memset/(void*) memset::str#3 memset::@4/(void*) memset::str#4 ) + (void*) memset::return#0 ← (void*) memset::str#1 + to:memset::@return +memset::@2: scope:[memset] from memset + (byte) memset::c#3 ← phi( memset/(byte) memset::c#4 ) + (word) memset::num#2 ← phi( memset/(word) memset::num#1 ) + (void*) memset::str#2 ← phi( memset/(void*) memset::str#3 ) + (byte*~) memset::$2 ← ((byte*)) (void*) memset::str#2 + (byte*~) memset::$3 ← (byte*~) memset::$2 + (word) memset::num#2 + (byte*) memset::end#0 ← (byte*~) memset::$3 + (byte*) memset::dst#0 ← ((byte*)) (void*) memset::str#2 + to:memset::@4 +memset::@4: scope:[memset] from memset::@2 memset::@5 + (byte) memset::c#2 ← phi( memset::@2/(byte) memset::c#3 memset::@5/(byte) memset::c#1 ) + (void*) memset::str#4 ← phi( memset::@2/(void*) memset::str#2 memset::@5/(void*) memset::str#5 ) + (byte*) memset::end#1 ← phi( memset::@2/(byte*) memset::end#0 memset::@5/(byte*) memset::end#2 ) + (byte*) memset::dst#2 ← phi( memset::@2/(byte*) memset::dst#0 memset::@5/(byte*) memset::dst#1 ) + (bool~) memset::$4 ← (byte*) memset::dst#2 != (byte*) memset::end#1 + if((bool~) memset::$4) goto memset::@5 + to:memset::@1 +memset::@5: scope:[memset] from memset::@4 + (void*) memset::str#5 ← phi( memset::@4/(void*) memset::str#4 ) + (byte*) memset::end#2 ← phi( memset::@4/(byte*) memset::end#1 ) + (byte*) memset::dst#3 ← phi( memset::@4/(byte*) memset::dst#2 ) + (byte) memset::c#1 ← phi( memset::@4/(byte) memset::c#2 ) + *((byte*) memset::dst#3) ← (byte) memset::c#1 + (byte*) memset::dst#1 ← ++ (byte*) memset::dst#3 + to:memset::@4 +memset::@return: scope:[memset] from memset::@1 + (void*) memset::return#3 ← phi( memset::@1/(void*) memset::return#0 ) + (void*) memset::return#1 ← (void*) memset::return#3 + return + to:@return + +(byte()) keyboard_matrix_read((byte) keyboard_matrix_read::rowid) +keyboard_matrix_read: scope:[keyboard_matrix_read] from keyboard_key_pressed + (byte) keyboard_matrix_read::rowid#1 ← phi( keyboard_key_pressed/(byte) keyboard_matrix_read::rowid#0 ) + *((const byte*) CIA1_PORT_A) ← *((const byte*) keyboard_matrix_row_bitmask + (byte) keyboard_matrix_read::rowid#1) + (byte~) keyboard_matrix_read::$0 ← ~ *((const byte*) CIA1_PORT_B) + (byte) keyboard_matrix_read::row_pressed_bits#0 ← (byte~) keyboard_matrix_read::$0 + (byte) keyboard_matrix_read::return#0 ← (byte) keyboard_matrix_read::row_pressed_bits#0 + to:keyboard_matrix_read::@return +keyboard_matrix_read::@return: scope:[keyboard_matrix_read] from keyboard_matrix_read + (byte) keyboard_matrix_read::return#3 ← phi( keyboard_matrix_read/(byte) keyboard_matrix_read::return#0 ) + (byte) keyboard_matrix_read::return#1 ← (byte) keyboard_matrix_read::return#3 + return + to:@return + +(byte()) keyboard_key_pressed((byte) keyboard_key_pressed::key) +keyboard_key_pressed: scope:[keyboard_key_pressed] from main::@15 main::@7 + (byte) keyboard_key_pressed::key#2 ← phi( main::@15/(byte) keyboard_key_pressed::key#1 main::@7/(byte) keyboard_key_pressed::key#0 ) + (number~) keyboard_key_pressed::$0 ← (byte) keyboard_key_pressed::key#2 & (number) 7 + (byte) keyboard_key_pressed::colidx#0 ← (number~) keyboard_key_pressed::$0 + (byte~) keyboard_key_pressed::$1 ← (byte) keyboard_key_pressed::key#2 >> (number) 3 + (byte) keyboard_key_pressed::rowidx#0 ← (byte~) keyboard_key_pressed::$1 + (byte) keyboard_matrix_read::rowid#0 ← (byte) keyboard_key_pressed::rowidx#0 + call keyboard_matrix_read + (byte) keyboard_matrix_read::return#2 ← (byte) keyboard_matrix_read::return#1 + to:keyboard_key_pressed::@2 +keyboard_key_pressed::@2: scope:[keyboard_key_pressed] from keyboard_key_pressed + (byte) keyboard_key_pressed::colidx#1 ← phi( keyboard_key_pressed/(byte) keyboard_key_pressed::colidx#0 ) + (byte) keyboard_matrix_read::return#4 ← phi( keyboard_key_pressed/(byte) keyboard_matrix_read::return#2 ) + (byte~) keyboard_key_pressed::$2 ← (byte) keyboard_matrix_read::return#4 + (byte~) keyboard_key_pressed::$3 ← (byte~) keyboard_key_pressed::$2 & *((const byte*) keyboard_matrix_col_bitmask + (byte) keyboard_key_pressed::colidx#1) + (byte) keyboard_key_pressed::return#0 ← (byte~) keyboard_key_pressed::$3 + to:keyboard_key_pressed::@return +keyboard_key_pressed::@return: scope:[keyboard_key_pressed] from keyboard_key_pressed::@2 + (byte) keyboard_key_pressed::return#4 ← phi( keyboard_key_pressed::@2/(byte) keyboard_key_pressed::return#0 ) + (byte) keyboard_key_pressed::return#1 ← (byte) keyboard_key_pressed::return#4 + return + to:@return + +(void()) mulf_init() +mulf_init: scope:[mulf_init] from main + (word) mulf_init::sqr#0 ← (number) 0 + (byte) mulf_init::x_2#0 ← (number) 0 + (byte) mulf_init::c#0 ← (number) 0 + (byte*) mulf_init::sqr1_hi#0 ← (const byte*) mulf_sqr1_hi+(number) 1 + (byte*) mulf_init::sqr1_lo#0 ← (const byte*) mulf_sqr1_lo+(number) 1 + to:mulf_init::@1 +mulf_init::@1: scope:[mulf_init] from mulf_init mulf_init::@4 + (byte) mulf_init::x_2#5 ← phi( mulf_init/(byte) mulf_init::x_2#0 mulf_init::@4/(byte) mulf_init::x_2#2 ) + (byte*) mulf_init::sqr1_hi#5 ← phi( mulf_init/(byte*) mulf_init::sqr1_hi#0 mulf_init::@4/(byte*) mulf_init::sqr1_hi#1 ) + (word) mulf_init::sqr#6 ← phi( mulf_init/(word) mulf_init::sqr#0 mulf_init::@4/(word) mulf_init::sqr#1 ) + (byte) mulf_init::c#3 ← phi( mulf_init/(byte) mulf_init::c#0 mulf_init::@4/(byte) mulf_init::c#4 ) + (byte*) mulf_init::sqr1_lo#2 ← phi( mulf_init/(byte*) mulf_init::sqr1_lo#0 mulf_init::@4/(byte*) mulf_init::sqr1_lo#1 ) + (bool~) mulf_init::$0 ← (byte*) mulf_init::sqr1_lo#2 != (const byte*) mulf_sqr1_lo+(number) $200 + if((bool~) mulf_init::$0) goto mulf_init::@2 + to:mulf_init::@3 +mulf_init::@2: scope:[mulf_init] from mulf_init::@1 + (byte) mulf_init::x_2#4 ← phi( mulf_init::@1/(byte) mulf_init::x_2#5 ) + (byte*) mulf_init::sqr1_hi#3 ← phi( mulf_init::@1/(byte*) mulf_init::sqr1_hi#5 ) + (byte*) mulf_init::sqr1_lo#4 ← phi( mulf_init::@1/(byte*) mulf_init::sqr1_lo#2 ) + (word) mulf_init::sqr#5 ← phi( mulf_init::@1/(word) mulf_init::sqr#6 ) + (byte) mulf_init::c#2 ← phi( mulf_init::@1/(byte) mulf_init::c#3 ) + (byte) mulf_init::c#1 ← ++ (byte) mulf_init::c#2 + (number~) mulf_init::$1 ← (byte) mulf_init::c#1 & (number) 1 + (bool~) mulf_init::$2 ← (number~) mulf_init::$1 == (number) 0 + (bool~) mulf_init::$3 ← ! (bool~) mulf_init::$2 + if((bool~) mulf_init::$3) goto mulf_init::@4 + to:mulf_init::@7 +mulf_init::@3: scope:[mulf_init] from mulf_init::@1 + (byte) mulf_init::x_255#0 ← (byte)(number) -1 + (byte) mulf_init::dir#0 ← (number) $ff + (byte*) mulf_init::sqr2_hi#0 ← (const byte*) mulf_sqr2_hi + (byte*) mulf_init::sqr2_lo#0 ← (const byte*) mulf_sqr2_lo + to:mulf_init::@9 +mulf_init::@4: scope:[mulf_init] from mulf_init::@2 mulf_init::@7 + (byte) mulf_init::c#4 ← phi( mulf_init::@2/(byte) mulf_init::c#1 mulf_init::@7/(byte) mulf_init::c#5 ) + (byte) mulf_init::x_2#2 ← phi( mulf_init::@2/(byte) mulf_init::x_2#4 mulf_init::@7/(byte) mulf_init::x_2#1 ) + (byte*) mulf_init::sqr1_hi#2 ← phi( mulf_init::@2/(byte*) mulf_init::sqr1_hi#3 mulf_init::@7/(byte*) mulf_init::sqr1_hi#4 ) + (byte*) mulf_init::sqr1_lo#3 ← phi( mulf_init::@2/(byte*) mulf_init::sqr1_lo#4 mulf_init::@7/(byte*) mulf_init::sqr1_lo#5 ) + (word) mulf_init::sqr#3 ← phi( mulf_init::@2/(word) mulf_init::sqr#5 mulf_init::@7/(word) mulf_init::sqr#2 ) + (byte~) mulf_init::$4 ← < (word) mulf_init::sqr#3 + *((byte*) mulf_init::sqr1_lo#3) ← (byte~) mulf_init::$4 + (byte~) mulf_init::$5 ← > (word) mulf_init::sqr#3 + *((byte*) mulf_init::sqr1_hi#2) ← (byte~) mulf_init::$5 + (byte*) mulf_init::sqr1_hi#1 ← ++ (byte*) mulf_init::sqr1_hi#2 + (word~) mulf_init::$6 ← (word) mulf_init::sqr#3 + (byte) mulf_init::x_2#2 + (word) mulf_init::sqr#1 ← (word~) mulf_init::$6 + (byte*) mulf_init::sqr1_lo#1 ← ++ (byte*) mulf_init::sqr1_lo#3 + to:mulf_init::@1 +mulf_init::@7: scope:[mulf_init] from mulf_init::@2 + (byte) mulf_init::c#5 ← phi( mulf_init::@2/(byte) mulf_init::c#1 ) + (byte*) mulf_init::sqr1_hi#4 ← phi( mulf_init::@2/(byte*) mulf_init::sqr1_hi#3 ) + (byte*) mulf_init::sqr1_lo#5 ← phi( mulf_init::@2/(byte*) mulf_init::sqr1_lo#4 ) + (word) mulf_init::sqr#4 ← phi( mulf_init::@2/(word) mulf_init::sqr#5 ) + (byte) mulf_init::x_2#3 ← phi( mulf_init::@2/(byte) mulf_init::x_2#4 ) + (byte) mulf_init::x_2#1 ← ++ (byte) mulf_init::x_2#3 + (word) mulf_init::sqr#2 ← ++ (word) mulf_init::sqr#4 + to:mulf_init::@4 +mulf_init::@9: scope:[mulf_init] from mulf_init::@12 mulf_init::@3 + (byte) mulf_init::dir#3 ← phi( mulf_init::@12/(byte) mulf_init::dir#4 mulf_init::@3/(byte) mulf_init::dir#0 ) + (byte*) mulf_init::sqr2_hi#3 ← phi( mulf_init::@12/(byte*) mulf_init::sqr2_hi#4 mulf_init::@3/(byte*) mulf_init::sqr2_hi#0 ) + (byte) mulf_init::x_255#3 ← phi( mulf_init::@12/(byte) mulf_init::x_255#4 mulf_init::@3/(byte) mulf_init::x_255#0 ) + (byte*) mulf_init::sqr2_lo#2 ← phi( mulf_init::@12/(byte*) mulf_init::sqr2_lo#1 mulf_init::@3/(byte*) mulf_init::sqr2_lo#0 ) + (bool~) mulf_init::$7 ← (byte*) mulf_init::sqr2_lo#2 != (const byte*) mulf_sqr2_lo+(number) $1ff + if((bool~) mulf_init::$7) goto mulf_init::@10 + to:mulf_init::@11 +mulf_init::@10: scope:[mulf_init] from mulf_init::@9 + (byte) mulf_init::dir#2 ← phi( mulf_init::@9/(byte) mulf_init::dir#3 ) + (byte*) mulf_init::sqr2_hi#2 ← phi( mulf_init::@9/(byte*) mulf_init::sqr2_hi#3 ) + (byte*) mulf_init::sqr2_lo#3 ← phi( mulf_init::@9/(byte*) mulf_init::sqr2_lo#2 ) + (byte) mulf_init::x_255#2 ← phi( mulf_init::@9/(byte) mulf_init::x_255#3 ) + *((byte*) mulf_init::sqr2_lo#3) ← *((const byte*) mulf_sqr1_lo + (byte) mulf_init::x_255#2) + *((byte*) mulf_init::sqr2_hi#2) ← *((const byte*) mulf_sqr1_hi + (byte) mulf_init::x_255#2) + (byte*) mulf_init::sqr2_hi#1 ← ++ (byte*) mulf_init::sqr2_hi#2 + (byte~) mulf_init::$8 ← (byte) mulf_init::x_255#2 + (byte) mulf_init::dir#2 + (byte) mulf_init::x_255#1 ← (byte~) mulf_init::$8 + (bool~) mulf_init::$9 ← (byte) mulf_init::x_255#1 == (number) 0 + (bool~) mulf_init::$10 ← ! (bool~) mulf_init::$9 + if((bool~) mulf_init::$10) goto mulf_init::@12 + to:mulf_init::@15 +mulf_init::@11: scope:[mulf_init] from mulf_init::@9 + *((const byte*) mulf_sqr2_lo+(number) $1ff) ← *((const byte*) mulf_sqr1_lo+(number) $100) + *((const byte*) mulf_sqr2_hi+(number) $1ff) ← *((const byte*) mulf_sqr1_hi+(number) $100) + to:mulf_init::@return +mulf_init::@12: scope:[mulf_init] from mulf_init::@10 mulf_init::@15 + (byte) mulf_init::dir#4 ← phi( mulf_init::@10/(byte) mulf_init::dir#2 mulf_init::@15/(byte) mulf_init::dir#1 ) + (byte*) mulf_init::sqr2_hi#4 ← phi( mulf_init::@10/(byte*) mulf_init::sqr2_hi#1 mulf_init::@15/(byte*) mulf_init::sqr2_hi#5 ) + (byte) mulf_init::x_255#4 ← phi( mulf_init::@10/(byte) mulf_init::x_255#1 mulf_init::@15/(byte) mulf_init::x_255#5 ) + (byte*) mulf_init::sqr2_lo#4 ← phi( mulf_init::@10/(byte*) mulf_init::sqr2_lo#3 mulf_init::@15/(byte*) mulf_init::sqr2_lo#5 ) + (byte*) mulf_init::sqr2_lo#1 ← ++ (byte*) mulf_init::sqr2_lo#4 + to:mulf_init::@9 +mulf_init::@15: scope:[mulf_init] from mulf_init::@10 + (byte*) mulf_init::sqr2_hi#5 ← phi( mulf_init::@10/(byte*) mulf_init::sqr2_hi#1 ) + (byte) mulf_init::x_255#5 ← phi( mulf_init::@10/(byte) mulf_init::x_255#1 ) + (byte*) mulf_init::sqr2_lo#5 ← phi( mulf_init::@10/(byte*) mulf_init::sqr2_lo#3 ) + (byte) mulf_init::dir#1 ← (number) 1 + to:mulf_init::@12 +mulf_init::@return: scope:[mulf_init] from mulf_init::@11 + return + to:@return + +(void()) mulf8u_prepare((byte) mulf8u_prepare::a) +mulf8u_prepare: scope:[mulf8u_prepare] from mulf8s::mulf8s_prepare1 + (byte) mulf8u_prepare::a#1 ← phi( mulf8s::mulf8s_prepare1/(byte) mulf8u_prepare::a#0 ) + *((const byte*) mulf8u_prepare::memA) ← (byte) mulf8u_prepare::a#1 + asm { ldamemA stamulf8u_prepared.sm1+1 stamulf8u_prepared.sm3+1 eor#$ff stamulf8u_prepared.sm2+1 stamulf8u_prepared.sm4+1 } + to:mulf8u_prepare::@return +mulf8u_prepare::@return: scope:[mulf8u_prepare] from mulf8u_prepare + return + to:@return + +(word()) mulf8u_prepared((byte) mulf8u_prepared::b) +mulf8u_prepared: scope:[mulf8u_prepared] from mulf8s_prepared + (byte) mulf8u_prepared::b#1 ← phi( mulf8s_prepared/(byte) mulf8u_prepared::b#0 ) + *((const byte*) mulf8u_prepared::memB) ← (byte) mulf8u_prepared::b#1 + asm { ldxmemB sec sm1: ldamulf_sqr1_lo,x sm2: sbcmulf_sqr2_lo,x staresL sm3: ldamulf_sqr1_hi,x sm4: sbcmulf_sqr2_hi,x stamemB } + (word) mulf8u_prepared::return#0 ← ((word)) { *((const byte*) mulf8u_prepared::memB), *((const byte*) mulf8u_prepared::resL) } + to:mulf8u_prepared::@return +mulf8u_prepared::@return: scope:[mulf8u_prepared] from mulf8u_prepared + (word) mulf8u_prepared::return#3 ← phi( mulf8u_prepared/(word) mulf8u_prepared::return#0 ) + (word) mulf8u_prepared::return#1 ← (word) mulf8u_prepared::return#3 + return + to:@return + +(signed word()) mulf8s_prepared((signed byte) mulf8s_prepared::b) +mulf8s_prepared: scope:[mulf8s_prepared] from mulf8s::@2 + (signed byte) mulf8s_prepared::b#1 ← phi( mulf8s::@2/(signed byte) mulf8s_prepared::b#0 ) + (byte~) mulf8s_prepared::$0 ← ((byte)) (signed byte) mulf8s_prepared::b#1 + (byte) mulf8u_prepared::b#0 ← (byte~) mulf8s_prepared::$0 + call mulf8u_prepared + (word) mulf8u_prepared::return#2 ← (word) mulf8u_prepared::return#1 + to:mulf8s_prepared::@6 +mulf8s_prepared::@6: scope:[mulf8s_prepared] from mulf8s_prepared + (signed byte) mulf8s_prepared::b#4 ← phi( mulf8s_prepared/(signed byte) mulf8s_prepared::b#1 ) + (word) mulf8u_prepared::return#4 ← phi( mulf8s_prepared/(word) mulf8u_prepared::return#2 ) + (word~) mulf8s_prepared::$1 ← (word) mulf8u_prepared::return#4 + (word) mulf8s_prepared::m#0 ← (word~) mulf8s_prepared::$1 + (bool~) mulf8s_prepared::$2 ← *((const signed byte*) mulf8s_prepared::memA) < (number) 0 + (bool~) mulf8s_prepared::$3 ← ! (bool~) mulf8s_prepared::$2 + if((bool~) mulf8s_prepared::$3) goto mulf8s_prepared::@1 + to:mulf8s_prepared::@3 +mulf8s_prepared::@1: scope:[mulf8s_prepared] from mulf8s_prepared::@3 mulf8s_prepared::@6 + (word) mulf8s_prepared::m#6 ← phi( mulf8s_prepared::@3/(word) mulf8s_prepared::m#1 mulf8s_prepared::@6/(word) mulf8s_prepared::m#0 ) + (signed byte) mulf8s_prepared::b#2 ← phi( mulf8s_prepared::@3/(signed byte) mulf8s_prepared::b#3 mulf8s_prepared::@6/(signed byte) mulf8s_prepared::b#4 ) + (bool~) mulf8s_prepared::$4 ← (signed byte) mulf8s_prepared::b#2 < (number) 0 + (bool~) mulf8s_prepared::$5 ← ! (bool~) mulf8s_prepared::$4 + if((bool~) mulf8s_prepared::$5) goto mulf8s_prepared::@2 + to:mulf8s_prepared::@4 +mulf8s_prepared::@3: scope:[mulf8s_prepared] from mulf8s_prepared::@6 + (signed byte) mulf8s_prepared::b#3 ← phi( mulf8s_prepared::@6/(signed byte) mulf8s_prepared::b#4 ) + (word) mulf8s_prepared::m#3 ← phi( mulf8s_prepared::@6/(word) mulf8s_prepared::m#0 ) + (byte~) mulf8s_prepared::$8 ← > (word) mulf8s_prepared::m#3 + (byte~) mulf8s_prepared::$9 ← ((byte)) (signed byte) mulf8s_prepared::b#3 + (byte~) mulf8s_prepared::$10 ← (byte~) mulf8s_prepared::$8 - (byte~) mulf8s_prepared::$9 + (byte~) mulf8s_prepared::$15 ← (byte~) mulf8s_prepared::$10 + (word) mulf8s_prepared::m#1 ← (word) mulf8s_prepared::m#3 hi= (byte~) mulf8s_prepared::$15 + to:mulf8s_prepared::@1 +mulf8s_prepared::@2: scope:[mulf8s_prepared] from mulf8s_prepared::@1 mulf8s_prepared::@4 + (word) mulf8s_prepared::m#4 ← phi( mulf8s_prepared::@1/(word) mulf8s_prepared::m#6 mulf8s_prepared::@4/(word) mulf8s_prepared::m#2 ) + (signed word~) mulf8s_prepared::$6 ← ((signed word)) (word) mulf8s_prepared::m#4 + (signed word) mulf8s_prepared::return#0 ← (signed word~) mulf8s_prepared::$6 + to:mulf8s_prepared::@return +mulf8s_prepared::@4: scope:[mulf8s_prepared] from mulf8s_prepared::@1 + (word) mulf8s_prepared::m#5 ← phi( mulf8s_prepared::@1/(word) mulf8s_prepared::m#6 ) + (byte~) mulf8s_prepared::$12 ← > (word) mulf8s_prepared::m#5 + (byte~) mulf8s_prepared::$13 ← ((byte)) *((const signed byte*) mulf8s_prepared::memA) + (byte~) mulf8s_prepared::$14 ← (byte~) mulf8s_prepared::$12 - (byte~) mulf8s_prepared::$13 + (byte~) mulf8s_prepared::$16 ← (byte~) mulf8s_prepared::$14 + (word) mulf8s_prepared::m#2 ← (word) mulf8s_prepared::m#5 hi= (byte~) mulf8s_prepared::$16 + to:mulf8s_prepared::@2 +mulf8s_prepared::@return: scope:[mulf8s_prepared] from mulf8s_prepared::@2 + (signed word) mulf8s_prepared::return#3 ← phi( mulf8s_prepared::@2/(signed word) mulf8s_prepared::return#0 ) + (signed word) mulf8s_prepared::return#1 ← (signed word) mulf8s_prepared::return#3 + return + to:@return + +(signed word()) mulf8s((signed byte) mulf8s::a , (signed byte) mulf8s::b) +mulf8s: scope:[mulf8s] from main::@30 main::@6 + (signed byte) mulf8s::b#5 ← phi( main::@30/(signed byte) mulf8s::b#1 main::@6/(signed byte) mulf8s::b#0 ) + (signed byte) mulf8s::a#2 ← phi( main::@30/(signed byte) mulf8s::a#1 main::@6/(signed byte) mulf8s::a#0 ) + (signed byte) mulf8s::mulf8s_prepare1_a#0 ← (signed byte) mulf8s::a#2 + to:mulf8s::mulf8s_prepare1 +mulf8s::mulf8s_prepare1: scope:[mulf8s] from mulf8s + (signed byte) mulf8s::b#4 ← phi( mulf8s/(signed byte) mulf8s::b#5 ) + (signed byte) mulf8s::mulf8s_prepare1_a#1 ← phi( mulf8s/(signed byte) mulf8s::mulf8s_prepare1_a#0 ) + (byte~) mulf8s::mulf8s_prepare1_$0 ← ((byte)) (signed byte) mulf8s::mulf8s_prepare1_a#1 + (byte) mulf8u_prepare::a#0 ← (byte~) mulf8s::mulf8s_prepare1_$0 + call mulf8u_prepare + to:mulf8s::@3 +mulf8s::@3: scope:[mulf8s] from mulf8s::mulf8s_prepare1 + (signed byte) mulf8s::b#3 ← phi( mulf8s::mulf8s_prepare1/(signed byte) mulf8s::b#4 ) + to:mulf8s::@2 +mulf8s::@2: scope:[mulf8s] from mulf8s::@3 + (signed byte) mulf8s::b#2 ← phi( mulf8s::@3/(signed byte) mulf8s::b#3 ) + (signed byte) mulf8s_prepared::b#0 ← (signed byte) mulf8s::b#2 + call mulf8s_prepared + (signed word) mulf8s_prepared::return#2 ← (signed word) mulf8s_prepared::return#1 + to:mulf8s::@4 +mulf8s::@4: scope:[mulf8s] from mulf8s::@2 + (signed word) mulf8s_prepared::return#4 ← phi( mulf8s::@2/(signed word) mulf8s_prepared::return#2 ) + (signed word~) mulf8s::$1 ← (signed word) mulf8s_prepared::return#4 + (signed word) mulf8s::return#0 ← (signed word~) mulf8s::$1 + to:mulf8s::@return +mulf8s::@return: scope:[mulf8s] from mulf8s::@4 + (signed word) mulf8s::return#4 ← phi( mulf8s::@4/(signed word) mulf8s::return#0 ) + (signed word) mulf8s::return#1 ← (signed word) mulf8s::return#4 + return + to:@return + +(void()) main() +main: scope:[main] from @68 + (byte**) renderBobCleanupNext#50 ← phi( @68/(byte**) renderBobCleanupNext#19 ) + (byte) bob_charset_next_id#28 ← phi( @68/(byte) bob_charset_next_id#27 ) + (byte) progress_idx#28 ← phi( @68/(byte) progress_idx#27 ) + (byte*) progress_cursor#28 ← phi( @68/(byte*) progress_cursor#27 ) + call mulf_init + to:main::@25 +main::@25: scope:[main] from main + (byte**) renderBobCleanupNext#49 ← phi( main/(byte**) renderBobCleanupNext#50 ) + (byte) bob_charset_next_id#19 ← phi( main/(byte) bob_charset_next_id#28 ) + (byte) progress_idx#22 ← phi( main/(byte) progress_idx#28 ) + (byte*) progress_cursor#21 ← phi( main/(byte*) progress_cursor#28 ) + call prepareBobs + to:main::@26 +main::@26: scope:[main] from main::@25 + (byte**) renderBobCleanupNext#48 ← phi( main::@25/(byte**) renderBobCleanupNext#49 ) + (byte) bob_charset_next_id#10 ← phi( main::@25/(byte) bob_charset_next_id#5 ) + (byte) progress_idx#12 ← phi( main::@25/(byte) progress_idx#4 ) + (byte*) progress_cursor#11 ← phi( main::@25/(byte*) progress_cursor#4 ) + (byte*) progress_cursor#0 ← (byte*) progress_cursor#11 + (byte) progress_idx#0 ← (byte) progress_idx#12 + (byte) bob_charset_next_id#0 ← (byte) bob_charset_next_id#10 + call renderBobInit + to:main::@27 +main::@27: scope:[main] from main::@26 + (byte) bob_charset_next_id#77 ← phi( main::@26/(byte) bob_charset_next_id#0 ) + (byte) progress_idx#69 ← phi( main::@26/(byte) progress_idx#0 ) + (byte*) progress_cursor#69 ← phi( main::@26/(byte*) progress_cursor#0 ) + (byte**) renderBobCleanupNext#47 ← phi( main::@26/(byte**) renderBobCleanupNext#48 ) + (byte*) main::vicSelectGfxBank1_gfx#0 ← (const byte*) BOB_SCREEN + to:main::vicSelectGfxBank1 +main::vicSelectGfxBank1: scope:[main] from main::@27 + (byte) bob_charset_next_id#76 ← phi( main::@27/(byte) bob_charset_next_id#77 ) + (byte) progress_idx#68 ← phi( main::@27/(byte) progress_idx#69 ) + (byte*) progress_cursor#68 ← phi( main::@27/(byte*) progress_cursor#69 ) + (byte**) renderBobCleanupNext#46 ← phi( main::@27/(byte**) renderBobCleanupNext#47 ) + (byte*) main::vicSelectGfxBank1_gfx#1 ← phi( main::@27/(byte*) main::vicSelectGfxBank1_gfx#0 ) + *((const byte*) CIA2_PORT_A_DDR) ← (number) 3 + (byte*) main::vicSelectGfxBank1_toDd001_gfx#0 ← (byte*) main::vicSelectGfxBank1_gfx#1 + to:main::vicSelectGfxBank1_toDd001 +main::vicSelectGfxBank1_toDd001: scope:[main] from main::vicSelectGfxBank1 + (byte) bob_charset_next_id#74 ← phi( main::vicSelectGfxBank1/(byte) bob_charset_next_id#76 ) + (byte) progress_idx#66 ← phi( main::vicSelectGfxBank1/(byte) progress_idx#68 ) + (byte*) progress_cursor#66 ← phi( main::vicSelectGfxBank1/(byte*) progress_cursor#68 ) + (byte**) renderBobCleanupNext#44 ← phi( main::vicSelectGfxBank1/(byte**) renderBobCleanupNext#46 ) + (byte*) main::vicSelectGfxBank1_toDd001_gfx#1 ← phi( main::vicSelectGfxBank1/(byte*) main::vicSelectGfxBank1_toDd001_gfx#0 ) + (word~) main::vicSelectGfxBank1_toDd001_$0 ← ((word)) (byte*) main::vicSelectGfxBank1_toDd001_gfx#1 + (byte~) main::vicSelectGfxBank1_toDd001_$1 ← > (word~) main::vicSelectGfxBank1_toDd001_$0 + (number~) main::vicSelectGfxBank1_toDd001_$2 ← (byte~) main::vicSelectGfxBank1_toDd001_$1 / (number) $40 + (number~) main::vicSelectGfxBank1_toDd001_$3 ← (number) 3 ^ (number~) main::vicSelectGfxBank1_toDd001_$2 + (byte) main::vicSelectGfxBank1_toDd001_return#0 ← (number~) main::vicSelectGfxBank1_toDd001_$3 + to:main::vicSelectGfxBank1_toDd001_@return +main::vicSelectGfxBank1_toDd001_@return: scope:[main] from main::vicSelectGfxBank1_toDd001 + (byte) bob_charset_next_id#72 ← phi( main::vicSelectGfxBank1_toDd001/(byte) bob_charset_next_id#74 ) + (byte) progress_idx#64 ← phi( main::vicSelectGfxBank1_toDd001/(byte) progress_idx#66 ) + (byte*) progress_cursor#64 ← phi( main::vicSelectGfxBank1_toDd001/(byte*) progress_cursor#66 ) + (byte**) renderBobCleanupNext#42 ← phi( main::vicSelectGfxBank1_toDd001/(byte**) renderBobCleanupNext#44 ) + (byte) main::vicSelectGfxBank1_toDd001_return#2 ← phi( main::vicSelectGfxBank1_toDd001/(byte) main::vicSelectGfxBank1_toDd001_return#0 ) + (byte) main::vicSelectGfxBank1_toDd001_return#1 ← (byte) main::vicSelectGfxBank1_toDd001_return#2 + to:main::vicSelectGfxBank1_@1 +main::vicSelectGfxBank1_@1: scope:[main] from main::vicSelectGfxBank1_toDd001_@return + (byte) bob_charset_next_id#70 ← phi( main::vicSelectGfxBank1_toDd001_@return/(byte) bob_charset_next_id#72 ) + (byte) progress_idx#62 ← phi( main::vicSelectGfxBank1_toDd001_@return/(byte) progress_idx#64 ) + (byte*) progress_cursor#62 ← phi( main::vicSelectGfxBank1_toDd001_@return/(byte*) progress_cursor#64 ) + (byte**) renderBobCleanupNext#40 ← phi( main::vicSelectGfxBank1_toDd001_@return/(byte**) renderBobCleanupNext#42 ) + (byte) main::vicSelectGfxBank1_toDd001_return#3 ← phi( main::vicSelectGfxBank1_toDd001_@return/(byte) main::vicSelectGfxBank1_toDd001_return#1 ) + (byte~) main::vicSelectGfxBank1_$0 ← (byte) main::vicSelectGfxBank1_toDd001_return#3 + *((const byte*) CIA2_PORT_A) ← (byte~) main::vicSelectGfxBank1_$0 + to:main::@21 +main::@21: scope:[main] from main::vicSelectGfxBank1_@1 + (byte) bob_charset_next_id#68 ← phi( main::vicSelectGfxBank1_@1/(byte) bob_charset_next_id#70 ) + (byte) progress_idx#60 ← phi( main::vicSelectGfxBank1_@1/(byte) progress_idx#62 ) + (byte*) progress_cursor#60 ← phi( main::vicSelectGfxBank1_@1/(byte*) progress_cursor#62 ) + (byte**) renderBobCleanupNext#38 ← phi( main::vicSelectGfxBank1_@1/(byte**) renderBobCleanupNext#40 ) + (byte*) main::toD0181_screen#0 ← (const byte*) BOB_SCREEN + (byte*) main::toD0181_gfx#0 ← (const byte*) BOB_CHARSET + to:main::toD0181 +main::toD0181: scope:[main] from main::@21 + (byte) bob_charset_next_id#66 ← phi( main::@21/(byte) bob_charset_next_id#68 ) + (byte) progress_idx#58 ← phi( main::@21/(byte) progress_idx#60 ) + (byte*) progress_cursor#58 ← phi( main::@21/(byte*) progress_cursor#60 ) + (byte**) renderBobCleanupNext#36 ← phi( main::@21/(byte**) renderBobCleanupNext#38 ) + (byte*) main::toD0181_gfx#1 ← phi( main::@21/(byte*) main::toD0181_gfx#0 ) + (byte*) main::toD0181_screen#1 ← phi( main::@21/(byte*) main::toD0181_screen#0 ) + (word~) main::toD0181_$0 ← ((word)) (byte*) main::toD0181_screen#1 + (number~) main::toD0181_$1 ← (word~) main::toD0181_$0 & (number) $3fff + (number~) main::toD0181_$2 ← (number~) main::toD0181_$1 * (number) 4 + (number~) main::toD0181_$3 ← > (number~) main::toD0181_$2 + (word~) main::toD0181_$4 ← ((word)) (byte*) main::toD0181_gfx#1 + (byte~) main::toD0181_$5 ← > (word~) main::toD0181_$4 + (number~) main::toD0181_$6 ← (byte~) main::toD0181_$5 / (number) 4 + (number~) main::toD0181_$7 ← (number~) main::toD0181_$6 & (number) $f + (number~) main::toD0181_$8 ← (number~) main::toD0181_$3 | (number~) main::toD0181_$7 + (byte) main::toD0181_return#0 ← (number~) main::toD0181_$8 + to:main::toD0181_@return +main::toD0181_@return: scope:[main] from main::toD0181 + (byte) bob_charset_next_id#64 ← phi( main::toD0181/(byte) bob_charset_next_id#66 ) + (byte) progress_idx#56 ← phi( main::toD0181/(byte) progress_idx#58 ) + (byte*) progress_cursor#56 ← phi( main::toD0181/(byte*) progress_cursor#58 ) + (byte**) renderBobCleanupNext#34 ← phi( main::toD0181/(byte**) renderBobCleanupNext#36 ) + (byte) main::toD0181_return#2 ← phi( main::toD0181/(byte) main::toD0181_return#0 ) + (byte) main::toD0181_return#1 ← (byte) main::toD0181_return#2 + to:main::@22 +main::@22: scope:[main] from main::toD0181_@return + (byte) bob_charset_next_id#62 ← phi( main::toD0181_@return/(byte) bob_charset_next_id#64 ) + (byte) progress_idx#54 ← phi( main::toD0181_@return/(byte) progress_idx#56 ) + (byte*) progress_cursor#54 ← phi( main::toD0181_@return/(byte*) progress_cursor#56 ) + (byte**) renderBobCleanupNext#31 ← phi( main::toD0181_@return/(byte**) renderBobCleanupNext#34 ) + (byte) main::toD0181_return#3 ← phi( main::toD0181_@return/(byte) main::toD0181_return#1 ) + (byte~) main::$4 ← (byte) main::toD0181_return#3 + *((const byte*) D018) ← (byte~) main::$4 + (void*) memset::str#0 ← (void*)(const byte*) BOB_SCREEN + (byte) memset::c#0 ← (number) 0 + (word) memset::num#0 ← (number) $3e8 + call memset + (void*) memset::return#2 ← (void*) memset::return#1 + to:main::@28 +main::@28: scope:[main] from main::@22 + (byte) bob_charset_next_id#60 ← phi( main::@22/(byte) bob_charset_next_id#62 ) + (byte) progress_idx#52 ← phi( main::@22/(byte) progress_idx#54 ) + (byte*) progress_cursor#52 ← phi( main::@22/(byte*) progress_cursor#54 ) + (byte**) renderBobCleanupNext#28 ← phi( main::@22/(byte**) renderBobCleanupNext#31 ) + (byte) main::angle#0 ← (number) 0 + to:main::@1 +main::@1: scope:[main] from main::@28 main::@33 + (byte) bob_charset_next_id#58 ← phi( main::@28/(byte) bob_charset_next_id#60 main::@33/(byte) bob_charset_next_id#59 ) + (byte) progress_idx#50 ← phi( main::@28/(byte) progress_idx#52 main::@33/(byte) progress_idx#51 ) + (byte*) progress_cursor#50 ← phi( main::@28/(byte*) progress_cursor#52 main::@33/(byte*) progress_cursor#51 ) + (byte) main::angle#8 ← phi( main::@28/(byte) main::angle#0 main::@33/(byte) main::angle#10 ) + (byte**) renderBobCleanupNext#24 ← phi( main::@28/(byte**) renderBobCleanupNext#28 main::@33/(byte**) renderBobCleanupNext#29 ) + if(true) goto main::@4 + to:main::@15 +main::@4: scope:[main] from main::@1 main::@4 + (byte) bob_charset_next_id#75 ← phi( main::@1/(byte) bob_charset_next_id#58 main::@4/(byte) bob_charset_next_id#75 ) + (byte) progress_idx#67 ← phi( main::@1/(byte) progress_idx#50 main::@4/(byte) progress_idx#67 ) + (byte*) progress_cursor#67 ← phi( main::@1/(byte*) progress_cursor#50 main::@4/(byte*) progress_cursor#67 ) + (byte) main::angle#6 ← phi( main::@1/(byte) main::angle#8 main::@4/(byte) main::angle#6 ) + (byte**) renderBobCleanupNext#20 ← phi( main::@1/(byte**) renderBobCleanupNext#24 main::@4/(byte**) renderBobCleanupNext#20 ) + (bool~) main::$8 ← *((const byte*) RASTER) < (number) $f8 + if((bool~) main::$8) goto main::@4 + to:main::@5 +main::@5: scope:[main] from main::@4 + (byte) bob_charset_next_id#73 ← phi( main::@4/(byte) bob_charset_next_id#75 ) + (byte) progress_idx#65 ← phi( main::@4/(byte) progress_idx#67 ) + (byte*) progress_cursor#65 ← phi( main::@4/(byte*) progress_cursor#67 ) + (byte) main::angle#4 ← phi( main::@4/(byte) main::angle#6 ) + (byte**) renderBobCleanupNext#16 ← phi( main::@4/(byte**) renderBobCleanupNext#20 ) + *((const byte*) BORDERCOL) ← (number) $f + call renderBobCleanup + to:main::@29 +main::@29: scope:[main] from main::@5 + (byte) bob_charset_next_id#71 ← phi( main::@5/(byte) bob_charset_next_id#73 ) + (byte) progress_idx#63 ← phi( main::@5/(byte) progress_idx#65 ) + (byte*) progress_cursor#63 ← phi( main::@5/(byte*) progress_cursor#65 ) + (byte) main::angle#2 ← phi( main::@5/(byte) main::angle#4 ) + (byte**) renderBobCleanupNext#9 ← phi( main::@5/(byte**) renderBobCleanupNext#7 ) + (byte**) renderBobCleanupNext#0 ← (byte**) renderBobCleanupNext#9 + (signed byte) main::r#0 ← (number) $1e + (byte) main::a#0 ← (byte) main::angle#2 + (byte) main::i#0 ← (byte) 0 + to:main::@6 +main::@6: scope:[main] from main::@29 main::@32 + (byte) bob_charset_next_id#69 ← phi( main::@29/(byte) bob_charset_next_id#71 main::@32/(byte) bob_charset_next_id#63 ) + (byte) progress_idx#61 ← phi( main::@29/(byte) progress_idx#63 main::@32/(byte) progress_idx#55 ) + (byte*) progress_cursor#61 ← phi( main::@29/(byte*) progress_cursor#63 main::@32/(byte*) progress_cursor#55 ) + (byte) main::angle#11 ← phi( main::@29/(byte) main::angle#2 main::@32/(byte) main::angle#5 ) + (byte) main::i#5 ← phi( main::@29/(byte) main::i#0 main::@32/(byte) main::i#1 ) + (byte**) renderBobCleanupNext#25 ← phi( main::@29/(byte**) renderBobCleanupNext#0 main::@32/(byte**) renderBobCleanupNext#1 ) + (byte) main::a#2 ← phi( main::@29/(byte) main::a#0 main::@32/(byte) main::a#5 ) + (signed byte) main::r#2 ← phi( main::@29/(signed byte) main::r#0 main::@32/(signed byte) main::r#5 ) + *((const byte*) BORDERCOL) ← (number) 1 + (signed byte) mulf8s::a#0 ← (signed byte) main::r#2 + (signed byte) mulf8s::b#0 ← *((const signed byte*) COS + (byte) main::a#2) + call mulf8s + (signed word) mulf8s::return#2 ← (signed word) mulf8s::return#1 + to:main::@30 +main::@30: scope:[main] from main::@6 + (byte) bob_charset_next_id#67 ← phi( main::@6/(byte) bob_charset_next_id#69 ) + (byte) progress_idx#59 ← phi( main::@6/(byte) progress_idx#61 ) + (byte*) progress_cursor#59 ← phi( main::@6/(byte*) progress_cursor#61 ) + (byte) main::angle#9 ← phi( main::@6/(byte) main::angle#11 ) + (byte) main::i#4 ← phi( main::@6/(byte) main::i#5 ) + (byte**) renderBobCleanupNext#21 ← phi( main::@6/(byte**) renderBobCleanupNext#25 ) + (byte) main::a#3 ← phi( main::@6/(byte) main::a#2 ) + (signed byte) main::r#3 ← phi( main::@6/(signed byte) main::r#2 ) + (signed word) mulf8s::return#5 ← phi( main::@6/(signed word) mulf8s::return#2 ) + (signed word~) main::$10 ← (signed word) mulf8s::return#5 + (number~) main::$11 ← (signed word~) main::$10 + (number) $4b*(number) $100 + (signed word) main::x#0 ← (number~) main::$11 + (signed byte) mulf8s::a#1 ← (signed byte) main::r#3 + (signed byte) mulf8s::b#1 ← *((const signed byte*) SIN + (byte) main::a#3) + call mulf8s + (signed word) mulf8s::return#3 ← (signed word) mulf8s::return#1 + to:main::@31 +main::@31: scope:[main] from main::@30 + (byte) bob_charset_next_id#65 ← phi( main::@30/(byte) bob_charset_next_id#67 ) + (byte) progress_idx#57 ← phi( main::@30/(byte) progress_idx#59 ) + (byte*) progress_cursor#57 ← phi( main::@30/(byte*) progress_cursor#59 ) + (byte) main::angle#7 ← phi( main::@30/(byte) main::angle#9 ) + (byte) main::i#3 ← phi( main::@30/(byte) main::i#4 ) + (byte**) renderBobCleanupNext#17 ← phi( main::@30/(byte**) renderBobCleanupNext#21 ) + (signed word) main::x#1 ← phi( main::@30/(signed word) main::x#0 ) + (signed byte) main::r#4 ← phi( main::@30/(signed byte) main::r#3 ) + (byte) main::a#4 ← phi( main::@30/(byte) main::a#3 ) + (signed word) mulf8s::return#6 ← phi( main::@30/(signed word) mulf8s::return#3 ) + (signed word~) main::$12 ← (signed word) mulf8s::return#6 + (number~) main::$13 ← (signed word~) main::$12 * (number) 2 + (number~) main::$14 ← (number~) main::$13 + (number) $5a*(number) $100 + (signed word) main::y#0 ← (number~) main::$14 + *((const byte*) BORDERCOL) ← (number) 2 + (byte) main::a#1 ← (byte) main::a#4 + (number) $62 + (signed byte) main::r#1 ← (signed byte) main::r#4 + (number) 3 + (byte~) main::$15 ← > (signed word) main::x#1 + (byte~) main::$16 ← > (signed word) main::y#0 + (byte) renderBob::xpos#0 ← (byte~) main::$15 + (byte) renderBob::ypos#0 ← (byte~) main::$16 + call renderBob + to:main::@32 +main::@32: scope:[main] from main::@31 + (byte) bob_charset_next_id#63 ← phi( main::@31/(byte) bob_charset_next_id#65 ) + (byte) progress_idx#55 ← phi( main::@31/(byte) progress_idx#57 ) + (byte*) progress_cursor#55 ← phi( main::@31/(byte*) progress_cursor#57 ) + (byte) main::angle#5 ← phi( main::@31/(byte) main::angle#7 ) + (byte) main::a#5 ← phi( main::@31/(byte) main::a#1 ) + (signed byte) main::r#5 ← phi( main::@31/(signed byte) main::r#1 ) + (byte) main::i#2 ← phi( main::@31/(byte) main::i#3 ) + (byte**) renderBobCleanupNext#10 ← phi( main::@31/(byte**) renderBobCleanupNext#5 ) + (byte**) renderBobCleanupNext#1 ← (byte**) renderBobCleanupNext#10 + (byte) main::i#1 ← (byte) main::i#2 + rangenext(0,NUM_BOBS-1) + (bool~) main::$18 ← (byte) main::i#1 != rangelast(0,NUM_BOBS-1) + if((bool~) main::$18) goto main::@6 + to:main::@7 +main::@7: scope:[main] from main::@32 + (byte) bob_charset_next_id#61 ← phi( main::@32/(byte) bob_charset_next_id#63 ) + (byte) progress_idx#53 ← phi( main::@32/(byte) progress_idx#55 ) + (byte*) progress_cursor#53 ← phi( main::@32/(byte*) progress_cursor#55 ) + (byte**) renderBobCleanupNext#32 ← phi( main::@32/(byte**) renderBobCleanupNext#1 ) + (byte) main::angle#3 ← phi( main::@32/(byte) main::angle#5 ) + (byte) main::angle#1 ← (byte) main::angle#3 + (number) 3 + *((const byte*) BORDERCOL) ← (number) 0 + (byte) keyboard_key_pressed::key#0 ← (const byte) KEY_SPACE + call keyboard_key_pressed + (byte) keyboard_key_pressed::return#2 ← (byte) keyboard_key_pressed::return#1 + to:main::@33 +main::@33: scope:[main] from main::@7 + (byte) bob_charset_next_id#59 ← phi( main::@7/(byte) bob_charset_next_id#61 ) + (byte) progress_idx#51 ← phi( main::@7/(byte) progress_idx#53 ) + (byte*) progress_cursor#51 ← phi( main::@7/(byte*) progress_cursor#53 ) + (byte) main::angle#10 ← phi( main::@7/(byte) main::angle#1 ) + (byte**) renderBobCleanupNext#29 ← phi( main::@7/(byte**) renderBobCleanupNext#32 ) + (byte) keyboard_key_pressed::return#5 ← phi( main::@7/(byte) keyboard_key_pressed::return#2 ) + (byte~) main::$19 ← (byte) keyboard_key_pressed::return#5 + (bool~) main::$23 ← (number) 0 != (byte~) main::$19 + (bool~) main::$20 ← ! (bool~) main::$23 + if((bool~) main::$20) goto main::@1 + to:main::@15 +main::@15: scope:[main] from main::@1 main::@33 main::@34 + (byte**) renderBobCleanupNext#45 ← phi( main::@1/(byte**) renderBobCleanupNext#24 main::@33/(byte**) renderBobCleanupNext#29 main::@34/(byte**) renderBobCleanupNext#43 ) + (byte) bob_charset_next_id#57 ← phi( main::@1/(byte) bob_charset_next_id#58 main::@33/(byte) bob_charset_next_id#59 main::@34/(byte) bob_charset_next_id#56 ) + (byte) progress_idx#49 ← phi( main::@1/(byte) progress_idx#50 main::@33/(byte) progress_idx#51 main::@34/(byte) progress_idx#48 ) + (byte*) progress_cursor#49 ← phi( main::@1/(byte*) progress_cursor#50 main::@33/(byte*) progress_cursor#51 main::@34/(byte*) progress_cursor#48 ) + (byte) keyboard_key_pressed::key#1 ← (const byte) KEY_SPACE + call keyboard_key_pressed + (byte) keyboard_key_pressed::return#3 ← (byte) keyboard_key_pressed::return#1 + to:main::@34 +main::@34: scope:[main] from main::@15 + (byte**) renderBobCleanupNext#43 ← phi( main::@15/(byte**) renderBobCleanupNext#45 ) + (byte) bob_charset_next_id#56 ← phi( main::@15/(byte) bob_charset_next_id#57 ) + (byte) progress_idx#48 ← phi( main::@15/(byte) progress_idx#49 ) + (byte*) progress_cursor#48 ← phi( main::@15/(byte*) progress_cursor#49 ) + (byte) keyboard_key_pressed::return#6 ← phi( main::@15/(byte) keyboard_key_pressed::return#3 ) + (byte~) main::$21 ← (byte) keyboard_key_pressed::return#6 + (bool~) main::$22 ← (number) 0 != (byte~) main::$21 + if((bool~) main::$22) goto main::@15 + to:main::@17 +main::@17: scope:[main] from main::@34 + (byte**) renderBobCleanupNext#41 ← phi( main::@34/(byte**) renderBobCleanupNext#43 ) + (byte) bob_charset_next_id#55 ← phi( main::@34/(byte) bob_charset_next_id#56 ) + (byte) progress_idx#47 ← phi( main::@34/(byte) progress_idx#48 ) + (byte*) progress_cursor#47 ← phi( main::@34/(byte*) progress_cursor#48 ) + (byte*) main::vicSelectGfxBank2_gfx#0 ← (const byte*) SCREEN_BASIC + to:main::vicSelectGfxBank2 +main::vicSelectGfxBank2: scope:[main] from main::@17 + (byte**) renderBobCleanupNext#39 ← phi( main::@17/(byte**) renderBobCleanupNext#41 ) + (byte) bob_charset_next_id#54 ← phi( main::@17/(byte) bob_charset_next_id#55 ) + (byte) progress_idx#46 ← phi( main::@17/(byte) progress_idx#47 ) + (byte*) progress_cursor#46 ← phi( main::@17/(byte*) progress_cursor#47 ) + (byte*) main::vicSelectGfxBank2_gfx#1 ← phi( main::@17/(byte*) main::vicSelectGfxBank2_gfx#0 ) + *((const byte*) CIA2_PORT_A_DDR) ← (number) 3 + (byte*) main::vicSelectGfxBank2_toDd001_gfx#0 ← (byte*) main::vicSelectGfxBank2_gfx#1 + to:main::vicSelectGfxBank2_toDd001 +main::vicSelectGfxBank2_toDd001: scope:[main] from main::vicSelectGfxBank2 + (byte**) renderBobCleanupNext#37 ← phi( main::vicSelectGfxBank2/(byte**) renderBobCleanupNext#39 ) + (byte) bob_charset_next_id#52 ← phi( main::vicSelectGfxBank2/(byte) bob_charset_next_id#54 ) + (byte) progress_idx#44 ← phi( main::vicSelectGfxBank2/(byte) progress_idx#46 ) + (byte*) progress_cursor#44 ← phi( main::vicSelectGfxBank2/(byte*) progress_cursor#46 ) + (byte*) main::vicSelectGfxBank2_toDd001_gfx#1 ← phi( main::vicSelectGfxBank2/(byte*) main::vicSelectGfxBank2_toDd001_gfx#0 ) + (word~) main::vicSelectGfxBank2_toDd001_$0 ← ((word)) (byte*) main::vicSelectGfxBank2_toDd001_gfx#1 + (byte~) main::vicSelectGfxBank2_toDd001_$1 ← > (word~) main::vicSelectGfxBank2_toDd001_$0 + (number~) main::vicSelectGfxBank2_toDd001_$2 ← (byte~) main::vicSelectGfxBank2_toDd001_$1 / (number) $40 + (number~) main::vicSelectGfxBank2_toDd001_$3 ← (number) 3 ^ (number~) main::vicSelectGfxBank2_toDd001_$2 + (byte) main::vicSelectGfxBank2_toDd001_return#0 ← (number~) main::vicSelectGfxBank2_toDd001_$3 + to:main::vicSelectGfxBank2_toDd001_@return +main::vicSelectGfxBank2_toDd001_@return: scope:[main] from main::vicSelectGfxBank2_toDd001 + (byte**) renderBobCleanupNext#35 ← phi( main::vicSelectGfxBank2_toDd001/(byte**) renderBobCleanupNext#37 ) + (byte) bob_charset_next_id#50 ← phi( main::vicSelectGfxBank2_toDd001/(byte) bob_charset_next_id#52 ) + (byte) progress_idx#42 ← phi( main::vicSelectGfxBank2_toDd001/(byte) progress_idx#44 ) + (byte*) progress_cursor#42 ← phi( main::vicSelectGfxBank2_toDd001/(byte*) progress_cursor#44 ) + (byte) main::vicSelectGfxBank2_toDd001_return#2 ← phi( main::vicSelectGfxBank2_toDd001/(byte) main::vicSelectGfxBank2_toDd001_return#0 ) + (byte) main::vicSelectGfxBank2_toDd001_return#1 ← (byte) main::vicSelectGfxBank2_toDd001_return#2 + to:main::vicSelectGfxBank2_@1 +main::vicSelectGfxBank2_@1: scope:[main] from main::vicSelectGfxBank2_toDd001_@return + (byte**) renderBobCleanupNext#33 ← phi( main::vicSelectGfxBank2_toDd001_@return/(byte**) renderBobCleanupNext#35 ) + (byte) bob_charset_next_id#47 ← phi( main::vicSelectGfxBank2_toDd001_@return/(byte) bob_charset_next_id#50 ) + (byte) progress_idx#39 ← phi( main::vicSelectGfxBank2_toDd001_@return/(byte) progress_idx#42 ) + (byte*) progress_cursor#39 ← phi( main::vicSelectGfxBank2_toDd001_@return/(byte*) progress_cursor#42 ) + (byte) main::vicSelectGfxBank2_toDd001_return#3 ← phi( main::vicSelectGfxBank2_toDd001_@return/(byte) main::vicSelectGfxBank2_toDd001_return#1 ) + (byte~) main::vicSelectGfxBank2_$0 ← (byte) main::vicSelectGfxBank2_toDd001_return#3 + *((const byte*) CIA2_PORT_A) ← (byte~) main::vicSelectGfxBank2_$0 + to:main::@23 +main::@23: scope:[main] from main::vicSelectGfxBank2_@1 + (byte**) renderBobCleanupNext#30 ← phi( main::vicSelectGfxBank2_@1/(byte**) renderBobCleanupNext#33 ) + (byte) bob_charset_next_id#42 ← phi( main::vicSelectGfxBank2_@1/(byte) bob_charset_next_id#47 ) + (byte) progress_idx#36 ← phi( main::vicSelectGfxBank2_@1/(byte) progress_idx#39 ) + (byte*) progress_cursor#36 ← phi( main::vicSelectGfxBank2_@1/(byte*) progress_cursor#39 ) + (byte*) main::toD0182_screen#0 ← (const byte*) SCREEN_BASIC + (byte*) main::toD0182_gfx#0 ← (const byte*) CHARSET_BASIC + to:main::toD0182 +main::toD0182: scope:[main] from main::@23 + (byte**) renderBobCleanupNext#26 ← phi( main::@23/(byte**) renderBobCleanupNext#30 ) + (byte) bob_charset_next_id#36 ← phi( main::@23/(byte) bob_charset_next_id#42 ) + (byte) progress_idx#33 ← phi( main::@23/(byte) progress_idx#36 ) + (byte*) progress_cursor#33 ← phi( main::@23/(byte*) progress_cursor#36 ) + (byte*) main::toD0182_gfx#1 ← phi( main::@23/(byte*) main::toD0182_gfx#0 ) + (byte*) main::toD0182_screen#1 ← phi( main::@23/(byte*) main::toD0182_screen#0 ) + (word~) main::toD0182_$0 ← ((word)) (byte*) main::toD0182_screen#1 + (number~) main::toD0182_$1 ← (word~) main::toD0182_$0 & (number) $3fff + (number~) main::toD0182_$2 ← (number~) main::toD0182_$1 * (number) 4 + (number~) main::toD0182_$3 ← > (number~) main::toD0182_$2 + (word~) main::toD0182_$4 ← ((word)) (byte*) main::toD0182_gfx#1 + (byte~) main::toD0182_$5 ← > (word~) main::toD0182_$4 + (number~) main::toD0182_$6 ← (byte~) main::toD0182_$5 / (number) 4 + (number~) main::toD0182_$7 ← (number~) main::toD0182_$6 & (number) $f + (number~) main::toD0182_$8 ← (number~) main::toD0182_$3 | (number~) main::toD0182_$7 + (byte) main::toD0182_return#0 ← (number~) main::toD0182_$8 + to:main::toD0182_@return +main::toD0182_@return: scope:[main] from main::toD0182 + (byte**) renderBobCleanupNext#22 ← phi( main::toD0182/(byte**) renderBobCleanupNext#26 ) + (byte) bob_charset_next_id#29 ← phi( main::toD0182/(byte) bob_charset_next_id#36 ) + (byte) progress_idx#29 ← phi( main::toD0182/(byte) progress_idx#33 ) + (byte*) progress_cursor#29 ← phi( main::toD0182/(byte*) progress_cursor#33 ) + (byte) main::toD0182_return#2 ← phi( main::toD0182/(byte) main::toD0182_return#0 ) + (byte) main::toD0182_return#1 ← (byte) main::toD0182_return#2 + to:main::@24 +main::@24: scope:[main] from main::toD0182_@return + (byte**) renderBobCleanupNext#18 ← phi( main::toD0182_@return/(byte**) renderBobCleanupNext#22 ) + (byte) bob_charset_next_id#20 ← phi( main::toD0182_@return/(byte) bob_charset_next_id#29 ) + (byte) progress_idx#23 ← phi( main::toD0182_@return/(byte) progress_idx#29 ) + (byte*) progress_cursor#22 ← phi( main::toD0182_@return/(byte*) progress_cursor#29 ) + (byte) main::toD0182_return#3 ← phi( main::toD0182_@return/(byte) main::toD0182_return#1 ) + (byte~) main::$7 ← (byte) main::toD0182_return#3 + *((const byte*) D018) ← (byte~) main::$7 + to:main::@return +main::@return: scope:[main] from main::@24 + (byte**) renderBobCleanupNext#11 ← phi( main::@24/(byte**) renderBobCleanupNext#18 ) + (byte) bob_charset_next_id#11 ← phi( main::@24/(byte) bob_charset_next_id#20 ) + (byte) progress_idx#13 ← phi( main::@24/(byte) progress_idx#23 ) + (byte*) progress_cursor#12 ← phi( main::@24/(byte*) progress_cursor#22 ) + (byte*) progress_cursor#1 ← (byte*) progress_cursor#12 + (byte) progress_idx#1 ← (byte) progress_idx#13 + (byte) bob_charset_next_id#1 ← (byte) bob_charset_next_id#11 + (byte**) renderBobCleanupNext#2 ← (byte**) renderBobCleanupNext#11 + return + to:@return +@59: scope:[] from @begin + (byte**) renderBobCleanupNext#3 ← (byte**) 0 + to:@65 + +(void()) renderBobInit() +renderBobInit: scope:[renderBobInit] from main::@26 + (byte) renderBobInit::y#0 ← (byte) 0 + to:renderBobInit::@1 +renderBobInit::@1: scope:[renderBobInit] from renderBobInit renderBobInit::@1 + (byte) renderBobInit::y#2 ← phi( renderBobInit/(byte) renderBobInit::y#0 renderBobInit::@1/(byte) renderBobInit::y#1 ) + (word~) renderBobInit::$0 ← ((word)) (byte) renderBobInit::y#2 + (number~) renderBobInit::$1 ← (word~) renderBobInit::$0 * (number) $28 + (byte~) renderBobInit::$4 ← (byte) renderBobInit::y#2 * (const byte) SIZEOF_WORD + *((const word*) MUL40 + (byte~) renderBobInit::$4) ← (number~) renderBobInit::$1 + (byte) renderBobInit::y#1 ← (byte) renderBobInit::y#2 + rangenext(0,$1f) + (bool~) renderBobInit::$2 ← (byte) renderBobInit::y#1 != rangelast(0,$1f) + if((bool~) renderBobInit::$2) goto renderBobInit::@1 + to:renderBobInit::@2 +renderBobInit::@2: scope:[renderBobInit] from renderBobInit::@1 + (byte) renderBobInit::i#0 ← (byte) 0 + to:renderBobInit::@3 +renderBobInit::@3: scope:[renderBobInit] from renderBobInit::@2 renderBobInit::@3 + (byte) renderBobInit::i#2 ← phi( renderBobInit::@2/(byte) renderBobInit::i#0 renderBobInit::@3/(byte) renderBobInit::i#1 ) + (byte~) renderBobInit::$5 ← (byte) renderBobInit::i#2 * (const byte) SIZEOF_POINTER + *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobInit::$5) ← (const byte*) BOB_SCREEN + (byte) renderBobInit::i#1 ← (byte) renderBobInit::i#2 + rangenext(0,NUM_BOBS-1) + (bool~) renderBobInit::$3 ← (byte) renderBobInit::i#1 != rangelast(0,NUM_BOBS-1) + if((bool~) renderBobInit::$3) goto renderBobInit::@3 + to:renderBobInit::@return +renderBobInit::@return: scope:[renderBobInit] from renderBobInit::@3 + return + to:@return + +(void()) renderBob((byte) renderBob::xpos , (byte) renderBob::ypos) +renderBob: scope:[renderBob] from main::@31 + (byte**) renderBobCleanupNext#12 ← phi( main::@31/(byte**) renderBobCleanupNext#17 ) + (byte) renderBob::ypos#1 ← phi( main::@31/(byte) renderBob::ypos#0 ) + (byte) renderBob::xpos#1 ← phi( main::@31/(byte) renderBob::xpos#0 ) + (byte~) renderBob::$0 ← (byte) renderBob::xpos#1 / (const byte) BOB_SHIFTS_X + (byte) renderBob::x_char_offset#0 ← (byte~) renderBob::$0 + (byte~) renderBob::$1 ← (byte) renderBob::ypos#1 / (const byte) BOB_SHIFTS_Y + (byte) renderBob::y_char_offset#0 ← (byte~) renderBob::$1 + (byte~) renderBob::$8 ← (byte) renderBob::y_char_offset#0 * (const byte) SIZEOF_WORD + (word) renderBob::y_offset#0 ← *((const word*) MUL40 + (byte~) renderBob::$8) + (byte*~) renderBob::$2 ← (const byte*) BOB_SCREEN + (word) renderBob::y_offset#0 + (byte*~) renderBob::$3 ← (byte*~) renderBob::$2 + (byte) renderBob::x_char_offset#0 + (byte*) renderBob::screen#0 ← (byte*~) renderBob::$3 + (number~) renderBob::$4 ← (byte) renderBob::ypos#1 & (number) 7 + (number~) renderBob::$5 ← (number~) renderBob::$4 * (const byte) BOB_SHIFTS_X + (number~) renderBob::$6 ← (byte) renderBob::xpos#1 & (number) 3 + (number~) renderBob::$7 ← (number~) renderBob::$5 + (number~) renderBob::$6 + (byte) renderBob::bob_table_idx#0 ← (number~) renderBob::$7 + *((byte**) renderBobCleanupNext#12) ← (byte*) renderBob::screen#0 + (byte**) renderBobCleanupNext#4 ← (byte**) renderBobCleanupNext#12 + (const byte) SIZEOF_POINTER + *((byte*) renderBob::screen#0 + (number) 0) ← *((const byte*) BOB_TABLES+(number) 0*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + *((byte*) renderBob::screen#0 + (number) $28) ← *((const byte*) BOB_TABLES+(number) 1*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + *((byte*) renderBob::screen#0 + (number) $50) ← *((const byte*) BOB_TABLES+(number) 2*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + *((byte*) renderBob::screen#0 + (number) 1) ← *((const byte*) BOB_TABLES+(number) 3*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + *((byte*) renderBob::screen#0 + (number) $29) ← *((const byte*) BOB_TABLES+(number) 4*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + *((byte*) renderBob::screen#0 + (number) $51) ← *((const byte*) BOB_TABLES+(number) 5*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + *((byte*) renderBob::screen#0 + (number) 2) ← *((const byte*) BOB_TABLES+(number) 6*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + *((byte*) renderBob::screen#0 + (number) $2a) ← *((const byte*) BOB_TABLES+(number) 7*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + *((byte*) renderBob::screen#0 + (number) $52) ← *((const byte*) BOB_TABLES+(number) 8*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + to:renderBob::@return +renderBob::@return: scope:[renderBob] from renderBob + (byte**) renderBobCleanupNext#13 ← phi( renderBob/(byte**) renderBobCleanupNext#4 ) + (byte**) renderBobCleanupNext#5 ← (byte**) renderBobCleanupNext#13 + return + to:@return + +(void()) renderBobCleanup() +renderBobCleanup: scope:[renderBobCleanup] from main::@5 + (byte) renderBobCleanup::i#0 ← (byte) 0 + to:renderBobCleanup::@1 +renderBobCleanup::@1: scope:[renderBobCleanup] from renderBobCleanup renderBobCleanup::@1 + (byte) renderBobCleanup::i#2 ← phi( renderBobCleanup/(byte) renderBobCleanup::i#0 renderBobCleanup::@1/(byte) renderBobCleanup::i#1 ) + (byte~) renderBobCleanup::$1 ← (byte) renderBobCleanup::i#2 * (const byte) SIZEOF_POINTER + (byte*) renderBobCleanup::screen#0 ← *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobCleanup::$1) + *((byte*) renderBobCleanup::screen#0 + (number) 0) ← (number) 0 + *((byte*) renderBobCleanup::screen#0 + (number) $28) ← (number) 0 + *((byte*) renderBobCleanup::screen#0 + (number) $50) ← (number) 0 + *((byte*) renderBobCleanup::screen#0 + (number) 1) ← (number) 0 + *((byte*) renderBobCleanup::screen#0 + (number) $29) ← (number) 0 + *((byte*) renderBobCleanup::screen#0 + (number) $51) ← (number) 0 + *((byte*) renderBobCleanup::screen#0 + (number) 2) ← (number) 0 + *((byte*) renderBobCleanup::screen#0 + (number) $2a) ← (number) 0 + *((byte*) renderBobCleanup::screen#0 + (number) $52) ← (number) 0 + (byte) renderBobCleanup::i#1 ← (byte) renderBobCleanup::i#2 + rangenext(0,NUM_BOBS-1) + (bool~) renderBobCleanup::$0 ← (byte) renderBobCleanup::i#1 != rangelast(0,NUM_BOBS-1) + if((bool~) renderBobCleanup::$0) goto renderBobCleanup::@1 + to:renderBobCleanup::@2 +renderBobCleanup::@2: scope:[renderBobCleanup] from renderBobCleanup::@1 + (byte**) renderBobCleanupNext#6 ← (const byte**) RENDERBOB_CLEANUP + to:renderBobCleanup::@return +renderBobCleanup::@return: scope:[renderBobCleanup] from renderBobCleanup::@2 + (byte**) renderBobCleanupNext#14 ← phi( renderBobCleanup::@2/(byte**) renderBobCleanupNext#6 ) + (byte**) renderBobCleanupNext#7 ← (byte**) renderBobCleanupNext#14 + return + to:@return + +(void()) prepareBobs() +prepareBobs: scope:[prepareBobs] from main::@25 + (byte) progress_idx#24 ← phi( main::@25/(byte) progress_idx#22 ) + (byte*) progress_cursor#23 ← phi( main::@25/(byte*) progress_cursor#21 ) + (byte*) progress_init::line#0 ← (const byte*) SCREEN_BASIC + call progress_init + to:prepareBobs::@19 +prepareBobs::@19: scope:[prepareBobs] from prepareBobs + (byte) progress_idx#14 ← phi( prepareBobs/(byte) progress_idx#7 ) + (byte*) progress_cursor#13 ← phi( prepareBobs/(byte*) progress_cursor#7 ) + (byte*) progress_cursor#2 ← (byte*) progress_cursor#13 + (byte) progress_idx#2 ← (byte) progress_idx#14 + (byte) bob_charset_next_id#2 ← (number) 0 + (byte*) charsetFindOrAddGlyph::glyph#0 ← (const byte*) PROTO_BOB+(number) $30 + (byte*) charsetFindOrAddGlyph::charset#0 ← (const byte*) BOB_CHARSET + call charsetFindOrAddGlyph + (byte) charsetFindOrAddGlyph::return#0 ← (byte) charsetFindOrAddGlyph::return#3 + to:prepareBobs::@20 +prepareBobs::@20: scope:[prepareBobs] from prepareBobs::@19 + (byte) progress_idx#30 ← phi( prepareBobs::@19/(byte) progress_idx#2 ) + (byte*) progress_cursor#30 ← phi( prepareBobs::@19/(byte*) progress_cursor#2 ) + (byte) bob_charset_next_id#12 ← phi( prepareBobs::@19/(byte) bob_charset_next_id#7 ) + (byte) bob_charset_next_id#3 ← (byte) bob_charset_next_id#12 + (byte) prepareBobs::bob_table_idx#0 ← (number) 0 + (byte) prepareBobs::shift_y#0 ← (number) 0 + to:prepareBobs::@1 +prepareBobs::@1: scope:[prepareBobs] from prepareBobs::@20 prepareBobs::@21 + (byte) prepareBobs::bob_table_idx#9 ← phi( prepareBobs::@20/(byte) prepareBobs::bob_table_idx#0 prepareBobs::@21/(byte) prepareBobs::bob_table_idx#12 ) + (byte) bob_charset_next_id#22 ← phi( prepareBobs::@20/(byte) bob_charset_next_id#3 prepareBobs::@21/(byte) bob_charset_next_id#30 ) + (byte) progress_idx#26 ← phi( prepareBobs::@20/(byte) progress_idx#30 prepareBobs::@21/(byte) progress_idx#31 ) + (byte*) progress_cursor#25 ← phi( prepareBobs::@20/(byte*) progress_cursor#30 prepareBobs::@21/(byte*) progress_cursor#31 ) + (byte) prepareBobs::shift_y#2 ← phi( prepareBobs::@20/(byte) prepareBobs::shift_y#0 prepareBobs::@21/(byte) prepareBobs::shift_y#1 ) + (bool~) prepareBobs::$2 ← (byte) prepareBobs::shift_y#2 < (const byte) BOB_SHIFTS_Y + if((bool~) prepareBobs::$2) goto prepareBobs::@2 + to:prepareBobs::@return +prepareBobs::@2: scope:[prepareBobs] from prepareBobs::@1 + (byte) progress_idx#40 ← phi( prepareBobs::@1/(byte) progress_idx#26 ) + (byte*) progress_cursor#40 ← phi( prepareBobs::@1/(byte*) progress_cursor#25 ) + (byte) bob_charset_next_id#48 ← phi( prepareBobs::@1/(byte) bob_charset_next_id#22 ) + (byte) prepareBobs::shift_y#6 ← phi( prepareBobs::@1/(byte) prepareBobs::shift_y#2 ) + (byte) prepareBobs::bob_table_idx#6 ← phi( prepareBobs::@1/(byte) prepareBobs::bob_table_idx#9 ) + (byte) prepareBobs::shift_x#0 ← (number) 0 + to:prepareBobs::@4 +prepareBobs::@4: scope:[prepareBobs] from prepareBobs::@2 prepareBobs::@25 + (byte) progress_idx#37 ← phi( prepareBobs::@2/(byte) progress_idx#40 prepareBobs::@25/(byte) progress_idx#41 ) + (byte*) progress_cursor#37 ← phi( prepareBobs::@2/(byte*) progress_cursor#40 prepareBobs::@25/(byte*) progress_cursor#41 ) + (byte) bob_charset_next_id#43 ← phi( prepareBobs::@2/(byte) bob_charset_next_id#48 prepareBobs::@25/(byte) bob_charset_next_id#49 ) + (byte) prepareBobs::shift_y#5 ← phi( prepareBobs::@2/(byte) prepareBobs::shift_y#6 prepareBobs::@25/(byte) prepareBobs::shift_y#7 ) + (byte) prepareBobs::bob_table_idx#4 ← phi( prepareBobs::@2/(byte) prepareBobs::bob_table_idx#6 prepareBobs::@25/(byte) prepareBobs::bob_table_idx#7 ) + (byte) prepareBobs::shift_x#2 ← phi( prepareBobs::@2/(byte) prepareBobs::shift_x#0 prepareBobs::@25/(byte) prepareBobs::shift_x#1 ) + (bool~) prepareBobs::$3 ← (byte) prepareBobs::shift_x#2 < (const byte) BOB_SHIFTS_X + if((bool~) prepareBobs::$3) goto prepareBobs::@5 + to:prepareBobs::@6 +prepareBobs::@5: scope:[prepareBobs] from prepareBobs::@4 + (byte) prepareBobs::shift_y#12 ← phi( prepareBobs::@4/(byte) prepareBobs::shift_y#5 ) + (byte) prepareBobs::shift_x#8 ← phi( prepareBobs::@4/(byte) prepareBobs::shift_x#2 ) + (byte*) progress_cursor#38 ← phi( prepareBobs::@4/(byte*) progress_cursor#37 ) + (byte) progress_idx#38 ← phi( prepareBobs::@4/(byte) progress_idx#37 ) + (byte) bob_charset_next_id#39 ← phi( prepareBobs::@4/(byte) bob_charset_next_id#43 ) + (byte) prepareBobs::bob_table_idx#2 ← phi( prepareBobs::@4/(byte) prepareBobs::bob_table_idx#4 ) + (byte*) prepareBobs::bob_glyph#0 ← (const byte*) PROTO_BOB + (byte*~) prepareBobs::$4 ← (const byte*) BOB_TABLES + (byte) prepareBobs::bob_table_idx#2 + (byte*) prepareBobs::bob_table#0 ← (byte*~) prepareBobs::$4 + (byte) prepareBobs::cell#0 ← (number) 0 + to:prepareBobs::@7 +prepareBobs::@6: scope:[prepareBobs] from prepareBobs::@4 + (byte) prepareBobs::bob_table_idx#14 ← phi( prepareBobs::@4/(byte) prepareBobs::bob_table_idx#4 ) + (byte) bob_charset_next_id#37 ← phi( prepareBobs::@4/(byte) bob_charset_next_id#43 ) + (byte) progress_idx#34 ← phi( prepareBobs::@4/(byte) progress_idx#37 ) + (byte*) progress_cursor#34 ← phi( prepareBobs::@4/(byte*) progress_cursor#37 ) + (byte) prepareBobs::shift_y#4 ← phi( prepareBobs::@4/(byte) prepareBobs::shift_y#5 ) + call protoBobShiftDown + to:prepareBobs::@21 +prepareBobs::@21: scope:[prepareBobs] from prepareBobs::@6 + (byte) prepareBobs::bob_table_idx#12 ← phi( prepareBobs::@6/(byte) prepareBobs::bob_table_idx#14 ) + (byte) bob_charset_next_id#30 ← phi( prepareBobs::@6/(byte) bob_charset_next_id#37 ) + (byte) progress_idx#31 ← phi( prepareBobs::@6/(byte) progress_idx#34 ) + (byte*) progress_cursor#31 ← phi( prepareBobs::@6/(byte*) progress_cursor#34 ) + (byte) prepareBobs::shift_y#3 ← phi( prepareBobs::@6/(byte) prepareBobs::shift_y#4 ) + (byte) prepareBobs::shift_y#1 ← ++ (byte) prepareBobs::shift_y#3 + to:prepareBobs::@1 +prepareBobs::@7: scope:[prepareBobs] from prepareBobs::@23 prepareBobs::@5 + (byte) prepareBobs::shift_y#10 ← phi( prepareBobs::@23/(byte) prepareBobs::shift_y#11 prepareBobs::@5/(byte) prepareBobs::shift_y#12 ) + (byte) prepareBobs::shift_x#6 ← phi( prepareBobs::@23/(byte) prepareBobs::shift_x#7 prepareBobs::@5/(byte) prepareBobs::shift_x#8 ) + (byte*) progress_cursor#35 ← phi( prepareBobs::@23/(byte*) progress_cursor#3 prepareBobs::@5/(byte*) progress_cursor#38 ) + (byte) progress_idx#35 ← phi( prepareBobs::@23/(byte) progress_idx#3 prepareBobs::@5/(byte) progress_idx#38 ) + (byte*) prepareBobs::bob_table#4 ← phi( prepareBobs::@23/(byte*) prepareBobs::bob_table#5 prepareBobs::@5/(byte*) prepareBobs::bob_table#0 ) + (byte) bob_charset_next_id#31 ← phi( prepareBobs::@23/(byte) bob_charset_next_id#38 prepareBobs::@5/(byte) bob_charset_next_id#39 ) + (byte) prepareBobs::bob_table_idx#5 ← phi( prepareBobs::@23/(byte) prepareBobs::bob_table_idx#8 prepareBobs::@5/(byte) prepareBobs::bob_table_idx#2 ) + (byte*) prepareBobs::bob_glyph#4 ← phi( prepareBobs::@23/(byte*) prepareBobs::bob_glyph#5 prepareBobs::@5/(byte*) prepareBobs::bob_glyph#0 ) + (byte) prepareBobs::cell#2 ← phi( prepareBobs::@23/(byte) prepareBobs::cell#1 prepareBobs::@5/(byte) prepareBobs::cell#0 ) + (bool~) prepareBobs::$5 ← (byte) prepareBobs::cell#2 < (number) 9 + if((bool~) prepareBobs::$5) goto prepareBobs::@8 + to:prepareBobs::@9 +prepareBobs::@8: scope:[prepareBobs] from prepareBobs::@7 + (byte) prepareBobs::shift_y#14 ← phi( prepareBobs::@7/(byte) prepareBobs::shift_y#10 ) + (byte) prepareBobs::shift_x#10 ← phi( prepareBobs::@7/(byte) prepareBobs::shift_x#6 ) + (byte) prepareBobs::bob_table_idx#13 ← phi( prepareBobs::@7/(byte) prepareBobs::bob_table_idx#5 ) + (byte) prepareBobs::cell#5 ← phi( prepareBobs::@7/(byte) prepareBobs::cell#2 ) + (byte*) progress_cursor#32 ← phi( prepareBobs::@7/(byte*) progress_cursor#35 ) + (byte) progress_idx#32 ← phi( prepareBobs::@7/(byte) progress_idx#35 ) + (byte*) prepareBobs::bob_table#3 ← phi( prepareBobs::@7/(byte*) prepareBobs::bob_table#4 ) + (byte) bob_charset_next_id#21 ← phi( prepareBobs::@7/(byte) bob_charset_next_id#31 ) + (byte*) prepareBobs::bob_glyph#2 ← phi( prepareBobs::@7/(byte*) prepareBobs::bob_glyph#4 ) + (byte*) charsetFindOrAddGlyph::glyph#1 ← (byte*) prepareBobs::bob_glyph#2 + (byte*) charsetFindOrAddGlyph::charset#1 ← (const byte*) BOB_CHARSET + call charsetFindOrAddGlyph + (byte) charsetFindOrAddGlyph::return#1 ← (byte) charsetFindOrAddGlyph::return#3 + to:prepareBobs::@22 +prepareBobs::@22: scope:[prepareBobs] from prepareBobs::@8 + (byte) prepareBobs::shift_y#13 ← phi( prepareBobs::@8/(byte) prepareBobs::shift_y#14 ) + (byte) prepareBobs::shift_x#9 ← phi( prepareBobs::@8/(byte) prepareBobs::shift_x#10 ) + (byte) prepareBobs::bob_table_idx#10 ← phi( prepareBobs::@8/(byte) prepareBobs::bob_table_idx#13 ) + (byte) prepareBobs::cell#4 ← phi( prepareBobs::@8/(byte) prepareBobs::cell#5 ) + (byte*) progress_cursor#24 ← phi( prepareBobs::@8/(byte*) progress_cursor#32 ) + (byte) progress_idx#25 ← phi( prepareBobs::@8/(byte) progress_idx#32 ) + (byte*) prepareBobs::bob_glyph#3 ← phi( prepareBobs::@8/(byte*) prepareBobs::bob_glyph#2 ) + (byte*) prepareBobs::bob_table#2 ← phi( prepareBobs::@8/(byte*) prepareBobs::bob_table#3 ) + (byte) bob_charset_next_id#13 ← phi( prepareBobs::@8/(byte) bob_charset_next_id#7 ) + (byte) charsetFindOrAddGlyph::return#5 ← phi( prepareBobs::@8/(byte) charsetFindOrAddGlyph::return#1 ) + (byte~) prepareBobs::$6 ← (byte) charsetFindOrAddGlyph::return#5 + (byte) bob_charset_next_id#4 ← (byte) bob_charset_next_id#13 + *((byte*) prepareBobs::bob_table#2) ← (byte~) prepareBobs::$6 + (byte*) prepareBobs::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#3 + (number) 8 + (byte*) prepareBobs::bob_table#1 ← (byte*) prepareBobs::bob_table#2 + (const byte) BOB_SHIFTS_X*(const byte) BOB_SHIFTS_Y + call progress_inc + to:prepareBobs::@23 +prepareBobs::@23: scope:[prepareBobs] from prepareBobs::@22 + (byte) prepareBobs::shift_y#11 ← phi( prepareBobs::@22/(byte) prepareBobs::shift_y#13 ) + (byte) prepareBobs::shift_x#7 ← phi( prepareBobs::@22/(byte) prepareBobs::shift_x#9 ) + (byte*) prepareBobs::bob_table#5 ← phi( prepareBobs::@22/(byte*) prepareBobs::bob_table#1 ) + (byte) bob_charset_next_id#38 ← phi( prepareBobs::@22/(byte) bob_charset_next_id#4 ) + (byte) prepareBobs::bob_table_idx#8 ← phi( prepareBobs::@22/(byte) prepareBobs::bob_table_idx#10 ) + (byte*) prepareBobs::bob_glyph#5 ← phi( prepareBobs::@22/(byte*) prepareBobs::bob_glyph#1 ) + (byte) prepareBobs::cell#3 ← phi( prepareBobs::@22/(byte) prepareBobs::cell#4 ) + (byte*) progress_cursor#14 ← phi( prepareBobs::@22/(byte*) progress_cursor#9 ) + (byte) progress_idx#15 ← phi( prepareBobs::@22/(byte) progress_idx#10 ) + (byte) progress_idx#3 ← (byte) progress_idx#15 + (byte*) progress_cursor#3 ← (byte*) progress_cursor#14 + (byte) prepareBobs::cell#1 ← ++ (byte) prepareBobs::cell#3 + to:prepareBobs::@7 +prepareBobs::@9: scope:[prepareBobs] from prepareBobs::@7 + (byte) progress_idx#45 ← phi( prepareBobs::@7/(byte) progress_idx#35 ) + (byte*) progress_cursor#45 ← phi( prepareBobs::@7/(byte*) progress_cursor#35 ) + (byte) bob_charset_next_id#53 ← phi( prepareBobs::@7/(byte) bob_charset_next_id#31 ) + (byte) prepareBobs::shift_y#9 ← phi( prepareBobs::@7/(byte) prepareBobs::shift_y#10 ) + (byte) prepareBobs::shift_x#5 ← phi( prepareBobs::@7/(byte) prepareBobs::shift_x#6 ) + (byte) prepareBobs::bob_table_idx#3 ← phi( prepareBobs::@7/(byte) prepareBobs::bob_table_idx#5 ) + (byte) prepareBobs::bob_table_idx#1 ← ++ (byte) prepareBobs::bob_table_idx#3 + call protoBobShiftRight + to:prepareBobs::@24 +prepareBobs::@24: scope:[prepareBobs] from prepareBobs::@9 + (byte) progress_idx#43 ← phi( prepareBobs::@9/(byte) progress_idx#45 ) + (byte*) progress_cursor#43 ← phi( prepareBobs::@9/(byte*) progress_cursor#45 ) + (byte) bob_charset_next_id#51 ← phi( prepareBobs::@9/(byte) bob_charset_next_id#53 ) + (byte) prepareBobs::shift_y#8 ← phi( prepareBobs::@9/(byte) prepareBobs::shift_y#9 ) + (byte) prepareBobs::bob_table_idx#11 ← phi( prepareBobs::@9/(byte) prepareBobs::bob_table_idx#1 ) + (byte) prepareBobs::shift_x#4 ← phi( prepareBobs::@9/(byte) prepareBobs::shift_x#5 ) + call protoBobShiftRight + to:prepareBobs::@25 +prepareBobs::@25: scope:[prepareBobs] from prepareBobs::@24 + (byte) progress_idx#41 ← phi( prepareBobs::@24/(byte) progress_idx#43 ) + (byte*) progress_cursor#41 ← phi( prepareBobs::@24/(byte*) progress_cursor#43 ) + (byte) bob_charset_next_id#49 ← phi( prepareBobs::@24/(byte) bob_charset_next_id#51 ) + (byte) prepareBobs::shift_y#7 ← phi( prepareBobs::@24/(byte) prepareBobs::shift_y#8 ) + (byte) prepareBobs::bob_table_idx#7 ← phi( prepareBobs::@24/(byte) prepareBobs::bob_table_idx#11 ) + (byte) prepareBobs::shift_x#3 ← phi( prepareBobs::@24/(byte) prepareBobs::shift_x#4 ) + (byte) prepareBobs::shift_x#1 ← ++ (byte) prepareBobs::shift_x#3 + to:prepareBobs::@4 +prepareBobs::@return: scope:[prepareBobs] from prepareBobs::@1 + (byte) bob_charset_next_id#14 ← phi( prepareBobs::@1/(byte) bob_charset_next_id#22 ) + (byte) progress_idx#16 ← phi( prepareBobs::@1/(byte) progress_idx#26 ) + (byte*) progress_cursor#15 ← phi( prepareBobs::@1/(byte*) progress_cursor#25 ) + (byte*) progress_cursor#4 ← (byte*) progress_cursor#15 + (byte) progress_idx#4 ← (byte) progress_idx#16 + (byte) bob_charset_next_id#5 ← (byte) bob_charset_next_id#14 + return + to:@return + +(void()) protoBobShiftRight() +protoBobShiftRight: scope:[protoBobShiftRight] from prepareBobs::@24 prepareBobs::@9 + (byte) protoBobShiftRight::carry#0 ← (number) 0 + (byte) protoBobShiftRight::j#0 ← (number) 0 + (byte) protoBobShiftRight::i#0 ← (number) 0 + to:protoBobShiftRight::@1 +protoBobShiftRight::@1: scope:[protoBobShiftRight] from protoBobShiftRight protoBobShiftRight::@8 + (byte) protoBobShiftRight::carry#6 ← phi( protoBobShiftRight/(byte) protoBobShiftRight::carry#0 protoBobShiftRight::@8/(byte) protoBobShiftRight::carry#7 ) + (byte) protoBobShiftRight::j#7 ← phi( protoBobShiftRight/(byte) protoBobShiftRight::j#0 protoBobShiftRight::@8/(byte) protoBobShiftRight::j#10 ) + (byte) protoBobShiftRight::i#2 ← phi( protoBobShiftRight/(byte) protoBobShiftRight::i#0 protoBobShiftRight::@8/(byte) protoBobShiftRight::i#1 ) + (bool~) protoBobShiftRight::$0 ← (byte) protoBobShiftRight::i#2 < (number) 3*(number) 3*(number) 8 + if((bool~) protoBobShiftRight::$0) goto protoBobShiftRight::@2 + to:protoBobShiftRight::@return +protoBobShiftRight::@2: scope:[protoBobShiftRight] from protoBobShiftRight::@1 + (byte) protoBobShiftRight::i#9 ← phi( protoBobShiftRight::@1/(byte) protoBobShiftRight::i#2 ) + (byte) protoBobShiftRight::carry#5 ← phi( protoBobShiftRight::@1/(byte) protoBobShiftRight::carry#6 ) + (byte) protoBobShiftRight::j#3 ← phi( protoBobShiftRight::@1/(byte) protoBobShiftRight::j#7 ) + (number~) protoBobShiftRight::$1 ← *((const byte*) PROTO_BOB + (byte) protoBobShiftRight::j#3) & (number) 1 + (bool~) protoBobShiftRight::$8 ← (number) 0 != (number~) protoBobShiftRight::$1 + if((bool~) protoBobShiftRight::$8) goto protoBobShiftRight::@4 + to:protoBobShiftRight::@5 +protoBobShiftRight::@4: scope:[protoBobShiftRight] from protoBobShiftRight::@2 + (byte) protoBobShiftRight::i#7 ← phi( protoBobShiftRight::@2/(byte) protoBobShiftRight::i#9 ) + (byte) protoBobShiftRight::carry#3 ← phi( protoBobShiftRight::@2/(byte) protoBobShiftRight::carry#5 ) + (byte) protoBobShiftRight::j#8 ← phi( protoBobShiftRight::@2/(byte) protoBobShiftRight::j#3 ) + (byte~) protoBobShiftRight::$3 ← (byte) $80 + to:protoBobShiftRight::@6 +protoBobShiftRight::@5: scope:[protoBobShiftRight] from protoBobShiftRight::@2 + (byte) protoBobShiftRight::i#8 ← phi( protoBobShiftRight::@2/(byte) protoBobShiftRight::i#9 ) + (byte) protoBobShiftRight::carry#4 ← phi( protoBobShiftRight::@2/(byte) protoBobShiftRight::carry#5 ) + (byte) protoBobShiftRight::j#9 ← phi( protoBobShiftRight::@2/(byte) protoBobShiftRight::j#3 ) + (byte~) protoBobShiftRight::$2 ← (byte) 0 + to:protoBobShiftRight::@6 +protoBobShiftRight::@6: scope:[protoBobShiftRight] from protoBobShiftRight::@4 protoBobShiftRight::@5 + (byte) protoBobShiftRight::i#6 ← phi( protoBobShiftRight::@4/(byte) protoBobShiftRight::i#7 protoBobShiftRight::@5/(byte) protoBobShiftRight::i#8 ) + (byte) protoBobShiftRight::carry#2 ← phi( protoBobShiftRight::@4/(byte) protoBobShiftRight::carry#3 protoBobShiftRight::@5/(byte) protoBobShiftRight::carry#4 ) + (byte) protoBobShiftRight::j#4 ← phi( protoBobShiftRight::@4/(byte) protoBobShiftRight::j#8 protoBobShiftRight::@5/(byte) protoBobShiftRight::j#9 ) + (byte~) protoBobShiftRight::$4 ← phi( protoBobShiftRight::@4/(byte~) protoBobShiftRight::$3 protoBobShiftRight::@5/(byte~) protoBobShiftRight::$2 ) + (byte) protoBobShiftRight::new_carry#0 ← (byte~) protoBobShiftRight::$4 + (byte~) protoBobShiftRight::$5 ← *((const byte*) PROTO_BOB + (byte) protoBobShiftRight::j#4) >> (number) 1 + (byte~) protoBobShiftRight::$6 ← (byte) protoBobShiftRight::carry#2 | (byte~) protoBobShiftRight::$5 + *((const byte*) PROTO_BOB + (byte) protoBobShiftRight::j#4) ← (byte~) protoBobShiftRight::$6 + (byte) protoBobShiftRight::carry#1 ← (byte) protoBobShiftRight::new_carry#0 + (bool~) protoBobShiftRight::$7 ← (byte) protoBobShiftRight::j#4 >= (number) $30 + if((bool~) protoBobShiftRight::$7) goto protoBobShiftRight::@7 + to:protoBobShiftRight::@13 +protoBobShiftRight::@7: scope:[protoBobShiftRight] from protoBobShiftRight::@6 + (byte) protoBobShiftRight::carry#9 ← phi( protoBobShiftRight::@6/(byte) protoBobShiftRight::carry#1 ) + (byte) protoBobShiftRight::i#5 ← phi( protoBobShiftRight::@6/(byte) protoBobShiftRight::i#6 ) + (byte) protoBobShiftRight::j#5 ← phi( protoBobShiftRight::@6/(byte) protoBobShiftRight::j#4 ) + (byte) protoBobShiftRight::j#1 ← (byte) protoBobShiftRight::j#5 - (number) $2f + to:protoBobShiftRight::@8 +protoBobShiftRight::@13: scope:[protoBobShiftRight] from protoBobShiftRight::@6 + (byte) protoBobShiftRight::carry#8 ← phi( protoBobShiftRight::@6/(byte) protoBobShiftRight::carry#1 ) + (byte) protoBobShiftRight::i#4 ← phi( protoBobShiftRight::@6/(byte) protoBobShiftRight::i#6 ) + (byte) protoBobShiftRight::j#6 ← phi( protoBobShiftRight::@6/(byte) protoBobShiftRight::j#4 ) + (byte) protoBobShiftRight::j#2 ← (byte) protoBobShiftRight::j#6 + (number) $18 + to:protoBobShiftRight::@8 +protoBobShiftRight::@8: scope:[protoBobShiftRight] from protoBobShiftRight::@13 protoBobShiftRight::@7 + (byte) protoBobShiftRight::carry#7 ← phi( protoBobShiftRight::@13/(byte) protoBobShiftRight::carry#8 protoBobShiftRight::@7/(byte) protoBobShiftRight::carry#9 ) + (byte) protoBobShiftRight::j#10 ← phi( protoBobShiftRight::@13/(byte) protoBobShiftRight::j#2 protoBobShiftRight::@7/(byte) protoBobShiftRight::j#1 ) + (byte) protoBobShiftRight::i#3 ← phi( protoBobShiftRight::@13/(byte) protoBobShiftRight::i#4 protoBobShiftRight::@7/(byte) protoBobShiftRight::i#5 ) + (byte) protoBobShiftRight::i#1 ← ++ (byte) protoBobShiftRight::i#3 + to:protoBobShiftRight::@1 +protoBobShiftRight::@return: scope:[protoBobShiftRight] from protoBobShiftRight::@1 + return + to:@return + +(void()) protoBobShiftDown() +protoBobShiftDown: scope:[protoBobShiftDown] from prepareBobs::@6 + (byte) protoBobShiftDown::i#0 ← (number) $17 + to:protoBobShiftDown::@1 +protoBobShiftDown::@1: scope:[protoBobShiftDown] from protoBobShiftDown protoBobShiftDown::@2 + (byte) protoBobShiftDown::i#2 ← phi( protoBobShiftDown/(byte) protoBobShiftDown::i#0 protoBobShiftDown::@2/(byte) protoBobShiftDown::i#1 ) + (bool~) protoBobShiftDown::$0 ← (byte) protoBobShiftDown::i#2 > (number) 0 + if((bool~) protoBobShiftDown::$0) goto protoBobShiftDown::@2 + to:protoBobShiftDown::@3 +protoBobShiftDown::@2: scope:[protoBobShiftDown] from protoBobShiftDown::@1 + (byte) protoBobShiftDown::i#3 ← phi( protoBobShiftDown::@1/(byte) protoBobShiftDown::i#2 ) + *((const byte*) PROTO_BOB + (byte) protoBobShiftDown::i#3) ← *((const byte*) PROTO_BOB+(number) $17 + (byte) protoBobShiftDown::i#3) + *((const byte*) PROTO_BOB+(number) $18 + (byte) protoBobShiftDown::i#3) ← *((const byte*) PROTO_BOB+(number) $2f + (byte) protoBobShiftDown::i#3) + *((const byte*) PROTO_BOB+(number) $30 + (byte) protoBobShiftDown::i#3) ← (number) 0 + (byte) protoBobShiftDown::i#1 ← -- (byte) protoBobShiftDown::i#3 + to:protoBobShiftDown::@1 +protoBobShiftDown::@3: scope:[protoBobShiftDown] from protoBobShiftDown::@1 + *((const byte*) PROTO_BOB + (number) 0) ← (number) 0 + *((const byte*) PROTO_BOB + (number) $18) ← (number) 0 + *((const byte*) PROTO_BOB + (number) $30) ← (number) 0 + to:protoBobShiftDown::@return +protoBobShiftDown::@return: scope:[protoBobShiftDown] from protoBobShiftDown::@3 + return + to:@return +@65: scope:[] from @59 + (byte**) renderBobCleanupNext#27 ← phi( @59/(byte**) renderBobCleanupNext#3 ) + (byte) bob_charset_next_id#6 ← (byte) 0 + to:@66 + +(byte()) charsetFindOrAddGlyph((byte*) charsetFindOrAddGlyph::glyph , (byte*) charsetFindOrAddGlyph::charset) +charsetFindOrAddGlyph: scope:[charsetFindOrAddGlyph] from prepareBobs::@19 prepareBobs::@8 + (byte*) charsetFindOrAddGlyph::glyph#10 ← phi( prepareBobs::@19/(byte*) charsetFindOrAddGlyph::glyph#0 prepareBobs::@8/(byte*) charsetFindOrAddGlyph::glyph#1 ) + (byte) bob_charset_next_id#23 ← phi( prepareBobs::@19/(byte) bob_charset_next_id#2 prepareBobs::@8/(byte) bob_charset_next_id#21 ) + (byte*) charsetFindOrAddGlyph::charset#2 ← phi( prepareBobs::@19/(byte*) charsetFindOrAddGlyph::charset#0 prepareBobs::@8/(byte*) charsetFindOrAddGlyph::charset#1 ) + (byte*) charsetFindOrAddGlyph::glyph_cursor#0 ← (byte*) charsetFindOrAddGlyph::charset#2 + (byte) charsetFindOrAddGlyph::glyph_id#0 ← (number) 0 + to:charsetFindOrAddGlyph::@1 +charsetFindOrAddGlyph::@1: scope:[charsetFindOrAddGlyph] from charsetFindOrAddGlyph charsetFindOrAddGlyph::@16 + (byte*) charsetFindOrAddGlyph::glyph#9 ← phi( charsetFindOrAddGlyph/(byte*) charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::@16/(byte*) charsetFindOrAddGlyph::glyph#11 ) + (byte*) charsetFindOrAddGlyph::glyph_cursor#12 ← phi( charsetFindOrAddGlyph/(byte*) charsetFindOrAddGlyph::glyph_cursor#0 charsetFindOrAddGlyph::@16/(byte*) charsetFindOrAddGlyph::glyph_cursor#1 ) + (byte) bob_charset_next_id#15 ← phi( charsetFindOrAddGlyph/(byte) bob_charset_next_id#23 charsetFindOrAddGlyph::@16/(byte) bob_charset_next_id#24 ) + (byte) charsetFindOrAddGlyph::glyph_id#2 ← phi( charsetFindOrAddGlyph/(byte) charsetFindOrAddGlyph::glyph_id#0 charsetFindOrAddGlyph::@16/(byte) charsetFindOrAddGlyph::glyph_id#1 ) + (bool~) charsetFindOrAddGlyph::$0 ← (byte) charsetFindOrAddGlyph::glyph_id#2 != (byte) bob_charset_next_id#15 + if((bool~) charsetFindOrAddGlyph::$0) goto charsetFindOrAddGlyph::@2 + to:charsetFindOrAddGlyph::@3 +charsetFindOrAddGlyph::@2: scope:[charsetFindOrAddGlyph] from charsetFindOrAddGlyph::@1 + (byte) bob_charset_next_id#44 ← phi( charsetFindOrAddGlyph::@1/(byte) bob_charset_next_id#15 ) + (byte) charsetFindOrAddGlyph::glyph_id#12 ← phi( charsetFindOrAddGlyph::@1/(byte) charsetFindOrAddGlyph::glyph_id#2 ) + (byte*) charsetFindOrAddGlyph::glyph#6 ← phi( charsetFindOrAddGlyph::@1/(byte*) charsetFindOrAddGlyph::glyph#9 ) + (byte*) charsetFindOrAddGlyph::glyph_cursor#8 ← phi( charsetFindOrAddGlyph::@1/(byte*) charsetFindOrAddGlyph::glyph_cursor#12 ) + (byte) charsetFindOrAddGlyph::found#0 ← (number) 1 + (byte) charsetFindOrAddGlyph::i#0 ← (number) 0 + to:charsetFindOrAddGlyph::@4 +charsetFindOrAddGlyph::@3: scope:[charsetFindOrAddGlyph] from charsetFindOrAddGlyph::@1 + (byte) charsetFindOrAddGlyph::glyph_id#11 ← phi( charsetFindOrAddGlyph::@1/(byte) charsetFindOrAddGlyph::glyph_id#2 ) + (byte) bob_charset_next_id#34 ← phi( charsetFindOrAddGlyph::@1/(byte) bob_charset_next_id#15 ) + (byte*) charsetFindOrAddGlyph::glyph_cursor#11 ← phi( charsetFindOrAddGlyph::@1/(byte*) charsetFindOrAddGlyph::glyph_cursor#12 ) + (byte*) charsetFindOrAddGlyph::glyph#8 ← phi( charsetFindOrAddGlyph::@1/(byte*) charsetFindOrAddGlyph::glyph#9 ) + (byte) charsetFindOrAddGlyph::i1#0 ← (number) 0 + to:charsetFindOrAddGlyph::@20 +charsetFindOrAddGlyph::@4: scope:[charsetFindOrAddGlyph] from charsetFindOrAddGlyph::@2 charsetFindOrAddGlyph::@7 + (byte) bob_charset_next_id#41 ← phi( charsetFindOrAddGlyph::@2/(byte) bob_charset_next_id#44 charsetFindOrAddGlyph::@7/(byte) bob_charset_next_id#45 ) + (byte) charsetFindOrAddGlyph::glyph_id#9 ← phi( charsetFindOrAddGlyph::@2/(byte) charsetFindOrAddGlyph::glyph_id#12 charsetFindOrAddGlyph::@7/(byte) charsetFindOrAddGlyph::glyph_id#13 ) + (byte) charsetFindOrAddGlyph::found#3 ← phi( charsetFindOrAddGlyph::@2/(byte) charsetFindOrAddGlyph::found#0 charsetFindOrAddGlyph::@7/(byte) charsetFindOrAddGlyph::found#4 ) + (byte*) charsetFindOrAddGlyph::glyph#4 ← phi( charsetFindOrAddGlyph::@2/(byte*) charsetFindOrAddGlyph::glyph#6 charsetFindOrAddGlyph::@7/(byte*) charsetFindOrAddGlyph::glyph#7 ) + (byte*) charsetFindOrAddGlyph::glyph_cursor#5 ← phi( charsetFindOrAddGlyph::@2/(byte*) charsetFindOrAddGlyph::glyph_cursor#8 charsetFindOrAddGlyph::@7/(byte*) charsetFindOrAddGlyph::glyph_cursor#9 ) + (byte) charsetFindOrAddGlyph::i#2 ← phi( charsetFindOrAddGlyph::@2/(byte) charsetFindOrAddGlyph::i#0 charsetFindOrAddGlyph::@7/(byte) charsetFindOrAddGlyph::i#1 ) + (bool~) charsetFindOrAddGlyph::$1 ← (byte) charsetFindOrAddGlyph::i#2 < (number) 8 + if((bool~) charsetFindOrAddGlyph::$1) goto charsetFindOrAddGlyph::@5 + to:charsetFindOrAddGlyph::@8 +charsetFindOrAddGlyph::@5: scope:[charsetFindOrAddGlyph] from charsetFindOrAddGlyph::@4 + (byte) bob_charset_next_id#46 ← phi( charsetFindOrAddGlyph::@4/(byte) bob_charset_next_id#41 ) + (byte) charsetFindOrAddGlyph::glyph_id#14 ← phi( charsetFindOrAddGlyph::@4/(byte) charsetFindOrAddGlyph::glyph_id#9 ) + (byte) charsetFindOrAddGlyph::found#5 ← phi( charsetFindOrAddGlyph::@4/(byte) charsetFindOrAddGlyph::found#3 ) + (byte*) charsetFindOrAddGlyph::glyph#2 ← phi( charsetFindOrAddGlyph::@4/(byte*) charsetFindOrAddGlyph::glyph#4 ) + (byte) charsetFindOrAddGlyph::i#3 ← phi( charsetFindOrAddGlyph::@4/(byte) charsetFindOrAddGlyph::i#2 ) + (byte*) charsetFindOrAddGlyph::glyph_cursor#2 ← phi( charsetFindOrAddGlyph::@4/(byte*) charsetFindOrAddGlyph::glyph_cursor#5 ) + (bool~) charsetFindOrAddGlyph::$2 ← *((byte*) charsetFindOrAddGlyph::glyph_cursor#2 + (byte) charsetFindOrAddGlyph::i#3) != *((byte*) charsetFindOrAddGlyph::glyph#2 + (byte) charsetFindOrAddGlyph::i#3) + (bool~) charsetFindOrAddGlyph::$3 ← ! (bool~) charsetFindOrAddGlyph::$2 + if((bool~) charsetFindOrAddGlyph::$3) goto charsetFindOrAddGlyph::@7 + to:charsetFindOrAddGlyph::@11 +charsetFindOrAddGlyph::@7: scope:[charsetFindOrAddGlyph] from charsetFindOrAddGlyph::@5 + (byte) bob_charset_next_id#45 ← phi( charsetFindOrAddGlyph::@5/(byte) bob_charset_next_id#46 ) + (byte) charsetFindOrAddGlyph::glyph_id#13 ← phi( charsetFindOrAddGlyph::@5/(byte) charsetFindOrAddGlyph::glyph_id#14 ) + (byte) charsetFindOrAddGlyph::found#4 ← phi( charsetFindOrAddGlyph::@5/(byte) charsetFindOrAddGlyph::found#5 ) + (byte*) charsetFindOrAddGlyph::glyph#7 ← phi( charsetFindOrAddGlyph::@5/(byte*) charsetFindOrAddGlyph::glyph#2 ) + (byte*) charsetFindOrAddGlyph::glyph_cursor#9 ← phi( charsetFindOrAddGlyph::@5/(byte*) charsetFindOrAddGlyph::glyph_cursor#2 ) + (byte) charsetFindOrAddGlyph::i#4 ← phi( charsetFindOrAddGlyph::@5/(byte) charsetFindOrAddGlyph::i#3 ) + (byte) charsetFindOrAddGlyph::i#1 ← ++ (byte) charsetFindOrAddGlyph::i#4 + to:charsetFindOrAddGlyph::@4 +charsetFindOrAddGlyph::@11: scope:[charsetFindOrAddGlyph] from charsetFindOrAddGlyph::@5 + (byte*) charsetFindOrAddGlyph::glyph#13 ← phi( charsetFindOrAddGlyph::@5/(byte*) charsetFindOrAddGlyph::glyph#2 ) + (byte) bob_charset_next_id#40 ← phi( charsetFindOrAddGlyph::@5/(byte) bob_charset_next_id#46 ) + (byte*) charsetFindOrAddGlyph::glyph_cursor#10 ← phi( charsetFindOrAddGlyph::@5/(byte*) charsetFindOrAddGlyph::glyph_cursor#2 ) + (byte) charsetFindOrAddGlyph::glyph_id#8 ← phi( charsetFindOrAddGlyph::@5/(byte) charsetFindOrAddGlyph::glyph_id#14 ) + (byte) charsetFindOrAddGlyph::found#1 ← (number) 0 + to:charsetFindOrAddGlyph::@8 +charsetFindOrAddGlyph::@8: scope:[charsetFindOrAddGlyph] from charsetFindOrAddGlyph::@11 charsetFindOrAddGlyph::@4 + (byte*) charsetFindOrAddGlyph::glyph#12 ← phi( charsetFindOrAddGlyph::@11/(byte*) charsetFindOrAddGlyph::glyph#13 charsetFindOrAddGlyph::@4/(byte*) charsetFindOrAddGlyph::glyph#4 ) + (byte) bob_charset_next_id#32 ← phi( charsetFindOrAddGlyph::@11/(byte) bob_charset_next_id#40 charsetFindOrAddGlyph::@4/(byte) bob_charset_next_id#41 ) + (byte*) charsetFindOrAddGlyph::glyph_cursor#6 ← phi( charsetFindOrAddGlyph::@11/(byte*) charsetFindOrAddGlyph::glyph_cursor#10 charsetFindOrAddGlyph::@4/(byte*) charsetFindOrAddGlyph::glyph_cursor#5 ) + (byte) charsetFindOrAddGlyph::glyph_id#6 ← phi( charsetFindOrAddGlyph::@11/(byte) charsetFindOrAddGlyph::glyph_id#8 charsetFindOrAddGlyph::@4/(byte) charsetFindOrAddGlyph::glyph_id#9 ) + (byte) charsetFindOrAddGlyph::found#2 ← phi( charsetFindOrAddGlyph::@11/(byte) charsetFindOrAddGlyph::found#1 charsetFindOrAddGlyph::@4/(byte) charsetFindOrAddGlyph::found#3 ) + (bool~) charsetFindOrAddGlyph::$6 ← (number) 0 != (byte) charsetFindOrAddGlyph::found#2 + (bool~) charsetFindOrAddGlyph::$4 ← ! (bool~) charsetFindOrAddGlyph::$6 + if((bool~) charsetFindOrAddGlyph::$4) goto charsetFindOrAddGlyph::@16 + to:charsetFindOrAddGlyph::@14 +charsetFindOrAddGlyph::@16: scope:[charsetFindOrAddGlyph] from charsetFindOrAddGlyph::@8 + (byte*) charsetFindOrAddGlyph::glyph#11 ← phi( charsetFindOrAddGlyph::@8/(byte*) charsetFindOrAddGlyph::glyph#12 ) + (byte) bob_charset_next_id#24 ← phi( charsetFindOrAddGlyph::@8/(byte) bob_charset_next_id#32 ) + (byte*) charsetFindOrAddGlyph::glyph_cursor#3 ← phi( charsetFindOrAddGlyph::@8/(byte*) charsetFindOrAddGlyph::glyph_cursor#6 ) + (byte) charsetFindOrAddGlyph::glyph_id#3 ← phi( charsetFindOrAddGlyph::@8/(byte) charsetFindOrAddGlyph::glyph_id#6 ) + (byte) charsetFindOrAddGlyph::glyph_id#1 ← ++ (byte) charsetFindOrAddGlyph::glyph_id#3 + (byte*) charsetFindOrAddGlyph::glyph_cursor#1 ← (byte*) charsetFindOrAddGlyph::glyph_cursor#3 + (number) 8 + to:charsetFindOrAddGlyph::@1 +charsetFindOrAddGlyph::@14: scope:[charsetFindOrAddGlyph] from charsetFindOrAddGlyph::@8 + (byte) bob_charset_next_id#25 ← phi( charsetFindOrAddGlyph::@8/(byte) bob_charset_next_id#32 ) + (byte) charsetFindOrAddGlyph::glyph_id#4 ← phi( charsetFindOrAddGlyph::@8/(byte) charsetFindOrAddGlyph::glyph_id#6 ) + (byte) charsetFindOrAddGlyph::return#2 ← (byte) charsetFindOrAddGlyph::glyph_id#4 + to:charsetFindOrAddGlyph::@return +charsetFindOrAddGlyph::@return: scope:[charsetFindOrAddGlyph] from charsetFindOrAddGlyph::@14 charsetFindOrAddGlyph::@22 + (byte) bob_charset_next_id#16 ← phi( charsetFindOrAddGlyph::@14/(byte) bob_charset_next_id#25 charsetFindOrAddGlyph::@22/(byte) bob_charset_next_id#8 ) + (byte) charsetFindOrAddGlyph::return#6 ← phi( charsetFindOrAddGlyph::@14/(byte) charsetFindOrAddGlyph::return#2 charsetFindOrAddGlyph::@22/(byte) charsetFindOrAddGlyph::return#4 ) + (byte) charsetFindOrAddGlyph::return#3 ← (byte) charsetFindOrAddGlyph::return#6 + (byte) bob_charset_next_id#7 ← (byte) bob_charset_next_id#16 + return + to:@return +charsetFindOrAddGlyph::@20: scope:[charsetFindOrAddGlyph] from charsetFindOrAddGlyph::@21 charsetFindOrAddGlyph::@3 + (byte) charsetFindOrAddGlyph::glyph_id#7 ← phi( charsetFindOrAddGlyph::@21/(byte) charsetFindOrAddGlyph::glyph_id#10 charsetFindOrAddGlyph::@3/(byte) charsetFindOrAddGlyph::glyph_id#11 ) + (byte) bob_charset_next_id#26 ← phi( charsetFindOrAddGlyph::@21/(byte) bob_charset_next_id#33 charsetFindOrAddGlyph::@3/(byte) bob_charset_next_id#34 ) + (byte*) charsetFindOrAddGlyph::glyph_cursor#7 ← phi( charsetFindOrAddGlyph::@21/(byte*) charsetFindOrAddGlyph::glyph_cursor#4 charsetFindOrAddGlyph::@3/(byte*) charsetFindOrAddGlyph::glyph_cursor#11 ) + (byte*) charsetFindOrAddGlyph::glyph#5 ← phi( charsetFindOrAddGlyph::@21/(byte*) charsetFindOrAddGlyph::glyph#3 charsetFindOrAddGlyph::@3/(byte*) charsetFindOrAddGlyph::glyph#8 ) + (byte) charsetFindOrAddGlyph::i1#2 ← phi( charsetFindOrAddGlyph::@21/(byte) charsetFindOrAddGlyph::i1#1 charsetFindOrAddGlyph::@3/(byte) charsetFindOrAddGlyph::i1#0 ) + (bool~) charsetFindOrAddGlyph::$5 ← (byte) charsetFindOrAddGlyph::i1#2 < (number) 8 + if((bool~) charsetFindOrAddGlyph::$5) goto charsetFindOrAddGlyph::@21 + to:charsetFindOrAddGlyph::@22 +charsetFindOrAddGlyph::@21: scope:[charsetFindOrAddGlyph] from charsetFindOrAddGlyph::@20 + (byte) charsetFindOrAddGlyph::glyph_id#10 ← phi( charsetFindOrAddGlyph::@20/(byte) charsetFindOrAddGlyph::glyph_id#7 ) + (byte) bob_charset_next_id#33 ← phi( charsetFindOrAddGlyph::@20/(byte) bob_charset_next_id#26 ) + (byte*) charsetFindOrAddGlyph::glyph_cursor#4 ← phi( charsetFindOrAddGlyph::@20/(byte*) charsetFindOrAddGlyph::glyph_cursor#7 ) + (byte) charsetFindOrAddGlyph::i1#3 ← phi( charsetFindOrAddGlyph::@20/(byte) charsetFindOrAddGlyph::i1#2 ) + (byte*) charsetFindOrAddGlyph::glyph#3 ← phi( charsetFindOrAddGlyph::@20/(byte*) charsetFindOrAddGlyph::glyph#5 ) + *((byte*) charsetFindOrAddGlyph::glyph_cursor#4 + (byte) charsetFindOrAddGlyph::i1#3) ← *((byte*) charsetFindOrAddGlyph::glyph#3 + (byte) charsetFindOrAddGlyph::i1#3) + (byte) charsetFindOrAddGlyph::i1#1 ← ++ (byte) charsetFindOrAddGlyph::i1#3 + to:charsetFindOrAddGlyph::@20 +charsetFindOrAddGlyph::@22: scope:[charsetFindOrAddGlyph] from charsetFindOrAddGlyph::@20 + (byte) charsetFindOrAddGlyph::glyph_id#5 ← phi( charsetFindOrAddGlyph::@20/(byte) charsetFindOrAddGlyph::glyph_id#7 ) + (byte) bob_charset_next_id#17 ← phi( charsetFindOrAddGlyph::@20/(byte) bob_charset_next_id#26 ) + (byte) bob_charset_next_id#8 ← ++ (byte) bob_charset_next_id#17 + (byte) charsetFindOrAddGlyph::return#4 ← (byte) charsetFindOrAddGlyph::glyph_id#5 + to:charsetFindOrAddGlyph::@return +@66: scope:[] from @65 + (byte**) renderBobCleanupNext#23 ← phi( @65/(byte**) renderBobCleanupNext#27 ) + (byte) bob_charset_next_id#35 ← phi( @65/(byte) bob_charset_next_id#6 ) + (byte*) progress_cursor#5 ← (byte*) 0 + (byte) progress_idx#5 ← (byte) 0 + to:@68 + +(void()) progress_init((byte*) progress_init::line) +progress_init: scope:[progress_init] from prepareBobs + (byte*) progress_init::line#1 ← phi( prepareBobs/(byte*) progress_init::line#0 ) + (byte*) progress_cursor#6 ← (byte*) progress_init::line#1 + (byte) progress_idx#6 ← (number) 0 + to:progress_init::@return +progress_init::@return: scope:[progress_init] from progress_init + (byte) progress_idx#17 ← phi( progress_init/(byte) progress_idx#6 ) + (byte*) progress_cursor#16 ← phi( progress_init/(byte*) progress_cursor#6 ) + (byte*) progress_cursor#7 ← (byte*) progress_cursor#16 + (byte) progress_idx#7 ← (byte) progress_idx#17 + return + to:@return + +(void()) progress_inc() +progress_inc: scope:[progress_inc] from prepareBobs::@22 + (byte*) progress_cursor#26 ← phi( prepareBobs::@22/(byte*) progress_cursor#24 ) + (byte) progress_idx#18 ← phi( prepareBobs::@22/(byte) progress_idx#25 ) + (byte) progress_idx#8 ← ++ (byte) progress_idx#18 + (bool~) progress_inc::$0 ← (byte) progress_idx#8 == (number) 8 + (bool~) progress_inc::$1 ← ! (bool~) progress_inc::$0 + if((bool~) progress_inc::$1) goto progress_inc::@1 + to:progress_inc::@2 +progress_inc::@1: scope:[progress_inc] from progress_inc progress_inc::@2 + (byte*) progress_cursor#17 ← phi( progress_inc/(byte*) progress_cursor#26 progress_inc::@2/(byte*) progress_cursor#8 ) + (byte) progress_idx#19 ← phi( progress_inc/(byte) progress_idx#8 progress_inc::@2/(byte) progress_idx#9 ) + *((byte*) progress_cursor#17) ← *((const byte*) progress_inc::progress_chars + (byte) progress_idx#19) + to:progress_inc::@return +progress_inc::@2: scope:[progress_inc] from progress_inc + (byte*) progress_cursor#18 ← phi( progress_inc/(byte*) progress_cursor#26 ) + *((byte*) progress_cursor#18) ← *((const byte*) progress_inc::progress_chars + (number) 8) + (byte*) progress_cursor#8 ← ++ (byte*) progress_cursor#18 + (byte) progress_idx#9 ← (number) 0 + to:progress_inc::@1 +progress_inc::@return: scope:[progress_inc] from progress_inc::@1 + (byte*) progress_cursor#19 ← phi( progress_inc::@1/(byte*) progress_cursor#17 ) + (byte) progress_idx#20 ← phi( progress_inc::@1/(byte) progress_idx#19 ) + (byte) progress_idx#10 ← (byte) progress_idx#20 + (byte*) progress_cursor#9 ← (byte*) progress_cursor#19 + return + to:@return +@68: scope:[] from @66 + (byte**) renderBobCleanupNext#19 ← phi( @66/(byte**) renderBobCleanupNext#23 ) + (byte) bob_charset_next_id#27 ← phi( @66/(byte) bob_charset_next_id#35 ) + (byte) progress_idx#27 ← phi( @66/(byte) progress_idx#5 ) + (byte*) progress_cursor#27 ← phi( @66/(byte*) progress_cursor#5 ) + call main + to:@69 +@69: scope:[] from @68 + (byte**) renderBobCleanupNext#15 ← phi( @68/(byte**) renderBobCleanupNext#2 ) + (byte) bob_charset_next_id#18 ← phi( @68/(byte) bob_charset_next_id#1 ) + (byte) progress_idx#21 ← phi( @68/(byte) progress_idx#1 ) + (byte*) progress_cursor#20 ← phi( @68/(byte*) progress_cursor#1 ) + (byte*) progress_cursor#10 ← (byte*) progress_cursor#20 + (byte) progress_idx#11 ← (byte) progress_idx#21 + (byte) bob_charset_next_id#9 ← (byte) bob_charset_next_id#18 + (byte**) renderBobCleanupNext#8 ← (byte**) renderBobCleanupNext#15 + to:@end +@end: scope:[] from @69 + +SYMBOL TABLE SSA +(label) @59 +(label) @65 +(label) @66 +(label) @68 +(label) @69 +(label) @begin +(label) @end +(const byte*) BOB_CHARSET = (byte*)(number) $2000 +(const byte*) BOB_SCREEN = (byte*)(number) $2800 +(const byte) BOB_SHIFTS_X = (number) 4 +(const byte) BOB_SHIFTS_Y = (number) 8 +(const byte) BOB_SUBTABLE_SIZE = (const byte) BOB_SHIFTS_X*(const byte) BOB_SHIFTS_Y +(const byte*) BOB_TABLES = { fill( 9*8*4, 0) } +(const byte*) BORDERCOL = (byte*)(number) $d020 +(const byte*) CHARSET_BASIC = (byte*)(number) $1000 +(const byte*) CIA1_PORT_A = (byte*)(number) $dc00 +(const byte*) CIA1_PORT_B = (byte*)(number) $dc01 +(const byte*) CIA2_PORT_A = (byte*)(number) $dd00 +(const byte*) CIA2_PORT_A_DDR = (byte*)(number) $dd02 +(const signed byte*) COS = (const signed byte*) SIN+(number) $40 +(const byte*) D018 = (byte*)(number) $d018 +(const byte) KEY_SPACE = (number) $3c +(const word*) MUL40 = { fill( $20, 0) } +(const byte) NUM_BOBS = (number) $14 +(const byte*) PROTO_BOB = kickasm {{ .var pic = LoadPicture("smiley.png", List().add($000000, $ffffff)) + .for (var x=0;x<3; x++) + .for (var y=0; y<24; y++) + .byte pic.getSinglecolorByte(x,y) + }} +(const byte) RADIX::BINARY = (number) 2 +(const byte) RADIX::DECIMAL = (number) $a +(const byte) RADIX::HEXADECIMAL = (number) $10 +(const byte) RADIX::OCTAL = (number) 8 +(const byte*) RASTER = (byte*)(number) $d012 +(const byte**) RENDERBOB_CLEANUP = { fill( NUM_BOBS, 0) } +(const byte*) SCREEN_BASIC = (byte*)(number) $400 +(const signed byte*) SIN = kickasm {{ .for(var i=0;i<$140;i++) + .byte >round($7fff*sin(i*2*PI/256)) + }} +(const byte) SIZEOF_POINTER = (byte) 2 +(const byte) SIZEOF_WORD = (byte) 2 +(byte) bob_charset_next_id +(byte) bob_charset_next_id#0 +(byte) bob_charset_next_id#1 +(byte) bob_charset_next_id#10 +(byte) bob_charset_next_id#11 +(byte) bob_charset_next_id#12 +(byte) bob_charset_next_id#13 +(byte) bob_charset_next_id#14 +(byte) bob_charset_next_id#15 +(byte) bob_charset_next_id#16 +(byte) bob_charset_next_id#17 +(byte) bob_charset_next_id#18 +(byte) bob_charset_next_id#19 +(byte) bob_charset_next_id#2 +(byte) bob_charset_next_id#20 +(byte) bob_charset_next_id#21 +(byte) bob_charset_next_id#22 +(byte) bob_charset_next_id#23 +(byte) bob_charset_next_id#24 +(byte) bob_charset_next_id#25 +(byte) bob_charset_next_id#26 +(byte) bob_charset_next_id#27 +(byte) bob_charset_next_id#28 +(byte) bob_charset_next_id#29 +(byte) bob_charset_next_id#3 +(byte) bob_charset_next_id#30 +(byte) bob_charset_next_id#31 +(byte) bob_charset_next_id#32 +(byte) bob_charset_next_id#33 +(byte) bob_charset_next_id#34 +(byte) bob_charset_next_id#35 +(byte) bob_charset_next_id#36 +(byte) bob_charset_next_id#37 +(byte) bob_charset_next_id#38 +(byte) bob_charset_next_id#39 +(byte) bob_charset_next_id#4 +(byte) bob_charset_next_id#40 +(byte) bob_charset_next_id#41 +(byte) bob_charset_next_id#42 +(byte) bob_charset_next_id#43 +(byte) bob_charset_next_id#44 +(byte) bob_charset_next_id#45 +(byte) bob_charset_next_id#46 +(byte) bob_charset_next_id#47 +(byte) bob_charset_next_id#48 +(byte) bob_charset_next_id#49 +(byte) bob_charset_next_id#5 +(byte) bob_charset_next_id#50 +(byte) bob_charset_next_id#51 +(byte) bob_charset_next_id#52 +(byte) bob_charset_next_id#53 +(byte) bob_charset_next_id#54 +(byte) bob_charset_next_id#55 +(byte) bob_charset_next_id#56 +(byte) bob_charset_next_id#57 +(byte) bob_charset_next_id#58 +(byte) bob_charset_next_id#59 +(byte) bob_charset_next_id#6 +(byte) bob_charset_next_id#60 +(byte) bob_charset_next_id#61 +(byte) bob_charset_next_id#62 +(byte) bob_charset_next_id#63 +(byte) bob_charset_next_id#64 +(byte) bob_charset_next_id#65 +(byte) bob_charset_next_id#66 +(byte) bob_charset_next_id#67 +(byte) bob_charset_next_id#68 +(byte) bob_charset_next_id#69 +(byte) bob_charset_next_id#7 +(byte) bob_charset_next_id#70 +(byte) bob_charset_next_id#71 +(byte) bob_charset_next_id#72 +(byte) bob_charset_next_id#73 +(byte) bob_charset_next_id#74 +(byte) bob_charset_next_id#75 +(byte) bob_charset_next_id#76 +(byte) bob_charset_next_id#77 +(byte) bob_charset_next_id#8 +(byte) bob_charset_next_id#9 +(byte()) charsetFindOrAddGlyph((byte*) charsetFindOrAddGlyph::glyph , (byte*) charsetFindOrAddGlyph::charset) +(bool~) charsetFindOrAddGlyph::$0 +(bool~) charsetFindOrAddGlyph::$1 +(bool~) charsetFindOrAddGlyph::$2 +(bool~) charsetFindOrAddGlyph::$3 +(bool~) charsetFindOrAddGlyph::$4 +(bool~) charsetFindOrAddGlyph::$5 +(bool~) charsetFindOrAddGlyph::$6 +(label) charsetFindOrAddGlyph::@1 +(label) charsetFindOrAddGlyph::@11 +(label) charsetFindOrAddGlyph::@14 +(label) charsetFindOrAddGlyph::@16 +(label) charsetFindOrAddGlyph::@2 +(label) charsetFindOrAddGlyph::@20 +(label) charsetFindOrAddGlyph::@21 +(label) charsetFindOrAddGlyph::@22 +(label) charsetFindOrAddGlyph::@3 +(label) charsetFindOrAddGlyph::@4 +(label) charsetFindOrAddGlyph::@5 +(label) charsetFindOrAddGlyph::@7 +(label) charsetFindOrAddGlyph::@8 +(label) charsetFindOrAddGlyph::@return +(byte*) charsetFindOrAddGlyph::charset +(byte*) charsetFindOrAddGlyph::charset#0 +(byte*) charsetFindOrAddGlyph::charset#1 +(byte*) charsetFindOrAddGlyph::charset#2 +(byte) charsetFindOrAddGlyph::found +(byte) charsetFindOrAddGlyph::found#0 +(byte) charsetFindOrAddGlyph::found#1 +(byte) charsetFindOrAddGlyph::found#2 +(byte) charsetFindOrAddGlyph::found#3 +(byte) charsetFindOrAddGlyph::found#4 +(byte) charsetFindOrAddGlyph::found#5 +(byte*) charsetFindOrAddGlyph::glyph +(byte*) charsetFindOrAddGlyph::glyph#0 +(byte*) charsetFindOrAddGlyph::glyph#1 +(byte*) charsetFindOrAddGlyph::glyph#10 +(byte*) charsetFindOrAddGlyph::glyph#11 +(byte*) charsetFindOrAddGlyph::glyph#12 +(byte*) charsetFindOrAddGlyph::glyph#13 +(byte*) charsetFindOrAddGlyph::glyph#2 +(byte*) charsetFindOrAddGlyph::glyph#3 +(byte*) charsetFindOrAddGlyph::glyph#4 +(byte*) charsetFindOrAddGlyph::glyph#5 +(byte*) charsetFindOrAddGlyph::glyph#6 +(byte*) charsetFindOrAddGlyph::glyph#7 +(byte*) charsetFindOrAddGlyph::glyph#8 +(byte*) charsetFindOrAddGlyph::glyph#9 +(byte*) charsetFindOrAddGlyph::glyph_cursor +(byte*) charsetFindOrAddGlyph::glyph_cursor#0 +(byte*) charsetFindOrAddGlyph::glyph_cursor#1 +(byte*) charsetFindOrAddGlyph::glyph_cursor#10 +(byte*) charsetFindOrAddGlyph::glyph_cursor#11 +(byte*) charsetFindOrAddGlyph::glyph_cursor#12 +(byte*) charsetFindOrAddGlyph::glyph_cursor#2 +(byte*) charsetFindOrAddGlyph::glyph_cursor#3 +(byte*) charsetFindOrAddGlyph::glyph_cursor#4 +(byte*) charsetFindOrAddGlyph::glyph_cursor#5 +(byte*) charsetFindOrAddGlyph::glyph_cursor#6 +(byte*) charsetFindOrAddGlyph::glyph_cursor#7 +(byte*) charsetFindOrAddGlyph::glyph_cursor#8 +(byte*) charsetFindOrAddGlyph::glyph_cursor#9 +(byte) charsetFindOrAddGlyph::glyph_id +(byte) charsetFindOrAddGlyph::glyph_id#0 +(byte) charsetFindOrAddGlyph::glyph_id#1 +(byte) charsetFindOrAddGlyph::glyph_id#10 +(byte) charsetFindOrAddGlyph::glyph_id#11 +(byte) charsetFindOrAddGlyph::glyph_id#12 +(byte) charsetFindOrAddGlyph::glyph_id#13 +(byte) charsetFindOrAddGlyph::glyph_id#14 +(byte) charsetFindOrAddGlyph::glyph_id#2 +(byte) charsetFindOrAddGlyph::glyph_id#3 +(byte) charsetFindOrAddGlyph::glyph_id#4 +(byte) charsetFindOrAddGlyph::glyph_id#5 +(byte) charsetFindOrAddGlyph::glyph_id#6 +(byte) charsetFindOrAddGlyph::glyph_id#7 +(byte) charsetFindOrAddGlyph::glyph_id#8 +(byte) charsetFindOrAddGlyph::glyph_id#9 +(byte) charsetFindOrAddGlyph::i +(byte) charsetFindOrAddGlyph::i#0 +(byte) charsetFindOrAddGlyph::i#1 +(byte) charsetFindOrAddGlyph::i#2 +(byte) charsetFindOrAddGlyph::i#3 +(byte) charsetFindOrAddGlyph::i#4 +(byte) charsetFindOrAddGlyph::i1 +(byte) charsetFindOrAddGlyph::i1#0 +(byte) charsetFindOrAddGlyph::i1#1 +(byte) charsetFindOrAddGlyph::i1#2 +(byte) charsetFindOrAddGlyph::i1#3 +(byte) charsetFindOrAddGlyph::return +(byte) charsetFindOrAddGlyph::return#0 +(byte) charsetFindOrAddGlyph::return#1 +(byte) charsetFindOrAddGlyph::return#2 +(byte) charsetFindOrAddGlyph::return#3 +(byte) charsetFindOrAddGlyph::return#4 +(byte) charsetFindOrAddGlyph::return#5 +(byte) charsetFindOrAddGlyph::return#6 +(byte()) keyboard_key_pressed((byte) keyboard_key_pressed::key) +(number~) keyboard_key_pressed::$0 +(byte~) keyboard_key_pressed::$1 +(byte~) keyboard_key_pressed::$2 +(byte~) keyboard_key_pressed::$3 +(label) keyboard_key_pressed::@2 +(label) keyboard_key_pressed::@return +(byte) keyboard_key_pressed::colidx +(byte) keyboard_key_pressed::colidx#0 +(byte) keyboard_key_pressed::colidx#1 +(byte) keyboard_key_pressed::key +(byte) keyboard_key_pressed::key#0 +(byte) keyboard_key_pressed::key#1 +(byte) keyboard_key_pressed::key#2 +(byte) keyboard_key_pressed::return +(byte) keyboard_key_pressed::return#0 +(byte) keyboard_key_pressed::return#1 +(byte) keyboard_key_pressed::return#2 +(byte) keyboard_key_pressed::return#3 +(byte) keyboard_key_pressed::return#4 +(byte) keyboard_key_pressed::return#5 +(byte) keyboard_key_pressed::return#6 +(byte) keyboard_key_pressed::rowidx +(byte) keyboard_key_pressed::rowidx#0 +(const byte*) keyboard_matrix_col_bitmask = { (byte)(number) 1, (byte)(number) 2, (byte)(number) 4, (byte)(number) 8, (byte)(number) $10, (byte)(number) $20, (byte)(number) $40, (byte)(number) $80 } +(byte()) keyboard_matrix_read((byte) keyboard_matrix_read::rowid) +(byte~) keyboard_matrix_read::$0 +(label) keyboard_matrix_read::@return +(byte) keyboard_matrix_read::return +(byte) keyboard_matrix_read::return#0 +(byte) keyboard_matrix_read::return#1 +(byte) keyboard_matrix_read::return#2 +(byte) keyboard_matrix_read::return#3 +(byte) keyboard_matrix_read::return#4 +(byte) keyboard_matrix_read::row_pressed_bits +(byte) keyboard_matrix_read::row_pressed_bits#0 +(byte) keyboard_matrix_read::rowid +(byte) keyboard_matrix_read::rowid#0 +(byte) keyboard_matrix_read::rowid#1 +(const byte*) keyboard_matrix_row_bitmask = { (byte)(number) $fe, (byte)(number) $fd, (byte)(number) $fb, (byte)(number) $f7, (byte)(number) $ef, (byte)(number) $df, (byte)(number) $bf, (byte)(number) $7f } +(void()) main() +(signed word~) main::$10 +(number~) main::$11 +(signed word~) main::$12 +(number~) main::$13 +(number~) main::$14 +(byte~) main::$15 +(byte~) main::$16 +(bool~) main::$18 +(byte~) main::$19 +(bool~) main::$20 +(byte~) main::$21 +(bool~) main::$22 +(bool~) main::$23 +(byte~) main::$4 +(byte~) main::$7 +(bool~) main::$8 +(label) main::@1 +(label) main::@15 +(label) main::@17 +(label) main::@21 +(label) main::@22 +(label) main::@23 +(label) main::@24 +(label) main::@25 +(label) main::@26 +(label) main::@27 +(label) main::@28 +(label) main::@29 +(label) main::@30 +(label) main::@31 +(label) main::@32 +(label) main::@33 +(label) main::@34 +(label) main::@4 +(label) main::@5 +(label) main::@6 +(label) main::@7 +(label) main::@return +(byte) main::a +(byte) main::a#0 +(byte) main::a#1 +(byte) main::a#2 +(byte) main::a#3 +(byte) main::a#4 +(byte) main::a#5 +(byte) main::angle +(byte) main::angle#0 +(byte) main::angle#1 +(byte) main::angle#10 +(byte) main::angle#11 +(byte) main::angle#2 +(byte) main::angle#3 +(byte) main::angle#4 +(byte) main::angle#5 +(byte) main::angle#6 +(byte) main::angle#7 +(byte) main::angle#8 +(byte) main::angle#9 +(byte) main::i +(byte) main::i#0 +(byte) main::i#1 +(byte) main::i#2 +(byte) main::i#3 +(byte) main::i#4 +(byte) main::i#5 +(signed byte) main::r +(signed byte) main::r#0 +(signed byte) main::r#1 +(signed byte) main::r#2 +(signed byte) main::r#3 +(signed byte) main::r#4 +(signed byte) main::r#5 +(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 +(label) main::toD0181_@return +(byte*) main::toD0181_gfx +(byte*) main::toD0181_gfx#0 +(byte*) main::toD0181_gfx#1 +(byte) main::toD0181_return +(byte) main::toD0181_return#0 +(byte) main::toD0181_return#1 +(byte) main::toD0181_return#2 +(byte) main::toD0181_return#3 +(byte*) main::toD0181_screen +(byte*) main::toD0181_screen#0 +(byte*) main::toD0181_screen#1 +(label) main::toD0182 +(word~) main::toD0182_$0 +(number~) main::toD0182_$1 +(number~) main::toD0182_$2 +(number~) main::toD0182_$3 +(word~) main::toD0182_$4 +(byte~) main::toD0182_$5 +(number~) main::toD0182_$6 +(number~) main::toD0182_$7 +(number~) main::toD0182_$8 +(label) main::toD0182_@return +(byte*) main::toD0182_gfx +(byte*) main::toD0182_gfx#0 +(byte*) main::toD0182_gfx#1 +(byte) main::toD0182_return +(byte) main::toD0182_return#0 +(byte) main::toD0182_return#1 +(byte) main::toD0182_return#2 +(byte) main::toD0182_return#3 +(byte*) main::toD0182_screen +(byte*) main::toD0182_screen#0 +(byte*) main::toD0182_screen#1 +(label) main::vicSelectGfxBank1 +(byte~) main::vicSelectGfxBank1_$0 +(label) main::vicSelectGfxBank1_@1 +(byte*) main::vicSelectGfxBank1_gfx +(byte*) main::vicSelectGfxBank1_gfx#0 +(byte*) main::vicSelectGfxBank1_gfx#1 +(label) main::vicSelectGfxBank1_toDd001 +(word~) main::vicSelectGfxBank1_toDd001_$0 +(byte~) main::vicSelectGfxBank1_toDd001_$1 +(number~) main::vicSelectGfxBank1_toDd001_$2 +(number~) main::vicSelectGfxBank1_toDd001_$3 +(label) main::vicSelectGfxBank1_toDd001_@return +(byte*) main::vicSelectGfxBank1_toDd001_gfx +(byte*) main::vicSelectGfxBank1_toDd001_gfx#0 +(byte*) main::vicSelectGfxBank1_toDd001_gfx#1 +(byte) main::vicSelectGfxBank1_toDd001_return +(byte) main::vicSelectGfxBank1_toDd001_return#0 +(byte) main::vicSelectGfxBank1_toDd001_return#1 +(byte) main::vicSelectGfxBank1_toDd001_return#2 +(byte) main::vicSelectGfxBank1_toDd001_return#3 +(label) main::vicSelectGfxBank2 +(byte~) main::vicSelectGfxBank2_$0 +(label) main::vicSelectGfxBank2_@1 +(byte*) main::vicSelectGfxBank2_gfx +(byte*) main::vicSelectGfxBank2_gfx#0 +(byte*) main::vicSelectGfxBank2_gfx#1 +(label) main::vicSelectGfxBank2_toDd001 +(word~) main::vicSelectGfxBank2_toDd001_$0 +(byte~) main::vicSelectGfxBank2_toDd001_$1 +(number~) main::vicSelectGfxBank2_toDd001_$2 +(number~) main::vicSelectGfxBank2_toDd001_$3 +(label) main::vicSelectGfxBank2_toDd001_@return +(byte*) main::vicSelectGfxBank2_toDd001_gfx +(byte*) main::vicSelectGfxBank2_toDd001_gfx#0 +(byte*) main::vicSelectGfxBank2_toDd001_gfx#1 +(byte) main::vicSelectGfxBank2_toDd001_return +(byte) main::vicSelectGfxBank2_toDd001_return#0 +(byte) main::vicSelectGfxBank2_toDd001_return#1 +(byte) main::vicSelectGfxBank2_toDd001_return#2 +(byte) main::vicSelectGfxBank2_toDd001_return#3 +(signed word) main::x +(signed word) main::x#0 +(signed word) main::x#1 +(signed word) main::y +(signed word) main::y#0 +(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num) +(bool~) memset::$0 +(bool~) memset::$1 +(byte*~) memset::$2 +(byte*~) memset::$3 +(bool~) memset::$4 +(label) memset::@1 +(label) memset::@2 +(label) memset::@4 +(label) memset::@5 +(label) memset::@return +(byte) memset::c +(byte) memset::c#0 +(byte) memset::c#1 +(byte) memset::c#2 +(byte) memset::c#3 +(byte) memset::c#4 +(byte*) memset::dst +(byte*) memset::dst#0 +(byte*) memset::dst#1 +(byte*) memset::dst#2 +(byte*) memset::dst#3 +(byte*) memset::end +(byte*) memset::end#0 +(byte*) memset::end#1 +(byte*) memset::end#2 +(word) memset::num +(word) memset::num#0 +(word) memset::num#1 +(word) memset::num#2 +(void*) memset::return +(void*) memset::return#0 +(void*) memset::return#1 +(void*) memset::return#2 +(void*) memset::return#3 +(void*) memset::str +(void*) memset::str#0 +(void*) memset::str#1 +(void*) memset::str#2 +(void*) memset::str#3 +(void*) memset::str#4 +(void*) memset::str#5 +(signed word()) mulf8s((signed byte) mulf8s::a , (signed byte) mulf8s::b) +(signed word~) mulf8s::$1 +(label) mulf8s::@2 +(label) mulf8s::@3 +(label) mulf8s::@4 +(label) mulf8s::@return +(signed byte) mulf8s::a +(signed byte) mulf8s::a#0 +(signed byte) mulf8s::a#1 +(signed byte) mulf8s::a#2 +(signed byte) mulf8s::b +(signed byte) mulf8s::b#0 +(signed byte) mulf8s::b#1 +(signed byte) mulf8s::b#2 +(signed byte) mulf8s::b#3 +(signed byte) mulf8s::b#4 +(signed byte) mulf8s::b#5 +(label) mulf8s::mulf8s_prepare1 +(byte~) mulf8s::mulf8s_prepare1_$0 +(signed byte) mulf8s::mulf8s_prepare1_a +(signed byte) mulf8s::mulf8s_prepare1_a#0 +(signed byte) mulf8s::mulf8s_prepare1_a#1 +(signed word) mulf8s::return +(signed word) mulf8s::return#0 +(signed word) mulf8s::return#1 +(signed word) mulf8s::return#2 +(signed word) mulf8s::return#3 +(signed word) mulf8s::return#4 +(signed word) mulf8s::return#5 +(signed word) mulf8s::return#6 +(signed word()) mulf8s_prepared((signed byte) mulf8s_prepared::b) +(byte~) mulf8s_prepared::$0 +(word~) mulf8s_prepared::$1 +(byte~) mulf8s_prepared::$10 +(byte~) mulf8s_prepared::$12 +(byte~) mulf8s_prepared::$13 +(byte~) mulf8s_prepared::$14 +(byte~) mulf8s_prepared::$15 +(byte~) mulf8s_prepared::$16 +(bool~) mulf8s_prepared::$2 +(bool~) mulf8s_prepared::$3 +(bool~) mulf8s_prepared::$4 +(bool~) mulf8s_prepared::$5 +(signed word~) mulf8s_prepared::$6 +(byte~) mulf8s_prepared::$8 +(byte~) mulf8s_prepared::$9 +(label) mulf8s_prepared::@1 +(label) mulf8s_prepared::@2 +(label) mulf8s_prepared::@3 +(label) mulf8s_prepared::@4 +(label) mulf8s_prepared::@6 +(label) mulf8s_prepared::@return +(signed byte) mulf8s_prepared::b +(signed byte) mulf8s_prepared::b#0 +(signed byte) mulf8s_prepared::b#1 +(signed byte) mulf8s_prepared::b#2 +(signed byte) mulf8s_prepared::b#3 +(signed byte) mulf8s_prepared::b#4 +(word) mulf8s_prepared::m +(word) mulf8s_prepared::m#0 +(word) mulf8s_prepared::m#1 +(word) mulf8s_prepared::m#2 +(word) mulf8s_prepared::m#3 +(word) mulf8s_prepared::m#4 +(word) mulf8s_prepared::m#5 +(word) mulf8s_prepared::m#6 +(const signed byte*) mulf8s_prepared::memA = (signed byte*)(number) $fd +(signed word) mulf8s_prepared::return +(signed word) mulf8s_prepared::return#0 +(signed word) mulf8s_prepared::return#1 +(signed word) mulf8s_prepared::return#2 +(signed word) mulf8s_prepared::return#3 +(signed word) mulf8s_prepared::return#4 +(void()) mulf8u_prepare((byte) mulf8u_prepare::a) +(label) mulf8u_prepare::@return +(byte) mulf8u_prepare::a +(byte) mulf8u_prepare::a#0 +(byte) mulf8u_prepare::a#1 +(const byte*) mulf8u_prepare::memA = (byte*)(number) $fd +(word()) mulf8u_prepared((byte) mulf8u_prepared::b) +(label) mulf8u_prepared::@return +(byte) mulf8u_prepared::b +(byte) mulf8u_prepared::b#0 +(byte) mulf8u_prepared::b#1 +(const byte*) mulf8u_prepared::memB = (byte*)(number) $ff +(const byte*) mulf8u_prepared::resL = (byte*)(number) $fe +(word) mulf8u_prepared::return +(word) mulf8u_prepared::return#0 +(word) mulf8u_prepared::return#1 +(word) mulf8u_prepared::return#2 +(word) mulf8u_prepared::return#3 +(word) mulf8u_prepared::return#4 +(void()) mulf_init() +(bool~) mulf_init::$0 +(number~) mulf_init::$1 +(bool~) mulf_init::$10 +(bool~) mulf_init::$2 +(bool~) mulf_init::$3 +(byte~) mulf_init::$4 +(byte~) mulf_init::$5 +(word~) mulf_init::$6 +(bool~) mulf_init::$7 +(byte~) mulf_init::$8 +(bool~) mulf_init::$9 +(label) mulf_init::@1 +(label) mulf_init::@10 +(label) mulf_init::@11 +(label) mulf_init::@12 +(label) mulf_init::@15 +(label) mulf_init::@2 +(label) mulf_init::@3 +(label) mulf_init::@4 +(label) mulf_init::@7 +(label) mulf_init::@9 +(label) mulf_init::@return +(byte) mulf_init::c +(byte) mulf_init::c#0 +(byte) mulf_init::c#1 +(byte) mulf_init::c#2 +(byte) mulf_init::c#3 +(byte) mulf_init::c#4 +(byte) mulf_init::c#5 +(byte) mulf_init::dir +(byte) mulf_init::dir#0 +(byte) mulf_init::dir#1 +(byte) mulf_init::dir#2 +(byte) mulf_init::dir#3 +(byte) mulf_init::dir#4 +(word) mulf_init::sqr +(word) mulf_init::sqr#0 +(word) mulf_init::sqr#1 +(word) mulf_init::sqr#2 +(word) mulf_init::sqr#3 +(word) mulf_init::sqr#4 +(word) mulf_init::sqr#5 +(word) mulf_init::sqr#6 +(byte*) mulf_init::sqr1_hi +(byte*) mulf_init::sqr1_hi#0 +(byte*) mulf_init::sqr1_hi#1 +(byte*) mulf_init::sqr1_hi#2 +(byte*) mulf_init::sqr1_hi#3 +(byte*) mulf_init::sqr1_hi#4 +(byte*) mulf_init::sqr1_hi#5 +(byte*) mulf_init::sqr1_lo +(byte*) mulf_init::sqr1_lo#0 +(byte*) mulf_init::sqr1_lo#1 +(byte*) mulf_init::sqr1_lo#2 +(byte*) mulf_init::sqr1_lo#3 +(byte*) mulf_init::sqr1_lo#4 +(byte*) mulf_init::sqr1_lo#5 +(byte*) mulf_init::sqr2_hi +(byte*) mulf_init::sqr2_hi#0 +(byte*) mulf_init::sqr2_hi#1 +(byte*) mulf_init::sqr2_hi#2 +(byte*) mulf_init::sqr2_hi#3 +(byte*) mulf_init::sqr2_hi#4 +(byte*) mulf_init::sqr2_hi#5 +(byte*) mulf_init::sqr2_lo +(byte*) mulf_init::sqr2_lo#0 +(byte*) mulf_init::sqr2_lo#1 +(byte*) mulf_init::sqr2_lo#2 +(byte*) mulf_init::sqr2_lo#3 +(byte*) mulf_init::sqr2_lo#4 +(byte*) mulf_init::sqr2_lo#5 +(byte) mulf_init::x_2 +(byte) mulf_init::x_2#0 +(byte) mulf_init::x_2#1 +(byte) mulf_init::x_2#2 +(byte) mulf_init::x_2#3 +(byte) mulf_init::x_2#4 +(byte) mulf_init::x_2#5 +(byte) mulf_init::x_255 +(byte) mulf_init::x_255#0 +(byte) mulf_init::x_255#1 +(byte) mulf_init::x_255#2 +(byte) mulf_init::x_255#3 +(byte) mulf_init::x_255#4 +(byte) mulf_init::x_255#5 +(const byte*) mulf_sqr1_hi = { fill( $200, 0) } +(const byte*) mulf_sqr1_lo = { fill( $200, 0) } +(const byte*) mulf_sqr2_hi = { fill( $200, 0) } +(const byte*) mulf_sqr2_lo = { fill( $200, 0) } +(void()) prepareBobs() +(bool~) prepareBobs::$2 +(bool~) prepareBobs::$3 +(byte*~) prepareBobs::$4 +(bool~) prepareBobs::$5 +(byte~) prepareBobs::$6 +(label) prepareBobs::@1 +(label) prepareBobs::@19 +(label) prepareBobs::@2 +(label) prepareBobs::@20 +(label) prepareBobs::@21 +(label) prepareBobs::@22 +(label) prepareBobs::@23 +(label) prepareBobs::@24 +(label) prepareBobs::@25 +(label) prepareBobs::@4 +(label) prepareBobs::@5 +(label) prepareBobs::@6 +(label) prepareBobs::@7 +(label) prepareBobs::@8 +(label) prepareBobs::@9 +(label) prepareBobs::@return +(byte*) prepareBobs::bob_glyph +(byte*) prepareBobs::bob_glyph#0 +(byte*) prepareBobs::bob_glyph#1 +(byte*) prepareBobs::bob_glyph#2 +(byte*) prepareBobs::bob_glyph#3 +(byte*) prepareBobs::bob_glyph#4 +(byte*) prepareBobs::bob_glyph#5 +(byte*) prepareBobs::bob_table +(byte*) prepareBobs::bob_table#0 +(byte*) prepareBobs::bob_table#1 +(byte*) prepareBobs::bob_table#2 +(byte*) prepareBobs::bob_table#3 +(byte*) prepareBobs::bob_table#4 +(byte*) prepareBobs::bob_table#5 +(byte) prepareBobs::bob_table_idx +(byte) prepareBobs::bob_table_idx#0 +(byte) prepareBobs::bob_table_idx#1 +(byte) prepareBobs::bob_table_idx#10 +(byte) prepareBobs::bob_table_idx#11 +(byte) prepareBobs::bob_table_idx#12 +(byte) prepareBobs::bob_table_idx#13 +(byte) prepareBobs::bob_table_idx#14 +(byte) prepareBobs::bob_table_idx#2 +(byte) prepareBobs::bob_table_idx#3 +(byte) prepareBobs::bob_table_idx#4 +(byte) prepareBobs::bob_table_idx#5 +(byte) prepareBobs::bob_table_idx#6 +(byte) prepareBobs::bob_table_idx#7 +(byte) prepareBobs::bob_table_idx#8 +(byte) prepareBobs::bob_table_idx#9 +(byte) prepareBobs::cell +(byte) prepareBobs::cell#0 +(byte) prepareBobs::cell#1 +(byte) prepareBobs::cell#2 +(byte) prepareBobs::cell#3 +(byte) prepareBobs::cell#4 +(byte) prepareBobs::cell#5 +(byte) prepareBobs::shift_x +(byte) prepareBobs::shift_x#0 +(byte) prepareBobs::shift_x#1 +(byte) prepareBobs::shift_x#10 +(byte) prepareBobs::shift_x#2 +(byte) prepareBobs::shift_x#3 +(byte) prepareBobs::shift_x#4 +(byte) prepareBobs::shift_x#5 +(byte) prepareBobs::shift_x#6 +(byte) prepareBobs::shift_x#7 +(byte) prepareBobs::shift_x#8 +(byte) prepareBobs::shift_x#9 +(byte) prepareBobs::shift_y +(byte) prepareBobs::shift_y#0 +(byte) prepareBobs::shift_y#1 +(byte) prepareBobs::shift_y#10 +(byte) prepareBobs::shift_y#11 +(byte) prepareBobs::shift_y#12 +(byte) prepareBobs::shift_y#13 +(byte) prepareBobs::shift_y#14 +(byte) prepareBobs::shift_y#2 +(byte) prepareBobs::shift_y#3 +(byte) prepareBobs::shift_y#4 +(byte) prepareBobs::shift_y#5 +(byte) prepareBobs::shift_y#6 +(byte) prepareBobs::shift_y#7 +(byte) prepareBobs::shift_y#8 +(byte) prepareBobs::shift_y#9 +(byte*) progress_cursor +(byte*) progress_cursor#0 +(byte*) progress_cursor#1 +(byte*) progress_cursor#10 +(byte*) progress_cursor#11 +(byte*) progress_cursor#12 +(byte*) progress_cursor#13 +(byte*) progress_cursor#14 +(byte*) progress_cursor#15 +(byte*) progress_cursor#16 +(byte*) progress_cursor#17 +(byte*) progress_cursor#18 +(byte*) progress_cursor#19 +(byte*) progress_cursor#2 +(byte*) progress_cursor#20 +(byte*) progress_cursor#21 +(byte*) progress_cursor#22 +(byte*) progress_cursor#23 +(byte*) progress_cursor#24 +(byte*) progress_cursor#25 +(byte*) progress_cursor#26 +(byte*) progress_cursor#27 +(byte*) progress_cursor#28 +(byte*) progress_cursor#29 +(byte*) progress_cursor#3 +(byte*) progress_cursor#30 +(byte*) progress_cursor#31 +(byte*) progress_cursor#32 +(byte*) progress_cursor#33 +(byte*) progress_cursor#34 +(byte*) progress_cursor#35 +(byte*) progress_cursor#36 +(byte*) progress_cursor#37 +(byte*) progress_cursor#38 +(byte*) progress_cursor#39 +(byte*) progress_cursor#4 +(byte*) progress_cursor#40 +(byte*) progress_cursor#41 +(byte*) progress_cursor#42 +(byte*) progress_cursor#43 +(byte*) progress_cursor#44 +(byte*) progress_cursor#45 +(byte*) progress_cursor#46 +(byte*) progress_cursor#47 +(byte*) progress_cursor#48 +(byte*) progress_cursor#49 +(byte*) progress_cursor#5 +(byte*) progress_cursor#50 +(byte*) progress_cursor#51 +(byte*) progress_cursor#52 +(byte*) progress_cursor#53 +(byte*) progress_cursor#54 +(byte*) progress_cursor#55 +(byte*) progress_cursor#56 +(byte*) progress_cursor#57 +(byte*) progress_cursor#58 +(byte*) progress_cursor#59 +(byte*) progress_cursor#6 +(byte*) progress_cursor#60 +(byte*) progress_cursor#61 +(byte*) progress_cursor#62 +(byte*) progress_cursor#63 +(byte*) progress_cursor#64 +(byte*) progress_cursor#65 +(byte*) progress_cursor#66 +(byte*) progress_cursor#67 +(byte*) progress_cursor#68 +(byte*) progress_cursor#69 +(byte*) progress_cursor#7 +(byte*) progress_cursor#8 +(byte*) progress_cursor#9 +(byte) progress_idx +(byte) progress_idx#0 +(byte) progress_idx#1 +(byte) progress_idx#10 +(byte) progress_idx#11 +(byte) progress_idx#12 +(byte) progress_idx#13 +(byte) progress_idx#14 +(byte) progress_idx#15 +(byte) progress_idx#16 +(byte) progress_idx#17 +(byte) progress_idx#18 +(byte) progress_idx#19 +(byte) progress_idx#2 +(byte) progress_idx#20 +(byte) progress_idx#21 +(byte) progress_idx#22 +(byte) progress_idx#23 +(byte) progress_idx#24 +(byte) progress_idx#25 +(byte) progress_idx#26 +(byte) progress_idx#27 +(byte) progress_idx#28 +(byte) progress_idx#29 +(byte) progress_idx#3 +(byte) progress_idx#30 +(byte) progress_idx#31 +(byte) progress_idx#32 +(byte) progress_idx#33 +(byte) progress_idx#34 +(byte) progress_idx#35 +(byte) progress_idx#36 +(byte) progress_idx#37 +(byte) progress_idx#38 +(byte) progress_idx#39 +(byte) progress_idx#4 +(byte) progress_idx#40 +(byte) progress_idx#41 +(byte) progress_idx#42 +(byte) progress_idx#43 +(byte) progress_idx#44 +(byte) progress_idx#45 +(byte) progress_idx#46 +(byte) progress_idx#47 +(byte) progress_idx#48 +(byte) progress_idx#49 +(byte) progress_idx#5 +(byte) progress_idx#50 +(byte) progress_idx#51 +(byte) progress_idx#52 +(byte) progress_idx#53 +(byte) progress_idx#54 +(byte) progress_idx#55 +(byte) progress_idx#56 +(byte) progress_idx#57 +(byte) progress_idx#58 +(byte) progress_idx#59 +(byte) progress_idx#6 +(byte) progress_idx#60 +(byte) progress_idx#61 +(byte) progress_idx#62 +(byte) progress_idx#63 +(byte) progress_idx#64 +(byte) progress_idx#65 +(byte) progress_idx#66 +(byte) progress_idx#67 +(byte) progress_idx#68 +(byte) progress_idx#69 +(byte) progress_idx#7 +(byte) progress_idx#8 +(byte) progress_idx#9 +(void()) progress_inc() +(bool~) progress_inc::$0 +(bool~) progress_inc::$1 +(label) progress_inc::@1 +(label) progress_inc::@2 +(label) progress_inc::@return +(const byte*) progress_inc::progress_chars = { (byte)(number) $20, (byte)(number) $65, (byte)(number) $74, (byte)(number) $75, (byte)(number) $61, (byte)(number) $f6, (byte)(number) $e7, (byte)(number) $ea, (byte)(number) $e0 } +(void()) progress_init((byte*) progress_init::line) +(label) progress_init::@return +(byte*) progress_init::line +(byte*) progress_init::line#0 +(byte*) progress_init::line#1 +(void()) protoBobShiftDown() +(bool~) protoBobShiftDown::$0 +(label) protoBobShiftDown::@1 +(label) protoBobShiftDown::@2 +(label) protoBobShiftDown::@3 +(label) protoBobShiftDown::@return +(byte) protoBobShiftDown::i +(byte) protoBobShiftDown::i#0 +(byte) protoBobShiftDown::i#1 +(byte) protoBobShiftDown::i#2 +(byte) protoBobShiftDown::i#3 +(void()) protoBobShiftRight() +(bool~) protoBobShiftRight::$0 +(number~) protoBobShiftRight::$1 +(byte~) protoBobShiftRight::$2 +(byte~) protoBobShiftRight::$3 +(byte~) protoBobShiftRight::$4 +(byte~) protoBobShiftRight::$5 +(byte~) protoBobShiftRight::$6 +(bool~) protoBobShiftRight::$7 +(bool~) protoBobShiftRight::$8 +(label) protoBobShiftRight::@1 +(label) protoBobShiftRight::@13 +(label) protoBobShiftRight::@2 +(label) protoBobShiftRight::@4 +(label) protoBobShiftRight::@5 +(label) protoBobShiftRight::@6 +(label) protoBobShiftRight::@7 +(label) protoBobShiftRight::@8 +(label) protoBobShiftRight::@return +(byte) protoBobShiftRight::carry +(byte) protoBobShiftRight::carry#0 +(byte) protoBobShiftRight::carry#1 +(byte) protoBobShiftRight::carry#2 +(byte) protoBobShiftRight::carry#3 +(byte) protoBobShiftRight::carry#4 +(byte) protoBobShiftRight::carry#5 +(byte) protoBobShiftRight::carry#6 +(byte) protoBobShiftRight::carry#7 +(byte) protoBobShiftRight::carry#8 +(byte) protoBobShiftRight::carry#9 +(byte) protoBobShiftRight::i +(byte) protoBobShiftRight::i#0 +(byte) protoBobShiftRight::i#1 +(byte) protoBobShiftRight::i#2 +(byte) protoBobShiftRight::i#3 +(byte) protoBobShiftRight::i#4 +(byte) protoBobShiftRight::i#5 +(byte) protoBobShiftRight::i#6 +(byte) protoBobShiftRight::i#7 +(byte) protoBobShiftRight::i#8 +(byte) protoBobShiftRight::i#9 +(byte) protoBobShiftRight::j +(byte) protoBobShiftRight::j#0 +(byte) protoBobShiftRight::j#1 +(byte) protoBobShiftRight::j#10 +(byte) protoBobShiftRight::j#2 +(byte) protoBobShiftRight::j#3 +(byte) protoBobShiftRight::j#4 +(byte) protoBobShiftRight::j#5 +(byte) protoBobShiftRight::j#6 +(byte) protoBobShiftRight::j#7 +(byte) protoBobShiftRight::j#8 +(byte) protoBobShiftRight::j#9 +(byte) protoBobShiftRight::new_carry +(byte) protoBobShiftRight::new_carry#0 +(void()) renderBob((byte) renderBob::xpos , (byte) renderBob::ypos) +(byte~) renderBob::$0 +(byte~) renderBob::$1 +(byte*~) renderBob::$2 +(byte*~) renderBob::$3 +(number~) renderBob::$4 +(number~) renderBob::$5 +(number~) renderBob::$6 +(number~) renderBob::$7 +(byte~) renderBob::$8 +(label) renderBob::@return +(byte) renderBob::bob_table_idx +(byte) renderBob::bob_table_idx#0 +(byte*) renderBob::screen +(byte*) renderBob::screen#0 +(byte) renderBob::x_char_offset +(byte) renderBob::x_char_offset#0 +(byte) renderBob::xpos +(byte) renderBob::xpos#0 +(byte) renderBob::xpos#1 +(byte) renderBob::y_char_offset +(byte) renderBob::y_char_offset#0 +(word) renderBob::y_offset +(word) renderBob::y_offset#0 +(byte) renderBob::ypos +(byte) renderBob::ypos#0 +(byte) renderBob::ypos#1 +(void()) renderBobCleanup() +(bool~) renderBobCleanup::$0 +(byte~) renderBobCleanup::$1 +(label) renderBobCleanup::@1 +(label) renderBobCleanup::@2 +(label) renderBobCleanup::@return +(byte) renderBobCleanup::i +(byte) renderBobCleanup::i#0 +(byte) renderBobCleanup::i#1 +(byte) renderBobCleanup::i#2 +(byte*) renderBobCleanup::screen +(byte*) renderBobCleanup::screen#0 +(byte**) renderBobCleanupNext +(byte**) renderBobCleanupNext#0 +(byte**) renderBobCleanupNext#1 +(byte**) renderBobCleanupNext#10 +(byte**) renderBobCleanupNext#11 +(byte**) renderBobCleanupNext#12 +(byte**) renderBobCleanupNext#13 +(byte**) renderBobCleanupNext#14 +(byte**) renderBobCleanupNext#15 +(byte**) renderBobCleanupNext#16 +(byte**) renderBobCleanupNext#17 +(byte**) renderBobCleanupNext#18 +(byte**) renderBobCleanupNext#19 +(byte**) renderBobCleanupNext#2 +(byte**) renderBobCleanupNext#20 +(byte**) renderBobCleanupNext#21 +(byte**) renderBobCleanupNext#22 +(byte**) renderBobCleanupNext#23 +(byte**) renderBobCleanupNext#24 +(byte**) renderBobCleanupNext#25 +(byte**) renderBobCleanupNext#26 +(byte**) renderBobCleanupNext#27 +(byte**) renderBobCleanupNext#28 +(byte**) renderBobCleanupNext#29 +(byte**) renderBobCleanupNext#3 +(byte**) renderBobCleanupNext#30 +(byte**) renderBobCleanupNext#31 +(byte**) renderBobCleanupNext#32 +(byte**) renderBobCleanupNext#33 +(byte**) renderBobCleanupNext#34 +(byte**) renderBobCleanupNext#35 +(byte**) renderBobCleanupNext#36 +(byte**) renderBobCleanupNext#37 +(byte**) renderBobCleanupNext#38 +(byte**) renderBobCleanupNext#39 +(byte**) renderBobCleanupNext#4 +(byte**) renderBobCleanupNext#40 +(byte**) renderBobCleanupNext#41 +(byte**) renderBobCleanupNext#42 +(byte**) renderBobCleanupNext#43 +(byte**) renderBobCleanupNext#44 +(byte**) renderBobCleanupNext#45 +(byte**) renderBobCleanupNext#46 +(byte**) renderBobCleanupNext#47 +(byte**) renderBobCleanupNext#48 +(byte**) renderBobCleanupNext#49 +(byte**) renderBobCleanupNext#5 +(byte**) renderBobCleanupNext#50 +(byte**) renderBobCleanupNext#6 +(byte**) renderBobCleanupNext#7 +(byte**) renderBobCleanupNext#8 +(byte**) renderBobCleanupNext#9 +(void()) renderBobInit() +(word~) renderBobInit::$0 +(number~) renderBobInit::$1 +(bool~) renderBobInit::$2 +(bool~) renderBobInit::$3 +(byte~) renderBobInit::$4 +(byte~) renderBobInit::$5 +(label) renderBobInit::@1 +(label) renderBobInit::@2 +(label) renderBobInit::@3 +(label) renderBobInit::@return +(byte) renderBobInit::i +(byte) renderBobInit::i#0 +(byte) renderBobInit::i#1 +(byte) renderBobInit::i#2 +(byte) renderBobInit::y +(byte) renderBobInit::y#0 +(byte) renderBobInit::y#1 +(byte) renderBobInit::y#2 + +Fixing inline constructor with mulf8u_prepared::$0 ← (byte)*(mulf8u_prepared::memB) w= (byte)*(mulf8u_prepared::resL) +Successful SSA optimization Pass2FixInlineConstructors +Adding number conversion cast (unumber) $40 in +Adding number conversion cast (unumber) 0 in (bool~) memset::$0 ← (word) memset::num#1 > (number) 0 +Adding number conversion cast (unumber) 7 in (number~) keyboard_key_pressed::$0 ← (byte) keyboard_key_pressed::key#2 & (number) 7 +Adding number conversion cast (unumber) keyboard_key_pressed::$0 in (number~) keyboard_key_pressed::$0 ← (byte) keyboard_key_pressed::key#2 & (unumber)(number) 7 +Adding number conversion cast (unumber) 3 in (byte~) keyboard_key_pressed::$1 ← (byte) keyboard_key_pressed::key#2 >> (number) 3 +Adding number conversion cast (unumber) 0 in (word) mulf_init::sqr#0 ← (number) 0 +Adding number conversion cast (unumber) 0 in (byte) mulf_init::x_2#0 ← (number) 0 +Adding number conversion cast (unumber) 0 in (byte) mulf_init::c#0 ← (number) 0 +Adding number conversion cast (unumber) 1 in (byte*) mulf_init::sqr1_hi#0 ← (const byte*) mulf_sqr1_hi+(number) 1 +Adding number conversion cast (unumber) 1 in (byte*) mulf_init::sqr1_lo#0 ← (const byte*) mulf_sqr1_lo+(number) 1 +Adding number conversion cast (unumber) $200 in (bool~) mulf_init::$0 ← (byte*) mulf_init::sqr1_lo#2 != (const byte*) mulf_sqr1_lo+(number) $200 +Adding number conversion cast (unumber) 1 in (number~) mulf_init::$1 ← (byte) mulf_init::c#1 & (number) 1 +Adding number conversion cast (unumber) mulf_init::$1 in (number~) mulf_init::$1 ← (byte) mulf_init::c#1 & (unumber)(number) 1 +Adding number conversion cast (unumber) 0 in (bool~) mulf_init::$2 ← (unumber~) mulf_init::$1 == (number) 0 +Adding number conversion cast (unumber) $ff in (byte) mulf_init::dir#0 ← (number) $ff +Adding number conversion cast (unumber) $1ff in (bool~) mulf_init::$7 ← (byte*) mulf_init::sqr2_lo#2 != (const byte*) mulf_sqr2_lo+(number) $1ff +Adding number conversion cast (unumber) 0 in (bool~) mulf_init::$9 ← (byte) mulf_init::x_255#1 == (number) 0 +Adding number conversion cast (unumber) $100 in *((const byte*) mulf_sqr2_lo+(number) $1ff) ← *((const byte*) mulf_sqr1_lo+(number) $100) +Adding number conversion cast (unumber) $1ff in *((const byte*) mulf_sqr2_lo+(number) $1ff) ← *((const byte*) mulf_sqr1_lo+(unumber)(number) $100) +Adding number conversion cast (unumber) $100 in *((const byte*) mulf_sqr2_hi+(number) $1ff) ← *((const byte*) mulf_sqr1_hi+(number) $100) +Adding number conversion cast (unumber) $1ff in *((const byte*) mulf_sqr2_hi+(number) $1ff) ← *((const byte*) mulf_sqr1_hi+(unumber)(number) $100) +Adding number conversion cast (unumber) 1 in (byte) mulf_init::dir#1 ← (number) 1 +Adding number conversion cast (snumber) 0 in (bool~) mulf8s_prepared::$2 ← *((const signed byte*) mulf8s_prepared::memA) < (number) 0 +Adding number conversion cast (snumber) 0 in (bool~) mulf8s_prepared::$4 ← (signed byte) mulf8s_prepared::b#2 < (number) 0 +Adding number conversion cast (unumber) 3 in *((const byte*) CIA2_PORT_A_DDR) ← (number) 3 +Adding number conversion cast (unumber) $40 in (number~) main::vicSelectGfxBank1_toDd001_$2 ← (byte~) main::vicSelectGfxBank1_toDd001_$1 / (number) $40 +Adding number conversion cast (unumber) main::vicSelectGfxBank1_toDd001_$2 in (number~) main::vicSelectGfxBank1_toDd001_$2 ← (byte~) main::vicSelectGfxBank1_toDd001_$1 / (unumber)(number) $40 +Adding number conversion cast (unumber) 3 in (number~) main::vicSelectGfxBank1_toDd001_$3 ← (number) 3 ^ (unumber~) main::vicSelectGfxBank1_toDd001_$2 +Adding number conversion cast (unumber) main::vicSelectGfxBank1_toDd001_$3 in (number~) main::vicSelectGfxBank1_toDd001_$3 ← (unumber)(number) 3 ^ (unumber~) main::vicSelectGfxBank1_toDd001_$2 +Adding number conversion cast (unumber) $3fff in (number~) main::toD0181_$1 ← (word~) main::toD0181_$0 & (number) $3fff +Adding number conversion cast (unumber) main::toD0181_$1 in (number~) main::toD0181_$1 ← (word~) main::toD0181_$0 & (unumber)(number) $3fff +Adding number conversion cast (unumber) 4 in (number~) main::toD0181_$2 ← (unumber~) main::toD0181_$1 * (number) 4 +Adding number conversion cast (unumber) main::toD0181_$2 in (number~) main::toD0181_$2 ← (unumber~) main::toD0181_$1 * (unumber)(number) 4 +Adding number conversion cast (unumber) main::toD0181_$3 in (number~) main::toD0181_$3 ← > (unumber~) main::toD0181_$2 +Adding number conversion cast (unumber) 4 in (number~) main::toD0181_$6 ← (byte~) main::toD0181_$5 / (number) 4 +Adding number conversion cast (unumber) main::toD0181_$6 in (number~) main::toD0181_$6 ← (byte~) main::toD0181_$5 / (unumber)(number) 4 +Adding number conversion cast (unumber) $f in (number~) main::toD0181_$7 ← (unumber~) main::toD0181_$6 & (number) $f +Adding number conversion cast (unumber) main::toD0181_$7 in (number~) main::toD0181_$7 ← (unumber~) main::toD0181_$6 & (unumber)(number) $f +Adding number conversion cast (unumber) main::toD0181_$8 in (number~) main::toD0181_$8 ← (unumber~) main::toD0181_$3 | (unumber~) main::toD0181_$7 +Adding number conversion cast (unumber) 0 in (byte) memset::c#0 ← (number) 0 +Adding number conversion cast (unumber) $3e8 in (word) memset::num#0 ← (number) $3e8 +Adding number conversion cast (unumber) 0 in (byte) main::angle#0 ← (number) 0 +Adding number conversion cast (unumber) $f8 in (bool~) main::$8 ← *((const byte*) RASTER) < (number) $f8 +Adding number conversion cast (unumber) $f in *((const byte*) BORDERCOL) ← (number) $f +Adding number conversion cast (snumber) $1e in (signed byte) main::r#0 ← (number) $1e +Adding number conversion cast (unumber) 1 in *((const byte*) BORDERCOL) ← (number) 1 +Adding number conversion cast (snumber) $4b*$100 in (number~) main::$11 ← (signed word~) main::$10 + (number) $4b*(number) $100 +Adding number conversion cast (snumber) main::$11 in (number~) main::$11 ← (signed word~) main::$10 + (snumber)(number) $4b*(number) $100 +Adding number conversion cast (snumber) 2 in (number~) main::$13 ← (signed word~) main::$12 * (number) 2 +Adding number conversion cast (snumber) main::$13 in (number~) main::$13 ← (signed word~) main::$12 * (snumber)(number) 2 +Adding number conversion cast (snumber) $5a*$100 in (number~) main::$14 ← (snumber~) main::$13 + (number) $5a*(number) $100 +Adding number conversion cast (snumber) main::$14 in (number~) main::$14 ← (snumber~) main::$13 + (snumber)(number) $5a*(number) $100 +Adding number conversion cast (unumber) 2 in *((const byte*) BORDERCOL) ← (number) 2 +Adding number conversion cast (unumber) $62 in (byte) main::a#1 ← (byte) main::a#4 + (number) $62 +Adding number conversion cast (snumber) 3 in (signed byte) main::r#1 ← (signed byte) main::r#4 + (number) 3 +Adding number conversion cast (unumber) 1 in (byte) main::i#1 ← (byte) main::i#2 + rangenext(0,NUM_BOBS-1) +Adding number conversion cast (unumber) 3 in (byte) main::angle#1 ← (byte) main::angle#3 + (number) 3 +Adding number conversion cast (unumber) 0 in *((const byte*) BORDERCOL) ← (number) 0 +Adding number conversion cast (unumber) 0 in (bool~) main::$23 ← (number) 0 != (byte~) main::$19 +Adding number conversion cast (unumber) 0 in (bool~) main::$22 ← (number) 0 != (byte~) main::$21 +Adding number conversion cast (unumber) 3 in *((const byte*) CIA2_PORT_A_DDR) ← (number) 3 +Adding number conversion cast (unumber) $40 in (number~) main::vicSelectGfxBank2_toDd001_$2 ← (byte~) main::vicSelectGfxBank2_toDd001_$1 / (number) $40 +Adding number conversion cast (unumber) main::vicSelectGfxBank2_toDd001_$2 in (number~) main::vicSelectGfxBank2_toDd001_$2 ← (byte~) main::vicSelectGfxBank2_toDd001_$1 / (unumber)(number) $40 +Adding number conversion cast (unumber) 3 in (number~) main::vicSelectGfxBank2_toDd001_$3 ← (number) 3 ^ (unumber~) main::vicSelectGfxBank2_toDd001_$2 +Adding number conversion cast (unumber) main::vicSelectGfxBank2_toDd001_$3 in (number~) main::vicSelectGfxBank2_toDd001_$3 ← (unumber)(number) 3 ^ (unumber~) main::vicSelectGfxBank2_toDd001_$2 +Adding number conversion cast (unumber) $3fff in (number~) main::toD0182_$1 ← (word~) main::toD0182_$0 & (number) $3fff +Adding number conversion cast (unumber) main::toD0182_$1 in (number~) main::toD0182_$1 ← (word~) main::toD0182_$0 & (unumber)(number) $3fff +Adding number conversion cast (unumber) 4 in (number~) main::toD0182_$2 ← (unumber~) main::toD0182_$1 * (number) 4 +Adding number conversion cast (unumber) main::toD0182_$2 in (number~) main::toD0182_$2 ← (unumber~) main::toD0182_$1 * (unumber)(number) 4 +Adding number conversion cast (unumber) main::toD0182_$3 in (number~) main::toD0182_$3 ← > (unumber~) main::toD0182_$2 +Adding number conversion cast (unumber) 4 in (number~) main::toD0182_$6 ← (byte~) main::toD0182_$5 / (number) 4 +Adding number conversion cast (unumber) main::toD0182_$6 in (number~) main::toD0182_$6 ← (byte~) main::toD0182_$5 / (unumber)(number) 4 +Adding number conversion cast (unumber) $f in (number~) main::toD0182_$7 ← (unumber~) main::toD0182_$6 & (number) $f +Adding number conversion cast (unumber) main::toD0182_$7 in (number~) main::toD0182_$7 ← (unumber~) main::toD0182_$6 & (unumber)(number) $f +Adding number conversion cast (unumber) main::toD0182_$8 in (number~) main::toD0182_$8 ← (unumber~) main::toD0182_$3 | (unumber~) main::toD0182_$7 +Adding number conversion cast (unumber) $28 in (number~) renderBobInit::$1 ← (word~) renderBobInit::$0 * (number) $28 +Adding number conversion cast (unumber) renderBobInit::$1 in (number~) renderBobInit::$1 ← (word~) renderBobInit::$0 * (unumber)(number) $28 +Adding number conversion cast (unumber) 1 in (byte) renderBobInit::i#1 ← (byte) renderBobInit::i#2 + rangenext(0,NUM_BOBS-1) +Adding number conversion cast (unumber) 7 in (number~) renderBob::$4 ← (byte) renderBob::ypos#1 & (number) 7 +Adding number conversion cast (unumber) renderBob::$4 in (number~) renderBob::$4 ← (byte) renderBob::ypos#1 & (unumber)(number) 7 +Adding number conversion cast (unumber) renderBob::$5 in (number~) renderBob::$5 ← (unumber~) renderBob::$4 * (const byte) BOB_SHIFTS_X +Adding number conversion cast (unumber) 3 in (number~) renderBob::$6 ← (byte) renderBob::xpos#1 & (number) 3 +Adding number conversion cast (unumber) renderBob::$6 in (number~) renderBob::$6 ← (byte) renderBob::xpos#1 & (unumber)(number) 3 +Adding number conversion cast (unumber) renderBob::$7 in (number~) renderBob::$7 ← (unumber~) renderBob::$5 + (unumber~) renderBob::$6 +Adding number conversion cast (unumber) 0*BOB_SUBTABLE_SIZE in *((byte*) renderBob::screen#0 + (number) 0) ← *((const byte*) BOB_TABLES+(number) 0*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) +Adding number conversion cast (unumber) 0 in *((byte*) renderBob::screen#0 + (number) 0) ← *((const byte*) BOB_TABLES+(unumber)(number) 0*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) +Adding number conversion cast (unumber) 0 in *((byte*) renderBob::screen#0 + (number) 0) ← *((const byte*) BOB_TABLES+(unumber)(unumber)(number) 0*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) +Adding number conversion cast (unumber) 1*BOB_SUBTABLE_SIZE in *((byte*) renderBob::screen#0 + (number) $28) ← *((const byte*) BOB_TABLES+(number) 1*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) +Adding number conversion cast (unumber) 1 in *((byte*) renderBob::screen#0 + (number) $28) ← *((const byte*) BOB_TABLES+(unumber)(number) 1*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) +Adding number conversion cast (unumber) $28 in *((byte*) renderBob::screen#0 + (number) $28) ← *((const byte*) BOB_TABLES+(unumber)(unumber)(number) 1*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) +Adding number conversion cast (unumber) 2*BOB_SUBTABLE_SIZE in *((byte*) renderBob::screen#0 + (number) $50) ← *((const byte*) BOB_TABLES+(number) 2*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) +Adding number conversion cast (unumber) 2 in *((byte*) renderBob::screen#0 + (number) $50) ← *((const byte*) BOB_TABLES+(unumber)(number) 2*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) +Adding number conversion cast (unumber) $50 in *((byte*) renderBob::screen#0 + (number) $50) ← *((const byte*) BOB_TABLES+(unumber)(unumber)(number) 2*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) +Adding number conversion cast (unumber) 3*BOB_SUBTABLE_SIZE in *((byte*) renderBob::screen#0 + (number) 1) ← *((const byte*) BOB_TABLES+(number) 3*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) +Adding number conversion cast (unumber) 3 in *((byte*) renderBob::screen#0 + (number) 1) ← *((const byte*) BOB_TABLES+(unumber)(number) 3*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) +Adding number conversion cast (unumber) 1 in *((byte*) renderBob::screen#0 + (number) 1) ← *((const byte*) BOB_TABLES+(unumber)(unumber)(number) 3*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) +Adding number conversion cast (unumber) 4*BOB_SUBTABLE_SIZE in *((byte*) renderBob::screen#0 + (number) $29) ← *((const byte*) BOB_TABLES+(number) 4*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) +Adding number conversion cast (unumber) 4 in *((byte*) renderBob::screen#0 + (number) $29) ← *((const byte*) BOB_TABLES+(unumber)(number) 4*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) +Adding number conversion cast (unumber) $29 in *((byte*) renderBob::screen#0 + (number) $29) ← *((const byte*) BOB_TABLES+(unumber)(unumber)(number) 4*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) +Adding number conversion cast (unumber) 5*BOB_SUBTABLE_SIZE in *((byte*) renderBob::screen#0 + (number) $51) ← *((const byte*) BOB_TABLES+(number) 5*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) +Adding number conversion cast (unumber) 5 in *((byte*) renderBob::screen#0 + (number) $51) ← *((const byte*) BOB_TABLES+(unumber)(number) 5*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) +Adding number conversion cast (unumber) $51 in *((byte*) renderBob::screen#0 + (number) $51) ← *((const byte*) BOB_TABLES+(unumber)(unumber)(number) 5*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) +Adding number conversion cast (unumber) 6*BOB_SUBTABLE_SIZE in *((byte*) renderBob::screen#0 + (number) 2) ← *((const byte*) BOB_TABLES+(number) 6*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) +Adding number conversion cast (unumber) 6 in *((byte*) renderBob::screen#0 + (number) 2) ← *((const byte*) BOB_TABLES+(unumber)(number) 6*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) +Adding number conversion cast (unumber) 2 in *((byte*) renderBob::screen#0 + (number) 2) ← *((const byte*) BOB_TABLES+(unumber)(unumber)(number) 6*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) +Adding number conversion cast (unumber) 7*BOB_SUBTABLE_SIZE in *((byte*) renderBob::screen#0 + (number) $2a) ← *((const byte*) BOB_TABLES+(number) 7*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) +Adding number conversion cast (unumber) 7 in *((byte*) renderBob::screen#0 + (number) $2a) ← *((const byte*) BOB_TABLES+(unumber)(number) 7*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) +Adding number conversion cast (unumber) $2a in *((byte*) renderBob::screen#0 + (number) $2a) ← *((const byte*) BOB_TABLES+(unumber)(unumber)(number) 7*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) +Adding number conversion cast (unumber) 8*BOB_SUBTABLE_SIZE in *((byte*) renderBob::screen#0 + (number) $52) ← *((const byte*) BOB_TABLES+(number) 8*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) +Adding number conversion cast (unumber) 8 in *((byte*) renderBob::screen#0 + (number) $52) ← *((const byte*) BOB_TABLES+(unumber)(number) 8*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) +Adding number conversion cast (unumber) $52 in *((byte*) renderBob::screen#0 + (number) $52) ← *((const byte*) BOB_TABLES+(unumber)(unumber)(number) 8*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) +Adding number conversion cast (unumber) 0 in *((byte*) renderBobCleanup::screen#0 + (number) 0) ← (number) 0 +Adding number conversion cast (unumber) 0 in *((byte*) renderBobCleanup::screen#0 + (number) 0) ← ((unumber)) (number) 0 +Adding number conversion cast (unumber) 0 in *((byte*) renderBobCleanup::screen#0 + (number) $28) ← (number) 0 +Adding number conversion cast (unumber) $28 in *((byte*) renderBobCleanup::screen#0 + (number) $28) ← ((unumber)) (number) 0 +Adding number conversion cast (unumber) 0 in *((byte*) renderBobCleanup::screen#0 + (number) $50) ← (number) 0 +Adding number conversion cast (unumber) $50 in *((byte*) renderBobCleanup::screen#0 + (number) $50) ← ((unumber)) (number) 0 +Adding number conversion cast (unumber) 0 in *((byte*) renderBobCleanup::screen#0 + (number) 1) ← (number) 0 +Adding number conversion cast (unumber) 1 in *((byte*) renderBobCleanup::screen#0 + (number) 1) ← ((unumber)) (number) 0 +Adding number conversion cast (unumber) 0 in *((byte*) renderBobCleanup::screen#0 + (number) $29) ← (number) 0 +Adding number conversion cast (unumber) $29 in *((byte*) renderBobCleanup::screen#0 + (number) $29) ← ((unumber)) (number) 0 +Adding number conversion cast (unumber) 0 in *((byte*) renderBobCleanup::screen#0 + (number) $51) ← (number) 0 +Adding number conversion cast (unumber) $51 in *((byte*) renderBobCleanup::screen#0 + (number) $51) ← ((unumber)) (number) 0 +Adding number conversion cast (unumber) 0 in *((byte*) renderBobCleanup::screen#0 + (number) 2) ← (number) 0 +Adding number conversion cast (unumber) 2 in *((byte*) renderBobCleanup::screen#0 + (number) 2) ← ((unumber)) (number) 0 +Adding number conversion cast (unumber) 0 in *((byte*) renderBobCleanup::screen#0 + (number) $2a) ← (number) 0 +Adding number conversion cast (unumber) $2a in *((byte*) renderBobCleanup::screen#0 + (number) $2a) ← ((unumber)) (number) 0 +Adding number conversion cast (unumber) 0 in *((byte*) renderBobCleanup::screen#0 + (number) $52) ← (number) 0 +Adding number conversion cast (unumber) $52 in *((byte*) renderBobCleanup::screen#0 + (number) $52) ← ((unumber)) (number) 0 +Adding number conversion cast (unumber) 1 in (byte) renderBobCleanup::i#1 ← (byte) renderBobCleanup::i#2 + rangenext(0,NUM_BOBS-1) +Adding number conversion cast (unumber) 0 in (byte) bob_charset_next_id#2 ← (number) 0 +Adding number conversion cast (unumber) $30 in (byte*) charsetFindOrAddGlyph::glyph#0 ← (const byte*) PROTO_BOB+(number) $30 +Adding number conversion cast (unumber) 0 in (byte) prepareBobs::bob_table_idx#0 ← (number) 0 +Adding number conversion cast (unumber) 0 in (byte) prepareBobs::shift_y#0 ← (number) 0 +Adding number conversion cast (unumber) 0 in (byte) prepareBobs::shift_x#0 ← (number) 0 +Adding number conversion cast (unumber) 0 in (byte) prepareBobs::cell#0 ← (number) 0 +Adding number conversion cast (unumber) 9 in (bool~) prepareBobs::$5 ← (byte) prepareBobs::cell#2 < (number) 9 +Adding number conversion cast (unumber) 8 in (byte*) prepareBobs::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#3 + (number) 8 +Adding number conversion cast (unumber) 0 in (byte) protoBobShiftRight::carry#0 ← (number) 0 +Adding number conversion cast (unumber) 0 in (byte) protoBobShiftRight::j#0 ← (number) 0 +Adding number conversion cast (unumber) 0 in (byte) protoBobShiftRight::i#0 ← (number) 0 +Adding number conversion cast (unumber) 3*3*8 in (bool~) protoBobShiftRight::$0 ← (byte) protoBobShiftRight::i#2 < (number) 3*(number) 3*(number) 8 +Adding number conversion cast (unumber) 1 in (number~) protoBobShiftRight::$1 ← *((const byte*) PROTO_BOB + (byte) protoBobShiftRight::j#3) & (number) 1 +Adding number conversion cast (unumber) protoBobShiftRight::$1 in (number~) protoBobShiftRight::$1 ← *((const byte*) PROTO_BOB + (byte) protoBobShiftRight::j#3) & (unumber)(number) 1 +Adding number conversion cast (unumber) 0 in (bool~) protoBobShiftRight::$8 ← (number) 0 != (unumber~) protoBobShiftRight::$1 +Adding number conversion cast (unumber) 1 in (byte~) protoBobShiftRight::$5 ← *((const byte*) PROTO_BOB + (byte) protoBobShiftRight::j#4) >> (number) 1 +Adding number conversion cast (unumber) $30 in (bool~) protoBobShiftRight::$7 ← (byte) protoBobShiftRight::j#4 >= (number) $30 +Adding number conversion cast (unumber) $2f in (byte) protoBobShiftRight::j#1 ← (byte) protoBobShiftRight::j#5 - (number) $2f +Adding number conversion cast (unumber) $18 in (byte) protoBobShiftRight::j#2 ← (byte) protoBobShiftRight::j#6 + (number) $18 +Adding number conversion cast (unumber) $17 in (byte) protoBobShiftDown::i#0 ← (number) $17 +Adding number conversion cast (unumber) 0 in (bool~) protoBobShiftDown::$0 ← (byte) protoBobShiftDown::i#2 > (number) 0 +Adding number conversion cast (unumber) $17 in *((const byte*) PROTO_BOB + (byte) protoBobShiftDown::i#3) ← *((const byte*) PROTO_BOB+(number) $17 + (byte) protoBobShiftDown::i#3) +Adding number conversion cast (unumber) $2f in *((const byte*) PROTO_BOB+(number) $18 + (byte) protoBobShiftDown::i#3) ← *((const byte*) PROTO_BOB+(number) $2f + (byte) protoBobShiftDown::i#3) +Adding number conversion cast (unumber) $18 in *((const byte*) PROTO_BOB+(number) $18 + (byte) protoBobShiftDown::i#3) ← *((const byte*) PROTO_BOB+(unumber)(number) $2f + (byte) protoBobShiftDown::i#3) +Adding number conversion cast (unumber) 0 in *((const byte*) PROTO_BOB+(number) $30 + (byte) protoBobShiftDown::i#3) ← (number) 0 +Adding number conversion cast (unumber) $30 in *((const byte*) PROTO_BOB+(number) $30 + (byte) protoBobShiftDown::i#3) ← ((unumber)) (number) 0 +Adding number conversion cast (unumber) 0 in *((const byte*) PROTO_BOB + (number) 0) ← (number) 0 +Adding number conversion cast (unumber) 0 in *((const byte*) PROTO_BOB + (number) 0) ← ((unumber)) (number) 0 +Adding number conversion cast (unumber) 0 in *((const byte*) PROTO_BOB + (number) $18) ← (number) 0 +Adding number conversion cast (unumber) $18 in *((const byte*) PROTO_BOB + (number) $18) ← ((unumber)) (number) 0 +Adding number conversion cast (unumber) 0 in *((const byte*) PROTO_BOB + (number) $30) ← (number) 0 +Adding number conversion cast (unumber) $30 in *((const byte*) PROTO_BOB + (number) $30) ← ((unumber)) (number) 0 +Adding number conversion cast (unumber) 0 in (byte) charsetFindOrAddGlyph::glyph_id#0 ← (number) 0 +Adding number conversion cast (unumber) 1 in (byte) charsetFindOrAddGlyph::found#0 ← (number) 1 +Adding number conversion cast (unumber) 0 in (byte) charsetFindOrAddGlyph::i#0 ← (number) 0 +Adding number conversion cast (unumber) 0 in (byte) charsetFindOrAddGlyph::i1#0 ← (number) 0 +Adding number conversion cast (unumber) 8 in (bool~) charsetFindOrAddGlyph::$1 ← (byte) charsetFindOrAddGlyph::i#2 < (number) 8 +Adding number conversion cast (unumber) 0 in (byte) charsetFindOrAddGlyph::found#1 ← (number) 0 +Adding number conversion cast (unumber) 0 in (bool~) charsetFindOrAddGlyph::$6 ← (number) 0 != (byte) charsetFindOrAddGlyph::found#2 +Adding number conversion cast (unumber) 8 in (byte*) charsetFindOrAddGlyph::glyph_cursor#1 ← (byte*) charsetFindOrAddGlyph::glyph_cursor#3 + (number) 8 +Adding number conversion cast (unumber) 8 in (bool~) charsetFindOrAddGlyph::$5 ← (byte) charsetFindOrAddGlyph::i1#2 < (number) 8 +Adding number conversion cast (unumber) 0 in (byte) progress_idx#6 ← (number) 0 +Adding number conversion cast (unumber) 8 in (bool~) progress_inc::$0 ← (byte) progress_idx#8 == (number) 8 +Adding number conversion cast (unumber) 8 in *((byte*) progress_cursor#18) ← *((const byte*) progress_inc::progress_chars + (number) 8) +Adding number conversion cast (unumber) 0 in (byte) progress_idx#9 ← (number) 0 +Successful SSA optimization PassNAddNumberTypeConversions +Inlining cast (byte*~) memset::$2 ← (byte*)(void*) memset::str#2 +Inlining cast (byte*) memset::dst#0 ← (byte*)(void*) memset::str#2 +Inlining cast (word) mulf_init::sqr#0 ← (unumber)(number) 0 +Inlining cast (byte) mulf_init::x_2#0 ← (unumber)(number) 0 +Inlining cast (byte) mulf_init::c#0 ← (unumber)(number) 0 +Inlining cast (byte) mulf_init::dir#0 ← (unumber)(number) $ff +Inlining cast (byte) mulf_init::dir#1 ← (unumber)(number) 1 +Inlining cast (byte~) mulf8s_prepared::$0 ← (byte)(signed byte) mulf8s_prepared::b#1 +Inlining cast (byte~) mulf8s_prepared::$9 ← (byte)(signed byte) mulf8s_prepared::b#3 +Inlining cast (signed word~) mulf8s_prepared::$6 ← (signed word)(word) mulf8s_prepared::m#4 +Inlining cast (byte~) mulf8s_prepared::$13 ← (byte)*((const signed byte*) mulf8s_prepared::memA) +Inlining cast (byte~) mulf8s::mulf8s_prepare1_$0 ← (byte)(signed byte) mulf8s::mulf8s_prepare1_a#1 +Inlining cast *((const byte*) CIA2_PORT_A_DDR) ← (unumber)(number) 3 +Inlining cast (word~) main::vicSelectGfxBank1_toDd001_$0 ← (word)(byte*) main::vicSelectGfxBank1_toDd001_gfx#1 +Inlining cast (word~) main::toD0181_$0 ← (word)(byte*) main::toD0181_screen#1 +Inlining cast (word~) main::toD0181_$4 ← (word)(byte*) main::toD0181_gfx#1 +Inlining cast (byte) memset::c#0 ← (unumber)(number) 0 +Inlining cast (word) memset::num#0 ← (unumber)(number) $3e8 +Inlining cast (byte) main::angle#0 ← (unumber)(number) 0 +Inlining cast *((const byte*) BORDERCOL) ← (unumber)(number) $f +Inlining cast (signed byte) main::r#0 ← (snumber)(number) $1e +Inlining cast *((const byte*) BORDERCOL) ← (unumber)(number) 1 +Inlining cast *((const byte*) BORDERCOL) ← (unumber)(number) 2 +Inlining cast *((const byte*) BORDERCOL) ← (unumber)(number) 0 +Inlining cast *((const byte*) CIA2_PORT_A_DDR) ← (unumber)(number) 3 +Inlining cast (word~) main::vicSelectGfxBank2_toDd001_$0 ← (word)(byte*) main::vicSelectGfxBank2_toDd001_gfx#1 +Inlining cast (word~) main::toD0182_$0 ← (word)(byte*) main::toD0182_screen#1 +Inlining cast (word~) main::toD0182_$4 ← (word)(byte*) main::toD0182_gfx#1 +Inlining cast (word~) renderBobInit::$0 ← (word)(byte) renderBobInit::y#2 +Inlining cast *((byte*) renderBobCleanup::screen#0 + (unumber)(number) 0) ← (unumber)(number) 0 +Inlining cast *((byte*) renderBobCleanup::screen#0 + (unumber)(number) $28) ← (unumber)(number) 0 +Inlining cast *((byte*) renderBobCleanup::screen#0 + (unumber)(number) $50) ← (unumber)(number) 0 +Inlining cast *((byte*) renderBobCleanup::screen#0 + (unumber)(number) 1) ← (unumber)(number) 0 +Inlining cast *((byte*) renderBobCleanup::screen#0 + (unumber)(number) $29) ← (unumber)(number) 0 +Inlining cast *((byte*) renderBobCleanup::screen#0 + (unumber)(number) $51) ← (unumber)(number) 0 +Inlining cast *((byte*) renderBobCleanup::screen#0 + (unumber)(number) 2) ← (unumber)(number) 0 +Inlining cast *((byte*) renderBobCleanup::screen#0 + (unumber)(number) $2a) ← (unumber)(number) 0 +Inlining cast *((byte*) renderBobCleanup::screen#0 + (unumber)(number) $52) ← (unumber)(number) 0 +Inlining cast (byte) bob_charset_next_id#2 ← (unumber)(number) 0 +Inlining cast (byte) prepareBobs::bob_table_idx#0 ← (unumber)(number) 0 +Inlining cast (byte) prepareBobs::shift_y#0 ← (unumber)(number) 0 +Inlining cast (byte) prepareBobs::shift_x#0 ← (unumber)(number) 0 +Inlining cast (byte) prepareBobs::cell#0 ← (unumber)(number) 0 +Inlining cast (byte) protoBobShiftRight::carry#0 ← (unumber)(number) 0 +Inlining cast (byte) protoBobShiftRight::j#0 ← (unumber)(number) 0 +Inlining cast (byte) protoBobShiftRight::i#0 ← (unumber)(number) 0 +Inlining cast (byte) protoBobShiftDown::i#0 ← (unumber)(number) $17 +Inlining cast *((const byte*) PROTO_BOB+(unumber)(number) $30 + (byte) protoBobShiftDown::i#3) ← (unumber)(number) 0 +Inlining cast *((const byte*) PROTO_BOB + (unumber)(number) 0) ← (unumber)(number) 0 +Inlining cast *((const byte*) PROTO_BOB + (unumber)(number) $18) ← (unumber)(number) 0 +Inlining cast *((const byte*) PROTO_BOB + (unumber)(number) $30) ← (unumber)(number) 0 +Inlining cast (byte) charsetFindOrAddGlyph::glyph_id#0 ← (unumber)(number) 0 +Inlining cast (byte) charsetFindOrAddGlyph::found#0 ← (unumber)(number) 1 +Inlining cast (byte) charsetFindOrAddGlyph::i#0 ← (unumber)(number) 0 +Inlining cast (byte) charsetFindOrAddGlyph::i1#0 ← (unumber)(number) 0 +Inlining cast (byte) charsetFindOrAddGlyph::found#1 ← (unumber)(number) 0 +Inlining cast (byte) progress_idx#6 ← (unumber)(number) 0 +Inlining cast (byte) progress_idx#9 ← (unumber)(number) 0 +Successful SSA optimization Pass2InlineCast +Simplifying constant pointer cast (byte*) 53266 +Simplifying constant pointer cast (byte*) 53280 +Simplifying constant pointer cast (byte*) 53272 +Simplifying constant pointer cast (byte*) 56320 +Simplifying constant pointer cast (byte*) 56321 +Simplifying constant pointer cast (byte*) 56576 +Simplifying constant pointer cast (byte*) 56578 +Simplifying constant integer cast $fe +Simplifying constant integer cast $fd +Simplifying constant integer cast $fb +Simplifying constant integer cast $f7 +Simplifying constant integer cast $ef +Simplifying constant integer cast $df +Simplifying constant integer cast $bf +Simplifying constant integer cast $7f +Simplifying constant integer cast 1 +Simplifying constant integer cast 2 +Simplifying constant integer cast 4 +Simplifying constant integer cast 8 +Simplifying constant integer cast $10 +Simplifying constant integer cast $20 +Simplifying constant integer cast $40 +Simplifying constant integer cast $80 +Simplifying constant pointer cast (byte*) 253 +Simplifying constant pointer cast (byte*) 254 +Simplifying constant pointer cast (byte*) 255 +Simplifying constant pointer cast (signed byte*) 253 +Simplifying constant pointer cast (byte*) 1024 +Simplifying constant pointer cast (byte*) 4096 +Simplifying constant pointer cast (byte*) 10240 +Simplifying constant pointer cast (byte*) 8192 +Simplifying constant integer cast $20 +Simplifying constant integer cast $65 +Simplifying constant integer cast $74 +Simplifying constant integer cast $75 +Simplifying constant integer cast $61 +Simplifying constant integer cast $f6 +Simplifying constant integer cast $e7 +Simplifying constant integer cast $ea +Simplifying constant integer cast $e0 +Simplifying constant integer cast $40 +Simplifying constant integer cast 0 +Simplifying constant integer cast 7 +Simplifying constant integer cast 3 +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Simplifying constant integer cast 1 +Simplifying constant integer cast 1 +Simplifying constant integer cast $200 +Simplifying constant integer cast 1 +Simplifying constant integer cast 0 +Simplifying constant integer cast -1 +Simplifying constant integer cast $ff +Simplifying constant integer cast $1ff +Simplifying constant integer cast 0 +Simplifying constant integer cast $100 +Simplifying constant integer cast $1ff +Simplifying constant integer cast $100 +Simplifying constant integer cast $1ff +Simplifying constant integer cast 1 +Simplifying constant integer cast *((const byte*) mulf8u_prepared::memB) +Simplifying constant integer cast *((const byte*) mulf8u_prepared::resL) +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Simplifying constant integer cast 3 +Simplifying constant integer cast $40 +Simplifying constant integer cast 3 +Simplifying constant integer cast $3fff +Simplifying constant integer cast 4 +Simplifying constant integer cast 4 +Simplifying constant integer cast $f +Simplifying constant integer cast 0 +Simplifying constant integer cast $3e8 +Simplifying constant integer cast 0 +Simplifying constant integer cast $f8 +Simplifying constant integer cast $f +Simplifying constant integer cast $1e +Simplifying constant integer cast 1 +Simplifying constant integer cast 2 +Simplifying constant integer cast 2 +Simplifying constant integer cast $62 +Simplifying constant integer cast 3 +Simplifying constant integer cast 1 +Simplifying constant integer cast 3 +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Simplifying constant integer cast 3 +Simplifying constant integer cast $40 +Simplifying constant integer cast 3 +Simplifying constant integer cast $3fff +Simplifying constant integer cast 4 +Simplifying constant integer cast 4 +Simplifying constant integer cast $f +Simplifying constant integer cast $28 +Simplifying constant integer cast 1 +Simplifying constant integer cast 7 +Simplifying constant integer cast 3 +Simplifying constant integer cast (unumber)(number) 0*(const byte) BOB_SUBTABLE_SIZE +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Simplifying constant integer cast (unumber)(number) 1*(const byte) BOB_SUBTABLE_SIZE +Simplifying constant integer cast 1 +Simplifying constant integer cast $28 +Simplifying constant integer cast (unumber)(number) 2*(const byte) BOB_SUBTABLE_SIZE +Simplifying constant integer cast 2 +Simplifying constant integer cast $50 +Simplifying constant integer cast (unumber)(number) 3*(const byte) BOB_SUBTABLE_SIZE +Simplifying constant integer cast 3 +Simplifying constant integer cast 1 +Simplifying constant integer cast (unumber)(number) 4*(const byte) BOB_SUBTABLE_SIZE +Simplifying constant integer cast 4 +Simplifying constant integer cast $29 +Simplifying constant integer cast (unumber)(number) 5*(const byte) BOB_SUBTABLE_SIZE +Simplifying constant integer cast 5 +Simplifying constant integer cast $51 +Simplifying constant integer cast (unumber)(number) 6*(const byte) BOB_SUBTABLE_SIZE +Simplifying constant integer cast 6 +Simplifying constant integer cast 2 +Simplifying constant integer cast (unumber)(number) 7*(const byte) BOB_SUBTABLE_SIZE +Simplifying constant integer cast 7 +Simplifying constant integer cast $2a +Simplifying constant integer cast (unumber)(number) 8*(const byte) BOB_SUBTABLE_SIZE +Simplifying constant integer cast 8 +Simplifying constant integer cast $52 +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Simplifying constant integer cast $28 +Simplifying constant integer cast 0 +Simplifying constant integer cast $50 +Simplifying constant integer cast 0 +Simplifying constant integer cast 1 +Simplifying constant integer cast 0 +Simplifying constant integer cast $29 +Simplifying constant integer cast 0 +Simplifying constant integer cast $51 +Simplifying constant integer cast 0 +Simplifying constant integer cast 2 +Simplifying constant integer cast 0 +Simplifying constant integer cast $2a +Simplifying constant integer cast 0 +Simplifying constant integer cast $52 +Simplifying constant integer cast 1 +Simplifying constant integer cast 0 +Simplifying constant integer cast $30 +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Simplifying constant integer cast 9 +Simplifying constant integer cast 8 +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Simplifying constant integer cast 1 +Simplifying constant integer cast 0 +Simplifying constant integer cast 1 +Simplifying constant integer cast $30 +Simplifying constant integer cast $2f +Simplifying constant integer cast $18 +Simplifying constant integer cast $17 +Simplifying constant integer cast 0 +Simplifying constant integer cast $17 +Simplifying constant integer cast $2f +Simplifying constant integer cast $18 +Simplifying constant integer cast 0 +Simplifying constant integer cast $30 +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Simplifying constant integer cast $18 +Simplifying constant integer cast 0 +Simplifying constant integer cast $30 +Simplifying constant integer cast 0 +Simplifying constant integer cast 1 +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Simplifying constant integer cast 8 +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Simplifying constant integer cast 8 +Simplifying constant integer cast 8 +Simplifying constant integer cast 0 +Simplifying constant integer cast 8 +Simplifying constant integer cast 8 +Simplifying constant integer cast 0 +Successful SSA optimization PassNCastSimplification +Finalized unsigned number type (byte) $40 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 7 +Finalized unsigned number type (byte) 3 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 1 +Finalized unsigned number type (byte) 1 +Finalized unsigned number type (word) $200 +Finalized unsigned number type (byte) 1 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) $ff +Finalized unsigned number type (word) $1ff +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (word) $100 +Finalized unsigned number type (word) $1ff +Finalized unsigned number type (word) $100 +Finalized unsigned number type (word) $1ff +Finalized unsigned number type (byte) 1 +Finalized signed number type (signed byte) 0 +Finalized signed number type (signed byte) 0 +Finalized unsigned number type (byte) 3 +Finalized unsigned number type (byte) $40 +Finalized unsigned number type (byte) 3 +Finalized unsigned number type (word) $3fff +Finalized unsigned number type (byte) 4 +Finalized unsigned number type (byte) 4 +Finalized unsigned number type (byte) $f +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (word) $3e8 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) $f8 +Finalized unsigned number type (byte) $f +Finalized signed number type (signed byte) $1e +Finalized unsigned number type (byte) 1 +Finalized signed number type (signed byte) 2 +Finalized unsigned number type (byte) 2 +Finalized unsigned number type (byte) $62 +Finalized signed number type (signed byte) 3 +Finalized unsigned number type (byte) 1 +Finalized unsigned number type (byte) 3 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 3 +Finalized unsigned number type (byte) $40 +Finalized unsigned number type (byte) 3 +Finalized unsigned number type (word) $3fff +Finalized unsigned number type (byte) 4 +Finalized unsigned number type (byte) 4 +Finalized unsigned number type (byte) $f +Finalized unsigned number type (byte) $28 +Finalized unsigned number type (byte) 1 +Finalized unsigned number type (byte) 7 +Finalized unsigned number type (byte) 3 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 1 +Finalized unsigned number type (byte) $28 +Finalized unsigned number type (byte) 2 +Finalized unsigned number type (byte) $50 +Finalized unsigned number type (byte) 3 +Finalized unsigned number type (byte) 1 +Finalized unsigned number type (byte) 4 +Finalized unsigned number type (byte) $29 +Finalized unsigned number type (byte) 5 +Finalized unsigned number type (byte) $51 +Finalized unsigned number type (byte) 6 +Finalized unsigned number type (byte) 2 +Finalized unsigned number type (byte) 7 +Finalized unsigned number type (byte) $2a +Finalized unsigned number type (byte) 8 +Finalized unsigned number type (byte) $52 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) $28 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) $50 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 1 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) $29 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) $51 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 2 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) $2a +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) $52 +Finalized unsigned number type (byte) 1 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) $30 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 9 +Finalized unsigned number type (byte) 8 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 1 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 1 +Finalized unsigned number type (byte) $30 +Finalized unsigned number type (byte) $2f +Finalized unsigned number type (byte) $18 +Finalized unsigned number type (byte) $17 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) $17 +Finalized unsigned number type (byte) $2f +Finalized unsigned number type (byte) $18 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) $30 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) $18 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) $30 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 1 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 8 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 8 +Finalized unsigned number type (byte) 8 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 8 +Finalized unsigned number type (byte) 8 +Finalized unsigned number type (byte) 0 +Successful SSA optimization PassNFinalizeNumberTypeConversions +Inferred type updated to byte in (unumber~) keyboard_key_pressed::$0 ← (byte) keyboard_key_pressed::key#2 & (byte) 7 +Inferred type updated to byte in (unumber~) mulf_init::$1 ← (byte) mulf_init::c#1 & (byte) 1 +Inferred type updated to byte in (unumber~) main::vicSelectGfxBank1_toDd001_$2 ← (byte~) main::vicSelectGfxBank1_toDd001_$1 / (byte) $40 +Inferred type updated to byte in (unumber~) main::vicSelectGfxBank1_toDd001_$3 ← (byte) 3 ^ (byte~) main::vicSelectGfxBank1_toDd001_$2 +Inferred type updated to word in (unumber~) main::toD0181_$1 ← (word~) main::toD0181_$0 & (word) $3fff +Inferred type updated to word in (unumber~) main::toD0181_$2 ← (word~) main::toD0181_$1 * (byte) 4 +Inferred type updated to byte in (unumber~) main::toD0181_$3 ← > (word~) main::toD0181_$2 +Inferred type updated to byte in (unumber~) main::toD0181_$6 ← (byte~) main::toD0181_$5 / (byte) 4 +Inferred type updated to byte in (unumber~) main::toD0181_$7 ← (byte~) main::toD0181_$6 & (byte) $f +Inferred type updated to byte in (unumber~) main::toD0181_$8 ← (byte~) main::toD0181_$3 | (byte~) main::toD0181_$7 +Inferred type updated to signed word in (snumber~) main::$11 ← (signed word~) main::$10 + (signed word)(number) $4b*(number) $100 +Inferred type updated to signed word in (snumber~) main::$13 ← (signed word~) main::$12 * (signed byte) 2 +Inferred type updated to signed word in (snumber~) main::$14 ← (signed word~) main::$13 + (signed word)(number) $5a*(number) $100 +Inferred type updated to byte in (unumber~) main::vicSelectGfxBank2_toDd001_$2 ← (byte~) main::vicSelectGfxBank2_toDd001_$1 / (byte) $40 +Inferred type updated to byte in (unumber~) main::vicSelectGfxBank2_toDd001_$3 ← (byte) 3 ^ (byte~) main::vicSelectGfxBank2_toDd001_$2 +Inferred type updated to word in (unumber~) main::toD0182_$1 ← (word~) main::toD0182_$0 & (word) $3fff +Inferred type updated to word in (unumber~) main::toD0182_$2 ← (word~) main::toD0182_$1 * (byte) 4 +Inferred type updated to byte in (unumber~) main::toD0182_$3 ← > (word~) main::toD0182_$2 +Inferred type updated to byte in (unumber~) main::toD0182_$6 ← (byte~) main::toD0182_$5 / (byte) 4 +Inferred type updated to byte in (unumber~) main::toD0182_$7 ← (byte~) main::toD0182_$6 & (byte) $f +Inferred type updated to byte in (unumber~) main::toD0182_$8 ← (byte~) main::toD0182_$3 | (byte~) main::toD0182_$7 +Inferred type updated to word in (unumber~) renderBobInit::$1 ← (word~) renderBobInit::$0 * (byte) $28 +Inferred type updated to byte in (unumber~) renderBob::$4 ← (byte) renderBob::ypos#1 & (byte) 7 +Inferred type updated to byte in (unumber~) renderBob::$5 ← (byte~) renderBob::$4 * (const byte) BOB_SHIFTS_X +Inferred type updated to byte in (unumber~) renderBob::$6 ← (byte) renderBob::xpos#1 & (byte) 3 +Inferred type updated to byte in (unumber~) renderBob::$7 ← (byte~) renderBob::$5 + (byte~) renderBob::$6 +Inferred type updated to byte in (unumber~) protoBobShiftRight::$1 ← *((const byte*) PROTO_BOB + (byte) protoBobShiftRight::j#3) & (byte) 1 +Inversing boolean not [2] (bool~) memset::$1 ← (word) memset::num#1 <= (byte) 0 from [1] (bool~) memset::$0 ← (word) memset::num#1 > (byte) 0 +Inversing boolean not [55] (bool~) mulf_init::$3 ← (byte~) mulf_init::$1 != (byte) 0 from [54] (bool~) mulf_init::$2 ← (byte~) mulf_init::$1 == (byte) 0 +Inversing boolean not [83] (bool~) mulf_init::$10 ← (byte) mulf_init::x_255#1 != (byte) 0 from [82] (bool~) mulf_init::$9 ← (byte) mulf_init::x_255#1 == (byte) 0 +Inversing boolean not [113] (bool~) mulf8s_prepared::$3 ← *((const signed byte*) mulf8s_prepared::memA) >= (signed byte) 0 from [112] (bool~) mulf8s_prepared::$2 ← *((const signed byte*) mulf8s_prepared::memA) < (signed byte) 0 +Inversing boolean not [117] (bool~) mulf8s_prepared::$5 ← (signed byte) mulf8s_prepared::b#2 >= (signed byte) 0 from [116] (bool~) mulf8s_prepared::$4 ← (signed byte) mulf8s_prepared::b#2 < (signed byte) 0 +Inversing boolean not [259] (bool~) main::$20 ← (byte) 0 == (byte~) main::$19 from [258] (bool~) main::$23 ← (byte) 0 != (byte~) main::$19 +Inversing boolean not [500] (bool~) charsetFindOrAddGlyph::$3 ← *((byte*) charsetFindOrAddGlyph::glyph_cursor#2 + (byte) charsetFindOrAddGlyph::i#3) == *((byte*) charsetFindOrAddGlyph::glyph#2 + (byte) charsetFindOrAddGlyph::i#3) from [499] (bool~) charsetFindOrAddGlyph::$2 ← *((byte*) charsetFindOrAddGlyph::glyph_cursor#2 + (byte) charsetFindOrAddGlyph::i#3) != *((byte*) charsetFindOrAddGlyph::glyph#2 + (byte) charsetFindOrAddGlyph::i#3) +Inversing boolean not [508] (bool~) charsetFindOrAddGlyph::$4 ← (byte) 0 == (byte) charsetFindOrAddGlyph::found#2 from [507] (bool~) charsetFindOrAddGlyph::$6 ← (byte) 0 != (byte) charsetFindOrAddGlyph::found#2 +Inversing boolean not [541] (bool~) progress_inc::$1 ← (byte) progress_idx#8 != (byte) 8 from [540] (bool~) progress_inc::$0 ← (byte) progress_idx#8 == (byte) 8 +Successful SSA optimization Pass2UnaryNotSimplification +Alias (void*) memset::return#0 = (void*) memset::str#1 (void*) memset::return#3 (void*) memset::return#1 +Alias (void*) memset::str#2 = (void*) memset::str#3 +Alias (word) memset::num#1 = (word) memset::num#2 +Alias (byte) memset::c#3 = (byte) memset::c#4 +Alias (byte*) memset::end#0 = (byte*~) memset::$3 +Alias (byte) memset::c#1 = (byte) memset::c#2 +Alias (byte*) memset::dst#2 = (byte*) memset::dst#3 +Alias (byte*) memset::end#1 = (byte*) memset::end#2 +Alias (void*) memset::str#4 = (void*) memset::str#5 +Alias (byte) keyboard_matrix_read::return#0 = (byte) keyboard_matrix_read::row_pressed_bits#0 (byte~) keyboard_matrix_read::$0 (byte) keyboard_matrix_read::return#3 (byte) keyboard_matrix_read::return#1 +Alias (byte) keyboard_key_pressed::colidx#0 = (byte~) keyboard_key_pressed::$0 (byte) keyboard_key_pressed::colidx#1 +Alias (byte) keyboard_key_pressed::rowidx#0 = (byte~) keyboard_key_pressed::$1 +Alias (byte) keyboard_matrix_read::return#2 = (byte) keyboard_matrix_read::return#4 +Alias (byte) keyboard_key_pressed::return#0 = (byte~) keyboard_key_pressed::$3 (byte) keyboard_key_pressed::return#4 (byte) keyboard_key_pressed::return#1 +Alias (byte) mulf_init::c#2 = (byte) mulf_init::c#3 +Alias (word) mulf_init::sqr#4 = (word) mulf_init::sqr#5 (word) mulf_init::sqr#6 +Alias (byte*) mulf_init::sqr1_lo#2 = (byte*) mulf_init::sqr1_lo#4 (byte*) mulf_init::sqr1_lo#5 +Alias (byte*) mulf_init::sqr1_hi#3 = (byte*) mulf_init::sqr1_hi#5 (byte*) mulf_init::sqr1_hi#4 +Alias (byte) mulf_init::x_2#3 = (byte) mulf_init::x_2#4 (byte) mulf_init::x_2#5 +Alias (word) mulf_init::sqr#1 = (word~) mulf_init::$6 +Alias (byte) mulf_init::c#1 = (byte) mulf_init::c#5 +Alias (byte) mulf_init::x_255#2 = (byte) mulf_init::x_255#3 +Alias (byte*) mulf_init::sqr2_lo#2 = (byte*) mulf_init::sqr2_lo#3 (byte*) mulf_init::sqr2_lo#5 +Alias (byte*) mulf_init::sqr2_hi#2 = (byte*) mulf_init::sqr2_hi#3 +Alias (byte) mulf_init::dir#2 = (byte) mulf_init::dir#3 +Alias (byte) mulf_init::x_255#1 = (byte~) mulf_init::$8 (byte) mulf_init::x_255#5 +Alias (byte*) mulf_init::sqr2_hi#1 = (byte*) mulf_init::sqr2_hi#5 +Alias (word) mulf8u_prepared::return#0 = (word~) mulf8u_prepared::$0 (word) mulf8u_prepared::return#3 (word) mulf8u_prepared::return#1 +Alias (byte) mulf8u_prepared::b#0 = (byte~) mulf8s_prepared::$0 +Alias (word) mulf8u_prepared::return#2 = (word) mulf8u_prepared::return#4 +Alias (signed byte) mulf8s_prepared::b#1 = (signed byte) mulf8s_prepared::b#4 (signed byte) mulf8s_prepared::b#3 +Alias (word) mulf8s_prepared::m#0 = (word~) mulf8s_prepared::$1 (word) mulf8s_prepared::m#3 +Alias (byte~) mulf8s_prepared::$15 = (byte~) mulf8s_prepared::$10 +Alias (signed word) mulf8s_prepared::return#0 = (signed word~) mulf8s_prepared::$6 (signed word) mulf8s_prepared::return#3 (signed word) mulf8s_prepared::return#1 +Alias (word) mulf8s_prepared::m#5 = (word) mulf8s_prepared::m#6 +Alias (byte~) mulf8s_prepared::$16 = (byte~) mulf8s_prepared::$14 +Alias (signed byte) mulf8s::mulf8s_prepare1_a#0 = (signed byte) mulf8s::a#2 (signed byte) mulf8s::mulf8s_prepare1_a#1 +Alias (signed byte) mulf8s::b#2 = (signed byte) mulf8s::b#4 (signed byte) mulf8s::b#5 (signed byte) mulf8s::b#3 +Alias (byte) mulf8u_prepare::a#0 = (byte~) mulf8s::mulf8s_prepare1_$0 +Alias (signed word) mulf8s_prepared::return#2 = (signed word) mulf8s_prepared::return#4 +Alias (signed word) mulf8s::return#0 = (signed word~) mulf8s::$1 (signed word) mulf8s::return#4 (signed word) mulf8s::return#1 +Alias (byte*) progress_cursor#21 = (byte*) progress_cursor#28 +Alias (byte) progress_idx#22 = (byte) progress_idx#28 +Alias (byte) bob_charset_next_id#19 = (byte) bob_charset_next_id#28 +Alias (byte**) renderBobCleanupNext#28 = (byte**) renderBobCleanupNext#49 (byte**) renderBobCleanupNext#50 (byte**) renderBobCleanupNext#48 (byte**) renderBobCleanupNext#47 (byte**) renderBobCleanupNext#46 (byte**) renderBobCleanupNext#44 (byte**) renderBobCleanupNext#42 (byte**) renderBobCleanupNext#40 (byte**) renderBobCleanupNext#38 (byte**) renderBobCleanupNext#36 (byte**) renderBobCleanupNext#34 (byte**) renderBobCleanupNext#31 +Alias (byte*) progress_cursor#0 = (byte*) progress_cursor#11 (byte*) progress_cursor#69 (byte*) progress_cursor#68 (byte*) progress_cursor#66 (byte*) progress_cursor#64 (byte*) progress_cursor#62 (byte*) progress_cursor#60 (byte*) progress_cursor#58 (byte*) progress_cursor#56 (byte*) progress_cursor#54 (byte*) progress_cursor#52 +Alias (byte) progress_idx#0 = (byte) progress_idx#12 (byte) progress_idx#69 (byte) progress_idx#68 (byte) progress_idx#66 (byte) progress_idx#64 (byte) progress_idx#62 (byte) progress_idx#60 (byte) progress_idx#58 (byte) progress_idx#56 (byte) progress_idx#54 (byte) progress_idx#52 +Alias (byte) bob_charset_next_id#0 = (byte) bob_charset_next_id#10 (byte) bob_charset_next_id#77 (byte) bob_charset_next_id#76 (byte) bob_charset_next_id#74 (byte) bob_charset_next_id#72 (byte) bob_charset_next_id#70 (byte) bob_charset_next_id#68 (byte) bob_charset_next_id#66 (byte) bob_charset_next_id#64 (byte) bob_charset_next_id#62 (byte) bob_charset_next_id#60 +Alias (byte*) main::vicSelectGfxBank1_gfx#0 = (byte*) main::vicSelectGfxBank1_gfx#1 (byte*) main::vicSelectGfxBank1_toDd001_gfx#0 (byte*) main::vicSelectGfxBank1_toDd001_gfx#1 +Alias (byte) main::vicSelectGfxBank1_toDd001_return#0 = (byte~) main::vicSelectGfxBank1_toDd001_$3 (byte) main::vicSelectGfxBank1_toDd001_return#2 (byte) main::vicSelectGfxBank1_toDd001_return#1 (byte) main::vicSelectGfxBank1_toDd001_return#3 (byte~) main::vicSelectGfxBank1_$0 +Alias (byte*) main::toD0181_screen#0 = (byte*) main::toD0181_screen#1 +Alias (byte*) main::toD0181_gfx#0 = (byte*) main::toD0181_gfx#1 +Alias (byte) main::toD0181_return#0 = (byte~) main::toD0181_$8 (byte) main::toD0181_return#2 (byte) main::toD0181_return#1 (byte) main::toD0181_return#3 (byte~) main::$4 +Alias (byte**) renderBobCleanupNext#16 = (byte**) renderBobCleanupNext#20 +Alias (byte) main::angle#2 = (byte) main::angle#4 (byte) main::angle#6 (byte) main::a#0 +Alias (byte*) progress_cursor#63 = (byte*) progress_cursor#65 (byte*) progress_cursor#67 +Alias (byte) progress_idx#63 = (byte) progress_idx#65 (byte) progress_idx#67 +Alias (byte) bob_charset_next_id#71 = (byte) bob_charset_next_id#73 (byte) bob_charset_next_id#75 +Alias (byte**) renderBobCleanupNext#0 = (byte**) renderBobCleanupNext#9 +Alias (signed word) mulf8s::return#2 = (signed word) mulf8s::return#5 +Alias (signed byte) main::r#2 = (signed byte) main::r#3 (signed byte) main::r#4 +Alias (byte) main::a#2 = (byte) main::a#3 (byte) main::a#4 +Alias (byte**) renderBobCleanupNext#17 = (byte**) renderBobCleanupNext#21 (byte**) renderBobCleanupNext#25 +Alias (byte) main::i#2 = (byte) main::i#4 (byte) main::i#5 (byte) main::i#3 +Alias (byte) main::angle#11 = (byte) main::angle#9 (byte) main::angle#7 (byte) main::angle#5 (byte) main::angle#3 +Alias (byte*) progress_cursor#51 = (byte*) progress_cursor#59 (byte*) progress_cursor#61 (byte*) progress_cursor#57 (byte*) progress_cursor#55 (byte*) progress_cursor#53 +Alias (byte) progress_idx#51 = (byte) progress_idx#59 (byte) progress_idx#61 (byte) progress_idx#57 (byte) progress_idx#55 (byte) progress_idx#53 +Alias (byte) bob_charset_next_id#59 = (byte) bob_charset_next_id#67 (byte) bob_charset_next_id#69 (byte) bob_charset_next_id#65 (byte) bob_charset_next_id#63 (byte) bob_charset_next_id#61 +Alias (signed word) main::x#0 = (signed word~) main::$11 (signed word) main::x#1 +Alias (signed word) mulf8s::return#3 = (signed word) mulf8s::return#6 +Alias (signed word) main::y#0 = (signed word~) main::$14 +Alias (byte) renderBob::xpos#0 = (byte~) main::$15 +Alias (byte) renderBob::ypos#0 = (byte~) main::$16 +Alias (signed byte) main::r#1 = (signed byte) main::r#5 +Alias (byte) main::a#1 = (byte) main::a#5 +Alias (byte**) renderBobCleanupNext#1 = (byte**) renderBobCleanupNext#10 (byte**) renderBobCleanupNext#32 (byte**) renderBobCleanupNext#29 +Alias (byte) keyboard_key_pressed::return#2 = (byte) keyboard_key_pressed::return#5 +Alias (byte) main::angle#1 = (byte) main::angle#10 +Alias (byte) keyboard_key_pressed::return#3 = (byte) keyboard_key_pressed::return#6 +Alias (byte*) progress_cursor#1 = (byte*) progress_cursor#48 (byte*) progress_cursor#49 (byte*) progress_cursor#47 (byte*) progress_cursor#46 (byte*) progress_cursor#44 (byte*) progress_cursor#42 (byte*) progress_cursor#39 (byte*) progress_cursor#36 (byte*) progress_cursor#33 (byte*) progress_cursor#29 (byte*) progress_cursor#22 (byte*) progress_cursor#12 +Alias (byte) progress_idx#1 = (byte) progress_idx#48 (byte) progress_idx#49 (byte) progress_idx#47 (byte) progress_idx#46 (byte) progress_idx#44 (byte) progress_idx#42 (byte) progress_idx#39 (byte) progress_idx#36 (byte) progress_idx#33 (byte) progress_idx#29 (byte) progress_idx#23 (byte) progress_idx#13 +Alias (byte) bob_charset_next_id#1 = (byte) bob_charset_next_id#56 (byte) bob_charset_next_id#57 (byte) bob_charset_next_id#55 (byte) bob_charset_next_id#54 (byte) bob_charset_next_id#52 (byte) bob_charset_next_id#50 (byte) bob_charset_next_id#47 (byte) bob_charset_next_id#42 (byte) bob_charset_next_id#36 (byte) bob_charset_next_id#29 (byte) bob_charset_next_id#20 (byte) bob_charset_next_id#11 +Alias (byte**) renderBobCleanupNext#11 = (byte**) renderBobCleanupNext#43 (byte**) renderBobCleanupNext#45 (byte**) renderBobCleanupNext#41 (byte**) renderBobCleanupNext#39 (byte**) renderBobCleanupNext#37 (byte**) renderBobCleanupNext#35 (byte**) renderBobCleanupNext#33 (byte**) renderBobCleanupNext#30 (byte**) renderBobCleanupNext#26 (byte**) renderBobCleanupNext#22 (byte**) renderBobCleanupNext#18 (byte**) renderBobCleanupNext#2 +Alias (byte*) main::vicSelectGfxBank2_gfx#0 = (byte*) main::vicSelectGfxBank2_gfx#1 (byte*) main::vicSelectGfxBank2_toDd001_gfx#0 (byte*) main::vicSelectGfxBank2_toDd001_gfx#1 +Alias (byte) main::vicSelectGfxBank2_toDd001_return#0 = (byte~) main::vicSelectGfxBank2_toDd001_$3 (byte) main::vicSelectGfxBank2_toDd001_return#2 (byte) main::vicSelectGfxBank2_toDd001_return#1 (byte) main::vicSelectGfxBank2_toDd001_return#3 (byte~) main::vicSelectGfxBank2_$0 +Alias (byte*) main::toD0182_screen#0 = (byte*) main::toD0182_screen#1 +Alias (byte*) main::toD0182_gfx#0 = (byte*) main::toD0182_gfx#1 +Alias (byte) main::toD0182_return#0 = (byte~) main::toD0182_$8 (byte) main::toD0182_return#2 (byte) main::toD0182_return#1 (byte) main::toD0182_return#3 (byte~) main::$7 +Alias (byte) renderBob::x_char_offset#0 = (byte~) renderBob::$0 +Alias (byte) renderBob::y_char_offset#0 = (byte~) renderBob::$1 +Alias (byte*) renderBob::screen#0 = (byte*~) renderBob::$3 +Alias (byte) renderBob::bob_table_idx#0 = (byte~) renderBob::$7 +Alias (byte**) renderBobCleanupNext#13 = (byte**) renderBobCleanupNext#4 (byte**) renderBobCleanupNext#5 +Alias (byte**) renderBobCleanupNext#14 = (byte**) renderBobCleanupNext#6 (byte**) renderBobCleanupNext#7 +Alias (byte*) progress_cursor#13 = (byte*) progress_cursor#2 (byte*) progress_cursor#30 +Alias (byte) progress_idx#14 = (byte) progress_idx#2 (byte) progress_idx#30 +Alias (byte) bob_charset_next_id#12 = (byte) bob_charset_next_id#3 +Alias (byte) prepareBobs::bob_table_idx#6 = (byte) prepareBobs::bob_table_idx#9 +Alias (byte) prepareBobs::shift_y#2 = (byte) prepareBobs::shift_y#6 +Alias (byte) bob_charset_next_id#14 = (byte) bob_charset_next_id#48 (byte) bob_charset_next_id#22 (byte) bob_charset_next_id#5 +Alias (byte*) progress_cursor#15 = (byte*) progress_cursor#40 (byte*) progress_cursor#25 (byte*) progress_cursor#4 +Alias (byte) progress_idx#16 = (byte) progress_idx#40 (byte) progress_idx#26 (byte) progress_idx#4 +Alias (byte) prepareBobs::bob_table_idx#12 = (byte) prepareBobs::bob_table_idx#2 (byte) prepareBobs::bob_table_idx#4 (byte) prepareBobs::bob_table_idx#14 +Alias (byte) bob_charset_next_id#30 = (byte) bob_charset_next_id#39 (byte) bob_charset_next_id#43 (byte) bob_charset_next_id#37 +Alias (byte) progress_idx#31 = (byte) progress_idx#38 (byte) progress_idx#37 (byte) progress_idx#34 +Alias (byte*) progress_cursor#31 = (byte*) progress_cursor#38 (byte*) progress_cursor#37 (byte*) progress_cursor#34 +Alias (byte) prepareBobs::shift_x#2 = (byte) prepareBobs::shift_x#8 +Alias (byte) prepareBobs::shift_y#12 = (byte) prepareBobs::shift_y#5 (byte) prepareBobs::shift_y#4 (byte) prepareBobs::shift_y#3 +Alias (byte*) prepareBobs::bob_table#0 = (byte*~) prepareBobs::$4 +Alias (byte*) prepareBobs::bob_glyph#2 = (byte*) prepareBobs::bob_glyph#4 (byte*) prepareBobs::bob_glyph#3 +Alias (byte) bob_charset_next_id#21 = (byte) bob_charset_next_id#31 (byte) bob_charset_next_id#53 (byte) bob_charset_next_id#51 (byte) bob_charset_next_id#49 +Alias (byte*) prepareBobs::bob_table#2 = (byte*) prepareBobs::bob_table#3 (byte*) prepareBobs::bob_table#4 +Alias (byte) progress_idx#25 = (byte) progress_idx#32 (byte) progress_idx#35 (byte) progress_idx#45 (byte) progress_idx#43 (byte) progress_idx#41 +Alias (byte*) progress_cursor#24 = (byte*) progress_cursor#32 (byte*) progress_cursor#35 (byte*) progress_cursor#45 (byte*) progress_cursor#43 (byte*) progress_cursor#41 +Alias (byte) prepareBobs::cell#2 = (byte) prepareBobs::cell#5 (byte) prepareBobs::cell#4 (byte) prepareBobs::cell#3 +Alias (byte) prepareBobs::bob_table_idx#10 = (byte) prepareBobs::bob_table_idx#13 (byte) prepareBobs::bob_table_idx#5 (byte) prepareBobs::bob_table_idx#8 (byte) prepareBobs::bob_table_idx#3 +Alias (byte) prepareBobs::shift_x#10 = (byte) prepareBobs::shift_x#6 (byte) prepareBobs::shift_x#9 (byte) prepareBobs::shift_x#7 (byte) prepareBobs::shift_x#5 (byte) prepareBobs::shift_x#4 (byte) prepareBobs::shift_x#3 +Alias (byte) prepareBobs::shift_y#10 = (byte) prepareBobs::shift_y#14 (byte) prepareBobs::shift_y#13 (byte) prepareBobs::shift_y#11 (byte) prepareBobs::shift_y#9 (byte) prepareBobs::shift_y#8 (byte) prepareBobs::shift_y#7 +Alias (byte) charsetFindOrAddGlyph::return#1 = (byte) charsetFindOrAddGlyph::return#5 +Alias (byte) bob_charset_next_id#13 = (byte) bob_charset_next_id#4 (byte) bob_charset_next_id#38 +Alias (byte*) prepareBobs::bob_glyph#1 = (byte*) prepareBobs::bob_glyph#5 +Alias (byte*) prepareBobs::bob_table#1 = (byte*) prepareBobs::bob_table#5 +Alias (byte) progress_idx#15 = (byte) progress_idx#3 +Alias (byte*) progress_cursor#14 = (byte*) progress_cursor#3 +Alias (byte) prepareBobs::bob_table_idx#1 = (byte) prepareBobs::bob_table_idx#11 (byte) prepareBobs::bob_table_idx#7 +Alias (byte) protoBobShiftRight::j#3 = (byte) protoBobShiftRight::j#7 (byte) protoBobShiftRight::j#8 (byte) protoBobShiftRight::j#9 +Alias (byte) protoBobShiftRight::carry#3 = (byte) protoBobShiftRight::carry#5 (byte) protoBobShiftRight::carry#6 (byte) protoBobShiftRight::carry#4 +Alias (byte) protoBobShiftRight::i#2 = (byte) protoBobShiftRight::i#9 (byte) protoBobShiftRight::i#7 (byte) protoBobShiftRight::i#8 +Alias (byte) protoBobShiftRight::carry#1 = (byte) protoBobShiftRight::new_carry#0 (byte~) protoBobShiftRight::$4 (byte) protoBobShiftRight::carry#9 (byte) protoBobShiftRight::carry#8 +Alias (byte) protoBobShiftRight::j#4 = (byte) protoBobShiftRight::j#5 (byte) protoBobShiftRight::j#6 +Alias (byte) protoBobShiftRight::i#4 = (byte) protoBobShiftRight::i#5 (byte) protoBobShiftRight::i#6 +Alias (byte) protoBobShiftDown::i#2 = (byte) protoBobShiftDown::i#3 +Alias (byte**) renderBobCleanupNext#19 = (byte**) renderBobCleanupNext#27 (byte**) renderBobCleanupNext#3 (byte**) renderBobCleanupNext#23 +Alias (byte*) charsetFindOrAddGlyph::glyph_cursor#0 = (byte*) charsetFindOrAddGlyph::charset#2 +Alias (byte*) charsetFindOrAddGlyph::glyph_cursor#11 = (byte*) charsetFindOrAddGlyph::glyph_cursor#8 (byte*) charsetFindOrAddGlyph::glyph_cursor#12 +Alias (byte*) charsetFindOrAddGlyph::glyph#6 = (byte*) charsetFindOrAddGlyph::glyph#9 (byte*) charsetFindOrAddGlyph::glyph#8 +Alias (byte) charsetFindOrAddGlyph::glyph_id#11 = (byte) charsetFindOrAddGlyph::glyph_id#12 (byte) charsetFindOrAddGlyph::glyph_id#2 +Alias (byte) bob_charset_next_id#15 = (byte) bob_charset_next_id#44 (byte) bob_charset_next_id#34 +Alias (byte*) charsetFindOrAddGlyph::glyph_cursor#10 = (byte*) charsetFindOrAddGlyph::glyph_cursor#2 (byte*) charsetFindOrAddGlyph::glyph_cursor#5 (byte*) charsetFindOrAddGlyph::glyph_cursor#9 +Alias (byte) charsetFindOrAddGlyph::i#2 = (byte) charsetFindOrAddGlyph::i#3 (byte) charsetFindOrAddGlyph::i#4 +Alias (byte*) charsetFindOrAddGlyph::glyph#13 = (byte*) charsetFindOrAddGlyph::glyph#2 (byte*) charsetFindOrAddGlyph::glyph#4 (byte*) charsetFindOrAddGlyph::glyph#7 +Alias (byte) charsetFindOrAddGlyph::found#3 = (byte) charsetFindOrAddGlyph::found#5 (byte) charsetFindOrAddGlyph::found#4 +Alias (byte) charsetFindOrAddGlyph::glyph_id#13 = (byte) charsetFindOrAddGlyph::glyph_id#14 (byte) charsetFindOrAddGlyph::glyph_id#9 (byte) charsetFindOrAddGlyph::glyph_id#8 +Alias (byte) bob_charset_next_id#40 = (byte) bob_charset_next_id#46 (byte) bob_charset_next_id#41 (byte) bob_charset_next_id#45 +Alias (byte) charsetFindOrAddGlyph::glyph_id#3 = (byte) charsetFindOrAddGlyph::glyph_id#6 (byte) charsetFindOrAddGlyph::glyph_id#4 (byte) charsetFindOrAddGlyph::return#2 +Alias (byte*) charsetFindOrAddGlyph::glyph_cursor#3 = (byte*) charsetFindOrAddGlyph::glyph_cursor#6 +Alias (byte) bob_charset_next_id#24 = (byte) bob_charset_next_id#32 (byte) bob_charset_next_id#25 +Alias (byte*) charsetFindOrAddGlyph::glyph#11 = (byte*) charsetFindOrAddGlyph::glyph#12 +Alias (byte) charsetFindOrAddGlyph::return#3 = (byte) charsetFindOrAddGlyph::return#6 +Alias (byte) bob_charset_next_id#16 = (byte) bob_charset_next_id#7 +Alias (byte*) charsetFindOrAddGlyph::glyph#3 = (byte*) charsetFindOrAddGlyph::glyph#5 +Alias (byte) charsetFindOrAddGlyph::i1#2 = (byte) charsetFindOrAddGlyph::i1#3 +Alias (byte*) charsetFindOrAddGlyph::glyph_cursor#4 = (byte*) charsetFindOrAddGlyph::glyph_cursor#7 +Alias (byte) bob_charset_next_id#17 = (byte) bob_charset_next_id#33 (byte) bob_charset_next_id#26 +Alias (byte) charsetFindOrAddGlyph::glyph_id#10 = (byte) charsetFindOrAddGlyph::glyph_id#7 (byte) charsetFindOrAddGlyph::glyph_id#5 (byte) charsetFindOrAddGlyph::return#4 +Alias (byte) bob_charset_next_id#27 = (byte) bob_charset_next_id#35 (byte) bob_charset_next_id#6 +Alias (byte*) progress_cursor#16 = (byte*) progress_cursor#6 (byte*) progress_cursor#7 +Alias (byte) progress_idx#17 = (byte) progress_idx#6 (byte) progress_idx#7 +Alias (byte*) progress_cursor#18 = (byte*) progress_cursor#26 +Alias (byte) progress_idx#10 = (byte) progress_idx#20 (byte) progress_idx#19 +Alias (byte*) progress_cursor#17 = (byte*) progress_cursor#19 (byte*) progress_cursor#9 +Alias (byte*) progress_cursor#27 = (byte*) progress_cursor#5 +Alias (byte) progress_idx#27 = (byte) progress_idx#5 +Alias (byte*) progress_cursor#10 = (byte*) progress_cursor#20 +Alias (byte) progress_idx#11 = (byte) progress_idx#21 +Alias (byte) bob_charset_next_id#18 = (byte) bob_charset_next_id#9 +Alias (byte**) renderBobCleanupNext#15 = (byte**) renderBobCleanupNext#8 +Successful SSA optimization Pass2AliasElimination +Alias (byte*) mulf_init::sqr1_lo#2 = (byte*) mulf_init::sqr1_lo#3 +Alias (byte*) mulf_init::sqr1_hi#2 = (byte*) mulf_init::sqr1_hi#3 +Alias (byte) mulf_init::c#1 = (byte) mulf_init::c#4 +Alias (byte*) mulf_init::sqr2_lo#2 = (byte*) mulf_init::sqr2_lo#4 +Alias (byte) mulf_init::x_255#1 = (byte) mulf_init::x_255#4 +Alias (byte*) mulf_init::sqr2_hi#1 = (byte*) mulf_init::sqr2_hi#4 +Alias (signed byte) mulf8s_prepared::b#1 = (signed byte) mulf8s_prepared::b#2 +Alias (byte) protoBobShiftRight::j#3 = (byte) protoBobShiftRight::j#4 +Alias (byte) protoBobShiftRight::carry#2 = (byte) protoBobShiftRight::carry#3 +Alias (byte) protoBobShiftRight::i#2 = (byte) protoBobShiftRight::i#4 (byte) protoBobShiftRight::i#3 +Alias (byte) protoBobShiftRight::carry#1 = (byte) protoBobShiftRight::carry#7 +Alias (byte) charsetFindOrAddGlyph::glyph_id#13 = (byte) charsetFindOrAddGlyph::glyph_id#3 +Alias (byte*) charsetFindOrAddGlyph::glyph_cursor#10 = (byte*) charsetFindOrAddGlyph::glyph_cursor#3 +Alias (byte) bob_charset_next_id#24 = (byte) bob_charset_next_id#40 +Alias (byte*) charsetFindOrAddGlyph::glyph#11 = (byte*) charsetFindOrAddGlyph::glyph#13 +Successful SSA optimization Pass2AliasElimination +Identical Phi Values (word) memset::num#1 (word) memset::num#0 +Identical Phi Values (void*) memset::str#2 (void*) memset::str#0 +Identical Phi Values (byte) memset::c#3 (byte) memset::c#0 +Identical Phi Values (byte*) memset::end#1 (byte*) memset::end#0 +Identical Phi Values (void*) memset::str#4 (void*) memset::str#2 +Identical Phi Values (byte) memset::c#1 (byte) memset::c#3 +Identical Phi Values (byte) keyboard_matrix_read::rowid#1 (byte) keyboard_matrix_read::rowid#0 +Identical Phi Values (byte) mulf8u_prepare::a#1 (byte) mulf8u_prepare::a#0 +Identical Phi Values (byte) mulf8u_prepared::b#1 (byte) mulf8u_prepared::b#0 +Identical Phi Values (signed byte) mulf8s_prepared::b#1 (signed byte) mulf8s_prepared::b#0 +Identical Phi Values (byte*) progress_cursor#21 (byte*) progress_cursor#27 +Identical Phi Values (byte) progress_idx#22 (byte) progress_idx#27 +Identical Phi Values (byte) bob_charset_next_id#19 (byte) bob_charset_next_id#27 +Identical Phi Values (byte**) renderBobCleanupNext#28 (byte**) renderBobCleanupNext#19 +Identical Phi Values (byte*) progress_cursor#0 (byte*) progress_cursor#15 +Identical Phi Values (byte) progress_idx#0 (byte) progress_idx#16 +Identical Phi Values (byte) bob_charset_next_id#0 (byte) bob_charset_next_id#14 +Identical Phi Values (byte**) renderBobCleanupNext#16 (byte**) renderBobCleanupNext#24 +Identical Phi Values (byte) main::angle#2 (byte) main::angle#8 +Identical Phi Values (byte*) progress_cursor#63 (byte*) progress_cursor#50 +Identical Phi Values (byte) progress_idx#63 (byte) progress_idx#50 +Identical Phi Values (byte) bob_charset_next_id#71 (byte) bob_charset_next_id#58 +Identical Phi Values (byte**) renderBobCleanupNext#0 (byte**) renderBobCleanupNext#14 +Identical Phi Values (byte) main::angle#11 (byte) main::angle#2 +Identical Phi Values (byte*) progress_cursor#51 (byte*) progress_cursor#63 +Identical Phi Values (byte) progress_idx#51 (byte) progress_idx#63 +Identical Phi Values (byte) bob_charset_next_id#59 (byte) bob_charset_next_id#71 +Identical Phi Values (byte**) renderBobCleanupNext#1 (byte**) renderBobCleanupNext#13 +Identical Phi Values (byte) renderBob::xpos#1 (byte) renderBob::xpos#0 +Identical Phi Values (byte) renderBob::ypos#1 (byte) renderBob::ypos#0 +Identical Phi Values (byte**) renderBobCleanupNext#12 (byte**) renderBobCleanupNext#17 +Identical Phi Values (byte*) progress_cursor#23 (byte*) progress_cursor#21 +Identical Phi Values (byte) progress_idx#24 (byte) progress_idx#22 +Identical Phi Values (byte*) progress_cursor#13 (byte*) progress_cursor#16 +Identical Phi Values (byte) progress_idx#14 (byte) progress_idx#17 +Identical Phi Values (byte) bob_charset_next_id#12 (byte) bob_charset_next_id#16 +Identical Phi Values (byte) prepareBobs::bob_table_idx#10 (byte) prepareBobs::bob_table_idx#12 +Identical Phi Values (byte) prepareBobs::shift_x#10 (byte) prepareBobs::shift_x#2 +Identical Phi Values (byte) prepareBobs::shift_y#10 (byte) prepareBobs::shift_y#12 +Identical Phi Values (byte) bob_charset_next_id#13 (byte) bob_charset_next_id#16 +Identical Phi Values (byte) progress_idx#15 (byte) progress_idx#10 +Identical Phi Values (byte*) progress_cursor#14 (byte*) progress_cursor#17 +Identical Phi Values (byte*) charsetFindOrAddGlyph::glyph_cursor#10 (byte*) charsetFindOrAddGlyph::glyph_cursor#11 +Identical Phi Values (byte*) charsetFindOrAddGlyph::glyph#11 (byte*) charsetFindOrAddGlyph::glyph#6 +Identical Phi Values (byte) charsetFindOrAddGlyph::found#3 (byte) charsetFindOrAddGlyph::found#0 +Identical Phi Values (byte) charsetFindOrAddGlyph::glyph_id#13 (byte) charsetFindOrAddGlyph::glyph_id#11 +Identical Phi Values (byte) bob_charset_next_id#24 (byte) bob_charset_next_id#15 +Identical Phi Values (byte*) charsetFindOrAddGlyph::glyph#3 (byte*) charsetFindOrAddGlyph::glyph#6 +Identical Phi Values (byte*) charsetFindOrAddGlyph::glyph_cursor#4 (byte*) charsetFindOrAddGlyph::glyph_cursor#11 +Identical Phi Values (byte) bob_charset_next_id#17 (byte) bob_charset_next_id#15 +Identical Phi Values (byte) charsetFindOrAddGlyph::glyph_id#10 (byte) charsetFindOrAddGlyph::glyph_id#11 +Identical Phi Values (byte*) progress_init::line#1 (byte*) progress_init::line#0 +Identical Phi Values (byte) progress_idx#18 (byte) progress_idx#25 +Identical Phi Values (byte*) progress_cursor#18 (byte*) progress_cursor#24 +Identical Phi Values (byte*) progress_cursor#10 (byte*) progress_cursor#1 +Identical Phi Values (byte) progress_idx#11 (byte) progress_idx#1 +Identical Phi Values (byte) bob_charset_next_id#18 (byte) bob_charset_next_id#1 +Identical Phi Values (byte**) renderBobCleanupNext#15 (byte**) renderBobCleanupNext#11 +Successful SSA optimization Pass2IdenticalPhiElimination +Identical Phi Values (void*) memset::return#0 (void*) memset::str#0 +Identical Phi Values (byte*) progress_cursor#50 (byte*) progress_cursor#15 +Identical Phi Values (byte) progress_idx#50 (byte) progress_idx#16 +Identical Phi Values (byte) bob_charset_next_id#58 (byte) bob_charset_next_id#14 +Identical Phi Values (byte*) progress_cursor#1 (byte*) progress_cursor#50 +Identical Phi Values (byte) progress_idx#1 (byte) progress_idx#50 +Identical Phi Values (byte) bob_charset_next_id#1 (byte) bob_charset_next_id#58 +Identical Phi Values (byte) prepareBobs::shift_y#12 (byte) prepareBobs::shift_y#2 +Identical Phi Values (byte) bob_charset_next_id#15 (byte) bob_charset_next_id#23 +Identical Phi Values (byte*) charsetFindOrAddGlyph::glyph#6 (byte*) charsetFindOrAddGlyph::glyph#10 +Identical Phi Values (byte) charsetFindOrAddGlyph::return#3 (byte) charsetFindOrAddGlyph::glyph_id#11 +Successful SSA optimization Pass2IdenticalPhiElimination +Simple Condition (bool~) memset::$1 [3] if((word) memset::num#0<=(byte) 0) goto memset::@1 +Simple Condition (bool~) memset::$4 [13] if((byte*) memset::dst#2!=(byte*) memset::end#0) goto memset::@5 +Simple Condition (bool~) mulf_init::$0 [50] if((byte*) mulf_init::sqr1_lo#2!=(const byte*) mulf_sqr1_lo+(word) $200) goto mulf_init::@2 +Simple Condition (bool~) mulf_init::$3 [56] if((byte~) mulf_init::$1!=(byte) 0) goto mulf_init::@4 +Simple Condition (bool~) mulf_init::$7 [75] if((byte*) mulf_init::sqr2_lo#2!=(const byte*) mulf_sqr2_lo+(word) $1ff) goto mulf_init::@10 +Simple Condition (bool~) mulf_init::$10 [84] if((byte) mulf_init::x_255#1!=(byte) 0) goto mulf_init::@12 +Simple Condition (bool~) mulf8s_prepared::$3 [114] if(*((const signed byte*) mulf8s_prepared::memA)>=(signed byte) 0) goto mulf8s_prepared::@1 +Simple Condition (bool~) mulf8s_prepared::$5 [118] if((signed byte) mulf8s_prepared::b#0>=(signed byte) 0) goto mulf8s_prepared::@2 +Simple Condition (bool~) main::$8 [209] if(*((const byte*) RASTER)<(byte) $f8) goto main::@4 +Simple Condition (bool~) main::$18 [249] if((byte) main::i#1!=rangelast(0,NUM_BOBS-1)) goto main::@6 +Simple Condition (bool~) main::$20 [260] if((byte) 0==(byte~) main::$19) goto main::@1 +Simple Condition (bool~) main::$22 [268] if((byte) 0!=(byte~) main::$21) goto main::@15 +Simple Condition (bool~) renderBobInit::$2 [319] if((byte) renderBobInit::y#1!=rangelast(0,$1f)) goto renderBobInit::@1 +Simple Condition (bool~) renderBobInit::$3 [326] if((byte) renderBobInit::i#1!=rangelast(0,NUM_BOBS-1)) goto renderBobInit::@3 +Simple Condition (bool~) renderBobCleanup::$0 [372] if((byte) renderBobCleanup::i#1!=rangelast(0,NUM_BOBS-1)) goto renderBobCleanup::@1 +Simple Condition (bool~) prepareBobs::$2 [394] if((byte) prepareBobs::shift_y#2<(const byte) BOB_SHIFTS_Y) goto prepareBobs::@2 +Simple Condition (bool~) prepareBobs::$3 [399] if((byte) prepareBobs::shift_x#2<(const byte) BOB_SHIFTS_X) goto prepareBobs::@5 +Simple Condition (bool~) prepareBobs::$5 [411] if((byte) prepareBobs::cell#2<(byte) 9) goto prepareBobs::@8 +Simple Condition (bool~) protoBobShiftRight::$0 [445] if((byte) protoBobShiftRight::i#2<(byte)(number) 3*(number) 3*(number) 8) goto protoBobShiftRight::@2 +Simple Condition (bool~) protoBobShiftRight::$8 [449] if((byte) 0!=(byte~) protoBobShiftRight::$1) goto protoBobShiftRight::@4 +Simple Condition (bool~) protoBobShiftRight::$7 [461] if((byte) protoBobShiftRight::j#3>=(byte) $30) goto protoBobShiftRight::@7 +Simple Condition (bool~) protoBobShiftDown::$0 [472] if((byte) protoBobShiftDown::i#2>(byte) 0) goto protoBobShiftDown::@2 +Simple Condition (bool~) charsetFindOrAddGlyph::$0 [489] if((byte) charsetFindOrAddGlyph::glyph_id#11!=(byte) bob_charset_next_id#23) goto charsetFindOrAddGlyph::@2 +Simple Condition (bool~) charsetFindOrAddGlyph::$1 [497] if((byte) charsetFindOrAddGlyph::i#2<(byte) 8) goto charsetFindOrAddGlyph::@5 +Simple Condition (bool~) charsetFindOrAddGlyph::$3 [501] if(*((byte*) charsetFindOrAddGlyph::glyph_cursor#11 + (byte) charsetFindOrAddGlyph::i#2)==*((byte*) charsetFindOrAddGlyph::glyph#10 + (byte) charsetFindOrAddGlyph::i#2)) goto charsetFindOrAddGlyph::@7 +Simple Condition (bool~) charsetFindOrAddGlyph::$4 [509] if((byte) 0==(byte) charsetFindOrAddGlyph::found#2) goto charsetFindOrAddGlyph::@16 +Simple Condition (bool~) charsetFindOrAddGlyph::$5 [521] if((byte) charsetFindOrAddGlyph::i1#2<(byte) 8) goto charsetFindOrAddGlyph::@21 +Simple Condition (bool~) progress_inc::$1 [542] if((byte) progress_idx#8!=(byte) 8) goto progress_inc::@1 +Successful SSA optimization Pass2ConditionalJumpSimplification +Negating conditional jump and destination [260] if((byte) 0!=(byte~) main::$19) goto main::@15 +Successful SSA optimization Pass2ConditionalJumpSequenceImprovement +Constant (const word) mulf_init::sqr#0 = 0 +Constant (const byte) mulf_init::x_2#0 = 0 +Constant (const byte) mulf_init::c#0 = 0 +Constant (const byte*) mulf_init::sqr1_hi#0 = mulf_sqr1_hi+1 +Constant (const byte*) mulf_init::sqr1_lo#0 = mulf_sqr1_lo+1 +Constant (const byte) mulf_init::x_255#0 = -1 +Constant (const byte) mulf_init::dir#0 = $ff +Constant (const byte*) mulf_init::sqr2_hi#0 = mulf_sqr2_hi +Constant (const byte*) mulf_init::sqr2_lo#0 = mulf_sqr2_lo +Constant (const byte) mulf_init::dir#1 = 1 +Constant (const byte*) main::vicSelectGfxBank1_gfx#0 = BOB_SCREEN +Constant (const byte*) main::toD0181_screen#0 = BOB_SCREEN +Constant (const byte*) main::toD0181_gfx#0 = BOB_CHARSET +Constant (const void*) memset::str#0 = (void*)BOB_SCREEN +Constant (const byte) memset::c#0 = 0 +Constant (const word) memset::num#0 = $3e8 +Constant (const byte) main::angle#0 = 0 +Constant (const signed byte) main::r#0 = $1e +Constant (const byte) main::i#0 = 0 +Constant (const byte) keyboard_key_pressed::key#0 = KEY_SPACE +Constant (const byte) keyboard_key_pressed::key#1 = KEY_SPACE +Constant (const byte*) main::vicSelectGfxBank2_gfx#0 = SCREEN_BASIC +Constant (const byte*) main::toD0182_screen#0 = SCREEN_BASIC +Constant (const byte*) main::toD0182_gfx#0 = CHARSET_BASIC +Constant (const byte**) renderBobCleanupNext#19 = (byte**) 0 +Constant (const byte) renderBobInit::y#0 = 0 +Constant (const byte) renderBobInit::i#0 = 0 +Constant (const byte) renderBobCleanup::i#0 = 0 +Constant (const byte**) renderBobCleanupNext#14 = RENDERBOB_CLEANUP +Constant (const byte*) progress_init::line#0 = SCREEN_BASIC +Constant (const byte) bob_charset_next_id#2 = 0 +Constant (const byte*) charsetFindOrAddGlyph::glyph#0 = PROTO_BOB+$30 +Constant (const byte*) charsetFindOrAddGlyph::charset#0 = BOB_CHARSET +Constant (const byte) prepareBobs::bob_table_idx#0 = 0 +Constant (const byte) prepareBobs::shift_y#0 = 0 +Constant (const byte) prepareBobs::shift_x#0 = 0 +Constant (const byte*) prepareBobs::bob_glyph#0 = PROTO_BOB +Constant (const byte) prepareBobs::cell#0 = 0 +Constant (const byte*) charsetFindOrAddGlyph::charset#1 = BOB_CHARSET +Constant (const byte) protoBobShiftRight::carry#0 = 0 +Constant (const byte) protoBobShiftRight::j#0 = 0 +Constant (const byte) protoBobShiftRight::i#0 = 0 +Constant (const byte) protoBobShiftRight::$3 = $80 +Constant (const byte) protoBobShiftRight::$2 = 0 +Constant (const byte) protoBobShiftDown::i#0 = $17 +Constant (const byte) bob_charset_next_id#27 = 0 +Constant (const byte) charsetFindOrAddGlyph::glyph_id#0 = 0 +Constant (const byte) charsetFindOrAddGlyph::found#0 = 1 +Constant (const byte) charsetFindOrAddGlyph::i#0 = 0 +Constant (const byte) charsetFindOrAddGlyph::i1#0 = 0 +Constant (const byte) charsetFindOrAddGlyph::found#1 = 0 +Constant (const byte*) progress_cursor#27 = (byte*) 0 +Constant (const byte) progress_idx#27 = 0 +Constant (const byte) progress_idx#17 = 0 +Constant (const byte) progress_idx#9 = 0 +Successful SSA optimization Pass2ConstantIdentification +Constant (const byte*) memset::$2 = (byte*)memset::str#0 +Constant (const byte*) memset::dst#0 = (byte*)memset::str#0 +Constant (const word) main::vicSelectGfxBank1_toDd001_$0 = (word)main::vicSelectGfxBank1_gfx#0 +Constant (const word) main::toD0181_$0 = (word)main::toD0181_screen#0 +Constant (const word) main::toD0181_$4 = (word)main::toD0181_gfx#0 +Constant (const void*) memset::return#2 = memset::str#0 +Constant (const word) main::vicSelectGfxBank2_toDd001_$0 = (word)main::vicSelectGfxBank2_gfx#0 +Constant (const word) main::toD0182_$0 = (word)main::toD0182_screen#0 +Constant (const word) main::toD0182_$4 = (word)main::toD0182_gfx#0 +Constant (const byte*) progress_cursor#16 = progress_init::line#0 +Successful SSA optimization Pass2ConstantIdentification +if() condition always false - eliminating [3] if((const word) memset::num#0<=(byte) 0) goto memset::@1 +Removing PHI-reference to removed block (main::@1) in block main::@15 +if() condition always true - replacing block destination [206] if(true) goto main::@4 +Successful SSA optimization Pass2ConstantIfs +Resolved ranged next value [247] main::i#1 ← ++ main::i#2 to ++ +Resolved ranged comparison value [249] if(main::i#1!=rangelast(0,NUM_BOBS-1)) goto main::@6 to (const byte) NUM_BOBS-(byte) 1+(number) 1 +Resolved ranged next value [317] renderBobInit::y#1 ← ++ renderBobInit::y#2 to ++ +Resolved ranged comparison value [319] if(renderBobInit::y#1!=rangelast(0,$1f)) goto renderBobInit::@1 to (number) $20 +Resolved ranged next value [324] renderBobInit::i#1 ← ++ renderBobInit::i#2 to ++ +Resolved ranged comparison value [326] if(renderBobInit::i#1!=rangelast(0,NUM_BOBS-1)) goto renderBobInit::@3 to (const byte) NUM_BOBS-(byte) 1+(number) 1 +Resolved ranged next value [370] renderBobCleanup::i#1 ← ++ renderBobCleanup::i#2 to ++ +Resolved ranged comparison value [372] if(renderBobCleanup::i#1!=rangelast(0,NUM_BOBS-1)) goto renderBobCleanup::@1 to (const byte) NUM_BOBS-(byte) 1+(number) 1 +Simplifying constant evaluating to zero (byte) 0*(const byte) BOB_SUBTABLE_SIZE in [345] *((byte*) renderBob::screen#0 + (byte) 0) ← *((const byte*) BOB_TABLES+(byte) 0*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) +Successful SSA optimization PassNSimplifyConstantZero +Simplifying expression containing zero BOB_TABLES in [345] *((byte*) renderBob::screen#0 + (byte) 0) ← *((const byte*) BOB_TABLES+(byte) 0 + (byte) renderBob::bob_table_idx#0) +Simplifying expression containing zero renderBob::screen#0 in [345] *((byte*) renderBob::screen#0 + (byte) 0) ← *((const byte*) BOB_TABLES + (byte) renderBob::bob_table_idx#0) +Simplifying expression containing zero renderBobCleanup::screen#0 in [361] *((byte*) renderBobCleanup::screen#0 + (byte) 0) ← (byte) 0 +Simplifying expression containing zero PROTO_BOB in [478] *((const byte*) PROTO_BOB + (byte) 0) ← (byte) 0 +Successful SSA optimization PassNSimplifyExpressionWithZero +Eliminating unused variable - keeping the phi block (byte**) renderBobCleanupNext#24 +Eliminating unused variable - keeping the phi block (byte**) renderBobCleanupNext#11 +Eliminating unused variable (byte) charsetFindOrAddGlyph::return#0 and assignment [199] (byte) charsetFindOrAddGlyph::return#0 ← (byte) charsetFindOrAddGlyph::glyph_id#11 +Eliminating unused constant (const void*) memset::return#2 +Eliminating unused constant (const byte) bob_charset_next_id#27 +Eliminating unused constant (const byte*) progress_cursor#27 +Eliminating unused constant (const byte) progress_idx#27 +Successful SSA optimization PassNEliminateUnusedVars +Eliminating unused constant (const byte**) renderBobCleanupNext#19 +Successful SSA optimization PassNEliminateUnusedVars +Adding number conversion cast (unumber) NUM_BOBS-1+1 in if((byte) main::i#1!=(const byte) NUM_BOBS-(byte) 1+(number) 1) goto main::@6 +Adding number conversion cast (unumber) 1 in if((byte) main::i#1!=(unumber)(const byte) NUM_BOBS-(byte) 1+(number) 1) goto main::@6 +Adding number conversion cast (unumber) $20 in if((byte) renderBobInit::y#1!=(number) $20) goto renderBobInit::@1 +Adding number conversion cast (unumber) NUM_BOBS-1+1 in if((byte) renderBobInit::i#1!=(const byte) NUM_BOBS-(byte) 1+(number) 1) goto renderBobInit::@3 +Adding number conversion cast (unumber) 1 in if((byte) renderBobInit::i#1!=(unumber)(const byte) NUM_BOBS-(byte) 1+(number) 1) goto renderBobInit::@3 +Adding number conversion cast (unumber) NUM_BOBS-1+1 in if((byte) renderBobCleanup::i#1!=(const byte) NUM_BOBS-(byte) 1+(number) 1) goto renderBobCleanup::@1 +Adding number conversion cast (unumber) 1 in if((byte) renderBobCleanup::i#1!=(unumber)(const byte) NUM_BOBS-(byte) 1+(number) 1) goto renderBobCleanup::@1 +Successful SSA optimization PassNAddNumberTypeConversions +Simplifying constant integer cast (const byte) NUM_BOBS-(byte) 1+(unumber)(number) 1 +Simplifying constant integer cast 1 +Simplifying constant integer cast $20 +Simplifying constant integer cast (const byte) NUM_BOBS-(byte) 1+(unumber)(number) 1 +Simplifying constant integer cast 1 +Simplifying constant integer cast (const byte) NUM_BOBS-(byte) 1+(unumber)(number) 1 +Simplifying constant integer cast 1 +Successful SSA optimization PassNCastSimplification +Finalized unsigned number type (byte) 1 +Finalized unsigned number type (byte) $20 +Finalized unsigned number type (byte) 1 +Finalized unsigned number type (byte) 1 +Successful SSA optimization PassNFinalizeNumberTypeConversions +Constant right-side identified [0] (byte*) memset::end#0 ← (const byte*) memset::$2 + (const word) memset::num#0 +Constant right-side identified [82] (byte~) main::vicSelectGfxBank1_toDd001_$1 ← > (const word) main::vicSelectGfxBank1_toDd001_$0 +Constant right-side identified [86] (word~) main::toD0181_$1 ← (const word) main::toD0181_$0 & (word) $3fff +Constant right-side identified [89] (byte~) main::toD0181_$5 ← > (const word) main::toD0181_$4 +Constant right-side identified [134] (byte~) main::vicSelectGfxBank2_toDd001_$1 ← > (const word) main::vicSelectGfxBank2_toDd001_$0 +Constant right-side identified [138] (word~) main::toD0182_$1 ← (const word) main::toD0182_$0 & (word) $3fff +Constant right-side identified [141] (byte~) main::toD0182_$5 ← > (const word) main::toD0182_$4 +Successful SSA optimization Pass2ConstantRValueConsolidation +Constant (const byte*) memset::end#0 = memset::$2+memset::num#0 +Constant (const byte) main::vicSelectGfxBank1_toDd001_$1 = >main::vicSelectGfxBank1_toDd001_$0 +Constant (const word) main::toD0181_$1 = main::toD0181_$0&$3fff +Constant (const byte) main::toD0181_$5 = >main::toD0181_$4 +Constant (const byte) main::vicSelectGfxBank2_toDd001_$1 = >main::vicSelectGfxBank2_toDd001_$0 +Constant (const word) main::toD0182_$1 = main::toD0182_$0&$3fff +Constant (const byte) main::toD0182_$5 = >main::toD0182_$4 +Successful SSA optimization Pass2ConstantIdentification +Constant right-side identified [81] (byte~) main::vicSelectGfxBank1_toDd001_$2 ← (const byte) main::vicSelectGfxBank1_toDd001_$1 / (byte) $40 +Constant right-side identified [84] (word~) main::toD0181_$2 ← (const word) main::toD0181_$1 * (byte) 4 +Constant right-side identified [86] (byte~) main::toD0181_$6 ← (const byte) main::toD0181_$5 / (byte) 4 +Constant right-side identified [129] (byte~) main::vicSelectGfxBank2_toDd001_$2 ← (const byte) main::vicSelectGfxBank2_toDd001_$1 / (byte) $40 +Constant right-side identified [132] (word~) main::toD0182_$2 ← (const word) main::toD0182_$1 * (byte) 4 +Constant right-side identified [134] (byte~) main::toD0182_$6 ← (const byte) main::toD0182_$5 / (byte) 4 +Successful SSA optimization Pass2ConstantRValueConsolidation +Constant (const byte) main::vicSelectGfxBank1_toDd001_$2 = main::vicSelectGfxBank1_toDd001_$1/$40 +Constant (const word) main::toD0181_$2 = main::toD0181_$1*4 +Constant (const byte) main::toD0181_$6 = main::toD0181_$5/4 +Constant (const byte) main::vicSelectGfxBank2_toDd001_$2 = main::vicSelectGfxBank2_toDd001_$1/$40 +Constant (const word) main::toD0182_$2 = main::toD0182_$1*4 +Constant (const byte) main::toD0182_$6 = main::toD0182_$5/4 +Successful SSA optimization Pass2ConstantIdentification +Simplifying constant evaluating to zero (const byte) main::vicSelectGfxBank1_toDd001_$1/(byte) $40 in +Simplifying constant evaluating to zero (const byte) main::vicSelectGfxBank2_toDd001_$1/(byte) $40 in +Successful SSA optimization PassNSimplifyConstantZero +Simplifying expression containing zero 3 in [82] (byte) main::vicSelectGfxBank1_toDd001_return#0 ← (byte) 3 ^ (const byte) main::vicSelectGfxBank1_toDd001_$2 +Simplifying expression containing zero 3 in [130] (byte) main::vicSelectGfxBank2_toDd001_return#0 ← (byte) 3 ^ (const byte) main::vicSelectGfxBank2_toDd001_$2 +Successful SSA optimization PassNSimplifyExpressionWithZero +Eliminating unused constant (const byte) main::vicSelectGfxBank1_toDd001_$1 +Eliminating unused constant (const byte) main::vicSelectGfxBank2_toDd001_$1 +Eliminating unused constant (const byte) main::vicSelectGfxBank1_toDd001_$2 +Eliminating unused constant (const byte) main::vicSelectGfxBank2_toDd001_$2 +Successful SSA optimization PassNEliminateUnusedVars +Eliminating unused constant (const word) main::vicSelectGfxBank1_toDd001_$0 +Eliminating unused constant (const word) main::vicSelectGfxBank2_toDd001_$0 +Successful SSA optimization PassNEliminateUnusedVars +Eliminating unused constant (const byte*) main::vicSelectGfxBank1_gfx#0 +Eliminating unused constant (const byte*) main::vicSelectGfxBank2_gfx#0 +Successful SSA optimization PassNEliminateUnusedVars +Constant right-side identified [83] (byte~) main::toD0181_$3 ← > (const word) main::toD0181_$2 +Constant right-side identified [84] (byte~) main::toD0181_$7 ← (const byte) main::toD0181_$6 & (byte) $f +Constant right-side identified [128] (byte~) main::toD0182_$3 ← > (const word) main::toD0182_$2 +Constant right-side identified [129] (byte~) main::toD0182_$7 ← (const byte) main::toD0182_$6 & (byte) $f +Successful SSA optimization Pass2ConstantRValueConsolidation +Constant (const byte) main::vicSelectGfxBank1_toDd001_return#0 = 3 +Constant (const byte) main::toD0181_$3 = >main::toD0181_$2 +Constant (const byte) main::toD0181_$7 = main::toD0181_$6&$f +Constant (const byte) main::vicSelectGfxBank2_toDd001_return#0 = 3 +Constant (const byte) main::toD0182_$3 = >main::toD0182_$2 +Constant (const byte) main::toD0182_$7 = main::toD0182_$6&$f +Successful SSA optimization Pass2ConstantIdentification +Constant right-side identified [82] (byte) main::toD0181_return#0 ← (const byte) main::toD0181_$3 | (const byte) main::toD0181_$7 +Constant right-side identified [124] (byte) main::toD0182_return#0 ← (const byte) main::toD0182_$3 | (const byte) main::toD0182_$7 +Successful SSA optimization Pass2ConstantRValueConsolidation +Constant (const byte) main::toD0181_return#0 = main::toD0181_$3|main::toD0181_$7 +Constant (const byte) main::toD0182_return#0 = main::toD0182_$3|main::toD0182_$7 +Successful SSA optimization Pass2ConstantIdentification +Inlining Noop Cast [59] (byte~) mulf8s_prepared::$9 ← (byte)(signed byte) mulf8s_prepared::b#0 keeping mulf8s_prepared::b#0 +Inlining Noop Cast [63] (signed word) mulf8s_prepared::return#0 ← (signed word)(word) mulf8s_prepared::m#4 keeping mulf8s_prepared::m#4 +Inlining Noop Cast [65] (byte~) mulf8s_prepared::$13 ← (byte)*((const signed byte*) mulf8s_prepared::memA) keeping *(mulf8s_prepared::memA) +Successful SSA optimization Pass2NopCastInlining +Inlining Noop Cast [74] (signed word) mulf8s_prepared::return#2 ← (signed word)(word) mulf8s_prepared::m#4 keeping mulf8s_prepared::m#4 +Successful SSA optimization Pass2NopCastInlining +Rewriting multiplication to use shift [101] (signed word~) main::$13 ← (signed word~) main::$12 * (signed byte) 2 +Rewriting multiplication to use shift and addition[127] (word~) renderBobInit::$1 ← (word~) renderBobInit::$0 * (byte) $28 +Rewriting multiplication to use shift [128] (byte~) renderBobInit::$4 ← (byte) renderBobInit::y#2 * (const byte) SIZEOF_WORD +Rewriting multiplication to use shift [133] (byte~) renderBobInit::$5 ← (byte) renderBobInit::i#2 * (const byte) SIZEOF_POINTER +Rewriting division to use shift [138] (byte) renderBob::x_char_offset#0 ← (byte) renderBob::xpos#0 / (const byte) BOB_SHIFTS_X +Rewriting division to use shift [139] (byte) renderBob::y_char_offset#0 ← (byte) renderBob::ypos#0 / (const byte) BOB_SHIFTS_Y +Rewriting multiplication to use shift [140] (byte~) renderBob::$8 ← (byte) renderBob::y_char_offset#0 * (const byte) SIZEOF_WORD +Rewriting multiplication to use shift [145] (byte~) renderBob::$5 ← (byte~) renderBob::$4 * (const byte) BOB_SHIFTS_X +Rewriting multiplication to use shift [161] (byte~) renderBobCleanup::$1 ← (byte) renderBobCleanup::i#2 * (const byte) SIZEOF_POINTER +Successful SSA optimization Pass2MultiplyToShiftRewriting +Inlining constant with var siblings (const byte*) memset::dst#0 +Inlining constant with var siblings (const byte) keyboard_key_pressed::key#0 +Inlining constant with var siblings (const byte) keyboard_key_pressed::key#1 +Inlining constant with var siblings (const word) mulf_init::sqr#0 +Inlining constant with var siblings (const byte) mulf_init::x_2#0 +Inlining constant with var siblings (const byte) mulf_init::c#0 +Inlining constant with var siblings (const byte*) mulf_init::sqr1_hi#0 +Inlining constant with var siblings (const byte*) mulf_init::sqr1_lo#0 +Inlining constant with var siblings (const byte) mulf_init::x_255#0 +Inlining constant with var siblings (const byte) mulf_init::dir#0 +Inlining constant with var siblings (const byte*) mulf_init::sqr2_hi#0 +Inlining constant with var siblings (const byte*) mulf_init::sqr2_lo#0 +Inlining constant with var siblings (const byte) mulf_init::dir#1 +Inlining constant with var siblings (const byte) main::angle#0 +Inlining constant with var siblings (const signed byte) main::r#0 +Inlining constant with var siblings (const byte) main::i#0 +Inlining constant with var siblings (const byte) renderBobInit::y#0 +Inlining constant with var siblings (const byte) renderBobInit::i#0 +Inlining constant with var siblings (const byte) renderBobCleanup::i#0 +Inlining constant with var siblings (const byte) prepareBobs::bob_table_idx#0 +Inlining constant with var siblings (const byte) prepareBobs::shift_y#0 +Inlining constant with var siblings (const byte) prepareBobs::shift_x#0 +Inlining constant with var siblings (const byte*) prepareBobs::bob_glyph#0 +Inlining constant with var siblings (const byte) prepareBobs::cell#0 +Inlining constant with var siblings (const byte) protoBobShiftRight::carry#0 +Inlining constant with var siblings (const byte) protoBobShiftRight::j#0 +Inlining constant with var siblings (const byte) protoBobShiftRight::i#0 +Inlining constant with var siblings (const byte) protoBobShiftDown::i#0 +Inlining constant with var siblings (const byte*) charsetFindOrAddGlyph::glyph#0 +Inlining constant with var siblings (const byte) charsetFindOrAddGlyph::glyph_id#0 +Inlining constant with var siblings (const byte) charsetFindOrAddGlyph::found#0 +Inlining constant with var siblings (const byte) charsetFindOrAddGlyph::i#0 +Inlining constant with var siblings (const byte) charsetFindOrAddGlyph::i1#0 +Inlining constant with var siblings (const byte) charsetFindOrAddGlyph::found#1 +Inlining constant with var siblings (const byte**) renderBobCleanupNext#14 +Inlining constant with var siblings (const byte) bob_charset_next_id#2 +Inlining constant with var siblings (const byte) progress_idx#17 +Inlining constant with var siblings (const byte) progress_idx#9 +Inlining constant with var siblings (const byte*) progress_cursor#16 +Constant inlined mulf_init::sqr2_lo#0 = (const byte*) mulf_sqr2_lo +Constant inlined charsetFindOrAddGlyph::i#0 = (byte) 0 +Constant inlined prepareBobs::bob_table_idx#0 = (byte) 0 +Constant inlined charsetFindOrAddGlyph::i1#0 = (byte) 0 +Constant inlined mulf_init::sqr2_hi#0 = (const byte*) mulf_sqr2_hi +Constant inlined main::toD0182_$4 = (word)(const byte*) CHARSET_BASIC +Constant inlined main::toD0182_$5 = >(word)(const byte*) CHARSET_BASIC +Constant inlined main::toD0182_$6 = >(word)(const byte*) CHARSET_BASIC/(byte) 4 +Constant inlined main::toD0182_$7 = >(word)(const byte*) CHARSET_BASIC/(byte) 4&(byte) $f +Constant inlined main::toD0182_$0 = (word)(const byte*) SCREEN_BASIC +Constant inlined main::toD0182_$1 = (word)(const byte*) SCREEN_BASIC&(word) $3fff +Constant inlined main::toD0182_$2 = (word)(const byte*) SCREEN_BASIC&(word) $3fff*(byte) 4 +Constant inlined protoBobShiftRight::j#0 = (byte) 0 +Constant inlined main::toD0182_$3 = >(word)(const byte*) SCREEN_BASIC&(word) $3fff*(byte) 4 +Constant inlined mulf_init::dir#1 = (byte) 1 +Constant inlined mulf_init::dir#0 = (byte) $ff +Constant inlined bob_charset_next_id#2 = (byte) 0 +Constant inlined protoBobShiftRight::$3 = (byte) $80 +Constant inlined protoBobShiftDown::i#0 = (byte) $17 +Constant inlined mulf_init::x_255#0 = (byte) -1 +Constant inlined protoBobShiftRight::$2 = (byte) 0 +Constant inlined mulf_init::x_2#0 = (byte) 0 +Constant inlined keyboard_key_pressed::key#0 = (const byte) KEY_SPACE +Constant inlined keyboard_key_pressed::key#1 = (const byte) KEY_SPACE +Constant inlined main::toD0181_$7 = >(word)(const byte*) BOB_CHARSET/(byte) 4&(byte) $f +Constant inlined main::toD0182_gfx#0 = (const byte*) CHARSET_BASIC +Constant inlined prepareBobs::shift_x#0 = (byte) 0 +Constant inlined progress_idx#9 = (byte) 0 +Constant inlined main::toD0181_$2 = (word)(const byte*) BOB_SCREEN&(word) $3fff*(byte) 4 +Constant inlined main::toD0181_$1 = (word)(const byte*) BOB_SCREEN&(word) $3fff +Constant inlined main::toD0181_$0 = (word)(const byte*) BOB_SCREEN +Constant inlined main::toD0181_$6 = >(word)(const byte*) BOB_CHARSET/(byte) 4 +Constant inlined main::toD0181_$5 = >(word)(const byte*) BOB_CHARSET +Constant inlined main::toD0181_$4 = (word)(const byte*) BOB_CHARSET +Constant inlined main::toD0181_$3 = >(word)(const byte*) BOB_SCREEN&(word) $3fff*(byte) 4 +Constant inlined mulf_init::sqr1_hi#0 = (const byte*) mulf_sqr1_hi+(byte) 1 +Constant inlined prepareBobs::cell#0 = (byte) 0 +Constant inlined renderBobCleanupNext#14 = (const byte**) RENDERBOB_CLEANUP +Constant inlined mulf_init::sqr1_lo#0 = (const byte*) mulf_sqr1_lo+(byte) 1 +Constant inlined memset::dst#0 = (byte*)(const void*) memset::str#0 +Constant inlined charsetFindOrAddGlyph::glyph#0 = (const byte*) PROTO_BOB+(byte) $30 +Constant inlined mulf_init::c#0 = (byte) 0 +Constant inlined main::toD0181_screen#0 = (const byte*) BOB_SCREEN +Constant inlined main::toD0181_gfx#0 = (const byte*) BOB_CHARSET +Constant inlined protoBobShiftRight::carry#0 = (byte) 0 +Constant inlined progress_init::line#0 = (const byte*) SCREEN_BASIC +Constant inlined protoBobShiftRight::i#0 = (byte) 0 +Constant inlined memset::$2 = (byte*)(const void*) memset::str#0 +Constant inlined progress_cursor#16 = (const byte*) SCREEN_BASIC +Constant inlined prepareBobs::bob_glyph#0 = (const byte*) PROTO_BOB +Constant inlined main::i#0 = (byte) 0 +Constant inlined renderBobCleanup::i#0 = (byte) 0 +Constant inlined main::r#0 = (signed byte) $1e +Constant inlined prepareBobs::shift_y#0 = (byte) 0 +Constant inlined mulf_init::sqr#0 = (byte) 0 +Constant inlined charsetFindOrAddGlyph::charset#0 = (const byte*) BOB_CHARSET +Constant inlined charsetFindOrAddGlyph::glyph_id#0 = (byte) 0 +Constant inlined charsetFindOrAddGlyph::charset#1 = (const byte*) BOB_CHARSET +Constant inlined progress_idx#17 = (byte) 0 +Constant inlined renderBobInit::y#0 = (byte) 0 +Constant inlined charsetFindOrAddGlyph::found#1 = (byte) 0 +Constant inlined charsetFindOrAddGlyph::found#0 = (byte) 1 +Constant inlined main::angle#0 = (byte) 0 +Constant inlined main::toD0182_screen#0 = (const byte*) SCREEN_BASIC +Constant inlined renderBobInit::i#0 = (byte) 0 +Successful SSA optimization Pass2ConstantInlining +Consolidated array index constant in *(PROTO_BOB+$18) +Consolidated array index constant in *(PROTO_BOB+$30) +Consolidated array index constant in *(progress_inc::progress_chars+8) +Successful SSA optimization Pass2ConstantAdditionElimination +Alias (word~) renderBobInit::$1 = (word~) renderBobInit::$8 +Successful SSA optimization Pass2AliasElimination +Identical Phi Values (byte) keyboard_key_pressed::key#2 (const byte) KEY_SPACE +Identical Phi Values (byte*) charsetFindOrAddGlyph::glyph_cursor#0 (const byte*) BOB_CHARSET +Successful SSA optimization Pass2IdenticalPhiElimination +Constant right-side identified [9] (byte) keyboard_key_pressed::colidx#0 ← (const byte) KEY_SPACE & (byte) 7 +Constant right-side identified [10] (byte) keyboard_key_pressed::rowidx#0 ← (const byte) KEY_SPACE >> (byte) 3 +Successful SSA optimization Pass2ConstantRValueConsolidation +Constant (const byte) keyboard_key_pressed::colidx#0 = KEY_SPACE&7 +Constant (const byte) keyboard_key_pressed::rowidx#0 = KEY_SPACE>>3 +Successful SSA optimization Pass2ConstantIdentification +Constant (const byte) keyboard_matrix_read::rowid#0 = keyboard_key_pressed::rowidx#0 +Successful SSA optimization Pass2ConstantIdentification +Eliminating unused constant (const byte) SIZEOF_WORD +Successful SSA optimization PassNEliminateUnusedVars +Constant inlined keyboard_matrix_read::rowid#0 = (const byte) keyboard_key_pressed::rowidx#0 +Successful SSA optimization Pass2ConstantInlining +Consolidated array index constant in *(keyboard_matrix_row_bitmask+keyboard_key_pressed::rowidx#0) +Consolidated array index constant in *(keyboard_matrix_col_bitmask+keyboard_key_pressed::colidx#0) +Successful SSA optimization Pass2ConstantAdditionElimination +Added new block during phi lifting mulf_init::@17(between mulf_init::@2 and mulf_init::@4) +Added new block during phi lifting mulf_init::@18(between mulf_init::@10 and mulf_init::@12) +Added new block during phi lifting mulf8s_prepared::@7(between mulf8s_prepared::@6 and mulf8s_prepared::@1) +Added new block during phi lifting mulf8s_prepared::@8(between mulf8s_prepared::@1 and mulf8s_prepared::@2) +Added new block during phi lifting main::@35(between main::@33 and main::@1) +Added new block during phi lifting main::@36(between main::@32 and main::@6) +Added new block during phi lifting renderBobInit::@5(between renderBobInit::@1 and renderBobInit::@1) +Added new block during phi lifting renderBobInit::@6(between renderBobInit::@3 and renderBobInit::@3) +Added new block during phi lifting renderBobCleanup::@3(between renderBobCleanup::@1 and renderBobCleanup::@1) +Added new block during phi lifting progress_inc::@3(between progress_inc and progress_inc::@1) +Adding NOP phi() at start of @begin +Adding NOP phi() at start of @59 +Adding NOP phi() at start of @65 +Adding NOP phi() at start of @66 +Adding NOP phi() at start of @68 +Adding NOP phi() at start of @69 +Adding NOP phi() at start of @end +Adding NOP phi() at start of main +Adding NOP phi() at start of main::@25 +Adding NOP phi() at start of main::@26 +Adding NOP phi() at start of main::@27 +Adding NOP phi() at start of main::vicSelectGfxBank1_toDd001 +Adding NOP phi() at start of main::vicSelectGfxBank1_toDd001_@return +Adding NOP phi() at start of main::@21 +Adding NOP phi() at start of main::toD0181 +Adding NOP phi() at start of main::toD0181_@return +Adding NOP phi() at start of main::@28 +Adding NOP phi() at start of main::@15 +Adding NOP phi() at start of main::@17 +Adding NOP phi() at start of main::vicSelectGfxBank2_toDd001 +Adding NOP phi() at start of main::vicSelectGfxBank2_toDd001_@return +Adding NOP phi() at start of main::@23 +Adding NOP phi() at start of main::toD0182 +Adding NOP phi() at start of main::toD0182_@return +Adding NOP phi() at start of keyboard_key_pressed +Adding NOP phi() at start of mulf8s::@3 +Adding NOP phi() at start of renderBobCleanup +Adding NOP phi() at start of renderBobCleanup::@2 +Adding NOP phi() at start of memset +Adding NOP phi() at start of memset::@2 +Adding NOP phi() at start of memset::@1 +Adding NOP phi() at start of renderBobInit +Adding NOP phi() at start of renderBobInit::@2 +Adding NOP phi() at start of prepareBobs +Adding NOP phi() at start of prepareBobs::@19 +Adding NOP phi() at start of prepareBobs::@6 +Adding NOP phi() at start of prepareBobs::@24 +Adding NOP phi() at start of charsetFindOrAddGlyph::@3 +Adding NOP phi() at start of charsetFindOrAddGlyph::@2 +Adding NOP phi() at start of charsetFindOrAddGlyph::@11 +Adding NOP phi() at start of protoBobShiftRight +Adding NOP phi() at start of protoBobShiftRight::@5 +Adding NOP phi() at start of protoBobShiftRight::@4 +Adding NOP phi() at start of protoBobShiftDown +Adding NOP phi() at start of progress_init +Adding NOP phi() at start of mulf_init +Adding NOP phi() at start of mulf_init::@3 +Adding NOP phi() at start of mulf_init::@15 +CALL GRAPH +Calls in [] to main:5 +Calls in [main] to mulf_init:9 prepareBobs:11 renderBobInit:13 memset:23 renderBobCleanup:28 mulf8s:36 mulf8s:44 renderBob:54 keyboard_key_pressed:59 keyboard_key_pressed:65 +Calls in [keyboard_key_pressed] to keyboard_matrix_read:84 +Calls in [mulf8s] to mulf8u_prepare:116 mulf8s_prepared:119 +Calls in [mulf8s_prepared] to mulf8u_prepared:123 +Calls in [prepareBobs] to progress_init:195 charsetFindOrAddGlyph:197 protoBobShiftDown:209 protoBobShiftRight:224 protoBobShiftRight:226 charsetFindOrAddGlyph:236 progress_inc:242 + +Created 57 initial phi equivalence classes +Not coalescing [29] main::a#6 ← main::angle#8 +Coalesced [34] mulf8s::mulf8s_prepare1_a#3 ← mulf8s::a#0 +Coalesced [35] mulf8s::b#7 ← mulf8s::b#0 +Coalesced [42] mulf8s::mulf8s_prepare1_a#2 ← mulf8s::a#1 +Coalesced [43] mulf8s::b#6 ← mulf8s::b#1 +Coalesced [63] main::angle#12 ← main::angle#1 +Coalesced [79] main::r#6 ← main::r#1 +Coalesced [80] main::a#7 ← main::a#1 +Coalesced [81] renderBobCleanupNext#51 ← renderBobCleanupNext#13 +Coalesced [82] main::i#6 ← main::i#1 +Coalesced [130] mulf8s_prepared::m#7 ← mulf8s_prepared::m#1 +Coalesced [136] mulf8s_prepared::m#10 ← mulf8s_prepared::m#2 +Coalesced [139] mulf8s_prepared::m#9 ← mulf8s_prepared::m#5 +Coalesced [140] mulf8s_prepared::m#8 ← mulf8s_prepared::m#0 +Coalesced [165] renderBobCleanup::i#3 ← renderBobCleanup::i#1 +Coalesced [174] memset::dst#4 ← memset::dst#1 +Coalesced [192] renderBobInit::i#3 ← renderBobInit::i#1 +Coalesced [193] renderBobInit::y#3 ← renderBobInit::y#1 +Coalesced [198] bob_charset_next_id#78 ← bob_charset_next_id#16 +Coalesced [202] prepareBobs::bob_table_idx#16 ← prepareBobs::bob_table_idx#6 +Coalesced [203] bob_charset_next_id#80 ← bob_charset_next_id#14 +Coalesced [204] progress_cursor#71 ← progress_cursor#15 +Coalesced [205] progress_idx#71 ← progress_idx#16 +Coalesced [211] prepareBobs::shift_y#15 ← prepareBobs::shift_y#1 +Coalesced (already) [212] progress_cursor#70 ← progress_cursor#31 +Coalesced (already) [213] progress_idx#70 ← progress_idx#31 +Coalesced (already) [214] bob_charset_next_id#79 ← bob_charset_next_id#30 +Coalesced (already) [215] prepareBobs::bob_table_idx#15 ← prepareBobs::bob_table_idx#12 +Coalesced [217] bob_charset_next_id#83 ← bob_charset_next_id#30 +Coalesced [218] prepareBobs::bob_table#7 ← prepareBobs::bob_table#0 +Coalesced [219] progress_idx#74 ← progress_idx#31 +Coalesced [220] progress_cursor#74 ← progress_cursor#31 +Coalesced [228] prepareBobs::shift_x#11 ← prepareBobs::shift_x#1 +Coalesced [229] prepareBobs::bob_table_idx#17 ← prepareBobs::bob_table_idx#1 +Coalesced (already) [230] bob_charset_next_id#81 ← bob_charset_next_id#21 +Coalesced (already) [231] progress_cursor#72 ← progress_cursor#24 +Coalesced (already) [232] progress_idx#72 ← progress_idx#25 +Coalesced [234] bob_charset_next_id#84 ← bob_charset_next_id#21 +Coalesced [235] charsetFindOrAddGlyph::glyph#14 ← charsetFindOrAddGlyph::glyph#1 +Coalesced [244] prepareBobs::cell#6 ← prepareBobs::cell#1 +Coalesced [245] prepareBobs::bob_glyph#6 ← prepareBobs::bob_glyph#1 +Coalesced (already) [246] bob_charset_next_id#82 ← bob_charset_next_id#16 +Coalesced [247] prepareBobs::bob_table#6 ← prepareBobs::bob_table#1 +Coalesced [248] progress_idx#73 ← progress_idx#10 +Coalesced [249] progress_cursor#73 ← progress_cursor#17 +Coalesced [254] progress_cursor#76 ← progress_cursor#8 +Coalesced [258] progress_idx#75 ← progress_idx#8 +Coalesced (already) [259] progress_cursor#75 ← progress_cursor#24 +Coalesced [267] bob_charset_next_id#86 ← bob_charset_next_id#8 +Coalesced [272] charsetFindOrAddGlyph::i1#4 ← charsetFindOrAddGlyph::i1#1 +Coalesced (already) [278] bob_charset_next_id#85 ← bob_charset_next_id#23 +Coalesced [281] charsetFindOrAddGlyph::glyph_id#15 ← charsetFindOrAddGlyph::glyph_id#1 +Coalesced [282] charsetFindOrAddGlyph::glyph_cursor#13 ← charsetFindOrAddGlyph::glyph_cursor#1 +Coalesced [286] charsetFindOrAddGlyph::i#5 ← charsetFindOrAddGlyph::i#1 +Coalesced [300] protoBobShiftRight::j#12 ← protoBobShiftRight::j#2 +Coalesced [303] protoBobShiftRight::i#10 ← protoBobShiftRight::i#1 +Coalesced [304] protoBobShiftRight::j#11 ← protoBobShiftRight::j#10 +Not coalescing [305] protoBobShiftRight::carry#10 ← protoBobShiftRight::carry#1 +Coalesced [307] protoBobShiftRight::j#13 ← protoBobShiftRight::j#1 +Coalesced [320] protoBobShiftDown::i#4 ← protoBobShiftDown::i#1 +Coalesced [340] mulf_init::sqr2_lo#6 ← mulf_init::sqr2_lo#1 +Coalesced [341] mulf_init::x_255#6 ← mulf_init::x_255#1 +Coalesced [342] mulf_init::sqr2_hi#6 ← mulf_init::sqr2_hi#1 +Coalesced [343] mulf_init::dir#5 ← mulf_init::dir#4 +Coalesced (already) [344] mulf_init::dir#6 ← mulf_init::dir#2 +Coalesced [350] mulf_init::sqr#9 ← mulf_init::sqr#2 +Coalesced [351] mulf_init::x_2#8 ← mulf_init::x_2#1 +Coalesced [360] mulf_init::sqr1_lo#6 ← mulf_init::sqr1_lo#1 +Coalesced [361] mulf_init::c#6 ← mulf_init::c#1 +Coalesced [362] mulf_init::sqr#7 ← mulf_init::sqr#1 +Coalesced [363] mulf_init::sqr1_hi#6 ← mulf_init::sqr1_hi#1 +Coalesced [364] mulf_init::x_2#6 ← mulf_init::x_2#2 +Coalesced [365] mulf_init::sqr#8 ← mulf_init::sqr#4 +Coalesced (already) [366] mulf_init::x_2#7 ← mulf_init::x_2#3 +Coalesced down to 41 phi equivalence classes +Culled Empty Block (label) @59 +Culled Empty Block (label) @65 +Culled Empty Block (label) @66 +Culled Empty Block (label) @69 +Culled Empty Block (label) main::@27 +Culled Empty Block (label) main::vicSelectGfxBank1_toDd001_@return +Culled Empty Block (label) main::@21 +Culled Empty Block (label) main::toD0181_@return +Culled Empty Block (label) main::@28 +Culled Empty Block (label) main::@35 +Culled Empty Block (label) main::@17 +Culled Empty Block (label) main::vicSelectGfxBank2_toDd001_@return +Culled Empty Block (label) main::@23 +Culled Empty Block (label) main::toD0182_@return +Culled Empty Block (label) main::@36 +Culled Empty Block (label) mulf8s::@3 +Culled Empty Block (label) mulf8s_prepared::@8 +Culled Empty Block (label) mulf8s_prepared::@7 +Culled Empty Block (label) renderBobCleanup::@2 +Culled Empty Block (label) renderBobCleanup::@3 +Culled Empty Block (label) memset::@2 +Culled Empty Block (label) memset::@1 +Culled Empty Block (label) renderBobInit::@2 +Culled Empty Block (label) renderBobInit::@6 +Culled Empty Block (label) renderBobInit::@5 +Culled Empty Block (label) prepareBobs::@20 +Culled Empty Block (label) prepareBobs::@2 +Culled Empty Block (label) progress_inc::@3 +Culled Empty Block (label) charsetFindOrAddGlyph::@3 +Culled Empty Block (label) charsetFindOrAddGlyph::@2 +Culled Empty Block (label) charsetFindOrAddGlyph::@14 +Culled Empty Block (label) charsetFindOrAddGlyph::@11 +Culled Empty Block (label) protoBobShiftRight::@5 +Culled Empty Block (label) mulf_init::@3 +Culled Empty Block (label) mulf_init::@15 +Culled Empty Block (label) mulf_init::@17 +Renumbering block @68 to @1 +Renumbering block memset::@4 to memset::@1 +Renumbering block memset::@5 to memset::@2 +Renumbering block keyboard_key_pressed::@2 to keyboard_key_pressed::@1 +Renumbering block mulf_init::@4 to mulf_init::@3 +Renumbering block mulf_init::@7 to mulf_init::@4 +Renumbering block mulf_init::@9 to mulf_init::@5 +Renumbering block mulf_init::@10 to mulf_init::@6 +Renumbering block mulf_init::@11 to mulf_init::@7 +Renumbering block mulf_init::@12 to mulf_init::@8 +Renumbering block mulf_init::@18 to mulf_init::@9 +Renumbering block mulf8s_prepared::@6 to mulf8s_prepared::@5 +Renumbering block mulf8s::@2 to mulf8s::@1 +Renumbering block mulf8s::@4 to mulf8s::@2 +Renumbering block main::@4 to main::@2 +Renumbering block main::@5 to main::@3 +Renumbering block main::@6 to main::@4 +Renumbering block main::@7 to main::@5 +Renumbering block main::@15 to main::@6 +Renumbering block main::@22 to main::@7 +Renumbering block main::@24 to main::@8 +Renumbering block main::@25 to main::@9 +Renumbering block main::@26 to main::@10 +Renumbering block main::@29 to main::@11 +Renumbering block main::@30 to main::@12 +Renumbering block main::@31 to main::@13 +Renumbering block main::@32 to main::@14 +Renumbering block main::@33 to main::@15 +Renumbering block main::@34 to main::@16 +Renumbering block renderBobInit::@3 to renderBobInit::@2 +Renumbering block prepareBobs::@4 to prepareBobs::@2 +Renumbering block prepareBobs::@5 to prepareBobs::@3 +Renumbering block prepareBobs::@6 to prepareBobs::@4 +Renumbering block prepareBobs::@7 to prepareBobs::@5 +Renumbering block prepareBobs::@8 to prepareBobs::@6 +Renumbering block prepareBobs::@9 to prepareBobs::@7 +Renumbering block prepareBobs::@19 to prepareBobs::@8 +Renumbering block prepareBobs::@21 to prepareBobs::@9 +Renumbering block prepareBobs::@22 to prepareBobs::@10 +Renumbering block prepareBobs::@23 to prepareBobs::@11 +Renumbering block prepareBobs::@24 to prepareBobs::@12 +Renumbering block prepareBobs::@25 to prepareBobs::@13 +Renumbering block protoBobShiftRight::@4 to protoBobShiftRight::@3 +Renumbering block protoBobShiftRight::@6 to protoBobShiftRight::@4 +Renumbering block protoBobShiftRight::@7 to protoBobShiftRight::@5 +Renumbering block protoBobShiftRight::@8 to protoBobShiftRight::@6 +Renumbering block protoBobShiftRight::@13 to protoBobShiftRight::@7 +Renumbering block charsetFindOrAddGlyph::@4 to charsetFindOrAddGlyph::@2 +Renumbering block charsetFindOrAddGlyph::@5 to charsetFindOrAddGlyph::@3 +Renumbering block charsetFindOrAddGlyph::@7 to charsetFindOrAddGlyph::@4 +Renumbering block charsetFindOrAddGlyph::@8 to charsetFindOrAddGlyph::@5 +Renumbering block charsetFindOrAddGlyph::@16 to charsetFindOrAddGlyph::@6 +Renumbering block charsetFindOrAddGlyph::@20 to charsetFindOrAddGlyph::@7 +Renumbering block charsetFindOrAddGlyph::@21 to charsetFindOrAddGlyph::@8 +Renumbering block charsetFindOrAddGlyph::@22 to charsetFindOrAddGlyph::@9 +Adding NOP phi() at start of @begin +Adding NOP phi() at start of @1 +Adding NOP phi() at start of @end +Adding NOP phi() at start of main +Adding NOP phi() at start of main::@9 +Adding NOP phi() at start of main::@10 +Adding NOP phi() at start of main::vicSelectGfxBank1_toDd001 +Adding NOP phi() at start of main::toD0181 +Adding NOP phi() at start of main::@6 +Adding NOP phi() at start of main::vicSelectGfxBank2_toDd001 +Adding NOP phi() at start of main::toD0182 +Adding NOP phi() at start of keyboard_key_pressed +Adding NOP phi() at start of renderBobCleanup +Adding NOP phi() at start of memset +Adding NOP phi() at start of renderBobInit +Adding NOP phi() at start of prepareBobs +Adding NOP phi() at start of prepareBobs::@8 +Adding NOP phi() at start of prepareBobs::@4 +Adding NOP phi() at start of prepareBobs::@12 +Adding NOP phi() at start of protoBobShiftRight +Adding NOP phi() at start of protoBobShiftRight::@3 +Adding NOP phi() at start of protoBobShiftDown +Adding NOP phi() at start of progress_init +Adding NOP phi() at start of mulf_init +Adding NOP phi() at start of mulf_init::@9 + +FINAL CONTROL FLOW GRAPH +@begin: scope:[] from + [0] phi() + to:@1 +@1: scope:[] from @begin + [1] phi() + [2] call main + to:@end +@end: scope:[] from @1 + [3] phi() + +(void()) main() +main: scope:[main] from @1 + [4] phi() + [5] call mulf_init + to:main::@9 +main::@9: scope:[main] from main + [6] phi() + [7] call prepareBobs + to:main::@10 +main::@10: scope:[main] from main::@9 + [8] phi() + [9] call renderBobInit + to:main::vicSelectGfxBank1 +main::vicSelectGfxBank1: scope:[main] from main::@10 + [10] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 + to:main::vicSelectGfxBank1_toDd001 +main::vicSelectGfxBank1_toDd001: scope:[main] from main::vicSelectGfxBank1 + [11] phi() + to:main::vicSelectGfxBank1_@1 +main::vicSelectGfxBank1_@1: scope:[main] from main::vicSelectGfxBank1_toDd001 + [12] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank1_toDd001_return#0 + to:main::toD0181 +main::toD0181: scope:[main] from main::vicSelectGfxBank1_@1 + [13] phi() + to:main::@7 +main::@7: scope:[main] from main::toD0181 + [14] *((const byte*) D018) ← (const byte) main::toD0181_return#0 + [15] call memset + to:main::@1 +main::@1: scope:[main] from main::@15 main::@7 + [16] (byte) main::angle#8 ← phi( main::@7/(byte) 0 main::@15/(byte) main::angle#1 ) + to:main::@2 +main::@2: scope:[main] from main::@1 main::@2 + [17] if(*((const byte*) RASTER)<(byte) $f8) goto main::@2 + to:main::@3 +main::@3: scope:[main] from main::@2 + [18] *((const byte*) BORDERCOL) ← (byte) $f + [19] call renderBobCleanup + to:main::@11 +main::@11: scope:[main] from main::@3 + [20] (byte) main::a#6 ← (byte) main::angle#8 + to:main::@4 +main::@4: scope:[main] from main::@11 main::@14 + [21] (byte) main::i#2 ← phi( main::@11/(byte) 0 main::@14/(byte) main::i#1 ) + [21] (byte**) renderBobCleanupNext#17 ← phi( main::@11/(const byte**) RENDERBOB_CLEANUP main::@14/(byte**) renderBobCleanupNext#13 ) + [21] (byte) main::a#2 ← phi( main::@11/(byte) main::a#6 main::@14/(byte) main::a#1 ) + [21] (signed byte) main::r#2 ← phi( main::@11/(signed byte) $1e main::@14/(signed byte) main::r#1 ) + [22] *((const byte*) BORDERCOL) ← (byte) 1 + [23] (signed byte) mulf8s::a#0 ← (signed byte) main::r#2 + [24] (signed byte) mulf8s::b#0 ← *((const signed byte*) COS + (byte) main::a#2) + [25] call mulf8s + [26] (signed word) mulf8s::return#2 ← (signed word) mulf8s::return#0 + to:main::@12 +main::@12: scope:[main] from main::@4 + [27] (signed word~) main::$10 ← (signed word) mulf8s::return#2 + [28] (signed word) main::x#0 ← (signed word~) main::$10 + (signed word)(number) $4b*(number) $100 + [29] (signed byte) mulf8s::a#1 ← (signed byte) main::r#2 + [30] (signed byte) mulf8s::b#1 ← *((const signed byte*) SIN + (byte) main::a#2) + [31] call mulf8s + [32] (signed word) mulf8s::return#3 ← (signed word) mulf8s::return#0 + to:main::@13 +main::@13: scope:[main] from main::@12 + [33] (signed word~) main::$12 ← (signed word) mulf8s::return#3 + [34] (signed word~) main::$13 ← (signed word~) main::$12 << (byte) 1 + [35] (signed word) main::y#0 ← (signed word~) main::$13 + (signed word)(number) $5a*(number) $100 + [36] *((const byte*) BORDERCOL) ← (byte) 2 + [37] (byte) main::a#1 ← (byte) main::a#2 + (byte) $62 + [38] (signed byte) main::r#1 ← (signed byte) main::r#2 + (signed byte) 3 + [39] (byte) renderBob::xpos#0 ← > (signed word) main::x#0 + [40] (byte) renderBob::ypos#0 ← > (signed word) main::y#0 + [41] call renderBob + to:main::@14 +main::@14: scope:[main] from main::@13 + [42] (byte) main::i#1 ← ++ (byte) main::i#2 + [43] if((byte) main::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto main::@4 + to:main::@5 +main::@5: scope:[main] from main::@14 + [44] (byte) main::angle#1 ← (byte) main::angle#8 + (byte) 3 + [45] *((const byte*) BORDERCOL) ← (byte) 0 + [46] call keyboard_key_pressed + [47] (byte) keyboard_key_pressed::return#2 ← (byte) keyboard_key_pressed::return#0 + to:main::@15 +main::@15: scope:[main] from main::@5 + [48] (byte~) main::$19 ← (byte) keyboard_key_pressed::return#2 + [49] if((byte) 0!=(byte~) main::$19) goto main::@6 + to:main::@1 +main::@6: scope:[main] from main::@15 main::@16 + [50] phi() + [51] call keyboard_key_pressed + [52] (byte) keyboard_key_pressed::return#3 ← (byte) keyboard_key_pressed::return#0 + to:main::@16 +main::@16: scope:[main] from main::@6 + [53] (byte~) main::$21 ← (byte) keyboard_key_pressed::return#3 + [54] if((byte) 0!=(byte~) main::$21) goto main::@6 + to:main::vicSelectGfxBank2 +main::vicSelectGfxBank2: scope:[main] from main::@16 + [55] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 + to:main::vicSelectGfxBank2_toDd001 +main::vicSelectGfxBank2_toDd001: scope:[main] from main::vicSelectGfxBank2 + [56] phi() + to:main::vicSelectGfxBank2_@1 +main::vicSelectGfxBank2_@1: scope:[main] from main::vicSelectGfxBank2_toDd001 + [57] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank2_toDd001_return#0 + to:main::toD0182 +main::toD0182: scope:[main] from main::vicSelectGfxBank2_@1 + [58] phi() + to:main::@8 +main::@8: scope:[main] from main::toD0182 + [59] *((const byte*) D018) ← (const byte) main::toD0182_return#0 + to:main::@return +main::@return: scope:[main] from main::@8 + [60] return + to:@return + +(byte()) keyboard_key_pressed((byte) keyboard_key_pressed::key) +keyboard_key_pressed: scope:[keyboard_key_pressed] from main::@5 main::@6 + [61] phi() + [62] call keyboard_matrix_read + [63] (byte) keyboard_matrix_read::return#2 ← (byte) keyboard_matrix_read::return#0 + to:keyboard_key_pressed::@1 +keyboard_key_pressed::@1: scope:[keyboard_key_pressed] from keyboard_key_pressed + [64] (byte~) keyboard_key_pressed::$2 ← (byte) keyboard_matrix_read::return#2 + [65] (byte) keyboard_key_pressed::return#0 ← (byte~) keyboard_key_pressed::$2 & *((const byte*) keyboard_matrix_col_bitmask+(const byte) keyboard_key_pressed::colidx#0) + to:keyboard_key_pressed::@return +keyboard_key_pressed::@return: scope:[keyboard_key_pressed] from keyboard_key_pressed::@1 + [66] return + to:@return + +(byte()) keyboard_matrix_read((byte) keyboard_matrix_read::rowid) +keyboard_matrix_read: scope:[keyboard_matrix_read] from keyboard_key_pressed + [67] *((const byte*) CIA1_PORT_A) ← *((const byte*) keyboard_matrix_row_bitmask+(const byte) keyboard_key_pressed::rowidx#0) + [68] (byte) keyboard_matrix_read::return#0 ← ~ *((const byte*) CIA1_PORT_B) + to:keyboard_matrix_read::@return +keyboard_matrix_read::@return: scope:[keyboard_matrix_read] from keyboard_matrix_read + [69] return + to:@return + +(void()) renderBob((byte) renderBob::xpos , (byte) renderBob::ypos) +renderBob: scope:[renderBob] from main::@13 + [70] (byte) renderBob::x_char_offset#0 ← (byte) renderBob::xpos#0 >> (byte) 2 + [71] (byte) renderBob::y_char_offset#0 ← (byte) renderBob::ypos#0 >> (byte) 3 + [72] (byte~) renderBob::$8 ← (byte) renderBob::y_char_offset#0 << (byte) 1 + [73] (word) renderBob::y_offset#0 ← *((const word*) MUL40 + (byte~) renderBob::$8) + [74] (byte*~) renderBob::$2 ← (const byte*) BOB_SCREEN + (word) renderBob::y_offset#0 + [75] (byte*) renderBob::screen#0 ← (byte*~) renderBob::$2 + (byte) renderBob::x_char_offset#0 + [76] (byte~) renderBob::$4 ← (byte) renderBob::ypos#0 & (byte) 7 + [77] (byte~) renderBob::$5 ← (byte~) renderBob::$4 << (byte) 2 + [78] (byte~) renderBob::$6 ← (byte) renderBob::xpos#0 & (byte) 3 + [79] (byte) renderBob::bob_table_idx#0 ← (byte~) renderBob::$5 + (byte~) renderBob::$6 + [80] *((byte**) renderBobCleanupNext#17) ← (byte*) renderBob::screen#0 + [81] (byte**) renderBobCleanupNext#13 ← (byte**) renderBobCleanupNext#17 + (const byte) SIZEOF_POINTER + [82] *((byte*) renderBob::screen#0) ← *((const byte*) BOB_TABLES + (byte) renderBob::bob_table_idx#0) + [83] *((byte*) renderBob::screen#0 + (byte) $28) ← *((const byte*) BOB_TABLES+(byte) 1*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + [84] *((byte*) renderBob::screen#0 + (byte) $50) ← *((const byte*) BOB_TABLES+(byte) 2*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + [85] *((byte*) renderBob::screen#0 + (byte) 1) ← *((const byte*) BOB_TABLES+(byte) 3*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + [86] *((byte*) renderBob::screen#0 + (byte) $29) ← *((const byte*) BOB_TABLES+(byte) 4*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + [87] *((byte*) renderBob::screen#0 + (byte) $51) ← *((const byte*) BOB_TABLES+(byte) 5*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + [88] *((byte*) renderBob::screen#0 + (byte) 2) ← *((const byte*) BOB_TABLES+(byte) 6*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + [89] *((byte*) renderBob::screen#0 + (byte) $2a) ← *((const byte*) BOB_TABLES+(byte) 7*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + [90] *((byte*) renderBob::screen#0 + (byte) $52) ← *((const byte*) BOB_TABLES+(byte) 8*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + to:renderBob::@return +renderBob::@return: scope:[renderBob] from renderBob + [91] return + to:@return + +(signed word()) mulf8s((signed byte) mulf8s::a , (signed byte) mulf8s::b) +mulf8s: scope:[mulf8s] from main::@12 main::@4 + [92] (signed byte) mulf8s::b#2 ← phi( main::@12/(signed byte) mulf8s::b#1 main::@4/(signed byte) mulf8s::b#0 ) + [92] (signed byte) mulf8s::mulf8s_prepare1_a#0 ← phi( main::@12/(signed byte) mulf8s::a#1 main::@4/(signed byte) mulf8s::a#0 ) + to:mulf8s::mulf8s_prepare1 +mulf8s::mulf8s_prepare1: scope:[mulf8s] from mulf8s + [93] (byte) mulf8u_prepare::a#0 ← (byte)(signed byte) mulf8s::mulf8s_prepare1_a#0 + [94] call mulf8u_prepare + to:mulf8s::@1 +mulf8s::@1: scope:[mulf8s] from mulf8s::mulf8s_prepare1 + [95] (signed byte) mulf8s_prepared::b#0 ← (signed byte) mulf8s::b#2 + [96] call mulf8s_prepared + to:mulf8s::@2 +mulf8s::@2: scope:[mulf8s] from mulf8s::@1 + [97] (signed word) mulf8s::return#0 ← (signed word)(word) mulf8s_prepared::m#4 + to:mulf8s::@return +mulf8s::@return: scope:[mulf8s] from mulf8s::@2 + [98] return + to:@return + +(signed word()) mulf8s_prepared((signed byte) mulf8s_prepared::b) +mulf8s_prepared: scope:[mulf8s_prepared] from mulf8s::@1 + [99] (byte) mulf8u_prepared::b#0 ← (byte)(signed byte) mulf8s_prepared::b#0 + [100] call mulf8u_prepared + [101] (word) mulf8u_prepared::return#2 ← (word) mulf8u_prepared::return#0 + to:mulf8s_prepared::@5 +mulf8s_prepared::@5: scope:[mulf8s_prepared] from mulf8s_prepared + [102] (word) mulf8s_prepared::m#0 ← (word) mulf8u_prepared::return#2 + [103] if(*((const signed byte*) mulf8s_prepared::memA)>=(signed byte) 0) goto mulf8s_prepared::@1 + to:mulf8s_prepared::@3 +mulf8s_prepared::@3: scope:[mulf8s_prepared] from mulf8s_prepared::@5 + [104] (byte~) mulf8s_prepared::$8 ← > (word) mulf8s_prepared::m#0 + [105] (byte~) mulf8s_prepared::$15 ← (byte~) mulf8s_prepared::$8 - (byte)(signed byte) mulf8s_prepared::b#0 + [106] (word) mulf8s_prepared::m#1 ← (word) mulf8s_prepared::m#0 hi= (byte~) mulf8s_prepared::$15 + to:mulf8s_prepared::@1 +mulf8s_prepared::@1: scope:[mulf8s_prepared] from mulf8s_prepared::@3 mulf8s_prepared::@5 + [107] (word) mulf8s_prepared::m#5 ← phi( mulf8s_prepared::@3/(word) mulf8s_prepared::m#1 mulf8s_prepared::@5/(word) mulf8s_prepared::m#0 ) + [108] if((signed byte) mulf8s_prepared::b#0>=(signed byte) 0) goto mulf8s_prepared::@2 + to:mulf8s_prepared::@4 +mulf8s_prepared::@4: scope:[mulf8s_prepared] from mulf8s_prepared::@1 + [109] (byte~) mulf8s_prepared::$12 ← > (word) mulf8s_prepared::m#5 + [110] (byte~) mulf8s_prepared::$16 ← (byte~) mulf8s_prepared::$12 - (byte)*((const signed byte*) mulf8s_prepared::memA) + [111] (word) mulf8s_prepared::m#2 ← (word) mulf8s_prepared::m#5 hi= (byte~) mulf8s_prepared::$16 + to:mulf8s_prepared::@2 +mulf8s_prepared::@2: scope:[mulf8s_prepared] from mulf8s_prepared::@1 mulf8s_prepared::@4 + [112] (word) mulf8s_prepared::m#4 ← phi( mulf8s_prepared::@1/(word) mulf8s_prepared::m#5 mulf8s_prepared::@4/(word) mulf8s_prepared::m#2 ) + to:mulf8s_prepared::@return +mulf8s_prepared::@return: scope:[mulf8s_prepared] from mulf8s_prepared::@2 + [113] return + to:@return + +(word()) mulf8u_prepared((byte) mulf8u_prepared::b) +mulf8u_prepared: scope:[mulf8u_prepared] from mulf8s_prepared + [114] *((const byte*) mulf8u_prepared::memB) ← (byte) mulf8u_prepared::b#0 + asm { ldxmemB sec sm1: ldamulf_sqr1_lo,x sm2: sbcmulf_sqr2_lo,x staresL sm3: ldamulf_sqr1_hi,x sm4: sbcmulf_sqr2_hi,x stamemB } + [116] (word) mulf8u_prepared::return#0 ← *((const byte*) mulf8u_prepared::memB) w= *((const byte*) mulf8u_prepared::resL) + to:mulf8u_prepared::@return +mulf8u_prepared::@return: scope:[mulf8u_prepared] from mulf8u_prepared + [117] return + to:@return + +(void()) mulf8u_prepare((byte) mulf8u_prepare::a) +mulf8u_prepare: scope:[mulf8u_prepare] from mulf8s::mulf8s_prepare1 + [118] *((const byte*) mulf8u_prepare::memA) ← (byte) mulf8u_prepare::a#0 + asm { ldamemA stamulf8u_prepared.sm1+1 stamulf8u_prepared.sm3+1 eor#$ff stamulf8u_prepared.sm2+1 stamulf8u_prepared.sm4+1 } + to:mulf8u_prepare::@return +mulf8u_prepare::@return: scope:[mulf8u_prepare] from mulf8u_prepare + [120] return + to:@return + +(void()) renderBobCleanup() +renderBobCleanup: scope:[renderBobCleanup] from main::@3 + [121] phi() + to:renderBobCleanup::@1 +renderBobCleanup::@1: scope:[renderBobCleanup] from renderBobCleanup renderBobCleanup::@1 + [122] (byte) renderBobCleanup::i#2 ← phi( renderBobCleanup/(byte) 0 renderBobCleanup::@1/(byte) renderBobCleanup::i#1 ) + [123] (byte~) renderBobCleanup::$1 ← (byte) renderBobCleanup::i#2 << (byte) 1 + [124] (byte*) renderBobCleanup::screen#0 ← *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobCleanup::$1) + [125] *((byte*) renderBobCleanup::screen#0) ← (byte) 0 + [126] *((byte*) renderBobCleanup::screen#0 + (byte) $28) ← (byte) 0 + [127] *((byte*) renderBobCleanup::screen#0 + (byte) $50) ← (byte) 0 + [128] *((byte*) renderBobCleanup::screen#0 + (byte) 1) ← (byte) 0 + [129] *((byte*) renderBobCleanup::screen#0 + (byte) $29) ← (byte) 0 + [130] *((byte*) renderBobCleanup::screen#0 + (byte) $51) ← (byte) 0 + [131] *((byte*) renderBobCleanup::screen#0 + (byte) 2) ← (byte) 0 + [132] *((byte*) renderBobCleanup::screen#0 + (byte) $2a) ← (byte) 0 + [133] *((byte*) renderBobCleanup::screen#0 + (byte) $52) ← (byte) 0 + [134] (byte) renderBobCleanup::i#1 ← ++ (byte) renderBobCleanup::i#2 + [135] if((byte) renderBobCleanup::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto renderBobCleanup::@1 + to:renderBobCleanup::@return +renderBobCleanup::@return: scope:[renderBobCleanup] from renderBobCleanup::@1 + [136] return + to:@return + +(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num) +memset: scope:[memset] from main::@7 + [137] phi() + to:memset::@1 +memset::@1: scope:[memset] from memset memset::@2 + [138] (byte*) memset::dst#2 ← phi( memset/(byte*)(const void*) memset::str#0 memset::@2/(byte*) memset::dst#1 ) + [139] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 + to:memset::@return +memset::@return: scope:[memset] from memset::@1 + [140] return + to:@return +memset::@2: scope:[memset] from memset::@1 + [141] *((byte*) memset::dst#2) ← (const byte) memset::c#0 + [142] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2 + to:memset::@1 + +(void()) renderBobInit() +renderBobInit: scope:[renderBobInit] from main::@10 + [143] phi() + to:renderBobInit::@1 +renderBobInit::@1: scope:[renderBobInit] from renderBobInit renderBobInit::@1 + [144] (byte) renderBobInit::y#2 ← phi( renderBobInit/(byte) 0 renderBobInit::@1/(byte) renderBobInit::y#1 ) + [145] (word~) renderBobInit::$0 ← (word)(byte) renderBobInit::y#2 + [146] (word~) renderBobInit::$6 ← (word~) renderBobInit::$0 << (byte) 2 + [147] (word~) renderBobInit::$7 ← (word~) renderBobInit::$6 + (word~) renderBobInit::$0 + [148] (word~) renderBobInit::$1 ← (word~) renderBobInit::$7 << (byte) 3 + [149] (byte~) renderBobInit::$4 ← (byte) renderBobInit::y#2 << (byte) 1 + [150] *((const word*) MUL40 + (byte~) renderBobInit::$4) ← (word~) renderBobInit::$1 + [151] (byte) renderBobInit::y#1 ← ++ (byte) renderBobInit::y#2 + [152] if((byte) renderBobInit::y#1!=(byte) $20) goto renderBobInit::@1 + to:renderBobInit::@2 +renderBobInit::@2: scope:[renderBobInit] from renderBobInit::@1 renderBobInit::@2 + [153] (byte) renderBobInit::i#2 ← phi( renderBobInit::@1/(byte) 0 renderBobInit::@2/(byte) renderBobInit::i#1 ) + [154] (byte~) renderBobInit::$5 ← (byte) renderBobInit::i#2 << (byte) 1 + [155] *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobInit::$5) ← (const byte*) BOB_SCREEN + [156] (byte) renderBobInit::i#1 ← ++ (byte) renderBobInit::i#2 + [157] if((byte) renderBobInit::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto renderBobInit::@2 + to:renderBobInit::@return +renderBobInit::@return: scope:[renderBobInit] from renderBobInit::@2 + [158] return + to:@return + +(void()) prepareBobs() +prepareBobs: scope:[prepareBobs] from main::@9 + [159] phi() + [160] call progress_init + to:prepareBobs::@8 +prepareBobs::@8: scope:[prepareBobs] from prepareBobs + [161] phi() + [162] call charsetFindOrAddGlyph + to:prepareBobs::@1 +prepareBobs::@1: scope:[prepareBobs] from prepareBobs::@8 prepareBobs::@9 + [163] (byte) prepareBobs::bob_table_idx#6 ← phi( prepareBobs::@8/(byte) 0 prepareBobs::@9/(byte) prepareBobs::bob_table_idx#12 ) + [163] (byte) bob_charset_next_id#14 ← phi( prepareBobs::@8/(byte) bob_charset_next_id#16 prepareBobs::@9/(byte) bob_charset_next_id#30 ) + [163] (byte) progress_idx#16 ← phi( prepareBobs::@8/(byte) 0 prepareBobs::@9/(byte) progress_idx#31 ) + [163] (byte*) progress_cursor#15 ← phi( prepareBobs::@8/(const byte*) SCREEN_BASIC prepareBobs::@9/(byte*) progress_cursor#31 ) + [163] (byte) prepareBobs::shift_y#2 ← phi( prepareBobs::@8/(byte) 0 prepareBobs::@9/(byte) prepareBobs::shift_y#1 ) + [164] if((byte) prepareBobs::shift_y#2<(const byte) BOB_SHIFTS_Y) goto prepareBobs::@2 + to:prepareBobs::@return +prepareBobs::@return: scope:[prepareBobs] from prepareBobs::@1 + [165] return + to:@return +prepareBobs::@2: scope:[prepareBobs] from prepareBobs::@1 prepareBobs::@13 + [166] (byte) progress_idx#31 ← phi( prepareBobs::@1/(byte) progress_idx#16 prepareBobs::@13/(byte) progress_idx#25 ) + [166] (byte*) progress_cursor#31 ← phi( prepareBobs::@1/(byte*) progress_cursor#15 prepareBobs::@13/(byte*) progress_cursor#24 ) + [166] (byte) bob_charset_next_id#30 ← phi( prepareBobs::@1/(byte) bob_charset_next_id#14 prepareBobs::@13/(byte) bob_charset_next_id#21 ) + [166] (byte) prepareBobs::bob_table_idx#12 ← phi( prepareBobs::@1/(byte) prepareBobs::bob_table_idx#6 prepareBobs::@13/(byte) prepareBobs::bob_table_idx#1 ) + [166] (byte) prepareBobs::shift_x#2 ← phi( prepareBobs::@1/(byte) 0 prepareBobs::@13/(byte) prepareBobs::shift_x#1 ) + [167] if((byte) prepareBobs::shift_x#2<(const byte) BOB_SHIFTS_X) goto prepareBobs::@3 + to:prepareBobs::@4 +prepareBobs::@4: scope:[prepareBobs] from prepareBobs::@2 + [168] phi() + [169] call protoBobShiftDown + to:prepareBobs::@9 +prepareBobs::@9: scope:[prepareBobs] from prepareBobs::@4 + [170] (byte) prepareBobs::shift_y#1 ← ++ (byte) prepareBobs::shift_y#2 + to:prepareBobs::@1 +prepareBobs::@3: scope:[prepareBobs] from prepareBobs::@2 + [171] (byte*) prepareBobs::bob_table#0 ← (const byte*) BOB_TABLES + (byte) prepareBobs::bob_table_idx#12 + to:prepareBobs::@5 +prepareBobs::@5: scope:[prepareBobs] from prepareBobs::@11 prepareBobs::@3 + [172] (byte*) progress_cursor#24 ← phi( prepareBobs::@11/(byte*) progress_cursor#17 prepareBobs::@3/(byte*) progress_cursor#31 ) + [172] (byte) progress_idx#25 ← phi( prepareBobs::@11/(byte) progress_idx#10 prepareBobs::@3/(byte) progress_idx#31 ) + [172] (byte*) prepareBobs::bob_table#2 ← phi( prepareBobs::@11/(byte*) prepareBobs::bob_table#1 prepareBobs::@3/(byte*) prepareBobs::bob_table#0 ) + [172] (byte) bob_charset_next_id#21 ← phi( prepareBobs::@11/(byte) bob_charset_next_id#16 prepareBobs::@3/(byte) bob_charset_next_id#30 ) + [172] (byte*) prepareBobs::bob_glyph#2 ← phi( prepareBobs::@11/(byte*) prepareBobs::bob_glyph#1 prepareBobs::@3/(const byte*) PROTO_BOB ) + [172] (byte) prepareBobs::cell#2 ← phi( prepareBobs::@11/(byte) prepareBobs::cell#1 prepareBobs::@3/(byte) 0 ) + [173] if((byte) prepareBobs::cell#2<(byte) 9) goto prepareBobs::@6 + to:prepareBobs::@7 +prepareBobs::@7: scope:[prepareBobs] from prepareBobs::@5 + [174] (byte) prepareBobs::bob_table_idx#1 ← ++ (byte) prepareBobs::bob_table_idx#12 + [175] call protoBobShiftRight + to:prepareBobs::@12 +prepareBobs::@12: scope:[prepareBobs] from prepareBobs::@7 + [176] phi() + [177] call protoBobShiftRight + to:prepareBobs::@13 +prepareBobs::@13: scope:[prepareBobs] from prepareBobs::@12 + [178] (byte) prepareBobs::shift_x#1 ← ++ (byte) prepareBobs::shift_x#2 + to:prepareBobs::@2 +prepareBobs::@6: scope:[prepareBobs] from prepareBobs::@5 + [179] (byte*) charsetFindOrAddGlyph::glyph#1 ← (byte*) prepareBobs::bob_glyph#2 + [180] call charsetFindOrAddGlyph + [181] (byte) charsetFindOrAddGlyph::return#1 ← (byte) charsetFindOrAddGlyph::glyph_id#11 + to:prepareBobs::@10 +prepareBobs::@10: scope:[prepareBobs] from prepareBobs::@6 + [182] (byte~) prepareBobs::$6 ← (byte) charsetFindOrAddGlyph::return#1 + [183] *((byte*) prepareBobs::bob_table#2) ← (byte~) prepareBobs::$6 + [184] (byte*) prepareBobs::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 + (byte) 8 + [185] (byte*) prepareBobs::bob_table#1 ← (byte*) prepareBobs::bob_table#2 + (const byte) BOB_SHIFTS_X*(const byte) BOB_SHIFTS_Y + [186] call progress_inc + to:prepareBobs::@11 +prepareBobs::@11: scope:[prepareBobs] from prepareBobs::@10 + [187] (byte) prepareBobs::cell#1 ← ++ (byte) prepareBobs::cell#2 + to:prepareBobs::@5 + +(void()) progress_inc() +progress_inc: scope:[progress_inc] from prepareBobs::@10 + [188] (byte) progress_idx#8 ← ++ (byte) progress_idx#25 + [189] if((byte) progress_idx#8!=(byte) 8) goto progress_inc::@1 + to:progress_inc::@2 +progress_inc::@2: scope:[progress_inc] from progress_inc + [190] *((byte*) progress_cursor#24) ← *((const byte*) progress_inc::progress_chars+(byte) 8) + [191] (byte*) progress_cursor#8 ← ++ (byte*) progress_cursor#24 + to:progress_inc::@1 +progress_inc::@1: scope:[progress_inc] from progress_inc progress_inc::@2 + [192] (byte*) progress_cursor#17 ← phi( progress_inc/(byte*) progress_cursor#24 progress_inc::@2/(byte*) progress_cursor#8 ) + [192] (byte) progress_idx#10 ← phi( progress_inc/(byte) progress_idx#8 progress_inc::@2/(byte) 0 ) + [193] *((byte*) progress_cursor#17) ← *((const byte*) progress_inc::progress_chars + (byte) progress_idx#10) + to:progress_inc::@return +progress_inc::@return: scope:[progress_inc] from progress_inc::@1 + [194] return + to:@return + +(byte()) charsetFindOrAddGlyph((byte*) charsetFindOrAddGlyph::glyph , (byte*) charsetFindOrAddGlyph::charset) +charsetFindOrAddGlyph: scope:[charsetFindOrAddGlyph] from prepareBobs::@6 prepareBobs::@8 + [195] (byte*) charsetFindOrAddGlyph::glyph#10 ← phi( prepareBobs::@8/(const byte*) PROTO_BOB+(byte) $30 prepareBobs::@6/(byte*) charsetFindOrAddGlyph::glyph#1 ) + [195] (byte) bob_charset_next_id#23 ← phi( prepareBobs::@8/(byte) 0 prepareBobs::@6/(byte) bob_charset_next_id#21 ) + to:charsetFindOrAddGlyph::@1 +charsetFindOrAddGlyph::@1: scope:[charsetFindOrAddGlyph] from charsetFindOrAddGlyph charsetFindOrAddGlyph::@6 + [196] (byte*) charsetFindOrAddGlyph::glyph_cursor#11 ← phi( charsetFindOrAddGlyph/(const byte*) BOB_CHARSET charsetFindOrAddGlyph::@6/(byte*) charsetFindOrAddGlyph::glyph_cursor#1 ) + [196] (byte) charsetFindOrAddGlyph::glyph_id#11 ← phi( charsetFindOrAddGlyph/(byte) 0 charsetFindOrAddGlyph::@6/(byte) charsetFindOrAddGlyph::glyph_id#1 ) + [197] if((byte) charsetFindOrAddGlyph::glyph_id#11!=(byte) bob_charset_next_id#23) goto charsetFindOrAddGlyph::@2 + to:charsetFindOrAddGlyph::@7 +charsetFindOrAddGlyph::@7: scope:[charsetFindOrAddGlyph] from charsetFindOrAddGlyph::@1 charsetFindOrAddGlyph::@8 + [198] (byte) charsetFindOrAddGlyph::i1#2 ← phi( charsetFindOrAddGlyph::@8/(byte) charsetFindOrAddGlyph::i1#1 charsetFindOrAddGlyph::@1/(byte) 0 ) + [199] if((byte) charsetFindOrAddGlyph::i1#2<(byte) 8) goto charsetFindOrAddGlyph::@8 + to:charsetFindOrAddGlyph::@9 +charsetFindOrAddGlyph::@9: scope:[charsetFindOrAddGlyph] from charsetFindOrAddGlyph::@7 + [200] (byte) bob_charset_next_id#8 ← ++ (byte) bob_charset_next_id#23 + to:charsetFindOrAddGlyph::@return +charsetFindOrAddGlyph::@return: scope:[charsetFindOrAddGlyph] from charsetFindOrAddGlyph::@5 charsetFindOrAddGlyph::@9 + [201] (byte) bob_charset_next_id#16 ← phi( charsetFindOrAddGlyph::@5/(byte) bob_charset_next_id#23 charsetFindOrAddGlyph::@9/(byte) bob_charset_next_id#8 ) + [202] return + to:@return +charsetFindOrAddGlyph::@8: scope:[charsetFindOrAddGlyph] from charsetFindOrAddGlyph::@7 + [203] *((byte*) charsetFindOrAddGlyph::glyph_cursor#11 + (byte) charsetFindOrAddGlyph::i1#2) ← *((byte*) charsetFindOrAddGlyph::glyph#10 + (byte) charsetFindOrAddGlyph::i1#2) + [204] (byte) charsetFindOrAddGlyph::i1#1 ← ++ (byte) charsetFindOrAddGlyph::i1#2 + to:charsetFindOrAddGlyph::@7 +charsetFindOrAddGlyph::@2: scope:[charsetFindOrAddGlyph] from charsetFindOrAddGlyph::@1 charsetFindOrAddGlyph::@4 + [205] (byte) charsetFindOrAddGlyph::i#2 ← phi( charsetFindOrAddGlyph::@1/(byte) 0 charsetFindOrAddGlyph::@4/(byte) charsetFindOrAddGlyph::i#1 ) + [206] if((byte) charsetFindOrAddGlyph::i#2<(byte) 8) goto charsetFindOrAddGlyph::@3 + to:charsetFindOrAddGlyph::@5 +charsetFindOrAddGlyph::@3: scope:[charsetFindOrAddGlyph] from charsetFindOrAddGlyph::@2 + [207] if(*((byte*) charsetFindOrAddGlyph::glyph_cursor#11 + (byte) charsetFindOrAddGlyph::i#2)==*((byte*) charsetFindOrAddGlyph::glyph#10 + (byte) charsetFindOrAddGlyph::i#2)) goto charsetFindOrAddGlyph::@4 + to:charsetFindOrAddGlyph::@5 +charsetFindOrAddGlyph::@5: scope:[charsetFindOrAddGlyph] from charsetFindOrAddGlyph::@2 charsetFindOrAddGlyph::@3 + [208] (byte) charsetFindOrAddGlyph::found#2 ← phi( charsetFindOrAddGlyph::@3/(byte) 0 charsetFindOrAddGlyph::@2/(byte) 1 ) + [209] if((byte) 0==(byte) charsetFindOrAddGlyph::found#2) goto charsetFindOrAddGlyph::@6 + to:charsetFindOrAddGlyph::@return +charsetFindOrAddGlyph::@6: scope:[charsetFindOrAddGlyph] from charsetFindOrAddGlyph::@5 + [210] (byte) charsetFindOrAddGlyph::glyph_id#1 ← ++ (byte) charsetFindOrAddGlyph::glyph_id#11 + [211] (byte*) charsetFindOrAddGlyph::glyph_cursor#1 ← (byte*) charsetFindOrAddGlyph::glyph_cursor#11 + (byte) 8 + to:charsetFindOrAddGlyph::@1 +charsetFindOrAddGlyph::@4: scope:[charsetFindOrAddGlyph] from charsetFindOrAddGlyph::@3 + [212] (byte) charsetFindOrAddGlyph::i#1 ← ++ (byte) charsetFindOrAddGlyph::i#2 + to:charsetFindOrAddGlyph::@2 + +(void()) protoBobShiftRight() +protoBobShiftRight: scope:[protoBobShiftRight] from prepareBobs::@12 prepareBobs::@7 + [213] phi() + to:protoBobShiftRight::@1 +protoBobShiftRight::@1: scope:[protoBobShiftRight] from protoBobShiftRight protoBobShiftRight::@6 + [214] (byte) protoBobShiftRight::carry#2 ← phi( protoBobShiftRight/(byte) 0 protoBobShiftRight::@6/(byte) protoBobShiftRight::carry#10 ) + [214] (byte) protoBobShiftRight::j#3 ← phi( protoBobShiftRight/(byte) 0 protoBobShiftRight::@6/(byte) protoBobShiftRight::j#10 ) + [214] (byte) protoBobShiftRight::i#2 ← phi( protoBobShiftRight/(byte) 0 protoBobShiftRight::@6/(byte) protoBobShiftRight::i#1 ) + [215] if((byte) protoBobShiftRight::i#2<(byte)(number) 3*(number) 3*(number) 8) goto protoBobShiftRight::@2 + to:protoBobShiftRight::@return +protoBobShiftRight::@return: scope:[protoBobShiftRight] from protoBobShiftRight::@1 + [216] return + to:@return +protoBobShiftRight::@2: scope:[protoBobShiftRight] from protoBobShiftRight::@1 + [217] (byte~) protoBobShiftRight::$1 ← *((const byte*) PROTO_BOB + (byte) protoBobShiftRight::j#3) & (byte) 1 + [218] if((byte) 0!=(byte~) protoBobShiftRight::$1) goto protoBobShiftRight::@3 + to:protoBobShiftRight::@4 +protoBobShiftRight::@3: scope:[protoBobShiftRight] from protoBobShiftRight::@2 + [219] phi() + to:protoBobShiftRight::@4 +protoBobShiftRight::@4: scope:[protoBobShiftRight] from protoBobShiftRight::@2 protoBobShiftRight::@3 + [220] (byte) protoBobShiftRight::carry#1 ← phi( protoBobShiftRight::@3/(byte) $80 protoBobShiftRight::@2/(byte) 0 ) + [221] (byte~) protoBobShiftRight::$5 ← *((const byte*) PROTO_BOB + (byte) protoBobShiftRight::j#3) >> (byte) 1 + [222] (byte~) protoBobShiftRight::$6 ← (byte) protoBobShiftRight::carry#2 | (byte~) protoBobShiftRight::$5 + [223] *((const byte*) PROTO_BOB + (byte) protoBobShiftRight::j#3) ← (byte~) protoBobShiftRight::$6 + [224] if((byte) protoBobShiftRight::j#3>=(byte) $30) goto protoBobShiftRight::@5 + to:protoBobShiftRight::@7 +protoBobShiftRight::@7: scope:[protoBobShiftRight] from protoBobShiftRight::@4 + [225] (byte) protoBobShiftRight::j#2 ← (byte) protoBobShiftRight::j#3 + (byte) $18 + to:protoBobShiftRight::@6 +protoBobShiftRight::@6: scope:[protoBobShiftRight] from protoBobShiftRight::@5 protoBobShiftRight::@7 + [226] (byte) protoBobShiftRight::j#10 ← phi( protoBobShiftRight::@7/(byte) protoBobShiftRight::j#2 protoBobShiftRight::@5/(byte) protoBobShiftRight::j#1 ) + [227] (byte) protoBobShiftRight::i#1 ← ++ (byte) protoBobShiftRight::i#2 + [228] (byte) protoBobShiftRight::carry#10 ← (byte) protoBobShiftRight::carry#1 + to:protoBobShiftRight::@1 +protoBobShiftRight::@5: scope:[protoBobShiftRight] from protoBobShiftRight::@4 + [229] (byte) protoBobShiftRight::j#1 ← (byte) protoBobShiftRight::j#3 - (byte) $2f + to:protoBobShiftRight::@6 + +(void()) protoBobShiftDown() +protoBobShiftDown: scope:[protoBobShiftDown] from prepareBobs::@4 + [230] phi() + to:protoBobShiftDown::@1 +protoBobShiftDown::@1: scope:[protoBobShiftDown] from protoBobShiftDown protoBobShiftDown::@2 + [231] (byte) protoBobShiftDown::i#2 ← phi( protoBobShiftDown/(byte) $17 protoBobShiftDown::@2/(byte) protoBobShiftDown::i#1 ) + [232] if((byte) protoBobShiftDown::i#2>(byte) 0) goto protoBobShiftDown::@2 + to:protoBobShiftDown::@3 +protoBobShiftDown::@3: scope:[protoBobShiftDown] from protoBobShiftDown::@1 + [233] *((const byte*) PROTO_BOB) ← (byte) 0 + [234] *((const byte*) PROTO_BOB+(byte) $18) ← (byte) 0 + [235] *((const byte*) PROTO_BOB+(byte) $30) ← (byte) 0 + to:protoBobShiftDown::@return +protoBobShiftDown::@return: scope:[protoBobShiftDown] from protoBobShiftDown::@3 + [236] return + to:@return +protoBobShiftDown::@2: scope:[protoBobShiftDown] from protoBobShiftDown::@1 + [237] *((const byte*) PROTO_BOB + (byte) protoBobShiftDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $17 + (byte) protoBobShiftDown::i#2) + [238] *((const byte*) PROTO_BOB+(byte) $18 + (byte) protoBobShiftDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $2f + (byte) protoBobShiftDown::i#2) + [239] *((const byte*) PROTO_BOB+(byte) $30 + (byte) protoBobShiftDown::i#2) ← (byte) 0 + [240] (byte) protoBobShiftDown::i#1 ← -- (byte) protoBobShiftDown::i#2 + to:protoBobShiftDown::@1 + +(void()) progress_init((byte*) progress_init::line) +progress_init: scope:[progress_init] from prepareBobs + [241] phi() + to:progress_init::@return +progress_init::@return: scope:[progress_init] from progress_init + [242] return + to:@return + +(void()) mulf_init() +mulf_init: scope:[mulf_init] from main + [243] phi() + to:mulf_init::@1 +mulf_init::@1: scope:[mulf_init] from mulf_init mulf_init::@3 + [244] (byte) mulf_init::x_2#3 ← phi( mulf_init/(byte) 0 mulf_init::@3/(byte) mulf_init::x_2#2 ) + [244] (byte*) mulf_init::sqr1_hi#2 ← phi( mulf_init/(const byte*) mulf_sqr1_hi+(byte) 1 mulf_init::@3/(byte*) mulf_init::sqr1_hi#1 ) + [244] (word) mulf_init::sqr#4 ← phi( mulf_init/(byte) 0 mulf_init::@3/(word) mulf_init::sqr#1 ) + [244] (byte) mulf_init::c#2 ← phi( mulf_init/(byte) 0 mulf_init::@3/(byte) mulf_init::c#1 ) + [244] (byte*) mulf_init::sqr1_lo#2 ← phi( mulf_init/(const byte*) mulf_sqr1_lo+(byte) 1 mulf_init::@3/(byte*) mulf_init::sqr1_lo#1 ) + [245] if((byte*) mulf_init::sqr1_lo#2!=(const byte*) mulf_sqr1_lo+(word) $200) goto mulf_init::@2 + to:mulf_init::@5 +mulf_init::@5: scope:[mulf_init] from mulf_init::@1 mulf_init::@8 + [246] (byte) mulf_init::dir#2 ← phi( mulf_init::@8/(byte) mulf_init::dir#4 mulf_init::@1/(byte) $ff ) + [246] (byte*) mulf_init::sqr2_hi#2 ← phi( mulf_init::@8/(byte*) mulf_init::sqr2_hi#1 mulf_init::@1/(const byte*) mulf_sqr2_hi ) + [246] (byte) mulf_init::x_255#2 ← phi( mulf_init::@8/(byte) mulf_init::x_255#1 mulf_init::@1/(byte) -1 ) + [246] (byte*) mulf_init::sqr2_lo#2 ← phi( mulf_init::@8/(byte*) mulf_init::sqr2_lo#1 mulf_init::@1/(const byte*) mulf_sqr2_lo ) + [247] if((byte*) mulf_init::sqr2_lo#2!=(const byte*) mulf_sqr2_lo+(word) $1ff) goto mulf_init::@6 + to:mulf_init::@7 +mulf_init::@7: scope:[mulf_init] from mulf_init::@5 + [248] *((const byte*) mulf_sqr2_lo+(word) $1ff) ← *((const byte*) mulf_sqr1_lo+(word) $100) + [249] *((const byte*) mulf_sqr2_hi+(word) $1ff) ← *((const byte*) mulf_sqr1_hi+(word) $100) + to:mulf_init::@return +mulf_init::@return: scope:[mulf_init] from mulf_init::@7 + [250] return + to:@return +mulf_init::@6: scope:[mulf_init] from mulf_init::@5 + [251] *((byte*) mulf_init::sqr2_lo#2) ← *((const byte*) mulf_sqr1_lo + (byte) mulf_init::x_255#2) + [252] *((byte*) mulf_init::sqr2_hi#2) ← *((const byte*) mulf_sqr1_hi + (byte) mulf_init::x_255#2) + [253] (byte*) mulf_init::sqr2_hi#1 ← ++ (byte*) mulf_init::sqr2_hi#2 + [254] (byte) mulf_init::x_255#1 ← (byte) mulf_init::x_255#2 + (byte) mulf_init::dir#2 + [255] if((byte) mulf_init::x_255#1!=(byte) 0) goto mulf_init::@9 + to:mulf_init::@8 +mulf_init::@9: scope:[mulf_init] from mulf_init::@6 + [256] phi() + to:mulf_init::@8 +mulf_init::@8: scope:[mulf_init] from mulf_init::@6 mulf_init::@9 + [257] (byte) mulf_init::dir#4 ← phi( mulf_init::@9/(byte) mulf_init::dir#2 mulf_init::@6/(byte) 1 ) + [258] (byte*) mulf_init::sqr2_lo#1 ← ++ (byte*) mulf_init::sqr2_lo#2 + to:mulf_init::@5 +mulf_init::@2: scope:[mulf_init] from mulf_init::@1 + [259] (byte) mulf_init::c#1 ← ++ (byte) mulf_init::c#2 + [260] (byte~) mulf_init::$1 ← (byte) mulf_init::c#1 & (byte) 1 + [261] if((byte~) mulf_init::$1!=(byte) 0) goto mulf_init::@3 + to:mulf_init::@4 +mulf_init::@4: scope:[mulf_init] from mulf_init::@2 + [262] (byte) mulf_init::x_2#1 ← ++ (byte) mulf_init::x_2#3 + [263] (word) mulf_init::sqr#2 ← ++ (word) mulf_init::sqr#4 + to:mulf_init::@3 +mulf_init::@3: scope:[mulf_init] from mulf_init::@2 mulf_init::@4 + [264] (byte) mulf_init::x_2#2 ← phi( mulf_init::@2/(byte) mulf_init::x_2#3 mulf_init::@4/(byte) mulf_init::x_2#1 ) + [264] (word) mulf_init::sqr#3 ← phi( mulf_init::@2/(word) mulf_init::sqr#4 mulf_init::@4/(word) mulf_init::sqr#2 ) + [265] (byte~) mulf_init::$4 ← < (word) mulf_init::sqr#3 + [266] *((byte*) mulf_init::sqr1_lo#2) ← (byte~) mulf_init::$4 + [267] (byte~) mulf_init::$5 ← > (word) mulf_init::sqr#3 + [268] *((byte*) mulf_init::sqr1_hi#2) ← (byte~) mulf_init::$5 + [269] (byte*) mulf_init::sqr1_hi#1 ← ++ (byte*) mulf_init::sqr1_hi#2 + [270] (word) mulf_init::sqr#1 ← (word) mulf_init::sqr#3 + (byte) mulf_init::x_2#2 + [271] (byte*) mulf_init::sqr1_lo#1 ← ++ (byte*) mulf_init::sqr1_lo#2 + to:mulf_init::@1 + + +VARIABLE REGISTER WEIGHTS +(byte) bob_charset_next_id +(byte) bob_charset_next_id#14 12.0 +(byte) bob_charset_next_id#16 1000.5454545454544 +(byte) bob_charset_next_id#21 275.5 +(byte) bob_charset_next_id#23 1400.3333333333335 +(byte) bob_charset_next_id#30 37.33333333333333 +(byte) bob_charset_next_id#8 4.0 +(byte()) charsetFindOrAddGlyph((byte*) charsetFindOrAddGlyph::glyph , (byte*) charsetFindOrAddGlyph::charset) +(byte*) charsetFindOrAddGlyph::charset +(byte) charsetFindOrAddGlyph::found +(byte) charsetFindOrAddGlyph::found#2 10001.0 +(byte*) charsetFindOrAddGlyph::glyph +(byte*) charsetFindOrAddGlyph::glyph#1 2002.0 +(byte*) charsetFindOrAddGlyph::glyph#10 7400.200000000001 +(byte*) charsetFindOrAddGlyph::glyph_cursor +(byte*) charsetFindOrAddGlyph::glyph_cursor#1 20002.0 +(byte*) charsetFindOrAddGlyph::glyph_cursor#11 10000.307692307691 +(byte) charsetFindOrAddGlyph::glyph_id +(byte) charsetFindOrAddGlyph::glyph_id#1 10001.0 +(byte) charsetFindOrAddGlyph::glyph_id#11 1937.75 +(byte) charsetFindOrAddGlyph::i +(byte) charsetFindOrAddGlyph::i#1 200002.0 +(byte) charsetFindOrAddGlyph::i#2 166668.3333333333 +(byte) charsetFindOrAddGlyph::i1 +(byte) charsetFindOrAddGlyph::i1#1 20002.0 +(byte) charsetFindOrAddGlyph::i1#2 16668.333333333332 +(byte) charsetFindOrAddGlyph::return +(byte) charsetFindOrAddGlyph::return#1 2002.0 +(byte()) keyboard_key_pressed((byte) keyboard_key_pressed::key) +(byte~) keyboard_key_pressed::$2 4.0 +(byte) keyboard_key_pressed::colidx +(byte) keyboard_key_pressed::key +(byte) keyboard_key_pressed::return +(byte) keyboard_key_pressed::return#0 6.0 +(byte) keyboard_key_pressed::return#2 22.0 +(byte) keyboard_key_pressed::return#3 22.0 +(byte) keyboard_key_pressed::rowidx +(byte()) keyboard_matrix_read((byte) keyboard_matrix_read::rowid) +(byte) keyboard_matrix_read::return +(byte) keyboard_matrix_read::return#0 1.3333333333333333 +(byte) keyboard_matrix_read::return#2 4.0 +(byte) keyboard_matrix_read::row_pressed_bits +(byte) keyboard_matrix_read::rowid +(void()) main() +(signed word~) main::$10 202.0 +(signed word~) main::$12 202.0 +(signed word~) main::$13 202.0 +(byte~) main::$19 22.0 +(byte~) main::$21 22.0 +(byte) main::a +(byte) main::a#1 28.857142857142858 +(byte) main::a#2 25.9375 +(byte) main::a#6 22.0 +(byte) main::angle +(byte) main::angle#1 3.6666666666666665 +(byte) main::angle#8 1.1785714285714286 +(byte) main::i +(byte) main::i#1 151.5 +(byte) main::i#2 9.619047619047619 +(signed byte) main::r +(signed byte) main::r#1 33.666666666666664 +(signed byte) main::r#2 23.764705882352942 +(byte*) main::toD0181_gfx +(byte) main::toD0181_return +(byte*) main::toD0181_screen +(byte*) main::toD0182_gfx +(byte) main::toD0182_return +(byte*) main::toD0182_screen +(byte*) main::vicSelectGfxBank1_gfx +(byte*) main::vicSelectGfxBank1_toDd001_gfx +(byte) main::vicSelectGfxBank1_toDd001_return +(byte*) main::vicSelectGfxBank2_gfx +(byte*) main::vicSelectGfxBank2_toDd001_gfx +(byte) main::vicSelectGfxBank2_toDd001_return +(signed word) main::x +(signed word) main::x#0 18.363636363636363 +(signed word) main::y +(signed word) main::y#0 40.4 +(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num) +(byte) memset::c +(byte*) memset::dst +(byte*) memset::dst#1 22.0 +(byte*) memset::dst#2 14.666666666666666 +(byte*) memset::end +(word) memset::num +(void*) memset::return +(void*) memset::str +(signed word()) mulf8s((signed byte) mulf8s::a , (signed byte) mulf8s::b) +(signed byte) mulf8s::a +(signed byte) mulf8s::a#0 101.0 +(signed byte) mulf8s::a#1 101.0 +(signed byte) mulf8s::b +(signed byte) mulf8s::b#0 202.0 +(signed byte) mulf8s::b#1 202.0 +(signed byte) mulf8s::b#2 68.0 +(signed byte) mulf8s::mulf8s_prepare1_a +(signed byte) mulf8s::mulf8s_prepare1_a#0 202.0 +(signed word) mulf8s::return +(signed word) mulf8s::return#0 51.0 +(signed word) mulf8s::return#2 202.0 +(signed word) mulf8s::return#3 202.0 +(signed word()) mulf8s_prepared((signed byte) mulf8s_prepared::b) +(byte~) mulf8s_prepared::$12 4.0 +(byte~) mulf8s_prepared::$15 4.0 +(byte~) mulf8s_prepared::$16 4.0 +(byte~) mulf8s_prepared::$8 4.0 +(signed byte) mulf8s_prepared::b +(signed byte) mulf8s_prepared::b#0 0.4 +(word) mulf8s_prepared::m +(word) mulf8s_prepared::m#0 2.0 +(word) mulf8s_prepared::m#1 4.0 +(word) mulf8s_prepared::m#2 4.0 +(word) mulf8s_prepared::m#4 1.3333333333333333 +(word) mulf8s_prepared::m#5 2.5 +(signed word) mulf8s_prepared::return +(void()) mulf8u_prepare((byte) mulf8u_prepare::a) +(byte) mulf8u_prepare::a +(byte) mulf8u_prepare::a#0 4.0 +(word()) mulf8u_prepared((byte) mulf8u_prepared::b) +(byte) mulf8u_prepared::b +(byte) mulf8u_prepared::b#0 4.0 +(word) mulf8u_prepared::return +(word) mulf8u_prepared::return#0 1.3333333333333333 +(word) mulf8u_prepared::return#2 4.0 +(void()) mulf_init() +(byte~) mulf_init::$1 22.0 +(byte~) mulf_init::$4 22.0 +(byte~) mulf_init::$5 22.0 +(byte) mulf_init::c +(byte) mulf_init::c#1 2.5384615384615383 +(byte) mulf_init::c#2 11.0 +(byte) mulf_init::dir +(byte) mulf_init::dir#2 4.125 +(byte) mulf_init::dir#4 11.0 +(word) mulf_init::sqr +(word) mulf_init::sqr#1 11.0 +(word) mulf_init::sqr#2 22.0 +(word) mulf_init::sqr#3 9.166666666666666 +(word) mulf_init::sqr#4 5.5 +(byte*) mulf_init::sqr1_hi +(byte*) mulf_init::sqr1_hi#1 7.333333333333333 +(byte*) mulf_init::sqr1_hi#2 2.75 +(byte*) mulf_init::sqr1_lo +(byte*) mulf_init::sqr1_lo#1 22.0 +(byte*) mulf_init::sqr1_lo#2 3.142857142857143 +(byte*) mulf_init::sqr2_hi +(byte*) mulf_init::sqr2_hi#1 3.6666666666666665 +(byte*) mulf_init::sqr2_hi#2 8.25 +(byte*) mulf_init::sqr2_lo +(byte*) mulf_init::sqr2_lo#1 22.0 +(byte*) mulf_init::sqr2_lo#2 4.888888888888889 +(byte) mulf_init::x_2 +(byte) mulf_init::x_2#1 11.0 +(byte) mulf_init::x_2#2 5.5 +(byte) mulf_init::x_2#3 6.6000000000000005 +(byte) mulf_init::x_255 +(byte) mulf_init::x_255#1 6.6000000000000005 +(byte) mulf_init::x_255#2 8.8 +(void()) prepareBobs() +(byte~) prepareBobs::$6 2002.0 +(byte*) prepareBobs::bob_glyph +(byte*) prepareBobs::bob_glyph#1 500.5 +(byte*) prepareBobs::bob_glyph#2 429.0 +(byte*) prepareBobs::bob_table +(byte*) prepareBobs::bob_table#0 202.0 +(byte*) prepareBobs::bob_table#1 667.3333333333334 +(byte*) prepareBobs::bob_table#2 388.0 +(byte) prepareBobs::bob_table_idx +(byte) prepareBobs::bob_table_idx#1 40.4 +(byte) prepareBobs::bob_table_idx#12 19.11764705882353 +(byte) prepareBobs::bob_table_idx#6 11.0 +(byte) prepareBobs::cell +(byte) prepareBobs::cell#1 2002.0 +(byte) prepareBobs::cell#2 300.29999999999995 +(byte) prepareBobs::shift_x +(byte) prepareBobs::shift_x#1 202.0 +(byte) prepareBobs::shift_x#2 16.833333333333332 +(byte) prepareBobs::shift_y +(byte) prepareBobs::shift_y#1 22.0 +(byte) prepareBobs::shift_y#2 1.4347826086956523 +(byte*) progress_cursor +(byte*) progress_cursor#15 11.0 +(byte*) progress_cursor#17 201.4 +(byte*) progress_cursor#24 71.11764705882355 +(byte*) progress_cursor#31 37.33333333333333 +(byte*) progress_cursor#8 4.0 +(byte) progress_idx +(byte) progress_idx#10 201.0 +(byte) progress_idx#16 11.0 +(byte) progress_idx#25 86.07142857142856 +(byte) progress_idx#31 37.33333333333333 +(byte) progress_idx#8 3.0 +(void()) progress_inc() +(void()) progress_init((byte*) progress_init::line) +(byte*) progress_init::line +(void()) protoBobShiftDown() +(byte) protoBobShiftDown::i +(byte) protoBobShiftDown::i#1 202.0 +(byte) protoBobShiftDown::i#2 161.6 +(void()) protoBobShiftRight() +(byte~) protoBobShiftRight::$1 2002.0 +(byte~) protoBobShiftRight::$5 2002.0 +(byte~) protoBobShiftRight::$6 2002.0 +(byte) protoBobShiftRight::carry +(byte) protoBobShiftRight::carry#1 111.22222222222223 +(byte) protoBobShiftRight::carry#10 2002.0 +(byte) protoBobShiftRight::carry#2 286.0 +(byte) protoBobShiftRight::i +(byte) protoBobShiftRight::i#1 1001.0 +(byte) protoBobShiftRight::i#2 231.0 +(byte) protoBobShiftRight::j +(byte) protoBobShiftRight::j#1 2002.0 +(byte) protoBobShiftRight::j#10 1001.0 +(byte) protoBobShiftRight::j#2 2002.0 +(byte) protoBobShiftRight::j#3 700.7 +(byte) protoBobShiftRight::new_carry +(void()) renderBob((byte) renderBob::xpos , (byte) renderBob::ypos) +(byte*~) renderBob::$2 4.0 +(byte~) renderBob::$4 4.0 +(byte~) renderBob::$5 2.0 +(byte~) renderBob::$6 4.0 +(byte~) renderBob::$8 4.0 +(byte) renderBob::bob_table_idx +(byte) renderBob::bob_table_idx#0 1.8181818181818186 +(byte*) renderBob::screen +(byte*) renderBob::screen#0 1.4666666666666666 +(byte) renderBob::x_char_offset +(byte) renderBob::x_char_offset#0 0.8 +(byte) renderBob::xpos +(byte) renderBob::xpos#0 10.499999999999998 +(byte) renderBob::y_char_offset +(byte) renderBob::y_char_offset#0 4.0 +(word) renderBob::y_offset +(word) renderBob::y_offset#0 4.0 +(byte) renderBob::ypos +(byte) renderBob::ypos#0 15.000000000000002 +(void()) renderBobCleanup() +(byte~) renderBobCleanup::$1 202.0 +(byte) renderBobCleanup::i +(byte) renderBobCleanup::i#1 151.5 +(byte) renderBobCleanup::i#2 25.25 +(byte*) renderBobCleanup::screen +(byte*) renderBobCleanup::screen#0 112.22222222222223 +(byte**) renderBobCleanupNext +(byte**) renderBobCleanupNext#13 7.357142857142858 +(byte**) renderBobCleanupNext#17 3.3870967741935485 +(void()) renderBobInit() +(word~) renderBobInit::$0 16.5 +(word~) renderBobInit::$1 11.0 +(byte~) renderBobInit::$4 22.0 +(byte~) renderBobInit::$5 22.0 +(word~) renderBobInit::$6 22.0 +(word~) renderBobInit::$7 22.0 +(byte) renderBobInit::i +(byte) renderBobInit::i#1 16.5 +(byte) renderBobInit::i#2 11.0 +(byte) renderBobInit::y +(byte) renderBobInit::y#1 16.5 +(byte) renderBobInit::y#2 4.714285714285714 + +Initial phi equivalence classes +[ main::angle#8 main::angle#1 ] +[ main::r#2 main::r#1 ] +[ main::a#2 main::a#6 main::a#1 ] +[ renderBobCleanupNext#17 renderBobCleanupNext#13 ] +[ main::i#2 main::i#1 ] +[ mulf8s::mulf8s_prepare1_a#0 mulf8s::a#1 mulf8s::a#0 ] +[ mulf8s::b#2 mulf8s::b#1 mulf8s::b#0 ] +[ mulf8s_prepared::m#4 mulf8s_prepared::m#5 mulf8s_prepared::m#1 mulf8s_prepared::m#0 mulf8s_prepared::m#2 ] +[ renderBobCleanup::i#2 renderBobCleanup::i#1 ] +[ memset::dst#2 memset::dst#1 ] +[ renderBobInit::y#2 renderBobInit::y#1 ] +[ renderBobInit::i#2 renderBobInit::i#1 ] +[ prepareBobs::shift_y#2 prepareBobs::shift_y#1 ] +[ progress_cursor#15 progress_cursor#31 progress_cursor#24 progress_cursor#17 progress_cursor#8 ] +[ progress_idx#16 progress_idx#31 progress_idx#25 progress_idx#10 progress_idx#8 ] +[ prepareBobs::bob_table_idx#6 prepareBobs::bob_table_idx#12 prepareBobs::bob_table_idx#1 ] +[ prepareBobs::shift_x#2 prepareBobs::shift_x#1 ] +[ prepareBobs::cell#2 prepareBobs::cell#1 ] +[ prepareBobs::bob_glyph#2 prepareBobs::bob_glyph#1 ] +[ prepareBobs::bob_table#2 prepareBobs::bob_table#1 prepareBobs::bob_table#0 ] +[ bob_charset_next_id#23 bob_charset_next_id#14 bob_charset_next_id#16 bob_charset_next_id#30 bob_charset_next_id#21 bob_charset_next_id#8 ] +[ charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph#1 ] +[ charsetFindOrAddGlyph::glyph_id#11 charsetFindOrAddGlyph::glyph_id#1 ] +[ charsetFindOrAddGlyph::glyph_cursor#11 charsetFindOrAddGlyph::glyph_cursor#1 ] +[ charsetFindOrAddGlyph::i1#2 charsetFindOrAddGlyph::i1#1 ] +[ charsetFindOrAddGlyph::i#2 charsetFindOrAddGlyph::i#1 ] +[ charsetFindOrAddGlyph::found#2 ] +[ protoBobShiftRight::i#2 protoBobShiftRight::i#1 ] +[ protoBobShiftRight::j#3 protoBobShiftRight::j#10 protoBobShiftRight::j#2 protoBobShiftRight::j#1 ] +[ protoBobShiftRight::carry#2 protoBobShiftRight::carry#10 ] +[ protoBobShiftRight::carry#1 ] +[ protoBobShiftDown::i#2 protoBobShiftDown::i#1 ] +[ mulf_init::sqr1_lo#2 mulf_init::sqr1_lo#1 ] +[ mulf_init::c#2 mulf_init::c#1 ] +[ mulf_init::sqr1_hi#2 mulf_init::sqr1_hi#1 ] +[ mulf_init::x_2#3 mulf_init::x_2#2 mulf_init::x_2#1 ] +[ mulf_init::sqr2_lo#2 mulf_init::sqr2_lo#1 ] +[ mulf_init::x_255#2 mulf_init::x_255#1 ] +[ mulf_init::sqr2_hi#2 mulf_init::sqr2_hi#1 ] +[ mulf_init::dir#2 mulf_init::dir#4 ] +[ mulf_init::sqr#3 mulf_init::sqr#4 mulf_init::sqr#1 mulf_init::sqr#2 ] +Added variable mulf8s::return#2 to zero page equivalence class [ mulf8s::return#2 ] +Added variable main::$10 to zero page equivalence class [ main::$10 ] +Added variable main::x#0 to zero page equivalence class [ main::x#0 ] +Added variable mulf8s::return#3 to zero page equivalence class [ mulf8s::return#3 ] +Added variable main::$12 to zero page equivalence class [ main::$12 ] +Added variable main::$13 to zero page equivalence class [ main::$13 ] +Added variable main::y#0 to zero page equivalence class [ main::y#0 ] +Added variable renderBob::xpos#0 to zero page equivalence class [ renderBob::xpos#0 ] +Added variable renderBob::ypos#0 to zero page equivalence class [ renderBob::ypos#0 ] +Added variable keyboard_key_pressed::return#2 to zero page equivalence class [ keyboard_key_pressed::return#2 ] +Added variable main::$19 to zero page equivalence class [ main::$19 ] +Added variable keyboard_key_pressed::return#3 to zero page equivalence class [ keyboard_key_pressed::return#3 ] +Added variable main::$21 to zero page equivalence class [ main::$21 ] +Added variable keyboard_matrix_read::return#2 to zero page equivalence class [ keyboard_matrix_read::return#2 ] +Added variable keyboard_key_pressed::$2 to zero page equivalence class [ keyboard_key_pressed::$2 ] +Added variable keyboard_key_pressed::return#0 to zero page equivalence class [ keyboard_key_pressed::return#0 ] +Added variable keyboard_matrix_read::return#0 to zero page equivalence class [ keyboard_matrix_read::return#0 ] +Added variable renderBob::x_char_offset#0 to zero page equivalence class [ renderBob::x_char_offset#0 ] +Added variable renderBob::y_char_offset#0 to zero page equivalence class [ renderBob::y_char_offset#0 ] +Added variable renderBob::$8 to zero page equivalence class [ renderBob::$8 ] +Added variable renderBob::y_offset#0 to zero page equivalence class [ renderBob::y_offset#0 ] +Added variable renderBob::$2 to zero page equivalence class [ renderBob::$2 ] +Added variable renderBob::screen#0 to zero page equivalence class [ renderBob::screen#0 ] +Added variable renderBob::$4 to zero page equivalence class [ renderBob::$4 ] +Added variable renderBob::$5 to zero page equivalence class [ renderBob::$5 ] +Added variable renderBob::$6 to zero page equivalence class [ renderBob::$6 ] +Added variable renderBob::bob_table_idx#0 to zero page equivalence class [ renderBob::bob_table_idx#0 ] +Added variable mulf8u_prepare::a#0 to zero page equivalence class [ mulf8u_prepare::a#0 ] +Added variable mulf8s_prepared::b#0 to zero page equivalence class [ mulf8s_prepared::b#0 ] +Added variable mulf8s::return#0 to zero page equivalence class [ mulf8s::return#0 ] +Added variable mulf8u_prepared::b#0 to zero page equivalence class [ mulf8u_prepared::b#0 ] +Added variable mulf8u_prepared::return#2 to zero page equivalence class [ mulf8u_prepared::return#2 ] +Added variable mulf8s_prepared::$8 to zero page equivalence class [ mulf8s_prepared::$8 ] +Added variable mulf8s_prepared::$15 to zero page equivalence class [ mulf8s_prepared::$15 ] +Added variable mulf8s_prepared::$12 to zero page equivalence class [ mulf8s_prepared::$12 ] +Added variable mulf8s_prepared::$16 to zero page equivalence class [ mulf8s_prepared::$16 ] +Added variable mulf8u_prepared::return#0 to zero page equivalence class [ mulf8u_prepared::return#0 ] +Added variable renderBobCleanup::$1 to zero page equivalence class [ renderBobCleanup::$1 ] +Added variable renderBobCleanup::screen#0 to zero page equivalence class [ renderBobCleanup::screen#0 ] +Added variable renderBobInit::$0 to zero page equivalence class [ renderBobInit::$0 ] +Added variable renderBobInit::$6 to zero page equivalence class [ renderBobInit::$6 ] +Added variable renderBobInit::$7 to zero page equivalence class [ renderBobInit::$7 ] +Added variable renderBobInit::$1 to zero page equivalence class [ renderBobInit::$1 ] +Added variable renderBobInit::$4 to zero page equivalence class [ renderBobInit::$4 ] +Added variable renderBobInit::$5 to zero page equivalence class [ renderBobInit::$5 ] +Added variable charsetFindOrAddGlyph::return#1 to zero page equivalence class [ charsetFindOrAddGlyph::return#1 ] +Added variable prepareBobs::$6 to zero page equivalence class [ prepareBobs::$6 ] +Added variable protoBobShiftRight::$1 to zero page equivalence class [ protoBobShiftRight::$1 ] +Added variable protoBobShiftRight::$5 to zero page equivalence class [ protoBobShiftRight::$5 ] +Added variable protoBobShiftRight::$6 to zero page equivalence class [ protoBobShiftRight::$6 ] +Added variable mulf_init::$1 to zero page equivalence class [ mulf_init::$1 ] +Added variable mulf_init::$4 to zero page equivalence class [ mulf_init::$4 ] +Added variable mulf_init::$5 to zero page equivalence class [ mulf_init::$5 ] +Complete equivalence classes +[ main::angle#8 main::angle#1 ] +[ main::r#2 main::r#1 ] +[ main::a#2 main::a#6 main::a#1 ] +[ renderBobCleanupNext#17 renderBobCleanupNext#13 ] +[ main::i#2 main::i#1 ] +[ mulf8s::mulf8s_prepare1_a#0 mulf8s::a#1 mulf8s::a#0 ] +[ mulf8s::b#2 mulf8s::b#1 mulf8s::b#0 ] +[ mulf8s_prepared::m#4 mulf8s_prepared::m#5 mulf8s_prepared::m#1 mulf8s_prepared::m#0 mulf8s_prepared::m#2 ] +[ renderBobCleanup::i#2 renderBobCleanup::i#1 ] +[ memset::dst#2 memset::dst#1 ] +[ renderBobInit::y#2 renderBobInit::y#1 ] +[ renderBobInit::i#2 renderBobInit::i#1 ] +[ prepareBobs::shift_y#2 prepareBobs::shift_y#1 ] +[ progress_cursor#15 progress_cursor#31 progress_cursor#24 progress_cursor#17 progress_cursor#8 ] +[ progress_idx#16 progress_idx#31 progress_idx#25 progress_idx#10 progress_idx#8 ] +[ prepareBobs::bob_table_idx#6 prepareBobs::bob_table_idx#12 prepareBobs::bob_table_idx#1 ] +[ prepareBobs::shift_x#2 prepareBobs::shift_x#1 ] +[ prepareBobs::cell#2 prepareBobs::cell#1 ] +[ prepareBobs::bob_glyph#2 prepareBobs::bob_glyph#1 ] +[ prepareBobs::bob_table#2 prepareBobs::bob_table#1 prepareBobs::bob_table#0 ] +[ bob_charset_next_id#23 bob_charset_next_id#14 bob_charset_next_id#16 bob_charset_next_id#30 bob_charset_next_id#21 bob_charset_next_id#8 ] +[ charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph#1 ] +[ charsetFindOrAddGlyph::glyph_id#11 charsetFindOrAddGlyph::glyph_id#1 ] +[ charsetFindOrAddGlyph::glyph_cursor#11 charsetFindOrAddGlyph::glyph_cursor#1 ] +[ charsetFindOrAddGlyph::i1#2 charsetFindOrAddGlyph::i1#1 ] +[ charsetFindOrAddGlyph::i#2 charsetFindOrAddGlyph::i#1 ] +[ charsetFindOrAddGlyph::found#2 ] +[ protoBobShiftRight::i#2 protoBobShiftRight::i#1 ] +[ protoBobShiftRight::j#3 protoBobShiftRight::j#10 protoBobShiftRight::j#2 protoBobShiftRight::j#1 ] +[ protoBobShiftRight::carry#2 protoBobShiftRight::carry#10 ] +[ protoBobShiftRight::carry#1 ] +[ protoBobShiftDown::i#2 protoBobShiftDown::i#1 ] +[ mulf_init::sqr1_lo#2 mulf_init::sqr1_lo#1 ] +[ mulf_init::c#2 mulf_init::c#1 ] +[ mulf_init::sqr1_hi#2 mulf_init::sqr1_hi#1 ] +[ mulf_init::x_2#3 mulf_init::x_2#2 mulf_init::x_2#1 ] +[ mulf_init::sqr2_lo#2 mulf_init::sqr2_lo#1 ] +[ mulf_init::x_255#2 mulf_init::x_255#1 ] +[ mulf_init::sqr2_hi#2 mulf_init::sqr2_hi#1 ] +[ mulf_init::dir#2 mulf_init::dir#4 ] +[ mulf_init::sqr#3 mulf_init::sqr#4 mulf_init::sqr#1 mulf_init::sqr#2 ] +[ mulf8s::return#2 ] +[ main::$10 ] +[ main::x#0 ] +[ mulf8s::return#3 ] +[ main::$12 ] +[ main::$13 ] +[ main::y#0 ] +[ renderBob::xpos#0 ] +[ renderBob::ypos#0 ] +[ keyboard_key_pressed::return#2 ] +[ main::$19 ] +[ keyboard_key_pressed::return#3 ] +[ main::$21 ] +[ keyboard_matrix_read::return#2 ] +[ keyboard_key_pressed::$2 ] +[ keyboard_key_pressed::return#0 ] +[ keyboard_matrix_read::return#0 ] +[ renderBob::x_char_offset#0 ] +[ renderBob::y_char_offset#0 ] +[ renderBob::$8 ] +[ renderBob::y_offset#0 ] +[ renderBob::$2 ] +[ renderBob::screen#0 ] +[ renderBob::$4 ] +[ renderBob::$5 ] +[ renderBob::$6 ] +[ renderBob::bob_table_idx#0 ] +[ mulf8u_prepare::a#0 ] +[ mulf8s_prepared::b#0 ] +[ mulf8s::return#0 ] +[ mulf8u_prepared::b#0 ] +[ mulf8u_prepared::return#2 ] +[ mulf8s_prepared::$8 ] +[ mulf8s_prepared::$15 ] +[ mulf8s_prepared::$12 ] +[ mulf8s_prepared::$16 ] +[ mulf8u_prepared::return#0 ] +[ renderBobCleanup::$1 ] +[ renderBobCleanup::screen#0 ] +[ renderBobInit::$0 ] +[ renderBobInit::$6 ] +[ renderBobInit::$7 ] +[ renderBobInit::$1 ] +[ renderBobInit::$4 ] +[ renderBobInit::$5 ] +[ charsetFindOrAddGlyph::return#1 ] +[ prepareBobs::$6 ] +[ protoBobShiftRight::$1 ] +[ protoBobShiftRight::$5 ] +[ protoBobShiftRight::$6 ] +[ mulf_init::$1 ] +[ mulf_init::$4 ] +[ mulf_init::$5 ] +Allocated zp[1]:2 [ main::angle#8 main::angle#1 ] +Allocated zp[1]:3 [ main::r#2 main::r#1 ] +Allocated zp[1]:4 [ main::a#2 main::a#6 main::a#1 ] +Allocated zp[2]:5 [ renderBobCleanupNext#17 renderBobCleanupNext#13 ] +Allocated zp[1]:7 [ main::i#2 main::i#1 ] +Allocated zp[1]:8 [ mulf8s::mulf8s_prepare1_a#0 mulf8s::a#1 mulf8s::a#0 ] +Allocated zp[1]:9 [ mulf8s::b#2 mulf8s::b#1 mulf8s::b#0 ] +Allocated zp[2]:10 [ mulf8s_prepared::m#4 mulf8s_prepared::m#5 mulf8s_prepared::m#1 mulf8s_prepared::m#0 mulf8s_prepared::m#2 ] +Allocated zp[1]:12 [ renderBobCleanup::i#2 renderBobCleanup::i#1 ] +Allocated zp[2]:13 [ memset::dst#2 memset::dst#1 ] +Allocated zp[1]:15 [ renderBobInit::y#2 renderBobInit::y#1 ] +Allocated zp[1]:16 [ renderBobInit::i#2 renderBobInit::i#1 ] +Allocated zp[1]:17 [ prepareBobs::shift_y#2 prepareBobs::shift_y#1 ] +Allocated zp[2]:18 [ progress_cursor#15 progress_cursor#31 progress_cursor#24 progress_cursor#17 progress_cursor#8 ] +Allocated zp[1]:20 [ progress_idx#16 progress_idx#31 progress_idx#25 progress_idx#10 progress_idx#8 ] +Allocated zp[1]:21 [ prepareBobs::bob_table_idx#6 prepareBobs::bob_table_idx#12 prepareBobs::bob_table_idx#1 ] +Allocated zp[1]:22 [ prepareBobs::shift_x#2 prepareBobs::shift_x#1 ] +Allocated zp[1]:23 [ prepareBobs::cell#2 prepareBobs::cell#1 ] +Allocated zp[2]:24 [ prepareBobs::bob_glyph#2 prepareBobs::bob_glyph#1 ] +Allocated zp[2]:26 [ prepareBobs::bob_table#2 prepareBobs::bob_table#1 prepareBobs::bob_table#0 ] +Allocated zp[1]:28 [ bob_charset_next_id#23 bob_charset_next_id#14 bob_charset_next_id#16 bob_charset_next_id#30 bob_charset_next_id#21 bob_charset_next_id#8 ] +Allocated zp[2]:29 [ charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph#1 ] +Allocated zp[1]:31 [ charsetFindOrAddGlyph::glyph_id#11 charsetFindOrAddGlyph::glyph_id#1 ] +Allocated zp[2]:32 [ charsetFindOrAddGlyph::glyph_cursor#11 charsetFindOrAddGlyph::glyph_cursor#1 ] +Allocated zp[1]:34 [ charsetFindOrAddGlyph::i1#2 charsetFindOrAddGlyph::i1#1 ] +Allocated zp[1]:35 [ charsetFindOrAddGlyph::i#2 charsetFindOrAddGlyph::i#1 ] +Allocated zp[1]:36 [ charsetFindOrAddGlyph::found#2 ] +Allocated zp[1]:37 [ protoBobShiftRight::i#2 protoBobShiftRight::i#1 ] +Allocated zp[1]:38 [ protoBobShiftRight::j#3 protoBobShiftRight::j#10 protoBobShiftRight::j#2 protoBobShiftRight::j#1 ] +Allocated zp[1]:39 [ protoBobShiftRight::carry#2 protoBobShiftRight::carry#10 ] +Allocated zp[1]:40 [ protoBobShiftRight::carry#1 ] +Allocated zp[1]:41 [ protoBobShiftDown::i#2 protoBobShiftDown::i#1 ] +Allocated zp[2]:42 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_lo#1 ] +Allocated zp[1]:44 [ mulf_init::c#2 mulf_init::c#1 ] +Allocated zp[2]:45 [ mulf_init::sqr1_hi#2 mulf_init::sqr1_hi#1 ] +Allocated zp[1]:47 [ mulf_init::x_2#3 mulf_init::x_2#2 mulf_init::x_2#1 ] +Allocated zp[2]:48 [ mulf_init::sqr2_lo#2 mulf_init::sqr2_lo#1 ] +Allocated zp[1]:50 [ mulf_init::x_255#2 mulf_init::x_255#1 ] +Allocated zp[2]:51 [ mulf_init::sqr2_hi#2 mulf_init::sqr2_hi#1 ] +Allocated zp[1]:53 [ mulf_init::dir#2 mulf_init::dir#4 ] +Allocated zp[2]:54 [ mulf_init::sqr#3 mulf_init::sqr#4 mulf_init::sqr#1 mulf_init::sqr#2 ] +Allocated zp[2]:56 [ mulf8s::return#2 ] +Allocated zp[2]:58 [ main::$10 ] +Allocated zp[2]:60 [ main::x#0 ] +Allocated zp[2]:62 [ mulf8s::return#3 ] +Allocated zp[2]:64 [ main::$12 ] +Allocated zp[2]:66 [ main::$13 ] +Allocated zp[2]:68 [ main::y#0 ] +Allocated zp[1]:70 [ renderBob::xpos#0 ] +Allocated zp[1]:71 [ renderBob::ypos#0 ] +Allocated zp[1]:72 [ keyboard_key_pressed::return#2 ] +Allocated zp[1]:73 [ main::$19 ] +Allocated zp[1]:74 [ keyboard_key_pressed::return#3 ] +Allocated zp[1]:75 [ main::$21 ] +Allocated zp[1]:76 [ keyboard_matrix_read::return#2 ] +Allocated zp[1]:77 [ keyboard_key_pressed::$2 ] +Allocated zp[1]:78 [ keyboard_key_pressed::return#0 ] +Allocated zp[1]:79 [ keyboard_matrix_read::return#0 ] +Allocated zp[1]:80 [ renderBob::x_char_offset#0 ] +Allocated zp[1]:81 [ renderBob::y_char_offset#0 ] +Allocated zp[1]:82 [ renderBob::$8 ] +Allocated zp[2]:83 [ renderBob::y_offset#0 ] +Allocated zp[2]:85 [ renderBob::$2 ] +Allocated zp[2]:87 [ renderBob::screen#0 ] +Allocated zp[1]:89 [ renderBob::$4 ] +Allocated zp[1]:90 [ renderBob::$5 ] +Allocated zp[1]:91 [ renderBob::$6 ] +Allocated zp[1]:92 [ renderBob::bob_table_idx#0 ] +Allocated zp[1]:93 [ mulf8u_prepare::a#0 ] +Allocated zp[1]:94 [ mulf8s_prepared::b#0 ] +Allocated zp[2]:95 [ mulf8s::return#0 ] +Allocated zp[1]:97 [ mulf8u_prepared::b#0 ] +Allocated zp[2]:98 [ mulf8u_prepared::return#2 ] +Allocated zp[1]:100 [ mulf8s_prepared::$8 ] +Allocated zp[1]:101 [ mulf8s_prepared::$15 ] +Allocated zp[1]:102 [ mulf8s_prepared::$12 ] +Allocated zp[1]:103 [ mulf8s_prepared::$16 ] +Allocated zp[2]:104 [ mulf8u_prepared::return#0 ] +Allocated zp[1]:106 [ renderBobCleanup::$1 ] +Allocated zp[2]:107 [ renderBobCleanup::screen#0 ] +Allocated zp[2]:109 [ renderBobInit::$0 ] +Allocated zp[2]:111 [ renderBobInit::$6 ] +Allocated zp[2]:113 [ renderBobInit::$7 ] +Allocated zp[2]:115 [ renderBobInit::$1 ] +Allocated zp[1]:117 [ renderBobInit::$4 ] +Allocated zp[1]:118 [ renderBobInit::$5 ] +Allocated zp[1]:119 [ charsetFindOrAddGlyph::return#1 ] +Allocated zp[1]:120 [ prepareBobs::$6 ] +Allocated zp[1]:121 [ protoBobShiftRight::$1 ] +Allocated zp[1]:122 [ protoBobShiftRight::$5 ] +Allocated zp[1]:123 [ protoBobShiftRight::$6 ] +Allocated zp[1]:124 [ mulf_init::$1 ] +Allocated zp[1]:125 [ mulf_init::$4 ] +Allocated zp[1]:126 [ mulf_init::$5 ] + +INITIAL ASM +Target platform is c64basic / MOS6502X + // File Comments +// Pre-calculated bobs inside a charset (pre-moved to all x/y-combinations) + // Upstart +.pc = $801 "Basic" +:BasicUpstart(__bbegin) +.pc = $80d "Program" + // Global Constants & labels + .label RASTER = $d012 + .label BORDERCOL = $d020 + .label D018 = $d018 + // CIA#1 Port A: keyboard matrix columns and joystick #2 + .label CIA1_PORT_A = $dc00 + // CIA#1 Port B: keyboard matrix rows and joystick #1. + .label CIA1_PORT_B = $dc01 + // CIA#2 Port A: Serial bus, RS-232, VIC memory bank + .label CIA2_PORT_A = $dd00 + // CIA #2 Port A data direction register. + .label CIA2_PORT_A_DDR = $dd02 + .const KEY_SPACE = $3c + // The BASIC screen + .label SCREEN_BASIC = $400 + // The BASIC charset + .label CHARSET_BASIC = $1000 + // The BOB screen + .label BOB_SCREEN = $2800 + // The BOB charset + .label BOB_CHARSET = $2000 + // The number of different X-shifts + .const BOB_SHIFTS_X = 4 + // The number of different Y-shifts + .const BOB_SHIFTS_Y = 8 + // The size of a sub-table of BOB_TABLES + .const BOB_SUBTABLE_SIZE = BOB_SHIFTS_X*BOB_SHIFTS_Y + // The number of BOBs to render + .const NUM_BOBS = $14 + .const SIZEOF_POINTER = 2 + .label COS = SIN+$40 + // BOB charset ID of the next glyph to be added + .label bob_charset_next_id = $1c + // Current index within the progress cursor (0-7) + .label progress_idx = $14 + // Current position of the progress cursor + .label progress_cursor = $12 + // Pointer to the next clean-up to add + // Prepare for next clean-up + .label renderBobCleanupNext = 5 + // @begin +__bbegin: + // [1] phi from @begin to @1 [phi:@begin->@1] +__b1_from___bbegin: + jmp __b1 + // @1 +__b1: + // [2] call main + // [4] phi from @1 to main [phi:@1->main] +main_from___b1: + jsr main + // [3] phi from @1 to @end [phi:@1->@end] +__bend_from___b1: + jmp __bend + // @end +__bend: + // main +main: { + .const vicSelectGfxBank1_toDd001_return = 3 + .const vicSelectGfxBank2_toDd001_return = 3 + .const toD0181_return = (>(BOB_SCREEN&$3fff)*4)|(>BOB_CHARSET)/4&$f + .const toD0182_return = (>(SCREEN_BASIC&$3fff)*4)|(>CHARSET_BASIC)/4&$f + .label __10 = $3a + .label __12 = $40 + .label __13 = $42 + .label __19 = $49 + .label __21 = $4b + .label x = $3c + .label y = $44 + .label a = 4 + .label r = 3 + .label i = 7 + // Render Rotated BOBs + .label angle = 2 + // [5] call mulf_init + // [243] phi from main to mulf_init [phi:main->mulf_init] + mulf_init_from_main: + jsr mulf_init + // [6] phi from main to main::@9 [phi:main->main::@9] + __b9_from_main: + jmp __b9 + // main::@9 + __b9: + // [7] call prepareBobs + // [159] phi from main::@9 to prepareBobs [phi:main::@9->prepareBobs] + prepareBobs_from___b9: + jsr prepareBobs + // [8] phi from main::@9 to main::@10 [phi:main::@9->main::@10] + __b10_from___b9: + jmp __b10 + // main::@10 + __b10: + // [9] call renderBobInit + // [143] phi from main::@10 to renderBobInit [phi:main::@10->renderBobInit] + renderBobInit_from___b10: + jsr renderBobInit + jmp vicSelectGfxBank1 + // main::vicSelectGfxBank1 + vicSelectGfxBank1: + // [10] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 -- _deref_pbuc1=vbuc2 + lda #3 + sta CIA2_PORT_A_DDR + // [11] phi from main::vicSelectGfxBank1 to main::vicSelectGfxBank1_toDd001 [phi:main::vicSelectGfxBank1->main::vicSelectGfxBank1_toDd001] + vicSelectGfxBank1_toDd001_from_vicSelectGfxBank1: + jmp vicSelectGfxBank1_toDd001 + // main::vicSelectGfxBank1_toDd001 + vicSelectGfxBank1_toDd001: + jmp vicSelectGfxBank1___b1 + // main::vicSelectGfxBank1_@1 + vicSelectGfxBank1___b1: + // [12] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank1_toDd001_return#0 -- _deref_pbuc1=vbuc2 + lda #vicSelectGfxBank1_toDd001_return + sta CIA2_PORT_A + // [13] phi from main::vicSelectGfxBank1_@1 to main::toD0181 [phi:main::vicSelectGfxBank1_@1->main::toD0181] + toD0181_from_vicSelectGfxBank1___b1: + jmp toD0181 + // main::toD0181 + toD0181: + jmp __b7 + // main::@7 + __b7: + // [14] *((const byte*) D018) ← (const byte) main::toD0181_return#0 -- _deref_pbuc1=vbuc2 + lda #toD0181_return + sta D018 + // [15] call memset + // [137] phi from main::@7 to memset [phi:main::@7->memset] + memset_from___b7: + jsr memset + // [16] phi from main::@7 to main::@1 [phi:main::@7->main::@1] + __b1_from___b7: + // [16] phi (byte) main::angle#8 = (byte) 0 [phi:main::@7->main::@1#0] -- vbuz1=vbuc1 + lda #0 + sta.z angle + jmp __b1 + // main::@1 + __b1: + jmp __b2 + // main::@2 + __b2: + // [17] if(*((const byte*) RASTER)<(byte) $f8) goto main::@2 -- _deref_pbuc1_lt_vbuc2_then_la1 + lda RASTER + cmp #$f8 + bcc __b2 + jmp __b3 + // main::@3 + __b3: + // [18] *((const byte*) BORDERCOL) ← (byte) $f -- _deref_pbuc1=vbuc2 + lda #$f + sta BORDERCOL + // [19] call renderBobCleanup + // [121] phi from main::@3 to renderBobCleanup [phi:main::@3->renderBobCleanup] + renderBobCleanup_from___b3: + jsr renderBobCleanup + jmp __b11 + // main::@11 + __b11: + // [20] (byte) main::a#6 ← (byte) main::angle#8 -- vbuz1=vbuz2 + lda.z angle + sta.z a + // [21] phi from main::@11 to main::@4 [phi:main::@11->main::@4] + __b4_from___b11: + // [21] phi (byte) main::i#2 = (byte) 0 [phi:main::@11->main::@4#0] -- vbuz1=vbuc1 + lda #0 + sta.z i + // [21] phi (byte**) renderBobCleanupNext#17 = (const byte**) RENDERBOB_CLEANUP [phi:main::@11->main::@4#1] -- pptz1=pptc1 + lda #RENDERBOB_CLEANUP + sta.z renderBobCleanupNext+1 + // [21] phi (byte) main::a#2 = (byte) main::a#6 [phi:main::@11->main::@4#2] -- register_copy + // [21] phi (signed byte) main::r#2 = (signed byte) $1e [phi:main::@11->main::@4#3] -- vbsz1=vbsc1 + lda #$1e + sta.z r + jmp __b4 + // [21] phi from main::@14 to main::@4 [phi:main::@14->main::@4] + __b4_from___b14: + // [21] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@14->main::@4#0] -- register_copy + // [21] phi (byte**) renderBobCleanupNext#17 = (byte**) renderBobCleanupNext#13 [phi:main::@14->main::@4#1] -- register_copy + // [21] phi (byte) main::a#2 = (byte) main::a#1 [phi:main::@14->main::@4#2] -- register_copy + // [21] phi (signed byte) main::r#2 = (signed byte) main::r#1 [phi:main::@14->main::@4#3] -- register_copy + jmp __b4 + // main::@4 + __b4: + // [22] *((const byte*) BORDERCOL) ← (byte) 1 -- _deref_pbuc1=vbuc2 + //kickasm {{ .break }} + lda #1 + sta BORDERCOL + // [23] (signed byte) mulf8s::a#0 ← (signed byte) main::r#2 -- vbsz1=vbsz2 + lda.z r + sta.z mulf8s.a + // [24] (signed byte) mulf8s::b#0 ← *((const signed byte*) COS + (byte) main::a#2) -- vbsz1=pbsc1_derefidx_vbuz2 + ldy.z a + lda COS,y + sta.z mulf8s.b + // [25] call mulf8s + // [92] phi from main::@4 to mulf8s [phi:main::@4->mulf8s] + mulf8s_from___b4: + // [92] phi (signed byte) mulf8s::b#2 = (signed byte) mulf8s::b#0 [phi:main::@4->mulf8s#0] -- register_copy + // [92] phi (signed byte) mulf8s::mulf8s_prepare1_a#0 = (signed byte) mulf8s::a#0 [phi:main::@4->mulf8s#1] -- register_copy + jsr mulf8s + // [26] (signed word) mulf8s::return#2 ← (signed word) mulf8s::return#0 -- vwsz1=vwsz2 + lda.z mulf8s.return + sta.z mulf8s.return_1 + lda.z mulf8s.return+1 + sta.z mulf8s.return_1+1 + jmp __b12 + // main::@12 + __b12: + // [27] (signed word~) main::$10 ← (signed word) mulf8s::return#2 -- vwsz1=vwsz2 + lda.z mulf8s.return_1 + sta.z __10 + lda.z mulf8s.return_1+1 + sta.z __10+1 + // [28] (signed word) main::x#0 ← (signed word~) main::$10 + (signed word)(number) $4b*(number) $100 -- vwsz1=vwsz2_plus_vwsc1 + lda.z __10 + clc + adc #<$4b*$100 + sta.z x + lda.z __10+1 + adc #>$4b*$100 + sta.z x+1 + // [29] (signed byte) mulf8s::a#1 ← (signed byte) main::r#2 -- vbsz1=vbsz2 + lda.z r + sta.z mulf8s.a + // [30] (signed byte) mulf8s::b#1 ← *((const signed byte*) SIN + (byte) main::a#2) -- vbsz1=pbsc1_derefidx_vbuz2 + ldy.z a + lda SIN,y + sta.z mulf8s.b + // [31] call mulf8s + // [92] phi from main::@12 to mulf8s [phi:main::@12->mulf8s] + mulf8s_from___b12: + // [92] phi (signed byte) mulf8s::b#2 = (signed byte) mulf8s::b#1 [phi:main::@12->mulf8s#0] -- register_copy + // [92] phi (signed byte) mulf8s::mulf8s_prepare1_a#0 = (signed byte) mulf8s::a#1 [phi:main::@12->mulf8s#1] -- register_copy + jsr mulf8s + // [32] (signed word) mulf8s::return#3 ← (signed word) mulf8s::return#0 -- vwsz1=vwsz2 + lda.z mulf8s.return + sta.z mulf8s.return_2 + lda.z mulf8s.return+1 + sta.z mulf8s.return_2+1 + jmp __b13 + // main::@13 + __b13: + // [33] (signed word~) main::$12 ← (signed word) mulf8s::return#3 -- vwsz1=vwsz2 + lda.z mulf8s.return_2 + sta.z __12 + lda.z mulf8s.return_2+1 + sta.z __12+1 + // [34] (signed word~) main::$13 ← (signed word~) main::$12 << (byte) 1 -- vwsz1=vwsz2_rol_1 + lda.z __12 + asl + sta.z __13 + lda.z __12+1 + rol + sta.z __13+1 + // [35] (signed word) main::y#0 ← (signed word~) main::$13 + (signed word)(number) $5a*(number) $100 -- vwsz1=vwsz2_plus_vwsc1 + lda.z __13 + clc + adc #<$5a*$100 + sta.z y + lda.z __13+1 + adc #>$5a*$100 + sta.z y+1 + // [36] *((const byte*) BORDERCOL) ← (byte) 2 -- _deref_pbuc1=vbuc2 + lda #2 + sta BORDERCOL + // [37] (byte) main::a#1 ← (byte) main::a#2 + (byte) $62 -- vbuz1=vbuz1_plus_vbuc1 + lax.z a + axs #-[$62] + stx.z a + // [38] (signed byte) main::r#1 ← (signed byte) main::r#2 + (signed byte) 3 -- vbsz1=vbsz1_plus_vbsc1 + lax.z r + axs #-[3] + stx.z r + // [39] (byte) renderBob::xpos#0 ← > (signed word) main::x#0 -- vbuz1=_hi_vwsz2 + lda.z x+1 + sta.z renderBob.xpos + // [40] (byte) renderBob::ypos#0 ← > (signed word) main::y#0 -- vbuz1=_hi_vwsz2 + lda.z y+1 + sta.z renderBob.ypos + // [41] call renderBob + jsr renderBob + jmp __b14 + // main::@14 + __b14: + // [42] (byte) main::i#1 ← ++ (byte) main::i#2 -- vbuz1=_inc_vbuz1 + inc.z i + // [43] if((byte) main::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto main::@4 -- vbuz1_neq_vbuc1_then_la1 + lda #NUM_BOBS-1+1 + cmp.z i + bne __b4_from___b14 + jmp __b5 + // main::@5 + __b5: + // [44] (byte) main::angle#1 ← (byte) main::angle#8 + (byte) 3 -- vbuz1=vbuz1_plus_vbuc1 + lax.z angle + axs #-[3] + stx.z angle + // [45] *((const byte*) BORDERCOL) ← (byte) 0 -- _deref_pbuc1=vbuc2 + lda #0 + sta BORDERCOL + // [46] call keyboard_key_pressed + // [61] phi from main::@5 to keyboard_key_pressed [phi:main::@5->keyboard_key_pressed] + keyboard_key_pressed_from___b5: + jsr keyboard_key_pressed + // [47] (byte) keyboard_key_pressed::return#2 ← (byte) keyboard_key_pressed::return#0 -- vbuz1=vbuz2 + lda.z keyboard_key_pressed.return + sta.z keyboard_key_pressed.return_1 + jmp __b15 + // main::@15 + __b15: + // [48] (byte~) main::$19 ← (byte) keyboard_key_pressed::return#2 -- vbuz1=vbuz2 + lda.z keyboard_key_pressed.return_1 + sta.z __19 + // [49] if((byte) 0!=(byte~) main::$19) goto main::@6 -- vbuc1_neq_vbuz1_then_la1 + lda #0 + cmp.z __19 + bne __b6_from___b15 + // [16] phi from main::@15 to main::@1 [phi:main::@15->main::@1] + __b1_from___b15: + // [16] phi (byte) main::angle#8 = (byte) main::angle#1 [phi:main::@15->main::@1#0] -- register_copy + jmp __b1 + // Wait for space release + // [50] phi from main::@15 main::@16 to main::@6 [phi:main::@15/main::@16->main::@6] + __b6_from___b15: + __b6_from___b16: + jmp __b6 + // main::@6 + __b6: + // [51] call keyboard_key_pressed + // [61] phi from main::@6 to keyboard_key_pressed [phi:main::@6->keyboard_key_pressed] + keyboard_key_pressed_from___b6: + jsr keyboard_key_pressed + // [52] (byte) keyboard_key_pressed::return#3 ← (byte) keyboard_key_pressed::return#0 -- vbuz1=vbuz2 + lda.z keyboard_key_pressed.return + sta.z keyboard_key_pressed.return_2 + jmp __b16 + // main::@16 + __b16: + // [53] (byte~) main::$21 ← (byte) keyboard_key_pressed::return#3 -- vbuz1=vbuz2 + lda.z keyboard_key_pressed.return_2 + sta.z __21 + // [54] if((byte) 0!=(byte~) main::$21) goto main::@6 -- vbuc1_neq_vbuz1_then_la1 + lda #0 + cmp.z __21 + bne __b6_from___b16 + jmp vicSelectGfxBank2 + // main::vicSelectGfxBank2 + vicSelectGfxBank2: + // [55] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 -- _deref_pbuc1=vbuc2 + lda #3 + sta CIA2_PORT_A_DDR + // [56] phi from main::vicSelectGfxBank2 to main::vicSelectGfxBank2_toDd001 [phi:main::vicSelectGfxBank2->main::vicSelectGfxBank2_toDd001] + vicSelectGfxBank2_toDd001_from_vicSelectGfxBank2: + jmp vicSelectGfxBank2_toDd001 + // main::vicSelectGfxBank2_toDd001 + vicSelectGfxBank2_toDd001: + jmp vicSelectGfxBank2___b1 + // main::vicSelectGfxBank2_@1 + vicSelectGfxBank2___b1: + // [57] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank2_toDd001_return#0 -- _deref_pbuc1=vbuc2 + lda #vicSelectGfxBank2_toDd001_return + sta CIA2_PORT_A + // [58] phi from main::vicSelectGfxBank2_@1 to main::toD0182 [phi:main::vicSelectGfxBank2_@1->main::toD0182] + toD0182_from_vicSelectGfxBank2___b1: + jmp toD0182 + // main::toD0182 + toD0182: + jmp __b8 + // main::@8 + __b8: + // [59] *((const byte*) D018) ← (const byte) main::toD0182_return#0 -- _deref_pbuc1=vbuc2 + lda #toD0182_return + sta D018 + jmp __breturn + // main::@return + __breturn: + // [60] return + rts +} + // keyboard_key_pressed +// Determines whether a specific key is currently pressed by accessing the matrix directly +// The key is a keyboard code defined from the keyboard matrix by %00rrrccc, where rrr is the row ID (0-7) and ccc is the column ID (0-7) +// All keys exist as as KEY_XXX constants. +// Returns zero if the key is not pressed and a non-zero value if the key is currently pressed +keyboard_key_pressed: { + .const colidx = KEY_SPACE&7 + .label rowidx = KEY_SPACE>>3 + .label __2 = $4d + .label return = $4e + .label return_1 = $48 + .label return_2 = $4a + // [62] call keyboard_matrix_read + jsr keyboard_matrix_read + // [63] (byte) keyboard_matrix_read::return#2 ← (byte) keyboard_matrix_read::return#0 -- vbuz1=vbuz2 + lda.z keyboard_matrix_read.return + sta.z keyboard_matrix_read.return_1 + jmp __b1 + // keyboard_key_pressed::@1 + __b1: + // [64] (byte~) keyboard_key_pressed::$2 ← (byte) keyboard_matrix_read::return#2 -- vbuz1=vbuz2 + lda.z keyboard_matrix_read.return_1 + sta.z __2 + // [65] (byte) keyboard_key_pressed::return#0 ← (byte~) keyboard_key_pressed::$2 & *((const byte*) keyboard_matrix_col_bitmask+(const byte) keyboard_key_pressed::colidx#0) -- vbuz1=vbuz2_band__deref_pbuc1 + lda keyboard_matrix_col_bitmask+colidx + and.z __2 + sta.z return + jmp __breturn + // keyboard_key_pressed::@return + __breturn: + // [66] return + rts +} + // keyboard_matrix_read +// Read a single row of the keyboard matrix +// The row ID (0-7) of the keyboard matrix row to read. See the C64 key matrix for row IDs. +// Returns the keys pressed on the row as bits according to the C64 key matrix. +// Notice: If the C64 normal interrupt is still running it will occasionally interrupt right between the read & write +// leading to erroneous readings. You must disable kill the normal interrupt or sei/cli around calls to the keyboard matrix reader. +keyboard_matrix_read: { + .label return = $4f + .label return_1 = $4c + // [67] *((const byte*) CIA1_PORT_A) ← *((const byte*) keyboard_matrix_row_bitmask+(const byte) keyboard_key_pressed::rowidx#0) -- _deref_pbuc1=_deref_pbuc2 + lda keyboard_matrix_row_bitmask+keyboard_key_pressed.rowidx + sta CIA1_PORT_A + // [68] (byte) keyboard_matrix_read::return#0 ← ~ *((const byte*) CIA1_PORT_B) -- vbuz1=_bnot__deref_pbuc1 + lda CIA1_PORT_B + eor #$ff + sta.z return + jmp __breturn + // keyboard_matrix_read::@return + __breturn: + // [69] return + rts +} + // renderBob +// Render a single BOB at a given x/y-position +// X-position is 0-151. Each x-position is 2 pixels wide. +// Y-position is 0-183. Each y-position is 1 pixel high. +// renderBob(byte zeropage($46) xpos, byte zeropage($47) ypos) +renderBob: { + .label __2 = $55 + .label __4 = $59 + .label __5 = $5a + .label __6 = $5b + .label __8 = $52 + .label xpos = $46 + .label ypos = $47 + .label x_char_offset = $50 + .label y_char_offset = $51 + .label y_offset = $53 + .label screen = $57 + .label bob_table_idx = $5c + // [70] (byte) renderBob::x_char_offset#0 ← (byte) renderBob::xpos#0 >> (byte) 2 -- vbuz1=vbuz2_ror_2 + lda.z xpos + lsr + lsr + sta.z x_char_offset + // [71] (byte) renderBob::y_char_offset#0 ← (byte) renderBob::ypos#0 >> (byte) 3 -- vbuz1=vbuz2_ror_3 + lda.z ypos + lsr + lsr + lsr + sta.z y_char_offset + // [72] (byte~) renderBob::$8 ← (byte) renderBob::y_char_offset#0 << (byte) 1 -- vbuz1=vbuz2_rol_1 + lda.z y_char_offset + asl + sta.z __8 + // [73] (word) renderBob::y_offset#0 ← *((const word*) MUL40 + (byte~) renderBob::$8) -- vwuz1=pwuc1_derefidx_vbuz2 + ldy.z __8 + lda MUL40,y + sta.z y_offset + lda MUL40+1,y + sta.z y_offset+1 + // [74] (byte*~) renderBob::$2 ← (const byte*) BOB_SCREEN + (word) renderBob::y_offset#0 -- pbuz1=pbuc1_plus_vwuz2 + lda.z y_offset + clc + adc #BOB_SCREEN + sta.z __2+1 + // [75] (byte*) renderBob::screen#0 ← (byte*~) renderBob::$2 + (byte) renderBob::x_char_offset#0 -- pbuz1=pbuz2_plus_vbuz3 + lda.z x_char_offset + clc + adc.z __2 + sta.z screen + lda #0 + adc.z __2+1 + sta.z screen+1 + // [76] (byte~) renderBob::$4 ← (byte) renderBob::ypos#0 & (byte) 7 -- vbuz1=vbuz2_band_vbuc1 + lda #7 + and.z ypos + sta.z __4 + // [77] (byte~) renderBob::$5 ← (byte~) renderBob::$4 << (byte) 2 -- vbuz1=vbuz2_rol_2 + lda.z __4 + asl + asl + sta.z __5 + // [78] (byte~) renderBob::$6 ← (byte) renderBob::xpos#0 & (byte) 3 -- vbuz1=vbuz2_band_vbuc1 + lda #3 + and.z xpos + sta.z __6 + // [79] (byte) renderBob::bob_table_idx#0 ← (byte~) renderBob::$5 + (byte~) renderBob::$6 -- vbuz1=vbuz2_plus_vbuz3 + lda.z __5 + clc + adc.z __6 + sta.z bob_table_idx + // [80] *((byte**) renderBobCleanupNext#17) ← (byte*) renderBob::screen#0 -- _deref_pptz1=pbuz2 + ldy #0 + lda.z screen + sta (renderBobCleanupNext),y + iny + lda.z screen+1 + sta (renderBobCleanupNext),y + // [81] (byte**) renderBobCleanupNext#13 ← (byte**) renderBobCleanupNext#17 + (const byte) SIZEOF_POINTER -- pptz1=pptz1_plus_vbuc1 + lda #SIZEOF_POINTER + clc + adc.z renderBobCleanupNext + sta.z renderBobCleanupNext + bcc !+ + inc.z renderBobCleanupNext+1 + !: + // [82] *((byte*) renderBob::screen#0) ← *((const byte*) BOB_TABLES + (byte) renderBob::bob_table_idx#0) -- _deref_pbuz1=pbuc1_derefidx_vbuz2 + ldy.z bob_table_idx + lda BOB_TABLES,y + ldy #0 + sta (screen),y + // [83] *((byte*) renderBob::screen#0 + (byte) $28) ← *((const byte*) BOB_TABLES+(byte) 1*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuz2 + ldy.z bob_table_idx + lda BOB_TABLES+1*BOB_SUBTABLE_SIZE,y + ldy #$28 + sta (screen),y + // [84] *((byte*) renderBob::screen#0 + (byte) $50) ← *((const byte*) BOB_TABLES+(byte) 2*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuz2 + ldy.z bob_table_idx + lda BOB_TABLES+2*BOB_SUBTABLE_SIZE,y + ldy #$50 + sta (screen),y + // [85] *((byte*) renderBob::screen#0 + (byte) 1) ← *((const byte*) BOB_TABLES+(byte) 3*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuz2 + ldy.z bob_table_idx + lda BOB_TABLES+3*BOB_SUBTABLE_SIZE,y + ldy #1 + sta (screen),y + // [86] *((byte*) renderBob::screen#0 + (byte) $29) ← *((const byte*) BOB_TABLES+(byte) 4*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuz2 + ldy.z bob_table_idx + lda BOB_TABLES+4*BOB_SUBTABLE_SIZE,y + ldy #$29 + sta (screen),y + // [87] *((byte*) renderBob::screen#0 + (byte) $51) ← *((const byte*) BOB_TABLES+(byte) 5*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuz2 + ldy.z bob_table_idx + lda BOB_TABLES+5*BOB_SUBTABLE_SIZE,y + ldy #$51 + sta (screen),y + // [88] *((byte*) renderBob::screen#0 + (byte) 2) ← *((const byte*) BOB_TABLES+(byte) 6*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuz2 + ldy.z bob_table_idx + lda BOB_TABLES+6*BOB_SUBTABLE_SIZE,y + ldy #2 + sta (screen),y + // [89] *((byte*) renderBob::screen#0 + (byte) $2a) ← *((const byte*) BOB_TABLES+(byte) 7*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuz2 + ldy.z bob_table_idx + lda BOB_TABLES+7*BOB_SUBTABLE_SIZE,y + ldy #$2a + sta (screen),y + // [90] *((byte*) renderBob::screen#0 + (byte) $52) ← *((const byte*) BOB_TABLES+(byte) 8*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuz2 + ldy.z bob_table_idx + lda BOB_TABLES+8*BOB_SUBTABLE_SIZE,y + ldy #$52 + sta (screen),y + jmp __breturn + // renderBob::@return + __breturn: + // [91] return + rts +} + // mulf8s +// Fast multiply two signed bytes to a word result +// mulf8s(signed byte zeropage(8) a, signed byte zeropage(9) b) +mulf8s: { + .label mulf8s_prepare1_a = 8 + .label return = $5f + .label a = 8 + .label b = 9 + .label return_1 = $38 + .label return_2 = $3e + jmp mulf8s_prepare1 + // mulf8s::mulf8s_prepare1 + mulf8s_prepare1: + // [93] (byte) mulf8u_prepare::a#0 ← (byte)(signed byte) mulf8s::mulf8s_prepare1_a#0 -- vbuz1=vbuz2 + lda.z mulf8s_prepare1_a + sta.z mulf8u_prepare.a + // [94] call mulf8u_prepare + jsr mulf8u_prepare + jmp __b1 + // mulf8s::@1 + __b1: + // [95] (signed byte) mulf8s_prepared::b#0 ← (signed byte) mulf8s::b#2 -- vbsz1=vbsz2 + lda.z b + sta.z mulf8s_prepared.b + // [96] call mulf8s_prepared + jsr mulf8s_prepared + jmp __b2 + // mulf8s::@2 + __b2: + // [97] (signed word) mulf8s::return#0 ← (signed word)(word) mulf8s_prepared::m#4 -- vwsz1=vwsz2 + lda.z mulf8s_prepared.m + sta.z return + lda.z mulf8s_prepared.m+1 + sta.z return+1 + jmp __breturn + // mulf8s::@return + __breturn: + // [98] return + rts +} + // mulf8s_prepared +// Calculate fast multiply with a prepared unsigned byte to a word result +// The prepared number is set by calling mulf8s_prepare(byte a) +// mulf8s_prepared(signed byte zeropage($5e) b) +mulf8s_prepared: { + .label memA = $fd + .label __8 = $64 + .label __12 = $66 + .label __15 = $65 + .label __16 = $67 + .label m = $a + .label b = $5e + // [99] (byte) mulf8u_prepared::b#0 ← (byte)(signed byte) mulf8s_prepared::b#0 -- vbuz1=vbuz2 + lda.z b + sta.z mulf8u_prepared.b + // [100] call mulf8u_prepared + jsr mulf8u_prepared + // [101] (word) mulf8u_prepared::return#2 ← (word) mulf8u_prepared::return#0 -- vwuz1=vwuz2 + lda.z mulf8u_prepared.return + sta.z mulf8u_prepared.return_1 + lda.z mulf8u_prepared.return+1 + sta.z mulf8u_prepared.return_1+1 + jmp __b5 + // mulf8s_prepared::@5 + __b5: + // [102] (word) mulf8s_prepared::m#0 ← (word) mulf8u_prepared::return#2 -- vwuz1=vwuz2 + lda.z mulf8u_prepared.return_1 + sta.z m + lda.z mulf8u_prepared.return_1+1 + sta.z m+1 + // [103] if(*((const signed byte*) mulf8s_prepared::memA)>=(signed byte) 0) goto mulf8s_prepared::@1 -- _deref_pbsc1_ge_0_then_la1 + lda memA + cmp #0 + bpl __b1_from___b5 + jmp __b3 + // mulf8s_prepared::@3 + __b3: + // [104] (byte~) mulf8s_prepared::$8 ← > (word) mulf8s_prepared::m#0 -- vbuz1=_hi_vwuz2 + lda.z m+1 + sta.z __8 + // [105] (byte~) mulf8s_prepared::$15 ← (byte~) mulf8s_prepared::$8 - (byte)(signed byte) mulf8s_prepared::b#0 -- vbuz1=vbuz2_minus_vbuz3 + lda.z __8 + sec + sbc.z b + sta.z __15 + // [106] (word) mulf8s_prepared::m#1 ← (word) mulf8s_prepared::m#0 hi= (byte~) mulf8s_prepared::$15 -- vwuz1=vwuz1_sethi_vbuz2 + lda.z __15 + sta.z m+1 + // [107] phi from mulf8s_prepared::@3 mulf8s_prepared::@5 to mulf8s_prepared::@1 [phi:mulf8s_prepared::@3/mulf8s_prepared::@5->mulf8s_prepared::@1] + __b1_from___b3: + __b1_from___b5: + // [107] phi (word) mulf8s_prepared::m#5 = (word) mulf8s_prepared::m#1 [phi:mulf8s_prepared::@3/mulf8s_prepared::@5->mulf8s_prepared::@1#0] -- register_copy + jmp __b1 + // mulf8s_prepared::@1 + __b1: + // [108] if((signed byte) mulf8s_prepared::b#0>=(signed byte) 0) goto mulf8s_prepared::@2 -- vbsz1_ge_0_then_la1 + lda.z b + cmp #0 + bpl __b2_from___b1 + jmp __b4 + // mulf8s_prepared::@4 + __b4: + // [109] (byte~) mulf8s_prepared::$12 ← > (word) mulf8s_prepared::m#5 -- vbuz1=_hi_vwuz2 + lda.z m+1 + sta.z __12 + // [110] (byte~) mulf8s_prepared::$16 ← (byte~) mulf8s_prepared::$12 - (byte)*((const signed byte*) mulf8s_prepared::memA) -- vbuz1=vbuz2_minus__deref_pbuc1 + lda.z __12 + sec + sbc memA + sta.z __16 + // [111] (word) mulf8s_prepared::m#2 ← (word) mulf8s_prepared::m#5 hi= (byte~) mulf8s_prepared::$16 -- vwuz1=vwuz1_sethi_vbuz2 + lda.z __16 + sta.z m+1 + // [112] phi from mulf8s_prepared::@1 mulf8s_prepared::@4 to mulf8s_prepared::@2 [phi:mulf8s_prepared::@1/mulf8s_prepared::@4->mulf8s_prepared::@2] + __b2_from___b1: + __b2_from___b4: + // [112] phi (word) mulf8s_prepared::m#4 = (word) mulf8s_prepared::m#5 [phi:mulf8s_prepared::@1/mulf8s_prepared::@4->mulf8s_prepared::@2#0] -- register_copy + jmp __b2 + // mulf8s_prepared::@2 + __b2: + jmp __breturn + // mulf8s_prepared::@return + __breturn: + // [113] return + rts +} + // mulf8u_prepared +// Calculate fast multiply with a prepared unsigned byte to a word result +// The prepared number is set by calling mulf8u_prepare(byte a) +// mulf8u_prepared(byte zeropage($61) b) +mulf8u_prepared: { + .label resL = $fe + .label memB = $ff + .label return = $68 + .label b = $61 + .label return_1 = $62 + // [114] *((const byte*) mulf8u_prepared::memB) ← (byte) mulf8u_prepared::b#0 -- _deref_pbuc1=vbuz1 + lda.z b + sta memB + // asm { ldxmemB sec sm1: ldamulf_sqr1_lo,x sm2: sbcmulf_sqr2_lo,x staresL sm3: ldamulf_sqr1_hi,x sm4: sbcmulf_sqr2_hi,x stamemB } + ldx memB + sec + sm1: + lda mulf_sqr1_lo,x + sm2: + sbc mulf_sqr2_lo,x + sta resL + sm3: + lda mulf_sqr1_hi,x + sm4: + sbc mulf_sqr2_hi,x + sta memB + // [116] (word) mulf8u_prepared::return#0 ← *((const byte*) mulf8u_prepared::memB) w= *((const byte*) mulf8u_prepared::resL) -- vwuz1=_deref_pbuc1_word__deref_pbuc2 + lda resL + sta.z return + lda memB + sta.z return+1 + jmp __breturn + // mulf8u_prepared::@return + __breturn: + // [117] return + rts +} + // mulf8u_prepare +// Prepare for fast multiply with an unsigned byte to a word result +// mulf8u_prepare(byte zeropage($5d) a) +mulf8u_prepare: { + .label memA = $fd + .label a = $5d + // [118] *((const byte*) mulf8u_prepare::memA) ← (byte) mulf8u_prepare::a#0 -- _deref_pbuc1=vbuz1 + lda.z a + sta memA + // asm { ldamemA stamulf8u_prepared.sm1+1 stamulf8u_prepared.sm3+1 eor#$ff stamulf8u_prepared.sm2+1 stamulf8u_prepared.sm4+1 } + lda memA + sta mulf8u_prepared.sm1+1 + sta mulf8u_prepared.sm3+1 + eor #$ff + sta mulf8u_prepared.sm2+1 + sta mulf8u_prepared.sm4+1 + jmp __breturn + // mulf8u_prepare::@return + __breturn: + // [120] return + rts +} + // renderBobCleanup +// Clean Up the rendered BOB's +renderBobCleanup: { + .label __1 = $6a + .label screen = $6b + .label i = $c + // [122] phi from renderBobCleanup to renderBobCleanup::@1 [phi:renderBobCleanup->renderBobCleanup::@1] + __b1_from_renderBobCleanup: + // [122] phi (byte) renderBobCleanup::i#2 = (byte) 0 [phi:renderBobCleanup->renderBobCleanup::@1#0] -- vbuz1=vbuc1 + lda #0 + sta.z i + jmp __b1 + // [122] phi from renderBobCleanup::@1 to renderBobCleanup::@1 [phi:renderBobCleanup::@1->renderBobCleanup::@1] + __b1_from___b1: + // [122] phi (byte) renderBobCleanup::i#2 = (byte) renderBobCleanup::i#1 [phi:renderBobCleanup::@1->renderBobCleanup::@1#0] -- register_copy + jmp __b1 + // renderBobCleanup::@1 + __b1: + // [123] (byte~) renderBobCleanup::$1 ← (byte) renderBobCleanup::i#2 << (byte) 1 -- vbuz1=vbuz2_rol_1 + lda.z i + asl + sta.z __1 + // [124] (byte*) renderBobCleanup::screen#0 ← *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobCleanup::$1) -- pbuz1=pptc1_derefidx_vbuz2 + ldy.z __1 + lda RENDERBOB_CLEANUP,y + sta.z screen + lda RENDERBOB_CLEANUP+1,y + sta.z screen+1 + // [125] *((byte*) renderBobCleanup::screen#0) ← (byte) 0 -- _deref_pbuz1=vbuc1 + lda #0 + ldy #0 + sta (screen),y + // [126] *((byte*) renderBobCleanup::screen#0 + (byte) $28) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + lda #0 + ldy #$28 + sta (screen),y + // [127] *((byte*) renderBobCleanup::screen#0 + (byte) $50) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + lda #0 + ldy #$50 + sta (screen),y + // [128] *((byte*) renderBobCleanup::screen#0 + (byte) 1) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + lda #0 + ldy #1 + sta (screen),y + // [129] *((byte*) renderBobCleanup::screen#0 + (byte) $29) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + lda #0 + ldy #$29 + sta (screen),y + // [130] *((byte*) renderBobCleanup::screen#0 + (byte) $51) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + lda #0 + ldy #$51 + sta (screen),y + // [131] *((byte*) renderBobCleanup::screen#0 + (byte) 2) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + lda #0 + ldy #2 + sta (screen),y + // [132] *((byte*) renderBobCleanup::screen#0 + (byte) $2a) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + lda #0 + ldy #$2a + sta (screen),y + // [133] *((byte*) renderBobCleanup::screen#0 + (byte) $52) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + lda #0 + ldy #$52 + sta (screen),y + // [134] (byte) renderBobCleanup::i#1 ← ++ (byte) renderBobCleanup::i#2 -- vbuz1=_inc_vbuz1 + inc.z i + // [135] if((byte) renderBobCleanup::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto renderBobCleanup::@1 -- vbuz1_neq_vbuc1_then_la1 + lda #NUM_BOBS-1+1 + cmp.z i + bne __b1_from___b1 + jmp __breturn + // renderBobCleanup::@return + __breturn: + // [136] return + rts +} + // memset +// Copies the character c (an unsigned char) to the first num characters of the object pointed to by the argument str. +memset: { + .label str = BOB_SCREEN + .const c = 0 + .const num = $3e8 + .label end = str+num + .label dst = $d + // [138] phi from memset to memset::@1 [phi:memset->memset::@1] + __b1_from_memset: + // [138] phi (byte*) memset::dst#2 = (byte*)(const void*) memset::str#0 [phi:memset->memset::@1#0] -- pbuz1=pbuc1 + lda #str + sta.z dst+1 + jmp __b1 + // memset::@1 + __b1: + // [139] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 -- pbuz1_neq_pbuc1_then_la1 + lda.z dst+1 + cmp #>end + bne __b2 + lda.z dst + cmp #memset::@1] + __b1_from___b2: + // [138] phi (byte*) memset::dst#2 = (byte*) memset::dst#1 [phi:memset::@2->memset::@1#0] -- register_copy + jmp __b1 +} + // renderBobInit +// Initialize the tables used by renderBob() +renderBobInit: { + .label __0 = $6d + .label __1 = $73 + .label __4 = $75 + .label __5 = $76 + .label y = $f + .label i = $10 + .label __6 = $6f + .label __7 = $71 + // [144] phi from renderBobInit to renderBobInit::@1 [phi:renderBobInit->renderBobInit::@1] + __b1_from_renderBobInit: + // [144] phi (byte) renderBobInit::y#2 = (byte) 0 [phi:renderBobInit->renderBobInit::@1#0] -- vbuz1=vbuc1 + lda #0 + sta.z y + jmp __b1 + // [144] phi from renderBobInit::@1 to renderBobInit::@1 [phi:renderBobInit::@1->renderBobInit::@1] + __b1_from___b1: + // [144] phi (byte) renderBobInit::y#2 = (byte) renderBobInit::y#1 [phi:renderBobInit::@1->renderBobInit::@1#0] -- register_copy + jmp __b1 + // renderBobInit::@1 + __b1: + // [145] (word~) renderBobInit::$0 ← (word)(byte) renderBobInit::y#2 -- vwuz1=_word_vbuz2 + lda.z y + sta.z __0 + lda #0 + sta.z __0+1 + // [146] (word~) renderBobInit::$6 ← (word~) renderBobInit::$0 << (byte) 2 -- vwuz1=vwuz2_rol_2 + lda.z __0 + asl + sta.z __6 + lda.z __0+1 + rol + sta.z __6+1 + asl.z __6 + rol.z __6+1 + // [147] (word~) renderBobInit::$7 ← (word~) renderBobInit::$6 + (word~) renderBobInit::$0 -- vwuz1=vwuz2_plus_vwuz3 + lda.z __6 + clc + adc.z __0 + sta.z __7 + lda.z __6+1 + adc.z __0+1 + sta.z __7+1 + // [148] (word~) renderBobInit::$1 ← (word~) renderBobInit::$7 << (byte) 3 -- vwuz1=vwuz2_rol_3 + lda.z __7 + asl + sta.z __1 + lda.z __7+1 + rol + sta.z __1+1 + asl.z __1 + rol.z __1+1 + asl.z __1 + rol.z __1+1 + // [149] (byte~) renderBobInit::$4 ← (byte) renderBobInit::y#2 << (byte) 1 -- vbuz1=vbuz2_rol_1 + lda.z y + asl + sta.z __4 + // [150] *((const word*) MUL40 + (byte~) renderBobInit::$4) ← (word~) renderBobInit::$1 -- pwuc1_derefidx_vbuz1=vwuz2 + ldy.z __4 + lda.z __1 + sta MUL40,y + lda.z __1+1 + sta MUL40+1,y + // [151] (byte) renderBobInit::y#1 ← ++ (byte) renderBobInit::y#2 -- vbuz1=_inc_vbuz1 + inc.z y + // [152] if((byte) renderBobInit::y#1!=(byte) $20) goto renderBobInit::@1 -- vbuz1_neq_vbuc1_then_la1 + lda #$20 + cmp.z y + bne __b1_from___b1 + // [153] phi from renderBobInit::@1 to renderBobInit::@2 [phi:renderBobInit::@1->renderBobInit::@2] + __b2_from___b1: + // [153] phi (byte) renderBobInit::i#2 = (byte) 0 [phi:renderBobInit::@1->renderBobInit::@2#0] -- vbuz1=vbuc1 + lda #0 + sta.z i + jmp __b2 + // [153] phi from renderBobInit::@2 to renderBobInit::@2 [phi:renderBobInit::@2->renderBobInit::@2] + __b2_from___b2: + // [153] phi (byte) renderBobInit::i#2 = (byte) renderBobInit::i#1 [phi:renderBobInit::@2->renderBobInit::@2#0] -- register_copy + jmp __b2 + // renderBobInit::@2 + __b2: + // [154] (byte~) renderBobInit::$5 ← (byte) renderBobInit::i#2 << (byte) 1 -- vbuz1=vbuz2_rol_1 + lda.z i + asl + sta.z __5 + // [155] *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobInit::$5) ← (const byte*) BOB_SCREEN -- pptc1_derefidx_vbuz1=pbuc2 + ldy.z __5 + lda #BOB_SCREEN + sta RENDERBOB_CLEANUP+1,y + // [156] (byte) renderBobInit::i#1 ← ++ (byte) renderBobInit::i#2 -- vbuz1=_inc_vbuz1 + inc.z i + // [157] if((byte) renderBobInit::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto renderBobInit::@2 -- vbuz1_neq_vbuc1_then_la1 + lda #NUM_BOBS-1+1 + cmp.z i + bne __b2_from___b2 + jmp __breturn + // renderBobInit::@return + __breturn: + // [158] return + rts +} + // prepareBobs +// Creates the pre-shifted bobs into BOB_CHARSET and populates the BOB_TABLES +// Modifies PROTO_BOB by shifting it around +prepareBobs: { + .label __6 = $78 + .label bob_table = $1a + .label shift_y = $11 + // Populate charset and tables + .label bob_glyph = $18 + .label cell = $17 + .label bob_table_idx = $15 + .label shift_x = $16 + // [160] call progress_init + // [241] phi from prepareBobs to progress_init [phi:prepareBobs->progress_init] + progress_init_from_prepareBobs: + jsr progress_init + // [161] phi from prepareBobs to prepareBobs::@8 [phi:prepareBobs->prepareBobs::@8] + __b8_from_prepareBobs: + jmp __b8 + // prepareBobs::@8 + __b8: + // [162] call charsetFindOrAddGlyph + // [195] phi from prepareBobs::@8 to charsetFindOrAddGlyph [phi:prepareBobs::@8->charsetFindOrAddGlyph] + charsetFindOrAddGlyph_from___b8: + // [195] phi (byte*) charsetFindOrAddGlyph::glyph#10 = (const byte*) PROTO_BOB+(byte) $30 [phi:prepareBobs::@8->charsetFindOrAddGlyph#0] -- pbuz1=pbuc1 + lda #PROTO_BOB+$30 + sta.z charsetFindOrAddGlyph.glyph+1 + // [195] phi (byte) bob_charset_next_id#23 = (byte) 0 [phi:prepareBobs::@8->charsetFindOrAddGlyph#1] -- vbuz1=vbuc1 + lda #0 + sta.z bob_charset_next_id + jsr charsetFindOrAddGlyph + // [163] phi from prepareBobs::@8 to prepareBobs::@1 [phi:prepareBobs::@8->prepareBobs::@1] + __b1_from___b8: + // [163] phi (byte) prepareBobs::bob_table_idx#6 = (byte) 0 [phi:prepareBobs::@8->prepareBobs::@1#0] -- vbuz1=vbuc1 + lda #0 + sta.z bob_table_idx + // [163] phi (byte) bob_charset_next_id#14 = (byte) bob_charset_next_id#16 [phi:prepareBobs::@8->prepareBobs::@1#1] -- register_copy + // [163] phi (byte) progress_idx#16 = (byte) 0 [phi:prepareBobs::@8->prepareBobs::@1#2] -- vbuz1=vbuc1 + lda #0 + sta.z progress_idx + // [163] phi (byte*) progress_cursor#15 = (const byte*) SCREEN_BASIC [phi:prepareBobs::@8->prepareBobs::@1#3] -- pbuz1=pbuc1 + lda #SCREEN_BASIC + sta.z progress_cursor+1 + // [163] phi (byte) prepareBobs::shift_y#2 = (byte) 0 [phi:prepareBobs::@8->prepareBobs::@1#4] -- vbuz1=vbuc1 + lda #0 + sta.z shift_y + jmp __b1 + // prepareBobs::@1 + __b1: + // [164] if((byte) prepareBobs::shift_y#2<(const byte) BOB_SHIFTS_Y) goto prepareBobs::@2 -- vbuz1_lt_vbuc1_then_la1 + lda.z shift_y + cmp #BOB_SHIFTS_Y + bcc __b2_from___b1 + jmp __breturn + // prepareBobs::@return + __breturn: + // [165] return + rts + // [166] phi from prepareBobs::@1 to prepareBobs::@2 [phi:prepareBobs::@1->prepareBobs::@2] + __b2_from___b1: + // [166] phi (byte) progress_idx#31 = (byte) progress_idx#16 [phi:prepareBobs::@1->prepareBobs::@2#0] -- register_copy + // [166] phi (byte*) progress_cursor#31 = (byte*) progress_cursor#15 [phi:prepareBobs::@1->prepareBobs::@2#1] -- register_copy + // [166] phi (byte) bob_charset_next_id#30 = (byte) bob_charset_next_id#14 [phi:prepareBobs::@1->prepareBobs::@2#2] -- register_copy + // [166] phi (byte) prepareBobs::bob_table_idx#12 = (byte) prepareBobs::bob_table_idx#6 [phi:prepareBobs::@1->prepareBobs::@2#3] -- register_copy + // [166] phi (byte) prepareBobs::shift_x#2 = (byte) 0 [phi:prepareBobs::@1->prepareBobs::@2#4] -- vbuz1=vbuc1 + lda #0 + sta.z shift_x + jmp __b2 + // prepareBobs::@2 + __b2: + // [167] if((byte) prepareBobs::shift_x#2<(const byte) BOB_SHIFTS_X) goto prepareBobs::@3 -- vbuz1_lt_vbuc1_then_la1 + lda.z shift_x + cmp #BOB_SHIFTS_X + bcc __b3 + // [168] phi from prepareBobs::@2 to prepareBobs::@4 [phi:prepareBobs::@2->prepareBobs::@4] + __b4_from___b2: + jmp __b4 + // prepareBobs::@4 + __b4: + // [169] call protoBobShiftDown + // [230] phi from prepareBobs::@4 to protoBobShiftDown [phi:prepareBobs::@4->protoBobShiftDown] + protoBobShiftDown_from___b4: + jsr protoBobShiftDown + jmp __b9 + // prepareBobs::@9 + __b9: + // [170] (byte) prepareBobs::shift_y#1 ← ++ (byte) prepareBobs::shift_y#2 -- vbuz1=_inc_vbuz1 + inc.z shift_y + // [163] phi from prepareBobs::@9 to prepareBobs::@1 [phi:prepareBobs::@9->prepareBobs::@1] + __b1_from___b9: + // [163] phi (byte) prepareBobs::bob_table_idx#6 = (byte) prepareBobs::bob_table_idx#12 [phi:prepareBobs::@9->prepareBobs::@1#0] -- register_copy + // [163] phi (byte) bob_charset_next_id#14 = (byte) bob_charset_next_id#30 [phi:prepareBobs::@9->prepareBobs::@1#1] -- register_copy + // [163] phi (byte) progress_idx#16 = (byte) progress_idx#31 [phi:prepareBobs::@9->prepareBobs::@1#2] -- register_copy + // [163] phi (byte*) progress_cursor#15 = (byte*) progress_cursor#31 [phi:prepareBobs::@9->prepareBobs::@1#3] -- register_copy + // [163] phi (byte) prepareBobs::shift_y#2 = (byte) prepareBobs::shift_y#1 [phi:prepareBobs::@9->prepareBobs::@1#4] -- register_copy + jmp __b1 + // prepareBobs::@3 + __b3: + // [171] (byte*) prepareBobs::bob_table#0 ← (const byte*) BOB_TABLES + (byte) prepareBobs::bob_table_idx#12 -- pbuz1=pbuc1_plus_vbuz2 + lda.z bob_table_idx + clc + adc #BOB_TABLES + adc #0 + sta.z bob_table+1 + // [172] phi from prepareBobs::@3 to prepareBobs::@5 [phi:prepareBobs::@3->prepareBobs::@5] + __b5_from___b3: + // [172] phi (byte*) progress_cursor#24 = (byte*) progress_cursor#31 [phi:prepareBobs::@3->prepareBobs::@5#0] -- register_copy + // [172] phi (byte) progress_idx#25 = (byte) progress_idx#31 [phi:prepareBobs::@3->prepareBobs::@5#1] -- register_copy + // [172] phi (byte*) prepareBobs::bob_table#2 = (byte*) prepareBobs::bob_table#0 [phi:prepareBobs::@3->prepareBobs::@5#2] -- register_copy + // [172] phi (byte) bob_charset_next_id#21 = (byte) bob_charset_next_id#30 [phi:prepareBobs::@3->prepareBobs::@5#3] -- register_copy + // [172] phi (byte*) prepareBobs::bob_glyph#2 = (const byte*) PROTO_BOB [phi:prepareBobs::@3->prepareBobs::@5#4] -- pbuz1=pbuc1 + lda #PROTO_BOB + sta.z bob_glyph+1 + // [172] phi (byte) prepareBobs::cell#2 = (byte) 0 [phi:prepareBobs::@3->prepareBobs::@5#5] -- vbuz1=vbuc1 + lda #0 + sta.z cell + jmp __b5 + // prepareBobs::@5 + __b5: + // [173] if((byte) prepareBobs::cell#2<(byte) 9) goto prepareBobs::@6 -- vbuz1_lt_vbuc1_then_la1 + lda.z cell + cmp #9 + bcc __b6 + jmp __b7 + // prepareBobs::@7 + __b7: + // [174] (byte) prepareBobs::bob_table_idx#1 ← ++ (byte) prepareBobs::bob_table_idx#12 -- vbuz1=_inc_vbuz1 + inc.z bob_table_idx + // [175] call protoBobShiftRight + // [213] phi from prepareBobs::@7 to protoBobShiftRight [phi:prepareBobs::@7->protoBobShiftRight] + protoBobShiftRight_from___b7: + jsr protoBobShiftRight + // [176] phi from prepareBobs::@7 to prepareBobs::@12 [phi:prepareBobs::@7->prepareBobs::@12] + __b12_from___b7: + jmp __b12 + // prepareBobs::@12 + __b12: + // [177] call protoBobShiftRight + // [213] phi from prepareBobs::@12 to protoBobShiftRight [phi:prepareBobs::@12->protoBobShiftRight] + protoBobShiftRight_from___b12: + jsr protoBobShiftRight + jmp __b13 + // prepareBobs::@13 + __b13: + // [178] (byte) prepareBobs::shift_x#1 ← ++ (byte) prepareBobs::shift_x#2 -- vbuz1=_inc_vbuz1 + inc.z shift_x + // [166] phi from prepareBobs::@13 to prepareBobs::@2 [phi:prepareBobs::@13->prepareBobs::@2] + __b2_from___b13: + // [166] phi (byte) progress_idx#31 = (byte) progress_idx#25 [phi:prepareBobs::@13->prepareBobs::@2#0] -- register_copy + // [166] phi (byte*) progress_cursor#31 = (byte*) progress_cursor#24 [phi:prepareBobs::@13->prepareBobs::@2#1] -- register_copy + // [166] phi (byte) bob_charset_next_id#30 = (byte) bob_charset_next_id#21 [phi:prepareBobs::@13->prepareBobs::@2#2] -- register_copy + // [166] phi (byte) prepareBobs::bob_table_idx#12 = (byte) prepareBobs::bob_table_idx#1 [phi:prepareBobs::@13->prepareBobs::@2#3] -- register_copy + // [166] phi (byte) prepareBobs::shift_x#2 = (byte) prepareBobs::shift_x#1 [phi:prepareBobs::@13->prepareBobs::@2#4] -- register_copy + jmp __b2 + // prepareBobs::@6 + __b6: + // [179] (byte*) charsetFindOrAddGlyph::glyph#1 ← (byte*) prepareBobs::bob_glyph#2 -- pbuz1=pbuz2 + lda.z bob_glyph + sta.z charsetFindOrAddGlyph.glyph + lda.z bob_glyph+1 + sta.z charsetFindOrAddGlyph.glyph+1 + // [180] call charsetFindOrAddGlyph + // [195] phi from prepareBobs::@6 to charsetFindOrAddGlyph [phi:prepareBobs::@6->charsetFindOrAddGlyph] + charsetFindOrAddGlyph_from___b6: + // [195] phi (byte*) charsetFindOrAddGlyph::glyph#10 = (byte*) charsetFindOrAddGlyph::glyph#1 [phi:prepareBobs::@6->charsetFindOrAddGlyph#0] -- register_copy + // [195] phi (byte) bob_charset_next_id#23 = (byte) bob_charset_next_id#21 [phi:prepareBobs::@6->charsetFindOrAddGlyph#1] -- register_copy + jsr charsetFindOrAddGlyph + // [181] (byte) charsetFindOrAddGlyph::return#1 ← (byte) charsetFindOrAddGlyph::glyph_id#11 -- vbuz1=vbuz2 + lda.z charsetFindOrAddGlyph.glyph_id + sta.z charsetFindOrAddGlyph.return + jmp __b10 + // prepareBobs::@10 + __b10: + // [182] (byte~) prepareBobs::$6 ← (byte) charsetFindOrAddGlyph::return#1 -- vbuz1=vbuz2 + lda.z charsetFindOrAddGlyph.return + sta.z __6 + // [183] *((byte*) prepareBobs::bob_table#2) ← (byte~) prepareBobs::$6 -- _deref_pbuz1=vbuz2 + // Look for an existing char in BOB_CHARSET + lda.z __6 + ldy #0 + sta (bob_table),y + // [184] (byte*) prepareBobs::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 + (byte) 8 -- pbuz1=pbuz1_plus_vbuc1 + // Move to the next glyph + lda #8 + clc + adc.z bob_glyph + sta.z bob_glyph + bcc !+ + inc.z bob_glyph+1 + !: + // [185] (byte*) prepareBobs::bob_table#1 ← (byte*) prepareBobs::bob_table#2 + (const byte) BOB_SHIFTS_X*(const byte) BOB_SHIFTS_Y -- pbuz1=pbuz1_plus_vbuc1 + // Move to the next sub-table + lda #BOB_SHIFTS_X*BOB_SHIFTS_Y + clc + adc.z bob_table + sta.z bob_table + bcc !+ + inc.z bob_table+1 + !: + // [186] call progress_inc + jsr progress_inc + jmp __b11 + // prepareBobs::@11 + __b11: + // [187] (byte) prepareBobs::cell#1 ← ++ (byte) prepareBobs::cell#2 -- vbuz1=_inc_vbuz1 + inc.z cell + // [172] phi from prepareBobs::@11 to prepareBobs::@5 [phi:prepareBobs::@11->prepareBobs::@5] + __b5_from___b11: + // [172] phi (byte*) progress_cursor#24 = (byte*) progress_cursor#17 [phi:prepareBobs::@11->prepareBobs::@5#0] -- register_copy + // [172] phi (byte) progress_idx#25 = (byte) progress_idx#10 [phi:prepareBobs::@11->prepareBobs::@5#1] -- register_copy + // [172] phi (byte*) prepareBobs::bob_table#2 = (byte*) prepareBobs::bob_table#1 [phi:prepareBobs::@11->prepareBobs::@5#2] -- register_copy + // [172] phi (byte) bob_charset_next_id#21 = (byte) bob_charset_next_id#16 [phi:prepareBobs::@11->prepareBobs::@5#3] -- register_copy + // [172] phi (byte*) prepareBobs::bob_glyph#2 = (byte*) prepareBobs::bob_glyph#1 [phi:prepareBobs::@11->prepareBobs::@5#4] -- register_copy + // [172] phi (byte) prepareBobs::cell#2 = (byte) prepareBobs::cell#1 [phi:prepareBobs::@11->prepareBobs::@5#5] -- register_copy + jmp __b5 +} + // progress_inc +// Increase PETSCII progress one bit +// Done by increasing the character until the idx is 8 and then moving to the next char +progress_inc: { + // [188] (byte) progress_idx#8 ← ++ (byte) progress_idx#25 -- vbuz1=_inc_vbuz1 + inc.z progress_idx + // [189] if((byte) progress_idx#8!=(byte) 8) goto progress_inc::@1 -- vbuz1_neq_vbuc1_then_la1 + lda #8 + cmp.z progress_idx + bne __b1_from_progress_inc + jmp __b2 + // progress_inc::@2 + __b2: + // [190] *((byte*) progress_cursor#24) ← *((const byte*) progress_inc::progress_chars+(byte) 8) -- _deref_pbuz1=_deref_pbuc1 + lda progress_chars+8 + ldy #0 + sta (progress_cursor),y + // [191] (byte*) progress_cursor#8 ← ++ (byte*) progress_cursor#24 -- pbuz1=_inc_pbuz1 + inc.z progress_cursor + bne !+ + inc.z progress_cursor+1 + !: + // [192] phi from progress_inc::@2 to progress_inc::@1 [phi:progress_inc::@2->progress_inc::@1] + __b1_from___b2: + // [192] phi (byte*) progress_cursor#17 = (byte*) progress_cursor#8 [phi:progress_inc::@2->progress_inc::@1#0] -- register_copy + // [192] phi (byte) progress_idx#10 = (byte) 0 [phi:progress_inc::@2->progress_inc::@1#1] -- vbuz1=vbuc1 + lda #0 + sta.z progress_idx + jmp __b1 + // [192] phi from progress_inc to progress_inc::@1 [phi:progress_inc->progress_inc::@1] + __b1_from_progress_inc: + // [192] phi (byte*) progress_cursor#17 = (byte*) progress_cursor#24 [phi:progress_inc->progress_inc::@1#0] -- register_copy + // [192] phi (byte) progress_idx#10 = (byte) progress_idx#8 [phi:progress_inc->progress_inc::@1#1] -- register_copy + jmp __b1 + // progress_inc::@1 + __b1: + // [193] *((byte*) progress_cursor#17) ← *((const byte*) progress_inc::progress_chars + (byte) progress_idx#10) -- _deref_pbuz1=pbuc1_derefidx_vbuz2 + ldy.z progress_idx + lda progress_chars,y + ldy #0 + sta (progress_cursor),y + jmp __breturn + // progress_inc::@return + __breturn: + // [194] return + rts + // Progress characters + progress_chars: .byte $20, $65, $74, $75, $61, $f6, $e7, $ea, $e0 +} + // charsetFindOrAddGlyph +// Looks through a charset to find a glyph if present. If not present it is added. +// Returns the glyph ID +// charsetFindOrAddGlyph(byte* zeropage($1d) glyph) +charsetFindOrAddGlyph: { + .label glyph = $1d + .label return = $77 + .label i = $23 + .label glyph_id = $1f + .label glyph_cursor = $20 + .label i1 = $22 + .label found = $24 + // [196] phi from charsetFindOrAddGlyph to charsetFindOrAddGlyph::@1 [phi:charsetFindOrAddGlyph->charsetFindOrAddGlyph::@1] + __b1_from_charsetFindOrAddGlyph: + // [196] phi (byte*) charsetFindOrAddGlyph::glyph_cursor#11 = (const byte*) BOB_CHARSET [phi:charsetFindOrAddGlyph->charsetFindOrAddGlyph::@1#0] -- pbuz1=pbuc1 + lda #BOB_CHARSET + sta.z glyph_cursor+1 + // [196] phi (byte) charsetFindOrAddGlyph::glyph_id#11 = (byte) 0 [phi:charsetFindOrAddGlyph->charsetFindOrAddGlyph::@1#1] -- vbuz1=vbuc1 + lda #0 + sta.z glyph_id + jmp __b1 + // charsetFindOrAddGlyph::@1 + __b1: + // [197] if((byte) charsetFindOrAddGlyph::glyph_id#11!=(byte) bob_charset_next_id#23) goto charsetFindOrAddGlyph::@2 -- vbuz1_neq_vbuz2_then_la1 + lda.z glyph_id + cmp.z bob_charset_next_id + bne __b2_from___b1 + // [198] phi from charsetFindOrAddGlyph::@1 to charsetFindOrAddGlyph::@7 [phi:charsetFindOrAddGlyph::@1->charsetFindOrAddGlyph::@7] + __b7_from___b1: + // [198] phi (byte) charsetFindOrAddGlyph::i1#2 = (byte) 0 [phi:charsetFindOrAddGlyph::@1->charsetFindOrAddGlyph::@7#0] -- vbuz1=vbuc1 + lda #0 + sta.z i1 + jmp __b7 + // Not found - add it + // charsetFindOrAddGlyph::@7 + __b7: + // [199] if((byte) charsetFindOrAddGlyph::i1#2<(byte) 8) goto charsetFindOrAddGlyph::@8 -- vbuz1_lt_vbuc1_then_la1 + lda.z i1 + cmp #8 + bcc __b8 + jmp __b9 + // charsetFindOrAddGlyph::@9 + __b9: + // [200] (byte) bob_charset_next_id#8 ← ++ (byte) bob_charset_next_id#23 -- vbuz1=_inc_vbuz1 + inc.z bob_charset_next_id + // [201] phi from charsetFindOrAddGlyph::@5 charsetFindOrAddGlyph::@9 to charsetFindOrAddGlyph::@return [phi:charsetFindOrAddGlyph::@5/charsetFindOrAddGlyph::@9->charsetFindOrAddGlyph::@return] + __breturn_from___b5: + __breturn_from___b9: + // [201] phi (byte) bob_charset_next_id#16 = (byte) bob_charset_next_id#23 [phi:charsetFindOrAddGlyph::@5/charsetFindOrAddGlyph::@9->charsetFindOrAddGlyph::@return#0] -- register_copy + jmp __breturn + // charsetFindOrAddGlyph::@return + __breturn: + // [202] return + rts + // charsetFindOrAddGlyph::@8 + __b8: + // [203] *((byte*) charsetFindOrAddGlyph::glyph_cursor#11 + (byte) charsetFindOrAddGlyph::i1#2) ← *((byte*) charsetFindOrAddGlyph::glyph#10 + (byte) charsetFindOrAddGlyph::i1#2) -- pbuz1_derefidx_vbuz2=pbuz3_derefidx_vbuz2 + ldy.z i1 + lda (glyph),y + sta (glyph_cursor),y + // [204] (byte) charsetFindOrAddGlyph::i1#1 ← ++ (byte) charsetFindOrAddGlyph::i1#2 -- vbuz1=_inc_vbuz1 + inc.z i1 + // [198] phi from charsetFindOrAddGlyph::@8 to charsetFindOrAddGlyph::@7 [phi:charsetFindOrAddGlyph::@8->charsetFindOrAddGlyph::@7] + __b7_from___b8: + // [198] phi (byte) charsetFindOrAddGlyph::i1#2 = (byte) charsetFindOrAddGlyph::i1#1 [phi:charsetFindOrAddGlyph::@8->charsetFindOrAddGlyph::@7#0] -- register_copy + jmp __b7 + // [205] phi from charsetFindOrAddGlyph::@1 to charsetFindOrAddGlyph::@2 [phi:charsetFindOrAddGlyph::@1->charsetFindOrAddGlyph::@2] + __b2_from___b1: + // [205] phi (byte) charsetFindOrAddGlyph::i#2 = (byte) 0 [phi:charsetFindOrAddGlyph::@1->charsetFindOrAddGlyph::@2#0] -- vbuz1=vbuc1 + lda #0 + sta.z i + jmp __b2 + // charsetFindOrAddGlyph::@2 + __b2: + // [206] if((byte) charsetFindOrAddGlyph::i#2<(byte) 8) goto charsetFindOrAddGlyph::@3 -- vbuz1_lt_vbuc1_then_la1 + lda.z i + cmp #8 + bcc __b3 + // [208] phi from charsetFindOrAddGlyph::@2 to charsetFindOrAddGlyph::@5 [phi:charsetFindOrAddGlyph::@2->charsetFindOrAddGlyph::@5] + __b5_from___b2: + // [208] phi (byte) charsetFindOrAddGlyph::found#2 = (byte) 1 [phi:charsetFindOrAddGlyph::@2->charsetFindOrAddGlyph::@5#0] -- vbuz1=vbuc1 + lda #1 + sta.z found + jmp __b5 + // charsetFindOrAddGlyph::@3 + __b3: + // [207] if(*((byte*) charsetFindOrAddGlyph::glyph_cursor#11 + (byte) charsetFindOrAddGlyph::i#2)==*((byte*) charsetFindOrAddGlyph::glyph#10 + (byte) charsetFindOrAddGlyph::i#2)) goto charsetFindOrAddGlyph::@4 -- pbuz1_derefidx_vbuz2_eq_pbuz3_derefidx_vbuz2_then_la1 + ldy.z i + lda (glyph_cursor),y + cmp (glyph),y + beq __b4 + // [208] phi from charsetFindOrAddGlyph::@3 to charsetFindOrAddGlyph::@5 [phi:charsetFindOrAddGlyph::@3->charsetFindOrAddGlyph::@5] + __b5_from___b3: + // [208] phi (byte) charsetFindOrAddGlyph::found#2 = (byte) 0 [phi:charsetFindOrAddGlyph::@3->charsetFindOrAddGlyph::@5#0] -- vbuz1=vbuc1 + lda #0 + sta.z found + jmp __b5 + // charsetFindOrAddGlyph::@5 + __b5: + // [209] if((byte) 0==(byte) charsetFindOrAddGlyph::found#2) goto charsetFindOrAddGlyph::@6 -- vbuc1_eq_vbuz1_then_la1 + lda #0 + cmp.z found + beq __b6 + jmp __breturn_from___b5 + // charsetFindOrAddGlyph::@6 + __b6: + // [210] (byte) charsetFindOrAddGlyph::glyph_id#1 ← ++ (byte) charsetFindOrAddGlyph::glyph_id#11 -- vbuz1=_inc_vbuz1 + inc.z glyph_id + // [211] (byte*) charsetFindOrAddGlyph::glyph_cursor#1 ← (byte*) charsetFindOrAddGlyph::glyph_cursor#11 + (byte) 8 -- pbuz1=pbuz1_plus_vbuc1 + lda #8 + clc + adc.z glyph_cursor + sta.z glyph_cursor + bcc !+ + inc.z glyph_cursor+1 + !: + // [196] phi from charsetFindOrAddGlyph::@6 to charsetFindOrAddGlyph::@1 [phi:charsetFindOrAddGlyph::@6->charsetFindOrAddGlyph::@1] + __b1_from___b6: + // [196] phi (byte*) charsetFindOrAddGlyph::glyph_cursor#11 = (byte*) charsetFindOrAddGlyph::glyph_cursor#1 [phi:charsetFindOrAddGlyph::@6->charsetFindOrAddGlyph::@1#0] -- register_copy + // [196] phi (byte) charsetFindOrAddGlyph::glyph_id#11 = (byte) charsetFindOrAddGlyph::glyph_id#1 [phi:charsetFindOrAddGlyph::@6->charsetFindOrAddGlyph::@1#1] -- register_copy + jmp __b1 + // charsetFindOrAddGlyph::@4 + __b4: + // [212] (byte) charsetFindOrAddGlyph::i#1 ← ++ (byte) charsetFindOrAddGlyph::i#2 -- vbuz1=_inc_vbuz1 + inc.z i + // [205] phi from charsetFindOrAddGlyph::@4 to charsetFindOrAddGlyph::@2 [phi:charsetFindOrAddGlyph::@4->charsetFindOrAddGlyph::@2] + __b2_from___b4: + // [205] phi (byte) charsetFindOrAddGlyph::i#2 = (byte) charsetFindOrAddGlyph::i#1 [phi:charsetFindOrAddGlyph::@4->charsetFindOrAddGlyph::@2#0] -- register_copy + jmp __b2 +} + // protoBobShiftRight +// Shift PROTO_BOB right one X pixel +protoBobShiftRight: { + .label __1 = $79 + .label __5 = $7a + .label __6 = $7b + .label carry = $28 + .label j = $26 + .label i = $25 + .label carry_1 = $27 + // [214] phi from protoBobShiftRight to protoBobShiftRight::@1 [phi:protoBobShiftRight->protoBobShiftRight::@1] + __b1_from_protoBobShiftRight: + // [214] phi (byte) protoBobShiftRight::carry#2 = (byte) 0 [phi:protoBobShiftRight->protoBobShiftRight::@1#0] -- vbuz1=vbuc1 + lda #0 + sta.z carry_1 + // [214] phi (byte) protoBobShiftRight::j#3 = (byte) 0 [phi:protoBobShiftRight->protoBobShiftRight::@1#1] -- vbuz1=vbuc1 + lda #0 + sta.z j + // [214] phi (byte) protoBobShiftRight::i#2 = (byte) 0 [phi:protoBobShiftRight->protoBobShiftRight::@1#2] -- vbuz1=vbuc1 + lda #0 + sta.z i + jmp __b1 + // protoBobShiftRight::@1 + __b1: + // [215] if((byte) protoBobShiftRight::i#2<(byte)(number) 3*(number) 3*(number) 8) goto protoBobShiftRight::@2 -- vbuz1_lt_vbuc1_then_la1 + lda.z i + cmp #3*3*8 + bcc __b2 + jmp __breturn + // protoBobShiftRight::@return + __breturn: + // [216] return + rts + // protoBobShiftRight::@2 + __b2: + // [217] (byte~) protoBobShiftRight::$1 ← *((const byte*) PROTO_BOB + (byte) protoBobShiftRight::j#3) & (byte) 1 -- vbuz1=pbuc1_derefidx_vbuz2_band_vbuc2 + lda #1 + ldy.z j + and PROTO_BOB,y + sta.z __1 + // [218] if((byte) 0!=(byte~) protoBobShiftRight::$1) goto protoBobShiftRight::@3 -- vbuc1_neq_vbuz1_then_la1 + lda #0 + cmp.z __1 + bne __b3_from___b2 + // [220] phi from protoBobShiftRight::@2 to protoBobShiftRight::@4 [phi:protoBobShiftRight::@2->protoBobShiftRight::@4] + __b4_from___b2: + // [220] phi (byte) protoBobShiftRight::carry#1 = (byte) 0 [phi:protoBobShiftRight::@2->protoBobShiftRight::@4#0] -- vbuz1=vbuc1 + lda #0 + sta.z carry + jmp __b4 + // [219] phi from protoBobShiftRight::@2 to protoBobShiftRight::@3 [phi:protoBobShiftRight::@2->protoBobShiftRight::@3] + __b3_from___b2: + jmp __b3 + // protoBobShiftRight::@3 + __b3: + // [220] phi from protoBobShiftRight::@3 to protoBobShiftRight::@4 [phi:protoBobShiftRight::@3->protoBobShiftRight::@4] + __b4_from___b3: + // [220] phi (byte) protoBobShiftRight::carry#1 = (byte) $80 [phi:protoBobShiftRight::@3->protoBobShiftRight::@4#0] -- vbuz1=vbuc1 + lda #$80 + sta.z carry + jmp __b4 + // protoBobShiftRight::@4 + __b4: + // [221] (byte~) protoBobShiftRight::$5 ← *((const byte*) PROTO_BOB + (byte) protoBobShiftRight::j#3) >> (byte) 1 -- vbuz1=pbuc1_derefidx_vbuz2_ror_1 + ldy.z j + lda PROTO_BOB,y + lsr + sta.z __5 + // [222] (byte~) protoBobShiftRight::$6 ← (byte) protoBobShiftRight::carry#2 | (byte~) protoBobShiftRight::$5 -- vbuz1=vbuz2_bor_vbuz3 + lda.z carry_1 + ora.z __5 + sta.z __6 + // [223] *((const byte*) PROTO_BOB + (byte) protoBobShiftRight::j#3) ← (byte~) protoBobShiftRight::$6 -- pbuc1_derefidx_vbuz1=vbuz2 + // Shift value and add old carry + lda.z __6 + ldy.z j + sta PROTO_BOB,y + // [224] if((byte) protoBobShiftRight::j#3>=(byte) $30) goto protoBobShiftRight::@5 -- vbuz1_ge_vbuc1_then_la1 + // Increment j to iterate over the PROTO_BOB left-to-right, top-to-bottom (0, 24, 48, 1, 25, 49, ...) + lda.z j + cmp #$30 + bcs __b5 + jmp __b7 + // protoBobShiftRight::@7 + __b7: + // [225] (byte) protoBobShiftRight::j#2 ← (byte) protoBobShiftRight::j#3 + (byte) $18 -- vbuz1=vbuz1_plus_vbuc1 + lax.z j + axs #-[$18] + stx.z j + // [226] phi from protoBobShiftRight::@5 protoBobShiftRight::@7 to protoBobShiftRight::@6 [phi:protoBobShiftRight::@5/protoBobShiftRight::@7->protoBobShiftRight::@6] + __b6_from___b5: + __b6_from___b7: + // [226] phi (byte) protoBobShiftRight::j#10 = (byte) protoBobShiftRight::j#1 [phi:protoBobShiftRight::@5/protoBobShiftRight::@7->protoBobShiftRight::@6#0] -- register_copy + jmp __b6 + // protoBobShiftRight::@6 + __b6: + // [227] (byte) protoBobShiftRight::i#1 ← ++ (byte) protoBobShiftRight::i#2 -- vbuz1=_inc_vbuz1 + inc.z i + // [228] (byte) protoBobShiftRight::carry#10 ← (byte) protoBobShiftRight::carry#1 -- vbuz1=vbuz2 + lda.z carry + sta.z carry_1 + // [214] phi from protoBobShiftRight::@6 to protoBobShiftRight::@1 [phi:protoBobShiftRight::@6->protoBobShiftRight::@1] + __b1_from___b6: + // [214] phi (byte) protoBobShiftRight::carry#2 = (byte) protoBobShiftRight::carry#10 [phi:protoBobShiftRight::@6->protoBobShiftRight::@1#0] -- register_copy + // [214] phi (byte) protoBobShiftRight::j#3 = (byte) protoBobShiftRight::j#10 [phi:protoBobShiftRight::@6->protoBobShiftRight::@1#1] -- register_copy + // [214] phi (byte) protoBobShiftRight::i#2 = (byte) protoBobShiftRight::i#1 [phi:protoBobShiftRight::@6->protoBobShiftRight::@1#2] -- register_copy + jmp __b1 + // protoBobShiftRight::@5 + __b5: + // [229] (byte) protoBobShiftRight::j#1 ← (byte) protoBobShiftRight::j#3 - (byte) $2f -- vbuz1=vbuz1_minus_vbuc1 + lax.z j + axs #$2f + stx.z j + jmp __b6_from___b5 +} + // protoBobShiftDown +// Shift PROTO_BOB down one Y pixel +// At the same time restore PROTO_BOB X by shifting 8 pixels left +protoBobShiftDown: { + .label i = $29 + // [231] phi from protoBobShiftDown to protoBobShiftDown::@1 [phi:protoBobShiftDown->protoBobShiftDown::@1] + __b1_from_protoBobShiftDown: + // [231] phi (byte) protoBobShiftDown::i#2 = (byte) $17 [phi:protoBobShiftDown->protoBobShiftDown::@1#0] -- vbuz1=vbuc1 + lda #$17 + sta.z i + jmp __b1 + // protoBobShiftDown::@1 + __b1: + // [232] if((byte) protoBobShiftDown::i#2>(byte) 0) goto protoBobShiftDown::@2 -- vbuz1_gt_0_then_la1 + lda.z i + bne __b2 + jmp __b3 + // protoBobShiftDown::@3 + __b3: + // [233] *((const byte*) PROTO_BOB) ← (byte) 0 -- _deref_pbuc1=vbuc2 + lda #0 + sta PROTO_BOB + // [234] *((const byte*) PROTO_BOB+(byte) $18) ← (byte) 0 -- _deref_pbuc1=vbuc2 + lda #0 + sta PROTO_BOB+$18 + // [235] *((const byte*) PROTO_BOB+(byte) $30) ← (byte) 0 -- _deref_pbuc1=vbuc2 + lda #0 + sta PROTO_BOB+$30 + jmp __breturn + // protoBobShiftDown::@return + __breturn: + // [236] return + rts + // protoBobShiftDown::@2 + __b2: + // [237] *((const byte*) PROTO_BOB + (byte) protoBobShiftDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $17 + (byte) protoBobShiftDown::i#2) -- pbuc1_derefidx_vbuz1=pbuc2_derefidx_vbuz1 + ldy.z i + lda PROTO_BOB+$17,y + sta PROTO_BOB,y + // [238] *((const byte*) PROTO_BOB+(byte) $18 + (byte) protoBobShiftDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $2f + (byte) protoBobShiftDown::i#2) -- pbuc1_derefidx_vbuz1=pbuc2_derefidx_vbuz1 + ldy.z i + lda PROTO_BOB+$2f,y + sta PROTO_BOB+$18,y + // [239] *((const byte*) PROTO_BOB+(byte) $30 + (byte) protoBobShiftDown::i#2) ← (byte) 0 -- pbuc1_derefidx_vbuz1=vbuc2 + lda #0 + ldy.z i + sta PROTO_BOB+$30,y + // [240] (byte) protoBobShiftDown::i#1 ← -- (byte) protoBobShiftDown::i#2 -- vbuz1=_dec_vbuz1 + dec.z i + // [231] phi from protoBobShiftDown::@2 to protoBobShiftDown::@1 [phi:protoBobShiftDown::@2->protoBobShiftDown::@1] + __b1_from___b2: + // [231] phi (byte) protoBobShiftDown::i#2 = (byte) protoBobShiftDown::i#1 [phi:protoBobShiftDown::@2->protoBobShiftDown::@1#0] -- register_copy + jmp __b1 +} + // progress_init +// Initialize the PETSCII progress bar +progress_init: { + jmp __breturn + // progress_init::@return + __breturn: + // [242] return + rts +} + // mulf_init +// Initialize the mulf_sqr multiplication tables with f(x)=int(x*x/4) +mulf_init: { + .label __1 = $7c + .label __4 = $7d + .label __5 = $7e + // x/2 + .label c = $2c + // Counter used for determining x%2==0 + .label sqr1_hi = $2d + // Fill mulf_sqr1 = f(x) = int(x*x/4): If f(x) = x*x/4 then f(x+1) = f(x) + x/2 + 1/4 + .label sqr = $36 + .label sqr1_lo = $2a + // sqr = (x*x)/4 + .label x_2 = $2f + // Decrease or increase x_255 - initially we decrease + .label sqr2_hi = $33 + // Fill mulf_sqr2 = g(x) = f(x-255) : If x-255<0 then g(x)=f(255-x) (because x*x = -x*-x) + // g(0) = f(255), g(1) = f(254), ..., g(254) = f(1), g(255) = f(0), g(256) = f(1), ..., g(510) = f(255), g(511) = f(256) + .label x_255 = $32 + .label sqr2_lo = $30 + //Start with g(0)=f(255) + .label dir = $35 + // [244] phi from mulf_init to mulf_init::@1 [phi:mulf_init->mulf_init::@1] + __b1_from_mulf_init: + // [244] phi (byte) mulf_init::x_2#3 = (byte) 0 [phi:mulf_init->mulf_init::@1#0] -- vbuz1=vbuc1 + lda #0 + sta.z x_2 + // [244] phi (byte*) mulf_init::sqr1_hi#2 = (const byte*) mulf_sqr1_hi+(byte) 1 [phi:mulf_init->mulf_init::@1#1] -- pbuz1=pbuc1 + lda #mulf_sqr1_hi+1 + sta.z sqr1_hi+1 + // [244] phi (word) mulf_init::sqr#4 = (byte) 0 [phi:mulf_init->mulf_init::@1#2] -- vwuz1=vbuc1 + lda #<0 + sta.z sqr + lda #>0 + sta.z sqr+1 + // [244] phi (byte) mulf_init::c#2 = (byte) 0 [phi:mulf_init->mulf_init::@1#3] -- vbuz1=vbuc1 + lda #0 + sta.z c + // [244] phi (byte*) mulf_init::sqr1_lo#2 = (const byte*) mulf_sqr1_lo+(byte) 1 [phi:mulf_init->mulf_init::@1#4] -- pbuz1=pbuc1 + lda #mulf_sqr1_lo+1 + sta.z sqr1_lo+1 + jmp __b1 + // mulf_init::@1 + __b1: + // [245] if((byte*) mulf_init::sqr1_lo#2!=(const byte*) mulf_sqr1_lo+(word) $200) goto mulf_init::@2 -- pbuz1_neq_pbuc1_then_la1 + lda.z sqr1_lo+1 + cmp #>mulf_sqr1_lo+$200 + bne __b2 + lda.z sqr1_lo + cmp #mulf_init::@5] + __b5_from___b1: + // [246] phi (byte) mulf_init::dir#2 = (byte) $ff [phi:mulf_init::@1->mulf_init::@5#0] -- vbuz1=vbuc1 + lda #$ff + sta.z dir + // [246] phi (byte*) mulf_init::sqr2_hi#2 = (const byte*) mulf_sqr2_hi [phi:mulf_init::@1->mulf_init::@5#1] -- pbuz1=pbuc1 + lda #mulf_sqr2_hi + sta.z sqr2_hi+1 + // [246] phi (byte) mulf_init::x_255#2 = (byte) -1 [phi:mulf_init::@1->mulf_init::@5#2] -- vbuz1=vbuc1 + lda #-1 + sta.z x_255 + // [246] phi (byte*) mulf_init::sqr2_lo#2 = (const byte*) mulf_sqr2_lo [phi:mulf_init::@1->mulf_init::@5#3] -- pbuz1=pbuc1 + lda #mulf_sqr2_lo + sta.z sqr2_lo+1 + jmp __b5 + // mulf_init::@5 + __b5: + // [247] if((byte*) mulf_init::sqr2_lo#2!=(const byte*) mulf_sqr2_lo+(word) $1ff) goto mulf_init::@6 -- pbuz1_neq_pbuc1_then_la1 + lda.z sqr2_lo+1 + cmp #>mulf_sqr2_lo+$1ff + bne __b6 + lda.z sqr2_lo + cmp #mulf_init::@8] + __b8_from___b6: + // [257] phi (byte) mulf_init::dir#4 = (byte) 1 [phi:mulf_init::@6->mulf_init::@8#0] -- vbuz1=vbuc1 + lda #1 + sta.z dir + jmp __b8 + // [256] phi from mulf_init::@6 to mulf_init::@9 [phi:mulf_init::@6->mulf_init::@9] + __b9_from___b6: + jmp __b9 + // mulf_init::@9 + __b9: + // [257] phi from mulf_init::@9 to mulf_init::@8 [phi:mulf_init::@9->mulf_init::@8] + __b8_from___b9: + // [257] phi (byte) mulf_init::dir#4 = (byte) mulf_init::dir#2 [phi:mulf_init::@9->mulf_init::@8#0] -- register_copy + jmp __b8 + // mulf_init::@8 + __b8: + // [258] (byte*) mulf_init::sqr2_lo#1 ← ++ (byte*) mulf_init::sqr2_lo#2 -- pbuz1=_inc_pbuz1 + inc.z sqr2_lo + bne !+ + inc.z sqr2_lo+1 + !: + // [246] phi from mulf_init::@8 to mulf_init::@5 [phi:mulf_init::@8->mulf_init::@5] + __b5_from___b8: + // [246] phi (byte) mulf_init::dir#2 = (byte) mulf_init::dir#4 [phi:mulf_init::@8->mulf_init::@5#0] -- register_copy + // [246] phi (byte*) mulf_init::sqr2_hi#2 = (byte*) mulf_init::sqr2_hi#1 [phi:mulf_init::@8->mulf_init::@5#1] -- register_copy + // [246] phi (byte) mulf_init::x_255#2 = (byte) mulf_init::x_255#1 [phi:mulf_init::@8->mulf_init::@5#2] -- register_copy + // [246] phi (byte*) mulf_init::sqr2_lo#2 = (byte*) mulf_init::sqr2_lo#1 [phi:mulf_init::@8->mulf_init::@5#3] -- register_copy + jmp __b5 + // mulf_init::@2 + __b2: + // [259] (byte) mulf_init::c#1 ← ++ (byte) mulf_init::c#2 -- vbuz1=_inc_vbuz1 + inc.z c + // [260] (byte~) mulf_init::$1 ← (byte) mulf_init::c#1 & (byte) 1 -- vbuz1=vbuz2_band_vbuc1 + lda #1 + and.z c + sta.z __1 + // [261] if((byte~) mulf_init::$1!=(byte) 0) goto mulf_init::@3 -- vbuz1_neq_0_then_la1 + lda.z __1 + cmp #0 + bne __b3_from___b2 + jmp __b4 + // mulf_init::@4 + __b4: + // [262] (byte) mulf_init::x_2#1 ← ++ (byte) mulf_init::x_2#3 -- vbuz1=_inc_vbuz1 + inc.z x_2 + // [263] (word) mulf_init::sqr#2 ← ++ (word) mulf_init::sqr#4 -- vwuz1=_inc_vwuz1 + inc.z sqr + bne !+ + inc.z sqr+1 + !: + // [264] phi from mulf_init::@2 mulf_init::@4 to mulf_init::@3 [phi:mulf_init::@2/mulf_init::@4->mulf_init::@3] + __b3_from___b2: + __b3_from___b4: + // [264] phi (byte) mulf_init::x_2#2 = (byte) mulf_init::x_2#3 [phi:mulf_init::@2/mulf_init::@4->mulf_init::@3#0] -- register_copy + // [264] phi (word) mulf_init::sqr#3 = (word) mulf_init::sqr#4 [phi:mulf_init::@2/mulf_init::@4->mulf_init::@3#1] -- register_copy + jmp __b3 + // mulf_init::@3 + __b3: + // [265] (byte~) mulf_init::$4 ← < (word) mulf_init::sqr#3 -- vbuz1=_lo_vwuz2 + lda.z sqr + sta.z __4 + // [266] *((byte*) mulf_init::sqr1_lo#2) ← (byte~) mulf_init::$4 -- _deref_pbuz1=vbuz2 + lda.z __4 + ldy #0 + sta (sqr1_lo),y + // [267] (byte~) mulf_init::$5 ← > (word) mulf_init::sqr#3 -- vbuz1=_hi_vwuz2 + lda.z sqr+1 + sta.z __5 + // [268] *((byte*) mulf_init::sqr1_hi#2) ← (byte~) mulf_init::$5 -- _deref_pbuz1=vbuz2 + lda.z __5 + ldy #0 + sta (sqr1_hi),y + // [269] (byte*) mulf_init::sqr1_hi#1 ← ++ (byte*) mulf_init::sqr1_hi#2 -- pbuz1=_inc_pbuz1 + inc.z sqr1_hi + bne !+ + inc.z sqr1_hi+1 + !: + // [270] (word) mulf_init::sqr#1 ← (word) mulf_init::sqr#3 + (byte) mulf_init::x_2#2 -- vwuz1=vwuz1_plus_vbuz2 + lda.z x_2 + clc + adc.z sqr + sta.z sqr + bcc !+ + inc.z sqr+1 + !: + // [271] (byte*) mulf_init::sqr1_lo#1 ← ++ (byte*) mulf_init::sqr1_lo#2 -- pbuz1=_inc_pbuz1 + inc.z sqr1_lo + bne !+ + inc.z sqr1_lo+1 + !: + // [244] phi from mulf_init::@3 to mulf_init::@1 [phi:mulf_init::@3->mulf_init::@1] + __b1_from___b3: + // [244] phi (byte) mulf_init::x_2#3 = (byte) mulf_init::x_2#2 [phi:mulf_init::@3->mulf_init::@1#0] -- register_copy + // [244] phi (byte*) mulf_init::sqr1_hi#2 = (byte*) mulf_init::sqr1_hi#1 [phi:mulf_init::@3->mulf_init::@1#1] -- register_copy + // [244] phi (word) mulf_init::sqr#4 = (word) mulf_init::sqr#1 [phi:mulf_init::@3->mulf_init::@1#2] -- register_copy + // [244] phi (byte) mulf_init::c#2 = (byte) mulf_init::c#1 [phi:mulf_init::@3->mulf_init::@1#3] -- register_copy + // [244] phi (byte*) mulf_init::sqr1_lo#2 = (byte*) mulf_init::sqr1_lo#1 [phi:mulf_init::@3->mulf_init::@1#4] -- register_copy + jmp __b1 +} + // File Data + // Keyboard row bitmask as expected by CIA#1 Port A when reading a specific keyboard matrix row (rows are numbered 0-7) + keyboard_matrix_row_bitmask: .byte $fe, $fd, $fb, $f7, $ef, $df, $bf, $7f + // Keyboard matrix column bitmasks for a specific keybooard matrix column when reading the keyboard. (columns are numbered 0-7) + keyboard_matrix_col_bitmask: .byte 1, 2, 4, 8, $10, $20, $40, $80 + // mulf_sqr tables will contain f(x)=int(x*x/4) and g(x) = f(x-255). + // f(x) = >(( x * x )/4) + .align $100 + mulf_sqr1_hi: .fill $200, 0 + // g(x) = >((( x - 255) * ( x - 255 ))/4) + .align $100 + mulf_sqr2_hi: .fill $200, 0 + // The prototype BOB (a 3x3 char image with a bob image in the upper 2x2 chars) + // The chars are layout as follows with data in chars 0, 1, 3, 4 initially + // 0 3 6 + // 1 4 7 + // 2 5 8 +PROTO_BOB: +.var pic = LoadPicture("smiley.png", List().add($000000, $ffffff)) + .for (var x=0;x<3; x++) + .for (var y=0; y<24; y++) + .byte pic.getSinglecolorByte(x,y) + + // Sine and Cosine tables + // Angles: $00=0, $80=PI,$100=2*PI + // Sine/Cosine: signed fixed [-$7f,$7f] + .align $40 +SIN: +.for(var i=0;i<$140;i++) + .byte >round($7fff*sin(i*2*PI/256)) + + // Tables containing the char to use for a specific cell of a shifted BOB. + // char_id = BOB_TABLES[cell*BOB_SUBTABLE_SIZE + shift_y*BOB_SHIFTS_X + shift_x]; + BOB_TABLES: .fill 9*8*4, 0 + // Table used for deleting rendered BOB's. Contains pointers to first char of each BOB. + RENDERBOB_CLEANUP: .fill 2*NUM_BOBS, 0 + // *40 Table unsigned int[0x20] MUL40 = { ((unsigned int)i)*40 }; + MUL40: .fill 2*$20, 0 + +REGISTER UPLIFT POTENTIAL REGISTERS +Statement [10] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [12] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank1_toDd001_return#0 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [14] *((const byte*) D018) ← (const byte) main::toD0181_return#0 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [17] if(*((const byte*) RASTER)<(byte) $f8) goto main::@2 [ main::angle#8 ] ( main:2 [ main::angle#8 ] ) always clobbers reg byte a +Removing always clobbered register reg byte a as potential for zp[1]:2 [ main::angle#8 main::angle#1 ] +Statement [18] *((const byte*) BORDERCOL) ← (byte) $f [ main::angle#8 ] ( main:2 [ main::angle#8 ] ) always clobbers reg byte a +Statement [22] *((const byte*) BORDERCOL) ← (byte) 1 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 ] ) always clobbers reg byte a +Removing always clobbered register reg byte a as potential for zp[1]:3 [ main::r#2 main::r#1 ] +Removing always clobbered register reg byte a as potential for zp[1]:4 [ main::a#2 main::a#6 main::a#1 ] +Removing always clobbered register reg byte a as potential for zp[1]:7 [ main::i#2 main::i#1 ] +Statement [26] (signed word) mulf8s::return#2 ← (signed word) mulf8s::return#0 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::return#2 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::return#2 ] ) always clobbers reg byte a +Statement [27] (signed word~) main::$10 ← (signed word) mulf8s::return#2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::$10 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::$10 ] ) always clobbers reg byte a +Statement [28] (signed word) main::x#0 ← (signed word~) main::$10 + (signed word)(number) $4b*(number) $100 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 ] ) always clobbers reg byte a +Statement [32] (signed word) mulf8s::return#3 ← (signed word) mulf8s::return#0 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::return#3 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::return#3 ] ) always clobbers reg byte a +Statement [33] (signed word~) main::$12 ← (signed word) mulf8s::return#3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$12 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$12 ] ) always clobbers reg byte a +Statement [34] (signed word~) main::$13 ← (signed word~) main::$12 << (byte) 1 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$13 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$13 ] ) always clobbers reg byte a +Statement [35] (signed word) main::y#0 ← (signed word~) main::$13 + (signed word)(number) $5a*(number) $100 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ) always clobbers reg byte a +Statement [36] *((const byte*) BORDERCOL) ← (byte) 2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ) always clobbers reg byte a +Statement [37] (byte) main::a#1 ← (byte) main::a#2 + (byte) $62 [ main::angle#8 main::r#2 renderBobCleanupNext#17 main::i#2 main::a#1 main::x#0 main::y#0 ] ( main:2 [ main::angle#8 main::r#2 renderBobCleanupNext#17 main::i#2 main::a#1 main::x#0 main::y#0 ] ) always clobbers reg byte a +Statement [38] (signed byte) main::r#1 ← (signed byte) main::r#2 + (signed byte) 3 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::x#0 main::y#0 ] ( main:2 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::x#0 main::y#0 ] ) always clobbers reg byte a +Statement [39] (byte) renderBob::xpos#0 ← > (signed word) main::x#0 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::y#0 renderBob::xpos#0 ] ( main:2 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::y#0 renderBob::xpos#0 ] ) always clobbers reg byte a +Statement [40] (byte) renderBob::ypos#0 ← > (signed word) main::y#0 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 renderBob::xpos#0 renderBob::ypos#0 ] ( main:2 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 renderBob::xpos#0 renderBob::ypos#0 ] ) always clobbers reg byte a +Removing always clobbered register reg byte a as potential for zp[1]:70 [ renderBob::xpos#0 ] +Statement [44] (byte) main::angle#1 ← (byte) main::angle#8 + (byte) 3 [ main::angle#1 ] ( main:2 [ main::angle#1 ] ) always clobbers reg byte a +Statement [45] *((const byte*) BORDERCOL) ← (byte) 0 [ main::angle#1 ] ( main:2 [ main::angle#1 ] ) always clobbers reg byte a +Statement [55] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [57] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank2_toDd001_return#0 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [59] *((const byte*) D018) ← (const byte) main::toD0182_return#0 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [67] *((const byte*) CIA1_PORT_A) ← *((const byte*) keyboard_matrix_row_bitmask+(const byte) keyboard_key_pressed::rowidx#0) [ ] ( main:2::keyboard_key_pressed:46::keyboard_matrix_read:62 [ main::angle#1 ] main:2::keyboard_key_pressed:51::keyboard_matrix_read:62 [ ] ) always clobbers reg byte a +Statement [68] (byte) keyboard_matrix_read::return#0 ← ~ *((const byte*) CIA1_PORT_B) [ keyboard_matrix_read::return#0 ] ( main:2::keyboard_key_pressed:46::keyboard_matrix_read:62 [ main::angle#1 keyboard_matrix_read::return#0 ] main:2::keyboard_key_pressed:51::keyboard_matrix_read:62 [ keyboard_matrix_read::return#0 ] ) always clobbers reg byte a +Statement [70] (byte) renderBob::x_char_offset#0 ← (byte) renderBob::xpos#0 >> (byte) 2 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 ] ) always clobbers reg byte a +Removing always clobbered register reg byte a as potential for zp[1]:71 [ renderBob::ypos#0 ] +Statement [71] (byte) renderBob::y_char_offset#0 ← (byte) renderBob::ypos#0 >> (byte) 3 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_char_offset#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_char_offset#0 ] ) always clobbers reg byte a +Removing always clobbered register reg byte a as potential for zp[1]:80 [ renderBob::x_char_offset#0 ] +Statement [72] (byte~) renderBob::$8 ← (byte) renderBob::y_char_offset#0 << (byte) 1 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$8 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$8 ] ) always clobbers reg byte a +Statement [73] (word) renderBob::y_offset#0 ← *((const word*) MUL40 + (byte~) renderBob::$8) [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_offset#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_offset#0 ] ) always clobbers reg byte a +Statement [74] (byte*~) renderBob::$2 ← (const byte*) BOB_SCREEN + (word) renderBob::y_offset#0 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$2 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$2 ] ) always clobbers reg byte a +Statement [75] (byte*) renderBob::screen#0 ← (byte*~) renderBob::$2 + (byte) renderBob::x_char_offset#0 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::screen#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::screen#0 ] ) always clobbers reg byte a +Statement [76] (byte~) renderBob::$4 ← (byte) renderBob::ypos#0 & (byte) 7 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$4 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$4 ] ) always clobbers reg byte a +Statement [77] (byte~) renderBob::$5 ← (byte~) renderBob::$4 << (byte) 2 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$5 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$5 ] ) always clobbers reg byte a +Statement [78] (byte~) renderBob::$6 ← (byte) renderBob::xpos#0 & (byte) 3 [ renderBobCleanupNext#17 renderBob::screen#0 renderBob::$5 renderBob::$6 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::screen#0 renderBob::$5 renderBob::$6 ] ) always clobbers reg byte a +Removing always clobbered register reg byte a as potential for zp[1]:90 [ renderBob::$5 ] +Statement [79] (byte) renderBob::bob_table_idx#0 ← (byte~) renderBob::$5 + (byte~) renderBob::$6 [ renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a +Statement [80] *((byte**) renderBobCleanupNext#17) ← (byte*) renderBob::screen#0 [ renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Removing always clobbered register reg byte y as potential for zp[1]:2 [ main::angle#8 main::angle#1 ] +Removing always clobbered register reg byte y as potential for zp[1]:7 [ main::i#2 main::i#1 ] +Removing always clobbered register reg byte y as potential for zp[1]:3 [ main::r#2 main::r#1 ] +Removing always clobbered register reg byte y as potential for zp[1]:4 [ main::a#2 main::a#6 main::a#1 ] +Removing always clobbered register reg byte a as potential for zp[1]:92 [ renderBob::bob_table_idx#0 ] +Removing always clobbered register reg byte y as potential for zp[1]:92 [ renderBob::bob_table_idx#0 ] +Statement [81] (byte**) renderBobCleanupNext#13 ← (byte**) renderBobCleanupNext#17 + (const byte) SIZEOF_POINTER [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a +Statement [82] *((byte*) renderBob::screen#0) ← *((const byte*) BOB_TABLES + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [83] *((byte*) renderBob::screen#0 + (byte) $28) ← *((const byte*) BOB_TABLES+(byte) 1*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [84] *((byte*) renderBob::screen#0 + (byte) $50) ← *((const byte*) BOB_TABLES+(byte) 2*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [85] *((byte*) renderBob::screen#0 + (byte) 1) ← *((const byte*) BOB_TABLES+(byte) 3*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [86] *((byte*) renderBob::screen#0 + (byte) $29) ← *((const byte*) BOB_TABLES+(byte) 4*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [87] *((byte*) renderBob::screen#0 + (byte) $51) ← *((const byte*) BOB_TABLES+(byte) 5*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [88] *((byte*) renderBob::screen#0 + (byte) 2) ← *((const byte*) BOB_TABLES+(byte) 6*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [89] *((byte*) renderBob::screen#0 + (byte) $2a) ← *((const byte*) BOB_TABLES+(byte) 7*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [90] *((byte*) renderBob::screen#0 + (byte) $52) ← *((const byte*) BOB_TABLES+(byte) 8*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 ] ) always clobbers reg byte a reg byte y +Statement [97] (signed word) mulf8s::return#0 ← (signed word)(word) mulf8s_prepared::m#4 [ mulf8s::return#0 ] ( main:2::mulf8s:25 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::return#0 ] main:2::mulf8s:31 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::return#0 ] ) always clobbers reg byte a +Statement [101] (word) mulf8u_prepared::return#2 ← (word) mulf8u_prepared::return#0 [ mulf8s_prepared::b#0 mulf8u_prepared::return#2 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8u_prepared::return#2 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8u_prepared::return#2 ] ) always clobbers reg byte a +Removing always clobbered register reg byte a as potential for zp[1]:94 [ mulf8s_prepared::b#0 ] +Statement [102] (word) mulf8s_prepared::m#0 ← (word) mulf8u_prepared::return#2 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ) always clobbers reg byte a +Statement [103] if(*((const signed byte*) mulf8s_prepared::memA)>=(signed byte) 0) goto mulf8s_prepared::@1 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ) always clobbers reg byte a +Statement [104] (byte~) mulf8s_prepared::$8 ← > (word) mulf8s_prepared::m#0 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$8 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$8 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$8 ] ) always clobbers reg byte a +Statement [105] (byte~) mulf8s_prepared::$15 ← (byte~) mulf8s_prepared::$8 - (byte)(signed byte) mulf8s_prepared::b#0 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$15 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$15 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$15 ] ) always clobbers reg byte a +Statement [109] (byte~) mulf8s_prepared::$12 ← > (word) mulf8s_prepared::m#5 [ mulf8s_prepared::m#5 mulf8s_prepared::$12 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::m#5 mulf8s_prepared::$12 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::m#5 mulf8s_prepared::$12 ] ) always clobbers reg byte a +Statement [110] (byte~) mulf8s_prepared::$16 ← (byte~) mulf8s_prepared::$12 - (byte)*((const signed byte*) mulf8s_prepared::memA) [ mulf8s_prepared::m#5 mulf8s_prepared::$16 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::m#5 mulf8s_prepared::$16 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::m#5 mulf8s_prepared::$16 ] ) always clobbers reg byte a +Statement asm { ldxmemB sec sm1: ldamulf_sqr1_lo,x sm2: sbcmulf_sqr2_lo,x staresL sm3: ldamulf_sqr1_hi,x sm4: sbcmulf_sqr2_hi,x stamemB } always clobbers reg byte a reg byte x +Removing always clobbered register reg byte x as potential for zp[1]:2 [ main::angle#8 main::angle#1 ] +Removing always clobbered register reg byte x as potential for zp[1]:3 [ main::r#2 main::r#1 ] +Removing always clobbered register reg byte x as potential for zp[1]:4 [ main::a#2 main::a#6 main::a#1 ] +Removing always clobbered register reg byte x as potential for zp[1]:7 [ main::i#2 main::i#1 ] +Removing always clobbered register reg byte x as potential for zp[1]:94 [ mulf8s_prepared::b#0 ] +Statement [116] (word) mulf8u_prepared::return#0 ← *((const byte*) mulf8u_prepared::memB) w= *((const byte*) mulf8u_prepared::resL) [ mulf8u_prepared::return#0 ] ( main:2::mulf8s:25::mulf8s_prepared:96::mulf8u_prepared:100 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8u_prepared::return#0 ] main:2::mulf8s:31::mulf8s_prepared:96::mulf8u_prepared:100 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8u_prepared::return#0 ] ) always clobbers reg byte a +Statement asm { ldamemA stamulf8u_prepared.sm1+1 stamulf8u_prepared.sm3+1 eor#$ff stamulf8u_prepared.sm2+1 stamulf8u_prepared.sm4+1 } always clobbers reg byte a +Removing always clobbered register reg byte a as potential for zp[1]:9 [ mulf8s::b#2 mulf8s::b#1 mulf8s::b#0 ] +Statement [123] (byte~) renderBobCleanup::$1 ← (byte) renderBobCleanup::i#2 << (byte) 1 [ renderBobCleanup::i#2 renderBobCleanup::$1 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::$1 ] ) always clobbers reg byte a +Removing always clobbered register reg byte a as potential for zp[1]:12 [ renderBobCleanup::i#2 renderBobCleanup::i#1 ] +Statement [124] (byte*) renderBobCleanup::screen#0 ← *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobCleanup::$1) [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a +Statement [125] *((byte*) renderBobCleanup::screen#0) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Removing always clobbered register reg byte y as potential for zp[1]:12 [ renderBobCleanup::i#2 renderBobCleanup::i#1 ] +Statement [126] *((byte*) renderBobCleanup::screen#0 + (byte) $28) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [127] *((byte*) renderBobCleanup::screen#0 + (byte) $50) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [128] *((byte*) renderBobCleanup::screen#0 + (byte) 1) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [129] *((byte*) renderBobCleanup::screen#0 + (byte) $29) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [130] *((byte*) renderBobCleanup::screen#0 + (byte) $51) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [131] *((byte*) renderBobCleanup::screen#0 + (byte) 2) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [132] *((byte*) renderBobCleanup::screen#0 + (byte) $2a) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [133] *((byte*) renderBobCleanup::screen#0 + (byte) $52) ← (byte) 0 [ renderBobCleanup::i#2 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 ] ) always clobbers reg byte a reg byte y +Statement [139] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 [ memset::dst#2 ] ( main:2::memset:15 [ memset::dst#2 ] ) always clobbers reg byte a +Statement [141] *((byte*) memset::dst#2) ← (const byte) memset::c#0 [ memset::dst#2 ] ( main:2::memset:15 [ memset::dst#2 ] ) always clobbers reg byte a reg byte y +Statement [145] (word~) renderBobInit::$0 ← (word)(byte) renderBobInit::y#2 [ renderBobInit::y#2 renderBobInit::$0 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 renderBobInit::$0 ] ) always clobbers reg byte a +Removing always clobbered register reg byte a as potential for zp[1]:15 [ renderBobInit::y#2 renderBobInit::y#1 ] +Statement [146] (word~) renderBobInit::$6 ← (word~) renderBobInit::$0 << (byte) 2 [ renderBobInit::y#2 renderBobInit::$0 renderBobInit::$6 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 renderBobInit::$0 renderBobInit::$6 ] ) always clobbers reg byte a +Statement [147] (word~) renderBobInit::$7 ← (word~) renderBobInit::$6 + (word~) renderBobInit::$0 [ renderBobInit::y#2 renderBobInit::$7 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 renderBobInit::$7 ] ) always clobbers reg byte a +Statement [148] (word~) renderBobInit::$1 ← (word~) renderBobInit::$7 << (byte) 3 [ renderBobInit::y#2 renderBobInit::$1 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 renderBobInit::$1 ] ) always clobbers reg byte a +Statement [149] (byte~) renderBobInit::$4 ← (byte) renderBobInit::y#2 << (byte) 1 [ renderBobInit::y#2 renderBobInit::$1 renderBobInit::$4 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 renderBobInit::$1 renderBobInit::$4 ] ) always clobbers reg byte a +Statement [150] *((const word*) MUL40 + (byte~) renderBobInit::$4) ← (word~) renderBobInit::$1 [ renderBobInit::y#2 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 ] ) always clobbers reg byte a +Statement [154] (byte~) renderBobInit::$5 ← (byte) renderBobInit::i#2 << (byte) 1 [ renderBobInit::i#2 renderBobInit::$5 ] ( main:2::renderBobInit:9 [ renderBobInit::i#2 renderBobInit::$5 ] ) always clobbers reg byte a +Removing always clobbered register reg byte a as potential for zp[1]:16 [ renderBobInit::i#2 renderBobInit::i#1 ] +Statement [155] *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobInit::$5) ← (const byte*) BOB_SCREEN [ renderBobInit::i#2 ] ( main:2::renderBobInit:9 [ renderBobInit::i#2 ] ) always clobbers reg byte a +Statement [171] (byte*) prepareBobs::bob_table#0 ← (const byte*) BOB_TABLES + (byte) prepareBobs::bob_table_idx#12 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::bob_table#0 ] ( main:2::prepareBobs:7 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::bob_table#0 ] ) always clobbers reg byte a +Removing always clobbered register reg byte a as potential for zp[1]:17 [ prepareBobs::shift_y#2 prepareBobs::shift_y#1 ] +Removing always clobbered register reg byte a as potential for zp[1]:20 [ progress_idx#16 progress_idx#31 progress_idx#25 progress_idx#10 progress_idx#8 ] +Removing always clobbered register reg byte a as potential for zp[1]:28 [ bob_charset_next_id#23 bob_charset_next_id#14 bob_charset_next_id#16 bob_charset_next_id#30 bob_charset_next_id#21 bob_charset_next_id#8 ] +Removing always clobbered register reg byte a as potential for zp[1]:21 [ prepareBobs::bob_table_idx#6 prepareBobs::bob_table_idx#12 prepareBobs::bob_table_idx#1 ] +Removing always clobbered register reg byte a as potential for zp[1]:22 [ prepareBobs::shift_x#2 prepareBobs::shift_x#1 ] +Statement [179] (byte*) charsetFindOrAddGlyph::glyph#1 ← (byte*) prepareBobs::bob_glyph#2 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 charsetFindOrAddGlyph::glyph#1 ] ( main:2::prepareBobs:7 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 charsetFindOrAddGlyph::glyph#1 ] ) always clobbers reg byte a +Removing always clobbered register reg byte a as potential for zp[1]:23 [ prepareBobs::cell#2 prepareBobs::cell#1 ] +Statement [183] *((byte*) prepareBobs::bob_table#2) ← (byte~) prepareBobs::$6 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 ] ( main:2::prepareBobs:7 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 ] ) always clobbers reg byte y +Removing always clobbered register reg byte y as potential for zp[1]:17 [ prepareBobs::shift_y#2 prepareBobs::shift_y#1 ] +Removing always clobbered register reg byte y as potential for zp[1]:28 [ bob_charset_next_id#23 bob_charset_next_id#14 bob_charset_next_id#16 bob_charset_next_id#30 bob_charset_next_id#21 bob_charset_next_id#8 ] +Removing always clobbered register reg byte y as potential for zp[1]:21 [ prepareBobs::bob_table_idx#6 prepareBobs::bob_table_idx#12 prepareBobs::bob_table_idx#1 ] +Removing always clobbered register reg byte y as potential for zp[1]:22 [ prepareBobs::shift_x#2 prepareBobs::shift_x#1 ] +Removing always clobbered register reg byte y as potential for zp[1]:20 [ progress_idx#16 progress_idx#31 progress_idx#25 progress_idx#10 progress_idx#8 ] +Removing always clobbered register reg byte y as potential for zp[1]:23 [ prepareBobs::cell#2 prepareBobs::cell#1 ] +Statement [184] (byte*) prepareBobs::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 + (byte) 8 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_table#2 prepareBobs::bob_glyph#1 ] ( main:2::prepareBobs:7 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_table#2 prepareBobs::bob_glyph#1 ] ) always clobbers reg byte a +Statement [185] (byte*) prepareBobs::bob_table#1 ← (byte*) prepareBobs::bob_table#2 + (const byte) BOB_SHIFTS_X*(const byte) BOB_SHIFTS_Y [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 ] ( main:2::prepareBobs:7 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 ] ) always clobbers reg byte a +Statement [190] *((byte*) progress_cursor#24) ← *((const byte*) progress_inc::progress_chars+(byte) 8) [ progress_cursor#24 ] ( main:2::prepareBobs:7::progress_inc:186 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 progress_cursor#24 ] ) always clobbers reg byte a reg byte y +Statement [193] *((byte*) progress_cursor#17) ← *((const byte*) progress_inc::progress_chars + (byte) progress_idx#10) [ progress_idx#10 progress_cursor#17 ] ( main:2::prepareBobs:7::progress_inc:186 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 progress_idx#10 progress_cursor#17 ] ) always clobbers reg byte a reg byte y +Statement [203] *((byte*) charsetFindOrAddGlyph::glyph_cursor#11 + (byte) charsetFindOrAddGlyph::i1#2) ← *((byte*) charsetFindOrAddGlyph::glyph#10 + (byte) charsetFindOrAddGlyph::i1#2) [ charsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph_cursor#11 charsetFindOrAddGlyph::i1#2 ] ( main:2::prepareBobs:7::charsetFindOrAddGlyph:162 [ charsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph_cursor#11 charsetFindOrAddGlyph::i1#2 ] main:2::prepareBobs:7::charsetFindOrAddGlyph:180 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 charsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph_cursor#11 charsetFindOrAddGlyph::i1#2 ] ) always clobbers reg byte a +Removing always clobbered register reg byte a as potential for zp[1]:31 [ charsetFindOrAddGlyph::glyph_id#11 charsetFindOrAddGlyph::glyph_id#1 ] +Removing always clobbered register reg byte a as potential for zp[1]:34 [ charsetFindOrAddGlyph::i1#2 charsetFindOrAddGlyph::i1#1 ] +Statement [207] if(*((byte*) charsetFindOrAddGlyph::glyph_cursor#11 + (byte) charsetFindOrAddGlyph::i#2)==*((byte*) charsetFindOrAddGlyph::glyph#10 + (byte) charsetFindOrAddGlyph::i#2)) goto charsetFindOrAddGlyph::@4 [ charsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph_cursor#11 charsetFindOrAddGlyph::i#2 ] ( main:2::prepareBobs:7::charsetFindOrAddGlyph:162 [ charsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph_cursor#11 charsetFindOrAddGlyph::i#2 ] main:2::prepareBobs:7::charsetFindOrAddGlyph:180 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 charsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph_cursor#11 charsetFindOrAddGlyph::i#2 ] ) always clobbers reg byte a +Removing always clobbered register reg byte a as potential for zp[1]:35 [ charsetFindOrAddGlyph::i#2 charsetFindOrAddGlyph::i#1 ] +Statement [211] (byte*) charsetFindOrAddGlyph::glyph_cursor#1 ← (byte*) charsetFindOrAddGlyph::glyph_cursor#11 + (byte) 8 [ bob_charset_next_id#23 charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph_id#1 charsetFindOrAddGlyph::glyph_cursor#1 ] ( main:2::prepareBobs:7::charsetFindOrAddGlyph:162 [ bob_charset_next_id#23 charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph_id#1 charsetFindOrAddGlyph::glyph_cursor#1 ] main:2::prepareBobs:7::charsetFindOrAddGlyph:180 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bob_charset_next_id#23 charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph_id#1 charsetFindOrAddGlyph::glyph_cursor#1 ] ) always clobbers reg byte a +Statement [217] (byte~) protoBobShiftRight::$1 ← *((const byte*) PROTO_BOB + (byte) protoBobShiftRight::j#3) & (byte) 1 [ protoBobShiftRight::i#2 protoBobShiftRight::j#3 protoBobShiftRight::carry#2 protoBobShiftRight::$1 ] ( main:2::prepareBobs:7::protoBobShiftRight:175 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 protoBobShiftRight::i#2 protoBobShiftRight::j#3 protoBobShiftRight::carry#2 protoBobShiftRight::$1 ] main:2::prepareBobs:7::protoBobShiftRight:177 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 protoBobShiftRight::i#2 protoBobShiftRight::j#3 protoBobShiftRight::carry#2 protoBobShiftRight::$1 ] ) always clobbers reg byte a +Removing always clobbered register reg byte a as potential for zp[1]:37 [ protoBobShiftRight::i#2 protoBobShiftRight::i#1 ] +Removing always clobbered register reg byte a as potential for zp[1]:38 [ protoBobShiftRight::j#3 protoBobShiftRight::j#10 protoBobShiftRight::j#2 protoBobShiftRight::j#1 ] +Removing always clobbered register reg byte a as potential for zp[1]:39 [ protoBobShiftRight::carry#2 protoBobShiftRight::carry#10 ] +Statement [221] (byte~) protoBobShiftRight::$5 ← *((const byte*) PROTO_BOB + (byte) protoBobShiftRight::j#3) >> (byte) 1 [ protoBobShiftRight::i#2 protoBobShiftRight::j#3 protoBobShiftRight::carry#2 protoBobShiftRight::carry#1 protoBobShiftRight::$5 ] ( main:2::prepareBobs:7::protoBobShiftRight:175 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 protoBobShiftRight::i#2 protoBobShiftRight::j#3 protoBobShiftRight::carry#2 protoBobShiftRight::carry#1 protoBobShiftRight::$5 ] main:2::prepareBobs:7::protoBobShiftRight:177 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 protoBobShiftRight::i#2 protoBobShiftRight::j#3 protoBobShiftRight::carry#2 protoBobShiftRight::carry#1 protoBobShiftRight::$5 ] ) always clobbers reg byte a +Removing always clobbered register reg byte a as potential for zp[1]:40 [ protoBobShiftRight::carry#1 ] +Statement [225] (byte) protoBobShiftRight::j#2 ← (byte) protoBobShiftRight::j#3 + (byte) $18 [ protoBobShiftRight::i#2 protoBobShiftRight::carry#1 protoBobShiftRight::j#2 ] ( main:2::prepareBobs:7::protoBobShiftRight:175 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 protoBobShiftRight::i#2 protoBobShiftRight::carry#1 protoBobShiftRight::j#2 ] main:2::prepareBobs:7::protoBobShiftRight:177 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 protoBobShiftRight::i#2 protoBobShiftRight::carry#1 protoBobShiftRight::j#2 ] ) always clobbers reg byte a +Statement [229] (byte) protoBobShiftRight::j#1 ← (byte) protoBobShiftRight::j#3 - (byte) $2f [ protoBobShiftRight::i#2 protoBobShiftRight::carry#1 protoBobShiftRight::j#1 ] ( main:2::prepareBobs:7::protoBobShiftRight:175 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 protoBobShiftRight::i#2 protoBobShiftRight::carry#1 protoBobShiftRight::j#1 ] main:2::prepareBobs:7::protoBobShiftRight:177 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 protoBobShiftRight::i#2 protoBobShiftRight::carry#1 protoBobShiftRight::j#1 ] ) always clobbers reg byte a +Statement [233] *((const byte*) PROTO_BOB) ← (byte) 0 [ ] ( main:2::prepareBobs:7::protoBobShiftDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 ] ) always clobbers reg byte a +Statement [234] *((const byte*) PROTO_BOB+(byte) $18) ← (byte) 0 [ ] ( main:2::prepareBobs:7::protoBobShiftDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 ] ) always clobbers reg byte a +Statement [235] *((const byte*) PROTO_BOB+(byte) $30) ← (byte) 0 [ ] ( main:2::prepareBobs:7::protoBobShiftDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 ] ) always clobbers reg byte a +Statement [237] *((const byte*) PROTO_BOB + (byte) protoBobShiftDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $17 + (byte) protoBobShiftDown::i#2) [ protoBobShiftDown::i#2 ] ( main:2::prepareBobs:7::protoBobShiftDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 protoBobShiftDown::i#2 ] ) always clobbers reg byte a +Removing always clobbered register reg byte a as potential for zp[1]:41 [ protoBobShiftDown::i#2 protoBobShiftDown::i#1 ] +Statement [238] *((const byte*) PROTO_BOB+(byte) $18 + (byte) protoBobShiftDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $2f + (byte) protoBobShiftDown::i#2) [ protoBobShiftDown::i#2 ] ( main:2::prepareBobs:7::protoBobShiftDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 protoBobShiftDown::i#2 ] ) always clobbers reg byte a +Statement [239] *((const byte*) PROTO_BOB+(byte) $30 + (byte) protoBobShiftDown::i#2) ← (byte) 0 [ protoBobShiftDown::i#2 ] ( main:2::prepareBobs:7::protoBobShiftDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 protoBobShiftDown::i#2 ] ) always clobbers reg byte a +Statement [245] if((byte*) mulf_init::sqr1_lo#2!=(const byte*) mulf_sqr1_lo+(word) $200) goto mulf_init::@2 [ mulf_init::sqr1_lo#2 mulf_init::c#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::c#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 ] ) always clobbers reg byte a +Removing always clobbered register reg byte a as potential for zp[1]:44 [ mulf_init::c#2 mulf_init::c#1 ] +Removing always clobbered register reg byte a as potential for zp[1]:47 [ mulf_init::x_2#3 mulf_init::x_2#2 mulf_init::x_2#1 ] +Statement [247] if((byte*) mulf_init::sqr2_lo#2!=(const byte*) mulf_sqr2_lo+(word) $1ff) goto mulf_init::@6 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ( main:2::mulf_init:5 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ) always clobbers reg byte a +Removing always clobbered register reg byte a as potential for zp[1]:50 [ mulf_init::x_255#2 mulf_init::x_255#1 ] +Removing always clobbered register reg byte a as potential for zp[1]:53 [ mulf_init::dir#2 mulf_init::dir#4 ] +Statement [248] *((const byte*) mulf_sqr2_lo+(word) $1ff) ← *((const byte*) mulf_sqr1_lo+(word) $100) [ ] ( main:2::mulf_init:5 [ ] ) always clobbers reg byte a +Statement [249] *((const byte*) mulf_sqr2_hi+(word) $1ff) ← *((const byte*) mulf_sqr1_hi+(word) $100) [ ] ( main:2::mulf_init:5 [ ] ) always clobbers reg byte a +Statement [251] *((byte*) mulf_init::sqr2_lo#2) ← *((const byte*) mulf_sqr1_lo + (byte) mulf_init::x_255#2) [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ( main:2::mulf_init:5 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ) always clobbers reg byte a reg byte y +Removing always clobbered register reg byte y as potential for zp[1]:50 [ mulf_init::x_255#2 mulf_init::x_255#1 ] +Removing always clobbered register reg byte y as potential for zp[1]:53 [ mulf_init::dir#2 mulf_init::dir#4 ] +Statement [252] *((byte*) mulf_init::sqr2_hi#2) ← *((const byte*) mulf_sqr1_hi + (byte) mulf_init::x_255#2) [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ( main:2::mulf_init:5 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ) always clobbers reg byte a reg byte y +Statement [254] (byte) mulf_init::x_255#1 ← (byte) mulf_init::x_255#2 + (byte) mulf_init::dir#2 [ mulf_init::sqr2_lo#2 mulf_init::dir#2 mulf_init::x_255#1 mulf_init::sqr2_hi#1 ] ( main:2::mulf_init:5 [ mulf_init::sqr2_lo#2 mulf_init::dir#2 mulf_init::x_255#1 mulf_init::sqr2_hi#1 ] ) always clobbers reg byte a +Statement [260] (byte~) mulf_init::$1 ← (byte) mulf_init::c#1 & (byte) 1 [ mulf_init::sqr1_lo#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 mulf_init::c#1 mulf_init::$1 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 mulf_init::c#1 mulf_init::$1 ] ) always clobbers reg byte a +Statement [265] (byte~) mulf_init::$4 ← < (word) mulf_init::sqr#3 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$4 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$4 ] ) always clobbers reg byte a +Statement [266] *((byte*) mulf_init::sqr1_lo#2) ← (byte~) mulf_init::$4 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ) always clobbers reg byte y +Removing always clobbered register reg byte y as potential for zp[1]:44 [ mulf_init::c#2 mulf_init::c#1 ] +Removing always clobbered register reg byte y as potential for zp[1]:47 [ mulf_init::x_2#3 mulf_init::x_2#2 mulf_init::x_2#1 ] +Statement [267] (byte~) mulf_init::$5 ← > (word) mulf_init::sqr#3 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$5 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$5 ] ) always clobbers reg byte a +Statement [268] *((byte*) mulf_init::sqr1_hi#2) ← (byte~) mulf_init::$5 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ) always clobbers reg byte y +Statement [270] (word) mulf_init::sqr#1 ← (word) mulf_init::sqr#3 + (byte) mulf_init::x_2#2 [ mulf_init::sqr1_lo#2 mulf_init::c#1 mulf_init::sqr#1 mulf_init::sqr1_hi#1 mulf_init::x_2#2 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::c#1 mulf_init::sqr#1 mulf_init::sqr1_hi#1 mulf_init::x_2#2 ] ) always clobbers reg byte a +Statement [10] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [12] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank1_toDd001_return#0 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [14] *((const byte*) D018) ← (const byte) main::toD0181_return#0 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [17] if(*((const byte*) RASTER)<(byte) $f8) goto main::@2 [ main::angle#8 ] ( main:2 [ main::angle#8 ] ) always clobbers reg byte a +Statement [18] *((const byte*) BORDERCOL) ← (byte) $f [ main::angle#8 ] ( main:2 [ main::angle#8 ] ) always clobbers reg byte a +Statement [20] (byte) main::a#6 ← (byte) main::angle#8 [ main::angle#8 main::a#6 ] ( main:2 [ main::angle#8 main::a#6 ] ) always clobbers reg byte a +Statement [22] *((const byte*) BORDERCOL) ← (byte) 1 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 ] ) always clobbers reg byte a +Statement [24] (signed byte) mulf8s::b#0 ← *((const signed byte*) COS + (byte) main::a#2) [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::a#0 mulf8s::b#0 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::a#0 mulf8s::b#0 ] ) always clobbers reg byte y +Removing always clobbered register reg byte y as potential for zp[1]:8 [ mulf8s::mulf8s_prepare1_a#0 mulf8s::a#1 mulf8s::a#0 ] +Statement [26] (signed word) mulf8s::return#2 ← (signed word) mulf8s::return#0 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::return#2 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::return#2 ] ) always clobbers reg byte a +Statement [27] (signed word~) main::$10 ← (signed word) mulf8s::return#2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::$10 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::$10 ] ) always clobbers reg byte a +Statement [28] (signed word) main::x#0 ← (signed word~) main::$10 + (signed word)(number) $4b*(number) $100 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 ] ) always clobbers reg byte a +Statement [30] (signed byte) mulf8s::b#1 ← *((const signed byte*) SIN + (byte) main::a#2) [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::a#1 mulf8s::b#1 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::a#1 mulf8s::b#1 ] ) always clobbers reg byte y +Statement [32] (signed word) mulf8s::return#3 ← (signed word) mulf8s::return#0 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::return#3 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::return#3 ] ) always clobbers reg byte a +Statement [33] (signed word~) main::$12 ← (signed word) mulf8s::return#3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$12 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$12 ] ) always clobbers reg byte a +Statement [34] (signed word~) main::$13 ← (signed word~) main::$12 << (byte) 1 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$13 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$13 ] ) always clobbers reg byte a +Statement [35] (signed word) main::y#0 ← (signed word~) main::$13 + (signed word)(number) $5a*(number) $100 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ) always clobbers reg byte a +Statement [36] *((const byte*) BORDERCOL) ← (byte) 2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ) always clobbers reg byte a +Statement [37] (byte) main::a#1 ← (byte) main::a#2 + (byte) $62 [ main::angle#8 main::r#2 renderBobCleanupNext#17 main::i#2 main::a#1 main::x#0 main::y#0 ] ( main:2 [ main::angle#8 main::r#2 renderBobCleanupNext#17 main::i#2 main::a#1 main::x#0 main::y#0 ] ) always clobbers reg byte a reg byte x +Statement [38] (signed byte) main::r#1 ← (signed byte) main::r#2 + (signed byte) 3 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::x#0 main::y#0 ] ( main:2 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::x#0 main::y#0 ] ) always clobbers reg byte a reg byte x +Statement [39] (byte) renderBob::xpos#0 ← > (signed word) main::x#0 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::y#0 renderBob::xpos#0 ] ( main:2 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::y#0 renderBob::xpos#0 ] ) always clobbers reg byte a +Statement [40] (byte) renderBob::ypos#0 ← > (signed word) main::y#0 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 renderBob::xpos#0 renderBob::ypos#0 ] ( main:2 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 renderBob::xpos#0 renderBob::ypos#0 ] ) always clobbers reg byte a +Statement [43] if((byte) main::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto main::@4 [ main::angle#8 main::r#1 main::a#1 renderBobCleanupNext#13 main::i#1 ] ( main:2 [ main::angle#8 main::r#1 main::a#1 renderBobCleanupNext#13 main::i#1 ] ) always clobbers reg byte a +Statement [44] (byte) main::angle#1 ← (byte) main::angle#8 + (byte) 3 [ main::angle#1 ] ( main:2 [ main::angle#1 ] ) always clobbers reg byte a reg byte x +Statement [45] *((const byte*) BORDERCOL) ← (byte) 0 [ main::angle#1 ] ( main:2 [ main::angle#1 ] ) always clobbers reg byte a +Statement [55] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [57] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank2_toDd001_return#0 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [59] *((const byte*) D018) ← (const byte) main::toD0182_return#0 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [67] *((const byte*) CIA1_PORT_A) ← *((const byte*) keyboard_matrix_row_bitmask+(const byte) keyboard_key_pressed::rowidx#0) [ ] ( main:2::keyboard_key_pressed:46::keyboard_matrix_read:62 [ main::angle#1 ] main:2::keyboard_key_pressed:51::keyboard_matrix_read:62 [ ] ) always clobbers reg byte a +Statement [68] (byte) keyboard_matrix_read::return#0 ← ~ *((const byte*) CIA1_PORT_B) [ keyboard_matrix_read::return#0 ] ( main:2::keyboard_key_pressed:46::keyboard_matrix_read:62 [ main::angle#1 keyboard_matrix_read::return#0 ] main:2::keyboard_key_pressed:51::keyboard_matrix_read:62 [ keyboard_matrix_read::return#0 ] ) always clobbers reg byte a +Statement [70] (byte) renderBob::x_char_offset#0 ← (byte) renderBob::xpos#0 >> (byte) 2 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 ] ) always clobbers reg byte a +Statement [71] (byte) renderBob::y_char_offset#0 ← (byte) renderBob::ypos#0 >> (byte) 3 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_char_offset#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_char_offset#0 ] ) always clobbers reg byte a +Statement [72] (byte~) renderBob::$8 ← (byte) renderBob::y_char_offset#0 << (byte) 1 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$8 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$8 ] ) always clobbers reg byte a +Statement [73] (word) renderBob::y_offset#0 ← *((const word*) MUL40 + (byte~) renderBob::$8) [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_offset#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_offset#0 ] ) always clobbers reg byte a +Statement [74] (byte*~) renderBob::$2 ← (const byte*) BOB_SCREEN + (word) renderBob::y_offset#0 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$2 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$2 ] ) always clobbers reg byte a +Statement [75] (byte*) renderBob::screen#0 ← (byte*~) renderBob::$2 + (byte) renderBob::x_char_offset#0 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::screen#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::screen#0 ] ) always clobbers reg byte a +Statement [76] (byte~) renderBob::$4 ← (byte) renderBob::ypos#0 & (byte) 7 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$4 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$4 ] ) always clobbers reg byte a +Statement [77] (byte~) renderBob::$5 ← (byte~) renderBob::$4 << (byte) 2 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$5 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$5 ] ) always clobbers reg byte a +Statement [78] (byte~) renderBob::$6 ← (byte) renderBob::xpos#0 & (byte) 3 [ renderBobCleanupNext#17 renderBob::screen#0 renderBob::$5 renderBob::$6 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::screen#0 renderBob::$5 renderBob::$6 ] ) always clobbers reg byte a +Statement [79] (byte) renderBob::bob_table_idx#0 ← (byte~) renderBob::$5 + (byte~) renderBob::$6 [ renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a +Statement [80] *((byte**) renderBobCleanupNext#17) ← (byte*) renderBob::screen#0 [ renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [81] (byte**) renderBobCleanupNext#13 ← (byte**) renderBobCleanupNext#17 + (const byte) SIZEOF_POINTER [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a +Statement [82] *((byte*) renderBob::screen#0) ← *((const byte*) BOB_TABLES + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [83] *((byte*) renderBob::screen#0 + (byte) $28) ← *((const byte*) BOB_TABLES+(byte) 1*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [84] *((byte*) renderBob::screen#0 + (byte) $50) ← *((const byte*) BOB_TABLES+(byte) 2*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [85] *((byte*) renderBob::screen#0 + (byte) 1) ← *((const byte*) BOB_TABLES+(byte) 3*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [86] *((byte*) renderBob::screen#0 + (byte) $29) ← *((const byte*) BOB_TABLES+(byte) 4*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [87] *((byte*) renderBob::screen#0 + (byte) $51) ← *((const byte*) BOB_TABLES+(byte) 5*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [88] *((byte*) renderBob::screen#0 + (byte) 2) ← *((const byte*) BOB_TABLES+(byte) 6*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [89] *((byte*) renderBob::screen#0 + (byte) $2a) ← *((const byte*) BOB_TABLES+(byte) 7*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [90] *((byte*) renderBob::screen#0 + (byte) $52) ← *((const byte*) BOB_TABLES+(byte) 8*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 ] ) always clobbers reg byte a reg byte y +Statement [97] (signed word) mulf8s::return#0 ← (signed word)(word) mulf8s_prepared::m#4 [ mulf8s::return#0 ] ( main:2::mulf8s:25 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::return#0 ] main:2::mulf8s:31 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::return#0 ] ) always clobbers reg byte a +Statement [101] (word) mulf8u_prepared::return#2 ← (word) mulf8u_prepared::return#0 [ mulf8s_prepared::b#0 mulf8u_prepared::return#2 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8u_prepared::return#2 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8u_prepared::return#2 ] ) always clobbers reg byte a +Statement [102] (word) mulf8s_prepared::m#0 ← (word) mulf8u_prepared::return#2 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ) always clobbers reg byte a +Statement [103] if(*((const signed byte*) mulf8s_prepared::memA)>=(signed byte) 0) goto mulf8s_prepared::@1 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ) always clobbers reg byte a +Statement [104] (byte~) mulf8s_prepared::$8 ← > (word) mulf8s_prepared::m#0 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$8 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$8 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$8 ] ) always clobbers reg byte a +Statement [105] (byte~) mulf8s_prepared::$15 ← (byte~) mulf8s_prepared::$8 - (byte)(signed byte) mulf8s_prepared::b#0 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$15 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$15 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$15 ] ) always clobbers reg byte a +Statement [109] (byte~) mulf8s_prepared::$12 ← > (word) mulf8s_prepared::m#5 [ mulf8s_prepared::m#5 mulf8s_prepared::$12 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::m#5 mulf8s_prepared::$12 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::m#5 mulf8s_prepared::$12 ] ) always clobbers reg byte a +Statement [110] (byte~) mulf8s_prepared::$16 ← (byte~) mulf8s_prepared::$12 - (byte)*((const signed byte*) mulf8s_prepared::memA) [ mulf8s_prepared::m#5 mulf8s_prepared::$16 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::m#5 mulf8s_prepared::$16 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::m#5 mulf8s_prepared::$16 ] ) always clobbers reg byte a +Statement asm { ldxmemB sec sm1: ldamulf_sqr1_lo,x sm2: sbcmulf_sqr2_lo,x staresL sm3: ldamulf_sqr1_hi,x sm4: sbcmulf_sqr2_hi,x stamemB } always clobbers reg byte a reg byte x +Statement [116] (word) mulf8u_prepared::return#0 ← *((const byte*) mulf8u_prepared::memB) w= *((const byte*) mulf8u_prepared::resL) [ mulf8u_prepared::return#0 ] ( main:2::mulf8s:25::mulf8s_prepared:96::mulf8u_prepared:100 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8u_prepared::return#0 ] main:2::mulf8s:31::mulf8s_prepared:96::mulf8u_prepared:100 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8u_prepared::return#0 ] ) always clobbers reg byte a +Statement asm { ldamemA stamulf8u_prepared.sm1+1 stamulf8u_prepared.sm3+1 eor#$ff stamulf8u_prepared.sm2+1 stamulf8u_prepared.sm4+1 } always clobbers reg byte a +Statement [123] (byte~) renderBobCleanup::$1 ← (byte) renderBobCleanup::i#2 << (byte) 1 [ renderBobCleanup::i#2 renderBobCleanup::$1 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::$1 ] ) always clobbers reg byte a +Statement [124] (byte*) renderBobCleanup::screen#0 ← *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobCleanup::$1) [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a +Statement [125] *((byte*) renderBobCleanup::screen#0) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [126] *((byte*) renderBobCleanup::screen#0 + (byte) $28) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [127] *((byte*) renderBobCleanup::screen#0 + (byte) $50) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [128] *((byte*) renderBobCleanup::screen#0 + (byte) 1) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [129] *((byte*) renderBobCleanup::screen#0 + (byte) $29) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [130] *((byte*) renderBobCleanup::screen#0 + (byte) $51) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [131] *((byte*) renderBobCleanup::screen#0 + (byte) 2) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [132] *((byte*) renderBobCleanup::screen#0 + (byte) $2a) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [133] *((byte*) renderBobCleanup::screen#0 + (byte) $52) ← (byte) 0 [ renderBobCleanup::i#2 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 ] ) always clobbers reg byte a reg byte y +Statement [139] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 [ memset::dst#2 ] ( main:2::memset:15 [ memset::dst#2 ] ) always clobbers reg byte a +Statement [141] *((byte*) memset::dst#2) ← (const byte) memset::c#0 [ memset::dst#2 ] ( main:2::memset:15 [ memset::dst#2 ] ) always clobbers reg byte a reg byte y +Statement [145] (word~) renderBobInit::$0 ← (word)(byte) renderBobInit::y#2 [ renderBobInit::y#2 renderBobInit::$0 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 renderBobInit::$0 ] ) always clobbers reg byte a +Statement [146] (word~) renderBobInit::$6 ← (word~) renderBobInit::$0 << (byte) 2 [ renderBobInit::y#2 renderBobInit::$0 renderBobInit::$6 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 renderBobInit::$0 renderBobInit::$6 ] ) always clobbers reg byte a +Statement [147] (word~) renderBobInit::$7 ← (word~) renderBobInit::$6 + (word~) renderBobInit::$0 [ renderBobInit::y#2 renderBobInit::$7 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 renderBobInit::$7 ] ) always clobbers reg byte a +Statement [148] (word~) renderBobInit::$1 ← (word~) renderBobInit::$7 << (byte) 3 [ renderBobInit::y#2 renderBobInit::$1 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 renderBobInit::$1 ] ) always clobbers reg byte a +Statement [149] (byte~) renderBobInit::$4 ← (byte) renderBobInit::y#2 << (byte) 1 [ renderBobInit::y#2 renderBobInit::$1 renderBobInit::$4 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 renderBobInit::$1 renderBobInit::$4 ] ) always clobbers reg byte a +Statement [150] *((const word*) MUL40 + (byte~) renderBobInit::$4) ← (word~) renderBobInit::$1 [ renderBobInit::y#2 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 ] ) always clobbers reg byte a +Statement [154] (byte~) renderBobInit::$5 ← (byte) renderBobInit::i#2 << (byte) 1 [ renderBobInit::i#2 renderBobInit::$5 ] ( main:2::renderBobInit:9 [ renderBobInit::i#2 renderBobInit::$5 ] ) always clobbers reg byte a +Statement [155] *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobInit::$5) ← (const byte*) BOB_SCREEN [ renderBobInit::i#2 ] ( main:2::renderBobInit:9 [ renderBobInit::i#2 ] ) always clobbers reg byte a +Statement [171] (byte*) prepareBobs::bob_table#0 ← (const byte*) BOB_TABLES + (byte) prepareBobs::bob_table_idx#12 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::bob_table#0 ] ( main:2::prepareBobs:7 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::bob_table#0 ] ) always clobbers reg byte a +Statement [179] (byte*) charsetFindOrAddGlyph::glyph#1 ← (byte*) prepareBobs::bob_glyph#2 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 charsetFindOrAddGlyph::glyph#1 ] ( main:2::prepareBobs:7 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 charsetFindOrAddGlyph::glyph#1 ] ) always clobbers reg byte a +Statement [183] *((byte*) prepareBobs::bob_table#2) ← (byte~) prepareBobs::$6 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 ] ( main:2::prepareBobs:7 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 ] ) always clobbers reg byte y +Statement [184] (byte*) prepareBobs::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 + (byte) 8 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_table#2 prepareBobs::bob_glyph#1 ] ( main:2::prepareBobs:7 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_table#2 prepareBobs::bob_glyph#1 ] ) always clobbers reg byte a +Statement [185] (byte*) prepareBobs::bob_table#1 ← (byte*) prepareBobs::bob_table#2 + (const byte) BOB_SHIFTS_X*(const byte) BOB_SHIFTS_Y [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 ] ( main:2::prepareBobs:7 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 ] ) always clobbers reg byte a +Statement [190] *((byte*) progress_cursor#24) ← *((const byte*) progress_inc::progress_chars+(byte) 8) [ progress_cursor#24 ] ( main:2::prepareBobs:7::progress_inc:186 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 progress_cursor#24 ] ) always clobbers reg byte a reg byte y +Statement [193] *((byte*) progress_cursor#17) ← *((const byte*) progress_inc::progress_chars + (byte) progress_idx#10) [ progress_idx#10 progress_cursor#17 ] ( main:2::prepareBobs:7::progress_inc:186 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 progress_idx#10 progress_cursor#17 ] ) always clobbers reg byte a reg byte y +Statement [203] *((byte*) charsetFindOrAddGlyph::glyph_cursor#11 + (byte) charsetFindOrAddGlyph::i1#2) ← *((byte*) charsetFindOrAddGlyph::glyph#10 + (byte) charsetFindOrAddGlyph::i1#2) [ charsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph_cursor#11 charsetFindOrAddGlyph::i1#2 ] ( main:2::prepareBobs:7::charsetFindOrAddGlyph:162 [ charsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph_cursor#11 charsetFindOrAddGlyph::i1#2 ] main:2::prepareBobs:7::charsetFindOrAddGlyph:180 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 charsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph_cursor#11 charsetFindOrAddGlyph::i1#2 ] ) always clobbers reg byte a +Statement [207] if(*((byte*) charsetFindOrAddGlyph::glyph_cursor#11 + (byte) charsetFindOrAddGlyph::i#2)==*((byte*) charsetFindOrAddGlyph::glyph#10 + (byte) charsetFindOrAddGlyph::i#2)) goto charsetFindOrAddGlyph::@4 [ charsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph_cursor#11 charsetFindOrAddGlyph::i#2 ] ( main:2::prepareBobs:7::charsetFindOrAddGlyph:162 [ charsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph_cursor#11 charsetFindOrAddGlyph::i#2 ] main:2::prepareBobs:7::charsetFindOrAddGlyph:180 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 charsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph_cursor#11 charsetFindOrAddGlyph::i#2 ] ) always clobbers reg byte a +Statement [211] (byte*) charsetFindOrAddGlyph::glyph_cursor#1 ← (byte*) charsetFindOrAddGlyph::glyph_cursor#11 + (byte) 8 [ bob_charset_next_id#23 charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph_id#1 charsetFindOrAddGlyph::glyph_cursor#1 ] ( main:2::prepareBobs:7::charsetFindOrAddGlyph:162 [ bob_charset_next_id#23 charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph_id#1 charsetFindOrAddGlyph::glyph_cursor#1 ] main:2::prepareBobs:7::charsetFindOrAddGlyph:180 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bob_charset_next_id#23 charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph_id#1 charsetFindOrAddGlyph::glyph_cursor#1 ] ) always clobbers reg byte a +Statement [217] (byte~) protoBobShiftRight::$1 ← *((const byte*) PROTO_BOB + (byte) protoBobShiftRight::j#3) & (byte) 1 [ protoBobShiftRight::i#2 protoBobShiftRight::j#3 protoBobShiftRight::carry#2 protoBobShiftRight::$1 ] ( main:2::prepareBobs:7::protoBobShiftRight:175 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 protoBobShiftRight::i#2 protoBobShiftRight::j#3 protoBobShiftRight::carry#2 protoBobShiftRight::$1 ] main:2::prepareBobs:7::protoBobShiftRight:177 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 protoBobShiftRight::i#2 protoBobShiftRight::j#3 protoBobShiftRight::carry#2 protoBobShiftRight::$1 ] ) always clobbers reg byte a +Statement [221] (byte~) protoBobShiftRight::$5 ← *((const byte*) PROTO_BOB + (byte) protoBobShiftRight::j#3) >> (byte) 1 [ protoBobShiftRight::i#2 protoBobShiftRight::j#3 protoBobShiftRight::carry#2 protoBobShiftRight::carry#1 protoBobShiftRight::$5 ] ( main:2::prepareBobs:7::protoBobShiftRight:175 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 protoBobShiftRight::i#2 protoBobShiftRight::j#3 protoBobShiftRight::carry#2 protoBobShiftRight::carry#1 protoBobShiftRight::$5 ] main:2::prepareBobs:7::protoBobShiftRight:177 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 protoBobShiftRight::i#2 protoBobShiftRight::j#3 protoBobShiftRight::carry#2 protoBobShiftRight::carry#1 protoBobShiftRight::$5 ] ) always clobbers reg byte a +Statement [225] (byte) protoBobShiftRight::j#2 ← (byte) protoBobShiftRight::j#3 + (byte) $18 [ protoBobShiftRight::i#2 protoBobShiftRight::carry#1 protoBobShiftRight::j#2 ] ( main:2::prepareBobs:7::protoBobShiftRight:175 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 protoBobShiftRight::i#2 protoBobShiftRight::carry#1 protoBobShiftRight::j#2 ] main:2::prepareBobs:7::protoBobShiftRight:177 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 protoBobShiftRight::i#2 protoBobShiftRight::carry#1 protoBobShiftRight::j#2 ] ) always clobbers reg byte a +Statement [229] (byte) protoBobShiftRight::j#1 ← (byte) protoBobShiftRight::j#3 - (byte) $2f [ protoBobShiftRight::i#2 protoBobShiftRight::carry#1 protoBobShiftRight::j#1 ] ( main:2::prepareBobs:7::protoBobShiftRight:175 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 protoBobShiftRight::i#2 protoBobShiftRight::carry#1 protoBobShiftRight::j#1 ] main:2::prepareBobs:7::protoBobShiftRight:177 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 protoBobShiftRight::i#2 protoBobShiftRight::carry#1 protoBobShiftRight::j#1 ] ) always clobbers reg byte a +Statement [233] *((const byte*) PROTO_BOB) ← (byte) 0 [ ] ( main:2::prepareBobs:7::protoBobShiftDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 ] ) always clobbers reg byte a +Statement [234] *((const byte*) PROTO_BOB+(byte) $18) ← (byte) 0 [ ] ( main:2::prepareBobs:7::protoBobShiftDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 ] ) always clobbers reg byte a +Statement [235] *((const byte*) PROTO_BOB+(byte) $30) ← (byte) 0 [ ] ( main:2::prepareBobs:7::protoBobShiftDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 ] ) always clobbers reg byte a +Statement [237] *((const byte*) PROTO_BOB + (byte) protoBobShiftDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $17 + (byte) protoBobShiftDown::i#2) [ protoBobShiftDown::i#2 ] ( main:2::prepareBobs:7::protoBobShiftDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 protoBobShiftDown::i#2 ] ) always clobbers reg byte a +Statement [238] *((const byte*) PROTO_BOB+(byte) $18 + (byte) protoBobShiftDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $2f + (byte) protoBobShiftDown::i#2) [ protoBobShiftDown::i#2 ] ( main:2::prepareBobs:7::protoBobShiftDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 protoBobShiftDown::i#2 ] ) always clobbers reg byte a +Statement [239] *((const byte*) PROTO_BOB+(byte) $30 + (byte) protoBobShiftDown::i#2) ← (byte) 0 [ protoBobShiftDown::i#2 ] ( main:2::prepareBobs:7::protoBobShiftDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 protoBobShiftDown::i#2 ] ) always clobbers reg byte a +Statement [245] if((byte*) mulf_init::sqr1_lo#2!=(const byte*) mulf_sqr1_lo+(word) $200) goto mulf_init::@2 [ mulf_init::sqr1_lo#2 mulf_init::c#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::c#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 ] ) always clobbers reg byte a +Statement [247] if((byte*) mulf_init::sqr2_lo#2!=(const byte*) mulf_sqr2_lo+(word) $1ff) goto mulf_init::@6 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ( main:2::mulf_init:5 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ) always clobbers reg byte a +Statement [248] *((const byte*) mulf_sqr2_lo+(word) $1ff) ← *((const byte*) mulf_sqr1_lo+(word) $100) [ ] ( main:2::mulf_init:5 [ ] ) always clobbers reg byte a +Statement [249] *((const byte*) mulf_sqr2_hi+(word) $1ff) ← *((const byte*) mulf_sqr1_hi+(word) $100) [ ] ( main:2::mulf_init:5 [ ] ) always clobbers reg byte a +Statement [251] *((byte*) mulf_init::sqr2_lo#2) ← *((const byte*) mulf_sqr1_lo + (byte) mulf_init::x_255#2) [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ( main:2::mulf_init:5 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ) always clobbers reg byte a reg byte y +Statement [252] *((byte*) mulf_init::sqr2_hi#2) ← *((const byte*) mulf_sqr1_hi + (byte) mulf_init::x_255#2) [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ( main:2::mulf_init:5 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ) always clobbers reg byte a reg byte y +Statement [254] (byte) mulf_init::x_255#1 ← (byte) mulf_init::x_255#2 + (byte) mulf_init::dir#2 [ mulf_init::sqr2_lo#2 mulf_init::dir#2 mulf_init::x_255#1 mulf_init::sqr2_hi#1 ] ( main:2::mulf_init:5 [ mulf_init::sqr2_lo#2 mulf_init::dir#2 mulf_init::x_255#1 mulf_init::sqr2_hi#1 ] ) always clobbers reg byte a +Statement [260] (byte~) mulf_init::$1 ← (byte) mulf_init::c#1 & (byte) 1 [ mulf_init::sqr1_lo#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 mulf_init::c#1 mulf_init::$1 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 mulf_init::c#1 mulf_init::$1 ] ) always clobbers reg byte a +Statement [265] (byte~) mulf_init::$4 ← < (word) mulf_init::sqr#3 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$4 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$4 ] ) always clobbers reg byte a +Statement [266] *((byte*) mulf_init::sqr1_lo#2) ← (byte~) mulf_init::$4 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ) always clobbers reg byte y +Statement [267] (byte~) mulf_init::$5 ← > (word) mulf_init::sqr#3 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$5 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$5 ] ) always clobbers reg byte a +Statement [268] *((byte*) mulf_init::sqr1_hi#2) ← (byte~) mulf_init::$5 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ) always clobbers reg byte y +Statement [270] (word) mulf_init::sqr#1 ← (word) mulf_init::sqr#3 + (byte) mulf_init::x_2#2 [ mulf_init::sqr1_lo#2 mulf_init::c#1 mulf_init::sqr#1 mulf_init::sqr1_hi#1 mulf_init::x_2#2 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::c#1 mulf_init::sqr#1 mulf_init::sqr1_hi#1 mulf_init::x_2#2 ] ) always clobbers reg byte a +Statement [10] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [12] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank1_toDd001_return#0 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [14] *((const byte*) D018) ← (const byte) main::toD0181_return#0 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [17] if(*((const byte*) RASTER)<(byte) $f8) goto main::@2 [ main::angle#8 ] ( main:2 [ main::angle#8 ] ) always clobbers reg byte a +Statement [18] *((const byte*) BORDERCOL) ← (byte) $f [ main::angle#8 ] ( main:2 [ main::angle#8 ] ) always clobbers reg byte a +Statement [20] (byte) main::a#6 ← (byte) main::angle#8 [ main::angle#8 main::a#6 ] ( main:2 [ main::angle#8 main::a#6 ] ) always clobbers reg byte a +Statement [22] *((const byte*) BORDERCOL) ← (byte) 1 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 ] ) always clobbers reg byte a +Statement [24] (signed byte) mulf8s::b#0 ← *((const signed byte*) COS + (byte) main::a#2) [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::a#0 mulf8s::b#0 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::a#0 mulf8s::b#0 ] ) always clobbers reg byte y +Statement [26] (signed word) mulf8s::return#2 ← (signed word) mulf8s::return#0 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::return#2 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::return#2 ] ) always clobbers reg byte a +Statement [27] (signed word~) main::$10 ← (signed word) mulf8s::return#2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::$10 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::$10 ] ) always clobbers reg byte a +Statement [28] (signed word) main::x#0 ← (signed word~) main::$10 + (signed word)(number) $4b*(number) $100 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 ] ) always clobbers reg byte a +Statement [30] (signed byte) mulf8s::b#1 ← *((const signed byte*) SIN + (byte) main::a#2) [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::a#1 mulf8s::b#1 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::a#1 mulf8s::b#1 ] ) always clobbers reg byte y +Statement [32] (signed word) mulf8s::return#3 ← (signed word) mulf8s::return#0 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::return#3 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::return#3 ] ) always clobbers reg byte a +Statement [33] (signed word~) main::$12 ← (signed word) mulf8s::return#3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$12 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$12 ] ) always clobbers reg byte a +Statement [34] (signed word~) main::$13 ← (signed word~) main::$12 << (byte) 1 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$13 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$13 ] ) always clobbers reg byte a +Statement [35] (signed word) main::y#0 ← (signed word~) main::$13 + (signed word)(number) $5a*(number) $100 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ) always clobbers reg byte a +Statement [36] *((const byte*) BORDERCOL) ← (byte) 2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ) always clobbers reg byte a +Statement [37] (byte) main::a#1 ← (byte) main::a#2 + (byte) $62 [ main::angle#8 main::r#2 renderBobCleanupNext#17 main::i#2 main::a#1 main::x#0 main::y#0 ] ( main:2 [ main::angle#8 main::r#2 renderBobCleanupNext#17 main::i#2 main::a#1 main::x#0 main::y#0 ] ) always clobbers reg byte a reg byte x +Statement [38] (signed byte) main::r#1 ← (signed byte) main::r#2 + (signed byte) 3 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::x#0 main::y#0 ] ( main:2 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::x#0 main::y#0 ] ) always clobbers reg byte a reg byte x +Statement [39] (byte) renderBob::xpos#0 ← > (signed word) main::x#0 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::y#0 renderBob::xpos#0 ] ( main:2 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::y#0 renderBob::xpos#0 ] ) always clobbers reg byte a +Statement [40] (byte) renderBob::ypos#0 ← > (signed word) main::y#0 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 renderBob::xpos#0 renderBob::ypos#0 ] ( main:2 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 renderBob::xpos#0 renderBob::ypos#0 ] ) always clobbers reg byte a +Statement [43] if((byte) main::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto main::@4 [ main::angle#8 main::r#1 main::a#1 renderBobCleanupNext#13 main::i#1 ] ( main:2 [ main::angle#8 main::r#1 main::a#1 renderBobCleanupNext#13 main::i#1 ] ) always clobbers reg byte a +Statement [44] (byte) main::angle#1 ← (byte) main::angle#8 + (byte) 3 [ main::angle#1 ] ( main:2 [ main::angle#1 ] ) always clobbers reg byte a reg byte x +Statement [45] *((const byte*) BORDERCOL) ← (byte) 0 [ main::angle#1 ] ( main:2 [ main::angle#1 ] ) always clobbers reg byte a +Statement [55] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [57] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank2_toDd001_return#0 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [59] *((const byte*) D018) ← (const byte) main::toD0182_return#0 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [67] *((const byte*) CIA1_PORT_A) ← *((const byte*) keyboard_matrix_row_bitmask+(const byte) keyboard_key_pressed::rowidx#0) [ ] ( main:2::keyboard_key_pressed:46::keyboard_matrix_read:62 [ main::angle#1 ] main:2::keyboard_key_pressed:51::keyboard_matrix_read:62 [ ] ) always clobbers reg byte a +Statement [68] (byte) keyboard_matrix_read::return#0 ← ~ *((const byte*) CIA1_PORT_B) [ keyboard_matrix_read::return#0 ] ( main:2::keyboard_key_pressed:46::keyboard_matrix_read:62 [ main::angle#1 keyboard_matrix_read::return#0 ] main:2::keyboard_key_pressed:51::keyboard_matrix_read:62 [ keyboard_matrix_read::return#0 ] ) always clobbers reg byte a +Statement [70] (byte) renderBob::x_char_offset#0 ← (byte) renderBob::xpos#0 >> (byte) 2 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 ] ) always clobbers reg byte a +Statement [71] (byte) renderBob::y_char_offset#0 ← (byte) renderBob::ypos#0 >> (byte) 3 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_char_offset#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_char_offset#0 ] ) always clobbers reg byte a +Statement [72] (byte~) renderBob::$8 ← (byte) renderBob::y_char_offset#0 << (byte) 1 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$8 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$8 ] ) always clobbers reg byte a +Statement [73] (word) renderBob::y_offset#0 ← *((const word*) MUL40 + (byte~) renderBob::$8) [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_offset#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_offset#0 ] ) always clobbers reg byte a +Statement [74] (byte*~) renderBob::$2 ← (const byte*) BOB_SCREEN + (word) renderBob::y_offset#0 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$2 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$2 ] ) always clobbers reg byte a +Statement [75] (byte*) renderBob::screen#0 ← (byte*~) renderBob::$2 + (byte) renderBob::x_char_offset#0 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::screen#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::screen#0 ] ) always clobbers reg byte a +Statement [76] (byte~) renderBob::$4 ← (byte) renderBob::ypos#0 & (byte) 7 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$4 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$4 ] ) always clobbers reg byte a +Statement [77] (byte~) renderBob::$5 ← (byte~) renderBob::$4 << (byte) 2 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$5 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$5 ] ) always clobbers reg byte a +Statement [78] (byte~) renderBob::$6 ← (byte) renderBob::xpos#0 & (byte) 3 [ renderBobCleanupNext#17 renderBob::screen#0 renderBob::$5 renderBob::$6 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::screen#0 renderBob::$5 renderBob::$6 ] ) always clobbers reg byte a +Statement [79] (byte) renderBob::bob_table_idx#0 ← (byte~) renderBob::$5 + (byte~) renderBob::$6 [ renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a +Statement [80] *((byte**) renderBobCleanupNext#17) ← (byte*) renderBob::screen#0 [ renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [81] (byte**) renderBobCleanupNext#13 ← (byte**) renderBobCleanupNext#17 + (const byte) SIZEOF_POINTER [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a +Statement [82] *((byte*) renderBob::screen#0) ← *((const byte*) BOB_TABLES + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [83] *((byte*) renderBob::screen#0 + (byte) $28) ← *((const byte*) BOB_TABLES+(byte) 1*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [84] *((byte*) renderBob::screen#0 + (byte) $50) ← *((const byte*) BOB_TABLES+(byte) 2*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [85] *((byte*) renderBob::screen#0 + (byte) 1) ← *((const byte*) BOB_TABLES+(byte) 3*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [86] *((byte*) renderBob::screen#0 + (byte) $29) ← *((const byte*) BOB_TABLES+(byte) 4*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [87] *((byte*) renderBob::screen#0 + (byte) $51) ← *((const byte*) BOB_TABLES+(byte) 5*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [88] *((byte*) renderBob::screen#0 + (byte) 2) ← *((const byte*) BOB_TABLES+(byte) 6*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [89] *((byte*) renderBob::screen#0 + (byte) $2a) ← *((const byte*) BOB_TABLES+(byte) 7*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [90] *((byte*) renderBob::screen#0 + (byte) $52) ← *((const byte*) BOB_TABLES+(byte) 8*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 ] ) always clobbers reg byte a reg byte y +Statement [97] (signed word) mulf8s::return#0 ← (signed word)(word) mulf8s_prepared::m#4 [ mulf8s::return#0 ] ( main:2::mulf8s:25 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::return#0 ] main:2::mulf8s:31 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::return#0 ] ) always clobbers reg byte a +Statement [101] (word) mulf8u_prepared::return#2 ← (word) mulf8u_prepared::return#0 [ mulf8s_prepared::b#0 mulf8u_prepared::return#2 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8u_prepared::return#2 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8u_prepared::return#2 ] ) always clobbers reg byte a +Statement [102] (word) mulf8s_prepared::m#0 ← (word) mulf8u_prepared::return#2 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ) always clobbers reg byte a +Statement [103] if(*((const signed byte*) mulf8s_prepared::memA)>=(signed byte) 0) goto mulf8s_prepared::@1 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ) always clobbers reg byte a +Statement [104] (byte~) mulf8s_prepared::$8 ← > (word) mulf8s_prepared::m#0 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$8 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$8 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$8 ] ) always clobbers reg byte a +Statement [105] (byte~) mulf8s_prepared::$15 ← (byte~) mulf8s_prepared::$8 - (byte)(signed byte) mulf8s_prepared::b#0 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$15 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$15 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$15 ] ) always clobbers reg byte a +Statement [109] (byte~) mulf8s_prepared::$12 ← > (word) mulf8s_prepared::m#5 [ mulf8s_prepared::m#5 mulf8s_prepared::$12 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::m#5 mulf8s_prepared::$12 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::m#5 mulf8s_prepared::$12 ] ) always clobbers reg byte a +Statement [110] (byte~) mulf8s_prepared::$16 ← (byte~) mulf8s_prepared::$12 - (byte)*((const signed byte*) mulf8s_prepared::memA) [ mulf8s_prepared::m#5 mulf8s_prepared::$16 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::m#5 mulf8s_prepared::$16 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::m#5 mulf8s_prepared::$16 ] ) always clobbers reg byte a +Statement asm { ldxmemB sec sm1: ldamulf_sqr1_lo,x sm2: sbcmulf_sqr2_lo,x staresL sm3: ldamulf_sqr1_hi,x sm4: sbcmulf_sqr2_hi,x stamemB } always clobbers reg byte a reg byte x +Statement [116] (word) mulf8u_prepared::return#0 ← *((const byte*) mulf8u_prepared::memB) w= *((const byte*) mulf8u_prepared::resL) [ mulf8u_prepared::return#0 ] ( main:2::mulf8s:25::mulf8s_prepared:96::mulf8u_prepared:100 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8u_prepared::return#0 ] main:2::mulf8s:31::mulf8s_prepared:96::mulf8u_prepared:100 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8u_prepared::return#0 ] ) always clobbers reg byte a +Statement asm { ldamemA stamulf8u_prepared.sm1+1 stamulf8u_prepared.sm3+1 eor#$ff stamulf8u_prepared.sm2+1 stamulf8u_prepared.sm4+1 } always clobbers reg byte a +Statement [123] (byte~) renderBobCleanup::$1 ← (byte) renderBobCleanup::i#2 << (byte) 1 [ renderBobCleanup::i#2 renderBobCleanup::$1 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::$1 ] ) always clobbers reg byte a +Statement [124] (byte*) renderBobCleanup::screen#0 ← *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobCleanup::$1) [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a +Statement [125] *((byte*) renderBobCleanup::screen#0) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [126] *((byte*) renderBobCleanup::screen#0 + (byte) $28) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [127] *((byte*) renderBobCleanup::screen#0 + (byte) $50) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [128] *((byte*) renderBobCleanup::screen#0 + (byte) 1) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [129] *((byte*) renderBobCleanup::screen#0 + (byte) $29) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [130] *((byte*) renderBobCleanup::screen#0 + (byte) $51) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [131] *((byte*) renderBobCleanup::screen#0 + (byte) 2) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [132] *((byte*) renderBobCleanup::screen#0 + (byte) $2a) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [133] *((byte*) renderBobCleanup::screen#0 + (byte) $52) ← (byte) 0 [ renderBobCleanup::i#2 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 ] ) always clobbers reg byte a reg byte y +Statement [139] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 [ memset::dst#2 ] ( main:2::memset:15 [ memset::dst#2 ] ) always clobbers reg byte a +Statement [141] *((byte*) memset::dst#2) ← (const byte) memset::c#0 [ memset::dst#2 ] ( main:2::memset:15 [ memset::dst#2 ] ) always clobbers reg byte a reg byte y +Statement [145] (word~) renderBobInit::$0 ← (word)(byte) renderBobInit::y#2 [ renderBobInit::y#2 renderBobInit::$0 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 renderBobInit::$0 ] ) always clobbers reg byte a +Statement [146] (word~) renderBobInit::$6 ← (word~) renderBobInit::$0 << (byte) 2 [ renderBobInit::y#2 renderBobInit::$0 renderBobInit::$6 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 renderBobInit::$0 renderBobInit::$6 ] ) always clobbers reg byte a +Statement [147] (word~) renderBobInit::$7 ← (word~) renderBobInit::$6 + (word~) renderBobInit::$0 [ renderBobInit::y#2 renderBobInit::$7 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 renderBobInit::$7 ] ) always clobbers reg byte a +Statement [148] (word~) renderBobInit::$1 ← (word~) renderBobInit::$7 << (byte) 3 [ renderBobInit::y#2 renderBobInit::$1 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 renderBobInit::$1 ] ) always clobbers reg byte a +Statement [149] (byte~) renderBobInit::$4 ← (byte) renderBobInit::y#2 << (byte) 1 [ renderBobInit::y#2 renderBobInit::$1 renderBobInit::$4 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 renderBobInit::$1 renderBobInit::$4 ] ) always clobbers reg byte a +Statement [150] *((const word*) MUL40 + (byte~) renderBobInit::$4) ← (word~) renderBobInit::$1 [ renderBobInit::y#2 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 ] ) always clobbers reg byte a +Statement [154] (byte~) renderBobInit::$5 ← (byte) renderBobInit::i#2 << (byte) 1 [ renderBobInit::i#2 renderBobInit::$5 ] ( main:2::renderBobInit:9 [ renderBobInit::i#2 renderBobInit::$5 ] ) always clobbers reg byte a +Statement [155] *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobInit::$5) ← (const byte*) BOB_SCREEN [ renderBobInit::i#2 ] ( main:2::renderBobInit:9 [ renderBobInit::i#2 ] ) always clobbers reg byte a +Statement [171] (byte*) prepareBobs::bob_table#0 ← (const byte*) BOB_TABLES + (byte) prepareBobs::bob_table_idx#12 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::bob_table#0 ] ( main:2::prepareBobs:7 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::bob_table#0 ] ) always clobbers reg byte a +Statement [179] (byte*) charsetFindOrAddGlyph::glyph#1 ← (byte*) prepareBobs::bob_glyph#2 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 charsetFindOrAddGlyph::glyph#1 ] ( main:2::prepareBobs:7 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 charsetFindOrAddGlyph::glyph#1 ] ) always clobbers reg byte a +Statement [183] *((byte*) prepareBobs::bob_table#2) ← (byte~) prepareBobs::$6 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 ] ( main:2::prepareBobs:7 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 ] ) always clobbers reg byte y +Statement [184] (byte*) prepareBobs::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 + (byte) 8 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_table#2 prepareBobs::bob_glyph#1 ] ( main:2::prepareBobs:7 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_table#2 prepareBobs::bob_glyph#1 ] ) always clobbers reg byte a +Statement [185] (byte*) prepareBobs::bob_table#1 ← (byte*) prepareBobs::bob_table#2 + (const byte) BOB_SHIFTS_X*(const byte) BOB_SHIFTS_Y [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 ] ( main:2::prepareBobs:7 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 ] ) always clobbers reg byte a +Statement [190] *((byte*) progress_cursor#24) ← *((const byte*) progress_inc::progress_chars+(byte) 8) [ progress_cursor#24 ] ( main:2::prepareBobs:7::progress_inc:186 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 progress_cursor#24 ] ) always clobbers reg byte a reg byte y +Statement [193] *((byte*) progress_cursor#17) ← *((const byte*) progress_inc::progress_chars + (byte) progress_idx#10) [ progress_idx#10 progress_cursor#17 ] ( main:2::prepareBobs:7::progress_inc:186 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 progress_idx#10 progress_cursor#17 ] ) always clobbers reg byte a reg byte y +Statement [203] *((byte*) charsetFindOrAddGlyph::glyph_cursor#11 + (byte) charsetFindOrAddGlyph::i1#2) ← *((byte*) charsetFindOrAddGlyph::glyph#10 + (byte) charsetFindOrAddGlyph::i1#2) [ charsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph_cursor#11 charsetFindOrAddGlyph::i1#2 ] ( main:2::prepareBobs:7::charsetFindOrAddGlyph:162 [ charsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph_cursor#11 charsetFindOrAddGlyph::i1#2 ] main:2::prepareBobs:7::charsetFindOrAddGlyph:180 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 charsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph_cursor#11 charsetFindOrAddGlyph::i1#2 ] ) always clobbers reg byte a +Statement [207] if(*((byte*) charsetFindOrAddGlyph::glyph_cursor#11 + (byte) charsetFindOrAddGlyph::i#2)==*((byte*) charsetFindOrAddGlyph::glyph#10 + (byte) charsetFindOrAddGlyph::i#2)) goto charsetFindOrAddGlyph::@4 [ charsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph_cursor#11 charsetFindOrAddGlyph::i#2 ] ( main:2::prepareBobs:7::charsetFindOrAddGlyph:162 [ charsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph_cursor#11 charsetFindOrAddGlyph::i#2 ] main:2::prepareBobs:7::charsetFindOrAddGlyph:180 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 charsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph_cursor#11 charsetFindOrAddGlyph::i#2 ] ) always clobbers reg byte a +Statement [211] (byte*) charsetFindOrAddGlyph::glyph_cursor#1 ← (byte*) charsetFindOrAddGlyph::glyph_cursor#11 + (byte) 8 [ bob_charset_next_id#23 charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph_id#1 charsetFindOrAddGlyph::glyph_cursor#1 ] ( main:2::prepareBobs:7::charsetFindOrAddGlyph:162 [ bob_charset_next_id#23 charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph_id#1 charsetFindOrAddGlyph::glyph_cursor#1 ] main:2::prepareBobs:7::charsetFindOrAddGlyph:180 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bob_charset_next_id#23 charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph_id#1 charsetFindOrAddGlyph::glyph_cursor#1 ] ) always clobbers reg byte a +Statement [217] (byte~) protoBobShiftRight::$1 ← *((const byte*) PROTO_BOB + (byte) protoBobShiftRight::j#3) & (byte) 1 [ protoBobShiftRight::i#2 protoBobShiftRight::j#3 protoBobShiftRight::carry#2 protoBobShiftRight::$1 ] ( main:2::prepareBobs:7::protoBobShiftRight:175 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 protoBobShiftRight::i#2 protoBobShiftRight::j#3 protoBobShiftRight::carry#2 protoBobShiftRight::$1 ] main:2::prepareBobs:7::protoBobShiftRight:177 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 protoBobShiftRight::i#2 protoBobShiftRight::j#3 protoBobShiftRight::carry#2 protoBobShiftRight::$1 ] ) always clobbers reg byte a +Statement [221] (byte~) protoBobShiftRight::$5 ← *((const byte*) PROTO_BOB + (byte) protoBobShiftRight::j#3) >> (byte) 1 [ protoBobShiftRight::i#2 protoBobShiftRight::j#3 protoBobShiftRight::carry#2 protoBobShiftRight::carry#1 protoBobShiftRight::$5 ] ( main:2::prepareBobs:7::protoBobShiftRight:175 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 protoBobShiftRight::i#2 protoBobShiftRight::j#3 protoBobShiftRight::carry#2 protoBobShiftRight::carry#1 protoBobShiftRight::$5 ] main:2::prepareBobs:7::protoBobShiftRight:177 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 protoBobShiftRight::i#2 protoBobShiftRight::j#3 protoBobShiftRight::carry#2 protoBobShiftRight::carry#1 protoBobShiftRight::$5 ] ) always clobbers reg byte a +Statement [225] (byte) protoBobShiftRight::j#2 ← (byte) protoBobShiftRight::j#3 + (byte) $18 [ protoBobShiftRight::i#2 protoBobShiftRight::carry#1 protoBobShiftRight::j#2 ] ( main:2::prepareBobs:7::protoBobShiftRight:175 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 protoBobShiftRight::i#2 protoBobShiftRight::carry#1 protoBobShiftRight::j#2 ] main:2::prepareBobs:7::protoBobShiftRight:177 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 protoBobShiftRight::i#2 protoBobShiftRight::carry#1 protoBobShiftRight::j#2 ] ) always clobbers reg byte a +Statement [229] (byte) protoBobShiftRight::j#1 ← (byte) protoBobShiftRight::j#3 - (byte) $2f [ protoBobShiftRight::i#2 protoBobShiftRight::carry#1 protoBobShiftRight::j#1 ] ( main:2::prepareBobs:7::protoBobShiftRight:175 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 protoBobShiftRight::i#2 protoBobShiftRight::carry#1 protoBobShiftRight::j#1 ] main:2::prepareBobs:7::protoBobShiftRight:177 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 protoBobShiftRight::i#2 protoBobShiftRight::carry#1 protoBobShiftRight::j#1 ] ) always clobbers reg byte a +Statement [233] *((const byte*) PROTO_BOB) ← (byte) 0 [ ] ( main:2::prepareBobs:7::protoBobShiftDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 ] ) always clobbers reg byte a +Statement [234] *((const byte*) PROTO_BOB+(byte) $18) ← (byte) 0 [ ] ( main:2::prepareBobs:7::protoBobShiftDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 ] ) always clobbers reg byte a +Statement [235] *((const byte*) PROTO_BOB+(byte) $30) ← (byte) 0 [ ] ( main:2::prepareBobs:7::protoBobShiftDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 ] ) always clobbers reg byte a +Statement [237] *((const byte*) PROTO_BOB + (byte) protoBobShiftDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $17 + (byte) protoBobShiftDown::i#2) [ protoBobShiftDown::i#2 ] ( main:2::prepareBobs:7::protoBobShiftDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 protoBobShiftDown::i#2 ] ) always clobbers reg byte a +Statement [238] *((const byte*) PROTO_BOB+(byte) $18 + (byte) protoBobShiftDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $2f + (byte) protoBobShiftDown::i#2) [ protoBobShiftDown::i#2 ] ( main:2::prepareBobs:7::protoBobShiftDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 protoBobShiftDown::i#2 ] ) always clobbers reg byte a +Statement [239] *((const byte*) PROTO_BOB+(byte) $30 + (byte) protoBobShiftDown::i#2) ← (byte) 0 [ protoBobShiftDown::i#2 ] ( main:2::prepareBobs:7::protoBobShiftDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 protoBobShiftDown::i#2 ] ) always clobbers reg byte a +Statement [245] if((byte*) mulf_init::sqr1_lo#2!=(const byte*) mulf_sqr1_lo+(word) $200) goto mulf_init::@2 [ mulf_init::sqr1_lo#2 mulf_init::c#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::c#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 ] ) always clobbers reg byte a +Statement [247] if((byte*) mulf_init::sqr2_lo#2!=(const byte*) mulf_sqr2_lo+(word) $1ff) goto mulf_init::@6 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ( main:2::mulf_init:5 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ) always clobbers reg byte a +Statement [248] *((const byte*) mulf_sqr2_lo+(word) $1ff) ← *((const byte*) mulf_sqr1_lo+(word) $100) [ ] ( main:2::mulf_init:5 [ ] ) always clobbers reg byte a +Statement [249] *((const byte*) mulf_sqr2_hi+(word) $1ff) ← *((const byte*) mulf_sqr1_hi+(word) $100) [ ] ( main:2::mulf_init:5 [ ] ) always clobbers reg byte a +Statement [251] *((byte*) mulf_init::sqr2_lo#2) ← *((const byte*) mulf_sqr1_lo + (byte) mulf_init::x_255#2) [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ( main:2::mulf_init:5 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ) always clobbers reg byte a reg byte y +Statement [252] *((byte*) mulf_init::sqr2_hi#2) ← *((const byte*) mulf_sqr1_hi + (byte) mulf_init::x_255#2) [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ( main:2::mulf_init:5 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ) always clobbers reg byte a reg byte y +Statement [254] (byte) mulf_init::x_255#1 ← (byte) mulf_init::x_255#2 + (byte) mulf_init::dir#2 [ mulf_init::sqr2_lo#2 mulf_init::dir#2 mulf_init::x_255#1 mulf_init::sqr2_hi#1 ] ( main:2::mulf_init:5 [ mulf_init::sqr2_lo#2 mulf_init::dir#2 mulf_init::x_255#1 mulf_init::sqr2_hi#1 ] ) always clobbers reg byte a +Statement [260] (byte~) mulf_init::$1 ← (byte) mulf_init::c#1 & (byte) 1 [ mulf_init::sqr1_lo#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 mulf_init::c#1 mulf_init::$1 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 mulf_init::c#1 mulf_init::$1 ] ) always clobbers reg byte a +Statement [265] (byte~) mulf_init::$4 ← < (word) mulf_init::sqr#3 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$4 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$4 ] ) always clobbers reg byte a +Statement [266] *((byte*) mulf_init::sqr1_lo#2) ← (byte~) mulf_init::$4 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ) always clobbers reg byte y +Statement [267] (byte~) mulf_init::$5 ← > (word) mulf_init::sqr#3 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$5 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$5 ] ) always clobbers reg byte a +Statement [268] *((byte*) mulf_init::sqr1_hi#2) ← (byte~) mulf_init::$5 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ) always clobbers reg byte y +Statement [270] (word) mulf_init::sqr#1 ← (word) mulf_init::sqr#3 + (byte) mulf_init::x_2#2 [ mulf_init::sqr1_lo#2 mulf_init::c#1 mulf_init::sqr#1 mulf_init::sqr1_hi#1 mulf_init::x_2#2 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::c#1 mulf_init::sqr#1 mulf_init::sqr1_hi#1 mulf_init::x_2#2 ] ) always clobbers reg byte a +Potential registers zp[1]:2 [ main::angle#8 main::angle#1 ] : zp[1]:2 , +Potential registers zp[1]:3 [ main::r#2 main::r#1 ] : zp[1]:3 , +Potential registers zp[1]:4 [ main::a#2 main::a#6 main::a#1 ] : zp[1]:4 , +Potential registers zp[2]:5 [ renderBobCleanupNext#17 renderBobCleanupNext#13 ] : zp[2]:5 , +Potential registers zp[1]:7 [ main::i#2 main::i#1 ] : zp[1]:7 , +Potential registers zp[1]:8 [ mulf8s::mulf8s_prepare1_a#0 mulf8s::a#1 mulf8s::a#0 ] : zp[1]:8 , reg byte a , reg byte x , +Potential registers zp[1]:9 [ mulf8s::b#2 mulf8s::b#1 mulf8s::b#0 ] : zp[1]:9 , reg byte x , reg byte y , +Potential registers zp[2]:10 [ mulf8s_prepared::m#4 mulf8s_prepared::m#5 mulf8s_prepared::m#1 mulf8s_prepared::m#0 mulf8s_prepared::m#2 ] : zp[2]:10 , +Potential registers zp[1]:12 [ renderBobCleanup::i#2 renderBobCleanup::i#1 ] : zp[1]:12 , reg byte x , +Potential registers zp[2]:13 [ memset::dst#2 memset::dst#1 ] : zp[2]:13 , +Potential registers zp[1]:15 [ renderBobInit::y#2 renderBobInit::y#1 ] : zp[1]:15 , reg byte x , reg byte y , +Potential registers zp[1]:16 [ renderBobInit::i#2 renderBobInit::i#1 ] : zp[1]:16 , reg byte x , reg byte y , +Potential registers zp[1]:17 [ prepareBobs::shift_y#2 prepareBobs::shift_y#1 ] : zp[1]:17 , reg byte x , +Potential registers zp[2]:18 [ progress_cursor#15 progress_cursor#31 progress_cursor#24 progress_cursor#17 progress_cursor#8 ] : zp[2]:18 , +Potential registers zp[1]:20 [ progress_idx#16 progress_idx#31 progress_idx#25 progress_idx#10 progress_idx#8 ] : zp[1]:20 , reg byte x , +Potential registers zp[1]:21 [ prepareBobs::bob_table_idx#6 prepareBobs::bob_table_idx#12 prepareBobs::bob_table_idx#1 ] : zp[1]:21 , reg byte x , +Potential registers zp[1]:22 [ prepareBobs::shift_x#2 prepareBobs::shift_x#1 ] : zp[1]:22 , reg byte x , +Potential registers zp[1]:23 [ prepareBobs::cell#2 prepareBobs::cell#1 ] : zp[1]:23 , reg byte x , +Potential registers zp[2]:24 [ prepareBobs::bob_glyph#2 prepareBobs::bob_glyph#1 ] : zp[2]:24 , +Potential registers zp[2]:26 [ prepareBobs::bob_table#2 prepareBobs::bob_table#1 prepareBobs::bob_table#0 ] : zp[2]:26 , +Potential registers zp[1]:28 [ bob_charset_next_id#23 bob_charset_next_id#14 bob_charset_next_id#16 bob_charset_next_id#30 bob_charset_next_id#21 bob_charset_next_id#8 ] : zp[1]:28 , reg byte x , +Potential registers zp[2]:29 [ charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph#1 ] : zp[2]:29 , +Potential registers zp[1]:31 [ charsetFindOrAddGlyph::glyph_id#11 charsetFindOrAddGlyph::glyph_id#1 ] : zp[1]:31 , reg byte x , reg byte y , +Potential registers zp[2]:32 [ charsetFindOrAddGlyph::glyph_cursor#11 charsetFindOrAddGlyph::glyph_cursor#1 ] : zp[2]:32 , +Potential registers zp[1]:34 [ charsetFindOrAddGlyph::i1#2 charsetFindOrAddGlyph::i1#1 ] : zp[1]:34 , reg byte x , reg byte y , +Potential registers zp[1]:35 [ charsetFindOrAddGlyph::i#2 charsetFindOrAddGlyph::i#1 ] : zp[1]:35 , reg byte x , reg byte y , +Potential registers zp[1]:36 [ charsetFindOrAddGlyph::found#2 ] : zp[1]:36 , reg byte a , reg byte x , reg byte y , +Potential registers zp[1]:37 [ protoBobShiftRight::i#2 protoBobShiftRight::i#1 ] : zp[1]:37 , reg byte x , reg byte y , +Potential registers zp[1]:38 [ protoBobShiftRight::j#3 protoBobShiftRight::j#10 protoBobShiftRight::j#2 protoBobShiftRight::j#1 ] : zp[1]:38 , reg byte x , reg byte y , +Potential registers zp[1]:39 [ protoBobShiftRight::carry#2 protoBobShiftRight::carry#10 ] : zp[1]:39 , reg byte x , reg byte y , +Potential registers zp[1]:40 [ protoBobShiftRight::carry#1 ] : zp[1]:40 , reg byte x , reg byte y , +Potential registers zp[1]:41 [ protoBobShiftDown::i#2 protoBobShiftDown::i#1 ] : zp[1]:41 , reg byte x , reg byte y , +Potential registers zp[2]:42 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_lo#1 ] : zp[2]:42 , +Potential registers zp[1]:44 [ mulf_init::c#2 mulf_init::c#1 ] : zp[1]:44 , reg byte x , +Potential registers zp[2]:45 [ mulf_init::sqr1_hi#2 mulf_init::sqr1_hi#1 ] : zp[2]:45 , +Potential registers zp[1]:47 [ mulf_init::x_2#3 mulf_init::x_2#2 mulf_init::x_2#1 ] : zp[1]:47 , reg byte x , +Potential registers zp[2]:48 [ mulf_init::sqr2_lo#2 mulf_init::sqr2_lo#1 ] : zp[2]:48 , +Potential registers zp[1]:50 [ mulf_init::x_255#2 mulf_init::x_255#1 ] : zp[1]:50 , reg byte x , +Potential registers zp[2]:51 [ mulf_init::sqr2_hi#2 mulf_init::sqr2_hi#1 ] : zp[2]:51 , +Potential registers zp[1]:53 [ mulf_init::dir#2 mulf_init::dir#4 ] : zp[1]:53 , reg byte x , +Potential registers zp[2]:54 [ mulf_init::sqr#3 mulf_init::sqr#4 mulf_init::sqr#1 mulf_init::sqr#2 ] : zp[2]:54 , +Potential registers zp[2]:56 [ mulf8s::return#2 ] : zp[2]:56 , +Potential registers zp[2]:58 [ main::$10 ] : zp[2]:58 , +Potential registers zp[2]:60 [ main::x#0 ] : zp[2]:60 , +Potential registers zp[2]:62 [ mulf8s::return#3 ] : zp[2]:62 , +Potential registers zp[2]:64 [ main::$12 ] : zp[2]:64 , +Potential registers zp[2]:66 [ main::$13 ] : zp[2]:66 , +Potential registers zp[2]:68 [ main::y#0 ] : zp[2]:68 , +Potential registers zp[1]:70 [ renderBob::xpos#0 ] : zp[1]:70 , reg byte x , reg byte y , +Potential registers zp[1]:71 [ renderBob::ypos#0 ] : zp[1]:71 , reg byte x , reg byte y , +Potential registers zp[1]:72 [ keyboard_key_pressed::return#2 ] : zp[1]:72 , reg byte a , reg byte x , reg byte y , +Potential registers zp[1]:73 [ main::$19 ] : zp[1]:73 , reg byte a , reg byte x , reg byte y , +Potential registers zp[1]:74 [ keyboard_key_pressed::return#3 ] : zp[1]:74 , reg byte a , reg byte x , reg byte y , +Potential registers zp[1]:75 [ main::$21 ] : zp[1]:75 , reg byte a , reg byte x , reg byte y , +Potential registers zp[1]:76 [ keyboard_matrix_read::return#2 ] : zp[1]:76 , reg byte a , reg byte x , reg byte y , +Potential registers zp[1]:77 [ keyboard_key_pressed::$2 ] : zp[1]:77 , reg byte a , reg byte x , reg byte y , +Potential registers zp[1]:78 [ keyboard_key_pressed::return#0 ] : zp[1]:78 , reg byte a , reg byte x , reg byte y , +Potential registers zp[1]:79 [ keyboard_matrix_read::return#0 ] : zp[1]:79 , reg byte a , reg byte x , reg byte y , +Potential registers zp[1]:80 [ renderBob::x_char_offset#0 ] : zp[1]:80 , reg byte x , reg byte y , +Potential registers zp[1]:81 [ renderBob::y_char_offset#0 ] : zp[1]:81 , reg byte a , reg byte x , reg byte y , +Potential registers zp[1]:82 [ renderBob::$8 ] : zp[1]:82 , reg byte a , reg byte x , reg byte y , +Potential registers zp[2]:83 [ renderBob::y_offset#0 ] : zp[2]:83 , +Potential registers zp[2]:85 [ renderBob::$2 ] : zp[2]:85 , +Potential registers zp[2]:87 [ renderBob::screen#0 ] : zp[2]:87 , +Potential registers zp[1]:89 [ renderBob::$4 ] : zp[1]:89 , reg byte a , reg byte x , reg byte y , +Potential registers zp[1]:90 [ renderBob::$5 ] : zp[1]:90 , reg byte x , reg byte y , +Potential registers zp[1]:91 [ renderBob::$6 ] : zp[1]:91 , reg byte a , reg byte x , reg byte y , +Potential registers zp[1]:92 [ renderBob::bob_table_idx#0 ] : zp[1]:92 , reg byte x , +Potential registers zp[1]:93 [ mulf8u_prepare::a#0 ] : zp[1]:93 , reg byte a , reg byte x , reg byte y , +Potential registers zp[1]:94 [ mulf8s_prepared::b#0 ] : zp[1]:94 , reg byte y , +Potential registers zp[2]:95 [ mulf8s::return#0 ] : zp[2]:95 , +Potential registers zp[1]:97 [ mulf8u_prepared::b#0 ] : zp[1]:97 , reg byte a , reg byte x , reg byte y , +Potential registers zp[2]:98 [ mulf8u_prepared::return#2 ] : zp[2]:98 , +Potential registers zp[1]:100 [ mulf8s_prepared::$8 ] : zp[1]:100 , reg byte a , reg byte x , reg byte y , +Potential registers zp[1]:101 [ mulf8s_prepared::$15 ] : zp[1]:101 , reg byte a , reg byte x , reg byte y , +Potential registers zp[1]:102 [ mulf8s_prepared::$12 ] : zp[1]:102 , reg byte a , reg byte x , reg byte y , +Potential registers zp[1]:103 [ mulf8s_prepared::$16 ] : zp[1]:103 , reg byte a , reg byte x , reg byte y , +Potential registers zp[2]:104 [ mulf8u_prepared::return#0 ] : zp[2]:104 , +Potential registers zp[1]:106 [ renderBobCleanup::$1 ] : zp[1]:106 , reg byte a , reg byte x , reg byte y , +Potential registers zp[2]:107 [ renderBobCleanup::screen#0 ] : zp[2]:107 , +Potential registers zp[2]:109 [ renderBobInit::$0 ] : zp[2]:109 , +Potential registers zp[2]:111 [ renderBobInit::$6 ] : zp[2]:111 , +Potential registers zp[2]:113 [ renderBobInit::$7 ] : zp[2]:113 , +Potential registers zp[2]:115 [ renderBobInit::$1 ] : zp[2]:115 , +Potential registers zp[1]:117 [ renderBobInit::$4 ] : zp[1]:117 , reg byte a , reg byte x , reg byte y , +Potential registers zp[1]:118 [ renderBobInit::$5 ] : zp[1]:118 , reg byte a , reg byte x , reg byte y , +Potential registers zp[1]:119 [ charsetFindOrAddGlyph::return#1 ] : zp[1]:119 , reg byte a , reg byte x , reg byte y , +Potential registers zp[1]:120 [ prepareBobs::$6 ] : zp[1]:120 , reg byte a , reg byte x , reg byte y , +Potential registers zp[1]:121 [ protoBobShiftRight::$1 ] : zp[1]:121 , reg byte a , reg byte x , reg byte y , +Potential registers zp[1]:122 [ protoBobShiftRight::$5 ] : zp[1]:122 , reg byte a , reg byte x , reg byte y , +Potential registers zp[1]:123 [ protoBobShiftRight::$6 ] : zp[1]:123 , reg byte a , reg byte x , reg byte y , +Potential registers zp[1]:124 [ mulf_init::$1 ] : zp[1]:124 , reg byte a , reg byte x , reg byte y , +Potential registers zp[1]:125 [ mulf_init::$4 ] : zp[1]:125 , reg byte a , reg byte x , reg byte y , +Potential registers zp[1]:126 [ mulf_init::$5 ] : zp[1]:126 , reg byte a , reg byte x , reg byte y , + +REGISTER UPLIFT SCOPES +Uplift Scope [charsetFindOrAddGlyph] 366,670.33: zp[1]:35 [ charsetFindOrAddGlyph::i#2 charsetFindOrAddGlyph::i#1 ] 36,670.33: zp[1]:34 [ charsetFindOrAddGlyph::i1#2 charsetFindOrAddGlyph::i1#1 ] 30,002.31: zp[2]:32 [ charsetFindOrAddGlyph::glyph_cursor#11 charsetFindOrAddGlyph::glyph_cursor#1 ] 11,938.75: zp[1]:31 [ charsetFindOrAddGlyph::glyph_id#11 charsetFindOrAddGlyph::glyph_id#1 ] 10,001: zp[1]:36 [ charsetFindOrAddGlyph::found#2 ] 9,402.2: zp[2]:29 [ charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph#1 ] 2,002: zp[1]:119 [ charsetFindOrAddGlyph::return#1 ] +Uplift Scope [protoBobShiftRight] 5,705.7: zp[1]:38 [ protoBobShiftRight::j#3 protoBobShiftRight::j#10 protoBobShiftRight::j#2 protoBobShiftRight::j#1 ] 2,288: zp[1]:39 [ protoBobShiftRight::carry#2 protoBobShiftRight::carry#10 ] 2,002: zp[1]:121 [ protoBobShiftRight::$1 ] 2,002: zp[1]:122 [ protoBobShiftRight::$5 ] 2,002: zp[1]:123 [ protoBobShiftRight::$6 ] 1,232: zp[1]:37 [ protoBobShiftRight::i#2 protoBobShiftRight::i#1 ] 111.22: zp[1]:40 [ protoBobShiftRight::carry#1 ] +Uplift Scope [prepareBobs] 2,302.3: zp[1]:23 [ prepareBobs::cell#2 prepareBobs::cell#1 ] 2,002: zp[1]:120 [ prepareBobs::$6 ] 1,257.33: zp[2]:26 [ prepareBobs::bob_table#2 prepareBobs::bob_table#1 prepareBobs::bob_table#0 ] 929.5: zp[2]:24 [ prepareBobs::bob_glyph#2 prepareBobs::bob_glyph#1 ] 218.83: zp[1]:22 [ prepareBobs::shift_x#2 prepareBobs::shift_x#1 ] 70.52: zp[1]:21 [ prepareBobs::bob_table_idx#6 prepareBobs::bob_table_idx#12 prepareBobs::bob_table_idx#1 ] 23.43: zp[1]:17 [ prepareBobs::shift_y#2 prepareBobs::shift_y#1 ] +Uplift Scope [] 2,729.71: zp[1]:28 [ bob_charset_next_id#23 bob_charset_next_id#14 bob_charset_next_id#16 bob_charset_next_id#30 bob_charset_next_id#21 bob_charset_next_id#8 ] 338.4: zp[1]:20 [ progress_idx#16 progress_idx#31 progress_idx#25 progress_idx#10 progress_idx#8 ] 324.85: zp[2]:18 [ progress_cursor#15 progress_cursor#31 progress_cursor#24 progress_cursor#17 progress_cursor#8 ] 10.74: zp[2]:5 [ renderBobCleanupNext#17 renderBobCleanupNext#13 ] +Uplift Scope [mulf8s] 472: zp[1]:9 [ mulf8s::b#2 mulf8s::b#1 mulf8s::b#0 ] 404: zp[1]:8 [ mulf8s::mulf8s_prepare1_a#0 mulf8s::a#1 mulf8s::a#0 ] 202: zp[2]:56 [ mulf8s::return#2 ] 202: zp[2]:62 [ mulf8s::return#3 ] 51: zp[2]:95 [ mulf8s::return#0 ] +Uplift Scope [main] 202: zp[2]:58 [ main::$10 ] 202: zp[2]:64 [ main::$12 ] 202: zp[2]:66 [ main::$13 ] 161.12: zp[1]:7 [ main::i#2 main::i#1 ] 76.79: zp[1]:4 [ main::a#2 main::a#6 main::a#1 ] 57.43: zp[1]:3 [ main::r#2 main::r#1 ] 40.4: zp[2]:68 [ main::y#0 ] 22: zp[1]:73 [ main::$19 ] 22: zp[1]:75 [ main::$21 ] 18.36: zp[2]:60 [ main::x#0 ] 4.85: zp[1]:2 [ main::angle#8 main::angle#1 ] +Uplift Scope [renderBobCleanup] 202: zp[1]:106 [ renderBobCleanup::$1 ] 176.75: zp[1]:12 [ renderBobCleanup::i#2 renderBobCleanup::i#1 ] 112.22: zp[2]:107 [ renderBobCleanup::screen#0 ] +Uplift Scope [protoBobShiftDown] 363.6: zp[1]:41 [ protoBobShiftDown::i#2 protoBobShiftDown::i#1 ] +Uplift Scope [mulf_init] 47.67: zp[2]:54 [ mulf_init::sqr#3 mulf_init::sqr#4 mulf_init::sqr#1 mulf_init::sqr#2 ] 26.89: zp[2]:48 [ mulf_init::sqr2_lo#2 mulf_init::sqr2_lo#1 ] 25.14: zp[2]:42 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_lo#1 ] 23.1: zp[1]:47 [ mulf_init::x_2#3 mulf_init::x_2#2 mulf_init::x_2#1 ] 22: zp[1]:124 [ mulf_init::$1 ] 22: zp[1]:125 [ mulf_init::$4 ] 22: zp[1]:126 [ mulf_init::$5 ] 15.4: zp[1]:50 [ mulf_init::x_255#2 mulf_init::x_255#1 ] 15.12: zp[1]:53 [ mulf_init::dir#2 mulf_init::dir#4 ] 13.54: zp[1]:44 [ mulf_init::c#2 mulf_init::c#1 ] 11.92: zp[2]:51 [ mulf_init::sqr2_hi#2 mulf_init::sqr2_hi#1 ] 10.08: zp[2]:45 [ mulf_init::sqr1_hi#2 mulf_init::sqr1_hi#1 ] +Uplift Scope [renderBobInit] 27.5: zp[1]:16 [ renderBobInit::i#2 renderBobInit::i#1 ] 22: zp[2]:111 [ renderBobInit::$6 ] 22: zp[2]:113 [ renderBobInit::$7 ] 22: zp[1]:117 [ renderBobInit::$4 ] 22: zp[1]:118 [ renderBobInit::$5 ] 21.21: zp[1]:15 [ renderBobInit::y#2 renderBobInit::y#1 ] 16.5: zp[2]:109 [ renderBobInit::$0 ] 11: zp[2]:115 [ renderBobInit::$1 ] +Uplift Scope [renderBob] 15: zp[1]:71 [ renderBob::ypos#0 ] 10.5: zp[1]:70 [ renderBob::xpos#0 ] 4: zp[1]:81 [ renderBob::y_char_offset#0 ] 4: zp[1]:82 [ renderBob::$8 ] 4: zp[2]:83 [ renderBob::y_offset#0 ] 4: zp[2]:85 [ renderBob::$2 ] 4: zp[1]:89 [ renderBob::$4 ] 4: zp[1]:91 [ renderBob::$6 ] 2: zp[1]:90 [ renderBob::$5 ] 1.82: zp[1]:92 [ renderBob::bob_table_idx#0 ] 1.47: zp[2]:87 [ renderBob::screen#0 ] 0.8: zp[1]:80 [ renderBob::x_char_offset#0 ] +Uplift Scope [keyboard_key_pressed] 22: zp[1]:72 [ keyboard_key_pressed::return#2 ] 22: zp[1]:74 [ keyboard_key_pressed::return#3 ] 6: zp[1]:78 [ keyboard_key_pressed::return#0 ] 4: zp[1]:77 [ keyboard_key_pressed::$2 ] +Uplift Scope [memset] 36.67: zp[2]:13 [ memset::dst#2 memset::dst#1 ] +Uplift Scope [mulf8s_prepared] 13.83: zp[2]:10 [ mulf8s_prepared::m#4 mulf8s_prepared::m#5 mulf8s_prepared::m#1 mulf8s_prepared::m#0 mulf8s_prepared::m#2 ] 4: zp[1]:100 [ mulf8s_prepared::$8 ] 4: zp[1]:101 [ mulf8s_prepared::$15 ] 4: zp[1]:102 [ mulf8s_prepared::$12 ] 4: zp[1]:103 [ mulf8s_prepared::$16 ] 0.4: zp[1]:94 [ mulf8s_prepared::b#0 ] +Uplift Scope [mulf8u_prepared] 4: zp[1]:97 [ mulf8u_prepared::b#0 ] 4: zp[2]:98 [ mulf8u_prepared::return#2 ] 1.33: zp[2]:104 [ mulf8u_prepared::return#0 ] +Uplift Scope [keyboard_matrix_read] 4: zp[1]:76 [ keyboard_matrix_read::return#2 ] 1.33: zp[1]:79 [ keyboard_matrix_read::return#0 ] +Uplift Scope [mulf8u_prepare] 4: zp[1]:93 [ mulf8u_prepare::a#0 ] +Uplift Scope [RADIX] +Uplift Scope [progress_init] +Uplift Scope [progress_inc] + +Uplifting [charsetFindOrAddGlyph] best 4014542 combination reg byte y [ charsetFindOrAddGlyph::i#2 charsetFindOrAddGlyph::i#1 ] reg byte y [ charsetFindOrAddGlyph::i1#2 charsetFindOrAddGlyph::i1#1 ] zp[2]:32 [ charsetFindOrAddGlyph::glyph_cursor#11 charsetFindOrAddGlyph::glyph_cursor#1 ] reg byte x [ charsetFindOrAddGlyph::glyph_id#11 charsetFindOrAddGlyph::glyph_id#1 ] reg byte a [ charsetFindOrAddGlyph::found#2 ] zp[2]:29 [ charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph#1 ] zp[1]:119 [ charsetFindOrAddGlyph::return#1 ] +Limited combination testing to 100 combinations of 432 possible. +Uplifting [protoBobShiftRight] best 3976542 combination reg byte x [ protoBobShiftRight::j#3 protoBobShiftRight::j#10 protoBobShiftRight::j#2 protoBobShiftRight::j#1 ] reg byte y [ protoBobShiftRight::carry#2 protoBobShiftRight::carry#10 ] reg byte a [ protoBobShiftRight::$1 ] reg byte a [ protoBobShiftRight::$5 ] zp[1]:123 [ protoBobShiftRight::$6 ] zp[1]:37 [ protoBobShiftRight::i#2 protoBobShiftRight::i#1 ] zp[1]:40 [ protoBobShiftRight::carry#1 ] +Limited combination testing to 100 combinations of 5184 possible. +Uplifting [prepareBobs] best 3970542 combination zp[1]:23 [ prepareBobs::cell#2 prepareBobs::cell#1 ] reg byte a [ prepareBobs::$6 ] zp[2]:26 [ prepareBobs::bob_table#2 prepareBobs::bob_table#1 prepareBobs::bob_table#0 ] zp[2]:24 [ prepareBobs::bob_glyph#2 prepareBobs::bob_glyph#1 ] zp[1]:22 [ prepareBobs::shift_x#2 prepareBobs::shift_x#1 ] zp[1]:21 [ prepareBobs::bob_table_idx#6 prepareBobs::bob_table_idx#12 prepareBobs::bob_table_idx#1 ] zp[1]:17 [ prepareBobs::shift_y#2 prepareBobs::shift_y#1 ] +Uplifting [] best 3970542 combination zp[1]:28 [ bob_charset_next_id#23 bob_charset_next_id#14 bob_charset_next_id#16 bob_charset_next_id#30 bob_charset_next_id#21 bob_charset_next_id#8 ] zp[1]:20 [ progress_idx#16 progress_idx#31 progress_idx#25 progress_idx#10 progress_idx#8 ] zp[2]:18 [ progress_cursor#15 progress_cursor#31 progress_cursor#24 progress_cursor#17 progress_cursor#8 ] zp[2]:5 [ renderBobCleanupNext#17 renderBobCleanupNext#13 ] +Uplifting [mulf8s] best 3969336 combination reg byte x [ mulf8s::b#2 mulf8s::b#1 mulf8s::b#0 ] reg byte a [ mulf8s::mulf8s_prepare1_a#0 mulf8s::a#1 mulf8s::a#0 ] zp[2]:56 [ mulf8s::return#2 ] zp[2]:62 [ mulf8s::return#3 ] zp[2]:95 [ mulf8s::return#0 ] +Uplifting [main] best 3969216 combination zp[2]:58 [ main::$10 ] zp[2]:64 [ main::$12 ] zp[2]:66 [ main::$13 ] zp[1]:7 [ main::i#2 main::i#1 ] zp[1]:4 [ main::a#2 main::a#6 main::a#1 ] zp[1]:3 [ main::r#2 main::r#1 ] zp[2]:68 [ main::y#0 ] reg byte a [ main::$19 ] reg byte a [ main::$21 ] zp[2]:60 [ main::x#0 ] zp[1]:2 [ main::angle#8 main::angle#1 ] +Uplifting [renderBobCleanup] best 3967816 combination reg byte a [ renderBobCleanup::$1 ] reg byte x [ renderBobCleanup::i#2 renderBobCleanup::i#1 ] zp[2]:107 [ renderBobCleanup::screen#0 ] +Uplifting [protoBobShiftDown] best 3966216 combination reg byte x [ protoBobShiftDown::i#2 protoBobShiftDown::i#1 ] +Uplifting [mulf_init] best 3965966 combination zp[2]:54 [ mulf_init::sqr#3 mulf_init::sqr#4 mulf_init::sqr#1 mulf_init::sqr#2 ] zp[2]:48 [ mulf_init::sqr2_lo#2 mulf_init::sqr2_lo#1 ] zp[2]:42 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_lo#1 ] reg byte x [ mulf_init::x_2#3 mulf_init::x_2#2 mulf_init::x_2#1 ] reg byte a [ mulf_init::$1 ] reg byte a [ mulf_init::$4 ] reg byte a [ mulf_init::$5 ] zp[1]:50 [ mulf_init::x_255#2 mulf_init::x_255#1 ] zp[1]:53 [ mulf_init::dir#2 mulf_init::dir#4 ] zp[1]:44 [ mulf_init::c#2 mulf_init::c#1 ] zp[2]:51 [ mulf_init::sqr2_hi#2 mulf_init::sqr2_hi#1 ] zp[2]:45 [ mulf_init::sqr1_hi#2 mulf_init::sqr1_hi#1 ] +Limited combination testing to 100 combinations of 1024 possible. +Uplifting [renderBobInit] best 3965676 combination reg byte x [ renderBobInit::i#2 renderBobInit::i#1 ] zp[2]:111 [ renderBobInit::$6 ] zp[2]:113 [ renderBobInit::$7 ] reg byte a [ renderBobInit::$4 ] reg byte a [ renderBobInit::$5 ] reg byte x [ renderBobInit::y#2 renderBobInit::y#1 ] zp[2]:109 [ renderBobInit::$0 ] zp[2]:115 [ renderBobInit::$1 ] +Limited combination testing to 100 combinations of 144 possible. +Uplifting [renderBob] best 3965562 combination reg byte x [ renderBob::ypos#0 ] zp[1]:70 [ renderBob::xpos#0 ] reg byte a [ renderBob::y_char_offset#0 ] reg byte a [ renderBob::$8 ] zp[2]:83 [ renderBob::y_offset#0 ] zp[2]:85 [ renderBob::$2 ] zp[1]:89 [ renderBob::$4 ] zp[1]:91 [ renderBob::$6 ] zp[1]:90 [ renderBob::$5 ] zp[1]:92 [ renderBob::bob_table_idx#0 ] zp[2]:87 [ renderBob::screen#0 ] zp[1]:80 [ renderBob::x_char_offset#0 ] +Limited combination testing to 100 combinations of 41472 possible. +Uplifting [keyboard_key_pressed] best 3965373 combination reg byte a [ keyboard_key_pressed::return#2 ] reg byte a [ keyboard_key_pressed::return#3 ] reg byte a [ keyboard_key_pressed::return#0 ] reg byte a [ keyboard_key_pressed::$2 ] +Limited combination testing to 100 combinations of 256 possible. +Uplifting [memset] best 3965373 combination zp[2]:13 [ memset::dst#2 memset::dst#1 ] +Uplifting [mulf8s_prepared] best 3965349 combination zp[2]:10 [ mulf8s_prepared::m#4 mulf8s_prepared::m#5 mulf8s_prepared::m#1 mulf8s_prepared::m#0 mulf8s_prepared::m#2 ] reg byte a [ mulf8s_prepared::$8 ] reg byte a [ mulf8s_prepared::$15 ] reg byte a [ mulf8s_prepared::$12 ] reg byte a [ mulf8s_prepared::$16 ] zp[1]:94 [ mulf8s_prepared::b#0 ] +Limited combination testing to 100 combinations of 512 possible. +Uplifting [mulf8u_prepared] best 3965343 combination reg byte a [ mulf8u_prepared::b#0 ] zp[2]:98 [ mulf8u_prepared::return#2 ] zp[2]:104 [ mulf8u_prepared::return#0 ] +Uplifting [keyboard_matrix_read] best 3965331 combination reg byte a [ keyboard_matrix_read::return#2 ] reg byte a [ keyboard_matrix_read::return#0 ] +Uplifting [mulf8u_prepare] best 3965325 combination reg byte a [ mulf8u_prepare::a#0 ] +Uplifting [RADIX] best 3965325 combination +Uplifting [progress_init] best 3965325 combination +Uplifting [progress_inc] best 3965325 combination +Attempting to uplift remaining variables inzp[1]:28 [ bob_charset_next_id#23 bob_charset_next_id#14 bob_charset_next_id#16 bob_charset_next_id#30 bob_charset_next_id#21 bob_charset_next_id#8 ] +Uplifting [] best 3965325 combination zp[1]:28 [ bob_charset_next_id#23 bob_charset_next_id#14 bob_charset_next_id#16 bob_charset_next_id#30 bob_charset_next_id#21 bob_charset_next_id#8 ] +Attempting to uplift remaining variables inzp[1]:23 [ prepareBobs::cell#2 prepareBobs::cell#1 ] +Uplifting [prepareBobs] best 3965325 combination zp[1]:23 [ prepareBobs::cell#2 prepareBobs::cell#1 ] +Attempting to uplift remaining variables inzp[1]:119 [ charsetFindOrAddGlyph::return#1 ] +Uplifting [charsetFindOrAddGlyph] best 3961325 combination reg byte a [ charsetFindOrAddGlyph::return#1 ] +Attempting to uplift remaining variables inzp[1]:123 [ protoBobShiftRight::$6 ] +Uplifting [protoBobShiftRight] best 3955325 combination reg byte a [ protoBobShiftRight::$6 ] +Attempting to uplift remaining variables inzp[1]:37 [ protoBobShiftRight::i#2 protoBobShiftRight::i#1 ] +Uplifting [protoBobShiftRight] best 3955325 combination zp[1]:37 [ protoBobShiftRight::i#2 protoBobShiftRight::i#1 ] +Attempting to uplift remaining variables inzp[1]:20 [ progress_idx#16 progress_idx#31 progress_idx#25 progress_idx#10 progress_idx#8 ] +Uplifting [] best 3955325 combination zp[1]:20 [ progress_idx#16 progress_idx#31 progress_idx#25 progress_idx#10 progress_idx#8 ] +Attempting to uplift remaining variables inzp[1]:22 [ prepareBobs::shift_x#2 prepareBobs::shift_x#1 ] +Uplifting [prepareBobs] best 3955325 combination zp[1]:22 [ prepareBobs::shift_x#2 prepareBobs::shift_x#1 ] +Attempting to uplift remaining variables inzp[1]:7 [ main::i#2 main::i#1 ] +Uplifting [main] best 3955325 combination zp[1]:7 [ main::i#2 main::i#1 ] +Attempting to uplift remaining variables inzp[1]:40 [ protoBobShiftRight::carry#1 ] +Uplifting [protoBobShiftRight] best 3955325 combination zp[1]:40 [ protoBobShiftRight::carry#1 ] +Attempting to uplift remaining variables inzp[1]:4 [ main::a#2 main::a#6 main::a#1 ] +Uplifting [main] best 3955325 combination zp[1]:4 [ main::a#2 main::a#6 main::a#1 ] +Attempting to uplift remaining variables inzp[1]:21 [ prepareBobs::bob_table_idx#6 prepareBobs::bob_table_idx#12 prepareBobs::bob_table_idx#1 ] +Uplifting [prepareBobs] best 3955325 combination zp[1]:21 [ prepareBobs::bob_table_idx#6 prepareBobs::bob_table_idx#12 prepareBobs::bob_table_idx#1 ] +Attempting to uplift remaining variables inzp[1]:3 [ main::r#2 main::r#1 ] +Uplifting [main] best 3955325 combination zp[1]:3 [ main::r#2 main::r#1 ] +Attempting to uplift remaining variables inzp[1]:17 [ prepareBobs::shift_y#2 prepareBobs::shift_y#1 ] +Uplifting [prepareBobs] best 3955325 combination zp[1]:17 [ prepareBobs::shift_y#2 prepareBobs::shift_y#1 ] +Attempting to uplift remaining variables inzp[1]:50 [ mulf_init::x_255#2 mulf_init::x_255#1 ] +Uplifting [mulf_init] best 3955185 combination reg byte x [ mulf_init::x_255#2 mulf_init::x_255#1 ] +Attempting to uplift remaining variables inzp[1]:53 [ mulf_init::dir#2 mulf_init::dir#4 ] +Uplifting [mulf_init] best 3955185 combination zp[1]:53 [ mulf_init::dir#2 mulf_init::dir#4 ] +Attempting to uplift remaining variables inzp[1]:44 [ mulf_init::c#2 mulf_init::c#1 ] +Uplifting [mulf_init] best 3955185 combination zp[1]:44 [ mulf_init::c#2 mulf_init::c#1 ] +Attempting to uplift remaining variables inzp[1]:70 [ renderBob::xpos#0 ] +Uplifting [renderBob] best 3955185 combination zp[1]:70 [ renderBob::xpos#0 ] +Attempting to uplift remaining variables inzp[1]:2 [ main::angle#8 main::angle#1 ] +Uplifting [main] best 3955185 combination zp[1]:2 [ main::angle#8 main::angle#1 ] +Attempting to uplift remaining variables inzp[1]:89 [ renderBob::$4 ] +Uplifting [renderBob] best 3955181 combination reg byte a [ renderBob::$4 ] +Attempting to uplift remaining variables inzp[1]:91 [ renderBob::$6 ] +Uplifting [renderBob] best 3955175 combination reg byte a [ renderBob::$6 ] +Attempting to uplift remaining variables inzp[1]:90 [ renderBob::$5 ] +Uplifting [renderBob] best 3955175 combination zp[1]:90 [ renderBob::$5 ] +Attempting to uplift remaining variables inzp[1]:92 [ renderBob::bob_table_idx#0 ] +Uplifting [renderBob] best 3955147 combination reg byte x [ renderBob::bob_table_idx#0 ] +Attempting to uplift remaining variables inzp[1]:80 [ renderBob::x_char_offset#0 ] +Uplifting [renderBob] best 3955147 combination zp[1]:80 [ renderBob::x_char_offset#0 ] +Attempting to uplift remaining variables inzp[1]:94 [ mulf8s_prepared::b#0 ] +Uplifting [mulf8s_prepared] best 3955147 combination zp[1]:94 [ mulf8s_prepared::b#0 ] +Coalescing zero page register [ zp[2]:10 [ mulf8s_prepared::m#4 mulf8s_prepared::m#5 mulf8s_prepared::m#1 mulf8s_prepared::m#0 mulf8s_prepared::m#2 ] ] with [ zp[2]:95 [ mulf8s::return#0 ] ] - score: 1 +Coalescing zero page register [ zp[2]:10 [ mulf8s_prepared::m#4 mulf8s_prepared::m#5 mulf8s_prepared::m#1 mulf8s_prepared::m#0 mulf8s_prepared::m#2 mulf8s::return#0 ] ] with [ zp[2]:98 [ mulf8u_prepared::return#2 ] ] - score: 1 +Coalescing zero page register [ zp[2]:24 [ prepareBobs::bob_glyph#2 prepareBobs::bob_glyph#1 ] ] with [ zp[2]:29 [ charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph#1 ] ] - score: 1 +Coalescing zero page register [ zp[2]:56 [ mulf8s::return#2 ] ] with [ zp[2]:58 [ main::$10 ] ] - score: 1 +Coalescing zero page register [ zp[2]:62 [ mulf8s::return#3 ] ] with [ zp[2]:64 [ main::$12 ] ] - score: 1 +Coalescing zero page register [ zp[2]:66 [ main::$13 ] ] with [ zp[2]:68 [ main::y#0 ] ] - score: 1 +Coalescing zero page register [ zp[2]:83 [ renderBob::y_offset#0 ] ] with [ zp[2]:85 [ renderBob::$2 ] ] - score: 1 +Coalescing zero page register [ zp[2]:109 [ renderBobInit::$0 ] ] with [ zp[2]:113 [ renderBobInit::$7 ] ] - score: 1 +Coalescing zero page register [ zp[2]:10 [ mulf8s_prepared::m#4 mulf8s_prepared::m#5 mulf8s_prepared::m#1 mulf8s_prepared::m#0 mulf8s_prepared::m#2 mulf8s::return#0 mulf8u_prepared::return#2 ] ] with [ zp[2]:56 [ mulf8s::return#2 main::$10 ] ] - score: 1 +Coalescing zero page register [ zp[2]:10 [ mulf8s_prepared::m#4 mulf8s_prepared::m#5 mulf8s_prepared::m#1 mulf8s_prepared::m#0 mulf8s_prepared::m#2 mulf8s::return#0 mulf8u_prepared::return#2 mulf8s::return#2 main::$10 ] ] with [ zp[2]:62 [ mulf8s::return#3 main::$12 ] ] - score: 1 +Coalescing zero page register [ zp[2]:10 [ mulf8s_prepared::m#4 mulf8s_prepared::m#5 mulf8s_prepared::m#1 mulf8s_prepared::m#0 mulf8s_prepared::m#2 mulf8s::return#0 mulf8u_prepared::return#2 mulf8s::return#2 main::$10 mulf8s::return#3 main::$12 ] ] with [ zp[2]:104 [ mulf8u_prepared::return#0 ] ] - score: 1 +Coalescing zero page register [ zp[2]:83 [ renderBob::y_offset#0 renderBob::$2 ] ] with [ zp[2]:87 [ renderBob::screen#0 ] ] - score: 1 +Coalescing zero page register [ zp[2]:109 [ renderBobInit::$0 renderBobInit::$7 ] ] with [ zp[2]:115 [ renderBobInit::$1 ] ] - score: 1 +Coalescing zero page register [ zp[2]:10 [ mulf8s_prepared::m#4 mulf8s_prepared::m#5 mulf8s_prepared::m#1 mulf8s_prepared::m#0 mulf8s_prepared::m#2 mulf8s::return#0 mulf8u_prepared::return#2 mulf8s::return#2 main::$10 mulf8s::return#3 main::$12 mulf8u_prepared::return#0 ] ] with [ zp[2]:66 [ main::$13 main::y#0 ] ] - score: 1 +Coalescing zero page register [ zp[2]:13 [ memset::dst#2 memset::dst#1 ] ] with [ zp[2]:5 [ renderBobCleanupNext#17 renderBobCleanupNext#13 ] ] +Coalescing zero page register [ zp[1]:17 [ prepareBobs::shift_y#2 prepareBobs::shift_y#1 ] ] with [ zp[1]:2 [ main::angle#8 main::angle#1 ] ] +Coalescing zero page register [ zp[2]:18 [ progress_cursor#15 progress_cursor#31 progress_cursor#24 progress_cursor#17 progress_cursor#8 ] ] with [ zp[2]:10 [ mulf8s_prepared::m#4 mulf8s_prepared::m#5 mulf8s_prepared::m#1 mulf8s_prepared::m#0 mulf8s_prepared::m#2 mulf8s::return#0 mulf8u_prepared::return#2 mulf8s::return#2 main::$10 mulf8s::return#3 main::$12 mulf8u_prepared::return#0 main::$13 main::y#0 ] ] +Coalescing zero page register [ zp[1]:20 [ progress_idx#16 progress_idx#31 progress_idx#25 progress_idx#10 progress_idx#8 ] ] with [ zp[1]:3 [ main::r#2 main::r#1 ] ] +Coalescing zero page register [ zp[1]:21 [ prepareBobs::bob_table_idx#6 prepareBobs::bob_table_idx#12 prepareBobs::bob_table_idx#1 ] ] with [ zp[1]:4 [ main::a#2 main::a#6 main::a#1 ] ] +Coalescing zero page register [ zp[1]:22 [ prepareBobs::shift_x#2 prepareBobs::shift_x#1 ] ] with [ zp[1]:7 [ main::i#2 main::i#1 ] ] +Coalescing zero page register [ zp[1]:37 [ protoBobShiftRight::i#2 protoBobShiftRight::i#1 ] ] with [ zp[1]:23 [ prepareBobs::cell#2 prepareBobs::cell#1 ] ] +Coalescing zero page register [ zp[2]:42 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_lo#1 ] ] with [ zp[2]:24 [ prepareBobs::bob_glyph#2 prepareBobs::bob_glyph#1 charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph#1 ] ] +Coalescing zero page register [ zp[1]:44 [ mulf_init::c#2 mulf_init::c#1 ] ] with [ zp[1]:28 [ bob_charset_next_id#23 bob_charset_next_id#14 bob_charset_next_id#16 bob_charset_next_id#30 bob_charset_next_id#21 bob_charset_next_id#8 ] ] +Coalescing zero page register [ zp[2]:45 [ mulf_init::sqr1_hi#2 mulf_init::sqr1_hi#1 ] ] with [ zp[2]:26 [ prepareBobs::bob_table#2 prepareBobs::bob_table#1 prepareBobs::bob_table#0 ] ] +Coalescing zero page register [ zp[2]:48 [ mulf_init::sqr2_lo#2 mulf_init::sqr2_lo#1 ] ] with [ zp[2]:32 [ charsetFindOrAddGlyph::glyph_cursor#11 charsetFindOrAddGlyph::glyph_cursor#1 ] ] +Coalescing zero page register [ zp[1]:53 [ mulf_init::dir#2 mulf_init::dir#4 ] ] with [ zp[1]:40 [ protoBobShiftRight::carry#1 ] ] +Coalescing zero page register [ zp[2]:60 [ main::x#0 ] ] with [ zp[2]:51 [ mulf_init::sqr2_hi#2 mulf_init::sqr2_hi#1 ] ] +Coalescing zero page register [ zp[2]:83 [ renderBob::y_offset#0 renderBob::$2 renderBob::screen#0 ] ] with [ zp[2]:54 [ mulf_init::sqr#3 mulf_init::sqr#4 mulf_init::sqr#1 mulf_init::sqr#2 ] ] +Coalescing zero page register [ zp[1]:94 [ mulf8s_prepared::b#0 ] ] with [ zp[1]:70 [ renderBob::xpos#0 ] ] +Coalescing zero page register [ zp[2]:109 [ renderBobInit::$0 renderBobInit::$7 renderBobInit::$1 ] ] with [ zp[2]:107 [ renderBobCleanup::screen#0 ] ] +Coalescing zero page register [ zp[2]:42 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_lo#1 prepareBobs::bob_glyph#2 prepareBobs::bob_glyph#1 charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph#1 ] ] with [ zp[2]:13 [ memset::dst#2 memset::dst#1 renderBobCleanupNext#17 renderBobCleanupNext#13 ] ] +Coalescing zero page register [ zp[1]:80 [ renderBob::x_char_offset#0 ] ] with [ zp[1]:37 [ protoBobShiftRight::i#2 protoBobShiftRight::i#1 prepareBobs::cell#2 prepareBobs::cell#1 ] ] +Coalescing zero page register [ zp[2]:83 [ renderBob::y_offset#0 renderBob::$2 renderBob::screen#0 mulf_init::sqr#3 mulf_init::sqr#4 mulf_init::sqr#1 mulf_init::sqr#2 ] ] with [ zp[2]:18 [ progress_cursor#15 progress_cursor#31 progress_cursor#24 progress_cursor#17 progress_cursor#8 mulf8s_prepared::m#4 mulf8s_prepared::m#5 mulf8s_prepared::m#1 mulf8s_prepared::m#0 mulf8s_prepared::m#2 mulf8s::return#0 mulf8u_prepared::return#2 mulf8s::return#2 main::$10 mulf8s::return#3 main::$12 mulf8u_prepared::return#0 main::$13 main::y#0 ] ] +Coalescing zero page register [ zp[1]:90 [ renderBob::$5 ] ] with [ zp[1]:44 [ mulf_init::c#2 mulf_init::c#1 bob_charset_next_id#23 bob_charset_next_id#14 bob_charset_next_id#16 bob_charset_next_id#30 bob_charset_next_id#21 bob_charset_next_id#8 ] ] +Coalescing zero page register [ zp[1]:94 [ mulf8s_prepared::b#0 renderBob::xpos#0 ] ] with [ zp[1]:53 [ mulf_init::dir#2 mulf_init::dir#4 protoBobShiftRight::carry#1 ] ] +Coalescing zero page register [ zp[2]:109 [ renderBobInit::$0 renderBobInit::$7 renderBobInit::$1 renderBobCleanup::screen#0 ] ] with [ zp[2]:45 [ mulf_init::sqr1_hi#2 mulf_init::sqr1_hi#1 prepareBobs::bob_table#2 prepareBobs::bob_table#1 prepareBobs::bob_table#0 ] ] +Coalescing zero page register [ zp[2]:111 [ renderBobInit::$6 ] ] with [ zp[2]:48 [ mulf_init::sqr2_lo#2 mulf_init::sqr2_lo#1 charsetFindOrAddGlyph::glyph_cursor#11 charsetFindOrAddGlyph::glyph_cursor#1 ] ] +Allocated (was zp[1]:17) zp[1]:2 [ prepareBobs::shift_y#2 prepareBobs::shift_y#1 main::angle#8 main::angle#1 ] +Allocated (was zp[1]:20) zp[1]:3 [ progress_idx#16 progress_idx#31 progress_idx#25 progress_idx#10 progress_idx#8 main::r#2 main::r#1 ] +Allocated (was zp[1]:21) zp[1]:4 [ prepareBobs::bob_table_idx#6 prepareBobs::bob_table_idx#12 prepareBobs::bob_table_idx#1 main::a#2 main::a#6 main::a#1 ] +Allocated (was zp[1]:22) zp[1]:5 [ prepareBobs::shift_x#2 prepareBobs::shift_x#1 main::i#2 main::i#1 ] +Allocated (was zp[2]:42) zp[2]:6 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_lo#1 prepareBobs::bob_glyph#2 prepareBobs::bob_glyph#1 charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph#1 memset::dst#2 memset::dst#1 renderBobCleanupNext#17 renderBobCleanupNext#13 ] +Allocated (was zp[2]:60) zp[2]:8 [ main::x#0 mulf_init::sqr2_hi#2 mulf_init::sqr2_hi#1 ] +Allocated (was zp[1]:80) zp[1]:10 [ renderBob::x_char_offset#0 protoBobShiftRight::i#2 protoBobShiftRight::i#1 prepareBobs::cell#2 prepareBobs::cell#1 ] +Allocated (was zp[2]:83) zp[2]:11 [ renderBob::y_offset#0 renderBob::$2 renderBob::screen#0 mulf_init::sqr#3 mulf_init::sqr#4 mulf_init::sqr#1 mulf_init::sqr#2 progress_cursor#15 progress_cursor#31 progress_cursor#24 progress_cursor#17 progress_cursor#8 mulf8s_prepared::m#4 mulf8s_prepared::m#5 mulf8s_prepared::m#1 mulf8s_prepared::m#0 mulf8s_prepared::m#2 mulf8s::return#0 mulf8u_prepared::return#2 mulf8s::return#2 main::$10 mulf8s::return#3 main::$12 mulf8u_prepared::return#0 main::$13 main::y#0 ] +Allocated (was zp[1]:90) zp[1]:13 [ renderBob::$5 mulf_init::c#2 mulf_init::c#1 bob_charset_next_id#23 bob_charset_next_id#14 bob_charset_next_id#16 bob_charset_next_id#30 bob_charset_next_id#21 bob_charset_next_id#8 ] +Allocated (was zp[1]:94) zp[1]:14 [ mulf8s_prepared::b#0 renderBob::xpos#0 mulf_init::dir#2 mulf_init::dir#4 protoBobShiftRight::carry#1 ] +Allocated (was zp[2]:109) zp[2]:15 [ renderBobInit::$0 renderBobInit::$7 renderBobInit::$1 renderBobCleanup::screen#0 mulf_init::sqr1_hi#2 mulf_init::sqr1_hi#1 prepareBobs::bob_table#2 prepareBobs::bob_table#1 prepareBobs::bob_table#0 ] +Allocated (was zp[2]:111) zp[2]:17 [ renderBobInit::$6 mulf_init::sqr2_lo#2 mulf_init::sqr2_lo#1 charsetFindOrAddGlyph::glyph_cursor#11 charsetFindOrAddGlyph::glyph_cursor#1 ] + +ASSEMBLER BEFORE OPTIMIZATION + // File Comments +// Pre-calculated bobs inside a charset (pre-moved to all x/y-combinations) + // Upstart +.pc = $801 "Basic" +:BasicUpstart(__bbegin) +.pc = $80d "Program" + // Global Constants & labels + .label RASTER = $d012 + .label BORDERCOL = $d020 + .label D018 = $d018 + // CIA#1 Port A: keyboard matrix columns and joystick #2 + .label CIA1_PORT_A = $dc00 + // CIA#1 Port B: keyboard matrix rows and joystick #1. + .label CIA1_PORT_B = $dc01 + // CIA#2 Port A: Serial bus, RS-232, VIC memory bank + .label CIA2_PORT_A = $dd00 + // CIA #2 Port A data direction register. + .label CIA2_PORT_A_DDR = $dd02 + .const KEY_SPACE = $3c + // The BASIC screen + .label SCREEN_BASIC = $400 + // The BASIC charset + .label CHARSET_BASIC = $1000 + // The BOB screen + .label BOB_SCREEN = $2800 + // The BOB charset + .label BOB_CHARSET = $2000 + // The number of different X-shifts + .const BOB_SHIFTS_X = 4 + // The number of different Y-shifts + .const BOB_SHIFTS_Y = 8 + // The size of a sub-table of BOB_TABLES + .const BOB_SUBTABLE_SIZE = BOB_SHIFTS_X*BOB_SHIFTS_Y + // The number of BOBs to render + .const NUM_BOBS = $14 + .const SIZEOF_POINTER = 2 + .label COS = SIN+$40 + // BOB charset ID of the next glyph to be added + .label bob_charset_next_id = $d + // Current index within the progress cursor (0-7) + .label progress_idx = 3 + // Current position of the progress cursor + .label progress_cursor = $b + // Pointer to the next clean-up to add + // Prepare for next clean-up + .label renderBobCleanupNext = 6 + // @begin +__bbegin: + // [1] phi from @begin to @1 [phi:@begin->@1] +__b1_from___bbegin: + jmp __b1 + // @1 +__b1: + // [2] call main + // [4] phi from @1 to main [phi:@1->main] +main_from___b1: + jsr main + // [3] phi from @1 to @end [phi:@1->@end] +__bend_from___b1: + jmp __bend + // @end +__bend: + // main +main: { + .const vicSelectGfxBank1_toDd001_return = 3 + .const vicSelectGfxBank2_toDd001_return = 3 + .const toD0181_return = (>(BOB_SCREEN&$3fff)*4)|(>BOB_CHARSET)/4&$f + .const toD0182_return = (>(SCREEN_BASIC&$3fff)*4)|(>CHARSET_BASIC)/4&$f + .label __10 = $b + .label __12 = $b + .label __13 = $b + .label x = 8 + .label y = $b + .label a = 4 + .label r = 3 + .label i = 5 + // Render Rotated BOBs + .label angle = 2 + // [5] call mulf_init + // [243] phi from main to mulf_init [phi:main->mulf_init] + mulf_init_from_main: + jsr mulf_init + // [6] phi from main to main::@9 [phi:main->main::@9] + __b9_from_main: + jmp __b9 + // main::@9 + __b9: + // [7] call prepareBobs + // [159] phi from main::@9 to prepareBobs [phi:main::@9->prepareBobs] + prepareBobs_from___b9: + jsr prepareBobs + // [8] phi from main::@9 to main::@10 [phi:main::@9->main::@10] + __b10_from___b9: + jmp __b10 + // main::@10 + __b10: + // [9] call renderBobInit + // [143] phi from main::@10 to renderBobInit [phi:main::@10->renderBobInit] + renderBobInit_from___b10: + jsr renderBobInit + jmp vicSelectGfxBank1 + // main::vicSelectGfxBank1 + vicSelectGfxBank1: + // [10] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 -- _deref_pbuc1=vbuc2 + lda #3 + sta CIA2_PORT_A_DDR + // [11] phi from main::vicSelectGfxBank1 to main::vicSelectGfxBank1_toDd001 [phi:main::vicSelectGfxBank1->main::vicSelectGfxBank1_toDd001] + vicSelectGfxBank1_toDd001_from_vicSelectGfxBank1: + jmp vicSelectGfxBank1_toDd001 + // main::vicSelectGfxBank1_toDd001 + vicSelectGfxBank1_toDd001: + jmp vicSelectGfxBank1___b1 + // main::vicSelectGfxBank1_@1 + vicSelectGfxBank1___b1: + // [12] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank1_toDd001_return#0 -- _deref_pbuc1=vbuc2 + lda #vicSelectGfxBank1_toDd001_return + sta CIA2_PORT_A + // [13] phi from main::vicSelectGfxBank1_@1 to main::toD0181 [phi:main::vicSelectGfxBank1_@1->main::toD0181] + toD0181_from_vicSelectGfxBank1___b1: + jmp toD0181 + // main::toD0181 + toD0181: + jmp __b7 + // main::@7 + __b7: + // [14] *((const byte*) D018) ← (const byte) main::toD0181_return#0 -- _deref_pbuc1=vbuc2 + lda #toD0181_return + sta D018 + // [15] call memset + // [137] phi from main::@7 to memset [phi:main::@7->memset] + memset_from___b7: + jsr memset + // [16] phi from main::@7 to main::@1 [phi:main::@7->main::@1] + __b1_from___b7: + // [16] phi (byte) main::angle#8 = (byte) 0 [phi:main::@7->main::@1#0] -- vbuz1=vbuc1 + lda #0 + sta.z angle + jmp __b1 + // main::@1 + __b1: + jmp __b2 + // main::@2 + __b2: + // [17] if(*((const byte*) RASTER)<(byte) $f8) goto main::@2 -- _deref_pbuc1_lt_vbuc2_then_la1 + lda RASTER + cmp #$f8 + bcc __b2 + jmp __b3 + // main::@3 + __b3: + // [18] *((const byte*) BORDERCOL) ← (byte) $f -- _deref_pbuc1=vbuc2 + lda #$f + sta BORDERCOL + // [19] call renderBobCleanup + // [121] phi from main::@3 to renderBobCleanup [phi:main::@3->renderBobCleanup] + renderBobCleanup_from___b3: + jsr renderBobCleanup + jmp __b11 + // main::@11 + __b11: + // [20] (byte) main::a#6 ← (byte) main::angle#8 -- vbuz1=vbuz2 + lda.z angle + sta.z a + // [21] phi from main::@11 to main::@4 [phi:main::@11->main::@4] + __b4_from___b11: + // [21] phi (byte) main::i#2 = (byte) 0 [phi:main::@11->main::@4#0] -- vbuz1=vbuc1 + lda #0 + sta.z i + // [21] phi (byte**) renderBobCleanupNext#17 = (const byte**) RENDERBOB_CLEANUP [phi:main::@11->main::@4#1] -- pptz1=pptc1 + lda #RENDERBOB_CLEANUP + sta.z renderBobCleanupNext+1 + // [21] phi (byte) main::a#2 = (byte) main::a#6 [phi:main::@11->main::@4#2] -- register_copy + // [21] phi (signed byte) main::r#2 = (signed byte) $1e [phi:main::@11->main::@4#3] -- vbsz1=vbsc1 + lda #$1e + sta.z r + jmp __b4 + // [21] phi from main::@14 to main::@4 [phi:main::@14->main::@4] + __b4_from___b14: + // [21] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@14->main::@4#0] -- register_copy + // [21] phi (byte**) renderBobCleanupNext#17 = (byte**) renderBobCleanupNext#13 [phi:main::@14->main::@4#1] -- register_copy + // [21] phi (byte) main::a#2 = (byte) main::a#1 [phi:main::@14->main::@4#2] -- register_copy + // [21] phi (signed byte) main::r#2 = (signed byte) main::r#1 [phi:main::@14->main::@4#3] -- register_copy + jmp __b4 + // main::@4 + __b4: + // [22] *((const byte*) BORDERCOL) ← (byte) 1 -- _deref_pbuc1=vbuc2 + //kickasm {{ .break }} + lda #1 + sta BORDERCOL + // [23] (signed byte) mulf8s::a#0 ← (signed byte) main::r#2 -- vbsaa=vbsz1 + lda.z r + // [24] (signed byte) mulf8s::b#0 ← *((const signed byte*) COS + (byte) main::a#2) -- vbsxx=pbsc1_derefidx_vbuz1 + ldy.z a + ldx COS,y + // [25] call mulf8s + // [92] phi from main::@4 to mulf8s [phi:main::@4->mulf8s] + mulf8s_from___b4: + // [92] phi (signed byte) mulf8s::b#2 = (signed byte) mulf8s::b#0 [phi:main::@4->mulf8s#0] -- register_copy + // [92] phi (signed byte) mulf8s::mulf8s_prepare1_a#0 = (signed byte) mulf8s::a#0 [phi:main::@4->mulf8s#1] -- register_copy + jsr mulf8s + // [26] (signed word) mulf8s::return#2 ← (signed word) mulf8s::return#0 + jmp __b12 + // main::@12 + __b12: + // [27] (signed word~) main::$10 ← (signed word) mulf8s::return#2 + // [28] (signed word) main::x#0 ← (signed word~) main::$10 + (signed word)(number) $4b*(number) $100 -- vwsz1=vwsz2_plus_vwsc1 + lda.z __10 + clc + adc #<$4b*$100 + sta.z x + lda.z __10+1 + adc #>$4b*$100 + sta.z x+1 + // [29] (signed byte) mulf8s::a#1 ← (signed byte) main::r#2 -- vbsaa=vbsz1 + lda.z r + // [30] (signed byte) mulf8s::b#1 ← *((const signed byte*) SIN + (byte) main::a#2) -- vbsxx=pbsc1_derefidx_vbuz1 + ldy.z a + ldx SIN,y + // [31] call mulf8s + // [92] phi from main::@12 to mulf8s [phi:main::@12->mulf8s] + mulf8s_from___b12: + // [92] phi (signed byte) mulf8s::b#2 = (signed byte) mulf8s::b#1 [phi:main::@12->mulf8s#0] -- register_copy + // [92] phi (signed byte) mulf8s::mulf8s_prepare1_a#0 = (signed byte) mulf8s::a#1 [phi:main::@12->mulf8s#1] -- register_copy + jsr mulf8s + // [32] (signed word) mulf8s::return#3 ← (signed word) mulf8s::return#0 + jmp __b13 + // main::@13 + __b13: + // [33] (signed word~) main::$12 ← (signed word) mulf8s::return#3 + // [34] (signed word~) main::$13 ← (signed word~) main::$12 << (byte) 1 -- vwsz1=vwsz1_rol_1 + asl.z __13 + rol.z __13+1 + // [35] (signed word) main::y#0 ← (signed word~) main::$13 + (signed word)(number) $5a*(number) $100 -- vwsz1=vwsz1_plus_vwsc1 + clc + lda.z y + adc #<$5a*$100 + sta.z y + lda.z y+1 + adc #>$5a*$100 + sta.z y+1 + // [36] *((const byte*) BORDERCOL) ← (byte) 2 -- _deref_pbuc1=vbuc2 + lda #2 + sta BORDERCOL + // [37] (byte) main::a#1 ← (byte) main::a#2 + (byte) $62 -- vbuz1=vbuz1_plus_vbuc1 + lax.z a + axs #-[$62] + stx.z a + // [38] (signed byte) main::r#1 ← (signed byte) main::r#2 + (signed byte) 3 -- vbsz1=vbsz1_plus_vbsc1 + lax.z r + axs #-[3] + stx.z r + // [39] (byte) renderBob::xpos#0 ← > (signed word) main::x#0 -- vbuz1=_hi_vwsz2 + lda.z x+1 + sta.z renderBob.xpos + // [40] (byte) renderBob::ypos#0 ← > (signed word) main::y#0 -- vbuxx=_hi_vwsz1 + lda.z y+1 + tax + // [41] call renderBob + jsr renderBob + jmp __b14 + // main::@14 + __b14: + // [42] (byte) main::i#1 ← ++ (byte) main::i#2 -- vbuz1=_inc_vbuz1 + inc.z i + // [43] if((byte) main::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto main::@4 -- vbuz1_neq_vbuc1_then_la1 + lda #NUM_BOBS-1+1 + cmp.z i + bne __b4_from___b14 + jmp __b5 + // main::@5 + __b5: + // [44] (byte) main::angle#1 ← (byte) main::angle#8 + (byte) 3 -- vbuz1=vbuz1_plus_vbuc1 + lax.z angle + axs #-[3] + stx.z angle + // [45] *((const byte*) BORDERCOL) ← (byte) 0 -- _deref_pbuc1=vbuc2 + lda #0 + sta BORDERCOL + // [46] call keyboard_key_pressed + // [61] phi from main::@5 to keyboard_key_pressed [phi:main::@5->keyboard_key_pressed] + keyboard_key_pressed_from___b5: + jsr keyboard_key_pressed + // [47] (byte) keyboard_key_pressed::return#2 ← (byte) keyboard_key_pressed::return#0 + jmp __b15 + // main::@15 + __b15: + // [48] (byte~) main::$19 ← (byte) keyboard_key_pressed::return#2 + // [49] if((byte) 0!=(byte~) main::$19) goto main::@6 -- vbuc1_neq_vbuaa_then_la1 + cmp #0 + bne __b6_from___b15 + // [16] phi from main::@15 to main::@1 [phi:main::@15->main::@1] + __b1_from___b15: + // [16] phi (byte) main::angle#8 = (byte) main::angle#1 [phi:main::@15->main::@1#0] -- register_copy + jmp __b1 + // Wait for space release + // [50] phi from main::@15 main::@16 to main::@6 [phi:main::@15/main::@16->main::@6] + __b6_from___b15: + __b6_from___b16: + jmp __b6 + // main::@6 + __b6: + // [51] call keyboard_key_pressed + // [61] phi from main::@6 to keyboard_key_pressed [phi:main::@6->keyboard_key_pressed] + keyboard_key_pressed_from___b6: + jsr keyboard_key_pressed + // [52] (byte) keyboard_key_pressed::return#3 ← (byte) keyboard_key_pressed::return#0 + jmp __b16 + // main::@16 + __b16: + // [53] (byte~) main::$21 ← (byte) keyboard_key_pressed::return#3 + // [54] if((byte) 0!=(byte~) main::$21) goto main::@6 -- vbuc1_neq_vbuaa_then_la1 + cmp #0 + bne __b6_from___b16 + jmp vicSelectGfxBank2 + // main::vicSelectGfxBank2 + vicSelectGfxBank2: + // [55] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 -- _deref_pbuc1=vbuc2 + lda #3 + sta CIA2_PORT_A_DDR + // [56] phi from main::vicSelectGfxBank2 to main::vicSelectGfxBank2_toDd001 [phi:main::vicSelectGfxBank2->main::vicSelectGfxBank2_toDd001] + vicSelectGfxBank2_toDd001_from_vicSelectGfxBank2: + jmp vicSelectGfxBank2_toDd001 + // main::vicSelectGfxBank2_toDd001 + vicSelectGfxBank2_toDd001: + jmp vicSelectGfxBank2___b1 + // main::vicSelectGfxBank2_@1 + vicSelectGfxBank2___b1: + // [57] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank2_toDd001_return#0 -- _deref_pbuc1=vbuc2 + lda #vicSelectGfxBank2_toDd001_return + sta CIA2_PORT_A + // [58] phi from main::vicSelectGfxBank2_@1 to main::toD0182 [phi:main::vicSelectGfxBank2_@1->main::toD0182] + toD0182_from_vicSelectGfxBank2___b1: + jmp toD0182 + // main::toD0182 + toD0182: + jmp __b8 + // main::@8 + __b8: + // [59] *((const byte*) D018) ← (const byte) main::toD0182_return#0 -- _deref_pbuc1=vbuc2 + lda #toD0182_return + sta D018 + jmp __breturn + // main::@return + __breturn: + // [60] return + rts +} + // keyboard_key_pressed +// Determines whether a specific key is currently pressed by accessing the matrix directly +// The key is a keyboard code defined from the keyboard matrix by %00rrrccc, where rrr is the row ID (0-7) and ccc is the column ID (0-7) +// All keys exist as as KEY_XXX constants. +// Returns zero if the key is not pressed and a non-zero value if the key is currently pressed +keyboard_key_pressed: { + .const colidx = KEY_SPACE&7 + .label rowidx = KEY_SPACE>>3 + // [62] call keyboard_matrix_read + jsr keyboard_matrix_read + // [63] (byte) keyboard_matrix_read::return#2 ← (byte) keyboard_matrix_read::return#0 + jmp __b1 + // keyboard_key_pressed::@1 + __b1: + // [64] (byte~) keyboard_key_pressed::$2 ← (byte) keyboard_matrix_read::return#2 + // [65] (byte) keyboard_key_pressed::return#0 ← (byte~) keyboard_key_pressed::$2 & *((const byte*) keyboard_matrix_col_bitmask+(const byte) keyboard_key_pressed::colidx#0) -- vbuaa=vbuaa_band__deref_pbuc1 + and keyboard_matrix_col_bitmask+colidx + jmp __breturn + // keyboard_key_pressed::@return + __breturn: + // [66] return + rts +} + // keyboard_matrix_read +// Read a single row of the keyboard matrix +// The row ID (0-7) of the keyboard matrix row to read. See the C64 key matrix for row IDs. +// Returns the keys pressed on the row as bits according to the C64 key matrix. +// Notice: If the C64 normal interrupt is still running it will occasionally interrupt right between the read & write +// leading to erroneous readings. You must disable kill the normal interrupt or sei/cli around calls to the keyboard matrix reader. +keyboard_matrix_read: { + // [67] *((const byte*) CIA1_PORT_A) ← *((const byte*) keyboard_matrix_row_bitmask+(const byte) keyboard_key_pressed::rowidx#0) -- _deref_pbuc1=_deref_pbuc2 + lda keyboard_matrix_row_bitmask+keyboard_key_pressed.rowidx + sta CIA1_PORT_A + // [68] (byte) keyboard_matrix_read::return#0 ← ~ *((const byte*) CIA1_PORT_B) -- vbuaa=_bnot__deref_pbuc1 + lda CIA1_PORT_B + eor #$ff + jmp __breturn + // keyboard_matrix_read::@return + __breturn: + // [69] return + rts +} + // renderBob +// Render a single BOB at a given x/y-position +// X-position is 0-151. Each x-position is 2 pixels wide. +// Y-position is 0-183. Each y-position is 1 pixel high. +// renderBob(byte zeropage($e) xpos, byte register(X) ypos) +renderBob: { + .label __2 = $b + .label __5 = $d + .label xpos = $e + .label x_char_offset = $a + .label y_offset = $b + .label screen = $b + // [70] (byte) renderBob::x_char_offset#0 ← (byte) renderBob::xpos#0 >> (byte) 2 -- vbuz1=vbuz2_ror_2 + lda.z xpos + lsr + lsr + sta.z x_char_offset + // [71] (byte) renderBob::y_char_offset#0 ← (byte) renderBob::ypos#0 >> (byte) 3 -- vbuaa=vbuxx_ror_3 + txa + lsr + lsr + lsr + // [72] (byte~) renderBob::$8 ← (byte) renderBob::y_char_offset#0 << (byte) 1 -- vbuaa=vbuaa_rol_1 + asl + // [73] (word) renderBob::y_offset#0 ← *((const word*) MUL40 + (byte~) renderBob::$8) -- vwuz1=pwuc1_derefidx_vbuaa + tay + lda MUL40,y + sta.z y_offset + lda MUL40+1,y + sta.z y_offset+1 + // [74] (byte*~) renderBob::$2 ← (const byte*) BOB_SCREEN + (word) renderBob::y_offset#0 -- pbuz1=pbuc1_plus_vwuz1 + clc + lda.z __2 + adc #BOB_SCREEN + sta.z __2+1 + // [75] (byte*) renderBob::screen#0 ← (byte*~) renderBob::$2 + (byte) renderBob::x_char_offset#0 -- pbuz1=pbuz1_plus_vbuz2 + lda.z x_char_offset + clc + adc.z screen + sta.z screen + bcc !+ + inc.z screen+1 + !: + // [76] (byte~) renderBob::$4 ← (byte) renderBob::ypos#0 & (byte) 7 -- vbuaa=vbuxx_band_vbuc1 + txa + and #7 + // [77] (byte~) renderBob::$5 ← (byte~) renderBob::$4 << (byte) 2 -- vbuz1=vbuaa_rol_2 + asl + asl + sta.z __5 + // [78] (byte~) renderBob::$6 ← (byte) renderBob::xpos#0 & (byte) 3 -- vbuaa=vbuz1_band_vbuc1 + lda #3 + and.z xpos + // [79] (byte) renderBob::bob_table_idx#0 ← (byte~) renderBob::$5 + (byte~) renderBob::$6 -- vbuxx=vbuz1_plus_vbuaa + clc + adc.z __5 + tax + // [80] *((byte**) renderBobCleanupNext#17) ← (byte*) renderBob::screen#0 -- _deref_pptz1=pbuz2 + ldy #0 + lda.z screen + sta (renderBobCleanupNext),y + iny + lda.z screen+1 + sta (renderBobCleanupNext),y + // [81] (byte**) renderBobCleanupNext#13 ← (byte**) renderBobCleanupNext#17 + (const byte) SIZEOF_POINTER -- pptz1=pptz1_plus_vbuc1 + lda #SIZEOF_POINTER + clc + adc.z renderBobCleanupNext + sta.z renderBobCleanupNext + bcc !+ + inc.z renderBobCleanupNext+1 + !: + // [82] *((byte*) renderBob::screen#0) ← *((const byte*) BOB_TABLES + (byte) renderBob::bob_table_idx#0) -- _deref_pbuz1=pbuc1_derefidx_vbuxx + lda BOB_TABLES,x + ldy #0 + sta (screen),y + // [83] *((byte*) renderBob::screen#0 + (byte) $28) ← *((const byte*) BOB_TABLES+(byte) 1*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx + lda BOB_TABLES+1*BOB_SUBTABLE_SIZE,x + ldy #$28 + sta (screen),y + // [84] *((byte*) renderBob::screen#0 + (byte) $50) ← *((const byte*) BOB_TABLES+(byte) 2*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx + lda BOB_TABLES+2*BOB_SUBTABLE_SIZE,x + ldy #$50 + sta (screen),y + // [85] *((byte*) renderBob::screen#0 + (byte) 1) ← *((const byte*) BOB_TABLES+(byte) 3*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx + lda BOB_TABLES+3*BOB_SUBTABLE_SIZE,x + ldy #1 + sta (screen),y + // [86] *((byte*) renderBob::screen#0 + (byte) $29) ← *((const byte*) BOB_TABLES+(byte) 4*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx + lda BOB_TABLES+4*BOB_SUBTABLE_SIZE,x + ldy #$29 + sta (screen),y + // [87] *((byte*) renderBob::screen#0 + (byte) $51) ← *((const byte*) BOB_TABLES+(byte) 5*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx + lda BOB_TABLES+5*BOB_SUBTABLE_SIZE,x + ldy #$51 + sta (screen),y + // [88] *((byte*) renderBob::screen#0 + (byte) 2) ← *((const byte*) BOB_TABLES+(byte) 6*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx + lda BOB_TABLES+6*BOB_SUBTABLE_SIZE,x + ldy #2 + sta (screen),y + // [89] *((byte*) renderBob::screen#0 + (byte) $2a) ← *((const byte*) BOB_TABLES+(byte) 7*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx + lda BOB_TABLES+7*BOB_SUBTABLE_SIZE,x + ldy #$2a + sta (screen),y + // [90] *((byte*) renderBob::screen#0 + (byte) $52) ← *((const byte*) BOB_TABLES+(byte) 8*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx + lda BOB_TABLES+8*BOB_SUBTABLE_SIZE,x + ldy #$52 + sta (screen),y + jmp __breturn + // renderBob::@return + __breturn: + // [91] return + rts +} + // mulf8s +// Fast multiply two signed bytes to a word result +// mulf8s(signed byte register(A) a, signed byte register(X) b) +mulf8s: { + .label return = $b + jmp mulf8s_prepare1 + // mulf8s::mulf8s_prepare1 + mulf8s_prepare1: + // [93] (byte) mulf8u_prepare::a#0 ← (byte)(signed byte) mulf8s::mulf8s_prepare1_a#0 + // [94] call mulf8u_prepare + jsr mulf8u_prepare + jmp __b1 + // mulf8s::@1 + __b1: + // [95] (signed byte) mulf8s_prepared::b#0 ← (signed byte) mulf8s::b#2 -- vbsz1=vbsxx + stx.z mulf8s_prepared.b + // [96] call mulf8s_prepared + jsr mulf8s_prepared + jmp __b2 + // mulf8s::@2 + __b2: + // [97] (signed word) mulf8s::return#0 ← (signed word)(word) mulf8s_prepared::m#4 + jmp __breturn + // mulf8s::@return + __breturn: + // [98] return + rts +} + // mulf8s_prepared +// Calculate fast multiply with a prepared unsigned byte to a word result +// The prepared number is set by calling mulf8s_prepare(byte a) +// mulf8s_prepared(signed byte zeropage($e) b) +mulf8s_prepared: { + .label memA = $fd + .label m = $b + .label b = $e + // [99] (byte) mulf8u_prepared::b#0 ← (byte)(signed byte) mulf8s_prepared::b#0 -- vbuaa=vbuz1 + lda.z b + // [100] call mulf8u_prepared + jsr mulf8u_prepared + // [101] (word) mulf8u_prepared::return#2 ← (word) mulf8u_prepared::return#0 + jmp __b5 + // mulf8s_prepared::@5 + __b5: + // [102] (word) mulf8s_prepared::m#0 ← (word) mulf8u_prepared::return#2 + // [103] if(*((const signed byte*) mulf8s_prepared::memA)>=(signed byte) 0) goto mulf8s_prepared::@1 -- _deref_pbsc1_ge_0_then_la1 + lda memA + cmp #0 + bpl __b1_from___b5 + jmp __b3 + // mulf8s_prepared::@3 + __b3: + // [104] (byte~) mulf8s_prepared::$8 ← > (word) mulf8s_prepared::m#0 -- vbuaa=_hi_vwuz1 + lda.z m+1 + // [105] (byte~) mulf8s_prepared::$15 ← (byte~) mulf8s_prepared::$8 - (byte)(signed byte) mulf8s_prepared::b#0 -- vbuaa=vbuaa_minus_vbuz1 + sec + sbc.z b + // [106] (word) mulf8s_prepared::m#1 ← (word) mulf8s_prepared::m#0 hi= (byte~) mulf8s_prepared::$15 -- vwuz1=vwuz1_sethi_vbuaa + sta.z m+1 + // [107] phi from mulf8s_prepared::@3 mulf8s_prepared::@5 to mulf8s_prepared::@1 [phi:mulf8s_prepared::@3/mulf8s_prepared::@5->mulf8s_prepared::@1] + __b1_from___b3: + __b1_from___b5: + // [107] phi (word) mulf8s_prepared::m#5 = (word) mulf8s_prepared::m#1 [phi:mulf8s_prepared::@3/mulf8s_prepared::@5->mulf8s_prepared::@1#0] -- register_copy + jmp __b1 + // mulf8s_prepared::@1 + __b1: + // [108] if((signed byte) mulf8s_prepared::b#0>=(signed byte) 0) goto mulf8s_prepared::@2 -- vbsz1_ge_0_then_la1 + lda.z b + cmp #0 + bpl __b2_from___b1 + jmp __b4 + // mulf8s_prepared::@4 + __b4: + // [109] (byte~) mulf8s_prepared::$12 ← > (word) mulf8s_prepared::m#5 -- vbuaa=_hi_vwuz1 + lda.z m+1 + // [110] (byte~) mulf8s_prepared::$16 ← (byte~) mulf8s_prepared::$12 - (byte)*((const signed byte*) mulf8s_prepared::memA) -- vbuaa=vbuaa_minus__deref_pbuc1 + sec + sbc memA + // [111] (word) mulf8s_prepared::m#2 ← (word) mulf8s_prepared::m#5 hi= (byte~) mulf8s_prepared::$16 -- vwuz1=vwuz1_sethi_vbuaa + sta.z m+1 + // [112] phi from mulf8s_prepared::@1 mulf8s_prepared::@4 to mulf8s_prepared::@2 [phi:mulf8s_prepared::@1/mulf8s_prepared::@4->mulf8s_prepared::@2] + __b2_from___b1: + __b2_from___b4: + // [112] phi (word) mulf8s_prepared::m#4 = (word) mulf8s_prepared::m#5 [phi:mulf8s_prepared::@1/mulf8s_prepared::@4->mulf8s_prepared::@2#0] -- register_copy + jmp __b2 + // mulf8s_prepared::@2 + __b2: + jmp __breturn + // mulf8s_prepared::@return + __breturn: + // [113] return + rts +} + // mulf8u_prepared +// Calculate fast multiply with a prepared unsigned byte to a word result +// The prepared number is set by calling mulf8u_prepare(byte a) +// mulf8u_prepared(byte register(A) b) +mulf8u_prepared: { + .label resL = $fe + .label memB = $ff + .label return = $b + // [114] *((const byte*) mulf8u_prepared::memB) ← (byte) mulf8u_prepared::b#0 -- _deref_pbuc1=vbuaa + sta memB + // asm { ldxmemB sec sm1: ldamulf_sqr1_lo,x sm2: sbcmulf_sqr2_lo,x staresL sm3: ldamulf_sqr1_hi,x sm4: sbcmulf_sqr2_hi,x stamemB } + ldx memB + sec + sm1: + lda mulf_sqr1_lo,x + sm2: + sbc mulf_sqr2_lo,x + sta resL + sm3: + lda mulf_sqr1_hi,x + sm4: + sbc mulf_sqr2_hi,x + sta memB + // [116] (word) mulf8u_prepared::return#0 ← *((const byte*) mulf8u_prepared::memB) w= *((const byte*) mulf8u_prepared::resL) -- vwuz1=_deref_pbuc1_word__deref_pbuc2 + lda resL + sta.z return + lda memB + sta.z return+1 + jmp __breturn + // mulf8u_prepared::@return + __breturn: + // [117] return + rts +} + // mulf8u_prepare +// Prepare for fast multiply with an unsigned byte to a word result +// mulf8u_prepare(byte register(A) a) +mulf8u_prepare: { + .label memA = $fd + // [118] *((const byte*) mulf8u_prepare::memA) ← (byte) mulf8u_prepare::a#0 -- _deref_pbuc1=vbuaa + sta memA + // asm { ldamemA stamulf8u_prepared.sm1+1 stamulf8u_prepared.sm3+1 eor#$ff stamulf8u_prepared.sm2+1 stamulf8u_prepared.sm4+1 } + lda memA + sta mulf8u_prepared.sm1+1 + sta mulf8u_prepared.sm3+1 + eor #$ff + sta mulf8u_prepared.sm2+1 + sta mulf8u_prepared.sm4+1 + jmp __breturn + // mulf8u_prepare::@return + __breturn: + // [120] return + rts +} + // renderBobCleanup +// Clean Up the rendered BOB's +renderBobCleanup: { + .label screen = $f + // [122] phi from renderBobCleanup to renderBobCleanup::@1 [phi:renderBobCleanup->renderBobCleanup::@1] + __b1_from_renderBobCleanup: + // [122] phi (byte) renderBobCleanup::i#2 = (byte) 0 [phi:renderBobCleanup->renderBobCleanup::@1#0] -- vbuxx=vbuc1 + ldx #0 + jmp __b1 + // [122] phi from renderBobCleanup::@1 to renderBobCleanup::@1 [phi:renderBobCleanup::@1->renderBobCleanup::@1] + __b1_from___b1: + // [122] phi (byte) renderBobCleanup::i#2 = (byte) renderBobCleanup::i#1 [phi:renderBobCleanup::@1->renderBobCleanup::@1#0] -- register_copy + jmp __b1 + // renderBobCleanup::@1 + __b1: + // [123] (byte~) renderBobCleanup::$1 ← (byte) renderBobCleanup::i#2 << (byte) 1 -- vbuaa=vbuxx_rol_1 + txa + asl + // [124] (byte*) renderBobCleanup::screen#0 ← *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobCleanup::$1) -- pbuz1=pptc1_derefidx_vbuaa + tay + lda RENDERBOB_CLEANUP,y + sta.z screen + lda RENDERBOB_CLEANUP+1,y + sta.z screen+1 + // [125] *((byte*) renderBobCleanup::screen#0) ← (byte) 0 -- _deref_pbuz1=vbuc1 + lda #0 + ldy #0 + sta (screen),y + // [126] *((byte*) renderBobCleanup::screen#0 + (byte) $28) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + lda #0 + ldy #$28 + sta (screen),y + // [127] *((byte*) renderBobCleanup::screen#0 + (byte) $50) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + lda #0 + ldy #$50 + sta (screen),y + // [128] *((byte*) renderBobCleanup::screen#0 + (byte) 1) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + lda #0 + ldy #1 + sta (screen),y + // [129] *((byte*) renderBobCleanup::screen#0 + (byte) $29) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + lda #0 + ldy #$29 + sta (screen),y + // [130] *((byte*) renderBobCleanup::screen#0 + (byte) $51) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + lda #0 + ldy #$51 + sta (screen),y + // [131] *((byte*) renderBobCleanup::screen#0 + (byte) 2) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + lda #0 + ldy #2 + sta (screen),y + // [132] *((byte*) renderBobCleanup::screen#0 + (byte) $2a) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + lda #0 + ldy #$2a + sta (screen),y + // [133] *((byte*) renderBobCleanup::screen#0 + (byte) $52) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + lda #0 + ldy #$52 + sta (screen),y + // [134] (byte) renderBobCleanup::i#1 ← ++ (byte) renderBobCleanup::i#2 -- vbuxx=_inc_vbuxx + inx + // [135] if((byte) renderBobCleanup::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto renderBobCleanup::@1 -- vbuxx_neq_vbuc1_then_la1 + cpx #NUM_BOBS-1+1 + bne __b1_from___b1 + jmp __breturn + // renderBobCleanup::@return + __breturn: + // [136] return + rts +} + // memset +// Copies the character c (an unsigned char) to the first num characters of the object pointed to by the argument str. +memset: { + .label str = BOB_SCREEN + .const c = 0 + .const num = $3e8 + .label end = str+num + .label dst = 6 + // [138] phi from memset to memset::@1 [phi:memset->memset::@1] + __b1_from_memset: + // [138] phi (byte*) memset::dst#2 = (byte*)(const void*) memset::str#0 [phi:memset->memset::@1#0] -- pbuz1=pbuc1 + lda #str + sta.z dst+1 + jmp __b1 + // memset::@1 + __b1: + // [139] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 -- pbuz1_neq_pbuc1_then_la1 + lda.z dst+1 + cmp #>end + bne __b2 + lda.z dst + cmp #memset::@1] + __b1_from___b2: + // [138] phi (byte*) memset::dst#2 = (byte*) memset::dst#1 [phi:memset::@2->memset::@1#0] -- register_copy + jmp __b1 +} + // renderBobInit +// Initialize the tables used by renderBob() +renderBobInit: { + .label __0 = $f + .label __1 = $f + .label __6 = $11 + .label __7 = $f + // [144] phi from renderBobInit to renderBobInit::@1 [phi:renderBobInit->renderBobInit::@1] + __b1_from_renderBobInit: + // [144] phi (byte) renderBobInit::y#2 = (byte) 0 [phi:renderBobInit->renderBobInit::@1#0] -- vbuxx=vbuc1 + ldx #0 + jmp __b1 + // [144] phi from renderBobInit::@1 to renderBobInit::@1 [phi:renderBobInit::@1->renderBobInit::@1] + __b1_from___b1: + // [144] phi (byte) renderBobInit::y#2 = (byte) renderBobInit::y#1 [phi:renderBobInit::@1->renderBobInit::@1#0] -- register_copy + jmp __b1 + // renderBobInit::@1 + __b1: + // [145] (word~) renderBobInit::$0 ← (word)(byte) renderBobInit::y#2 -- vwuz1=_word_vbuxx + txa + sta.z __0 + lda #0 + sta.z __0+1 + // [146] (word~) renderBobInit::$6 ← (word~) renderBobInit::$0 << (byte) 2 -- vwuz1=vwuz2_rol_2 + lda.z __0 + asl + sta.z __6 + lda.z __0+1 + rol + sta.z __6+1 + asl.z __6 + rol.z __6+1 + // [147] (word~) renderBobInit::$7 ← (word~) renderBobInit::$6 + (word~) renderBobInit::$0 -- vwuz1=vwuz2_plus_vwuz1 + lda.z __7 + clc + adc.z __6 + sta.z __7 + lda.z __7+1 + adc.z __6+1 + sta.z __7+1 + // [148] (word~) renderBobInit::$1 ← (word~) renderBobInit::$7 << (byte) 3 -- vwuz1=vwuz1_rol_3 + asl.z __1 + rol.z __1+1 + asl.z __1 + rol.z __1+1 + asl.z __1 + rol.z __1+1 + // [149] (byte~) renderBobInit::$4 ← (byte) renderBobInit::y#2 << (byte) 1 -- vbuaa=vbuxx_rol_1 + txa + asl + // [150] *((const word*) MUL40 + (byte~) renderBobInit::$4) ← (word~) renderBobInit::$1 -- pwuc1_derefidx_vbuaa=vwuz1 + tay + lda.z __1 + sta MUL40,y + lda.z __1+1 + sta MUL40+1,y + // [151] (byte) renderBobInit::y#1 ← ++ (byte) renderBobInit::y#2 -- vbuxx=_inc_vbuxx + inx + // [152] if((byte) renderBobInit::y#1!=(byte) $20) goto renderBobInit::@1 -- vbuxx_neq_vbuc1_then_la1 + cpx #$20 + bne __b1_from___b1 + // [153] phi from renderBobInit::@1 to renderBobInit::@2 [phi:renderBobInit::@1->renderBobInit::@2] + __b2_from___b1: + // [153] phi (byte) renderBobInit::i#2 = (byte) 0 [phi:renderBobInit::@1->renderBobInit::@2#0] -- vbuxx=vbuc1 + ldx #0 + jmp __b2 + // [153] phi from renderBobInit::@2 to renderBobInit::@2 [phi:renderBobInit::@2->renderBobInit::@2] + __b2_from___b2: + // [153] phi (byte) renderBobInit::i#2 = (byte) renderBobInit::i#1 [phi:renderBobInit::@2->renderBobInit::@2#0] -- register_copy + jmp __b2 + // renderBobInit::@2 + __b2: + // [154] (byte~) renderBobInit::$5 ← (byte) renderBobInit::i#2 << (byte) 1 -- vbuaa=vbuxx_rol_1 + txa + asl + // [155] *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobInit::$5) ← (const byte*) BOB_SCREEN -- pptc1_derefidx_vbuaa=pbuc2 + tay + lda #BOB_SCREEN + sta RENDERBOB_CLEANUP+1,y + // [156] (byte) renderBobInit::i#1 ← ++ (byte) renderBobInit::i#2 -- vbuxx=_inc_vbuxx + inx + // [157] if((byte) renderBobInit::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto renderBobInit::@2 -- vbuxx_neq_vbuc1_then_la1 + cpx #NUM_BOBS-1+1 + bne __b2_from___b2 + jmp __breturn + // renderBobInit::@return + __breturn: + // [158] return + rts +} + // prepareBobs +// Creates the pre-shifted bobs into BOB_CHARSET and populates the BOB_TABLES +// Modifies PROTO_BOB by shifting it around +prepareBobs: { + .label bob_table = $f + .label shift_y = 2 + // Populate charset and tables + .label bob_glyph = 6 + .label cell = $a + .label bob_table_idx = 4 + .label shift_x = 5 + // [160] call progress_init + // [241] phi from prepareBobs to progress_init [phi:prepareBobs->progress_init] + progress_init_from_prepareBobs: + jsr progress_init + // [161] phi from prepareBobs to prepareBobs::@8 [phi:prepareBobs->prepareBobs::@8] + __b8_from_prepareBobs: + jmp __b8 + // prepareBobs::@8 + __b8: + // [162] call charsetFindOrAddGlyph + // [195] phi from prepareBobs::@8 to charsetFindOrAddGlyph [phi:prepareBobs::@8->charsetFindOrAddGlyph] + charsetFindOrAddGlyph_from___b8: + // [195] phi (byte*) charsetFindOrAddGlyph::glyph#10 = (const byte*) PROTO_BOB+(byte) $30 [phi:prepareBobs::@8->charsetFindOrAddGlyph#0] -- pbuz1=pbuc1 + lda #PROTO_BOB+$30 + sta.z charsetFindOrAddGlyph.glyph+1 + // [195] phi (byte) bob_charset_next_id#23 = (byte) 0 [phi:prepareBobs::@8->charsetFindOrAddGlyph#1] -- vbuz1=vbuc1 + lda #0 + sta.z bob_charset_next_id + jsr charsetFindOrAddGlyph + // [163] phi from prepareBobs::@8 to prepareBobs::@1 [phi:prepareBobs::@8->prepareBobs::@1] + __b1_from___b8: + // [163] phi (byte) prepareBobs::bob_table_idx#6 = (byte) 0 [phi:prepareBobs::@8->prepareBobs::@1#0] -- vbuz1=vbuc1 + lda #0 + sta.z bob_table_idx + // [163] phi (byte) bob_charset_next_id#14 = (byte) bob_charset_next_id#16 [phi:prepareBobs::@8->prepareBobs::@1#1] -- register_copy + // [163] phi (byte) progress_idx#16 = (byte) 0 [phi:prepareBobs::@8->prepareBobs::@1#2] -- vbuz1=vbuc1 + lda #0 + sta.z progress_idx + // [163] phi (byte*) progress_cursor#15 = (const byte*) SCREEN_BASIC [phi:prepareBobs::@8->prepareBobs::@1#3] -- pbuz1=pbuc1 + lda #SCREEN_BASIC + sta.z progress_cursor+1 + // [163] phi (byte) prepareBobs::shift_y#2 = (byte) 0 [phi:prepareBobs::@8->prepareBobs::@1#4] -- vbuz1=vbuc1 + lda #0 + sta.z shift_y + jmp __b1 + // prepareBobs::@1 + __b1: + // [164] if((byte) prepareBobs::shift_y#2<(const byte) BOB_SHIFTS_Y) goto prepareBobs::@2 -- vbuz1_lt_vbuc1_then_la1 + lda.z shift_y + cmp #BOB_SHIFTS_Y + bcc __b2_from___b1 + jmp __breturn + // prepareBobs::@return + __breturn: + // [165] return + rts + // [166] phi from prepareBobs::@1 to prepareBobs::@2 [phi:prepareBobs::@1->prepareBobs::@2] + __b2_from___b1: + // [166] phi (byte) progress_idx#31 = (byte) progress_idx#16 [phi:prepareBobs::@1->prepareBobs::@2#0] -- register_copy + // [166] phi (byte*) progress_cursor#31 = (byte*) progress_cursor#15 [phi:prepareBobs::@1->prepareBobs::@2#1] -- register_copy + // [166] phi (byte) bob_charset_next_id#30 = (byte) bob_charset_next_id#14 [phi:prepareBobs::@1->prepareBobs::@2#2] -- register_copy + // [166] phi (byte) prepareBobs::bob_table_idx#12 = (byte) prepareBobs::bob_table_idx#6 [phi:prepareBobs::@1->prepareBobs::@2#3] -- register_copy + // [166] phi (byte) prepareBobs::shift_x#2 = (byte) 0 [phi:prepareBobs::@1->prepareBobs::@2#4] -- vbuz1=vbuc1 + lda #0 + sta.z shift_x + jmp __b2 + // prepareBobs::@2 + __b2: + // [167] if((byte) prepareBobs::shift_x#2<(const byte) BOB_SHIFTS_X) goto prepareBobs::@3 -- vbuz1_lt_vbuc1_then_la1 + lda.z shift_x + cmp #BOB_SHIFTS_X + bcc __b3 + // [168] phi from prepareBobs::@2 to prepareBobs::@4 [phi:prepareBobs::@2->prepareBobs::@4] + __b4_from___b2: + jmp __b4 + // prepareBobs::@4 + __b4: + // [169] call protoBobShiftDown + // [230] phi from prepareBobs::@4 to protoBobShiftDown [phi:prepareBobs::@4->protoBobShiftDown] + protoBobShiftDown_from___b4: + jsr protoBobShiftDown + jmp __b9 + // prepareBobs::@9 + __b9: + // [170] (byte) prepareBobs::shift_y#1 ← ++ (byte) prepareBobs::shift_y#2 -- vbuz1=_inc_vbuz1 + inc.z shift_y + // [163] phi from prepareBobs::@9 to prepareBobs::@1 [phi:prepareBobs::@9->prepareBobs::@1] + __b1_from___b9: + // [163] phi (byte) prepareBobs::bob_table_idx#6 = (byte) prepareBobs::bob_table_idx#12 [phi:prepareBobs::@9->prepareBobs::@1#0] -- register_copy + // [163] phi (byte) bob_charset_next_id#14 = (byte) bob_charset_next_id#30 [phi:prepareBobs::@9->prepareBobs::@1#1] -- register_copy + // [163] phi (byte) progress_idx#16 = (byte) progress_idx#31 [phi:prepareBobs::@9->prepareBobs::@1#2] -- register_copy + // [163] phi (byte*) progress_cursor#15 = (byte*) progress_cursor#31 [phi:prepareBobs::@9->prepareBobs::@1#3] -- register_copy + // [163] phi (byte) prepareBobs::shift_y#2 = (byte) prepareBobs::shift_y#1 [phi:prepareBobs::@9->prepareBobs::@1#4] -- register_copy + jmp __b1 + // prepareBobs::@3 + __b3: + // [171] (byte*) prepareBobs::bob_table#0 ← (const byte*) BOB_TABLES + (byte) prepareBobs::bob_table_idx#12 -- pbuz1=pbuc1_plus_vbuz2 + lda.z bob_table_idx + clc + adc #BOB_TABLES + adc #0 + sta.z bob_table+1 + // [172] phi from prepareBobs::@3 to prepareBobs::@5 [phi:prepareBobs::@3->prepareBobs::@5] + __b5_from___b3: + // [172] phi (byte*) progress_cursor#24 = (byte*) progress_cursor#31 [phi:prepareBobs::@3->prepareBobs::@5#0] -- register_copy + // [172] phi (byte) progress_idx#25 = (byte) progress_idx#31 [phi:prepareBobs::@3->prepareBobs::@5#1] -- register_copy + // [172] phi (byte*) prepareBobs::bob_table#2 = (byte*) prepareBobs::bob_table#0 [phi:prepareBobs::@3->prepareBobs::@5#2] -- register_copy + // [172] phi (byte) bob_charset_next_id#21 = (byte) bob_charset_next_id#30 [phi:prepareBobs::@3->prepareBobs::@5#3] -- register_copy + // [172] phi (byte*) prepareBobs::bob_glyph#2 = (const byte*) PROTO_BOB [phi:prepareBobs::@3->prepareBobs::@5#4] -- pbuz1=pbuc1 + lda #PROTO_BOB + sta.z bob_glyph+1 + // [172] phi (byte) prepareBobs::cell#2 = (byte) 0 [phi:prepareBobs::@3->prepareBobs::@5#5] -- vbuz1=vbuc1 + lda #0 + sta.z cell + jmp __b5 + // prepareBobs::@5 + __b5: + // [173] if((byte) prepareBobs::cell#2<(byte) 9) goto prepareBobs::@6 -- vbuz1_lt_vbuc1_then_la1 + lda.z cell + cmp #9 + bcc __b6 + jmp __b7 + // prepareBobs::@7 + __b7: + // [174] (byte) prepareBobs::bob_table_idx#1 ← ++ (byte) prepareBobs::bob_table_idx#12 -- vbuz1=_inc_vbuz1 + inc.z bob_table_idx + // [175] call protoBobShiftRight + // [213] phi from prepareBobs::@7 to protoBobShiftRight [phi:prepareBobs::@7->protoBobShiftRight] + protoBobShiftRight_from___b7: + jsr protoBobShiftRight + // [176] phi from prepareBobs::@7 to prepareBobs::@12 [phi:prepareBobs::@7->prepareBobs::@12] + __b12_from___b7: + jmp __b12 + // prepareBobs::@12 + __b12: + // [177] call protoBobShiftRight + // [213] phi from prepareBobs::@12 to protoBobShiftRight [phi:prepareBobs::@12->protoBobShiftRight] + protoBobShiftRight_from___b12: + jsr protoBobShiftRight + jmp __b13 + // prepareBobs::@13 + __b13: + // [178] (byte) prepareBobs::shift_x#1 ← ++ (byte) prepareBobs::shift_x#2 -- vbuz1=_inc_vbuz1 + inc.z shift_x + // [166] phi from prepareBobs::@13 to prepareBobs::@2 [phi:prepareBobs::@13->prepareBobs::@2] + __b2_from___b13: + // [166] phi (byte) progress_idx#31 = (byte) progress_idx#25 [phi:prepareBobs::@13->prepareBobs::@2#0] -- register_copy + // [166] phi (byte*) progress_cursor#31 = (byte*) progress_cursor#24 [phi:prepareBobs::@13->prepareBobs::@2#1] -- register_copy + // [166] phi (byte) bob_charset_next_id#30 = (byte) bob_charset_next_id#21 [phi:prepareBobs::@13->prepareBobs::@2#2] -- register_copy + // [166] phi (byte) prepareBobs::bob_table_idx#12 = (byte) prepareBobs::bob_table_idx#1 [phi:prepareBobs::@13->prepareBobs::@2#3] -- register_copy + // [166] phi (byte) prepareBobs::shift_x#2 = (byte) prepareBobs::shift_x#1 [phi:prepareBobs::@13->prepareBobs::@2#4] -- register_copy + jmp __b2 + // prepareBobs::@6 + __b6: + // [179] (byte*) charsetFindOrAddGlyph::glyph#1 ← (byte*) prepareBobs::bob_glyph#2 + // [180] call charsetFindOrAddGlyph + // [195] phi from prepareBobs::@6 to charsetFindOrAddGlyph [phi:prepareBobs::@6->charsetFindOrAddGlyph] + charsetFindOrAddGlyph_from___b6: + // [195] phi (byte*) charsetFindOrAddGlyph::glyph#10 = (byte*) charsetFindOrAddGlyph::glyph#1 [phi:prepareBobs::@6->charsetFindOrAddGlyph#0] -- register_copy + // [195] phi (byte) bob_charset_next_id#23 = (byte) bob_charset_next_id#21 [phi:prepareBobs::@6->charsetFindOrAddGlyph#1] -- register_copy + jsr charsetFindOrAddGlyph + // [181] (byte) charsetFindOrAddGlyph::return#1 ← (byte) charsetFindOrAddGlyph::glyph_id#11 -- vbuaa=vbuxx + txa + jmp __b10 + // prepareBobs::@10 + __b10: + // [182] (byte~) prepareBobs::$6 ← (byte) charsetFindOrAddGlyph::return#1 + // [183] *((byte*) prepareBobs::bob_table#2) ← (byte~) prepareBobs::$6 -- _deref_pbuz1=vbuaa + // Look for an existing char in BOB_CHARSET + ldy #0 + sta (bob_table),y + // [184] (byte*) prepareBobs::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 + (byte) 8 -- pbuz1=pbuz1_plus_vbuc1 + // Move to the next glyph + lda #8 + clc + adc.z bob_glyph + sta.z bob_glyph + bcc !+ + inc.z bob_glyph+1 + !: + // [185] (byte*) prepareBobs::bob_table#1 ← (byte*) prepareBobs::bob_table#2 + (const byte) BOB_SHIFTS_X*(const byte) BOB_SHIFTS_Y -- pbuz1=pbuz1_plus_vbuc1 + // Move to the next sub-table + lda #BOB_SHIFTS_X*BOB_SHIFTS_Y + clc + adc.z bob_table + sta.z bob_table + bcc !+ + inc.z bob_table+1 + !: + // [186] call progress_inc + jsr progress_inc + jmp __b11 + // prepareBobs::@11 + __b11: + // [187] (byte) prepareBobs::cell#1 ← ++ (byte) prepareBobs::cell#2 -- vbuz1=_inc_vbuz1 + inc.z cell + // [172] phi from prepareBobs::@11 to prepareBobs::@5 [phi:prepareBobs::@11->prepareBobs::@5] + __b5_from___b11: + // [172] phi (byte*) progress_cursor#24 = (byte*) progress_cursor#17 [phi:prepareBobs::@11->prepareBobs::@5#0] -- register_copy + // [172] phi (byte) progress_idx#25 = (byte) progress_idx#10 [phi:prepareBobs::@11->prepareBobs::@5#1] -- register_copy + // [172] phi (byte*) prepareBobs::bob_table#2 = (byte*) prepareBobs::bob_table#1 [phi:prepareBobs::@11->prepareBobs::@5#2] -- register_copy + // [172] phi (byte) bob_charset_next_id#21 = (byte) bob_charset_next_id#16 [phi:prepareBobs::@11->prepareBobs::@5#3] -- register_copy + // [172] phi (byte*) prepareBobs::bob_glyph#2 = (byte*) prepareBobs::bob_glyph#1 [phi:prepareBobs::@11->prepareBobs::@5#4] -- register_copy + // [172] phi (byte) prepareBobs::cell#2 = (byte) prepareBobs::cell#1 [phi:prepareBobs::@11->prepareBobs::@5#5] -- register_copy + jmp __b5 +} + // progress_inc +// Increase PETSCII progress one bit +// Done by increasing the character until the idx is 8 and then moving to the next char +progress_inc: { + // [188] (byte) progress_idx#8 ← ++ (byte) progress_idx#25 -- vbuz1=_inc_vbuz1 + inc.z progress_idx + // [189] if((byte) progress_idx#8!=(byte) 8) goto progress_inc::@1 -- vbuz1_neq_vbuc1_then_la1 + lda #8 + cmp.z progress_idx + bne __b1_from_progress_inc + jmp __b2 + // progress_inc::@2 + __b2: + // [190] *((byte*) progress_cursor#24) ← *((const byte*) progress_inc::progress_chars+(byte) 8) -- _deref_pbuz1=_deref_pbuc1 + lda progress_chars+8 + ldy #0 + sta (progress_cursor),y + // [191] (byte*) progress_cursor#8 ← ++ (byte*) progress_cursor#24 -- pbuz1=_inc_pbuz1 + inc.z progress_cursor + bne !+ + inc.z progress_cursor+1 + !: + // [192] phi from progress_inc::@2 to progress_inc::@1 [phi:progress_inc::@2->progress_inc::@1] + __b1_from___b2: + // [192] phi (byte*) progress_cursor#17 = (byte*) progress_cursor#8 [phi:progress_inc::@2->progress_inc::@1#0] -- register_copy + // [192] phi (byte) progress_idx#10 = (byte) 0 [phi:progress_inc::@2->progress_inc::@1#1] -- vbuz1=vbuc1 + lda #0 + sta.z progress_idx + jmp __b1 + // [192] phi from progress_inc to progress_inc::@1 [phi:progress_inc->progress_inc::@1] + __b1_from_progress_inc: + // [192] phi (byte*) progress_cursor#17 = (byte*) progress_cursor#24 [phi:progress_inc->progress_inc::@1#0] -- register_copy + // [192] phi (byte) progress_idx#10 = (byte) progress_idx#8 [phi:progress_inc->progress_inc::@1#1] -- register_copy + jmp __b1 + // progress_inc::@1 + __b1: + // [193] *((byte*) progress_cursor#17) ← *((const byte*) progress_inc::progress_chars + (byte) progress_idx#10) -- _deref_pbuz1=pbuc1_derefidx_vbuz2 + ldy.z progress_idx + lda progress_chars,y + ldy #0 + sta (progress_cursor),y + jmp __breturn + // progress_inc::@return + __breturn: + // [194] return + rts + // Progress characters + progress_chars: .byte $20, $65, $74, $75, $61, $f6, $e7, $ea, $e0 +} + // charsetFindOrAddGlyph +// Looks through a charset to find a glyph if present. If not present it is added. +// Returns the glyph ID +// charsetFindOrAddGlyph(byte* zeropage(6) glyph) +charsetFindOrAddGlyph: { + .label glyph = 6 + .label glyph_cursor = $11 + // [196] phi from charsetFindOrAddGlyph to charsetFindOrAddGlyph::@1 [phi:charsetFindOrAddGlyph->charsetFindOrAddGlyph::@1] + __b1_from_charsetFindOrAddGlyph: + // [196] phi (byte*) charsetFindOrAddGlyph::glyph_cursor#11 = (const byte*) BOB_CHARSET [phi:charsetFindOrAddGlyph->charsetFindOrAddGlyph::@1#0] -- pbuz1=pbuc1 + lda #BOB_CHARSET + sta.z glyph_cursor+1 + // [196] phi (byte) charsetFindOrAddGlyph::glyph_id#11 = (byte) 0 [phi:charsetFindOrAddGlyph->charsetFindOrAddGlyph::@1#1] -- vbuxx=vbuc1 + ldx #0 + jmp __b1 + // charsetFindOrAddGlyph::@1 + __b1: + // [197] if((byte) charsetFindOrAddGlyph::glyph_id#11!=(byte) bob_charset_next_id#23) goto charsetFindOrAddGlyph::@2 -- vbuxx_neq_vbuz1_then_la1 + cpx.z bob_charset_next_id + bne __b2_from___b1 + // [198] phi from charsetFindOrAddGlyph::@1 to charsetFindOrAddGlyph::@7 [phi:charsetFindOrAddGlyph::@1->charsetFindOrAddGlyph::@7] + __b7_from___b1: + // [198] phi (byte) charsetFindOrAddGlyph::i1#2 = (byte) 0 [phi:charsetFindOrAddGlyph::@1->charsetFindOrAddGlyph::@7#0] -- vbuyy=vbuc1 + ldy #0 + jmp __b7 + // Not found - add it + // charsetFindOrAddGlyph::@7 + __b7: + // [199] if((byte) charsetFindOrAddGlyph::i1#2<(byte) 8) goto charsetFindOrAddGlyph::@8 -- vbuyy_lt_vbuc1_then_la1 + cpy #8 + bcc __b8 + jmp __b9 + // charsetFindOrAddGlyph::@9 + __b9: + // [200] (byte) bob_charset_next_id#8 ← ++ (byte) bob_charset_next_id#23 -- vbuz1=_inc_vbuz1 + inc.z bob_charset_next_id + // [201] phi from charsetFindOrAddGlyph::@5 charsetFindOrAddGlyph::@9 to charsetFindOrAddGlyph::@return [phi:charsetFindOrAddGlyph::@5/charsetFindOrAddGlyph::@9->charsetFindOrAddGlyph::@return] + __breturn_from___b5: + __breturn_from___b9: + // [201] phi (byte) bob_charset_next_id#16 = (byte) bob_charset_next_id#23 [phi:charsetFindOrAddGlyph::@5/charsetFindOrAddGlyph::@9->charsetFindOrAddGlyph::@return#0] -- register_copy + jmp __breturn + // charsetFindOrAddGlyph::@return + __breturn: + // [202] return + rts + // charsetFindOrAddGlyph::@8 + __b8: + // [203] *((byte*) charsetFindOrAddGlyph::glyph_cursor#11 + (byte) charsetFindOrAddGlyph::i1#2) ← *((byte*) charsetFindOrAddGlyph::glyph#10 + (byte) charsetFindOrAddGlyph::i1#2) -- pbuz1_derefidx_vbuyy=pbuz2_derefidx_vbuyy + lda (glyph),y + sta (glyph_cursor),y + // [204] (byte) charsetFindOrAddGlyph::i1#1 ← ++ (byte) charsetFindOrAddGlyph::i1#2 -- vbuyy=_inc_vbuyy + iny + // [198] phi from charsetFindOrAddGlyph::@8 to charsetFindOrAddGlyph::@7 [phi:charsetFindOrAddGlyph::@8->charsetFindOrAddGlyph::@7] + __b7_from___b8: + // [198] phi (byte) charsetFindOrAddGlyph::i1#2 = (byte) charsetFindOrAddGlyph::i1#1 [phi:charsetFindOrAddGlyph::@8->charsetFindOrAddGlyph::@7#0] -- register_copy + jmp __b7 + // [205] phi from charsetFindOrAddGlyph::@1 to charsetFindOrAddGlyph::@2 [phi:charsetFindOrAddGlyph::@1->charsetFindOrAddGlyph::@2] + __b2_from___b1: + // [205] phi (byte) charsetFindOrAddGlyph::i#2 = (byte) 0 [phi:charsetFindOrAddGlyph::@1->charsetFindOrAddGlyph::@2#0] -- vbuyy=vbuc1 + ldy #0 + jmp __b2 + // charsetFindOrAddGlyph::@2 + __b2: + // [206] if((byte) charsetFindOrAddGlyph::i#2<(byte) 8) goto charsetFindOrAddGlyph::@3 -- vbuyy_lt_vbuc1_then_la1 + cpy #8 + bcc __b3 + // [208] phi from charsetFindOrAddGlyph::@2 to charsetFindOrAddGlyph::@5 [phi:charsetFindOrAddGlyph::@2->charsetFindOrAddGlyph::@5] + __b5_from___b2: + // [208] phi (byte) charsetFindOrAddGlyph::found#2 = (byte) 1 [phi:charsetFindOrAddGlyph::@2->charsetFindOrAddGlyph::@5#0] -- vbuaa=vbuc1 + lda #1 + jmp __b5 + // charsetFindOrAddGlyph::@3 + __b3: + // [207] if(*((byte*) charsetFindOrAddGlyph::glyph_cursor#11 + (byte) charsetFindOrAddGlyph::i#2)==*((byte*) charsetFindOrAddGlyph::glyph#10 + (byte) charsetFindOrAddGlyph::i#2)) goto charsetFindOrAddGlyph::@4 -- pbuz1_derefidx_vbuyy_eq_pbuz2_derefidx_vbuyy_then_la1 + lda (glyph_cursor),y + cmp (glyph),y + beq __b4 + // [208] phi from charsetFindOrAddGlyph::@3 to charsetFindOrAddGlyph::@5 [phi:charsetFindOrAddGlyph::@3->charsetFindOrAddGlyph::@5] + __b5_from___b3: + // [208] phi (byte) charsetFindOrAddGlyph::found#2 = (byte) 0 [phi:charsetFindOrAddGlyph::@3->charsetFindOrAddGlyph::@5#0] -- vbuaa=vbuc1 + lda #0 + jmp __b5 + // charsetFindOrAddGlyph::@5 + __b5: + // [209] if((byte) 0==(byte) charsetFindOrAddGlyph::found#2) goto charsetFindOrAddGlyph::@6 -- vbuc1_eq_vbuaa_then_la1 + cmp #0 + beq __b6 + jmp __breturn_from___b5 + // charsetFindOrAddGlyph::@6 + __b6: + // [210] (byte) charsetFindOrAddGlyph::glyph_id#1 ← ++ (byte) charsetFindOrAddGlyph::glyph_id#11 -- vbuxx=_inc_vbuxx + inx + // [211] (byte*) charsetFindOrAddGlyph::glyph_cursor#1 ← (byte*) charsetFindOrAddGlyph::glyph_cursor#11 + (byte) 8 -- pbuz1=pbuz1_plus_vbuc1 + lda #8 + clc + adc.z glyph_cursor + sta.z glyph_cursor + bcc !+ + inc.z glyph_cursor+1 + !: + // [196] phi from charsetFindOrAddGlyph::@6 to charsetFindOrAddGlyph::@1 [phi:charsetFindOrAddGlyph::@6->charsetFindOrAddGlyph::@1] + __b1_from___b6: + // [196] phi (byte*) charsetFindOrAddGlyph::glyph_cursor#11 = (byte*) charsetFindOrAddGlyph::glyph_cursor#1 [phi:charsetFindOrAddGlyph::@6->charsetFindOrAddGlyph::@1#0] -- register_copy + // [196] phi (byte) charsetFindOrAddGlyph::glyph_id#11 = (byte) charsetFindOrAddGlyph::glyph_id#1 [phi:charsetFindOrAddGlyph::@6->charsetFindOrAddGlyph::@1#1] -- register_copy + jmp __b1 + // charsetFindOrAddGlyph::@4 + __b4: + // [212] (byte) charsetFindOrAddGlyph::i#1 ← ++ (byte) charsetFindOrAddGlyph::i#2 -- vbuyy=_inc_vbuyy + iny + // [205] phi from charsetFindOrAddGlyph::@4 to charsetFindOrAddGlyph::@2 [phi:charsetFindOrAddGlyph::@4->charsetFindOrAddGlyph::@2] + __b2_from___b4: + // [205] phi (byte) charsetFindOrAddGlyph::i#2 = (byte) charsetFindOrAddGlyph::i#1 [phi:charsetFindOrAddGlyph::@4->charsetFindOrAddGlyph::@2#0] -- register_copy + jmp __b2 +} + // protoBobShiftRight +// Shift PROTO_BOB right one X pixel +protoBobShiftRight: { + .label carry = $e + .label i = $a + // [214] phi from protoBobShiftRight to protoBobShiftRight::@1 [phi:protoBobShiftRight->protoBobShiftRight::@1] + __b1_from_protoBobShiftRight: + // [214] phi (byte) protoBobShiftRight::carry#2 = (byte) 0 [phi:protoBobShiftRight->protoBobShiftRight::@1#0] -- vbuyy=vbuc1 + ldy #0 + // [214] phi (byte) protoBobShiftRight::j#3 = (byte) 0 [phi:protoBobShiftRight->protoBobShiftRight::@1#1] -- vbuxx=vbuc1 + ldx #0 + // [214] phi (byte) protoBobShiftRight::i#2 = (byte) 0 [phi:protoBobShiftRight->protoBobShiftRight::@1#2] -- vbuz1=vbuc1 + lda #0 + sta.z i + jmp __b1 + // protoBobShiftRight::@1 + __b1: + // [215] if((byte) protoBobShiftRight::i#2<(byte)(number) 3*(number) 3*(number) 8) goto protoBobShiftRight::@2 -- vbuz1_lt_vbuc1_then_la1 + lda.z i + cmp #3*3*8 + bcc __b2 + jmp __breturn + // protoBobShiftRight::@return + __breturn: + // [216] return + rts + // protoBobShiftRight::@2 + __b2: + // [217] (byte~) protoBobShiftRight::$1 ← *((const byte*) PROTO_BOB + (byte) protoBobShiftRight::j#3) & (byte) 1 -- vbuaa=pbuc1_derefidx_vbuxx_band_vbuc2 + lda #1 + and PROTO_BOB,x + // [218] if((byte) 0!=(byte~) protoBobShiftRight::$1) goto protoBobShiftRight::@3 -- vbuc1_neq_vbuaa_then_la1 + cmp #0 + bne __b3_from___b2 + // [220] phi from protoBobShiftRight::@2 to protoBobShiftRight::@4 [phi:protoBobShiftRight::@2->protoBobShiftRight::@4] + __b4_from___b2: + // [220] phi (byte) protoBobShiftRight::carry#1 = (byte) 0 [phi:protoBobShiftRight::@2->protoBobShiftRight::@4#0] -- vbuz1=vbuc1 + lda #0 + sta.z carry + jmp __b4 + // [219] phi from protoBobShiftRight::@2 to protoBobShiftRight::@3 [phi:protoBobShiftRight::@2->protoBobShiftRight::@3] + __b3_from___b2: + jmp __b3 + // protoBobShiftRight::@3 + __b3: + // [220] phi from protoBobShiftRight::@3 to protoBobShiftRight::@4 [phi:protoBobShiftRight::@3->protoBobShiftRight::@4] + __b4_from___b3: + // [220] phi (byte) protoBobShiftRight::carry#1 = (byte) $80 [phi:protoBobShiftRight::@3->protoBobShiftRight::@4#0] -- vbuz1=vbuc1 + lda #$80 + sta.z carry + jmp __b4 + // protoBobShiftRight::@4 + __b4: + // [221] (byte~) protoBobShiftRight::$5 ← *((const byte*) PROTO_BOB + (byte) protoBobShiftRight::j#3) >> (byte) 1 -- vbuaa=pbuc1_derefidx_vbuxx_ror_1 + lda PROTO_BOB,x + lsr + // [222] (byte~) protoBobShiftRight::$6 ← (byte) protoBobShiftRight::carry#2 | (byte~) protoBobShiftRight::$5 -- vbuaa=vbuyy_bor_vbuaa + sty.z $ff + ora.z $ff + // [223] *((const byte*) PROTO_BOB + (byte) protoBobShiftRight::j#3) ← (byte~) protoBobShiftRight::$6 -- pbuc1_derefidx_vbuxx=vbuaa + // Shift value and add old carry + sta PROTO_BOB,x + // [224] if((byte) protoBobShiftRight::j#3>=(byte) $30) goto protoBobShiftRight::@5 -- vbuxx_ge_vbuc1_then_la1 + // Increment j to iterate over the PROTO_BOB left-to-right, top-to-bottom (0, 24, 48, 1, 25, 49, ...) + cpx #$30 + bcs __b5 + jmp __b7 + // protoBobShiftRight::@7 + __b7: + // [225] (byte) protoBobShiftRight::j#2 ← (byte) protoBobShiftRight::j#3 + (byte) $18 -- vbuxx=vbuxx_plus_vbuc1 + txa + axs #-[$18] + // [226] phi from protoBobShiftRight::@5 protoBobShiftRight::@7 to protoBobShiftRight::@6 [phi:protoBobShiftRight::@5/protoBobShiftRight::@7->protoBobShiftRight::@6] + __b6_from___b5: + __b6_from___b7: + // [226] phi (byte) protoBobShiftRight::j#10 = (byte) protoBobShiftRight::j#1 [phi:protoBobShiftRight::@5/protoBobShiftRight::@7->protoBobShiftRight::@6#0] -- register_copy + jmp __b6 + // protoBobShiftRight::@6 + __b6: + // [227] (byte) protoBobShiftRight::i#1 ← ++ (byte) protoBobShiftRight::i#2 -- vbuz1=_inc_vbuz1 + inc.z i + // [228] (byte) protoBobShiftRight::carry#10 ← (byte) protoBobShiftRight::carry#1 -- vbuyy=vbuz1 + ldy.z carry + // [214] phi from protoBobShiftRight::@6 to protoBobShiftRight::@1 [phi:protoBobShiftRight::@6->protoBobShiftRight::@1] + __b1_from___b6: + // [214] phi (byte) protoBobShiftRight::carry#2 = (byte) protoBobShiftRight::carry#10 [phi:protoBobShiftRight::@6->protoBobShiftRight::@1#0] -- register_copy + // [214] phi (byte) protoBobShiftRight::j#3 = (byte) protoBobShiftRight::j#10 [phi:protoBobShiftRight::@6->protoBobShiftRight::@1#1] -- register_copy + // [214] phi (byte) protoBobShiftRight::i#2 = (byte) protoBobShiftRight::i#1 [phi:protoBobShiftRight::@6->protoBobShiftRight::@1#2] -- register_copy + jmp __b1 + // protoBobShiftRight::@5 + __b5: + // [229] (byte) protoBobShiftRight::j#1 ← (byte) protoBobShiftRight::j#3 - (byte) $2f -- vbuxx=vbuxx_minus_vbuc1 + txa + axs #$2f + jmp __b6_from___b5 +} + // protoBobShiftDown +// Shift PROTO_BOB down one Y pixel +// At the same time restore PROTO_BOB X by shifting 8 pixels left +protoBobShiftDown: { + // [231] phi from protoBobShiftDown to protoBobShiftDown::@1 [phi:protoBobShiftDown->protoBobShiftDown::@1] + __b1_from_protoBobShiftDown: + // [231] phi (byte) protoBobShiftDown::i#2 = (byte) $17 [phi:protoBobShiftDown->protoBobShiftDown::@1#0] -- vbuxx=vbuc1 + ldx #$17 + jmp __b1 + // protoBobShiftDown::@1 + __b1: + // [232] if((byte) protoBobShiftDown::i#2>(byte) 0) goto protoBobShiftDown::@2 -- vbuxx_gt_0_then_la1 + cpx #0 + bne __b2 + jmp __b3 + // protoBobShiftDown::@3 + __b3: + // [233] *((const byte*) PROTO_BOB) ← (byte) 0 -- _deref_pbuc1=vbuc2 + lda #0 + sta PROTO_BOB + // [234] *((const byte*) PROTO_BOB+(byte) $18) ← (byte) 0 -- _deref_pbuc1=vbuc2 + lda #0 + sta PROTO_BOB+$18 + // [235] *((const byte*) PROTO_BOB+(byte) $30) ← (byte) 0 -- _deref_pbuc1=vbuc2 + lda #0 + sta PROTO_BOB+$30 + jmp __breturn + // protoBobShiftDown::@return + __breturn: + // [236] return + rts + // protoBobShiftDown::@2 + __b2: + // [237] *((const byte*) PROTO_BOB + (byte) protoBobShiftDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $17 + (byte) protoBobShiftDown::i#2) -- pbuc1_derefidx_vbuxx=pbuc2_derefidx_vbuxx + lda PROTO_BOB+$17,x + sta PROTO_BOB,x + // [238] *((const byte*) PROTO_BOB+(byte) $18 + (byte) protoBobShiftDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $2f + (byte) protoBobShiftDown::i#2) -- pbuc1_derefidx_vbuxx=pbuc2_derefidx_vbuxx + lda PROTO_BOB+$2f,x + sta PROTO_BOB+$18,x + // [239] *((const byte*) PROTO_BOB+(byte) $30 + (byte) protoBobShiftDown::i#2) ← (byte) 0 -- pbuc1_derefidx_vbuxx=vbuc2 + lda #0 + sta PROTO_BOB+$30,x + // [240] (byte) protoBobShiftDown::i#1 ← -- (byte) protoBobShiftDown::i#2 -- vbuxx=_dec_vbuxx + dex + // [231] phi from protoBobShiftDown::@2 to protoBobShiftDown::@1 [phi:protoBobShiftDown::@2->protoBobShiftDown::@1] + __b1_from___b2: + // [231] phi (byte) protoBobShiftDown::i#2 = (byte) protoBobShiftDown::i#1 [phi:protoBobShiftDown::@2->protoBobShiftDown::@1#0] -- register_copy + jmp __b1 +} + // progress_init +// Initialize the PETSCII progress bar +progress_init: { + jmp __breturn + // progress_init::@return + __breturn: + // [242] return + rts +} + // mulf_init +// Initialize the mulf_sqr multiplication tables with f(x)=int(x*x/4) +mulf_init: { + // x/2 + .label c = $d + // Counter used for determining x%2==0 + .label sqr1_hi = $f + // Fill mulf_sqr1 = f(x) = int(x*x/4): If f(x) = x*x/4 then f(x+1) = f(x) + x/2 + 1/4 + .label sqr = $b + .label sqr1_lo = 6 + // Decrease or increase x_255 - initially we decrease + .label sqr2_hi = 8 + .label sqr2_lo = $11 + //Start with g(0)=f(255) + .label dir = $e + // [244] phi from mulf_init to mulf_init::@1 [phi:mulf_init->mulf_init::@1] + __b1_from_mulf_init: + // [244] phi (byte) mulf_init::x_2#3 = (byte) 0 [phi:mulf_init->mulf_init::@1#0] -- vbuxx=vbuc1 + ldx #0 + // [244] phi (byte*) mulf_init::sqr1_hi#2 = (const byte*) mulf_sqr1_hi+(byte) 1 [phi:mulf_init->mulf_init::@1#1] -- pbuz1=pbuc1 + lda #mulf_sqr1_hi+1 + sta.z sqr1_hi+1 + // [244] phi (word) mulf_init::sqr#4 = (byte) 0 [phi:mulf_init->mulf_init::@1#2] -- vwuz1=vbuc1 + lda #<0 + sta.z sqr + lda #>0 + sta.z sqr+1 + // [244] phi (byte) mulf_init::c#2 = (byte) 0 [phi:mulf_init->mulf_init::@1#3] -- vbuz1=vbuc1 + lda #0 + sta.z c + // [244] phi (byte*) mulf_init::sqr1_lo#2 = (const byte*) mulf_sqr1_lo+(byte) 1 [phi:mulf_init->mulf_init::@1#4] -- pbuz1=pbuc1 + lda #mulf_sqr1_lo+1 + sta.z sqr1_lo+1 + jmp __b1 + // mulf_init::@1 + __b1: + // [245] if((byte*) mulf_init::sqr1_lo#2!=(const byte*) mulf_sqr1_lo+(word) $200) goto mulf_init::@2 -- pbuz1_neq_pbuc1_then_la1 + lda.z sqr1_lo+1 + cmp #>mulf_sqr1_lo+$200 + bne __b2 + lda.z sqr1_lo + cmp #mulf_init::@5] + __b5_from___b1: + // [246] phi (byte) mulf_init::dir#2 = (byte) $ff [phi:mulf_init::@1->mulf_init::@5#0] -- vbuz1=vbuc1 + lda #$ff + sta.z dir + // [246] phi (byte*) mulf_init::sqr2_hi#2 = (const byte*) mulf_sqr2_hi [phi:mulf_init::@1->mulf_init::@5#1] -- pbuz1=pbuc1 + lda #mulf_sqr2_hi + sta.z sqr2_hi+1 + // [246] phi (byte) mulf_init::x_255#2 = (byte) -1 [phi:mulf_init::@1->mulf_init::@5#2] -- vbuxx=vbuc1 + ldx #-1 + // [246] phi (byte*) mulf_init::sqr2_lo#2 = (const byte*) mulf_sqr2_lo [phi:mulf_init::@1->mulf_init::@5#3] -- pbuz1=pbuc1 + lda #mulf_sqr2_lo + sta.z sqr2_lo+1 + jmp __b5 + // mulf_init::@5 + __b5: + // [247] if((byte*) mulf_init::sqr2_lo#2!=(const byte*) mulf_sqr2_lo+(word) $1ff) goto mulf_init::@6 -- pbuz1_neq_pbuc1_then_la1 + lda.z sqr2_lo+1 + cmp #>mulf_sqr2_lo+$1ff + bne __b6 + lda.z sqr2_lo + cmp #mulf_init::@8] + __b8_from___b6: + // [257] phi (byte) mulf_init::dir#4 = (byte) 1 [phi:mulf_init::@6->mulf_init::@8#0] -- vbuz1=vbuc1 + lda #1 + sta.z dir + jmp __b8 + // [256] phi from mulf_init::@6 to mulf_init::@9 [phi:mulf_init::@6->mulf_init::@9] + __b9_from___b6: + jmp __b9 + // mulf_init::@9 + __b9: + // [257] phi from mulf_init::@9 to mulf_init::@8 [phi:mulf_init::@9->mulf_init::@8] + __b8_from___b9: + // [257] phi (byte) mulf_init::dir#4 = (byte) mulf_init::dir#2 [phi:mulf_init::@9->mulf_init::@8#0] -- register_copy + jmp __b8 + // mulf_init::@8 + __b8: + // [258] (byte*) mulf_init::sqr2_lo#1 ← ++ (byte*) mulf_init::sqr2_lo#2 -- pbuz1=_inc_pbuz1 + inc.z sqr2_lo + bne !+ + inc.z sqr2_lo+1 + !: + // [246] phi from mulf_init::@8 to mulf_init::@5 [phi:mulf_init::@8->mulf_init::@5] + __b5_from___b8: + // [246] phi (byte) mulf_init::dir#2 = (byte) mulf_init::dir#4 [phi:mulf_init::@8->mulf_init::@5#0] -- register_copy + // [246] phi (byte*) mulf_init::sqr2_hi#2 = (byte*) mulf_init::sqr2_hi#1 [phi:mulf_init::@8->mulf_init::@5#1] -- register_copy + // [246] phi (byte) mulf_init::x_255#2 = (byte) mulf_init::x_255#1 [phi:mulf_init::@8->mulf_init::@5#2] -- register_copy + // [246] phi (byte*) mulf_init::sqr2_lo#2 = (byte*) mulf_init::sqr2_lo#1 [phi:mulf_init::@8->mulf_init::@5#3] -- register_copy + jmp __b5 + // mulf_init::@2 + __b2: + // [259] (byte) mulf_init::c#1 ← ++ (byte) mulf_init::c#2 -- vbuz1=_inc_vbuz1 + inc.z c + // [260] (byte~) mulf_init::$1 ← (byte) mulf_init::c#1 & (byte) 1 -- vbuaa=vbuz1_band_vbuc1 + lda #1 + and.z c + // [261] if((byte~) mulf_init::$1!=(byte) 0) goto mulf_init::@3 -- vbuaa_neq_0_then_la1 + cmp #0 + bne __b3_from___b2 + jmp __b4 + // mulf_init::@4 + __b4: + // [262] (byte) mulf_init::x_2#1 ← ++ (byte) mulf_init::x_2#3 -- vbuxx=_inc_vbuxx + inx + // [263] (word) mulf_init::sqr#2 ← ++ (word) mulf_init::sqr#4 -- vwuz1=_inc_vwuz1 + inc.z sqr + bne !+ + inc.z sqr+1 + !: + // [264] phi from mulf_init::@2 mulf_init::@4 to mulf_init::@3 [phi:mulf_init::@2/mulf_init::@4->mulf_init::@3] + __b3_from___b2: + __b3_from___b4: + // [264] phi (byte) mulf_init::x_2#2 = (byte) mulf_init::x_2#3 [phi:mulf_init::@2/mulf_init::@4->mulf_init::@3#0] -- register_copy + // [264] phi (word) mulf_init::sqr#3 = (word) mulf_init::sqr#4 [phi:mulf_init::@2/mulf_init::@4->mulf_init::@3#1] -- register_copy + jmp __b3 + // mulf_init::@3 + __b3: + // [265] (byte~) mulf_init::$4 ← < (word) mulf_init::sqr#3 -- vbuaa=_lo_vwuz1 + lda.z sqr + // [266] *((byte*) mulf_init::sqr1_lo#2) ← (byte~) mulf_init::$4 -- _deref_pbuz1=vbuaa + ldy #0 + sta (sqr1_lo),y + // [267] (byte~) mulf_init::$5 ← > (word) mulf_init::sqr#3 -- vbuaa=_hi_vwuz1 + lda.z sqr+1 + // [268] *((byte*) mulf_init::sqr1_hi#2) ← (byte~) mulf_init::$5 -- _deref_pbuz1=vbuaa + ldy #0 + sta (sqr1_hi),y + // [269] (byte*) mulf_init::sqr1_hi#1 ← ++ (byte*) mulf_init::sqr1_hi#2 -- pbuz1=_inc_pbuz1 + inc.z sqr1_hi + bne !+ + inc.z sqr1_hi+1 + !: + // [270] (word) mulf_init::sqr#1 ← (word) mulf_init::sqr#3 + (byte) mulf_init::x_2#2 -- vwuz1=vwuz1_plus_vbuxx + txa + clc + adc.z sqr + sta.z sqr + bcc !+ + inc.z sqr+1 + !: + // [271] (byte*) mulf_init::sqr1_lo#1 ← ++ (byte*) mulf_init::sqr1_lo#2 -- pbuz1=_inc_pbuz1 + inc.z sqr1_lo + bne !+ + inc.z sqr1_lo+1 + !: + // [244] phi from mulf_init::@3 to mulf_init::@1 [phi:mulf_init::@3->mulf_init::@1] + __b1_from___b3: + // [244] phi (byte) mulf_init::x_2#3 = (byte) mulf_init::x_2#2 [phi:mulf_init::@3->mulf_init::@1#0] -- register_copy + // [244] phi (byte*) mulf_init::sqr1_hi#2 = (byte*) mulf_init::sqr1_hi#1 [phi:mulf_init::@3->mulf_init::@1#1] -- register_copy + // [244] phi (word) mulf_init::sqr#4 = (word) mulf_init::sqr#1 [phi:mulf_init::@3->mulf_init::@1#2] -- register_copy + // [244] phi (byte) mulf_init::c#2 = (byte) mulf_init::c#1 [phi:mulf_init::@3->mulf_init::@1#3] -- register_copy + // [244] phi (byte*) mulf_init::sqr1_lo#2 = (byte*) mulf_init::sqr1_lo#1 [phi:mulf_init::@3->mulf_init::@1#4] -- register_copy + jmp __b1 +} + // File Data + // Keyboard row bitmask as expected by CIA#1 Port A when reading a specific keyboard matrix row (rows are numbered 0-7) + keyboard_matrix_row_bitmask: .byte $fe, $fd, $fb, $f7, $ef, $df, $bf, $7f + // Keyboard matrix column bitmasks for a specific keybooard matrix column when reading the keyboard. (columns are numbered 0-7) + keyboard_matrix_col_bitmask: .byte 1, 2, 4, 8, $10, $20, $40, $80 + // mulf_sqr tables will contain f(x)=int(x*x/4) and g(x) = f(x-255). + // f(x) = >(( x * x )/4) + .align $100 + mulf_sqr1_hi: .fill $200, 0 + // g(x) = >((( x - 255) * ( x - 255 ))/4) + .align $100 + mulf_sqr2_hi: .fill $200, 0 + // The prototype BOB (a 3x3 char image with a bob image in the upper 2x2 chars) + // The chars are layout as follows with data in chars 0, 1, 3, 4 initially + // 0 3 6 + // 1 4 7 + // 2 5 8 +PROTO_BOB: +.var pic = LoadPicture("smiley.png", List().add($000000, $ffffff)) + .for (var x=0;x<3; x++) + .for (var y=0; y<24; y++) + .byte pic.getSinglecolorByte(x,y) + + // Sine and Cosine tables + // Angles: $00=0, $80=PI,$100=2*PI + // Sine/Cosine: signed fixed [-$7f,$7f] + .align $40 +SIN: +.for(var i=0;i<$140;i++) + .byte >round($7fff*sin(i*2*PI/256)) + + // Tables containing the char to use for a specific cell of a shifted BOB. + // char_id = BOB_TABLES[cell*BOB_SUBTABLE_SIZE + shift_y*BOB_SHIFTS_X + shift_x]; + BOB_TABLES: .fill 9*8*4, 0 + // Table used for deleting rendered BOB's. Contains pointers to first char of each BOB. + RENDERBOB_CLEANUP: .fill 2*NUM_BOBS, 0 + // *40 Table unsigned int[0x20] MUL40 = { ((unsigned int)i)*40 }; + MUL40: .fill 2*$20, 0 + +ASSEMBLER OPTIMIZATIONS +Removing instruction jmp __b1 +Removing instruction jmp __bend +Removing instruction jmp __b9 +Removing instruction jmp __b10 +Removing instruction jmp vicSelectGfxBank1 +Removing instruction jmp vicSelectGfxBank1_toDd001 +Removing instruction jmp vicSelectGfxBank1___b1 +Removing instruction jmp toD0181 +Removing instruction jmp __b7 +Removing instruction jmp __b1 +Removing instruction jmp __b2 +Removing instruction jmp __b3 +Removing instruction jmp __b11 +Removing instruction jmp __b4 +Removing instruction jmp __b12 +Removing instruction jmp __b13 +Removing instruction jmp __b14 +Removing instruction jmp __b5 +Removing instruction jmp __b15 +Removing instruction jmp __b6 +Removing instruction jmp __b16 +Removing instruction jmp vicSelectGfxBank2 +Removing instruction jmp vicSelectGfxBank2_toDd001 +Removing instruction jmp vicSelectGfxBank2___b1 +Removing instruction jmp toD0182 +Removing instruction jmp __b8 +Removing instruction jmp __breturn +Removing instruction jmp __b1 +Removing instruction jmp __breturn +Removing instruction jmp __breturn +Removing instruction jmp __breturn +Removing instruction jmp mulf8s_prepare1 +Removing instruction jmp __b1 +Removing instruction jmp __b2 +Removing instruction jmp __breturn +Removing instruction jmp __b5 +Removing instruction jmp __b3 +Removing instruction jmp __b1 +Removing instruction jmp __b4 +Removing instruction jmp __b2 +Removing instruction jmp __breturn +Removing instruction jmp __breturn +Removing instruction jmp __breturn +Removing instruction jmp __b1 +Removing instruction jmp __breturn +Removing instruction jmp __b1 +Removing instruction jmp __breturn +Removing instruction jmp __b1 +Removing instruction jmp __b2 +Removing instruction jmp __breturn +Removing instruction jmp __b8 +Removing instruction jmp __b1 +Removing instruction jmp __breturn +Removing instruction jmp __b2 +Removing instruction jmp __b4 +Removing instruction jmp __b9 +Removing instruction jmp __b5 +Removing instruction jmp __b7 +Removing instruction jmp __b12 +Removing instruction jmp __b13 +Removing instruction jmp __b10 +Removing instruction jmp __b11 +Removing instruction jmp __b2 +Removing instruction jmp __b1 +Removing instruction jmp __breturn +Removing instruction jmp __b1 +Removing instruction jmp __b7 +Removing instruction jmp __b9 +Removing instruction jmp __breturn +Removing instruction jmp __b2 +Removing instruction jmp __b5 +Removing instruction jmp __b1 +Removing instruction jmp __breturn +Removing instruction jmp __b3 +Removing instruction jmp __b4 +Removing instruction jmp __b7 +Removing instruction jmp __b6 +Removing instruction jmp __b1 +Removing instruction jmp __b3 +Removing instruction jmp __breturn +Removing instruction jmp __breturn +Removing instruction jmp __b1 +Removing instruction jmp __b5 +Removing instruction jmp __b7 +Removing instruction jmp __breturn +Removing instruction jmp __b9 +Removing instruction jmp __b8 +Removing instruction jmp __b4 +Removing instruction jmp __b3 +Succesful ASM optimization Pass5NextJumpElimination +Replacing instruction ldx memB with TAX +Removing instruction lda memA +Replacing instruction ldy #0 with TAY +Removing instruction lda #0 +Removing instruction lda #0 +Removing instruction lda #0 +Removing instruction lda #0 +Removing instruction lda #0 +Removing instruction lda #0 +Removing instruction lda #0 +Removing instruction lda #0 +Removing instruction lda #0 +Replacing instruction lda #0 with TXA +Removing instruction lda #0 +Removing instruction lda #0 +Replacing instruction lda #<0 with TXA +Removing instruction lda #>0 +Removing instruction lda #0 +Removing instruction ldy #0 +Removing instruction ldy #0 +Succesful ASM optimization Pass5UnnecesaryLoadElimination +Replacing label __bbegin with __b1 +Replacing label __b4_from___b14 with __b4 +Replacing label __b6_from___b15 with __b6 +Replacing label __b1 with __b2 +Replacing label __b6_from___b16 with __b6 +Replacing label __b1_from___b5 with __b1 +Replacing label __b2_from___b1 with __b2 +Replacing label __b1_from___b1 with __b1 +Replacing label __b1_from___b1 with __b1 +Replacing label __b2_from___b2 with __b2 +Replacing label __b1_from_progress_inc with __b1 +Replacing label __breturn_from___b5 with __breturn +Replacing label __b3_from___b2 with __b3 +Replacing label __b6_from___b5 with __b6 +Replacing label __b9_from___b6 with __b8 +Replacing label __b3_from___b2 with __b3 +Removing instruction __bbegin: +Removing instruction __b1_from___bbegin: +Removing instruction main_from___b1: +Removing instruction __bend_from___b1: +Removing instruction __b9_from_main: +Removing instruction prepareBobs_from___b9: +Removing instruction __b10_from___b9: +Removing instruction renderBobInit_from___b10: +Removing instruction vicSelectGfxBank1_toDd001_from_vicSelectGfxBank1: +Removing instruction vicSelectGfxBank1_toDd001: +Removing instruction toD0181_from_vicSelectGfxBank1___b1: +Removing instruction toD0181: +Removing instruction __b1: +Removing instruction __b4_from___b14: +Removing instruction __b6_from___b15: +Removing instruction __b6_from___b16: +Removing instruction keyboard_key_pressed_from___b6: +Removing instruction vicSelectGfxBank2_toDd001_from_vicSelectGfxBank2: +Removing instruction vicSelectGfxBank2_toDd001: +Removing instruction toD0182_from_vicSelectGfxBank2___b1: +Removing instruction toD0182: +Removing instruction __breturn: +Removing instruction __b1_from___b3: +Removing instruction __b1_from___b5: +Removing instruction __b2_from___b1: +Removing instruction __b2_from___b4: +Removing instruction __breturn: +Removing instruction __b1_from___b1: +Removing instruction __b1_from___b1: +Removing instruction __b2_from___b2: +Removing instruction __b8_from_prepareBobs: +Removing instruction charsetFindOrAddGlyph_from___b8: +Removing instruction __b4_from___b2: +Removing instruction protoBobShiftDown_from___b4: +Removing instruction __b12_from___b7: +Removing instruction protoBobShiftRight_from___b12: +Removing instruction charsetFindOrAddGlyph_from___b6: +Removing instruction __b1_from_progress_inc: +Removing instruction __breturn_from___b5: +Removing instruction __breturn_from___b9: +Removing instruction __b3_from___b2: +Removing instruction __b4_from___b3: +Removing instruction __b6_from___b5: +Removing instruction __b6_from___b7: +Removing instruction __b9_from___b6: +Removing instruction __b9: +Removing instruction __b8_from___b9: +Removing instruction __b3_from___b2: +Removing instruction __b3_from___b4: +Succesful ASM optimization Pass5RedundantLabelElimination +Removing instruction __bend: +Removing instruction mulf_init_from_main: +Removing instruction __b9: +Removing instruction __b10: +Removing instruction vicSelectGfxBank1: +Removing instruction vicSelectGfxBank1___b1: +Removing instruction __b7: +Removing instruction memset_from___b7: +Removing instruction __b1_from___b7: +Removing instruction __b3: +Removing instruction renderBobCleanup_from___b3: +Removing instruction __b11: +Removing instruction __b4_from___b11: +Removing instruction mulf8s_from___b4: +Removing instruction __b12: +Removing instruction mulf8s_from___b12: +Removing instruction __b13: +Removing instruction __b14: +Removing instruction __b5: +Removing instruction keyboard_key_pressed_from___b5: +Removing instruction __b15: +Removing instruction __b1_from___b15: +Removing instruction __b16: +Removing instruction vicSelectGfxBank2: +Removing instruction vicSelectGfxBank2___b1: +Removing instruction __b8: +Removing instruction __breturn: +Removing instruction __b1: +Removing instruction __breturn: +Removing instruction __breturn: +Removing instruction __breturn: +Removing instruction mulf8s_prepare1: +Removing instruction __b1: +Removing instruction __b2: +Removing instruction __b5: +Removing instruction __b3: +Removing instruction __b4: +Removing instruction __breturn: +Removing instruction __breturn: +Removing instruction __b1_from_renderBobCleanup: +Removing instruction __breturn: +Removing instruction __b1_from_memset: +Removing instruction __breturn: +Removing instruction __b1_from___b2: +Removing instruction __b1_from_renderBobInit: +Removing instruction __b2_from___b1: +Removing instruction __breturn: +Removing instruction progress_init_from_prepareBobs: +Removing instruction __b8: +Removing instruction __b1_from___b8: +Removing instruction __breturn: +Removing instruction __b4: +Removing instruction __b9: +Removing instruction __b1_from___b9: +Removing instruction __b5_from___b3: +Removing instruction __b7: +Removing instruction protoBobShiftRight_from___b7: +Removing instruction __b12: +Removing instruction __b13: +Removing instruction __b2_from___b13: +Removing instruction __b10: +Removing instruction __b11: +Removing instruction __b5_from___b11: +Removing instruction __b2: +Removing instruction __b1_from___b2: +Removing instruction __breturn: +Removing instruction __b1_from_charsetFindOrAddGlyph: +Removing instruction __b7_from___b1: +Removing instruction __b9: +Removing instruction __b7_from___b8: +Removing instruction __b5_from___b2: +Removing instruction __b5_from___b3: +Removing instruction __b1_from___b6: +Removing instruction __b2_from___b4: +Removing instruction __b1_from_protoBobShiftRight: +Removing instruction __breturn: +Removing instruction __b4_from___b2: +Removing instruction __b7: +Removing instruction __b1_from___b6: +Removing instruction __b1_from_protoBobShiftDown: +Removing instruction __b3: +Removing instruction __breturn: +Removing instruction __b1_from___b2: +Removing instruction __breturn: +Removing instruction __b1_from_mulf_init: +Removing instruction __b5_from___b1: +Removing instruction __b7: +Removing instruction __breturn: +Removing instruction __b8_from___b6: +Removing instruction __b5_from___b8: +Removing instruction __b4: +Removing instruction __b1_from___b3: +Succesful ASM optimization Pass5UnusedLabelElimination +Updating BasicUpstart to call main directly +Removing instruction jsr main +Succesful ASM optimization Pass5SkipBegin +Replacing jump to rts with rts in jmp __breturn +Succesful ASM optimization Pass5DoubleJumpElimination +Relabelling long label __b2_from___b1 to b1 +Relabelling long label __b2_from___b1 to b1 +Succesful ASM optimization Pass5RelabelLongLabels +Removing instruction jmp __b4 +Removing instruction jmp __b1 +Removing instruction jmp __b1 +Removing instruction jmp __b2 +Removing instruction jmp __b1 +Removing instruction jmp __b8 +Succesful ASM optimization Pass5NextJumpElimination +Removing instruction __b1: +Removing instruction __breturn: +Succesful ASM optimization Pass5UnusedLabelElimination + +FINAL SYMBOL TABLE +(label) @1 +(label) @begin +(label) @end +(const byte*) BOB_CHARSET = (byte*) 8192 +(const byte*) BOB_SCREEN = (byte*) 10240 +(const byte) BOB_SHIFTS_X = (number) 4 +(const byte) BOB_SHIFTS_Y = (number) 8 +(const byte) BOB_SUBTABLE_SIZE = (const byte) BOB_SHIFTS_X*(const byte) BOB_SHIFTS_Y +(const byte*) BOB_TABLES = { fill( 9*8*4, 0) } +(const byte*) BORDERCOL = (byte*) 53280 +(const byte*) CHARSET_BASIC = (byte*) 4096 +(const byte*) CIA1_PORT_A = (byte*) 56320 +(const byte*) CIA1_PORT_B = (byte*) 56321 +(const byte*) CIA2_PORT_A = (byte*) 56576 +(const byte*) CIA2_PORT_A_DDR = (byte*) 56578 +(const signed byte*) COS = (const signed byte*) SIN+(byte) $40 +(const byte*) D018 = (byte*) 53272 +(const byte) KEY_SPACE = (number) $3c +(const word*) MUL40 = { fill( $20, 0) } +(const byte) NUM_BOBS = (number) $14 +(const byte*) PROTO_BOB = kickasm {{ .var pic = LoadPicture("smiley.png", List().add($000000, $ffffff)) + .for (var x=0;x<3; x++) + .for (var y=0; y<24; y++) + .byte pic.getSinglecolorByte(x,y) + }} +(const byte) RADIX::BINARY = (number) 2 +(const byte) RADIX::DECIMAL = (number) $a +(const byte) RADIX::HEXADECIMAL = (number) $10 +(const byte) RADIX::OCTAL = (number) 8 +(const byte*) RASTER = (byte*) 53266 +(const byte**) RENDERBOB_CLEANUP = { fill( NUM_BOBS, 0) } +(const byte*) SCREEN_BASIC = (byte*) 1024 +(const signed byte*) SIN = kickasm {{ .for(var i=0;i<$140;i++) + .byte >round($7fff*sin(i*2*PI/256)) + }} +(const byte) SIZEOF_POINTER = (byte) 2 +(byte) bob_charset_next_id +(byte) bob_charset_next_id#14 bob_charset_next_id zp[1]:13 12.0 +(byte) bob_charset_next_id#16 bob_charset_next_id zp[1]:13 1000.5454545454544 +(byte) bob_charset_next_id#21 bob_charset_next_id zp[1]:13 275.5 +(byte) bob_charset_next_id#23 bob_charset_next_id zp[1]:13 1400.3333333333335 +(byte) bob_charset_next_id#30 bob_charset_next_id zp[1]:13 37.33333333333333 +(byte) bob_charset_next_id#8 bob_charset_next_id zp[1]:13 4.0 +(byte()) charsetFindOrAddGlyph((byte*) charsetFindOrAddGlyph::glyph , (byte*) charsetFindOrAddGlyph::charset) +(label) charsetFindOrAddGlyph::@1 +(label) charsetFindOrAddGlyph::@2 +(label) charsetFindOrAddGlyph::@3 +(label) charsetFindOrAddGlyph::@4 +(label) charsetFindOrAddGlyph::@5 +(label) charsetFindOrAddGlyph::@6 +(label) charsetFindOrAddGlyph::@7 +(label) charsetFindOrAddGlyph::@8 +(label) charsetFindOrAddGlyph::@9 +(label) charsetFindOrAddGlyph::@return +(byte*) charsetFindOrAddGlyph::charset +(byte) charsetFindOrAddGlyph::found +(byte) charsetFindOrAddGlyph::found#2 reg byte a 10001.0 +(byte*) charsetFindOrAddGlyph::glyph +(byte*) charsetFindOrAddGlyph::glyph#1 glyph zp[2]:6 2002.0 +(byte*) charsetFindOrAddGlyph::glyph#10 glyph zp[2]:6 7400.200000000001 +(byte*) charsetFindOrAddGlyph::glyph_cursor +(byte*) charsetFindOrAddGlyph::glyph_cursor#1 glyph_cursor zp[2]:17 20002.0 +(byte*) charsetFindOrAddGlyph::glyph_cursor#11 glyph_cursor zp[2]:17 10000.307692307691 +(byte) charsetFindOrAddGlyph::glyph_id +(byte) charsetFindOrAddGlyph::glyph_id#1 reg byte x 10001.0 +(byte) charsetFindOrAddGlyph::glyph_id#11 reg byte x 1937.75 +(byte) charsetFindOrAddGlyph::i +(byte) charsetFindOrAddGlyph::i#1 reg byte y 200002.0 +(byte) charsetFindOrAddGlyph::i#2 reg byte y 166668.3333333333 +(byte) charsetFindOrAddGlyph::i1 +(byte) charsetFindOrAddGlyph::i1#1 reg byte y 20002.0 +(byte) charsetFindOrAddGlyph::i1#2 reg byte y 16668.333333333332 +(byte) charsetFindOrAddGlyph::return +(byte) charsetFindOrAddGlyph::return#1 reg byte a 2002.0 +(byte()) keyboard_key_pressed((byte) keyboard_key_pressed::key) +(byte~) keyboard_key_pressed::$2 reg byte a 4.0 +(label) keyboard_key_pressed::@1 +(label) keyboard_key_pressed::@return +(byte) keyboard_key_pressed::colidx +(const byte) keyboard_key_pressed::colidx#0 colidx = (const byte) KEY_SPACE&(byte) 7 +(byte) keyboard_key_pressed::key +(byte) keyboard_key_pressed::return +(byte) keyboard_key_pressed::return#0 reg byte a 6.0 +(byte) keyboard_key_pressed::return#2 reg byte a 22.0 +(byte) keyboard_key_pressed::return#3 reg byte a 22.0 +(byte) keyboard_key_pressed::rowidx +(const byte) keyboard_key_pressed::rowidx#0 rowidx = (const byte) KEY_SPACE>>(byte) 3 +(const byte*) keyboard_matrix_col_bitmask = { (byte) 1, (byte) 2, (byte) 4, (byte) 8, (byte) $10, (byte) $20, (byte) $40, (byte) $80 } +(byte()) keyboard_matrix_read((byte) keyboard_matrix_read::rowid) +(label) keyboard_matrix_read::@return +(byte) keyboard_matrix_read::return +(byte) keyboard_matrix_read::return#0 reg byte a 1.3333333333333333 +(byte) keyboard_matrix_read::return#2 reg byte a 4.0 +(byte) keyboard_matrix_read::row_pressed_bits +(byte) keyboard_matrix_read::rowid +(const byte*) keyboard_matrix_row_bitmask = { (byte) $fe, (byte) $fd, (byte) $fb, (byte) $f7, (byte) $ef, (byte) $df, (byte) $bf, (byte) $7f } +(void()) main() +(signed word~) main::$10 zp[2]:11 202.0 +(signed word~) main::$12 zp[2]:11 202.0 +(signed word~) main::$13 zp[2]:11 202.0 +(byte~) main::$19 reg byte a 22.0 +(byte~) main::$21 reg byte a 22.0 +(label) main::@1 +(label) main::@10 +(label) main::@11 +(label) main::@12 +(label) main::@13 +(label) main::@14 +(label) main::@15 +(label) main::@16 +(label) main::@2 +(label) main::@3 +(label) main::@4 +(label) main::@5 +(label) main::@6 +(label) main::@7 +(label) main::@8 +(label) main::@9 +(label) main::@return +(byte) main::a +(byte) main::a#1 a zp[1]:4 28.857142857142858 +(byte) main::a#2 a zp[1]:4 25.9375 +(byte) main::a#6 a zp[1]:4 22.0 +(byte) main::angle +(byte) main::angle#1 angle zp[1]:2 3.6666666666666665 +(byte) main::angle#8 angle zp[1]:2 1.1785714285714286 +(byte) main::i +(byte) main::i#1 i zp[1]:5 151.5 +(byte) main::i#2 i zp[1]:5 9.619047619047619 +(signed byte) main::r +(signed byte) main::r#1 r zp[1]:3 33.666666666666664 +(signed byte) main::r#2 r zp[1]:3 23.764705882352942 +(label) main::toD0181 +(byte*) main::toD0181_gfx +(byte) main::toD0181_return +(const byte) main::toD0181_return#0 toD0181_return = >(word)(const byte*) BOB_SCREEN&(word) $3fff*(byte) 4|>(word)(const byte*) BOB_CHARSET/(byte) 4&(byte) $f +(byte*) main::toD0181_screen +(label) main::toD0182 +(byte*) main::toD0182_gfx +(byte) main::toD0182_return +(const byte) main::toD0182_return#0 toD0182_return = >(word)(const byte*) SCREEN_BASIC&(word) $3fff*(byte) 4|>(word)(const byte*) CHARSET_BASIC/(byte) 4&(byte) $f +(byte*) main::toD0182_screen +(label) main::vicSelectGfxBank1 +(label) main::vicSelectGfxBank1_@1 +(byte*) main::vicSelectGfxBank1_gfx +(label) main::vicSelectGfxBank1_toDd001 +(byte*) main::vicSelectGfxBank1_toDd001_gfx +(byte) main::vicSelectGfxBank1_toDd001_return +(const byte) main::vicSelectGfxBank1_toDd001_return#0 vicSelectGfxBank1_toDd001_return = (byte) 3 +(label) main::vicSelectGfxBank2 +(label) main::vicSelectGfxBank2_@1 +(byte*) main::vicSelectGfxBank2_gfx +(label) main::vicSelectGfxBank2_toDd001 +(byte*) main::vicSelectGfxBank2_toDd001_gfx +(byte) main::vicSelectGfxBank2_toDd001_return +(const byte) main::vicSelectGfxBank2_toDd001_return#0 vicSelectGfxBank2_toDd001_return = (byte) 3 +(signed word) main::x +(signed word) main::x#0 x zp[2]:8 18.363636363636363 +(signed word) main::y +(signed word) main::y#0 y zp[2]:11 40.4 +(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num) +(label) memset::@1 +(label) memset::@2 +(label) memset::@return +(byte) memset::c +(const byte) memset::c#0 c = (byte) 0 +(byte*) memset::dst +(byte*) memset::dst#1 dst zp[2]:6 22.0 +(byte*) memset::dst#2 dst zp[2]:6 14.666666666666666 +(byte*) memset::end +(const byte*) memset::end#0 end = (byte*)(const void*) memset::str#0+(const word) memset::num#0 +(word) memset::num +(const word) memset::num#0 num = (word) $3e8 +(void*) memset::return +(void*) memset::str +(const void*) memset::str#0 str = (void*)(const byte*) BOB_SCREEN +(signed word()) mulf8s((signed byte) mulf8s::a , (signed byte) mulf8s::b) +(label) mulf8s::@1 +(label) mulf8s::@2 +(label) mulf8s::@return +(signed byte) mulf8s::a +(signed byte) mulf8s::a#0 reg byte a 101.0 +(signed byte) mulf8s::a#1 reg byte a 101.0 +(signed byte) mulf8s::b +(signed byte) mulf8s::b#0 reg byte x 202.0 +(signed byte) mulf8s::b#1 reg byte x 202.0 +(signed byte) mulf8s::b#2 reg byte x 68.0 +(label) mulf8s::mulf8s_prepare1 +(signed byte) mulf8s::mulf8s_prepare1_a +(signed byte) mulf8s::mulf8s_prepare1_a#0 reg byte a 202.0 +(signed word) mulf8s::return +(signed word) mulf8s::return#0 return zp[2]:11 51.0 +(signed word) mulf8s::return#2 return zp[2]:11 202.0 +(signed word) mulf8s::return#3 return zp[2]:11 202.0 +(signed word()) mulf8s_prepared((signed byte) mulf8s_prepared::b) +(byte~) mulf8s_prepared::$12 reg byte a 4.0 +(byte~) mulf8s_prepared::$15 reg byte a 4.0 +(byte~) mulf8s_prepared::$16 reg byte a 4.0 +(byte~) mulf8s_prepared::$8 reg byte a 4.0 +(label) mulf8s_prepared::@1 +(label) mulf8s_prepared::@2 +(label) mulf8s_prepared::@3 +(label) mulf8s_prepared::@4 +(label) mulf8s_prepared::@5 +(label) mulf8s_prepared::@return +(signed byte) mulf8s_prepared::b +(signed byte) mulf8s_prepared::b#0 b zp[1]:14 0.4 +(word) mulf8s_prepared::m +(word) mulf8s_prepared::m#0 m zp[2]:11 2.0 +(word) mulf8s_prepared::m#1 m zp[2]:11 4.0 +(word) mulf8s_prepared::m#2 m zp[2]:11 4.0 +(word) mulf8s_prepared::m#4 m zp[2]:11 1.3333333333333333 +(word) mulf8s_prepared::m#5 m zp[2]:11 2.5 +(const signed byte*) mulf8s_prepared::memA = (signed byte*) 253 +(signed word) mulf8s_prepared::return +(void()) mulf8u_prepare((byte) mulf8u_prepare::a) +(label) mulf8u_prepare::@return +(byte) mulf8u_prepare::a +(byte) mulf8u_prepare::a#0 reg byte a 4.0 +(const byte*) mulf8u_prepare::memA = (byte*) 253 +(word()) mulf8u_prepared((byte) mulf8u_prepared::b) +(label) mulf8u_prepared::@return +(byte) mulf8u_prepared::b +(byte) mulf8u_prepared::b#0 reg byte a 4.0 +(const byte*) mulf8u_prepared::memB = (byte*) 255 +(const byte*) mulf8u_prepared::resL = (byte*) 254 +(word) mulf8u_prepared::return +(word) mulf8u_prepared::return#0 return zp[2]:11 1.3333333333333333 +(word) mulf8u_prepared::return#2 return zp[2]:11 4.0 +(void()) mulf_init() +(byte~) mulf_init::$1 reg byte a 22.0 +(byte~) mulf_init::$4 reg byte a 22.0 +(byte~) mulf_init::$5 reg byte a 22.0 +(label) mulf_init::@1 +(label) mulf_init::@2 +(label) mulf_init::@3 +(label) mulf_init::@4 +(label) mulf_init::@5 +(label) mulf_init::@6 +(label) mulf_init::@7 +(label) mulf_init::@8 +(label) mulf_init::@9 +(label) mulf_init::@return +(byte) mulf_init::c +(byte) mulf_init::c#1 c zp[1]:13 2.5384615384615383 +(byte) mulf_init::c#2 c zp[1]:13 11.0 +(byte) mulf_init::dir +(byte) mulf_init::dir#2 dir zp[1]:14 4.125 +(byte) mulf_init::dir#4 dir zp[1]:14 11.0 +(word) mulf_init::sqr +(word) mulf_init::sqr#1 sqr zp[2]:11 11.0 +(word) mulf_init::sqr#2 sqr zp[2]:11 22.0 +(word) mulf_init::sqr#3 sqr zp[2]:11 9.166666666666666 +(word) mulf_init::sqr#4 sqr zp[2]:11 5.5 +(byte*) mulf_init::sqr1_hi +(byte*) mulf_init::sqr1_hi#1 sqr1_hi zp[2]:15 7.333333333333333 +(byte*) mulf_init::sqr1_hi#2 sqr1_hi zp[2]:15 2.75 +(byte*) mulf_init::sqr1_lo +(byte*) mulf_init::sqr1_lo#1 sqr1_lo zp[2]:6 22.0 +(byte*) mulf_init::sqr1_lo#2 sqr1_lo zp[2]:6 3.142857142857143 +(byte*) mulf_init::sqr2_hi +(byte*) mulf_init::sqr2_hi#1 sqr2_hi zp[2]:8 3.6666666666666665 +(byte*) mulf_init::sqr2_hi#2 sqr2_hi zp[2]:8 8.25 +(byte*) mulf_init::sqr2_lo +(byte*) mulf_init::sqr2_lo#1 sqr2_lo zp[2]:17 22.0 +(byte*) mulf_init::sqr2_lo#2 sqr2_lo zp[2]:17 4.888888888888889 +(byte) mulf_init::x_2 +(byte) mulf_init::x_2#1 reg byte x 11.0 +(byte) mulf_init::x_2#2 reg byte x 5.5 +(byte) mulf_init::x_2#3 reg byte x 6.6000000000000005 +(byte) mulf_init::x_255 +(byte) mulf_init::x_255#1 reg byte x 6.6000000000000005 +(byte) mulf_init::x_255#2 reg byte x 8.8 +(const byte*) mulf_sqr1_hi = { fill( $200, 0) } +(const byte*) mulf_sqr1_lo = { fill( $200, 0) } +(const byte*) mulf_sqr2_hi = { fill( $200, 0) } +(const byte*) mulf_sqr2_lo = { fill( $200, 0) } +(void()) prepareBobs() +(byte~) prepareBobs::$6 reg byte a 2002.0 +(label) prepareBobs::@1 +(label) prepareBobs::@10 +(label) prepareBobs::@11 +(label) prepareBobs::@12 +(label) prepareBobs::@13 +(label) prepareBobs::@2 +(label) prepareBobs::@3 +(label) prepareBobs::@4 +(label) prepareBobs::@5 +(label) prepareBobs::@6 +(label) prepareBobs::@7 +(label) prepareBobs::@8 +(label) prepareBobs::@9 +(label) prepareBobs::@return +(byte*) prepareBobs::bob_glyph +(byte*) prepareBobs::bob_glyph#1 bob_glyph zp[2]:6 500.5 +(byte*) prepareBobs::bob_glyph#2 bob_glyph zp[2]:6 429.0 +(byte*) prepareBobs::bob_table +(byte*) prepareBobs::bob_table#0 bob_table zp[2]:15 202.0 +(byte*) prepareBobs::bob_table#1 bob_table zp[2]:15 667.3333333333334 +(byte*) prepareBobs::bob_table#2 bob_table zp[2]:15 388.0 +(byte) prepareBobs::bob_table_idx +(byte) prepareBobs::bob_table_idx#1 bob_table_idx zp[1]:4 40.4 +(byte) prepareBobs::bob_table_idx#12 bob_table_idx zp[1]:4 19.11764705882353 +(byte) prepareBobs::bob_table_idx#6 bob_table_idx zp[1]:4 11.0 +(byte) prepareBobs::cell +(byte) prepareBobs::cell#1 cell zp[1]:10 2002.0 +(byte) prepareBobs::cell#2 cell zp[1]:10 300.29999999999995 +(byte) prepareBobs::shift_x +(byte) prepareBobs::shift_x#1 shift_x zp[1]:5 202.0 +(byte) prepareBobs::shift_x#2 shift_x zp[1]:5 16.833333333333332 +(byte) prepareBobs::shift_y +(byte) prepareBobs::shift_y#1 shift_y zp[1]:2 22.0 +(byte) prepareBobs::shift_y#2 shift_y zp[1]:2 1.4347826086956523 +(byte*) progress_cursor +(byte*) progress_cursor#15 progress_cursor zp[2]:11 11.0 +(byte*) progress_cursor#17 progress_cursor zp[2]:11 201.4 +(byte*) progress_cursor#24 progress_cursor zp[2]:11 71.11764705882355 +(byte*) progress_cursor#31 progress_cursor zp[2]:11 37.33333333333333 +(byte*) progress_cursor#8 progress_cursor zp[2]:11 4.0 +(byte) progress_idx +(byte) progress_idx#10 progress_idx zp[1]:3 201.0 +(byte) progress_idx#16 progress_idx zp[1]:3 11.0 +(byte) progress_idx#25 progress_idx zp[1]:3 86.07142857142856 +(byte) progress_idx#31 progress_idx zp[1]:3 37.33333333333333 +(byte) progress_idx#8 progress_idx zp[1]:3 3.0 +(void()) progress_inc() +(label) progress_inc::@1 +(label) progress_inc::@2 +(label) progress_inc::@return +(const byte*) progress_inc::progress_chars = { (byte) $20, (byte) $65, (byte) $74, (byte) $75, (byte) $61, (byte) $f6, (byte) $e7, (byte) $ea, (byte) $e0 } +(void()) progress_init((byte*) progress_init::line) +(label) progress_init::@return +(byte*) progress_init::line +(void()) protoBobShiftDown() +(label) protoBobShiftDown::@1 +(label) protoBobShiftDown::@2 +(label) protoBobShiftDown::@3 +(label) protoBobShiftDown::@return +(byte) protoBobShiftDown::i +(byte) protoBobShiftDown::i#1 reg byte x 202.0 +(byte) protoBobShiftDown::i#2 reg byte x 161.6 +(void()) protoBobShiftRight() +(byte~) protoBobShiftRight::$1 reg byte a 2002.0 +(byte~) protoBobShiftRight::$5 reg byte a 2002.0 +(byte~) protoBobShiftRight::$6 reg byte a 2002.0 +(label) protoBobShiftRight::@1 +(label) protoBobShiftRight::@2 +(label) protoBobShiftRight::@3 +(label) protoBobShiftRight::@4 +(label) protoBobShiftRight::@5 +(label) protoBobShiftRight::@6 +(label) protoBobShiftRight::@7 +(label) protoBobShiftRight::@return +(byte) protoBobShiftRight::carry +(byte) protoBobShiftRight::carry#1 carry zp[1]:14 111.22222222222223 +(byte) protoBobShiftRight::carry#10 reg byte y 2002.0 +(byte) protoBobShiftRight::carry#2 reg byte y 286.0 +(byte) protoBobShiftRight::i +(byte) protoBobShiftRight::i#1 i zp[1]:10 1001.0 +(byte) protoBobShiftRight::i#2 i zp[1]:10 231.0 +(byte) protoBobShiftRight::j +(byte) protoBobShiftRight::j#1 reg byte x 2002.0 +(byte) protoBobShiftRight::j#10 reg byte x 1001.0 +(byte) protoBobShiftRight::j#2 reg byte x 2002.0 +(byte) protoBobShiftRight::j#3 reg byte x 700.7 +(byte) protoBobShiftRight::new_carry +(void()) renderBob((byte) renderBob::xpos , (byte) renderBob::ypos) +(byte*~) renderBob::$2 zp[2]:11 4.0 +(byte~) renderBob::$4 reg byte a 4.0 +(byte~) renderBob::$5 zp[1]:13 2.0 +(byte~) renderBob::$6 reg byte a 4.0 +(byte~) renderBob::$8 reg byte a 4.0 +(label) renderBob::@return +(byte) renderBob::bob_table_idx +(byte) renderBob::bob_table_idx#0 reg byte x 1.8181818181818186 +(byte*) renderBob::screen +(byte*) renderBob::screen#0 screen zp[2]:11 1.4666666666666666 +(byte) renderBob::x_char_offset +(byte) renderBob::x_char_offset#0 x_char_offset zp[1]:10 0.8 +(byte) renderBob::xpos +(byte) renderBob::xpos#0 xpos zp[1]:14 10.499999999999998 +(byte) renderBob::y_char_offset +(byte) renderBob::y_char_offset#0 reg byte a 4.0 +(word) renderBob::y_offset +(word) renderBob::y_offset#0 y_offset zp[2]:11 4.0 +(byte) renderBob::ypos +(byte) renderBob::ypos#0 reg byte x 15.000000000000002 +(void()) renderBobCleanup() +(byte~) renderBobCleanup::$1 reg byte a 202.0 +(label) renderBobCleanup::@1 +(label) renderBobCleanup::@return +(byte) renderBobCleanup::i +(byte) renderBobCleanup::i#1 reg byte x 151.5 +(byte) renderBobCleanup::i#2 reg byte x 25.25 +(byte*) renderBobCleanup::screen +(byte*) renderBobCleanup::screen#0 screen zp[2]:15 112.22222222222223 +(byte**) renderBobCleanupNext +(byte**) renderBobCleanupNext#13 renderBobCleanupNext zp[2]:6 7.357142857142858 +(byte**) renderBobCleanupNext#17 renderBobCleanupNext zp[2]:6 3.3870967741935485 +(void()) renderBobInit() +(word~) renderBobInit::$0 zp[2]:15 16.5 +(word~) renderBobInit::$1 zp[2]:15 11.0 +(byte~) renderBobInit::$4 reg byte a 22.0 +(byte~) renderBobInit::$5 reg byte a 22.0 +(word~) renderBobInit::$6 zp[2]:17 22.0 +(word~) renderBobInit::$7 zp[2]:15 22.0 +(label) renderBobInit::@1 +(label) renderBobInit::@2 +(label) renderBobInit::@return +(byte) renderBobInit::i +(byte) renderBobInit::i#1 reg byte x 16.5 +(byte) renderBobInit::i#2 reg byte x 11.0 +(byte) renderBobInit::y +(byte) renderBobInit::y#1 reg byte x 16.5 +(byte) renderBobInit::y#2 reg byte x 4.714285714285714 + +reg byte a [ mulf8s::mulf8s_prepare1_a#0 mulf8s::a#1 mulf8s::a#0 ] +reg byte x [ mulf8s::b#2 mulf8s::b#1 mulf8s::b#0 ] +reg byte x [ renderBobCleanup::i#2 renderBobCleanup::i#1 ] +reg byte x [ renderBobInit::y#2 renderBobInit::y#1 ] +reg byte x [ renderBobInit::i#2 renderBobInit::i#1 ] +zp[1]:2 [ prepareBobs::shift_y#2 prepareBobs::shift_y#1 main::angle#8 main::angle#1 ] +zp[1]:3 [ progress_idx#16 progress_idx#31 progress_idx#25 progress_idx#10 progress_idx#8 main::r#2 main::r#1 ] +zp[1]:4 [ prepareBobs::bob_table_idx#6 prepareBobs::bob_table_idx#12 prepareBobs::bob_table_idx#1 main::a#2 main::a#6 main::a#1 ] +zp[1]:5 [ prepareBobs::shift_x#2 prepareBobs::shift_x#1 main::i#2 main::i#1 ] +reg byte x [ charsetFindOrAddGlyph::glyph_id#11 charsetFindOrAddGlyph::glyph_id#1 ] +reg byte y [ charsetFindOrAddGlyph::i1#2 charsetFindOrAddGlyph::i1#1 ] +reg byte y [ charsetFindOrAddGlyph::i#2 charsetFindOrAddGlyph::i#1 ] +reg byte a [ charsetFindOrAddGlyph::found#2 ] +reg byte x [ protoBobShiftRight::j#3 protoBobShiftRight::j#10 protoBobShiftRight::j#2 protoBobShiftRight::j#1 ] +reg byte y [ protoBobShiftRight::carry#2 protoBobShiftRight::carry#10 ] +reg byte x [ protoBobShiftDown::i#2 protoBobShiftDown::i#1 ] +zp[2]:6 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_lo#1 prepareBobs::bob_glyph#2 prepareBobs::bob_glyph#1 charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph#1 memset::dst#2 memset::dst#1 renderBobCleanupNext#17 renderBobCleanupNext#13 ] +reg byte x [ mulf_init::x_2#3 mulf_init::x_2#2 mulf_init::x_2#1 ] +reg byte x [ mulf_init::x_255#2 mulf_init::x_255#1 ] +zp[2]:8 [ main::x#0 mulf_init::sqr2_hi#2 mulf_init::sqr2_hi#1 ] +reg byte x [ renderBob::ypos#0 ] +reg byte a [ keyboard_key_pressed::return#2 ] +reg byte a [ main::$19 ] +reg byte a [ keyboard_key_pressed::return#3 ] +reg byte a [ main::$21 ] +reg byte a [ keyboard_matrix_read::return#2 ] +reg byte a [ keyboard_key_pressed::$2 ] +reg byte a [ keyboard_key_pressed::return#0 ] +reg byte a [ keyboard_matrix_read::return#0 ] +zp[1]:10 [ renderBob::x_char_offset#0 protoBobShiftRight::i#2 protoBobShiftRight::i#1 prepareBobs::cell#2 prepareBobs::cell#1 ] +reg byte a [ renderBob::y_char_offset#0 ] +reg byte a [ renderBob::$8 ] +zp[2]:11 [ renderBob::y_offset#0 renderBob::$2 renderBob::screen#0 mulf_init::sqr#3 mulf_init::sqr#4 mulf_init::sqr#1 mulf_init::sqr#2 progress_cursor#15 progress_cursor#31 progress_cursor#24 progress_cursor#17 progress_cursor#8 mulf8s_prepared::m#4 mulf8s_prepared::m#5 mulf8s_prepared::m#1 mulf8s_prepared::m#0 mulf8s_prepared::m#2 mulf8s::return#0 mulf8u_prepared::return#2 mulf8s::return#2 main::$10 mulf8s::return#3 main::$12 mulf8u_prepared::return#0 main::$13 main::y#0 ] +reg byte a [ renderBob::$4 ] +zp[1]:13 [ renderBob::$5 mulf_init::c#2 mulf_init::c#1 bob_charset_next_id#23 bob_charset_next_id#14 bob_charset_next_id#16 bob_charset_next_id#30 bob_charset_next_id#21 bob_charset_next_id#8 ] +reg byte a [ renderBob::$6 ] +reg byte x [ renderBob::bob_table_idx#0 ] +reg byte a [ mulf8u_prepare::a#0 ] +zp[1]:14 [ mulf8s_prepared::b#0 renderBob::xpos#0 mulf_init::dir#2 mulf_init::dir#4 protoBobShiftRight::carry#1 ] +reg byte a [ mulf8u_prepared::b#0 ] +reg byte a [ mulf8s_prepared::$8 ] +reg byte a [ mulf8s_prepared::$15 ] +reg byte a [ mulf8s_prepared::$12 ] +reg byte a [ mulf8s_prepared::$16 ] +reg byte a [ renderBobCleanup::$1 ] +zp[2]:15 [ renderBobInit::$0 renderBobInit::$7 renderBobInit::$1 renderBobCleanup::screen#0 mulf_init::sqr1_hi#2 mulf_init::sqr1_hi#1 prepareBobs::bob_table#2 prepareBobs::bob_table#1 prepareBobs::bob_table#0 ] +zp[2]:17 [ renderBobInit::$6 mulf_init::sqr2_lo#2 mulf_init::sqr2_lo#1 charsetFindOrAddGlyph::glyph_cursor#11 charsetFindOrAddGlyph::glyph_cursor#1 ] +reg byte a [ renderBobInit::$4 ] +reg byte a [ renderBobInit::$5 ] +reg byte a [ charsetFindOrAddGlyph::return#1 ] +reg byte a [ prepareBobs::$6 ] +reg byte a [ protoBobShiftRight::$1 ] +reg byte a [ protoBobShiftRight::$5 ] +reg byte a [ protoBobShiftRight::$6 ] +reg byte a [ mulf_init::$1 ] +reg byte a [ mulf_init::$4 ] +reg byte a [ mulf_init::$5 ] + + +FINAL ASSEMBLER +Score: 3510699 + + // File Comments +// Pre-calculated bobs inside a charset (pre-moved to all x/y-combinations) + // Upstart +.pc = $801 "Basic" +:BasicUpstart(main) +.pc = $80d "Program" + // Global Constants & labels + .label RASTER = $d012 + .label BORDERCOL = $d020 + .label D018 = $d018 + // CIA#1 Port A: keyboard matrix columns and joystick #2 + .label CIA1_PORT_A = $dc00 + // CIA#1 Port B: keyboard matrix rows and joystick #1. + .label CIA1_PORT_B = $dc01 + // CIA#2 Port A: Serial bus, RS-232, VIC memory bank + .label CIA2_PORT_A = $dd00 + // CIA #2 Port A data direction register. + .label CIA2_PORT_A_DDR = $dd02 + .const KEY_SPACE = $3c + // The BASIC screen + .label SCREEN_BASIC = $400 + // The BASIC charset + .label CHARSET_BASIC = $1000 + // The BOB screen + .label BOB_SCREEN = $2800 + // The BOB charset + .label BOB_CHARSET = $2000 + // The number of different X-shifts + .const BOB_SHIFTS_X = 4 + // The number of different Y-shifts + .const BOB_SHIFTS_Y = 8 + // The size of a sub-table of BOB_TABLES + .const BOB_SUBTABLE_SIZE = BOB_SHIFTS_X*BOB_SHIFTS_Y + // The number of BOBs to render + .const NUM_BOBS = $14 + .const SIZEOF_POINTER = 2 + .label COS = SIN+$40 + // BOB charset ID of the next glyph to be added + .label bob_charset_next_id = $d + // Current index within the progress cursor (0-7) + .label progress_idx = 3 + // Current position of the progress cursor + .label progress_cursor = $b + // Pointer to the next clean-up to add + // Prepare for next clean-up + .label renderBobCleanupNext = 6 + // @begin + // [1] phi from @begin to @1 [phi:@begin->@1] + // @1 + // [2] call main + // [4] phi from @1 to main [phi:@1->main] + // [3] phi from @1 to @end [phi:@1->@end] + // @end + // main +main: { + .const vicSelectGfxBank1_toDd001_return = 3 + .const vicSelectGfxBank2_toDd001_return = 3 + .const toD0181_return = (>(BOB_SCREEN&$3fff)*4)|(>BOB_CHARSET)/4&$f + .const toD0182_return = (>(SCREEN_BASIC&$3fff)*4)|(>CHARSET_BASIC)/4&$f + .label __10 = $b + .label __12 = $b + .label __13 = $b + .label x = 8 + .label y = $b + .label a = 4 + .label r = 3 + .label i = 5 + // Render Rotated BOBs + .label angle = 2 + // mulf_init() + // [5] call mulf_init + // [243] phi from main to mulf_init [phi:main->mulf_init] + jsr mulf_init + // [6] phi from main to main::@9 [phi:main->main::@9] + // main::@9 + // prepareBobs() + // [7] call prepareBobs + // [159] phi from main::@9 to prepareBobs [phi:main::@9->prepareBobs] + jsr prepareBobs + // [8] phi from main::@9 to main::@10 [phi:main::@9->main::@10] + // main::@10 + // renderBobInit() + // [9] call renderBobInit + // [143] phi from main::@10 to renderBobInit [phi:main::@10->renderBobInit] + jsr renderBobInit + // main::vicSelectGfxBank1 + // *CIA2_PORT_A_DDR = %00000011 + // [10] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 -- _deref_pbuc1=vbuc2 + lda #3 + sta CIA2_PORT_A_DDR + // [11] phi from main::vicSelectGfxBank1 to main::vicSelectGfxBank1_toDd001 [phi:main::vicSelectGfxBank1->main::vicSelectGfxBank1_toDd001] + // main::vicSelectGfxBank1_toDd001 + // main::vicSelectGfxBank1_@1 + // *CIA2_PORT_A = toDd00(gfx) + // [12] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank1_toDd001_return#0 -- _deref_pbuc1=vbuc2 + lda #vicSelectGfxBank1_toDd001_return + sta CIA2_PORT_A + // [13] phi from main::vicSelectGfxBank1_@1 to main::toD0181 [phi:main::vicSelectGfxBank1_@1->main::toD0181] + // main::toD0181 + // main::@7 + // *D018 = toD018(BOB_SCREEN, BOB_CHARSET) + // [14] *((const byte*) D018) ← (const byte) main::toD0181_return#0 -- _deref_pbuc1=vbuc2 + lda #toD0181_return + sta D018 + // memset(BOB_SCREEN, 0x00, 1000) + // [15] call memset + // [137] phi from main::@7 to memset [phi:main::@7->memset] + jsr memset + // [16] phi from main::@7 to main::@1 [phi:main::@7->main::@1] + // [16] phi (byte) main::angle#8 = (byte) 0 [phi:main::@7->main::@1#0] -- vbuz1=vbuc1 + lda #0 + sta.z angle + // main::@1 + // main::@2 + __b2: + // while (*RASTER<$f8) + // [17] if(*((const byte*) RASTER)<(byte) $f8) goto main::@2 -- _deref_pbuc1_lt_vbuc2_then_la1 + lda RASTER + cmp #$f8 + bcc __b2 + // main::@3 + // *BORDERCOL = 0xf + // [18] *((const byte*) BORDERCOL) ← (byte) $f -- _deref_pbuc1=vbuc2 + lda #$f + sta BORDERCOL + // renderBobCleanup() + // [19] call renderBobCleanup + // [121] phi from main::@3 to renderBobCleanup [phi:main::@3->renderBobCleanup] + jsr renderBobCleanup + // main::@11 + // [20] (byte) main::a#6 ← (byte) main::angle#8 -- vbuz1=vbuz2 + lda.z angle + sta.z a + // [21] phi from main::@11 to main::@4 [phi:main::@11->main::@4] + // [21] phi (byte) main::i#2 = (byte) 0 [phi:main::@11->main::@4#0] -- vbuz1=vbuc1 + lda #0 + sta.z i + // [21] phi (byte**) renderBobCleanupNext#17 = (const byte**) RENDERBOB_CLEANUP [phi:main::@11->main::@4#1] -- pptz1=pptc1 + lda #RENDERBOB_CLEANUP + sta.z renderBobCleanupNext+1 + // [21] phi (byte) main::a#2 = (byte) main::a#6 [phi:main::@11->main::@4#2] -- register_copy + // [21] phi (signed byte) main::r#2 = (signed byte) $1e [phi:main::@11->main::@4#3] -- vbsz1=vbsc1 + lda #$1e + sta.z r + // [21] phi from main::@14 to main::@4 [phi:main::@14->main::@4] + // [21] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@14->main::@4#0] -- register_copy + // [21] phi (byte**) renderBobCleanupNext#17 = (byte**) renderBobCleanupNext#13 [phi:main::@14->main::@4#1] -- register_copy + // [21] phi (byte) main::a#2 = (byte) main::a#1 [phi:main::@14->main::@4#2] -- register_copy + // [21] phi (signed byte) main::r#2 = (signed byte) main::r#1 [phi:main::@14->main::@4#3] -- register_copy + // main::@4 + __b4: + // *BORDERCOL = 1 + // [22] *((const byte*) BORDERCOL) ← (byte) 1 -- _deref_pbuc1=vbuc2 + //kickasm {{ .break }} + lda #1 + sta BORDERCOL + // mulf8s(r, COS[a]) + // [23] (signed byte) mulf8s::a#0 ← (signed byte) main::r#2 -- vbsaa=vbsz1 + lda.z r + // [24] (signed byte) mulf8s::b#0 ← *((const signed byte*) COS + (byte) main::a#2) -- vbsxx=pbsc1_derefidx_vbuz1 + ldy.z a + ldx COS,y + // [25] call mulf8s + // [92] phi from main::@4 to mulf8s [phi:main::@4->mulf8s] + // [92] phi (signed byte) mulf8s::b#2 = (signed byte) mulf8s::b#0 [phi:main::@4->mulf8s#0] -- register_copy + // [92] phi (signed byte) mulf8s::mulf8s_prepare1_a#0 = (signed byte) mulf8s::a#0 [phi:main::@4->mulf8s#1] -- register_copy + jsr mulf8s + // mulf8s(r, COS[a]) + // [26] (signed word) mulf8s::return#2 ← (signed word) mulf8s::return#0 + // main::@12 + // [27] (signed word~) main::$10 ← (signed word) mulf8s::return#2 + // x = mulf8s(r, COS[a]) + 75*0x100 + // [28] (signed word) main::x#0 ← (signed word~) main::$10 + (signed word)(number) $4b*(number) $100 -- vwsz1=vwsz2_plus_vwsc1 + lda.z __10 + clc + adc #<$4b*$100 + sta.z x + lda.z __10+1 + adc #>$4b*$100 + sta.z x+1 + // mulf8s(r, SIN[a]) + // [29] (signed byte) mulf8s::a#1 ← (signed byte) main::r#2 -- vbsaa=vbsz1 + lda.z r + // [30] (signed byte) mulf8s::b#1 ← *((const signed byte*) SIN + (byte) main::a#2) -- vbsxx=pbsc1_derefidx_vbuz1 + ldy.z a + ldx SIN,y + // [31] call mulf8s + // [92] phi from main::@12 to mulf8s [phi:main::@12->mulf8s] + // [92] phi (signed byte) mulf8s::b#2 = (signed byte) mulf8s::b#1 [phi:main::@12->mulf8s#0] -- register_copy + // [92] phi (signed byte) mulf8s::mulf8s_prepare1_a#0 = (signed byte) mulf8s::a#1 [phi:main::@12->mulf8s#1] -- register_copy + jsr mulf8s + // mulf8s(r, SIN[a]) + // [32] (signed word) mulf8s::return#3 ← (signed word) mulf8s::return#0 + // main::@13 + // [33] (signed word~) main::$12 ← (signed word) mulf8s::return#3 + // mulf8s(r, SIN[a])*2 + // [34] (signed word~) main::$13 ← (signed word~) main::$12 << (byte) 1 -- vwsz1=vwsz1_rol_1 + asl.z __13 + rol.z __13+1 + // y = mulf8s(r, SIN[a])*2 + 90*0x100 + // [35] (signed word) main::y#0 ← (signed word~) main::$13 + (signed word)(number) $5a*(number) $100 -- vwsz1=vwsz1_plus_vwsc1 + clc + lda.z y + adc #<$5a*$100 + sta.z y + lda.z y+1 + adc #>$5a*$100 + sta.z y+1 + // *BORDERCOL = 2 + // [36] *((const byte*) BORDERCOL) ← (byte) 2 -- _deref_pbuc1=vbuc2 + lda #2 + sta BORDERCOL + // a += 98 + // [37] (byte) main::a#1 ← (byte) main::a#2 + (byte) $62 -- vbuz1=vbuz1_plus_vbuc1 + lax.z a + axs #-[$62] + stx.z a + // r += 3 + // [38] (signed byte) main::r#1 ← (signed byte) main::r#2 + (signed byte) 3 -- vbsz1=vbsz1_plus_vbsc1 + lax.z r + axs #-[3] + stx.z r + // renderBob(>x, >y) + // [39] (byte) renderBob::xpos#0 ← > (signed word) main::x#0 -- vbuz1=_hi_vwsz2 + lda.z x+1 + sta.z renderBob.xpos + // [40] (byte) renderBob::ypos#0 ← > (signed word) main::y#0 -- vbuxx=_hi_vwsz1 + lda.z y+1 + tax + // [41] call renderBob + jsr renderBob + // main::@14 + // for(char i: 0..NUM_BOBS-1) + // [42] (byte) main::i#1 ← ++ (byte) main::i#2 -- vbuz1=_inc_vbuz1 + inc.z i + // [43] if((byte) main::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto main::@4 -- vbuz1_neq_vbuc1_then_la1 + lda #NUM_BOBS-1+1 + cmp.z i + bne __b4 + // main::@5 + // angle += 3 + // [44] (byte) main::angle#1 ← (byte) main::angle#8 + (byte) 3 -- vbuz1=vbuz1_plus_vbuc1 + lax.z angle + axs #-[3] + stx.z angle + // *BORDERCOL = 0 + // [45] *((const byte*) BORDERCOL) ← (byte) 0 -- _deref_pbuc1=vbuc2 + lda #0 + sta BORDERCOL + // keyboard_key_pressed(KEY_SPACE) + // [46] call keyboard_key_pressed + // [61] phi from main::@5 to keyboard_key_pressed [phi:main::@5->keyboard_key_pressed] + jsr keyboard_key_pressed + // keyboard_key_pressed(KEY_SPACE) + // [47] (byte) keyboard_key_pressed::return#2 ← (byte) keyboard_key_pressed::return#0 + // main::@15 + // [48] (byte~) main::$19 ← (byte) keyboard_key_pressed::return#2 + // if(keyboard_key_pressed(KEY_SPACE)) + // [49] if((byte) 0!=(byte~) main::$19) goto main::@6 -- vbuc1_neq_vbuaa_then_la1 + cmp #0 + bne __b6 + // [16] phi from main::@15 to main::@1 [phi:main::@15->main::@1] + // [16] phi (byte) main::angle#8 = (byte) main::angle#1 [phi:main::@15->main::@1#0] -- register_copy + jmp __b2 + // Wait for space release + // [50] phi from main::@15 main::@16 to main::@6 [phi:main::@15/main::@16->main::@6] + // main::@6 + __b6: + // keyboard_key_pressed(KEY_SPACE) + // [51] call keyboard_key_pressed + // [61] phi from main::@6 to keyboard_key_pressed [phi:main::@6->keyboard_key_pressed] + jsr keyboard_key_pressed + // keyboard_key_pressed(KEY_SPACE) + // [52] (byte) keyboard_key_pressed::return#3 ← (byte) keyboard_key_pressed::return#0 + // main::@16 + // [53] (byte~) main::$21 ← (byte) keyboard_key_pressed::return#3 + // while(keyboard_key_pressed(KEY_SPACE)) + // [54] if((byte) 0!=(byte~) main::$21) goto main::@6 -- vbuc1_neq_vbuaa_then_la1 + cmp #0 + bne __b6 + // main::vicSelectGfxBank2 + // *CIA2_PORT_A_DDR = %00000011 + // [55] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 -- _deref_pbuc1=vbuc2 + lda #3 + sta CIA2_PORT_A_DDR + // [56] phi from main::vicSelectGfxBank2 to main::vicSelectGfxBank2_toDd001 [phi:main::vicSelectGfxBank2->main::vicSelectGfxBank2_toDd001] + // main::vicSelectGfxBank2_toDd001 + // main::vicSelectGfxBank2_@1 + // *CIA2_PORT_A = toDd00(gfx) + // [57] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank2_toDd001_return#0 -- _deref_pbuc1=vbuc2 + lda #vicSelectGfxBank2_toDd001_return + sta CIA2_PORT_A + // [58] phi from main::vicSelectGfxBank2_@1 to main::toD0182 [phi:main::vicSelectGfxBank2_@1->main::toD0182] + // main::toD0182 + // main::@8 + // *D018 = toD018(SCREEN_BASIC, CHARSET_BASIC) + // [59] *((const byte*) D018) ← (const byte) main::toD0182_return#0 -- _deref_pbuc1=vbuc2 + lda #toD0182_return + sta D018 + // main::@return + // } + // [60] return + rts +} + // keyboard_key_pressed +// Determines whether a specific key is currently pressed by accessing the matrix directly +// The key is a keyboard code defined from the keyboard matrix by %00rrrccc, where rrr is the row ID (0-7) and ccc is the column ID (0-7) +// All keys exist as as KEY_XXX constants. +// Returns zero if the key is not pressed and a non-zero value if the key is currently pressed +keyboard_key_pressed: { + .const colidx = KEY_SPACE&7 + .label rowidx = KEY_SPACE>>3 + // keyboard_matrix_read(rowidx) + // [62] call keyboard_matrix_read + jsr keyboard_matrix_read + // [63] (byte) keyboard_matrix_read::return#2 ← (byte) keyboard_matrix_read::return#0 + // keyboard_key_pressed::@1 + // [64] (byte~) keyboard_key_pressed::$2 ← (byte) keyboard_matrix_read::return#2 + // keyboard_matrix_read(rowidx) & keyboard_matrix_col_bitmask[colidx] + // [65] (byte) keyboard_key_pressed::return#0 ← (byte~) keyboard_key_pressed::$2 & *((const byte*) keyboard_matrix_col_bitmask+(const byte) keyboard_key_pressed::colidx#0) -- vbuaa=vbuaa_band__deref_pbuc1 + and keyboard_matrix_col_bitmask+colidx + // keyboard_key_pressed::@return + // } + // [66] return + rts +} + // keyboard_matrix_read +// Read a single row of the keyboard matrix +// The row ID (0-7) of the keyboard matrix row to read. See the C64 key matrix for row IDs. +// Returns the keys pressed on the row as bits according to the C64 key matrix. +// Notice: If the C64 normal interrupt is still running it will occasionally interrupt right between the read & write +// leading to erroneous readings. You must disable kill the normal interrupt or sei/cli around calls to the keyboard matrix reader. +keyboard_matrix_read: { + // *CIA1_PORT_A = keyboard_matrix_row_bitmask[rowid] + // [67] *((const byte*) CIA1_PORT_A) ← *((const byte*) keyboard_matrix_row_bitmask+(const byte) keyboard_key_pressed::rowidx#0) -- _deref_pbuc1=_deref_pbuc2 + lda keyboard_matrix_row_bitmask+keyboard_key_pressed.rowidx + sta CIA1_PORT_A + // ~*CIA1_PORT_B + // [68] (byte) keyboard_matrix_read::return#0 ← ~ *((const byte*) CIA1_PORT_B) -- vbuaa=_bnot__deref_pbuc1 + lda CIA1_PORT_B + eor #$ff + // keyboard_matrix_read::@return + // } + // [69] return + rts +} + // renderBob +// Render a single BOB at a given x/y-position +// X-position is 0-151. Each x-position is 2 pixels wide. +// Y-position is 0-183. Each y-position is 1 pixel high. +// renderBob(byte zeropage($e) xpos, byte register(X) ypos) +renderBob: { + .label __2 = $b + .label __5 = $d + .label xpos = $e + .label x_char_offset = $a + .label y_offset = $b + .label screen = $b + // x_char_offset = xpos/BOB_SHIFTS_X + // [70] (byte) renderBob::x_char_offset#0 ← (byte) renderBob::xpos#0 >> (byte) 2 -- vbuz1=vbuz2_ror_2 + lda.z xpos + lsr + lsr + sta.z x_char_offset + // y_char_offset = ypos/BOB_SHIFTS_Y + // [71] (byte) renderBob::y_char_offset#0 ← (byte) renderBob::ypos#0 >> (byte) 3 -- vbuaa=vbuxx_ror_3 + txa + lsr + lsr + lsr + // y_offset = MUL40[y_char_offset] + // [72] (byte~) renderBob::$8 ← (byte) renderBob::y_char_offset#0 << (byte) 1 -- vbuaa=vbuaa_rol_1 + asl + // [73] (word) renderBob::y_offset#0 ← *((const word*) MUL40 + (byte~) renderBob::$8) -- vwuz1=pwuc1_derefidx_vbuaa + tay + lda MUL40,y + sta.z y_offset + lda MUL40+1,y + sta.z y_offset+1 + // BOB_SCREEN+y_offset + // [74] (byte*~) renderBob::$2 ← (const byte*) BOB_SCREEN + (word) renderBob::y_offset#0 -- pbuz1=pbuc1_plus_vwuz1 + clc + lda.z __2 + adc #BOB_SCREEN + sta.z __2+1 + // screen = BOB_SCREEN+y_offset+x_char_offset + // [75] (byte*) renderBob::screen#0 ← (byte*~) renderBob::$2 + (byte) renderBob::x_char_offset#0 -- pbuz1=pbuz1_plus_vbuz2 + lda.z x_char_offset + clc + adc.z screen + sta.z screen + bcc !+ + inc.z screen+1 + !: + // ypos&7 + // [76] (byte~) renderBob::$4 ← (byte) renderBob::ypos#0 & (byte) 7 -- vbuaa=vbuxx_band_vbuc1 + txa + and #7 + // (ypos&7)*BOB_SHIFTS_X + // [77] (byte~) renderBob::$5 ← (byte~) renderBob::$4 << (byte) 2 -- vbuz1=vbuaa_rol_2 + asl + asl + sta.z __5 + // xpos&3 + // [78] (byte~) renderBob::$6 ← (byte) renderBob::xpos#0 & (byte) 3 -- vbuaa=vbuz1_band_vbuc1 + lda #3 + and.z xpos + // bob_table_idx = (ypos&7)*BOB_SHIFTS_X+(xpos&3) + // [79] (byte) renderBob::bob_table_idx#0 ← (byte~) renderBob::$5 + (byte~) renderBob::$6 -- vbuxx=vbuz1_plus_vbuaa + clc + adc.z __5 + tax + // *renderBobCleanupNext++ = screen + // [80] *((byte**) renderBobCleanupNext#17) ← (byte*) renderBob::screen#0 -- _deref_pptz1=pbuz2 + ldy #0 + lda.z screen + sta (renderBobCleanupNext),y + iny + lda.z screen+1 + sta (renderBobCleanupNext),y + // *renderBobCleanupNext++ = screen; + // [81] (byte**) renderBobCleanupNext#13 ← (byte**) renderBobCleanupNext#17 + (const byte) SIZEOF_POINTER -- pptz1=pptz1_plus_vbuc1 + lda #SIZEOF_POINTER + clc + adc.z renderBobCleanupNext + sta.z renderBobCleanupNext + bcc !+ + inc.z renderBobCleanupNext+1 + !: + // screen[0] = (BOB_TABLES+0*BOB_SUBTABLE_SIZE)[bob_table_idx] + // [82] *((byte*) renderBob::screen#0) ← *((const byte*) BOB_TABLES + (byte) renderBob::bob_table_idx#0) -- _deref_pbuz1=pbuc1_derefidx_vbuxx + lda BOB_TABLES,x + ldy #0 + sta (screen),y + // screen[40] = (BOB_TABLES+1*BOB_SUBTABLE_SIZE)[bob_table_idx] + // [83] *((byte*) renderBob::screen#0 + (byte) $28) ← *((const byte*) BOB_TABLES+(byte) 1*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx + lda BOB_TABLES+1*BOB_SUBTABLE_SIZE,x + ldy #$28 + sta (screen),y + // screen[80] = (BOB_TABLES+2*BOB_SUBTABLE_SIZE)[bob_table_idx] + // [84] *((byte*) renderBob::screen#0 + (byte) $50) ← *((const byte*) BOB_TABLES+(byte) 2*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx + lda BOB_TABLES+2*BOB_SUBTABLE_SIZE,x + ldy #$50 + sta (screen),y + // screen[1] = (BOB_TABLES+3*BOB_SUBTABLE_SIZE)[bob_table_idx] + // [85] *((byte*) renderBob::screen#0 + (byte) 1) ← *((const byte*) BOB_TABLES+(byte) 3*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx + lda BOB_TABLES+3*BOB_SUBTABLE_SIZE,x + ldy #1 + sta (screen),y + // screen[41] = (BOB_TABLES+4*BOB_SUBTABLE_SIZE)[bob_table_idx] + // [86] *((byte*) renderBob::screen#0 + (byte) $29) ← *((const byte*) BOB_TABLES+(byte) 4*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx + lda BOB_TABLES+4*BOB_SUBTABLE_SIZE,x + ldy #$29 + sta (screen),y + // screen[81] = (BOB_TABLES+5*BOB_SUBTABLE_SIZE)[bob_table_idx] + // [87] *((byte*) renderBob::screen#0 + (byte) $51) ← *((const byte*) BOB_TABLES+(byte) 5*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx + lda BOB_TABLES+5*BOB_SUBTABLE_SIZE,x + ldy #$51 + sta (screen),y + // screen[2] = (BOB_TABLES+6*BOB_SUBTABLE_SIZE)[bob_table_idx] + // [88] *((byte*) renderBob::screen#0 + (byte) 2) ← *((const byte*) BOB_TABLES+(byte) 6*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx + lda BOB_TABLES+6*BOB_SUBTABLE_SIZE,x + ldy #2 + sta (screen),y + // screen[42] = (BOB_TABLES+7*BOB_SUBTABLE_SIZE)[bob_table_idx] + // [89] *((byte*) renderBob::screen#0 + (byte) $2a) ← *((const byte*) BOB_TABLES+(byte) 7*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx + lda BOB_TABLES+7*BOB_SUBTABLE_SIZE,x + ldy #$2a + sta (screen),y + // screen[82] = (BOB_TABLES+8*BOB_SUBTABLE_SIZE)[bob_table_idx] + // [90] *((byte*) renderBob::screen#0 + (byte) $52) ← *((const byte*) BOB_TABLES+(byte) 8*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx + lda BOB_TABLES+8*BOB_SUBTABLE_SIZE,x + ldy #$52 + sta (screen),y + // renderBob::@return + // } + // [91] return + rts +} + // mulf8s +// Fast multiply two signed bytes to a word result +// mulf8s(signed byte register(A) a, signed byte register(X) b) +mulf8s: { + .label return = $b + // mulf8s::mulf8s_prepare1 + // mulf8u_prepare((byte)a) + // [93] (byte) mulf8u_prepare::a#0 ← (byte)(signed byte) mulf8s::mulf8s_prepare1_a#0 + // [94] call mulf8u_prepare + jsr mulf8u_prepare + // mulf8s::@1 + // mulf8s_prepared(b) + // [95] (signed byte) mulf8s_prepared::b#0 ← (signed byte) mulf8s::b#2 -- vbsz1=vbsxx + stx.z mulf8s_prepared.b + // [96] call mulf8s_prepared + jsr mulf8s_prepared + // mulf8s::@2 + // [97] (signed word) mulf8s::return#0 ← (signed word)(word) mulf8s_prepared::m#4 + // mulf8s::@return + // } + // [98] return + rts +} + // mulf8s_prepared +// Calculate fast multiply with a prepared unsigned byte to a word result +// The prepared number is set by calling mulf8s_prepare(byte a) +// mulf8s_prepared(signed byte zeropage($e) b) +mulf8s_prepared: { + .label memA = $fd + .label m = $b + .label b = $e + // mulf8u_prepared((byte) b) + // [99] (byte) mulf8u_prepared::b#0 ← (byte)(signed byte) mulf8s_prepared::b#0 -- vbuaa=vbuz1 + lda.z b + // [100] call mulf8u_prepared + jsr mulf8u_prepared + // [101] (word) mulf8u_prepared::return#2 ← (word) mulf8u_prepared::return#0 + // mulf8s_prepared::@5 + // m = mulf8u_prepared((byte) b) + // [102] (word) mulf8s_prepared::m#0 ← (word) mulf8u_prepared::return#2 + // if(*memA<0) + // [103] if(*((const signed byte*) mulf8s_prepared::memA)>=(signed byte) 0) goto mulf8s_prepared::@1 -- _deref_pbsc1_ge_0_then_la1 + lda memA + cmp #0 + bpl __b1 + // mulf8s_prepared::@3 + // >m + // [104] (byte~) mulf8s_prepared::$8 ← > (word) mulf8s_prepared::m#0 -- vbuaa=_hi_vwuz1 + lda.z m+1 + // >m = (>m)-(byte)b + // [105] (byte~) mulf8s_prepared::$15 ← (byte~) mulf8s_prepared::$8 - (byte)(signed byte) mulf8s_prepared::b#0 -- vbuaa=vbuaa_minus_vbuz1 + sec + sbc.z b + // [106] (word) mulf8s_prepared::m#1 ← (word) mulf8s_prepared::m#0 hi= (byte~) mulf8s_prepared::$15 -- vwuz1=vwuz1_sethi_vbuaa + sta.z m+1 + // [107] phi from mulf8s_prepared::@3 mulf8s_prepared::@5 to mulf8s_prepared::@1 [phi:mulf8s_prepared::@3/mulf8s_prepared::@5->mulf8s_prepared::@1] + // [107] phi (word) mulf8s_prepared::m#5 = (word) mulf8s_prepared::m#1 [phi:mulf8s_prepared::@3/mulf8s_prepared::@5->mulf8s_prepared::@1#0] -- register_copy + // mulf8s_prepared::@1 + __b1: + // if(b<0) + // [108] if((signed byte) mulf8s_prepared::b#0>=(signed byte) 0) goto mulf8s_prepared::@2 -- vbsz1_ge_0_then_la1 + lda.z b + cmp #0 + bpl __b2 + // mulf8s_prepared::@4 + // >m + // [109] (byte~) mulf8s_prepared::$12 ← > (word) mulf8s_prepared::m#5 -- vbuaa=_hi_vwuz1 + lda.z m+1 + // >m = (>m)-(byte)*memA + // [110] (byte~) mulf8s_prepared::$16 ← (byte~) mulf8s_prepared::$12 - (byte)*((const signed byte*) mulf8s_prepared::memA) -- vbuaa=vbuaa_minus__deref_pbuc1 + sec + sbc memA + // [111] (word) mulf8s_prepared::m#2 ← (word) mulf8s_prepared::m#5 hi= (byte~) mulf8s_prepared::$16 -- vwuz1=vwuz1_sethi_vbuaa + sta.z m+1 + // [112] phi from mulf8s_prepared::@1 mulf8s_prepared::@4 to mulf8s_prepared::@2 [phi:mulf8s_prepared::@1/mulf8s_prepared::@4->mulf8s_prepared::@2] + // [112] phi (word) mulf8s_prepared::m#4 = (word) mulf8s_prepared::m#5 [phi:mulf8s_prepared::@1/mulf8s_prepared::@4->mulf8s_prepared::@2#0] -- register_copy + // mulf8s_prepared::@2 + __b2: + // mulf8s_prepared::@return + // } + // [113] return + rts +} + // mulf8u_prepared +// Calculate fast multiply with a prepared unsigned byte to a word result +// The prepared number is set by calling mulf8u_prepare(byte a) +// mulf8u_prepared(byte register(A) b) +mulf8u_prepared: { + .label resL = $fe + .label memB = $ff + .label return = $b + // *memB = b + // [114] *((const byte*) mulf8u_prepared::memB) ← (byte) mulf8u_prepared::b#0 -- _deref_pbuc1=vbuaa + sta memB + // asm + // asm { ldxmemB sec sm1: ldamulf_sqr1_lo,x sm2: sbcmulf_sqr2_lo,x staresL sm3: ldamulf_sqr1_hi,x sm4: sbcmulf_sqr2_hi,x stamemB } + tax + sec + sm1: + lda mulf_sqr1_lo,x + sm2: + sbc mulf_sqr2_lo,x + sta resL + sm3: + lda mulf_sqr1_hi,x + sm4: + sbc mulf_sqr2_hi,x + sta memB + // return { *memB, *resL }; + // [116] (word) mulf8u_prepared::return#0 ← *((const byte*) mulf8u_prepared::memB) w= *((const byte*) mulf8u_prepared::resL) -- vwuz1=_deref_pbuc1_word__deref_pbuc2 + lda resL + sta.z return + lda memB + sta.z return+1 + // mulf8u_prepared::@return + // } + // [117] return + rts +} + // mulf8u_prepare +// Prepare for fast multiply with an unsigned byte to a word result +// mulf8u_prepare(byte register(A) a) +mulf8u_prepare: { + .label memA = $fd + // *memA = a + // [118] *((const byte*) mulf8u_prepare::memA) ← (byte) mulf8u_prepare::a#0 -- _deref_pbuc1=vbuaa + sta memA + // asm + // asm { ldamemA stamulf8u_prepared.sm1+1 stamulf8u_prepared.sm3+1 eor#$ff stamulf8u_prepared.sm2+1 stamulf8u_prepared.sm4+1 } + sta mulf8u_prepared.sm1+1 + sta mulf8u_prepared.sm3+1 + eor #$ff + sta mulf8u_prepared.sm2+1 + sta mulf8u_prepared.sm4+1 + // mulf8u_prepare::@return + // } + // [120] return + rts +} + // renderBobCleanup +// Clean Up the rendered BOB's +renderBobCleanup: { + .label screen = $f + // [122] phi from renderBobCleanup to renderBobCleanup::@1 [phi:renderBobCleanup->renderBobCleanup::@1] + // [122] phi (byte) renderBobCleanup::i#2 = (byte) 0 [phi:renderBobCleanup->renderBobCleanup::@1#0] -- vbuxx=vbuc1 + ldx #0 + // [122] phi from renderBobCleanup::@1 to renderBobCleanup::@1 [phi:renderBobCleanup::@1->renderBobCleanup::@1] + // [122] phi (byte) renderBobCleanup::i#2 = (byte) renderBobCleanup::i#1 [phi:renderBobCleanup::@1->renderBobCleanup::@1#0] -- register_copy + // renderBobCleanup::@1 + __b1: + // screen = RENDERBOB_CLEANUP[i] + // [123] (byte~) renderBobCleanup::$1 ← (byte) renderBobCleanup::i#2 << (byte) 1 -- vbuaa=vbuxx_rol_1 + txa + asl + // [124] (byte*) renderBobCleanup::screen#0 ← *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobCleanup::$1) -- pbuz1=pptc1_derefidx_vbuaa + tay + lda RENDERBOB_CLEANUP,y + sta.z screen + lda RENDERBOB_CLEANUP+1,y + sta.z screen+1 + // screen[0] = 0 + // [125] *((byte*) renderBobCleanup::screen#0) ← (byte) 0 -- _deref_pbuz1=vbuc1 + lda #0 + tay + sta (screen),y + // screen[40] = 0 + // [126] *((byte*) renderBobCleanup::screen#0 + (byte) $28) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + ldy #$28 + sta (screen),y + // screen[80] = 0 + // [127] *((byte*) renderBobCleanup::screen#0 + (byte) $50) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + ldy #$50 + sta (screen),y + // screen[1] = 0 + // [128] *((byte*) renderBobCleanup::screen#0 + (byte) 1) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + ldy #1 + sta (screen),y + // screen[41] = 0 + // [129] *((byte*) renderBobCleanup::screen#0 + (byte) $29) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + ldy #$29 + sta (screen),y + // screen[81] = 0 + // [130] *((byte*) renderBobCleanup::screen#0 + (byte) $51) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + ldy #$51 + sta (screen),y + // screen[2] = 0 + // [131] *((byte*) renderBobCleanup::screen#0 + (byte) 2) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + ldy #2 + sta (screen),y + // screen[42] = 0 + // [132] *((byte*) renderBobCleanup::screen#0 + (byte) $2a) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + ldy #$2a + sta (screen),y + // screen[82] = 0 + // [133] *((byte*) renderBobCleanup::screen#0 + (byte) $52) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + ldy #$52 + sta (screen),y + // for(char i: 0..NUM_BOBS-1) + // [134] (byte) renderBobCleanup::i#1 ← ++ (byte) renderBobCleanup::i#2 -- vbuxx=_inc_vbuxx + inx + // [135] if((byte) renderBobCleanup::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto renderBobCleanup::@1 -- vbuxx_neq_vbuc1_then_la1 + cpx #NUM_BOBS-1+1 + bne __b1 + // renderBobCleanup::@return + // } + // [136] return + rts +} + // memset +// Copies the character c (an unsigned char) to the first num characters of the object pointed to by the argument str. +memset: { + .label str = BOB_SCREEN + .const c = 0 + .const num = $3e8 + .label end = str+num + .label dst = 6 + // [138] phi from memset to memset::@1 [phi:memset->memset::@1] + // [138] phi (byte*) memset::dst#2 = (byte*)(const void*) memset::str#0 [phi:memset->memset::@1#0] -- pbuz1=pbuc1 + lda #str + sta.z dst+1 + // memset::@1 + __b1: + // for(char* dst = str; dst!=end; dst++) + // [139] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 -- pbuz1_neq_pbuc1_then_la1 + lda.z dst+1 + cmp #>end + bne __b2 + lda.z dst + cmp #memset::@1] + // [138] phi (byte*) memset::dst#2 = (byte*) memset::dst#1 [phi:memset::@2->memset::@1#0] -- register_copy + jmp __b1 +} + // renderBobInit +// Initialize the tables used by renderBob() +renderBobInit: { + .label __0 = $f + .label __1 = $f + .label __6 = $11 + .label __7 = $f + // [144] phi from renderBobInit to renderBobInit::@1 [phi:renderBobInit->renderBobInit::@1] + // [144] phi (byte) renderBobInit::y#2 = (byte) 0 [phi:renderBobInit->renderBobInit::@1#0] -- vbuxx=vbuc1 + ldx #0 + // [144] phi from renderBobInit::@1 to renderBobInit::@1 [phi:renderBobInit::@1->renderBobInit::@1] + // [144] phi (byte) renderBobInit::y#2 = (byte) renderBobInit::y#1 [phi:renderBobInit::@1->renderBobInit::@1#0] -- register_copy + // renderBobInit::@1 + __b1: + // (unsigned int)y + // [145] (word~) renderBobInit::$0 ← (word)(byte) renderBobInit::y#2 -- vwuz1=_word_vbuxx + txa + sta.z __0 + lda #0 + sta.z __0+1 + // ((unsigned int)y)*40 + // [146] (word~) renderBobInit::$6 ← (word~) renderBobInit::$0 << (byte) 2 -- vwuz1=vwuz2_rol_2 + lda.z __0 + asl + sta.z __6 + lda.z __0+1 + rol + sta.z __6+1 + asl.z __6 + rol.z __6+1 + // [147] (word~) renderBobInit::$7 ← (word~) renderBobInit::$6 + (word~) renderBobInit::$0 -- vwuz1=vwuz2_plus_vwuz1 + lda.z __7 + clc + adc.z __6 + sta.z __7 + lda.z __7+1 + adc.z __6+1 + sta.z __7+1 + // [148] (word~) renderBobInit::$1 ← (word~) renderBobInit::$7 << (byte) 3 -- vwuz1=vwuz1_rol_3 + asl.z __1 + rol.z __1+1 + asl.z __1 + rol.z __1+1 + asl.z __1 + rol.z __1+1 + // MUL40[y] = ((unsigned int)y)*40 + // [149] (byte~) renderBobInit::$4 ← (byte) renderBobInit::y#2 << (byte) 1 -- vbuaa=vbuxx_rol_1 + txa + asl + // [150] *((const word*) MUL40 + (byte~) renderBobInit::$4) ← (word~) renderBobInit::$1 -- pwuc1_derefidx_vbuaa=vwuz1 + tay + lda.z __1 + sta MUL40,y + lda.z __1+1 + sta MUL40+1,y + // for(char y: 0..0x1f) + // [151] (byte) renderBobInit::y#1 ← ++ (byte) renderBobInit::y#2 -- vbuxx=_inc_vbuxx + inx + // [152] if((byte) renderBobInit::y#1!=(byte) $20) goto renderBobInit::@1 -- vbuxx_neq_vbuc1_then_la1 + cpx #$20 + bne __b1 + // [153] phi from renderBobInit::@1 to renderBobInit::@2 [phi:renderBobInit::@1->renderBobInit::@2] + // [153] phi (byte) renderBobInit::i#2 = (byte) 0 [phi:renderBobInit::@1->renderBobInit::@2#0] -- vbuxx=vbuc1 + ldx #0 + // [153] phi from renderBobInit::@2 to renderBobInit::@2 [phi:renderBobInit::@2->renderBobInit::@2] + // [153] phi (byte) renderBobInit::i#2 = (byte) renderBobInit::i#1 [phi:renderBobInit::@2->renderBobInit::@2#0] -- register_copy + // renderBobInit::@2 + __b2: + // RENDERBOB_CLEANUP[i] = BOB_SCREEN + // [154] (byte~) renderBobInit::$5 ← (byte) renderBobInit::i#2 << (byte) 1 -- vbuaa=vbuxx_rol_1 + txa + asl + // [155] *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobInit::$5) ← (const byte*) BOB_SCREEN -- pptc1_derefidx_vbuaa=pbuc2 + tay + lda #BOB_SCREEN + sta RENDERBOB_CLEANUP+1,y + // for(char i: 0..NUM_BOBS-1) + // [156] (byte) renderBobInit::i#1 ← ++ (byte) renderBobInit::i#2 -- vbuxx=_inc_vbuxx + inx + // [157] if((byte) renderBobInit::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto renderBobInit::@2 -- vbuxx_neq_vbuc1_then_la1 + cpx #NUM_BOBS-1+1 + bne __b2 + // renderBobInit::@return + // } + // [158] return + rts +} + // prepareBobs +// Creates the pre-shifted bobs into BOB_CHARSET and populates the BOB_TABLES +// Modifies PROTO_BOB by shifting it around +prepareBobs: { + .label bob_table = $f + .label shift_y = 2 + // Populate charset and tables + .label bob_glyph = 6 + .label cell = $a + .label bob_table_idx = 4 + .label shift_x = 5 + // progress_init(SCREEN_BASIC) + // [160] call progress_init + // [241] phi from prepareBobs to progress_init [phi:prepareBobs->progress_init] + jsr progress_init + // [161] phi from prepareBobs to prepareBobs::@8 [phi:prepareBobs->prepareBobs::@8] + // prepareBobs::@8 + // charsetFindOrAddGlyph(PROTO_BOB+48, BOB_CHARSET) + // [162] call charsetFindOrAddGlyph + // [195] phi from prepareBobs::@8 to charsetFindOrAddGlyph [phi:prepareBobs::@8->charsetFindOrAddGlyph] + // [195] phi (byte*) charsetFindOrAddGlyph::glyph#10 = (const byte*) PROTO_BOB+(byte) $30 [phi:prepareBobs::@8->charsetFindOrAddGlyph#0] -- pbuz1=pbuc1 + lda #PROTO_BOB+$30 + sta.z charsetFindOrAddGlyph.glyph+1 + // [195] phi (byte) bob_charset_next_id#23 = (byte) 0 [phi:prepareBobs::@8->charsetFindOrAddGlyph#1] -- vbuz1=vbuc1 + lda #0 + sta.z bob_charset_next_id + jsr charsetFindOrAddGlyph + // [163] phi from prepareBobs::@8 to prepareBobs::@1 [phi:prepareBobs::@8->prepareBobs::@1] + // [163] phi (byte) prepareBobs::bob_table_idx#6 = (byte) 0 [phi:prepareBobs::@8->prepareBobs::@1#0] -- vbuz1=vbuc1 + lda #0 + sta.z bob_table_idx + // [163] phi (byte) bob_charset_next_id#14 = (byte) bob_charset_next_id#16 [phi:prepareBobs::@8->prepareBobs::@1#1] -- register_copy + // [163] phi (byte) progress_idx#16 = (byte) 0 [phi:prepareBobs::@8->prepareBobs::@1#2] -- vbuz1=vbuc1 + sta.z progress_idx + // [163] phi (byte*) progress_cursor#15 = (const byte*) SCREEN_BASIC [phi:prepareBobs::@8->prepareBobs::@1#3] -- pbuz1=pbuc1 + lda #SCREEN_BASIC + sta.z progress_cursor+1 + // [163] phi (byte) prepareBobs::shift_y#2 = (byte) 0 [phi:prepareBobs::@8->prepareBobs::@1#4] -- vbuz1=vbuc1 + lda #0 + sta.z shift_y + // prepareBobs::@1 + __b1: + // for(char shift_y=0;shift_yprepareBobs::@2] + b1: + // [166] phi (byte) progress_idx#31 = (byte) progress_idx#16 [phi:prepareBobs::@1->prepareBobs::@2#0] -- register_copy + // [166] phi (byte*) progress_cursor#31 = (byte*) progress_cursor#15 [phi:prepareBobs::@1->prepareBobs::@2#1] -- register_copy + // [166] phi (byte) bob_charset_next_id#30 = (byte) bob_charset_next_id#14 [phi:prepareBobs::@1->prepareBobs::@2#2] -- register_copy + // [166] phi (byte) prepareBobs::bob_table_idx#12 = (byte) prepareBobs::bob_table_idx#6 [phi:prepareBobs::@1->prepareBobs::@2#3] -- register_copy + // [166] phi (byte) prepareBobs::shift_x#2 = (byte) 0 [phi:prepareBobs::@1->prepareBobs::@2#4] -- vbuz1=vbuc1 + lda #0 + sta.z shift_x + // prepareBobs::@2 + __b2: + // for(char shift_x=0;shift_xprepareBobs::@4] + // prepareBobs::@4 + // protoBobShiftDown() + // [169] call protoBobShiftDown + // [230] phi from prepareBobs::@4 to protoBobShiftDown [phi:prepareBobs::@4->protoBobShiftDown] + jsr protoBobShiftDown + // prepareBobs::@9 + // for(char shift_y=0;shift_yprepareBobs::@1] + // [163] phi (byte) prepareBobs::bob_table_idx#6 = (byte) prepareBobs::bob_table_idx#12 [phi:prepareBobs::@9->prepareBobs::@1#0] -- register_copy + // [163] phi (byte) bob_charset_next_id#14 = (byte) bob_charset_next_id#30 [phi:prepareBobs::@9->prepareBobs::@1#1] -- register_copy + // [163] phi (byte) progress_idx#16 = (byte) progress_idx#31 [phi:prepareBobs::@9->prepareBobs::@1#2] -- register_copy + // [163] phi (byte*) progress_cursor#15 = (byte*) progress_cursor#31 [phi:prepareBobs::@9->prepareBobs::@1#3] -- register_copy + // [163] phi (byte) prepareBobs::shift_y#2 = (byte) prepareBobs::shift_y#1 [phi:prepareBobs::@9->prepareBobs::@1#4] -- register_copy + jmp __b1 + // prepareBobs::@3 + __b3: + // bob_table = BOB_TABLES + bob_table_idx + // [171] (byte*) prepareBobs::bob_table#0 ← (const byte*) BOB_TABLES + (byte) prepareBobs::bob_table_idx#12 -- pbuz1=pbuc1_plus_vbuz2 + lda.z bob_table_idx + clc + adc #BOB_TABLES + adc #0 + sta.z bob_table+1 + // [172] phi from prepareBobs::@3 to prepareBobs::@5 [phi:prepareBobs::@3->prepareBobs::@5] + // [172] phi (byte*) progress_cursor#24 = (byte*) progress_cursor#31 [phi:prepareBobs::@3->prepareBobs::@5#0] -- register_copy + // [172] phi (byte) progress_idx#25 = (byte) progress_idx#31 [phi:prepareBobs::@3->prepareBobs::@5#1] -- register_copy + // [172] phi (byte*) prepareBobs::bob_table#2 = (byte*) prepareBobs::bob_table#0 [phi:prepareBobs::@3->prepareBobs::@5#2] -- register_copy + // [172] phi (byte) bob_charset_next_id#21 = (byte) bob_charset_next_id#30 [phi:prepareBobs::@3->prepareBobs::@5#3] -- register_copy + // [172] phi (byte*) prepareBobs::bob_glyph#2 = (const byte*) PROTO_BOB [phi:prepareBobs::@3->prepareBobs::@5#4] -- pbuz1=pbuc1 + lda #PROTO_BOB + sta.z bob_glyph+1 + // [172] phi (byte) prepareBobs::cell#2 = (byte) 0 [phi:prepareBobs::@3->prepareBobs::@5#5] -- vbuz1=vbuc1 + lda #0 + sta.z cell + // prepareBobs::@5 + __b5: + // for(char cell = 0; cell<9; cell++) + // [173] if((byte) prepareBobs::cell#2<(byte) 9) goto prepareBobs::@6 -- vbuz1_lt_vbuc1_then_la1 + lda.z cell + cmp #9 + bcc __b6 + // prepareBobs::@7 + // bob_table_idx++; + // [174] (byte) prepareBobs::bob_table_idx#1 ← ++ (byte) prepareBobs::bob_table_idx#12 -- vbuz1=_inc_vbuz1 + inc.z bob_table_idx + // protoBobShiftRight() + // [175] call protoBobShiftRight + // [213] phi from prepareBobs::@7 to protoBobShiftRight [phi:prepareBobs::@7->protoBobShiftRight] + jsr protoBobShiftRight + // [176] phi from prepareBobs::@7 to prepareBobs::@12 [phi:prepareBobs::@7->prepareBobs::@12] + // prepareBobs::@12 + // protoBobShiftRight() + // [177] call protoBobShiftRight + // [213] phi from prepareBobs::@12 to protoBobShiftRight [phi:prepareBobs::@12->protoBobShiftRight] + jsr protoBobShiftRight + // prepareBobs::@13 + // for(char shift_x=0;shift_xprepareBobs::@2] + // [166] phi (byte) progress_idx#31 = (byte) progress_idx#25 [phi:prepareBobs::@13->prepareBobs::@2#0] -- register_copy + // [166] phi (byte*) progress_cursor#31 = (byte*) progress_cursor#24 [phi:prepareBobs::@13->prepareBobs::@2#1] -- register_copy + // [166] phi (byte) bob_charset_next_id#30 = (byte) bob_charset_next_id#21 [phi:prepareBobs::@13->prepareBobs::@2#2] -- register_copy + // [166] phi (byte) prepareBobs::bob_table_idx#12 = (byte) prepareBobs::bob_table_idx#1 [phi:prepareBobs::@13->prepareBobs::@2#3] -- register_copy + // [166] phi (byte) prepareBobs::shift_x#2 = (byte) prepareBobs::shift_x#1 [phi:prepareBobs::@13->prepareBobs::@2#4] -- register_copy + jmp __b2 + // prepareBobs::@6 + __b6: + // charsetFindOrAddGlyph(bob_glyph, BOB_CHARSET) + // [179] (byte*) charsetFindOrAddGlyph::glyph#1 ← (byte*) prepareBobs::bob_glyph#2 + // [180] call charsetFindOrAddGlyph + // [195] phi from prepareBobs::@6 to charsetFindOrAddGlyph [phi:prepareBobs::@6->charsetFindOrAddGlyph] + // [195] phi (byte*) charsetFindOrAddGlyph::glyph#10 = (byte*) charsetFindOrAddGlyph::glyph#1 [phi:prepareBobs::@6->charsetFindOrAddGlyph#0] -- register_copy + // [195] phi (byte) bob_charset_next_id#23 = (byte) bob_charset_next_id#21 [phi:prepareBobs::@6->charsetFindOrAddGlyph#1] -- register_copy + jsr charsetFindOrAddGlyph + // charsetFindOrAddGlyph(bob_glyph, BOB_CHARSET) + // [181] (byte) charsetFindOrAddGlyph::return#1 ← (byte) charsetFindOrAddGlyph::glyph_id#11 -- vbuaa=vbuxx + txa + // prepareBobs::@10 + // [182] (byte~) prepareBobs::$6 ← (byte) charsetFindOrAddGlyph::return#1 + // *bob_table = charsetFindOrAddGlyph(bob_glyph, BOB_CHARSET) + // [183] *((byte*) prepareBobs::bob_table#2) ← (byte~) prepareBobs::$6 -- _deref_pbuz1=vbuaa + // Look for an existing char in BOB_CHARSET + ldy #0 + sta (bob_table),y + // bob_glyph+=8 + // [184] (byte*) prepareBobs::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 + (byte) 8 -- pbuz1=pbuz1_plus_vbuc1 + // Move to the next glyph + lda #8 + clc + adc.z bob_glyph + sta.z bob_glyph + bcc !+ + inc.z bob_glyph+1 + !: + // bob_table += BOB_SHIFTS_X*BOB_SHIFTS_Y + // [185] (byte*) prepareBobs::bob_table#1 ← (byte*) prepareBobs::bob_table#2 + (const byte) BOB_SHIFTS_X*(const byte) BOB_SHIFTS_Y -- pbuz1=pbuz1_plus_vbuc1 + // Move to the next sub-table + lda #BOB_SHIFTS_X*BOB_SHIFTS_Y + clc + adc.z bob_table + sta.z bob_table + bcc !+ + inc.z bob_table+1 + !: + // progress_inc() + // [186] call progress_inc + jsr progress_inc + // prepareBobs::@11 + // for(char cell = 0; cell<9; cell++) + // [187] (byte) prepareBobs::cell#1 ← ++ (byte) prepareBobs::cell#2 -- vbuz1=_inc_vbuz1 + inc.z cell + // [172] phi from prepareBobs::@11 to prepareBobs::@5 [phi:prepareBobs::@11->prepareBobs::@5] + // [172] phi (byte*) progress_cursor#24 = (byte*) progress_cursor#17 [phi:prepareBobs::@11->prepareBobs::@5#0] -- register_copy + // [172] phi (byte) progress_idx#25 = (byte) progress_idx#10 [phi:prepareBobs::@11->prepareBobs::@5#1] -- register_copy + // [172] phi (byte*) prepareBobs::bob_table#2 = (byte*) prepareBobs::bob_table#1 [phi:prepareBobs::@11->prepareBobs::@5#2] -- register_copy + // [172] phi (byte) bob_charset_next_id#21 = (byte) bob_charset_next_id#16 [phi:prepareBobs::@11->prepareBobs::@5#3] -- register_copy + // [172] phi (byte*) prepareBobs::bob_glyph#2 = (byte*) prepareBobs::bob_glyph#1 [phi:prepareBobs::@11->prepareBobs::@5#4] -- register_copy + // [172] phi (byte) prepareBobs::cell#2 = (byte) prepareBobs::cell#1 [phi:prepareBobs::@11->prepareBobs::@5#5] -- register_copy + jmp __b5 +} + // progress_inc +// Increase PETSCII progress one bit +// Done by increasing the character until the idx is 8 and then moving to the next char +progress_inc: { + // if(++progress_idx==8) + // [188] (byte) progress_idx#8 ← ++ (byte) progress_idx#25 -- vbuz1=_inc_vbuz1 + inc.z progress_idx + // [189] if((byte) progress_idx#8!=(byte) 8) goto progress_inc::@1 -- vbuz1_neq_vbuc1_then_la1 + lda #8 + cmp.z progress_idx + bne __b1 + // progress_inc::@2 + // *progress_cursor = progress_chars[8] + // [190] *((byte*) progress_cursor#24) ← *((const byte*) progress_inc::progress_chars+(byte) 8) -- _deref_pbuz1=_deref_pbuc1 + lda progress_chars+8 + ldy #0 + sta (progress_cursor),y + // progress_cursor++; + // [191] (byte*) progress_cursor#8 ← ++ (byte*) progress_cursor#24 -- pbuz1=_inc_pbuz1 + inc.z progress_cursor + bne !+ + inc.z progress_cursor+1 + !: + // [192] phi from progress_inc::@2 to progress_inc::@1 [phi:progress_inc::@2->progress_inc::@1] + // [192] phi (byte*) progress_cursor#17 = (byte*) progress_cursor#8 [phi:progress_inc::@2->progress_inc::@1#0] -- register_copy + // [192] phi (byte) progress_idx#10 = (byte) 0 [phi:progress_inc::@2->progress_inc::@1#1] -- vbuz1=vbuc1 + lda #0 + sta.z progress_idx + // [192] phi from progress_inc to progress_inc::@1 [phi:progress_inc->progress_inc::@1] + // [192] phi (byte*) progress_cursor#17 = (byte*) progress_cursor#24 [phi:progress_inc->progress_inc::@1#0] -- register_copy + // [192] phi (byte) progress_idx#10 = (byte) progress_idx#8 [phi:progress_inc->progress_inc::@1#1] -- register_copy + // progress_inc::@1 + __b1: + // *progress_cursor = progress_chars[progress_idx] + // [193] *((byte*) progress_cursor#17) ← *((const byte*) progress_inc::progress_chars + (byte) progress_idx#10) -- _deref_pbuz1=pbuc1_derefidx_vbuz2 + ldy.z progress_idx + lda progress_chars,y + ldy #0 + sta (progress_cursor),y + // progress_inc::@return + // } + // [194] return + rts + // Progress characters + progress_chars: .byte $20, $65, $74, $75, $61, $f6, $e7, $ea, $e0 +} + // charsetFindOrAddGlyph +// Looks through a charset to find a glyph if present. If not present it is added. +// Returns the glyph ID +// charsetFindOrAddGlyph(byte* zeropage(6) glyph) +charsetFindOrAddGlyph: { + .label glyph = 6 + .label glyph_cursor = $11 + // [196] phi from charsetFindOrAddGlyph to charsetFindOrAddGlyph::@1 [phi:charsetFindOrAddGlyph->charsetFindOrAddGlyph::@1] + // [196] phi (byte*) charsetFindOrAddGlyph::glyph_cursor#11 = (const byte*) BOB_CHARSET [phi:charsetFindOrAddGlyph->charsetFindOrAddGlyph::@1#0] -- pbuz1=pbuc1 + lda #BOB_CHARSET + sta.z glyph_cursor+1 + // [196] phi (byte) charsetFindOrAddGlyph::glyph_id#11 = (byte) 0 [phi:charsetFindOrAddGlyph->charsetFindOrAddGlyph::@1#1] -- vbuxx=vbuc1 + ldx #0 + // charsetFindOrAddGlyph::@1 + __b1: + // while(glyph_id!=bob_charset_next_id) + // [197] if((byte) charsetFindOrAddGlyph::glyph_id#11!=(byte) bob_charset_next_id#23) goto charsetFindOrAddGlyph::@2 -- vbuxx_neq_vbuz1_then_la1 + cpx.z bob_charset_next_id + bne b1 + // [198] phi from charsetFindOrAddGlyph::@1 to charsetFindOrAddGlyph::@7 [phi:charsetFindOrAddGlyph::@1->charsetFindOrAddGlyph::@7] + // [198] phi (byte) charsetFindOrAddGlyph::i1#2 = (byte) 0 [phi:charsetFindOrAddGlyph::@1->charsetFindOrAddGlyph::@7#0] -- vbuyy=vbuc1 + ldy #0 + // Not found - add it + // charsetFindOrAddGlyph::@7 + __b7: + // for(char i=0;i<8;i++) + // [199] if((byte) charsetFindOrAddGlyph::i1#2<(byte) 8) goto charsetFindOrAddGlyph::@8 -- vbuyy_lt_vbuc1_then_la1 + cpy #8 + bcc __b8 + // charsetFindOrAddGlyph::@9 + // bob_charset_next_id++; + // [200] (byte) bob_charset_next_id#8 ← ++ (byte) bob_charset_next_id#23 -- vbuz1=_inc_vbuz1 + inc.z bob_charset_next_id + // [201] phi from charsetFindOrAddGlyph::@5 charsetFindOrAddGlyph::@9 to charsetFindOrAddGlyph::@return [phi:charsetFindOrAddGlyph::@5/charsetFindOrAddGlyph::@9->charsetFindOrAddGlyph::@return] + // [201] phi (byte) bob_charset_next_id#16 = (byte) bob_charset_next_id#23 [phi:charsetFindOrAddGlyph::@5/charsetFindOrAddGlyph::@9->charsetFindOrAddGlyph::@return#0] -- register_copy + // charsetFindOrAddGlyph::@return + // } + // [202] return + rts + // charsetFindOrAddGlyph::@8 + __b8: + // glyph_cursor[i]=glyph[i] + // [203] *((byte*) charsetFindOrAddGlyph::glyph_cursor#11 + (byte) charsetFindOrAddGlyph::i1#2) ← *((byte*) charsetFindOrAddGlyph::glyph#10 + (byte) charsetFindOrAddGlyph::i1#2) -- pbuz1_derefidx_vbuyy=pbuz2_derefidx_vbuyy + lda (glyph),y + sta (glyph_cursor),y + // for(char i=0;i<8;i++) + // [204] (byte) charsetFindOrAddGlyph::i1#1 ← ++ (byte) charsetFindOrAddGlyph::i1#2 -- vbuyy=_inc_vbuyy + iny + // [198] phi from charsetFindOrAddGlyph::@8 to charsetFindOrAddGlyph::@7 [phi:charsetFindOrAddGlyph::@8->charsetFindOrAddGlyph::@7] + // [198] phi (byte) charsetFindOrAddGlyph::i1#2 = (byte) charsetFindOrAddGlyph::i1#1 [phi:charsetFindOrAddGlyph::@8->charsetFindOrAddGlyph::@7#0] -- register_copy + jmp __b7 + // [205] phi from charsetFindOrAddGlyph::@1 to charsetFindOrAddGlyph::@2 [phi:charsetFindOrAddGlyph::@1->charsetFindOrAddGlyph::@2] + b1: + // [205] phi (byte) charsetFindOrAddGlyph::i#2 = (byte) 0 [phi:charsetFindOrAddGlyph::@1->charsetFindOrAddGlyph::@2#0] -- vbuyy=vbuc1 + ldy #0 + // charsetFindOrAddGlyph::@2 + __b2: + // for(char i=0;i<8;i++) + // [206] if((byte) charsetFindOrAddGlyph::i#2<(byte) 8) goto charsetFindOrAddGlyph::@3 -- vbuyy_lt_vbuc1_then_la1 + cpy #8 + bcc __b3 + // [208] phi from charsetFindOrAddGlyph::@2 to charsetFindOrAddGlyph::@5 [phi:charsetFindOrAddGlyph::@2->charsetFindOrAddGlyph::@5] + // [208] phi (byte) charsetFindOrAddGlyph::found#2 = (byte) 1 [phi:charsetFindOrAddGlyph::@2->charsetFindOrAddGlyph::@5#0] -- vbuaa=vbuc1 + lda #1 + jmp __b5 + // charsetFindOrAddGlyph::@3 + __b3: + // if(glyph_cursor[i]!=glyph[i]) + // [207] if(*((byte*) charsetFindOrAddGlyph::glyph_cursor#11 + (byte) charsetFindOrAddGlyph::i#2)==*((byte*) charsetFindOrAddGlyph::glyph#10 + (byte) charsetFindOrAddGlyph::i#2)) goto charsetFindOrAddGlyph::@4 -- pbuz1_derefidx_vbuyy_eq_pbuz2_derefidx_vbuyy_then_la1 + lda (glyph_cursor),y + cmp (glyph),y + beq __b4 + // [208] phi from charsetFindOrAddGlyph::@3 to charsetFindOrAddGlyph::@5 [phi:charsetFindOrAddGlyph::@3->charsetFindOrAddGlyph::@5] + // [208] phi (byte) charsetFindOrAddGlyph::found#2 = (byte) 0 [phi:charsetFindOrAddGlyph::@3->charsetFindOrAddGlyph::@5#0] -- vbuaa=vbuc1 + lda #0 + // charsetFindOrAddGlyph::@5 + __b5: + // if(found) + // [209] if((byte) 0==(byte) charsetFindOrAddGlyph::found#2) goto charsetFindOrAddGlyph::@6 -- vbuc1_eq_vbuaa_then_la1 + cmp #0 + beq __b6 + rts + // charsetFindOrAddGlyph::@6 + __b6: + // glyph_id++; + // [210] (byte) charsetFindOrAddGlyph::glyph_id#1 ← ++ (byte) charsetFindOrAddGlyph::glyph_id#11 -- vbuxx=_inc_vbuxx + inx + // glyph_cursor +=8 + // [211] (byte*) charsetFindOrAddGlyph::glyph_cursor#1 ← (byte*) charsetFindOrAddGlyph::glyph_cursor#11 + (byte) 8 -- pbuz1=pbuz1_plus_vbuc1 + lda #8 + clc + adc.z glyph_cursor + sta.z glyph_cursor + bcc !+ + inc.z glyph_cursor+1 + !: + // [196] phi from charsetFindOrAddGlyph::@6 to charsetFindOrAddGlyph::@1 [phi:charsetFindOrAddGlyph::@6->charsetFindOrAddGlyph::@1] + // [196] phi (byte*) charsetFindOrAddGlyph::glyph_cursor#11 = (byte*) charsetFindOrAddGlyph::glyph_cursor#1 [phi:charsetFindOrAddGlyph::@6->charsetFindOrAddGlyph::@1#0] -- register_copy + // [196] phi (byte) charsetFindOrAddGlyph::glyph_id#11 = (byte) charsetFindOrAddGlyph::glyph_id#1 [phi:charsetFindOrAddGlyph::@6->charsetFindOrAddGlyph::@1#1] -- register_copy + jmp __b1 + // charsetFindOrAddGlyph::@4 + __b4: + // for(char i=0;i<8;i++) + // [212] (byte) charsetFindOrAddGlyph::i#1 ← ++ (byte) charsetFindOrAddGlyph::i#2 -- vbuyy=_inc_vbuyy + iny + // [205] phi from charsetFindOrAddGlyph::@4 to charsetFindOrAddGlyph::@2 [phi:charsetFindOrAddGlyph::@4->charsetFindOrAddGlyph::@2] + // [205] phi (byte) charsetFindOrAddGlyph::i#2 = (byte) charsetFindOrAddGlyph::i#1 [phi:charsetFindOrAddGlyph::@4->charsetFindOrAddGlyph::@2#0] -- register_copy + jmp __b2 +} + // protoBobShiftRight +// Shift PROTO_BOB right one X pixel +protoBobShiftRight: { + .label carry = $e + .label i = $a + // [214] phi from protoBobShiftRight to protoBobShiftRight::@1 [phi:protoBobShiftRight->protoBobShiftRight::@1] + // [214] phi (byte) protoBobShiftRight::carry#2 = (byte) 0 [phi:protoBobShiftRight->protoBobShiftRight::@1#0] -- vbuyy=vbuc1 + ldy #0 + // [214] phi (byte) protoBobShiftRight::j#3 = (byte) 0 [phi:protoBobShiftRight->protoBobShiftRight::@1#1] -- vbuxx=vbuc1 + ldx #0 + // [214] phi (byte) protoBobShiftRight::i#2 = (byte) 0 [phi:protoBobShiftRight->protoBobShiftRight::@1#2] -- vbuz1=vbuc1 + txa + sta.z i + // protoBobShiftRight::@1 + __b1: + // for(char i=0;i<3*3*8;i++) + // [215] if((byte) protoBobShiftRight::i#2<(byte)(number) 3*(number) 3*(number) 8) goto protoBobShiftRight::@2 -- vbuz1_lt_vbuc1_then_la1 + lda.z i + cmp #3*3*8 + bcc __b2 + // protoBobShiftRight::@return + // } + // [216] return + rts + // protoBobShiftRight::@2 + __b2: + // PROTO_BOB[j]&1 + // [217] (byte~) protoBobShiftRight::$1 ← *((const byte*) PROTO_BOB + (byte) protoBobShiftRight::j#3) & (byte) 1 -- vbuaa=pbuc1_derefidx_vbuxx_band_vbuc2 + lda #1 + and PROTO_BOB,x + // (PROTO_BOB[j]&1)?0x80ub:0ub + // [218] if((byte) 0!=(byte~) protoBobShiftRight::$1) goto protoBobShiftRight::@3 -- vbuc1_neq_vbuaa_then_la1 + cmp #0 + bne __b3 + // [220] phi from protoBobShiftRight::@2 to protoBobShiftRight::@4 [phi:protoBobShiftRight::@2->protoBobShiftRight::@4] + // [220] phi (byte) protoBobShiftRight::carry#1 = (byte) 0 [phi:protoBobShiftRight::@2->protoBobShiftRight::@4#0] -- vbuz1=vbuc1 + lda #0 + sta.z carry + jmp __b4 + // [219] phi from protoBobShiftRight::@2 to protoBobShiftRight::@3 [phi:protoBobShiftRight::@2->protoBobShiftRight::@3] + // protoBobShiftRight::@3 + __b3: + // [220] phi from protoBobShiftRight::@3 to protoBobShiftRight::@4 [phi:protoBobShiftRight::@3->protoBobShiftRight::@4] + // [220] phi (byte) protoBobShiftRight::carry#1 = (byte) $80 [phi:protoBobShiftRight::@3->protoBobShiftRight::@4#0] -- vbuz1=vbuc1 + lda #$80 + sta.z carry + // protoBobShiftRight::@4 + __b4: + // PROTO_BOB[j]>>1 + // [221] (byte~) protoBobShiftRight::$5 ← *((const byte*) PROTO_BOB + (byte) protoBobShiftRight::j#3) >> (byte) 1 -- vbuaa=pbuc1_derefidx_vbuxx_ror_1 + lda PROTO_BOB,x + lsr + // carry | PROTO_BOB[j]>>1 + // [222] (byte~) protoBobShiftRight::$6 ← (byte) protoBobShiftRight::carry#2 | (byte~) protoBobShiftRight::$5 -- vbuaa=vbuyy_bor_vbuaa + sty.z $ff + ora.z $ff + // PROTO_BOB[j] = carry | PROTO_BOB[j]>>1 + // [223] *((const byte*) PROTO_BOB + (byte) protoBobShiftRight::j#3) ← (byte~) protoBobShiftRight::$6 -- pbuc1_derefidx_vbuxx=vbuaa + // Shift value and add old carry + sta PROTO_BOB,x + // if(j>=48) + // [224] if((byte) protoBobShiftRight::j#3>=(byte) $30) goto protoBobShiftRight::@5 -- vbuxx_ge_vbuc1_then_la1 + // Increment j to iterate over the PROTO_BOB left-to-right, top-to-bottom (0, 24, 48, 1, 25, 49, ...) + cpx #$30 + bcs __b5 + // protoBobShiftRight::@7 + // j+=24 + // [225] (byte) protoBobShiftRight::j#2 ← (byte) protoBobShiftRight::j#3 + (byte) $18 -- vbuxx=vbuxx_plus_vbuc1 + txa + axs #-[$18] + // [226] phi from protoBobShiftRight::@5 protoBobShiftRight::@7 to protoBobShiftRight::@6 [phi:protoBobShiftRight::@5/protoBobShiftRight::@7->protoBobShiftRight::@6] + // [226] phi (byte) protoBobShiftRight::j#10 = (byte) protoBobShiftRight::j#1 [phi:protoBobShiftRight::@5/protoBobShiftRight::@7->protoBobShiftRight::@6#0] -- register_copy + // protoBobShiftRight::@6 + __b6: + // for(char i=0;i<3*3*8;i++) + // [227] (byte) protoBobShiftRight::i#1 ← ++ (byte) protoBobShiftRight::i#2 -- vbuz1=_inc_vbuz1 + inc.z i + // [228] (byte) protoBobShiftRight::carry#10 ← (byte) protoBobShiftRight::carry#1 -- vbuyy=vbuz1 + ldy.z carry + // [214] phi from protoBobShiftRight::@6 to protoBobShiftRight::@1 [phi:protoBobShiftRight::@6->protoBobShiftRight::@1] + // [214] phi (byte) protoBobShiftRight::carry#2 = (byte) protoBobShiftRight::carry#10 [phi:protoBobShiftRight::@6->protoBobShiftRight::@1#0] -- register_copy + // [214] phi (byte) protoBobShiftRight::j#3 = (byte) protoBobShiftRight::j#10 [phi:protoBobShiftRight::@6->protoBobShiftRight::@1#1] -- register_copy + // [214] phi (byte) protoBobShiftRight::i#2 = (byte) protoBobShiftRight::i#1 [phi:protoBobShiftRight::@6->protoBobShiftRight::@1#2] -- register_copy + jmp __b1 + // protoBobShiftRight::@5 + __b5: + // j-=47 + // [229] (byte) protoBobShiftRight::j#1 ← (byte) protoBobShiftRight::j#3 - (byte) $2f -- vbuxx=vbuxx_minus_vbuc1 + txa + axs #$2f + jmp __b6 +} + // protoBobShiftDown +// Shift PROTO_BOB down one Y pixel +// At the same time restore PROTO_BOB X by shifting 8 pixels left +protoBobShiftDown: { + // [231] phi from protoBobShiftDown to protoBobShiftDown::@1 [phi:protoBobShiftDown->protoBobShiftDown::@1] + // [231] phi (byte) protoBobShiftDown::i#2 = (byte) $17 [phi:protoBobShiftDown->protoBobShiftDown::@1#0] -- vbuxx=vbuc1 + ldx #$17 + // protoBobShiftDown::@1 + __b1: + // for(char i=23;i>0;i--) + // [232] if((byte) protoBobShiftDown::i#2>(byte) 0) goto protoBobShiftDown::@2 -- vbuxx_gt_0_then_la1 + cpx #0 + bne __b2 + // protoBobShiftDown::@3 + // PROTO_BOB[0] = 0 + // [233] *((const byte*) PROTO_BOB) ← (byte) 0 -- _deref_pbuc1=vbuc2 + lda #0 + sta PROTO_BOB + // PROTO_BOB[24] = 0 + // [234] *((const byte*) PROTO_BOB+(byte) $18) ← (byte) 0 -- _deref_pbuc1=vbuc2 + sta PROTO_BOB+$18 + // PROTO_BOB[48] = 0 + // [235] *((const byte*) PROTO_BOB+(byte) $30) ← (byte) 0 -- _deref_pbuc1=vbuc2 + sta PROTO_BOB+$30 + // protoBobShiftDown::@return + // } + // [236] return + rts + // protoBobShiftDown::@2 + __b2: + // PROTO_BOB[i] = (PROTO_BOB+23)[i] + // [237] *((const byte*) PROTO_BOB + (byte) protoBobShiftDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $17 + (byte) protoBobShiftDown::i#2) -- pbuc1_derefidx_vbuxx=pbuc2_derefidx_vbuxx + lda PROTO_BOB+$17,x + sta PROTO_BOB,x + // (PROTO_BOB+24)[i] = (PROTO_BOB+47)[i] + // [238] *((const byte*) PROTO_BOB+(byte) $18 + (byte) protoBobShiftDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $2f + (byte) protoBobShiftDown::i#2) -- pbuc1_derefidx_vbuxx=pbuc2_derefidx_vbuxx + lda PROTO_BOB+$2f,x + sta PROTO_BOB+$18,x + // (PROTO_BOB+48)[i] = 0x00 + // [239] *((const byte*) PROTO_BOB+(byte) $30 + (byte) protoBobShiftDown::i#2) ← (byte) 0 -- pbuc1_derefidx_vbuxx=vbuc2 + lda #0 + sta PROTO_BOB+$30,x + // for(char i=23;i>0;i--) + // [240] (byte) protoBobShiftDown::i#1 ← -- (byte) protoBobShiftDown::i#2 -- vbuxx=_dec_vbuxx + dex + // [231] phi from protoBobShiftDown::@2 to protoBobShiftDown::@1 [phi:protoBobShiftDown::@2->protoBobShiftDown::@1] + // [231] phi (byte) protoBobShiftDown::i#2 = (byte) protoBobShiftDown::i#1 [phi:protoBobShiftDown::@2->protoBobShiftDown::@1#0] -- register_copy + jmp __b1 +} + // progress_init +// Initialize the PETSCII progress bar +progress_init: { + // progress_init::@return + // } + // [242] return + rts +} + // mulf_init +// Initialize the mulf_sqr multiplication tables with f(x)=int(x*x/4) +mulf_init: { + // x/2 + .label c = $d + // Counter used for determining x%2==0 + .label sqr1_hi = $f + // Fill mulf_sqr1 = f(x) = int(x*x/4): If f(x) = x*x/4 then f(x+1) = f(x) + x/2 + 1/4 + .label sqr = $b + .label sqr1_lo = 6 + // Decrease or increase x_255 - initially we decrease + .label sqr2_hi = 8 + .label sqr2_lo = $11 + //Start with g(0)=f(255) + .label dir = $e + // [244] phi from mulf_init to mulf_init::@1 [phi:mulf_init->mulf_init::@1] + // [244] phi (byte) mulf_init::x_2#3 = (byte) 0 [phi:mulf_init->mulf_init::@1#0] -- vbuxx=vbuc1 + ldx #0 + // [244] phi (byte*) mulf_init::sqr1_hi#2 = (const byte*) mulf_sqr1_hi+(byte) 1 [phi:mulf_init->mulf_init::@1#1] -- pbuz1=pbuc1 + lda #mulf_sqr1_hi+1 + sta.z sqr1_hi+1 + // [244] phi (word) mulf_init::sqr#4 = (byte) 0 [phi:mulf_init->mulf_init::@1#2] -- vwuz1=vbuc1 + txa + sta.z sqr + sta.z sqr+1 + // [244] phi (byte) mulf_init::c#2 = (byte) 0 [phi:mulf_init->mulf_init::@1#3] -- vbuz1=vbuc1 + sta.z c + // [244] phi (byte*) mulf_init::sqr1_lo#2 = (const byte*) mulf_sqr1_lo+(byte) 1 [phi:mulf_init->mulf_init::@1#4] -- pbuz1=pbuc1 + lda #mulf_sqr1_lo+1 + sta.z sqr1_lo+1 + // mulf_init::@1 + __b1: + // for(byte* sqr1_lo = mulf_sqr1_lo+1; sqr1_lo!=mulf_sqr1_lo+512; sqr1_lo++) + // [245] if((byte*) mulf_init::sqr1_lo#2!=(const byte*) mulf_sqr1_lo+(word) $200) goto mulf_init::@2 -- pbuz1_neq_pbuc1_then_la1 + lda.z sqr1_lo+1 + cmp #>mulf_sqr1_lo+$200 + bne __b2 + lda.z sqr1_lo + cmp #mulf_init::@5] + // [246] phi (byte) mulf_init::dir#2 = (byte) $ff [phi:mulf_init::@1->mulf_init::@5#0] -- vbuz1=vbuc1 + lda #$ff + sta.z dir + // [246] phi (byte*) mulf_init::sqr2_hi#2 = (const byte*) mulf_sqr2_hi [phi:mulf_init::@1->mulf_init::@5#1] -- pbuz1=pbuc1 + lda #mulf_sqr2_hi + sta.z sqr2_hi+1 + // [246] phi (byte) mulf_init::x_255#2 = (byte) -1 [phi:mulf_init::@1->mulf_init::@5#2] -- vbuxx=vbuc1 + ldx #-1 + // [246] phi (byte*) mulf_init::sqr2_lo#2 = (const byte*) mulf_sqr2_lo [phi:mulf_init::@1->mulf_init::@5#3] -- pbuz1=pbuc1 + lda #mulf_sqr2_lo + sta.z sqr2_lo+1 + // mulf_init::@5 + __b5: + // for(byte* sqr2_lo = mulf_sqr2_lo; sqr2_lo!=mulf_sqr2_lo+511; sqr2_lo++) + // [247] if((byte*) mulf_init::sqr2_lo#2!=(const byte*) mulf_sqr2_lo+(word) $1ff) goto mulf_init::@6 -- pbuz1_neq_pbuc1_then_la1 + lda.z sqr2_lo+1 + cmp #>mulf_sqr2_lo+$1ff + bne __b6 + lda.z sqr2_lo + cmp #mulf_init::@8] + // [257] phi (byte) mulf_init::dir#4 = (byte) 1 [phi:mulf_init::@6->mulf_init::@8#0] -- vbuz1=vbuc1 + lda #1 + sta.z dir + // [256] phi from mulf_init::@6 to mulf_init::@9 [phi:mulf_init::@6->mulf_init::@9] + // mulf_init::@9 + // [257] phi from mulf_init::@9 to mulf_init::@8 [phi:mulf_init::@9->mulf_init::@8] + // [257] phi (byte) mulf_init::dir#4 = (byte) mulf_init::dir#2 [phi:mulf_init::@9->mulf_init::@8#0] -- register_copy + // mulf_init::@8 + __b8: + // for(byte* sqr2_lo = mulf_sqr2_lo; sqr2_lo!=mulf_sqr2_lo+511; sqr2_lo++) + // [258] (byte*) mulf_init::sqr2_lo#1 ← ++ (byte*) mulf_init::sqr2_lo#2 -- pbuz1=_inc_pbuz1 + inc.z sqr2_lo + bne !+ + inc.z sqr2_lo+1 + !: + // [246] phi from mulf_init::@8 to mulf_init::@5 [phi:mulf_init::@8->mulf_init::@5] + // [246] phi (byte) mulf_init::dir#2 = (byte) mulf_init::dir#4 [phi:mulf_init::@8->mulf_init::@5#0] -- register_copy + // [246] phi (byte*) mulf_init::sqr2_hi#2 = (byte*) mulf_init::sqr2_hi#1 [phi:mulf_init::@8->mulf_init::@5#1] -- register_copy + // [246] phi (byte) mulf_init::x_255#2 = (byte) mulf_init::x_255#1 [phi:mulf_init::@8->mulf_init::@5#2] -- register_copy + // [246] phi (byte*) mulf_init::sqr2_lo#2 = (byte*) mulf_init::sqr2_lo#1 [phi:mulf_init::@8->mulf_init::@5#3] -- register_copy + jmp __b5 + // mulf_init::@2 + __b2: + // if((++c&1)==0) + // [259] (byte) mulf_init::c#1 ← ++ (byte) mulf_init::c#2 -- vbuz1=_inc_vbuz1 + inc.z c + // ++c&1 + // [260] (byte~) mulf_init::$1 ← (byte) mulf_init::c#1 & (byte) 1 -- vbuaa=vbuz1_band_vbuc1 + lda #1 + and.z c + // if((++c&1)==0) + // [261] if((byte~) mulf_init::$1!=(byte) 0) goto mulf_init::@3 -- vbuaa_neq_0_then_la1 + cmp #0 + bne __b3 + // mulf_init::@4 + // x_2++; + // [262] (byte) mulf_init::x_2#1 ← ++ (byte) mulf_init::x_2#3 -- vbuxx=_inc_vbuxx + inx + // sqr++; + // [263] (word) mulf_init::sqr#2 ← ++ (word) mulf_init::sqr#4 -- vwuz1=_inc_vwuz1 + inc.z sqr + bne !+ + inc.z sqr+1 + !: + // [264] phi from mulf_init::@2 mulf_init::@4 to mulf_init::@3 [phi:mulf_init::@2/mulf_init::@4->mulf_init::@3] + // [264] phi (byte) mulf_init::x_2#2 = (byte) mulf_init::x_2#3 [phi:mulf_init::@2/mulf_init::@4->mulf_init::@3#0] -- register_copy + // [264] phi (word) mulf_init::sqr#3 = (word) mulf_init::sqr#4 [phi:mulf_init::@2/mulf_init::@4->mulf_init::@3#1] -- register_copy + // mulf_init::@3 + __b3: + // sqr + // [267] (byte~) mulf_init::$5 ← > (word) mulf_init::sqr#3 -- vbuaa=_hi_vwuz1 + lda.z sqr+1 + // *sqr1_hi++ = >sqr + // [268] *((byte*) mulf_init::sqr1_hi#2) ← (byte~) mulf_init::$5 -- _deref_pbuz1=vbuaa + sta (sqr1_hi),y + // *sqr1_hi++ = >sqr; + // [269] (byte*) mulf_init::sqr1_hi#1 ← ++ (byte*) mulf_init::sqr1_hi#2 -- pbuz1=_inc_pbuz1 + inc.z sqr1_hi + bne !+ + inc.z sqr1_hi+1 + !: + // sqr = sqr + x_2 + // [270] (word) mulf_init::sqr#1 ← (word) mulf_init::sqr#3 + (byte) mulf_init::x_2#2 -- vwuz1=vwuz1_plus_vbuxx + txa + clc + adc.z sqr + sta.z sqr + bcc !+ + inc.z sqr+1 + !: + // for(byte* sqr1_lo = mulf_sqr1_lo+1; sqr1_lo!=mulf_sqr1_lo+512; sqr1_lo++) + // [271] (byte*) mulf_init::sqr1_lo#1 ← ++ (byte*) mulf_init::sqr1_lo#2 -- pbuz1=_inc_pbuz1 + inc.z sqr1_lo + bne !+ + inc.z sqr1_lo+1 + !: + // [244] phi from mulf_init::@3 to mulf_init::@1 [phi:mulf_init::@3->mulf_init::@1] + // [244] phi (byte) mulf_init::x_2#3 = (byte) mulf_init::x_2#2 [phi:mulf_init::@3->mulf_init::@1#0] -- register_copy + // [244] phi (byte*) mulf_init::sqr1_hi#2 = (byte*) mulf_init::sqr1_hi#1 [phi:mulf_init::@3->mulf_init::@1#1] -- register_copy + // [244] phi (word) mulf_init::sqr#4 = (word) mulf_init::sqr#1 [phi:mulf_init::@3->mulf_init::@1#2] -- register_copy + // [244] phi (byte) mulf_init::c#2 = (byte) mulf_init::c#1 [phi:mulf_init::@3->mulf_init::@1#3] -- register_copy + // [244] phi (byte*) mulf_init::sqr1_lo#2 = (byte*) mulf_init::sqr1_lo#1 [phi:mulf_init::@3->mulf_init::@1#4] -- register_copy + jmp __b1 +} + // File Data + // Keyboard row bitmask as expected by CIA#1 Port A when reading a specific keyboard matrix row (rows are numbered 0-7) + keyboard_matrix_row_bitmask: .byte $fe, $fd, $fb, $f7, $ef, $df, $bf, $7f + // Keyboard matrix column bitmasks for a specific keybooard matrix column when reading the keyboard. (columns are numbered 0-7) + keyboard_matrix_col_bitmask: .byte 1, 2, 4, 8, $10, $20, $40, $80 + // mulf_sqr tables will contain f(x)=int(x*x/4) and g(x) = f(x-255). + // f(x) = >(( x * x )/4) + .align $100 + mulf_sqr1_hi: .fill $200, 0 + // g(x) = >((( x - 255) * ( x - 255 ))/4) + .align $100 + mulf_sqr2_hi: .fill $200, 0 + // The prototype BOB (a 3x3 char image with a bob image in the upper 2x2 chars) + // The chars are layout as follows with data in chars 0, 1, 3, 4 initially + // 0 3 6 + // 1 4 7 + // 2 5 8 +PROTO_BOB: +.var pic = LoadPicture("smiley.png", List().add($000000, $ffffff)) + .for (var x=0;x<3; x++) + .for (var y=0; y<24; y++) + .byte pic.getSinglecolorByte(x,y) + + // Sine and Cosine tables + // Angles: $00=0, $80=PI,$100=2*PI + // Sine/Cosine: signed fixed [-$7f,$7f] + .align $40 +SIN: +.for(var i=0;i<$140;i++) + .byte >round($7fff*sin(i*2*PI/256)) + + // Tables containing the char to use for a specific cell of a shifted BOB. + // char_id = BOB_TABLES[cell*BOB_SUBTABLE_SIZE + shift_y*BOB_SHIFTS_X + shift_x]; + BOB_TABLES: .fill 9*8*4, 0 + // Table used for deleting rendered BOB's. Contains pointers to first char of each BOB. + RENDERBOB_CLEANUP: .fill 2*NUM_BOBS, 0 + // *40 Table unsigned int[0x20] MUL40 = { ((unsigned int)i)*40 }; + MUL40: .fill 2*$20, 0 + diff --git a/src/test/ref/complex/prebob/grid-bobs.sym b/src/test/ref/complex/prebob/grid-bobs.sym new file mode 100644 index 000000000..1f0335b31 --- /dev/null +++ b/src/test/ref/complex/prebob/grid-bobs.sym @@ -0,0 +1,473 @@ +(label) @1 +(label) @begin +(label) @end +(const byte*) BOB_CHARSET = (byte*) 8192 +(const byte*) BOB_SCREEN = (byte*) 10240 +(const byte) BOB_SHIFTS_X = (number) 4 +(const byte) BOB_SHIFTS_Y = (number) 8 +(const byte) BOB_SUBTABLE_SIZE = (const byte) BOB_SHIFTS_X*(const byte) BOB_SHIFTS_Y +(const byte*) BOB_TABLES = { fill( 9*8*4, 0) } +(const byte*) BORDERCOL = (byte*) 53280 +(const byte*) CHARSET_BASIC = (byte*) 4096 +(const byte*) CIA1_PORT_A = (byte*) 56320 +(const byte*) CIA1_PORT_B = (byte*) 56321 +(const byte*) CIA2_PORT_A = (byte*) 56576 +(const byte*) CIA2_PORT_A_DDR = (byte*) 56578 +(const signed byte*) COS = (const signed byte*) SIN+(byte) $40 +(const byte*) D018 = (byte*) 53272 +(const byte) KEY_SPACE = (number) $3c +(const word*) MUL40 = { fill( $20, 0) } +(const byte) NUM_BOBS = (number) $14 +(const byte*) PROTO_BOB = kickasm {{ .var pic = LoadPicture("smiley.png", List().add($000000, $ffffff)) + .for (var x=0;x<3; x++) + .for (var y=0; y<24; y++) + .byte pic.getSinglecolorByte(x,y) + }} +(const byte) RADIX::BINARY = (number) 2 +(const byte) RADIX::DECIMAL = (number) $a +(const byte) RADIX::HEXADECIMAL = (number) $10 +(const byte) RADIX::OCTAL = (number) 8 +(const byte*) RASTER = (byte*) 53266 +(const byte**) RENDERBOB_CLEANUP = { fill( NUM_BOBS, 0) } +(const byte*) SCREEN_BASIC = (byte*) 1024 +(const signed byte*) SIN = kickasm {{ .for(var i=0;i<$140;i++) + .byte >round($7fff*sin(i*2*PI/256)) + }} +(const byte) SIZEOF_POINTER = (byte) 2 +(byte) bob_charset_next_id +(byte) bob_charset_next_id#14 bob_charset_next_id zp[1]:13 12.0 +(byte) bob_charset_next_id#16 bob_charset_next_id zp[1]:13 1000.5454545454544 +(byte) bob_charset_next_id#21 bob_charset_next_id zp[1]:13 275.5 +(byte) bob_charset_next_id#23 bob_charset_next_id zp[1]:13 1400.3333333333335 +(byte) bob_charset_next_id#30 bob_charset_next_id zp[1]:13 37.33333333333333 +(byte) bob_charset_next_id#8 bob_charset_next_id zp[1]:13 4.0 +(byte()) charsetFindOrAddGlyph((byte*) charsetFindOrAddGlyph::glyph , (byte*) charsetFindOrAddGlyph::charset) +(label) charsetFindOrAddGlyph::@1 +(label) charsetFindOrAddGlyph::@2 +(label) charsetFindOrAddGlyph::@3 +(label) charsetFindOrAddGlyph::@4 +(label) charsetFindOrAddGlyph::@5 +(label) charsetFindOrAddGlyph::@6 +(label) charsetFindOrAddGlyph::@7 +(label) charsetFindOrAddGlyph::@8 +(label) charsetFindOrAddGlyph::@9 +(label) charsetFindOrAddGlyph::@return +(byte*) charsetFindOrAddGlyph::charset +(byte) charsetFindOrAddGlyph::found +(byte) charsetFindOrAddGlyph::found#2 reg byte a 10001.0 +(byte*) charsetFindOrAddGlyph::glyph +(byte*) charsetFindOrAddGlyph::glyph#1 glyph zp[2]:6 2002.0 +(byte*) charsetFindOrAddGlyph::glyph#10 glyph zp[2]:6 7400.200000000001 +(byte*) charsetFindOrAddGlyph::glyph_cursor +(byte*) charsetFindOrAddGlyph::glyph_cursor#1 glyph_cursor zp[2]:17 20002.0 +(byte*) charsetFindOrAddGlyph::glyph_cursor#11 glyph_cursor zp[2]:17 10000.307692307691 +(byte) charsetFindOrAddGlyph::glyph_id +(byte) charsetFindOrAddGlyph::glyph_id#1 reg byte x 10001.0 +(byte) charsetFindOrAddGlyph::glyph_id#11 reg byte x 1937.75 +(byte) charsetFindOrAddGlyph::i +(byte) charsetFindOrAddGlyph::i#1 reg byte y 200002.0 +(byte) charsetFindOrAddGlyph::i#2 reg byte y 166668.3333333333 +(byte) charsetFindOrAddGlyph::i1 +(byte) charsetFindOrAddGlyph::i1#1 reg byte y 20002.0 +(byte) charsetFindOrAddGlyph::i1#2 reg byte y 16668.333333333332 +(byte) charsetFindOrAddGlyph::return +(byte) charsetFindOrAddGlyph::return#1 reg byte a 2002.0 +(byte()) keyboard_key_pressed((byte) keyboard_key_pressed::key) +(byte~) keyboard_key_pressed::$2 reg byte a 4.0 +(label) keyboard_key_pressed::@1 +(label) keyboard_key_pressed::@return +(byte) keyboard_key_pressed::colidx +(const byte) keyboard_key_pressed::colidx#0 colidx = (const byte) KEY_SPACE&(byte) 7 +(byte) keyboard_key_pressed::key +(byte) keyboard_key_pressed::return +(byte) keyboard_key_pressed::return#0 reg byte a 6.0 +(byte) keyboard_key_pressed::return#2 reg byte a 22.0 +(byte) keyboard_key_pressed::return#3 reg byte a 22.0 +(byte) keyboard_key_pressed::rowidx +(const byte) keyboard_key_pressed::rowidx#0 rowidx = (const byte) KEY_SPACE>>(byte) 3 +(const byte*) keyboard_matrix_col_bitmask = { (byte) 1, (byte) 2, (byte) 4, (byte) 8, (byte) $10, (byte) $20, (byte) $40, (byte) $80 } +(byte()) keyboard_matrix_read((byte) keyboard_matrix_read::rowid) +(label) keyboard_matrix_read::@return +(byte) keyboard_matrix_read::return +(byte) keyboard_matrix_read::return#0 reg byte a 1.3333333333333333 +(byte) keyboard_matrix_read::return#2 reg byte a 4.0 +(byte) keyboard_matrix_read::row_pressed_bits +(byte) keyboard_matrix_read::rowid +(const byte*) keyboard_matrix_row_bitmask = { (byte) $fe, (byte) $fd, (byte) $fb, (byte) $f7, (byte) $ef, (byte) $df, (byte) $bf, (byte) $7f } +(void()) main() +(signed word~) main::$10 zp[2]:11 202.0 +(signed word~) main::$12 zp[2]:11 202.0 +(signed word~) main::$13 zp[2]:11 202.0 +(byte~) main::$19 reg byte a 22.0 +(byte~) main::$21 reg byte a 22.0 +(label) main::@1 +(label) main::@10 +(label) main::@11 +(label) main::@12 +(label) main::@13 +(label) main::@14 +(label) main::@15 +(label) main::@16 +(label) main::@2 +(label) main::@3 +(label) main::@4 +(label) main::@5 +(label) main::@6 +(label) main::@7 +(label) main::@8 +(label) main::@9 +(label) main::@return +(byte) main::a +(byte) main::a#1 a zp[1]:4 28.857142857142858 +(byte) main::a#2 a zp[1]:4 25.9375 +(byte) main::a#6 a zp[1]:4 22.0 +(byte) main::angle +(byte) main::angle#1 angle zp[1]:2 3.6666666666666665 +(byte) main::angle#8 angle zp[1]:2 1.1785714285714286 +(byte) main::i +(byte) main::i#1 i zp[1]:5 151.5 +(byte) main::i#2 i zp[1]:5 9.619047619047619 +(signed byte) main::r +(signed byte) main::r#1 r zp[1]:3 33.666666666666664 +(signed byte) main::r#2 r zp[1]:3 23.764705882352942 +(label) main::toD0181 +(byte*) main::toD0181_gfx +(byte) main::toD0181_return +(const byte) main::toD0181_return#0 toD0181_return = >(word)(const byte*) BOB_SCREEN&(word) $3fff*(byte) 4|>(word)(const byte*) BOB_CHARSET/(byte) 4&(byte) $f +(byte*) main::toD0181_screen +(label) main::toD0182 +(byte*) main::toD0182_gfx +(byte) main::toD0182_return +(const byte) main::toD0182_return#0 toD0182_return = >(word)(const byte*) SCREEN_BASIC&(word) $3fff*(byte) 4|>(word)(const byte*) CHARSET_BASIC/(byte) 4&(byte) $f +(byte*) main::toD0182_screen +(label) main::vicSelectGfxBank1 +(label) main::vicSelectGfxBank1_@1 +(byte*) main::vicSelectGfxBank1_gfx +(label) main::vicSelectGfxBank1_toDd001 +(byte*) main::vicSelectGfxBank1_toDd001_gfx +(byte) main::vicSelectGfxBank1_toDd001_return +(const byte) main::vicSelectGfxBank1_toDd001_return#0 vicSelectGfxBank1_toDd001_return = (byte) 3 +(label) main::vicSelectGfxBank2 +(label) main::vicSelectGfxBank2_@1 +(byte*) main::vicSelectGfxBank2_gfx +(label) main::vicSelectGfxBank2_toDd001 +(byte*) main::vicSelectGfxBank2_toDd001_gfx +(byte) main::vicSelectGfxBank2_toDd001_return +(const byte) main::vicSelectGfxBank2_toDd001_return#0 vicSelectGfxBank2_toDd001_return = (byte) 3 +(signed word) main::x +(signed word) main::x#0 x zp[2]:8 18.363636363636363 +(signed word) main::y +(signed word) main::y#0 y zp[2]:11 40.4 +(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num) +(label) memset::@1 +(label) memset::@2 +(label) memset::@return +(byte) memset::c +(const byte) memset::c#0 c = (byte) 0 +(byte*) memset::dst +(byte*) memset::dst#1 dst zp[2]:6 22.0 +(byte*) memset::dst#2 dst zp[2]:6 14.666666666666666 +(byte*) memset::end +(const byte*) memset::end#0 end = (byte*)(const void*) memset::str#0+(const word) memset::num#0 +(word) memset::num +(const word) memset::num#0 num = (word) $3e8 +(void*) memset::return +(void*) memset::str +(const void*) memset::str#0 str = (void*)(const byte*) BOB_SCREEN +(signed word()) mulf8s((signed byte) mulf8s::a , (signed byte) mulf8s::b) +(label) mulf8s::@1 +(label) mulf8s::@2 +(label) mulf8s::@return +(signed byte) mulf8s::a +(signed byte) mulf8s::a#0 reg byte a 101.0 +(signed byte) mulf8s::a#1 reg byte a 101.0 +(signed byte) mulf8s::b +(signed byte) mulf8s::b#0 reg byte x 202.0 +(signed byte) mulf8s::b#1 reg byte x 202.0 +(signed byte) mulf8s::b#2 reg byte x 68.0 +(label) mulf8s::mulf8s_prepare1 +(signed byte) mulf8s::mulf8s_prepare1_a +(signed byte) mulf8s::mulf8s_prepare1_a#0 reg byte a 202.0 +(signed word) mulf8s::return +(signed word) mulf8s::return#0 return zp[2]:11 51.0 +(signed word) mulf8s::return#2 return zp[2]:11 202.0 +(signed word) mulf8s::return#3 return zp[2]:11 202.0 +(signed word()) mulf8s_prepared((signed byte) mulf8s_prepared::b) +(byte~) mulf8s_prepared::$12 reg byte a 4.0 +(byte~) mulf8s_prepared::$15 reg byte a 4.0 +(byte~) mulf8s_prepared::$16 reg byte a 4.0 +(byte~) mulf8s_prepared::$8 reg byte a 4.0 +(label) mulf8s_prepared::@1 +(label) mulf8s_prepared::@2 +(label) mulf8s_prepared::@3 +(label) mulf8s_prepared::@4 +(label) mulf8s_prepared::@5 +(label) mulf8s_prepared::@return +(signed byte) mulf8s_prepared::b +(signed byte) mulf8s_prepared::b#0 b zp[1]:14 0.4 +(word) mulf8s_prepared::m +(word) mulf8s_prepared::m#0 m zp[2]:11 2.0 +(word) mulf8s_prepared::m#1 m zp[2]:11 4.0 +(word) mulf8s_prepared::m#2 m zp[2]:11 4.0 +(word) mulf8s_prepared::m#4 m zp[2]:11 1.3333333333333333 +(word) mulf8s_prepared::m#5 m zp[2]:11 2.5 +(const signed byte*) mulf8s_prepared::memA = (signed byte*) 253 +(signed word) mulf8s_prepared::return +(void()) mulf8u_prepare((byte) mulf8u_prepare::a) +(label) mulf8u_prepare::@return +(byte) mulf8u_prepare::a +(byte) mulf8u_prepare::a#0 reg byte a 4.0 +(const byte*) mulf8u_prepare::memA = (byte*) 253 +(word()) mulf8u_prepared((byte) mulf8u_prepared::b) +(label) mulf8u_prepared::@return +(byte) mulf8u_prepared::b +(byte) mulf8u_prepared::b#0 reg byte a 4.0 +(const byte*) mulf8u_prepared::memB = (byte*) 255 +(const byte*) mulf8u_prepared::resL = (byte*) 254 +(word) mulf8u_prepared::return +(word) mulf8u_prepared::return#0 return zp[2]:11 1.3333333333333333 +(word) mulf8u_prepared::return#2 return zp[2]:11 4.0 +(void()) mulf_init() +(byte~) mulf_init::$1 reg byte a 22.0 +(byte~) mulf_init::$4 reg byte a 22.0 +(byte~) mulf_init::$5 reg byte a 22.0 +(label) mulf_init::@1 +(label) mulf_init::@2 +(label) mulf_init::@3 +(label) mulf_init::@4 +(label) mulf_init::@5 +(label) mulf_init::@6 +(label) mulf_init::@7 +(label) mulf_init::@8 +(label) mulf_init::@9 +(label) mulf_init::@return +(byte) mulf_init::c +(byte) mulf_init::c#1 c zp[1]:13 2.5384615384615383 +(byte) mulf_init::c#2 c zp[1]:13 11.0 +(byte) mulf_init::dir +(byte) mulf_init::dir#2 dir zp[1]:14 4.125 +(byte) mulf_init::dir#4 dir zp[1]:14 11.0 +(word) mulf_init::sqr +(word) mulf_init::sqr#1 sqr zp[2]:11 11.0 +(word) mulf_init::sqr#2 sqr zp[2]:11 22.0 +(word) mulf_init::sqr#3 sqr zp[2]:11 9.166666666666666 +(word) mulf_init::sqr#4 sqr zp[2]:11 5.5 +(byte*) mulf_init::sqr1_hi +(byte*) mulf_init::sqr1_hi#1 sqr1_hi zp[2]:15 7.333333333333333 +(byte*) mulf_init::sqr1_hi#2 sqr1_hi zp[2]:15 2.75 +(byte*) mulf_init::sqr1_lo +(byte*) mulf_init::sqr1_lo#1 sqr1_lo zp[2]:6 22.0 +(byte*) mulf_init::sqr1_lo#2 sqr1_lo zp[2]:6 3.142857142857143 +(byte*) mulf_init::sqr2_hi +(byte*) mulf_init::sqr2_hi#1 sqr2_hi zp[2]:8 3.6666666666666665 +(byte*) mulf_init::sqr2_hi#2 sqr2_hi zp[2]:8 8.25 +(byte*) mulf_init::sqr2_lo +(byte*) mulf_init::sqr2_lo#1 sqr2_lo zp[2]:17 22.0 +(byte*) mulf_init::sqr2_lo#2 sqr2_lo zp[2]:17 4.888888888888889 +(byte) mulf_init::x_2 +(byte) mulf_init::x_2#1 reg byte x 11.0 +(byte) mulf_init::x_2#2 reg byte x 5.5 +(byte) mulf_init::x_2#3 reg byte x 6.6000000000000005 +(byte) mulf_init::x_255 +(byte) mulf_init::x_255#1 reg byte x 6.6000000000000005 +(byte) mulf_init::x_255#2 reg byte x 8.8 +(const byte*) mulf_sqr1_hi = { fill( $200, 0) } +(const byte*) mulf_sqr1_lo = { fill( $200, 0) } +(const byte*) mulf_sqr2_hi = { fill( $200, 0) } +(const byte*) mulf_sqr2_lo = { fill( $200, 0) } +(void()) prepareBobs() +(byte~) prepareBobs::$6 reg byte a 2002.0 +(label) prepareBobs::@1 +(label) prepareBobs::@10 +(label) prepareBobs::@11 +(label) prepareBobs::@12 +(label) prepareBobs::@13 +(label) prepareBobs::@2 +(label) prepareBobs::@3 +(label) prepareBobs::@4 +(label) prepareBobs::@5 +(label) prepareBobs::@6 +(label) prepareBobs::@7 +(label) prepareBobs::@8 +(label) prepareBobs::@9 +(label) prepareBobs::@return +(byte*) prepareBobs::bob_glyph +(byte*) prepareBobs::bob_glyph#1 bob_glyph zp[2]:6 500.5 +(byte*) prepareBobs::bob_glyph#2 bob_glyph zp[2]:6 429.0 +(byte*) prepareBobs::bob_table +(byte*) prepareBobs::bob_table#0 bob_table zp[2]:15 202.0 +(byte*) prepareBobs::bob_table#1 bob_table zp[2]:15 667.3333333333334 +(byte*) prepareBobs::bob_table#2 bob_table zp[2]:15 388.0 +(byte) prepareBobs::bob_table_idx +(byte) prepareBobs::bob_table_idx#1 bob_table_idx zp[1]:4 40.4 +(byte) prepareBobs::bob_table_idx#12 bob_table_idx zp[1]:4 19.11764705882353 +(byte) prepareBobs::bob_table_idx#6 bob_table_idx zp[1]:4 11.0 +(byte) prepareBobs::cell +(byte) prepareBobs::cell#1 cell zp[1]:10 2002.0 +(byte) prepareBobs::cell#2 cell zp[1]:10 300.29999999999995 +(byte) prepareBobs::shift_x +(byte) prepareBobs::shift_x#1 shift_x zp[1]:5 202.0 +(byte) prepareBobs::shift_x#2 shift_x zp[1]:5 16.833333333333332 +(byte) prepareBobs::shift_y +(byte) prepareBobs::shift_y#1 shift_y zp[1]:2 22.0 +(byte) prepareBobs::shift_y#2 shift_y zp[1]:2 1.4347826086956523 +(byte*) progress_cursor +(byte*) progress_cursor#15 progress_cursor zp[2]:11 11.0 +(byte*) progress_cursor#17 progress_cursor zp[2]:11 201.4 +(byte*) progress_cursor#24 progress_cursor zp[2]:11 71.11764705882355 +(byte*) progress_cursor#31 progress_cursor zp[2]:11 37.33333333333333 +(byte*) progress_cursor#8 progress_cursor zp[2]:11 4.0 +(byte) progress_idx +(byte) progress_idx#10 progress_idx zp[1]:3 201.0 +(byte) progress_idx#16 progress_idx zp[1]:3 11.0 +(byte) progress_idx#25 progress_idx zp[1]:3 86.07142857142856 +(byte) progress_idx#31 progress_idx zp[1]:3 37.33333333333333 +(byte) progress_idx#8 progress_idx zp[1]:3 3.0 +(void()) progress_inc() +(label) progress_inc::@1 +(label) progress_inc::@2 +(label) progress_inc::@return +(const byte*) progress_inc::progress_chars = { (byte) $20, (byte) $65, (byte) $74, (byte) $75, (byte) $61, (byte) $f6, (byte) $e7, (byte) $ea, (byte) $e0 } +(void()) progress_init((byte*) progress_init::line) +(label) progress_init::@return +(byte*) progress_init::line +(void()) protoBobShiftDown() +(label) protoBobShiftDown::@1 +(label) protoBobShiftDown::@2 +(label) protoBobShiftDown::@3 +(label) protoBobShiftDown::@return +(byte) protoBobShiftDown::i +(byte) protoBobShiftDown::i#1 reg byte x 202.0 +(byte) protoBobShiftDown::i#2 reg byte x 161.6 +(void()) protoBobShiftRight() +(byte~) protoBobShiftRight::$1 reg byte a 2002.0 +(byte~) protoBobShiftRight::$5 reg byte a 2002.0 +(byte~) protoBobShiftRight::$6 reg byte a 2002.0 +(label) protoBobShiftRight::@1 +(label) protoBobShiftRight::@2 +(label) protoBobShiftRight::@3 +(label) protoBobShiftRight::@4 +(label) protoBobShiftRight::@5 +(label) protoBobShiftRight::@6 +(label) protoBobShiftRight::@7 +(label) protoBobShiftRight::@return +(byte) protoBobShiftRight::carry +(byte) protoBobShiftRight::carry#1 carry zp[1]:14 111.22222222222223 +(byte) protoBobShiftRight::carry#10 reg byte y 2002.0 +(byte) protoBobShiftRight::carry#2 reg byte y 286.0 +(byte) protoBobShiftRight::i +(byte) protoBobShiftRight::i#1 i zp[1]:10 1001.0 +(byte) protoBobShiftRight::i#2 i zp[1]:10 231.0 +(byte) protoBobShiftRight::j +(byte) protoBobShiftRight::j#1 reg byte x 2002.0 +(byte) protoBobShiftRight::j#10 reg byte x 1001.0 +(byte) protoBobShiftRight::j#2 reg byte x 2002.0 +(byte) protoBobShiftRight::j#3 reg byte x 700.7 +(byte) protoBobShiftRight::new_carry +(void()) renderBob((byte) renderBob::xpos , (byte) renderBob::ypos) +(byte*~) renderBob::$2 zp[2]:11 4.0 +(byte~) renderBob::$4 reg byte a 4.0 +(byte~) renderBob::$5 zp[1]:13 2.0 +(byte~) renderBob::$6 reg byte a 4.0 +(byte~) renderBob::$8 reg byte a 4.0 +(label) renderBob::@return +(byte) renderBob::bob_table_idx +(byte) renderBob::bob_table_idx#0 reg byte x 1.8181818181818186 +(byte*) renderBob::screen +(byte*) renderBob::screen#0 screen zp[2]:11 1.4666666666666666 +(byte) renderBob::x_char_offset +(byte) renderBob::x_char_offset#0 x_char_offset zp[1]:10 0.8 +(byte) renderBob::xpos +(byte) renderBob::xpos#0 xpos zp[1]:14 10.499999999999998 +(byte) renderBob::y_char_offset +(byte) renderBob::y_char_offset#0 reg byte a 4.0 +(word) renderBob::y_offset +(word) renderBob::y_offset#0 y_offset zp[2]:11 4.0 +(byte) renderBob::ypos +(byte) renderBob::ypos#0 reg byte x 15.000000000000002 +(void()) renderBobCleanup() +(byte~) renderBobCleanup::$1 reg byte a 202.0 +(label) renderBobCleanup::@1 +(label) renderBobCleanup::@return +(byte) renderBobCleanup::i +(byte) renderBobCleanup::i#1 reg byte x 151.5 +(byte) renderBobCleanup::i#2 reg byte x 25.25 +(byte*) renderBobCleanup::screen +(byte*) renderBobCleanup::screen#0 screen zp[2]:15 112.22222222222223 +(byte**) renderBobCleanupNext +(byte**) renderBobCleanupNext#13 renderBobCleanupNext zp[2]:6 7.357142857142858 +(byte**) renderBobCleanupNext#17 renderBobCleanupNext zp[2]:6 3.3870967741935485 +(void()) renderBobInit() +(word~) renderBobInit::$0 zp[2]:15 16.5 +(word~) renderBobInit::$1 zp[2]:15 11.0 +(byte~) renderBobInit::$4 reg byte a 22.0 +(byte~) renderBobInit::$5 reg byte a 22.0 +(word~) renderBobInit::$6 zp[2]:17 22.0 +(word~) renderBobInit::$7 zp[2]:15 22.0 +(label) renderBobInit::@1 +(label) renderBobInit::@2 +(label) renderBobInit::@return +(byte) renderBobInit::i +(byte) renderBobInit::i#1 reg byte x 16.5 +(byte) renderBobInit::i#2 reg byte x 11.0 +(byte) renderBobInit::y +(byte) renderBobInit::y#1 reg byte x 16.5 +(byte) renderBobInit::y#2 reg byte x 4.714285714285714 + +reg byte a [ mulf8s::mulf8s_prepare1_a#0 mulf8s::a#1 mulf8s::a#0 ] +reg byte x [ mulf8s::b#2 mulf8s::b#1 mulf8s::b#0 ] +reg byte x [ renderBobCleanup::i#2 renderBobCleanup::i#1 ] +reg byte x [ renderBobInit::y#2 renderBobInit::y#1 ] +reg byte x [ renderBobInit::i#2 renderBobInit::i#1 ] +zp[1]:2 [ prepareBobs::shift_y#2 prepareBobs::shift_y#1 main::angle#8 main::angle#1 ] +zp[1]:3 [ progress_idx#16 progress_idx#31 progress_idx#25 progress_idx#10 progress_idx#8 main::r#2 main::r#1 ] +zp[1]:4 [ prepareBobs::bob_table_idx#6 prepareBobs::bob_table_idx#12 prepareBobs::bob_table_idx#1 main::a#2 main::a#6 main::a#1 ] +zp[1]:5 [ prepareBobs::shift_x#2 prepareBobs::shift_x#1 main::i#2 main::i#1 ] +reg byte x [ charsetFindOrAddGlyph::glyph_id#11 charsetFindOrAddGlyph::glyph_id#1 ] +reg byte y [ charsetFindOrAddGlyph::i1#2 charsetFindOrAddGlyph::i1#1 ] +reg byte y [ charsetFindOrAddGlyph::i#2 charsetFindOrAddGlyph::i#1 ] +reg byte a [ charsetFindOrAddGlyph::found#2 ] +reg byte x [ protoBobShiftRight::j#3 protoBobShiftRight::j#10 protoBobShiftRight::j#2 protoBobShiftRight::j#1 ] +reg byte y [ protoBobShiftRight::carry#2 protoBobShiftRight::carry#10 ] +reg byte x [ protoBobShiftDown::i#2 protoBobShiftDown::i#1 ] +zp[2]:6 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_lo#1 prepareBobs::bob_glyph#2 prepareBobs::bob_glyph#1 charsetFindOrAddGlyph::glyph#10 charsetFindOrAddGlyph::glyph#1 memset::dst#2 memset::dst#1 renderBobCleanupNext#17 renderBobCleanupNext#13 ] +reg byte x [ mulf_init::x_2#3 mulf_init::x_2#2 mulf_init::x_2#1 ] +reg byte x [ mulf_init::x_255#2 mulf_init::x_255#1 ] +zp[2]:8 [ main::x#0 mulf_init::sqr2_hi#2 mulf_init::sqr2_hi#1 ] +reg byte x [ renderBob::ypos#0 ] +reg byte a [ keyboard_key_pressed::return#2 ] +reg byte a [ main::$19 ] +reg byte a [ keyboard_key_pressed::return#3 ] +reg byte a [ main::$21 ] +reg byte a [ keyboard_matrix_read::return#2 ] +reg byte a [ keyboard_key_pressed::$2 ] +reg byte a [ keyboard_key_pressed::return#0 ] +reg byte a [ keyboard_matrix_read::return#0 ] +zp[1]:10 [ renderBob::x_char_offset#0 protoBobShiftRight::i#2 protoBobShiftRight::i#1 prepareBobs::cell#2 prepareBobs::cell#1 ] +reg byte a [ renderBob::y_char_offset#0 ] +reg byte a [ renderBob::$8 ] +zp[2]:11 [ renderBob::y_offset#0 renderBob::$2 renderBob::screen#0 mulf_init::sqr#3 mulf_init::sqr#4 mulf_init::sqr#1 mulf_init::sqr#2 progress_cursor#15 progress_cursor#31 progress_cursor#24 progress_cursor#17 progress_cursor#8 mulf8s_prepared::m#4 mulf8s_prepared::m#5 mulf8s_prepared::m#1 mulf8s_prepared::m#0 mulf8s_prepared::m#2 mulf8s::return#0 mulf8u_prepared::return#2 mulf8s::return#2 main::$10 mulf8s::return#3 main::$12 mulf8u_prepared::return#0 main::$13 main::y#0 ] +reg byte a [ renderBob::$4 ] +zp[1]:13 [ renderBob::$5 mulf_init::c#2 mulf_init::c#1 bob_charset_next_id#23 bob_charset_next_id#14 bob_charset_next_id#16 bob_charset_next_id#30 bob_charset_next_id#21 bob_charset_next_id#8 ] +reg byte a [ renderBob::$6 ] +reg byte x [ renderBob::bob_table_idx#0 ] +reg byte a [ mulf8u_prepare::a#0 ] +zp[1]:14 [ mulf8s_prepared::b#0 renderBob::xpos#0 mulf_init::dir#2 mulf_init::dir#4 protoBobShiftRight::carry#1 ] +reg byte a [ mulf8u_prepared::b#0 ] +reg byte a [ mulf8s_prepared::$8 ] +reg byte a [ mulf8s_prepared::$15 ] +reg byte a [ mulf8s_prepared::$12 ] +reg byte a [ mulf8s_prepared::$16 ] +reg byte a [ renderBobCleanup::$1 ] +zp[2]:15 [ renderBobInit::$0 renderBobInit::$7 renderBobInit::$1 renderBobCleanup::screen#0 mulf_init::sqr1_hi#2 mulf_init::sqr1_hi#1 prepareBobs::bob_table#2 prepareBobs::bob_table#1 prepareBobs::bob_table#0 ] +zp[2]:17 [ renderBobInit::$6 mulf_init::sqr2_lo#2 mulf_init::sqr2_lo#1 charsetFindOrAddGlyph::glyph_cursor#11 charsetFindOrAddGlyph::glyph_cursor#1 ] +reg byte a [ renderBobInit::$4 ] +reg byte a [ renderBobInit::$5 ] +reg byte a [ charsetFindOrAddGlyph::return#1 ] +reg byte a [ prepareBobs::$6 ] +reg byte a [ protoBobShiftRight::$1 ] +reg byte a [ protoBobShiftRight::$5 ] +reg byte a [ protoBobShiftRight::$6 ] +reg byte a [ mulf_init::$1 ] +reg byte a [ mulf_init::$4 ] +reg byte a [ mulf_init::$5 ] diff --git a/src/test/ref/complex/prebob/vogel-bobs.asm b/src/test/ref/complex/prebob/vogel-bobs.asm index 31204db13..20b9f3590 100644 --- a/src/test/ref/complex/prebob/vogel-bobs.asm +++ b/src/test/ref/complex/prebob/vogel-bobs.asm @@ -33,28 +33,24 @@ .const SIZEOF_POINTER = 2 .label COS = SIN+$40 // BOB charset ID of the next glyph to be added - .label bob_charset_next_id = $f + .label bob_charset_next_id = $d // Current index within the progress cursor (0-7) .label progress_idx = 3 // Current position of the progress cursor - .label progress_cursor = $c + .label progress_cursor = $b // Pointer to the next clean-up to add // Prepare for next clean-up .label renderBobCleanupNext = 6 - // Constants for KickAsm Vogel Sunflower - .const PHI = (1+sqrt(5))/2 - - main: { .const vicSelectGfxBank1_toDd001_return = 3 .const vicSelectGfxBank2_toDd001_return = 3 .const toD0181_return = (>(BOB_SCREEN&$3fff)*4)|(>BOB_CHARSET)/4&$f .const toD0182_return = (>(SCREEN_BASIC&$3fff)*4)|(>CHARSET_BASIC)/4&$f - .label __10 = $c - .label __12 = $c - .label __13 = $c - .label x = 9 - .label y = $c + .label __10 = $b + .label __12 = $b + .label __13 = $b + .label x = 8 + .label y = $b .label a = 4 .label r = 3 .label i = 5 @@ -182,14 +178,14 @@ keyboard_matrix_read: { // Render a single BOB at a given x/y-position // X-position is 0-151. Each x-position is 2 pixels wide. // Y-position is 0-183. Each y-position is 1 pixel high. -// renderBob(byte zeropage($f) xpos, byte register(X) ypos) +// renderBob(byte zeropage($e) xpos, byte register(X) ypos) renderBob: { - .label __2 = $c - .label __5 = $e - .label xpos = $f - .label x_char_offset = $b - .label y_offset = $c - .label screen = $c + .label __2 = $b + .label __5 = $d + .label xpos = $e + .label x_char_offset = $a + .label y_offset = $b + .label screen = $b lda.z xpos lsr lsr @@ -273,7 +269,7 @@ renderBob: { // Fast multiply two signed bytes to a word result // mulf8s(signed byte register(A) a, signed byte register(X) b) mulf8s: { - .label return = $c + .label return = $b jsr mulf8u_prepare stx.z mulf8s_prepared.b jsr mulf8s_prepared @@ -281,11 +277,11 @@ mulf8s: { } // Calculate fast multiply with a prepared unsigned byte to a word result // The prepared number is set by calling mulf8s_prepare(byte a) -// mulf8s_prepared(signed byte zeropage($f) b) +// mulf8s_prepared(signed byte zeropage($e) b) mulf8s_prepared: { .label memA = $fd - .label m = $c - .label b = $f + .label m = $b + .label b = $e lda.z b jsr mulf8u_prepared lda memA @@ -312,7 +308,7 @@ mulf8s_prepared: { mulf8u_prepared: { .label resL = $fe .label memB = $ff - .label return = $c + .label return = $b sta memB tax sec @@ -346,7 +342,7 @@ mulf8u_prepare: { } // Clean Up the rendered BOB's renderBobCleanup: { - .label screen = $10 + .label screen = $f ldx #0 __b1: txa @@ -411,10 +407,10 @@ memset: { } // Initialize the tables used by renderBob() renderBobInit: { - .label __0 = $10 - .label __1 = $10 - .label __6 = $12 - .label __7 = $10 + .label __0 = $f + .label __1 = $f + .label __6 = $11 + .label __7 = $f ldx #0 __b1: txa @@ -469,11 +465,11 @@ renderBobInit: { // Creates the pre-shifted bobs into BOB_CHARSET and populates the BOB_TABLES // Modifies PROTO_BOB by shifting it around prepareBobs: { - .label bob_table = $10 + .label bob_table = $f .label shift_y = 2 // Populate charset and tables .label bob_glyph = 6 - .label cell = $b + .label cell = $a .label bob_table_idx = 4 .label shift_x = 5 jsr progress_init @@ -533,7 +529,7 @@ prepareBobs: { jmp __b2 __b6: jsr bobCharsetFindOrAddGlyph - lda.z bobCharsetFindOrAddGlyph.glyph_id + txa // Look for an existing char in BOB_CHARSET ldy #0 sta (bob_table),y @@ -588,18 +584,14 @@ progress_inc: { // bobCharsetFindOrAddGlyph(byte* zeropage(6) bob_glyph) bobCharsetFindOrAddGlyph: { .label bob_glyph = 6 - .label i = 8 - .label glyph_id = $e - .label glyph_cursor = $12 + .label glyph_cursor = $11 lda #BOB_CHARSET sta.z glyph_cursor+1 - lda #0 - sta.z glyph_id + ldx #0 __b1: - lda.z glyph_id - cmp.z bob_charset_next_id + cpx.z bob_charset_next_id bne b1 ldy #0 // Not found - add it @@ -614,22 +606,15 @@ bobCharsetFindOrAddGlyph: { iny jmp __b7 b1: - lda #0 - sta.z i + ldy #0 __b2: - lda.z i - cmp #8 + cpy #8 bcc __b3 lda #1 jmp __b5 __b3: - ldy.z i lda (glyph_cursor),y - tax - lda (bob_glyph),y - tay - sty.z $ff - cpx.z $ff + cmp (bob_glyph),y beq __b4 lda #0 __b5: @@ -637,7 +622,7 @@ bobCharsetFindOrAddGlyph: { beq __b6 rts __b6: - inc.z glyph_id + inx lda #8 clc adc.z glyph_cursor @@ -647,13 +632,13 @@ bobCharsetFindOrAddGlyph: { !: jmp __b1 __b4: - inc.z i + iny jmp __b2 } // Shift PROTO_BOB right one X pixel shiftProtoBobRight: { .label carry = $e - .label i = $b + .label i = $a ldy #0 ldx #0 txa @@ -724,17 +709,17 @@ progress_init: { // Initialize the mulf_sqr multiplication tables with f(x)=int(x*x/4) mulf_init: { // x/2 - .label c = $f + .label c = $d // Counter used for determining x%2==0 - .label sqr1_hi = $10 + .label sqr1_hi = $f // Fill mulf_sqr1 = f(x) = int(x*x/4): If f(x) = x*x/4 then f(x+1) = f(x) + x/2 + 1/4 - .label sqr = $c + .label sqr = $b .label sqr1_lo = 6 // Decrease or increase x_255 - initially we decrease - .label sqr2_hi = 9 - .label sqr2_lo = $12 + .label sqr2_hi = 8 + .label sqr2_lo = $11 //Start with g(0)=f(255) - .label dir = 8 + .label dir = $e ldx #0 lda # (signed word) main::x#0 - [41] (byte) renderBob::ypos#0 ← > (signed word) main::y#0 - [42] call renderBob + [33] (signed word~) main::$12 ← (signed word) mulf8s::return#3 + [34] (signed word~) main::$13 ← (signed word~) main::$12 << (byte) 1 + [35] (signed word) main::y#0 ← (signed word~) main::$13 + (signed word)(number) $5a*(number) $100 + [36] *((const byte*) BORDERCOL) ← (byte) 2 + [37] (byte) main::a#1 ← (byte) main::a#2 + (byte) $62 + [38] (signed byte) main::r#1 ← (signed byte) main::r#2 + (signed byte) 3 + [39] (byte) renderBob::xpos#0 ← > (signed word) main::x#0 + [40] (byte) renderBob::ypos#0 ← > (signed word) main::y#0 + [41] call renderBob to:main::@14 main::@14: scope:[main] from main::@13 - [43] (byte) main::i#1 ← ++ (byte) main::i#2 - [44] if((byte) main::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto main::@4 + [42] (byte) main::i#1 ← ++ (byte) main::i#2 + [43] if((byte) main::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto main::@4 to:main::@5 main::@5: scope:[main] from main::@14 - [45] (byte) main::angle#1 ← (byte) main::angle#8 + (byte) 3 - [46] *((const byte*) BORDERCOL) ← (byte) 0 - [47] call keyboard_key_pressed - [48] (byte) keyboard_key_pressed::return#2 ← (byte) keyboard_key_pressed::return#0 + [44] (byte) main::angle#1 ← (byte) main::angle#8 + (byte) 3 + [45] *((const byte*) BORDERCOL) ← (byte) 0 + [46] call keyboard_key_pressed + [47] (byte) keyboard_key_pressed::return#2 ← (byte) keyboard_key_pressed::return#0 to:main::@15 main::@15: scope:[main] from main::@5 - [49] (byte~) main::$19 ← (byte) keyboard_key_pressed::return#2 - [50] if((byte) 0!=(byte~) main::$19) goto main::@6 + [48] (byte~) main::$19 ← (byte) keyboard_key_pressed::return#2 + [49] if((byte) 0!=(byte~) main::$19) goto main::@6 to:main::@1 main::@6: scope:[main] from main::@15 main::@16 - [51] phi() - [52] call keyboard_key_pressed - [53] (byte) keyboard_key_pressed::return#3 ← (byte) keyboard_key_pressed::return#0 + [50] phi() + [51] call keyboard_key_pressed + [52] (byte) keyboard_key_pressed::return#3 ← (byte) keyboard_key_pressed::return#0 to:main::@16 main::@16: scope:[main] from main::@6 - [54] (byte~) main::$21 ← (byte) keyboard_key_pressed::return#3 - [55] if((byte) 0!=(byte~) main::$21) goto main::@6 + [53] (byte~) main::$21 ← (byte) keyboard_key_pressed::return#3 + [54] if((byte) 0!=(byte~) main::$21) goto main::@6 to:main::vicSelectGfxBank2 main::vicSelectGfxBank2: scope:[main] from main::@16 - [56] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 + [55] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 to:main::vicSelectGfxBank2_toDd001 main::vicSelectGfxBank2_toDd001: scope:[main] from main::vicSelectGfxBank2 - [57] phi() + [56] phi() to:main::vicSelectGfxBank2_@1 main::vicSelectGfxBank2_@1: scope:[main] from main::vicSelectGfxBank2_toDd001 - [58] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank2_toDd001_return#0 + [57] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank2_toDd001_return#0 to:main::toD0182 main::toD0182: scope:[main] from main::vicSelectGfxBank2_@1 - [59] phi() + [58] phi() to:main::@8 main::@8: scope:[main] from main::toD0182 - [60] *((const byte*) D018) ← (const byte) main::toD0182_return#0 + [59] *((const byte*) D018) ← (const byte) main::toD0182_return#0 to:main::@return main::@return: scope:[main] from main::@8 - [61] return + [60] return to:@return (byte()) keyboard_key_pressed((byte) keyboard_key_pressed::key) keyboard_key_pressed: scope:[keyboard_key_pressed] from main::@5 main::@6 - [62] phi() - [63] call keyboard_matrix_read - [64] (byte) keyboard_matrix_read::return#2 ← (byte) keyboard_matrix_read::return#0 + [61] phi() + [62] call keyboard_matrix_read + [63] (byte) keyboard_matrix_read::return#2 ← (byte) keyboard_matrix_read::return#0 to:keyboard_key_pressed::@1 keyboard_key_pressed::@1: scope:[keyboard_key_pressed] from keyboard_key_pressed - [65] (byte~) keyboard_key_pressed::$2 ← (byte) keyboard_matrix_read::return#2 - [66] (byte) keyboard_key_pressed::return#0 ← (byte~) keyboard_key_pressed::$2 & *((const byte*) keyboard_matrix_col_bitmask+(const byte) keyboard_key_pressed::colidx#0) + [64] (byte~) keyboard_key_pressed::$2 ← (byte) keyboard_matrix_read::return#2 + [65] (byte) keyboard_key_pressed::return#0 ← (byte~) keyboard_key_pressed::$2 & *((const byte*) keyboard_matrix_col_bitmask+(const byte) keyboard_key_pressed::colidx#0) to:keyboard_key_pressed::@return keyboard_key_pressed::@return: scope:[keyboard_key_pressed] from keyboard_key_pressed::@1 - [67] return + [66] return to:@return (byte()) keyboard_matrix_read((byte) keyboard_matrix_read::rowid) keyboard_matrix_read: scope:[keyboard_matrix_read] from keyboard_key_pressed - [68] *((const byte*) CIA1_PORT_A) ← *((const byte*) keyboard_matrix_row_bitmask+(const byte) keyboard_key_pressed::rowidx#0) - [69] (byte) keyboard_matrix_read::return#0 ← ~ *((const byte*) CIA1_PORT_B) + [67] *((const byte*) CIA1_PORT_A) ← *((const byte*) keyboard_matrix_row_bitmask+(const byte) keyboard_key_pressed::rowidx#0) + [68] (byte) keyboard_matrix_read::return#0 ← ~ *((const byte*) CIA1_PORT_B) to:keyboard_matrix_read::@return keyboard_matrix_read::@return: scope:[keyboard_matrix_read] from keyboard_matrix_read - [70] return + [69] return to:@return (void()) renderBob((byte) renderBob::xpos , (byte) renderBob::ypos) renderBob: scope:[renderBob] from main::@13 - [71] (byte) renderBob::x_char_offset#0 ← (byte) renderBob::xpos#0 >> (byte) 2 - [72] (byte) renderBob::y_char_offset#0 ← (byte) renderBob::ypos#0 >> (byte) 3 - [73] (byte~) renderBob::$8 ← (byte) renderBob::y_char_offset#0 << (byte) 1 - [74] (word) renderBob::y_offset#0 ← *((const word*) MUL40 + (byte~) renderBob::$8) - [75] (byte*~) renderBob::$2 ← (const byte*) BOB_SCREEN + (word) renderBob::y_offset#0 - [76] (byte*) renderBob::screen#0 ← (byte*~) renderBob::$2 + (byte) renderBob::x_char_offset#0 - [77] (byte~) renderBob::$4 ← (byte) renderBob::ypos#0 & (byte) 7 - [78] (byte~) renderBob::$5 ← (byte~) renderBob::$4 << (byte) 2 - [79] (byte~) renderBob::$6 ← (byte) renderBob::xpos#0 & (byte) 3 - [80] (byte) renderBob::bob_table_idx#0 ← (byte~) renderBob::$5 + (byte~) renderBob::$6 - [81] *((byte**) renderBobCleanupNext#17) ← (byte*) renderBob::screen#0 - [82] (byte**) renderBobCleanupNext#13 ← (byte**) renderBobCleanupNext#17 + (const byte) SIZEOF_POINTER - [83] *((byte*) renderBob::screen#0) ← *((const byte*) BOB_TABLES + (byte) renderBob::bob_table_idx#0) - [84] *((byte*) renderBob::screen#0 + (byte) $28) ← *((const byte*) BOB_TABLES+(byte) 1*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) - [85] *((byte*) renderBob::screen#0 + (byte) $50) ← *((const byte*) BOB_TABLES+(byte) 2*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) - [86] *((byte*) renderBob::screen#0 + (byte) 1) ← *((const byte*) BOB_TABLES+(byte) 3*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) - [87] *((byte*) renderBob::screen#0 + (byte) $29) ← *((const byte*) BOB_TABLES+(byte) 4*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) - [88] *((byte*) renderBob::screen#0 + (byte) $51) ← *((const byte*) BOB_TABLES+(byte) 5*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) - [89] *((byte*) renderBob::screen#0 + (byte) 2) ← *((const byte*) BOB_TABLES+(byte) 6*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) - [90] *((byte*) renderBob::screen#0 + (byte) $2a) ← *((const byte*) BOB_TABLES+(byte) 7*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) - [91] *((byte*) renderBob::screen#0 + (byte) $52) ← *((const byte*) BOB_TABLES+(byte) 8*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + [70] (byte) renderBob::x_char_offset#0 ← (byte) renderBob::xpos#0 >> (byte) 2 + [71] (byte) renderBob::y_char_offset#0 ← (byte) renderBob::ypos#0 >> (byte) 3 + [72] (byte~) renderBob::$8 ← (byte) renderBob::y_char_offset#0 << (byte) 1 + [73] (word) renderBob::y_offset#0 ← *((const word*) MUL40 + (byte~) renderBob::$8) + [74] (byte*~) renderBob::$2 ← (const byte*) BOB_SCREEN + (word) renderBob::y_offset#0 + [75] (byte*) renderBob::screen#0 ← (byte*~) renderBob::$2 + (byte) renderBob::x_char_offset#0 + [76] (byte~) renderBob::$4 ← (byte) renderBob::ypos#0 & (byte) 7 + [77] (byte~) renderBob::$5 ← (byte~) renderBob::$4 << (byte) 2 + [78] (byte~) renderBob::$6 ← (byte) renderBob::xpos#0 & (byte) 3 + [79] (byte) renderBob::bob_table_idx#0 ← (byte~) renderBob::$5 + (byte~) renderBob::$6 + [80] *((byte**) renderBobCleanupNext#17) ← (byte*) renderBob::screen#0 + [81] (byte**) renderBobCleanupNext#13 ← (byte**) renderBobCleanupNext#17 + (const byte) SIZEOF_POINTER + [82] *((byte*) renderBob::screen#0) ← *((const byte*) BOB_TABLES + (byte) renderBob::bob_table_idx#0) + [83] *((byte*) renderBob::screen#0 + (byte) $28) ← *((const byte*) BOB_TABLES+(byte) 1*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + [84] *((byte*) renderBob::screen#0 + (byte) $50) ← *((const byte*) BOB_TABLES+(byte) 2*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + [85] *((byte*) renderBob::screen#0 + (byte) 1) ← *((const byte*) BOB_TABLES+(byte) 3*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + [86] *((byte*) renderBob::screen#0 + (byte) $29) ← *((const byte*) BOB_TABLES+(byte) 4*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + [87] *((byte*) renderBob::screen#0 + (byte) $51) ← *((const byte*) BOB_TABLES+(byte) 5*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + [88] *((byte*) renderBob::screen#0 + (byte) 2) ← *((const byte*) BOB_TABLES+(byte) 6*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + [89] *((byte*) renderBob::screen#0 + (byte) $2a) ← *((const byte*) BOB_TABLES+(byte) 7*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + [90] *((byte*) renderBob::screen#0 + (byte) $52) ← *((const byte*) BOB_TABLES+(byte) 8*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) to:renderBob::@return renderBob::@return: scope:[renderBob] from renderBob - [92] return + [91] return to:@return (signed word()) mulf8s((signed byte) mulf8s::a , (signed byte) mulf8s::b) mulf8s: scope:[mulf8s] from main::@12 main::@4 - [93] (signed byte) mulf8s::b#2 ← phi( main::@12/(signed byte) mulf8s::b#1 main::@4/(signed byte) mulf8s::b#0 ) - [93] (signed byte) mulf8s::mulf8s_prepare1_a#0 ← phi( main::@12/(signed byte) mulf8s::a#1 main::@4/(signed byte) mulf8s::a#0 ) + [92] (signed byte) mulf8s::b#2 ← phi( main::@12/(signed byte) mulf8s::b#1 main::@4/(signed byte) mulf8s::b#0 ) + [92] (signed byte) mulf8s::mulf8s_prepare1_a#0 ← phi( main::@12/(signed byte) mulf8s::a#1 main::@4/(signed byte) mulf8s::a#0 ) to:mulf8s::mulf8s_prepare1 mulf8s::mulf8s_prepare1: scope:[mulf8s] from mulf8s - [94] (byte) mulf8u_prepare::a#0 ← (byte)(signed byte) mulf8s::mulf8s_prepare1_a#0 - [95] call mulf8u_prepare + [93] (byte) mulf8u_prepare::a#0 ← (byte)(signed byte) mulf8s::mulf8s_prepare1_a#0 + [94] call mulf8u_prepare to:mulf8s::@1 mulf8s::@1: scope:[mulf8s] from mulf8s::mulf8s_prepare1 - [96] (signed byte) mulf8s_prepared::b#0 ← (signed byte) mulf8s::b#2 - [97] call mulf8s_prepared + [95] (signed byte) mulf8s_prepared::b#0 ← (signed byte) mulf8s::b#2 + [96] call mulf8s_prepared to:mulf8s::@2 mulf8s::@2: scope:[mulf8s] from mulf8s::@1 - [98] (signed word) mulf8s::return#0 ← (signed word)(word) mulf8s_prepared::m#4 + [97] (signed word) mulf8s::return#0 ← (signed word)(word) mulf8s_prepared::m#4 to:mulf8s::@return mulf8s::@return: scope:[mulf8s] from mulf8s::@2 - [99] return + [98] return to:@return (signed word()) mulf8s_prepared((signed byte) mulf8s_prepared::b) mulf8s_prepared: scope:[mulf8s_prepared] from mulf8s::@1 - [100] (byte) mulf8u_prepared::b#0 ← (byte)(signed byte) mulf8s_prepared::b#0 - [101] call mulf8u_prepared - [102] (word) mulf8u_prepared::return#2 ← (word) mulf8u_prepared::return#0 + [99] (byte) mulf8u_prepared::b#0 ← (byte)(signed byte) mulf8s_prepared::b#0 + [100] call mulf8u_prepared + [101] (word) mulf8u_prepared::return#2 ← (word) mulf8u_prepared::return#0 to:mulf8s_prepared::@5 mulf8s_prepared::@5: scope:[mulf8s_prepared] from mulf8s_prepared - [103] (word) mulf8s_prepared::m#0 ← (word) mulf8u_prepared::return#2 - [104] if(*((const signed byte*) mulf8s_prepared::memA)>=(signed byte) 0) goto mulf8s_prepared::@1 + [102] (word) mulf8s_prepared::m#0 ← (word) mulf8u_prepared::return#2 + [103] if(*((const signed byte*) mulf8s_prepared::memA)>=(signed byte) 0) goto mulf8s_prepared::@1 to:mulf8s_prepared::@3 mulf8s_prepared::@3: scope:[mulf8s_prepared] from mulf8s_prepared::@5 - [105] (byte~) mulf8s_prepared::$8 ← > (word) mulf8s_prepared::m#0 - [106] (byte~) mulf8s_prepared::$15 ← (byte~) mulf8s_prepared::$8 - (byte)(signed byte) mulf8s_prepared::b#0 - [107] (word) mulf8s_prepared::m#1 ← (word) mulf8s_prepared::m#0 hi= (byte~) mulf8s_prepared::$15 + [104] (byte~) mulf8s_prepared::$8 ← > (word) mulf8s_prepared::m#0 + [105] (byte~) mulf8s_prepared::$15 ← (byte~) mulf8s_prepared::$8 - (byte)(signed byte) mulf8s_prepared::b#0 + [106] (word) mulf8s_prepared::m#1 ← (word) mulf8s_prepared::m#0 hi= (byte~) mulf8s_prepared::$15 to:mulf8s_prepared::@1 mulf8s_prepared::@1: scope:[mulf8s_prepared] from mulf8s_prepared::@3 mulf8s_prepared::@5 - [108] (word) mulf8s_prepared::m#5 ← phi( mulf8s_prepared::@3/(word) mulf8s_prepared::m#1 mulf8s_prepared::@5/(word) mulf8s_prepared::m#0 ) - [109] if((signed byte) mulf8s_prepared::b#0>=(signed byte) 0) goto mulf8s_prepared::@2 + [107] (word) mulf8s_prepared::m#5 ← phi( mulf8s_prepared::@3/(word) mulf8s_prepared::m#1 mulf8s_prepared::@5/(word) mulf8s_prepared::m#0 ) + [108] if((signed byte) mulf8s_prepared::b#0>=(signed byte) 0) goto mulf8s_prepared::@2 to:mulf8s_prepared::@4 mulf8s_prepared::@4: scope:[mulf8s_prepared] from mulf8s_prepared::@1 - [110] (byte~) mulf8s_prepared::$12 ← > (word) mulf8s_prepared::m#5 - [111] (byte~) mulf8s_prepared::$16 ← (byte~) mulf8s_prepared::$12 - (byte)*((const signed byte*) mulf8s_prepared::memA) - [112] (word) mulf8s_prepared::m#2 ← (word) mulf8s_prepared::m#5 hi= (byte~) mulf8s_prepared::$16 + [109] (byte~) mulf8s_prepared::$12 ← > (word) mulf8s_prepared::m#5 + [110] (byte~) mulf8s_prepared::$16 ← (byte~) mulf8s_prepared::$12 - (byte)*((const signed byte*) mulf8s_prepared::memA) + [111] (word) mulf8s_prepared::m#2 ← (word) mulf8s_prepared::m#5 hi= (byte~) mulf8s_prepared::$16 to:mulf8s_prepared::@2 mulf8s_prepared::@2: scope:[mulf8s_prepared] from mulf8s_prepared::@1 mulf8s_prepared::@4 - [113] (word) mulf8s_prepared::m#4 ← phi( mulf8s_prepared::@1/(word) mulf8s_prepared::m#5 mulf8s_prepared::@4/(word) mulf8s_prepared::m#2 ) + [112] (word) mulf8s_prepared::m#4 ← phi( mulf8s_prepared::@1/(word) mulf8s_prepared::m#5 mulf8s_prepared::@4/(word) mulf8s_prepared::m#2 ) to:mulf8s_prepared::@return mulf8s_prepared::@return: scope:[mulf8s_prepared] from mulf8s_prepared::@2 - [114] return + [113] return to:@return (word()) mulf8u_prepared((byte) mulf8u_prepared::b) mulf8u_prepared: scope:[mulf8u_prepared] from mulf8s_prepared - [115] *((const byte*) mulf8u_prepared::memB) ← (byte) mulf8u_prepared::b#0 + [114] *((const byte*) mulf8u_prepared::memB) ← (byte) mulf8u_prepared::b#0 asm { ldxmemB sec sm1: ldamulf_sqr1_lo,x sm2: sbcmulf_sqr2_lo,x staresL sm3: ldamulf_sqr1_hi,x sm4: sbcmulf_sqr2_hi,x stamemB } - [117] (word) mulf8u_prepared::return#0 ← *((const byte*) mulf8u_prepared::memB) w= *((const byte*) mulf8u_prepared::resL) + [116] (word) mulf8u_prepared::return#0 ← *((const byte*) mulf8u_prepared::memB) w= *((const byte*) mulf8u_prepared::resL) to:mulf8u_prepared::@return mulf8u_prepared::@return: scope:[mulf8u_prepared] from mulf8u_prepared - [118] return + [117] return to:@return (void()) mulf8u_prepare((byte) mulf8u_prepare::a) mulf8u_prepare: scope:[mulf8u_prepare] from mulf8s::mulf8s_prepare1 - [119] *((const byte*) mulf8u_prepare::memA) ← (byte) mulf8u_prepare::a#0 + [118] *((const byte*) mulf8u_prepare::memA) ← (byte) mulf8u_prepare::a#0 asm { ldamemA stamulf8u_prepared.sm1+1 stamulf8u_prepared.sm3+1 eor#$ff stamulf8u_prepared.sm2+1 stamulf8u_prepared.sm4+1 } to:mulf8u_prepare::@return mulf8u_prepare::@return: scope:[mulf8u_prepare] from mulf8u_prepare - [121] return + [120] return to:@return (void()) renderBobCleanup() renderBobCleanup: scope:[renderBobCleanup] from main::@3 - [122] phi() + [121] phi() to:renderBobCleanup::@1 renderBobCleanup::@1: scope:[renderBobCleanup] from renderBobCleanup renderBobCleanup::@1 - [123] (byte) renderBobCleanup::i#2 ← phi( renderBobCleanup/(byte) 0 renderBobCleanup::@1/(byte) renderBobCleanup::i#1 ) - [124] (byte~) renderBobCleanup::$1 ← (byte) renderBobCleanup::i#2 << (byte) 1 - [125] (byte*) renderBobCleanup::screen#0 ← *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobCleanup::$1) - [126] *((byte*) renderBobCleanup::screen#0) ← (byte) 0 - [127] *((byte*) renderBobCleanup::screen#0 + (byte) $28) ← (byte) 0 - [128] *((byte*) renderBobCleanup::screen#0 + (byte) $50) ← (byte) 0 - [129] *((byte*) renderBobCleanup::screen#0 + (byte) 1) ← (byte) 0 - [130] *((byte*) renderBobCleanup::screen#0 + (byte) $29) ← (byte) 0 - [131] *((byte*) renderBobCleanup::screen#0 + (byte) $51) ← (byte) 0 - [132] *((byte*) renderBobCleanup::screen#0 + (byte) 2) ← (byte) 0 - [133] *((byte*) renderBobCleanup::screen#0 + (byte) $2a) ← (byte) 0 - [134] *((byte*) renderBobCleanup::screen#0 + (byte) $52) ← (byte) 0 - [135] (byte) renderBobCleanup::i#1 ← ++ (byte) renderBobCleanup::i#2 - [136] if((byte) renderBobCleanup::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto renderBobCleanup::@1 + [122] (byte) renderBobCleanup::i#2 ← phi( renderBobCleanup/(byte) 0 renderBobCleanup::@1/(byte) renderBobCleanup::i#1 ) + [123] (byte~) renderBobCleanup::$1 ← (byte) renderBobCleanup::i#2 << (byte) 1 + [124] (byte*) renderBobCleanup::screen#0 ← *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobCleanup::$1) + [125] *((byte*) renderBobCleanup::screen#0) ← (byte) 0 + [126] *((byte*) renderBobCleanup::screen#0 + (byte) $28) ← (byte) 0 + [127] *((byte*) renderBobCleanup::screen#0 + (byte) $50) ← (byte) 0 + [128] *((byte*) renderBobCleanup::screen#0 + (byte) 1) ← (byte) 0 + [129] *((byte*) renderBobCleanup::screen#0 + (byte) $29) ← (byte) 0 + [130] *((byte*) renderBobCleanup::screen#0 + (byte) $51) ← (byte) 0 + [131] *((byte*) renderBobCleanup::screen#0 + (byte) 2) ← (byte) 0 + [132] *((byte*) renderBobCleanup::screen#0 + (byte) $2a) ← (byte) 0 + [133] *((byte*) renderBobCleanup::screen#0 + (byte) $52) ← (byte) 0 + [134] (byte) renderBobCleanup::i#1 ← ++ (byte) renderBobCleanup::i#2 + [135] if((byte) renderBobCleanup::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto renderBobCleanup::@1 to:renderBobCleanup::@return renderBobCleanup::@return: scope:[renderBobCleanup] from renderBobCleanup::@1 - [137] return + [136] return to:@return (void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num) memset: scope:[memset] from main::@7 - [138] phi() + [137] phi() to:memset::@1 memset::@1: scope:[memset] from memset memset::@2 - [139] (byte*) memset::dst#2 ← phi( memset/(byte*)(const void*) memset::str#0 memset::@2/(byte*) memset::dst#1 ) - [140] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 + [138] (byte*) memset::dst#2 ← phi( memset/(byte*)(const void*) memset::str#0 memset::@2/(byte*) memset::dst#1 ) + [139] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 to:memset::@return memset::@return: scope:[memset] from memset::@1 - [141] return + [140] return to:@return memset::@2: scope:[memset] from memset::@1 - [142] *((byte*) memset::dst#2) ← (const byte) memset::c#0 - [143] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2 + [141] *((byte*) memset::dst#2) ← (const byte) memset::c#0 + [142] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2 to:memset::@1 (void()) renderBobInit() renderBobInit: scope:[renderBobInit] from main::@10 - [144] phi() + [143] phi() to:renderBobInit::@1 renderBobInit::@1: scope:[renderBobInit] from renderBobInit renderBobInit::@1 - [145] (byte) renderBobInit::y#2 ← phi( renderBobInit/(byte) 0 renderBobInit::@1/(byte) renderBobInit::y#1 ) - [146] (word~) renderBobInit::$0 ← (word)(byte) renderBobInit::y#2 - [147] (word~) renderBobInit::$6 ← (word~) renderBobInit::$0 << (byte) 2 - [148] (word~) renderBobInit::$7 ← (word~) renderBobInit::$6 + (word~) renderBobInit::$0 - [149] (word~) renderBobInit::$1 ← (word~) renderBobInit::$7 << (byte) 3 - [150] (byte~) renderBobInit::$4 ← (byte) renderBobInit::y#2 << (byte) 1 - [151] *((const word*) MUL40 + (byte~) renderBobInit::$4) ← (word~) renderBobInit::$1 - [152] (byte) renderBobInit::y#1 ← ++ (byte) renderBobInit::y#2 - [153] if((byte) renderBobInit::y#1!=(byte) $20) goto renderBobInit::@1 + [144] (byte) renderBobInit::y#2 ← phi( renderBobInit/(byte) 0 renderBobInit::@1/(byte) renderBobInit::y#1 ) + [145] (word~) renderBobInit::$0 ← (word)(byte) renderBobInit::y#2 + [146] (word~) renderBobInit::$6 ← (word~) renderBobInit::$0 << (byte) 2 + [147] (word~) renderBobInit::$7 ← (word~) renderBobInit::$6 + (word~) renderBobInit::$0 + [148] (word~) renderBobInit::$1 ← (word~) renderBobInit::$7 << (byte) 3 + [149] (byte~) renderBobInit::$4 ← (byte) renderBobInit::y#2 << (byte) 1 + [150] *((const word*) MUL40 + (byte~) renderBobInit::$4) ← (word~) renderBobInit::$1 + [151] (byte) renderBobInit::y#1 ← ++ (byte) renderBobInit::y#2 + [152] if((byte) renderBobInit::y#1!=(byte) $20) goto renderBobInit::@1 to:renderBobInit::@2 renderBobInit::@2: scope:[renderBobInit] from renderBobInit::@1 renderBobInit::@2 - [154] (byte) renderBobInit::i#2 ← phi( renderBobInit::@1/(byte) 0 renderBobInit::@2/(byte) renderBobInit::i#1 ) - [155] (byte~) renderBobInit::$5 ← (byte) renderBobInit::i#2 << (byte) 1 - [156] *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobInit::$5) ← (const byte*) BOB_SCREEN - [157] (byte) renderBobInit::i#1 ← ++ (byte) renderBobInit::i#2 - [158] if((byte) renderBobInit::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto renderBobInit::@2 + [153] (byte) renderBobInit::i#2 ← phi( renderBobInit::@1/(byte) 0 renderBobInit::@2/(byte) renderBobInit::i#1 ) + [154] (byte~) renderBobInit::$5 ← (byte) renderBobInit::i#2 << (byte) 1 + [155] *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobInit::$5) ← (const byte*) BOB_SCREEN + [156] (byte) renderBobInit::i#1 ← ++ (byte) renderBobInit::i#2 + [157] if((byte) renderBobInit::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto renderBobInit::@2 to:renderBobInit::@return renderBobInit::@return: scope:[renderBobInit] from renderBobInit::@2 - [159] return + [158] return to:@return (void()) prepareBobs() prepareBobs: scope:[prepareBobs] from main::@9 - [160] phi() - [161] call progress_init + [159] phi() + [160] call progress_init to:prepareBobs::@8 prepareBobs::@8: scope:[prepareBobs] from prepareBobs - [162] phi() - [163] call bobCharsetFindOrAddGlyph + [161] phi() + [162] call bobCharsetFindOrAddGlyph to:prepareBobs::@1 prepareBobs::@1: scope:[prepareBobs] from prepareBobs::@8 prepareBobs::@9 - [164] (byte) prepareBobs::bob_table_idx#6 ← phi( prepareBobs::@8/(byte) 0 prepareBobs::@9/(byte) prepareBobs::bob_table_idx#12 ) - [164] (byte) bob_charset_next_id#14 ← phi( prepareBobs::@8/(byte) bob_charset_next_id#16 prepareBobs::@9/(byte) bob_charset_next_id#30 ) - [164] (byte) progress_idx#16 ← phi( prepareBobs::@8/(byte) 0 prepareBobs::@9/(byte) progress_idx#31 ) - [164] (byte*) progress_cursor#15 ← phi( prepareBobs::@8/(const byte*) SCREEN_BASIC prepareBobs::@9/(byte*) progress_cursor#31 ) - [164] (byte) prepareBobs::shift_y#2 ← phi( prepareBobs::@8/(byte) 0 prepareBobs::@9/(byte) prepareBobs::shift_y#1 ) - [165] if((byte) prepareBobs::shift_y#2<(const byte) BOB_SHIFTS_Y) goto prepareBobs::@2 + [163] (byte) prepareBobs::bob_table_idx#6 ← phi( prepareBobs::@8/(byte) 0 prepareBobs::@9/(byte) prepareBobs::bob_table_idx#12 ) + [163] (byte) bob_charset_next_id#14 ← phi( prepareBobs::@8/(byte) bob_charset_next_id#16 prepareBobs::@9/(byte) bob_charset_next_id#30 ) + [163] (byte) progress_idx#16 ← phi( prepareBobs::@8/(byte) 0 prepareBobs::@9/(byte) progress_idx#31 ) + [163] (byte*) progress_cursor#15 ← phi( prepareBobs::@8/(const byte*) SCREEN_BASIC prepareBobs::@9/(byte*) progress_cursor#31 ) + [163] (byte) prepareBobs::shift_y#2 ← phi( prepareBobs::@8/(byte) 0 prepareBobs::@9/(byte) prepareBobs::shift_y#1 ) + [164] if((byte) prepareBobs::shift_y#2<(const byte) BOB_SHIFTS_Y) goto prepareBobs::@2 to:prepareBobs::@return prepareBobs::@return: scope:[prepareBobs] from prepareBobs::@1 - [166] return + [165] return to:@return prepareBobs::@2: scope:[prepareBobs] from prepareBobs::@1 prepareBobs::@13 - [167] (byte) progress_idx#31 ← phi( prepareBobs::@1/(byte) progress_idx#16 prepareBobs::@13/(byte) progress_idx#25 ) - [167] (byte*) progress_cursor#31 ← phi( prepareBobs::@1/(byte*) progress_cursor#15 prepareBobs::@13/(byte*) progress_cursor#24 ) - [167] (byte) bob_charset_next_id#30 ← phi( prepareBobs::@1/(byte) bob_charset_next_id#14 prepareBobs::@13/(byte) bob_charset_next_id#21 ) - [167] (byte) prepareBobs::bob_table_idx#12 ← phi( prepareBobs::@1/(byte) prepareBobs::bob_table_idx#6 prepareBobs::@13/(byte) prepareBobs::bob_table_idx#1 ) - [167] (byte) prepareBobs::shift_x#2 ← phi( prepareBobs::@1/(byte) 0 prepareBobs::@13/(byte) prepareBobs::shift_x#1 ) - [168] if((byte) prepareBobs::shift_x#2<(const byte) BOB_SHIFTS_X) goto prepareBobs::@3 + [166] (byte) progress_idx#31 ← phi( prepareBobs::@1/(byte) progress_idx#16 prepareBobs::@13/(byte) progress_idx#25 ) + [166] (byte*) progress_cursor#31 ← phi( prepareBobs::@1/(byte*) progress_cursor#15 prepareBobs::@13/(byte*) progress_cursor#24 ) + [166] (byte) bob_charset_next_id#30 ← phi( prepareBobs::@1/(byte) bob_charset_next_id#14 prepareBobs::@13/(byte) bob_charset_next_id#21 ) + [166] (byte) prepareBobs::bob_table_idx#12 ← phi( prepareBobs::@1/(byte) prepareBobs::bob_table_idx#6 prepareBobs::@13/(byte) prepareBobs::bob_table_idx#1 ) + [166] (byte) prepareBobs::shift_x#2 ← phi( prepareBobs::@1/(byte) 0 prepareBobs::@13/(byte) prepareBobs::shift_x#1 ) + [167] if((byte) prepareBobs::shift_x#2<(const byte) BOB_SHIFTS_X) goto prepareBobs::@3 to:prepareBobs::@4 prepareBobs::@4: scope:[prepareBobs] from prepareBobs::@2 - [169] phi() - [170] call shiftProtoBobDown + [168] phi() + [169] call shiftProtoBobDown to:prepareBobs::@9 prepareBobs::@9: scope:[prepareBobs] from prepareBobs::@4 - [171] (byte) prepareBobs::shift_y#1 ← ++ (byte) prepareBobs::shift_y#2 + [170] (byte) prepareBobs::shift_y#1 ← ++ (byte) prepareBobs::shift_y#2 to:prepareBobs::@1 prepareBobs::@3: scope:[prepareBobs] from prepareBobs::@2 - [172] (byte*) prepareBobs::bob_table#0 ← (const byte*) BOB_TABLES + (byte) prepareBobs::bob_table_idx#12 + [171] (byte*) prepareBobs::bob_table#0 ← (const byte*) BOB_TABLES + (byte) prepareBobs::bob_table_idx#12 to:prepareBobs::@5 prepareBobs::@5: scope:[prepareBobs] from prepareBobs::@11 prepareBobs::@3 - [173] (byte*) progress_cursor#24 ← phi( prepareBobs::@11/(byte*) progress_cursor#17 prepareBobs::@3/(byte*) progress_cursor#31 ) - [173] (byte) progress_idx#25 ← phi( prepareBobs::@11/(byte) progress_idx#10 prepareBobs::@3/(byte) progress_idx#31 ) - [173] (byte*) prepareBobs::bob_table#2 ← phi( prepareBobs::@11/(byte*) prepareBobs::bob_table#1 prepareBobs::@3/(byte*) prepareBobs::bob_table#0 ) - [173] (byte) bob_charset_next_id#21 ← phi( prepareBobs::@11/(byte) bob_charset_next_id#16 prepareBobs::@3/(byte) bob_charset_next_id#30 ) - [173] (byte*) prepareBobs::bob_glyph#2 ← phi( prepareBobs::@11/(byte*) prepareBobs::bob_glyph#1 prepareBobs::@3/(const byte*) PROTO_BOB ) - [173] (byte) prepareBobs::cell#2 ← phi( prepareBobs::@11/(byte) prepareBobs::cell#1 prepareBobs::@3/(byte) 0 ) - [174] if((byte) prepareBobs::cell#2<(byte) 9) goto prepareBobs::@6 + [172] (byte*) progress_cursor#24 ← phi( prepareBobs::@11/(byte*) progress_cursor#17 prepareBobs::@3/(byte*) progress_cursor#31 ) + [172] (byte) progress_idx#25 ← phi( prepareBobs::@11/(byte) progress_idx#10 prepareBobs::@3/(byte) progress_idx#31 ) + [172] (byte*) prepareBobs::bob_table#2 ← phi( prepareBobs::@11/(byte*) prepareBobs::bob_table#1 prepareBobs::@3/(byte*) prepareBobs::bob_table#0 ) + [172] (byte) bob_charset_next_id#21 ← phi( prepareBobs::@11/(byte) bob_charset_next_id#16 prepareBobs::@3/(byte) bob_charset_next_id#30 ) + [172] (byte*) prepareBobs::bob_glyph#2 ← phi( prepareBobs::@11/(byte*) prepareBobs::bob_glyph#1 prepareBobs::@3/(const byte*) PROTO_BOB ) + [172] (byte) prepareBobs::cell#2 ← phi( prepareBobs::@11/(byte) prepareBobs::cell#1 prepareBobs::@3/(byte) 0 ) + [173] if((byte) prepareBobs::cell#2<(byte) 9) goto prepareBobs::@6 to:prepareBobs::@7 prepareBobs::@7: scope:[prepareBobs] from prepareBobs::@5 - [175] (byte) prepareBobs::bob_table_idx#1 ← ++ (byte) prepareBobs::bob_table_idx#12 - [176] call shiftProtoBobRight + [174] (byte) prepareBobs::bob_table_idx#1 ← ++ (byte) prepareBobs::bob_table_idx#12 + [175] call shiftProtoBobRight to:prepareBobs::@12 prepareBobs::@12: scope:[prepareBobs] from prepareBobs::@7 - [177] phi() - [178] call shiftProtoBobRight + [176] phi() + [177] call shiftProtoBobRight to:prepareBobs::@13 prepareBobs::@13: scope:[prepareBobs] from prepareBobs::@12 - [179] (byte) prepareBobs::shift_x#1 ← ++ (byte) prepareBobs::shift_x#2 + [178] (byte) prepareBobs::shift_x#1 ← ++ (byte) prepareBobs::shift_x#2 to:prepareBobs::@2 prepareBobs::@6: scope:[prepareBobs] from prepareBobs::@5 - [180] (byte*) bobCharsetFindOrAddGlyph::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 - [181] call bobCharsetFindOrAddGlyph - [182] (byte) bobCharsetFindOrAddGlyph::return#1 ← (byte) bobCharsetFindOrAddGlyph::glyph_id#11 + [179] (byte*) bobCharsetFindOrAddGlyph::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 + [180] call bobCharsetFindOrAddGlyph + [181] (byte) bobCharsetFindOrAddGlyph::return#1 ← (byte) bobCharsetFindOrAddGlyph::glyph_id#11 to:prepareBobs::@10 prepareBobs::@10: scope:[prepareBobs] from prepareBobs::@6 - [183] (byte~) prepareBobs::$6 ← (byte) bobCharsetFindOrAddGlyph::return#1 - [184] *((byte*) prepareBobs::bob_table#2) ← (byte~) prepareBobs::$6 - [185] (byte*) prepareBobs::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 + (byte) 8 - [186] (byte*) prepareBobs::bob_table#1 ← (byte*) prepareBobs::bob_table#2 + (const byte) BOB_SHIFTS_X*(const byte) BOB_SHIFTS_Y - [187] call progress_inc + [182] (byte~) prepareBobs::$6 ← (byte) bobCharsetFindOrAddGlyph::return#1 + [183] *((byte*) prepareBobs::bob_table#2) ← (byte~) prepareBobs::$6 + [184] (byte*) prepareBobs::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 + (byte) 8 + [185] (byte*) prepareBobs::bob_table#1 ← (byte*) prepareBobs::bob_table#2 + (const byte) BOB_SHIFTS_X*(const byte) BOB_SHIFTS_Y + [186] call progress_inc to:prepareBobs::@11 prepareBobs::@11: scope:[prepareBobs] from prepareBobs::@10 - [188] (byte) prepareBobs::cell#1 ← ++ (byte) prepareBobs::cell#2 + [187] (byte) prepareBobs::cell#1 ← ++ (byte) prepareBobs::cell#2 to:prepareBobs::@5 (void()) progress_inc() progress_inc: scope:[progress_inc] from prepareBobs::@10 - [189] (byte) progress_idx#8 ← ++ (byte) progress_idx#25 - [190] if((byte) progress_idx#8!=(byte) 8) goto progress_inc::@1 + [188] (byte) progress_idx#8 ← ++ (byte) progress_idx#25 + [189] if((byte) progress_idx#8!=(byte) 8) goto progress_inc::@1 to:progress_inc::@2 progress_inc::@2: scope:[progress_inc] from progress_inc - [191] *((byte*) progress_cursor#24) ← *((const byte*) progress_inc::progress_chars+(byte) 8) - [192] (byte*) progress_cursor#8 ← ++ (byte*) progress_cursor#24 + [190] *((byte*) progress_cursor#24) ← *((const byte*) progress_inc::progress_chars+(byte) 8) + [191] (byte*) progress_cursor#8 ← ++ (byte*) progress_cursor#24 to:progress_inc::@1 progress_inc::@1: scope:[progress_inc] from progress_inc progress_inc::@2 - [193] (byte*) progress_cursor#17 ← phi( progress_inc/(byte*) progress_cursor#24 progress_inc::@2/(byte*) progress_cursor#8 ) - [193] (byte) progress_idx#10 ← phi( progress_inc/(byte) progress_idx#8 progress_inc::@2/(byte) 0 ) - [194] *((byte*) progress_cursor#17) ← *((const byte*) progress_inc::progress_chars + (byte) progress_idx#10) + [192] (byte*) progress_cursor#17 ← phi( progress_inc/(byte*) progress_cursor#24 progress_inc::@2/(byte*) progress_cursor#8 ) + [192] (byte) progress_idx#10 ← phi( progress_inc/(byte) progress_idx#8 progress_inc::@2/(byte) 0 ) + [193] *((byte*) progress_cursor#17) ← *((const byte*) progress_inc::progress_chars + (byte) progress_idx#10) to:progress_inc::@return progress_inc::@return: scope:[progress_inc] from progress_inc::@1 - [195] return + [194] return to:@return (byte()) bobCharsetFindOrAddGlyph((byte*) bobCharsetFindOrAddGlyph::bob_glyph) bobCharsetFindOrAddGlyph: scope:[bobCharsetFindOrAddGlyph] from prepareBobs::@6 prepareBobs::@8 - [196] (byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 ← phi( prepareBobs::@8/(const byte*) PROTO_BOB+(byte) $30 prepareBobs::@6/(byte*) bobCharsetFindOrAddGlyph::bob_glyph#1 ) - [196] (byte) bob_charset_next_id#23 ← phi( prepareBobs::@8/(byte) 0 prepareBobs::@6/(byte) bob_charset_next_id#21 ) + [195] (byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 ← phi( prepareBobs::@8/(const byte*) PROTO_BOB+(byte) $30 prepareBobs::@6/(byte*) bobCharsetFindOrAddGlyph::bob_glyph#1 ) + [195] (byte) bob_charset_next_id#23 ← phi( prepareBobs::@8/(byte) 0 prepareBobs::@6/(byte) bob_charset_next_id#21 ) to:bobCharsetFindOrAddGlyph::@1 bobCharsetFindOrAddGlyph::@1: scope:[bobCharsetFindOrAddGlyph] from bobCharsetFindOrAddGlyph bobCharsetFindOrAddGlyph::@6 - [197] (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 ← phi( bobCharsetFindOrAddGlyph/(const byte*) BOB_CHARSET bobCharsetFindOrAddGlyph::@6/(byte*) bobCharsetFindOrAddGlyph::glyph_cursor#1 ) - [197] (byte) bobCharsetFindOrAddGlyph::glyph_id#11 ← phi( bobCharsetFindOrAddGlyph/(byte) 0 bobCharsetFindOrAddGlyph::@6/(byte) bobCharsetFindOrAddGlyph::glyph_id#1 ) - [198] if((byte) bobCharsetFindOrAddGlyph::glyph_id#11!=(byte) bob_charset_next_id#23) goto bobCharsetFindOrAddGlyph::@2 + [196] (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 ← phi( bobCharsetFindOrAddGlyph/(const byte*) BOB_CHARSET bobCharsetFindOrAddGlyph::@6/(byte*) bobCharsetFindOrAddGlyph::glyph_cursor#1 ) + [196] (byte) bobCharsetFindOrAddGlyph::glyph_id#11 ← phi( bobCharsetFindOrAddGlyph/(byte) 0 bobCharsetFindOrAddGlyph::@6/(byte) bobCharsetFindOrAddGlyph::glyph_id#1 ) + [197] if((byte) bobCharsetFindOrAddGlyph::glyph_id#11!=(byte) bob_charset_next_id#23) goto bobCharsetFindOrAddGlyph::@2 to:bobCharsetFindOrAddGlyph::@7 bobCharsetFindOrAddGlyph::@7: scope:[bobCharsetFindOrAddGlyph] from bobCharsetFindOrAddGlyph::@1 bobCharsetFindOrAddGlyph::@8 - [199] (byte) bobCharsetFindOrAddGlyph::i1#2 ← phi( bobCharsetFindOrAddGlyph::@8/(byte) bobCharsetFindOrAddGlyph::i1#1 bobCharsetFindOrAddGlyph::@1/(byte) 0 ) - [200] if((byte) bobCharsetFindOrAddGlyph::i1#2<(byte) 8) goto bobCharsetFindOrAddGlyph::@8 + [198] (byte) bobCharsetFindOrAddGlyph::i1#2 ← phi( bobCharsetFindOrAddGlyph::@8/(byte) bobCharsetFindOrAddGlyph::i1#1 bobCharsetFindOrAddGlyph::@1/(byte) 0 ) + [199] if((byte) bobCharsetFindOrAddGlyph::i1#2<(byte) 8) goto bobCharsetFindOrAddGlyph::@8 to:bobCharsetFindOrAddGlyph::@9 bobCharsetFindOrAddGlyph::@9: scope:[bobCharsetFindOrAddGlyph] from bobCharsetFindOrAddGlyph::@7 - [201] (byte) bob_charset_next_id#8 ← ++ (byte) bob_charset_next_id#23 + [200] (byte) bob_charset_next_id#8 ← ++ (byte) bob_charset_next_id#23 to:bobCharsetFindOrAddGlyph::@return bobCharsetFindOrAddGlyph::@return: scope:[bobCharsetFindOrAddGlyph] from bobCharsetFindOrAddGlyph::@5 bobCharsetFindOrAddGlyph::@9 - [202] (byte) bob_charset_next_id#16 ← phi( bobCharsetFindOrAddGlyph::@5/(byte) bob_charset_next_id#23 bobCharsetFindOrAddGlyph::@9/(byte) bob_charset_next_id#8 ) - [203] return + [201] (byte) bob_charset_next_id#16 ← phi( bobCharsetFindOrAddGlyph::@5/(byte) bob_charset_next_id#23 bobCharsetFindOrAddGlyph::@9/(byte) bob_charset_next_id#8 ) + [202] return to:@return bobCharsetFindOrAddGlyph::@8: scope:[bobCharsetFindOrAddGlyph] from bobCharsetFindOrAddGlyph::@7 - [204] *((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) bobCharsetFindOrAddGlyph::i1#2) ← *((byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 + (byte) bobCharsetFindOrAddGlyph::i1#2) - [205] (byte) bobCharsetFindOrAddGlyph::i1#1 ← ++ (byte) bobCharsetFindOrAddGlyph::i1#2 + [203] *((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) bobCharsetFindOrAddGlyph::i1#2) ← *((byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 + (byte) bobCharsetFindOrAddGlyph::i1#2) + [204] (byte) bobCharsetFindOrAddGlyph::i1#1 ← ++ (byte) bobCharsetFindOrAddGlyph::i1#2 to:bobCharsetFindOrAddGlyph::@7 bobCharsetFindOrAddGlyph::@2: scope:[bobCharsetFindOrAddGlyph] from bobCharsetFindOrAddGlyph::@1 bobCharsetFindOrAddGlyph::@4 - [206] (byte) bobCharsetFindOrAddGlyph::i#2 ← phi( bobCharsetFindOrAddGlyph::@1/(byte) 0 bobCharsetFindOrAddGlyph::@4/(byte) bobCharsetFindOrAddGlyph::i#1 ) - [207] if((byte) bobCharsetFindOrAddGlyph::i#2<(byte) 8) goto bobCharsetFindOrAddGlyph::@3 + [205] (byte) bobCharsetFindOrAddGlyph::i#2 ← phi( bobCharsetFindOrAddGlyph::@1/(byte) 0 bobCharsetFindOrAddGlyph::@4/(byte) bobCharsetFindOrAddGlyph::i#1 ) + [206] if((byte) bobCharsetFindOrAddGlyph::i#2<(byte) 8) goto bobCharsetFindOrAddGlyph::@3 to:bobCharsetFindOrAddGlyph::@5 bobCharsetFindOrAddGlyph::@3: scope:[bobCharsetFindOrAddGlyph] from bobCharsetFindOrAddGlyph::@2 - [208] if(*((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) bobCharsetFindOrAddGlyph::i#2)==*((byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 + (byte) bobCharsetFindOrAddGlyph::i#2)) goto bobCharsetFindOrAddGlyph::@4 + [207] if(*((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) bobCharsetFindOrAddGlyph::i#2)==*((byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 + (byte) bobCharsetFindOrAddGlyph::i#2)) goto bobCharsetFindOrAddGlyph::@4 to:bobCharsetFindOrAddGlyph::@5 bobCharsetFindOrAddGlyph::@5: scope:[bobCharsetFindOrAddGlyph] from bobCharsetFindOrAddGlyph::@2 bobCharsetFindOrAddGlyph::@3 - [209] (byte) bobCharsetFindOrAddGlyph::found#2 ← phi( bobCharsetFindOrAddGlyph::@3/(byte) 0 bobCharsetFindOrAddGlyph::@2/(byte) 1 ) - [210] if((byte) 0==(byte) bobCharsetFindOrAddGlyph::found#2) goto bobCharsetFindOrAddGlyph::@6 + [208] (byte) bobCharsetFindOrAddGlyph::found#2 ← phi( bobCharsetFindOrAddGlyph::@3/(byte) 0 bobCharsetFindOrAddGlyph::@2/(byte) 1 ) + [209] if((byte) 0==(byte) bobCharsetFindOrAddGlyph::found#2) goto bobCharsetFindOrAddGlyph::@6 to:bobCharsetFindOrAddGlyph::@return bobCharsetFindOrAddGlyph::@6: scope:[bobCharsetFindOrAddGlyph] from bobCharsetFindOrAddGlyph::@5 - [211] (byte) bobCharsetFindOrAddGlyph::glyph_id#1 ← ++ (byte) bobCharsetFindOrAddGlyph::glyph_id#11 - [212] (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#1 ← (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) 8 + [210] (byte) bobCharsetFindOrAddGlyph::glyph_id#1 ← ++ (byte) bobCharsetFindOrAddGlyph::glyph_id#11 + [211] (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#1 ← (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) 8 to:bobCharsetFindOrAddGlyph::@1 bobCharsetFindOrAddGlyph::@4: scope:[bobCharsetFindOrAddGlyph] from bobCharsetFindOrAddGlyph::@3 - [213] (byte) bobCharsetFindOrAddGlyph::i#1 ← ++ (byte) bobCharsetFindOrAddGlyph::i#2 + [212] (byte) bobCharsetFindOrAddGlyph::i#1 ← ++ (byte) bobCharsetFindOrAddGlyph::i#2 to:bobCharsetFindOrAddGlyph::@2 (void()) shiftProtoBobRight() shiftProtoBobRight: scope:[shiftProtoBobRight] from prepareBobs::@12 prepareBobs::@7 - [214] phi() + [213] phi() to:shiftProtoBobRight::@1 shiftProtoBobRight::@1: scope:[shiftProtoBobRight] from shiftProtoBobRight shiftProtoBobRight::@6 - [215] (byte) shiftProtoBobRight::carry#2 ← phi( shiftProtoBobRight/(byte) 0 shiftProtoBobRight::@6/(byte) shiftProtoBobRight::carry#10 ) - [215] (byte) shiftProtoBobRight::j#3 ← phi( shiftProtoBobRight/(byte) 0 shiftProtoBobRight::@6/(byte) shiftProtoBobRight::j#10 ) - [215] (byte) shiftProtoBobRight::i#2 ← phi( shiftProtoBobRight/(byte) 0 shiftProtoBobRight::@6/(byte) shiftProtoBobRight::i#1 ) - [216] if((byte) shiftProtoBobRight::i#2<(byte)(number) 3*(number) 3*(number) 8) goto shiftProtoBobRight::@2 + [214] (byte) shiftProtoBobRight::carry#2 ← phi( shiftProtoBobRight/(byte) 0 shiftProtoBobRight::@6/(byte) shiftProtoBobRight::carry#10 ) + [214] (byte) shiftProtoBobRight::j#3 ← phi( shiftProtoBobRight/(byte) 0 shiftProtoBobRight::@6/(byte) shiftProtoBobRight::j#10 ) + [214] (byte) shiftProtoBobRight::i#2 ← phi( shiftProtoBobRight/(byte) 0 shiftProtoBobRight::@6/(byte) shiftProtoBobRight::i#1 ) + [215] if((byte) shiftProtoBobRight::i#2<(byte)(number) 3*(number) 3*(number) 8) goto shiftProtoBobRight::@2 to:shiftProtoBobRight::@return shiftProtoBobRight::@return: scope:[shiftProtoBobRight] from shiftProtoBobRight::@1 - [217] return + [216] return to:@return shiftProtoBobRight::@2: scope:[shiftProtoBobRight] from shiftProtoBobRight::@1 - [218] (byte~) shiftProtoBobRight::$1 ← *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) & (byte) 1 - [219] if((byte) 0!=(byte~) shiftProtoBobRight::$1) goto shiftProtoBobRight::@3 + [217] (byte~) shiftProtoBobRight::$1 ← *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) & (byte) 1 + [218] if((byte) 0!=(byte~) shiftProtoBobRight::$1) goto shiftProtoBobRight::@3 to:shiftProtoBobRight::@4 shiftProtoBobRight::@3: scope:[shiftProtoBobRight] from shiftProtoBobRight::@2 - [220] phi() + [219] phi() to:shiftProtoBobRight::@4 shiftProtoBobRight::@4: scope:[shiftProtoBobRight] from shiftProtoBobRight::@2 shiftProtoBobRight::@3 - [221] (byte) shiftProtoBobRight::carry#1 ← phi( shiftProtoBobRight::@3/(byte) $80 shiftProtoBobRight::@2/(byte) 0 ) - [222] (byte~) shiftProtoBobRight::$5 ← *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) >> (byte) 1 - [223] (byte~) shiftProtoBobRight::$6 ← (byte) shiftProtoBobRight::carry#2 | (byte~) shiftProtoBobRight::$5 - [224] *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) ← (byte~) shiftProtoBobRight::$6 - [225] if((byte) shiftProtoBobRight::j#3>=(byte) $30) goto shiftProtoBobRight::@5 + [220] (byte) shiftProtoBobRight::carry#1 ← phi( shiftProtoBobRight::@3/(byte) $80 shiftProtoBobRight::@2/(byte) 0 ) + [221] (byte~) shiftProtoBobRight::$5 ← *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) >> (byte) 1 + [222] (byte~) shiftProtoBobRight::$6 ← (byte) shiftProtoBobRight::carry#2 | (byte~) shiftProtoBobRight::$5 + [223] *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) ← (byte~) shiftProtoBobRight::$6 + [224] if((byte) shiftProtoBobRight::j#3>=(byte) $30) goto shiftProtoBobRight::@5 to:shiftProtoBobRight::@7 shiftProtoBobRight::@7: scope:[shiftProtoBobRight] from shiftProtoBobRight::@4 - [226] (byte) shiftProtoBobRight::j#2 ← (byte) shiftProtoBobRight::j#3 + (byte) $18 + [225] (byte) shiftProtoBobRight::j#2 ← (byte) shiftProtoBobRight::j#3 + (byte) $18 to:shiftProtoBobRight::@6 shiftProtoBobRight::@6: scope:[shiftProtoBobRight] from shiftProtoBobRight::@5 shiftProtoBobRight::@7 - [227] (byte) shiftProtoBobRight::j#10 ← phi( shiftProtoBobRight::@7/(byte) shiftProtoBobRight::j#2 shiftProtoBobRight::@5/(byte) shiftProtoBobRight::j#1 ) - [228] (byte) shiftProtoBobRight::i#1 ← ++ (byte) shiftProtoBobRight::i#2 - [229] (byte) shiftProtoBobRight::carry#10 ← (byte) shiftProtoBobRight::carry#1 + [226] (byte) shiftProtoBobRight::j#10 ← phi( shiftProtoBobRight::@7/(byte) shiftProtoBobRight::j#2 shiftProtoBobRight::@5/(byte) shiftProtoBobRight::j#1 ) + [227] (byte) shiftProtoBobRight::i#1 ← ++ (byte) shiftProtoBobRight::i#2 + [228] (byte) shiftProtoBobRight::carry#10 ← (byte) shiftProtoBobRight::carry#1 to:shiftProtoBobRight::@1 shiftProtoBobRight::@5: scope:[shiftProtoBobRight] from shiftProtoBobRight::@4 - [230] (byte) shiftProtoBobRight::j#1 ← (byte) shiftProtoBobRight::j#3 - (byte) $2f + [229] (byte) shiftProtoBobRight::j#1 ← (byte) shiftProtoBobRight::j#3 - (byte) $2f to:shiftProtoBobRight::@6 (void()) shiftProtoBobDown() shiftProtoBobDown: scope:[shiftProtoBobDown] from prepareBobs::@4 - [231] phi() + [230] phi() to:shiftProtoBobDown::@1 shiftProtoBobDown::@1: scope:[shiftProtoBobDown] from shiftProtoBobDown shiftProtoBobDown::@2 - [232] (byte) shiftProtoBobDown::i#2 ← phi( shiftProtoBobDown/(byte) $17 shiftProtoBobDown::@2/(byte) shiftProtoBobDown::i#1 ) - [233] if((byte) shiftProtoBobDown::i#2>(byte) 0) goto shiftProtoBobDown::@2 + [231] (byte) shiftProtoBobDown::i#2 ← phi( shiftProtoBobDown/(byte) $17 shiftProtoBobDown::@2/(byte) shiftProtoBobDown::i#1 ) + [232] if((byte) shiftProtoBobDown::i#2>(byte) 0) goto shiftProtoBobDown::@2 to:shiftProtoBobDown::@3 shiftProtoBobDown::@3: scope:[shiftProtoBobDown] from shiftProtoBobDown::@1 - [234] *((const byte*) PROTO_BOB) ← (byte) 0 - [235] *((const byte*) PROTO_BOB+(byte) $18) ← (byte) 0 - [236] *((const byte*) PROTO_BOB+(byte) $30) ← (byte) 0 + [233] *((const byte*) PROTO_BOB) ← (byte) 0 + [234] *((const byte*) PROTO_BOB+(byte) $18) ← (byte) 0 + [235] *((const byte*) PROTO_BOB+(byte) $30) ← (byte) 0 to:shiftProtoBobDown::@return shiftProtoBobDown::@return: scope:[shiftProtoBobDown] from shiftProtoBobDown::@3 - [237] return + [236] return to:@return shiftProtoBobDown::@2: scope:[shiftProtoBobDown] from shiftProtoBobDown::@1 - [238] *((const byte*) PROTO_BOB + (byte) shiftProtoBobDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $17 + (byte) shiftProtoBobDown::i#2) - [239] *((const byte*) PROTO_BOB+(byte) $18 + (byte) shiftProtoBobDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $2f + (byte) shiftProtoBobDown::i#2) - [240] *((const byte*) PROTO_BOB+(byte) $30 + (byte) shiftProtoBobDown::i#2) ← (byte) 0 - [241] (byte) shiftProtoBobDown::i#1 ← -- (byte) shiftProtoBobDown::i#2 + [237] *((const byte*) PROTO_BOB + (byte) shiftProtoBobDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $17 + (byte) shiftProtoBobDown::i#2) + [238] *((const byte*) PROTO_BOB+(byte) $18 + (byte) shiftProtoBobDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $2f + (byte) shiftProtoBobDown::i#2) + [239] *((const byte*) PROTO_BOB+(byte) $30 + (byte) shiftProtoBobDown::i#2) ← (byte) 0 + [240] (byte) shiftProtoBobDown::i#1 ← -- (byte) shiftProtoBobDown::i#2 to:shiftProtoBobDown::@1 (void()) progress_init((byte*) progress_init::line) progress_init: scope:[progress_init] from prepareBobs - [242] phi() + [241] phi() to:progress_init::@return progress_init::@return: scope:[progress_init] from progress_init - [243] return + [242] return to:@return (void()) mulf_init() mulf_init: scope:[mulf_init] from main - [244] phi() + [243] phi() to:mulf_init::@1 mulf_init::@1: scope:[mulf_init] from mulf_init mulf_init::@3 - [245] (byte) mulf_init::x_2#3 ← phi( mulf_init/(byte) 0 mulf_init::@3/(byte) mulf_init::x_2#2 ) - [245] (byte*) mulf_init::sqr1_hi#2 ← phi( mulf_init/(const byte*) mulf_sqr1_hi+(byte) 1 mulf_init::@3/(byte*) mulf_init::sqr1_hi#1 ) - [245] (word) mulf_init::sqr#4 ← phi( mulf_init/(byte) 0 mulf_init::@3/(word) mulf_init::sqr#1 ) - [245] (byte) mulf_init::c#2 ← phi( mulf_init/(byte) 0 mulf_init::@3/(byte) mulf_init::c#1 ) - [245] (byte*) mulf_init::sqr1_lo#2 ← phi( mulf_init/(const byte*) mulf_sqr1_lo+(byte) 1 mulf_init::@3/(byte*) mulf_init::sqr1_lo#1 ) - [246] if((byte*) mulf_init::sqr1_lo#2!=(const byte*) mulf_sqr1_lo+(word) $200) goto mulf_init::@2 + [244] (byte) mulf_init::x_2#3 ← phi( mulf_init/(byte) 0 mulf_init::@3/(byte) mulf_init::x_2#2 ) + [244] (byte*) mulf_init::sqr1_hi#2 ← phi( mulf_init/(const byte*) mulf_sqr1_hi+(byte) 1 mulf_init::@3/(byte*) mulf_init::sqr1_hi#1 ) + [244] (word) mulf_init::sqr#4 ← phi( mulf_init/(byte) 0 mulf_init::@3/(word) mulf_init::sqr#1 ) + [244] (byte) mulf_init::c#2 ← phi( mulf_init/(byte) 0 mulf_init::@3/(byte) mulf_init::c#1 ) + [244] (byte*) mulf_init::sqr1_lo#2 ← phi( mulf_init/(const byte*) mulf_sqr1_lo+(byte) 1 mulf_init::@3/(byte*) mulf_init::sqr1_lo#1 ) + [245] if((byte*) mulf_init::sqr1_lo#2!=(const byte*) mulf_sqr1_lo+(word) $200) goto mulf_init::@2 to:mulf_init::@5 mulf_init::@5: scope:[mulf_init] from mulf_init::@1 mulf_init::@8 - [247] (byte) mulf_init::dir#2 ← phi( mulf_init::@8/(byte) mulf_init::dir#4 mulf_init::@1/(byte) $ff ) - [247] (byte*) mulf_init::sqr2_hi#2 ← phi( mulf_init::@8/(byte*) mulf_init::sqr2_hi#1 mulf_init::@1/(const byte*) mulf_sqr2_hi ) - [247] (byte) mulf_init::x_255#2 ← phi( mulf_init::@8/(byte) mulf_init::x_255#1 mulf_init::@1/(byte) -1 ) - [247] (byte*) mulf_init::sqr2_lo#2 ← phi( mulf_init::@8/(byte*) mulf_init::sqr2_lo#1 mulf_init::@1/(const byte*) mulf_sqr2_lo ) - [248] if((byte*) mulf_init::sqr2_lo#2!=(const byte*) mulf_sqr2_lo+(word) $1ff) goto mulf_init::@6 + [246] (byte) mulf_init::dir#2 ← phi( mulf_init::@8/(byte) mulf_init::dir#4 mulf_init::@1/(byte) $ff ) + [246] (byte*) mulf_init::sqr2_hi#2 ← phi( mulf_init::@8/(byte*) mulf_init::sqr2_hi#1 mulf_init::@1/(const byte*) mulf_sqr2_hi ) + [246] (byte) mulf_init::x_255#2 ← phi( mulf_init::@8/(byte) mulf_init::x_255#1 mulf_init::@1/(byte) -1 ) + [246] (byte*) mulf_init::sqr2_lo#2 ← phi( mulf_init::@8/(byte*) mulf_init::sqr2_lo#1 mulf_init::@1/(const byte*) mulf_sqr2_lo ) + [247] if((byte*) mulf_init::sqr2_lo#2!=(const byte*) mulf_sqr2_lo+(word) $1ff) goto mulf_init::@6 to:mulf_init::@7 mulf_init::@7: scope:[mulf_init] from mulf_init::@5 - [249] *((const byte*) mulf_sqr2_lo+(word) $1ff) ← *((const byte*) mulf_sqr1_lo+(word) $100) - [250] *((const byte*) mulf_sqr2_hi+(word) $1ff) ← *((const byte*) mulf_sqr1_hi+(word) $100) + [248] *((const byte*) mulf_sqr2_lo+(word) $1ff) ← *((const byte*) mulf_sqr1_lo+(word) $100) + [249] *((const byte*) mulf_sqr2_hi+(word) $1ff) ← *((const byte*) mulf_sqr1_hi+(word) $100) to:mulf_init::@return mulf_init::@return: scope:[mulf_init] from mulf_init::@7 - [251] return + [250] return to:@return mulf_init::@6: scope:[mulf_init] from mulf_init::@5 - [252] *((byte*) mulf_init::sqr2_lo#2) ← *((const byte*) mulf_sqr1_lo + (byte) mulf_init::x_255#2) - [253] *((byte*) mulf_init::sqr2_hi#2) ← *((const byte*) mulf_sqr1_hi + (byte) mulf_init::x_255#2) - [254] (byte*) mulf_init::sqr2_hi#1 ← ++ (byte*) mulf_init::sqr2_hi#2 - [255] (byte) mulf_init::x_255#1 ← (byte) mulf_init::x_255#2 + (byte) mulf_init::dir#2 - [256] if((byte) mulf_init::x_255#1!=(byte) 0) goto mulf_init::@9 + [251] *((byte*) mulf_init::sqr2_lo#2) ← *((const byte*) mulf_sqr1_lo + (byte) mulf_init::x_255#2) + [252] *((byte*) mulf_init::sqr2_hi#2) ← *((const byte*) mulf_sqr1_hi + (byte) mulf_init::x_255#2) + [253] (byte*) mulf_init::sqr2_hi#1 ← ++ (byte*) mulf_init::sqr2_hi#2 + [254] (byte) mulf_init::x_255#1 ← (byte) mulf_init::x_255#2 + (byte) mulf_init::dir#2 + [255] if((byte) mulf_init::x_255#1!=(byte) 0) goto mulf_init::@9 to:mulf_init::@8 mulf_init::@9: scope:[mulf_init] from mulf_init::@6 - [257] phi() + [256] phi() to:mulf_init::@8 mulf_init::@8: scope:[mulf_init] from mulf_init::@6 mulf_init::@9 - [258] (byte) mulf_init::dir#4 ← phi( mulf_init::@9/(byte) mulf_init::dir#2 mulf_init::@6/(byte) 1 ) - [259] (byte*) mulf_init::sqr2_lo#1 ← ++ (byte*) mulf_init::sqr2_lo#2 + [257] (byte) mulf_init::dir#4 ← phi( mulf_init::@9/(byte) mulf_init::dir#2 mulf_init::@6/(byte) 1 ) + [258] (byte*) mulf_init::sqr2_lo#1 ← ++ (byte*) mulf_init::sqr2_lo#2 to:mulf_init::@5 mulf_init::@2: scope:[mulf_init] from mulf_init::@1 - [260] (byte) mulf_init::c#1 ← ++ (byte) mulf_init::c#2 - [261] (byte~) mulf_init::$1 ← (byte) mulf_init::c#1 & (byte) 1 - [262] if((byte~) mulf_init::$1!=(byte) 0) goto mulf_init::@3 + [259] (byte) mulf_init::c#1 ← ++ (byte) mulf_init::c#2 + [260] (byte~) mulf_init::$1 ← (byte) mulf_init::c#1 & (byte) 1 + [261] if((byte~) mulf_init::$1!=(byte) 0) goto mulf_init::@3 to:mulf_init::@4 mulf_init::@4: scope:[mulf_init] from mulf_init::@2 - [263] (byte) mulf_init::x_2#1 ← ++ (byte) mulf_init::x_2#3 - [264] (word) mulf_init::sqr#2 ← ++ (word) mulf_init::sqr#4 + [262] (byte) mulf_init::x_2#1 ← ++ (byte) mulf_init::x_2#3 + [263] (word) mulf_init::sqr#2 ← ++ (word) mulf_init::sqr#4 to:mulf_init::@3 mulf_init::@3: scope:[mulf_init] from mulf_init::@2 mulf_init::@4 - [265] (byte) mulf_init::x_2#2 ← phi( mulf_init::@2/(byte) mulf_init::x_2#3 mulf_init::@4/(byte) mulf_init::x_2#1 ) - [265] (word) mulf_init::sqr#3 ← phi( mulf_init::@2/(word) mulf_init::sqr#4 mulf_init::@4/(word) mulf_init::sqr#2 ) - [266] (byte~) mulf_init::$4 ← < (word) mulf_init::sqr#3 - [267] *((byte*) mulf_init::sqr1_lo#2) ← (byte~) mulf_init::$4 - [268] (byte~) mulf_init::$5 ← > (word) mulf_init::sqr#3 - [269] *((byte*) mulf_init::sqr1_hi#2) ← (byte~) mulf_init::$5 - [270] (byte*) mulf_init::sqr1_hi#1 ← ++ (byte*) mulf_init::sqr1_hi#2 - [271] (word) mulf_init::sqr#1 ← (word) mulf_init::sqr#3 + (byte) mulf_init::x_2#2 - [272] (byte*) mulf_init::sqr1_lo#1 ← ++ (byte*) mulf_init::sqr1_lo#2 + [264] (byte) mulf_init::x_2#2 ← phi( mulf_init::@2/(byte) mulf_init::x_2#3 mulf_init::@4/(byte) mulf_init::x_2#1 ) + [264] (word) mulf_init::sqr#3 ← phi( mulf_init::@2/(word) mulf_init::sqr#4 mulf_init::@4/(word) mulf_init::sqr#2 ) + [265] (byte~) mulf_init::$4 ← < (word) mulf_init::sqr#3 + [266] *((byte*) mulf_init::sqr1_lo#2) ← (byte~) mulf_init::$4 + [267] (byte~) mulf_init::$5 ← > (word) mulf_init::sqr#3 + [268] *((byte*) mulf_init::sqr1_hi#2) ← (byte~) mulf_init::$5 + [269] (byte*) mulf_init::sqr1_hi#1 ← ++ (byte*) mulf_init::sqr1_hi#2 + [270] (word) mulf_init::sqr#1 ← (word) mulf_init::sqr#3 + (byte) mulf_init::x_2#2 + [271] (byte*) mulf_init::sqr1_lo#1 ← ++ (byte*) mulf_init::sqr1_lo#2 to:mulf_init::@1 diff --git a/src/test/ref/complex/prebob/vogel-bobs.log b/src/test/ref/complex/prebob/vogel-bobs.log index 14ea656e6..2238fe007 100644 --- a/src/test/ref/complex/prebob/vogel-bobs.log +++ b/src/test/ref/complex/prebob/vogel-bobs.log @@ -101,6 +101,7 @@ Culled Empty Block (label) mulf8s::mulf8s_prepare1_@return Culled Empty Block (label) mulf8s::@1 Culled Empty Block (label) @56 Culled Empty Block (label) @57 +Culled Empty Block (label) @58 Culled Empty Block (label) main::vicSelectGfxBank1_toDd001_@1 Culled Empty Block (label) main::vicSelectGfxBank1_@return Culled Empty Block (label) main::toD0181_@1 @@ -163,7 +164,7 @@ Culled Empty Block (label) @67 CONTROL FLOW GRAPH SSA @begin: scope:[] from - to:@58 + to:@59 (void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num) memset: scope:[memset] from main::@22 @@ -456,11 +457,6 @@ mulf8s::@return: scope:[mulf8s] from mulf8s::@4 (signed word) mulf8s::return#1 ← (signed word) mulf8s::return#4 return to:@return -@58: scope:[] from @begin - kickasm() {{ .const PHI = (1+sqrt(5))/2 - - }} - to:@59 (void()) main() main: scope:[main] from @68 @@ -837,7 +833,7 @@ main::@return: scope:[main] from main::@24 (byte**) renderBobCleanupNext#2 ← (byte**) renderBobCleanupNext#11 return to:@return -@59: scope:[] from @58 +@59: scope:[] from @begin (byte**) renderBobCleanupNext#3 ← (byte**) 0 to:@65 @@ -1400,7 +1396,6 @@ progress_inc::@return: scope:[progress_inc] from progress_inc::@1 @end: scope:[] from @69 SYMBOL TABLE SSA -(label) @58 (label) @59 (label) @65 (label) @66 @@ -3053,10 +3048,10 @@ Inversing boolean not [55] (bool~) mulf_init::$3 ← (byte~) mulf_init::$1 != (b Inversing boolean not [83] (bool~) mulf_init::$10 ← (byte) mulf_init::x_255#1 != (byte) 0 from [82] (bool~) mulf_init::$9 ← (byte) mulf_init::x_255#1 == (byte) 0 Inversing boolean not [113] (bool~) mulf8s_prepared::$3 ← *((const signed byte*) mulf8s_prepared::memA) >= (signed byte) 0 from [112] (bool~) mulf8s_prepared::$2 ← *((const signed byte*) mulf8s_prepared::memA) < (signed byte) 0 Inversing boolean not [117] (bool~) mulf8s_prepared::$5 ← (signed byte) mulf8s_prepared::b#2 >= (signed byte) 0 from [116] (bool~) mulf8s_prepared::$4 ← (signed byte) mulf8s_prepared::b#2 < (signed byte) 0 -Inversing boolean not [260] (bool~) main::$20 ← (byte) 0 == (byte~) main::$19 from [259] (bool~) main::$23 ← (byte) 0 != (byte~) main::$19 -Inversing boolean not [499] (bool~) bobCharsetFindOrAddGlyph::$3 ← *((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#2 + (byte) bobCharsetFindOrAddGlyph::i#3) == *((byte*) bobCharsetFindOrAddGlyph::bob_glyph#2 + (byte) bobCharsetFindOrAddGlyph::i#3) from [498] (bool~) bobCharsetFindOrAddGlyph::$2 ← *((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#2 + (byte) bobCharsetFindOrAddGlyph::i#3) != *((byte*) bobCharsetFindOrAddGlyph::bob_glyph#2 + (byte) bobCharsetFindOrAddGlyph::i#3) -Inversing boolean not [507] (bool~) bobCharsetFindOrAddGlyph::$4 ← (byte) 0 == (byte) bobCharsetFindOrAddGlyph::found#2 from [506] (bool~) bobCharsetFindOrAddGlyph::$6 ← (byte) 0 != (byte) bobCharsetFindOrAddGlyph::found#2 -Inversing boolean not [540] (bool~) progress_inc::$1 ← (byte) progress_idx#8 != (byte) 8 from [539] (bool~) progress_inc::$0 ← (byte) progress_idx#8 == (byte) 8 +Inversing boolean not [259] (bool~) main::$20 ← (byte) 0 == (byte~) main::$19 from [258] (bool~) main::$23 ← (byte) 0 != (byte~) main::$19 +Inversing boolean not [498] (bool~) bobCharsetFindOrAddGlyph::$3 ← *((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#2 + (byte) bobCharsetFindOrAddGlyph::i#3) == *((byte*) bobCharsetFindOrAddGlyph::bob_glyph#2 + (byte) bobCharsetFindOrAddGlyph::i#3) from [497] (bool~) bobCharsetFindOrAddGlyph::$2 ← *((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#2 + (byte) bobCharsetFindOrAddGlyph::i#3) != *((byte*) bobCharsetFindOrAddGlyph::bob_glyph#2 + (byte) bobCharsetFindOrAddGlyph::i#3) +Inversing boolean not [506] (bool~) bobCharsetFindOrAddGlyph::$4 ← (byte) 0 == (byte) bobCharsetFindOrAddGlyph::found#2 from [505] (bool~) bobCharsetFindOrAddGlyph::$6 ← (byte) 0 != (byte) bobCharsetFindOrAddGlyph::found#2 +Inversing boolean not [539] (bool~) progress_inc::$1 ← (byte) progress_idx#8 != (byte) 8 from [538] (bool~) progress_inc::$0 ← (byte) progress_idx#8 == (byte) 8 Successful SSA optimization Pass2UnaryNotSimplification Alias (void*) memset::return#0 = (void*) memset::str#1 (void*) memset::return#3 (void*) memset::return#1 Alias (void*) memset::str#2 = (void*) memset::str#3 @@ -3320,28 +3315,28 @@ Simple Condition (bool~) mulf_init::$7 [75] if((byte*) mulf_init::sqr2_lo#2!=(co Simple Condition (bool~) mulf_init::$10 [84] if((byte) mulf_init::x_255#1!=(byte) 0) goto mulf_init::@12 Simple Condition (bool~) mulf8s_prepared::$3 [114] if(*((const signed byte*) mulf8s_prepared::memA)>=(signed byte) 0) goto mulf8s_prepared::@1 Simple Condition (bool~) mulf8s_prepared::$5 [118] if((signed byte) mulf8s_prepared::b#0>=(signed byte) 0) goto mulf8s_prepared::@2 -Simple Condition (bool~) main::$8 [210] if(*((const byte*) RASTER)<(byte) $f8) goto main::@4 -Simple Condition (bool~) main::$18 [250] if((byte) main::i#1!=rangelast(0,NUM_BOBS-1)) goto main::@6 -Simple Condition (bool~) main::$20 [261] if((byte) 0==(byte~) main::$19) goto main::@1 -Simple Condition (bool~) main::$22 [269] if((byte) 0!=(byte~) main::$21) goto main::@15 -Simple Condition (bool~) renderBobInit::$2 [320] if((byte) renderBobInit::y#1!=rangelast(0,$1f)) goto renderBobInit::@1 -Simple Condition (bool~) renderBobInit::$3 [327] if((byte) renderBobInit::i#1!=rangelast(0,NUM_BOBS-1)) goto renderBobInit::@3 -Simple Condition (bool~) renderBobCleanup::$0 [373] if((byte) renderBobCleanup::i#1!=rangelast(0,NUM_BOBS-1)) goto renderBobCleanup::@1 -Simple Condition (bool~) prepareBobs::$2 [394] if((byte) prepareBobs::shift_y#2<(const byte) BOB_SHIFTS_Y) goto prepareBobs::@2 -Simple Condition (bool~) prepareBobs::$3 [399] if((byte) prepareBobs::shift_x#2<(const byte) BOB_SHIFTS_X) goto prepareBobs::@5 -Simple Condition (bool~) prepareBobs::$5 [411] if((byte) prepareBobs::cell#2<(byte) 9) goto prepareBobs::@8 -Simple Condition (bool~) shiftProtoBobRight::$0 [444] if((byte) shiftProtoBobRight::i#2<(byte)(number) 3*(number) 3*(number) 8) goto shiftProtoBobRight::@2 -Simple Condition (bool~) shiftProtoBobRight::$8 [448] if((byte) 0!=(byte~) shiftProtoBobRight::$1) goto shiftProtoBobRight::@4 -Simple Condition (bool~) shiftProtoBobRight::$7 [460] if((byte) shiftProtoBobRight::j#3>=(byte) $30) goto shiftProtoBobRight::@7 -Simple Condition (bool~) shiftProtoBobDown::$0 [471] if((byte) shiftProtoBobDown::i#2>(byte) 0) goto shiftProtoBobDown::@2 -Simple Condition (bool~) bobCharsetFindOrAddGlyph::$0 [488] if((byte) bobCharsetFindOrAddGlyph::glyph_id#11!=(byte) bob_charset_next_id#23) goto bobCharsetFindOrAddGlyph::@2 -Simple Condition (bool~) bobCharsetFindOrAddGlyph::$1 [496] if((byte) bobCharsetFindOrAddGlyph::i#2<(byte) 8) goto bobCharsetFindOrAddGlyph::@5 -Simple Condition (bool~) bobCharsetFindOrAddGlyph::$3 [500] if(*((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) bobCharsetFindOrAddGlyph::i#2)==*((byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 + (byte) bobCharsetFindOrAddGlyph::i#2)) goto bobCharsetFindOrAddGlyph::@7 -Simple Condition (bool~) bobCharsetFindOrAddGlyph::$4 [508] if((byte) 0==(byte) bobCharsetFindOrAddGlyph::found#2) goto bobCharsetFindOrAddGlyph::@16 -Simple Condition (bool~) bobCharsetFindOrAddGlyph::$5 [520] if((byte) bobCharsetFindOrAddGlyph::i1#2<(byte) 8) goto bobCharsetFindOrAddGlyph::@21 -Simple Condition (bool~) progress_inc::$1 [541] if((byte) progress_idx#8!=(byte) 8) goto progress_inc::@1 +Simple Condition (bool~) main::$8 [209] if(*((const byte*) RASTER)<(byte) $f8) goto main::@4 +Simple Condition (bool~) main::$18 [249] if((byte) main::i#1!=rangelast(0,NUM_BOBS-1)) goto main::@6 +Simple Condition (bool~) main::$20 [260] if((byte) 0==(byte~) main::$19) goto main::@1 +Simple Condition (bool~) main::$22 [268] if((byte) 0!=(byte~) main::$21) goto main::@15 +Simple Condition (bool~) renderBobInit::$2 [319] if((byte) renderBobInit::y#1!=rangelast(0,$1f)) goto renderBobInit::@1 +Simple Condition (bool~) renderBobInit::$3 [326] if((byte) renderBobInit::i#1!=rangelast(0,NUM_BOBS-1)) goto renderBobInit::@3 +Simple Condition (bool~) renderBobCleanup::$0 [372] if((byte) renderBobCleanup::i#1!=rangelast(0,NUM_BOBS-1)) goto renderBobCleanup::@1 +Simple Condition (bool~) prepareBobs::$2 [393] if((byte) prepareBobs::shift_y#2<(const byte) BOB_SHIFTS_Y) goto prepareBobs::@2 +Simple Condition (bool~) prepareBobs::$3 [398] if((byte) prepareBobs::shift_x#2<(const byte) BOB_SHIFTS_X) goto prepareBobs::@5 +Simple Condition (bool~) prepareBobs::$5 [410] if((byte) prepareBobs::cell#2<(byte) 9) goto prepareBobs::@8 +Simple Condition (bool~) shiftProtoBobRight::$0 [443] if((byte) shiftProtoBobRight::i#2<(byte)(number) 3*(number) 3*(number) 8) goto shiftProtoBobRight::@2 +Simple Condition (bool~) shiftProtoBobRight::$8 [447] if((byte) 0!=(byte~) shiftProtoBobRight::$1) goto shiftProtoBobRight::@4 +Simple Condition (bool~) shiftProtoBobRight::$7 [459] if((byte) shiftProtoBobRight::j#3>=(byte) $30) goto shiftProtoBobRight::@7 +Simple Condition (bool~) shiftProtoBobDown::$0 [470] if((byte) shiftProtoBobDown::i#2>(byte) 0) goto shiftProtoBobDown::@2 +Simple Condition (bool~) bobCharsetFindOrAddGlyph::$0 [487] if((byte) bobCharsetFindOrAddGlyph::glyph_id#11!=(byte) bob_charset_next_id#23) goto bobCharsetFindOrAddGlyph::@2 +Simple Condition (bool~) bobCharsetFindOrAddGlyph::$1 [495] if((byte) bobCharsetFindOrAddGlyph::i#2<(byte) 8) goto bobCharsetFindOrAddGlyph::@5 +Simple Condition (bool~) bobCharsetFindOrAddGlyph::$3 [499] if(*((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) bobCharsetFindOrAddGlyph::i#2)==*((byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 + (byte) bobCharsetFindOrAddGlyph::i#2)) goto bobCharsetFindOrAddGlyph::@7 +Simple Condition (bool~) bobCharsetFindOrAddGlyph::$4 [507] if((byte) 0==(byte) bobCharsetFindOrAddGlyph::found#2) goto bobCharsetFindOrAddGlyph::@16 +Simple Condition (bool~) bobCharsetFindOrAddGlyph::$5 [519] if((byte) bobCharsetFindOrAddGlyph::i1#2<(byte) 8) goto bobCharsetFindOrAddGlyph::@21 +Simple Condition (bool~) progress_inc::$1 [540] if((byte) progress_idx#8!=(byte) 8) goto progress_inc::@1 Successful SSA optimization Pass2ConditionalJumpSimplification -Negating conditional jump and destination [261] if((byte) 0!=(byte~) main::$19) goto main::@15 +Negating conditional jump and destination [260] if((byte) 0!=(byte~) main::$19) goto main::@15 Successful SSA optimization Pass2ConditionalJumpSequenceImprovement Constant (const word) mulf_init::sqr#0 = 0 Constant (const byte) mulf_init::x_2#0 = 0 @@ -3411,26 +3406,26 @@ Constant (const byte*) progress_cursor#16 = progress_init::line#0 Successful SSA optimization Pass2ConstantIdentification if() condition always false - eliminating [3] if((const word) memset::num#0<=(byte) 0) goto memset::@1 Removing PHI-reference to removed block (main::@1) in block main::@15 -if() condition always true - replacing block destination [207] if(true) goto main::@4 +if() condition always true - replacing block destination [206] if(true) goto main::@4 Successful SSA optimization Pass2ConstantIfs -Resolved ranged next value [248] main::i#1 ← ++ main::i#2 to ++ -Resolved ranged comparison value [250] if(main::i#1!=rangelast(0,NUM_BOBS-1)) goto main::@6 to (const byte) NUM_BOBS-(byte) 1+(number) 1 -Resolved ranged next value [318] renderBobInit::y#1 ← ++ renderBobInit::y#2 to ++ -Resolved ranged comparison value [320] if(renderBobInit::y#1!=rangelast(0,$1f)) goto renderBobInit::@1 to (number) $20 -Resolved ranged next value [325] renderBobInit::i#1 ← ++ renderBobInit::i#2 to ++ -Resolved ranged comparison value [327] if(renderBobInit::i#1!=rangelast(0,NUM_BOBS-1)) goto renderBobInit::@3 to (const byte) NUM_BOBS-(byte) 1+(number) 1 -Resolved ranged next value [371] renderBobCleanup::i#1 ← ++ renderBobCleanup::i#2 to ++ -Resolved ranged comparison value [373] if(renderBobCleanup::i#1!=rangelast(0,NUM_BOBS-1)) goto renderBobCleanup::@1 to (const byte) NUM_BOBS-(byte) 1+(number) 1 -Simplifying constant evaluating to zero (byte) 0*(const byte) BOB_SUBTABLE_SIZE in [346] *((byte*) renderBob::screen#0 + (byte) 0) ← *((const byte*) BOB_TABLES+(byte) 0*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) +Resolved ranged next value [247] main::i#1 ← ++ main::i#2 to ++ +Resolved ranged comparison value [249] if(main::i#1!=rangelast(0,NUM_BOBS-1)) goto main::@6 to (const byte) NUM_BOBS-(byte) 1+(number) 1 +Resolved ranged next value [317] renderBobInit::y#1 ← ++ renderBobInit::y#2 to ++ +Resolved ranged comparison value [319] if(renderBobInit::y#1!=rangelast(0,$1f)) goto renderBobInit::@1 to (number) $20 +Resolved ranged next value [324] renderBobInit::i#1 ← ++ renderBobInit::i#2 to ++ +Resolved ranged comparison value [326] if(renderBobInit::i#1!=rangelast(0,NUM_BOBS-1)) goto renderBobInit::@3 to (const byte) NUM_BOBS-(byte) 1+(number) 1 +Resolved ranged next value [370] renderBobCleanup::i#1 ← ++ renderBobCleanup::i#2 to ++ +Resolved ranged comparison value [372] if(renderBobCleanup::i#1!=rangelast(0,NUM_BOBS-1)) goto renderBobCleanup::@1 to (const byte) NUM_BOBS-(byte) 1+(number) 1 +Simplifying constant evaluating to zero (byte) 0*(const byte) BOB_SUBTABLE_SIZE in [345] *((byte*) renderBob::screen#0 + (byte) 0) ← *((const byte*) BOB_TABLES+(byte) 0*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) Successful SSA optimization PassNSimplifyConstantZero -Simplifying expression containing zero BOB_TABLES in [346] *((byte*) renderBob::screen#0 + (byte) 0) ← *((const byte*) BOB_TABLES+(byte) 0 + (byte) renderBob::bob_table_idx#0) -Simplifying expression containing zero renderBob::screen#0 in [346] *((byte*) renderBob::screen#0 + (byte) 0) ← *((const byte*) BOB_TABLES + (byte) renderBob::bob_table_idx#0) -Simplifying expression containing zero renderBobCleanup::screen#0 in [362] *((byte*) renderBobCleanup::screen#0 + (byte) 0) ← (byte) 0 -Simplifying expression containing zero PROTO_BOB in [477] *((const byte*) PROTO_BOB + (byte) 0) ← (byte) 0 +Simplifying expression containing zero BOB_TABLES in [345] *((byte*) renderBob::screen#0 + (byte) 0) ← *((const byte*) BOB_TABLES+(byte) 0 + (byte) renderBob::bob_table_idx#0) +Simplifying expression containing zero renderBob::screen#0 in [345] *((byte*) renderBob::screen#0 + (byte) 0) ← *((const byte*) BOB_TABLES + (byte) renderBob::bob_table_idx#0) +Simplifying expression containing zero renderBobCleanup::screen#0 in [361] *((byte*) renderBobCleanup::screen#0 + (byte) 0) ← (byte) 0 +Simplifying expression containing zero PROTO_BOB in [476] *((const byte*) PROTO_BOB + (byte) 0) ← (byte) 0 Successful SSA optimization PassNSimplifyExpressionWithZero Eliminating unused variable - keeping the phi block (byte**) renderBobCleanupNext#24 Eliminating unused variable - keeping the phi block (byte**) renderBobCleanupNext#11 -Eliminating unused variable (byte) bobCharsetFindOrAddGlyph::return#0 and assignment [200] (byte) bobCharsetFindOrAddGlyph::return#0 ← (byte) bobCharsetFindOrAddGlyph::glyph_id#11 +Eliminating unused variable (byte) bobCharsetFindOrAddGlyph::return#0 and assignment [199] (byte) bobCharsetFindOrAddGlyph::return#0 ← (byte) bobCharsetFindOrAddGlyph::glyph_id#11 Eliminating unused constant (const void*) memset::return#2 Eliminating unused constant (const byte) bob_charset_next_id#27 Eliminating unused constant (const byte*) progress_cursor#27 @@ -3460,12 +3455,12 @@ Finalized unsigned number type (byte) 1 Finalized unsigned number type (byte) 1 Successful SSA optimization PassNFinalizeNumberTypeConversions Constant right-side identified [0] (byte*) memset::end#0 ← (const byte*) memset::$2 + (const word) memset::num#0 -Constant right-side identified [83] (byte~) main::vicSelectGfxBank1_toDd001_$1 ← > (const word) main::vicSelectGfxBank1_toDd001_$0 -Constant right-side identified [87] (word~) main::toD0181_$1 ← (const word) main::toD0181_$0 & (word) $3fff -Constant right-side identified [90] (byte~) main::toD0181_$5 ← > (const word) main::toD0181_$4 -Constant right-side identified [135] (byte~) main::vicSelectGfxBank2_toDd001_$1 ← > (const word) main::vicSelectGfxBank2_toDd001_$0 -Constant right-side identified [139] (word~) main::toD0182_$1 ← (const word) main::toD0182_$0 & (word) $3fff -Constant right-side identified [142] (byte~) main::toD0182_$5 ← > (const word) main::toD0182_$4 +Constant right-side identified [82] (byte~) main::vicSelectGfxBank1_toDd001_$1 ← > (const word) main::vicSelectGfxBank1_toDd001_$0 +Constant right-side identified [86] (word~) main::toD0181_$1 ← (const word) main::toD0181_$0 & (word) $3fff +Constant right-side identified [89] (byte~) main::toD0181_$5 ← > (const word) main::toD0181_$4 +Constant right-side identified [134] (byte~) main::vicSelectGfxBank2_toDd001_$1 ← > (const word) main::vicSelectGfxBank2_toDd001_$0 +Constant right-side identified [138] (word~) main::toD0182_$1 ← (const word) main::toD0182_$0 & (word) $3fff +Constant right-side identified [141] (byte~) main::toD0182_$5 ← > (const word) main::toD0182_$4 Successful SSA optimization Pass2ConstantRValueConsolidation Constant (const byte*) memset::end#0 = memset::$2+memset::num#0 Constant (const byte) main::vicSelectGfxBank1_toDd001_$1 = >main::vicSelectGfxBank1_toDd001_$0 @@ -3475,12 +3470,12 @@ Constant (const byte) main::vicSelectGfxBank2_toDd001_$1 = >main::vicSelectGfxBa Constant (const word) main::toD0182_$1 = main::toD0182_$0&$3fff Constant (const byte) main::toD0182_$5 = >main::toD0182_$4 Successful SSA optimization Pass2ConstantIdentification -Constant right-side identified [82] (byte~) main::vicSelectGfxBank1_toDd001_$2 ← (const byte) main::vicSelectGfxBank1_toDd001_$1 / (byte) $40 -Constant right-side identified [85] (word~) main::toD0181_$2 ← (const word) main::toD0181_$1 * (byte) 4 -Constant right-side identified [87] (byte~) main::toD0181_$6 ← (const byte) main::toD0181_$5 / (byte) 4 -Constant right-side identified [130] (byte~) main::vicSelectGfxBank2_toDd001_$2 ← (const byte) main::vicSelectGfxBank2_toDd001_$1 / (byte) $40 -Constant right-side identified [133] (word~) main::toD0182_$2 ← (const word) main::toD0182_$1 * (byte) 4 -Constant right-side identified [135] (byte~) main::toD0182_$6 ← (const byte) main::toD0182_$5 / (byte) 4 +Constant right-side identified [81] (byte~) main::vicSelectGfxBank1_toDd001_$2 ← (const byte) main::vicSelectGfxBank1_toDd001_$1 / (byte) $40 +Constant right-side identified [84] (word~) main::toD0181_$2 ← (const word) main::toD0181_$1 * (byte) 4 +Constant right-side identified [86] (byte~) main::toD0181_$6 ← (const byte) main::toD0181_$5 / (byte) 4 +Constant right-side identified [129] (byte~) main::vicSelectGfxBank2_toDd001_$2 ← (const byte) main::vicSelectGfxBank2_toDd001_$1 / (byte) $40 +Constant right-side identified [132] (word~) main::toD0182_$2 ← (const word) main::toD0182_$1 * (byte) 4 +Constant right-side identified [134] (byte~) main::toD0182_$6 ← (const byte) main::toD0182_$5 / (byte) 4 Successful SSA optimization Pass2ConstantRValueConsolidation Constant (const byte) main::vicSelectGfxBank1_toDd001_$2 = main::vicSelectGfxBank1_toDd001_$1/$40 Constant (const word) main::toD0181_$2 = main::toD0181_$1*4 @@ -3492,8 +3487,8 @@ Successful SSA optimization Pass2ConstantIdentification Simplifying constant evaluating to zero (const byte) main::vicSelectGfxBank1_toDd001_$1/(byte) $40 in Simplifying constant evaluating to zero (const byte) main::vicSelectGfxBank2_toDd001_$1/(byte) $40 in Successful SSA optimization PassNSimplifyConstantZero -Simplifying expression containing zero 3 in [83] (byte) main::vicSelectGfxBank1_toDd001_return#0 ← (byte) 3 ^ (const byte) main::vicSelectGfxBank1_toDd001_$2 -Simplifying expression containing zero 3 in [131] (byte) main::vicSelectGfxBank2_toDd001_return#0 ← (byte) 3 ^ (const byte) main::vicSelectGfxBank2_toDd001_$2 +Simplifying expression containing zero 3 in [82] (byte) main::vicSelectGfxBank1_toDd001_return#0 ← (byte) 3 ^ (const byte) main::vicSelectGfxBank1_toDd001_$2 +Simplifying expression containing zero 3 in [130] (byte) main::vicSelectGfxBank2_toDd001_return#0 ← (byte) 3 ^ (const byte) main::vicSelectGfxBank2_toDd001_$2 Successful SSA optimization PassNSimplifyExpressionWithZero Eliminating unused constant (const byte) main::vicSelectGfxBank1_toDd001_$1 Eliminating unused constant (const byte) main::vicSelectGfxBank2_toDd001_$1 @@ -3506,10 +3501,10 @@ Successful SSA optimization PassNEliminateUnusedVars Eliminating unused constant (const byte*) main::vicSelectGfxBank1_gfx#0 Eliminating unused constant (const byte*) main::vicSelectGfxBank2_gfx#0 Successful SSA optimization PassNEliminateUnusedVars -Constant right-side identified [84] (byte~) main::toD0181_$3 ← > (const word) main::toD0181_$2 -Constant right-side identified [85] (byte~) main::toD0181_$7 ← (const byte) main::toD0181_$6 & (byte) $f -Constant right-side identified [129] (byte~) main::toD0182_$3 ← > (const word) main::toD0182_$2 -Constant right-side identified [130] (byte~) main::toD0182_$7 ← (const byte) main::toD0182_$6 & (byte) $f +Constant right-side identified [83] (byte~) main::toD0181_$3 ← > (const word) main::toD0181_$2 +Constant right-side identified [84] (byte~) main::toD0181_$7 ← (const byte) main::toD0181_$6 & (byte) $f +Constant right-side identified [128] (byte~) main::toD0182_$3 ← > (const word) main::toD0182_$2 +Constant right-side identified [129] (byte~) main::toD0182_$7 ← (const byte) main::toD0182_$6 & (byte) $f Successful SSA optimization Pass2ConstantRValueConsolidation Constant (const byte) main::vicSelectGfxBank1_toDd001_return#0 = 3 Constant (const byte) main::toD0181_$3 = >main::toD0181_$2 @@ -3518,8 +3513,8 @@ Constant (const byte) main::vicSelectGfxBank2_toDd001_return#0 = 3 Constant (const byte) main::toD0182_$3 = >main::toD0182_$2 Constant (const byte) main::toD0182_$7 = main::toD0182_$6&$f Successful SSA optimization Pass2ConstantIdentification -Constant right-side identified [83] (byte) main::toD0181_return#0 ← (const byte) main::toD0181_$3 | (const byte) main::toD0181_$7 -Constant right-side identified [125] (byte) main::toD0182_return#0 ← (const byte) main::toD0182_$3 | (const byte) main::toD0182_$7 +Constant right-side identified [82] (byte) main::toD0181_return#0 ← (const byte) main::toD0181_$3 | (const byte) main::toD0181_$7 +Constant right-side identified [124] (byte) main::toD0182_return#0 ← (const byte) main::toD0182_$3 | (const byte) main::toD0182_$7 Successful SSA optimization Pass2ConstantRValueConsolidation Constant (const byte) main::toD0181_return#0 = main::toD0181_$3|main::toD0181_$7 Constant (const byte) main::toD0182_return#0 = main::toD0182_$3|main::toD0182_$7 @@ -3530,15 +3525,15 @@ Inlining Noop Cast [65] (byte~) mulf8s_prepared::$13 ← (byte)*((const signed b Successful SSA optimization Pass2NopCastInlining Inlining Noop Cast [74] (signed word) mulf8s_prepared::return#2 ← (signed word)(word) mulf8s_prepared::m#4 keeping mulf8s_prepared::m#4 Successful SSA optimization Pass2NopCastInlining -Rewriting multiplication to use shift [102] (signed word~) main::$13 ← (signed word~) main::$12 * (signed byte) 2 -Rewriting multiplication to use shift and addition[128] (word~) renderBobInit::$1 ← (word~) renderBobInit::$0 * (byte) $28 -Rewriting multiplication to use shift [129] (byte~) renderBobInit::$4 ← (byte) renderBobInit::y#2 * (const byte) SIZEOF_WORD -Rewriting multiplication to use shift [134] (byte~) renderBobInit::$5 ← (byte) renderBobInit::i#2 * (const byte) SIZEOF_POINTER -Rewriting division to use shift [139] (byte) renderBob::x_char_offset#0 ← (byte) renderBob::xpos#0 / (const byte) BOB_SHIFTS_X -Rewriting division to use shift [140] (byte) renderBob::y_char_offset#0 ← (byte) renderBob::ypos#0 / (const byte) BOB_SHIFTS_Y -Rewriting multiplication to use shift [141] (byte~) renderBob::$8 ← (byte) renderBob::y_char_offset#0 * (const byte) SIZEOF_WORD -Rewriting multiplication to use shift [146] (byte~) renderBob::$5 ← (byte~) renderBob::$4 * (const byte) BOB_SHIFTS_X -Rewriting multiplication to use shift [162] (byte~) renderBobCleanup::$1 ← (byte) renderBobCleanup::i#2 * (const byte) SIZEOF_POINTER +Rewriting multiplication to use shift [101] (signed word~) main::$13 ← (signed word~) main::$12 * (signed byte) 2 +Rewriting multiplication to use shift and addition[127] (word~) renderBobInit::$1 ← (word~) renderBobInit::$0 * (byte) $28 +Rewriting multiplication to use shift [128] (byte~) renderBobInit::$4 ← (byte) renderBobInit::y#2 * (const byte) SIZEOF_WORD +Rewriting multiplication to use shift [133] (byte~) renderBobInit::$5 ← (byte) renderBobInit::i#2 * (const byte) SIZEOF_POINTER +Rewriting division to use shift [138] (byte) renderBob::x_char_offset#0 ← (byte) renderBob::xpos#0 / (const byte) BOB_SHIFTS_X +Rewriting division to use shift [139] (byte) renderBob::y_char_offset#0 ← (byte) renderBob::ypos#0 / (const byte) BOB_SHIFTS_Y +Rewriting multiplication to use shift [140] (byte~) renderBob::$8 ← (byte) renderBob::y_char_offset#0 * (const byte) SIZEOF_WORD +Rewriting multiplication to use shift [145] (byte~) renderBob::$5 ← (byte~) renderBob::$4 * (const byte) BOB_SHIFTS_X +Rewriting multiplication to use shift [161] (byte~) renderBobCleanup::$1 ← (byte) renderBobCleanup::i#2 * (const byte) SIZEOF_POINTER Successful SSA optimization Pass2MultiplyToShiftRewriting Inlining constant with var siblings (const byte*) memset::dst#0 Inlining constant with var siblings (const byte) keyboard_key_pressed::key#0 @@ -3727,88 +3722,88 @@ Adding NOP phi() at start of mulf_init Adding NOP phi() at start of mulf_init::@3 Adding NOP phi() at start of mulf_init::@15 CALL GRAPH -Calls in [] to main:6 -Calls in [main] to mulf_init:10 prepareBobs:12 renderBobInit:14 memset:24 renderBobCleanup:29 mulf8s:37 mulf8s:45 renderBob:55 keyboard_key_pressed:60 keyboard_key_pressed:66 -Calls in [keyboard_key_pressed] to keyboard_matrix_read:85 -Calls in [mulf8s] to mulf8u_prepare:117 mulf8s_prepared:120 -Calls in [mulf8s_prepared] to mulf8u_prepared:124 -Calls in [prepareBobs] to progress_init:196 bobCharsetFindOrAddGlyph:198 shiftProtoBobDown:210 shiftProtoBobRight:225 shiftProtoBobRight:227 bobCharsetFindOrAddGlyph:237 progress_inc:243 +Calls in [] to main:5 +Calls in [main] to mulf_init:9 prepareBobs:11 renderBobInit:13 memset:23 renderBobCleanup:28 mulf8s:36 mulf8s:44 renderBob:54 keyboard_key_pressed:59 keyboard_key_pressed:65 +Calls in [keyboard_key_pressed] to keyboard_matrix_read:84 +Calls in [mulf8s] to mulf8u_prepare:116 mulf8s_prepared:119 +Calls in [mulf8s_prepared] to mulf8u_prepared:123 +Calls in [prepareBobs] to progress_init:195 bobCharsetFindOrAddGlyph:197 shiftProtoBobDown:209 shiftProtoBobRight:224 shiftProtoBobRight:226 bobCharsetFindOrAddGlyph:236 progress_inc:242 Created 57 initial phi equivalence classes -Not coalescing [30] main::a#6 ← main::angle#8 -Coalesced [35] mulf8s::mulf8s_prepare1_a#3 ← mulf8s::a#0 -Coalesced [36] mulf8s::b#7 ← mulf8s::b#0 -Coalesced [43] mulf8s::mulf8s_prepare1_a#2 ← mulf8s::a#1 -Coalesced [44] mulf8s::b#6 ← mulf8s::b#1 -Coalesced [64] main::angle#12 ← main::angle#1 -Coalesced [80] main::r#6 ← main::r#1 -Coalesced [81] main::a#7 ← main::a#1 -Coalesced [82] renderBobCleanupNext#51 ← renderBobCleanupNext#13 -Coalesced [83] main::i#6 ← main::i#1 -Coalesced [131] mulf8s_prepared::m#7 ← mulf8s_prepared::m#1 -Coalesced [137] mulf8s_prepared::m#10 ← mulf8s_prepared::m#2 -Coalesced [140] mulf8s_prepared::m#9 ← mulf8s_prepared::m#5 -Coalesced [141] mulf8s_prepared::m#8 ← mulf8s_prepared::m#0 -Coalesced [166] renderBobCleanup::i#3 ← renderBobCleanup::i#1 -Coalesced [175] memset::dst#4 ← memset::dst#1 -Coalesced [193] renderBobInit::i#3 ← renderBobInit::i#1 -Coalesced [194] renderBobInit::y#3 ← renderBobInit::y#1 -Coalesced [199] bob_charset_next_id#78 ← bob_charset_next_id#16 -Coalesced [203] prepareBobs::bob_table_idx#16 ← prepareBobs::bob_table_idx#6 -Coalesced [204] bob_charset_next_id#80 ← bob_charset_next_id#14 -Coalesced [205] progress_cursor#71 ← progress_cursor#15 -Coalesced [206] progress_idx#71 ← progress_idx#16 -Coalesced [212] prepareBobs::shift_y#15 ← prepareBobs::shift_y#1 -Coalesced (already) [213] progress_cursor#70 ← progress_cursor#31 -Coalesced (already) [214] progress_idx#70 ← progress_idx#31 -Coalesced (already) [215] bob_charset_next_id#79 ← bob_charset_next_id#30 -Coalesced (already) [216] prepareBobs::bob_table_idx#15 ← prepareBobs::bob_table_idx#12 -Coalesced [218] bob_charset_next_id#83 ← bob_charset_next_id#30 -Coalesced [219] prepareBobs::bob_table#7 ← prepareBobs::bob_table#0 -Coalesced [220] progress_idx#74 ← progress_idx#31 -Coalesced [221] progress_cursor#74 ← progress_cursor#31 -Coalesced [229] prepareBobs::shift_x#11 ← prepareBobs::shift_x#1 -Coalesced [230] prepareBobs::bob_table_idx#17 ← prepareBobs::bob_table_idx#1 -Coalesced (already) [231] bob_charset_next_id#81 ← bob_charset_next_id#21 -Coalesced (already) [232] progress_cursor#72 ← progress_cursor#24 -Coalesced (already) [233] progress_idx#72 ← progress_idx#25 -Coalesced [235] bob_charset_next_id#84 ← bob_charset_next_id#21 -Coalesced [236] bobCharsetFindOrAddGlyph::bob_glyph#14 ← bobCharsetFindOrAddGlyph::bob_glyph#1 -Coalesced [245] prepareBobs::cell#6 ← prepareBobs::cell#1 -Coalesced [246] prepareBobs::bob_glyph#6 ← prepareBobs::bob_glyph#1 -Coalesced (already) [247] bob_charset_next_id#82 ← bob_charset_next_id#16 -Coalesced [248] prepareBobs::bob_table#6 ← prepareBobs::bob_table#1 -Coalesced [249] progress_idx#73 ← progress_idx#10 -Coalesced [250] progress_cursor#73 ← progress_cursor#17 -Coalesced [255] progress_cursor#76 ← progress_cursor#8 -Coalesced [259] progress_idx#75 ← progress_idx#8 -Coalesced (already) [260] progress_cursor#75 ← progress_cursor#24 -Coalesced [268] bob_charset_next_id#86 ← bob_charset_next_id#8 -Coalesced [273] bobCharsetFindOrAddGlyph::i1#4 ← bobCharsetFindOrAddGlyph::i1#1 -Coalesced (already) [279] bob_charset_next_id#85 ← bob_charset_next_id#23 -Coalesced [282] bobCharsetFindOrAddGlyph::glyph_id#15 ← bobCharsetFindOrAddGlyph::glyph_id#1 -Coalesced [283] bobCharsetFindOrAddGlyph::glyph_cursor#13 ← bobCharsetFindOrAddGlyph::glyph_cursor#1 -Coalesced [287] bobCharsetFindOrAddGlyph::i#5 ← bobCharsetFindOrAddGlyph::i#1 -Coalesced [301] shiftProtoBobRight::j#12 ← shiftProtoBobRight::j#2 -Coalesced [304] shiftProtoBobRight::i#10 ← shiftProtoBobRight::i#1 -Coalesced [305] shiftProtoBobRight::j#11 ← shiftProtoBobRight::j#10 -Not coalescing [306] shiftProtoBobRight::carry#10 ← shiftProtoBobRight::carry#1 -Coalesced [308] shiftProtoBobRight::j#13 ← shiftProtoBobRight::j#1 -Coalesced [321] shiftProtoBobDown::i#4 ← shiftProtoBobDown::i#1 -Coalesced [341] mulf_init::sqr2_lo#6 ← mulf_init::sqr2_lo#1 -Coalesced [342] mulf_init::x_255#6 ← mulf_init::x_255#1 -Coalesced [343] mulf_init::sqr2_hi#6 ← mulf_init::sqr2_hi#1 -Coalesced [344] mulf_init::dir#5 ← mulf_init::dir#4 -Coalesced (already) [345] mulf_init::dir#6 ← mulf_init::dir#2 -Coalesced [351] mulf_init::sqr#9 ← mulf_init::sqr#2 -Coalesced [352] mulf_init::x_2#8 ← mulf_init::x_2#1 -Coalesced [361] mulf_init::sqr1_lo#6 ← mulf_init::sqr1_lo#1 -Coalesced [362] mulf_init::c#6 ← mulf_init::c#1 -Coalesced [363] mulf_init::sqr#7 ← mulf_init::sqr#1 -Coalesced [364] mulf_init::sqr1_hi#6 ← mulf_init::sqr1_hi#1 -Coalesced [365] mulf_init::x_2#6 ← mulf_init::x_2#2 -Coalesced [366] mulf_init::sqr#8 ← mulf_init::sqr#4 -Coalesced (already) [367] mulf_init::x_2#7 ← mulf_init::x_2#3 +Not coalescing [29] main::a#6 ← main::angle#8 +Coalesced [34] mulf8s::mulf8s_prepare1_a#3 ← mulf8s::a#0 +Coalesced [35] mulf8s::b#7 ← mulf8s::b#0 +Coalesced [42] mulf8s::mulf8s_prepare1_a#2 ← mulf8s::a#1 +Coalesced [43] mulf8s::b#6 ← mulf8s::b#1 +Coalesced [63] main::angle#12 ← main::angle#1 +Coalesced [79] main::r#6 ← main::r#1 +Coalesced [80] main::a#7 ← main::a#1 +Coalesced [81] renderBobCleanupNext#51 ← renderBobCleanupNext#13 +Coalesced [82] main::i#6 ← main::i#1 +Coalesced [130] mulf8s_prepared::m#7 ← mulf8s_prepared::m#1 +Coalesced [136] mulf8s_prepared::m#10 ← mulf8s_prepared::m#2 +Coalesced [139] mulf8s_prepared::m#9 ← mulf8s_prepared::m#5 +Coalesced [140] mulf8s_prepared::m#8 ← mulf8s_prepared::m#0 +Coalesced [165] renderBobCleanup::i#3 ← renderBobCleanup::i#1 +Coalesced [174] memset::dst#4 ← memset::dst#1 +Coalesced [192] renderBobInit::i#3 ← renderBobInit::i#1 +Coalesced [193] renderBobInit::y#3 ← renderBobInit::y#1 +Coalesced [198] bob_charset_next_id#78 ← bob_charset_next_id#16 +Coalesced [202] prepareBobs::bob_table_idx#16 ← prepareBobs::bob_table_idx#6 +Coalesced [203] bob_charset_next_id#80 ← bob_charset_next_id#14 +Coalesced [204] progress_cursor#71 ← progress_cursor#15 +Coalesced [205] progress_idx#71 ← progress_idx#16 +Coalesced [211] prepareBobs::shift_y#15 ← prepareBobs::shift_y#1 +Coalesced (already) [212] progress_cursor#70 ← progress_cursor#31 +Coalesced (already) [213] progress_idx#70 ← progress_idx#31 +Coalesced (already) [214] bob_charset_next_id#79 ← bob_charset_next_id#30 +Coalesced (already) [215] prepareBobs::bob_table_idx#15 ← prepareBobs::bob_table_idx#12 +Coalesced [217] bob_charset_next_id#83 ← bob_charset_next_id#30 +Coalesced [218] prepareBobs::bob_table#7 ← prepareBobs::bob_table#0 +Coalesced [219] progress_idx#74 ← progress_idx#31 +Coalesced [220] progress_cursor#74 ← progress_cursor#31 +Coalesced [228] prepareBobs::shift_x#11 ← prepareBobs::shift_x#1 +Coalesced [229] prepareBobs::bob_table_idx#17 ← prepareBobs::bob_table_idx#1 +Coalesced (already) [230] bob_charset_next_id#81 ← bob_charset_next_id#21 +Coalesced (already) [231] progress_cursor#72 ← progress_cursor#24 +Coalesced (already) [232] progress_idx#72 ← progress_idx#25 +Coalesced [234] bob_charset_next_id#84 ← bob_charset_next_id#21 +Coalesced [235] bobCharsetFindOrAddGlyph::bob_glyph#14 ← bobCharsetFindOrAddGlyph::bob_glyph#1 +Coalesced [244] prepareBobs::cell#6 ← prepareBobs::cell#1 +Coalesced [245] prepareBobs::bob_glyph#6 ← prepareBobs::bob_glyph#1 +Coalesced (already) [246] bob_charset_next_id#82 ← bob_charset_next_id#16 +Coalesced [247] prepareBobs::bob_table#6 ← prepareBobs::bob_table#1 +Coalesced [248] progress_idx#73 ← progress_idx#10 +Coalesced [249] progress_cursor#73 ← progress_cursor#17 +Coalesced [254] progress_cursor#76 ← progress_cursor#8 +Coalesced [258] progress_idx#75 ← progress_idx#8 +Coalesced (already) [259] progress_cursor#75 ← progress_cursor#24 +Coalesced [267] bob_charset_next_id#86 ← bob_charset_next_id#8 +Coalesced [272] bobCharsetFindOrAddGlyph::i1#4 ← bobCharsetFindOrAddGlyph::i1#1 +Coalesced (already) [278] bob_charset_next_id#85 ← bob_charset_next_id#23 +Coalesced [281] bobCharsetFindOrAddGlyph::glyph_id#15 ← bobCharsetFindOrAddGlyph::glyph_id#1 +Coalesced [282] bobCharsetFindOrAddGlyph::glyph_cursor#13 ← bobCharsetFindOrAddGlyph::glyph_cursor#1 +Coalesced [286] bobCharsetFindOrAddGlyph::i#5 ← bobCharsetFindOrAddGlyph::i#1 +Coalesced [300] shiftProtoBobRight::j#12 ← shiftProtoBobRight::j#2 +Coalesced [303] shiftProtoBobRight::i#10 ← shiftProtoBobRight::i#1 +Coalesced [304] shiftProtoBobRight::j#11 ← shiftProtoBobRight::j#10 +Not coalescing [305] shiftProtoBobRight::carry#10 ← shiftProtoBobRight::carry#1 +Coalesced [307] shiftProtoBobRight::j#13 ← shiftProtoBobRight::j#1 +Coalesced [320] shiftProtoBobDown::i#4 ← shiftProtoBobDown::i#1 +Coalesced [340] mulf_init::sqr2_lo#6 ← mulf_init::sqr2_lo#1 +Coalesced [341] mulf_init::x_255#6 ← mulf_init::x_255#1 +Coalesced [342] mulf_init::sqr2_hi#6 ← mulf_init::sqr2_hi#1 +Coalesced [343] mulf_init::dir#5 ← mulf_init::dir#4 +Coalesced (already) [344] mulf_init::dir#6 ← mulf_init::dir#2 +Coalesced [350] mulf_init::sqr#9 ← mulf_init::sqr#2 +Coalesced [351] mulf_init::x_2#8 ← mulf_init::x_2#1 +Coalesced [360] mulf_init::sqr1_lo#6 ← mulf_init::sqr1_lo#1 +Coalesced [361] mulf_init::c#6 ← mulf_init::c#1 +Coalesced [362] mulf_init::sqr#7 ← mulf_init::sqr#1 +Coalesced [363] mulf_init::sqr1_hi#6 ← mulf_init::sqr1_hi#1 +Coalesced [364] mulf_init::x_2#6 ← mulf_init::x_2#2 +Coalesced [365] mulf_init::sqr#8 ← mulf_init::sqr#4 +Coalesced (already) [366] mulf_init::x_2#7 ← mulf_init::x_2#3 Coalesced down to 41 phi equivalence classes Culled Empty Block (label) @59 Culled Empty Block (label) @65 @@ -3846,8 +3841,7 @@ Culled Empty Block (label) shiftProtoBobRight::@5 Culled Empty Block (label) mulf_init::@3 Culled Empty Block (label) mulf_init::@15 Culled Empty Block (label) mulf_init::@17 -Renumbering block @58 to @1 -Renumbering block @68 to @2 +Renumbering block @68 to @1 Renumbering block memset::@4 to memset::@1 Renumbering block memset::@5 to memset::@2 Renumbering block keyboard_key_pressed::@2 to keyboard_key_pressed::@1 @@ -3903,7 +3897,7 @@ Renumbering block bobCharsetFindOrAddGlyph::@20 to bobCharsetFindOrAddGlyph::@7 Renumbering block bobCharsetFindOrAddGlyph::@21 to bobCharsetFindOrAddGlyph::@8 Renumbering block bobCharsetFindOrAddGlyph::@22 to bobCharsetFindOrAddGlyph::@9 Adding NOP phi() at start of @begin -Adding NOP phi() at start of @2 +Adding NOP phi() at start of @1 Adding NOP phi() at start of @end Adding NOP phi() at start of main Adding NOP phi() at start of main::@9 @@ -3933,583 +3927,578 @@ FINAL CONTROL FLOW GRAPH [0] phi() to:@1 @1: scope:[] from @begin - kickasm() {{ .const PHI = (1+sqrt(5))/2 - - }} - to:@2 -@2: scope:[] from @1 - [2] phi() - [3] call main + [1] phi() + [2] call main to:@end -@end: scope:[] from @2 - [4] phi() +@end: scope:[] from @1 + [3] phi() (void()) main() -main: scope:[main] from @2 - [5] phi() - [6] call mulf_init +main: scope:[main] from @1 + [4] phi() + [5] call mulf_init to:main::@9 main::@9: scope:[main] from main - [7] phi() - [8] call prepareBobs + [6] phi() + [7] call prepareBobs to:main::@10 main::@10: scope:[main] from main::@9 - [9] phi() - [10] call renderBobInit + [8] phi() + [9] call renderBobInit to:main::vicSelectGfxBank1 main::vicSelectGfxBank1: scope:[main] from main::@10 - [11] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 + [10] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 to:main::vicSelectGfxBank1_toDd001 main::vicSelectGfxBank1_toDd001: scope:[main] from main::vicSelectGfxBank1 - [12] phi() + [11] phi() to:main::vicSelectGfxBank1_@1 main::vicSelectGfxBank1_@1: scope:[main] from main::vicSelectGfxBank1_toDd001 - [13] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank1_toDd001_return#0 + [12] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank1_toDd001_return#0 to:main::toD0181 main::toD0181: scope:[main] from main::vicSelectGfxBank1_@1 - [14] phi() + [13] phi() to:main::@7 main::@7: scope:[main] from main::toD0181 - [15] *((const byte*) D018) ← (const byte) main::toD0181_return#0 - [16] call memset + [14] *((const byte*) D018) ← (const byte) main::toD0181_return#0 + [15] call memset to:main::@1 main::@1: scope:[main] from main::@15 main::@7 - [17] (byte) main::angle#8 ← phi( main::@7/(byte) 0 main::@15/(byte) main::angle#1 ) + [16] (byte) main::angle#8 ← phi( main::@7/(byte) 0 main::@15/(byte) main::angle#1 ) to:main::@2 main::@2: scope:[main] from main::@1 main::@2 - [18] if(*((const byte*) RASTER)<(byte) $f8) goto main::@2 + [17] if(*((const byte*) RASTER)<(byte) $f8) goto main::@2 to:main::@3 main::@3: scope:[main] from main::@2 - [19] *((const byte*) BORDERCOL) ← (byte) $f - [20] call renderBobCleanup + [18] *((const byte*) BORDERCOL) ← (byte) $f + [19] call renderBobCleanup to:main::@11 main::@11: scope:[main] from main::@3 - [21] (byte) main::a#6 ← (byte) main::angle#8 + [20] (byte) main::a#6 ← (byte) main::angle#8 to:main::@4 main::@4: scope:[main] from main::@11 main::@14 - [22] (byte) main::i#2 ← phi( main::@11/(byte) 0 main::@14/(byte) main::i#1 ) - [22] (byte**) renderBobCleanupNext#17 ← phi( main::@11/(const byte**) RENDERBOB_CLEANUP main::@14/(byte**) renderBobCleanupNext#13 ) - [22] (byte) main::a#2 ← phi( main::@11/(byte) main::a#6 main::@14/(byte) main::a#1 ) - [22] (signed byte) main::r#2 ← phi( main::@11/(signed byte) $1e main::@14/(signed byte) main::r#1 ) - [23] *((const byte*) BORDERCOL) ← (byte) 1 - [24] (signed byte) mulf8s::a#0 ← (signed byte) main::r#2 - [25] (signed byte) mulf8s::b#0 ← *((const signed byte*) COS + (byte) main::a#2) - [26] call mulf8s - [27] (signed word) mulf8s::return#2 ← (signed word) mulf8s::return#0 + [21] (byte) main::i#2 ← phi( main::@11/(byte) 0 main::@14/(byte) main::i#1 ) + [21] (byte**) renderBobCleanupNext#17 ← phi( main::@11/(const byte**) RENDERBOB_CLEANUP main::@14/(byte**) renderBobCleanupNext#13 ) + [21] (byte) main::a#2 ← phi( main::@11/(byte) main::a#6 main::@14/(byte) main::a#1 ) + [21] (signed byte) main::r#2 ← phi( main::@11/(signed byte) $1e main::@14/(signed byte) main::r#1 ) + [22] *((const byte*) BORDERCOL) ← (byte) 1 + [23] (signed byte) mulf8s::a#0 ← (signed byte) main::r#2 + [24] (signed byte) mulf8s::b#0 ← *((const signed byte*) COS + (byte) main::a#2) + [25] call mulf8s + [26] (signed word) mulf8s::return#2 ← (signed word) mulf8s::return#0 to:main::@12 main::@12: scope:[main] from main::@4 - [28] (signed word~) main::$10 ← (signed word) mulf8s::return#2 - [29] (signed word) main::x#0 ← (signed word~) main::$10 + (signed word)(number) $4b*(number) $100 - [30] (signed byte) mulf8s::a#1 ← (signed byte) main::r#2 - [31] (signed byte) mulf8s::b#1 ← *((const signed byte*) SIN + (byte) main::a#2) - [32] call mulf8s - [33] (signed word) mulf8s::return#3 ← (signed word) mulf8s::return#0 + [27] (signed word~) main::$10 ← (signed word) mulf8s::return#2 + [28] (signed word) main::x#0 ← (signed word~) main::$10 + (signed word)(number) $4b*(number) $100 + [29] (signed byte) mulf8s::a#1 ← (signed byte) main::r#2 + [30] (signed byte) mulf8s::b#1 ← *((const signed byte*) SIN + (byte) main::a#2) + [31] call mulf8s + [32] (signed word) mulf8s::return#3 ← (signed word) mulf8s::return#0 to:main::@13 main::@13: scope:[main] from main::@12 - [34] (signed word~) main::$12 ← (signed word) mulf8s::return#3 - [35] (signed word~) main::$13 ← (signed word~) main::$12 << (byte) 1 - [36] (signed word) main::y#0 ← (signed word~) main::$13 + (signed word)(number) $5a*(number) $100 - [37] *((const byte*) BORDERCOL) ← (byte) 2 - [38] (byte) main::a#1 ← (byte) main::a#2 + (byte) $62 - [39] (signed byte) main::r#1 ← (signed byte) main::r#2 + (signed byte) 3 - [40] (byte) renderBob::xpos#0 ← > (signed word) main::x#0 - [41] (byte) renderBob::ypos#0 ← > (signed word) main::y#0 - [42] call renderBob + [33] (signed word~) main::$12 ← (signed word) mulf8s::return#3 + [34] (signed word~) main::$13 ← (signed word~) main::$12 << (byte) 1 + [35] (signed word) main::y#0 ← (signed word~) main::$13 + (signed word)(number) $5a*(number) $100 + [36] *((const byte*) BORDERCOL) ← (byte) 2 + [37] (byte) main::a#1 ← (byte) main::a#2 + (byte) $62 + [38] (signed byte) main::r#1 ← (signed byte) main::r#2 + (signed byte) 3 + [39] (byte) renderBob::xpos#0 ← > (signed word) main::x#0 + [40] (byte) renderBob::ypos#0 ← > (signed word) main::y#0 + [41] call renderBob to:main::@14 main::@14: scope:[main] from main::@13 - [43] (byte) main::i#1 ← ++ (byte) main::i#2 - [44] if((byte) main::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto main::@4 + [42] (byte) main::i#1 ← ++ (byte) main::i#2 + [43] if((byte) main::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto main::@4 to:main::@5 main::@5: scope:[main] from main::@14 - [45] (byte) main::angle#1 ← (byte) main::angle#8 + (byte) 3 - [46] *((const byte*) BORDERCOL) ← (byte) 0 - [47] call keyboard_key_pressed - [48] (byte) keyboard_key_pressed::return#2 ← (byte) keyboard_key_pressed::return#0 + [44] (byte) main::angle#1 ← (byte) main::angle#8 + (byte) 3 + [45] *((const byte*) BORDERCOL) ← (byte) 0 + [46] call keyboard_key_pressed + [47] (byte) keyboard_key_pressed::return#2 ← (byte) keyboard_key_pressed::return#0 to:main::@15 main::@15: scope:[main] from main::@5 - [49] (byte~) main::$19 ← (byte) keyboard_key_pressed::return#2 - [50] if((byte) 0!=(byte~) main::$19) goto main::@6 + [48] (byte~) main::$19 ← (byte) keyboard_key_pressed::return#2 + [49] if((byte) 0!=(byte~) main::$19) goto main::@6 to:main::@1 main::@6: scope:[main] from main::@15 main::@16 - [51] phi() - [52] call keyboard_key_pressed - [53] (byte) keyboard_key_pressed::return#3 ← (byte) keyboard_key_pressed::return#0 + [50] phi() + [51] call keyboard_key_pressed + [52] (byte) keyboard_key_pressed::return#3 ← (byte) keyboard_key_pressed::return#0 to:main::@16 main::@16: scope:[main] from main::@6 - [54] (byte~) main::$21 ← (byte) keyboard_key_pressed::return#3 - [55] if((byte) 0!=(byte~) main::$21) goto main::@6 + [53] (byte~) main::$21 ← (byte) keyboard_key_pressed::return#3 + [54] if((byte) 0!=(byte~) main::$21) goto main::@6 to:main::vicSelectGfxBank2 main::vicSelectGfxBank2: scope:[main] from main::@16 - [56] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 + [55] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 to:main::vicSelectGfxBank2_toDd001 main::vicSelectGfxBank2_toDd001: scope:[main] from main::vicSelectGfxBank2 - [57] phi() + [56] phi() to:main::vicSelectGfxBank2_@1 main::vicSelectGfxBank2_@1: scope:[main] from main::vicSelectGfxBank2_toDd001 - [58] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank2_toDd001_return#0 + [57] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank2_toDd001_return#0 to:main::toD0182 main::toD0182: scope:[main] from main::vicSelectGfxBank2_@1 - [59] phi() + [58] phi() to:main::@8 main::@8: scope:[main] from main::toD0182 - [60] *((const byte*) D018) ← (const byte) main::toD0182_return#0 + [59] *((const byte*) D018) ← (const byte) main::toD0182_return#0 to:main::@return main::@return: scope:[main] from main::@8 - [61] return + [60] return to:@return (byte()) keyboard_key_pressed((byte) keyboard_key_pressed::key) keyboard_key_pressed: scope:[keyboard_key_pressed] from main::@5 main::@6 - [62] phi() - [63] call keyboard_matrix_read - [64] (byte) keyboard_matrix_read::return#2 ← (byte) keyboard_matrix_read::return#0 + [61] phi() + [62] call keyboard_matrix_read + [63] (byte) keyboard_matrix_read::return#2 ← (byte) keyboard_matrix_read::return#0 to:keyboard_key_pressed::@1 keyboard_key_pressed::@1: scope:[keyboard_key_pressed] from keyboard_key_pressed - [65] (byte~) keyboard_key_pressed::$2 ← (byte) keyboard_matrix_read::return#2 - [66] (byte) keyboard_key_pressed::return#0 ← (byte~) keyboard_key_pressed::$2 & *((const byte*) keyboard_matrix_col_bitmask+(const byte) keyboard_key_pressed::colidx#0) + [64] (byte~) keyboard_key_pressed::$2 ← (byte) keyboard_matrix_read::return#2 + [65] (byte) keyboard_key_pressed::return#0 ← (byte~) keyboard_key_pressed::$2 & *((const byte*) keyboard_matrix_col_bitmask+(const byte) keyboard_key_pressed::colidx#0) to:keyboard_key_pressed::@return keyboard_key_pressed::@return: scope:[keyboard_key_pressed] from keyboard_key_pressed::@1 - [67] return + [66] return to:@return (byte()) keyboard_matrix_read((byte) keyboard_matrix_read::rowid) keyboard_matrix_read: scope:[keyboard_matrix_read] from keyboard_key_pressed - [68] *((const byte*) CIA1_PORT_A) ← *((const byte*) keyboard_matrix_row_bitmask+(const byte) keyboard_key_pressed::rowidx#0) - [69] (byte) keyboard_matrix_read::return#0 ← ~ *((const byte*) CIA1_PORT_B) + [67] *((const byte*) CIA1_PORT_A) ← *((const byte*) keyboard_matrix_row_bitmask+(const byte) keyboard_key_pressed::rowidx#0) + [68] (byte) keyboard_matrix_read::return#0 ← ~ *((const byte*) CIA1_PORT_B) to:keyboard_matrix_read::@return keyboard_matrix_read::@return: scope:[keyboard_matrix_read] from keyboard_matrix_read - [70] return + [69] return to:@return (void()) renderBob((byte) renderBob::xpos , (byte) renderBob::ypos) renderBob: scope:[renderBob] from main::@13 - [71] (byte) renderBob::x_char_offset#0 ← (byte) renderBob::xpos#0 >> (byte) 2 - [72] (byte) renderBob::y_char_offset#0 ← (byte) renderBob::ypos#0 >> (byte) 3 - [73] (byte~) renderBob::$8 ← (byte) renderBob::y_char_offset#0 << (byte) 1 - [74] (word) renderBob::y_offset#0 ← *((const word*) MUL40 + (byte~) renderBob::$8) - [75] (byte*~) renderBob::$2 ← (const byte*) BOB_SCREEN + (word) renderBob::y_offset#0 - [76] (byte*) renderBob::screen#0 ← (byte*~) renderBob::$2 + (byte) renderBob::x_char_offset#0 - [77] (byte~) renderBob::$4 ← (byte) renderBob::ypos#0 & (byte) 7 - [78] (byte~) renderBob::$5 ← (byte~) renderBob::$4 << (byte) 2 - [79] (byte~) renderBob::$6 ← (byte) renderBob::xpos#0 & (byte) 3 - [80] (byte) renderBob::bob_table_idx#0 ← (byte~) renderBob::$5 + (byte~) renderBob::$6 - [81] *((byte**) renderBobCleanupNext#17) ← (byte*) renderBob::screen#0 - [82] (byte**) renderBobCleanupNext#13 ← (byte**) renderBobCleanupNext#17 + (const byte) SIZEOF_POINTER - [83] *((byte*) renderBob::screen#0) ← *((const byte*) BOB_TABLES + (byte) renderBob::bob_table_idx#0) - [84] *((byte*) renderBob::screen#0 + (byte) $28) ← *((const byte*) BOB_TABLES+(byte) 1*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) - [85] *((byte*) renderBob::screen#0 + (byte) $50) ← *((const byte*) BOB_TABLES+(byte) 2*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) - [86] *((byte*) renderBob::screen#0 + (byte) 1) ← *((const byte*) BOB_TABLES+(byte) 3*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) - [87] *((byte*) renderBob::screen#0 + (byte) $29) ← *((const byte*) BOB_TABLES+(byte) 4*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) - [88] *((byte*) renderBob::screen#0 + (byte) $51) ← *((const byte*) BOB_TABLES+(byte) 5*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) - [89] *((byte*) renderBob::screen#0 + (byte) 2) ← *((const byte*) BOB_TABLES+(byte) 6*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) - [90] *((byte*) renderBob::screen#0 + (byte) $2a) ← *((const byte*) BOB_TABLES+(byte) 7*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) - [91] *((byte*) renderBob::screen#0 + (byte) $52) ← *((const byte*) BOB_TABLES+(byte) 8*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + [70] (byte) renderBob::x_char_offset#0 ← (byte) renderBob::xpos#0 >> (byte) 2 + [71] (byte) renderBob::y_char_offset#0 ← (byte) renderBob::ypos#0 >> (byte) 3 + [72] (byte~) renderBob::$8 ← (byte) renderBob::y_char_offset#0 << (byte) 1 + [73] (word) renderBob::y_offset#0 ← *((const word*) MUL40 + (byte~) renderBob::$8) + [74] (byte*~) renderBob::$2 ← (const byte*) BOB_SCREEN + (word) renderBob::y_offset#0 + [75] (byte*) renderBob::screen#0 ← (byte*~) renderBob::$2 + (byte) renderBob::x_char_offset#0 + [76] (byte~) renderBob::$4 ← (byte) renderBob::ypos#0 & (byte) 7 + [77] (byte~) renderBob::$5 ← (byte~) renderBob::$4 << (byte) 2 + [78] (byte~) renderBob::$6 ← (byte) renderBob::xpos#0 & (byte) 3 + [79] (byte) renderBob::bob_table_idx#0 ← (byte~) renderBob::$5 + (byte~) renderBob::$6 + [80] *((byte**) renderBobCleanupNext#17) ← (byte*) renderBob::screen#0 + [81] (byte**) renderBobCleanupNext#13 ← (byte**) renderBobCleanupNext#17 + (const byte) SIZEOF_POINTER + [82] *((byte*) renderBob::screen#0) ← *((const byte*) BOB_TABLES + (byte) renderBob::bob_table_idx#0) + [83] *((byte*) renderBob::screen#0 + (byte) $28) ← *((const byte*) BOB_TABLES+(byte) 1*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + [84] *((byte*) renderBob::screen#0 + (byte) $50) ← *((const byte*) BOB_TABLES+(byte) 2*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + [85] *((byte*) renderBob::screen#0 + (byte) 1) ← *((const byte*) BOB_TABLES+(byte) 3*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + [86] *((byte*) renderBob::screen#0 + (byte) $29) ← *((const byte*) BOB_TABLES+(byte) 4*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + [87] *((byte*) renderBob::screen#0 + (byte) $51) ← *((const byte*) BOB_TABLES+(byte) 5*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + [88] *((byte*) renderBob::screen#0 + (byte) 2) ← *((const byte*) BOB_TABLES+(byte) 6*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + [89] *((byte*) renderBob::screen#0 + (byte) $2a) ← *((const byte*) BOB_TABLES+(byte) 7*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) + [90] *((byte*) renderBob::screen#0 + (byte) $52) ← *((const byte*) BOB_TABLES+(byte) 8*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) to:renderBob::@return renderBob::@return: scope:[renderBob] from renderBob - [92] return + [91] return to:@return (signed word()) mulf8s((signed byte) mulf8s::a , (signed byte) mulf8s::b) mulf8s: scope:[mulf8s] from main::@12 main::@4 - [93] (signed byte) mulf8s::b#2 ← phi( main::@12/(signed byte) mulf8s::b#1 main::@4/(signed byte) mulf8s::b#0 ) - [93] (signed byte) mulf8s::mulf8s_prepare1_a#0 ← phi( main::@12/(signed byte) mulf8s::a#1 main::@4/(signed byte) mulf8s::a#0 ) + [92] (signed byte) mulf8s::b#2 ← phi( main::@12/(signed byte) mulf8s::b#1 main::@4/(signed byte) mulf8s::b#0 ) + [92] (signed byte) mulf8s::mulf8s_prepare1_a#0 ← phi( main::@12/(signed byte) mulf8s::a#1 main::@4/(signed byte) mulf8s::a#0 ) to:mulf8s::mulf8s_prepare1 mulf8s::mulf8s_prepare1: scope:[mulf8s] from mulf8s - [94] (byte) mulf8u_prepare::a#0 ← (byte)(signed byte) mulf8s::mulf8s_prepare1_a#0 - [95] call mulf8u_prepare + [93] (byte) mulf8u_prepare::a#0 ← (byte)(signed byte) mulf8s::mulf8s_prepare1_a#0 + [94] call mulf8u_prepare to:mulf8s::@1 mulf8s::@1: scope:[mulf8s] from mulf8s::mulf8s_prepare1 - [96] (signed byte) mulf8s_prepared::b#0 ← (signed byte) mulf8s::b#2 - [97] call mulf8s_prepared + [95] (signed byte) mulf8s_prepared::b#0 ← (signed byte) mulf8s::b#2 + [96] call mulf8s_prepared to:mulf8s::@2 mulf8s::@2: scope:[mulf8s] from mulf8s::@1 - [98] (signed word) mulf8s::return#0 ← (signed word)(word) mulf8s_prepared::m#4 + [97] (signed word) mulf8s::return#0 ← (signed word)(word) mulf8s_prepared::m#4 to:mulf8s::@return mulf8s::@return: scope:[mulf8s] from mulf8s::@2 - [99] return + [98] return to:@return (signed word()) mulf8s_prepared((signed byte) mulf8s_prepared::b) mulf8s_prepared: scope:[mulf8s_prepared] from mulf8s::@1 - [100] (byte) mulf8u_prepared::b#0 ← (byte)(signed byte) mulf8s_prepared::b#0 - [101] call mulf8u_prepared - [102] (word) mulf8u_prepared::return#2 ← (word) mulf8u_prepared::return#0 + [99] (byte) mulf8u_prepared::b#0 ← (byte)(signed byte) mulf8s_prepared::b#0 + [100] call mulf8u_prepared + [101] (word) mulf8u_prepared::return#2 ← (word) mulf8u_prepared::return#0 to:mulf8s_prepared::@5 mulf8s_prepared::@5: scope:[mulf8s_prepared] from mulf8s_prepared - [103] (word) mulf8s_prepared::m#0 ← (word) mulf8u_prepared::return#2 - [104] if(*((const signed byte*) mulf8s_prepared::memA)>=(signed byte) 0) goto mulf8s_prepared::@1 + [102] (word) mulf8s_prepared::m#0 ← (word) mulf8u_prepared::return#2 + [103] if(*((const signed byte*) mulf8s_prepared::memA)>=(signed byte) 0) goto mulf8s_prepared::@1 to:mulf8s_prepared::@3 mulf8s_prepared::@3: scope:[mulf8s_prepared] from mulf8s_prepared::@5 - [105] (byte~) mulf8s_prepared::$8 ← > (word) mulf8s_prepared::m#0 - [106] (byte~) mulf8s_prepared::$15 ← (byte~) mulf8s_prepared::$8 - (byte)(signed byte) mulf8s_prepared::b#0 - [107] (word) mulf8s_prepared::m#1 ← (word) mulf8s_prepared::m#0 hi= (byte~) mulf8s_prepared::$15 + [104] (byte~) mulf8s_prepared::$8 ← > (word) mulf8s_prepared::m#0 + [105] (byte~) mulf8s_prepared::$15 ← (byte~) mulf8s_prepared::$8 - (byte)(signed byte) mulf8s_prepared::b#0 + [106] (word) mulf8s_prepared::m#1 ← (word) mulf8s_prepared::m#0 hi= (byte~) mulf8s_prepared::$15 to:mulf8s_prepared::@1 mulf8s_prepared::@1: scope:[mulf8s_prepared] from mulf8s_prepared::@3 mulf8s_prepared::@5 - [108] (word) mulf8s_prepared::m#5 ← phi( mulf8s_prepared::@3/(word) mulf8s_prepared::m#1 mulf8s_prepared::@5/(word) mulf8s_prepared::m#0 ) - [109] if((signed byte) mulf8s_prepared::b#0>=(signed byte) 0) goto mulf8s_prepared::@2 + [107] (word) mulf8s_prepared::m#5 ← phi( mulf8s_prepared::@3/(word) mulf8s_prepared::m#1 mulf8s_prepared::@5/(word) mulf8s_prepared::m#0 ) + [108] if((signed byte) mulf8s_prepared::b#0>=(signed byte) 0) goto mulf8s_prepared::@2 to:mulf8s_prepared::@4 mulf8s_prepared::@4: scope:[mulf8s_prepared] from mulf8s_prepared::@1 - [110] (byte~) mulf8s_prepared::$12 ← > (word) mulf8s_prepared::m#5 - [111] (byte~) mulf8s_prepared::$16 ← (byte~) mulf8s_prepared::$12 - (byte)*((const signed byte*) mulf8s_prepared::memA) - [112] (word) mulf8s_prepared::m#2 ← (word) mulf8s_prepared::m#5 hi= (byte~) mulf8s_prepared::$16 + [109] (byte~) mulf8s_prepared::$12 ← > (word) mulf8s_prepared::m#5 + [110] (byte~) mulf8s_prepared::$16 ← (byte~) mulf8s_prepared::$12 - (byte)*((const signed byte*) mulf8s_prepared::memA) + [111] (word) mulf8s_prepared::m#2 ← (word) mulf8s_prepared::m#5 hi= (byte~) mulf8s_prepared::$16 to:mulf8s_prepared::@2 mulf8s_prepared::@2: scope:[mulf8s_prepared] from mulf8s_prepared::@1 mulf8s_prepared::@4 - [113] (word) mulf8s_prepared::m#4 ← phi( mulf8s_prepared::@1/(word) mulf8s_prepared::m#5 mulf8s_prepared::@4/(word) mulf8s_prepared::m#2 ) + [112] (word) mulf8s_prepared::m#4 ← phi( mulf8s_prepared::@1/(word) mulf8s_prepared::m#5 mulf8s_prepared::@4/(word) mulf8s_prepared::m#2 ) to:mulf8s_prepared::@return mulf8s_prepared::@return: scope:[mulf8s_prepared] from mulf8s_prepared::@2 - [114] return + [113] return to:@return (word()) mulf8u_prepared((byte) mulf8u_prepared::b) mulf8u_prepared: scope:[mulf8u_prepared] from mulf8s_prepared - [115] *((const byte*) mulf8u_prepared::memB) ← (byte) mulf8u_prepared::b#0 + [114] *((const byte*) mulf8u_prepared::memB) ← (byte) mulf8u_prepared::b#0 asm { ldxmemB sec sm1: ldamulf_sqr1_lo,x sm2: sbcmulf_sqr2_lo,x staresL sm3: ldamulf_sqr1_hi,x sm4: sbcmulf_sqr2_hi,x stamemB } - [117] (word) mulf8u_prepared::return#0 ← *((const byte*) mulf8u_prepared::memB) w= *((const byte*) mulf8u_prepared::resL) + [116] (word) mulf8u_prepared::return#0 ← *((const byte*) mulf8u_prepared::memB) w= *((const byte*) mulf8u_prepared::resL) to:mulf8u_prepared::@return mulf8u_prepared::@return: scope:[mulf8u_prepared] from mulf8u_prepared - [118] return + [117] return to:@return (void()) mulf8u_prepare((byte) mulf8u_prepare::a) mulf8u_prepare: scope:[mulf8u_prepare] from mulf8s::mulf8s_prepare1 - [119] *((const byte*) mulf8u_prepare::memA) ← (byte) mulf8u_prepare::a#0 + [118] *((const byte*) mulf8u_prepare::memA) ← (byte) mulf8u_prepare::a#0 asm { ldamemA stamulf8u_prepared.sm1+1 stamulf8u_prepared.sm3+1 eor#$ff stamulf8u_prepared.sm2+1 stamulf8u_prepared.sm4+1 } to:mulf8u_prepare::@return mulf8u_prepare::@return: scope:[mulf8u_prepare] from mulf8u_prepare - [121] return + [120] return to:@return (void()) renderBobCleanup() renderBobCleanup: scope:[renderBobCleanup] from main::@3 - [122] phi() + [121] phi() to:renderBobCleanup::@1 renderBobCleanup::@1: scope:[renderBobCleanup] from renderBobCleanup renderBobCleanup::@1 - [123] (byte) renderBobCleanup::i#2 ← phi( renderBobCleanup/(byte) 0 renderBobCleanup::@1/(byte) renderBobCleanup::i#1 ) - [124] (byte~) renderBobCleanup::$1 ← (byte) renderBobCleanup::i#2 << (byte) 1 - [125] (byte*) renderBobCleanup::screen#0 ← *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobCleanup::$1) - [126] *((byte*) renderBobCleanup::screen#0) ← (byte) 0 - [127] *((byte*) renderBobCleanup::screen#0 + (byte) $28) ← (byte) 0 - [128] *((byte*) renderBobCleanup::screen#0 + (byte) $50) ← (byte) 0 - [129] *((byte*) renderBobCleanup::screen#0 + (byte) 1) ← (byte) 0 - [130] *((byte*) renderBobCleanup::screen#0 + (byte) $29) ← (byte) 0 - [131] *((byte*) renderBobCleanup::screen#0 + (byte) $51) ← (byte) 0 - [132] *((byte*) renderBobCleanup::screen#0 + (byte) 2) ← (byte) 0 - [133] *((byte*) renderBobCleanup::screen#0 + (byte) $2a) ← (byte) 0 - [134] *((byte*) renderBobCleanup::screen#0 + (byte) $52) ← (byte) 0 - [135] (byte) renderBobCleanup::i#1 ← ++ (byte) renderBobCleanup::i#2 - [136] if((byte) renderBobCleanup::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto renderBobCleanup::@1 + [122] (byte) renderBobCleanup::i#2 ← phi( renderBobCleanup/(byte) 0 renderBobCleanup::@1/(byte) renderBobCleanup::i#1 ) + [123] (byte~) renderBobCleanup::$1 ← (byte) renderBobCleanup::i#2 << (byte) 1 + [124] (byte*) renderBobCleanup::screen#0 ← *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobCleanup::$1) + [125] *((byte*) renderBobCleanup::screen#0) ← (byte) 0 + [126] *((byte*) renderBobCleanup::screen#0 + (byte) $28) ← (byte) 0 + [127] *((byte*) renderBobCleanup::screen#0 + (byte) $50) ← (byte) 0 + [128] *((byte*) renderBobCleanup::screen#0 + (byte) 1) ← (byte) 0 + [129] *((byte*) renderBobCleanup::screen#0 + (byte) $29) ← (byte) 0 + [130] *((byte*) renderBobCleanup::screen#0 + (byte) $51) ← (byte) 0 + [131] *((byte*) renderBobCleanup::screen#0 + (byte) 2) ← (byte) 0 + [132] *((byte*) renderBobCleanup::screen#0 + (byte) $2a) ← (byte) 0 + [133] *((byte*) renderBobCleanup::screen#0 + (byte) $52) ← (byte) 0 + [134] (byte) renderBobCleanup::i#1 ← ++ (byte) renderBobCleanup::i#2 + [135] if((byte) renderBobCleanup::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto renderBobCleanup::@1 to:renderBobCleanup::@return renderBobCleanup::@return: scope:[renderBobCleanup] from renderBobCleanup::@1 - [137] return + [136] return to:@return (void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num) memset: scope:[memset] from main::@7 - [138] phi() + [137] phi() to:memset::@1 memset::@1: scope:[memset] from memset memset::@2 - [139] (byte*) memset::dst#2 ← phi( memset/(byte*)(const void*) memset::str#0 memset::@2/(byte*) memset::dst#1 ) - [140] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 + [138] (byte*) memset::dst#2 ← phi( memset/(byte*)(const void*) memset::str#0 memset::@2/(byte*) memset::dst#1 ) + [139] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 to:memset::@return memset::@return: scope:[memset] from memset::@1 - [141] return + [140] return to:@return memset::@2: scope:[memset] from memset::@1 - [142] *((byte*) memset::dst#2) ← (const byte) memset::c#0 - [143] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2 + [141] *((byte*) memset::dst#2) ← (const byte) memset::c#0 + [142] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2 to:memset::@1 (void()) renderBobInit() renderBobInit: scope:[renderBobInit] from main::@10 - [144] phi() + [143] phi() to:renderBobInit::@1 renderBobInit::@1: scope:[renderBobInit] from renderBobInit renderBobInit::@1 - [145] (byte) renderBobInit::y#2 ← phi( renderBobInit/(byte) 0 renderBobInit::@1/(byte) renderBobInit::y#1 ) - [146] (word~) renderBobInit::$0 ← (word)(byte) renderBobInit::y#2 - [147] (word~) renderBobInit::$6 ← (word~) renderBobInit::$0 << (byte) 2 - [148] (word~) renderBobInit::$7 ← (word~) renderBobInit::$6 + (word~) renderBobInit::$0 - [149] (word~) renderBobInit::$1 ← (word~) renderBobInit::$7 << (byte) 3 - [150] (byte~) renderBobInit::$4 ← (byte) renderBobInit::y#2 << (byte) 1 - [151] *((const word*) MUL40 + (byte~) renderBobInit::$4) ← (word~) renderBobInit::$1 - [152] (byte) renderBobInit::y#1 ← ++ (byte) renderBobInit::y#2 - [153] if((byte) renderBobInit::y#1!=(byte) $20) goto renderBobInit::@1 + [144] (byte) renderBobInit::y#2 ← phi( renderBobInit/(byte) 0 renderBobInit::@1/(byte) renderBobInit::y#1 ) + [145] (word~) renderBobInit::$0 ← (word)(byte) renderBobInit::y#2 + [146] (word~) renderBobInit::$6 ← (word~) renderBobInit::$0 << (byte) 2 + [147] (word~) renderBobInit::$7 ← (word~) renderBobInit::$6 + (word~) renderBobInit::$0 + [148] (word~) renderBobInit::$1 ← (word~) renderBobInit::$7 << (byte) 3 + [149] (byte~) renderBobInit::$4 ← (byte) renderBobInit::y#2 << (byte) 1 + [150] *((const word*) MUL40 + (byte~) renderBobInit::$4) ← (word~) renderBobInit::$1 + [151] (byte) renderBobInit::y#1 ← ++ (byte) renderBobInit::y#2 + [152] if((byte) renderBobInit::y#1!=(byte) $20) goto renderBobInit::@1 to:renderBobInit::@2 renderBobInit::@2: scope:[renderBobInit] from renderBobInit::@1 renderBobInit::@2 - [154] (byte) renderBobInit::i#2 ← phi( renderBobInit::@1/(byte) 0 renderBobInit::@2/(byte) renderBobInit::i#1 ) - [155] (byte~) renderBobInit::$5 ← (byte) renderBobInit::i#2 << (byte) 1 - [156] *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobInit::$5) ← (const byte*) BOB_SCREEN - [157] (byte) renderBobInit::i#1 ← ++ (byte) renderBobInit::i#2 - [158] if((byte) renderBobInit::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto renderBobInit::@2 + [153] (byte) renderBobInit::i#2 ← phi( renderBobInit::@1/(byte) 0 renderBobInit::@2/(byte) renderBobInit::i#1 ) + [154] (byte~) renderBobInit::$5 ← (byte) renderBobInit::i#2 << (byte) 1 + [155] *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobInit::$5) ← (const byte*) BOB_SCREEN + [156] (byte) renderBobInit::i#1 ← ++ (byte) renderBobInit::i#2 + [157] if((byte) renderBobInit::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto renderBobInit::@2 to:renderBobInit::@return renderBobInit::@return: scope:[renderBobInit] from renderBobInit::@2 - [159] return + [158] return to:@return (void()) prepareBobs() prepareBobs: scope:[prepareBobs] from main::@9 - [160] phi() - [161] call progress_init + [159] phi() + [160] call progress_init to:prepareBobs::@8 prepareBobs::@8: scope:[prepareBobs] from prepareBobs - [162] phi() - [163] call bobCharsetFindOrAddGlyph + [161] phi() + [162] call bobCharsetFindOrAddGlyph to:prepareBobs::@1 prepareBobs::@1: scope:[prepareBobs] from prepareBobs::@8 prepareBobs::@9 - [164] (byte) prepareBobs::bob_table_idx#6 ← phi( prepareBobs::@8/(byte) 0 prepareBobs::@9/(byte) prepareBobs::bob_table_idx#12 ) - [164] (byte) bob_charset_next_id#14 ← phi( prepareBobs::@8/(byte) bob_charset_next_id#16 prepareBobs::@9/(byte) bob_charset_next_id#30 ) - [164] (byte) progress_idx#16 ← phi( prepareBobs::@8/(byte) 0 prepareBobs::@9/(byte) progress_idx#31 ) - [164] (byte*) progress_cursor#15 ← phi( prepareBobs::@8/(const byte*) SCREEN_BASIC prepareBobs::@9/(byte*) progress_cursor#31 ) - [164] (byte) prepareBobs::shift_y#2 ← phi( prepareBobs::@8/(byte) 0 prepareBobs::@9/(byte) prepareBobs::shift_y#1 ) - [165] if((byte) prepareBobs::shift_y#2<(const byte) BOB_SHIFTS_Y) goto prepareBobs::@2 + [163] (byte) prepareBobs::bob_table_idx#6 ← phi( prepareBobs::@8/(byte) 0 prepareBobs::@9/(byte) prepareBobs::bob_table_idx#12 ) + [163] (byte) bob_charset_next_id#14 ← phi( prepareBobs::@8/(byte) bob_charset_next_id#16 prepareBobs::@9/(byte) bob_charset_next_id#30 ) + [163] (byte) progress_idx#16 ← phi( prepareBobs::@8/(byte) 0 prepareBobs::@9/(byte) progress_idx#31 ) + [163] (byte*) progress_cursor#15 ← phi( prepareBobs::@8/(const byte*) SCREEN_BASIC prepareBobs::@9/(byte*) progress_cursor#31 ) + [163] (byte) prepareBobs::shift_y#2 ← phi( prepareBobs::@8/(byte) 0 prepareBobs::@9/(byte) prepareBobs::shift_y#1 ) + [164] if((byte) prepareBobs::shift_y#2<(const byte) BOB_SHIFTS_Y) goto prepareBobs::@2 to:prepareBobs::@return prepareBobs::@return: scope:[prepareBobs] from prepareBobs::@1 - [166] return + [165] return to:@return prepareBobs::@2: scope:[prepareBobs] from prepareBobs::@1 prepareBobs::@13 - [167] (byte) progress_idx#31 ← phi( prepareBobs::@1/(byte) progress_idx#16 prepareBobs::@13/(byte) progress_idx#25 ) - [167] (byte*) progress_cursor#31 ← phi( prepareBobs::@1/(byte*) progress_cursor#15 prepareBobs::@13/(byte*) progress_cursor#24 ) - [167] (byte) bob_charset_next_id#30 ← phi( prepareBobs::@1/(byte) bob_charset_next_id#14 prepareBobs::@13/(byte) bob_charset_next_id#21 ) - [167] (byte) prepareBobs::bob_table_idx#12 ← phi( prepareBobs::@1/(byte) prepareBobs::bob_table_idx#6 prepareBobs::@13/(byte) prepareBobs::bob_table_idx#1 ) - [167] (byte) prepareBobs::shift_x#2 ← phi( prepareBobs::@1/(byte) 0 prepareBobs::@13/(byte) prepareBobs::shift_x#1 ) - [168] if((byte) prepareBobs::shift_x#2<(const byte) BOB_SHIFTS_X) goto prepareBobs::@3 + [166] (byte) progress_idx#31 ← phi( prepareBobs::@1/(byte) progress_idx#16 prepareBobs::@13/(byte) progress_idx#25 ) + [166] (byte*) progress_cursor#31 ← phi( prepareBobs::@1/(byte*) progress_cursor#15 prepareBobs::@13/(byte*) progress_cursor#24 ) + [166] (byte) bob_charset_next_id#30 ← phi( prepareBobs::@1/(byte) bob_charset_next_id#14 prepareBobs::@13/(byte) bob_charset_next_id#21 ) + [166] (byte) prepareBobs::bob_table_idx#12 ← phi( prepareBobs::@1/(byte) prepareBobs::bob_table_idx#6 prepareBobs::@13/(byte) prepareBobs::bob_table_idx#1 ) + [166] (byte) prepareBobs::shift_x#2 ← phi( prepareBobs::@1/(byte) 0 prepareBobs::@13/(byte) prepareBobs::shift_x#1 ) + [167] if((byte) prepareBobs::shift_x#2<(const byte) BOB_SHIFTS_X) goto prepareBobs::@3 to:prepareBobs::@4 prepareBobs::@4: scope:[prepareBobs] from prepareBobs::@2 - [169] phi() - [170] call shiftProtoBobDown + [168] phi() + [169] call shiftProtoBobDown to:prepareBobs::@9 prepareBobs::@9: scope:[prepareBobs] from prepareBobs::@4 - [171] (byte) prepareBobs::shift_y#1 ← ++ (byte) prepareBobs::shift_y#2 + [170] (byte) prepareBobs::shift_y#1 ← ++ (byte) prepareBobs::shift_y#2 to:prepareBobs::@1 prepareBobs::@3: scope:[prepareBobs] from prepareBobs::@2 - [172] (byte*) prepareBobs::bob_table#0 ← (const byte*) BOB_TABLES + (byte) prepareBobs::bob_table_idx#12 + [171] (byte*) prepareBobs::bob_table#0 ← (const byte*) BOB_TABLES + (byte) prepareBobs::bob_table_idx#12 to:prepareBobs::@5 prepareBobs::@5: scope:[prepareBobs] from prepareBobs::@11 prepareBobs::@3 - [173] (byte*) progress_cursor#24 ← phi( prepareBobs::@11/(byte*) progress_cursor#17 prepareBobs::@3/(byte*) progress_cursor#31 ) - [173] (byte) progress_idx#25 ← phi( prepareBobs::@11/(byte) progress_idx#10 prepareBobs::@3/(byte) progress_idx#31 ) - [173] (byte*) prepareBobs::bob_table#2 ← phi( prepareBobs::@11/(byte*) prepareBobs::bob_table#1 prepareBobs::@3/(byte*) prepareBobs::bob_table#0 ) - [173] (byte) bob_charset_next_id#21 ← phi( prepareBobs::@11/(byte) bob_charset_next_id#16 prepareBobs::@3/(byte) bob_charset_next_id#30 ) - [173] (byte*) prepareBobs::bob_glyph#2 ← phi( prepareBobs::@11/(byte*) prepareBobs::bob_glyph#1 prepareBobs::@3/(const byte*) PROTO_BOB ) - [173] (byte) prepareBobs::cell#2 ← phi( prepareBobs::@11/(byte) prepareBobs::cell#1 prepareBobs::@3/(byte) 0 ) - [174] if((byte) prepareBobs::cell#2<(byte) 9) goto prepareBobs::@6 + [172] (byte*) progress_cursor#24 ← phi( prepareBobs::@11/(byte*) progress_cursor#17 prepareBobs::@3/(byte*) progress_cursor#31 ) + [172] (byte) progress_idx#25 ← phi( prepareBobs::@11/(byte) progress_idx#10 prepareBobs::@3/(byte) progress_idx#31 ) + [172] (byte*) prepareBobs::bob_table#2 ← phi( prepareBobs::@11/(byte*) prepareBobs::bob_table#1 prepareBobs::@3/(byte*) prepareBobs::bob_table#0 ) + [172] (byte) bob_charset_next_id#21 ← phi( prepareBobs::@11/(byte) bob_charset_next_id#16 prepareBobs::@3/(byte) bob_charset_next_id#30 ) + [172] (byte*) prepareBobs::bob_glyph#2 ← phi( prepareBobs::@11/(byte*) prepareBobs::bob_glyph#1 prepareBobs::@3/(const byte*) PROTO_BOB ) + [172] (byte) prepareBobs::cell#2 ← phi( prepareBobs::@11/(byte) prepareBobs::cell#1 prepareBobs::@3/(byte) 0 ) + [173] if((byte) prepareBobs::cell#2<(byte) 9) goto prepareBobs::@6 to:prepareBobs::@7 prepareBobs::@7: scope:[prepareBobs] from prepareBobs::@5 - [175] (byte) prepareBobs::bob_table_idx#1 ← ++ (byte) prepareBobs::bob_table_idx#12 - [176] call shiftProtoBobRight + [174] (byte) prepareBobs::bob_table_idx#1 ← ++ (byte) prepareBobs::bob_table_idx#12 + [175] call shiftProtoBobRight to:prepareBobs::@12 prepareBobs::@12: scope:[prepareBobs] from prepareBobs::@7 - [177] phi() - [178] call shiftProtoBobRight + [176] phi() + [177] call shiftProtoBobRight to:prepareBobs::@13 prepareBobs::@13: scope:[prepareBobs] from prepareBobs::@12 - [179] (byte) prepareBobs::shift_x#1 ← ++ (byte) prepareBobs::shift_x#2 + [178] (byte) prepareBobs::shift_x#1 ← ++ (byte) prepareBobs::shift_x#2 to:prepareBobs::@2 prepareBobs::@6: scope:[prepareBobs] from prepareBobs::@5 - [180] (byte*) bobCharsetFindOrAddGlyph::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 - [181] call bobCharsetFindOrAddGlyph - [182] (byte) bobCharsetFindOrAddGlyph::return#1 ← (byte) bobCharsetFindOrAddGlyph::glyph_id#11 + [179] (byte*) bobCharsetFindOrAddGlyph::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 + [180] call bobCharsetFindOrAddGlyph + [181] (byte) bobCharsetFindOrAddGlyph::return#1 ← (byte) bobCharsetFindOrAddGlyph::glyph_id#11 to:prepareBobs::@10 prepareBobs::@10: scope:[prepareBobs] from prepareBobs::@6 - [183] (byte~) prepareBobs::$6 ← (byte) bobCharsetFindOrAddGlyph::return#1 - [184] *((byte*) prepareBobs::bob_table#2) ← (byte~) prepareBobs::$6 - [185] (byte*) prepareBobs::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 + (byte) 8 - [186] (byte*) prepareBobs::bob_table#1 ← (byte*) prepareBobs::bob_table#2 + (const byte) BOB_SHIFTS_X*(const byte) BOB_SHIFTS_Y - [187] call progress_inc + [182] (byte~) prepareBobs::$6 ← (byte) bobCharsetFindOrAddGlyph::return#1 + [183] *((byte*) prepareBobs::bob_table#2) ← (byte~) prepareBobs::$6 + [184] (byte*) prepareBobs::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 + (byte) 8 + [185] (byte*) prepareBobs::bob_table#1 ← (byte*) prepareBobs::bob_table#2 + (const byte) BOB_SHIFTS_X*(const byte) BOB_SHIFTS_Y + [186] call progress_inc to:prepareBobs::@11 prepareBobs::@11: scope:[prepareBobs] from prepareBobs::@10 - [188] (byte) prepareBobs::cell#1 ← ++ (byte) prepareBobs::cell#2 + [187] (byte) prepareBobs::cell#1 ← ++ (byte) prepareBobs::cell#2 to:prepareBobs::@5 (void()) progress_inc() progress_inc: scope:[progress_inc] from prepareBobs::@10 - [189] (byte) progress_idx#8 ← ++ (byte) progress_idx#25 - [190] if((byte) progress_idx#8!=(byte) 8) goto progress_inc::@1 + [188] (byte) progress_idx#8 ← ++ (byte) progress_idx#25 + [189] if((byte) progress_idx#8!=(byte) 8) goto progress_inc::@1 to:progress_inc::@2 progress_inc::@2: scope:[progress_inc] from progress_inc - [191] *((byte*) progress_cursor#24) ← *((const byte*) progress_inc::progress_chars+(byte) 8) - [192] (byte*) progress_cursor#8 ← ++ (byte*) progress_cursor#24 + [190] *((byte*) progress_cursor#24) ← *((const byte*) progress_inc::progress_chars+(byte) 8) + [191] (byte*) progress_cursor#8 ← ++ (byte*) progress_cursor#24 to:progress_inc::@1 progress_inc::@1: scope:[progress_inc] from progress_inc progress_inc::@2 - [193] (byte*) progress_cursor#17 ← phi( progress_inc/(byte*) progress_cursor#24 progress_inc::@2/(byte*) progress_cursor#8 ) - [193] (byte) progress_idx#10 ← phi( progress_inc/(byte) progress_idx#8 progress_inc::@2/(byte) 0 ) - [194] *((byte*) progress_cursor#17) ← *((const byte*) progress_inc::progress_chars + (byte) progress_idx#10) + [192] (byte*) progress_cursor#17 ← phi( progress_inc/(byte*) progress_cursor#24 progress_inc::@2/(byte*) progress_cursor#8 ) + [192] (byte) progress_idx#10 ← phi( progress_inc/(byte) progress_idx#8 progress_inc::@2/(byte) 0 ) + [193] *((byte*) progress_cursor#17) ← *((const byte*) progress_inc::progress_chars + (byte) progress_idx#10) to:progress_inc::@return progress_inc::@return: scope:[progress_inc] from progress_inc::@1 - [195] return + [194] return to:@return (byte()) bobCharsetFindOrAddGlyph((byte*) bobCharsetFindOrAddGlyph::bob_glyph) bobCharsetFindOrAddGlyph: scope:[bobCharsetFindOrAddGlyph] from prepareBobs::@6 prepareBobs::@8 - [196] (byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 ← phi( prepareBobs::@8/(const byte*) PROTO_BOB+(byte) $30 prepareBobs::@6/(byte*) bobCharsetFindOrAddGlyph::bob_glyph#1 ) - [196] (byte) bob_charset_next_id#23 ← phi( prepareBobs::@8/(byte) 0 prepareBobs::@6/(byte) bob_charset_next_id#21 ) + [195] (byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 ← phi( prepareBobs::@8/(const byte*) PROTO_BOB+(byte) $30 prepareBobs::@6/(byte*) bobCharsetFindOrAddGlyph::bob_glyph#1 ) + [195] (byte) bob_charset_next_id#23 ← phi( prepareBobs::@8/(byte) 0 prepareBobs::@6/(byte) bob_charset_next_id#21 ) to:bobCharsetFindOrAddGlyph::@1 bobCharsetFindOrAddGlyph::@1: scope:[bobCharsetFindOrAddGlyph] from bobCharsetFindOrAddGlyph bobCharsetFindOrAddGlyph::@6 - [197] (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 ← phi( bobCharsetFindOrAddGlyph/(const byte*) BOB_CHARSET bobCharsetFindOrAddGlyph::@6/(byte*) bobCharsetFindOrAddGlyph::glyph_cursor#1 ) - [197] (byte) bobCharsetFindOrAddGlyph::glyph_id#11 ← phi( bobCharsetFindOrAddGlyph/(byte) 0 bobCharsetFindOrAddGlyph::@6/(byte) bobCharsetFindOrAddGlyph::glyph_id#1 ) - [198] if((byte) bobCharsetFindOrAddGlyph::glyph_id#11!=(byte) bob_charset_next_id#23) goto bobCharsetFindOrAddGlyph::@2 + [196] (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 ← phi( bobCharsetFindOrAddGlyph/(const byte*) BOB_CHARSET bobCharsetFindOrAddGlyph::@6/(byte*) bobCharsetFindOrAddGlyph::glyph_cursor#1 ) + [196] (byte) bobCharsetFindOrAddGlyph::glyph_id#11 ← phi( bobCharsetFindOrAddGlyph/(byte) 0 bobCharsetFindOrAddGlyph::@6/(byte) bobCharsetFindOrAddGlyph::glyph_id#1 ) + [197] if((byte) bobCharsetFindOrAddGlyph::glyph_id#11!=(byte) bob_charset_next_id#23) goto bobCharsetFindOrAddGlyph::@2 to:bobCharsetFindOrAddGlyph::@7 bobCharsetFindOrAddGlyph::@7: scope:[bobCharsetFindOrAddGlyph] from bobCharsetFindOrAddGlyph::@1 bobCharsetFindOrAddGlyph::@8 - [199] (byte) bobCharsetFindOrAddGlyph::i1#2 ← phi( bobCharsetFindOrAddGlyph::@8/(byte) bobCharsetFindOrAddGlyph::i1#1 bobCharsetFindOrAddGlyph::@1/(byte) 0 ) - [200] if((byte) bobCharsetFindOrAddGlyph::i1#2<(byte) 8) goto bobCharsetFindOrAddGlyph::@8 + [198] (byte) bobCharsetFindOrAddGlyph::i1#2 ← phi( bobCharsetFindOrAddGlyph::@8/(byte) bobCharsetFindOrAddGlyph::i1#1 bobCharsetFindOrAddGlyph::@1/(byte) 0 ) + [199] if((byte) bobCharsetFindOrAddGlyph::i1#2<(byte) 8) goto bobCharsetFindOrAddGlyph::@8 to:bobCharsetFindOrAddGlyph::@9 bobCharsetFindOrAddGlyph::@9: scope:[bobCharsetFindOrAddGlyph] from bobCharsetFindOrAddGlyph::@7 - [201] (byte) bob_charset_next_id#8 ← ++ (byte) bob_charset_next_id#23 + [200] (byte) bob_charset_next_id#8 ← ++ (byte) bob_charset_next_id#23 to:bobCharsetFindOrAddGlyph::@return bobCharsetFindOrAddGlyph::@return: scope:[bobCharsetFindOrAddGlyph] from bobCharsetFindOrAddGlyph::@5 bobCharsetFindOrAddGlyph::@9 - [202] (byte) bob_charset_next_id#16 ← phi( bobCharsetFindOrAddGlyph::@5/(byte) bob_charset_next_id#23 bobCharsetFindOrAddGlyph::@9/(byte) bob_charset_next_id#8 ) - [203] return + [201] (byte) bob_charset_next_id#16 ← phi( bobCharsetFindOrAddGlyph::@5/(byte) bob_charset_next_id#23 bobCharsetFindOrAddGlyph::@9/(byte) bob_charset_next_id#8 ) + [202] return to:@return bobCharsetFindOrAddGlyph::@8: scope:[bobCharsetFindOrAddGlyph] from bobCharsetFindOrAddGlyph::@7 - [204] *((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) bobCharsetFindOrAddGlyph::i1#2) ← *((byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 + (byte) bobCharsetFindOrAddGlyph::i1#2) - [205] (byte) bobCharsetFindOrAddGlyph::i1#1 ← ++ (byte) bobCharsetFindOrAddGlyph::i1#2 + [203] *((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) bobCharsetFindOrAddGlyph::i1#2) ← *((byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 + (byte) bobCharsetFindOrAddGlyph::i1#2) + [204] (byte) bobCharsetFindOrAddGlyph::i1#1 ← ++ (byte) bobCharsetFindOrAddGlyph::i1#2 to:bobCharsetFindOrAddGlyph::@7 bobCharsetFindOrAddGlyph::@2: scope:[bobCharsetFindOrAddGlyph] from bobCharsetFindOrAddGlyph::@1 bobCharsetFindOrAddGlyph::@4 - [206] (byte) bobCharsetFindOrAddGlyph::i#2 ← phi( bobCharsetFindOrAddGlyph::@1/(byte) 0 bobCharsetFindOrAddGlyph::@4/(byte) bobCharsetFindOrAddGlyph::i#1 ) - [207] if((byte) bobCharsetFindOrAddGlyph::i#2<(byte) 8) goto bobCharsetFindOrAddGlyph::@3 + [205] (byte) bobCharsetFindOrAddGlyph::i#2 ← phi( bobCharsetFindOrAddGlyph::@1/(byte) 0 bobCharsetFindOrAddGlyph::@4/(byte) bobCharsetFindOrAddGlyph::i#1 ) + [206] if((byte) bobCharsetFindOrAddGlyph::i#2<(byte) 8) goto bobCharsetFindOrAddGlyph::@3 to:bobCharsetFindOrAddGlyph::@5 bobCharsetFindOrAddGlyph::@3: scope:[bobCharsetFindOrAddGlyph] from bobCharsetFindOrAddGlyph::@2 - [208] if(*((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) bobCharsetFindOrAddGlyph::i#2)==*((byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 + (byte) bobCharsetFindOrAddGlyph::i#2)) goto bobCharsetFindOrAddGlyph::@4 + [207] if(*((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) bobCharsetFindOrAddGlyph::i#2)==*((byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 + (byte) bobCharsetFindOrAddGlyph::i#2)) goto bobCharsetFindOrAddGlyph::@4 to:bobCharsetFindOrAddGlyph::@5 bobCharsetFindOrAddGlyph::@5: scope:[bobCharsetFindOrAddGlyph] from bobCharsetFindOrAddGlyph::@2 bobCharsetFindOrAddGlyph::@3 - [209] (byte) bobCharsetFindOrAddGlyph::found#2 ← phi( bobCharsetFindOrAddGlyph::@3/(byte) 0 bobCharsetFindOrAddGlyph::@2/(byte) 1 ) - [210] if((byte) 0==(byte) bobCharsetFindOrAddGlyph::found#2) goto bobCharsetFindOrAddGlyph::@6 + [208] (byte) bobCharsetFindOrAddGlyph::found#2 ← phi( bobCharsetFindOrAddGlyph::@3/(byte) 0 bobCharsetFindOrAddGlyph::@2/(byte) 1 ) + [209] if((byte) 0==(byte) bobCharsetFindOrAddGlyph::found#2) goto bobCharsetFindOrAddGlyph::@6 to:bobCharsetFindOrAddGlyph::@return bobCharsetFindOrAddGlyph::@6: scope:[bobCharsetFindOrAddGlyph] from bobCharsetFindOrAddGlyph::@5 - [211] (byte) bobCharsetFindOrAddGlyph::glyph_id#1 ← ++ (byte) bobCharsetFindOrAddGlyph::glyph_id#11 - [212] (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#1 ← (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) 8 + [210] (byte) bobCharsetFindOrAddGlyph::glyph_id#1 ← ++ (byte) bobCharsetFindOrAddGlyph::glyph_id#11 + [211] (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#1 ← (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) 8 to:bobCharsetFindOrAddGlyph::@1 bobCharsetFindOrAddGlyph::@4: scope:[bobCharsetFindOrAddGlyph] from bobCharsetFindOrAddGlyph::@3 - [213] (byte) bobCharsetFindOrAddGlyph::i#1 ← ++ (byte) bobCharsetFindOrAddGlyph::i#2 + [212] (byte) bobCharsetFindOrAddGlyph::i#1 ← ++ (byte) bobCharsetFindOrAddGlyph::i#2 to:bobCharsetFindOrAddGlyph::@2 (void()) shiftProtoBobRight() shiftProtoBobRight: scope:[shiftProtoBobRight] from prepareBobs::@12 prepareBobs::@7 - [214] phi() + [213] phi() to:shiftProtoBobRight::@1 shiftProtoBobRight::@1: scope:[shiftProtoBobRight] from shiftProtoBobRight shiftProtoBobRight::@6 - [215] (byte) shiftProtoBobRight::carry#2 ← phi( shiftProtoBobRight/(byte) 0 shiftProtoBobRight::@6/(byte) shiftProtoBobRight::carry#10 ) - [215] (byte) shiftProtoBobRight::j#3 ← phi( shiftProtoBobRight/(byte) 0 shiftProtoBobRight::@6/(byte) shiftProtoBobRight::j#10 ) - [215] (byte) shiftProtoBobRight::i#2 ← phi( shiftProtoBobRight/(byte) 0 shiftProtoBobRight::@6/(byte) shiftProtoBobRight::i#1 ) - [216] if((byte) shiftProtoBobRight::i#2<(byte)(number) 3*(number) 3*(number) 8) goto shiftProtoBobRight::@2 + [214] (byte) shiftProtoBobRight::carry#2 ← phi( shiftProtoBobRight/(byte) 0 shiftProtoBobRight::@6/(byte) shiftProtoBobRight::carry#10 ) + [214] (byte) shiftProtoBobRight::j#3 ← phi( shiftProtoBobRight/(byte) 0 shiftProtoBobRight::@6/(byte) shiftProtoBobRight::j#10 ) + [214] (byte) shiftProtoBobRight::i#2 ← phi( shiftProtoBobRight/(byte) 0 shiftProtoBobRight::@6/(byte) shiftProtoBobRight::i#1 ) + [215] if((byte) shiftProtoBobRight::i#2<(byte)(number) 3*(number) 3*(number) 8) goto shiftProtoBobRight::@2 to:shiftProtoBobRight::@return shiftProtoBobRight::@return: scope:[shiftProtoBobRight] from shiftProtoBobRight::@1 - [217] return + [216] return to:@return shiftProtoBobRight::@2: scope:[shiftProtoBobRight] from shiftProtoBobRight::@1 - [218] (byte~) shiftProtoBobRight::$1 ← *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) & (byte) 1 - [219] if((byte) 0!=(byte~) shiftProtoBobRight::$1) goto shiftProtoBobRight::@3 + [217] (byte~) shiftProtoBobRight::$1 ← *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) & (byte) 1 + [218] if((byte) 0!=(byte~) shiftProtoBobRight::$1) goto shiftProtoBobRight::@3 to:shiftProtoBobRight::@4 shiftProtoBobRight::@3: scope:[shiftProtoBobRight] from shiftProtoBobRight::@2 - [220] phi() + [219] phi() to:shiftProtoBobRight::@4 shiftProtoBobRight::@4: scope:[shiftProtoBobRight] from shiftProtoBobRight::@2 shiftProtoBobRight::@3 - [221] (byte) shiftProtoBobRight::carry#1 ← phi( shiftProtoBobRight::@3/(byte) $80 shiftProtoBobRight::@2/(byte) 0 ) - [222] (byte~) shiftProtoBobRight::$5 ← *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) >> (byte) 1 - [223] (byte~) shiftProtoBobRight::$6 ← (byte) shiftProtoBobRight::carry#2 | (byte~) shiftProtoBobRight::$5 - [224] *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) ← (byte~) shiftProtoBobRight::$6 - [225] if((byte) shiftProtoBobRight::j#3>=(byte) $30) goto shiftProtoBobRight::@5 + [220] (byte) shiftProtoBobRight::carry#1 ← phi( shiftProtoBobRight::@3/(byte) $80 shiftProtoBobRight::@2/(byte) 0 ) + [221] (byte~) shiftProtoBobRight::$5 ← *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) >> (byte) 1 + [222] (byte~) shiftProtoBobRight::$6 ← (byte) shiftProtoBobRight::carry#2 | (byte~) shiftProtoBobRight::$5 + [223] *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) ← (byte~) shiftProtoBobRight::$6 + [224] if((byte) shiftProtoBobRight::j#3>=(byte) $30) goto shiftProtoBobRight::@5 to:shiftProtoBobRight::@7 shiftProtoBobRight::@7: scope:[shiftProtoBobRight] from shiftProtoBobRight::@4 - [226] (byte) shiftProtoBobRight::j#2 ← (byte) shiftProtoBobRight::j#3 + (byte) $18 + [225] (byte) shiftProtoBobRight::j#2 ← (byte) shiftProtoBobRight::j#3 + (byte) $18 to:shiftProtoBobRight::@6 shiftProtoBobRight::@6: scope:[shiftProtoBobRight] from shiftProtoBobRight::@5 shiftProtoBobRight::@7 - [227] (byte) shiftProtoBobRight::j#10 ← phi( shiftProtoBobRight::@7/(byte) shiftProtoBobRight::j#2 shiftProtoBobRight::@5/(byte) shiftProtoBobRight::j#1 ) - [228] (byte) shiftProtoBobRight::i#1 ← ++ (byte) shiftProtoBobRight::i#2 - [229] (byte) shiftProtoBobRight::carry#10 ← (byte) shiftProtoBobRight::carry#1 + [226] (byte) shiftProtoBobRight::j#10 ← phi( shiftProtoBobRight::@7/(byte) shiftProtoBobRight::j#2 shiftProtoBobRight::@5/(byte) shiftProtoBobRight::j#1 ) + [227] (byte) shiftProtoBobRight::i#1 ← ++ (byte) shiftProtoBobRight::i#2 + [228] (byte) shiftProtoBobRight::carry#10 ← (byte) shiftProtoBobRight::carry#1 to:shiftProtoBobRight::@1 shiftProtoBobRight::@5: scope:[shiftProtoBobRight] from shiftProtoBobRight::@4 - [230] (byte) shiftProtoBobRight::j#1 ← (byte) shiftProtoBobRight::j#3 - (byte) $2f + [229] (byte) shiftProtoBobRight::j#1 ← (byte) shiftProtoBobRight::j#3 - (byte) $2f to:shiftProtoBobRight::@6 (void()) shiftProtoBobDown() shiftProtoBobDown: scope:[shiftProtoBobDown] from prepareBobs::@4 - [231] phi() + [230] phi() to:shiftProtoBobDown::@1 shiftProtoBobDown::@1: scope:[shiftProtoBobDown] from shiftProtoBobDown shiftProtoBobDown::@2 - [232] (byte) shiftProtoBobDown::i#2 ← phi( shiftProtoBobDown/(byte) $17 shiftProtoBobDown::@2/(byte) shiftProtoBobDown::i#1 ) - [233] if((byte) shiftProtoBobDown::i#2>(byte) 0) goto shiftProtoBobDown::@2 + [231] (byte) shiftProtoBobDown::i#2 ← phi( shiftProtoBobDown/(byte) $17 shiftProtoBobDown::@2/(byte) shiftProtoBobDown::i#1 ) + [232] if((byte) shiftProtoBobDown::i#2>(byte) 0) goto shiftProtoBobDown::@2 to:shiftProtoBobDown::@3 shiftProtoBobDown::@3: scope:[shiftProtoBobDown] from shiftProtoBobDown::@1 - [234] *((const byte*) PROTO_BOB) ← (byte) 0 - [235] *((const byte*) PROTO_BOB+(byte) $18) ← (byte) 0 - [236] *((const byte*) PROTO_BOB+(byte) $30) ← (byte) 0 + [233] *((const byte*) PROTO_BOB) ← (byte) 0 + [234] *((const byte*) PROTO_BOB+(byte) $18) ← (byte) 0 + [235] *((const byte*) PROTO_BOB+(byte) $30) ← (byte) 0 to:shiftProtoBobDown::@return shiftProtoBobDown::@return: scope:[shiftProtoBobDown] from shiftProtoBobDown::@3 - [237] return + [236] return to:@return shiftProtoBobDown::@2: scope:[shiftProtoBobDown] from shiftProtoBobDown::@1 - [238] *((const byte*) PROTO_BOB + (byte) shiftProtoBobDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $17 + (byte) shiftProtoBobDown::i#2) - [239] *((const byte*) PROTO_BOB+(byte) $18 + (byte) shiftProtoBobDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $2f + (byte) shiftProtoBobDown::i#2) - [240] *((const byte*) PROTO_BOB+(byte) $30 + (byte) shiftProtoBobDown::i#2) ← (byte) 0 - [241] (byte) shiftProtoBobDown::i#1 ← -- (byte) shiftProtoBobDown::i#2 + [237] *((const byte*) PROTO_BOB + (byte) shiftProtoBobDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $17 + (byte) shiftProtoBobDown::i#2) + [238] *((const byte*) PROTO_BOB+(byte) $18 + (byte) shiftProtoBobDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $2f + (byte) shiftProtoBobDown::i#2) + [239] *((const byte*) PROTO_BOB+(byte) $30 + (byte) shiftProtoBobDown::i#2) ← (byte) 0 + [240] (byte) shiftProtoBobDown::i#1 ← -- (byte) shiftProtoBobDown::i#2 to:shiftProtoBobDown::@1 (void()) progress_init((byte*) progress_init::line) progress_init: scope:[progress_init] from prepareBobs - [242] phi() + [241] phi() to:progress_init::@return progress_init::@return: scope:[progress_init] from progress_init - [243] return + [242] return to:@return (void()) mulf_init() mulf_init: scope:[mulf_init] from main - [244] phi() + [243] phi() to:mulf_init::@1 mulf_init::@1: scope:[mulf_init] from mulf_init mulf_init::@3 - [245] (byte) mulf_init::x_2#3 ← phi( mulf_init/(byte) 0 mulf_init::@3/(byte) mulf_init::x_2#2 ) - [245] (byte*) mulf_init::sqr1_hi#2 ← phi( mulf_init/(const byte*) mulf_sqr1_hi+(byte) 1 mulf_init::@3/(byte*) mulf_init::sqr1_hi#1 ) - [245] (word) mulf_init::sqr#4 ← phi( mulf_init/(byte) 0 mulf_init::@3/(word) mulf_init::sqr#1 ) - [245] (byte) mulf_init::c#2 ← phi( mulf_init/(byte) 0 mulf_init::@3/(byte) mulf_init::c#1 ) - [245] (byte*) mulf_init::sqr1_lo#2 ← phi( mulf_init/(const byte*) mulf_sqr1_lo+(byte) 1 mulf_init::@3/(byte*) mulf_init::sqr1_lo#1 ) - [246] if((byte*) mulf_init::sqr1_lo#2!=(const byte*) mulf_sqr1_lo+(word) $200) goto mulf_init::@2 + [244] (byte) mulf_init::x_2#3 ← phi( mulf_init/(byte) 0 mulf_init::@3/(byte) mulf_init::x_2#2 ) + [244] (byte*) mulf_init::sqr1_hi#2 ← phi( mulf_init/(const byte*) mulf_sqr1_hi+(byte) 1 mulf_init::@3/(byte*) mulf_init::sqr1_hi#1 ) + [244] (word) mulf_init::sqr#4 ← phi( mulf_init/(byte) 0 mulf_init::@3/(word) mulf_init::sqr#1 ) + [244] (byte) mulf_init::c#2 ← phi( mulf_init/(byte) 0 mulf_init::@3/(byte) mulf_init::c#1 ) + [244] (byte*) mulf_init::sqr1_lo#2 ← phi( mulf_init/(const byte*) mulf_sqr1_lo+(byte) 1 mulf_init::@3/(byte*) mulf_init::sqr1_lo#1 ) + [245] if((byte*) mulf_init::sqr1_lo#2!=(const byte*) mulf_sqr1_lo+(word) $200) goto mulf_init::@2 to:mulf_init::@5 mulf_init::@5: scope:[mulf_init] from mulf_init::@1 mulf_init::@8 - [247] (byte) mulf_init::dir#2 ← phi( mulf_init::@8/(byte) mulf_init::dir#4 mulf_init::@1/(byte) $ff ) - [247] (byte*) mulf_init::sqr2_hi#2 ← phi( mulf_init::@8/(byte*) mulf_init::sqr2_hi#1 mulf_init::@1/(const byte*) mulf_sqr2_hi ) - [247] (byte) mulf_init::x_255#2 ← phi( mulf_init::@8/(byte) mulf_init::x_255#1 mulf_init::@1/(byte) -1 ) - [247] (byte*) mulf_init::sqr2_lo#2 ← phi( mulf_init::@8/(byte*) mulf_init::sqr2_lo#1 mulf_init::@1/(const byte*) mulf_sqr2_lo ) - [248] if((byte*) mulf_init::sqr2_lo#2!=(const byte*) mulf_sqr2_lo+(word) $1ff) goto mulf_init::@6 + [246] (byte) mulf_init::dir#2 ← phi( mulf_init::@8/(byte) mulf_init::dir#4 mulf_init::@1/(byte) $ff ) + [246] (byte*) mulf_init::sqr2_hi#2 ← phi( mulf_init::@8/(byte*) mulf_init::sqr2_hi#1 mulf_init::@1/(const byte*) mulf_sqr2_hi ) + [246] (byte) mulf_init::x_255#2 ← phi( mulf_init::@8/(byte) mulf_init::x_255#1 mulf_init::@1/(byte) -1 ) + [246] (byte*) mulf_init::sqr2_lo#2 ← phi( mulf_init::@8/(byte*) mulf_init::sqr2_lo#1 mulf_init::@1/(const byte*) mulf_sqr2_lo ) + [247] if((byte*) mulf_init::sqr2_lo#2!=(const byte*) mulf_sqr2_lo+(word) $1ff) goto mulf_init::@6 to:mulf_init::@7 mulf_init::@7: scope:[mulf_init] from mulf_init::@5 - [249] *((const byte*) mulf_sqr2_lo+(word) $1ff) ← *((const byte*) mulf_sqr1_lo+(word) $100) - [250] *((const byte*) mulf_sqr2_hi+(word) $1ff) ← *((const byte*) mulf_sqr1_hi+(word) $100) + [248] *((const byte*) mulf_sqr2_lo+(word) $1ff) ← *((const byte*) mulf_sqr1_lo+(word) $100) + [249] *((const byte*) mulf_sqr2_hi+(word) $1ff) ← *((const byte*) mulf_sqr1_hi+(word) $100) to:mulf_init::@return mulf_init::@return: scope:[mulf_init] from mulf_init::@7 - [251] return + [250] return to:@return mulf_init::@6: scope:[mulf_init] from mulf_init::@5 - [252] *((byte*) mulf_init::sqr2_lo#2) ← *((const byte*) mulf_sqr1_lo + (byte) mulf_init::x_255#2) - [253] *((byte*) mulf_init::sqr2_hi#2) ← *((const byte*) mulf_sqr1_hi + (byte) mulf_init::x_255#2) - [254] (byte*) mulf_init::sqr2_hi#1 ← ++ (byte*) mulf_init::sqr2_hi#2 - [255] (byte) mulf_init::x_255#1 ← (byte) mulf_init::x_255#2 + (byte) mulf_init::dir#2 - [256] if((byte) mulf_init::x_255#1!=(byte) 0) goto mulf_init::@9 + [251] *((byte*) mulf_init::sqr2_lo#2) ← *((const byte*) mulf_sqr1_lo + (byte) mulf_init::x_255#2) + [252] *((byte*) mulf_init::sqr2_hi#2) ← *((const byte*) mulf_sqr1_hi + (byte) mulf_init::x_255#2) + [253] (byte*) mulf_init::sqr2_hi#1 ← ++ (byte*) mulf_init::sqr2_hi#2 + [254] (byte) mulf_init::x_255#1 ← (byte) mulf_init::x_255#2 + (byte) mulf_init::dir#2 + [255] if((byte) mulf_init::x_255#1!=(byte) 0) goto mulf_init::@9 to:mulf_init::@8 mulf_init::@9: scope:[mulf_init] from mulf_init::@6 - [257] phi() + [256] phi() to:mulf_init::@8 mulf_init::@8: scope:[mulf_init] from mulf_init::@6 mulf_init::@9 - [258] (byte) mulf_init::dir#4 ← phi( mulf_init::@9/(byte) mulf_init::dir#2 mulf_init::@6/(byte) 1 ) - [259] (byte*) mulf_init::sqr2_lo#1 ← ++ (byte*) mulf_init::sqr2_lo#2 + [257] (byte) mulf_init::dir#4 ← phi( mulf_init::@9/(byte) mulf_init::dir#2 mulf_init::@6/(byte) 1 ) + [258] (byte*) mulf_init::sqr2_lo#1 ← ++ (byte*) mulf_init::sqr2_lo#2 to:mulf_init::@5 mulf_init::@2: scope:[mulf_init] from mulf_init::@1 - [260] (byte) mulf_init::c#1 ← ++ (byte) mulf_init::c#2 - [261] (byte~) mulf_init::$1 ← (byte) mulf_init::c#1 & (byte) 1 - [262] if((byte~) mulf_init::$1!=(byte) 0) goto mulf_init::@3 + [259] (byte) mulf_init::c#1 ← ++ (byte) mulf_init::c#2 + [260] (byte~) mulf_init::$1 ← (byte) mulf_init::c#1 & (byte) 1 + [261] if((byte~) mulf_init::$1!=(byte) 0) goto mulf_init::@3 to:mulf_init::@4 mulf_init::@4: scope:[mulf_init] from mulf_init::@2 - [263] (byte) mulf_init::x_2#1 ← ++ (byte) mulf_init::x_2#3 - [264] (word) mulf_init::sqr#2 ← ++ (word) mulf_init::sqr#4 + [262] (byte) mulf_init::x_2#1 ← ++ (byte) mulf_init::x_2#3 + [263] (word) mulf_init::sqr#2 ← ++ (word) mulf_init::sqr#4 to:mulf_init::@3 mulf_init::@3: scope:[mulf_init] from mulf_init::@2 mulf_init::@4 - [265] (byte) mulf_init::x_2#2 ← phi( mulf_init::@2/(byte) mulf_init::x_2#3 mulf_init::@4/(byte) mulf_init::x_2#1 ) - [265] (word) mulf_init::sqr#3 ← phi( mulf_init::@2/(word) mulf_init::sqr#4 mulf_init::@4/(word) mulf_init::sqr#2 ) - [266] (byte~) mulf_init::$4 ← < (word) mulf_init::sqr#3 - [267] *((byte*) mulf_init::sqr1_lo#2) ← (byte~) mulf_init::$4 - [268] (byte~) mulf_init::$5 ← > (word) mulf_init::sqr#3 - [269] *((byte*) mulf_init::sqr1_hi#2) ← (byte~) mulf_init::$5 - [270] (byte*) mulf_init::sqr1_hi#1 ← ++ (byte*) mulf_init::sqr1_hi#2 - [271] (word) mulf_init::sqr#1 ← (word) mulf_init::sqr#3 + (byte) mulf_init::x_2#2 - [272] (byte*) mulf_init::sqr1_lo#1 ← ++ (byte*) mulf_init::sqr1_lo#2 + [264] (byte) mulf_init::x_2#2 ← phi( mulf_init::@2/(byte) mulf_init::x_2#3 mulf_init::@4/(byte) mulf_init::x_2#1 ) + [264] (word) mulf_init::sqr#3 ← phi( mulf_init::@2/(word) mulf_init::sqr#4 mulf_init::@4/(word) mulf_init::sqr#2 ) + [265] (byte~) mulf_init::$4 ← < (word) mulf_init::sqr#3 + [266] *((byte*) mulf_init::sqr1_lo#2) ← (byte~) mulf_init::$4 + [267] (byte~) mulf_init::$5 ← > (word) mulf_init::sqr#3 + [268] *((byte*) mulf_init::sqr1_hi#2) ← (byte~) mulf_init::$5 + [269] (byte*) mulf_init::sqr1_hi#1 ← ++ (byte*) mulf_init::sqr1_hi#2 + [270] (word) mulf_init::sqr#1 ← (word) mulf_init::sqr#3 + (byte) mulf_init::x_2#2 + [271] (byte*) mulf_init::sqr1_lo#1 ← ++ (byte*) mulf_init::sqr1_lo#2 to:mulf_init::@1 @@ -5108,25 +5097,17 @@ Target platform is c64basic / MOS6502X .label renderBobCleanupNext = 5 // @begin __bbegin: + // [1] phi from @begin to @1 [phi:@begin->@1] +__b1_from___bbegin: jmp __b1 // @1 __b1: - // kickasm() {{ .const PHI = (1+sqrt(5))/2 }} - // Constants for KickAsm Vogel Sunflower - .const PHI = (1+sqrt(5))/2 - - - // [2] phi from @1 to @2 [phi:@1->@2] -__b2_from___b1: - jmp __b2 - // @2 -__b2: - // [3] call main - // [5] phi from @2 to main [phi:@2->main] -main_from___b2: + // [2] call main + // [4] phi from @1 to main [phi:@1->main] +main_from___b1: jsr main - // [4] phi from @2 to @end [phi:@2->@end] -__bend_from___b2: + // [3] phi from @1 to @end [phi:@1->@end] +__bend_from___b1: jmp __bend // @end __bend: @@ -5148,35 +5129,35 @@ main: { .label i = 7 // Render Rotated BOBs .label angle = 2 - // [6] call mulf_init - // [244] phi from main to mulf_init [phi:main->mulf_init] + // [5] call mulf_init + // [243] phi from main to mulf_init [phi:main->mulf_init] mulf_init_from_main: jsr mulf_init - // [7] phi from main to main::@9 [phi:main->main::@9] + // [6] phi from main to main::@9 [phi:main->main::@9] __b9_from_main: jmp __b9 // main::@9 __b9: - // [8] call prepareBobs - // [160] phi from main::@9 to prepareBobs [phi:main::@9->prepareBobs] + // [7] call prepareBobs + // [159] phi from main::@9 to prepareBobs [phi:main::@9->prepareBobs] prepareBobs_from___b9: jsr prepareBobs - // [9] phi from main::@9 to main::@10 [phi:main::@9->main::@10] + // [8] phi from main::@9 to main::@10 [phi:main::@9->main::@10] __b10_from___b9: jmp __b10 // main::@10 __b10: - // [10] call renderBobInit - // [144] phi from main::@10 to renderBobInit [phi:main::@10->renderBobInit] + // [9] call renderBobInit + // [143] phi from main::@10 to renderBobInit [phi:main::@10->renderBobInit] renderBobInit_from___b10: jsr renderBobInit jmp vicSelectGfxBank1 // main::vicSelectGfxBank1 vicSelectGfxBank1: - // [11] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 -- _deref_pbuc1=vbuc2 + // [10] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 -- _deref_pbuc1=vbuc2 lda #3 sta CIA2_PORT_A_DDR - // [12] phi from main::vicSelectGfxBank1 to main::vicSelectGfxBank1_toDd001 [phi:main::vicSelectGfxBank1->main::vicSelectGfxBank1_toDd001] + // [11] phi from main::vicSelectGfxBank1 to main::vicSelectGfxBank1_toDd001 [phi:main::vicSelectGfxBank1->main::vicSelectGfxBank1_toDd001] vicSelectGfxBank1_toDd001_from_vicSelectGfxBank1: jmp vicSelectGfxBank1_toDd001 // main::vicSelectGfxBank1_toDd001 @@ -5184,10 +5165,10 @@ main: { jmp vicSelectGfxBank1___b1 // main::vicSelectGfxBank1_@1 vicSelectGfxBank1___b1: - // [13] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank1_toDd001_return#0 -- _deref_pbuc1=vbuc2 + // [12] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank1_toDd001_return#0 -- _deref_pbuc1=vbuc2 lda #vicSelectGfxBank1_toDd001_return sta CIA2_PORT_A - // [14] phi from main::vicSelectGfxBank1_@1 to main::toD0181 [phi:main::vicSelectGfxBank1_@1->main::toD0181] + // [13] phi from main::vicSelectGfxBank1_@1 to main::toD0181 [phi:main::vicSelectGfxBank1_@1->main::toD0181] toD0181_from_vicSelectGfxBank1___b1: jmp toD0181 // main::toD0181 @@ -5195,16 +5176,16 @@ main: { jmp __b7 // main::@7 __b7: - // [15] *((const byte*) D018) ← (const byte) main::toD0181_return#0 -- _deref_pbuc1=vbuc2 + // [14] *((const byte*) D018) ← (const byte) main::toD0181_return#0 -- _deref_pbuc1=vbuc2 lda #toD0181_return sta D018 - // [16] call memset - // [138] phi from main::@7 to memset [phi:main::@7->memset] + // [15] call memset + // [137] phi from main::@7 to memset [phi:main::@7->memset] memset_from___b7: jsr memset - // [17] phi from main::@7 to main::@1 [phi:main::@7->main::@1] + // [16] phi from main::@7 to main::@1 [phi:main::@7->main::@1] __b1_from___b7: - // [17] phi (byte) main::angle#8 = (byte) 0 [phi:main::@7->main::@1#0] -- vbuz1=vbuc1 + // [16] phi (byte) main::angle#8 = (byte) 0 [phi:main::@7->main::@1#0] -- vbuz1=vbuc1 lda #0 sta.z angle jmp __b1 @@ -5213,68 +5194,68 @@ main: { jmp __b2 // main::@2 __b2: - // [18] if(*((const byte*) RASTER)<(byte) $f8) goto main::@2 -- _deref_pbuc1_lt_vbuc2_then_la1 + // [17] if(*((const byte*) RASTER)<(byte) $f8) goto main::@2 -- _deref_pbuc1_lt_vbuc2_then_la1 lda RASTER cmp #$f8 bcc __b2 jmp __b3 // main::@3 __b3: - // [19] *((const byte*) BORDERCOL) ← (byte) $f -- _deref_pbuc1=vbuc2 + // [18] *((const byte*) BORDERCOL) ← (byte) $f -- _deref_pbuc1=vbuc2 lda #$f sta BORDERCOL - // [20] call renderBobCleanup - // [122] phi from main::@3 to renderBobCleanup [phi:main::@3->renderBobCleanup] + // [19] call renderBobCleanup + // [121] phi from main::@3 to renderBobCleanup [phi:main::@3->renderBobCleanup] renderBobCleanup_from___b3: jsr renderBobCleanup jmp __b11 // main::@11 __b11: - // [21] (byte) main::a#6 ← (byte) main::angle#8 -- vbuz1=vbuz2 + // [20] (byte) main::a#6 ← (byte) main::angle#8 -- vbuz1=vbuz2 lda.z angle sta.z a - // [22] phi from main::@11 to main::@4 [phi:main::@11->main::@4] + // [21] phi from main::@11 to main::@4 [phi:main::@11->main::@4] __b4_from___b11: - // [22] phi (byte) main::i#2 = (byte) 0 [phi:main::@11->main::@4#0] -- vbuz1=vbuc1 + // [21] phi (byte) main::i#2 = (byte) 0 [phi:main::@11->main::@4#0] -- vbuz1=vbuc1 lda #0 sta.z i - // [22] phi (byte**) renderBobCleanupNext#17 = (const byte**) RENDERBOB_CLEANUP [phi:main::@11->main::@4#1] -- pptz1=pptc1 + // [21] phi (byte**) renderBobCleanupNext#17 = (const byte**) RENDERBOB_CLEANUP [phi:main::@11->main::@4#1] -- pptz1=pptc1 lda #RENDERBOB_CLEANUP sta.z renderBobCleanupNext+1 - // [22] phi (byte) main::a#2 = (byte) main::a#6 [phi:main::@11->main::@4#2] -- register_copy - // [22] phi (signed byte) main::r#2 = (signed byte) $1e [phi:main::@11->main::@4#3] -- vbsz1=vbsc1 + // [21] phi (byte) main::a#2 = (byte) main::a#6 [phi:main::@11->main::@4#2] -- register_copy + // [21] phi (signed byte) main::r#2 = (signed byte) $1e [phi:main::@11->main::@4#3] -- vbsz1=vbsc1 lda #$1e sta.z r jmp __b4 - // [22] phi from main::@14 to main::@4 [phi:main::@14->main::@4] + // [21] phi from main::@14 to main::@4 [phi:main::@14->main::@4] __b4_from___b14: - // [22] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@14->main::@4#0] -- register_copy - // [22] phi (byte**) renderBobCleanupNext#17 = (byte**) renderBobCleanupNext#13 [phi:main::@14->main::@4#1] -- register_copy - // [22] phi (byte) main::a#2 = (byte) main::a#1 [phi:main::@14->main::@4#2] -- register_copy - // [22] phi (signed byte) main::r#2 = (signed byte) main::r#1 [phi:main::@14->main::@4#3] -- register_copy + // [21] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@14->main::@4#0] -- register_copy + // [21] phi (byte**) renderBobCleanupNext#17 = (byte**) renderBobCleanupNext#13 [phi:main::@14->main::@4#1] -- register_copy + // [21] phi (byte) main::a#2 = (byte) main::a#1 [phi:main::@14->main::@4#2] -- register_copy + // [21] phi (signed byte) main::r#2 = (signed byte) main::r#1 [phi:main::@14->main::@4#3] -- register_copy jmp __b4 // main::@4 __b4: - // [23] *((const byte*) BORDERCOL) ← (byte) 1 -- _deref_pbuc1=vbuc2 + // [22] *((const byte*) BORDERCOL) ← (byte) 1 -- _deref_pbuc1=vbuc2 //kickasm {{ .break }} lda #1 sta BORDERCOL - // [24] (signed byte) mulf8s::a#0 ← (signed byte) main::r#2 -- vbsz1=vbsz2 + // [23] (signed byte) mulf8s::a#0 ← (signed byte) main::r#2 -- vbsz1=vbsz2 lda.z r sta.z mulf8s.a - // [25] (signed byte) mulf8s::b#0 ← *((const signed byte*) COS + (byte) main::a#2) -- vbsz1=pbsc1_derefidx_vbuz2 + // [24] (signed byte) mulf8s::b#0 ← *((const signed byte*) COS + (byte) main::a#2) -- vbsz1=pbsc1_derefidx_vbuz2 ldy.z a lda COS,y sta.z mulf8s.b - // [26] call mulf8s - // [93] phi from main::@4 to mulf8s [phi:main::@4->mulf8s] + // [25] call mulf8s + // [92] phi from main::@4 to mulf8s [phi:main::@4->mulf8s] mulf8s_from___b4: - // [93] phi (signed byte) mulf8s::b#2 = (signed byte) mulf8s::b#0 [phi:main::@4->mulf8s#0] -- register_copy - // [93] phi (signed byte) mulf8s::mulf8s_prepare1_a#0 = (signed byte) mulf8s::a#0 [phi:main::@4->mulf8s#1] -- register_copy + // [92] phi (signed byte) mulf8s::b#2 = (signed byte) mulf8s::b#0 [phi:main::@4->mulf8s#0] -- register_copy + // [92] phi (signed byte) mulf8s::mulf8s_prepare1_a#0 = (signed byte) mulf8s::a#0 [phi:main::@4->mulf8s#1] -- register_copy jsr mulf8s - // [27] (signed word) mulf8s::return#2 ← (signed word) mulf8s::return#0 -- vwsz1=vwsz2 + // [26] (signed word) mulf8s::return#2 ← (signed word) mulf8s::return#0 -- vwsz1=vwsz2 lda.z mulf8s.return sta.z mulf8s.return_1 lda.z mulf8s.return+1 @@ -5282,12 +5263,12 @@ main: { jmp __b12 // main::@12 __b12: - // [28] (signed word~) main::$10 ← (signed word) mulf8s::return#2 -- vwsz1=vwsz2 + // [27] (signed word~) main::$10 ← (signed word) mulf8s::return#2 -- vwsz1=vwsz2 lda.z mulf8s.return_1 sta.z __10 lda.z mulf8s.return_1+1 sta.z __10+1 - // [29] (signed word) main::x#0 ← (signed word~) main::$10 + (signed word)(number) $4b*(number) $100 -- vwsz1=vwsz2_plus_vwsc1 + // [28] (signed word) main::x#0 ← (signed word~) main::$10 + (signed word)(number) $4b*(number) $100 -- vwsz1=vwsz2_plus_vwsc1 lda.z __10 clc adc #<$4b*$100 @@ -5295,20 +5276,20 @@ main: { lda.z __10+1 adc #>$4b*$100 sta.z x+1 - // [30] (signed byte) mulf8s::a#1 ← (signed byte) main::r#2 -- vbsz1=vbsz2 + // [29] (signed byte) mulf8s::a#1 ← (signed byte) main::r#2 -- vbsz1=vbsz2 lda.z r sta.z mulf8s.a - // [31] (signed byte) mulf8s::b#1 ← *((const signed byte*) SIN + (byte) main::a#2) -- vbsz1=pbsc1_derefidx_vbuz2 + // [30] (signed byte) mulf8s::b#1 ← *((const signed byte*) SIN + (byte) main::a#2) -- vbsz1=pbsc1_derefidx_vbuz2 ldy.z a lda SIN,y sta.z mulf8s.b - // [32] call mulf8s - // [93] phi from main::@12 to mulf8s [phi:main::@12->mulf8s] + // [31] call mulf8s + // [92] phi from main::@12 to mulf8s [phi:main::@12->mulf8s] mulf8s_from___b12: - // [93] phi (signed byte) mulf8s::b#2 = (signed byte) mulf8s::b#1 [phi:main::@12->mulf8s#0] -- register_copy - // [93] phi (signed byte) mulf8s::mulf8s_prepare1_a#0 = (signed byte) mulf8s::a#1 [phi:main::@12->mulf8s#1] -- register_copy + // [92] phi (signed byte) mulf8s::b#2 = (signed byte) mulf8s::b#1 [phi:main::@12->mulf8s#0] -- register_copy + // [92] phi (signed byte) mulf8s::mulf8s_prepare1_a#0 = (signed byte) mulf8s::a#1 [phi:main::@12->mulf8s#1] -- register_copy jsr mulf8s - // [33] (signed word) mulf8s::return#3 ← (signed word) mulf8s::return#0 -- vwsz1=vwsz2 + // [32] (signed word) mulf8s::return#3 ← (signed word) mulf8s::return#0 -- vwsz1=vwsz2 lda.z mulf8s.return sta.z mulf8s.return_2 lda.z mulf8s.return+1 @@ -5316,19 +5297,19 @@ main: { jmp __b13 // main::@13 __b13: - // [34] (signed word~) main::$12 ← (signed word) mulf8s::return#3 -- vwsz1=vwsz2 + // [33] (signed word~) main::$12 ← (signed word) mulf8s::return#3 -- vwsz1=vwsz2 lda.z mulf8s.return_2 sta.z __12 lda.z mulf8s.return_2+1 sta.z __12+1 - // [35] (signed word~) main::$13 ← (signed word~) main::$12 << (byte) 1 -- vwsz1=vwsz2_rol_1 + // [34] (signed word~) main::$13 ← (signed word~) main::$12 << (byte) 1 -- vwsz1=vwsz2_rol_1 lda.z __12 asl sta.z __13 lda.z __12+1 rol sta.z __13+1 - // [36] (signed word) main::y#0 ← (signed word~) main::$13 + (signed word)(number) $5a*(number) $100 -- vwsz1=vwsz2_plus_vwsc1 + // [35] (signed word) main::y#0 ← (signed word~) main::$13 + (signed word)(number) $5a*(number) $100 -- vwsz1=vwsz2_plus_vwsc1 lda.z __13 clc adc #<$5a*$100 @@ -5336,96 +5317,96 @@ main: { lda.z __13+1 adc #>$5a*$100 sta.z y+1 - // [37] *((const byte*) BORDERCOL) ← (byte) 2 -- _deref_pbuc1=vbuc2 + // [36] *((const byte*) BORDERCOL) ← (byte) 2 -- _deref_pbuc1=vbuc2 lda #2 sta BORDERCOL - // [38] (byte) main::a#1 ← (byte) main::a#2 + (byte) $62 -- vbuz1=vbuz1_plus_vbuc1 + // [37] (byte) main::a#1 ← (byte) main::a#2 + (byte) $62 -- vbuz1=vbuz1_plus_vbuc1 lax.z a axs #-[$62] stx.z a - // [39] (signed byte) main::r#1 ← (signed byte) main::r#2 + (signed byte) 3 -- vbsz1=vbsz1_plus_vbsc1 + // [38] (signed byte) main::r#1 ← (signed byte) main::r#2 + (signed byte) 3 -- vbsz1=vbsz1_plus_vbsc1 lax.z r axs #-[3] stx.z r - // [40] (byte) renderBob::xpos#0 ← > (signed word) main::x#0 -- vbuz1=_hi_vwsz2 + // [39] (byte) renderBob::xpos#0 ← > (signed word) main::x#0 -- vbuz1=_hi_vwsz2 lda.z x+1 sta.z renderBob.xpos - // [41] (byte) renderBob::ypos#0 ← > (signed word) main::y#0 -- vbuz1=_hi_vwsz2 + // [40] (byte) renderBob::ypos#0 ← > (signed word) main::y#0 -- vbuz1=_hi_vwsz2 lda.z y+1 sta.z renderBob.ypos - // [42] call renderBob + // [41] call renderBob jsr renderBob jmp __b14 // main::@14 __b14: - // [43] (byte) main::i#1 ← ++ (byte) main::i#2 -- vbuz1=_inc_vbuz1 + // [42] (byte) main::i#1 ← ++ (byte) main::i#2 -- vbuz1=_inc_vbuz1 inc.z i - // [44] if((byte) main::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto main::@4 -- vbuz1_neq_vbuc1_then_la1 + // [43] if((byte) main::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto main::@4 -- vbuz1_neq_vbuc1_then_la1 lda #NUM_BOBS-1+1 cmp.z i bne __b4_from___b14 jmp __b5 // main::@5 __b5: - // [45] (byte) main::angle#1 ← (byte) main::angle#8 + (byte) 3 -- vbuz1=vbuz1_plus_vbuc1 + // [44] (byte) main::angle#1 ← (byte) main::angle#8 + (byte) 3 -- vbuz1=vbuz1_plus_vbuc1 lax.z angle axs #-[3] stx.z angle - // [46] *((const byte*) BORDERCOL) ← (byte) 0 -- _deref_pbuc1=vbuc2 + // [45] *((const byte*) BORDERCOL) ← (byte) 0 -- _deref_pbuc1=vbuc2 lda #0 sta BORDERCOL - // [47] call keyboard_key_pressed - // [62] phi from main::@5 to keyboard_key_pressed [phi:main::@5->keyboard_key_pressed] + // [46] call keyboard_key_pressed + // [61] phi from main::@5 to keyboard_key_pressed [phi:main::@5->keyboard_key_pressed] keyboard_key_pressed_from___b5: jsr keyboard_key_pressed - // [48] (byte) keyboard_key_pressed::return#2 ← (byte) keyboard_key_pressed::return#0 -- vbuz1=vbuz2 + // [47] (byte) keyboard_key_pressed::return#2 ← (byte) keyboard_key_pressed::return#0 -- vbuz1=vbuz2 lda.z keyboard_key_pressed.return sta.z keyboard_key_pressed.return_1 jmp __b15 // main::@15 __b15: - // [49] (byte~) main::$19 ← (byte) keyboard_key_pressed::return#2 -- vbuz1=vbuz2 + // [48] (byte~) main::$19 ← (byte) keyboard_key_pressed::return#2 -- vbuz1=vbuz2 lda.z keyboard_key_pressed.return_1 sta.z __19 - // [50] if((byte) 0!=(byte~) main::$19) goto main::@6 -- vbuc1_neq_vbuz1_then_la1 + // [49] if((byte) 0!=(byte~) main::$19) goto main::@6 -- vbuc1_neq_vbuz1_then_la1 lda #0 cmp.z __19 bne __b6_from___b15 - // [17] phi from main::@15 to main::@1 [phi:main::@15->main::@1] + // [16] phi from main::@15 to main::@1 [phi:main::@15->main::@1] __b1_from___b15: - // [17] phi (byte) main::angle#8 = (byte) main::angle#1 [phi:main::@15->main::@1#0] -- register_copy + // [16] phi (byte) main::angle#8 = (byte) main::angle#1 [phi:main::@15->main::@1#0] -- register_copy jmp __b1 // Wait for space release - // [51] phi from main::@15 main::@16 to main::@6 [phi:main::@15/main::@16->main::@6] + // [50] phi from main::@15 main::@16 to main::@6 [phi:main::@15/main::@16->main::@6] __b6_from___b15: __b6_from___b16: jmp __b6 // main::@6 __b6: - // [52] call keyboard_key_pressed - // [62] phi from main::@6 to keyboard_key_pressed [phi:main::@6->keyboard_key_pressed] + // [51] call keyboard_key_pressed + // [61] phi from main::@6 to keyboard_key_pressed [phi:main::@6->keyboard_key_pressed] keyboard_key_pressed_from___b6: jsr keyboard_key_pressed - // [53] (byte) keyboard_key_pressed::return#3 ← (byte) keyboard_key_pressed::return#0 -- vbuz1=vbuz2 + // [52] (byte) keyboard_key_pressed::return#3 ← (byte) keyboard_key_pressed::return#0 -- vbuz1=vbuz2 lda.z keyboard_key_pressed.return sta.z keyboard_key_pressed.return_2 jmp __b16 // main::@16 __b16: - // [54] (byte~) main::$21 ← (byte) keyboard_key_pressed::return#3 -- vbuz1=vbuz2 + // [53] (byte~) main::$21 ← (byte) keyboard_key_pressed::return#3 -- vbuz1=vbuz2 lda.z keyboard_key_pressed.return_2 sta.z __21 - // [55] if((byte) 0!=(byte~) main::$21) goto main::@6 -- vbuc1_neq_vbuz1_then_la1 + // [54] if((byte) 0!=(byte~) main::$21) goto main::@6 -- vbuc1_neq_vbuz1_then_la1 lda #0 cmp.z __21 bne __b6_from___b16 jmp vicSelectGfxBank2 // main::vicSelectGfxBank2 vicSelectGfxBank2: - // [56] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 -- _deref_pbuc1=vbuc2 + // [55] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 -- _deref_pbuc1=vbuc2 lda #3 sta CIA2_PORT_A_DDR - // [57] phi from main::vicSelectGfxBank2 to main::vicSelectGfxBank2_toDd001 [phi:main::vicSelectGfxBank2->main::vicSelectGfxBank2_toDd001] + // [56] phi from main::vicSelectGfxBank2 to main::vicSelectGfxBank2_toDd001 [phi:main::vicSelectGfxBank2->main::vicSelectGfxBank2_toDd001] vicSelectGfxBank2_toDd001_from_vicSelectGfxBank2: jmp vicSelectGfxBank2_toDd001 // main::vicSelectGfxBank2_toDd001 @@ -5433,10 +5414,10 @@ main: { jmp vicSelectGfxBank2___b1 // main::vicSelectGfxBank2_@1 vicSelectGfxBank2___b1: - // [58] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank2_toDd001_return#0 -- _deref_pbuc1=vbuc2 + // [57] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank2_toDd001_return#0 -- _deref_pbuc1=vbuc2 lda #vicSelectGfxBank2_toDd001_return sta CIA2_PORT_A - // [59] phi from main::vicSelectGfxBank2_@1 to main::toD0182 [phi:main::vicSelectGfxBank2_@1->main::toD0182] + // [58] phi from main::vicSelectGfxBank2_@1 to main::toD0182 [phi:main::vicSelectGfxBank2_@1->main::toD0182] toD0182_from_vicSelectGfxBank2___b1: jmp toD0182 // main::toD0182 @@ -5444,13 +5425,13 @@ main: { jmp __b8 // main::@8 __b8: - // [60] *((const byte*) D018) ← (const byte) main::toD0182_return#0 -- _deref_pbuc1=vbuc2 + // [59] *((const byte*) D018) ← (const byte) main::toD0182_return#0 -- _deref_pbuc1=vbuc2 lda #toD0182_return sta D018 jmp __breturn // main::@return __breturn: - // [61] return + // [60] return rts } // keyboard_key_pressed @@ -5465,25 +5446,25 @@ keyboard_key_pressed: { .label return = $4e .label return_1 = $48 .label return_2 = $4a - // [63] call keyboard_matrix_read + // [62] call keyboard_matrix_read jsr keyboard_matrix_read - // [64] (byte) keyboard_matrix_read::return#2 ← (byte) keyboard_matrix_read::return#0 -- vbuz1=vbuz2 + // [63] (byte) keyboard_matrix_read::return#2 ← (byte) keyboard_matrix_read::return#0 -- vbuz1=vbuz2 lda.z keyboard_matrix_read.return sta.z keyboard_matrix_read.return_1 jmp __b1 // keyboard_key_pressed::@1 __b1: - // [65] (byte~) keyboard_key_pressed::$2 ← (byte) keyboard_matrix_read::return#2 -- vbuz1=vbuz2 + // [64] (byte~) keyboard_key_pressed::$2 ← (byte) keyboard_matrix_read::return#2 -- vbuz1=vbuz2 lda.z keyboard_matrix_read.return_1 sta.z __2 - // [66] (byte) keyboard_key_pressed::return#0 ← (byte~) keyboard_key_pressed::$2 & *((const byte*) keyboard_matrix_col_bitmask+(const byte) keyboard_key_pressed::colidx#0) -- vbuz1=vbuz2_band__deref_pbuc1 + // [65] (byte) keyboard_key_pressed::return#0 ← (byte~) keyboard_key_pressed::$2 & *((const byte*) keyboard_matrix_col_bitmask+(const byte) keyboard_key_pressed::colidx#0) -- vbuz1=vbuz2_band__deref_pbuc1 lda keyboard_matrix_col_bitmask+colidx and.z __2 sta.z return jmp __breturn // keyboard_key_pressed::@return __breturn: - // [67] return + // [66] return rts } // keyboard_matrix_read @@ -5495,17 +5476,17 @@ keyboard_key_pressed: { keyboard_matrix_read: { .label return = $4f .label return_1 = $4c - // [68] *((const byte*) CIA1_PORT_A) ← *((const byte*) keyboard_matrix_row_bitmask+(const byte) keyboard_key_pressed::rowidx#0) -- _deref_pbuc1=_deref_pbuc2 + // [67] *((const byte*) CIA1_PORT_A) ← *((const byte*) keyboard_matrix_row_bitmask+(const byte) keyboard_key_pressed::rowidx#0) -- _deref_pbuc1=_deref_pbuc2 lda keyboard_matrix_row_bitmask+keyboard_key_pressed.rowidx sta CIA1_PORT_A - // [69] (byte) keyboard_matrix_read::return#0 ← ~ *((const byte*) CIA1_PORT_B) -- vbuz1=_bnot__deref_pbuc1 + // [68] (byte) keyboard_matrix_read::return#0 ← ~ *((const byte*) CIA1_PORT_B) -- vbuz1=_bnot__deref_pbuc1 lda CIA1_PORT_B eor #$ff sta.z return jmp __breturn // keyboard_matrix_read::@return __breturn: - // [70] return + // [69] return rts } // renderBob @@ -5526,28 +5507,28 @@ renderBob: { .label y_offset = $53 .label screen = $57 .label bob_table_idx = $5c - // [71] (byte) renderBob::x_char_offset#0 ← (byte) renderBob::xpos#0 >> (byte) 2 -- vbuz1=vbuz2_ror_2 + // [70] (byte) renderBob::x_char_offset#0 ← (byte) renderBob::xpos#0 >> (byte) 2 -- vbuz1=vbuz2_ror_2 lda.z xpos lsr lsr sta.z x_char_offset - // [72] (byte) renderBob::y_char_offset#0 ← (byte) renderBob::ypos#0 >> (byte) 3 -- vbuz1=vbuz2_ror_3 + // [71] (byte) renderBob::y_char_offset#0 ← (byte) renderBob::ypos#0 >> (byte) 3 -- vbuz1=vbuz2_ror_3 lda.z ypos lsr lsr lsr sta.z y_char_offset - // [73] (byte~) renderBob::$8 ← (byte) renderBob::y_char_offset#0 << (byte) 1 -- vbuz1=vbuz2_rol_1 + // [72] (byte~) renderBob::$8 ← (byte) renderBob::y_char_offset#0 << (byte) 1 -- vbuz1=vbuz2_rol_1 lda.z y_char_offset asl sta.z __8 - // [74] (word) renderBob::y_offset#0 ← *((const word*) MUL40 + (byte~) renderBob::$8) -- vwuz1=pwuc1_derefidx_vbuz2 + // [73] (word) renderBob::y_offset#0 ← *((const word*) MUL40 + (byte~) renderBob::$8) -- vwuz1=pwuc1_derefidx_vbuz2 ldy.z __8 lda MUL40,y sta.z y_offset lda MUL40+1,y sta.z y_offset+1 - // [75] (byte*~) renderBob::$2 ← (const byte*) BOB_SCREEN + (word) renderBob::y_offset#0 -- pbuz1=pbuc1_plus_vwuz2 + // [74] (byte*~) renderBob::$2 ← (const byte*) BOB_SCREEN + (word) renderBob::y_offset#0 -- pbuz1=pbuc1_plus_vwuz2 lda.z y_offset clc adc #BOB_SCREEN sta.z __2+1 - // [76] (byte*) renderBob::screen#0 ← (byte*~) renderBob::$2 + (byte) renderBob::x_char_offset#0 -- pbuz1=pbuz2_plus_vbuz3 + // [75] (byte*) renderBob::screen#0 ← (byte*~) renderBob::$2 + (byte) renderBob::x_char_offset#0 -- pbuz1=pbuz2_plus_vbuz3 lda.z x_char_offset clc adc.z __2 @@ -5563,32 +5544,32 @@ renderBob: { lda #0 adc.z __2+1 sta.z screen+1 - // [77] (byte~) renderBob::$4 ← (byte) renderBob::ypos#0 & (byte) 7 -- vbuz1=vbuz2_band_vbuc1 + // [76] (byte~) renderBob::$4 ← (byte) renderBob::ypos#0 & (byte) 7 -- vbuz1=vbuz2_band_vbuc1 lda #7 and.z ypos sta.z __4 - // [78] (byte~) renderBob::$5 ← (byte~) renderBob::$4 << (byte) 2 -- vbuz1=vbuz2_rol_2 + // [77] (byte~) renderBob::$5 ← (byte~) renderBob::$4 << (byte) 2 -- vbuz1=vbuz2_rol_2 lda.z __4 asl asl sta.z __5 - // [79] (byte~) renderBob::$6 ← (byte) renderBob::xpos#0 & (byte) 3 -- vbuz1=vbuz2_band_vbuc1 + // [78] (byte~) renderBob::$6 ← (byte) renderBob::xpos#0 & (byte) 3 -- vbuz1=vbuz2_band_vbuc1 lda #3 and.z xpos sta.z __6 - // [80] (byte) renderBob::bob_table_idx#0 ← (byte~) renderBob::$5 + (byte~) renderBob::$6 -- vbuz1=vbuz2_plus_vbuz3 + // [79] (byte) renderBob::bob_table_idx#0 ← (byte~) renderBob::$5 + (byte~) renderBob::$6 -- vbuz1=vbuz2_plus_vbuz3 lda.z __5 clc adc.z __6 sta.z bob_table_idx - // [81] *((byte**) renderBobCleanupNext#17) ← (byte*) renderBob::screen#0 -- _deref_pptz1=pbuz2 + // [80] *((byte**) renderBobCleanupNext#17) ← (byte*) renderBob::screen#0 -- _deref_pptz1=pbuz2 ldy #0 lda.z screen sta (renderBobCleanupNext),y iny lda.z screen+1 sta (renderBobCleanupNext),y - // [82] (byte**) renderBobCleanupNext#13 ← (byte**) renderBobCleanupNext#17 + (const byte) SIZEOF_POINTER -- pptz1=pptz1_plus_vbuc1 + // [81] (byte**) renderBobCleanupNext#13 ← (byte**) renderBobCleanupNext#17 + (const byte) SIZEOF_POINTER -- pptz1=pptz1_plus_vbuc1 lda #SIZEOF_POINTER clc adc.z renderBobCleanupNext @@ -5596,47 +5577,47 @@ renderBob: { bcc !+ inc.z renderBobCleanupNext+1 !: - // [83] *((byte*) renderBob::screen#0) ← *((const byte*) BOB_TABLES + (byte) renderBob::bob_table_idx#0) -- _deref_pbuz1=pbuc1_derefidx_vbuz2 + // [82] *((byte*) renderBob::screen#0) ← *((const byte*) BOB_TABLES + (byte) renderBob::bob_table_idx#0) -- _deref_pbuz1=pbuc1_derefidx_vbuz2 ldy.z bob_table_idx lda BOB_TABLES,y ldy #0 sta (screen),y - // [84] *((byte*) renderBob::screen#0 + (byte) $28) ← *((const byte*) BOB_TABLES+(byte) 1*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuz2 + // [83] *((byte*) renderBob::screen#0 + (byte) $28) ← *((const byte*) BOB_TABLES+(byte) 1*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuz2 ldy.z bob_table_idx lda BOB_TABLES+1*BOB_SUBTABLE_SIZE,y ldy #$28 sta (screen),y - // [85] *((byte*) renderBob::screen#0 + (byte) $50) ← *((const byte*) BOB_TABLES+(byte) 2*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuz2 + // [84] *((byte*) renderBob::screen#0 + (byte) $50) ← *((const byte*) BOB_TABLES+(byte) 2*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuz2 ldy.z bob_table_idx lda BOB_TABLES+2*BOB_SUBTABLE_SIZE,y ldy #$50 sta (screen),y - // [86] *((byte*) renderBob::screen#0 + (byte) 1) ← *((const byte*) BOB_TABLES+(byte) 3*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuz2 + // [85] *((byte*) renderBob::screen#0 + (byte) 1) ← *((const byte*) BOB_TABLES+(byte) 3*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuz2 ldy.z bob_table_idx lda BOB_TABLES+3*BOB_SUBTABLE_SIZE,y ldy #1 sta (screen),y - // [87] *((byte*) renderBob::screen#0 + (byte) $29) ← *((const byte*) BOB_TABLES+(byte) 4*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuz2 + // [86] *((byte*) renderBob::screen#0 + (byte) $29) ← *((const byte*) BOB_TABLES+(byte) 4*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuz2 ldy.z bob_table_idx lda BOB_TABLES+4*BOB_SUBTABLE_SIZE,y ldy #$29 sta (screen),y - // [88] *((byte*) renderBob::screen#0 + (byte) $51) ← *((const byte*) BOB_TABLES+(byte) 5*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuz2 + // [87] *((byte*) renderBob::screen#0 + (byte) $51) ← *((const byte*) BOB_TABLES+(byte) 5*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuz2 ldy.z bob_table_idx lda BOB_TABLES+5*BOB_SUBTABLE_SIZE,y ldy #$51 sta (screen),y - // [89] *((byte*) renderBob::screen#0 + (byte) 2) ← *((const byte*) BOB_TABLES+(byte) 6*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuz2 + // [88] *((byte*) renderBob::screen#0 + (byte) 2) ← *((const byte*) BOB_TABLES+(byte) 6*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuz2 ldy.z bob_table_idx lda BOB_TABLES+6*BOB_SUBTABLE_SIZE,y ldy #2 sta (screen),y - // [90] *((byte*) renderBob::screen#0 + (byte) $2a) ← *((const byte*) BOB_TABLES+(byte) 7*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuz2 + // [89] *((byte*) renderBob::screen#0 + (byte) $2a) ← *((const byte*) BOB_TABLES+(byte) 7*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuz2 ldy.z bob_table_idx lda BOB_TABLES+7*BOB_SUBTABLE_SIZE,y ldy #$2a sta (screen),y - // [91] *((byte*) renderBob::screen#0 + (byte) $52) ← *((const byte*) BOB_TABLES+(byte) 8*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuz2 + // [90] *((byte*) renderBob::screen#0 + (byte) $52) ← *((const byte*) BOB_TABLES+(byte) 8*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuz2 ldy.z bob_table_idx lda BOB_TABLES+8*BOB_SUBTABLE_SIZE,y ldy #$52 @@ -5644,7 +5625,7 @@ renderBob: { jmp __breturn // renderBob::@return __breturn: - // [92] return + // [91] return rts } // mulf8s @@ -5660,23 +5641,23 @@ mulf8s: { jmp mulf8s_prepare1 // mulf8s::mulf8s_prepare1 mulf8s_prepare1: - // [94] (byte) mulf8u_prepare::a#0 ← (byte)(signed byte) mulf8s::mulf8s_prepare1_a#0 -- vbuz1=vbuz2 + // [93] (byte) mulf8u_prepare::a#0 ← (byte)(signed byte) mulf8s::mulf8s_prepare1_a#0 -- vbuz1=vbuz2 lda.z mulf8s_prepare1_a sta.z mulf8u_prepare.a - // [95] call mulf8u_prepare + // [94] call mulf8u_prepare jsr mulf8u_prepare jmp __b1 // mulf8s::@1 __b1: - // [96] (signed byte) mulf8s_prepared::b#0 ← (signed byte) mulf8s::b#2 -- vbsz1=vbsz2 + // [95] (signed byte) mulf8s_prepared::b#0 ← (signed byte) mulf8s::b#2 -- vbsz1=vbsz2 lda.z b sta.z mulf8s_prepared.b - // [97] call mulf8s_prepared + // [96] call mulf8s_prepared jsr mulf8s_prepared jmp __b2 // mulf8s::@2 __b2: - // [98] (signed word) mulf8s::return#0 ← (signed word)(word) mulf8s_prepared::m#4 -- vwsz1=vwsz2 + // [97] (signed word) mulf8s::return#0 ← (signed word)(word) mulf8s_prepared::m#4 -- vwsz1=vwsz2 lda.z mulf8s_prepared.m sta.z return lda.z mulf8s_prepared.m+1 @@ -5684,7 +5665,7 @@ mulf8s: { jmp __breturn // mulf8s::@return __breturn: - // [99] return + // [98] return rts } // mulf8s_prepared @@ -5699,12 +5680,12 @@ mulf8s_prepared: { .label __16 = $67 .label m = $a .label b = $5e - // [100] (byte) mulf8u_prepared::b#0 ← (byte)(signed byte) mulf8s_prepared::b#0 -- vbuz1=vbuz2 + // [99] (byte) mulf8u_prepared::b#0 ← (byte)(signed byte) mulf8s_prepared::b#0 -- vbuz1=vbuz2 lda.z b sta.z mulf8u_prepared.b - // [101] call mulf8u_prepared + // [100] call mulf8u_prepared jsr mulf8u_prepared - // [102] (word) mulf8u_prepared::return#2 ← (word) mulf8u_prepared::return#0 -- vwuz1=vwuz2 + // [101] (word) mulf8u_prepared::return#2 ← (word) mulf8u_prepared::return#0 -- vwuz1=vwuz2 lda.z mulf8u_prepared.return sta.z mulf8u_prepared.return_1 lda.z mulf8u_prepared.return+1 @@ -5712,65 +5693,65 @@ mulf8s_prepared: { jmp __b5 // mulf8s_prepared::@5 __b5: - // [103] (word) mulf8s_prepared::m#0 ← (word) mulf8u_prepared::return#2 -- vwuz1=vwuz2 + // [102] (word) mulf8s_prepared::m#0 ← (word) mulf8u_prepared::return#2 -- vwuz1=vwuz2 lda.z mulf8u_prepared.return_1 sta.z m lda.z mulf8u_prepared.return_1+1 sta.z m+1 - // [104] if(*((const signed byte*) mulf8s_prepared::memA)>=(signed byte) 0) goto mulf8s_prepared::@1 -- _deref_pbsc1_ge_0_then_la1 + // [103] if(*((const signed byte*) mulf8s_prepared::memA)>=(signed byte) 0) goto mulf8s_prepared::@1 -- _deref_pbsc1_ge_0_then_la1 lda memA cmp #0 bpl __b1_from___b5 jmp __b3 // mulf8s_prepared::@3 __b3: - // [105] (byte~) mulf8s_prepared::$8 ← > (word) mulf8s_prepared::m#0 -- vbuz1=_hi_vwuz2 + // [104] (byte~) mulf8s_prepared::$8 ← > (word) mulf8s_prepared::m#0 -- vbuz1=_hi_vwuz2 lda.z m+1 sta.z __8 - // [106] (byte~) mulf8s_prepared::$15 ← (byte~) mulf8s_prepared::$8 - (byte)(signed byte) mulf8s_prepared::b#0 -- vbuz1=vbuz2_minus_vbuz3 + // [105] (byte~) mulf8s_prepared::$15 ← (byte~) mulf8s_prepared::$8 - (byte)(signed byte) mulf8s_prepared::b#0 -- vbuz1=vbuz2_minus_vbuz3 lda.z __8 sec sbc.z b sta.z __15 - // [107] (word) mulf8s_prepared::m#1 ← (word) mulf8s_prepared::m#0 hi= (byte~) mulf8s_prepared::$15 -- vwuz1=vwuz1_sethi_vbuz2 + // [106] (word) mulf8s_prepared::m#1 ← (word) mulf8s_prepared::m#0 hi= (byte~) mulf8s_prepared::$15 -- vwuz1=vwuz1_sethi_vbuz2 lda.z __15 sta.z m+1 - // [108] phi from mulf8s_prepared::@3 mulf8s_prepared::@5 to mulf8s_prepared::@1 [phi:mulf8s_prepared::@3/mulf8s_prepared::@5->mulf8s_prepared::@1] + // [107] phi from mulf8s_prepared::@3 mulf8s_prepared::@5 to mulf8s_prepared::@1 [phi:mulf8s_prepared::@3/mulf8s_prepared::@5->mulf8s_prepared::@1] __b1_from___b3: __b1_from___b5: - // [108] phi (word) mulf8s_prepared::m#5 = (word) mulf8s_prepared::m#1 [phi:mulf8s_prepared::@3/mulf8s_prepared::@5->mulf8s_prepared::@1#0] -- register_copy + // [107] phi (word) mulf8s_prepared::m#5 = (word) mulf8s_prepared::m#1 [phi:mulf8s_prepared::@3/mulf8s_prepared::@5->mulf8s_prepared::@1#0] -- register_copy jmp __b1 // mulf8s_prepared::@1 __b1: - // [109] if((signed byte) mulf8s_prepared::b#0>=(signed byte) 0) goto mulf8s_prepared::@2 -- vbsz1_ge_0_then_la1 + // [108] if((signed byte) mulf8s_prepared::b#0>=(signed byte) 0) goto mulf8s_prepared::@2 -- vbsz1_ge_0_then_la1 lda.z b cmp #0 bpl __b2_from___b1 jmp __b4 // mulf8s_prepared::@4 __b4: - // [110] (byte~) mulf8s_prepared::$12 ← > (word) mulf8s_prepared::m#5 -- vbuz1=_hi_vwuz2 + // [109] (byte~) mulf8s_prepared::$12 ← > (word) mulf8s_prepared::m#5 -- vbuz1=_hi_vwuz2 lda.z m+1 sta.z __12 - // [111] (byte~) mulf8s_prepared::$16 ← (byte~) mulf8s_prepared::$12 - (byte)*((const signed byte*) mulf8s_prepared::memA) -- vbuz1=vbuz2_minus__deref_pbuc1 + // [110] (byte~) mulf8s_prepared::$16 ← (byte~) mulf8s_prepared::$12 - (byte)*((const signed byte*) mulf8s_prepared::memA) -- vbuz1=vbuz2_minus__deref_pbuc1 lda.z __12 sec sbc memA sta.z __16 - // [112] (word) mulf8s_prepared::m#2 ← (word) mulf8s_prepared::m#5 hi= (byte~) mulf8s_prepared::$16 -- vwuz1=vwuz1_sethi_vbuz2 + // [111] (word) mulf8s_prepared::m#2 ← (word) mulf8s_prepared::m#5 hi= (byte~) mulf8s_prepared::$16 -- vwuz1=vwuz1_sethi_vbuz2 lda.z __16 sta.z m+1 - // [113] phi from mulf8s_prepared::@1 mulf8s_prepared::@4 to mulf8s_prepared::@2 [phi:mulf8s_prepared::@1/mulf8s_prepared::@4->mulf8s_prepared::@2] + // [112] phi from mulf8s_prepared::@1 mulf8s_prepared::@4 to mulf8s_prepared::@2 [phi:mulf8s_prepared::@1/mulf8s_prepared::@4->mulf8s_prepared::@2] __b2_from___b1: __b2_from___b4: - // [113] phi (word) mulf8s_prepared::m#4 = (word) mulf8s_prepared::m#5 [phi:mulf8s_prepared::@1/mulf8s_prepared::@4->mulf8s_prepared::@2#0] -- register_copy + // [112] phi (word) mulf8s_prepared::m#4 = (word) mulf8s_prepared::m#5 [phi:mulf8s_prepared::@1/mulf8s_prepared::@4->mulf8s_prepared::@2#0] -- register_copy jmp __b2 // mulf8s_prepared::@2 __b2: jmp __breturn // mulf8s_prepared::@return __breturn: - // [114] return + // [113] return rts } // mulf8u_prepared @@ -5783,7 +5764,7 @@ mulf8u_prepared: { .label return = $68 .label b = $61 .label return_1 = $62 - // [115] *((const byte*) mulf8u_prepared::memB) ← (byte) mulf8u_prepared::b#0 -- _deref_pbuc1=vbuz1 + // [114] *((const byte*) mulf8u_prepared::memB) ← (byte) mulf8u_prepared::b#0 -- _deref_pbuc1=vbuz1 lda.z b sta memB // asm { ldxmemB sec sm1: ldamulf_sqr1_lo,x sm2: sbcmulf_sqr2_lo,x staresL sm3: ldamulf_sqr1_hi,x sm4: sbcmulf_sqr2_hi,x stamemB } @@ -5799,7 +5780,7 @@ mulf8u_prepared: { sm4: sbc mulf_sqr2_hi,x sta memB - // [117] (word) mulf8u_prepared::return#0 ← *((const byte*) mulf8u_prepared::memB) w= *((const byte*) mulf8u_prepared::resL) -- vwuz1=_deref_pbuc1_word__deref_pbuc2 + // [116] (word) mulf8u_prepared::return#0 ← *((const byte*) mulf8u_prepared::memB) w= *((const byte*) mulf8u_prepared::resL) -- vwuz1=_deref_pbuc1_word__deref_pbuc2 lda resL sta.z return lda memB @@ -5807,7 +5788,7 @@ mulf8u_prepared: { jmp __breturn // mulf8u_prepared::@return __breturn: - // [118] return + // [117] return rts } // mulf8u_prepare @@ -5816,7 +5797,7 @@ mulf8u_prepared: { mulf8u_prepare: { .label memA = $fd .label a = $5d - // [119] *((const byte*) mulf8u_prepare::memA) ← (byte) mulf8u_prepare::a#0 -- _deref_pbuc1=vbuz1 + // [118] *((const byte*) mulf8u_prepare::memA) ← (byte) mulf8u_prepare::a#0 -- _deref_pbuc1=vbuz1 lda.z a sta memA // asm { ldamemA stamulf8u_prepared.sm1+1 stamulf8u_prepared.sm3+1 eor#$ff stamulf8u_prepared.sm2+1 stamulf8u_prepared.sm4+1 } @@ -5829,7 +5810,7 @@ mulf8u_prepare: { jmp __breturn // mulf8u_prepare::@return __breturn: - // [121] return + // [120] return rts } // renderBobCleanup @@ -5838,74 +5819,74 @@ renderBobCleanup: { .label __1 = $6a .label screen = $6b .label i = $c - // [123] phi from renderBobCleanup to renderBobCleanup::@1 [phi:renderBobCleanup->renderBobCleanup::@1] + // [122] phi from renderBobCleanup to renderBobCleanup::@1 [phi:renderBobCleanup->renderBobCleanup::@1] __b1_from_renderBobCleanup: - // [123] phi (byte) renderBobCleanup::i#2 = (byte) 0 [phi:renderBobCleanup->renderBobCleanup::@1#0] -- vbuz1=vbuc1 + // [122] phi (byte) renderBobCleanup::i#2 = (byte) 0 [phi:renderBobCleanup->renderBobCleanup::@1#0] -- vbuz1=vbuc1 lda #0 sta.z i jmp __b1 - // [123] phi from renderBobCleanup::@1 to renderBobCleanup::@1 [phi:renderBobCleanup::@1->renderBobCleanup::@1] + // [122] phi from renderBobCleanup::@1 to renderBobCleanup::@1 [phi:renderBobCleanup::@1->renderBobCleanup::@1] __b1_from___b1: - // [123] phi (byte) renderBobCleanup::i#2 = (byte) renderBobCleanup::i#1 [phi:renderBobCleanup::@1->renderBobCleanup::@1#0] -- register_copy + // [122] phi (byte) renderBobCleanup::i#2 = (byte) renderBobCleanup::i#1 [phi:renderBobCleanup::@1->renderBobCleanup::@1#0] -- register_copy jmp __b1 // renderBobCleanup::@1 __b1: - // [124] (byte~) renderBobCleanup::$1 ← (byte) renderBobCleanup::i#2 << (byte) 1 -- vbuz1=vbuz2_rol_1 + // [123] (byte~) renderBobCleanup::$1 ← (byte) renderBobCleanup::i#2 << (byte) 1 -- vbuz1=vbuz2_rol_1 lda.z i asl sta.z __1 - // [125] (byte*) renderBobCleanup::screen#0 ← *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobCleanup::$1) -- pbuz1=pptc1_derefidx_vbuz2 + // [124] (byte*) renderBobCleanup::screen#0 ← *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobCleanup::$1) -- pbuz1=pptc1_derefidx_vbuz2 ldy.z __1 lda RENDERBOB_CLEANUP,y sta.z screen lda RENDERBOB_CLEANUP+1,y sta.z screen+1 - // [126] *((byte*) renderBobCleanup::screen#0) ← (byte) 0 -- _deref_pbuz1=vbuc1 + // [125] *((byte*) renderBobCleanup::screen#0) ← (byte) 0 -- _deref_pbuz1=vbuc1 lda #0 ldy #0 sta (screen),y - // [127] *((byte*) renderBobCleanup::screen#0 + (byte) $28) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + // [126] *((byte*) renderBobCleanup::screen#0 + (byte) $28) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 lda #0 ldy #$28 sta (screen),y - // [128] *((byte*) renderBobCleanup::screen#0 + (byte) $50) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + // [127] *((byte*) renderBobCleanup::screen#0 + (byte) $50) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 lda #0 ldy #$50 sta (screen),y - // [129] *((byte*) renderBobCleanup::screen#0 + (byte) 1) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + // [128] *((byte*) renderBobCleanup::screen#0 + (byte) 1) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 lda #0 ldy #1 sta (screen),y - // [130] *((byte*) renderBobCleanup::screen#0 + (byte) $29) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + // [129] *((byte*) renderBobCleanup::screen#0 + (byte) $29) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 lda #0 ldy #$29 sta (screen),y - // [131] *((byte*) renderBobCleanup::screen#0 + (byte) $51) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + // [130] *((byte*) renderBobCleanup::screen#0 + (byte) $51) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 lda #0 ldy #$51 sta (screen),y - // [132] *((byte*) renderBobCleanup::screen#0 + (byte) 2) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + // [131] *((byte*) renderBobCleanup::screen#0 + (byte) 2) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 lda #0 ldy #2 sta (screen),y - // [133] *((byte*) renderBobCleanup::screen#0 + (byte) $2a) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + // [132] *((byte*) renderBobCleanup::screen#0 + (byte) $2a) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 lda #0 ldy #$2a sta (screen),y - // [134] *((byte*) renderBobCleanup::screen#0 + (byte) $52) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + // [133] *((byte*) renderBobCleanup::screen#0 + (byte) $52) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 lda #0 ldy #$52 sta (screen),y - // [135] (byte) renderBobCleanup::i#1 ← ++ (byte) renderBobCleanup::i#2 -- vbuz1=_inc_vbuz1 + // [134] (byte) renderBobCleanup::i#1 ← ++ (byte) renderBobCleanup::i#2 -- vbuz1=_inc_vbuz1 inc.z i - // [136] if((byte) renderBobCleanup::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto renderBobCleanup::@1 -- vbuz1_neq_vbuc1_then_la1 + // [135] if((byte) renderBobCleanup::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto renderBobCleanup::@1 -- vbuz1_neq_vbuc1_then_la1 lda #NUM_BOBS-1+1 cmp.z i bne __b1_from___b1 jmp __breturn // renderBobCleanup::@return __breturn: - // [137] return + // [136] return rts } // memset @@ -5916,9 +5897,9 @@ memset: { .const num = $3e8 .label end = str+num .label dst = $d - // [139] phi from memset to memset::@1 [phi:memset->memset::@1] + // [138] phi from memset to memset::@1 [phi:memset->memset::@1] __b1_from_memset: - // [139] phi (byte*) memset::dst#2 = (byte*)(const void*) memset::str#0 [phi:memset->memset::@1#0] -- pbuz1=pbuc1 + // [138] phi (byte*) memset::dst#2 = (byte*)(const void*) memset::str#0 [phi:memset->memset::@1#0] -- pbuz1=pbuc1 lda #str @@ -5926,7 +5907,7 @@ memset: { jmp __b1 // memset::@1 __b1: - // [140] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 -- pbuz1_neq_pbuc1_then_la1 + // [139] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 -- pbuz1_neq_pbuc1_then_la1 lda.z dst+1 cmp #>end bne __b2 @@ -5936,22 +5917,22 @@ memset: { jmp __breturn // memset::@return __breturn: - // [141] return + // [140] return rts // memset::@2 __b2: - // [142] *((byte*) memset::dst#2) ← (const byte) memset::c#0 -- _deref_pbuz1=vbuc1 + // [141] *((byte*) memset::dst#2) ← (const byte) memset::c#0 -- _deref_pbuz1=vbuc1 lda #c ldy #0 sta (dst),y - // [143] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2 -- pbuz1=_inc_pbuz1 + // [142] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2 -- pbuz1=_inc_pbuz1 inc.z dst bne !+ inc.z dst+1 !: - // [139] phi from memset::@2 to memset::@1 [phi:memset::@2->memset::@1] + // [138] phi from memset::@2 to memset::@1 [phi:memset::@2->memset::@1] __b1_from___b2: - // [139] phi (byte*) memset::dst#2 = (byte*) memset::dst#1 [phi:memset::@2->memset::@1#0] -- register_copy + // [138] phi (byte*) memset::dst#2 = (byte*) memset::dst#1 [phi:memset::@2->memset::@1#0] -- register_copy jmp __b1 } // renderBobInit @@ -5965,24 +5946,24 @@ renderBobInit: { .label i = $10 .label __6 = $6f .label __7 = $71 - // [145] phi from renderBobInit to renderBobInit::@1 [phi:renderBobInit->renderBobInit::@1] + // [144] phi from renderBobInit to renderBobInit::@1 [phi:renderBobInit->renderBobInit::@1] __b1_from_renderBobInit: - // [145] phi (byte) renderBobInit::y#2 = (byte) 0 [phi:renderBobInit->renderBobInit::@1#0] -- vbuz1=vbuc1 + // [144] phi (byte) renderBobInit::y#2 = (byte) 0 [phi:renderBobInit->renderBobInit::@1#0] -- vbuz1=vbuc1 lda #0 sta.z y jmp __b1 - // [145] phi from renderBobInit::@1 to renderBobInit::@1 [phi:renderBobInit::@1->renderBobInit::@1] + // [144] phi from renderBobInit::@1 to renderBobInit::@1 [phi:renderBobInit::@1->renderBobInit::@1] __b1_from___b1: - // [145] phi (byte) renderBobInit::y#2 = (byte) renderBobInit::y#1 [phi:renderBobInit::@1->renderBobInit::@1#0] -- register_copy + // [144] phi (byte) renderBobInit::y#2 = (byte) renderBobInit::y#1 [phi:renderBobInit::@1->renderBobInit::@1#0] -- register_copy jmp __b1 // renderBobInit::@1 __b1: - // [146] (word~) renderBobInit::$0 ← (word)(byte) renderBobInit::y#2 -- vwuz1=_word_vbuz2 + // [145] (word~) renderBobInit::$0 ← (word)(byte) renderBobInit::y#2 -- vwuz1=_word_vbuz2 lda.z y sta.z __0 lda #0 sta.z __0+1 - // [147] (word~) renderBobInit::$6 ← (word~) renderBobInit::$0 << (byte) 2 -- vwuz1=vwuz2_rol_2 + // [146] (word~) renderBobInit::$6 ← (word~) renderBobInit::$0 << (byte) 2 -- vwuz1=vwuz2_rol_2 lda.z __0 asl sta.z __6 @@ -5991,7 +5972,7 @@ renderBobInit: { sta.z __6+1 asl.z __6 rol.z __6+1 - // [148] (word~) renderBobInit::$7 ← (word~) renderBobInit::$6 + (word~) renderBobInit::$0 -- vwuz1=vwuz2_plus_vwuz3 + // [147] (word~) renderBobInit::$7 ← (word~) renderBobInit::$6 + (word~) renderBobInit::$0 -- vwuz1=vwuz2_plus_vwuz3 lda.z __6 clc adc.z __0 @@ -5999,7 +5980,7 @@ renderBobInit: { lda.z __6+1 adc.z __0+1 sta.z __7+1 - // [149] (word~) renderBobInit::$1 ← (word~) renderBobInit::$7 << (byte) 3 -- vwuz1=vwuz2_rol_3 + // [148] (word~) renderBobInit::$1 ← (word~) renderBobInit::$7 << (byte) 3 -- vwuz1=vwuz2_rol_3 lda.z __7 asl sta.z __1 @@ -6010,54 +5991,54 @@ renderBobInit: { rol.z __1+1 asl.z __1 rol.z __1+1 - // [150] (byte~) renderBobInit::$4 ← (byte) renderBobInit::y#2 << (byte) 1 -- vbuz1=vbuz2_rol_1 + // [149] (byte~) renderBobInit::$4 ← (byte) renderBobInit::y#2 << (byte) 1 -- vbuz1=vbuz2_rol_1 lda.z y asl sta.z __4 - // [151] *((const word*) MUL40 + (byte~) renderBobInit::$4) ← (word~) renderBobInit::$1 -- pwuc1_derefidx_vbuz1=vwuz2 + // [150] *((const word*) MUL40 + (byte~) renderBobInit::$4) ← (word~) renderBobInit::$1 -- pwuc1_derefidx_vbuz1=vwuz2 ldy.z __4 lda.z __1 sta MUL40,y lda.z __1+1 sta MUL40+1,y - // [152] (byte) renderBobInit::y#1 ← ++ (byte) renderBobInit::y#2 -- vbuz1=_inc_vbuz1 + // [151] (byte) renderBobInit::y#1 ← ++ (byte) renderBobInit::y#2 -- vbuz1=_inc_vbuz1 inc.z y - // [153] if((byte) renderBobInit::y#1!=(byte) $20) goto renderBobInit::@1 -- vbuz1_neq_vbuc1_then_la1 + // [152] if((byte) renderBobInit::y#1!=(byte) $20) goto renderBobInit::@1 -- vbuz1_neq_vbuc1_then_la1 lda #$20 cmp.z y bne __b1_from___b1 - // [154] phi from renderBobInit::@1 to renderBobInit::@2 [phi:renderBobInit::@1->renderBobInit::@2] + // [153] phi from renderBobInit::@1 to renderBobInit::@2 [phi:renderBobInit::@1->renderBobInit::@2] __b2_from___b1: - // [154] phi (byte) renderBobInit::i#2 = (byte) 0 [phi:renderBobInit::@1->renderBobInit::@2#0] -- vbuz1=vbuc1 + // [153] phi (byte) renderBobInit::i#2 = (byte) 0 [phi:renderBobInit::@1->renderBobInit::@2#0] -- vbuz1=vbuc1 lda #0 sta.z i jmp __b2 - // [154] phi from renderBobInit::@2 to renderBobInit::@2 [phi:renderBobInit::@2->renderBobInit::@2] + // [153] phi from renderBobInit::@2 to renderBobInit::@2 [phi:renderBobInit::@2->renderBobInit::@2] __b2_from___b2: - // [154] phi (byte) renderBobInit::i#2 = (byte) renderBobInit::i#1 [phi:renderBobInit::@2->renderBobInit::@2#0] -- register_copy + // [153] phi (byte) renderBobInit::i#2 = (byte) renderBobInit::i#1 [phi:renderBobInit::@2->renderBobInit::@2#0] -- register_copy jmp __b2 // renderBobInit::@2 __b2: - // [155] (byte~) renderBobInit::$5 ← (byte) renderBobInit::i#2 << (byte) 1 -- vbuz1=vbuz2_rol_1 + // [154] (byte~) renderBobInit::$5 ← (byte) renderBobInit::i#2 << (byte) 1 -- vbuz1=vbuz2_rol_1 lda.z i asl sta.z __5 - // [156] *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobInit::$5) ← (const byte*) BOB_SCREEN -- pptc1_derefidx_vbuz1=pbuc2 + // [155] *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobInit::$5) ← (const byte*) BOB_SCREEN -- pptc1_derefidx_vbuz1=pbuc2 ldy.z __5 lda #BOB_SCREEN sta RENDERBOB_CLEANUP+1,y - // [157] (byte) renderBobInit::i#1 ← ++ (byte) renderBobInit::i#2 -- vbuz1=_inc_vbuz1 + // [156] (byte) renderBobInit::i#1 ← ++ (byte) renderBobInit::i#2 -- vbuz1=_inc_vbuz1 inc.z i - // [158] if((byte) renderBobInit::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto renderBobInit::@2 -- vbuz1_neq_vbuc1_then_la1 + // [157] if((byte) renderBobInit::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto renderBobInit::@2 -- vbuz1_neq_vbuc1_then_la1 lda #NUM_BOBS-1+1 cmp.z i bne __b2_from___b2 jmp __breturn // renderBobInit::@return __breturn: - // [159] return + // [158] return rts } // prepareBobs @@ -6072,97 +6053,97 @@ prepareBobs: { .label cell = $17 .label bob_table_idx = $15 .label shift_x = $16 - // [161] call progress_init - // [242] phi from prepareBobs to progress_init [phi:prepareBobs->progress_init] + // [160] call progress_init + // [241] phi from prepareBobs to progress_init [phi:prepareBobs->progress_init] progress_init_from_prepareBobs: jsr progress_init - // [162] phi from prepareBobs to prepareBobs::@8 [phi:prepareBobs->prepareBobs::@8] + // [161] phi from prepareBobs to prepareBobs::@8 [phi:prepareBobs->prepareBobs::@8] __b8_from_prepareBobs: jmp __b8 // prepareBobs::@8 __b8: - // [163] call bobCharsetFindOrAddGlyph - // [196] phi from prepareBobs::@8 to bobCharsetFindOrAddGlyph [phi:prepareBobs::@8->bobCharsetFindOrAddGlyph] + // [162] call bobCharsetFindOrAddGlyph + // [195] phi from prepareBobs::@8 to bobCharsetFindOrAddGlyph [phi:prepareBobs::@8->bobCharsetFindOrAddGlyph] bobCharsetFindOrAddGlyph_from___b8: - // [196] phi (byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 = (const byte*) PROTO_BOB+(byte) $30 [phi:prepareBobs::@8->bobCharsetFindOrAddGlyph#0] -- pbuz1=pbuc1 + // [195] phi (byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 = (const byte*) PROTO_BOB+(byte) $30 [phi:prepareBobs::@8->bobCharsetFindOrAddGlyph#0] -- pbuz1=pbuc1 lda #PROTO_BOB+$30 sta.z bobCharsetFindOrAddGlyph.bob_glyph+1 - // [196] phi (byte) bob_charset_next_id#23 = (byte) 0 [phi:prepareBobs::@8->bobCharsetFindOrAddGlyph#1] -- vbuz1=vbuc1 + // [195] phi (byte) bob_charset_next_id#23 = (byte) 0 [phi:prepareBobs::@8->bobCharsetFindOrAddGlyph#1] -- vbuz1=vbuc1 lda #0 sta.z bob_charset_next_id jsr bobCharsetFindOrAddGlyph - // [164] phi from prepareBobs::@8 to prepareBobs::@1 [phi:prepareBobs::@8->prepareBobs::@1] + // [163] phi from prepareBobs::@8 to prepareBobs::@1 [phi:prepareBobs::@8->prepareBobs::@1] __b1_from___b8: - // [164] phi (byte) prepareBobs::bob_table_idx#6 = (byte) 0 [phi:prepareBobs::@8->prepareBobs::@1#0] -- vbuz1=vbuc1 + // [163] phi (byte) prepareBobs::bob_table_idx#6 = (byte) 0 [phi:prepareBobs::@8->prepareBobs::@1#0] -- vbuz1=vbuc1 lda #0 sta.z bob_table_idx - // [164] phi (byte) bob_charset_next_id#14 = (byte) bob_charset_next_id#16 [phi:prepareBobs::@8->prepareBobs::@1#1] -- register_copy - // [164] phi (byte) progress_idx#16 = (byte) 0 [phi:prepareBobs::@8->prepareBobs::@1#2] -- vbuz1=vbuc1 + // [163] phi (byte) bob_charset_next_id#14 = (byte) bob_charset_next_id#16 [phi:prepareBobs::@8->prepareBobs::@1#1] -- register_copy + // [163] phi (byte) progress_idx#16 = (byte) 0 [phi:prepareBobs::@8->prepareBobs::@1#2] -- vbuz1=vbuc1 lda #0 sta.z progress_idx - // [164] phi (byte*) progress_cursor#15 = (const byte*) SCREEN_BASIC [phi:prepareBobs::@8->prepareBobs::@1#3] -- pbuz1=pbuc1 + // [163] phi (byte*) progress_cursor#15 = (const byte*) SCREEN_BASIC [phi:prepareBobs::@8->prepareBobs::@1#3] -- pbuz1=pbuc1 lda #SCREEN_BASIC sta.z progress_cursor+1 - // [164] phi (byte) prepareBobs::shift_y#2 = (byte) 0 [phi:prepareBobs::@8->prepareBobs::@1#4] -- vbuz1=vbuc1 + // [163] phi (byte) prepareBobs::shift_y#2 = (byte) 0 [phi:prepareBobs::@8->prepareBobs::@1#4] -- vbuz1=vbuc1 lda #0 sta.z shift_y jmp __b1 // prepareBobs::@1 __b1: - // [165] if((byte) prepareBobs::shift_y#2<(const byte) BOB_SHIFTS_Y) goto prepareBobs::@2 -- vbuz1_lt_vbuc1_then_la1 + // [164] if((byte) prepareBobs::shift_y#2<(const byte) BOB_SHIFTS_Y) goto prepareBobs::@2 -- vbuz1_lt_vbuc1_then_la1 lda.z shift_y cmp #BOB_SHIFTS_Y bcc __b2_from___b1 jmp __breturn // prepareBobs::@return __breturn: - // [166] return + // [165] return rts - // [167] phi from prepareBobs::@1 to prepareBobs::@2 [phi:prepareBobs::@1->prepareBobs::@2] + // [166] phi from prepareBobs::@1 to prepareBobs::@2 [phi:prepareBobs::@1->prepareBobs::@2] __b2_from___b1: - // [167] phi (byte) progress_idx#31 = (byte) progress_idx#16 [phi:prepareBobs::@1->prepareBobs::@2#0] -- register_copy - // [167] phi (byte*) progress_cursor#31 = (byte*) progress_cursor#15 [phi:prepareBobs::@1->prepareBobs::@2#1] -- register_copy - // [167] phi (byte) bob_charset_next_id#30 = (byte) bob_charset_next_id#14 [phi:prepareBobs::@1->prepareBobs::@2#2] -- register_copy - // [167] phi (byte) prepareBobs::bob_table_idx#12 = (byte) prepareBobs::bob_table_idx#6 [phi:prepareBobs::@1->prepareBobs::@2#3] -- register_copy - // [167] phi (byte) prepareBobs::shift_x#2 = (byte) 0 [phi:prepareBobs::@1->prepareBobs::@2#4] -- vbuz1=vbuc1 + // [166] phi (byte) progress_idx#31 = (byte) progress_idx#16 [phi:prepareBobs::@1->prepareBobs::@2#0] -- register_copy + // [166] phi (byte*) progress_cursor#31 = (byte*) progress_cursor#15 [phi:prepareBobs::@1->prepareBobs::@2#1] -- register_copy + // [166] phi (byte) bob_charset_next_id#30 = (byte) bob_charset_next_id#14 [phi:prepareBobs::@1->prepareBobs::@2#2] -- register_copy + // [166] phi (byte) prepareBobs::bob_table_idx#12 = (byte) prepareBobs::bob_table_idx#6 [phi:prepareBobs::@1->prepareBobs::@2#3] -- register_copy + // [166] phi (byte) prepareBobs::shift_x#2 = (byte) 0 [phi:prepareBobs::@1->prepareBobs::@2#4] -- vbuz1=vbuc1 lda #0 sta.z shift_x jmp __b2 // prepareBobs::@2 __b2: - // [168] if((byte) prepareBobs::shift_x#2<(const byte) BOB_SHIFTS_X) goto prepareBobs::@3 -- vbuz1_lt_vbuc1_then_la1 + // [167] if((byte) prepareBobs::shift_x#2<(const byte) BOB_SHIFTS_X) goto prepareBobs::@3 -- vbuz1_lt_vbuc1_then_la1 lda.z shift_x cmp #BOB_SHIFTS_X bcc __b3 - // [169] phi from prepareBobs::@2 to prepareBobs::@4 [phi:prepareBobs::@2->prepareBobs::@4] + // [168] phi from prepareBobs::@2 to prepareBobs::@4 [phi:prepareBobs::@2->prepareBobs::@4] __b4_from___b2: jmp __b4 // prepareBobs::@4 __b4: - // [170] call shiftProtoBobDown - // [231] phi from prepareBobs::@4 to shiftProtoBobDown [phi:prepareBobs::@4->shiftProtoBobDown] + // [169] call shiftProtoBobDown + // [230] phi from prepareBobs::@4 to shiftProtoBobDown [phi:prepareBobs::@4->shiftProtoBobDown] shiftProtoBobDown_from___b4: jsr shiftProtoBobDown jmp __b9 // prepareBobs::@9 __b9: - // [171] (byte) prepareBobs::shift_y#1 ← ++ (byte) prepareBobs::shift_y#2 -- vbuz1=_inc_vbuz1 + // [170] (byte) prepareBobs::shift_y#1 ← ++ (byte) prepareBobs::shift_y#2 -- vbuz1=_inc_vbuz1 inc.z shift_y - // [164] phi from prepareBobs::@9 to prepareBobs::@1 [phi:prepareBobs::@9->prepareBobs::@1] + // [163] phi from prepareBobs::@9 to prepareBobs::@1 [phi:prepareBobs::@9->prepareBobs::@1] __b1_from___b9: - // [164] phi (byte) prepareBobs::bob_table_idx#6 = (byte) prepareBobs::bob_table_idx#12 [phi:prepareBobs::@9->prepareBobs::@1#0] -- register_copy - // [164] phi (byte) bob_charset_next_id#14 = (byte) bob_charset_next_id#30 [phi:prepareBobs::@9->prepareBobs::@1#1] -- register_copy - // [164] phi (byte) progress_idx#16 = (byte) progress_idx#31 [phi:prepareBobs::@9->prepareBobs::@1#2] -- register_copy - // [164] phi (byte*) progress_cursor#15 = (byte*) progress_cursor#31 [phi:prepareBobs::@9->prepareBobs::@1#3] -- register_copy - // [164] phi (byte) prepareBobs::shift_y#2 = (byte) prepareBobs::shift_y#1 [phi:prepareBobs::@9->prepareBobs::@1#4] -- register_copy + // [163] phi (byte) prepareBobs::bob_table_idx#6 = (byte) prepareBobs::bob_table_idx#12 [phi:prepareBobs::@9->prepareBobs::@1#0] -- register_copy + // [163] phi (byte) bob_charset_next_id#14 = (byte) bob_charset_next_id#30 [phi:prepareBobs::@9->prepareBobs::@1#1] -- register_copy + // [163] phi (byte) progress_idx#16 = (byte) progress_idx#31 [phi:prepareBobs::@9->prepareBobs::@1#2] -- register_copy + // [163] phi (byte*) progress_cursor#15 = (byte*) progress_cursor#31 [phi:prepareBobs::@9->prepareBobs::@1#3] -- register_copy + // [163] phi (byte) prepareBobs::shift_y#2 = (byte) prepareBobs::shift_y#1 [phi:prepareBobs::@9->prepareBobs::@1#4] -- register_copy jmp __b1 // prepareBobs::@3 __b3: - // [172] (byte*) prepareBobs::bob_table#0 ← (const byte*) BOB_TABLES + (byte) prepareBobs::bob_table_idx#12 -- pbuz1=pbuc1_plus_vbuz2 + // [171] (byte*) prepareBobs::bob_table#0 ← (const byte*) BOB_TABLES + (byte) prepareBobs::bob_table_idx#12 -- pbuz1=pbuc1_plus_vbuz2 lda.z bob_table_idx clc adc #BOB_TABLES adc #0 sta.z bob_table+1 - // [173] phi from prepareBobs::@3 to prepareBobs::@5 [phi:prepareBobs::@3->prepareBobs::@5] + // [172] phi from prepareBobs::@3 to prepareBobs::@5 [phi:prepareBobs::@3->prepareBobs::@5] __b5_from___b3: - // [173] phi (byte*) progress_cursor#24 = (byte*) progress_cursor#31 [phi:prepareBobs::@3->prepareBobs::@5#0] -- register_copy - // [173] phi (byte) progress_idx#25 = (byte) progress_idx#31 [phi:prepareBobs::@3->prepareBobs::@5#1] -- register_copy - // [173] phi (byte*) prepareBobs::bob_table#2 = (byte*) prepareBobs::bob_table#0 [phi:prepareBobs::@3->prepareBobs::@5#2] -- register_copy - // [173] phi (byte) bob_charset_next_id#21 = (byte) bob_charset_next_id#30 [phi:prepareBobs::@3->prepareBobs::@5#3] -- register_copy - // [173] phi (byte*) prepareBobs::bob_glyph#2 = (const byte*) PROTO_BOB [phi:prepareBobs::@3->prepareBobs::@5#4] -- pbuz1=pbuc1 + // [172] phi (byte*) progress_cursor#24 = (byte*) progress_cursor#31 [phi:prepareBobs::@3->prepareBobs::@5#0] -- register_copy + // [172] phi (byte) progress_idx#25 = (byte) progress_idx#31 [phi:prepareBobs::@3->prepareBobs::@5#1] -- register_copy + // [172] phi (byte*) prepareBobs::bob_table#2 = (byte*) prepareBobs::bob_table#0 [phi:prepareBobs::@3->prepareBobs::@5#2] -- register_copy + // [172] phi (byte) bob_charset_next_id#21 = (byte) bob_charset_next_id#30 [phi:prepareBobs::@3->prepareBobs::@5#3] -- register_copy + // [172] phi (byte*) prepareBobs::bob_glyph#2 = (const byte*) PROTO_BOB [phi:prepareBobs::@3->prepareBobs::@5#4] -- pbuz1=pbuc1 lda #PROTO_BOB sta.z bob_glyph+1 - // [173] phi (byte) prepareBobs::cell#2 = (byte) 0 [phi:prepareBobs::@3->prepareBobs::@5#5] -- vbuz1=vbuc1 + // [172] phi (byte) prepareBobs::cell#2 = (byte) 0 [phi:prepareBobs::@3->prepareBobs::@5#5] -- vbuz1=vbuc1 lda #0 sta.z cell jmp __b5 // prepareBobs::@5 __b5: - // [174] if((byte) prepareBobs::cell#2<(byte) 9) goto prepareBobs::@6 -- vbuz1_lt_vbuc1_then_la1 + // [173] if((byte) prepareBobs::cell#2<(byte) 9) goto prepareBobs::@6 -- vbuz1_lt_vbuc1_then_la1 lda.z cell cmp #9 bcc __b6 jmp __b7 // prepareBobs::@7 __b7: - // [175] (byte) prepareBobs::bob_table_idx#1 ← ++ (byte) prepareBobs::bob_table_idx#12 -- vbuz1=_inc_vbuz1 + // [174] (byte) prepareBobs::bob_table_idx#1 ← ++ (byte) prepareBobs::bob_table_idx#12 -- vbuz1=_inc_vbuz1 inc.z bob_table_idx - // [176] call shiftProtoBobRight - // [214] phi from prepareBobs::@7 to shiftProtoBobRight [phi:prepareBobs::@7->shiftProtoBobRight] + // [175] call shiftProtoBobRight + // [213] phi from prepareBobs::@7 to shiftProtoBobRight [phi:prepareBobs::@7->shiftProtoBobRight] shiftProtoBobRight_from___b7: jsr shiftProtoBobRight - // [177] phi from prepareBobs::@7 to prepareBobs::@12 [phi:prepareBobs::@7->prepareBobs::@12] + // [176] phi from prepareBobs::@7 to prepareBobs::@12 [phi:prepareBobs::@7->prepareBobs::@12] __b12_from___b7: jmp __b12 // prepareBobs::@12 __b12: - // [178] call shiftProtoBobRight - // [214] phi from prepareBobs::@12 to shiftProtoBobRight [phi:prepareBobs::@12->shiftProtoBobRight] + // [177] call shiftProtoBobRight + // [213] phi from prepareBobs::@12 to shiftProtoBobRight [phi:prepareBobs::@12->shiftProtoBobRight] shiftProtoBobRight_from___b12: jsr shiftProtoBobRight jmp __b13 // prepareBobs::@13 __b13: - // [179] (byte) prepareBobs::shift_x#1 ← ++ (byte) prepareBobs::shift_x#2 -- vbuz1=_inc_vbuz1 + // [178] (byte) prepareBobs::shift_x#1 ← ++ (byte) prepareBobs::shift_x#2 -- vbuz1=_inc_vbuz1 inc.z shift_x - // [167] phi from prepareBobs::@13 to prepareBobs::@2 [phi:prepareBobs::@13->prepareBobs::@2] + // [166] phi from prepareBobs::@13 to prepareBobs::@2 [phi:prepareBobs::@13->prepareBobs::@2] __b2_from___b13: - // [167] phi (byte) progress_idx#31 = (byte) progress_idx#25 [phi:prepareBobs::@13->prepareBobs::@2#0] -- register_copy - // [167] phi (byte*) progress_cursor#31 = (byte*) progress_cursor#24 [phi:prepareBobs::@13->prepareBobs::@2#1] -- register_copy - // [167] phi (byte) bob_charset_next_id#30 = (byte) bob_charset_next_id#21 [phi:prepareBobs::@13->prepareBobs::@2#2] -- register_copy - // [167] phi (byte) prepareBobs::bob_table_idx#12 = (byte) prepareBobs::bob_table_idx#1 [phi:prepareBobs::@13->prepareBobs::@2#3] -- register_copy - // [167] phi (byte) prepareBobs::shift_x#2 = (byte) prepareBobs::shift_x#1 [phi:prepareBobs::@13->prepareBobs::@2#4] -- register_copy + // [166] phi (byte) progress_idx#31 = (byte) progress_idx#25 [phi:prepareBobs::@13->prepareBobs::@2#0] -- register_copy + // [166] phi (byte*) progress_cursor#31 = (byte*) progress_cursor#24 [phi:prepareBobs::@13->prepareBobs::@2#1] -- register_copy + // [166] phi (byte) bob_charset_next_id#30 = (byte) bob_charset_next_id#21 [phi:prepareBobs::@13->prepareBobs::@2#2] -- register_copy + // [166] phi (byte) prepareBobs::bob_table_idx#12 = (byte) prepareBobs::bob_table_idx#1 [phi:prepareBobs::@13->prepareBobs::@2#3] -- register_copy + // [166] phi (byte) prepareBobs::shift_x#2 = (byte) prepareBobs::shift_x#1 [phi:prepareBobs::@13->prepareBobs::@2#4] -- register_copy jmp __b2 // prepareBobs::@6 __b6: - // [180] (byte*) bobCharsetFindOrAddGlyph::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 -- pbuz1=pbuz2 + // [179] (byte*) bobCharsetFindOrAddGlyph::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 -- pbuz1=pbuz2 lda.z bob_glyph sta.z bobCharsetFindOrAddGlyph.bob_glyph lda.z bob_glyph+1 sta.z bobCharsetFindOrAddGlyph.bob_glyph+1 - // [181] call bobCharsetFindOrAddGlyph - // [196] phi from prepareBobs::@6 to bobCharsetFindOrAddGlyph [phi:prepareBobs::@6->bobCharsetFindOrAddGlyph] + // [180] call bobCharsetFindOrAddGlyph + // [195] phi from prepareBobs::@6 to bobCharsetFindOrAddGlyph [phi:prepareBobs::@6->bobCharsetFindOrAddGlyph] bobCharsetFindOrAddGlyph_from___b6: - // [196] phi (byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 = (byte*) bobCharsetFindOrAddGlyph::bob_glyph#1 [phi:prepareBobs::@6->bobCharsetFindOrAddGlyph#0] -- register_copy - // [196] phi (byte) bob_charset_next_id#23 = (byte) bob_charset_next_id#21 [phi:prepareBobs::@6->bobCharsetFindOrAddGlyph#1] -- register_copy + // [195] phi (byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 = (byte*) bobCharsetFindOrAddGlyph::bob_glyph#1 [phi:prepareBobs::@6->bobCharsetFindOrAddGlyph#0] -- register_copy + // [195] phi (byte) bob_charset_next_id#23 = (byte) bob_charset_next_id#21 [phi:prepareBobs::@6->bobCharsetFindOrAddGlyph#1] -- register_copy jsr bobCharsetFindOrAddGlyph - // [182] (byte) bobCharsetFindOrAddGlyph::return#1 ← (byte) bobCharsetFindOrAddGlyph::glyph_id#11 -- vbuz1=vbuz2 + // [181] (byte) bobCharsetFindOrAddGlyph::return#1 ← (byte) bobCharsetFindOrAddGlyph::glyph_id#11 -- vbuz1=vbuz2 lda.z bobCharsetFindOrAddGlyph.glyph_id sta.z bobCharsetFindOrAddGlyph.return jmp __b10 // prepareBobs::@10 __b10: - // [183] (byte~) prepareBobs::$6 ← (byte) bobCharsetFindOrAddGlyph::return#1 -- vbuz1=vbuz2 + // [182] (byte~) prepareBobs::$6 ← (byte) bobCharsetFindOrAddGlyph::return#1 -- vbuz1=vbuz2 lda.z bobCharsetFindOrAddGlyph.return sta.z __6 - // [184] *((byte*) prepareBobs::bob_table#2) ← (byte~) prepareBobs::$6 -- _deref_pbuz1=vbuz2 + // [183] *((byte*) prepareBobs::bob_table#2) ← (byte~) prepareBobs::$6 -- _deref_pbuz1=vbuz2 // Look for an existing char in BOB_CHARSET lda.z __6 ldy #0 sta (bob_table),y - // [185] (byte*) prepareBobs::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 + (byte) 8 -- pbuz1=pbuz1_plus_vbuc1 + // [184] (byte*) prepareBobs::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 + (byte) 8 -- pbuz1=pbuz1_plus_vbuc1 // Move to the next glyph lda #8 clc @@ -6258,7 +6239,7 @@ prepareBobs: { bcc !+ inc.z bob_glyph+1 !: - // [186] (byte*) prepareBobs::bob_table#1 ← (byte*) prepareBobs::bob_table#2 + (const byte) BOB_SHIFTS_X*(const byte) BOB_SHIFTS_Y -- pbuz1=pbuz1_plus_vbuc1 + // [185] (byte*) prepareBobs::bob_table#1 ← (byte*) prepareBobs::bob_table#2 + (const byte) BOB_SHIFTS_X*(const byte) BOB_SHIFTS_Y -- pbuz1=pbuz1_plus_vbuc1 // Move to the next sub-table lda #BOB_SHIFTS_X*BOB_SHIFTS_Y clc @@ -6267,60 +6248,60 @@ prepareBobs: { bcc !+ inc.z bob_table+1 !: - // [187] call progress_inc + // [186] call progress_inc jsr progress_inc jmp __b11 // prepareBobs::@11 __b11: - // [188] (byte) prepareBobs::cell#1 ← ++ (byte) prepareBobs::cell#2 -- vbuz1=_inc_vbuz1 + // [187] (byte) prepareBobs::cell#1 ← ++ (byte) prepareBobs::cell#2 -- vbuz1=_inc_vbuz1 inc.z cell - // [173] phi from prepareBobs::@11 to prepareBobs::@5 [phi:prepareBobs::@11->prepareBobs::@5] + // [172] phi from prepareBobs::@11 to prepareBobs::@5 [phi:prepareBobs::@11->prepareBobs::@5] __b5_from___b11: - // [173] phi (byte*) progress_cursor#24 = (byte*) progress_cursor#17 [phi:prepareBobs::@11->prepareBobs::@5#0] -- register_copy - // [173] phi (byte) progress_idx#25 = (byte) progress_idx#10 [phi:prepareBobs::@11->prepareBobs::@5#1] -- register_copy - // [173] phi (byte*) prepareBobs::bob_table#2 = (byte*) prepareBobs::bob_table#1 [phi:prepareBobs::@11->prepareBobs::@5#2] -- register_copy - // [173] phi (byte) bob_charset_next_id#21 = (byte) bob_charset_next_id#16 [phi:prepareBobs::@11->prepareBobs::@5#3] -- register_copy - // [173] phi (byte*) prepareBobs::bob_glyph#2 = (byte*) prepareBobs::bob_glyph#1 [phi:prepareBobs::@11->prepareBobs::@5#4] -- register_copy - // [173] phi (byte) prepareBobs::cell#2 = (byte) prepareBobs::cell#1 [phi:prepareBobs::@11->prepareBobs::@5#5] -- register_copy + // [172] phi (byte*) progress_cursor#24 = (byte*) progress_cursor#17 [phi:prepareBobs::@11->prepareBobs::@5#0] -- register_copy + // [172] phi (byte) progress_idx#25 = (byte) progress_idx#10 [phi:prepareBobs::@11->prepareBobs::@5#1] -- register_copy + // [172] phi (byte*) prepareBobs::bob_table#2 = (byte*) prepareBobs::bob_table#1 [phi:prepareBobs::@11->prepareBobs::@5#2] -- register_copy + // [172] phi (byte) bob_charset_next_id#21 = (byte) bob_charset_next_id#16 [phi:prepareBobs::@11->prepareBobs::@5#3] -- register_copy + // [172] phi (byte*) prepareBobs::bob_glyph#2 = (byte*) prepareBobs::bob_glyph#1 [phi:prepareBobs::@11->prepareBobs::@5#4] -- register_copy + // [172] phi (byte) prepareBobs::cell#2 = (byte) prepareBobs::cell#1 [phi:prepareBobs::@11->prepareBobs::@5#5] -- register_copy jmp __b5 } // progress_inc // Increase PETSCII progress one bit // Done by increasing the character until the idx is 8 and then moving to the next char progress_inc: { - // [189] (byte) progress_idx#8 ← ++ (byte) progress_idx#25 -- vbuz1=_inc_vbuz1 + // [188] (byte) progress_idx#8 ← ++ (byte) progress_idx#25 -- vbuz1=_inc_vbuz1 inc.z progress_idx - // [190] if((byte) progress_idx#8!=(byte) 8) goto progress_inc::@1 -- vbuz1_neq_vbuc1_then_la1 + // [189] if((byte) progress_idx#8!=(byte) 8) goto progress_inc::@1 -- vbuz1_neq_vbuc1_then_la1 lda #8 cmp.z progress_idx bne __b1_from_progress_inc jmp __b2 // progress_inc::@2 __b2: - // [191] *((byte*) progress_cursor#24) ← *((const byte*) progress_inc::progress_chars+(byte) 8) -- _deref_pbuz1=_deref_pbuc1 + // [190] *((byte*) progress_cursor#24) ← *((const byte*) progress_inc::progress_chars+(byte) 8) -- _deref_pbuz1=_deref_pbuc1 lda progress_chars+8 ldy #0 sta (progress_cursor),y - // [192] (byte*) progress_cursor#8 ← ++ (byte*) progress_cursor#24 -- pbuz1=_inc_pbuz1 + // [191] (byte*) progress_cursor#8 ← ++ (byte*) progress_cursor#24 -- pbuz1=_inc_pbuz1 inc.z progress_cursor bne !+ inc.z progress_cursor+1 !: - // [193] phi from progress_inc::@2 to progress_inc::@1 [phi:progress_inc::@2->progress_inc::@1] + // [192] phi from progress_inc::@2 to progress_inc::@1 [phi:progress_inc::@2->progress_inc::@1] __b1_from___b2: - // [193] phi (byte*) progress_cursor#17 = (byte*) progress_cursor#8 [phi:progress_inc::@2->progress_inc::@1#0] -- register_copy - // [193] phi (byte) progress_idx#10 = (byte) 0 [phi:progress_inc::@2->progress_inc::@1#1] -- vbuz1=vbuc1 + // [192] phi (byte*) progress_cursor#17 = (byte*) progress_cursor#8 [phi:progress_inc::@2->progress_inc::@1#0] -- register_copy + // [192] phi (byte) progress_idx#10 = (byte) 0 [phi:progress_inc::@2->progress_inc::@1#1] -- vbuz1=vbuc1 lda #0 sta.z progress_idx jmp __b1 - // [193] phi from progress_inc to progress_inc::@1 [phi:progress_inc->progress_inc::@1] + // [192] phi from progress_inc to progress_inc::@1 [phi:progress_inc->progress_inc::@1] __b1_from_progress_inc: - // [193] phi (byte*) progress_cursor#17 = (byte*) progress_cursor#24 [phi:progress_inc->progress_inc::@1#0] -- register_copy - // [193] phi (byte) progress_idx#10 = (byte) progress_idx#8 [phi:progress_inc->progress_inc::@1#1] -- register_copy + // [192] phi (byte*) progress_cursor#17 = (byte*) progress_cursor#24 [phi:progress_inc->progress_inc::@1#0] -- register_copy + // [192] phi (byte) progress_idx#10 = (byte) progress_idx#8 [phi:progress_inc->progress_inc::@1#1] -- register_copy jmp __b1 // progress_inc::@1 __b1: - // [194] *((byte*) progress_cursor#17) ← *((const byte*) progress_inc::progress_chars + (byte) progress_idx#10) -- _deref_pbuz1=pbuc1_derefidx_vbuz2 + // [193] *((byte*) progress_cursor#17) ← *((const byte*) progress_inc::progress_chars + (byte) progress_idx#10) -- _deref_pbuz1=pbuc1_derefidx_vbuz2 ldy.z progress_idx lda progress_chars,y ldy #0 @@ -6328,7 +6309,7 @@ progress_inc: { jmp __breturn // progress_inc::@return __breturn: - // [195] return + // [194] return rts // Progress characters progress_chars: .byte $20, $65, $74, $75, $61, $f6, $e7, $ea, $e0 @@ -6346,109 +6327,105 @@ bobCharsetFindOrAddGlyph: { .label glyph_cursor = $20 .label i1 = $22 .label found = $24 - // [197] phi from bobCharsetFindOrAddGlyph to bobCharsetFindOrAddGlyph::@1 [phi:bobCharsetFindOrAddGlyph->bobCharsetFindOrAddGlyph::@1] + // [196] phi from bobCharsetFindOrAddGlyph to bobCharsetFindOrAddGlyph::@1 [phi:bobCharsetFindOrAddGlyph->bobCharsetFindOrAddGlyph::@1] __b1_from_bobCharsetFindOrAddGlyph: - // [197] phi (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 = (const byte*) BOB_CHARSET [phi:bobCharsetFindOrAddGlyph->bobCharsetFindOrAddGlyph::@1#0] -- pbuz1=pbuc1 + // [196] phi (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 = (const byte*) BOB_CHARSET [phi:bobCharsetFindOrAddGlyph->bobCharsetFindOrAddGlyph::@1#0] -- pbuz1=pbuc1 lda #BOB_CHARSET sta.z glyph_cursor+1 - // [197] phi (byte) bobCharsetFindOrAddGlyph::glyph_id#11 = (byte) 0 [phi:bobCharsetFindOrAddGlyph->bobCharsetFindOrAddGlyph::@1#1] -- vbuz1=vbuc1 + // [196] phi (byte) bobCharsetFindOrAddGlyph::glyph_id#11 = (byte) 0 [phi:bobCharsetFindOrAddGlyph->bobCharsetFindOrAddGlyph::@1#1] -- vbuz1=vbuc1 lda #0 sta.z glyph_id jmp __b1 // bobCharsetFindOrAddGlyph::@1 __b1: - // [198] if((byte) bobCharsetFindOrAddGlyph::glyph_id#11!=(byte) bob_charset_next_id#23) goto bobCharsetFindOrAddGlyph::@2 -- vbuz1_neq_vbuz2_then_la1 + // [197] if((byte) bobCharsetFindOrAddGlyph::glyph_id#11!=(byte) bob_charset_next_id#23) goto bobCharsetFindOrAddGlyph::@2 -- vbuz1_neq_vbuz2_then_la1 lda.z glyph_id cmp.z bob_charset_next_id bne __b2_from___b1 - // [199] phi from bobCharsetFindOrAddGlyph::@1 to bobCharsetFindOrAddGlyph::@7 [phi:bobCharsetFindOrAddGlyph::@1->bobCharsetFindOrAddGlyph::@7] + // [198] phi from bobCharsetFindOrAddGlyph::@1 to bobCharsetFindOrAddGlyph::@7 [phi:bobCharsetFindOrAddGlyph::@1->bobCharsetFindOrAddGlyph::@7] __b7_from___b1: - // [199] phi (byte) bobCharsetFindOrAddGlyph::i1#2 = (byte) 0 [phi:bobCharsetFindOrAddGlyph::@1->bobCharsetFindOrAddGlyph::@7#0] -- vbuz1=vbuc1 + // [198] phi (byte) bobCharsetFindOrAddGlyph::i1#2 = (byte) 0 [phi:bobCharsetFindOrAddGlyph::@1->bobCharsetFindOrAddGlyph::@7#0] -- vbuz1=vbuc1 lda #0 sta.z i1 jmp __b7 // Not found - add it // bobCharsetFindOrAddGlyph::@7 __b7: - // [200] if((byte) bobCharsetFindOrAddGlyph::i1#2<(byte) 8) goto bobCharsetFindOrAddGlyph::@8 -- vbuz1_lt_vbuc1_then_la1 + // [199] if((byte) bobCharsetFindOrAddGlyph::i1#2<(byte) 8) goto bobCharsetFindOrAddGlyph::@8 -- vbuz1_lt_vbuc1_then_la1 lda.z i1 cmp #8 bcc __b8 jmp __b9 // bobCharsetFindOrAddGlyph::@9 __b9: - // [201] (byte) bob_charset_next_id#8 ← ++ (byte) bob_charset_next_id#23 -- vbuz1=_inc_vbuz1 + // [200] (byte) bob_charset_next_id#8 ← ++ (byte) bob_charset_next_id#23 -- vbuz1=_inc_vbuz1 inc.z bob_charset_next_id - // [202] phi from bobCharsetFindOrAddGlyph::@5 bobCharsetFindOrAddGlyph::@9 to bobCharsetFindOrAddGlyph::@return [phi:bobCharsetFindOrAddGlyph::@5/bobCharsetFindOrAddGlyph::@9->bobCharsetFindOrAddGlyph::@return] + // [201] phi from bobCharsetFindOrAddGlyph::@5 bobCharsetFindOrAddGlyph::@9 to bobCharsetFindOrAddGlyph::@return [phi:bobCharsetFindOrAddGlyph::@5/bobCharsetFindOrAddGlyph::@9->bobCharsetFindOrAddGlyph::@return] __breturn_from___b5: __breturn_from___b9: - // [202] phi (byte) bob_charset_next_id#16 = (byte) bob_charset_next_id#23 [phi:bobCharsetFindOrAddGlyph::@5/bobCharsetFindOrAddGlyph::@9->bobCharsetFindOrAddGlyph::@return#0] -- register_copy + // [201] phi (byte) bob_charset_next_id#16 = (byte) bob_charset_next_id#23 [phi:bobCharsetFindOrAddGlyph::@5/bobCharsetFindOrAddGlyph::@9->bobCharsetFindOrAddGlyph::@return#0] -- register_copy jmp __breturn // bobCharsetFindOrAddGlyph::@return __breturn: - // [203] return + // [202] return rts // bobCharsetFindOrAddGlyph::@8 __b8: - // [204] *((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) bobCharsetFindOrAddGlyph::i1#2) ← *((byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 + (byte) bobCharsetFindOrAddGlyph::i1#2) -- pbuz1_derefidx_vbuz2=pbuz3_derefidx_vbuz2 + // [203] *((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) bobCharsetFindOrAddGlyph::i1#2) ← *((byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 + (byte) bobCharsetFindOrAddGlyph::i1#2) -- pbuz1_derefidx_vbuz2=pbuz3_derefidx_vbuz2 ldy.z i1 lda (bob_glyph),y sta (glyph_cursor),y - // [205] (byte) bobCharsetFindOrAddGlyph::i1#1 ← ++ (byte) bobCharsetFindOrAddGlyph::i1#2 -- vbuz1=_inc_vbuz1 + // [204] (byte) bobCharsetFindOrAddGlyph::i1#1 ← ++ (byte) bobCharsetFindOrAddGlyph::i1#2 -- vbuz1=_inc_vbuz1 inc.z i1 - // [199] phi from bobCharsetFindOrAddGlyph::@8 to bobCharsetFindOrAddGlyph::@7 [phi:bobCharsetFindOrAddGlyph::@8->bobCharsetFindOrAddGlyph::@7] + // [198] phi from bobCharsetFindOrAddGlyph::@8 to bobCharsetFindOrAddGlyph::@7 [phi:bobCharsetFindOrAddGlyph::@8->bobCharsetFindOrAddGlyph::@7] __b7_from___b8: - // [199] phi (byte) bobCharsetFindOrAddGlyph::i1#2 = (byte) bobCharsetFindOrAddGlyph::i1#1 [phi:bobCharsetFindOrAddGlyph::@8->bobCharsetFindOrAddGlyph::@7#0] -- register_copy + // [198] phi (byte) bobCharsetFindOrAddGlyph::i1#2 = (byte) bobCharsetFindOrAddGlyph::i1#1 [phi:bobCharsetFindOrAddGlyph::@8->bobCharsetFindOrAddGlyph::@7#0] -- register_copy jmp __b7 - // [206] phi from bobCharsetFindOrAddGlyph::@1 to bobCharsetFindOrAddGlyph::@2 [phi:bobCharsetFindOrAddGlyph::@1->bobCharsetFindOrAddGlyph::@2] + // [205] phi from bobCharsetFindOrAddGlyph::@1 to bobCharsetFindOrAddGlyph::@2 [phi:bobCharsetFindOrAddGlyph::@1->bobCharsetFindOrAddGlyph::@2] __b2_from___b1: - // [206] phi (byte) bobCharsetFindOrAddGlyph::i#2 = (byte) 0 [phi:bobCharsetFindOrAddGlyph::@1->bobCharsetFindOrAddGlyph::@2#0] -- vbuz1=vbuc1 + // [205] phi (byte) bobCharsetFindOrAddGlyph::i#2 = (byte) 0 [phi:bobCharsetFindOrAddGlyph::@1->bobCharsetFindOrAddGlyph::@2#0] -- vbuz1=vbuc1 lda #0 sta.z i jmp __b2 // bobCharsetFindOrAddGlyph::@2 __b2: - // [207] if((byte) bobCharsetFindOrAddGlyph::i#2<(byte) 8) goto bobCharsetFindOrAddGlyph::@3 -- vbuz1_lt_vbuc1_then_la1 + // [206] if((byte) bobCharsetFindOrAddGlyph::i#2<(byte) 8) goto bobCharsetFindOrAddGlyph::@3 -- vbuz1_lt_vbuc1_then_la1 lda.z i cmp #8 bcc __b3 - // [209] phi from bobCharsetFindOrAddGlyph::@2 to bobCharsetFindOrAddGlyph::@5 [phi:bobCharsetFindOrAddGlyph::@2->bobCharsetFindOrAddGlyph::@5] + // [208] phi from bobCharsetFindOrAddGlyph::@2 to bobCharsetFindOrAddGlyph::@5 [phi:bobCharsetFindOrAddGlyph::@2->bobCharsetFindOrAddGlyph::@5] __b5_from___b2: - // [209] phi (byte) bobCharsetFindOrAddGlyph::found#2 = (byte) 1 [phi:bobCharsetFindOrAddGlyph::@2->bobCharsetFindOrAddGlyph::@5#0] -- vbuz1=vbuc1 + // [208] phi (byte) bobCharsetFindOrAddGlyph::found#2 = (byte) 1 [phi:bobCharsetFindOrAddGlyph::@2->bobCharsetFindOrAddGlyph::@5#0] -- vbuz1=vbuc1 lda #1 sta.z found jmp __b5 // bobCharsetFindOrAddGlyph::@3 __b3: - // [208] if(*((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) bobCharsetFindOrAddGlyph::i#2)==*((byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 + (byte) bobCharsetFindOrAddGlyph::i#2)) goto bobCharsetFindOrAddGlyph::@4 -- pbuz1_derefidx_vbuz2_eq_pbuz3_derefidx_vbuz2_then_la1 + // [207] if(*((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) bobCharsetFindOrAddGlyph::i#2)==*((byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 + (byte) bobCharsetFindOrAddGlyph::i#2)) goto bobCharsetFindOrAddGlyph::@4 -- pbuz1_derefidx_vbuz2_eq_pbuz3_derefidx_vbuz2_then_la1 ldy.z i lda (glyph_cursor),y - tax - lda (bob_glyph),y - tay - sty.z $ff - cpx.z $ff + cmp (bob_glyph),y beq __b4 - // [209] phi from bobCharsetFindOrAddGlyph::@3 to bobCharsetFindOrAddGlyph::@5 [phi:bobCharsetFindOrAddGlyph::@3->bobCharsetFindOrAddGlyph::@5] + // [208] phi from bobCharsetFindOrAddGlyph::@3 to bobCharsetFindOrAddGlyph::@5 [phi:bobCharsetFindOrAddGlyph::@3->bobCharsetFindOrAddGlyph::@5] __b5_from___b3: - // [209] phi (byte) bobCharsetFindOrAddGlyph::found#2 = (byte) 0 [phi:bobCharsetFindOrAddGlyph::@3->bobCharsetFindOrAddGlyph::@5#0] -- vbuz1=vbuc1 + // [208] phi (byte) bobCharsetFindOrAddGlyph::found#2 = (byte) 0 [phi:bobCharsetFindOrAddGlyph::@3->bobCharsetFindOrAddGlyph::@5#0] -- vbuz1=vbuc1 lda #0 sta.z found jmp __b5 // bobCharsetFindOrAddGlyph::@5 __b5: - // [210] if((byte) 0==(byte) bobCharsetFindOrAddGlyph::found#2) goto bobCharsetFindOrAddGlyph::@6 -- vbuc1_eq_vbuz1_then_la1 + // [209] if((byte) 0==(byte) bobCharsetFindOrAddGlyph::found#2) goto bobCharsetFindOrAddGlyph::@6 -- vbuc1_eq_vbuz1_then_la1 lda #0 cmp.z found beq __b6 jmp __breturn_from___b5 // bobCharsetFindOrAddGlyph::@6 __b6: - // [211] (byte) bobCharsetFindOrAddGlyph::glyph_id#1 ← ++ (byte) bobCharsetFindOrAddGlyph::glyph_id#11 -- vbuz1=_inc_vbuz1 + // [210] (byte) bobCharsetFindOrAddGlyph::glyph_id#1 ← ++ (byte) bobCharsetFindOrAddGlyph::glyph_id#11 -- vbuz1=_inc_vbuz1 inc.z glyph_id - // [212] (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#1 ← (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) 8 -- pbuz1=pbuz1_plus_vbuc1 + // [211] (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#1 ← (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) 8 -- pbuz1=pbuz1_plus_vbuc1 lda #8 clc adc.z glyph_cursor @@ -6456,18 +6433,18 @@ bobCharsetFindOrAddGlyph: { bcc !+ inc.z glyph_cursor+1 !: - // [197] phi from bobCharsetFindOrAddGlyph::@6 to bobCharsetFindOrAddGlyph::@1 [phi:bobCharsetFindOrAddGlyph::@6->bobCharsetFindOrAddGlyph::@1] + // [196] phi from bobCharsetFindOrAddGlyph::@6 to bobCharsetFindOrAddGlyph::@1 [phi:bobCharsetFindOrAddGlyph::@6->bobCharsetFindOrAddGlyph::@1] __b1_from___b6: - // [197] phi (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 = (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#1 [phi:bobCharsetFindOrAddGlyph::@6->bobCharsetFindOrAddGlyph::@1#0] -- register_copy - // [197] phi (byte) bobCharsetFindOrAddGlyph::glyph_id#11 = (byte) bobCharsetFindOrAddGlyph::glyph_id#1 [phi:bobCharsetFindOrAddGlyph::@6->bobCharsetFindOrAddGlyph::@1#1] -- register_copy + // [196] phi (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 = (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#1 [phi:bobCharsetFindOrAddGlyph::@6->bobCharsetFindOrAddGlyph::@1#0] -- register_copy + // [196] phi (byte) bobCharsetFindOrAddGlyph::glyph_id#11 = (byte) bobCharsetFindOrAddGlyph::glyph_id#1 [phi:bobCharsetFindOrAddGlyph::@6->bobCharsetFindOrAddGlyph::@1#1] -- register_copy jmp __b1 // bobCharsetFindOrAddGlyph::@4 __b4: - // [213] (byte) bobCharsetFindOrAddGlyph::i#1 ← ++ (byte) bobCharsetFindOrAddGlyph::i#2 -- vbuz1=_inc_vbuz1 + // [212] (byte) bobCharsetFindOrAddGlyph::i#1 ← ++ (byte) bobCharsetFindOrAddGlyph::i#2 -- vbuz1=_inc_vbuz1 inc.z i - // [206] phi from bobCharsetFindOrAddGlyph::@4 to bobCharsetFindOrAddGlyph::@2 [phi:bobCharsetFindOrAddGlyph::@4->bobCharsetFindOrAddGlyph::@2] + // [205] phi from bobCharsetFindOrAddGlyph::@4 to bobCharsetFindOrAddGlyph::@2 [phi:bobCharsetFindOrAddGlyph::@4->bobCharsetFindOrAddGlyph::@2] __b2_from___b4: - // [206] phi (byte) bobCharsetFindOrAddGlyph::i#2 = (byte) bobCharsetFindOrAddGlyph::i#1 [phi:bobCharsetFindOrAddGlyph::@4->bobCharsetFindOrAddGlyph::@2#0] -- register_copy + // [205] phi (byte) bobCharsetFindOrAddGlyph::i#2 = (byte) bobCharsetFindOrAddGlyph::i#1 [phi:bobCharsetFindOrAddGlyph::@4->bobCharsetFindOrAddGlyph::@2#0] -- register_copy jmp __b2 } // shiftProtoBobRight @@ -6480,74 +6457,74 @@ shiftProtoBobRight: { .label j = $26 .label i = $25 .label carry_1 = $27 - // [215] phi from shiftProtoBobRight to shiftProtoBobRight::@1 [phi:shiftProtoBobRight->shiftProtoBobRight::@1] + // [214] phi from shiftProtoBobRight to shiftProtoBobRight::@1 [phi:shiftProtoBobRight->shiftProtoBobRight::@1] __b1_from_shiftProtoBobRight: - // [215] phi (byte) shiftProtoBobRight::carry#2 = (byte) 0 [phi:shiftProtoBobRight->shiftProtoBobRight::@1#0] -- vbuz1=vbuc1 + // [214] phi (byte) shiftProtoBobRight::carry#2 = (byte) 0 [phi:shiftProtoBobRight->shiftProtoBobRight::@1#0] -- vbuz1=vbuc1 lda #0 sta.z carry_1 - // [215] phi (byte) shiftProtoBobRight::j#3 = (byte) 0 [phi:shiftProtoBobRight->shiftProtoBobRight::@1#1] -- vbuz1=vbuc1 + // [214] phi (byte) shiftProtoBobRight::j#3 = (byte) 0 [phi:shiftProtoBobRight->shiftProtoBobRight::@1#1] -- vbuz1=vbuc1 lda #0 sta.z j - // [215] phi (byte) shiftProtoBobRight::i#2 = (byte) 0 [phi:shiftProtoBobRight->shiftProtoBobRight::@1#2] -- vbuz1=vbuc1 + // [214] phi (byte) shiftProtoBobRight::i#2 = (byte) 0 [phi:shiftProtoBobRight->shiftProtoBobRight::@1#2] -- vbuz1=vbuc1 lda #0 sta.z i jmp __b1 // shiftProtoBobRight::@1 __b1: - // [216] if((byte) shiftProtoBobRight::i#2<(byte)(number) 3*(number) 3*(number) 8) goto shiftProtoBobRight::@2 -- vbuz1_lt_vbuc1_then_la1 + // [215] if((byte) shiftProtoBobRight::i#2<(byte)(number) 3*(number) 3*(number) 8) goto shiftProtoBobRight::@2 -- vbuz1_lt_vbuc1_then_la1 lda.z i cmp #3*3*8 bcc __b2 jmp __breturn // shiftProtoBobRight::@return __breturn: - // [217] return + // [216] return rts // shiftProtoBobRight::@2 __b2: - // [218] (byte~) shiftProtoBobRight::$1 ← *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) & (byte) 1 -- vbuz1=pbuc1_derefidx_vbuz2_band_vbuc2 + // [217] (byte~) shiftProtoBobRight::$1 ← *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) & (byte) 1 -- vbuz1=pbuc1_derefidx_vbuz2_band_vbuc2 lda #1 ldy.z j and PROTO_BOB,y sta.z __1 - // [219] if((byte) 0!=(byte~) shiftProtoBobRight::$1) goto shiftProtoBobRight::@3 -- vbuc1_neq_vbuz1_then_la1 + // [218] if((byte) 0!=(byte~) shiftProtoBobRight::$1) goto shiftProtoBobRight::@3 -- vbuc1_neq_vbuz1_then_la1 lda #0 cmp.z __1 bne __b3_from___b2 - // [221] phi from shiftProtoBobRight::@2 to shiftProtoBobRight::@4 [phi:shiftProtoBobRight::@2->shiftProtoBobRight::@4] + // [220] phi from shiftProtoBobRight::@2 to shiftProtoBobRight::@4 [phi:shiftProtoBobRight::@2->shiftProtoBobRight::@4] __b4_from___b2: - // [221] phi (byte) shiftProtoBobRight::carry#1 = (byte) 0 [phi:shiftProtoBobRight::@2->shiftProtoBobRight::@4#0] -- vbuz1=vbuc1 + // [220] phi (byte) shiftProtoBobRight::carry#1 = (byte) 0 [phi:shiftProtoBobRight::@2->shiftProtoBobRight::@4#0] -- vbuz1=vbuc1 lda #0 sta.z carry jmp __b4 - // [220] phi from shiftProtoBobRight::@2 to shiftProtoBobRight::@3 [phi:shiftProtoBobRight::@2->shiftProtoBobRight::@3] + // [219] phi from shiftProtoBobRight::@2 to shiftProtoBobRight::@3 [phi:shiftProtoBobRight::@2->shiftProtoBobRight::@3] __b3_from___b2: jmp __b3 // shiftProtoBobRight::@3 __b3: - // [221] phi from shiftProtoBobRight::@3 to shiftProtoBobRight::@4 [phi:shiftProtoBobRight::@3->shiftProtoBobRight::@4] + // [220] phi from shiftProtoBobRight::@3 to shiftProtoBobRight::@4 [phi:shiftProtoBobRight::@3->shiftProtoBobRight::@4] __b4_from___b3: - // [221] phi (byte) shiftProtoBobRight::carry#1 = (byte) $80 [phi:shiftProtoBobRight::@3->shiftProtoBobRight::@4#0] -- vbuz1=vbuc1 + // [220] phi (byte) shiftProtoBobRight::carry#1 = (byte) $80 [phi:shiftProtoBobRight::@3->shiftProtoBobRight::@4#0] -- vbuz1=vbuc1 lda #$80 sta.z carry jmp __b4 // shiftProtoBobRight::@4 __b4: - // [222] (byte~) shiftProtoBobRight::$5 ← *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) >> (byte) 1 -- vbuz1=pbuc1_derefidx_vbuz2_ror_1 + // [221] (byte~) shiftProtoBobRight::$5 ← *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) >> (byte) 1 -- vbuz1=pbuc1_derefidx_vbuz2_ror_1 ldy.z j lda PROTO_BOB,y lsr sta.z __5 - // [223] (byte~) shiftProtoBobRight::$6 ← (byte) shiftProtoBobRight::carry#2 | (byte~) shiftProtoBobRight::$5 -- vbuz1=vbuz2_bor_vbuz3 + // [222] (byte~) shiftProtoBobRight::$6 ← (byte) shiftProtoBobRight::carry#2 | (byte~) shiftProtoBobRight::$5 -- vbuz1=vbuz2_bor_vbuz3 lda.z carry_1 ora.z __5 sta.z __6 - // [224] *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) ← (byte~) shiftProtoBobRight::$6 -- pbuc1_derefidx_vbuz1=vbuz2 + // [223] *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) ← (byte~) shiftProtoBobRight::$6 -- pbuc1_derefidx_vbuz1=vbuz2 // Shift value and add old carry lda.z __6 ldy.z j sta PROTO_BOB,y - // [225] if((byte) shiftProtoBobRight::j#3>=(byte) $30) goto shiftProtoBobRight::@5 -- vbuz1_ge_vbuc1_then_la1 + // [224] if((byte) shiftProtoBobRight::j#3>=(byte) $30) goto shiftProtoBobRight::@5 -- vbuz1_ge_vbuc1_then_la1 // Increment j to iterate over the PROTO_BOB left-to-right, top-to-bottom (0, 24, 48, 1, 25, 49, ...) lda.z j cmp #$30 @@ -6555,31 +6532,31 @@ shiftProtoBobRight: { jmp __b7 // shiftProtoBobRight::@7 __b7: - // [226] (byte) shiftProtoBobRight::j#2 ← (byte) shiftProtoBobRight::j#3 + (byte) $18 -- vbuz1=vbuz1_plus_vbuc1 + // [225] (byte) shiftProtoBobRight::j#2 ← (byte) shiftProtoBobRight::j#3 + (byte) $18 -- vbuz1=vbuz1_plus_vbuc1 lax.z j axs #-[$18] stx.z j - // [227] phi from shiftProtoBobRight::@5 shiftProtoBobRight::@7 to shiftProtoBobRight::@6 [phi:shiftProtoBobRight::@5/shiftProtoBobRight::@7->shiftProtoBobRight::@6] + // [226] phi from shiftProtoBobRight::@5 shiftProtoBobRight::@7 to shiftProtoBobRight::@6 [phi:shiftProtoBobRight::@5/shiftProtoBobRight::@7->shiftProtoBobRight::@6] __b6_from___b5: __b6_from___b7: - // [227] phi (byte) shiftProtoBobRight::j#10 = (byte) shiftProtoBobRight::j#1 [phi:shiftProtoBobRight::@5/shiftProtoBobRight::@7->shiftProtoBobRight::@6#0] -- register_copy + // [226] phi (byte) shiftProtoBobRight::j#10 = (byte) shiftProtoBobRight::j#1 [phi:shiftProtoBobRight::@5/shiftProtoBobRight::@7->shiftProtoBobRight::@6#0] -- register_copy jmp __b6 // shiftProtoBobRight::@6 __b6: - // [228] (byte) shiftProtoBobRight::i#1 ← ++ (byte) shiftProtoBobRight::i#2 -- vbuz1=_inc_vbuz1 + // [227] (byte) shiftProtoBobRight::i#1 ← ++ (byte) shiftProtoBobRight::i#2 -- vbuz1=_inc_vbuz1 inc.z i - // [229] (byte) shiftProtoBobRight::carry#10 ← (byte) shiftProtoBobRight::carry#1 -- vbuz1=vbuz2 + // [228] (byte) shiftProtoBobRight::carry#10 ← (byte) shiftProtoBobRight::carry#1 -- vbuz1=vbuz2 lda.z carry sta.z carry_1 - // [215] phi from shiftProtoBobRight::@6 to shiftProtoBobRight::@1 [phi:shiftProtoBobRight::@6->shiftProtoBobRight::@1] + // [214] phi from shiftProtoBobRight::@6 to shiftProtoBobRight::@1 [phi:shiftProtoBobRight::@6->shiftProtoBobRight::@1] __b1_from___b6: - // [215] phi (byte) shiftProtoBobRight::carry#2 = (byte) shiftProtoBobRight::carry#10 [phi:shiftProtoBobRight::@6->shiftProtoBobRight::@1#0] -- register_copy - // [215] phi (byte) shiftProtoBobRight::j#3 = (byte) shiftProtoBobRight::j#10 [phi:shiftProtoBobRight::@6->shiftProtoBobRight::@1#1] -- register_copy - // [215] phi (byte) shiftProtoBobRight::i#2 = (byte) shiftProtoBobRight::i#1 [phi:shiftProtoBobRight::@6->shiftProtoBobRight::@1#2] -- register_copy + // [214] phi (byte) shiftProtoBobRight::carry#2 = (byte) shiftProtoBobRight::carry#10 [phi:shiftProtoBobRight::@6->shiftProtoBobRight::@1#0] -- register_copy + // [214] phi (byte) shiftProtoBobRight::j#3 = (byte) shiftProtoBobRight::j#10 [phi:shiftProtoBobRight::@6->shiftProtoBobRight::@1#1] -- register_copy + // [214] phi (byte) shiftProtoBobRight::i#2 = (byte) shiftProtoBobRight::i#1 [phi:shiftProtoBobRight::@6->shiftProtoBobRight::@1#2] -- register_copy jmp __b1 // shiftProtoBobRight::@5 __b5: - // [230] (byte) shiftProtoBobRight::j#1 ← (byte) shiftProtoBobRight::j#3 - (byte) $2f -- vbuz1=vbuz1_minus_vbuc1 + // [229] (byte) shiftProtoBobRight::j#1 ← (byte) shiftProtoBobRight::j#3 - (byte) $2f -- vbuz1=vbuz1_minus_vbuc1 lax.z j axs #$2f stx.z j @@ -6590,53 +6567,53 @@ shiftProtoBobRight: { // At the same time restore PROTO_BOB X by shifting 8 pixels left shiftProtoBobDown: { .label i = $29 - // [232] phi from shiftProtoBobDown to shiftProtoBobDown::@1 [phi:shiftProtoBobDown->shiftProtoBobDown::@1] + // [231] phi from shiftProtoBobDown to shiftProtoBobDown::@1 [phi:shiftProtoBobDown->shiftProtoBobDown::@1] __b1_from_shiftProtoBobDown: - // [232] phi (byte) shiftProtoBobDown::i#2 = (byte) $17 [phi:shiftProtoBobDown->shiftProtoBobDown::@1#0] -- vbuz1=vbuc1 + // [231] phi (byte) shiftProtoBobDown::i#2 = (byte) $17 [phi:shiftProtoBobDown->shiftProtoBobDown::@1#0] -- vbuz1=vbuc1 lda #$17 sta.z i jmp __b1 // shiftProtoBobDown::@1 __b1: - // [233] if((byte) shiftProtoBobDown::i#2>(byte) 0) goto shiftProtoBobDown::@2 -- vbuz1_gt_0_then_la1 + // [232] if((byte) shiftProtoBobDown::i#2>(byte) 0) goto shiftProtoBobDown::@2 -- vbuz1_gt_0_then_la1 lda.z i bne __b2 jmp __b3 // shiftProtoBobDown::@3 __b3: - // [234] *((const byte*) PROTO_BOB) ← (byte) 0 -- _deref_pbuc1=vbuc2 + // [233] *((const byte*) PROTO_BOB) ← (byte) 0 -- _deref_pbuc1=vbuc2 lda #0 sta PROTO_BOB - // [235] *((const byte*) PROTO_BOB+(byte) $18) ← (byte) 0 -- _deref_pbuc1=vbuc2 + // [234] *((const byte*) PROTO_BOB+(byte) $18) ← (byte) 0 -- _deref_pbuc1=vbuc2 lda #0 sta PROTO_BOB+$18 - // [236] *((const byte*) PROTO_BOB+(byte) $30) ← (byte) 0 -- _deref_pbuc1=vbuc2 + // [235] *((const byte*) PROTO_BOB+(byte) $30) ← (byte) 0 -- _deref_pbuc1=vbuc2 lda #0 sta PROTO_BOB+$30 jmp __breturn // shiftProtoBobDown::@return __breturn: - // [237] return + // [236] return rts // shiftProtoBobDown::@2 __b2: - // [238] *((const byte*) PROTO_BOB + (byte) shiftProtoBobDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $17 + (byte) shiftProtoBobDown::i#2) -- pbuc1_derefidx_vbuz1=pbuc2_derefidx_vbuz1 + // [237] *((const byte*) PROTO_BOB + (byte) shiftProtoBobDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $17 + (byte) shiftProtoBobDown::i#2) -- pbuc1_derefidx_vbuz1=pbuc2_derefidx_vbuz1 ldy.z i lda PROTO_BOB+$17,y sta PROTO_BOB,y - // [239] *((const byte*) PROTO_BOB+(byte) $18 + (byte) shiftProtoBobDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $2f + (byte) shiftProtoBobDown::i#2) -- pbuc1_derefidx_vbuz1=pbuc2_derefidx_vbuz1 + // [238] *((const byte*) PROTO_BOB+(byte) $18 + (byte) shiftProtoBobDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $2f + (byte) shiftProtoBobDown::i#2) -- pbuc1_derefidx_vbuz1=pbuc2_derefidx_vbuz1 ldy.z i lda PROTO_BOB+$2f,y sta PROTO_BOB+$18,y - // [240] *((const byte*) PROTO_BOB+(byte) $30 + (byte) shiftProtoBobDown::i#2) ← (byte) 0 -- pbuc1_derefidx_vbuz1=vbuc2 + // [239] *((const byte*) PROTO_BOB+(byte) $30 + (byte) shiftProtoBobDown::i#2) ← (byte) 0 -- pbuc1_derefidx_vbuz1=vbuc2 lda #0 ldy.z i sta PROTO_BOB+$30,y - // [241] (byte) shiftProtoBobDown::i#1 ← -- (byte) shiftProtoBobDown::i#2 -- vbuz1=_dec_vbuz1 + // [240] (byte) shiftProtoBobDown::i#1 ← -- (byte) shiftProtoBobDown::i#2 -- vbuz1=_dec_vbuz1 dec.z i - // [232] phi from shiftProtoBobDown::@2 to shiftProtoBobDown::@1 [phi:shiftProtoBobDown::@2->shiftProtoBobDown::@1] + // [231] phi from shiftProtoBobDown::@2 to shiftProtoBobDown::@1 [phi:shiftProtoBobDown::@2->shiftProtoBobDown::@1] __b1_from___b2: - // [232] phi (byte) shiftProtoBobDown::i#2 = (byte) shiftProtoBobDown::i#1 [phi:shiftProtoBobDown::@2->shiftProtoBobDown::@1#0] -- register_copy + // [231] phi (byte) shiftProtoBobDown::i#2 = (byte) shiftProtoBobDown::i#1 [phi:shiftProtoBobDown::@2->shiftProtoBobDown::@1#0] -- register_copy jmp __b1 } // progress_init @@ -6645,7 +6622,7 @@ progress_init: { jmp __breturn // progress_init::@return __breturn: - // [243] return + // [242] return rts } // mulf_init @@ -6671,25 +6648,25 @@ mulf_init: { .label sqr2_lo = $30 //Start with g(0)=f(255) .label dir = $35 - // [245] phi from mulf_init to mulf_init::@1 [phi:mulf_init->mulf_init::@1] + // [244] phi from mulf_init to mulf_init::@1 [phi:mulf_init->mulf_init::@1] __b1_from_mulf_init: - // [245] phi (byte) mulf_init::x_2#3 = (byte) 0 [phi:mulf_init->mulf_init::@1#0] -- vbuz1=vbuc1 + // [244] phi (byte) mulf_init::x_2#3 = (byte) 0 [phi:mulf_init->mulf_init::@1#0] -- vbuz1=vbuc1 lda #0 sta.z x_2 - // [245] phi (byte*) mulf_init::sqr1_hi#2 = (const byte*) mulf_sqr1_hi+(byte) 1 [phi:mulf_init->mulf_init::@1#1] -- pbuz1=pbuc1 + // [244] phi (byte*) mulf_init::sqr1_hi#2 = (const byte*) mulf_sqr1_hi+(byte) 1 [phi:mulf_init->mulf_init::@1#1] -- pbuz1=pbuc1 lda #mulf_sqr1_hi+1 sta.z sqr1_hi+1 - // [245] phi (word) mulf_init::sqr#4 = (byte) 0 [phi:mulf_init->mulf_init::@1#2] -- vwuz1=vbuc1 + // [244] phi (word) mulf_init::sqr#4 = (byte) 0 [phi:mulf_init->mulf_init::@1#2] -- vwuz1=vbuc1 lda #<0 sta.z sqr lda #>0 sta.z sqr+1 - // [245] phi (byte) mulf_init::c#2 = (byte) 0 [phi:mulf_init->mulf_init::@1#3] -- vbuz1=vbuc1 + // [244] phi (byte) mulf_init::c#2 = (byte) 0 [phi:mulf_init->mulf_init::@1#3] -- vbuz1=vbuc1 lda #0 sta.z c - // [245] phi (byte*) mulf_init::sqr1_lo#2 = (const byte*) mulf_sqr1_lo+(byte) 1 [phi:mulf_init->mulf_init::@1#4] -- pbuz1=pbuc1 + // [244] phi (byte*) mulf_init::sqr1_lo#2 = (const byte*) mulf_sqr1_lo+(byte) 1 [phi:mulf_init->mulf_init::@1#4] -- pbuz1=pbuc1 lda #mulf_sqr1_lo+1 @@ -6697,27 +6674,27 @@ mulf_init: { jmp __b1 // mulf_init::@1 __b1: - // [246] if((byte*) mulf_init::sqr1_lo#2!=(const byte*) mulf_sqr1_lo+(word) $200) goto mulf_init::@2 -- pbuz1_neq_pbuc1_then_la1 + // [245] if((byte*) mulf_init::sqr1_lo#2!=(const byte*) mulf_sqr1_lo+(word) $200) goto mulf_init::@2 -- pbuz1_neq_pbuc1_then_la1 lda.z sqr1_lo+1 cmp #>mulf_sqr1_lo+$200 bne __b2 lda.z sqr1_lo cmp #mulf_init::@5] + // [246] phi from mulf_init::@1 to mulf_init::@5 [phi:mulf_init::@1->mulf_init::@5] __b5_from___b1: - // [247] phi (byte) mulf_init::dir#2 = (byte) $ff [phi:mulf_init::@1->mulf_init::@5#0] -- vbuz1=vbuc1 + // [246] phi (byte) mulf_init::dir#2 = (byte) $ff [phi:mulf_init::@1->mulf_init::@5#0] -- vbuz1=vbuc1 lda #$ff sta.z dir - // [247] phi (byte*) mulf_init::sqr2_hi#2 = (const byte*) mulf_sqr2_hi [phi:mulf_init::@1->mulf_init::@5#1] -- pbuz1=pbuc1 + // [246] phi (byte*) mulf_init::sqr2_hi#2 = (const byte*) mulf_sqr2_hi [phi:mulf_init::@1->mulf_init::@5#1] -- pbuz1=pbuc1 lda #mulf_sqr2_hi sta.z sqr2_hi+1 - // [247] phi (byte) mulf_init::x_255#2 = (byte) -1 [phi:mulf_init::@1->mulf_init::@5#2] -- vbuz1=vbuc1 + // [246] phi (byte) mulf_init::x_255#2 = (byte) -1 [phi:mulf_init::@1->mulf_init::@5#2] -- vbuz1=vbuc1 lda #-1 sta.z x_255 - // [247] phi (byte*) mulf_init::sqr2_lo#2 = (const byte*) mulf_sqr2_lo [phi:mulf_init::@1->mulf_init::@5#3] -- pbuz1=pbuc1 + // [246] phi (byte*) mulf_init::sqr2_lo#2 = (const byte*) mulf_sqr2_lo [phi:mulf_init::@1->mulf_init::@5#3] -- pbuz1=pbuc1 lda #mulf_sqr2_lo @@ -6725,7 +6702,7 @@ mulf_init: { jmp __b5 // mulf_init::@5 __b5: - // [248] if((byte*) mulf_init::sqr2_lo#2!=(const byte*) mulf_sqr2_lo+(word) $1ff) goto mulf_init::@6 -- pbuz1_neq_pbuc1_then_la1 + // [247] if((byte*) mulf_init::sqr2_lo#2!=(const byte*) mulf_sqr2_lo+(word) $1ff) goto mulf_init::@6 -- pbuz1_neq_pbuc1_then_la1 lda.z sqr2_lo+1 cmp #>mulf_sqr2_lo+$1ff bne __b6 @@ -6735,123 +6712,123 @@ mulf_init: { jmp __b7 // mulf_init::@7 __b7: - // [249] *((const byte*) mulf_sqr2_lo+(word) $1ff) ← *((const byte*) mulf_sqr1_lo+(word) $100) -- _deref_pbuc1=_deref_pbuc2 + // [248] *((const byte*) mulf_sqr2_lo+(word) $1ff) ← *((const byte*) mulf_sqr1_lo+(word) $100) -- _deref_pbuc1=_deref_pbuc2 // Set the very last value g(511) = f(256) lda mulf_sqr1_lo+$100 sta mulf_sqr2_lo+$1ff - // [250] *((const byte*) mulf_sqr2_hi+(word) $1ff) ← *((const byte*) mulf_sqr1_hi+(word) $100) -- _deref_pbuc1=_deref_pbuc2 + // [249] *((const byte*) mulf_sqr2_hi+(word) $1ff) ← *((const byte*) mulf_sqr1_hi+(word) $100) -- _deref_pbuc1=_deref_pbuc2 lda mulf_sqr1_hi+$100 sta mulf_sqr2_hi+$1ff jmp __breturn // mulf_init::@return __breturn: - // [251] return + // [250] return rts // mulf_init::@6 __b6: - // [252] *((byte*) mulf_init::sqr2_lo#2) ← *((const byte*) mulf_sqr1_lo + (byte) mulf_init::x_255#2) -- _deref_pbuz1=pbuc1_derefidx_vbuz2 + // [251] *((byte*) mulf_init::sqr2_lo#2) ← *((const byte*) mulf_sqr1_lo + (byte) mulf_init::x_255#2) -- _deref_pbuz1=pbuc1_derefidx_vbuz2 ldy.z x_255 lda mulf_sqr1_lo,y ldy #0 sta (sqr2_lo),y - // [253] *((byte*) mulf_init::sqr2_hi#2) ← *((const byte*) mulf_sqr1_hi + (byte) mulf_init::x_255#2) -- _deref_pbuz1=pbuc1_derefidx_vbuz2 + // [252] *((byte*) mulf_init::sqr2_hi#2) ← *((const byte*) mulf_sqr1_hi + (byte) mulf_init::x_255#2) -- _deref_pbuz1=pbuc1_derefidx_vbuz2 ldy.z x_255 lda mulf_sqr1_hi,y ldy #0 sta (sqr2_hi),y - // [254] (byte*) mulf_init::sqr2_hi#1 ← ++ (byte*) mulf_init::sqr2_hi#2 -- pbuz1=_inc_pbuz1 + // [253] (byte*) mulf_init::sqr2_hi#1 ← ++ (byte*) mulf_init::sqr2_hi#2 -- pbuz1=_inc_pbuz1 inc.z sqr2_hi bne !+ inc.z sqr2_hi+1 !: - // [255] (byte) mulf_init::x_255#1 ← (byte) mulf_init::x_255#2 + (byte) mulf_init::dir#2 -- vbuz1=vbuz1_plus_vbuz2 + // [254] (byte) mulf_init::x_255#1 ← (byte) mulf_init::x_255#2 + (byte) mulf_init::dir#2 -- vbuz1=vbuz1_plus_vbuz2 lda.z x_255 clc adc.z dir sta.z x_255 - // [256] if((byte) mulf_init::x_255#1!=(byte) 0) goto mulf_init::@9 -- vbuz1_neq_0_then_la1 + // [255] if((byte) mulf_init::x_255#1!=(byte) 0) goto mulf_init::@9 -- vbuz1_neq_0_then_la1 lda.z x_255 cmp #0 bne __b9_from___b6 - // [258] phi from mulf_init::@6 to mulf_init::@8 [phi:mulf_init::@6->mulf_init::@8] + // [257] phi from mulf_init::@6 to mulf_init::@8 [phi:mulf_init::@6->mulf_init::@8] __b8_from___b6: - // [258] phi (byte) mulf_init::dir#4 = (byte) 1 [phi:mulf_init::@6->mulf_init::@8#0] -- vbuz1=vbuc1 + // [257] phi (byte) mulf_init::dir#4 = (byte) 1 [phi:mulf_init::@6->mulf_init::@8#0] -- vbuz1=vbuc1 lda #1 sta.z dir jmp __b8 - // [257] phi from mulf_init::@6 to mulf_init::@9 [phi:mulf_init::@6->mulf_init::@9] + // [256] phi from mulf_init::@6 to mulf_init::@9 [phi:mulf_init::@6->mulf_init::@9] __b9_from___b6: jmp __b9 // mulf_init::@9 __b9: - // [258] phi from mulf_init::@9 to mulf_init::@8 [phi:mulf_init::@9->mulf_init::@8] + // [257] phi from mulf_init::@9 to mulf_init::@8 [phi:mulf_init::@9->mulf_init::@8] __b8_from___b9: - // [258] phi (byte) mulf_init::dir#4 = (byte) mulf_init::dir#2 [phi:mulf_init::@9->mulf_init::@8#0] -- register_copy + // [257] phi (byte) mulf_init::dir#4 = (byte) mulf_init::dir#2 [phi:mulf_init::@9->mulf_init::@8#0] -- register_copy jmp __b8 // mulf_init::@8 __b8: - // [259] (byte*) mulf_init::sqr2_lo#1 ← ++ (byte*) mulf_init::sqr2_lo#2 -- pbuz1=_inc_pbuz1 + // [258] (byte*) mulf_init::sqr2_lo#1 ← ++ (byte*) mulf_init::sqr2_lo#2 -- pbuz1=_inc_pbuz1 inc.z sqr2_lo bne !+ inc.z sqr2_lo+1 !: - // [247] phi from mulf_init::@8 to mulf_init::@5 [phi:mulf_init::@8->mulf_init::@5] + // [246] phi from mulf_init::@8 to mulf_init::@5 [phi:mulf_init::@8->mulf_init::@5] __b5_from___b8: - // [247] phi (byte) mulf_init::dir#2 = (byte) mulf_init::dir#4 [phi:mulf_init::@8->mulf_init::@5#0] -- register_copy - // [247] phi (byte*) mulf_init::sqr2_hi#2 = (byte*) mulf_init::sqr2_hi#1 [phi:mulf_init::@8->mulf_init::@5#1] -- register_copy - // [247] phi (byte) mulf_init::x_255#2 = (byte) mulf_init::x_255#1 [phi:mulf_init::@8->mulf_init::@5#2] -- register_copy - // [247] phi (byte*) mulf_init::sqr2_lo#2 = (byte*) mulf_init::sqr2_lo#1 [phi:mulf_init::@8->mulf_init::@5#3] -- register_copy + // [246] phi (byte) mulf_init::dir#2 = (byte) mulf_init::dir#4 [phi:mulf_init::@8->mulf_init::@5#0] -- register_copy + // [246] phi (byte*) mulf_init::sqr2_hi#2 = (byte*) mulf_init::sqr2_hi#1 [phi:mulf_init::@8->mulf_init::@5#1] -- register_copy + // [246] phi (byte) mulf_init::x_255#2 = (byte) mulf_init::x_255#1 [phi:mulf_init::@8->mulf_init::@5#2] -- register_copy + // [246] phi (byte*) mulf_init::sqr2_lo#2 = (byte*) mulf_init::sqr2_lo#1 [phi:mulf_init::@8->mulf_init::@5#3] -- register_copy jmp __b5 // mulf_init::@2 __b2: - // [260] (byte) mulf_init::c#1 ← ++ (byte) mulf_init::c#2 -- vbuz1=_inc_vbuz1 + // [259] (byte) mulf_init::c#1 ← ++ (byte) mulf_init::c#2 -- vbuz1=_inc_vbuz1 inc.z c - // [261] (byte~) mulf_init::$1 ← (byte) mulf_init::c#1 & (byte) 1 -- vbuz1=vbuz2_band_vbuc1 + // [260] (byte~) mulf_init::$1 ← (byte) mulf_init::c#1 & (byte) 1 -- vbuz1=vbuz2_band_vbuc1 lda #1 and.z c sta.z __1 - // [262] if((byte~) mulf_init::$1!=(byte) 0) goto mulf_init::@3 -- vbuz1_neq_0_then_la1 + // [261] if((byte~) mulf_init::$1!=(byte) 0) goto mulf_init::@3 -- vbuz1_neq_0_then_la1 lda.z __1 cmp #0 bne __b3_from___b2 jmp __b4 // mulf_init::@4 __b4: - // [263] (byte) mulf_init::x_2#1 ← ++ (byte) mulf_init::x_2#3 -- vbuz1=_inc_vbuz1 + // [262] (byte) mulf_init::x_2#1 ← ++ (byte) mulf_init::x_2#3 -- vbuz1=_inc_vbuz1 inc.z x_2 - // [264] (word) mulf_init::sqr#2 ← ++ (word) mulf_init::sqr#4 -- vwuz1=_inc_vwuz1 + // [263] (word) mulf_init::sqr#2 ← ++ (word) mulf_init::sqr#4 -- vwuz1=_inc_vwuz1 inc.z sqr bne !+ inc.z sqr+1 !: - // [265] phi from mulf_init::@2 mulf_init::@4 to mulf_init::@3 [phi:mulf_init::@2/mulf_init::@4->mulf_init::@3] + // [264] phi from mulf_init::@2 mulf_init::@4 to mulf_init::@3 [phi:mulf_init::@2/mulf_init::@4->mulf_init::@3] __b3_from___b2: __b3_from___b4: - // [265] phi (byte) mulf_init::x_2#2 = (byte) mulf_init::x_2#3 [phi:mulf_init::@2/mulf_init::@4->mulf_init::@3#0] -- register_copy - // [265] phi (word) mulf_init::sqr#3 = (word) mulf_init::sqr#4 [phi:mulf_init::@2/mulf_init::@4->mulf_init::@3#1] -- register_copy + // [264] phi (byte) mulf_init::x_2#2 = (byte) mulf_init::x_2#3 [phi:mulf_init::@2/mulf_init::@4->mulf_init::@3#0] -- register_copy + // [264] phi (word) mulf_init::sqr#3 = (word) mulf_init::sqr#4 [phi:mulf_init::@2/mulf_init::@4->mulf_init::@3#1] -- register_copy jmp __b3 // mulf_init::@3 __b3: - // [266] (byte~) mulf_init::$4 ← < (word) mulf_init::sqr#3 -- vbuz1=_lo_vwuz2 + // [265] (byte~) mulf_init::$4 ← < (word) mulf_init::sqr#3 -- vbuz1=_lo_vwuz2 lda.z sqr sta.z __4 - // [267] *((byte*) mulf_init::sqr1_lo#2) ← (byte~) mulf_init::$4 -- _deref_pbuz1=vbuz2 + // [266] *((byte*) mulf_init::sqr1_lo#2) ← (byte~) mulf_init::$4 -- _deref_pbuz1=vbuz2 lda.z __4 ldy #0 sta (sqr1_lo),y - // [268] (byte~) mulf_init::$5 ← > (word) mulf_init::sqr#3 -- vbuz1=_hi_vwuz2 + // [267] (byte~) mulf_init::$5 ← > (word) mulf_init::sqr#3 -- vbuz1=_hi_vwuz2 lda.z sqr+1 sta.z __5 - // [269] *((byte*) mulf_init::sqr1_hi#2) ← (byte~) mulf_init::$5 -- _deref_pbuz1=vbuz2 + // [268] *((byte*) mulf_init::sqr1_hi#2) ← (byte~) mulf_init::$5 -- _deref_pbuz1=vbuz2 lda.z __5 ldy #0 sta (sqr1_hi),y - // [270] (byte*) mulf_init::sqr1_hi#1 ← ++ (byte*) mulf_init::sqr1_hi#2 -- pbuz1=_inc_pbuz1 + // [269] (byte*) mulf_init::sqr1_hi#1 ← ++ (byte*) mulf_init::sqr1_hi#2 -- pbuz1=_inc_pbuz1 inc.z sqr1_hi bne !+ inc.z sqr1_hi+1 !: - // [271] (word) mulf_init::sqr#1 ← (word) mulf_init::sqr#3 + (byte) mulf_init::x_2#2 -- vwuz1=vwuz1_plus_vbuz2 + // [270] (word) mulf_init::sqr#1 ← (word) mulf_init::sqr#3 + (byte) mulf_init::x_2#2 -- vwuz1=vwuz1_plus_vbuz2 lda.z x_2 clc adc.z sqr @@ -6859,18 +6836,18 @@ mulf_init: { bcc !+ inc.z sqr+1 !: - // [272] (byte*) mulf_init::sqr1_lo#1 ← ++ (byte*) mulf_init::sqr1_lo#2 -- pbuz1=_inc_pbuz1 + // [271] (byte*) mulf_init::sqr1_lo#1 ← ++ (byte*) mulf_init::sqr1_lo#2 -- pbuz1=_inc_pbuz1 inc.z sqr1_lo bne !+ inc.z sqr1_lo+1 !: - // [245] phi from mulf_init::@3 to mulf_init::@1 [phi:mulf_init::@3->mulf_init::@1] + // [244] phi from mulf_init::@3 to mulf_init::@1 [phi:mulf_init::@3->mulf_init::@1] __b1_from___b3: - // [245] phi (byte) mulf_init::x_2#3 = (byte) mulf_init::x_2#2 [phi:mulf_init::@3->mulf_init::@1#0] -- register_copy - // [245] phi (byte*) mulf_init::sqr1_hi#2 = (byte*) mulf_init::sqr1_hi#1 [phi:mulf_init::@3->mulf_init::@1#1] -- register_copy - // [245] phi (word) mulf_init::sqr#4 = (word) mulf_init::sqr#1 [phi:mulf_init::@3->mulf_init::@1#2] -- register_copy - // [245] phi (byte) mulf_init::c#2 = (byte) mulf_init::c#1 [phi:mulf_init::@3->mulf_init::@1#3] -- register_copy - // [245] phi (byte*) mulf_init::sqr1_lo#2 = (byte*) mulf_init::sqr1_lo#1 [phi:mulf_init::@3->mulf_init::@1#4] -- register_copy + // [244] phi (byte) mulf_init::x_2#3 = (byte) mulf_init::x_2#2 [phi:mulf_init::@3->mulf_init::@1#0] -- register_copy + // [244] phi (byte*) mulf_init::sqr1_hi#2 = (byte*) mulf_init::sqr1_hi#1 [phi:mulf_init::@3->mulf_init::@1#1] -- register_copy + // [244] phi (word) mulf_init::sqr#4 = (word) mulf_init::sqr#1 [phi:mulf_init::@3->mulf_init::@1#2] -- register_copy + // [244] phi (byte) mulf_init::c#2 = (byte) mulf_init::c#1 [phi:mulf_init::@3->mulf_init::@1#3] -- register_copy + // [244] phi (byte*) mulf_init::sqr1_lo#2 = (byte*) mulf_init::sqr1_lo#1 [phi:mulf_init::@3->mulf_init::@1#4] -- register_copy jmp __b1 } // File Data @@ -6919,423 +6896,401 @@ SIN: MUL40: .fill 2*$20, 0 REGISTER UPLIFT POTENTIAL REGISTERS -Statement [11] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 [ ] ( main:3 [ ] ) always clobbers reg byte a -Statement [13] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank1_toDd001_return#0 [ ] ( main:3 [ ] ) always clobbers reg byte a -Statement [15] *((const byte*) D018) ← (const byte) main::toD0181_return#0 [ ] ( main:3 [ ] ) always clobbers reg byte a -Statement [18] if(*((const byte*) RASTER)<(byte) $f8) goto main::@2 [ main::angle#8 ] ( main:3 [ main::angle#8 ] ) always clobbers reg byte a +Statement [10] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [12] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank1_toDd001_return#0 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [14] *((const byte*) D018) ← (const byte) main::toD0181_return#0 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [17] if(*((const byte*) RASTER)<(byte) $f8) goto main::@2 [ main::angle#8 ] ( main:2 [ main::angle#8 ] ) always clobbers reg byte a Removing always clobbered register reg byte a as potential for zp[1]:2 [ main::angle#8 main::angle#1 ] -Statement [19] *((const byte*) BORDERCOL) ← (byte) $f [ main::angle#8 ] ( main:3 [ main::angle#8 ] ) always clobbers reg byte a -Statement [23] *((const byte*) BORDERCOL) ← (byte) 1 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 ] ( main:3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 ] ) always clobbers reg byte a +Statement [18] *((const byte*) BORDERCOL) ← (byte) $f [ main::angle#8 ] ( main:2 [ main::angle#8 ] ) always clobbers reg byte a +Statement [22] *((const byte*) BORDERCOL) ← (byte) 1 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 ] ) always clobbers reg byte a Removing always clobbered register reg byte a as potential for zp[1]:3 [ main::r#2 main::r#1 ] Removing always clobbered register reg byte a as potential for zp[1]:4 [ main::a#2 main::a#6 main::a#1 ] Removing always clobbered register reg byte a as potential for zp[1]:7 [ main::i#2 main::i#1 ] -Statement [27] (signed word) mulf8s::return#2 ← (signed word) mulf8s::return#0 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::return#2 ] ( main:3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::return#2 ] ) always clobbers reg byte a -Statement [28] (signed word~) main::$10 ← (signed word) mulf8s::return#2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::$10 ] ( main:3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::$10 ] ) always clobbers reg byte a -Statement [29] (signed word) main::x#0 ← (signed word~) main::$10 + (signed word)(number) $4b*(number) $100 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 ] ( main:3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 ] ) always clobbers reg byte a -Statement [33] (signed word) mulf8s::return#3 ← (signed word) mulf8s::return#0 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::return#3 ] ( main:3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::return#3 ] ) always clobbers reg byte a -Statement [34] (signed word~) main::$12 ← (signed word) mulf8s::return#3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$12 ] ( main:3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$12 ] ) always clobbers reg byte a -Statement [35] (signed word~) main::$13 ← (signed word~) main::$12 << (byte) 1 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$13 ] ( main:3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$13 ] ) always clobbers reg byte a -Statement [36] (signed word) main::y#0 ← (signed word~) main::$13 + (signed word)(number) $5a*(number) $100 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ( main:3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ) always clobbers reg byte a -Statement [37] *((const byte*) BORDERCOL) ← (byte) 2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ( main:3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ) always clobbers reg byte a -Statement [38] (byte) main::a#1 ← (byte) main::a#2 + (byte) $62 [ main::angle#8 main::r#2 renderBobCleanupNext#17 main::i#2 main::a#1 main::x#0 main::y#0 ] ( main:3 [ main::angle#8 main::r#2 renderBobCleanupNext#17 main::i#2 main::a#1 main::x#0 main::y#0 ] ) always clobbers reg byte a -Statement [39] (signed byte) main::r#1 ← (signed byte) main::r#2 + (signed byte) 3 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::x#0 main::y#0 ] ( main:3 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::x#0 main::y#0 ] ) always clobbers reg byte a -Statement [40] (byte) renderBob::xpos#0 ← > (signed word) main::x#0 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::y#0 renderBob::xpos#0 ] ( main:3 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::y#0 renderBob::xpos#0 ] ) always clobbers reg byte a -Statement [41] (byte) renderBob::ypos#0 ← > (signed word) main::y#0 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 renderBob::xpos#0 renderBob::ypos#0 ] ( main:3 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 renderBob::xpos#0 renderBob::ypos#0 ] ) always clobbers reg byte a +Statement [26] (signed word) mulf8s::return#2 ← (signed word) mulf8s::return#0 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::return#2 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::return#2 ] ) always clobbers reg byte a +Statement [27] (signed word~) main::$10 ← (signed word) mulf8s::return#2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::$10 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::$10 ] ) always clobbers reg byte a +Statement [28] (signed word) main::x#0 ← (signed word~) main::$10 + (signed word)(number) $4b*(number) $100 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 ] ) always clobbers reg byte a +Statement [32] (signed word) mulf8s::return#3 ← (signed word) mulf8s::return#0 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::return#3 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::return#3 ] ) always clobbers reg byte a +Statement [33] (signed word~) main::$12 ← (signed word) mulf8s::return#3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$12 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$12 ] ) always clobbers reg byte a +Statement [34] (signed word~) main::$13 ← (signed word~) main::$12 << (byte) 1 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$13 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$13 ] ) always clobbers reg byte a +Statement [35] (signed word) main::y#0 ← (signed word~) main::$13 + (signed word)(number) $5a*(number) $100 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ) always clobbers reg byte a +Statement [36] *((const byte*) BORDERCOL) ← (byte) 2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ) always clobbers reg byte a +Statement [37] (byte) main::a#1 ← (byte) main::a#2 + (byte) $62 [ main::angle#8 main::r#2 renderBobCleanupNext#17 main::i#2 main::a#1 main::x#0 main::y#0 ] ( main:2 [ main::angle#8 main::r#2 renderBobCleanupNext#17 main::i#2 main::a#1 main::x#0 main::y#0 ] ) always clobbers reg byte a +Statement [38] (signed byte) main::r#1 ← (signed byte) main::r#2 + (signed byte) 3 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::x#0 main::y#0 ] ( main:2 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::x#0 main::y#0 ] ) always clobbers reg byte a +Statement [39] (byte) renderBob::xpos#0 ← > (signed word) main::x#0 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::y#0 renderBob::xpos#0 ] ( main:2 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::y#0 renderBob::xpos#0 ] ) always clobbers reg byte a +Statement [40] (byte) renderBob::ypos#0 ← > (signed word) main::y#0 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 renderBob::xpos#0 renderBob::ypos#0 ] ( main:2 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 renderBob::xpos#0 renderBob::ypos#0 ] ) always clobbers reg byte a Removing always clobbered register reg byte a as potential for zp[1]:70 [ renderBob::xpos#0 ] -Statement [45] (byte) main::angle#1 ← (byte) main::angle#8 + (byte) 3 [ main::angle#1 ] ( main:3 [ main::angle#1 ] ) always clobbers reg byte a -Statement [46] *((const byte*) BORDERCOL) ← (byte) 0 [ main::angle#1 ] ( main:3 [ main::angle#1 ] ) always clobbers reg byte a -Statement [56] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 [ ] ( main:3 [ ] ) always clobbers reg byte a -Statement [58] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank2_toDd001_return#0 [ ] ( main:3 [ ] ) always clobbers reg byte a -Statement [60] *((const byte*) D018) ← (const byte) main::toD0182_return#0 [ ] ( main:3 [ ] ) always clobbers reg byte a -Statement [68] *((const byte*) CIA1_PORT_A) ← *((const byte*) keyboard_matrix_row_bitmask+(const byte) keyboard_key_pressed::rowidx#0) [ ] ( main:3::keyboard_key_pressed:47::keyboard_matrix_read:63 [ main::angle#1 ] main:3::keyboard_key_pressed:52::keyboard_matrix_read:63 [ ] ) always clobbers reg byte a -Statement [69] (byte) keyboard_matrix_read::return#0 ← ~ *((const byte*) CIA1_PORT_B) [ keyboard_matrix_read::return#0 ] ( main:3::keyboard_key_pressed:47::keyboard_matrix_read:63 [ main::angle#1 keyboard_matrix_read::return#0 ] main:3::keyboard_key_pressed:52::keyboard_matrix_read:63 [ keyboard_matrix_read::return#0 ] ) always clobbers reg byte a -Statement [71] (byte) renderBob::x_char_offset#0 ← (byte) renderBob::xpos#0 >> (byte) 2 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 ] ) always clobbers reg byte a +Statement [44] (byte) main::angle#1 ← (byte) main::angle#8 + (byte) 3 [ main::angle#1 ] ( main:2 [ main::angle#1 ] ) always clobbers reg byte a +Statement [45] *((const byte*) BORDERCOL) ← (byte) 0 [ main::angle#1 ] ( main:2 [ main::angle#1 ] ) always clobbers reg byte a +Statement [55] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [57] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank2_toDd001_return#0 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [59] *((const byte*) D018) ← (const byte) main::toD0182_return#0 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [67] *((const byte*) CIA1_PORT_A) ← *((const byte*) keyboard_matrix_row_bitmask+(const byte) keyboard_key_pressed::rowidx#0) [ ] ( main:2::keyboard_key_pressed:46::keyboard_matrix_read:62 [ main::angle#1 ] main:2::keyboard_key_pressed:51::keyboard_matrix_read:62 [ ] ) always clobbers reg byte a +Statement [68] (byte) keyboard_matrix_read::return#0 ← ~ *((const byte*) CIA1_PORT_B) [ keyboard_matrix_read::return#0 ] ( main:2::keyboard_key_pressed:46::keyboard_matrix_read:62 [ main::angle#1 keyboard_matrix_read::return#0 ] main:2::keyboard_key_pressed:51::keyboard_matrix_read:62 [ keyboard_matrix_read::return#0 ] ) always clobbers reg byte a +Statement [70] (byte) renderBob::x_char_offset#0 ← (byte) renderBob::xpos#0 >> (byte) 2 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 ] ) always clobbers reg byte a Removing always clobbered register reg byte a as potential for zp[1]:71 [ renderBob::ypos#0 ] -Statement [72] (byte) renderBob::y_char_offset#0 ← (byte) renderBob::ypos#0 >> (byte) 3 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_char_offset#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_char_offset#0 ] ) always clobbers reg byte a +Statement [71] (byte) renderBob::y_char_offset#0 ← (byte) renderBob::ypos#0 >> (byte) 3 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_char_offset#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_char_offset#0 ] ) always clobbers reg byte a Removing always clobbered register reg byte a as potential for zp[1]:80 [ renderBob::x_char_offset#0 ] -Statement [73] (byte~) renderBob::$8 ← (byte) renderBob::y_char_offset#0 << (byte) 1 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$8 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$8 ] ) always clobbers reg byte a -Statement [74] (word) renderBob::y_offset#0 ← *((const word*) MUL40 + (byte~) renderBob::$8) [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_offset#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_offset#0 ] ) always clobbers reg byte a -Statement [75] (byte*~) renderBob::$2 ← (const byte*) BOB_SCREEN + (word) renderBob::y_offset#0 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$2 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$2 ] ) always clobbers reg byte a -Statement [76] (byte*) renderBob::screen#0 ← (byte*~) renderBob::$2 + (byte) renderBob::x_char_offset#0 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::screen#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::screen#0 ] ) always clobbers reg byte a -Statement [77] (byte~) renderBob::$4 ← (byte) renderBob::ypos#0 & (byte) 7 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$4 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$4 ] ) always clobbers reg byte a -Statement [78] (byte~) renderBob::$5 ← (byte~) renderBob::$4 << (byte) 2 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$5 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$5 ] ) always clobbers reg byte a -Statement [79] (byte~) renderBob::$6 ← (byte) renderBob::xpos#0 & (byte) 3 [ renderBobCleanupNext#17 renderBob::screen#0 renderBob::$5 renderBob::$6 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::screen#0 renderBob::$5 renderBob::$6 ] ) always clobbers reg byte a +Statement [72] (byte~) renderBob::$8 ← (byte) renderBob::y_char_offset#0 << (byte) 1 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$8 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$8 ] ) always clobbers reg byte a +Statement [73] (word) renderBob::y_offset#0 ← *((const word*) MUL40 + (byte~) renderBob::$8) [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_offset#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_offset#0 ] ) always clobbers reg byte a +Statement [74] (byte*~) renderBob::$2 ← (const byte*) BOB_SCREEN + (word) renderBob::y_offset#0 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$2 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$2 ] ) always clobbers reg byte a +Statement [75] (byte*) renderBob::screen#0 ← (byte*~) renderBob::$2 + (byte) renderBob::x_char_offset#0 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::screen#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::screen#0 ] ) always clobbers reg byte a +Statement [76] (byte~) renderBob::$4 ← (byte) renderBob::ypos#0 & (byte) 7 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$4 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$4 ] ) always clobbers reg byte a +Statement [77] (byte~) renderBob::$5 ← (byte~) renderBob::$4 << (byte) 2 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$5 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$5 ] ) always clobbers reg byte a +Statement [78] (byte~) renderBob::$6 ← (byte) renderBob::xpos#0 & (byte) 3 [ renderBobCleanupNext#17 renderBob::screen#0 renderBob::$5 renderBob::$6 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::screen#0 renderBob::$5 renderBob::$6 ] ) always clobbers reg byte a Removing always clobbered register reg byte a as potential for zp[1]:90 [ renderBob::$5 ] -Statement [80] (byte) renderBob::bob_table_idx#0 ← (byte~) renderBob::$5 + (byte~) renderBob::$6 [ renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a -Statement [81] *((byte**) renderBobCleanupNext#17) ← (byte*) renderBob::screen#0 [ renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [79] (byte) renderBob::bob_table_idx#0 ← (byte~) renderBob::$5 + (byte~) renderBob::$6 [ renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a +Statement [80] *((byte**) renderBobCleanupNext#17) ← (byte*) renderBob::screen#0 [ renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y Removing always clobbered register reg byte y as potential for zp[1]:2 [ main::angle#8 main::angle#1 ] Removing always clobbered register reg byte y as potential for zp[1]:7 [ main::i#2 main::i#1 ] Removing always clobbered register reg byte y as potential for zp[1]:3 [ main::r#2 main::r#1 ] Removing always clobbered register reg byte y as potential for zp[1]:4 [ main::a#2 main::a#6 main::a#1 ] Removing always clobbered register reg byte a as potential for zp[1]:92 [ renderBob::bob_table_idx#0 ] Removing always clobbered register reg byte y as potential for zp[1]:92 [ renderBob::bob_table_idx#0 ] -Statement [82] (byte**) renderBobCleanupNext#13 ← (byte**) renderBobCleanupNext#17 + (const byte) SIZEOF_POINTER [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a -Statement [83] *((byte*) renderBob::screen#0) ← *((const byte*) BOB_TABLES + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y -Statement [84] *((byte*) renderBob::screen#0 + (byte) $28) ← *((const byte*) BOB_TABLES+(byte) 1*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y -Statement [85] *((byte*) renderBob::screen#0 + (byte) $50) ← *((const byte*) BOB_TABLES+(byte) 2*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y -Statement [86] *((byte*) renderBob::screen#0 + (byte) 1) ← *((const byte*) BOB_TABLES+(byte) 3*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y -Statement [87] *((byte*) renderBob::screen#0 + (byte) $29) ← *((const byte*) BOB_TABLES+(byte) 4*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y -Statement [88] *((byte*) renderBob::screen#0 + (byte) $51) ← *((const byte*) BOB_TABLES+(byte) 5*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y -Statement [89] *((byte*) renderBob::screen#0 + (byte) 2) ← *((const byte*) BOB_TABLES+(byte) 6*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y -Statement [90] *((byte*) renderBob::screen#0 + (byte) $2a) ← *((const byte*) BOB_TABLES+(byte) 7*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y -Statement [91] *((byte*) renderBob::screen#0 + (byte) $52) ← *((const byte*) BOB_TABLES+(byte) 8*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 ] ) always clobbers reg byte a reg byte y -Statement [98] (signed word) mulf8s::return#0 ← (signed word)(word) mulf8s_prepared::m#4 [ mulf8s::return#0 ] ( main:3::mulf8s:26 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::return#0 ] main:3::mulf8s:32 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::return#0 ] ) always clobbers reg byte a -Statement [102] (word) mulf8u_prepared::return#2 ← (word) mulf8u_prepared::return#0 [ mulf8s_prepared::b#0 mulf8u_prepared::return#2 ] ( main:3::mulf8s:26::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8u_prepared::return#2 ] main:3::mulf8s:32::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8u_prepared::return#2 ] ) always clobbers reg byte a +Statement [81] (byte**) renderBobCleanupNext#13 ← (byte**) renderBobCleanupNext#17 + (const byte) SIZEOF_POINTER [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a +Statement [82] *((byte*) renderBob::screen#0) ← *((const byte*) BOB_TABLES + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [83] *((byte*) renderBob::screen#0 + (byte) $28) ← *((const byte*) BOB_TABLES+(byte) 1*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [84] *((byte*) renderBob::screen#0 + (byte) $50) ← *((const byte*) BOB_TABLES+(byte) 2*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [85] *((byte*) renderBob::screen#0 + (byte) 1) ← *((const byte*) BOB_TABLES+(byte) 3*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [86] *((byte*) renderBob::screen#0 + (byte) $29) ← *((const byte*) BOB_TABLES+(byte) 4*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [87] *((byte*) renderBob::screen#0 + (byte) $51) ← *((const byte*) BOB_TABLES+(byte) 5*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [88] *((byte*) renderBob::screen#0 + (byte) 2) ← *((const byte*) BOB_TABLES+(byte) 6*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [89] *((byte*) renderBob::screen#0 + (byte) $2a) ← *((const byte*) BOB_TABLES+(byte) 7*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [90] *((byte*) renderBob::screen#0 + (byte) $52) ← *((const byte*) BOB_TABLES+(byte) 8*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 ] ) always clobbers reg byte a reg byte y +Statement [97] (signed word) mulf8s::return#0 ← (signed word)(word) mulf8s_prepared::m#4 [ mulf8s::return#0 ] ( main:2::mulf8s:25 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::return#0 ] main:2::mulf8s:31 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::return#0 ] ) always clobbers reg byte a +Statement [101] (word) mulf8u_prepared::return#2 ← (word) mulf8u_prepared::return#0 [ mulf8s_prepared::b#0 mulf8u_prepared::return#2 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8u_prepared::return#2 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8u_prepared::return#2 ] ) always clobbers reg byte a Removing always clobbered register reg byte a as potential for zp[1]:94 [ mulf8s_prepared::b#0 ] -Statement [103] (word) mulf8s_prepared::m#0 ← (word) mulf8u_prepared::return#2 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ( main:3::mulf8s:26::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] main:3::mulf8s:32::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ) always clobbers reg byte a -Statement [104] if(*((const signed byte*) mulf8s_prepared::memA)>=(signed byte) 0) goto mulf8s_prepared::@1 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ( main:3::mulf8s:26::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] main:3::mulf8s:32::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ) always clobbers reg byte a -Statement [105] (byte~) mulf8s_prepared::$8 ← > (word) mulf8s_prepared::m#0 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$8 ] ( main:3::mulf8s:26::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$8 ] main:3::mulf8s:32::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$8 ] ) always clobbers reg byte a -Statement [106] (byte~) mulf8s_prepared::$15 ← (byte~) mulf8s_prepared::$8 - (byte)(signed byte) mulf8s_prepared::b#0 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$15 ] ( main:3::mulf8s:26::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$15 ] main:3::mulf8s:32::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$15 ] ) always clobbers reg byte a -Statement [110] (byte~) mulf8s_prepared::$12 ← > (word) mulf8s_prepared::m#5 [ mulf8s_prepared::m#5 mulf8s_prepared::$12 ] ( main:3::mulf8s:26::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::m#5 mulf8s_prepared::$12 ] main:3::mulf8s:32::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::m#5 mulf8s_prepared::$12 ] ) always clobbers reg byte a -Statement [111] (byte~) mulf8s_prepared::$16 ← (byte~) mulf8s_prepared::$12 - (byte)*((const signed byte*) mulf8s_prepared::memA) [ mulf8s_prepared::m#5 mulf8s_prepared::$16 ] ( main:3::mulf8s:26::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::m#5 mulf8s_prepared::$16 ] main:3::mulf8s:32::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::m#5 mulf8s_prepared::$16 ] ) always clobbers reg byte a +Statement [102] (word) mulf8s_prepared::m#0 ← (word) mulf8u_prepared::return#2 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ) always clobbers reg byte a +Statement [103] if(*((const signed byte*) mulf8s_prepared::memA)>=(signed byte) 0) goto mulf8s_prepared::@1 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ) always clobbers reg byte a +Statement [104] (byte~) mulf8s_prepared::$8 ← > (word) mulf8s_prepared::m#0 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$8 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$8 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$8 ] ) always clobbers reg byte a +Statement [105] (byte~) mulf8s_prepared::$15 ← (byte~) mulf8s_prepared::$8 - (byte)(signed byte) mulf8s_prepared::b#0 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$15 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$15 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$15 ] ) always clobbers reg byte a +Statement [109] (byte~) mulf8s_prepared::$12 ← > (word) mulf8s_prepared::m#5 [ mulf8s_prepared::m#5 mulf8s_prepared::$12 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::m#5 mulf8s_prepared::$12 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::m#5 mulf8s_prepared::$12 ] ) always clobbers reg byte a +Statement [110] (byte~) mulf8s_prepared::$16 ← (byte~) mulf8s_prepared::$12 - (byte)*((const signed byte*) mulf8s_prepared::memA) [ mulf8s_prepared::m#5 mulf8s_prepared::$16 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::m#5 mulf8s_prepared::$16 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::m#5 mulf8s_prepared::$16 ] ) always clobbers reg byte a Statement asm { ldxmemB sec sm1: ldamulf_sqr1_lo,x sm2: sbcmulf_sqr2_lo,x staresL sm3: ldamulf_sqr1_hi,x sm4: sbcmulf_sqr2_hi,x stamemB } always clobbers reg byte a reg byte x Removing always clobbered register reg byte x as potential for zp[1]:2 [ main::angle#8 main::angle#1 ] Removing always clobbered register reg byte x as potential for zp[1]:3 [ main::r#2 main::r#1 ] Removing always clobbered register reg byte x as potential for zp[1]:4 [ main::a#2 main::a#6 main::a#1 ] Removing always clobbered register reg byte x as potential for zp[1]:7 [ main::i#2 main::i#1 ] Removing always clobbered register reg byte x as potential for zp[1]:94 [ mulf8s_prepared::b#0 ] -Statement [117] (word) mulf8u_prepared::return#0 ← *((const byte*) mulf8u_prepared::memB) w= *((const byte*) mulf8u_prepared::resL) [ mulf8u_prepared::return#0 ] ( main:3::mulf8s:26::mulf8s_prepared:97::mulf8u_prepared:101 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8u_prepared::return#0 ] main:3::mulf8s:32::mulf8s_prepared:97::mulf8u_prepared:101 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8u_prepared::return#0 ] ) always clobbers reg byte a +Statement [116] (word) mulf8u_prepared::return#0 ← *((const byte*) mulf8u_prepared::memB) w= *((const byte*) mulf8u_prepared::resL) [ mulf8u_prepared::return#0 ] ( main:2::mulf8s:25::mulf8s_prepared:96::mulf8u_prepared:100 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8u_prepared::return#0 ] main:2::mulf8s:31::mulf8s_prepared:96::mulf8u_prepared:100 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8u_prepared::return#0 ] ) always clobbers reg byte a Statement asm { ldamemA stamulf8u_prepared.sm1+1 stamulf8u_prepared.sm3+1 eor#$ff stamulf8u_prepared.sm2+1 stamulf8u_prepared.sm4+1 } always clobbers reg byte a Removing always clobbered register reg byte a as potential for zp[1]:9 [ mulf8s::b#2 mulf8s::b#1 mulf8s::b#0 ] -Statement [124] (byte~) renderBobCleanup::$1 ← (byte) renderBobCleanup::i#2 << (byte) 1 [ renderBobCleanup::i#2 renderBobCleanup::$1 ] ( main:3::renderBobCleanup:20 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::$1 ] ) always clobbers reg byte a +Statement [123] (byte~) renderBobCleanup::$1 ← (byte) renderBobCleanup::i#2 << (byte) 1 [ renderBobCleanup::i#2 renderBobCleanup::$1 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::$1 ] ) always clobbers reg byte a Removing always clobbered register reg byte a as potential for zp[1]:12 [ renderBobCleanup::i#2 renderBobCleanup::i#1 ] -Statement [125] (byte*) renderBobCleanup::screen#0 ← *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobCleanup::$1) [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:3::renderBobCleanup:20 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a -Statement [126] *((byte*) renderBobCleanup::screen#0) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:3::renderBobCleanup:20 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [124] (byte*) renderBobCleanup::screen#0 ← *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobCleanup::$1) [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a +Statement [125] *((byte*) renderBobCleanup::screen#0) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y Removing always clobbered register reg byte y as potential for zp[1]:12 [ renderBobCleanup::i#2 renderBobCleanup::i#1 ] -Statement [127] *((byte*) renderBobCleanup::screen#0 + (byte) $28) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:3::renderBobCleanup:20 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y -Statement [128] *((byte*) renderBobCleanup::screen#0 + (byte) $50) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:3::renderBobCleanup:20 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y -Statement [129] *((byte*) renderBobCleanup::screen#0 + (byte) 1) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:3::renderBobCleanup:20 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y -Statement [130] *((byte*) renderBobCleanup::screen#0 + (byte) $29) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:3::renderBobCleanup:20 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y -Statement [131] *((byte*) renderBobCleanup::screen#0 + (byte) $51) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:3::renderBobCleanup:20 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y -Statement [132] *((byte*) renderBobCleanup::screen#0 + (byte) 2) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:3::renderBobCleanup:20 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y -Statement [133] *((byte*) renderBobCleanup::screen#0 + (byte) $2a) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:3::renderBobCleanup:20 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y -Statement [134] *((byte*) renderBobCleanup::screen#0 + (byte) $52) ← (byte) 0 [ renderBobCleanup::i#2 ] ( main:3::renderBobCleanup:20 [ main::angle#8 renderBobCleanup::i#2 ] ) always clobbers reg byte a reg byte y -Statement [140] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 [ memset::dst#2 ] ( main:3::memset:16 [ memset::dst#2 ] ) always clobbers reg byte a -Statement [142] *((byte*) memset::dst#2) ← (const byte) memset::c#0 [ memset::dst#2 ] ( main:3::memset:16 [ memset::dst#2 ] ) always clobbers reg byte a reg byte y -Statement [146] (word~) renderBobInit::$0 ← (word)(byte) renderBobInit::y#2 [ renderBobInit::y#2 renderBobInit::$0 ] ( main:3::renderBobInit:10 [ renderBobInit::y#2 renderBobInit::$0 ] ) always clobbers reg byte a +Statement [126] *((byte*) renderBobCleanup::screen#0 + (byte) $28) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [127] *((byte*) renderBobCleanup::screen#0 + (byte) $50) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [128] *((byte*) renderBobCleanup::screen#0 + (byte) 1) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [129] *((byte*) renderBobCleanup::screen#0 + (byte) $29) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [130] *((byte*) renderBobCleanup::screen#0 + (byte) $51) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [131] *((byte*) renderBobCleanup::screen#0 + (byte) 2) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [132] *((byte*) renderBobCleanup::screen#0 + (byte) $2a) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [133] *((byte*) renderBobCleanup::screen#0 + (byte) $52) ← (byte) 0 [ renderBobCleanup::i#2 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 ] ) always clobbers reg byte a reg byte y +Statement [139] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 [ memset::dst#2 ] ( main:2::memset:15 [ memset::dst#2 ] ) always clobbers reg byte a +Statement [141] *((byte*) memset::dst#2) ← (const byte) memset::c#0 [ memset::dst#2 ] ( main:2::memset:15 [ memset::dst#2 ] ) always clobbers reg byte a reg byte y +Statement [145] (word~) renderBobInit::$0 ← (word)(byte) renderBobInit::y#2 [ renderBobInit::y#2 renderBobInit::$0 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 renderBobInit::$0 ] ) always clobbers reg byte a Removing always clobbered register reg byte a as potential for zp[1]:15 [ renderBobInit::y#2 renderBobInit::y#1 ] -Statement [147] (word~) renderBobInit::$6 ← (word~) renderBobInit::$0 << (byte) 2 [ renderBobInit::y#2 renderBobInit::$0 renderBobInit::$6 ] ( main:3::renderBobInit:10 [ renderBobInit::y#2 renderBobInit::$0 renderBobInit::$6 ] ) always clobbers reg byte a -Statement [148] (word~) renderBobInit::$7 ← (word~) renderBobInit::$6 + (word~) renderBobInit::$0 [ renderBobInit::y#2 renderBobInit::$7 ] ( main:3::renderBobInit:10 [ renderBobInit::y#2 renderBobInit::$7 ] ) always clobbers reg byte a -Statement [149] (word~) renderBobInit::$1 ← (word~) renderBobInit::$7 << (byte) 3 [ renderBobInit::y#2 renderBobInit::$1 ] ( main:3::renderBobInit:10 [ renderBobInit::y#2 renderBobInit::$1 ] ) always clobbers reg byte a -Statement [150] (byte~) renderBobInit::$4 ← (byte) renderBobInit::y#2 << (byte) 1 [ renderBobInit::y#2 renderBobInit::$1 renderBobInit::$4 ] ( main:3::renderBobInit:10 [ renderBobInit::y#2 renderBobInit::$1 renderBobInit::$4 ] ) always clobbers reg byte a -Statement [151] *((const word*) MUL40 + (byte~) renderBobInit::$4) ← (word~) renderBobInit::$1 [ renderBobInit::y#2 ] ( main:3::renderBobInit:10 [ renderBobInit::y#2 ] ) always clobbers reg byte a -Statement [155] (byte~) renderBobInit::$5 ← (byte) renderBobInit::i#2 << (byte) 1 [ renderBobInit::i#2 renderBobInit::$5 ] ( main:3::renderBobInit:10 [ renderBobInit::i#2 renderBobInit::$5 ] ) always clobbers reg byte a +Statement [146] (word~) renderBobInit::$6 ← (word~) renderBobInit::$0 << (byte) 2 [ renderBobInit::y#2 renderBobInit::$0 renderBobInit::$6 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 renderBobInit::$0 renderBobInit::$6 ] ) always clobbers reg byte a +Statement [147] (word~) renderBobInit::$7 ← (word~) renderBobInit::$6 + (word~) renderBobInit::$0 [ renderBobInit::y#2 renderBobInit::$7 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 renderBobInit::$7 ] ) always clobbers reg byte a +Statement [148] (word~) renderBobInit::$1 ← (word~) renderBobInit::$7 << (byte) 3 [ renderBobInit::y#2 renderBobInit::$1 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 renderBobInit::$1 ] ) always clobbers reg byte a +Statement [149] (byte~) renderBobInit::$4 ← (byte) renderBobInit::y#2 << (byte) 1 [ renderBobInit::y#2 renderBobInit::$1 renderBobInit::$4 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 renderBobInit::$1 renderBobInit::$4 ] ) always clobbers reg byte a +Statement [150] *((const word*) MUL40 + (byte~) renderBobInit::$4) ← (word~) renderBobInit::$1 [ renderBobInit::y#2 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 ] ) always clobbers reg byte a +Statement [154] (byte~) renderBobInit::$5 ← (byte) renderBobInit::i#2 << (byte) 1 [ renderBobInit::i#2 renderBobInit::$5 ] ( main:2::renderBobInit:9 [ renderBobInit::i#2 renderBobInit::$5 ] ) always clobbers reg byte a Removing always clobbered register reg byte a as potential for zp[1]:16 [ renderBobInit::i#2 renderBobInit::i#1 ] -Statement [156] *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobInit::$5) ← (const byte*) BOB_SCREEN [ renderBobInit::i#2 ] ( main:3::renderBobInit:10 [ renderBobInit::i#2 ] ) always clobbers reg byte a -Statement [172] (byte*) prepareBobs::bob_table#0 ← (const byte*) BOB_TABLES + (byte) prepareBobs::bob_table_idx#12 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::bob_table#0 ] ( main:3::prepareBobs:8 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::bob_table#0 ] ) always clobbers reg byte a +Statement [155] *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobInit::$5) ← (const byte*) BOB_SCREEN [ renderBobInit::i#2 ] ( main:2::renderBobInit:9 [ renderBobInit::i#2 ] ) always clobbers reg byte a +Statement [171] (byte*) prepareBobs::bob_table#0 ← (const byte*) BOB_TABLES + (byte) prepareBobs::bob_table_idx#12 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::bob_table#0 ] ( main:2::prepareBobs:7 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::bob_table#0 ] ) always clobbers reg byte a Removing always clobbered register reg byte a as potential for zp[1]:17 [ prepareBobs::shift_y#2 prepareBobs::shift_y#1 ] Removing always clobbered register reg byte a as potential for zp[1]:20 [ progress_idx#16 progress_idx#31 progress_idx#25 progress_idx#10 progress_idx#8 ] Removing always clobbered register reg byte a as potential for zp[1]:28 [ bob_charset_next_id#23 bob_charset_next_id#14 bob_charset_next_id#16 bob_charset_next_id#30 bob_charset_next_id#21 bob_charset_next_id#8 ] Removing always clobbered register reg byte a as potential for zp[1]:21 [ prepareBobs::bob_table_idx#6 prepareBobs::bob_table_idx#12 prepareBobs::bob_table_idx#1 ] Removing always clobbered register reg byte a as potential for zp[1]:22 [ prepareBobs::shift_x#2 prepareBobs::shift_x#1 ] -Statement [180] (byte*) bobCharsetFindOrAddGlyph::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bobCharsetFindOrAddGlyph::bob_glyph#1 ] ( main:3::prepareBobs:8 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bobCharsetFindOrAddGlyph::bob_glyph#1 ] ) always clobbers reg byte a +Statement [179] (byte*) bobCharsetFindOrAddGlyph::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bobCharsetFindOrAddGlyph::bob_glyph#1 ] ( main:2::prepareBobs:7 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bobCharsetFindOrAddGlyph::bob_glyph#1 ] ) always clobbers reg byte a Removing always clobbered register reg byte a as potential for zp[1]:23 [ prepareBobs::cell#2 prepareBobs::cell#1 ] -Statement [184] *((byte*) prepareBobs::bob_table#2) ← (byte~) prepareBobs::$6 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 ] ( main:3::prepareBobs:8 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 ] ) always clobbers reg byte y +Statement [183] *((byte*) prepareBobs::bob_table#2) ← (byte~) prepareBobs::$6 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 ] ( main:2::prepareBobs:7 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 ] ) always clobbers reg byte y Removing always clobbered register reg byte y as potential for zp[1]:17 [ prepareBobs::shift_y#2 prepareBobs::shift_y#1 ] Removing always clobbered register reg byte y as potential for zp[1]:28 [ bob_charset_next_id#23 bob_charset_next_id#14 bob_charset_next_id#16 bob_charset_next_id#30 bob_charset_next_id#21 bob_charset_next_id#8 ] Removing always clobbered register reg byte y as potential for zp[1]:21 [ prepareBobs::bob_table_idx#6 prepareBobs::bob_table_idx#12 prepareBobs::bob_table_idx#1 ] Removing always clobbered register reg byte y as potential for zp[1]:22 [ prepareBobs::shift_x#2 prepareBobs::shift_x#1 ] Removing always clobbered register reg byte y as potential for zp[1]:20 [ progress_idx#16 progress_idx#31 progress_idx#25 progress_idx#10 progress_idx#8 ] Removing always clobbered register reg byte y as potential for zp[1]:23 [ prepareBobs::cell#2 prepareBobs::cell#1 ] -Statement [185] (byte*) prepareBobs::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 + (byte) 8 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_table#2 prepareBobs::bob_glyph#1 ] ( main:3::prepareBobs:8 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_table#2 prepareBobs::bob_glyph#1 ] ) always clobbers reg byte a -Statement [186] (byte*) prepareBobs::bob_table#1 ← (byte*) prepareBobs::bob_table#2 + (const byte) BOB_SHIFTS_X*(const byte) BOB_SHIFTS_Y [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 ] ( main:3::prepareBobs:8 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 ] ) always clobbers reg byte a -Statement [191] *((byte*) progress_cursor#24) ← *((const byte*) progress_inc::progress_chars+(byte) 8) [ progress_cursor#24 ] ( main:3::prepareBobs:8::progress_inc:187 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 progress_cursor#24 ] ) always clobbers reg byte a reg byte y -Statement [194] *((byte*) progress_cursor#17) ← *((const byte*) progress_inc::progress_chars + (byte) progress_idx#10) [ progress_idx#10 progress_cursor#17 ] ( main:3::prepareBobs:8::progress_inc:187 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 progress_idx#10 progress_cursor#17 ] ) always clobbers reg byte a reg byte y -Statement [204] *((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) bobCharsetFindOrAddGlyph::i1#2) ← *((byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 + (byte) bobCharsetFindOrAddGlyph::i1#2) [ bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i1#2 ] ( main:3::prepareBobs:8::bobCharsetFindOrAddGlyph:163 [ bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i1#2 ] main:3::prepareBobs:8::bobCharsetFindOrAddGlyph:181 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i1#2 ] ) always clobbers reg byte a +Statement [184] (byte*) prepareBobs::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 + (byte) 8 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_table#2 prepareBobs::bob_glyph#1 ] ( main:2::prepareBobs:7 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_table#2 prepareBobs::bob_glyph#1 ] ) always clobbers reg byte a +Statement [185] (byte*) prepareBobs::bob_table#1 ← (byte*) prepareBobs::bob_table#2 + (const byte) BOB_SHIFTS_X*(const byte) BOB_SHIFTS_Y [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 ] ( main:2::prepareBobs:7 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 ] ) always clobbers reg byte a +Statement [190] *((byte*) progress_cursor#24) ← *((const byte*) progress_inc::progress_chars+(byte) 8) [ progress_cursor#24 ] ( main:2::prepareBobs:7::progress_inc:186 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 progress_cursor#24 ] ) always clobbers reg byte a reg byte y +Statement [193] *((byte*) progress_cursor#17) ← *((const byte*) progress_inc::progress_chars + (byte) progress_idx#10) [ progress_idx#10 progress_cursor#17 ] ( main:2::prepareBobs:7::progress_inc:186 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 progress_idx#10 progress_cursor#17 ] ) always clobbers reg byte a reg byte y +Statement [203] *((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) bobCharsetFindOrAddGlyph::i1#2) ← *((byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 + (byte) bobCharsetFindOrAddGlyph::i1#2) [ bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i1#2 ] ( main:2::prepareBobs:7::bobCharsetFindOrAddGlyph:162 [ bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i1#2 ] main:2::prepareBobs:7::bobCharsetFindOrAddGlyph:180 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i1#2 ] ) always clobbers reg byte a Removing always clobbered register reg byte a as potential for zp[1]:31 [ bobCharsetFindOrAddGlyph::glyph_id#11 bobCharsetFindOrAddGlyph::glyph_id#1 ] Removing always clobbered register reg byte a as potential for zp[1]:34 [ bobCharsetFindOrAddGlyph::i1#2 bobCharsetFindOrAddGlyph::i1#1 ] -Statement [208] if(*((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) bobCharsetFindOrAddGlyph::i#2)==*((byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 + (byte) bobCharsetFindOrAddGlyph::i#2)) goto bobCharsetFindOrAddGlyph::@4 [ bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i#2 ] ( main:3::prepareBobs:8::bobCharsetFindOrAddGlyph:163 [ bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i#2 ] main:3::prepareBobs:8::bobCharsetFindOrAddGlyph:181 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i#2 ] ) always clobbers reg byte a reg byte x reg byte y -Removing always clobbered register reg byte x as potential for zp[1]:31 [ bobCharsetFindOrAddGlyph::glyph_id#11 bobCharsetFindOrAddGlyph::glyph_id#1 ] -Removing always clobbered register reg byte y as potential for zp[1]:31 [ bobCharsetFindOrAddGlyph::glyph_id#11 bobCharsetFindOrAddGlyph::glyph_id#1 ] -Removing always clobbered register reg byte x as potential for zp[1]:28 [ bob_charset_next_id#23 bob_charset_next_id#14 bob_charset_next_id#16 bob_charset_next_id#30 bob_charset_next_id#21 bob_charset_next_id#8 ] +Statement [207] if(*((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) bobCharsetFindOrAddGlyph::i#2)==*((byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 + (byte) bobCharsetFindOrAddGlyph::i#2)) goto bobCharsetFindOrAddGlyph::@4 [ bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i#2 ] ( main:2::prepareBobs:7::bobCharsetFindOrAddGlyph:162 [ bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i#2 ] main:2::prepareBobs:7::bobCharsetFindOrAddGlyph:180 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i#2 ] ) always clobbers reg byte a Removing always clobbered register reg byte a as potential for zp[1]:35 [ bobCharsetFindOrAddGlyph::i#2 bobCharsetFindOrAddGlyph::i#1 ] -Removing always clobbered register reg byte x as potential for zp[1]:35 [ bobCharsetFindOrAddGlyph::i#2 bobCharsetFindOrAddGlyph::i#1 ] -Removing always clobbered register reg byte y as potential for zp[1]:35 [ bobCharsetFindOrAddGlyph::i#2 bobCharsetFindOrAddGlyph::i#1 ] -Removing always clobbered register reg byte x as potential for zp[1]:17 [ prepareBobs::shift_y#2 prepareBobs::shift_y#1 ] -Removing always clobbered register reg byte x as potential for zp[1]:21 [ prepareBobs::bob_table_idx#6 prepareBobs::bob_table_idx#12 prepareBobs::bob_table_idx#1 ] -Removing always clobbered register reg byte x as potential for zp[1]:22 [ prepareBobs::shift_x#2 prepareBobs::shift_x#1 ] -Removing always clobbered register reg byte x as potential for zp[1]:20 [ progress_idx#16 progress_idx#31 progress_idx#25 progress_idx#10 progress_idx#8 ] -Removing always clobbered register reg byte x as potential for zp[1]:23 [ prepareBobs::cell#2 prepareBobs::cell#1 ] -Statement [212] (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#1 ← (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) 8 [ bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_id#1 bobCharsetFindOrAddGlyph::glyph_cursor#1 ] ( main:3::prepareBobs:8::bobCharsetFindOrAddGlyph:163 [ bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_id#1 bobCharsetFindOrAddGlyph::glyph_cursor#1 ] main:3::prepareBobs:8::bobCharsetFindOrAddGlyph:181 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_id#1 bobCharsetFindOrAddGlyph::glyph_cursor#1 ] ) always clobbers reg byte a -Statement [218] (byte~) shiftProtoBobRight::$1 ← *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) & (byte) 1 [ shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::$1 ] ( main:3::prepareBobs:8::shiftProtoBobRight:176 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::$1 ] main:3::prepareBobs:8::shiftProtoBobRight:178 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::$1 ] ) always clobbers reg byte a +Statement [211] (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#1 ← (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) 8 [ bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_id#1 bobCharsetFindOrAddGlyph::glyph_cursor#1 ] ( main:2::prepareBobs:7::bobCharsetFindOrAddGlyph:162 [ bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_id#1 bobCharsetFindOrAddGlyph::glyph_cursor#1 ] main:2::prepareBobs:7::bobCharsetFindOrAddGlyph:180 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_id#1 bobCharsetFindOrAddGlyph::glyph_cursor#1 ] ) always clobbers reg byte a +Statement [217] (byte~) shiftProtoBobRight::$1 ← *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) & (byte) 1 [ shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::$1 ] ( main:2::prepareBobs:7::shiftProtoBobRight:175 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::$1 ] main:2::prepareBobs:7::shiftProtoBobRight:177 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::$1 ] ) always clobbers reg byte a Removing always clobbered register reg byte a as potential for zp[1]:37 [ shiftProtoBobRight::i#2 shiftProtoBobRight::i#1 ] Removing always clobbered register reg byte a as potential for zp[1]:38 [ shiftProtoBobRight::j#3 shiftProtoBobRight::j#10 shiftProtoBobRight::j#2 shiftProtoBobRight::j#1 ] Removing always clobbered register reg byte a as potential for zp[1]:39 [ shiftProtoBobRight::carry#2 shiftProtoBobRight::carry#10 ] -Statement [222] (byte~) shiftProtoBobRight::$5 ← *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) >> (byte) 1 [ shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::$5 ] ( main:3::prepareBobs:8::shiftProtoBobRight:176 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::$5 ] main:3::prepareBobs:8::shiftProtoBobRight:178 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::$5 ] ) always clobbers reg byte a +Statement [221] (byte~) shiftProtoBobRight::$5 ← *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) >> (byte) 1 [ shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::$5 ] ( main:2::prepareBobs:7::shiftProtoBobRight:175 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::$5 ] main:2::prepareBobs:7::shiftProtoBobRight:177 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::$5 ] ) always clobbers reg byte a Removing always clobbered register reg byte a as potential for zp[1]:40 [ shiftProtoBobRight::carry#1 ] -Statement [226] (byte) shiftProtoBobRight::j#2 ← (byte) shiftProtoBobRight::j#3 + (byte) $18 [ shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#2 ] ( main:3::prepareBobs:8::shiftProtoBobRight:176 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#2 ] main:3::prepareBobs:8::shiftProtoBobRight:178 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#2 ] ) always clobbers reg byte a -Statement [230] (byte) shiftProtoBobRight::j#1 ← (byte) shiftProtoBobRight::j#3 - (byte) $2f [ shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#1 ] ( main:3::prepareBobs:8::shiftProtoBobRight:176 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#1 ] main:3::prepareBobs:8::shiftProtoBobRight:178 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#1 ] ) always clobbers reg byte a -Statement [234] *((const byte*) PROTO_BOB) ← (byte) 0 [ ] ( main:3::prepareBobs:8::shiftProtoBobDown:170 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 ] ) always clobbers reg byte a -Statement [235] *((const byte*) PROTO_BOB+(byte) $18) ← (byte) 0 [ ] ( main:3::prepareBobs:8::shiftProtoBobDown:170 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 ] ) always clobbers reg byte a -Statement [236] *((const byte*) PROTO_BOB+(byte) $30) ← (byte) 0 [ ] ( main:3::prepareBobs:8::shiftProtoBobDown:170 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 ] ) always clobbers reg byte a -Statement [238] *((const byte*) PROTO_BOB + (byte) shiftProtoBobDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $17 + (byte) shiftProtoBobDown::i#2) [ shiftProtoBobDown::i#2 ] ( main:3::prepareBobs:8::shiftProtoBobDown:170 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 shiftProtoBobDown::i#2 ] ) always clobbers reg byte a +Statement [225] (byte) shiftProtoBobRight::j#2 ← (byte) shiftProtoBobRight::j#3 + (byte) $18 [ shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#2 ] ( main:2::prepareBobs:7::shiftProtoBobRight:175 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#2 ] main:2::prepareBobs:7::shiftProtoBobRight:177 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#2 ] ) always clobbers reg byte a +Statement [229] (byte) shiftProtoBobRight::j#1 ← (byte) shiftProtoBobRight::j#3 - (byte) $2f [ shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#1 ] ( main:2::prepareBobs:7::shiftProtoBobRight:175 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#1 ] main:2::prepareBobs:7::shiftProtoBobRight:177 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#1 ] ) always clobbers reg byte a +Statement [233] *((const byte*) PROTO_BOB) ← (byte) 0 [ ] ( main:2::prepareBobs:7::shiftProtoBobDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 ] ) always clobbers reg byte a +Statement [234] *((const byte*) PROTO_BOB+(byte) $18) ← (byte) 0 [ ] ( main:2::prepareBobs:7::shiftProtoBobDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 ] ) always clobbers reg byte a +Statement [235] *((const byte*) PROTO_BOB+(byte) $30) ← (byte) 0 [ ] ( main:2::prepareBobs:7::shiftProtoBobDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 ] ) always clobbers reg byte a +Statement [237] *((const byte*) PROTO_BOB + (byte) shiftProtoBobDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $17 + (byte) shiftProtoBobDown::i#2) [ shiftProtoBobDown::i#2 ] ( main:2::prepareBobs:7::shiftProtoBobDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 shiftProtoBobDown::i#2 ] ) always clobbers reg byte a Removing always clobbered register reg byte a as potential for zp[1]:41 [ shiftProtoBobDown::i#2 shiftProtoBobDown::i#1 ] -Statement [239] *((const byte*) PROTO_BOB+(byte) $18 + (byte) shiftProtoBobDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $2f + (byte) shiftProtoBobDown::i#2) [ shiftProtoBobDown::i#2 ] ( main:3::prepareBobs:8::shiftProtoBobDown:170 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 shiftProtoBobDown::i#2 ] ) always clobbers reg byte a -Statement [240] *((const byte*) PROTO_BOB+(byte) $30 + (byte) shiftProtoBobDown::i#2) ← (byte) 0 [ shiftProtoBobDown::i#2 ] ( main:3::prepareBobs:8::shiftProtoBobDown:170 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 shiftProtoBobDown::i#2 ] ) always clobbers reg byte a -Statement [246] if((byte*) mulf_init::sqr1_lo#2!=(const byte*) mulf_sqr1_lo+(word) $200) goto mulf_init::@2 [ mulf_init::sqr1_lo#2 mulf_init::c#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 ] ( main:3::mulf_init:6 [ mulf_init::sqr1_lo#2 mulf_init::c#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 ] ) always clobbers reg byte a +Statement [238] *((const byte*) PROTO_BOB+(byte) $18 + (byte) shiftProtoBobDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $2f + (byte) shiftProtoBobDown::i#2) [ shiftProtoBobDown::i#2 ] ( main:2::prepareBobs:7::shiftProtoBobDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 shiftProtoBobDown::i#2 ] ) always clobbers reg byte a +Statement [239] *((const byte*) PROTO_BOB+(byte) $30 + (byte) shiftProtoBobDown::i#2) ← (byte) 0 [ shiftProtoBobDown::i#2 ] ( main:2::prepareBobs:7::shiftProtoBobDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 shiftProtoBobDown::i#2 ] ) always clobbers reg byte a +Statement [245] if((byte*) mulf_init::sqr1_lo#2!=(const byte*) mulf_sqr1_lo+(word) $200) goto mulf_init::@2 [ mulf_init::sqr1_lo#2 mulf_init::c#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::c#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 ] ) always clobbers reg byte a Removing always clobbered register reg byte a as potential for zp[1]:44 [ mulf_init::c#2 mulf_init::c#1 ] Removing always clobbered register reg byte a as potential for zp[1]:47 [ mulf_init::x_2#3 mulf_init::x_2#2 mulf_init::x_2#1 ] -Statement [248] if((byte*) mulf_init::sqr2_lo#2!=(const byte*) mulf_sqr2_lo+(word) $1ff) goto mulf_init::@6 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ( main:3::mulf_init:6 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ) always clobbers reg byte a +Statement [247] if((byte*) mulf_init::sqr2_lo#2!=(const byte*) mulf_sqr2_lo+(word) $1ff) goto mulf_init::@6 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ( main:2::mulf_init:5 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ) always clobbers reg byte a Removing always clobbered register reg byte a as potential for zp[1]:50 [ mulf_init::x_255#2 mulf_init::x_255#1 ] Removing always clobbered register reg byte a as potential for zp[1]:53 [ mulf_init::dir#2 mulf_init::dir#4 ] -Statement [249] *((const byte*) mulf_sqr2_lo+(word) $1ff) ← *((const byte*) mulf_sqr1_lo+(word) $100) [ ] ( main:3::mulf_init:6 [ ] ) always clobbers reg byte a -Statement [250] *((const byte*) mulf_sqr2_hi+(word) $1ff) ← *((const byte*) mulf_sqr1_hi+(word) $100) [ ] ( main:3::mulf_init:6 [ ] ) always clobbers reg byte a -Statement [252] *((byte*) mulf_init::sqr2_lo#2) ← *((const byte*) mulf_sqr1_lo + (byte) mulf_init::x_255#2) [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ( main:3::mulf_init:6 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ) always clobbers reg byte a reg byte y +Statement [248] *((const byte*) mulf_sqr2_lo+(word) $1ff) ← *((const byte*) mulf_sqr1_lo+(word) $100) [ ] ( main:2::mulf_init:5 [ ] ) always clobbers reg byte a +Statement [249] *((const byte*) mulf_sqr2_hi+(word) $1ff) ← *((const byte*) mulf_sqr1_hi+(word) $100) [ ] ( main:2::mulf_init:5 [ ] ) always clobbers reg byte a +Statement [251] *((byte*) mulf_init::sqr2_lo#2) ← *((const byte*) mulf_sqr1_lo + (byte) mulf_init::x_255#2) [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ( main:2::mulf_init:5 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ) always clobbers reg byte a reg byte y Removing always clobbered register reg byte y as potential for zp[1]:50 [ mulf_init::x_255#2 mulf_init::x_255#1 ] Removing always clobbered register reg byte y as potential for zp[1]:53 [ mulf_init::dir#2 mulf_init::dir#4 ] -Statement [253] *((byte*) mulf_init::sqr2_hi#2) ← *((const byte*) mulf_sqr1_hi + (byte) mulf_init::x_255#2) [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ( main:3::mulf_init:6 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ) always clobbers reg byte a reg byte y -Statement [255] (byte) mulf_init::x_255#1 ← (byte) mulf_init::x_255#2 + (byte) mulf_init::dir#2 [ mulf_init::sqr2_lo#2 mulf_init::dir#2 mulf_init::x_255#1 mulf_init::sqr2_hi#1 ] ( main:3::mulf_init:6 [ mulf_init::sqr2_lo#2 mulf_init::dir#2 mulf_init::x_255#1 mulf_init::sqr2_hi#1 ] ) always clobbers reg byte a -Statement [261] (byte~) mulf_init::$1 ← (byte) mulf_init::c#1 & (byte) 1 [ mulf_init::sqr1_lo#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 mulf_init::c#1 mulf_init::$1 ] ( main:3::mulf_init:6 [ mulf_init::sqr1_lo#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 mulf_init::c#1 mulf_init::$1 ] ) always clobbers reg byte a -Statement [266] (byte~) mulf_init::$4 ← < (word) mulf_init::sqr#3 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$4 ] ( main:3::mulf_init:6 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$4 ] ) always clobbers reg byte a -Statement [267] *((byte*) mulf_init::sqr1_lo#2) ← (byte~) mulf_init::$4 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ( main:3::mulf_init:6 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ) always clobbers reg byte y +Statement [252] *((byte*) mulf_init::sqr2_hi#2) ← *((const byte*) mulf_sqr1_hi + (byte) mulf_init::x_255#2) [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ( main:2::mulf_init:5 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ) always clobbers reg byte a reg byte y +Statement [254] (byte) mulf_init::x_255#1 ← (byte) mulf_init::x_255#2 + (byte) mulf_init::dir#2 [ mulf_init::sqr2_lo#2 mulf_init::dir#2 mulf_init::x_255#1 mulf_init::sqr2_hi#1 ] ( main:2::mulf_init:5 [ mulf_init::sqr2_lo#2 mulf_init::dir#2 mulf_init::x_255#1 mulf_init::sqr2_hi#1 ] ) always clobbers reg byte a +Statement [260] (byte~) mulf_init::$1 ← (byte) mulf_init::c#1 & (byte) 1 [ mulf_init::sqr1_lo#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 mulf_init::c#1 mulf_init::$1 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 mulf_init::c#1 mulf_init::$1 ] ) always clobbers reg byte a +Statement [265] (byte~) mulf_init::$4 ← < (word) mulf_init::sqr#3 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$4 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$4 ] ) always clobbers reg byte a +Statement [266] *((byte*) mulf_init::sqr1_lo#2) ← (byte~) mulf_init::$4 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ) always clobbers reg byte y Removing always clobbered register reg byte y as potential for zp[1]:44 [ mulf_init::c#2 mulf_init::c#1 ] Removing always clobbered register reg byte y as potential for zp[1]:47 [ mulf_init::x_2#3 mulf_init::x_2#2 mulf_init::x_2#1 ] -Statement [268] (byte~) mulf_init::$5 ← > (word) mulf_init::sqr#3 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$5 ] ( main:3::mulf_init:6 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$5 ] ) always clobbers reg byte a -Statement [269] *((byte*) mulf_init::sqr1_hi#2) ← (byte~) mulf_init::$5 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ( main:3::mulf_init:6 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ) always clobbers reg byte y -Statement [271] (word) mulf_init::sqr#1 ← (word) mulf_init::sqr#3 + (byte) mulf_init::x_2#2 [ mulf_init::sqr1_lo#2 mulf_init::c#1 mulf_init::sqr#1 mulf_init::sqr1_hi#1 mulf_init::x_2#2 ] ( main:3::mulf_init:6 [ mulf_init::sqr1_lo#2 mulf_init::c#1 mulf_init::sqr#1 mulf_init::sqr1_hi#1 mulf_init::x_2#2 ] ) always clobbers reg byte a -Statement [11] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 [ ] ( main:3 [ ] ) always clobbers reg byte a -Statement [13] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank1_toDd001_return#0 [ ] ( main:3 [ ] ) always clobbers reg byte a -Statement [15] *((const byte*) D018) ← (const byte) main::toD0181_return#0 [ ] ( main:3 [ ] ) always clobbers reg byte a -Statement [18] if(*((const byte*) RASTER)<(byte) $f8) goto main::@2 [ main::angle#8 ] ( main:3 [ main::angle#8 ] ) always clobbers reg byte a -Statement [19] *((const byte*) BORDERCOL) ← (byte) $f [ main::angle#8 ] ( main:3 [ main::angle#8 ] ) always clobbers reg byte a -Statement [21] (byte) main::a#6 ← (byte) main::angle#8 [ main::angle#8 main::a#6 ] ( main:3 [ main::angle#8 main::a#6 ] ) always clobbers reg byte a -Statement [23] *((const byte*) BORDERCOL) ← (byte) 1 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 ] ( main:3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 ] ) always clobbers reg byte a -Statement [25] (signed byte) mulf8s::b#0 ← *((const signed byte*) COS + (byte) main::a#2) [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::a#0 mulf8s::b#0 ] ( main:3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::a#0 mulf8s::b#0 ] ) always clobbers reg byte y +Statement [267] (byte~) mulf_init::$5 ← > (word) mulf_init::sqr#3 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$5 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$5 ] ) always clobbers reg byte a +Statement [268] *((byte*) mulf_init::sqr1_hi#2) ← (byte~) mulf_init::$5 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ) always clobbers reg byte y +Statement [270] (word) mulf_init::sqr#1 ← (word) mulf_init::sqr#3 + (byte) mulf_init::x_2#2 [ mulf_init::sqr1_lo#2 mulf_init::c#1 mulf_init::sqr#1 mulf_init::sqr1_hi#1 mulf_init::x_2#2 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::c#1 mulf_init::sqr#1 mulf_init::sqr1_hi#1 mulf_init::x_2#2 ] ) always clobbers reg byte a +Statement [10] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [12] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank1_toDd001_return#0 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [14] *((const byte*) D018) ← (const byte) main::toD0181_return#0 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [17] if(*((const byte*) RASTER)<(byte) $f8) goto main::@2 [ main::angle#8 ] ( main:2 [ main::angle#8 ] ) always clobbers reg byte a +Statement [18] *((const byte*) BORDERCOL) ← (byte) $f [ main::angle#8 ] ( main:2 [ main::angle#8 ] ) always clobbers reg byte a +Statement [20] (byte) main::a#6 ← (byte) main::angle#8 [ main::angle#8 main::a#6 ] ( main:2 [ main::angle#8 main::a#6 ] ) always clobbers reg byte a +Statement [22] *((const byte*) BORDERCOL) ← (byte) 1 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 ] ) always clobbers reg byte a +Statement [24] (signed byte) mulf8s::b#0 ← *((const signed byte*) COS + (byte) main::a#2) [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::a#0 mulf8s::b#0 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::a#0 mulf8s::b#0 ] ) always clobbers reg byte y Removing always clobbered register reg byte y as potential for zp[1]:8 [ mulf8s::mulf8s_prepare1_a#0 mulf8s::a#1 mulf8s::a#0 ] -Statement [27] (signed word) mulf8s::return#2 ← (signed word) mulf8s::return#0 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::return#2 ] ( main:3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::return#2 ] ) always clobbers reg byte a -Statement [28] (signed word~) main::$10 ← (signed word) mulf8s::return#2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::$10 ] ( main:3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::$10 ] ) always clobbers reg byte a -Statement [29] (signed word) main::x#0 ← (signed word~) main::$10 + (signed word)(number) $4b*(number) $100 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 ] ( main:3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 ] ) always clobbers reg byte a -Statement [31] (signed byte) mulf8s::b#1 ← *((const signed byte*) SIN + (byte) main::a#2) [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::a#1 mulf8s::b#1 ] ( main:3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::a#1 mulf8s::b#1 ] ) always clobbers reg byte y -Statement [33] (signed word) mulf8s::return#3 ← (signed word) mulf8s::return#0 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::return#3 ] ( main:3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::return#3 ] ) always clobbers reg byte a -Statement [34] (signed word~) main::$12 ← (signed word) mulf8s::return#3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$12 ] ( main:3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$12 ] ) always clobbers reg byte a -Statement [35] (signed word~) main::$13 ← (signed word~) main::$12 << (byte) 1 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$13 ] ( main:3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$13 ] ) always clobbers reg byte a -Statement [36] (signed word) main::y#0 ← (signed word~) main::$13 + (signed word)(number) $5a*(number) $100 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ( main:3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ) always clobbers reg byte a -Statement [37] *((const byte*) BORDERCOL) ← (byte) 2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ( main:3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ) always clobbers reg byte a -Statement [38] (byte) main::a#1 ← (byte) main::a#2 + (byte) $62 [ main::angle#8 main::r#2 renderBobCleanupNext#17 main::i#2 main::a#1 main::x#0 main::y#0 ] ( main:3 [ main::angle#8 main::r#2 renderBobCleanupNext#17 main::i#2 main::a#1 main::x#0 main::y#0 ] ) always clobbers reg byte a reg byte x -Statement [39] (signed byte) main::r#1 ← (signed byte) main::r#2 + (signed byte) 3 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::x#0 main::y#0 ] ( main:3 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::x#0 main::y#0 ] ) always clobbers reg byte a reg byte x -Statement [40] (byte) renderBob::xpos#0 ← > (signed word) main::x#0 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::y#0 renderBob::xpos#0 ] ( main:3 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::y#0 renderBob::xpos#0 ] ) always clobbers reg byte a -Statement [41] (byte) renderBob::ypos#0 ← > (signed word) main::y#0 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 renderBob::xpos#0 renderBob::ypos#0 ] ( main:3 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 renderBob::xpos#0 renderBob::ypos#0 ] ) always clobbers reg byte a -Statement [44] if((byte) main::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto main::@4 [ main::angle#8 main::r#1 main::a#1 renderBobCleanupNext#13 main::i#1 ] ( main:3 [ main::angle#8 main::r#1 main::a#1 renderBobCleanupNext#13 main::i#1 ] ) always clobbers reg byte a -Statement [45] (byte) main::angle#1 ← (byte) main::angle#8 + (byte) 3 [ main::angle#1 ] ( main:3 [ main::angle#1 ] ) always clobbers reg byte a reg byte x -Statement [46] *((const byte*) BORDERCOL) ← (byte) 0 [ main::angle#1 ] ( main:3 [ main::angle#1 ] ) always clobbers reg byte a -Statement [56] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 [ ] ( main:3 [ ] ) always clobbers reg byte a -Statement [58] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank2_toDd001_return#0 [ ] ( main:3 [ ] ) always clobbers reg byte a -Statement [60] *((const byte*) D018) ← (const byte) main::toD0182_return#0 [ ] ( main:3 [ ] ) always clobbers reg byte a -Statement [68] *((const byte*) CIA1_PORT_A) ← *((const byte*) keyboard_matrix_row_bitmask+(const byte) keyboard_key_pressed::rowidx#0) [ ] ( main:3::keyboard_key_pressed:47::keyboard_matrix_read:63 [ main::angle#1 ] main:3::keyboard_key_pressed:52::keyboard_matrix_read:63 [ ] ) always clobbers reg byte a -Statement [69] (byte) keyboard_matrix_read::return#0 ← ~ *((const byte*) CIA1_PORT_B) [ keyboard_matrix_read::return#0 ] ( main:3::keyboard_key_pressed:47::keyboard_matrix_read:63 [ main::angle#1 keyboard_matrix_read::return#0 ] main:3::keyboard_key_pressed:52::keyboard_matrix_read:63 [ keyboard_matrix_read::return#0 ] ) always clobbers reg byte a -Statement [71] (byte) renderBob::x_char_offset#0 ← (byte) renderBob::xpos#0 >> (byte) 2 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 ] ) always clobbers reg byte a -Statement [72] (byte) renderBob::y_char_offset#0 ← (byte) renderBob::ypos#0 >> (byte) 3 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_char_offset#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_char_offset#0 ] ) always clobbers reg byte a -Statement [73] (byte~) renderBob::$8 ← (byte) renderBob::y_char_offset#0 << (byte) 1 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$8 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$8 ] ) always clobbers reg byte a -Statement [74] (word) renderBob::y_offset#0 ← *((const word*) MUL40 + (byte~) renderBob::$8) [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_offset#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_offset#0 ] ) always clobbers reg byte a -Statement [75] (byte*~) renderBob::$2 ← (const byte*) BOB_SCREEN + (word) renderBob::y_offset#0 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$2 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$2 ] ) always clobbers reg byte a -Statement [76] (byte*) renderBob::screen#0 ← (byte*~) renderBob::$2 + (byte) renderBob::x_char_offset#0 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::screen#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::screen#0 ] ) always clobbers reg byte a -Statement [77] (byte~) renderBob::$4 ← (byte) renderBob::ypos#0 & (byte) 7 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$4 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$4 ] ) always clobbers reg byte a -Statement [78] (byte~) renderBob::$5 ← (byte~) renderBob::$4 << (byte) 2 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$5 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$5 ] ) always clobbers reg byte a -Statement [79] (byte~) renderBob::$6 ← (byte) renderBob::xpos#0 & (byte) 3 [ renderBobCleanupNext#17 renderBob::screen#0 renderBob::$5 renderBob::$6 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::screen#0 renderBob::$5 renderBob::$6 ] ) always clobbers reg byte a -Statement [80] (byte) renderBob::bob_table_idx#0 ← (byte~) renderBob::$5 + (byte~) renderBob::$6 [ renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a -Statement [81] *((byte**) renderBobCleanupNext#17) ← (byte*) renderBob::screen#0 [ renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y -Statement [82] (byte**) renderBobCleanupNext#13 ← (byte**) renderBobCleanupNext#17 + (const byte) SIZEOF_POINTER [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a -Statement [83] *((byte*) renderBob::screen#0) ← *((const byte*) BOB_TABLES + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y -Statement [84] *((byte*) renderBob::screen#0 + (byte) $28) ← *((const byte*) BOB_TABLES+(byte) 1*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y -Statement [85] *((byte*) renderBob::screen#0 + (byte) $50) ← *((const byte*) BOB_TABLES+(byte) 2*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y -Statement [86] *((byte*) renderBob::screen#0 + (byte) 1) ← *((const byte*) BOB_TABLES+(byte) 3*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y -Statement [87] *((byte*) renderBob::screen#0 + (byte) $29) ← *((const byte*) BOB_TABLES+(byte) 4*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y -Statement [88] *((byte*) renderBob::screen#0 + (byte) $51) ← *((const byte*) BOB_TABLES+(byte) 5*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y -Statement [89] *((byte*) renderBob::screen#0 + (byte) 2) ← *((const byte*) BOB_TABLES+(byte) 6*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y -Statement [90] *((byte*) renderBob::screen#0 + (byte) $2a) ← *((const byte*) BOB_TABLES+(byte) 7*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y -Statement [91] *((byte*) renderBob::screen#0 + (byte) $52) ← *((const byte*) BOB_TABLES+(byte) 8*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 ] ) always clobbers reg byte a reg byte y -Statement [98] (signed word) mulf8s::return#0 ← (signed word)(word) mulf8s_prepared::m#4 [ mulf8s::return#0 ] ( main:3::mulf8s:26 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::return#0 ] main:3::mulf8s:32 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::return#0 ] ) always clobbers reg byte a -Statement [102] (word) mulf8u_prepared::return#2 ← (word) mulf8u_prepared::return#0 [ mulf8s_prepared::b#0 mulf8u_prepared::return#2 ] ( main:3::mulf8s:26::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8u_prepared::return#2 ] main:3::mulf8s:32::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8u_prepared::return#2 ] ) always clobbers reg byte a -Statement [103] (word) mulf8s_prepared::m#0 ← (word) mulf8u_prepared::return#2 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ( main:3::mulf8s:26::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] main:3::mulf8s:32::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ) always clobbers reg byte a -Statement [104] if(*((const signed byte*) mulf8s_prepared::memA)>=(signed byte) 0) goto mulf8s_prepared::@1 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ( main:3::mulf8s:26::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] main:3::mulf8s:32::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ) always clobbers reg byte a -Statement [105] (byte~) mulf8s_prepared::$8 ← > (word) mulf8s_prepared::m#0 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$8 ] ( main:3::mulf8s:26::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$8 ] main:3::mulf8s:32::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$8 ] ) always clobbers reg byte a -Statement [106] (byte~) mulf8s_prepared::$15 ← (byte~) mulf8s_prepared::$8 - (byte)(signed byte) mulf8s_prepared::b#0 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$15 ] ( main:3::mulf8s:26::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$15 ] main:3::mulf8s:32::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$15 ] ) always clobbers reg byte a -Statement [110] (byte~) mulf8s_prepared::$12 ← > (word) mulf8s_prepared::m#5 [ mulf8s_prepared::m#5 mulf8s_prepared::$12 ] ( main:3::mulf8s:26::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::m#5 mulf8s_prepared::$12 ] main:3::mulf8s:32::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::m#5 mulf8s_prepared::$12 ] ) always clobbers reg byte a -Statement [111] (byte~) mulf8s_prepared::$16 ← (byte~) mulf8s_prepared::$12 - (byte)*((const signed byte*) mulf8s_prepared::memA) [ mulf8s_prepared::m#5 mulf8s_prepared::$16 ] ( main:3::mulf8s:26::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::m#5 mulf8s_prepared::$16 ] main:3::mulf8s:32::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::m#5 mulf8s_prepared::$16 ] ) always clobbers reg byte a +Statement [26] (signed word) mulf8s::return#2 ← (signed word) mulf8s::return#0 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::return#2 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::return#2 ] ) always clobbers reg byte a +Statement [27] (signed word~) main::$10 ← (signed word) mulf8s::return#2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::$10 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::$10 ] ) always clobbers reg byte a +Statement [28] (signed word) main::x#0 ← (signed word~) main::$10 + (signed word)(number) $4b*(number) $100 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 ] ) always clobbers reg byte a +Statement [30] (signed byte) mulf8s::b#1 ← *((const signed byte*) SIN + (byte) main::a#2) [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::a#1 mulf8s::b#1 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::a#1 mulf8s::b#1 ] ) always clobbers reg byte y +Statement [32] (signed word) mulf8s::return#3 ← (signed word) mulf8s::return#0 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::return#3 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::return#3 ] ) always clobbers reg byte a +Statement [33] (signed word~) main::$12 ← (signed word) mulf8s::return#3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$12 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$12 ] ) always clobbers reg byte a +Statement [34] (signed word~) main::$13 ← (signed word~) main::$12 << (byte) 1 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$13 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$13 ] ) always clobbers reg byte a +Statement [35] (signed word) main::y#0 ← (signed word~) main::$13 + (signed word)(number) $5a*(number) $100 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ) always clobbers reg byte a +Statement [36] *((const byte*) BORDERCOL) ← (byte) 2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ) always clobbers reg byte a +Statement [37] (byte) main::a#1 ← (byte) main::a#2 + (byte) $62 [ main::angle#8 main::r#2 renderBobCleanupNext#17 main::i#2 main::a#1 main::x#0 main::y#0 ] ( main:2 [ main::angle#8 main::r#2 renderBobCleanupNext#17 main::i#2 main::a#1 main::x#0 main::y#0 ] ) always clobbers reg byte a reg byte x +Statement [38] (signed byte) main::r#1 ← (signed byte) main::r#2 + (signed byte) 3 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::x#0 main::y#0 ] ( main:2 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::x#0 main::y#0 ] ) always clobbers reg byte a reg byte x +Statement [39] (byte) renderBob::xpos#0 ← > (signed word) main::x#0 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::y#0 renderBob::xpos#0 ] ( main:2 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::y#0 renderBob::xpos#0 ] ) always clobbers reg byte a +Statement [40] (byte) renderBob::ypos#0 ← > (signed word) main::y#0 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 renderBob::xpos#0 renderBob::ypos#0 ] ( main:2 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 renderBob::xpos#0 renderBob::ypos#0 ] ) always clobbers reg byte a +Statement [43] if((byte) main::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto main::@4 [ main::angle#8 main::r#1 main::a#1 renderBobCleanupNext#13 main::i#1 ] ( main:2 [ main::angle#8 main::r#1 main::a#1 renderBobCleanupNext#13 main::i#1 ] ) always clobbers reg byte a +Statement [44] (byte) main::angle#1 ← (byte) main::angle#8 + (byte) 3 [ main::angle#1 ] ( main:2 [ main::angle#1 ] ) always clobbers reg byte a reg byte x +Statement [45] *((const byte*) BORDERCOL) ← (byte) 0 [ main::angle#1 ] ( main:2 [ main::angle#1 ] ) always clobbers reg byte a +Statement [55] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [57] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank2_toDd001_return#0 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [59] *((const byte*) D018) ← (const byte) main::toD0182_return#0 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [67] *((const byte*) CIA1_PORT_A) ← *((const byte*) keyboard_matrix_row_bitmask+(const byte) keyboard_key_pressed::rowidx#0) [ ] ( main:2::keyboard_key_pressed:46::keyboard_matrix_read:62 [ main::angle#1 ] main:2::keyboard_key_pressed:51::keyboard_matrix_read:62 [ ] ) always clobbers reg byte a +Statement [68] (byte) keyboard_matrix_read::return#0 ← ~ *((const byte*) CIA1_PORT_B) [ keyboard_matrix_read::return#0 ] ( main:2::keyboard_key_pressed:46::keyboard_matrix_read:62 [ main::angle#1 keyboard_matrix_read::return#0 ] main:2::keyboard_key_pressed:51::keyboard_matrix_read:62 [ keyboard_matrix_read::return#0 ] ) always clobbers reg byte a +Statement [70] (byte) renderBob::x_char_offset#0 ← (byte) renderBob::xpos#0 >> (byte) 2 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 ] ) always clobbers reg byte a +Statement [71] (byte) renderBob::y_char_offset#0 ← (byte) renderBob::ypos#0 >> (byte) 3 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_char_offset#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_char_offset#0 ] ) always clobbers reg byte a +Statement [72] (byte~) renderBob::$8 ← (byte) renderBob::y_char_offset#0 << (byte) 1 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$8 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$8 ] ) always clobbers reg byte a +Statement [73] (word) renderBob::y_offset#0 ← *((const word*) MUL40 + (byte~) renderBob::$8) [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_offset#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_offset#0 ] ) always clobbers reg byte a +Statement [74] (byte*~) renderBob::$2 ← (const byte*) BOB_SCREEN + (word) renderBob::y_offset#0 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$2 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$2 ] ) always clobbers reg byte a +Statement [75] (byte*) renderBob::screen#0 ← (byte*~) renderBob::$2 + (byte) renderBob::x_char_offset#0 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::screen#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::screen#0 ] ) always clobbers reg byte a +Statement [76] (byte~) renderBob::$4 ← (byte) renderBob::ypos#0 & (byte) 7 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$4 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$4 ] ) always clobbers reg byte a +Statement [77] (byte~) renderBob::$5 ← (byte~) renderBob::$4 << (byte) 2 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$5 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$5 ] ) always clobbers reg byte a +Statement [78] (byte~) renderBob::$6 ← (byte) renderBob::xpos#0 & (byte) 3 [ renderBobCleanupNext#17 renderBob::screen#0 renderBob::$5 renderBob::$6 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::screen#0 renderBob::$5 renderBob::$6 ] ) always clobbers reg byte a +Statement [79] (byte) renderBob::bob_table_idx#0 ← (byte~) renderBob::$5 + (byte~) renderBob::$6 [ renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a +Statement [80] *((byte**) renderBobCleanupNext#17) ← (byte*) renderBob::screen#0 [ renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [81] (byte**) renderBobCleanupNext#13 ← (byte**) renderBobCleanupNext#17 + (const byte) SIZEOF_POINTER [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a +Statement [82] *((byte*) renderBob::screen#0) ← *((const byte*) BOB_TABLES + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [83] *((byte*) renderBob::screen#0 + (byte) $28) ← *((const byte*) BOB_TABLES+(byte) 1*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [84] *((byte*) renderBob::screen#0 + (byte) $50) ← *((const byte*) BOB_TABLES+(byte) 2*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [85] *((byte*) renderBob::screen#0 + (byte) 1) ← *((const byte*) BOB_TABLES+(byte) 3*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [86] *((byte*) renderBob::screen#0 + (byte) $29) ← *((const byte*) BOB_TABLES+(byte) 4*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [87] *((byte*) renderBob::screen#0 + (byte) $51) ← *((const byte*) BOB_TABLES+(byte) 5*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [88] *((byte*) renderBob::screen#0 + (byte) 2) ← *((const byte*) BOB_TABLES+(byte) 6*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [89] *((byte*) renderBob::screen#0 + (byte) $2a) ← *((const byte*) BOB_TABLES+(byte) 7*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [90] *((byte*) renderBob::screen#0 + (byte) $52) ← *((const byte*) BOB_TABLES+(byte) 8*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 ] ) always clobbers reg byte a reg byte y +Statement [97] (signed word) mulf8s::return#0 ← (signed word)(word) mulf8s_prepared::m#4 [ mulf8s::return#0 ] ( main:2::mulf8s:25 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::return#0 ] main:2::mulf8s:31 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::return#0 ] ) always clobbers reg byte a +Statement [101] (word) mulf8u_prepared::return#2 ← (word) mulf8u_prepared::return#0 [ mulf8s_prepared::b#0 mulf8u_prepared::return#2 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8u_prepared::return#2 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8u_prepared::return#2 ] ) always clobbers reg byte a +Statement [102] (word) mulf8s_prepared::m#0 ← (word) mulf8u_prepared::return#2 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ) always clobbers reg byte a +Statement [103] if(*((const signed byte*) mulf8s_prepared::memA)>=(signed byte) 0) goto mulf8s_prepared::@1 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ) always clobbers reg byte a +Statement [104] (byte~) mulf8s_prepared::$8 ← > (word) mulf8s_prepared::m#0 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$8 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$8 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$8 ] ) always clobbers reg byte a +Statement [105] (byte~) mulf8s_prepared::$15 ← (byte~) mulf8s_prepared::$8 - (byte)(signed byte) mulf8s_prepared::b#0 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$15 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$15 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$15 ] ) always clobbers reg byte a +Statement [109] (byte~) mulf8s_prepared::$12 ← > (word) mulf8s_prepared::m#5 [ mulf8s_prepared::m#5 mulf8s_prepared::$12 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::m#5 mulf8s_prepared::$12 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::m#5 mulf8s_prepared::$12 ] ) always clobbers reg byte a +Statement [110] (byte~) mulf8s_prepared::$16 ← (byte~) mulf8s_prepared::$12 - (byte)*((const signed byte*) mulf8s_prepared::memA) [ mulf8s_prepared::m#5 mulf8s_prepared::$16 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::m#5 mulf8s_prepared::$16 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::m#5 mulf8s_prepared::$16 ] ) always clobbers reg byte a Statement asm { ldxmemB sec sm1: ldamulf_sqr1_lo,x sm2: sbcmulf_sqr2_lo,x staresL sm3: ldamulf_sqr1_hi,x sm4: sbcmulf_sqr2_hi,x stamemB } always clobbers reg byte a reg byte x -Statement [117] (word) mulf8u_prepared::return#0 ← *((const byte*) mulf8u_prepared::memB) w= *((const byte*) mulf8u_prepared::resL) [ mulf8u_prepared::return#0 ] ( main:3::mulf8s:26::mulf8s_prepared:97::mulf8u_prepared:101 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8u_prepared::return#0 ] main:3::mulf8s:32::mulf8s_prepared:97::mulf8u_prepared:101 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8u_prepared::return#0 ] ) always clobbers reg byte a +Statement [116] (word) mulf8u_prepared::return#0 ← *((const byte*) mulf8u_prepared::memB) w= *((const byte*) mulf8u_prepared::resL) [ mulf8u_prepared::return#0 ] ( main:2::mulf8s:25::mulf8s_prepared:96::mulf8u_prepared:100 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8u_prepared::return#0 ] main:2::mulf8s:31::mulf8s_prepared:96::mulf8u_prepared:100 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8u_prepared::return#0 ] ) always clobbers reg byte a Statement asm { ldamemA stamulf8u_prepared.sm1+1 stamulf8u_prepared.sm3+1 eor#$ff stamulf8u_prepared.sm2+1 stamulf8u_prepared.sm4+1 } always clobbers reg byte a -Statement [124] (byte~) renderBobCleanup::$1 ← (byte) renderBobCleanup::i#2 << (byte) 1 [ renderBobCleanup::i#2 renderBobCleanup::$1 ] ( main:3::renderBobCleanup:20 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::$1 ] ) always clobbers reg byte a -Statement [125] (byte*) renderBobCleanup::screen#0 ← *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobCleanup::$1) [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:3::renderBobCleanup:20 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a -Statement [126] *((byte*) renderBobCleanup::screen#0) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:3::renderBobCleanup:20 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y -Statement [127] *((byte*) renderBobCleanup::screen#0 + (byte) $28) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:3::renderBobCleanup:20 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y -Statement [128] *((byte*) renderBobCleanup::screen#0 + (byte) $50) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:3::renderBobCleanup:20 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y -Statement [129] *((byte*) renderBobCleanup::screen#0 + (byte) 1) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:3::renderBobCleanup:20 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y -Statement [130] *((byte*) renderBobCleanup::screen#0 + (byte) $29) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:3::renderBobCleanup:20 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y -Statement [131] *((byte*) renderBobCleanup::screen#0 + (byte) $51) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:3::renderBobCleanup:20 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y -Statement [132] *((byte*) renderBobCleanup::screen#0 + (byte) 2) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:3::renderBobCleanup:20 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y -Statement [133] *((byte*) renderBobCleanup::screen#0 + (byte) $2a) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:3::renderBobCleanup:20 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y -Statement [134] *((byte*) renderBobCleanup::screen#0 + (byte) $52) ← (byte) 0 [ renderBobCleanup::i#2 ] ( main:3::renderBobCleanup:20 [ main::angle#8 renderBobCleanup::i#2 ] ) always clobbers reg byte a reg byte y -Statement [140] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 [ memset::dst#2 ] ( main:3::memset:16 [ memset::dst#2 ] ) always clobbers reg byte a -Statement [142] *((byte*) memset::dst#2) ← (const byte) memset::c#0 [ memset::dst#2 ] ( main:3::memset:16 [ memset::dst#2 ] ) always clobbers reg byte a reg byte y -Statement [146] (word~) renderBobInit::$0 ← (word)(byte) renderBobInit::y#2 [ renderBobInit::y#2 renderBobInit::$0 ] ( main:3::renderBobInit:10 [ renderBobInit::y#2 renderBobInit::$0 ] ) always clobbers reg byte a -Statement [147] (word~) renderBobInit::$6 ← (word~) renderBobInit::$0 << (byte) 2 [ renderBobInit::y#2 renderBobInit::$0 renderBobInit::$6 ] ( main:3::renderBobInit:10 [ renderBobInit::y#2 renderBobInit::$0 renderBobInit::$6 ] ) always clobbers reg byte a -Statement [148] (word~) renderBobInit::$7 ← (word~) renderBobInit::$6 + (word~) renderBobInit::$0 [ renderBobInit::y#2 renderBobInit::$7 ] ( main:3::renderBobInit:10 [ renderBobInit::y#2 renderBobInit::$7 ] ) always clobbers reg byte a -Statement [149] (word~) renderBobInit::$1 ← (word~) renderBobInit::$7 << (byte) 3 [ renderBobInit::y#2 renderBobInit::$1 ] ( main:3::renderBobInit:10 [ renderBobInit::y#2 renderBobInit::$1 ] ) always clobbers reg byte a -Statement [150] (byte~) renderBobInit::$4 ← (byte) renderBobInit::y#2 << (byte) 1 [ renderBobInit::y#2 renderBobInit::$1 renderBobInit::$4 ] ( main:3::renderBobInit:10 [ renderBobInit::y#2 renderBobInit::$1 renderBobInit::$4 ] ) always clobbers reg byte a -Statement [151] *((const word*) MUL40 + (byte~) renderBobInit::$4) ← (word~) renderBobInit::$1 [ renderBobInit::y#2 ] ( main:3::renderBobInit:10 [ renderBobInit::y#2 ] ) always clobbers reg byte a -Statement [155] (byte~) renderBobInit::$5 ← (byte) renderBobInit::i#2 << (byte) 1 [ renderBobInit::i#2 renderBobInit::$5 ] ( main:3::renderBobInit:10 [ renderBobInit::i#2 renderBobInit::$5 ] ) always clobbers reg byte a -Statement [156] *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobInit::$5) ← (const byte*) BOB_SCREEN [ renderBobInit::i#2 ] ( main:3::renderBobInit:10 [ renderBobInit::i#2 ] ) always clobbers reg byte a -Statement [165] if((byte) prepareBobs::shift_y#2<(const byte) BOB_SHIFTS_Y) goto prepareBobs::@2 [ prepareBobs::shift_y#2 progress_cursor#15 progress_idx#16 bob_charset_next_id#14 prepareBobs::bob_table_idx#6 ] ( main:3::prepareBobs:8 [ prepareBobs::shift_y#2 progress_cursor#15 progress_idx#16 bob_charset_next_id#14 prepareBobs::bob_table_idx#6 ] ) always clobbers reg byte a -Statement [168] if((byte) prepareBobs::shift_x#2<(const byte) BOB_SHIFTS_X) goto prepareBobs::@3 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 ] ( main:3::prepareBobs:8 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 ] ) always clobbers reg byte a -Statement [172] (byte*) prepareBobs::bob_table#0 ← (const byte*) BOB_TABLES + (byte) prepareBobs::bob_table_idx#12 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::bob_table#0 ] ( main:3::prepareBobs:8 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::bob_table#0 ] ) always clobbers reg byte a -Statement [174] if((byte) prepareBobs::cell#2<(byte) 9) goto prepareBobs::@6 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 ] ( main:3::prepareBobs:8 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 ] ) always clobbers reg byte a -Statement [180] (byte*) bobCharsetFindOrAddGlyph::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bobCharsetFindOrAddGlyph::bob_glyph#1 ] ( main:3::prepareBobs:8 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bobCharsetFindOrAddGlyph::bob_glyph#1 ] ) always clobbers reg byte a -Statement [184] *((byte*) prepareBobs::bob_table#2) ← (byte~) prepareBobs::$6 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 ] ( main:3::prepareBobs:8 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 ] ) always clobbers reg byte y -Statement [185] (byte*) prepareBobs::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 + (byte) 8 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_table#2 prepareBobs::bob_glyph#1 ] ( main:3::prepareBobs:8 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_table#2 prepareBobs::bob_glyph#1 ] ) always clobbers reg byte a -Statement [186] (byte*) prepareBobs::bob_table#1 ← (byte*) prepareBobs::bob_table#2 + (const byte) BOB_SHIFTS_X*(const byte) BOB_SHIFTS_Y [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 ] ( main:3::prepareBobs:8 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 ] ) always clobbers reg byte a -Statement [190] if((byte) progress_idx#8!=(byte) 8) goto progress_inc::@1 [ progress_cursor#24 progress_idx#8 ] ( main:3::prepareBobs:8::progress_inc:187 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 progress_cursor#24 progress_idx#8 ] ) always clobbers reg byte a -Statement [191] *((byte*) progress_cursor#24) ← *((const byte*) progress_inc::progress_chars+(byte) 8) [ progress_cursor#24 ] ( main:3::prepareBobs:8::progress_inc:187 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 progress_cursor#24 ] ) always clobbers reg byte a reg byte y -Statement [194] *((byte*) progress_cursor#17) ← *((const byte*) progress_inc::progress_chars + (byte) progress_idx#10) [ progress_idx#10 progress_cursor#17 ] ( main:3::prepareBobs:8::progress_inc:187 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 progress_idx#10 progress_cursor#17 ] ) always clobbers reg byte a reg byte y -Statement [198] if((byte) bobCharsetFindOrAddGlyph::glyph_id#11!=(byte) bob_charset_next_id#23) goto bobCharsetFindOrAddGlyph::@2 [ bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 ] ( main:3::prepareBobs:8::bobCharsetFindOrAddGlyph:163 [ bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 ] main:3::prepareBobs:8::bobCharsetFindOrAddGlyph:181 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 ] ) always clobbers reg byte a -Statement [204] *((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) bobCharsetFindOrAddGlyph::i1#2) ← *((byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 + (byte) bobCharsetFindOrAddGlyph::i1#2) [ bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i1#2 ] ( main:3::prepareBobs:8::bobCharsetFindOrAddGlyph:163 [ bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i1#2 ] main:3::prepareBobs:8::bobCharsetFindOrAddGlyph:181 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i1#2 ] ) always clobbers reg byte a -Statement [207] if((byte) bobCharsetFindOrAddGlyph::i#2<(byte) 8) goto bobCharsetFindOrAddGlyph::@3 [ bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i#2 ] ( main:3::prepareBobs:8::bobCharsetFindOrAddGlyph:163 [ bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i#2 ] main:3::prepareBobs:8::bobCharsetFindOrAddGlyph:181 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i#2 ] ) always clobbers reg byte a -Statement [208] if(*((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) bobCharsetFindOrAddGlyph::i#2)==*((byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 + (byte) bobCharsetFindOrAddGlyph::i#2)) goto bobCharsetFindOrAddGlyph::@4 [ bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i#2 ] ( main:3::prepareBobs:8::bobCharsetFindOrAddGlyph:163 [ bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i#2 ] main:3::prepareBobs:8::bobCharsetFindOrAddGlyph:181 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i#2 ] ) always clobbers reg byte a reg byte x reg byte y -Statement [212] (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#1 ← (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) 8 [ bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_id#1 bobCharsetFindOrAddGlyph::glyph_cursor#1 ] ( main:3::prepareBobs:8::bobCharsetFindOrAddGlyph:163 [ bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_id#1 bobCharsetFindOrAddGlyph::glyph_cursor#1 ] main:3::prepareBobs:8::bobCharsetFindOrAddGlyph:181 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_id#1 bobCharsetFindOrAddGlyph::glyph_cursor#1 ] ) always clobbers reg byte a -Statement [218] (byte~) shiftProtoBobRight::$1 ← *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) & (byte) 1 [ shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::$1 ] ( main:3::prepareBobs:8::shiftProtoBobRight:176 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::$1 ] main:3::prepareBobs:8::shiftProtoBobRight:178 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::$1 ] ) always clobbers reg byte a -Statement [222] (byte~) shiftProtoBobRight::$5 ← *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) >> (byte) 1 [ shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::$5 ] ( main:3::prepareBobs:8::shiftProtoBobRight:176 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::$5 ] main:3::prepareBobs:8::shiftProtoBobRight:178 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::$5 ] ) always clobbers reg byte a -Statement [226] (byte) shiftProtoBobRight::j#2 ← (byte) shiftProtoBobRight::j#3 + (byte) $18 [ shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#2 ] ( main:3::prepareBobs:8::shiftProtoBobRight:176 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#2 ] main:3::prepareBobs:8::shiftProtoBobRight:178 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#2 ] ) always clobbers reg byte a -Statement [230] (byte) shiftProtoBobRight::j#1 ← (byte) shiftProtoBobRight::j#3 - (byte) $2f [ shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#1 ] ( main:3::prepareBobs:8::shiftProtoBobRight:176 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#1 ] main:3::prepareBobs:8::shiftProtoBobRight:178 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#1 ] ) always clobbers reg byte a -Statement [234] *((const byte*) PROTO_BOB) ← (byte) 0 [ ] ( main:3::prepareBobs:8::shiftProtoBobDown:170 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 ] ) always clobbers reg byte a -Statement [235] *((const byte*) PROTO_BOB+(byte) $18) ← (byte) 0 [ ] ( main:3::prepareBobs:8::shiftProtoBobDown:170 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 ] ) always clobbers reg byte a -Statement [236] *((const byte*) PROTO_BOB+(byte) $30) ← (byte) 0 [ ] ( main:3::prepareBobs:8::shiftProtoBobDown:170 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 ] ) always clobbers reg byte a -Statement [238] *((const byte*) PROTO_BOB + (byte) shiftProtoBobDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $17 + (byte) shiftProtoBobDown::i#2) [ shiftProtoBobDown::i#2 ] ( main:3::prepareBobs:8::shiftProtoBobDown:170 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 shiftProtoBobDown::i#2 ] ) always clobbers reg byte a -Statement [239] *((const byte*) PROTO_BOB+(byte) $18 + (byte) shiftProtoBobDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $2f + (byte) shiftProtoBobDown::i#2) [ shiftProtoBobDown::i#2 ] ( main:3::prepareBobs:8::shiftProtoBobDown:170 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 shiftProtoBobDown::i#2 ] ) always clobbers reg byte a -Statement [240] *((const byte*) PROTO_BOB+(byte) $30 + (byte) shiftProtoBobDown::i#2) ← (byte) 0 [ shiftProtoBobDown::i#2 ] ( main:3::prepareBobs:8::shiftProtoBobDown:170 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 shiftProtoBobDown::i#2 ] ) always clobbers reg byte a -Statement [246] if((byte*) mulf_init::sqr1_lo#2!=(const byte*) mulf_sqr1_lo+(word) $200) goto mulf_init::@2 [ mulf_init::sqr1_lo#2 mulf_init::c#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 ] ( main:3::mulf_init:6 [ mulf_init::sqr1_lo#2 mulf_init::c#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 ] ) always clobbers reg byte a -Statement [248] if((byte*) mulf_init::sqr2_lo#2!=(const byte*) mulf_sqr2_lo+(word) $1ff) goto mulf_init::@6 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ( main:3::mulf_init:6 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ) always clobbers reg byte a -Statement [249] *((const byte*) mulf_sqr2_lo+(word) $1ff) ← *((const byte*) mulf_sqr1_lo+(word) $100) [ ] ( main:3::mulf_init:6 [ ] ) always clobbers reg byte a -Statement [250] *((const byte*) mulf_sqr2_hi+(word) $1ff) ← *((const byte*) mulf_sqr1_hi+(word) $100) [ ] ( main:3::mulf_init:6 [ ] ) always clobbers reg byte a -Statement [252] *((byte*) mulf_init::sqr2_lo#2) ← *((const byte*) mulf_sqr1_lo + (byte) mulf_init::x_255#2) [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ( main:3::mulf_init:6 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ) always clobbers reg byte a reg byte y -Statement [253] *((byte*) mulf_init::sqr2_hi#2) ← *((const byte*) mulf_sqr1_hi + (byte) mulf_init::x_255#2) [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ( main:3::mulf_init:6 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ) always clobbers reg byte a reg byte y -Statement [255] (byte) mulf_init::x_255#1 ← (byte) mulf_init::x_255#2 + (byte) mulf_init::dir#2 [ mulf_init::sqr2_lo#2 mulf_init::dir#2 mulf_init::x_255#1 mulf_init::sqr2_hi#1 ] ( main:3::mulf_init:6 [ mulf_init::sqr2_lo#2 mulf_init::dir#2 mulf_init::x_255#1 mulf_init::sqr2_hi#1 ] ) always clobbers reg byte a -Statement [261] (byte~) mulf_init::$1 ← (byte) mulf_init::c#1 & (byte) 1 [ mulf_init::sqr1_lo#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 mulf_init::c#1 mulf_init::$1 ] ( main:3::mulf_init:6 [ mulf_init::sqr1_lo#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 mulf_init::c#1 mulf_init::$1 ] ) always clobbers reg byte a -Statement [266] (byte~) mulf_init::$4 ← < (word) mulf_init::sqr#3 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$4 ] ( main:3::mulf_init:6 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$4 ] ) always clobbers reg byte a -Statement [267] *((byte*) mulf_init::sqr1_lo#2) ← (byte~) mulf_init::$4 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ( main:3::mulf_init:6 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ) always clobbers reg byte y -Statement [268] (byte~) mulf_init::$5 ← > (word) mulf_init::sqr#3 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$5 ] ( main:3::mulf_init:6 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$5 ] ) always clobbers reg byte a -Statement [269] *((byte*) mulf_init::sqr1_hi#2) ← (byte~) mulf_init::$5 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ( main:3::mulf_init:6 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ) always clobbers reg byte y -Statement [271] (word) mulf_init::sqr#1 ← (word) mulf_init::sqr#3 + (byte) mulf_init::x_2#2 [ mulf_init::sqr1_lo#2 mulf_init::c#1 mulf_init::sqr#1 mulf_init::sqr1_hi#1 mulf_init::x_2#2 ] ( main:3::mulf_init:6 [ mulf_init::sqr1_lo#2 mulf_init::c#1 mulf_init::sqr#1 mulf_init::sqr1_hi#1 mulf_init::x_2#2 ] ) always clobbers reg byte a -Statement [11] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 [ ] ( main:3 [ ] ) always clobbers reg byte a -Statement [13] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank1_toDd001_return#0 [ ] ( main:3 [ ] ) always clobbers reg byte a -Statement [15] *((const byte*) D018) ← (const byte) main::toD0181_return#0 [ ] ( main:3 [ ] ) always clobbers reg byte a -Statement [18] if(*((const byte*) RASTER)<(byte) $f8) goto main::@2 [ main::angle#8 ] ( main:3 [ main::angle#8 ] ) always clobbers reg byte a -Statement [19] *((const byte*) BORDERCOL) ← (byte) $f [ main::angle#8 ] ( main:3 [ main::angle#8 ] ) always clobbers reg byte a -Statement [21] (byte) main::a#6 ← (byte) main::angle#8 [ main::angle#8 main::a#6 ] ( main:3 [ main::angle#8 main::a#6 ] ) always clobbers reg byte a -Statement [23] *((const byte*) BORDERCOL) ← (byte) 1 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 ] ( main:3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 ] ) always clobbers reg byte a -Statement [25] (signed byte) mulf8s::b#0 ← *((const signed byte*) COS + (byte) main::a#2) [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::a#0 mulf8s::b#0 ] ( main:3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::a#0 mulf8s::b#0 ] ) always clobbers reg byte y -Statement [27] (signed word) mulf8s::return#2 ← (signed word) mulf8s::return#0 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::return#2 ] ( main:3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::return#2 ] ) always clobbers reg byte a -Statement [28] (signed word~) main::$10 ← (signed word) mulf8s::return#2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::$10 ] ( main:3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::$10 ] ) always clobbers reg byte a -Statement [29] (signed word) main::x#0 ← (signed word~) main::$10 + (signed word)(number) $4b*(number) $100 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 ] ( main:3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 ] ) always clobbers reg byte a -Statement [31] (signed byte) mulf8s::b#1 ← *((const signed byte*) SIN + (byte) main::a#2) [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::a#1 mulf8s::b#1 ] ( main:3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::a#1 mulf8s::b#1 ] ) always clobbers reg byte y -Statement [33] (signed word) mulf8s::return#3 ← (signed word) mulf8s::return#0 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::return#3 ] ( main:3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::return#3 ] ) always clobbers reg byte a -Statement [34] (signed word~) main::$12 ← (signed word) mulf8s::return#3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$12 ] ( main:3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$12 ] ) always clobbers reg byte a -Statement [35] (signed word~) main::$13 ← (signed word~) main::$12 << (byte) 1 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$13 ] ( main:3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$13 ] ) always clobbers reg byte a -Statement [36] (signed word) main::y#0 ← (signed word~) main::$13 + (signed word)(number) $5a*(number) $100 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ( main:3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ) always clobbers reg byte a -Statement [37] *((const byte*) BORDERCOL) ← (byte) 2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ( main:3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ) always clobbers reg byte a -Statement [38] (byte) main::a#1 ← (byte) main::a#2 + (byte) $62 [ main::angle#8 main::r#2 renderBobCleanupNext#17 main::i#2 main::a#1 main::x#0 main::y#0 ] ( main:3 [ main::angle#8 main::r#2 renderBobCleanupNext#17 main::i#2 main::a#1 main::x#0 main::y#0 ] ) always clobbers reg byte a reg byte x -Statement [39] (signed byte) main::r#1 ← (signed byte) main::r#2 + (signed byte) 3 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::x#0 main::y#0 ] ( main:3 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::x#0 main::y#0 ] ) always clobbers reg byte a reg byte x -Statement [40] (byte) renderBob::xpos#0 ← > (signed word) main::x#0 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::y#0 renderBob::xpos#0 ] ( main:3 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::y#0 renderBob::xpos#0 ] ) always clobbers reg byte a -Statement [41] (byte) renderBob::ypos#0 ← > (signed word) main::y#0 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 renderBob::xpos#0 renderBob::ypos#0 ] ( main:3 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 renderBob::xpos#0 renderBob::ypos#0 ] ) always clobbers reg byte a -Statement [44] if((byte) main::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto main::@4 [ main::angle#8 main::r#1 main::a#1 renderBobCleanupNext#13 main::i#1 ] ( main:3 [ main::angle#8 main::r#1 main::a#1 renderBobCleanupNext#13 main::i#1 ] ) always clobbers reg byte a -Statement [45] (byte) main::angle#1 ← (byte) main::angle#8 + (byte) 3 [ main::angle#1 ] ( main:3 [ main::angle#1 ] ) always clobbers reg byte a reg byte x -Statement [46] *((const byte*) BORDERCOL) ← (byte) 0 [ main::angle#1 ] ( main:3 [ main::angle#1 ] ) always clobbers reg byte a -Statement [56] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 [ ] ( main:3 [ ] ) always clobbers reg byte a -Statement [58] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank2_toDd001_return#0 [ ] ( main:3 [ ] ) always clobbers reg byte a -Statement [60] *((const byte*) D018) ← (const byte) main::toD0182_return#0 [ ] ( main:3 [ ] ) always clobbers reg byte a -Statement [68] *((const byte*) CIA1_PORT_A) ← *((const byte*) keyboard_matrix_row_bitmask+(const byte) keyboard_key_pressed::rowidx#0) [ ] ( main:3::keyboard_key_pressed:47::keyboard_matrix_read:63 [ main::angle#1 ] main:3::keyboard_key_pressed:52::keyboard_matrix_read:63 [ ] ) always clobbers reg byte a -Statement [69] (byte) keyboard_matrix_read::return#0 ← ~ *((const byte*) CIA1_PORT_B) [ keyboard_matrix_read::return#0 ] ( main:3::keyboard_key_pressed:47::keyboard_matrix_read:63 [ main::angle#1 keyboard_matrix_read::return#0 ] main:3::keyboard_key_pressed:52::keyboard_matrix_read:63 [ keyboard_matrix_read::return#0 ] ) always clobbers reg byte a -Statement [71] (byte) renderBob::x_char_offset#0 ← (byte) renderBob::xpos#0 >> (byte) 2 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 ] ) always clobbers reg byte a -Statement [72] (byte) renderBob::y_char_offset#0 ← (byte) renderBob::ypos#0 >> (byte) 3 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_char_offset#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_char_offset#0 ] ) always clobbers reg byte a -Statement [73] (byte~) renderBob::$8 ← (byte) renderBob::y_char_offset#0 << (byte) 1 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$8 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$8 ] ) always clobbers reg byte a -Statement [74] (word) renderBob::y_offset#0 ← *((const word*) MUL40 + (byte~) renderBob::$8) [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_offset#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_offset#0 ] ) always clobbers reg byte a -Statement [75] (byte*~) renderBob::$2 ← (const byte*) BOB_SCREEN + (word) renderBob::y_offset#0 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$2 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$2 ] ) always clobbers reg byte a -Statement [76] (byte*) renderBob::screen#0 ← (byte*~) renderBob::$2 + (byte) renderBob::x_char_offset#0 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::screen#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::screen#0 ] ) always clobbers reg byte a -Statement [77] (byte~) renderBob::$4 ← (byte) renderBob::ypos#0 & (byte) 7 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$4 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$4 ] ) always clobbers reg byte a -Statement [78] (byte~) renderBob::$5 ← (byte~) renderBob::$4 << (byte) 2 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$5 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$5 ] ) always clobbers reg byte a -Statement [79] (byte~) renderBob::$6 ← (byte) renderBob::xpos#0 & (byte) 3 [ renderBobCleanupNext#17 renderBob::screen#0 renderBob::$5 renderBob::$6 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::screen#0 renderBob::$5 renderBob::$6 ] ) always clobbers reg byte a -Statement [80] (byte) renderBob::bob_table_idx#0 ← (byte~) renderBob::$5 + (byte~) renderBob::$6 [ renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a -Statement [81] *((byte**) renderBobCleanupNext#17) ← (byte*) renderBob::screen#0 [ renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y -Statement [82] (byte**) renderBobCleanupNext#13 ← (byte**) renderBobCleanupNext#17 + (const byte) SIZEOF_POINTER [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a -Statement [83] *((byte*) renderBob::screen#0) ← *((const byte*) BOB_TABLES + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y -Statement [84] *((byte*) renderBob::screen#0 + (byte) $28) ← *((const byte*) BOB_TABLES+(byte) 1*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y -Statement [85] *((byte*) renderBob::screen#0 + (byte) $50) ← *((const byte*) BOB_TABLES+(byte) 2*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y -Statement [86] *((byte*) renderBob::screen#0 + (byte) 1) ← *((const byte*) BOB_TABLES+(byte) 3*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y -Statement [87] *((byte*) renderBob::screen#0 + (byte) $29) ← *((const byte*) BOB_TABLES+(byte) 4*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y -Statement [88] *((byte*) renderBob::screen#0 + (byte) $51) ← *((const byte*) BOB_TABLES+(byte) 5*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y -Statement [89] *((byte*) renderBob::screen#0 + (byte) 2) ← *((const byte*) BOB_TABLES+(byte) 6*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y -Statement [90] *((byte*) renderBob::screen#0 + (byte) $2a) ← *((const byte*) BOB_TABLES+(byte) 7*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y -Statement [91] *((byte*) renderBob::screen#0 + (byte) $52) ← *((const byte*) BOB_TABLES+(byte) 8*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 ] ( main:3::renderBob:42 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 ] ) always clobbers reg byte a reg byte y -Statement [98] (signed word) mulf8s::return#0 ← (signed word)(word) mulf8s_prepared::m#4 [ mulf8s::return#0 ] ( main:3::mulf8s:26 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::return#0 ] main:3::mulf8s:32 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::return#0 ] ) always clobbers reg byte a -Statement [102] (word) mulf8u_prepared::return#2 ← (word) mulf8u_prepared::return#0 [ mulf8s_prepared::b#0 mulf8u_prepared::return#2 ] ( main:3::mulf8s:26::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8u_prepared::return#2 ] main:3::mulf8s:32::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8u_prepared::return#2 ] ) always clobbers reg byte a -Statement [103] (word) mulf8s_prepared::m#0 ← (word) mulf8u_prepared::return#2 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ( main:3::mulf8s:26::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] main:3::mulf8s:32::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ) always clobbers reg byte a -Statement [104] if(*((const signed byte*) mulf8s_prepared::memA)>=(signed byte) 0) goto mulf8s_prepared::@1 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ( main:3::mulf8s:26::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] main:3::mulf8s:32::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ) always clobbers reg byte a -Statement [105] (byte~) mulf8s_prepared::$8 ← > (word) mulf8s_prepared::m#0 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$8 ] ( main:3::mulf8s:26::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$8 ] main:3::mulf8s:32::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$8 ] ) always clobbers reg byte a -Statement [106] (byte~) mulf8s_prepared::$15 ← (byte~) mulf8s_prepared::$8 - (byte)(signed byte) mulf8s_prepared::b#0 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$15 ] ( main:3::mulf8s:26::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$15 ] main:3::mulf8s:32::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$15 ] ) always clobbers reg byte a -Statement [110] (byte~) mulf8s_prepared::$12 ← > (word) mulf8s_prepared::m#5 [ mulf8s_prepared::m#5 mulf8s_prepared::$12 ] ( main:3::mulf8s:26::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::m#5 mulf8s_prepared::$12 ] main:3::mulf8s:32::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::m#5 mulf8s_prepared::$12 ] ) always clobbers reg byte a -Statement [111] (byte~) mulf8s_prepared::$16 ← (byte~) mulf8s_prepared::$12 - (byte)*((const signed byte*) mulf8s_prepared::memA) [ mulf8s_prepared::m#5 mulf8s_prepared::$16 ] ( main:3::mulf8s:26::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::m#5 mulf8s_prepared::$16 ] main:3::mulf8s:32::mulf8s_prepared:97 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::m#5 mulf8s_prepared::$16 ] ) always clobbers reg byte a +Statement [123] (byte~) renderBobCleanup::$1 ← (byte) renderBobCleanup::i#2 << (byte) 1 [ renderBobCleanup::i#2 renderBobCleanup::$1 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::$1 ] ) always clobbers reg byte a +Statement [124] (byte*) renderBobCleanup::screen#0 ← *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobCleanup::$1) [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a +Statement [125] *((byte*) renderBobCleanup::screen#0) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [126] *((byte*) renderBobCleanup::screen#0 + (byte) $28) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [127] *((byte*) renderBobCleanup::screen#0 + (byte) $50) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [128] *((byte*) renderBobCleanup::screen#0 + (byte) 1) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [129] *((byte*) renderBobCleanup::screen#0 + (byte) $29) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [130] *((byte*) renderBobCleanup::screen#0 + (byte) $51) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [131] *((byte*) renderBobCleanup::screen#0 + (byte) 2) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [132] *((byte*) renderBobCleanup::screen#0 + (byte) $2a) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [133] *((byte*) renderBobCleanup::screen#0 + (byte) $52) ← (byte) 0 [ renderBobCleanup::i#2 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 ] ) always clobbers reg byte a reg byte y +Statement [139] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 [ memset::dst#2 ] ( main:2::memset:15 [ memset::dst#2 ] ) always clobbers reg byte a +Statement [141] *((byte*) memset::dst#2) ← (const byte) memset::c#0 [ memset::dst#2 ] ( main:2::memset:15 [ memset::dst#2 ] ) always clobbers reg byte a reg byte y +Statement [145] (word~) renderBobInit::$0 ← (word)(byte) renderBobInit::y#2 [ renderBobInit::y#2 renderBobInit::$0 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 renderBobInit::$0 ] ) always clobbers reg byte a +Statement [146] (word~) renderBobInit::$6 ← (word~) renderBobInit::$0 << (byte) 2 [ renderBobInit::y#2 renderBobInit::$0 renderBobInit::$6 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 renderBobInit::$0 renderBobInit::$6 ] ) always clobbers reg byte a +Statement [147] (word~) renderBobInit::$7 ← (word~) renderBobInit::$6 + (word~) renderBobInit::$0 [ renderBobInit::y#2 renderBobInit::$7 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 renderBobInit::$7 ] ) always clobbers reg byte a +Statement [148] (word~) renderBobInit::$1 ← (word~) renderBobInit::$7 << (byte) 3 [ renderBobInit::y#2 renderBobInit::$1 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 renderBobInit::$1 ] ) always clobbers reg byte a +Statement [149] (byte~) renderBobInit::$4 ← (byte) renderBobInit::y#2 << (byte) 1 [ renderBobInit::y#2 renderBobInit::$1 renderBobInit::$4 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 renderBobInit::$1 renderBobInit::$4 ] ) always clobbers reg byte a +Statement [150] *((const word*) MUL40 + (byte~) renderBobInit::$4) ← (word~) renderBobInit::$1 [ renderBobInit::y#2 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 ] ) always clobbers reg byte a +Statement [154] (byte~) renderBobInit::$5 ← (byte) renderBobInit::i#2 << (byte) 1 [ renderBobInit::i#2 renderBobInit::$5 ] ( main:2::renderBobInit:9 [ renderBobInit::i#2 renderBobInit::$5 ] ) always clobbers reg byte a +Statement [155] *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobInit::$5) ← (const byte*) BOB_SCREEN [ renderBobInit::i#2 ] ( main:2::renderBobInit:9 [ renderBobInit::i#2 ] ) always clobbers reg byte a +Statement [171] (byte*) prepareBobs::bob_table#0 ← (const byte*) BOB_TABLES + (byte) prepareBobs::bob_table_idx#12 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::bob_table#0 ] ( main:2::prepareBobs:7 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::bob_table#0 ] ) always clobbers reg byte a +Statement [179] (byte*) bobCharsetFindOrAddGlyph::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bobCharsetFindOrAddGlyph::bob_glyph#1 ] ( main:2::prepareBobs:7 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bobCharsetFindOrAddGlyph::bob_glyph#1 ] ) always clobbers reg byte a +Statement [183] *((byte*) prepareBobs::bob_table#2) ← (byte~) prepareBobs::$6 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 ] ( main:2::prepareBobs:7 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 ] ) always clobbers reg byte y +Statement [184] (byte*) prepareBobs::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 + (byte) 8 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_table#2 prepareBobs::bob_glyph#1 ] ( main:2::prepareBobs:7 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_table#2 prepareBobs::bob_glyph#1 ] ) always clobbers reg byte a +Statement [185] (byte*) prepareBobs::bob_table#1 ← (byte*) prepareBobs::bob_table#2 + (const byte) BOB_SHIFTS_X*(const byte) BOB_SHIFTS_Y [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 ] ( main:2::prepareBobs:7 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 ] ) always clobbers reg byte a +Statement [190] *((byte*) progress_cursor#24) ← *((const byte*) progress_inc::progress_chars+(byte) 8) [ progress_cursor#24 ] ( main:2::prepareBobs:7::progress_inc:186 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 progress_cursor#24 ] ) always clobbers reg byte a reg byte y +Statement [193] *((byte*) progress_cursor#17) ← *((const byte*) progress_inc::progress_chars + (byte) progress_idx#10) [ progress_idx#10 progress_cursor#17 ] ( main:2::prepareBobs:7::progress_inc:186 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 progress_idx#10 progress_cursor#17 ] ) always clobbers reg byte a reg byte y +Statement [203] *((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) bobCharsetFindOrAddGlyph::i1#2) ← *((byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 + (byte) bobCharsetFindOrAddGlyph::i1#2) [ bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i1#2 ] ( main:2::prepareBobs:7::bobCharsetFindOrAddGlyph:162 [ bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i1#2 ] main:2::prepareBobs:7::bobCharsetFindOrAddGlyph:180 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i1#2 ] ) always clobbers reg byte a +Statement [207] if(*((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) bobCharsetFindOrAddGlyph::i#2)==*((byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 + (byte) bobCharsetFindOrAddGlyph::i#2)) goto bobCharsetFindOrAddGlyph::@4 [ bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i#2 ] ( main:2::prepareBobs:7::bobCharsetFindOrAddGlyph:162 [ bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i#2 ] main:2::prepareBobs:7::bobCharsetFindOrAddGlyph:180 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i#2 ] ) always clobbers reg byte a +Statement [211] (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#1 ← (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) 8 [ bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_id#1 bobCharsetFindOrAddGlyph::glyph_cursor#1 ] ( main:2::prepareBobs:7::bobCharsetFindOrAddGlyph:162 [ bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_id#1 bobCharsetFindOrAddGlyph::glyph_cursor#1 ] main:2::prepareBobs:7::bobCharsetFindOrAddGlyph:180 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_id#1 bobCharsetFindOrAddGlyph::glyph_cursor#1 ] ) always clobbers reg byte a +Statement [217] (byte~) shiftProtoBobRight::$1 ← *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) & (byte) 1 [ shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::$1 ] ( main:2::prepareBobs:7::shiftProtoBobRight:175 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::$1 ] main:2::prepareBobs:7::shiftProtoBobRight:177 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::$1 ] ) always clobbers reg byte a +Statement [221] (byte~) shiftProtoBobRight::$5 ← *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) >> (byte) 1 [ shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::$5 ] ( main:2::prepareBobs:7::shiftProtoBobRight:175 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::$5 ] main:2::prepareBobs:7::shiftProtoBobRight:177 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::$5 ] ) always clobbers reg byte a +Statement [225] (byte) shiftProtoBobRight::j#2 ← (byte) shiftProtoBobRight::j#3 + (byte) $18 [ shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#2 ] ( main:2::prepareBobs:7::shiftProtoBobRight:175 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#2 ] main:2::prepareBobs:7::shiftProtoBobRight:177 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#2 ] ) always clobbers reg byte a +Statement [229] (byte) shiftProtoBobRight::j#1 ← (byte) shiftProtoBobRight::j#3 - (byte) $2f [ shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#1 ] ( main:2::prepareBobs:7::shiftProtoBobRight:175 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#1 ] main:2::prepareBobs:7::shiftProtoBobRight:177 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#1 ] ) always clobbers reg byte a +Statement [233] *((const byte*) PROTO_BOB) ← (byte) 0 [ ] ( main:2::prepareBobs:7::shiftProtoBobDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 ] ) always clobbers reg byte a +Statement [234] *((const byte*) PROTO_BOB+(byte) $18) ← (byte) 0 [ ] ( main:2::prepareBobs:7::shiftProtoBobDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 ] ) always clobbers reg byte a +Statement [235] *((const byte*) PROTO_BOB+(byte) $30) ← (byte) 0 [ ] ( main:2::prepareBobs:7::shiftProtoBobDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 ] ) always clobbers reg byte a +Statement [237] *((const byte*) PROTO_BOB + (byte) shiftProtoBobDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $17 + (byte) shiftProtoBobDown::i#2) [ shiftProtoBobDown::i#2 ] ( main:2::prepareBobs:7::shiftProtoBobDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 shiftProtoBobDown::i#2 ] ) always clobbers reg byte a +Statement [238] *((const byte*) PROTO_BOB+(byte) $18 + (byte) shiftProtoBobDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $2f + (byte) shiftProtoBobDown::i#2) [ shiftProtoBobDown::i#2 ] ( main:2::prepareBobs:7::shiftProtoBobDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 shiftProtoBobDown::i#2 ] ) always clobbers reg byte a +Statement [239] *((const byte*) PROTO_BOB+(byte) $30 + (byte) shiftProtoBobDown::i#2) ← (byte) 0 [ shiftProtoBobDown::i#2 ] ( main:2::prepareBobs:7::shiftProtoBobDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 shiftProtoBobDown::i#2 ] ) always clobbers reg byte a +Statement [245] if((byte*) mulf_init::sqr1_lo#2!=(const byte*) mulf_sqr1_lo+(word) $200) goto mulf_init::@2 [ mulf_init::sqr1_lo#2 mulf_init::c#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::c#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 ] ) always clobbers reg byte a +Statement [247] if((byte*) mulf_init::sqr2_lo#2!=(const byte*) mulf_sqr2_lo+(word) $1ff) goto mulf_init::@6 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ( main:2::mulf_init:5 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ) always clobbers reg byte a +Statement [248] *((const byte*) mulf_sqr2_lo+(word) $1ff) ← *((const byte*) mulf_sqr1_lo+(word) $100) [ ] ( main:2::mulf_init:5 [ ] ) always clobbers reg byte a +Statement [249] *((const byte*) mulf_sqr2_hi+(word) $1ff) ← *((const byte*) mulf_sqr1_hi+(word) $100) [ ] ( main:2::mulf_init:5 [ ] ) always clobbers reg byte a +Statement [251] *((byte*) mulf_init::sqr2_lo#2) ← *((const byte*) mulf_sqr1_lo + (byte) mulf_init::x_255#2) [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ( main:2::mulf_init:5 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ) always clobbers reg byte a reg byte y +Statement [252] *((byte*) mulf_init::sqr2_hi#2) ← *((const byte*) mulf_sqr1_hi + (byte) mulf_init::x_255#2) [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ( main:2::mulf_init:5 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ) always clobbers reg byte a reg byte y +Statement [254] (byte) mulf_init::x_255#1 ← (byte) mulf_init::x_255#2 + (byte) mulf_init::dir#2 [ mulf_init::sqr2_lo#2 mulf_init::dir#2 mulf_init::x_255#1 mulf_init::sqr2_hi#1 ] ( main:2::mulf_init:5 [ mulf_init::sqr2_lo#2 mulf_init::dir#2 mulf_init::x_255#1 mulf_init::sqr2_hi#1 ] ) always clobbers reg byte a +Statement [260] (byte~) mulf_init::$1 ← (byte) mulf_init::c#1 & (byte) 1 [ mulf_init::sqr1_lo#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 mulf_init::c#1 mulf_init::$1 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 mulf_init::c#1 mulf_init::$1 ] ) always clobbers reg byte a +Statement [265] (byte~) mulf_init::$4 ← < (word) mulf_init::sqr#3 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$4 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$4 ] ) always clobbers reg byte a +Statement [266] *((byte*) mulf_init::sqr1_lo#2) ← (byte~) mulf_init::$4 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ) always clobbers reg byte y +Statement [267] (byte~) mulf_init::$5 ← > (word) mulf_init::sqr#3 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$5 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$5 ] ) always clobbers reg byte a +Statement [268] *((byte*) mulf_init::sqr1_hi#2) ← (byte~) mulf_init::$5 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ) always clobbers reg byte y +Statement [270] (word) mulf_init::sqr#1 ← (word) mulf_init::sqr#3 + (byte) mulf_init::x_2#2 [ mulf_init::sqr1_lo#2 mulf_init::c#1 mulf_init::sqr#1 mulf_init::sqr1_hi#1 mulf_init::x_2#2 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::c#1 mulf_init::sqr#1 mulf_init::sqr1_hi#1 mulf_init::x_2#2 ] ) always clobbers reg byte a +Statement [10] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [12] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank1_toDd001_return#0 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [14] *((const byte*) D018) ← (const byte) main::toD0181_return#0 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [17] if(*((const byte*) RASTER)<(byte) $f8) goto main::@2 [ main::angle#8 ] ( main:2 [ main::angle#8 ] ) always clobbers reg byte a +Statement [18] *((const byte*) BORDERCOL) ← (byte) $f [ main::angle#8 ] ( main:2 [ main::angle#8 ] ) always clobbers reg byte a +Statement [20] (byte) main::a#6 ← (byte) main::angle#8 [ main::angle#8 main::a#6 ] ( main:2 [ main::angle#8 main::a#6 ] ) always clobbers reg byte a +Statement [22] *((const byte*) BORDERCOL) ← (byte) 1 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 ] ) always clobbers reg byte a +Statement [24] (signed byte) mulf8s::b#0 ← *((const signed byte*) COS + (byte) main::a#2) [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::a#0 mulf8s::b#0 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::a#0 mulf8s::b#0 ] ) always clobbers reg byte y +Statement [26] (signed word) mulf8s::return#2 ← (signed word) mulf8s::return#0 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::return#2 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::return#2 ] ) always clobbers reg byte a +Statement [27] (signed word~) main::$10 ← (signed word) mulf8s::return#2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::$10 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::$10 ] ) always clobbers reg byte a +Statement [28] (signed word) main::x#0 ← (signed word~) main::$10 + (signed word)(number) $4b*(number) $100 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 ] ) always clobbers reg byte a +Statement [30] (signed byte) mulf8s::b#1 ← *((const signed byte*) SIN + (byte) main::a#2) [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::a#1 mulf8s::b#1 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::a#1 mulf8s::b#1 ] ) always clobbers reg byte y +Statement [32] (signed word) mulf8s::return#3 ← (signed word) mulf8s::return#0 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::return#3 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::return#3 ] ) always clobbers reg byte a +Statement [33] (signed word~) main::$12 ← (signed word) mulf8s::return#3 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$12 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$12 ] ) always clobbers reg byte a +Statement [34] (signed word~) main::$13 ← (signed word~) main::$12 << (byte) 1 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$13 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::$13 ] ) always clobbers reg byte a +Statement [35] (signed word) main::y#0 ← (signed word~) main::$13 + (signed word)(number) $5a*(number) $100 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ) always clobbers reg byte a +Statement [36] *((const byte*) BORDERCOL) ← (byte) 2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ( main:2 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 main::y#0 ] ) always clobbers reg byte a +Statement [37] (byte) main::a#1 ← (byte) main::a#2 + (byte) $62 [ main::angle#8 main::r#2 renderBobCleanupNext#17 main::i#2 main::a#1 main::x#0 main::y#0 ] ( main:2 [ main::angle#8 main::r#2 renderBobCleanupNext#17 main::i#2 main::a#1 main::x#0 main::y#0 ] ) always clobbers reg byte a reg byte x +Statement [38] (signed byte) main::r#1 ← (signed byte) main::r#2 + (signed byte) 3 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::x#0 main::y#0 ] ( main:2 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::x#0 main::y#0 ] ) always clobbers reg byte a reg byte x +Statement [39] (byte) renderBob::xpos#0 ← > (signed word) main::x#0 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::y#0 renderBob::xpos#0 ] ( main:2 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 main::y#0 renderBob::xpos#0 ] ) always clobbers reg byte a +Statement [40] (byte) renderBob::ypos#0 ← > (signed word) main::y#0 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 renderBob::xpos#0 renderBob::ypos#0 ] ( main:2 [ main::angle#8 renderBobCleanupNext#17 main::i#2 main::r#1 main::a#1 renderBob::xpos#0 renderBob::ypos#0 ] ) always clobbers reg byte a +Statement [43] if((byte) main::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto main::@4 [ main::angle#8 main::r#1 main::a#1 renderBobCleanupNext#13 main::i#1 ] ( main:2 [ main::angle#8 main::r#1 main::a#1 renderBobCleanupNext#13 main::i#1 ] ) always clobbers reg byte a +Statement [44] (byte) main::angle#1 ← (byte) main::angle#8 + (byte) 3 [ main::angle#1 ] ( main:2 [ main::angle#1 ] ) always clobbers reg byte a reg byte x +Statement [45] *((const byte*) BORDERCOL) ← (byte) 0 [ main::angle#1 ] ( main:2 [ main::angle#1 ] ) always clobbers reg byte a +Statement [55] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [57] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank2_toDd001_return#0 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [59] *((const byte*) D018) ← (const byte) main::toD0182_return#0 [ ] ( main:2 [ ] ) always clobbers reg byte a +Statement [67] *((const byte*) CIA1_PORT_A) ← *((const byte*) keyboard_matrix_row_bitmask+(const byte) keyboard_key_pressed::rowidx#0) [ ] ( main:2::keyboard_key_pressed:46::keyboard_matrix_read:62 [ main::angle#1 ] main:2::keyboard_key_pressed:51::keyboard_matrix_read:62 [ ] ) always clobbers reg byte a +Statement [68] (byte) keyboard_matrix_read::return#0 ← ~ *((const byte*) CIA1_PORT_B) [ keyboard_matrix_read::return#0 ] ( main:2::keyboard_key_pressed:46::keyboard_matrix_read:62 [ main::angle#1 keyboard_matrix_read::return#0 ] main:2::keyboard_key_pressed:51::keyboard_matrix_read:62 [ keyboard_matrix_read::return#0 ] ) always clobbers reg byte a +Statement [70] (byte) renderBob::x_char_offset#0 ← (byte) renderBob::xpos#0 >> (byte) 2 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 ] ) always clobbers reg byte a +Statement [71] (byte) renderBob::y_char_offset#0 ← (byte) renderBob::ypos#0 >> (byte) 3 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_char_offset#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_char_offset#0 ] ) always clobbers reg byte a +Statement [72] (byte~) renderBob::$8 ← (byte) renderBob::y_char_offset#0 << (byte) 1 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$8 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$8 ] ) always clobbers reg byte a +Statement [73] (word) renderBob::y_offset#0 ← *((const word*) MUL40 + (byte~) renderBob::$8) [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_offset#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::y_offset#0 ] ) always clobbers reg byte a +Statement [74] (byte*~) renderBob::$2 ← (const byte*) BOB_SCREEN + (word) renderBob::y_offset#0 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$2 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::x_char_offset#0 renderBob::$2 ] ) always clobbers reg byte a +Statement [75] (byte*) renderBob::screen#0 ← (byte*~) renderBob::$2 + (byte) renderBob::x_char_offset#0 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::screen#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::ypos#0 renderBob::screen#0 ] ) always clobbers reg byte a +Statement [76] (byte~) renderBob::$4 ← (byte) renderBob::ypos#0 & (byte) 7 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$4 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$4 ] ) always clobbers reg byte a +Statement [77] (byte~) renderBob::$5 ← (byte~) renderBob::$4 << (byte) 2 [ renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$5 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::xpos#0 renderBob::screen#0 renderBob::$5 ] ) always clobbers reg byte a +Statement [78] (byte~) renderBob::$6 ← (byte) renderBob::xpos#0 & (byte) 3 [ renderBobCleanupNext#17 renderBob::screen#0 renderBob::$5 renderBob::$6 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::screen#0 renderBob::$5 renderBob::$6 ] ) always clobbers reg byte a +Statement [79] (byte) renderBob::bob_table_idx#0 ← (byte~) renderBob::$5 + (byte~) renderBob::$6 [ renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a +Statement [80] *((byte**) renderBobCleanupNext#17) ← (byte*) renderBob::screen#0 [ renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#17 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [81] (byte**) renderBobCleanupNext#13 ← (byte**) renderBobCleanupNext#17 + (const byte) SIZEOF_POINTER [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a +Statement [82] *((byte*) renderBob::screen#0) ← *((const byte*) BOB_TABLES + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [83] *((byte*) renderBob::screen#0 + (byte) $28) ← *((const byte*) BOB_TABLES+(byte) 1*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [84] *((byte*) renderBob::screen#0 + (byte) $50) ← *((const byte*) BOB_TABLES+(byte) 2*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [85] *((byte*) renderBob::screen#0 + (byte) 1) ← *((const byte*) BOB_TABLES+(byte) 3*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [86] *((byte*) renderBob::screen#0 + (byte) $29) ← *((const byte*) BOB_TABLES+(byte) 4*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [87] *((byte*) renderBob::screen#0 + (byte) $51) ← *((const byte*) BOB_TABLES+(byte) 5*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [88] *((byte*) renderBob::screen#0 + (byte) 2) ← *((const byte*) BOB_TABLES+(byte) 6*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [89] *((byte*) renderBob::screen#0 + (byte) $2a) ← *((const byte*) BOB_TABLES+(byte) 7*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 renderBob::screen#0 renderBob::bob_table_idx#0 ] ) always clobbers reg byte a reg byte y +Statement [90] *((byte*) renderBob::screen#0 + (byte) $52) ← *((const byte*) BOB_TABLES+(byte) 8*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) [ renderBobCleanupNext#13 ] ( main:2::renderBob:41 [ main::angle#8 main::i#2 main::r#1 main::a#1 renderBobCleanupNext#13 ] ) always clobbers reg byte a reg byte y +Statement [97] (signed word) mulf8s::return#0 ← (signed word)(word) mulf8s_prepared::m#4 [ mulf8s::return#0 ] ( main:2::mulf8s:25 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s::return#0 ] main:2::mulf8s:31 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s::return#0 ] ) always clobbers reg byte a +Statement [101] (word) mulf8u_prepared::return#2 ← (word) mulf8u_prepared::return#0 [ mulf8s_prepared::b#0 mulf8u_prepared::return#2 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8u_prepared::return#2 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8u_prepared::return#2 ] ) always clobbers reg byte a +Statement [102] (word) mulf8s_prepared::m#0 ← (word) mulf8u_prepared::return#2 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ) always clobbers reg byte a +Statement [103] if(*((const signed byte*) mulf8s_prepared::memA)>=(signed byte) 0) goto mulf8s_prepared::@1 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 ] ) always clobbers reg byte a +Statement [104] (byte~) mulf8s_prepared::$8 ← > (word) mulf8s_prepared::m#0 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$8 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$8 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$8 ] ) always clobbers reg byte a +Statement [105] (byte~) mulf8s_prepared::$15 ← (byte~) mulf8s_prepared::$8 - (byte)(signed byte) mulf8s_prepared::b#0 [ mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$15 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$15 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8s_prepared::m#0 mulf8s_prepared::$15 ] ) always clobbers reg byte a +Statement [109] (byte~) mulf8s_prepared::$12 ← > (word) mulf8s_prepared::m#5 [ mulf8s_prepared::m#5 mulf8s_prepared::$12 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::m#5 mulf8s_prepared::$12 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::m#5 mulf8s_prepared::$12 ] ) always clobbers reg byte a +Statement [110] (byte~) mulf8s_prepared::$16 ← (byte~) mulf8s_prepared::$12 - (byte)*((const signed byte*) mulf8s_prepared::memA) [ mulf8s_prepared::m#5 mulf8s_prepared::$16 ] ( main:2::mulf8s:25::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::m#5 mulf8s_prepared::$16 ] main:2::mulf8s:31::mulf8s_prepared:96 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::m#5 mulf8s_prepared::$16 ] ) always clobbers reg byte a Statement asm { ldxmemB sec sm1: ldamulf_sqr1_lo,x sm2: sbcmulf_sqr2_lo,x staresL sm3: ldamulf_sqr1_hi,x sm4: sbcmulf_sqr2_hi,x stamemB } always clobbers reg byte a reg byte x -Statement [117] (word) mulf8u_prepared::return#0 ← *((const byte*) mulf8u_prepared::memB) w= *((const byte*) mulf8u_prepared::resL) [ mulf8u_prepared::return#0 ] ( main:3::mulf8s:26::mulf8s_prepared:97::mulf8u_prepared:101 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8u_prepared::return#0 ] main:3::mulf8s:32::mulf8s_prepared:97::mulf8u_prepared:101 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8u_prepared::return#0 ] ) always clobbers reg byte a +Statement [116] (word) mulf8u_prepared::return#0 ← *((const byte*) mulf8u_prepared::memB) w= *((const byte*) mulf8u_prepared::resL) [ mulf8u_prepared::return#0 ] ( main:2::mulf8s:25::mulf8s_prepared:96::mulf8u_prepared:100 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 mulf8s_prepared::b#0 mulf8u_prepared::return#0 ] main:2::mulf8s:31::mulf8s_prepared:96::mulf8u_prepared:100 [ main::angle#8 main::r#2 main::a#2 renderBobCleanupNext#17 main::i#2 main::x#0 mulf8s_prepared::b#0 mulf8u_prepared::return#0 ] ) always clobbers reg byte a Statement asm { ldamemA stamulf8u_prepared.sm1+1 stamulf8u_prepared.sm3+1 eor#$ff stamulf8u_prepared.sm2+1 stamulf8u_prepared.sm4+1 } always clobbers reg byte a -Statement [124] (byte~) renderBobCleanup::$1 ← (byte) renderBobCleanup::i#2 << (byte) 1 [ renderBobCleanup::i#2 renderBobCleanup::$1 ] ( main:3::renderBobCleanup:20 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::$1 ] ) always clobbers reg byte a -Statement [125] (byte*) renderBobCleanup::screen#0 ← *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobCleanup::$1) [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:3::renderBobCleanup:20 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a -Statement [126] *((byte*) renderBobCleanup::screen#0) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:3::renderBobCleanup:20 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y -Statement [127] *((byte*) renderBobCleanup::screen#0 + (byte) $28) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:3::renderBobCleanup:20 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y -Statement [128] *((byte*) renderBobCleanup::screen#0 + (byte) $50) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:3::renderBobCleanup:20 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y -Statement [129] *((byte*) renderBobCleanup::screen#0 + (byte) 1) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:3::renderBobCleanup:20 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y -Statement [130] *((byte*) renderBobCleanup::screen#0 + (byte) $29) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:3::renderBobCleanup:20 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y -Statement [131] *((byte*) renderBobCleanup::screen#0 + (byte) $51) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:3::renderBobCleanup:20 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y -Statement [132] *((byte*) renderBobCleanup::screen#0 + (byte) 2) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:3::renderBobCleanup:20 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y -Statement [133] *((byte*) renderBobCleanup::screen#0 + (byte) $2a) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:3::renderBobCleanup:20 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y -Statement [134] *((byte*) renderBobCleanup::screen#0 + (byte) $52) ← (byte) 0 [ renderBobCleanup::i#2 ] ( main:3::renderBobCleanup:20 [ main::angle#8 renderBobCleanup::i#2 ] ) always clobbers reg byte a reg byte y -Statement [140] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 [ memset::dst#2 ] ( main:3::memset:16 [ memset::dst#2 ] ) always clobbers reg byte a -Statement [142] *((byte*) memset::dst#2) ← (const byte) memset::c#0 [ memset::dst#2 ] ( main:3::memset:16 [ memset::dst#2 ] ) always clobbers reg byte a reg byte y -Statement [146] (word~) renderBobInit::$0 ← (word)(byte) renderBobInit::y#2 [ renderBobInit::y#2 renderBobInit::$0 ] ( main:3::renderBobInit:10 [ renderBobInit::y#2 renderBobInit::$0 ] ) always clobbers reg byte a -Statement [147] (word~) renderBobInit::$6 ← (word~) renderBobInit::$0 << (byte) 2 [ renderBobInit::y#2 renderBobInit::$0 renderBobInit::$6 ] ( main:3::renderBobInit:10 [ renderBobInit::y#2 renderBobInit::$0 renderBobInit::$6 ] ) always clobbers reg byte a -Statement [148] (word~) renderBobInit::$7 ← (word~) renderBobInit::$6 + (word~) renderBobInit::$0 [ renderBobInit::y#2 renderBobInit::$7 ] ( main:3::renderBobInit:10 [ renderBobInit::y#2 renderBobInit::$7 ] ) always clobbers reg byte a -Statement [149] (word~) renderBobInit::$1 ← (word~) renderBobInit::$7 << (byte) 3 [ renderBobInit::y#2 renderBobInit::$1 ] ( main:3::renderBobInit:10 [ renderBobInit::y#2 renderBobInit::$1 ] ) always clobbers reg byte a -Statement [150] (byte~) renderBobInit::$4 ← (byte) renderBobInit::y#2 << (byte) 1 [ renderBobInit::y#2 renderBobInit::$1 renderBobInit::$4 ] ( main:3::renderBobInit:10 [ renderBobInit::y#2 renderBobInit::$1 renderBobInit::$4 ] ) always clobbers reg byte a -Statement [151] *((const word*) MUL40 + (byte~) renderBobInit::$4) ← (word~) renderBobInit::$1 [ renderBobInit::y#2 ] ( main:3::renderBobInit:10 [ renderBobInit::y#2 ] ) always clobbers reg byte a -Statement [155] (byte~) renderBobInit::$5 ← (byte) renderBobInit::i#2 << (byte) 1 [ renderBobInit::i#2 renderBobInit::$5 ] ( main:3::renderBobInit:10 [ renderBobInit::i#2 renderBobInit::$5 ] ) always clobbers reg byte a -Statement [156] *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobInit::$5) ← (const byte*) BOB_SCREEN [ renderBobInit::i#2 ] ( main:3::renderBobInit:10 [ renderBobInit::i#2 ] ) always clobbers reg byte a -Statement [165] if((byte) prepareBobs::shift_y#2<(const byte) BOB_SHIFTS_Y) goto prepareBobs::@2 [ prepareBobs::shift_y#2 progress_cursor#15 progress_idx#16 bob_charset_next_id#14 prepareBobs::bob_table_idx#6 ] ( main:3::prepareBobs:8 [ prepareBobs::shift_y#2 progress_cursor#15 progress_idx#16 bob_charset_next_id#14 prepareBobs::bob_table_idx#6 ] ) always clobbers reg byte a -Statement [168] if((byte) prepareBobs::shift_x#2<(const byte) BOB_SHIFTS_X) goto prepareBobs::@3 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 ] ( main:3::prepareBobs:8 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 ] ) always clobbers reg byte a -Statement [172] (byte*) prepareBobs::bob_table#0 ← (const byte*) BOB_TABLES + (byte) prepareBobs::bob_table_idx#12 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::bob_table#0 ] ( main:3::prepareBobs:8 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::bob_table#0 ] ) always clobbers reg byte a -Statement [174] if((byte) prepareBobs::cell#2<(byte) 9) goto prepareBobs::@6 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 ] ( main:3::prepareBobs:8 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 ] ) always clobbers reg byte a -Statement [180] (byte*) bobCharsetFindOrAddGlyph::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bobCharsetFindOrAddGlyph::bob_glyph#1 ] ( main:3::prepareBobs:8 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bobCharsetFindOrAddGlyph::bob_glyph#1 ] ) always clobbers reg byte a -Statement [184] *((byte*) prepareBobs::bob_table#2) ← (byte~) prepareBobs::$6 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 ] ( main:3::prepareBobs:8 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 ] ) always clobbers reg byte y -Statement [185] (byte*) prepareBobs::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 + (byte) 8 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_table#2 prepareBobs::bob_glyph#1 ] ( main:3::prepareBobs:8 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_table#2 prepareBobs::bob_glyph#1 ] ) always clobbers reg byte a -Statement [186] (byte*) prepareBobs::bob_table#1 ← (byte*) prepareBobs::bob_table#2 + (const byte) BOB_SHIFTS_X*(const byte) BOB_SHIFTS_Y [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 ] ( main:3::prepareBobs:8 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 ] ) always clobbers reg byte a -Statement [190] if((byte) progress_idx#8!=(byte) 8) goto progress_inc::@1 [ progress_cursor#24 progress_idx#8 ] ( main:3::prepareBobs:8::progress_inc:187 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 progress_cursor#24 progress_idx#8 ] ) always clobbers reg byte a -Statement [191] *((byte*) progress_cursor#24) ← *((const byte*) progress_inc::progress_chars+(byte) 8) [ progress_cursor#24 ] ( main:3::prepareBobs:8::progress_inc:187 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 progress_cursor#24 ] ) always clobbers reg byte a reg byte y -Statement [194] *((byte*) progress_cursor#17) ← *((const byte*) progress_inc::progress_chars + (byte) progress_idx#10) [ progress_idx#10 progress_cursor#17 ] ( main:3::prepareBobs:8::progress_inc:187 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 progress_idx#10 progress_cursor#17 ] ) always clobbers reg byte a reg byte y -Statement [198] if((byte) bobCharsetFindOrAddGlyph::glyph_id#11!=(byte) bob_charset_next_id#23) goto bobCharsetFindOrAddGlyph::@2 [ bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 ] ( main:3::prepareBobs:8::bobCharsetFindOrAddGlyph:163 [ bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 ] main:3::prepareBobs:8::bobCharsetFindOrAddGlyph:181 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 ] ) always clobbers reg byte a -Statement [204] *((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) bobCharsetFindOrAddGlyph::i1#2) ← *((byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 + (byte) bobCharsetFindOrAddGlyph::i1#2) [ bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i1#2 ] ( main:3::prepareBobs:8::bobCharsetFindOrAddGlyph:163 [ bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i1#2 ] main:3::prepareBobs:8::bobCharsetFindOrAddGlyph:181 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i1#2 ] ) always clobbers reg byte a -Statement [207] if((byte) bobCharsetFindOrAddGlyph::i#2<(byte) 8) goto bobCharsetFindOrAddGlyph::@3 [ bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i#2 ] ( main:3::prepareBobs:8::bobCharsetFindOrAddGlyph:163 [ bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i#2 ] main:3::prepareBobs:8::bobCharsetFindOrAddGlyph:181 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i#2 ] ) always clobbers reg byte a -Statement [208] if(*((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) bobCharsetFindOrAddGlyph::i#2)==*((byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 + (byte) bobCharsetFindOrAddGlyph::i#2)) goto bobCharsetFindOrAddGlyph::@4 [ bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i#2 ] ( main:3::prepareBobs:8::bobCharsetFindOrAddGlyph:163 [ bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i#2 ] main:3::prepareBobs:8::bobCharsetFindOrAddGlyph:181 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i#2 ] ) always clobbers reg byte a reg byte x reg byte y -Statement [212] (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#1 ← (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) 8 [ bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_id#1 bobCharsetFindOrAddGlyph::glyph_cursor#1 ] ( main:3::prepareBobs:8::bobCharsetFindOrAddGlyph:163 [ bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_id#1 bobCharsetFindOrAddGlyph::glyph_cursor#1 ] main:3::prepareBobs:8::bobCharsetFindOrAddGlyph:181 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_id#1 bobCharsetFindOrAddGlyph::glyph_cursor#1 ] ) always clobbers reg byte a -Statement [218] (byte~) shiftProtoBobRight::$1 ← *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) & (byte) 1 [ shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::$1 ] ( main:3::prepareBobs:8::shiftProtoBobRight:176 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::$1 ] main:3::prepareBobs:8::shiftProtoBobRight:178 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::$1 ] ) always clobbers reg byte a -Statement [222] (byte~) shiftProtoBobRight::$5 ← *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) >> (byte) 1 [ shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::$5 ] ( main:3::prepareBobs:8::shiftProtoBobRight:176 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::$5 ] main:3::prepareBobs:8::shiftProtoBobRight:178 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::$5 ] ) always clobbers reg byte a -Statement [226] (byte) shiftProtoBobRight::j#2 ← (byte) shiftProtoBobRight::j#3 + (byte) $18 [ shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#2 ] ( main:3::prepareBobs:8::shiftProtoBobRight:176 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#2 ] main:3::prepareBobs:8::shiftProtoBobRight:178 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#2 ] ) always clobbers reg byte a -Statement [230] (byte) shiftProtoBobRight::j#1 ← (byte) shiftProtoBobRight::j#3 - (byte) $2f [ shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#1 ] ( main:3::prepareBobs:8::shiftProtoBobRight:176 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#1 ] main:3::prepareBobs:8::shiftProtoBobRight:178 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#1 ] ) always clobbers reg byte a -Statement [234] *((const byte*) PROTO_BOB) ← (byte) 0 [ ] ( main:3::prepareBobs:8::shiftProtoBobDown:170 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 ] ) always clobbers reg byte a -Statement [235] *((const byte*) PROTO_BOB+(byte) $18) ← (byte) 0 [ ] ( main:3::prepareBobs:8::shiftProtoBobDown:170 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 ] ) always clobbers reg byte a -Statement [236] *((const byte*) PROTO_BOB+(byte) $30) ← (byte) 0 [ ] ( main:3::prepareBobs:8::shiftProtoBobDown:170 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 ] ) always clobbers reg byte a -Statement [238] *((const byte*) PROTO_BOB + (byte) shiftProtoBobDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $17 + (byte) shiftProtoBobDown::i#2) [ shiftProtoBobDown::i#2 ] ( main:3::prepareBobs:8::shiftProtoBobDown:170 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 shiftProtoBobDown::i#2 ] ) always clobbers reg byte a -Statement [239] *((const byte*) PROTO_BOB+(byte) $18 + (byte) shiftProtoBobDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $2f + (byte) shiftProtoBobDown::i#2) [ shiftProtoBobDown::i#2 ] ( main:3::prepareBobs:8::shiftProtoBobDown:170 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 shiftProtoBobDown::i#2 ] ) always clobbers reg byte a -Statement [240] *((const byte*) PROTO_BOB+(byte) $30 + (byte) shiftProtoBobDown::i#2) ← (byte) 0 [ shiftProtoBobDown::i#2 ] ( main:3::prepareBobs:8::shiftProtoBobDown:170 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 shiftProtoBobDown::i#2 ] ) always clobbers reg byte a -Statement [246] if((byte*) mulf_init::sqr1_lo#2!=(const byte*) mulf_sqr1_lo+(word) $200) goto mulf_init::@2 [ mulf_init::sqr1_lo#2 mulf_init::c#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 ] ( main:3::mulf_init:6 [ mulf_init::sqr1_lo#2 mulf_init::c#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 ] ) always clobbers reg byte a -Statement [248] if((byte*) mulf_init::sqr2_lo#2!=(const byte*) mulf_sqr2_lo+(word) $1ff) goto mulf_init::@6 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ( main:3::mulf_init:6 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ) always clobbers reg byte a -Statement [249] *((const byte*) mulf_sqr2_lo+(word) $1ff) ← *((const byte*) mulf_sqr1_lo+(word) $100) [ ] ( main:3::mulf_init:6 [ ] ) always clobbers reg byte a -Statement [250] *((const byte*) mulf_sqr2_hi+(word) $1ff) ← *((const byte*) mulf_sqr1_hi+(word) $100) [ ] ( main:3::mulf_init:6 [ ] ) always clobbers reg byte a -Statement [252] *((byte*) mulf_init::sqr2_lo#2) ← *((const byte*) mulf_sqr1_lo + (byte) mulf_init::x_255#2) [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ( main:3::mulf_init:6 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ) always clobbers reg byte a reg byte y -Statement [253] *((byte*) mulf_init::sqr2_hi#2) ← *((const byte*) mulf_sqr1_hi + (byte) mulf_init::x_255#2) [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ( main:3::mulf_init:6 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ) always clobbers reg byte a reg byte y -Statement [255] (byte) mulf_init::x_255#1 ← (byte) mulf_init::x_255#2 + (byte) mulf_init::dir#2 [ mulf_init::sqr2_lo#2 mulf_init::dir#2 mulf_init::x_255#1 mulf_init::sqr2_hi#1 ] ( main:3::mulf_init:6 [ mulf_init::sqr2_lo#2 mulf_init::dir#2 mulf_init::x_255#1 mulf_init::sqr2_hi#1 ] ) always clobbers reg byte a -Statement [261] (byte~) mulf_init::$1 ← (byte) mulf_init::c#1 & (byte) 1 [ mulf_init::sqr1_lo#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 mulf_init::c#1 mulf_init::$1 ] ( main:3::mulf_init:6 [ mulf_init::sqr1_lo#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 mulf_init::c#1 mulf_init::$1 ] ) always clobbers reg byte a -Statement [266] (byte~) mulf_init::$4 ← < (word) mulf_init::sqr#3 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$4 ] ( main:3::mulf_init:6 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$4 ] ) always clobbers reg byte a -Statement [267] *((byte*) mulf_init::sqr1_lo#2) ← (byte~) mulf_init::$4 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ( main:3::mulf_init:6 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ) always clobbers reg byte y -Statement [268] (byte~) mulf_init::$5 ← > (word) mulf_init::sqr#3 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$5 ] ( main:3::mulf_init:6 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$5 ] ) always clobbers reg byte a -Statement [269] *((byte*) mulf_init::sqr1_hi#2) ← (byte~) mulf_init::$5 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ( main:3::mulf_init:6 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ) always clobbers reg byte y -Statement [271] (word) mulf_init::sqr#1 ← (word) mulf_init::sqr#3 + (byte) mulf_init::x_2#2 [ mulf_init::sqr1_lo#2 mulf_init::c#1 mulf_init::sqr#1 mulf_init::sqr1_hi#1 mulf_init::x_2#2 ] ( main:3::mulf_init:6 [ mulf_init::sqr1_lo#2 mulf_init::c#1 mulf_init::sqr#1 mulf_init::sqr1_hi#1 mulf_init::x_2#2 ] ) always clobbers reg byte a +Statement [123] (byte~) renderBobCleanup::$1 ← (byte) renderBobCleanup::i#2 << (byte) 1 [ renderBobCleanup::i#2 renderBobCleanup::$1 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::$1 ] ) always clobbers reg byte a +Statement [124] (byte*) renderBobCleanup::screen#0 ← *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobCleanup::$1) [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a +Statement [125] *((byte*) renderBobCleanup::screen#0) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [126] *((byte*) renderBobCleanup::screen#0 + (byte) $28) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [127] *((byte*) renderBobCleanup::screen#0 + (byte) $50) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [128] *((byte*) renderBobCleanup::screen#0 + (byte) 1) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [129] *((byte*) renderBobCleanup::screen#0 + (byte) $29) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [130] *((byte*) renderBobCleanup::screen#0 + (byte) $51) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [131] *((byte*) renderBobCleanup::screen#0 + (byte) 2) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [132] *((byte*) renderBobCleanup::screen#0 + (byte) $2a) ← (byte) 0 [ renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 renderBobCleanup::screen#0 ] ) always clobbers reg byte a reg byte y +Statement [133] *((byte*) renderBobCleanup::screen#0 + (byte) $52) ← (byte) 0 [ renderBobCleanup::i#2 ] ( main:2::renderBobCleanup:19 [ main::angle#8 renderBobCleanup::i#2 ] ) always clobbers reg byte a reg byte y +Statement [139] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 [ memset::dst#2 ] ( main:2::memset:15 [ memset::dst#2 ] ) always clobbers reg byte a +Statement [141] *((byte*) memset::dst#2) ← (const byte) memset::c#0 [ memset::dst#2 ] ( main:2::memset:15 [ memset::dst#2 ] ) always clobbers reg byte a reg byte y +Statement [145] (word~) renderBobInit::$0 ← (word)(byte) renderBobInit::y#2 [ renderBobInit::y#2 renderBobInit::$0 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 renderBobInit::$0 ] ) always clobbers reg byte a +Statement [146] (word~) renderBobInit::$6 ← (word~) renderBobInit::$0 << (byte) 2 [ renderBobInit::y#2 renderBobInit::$0 renderBobInit::$6 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 renderBobInit::$0 renderBobInit::$6 ] ) always clobbers reg byte a +Statement [147] (word~) renderBobInit::$7 ← (word~) renderBobInit::$6 + (word~) renderBobInit::$0 [ renderBobInit::y#2 renderBobInit::$7 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 renderBobInit::$7 ] ) always clobbers reg byte a +Statement [148] (word~) renderBobInit::$1 ← (word~) renderBobInit::$7 << (byte) 3 [ renderBobInit::y#2 renderBobInit::$1 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 renderBobInit::$1 ] ) always clobbers reg byte a +Statement [149] (byte~) renderBobInit::$4 ← (byte) renderBobInit::y#2 << (byte) 1 [ renderBobInit::y#2 renderBobInit::$1 renderBobInit::$4 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 renderBobInit::$1 renderBobInit::$4 ] ) always clobbers reg byte a +Statement [150] *((const word*) MUL40 + (byte~) renderBobInit::$4) ← (word~) renderBobInit::$1 [ renderBobInit::y#2 ] ( main:2::renderBobInit:9 [ renderBobInit::y#2 ] ) always clobbers reg byte a +Statement [154] (byte~) renderBobInit::$5 ← (byte) renderBobInit::i#2 << (byte) 1 [ renderBobInit::i#2 renderBobInit::$5 ] ( main:2::renderBobInit:9 [ renderBobInit::i#2 renderBobInit::$5 ] ) always clobbers reg byte a +Statement [155] *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobInit::$5) ← (const byte*) BOB_SCREEN [ renderBobInit::i#2 ] ( main:2::renderBobInit:9 [ renderBobInit::i#2 ] ) always clobbers reg byte a +Statement [171] (byte*) prepareBobs::bob_table#0 ← (const byte*) BOB_TABLES + (byte) prepareBobs::bob_table_idx#12 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::bob_table#0 ] ( main:2::prepareBobs:7 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::bob_table#0 ] ) always clobbers reg byte a +Statement [179] (byte*) bobCharsetFindOrAddGlyph::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bobCharsetFindOrAddGlyph::bob_glyph#1 ] ( main:2::prepareBobs:7 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bobCharsetFindOrAddGlyph::bob_glyph#1 ] ) always clobbers reg byte a +Statement [183] *((byte*) prepareBobs::bob_table#2) ← (byte~) prepareBobs::$6 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 ] ( main:2::prepareBobs:7 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 ] ) always clobbers reg byte y +Statement [184] (byte*) prepareBobs::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 + (byte) 8 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_table#2 prepareBobs::bob_glyph#1 ] ( main:2::prepareBobs:7 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_table#2 prepareBobs::bob_glyph#1 ] ) always clobbers reg byte a +Statement [185] (byte*) prepareBobs::bob_table#1 ← (byte*) prepareBobs::bob_table#2 + (const byte) BOB_SHIFTS_X*(const byte) BOB_SHIFTS_Y [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 ] ( main:2::prepareBobs:7 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 ] ) always clobbers reg byte a +Statement [190] *((byte*) progress_cursor#24) ← *((const byte*) progress_inc::progress_chars+(byte) 8) [ progress_cursor#24 ] ( main:2::prepareBobs:7::progress_inc:186 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 progress_cursor#24 ] ) always clobbers reg byte a reg byte y +Statement [193] *((byte*) progress_cursor#17) ← *((const byte*) progress_inc::progress_chars + (byte) progress_idx#10) [ progress_idx#10 progress_cursor#17 ] ( main:2::prepareBobs:7::progress_inc:186 [ prepareBobs::shift_y#2 bob_charset_next_id#16 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 prepareBobs::cell#2 prepareBobs::bob_glyph#1 prepareBobs::bob_table#1 progress_idx#10 progress_cursor#17 ] ) always clobbers reg byte a reg byte y +Statement [203] *((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) bobCharsetFindOrAddGlyph::i1#2) ← *((byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 + (byte) bobCharsetFindOrAddGlyph::i1#2) [ bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i1#2 ] ( main:2::prepareBobs:7::bobCharsetFindOrAddGlyph:162 [ bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i1#2 ] main:2::prepareBobs:7::bobCharsetFindOrAddGlyph:180 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i1#2 ] ) always clobbers reg byte a +Statement [207] if(*((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) bobCharsetFindOrAddGlyph::i#2)==*((byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 + (byte) bobCharsetFindOrAddGlyph::i#2)) goto bobCharsetFindOrAddGlyph::@4 [ bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i#2 ] ( main:2::prepareBobs:7::bobCharsetFindOrAddGlyph:162 [ bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i#2 ] main:2::prepareBobs:7::bobCharsetFindOrAddGlyph:180 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bobCharsetFindOrAddGlyph::glyph_id#11 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::i#2 ] ) always clobbers reg byte a +Statement [211] (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#1 ← (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) 8 [ bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_id#1 bobCharsetFindOrAddGlyph::glyph_cursor#1 ] ( main:2::prepareBobs:7::bobCharsetFindOrAddGlyph:162 [ bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_id#1 bobCharsetFindOrAddGlyph::glyph_cursor#1 ] main:2::prepareBobs:7::bobCharsetFindOrAddGlyph:180 [ prepareBobs::shift_y#2 prepareBobs::bob_table_idx#12 prepareBobs::shift_x#2 progress_cursor#24 progress_idx#25 prepareBobs::cell#2 prepareBobs::bob_glyph#2 prepareBobs::bob_table#2 bob_charset_next_id#23 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::glyph_id#1 bobCharsetFindOrAddGlyph::glyph_cursor#1 ] ) always clobbers reg byte a +Statement [217] (byte~) shiftProtoBobRight::$1 ← *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) & (byte) 1 [ shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::$1 ] ( main:2::prepareBobs:7::shiftProtoBobRight:175 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::$1 ] main:2::prepareBobs:7::shiftProtoBobRight:177 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::$1 ] ) always clobbers reg byte a +Statement [221] (byte~) shiftProtoBobRight::$5 ← *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) >> (byte) 1 [ shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::$5 ] ( main:2::prepareBobs:7::shiftProtoBobRight:175 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::$5 ] main:2::prepareBobs:7::shiftProtoBobRight:177 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::j#3 shiftProtoBobRight::carry#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::$5 ] ) always clobbers reg byte a +Statement [225] (byte) shiftProtoBobRight::j#2 ← (byte) shiftProtoBobRight::j#3 + (byte) $18 [ shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#2 ] ( main:2::prepareBobs:7::shiftProtoBobRight:175 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#2 ] main:2::prepareBobs:7::shiftProtoBobRight:177 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#2 ] ) always clobbers reg byte a +Statement [229] (byte) shiftProtoBobRight::j#1 ← (byte) shiftProtoBobRight::j#3 - (byte) $2f [ shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#1 ] ( main:2::prepareBobs:7::shiftProtoBobRight:175 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#1 ] main:2::prepareBobs:7::shiftProtoBobRight:177 [ prepareBobs::shift_y#2 prepareBobs::shift_x#2 prepareBobs::bob_table_idx#1 bob_charset_next_id#21 progress_cursor#24 progress_idx#25 shiftProtoBobRight::i#2 shiftProtoBobRight::carry#1 shiftProtoBobRight::j#1 ] ) always clobbers reg byte a +Statement [233] *((const byte*) PROTO_BOB) ← (byte) 0 [ ] ( main:2::prepareBobs:7::shiftProtoBobDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 ] ) always clobbers reg byte a +Statement [234] *((const byte*) PROTO_BOB+(byte) $18) ← (byte) 0 [ ] ( main:2::prepareBobs:7::shiftProtoBobDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 ] ) always clobbers reg byte a +Statement [235] *((const byte*) PROTO_BOB+(byte) $30) ← (byte) 0 [ ] ( main:2::prepareBobs:7::shiftProtoBobDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 ] ) always clobbers reg byte a +Statement [237] *((const byte*) PROTO_BOB + (byte) shiftProtoBobDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $17 + (byte) shiftProtoBobDown::i#2) [ shiftProtoBobDown::i#2 ] ( main:2::prepareBobs:7::shiftProtoBobDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 shiftProtoBobDown::i#2 ] ) always clobbers reg byte a +Statement [238] *((const byte*) PROTO_BOB+(byte) $18 + (byte) shiftProtoBobDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $2f + (byte) shiftProtoBobDown::i#2) [ shiftProtoBobDown::i#2 ] ( main:2::prepareBobs:7::shiftProtoBobDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 shiftProtoBobDown::i#2 ] ) always clobbers reg byte a +Statement [239] *((const byte*) PROTO_BOB+(byte) $30 + (byte) shiftProtoBobDown::i#2) ← (byte) 0 [ shiftProtoBobDown::i#2 ] ( main:2::prepareBobs:7::shiftProtoBobDown:169 [ prepareBobs::shift_y#2 progress_cursor#31 progress_idx#31 bob_charset_next_id#30 prepareBobs::bob_table_idx#12 shiftProtoBobDown::i#2 ] ) always clobbers reg byte a +Statement [245] if((byte*) mulf_init::sqr1_lo#2!=(const byte*) mulf_sqr1_lo+(word) $200) goto mulf_init::@2 [ mulf_init::sqr1_lo#2 mulf_init::c#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::c#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 ] ) always clobbers reg byte a +Statement [247] if((byte*) mulf_init::sqr2_lo#2!=(const byte*) mulf_sqr2_lo+(word) $1ff) goto mulf_init::@6 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ( main:2::mulf_init:5 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ) always clobbers reg byte a +Statement [248] *((const byte*) mulf_sqr2_lo+(word) $1ff) ← *((const byte*) mulf_sqr1_lo+(word) $100) [ ] ( main:2::mulf_init:5 [ ] ) always clobbers reg byte a +Statement [249] *((const byte*) mulf_sqr2_hi+(word) $1ff) ← *((const byte*) mulf_sqr1_hi+(word) $100) [ ] ( main:2::mulf_init:5 [ ] ) always clobbers reg byte a +Statement [251] *((byte*) mulf_init::sqr2_lo#2) ← *((const byte*) mulf_sqr1_lo + (byte) mulf_init::x_255#2) [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ( main:2::mulf_init:5 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ) always clobbers reg byte a reg byte y +Statement [252] *((byte*) mulf_init::sqr2_hi#2) ← *((const byte*) mulf_sqr1_hi + (byte) mulf_init::x_255#2) [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ( main:2::mulf_init:5 [ mulf_init::sqr2_lo#2 mulf_init::x_255#2 mulf_init::sqr2_hi#2 mulf_init::dir#2 ] ) always clobbers reg byte a reg byte y +Statement [254] (byte) mulf_init::x_255#1 ← (byte) mulf_init::x_255#2 + (byte) mulf_init::dir#2 [ mulf_init::sqr2_lo#2 mulf_init::dir#2 mulf_init::x_255#1 mulf_init::sqr2_hi#1 ] ( main:2::mulf_init:5 [ mulf_init::sqr2_lo#2 mulf_init::dir#2 mulf_init::x_255#1 mulf_init::sqr2_hi#1 ] ) always clobbers reg byte a +Statement [260] (byte~) mulf_init::$1 ← (byte) mulf_init::c#1 & (byte) 1 [ mulf_init::sqr1_lo#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 mulf_init::c#1 mulf_init::$1 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::sqr#4 mulf_init::sqr1_hi#2 mulf_init::x_2#3 mulf_init::c#1 mulf_init::$1 ] ) always clobbers reg byte a +Statement [265] (byte~) mulf_init::$4 ← < (word) mulf_init::sqr#3 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$4 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$4 ] ) always clobbers reg byte a +Statement [266] *((byte*) mulf_init::sqr1_lo#2) ← (byte~) mulf_init::$4 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ) always clobbers reg byte y +Statement [267] (byte~) mulf_init::$5 ← > (word) mulf_init::sqr#3 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$5 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 mulf_init::$5 ] ) always clobbers reg byte a +Statement [268] *((byte*) mulf_init::sqr1_hi#2) ← (byte~) mulf_init::$5 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_hi#2 mulf_init::c#1 mulf_init::x_2#2 mulf_init::sqr#3 ] ) always clobbers reg byte y +Statement [270] (word) mulf_init::sqr#1 ← (word) mulf_init::sqr#3 + (byte) mulf_init::x_2#2 [ mulf_init::sqr1_lo#2 mulf_init::c#1 mulf_init::sqr#1 mulf_init::sqr1_hi#1 mulf_init::x_2#2 ] ( main:2::mulf_init:5 [ mulf_init::sqr1_lo#2 mulf_init::c#1 mulf_init::sqr#1 mulf_init::sqr1_hi#1 mulf_init::x_2#2 ] ) always clobbers reg byte a Potential registers zp[1]:2 [ main::angle#8 main::angle#1 ] : zp[1]:2 , Potential registers zp[1]:3 [ main::r#2 main::r#1 ] : zp[1]:3 , Potential registers zp[1]:4 [ main::a#2 main::a#6 main::a#1 ] : zp[1]:4 , @@ -7348,20 +7303,20 @@ Potential registers zp[1]:12 [ renderBobCleanup::i#2 renderBobCleanup::i#1 ] : z Potential registers zp[2]:13 [ memset::dst#2 memset::dst#1 ] : zp[2]:13 , Potential registers zp[1]:15 [ renderBobInit::y#2 renderBobInit::y#1 ] : zp[1]:15 , reg byte x , reg byte y , Potential registers zp[1]:16 [ renderBobInit::i#2 renderBobInit::i#1 ] : zp[1]:16 , reg byte x , reg byte y , -Potential registers zp[1]:17 [ prepareBobs::shift_y#2 prepareBobs::shift_y#1 ] : zp[1]:17 , +Potential registers zp[1]:17 [ prepareBobs::shift_y#2 prepareBobs::shift_y#1 ] : zp[1]:17 , reg byte x , Potential registers zp[2]:18 [ progress_cursor#15 progress_cursor#31 progress_cursor#24 progress_cursor#17 progress_cursor#8 ] : zp[2]:18 , -Potential registers zp[1]:20 [ progress_idx#16 progress_idx#31 progress_idx#25 progress_idx#10 progress_idx#8 ] : zp[1]:20 , -Potential registers zp[1]:21 [ prepareBobs::bob_table_idx#6 prepareBobs::bob_table_idx#12 prepareBobs::bob_table_idx#1 ] : zp[1]:21 , -Potential registers zp[1]:22 [ prepareBobs::shift_x#2 prepareBobs::shift_x#1 ] : zp[1]:22 , -Potential registers zp[1]:23 [ prepareBobs::cell#2 prepareBobs::cell#1 ] : zp[1]:23 , +Potential registers zp[1]:20 [ progress_idx#16 progress_idx#31 progress_idx#25 progress_idx#10 progress_idx#8 ] : zp[1]:20 , reg byte x , +Potential registers zp[1]:21 [ prepareBobs::bob_table_idx#6 prepareBobs::bob_table_idx#12 prepareBobs::bob_table_idx#1 ] : zp[1]:21 , reg byte x , +Potential registers zp[1]:22 [ prepareBobs::shift_x#2 prepareBobs::shift_x#1 ] : zp[1]:22 , reg byte x , +Potential registers zp[1]:23 [ prepareBobs::cell#2 prepareBobs::cell#1 ] : zp[1]:23 , reg byte x , Potential registers zp[2]:24 [ prepareBobs::bob_glyph#2 prepareBobs::bob_glyph#1 ] : zp[2]:24 , Potential registers zp[2]:26 [ prepareBobs::bob_table#2 prepareBobs::bob_table#1 prepareBobs::bob_table#0 ] : zp[2]:26 , -Potential registers zp[1]:28 [ bob_charset_next_id#23 bob_charset_next_id#14 bob_charset_next_id#16 bob_charset_next_id#30 bob_charset_next_id#21 bob_charset_next_id#8 ] : zp[1]:28 , +Potential registers zp[1]:28 [ bob_charset_next_id#23 bob_charset_next_id#14 bob_charset_next_id#16 bob_charset_next_id#30 bob_charset_next_id#21 bob_charset_next_id#8 ] : zp[1]:28 , reg byte x , Potential registers zp[2]:29 [ bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::bob_glyph#1 ] : zp[2]:29 , -Potential registers zp[1]:31 [ bobCharsetFindOrAddGlyph::glyph_id#11 bobCharsetFindOrAddGlyph::glyph_id#1 ] : zp[1]:31 , +Potential registers zp[1]:31 [ bobCharsetFindOrAddGlyph::glyph_id#11 bobCharsetFindOrAddGlyph::glyph_id#1 ] : zp[1]:31 , reg byte x , reg byte y , Potential registers zp[2]:32 [ bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::glyph_cursor#1 ] : zp[2]:32 , Potential registers zp[1]:34 [ bobCharsetFindOrAddGlyph::i1#2 bobCharsetFindOrAddGlyph::i1#1 ] : zp[1]:34 , reg byte x , reg byte y , -Potential registers zp[1]:35 [ bobCharsetFindOrAddGlyph::i#2 bobCharsetFindOrAddGlyph::i#1 ] : zp[1]:35 , +Potential registers zp[1]:35 [ bobCharsetFindOrAddGlyph::i#2 bobCharsetFindOrAddGlyph::i#1 ] : zp[1]:35 , reg byte x , reg byte y , Potential registers zp[1]:36 [ bobCharsetFindOrAddGlyph::found#2 ] : zp[1]:36 , reg byte a , reg byte x , reg byte y , Potential registers zp[1]:37 [ shiftProtoBobRight::i#2 shiftProtoBobRight::i#1 ] : zp[1]:37 , reg byte x , reg byte y , Potential registers zp[1]:38 [ shiftProtoBobRight::j#3 shiftProtoBobRight::j#10 shiftProtoBobRight::j#2 shiftProtoBobRight::j#1 ] : zp[1]:38 , reg byte x , reg byte y , @@ -7453,82 +7408,81 @@ Uplift Scope [RADIX] Uplift Scope [progress_init] Uplift Scope [progress_inc] -Uplifting [bobCharsetFindOrAddGlyph] best 6301828 combination zp[1]:35 [ bobCharsetFindOrAddGlyph::i#2 bobCharsetFindOrAddGlyph::i#1 ] reg byte y [ bobCharsetFindOrAddGlyph::i1#2 bobCharsetFindOrAddGlyph::i1#1 ] zp[2]:32 [ bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::glyph_cursor#1 ] zp[1]:31 [ bobCharsetFindOrAddGlyph::glyph_id#11 bobCharsetFindOrAddGlyph::glyph_id#1 ] reg byte a [ bobCharsetFindOrAddGlyph::found#2 ] zp[2]:29 [ bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::bob_glyph#1 ] reg byte a [ bobCharsetFindOrAddGlyph::return#1 ] -Uplifting [shiftProtoBobRight] best 6263828 combination reg byte x [ shiftProtoBobRight::j#3 shiftProtoBobRight::j#10 shiftProtoBobRight::j#2 shiftProtoBobRight::j#1 ] reg byte y [ shiftProtoBobRight::carry#2 shiftProtoBobRight::carry#10 ] reg byte a [ shiftProtoBobRight::$1 ] reg byte a [ shiftProtoBobRight::$5 ] zp[1]:123 [ shiftProtoBobRight::$6 ] zp[1]:37 [ shiftProtoBobRight::i#2 shiftProtoBobRight::i#1 ] zp[1]:40 [ shiftProtoBobRight::carry#1 ] +Uplifting [bobCharsetFindOrAddGlyph] best 4014542 combination reg byte y [ bobCharsetFindOrAddGlyph::i#2 bobCharsetFindOrAddGlyph::i#1 ] reg byte y [ bobCharsetFindOrAddGlyph::i1#2 bobCharsetFindOrAddGlyph::i1#1 ] zp[2]:32 [ bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::glyph_cursor#1 ] reg byte x [ bobCharsetFindOrAddGlyph::glyph_id#11 bobCharsetFindOrAddGlyph::glyph_id#1 ] reg byte a [ bobCharsetFindOrAddGlyph::found#2 ] zp[2]:29 [ bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::bob_glyph#1 ] zp[1]:119 [ bobCharsetFindOrAddGlyph::return#1 ] +Limited combination testing to 100 combinations of 432 possible. +Uplifting [shiftProtoBobRight] best 3976542 combination reg byte x [ shiftProtoBobRight::j#3 shiftProtoBobRight::j#10 shiftProtoBobRight::j#2 shiftProtoBobRight::j#1 ] reg byte y [ shiftProtoBobRight::carry#2 shiftProtoBobRight::carry#10 ] reg byte a [ shiftProtoBobRight::$1 ] reg byte a [ shiftProtoBobRight::$5 ] zp[1]:123 [ shiftProtoBobRight::$6 ] zp[1]:37 [ shiftProtoBobRight::i#2 shiftProtoBobRight::i#1 ] zp[1]:40 [ shiftProtoBobRight::carry#1 ] Limited combination testing to 100 combinations of 5184 possible. -Uplifting [prepareBobs] best 6257828 combination zp[1]:23 [ prepareBobs::cell#2 prepareBobs::cell#1 ] reg byte a [ prepareBobs::$6 ] zp[2]:26 [ prepareBobs::bob_table#2 prepareBobs::bob_table#1 prepareBobs::bob_table#0 ] zp[2]:24 [ prepareBobs::bob_glyph#2 prepareBobs::bob_glyph#1 ] zp[1]:22 [ prepareBobs::shift_x#2 prepareBobs::shift_x#1 ] zp[1]:21 [ prepareBobs::bob_table_idx#6 prepareBobs::bob_table_idx#12 prepareBobs::bob_table_idx#1 ] zp[1]:17 [ prepareBobs::shift_y#2 prepareBobs::shift_y#1 ] -Uplifting [] best 6257828 combination zp[1]:28 [ bob_charset_next_id#23 bob_charset_next_id#14 bob_charset_next_id#16 bob_charset_next_id#30 bob_charset_next_id#21 bob_charset_next_id#8 ] zp[1]:20 [ progress_idx#16 progress_idx#31 progress_idx#25 progress_idx#10 progress_idx#8 ] zp[2]:18 [ progress_cursor#15 progress_cursor#31 progress_cursor#24 progress_cursor#17 progress_cursor#8 ] zp[2]:5 [ renderBobCleanupNext#17 renderBobCleanupNext#13 ] -Uplifting [mulf8s] best 6256622 combination reg byte x [ mulf8s::b#2 mulf8s::b#1 mulf8s::b#0 ] reg byte a [ mulf8s::mulf8s_prepare1_a#0 mulf8s::a#1 mulf8s::a#0 ] zp[2]:56 [ mulf8s::return#2 ] zp[2]:62 [ mulf8s::return#3 ] zp[2]:95 [ mulf8s::return#0 ] -Uplifting [main] best 6256502 combination zp[2]:58 [ main::$10 ] zp[2]:64 [ main::$12 ] zp[2]:66 [ main::$13 ] zp[1]:7 [ main::i#2 main::i#1 ] zp[1]:4 [ main::a#2 main::a#6 main::a#1 ] zp[1]:3 [ main::r#2 main::r#1 ] zp[2]:68 [ main::y#0 ] reg byte a [ main::$19 ] reg byte a [ main::$21 ] zp[2]:60 [ main::x#0 ] zp[1]:2 [ main::angle#8 main::angle#1 ] -Uplifting [renderBobCleanup] best 6255102 combination reg byte a [ renderBobCleanup::$1 ] reg byte x [ renderBobCleanup::i#2 renderBobCleanup::i#1 ] zp[2]:107 [ renderBobCleanup::screen#0 ] -Uplifting [shiftProtoBobDown] best 6253502 combination reg byte x [ shiftProtoBobDown::i#2 shiftProtoBobDown::i#1 ] -Uplifting [mulf_init] best 6253252 combination zp[2]:54 [ mulf_init::sqr#3 mulf_init::sqr#4 mulf_init::sqr#1 mulf_init::sqr#2 ] zp[2]:48 [ mulf_init::sqr2_lo#2 mulf_init::sqr2_lo#1 ] zp[2]:42 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_lo#1 ] reg byte x [ mulf_init::x_2#3 mulf_init::x_2#2 mulf_init::x_2#1 ] reg byte a [ mulf_init::$1 ] reg byte a [ mulf_init::$4 ] reg byte a [ mulf_init::$5 ] zp[1]:50 [ mulf_init::x_255#2 mulf_init::x_255#1 ] zp[1]:53 [ mulf_init::dir#2 mulf_init::dir#4 ] zp[1]:44 [ mulf_init::c#2 mulf_init::c#1 ] zp[2]:51 [ mulf_init::sqr2_hi#2 mulf_init::sqr2_hi#1 ] zp[2]:45 [ mulf_init::sqr1_hi#2 mulf_init::sqr1_hi#1 ] +Uplifting [prepareBobs] best 3970542 combination zp[1]:23 [ prepareBobs::cell#2 prepareBobs::cell#1 ] reg byte a [ prepareBobs::$6 ] zp[2]:26 [ prepareBobs::bob_table#2 prepareBobs::bob_table#1 prepareBobs::bob_table#0 ] zp[2]:24 [ prepareBobs::bob_glyph#2 prepareBobs::bob_glyph#1 ] zp[1]:22 [ prepareBobs::shift_x#2 prepareBobs::shift_x#1 ] zp[1]:21 [ prepareBobs::bob_table_idx#6 prepareBobs::bob_table_idx#12 prepareBobs::bob_table_idx#1 ] zp[1]:17 [ prepareBobs::shift_y#2 prepareBobs::shift_y#1 ] +Uplifting [] best 3970542 combination zp[1]:28 [ bob_charset_next_id#23 bob_charset_next_id#14 bob_charset_next_id#16 bob_charset_next_id#30 bob_charset_next_id#21 bob_charset_next_id#8 ] zp[1]:20 [ progress_idx#16 progress_idx#31 progress_idx#25 progress_idx#10 progress_idx#8 ] zp[2]:18 [ progress_cursor#15 progress_cursor#31 progress_cursor#24 progress_cursor#17 progress_cursor#8 ] zp[2]:5 [ renderBobCleanupNext#17 renderBobCleanupNext#13 ] +Uplifting [mulf8s] best 3969336 combination reg byte x [ mulf8s::b#2 mulf8s::b#1 mulf8s::b#0 ] reg byte a [ mulf8s::mulf8s_prepare1_a#0 mulf8s::a#1 mulf8s::a#0 ] zp[2]:56 [ mulf8s::return#2 ] zp[2]:62 [ mulf8s::return#3 ] zp[2]:95 [ mulf8s::return#0 ] +Uplifting [main] best 3969216 combination zp[2]:58 [ main::$10 ] zp[2]:64 [ main::$12 ] zp[2]:66 [ main::$13 ] zp[1]:7 [ main::i#2 main::i#1 ] zp[1]:4 [ main::a#2 main::a#6 main::a#1 ] zp[1]:3 [ main::r#2 main::r#1 ] zp[2]:68 [ main::y#0 ] reg byte a [ main::$19 ] reg byte a [ main::$21 ] zp[2]:60 [ main::x#0 ] zp[1]:2 [ main::angle#8 main::angle#1 ] +Uplifting [renderBobCleanup] best 3967816 combination reg byte a [ renderBobCleanup::$1 ] reg byte x [ renderBobCleanup::i#2 renderBobCleanup::i#1 ] zp[2]:107 [ renderBobCleanup::screen#0 ] +Uplifting [shiftProtoBobDown] best 3966216 combination reg byte x [ shiftProtoBobDown::i#2 shiftProtoBobDown::i#1 ] +Uplifting [mulf_init] best 3965966 combination zp[2]:54 [ mulf_init::sqr#3 mulf_init::sqr#4 mulf_init::sqr#1 mulf_init::sqr#2 ] zp[2]:48 [ mulf_init::sqr2_lo#2 mulf_init::sqr2_lo#1 ] zp[2]:42 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_lo#1 ] reg byte x [ mulf_init::x_2#3 mulf_init::x_2#2 mulf_init::x_2#1 ] reg byte a [ mulf_init::$1 ] reg byte a [ mulf_init::$4 ] reg byte a [ mulf_init::$5 ] zp[1]:50 [ mulf_init::x_255#2 mulf_init::x_255#1 ] zp[1]:53 [ mulf_init::dir#2 mulf_init::dir#4 ] zp[1]:44 [ mulf_init::c#2 mulf_init::c#1 ] zp[2]:51 [ mulf_init::sqr2_hi#2 mulf_init::sqr2_hi#1 ] zp[2]:45 [ mulf_init::sqr1_hi#2 mulf_init::sqr1_hi#1 ] Limited combination testing to 100 combinations of 1024 possible. -Uplifting [renderBobInit] best 6252962 combination reg byte x [ renderBobInit::i#2 renderBobInit::i#1 ] zp[2]:111 [ renderBobInit::$6 ] zp[2]:113 [ renderBobInit::$7 ] reg byte a [ renderBobInit::$4 ] reg byte a [ renderBobInit::$5 ] reg byte x [ renderBobInit::y#2 renderBobInit::y#1 ] zp[2]:109 [ renderBobInit::$0 ] zp[2]:115 [ renderBobInit::$1 ] +Uplifting [renderBobInit] best 3965676 combination reg byte x [ renderBobInit::i#2 renderBobInit::i#1 ] zp[2]:111 [ renderBobInit::$6 ] zp[2]:113 [ renderBobInit::$7 ] reg byte a [ renderBobInit::$4 ] reg byte a [ renderBobInit::$5 ] reg byte x [ renderBobInit::y#2 renderBobInit::y#1 ] zp[2]:109 [ renderBobInit::$0 ] zp[2]:115 [ renderBobInit::$1 ] Limited combination testing to 100 combinations of 144 possible. -Uplifting [renderBob] best 6252848 combination reg byte x [ renderBob::ypos#0 ] zp[1]:70 [ renderBob::xpos#0 ] reg byte a [ renderBob::y_char_offset#0 ] reg byte a [ renderBob::$8 ] zp[2]:83 [ renderBob::y_offset#0 ] zp[2]:85 [ renderBob::$2 ] zp[1]:89 [ renderBob::$4 ] zp[1]:91 [ renderBob::$6 ] zp[1]:90 [ renderBob::$5 ] zp[1]:92 [ renderBob::bob_table_idx#0 ] zp[2]:87 [ renderBob::screen#0 ] zp[1]:80 [ renderBob::x_char_offset#0 ] +Uplifting [renderBob] best 3965562 combination reg byte x [ renderBob::ypos#0 ] zp[1]:70 [ renderBob::xpos#0 ] reg byte a [ renderBob::y_char_offset#0 ] reg byte a [ renderBob::$8 ] zp[2]:83 [ renderBob::y_offset#0 ] zp[2]:85 [ renderBob::$2 ] zp[1]:89 [ renderBob::$4 ] zp[1]:91 [ renderBob::$6 ] zp[1]:90 [ renderBob::$5 ] zp[1]:92 [ renderBob::bob_table_idx#0 ] zp[2]:87 [ renderBob::screen#0 ] zp[1]:80 [ renderBob::x_char_offset#0 ] Limited combination testing to 100 combinations of 41472 possible. -Uplifting [keyboard_key_pressed] best 6252659 combination reg byte a [ keyboard_key_pressed::return#2 ] reg byte a [ keyboard_key_pressed::return#3 ] reg byte a [ keyboard_key_pressed::return#0 ] reg byte a [ keyboard_key_pressed::$2 ] +Uplifting [keyboard_key_pressed] best 3965373 combination reg byte a [ keyboard_key_pressed::return#2 ] reg byte a [ keyboard_key_pressed::return#3 ] reg byte a [ keyboard_key_pressed::return#0 ] reg byte a [ keyboard_key_pressed::$2 ] Limited combination testing to 100 combinations of 256 possible. -Uplifting [memset] best 6252659 combination zp[2]:13 [ memset::dst#2 memset::dst#1 ] -Uplifting [mulf8s_prepared] best 6252635 combination zp[2]:10 [ mulf8s_prepared::m#4 mulf8s_prepared::m#5 mulf8s_prepared::m#1 mulf8s_prepared::m#0 mulf8s_prepared::m#2 ] reg byte a [ mulf8s_prepared::$8 ] reg byte a [ mulf8s_prepared::$15 ] reg byte a [ mulf8s_prepared::$12 ] reg byte a [ mulf8s_prepared::$16 ] zp[1]:94 [ mulf8s_prepared::b#0 ] +Uplifting [memset] best 3965373 combination zp[2]:13 [ memset::dst#2 memset::dst#1 ] +Uplifting [mulf8s_prepared] best 3965349 combination zp[2]:10 [ mulf8s_prepared::m#4 mulf8s_prepared::m#5 mulf8s_prepared::m#1 mulf8s_prepared::m#0 mulf8s_prepared::m#2 ] reg byte a [ mulf8s_prepared::$8 ] reg byte a [ mulf8s_prepared::$15 ] reg byte a [ mulf8s_prepared::$12 ] reg byte a [ mulf8s_prepared::$16 ] zp[1]:94 [ mulf8s_prepared::b#0 ] Limited combination testing to 100 combinations of 512 possible. -Uplifting [mulf8u_prepared] best 6252629 combination reg byte a [ mulf8u_prepared::b#0 ] zp[2]:98 [ mulf8u_prepared::return#2 ] zp[2]:104 [ mulf8u_prepared::return#0 ] -Uplifting [keyboard_matrix_read] best 6252617 combination reg byte a [ keyboard_matrix_read::return#2 ] reg byte a [ keyboard_matrix_read::return#0 ] -Uplifting [mulf8u_prepare] best 6252611 combination reg byte a [ mulf8u_prepare::a#0 ] -Uplifting [RADIX] best 6252611 combination -Uplifting [progress_init] best 6252611 combination -Uplifting [progress_inc] best 6252611 combination -Attempting to uplift remaining variables inzp[1]:35 [ bobCharsetFindOrAddGlyph::i#2 bobCharsetFindOrAddGlyph::i#1 ] -Uplifting [bobCharsetFindOrAddGlyph] best 6252611 combination zp[1]:35 [ bobCharsetFindOrAddGlyph::i#2 bobCharsetFindOrAddGlyph::i#1 ] -Attempting to uplift remaining variables inzp[1]:31 [ bobCharsetFindOrAddGlyph::glyph_id#11 bobCharsetFindOrAddGlyph::glyph_id#1 ] -Uplifting [bobCharsetFindOrAddGlyph] best 6252611 combination zp[1]:31 [ bobCharsetFindOrAddGlyph::glyph_id#11 bobCharsetFindOrAddGlyph::glyph_id#1 ] +Uplifting [mulf8u_prepared] best 3965343 combination reg byte a [ mulf8u_prepared::b#0 ] zp[2]:98 [ mulf8u_prepared::return#2 ] zp[2]:104 [ mulf8u_prepared::return#0 ] +Uplifting [keyboard_matrix_read] best 3965331 combination reg byte a [ keyboard_matrix_read::return#2 ] reg byte a [ keyboard_matrix_read::return#0 ] +Uplifting [mulf8u_prepare] best 3965325 combination reg byte a [ mulf8u_prepare::a#0 ] +Uplifting [RADIX] best 3965325 combination +Uplifting [progress_init] best 3965325 combination +Uplifting [progress_inc] best 3965325 combination Attempting to uplift remaining variables inzp[1]:28 [ bob_charset_next_id#23 bob_charset_next_id#14 bob_charset_next_id#16 bob_charset_next_id#30 bob_charset_next_id#21 bob_charset_next_id#8 ] -Uplifting [] best 6252611 combination zp[1]:28 [ bob_charset_next_id#23 bob_charset_next_id#14 bob_charset_next_id#16 bob_charset_next_id#30 bob_charset_next_id#21 bob_charset_next_id#8 ] +Uplifting [] best 3965325 combination zp[1]:28 [ bob_charset_next_id#23 bob_charset_next_id#14 bob_charset_next_id#16 bob_charset_next_id#30 bob_charset_next_id#21 bob_charset_next_id#8 ] Attempting to uplift remaining variables inzp[1]:23 [ prepareBobs::cell#2 prepareBobs::cell#1 ] -Uplifting [prepareBobs] best 6252611 combination zp[1]:23 [ prepareBobs::cell#2 prepareBobs::cell#1 ] +Uplifting [prepareBobs] best 3965325 combination zp[1]:23 [ prepareBobs::cell#2 prepareBobs::cell#1 ] +Attempting to uplift remaining variables inzp[1]:119 [ bobCharsetFindOrAddGlyph::return#1 ] +Uplifting [bobCharsetFindOrAddGlyph] best 3961325 combination reg byte a [ bobCharsetFindOrAddGlyph::return#1 ] Attempting to uplift remaining variables inzp[1]:123 [ shiftProtoBobRight::$6 ] -Uplifting [shiftProtoBobRight] best 6246611 combination reg byte a [ shiftProtoBobRight::$6 ] +Uplifting [shiftProtoBobRight] best 3955325 combination reg byte a [ shiftProtoBobRight::$6 ] Attempting to uplift remaining variables inzp[1]:37 [ shiftProtoBobRight::i#2 shiftProtoBobRight::i#1 ] -Uplifting [shiftProtoBobRight] best 6246611 combination zp[1]:37 [ shiftProtoBobRight::i#2 shiftProtoBobRight::i#1 ] +Uplifting [shiftProtoBobRight] best 3955325 combination zp[1]:37 [ shiftProtoBobRight::i#2 shiftProtoBobRight::i#1 ] Attempting to uplift remaining variables inzp[1]:20 [ progress_idx#16 progress_idx#31 progress_idx#25 progress_idx#10 progress_idx#8 ] -Uplifting [] best 6246611 combination zp[1]:20 [ progress_idx#16 progress_idx#31 progress_idx#25 progress_idx#10 progress_idx#8 ] +Uplifting [] best 3955325 combination zp[1]:20 [ progress_idx#16 progress_idx#31 progress_idx#25 progress_idx#10 progress_idx#8 ] Attempting to uplift remaining variables inzp[1]:22 [ prepareBobs::shift_x#2 prepareBobs::shift_x#1 ] -Uplifting [prepareBobs] best 6246611 combination zp[1]:22 [ prepareBobs::shift_x#2 prepareBobs::shift_x#1 ] +Uplifting [prepareBobs] best 3955325 combination zp[1]:22 [ prepareBobs::shift_x#2 prepareBobs::shift_x#1 ] Attempting to uplift remaining variables inzp[1]:7 [ main::i#2 main::i#1 ] -Uplifting [main] best 6246611 combination zp[1]:7 [ main::i#2 main::i#1 ] +Uplifting [main] best 3955325 combination zp[1]:7 [ main::i#2 main::i#1 ] Attempting to uplift remaining variables inzp[1]:40 [ shiftProtoBobRight::carry#1 ] -Uplifting [shiftProtoBobRight] best 6246611 combination zp[1]:40 [ shiftProtoBobRight::carry#1 ] +Uplifting [shiftProtoBobRight] best 3955325 combination zp[1]:40 [ shiftProtoBobRight::carry#1 ] Attempting to uplift remaining variables inzp[1]:4 [ main::a#2 main::a#6 main::a#1 ] -Uplifting [main] best 6246611 combination zp[1]:4 [ main::a#2 main::a#6 main::a#1 ] +Uplifting [main] best 3955325 combination zp[1]:4 [ main::a#2 main::a#6 main::a#1 ] Attempting to uplift remaining variables inzp[1]:21 [ prepareBobs::bob_table_idx#6 prepareBobs::bob_table_idx#12 prepareBobs::bob_table_idx#1 ] -Uplifting [prepareBobs] best 6246611 combination zp[1]:21 [ prepareBobs::bob_table_idx#6 prepareBobs::bob_table_idx#12 prepareBobs::bob_table_idx#1 ] +Uplifting [prepareBobs] best 3955325 combination zp[1]:21 [ prepareBobs::bob_table_idx#6 prepareBobs::bob_table_idx#12 prepareBobs::bob_table_idx#1 ] Attempting to uplift remaining variables inzp[1]:3 [ main::r#2 main::r#1 ] -Uplifting [main] best 6246611 combination zp[1]:3 [ main::r#2 main::r#1 ] +Uplifting [main] best 3955325 combination zp[1]:3 [ main::r#2 main::r#1 ] Attempting to uplift remaining variables inzp[1]:17 [ prepareBobs::shift_y#2 prepareBobs::shift_y#1 ] -Uplifting [prepareBobs] best 6246611 combination zp[1]:17 [ prepareBobs::shift_y#2 prepareBobs::shift_y#1 ] +Uplifting [prepareBobs] best 3955325 combination zp[1]:17 [ prepareBobs::shift_y#2 prepareBobs::shift_y#1 ] Attempting to uplift remaining variables inzp[1]:50 [ mulf_init::x_255#2 mulf_init::x_255#1 ] -Uplifting [mulf_init] best 6246471 combination reg byte x [ mulf_init::x_255#2 mulf_init::x_255#1 ] +Uplifting [mulf_init] best 3955185 combination reg byte x [ mulf_init::x_255#2 mulf_init::x_255#1 ] Attempting to uplift remaining variables inzp[1]:53 [ mulf_init::dir#2 mulf_init::dir#4 ] -Uplifting [mulf_init] best 6246471 combination zp[1]:53 [ mulf_init::dir#2 mulf_init::dir#4 ] +Uplifting [mulf_init] best 3955185 combination zp[1]:53 [ mulf_init::dir#2 mulf_init::dir#4 ] Attempting to uplift remaining variables inzp[1]:44 [ mulf_init::c#2 mulf_init::c#1 ] -Uplifting [mulf_init] best 6246471 combination zp[1]:44 [ mulf_init::c#2 mulf_init::c#1 ] +Uplifting [mulf_init] best 3955185 combination zp[1]:44 [ mulf_init::c#2 mulf_init::c#1 ] Attempting to uplift remaining variables inzp[1]:70 [ renderBob::xpos#0 ] -Uplifting [renderBob] best 6246471 combination zp[1]:70 [ renderBob::xpos#0 ] +Uplifting [renderBob] best 3955185 combination zp[1]:70 [ renderBob::xpos#0 ] Attempting to uplift remaining variables inzp[1]:2 [ main::angle#8 main::angle#1 ] -Uplifting [main] best 6246471 combination zp[1]:2 [ main::angle#8 main::angle#1 ] +Uplifting [main] best 3955185 combination zp[1]:2 [ main::angle#8 main::angle#1 ] Attempting to uplift remaining variables inzp[1]:89 [ renderBob::$4 ] -Uplifting [renderBob] best 6246467 combination reg byte a [ renderBob::$4 ] +Uplifting [renderBob] best 3955181 combination reg byte a [ renderBob::$4 ] Attempting to uplift remaining variables inzp[1]:91 [ renderBob::$6 ] -Uplifting [renderBob] best 6246461 combination reg byte a [ renderBob::$6 ] +Uplifting [renderBob] best 3955175 combination reg byte a [ renderBob::$6 ] Attempting to uplift remaining variables inzp[1]:90 [ renderBob::$5 ] -Uplifting [renderBob] best 6246461 combination zp[1]:90 [ renderBob::$5 ] +Uplifting [renderBob] best 3955175 combination zp[1]:90 [ renderBob::$5 ] Attempting to uplift remaining variables inzp[1]:92 [ renderBob::bob_table_idx#0 ] -Uplifting [renderBob] best 6246433 combination reg byte x [ renderBob::bob_table_idx#0 ] +Uplifting [renderBob] best 3955147 combination reg byte x [ renderBob::bob_table_idx#0 ] Attempting to uplift remaining variables inzp[1]:80 [ renderBob::x_char_offset#0 ] -Uplifting [renderBob] best 6246433 combination zp[1]:80 [ renderBob::x_char_offset#0 ] +Uplifting [renderBob] best 3955147 combination zp[1]:80 [ renderBob::x_char_offset#0 ] Attempting to uplift remaining variables inzp[1]:94 [ mulf8s_prepared::b#0 ] -Uplifting [mulf8s_prepared] best 6246433 combination zp[1]:94 [ mulf8s_prepared::b#0 ] +Uplifting [mulf8s_prepared] best 3955147 combination zp[1]:94 [ mulf8s_prepared::b#0 ] Coalescing zero page register [ zp[2]:10 [ mulf8s_prepared::m#4 mulf8s_prepared::m#5 mulf8s_prepared::m#1 mulf8s_prepared::m#0 mulf8s_prepared::m#2 ] ] with [ zp[2]:95 [ mulf8s::return#0 ] ] - score: 1 Coalescing zero page register [ zp[2]:10 [ mulf8s_prepared::m#4 mulf8s_prepared::m#5 mulf8s_prepared::m#1 mulf8s_prepared::m#0 mulf8s_prepared::m#2 mulf8s::return#0 ] ] with [ zp[2]:98 [ mulf8u_prepared::return#2 ] ] - score: 1 Coalescing zero page register [ zp[2]:24 [ prepareBobs::bob_glyph#2 prepareBobs::bob_glyph#1 ] ] with [ zp[2]:29 [ bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::bob_glyph#1 ] ] - score: 1 @@ -7550,12 +7504,11 @@ Coalescing zero page register [ zp[1]:20 [ progress_idx#16 progress_idx#31 progr Coalescing zero page register [ zp[1]:21 [ prepareBobs::bob_table_idx#6 prepareBobs::bob_table_idx#12 prepareBobs::bob_table_idx#1 ] ] with [ zp[1]:4 [ main::a#2 main::a#6 main::a#1 ] ] Coalescing zero page register [ zp[1]:22 [ prepareBobs::shift_x#2 prepareBobs::shift_x#1 ] ] with [ zp[1]:7 [ main::i#2 main::i#1 ] ] Coalescing zero page register [ zp[1]:37 [ shiftProtoBobRight::i#2 shiftProtoBobRight::i#1 ] ] with [ zp[1]:23 [ prepareBobs::cell#2 prepareBobs::cell#1 ] ] -Coalescing zero page register [ zp[1]:40 [ shiftProtoBobRight::carry#1 ] ] with [ zp[1]:31 [ bobCharsetFindOrAddGlyph::glyph_id#11 bobCharsetFindOrAddGlyph::glyph_id#1 ] ] Coalescing zero page register [ zp[2]:42 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_lo#1 ] ] with [ zp[2]:24 [ prepareBobs::bob_glyph#2 prepareBobs::bob_glyph#1 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::bob_glyph#1 ] ] Coalescing zero page register [ zp[1]:44 [ mulf_init::c#2 mulf_init::c#1 ] ] with [ zp[1]:28 [ bob_charset_next_id#23 bob_charset_next_id#14 bob_charset_next_id#16 bob_charset_next_id#30 bob_charset_next_id#21 bob_charset_next_id#8 ] ] Coalescing zero page register [ zp[2]:45 [ mulf_init::sqr1_hi#2 mulf_init::sqr1_hi#1 ] ] with [ zp[2]:26 [ prepareBobs::bob_table#2 prepareBobs::bob_table#1 prepareBobs::bob_table#0 ] ] Coalescing zero page register [ zp[2]:48 [ mulf_init::sqr2_lo#2 mulf_init::sqr2_lo#1 ] ] with [ zp[2]:32 [ bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::glyph_cursor#1 ] ] -Coalescing zero page register [ zp[1]:53 [ mulf_init::dir#2 mulf_init::dir#4 ] ] with [ zp[1]:35 [ bobCharsetFindOrAddGlyph::i#2 bobCharsetFindOrAddGlyph::i#1 ] ] +Coalescing zero page register [ zp[1]:53 [ mulf_init::dir#2 mulf_init::dir#4 ] ] with [ zp[1]:40 [ shiftProtoBobRight::carry#1 ] ] Coalescing zero page register [ zp[2]:60 [ main::x#0 ] ] with [ zp[2]:51 [ mulf_init::sqr2_hi#2 mulf_init::sqr2_hi#1 ] ] Coalescing zero page register [ zp[2]:83 [ renderBob::y_offset#0 renderBob::$2 renderBob::screen#0 ] ] with [ zp[2]:54 [ mulf_init::sqr#3 mulf_init::sqr#4 mulf_init::sqr#1 mulf_init::sqr#2 ] ] Coalescing zero page register [ zp[1]:94 [ mulf8s_prepared::b#0 ] ] with [ zp[1]:70 [ renderBob::xpos#0 ] ] @@ -7563,8 +7516,8 @@ Coalescing zero page register [ zp[2]:109 [ renderBobInit::$0 renderBobInit::$7 Coalescing zero page register [ zp[2]:42 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_lo#1 prepareBobs::bob_glyph#2 prepareBobs::bob_glyph#1 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::bob_glyph#1 ] ] with [ zp[2]:13 [ memset::dst#2 memset::dst#1 renderBobCleanupNext#17 renderBobCleanupNext#13 ] ] Coalescing zero page register [ zp[1]:80 [ renderBob::x_char_offset#0 ] ] with [ zp[1]:37 [ shiftProtoBobRight::i#2 shiftProtoBobRight::i#1 prepareBobs::cell#2 prepareBobs::cell#1 ] ] Coalescing zero page register [ zp[2]:83 [ renderBob::y_offset#0 renderBob::$2 renderBob::screen#0 mulf_init::sqr#3 mulf_init::sqr#4 mulf_init::sqr#1 mulf_init::sqr#2 ] ] with [ zp[2]:18 [ progress_cursor#15 progress_cursor#31 progress_cursor#24 progress_cursor#17 progress_cursor#8 mulf8s_prepared::m#4 mulf8s_prepared::m#5 mulf8s_prepared::m#1 mulf8s_prepared::m#0 mulf8s_prepared::m#2 mulf8s::return#0 mulf8u_prepared::return#2 mulf8s::return#2 main::$10 mulf8s::return#3 main::$12 mulf8u_prepared::return#0 main::$13 main::y#0 ] ] -Coalescing zero page register [ zp[1]:90 [ renderBob::$5 ] ] with [ zp[1]:40 [ shiftProtoBobRight::carry#1 bobCharsetFindOrAddGlyph::glyph_id#11 bobCharsetFindOrAddGlyph::glyph_id#1 ] ] -Coalescing zero page register [ zp[1]:94 [ mulf8s_prepared::b#0 renderBob::xpos#0 ] ] with [ zp[1]:44 [ mulf_init::c#2 mulf_init::c#1 bob_charset_next_id#23 bob_charset_next_id#14 bob_charset_next_id#16 bob_charset_next_id#30 bob_charset_next_id#21 bob_charset_next_id#8 ] ] +Coalescing zero page register [ zp[1]:90 [ renderBob::$5 ] ] with [ zp[1]:44 [ mulf_init::c#2 mulf_init::c#1 bob_charset_next_id#23 bob_charset_next_id#14 bob_charset_next_id#16 bob_charset_next_id#30 bob_charset_next_id#21 bob_charset_next_id#8 ] ] +Coalescing zero page register [ zp[1]:94 [ mulf8s_prepared::b#0 renderBob::xpos#0 ] ] with [ zp[1]:53 [ mulf_init::dir#2 mulf_init::dir#4 shiftProtoBobRight::carry#1 ] ] Coalescing zero page register [ zp[2]:109 [ renderBobInit::$0 renderBobInit::$7 renderBobInit::$1 renderBobCleanup::screen#0 ] ] with [ zp[2]:45 [ mulf_init::sqr1_hi#2 mulf_init::sqr1_hi#1 prepareBobs::bob_table#2 prepareBobs::bob_table#1 prepareBobs::bob_table#0 ] ] Coalescing zero page register [ zp[2]:111 [ renderBobInit::$6 ] ] with [ zp[2]:48 [ mulf_init::sqr2_lo#2 mulf_init::sqr2_lo#1 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::glyph_cursor#1 ] ] Allocated (was zp[1]:17) zp[1]:2 [ prepareBobs::shift_y#2 prepareBobs::shift_y#1 main::angle#8 main::angle#1 ] @@ -7572,14 +7525,13 @@ Allocated (was zp[1]:20) zp[1]:3 [ progress_idx#16 progress_idx#31 progress_idx# Allocated (was zp[1]:21) zp[1]:4 [ prepareBobs::bob_table_idx#6 prepareBobs::bob_table_idx#12 prepareBobs::bob_table_idx#1 main::a#2 main::a#6 main::a#1 ] Allocated (was zp[1]:22) zp[1]:5 [ prepareBobs::shift_x#2 prepareBobs::shift_x#1 main::i#2 main::i#1 ] Allocated (was zp[2]:42) zp[2]:6 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_lo#1 prepareBobs::bob_glyph#2 prepareBobs::bob_glyph#1 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::bob_glyph#1 memset::dst#2 memset::dst#1 renderBobCleanupNext#17 renderBobCleanupNext#13 ] -Allocated (was zp[1]:53) zp[1]:8 [ mulf_init::dir#2 mulf_init::dir#4 bobCharsetFindOrAddGlyph::i#2 bobCharsetFindOrAddGlyph::i#1 ] -Allocated (was zp[2]:60) zp[2]:9 [ main::x#0 mulf_init::sqr2_hi#2 mulf_init::sqr2_hi#1 ] -Allocated (was zp[1]:80) zp[1]:11 [ renderBob::x_char_offset#0 shiftProtoBobRight::i#2 shiftProtoBobRight::i#1 prepareBobs::cell#2 prepareBobs::cell#1 ] -Allocated (was zp[2]:83) zp[2]:12 [ renderBob::y_offset#0 renderBob::$2 renderBob::screen#0 mulf_init::sqr#3 mulf_init::sqr#4 mulf_init::sqr#1 mulf_init::sqr#2 progress_cursor#15 progress_cursor#31 progress_cursor#24 progress_cursor#17 progress_cursor#8 mulf8s_prepared::m#4 mulf8s_prepared::m#5 mulf8s_prepared::m#1 mulf8s_prepared::m#0 mulf8s_prepared::m#2 mulf8s::return#0 mulf8u_prepared::return#2 mulf8s::return#2 main::$10 mulf8s::return#3 main::$12 mulf8u_prepared::return#0 main::$13 main::y#0 ] -Allocated (was zp[1]:90) zp[1]:14 [ renderBob::$5 shiftProtoBobRight::carry#1 bobCharsetFindOrAddGlyph::glyph_id#11 bobCharsetFindOrAddGlyph::glyph_id#1 ] -Allocated (was zp[1]:94) zp[1]:15 [ mulf8s_prepared::b#0 renderBob::xpos#0 mulf_init::c#2 mulf_init::c#1 bob_charset_next_id#23 bob_charset_next_id#14 bob_charset_next_id#16 bob_charset_next_id#30 bob_charset_next_id#21 bob_charset_next_id#8 ] -Allocated (was zp[2]:109) zp[2]:16 [ renderBobInit::$0 renderBobInit::$7 renderBobInit::$1 renderBobCleanup::screen#0 mulf_init::sqr1_hi#2 mulf_init::sqr1_hi#1 prepareBobs::bob_table#2 prepareBobs::bob_table#1 prepareBobs::bob_table#0 ] -Allocated (was zp[2]:111) zp[2]:18 [ renderBobInit::$6 mulf_init::sqr2_lo#2 mulf_init::sqr2_lo#1 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::glyph_cursor#1 ] +Allocated (was zp[2]:60) zp[2]:8 [ main::x#0 mulf_init::sqr2_hi#2 mulf_init::sqr2_hi#1 ] +Allocated (was zp[1]:80) zp[1]:10 [ renderBob::x_char_offset#0 shiftProtoBobRight::i#2 shiftProtoBobRight::i#1 prepareBobs::cell#2 prepareBobs::cell#1 ] +Allocated (was zp[2]:83) zp[2]:11 [ renderBob::y_offset#0 renderBob::$2 renderBob::screen#0 mulf_init::sqr#3 mulf_init::sqr#4 mulf_init::sqr#1 mulf_init::sqr#2 progress_cursor#15 progress_cursor#31 progress_cursor#24 progress_cursor#17 progress_cursor#8 mulf8s_prepared::m#4 mulf8s_prepared::m#5 mulf8s_prepared::m#1 mulf8s_prepared::m#0 mulf8s_prepared::m#2 mulf8s::return#0 mulf8u_prepared::return#2 mulf8s::return#2 main::$10 mulf8s::return#3 main::$12 mulf8u_prepared::return#0 main::$13 main::y#0 ] +Allocated (was zp[1]:90) zp[1]:13 [ renderBob::$5 mulf_init::c#2 mulf_init::c#1 bob_charset_next_id#23 bob_charset_next_id#14 bob_charset_next_id#16 bob_charset_next_id#30 bob_charset_next_id#21 bob_charset_next_id#8 ] +Allocated (was zp[1]:94) zp[1]:14 [ mulf8s_prepared::b#0 renderBob::xpos#0 mulf_init::dir#2 mulf_init::dir#4 shiftProtoBobRight::carry#1 ] +Allocated (was zp[2]:109) zp[2]:15 [ renderBobInit::$0 renderBobInit::$7 renderBobInit::$1 renderBobCleanup::screen#0 mulf_init::sqr1_hi#2 mulf_init::sqr1_hi#1 prepareBobs::bob_table#2 prepareBobs::bob_table#1 prepareBobs::bob_table#0 ] +Allocated (was zp[2]:111) zp[2]:17 [ renderBobInit::$6 mulf_init::sqr2_lo#2 mulf_init::sqr2_lo#1 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::glyph_cursor#1 ] ASSEMBLER BEFORE OPTIMIZATION // File Comments @@ -7620,35 +7572,27 @@ ASSEMBLER BEFORE OPTIMIZATION .const SIZEOF_POINTER = 2 .label COS = SIN+$40 // BOB charset ID of the next glyph to be added - .label bob_charset_next_id = $f + .label bob_charset_next_id = $d // Current index within the progress cursor (0-7) .label progress_idx = 3 // Current position of the progress cursor - .label progress_cursor = $c + .label progress_cursor = $b // Pointer to the next clean-up to add // Prepare for next clean-up .label renderBobCleanupNext = 6 // @begin __bbegin: + // [1] phi from @begin to @1 [phi:@begin->@1] +__b1_from___bbegin: jmp __b1 // @1 __b1: - // kickasm() {{ .const PHI = (1+sqrt(5))/2 }} - // Constants for KickAsm Vogel Sunflower - .const PHI = (1+sqrt(5))/2 - - - // [2] phi from @1 to @2 [phi:@1->@2] -__b2_from___b1: - jmp __b2 - // @2 -__b2: - // [3] call main - // [5] phi from @2 to main [phi:@2->main] -main_from___b2: + // [2] call main + // [4] phi from @1 to main [phi:@1->main] +main_from___b1: jsr main - // [4] phi from @2 to @end [phi:@2->@end] -__bend_from___b2: + // [3] phi from @1 to @end [phi:@1->@end] +__bend_from___b1: jmp __bend // @end __bend: @@ -7658,45 +7602,45 @@ main: { .const vicSelectGfxBank2_toDd001_return = 3 .const toD0181_return = (>(BOB_SCREEN&$3fff)*4)|(>BOB_CHARSET)/4&$f .const toD0182_return = (>(SCREEN_BASIC&$3fff)*4)|(>CHARSET_BASIC)/4&$f - .label __10 = $c - .label __12 = $c - .label __13 = $c - .label x = 9 - .label y = $c + .label __10 = $b + .label __12 = $b + .label __13 = $b + .label x = 8 + .label y = $b .label a = 4 .label r = 3 .label i = 5 // Render Rotated BOBs .label angle = 2 - // [6] call mulf_init - // [244] phi from main to mulf_init [phi:main->mulf_init] + // [5] call mulf_init + // [243] phi from main to mulf_init [phi:main->mulf_init] mulf_init_from_main: jsr mulf_init - // [7] phi from main to main::@9 [phi:main->main::@9] + // [6] phi from main to main::@9 [phi:main->main::@9] __b9_from_main: jmp __b9 // main::@9 __b9: - // [8] call prepareBobs - // [160] phi from main::@9 to prepareBobs [phi:main::@9->prepareBobs] + // [7] call prepareBobs + // [159] phi from main::@9 to prepareBobs [phi:main::@9->prepareBobs] prepareBobs_from___b9: jsr prepareBobs - // [9] phi from main::@9 to main::@10 [phi:main::@9->main::@10] + // [8] phi from main::@9 to main::@10 [phi:main::@9->main::@10] __b10_from___b9: jmp __b10 // main::@10 __b10: - // [10] call renderBobInit - // [144] phi from main::@10 to renderBobInit [phi:main::@10->renderBobInit] + // [9] call renderBobInit + // [143] phi from main::@10 to renderBobInit [phi:main::@10->renderBobInit] renderBobInit_from___b10: jsr renderBobInit jmp vicSelectGfxBank1 // main::vicSelectGfxBank1 vicSelectGfxBank1: - // [11] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 -- _deref_pbuc1=vbuc2 + // [10] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 -- _deref_pbuc1=vbuc2 lda #3 sta CIA2_PORT_A_DDR - // [12] phi from main::vicSelectGfxBank1 to main::vicSelectGfxBank1_toDd001 [phi:main::vicSelectGfxBank1->main::vicSelectGfxBank1_toDd001] + // [11] phi from main::vicSelectGfxBank1 to main::vicSelectGfxBank1_toDd001 [phi:main::vicSelectGfxBank1->main::vicSelectGfxBank1_toDd001] vicSelectGfxBank1_toDd001_from_vicSelectGfxBank1: jmp vicSelectGfxBank1_toDd001 // main::vicSelectGfxBank1_toDd001 @@ -7704,10 +7648,10 @@ main: { jmp vicSelectGfxBank1___b1 // main::vicSelectGfxBank1_@1 vicSelectGfxBank1___b1: - // [13] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank1_toDd001_return#0 -- _deref_pbuc1=vbuc2 + // [12] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank1_toDd001_return#0 -- _deref_pbuc1=vbuc2 lda #vicSelectGfxBank1_toDd001_return sta CIA2_PORT_A - // [14] phi from main::vicSelectGfxBank1_@1 to main::toD0181 [phi:main::vicSelectGfxBank1_@1->main::toD0181] + // [13] phi from main::vicSelectGfxBank1_@1 to main::toD0181 [phi:main::vicSelectGfxBank1_@1->main::toD0181] toD0181_from_vicSelectGfxBank1___b1: jmp toD0181 // main::toD0181 @@ -7715,16 +7659,16 @@ main: { jmp __b7 // main::@7 __b7: - // [15] *((const byte*) D018) ← (const byte) main::toD0181_return#0 -- _deref_pbuc1=vbuc2 + // [14] *((const byte*) D018) ← (const byte) main::toD0181_return#0 -- _deref_pbuc1=vbuc2 lda #toD0181_return sta D018 - // [16] call memset - // [138] phi from main::@7 to memset [phi:main::@7->memset] + // [15] call memset + // [137] phi from main::@7 to memset [phi:main::@7->memset] memset_from___b7: jsr memset - // [17] phi from main::@7 to main::@1 [phi:main::@7->main::@1] + // [16] phi from main::@7 to main::@1 [phi:main::@7->main::@1] __b1_from___b7: - // [17] phi (byte) main::angle#8 = (byte) 0 [phi:main::@7->main::@1#0] -- vbuz1=vbuc1 + // [16] phi (byte) main::angle#8 = (byte) 0 [phi:main::@7->main::@1#0] -- vbuz1=vbuc1 lda #0 sta.z angle jmp __b1 @@ -7733,71 +7677,71 @@ main: { jmp __b2 // main::@2 __b2: - // [18] if(*((const byte*) RASTER)<(byte) $f8) goto main::@2 -- _deref_pbuc1_lt_vbuc2_then_la1 + // [17] if(*((const byte*) RASTER)<(byte) $f8) goto main::@2 -- _deref_pbuc1_lt_vbuc2_then_la1 lda RASTER cmp #$f8 bcc __b2 jmp __b3 // main::@3 __b3: - // [19] *((const byte*) BORDERCOL) ← (byte) $f -- _deref_pbuc1=vbuc2 + // [18] *((const byte*) BORDERCOL) ← (byte) $f -- _deref_pbuc1=vbuc2 lda #$f sta BORDERCOL - // [20] call renderBobCleanup - // [122] phi from main::@3 to renderBobCleanup [phi:main::@3->renderBobCleanup] + // [19] call renderBobCleanup + // [121] phi from main::@3 to renderBobCleanup [phi:main::@3->renderBobCleanup] renderBobCleanup_from___b3: jsr renderBobCleanup jmp __b11 // main::@11 __b11: - // [21] (byte) main::a#6 ← (byte) main::angle#8 -- vbuz1=vbuz2 + // [20] (byte) main::a#6 ← (byte) main::angle#8 -- vbuz1=vbuz2 lda.z angle sta.z a - // [22] phi from main::@11 to main::@4 [phi:main::@11->main::@4] + // [21] phi from main::@11 to main::@4 [phi:main::@11->main::@4] __b4_from___b11: - // [22] phi (byte) main::i#2 = (byte) 0 [phi:main::@11->main::@4#0] -- vbuz1=vbuc1 + // [21] phi (byte) main::i#2 = (byte) 0 [phi:main::@11->main::@4#0] -- vbuz1=vbuc1 lda #0 sta.z i - // [22] phi (byte**) renderBobCleanupNext#17 = (const byte**) RENDERBOB_CLEANUP [phi:main::@11->main::@4#1] -- pptz1=pptc1 + // [21] phi (byte**) renderBobCleanupNext#17 = (const byte**) RENDERBOB_CLEANUP [phi:main::@11->main::@4#1] -- pptz1=pptc1 lda #RENDERBOB_CLEANUP sta.z renderBobCleanupNext+1 - // [22] phi (byte) main::a#2 = (byte) main::a#6 [phi:main::@11->main::@4#2] -- register_copy - // [22] phi (signed byte) main::r#2 = (signed byte) $1e [phi:main::@11->main::@4#3] -- vbsz1=vbsc1 + // [21] phi (byte) main::a#2 = (byte) main::a#6 [phi:main::@11->main::@4#2] -- register_copy + // [21] phi (signed byte) main::r#2 = (signed byte) $1e [phi:main::@11->main::@4#3] -- vbsz1=vbsc1 lda #$1e sta.z r jmp __b4 - // [22] phi from main::@14 to main::@4 [phi:main::@14->main::@4] + // [21] phi from main::@14 to main::@4 [phi:main::@14->main::@4] __b4_from___b14: - // [22] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@14->main::@4#0] -- register_copy - // [22] phi (byte**) renderBobCleanupNext#17 = (byte**) renderBobCleanupNext#13 [phi:main::@14->main::@4#1] -- register_copy - // [22] phi (byte) main::a#2 = (byte) main::a#1 [phi:main::@14->main::@4#2] -- register_copy - // [22] phi (signed byte) main::r#2 = (signed byte) main::r#1 [phi:main::@14->main::@4#3] -- register_copy + // [21] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@14->main::@4#0] -- register_copy + // [21] phi (byte**) renderBobCleanupNext#17 = (byte**) renderBobCleanupNext#13 [phi:main::@14->main::@4#1] -- register_copy + // [21] phi (byte) main::a#2 = (byte) main::a#1 [phi:main::@14->main::@4#2] -- register_copy + // [21] phi (signed byte) main::r#2 = (signed byte) main::r#1 [phi:main::@14->main::@4#3] -- register_copy jmp __b4 // main::@4 __b4: - // [23] *((const byte*) BORDERCOL) ← (byte) 1 -- _deref_pbuc1=vbuc2 + // [22] *((const byte*) BORDERCOL) ← (byte) 1 -- _deref_pbuc1=vbuc2 //kickasm {{ .break }} lda #1 sta BORDERCOL - // [24] (signed byte) mulf8s::a#0 ← (signed byte) main::r#2 -- vbsaa=vbsz1 + // [23] (signed byte) mulf8s::a#0 ← (signed byte) main::r#2 -- vbsaa=vbsz1 lda.z r - // [25] (signed byte) mulf8s::b#0 ← *((const signed byte*) COS + (byte) main::a#2) -- vbsxx=pbsc1_derefidx_vbuz1 + // [24] (signed byte) mulf8s::b#0 ← *((const signed byte*) COS + (byte) main::a#2) -- vbsxx=pbsc1_derefidx_vbuz1 ldy.z a ldx COS,y - // [26] call mulf8s - // [93] phi from main::@4 to mulf8s [phi:main::@4->mulf8s] + // [25] call mulf8s + // [92] phi from main::@4 to mulf8s [phi:main::@4->mulf8s] mulf8s_from___b4: - // [93] phi (signed byte) mulf8s::b#2 = (signed byte) mulf8s::b#0 [phi:main::@4->mulf8s#0] -- register_copy - // [93] phi (signed byte) mulf8s::mulf8s_prepare1_a#0 = (signed byte) mulf8s::a#0 [phi:main::@4->mulf8s#1] -- register_copy + // [92] phi (signed byte) mulf8s::b#2 = (signed byte) mulf8s::b#0 [phi:main::@4->mulf8s#0] -- register_copy + // [92] phi (signed byte) mulf8s::mulf8s_prepare1_a#0 = (signed byte) mulf8s::a#0 [phi:main::@4->mulf8s#1] -- register_copy jsr mulf8s - // [27] (signed word) mulf8s::return#2 ← (signed word) mulf8s::return#0 + // [26] (signed word) mulf8s::return#2 ← (signed word) mulf8s::return#0 jmp __b12 // main::@12 __b12: - // [28] (signed word~) main::$10 ← (signed word) mulf8s::return#2 - // [29] (signed word) main::x#0 ← (signed word~) main::$10 + (signed word)(number) $4b*(number) $100 -- vwsz1=vwsz2_plus_vwsc1 + // [27] (signed word~) main::$10 ← (signed word) mulf8s::return#2 + // [28] (signed word) main::x#0 ← (signed word~) main::$10 + (signed word)(number) $4b*(number) $100 -- vwsz1=vwsz2_plus_vwsc1 lda.z __10 clc adc #<$4b*$100 @@ -7805,26 +7749,26 @@ main: { lda.z __10+1 adc #>$4b*$100 sta.z x+1 - // [30] (signed byte) mulf8s::a#1 ← (signed byte) main::r#2 -- vbsaa=vbsz1 + // [29] (signed byte) mulf8s::a#1 ← (signed byte) main::r#2 -- vbsaa=vbsz1 lda.z r - // [31] (signed byte) mulf8s::b#1 ← *((const signed byte*) SIN + (byte) main::a#2) -- vbsxx=pbsc1_derefidx_vbuz1 + // [30] (signed byte) mulf8s::b#1 ← *((const signed byte*) SIN + (byte) main::a#2) -- vbsxx=pbsc1_derefidx_vbuz1 ldy.z a ldx SIN,y - // [32] call mulf8s - // [93] phi from main::@12 to mulf8s [phi:main::@12->mulf8s] + // [31] call mulf8s + // [92] phi from main::@12 to mulf8s [phi:main::@12->mulf8s] mulf8s_from___b12: - // [93] phi (signed byte) mulf8s::b#2 = (signed byte) mulf8s::b#1 [phi:main::@12->mulf8s#0] -- register_copy - // [93] phi (signed byte) mulf8s::mulf8s_prepare1_a#0 = (signed byte) mulf8s::a#1 [phi:main::@12->mulf8s#1] -- register_copy + // [92] phi (signed byte) mulf8s::b#2 = (signed byte) mulf8s::b#1 [phi:main::@12->mulf8s#0] -- register_copy + // [92] phi (signed byte) mulf8s::mulf8s_prepare1_a#0 = (signed byte) mulf8s::a#1 [phi:main::@12->mulf8s#1] -- register_copy jsr mulf8s - // [33] (signed word) mulf8s::return#3 ← (signed word) mulf8s::return#0 + // [32] (signed word) mulf8s::return#3 ← (signed word) mulf8s::return#0 jmp __b13 // main::@13 __b13: - // [34] (signed word~) main::$12 ← (signed word) mulf8s::return#3 - // [35] (signed word~) main::$13 ← (signed word~) main::$12 << (byte) 1 -- vwsz1=vwsz1_rol_1 + // [33] (signed word~) main::$12 ← (signed word) mulf8s::return#3 + // [34] (signed word~) main::$13 ← (signed word~) main::$12 << (byte) 1 -- vwsz1=vwsz1_rol_1 asl.z __13 rol.z __13+1 - // [36] (signed word) main::y#0 ← (signed word~) main::$13 + (signed word)(number) $5a*(number) $100 -- vwsz1=vwsz1_plus_vwsc1 + // [35] (signed word) main::y#0 ← (signed word~) main::$13 + (signed word)(number) $5a*(number) $100 -- vwsz1=vwsz1_plus_vwsc1 clc lda.z y adc #<$5a*$100 @@ -7832,86 +7776,86 @@ main: { lda.z y+1 adc #>$5a*$100 sta.z y+1 - // [37] *((const byte*) BORDERCOL) ← (byte) 2 -- _deref_pbuc1=vbuc2 + // [36] *((const byte*) BORDERCOL) ← (byte) 2 -- _deref_pbuc1=vbuc2 lda #2 sta BORDERCOL - // [38] (byte) main::a#1 ← (byte) main::a#2 + (byte) $62 -- vbuz1=vbuz1_plus_vbuc1 + // [37] (byte) main::a#1 ← (byte) main::a#2 + (byte) $62 -- vbuz1=vbuz1_plus_vbuc1 lax.z a axs #-[$62] stx.z a - // [39] (signed byte) main::r#1 ← (signed byte) main::r#2 + (signed byte) 3 -- vbsz1=vbsz1_plus_vbsc1 + // [38] (signed byte) main::r#1 ← (signed byte) main::r#2 + (signed byte) 3 -- vbsz1=vbsz1_plus_vbsc1 lax.z r axs #-[3] stx.z r - // [40] (byte) renderBob::xpos#0 ← > (signed word) main::x#0 -- vbuz1=_hi_vwsz2 + // [39] (byte) renderBob::xpos#0 ← > (signed word) main::x#0 -- vbuz1=_hi_vwsz2 lda.z x+1 sta.z renderBob.xpos - // [41] (byte) renderBob::ypos#0 ← > (signed word) main::y#0 -- vbuxx=_hi_vwsz1 + // [40] (byte) renderBob::ypos#0 ← > (signed word) main::y#0 -- vbuxx=_hi_vwsz1 lda.z y+1 tax - // [42] call renderBob + // [41] call renderBob jsr renderBob jmp __b14 // main::@14 __b14: - // [43] (byte) main::i#1 ← ++ (byte) main::i#2 -- vbuz1=_inc_vbuz1 + // [42] (byte) main::i#1 ← ++ (byte) main::i#2 -- vbuz1=_inc_vbuz1 inc.z i - // [44] if((byte) main::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto main::@4 -- vbuz1_neq_vbuc1_then_la1 + // [43] if((byte) main::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto main::@4 -- vbuz1_neq_vbuc1_then_la1 lda #NUM_BOBS-1+1 cmp.z i bne __b4_from___b14 jmp __b5 // main::@5 __b5: - // [45] (byte) main::angle#1 ← (byte) main::angle#8 + (byte) 3 -- vbuz1=vbuz1_plus_vbuc1 + // [44] (byte) main::angle#1 ← (byte) main::angle#8 + (byte) 3 -- vbuz1=vbuz1_plus_vbuc1 lax.z angle axs #-[3] stx.z angle - // [46] *((const byte*) BORDERCOL) ← (byte) 0 -- _deref_pbuc1=vbuc2 + // [45] *((const byte*) BORDERCOL) ← (byte) 0 -- _deref_pbuc1=vbuc2 lda #0 sta BORDERCOL - // [47] call keyboard_key_pressed - // [62] phi from main::@5 to keyboard_key_pressed [phi:main::@5->keyboard_key_pressed] + // [46] call keyboard_key_pressed + // [61] phi from main::@5 to keyboard_key_pressed [phi:main::@5->keyboard_key_pressed] keyboard_key_pressed_from___b5: jsr keyboard_key_pressed - // [48] (byte) keyboard_key_pressed::return#2 ← (byte) keyboard_key_pressed::return#0 + // [47] (byte) keyboard_key_pressed::return#2 ← (byte) keyboard_key_pressed::return#0 jmp __b15 // main::@15 __b15: - // [49] (byte~) main::$19 ← (byte) keyboard_key_pressed::return#2 - // [50] if((byte) 0!=(byte~) main::$19) goto main::@6 -- vbuc1_neq_vbuaa_then_la1 + // [48] (byte~) main::$19 ← (byte) keyboard_key_pressed::return#2 + // [49] if((byte) 0!=(byte~) main::$19) goto main::@6 -- vbuc1_neq_vbuaa_then_la1 cmp #0 bne __b6_from___b15 - // [17] phi from main::@15 to main::@1 [phi:main::@15->main::@1] + // [16] phi from main::@15 to main::@1 [phi:main::@15->main::@1] __b1_from___b15: - // [17] phi (byte) main::angle#8 = (byte) main::angle#1 [phi:main::@15->main::@1#0] -- register_copy + // [16] phi (byte) main::angle#8 = (byte) main::angle#1 [phi:main::@15->main::@1#0] -- register_copy jmp __b1 // Wait for space release - // [51] phi from main::@15 main::@16 to main::@6 [phi:main::@15/main::@16->main::@6] + // [50] phi from main::@15 main::@16 to main::@6 [phi:main::@15/main::@16->main::@6] __b6_from___b15: __b6_from___b16: jmp __b6 // main::@6 __b6: - // [52] call keyboard_key_pressed - // [62] phi from main::@6 to keyboard_key_pressed [phi:main::@6->keyboard_key_pressed] + // [51] call keyboard_key_pressed + // [61] phi from main::@6 to keyboard_key_pressed [phi:main::@6->keyboard_key_pressed] keyboard_key_pressed_from___b6: jsr keyboard_key_pressed - // [53] (byte) keyboard_key_pressed::return#3 ← (byte) keyboard_key_pressed::return#0 + // [52] (byte) keyboard_key_pressed::return#3 ← (byte) keyboard_key_pressed::return#0 jmp __b16 // main::@16 __b16: - // [54] (byte~) main::$21 ← (byte) keyboard_key_pressed::return#3 - // [55] if((byte) 0!=(byte~) main::$21) goto main::@6 -- vbuc1_neq_vbuaa_then_la1 + // [53] (byte~) main::$21 ← (byte) keyboard_key_pressed::return#3 + // [54] if((byte) 0!=(byte~) main::$21) goto main::@6 -- vbuc1_neq_vbuaa_then_la1 cmp #0 bne __b6_from___b16 jmp vicSelectGfxBank2 // main::vicSelectGfxBank2 vicSelectGfxBank2: - // [56] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 -- _deref_pbuc1=vbuc2 + // [55] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 -- _deref_pbuc1=vbuc2 lda #3 sta CIA2_PORT_A_DDR - // [57] phi from main::vicSelectGfxBank2 to main::vicSelectGfxBank2_toDd001 [phi:main::vicSelectGfxBank2->main::vicSelectGfxBank2_toDd001] + // [56] phi from main::vicSelectGfxBank2 to main::vicSelectGfxBank2_toDd001 [phi:main::vicSelectGfxBank2->main::vicSelectGfxBank2_toDd001] vicSelectGfxBank2_toDd001_from_vicSelectGfxBank2: jmp vicSelectGfxBank2_toDd001 // main::vicSelectGfxBank2_toDd001 @@ -7919,10 +7863,10 @@ main: { jmp vicSelectGfxBank2___b1 // main::vicSelectGfxBank2_@1 vicSelectGfxBank2___b1: - // [58] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank2_toDd001_return#0 -- _deref_pbuc1=vbuc2 + // [57] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank2_toDd001_return#0 -- _deref_pbuc1=vbuc2 lda #vicSelectGfxBank2_toDd001_return sta CIA2_PORT_A - // [59] phi from main::vicSelectGfxBank2_@1 to main::toD0182 [phi:main::vicSelectGfxBank2_@1->main::toD0182] + // [58] phi from main::vicSelectGfxBank2_@1 to main::toD0182 [phi:main::vicSelectGfxBank2_@1->main::toD0182] toD0182_from_vicSelectGfxBank2___b1: jmp toD0182 // main::toD0182 @@ -7930,13 +7874,13 @@ main: { jmp __b8 // main::@8 __b8: - // [60] *((const byte*) D018) ← (const byte) main::toD0182_return#0 -- _deref_pbuc1=vbuc2 + // [59] *((const byte*) D018) ← (const byte) main::toD0182_return#0 -- _deref_pbuc1=vbuc2 lda #toD0182_return sta D018 jmp __breturn // main::@return __breturn: - // [61] return + // [60] return rts } // keyboard_key_pressed @@ -7947,19 +7891,19 @@ main: { keyboard_key_pressed: { .const colidx = KEY_SPACE&7 .label rowidx = KEY_SPACE>>3 - // [63] call keyboard_matrix_read + // [62] call keyboard_matrix_read jsr keyboard_matrix_read - // [64] (byte) keyboard_matrix_read::return#2 ← (byte) keyboard_matrix_read::return#0 + // [63] (byte) keyboard_matrix_read::return#2 ← (byte) keyboard_matrix_read::return#0 jmp __b1 // keyboard_key_pressed::@1 __b1: - // [65] (byte~) keyboard_key_pressed::$2 ← (byte) keyboard_matrix_read::return#2 - // [66] (byte) keyboard_key_pressed::return#0 ← (byte~) keyboard_key_pressed::$2 & *((const byte*) keyboard_matrix_col_bitmask+(const byte) keyboard_key_pressed::colidx#0) -- vbuaa=vbuaa_band__deref_pbuc1 + // [64] (byte~) keyboard_key_pressed::$2 ← (byte) keyboard_matrix_read::return#2 + // [65] (byte) keyboard_key_pressed::return#0 ← (byte~) keyboard_key_pressed::$2 & *((const byte*) keyboard_matrix_col_bitmask+(const byte) keyboard_key_pressed::colidx#0) -- vbuaa=vbuaa_band__deref_pbuc1 and keyboard_matrix_col_bitmask+colidx jmp __breturn // keyboard_key_pressed::@return __breturn: - // [67] return + // [66] return rts } // keyboard_matrix_read @@ -7969,49 +7913,49 @@ keyboard_key_pressed: { // Notice: If the C64 normal interrupt is still running it will occasionally interrupt right between the read & write // leading to erroneous readings. You must disable kill the normal interrupt or sei/cli around calls to the keyboard matrix reader. keyboard_matrix_read: { - // [68] *((const byte*) CIA1_PORT_A) ← *((const byte*) keyboard_matrix_row_bitmask+(const byte) keyboard_key_pressed::rowidx#0) -- _deref_pbuc1=_deref_pbuc2 + // [67] *((const byte*) CIA1_PORT_A) ← *((const byte*) keyboard_matrix_row_bitmask+(const byte) keyboard_key_pressed::rowidx#0) -- _deref_pbuc1=_deref_pbuc2 lda keyboard_matrix_row_bitmask+keyboard_key_pressed.rowidx sta CIA1_PORT_A - // [69] (byte) keyboard_matrix_read::return#0 ← ~ *((const byte*) CIA1_PORT_B) -- vbuaa=_bnot__deref_pbuc1 + // [68] (byte) keyboard_matrix_read::return#0 ← ~ *((const byte*) CIA1_PORT_B) -- vbuaa=_bnot__deref_pbuc1 lda CIA1_PORT_B eor #$ff jmp __breturn // keyboard_matrix_read::@return __breturn: - // [70] return + // [69] return rts } // renderBob // Render a single BOB at a given x/y-position // X-position is 0-151. Each x-position is 2 pixels wide. // Y-position is 0-183. Each y-position is 1 pixel high. -// renderBob(byte zeropage($f) xpos, byte register(X) ypos) +// renderBob(byte zeropage($e) xpos, byte register(X) ypos) renderBob: { - .label __2 = $c - .label __5 = $e - .label xpos = $f - .label x_char_offset = $b - .label y_offset = $c - .label screen = $c - // [71] (byte) renderBob::x_char_offset#0 ← (byte) renderBob::xpos#0 >> (byte) 2 -- vbuz1=vbuz2_ror_2 + .label __2 = $b + .label __5 = $d + .label xpos = $e + .label x_char_offset = $a + .label y_offset = $b + .label screen = $b + // [70] (byte) renderBob::x_char_offset#0 ← (byte) renderBob::xpos#0 >> (byte) 2 -- vbuz1=vbuz2_ror_2 lda.z xpos lsr lsr sta.z x_char_offset - // [72] (byte) renderBob::y_char_offset#0 ← (byte) renderBob::ypos#0 >> (byte) 3 -- vbuaa=vbuxx_ror_3 + // [71] (byte) renderBob::y_char_offset#0 ← (byte) renderBob::ypos#0 >> (byte) 3 -- vbuaa=vbuxx_ror_3 txa lsr lsr lsr - // [73] (byte~) renderBob::$8 ← (byte) renderBob::y_char_offset#0 << (byte) 1 -- vbuaa=vbuaa_rol_1 + // [72] (byte~) renderBob::$8 ← (byte) renderBob::y_char_offset#0 << (byte) 1 -- vbuaa=vbuaa_rol_1 asl - // [74] (word) renderBob::y_offset#0 ← *((const word*) MUL40 + (byte~) renderBob::$8) -- vwuz1=pwuc1_derefidx_vbuaa + // [73] (word) renderBob::y_offset#0 ← *((const word*) MUL40 + (byte~) renderBob::$8) -- vwuz1=pwuc1_derefidx_vbuaa tay lda MUL40,y sta.z y_offset lda MUL40+1,y sta.z y_offset+1 - // [75] (byte*~) renderBob::$2 ← (const byte*) BOB_SCREEN + (word) renderBob::y_offset#0 -- pbuz1=pbuc1_plus_vwuz1 + // [74] (byte*~) renderBob::$2 ← (const byte*) BOB_SCREEN + (word) renderBob::y_offset#0 -- pbuz1=pbuc1_plus_vwuz1 clc lda.z __2 adc #BOB_SCREEN sta.z __2+1 - // [76] (byte*) renderBob::screen#0 ← (byte*~) renderBob::$2 + (byte) renderBob::x_char_offset#0 -- pbuz1=pbuz1_plus_vbuz2 + // [75] (byte*) renderBob::screen#0 ← (byte*~) renderBob::$2 + (byte) renderBob::x_char_offset#0 -- pbuz1=pbuz1_plus_vbuz2 lda.z x_char_offset clc adc.z screen @@ -8027,28 +7971,28 @@ renderBob: { bcc !+ inc.z screen+1 !: - // [77] (byte~) renderBob::$4 ← (byte) renderBob::ypos#0 & (byte) 7 -- vbuaa=vbuxx_band_vbuc1 + // [76] (byte~) renderBob::$4 ← (byte) renderBob::ypos#0 & (byte) 7 -- vbuaa=vbuxx_band_vbuc1 txa and #7 - // [78] (byte~) renderBob::$5 ← (byte~) renderBob::$4 << (byte) 2 -- vbuz1=vbuaa_rol_2 + // [77] (byte~) renderBob::$5 ← (byte~) renderBob::$4 << (byte) 2 -- vbuz1=vbuaa_rol_2 asl asl sta.z __5 - // [79] (byte~) renderBob::$6 ← (byte) renderBob::xpos#0 & (byte) 3 -- vbuaa=vbuz1_band_vbuc1 + // [78] (byte~) renderBob::$6 ← (byte) renderBob::xpos#0 & (byte) 3 -- vbuaa=vbuz1_band_vbuc1 lda #3 and.z xpos - // [80] (byte) renderBob::bob_table_idx#0 ← (byte~) renderBob::$5 + (byte~) renderBob::$6 -- vbuxx=vbuz1_plus_vbuaa + // [79] (byte) renderBob::bob_table_idx#0 ← (byte~) renderBob::$5 + (byte~) renderBob::$6 -- vbuxx=vbuz1_plus_vbuaa clc adc.z __5 tax - // [81] *((byte**) renderBobCleanupNext#17) ← (byte*) renderBob::screen#0 -- _deref_pptz1=pbuz2 + // [80] *((byte**) renderBobCleanupNext#17) ← (byte*) renderBob::screen#0 -- _deref_pptz1=pbuz2 ldy #0 lda.z screen sta (renderBobCleanupNext),y iny lda.z screen+1 sta (renderBobCleanupNext),y - // [82] (byte**) renderBobCleanupNext#13 ← (byte**) renderBobCleanupNext#17 + (const byte) SIZEOF_POINTER -- pptz1=pptz1_plus_vbuc1 + // [81] (byte**) renderBobCleanupNext#13 ← (byte**) renderBobCleanupNext#17 + (const byte) SIZEOF_POINTER -- pptz1=pptz1_plus_vbuc1 lda #SIZEOF_POINTER clc adc.z renderBobCleanupNext @@ -8056,139 +8000,139 @@ renderBob: { bcc !+ inc.z renderBobCleanupNext+1 !: - // [83] *((byte*) renderBob::screen#0) ← *((const byte*) BOB_TABLES + (byte) renderBob::bob_table_idx#0) -- _deref_pbuz1=pbuc1_derefidx_vbuxx + // [82] *((byte*) renderBob::screen#0) ← *((const byte*) BOB_TABLES + (byte) renderBob::bob_table_idx#0) -- _deref_pbuz1=pbuc1_derefidx_vbuxx lda BOB_TABLES,x ldy #0 sta (screen),y - // [84] *((byte*) renderBob::screen#0 + (byte) $28) ← *((const byte*) BOB_TABLES+(byte) 1*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx + // [83] *((byte*) renderBob::screen#0 + (byte) $28) ← *((const byte*) BOB_TABLES+(byte) 1*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx lda BOB_TABLES+1*BOB_SUBTABLE_SIZE,x ldy #$28 sta (screen),y - // [85] *((byte*) renderBob::screen#0 + (byte) $50) ← *((const byte*) BOB_TABLES+(byte) 2*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx + // [84] *((byte*) renderBob::screen#0 + (byte) $50) ← *((const byte*) BOB_TABLES+(byte) 2*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx lda BOB_TABLES+2*BOB_SUBTABLE_SIZE,x ldy #$50 sta (screen),y - // [86] *((byte*) renderBob::screen#0 + (byte) 1) ← *((const byte*) BOB_TABLES+(byte) 3*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx + // [85] *((byte*) renderBob::screen#0 + (byte) 1) ← *((const byte*) BOB_TABLES+(byte) 3*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx lda BOB_TABLES+3*BOB_SUBTABLE_SIZE,x ldy #1 sta (screen),y - // [87] *((byte*) renderBob::screen#0 + (byte) $29) ← *((const byte*) BOB_TABLES+(byte) 4*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx + // [86] *((byte*) renderBob::screen#0 + (byte) $29) ← *((const byte*) BOB_TABLES+(byte) 4*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx lda BOB_TABLES+4*BOB_SUBTABLE_SIZE,x ldy #$29 sta (screen),y - // [88] *((byte*) renderBob::screen#0 + (byte) $51) ← *((const byte*) BOB_TABLES+(byte) 5*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx + // [87] *((byte*) renderBob::screen#0 + (byte) $51) ← *((const byte*) BOB_TABLES+(byte) 5*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx lda BOB_TABLES+5*BOB_SUBTABLE_SIZE,x ldy #$51 sta (screen),y - // [89] *((byte*) renderBob::screen#0 + (byte) 2) ← *((const byte*) BOB_TABLES+(byte) 6*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx + // [88] *((byte*) renderBob::screen#0 + (byte) 2) ← *((const byte*) BOB_TABLES+(byte) 6*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx lda BOB_TABLES+6*BOB_SUBTABLE_SIZE,x ldy #2 sta (screen),y - // [90] *((byte*) renderBob::screen#0 + (byte) $2a) ← *((const byte*) BOB_TABLES+(byte) 7*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx + // [89] *((byte*) renderBob::screen#0 + (byte) $2a) ← *((const byte*) BOB_TABLES+(byte) 7*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx lda BOB_TABLES+7*BOB_SUBTABLE_SIZE,x ldy #$2a sta (screen),y - // [91] *((byte*) renderBob::screen#0 + (byte) $52) ← *((const byte*) BOB_TABLES+(byte) 8*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx + // [90] *((byte*) renderBob::screen#0 + (byte) $52) ← *((const byte*) BOB_TABLES+(byte) 8*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx lda BOB_TABLES+8*BOB_SUBTABLE_SIZE,x ldy #$52 sta (screen),y jmp __breturn // renderBob::@return __breturn: - // [92] return + // [91] return rts } // mulf8s // Fast multiply two signed bytes to a word result // mulf8s(signed byte register(A) a, signed byte register(X) b) mulf8s: { - .label return = $c + .label return = $b jmp mulf8s_prepare1 // mulf8s::mulf8s_prepare1 mulf8s_prepare1: - // [94] (byte) mulf8u_prepare::a#0 ← (byte)(signed byte) mulf8s::mulf8s_prepare1_a#0 - // [95] call mulf8u_prepare + // [93] (byte) mulf8u_prepare::a#0 ← (byte)(signed byte) mulf8s::mulf8s_prepare1_a#0 + // [94] call mulf8u_prepare jsr mulf8u_prepare jmp __b1 // mulf8s::@1 __b1: - // [96] (signed byte) mulf8s_prepared::b#0 ← (signed byte) mulf8s::b#2 -- vbsz1=vbsxx + // [95] (signed byte) mulf8s_prepared::b#0 ← (signed byte) mulf8s::b#2 -- vbsz1=vbsxx stx.z mulf8s_prepared.b - // [97] call mulf8s_prepared + // [96] call mulf8s_prepared jsr mulf8s_prepared jmp __b2 // mulf8s::@2 __b2: - // [98] (signed word) mulf8s::return#0 ← (signed word)(word) mulf8s_prepared::m#4 + // [97] (signed word) mulf8s::return#0 ← (signed word)(word) mulf8s_prepared::m#4 jmp __breturn // mulf8s::@return __breturn: - // [99] return + // [98] return rts } // mulf8s_prepared // Calculate fast multiply with a prepared unsigned byte to a word result // The prepared number is set by calling mulf8s_prepare(byte a) -// mulf8s_prepared(signed byte zeropage($f) b) +// mulf8s_prepared(signed byte zeropage($e) b) mulf8s_prepared: { .label memA = $fd - .label m = $c - .label b = $f - // [100] (byte) mulf8u_prepared::b#0 ← (byte)(signed byte) mulf8s_prepared::b#0 -- vbuaa=vbuz1 + .label m = $b + .label b = $e + // [99] (byte) mulf8u_prepared::b#0 ← (byte)(signed byte) mulf8s_prepared::b#0 -- vbuaa=vbuz1 lda.z b - // [101] call mulf8u_prepared + // [100] call mulf8u_prepared jsr mulf8u_prepared - // [102] (word) mulf8u_prepared::return#2 ← (word) mulf8u_prepared::return#0 + // [101] (word) mulf8u_prepared::return#2 ← (word) mulf8u_prepared::return#0 jmp __b5 // mulf8s_prepared::@5 __b5: - // [103] (word) mulf8s_prepared::m#0 ← (word) mulf8u_prepared::return#2 - // [104] if(*((const signed byte*) mulf8s_prepared::memA)>=(signed byte) 0) goto mulf8s_prepared::@1 -- _deref_pbsc1_ge_0_then_la1 + // [102] (word) mulf8s_prepared::m#0 ← (word) mulf8u_prepared::return#2 + // [103] if(*((const signed byte*) mulf8s_prepared::memA)>=(signed byte) 0) goto mulf8s_prepared::@1 -- _deref_pbsc1_ge_0_then_la1 lda memA cmp #0 bpl __b1_from___b5 jmp __b3 // mulf8s_prepared::@3 __b3: - // [105] (byte~) mulf8s_prepared::$8 ← > (word) mulf8s_prepared::m#0 -- vbuaa=_hi_vwuz1 + // [104] (byte~) mulf8s_prepared::$8 ← > (word) mulf8s_prepared::m#0 -- vbuaa=_hi_vwuz1 lda.z m+1 - // [106] (byte~) mulf8s_prepared::$15 ← (byte~) mulf8s_prepared::$8 - (byte)(signed byte) mulf8s_prepared::b#0 -- vbuaa=vbuaa_minus_vbuz1 + // [105] (byte~) mulf8s_prepared::$15 ← (byte~) mulf8s_prepared::$8 - (byte)(signed byte) mulf8s_prepared::b#0 -- vbuaa=vbuaa_minus_vbuz1 sec sbc.z b - // [107] (word) mulf8s_prepared::m#1 ← (word) mulf8s_prepared::m#0 hi= (byte~) mulf8s_prepared::$15 -- vwuz1=vwuz1_sethi_vbuaa + // [106] (word) mulf8s_prepared::m#1 ← (word) mulf8s_prepared::m#0 hi= (byte~) mulf8s_prepared::$15 -- vwuz1=vwuz1_sethi_vbuaa sta.z m+1 - // [108] phi from mulf8s_prepared::@3 mulf8s_prepared::@5 to mulf8s_prepared::@1 [phi:mulf8s_prepared::@3/mulf8s_prepared::@5->mulf8s_prepared::@1] + // [107] phi from mulf8s_prepared::@3 mulf8s_prepared::@5 to mulf8s_prepared::@1 [phi:mulf8s_prepared::@3/mulf8s_prepared::@5->mulf8s_prepared::@1] __b1_from___b3: __b1_from___b5: - // [108] phi (word) mulf8s_prepared::m#5 = (word) mulf8s_prepared::m#1 [phi:mulf8s_prepared::@3/mulf8s_prepared::@5->mulf8s_prepared::@1#0] -- register_copy + // [107] phi (word) mulf8s_prepared::m#5 = (word) mulf8s_prepared::m#1 [phi:mulf8s_prepared::@3/mulf8s_prepared::@5->mulf8s_prepared::@1#0] -- register_copy jmp __b1 // mulf8s_prepared::@1 __b1: - // [109] if((signed byte) mulf8s_prepared::b#0>=(signed byte) 0) goto mulf8s_prepared::@2 -- vbsz1_ge_0_then_la1 + // [108] if((signed byte) mulf8s_prepared::b#0>=(signed byte) 0) goto mulf8s_prepared::@2 -- vbsz1_ge_0_then_la1 lda.z b cmp #0 bpl __b2_from___b1 jmp __b4 // mulf8s_prepared::@4 __b4: - // [110] (byte~) mulf8s_prepared::$12 ← > (word) mulf8s_prepared::m#5 -- vbuaa=_hi_vwuz1 + // [109] (byte~) mulf8s_prepared::$12 ← > (word) mulf8s_prepared::m#5 -- vbuaa=_hi_vwuz1 lda.z m+1 - // [111] (byte~) mulf8s_prepared::$16 ← (byte~) mulf8s_prepared::$12 - (byte)*((const signed byte*) mulf8s_prepared::memA) -- vbuaa=vbuaa_minus__deref_pbuc1 + // [110] (byte~) mulf8s_prepared::$16 ← (byte~) mulf8s_prepared::$12 - (byte)*((const signed byte*) mulf8s_prepared::memA) -- vbuaa=vbuaa_minus__deref_pbuc1 sec sbc memA - // [112] (word) mulf8s_prepared::m#2 ← (word) mulf8s_prepared::m#5 hi= (byte~) mulf8s_prepared::$16 -- vwuz1=vwuz1_sethi_vbuaa + // [111] (word) mulf8s_prepared::m#2 ← (word) mulf8s_prepared::m#5 hi= (byte~) mulf8s_prepared::$16 -- vwuz1=vwuz1_sethi_vbuaa sta.z m+1 - // [113] phi from mulf8s_prepared::@1 mulf8s_prepared::@4 to mulf8s_prepared::@2 [phi:mulf8s_prepared::@1/mulf8s_prepared::@4->mulf8s_prepared::@2] + // [112] phi from mulf8s_prepared::@1 mulf8s_prepared::@4 to mulf8s_prepared::@2 [phi:mulf8s_prepared::@1/mulf8s_prepared::@4->mulf8s_prepared::@2] __b2_from___b1: __b2_from___b4: - // [113] phi (word) mulf8s_prepared::m#4 = (word) mulf8s_prepared::m#5 [phi:mulf8s_prepared::@1/mulf8s_prepared::@4->mulf8s_prepared::@2#0] -- register_copy + // [112] phi (word) mulf8s_prepared::m#4 = (word) mulf8s_prepared::m#5 [phi:mulf8s_prepared::@1/mulf8s_prepared::@4->mulf8s_prepared::@2#0] -- register_copy jmp __b2 // mulf8s_prepared::@2 __b2: jmp __breturn // mulf8s_prepared::@return __breturn: - // [114] return + // [113] return rts } // mulf8u_prepared @@ -8198,8 +8142,8 @@ mulf8s_prepared: { mulf8u_prepared: { .label resL = $fe .label memB = $ff - .label return = $c - // [115] *((const byte*) mulf8u_prepared::memB) ← (byte) mulf8u_prepared::b#0 -- _deref_pbuc1=vbuaa + .label return = $b + // [114] *((const byte*) mulf8u_prepared::memB) ← (byte) mulf8u_prepared::b#0 -- _deref_pbuc1=vbuaa sta memB // asm { ldxmemB sec sm1: ldamulf_sqr1_lo,x sm2: sbcmulf_sqr2_lo,x staresL sm3: ldamulf_sqr1_hi,x sm4: sbcmulf_sqr2_hi,x stamemB } ldx memB @@ -8214,7 +8158,7 @@ mulf8u_prepared: { sm4: sbc mulf_sqr2_hi,x sta memB - // [117] (word) mulf8u_prepared::return#0 ← *((const byte*) mulf8u_prepared::memB) w= *((const byte*) mulf8u_prepared::resL) -- vwuz1=_deref_pbuc1_word__deref_pbuc2 + // [116] (word) mulf8u_prepared::return#0 ← *((const byte*) mulf8u_prepared::memB) w= *((const byte*) mulf8u_prepared::resL) -- vwuz1=_deref_pbuc1_word__deref_pbuc2 lda resL sta.z return lda memB @@ -8222,7 +8166,7 @@ mulf8u_prepared: { jmp __breturn // mulf8u_prepared::@return __breturn: - // [118] return + // [117] return rts } // mulf8u_prepare @@ -8230,7 +8174,7 @@ mulf8u_prepared: { // mulf8u_prepare(byte register(A) a) mulf8u_prepare: { .label memA = $fd - // [119] *((const byte*) mulf8u_prepare::memA) ← (byte) mulf8u_prepare::a#0 -- _deref_pbuc1=vbuaa + // [118] *((const byte*) mulf8u_prepare::memA) ← (byte) mulf8u_prepare::a#0 -- _deref_pbuc1=vbuaa sta memA // asm { ldamemA stamulf8u_prepared.sm1+1 stamulf8u_prepared.sm3+1 eor#$ff stamulf8u_prepared.sm2+1 stamulf8u_prepared.sm4+1 } lda memA @@ -8242,78 +8186,78 @@ mulf8u_prepare: { jmp __breturn // mulf8u_prepare::@return __breturn: - // [121] return + // [120] return rts } // renderBobCleanup // Clean Up the rendered BOB's renderBobCleanup: { - .label screen = $10 - // [123] phi from renderBobCleanup to renderBobCleanup::@1 [phi:renderBobCleanup->renderBobCleanup::@1] + .label screen = $f + // [122] phi from renderBobCleanup to renderBobCleanup::@1 [phi:renderBobCleanup->renderBobCleanup::@1] __b1_from_renderBobCleanup: - // [123] phi (byte) renderBobCleanup::i#2 = (byte) 0 [phi:renderBobCleanup->renderBobCleanup::@1#0] -- vbuxx=vbuc1 + // [122] phi (byte) renderBobCleanup::i#2 = (byte) 0 [phi:renderBobCleanup->renderBobCleanup::@1#0] -- vbuxx=vbuc1 ldx #0 jmp __b1 - // [123] phi from renderBobCleanup::@1 to renderBobCleanup::@1 [phi:renderBobCleanup::@1->renderBobCleanup::@1] + // [122] phi from renderBobCleanup::@1 to renderBobCleanup::@1 [phi:renderBobCleanup::@1->renderBobCleanup::@1] __b1_from___b1: - // [123] phi (byte) renderBobCleanup::i#2 = (byte) renderBobCleanup::i#1 [phi:renderBobCleanup::@1->renderBobCleanup::@1#0] -- register_copy + // [122] phi (byte) renderBobCleanup::i#2 = (byte) renderBobCleanup::i#1 [phi:renderBobCleanup::@1->renderBobCleanup::@1#0] -- register_copy jmp __b1 // renderBobCleanup::@1 __b1: - // [124] (byte~) renderBobCleanup::$1 ← (byte) renderBobCleanup::i#2 << (byte) 1 -- vbuaa=vbuxx_rol_1 + // [123] (byte~) renderBobCleanup::$1 ← (byte) renderBobCleanup::i#2 << (byte) 1 -- vbuaa=vbuxx_rol_1 txa asl - // [125] (byte*) renderBobCleanup::screen#0 ← *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobCleanup::$1) -- pbuz1=pptc1_derefidx_vbuaa + // [124] (byte*) renderBobCleanup::screen#0 ← *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobCleanup::$1) -- pbuz1=pptc1_derefidx_vbuaa tay lda RENDERBOB_CLEANUP,y sta.z screen lda RENDERBOB_CLEANUP+1,y sta.z screen+1 - // [126] *((byte*) renderBobCleanup::screen#0) ← (byte) 0 -- _deref_pbuz1=vbuc1 + // [125] *((byte*) renderBobCleanup::screen#0) ← (byte) 0 -- _deref_pbuz1=vbuc1 lda #0 ldy #0 sta (screen),y - // [127] *((byte*) renderBobCleanup::screen#0 + (byte) $28) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + // [126] *((byte*) renderBobCleanup::screen#0 + (byte) $28) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 lda #0 ldy #$28 sta (screen),y - // [128] *((byte*) renderBobCleanup::screen#0 + (byte) $50) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + // [127] *((byte*) renderBobCleanup::screen#0 + (byte) $50) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 lda #0 ldy #$50 sta (screen),y - // [129] *((byte*) renderBobCleanup::screen#0 + (byte) 1) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + // [128] *((byte*) renderBobCleanup::screen#0 + (byte) 1) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 lda #0 ldy #1 sta (screen),y - // [130] *((byte*) renderBobCleanup::screen#0 + (byte) $29) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + // [129] *((byte*) renderBobCleanup::screen#0 + (byte) $29) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 lda #0 ldy #$29 sta (screen),y - // [131] *((byte*) renderBobCleanup::screen#0 + (byte) $51) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + // [130] *((byte*) renderBobCleanup::screen#0 + (byte) $51) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 lda #0 ldy #$51 sta (screen),y - // [132] *((byte*) renderBobCleanup::screen#0 + (byte) 2) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + // [131] *((byte*) renderBobCleanup::screen#0 + (byte) 2) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 lda #0 ldy #2 sta (screen),y - // [133] *((byte*) renderBobCleanup::screen#0 + (byte) $2a) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + // [132] *((byte*) renderBobCleanup::screen#0 + (byte) $2a) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 lda #0 ldy #$2a sta (screen),y - // [134] *((byte*) renderBobCleanup::screen#0 + (byte) $52) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + // [133] *((byte*) renderBobCleanup::screen#0 + (byte) $52) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 lda #0 ldy #$52 sta (screen),y - // [135] (byte) renderBobCleanup::i#1 ← ++ (byte) renderBobCleanup::i#2 -- vbuxx=_inc_vbuxx + // [134] (byte) renderBobCleanup::i#1 ← ++ (byte) renderBobCleanup::i#2 -- vbuxx=_inc_vbuxx inx - // [136] if((byte) renderBobCleanup::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto renderBobCleanup::@1 -- vbuxx_neq_vbuc1_then_la1 + // [135] if((byte) renderBobCleanup::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto renderBobCleanup::@1 -- vbuxx_neq_vbuc1_then_la1 cpx #NUM_BOBS-1+1 bne __b1_from___b1 jmp __breturn // renderBobCleanup::@return __breturn: - // [137] return + // [136] return rts } // memset @@ -8324,9 +8268,9 @@ memset: { .const num = $3e8 .label end = str+num .label dst = 6 - // [139] phi from memset to memset::@1 [phi:memset->memset::@1] + // [138] phi from memset to memset::@1 [phi:memset->memset::@1] __b1_from_memset: - // [139] phi (byte*) memset::dst#2 = (byte*)(const void*) memset::str#0 [phi:memset->memset::@1#0] -- pbuz1=pbuc1 + // [138] phi (byte*) memset::dst#2 = (byte*)(const void*) memset::str#0 [phi:memset->memset::@1#0] -- pbuz1=pbuc1 lda #str @@ -8334,7 +8278,7 @@ memset: { jmp __b1 // memset::@1 __b1: - // [140] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 -- pbuz1_neq_pbuc1_then_la1 + // [139] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 -- pbuz1_neq_pbuc1_then_la1 lda.z dst+1 cmp #>end bne __b2 @@ -8344,48 +8288,48 @@ memset: { jmp __breturn // memset::@return __breturn: - // [141] return + // [140] return rts // memset::@2 __b2: - // [142] *((byte*) memset::dst#2) ← (const byte) memset::c#0 -- _deref_pbuz1=vbuc1 + // [141] *((byte*) memset::dst#2) ← (const byte) memset::c#0 -- _deref_pbuz1=vbuc1 lda #c ldy #0 sta (dst),y - // [143] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2 -- pbuz1=_inc_pbuz1 + // [142] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2 -- pbuz1=_inc_pbuz1 inc.z dst bne !+ inc.z dst+1 !: - // [139] phi from memset::@2 to memset::@1 [phi:memset::@2->memset::@1] + // [138] phi from memset::@2 to memset::@1 [phi:memset::@2->memset::@1] __b1_from___b2: - // [139] phi (byte*) memset::dst#2 = (byte*) memset::dst#1 [phi:memset::@2->memset::@1#0] -- register_copy + // [138] phi (byte*) memset::dst#2 = (byte*) memset::dst#1 [phi:memset::@2->memset::@1#0] -- register_copy jmp __b1 } // renderBobInit // Initialize the tables used by renderBob() renderBobInit: { - .label __0 = $10 - .label __1 = $10 - .label __6 = $12 - .label __7 = $10 - // [145] phi from renderBobInit to renderBobInit::@1 [phi:renderBobInit->renderBobInit::@1] + .label __0 = $f + .label __1 = $f + .label __6 = $11 + .label __7 = $f + // [144] phi from renderBobInit to renderBobInit::@1 [phi:renderBobInit->renderBobInit::@1] __b1_from_renderBobInit: - // [145] phi (byte) renderBobInit::y#2 = (byte) 0 [phi:renderBobInit->renderBobInit::@1#0] -- vbuxx=vbuc1 + // [144] phi (byte) renderBobInit::y#2 = (byte) 0 [phi:renderBobInit->renderBobInit::@1#0] -- vbuxx=vbuc1 ldx #0 jmp __b1 - // [145] phi from renderBobInit::@1 to renderBobInit::@1 [phi:renderBobInit::@1->renderBobInit::@1] + // [144] phi from renderBobInit::@1 to renderBobInit::@1 [phi:renderBobInit::@1->renderBobInit::@1] __b1_from___b1: - // [145] phi (byte) renderBobInit::y#2 = (byte) renderBobInit::y#1 [phi:renderBobInit::@1->renderBobInit::@1#0] -- register_copy + // [144] phi (byte) renderBobInit::y#2 = (byte) renderBobInit::y#1 [phi:renderBobInit::@1->renderBobInit::@1#0] -- register_copy jmp __b1 // renderBobInit::@1 __b1: - // [146] (word~) renderBobInit::$0 ← (word)(byte) renderBobInit::y#2 -- vwuz1=_word_vbuxx + // [145] (word~) renderBobInit::$0 ← (word)(byte) renderBobInit::y#2 -- vwuz1=_word_vbuxx txa sta.z __0 lda #0 sta.z __0+1 - // [147] (word~) renderBobInit::$6 ← (word~) renderBobInit::$0 << (byte) 2 -- vwuz1=vwuz2_rol_2 + // [146] (word~) renderBobInit::$6 ← (word~) renderBobInit::$0 << (byte) 2 -- vwuz1=vwuz2_rol_2 lda.z __0 asl sta.z __6 @@ -8394,7 +8338,7 @@ renderBobInit: { sta.z __6+1 asl.z __6 rol.z __6+1 - // [148] (word~) renderBobInit::$7 ← (word~) renderBobInit::$6 + (word~) renderBobInit::$0 -- vwuz1=vwuz2_plus_vwuz1 + // [147] (word~) renderBobInit::$7 ← (word~) renderBobInit::$6 + (word~) renderBobInit::$0 -- vwuz1=vwuz2_plus_vwuz1 lda.z __7 clc adc.z __6 @@ -8402,160 +8346,160 @@ renderBobInit: { lda.z __7+1 adc.z __6+1 sta.z __7+1 - // [149] (word~) renderBobInit::$1 ← (word~) renderBobInit::$7 << (byte) 3 -- vwuz1=vwuz1_rol_3 + // [148] (word~) renderBobInit::$1 ← (word~) renderBobInit::$7 << (byte) 3 -- vwuz1=vwuz1_rol_3 asl.z __1 rol.z __1+1 asl.z __1 rol.z __1+1 asl.z __1 rol.z __1+1 - // [150] (byte~) renderBobInit::$4 ← (byte) renderBobInit::y#2 << (byte) 1 -- vbuaa=vbuxx_rol_1 + // [149] (byte~) renderBobInit::$4 ← (byte) renderBobInit::y#2 << (byte) 1 -- vbuaa=vbuxx_rol_1 txa asl - // [151] *((const word*) MUL40 + (byte~) renderBobInit::$4) ← (word~) renderBobInit::$1 -- pwuc1_derefidx_vbuaa=vwuz1 + // [150] *((const word*) MUL40 + (byte~) renderBobInit::$4) ← (word~) renderBobInit::$1 -- pwuc1_derefidx_vbuaa=vwuz1 tay lda.z __1 sta MUL40,y lda.z __1+1 sta MUL40+1,y - // [152] (byte) renderBobInit::y#1 ← ++ (byte) renderBobInit::y#2 -- vbuxx=_inc_vbuxx + // [151] (byte) renderBobInit::y#1 ← ++ (byte) renderBobInit::y#2 -- vbuxx=_inc_vbuxx inx - // [153] if((byte) renderBobInit::y#1!=(byte) $20) goto renderBobInit::@1 -- vbuxx_neq_vbuc1_then_la1 + // [152] if((byte) renderBobInit::y#1!=(byte) $20) goto renderBobInit::@1 -- vbuxx_neq_vbuc1_then_la1 cpx #$20 bne __b1_from___b1 - // [154] phi from renderBobInit::@1 to renderBobInit::@2 [phi:renderBobInit::@1->renderBobInit::@2] + // [153] phi from renderBobInit::@1 to renderBobInit::@2 [phi:renderBobInit::@1->renderBobInit::@2] __b2_from___b1: - // [154] phi (byte) renderBobInit::i#2 = (byte) 0 [phi:renderBobInit::@1->renderBobInit::@2#0] -- vbuxx=vbuc1 + // [153] phi (byte) renderBobInit::i#2 = (byte) 0 [phi:renderBobInit::@1->renderBobInit::@2#0] -- vbuxx=vbuc1 ldx #0 jmp __b2 - // [154] phi from renderBobInit::@2 to renderBobInit::@2 [phi:renderBobInit::@2->renderBobInit::@2] + // [153] phi from renderBobInit::@2 to renderBobInit::@2 [phi:renderBobInit::@2->renderBobInit::@2] __b2_from___b2: - // [154] phi (byte) renderBobInit::i#2 = (byte) renderBobInit::i#1 [phi:renderBobInit::@2->renderBobInit::@2#0] -- register_copy + // [153] phi (byte) renderBobInit::i#2 = (byte) renderBobInit::i#1 [phi:renderBobInit::@2->renderBobInit::@2#0] -- register_copy jmp __b2 // renderBobInit::@2 __b2: - // [155] (byte~) renderBobInit::$5 ← (byte) renderBobInit::i#2 << (byte) 1 -- vbuaa=vbuxx_rol_1 + // [154] (byte~) renderBobInit::$5 ← (byte) renderBobInit::i#2 << (byte) 1 -- vbuaa=vbuxx_rol_1 txa asl - // [156] *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobInit::$5) ← (const byte*) BOB_SCREEN -- pptc1_derefidx_vbuaa=pbuc2 + // [155] *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobInit::$5) ← (const byte*) BOB_SCREEN -- pptc1_derefidx_vbuaa=pbuc2 tay lda #BOB_SCREEN sta RENDERBOB_CLEANUP+1,y - // [157] (byte) renderBobInit::i#1 ← ++ (byte) renderBobInit::i#2 -- vbuxx=_inc_vbuxx + // [156] (byte) renderBobInit::i#1 ← ++ (byte) renderBobInit::i#2 -- vbuxx=_inc_vbuxx inx - // [158] if((byte) renderBobInit::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto renderBobInit::@2 -- vbuxx_neq_vbuc1_then_la1 + // [157] if((byte) renderBobInit::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto renderBobInit::@2 -- vbuxx_neq_vbuc1_then_la1 cpx #NUM_BOBS-1+1 bne __b2_from___b2 jmp __breturn // renderBobInit::@return __breturn: - // [159] return + // [158] return rts } // prepareBobs // Creates the pre-shifted bobs into BOB_CHARSET and populates the BOB_TABLES // Modifies PROTO_BOB by shifting it around prepareBobs: { - .label bob_table = $10 + .label bob_table = $f .label shift_y = 2 // Populate charset and tables .label bob_glyph = 6 - .label cell = $b + .label cell = $a .label bob_table_idx = 4 .label shift_x = 5 - // [161] call progress_init - // [242] phi from prepareBobs to progress_init [phi:prepareBobs->progress_init] + // [160] call progress_init + // [241] phi from prepareBobs to progress_init [phi:prepareBobs->progress_init] progress_init_from_prepareBobs: jsr progress_init - // [162] phi from prepareBobs to prepareBobs::@8 [phi:prepareBobs->prepareBobs::@8] + // [161] phi from prepareBobs to prepareBobs::@8 [phi:prepareBobs->prepareBobs::@8] __b8_from_prepareBobs: jmp __b8 // prepareBobs::@8 __b8: - // [163] call bobCharsetFindOrAddGlyph - // [196] phi from prepareBobs::@8 to bobCharsetFindOrAddGlyph [phi:prepareBobs::@8->bobCharsetFindOrAddGlyph] + // [162] call bobCharsetFindOrAddGlyph + // [195] phi from prepareBobs::@8 to bobCharsetFindOrAddGlyph [phi:prepareBobs::@8->bobCharsetFindOrAddGlyph] bobCharsetFindOrAddGlyph_from___b8: - // [196] phi (byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 = (const byte*) PROTO_BOB+(byte) $30 [phi:prepareBobs::@8->bobCharsetFindOrAddGlyph#0] -- pbuz1=pbuc1 + // [195] phi (byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 = (const byte*) PROTO_BOB+(byte) $30 [phi:prepareBobs::@8->bobCharsetFindOrAddGlyph#0] -- pbuz1=pbuc1 lda #PROTO_BOB+$30 sta.z bobCharsetFindOrAddGlyph.bob_glyph+1 - // [196] phi (byte) bob_charset_next_id#23 = (byte) 0 [phi:prepareBobs::@8->bobCharsetFindOrAddGlyph#1] -- vbuz1=vbuc1 + // [195] phi (byte) bob_charset_next_id#23 = (byte) 0 [phi:prepareBobs::@8->bobCharsetFindOrAddGlyph#1] -- vbuz1=vbuc1 lda #0 sta.z bob_charset_next_id jsr bobCharsetFindOrAddGlyph - // [164] phi from prepareBobs::@8 to prepareBobs::@1 [phi:prepareBobs::@8->prepareBobs::@1] + // [163] phi from prepareBobs::@8 to prepareBobs::@1 [phi:prepareBobs::@8->prepareBobs::@1] __b1_from___b8: - // [164] phi (byte) prepareBobs::bob_table_idx#6 = (byte) 0 [phi:prepareBobs::@8->prepareBobs::@1#0] -- vbuz1=vbuc1 + // [163] phi (byte) prepareBobs::bob_table_idx#6 = (byte) 0 [phi:prepareBobs::@8->prepareBobs::@1#0] -- vbuz1=vbuc1 lda #0 sta.z bob_table_idx - // [164] phi (byte) bob_charset_next_id#14 = (byte) bob_charset_next_id#16 [phi:prepareBobs::@8->prepareBobs::@1#1] -- register_copy - // [164] phi (byte) progress_idx#16 = (byte) 0 [phi:prepareBobs::@8->prepareBobs::@1#2] -- vbuz1=vbuc1 + // [163] phi (byte) bob_charset_next_id#14 = (byte) bob_charset_next_id#16 [phi:prepareBobs::@8->prepareBobs::@1#1] -- register_copy + // [163] phi (byte) progress_idx#16 = (byte) 0 [phi:prepareBobs::@8->prepareBobs::@1#2] -- vbuz1=vbuc1 lda #0 sta.z progress_idx - // [164] phi (byte*) progress_cursor#15 = (const byte*) SCREEN_BASIC [phi:prepareBobs::@8->prepareBobs::@1#3] -- pbuz1=pbuc1 + // [163] phi (byte*) progress_cursor#15 = (const byte*) SCREEN_BASIC [phi:prepareBobs::@8->prepareBobs::@1#3] -- pbuz1=pbuc1 lda #SCREEN_BASIC sta.z progress_cursor+1 - // [164] phi (byte) prepareBobs::shift_y#2 = (byte) 0 [phi:prepareBobs::@8->prepareBobs::@1#4] -- vbuz1=vbuc1 + // [163] phi (byte) prepareBobs::shift_y#2 = (byte) 0 [phi:prepareBobs::@8->prepareBobs::@1#4] -- vbuz1=vbuc1 lda #0 sta.z shift_y jmp __b1 // prepareBobs::@1 __b1: - // [165] if((byte) prepareBobs::shift_y#2<(const byte) BOB_SHIFTS_Y) goto prepareBobs::@2 -- vbuz1_lt_vbuc1_then_la1 + // [164] if((byte) prepareBobs::shift_y#2<(const byte) BOB_SHIFTS_Y) goto prepareBobs::@2 -- vbuz1_lt_vbuc1_then_la1 lda.z shift_y cmp #BOB_SHIFTS_Y bcc __b2_from___b1 jmp __breturn // prepareBobs::@return __breturn: - // [166] return + // [165] return rts - // [167] phi from prepareBobs::@1 to prepareBobs::@2 [phi:prepareBobs::@1->prepareBobs::@2] + // [166] phi from prepareBobs::@1 to prepareBobs::@2 [phi:prepareBobs::@1->prepareBobs::@2] __b2_from___b1: - // [167] phi (byte) progress_idx#31 = (byte) progress_idx#16 [phi:prepareBobs::@1->prepareBobs::@2#0] -- register_copy - // [167] phi (byte*) progress_cursor#31 = (byte*) progress_cursor#15 [phi:prepareBobs::@1->prepareBobs::@2#1] -- register_copy - // [167] phi (byte) bob_charset_next_id#30 = (byte) bob_charset_next_id#14 [phi:prepareBobs::@1->prepareBobs::@2#2] -- register_copy - // [167] phi (byte) prepareBobs::bob_table_idx#12 = (byte) prepareBobs::bob_table_idx#6 [phi:prepareBobs::@1->prepareBobs::@2#3] -- register_copy - // [167] phi (byte) prepareBobs::shift_x#2 = (byte) 0 [phi:prepareBobs::@1->prepareBobs::@2#4] -- vbuz1=vbuc1 + // [166] phi (byte) progress_idx#31 = (byte) progress_idx#16 [phi:prepareBobs::@1->prepareBobs::@2#0] -- register_copy + // [166] phi (byte*) progress_cursor#31 = (byte*) progress_cursor#15 [phi:prepareBobs::@1->prepareBobs::@2#1] -- register_copy + // [166] phi (byte) bob_charset_next_id#30 = (byte) bob_charset_next_id#14 [phi:prepareBobs::@1->prepareBobs::@2#2] -- register_copy + // [166] phi (byte) prepareBobs::bob_table_idx#12 = (byte) prepareBobs::bob_table_idx#6 [phi:prepareBobs::@1->prepareBobs::@2#3] -- register_copy + // [166] phi (byte) prepareBobs::shift_x#2 = (byte) 0 [phi:prepareBobs::@1->prepareBobs::@2#4] -- vbuz1=vbuc1 lda #0 sta.z shift_x jmp __b2 // prepareBobs::@2 __b2: - // [168] if((byte) prepareBobs::shift_x#2<(const byte) BOB_SHIFTS_X) goto prepareBobs::@3 -- vbuz1_lt_vbuc1_then_la1 + // [167] if((byte) prepareBobs::shift_x#2<(const byte) BOB_SHIFTS_X) goto prepareBobs::@3 -- vbuz1_lt_vbuc1_then_la1 lda.z shift_x cmp #BOB_SHIFTS_X bcc __b3 - // [169] phi from prepareBobs::@2 to prepareBobs::@4 [phi:prepareBobs::@2->prepareBobs::@4] + // [168] phi from prepareBobs::@2 to prepareBobs::@4 [phi:prepareBobs::@2->prepareBobs::@4] __b4_from___b2: jmp __b4 // prepareBobs::@4 __b4: - // [170] call shiftProtoBobDown - // [231] phi from prepareBobs::@4 to shiftProtoBobDown [phi:prepareBobs::@4->shiftProtoBobDown] + // [169] call shiftProtoBobDown + // [230] phi from prepareBobs::@4 to shiftProtoBobDown [phi:prepareBobs::@4->shiftProtoBobDown] shiftProtoBobDown_from___b4: jsr shiftProtoBobDown jmp __b9 // prepareBobs::@9 __b9: - // [171] (byte) prepareBobs::shift_y#1 ← ++ (byte) prepareBobs::shift_y#2 -- vbuz1=_inc_vbuz1 + // [170] (byte) prepareBobs::shift_y#1 ← ++ (byte) prepareBobs::shift_y#2 -- vbuz1=_inc_vbuz1 inc.z shift_y - // [164] phi from prepareBobs::@9 to prepareBobs::@1 [phi:prepareBobs::@9->prepareBobs::@1] + // [163] phi from prepareBobs::@9 to prepareBobs::@1 [phi:prepareBobs::@9->prepareBobs::@1] __b1_from___b9: - // [164] phi (byte) prepareBobs::bob_table_idx#6 = (byte) prepareBobs::bob_table_idx#12 [phi:prepareBobs::@9->prepareBobs::@1#0] -- register_copy - // [164] phi (byte) bob_charset_next_id#14 = (byte) bob_charset_next_id#30 [phi:prepareBobs::@9->prepareBobs::@1#1] -- register_copy - // [164] phi (byte) progress_idx#16 = (byte) progress_idx#31 [phi:prepareBobs::@9->prepareBobs::@1#2] -- register_copy - // [164] phi (byte*) progress_cursor#15 = (byte*) progress_cursor#31 [phi:prepareBobs::@9->prepareBobs::@1#3] -- register_copy - // [164] phi (byte) prepareBobs::shift_y#2 = (byte) prepareBobs::shift_y#1 [phi:prepareBobs::@9->prepareBobs::@1#4] -- register_copy + // [163] phi (byte) prepareBobs::bob_table_idx#6 = (byte) prepareBobs::bob_table_idx#12 [phi:prepareBobs::@9->prepareBobs::@1#0] -- register_copy + // [163] phi (byte) bob_charset_next_id#14 = (byte) bob_charset_next_id#30 [phi:prepareBobs::@9->prepareBobs::@1#1] -- register_copy + // [163] phi (byte) progress_idx#16 = (byte) progress_idx#31 [phi:prepareBobs::@9->prepareBobs::@1#2] -- register_copy + // [163] phi (byte*) progress_cursor#15 = (byte*) progress_cursor#31 [phi:prepareBobs::@9->prepareBobs::@1#3] -- register_copy + // [163] phi (byte) prepareBobs::shift_y#2 = (byte) prepareBobs::shift_y#1 [phi:prepareBobs::@9->prepareBobs::@1#4] -- register_copy jmp __b1 // prepareBobs::@3 __b3: - // [172] (byte*) prepareBobs::bob_table#0 ← (const byte*) BOB_TABLES + (byte) prepareBobs::bob_table_idx#12 -- pbuz1=pbuc1_plus_vbuz2 + // [171] (byte*) prepareBobs::bob_table#0 ← (const byte*) BOB_TABLES + (byte) prepareBobs::bob_table_idx#12 -- pbuz1=pbuc1_plus_vbuz2 lda.z bob_table_idx clc adc #BOB_TABLES adc #0 sta.z bob_table+1 - // [173] phi from prepareBobs::@3 to prepareBobs::@5 [phi:prepareBobs::@3->prepareBobs::@5] + // [172] phi from prepareBobs::@3 to prepareBobs::@5 [phi:prepareBobs::@3->prepareBobs::@5] __b5_from___b3: - // [173] phi (byte*) progress_cursor#24 = (byte*) progress_cursor#31 [phi:prepareBobs::@3->prepareBobs::@5#0] -- register_copy - // [173] phi (byte) progress_idx#25 = (byte) progress_idx#31 [phi:prepareBobs::@3->prepareBobs::@5#1] -- register_copy - // [173] phi (byte*) prepareBobs::bob_table#2 = (byte*) prepareBobs::bob_table#0 [phi:prepareBobs::@3->prepareBobs::@5#2] -- register_copy - // [173] phi (byte) bob_charset_next_id#21 = (byte) bob_charset_next_id#30 [phi:prepareBobs::@3->prepareBobs::@5#3] -- register_copy - // [173] phi (byte*) prepareBobs::bob_glyph#2 = (const byte*) PROTO_BOB [phi:prepareBobs::@3->prepareBobs::@5#4] -- pbuz1=pbuc1 + // [172] phi (byte*) progress_cursor#24 = (byte*) progress_cursor#31 [phi:prepareBobs::@3->prepareBobs::@5#0] -- register_copy + // [172] phi (byte) progress_idx#25 = (byte) progress_idx#31 [phi:prepareBobs::@3->prepareBobs::@5#1] -- register_copy + // [172] phi (byte*) prepareBobs::bob_table#2 = (byte*) prepareBobs::bob_table#0 [phi:prepareBobs::@3->prepareBobs::@5#2] -- register_copy + // [172] phi (byte) bob_charset_next_id#21 = (byte) bob_charset_next_id#30 [phi:prepareBobs::@3->prepareBobs::@5#3] -- register_copy + // [172] phi (byte*) prepareBobs::bob_glyph#2 = (const byte*) PROTO_BOB [phi:prepareBobs::@3->prepareBobs::@5#4] -- pbuz1=pbuc1 lda #PROTO_BOB sta.z bob_glyph+1 - // [173] phi (byte) prepareBobs::cell#2 = (byte) 0 [phi:prepareBobs::@3->prepareBobs::@5#5] -- vbuz1=vbuc1 + // [172] phi (byte) prepareBobs::cell#2 = (byte) 0 [phi:prepareBobs::@3->prepareBobs::@5#5] -- vbuz1=vbuc1 lda #0 sta.z cell jmp __b5 // prepareBobs::@5 __b5: - // [174] if((byte) prepareBobs::cell#2<(byte) 9) goto prepareBobs::@6 -- vbuz1_lt_vbuc1_then_la1 + // [173] if((byte) prepareBobs::cell#2<(byte) 9) goto prepareBobs::@6 -- vbuz1_lt_vbuc1_then_la1 lda.z cell cmp #9 bcc __b6 jmp __b7 // prepareBobs::@7 __b7: - // [175] (byte) prepareBobs::bob_table_idx#1 ← ++ (byte) prepareBobs::bob_table_idx#12 -- vbuz1=_inc_vbuz1 + // [174] (byte) prepareBobs::bob_table_idx#1 ← ++ (byte) prepareBobs::bob_table_idx#12 -- vbuz1=_inc_vbuz1 inc.z bob_table_idx - // [176] call shiftProtoBobRight - // [214] phi from prepareBobs::@7 to shiftProtoBobRight [phi:prepareBobs::@7->shiftProtoBobRight] + // [175] call shiftProtoBobRight + // [213] phi from prepareBobs::@7 to shiftProtoBobRight [phi:prepareBobs::@7->shiftProtoBobRight] shiftProtoBobRight_from___b7: jsr shiftProtoBobRight - // [177] phi from prepareBobs::@7 to prepareBobs::@12 [phi:prepareBobs::@7->prepareBobs::@12] + // [176] phi from prepareBobs::@7 to prepareBobs::@12 [phi:prepareBobs::@7->prepareBobs::@12] __b12_from___b7: jmp __b12 // prepareBobs::@12 __b12: - // [178] call shiftProtoBobRight - // [214] phi from prepareBobs::@12 to shiftProtoBobRight [phi:prepareBobs::@12->shiftProtoBobRight] + // [177] call shiftProtoBobRight + // [213] phi from prepareBobs::@12 to shiftProtoBobRight [phi:prepareBobs::@12->shiftProtoBobRight] shiftProtoBobRight_from___b12: jsr shiftProtoBobRight jmp __b13 // prepareBobs::@13 __b13: - // [179] (byte) prepareBobs::shift_x#1 ← ++ (byte) prepareBobs::shift_x#2 -- vbuz1=_inc_vbuz1 + // [178] (byte) prepareBobs::shift_x#1 ← ++ (byte) prepareBobs::shift_x#2 -- vbuz1=_inc_vbuz1 inc.z shift_x - // [167] phi from prepareBobs::@13 to prepareBobs::@2 [phi:prepareBobs::@13->prepareBobs::@2] + // [166] phi from prepareBobs::@13 to prepareBobs::@2 [phi:prepareBobs::@13->prepareBobs::@2] __b2_from___b13: - // [167] phi (byte) progress_idx#31 = (byte) progress_idx#25 [phi:prepareBobs::@13->prepareBobs::@2#0] -- register_copy - // [167] phi (byte*) progress_cursor#31 = (byte*) progress_cursor#24 [phi:prepareBobs::@13->prepareBobs::@2#1] -- register_copy - // [167] phi (byte) bob_charset_next_id#30 = (byte) bob_charset_next_id#21 [phi:prepareBobs::@13->prepareBobs::@2#2] -- register_copy - // [167] phi (byte) prepareBobs::bob_table_idx#12 = (byte) prepareBobs::bob_table_idx#1 [phi:prepareBobs::@13->prepareBobs::@2#3] -- register_copy - // [167] phi (byte) prepareBobs::shift_x#2 = (byte) prepareBobs::shift_x#1 [phi:prepareBobs::@13->prepareBobs::@2#4] -- register_copy + // [166] phi (byte) progress_idx#31 = (byte) progress_idx#25 [phi:prepareBobs::@13->prepareBobs::@2#0] -- register_copy + // [166] phi (byte*) progress_cursor#31 = (byte*) progress_cursor#24 [phi:prepareBobs::@13->prepareBobs::@2#1] -- register_copy + // [166] phi (byte) bob_charset_next_id#30 = (byte) bob_charset_next_id#21 [phi:prepareBobs::@13->prepareBobs::@2#2] -- register_copy + // [166] phi (byte) prepareBobs::bob_table_idx#12 = (byte) prepareBobs::bob_table_idx#1 [phi:prepareBobs::@13->prepareBobs::@2#3] -- register_copy + // [166] phi (byte) prepareBobs::shift_x#2 = (byte) prepareBobs::shift_x#1 [phi:prepareBobs::@13->prepareBobs::@2#4] -- register_copy jmp __b2 // prepareBobs::@6 __b6: - // [180] (byte*) bobCharsetFindOrAddGlyph::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 - // [181] call bobCharsetFindOrAddGlyph - // [196] phi from prepareBobs::@6 to bobCharsetFindOrAddGlyph [phi:prepareBobs::@6->bobCharsetFindOrAddGlyph] + // [179] (byte*) bobCharsetFindOrAddGlyph::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 + // [180] call bobCharsetFindOrAddGlyph + // [195] phi from prepareBobs::@6 to bobCharsetFindOrAddGlyph [phi:prepareBobs::@6->bobCharsetFindOrAddGlyph] bobCharsetFindOrAddGlyph_from___b6: - // [196] phi (byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 = (byte*) bobCharsetFindOrAddGlyph::bob_glyph#1 [phi:prepareBobs::@6->bobCharsetFindOrAddGlyph#0] -- register_copy - // [196] phi (byte) bob_charset_next_id#23 = (byte) bob_charset_next_id#21 [phi:prepareBobs::@6->bobCharsetFindOrAddGlyph#1] -- register_copy + // [195] phi (byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 = (byte*) bobCharsetFindOrAddGlyph::bob_glyph#1 [phi:prepareBobs::@6->bobCharsetFindOrAddGlyph#0] -- register_copy + // [195] phi (byte) bob_charset_next_id#23 = (byte) bob_charset_next_id#21 [phi:prepareBobs::@6->bobCharsetFindOrAddGlyph#1] -- register_copy jsr bobCharsetFindOrAddGlyph - // [182] (byte) bobCharsetFindOrAddGlyph::return#1 ← (byte) bobCharsetFindOrAddGlyph::glyph_id#11 -- vbuaa=vbuz1 - lda.z bobCharsetFindOrAddGlyph.glyph_id + // [181] (byte) bobCharsetFindOrAddGlyph::return#1 ← (byte) bobCharsetFindOrAddGlyph::glyph_id#11 -- vbuaa=vbuxx + txa jmp __b10 // prepareBobs::@10 __b10: - // [183] (byte~) prepareBobs::$6 ← (byte) bobCharsetFindOrAddGlyph::return#1 - // [184] *((byte*) prepareBobs::bob_table#2) ← (byte~) prepareBobs::$6 -- _deref_pbuz1=vbuaa + // [182] (byte~) prepareBobs::$6 ← (byte) bobCharsetFindOrAddGlyph::return#1 + // [183] *((byte*) prepareBobs::bob_table#2) ← (byte~) prepareBobs::$6 -- _deref_pbuz1=vbuaa // Look for an existing char in BOB_CHARSET ldy #0 sta (bob_table),y - // [185] (byte*) prepareBobs::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 + (byte) 8 -- pbuz1=pbuz1_plus_vbuc1 + // [184] (byte*) prepareBobs::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 + (byte) 8 -- pbuz1=pbuz1_plus_vbuc1 // Move to the next glyph lda #8 clc @@ -8643,7 +8587,7 @@ prepareBobs: { bcc !+ inc.z bob_glyph+1 !: - // [186] (byte*) prepareBobs::bob_table#1 ← (byte*) prepareBobs::bob_table#2 + (const byte) BOB_SHIFTS_X*(const byte) BOB_SHIFTS_Y -- pbuz1=pbuz1_plus_vbuc1 + // [185] (byte*) prepareBobs::bob_table#1 ← (byte*) prepareBobs::bob_table#2 + (const byte) BOB_SHIFTS_X*(const byte) BOB_SHIFTS_Y -- pbuz1=pbuz1_plus_vbuc1 // Move to the next sub-table lda #BOB_SHIFTS_X*BOB_SHIFTS_Y clc @@ -8652,60 +8596,60 @@ prepareBobs: { bcc !+ inc.z bob_table+1 !: - // [187] call progress_inc + // [186] call progress_inc jsr progress_inc jmp __b11 // prepareBobs::@11 __b11: - // [188] (byte) prepareBobs::cell#1 ← ++ (byte) prepareBobs::cell#2 -- vbuz1=_inc_vbuz1 + // [187] (byte) prepareBobs::cell#1 ← ++ (byte) prepareBobs::cell#2 -- vbuz1=_inc_vbuz1 inc.z cell - // [173] phi from prepareBobs::@11 to prepareBobs::@5 [phi:prepareBobs::@11->prepareBobs::@5] + // [172] phi from prepareBobs::@11 to prepareBobs::@5 [phi:prepareBobs::@11->prepareBobs::@5] __b5_from___b11: - // [173] phi (byte*) progress_cursor#24 = (byte*) progress_cursor#17 [phi:prepareBobs::@11->prepareBobs::@5#0] -- register_copy - // [173] phi (byte) progress_idx#25 = (byte) progress_idx#10 [phi:prepareBobs::@11->prepareBobs::@5#1] -- register_copy - // [173] phi (byte*) prepareBobs::bob_table#2 = (byte*) prepareBobs::bob_table#1 [phi:prepareBobs::@11->prepareBobs::@5#2] -- register_copy - // [173] phi (byte) bob_charset_next_id#21 = (byte) bob_charset_next_id#16 [phi:prepareBobs::@11->prepareBobs::@5#3] -- register_copy - // [173] phi (byte*) prepareBobs::bob_glyph#2 = (byte*) prepareBobs::bob_glyph#1 [phi:prepareBobs::@11->prepareBobs::@5#4] -- register_copy - // [173] phi (byte) prepareBobs::cell#2 = (byte) prepareBobs::cell#1 [phi:prepareBobs::@11->prepareBobs::@5#5] -- register_copy + // [172] phi (byte*) progress_cursor#24 = (byte*) progress_cursor#17 [phi:prepareBobs::@11->prepareBobs::@5#0] -- register_copy + // [172] phi (byte) progress_idx#25 = (byte) progress_idx#10 [phi:prepareBobs::@11->prepareBobs::@5#1] -- register_copy + // [172] phi (byte*) prepareBobs::bob_table#2 = (byte*) prepareBobs::bob_table#1 [phi:prepareBobs::@11->prepareBobs::@5#2] -- register_copy + // [172] phi (byte) bob_charset_next_id#21 = (byte) bob_charset_next_id#16 [phi:prepareBobs::@11->prepareBobs::@5#3] -- register_copy + // [172] phi (byte*) prepareBobs::bob_glyph#2 = (byte*) prepareBobs::bob_glyph#1 [phi:prepareBobs::@11->prepareBobs::@5#4] -- register_copy + // [172] phi (byte) prepareBobs::cell#2 = (byte) prepareBobs::cell#1 [phi:prepareBobs::@11->prepareBobs::@5#5] -- register_copy jmp __b5 } // progress_inc // Increase PETSCII progress one bit // Done by increasing the character until the idx is 8 and then moving to the next char progress_inc: { - // [189] (byte) progress_idx#8 ← ++ (byte) progress_idx#25 -- vbuz1=_inc_vbuz1 + // [188] (byte) progress_idx#8 ← ++ (byte) progress_idx#25 -- vbuz1=_inc_vbuz1 inc.z progress_idx - // [190] if((byte) progress_idx#8!=(byte) 8) goto progress_inc::@1 -- vbuz1_neq_vbuc1_then_la1 + // [189] if((byte) progress_idx#8!=(byte) 8) goto progress_inc::@1 -- vbuz1_neq_vbuc1_then_la1 lda #8 cmp.z progress_idx bne __b1_from_progress_inc jmp __b2 // progress_inc::@2 __b2: - // [191] *((byte*) progress_cursor#24) ← *((const byte*) progress_inc::progress_chars+(byte) 8) -- _deref_pbuz1=_deref_pbuc1 + // [190] *((byte*) progress_cursor#24) ← *((const byte*) progress_inc::progress_chars+(byte) 8) -- _deref_pbuz1=_deref_pbuc1 lda progress_chars+8 ldy #0 sta (progress_cursor),y - // [192] (byte*) progress_cursor#8 ← ++ (byte*) progress_cursor#24 -- pbuz1=_inc_pbuz1 + // [191] (byte*) progress_cursor#8 ← ++ (byte*) progress_cursor#24 -- pbuz1=_inc_pbuz1 inc.z progress_cursor bne !+ inc.z progress_cursor+1 !: - // [193] phi from progress_inc::@2 to progress_inc::@1 [phi:progress_inc::@2->progress_inc::@1] + // [192] phi from progress_inc::@2 to progress_inc::@1 [phi:progress_inc::@2->progress_inc::@1] __b1_from___b2: - // [193] phi (byte*) progress_cursor#17 = (byte*) progress_cursor#8 [phi:progress_inc::@2->progress_inc::@1#0] -- register_copy - // [193] phi (byte) progress_idx#10 = (byte) 0 [phi:progress_inc::@2->progress_inc::@1#1] -- vbuz1=vbuc1 + // [192] phi (byte*) progress_cursor#17 = (byte*) progress_cursor#8 [phi:progress_inc::@2->progress_inc::@1#0] -- register_copy + // [192] phi (byte) progress_idx#10 = (byte) 0 [phi:progress_inc::@2->progress_inc::@1#1] -- vbuz1=vbuc1 lda #0 sta.z progress_idx jmp __b1 - // [193] phi from progress_inc to progress_inc::@1 [phi:progress_inc->progress_inc::@1] + // [192] phi from progress_inc to progress_inc::@1 [phi:progress_inc->progress_inc::@1] __b1_from_progress_inc: - // [193] phi (byte*) progress_cursor#17 = (byte*) progress_cursor#24 [phi:progress_inc->progress_inc::@1#0] -- register_copy - // [193] phi (byte) progress_idx#10 = (byte) progress_idx#8 [phi:progress_inc->progress_inc::@1#1] -- register_copy + // [192] phi (byte*) progress_cursor#17 = (byte*) progress_cursor#24 [phi:progress_inc->progress_inc::@1#0] -- register_copy + // [192] phi (byte) progress_idx#10 = (byte) progress_idx#8 [phi:progress_inc->progress_inc::@1#1] -- register_copy jmp __b1 // progress_inc::@1 __b1: - // [194] *((byte*) progress_cursor#17) ← *((const byte*) progress_inc::progress_chars + (byte) progress_idx#10) -- _deref_pbuz1=pbuc1_derefidx_vbuz2 + // [193] *((byte*) progress_cursor#17) ← *((const byte*) progress_inc::progress_chars + (byte) progress_idx#10) -- _deref_pbuz1=pbuc1_derefidx_vbuz2 ldy.z progress_idx lda progress_chars,y ldy #0 @@ -8713,7 +8657,7 @@ progress_inc: { jmp __breturn // progress_inc::@return __breturn: - // [195] return + // [194] return rts // Progress characters progress_chars: .byte $20, $65, $74, $75, $61, $f6, $e7, $ea, $e0 @@ -8725,106 +8669,95 @@ progress_inc: { // bobCharsetFindOrAddGlyph(byte* zeropage(6) bob_glyph) bobCharsetFindOrAddGlyph: { .label bob_glyph = 6 - .label i = 8 - .label glyph_id = $e - .label glyph_cursor = $12 - // [197] phi from bobCharsetFindOrAddGlyph to bobCharsetFindOrAddGlyph::@1 [phi:bobCharsetFindOrAddGlyph->bobCharsetFindOrAddGlyph::@1] + .label glyph_cursor = $11 + // [196] phi from bobCharsetFindOrAddGlyph to bobCharsetFindOrAddGlyph::@1 [phi:bobCharsetFindOrAddGlyph->bobCharsetFindOrAddGlyph::@1] __b1_from_bobCharsetFindOrAddGlyph: - // [197] phi (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 = (const byte*) BOB_CHARSET [phi:bobCharsetFindOrAddGlyph->bobCharsetFindOrAddGlyph::@1#0] -- pbuz1=pbuc1 + // [196] phi (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 = (const byte*) BOB_CHARSET [phi:bobCharsetFindOrAddGlyph->bobCharsetFindOrAddGlyph::@1#0] -- pbuz1=pbuc1 lda #BOB_CHARSET sta.z glyph_cursor+1 - // [197] phi (byte) bobCharsetFindOrAddGlyph::glyph_id#11 = (byte) 0 [phi:bobCharsetFindOrAddGlyph->bobCharsetFindOrAddGlyph::@1#1] -- vbuz1=vbuc1 - lda #0 - sta.z glyph_id + // [196] phi (byte) bobCharsetFindOrAddGlyph::glyph_id#11 = (byte) 0 [phi:bobCharsetFindOrAddGlyph->bobCharsetFindOrAddGlyph::@1#1] -- vbuxx=vbuc1 + ldx #0 jmp __b1 // bobCharsetFindOrAddGlyph::@1 __b1: - // [198] if((byte) bobCharsetFindOrAddGlyph::glyph_id#11!=(byte) bob_charset_next_id#23) goto bobCharsetFindOrAddGlyph::@2 -- vbuz1_neq_vbuz2_then_la1 - lda.z glyph_id - cmp.z bob_charset_next_id + // [197] if((byte) bobCharsetFindOrAddGlyph::glyph_id#11!=(byte) bob_charset_next_id#23) goto bobCharsetFindOrAddGlyph::@2 -- vbuxx_neq_vbuz1_then_la1 + cpx.z bob_charset_next_id bne __b2_from___b1 - // [199] phi from bobCharsetFindOrAddGlyph::@1 to bobCharsetFindOrAddGlyph::@7 [phi:bobCharsetFindOrAddGlyph::@1->bobCharsetFindOrAddGlyph::@7] + // [198] phi from bobCharsetFindOrAddGlyph::@1 to bobCharsetFindOrAddGlyph::@7 [phi:bobCharsetFindOrAddGlyph::@1->bobCharsetFindOrAddGlyph::@7] __b7_from___b1: - // [199] phi (byte) bobCharsetFindOrAddGlyph::i1#2 = (byte) 0 [phi:bobCharsetFindOrAddGlyph::@1->bobCharsetFindOrAddGlyph::@7#0] -- vbuyy=vbuc1 + // [198] phi (byte) bobCharsetFindOrAddGlyph::i1#2 = (byte) 0 [phi:bobCharsetFindOrAddGlyph::@1->bobCharsetFindOrAddGlyph::@7#0] -- vbuyy=vbuc1 ldy #0 jmp __b7 // Not found - add it // bobCharsetFindOrAddGlyph::@7 __b7: - // [200] if((byte) bobCharsetFindOrAddGlyph::i1#2<(byte) 8) goto bobCharsetFindOrAddGlyph::@8 -- vbuyy_lt_vbuc1_then_la1 + // [199] if((byte) bobCharsetFindOrAddGlyph::i1#2<(byte) 8) goto bobCharsetFindOrAddGlyph::@8 -- vbuyy_lt_vbuc1_then_la1 cpy #8 bcc __b8 jmp __b9 // bobCharsetFindOrAddGlyph::@9 __b9: - // [201] (byte) bob_charset_next_id#8 ← ++ (byte) bob_charset_next_id#23 -- vbuz1=_inc_vbuz1 + // [200] (byte) bob_charset_next_id#8 ← ++ (byte) bob_charset_next_id#23 -- vbuz1=_inc_vbuz1 inc.z bob_charset_next_id - // [202] phi from bobCharsetFindOrAddGlyph::@5 bobCharsetFindOrAddGlyph::@9 to bobCharsetFindOrAddGlyph::@return [phi:bobCharsetFindOrAddGlyph::@5/bobCharsetFindOrAddGlyph::@9->bobCharsetFindOrAddGlyph::@return] + // [201] phi from bobCharsetFindOrAddGlyph::@5 bobCharsetFindOrAddGlyph::@9 to bobCharsetFindOrAddGlyph::@return [phi:bobCharsetFindOrAddGlyph::@5/bobCharsetFindOrAddGlyph::@9->bobCharsetFindOrAddGlyph::@return] __breturn_from___b5: __breturn_from___b9: - // [202] phi (byte) bob_charset_next_id#16 = (byte) bob_charset_next_id#23 [phi:bobCharsetFindOrAddGlyph::@5/bobCharsetFindOrAddGlyph::@9->bobCharsetFindOrAddGlyph::@return#0] -- register_copy + // [201] phi (byte) bob_charset_next_id#16 = (byte) bob_charset_next_id#23 [phi:bobCharsetFindOrAddGlyph::@5/bobCharsetFindOrAddGlyph::@9->bobCharsetFindOrAddGlyph::@return#0] -- register_copy jmp __breturn // bobCharsetFindOrAddGlyph::@return __breturn: - // [203] return + // [202] return rts // bobCharsetFindOrAddGlyph::@8 __b8: - // [204] *((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) bobCharsetFindOrAddGlyph::i1#2) ← *((byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 + (byte) bobCharsetFindOrAddGlyph::i1#2) -- pbuz1_derefidx_vbuyy=pbuz2_derefidx_vbuyy + // [203] *((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) bobCharsetFindOrAddGlyph::i1#2) ← *((byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 + (byte) bobCharsetFindOrAddGlyph::i1#2) -- pbuz1_derefidx_vbuyy=pbuz2_derefidx_vbuyy lda (bob_glyph),y sta (glyph_cursor),y - // [205] (byte) bobCharsetFindOrAddGlyph::i1#1 ← ++ (byte) bobCharsetFindOrAddGlyph::i1#2 -- vbuyy=_inc_vbuyy + // [204] (byte) bobCharsetFindOrAddGlyph::i1#1 ← ++ (byte) bobCharsetFindOrAddGlyph::i1#2 -- vbuyy=_inc_vbuyy iny - // [199] phi from bobCharsetFindOrAddGlyph::@8 to bobCharsetFindOrAddGlyph::@7 [phi:bobCharsetFindOrAddGlyph::@8->bobCharsetFindOrAddGlyph::@7] + // [198] phi from bobCharsetFindOrAddGlyph::@8 to bobCharsetFindOrAddGlyph::@7 [phi:bobCharsetFindOrAddGlyph::@8->bobCharsetFindOrAddGlyph::@7] __b7_from___b8: - // [199] phi (byte) bobCharsetFindOrAddGlyph::i1#2 = (byte) bobCharsetFindOrAddGlyph::i1#1 [phi:bobCharsetFindOrAddGlyph::@8->bobCharsetFindOrAddGlyph::@7#0] -- register_copy + // [198] phi (byte) bobCharsetFindOrAddGlyph::i1#2 = (byte) bobCharsetFindOrAddGlyph::i1#1 [phi:bobCharsetFindOrAddGlyph::@8->bobCharsetFindOrAddGlyph::@7#0] -- register_copy jmp __b7 - // [206] phi from bobCharsetFindOrAddGlyph::@1 to bobCharsetFindOrAddGlyph::@2 [phi:bobCharsetFindOrAddGlyph::@1->bobCharsetFindOrAddGlyph::@2] + // [205] phi from bobCharsetFindOrAddGlyph::@1 to bobCharsetFindOrAddGlyph::@2 [phi:bobCharsetFindOrAddGlyph::@1->bobCharsetFindOrAddGlyph::@2] __b2_from___b1: - // [206] phi (byte) bobCharsetFindOrAddGlyph::i#2 = (byte) 0 [phi:bobCharsetFindOrAddGlyph::@1->bobCharsetFindOrAddGlyph::@2#0] -- vbuz1=vbuc1 - lda #0 - sta.z i + // [205] phi (byte) bobCharsetFindOrAddGlyph::i#2 = (byte) 0 [phi:bobCharsetFindOrAddGlyph::@1->bobCharsetFindOrAddGlyph::@2#0] -- vbuyy=vbuc1 + ldy #0 jmp __b2 // bobCharsetFindOrAddGlyph::@2 __b2: - // [207] if((byte) bobCharsetFindOrAddGlyph::i#2<(byte) 8) goto bobCharsetFindOrAddGlyph::@3 -- vbuz1_lt_vbuc1_then_la1 - lda.z i - cmp #8 + // [206] if((byte) bobCharsetFindOrAddGlyph::i#2<(byte) 8) goto bobCharsetFindOrAddGlyph::@3 -- vbuyy_lt_vbuc1_then_la1 + cpy #8 bcc __b3 - // [209] phi from bobCharsetFindOrAddGlyph::@2 to bobCharsetFindOrAddGlyph::@5 [phi:bobCharsetFindOrAddGlyph::@2->bobCharsetFindOrAddGlyph::@5] + // [208] phi from bobCharsetFindOrAddGlyph::@2 to bobCharsetFindOrAddGlyph::@5 [phi:bobCharsetFindOrAddGlyph::@2->bobCharsetFindOrAddGlyph::@5] __b5_from___b2: - // [209] phi (byte) bobCharsetFindOrAddGlyph::found#2 = (byte) 1 [phi:bobCharsetFindOrAddGlyph::@2->bobCharsetFindOrAddGlyph::@5#0] -- vbuaa=vbuc1 + // [208] phi (byte) bobCharsetFindOrAddGlyph::found#2 = (byte) 1 [phi:bobCharsetFindOrAddGlyph::@2->bobCharsetFindOrAddGlyph::@5#0] -- vbuaa=vbuc1 lda #1 jmp __b5 // bobCharsetFindOrAddGlyph::@3 __b3: - // [208] if(*((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) bobCharsetFindOrAddGlyph::i#2)==*((byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 + (byte) bobCharsetFindOrAddGlyph::i#2)) goto bobCharsetFindOrAddGlyph::@4 -- pbuz1_derefidx_vbuz2_eq_pbuz3_derefidx_vbuz2_then_la1 - ldy.z i + // [207] if(*((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) bobCharsetFindOrAddGlyph::i#2)==*((byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 + (byte) bobCharsetFindOrAddGlyph::i#2)) goto bobCharsetFindOrAddGlyph::@4 -- pbuz1_derefidx_vbuyy_eq_pbuz2_derefidx_vbuyy_then_la1 lda (glyph_cursor),y - tax - lda (bob_glyph),y - tay - sty.z $ff - cpx.z $ff + cmp (bob_glyph),y beq __b4 - // [209] phi from bobCharsetFindOrAddGlyph::@3 to bobCharsetFindOrAddGlyph::@5 [phi:bobCharsetFindOrAddGlyph::@3->bobCharsetFindOrAddGlyph::@5] + // [208] phi from bobCharsetFindOrAddGlyph::@3 to bobCharsetFindOrAddGlyph::@5 [phi:bobCharsetFindOrAddGlyph::@3->bobCharsetFindOrAddGlyph::@5] __b5_from___b3: - // [209] phi (byte) bobCharsetFindOrAddGlyph::found#2 = (byte) 0 [phi:bobCharsetFindOrAddGlyph::@3->bobCharsetFindOrAddGlyph::@5#0] -- vbuaa=vbuc1 + // [208] phi (byte) bobCharsetFindOrAddGlyph::found#2 = (byte) 0 [phi:bobCharsetFindOrAddGlyph::@3->bobCharsetFindOrAddGlyph::@5#0] -- vbuaa=vbuc1 lda #0 jmp __b5 // bobCharsetFindOrAddGlyph::@5 __b5: - // [210] if((byte) 0==(byte) bobCharsetFindOrAddGlyph::found#2) goto bobCharsetFindOrAddGlyph::@6 -- vbuc1_eq_vbuaa_then_la1 + // [209] if((byte) 0==(byte) bobCharsetFindOrAddGlyph::found#2) goto bobCharsetFindOrAddGlyph::@6 -- vbuc1_eq_vbuaa_then_la1 cmp #0 beq __b6 jmp __breturn_from___b5 // bobCharsetFindOrAddGlyph::@6 __b6: - // [211] (byte) bobCharsetFindOrAddGlyph::glyph_id#1 ← ++ (byte) bobCharsetFindOrAddGlyph::glyph_id#11 -- vbuz1=_inc_vbuz1 - inc.z glyph_id - // [212] (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#1 ← (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) 8 -- pbuz1=pbuz1_plus_vbuc1 + // [210] (byte) bobCharsetFindOrAddGlyph::glyph_id#1 ← ++ (byte) bobCharsetFindOrAddGlyph::glyph_id#11 -- vbuxx=_inc_vbuxx + inx + // [211] (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#1 ← (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) 8 -- pbuz1=pbuz1_plus_vbuc1 lda #8 clc adc.z glyph_cursor @@ -8832,112 +8765,112 @@ bobCharsetFindOrAddGlyph: { bcc !+ inc.z glyph_cursor+1 !: - // [197] phi from bobCharsetFindOrAddGlyph::@6 to bobCharsetFindOrAddGlyph::@1 [phi:bobCharsetFindOrAddGlyph::@6->bobCharsetFindOrAddGlyph::@1] + // [196] phi from bobCharsetFindOrAddGlyph::@6 to bobCharsetFindOrAddGlyph::@1 [phi:bobCharsetFindOrAddGlyph::@6->bobCharsetFindOrAddGlyph::@1] __b1_from___b6: - // [197] phi (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 = (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#1 [phi:bobCharsetFindOrAddGlyph::@6->bobCharsetFindOrAddGlyph::@1#0] -- register_copy - // [197] phi (byte) bobCharsetFindOrAddGlyph::glyph_id#11 = (byte) bobCharsetFindOrAddGlyph::glyph_id#1 [phi:bobCharsetFindOrAddGlyph::@6->bobCharsetFindOrAddGlyph::@1#1] -- register_copy + // [196] phi (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 = (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#1 [phi:bobCharsetFindOrAddGlyph::@6->bobCharsetFindOrAddGlyph::@1#0] -- register_copy + // [196] phi (byte) bobCharsetFindOrAddGlyph::glyph_id#11 = (byte) bobCharsetFindOrAddGlyph::glyph_id#1 [phi:bobCharsetFindOrAddGlyph::@6->bobCharsetFindOrAddGlyph::@1#1] -- register_copy jmp __b1 // bobCharsetFindOrAddGlyph::@4 __b4: - // [213] (byte) bobCharsetFindOrAddGlyph::i#1 ← ++ (byte) bobCharsetFindOrAddGlyph::i#2 -- vbuz1=_inc_vbuz1 - inc.z i - // [206] phi from bobCharsetFindOrAddGlyph::@4 to bobCharsetFindOrAddGlyph::@2 [phi:bobCharsetFindOrAddGlyph::@4->bobCharsetFindOrAddGlyph::@2] + // [212] (byte) bobCharsetFindOrAddGlyph::i#1 ← ++ (byte) bobCharsetFindOrAddGlyph::i#2 -- vbuyy=_inc_vbuyy + iny + // [205] phi from bobCharsetFindOrAddGlyph::@4 to bobCharsetFindOrAddGlyph::@2 [phi:bobCharsetFindOrAddGlyph::@4->bobCharsetFindOrAddGlyph::@2] __b2_from___b4: - // [206] phi (byte) bobCharsetFindOrAddGlyph::i#2 = (byte) bobCharsetFindOrAddGlyph::i#1 [phi:bobCharsetFindOrAddGlyph::@4->bobCharsetFindOrAddGlyph::@2#0] -- register_copy + // [205] phi (byte) bobCharsetFindOrAddGlyph::i#2 = (byte) bobCharsetFindOrAddGlyph::i#1 [phi:bobCharsetFindOrAddGlyph::@4->bobCharsetFindOrAddGlyph::@2#0] -- register_copy jmp __b2 } // shiftProtoBobRight // Shift PROTO_BOB right one X pixel shiftProtoBobRight: { .label carry = $e - .label i = $b - // [215] phi from shiftProtoBobRight to shiftProtoBobRight::@1 [phi:shiftProtoBobRight->shiftProtoBobRight::@1] + .label i = $a + // [214] phi from shiftProtoBobRight to shiftProtoBobRight::@1 [phi:shiftProtoBobRight->shiftProtoBobRight::@1] __b1_from_shiftProtoBobRight: - // [215] phi (byte) shiftProtoBobRight::carry#2 = (byte) 0 [phi:shiftProtoBobRight->shiftProtoBobRight::@1#0] -- vbuyy=vbuc1 + // [214] phi (byte) shiftProtoBobRight::carry#2 = (byte) 0 [phi:shiftProtoBobRight->shiftProtoBobRight::@1#0] -- vbuyy=vbuc1 ldy #0 - // [215] phi (byte) shiftProtoBobRight::j#3 = (byte) 0 [phi:shiftProtoBobRight->shiftProtoBobRight::@1#1] -- vbuxx=vbuc1 + // [214] phi (byte) shiftProtoBobRight::j#3 = (byte) 0 [phi:shiftProtoBobRight->shiftProtoBobRight::@1#1] -- vbuxx=vbuc1 ldx #0 - // [215] phi (byte) shiftProtoBobRight::i#2 = (byte) 0 [phi:shiftProtoBobRight->shiftProtoBobRight::@1#2] -- vbuz1=vbuc1 + // [214] phi (byte) shiftProtoBobRight::i#2 = (byte) 0 [phi:shiftProtoBobRight->shiftProtoBobRight::@1#2] -- vbuz1=vbuc1 lda #0 sta.z i jmp __b1 // shiftProtoBobRight::@1 __b1: - // [216] if((byte) shiftProtoBobRight::i#2<(byte)(number) 3*(number) 3*(number) 8) goto shiftProtoBobRight::@2 -- vbuz1_lt_vbuc1_then_la1 + // [215] if((byte) shiftProtoBobRight::i#2<(byte)(number) 3*(number) 3*(number) 8) goto shiftProtoBobRight::@2 -- vbuz1_lt_vbuc1_then_la1 lda.z i cmp #3*3*8 bcc __b2 jmp __breturn // shiftProtoBobRight::@return __breturn: - // [217] return + // [216] return rts // shiftProtoBobRight::@2 __b2: - // [218] (byte~) shiftProtoBobRight::$1 ← *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) & (byte) 1 -- vbuaa=pbuc1_derefidx_vbuxx_band_vbuc2 + // [217] (byte~) shiftProtoBobRight::$1 ← *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) & (byte) 1 -- vbuaa=pbuc1_derefidx_vbuxx_band_vbuc2 lda #1 and PROTO_BOB,x - // [219] if((byte) 0!=(byte~) shiftProtoBobRight::$1) goto shiftProtoBobRight::@3 -- vbuc1_neq_vbuaa_then_la1 + // [218] if((byte) 0!=(byte~) shiftProtoBobRight::$1) goto shiftProtoBobRight::@3 -- vbuc1_neq_vbuaa_then_la1 cmp #0 bne __b3_from___b2 - // [221] phi from shiftProtoBobRight::@2 to shiftProtoBobRight::@4 [phi:shiftProtoBobRight::@2->shiftProtoBobRight::@4] + // [220] phi from shiftProtoBobRight::@2 to shiftProtoBobRight::@4 [phi:shiftProtoBobRight::@2->shiftProtoBobRight::@4] __b4_from___b2: - // [221] phi (byte) shiftProtoBobRight::carry#1 = (byte) 0 [phi:shiftProtoBobRight::@2->shiftProtoBobRight::@4#0] -- vbuz1=vbuc1 + // [220] phi (byte) shiftProtoBobRight::carry#1 = (byte) 0 [phi:shiftProtoBobRight::@2->shiftProtoBobRight::@4#0] -- vbuz1=vbuc1 lda #0 sta.z carry jmp __b4 - // [220] phi from shiftProtoBobRight::@2 to shiftProtoBobRight::@3 [phi:shiftProtoBobRight::@2->shiftProtoBobRight::@3] + // [219] phi from shiftProtoBobRight::@2 to shiftProtoBobRight::@3 [phi:shiftProtoBobRight::@2->shiftProtoBobRight::@3] __b3_from___b2: jmp __b3 // shiftProtoBobRight::@3 __b3: - // [221] phi from shiftProtoBobRight::@3 to shiftProtoBobRight::@4 [phi:shiftProtoBobRight::@3->shiftProtoBobRight::@4] + // [220] phi from shiftProtoBobRight::@3 to shiftProtoBobRight::@4 [phi:shiftProtoBobRight::@3->shiftProtoBobRight::@4] __b4_from___b3: - // [221] phi (byte) shiftProtoBobRight::carry#1 = (byte) $80 [phi:shiftProtoBobRight::@3->shiftProtoBobRight::@4#0] -- vbuz1=vbuc1 + // [220] phi (byte) shiftProtoBobRight::carry#1 = (byte) $80 [phi:shiftProtoBobRight::@3->shiftProtoBobRight::@4#0] -- vbuz1=vbuc1 lda #$80 sta.z carry jmp __b4 // shiftProtoBobRight::@4 __b4: - // [222] (byte~) shiftProtoBobRight::$5 ← *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) >> (byte) 1 -- vbuaa=pbuc1_derefidx_vbuxx_ror_1 + // [221] (byte~) shiftProtoBobRight::$5 ← *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) >> (byte) 1 -- vbuaa=pbuc1_derefidx_vbuxx_ror_1 lda PROTO_BOB,x lsr - // [223] (byte~) shiftProtoBobRight::$6 ← (byte) shiftProtoBobRight::carry#2 | (byte~) shiftProtoBobRight::$5 -- vbuaa=vbuyy_bor_vbuaa + // [222] (byte~) shiftProtoBobRight::$6 ← (byte) shiftProtoBobRight::carry#2 | (byte~) shiftProtoBobRight::$5 -- vbuaa=vbuyy_bor_vbuaa sty.z $ff ora.z $ff - // [224] *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) ← (byte~) shiftProtoBobRight::$6 -- pbuc1_derefidx_vbuxx=vbuaa + // [223] *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) ← (byte~) shiftProtoBobRight::$6 -- pbuc1_derefidx_vbuxx=vbuaa // Shift value and add old carry sta PROTO_BOB,x - // [225] if((byte) shiftProtoBobRight::j#3>=(byte) $30) goto shiftProtoBobRight::@5 -- vbuxx_ge_vbuc1_then_la1 + // [224] if((byte) shiftProtoBobRight::j#3>=(byte) $30) goto shiftProtoBobRight::@5 -- vbuxx_ge_vbuc1_then_la1 // Increment j to iterate over the PROTO_BOB left-to-right, top-to-bottom (0, 24, 48, 1, 25, 49, ...) cpx #$30 bcs __b5 jmp __b7 // shiftProtoBobRight::@7 __b7: - // [226] (byte) shiftProtoBobRight::j#2 ← (byte) shiftProtoBobRight::j#3 + (byte) $18 -- vbuxx=vbuxx_plus_vbuc1 + // [225] (byte) shiftProtoBobRight::j#2 ← (byte) shiftProtoBobRight::j#3 + (byte) $18 -- vbuxx=vbuxx_plus_vbuc1 txa axs #-[$18] - // [227] phi from shiftProtoBobRight::@5 shiftProtoBobRight::@7 to shiftProtoBobRight::@6 [phi:shiftProtoBobRight::@5/shiftProtoBobRight::@7->shiftProtoBobRight::@6] + // [226] phi from shiftProtoBobRight::@5 shiftProtoBobRight::@7 to shiftProtoBobRight::@6 [phi:shiftProtoBobRight::@5/shiftProtoBobRight::@7->shiftProtoBobRight::@6] __b6_from___b5: __b6_from___b7: - // [227] phi (byte) shiftProtoBobRight::j#10 = (byte) shiftProtoBobRight::j#1 [phi:shiftProtoBobRight::@5/shiftProtoBobRight::@7->shiftProtoBobRight::@6#0] -- register_copy + // [226] phi (byte) shiftProtoBobRight::j#10 = (byte) shiftProtoBobRight::j#1 [phi:shiftProtoBobRight::@5/shiftProtoBobRight::@7->shiftProtoBobRight::@6#0] -- register_copy jmp __b6 // shiftProtoBobRight::@6 __b6: - // [228] (byte) shiftProtoBobRight::i#1 ← ++ (byte) shiftProtoBobRight::i#2 -- vbuz1=_inc_vbuz1 + // [227] (byte) shiftProtoBobRight::i#1 ← ++ (byte) shiftProtoBobRight::i#2 -- vbuz1=_inc_vbuz1 inc.z i - // [229] (byte) shiftProtoBobRight::carry#10 ← (byte) shiftProtoBobRight::carry#1 -- vbuyy=vbuz1 + // [228] (byte) shiftProtoBobRight::carry#10 ← (byte) shiftProtoBobRight::carry#1 -- vbuyy=vbuz1 ldy.z carry - // [215] phi from shiftProtoBobRight::@6 to shiftProtoBobRight::@1 [phi:shiftProtoBobRight::@6->shiftProtoBobRight::@1] + // [214] phi from shiftProtoBobRight::@6 to shiftProtoBobRight::@1 [phi:shiftProtoBobRight::@6->shiftProtoBobRight::@1] __b1_from___b6: - // [215] phi (byte) shiftProtoBobRight::carry#2 = (byte) shiftProtoBobRight::carry#10 [phi:shiftProtoBobRight::@6->shiftProtoBobRight::@1#0] -- register_copy - // [215] phi (byte) shiftProtoBobRight::j#3 = (byte) shiftProtoBobRight::j#10 [phi:shiftProtoBobRight::@6->shiftProtoBobRight::@1#1] -- register_copy - // [215] phi (byte) shiftProtoBobRight::i#2 = (byte) shiftProtoBobRight::i#1 [phi:shiftProtoBobRight::@6->shiftProtoBobRight::@1#2] -- register_copy + // [214] phi (byte) shiftProtoBobRight::carry#2 = (byte) shiftProtoBobRight::carry#10 [phi:shiftProtoBobRight::@6->shiftProtoBobRight::@1#0] -- register_copy + // [214] phi (byte) shiftProtoBobRight::j#3 = (byte) shiftProtoBobRight::j#10 [phi:shiftProtoBobRight::@6->shiftProtoBobRight::@1#1] -- register_copy + // [214] phi (byte) shiftProtoBobRight::i#2 = (byte) shiftProtoBobRight::i#1 [phi:shiftProtoBobRight::@6->shiftProtoBobRight::@1#2] -- register_copy jmp __b1 // shiftProtoBobRight::@5 __b5: - // [230] (byte) shiftProtoBobRight::j#1 ← (byte) shiftProtoBobRight::j#3 - (byte) $2f -- vbuxx=vbuxx_minus_vbuc1 + // [229] (byte) shiftProtoBobRight::j#1 ← (byte) shiftProtoBobRight::j#3 - (byte) $2f -- vbuxx=vbuxx_minus_vbuc1 txa axs #$2f jmp __b6_from___b5 @@ -8946,49 +8879,49 @@ shiftProtoBobRight: { // Shift PROTO_BOB down one Y pixel // At the same time restore PROTO_BOB X by shifting 8 pixels left shiftProtoBobDown: { - // [232] phi from shiftProtoBobDown to shiftProtoBobDown::@1 [phi:shiftProtoBobDown->shiftProtoBobDown::@1] + // [231] phi from shiftProtoBobDown to shiftProtoBobDown::@1 [phi:shiftProtoBobDown->shiftProtoBobDown::@1] __b1_from_shiftProtoBobDown: - // [232] phi (byte) shiftProtoBobDown::i#2 = (byte) $17 [phi:shiftProtoBobDown->shiftProtoBobDown::@1#0] -- vbuxx=vbuc1 + // [231] phi (byte) shiftProtoBobDown::i#2 = (byte) $17 [phi:shiftProtoBobDown->shiftProtoBobDown::@1#0] -- vbuxx=vbuc1 ldx #$17 jmp __b1 // shiftProtoBobDown::@1 __b1: - // [233] if((byte) shiftProtoBobDown::i#2>(byte) 0) goto shiftProtoBobDown::@2 -- vbuxx_gt_0_then_la1 + // [232] if((byte) shiftProtoBobDown::i#2>(byte) 0) goto shiftProtoBobDown::@2 -- vbuxx_gt_0_then_la1 cpx #0 bne __b2 jmp __b3 // shiftProtoBobDown::@3 __b3: - // [234] *((const byte*) PROTO_BOB) ← (byte) 0 -- _deref_pbuc1=vbuc2 + // [233] *((const byte*) PROTO_BOB) ← (byte) 0 -- _deref_pbuc1=vbuc2 lda #0 sta PROTO_BOB - // [235] *((const byte*) PROTO_BOB+(byte) $18) ← (byte) 0 -- _deref_pbuc1=vbuc2 + // [234] *((const byte*) PROTO_BOB+(byte) $18) ← (byte) 0 -- _deref_pbuc1=vbuc2 lda #0 sta PROTO_BOB+$18 - // [236] *((const byte*) PROTO_BOB+(byte) $30) ← (byte) 0 -- _deref_pbuc1=vbuc2 + // [235] *((const byte*) PROTO_BOB+(byte) $30) ← (byte) 0 -- _deref_pbuc1=vbuc2 lda #0 sta PROTO_BOB+$30 jmp __breturn // shiftProtoBobDown::@return __breturn: - // [237] return + // [236] return rts // shiftProtoBobDown::@2 __b2: - // [238] *((const byte*) PROTO_BOB + (byte) shiftProtoBobDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $17 + (byte) shiftProtoBobDown::i#2) -- pbuc1_derefidx_vbuxx=pbuc2_derefidx_vbuxx + // [237] *((const byte*) PROTO_BOB + (byte) shiftProtoBobDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $17 + (byte) shiftProtoBobDown::i#2) -- pbuc1_derefidx_vbuxx=pbuc2_derefidx_vbuxx lda PROTO_BOB+$17,x sta PROTO_BOB,x - // [239] *((const byte*) PROTO_BOB+(byte) $18 + (byte) shiftProtoBobDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $2f + (byte) shiftProtoBobDown::i#2) -- pbuc1_derefidx_vbuxx=pbuc2_derefidx_vbuxx + // [238] *((const byte*) PROTO_BOB+(byte) $18 + (byte) shiftProtoBobDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $2f + (byte) shiftProtoBobDown::i#2) -- pbuc1_derefidx_vbuxx=pbuc2_derefidx_vbuxx lda PROTO_BOB+$2f,x sta PROTO_BOB+$18,x - // [240] *((const byte*) PROTO_BOB+(byte) $30 + (byte) shiftProtoBobDown::i#2) ← (byte) 0 -- pbuc1_derefidx_vbuxx=vbuc2 + // [239] *((const byte*) PROTO_BOB+(byte) $30 + (byte) shiftProtoBobDown::i#2) ← (byte) 0 -- pbuc1_derefidx_vbuxx=vbuc2 lda #0 sta PROTO_BOB+$30,x - // [241] (byte) shiftProtoBobDown::i#1 ← -- (byte) shiftProtoBobDown::i#2 -- vbuxx=_dec_vbuxx + // [240] (byte) shiftProtoBobDown::i#1 ← -- (byte) shiftProtoBobDown::i#2 -- vbuxx=_dec_vbuxx dex - // [232] phi from shiftProtoBobDown::@2 to shiftProtoBobDown::@1 [phi:shiftProtoBobDown::@2->shiftProtoBobDown::@1] + // [231] phi from shiftProtoBobDown::@2 to shiftProtoBobDown::@1 [phi:shiftProtoBobDown::@2->shiftProtoBobDown::@1] __b1_from___b2: - // [232] phi (byte) shiftProtoBobDown::i#2 = (byte) shiftProtoBobDown::i#1 [phi:shiftProtoBobDown::@2->shiftProtoBobDown::@1#0] -- register_copy + // [231] phi (byte) shiftProtoBobDown::i#2 = (byte) shiftProtoBobDown::i#1 [phi:shiftProtoBobDown::@2->shiftProtoBobDown::@1#0] -- register_copy jmp __b1 } // progress_init @@ -8997,42 +8930,42 @@ progress_init: { jmp __breturn // progress_init::@return __breturn: - // [243] return + // [242] return rts } // mulf_init // Initialize the mulf_sqr multiplication tables with f(x)=int(x*x/4) mulf_init: { // x/2 - .label c = $f + .label c = $d // Counter used for determining x%2==0 - .label sqr1_hi = $10 + .label sqr1_hi = $f // Fill mulf_sqr1 = f(x) = int(x*x/4): If f(x) = x*x/4 then f(x+1) = f(x) + x/2 + 1/4 - .label sqr = $c + .label sqr = $b .label sqr1_lo = 6 // Decrease or increase x_255 - initially we decrease - .label sqr2_hi = 9 - .label sqr2_lo = $12 + .label sqr2_hi = 8 + .label sqr2_lo = $11 //Start with g(0)=f(255) - .label dir = 8 - // [245] phi from mulf_init to mulf_init::@1 [phi:mulf_init->mulf_init::@1] + .label dir = $e + // [244] phi from mulf_init to mulf_init::@1 [phi:mulf_init->mulf_init::@1] __b1_from_mulf_init: - // [245] phi (byte) mulf_init::x_2#3 = (byte) 0 [phi:mulf_init->mulf_init::@1#0] -- vbuxx=vbuc1 + // [244] phi (byte) mulf_init::x_2#3 = (byte) 0 [phi:mulf_init->mulf_init::@1#0] -- vbuxx=vbuc1 ldx #0 - // [245] phi (byte*) mulf_init::sqr1_hi#2 = (const byte*) mulf_sqr1_hi+(byte) 1 [phi:mulf_init->mulf_init::@1#1] -- pbuz1=pbuc1 + // [244] phi (byte*) mulf_init::sqr1_hi#2 = (const byte*) mulf_sqr1_hi+(byte) 1 [phi:mulf_init->mulf_init::@1#1] -- pbuz1=pbuc1 lda #mulf_sqr1_hi+1 sta.z sqr1_hi+1 - // [245] phi (word) mulf_init::sqr#4 = (byte) 0 [phi:mulf_init->mulf_init::@1#2] -- vwuz1=vbuc1 + // [244] phi (word) mulf_init::sqr#4 = (byte) 0 [phi:mulf_init->mulf_init::@1#2] -- vwuz1=vbuc1 lda #<0 sta.z sqr lda #>0 sta.z sqr+1 - // [245] phi (byte) mulf_init::c#2 = (byte) 0 [phi:mulf_init->mulf_init::@1#3] -- vbuz1=vbuc1 + // [244] phi (byte) mulf_init::c#2 = (byte) 0 [phi:mulf_init->mulf_init::@1#3] -- vbuz1=vbuc1 lda #0 sta.z c - // [245] phi (byte*) mulf_init::sqr1_lo#2 = (const byte*) mulf_sqr1_lo+(byte) 1 [phi:mulf_init->mulf_init::@1#4] -- pbuz1=pbuc1 + // [244] phi (byte*) mulf_init::sqr1_lo#2 = (const byte*) mulf_sqr1_lo+(byte) 1 [phi:mulf_init->mulf_init::@1#4] -- pbuz1=pbuc1 lda #mulf_sqr1_lo+1 @@ -9040,26 +8973,26 @@ mulf_init: { jmp __b1 // mulf_init::@1 __b1: - // [246] if((byte*) mulf_init::sqr1_lo#2!=(const byte*) mulf_sqr1_lo+(word) $200) goto mulf_init::@2 -- pbuz1_neq_pbuc1_then_la1 + // [245] if((byte*) mulf_init::sqr1_lo#2!=(const byte*) mulf_sqr1_lo+(word) $200) goto mulf_init::@2 -- pbuz1_neq_pbuc1_then_la1 lda.z sqr1_lo+1 cmp #>mulf_sqr1_lo+$200 bne __b2 lda.z sqr1_lo cmp #mulf_init::@5] + // [246] phi from mulf_init::@1 to mulf_init::@5 [phi:mulf_init::@1->mulf_init::@5] __b5_from___b1: - // [247] phi (byte) mulf_init::dir#2 = (byte) $ff [phi:mulf_init::@1->mulf_init::@5#0] -- vbuz1=vbuc1 + // [246] phi (byte) mulf_init::dir#2 = (byte) $ff [phi:mulf_init::@1->mulf_init::@5#0] -- vbuz1=vbuc1 lda #$ff sta.z dir - // [247] phi (byte*) mulf_init::sqr2_hi#2 = (const byte*) mulf_sqr2_hi [phi:mulf_init::@1->mulf_init::@5#1] -- pbuz1=pbuc1 + // [246] phi (byte*) mulf_init::sqr2_hi#2 = (const byte*) mulf_sqr2_hi [phi:mulf_init::@1->mulf_init::@5#1] -- pbuz1=pbuc1 lda #mulf_sqr2_hi sta.z sqr2_hi+1 - // [247] phi (byte) mulf_init::x_255#2 = (byte) -1 [phi:mulf_init::@1->mulf_init::@5#2] -- vbuxx=vbuc1 + // [246] phi (byte) mulf_init::x_255#2 = (byte) -1 [phi:mulf_init::@1->mulf_init::@5#2] -- vbuxx=vbuc1 ldx #-1 - // [247] phi (byte*) mulf_init::sqr2_lo#2 = (const byte*) mulf_sqr2_lo [phi:mulf_init::@1->mulf_init::@5#3] -- pbuz1=pbuc1 + // [246] phi (byte*) mulf_init::sqr2_lo#2 = (const byte*) mulf_sqr2_lo [phi:mulf_init::@1->mulf_init::@5#3] -- pbuz1=pbuc1 lda #mulf_sqr2_lo @@ -9067,7 +9000,7 @@ mulf_init: { jmp __b5 // mulf_init::@5 __b5: - // [248] if((byte*) mulf_init::sqr2_lo#2!=(const byte*) mulf_sqr2_lo+(word) $1ff) goto mulf_init::@6 -- pbuz1_neq_pbuc1_then_la1 + // [247] if((byte*) mulf_init::sqr2_lo#2!=(const byte*) mulf_sqr2_lo+(word) $1ff) goto mulf_init::@6 -- pbuz1_neq_pbuc1_then_la1 lda.z sqr2_lo+1 cmp #>mulf_sqr2_lo+$1ff bne __b6 @@ -9077,114 +9010,114 @@ mulf_init: { jmp __b7 // mulf_init::@7 __b7: - // [249] *((const byte*) mulf_sqr2_lo+(word) $1ff) ← *((const byte*) mulf_sqr1_lo+(word) $100) -- _deref_pbuc1=_deref_pbuc2 + // [248] *((const byte*) mulf_sqr2_lo+(word) $1ff) ← *((const byte*) mulf_sqr1_lo+(word) $100) -- _deref_pbuc1=_deref_pbuc2 // Set the very last value g(511) = f(256) lda mulf_sqr1_lo+$100 sta mulf_sqr2_lo+$1ff - // [250] *((const byte*) mulf_sqr2_hi+(word) $1ff) ← *((const byte*) mulf_sqr1_hi+(word) $100) -- _deref_pbuc1=_deref_pbuc2 + // [249] *((const byte*) mulf_sqr2_hi+(word) $1ff) ← *((const byte*) mulf_sqr1_hi+(word) $100) -- _deref_pbuc1=_deref_pbuc2 lda mulf_sqr1_hi+$100 sta mulf_sqr2_hi+$1ff jmp __breturn // mulf_init::@return __breturn: - // [251] return + // [250] return rts // mulf_init::@6 __b6: - // [252] *((byte*) mulf_init::sqr2_lo#2) ← *((const byte*) mulf_sqr1_lo + (byte) mulf_init::x_255#2) -- _deref_pbuz1=pbuc1_derefidx_vbuxx + // [251] *((byte*) mulf_init::sqr2_lo#2) ← *((const byte*) mulf_sqr1_lo + (byte) mulf_init::x_255#2) -- _deref_pbuz1=pbuc1_derefidx_vbuxx lda mulf_sqr1_lo,x ldy #0 sta (sqr2_lo),y - // [253] *((byte*) mulf_init::sqr2_hi#2) ← *((const byte*) mulf_sqr1_hi + (byte) mulf_init::x_255#2) -- _deref_pbuz1=pbuc1_derefidx_vbuxx + // [252] *((byte*) mulf_init::sqr2_hi#2) ← *((const byte*) mulf_sqr1_hi + (byte) mulf_init::x_255#2) -- _deref_pbuz1=pbuc1_derefidx_vbuxx lda mulf_sqr1_hi,x ldy #0 sta (sqr2_hi),y - // [254] (byte*) mulf_init::sqr2_hi#1 ← ++ (byte*) mulf_init::sqr2_hi#2 -- pbuz1=_inc_pbuz1 + // [253] (byte*) mulf_init::sqr2_hi#1 ← ++ (byte*) mulf_init::sqr2_hi#2 -- pbuz1=_inc_pbuz1 inc.z sqr2_hi bne !+ inc.z sqr2_hi+1 !: - // [255] (byte) mulf_init::x_255#1 ← (byte) mulf_init::x_255#2 + (byte) mulf_init::dir#2 -- vbuxx=vbuxx_plus_vbuz1 + // [254] (byte) mulf_init::x_255#1 ← (byte) mulf_init::x_255#2 + (byte) mulf_init::dir#2 -- vbuxx=vbuxx_plus_vbuz1 txa clc adc.z dir tax - // [256] if((byte) mulf_init::x_255#1!=(byte) 0) goto mulf_init::@9 -- vbuxx_neq_0_then_la1 + // [255] if((byte) mulf_init::x_255#1!=(byte) 0) goto mulf_init::@9 -- vbuxx_neq_0_then_la1 cpx #0 bne __b9_from___b6 - // [258] phi from mulf_init::@6 to mulf_init::@8 [phi:mulf_init::@6->mulf_init::@8] + // [257] phi from mulf_init::@6 to mulf_init::@8 [phi:mulf_init::@6->mulf_init::@8] __b8_from___b6: - // [258] phi (byte) mulf_init::dir#4 = (byte) 1 [phi:mulf_init::@6->mulf_init::@8#0] -- vbuz1=vbuc1 + // [257] phi (byte) mulf_init::dir#4 = (byte) 1 [phi:mulf_init::@6->mulf_init::@8#0] -- vbuz1=vbuc1 lda #1 sta.z dir jmp __b8 - // [257] phi from mulf_init::@6 to mulf_init::@9 [phi:mulf_init::@6->mulf_init::@9] + // [256] phi from mulf_init::@6 to mulf_init::@9 [phi:mulf_init::@6->mulf_init::@9] __b9_from___b6: jmp __b9 // mulf_init::@9 __b9: - // [258] phi from mulf_init::@9 to mulf_init::@8 [phi:mulf_init::@9->mulf_init::@8] + // [257] phi from mulf_init::@9 to mulf_init::@8 [phi:mulf_init::@9->mulf_init::@8] __b8_from___b9: - // [258] phi (byte) mulf_init::dir#4 = (byte) mulf_init::dir#2 [phi:mulf_init::@9->mulf_init::@8#0] -- register_copy + // [257] phi (byte) mulf_init::dir#4 = (byte) mulf_init::dir#2 [phi:mulf_init::@9->mulf_init::@8#0] -- register_copy jmp __b8 // mulf_init::@8 __b8: - // [259] (byte*) mulf_init::sqr2_lo#1 ← ++ (byte*) mulf_init::sqr2_lo#2 -- pbuz1=_inc_pbuz1 + // [258] (byte*) mulf_init::sqr2_lo#1 ← ++ (byte*) mulf_init::sqr2_lo#2 -- pbuz1=_inc_pbuz1 inc.z sqr2_lo bne !+ inc.z sqr2_lo+1 !: - // [247] phi from mulf_init::@8 to mulf_init::@5 [phi:mulf_init::@8->mulf_init::@5] + // [246] phi from mulf_init::@8 to mulf_init::@5 [phi:mulf_init::@8->mulf_init::@5] __b5_from___b8: - // [247] phi (byte) mulf_init::dir#2 = (byte) mulf_init::dir#4 [phi:mulf_init::@8->mulf_init::@5#0] -- register_copy - // [247] phi (byte*) mulf_init::sqr2_hi#2 = (byte*) mulf_init::sqr2_hi#1 [phi:mulf_init::@8->mulf_init::@5#1] -- register_copy - // [247] phi (byte) mulf_init::x_255#2 = (byte) mulf_init::x_255#1 [phi:mulf_init::@8->mulf_init::@5#2] -- register_copy - // [247] phi (byte*) mulf_init::sqr2_lo#2 = (byte*) mulf_init::sqr2_lo#1 [phi:mulf_init::@8->mulf_init::@5#3] -- register_copy + // [246] phi (byte) mulf_init::dir#2 = (byte) mulf_init::dir#4 [phi:mulf_init::@8->mulf_init::@5#0] -- register_copy + // [246] phi (byte*) mulf_init::sqr2_hi#2 = (byte*) mulf_init::sqr2_hi#1 [phi:mulf_init::@8->mulf_init::@5#1] -- register_copy + // [246] phi (byte) mulf_init::x_255#2 = (byte) mulf_init::x_255#1 [phi:mulf_init::@8->mulf_init::@5#2] -- register_copy + // [246] phi (byte*) mulf_init::sqr2_lo#2 = (byte*) mulf_init::sqr2_lo#1 [phi:mulf_init::@8->mulf_init::@5#3] -- register_copy jmp __b5 // mulf_init::@2 __b2: - // [260] (byte) mulf_init::c#1 ← ++ (byte) mulf_init::c#2 -- vbuz1=_inc_vbuz1 + // [259] (byte) mulf_init::c#1 ← ++ (byte) mulf_init::c#2 -- vbuz1=_inc_vbuz1 inc.z c - // [261] (byte~) mulf_init::$1 ← (byte) mulf_init::c#1 & (byte) 1 -- vbuaa=vbuz1_band_vbuc1 + // [260] (byte~) mulf_init::$1 ← (byte) mulf_init::c#1 & (byte) 1 -- vbuaa=vbuz1_band_vbuc1 lda #1 and.z c - // [262] if((byte~) mulf_init::$1!=(byte) 0) goto mulf_init::@3 -- vbuaa_neq_0_then_la1 + // [261] if((byte~) mulf_init::$1!=(byte) 0) goto mulf_init::@3 -- vbuaa_neq_0_then_la1 cmp #0 bne __b3_from___b2 jmp __b4 // mulf_init::@4 __b4: - // [263] (byte) mulf_init::x_2#1 ← ++ (byte) mulf_init::x_2#3 -- vbuxx=_inc_vbuxx + // [262] (byte) mulf_init::x_2#1 ← ++ (byte) mulf_init::x_2#3 -- vbuxx=_inc_vbuxx inx - // [264] (word) mulf_init::sqr#2 ← ++ (word) mulf_init::sqr#4 -- vwuz1=_inc_vwuz1 + // [263] (word) mulf_init::sqr#2 ← ++ (word) mulf_init::sqr#4 -- vwuz1=_inc_vwuz1 inc.z sqr bne !+ inc.z sqr+1 !: - // [265] phi from mulf_init::@2 mulf_init::@4 to mulf_init::@3 [phi:mulf_init::@2/mulf_init::@4->mulf_init::@3] + // [264] phi from mulf_init::@2 mulf_init::@4 to mulf_init::@3 [phi:mulf_init::@2/mulf_init::@4->mulf_init::@3] __b3_from___b2: __b3_from___b4: - // [265] phi (byte) mulf_init::x_2#2 = (byte) mulf_init::x_2#3 [phi:mulf_init::@2/mulf_init::@4->mulf_init::@3#0] -- register_copy - // [265] phi (word) mulf_init::sqr#3 = (word) mulf_init::sqr#4 [phi:mulf_init::@2/mulf_init::@4->mulf_init::@3#1] -- register_copy + // [264] phi (byte) mulf_init::x_2#2 = (byte) mulf_init::x_2#3 [phi:mulf_init::@2/mulf_init::@4->mulf_init::@3#0] -- register_copy + // [264] phi (word) mulf_init::sqr#3 = (word) mulf_init::sqr#4 [phi:mulf_init::@2/mulf_init::@4->mulf_init::@3#1] -- register_copy jmp __b3 // mulf_init::@3 __b3: - // [266] (byte~) mulf_init::$4 ← < (word) mulf_init::sqr#3 -- vbuaa=_lo_vwuz1 + // [265] (byte~) mulf_init::$4 ← < (word) mulf_init::sqr#3 -- vbuaa=_lo_vwuz1 lda.z sqr - // [267] *((byte*) mulf_init::sqr1_lo#2) ← (byte~) mulf_init::$4 -- _deref_pbuz1=vbuaa + // [266] *((byte*) mulf_init::sqr1_lo#2) ← (byte~) mulf_init::$4 -- _deref_pbuz1=vbuaa ldy #0 sta (sqr1_lo),y - // [268] (byte~) mulf_init::$5 ← > (word) mulf_init::sqr#3 -- vbuaa=_hi_vwuz1 + // [267] (byte~) mulf_init::$5 ← > (word) mulf_init::sqr#3 -- vbuaa=_hi_vwuz1 lda.z sqr+1 - // [269] *((byte*) mulf_init::sqr1_hi#2) ← (byte~) mulf_init::$5 -- _deref_pbuz1=vbuaa + // [268] *((byte*) mulf_init::sqr1_hi#2) ← (byte~) mulf_init::$5 -- _deref_pbuz1=vbuaa ldy #0 sta (sqr1_hi),y - // [270] (byte*) mulf_init::sqr1_hi#1 ← ++ (byte*) mulf_init::sqr1_hi#2 -- pbuz1=_inc_pbuz1 + // [269] (byte*) mulf_init::sqr1_hi#1 ← ++ (byte*) mulf_init::sqr1_hi#2 -- pbuz1=_inc_pbuz1 inc.z sqr1_hi bne !+ inc.z sqr1_hi+1 !: - // [271] (word) mulf_init::sqr#1 ← (word) mulf_init::sqr#3 + (byte) mulf_init::x_2#2 -- vwuz1=vwuz1_plus_vbuxx + // [270] (word) mulf_init::sqr#1 ← (word) mulf_init::sqr#3 + (byte) mulf_init::x_2#2 -- vwuz1=vwuz1_plus_vbuxx txa clc adc.z sqr @@ -9192,18 +9125,18 @@ mulf_init: { bcc !+ inc.z sqr+1 !: - // [272] (byte*) mulf_init::sqr1_lo#1 ← ++ (byte*) mulf_init::sqr1_lo#2 -- pbuz1=_inc_pbuz1 + // [271] (byte*) mulf_init::sqr1_lo#1 ← ++ (byte*) mulf_init::sqr1_lo#2 -- pbuz1=_inc_pbuz1 inc.z sqr1_lo bne !+ inc.z sqr1_lo+1 !: - // [245] phi from mulf_init::@3 to mulf_init::@1 [phi:mulf_init::@3->mulf_init::@1] + // [244] phi from mulf_init::@3 to mulf_init::@1 [phi:mulf_init::@3->mulf_init::@1] __b1_from___b3: - // [245] phi (byte) mulf_init::x_2#3 = (byte) mulf_init::x_2#2 [phi:mulf_init::@3->mulf_init::@1#0] -- register_copy - // [245] phi (byte*) mulf_init::sqr1_hi#2 = (byte*) mulf_init::sqr1_hi#1 [phi:mulf_init::@3->mulf_init::@1#1] -- register_copy - // [245] phi (word) mulf_init::sqr#4 = (word) mulf_init::sqr#1 [phi:mulf_init::@3->mulf_init::@1#2] -- register_copy - // [245] phi (byte) mulf_init::c#2 = (byte) mulf_init::c#1 [phi:mulf_init::@3->mulf_init::@1#3] -- register_copy - // [245] phi (byte*) mulf_init::sqr1_lo#2 = (byte*) mulf_init::sqr1_lo#1 [phi:mulf_init::@3->mulf_init::@1#4] -- register_copy + // [244] phi (byte) mulf_init::x_2#3 = (byte) mulf_init::x_2#2 [phi:mulf_init::@3->mulf_init::@1#0] -- register_copy + // [244] phi (byte*) mulf_init::sqr1_hi#2 = (byte*) mulf_init::sqr1_hi#1 [phi:mulf_init::@3->mulf_init::@1#1] -- register_copy + // [244] phi (word) mulf_init::sqr#4 = (word) mulf_init::sqr#1 [phi:mulf_init::@3->mulf_init::@1#2] -- register_copy + // [244] phi (byte) mulf_init::c#2 = (byte) mulf_init::c#1 [phi:mulf_init::@3->mulf_init::@1#3] -- register_copy + // [244] phi (byte*) mulf_init::sqr1_lo#2 = (byte*) mulf_init::sqr1_lo#1 [phi:mulf_init::@3->mulf_init::@1#4] -- register_copy jmp __b1 } // File Data @@ -9253,7 +9186,6 @@ SIN: ASSEMBLER OPTIMIZATIONS Removing instruction jmp __b1 -Removing instruction jmp __b2 Removing instruction jmp __bend Removing instruction jmp __b9 Removing instruction jmp __b10 @@ -9381,9 +9313,9 @@ Replacing label __b6_from___b5 with __b6 Replacing label __b9_from___b6 with __b8 Replacing label __b3_from___b2 with __b3 Removing instruction __bbegin: -Removing instruction __b2_from___b1: -Removing instruction main_from___b2: -Removing instruction __bend_from___b2: +Removing instruction __b1_from___bbegin: +Removing instruction main_from___b1: +Removing instruction __bend_from___b1: Removing instruction __b9_from_main: Removing instruction prepareBobs_from___b9: Removing instruction __b10_from___b9: @@ -9430,7 +9362,6 @@ Removing instruction __b8_from___b9: Removing instruction __b3_from___b2: Removing instruction __b3_from___b4: Succesful ASM optimization Pass5RedundantLabelElimination -Removing instruction __b2: Removing instruction __bend: Removing instruction mulf_init_from_main: Removing instruction __b9: @@ -9545,7 +9476,6 @@ Succesful ASM optimization Pass5UnusedLabelElimination FINAL SYMBOL TABLE (label) @1 -(label) @2 (label) @begin (label) @end (const byte*) BOB_CHARSET = (byte*) 8192 @@ -9598,26 +9528,26 @@ FINAL SYMBOL TABLE (byte) bobCharsetFindOrAddGlyph::found (byte) bobCharsetFindOrAddGlyph::found#2 reg byte a 10001.0 (byte*) bobCharsetFindOrAddGlyph::glyph_cursor -(byte*) bobCharsetFindOrAddGlyph::glyph_cursor#1 glyph_cursor zp[2]:18 20002.0 -(byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 glyph_cursor zp[2]:18 10000.307692307691 +(byte*) bobCharsetFindOrAddGlyph::glyph_cursor#1 glyph_cursor zp[2]:17 20002.0 +(byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 glyph_cursor zp[2]:17 10000.307692307691 (byte) bobCharsetFindOrAddGlyph::glyph_id -(byte) bobCharsetFindOrAddGlyph::glyph_id#1 glyph_id zp[1]:14 10001.0 -(byte) bobCharsetFindOrAddGlyph::glyph_id#11 glyph_id zp[1]:14 1937.75 +(byte) bobCharsetFindOrAddGlyph::glyph_id#1 reg byte x 10001.0 +(byte) bobCharsetFindOrAddGlyph::glyph_id#11 reg byte x 1937.75 (byte) bobCharsetFindOrAddGlyph::i -(byte) bobCharsetFindOrAddGlyph::i#1 i zp[1]:8 200002.0 -(byte) bobCharsetFindOrAddGlyph::i#2 i zp[1]:8 166668.3333333333 +(byte) bobCharsetFindOrAddGlyph::i#1 reg byte y 200002.0 +(byte) bobCharsetFindOrAddGlyph::i#2 reg byte y 166668.3333333333 (byte) bobCharsetFindOrAddGlyph::i1 (byte) bobCharsetFindOrAddGlyph::i1#1 reg byte y 20002.0 (byte) bobCharsetFindOrAddGlyph::i1#2 reg byte y 16668.333333333332 (byte) bobCharsetFindOrAddGlyph::return (byte) bobCharsetFindOrAddGlyph::return#1 reg byte a 2002.0 (byte) bob_charset_next_id -(byte) bob_charset_next_id#14 bob_charset_next_id zp[1]:15 12.0 -(byte) bob_charset_next_id#16 bob_charset_next_id zp[1]:15 1000.5454545454544 -(byte) bob_charset_next_id#21 bob_charset_next_id zp[1]:15 275.5 -(byte) bob_charset_next_id#23 bob_charset_next_id zp[1]:15 1400.3333333333335 -(byte) bob_charset_next_id#30 bob_charset_next_id zp[1]:15 37.33333333333333 -(byte) bob_charset_next_id#8 bob_charset_next_id zp[1]:15 4.0 +(byte) bob_charset_next_id#14 bob_charset_next_id zp[1]:13 12.0 +(byte) bob_charset_next_id#16 bob_charset_next_id zp[1]:13 1000.5454545454544 +(byte) bob_charset_next_id#21 bob_charset_next_id zp[1]:13 275.5 +(byte) bob_charset_next_id#23 bob_charset_next_id zp[1]:13 1400.3333333333335 +(byte) bob_charset_next_id#30 bob_charset_next_id zp[1]:13 37.33333333333333 +(byte) bob_charset_next_id#8 bob_charset_next_id zp[1]:13 4.0 (byte()) keyboard_key_pressed((byte) keyboard_key_pressed::key) (byte~) keyboard_key_pressed::$2 reg byte a 4.0 (label) keyboard_key_pressed::@1 @@ -9641,9 +9571,9 @@ FINAL SYMBOL TABLE (byte) keyboard_matrix_read::rowid (const byte*) keyboard_matrix_row_bitmask = { (byte) $fe, (byte) $fd, (byte) $fb, (byte) $f7, (byte) $ef, (byte) $df, (byte) $bf, (byte) $7f } (void()) main() -(signed word~) main::$10 zp[2]:12 202.0 -(signed word~) main::$12 zp[2]:12 202.0 -(signed word~) main::$13 zp[2]:12 202.0 +(signed word~) main::$10 zp[2]:11 202.0 +(signed word~) main::$12 zp[2]:11 202.0 +(signed word~) main::$13 zp[2]:11 202.0 (byte~) main::$19 reg byte a 22.0 (byte~) main::$21 reg byte a 22.0 (label) main::@1 @@ -9701,9 +9631,9 @@ FINAL SYMBOL TABLE (byte) main::vicSelectGfxBank2_toDd001_return (const byte) main::vicSelectGfxBank2_toDd001_return#0 vicSelectGfxBank2_toDd001_return = (byte) 3 (signed word) main::x -(signed word) main::x#0 x zp[2]:9 18.363636363636363 +(signed word) main::x#0 x zp[2]:8 18.363636363636363 (signed word) main::y -(signed word) main::y#0 y zp[2]:12 40.4 +(signed word) main::y#0 y zp[2]:11 40.4 (void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num) (label) memset::@1 (label) memset::@2 @@ -9735,9 +9665,9 @@ FINAL SYMBOL TABLE (signed byte) mulf8s::mulf8s_prepare1_a (signed byte) mulf8s::mulf8s_prepare1_a#0 reg byte a 202.0 (signed word) mulf8s::return -(signed word) mulf8s::return#0 return zp[2]:12 51.0 -(signed word) mulf8s::return#2 return zp[2]:12 202.0 -(signed word) mulf8s::return#3 return zp[2]:12 202.0 +(signed word) mulf8s::return#0 return zp[2]:11 51.0 +(signed word) mulf8s::return#2 return zp[2]:11 202.0 +(signed word) mulf8s::return#3 return zp[2]:11 202.0 (signed word()) mulf8s_prepared((signed byte) mulf8s_prepared::b) (byte~) mulf8s_prepared::$12 reg byte a 4.0 (byte~) mulf8s_prepared::$15 reg byte a 4.0 @@ -9750,13 +9680,13 @@ FINAL SYMBOL TABLE (label) mulf8s_prepared::@5 (label) mulf8s_prepared::@return (signed byte) mulf8s_prepared::b -(signed byte) mulf8s_prepared::b#0 b zp[1]:15 0.4 +(signed byte) mulf8s_prepared::b#0 b zp[1]:14 0.4 (word) mulf8s_prepared::m -(word) mulf8s_prepared::m#0 m zp[2]:12 2.0 -(word) mulf8s_prepared::m#1 m zp[2]:12 4.0 -(word) mulf8s_prepared::m#2 m zp[2]:12 4.0 -(word) mulf8s_prepared::m#4 m zp[2]:12 1.3333333333333333 -(word) mulf8s_prepared::m#5 m zp[2]:12 2.5 +(word) mulf8s_prepared::m#0 m zp[2]:11 2.0 +(word) mulf8s_prepared::m#1 m zp[2]:11 4.0 +(word) mulf8s_prepared::m#2 m zp[2]:11 4.0 +(word) mulf8s_prepared::m#4 m zp[2]:11 1.3333333333333333 +(word) mulf8s_prepared::m#5 m zp[2]:11 2.5 (const signed byte*) mulf8s_prepared::memA = (signed byte*) 253 (signed word) mulf8s_prepared::return (void()) mulf8u_prepare((byte) mulf8u_prepare::a) @@ -9771,8 +9701,8 @@ FINAL SYMBOL TABLE (const byte*) mulf8u_prepared::memB = (byte*) 255 (const byte*) mulf8u_prepared::resL = (byte*) 254 (word) mulf8u_prepared::return -(word) mulf8u_prepared::return#0 return zp[2]:12 1.3333333333333333 -(word) mulf8u_prepared::return#2 return zp[2]:12 4.0 +(word) mulf8u_prepared::return#0 return zp[2]:11 1.3333333333333333 +(word) mulf8u_prepared::return#2 return zp[2]:11 4.0 (void()) mulf_init() (byte~) mulf_init::$1 reg byte a 22.0 (byte~) mulf_init::$4 reg byte a 22.0 @@ -9788,28 +9718,28 @@ FINAL SYMBOL TABLE (label) mulf_init::@9 (label) mulf_init::@return (byte) mulf_init::c -(byte) mulf_init::c#1 c zp[1]:15 2.5384615384615383 -(byte) mulf_init::c#2 c zp[1]:15 11.0 +(byte) mulf_init::c#1 c zp[1]:13 2.5384615384615383 +(byte) mulf_init::c#2 c zp[1]:13 11.0 (byte) mulf_init::dir -(byte) mulf_init::dir#2 dir zp[1]:8 4.125 -(byte) mulf_init::dir#4 dir zp[1]:8 11.0 +(byte) mulf_init::dir#2 dir zp[1]:14 4.125 +(byte) mulf_init::dir#4 dir zp[1]:14 11.0 (word) mulf_init::sqr -(word) mulf_init::sqr#1 sqr zp[2]:12 11.0 -(word) mulf_init::sqr#2 sqr zp[2]:12 22.0 -(word) mulf_init::sqr#3 sqr zp[2]:12 9.166666666666666 -(word) mulf_init::sqr#4 sqr zp[2]:12 5.5 +(word) mulf_init::sqr#1 sqr zp[2]:11 11.0 +(word) mulf_init::sqr#2 sqr zp[2]:11 22.0 +(word) mulf_init::sqr#3 sqr zp[2]:11 9.166666666666666 +(word) mulf_init::sqr#4 sqr zp[2]:11 5.5 (byte*) mulf_init::sqr1_hi -(byte*) mulf_init::sqr1_hi#1 sqr1_hi zp[2]:16 7.333333333333333 -(byte*) mulf_init::sqr1_hi#2 sqr1_hi zp[2]:16 2.75 +(byte*) mulf_init::sqr1_hi#1 sqr1_hi zp[2]:15 7.333333333333333 +(byte*) mulf_init::sqr1_hi#2 sqr1_hi zp[2]:15 2.75 (byte*) mulf_init::sqr1_lo (byte*) mulf_init::sqr1_lo#1 sqr1_lo zp[2]:6 22.0 (byte*) mulf_init::sqr1_lo#2 sqr1_lo zp[2]:6 3.142857142857143 (byte*) mulf_init::sqr2_hi -(byte*) mulf_init::sqr2_hi#1 sqr2_hi zp[2]:9 3.6666666666666665 -(byte*) mulf_init::sqr2_hi#2 sqr2_hi zp[2]:9 8.25 +(byte*) mulf_init::sqr2_hi#1 sqr2_hi zp[2]:8 3.6666666666666665 +(byte*) mulf_init::sqr2_hi#2 sqr2_hi zp[2]:8 8.25 (byte*) mulf_init::sqr2_lo -(byte*) mulf_init::sqr2_lo#1 sqr2_lo zp[2]:18 22.0 -(byte*) mulf_init::sqr2_lo#2 sqr2_lo zp[2]:18 4.888888888888889 +(byte*) mulf_init::sqr2_lo#1 sqr2_lo zp[2]:17 22.0 +(byte*) mulf_init::sqr2_lo#2 sqr2_lo zp[2]:17 4.888888888888889 (byte) mulf_init::x_2 (byte) mulf_init::x_2#1 reg byte x 11.0 (byte) mulf_init::x_2#2 reg byte x 5.5 @@ -9841,16 +9771,16 @@ FINAL SYMBOL TABLE (byte*) prepareBobs::bob_glyph#1 bob_glyph zp[2]:6 500.5 (byte*) prepareBobs::bob_glyph#2 bob_glyph zp[2]:6 429.0 (byte*) prepareBobs::bob_table -(byte*) prepareBobs::bob_table#0 bob_table zp[2]:16 202.0 -(byte*) prepareBobs::bob_table#1 bob_table zp[2]:16 667.3333333333334 -(byte*) prepareBobs::bob_table#2 bob_table zp[2]:16 388.0 +(byte*) prepareBobs::bob_table#0 bob_table zp[2]:15 202.0 +(byte*) prepareBobs::bob_table#1 bob_table zp[2]:15 667.3333333333334 +(byte*) prepareBobs::bob_table#2 bob_table zp[2]:15 388.0 (byte) prepareBobs::bob_table_idx (byte) prepareBobs::bob_table_idx#1 bob_table_idx zp[1]:4 40.4 (byte) prepareBobs::bob_table_idx#12 bob_table_idx zp[1]:4 19.11764705882353 (byte) prepareBobs::bob_table_idx#6 bob_table_idx zp[1]:4 11.0 (byte) prepareBobs::cell -(byte) prepareBobs::cell#1 cell zp[1]:11 2002.0 -(byte) prepareBobs::cell#2 cell zp[1]:11 300.29999999999995 +(byte) prepareBobs::cell#1 cell zp[1]:10 2002.0 +(byte) prepareBobs::cell#2 cell zp[1]:10 300.29999999999995 (byte) prepareBobs::shift_x (byte) prepareBobs::shift_x#1 shift_x zp[1]:5 202.0 (byte) prepareBobs::shift_x#2 shift_x zp[1]:5 16.833333333333332 @@ -9858,11 +9788,11 @@ FINAL SYMBOL TABLE (byte) prepareBobs::shift_y#1 shift_y zp[1]:2 22.0 (byte) prepareBobs::shift_y#2 shift_y zp[1]:2 1.4347826086956523 (byte*) progress_cursor -(byte*) progress_cursor#15 progress_cursor zp[2]:12 11.0 -(byte*) progress_cursor#17 progress_cursor zp[2]:12 201.4 -(byte*) progress_cursor#24 progress_cursor zp[2]:12 71.11764705882355 -(byte*) progress_cursor#31 progress_cursor zp[2]:12 37.33333333333333 -(byte*) progress_cursor#8 progress_cursor zp[2]:12 4.0 +(byte*) progress_cursor#15 progress_cursor zp[2]:11 11.0 +(byte*) progress_cursor#17 progress_cursor zp[2]:11 201.4 +(byte*) progress_cursor#24 progress_cursor zp[2]:11 71.11764705882355 +(byte*) progress_cursor#31 progress_cursor zp[2]:11 37.33333333333333 +(byte*) progress_cursor#8 progress_cursor zp[2]:11 4.0 (byte) progress_idx (byte) progress_idx#10 progress_idx zp[1]:3 201.0 (byte) progress_idx#16 progress_idx zp[1]:3 11.0 @@ -9878,24 +9808,24 @@ FINAL SYMBOL TABLE (label) progress_init::@return (byte*) progress_init::line (void()) renderBob((byte) renderBob::xpos , (byte) renderBob::ypos) -(byte*~) renderBob::$2 zp[2]:12 4.0 +(byte*~) renderBob::$2 zp[2]:11 4.0 (byte~) renderBob::$4 reg byte a 4.0 -(byte~) renderBob::$5 zp[1]:14 2.0 +(byte~) renderBob::$5 zp[1]:13 2.0 (byte~) renderBob::$6 reg byte a 4.0 (byte~) renderBob::$8 reg byte a 4.0 (label) renderBob::@return (byte) renderBob::bob_table_idx (byte) renderBob::bob_table_idx#0 reg byte x 1.8181818181818186 (byte*) renderBob::screen -(byte*) renderBob::screen#0 screen zp[2]:12 1.4666666666666666 +(byte*) renderBob::screen#0 screen zp[2]:11 1.4666666666666666 (byte) renderBob::x_char_offset -(byte) renderBob::x_char_offset#0 x_char_offset zp[1]:11 0.8 +(byte) renderBob::x_char_offset#0 x_char_offset zp[1]:10 0.8 (byte) renderBob::xpos -(byte) renderBob::xpos#0 xpos zp[1]:15 10.499999999999998 +(byte) renderBob::xpos#0 xpos zp[1]:14 10.499999999999998 (byte) renderBob::y_char_offset (byte) renderBob::y_char_offset#0 reg byte a 4.0 (word) renderBob::y_offset -(word) renderBob::y_offset#0 y_offset zp[2]:12 4.0 +(word) renderBob::y_offset#0 y_offset zp[2]:11 4.0 (byte) renderBob::ypos (byte) renderBob::ypos#0 reg byte x 15.000000000000002 (void()) renderBobCleanup() @@ -9906,17 +9836,17 @@ FINAL SYMBOL TABLE (byte) renderBobCleanup::i#1 reg byte x 151.5 (byte) renderBobCleanup::i#2 reg byte x 25.25 (byte*) renderBobCleanup::screen -(byte*) renderBobCleanup::screen#0 screen zp[2]:16 112.22222222222223 +(byte*) renderBobCleanup::screen#0 screen zp[2]:15 112.22222222222223 (byte**) renderBobCleanupNext (byte**) renderBobCleanupNext#13 renderBobCleanupNext zp[2]:6 7.357142857142858 (byte**) renderBobCleanupNext#17 renderBobCleanupNext zp[2]:6 3.3870967741935485 (void()) renderBobInit() -(word~) renderBobInit::$0 zp[2]:16 16.5 -(word~) renderBobInit::$1 zp[2]:16 11.0 +(word~) renderBobInit::$0 zp[2]:15 16.5 +(word~) renderBobInit::$1 zp[2]:15 11.0 (byte~) renderBobInit::$4 reg byte a 22.0 (byte~) renderBobInit::$5 reg byte a 22.0 -(word~) renderBobInit::$6 zp[2]:18 22.0 -(word~) renderBobInit::$7 zp[2]:16 22.0 +(word~) renderBobInit::$6 zp[2]:17 22.0 +(word~) renderBobInit::$7 zp[2]:15 22.0 (label) renderBobInit::@1 (label) renderBobInit::@2 (label) renderBobInit::@return @@ -9951,8 +9881,8 @@ FINAL SYMBOL TABLE (byte) shiftProtoBobRight::carry#10 reg byte y 2002.0 (byte) shiftProtoBobRight::carry#2 reg byte y 286.0 (byte) shiftProtoBobRight::i -(byte) shiftProtoBobRight::i#1 i zp[1]:11 1001.0 -(byte) shiftProtoBobRight::i#2 i zp[1]:11 231.0 +(byte) shiftProtoBobRight::i#1 i zp[1]:10 1001.0 +(byte) shiftProtoBobRight::i#2 i zp[1]:10 231.0 (byte) shiftProtoBobRight::j (byte) shiftProtoBobRight::j#1 reg byte x 2002.0 (byte) shiftProtoBobRight::j#10 reg byte x 1001.0 @@ -9969,7 +9899,9 @@ zp[1]:2 [ prepareBobs::shift_y#2 prepareBobs::shift_y#1 main::angle#8 main::angl zp[1]:3 [ progress_idx#16 progress_idx#31 progress_idx#25 progress_idx#10 progress_idx#8 main::r#2 main::r#1 ] zp[1]:4 [ prepareBobs::bob_table_idx#6 prepareBobs::bob_table_idx#12 prepareBobs::bob_table_idx#1 main::a#2 main::a#6 main::a#1 ] zp[1]:5 [ prepareBobs::shift_x#2 prepareBobs::shift_x#1 main::i#2 main::i#1 ] +reg byte x [ bobCharsetFindOrAddGlyph::glyph_id#11 bobCharsetFindOrAddGlyph::glyph_id#1 ] reg byte y [ bobCharsetFindOrAddGlyph::i1#2 bobCharsetFindOrAddGlyph::i1#1 ] +reg byte y [ bobCharsetFindOrAddGlyph::i#2 bobCharsetFindOrAddGlyph::i#1 ] reg byte a [ bobCharsetFindOrAddGlyph::found#2 ] reg byte x [ shiftProtoBobRight::j#3 shiftProtoBobRight::j#10 shiftProtoBobRight::j#2 shiftProtoBobRight::j#1 ] reg byte y [ shiftProtoBobRight::carry#2 shiftProtoBobRight::carry#10 ] @@ -9977,8 +9909,7 @@ reg byte x [ shiftProtoBobDown::i#2 shiftProtoBobDown::i#1 ] zp[2]:6 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_lo#1 prepareBobs::bob_glyph#2 prepareBobs::bob_glyph#1 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::bob_glyph#1 memset::dst#2 memset::dst#1 renderBobCleanupNext#17 renderBobCleanupNext#13 ] reg byte x [ mulf_init::x_2#3 mulf_init::x_2#2 mulf_init::x_2#1 ] reg byte x [ mulf_init::x_255#2 mulf_init::x_255#1 ] -zp[1]:8 [ mulf_init::dir#2 mulf_init::dir#4 bobCharsetFindOrAddGlyph::i#2 bobCharsetFindOrAddGlyph::i#1 ] -zp[2]:9 [ main::x#0 mulf_init::sqr2_hi#2 mulf_init::sqr2_hi#1 ] +zp[2]:8 [ main::x#0 mulf_init::sqr2_hi#2 mulf_init::sqr2_hi#1 ] reg byte x [ renderBob::ypos#0 ] reg byte a [ keyboard_key_pressed::return#2 ] reg byte a [ main::$19 ] @@ -9988,24 +9919,24 @@ reg byte a [ keyboard_matrix_read::return#2 ] reg byte a [ keyboard_key_pressed::$2 ] reg byte a [ keyboard_key_pressed::return#0 ] reg byte a [ keyboard_matrix_read::return#0 ] -zp[1]:11 [ renderBob::x_char_offset#0 shiftProtoBobRight::i#2 shiftProtoBobRight::i#1 prepareBobs::cell#2 prepareBobs::cell#1 ] +zp[1]:10 [ renderBob::x_char_offset#0 shiftProtoBobRight::i#2 shiftProtoBobRight::i#1 prepareBobs::cell#2 prepareBobs::cell#1 ] reg byte a [ renderBob::y_char_offset#0 ] reg byte a [ renderBob::$8 ] -zp[2]:12 [ renderBob::y_offset#0 renderBob::$2 renderBob::screen#0 mulf_init::sqr#3 mulf_init::sqr#4 mulf_init::sqr#1 mulf_init::sqr#2 progress_cursor#15 progress_cursor#31 progress_cursor#24 progress_cursor#17 progress_cursor#8 mulf8s_prepared::m#4 mulf8s_prepared::m#5 mulf8s_prepared::m#1 mulf8s_prepared::m#0 mulf8s_prepared::m#2 mulf8s::return#0 mulf8u_prepared::return#2 mulf8s::return#2 main::$10 mulf8s::return#3 main::$12 mulf8u_prepared::return#0 main::$13 main::y#0 ] +zp[2]:11 [ renderBob::y_offset#0 renderBob::$2 renderBob::screen#0 mulf_init::sqr#3 mulf_init::sqr#4 mulf_init::sqr#1 mulf_init::sqr#2 progress_cursor#15 progress_cursor#31 progress_cursor#24 progress_cursor#17 progress_cursor#8 mulf8s_prepared::m#4 mulf8s_prepared::m#5 mulf8s_prepared::m#1 mulf8s_prepared::m#0 mulf8s_prepared::m#2 mulf8s::return#0 mulf8u_prepared::return#2 mulf8s::return#2 main::$10 mulf8s::return#3 main::$12 mulf8u_prepared::return#0 main::$13 main::y#0 ] reg byte a [ renderBob::$4 ] -zp[1]:14 [ renderBob::$5 shiftProtoBobRight::carry#1 bobCharsetFindOrAddGlyph::glyph_id#11 bobCharsetFindOrAddGlyph::glyph_id#1 ] +zp[1]:13 [ renderBob::$5 mulf_init::c#2 mulf_init::c#1 bob_charset_next_id#23 bob_charset_next_id#14 bob_charset_next_id#16 bob_charset_next_id#30 bob_charset_next_id#21 bob_charset_next_id#8 ] reg byte a [ renderBob::$6 ] reg byte x [ renderBob::bob_table_idx#0 ] reg byte a [ mulf8u_prepare::a#0 ] -zp[1]:15 [ mulf8s_prepared::b#0 renderBob::xpos#0 mulf_init::c#2 mulf_init::c#1 bob_charset_next_id#23 bob_charset_next_id#14 bob_charset_next_id#16 bob_charset_next_id#30 bob_charset_next_id#21 bob_charset_next_id#8 ] +zp[1]:14 [ mulf8s_prepared::b#0 renderBob::xpos#0 mulf_init::dir#2 mulf_init::dir#4 shiftProtoBobRight::carry#1 ] reg byte a [ mulf8u_prepared::b#0 ] reg byte a [ mulf8s_prepared::$8 ] reg byte a [ mulf8s_prepared::$15 ] reg byte a [ mulf8s_prepared::$12 ] reg byte a [ mulf8s_prepared::$16 ] reg byte a [ renderBobCleanup::$1 ] -zp[2]:16 [ renderBobInit::$0 renderBobInit::$7 renderBobInit::$1 renderBobCleanup::screen#0 mulf_init::sqr1_hi#2 mulf_init::sqr1_hi#1 prepareBobs::bob_table#2 prepareBobs::bob_table#1 prepareBobs::bob_table#0 ] -zp[2]:18 [ renderBobInit::$6 mulf_init::sqr2_lo#2 mulf_init::sqr2_lo#1 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::glyph_cursor#1 ] +zp[2]:15 [ renderBobInit::$0 renderBobInit::$7 renderBobInit::$1 renderBobCleanup::screen#0 mulf_init::sqr1_hi#2 mulf_init::sqr1_hi#1 prepareBobs::bob_table#2 prepareBobs::bob_table#1 prepareBobs::bob_table#0 ] +zp[2]:17 [ renderBobInit::$6 mulf_init::sqr2_lo#2 mulf_init::sqr2_lo#1 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::glyph_cursor#1 ] reg byte a [ renderBobInit::$4 ] reg byte a [ renderBobInit::$5 ] reg byte a [ bobCharsetFindOrAddGlyph::return#1 ] @@ -10019,7 +9950,7 @@ reg byte a [ mulf_init::$5 ] FINAL ASSEMBLER -Score: 5801955 +Score: 3510699 // File Comments // Pre-calculated bobs inside a charset (pre-moved to all x/y-combinations) @@ -10059,27 +9990,20 @@ Score: 5801955 .const SIZEOF_POINTER = 2 .label COS = SIN+$40 // BOB charset ID of the next glyph to be added - .label bob_charset_next_id = $f + .label bob_charset_next_id = $d // Current index within the progress cursor (0-7) .label progress_idx = 3 // Current position of the progress cursor - .label progress_cursor = $c + .label progress_cursor = $b // Pointer to the next clean-up to add // Prepare for next clean-up .label renderBobCleanupNext = 6 // @begin + // [1] phi from @begin to @1 [phi:@begin->@1] // @1 - // kickasm - // kickasm() {{ .const PHI = (1+sqrt(5))/2 }} - // Constants for KickAsm Vogel Sunflower - .const PHI = (1+sqrt(5))/2 - - - // [2] phi from @1 to @2 [phi:@1->@2] - // @2 - // [3] call main - // [5] phi from @2 to main [phi:@2->main] - // [4] phi from @2 to @end [phi:@2->@end] + // [2] call main + // [4] phi from @1 to main [phi:@1->main] + // [3] phi from @1 to @end [phi:@1->@end] // @end // main main: { @@ -10087,122 +10011,122 @@ main: { .const vicSelectGfxBank2_toDd001_return = 3 .const toD0181_return = (>(BOB_SCREEN&$3fff)*4)|(>BOB_CHARSET)/4&$f .const toD0182_return = (>(SCREEN_BASIC&$3fff)*4)|(>CHARSET_BASIC)/4&$f - .label __10 = $c - .label __12 = $c - .label __13 = $c - .label x = 9 - .label y = $c + .label __10 = $b + .label __12 = $b + .label __13 = $b + .label x = 8 + .label y = $b .label a = 4 .label r = 3 .label i = 5 // Render Rotated BOBs .label angle = 2 // mulf_init() - // [6] call mulf_init - // [244] phi from main to mulf_init [phi:main->mulf_init] + // [5] call mulf_init + // [243] phi from main to mulf_init [phi:main->mulf_init] jsr mulf_init - // [7] phi from main to main::@9 [phi:main->main::@9] + // [6] phi from main to main::@9 [phi:main->main::@9] // main::@9 // prepareBobs() - // [8] call prepareBobs - // [160] phi from main::@9 to prepareBobs [phi:main::@9->prepareBobs] + // [7] call prepareBobs + // [159] phi from main::@9 to prepareBobs [phi:main::@9->prepareBobs] jsr prepareBobs - // [9] phi from main::@9 to main::@10 [phi:main::@9->main::@10] + // [8] phi from main::@9 to main::@10 [phi:main::@9->main::@10] // main::@10 // renderBobInit() - // [10] call renderBobInit - // [144] phi from main::@10 to renderBobInit [phi:main::@10->renderBobInit] + // [9] call renderBobInit + // [143] phi from main::@10 to renderBobInit [phi:main::@10->renderBobInit] jsr renderBobInit // main::vicSelectGfxBank1 // *CIA2_PORT_A_DDR = %00000011 - // [11] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 -- _deref_pbuc1=vbuc2 + // [10] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 -- _deref_pbuc1=vbuc2 lda #3 sta CIA2_PORT_A_DDR - // [12] phi from main::vicSelectGfxBank1 to main::vicSelectGfxBank1_toDd001 [phi:main::vicSelectGfxBank1->main::vicSelectGfxBank1_toDd001] + // [11] phi from main::vicSelectGfxBank1 to main::vicSelectGfxBank1_toDd001 [phi:main::vicSelectGfxBank1->main::vicSelectGfxBank1_toDd001] // main::vicSelectGfxBank1_toDd001 // main::vicSelectGfxBank1_@1 // *CIA2_PORT_A = toDd00(gfx) - // [13] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank1_toDd001_return#0 -- _deref_pbuc1=vbuc2 + // [12] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank1_toDd001_return#0 -- _deref_pbuc1=vbuc2 lda #vicSelectGfxBank1_toDd001_return sta CIA2_PORT_A - // [14] phi from main::vicSelectGfxBank1_@1 to main::toD0181 [phi:main::vicSelectGfxBank1_@1->main::toD0181] + // [13] phi from main::vicSelectGfxBank1_@1 to main::toD0181 [phi:main::vicSelectGfxBank1_@1->main::toD0181] // main::toD0181 // main::@7 // *D018 = toD018(BOB_SCREEN, BOB_CHARSET) - // [15] *((const byte*) D018) ← (const byte) main::toD0181_return#0 -- _deref_pbuc1=vbuc2 + // [14] *((const byte*) D018) ← (const byte) main::toD0181_return#0 -- _deref_pbuc1=vbuc2 lda #toD0181_return sta D018 // memset(BOB_SCREEN, 0x00, 1000) - // [16] call memset - // [138] phi from main::@7 to memset [phi:main::@7->memset] + // [15] call memset + // [137] phi from main::@7 to memset [phi:main::@7->memset] jsr memset - // [17] phi from main::@7 to main::@1 [phi:main::@7->main::@1] - // [17] phi (byte) main::angle#8 = (byte) 0 [phi:main::@7->main::@1#0] -- vbuz1=vbuc1 + // [16] phi from main::@7 to main::@1 [phi:main::@7->main::@1] + // [16] phi (byte) main::angle#8 = (byte) 0 [phi:main::@7->main::@1#0] -- vbuz1=vbuc1 lda #0 sta.z angle // main::@1 // main::@2 __b2: // while (*RASTER<$f8) - // [18] if(*((const byte*) RASTER)<(byte) $f8) goto main::@2 -- _deref_pbuc1_lt_vbuc2_then_la1 + // [17] if(*((const byte*) RASTER)<(byte) $f8) goto main::@2 -- _deref_pbuc1_lt_vbuc2_then_la1 lda RASTER cmp #$f8 bcc __b2 // main::@3 // *BORDERCOL = 0xf - // [19] *((const byte*) BORDERCOL) ← (byte) $f -- _deref_pbuc1=vbuc2 + // [18] *((const byte*) BORDERCOL) ← (byte) $f -- _deref_pbuc1=vbuc2 lda #$f sta BORDERCOL // renderBobCleanup() - // [20] call renderBobCleanup - // [122] phi from main::@3 to renderBobCleanup [phi:main::@3->renderBobCleanup] + // [19] call renderBobCleanup + // [121] phi from main::@3 to renderBobCleanup [phi:main::@3->renderBobCleanup] jsr renderBobCleanup // main::@11 - // [21] (byte) main::a#6 ← (byte) main::angle#8 -- vbuz1=vbuz2 + // [20] (byte) main::a#6 ← (byte) main::angle#8 -- vbuz1=vbuz2 lda.z angle sta.z a - // [22] phi from main::@11 to main::@4 [phi:main::@11->main::@4] - // [22] phi (byte) main::i#2 = (byte) 0 [phi:main::@11->main::@4#0] -- vbuz1=vbuc1 + // [21] phi from main::@11 to main::@4 [phi:main::@11->main::@4] + // [21] phi (byte) main::i#2 = (byte) 0 [phi:main::@11->main::@4#0] -- vbuz1=vbuc1 lda #0 sta.z i - // [22] phi (byte**) renderBobCleanupNext#17 = (const byte**) RENDERBOB_CLEANUP [phi:main::@11->main::@4#1] -- pptz1=pptc1 + // [21] phi (byte**) renderBobCleanupNext#17 = (const byte**) RENDERBOB_CLEANUP [phi:main::@11->main::@4#1] -- pptz1=pptc1 lda #RENDERBOB_CLEANUP sta.z renderBobCleanupNext+1 - // [22] phi (byte) main::a#2 = (byte) main::a#6 [phi:main::@11->main::@4#2] -- register_copy - // [22] phi (signed byte) main::r#2 = (signed byte) $1e [phi:main::@11->main::@4#3] -- vbsz1=vbsc1 + // [21] phi (byte) main::a#2 = (byte) main::a#6 [phi:main::@11->main::@4#2] -- register_copy + // [21] phi (signed byte) main::r#2 = (signed byte) $1e [phi:main::@11->main::@4#3] -- vbsz1=vbsc1 lda #$1e sta.z r - // [22] phi from main::@14 to main::@4 [phi:main::@14->main::@4] - // [22] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@14->main::@4#0] -- register_copy - // [22] phi (byte**) renderBobCleanupNext#17 = (byte**) renderBobCleanupNext#13 [phi:main::@14->main::@4#1] -- register_copy - // [22] phi (byte) main::a#2 = (byte) main::a#1 [phi:main::@14->main::@4#2] -- register_copy - // [22] phi (signed byte) main::r#2 = (signed byte) main::r#1 [phi:main::@14->main::@4#3] -- register_copy + // [21] phi from main::@14 to main::@4 [phi:main::@14->main::@4] + // [21] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@14->main::@4#0] -- register_copy + // [21] phi (byte**) renderBobCleanupNext#17 = (byte**) renderBobCleanupNext#13 [phi:main::@14->main::@4#1] -- register_copy + // [21] phi (byte) main::a#2 = (byte) main::a#1 [phi:main::@14->main::@4#2] -- register_copy + // [21] phi (signed byte) main::r#2 = (signed byte) main::r#1 [phi:main::@14->main::@4#3] -- register_copy // main::@4 __b4: // *BORDERCOL = 1 - // [23] *((const byte*) BORDERCOL) ← (byte) 1 -- _deref_pbuc1=vbuc2 + // [22] *((const byte*) BORDERCOL) ← (byte) 1 -- _deref_pbuc1=vbuc2 //kickasm {{ .break }} lda #1 sta BORDERCOL // mulf8s(r, COS[a]) - // [24] (signed byte) mulf8s::a#0 ← (signed byte) main::r#2 -- vbsaa=vbsz1 + // [23] (signed byte) mulf8s::a#0 ← (signed byte) main::r#2 -- vbsaa=vbsz1 lda.z r - // [25] (signed byte) mulf8s::b#0 ← *((const signed byte*) COS + (byte) main::a#2) -- vbsxx=pbsc1_derefidx_vbuz1 + // [24] (signed byte) mulf8s::b#0 ← *((const signed byte*) COS + (byte) main::a#2) -- vbsxx=pbsc1_derefidx_vbuz1 ldy.z a ldx COS,y - // [26] call mulf8s - // [93] phi from main::@4 to mulf8s [phi:main::@4->mulf8s] - // [93] phi (signed byte) mulf8s::b#2 = (signed byte) mulf8s::b#0 [phi:main::@4->mulf8s#0] -- register_copy - // [93] phi (signed byte) mulf8s::mulf8s_prepare1_a#0 = (signed byte) mulf8s::a#0 [phi:main::@4->mulf8s#1] -- register_copy + // [25] call mulf8s + // [92] phi from main::@4 to mulf8s [phi:main::@4->mulf8s] + // [92] phi (signed byte) mulf8s::b#2 = (signed byte) mulf8s::b#0 [phi:main::@4->mulf8s#0] -- register_copy + // [92] phi (signed byte) mulf8s::mulf8s_prepare1_a#0 = (signed byte) mulf8s::a#0 [phi:main::@4->mulf8s#1] -- register_copy jsr mulf8s // mulf8s(r, COS[a]) - // [27] (signed word) mulf8s::return#2 ← (signed word) mulf8s::return#0 + // [26] (signed word) mulf8s::return#2 ← (signed word) mulf8s::return#0 // main::@12 - // [28] (signed word~) main::$10 ← (signed word) mulf8s::return#2 + // [27] (signed word~) main::$10 ← (signed word) mulf8s::return#2 // x = mulf8s(r, COS[a]) + 75*0x100 - // [29] (signed word) main::x#0 ← (signed word~) main::$10 + (signed word)(number) $4b*(number) $100 -- vwsz1=vwsz2_plus_vwsc1 + // [28] (signed word) main::x#0 ← (signed word~) main::$10 + (signed word)(number) $4b*(number) $100 -- vwsz1=vwsz2_plus_vwsc1 lda.z __10 clc adc #<$4b*$100 @@ -10211,26 +10135,26 @@ main: { adc #>$4b*$100 sta.z x+1 // mulf8s(r, SIN[a]) - // [30] (signed byte) mulf8s::a#1 ← (signed byte) main::r#2 -- vbsaa=vbsz1 + // [29] (signed byte) mulf8s::a#1 ← (signed byte) main::r#2 -- vbsaa=vbsz1 lda.z r - // [31] (signed byte) mulf8s::b#1 ← *((const signed byte*) SIN + (byte) main::a#2) -- vbsxx=pbsc1_derefidx_vbuz1 + // [30] (signed byte) mulf8s::b#1 ← *((const signed byte*) SIN + (byte) main::a#2) -- vbsxx=pbsc1_derefidx_vbuz1 ldy.z a ldx SIN,y - // [32] call mulf8s - // [93] phi from main::@12 to mulf8s [phi:main::@12->mulf8s] - // [93] phi (signed byte) mulf8s::b#2 = (signed byte) mulf8s::b#1 [phi:main::@12->mulf8s#0] -- register_copy - // [93] phi (signed byte) mulf8s::mulf8s_prepare1_a#0 = (signed byte) mulf8s::a#1 [phi:main::@12->mulf8s#1] -- register_copy + // [31] call mulf8s + // [92] phi from main::@12 to mulf8s [phi:main::@12->mulf8s] + // [92] phi (signed byte) mulf8s::b#2 = (signed byte) mulf8s::b#1 [phi:main::@12->mulf8s#0] -- register_copy + // [92] phi (signed byte) mulf8s::mulf8s_prepare1_a#0 = (signed byte) mulf8s::a#1 [phi:main::@12->mulf8s#1] -- register_copy jsr mulf8s // mulf8s(r, SIN[a]) - // [33] (signed word) mulf8s::return#3 ← (signed word) mulf8s::return#0 + // [32] (signed word) mulf8s::return#3 ← (signed word) mulf8s::return#0 // main::@13 - // [34] (signed word~) main::$12 ← (signed word) mulf8s::return#3 + // [33] (signed word~) main::$12 ← (signed word) mulf8s::return#3 // mulf8s(r, SIN[a])*2 - // [35] (signed word~) main::$13 ← (signed word~) main::$12 << (byte) 1 -- vwsz1=vwsz1_rol_1 + // [34] (signed word~) main::$13 ← (signed word~) main::$12 << (byte) 1 -- vwsz1=vwsz1_rol_1 asl.z __13 rol.z __13+1 // y = mulf8s(r, SIN[a])*2 + 90*0x100 - // [36] (signed word) main::y#0 ← (signed word~) main::$13 + (signed word)(number) $5a*(number) $100 -- vwsz1=vwsz1_plus_vwsc1 + // [35] (signed word) main::y#0 ← (signed word~) main::$13 + (signed word)(number) $5a*(number) $100 -- vwsz1=vwsz1_plus_vwsc1 clc lda.z y adc #<$5a*$100 @@ -10239,99 +10163,99 @@ main: { adc #>$5a*$100 sta.z y+1 // *BORDERCOL = 2 - // [37] *((const byte*) BORDERCOL) ← (byte) 2 -- _deref_pbuc1=vbuc2 + // [36] *((const byte*) BORDERCOL) ← (byte) 2 -- _deref_pbuc1=vbuc2 lda #2 sta BORDERCOL // a += 98 - // [38] (byte) main::a#1 ← (byte) main::a#2 + (byte) $62 -- vbuz1=vbuz1_plus_vbuc1 + // [37] (byte) main::a#1 ← (byte) main::a#2 + (byte) $62 -- vbuz1=vbuz1_plus_vbuc1 lax.z a axs #-[$62] stx.z a // r += 3 - // [39] (signed byte) main::r#1 ← (signed byte) main::r#2 + (signed byte) 3 -- vbsz1=vbsz1_plus_vbsc1 + // [38] (signed byte) main::r#1 ← (signed byte) main::r#2 + (signed byte) 3 -- vbsz1=vbsz1_plus_vbsc1 lax.z r axs #-[3] stx.z r // renderBob(>x, >y) - // [40] (byte) renderBob::xpos#0 ← > (signed word) main::x#0 -- vbuz1=_hi_vwsz2 + // [39] (byte) renderBob::xpos#0 ← > (signed word) main::x#0 -- vbuz1=_hi_vwsz2 lda.z x+1 sta.z renderBob.xpos - // [41] (byte) renderBob::ypos#0 ← > (signed word) main::y#0 -- vbuxx=_hi_vwsz1 + // [40] (byte) renderBob::ypos#0 ← > (signed word) main::y#0 -- vbuxx=_hi_vwsz1 lda.z y+1 tax - // [42] call renderBob + // [41] call renderBob jsr renderBob // main::@14 // for(char i: 0..NUM_BOBS-1) - // [43] (byte) main::i#1 ← ++ (byte) main::i#2 -- vbuz1=_inc_vbuz1 + // [42] (byte) main::i#1 ← ++ (byte) main::i#2 -- vbuz1=_inc_vbuz1 inc.z i - // [44] if((byte) main::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto main::@4 -- vbuz1_neq_vbuc1_then_la1 + // [43] if((byte) main::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto main::@4 -- vbuz1_neq_vbuc1_then_la1 lda #NUM_BOBS-1+1 cmp.z i bne __b4 // main::@5 // angle += 3 - // [45] (byte) main::angle#1 ← (byte) main::angle#8 + (byte) 3 -- vbuz1=vbuz1_plus_vbuc1 + // [44] (byte) main::angle#1 ← (byte) main::angle#8 + (byte) 3 -- vbuz1=vbuz1_plus_vbuc1 lax.z angle axs #-[3] stx.z angle // *BORDERCOL = 0 - // [46] *((const byte*) BORDERCOL) ← (byte) 0 -- _deref_pbuc1=vbuc2 + // [45] *((const byte*) BORDERCOL) ← (byte) 0 -- _deref_pbuc1=vbuc2 lda #0 sta BORDERCOL // keyboard_key_pressed(KEY_SPACE) - // [47] call keyboard_key_pressed - // [62] phi from main::@5 to keyboard_key_pressed [phi:main::@5->keyboard_key_pressed] + // [46] call keyboard_key_pressed + // [61] phi from main::@5 to keyboard_key_pressed [phi:main::@5->keyboard_key_pressed] jsr keyboard_key_pressed // keyboard_key_pressed(KEY_SPACE) - // [48] (byte) keyboard_key_pressed::return#2 ← (byte) keyboard_key_pressed::return#0 + // [47] (byte) keyboard_key_pressed::return#2 ← (byte) keyboard_key_pressed::return#0 // main::@15 - // [49] (byte~) main::$19 ← (byte) keyboard_key_pressed::return#2 + // [48] (byte~) main::$19 ← (byte) keyboard_key_pressed::return#2 // if(keyboard_key_pressed(KEY_SPACE)) - // [50] if((byte) 0!=(byte~) main::$19) goto main::@6 -- vbuc1_neq_vbuaa_then_la1 + // [49] if((byte) 0!=(byte~) main::$19) goto main::@6 -- vbuc1_neq_vbuaa_then_la1 cmp #0 bne __b6 - // [17] phi from main::@15 to main::@1 [phi:main::@15->main::@1] - // [17] phi (byte) main::angle#8 = (byte) main::angle#1 [phi:main::@15->main::@1#0] -- register_copy + // [16] phi from main::@15 to main::@1 [phi:main::@15->main::@1] + // [16] phi (byte) main::angle#8 = (byte) main::angle#1 [phi:main::@15->main::@1#0] -- register_copy jmp __b2 // Wait for space release - // [51] phi from main::@15 main::@16 to main::@6 [phi:main::@15/main::@16->main::@6] + // [50] phi from main::@15 main::@16 to main::@6 [phi:main::@15/main::@16->main::@6] // main::@6 __b6: // keyboard_key_pressed(KEY_SPACE) - // [52] call keyboard_key_pressed - // [62] phi from main::@6 to keyboard_key_pressed [phi:main::@6->keyboard_key_pressed] + // [51] call keyboard_key_pressed + // [61] phi from main::@6 to keyboard_key_pressed [phi:main::@6->keyboard_key_pressed] jsr keyboard_key_pressed // keyboard_key_pressed(KEY_SPACE) - // [53] (byte) keyboard_key_pressed::return#3 ← (byte) keyboard_key_pressed::return#0 + // [52] (byte) keyboard_key_pressed::return#3 ← (byte) keyboard_key_pressed::return#0 // main::@16 - // [54] (byte~) main::$21 ← (byte) keyboard_key_pressed::return#3 + // [53] (byte~) main::$21 ← (byte) keyboard_key_pressed::return#3 // while(keyboard_key_pressed(KEY_SPACE)) - // [55] if((byte) 0!=(byte~) main::$21) goto main::@6 -- vbuc1_neq_vbuaa_then_la1 + // [54] if((byte) 0!=(byte~) main::$21) goto main::@6 -- vbuc1_neq_vbuaa_then_la1 cmp #0 bne __b6 // main::vicSelectGfxBank2 // *CIA2_PORT_A_DDR = %00000011 - // [56] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 -- _deref_pbuc1=vbuc2 + // [55] *((const byte*) CIA2_PORT_A_DDR) ← (byte) 3 -- _deref_pbuc1=vbuc2 lda #3 sta CIA2_PORT_A_DDR - // [57] phi from main::vicSelectGfxBank2 to main::vicSelectGfxBank2_toDd001 [phi:main::vicSelectGfxBank2->main::vicSelectGfxBank2_toDd001] + // [56] phi from main::vicSelectGfxBank2 to main::vicSelectGfxBank2_toDd001 [phi:main::vicSelectGfxBank2->main::vicSelectGfxBank2_toDd001] // main::vicSelectGfxBank2_toDd001 // main::vicSelectGfxBank2_@1 // *CIA2_PORT_A = toDd00(gfx) - // [58] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank2_toDd001_return#0 -- _deref_pbuc1=vbuc2 + // [57] *((const byte*) CIA2_PORT_A) ← (const byte) main::vicSelectGfxBank2_toDd001_return#0 -- _deref_pbuc1=vbuc2 lda #vicSelectGfxBank2_toDd001_return sta CIA2_PORT_A - // [59] phi from main::vicSelectGfxBank2_@1 to main::toD0182 [phi:main::vicSelectGfxBank2_@1->main::toD0182] + // [58] phi from main::vicSelectGfxBank2_@1 to main::toD0182 [phi:main::vicSelectGfxBank2_@1->main::toD0182] // main::toD0182 // main::@8 // *D018 = toD018(SCREEN_BASIC, CHARSET_BASIC) - // [60] *((const byte*) D018) ← (const byte) main::toD0182_return#0 -- _deref_pbuc1=vbuc2 + // [59] *((const byte*) D018) ← (const byte) main::toD0182_return#0 -- _deref_pbuc1=vbuc2 lda #toD0182_return sta D018 // main::@return // } - // [61] return + // [60] return rts } // keyboard_key_pressed @@ -10343,17 +10267,17 @@ keyboard_key_pressed: { .const colidx = KEY_SPACE&7 .label rowidx = KEY_SPACE>>3 // keyboard_matrix_read(rowidx) - // [63] call keyboard_matrix_read + // [62] call keyboard_matrix_read jsr keyboard_matrix_read - // [64] (byte) keyboard_matrix_read::return#2 ← (byte) keyboard_matrix_read::return#0 + // [63] (byte) keyboard_matrix_read::return#2 ← (byte) keyboard_matrix_read::return#0 // keyboard_key_pressed::@1 - // [65] (byte~) keyboard_key_pressed::$2 ← (byte) keyboard_matrix_read::return#2 + // [64] (byte~) keyboard_key_pressed::$2 ← (byte) keyboard_matrix_read::return#2 // keyboard_matrix_read(rowidx) & keyboard_matrix_col_bitmask[colidx] - // [66] (byte) keyboard_key_pressed::return#0 ← (byte~) keyboard_key_pressed::$2 & *((const byte*) keyboard_matrix_col_bitmask+(const byte) keyboard_key_pressed::colidx#0) -- vbuaa=vbuaa_band__deref_pbuc1 + // [65] (byte) keyboard_key_pressed::return#0 ← (byte~) keyboard_key_pressed::$2 & *((const byte*) keyboard_matrix_col_bitmask+(const byte) keyboard_key_pressed::colidx#0) -- vbuaa=vbuaa_band__deref_pbuc1 and keyboard_matrix_col_bitmask+colidx // keyboard_key_pressed::@return // } - // [67] return + // [66] return rts } // keyboard_matrix_read @@ -10364,53 +10288,53 @@ keyboard_key_pressed: { // leading to erroneous readings. You must disable kill the normal interrupt or sei/cli around calls to the keyboard matrix reader. keyboard_matrix_read: { // *CIA1_PORT_A = keyboard_matrix_row_bitmask[rowid] - // [68] *((const byte*) CIA1_PORT_A) ← *((const byte*) keyboard_matrix_row_bitmask+(const byte) keyboard_key_pressed::rowidx#0) -- _deref_pbuc1=_deref_pbuc2 + // [67] *((const byte*) CIA1_PORT_A) ← *((const byte*) keyboard_matrix_row_bitmask+(const byte) keyboard_key_pressed::rowidx#0) -- _deref_pbuc1=_deref_pbuc2 lda keyboard_matrix_row_bitmask+keyboard_key_pressed.rowidx sta CIA1_PORT_A // ~*CIA1_PORT_B - // [69] (byte) keyboard_matrix_read::return#0 ← ~ *((const byte*) CIA1_PORT_B) -- vbuaa=_bnot__deref_pbuc1 + // [68] (byte) keyboard_matrix_read::return#0 ← ~ *((const byte*) CIA1_PORT_B) -- vbuaa=_bnot__deref_pbuc1 lda CIA1_PORT_B eor #$ff // keyboard_matrix_read::@return // } - // [70] return + // [69] return rts } // renderBob // Render a single BOB at a given x/y-position // X-position is 0-151. Each x-position is 2 pixels wide. // Y-position is 0-183. Each y-position is 1 pixel high. -// renderBob(byte zeropage($f) xpos, byte register(X) ypos) +// renderBob(byte zeropage($e) xpos, byte register(X) ypos) renderBob: { - .label __2 = $c - .label __5 = $e - .label xpos = $f - .label x_char_offset = $b - .label y_offset = $c - .label screen = $c + .label __2 = $b + .label __5 = $d + .label xpos = $e + .label x_char_offset = $a + .label y_offset = $b + .label screen = $b // x_char_offset = xpos/BOB_SHIFTS_X - // [71] (byte) renderBob::x_char_offset#0 ← (byte) renderBob::xpos#0 >> (byte) 2 -- vbuz1=vbuz2_ror_2 + // [70] (byte) renderBob::x_char_offset#0 ← (byte) renderBob::xpos#0 >> (byte) 2 -- vbuz1=vbuz2_ror_2 lda.z xpos lsr lsr sta.z x_char_offset // y_char_offset = ypos/BOB_SHIFTS_Y - // [72] (byte) renderBob::y_char_offset#0 ← (byte) renderBob::ypos#0 >> (byte) 3 -- vbuaa=vbuxx_ror_3 + // [71] (byte) renderBob::y_char_offset#0 ← (byte) renderBob::ypos#0 >> (byte) 3 -- vbuaa=vbuxx_ror_3 txa lsr lsr lsr // y_offset = MUL40[y_char_offset] - // [73] (byte~) renderBob::$8 ← (byte) renderBob::y_char_offset#0 << (byte) 1 -- vbuaa=vbuaa_rol_1 + // [72] (byte~) renderBob::$8 ← (byte) renderBob::y_char_offset#0 << (byte) 1 -- vbuaa=vbuaa_rol_1 asl - // [74] (word) renderBob::y_offset#0 ← *((const word*) MUL40 + (byte~) renderBob::$8) -- vwuz1=pwuc1_derefidx_vbuaa + // [73] (word) renderBob::y_offset#0 ← *((const word*) MUL40 + (byte~) renderBob::$8) -- vwuz1=pwuc1_derefidx_vbuaa tay lda MUL40,y sta.z y_offset lda MUL40+1,y sta.z y_offset+1 // BOB_SCREEN+y_offset - // [75] (byte*~) renderBob::$2 ← (const byte*) BOB_SCREEN + (word) renderBob::y_offset#0 -- pbuz1=pbuc1_plus_vwuz1 + // [74] (byte*~) renderBob::$2 ← (const byte*) BOB_SCREEN + (word) renderBob::y_offset#0 -- pbuz1=pbuc1_plus_vwuz1 clc lda.z __2 adc #BOB_SCREEN sta.z __2+1 // screen = BOB_SCREEN+y_offset+x_char_offset - // [76] (byte*) renderBob::screen#0 ← (byte*~) renderBob::$2 + (byte) renderBob::x_char_offset#0 -- pbuz1=pbuz1_plus_vbuz2 + // [75] (byte*) renderBob::screen#0 ← (byte*~) renderBob::$2 + (byte) renderBob::x_char_offset#0 -- pbuz1=pbuz1_plus_vbuz2 lda.z x_char_offset clc adc.z screen @@ -10428,25 +10352,25 @@ renderBob: { inc.z screen+1 !: // ypos&7 - // [77] (byte~) renderBob::$4 ← (byte) renderBob::ypos#0 & (byte) 7 -- vbuaa=vbuxx_band_vbuc1 + // [76] (byte~) renderBob::$4 ← (byte) renderBob::ypos#0 & (byte) 7 -- vbuaa=vbuxx_band_vbuc1 txa and #7 // (ypos&7)*BOB_SHIFTS_X - // [78] (byte~) renderBob::$5 ← (byte~) renderBob::$4 << (byte) 2 -- vbuz1=vbuaa_rol_2 + // [77] (byte~) renderBob::$5 ← (byte~) renderBob::$4 << (byte) 2 -- vbuz1=vbuaa_rol_2 asl asl sta.z __5 // xpos&3 - // [79] (byte~) renderBob::$6 ← (byte) renderBob::xpos#0 & (byte) 3 -- vbuaa=vbuz1_band_vbuc1 + // [78] (byte~) renderBob::$6 ← (byte) renderBob::xpos#0 & (byte) 3 -- vbuaa=vbuz1_band_vbuc1 lda #3 and.z xpos // bob_table_idx = (ypos&7)*BOB_SHIFTS_X+(xpos&3) - // [80] (byte) renderBob::bob_table_idx#0 ← (byte~) renderBob::$5 + (byte~) renderBob::$6 -- vbuxx=vbuz1_plus_vbuaa + // [79] (byte) renderBob::bob_table_idx#0 ← (byte~) renderBob::$5 + (byte~) renderBob::$6 -- vbuxx=vbuz1_plus_vbuaa clc adc.z __5 tax // *renderBobCleanupNext++ = screen - // [81] *((byte**) renderBobCleanupNext#17) ← (byte*) renderBob::screen#0 -- _deref_pptz1=pbuz2 + // [80] *((byte**) renderBobCleanupNext#17) ← (byte*) renderBob::screen#0 -- _deref_pptz1=pbuz2 ldy #0 lda.z screen sta (renderBobCleanupNext),y @@ -10454,7 +10378,7 @@ renderBob: { lda.z screen+1 sta (renderBobCleanupNext),y // *renderBobCleanupNext++ = screen; - // [82] (byte**) renderBobCleanupNext#13 ← (byte**) renderBobCleanupNext#17 + (const byte) SIZEOF_POINTER -- pptz1=pptz1_plus_vbuc1 + // [81] (byte**) renderBobCleanupNext#13 ← (byte**) renderBobCleanupNext#17 + (const byte) SIZEOF_POINTER -- pptz1=pptz1_plus_vbuc1 lda #SIZEOF_POINTER clc adc.z renderBobCleanupNext @@ -10463,136 +10387,136 @@ renderBob: { inc.z renderBobCleanupNext+1 !: // screen[0] = (BOB_TABLES+0*BOB_SUBTABLE_SIZE)[bob_table_idx] - // [83] *((byte*) renderBob::screen#0) ← *((const byte*) BOB_TABLES + (byte) renderBob::bob_table_idx#0) -- _deref_pbuz1=pbuc1_derefidx_vbuxx + // [82] *((byte*) renderBob::screen#0) ← *((const byte*) BOB_TABLES + (byte) renderBob::bob_table_idx#0) -- _deref_pbuz1=pbuc1_derefidx_vbuxx lda BOB_TABLES,x ldy #0 sta (screen),y // screen[40] = (BOB_TABLES+1*BOB_SUBTABLE_SIZE)[bob_table_idx] - // [84] *((byte*) renderBob::screen#0 + (byte) $28) ← *((const byte*) BOB_TABLES+(byte) 1*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx + // [83] *((byte*) renderBob::screen#0 + (byte) $28) ← *((const byte*) BOB_TABLES+(byte) 1*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx lda BOB_TABLES+1*BOB_SUBTABLE_SIZE,x ldy #$28 sta (screen),y // screen[80] = (BOB_TABLES+2*BOB_SUBTABLE_SIZE)[bob_table_idx] - // [85] *((byte*) renderBob::screen#0 + (byte) $50) ← *((const byte*) BOB_TABLES+(byte) 2*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx + // [84] *((byte*) renderBob::screen#0 + (byte) $50) ← *((const byte*) BOB_TABLES+(byte) 2*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx lda BOB_TABLES+2*BOB_SUBTABLE_SIZE,x ldy #$50 sta (screen),y // screen[1] = (BOB_TABLES+3*BOB_SUBTABLE_SIZE)[bob_table_idx] - // [86] *((byte*) renderBob::screen#0 + (byte) 1) ← *((const byte*) BOB_TABLES+(byte) 3*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx + // [85] *((byte*) renderBob::screen#0 + (byte) 1) ← *((const byte*) BOB_TABLES+(byte) 3*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx lda BOB_TABLES+3*BOB_SUBTABLE_SIZE,x ldy #1 sta (screen),y // screen[41] = (BOB_TABLES+4*BOB_SUBTABLE_SIZE)[bob_table_idx] - // [87] *((byte*) renderBob::screen#0 + (byte) $29) ← *((const byte*) BOB_TABLES+(byte) 4*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx + // [86] *((byte*) renderBob::screen#0 + (byte) $29) ← *((const byte*) BOB_TABLES+(byte) 4*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx lda BOB_TABLES+4*BOB_SUBTABLE_SIZE,x ldy #$29 sta (screen),y // screen[81] = (BOB_TABLES+5*BOB_SUBTABLE_SIZE)[bob_table_idx] - // [88] *((byte*) renderBob::screen#0 + (byte) $51) ← *((const byte*) BOB_TABLES+(byte) 5*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx + // [87] *((byte*) renderBob::screen#0 + (byte) $51) ← *((const byte*) BOB_TABLES+(byte) 5*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx lda BOB_TABLES+5*BOB_SUBTABLE_SIZE,x ldy #$51 sta (screen),y // screen[2] = (BOB_TABLES+6*BOB_SUBTABLE_SIZE)[bob_table_idx] - // [89] *((byte*) renderBob::screen#0 + (byte) 2) ← *((const byte*) BOB_TABLES+(byte) 6*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx + // [88] *((byte*) renderBob::screen#0 + (byte) 2) ← *((const byte*) BOB_TABLES+(byte) 6*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx lda BOB_TABLES+6*BOB_SUBTABLE_SIZE,x ldy #2 sta (screen),y // screen[42] = (BOB_TABLES+7*BOB_SUBTABLE_SIZE)[bob_table_idx] - // [90] *((byte*) renderBob::screen#0 + (byte) $2a) ← *((const byte*) BOB_TABLES+(byte) 7*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx + // [89] *((byte*) renderBob::screen#0 + (byte) $2a) ← *((const byte*) BOB_TABLES+(byte) 7*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx lda BOB_TABLES+7*BOB_SUBTABLE_SIZE,x ldy #$2a sta (screen),y // screen[82] = (BOB_TABLES+8*BOB_SUBTABLE_SIZE)[bob_table_idx] - // [91] *((byte*) renderBob::screen#0 + (byte) $52) ← *((const byte*) BOB_TABLES+(byte) 8*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx + // [90] *((byte*) renderBob::screen#0 + (byte) $52) ← *((const byte*) BOB_TABLES+(byte) 8*(const byte) BOB_SUBTABLE_SIZE + (byte) renderBob::bob_table_idx#0) -- pbuz1_derefidx_vbuc1=pbuc2_derefidx_vbuxx lda BOB_TABLES+8*BOB_SUBTABLE_SIZE,x ldy #$52 sta (screen),y // renderBob::@return // } - // [92] return + // [91] return rts } // mulf8s // Fast multiply two signed bytes to a word result // mulf8s(signed byte register(A) a, signed byte register(X) b) mulf8s: { - .label return = $c + .label return = $b // mulf8s::mulf8s_prepare1 // mulf8u_prepare((byte)a) - // [94] (byte) mulf8u_prepare::a#0 ← (byte)(signed byte) mulf8s::mulf8s_prepare1_a#0 - // [95] call mulf8u_prepare + // [93] (byte) mulf8u_prepare::a#0 ← (byte)(signed byte) mulf8s::mulf8s_prepare1_a#0 + // [94] call mulf8u_prepare jsr mulf8u_prepare // mulf8s::@1 // mulf8s_prepared(b) - // [96] (signed byte) mulf8s_prepared::b#0 ← (signed byte) mulf8s::b#2 -- vbsz1=vbsxx + // [95] (signed byte) mulf8s_prepared::b#0 ← (signed byte) mulf8s::b#2 -- vbsz1=vbsxx stx.z mulf8s_prepared.b - // [97] call mulf8s_prepared + // [96] call mulf8s_prepared jsr mulf8s_prepared // mulf8s::@2 - // [98] (signed word) mulf8s::return#0 ← (signed word)(word) mulf8s_prepared::m#4 + // [97] (signed word) mulf8s::return#0 ← (signed word)(word) mulf8s_prepared::m#4 // mulf8s::@return // } - // [99] return + // [98] return rts } // mulf8s_prepared // Calculate fast multiply with a prepared unsigned byte to a word result // The prepared number is set by calling mulf8s_prepare(byte a) -// mulf8s_prepared(signed byte zeropage($f) b) +// mulf8s_prepared(signed byte zeropage($e) b) mulf8s_prepared: { .label memA = $fd - .label m = $c - .label b = $f + .label m = $b + .label b = $e // mulf8u_prepared((byte) b) - // [100] (byte) mulf8u_prepared::b#0 ← (byte)(signed byte) mulf8s_prepared::b#0 -- vbuaa=vbuz1 + // [99] (byte) mulf8u_prepared::b#0 ← (byte)(signed byte) mulf8s_prepared::b#0 -- vbuaa=vbuz1 lda.z b - // [101] call mulf8u_prepared + // [100] call mulf8u_prepared jsr mulf8u_prepared - // [102] (word) mulf8u_prepared::return#2 ← (word) mulf8u_prepared::return#0 + // [101] (word) mulf8u_prepared::return#2 ← (word) mulf8u_prepared::return#0 // mulf8s_prepared::@5 // m = mulf8u_prepared((byte) b) - // [103] (word) mulf8s_prepared::m#0 ← (word) mulf8u_prepared::return#2 + // [102] (word) mulf8s_prepared::m#0 ← (word) mulf8u_prepared::return#2 // if(*memA<0) - // [104] if(*((const signed byte*) mulf8s_prepared::memA)>=(signed byte) 0) goto mulf8s_prepared::@1 -- _deref_pbsc1_ge_0_then_la1 + // [103] if(*((const signed byte*) mulf8s_prepared::memA)>=(signed byte) 0) goto mulf8s_prepared::@1 -- _deref_pbsc1_ge_0_then_la1 lda memA cmp #0 bpl __b1 // mulf8s_prepared::@3 // >m - // [105] (byte~) mulf8s_prepared::$8 ← > (word) mulf8s_prepared::m#0 -- vbuaa=_hi_vwuz1 + // [104] (byte~) mulf8s_prepared::$8 ← > (word) mulf8s_prepared::m#0 -- vbuaa=_hi_vwuz1 lda.z m+1 // >m = (>m)-(byte)b - // [106] (byte~) mulf8s_prepared::$15 ← (byte~) mulf8s_prepared::$8 - (byte)(signed byte) mulf8s_prepared::b#0 -- vbuaa=vbuaa_minus_vbuz1 + // [105] (byte~) mulf8s_prepared::$15 ← (byte~) mulf8s_prepared::$8 - (byte)(signed byte) mulf8s_prepared::b#0 -- vbuaa=vbuaa_minus_vbuz1 sec sbc.z b - // [107] (word) mulf8s_prepared::m#1 ← (word) mulf8s_prepared::m#0 hi= (byte~) mulf8s_prepared::$15 -- vwuz1=vwuz1_sethi_vbuaa + // [106] (word) mulf8s_prepared::m#1 ← (word) mulf8s_prepared::m#0 hi= (byte~) mulf8s_prepared::$15 -- vwuz1=vwuz1_sethi_vbuaa sta.z m+1 - // [108] phi from mulf8s_prepared::@3 mulf8s_prepared::@5 to mulf8s_prepared::@1 [phi:mulf8s_prepared::@3/mulf8s_prepared::@5->mulf8s_prepared::@1] - // [108] phi (word) mulf8s_prepared::m#5 = (word) mulf8s_prepared::m#1 [phi:mulf8s_prepared::@3/mulf8s_prepared::@5->mulf8s_prepared::@1#0] -- register_copy + // [107] phi from mulf8s_prepared::@3 mulf8s_prepared::@5 to mulf8s_prepared::@1 [phi:mulf8s_prepared::@3/mulf8s_prepared::@5->mulf8s_prepared::@1] + // [107] phi (word) mulf8s_prepared::m#5 = (word) mulf8s_prepared::m#1 [phi:mulf8s_prepared::@3/mulf8s_prepared::@5->mulf8s_prepared::@1#0] -- register_copy // mulf8s_prepared::@1 __b1: // if(b<0) - // [109] if((signed byte) mulf8s_prepared::b#0>=(signed byte) 0) goto mulf8s_prepared::@2 -- vbsz1_ge_0_then_la1 + // [108] if((signed byte) mulf8s_prepared::b#0>=(signed byte) 0) goto mulf8s_prepared::@2 -- vbsz1_ge_0_then_la1 lda.z b cmp #0 bpl __b2 // mulf8s_prepared::@4 // >m - // [110] (byte~) mulf8s_prepared::$12 ← > (word) mulf8s_prepared::m#5 -- vbuaa=_hi_vwuz1 + // [109] (byte~) mulf8s_prepared::$12 ← > (word) mulf8s_prepared::m#5 -- vbuaa=_hi_vwuz1 lda.z m+1 // >m = (>m)-(byte)*memA - // [111] (byte~) mulf8s_prepared::$16 ← (byte~) mulf8s_prepared::$12 - (byte)*((const signed byte*) mulf8s_prepared::memA) -- vbuaa=vbuaa_minus__deref_pbuc1 + // [110] (byte~) mulf8s_prepared::$16 ← (byte~) mulf8s_prepared::$12 - (byte)*((const signed byte*) mulf8s_prepared::memA) -- vbuaa=vbuaa_minus__deref_pbuc1 sec sbc memA - // [112] (word) mulf8s_prepared::m#2 ← (word) mulf8s_prepared::m#5 hi= (byte~) mulf8s_prepared::$16 -- vwuz1=vwuz1_sethi_vbuaa + // [111] (word) mulf8s_prepared::m#2 ← (word) mulf8s_prepared::m#5 hi= (byte~) mulf8s_prepared::$16 -- vwuz1=vwuz1_sethi_vbuaa sta.z m+1 - // [113] phi from mulf8s_prepared::@1 mulf8s_prepared::@4 to mulf8s_prepared::@2 [phi:mulf8s_prepared::@1/mulf8s_prepared::@4->mulf8s_prepared::@2] - // [113] phi (word) mulf8s_prepared::m#4 = (word) mulf8s_prepared::m#5 [phi:mulf8s_prepared::@1/mulf8s_prepared::@4->mulf8s_prepared::@2#0] -- register_copy + // [112] phi from mulf8s_prepared::@1 mulf8s_prepared::@4 to mulf8s_prepared::@2 [phi:mulf8s_prepared::@1/mulf8s_prepared::@4->mulf8s_prepared::@2] + // [112] phi (word) mulf8s_prepared::m#4 = (word) mulf8s_prepared::m#5 [phi:mulf8s_prepared::@1/mulf8s_prepared::@4->mulf8s_prepared::@2#0] -- register_copy // mulf8s_prepared::@2 __b2: // mulf8s_prepared::@return // } - // [114] return + // [113] return rts } // mulf8u_prepared @@ -10602,9 +10526,9 @@ mulf8s_prepared: { mulf8u_prepared: { .label resL = $fe .label memB = $ff - .label return = $c + .label return = $b // *memB = b - // [115] *((const byte*) mulf8u_prepared::memB) ← (byte) mulf8u_prepared::b#0 -- _deref_pbuc1=vbuaa + // [114] *((const byte*) mulf8u_prepared::memB) ← (byte) mulf8u_prepared::b#0 -- _deref_pbuc1=vbuaa sta memB // asm // asm { ldxmemB sec sm1: ldamulf_sqr1_lo,x sm2: sbcmulf_sqr2_lo,x staresL sm3: ldamulf_sqr1_hi,x sm4: sbcmulf_sqr2_hi,x stamemB } @@ -10621,14 +10545,14 @@ mulf8u_prepared: { sbc mulf_sqr2_hi,x sta memB // return { *memB, *resL }; - // [117] (word) mulf8u_prepared::return#0 ← *((const byte*) mulf8u_prepared::memB) w= *((const byte*) mulf8u_prepared::resL) -- vwuz1=_deref_pbuc1_word__deref_pbuc2 + // [116] (word) mulf8u_prepared::return#0 ← *((const byte*) mulf8u_prepared::memB) w= *((const byte*) mulf8u_prepared::resL) -- vwuz1=_deref_pbuc1_word__deref_pbuc2 lda resL sta.z return lda memB sta.z return+1 // mulf8u_prepared::@return // } - // [118] return + // [117] return rts } // mulf8u_prepare @@ -10637,7 +10561,7 @@ mulf8u_prepared: { mulf8u_prepare: { .label memA = $fd // *memA = a - // [119] *((const byte*) mulf8u_prepare::memA) ← (byte) mulf8u_prepare::a#0 -- _deref_pbuc1=vbuaa + // [118] *((const byte*) mulf8u_prepare::memA) ← (byte) mulf8u_prepare::a#0 -- _deref_pbuc1=vbuaa sta memA // asm // asm { ldamemA stamulf8u_prepared.sm1+1 stamulf8u_prepared.sm3+1 eor#$ff stamulf8u_prepared.sm2+1 stamulf8u_prepared.sm4+1 } @@ -10648,76 +10572,76 @@ mulf8u_prepare: { sta mulf8u_prepared.sm4+1 // mulf8u_prepare::@return // } - // [121] return + // [120] return rts } // renderBobCleanup // Clean Up the rendered BOB's renderBobCleanup: { - .label screen = $10 - // [123] phi from renderBobCleanup to renderBobCleanup::@1 [phi:renderBobCleanup->renderBobCleanup::@1] - // [123] phi (byte) renderBobCleanup::i#2 = (byte) 0 [phi:renderBobCleanup->renderBobCleanup::@1#0] -- vbuxx=vbuc1 + .label screen = $f + // [122] phi from renderBobCleanup to renderBobCleanup::@1 [phi:renderBobCleanup->renderBobCleanup::@1] + // [122] phi (byte) renderBobCleanup::i#2 = (byte) 0 [phi:renderBobCleanup->renderBobCleanup::@1#0] -- vbuxx=vbuc1 ldx #0 - // [123] phi from renderBobCleanup::@1 to renderBobCleanup::@1 [phi:renderBobCleanup::@1->renderBobCleanup::@1] - // [123] phi (byte) renderBobCleanup::i#2 = (byte) renderBobCleanup::i#1 [phi:renderBobCleanup::@1->renderBobCleanup::@1#0] -- register_copy + // [122] phi from renderBobCleanup::@1 to renderBobCleanup::@1 [phi:renderBobCleanup::@1->renderBobCleanup::@1] + // [122] phi (byte) renderBobCleanup::i#2 = (byte) renderBobCleanup::i#1 [phi:renderBobCleanup::@1->renderBobCleanup::@1#0] -- register_copy // renderBobCleanup::@1 __b1: // screen = RENDERBOB_CLEANUP[i] - // [124] (byte~) renderBobCleanup::$1 ← (byte) renderBobCleanup::i#2 << (byte) 1 -- vbuaa=vbuxx_rol_1 + // [123] (byte~) renderBobCleanup::$1 ← (byte) renderBobCleanup::i#2 << (byte) 1 -- vbuaa=vbuxx_rol_1 txa asl - // [125] (byte*) renderBobCleanup::screen#0 ← *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobCleanup::$1) -- pbuz1=pptc1_derefidx_vbuaa + // [124] (byte*) renderBobCleanup::screen#0 ← *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobCleanup::$1) -- pbuz1=pptc1_derefidx_vbuaa tay lda RENDERBOB_CLEANUP,y sta.z screen lda RENDERBOB_CLEANUP+1,y sta.z screen+1 // screen[0] = 0 - // [126] *((byte*) renderBobCleanup::screen#0) ← (byte) 0 -- _deref_pbuz1=vbuc1 + // [125] *((byte*) renderBobCleanup::screen#0) ← (byte) 0 -- _deref_pbuz1=vbuc1 lda #0 tay sta (screen),y // screen[40] = 0 - // [127] *((byte*) renderBobCleanup::screen#0 + (byte) $28) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + // [126] *((byte*) renderBobCleanup::screen#0 + (byte) $28) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 ldy #$28 sta (screen),y // screen[80] = 0 - // [128] *((byte*) renderBobCleanup::screen#0 + (byte) $50) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + // [127] *((byte*) renderBobCleanup::screen#0 + (byte) $50) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 ldy #$50 sta (screen),y // screen[1] = 0 - // [129] *((byte*) renderBobCleanup::screen#0 + (byte) 1) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + // [128] *((byte*) renderBobCleanup::screen#0 + (byte) 1) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 ldy #1 sta (screen),y // screen[41] = 0 - // [130] *((byte*) renderBobCleanup::screen#0 + (byte) $29) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + // [129] *((byte*) renderBobCleanup::screen#0 + (byte) $29) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 ldy #$29 sta (screen),y // screen[81] = 0 - // [131] *((byte*) renderBobCleanup::screen#0 + (byte) $51) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + // [130] *((byte*) renderBobCleanup::screen#0 + (byte) $51) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 ldy #$51 sta (screen),y // screen[2] = 0 - // [132] *((byte*) renderBobCleanup::screen#0 + (byte) 2) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + // [131] *((byte*) renderBobCleanup::screen#0 + (byte) 2) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 ldy #2 sta (screen),y // screen[42] = 0 - // [133] *((byte*) renderBobCleanup::screen#0 + (byte) $2a) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + // [132] *((byte*) renderBobCleanup::screen#0 + (byte) $2a) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 ldy #$2a sta (screen),y // screen[82] = 0 - // [134] *((byte*) renderBobCleanup::screen#0 + (byte) $52) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 + // [133] *((byte*) renderBobCleanup::screen#0 + (byte) $52) ← (byte) 0 -- pbuz1_derefidx_vbuc1=vbuc2 ldy #$52 sta (screen),y // for(char i: 0..NUM_BOBS-1) - // [135] (byte) renderBobCleanup::i#1 ← ++ (byte) renderBobCleanup::i#2 -- vbuxx=_inc_vbuxx + // [134] (byte) renderBobCleanup::i#1 ← ++ (byte) renderBobCleanup::i#2 -- vbuxx=_inc_vbuxx inx - // [136] if((byte) renderBobCleanup::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto renderBobCleanup::@1 -- vbuxx_neq_vbuc1_then_la1 + // [135] if((byte) renderBobCleanup::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto renderBobCleanup::@1 -- vbuxx_neq_vbuc1_then_la1 cpx #NUM_BOBS-1+1 bne __b1 // renderBobCleanup::@return // } - // [137] return + // [136] return rts } // memset @@ -10728,8 +10652,8 @@ memset: { .const num = $3e8 .label end = str+num .label dst = 6 - // [139] phi from memset to memset::@1 [phi:memset->memset::@1] - // [139] phi (byte*) memset::dst#2 = (byte*)(const void*) memset::str#0 [phi:memset->memset::@1#0] -- pbuz1=pbuc1 + // [138] phi from memset to memset::@1 [phi:memset->memset::@1] + // [138] phi (byte*) memset::dst#2 = (byte*)(const void*) memset::str#0 [phi:memset->memset::@1#0] -- pbuz1=pbuc1 lda #str @@ -10737,7 +10661,7 @@ memset: { // memset::@1 __b1: // for(char* dst = str; dst!=end; dst++) - // [140] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 -- pbuz1_neq_pbuc1_then_la1 + // [139] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 -- pbuz1_neq_pbuc1_then_la1 lda.z dst+1 cmp #>end bne __b2 @@ -10746,47 +10670,47 @@ memset: { bne __b2 // memset::@return // } - // [141] return + // [140] return rts // memset::@2 __b2: // *dst = c - // [142] *((byte*) memset::dst#2) ← (const byte) memset::c#0 -- _deref_pbuz1=vbuc1 + // [141] *((byte*) memset::dst#2) ← (const byte) memset::c#0 -- _deref_pbuz1=vbuc1 lda #c ldy #0 sta (dst),y // for(char* dst = str; dst!=end; dst++) - // [143] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2 -- pbuz1=_inc_pbuz1 + // [142] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2 -- pbuz1=_inc_pbuz1 inc.z dst bne !+ inc.z dst+1 !: - // [139] phi from memset::@2 to memset::@1 [phi:memset::@2->memset::@1] - // [139] phi (byte*) memset::dst#2 = (byte*) memset::dst#1 [phi:memset::@2->memset::@1#0] -- register_copy + // [138] phi from memset::@2 to memset::@1 [phi:memset::@2->memset::@1] + // [138] phi (byte*) memset::dst#2 = (byte*) memset::dst#1 [phi:memset::@2->memset::@1#0] -- register_copy jmp __b1 } // renderBobInit // Initialize the tables used by renderBob() renderBobInit: { - .label __0 = $10 - .label __1 = $10 - .label __6 = $12 - .label __7 = $10 - // [145] phi from renderBobInit to renderBobInit::@1 [phi:renderBobInit->renderBobInit::@1] - // [145] phi (byte) renderBobInit::y#2 = (byte) 0 [phi:renderBobInit->renderBobInit::@1#0] -- vbuxx=vbuc1 + .label __0 = $f + .label __1 = $f + .label __6 = $11 + .label __7 = $f + // [144] phi from renderBobInit to renderBobInit::@1 [phi:renderBobInit->renderBobInit::@1] + // [144] phi (byte) renderBobInit::y#2 = (byte) 0 [phi:renderBobInit->renderBobInit::@1#0] -- vbuxx=vbuc1 ldx #0 - // [145] phi from renderBobInit::@1 to renderBobInit::@1 [phi:renderBobInit::@1->renderBobInit::@1] - // [145] phi (byte) renderBobInit::y#2 = (byte) renderBobInit::y#1 [phi:renderBobInit::@1->renderBobInit::@1#0] -- register_copy + // [144] phi from renderBobInit::@1 to renderBobInit::@1 [phi:renderBobInit::@1->renderBobInit::@1] + // [144] phi (byte) renderBobInit::y#2 = (byte) renderBobInit::y#1 [phi:renderBobInit::@1->renderBobInit::@1#0] -- register_copy // renderBobInit::@1 __b1: // (unsigned int)y - // [146] (word~) renderBobInit::$0 ← (word)(byte) renderBobInit::y#2 -- vwuz1=_word_vbuxx + // [145] (word~) renderBobInit::$0 ← (word)(byte) renderBobInit::y#2 -- vwuz1=_word_vbuxx txa sta.z __0 lda #0 sta.z __0+1 // ((unsigned int)y)*40 - // [147] (word~) renderBobInit::$6 ← (word~) renderBobInit::$0 << (byte) 2 -- vwuz1=vwuz2_rol_2 + // [146] (word~) renderBobInit::$6 ← (word~) renderBobInit::$0 << (byte) 2 -- vwuz1=vwuz2_rol_2 lda.z __0 asl sta.z __6 @@ -10795,7 +10719,7 @@ renderBobInit: { sta.z __6+1 asl.z __6 rol.z __6+1 - // [148] (word~) renderBobInit::$7 ← (word~) renderBobInit::$6 + (word~) renderBobInit::$0 -- vwuz1=vwuz2_plus_vwuz1 + // [147] (word~) renderBobInit::$7 ← (word~) renderBobInit::$6 + (word~) renderBobInit::$0 -- vwuz1=vwuz2_plus_vwuz1 lda.z __7 clc adc.z __6 @@ -10803,7 +10727,7 @@ renderBobInit: { lda.z __7+1 adc.z __6+1 sta.z __7+1 - // [149] (word~) renderBobInit::$1 ← (word~) renderBobInit::$7 << (byte) 3 -- vwuz1=vwuz1_rol_3 + // [148] (word~) renderBobInit::$1 ← (word~) renderBobInit::$7 << (byte) 3 -- vwuz1=vwuz1_rol_3 asl.z __1 rol.z __1+1 asl.z __1 @@ -10811,141 +10735,141 @@ renderBobInit: { asl.z __1 rol.z __1+1 // MUL40[y] = ((unsigned int)y)*40 - // [150] (byte~) renderBobInit::$4 ← (byte) renderBobInit::y#2 << (byte) 1 -- vbuaa=vbuxx_rol_1 + // [149] (byte~) renderBobInit::$4 ← (byte) renderBobInit::y#2 << (byte) 1 -- vbuaa=vbuxx_rol_1 txa asl - // [151] *((const word*) MUL40 + (byte~) renderBobInit::$4) ← (word~) renderBobInit::$1 -- pwuc1_derefidx_vbuaa=vwuz1 + // [150] *((const word*) MUL40 + (byte~) renderBobInit::$4) ← (word~) renderBobInit::$1 -- pwuc1_derefidx_vbuaa=vwuz1 tay lda.z __1 sta MUL40,y lda.z __1+1 sta MUL40+1,y // for(char y: 0..0x1f) - // [152] (byte) renderBobInit::y#1 ← ++ (byte) renderBobInit::y#2 -- vbuxx=_inc_vbuxx + // [151] (byte) renderBobInit::y#1 ← ++ (byte) renderBobInit::y#2 -- vbuxx=_inc_vbuxx inx - // [153] if((byte) renderBobInit::y#1!=(byte) $20) goto renderBobInit::@1 -- vbuxx_neq_vbuc1_then_la1 + // [152] if((byte) renderBobInit::y#1!=(byte) $20) goto renderBobInit::@1 -- vbuxx_neq_vbuc1_then_la1 cpx #$20 bne __b1 - // [154] phi from renderBobInit::@1 to renderBobInit::@2 [phi:renderBobInit::@1->renderBobInit::@2] - // [154] phi (byte) renderBobInit::i#2 = (byte) 0 [phi:renderBobInit::@1->renderBobInit::@2#0] -- vbuxx=vbuc1 + // [153] phi from renderBobInit::@1 to renderBobInit::@2 [phi:renderBobInit::@1->renderBobInit::@2] + // [153] phi (byte) renderBobInit::i#2 = (byte) 0 [phi:renderBobInit::@1->renderBobInit::@2#0] -- vbuxx=vbuc1 ldx #0 - // [154] phi from renderBobInit::@2 to renderBobInit::@2 [phi:renderBobInit::@2->renderBobInit::@2] - // [154] phi (byte) renderBobInit::i#2 = (byte) renderBobInit::i#1 [phi:renderBobInit::@2->renderBobInit::@2#0] -- register_copy + // [153] phi from renderBobInit::@2 to renderBobInit::@2 [phi:renderBobInit::@2->renderBobInit::@2] + // [153] phi (byte) renderBobInit::i#2 = (byte) renderBobInit::i#1 [phi:renderBobInit::@2->renderBobInit::@2#0] -- register_copy // renderBobInit::@2 __b2: // RENDERBOB_CLEANUP[i] = BOB_SCREEN - // [155] (byte~) renderBobInit::$5 ← (byte) renderBobInit::i#2 << (byte) 1 -- vbuaa=vbuxx_rol_1 + // [154] (byte~) renderBobInit::$5 ← (byte) renderBobInit::i#2 << (byte) 1 -- vbuaa=vbuxx_rol_1 txa asl - // [156] *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobInit::$5) ← (const byte*) BOB_SCREEN -- pptc1_derefidx_vbuaa=pbuc2 + // [155] *((const byte**) RENDERBOB_CLEANUP + (byte~) renderBobInit::$5) ← (const byte*) BOB_SCREEN -- pptc1_derefidx_vbuaa=pbuc2 tay lda #BOB_SCREEN sta RENDERBOB_CLEANUP+1,y // for(char i: 0..NUM_BOBS-1) - // [157] (byte) renderBobInit::i#1 ← ++ (byte) renderBobInit::i#2 -- vbuxx=_inc_vbuxx + // [156] (byte) renderBobInit::i#1 ← ++ (byte) renderBobInit::i#2 -- vbuxx=_inc_vbuxx inx - // [158] if((byte) renderBobInit::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto renderBobInit::@2 -- vbuxx_neq_vbuc1_then_la1 + // [157] if((byte) renderBobInit::i#1!=(const byte) NUM_BOBS-(byte) 1+(byte) 1) goto renderBobInit::@2 -- vbuxx_neq_vbuc1_then_la1 cpx #NUM_BOBS-1+1 bne __b2 // renderBobInit::@return // } - // [159] return + // [158] return rts } // prepareBobs // Creates the pre-shifted bobs into BOB_CHARSET and populates the BOB_TABLES // Modifies PROTO_BOB by shifting it around prepareBobs: { - .label bob_table = $10 + .label bob_table = $f .label shift_y = 2 // Populate charset and tables .label bob_glyph = 6 - .label cell = $b + .label cell = $a .label bob_table_idx = 4 .label shift_x = 5 // progress_init(SCREEN_BASIC) - // [161] call progress_init - // [242] phi from prepareBobs to progress_init [phi:prepareBobs->progress_init] + // [160] call progress_init + // [241] phi from prepareBobs to progress_init [phi:prepareBobs->progress_init] jsr progress_init - // [162] phi from prepareBobs to prepareBobs::@8 [phi:prepareBobs->prepareBobs::@8] + // [161] phi from prepareBobs to prepareBobs::@8 [phi:prepareBobs->prepareBobs::@8] // prepareBobs::@8 // bobCharsetFindOrAddGlyph(PROTO_BOB+48) - // [163] call bobCharsetFindOrAddGlyph - // [196] phi from prepareBobs::@8 to bobCharsetFindOrAddGlyph [phi:prepareBobs::@8->bobCharsetFindOrAddGlyph] - // [196] phi (byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 = (const byte*) PROTO_BOB+(byte) $30 [phi:prepareBobs::@8->bobCharsetFindOrAddGlyph#0] -- pbuz1=pbuc1 + // [162] call bobCharsetFindOrAddGlyph + // [195] phi from prepareBobs::@8 to bobCharsetFindOrAddGlyph [phi:prepareBobs::@8->bobCharsetFindOrAddGlyph] + // [195] phi (byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 = (const byte*) PROTO_BOB+(byte) $30 [phi:prepareBobs::@8->bobCharsetFindOrAddGlyph#0] -- pbuz1=pbuc1 lda #PROTO_BOB+$30 sta.z bobCharsetFindOrAddGlyph.bob_glyph+1 - // [196] phi (byte) bob_charset_next_id#23 = (byte) 0 [phi:prepareBobs::@8->bobCharsetFindOrAddGlyph#1] -- vbuz1=vbuc1 + // [195] phi (byte) bob_charset_next_id#23 = (byte) 0 [phi:prepareBobs::@8->bobCharsetFindOrAddGlyph#1] -- vbuz1=vbuc1 lda #0 sta.z bob_charset_next_id jsr bobCharsetFindOrAddGlyph - // [164] phi from prepareBobs::@8 to prepareBobs::@1 [phi:prepareBobs::@8->prepareBobs::@1] - // [164] phi (byte) prepareBobs::bob_table_idx#6 = (byte) 0 [phi:prepareBobs::@8->prepareBobs::@1#0] -- vbuz1=vbuc1 + // [163] phi from prepareBobs::@8 to prepareBobs::@1 [phi:prepareBobs::@8->prepareBobs::@1] + // [163] phi (byte) prepareBobs::bob_table_idx#6 = (byte) 0 [phi:prepareBobs::@8->prepareBobs::@1#0] -- vbuz1=vbuc1 lda #0 sta.z bob_table_idx - // [164] phi (byte) bob_charset_next_id#14 = (byte) bob_charset_next_id#16 [phi:prepareBobs::@8->prepareBobs::@1#1] -- register_copy - // [164] phi (byte) progress_idx#16 = (byte) 0 [phi:prepareBobs::@8->prepareBobs::@1#2] -- vbuz1=vbuc1 + // [163] phi (byte) bob_charset_next_id#14 = (byte) bob_charset_next_id#16 [phi:prepareBobs::@8->prepareBobs::@1#1] -- register_copy + // [163] phi (byte) progress_idx#16 = (byte) 0 [phi:prepareBobs::@8->prepareBobs::@1#2] -- vbuz1=vbuc1 sta.z progress_idx - // [164] phi (byte*) progress_cursor#15 = (const byte*) SCREEN_BASIC [phi:prepareBobs::@8->prepareBobs::@1#3] -- pbuz1=pbuc1 + // [163] phi (byte*) progress_cursor#15 = (const byte*) SCREEN_BASIC [phi:prepareBobs::@8->prepareBobs::@1#3] -- pbuz1=pbuc1 lda #SCREEN_BASIC sta.z progress_cursor+1 - // [164] phi (byte) prepareBobs::shift_y#2 = (byte) 0 [phi:prepareBobs::@8->prepareBobs::@1#4] -- vbuz1=vbuc1 + // [163] phi (byte) prepareBobs::shift_y#2 = (byte) 0 [phi:prepareBobs::@8->prepareBobs::@1#4] -- vbuz1=vbuc1 lda #0 sta.z shift_y // prepareBobs::@1 __b1: // for(char shift_y=0;shift_yprepareBobs::@2] + // [166] phi from prepareBobs::@1 to prepareBobs::@2 [phi:prepareBobs::@1->prepareBobs::@2] b1: - // [167] phi (byte) progress_idx#31 = (byte) progress_idx#16 [phi:prepareBobs::@1->prepareBobs::@2#0] -- register_copy - // [167] phi (byte*) progress_cursor#31 = (byte*) progress_cursor#15 [phi:prepareBobs::@1->prepareBobs::@2#1] -- register_copy - // [167] phi (byte) bob_charset_next_id#30 = (byte) bob_charset_next_id#14 [phi:prepareBobs::@1->prepareBobs::@2#2] -- register_copy - // [167] phi (byte) prepareBobs::bob_table_idx#12 = (byte) prepareBobs::bob_table_idx#6 [phi:prepareBobs::@1->prepareBobs::@2#3] -- register_copy - // [167] phi (byte) prepareBobs::shift_x#2 = (byte) 0 [phi:prepareBobs::@1->prepareBobs::@2#4] -- vbuz1=vbuc1 + // [166] phi (byte) progress_idx#31 = (byte) progress_idx#16 [phi:prepareBobs::@1->prepareBobs::@2#0] -- register_copy + // [166] phi (byte*) progress_cursor#31 = (byte*) progress_cursor#15 [phi:prepareBobs::@1->prepareBobs::@2#1] -- register_copy + // [166] phi (byte) bob_charset_next_id#30 = (byte) bob_charset_next_id#14 [phi:prepareBobs::@1->prepareBobs::@2#2] -- register_copy + // [166] phi (byte) prepareBobs::bob_table_idx#12 = (byte) prepareBobs::bob_table_idx#6 [phi:prepareBobs::@1->prepareBobs::@2#3] -- register_copy + // [166] phi (byte) prepareBobs::shift_x#2 = (byte) 0 [phi:prepareBobs::@1->prepareBobs::@2#4] -- vbuz1=vbuc1 lda #0 sta.z shift_x // prepareBobs::@2 __b2: // for(char shift_x=0;shift_xprepareBobs::@4] + // [168] phi from prepareBobs::@2 to prepareBobs::@4 [phi:prepareBobs::@2->prepareBobs::@4] // prepareBobs::@4 // shiftProtoBobDown() - // [170] call shiftProtoBobDown - // [231] phi from prepareBobs::@4 to shiftProtoBobDown [phi:prepareBobs::@4->shiftProtoBobDown] + // [169] call shiftProtoBobDown + // [230] phi from prepareBobs::@4 to shiftProtoBobDown [phi:prepareBobs::@4->shiftProtoBobDown] jsr shiftProtoBobDown // prepareBobs::@9 // for(char shift_y=0;shift_yprepareBobs::@1] - // [164] phi (byte) prepareBobs::bob_table_idx#6 = (byte) prepareBobs::bob_table_idx#12 [phi:prepareBobs::@9->prepareBobs::@1#0] -- register_copy - // [164] phi (byte) bob_charset_next_id#14 = (byte) bob_charset_next_id#30 [phi:prepareBobs::@9->prepareBobs::@1#1] -- register_copy - // [164] phi (byte) progress_idx#16 = (byte) progress_idx#31 [phi:prepareBobs::@9->prepareBobs::@1#2] -- register_copy - // [164] phi (byte*) progress_cursor#15 = (byte*) progress_cursor#31 [phi:prepareBobs::@9->prepareBobs::@1#3] -- register_copy - // [164] phi (byte) prepareBobs::shift_y#2 = (byte) prepareBobs::shift_y#1 [phi:prepareBobs::@9->prepareBobs::@1#4] -- register_copy + // [163] phi from prepareBobs::@9 to prepareBobs::@1 [phi:prepareBobs::@9->prepareBobs::@1] + // [163] phi (byte) prepareBobs::bob_table_idx#6 = (byte) prepareBobs::bob_table_idx#12 [phi:prepareBobs::@9->prepareBobs::@1#0] -- register_copy + // [163] phi (byte) bob_charset_next_id#14 = (byte) bob_charset_next_id#30 [phi:prepareBobs::@9->prepareBobs::@1#1] -- register_copy + // [163] phi (byte) progress_idx#16 = (byte) progress_idx#31 [phi:prepareBobs::@9->prepareBobs::@1#2] -- register_copy + // [163] phi (byte*) progress_cursor#15 = (byte*) progress_cursor#31 [phi:prepareBobs::@9->prepareBobs::@1#3] -- register_copy + // [163] phi (byte) prepareBobs::shift_y#2 = (byte) prepareBobs::shift_y#1 [phi:prepareBobs::@9->prepareBobs::@1#4] -- register_copy jmp __b1 // prepareBobs::@3 __b3: // bob_table = BOB_TABLES + bob_table_idx - // [172] (byte*) prepareBobs::bob_table#0 ← (const byte*) BOB_TABLES + (byte) prepareBobs::bob_table_idx#12 -- pbuz1=pbuc1_plus_vbuz2 + // [171] (byte*) prepareBobs::bob_table#0 ← (const byte*) BOB_TABLES + (byte) prepareBobs::bob_table_idx#12 -- pbuz1=pbuc1_plus_vbuz2 lda.z bob_table_idx clc adc #BOB_TABLES adc #0 sta.z bob_table+1 - // [173] phi from prepareBobs::@3 to prepareBobs::@5 [phi:prepareBobs::@3->prepareBobs::@5] - // [173] phi (byte*) progress_cursor#24 = (byte*) progress_cursor#31 [phi:prepareBobs::@3->prepareBobs::@5#0] -- register_copy - // [173] phi (byte) progress_idx#25 = (byte) progress_idx#31 [phi:prepareBobs::@3->prepareBobs::@5#1] -- register_copy - // [173] phi (byte*) prepareBobs::bob_table#2 = (byte*) prepareBobs::bob_table#0 [phi:prepareBobs::@3->prepareBobs::@5#2] -- register_copy - // [173] phi (byte) bob_charset_next_id#21 = (byte) bob_charset_next_id#30 [phi:prepareBobs::@3->prepareBobs::@5#3] -- register_copy - // [173] phi (byte*) prepareBobs::bob_glyph#2 = (const byte*) PROTO_BOB [phi:prepareBobs::@3->prepareBobs::@5#4] -- pbuz1=pbuc1 + // [172] phi from prepareBobs::@3 to prepareBobs::@5 [phi:prepareBobs::@3->prepareBobs::@5] + // [172] phi (byte*) progress_cursor#24 = (byte*) progress_cursor#31 [phi:prepareBobs::@3->prepareBobs::@5#0] -- register_copy + // [172] phi (byte) progress_idx#25 = (byte) progress_idx#31 [phi:prepareBobs::@3->prepareBobs::@5#1] -- register_copy + // [172] phi (byte*) prepareBobs::bob_table#2 = (byte*) prepareBobs::bob_table#0 [phi:prepareBobs::@3->prepareBobs::@5#2] -- register_copy + // [172] phi (byte) bob_charset_next_id#21 = (byte) bob_charset_next_id#30 [phi:prepareBobs::@3->prepareBobs::@5#3] -- register_copy + // [172] phi (byte*) prepareBobs::bob_glyph#2 = (const byte*) PROTO_BOB [phi:prepareBobs::@3->prepareBobs::@5#4] -- pbuz1=pbuc1 lda #PROTO_BOB sta.z bob_glyph+1 - // [173] phi (byte) prepareBobs::cell#2 = (byte) 0 [phi:prepareBobs::@3->prepareBobs::@5#5] -- vbuz1=vbuc1 + // [172] phi (byte) prepareBobs::cell#2 = (byte) 0 [phi:prepareBobs::@3->prepareBobs::@5#5] -- vbuz1=vbuc1 lda #0 sta.z cell // prepareBobs::@5 __b5: // for(char cell = 0; cell<9; cell++) - // [174] if((byte) prepareBobs::cell#2<(byte) 9) goto prepareBobs::@6 -- vbuz1_lt_vbuc1_then_la1 + // [173] if((byte) prepareBobs::cell#2<(byte) 9) goto prepareBobs::@6 -- vbuz1_lt_vbuc1_then_la1 lda.z cell cmp #9 bcc __b6 // prepareBobs::@7 // bob_table_idx++; - // [175] (byte) prepareBobs::bob_table_idx#1 ← ++ (byte) prepareBobs::bob_table_idx#12 -- vbuz1=_inc_vbuz1 + // [174] (byte) prepareBobs::bob_table_idx#1 ← ++ (byte) prepareBobs::bob_table_idx#12 -- vbuz1=_inc_vbuz1 inc.z bob_table_idx // shiftProtoBobRight() - // [176] call shiftProtoBobRight - // [214] phi from prepareBobs::@7 to shiftProtoBobRight [phi:prepareBobs::@7->shiftProtoBobRight] + // [175] call shiftProtoBobRight + // [213] phi from prepareBobs::@7 to shiftProtoBobRight [phi:prepareBobs::@7->shiftProtoBobRight] jsr shiftProtoBobRight - // [177] phi from prepareBobs::@7 to prepareBobs::@12 [phi:prepareBobs::@7->prepareBobs::@12] + // [176] phi from prepareBobs::@7 to prepareBobs::@12 [phi:prepareBobs::@7->prepareBobs::@12] // prepareBobs::@12 // shiftProtoBobRight() - // [178] call shiftProtoBobRight - // [214] phi from prepareBobs::@12 to shiftProtoBobRight [phi:prepareBobs::@12->shiftProtoBobRight] + // [177] call shiftProtoBobRight + // [213] phi from prepareBobs::@12 to shiftProtoBobRight [phi:prepareBobs::@12->shiftProtoBobRight] jsr shiftProtoBobRight // prepareBobs::@13 // for(char shift_x=0;shift_xprepareBobs::@2] - // [167] phi (byte) progress_idx#31 = (byte) progress_idx#25 [phi:prepareBobs::@13->prepareBobs::@2#0] -- register_copy - // [167] phi (byte*) progress_cursor#31 = (byte*) progress_cursor#24 [phi:prepareBobs::@13->prepareBobs::@2#1] -- register_copy - // [167] phi (byte) bob_charset_next_id#30 = (byte) bob_charset_next_id#21 [phi:prepareBobs::@13->prepareBobs::@2#2] -- register_copy - // [167] phi (byte) prepareBobs::bob_table_idx#12 = (byte) prepareBobs::bob_table_idx#1 [phi:prepareBobs::@13->prepareBobs::@2#3] -- register_copy - // [167] phi (byte) prepareBobs::shift_x#2 = (byte) prepareBobs::shift_x#1 [phi:prepareBobs::@13->prepareBobs::@2#4] -- register_copy + // [166] phi from prepareBobs::@13 to prepareBobs::@2 [phi:prepareBobs::@13->prepareBobs::@2] + // [166] phi (byte) progress_idx#31 = (byte) progress_idx#25 [phi:prepareBobs::@13->prepareBobs::@2#0] -- register_copy + // [166] phi (byte*) progress_cursor#31 = (byte*) progress_cursor#24 [phi:prepareBobs::@13->prepareBobs::@2#1] -- register_copy + // [166] phi (byte) bob_charset_next_id#30 = (byte) bob_charset_next_id#21 [phi:prepareBobs::@13->prepareBobs::@2#2] -- register_copy + // [166] phi (byte) prepareBobs::bob_table_idx#12 = (byte) prepareBobs::bob_table_idx#1 [phi:prepareBobs::@13->prepareBobs::@2#3] -- register_copy + // [166] phi (byte) prepareBobs::shift_x#2 = (byte) prepareBobs::shift_x#1 [phi:prepareBobs::@13->prepareBobs::@2#4] -- register_copy jmp __b2 // prepareBobs::@6 __b6: // bobCharsetFindOrAddGlyph(bob_glyph) - // [180] (byte*) bobCharsetFindOrAddGlyph::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 - // [181] call bobCharsetFindOrAddGlyph - // [196] phi from prepareBobs::@6 to bobCharsetFindOrAddGlyph [phi:prepareBobs::@6->bobCharsetFindOrAddGlyph] - // [196] phi (byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 = (byte*) bobCharsetFindOrAddGlyph::bob_glyph#1 [phi:prepareBobs::@6->bobCharsetFindOrAddGlyph#0] -- register_copy - // [196] phi (byte) bob_charset_next_id#23 = (byte) bob_charset_next_id#21 [phi:prepareBobs::@6->bobCharsetFindOrAddGlyph#1] -- register_copy + // [179] (byte*) bobCharsetFindOrAddGlyph::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 + // [180] call bobCharsetFindOrAddGlyph + // [195] phi from prepareBobs::@6 to bobCharsetFindOrAddGlyph [phi:prepareBobs::@6->bobCharsetFindOrAddGlyph] + // [195] phi (byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 = (byte*) bobCharsetFindOrAddGlyph::bob_glyph#1 [phi:prepareBobs::@6->bobCharsetFindOrAddGlyph#0] -- register_copy + // [195] phi (byte) bob_charset_next_id#23 = (byte) bob_charset_next_id#21 [phi:prepareBobs::@6->bobCharsetFindOrAddGlyph#1] -- register_copy jsr bobCharsetFindOrAddGlyph // bobCharsetFindOrAddGlyph(bob_glyph) - // [182] (byte) bobCharsetFindOrAddGlyph::return#1 ← (byte) bobCharsetFindOrAddGlyph::glyph_id#11 -- vbuaa=vbuz1 - lda.z bobCharsetFindOrAddGlyph.glyph_id + // [181] (byte) bobCharsetFindOrAddGlyph::return#1 ← (byte) bobCharsetFindOrAddGlyph::glyph_id#11 -- vbuaa=vbuxx + txa // prepareBobs::@10 - // [183] (byte~) prepareBobs::$6 ← (byte) bobCharsetFindOrAddGlyph::return#1 + // [182] (byte~) prepareBobs::$6 ← (byte) bobCharsetFindOrAddGlyph::return#1 // *bob_table = bobCharsetFindOrAddGlyph(bob_glyph) - // [184] *((byte*) prepareBobs::bob_table#2) ← (byte~) prepareBobs::$6 -- _deref_pbuz1=vbuaa + // [183] *((byte*) prepareBobs::bob_table#2) ← (byte~) prepareBobs::$6 -- _deref_pbuz1=vbuaa // Look for an existing char in BOB_CHARSET ldy #0 sta (bob_table),y // bob_glyph+=8 - // [185] (byte*) prepareBobs::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 + (byte) 8 -- pbuz1=pbuz1_plus_vbuc1 + // [184] (byte*) prepareBobs::bob_glyph#1 ← (byte*) prepareBobs::bob_glyph#2 + (byte) 8 -- pbuz1=pbuz1_plus_vbuc1 // Move to the next glyph lda #8 clc @@ -11028,7 +10952,7 @@ prepareBobs: { inc.z bob_glyph+1 !: // bob_table += BOB_SHIFTS_X*BOB_SHIFTS_Y - // [186] (byte*) prepareBobs::bob_table#1 ← (byte*) prepareBobs::bob_table#2 + (const byte) BOB_SHIFTS_X*(const byte) BOB_SHIFTS_Y -- pbuz1=pbuz1_plus_vbuc1 + // [185] (byte*) prepareBobs::bob_table#1 ← (byte*) prepareBobs::bob_table#2 + (const byte) BOB_SHIFTS_X*(const byte) BOB_SHIFTS_Y -- pbuz1=pbuz1_plus_vbuc1 // Move to the next sub-table lda #BOB_SHIFTS_X*BOB_SHIFTS_Y clc @@ -11038,19 +10962,19 @@ prepareBobs: { inc.z bob_table+1 !: // progress_inc() - // [187] call progress_inc + // [186] call progress_inc jsr progress_inc // prepareBobs::@11 // for(char cell = 0; cell<9; cell++) - // [188] (byte) prepareBobs::cell#1 ← ++ (byte) prepareBobs::cell#2 -- vbuz1=_inc_vbuz1 + // [187] (byte) prepareBobs::cell#1 ← ++ (byte) prepareBobs::cell#2 -- vbuz1=_inc_vbuz1 inc.z cell - // [173] phi from prepareBobs::@11 to prepareBobs::@5 [phi:prepareBobs::@11->prepareBobs::@5] - // [173] phi (byte*) progress_cursor#24 = (byte*) progress_cursor#17 [phi:prepareBobs::@11->prepareBobs::@5#0] -- register_copy - // [173] phi (byte) progress_idx#25 = (byte) progress_idx#10 [phi:prepareBobs::@11->prepareBobs::@5#1] -- register_copy - // [173] phi (byte*) prepareBobs::bob_table#2 = (byte*) prepareBobs::bob_table#1 [phi:prepareBobs::@11->prepareBobs::@5#2] -- register_copy - // [173] phi (byte) bob_charset_next_id#21 = (byte) bob_charset_next_id#16 [phi:prepareBobs::@11->prepareBobs::@5#3] -- register_copy - // [173] phi (byte*) prepareBobs::bob_glyph#2 = (byte*) prepareBobs::bob_glyph#1 [phi:prepareBobs::@11->prepareBobs::@5#4] -- register_copy - // [173] phi (byte) prepareBobs::cell#2 = (byte) prepareBobs::cell#1 [phi:prepareBobs::@11->prepareBobs::@5#5] -- register_copy + // [172] phi from prepareBobs::@11 to prepareBobs::@5 [phi:prepareBobs::@11->prepareBobs::@5] + // [172] phi (byte*) progress_cursor#24 = (byte*) progress_cursor#17 [phi:prepareBobs::@11->prepareBobs::@5#0] -- register_copy + // [172] phi (byte) progress_idx#25 = (byte) progress_idx#10 [phi:prepareBobs::@11->prepareBobs::@5#1] -- register_copy + // [172] phi (byte*) prepareBobs::bob_table#2 = (byte*) prepareBobs::bob_table#1 [phi:prepareBobs::@11->prepareBobs::@5#2] -- register_copy + // [172] phi (byte) bob_charset_next_id#21 = (byte) bob_charset_next_id#16 [phi:prepareBobs::@11->prepareBobs::@5#3] -- register_copy + // [172] phi (byte*) prepareBobs::bob_glyph#2 = (byte*) prepareBobs::bob_glyph#1 [phi:prepareBobs::@11->prepareBobs::@5#4] -- register_copy + // [172] phi (byte) prepareBobs::cell#2 = (byte) prepareBobs::cell#1 [phi:prepareBobs::@11->prepareBobs::@5#5] -- register_copy jmp __b5 } // progress_inc @@ -11058,43 +10982,43 @@ prepareBobs: { // Done by increasing the character until the idx is 8 and then moving to the next char progress_inc: { // if(++progress_idx==8) - // [189] (byte) progress_idx#8 ← ++ (byte) progress_idx#25 -- vbuz1=_inc_vbuz1 + // [188] (byte) progress_idx#8 ← ++ (byte) progress_idx#25 -- vbuz1=_inc_vbuz1 inc.z progress_idx - // [190] if((byte) progress_idx#8!=(byte) 8) goto progress_inc::@1 -- vbuz1_neq_vbuc1_then_la1 + // [189] if((byte) progress_idx#8!=(byte) 8) goto progress_inc::@1 -- vbuz1_neq_vbuc1_then_la1 lda #8 cmp.z progress_idx bne __b1 // progress_inc::@2 // *progress_cursor = progress_chars[8] - // [191] *((byte*) progress_cursor#24) ← *((const byte*) progress_inc::progress_chars+(byte) 8) -- _deref_pbuz1=_deref_pbuc1 + // [190] *((byte*) progress_cursor#24) ← *((const byte*) progress_inc::progress_chars+(byte) 8) -- _deref_pbuz1=_deref_pbuc1 lda progress_chars+8 ldy #0 sta (progress_cursor),y // progress_cursor++; - // [192] (byte*) progress_cursor#8 ← ++ (byte*) progress_cursor#24 -- pbuz1=_inc_pbuz1 + // [191] (byte*) progress_cursor#8 ← ++ (byte*) progress_cursor#24 -- pbuz1=_inc_pbuz1 inc.z progress_cursor bne !+ inc.z progress_cursor+1 !: - // [193] phi from progress_inc::@2 to progress_inc::@1 [phi:progress_inc::@2->progress_inc::@1] - // [193] phi (byte*) progress_cursor#17 = (byte*) progress_cursor#8 [phi:progress_inc::@2->progress_inc::@1#0] -- register_copy - // [193] phi (byte) progress_idx#10 = (byte) 0 [phi:progress_inc::@2->progress_inc::@1#1] -- vbuz1=vbuc1 + // [192] phi from progress_inc::@2 to progress_inc::@1 [phi:progress_inc::@2->progress_inc::@1] + // [192] phi (byte*) progress_cursor#17 = (byte*) progress_cursor#8 [phi:progress_inc::@2->progress_inc::@1#0] -- register_copy + // [192] phi (byte) progress_idx#10 = (byte) 0 [phi:progress_inc::@2->progress_inc::@1#1] -- vbuz1=vbuc1 lda #0 sta.z progress_idx - // [193] phi from progress_inc to progress_inc::@1 [phi:progress_inc->progress_inc::@1] - // [193] phi (byte*) progress_cursor#17 = (byte*) progress_cursor#24 [phi:progress_inc->progress_inc::@1#0] -- register_copy - // [193] phi (byte) progress_idx#10 = (byte) progress_idx#8 [phi:progress_inc->progress_inc::@1#1] -- register_copy + // [192] phi from progress_inc to progress_inc::@1 [phi:progress_inc->progress_inc::@1] + // [192] phi (byte*) progress_cursor#17 = (byte*) progress_cursor#24 [phi:progress_inc->progress_inc::@1#0] -- register_copy + // [192] phi (byte) progress_idx#10 = (byte) progress_idx#8 [phi:progress_inc->progress_inc::@1#1] -- register_copy // progress_inc::@1 __b1: // *progress_cursor = progress_chars[progress_idx] - // [194] *((byte*) progress_cursor#17) ← *((const byte*) progress_inc::progress_chars + (byte) progress_idx#10) -- _deref_pbuz1=pbuc1_derefidx_vbuz2 + // [193] *((byte*) progress_cursor#17) ← *((const byte*) progress_inc::progress_chars + (byte) progress_idx#10) -- _deref_pbuz1=pbuc1_derefidx_vbuz2 ldy.z progress_idx lda progress_chars,y ldy #0 sta (progress_cursor),y // progress_inc::@return // } - // [195] return + // [194] return rts // Progress characters progress_chars: .byte $20, $65, $74, $75, $61, $f6, $e7, $ea, $e0 @@ -11106,102 +11030,91 @@ progress_inc: { // bobCharsetFindOrAddGlyph(byte* zeropage(6) bob_glyph) bobCharsetFindOrAddGlyph: { .label bob_glyph = 6 - .label i = 8 - .label glyph_id = $e - .label glyph_cursor = $12 - // [197] phi from bobCharsetFindOrAddGlyph to bobCharsetFindOrAddGlyph::@1 [phi:bobCharsetFindOrAddGlyph->bobCharsetFindOrAddGlyph::@1] - // [197] phi (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 = (const byte*) BOB_CHARSET [phi:bobCharsetFindOrAddGlyph->bobCharsetFindOrAddGlyph::@1#0] -- pbuz1=pbuc1 + .label glyph_cursor = $11 + // [196] phi from bobCharsetFindOrAddGlyph to bobCharsetFindOrAddGlyph::@1 [phi:bobCharsetFindOrAddGlyph->bobCharsetFindOrAddGlyph::@1] + // [196] phi (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 = (const byte*) BOB_CHARSET [phi:bobCharsetFindOrAddGlyph->bobCharsetFindOrAddGlyph::@1#0] -- pbuz1=pbuc1 lda #BOB_CHARSET sta.z glyph_cursor+1 - // [197] phi (byte) bobCharsetFindOrAddGlyph::glyph_id#11 = (byte) 0 [phi:bobCharsetFindOrAddGlyph->bobCharsetFindOrAddGlyph::@1#1] -- vbuz1=vbuc1 - lda #0 - sta.z glyph_id + // [196] phi (byte) bobCharsetFindOrAddGlyph::glyph_id#11 = (byte) 0 [phi:bobCharsetFindOrAddGlyph->bobCharsetFindOrAddGlyph::@1#1] -- vbuxx=vbuc1 + ldx #0 // bobCharsetFindOrAddGlyph::@1 __b1: // while(glyph_id!=bob_charset_next_id) - // [198] if((byte) bobCharsetFindOrAddGlyph::glyph_id#11!=(byte) bob_charset_next_id#23) goto bobCharsetFindOrAddGlyph::@2 -- vbuz1_neq_vbuz2_then_la1 - lda.z glyph_id - cmp.z bob_charset_next_id + // [197] if((byte) bobCharsetFindOrAddGlyph::glyph_id#11!=(byte) bob_charset_next_id#23) goto bobCharsetFindOrAddGlyph::@2 -- vbuxx_neq_vbuz1_then_la1 + cpx.z bob_charset_next_id bne b1 - // [199] phi from bobCharsetFindOrAddGlyph::@1 to bobCharsetFindOrAddGlyph::@7 [phi:bobCharsetFindOrAddGlyph::@1->bobCharsetFindOrAddGlyph::@7] - // [199] phi (byte) bobCharsetFindOrAddGlyph::i1#2 = (byte) 0 [phi:bobCharsetFindOrAddGlyph::@1->bobCharsetFindOrAddGlyph::@7#0] -- vbuyy=vbuc1 + // [198] phi from bobCharsetFindOrAddGlyph::@1 to bobCharsetFindOrAddGlyph::@7 [phi:bobCharsetFindOrAddGlyph::@1->bobCharsetFindOrAddGlyph::@7] + // [198] phi (byte) bobCharsetFindOrAddGlyph::i1#2 = (byte) 0 [phi:bobCharsetFindOrAddGlyph::@1->bobCharsetFindOrAddGlyph::@7#0] -- vbuyy=vbuc1 ldy #0 // Not found - add it // bobCharsetFindOrAddGlyph::@7 __b7: // for(char i=0;i<8;i++) - // [200] if((byte) bobCharsetFindOrAddGlyph::i1#2<(byte) 8) goto bobCharsetFindOrAddGlyph::@8 -- vbuyy_lt_vbuc1_then_la1 + // [199] if((byte) bobCharsetFindOrAddGlyph::i1#2<(byte) 8) goto bobCharsetFindOrAddGlyph::@8 -- vbuyy_lt_vbuc1_then_la1 cpy #8 bcc __b8 // bobCharsetFindOrAddGlyph::@9 // bob_charset_next_id++; - // [201] (byte) bob_charset_next_id#8 ← ++ (byte) bob_charset_next_id#23 -- vbuz1=_inc_vbuz1 + // [200] (byte) bob_charset_next_id#8 ← ++ (byte) bob_charset_next_id#23 -- vbuz1=_inc_vbuz1 inc.z bob_charset_next_id - // [202] phi from bobCharsetFindOrAddGlyph::@5 bobCharsetFindOrAddGlyph::@9 to bobCharsetFindOrAddGlyph::@return [phi:bobCharsetFindOrAddGlyph::@5/bobCharsetFindOrAddGlyph::@9->bobCharsetFindOrAddGlyph::@return] - // [202] phi (byte) bob_charset_next_id#16 = (byte) bob_charset_next_id#23 [phi:bobCharsetFindOrAddGlyph::@5/bobCharsetFindOrAddGlyph::@9->bobCharsetFindOrAddGlyph::@return#0] -- register_copy + // [201] phi from bobCharsetFindOrAddGlyph::@5 bobCharsetFindOrAddGlyph::@9 to bobCharsetFindOrAddGlyph::@return [phi:bobCharsetFindOrAddGlyph::@5/bobCharsetFindOrAddGlyph::@9->bobCharsetFindOrAddGlyph::@return] + // [201] phi (byte) bob_charset_next_id#16 = (byte) bob_charset_next_id#23 [phi:bobCharsetFindOrAddGlyph::@5/bobCharsetFindOrAddGlyph::@9->bobCharsetFindOrAddGlyph::@return#0] -- register_copy // bobCharsetFindOrAddGlyph::@return // } - // [203] return + // [202] return rts // bobCharsetFindOrAddGlyph::@8 __b8: // glyph_cursor[i]=bob_glyph[i] - // [204] *((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) bobCharsetFindOrAddGlyph::i1#2) ← *((byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 + (byte) bobCharsetFindOrAddGlyph::i1#2) -- pbuz1_derefidx_vbuyy=pbuz2_derefidx_vbuyy + // [203] *((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) bobCharsetFindOrAddGlyph::i1#2) ← *((byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 + (byte) bobCharsetFindOrAddGlyph::i1#2) -- pbuz1_derefidx_vbuyy=pbuz2_derefidx_vbuyy lda (bob_glyph),y sta (glyph_cursor),y // for(char i=0;i<8;i++) - // [205] (byte) bobCharsetFindOrAddGlyph::i1#1 ← ++ (byte) bobCharsetFindOrAddGlyph::i1#2 -- vbuyy=_inc_vbuyy + // [204] (byte) bobCharsetFindOrAddGlyph::i1#1 ← ++ (byte) bobCharsetFindOrAddGlyph::i1#2 -- vbuyy=_inc_vbuyy iny - // [199] phi from bobCharsetFindOrAddGlyph::@8 to bobCharsetFindOrAddGlyph::@7 [phi:bobCharsetFindOrAddGlyph::@8->bobCharsetFindOrAddGlyph::@7] - // [199] phi (byte) bobCharsetFindOrAddGlyph::i1#2 = (byte) bobCharsetFindOrAddGlyph::i1#1 [phi:bobCharsetFindOrAddGlyph::@8->bobCharsetFindOrAddGlyph::@7#0] -- register_copy + // [198] phi from bobCharsetFindOrAddGlyph::@8 to bobCharsetFindOrAddGlyph::@7 [phi:bobCharsetFindOrAddGlyph::@8->bobCharsetFindOrAddGlyph::@7] + // [198] phi (byte) bobCharsetFindOrAddGlyph::i1#2 = (byte) bobCharsetFindOrAddGlyph::i1#1 [phi:bobCharsetFindOrAddGlyph::@8->bobCharsetFindOrAddGlyph::@7#0] -- register_copy jmp __b7 - // [206] phi from bobCharsetFindOrAddGlyph::@1 to bobCharsetFindOrAddGlyph::@2 [phi:bobCharsetFindOrAddGlyph::@1->bobCharsetFindOrAddGlyph::@2] + // [205] phi from bobCharsetFindOrAddGlyph::@1 to bobCharsetFindOrAddGlyph::@2 [phi:bobCharsetFindOrAddGlyph::@1->bobCharsetFindOrAddGlyph::@2] b1: - // [206] phi (byte) bobCharsetFindOrAddGlyph::i#2 = (byte) 0 [phi:bobCharsetFindOrAddGlyph::@1->bobCharsetFindOrAddGlyph::@2#0] -- vbuz1=vbuc1 - lda #0 - sta.z i + // [205] phi (byte) bobCharsetFindOrAddGlyph::i#2 = (byte) 0 [phi:bobCharsetFindOrAddGlyph::@1->bobCharsetFindOrAddGlyph::@2#0] -- vbuyy=vbuc1 + ldy #0 // bobCharsetFindOrAddGlyph::@2 __b2: // for(char i=0;i<8;i++) - // [207] if((byte) bobCharsetFindOrAddGlyph::i#2<(byte) 8) goto bobCharsetFindOrAddGlyph::@3 -- vbuz1_lt_vbuc1_then_la1 - lda.z i - cmp #8 + // [206] if((byte) bobCharsetFindOrAddGlyph::i#2<(byte) 8) goto bobCharsetFindOrAddGlyph::@3 -- vbuyy_lt_vbuc1_then_la1 + cpy #8 bcc __b3 - // [209] phi from bobCharsetFindOrAddGlyph::@2 to bobCharsetFindOrAddGlyph::@5 [phi:bobCharsetFindOrAddGlyph::@2->bobCharsetFindOrAddGlyph::@5] - // [209] phi (byte) bobCharsetFindOrAddGlyph::found#2 = (byte) 1 [phi:bobCharsetFindOrAddGlyph::@2->bobCharsetFindOrAddGlyph::@5#0] -- vbuaa=vbuc1 + // [208] phi from bobCharsetFindOrAddGlyph::@2 to bobCharsetFindOrAddGlyph::@5 [phi:bobCharsetFindOrAddGlyph::@2->bobCharsetFindOrAddGlyph::@5] + // [208] phi (byte) bobCharsetFindOrAddGlyph::found#2 = (byte) 1 [phi:bobCharsetFindOrAddGlyph::@2->bobCharsetFindOrAddGlyph::@5#0] -- vbuaa=vbuc1 lda #1 jmp __b5 // bobCharsetFindOrAddGlyph::@3 __b3: // if(glyph_cursor[i]!=bob_glyph[i]) - // [208] if(*((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) bobCharsetFindOrAddGlyph::i#2)==*((byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 + (byte) bobCharsetFindOrAddGlyph::i#2)) goto bobCharsetFindOrAddGlyph::@4 -- pbuz1_derefidx_vbuz2_eq_pbuz3_derefidx_vbuz2_then_la1 - ldy.z i + // [207] if(*((byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) bobCharsetFindOrAddGlyph::i#2)==*((byte*) bobCharsetFindOrAddGlyph::bob_glyph#10 + (byte) bobCharsetFindOrAddGlyph::i#2)) goto bobCharsetFindOrAddGlyph::@4 -- pbuz1_derefidx_vbuyy_eq_pbuz2_derefidx_vbuyy_then_la1 lda (glyph_cursor),y - tax - lda (bob_glyph),y - tay - sty.z $ff - cpx.z $ff + cmp (bob_glyph),y beq __b4 - // [209] phi from bobCharsetFindOrAddGlyph::@3 to bobCharsetFindOrAddGlyph::@5 [phi:bobCharsetFindOrAddGlyph::@3->bobCharsetFindOrAddGlyph::@5] - // [209] phi (byte) bobCharsetFindOrAddGlyph::found#2 = (byte) 0 [phi:bobCharsetFindOrAddGlyph::@3->bobCharsetFindOrAddGlyph::@5#0] -- vbuaa=vbuc1 + // [208] phi from bobCharsetFindOrAddGlyph::@3 to bobCharsetFindOrAddGlyph::@5 [phi:bobCharsetFindOrAddGlyph::@3->bobCharsetFindOrAddGlyph::@5] + // [208] phi (byte) bobCharsetFindOrAddGlyph::found#2 = (byte) 0 [phi:bobCharsetFindOrAddGlyph::@3->bobCharsetFindOrAddGlyph::@5#0] -- vbuaa=vbuc1 lda #0 // bobCharsetFindOrAddGlyph::@5 __b5: // if(found) - // [210] if((byte) 0==(byte) bobCharsetFindOrAddGlyph::found#2) goto bobCharsetFindOrAddGlyph::@6 -- vbuc1_eq_vbuaa_then_la1 + // [209] if((byte) 0==(byte) bobCharsetFindOrAddGlyph::found#2) goto bobCharsetFindOrAddGlyph::@6 -- vbuc1_eq_vbuaa_then_la1 cmp #0 beq __b6 rts // bobCharsetFindOrAddGlyph::@6 __b6: // glyph_id++; - // [211] (byte) bobCharsetFindOrAddGlyph::glyph_id#1 ← ++ (byte) bobCharsetFindOrAddGlyph::glyph_id#11 -- vbuz1=_inc_vbuz1 - inc.z glyph_id + // [210] (byte) bobCharsetFindOrAddGlyph::glyph_id#1 ← ++ (byte) bobCharsetFindOrAddGlyph::glyph_id#11 -- vbuxx=_inc_vbuxx + inx // glyph_cursor +=8 - // [212] (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#1 ← (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) 8 -- pbuz1=pbuz1_plus_vbuc1 + // [211] (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#1 ← (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 + (byte) 8 -- pbuz1=pbuz1_plus_vbuc1 lda #8 clc adc.z glyph_cursor @@ -11209,107 +11122,107 @@ bobCharsetFindOrAddGlyph: { bcc !+ inc.z glyph_cursor+1 !: - // [197] phi from bobCharsetFindOrAddGlyph::@6 to bobCharsetFindOrAddGlyph::@1 [phi:bobCharsetFindOrAddGlyph::@6->bobCharsetFindOrAddGlyph::@1] - // [197] phi (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 = (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#1 [phi:bobCharsetFindOrAddGlyph::@6->bobCharsetFindOrAddGlyph::@1#0] -- register_copy - // [197] phi (byte) bobCharsetFindOrAddGlyph::glyph_id#11 = (byte) bobCharsetFindOrAddGlyph::glyph_id#1 [phi:bobCharsetFindOrAddGlyph::@6->bobCharsetFindOrAddGlyph::@1#1] -- register_copy + // [196] phi from bobCharsetFindOrAddGlyph::@6 to bobCharsetFindOrAddGlyph::@1 [phi:bobCharsetFindOrAddGlyph::@6->bobCharsetFindOrAddGlyph::@1] + // [196] phi (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 = (byte*) bobCharsetFindOrAddGlyph::glyph_cursor#1 [phi:bobCharsetFindOrAddGlyph::@6->bobCharsetFindOrAddGlyph::@1#0] -- register_copy + // [196] phi (byte) bobCharsetFindOrAddGlyph::glyph_id#11 = (byte) bobCharsetFindOrAddGlyph::glyph_id#1 [phi:bobCharsetFindOrAddGlyph::@6->bobCharsetFindOrAddGlyph::@1#1] -- register_copy jmp __b1 // bobCharsetFindOrAddGlyph::@4 __b4: // for(char i=0;i<8;i++) - // [213] (byte) bobCharsetFindOrAddGlyph::i#1 ← ++ (byte) bobCharsetFindOrAddGlyph::i#2 -- vbuz1=_inc_vbuz1 - inc.z i - // [206] phi from bobCharsetFindOrAddGlyph::@4 to bobCharsetFindOrAddGlyph::@2 [phi:bobCharsetFindOrAddGlyph::@4->bobCharsetFindOrAddGlyph::@2] - // [206] phi (byte) bobCharsetFindOrAddGlyph::i#2 = (byte) bobCharsetFindOrAddGlyph::i#1 [phi:bobCharsetFindOrAddGlyph::@4->bobCharsetFindOrAddGlyph::@2#0] -- register_copy + // [212] (byte) bobCharsetFindOrAddGlyph::i#1 ← ++ (byte) bobCharsetFindOrAddGlyph::i#2 -- vbuyy=_inc_vbuyy + iny + // [205] phi from bobCharsetFindOrAddGlyph::@4 to bobCharsetFindOrAddGlyph::@2 [phi:bobCharsetFindOrAddGlyph::@4->bobCharsetFindOrAddGlyph::@2] + // [205] phi (byte) bobCharsetFindOrAddGlyph::i#2 = (byte) bobCharsetFindOrAddGlyph::i#1 [phi:bobCharsetFindOrAddGlyph::@4->bobCharsetFindOrAddGlyph::@2#0] -- register_copy jmp __b2 } // shiftProtoBobRight // Shift PROTO_BOB right one X pixel shiftProtoBobRight: { .label carry = $e - .label i = $b - // [215] phi from shiftProtoBobRight to shiftProtoBobRight::@1 [phi:shiftProtoBobRight->shiftProtoBobRight::@1] - // [215] phi (byte) shiftProtoBobRight::carry#2 = (byte) 0 [phi:shiftProtoBobRight->shiftProtoBobRight::@1#0] -- vbuyy=vbuc1 + .label i = $a + // [214] phi from shiftProtoBobRight to shiftProtoBobRight::@1 [phi:shiftProtoBobRight->shiftProtoBobRight::@1] + // [214] phi (byte) shiftProtoBobRight::carry#2 = (byte) 0 [phi:shiftProtoBobRight->shiftProtoBobRight::@1#0] -- vbuyy=vbuc1 ldy #0 - // [215] phi (byte) shiftProtoBobRight::j#3 = (byte) 0 [phi:shiftProtoBobRight->shiftProtoBobRight::@1#1] -- vbuxx=vbuc1 + // [214] phi (byte) shiftProtoBobRight::j#3 = (byte) 0 [phi:shiftProtoBobRight->shiftProtoBobRight::@1#1] -- vbuxx=vbuc1 ldx #0 - // [215] phi (byte) shiftProtoBobRight::i#2 = (byte) 0 [phi:shiftProtoBobRight->shiftProtoBobRight::@1#2] -- vbuz1=vbuc1 + // [214] phi (byte) shiftProtoBobRight::i#2 = (byte) 0 [phi:shiftProtoBobRight->shiftProtoBobRight::@1#2] -- vbuz1=vbuc1 txa sta.z i // shiftProtoBobRight::@1 __b1: // for(char i=0;i<3*3*8;i++) - // [216] if((byte) shiftProtoBobRight::i#2<(byte)(number) 3*(number) 3*(number) 8) goto shiftProtoBobRight::@2 -- vbuz1_lt_vbuc1_then_la1 + // [215] if((byte) shiftProtoBobRight::i#2<(byte)(number) 3*(number) 3*(number) 8) goto shiftProtoBobRight::@2 -- vbuz1_lt_vbuc1_then_la1 lda.z i cmp #3*3*8 bcc __b2 // shiftProtoBobRight::@return // } - // [217] return + // [216] return rts // shiftProtoBobRight::@2 __b2: // PROTO_BOB[j]&1 - // [218] (byte~) shiftProtoBobRight::$1 ← *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) & (byte) 1 -- vbuaa=pbuc1_derefidx_vbuxx_band_vbuc2 + // [217] (byte~) shiftProtoBobRight::$1 ← *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) & (byte) 1 -- vbuaa=pbuc1_derefidx_vbuxx_band_vbuc2 lda #1 and PROTO_BOB,x // (PROTO_BOB[j]&1)?0x80ub:0ub - // [219] if((byte) 0!=(byte~) shiftProtoBobRight::$1) goto shiftProtoBobRight::@3 -- vbuc1_neq_vbuaa_then_la1 + // [218] if((byte) 0!=(byte~) shiftProtoBobRight::$1) goto shiftProtoBobRight::@3 -- vbuc1_neq_vbuaa_then_la1 cmp #0 bne __b3 - // [221] phi from shiftProtoBobRight::@2 to shiftProtoBobRight::@4 [phi:shiftProtoBobRight::@2->shiftProtoBobRight::@4] - // [221] phi (byte) shiftProtoBobRight::carry#1 = (byte) 0 [phi:shiftProtoBobRight::@2->shiftProtoBobRight::@4#0] -- vbuz1=vbuc1 + // [220] phi from shiftProtoBobRight::@2 to shiftProtoBobRight::@4 [phi:shiftProtoBobRight::@2->shiftProtoBobRight::@4] + // [220] phi (byte) shiftProtoBobRight::carry#1 = (byte) 0 [phi:shiftProtoBobRight::@2->shiftProtoBobRight::@4#0] -- vbuz1=vbuc1 lda #0 sta.z carry jmp __b4 - // [220] phi from shiftProtoBobRight::@2 to shiftProtoBobRight::@3 [phi:shiftProtoBobRight::@2->shiftProtoBobRight::@3] + // [219] phi from shiftProtoBobRight::@2 to shiftProtoBobRight::@3 [phi:shiftProtoBobRight::@2->shiftProtoBobRight::@3] // shiftProtoBobRight::@3 __b3: - // [221] phi from shiftProtoBobRight::@3 to shiftProtoBobRight::@4 [phi:shiftProtoBobRight::@3->shiftProtoBobRight::@4] - // [221] phi (byte) shiftProtoBobRight::carry#1 = (byte) $80 [phi:shiftProtoBobRight::@3->shiftProtoBobRight::@4#0] -- vbuz1=vbuc1 + // [220] phi from shiftProtoBobRight::@3 to shiftProtoBobRight::@4 [phi:shiftProtoBobRight::@3->shiftProtoBobRight::@4] + // [220] phi (byte) shiftProtoBobRight::carry#1 = (byte) $80 [phi:shiftProtoBobRight::@3->shiftProtoBobRight::@4#0] -- vbuz1=vbuc1 lda #$80 sta.z carry // shiftProtoBobRight::@4 __b4: // PROTO_BOB[j]>>1 - // [222] (byte~) shiftProtoBobRight::$5 ← *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) >> (byte) 1 -- vbuaa=pbuc1_derefidx_vbuxx_ror_1 + // [221] (byte~) shiftProtoBobRight::$5 ← *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) >> (byte) 1 -- vbuaa=pbuc1_derefidx_vbuxx_ror_1 lda PROTO_BOB,x lsr // carry | PROTO_BOB[j]>>1 - // [223] (byte~) shiftProtoBobRight::$6 ← (byte) shiftProtoBobRight::carry#2 | (byte~) shiftProtoBobRight::$5 -- vbuaa=vbuyy_bor_vbuaa + // [222] (byte~) shiftProtoBobRight::$6 ← (byte) shiftProtoBobRight::carry#2 | (byte~) shiftProtoBobRight::$5 -- vbuaa=vbuyy_bor_vbuaa sty.z $ff ora.z $ff // PROTO_BOB[j] = carry | PROTO_BOB[j]>>1 - // [224] *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) ← (byte~) shiftProtoBobRight::$6 -- pbuc1_derefidx_vbuxx=vbuaa + // [223] *((const byte*) PROTO_BOB + (byte) shiftProtoBobRight::j#3) ← (byte~) shiftProtoBobRight::$6 -- pbuc1_derefidx_vbuxx=vbuaa // Shift value and add old carry sta PROTO_BOB,x // if(j>=48) - // [225] if((byte) shiftProtoBobRight::j#3>=(byte) $30) goto shiftProtoBobRight::@5 -- vbuxx_ge_vbuc1_then_la1 + // [224] if((byte) shiftProtoBobRight::j#3>=(byte) $30) goto shiftProtoBobRight::@5 -- vbuxx_ge_vbuc1_then_la1 // Increment j to iterate over the PROTO_BOB left-to-right, top-to-bottom (0, 24, 48, 1, 25, 49, ...) cpx #$30 bcs __b5 // shiftProtoBobRight::@7 // j+=24 - // [226] (byte) shiftProtoBobRight::j#2 ← (byte) shiftProtoBobRight::j#3 + (byte) $18 -- vbuxx=vbuxx_plus_vbuc1 + // [225] (byte) shiftProtoBobRight::j#2 ← (byte) shiftProtoBobRight::j#3 + (byte) $18 -- vbuxx=vbuxx_plus_vbuc1 txa axs #-[$18] - // [227] phi from shiftProtoBobRight::@5 shiftProtoBobRight::@7 to shiftProtoBobRight::@6 [phi:shiftProtoBobRight::@5/shiftProtoBobRight::@7->shiftProtoBobRight::@6] - // [227] phi (byte) shiftProtoBobRight::j#10 = (byte) shiftProtoBobRight::j#1 [phi:shiftProtoBobRight::@5/shiftProtoBobRight::@7->shiftProtoBobRight::@6#0] -- register_copy + // [226] phi from shiftProtoBobRight::@5 shiftProtoBobRight::@7 to shiftProtoBobRight::@6 [phi:shiftProtoBobRight::@5/shiftProtoBobRight::@7->shiftProtoBobRight::@6] + // [226] phi (byte) shiftProtoBobRight::j#10 = (byte) shiftProtoBobRight::j#1 [phi:shiftProtoBobRight::@5/shiftProtoBobRight::@7->shiftProtoBobRight::@6#0] -- register_copy // shiftProtoBobRight::@6 __b6: // for(char i=0;i<3*3*8;i++) - // [228] (byte) shiftProtoBobRight::i#1 ← ++ (byte) shiftProtoBobRight::i#2 -- vbuz1=_inc_vbuz1 + // [227] (byte) shiftProtoBobRight::i#1 ← ++ (byte) shiftProtoBobRight::i#2 -- vbuz1=_inc_vbuz1 inc.z i - // [229] (byte) shiftProtoBobRight::carry#10 ← (byte) shiftProtoBobRight::carry#1 -- vbuyy=vbuz1 + // [228] (byte) shiftProtoBobRight::carry#10 ← (byte) shiftProtoBobRight::carry#1 -- vbuyy=vbuz1 ldy.z carry - // [215] phi from shiftProtoBobRight::@6 to shiftProtoBobRight::@1 [phi:shiftProtoBobRight::@6->shiftProtoBobRight::@1] - // [215] phi (byte) shiftProtoBobRight::carry#2 = (byte) shiftProtoBobRight::carry#10 [phi:shiftProtoBobRight::@6->shiftProtoBobRight::@1#0] -- register_copy - // [215] phi (byte) shiftProtoBobRight::j#3 = (byte) shiftProtoBobRight::j#10 [phi:shiftProtoBobRight::@6->shiftProtoBobRight::@1#1] -- register_copy - // [215] phi (byte) shiftProtoBobRight::i#2 = (byte) shiftProtoBobRight::i#1 [phi:shiftProtoBobRight::@6->shiftProtoBobRight::@1#2] -- register_copy + // [214] phi from shiftProtoBobRight::@6 to shiftProtoBobRight::@1 [phi:shiftProtoBobRight::@6->shiftProtoBobRight::@1] + // [214] phi (byte) shiftProtoBobRight::carry#2 = (byte) shiftProtoBobRight::carry#10 [phi:shiftProtoBobRight::@6->shiftProtoBobRight::@1#0] -- register_copy + // [214] phi (byte) shiftProtoBobRight::j#3 = (byte) shiftProtoBobRight::j#10 [phi:shiftProtoBobRight::@6->shiftProtoBobRight::@1#1] -- register_copy + // [214] phi (byte) shiftProtoBobRight::i#2 = (byte) shiftProtoBobRight::i#1 [phi:shiftProtoBobRight::@6->shiftProtoBobRight::@1#2] -- register_copy jmp __b1 // shiftProtoBobRight::@5 __b5: // j-=47 - // [230] (byte) shiftProtoBobRight::j#1 ← (byte) shiftProtoBobRight::j#3 - (byte) $2f -- vbuxx=vbuxx_minus_vbuc1 + // [229] (byte) shiftProtoBobRight::j#1 ← (byte) shiftProtoBobRight::j#3 - (byte) $2f -- vbuxx=vbuxx_minus_vbuc1 txa axs #$2f jmp __b6 @@ -11318,49 +11231,49 @@ shiftProtoBobRight: { // Shift PROTO_BOB down one Y pixel // At the same time restore PROTO_BOB X by shifting 8 pixels left shiftProtoBobDown: { - // [232] phi from shiftProtoBobDown to shiftProtoBobDown::@1 [phi:shiftProtoBobDown->shiftProtoBobDown::@1] - // [232] phi (byte) shiftProtoBobDown::i#2 = (byte) $17 [phi:shiftProtoBobDown->shiftProtoBobDown::@1#0] -- vbuxx=vbuc1 + // [231] phi from shiftProtoBobDown to shiftProtoBobDown::@1 [phi:shiftProtoBobDown->shiftProtoBobDown::@1] + // [231] phi (byte) shiftProtoBobDown::i#2 = (byte) $17 [phi:shiftProtoBobDown->shiftProtoBobDown::@1#0] -- vbuxx=vbuc1 ldx #$17 // shiftProtoBobDown::@1 __b1: // for(char i=23;i>0;i--) - // [233] if((byte) shiftProtoBobDown::i#2>(byte) 0) goto shiftProtoBobDown::@2 -- vbuxx_gt_0_then_la1 + // [232] if((byte) shiftProtoBobDown::i#2>(byte) 0) goto shiftProtoBobDown::@2 -- vbuxx_gt_0_then_la1 cpx #0 bne __b2 // shiftProtoBobDown::@3 // PROTO_BOB[0] = 0 - // [234] *((const byte*) PROTO_BOB) ← (byte) 0 -- _deref_pbuc1=vbuc2 + // [233] *((const byte*) PROTO_BOB) ← (byte) 0 -- _deref_pbuc1=vbuc2 lda #0 sta PROTO_BOB // PROTO_BOB[24] = 0 - // [235] *((const byte*) PROTO_BOB+(byte) $18) ← (byte) 0 -- _deref_pbuc1=vbuc2 + // [234] *((const byte*) PROTO_BOB+(byte) $18) ← (byte) 0 -- _deref_pbuc1=vbuc2 sta PROTO_BOB+$18 // PROTO_BOB[48] = 0 - // [236] *((const byte*) PROTO_BOB+(byte) $30) ← (byte) 0 -- _deref_pbuc1=vbuc2 + // [235] *((const byte*) PROTO_BOB+(byte) $30) ← (byte) 0 -- _deref_pbuc1=vbuc2 sta PROTO_BOB+$30 // shiftProtoBobDown::@return // } - // [237] return + // [236] return rts // shiftProtoBobDown::@2 __b2: // PROTO_BOB[i] = (PROTO_BOB+23)[i] - // [238] *((const byte*) PROTO_BOB + (byte) shiftProtoBobDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $17 + (byte) shiftProtoBobDown::i#2) -- pbuc1_derefidx_vbuxx=pbuc2_derefidx_vbuxx + // [237] *((const byte*) PROTO_BOB + (byte) shiftProtoBobDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $17 + (byte) shiftProtoBobDown::i#2) -- pbuc1_derefidx_vbuxx=pbuc2_derefidx_vbuxx lda PROTO_BOB+$17,x sta PROTO_BOB,x // (PROTO_BOB+24)[i] = (PROTO_BOB+47)[i] - // [239] *((const byte*) PROTO_BOB+(byte) $18 + (byte) shiftProtoBobDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $2f + (byte) shiftProtoBobDown::i#2) -- pbuc1_derefidx_vbuxx=pbuc2_derefidx_vbuxx + // [238] *((const byte*) PROTO_BOB+(byte) $18 + (byte) shiftProtoBobDown::i#2) ← *((const byte*) PROTO_BOB+(byte) $2f + (byte) shiftProtoBobDown::i#2) -- pbuc1_derefidx_vbuxx=pbuc2_derefidx_vbuxx lda PROTO_BOB+$2f,x sta PROTO_BOB+$18,x // (PROTO_BOB+48)[i] = 0x00 - // [240] *((const byte*) PROTO_BOB+(byte) $30 + (byte) shiftProtoBobDown::i#2) ← (byte) 0 -- pbuc1_derefidx_vbuxx=vbuc2 + // [239] *((const byte*) PROTO_BOB+(byte) $30 + (byte) shiftProtoBobDown::i#2) ← (byte) 0 -- pbuc1_derefidx_vbuxx=vbuc2 lda #0 sta PROTO_BOB+$30,x // for(char i=23;i>0;i--) - // [241] (byte) shiftProtoBobDown::i#1 ← -- (byte) shiftProtoBobDown::i#2 -- vbuxx=_dec_vbuxx + // [240] (byte) shiftProtoBobDown::i#1 ← -- (byte) shiftProtoBobDown::i#2 -- vbuxx=_dec_vbuxx dex - // [232] phi from shiftProtoBobDown::@2 to shiftProtoBobDown::@1 [phi:shiftProtoBobDown::@2->shiftProtoBobDown::@1] - // [232] phi (byte) shiftProtoBobDown::i#2 = (byte) shiftProtoBobDown::i#1 [phi:shiftProtoBobDown::@2->shiftProtoBobDown::@1#0] -- register_copy + // [231] phi from shiftProtoBobDown::@2 to shiftProtoBobDown::@1 [phi:shiftProtoBobDown::@2->shiftProtoBobDown::@1] + // [231] phi (byte) shiftProtoBobDown::i#2 = (byte) shiftProtoBobDown::i#1 [phi:shiftProtoBobDown::@2->shiftProtoBobDown::@1#0] -- register_copy jmp __b1 } // progress_init @@ -11368,39 +11281,39 @@ shiftProtoBobDown: { progress_init: { // progress_init::@return // } - // [243] return + // [242] return rts } // mulf_init // Initialize the mulf_sqr multiplication tables with f(x)=int(x*x/4) mulf_init: { // x/2 - .label c = $f + .label c = $d // Counter used for determining x%2==0 - .label sqr1_hi = $10 + .label sqr1_hi = $f // Fill mulf_sqr1 = f(x) = int(x*x/4): If f(x) = x*x/4 then f(x+1) = f(x) + x/2 + 1/4 - .label sqr = $c + .label sqr = $b .label sqr1_lo = 6 // Decrease or increase x_255 - initially we decrease - .label sqr2_hi = 9 - .label sqr2_lo = $12 + .label sqr2_hi = 8 + .label sqr2_lo = $11 //Start with g(0)=f(255) - .label dir = 8 - // [245] phi from mulf_init to mulf_init::@1 [phi:mulf_init->mulf_init::@1] - // [245] phi (byte) mulf_init::x_2#3 = (byte) 0 [phi:mulf_init->mulf_init::@1#0] -- vbuxx=vbuc1 + .label dir = $e + // [244] phi from mulf_init to mulf_init::@1 [phi:mulf_init->mulf_init::@1] + // [244] phi (byte) mulf_init::x_2#3 = (byte) 0 [phi:mulf_init->mulf_init::@1#0] -- vbuxx=vbuc1 ldx #0 - // [245] phi (byte*) mulf_init::sqr1_hi#2 = (const byte*) mulf_sqr1_hi+(byte) 1 [phi:mulf_init->mulf_init::@1#1] -- pbuz1=pbuc1 + // [244] phi (byte*) mulf_init::sqr1_hi#2 = (const byte*) mulf_sqr1_hi+(byte) 1 [phi:mulf_init->mulf_init::@1#1] -- pbuz1=pbuc1 lda #mulf_sqr1_hi+1 sta.z sqr1_hi+1 - // [245] phi (word) mulf_init::sqr#4 = (byte) 0 [phi:mulf_init->mulf_init::@1#2] -- vwuz1=vbuc1 + // [244] phi (word) mulf_init::sqr#4 = (byte) 0 [phi:mulf_init->mulf_init::@1#2] -- vwuz1=vbuc1 txa sta.z sqr sta.z sqr+1 - // [245] phi (byte) mulf_init::c#2 = (byte) 0 [phi:mulf_init->mulf_init::@1#3] -- vbuz1=vbuc1 + // [244] phi (byte) mulf_init::c#2 = (byte) 0 [phi:mulf_init->mulf_init::@1#3] -- vbuz1=vbuc1 sta.z c - // [245] phi (byte*) mulf_init::sqr1_lo#2 = (const byte*) mulf_sqr1_lo+(byte) 1 [phi:mulf_init->mulf_init::@1#4] -- pbuz1=pbuc1 + // [244] phi (byte*) mulf_init::sqr1_lo#2 = (const byte*) mulf_sqr1_lo+(byte) 1 [phi:mulf_init->mulf_init::@1#4] -- pbuz1=pbuc1 lda #mulf_sqr1_lo+1 @@ -11408,25 +11321,25 @@ mulf_init: { // mulf_init::@1 __b1: // for(byte* sqr1_lo = mulf_sqr1_lo+1; sqr1_lo!=mulf_sqr1_lo+512; sqr1_lo++) - // [246] if((byte*) mulf_init::sqr1_lo#2!=(const byte*) mulf_sqr1_lo+(word) $200) goto mulf_init::@2 -- pbuz1_neq_pbuc1_then_la1 + // [245] if((byte*) mulf_init::sqr1_lo#2!=(const byte*) mulf_sqr1_lo+(word) $200) goto mulf_init::@2 -- pbuz1_neq_pbuc1_then_la1 lda.z sqr1_lo+1 cmp #>mulf_sqr1_lo+$200 bne __b2 lda.z sqr1_lo cmp #mulf_init::@5] - // [247] phi (byte) mulf_init::dir#2 = (byte) $ff [phi:mulf_init::@1->mulf_init::@5#0] -- vbuz1=vbuc1 + // [246] phi from mulf_init::@1 to mulf_init::@5 [phi:mulf_init::@1->mulf_init::@5] + // [246] phi (byte) mulf_init::dir#2 = (byte) $ff [phi:mulf_init::@1->mulf_init::@5#0] -- vbuz1=vbuc1 lda #$ff sta.z dir - // [247] phi (byte*) mulf_init::sqr2_hi#2 = (const byte*) mulf_sqr2_hi [phi:mulf_init::@1->mulf_init::@5#1] -- pbuz1=pbuc1 + // [246] phi (byte*) mulf_init::sqr2_hi#2 = (const byte*) mulf_sqr2_hi [phi:mulf_init::@1->mulf_init::@5#1] -- pbuz1=pbuc1 lda #mulf_sqr2_hi sta.z sqr2_hi+1 - // [247] phi (byte) mulf_init::x_255#2 = (byte) -1 [phi:mulf_init::@1->mulf_init::@5#2] -- vbuxx=vbuc1 + // [246] phi (byte) mulf_init::x_255#2 = (byte) -1 [phi:mulf_init::@1->mulf_init::@5#2] -- vbuxx=vbuc1 ldx #-1 - // [247] phi (byte*) mulf_init::sqr2_lo#2 = (const byte*) mulf_sqr2_lo [phi:mulf_init::@1->mulf_init::@5#3] -- pbuz1=pbuc1 + // [246] phi (byte*) mulf_init::sqr2_lo#2 = (const byte*) mulf_sqr2_lo [phi:mulf_init::@1->mulf_init::@5#3] -- pbuz1=pbuc1 lda #mulf_sqr2_lo @@ -11434,7 +11347,7 @@ mulf_init: { // mulf_init::@5 __b5: // for(byte* sqr2_lo = mulf_sqr2_lo; sqr2_lo!=mulf_sqr2_lo+511; sqr2_lo++) - // [248] if((byte*) mulf_init::sqr2_lo#2!=(const byte*) mulf_sqr2_lo+(word) $1ff) goto mulf_init::@6 -- pbuz1_neq_pbuc1_then_la1 + // [247] if((byte*) mulf_init::sqr2_lo#2!=(const byte*) mulf_sqr2_lo+(word) $1ff) goto mulf_init::@6 -- pbuz1_neq_pbuc1_then_la1 lda.z sqr2_lo+1 cmp #>mulf_sqr2_lo+$1ff bne __b6 @@ -11443,116 +11356,116 @@ mulf_init: { bne __b6 // mulf_init::@7 // *(mulf_sqr2_lo+511) = *(mulf_sqr1_lo+256) - // [249] *((const byte*) mulf_sqr2_lo+(word) $1ff) ← *((const byte*) mulf_sqr1_lo+(word) $100) -- _deref_pbuc1=_deref_pbuc2 + // [248] *((const byte*) mulf_sqr2_lo+(word) $1ff) ← *((const byte*) mulf_sqr1_lo+(word) $100) -- _deref_pbuc1=_deref_pbuc2 // Set the very last value g(511) = f(256) lda mulf_sqr1_lo+$100 sta mulf_sqr2_lo+$1ff // *(mulf_sqr2_hi+511) = *(mulf_sqr1_hi+256) - // [250] *((const byte*) mulf_sqr2_hi+(word) $1ff) ← *((const byte*) mulf_sqr1_hi+(word) $100) -- _deref_pbuc1=_deref_pbuc2 + // [249] *((const byte*) mulf_sqr2_hi+(word) $1ff) ← *((const byte*) mulf_sqr1_hi+(word) $100) -- _deref_pbuc1=_deref_pbuc2 lda mulf_sqr1_hi+$100 sta mulf_sqr2_hi+$1ff // mulf_init::@return // } - // [251] return + // [250] return rts // mulf_init::@6 __b6: // *sqr2_lo = mulf_sqr1_lo[x_255] - // [252] *((byte*) mulf_init::sqr2_lo#2) ← *((const byte*) mulf_sqr1_lo + (byte) mulf_init::x_255#2) -- _deref_pbuz1=pbuc1_derefidx_vbuxx + // [251] *((byte*) mulf_init::sqr2_lo#2) ← *((const byte*) mulf_sqr1_lo + (byte) mulf_init::x_255#2) -- _deref_pbuz1=pbuc1_derefidx_vbuxx lda mulf_sqr1_lo,x ldy #0 sta (sqr2_lo),y // *sqr2_hi++ = mulf_sqr1_hi[x_255] - // [253] *((byte*) mulf_init::sqr2_hi#2) ← *((const byte*) mulf_sqr1_hi + (byte) mulf_init::x_255#2) -- _deref_pbuz1=pbuc1_derefidx_vbuxx + // [252] *((byte*) mulf_init::sqr2_hi#2) ← *((const byte*) mulf_sqr1_hi + (byte) mulf_init::x_255#2) -- _deref_pbuz1=pbuc1_derefidx_vbuxx lda mulf_sqr1_hi,x sta (sqr2_hi),y // *sqr2_hi++ = mulf_sqr1_hi[x_255]; - // [254] (byte*) mulf_init::sqr2_hi#1 ← ++ (byte*) mulf_init::sqr2_hi#2 -- pbuz1=_inc_pbuz1 + // [253] (byte*) mulf_init::sqr2_hi#1 ← ++ (byte*) mulf_init::sqr2_hi#2 -- pbuz1=_inc_pbuz1 inc.z sqr2_hi bne !+ inc.z sqr2_hi+1 !: // x_255 = x_255 + dir - // [255] (byte) mulf_init::x_255#1 ← (byte) mulf_init::x_255#2 + (byte) mulf_init::dir#2 -- vbuxx=vbuxx_plus_vbuz1 + // [254] (byte) mulf_init::x_255#1 ← (byte) mulf_init::x_255#2 + (byte) mulf_init::dir#2 -- vbuxx=vbuxx_plus_vbuz1 txa clc adc.z dir tax // if(x_255==0) - // [256] if((byte) mulf_init::x_255#1!=(byte) 0) goto mulf_init::@9 -- vbuxx_neq_0_then_la1 + // [255] if((byte) mulf_init::x_255#1!=(byte) 0) goto mulf_init::@9 -- vbuxx_neq_0_then_la1 cpx #0 bne __b8 - // [258] phi from mulf_init::@6 to mulf_init::@8 [phi:mulf_init::@6->mulf_init::@8] - // [258] phi (byte) mulf_init::dir#4 = (byte) 1 [phi:mulf_init::@6->mulf_init::@8#0] -- vbuz1=vbuc1 + // [257] phi from mulf_init::@6 to mulf_init::@8 [phi:mulf_init::@6->mulf_init::@8] + // [257] phi (byte) mulf_init::dir#4 = (byte) 1 [phi:mulf_init::@6->mulf_init::@8#0] -- vbuz1=vbuc1 lda #1 sta.z dir - // [257] phi from mulf_init::@6 to mulf_init::@9 [phi:mulf_init::@6->mulf_init::@9] + // [256] phi from mulf_init::@6 to mulf_init::@9 [phi:mulf_init::@6->mulf_init::@9] // mulf_init::@9 - // [258] phi from mulf_init::@9 to mulf_init::@8 [phi:mulf_init::@9->mulf_init::@8] - // [258] phi (byte) mulf_init::dir#4 = (byte) mulf_init::dir#2 [phi:mulf_init::@9->mulf_init::@8#0] -- register_copy + // [257] phi from mulf_init::@9 to mulf_init::@8 [phi:mulf_init::@9->mulf_init::@8] + // [257] phi (byte) mulf_init::dir#4 = (byte) mulf_init::dir#2 [phi:mulf_init::@9->mulf_init::@8#0] -- register_copy // mulf_init::@8 __b8: // for(byte* sqr2_lo = mulf_sqr2_lo; sqr2_lo!=mulf_sqr2_lo+511; sqr2_lo++) - // [259] (byte*) mulf_init::sqr2_lo#1 ← ++ (byte*) mulf_init::sqr2_lo#2 -- pbuz1=_inc_pbuz1 + // [258] (byte*) mulf_init::sqr2_lo#1 ← ++ (byte*) mulf_init::sqr2_lo#2 -- pbuz1=_inc_pbuz1 inc.z sqr2_lo bne !+ inc.z sqr2_lo+1 !: - // [247] phi from mulf_init::@8 to mulf_init::@5 [phi:mulf_init::@8->mulf_init::@5] - // [247] phi (byte) mulf_init::dir#2 = (byte) mulf_init::dir#4 [phi:mulf_init::@8->mulf_init::@5#0] -- register_copy - // [247] phi (byte*) mulf_init::sqr2_hi#2 = (byte*) mulf_init::sqr2_hi#1 [phi:mulf_init::@8->mulf_init::@5#1] -- register_copy - // [247] phi (byte) mulf_init::x_255#2 = (byte) mulf_init::x_255#1 [phi:mulf_init::@8->mulf_init::@5#2] -- register_copy - // [247] phi (byte*) mulf_init::sqr2_lo#2 = (byte*) mulf_init::sqr2_lo#1 [phi:mulf_init::@8->mulf_init::@5#3] -- register_copy + // [246] phi from mulf_init::@8 to mulf_init::@5 [phi:mulf_init::@8->mulf_init::@5] + // [246] phi (byte) mulf_init::dir#2 = (byte) mulf_init::dir#4 [phi:mulf_init::@8->mulf_init::@5#0] -- register_copy + // [246] phi (byte*) mulf_init::sqr2_hi#2 = (byte*) mulf_init::sqr2_hi#1 [phi:mulf_init::@8->mulf_init::@5#1] -- register_copy + // [246] phi (byte) mulf_init::x_255#2 = (byte) mulf_init::x_255#1 [phi:mulf_init::@8->mulf_init::@5#2] -- register_copy + // [246] phi (byte*) mulf_init::sqr2_lo#2 = (byte*) mulf_init::sqr2_lo#1 [phi:mulf_init::@8->mulf_init::@5#3] -- register_copy jmp __b5 // mulf_init::@2 __b2: // if((++c&1)==0) - // [260] (byte) mulf_init::c#1 ← ++ (byte) mulf_init::c#2 -- vbuz1=_inc_vbuz1 + // [259] (byte) mulf_init::c#1 ← ++ (byte) mulf_init::c#2 -- vbuz1=_inc_vbuz1 inc.z c // ++c&1 - // [261] (byte~) mulf_init::$1 ← (byte) mulf_init::c#1 & (byte) 1 -- vbuaa=vbuz1_band_vbuc1 + // [260] (byte~) mulf_init::$1 ← (byte) mulf_init::c#1 & (byte) 1 -- vbuaa=vbuz1_band_vbuc1 lda #1 and.z c // if((++c&1)==0) - // [262] if((byte~) mulf_init::$1!=(byte) 0) goto mulf_init::@3 -- vbuaa_neq_0_then_la1 + // [261] if((byte~) mulf_init::$1!=(byte) 0) goto mulf_init::@3 -- vbuaa_neq_0_then_la1 cmp #0 bne __b3 // mulf_init::@4 // x_2++; - // [263] (byte) mulf_init::x_2#1 ← ++ (byte) mulf_init::x_2#3 -- vbuxx=_inc_vbuxx + // [262] (byte) mulf_init::x_2#1 ← ++ (byte) mulf_init::x_2#3 -- vbuxx=_inc_vbuxx inx // sqr++; - // [264] (word) mulf_init::sqr#2 ← ++ (word) mulf_init::sqr#4 -- vwuz1=_inc_vwuz1 + // [263] (word) mulf_init::sqr#2 ← ++ (word) mulf_init::sqr#4 -- vwuz1=_inc_vwuz1 inc.z sqr bne !+ inc.z sqr+1 !: - // [265] phi from mulf_init::@2 mulf_init::@4 to mulf_init::@3 [phi:mulf_init::@2/mulf_init::@4->mulf_init::@3] - // [265] phi (byte) mulf_init::x_2#2 = (byte) mulf_init::x_2#3 [phi:mulf_init::@2/mulf_init::@4->mulf_init::@3#0] -- register_copy - // [265] phi (word) mulf_init::sqr#3 = (word) mulf_init::sqr#4 [phi:mulf_init::@2/mulf_init::@4->mulf_init::@3#1] -- register_copy + // [264] phi from mulf_init::@2 mulf_init::@4 to mulf_init::@3 [phi:mulf_init::@2/mulf_init::@4->mulf_init::@3] + // [264] phi (byte) mulf_init::x_2#2 = (byte) mulf_init::x_2#3 [phi:mulf_init::@2/mulf_init::@4->mulf_init::@3#0] -- register_copy + // [264] phi (word) mulf_init::sqr#3 = (word) mulf_init::sqr#4 [phi:mulf_init::@2/mulf_init::@4->mulf_init::@3#1] -- register_copy // mulf_init::@3 __b3: // sqr - // [268] (byte~) mulf_init::$5 ← > (word) mulf_init::sqr#3 -- vbuaa=_hi_vwuz1 + // [267] (byte~) mulf_init::$5 ← > (word) mulf_init::sqr#3 -- vbuaa=_hi_vwuz1 lda.z sqr+1 // *sqr1_hi++ = >sqr - // [269] *((byte*) mulf_init::sqr1_hi#2) ← (byte~) mulf_init::$5 -- _deref_pbuz1=vbuaa + // [268] *((byte*) mulf_init::sqr1_hi#2) ← (byte~) mulf_init::$5 -- _deref_pbuz1=vbuaa sta (sqr1_hi),y // *sqr1_hi++ = >sqr; - // [270] (byte*) mulf_init::sqr1_hi#1 ← ++ (byte*) mulf_init::sqr1_hi#2 -- pbuz1=_inc_pbuz1 + // [269] (byte*) mulf_init::sqr1_hi#1 ← ++ (byte*) mulf_init::sqr1_hi#2 -- pbuz1=_inc_pbuz1 inc.z sqr1_hi bne !+ inc.z sqr1_hi+1 !: // sqr = sqr + x_2 - // [271] (word) mulf_init::sqr#1 ← (word) mulf_init::sqr#3 + (byte) mulf_init::x_2#2 -- vwuz1=vwuz1_plus_vbuxx + // [270] (word) mulf_init::sqr#1 ← (word) mulf_init::sqr#3 + (byte) mulf_init::x_2#2 -- vwuz1=vwuz1_plus_vbuxx txa clc adc.z sqr @@ -11561,17 +11474,17 @@ mulf_init: { inc.z sqr+1 !: // for(byte* sqr1_lo = mulf_sqr1_lo+1; sqr1_lo!=mulf_sqr1_lo+512; sqr1_lo++) - // [272] (byte*) mulf_init::sqr1_lo#1 ← ++ (byte*) mulf_init::sqr1_lo#2 -- pbuz1=_inc_pbuz1 + // [271] (byte*) mulf_init::sqr1_lo#1 ← ++ (byte*) mulf_init::sqr1_lo#2 -- pbuz1=_inc_pbuz1 inc.z sqr1_lo bne !+ inc.z sqr1_lo+1 !: - // [245] phi from mulf_init::@3 to mulf_init::@1 [phi:mulf_init::@3->mulf_init::@1] - // [245] phi (byte) mulf_init::x_2#3 = (byte) mulf_init::x_2#2 [phi:mulf_init::@3->mulf_init::@1#0] -- register_copy - // [245] phi (byte*) mulf_init::sqr1_hi#2 = (byte*) mulf_init::sqr1_hi#1 [phi:mulf_init::@3->mulf_init::@1#1] -- register_copy - // [245] phi (word) mulf_init::sqr#4 = (word) mulf_init::sqr#1 [phi:mulf_init::@3->mulf_init::@1#2] -- register_copy - // [245] phi (byte) mulf_init::c#2 = (byte) mulf_init::c#1 [phi:mulf_init::@3->mulf_init::@1#3] -- register_copy - // [245] phi (byte*) mulf_init::sqr1_lo#2 = (byte*) mulf_init::sqr1_lo#1 [phi:mulf_init::@3->mulf_init::@1#4] -- register_copy + // [244] phi from mulf_init::@3 to mulf_init::@1 [phi:mulf_init::@3->mulf_init::@1] + // [244] phi (byte) mulf_init::x_2#3 = (byte) mulf_init::x_2#2 [phi:mulf_init::@3->mulf_init::@1#0] -- register_copy + // [244] phi (byte*) mulf_init::sqr1_hi#2 = (byte*) mulf_init::sqr1_hi#1 [phi:mulf_init::@3->mulf_init::@1#1] -- register_copy + // [244] phi (word) mulf_init::sqr#4 = (word) mulf_init::sqr#1 [phi:mulf_init::@3->mulf_init::@1#2] -- register_copy + // [244] phi (byte) mulf_init::c#2 = (byte) mulf_init::c#1 [phi:mulf_init::@3->mulf_init::@1#3] -- register_copy + // [244] phi (byte*) mulf_init::sqr1_lo#2 = (byte*) mulf_init::sqr1_lo#1 [phi:mulf_init::@3->mulf_init::@1#4] -- register_copy jmp __b1 } // File Data diff --git a/src/test/ref/complex/prebob/vogel-bobs.sym b/src/test/ref/complex/prebob/vogel-bobs.sym index 2b194f0cf..a9f318f62 100644 --- a/src/test/ref/complex/prebob/vogel-bobs.sym +++ b/src/test/ref/complex/prebob/vogel-bobs.sym @@ -1,5 +1,4 @@ (label) @1 -(label) @2 (label) @begin (label) @end (const byte*) BOB_CHARSET = (byte*) 8192 @@ -52,26 +51,26 @@ (byte) bobCharsetFindOrAddGlyph::found (byte) bobCharsetFindOrAddGlyph::found#2 reg byte a 10001.0 (byte*) bobCharsetFindOrAddGlyph::glyph_cursor -(byte*) bobCharsetFindOrAddGlyph::glyph_cursor#1 glyph_cursor zp[2]:18 20002.0 -(byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 glyph_cursor zp[2]:18 10000.307692307691 +(byte*) bobCharsetFindOrAddGlyph::glyph_cursor#1 glyph_cursor zp[2]:17 20002.0 +(byte*) bobCharsetFindOrAddGlyph::glyph_cursor#11 glyph_cursor zp[2]:17 10000.307692307691 (byte) bobCharsetFindOrAddGlyph::glyph_id -(byte) bobCharsetFindOrAddGlyph::glyph_id#1 glyph_id zp[1]:14 10001.0 -(byte) bobCharsetFindOrAddGlyph::glyph_id#11 glyph_id zp[1]:14 1937.75 +(byte) bobCharsetFindOrAddGlyph::glyph_id#1 reg byte x 10001.0 +(byte) bobCharsetFindOrAddGlyph::glyph_id#11 reg byte x 1937.75 (byte) bobCharsetFindOrAddGlyph::i -(byte) bobCharsetFindOrAddGlyph::i#1 i zp[1]:8 200002.0 -(byte) bobCharsetFindOrAddGlyph::i#2 i zp[1]:8 166668.3333333333 +(byte) bobCharsetFindOrAddGlyph::i#1 reg byte y 200002.0 +(byte) bobCharsetFindOrAddGlyph::i#2 reg byte y 166668.3333333333 (byte) bobCharsetFindOrAddGlyph::i1 (byte) bobCharsetFindOrAddGlyph::i1#1 reg byte y 20002.0 (byte) bobCharsetFindOrAddGlyph::i1#2 reg byte y 16668.333333333332 (byte) bobCharsetFindOrAddGlyph::return (byte) bobCharsetFindOrAddGlyph::return#1 reg byte a 2002.0 (byte) bob_charset_next_id -(byte) bob_charset_next_id#14 bob_charset_next_id zp[1]:15 12.0 -(byte) bob_charset_next_id#16 bob_charset_next_id zp[1]:15 1000.5454545454544 -(byte) bob_charset_next_id#21 bob_charset_next_id zp[1]:15 275.5 -(byte) bob_charset_next_id#23 bob_charset_next_id zp[1]:15 1400.3333333333335 -(byte) bob_charset_next_id#30 bob_charset_next_id zp[1]:15 37.33333333333333 -(byte) bob_charset_next_id#8 bob_charset_next_id zp[1]:15 4.0 +(byte) bob_charset_next_id#14 bob_charset_next_id zp[1]:13 12.0 +(byte) bob_charset_next_id#16 bob_charset_next_id zp[1]:13 1000.5454545454544 +(byte) bob_charset_next_id#21 bob_charset_next_id zp[1]:13 275.5 +(byte) bob_charset_next_id#23 bob_charset_next_id zp[1]:13 1400.3333333333335 +(byte) bob_charset_next_id#30 bob_charset_next_id zp[1]:13 37.33333333333333 +(byte) bob_charset_next_id#8 bob_charset_next_id zp[1]:13 4.0 (byte()) keyboard_key_pressed((byte) keyboard_key_pressed::key) (byte~) keyboard_key_pressed::$2 reg byte a 4.0 (label) keyboard_key_pressed::@1 @@ -95,9 +94,9 @@ (byte) keyboard_matrix_read::rowid (const byte*) keyboard_matrix_row_bitmask = { (byte) $fe, (byte) $fd, (byte) $fb, (byte) $f7, (byte) $ef, (byte) $df, (byte) $bf, (byte) $7f } (void()) main() -(signed word~) main::$10 zp[2]:12 202.0 -(signed word~) main::$12 zp[2]:12 202.0 -(signed word~) main::$13 zp[2]:12 202.0 +(signed word~) main::$10 zp[2]:11 202.0 +(signed word~) main::$12 zp[2]:11 202.0 +(signed word~) main::$13 zp[2]:11 202.0 (byte~) main::$19 reg byte a 22.0 (byte~) main::$21 reg byte a 22.0 (label) main::@1 @@ -155,9 +154,9 @@ (byte) main::vicSelectGfxBank2_toDd001_return (const byte) main::vicSelectGfxBank2_toDd001_return#0 vicSelectGfxBank2_toDd001_return = (byte) 3 (signed word) main::x -(signed word) main::x#0 x zp[2]:9 18.363636363636363 +(signed word) main::x#0 x zp[2]:8 18.363636363636363 (signed word) main::y -(signed word) main::y#0 y zp[2]:12 40.4 +(signed word) main::y#0 y zp[2]:11 40.4 (void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num) (label) memset::@1 (label) memset::@2 @@ -189,9 +188,9 @@ (signed byte) mulf8s::mulf8s_prepare1_a (signed byte) mulf8s::mulf8s_prepare1_a#0 reg byte a 202.0 (signed word) mulf8s::return -(signed word) mulf8s::return#0 return zp[2]:12 51.0 -(signed word) mulf8s::return#2 return zp[2]:12 202.0 -(signed word) mulf8s::return#3 return zp[2]:12 202.0 +(signed word) mulf8s::return#0 return zp[2]:11 51.0 +(signed word) mulf8s::return#2 return zp[2]:11 202.0 +(signed word) mulf8s::return#3 return zp[2]:11 202.0 (signed word()) mulf8s_prepared((signed byte) mulf8s_prepared::b) (byte~) mulf8s_prepared::$12 reg byte a 4.0 (byte~) mulf8s_prepared::$15 reg byte a 4.0 @@ -204,13 +203,13 @@ (label) mulf8s_prepared::@5 (label) mulf8s_prepared::@return (signed byte) mulf8s_prepared::b -(signed byte) mulf8s_prepared::b#0 b zp[1]:15 0.4 +(signed byte) mulf8s_prepared::b#0 b zp[1]:14 0.4 (word) mulf8s_prepared::m -(word) mulf8s_prepared::m#0 m zp[2]:12 2.0 -(word) mulf8s_prepared::m#1 m zp[2]:12 4.0 -(word) mulf8s_prepared::m#2 m zp[2]:12 4.0 -(word) mulf8s_prepared::m#4 m zp[2]:12 1.3333333333333333 -(word) mulf8s_prepared::m#5 m zp[2]:12 2.5 +(word) mulf8s_prepared::m#0 m zp[2]:11 2.0 +(word) mulf8s_prepared::m#1 m zp[2]:11 4.0 +(word) mulf8s_prepared::m#2 m zp[2]:11 4.0 +(word) mulf8s_prepared::m#4 m zp[2]:11 1.3333333333333333 +(word) mulf8s_prepared::m#5 m zp[2]:11 2.5 (const signed byte*) mulf8s_prepared::memA = (signed byte*) 253 (signed word) mulf8s_prepared::return (void()) mulf8u_prepare((byte) mulf8u_prepare::a) @@ -225,8 +224,8 @@ (const byte*) mulf8u_prepared::memB = (byte*) 255 (const byte*) mulf8u_prepared::resL = (byte*) 254 (word) mulf8u_prepared::return -(word) mulf8u_prepared::return#0 return zp[2]:12 1.3333333333333333 -(word) mulf8u_prepared::return#2 return zp[2]:12 4.0 +(word) mulf8u_prepared::return#0 return zp[2]:11 1.3333333333333333 +(word) mulf8u_prepared::return#2 return zp[2]:11 4.0 (void()) mulf_init() (byte~) mulf_init::$1 reg byte a 22.0 (byte~) mulf_init::$4 reg byte a 22.0 @@ -242,28 +241,28 @@ (label) mulf_init::@9 (label) mulf_init::@return (byte) mulf_init::c -(byte) mulf_init::c#1 c zp[1]:15 2.5384615384615383 -(byte) mulf_init::c#2 c zp[1]:15 11.0 +(byte) mulf_init::c#1 c zp[1]:13 2.5384615384615383 +(byte) mulf_init::c#2 c zp[1]:13 11.0 (byte) mulf_init::dir -(byte) mulf_init::dir#2 dir zp[1]:8 4.125 -(byte) mulf_init::dir#4 dir zp[1]:8 11.0 +(byte) mulf_init::dir#2 dir zp[1]:14 4.125 +(byte) mulf_init::dir#4 dir zp[1]:14 11.0 (word) mulf_init::sqr -(word) mulf_init::sqr#1 sqr zp[2]:12 11.0 -(word) mulf_init::sqr#2 sqr zp[2]:12 22.0 -(word) mulf_init::sqr#3 sqr zp[2]:12 9.166666666666666 -(word) mulf_init::sqr#4 sqr zp[2]:12 5.5 +(word) mulf_init::sqr#1 sqr zp[2]:11 11.0 +(word) mulf_init::sqr#2 sqr zp[2]:11 22.0 +(word) mulf_init::sqr#3 sqr zp[2]:11 9.166666666666666 +(word) mulf_init::sqr#4 sqr zp[2]:11 5.5 (byte*) mulf_init::sqr1_hi -(byte*) mulf_init::sqr1_hi#1 sqr1_hi zp[2]:16 7.333333333333333 -(byte*) mulf_init::sqr1_hi#2 sqr1_hi zp[2]:16 2.75 +(byte*) mulf_init::sqr1_hi#1 sqr1_hi zp[2]:15 7.333333333333333 +(byte*) mulf_init::sqr1_hi#2 sqr1_hi zp[2]:15 2.75 (byte*) mulf_init::sqr1_lo (byte*) mulf_init::sqr1_lo#1 sqr1_lo zp[2]:6 22.0 (byte*) mulf_init::sqr1_lo#2 sqr1_lo zp[2]:6 3.142857142857143 (byte*) mulf_init::sqr2_hi -(byte*) mulf_init::sqr2_hi#1 sqr2_hi zp[2]:9 3.6666666666666665 -(byte*) mulf_init::sqr2_hi#2 sqr2_hi zp[2]:9 8.25 +(byte*) mulf_init::sqr2_hi#1 sqr2_hi zp[2]:8 3.6666666666666665 +(byte*) mulf_init::sqr2_hi#2 sqr2_hi zp[2]:8 8.25 (byte*) mulf_init::sqr2_lo -(byte*) mulf_init::sqr2_lo#1 sqr2_lo zp[2]:18 22.0 -(byte*) mulf_init::sqr2_lo#2 sqr2_lo zp[2]:18 4.888888888888889 +(byte*) mulf_init::sqr2_lo#1 sqr2_lo zp[2]:17 22.0 +(byte*) mulf_init::sqr2_lo#2 sqr2_lo zp[2]:17 4.888888888888889 (byte) mulf_init::x_2 (byte) mulf_init::x_2#1 reg byte x 11.0 (byte) mulf_init::x_2#2 reg byte x 5.5 @@ -295,16 +294,16 @@ (byte*) prepareBobs::bob_glyph#1 bob_glyph zp[2]:6 500.5 (byte*) prepareBobs::bob_glyph#2 bob_glyph zp[2]:6 429.0 (byte*) prepareBobs::bob_table -(byte*) prepareBobs::bob_table#0 bob_table zp[2]:16 202.0 -(byte*) prepareBobs::bob_table#1 bob_table zp[2]:16 667.3333333333334 -(byte*) prepareBobs::bob_table#2 bob_table zp[2]:16 388.0 +(byte*) prepareBobs::bob_table#0 bob_table zp[2]:15 202.0 +(byte*) prepareBobs::bob_table#1 bob_table zp[2]:15 667.3333333333334 +(byte*) prepareBobs::bob_table#2 bob_table zp[2]:15 388.0 (byte) prepareBobs::bob_table_idx (byte) prepareBobs::bob_table_idx#1 bob_table_idx zp[1]:4 40.4 (byte) prepareBobs::bob_table_idx#12 bob_table_idx zp[1]:4 19.11764705882353 (byte) prepareBobs::bob_table_idx#6 bob_table_idx zp[1]:4 11.0 (byte) prepareBobs::cell -(byte) prepareBobs::cell#1 cell zp[1]:11 2002.0 -(byte) prepareBobs::cell#2 cell zp[1]:11 300.29999999999995 +(byte) prepareBobs::cell#1 cell zp[1]:10 2002.0 +(byte) prepareBobs::cell#2 cell zp[1]:10 300.29999999999995 (byte) prepareBobs::shift_x (byte) prepareBobs::shift_x#1 shift_x zp[1]:5 202.0 (byte) prepareBobs::shift_x#2 shift_x zp[1]:5 16.833333333333332 @@ -312,11 +311,11 @@ (byte) prepareBobs::shift_y#1 shift_y zp[1]:2 22.0 (byte) prepareBobs::shift_y#2 shift_y zp[1]:2 1.4347826086956523 (byte*) progress_cursor -(byte*) progress_cursor#15 progress_cursor zp[2]:12 11.0 -(byte*) progress_cursor#17 progress_cursor zp[2]:12 201.4 -(byte*) progress_cursor#24 progress_cursor zp[2]:12 71.11764705882355 -(byte*) progress_cursor#31 progress_cursor zp[2]:12 37.33333333333333 -(byte*) progress_cursor#8 progress_cursor zp[2]:12 4.0 +(byte*) progress_cursor#15 progress_cursor zp[2]:11 11.0 +(byte*) progress_cursor#17 progress_cursor zp[2]:11 201.4 +(byte*) progress_cursor#24 progress_cursor zp[2]:11 71.11764705882355 +(byte*) progress_cursor#31 progress_cursor zp[2]:11 37.33333333333333 +(byte*) progress_cursor#8 progress_cursor zp[2]:11 4.0 (byte) progress_idx (byte) progress_idx#10 progress_idx zp[1]:3 201.0 (byte) progress_idx#16 progress_idx zp[1]:3 11.0 @@ -332,24 +331,24 @@ (label) progress_init::@return (byte*) progress_init::line (void()) renderBob((byte) renderBob::xpos , (byte) renderBob::ypos) -(byte*~) renderBob::$2 zp[2]:12 4.0 +(byte*~) renderBob::$2 zp[2]:11 4.0 (byte~) renderBob::$4 reg byte a 4.0 -(byte~) renderBob::$5 zp[1]:14 2.0 +(byte~) renderBob::$5 zp[1]:13 2.0 (byte~) renderBob::$6 reg byte a 4.0 (byte~) renderBob::$8 reg byte a 4.0 (label) renderBob::@return (byte) renderBob::bob_table_idx (byte) renderBob::bob_table_idx#0 reg byte x 1.8181818181818186 (byte*) renderBob::screen -(byte*) renderBob::screen#0 screen zp[2]:12 1.4666666666666666 +(byte*) renderBob::screen#0 screen zp[2]:11 1.4666666666666666 (byte) renderBob::x_char_offset -(byte) renderBob::x_char_offset#0 x_char_offset zp[1]:11 0.8 +(byte) renderBob::x_char_offset#0 x_char_offset zp[1]:10 0.8 (byte) renderBob::xpos -(byte) renderBob::xpos#0 xpos zp[1]:15 10.499999999999998 +(byte) renderBob::xpos#0 xpos zp[1]:14 10.499999999999998 (byte) renderBob::y_char_offset (byte) renderBob::y_char_offset#0 reg byte a 4.0 (word) renderBob::y_offset -(word) renderBob::y_offset#0 y_offset zp[2]:12 4.0 +(word) renderBob::y_offset#0 y_offset zp[2]:11 4.0 (byte) renderBob::ypos (byte) renderBob::ypos#0 reg byte x 15.000000000000002 (void()) renderBobCleanup() @@ -360,17 +359,17 @@ (byte) renderBobCleanup::i#1 reg byte x 151.5 (byte) renderBobCleanup::i#2 reg byte x 25.25 (byte*) renderBobCleanup::screen -(byte*) renderBobCleanup::screen#0 screen zp[2]:16 112.22222222222223 +(byte*) renderBobCleanup::screen#0 screen zp[2]:15 112.22222222222223 (byte**) renderBobCleanupNext (byte**) renderBobCleanupNext#13 renderBobCleanupNext zp[2]:6 7.357142857142858 (byte**) renderBobCleanupNext#17 renderBobCleanupNext zp[2]:6 3.3870967741935485 (void()) renderBobInit() -(word~) renderBobInit::$0 zp[2]:16 16.5 -(word~) renderBobInit::$1 zp[2]:16 11.0 +(word~) renderBobInit::$0 zp[2]:15 16.5 +(word~) renderBobInit::$1 zp[2]:15 11.0 (byte~) renderBobInit::$4 reg byte a 22.0 (byte~) renderBobInit::$5 reg byte a 22.0 -(word~) renderBobInit::$6 zp[2]:18 22.0 -(word~) renderBobInit::$7 zp[2]:16 22.0 +(word~) renderBobInit::$6 zp[2]:17 22.0 +(word~) renderBobInit::$7 zp[2]:15 22.0 (label) renderBobInit::@1 (label) renderBobInit::@2 (label) renderBobInit::@return @@ -405,8 +404,8 @@ (byte) shiftProtoBobRight::carry#10 reg byte y 2002.0 (byte) shiftProtoBobRight::carry#2 reg byte y 286.0 (byte) shiftProtoBobRight::i -(byte) shiftProtoBobRight::i#1 i zp[1]:11 1001.0 -(byte) shiftProtoBobRight::i#2 i zp[1]:11 231.0 +(byte) shiftProtoBobRight::i#1 i zp[1]:10 1001.0 +(byte) shiftProtoBobRight::i#2 i zp[1]:10 231.0 (byte) shiftProtoBobRight::j (byte) shiftProtoBobRight::j#1 reg byte x 2002.0 (byte) shiftProtoBobRight::j#10 reg byte x 1001.0 @@ -423,7 +422,9 @@ zp[1]:2 [ prepareBobs::shift_y#2 prepareBobs::shift_y#1 main::angle#8 main::angl zp[1]:3 [ progress_idx#16 progress_idx#31 progress_idx#25 progress_idx#10 progress_idx#8 main::r#2 main::r#1 ] zp[1]:4 [ prepareBobs::bob_table_idx#6 prepareBobs::bob_table_idx#12 prepareBobs::bob_table_idx#1 main::a#2 main::a#6 main::a#1 ] zp[1]:5 [ prepareBobs::shift_x#2 prepareBobs::shift_x#1 main::i#2 main::i#1 ] +reg byte x [ bobCharsetFindOrAddGlyph::glyph_id#11 bobCharsetFindOrAddGlyph::glyph_id#1 ] reg byte y [ bobCharsetFindOrAddGlyph::i1#2 bobCharsetFindOrAddGlyph::i1#1 ] +reg byte y [ bobCharsetFindOrAddGlyph::i#2 bobCharsetFindOrAddGlyph::i#1 ] reg byte a [ bobCharsetFindOrAddGlyph::found#2 ] reg byte x [ shiftProtoBobRight::j#3 shiftProtoBobRight::j#10 shiftProtoBobRight::j#2 shiftProtoBobRight::j#1 ] reg byte y [ shiftProtoBobRight::carry#2 shiftProtoBobRight::carry#10 ] @@ -431,8 +432,7 @@ reg byte x [ shiftProtoBobDown::i#2 shiftProtoBobDown::i#1 ] zp[2]:6 [ mulf_init::sqr1_lo#2 mulf_init::sqr1_lo#1 prepareBobs::bob_glyph#2 prepareBobs::bob_glyph#1 bobCharsetFindOrAddGlyph::bob_glyph#10 bobCharsetFindOrAddGlyph::bob_glyph#1 memset::dst#2 memset::dst#1 renderBobCleanupNext#17 renderBobCleanupNext#13 ] reg byte x [ mulf_init::x_2#3 mulf_init::x_2#2 mulf_init::x_2#1 ] reg byte x [ mulf_init::x_255#2 mulf_init::x_255#1 ] -zp[1]:8 [ mulf_init::dir#2 mulf_init::dir#4 bobCharsetFindOrAddGlyph::i#2 bobCharsetFindOrAddGlyph::i#1 ] -zp[2]:9 [ main::x#0 mulf_init::sqr2_hi#2 mulf_init::sqr2_hi#1 ] +zp[2]:8 [ main::x#0 mulf_init::sqr2_hi#2 mulf_init::sqr2_hi#1 ] reg byte x [ renderBob::ypos#0 ] reg byte a [ keyboard_key_pressed::return#2 ] reg byte a [ main::$19 ] @@ -442,24 +442,24 @@ reg byte a [ keyboard_matrix_read::return#2 ] reg byte a [ keyboard_key_pressed::$2 ] reg byte a [ keyboard_key_pressed::return#0 ] reg byte a [ keyboard_matrix_read::return#0 ] -zp[1]:11 [ renderBob::x_char_offset#0 shiftProtoBobRight::i#2 shiftProtoBobRight::i#1 prepareBobs::cell#2 prepareBobs::cell#1 ] +zp[1]:10 [ renderBob::x_char_offset#0 shiftProtoBobRight::i#2 shiftProtoBobRight::i#1 prepareBobs::cell#2 prepareBobs::cell#1 ] reg byte a [ renderBob::y_char_offset#0 ] reg byte a [ renderBob::$8 ] -zp[2]:12 [ renderBob::y_offset#0 renderBob::$2 renderBob::screen#0 mulf_init::sqr#3 mulf_init::sqr#4 mulf_init::sqr#1 mulf_init::sqr#2 progress_cursor#15 progress_cursor#31 progress_cursor#24 progress_cursor#17 progress_cursor#8 mulf8s_prepared::m#4 mulf8s_prepared::m#5 mulf8s_prepared::m#1 mulf8s_prepared::m#0 mulf8s_prepared::m#2 mulf8s::return#0 mulf8u_prepared::return#2 mulf8s::return#2 main::$10 mulf8s::return#3 main::$12 mulf8u_prepared::return#0 main::$13 main::y#0 ] +zp[2]:11 [ renderBob::y_offset#0 renderBob::$2 renderBob::screen#0 mulf_init::sqr#3 mulf_init::sqr#4 mulf_init::sqr#1 mulf_init::sqr#2 progress_cursor#15 progress_cursor#31 progress_cursor#24 progress_cursor#17 progress_cursor#8 mulf8s_prepared::m#4 mulf8s_prepared::m#5 mulf8s_prepared::m#1 mulf8s_prepared::m#0 mulf8s_prepared::m#2 mulf8s::return#0 mulf8u_prepared::return#2 mulf8s::return#2 main::$10 mulf8s::return#3 main::$12 mulf8u_prepared::return#0 main::$13 main::y#0 ] reg byte a [ renderBob::$4 ] -zp[1]:14 [ renderBob::$5 shiftProtoBobRight::carry#1 bobCharsetFindOrAddGlyph::glyph_id#11 bobCharsetFindOrAddGlyph::glyph_id#1 ] +zp[1]:13 [ renderBob::$5 mulf_init::c#2 mulf_init::c#1 bob_charset_next_id#23 bob_charset_next_id#14 bob_charset_next_id#16 bob_charset_next_id#30 bob_charset_next_id#21 bob_charset_next_id#8 ] reg byte a [ renderBob::$6 ] reg byte x [ renderBob::bob_table_idx#0 ] reg byte a [ mulf8u_prepare::a#0 ] -zp[1]:15 [ mulf8s_prepared::b#0 renderBob::xpos#0 mulf_init::c#2 mulf_init::c#1 bob_charset_next_id#23 bob_charset_next_id#14 bob_charset_next_id#16 bob_charset_next_id#30 bob_charset_next_id#21 bob_charset_next_id#8 ] +zp[1]:14 [ mulf8s_prepared::b#0 renderBob::xpos#0 mulf_init::dir#2 mulf_init::dir#4 shiftProtoBobRight::carry#1 ] reg byte a [ mulf8u_prepared::b#0 ] reg byte a [ mulf8s_prepared::$8 ] reg byte a [ mulf8s_prepared::$15 ] reg byte a [ mulf8s_prepared::$12 ] reg byte a [ mulf8s_prepared::$16 ] reg byte a [ renderBobCleanup::$1 ] -zp[2]:16 [ renderBobInit::$0 renderBobInit::$7 renderBobInit::$1 renderBobCleanup::screen#0 mulf_init::sqr1_hi#2 mulf_init::sqr1_hi#1 prepareBobs::bob_table#2 prepareBobs::bob_table#1 prepareBobs::bob_table#0 ] -zp[2]:18 [ renderBobInit::$6 mulf_init::sqr2_lo#2 mulf_init::sqr2_lo#1 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::glyph_cursor#1 ] +zp[2]:15 [ renderBobInit::$0 renderBobInit::$7 renderBobInit::$1 renderBobCleanup::screen#0 mulf_init::sqr1_hi#2 mulf_init::sqr1_hi#1 prepareBobs::bob_table#2 prepareBobs::bob_table#1 prepareBobs::bob_table#0 ] +zp[2]:17 [ renderBobInit::$6 mulf_init::sqr2_lo#2 mulf_init::sqr2_lo#1 bobCharsetFindOrAddGlyph::glyph_cursor#11 bobCharsetFindOrAddGlyph::glyph_cursor#1 ] reg byte a [ renderBobInit::$4 ] reg byte a [ renderBobInit::$5 ] reg byte a [ bobCharsetFindOrAddGlyph::return#1 ]