From a6d0f4a541748c85762c9b7a38de1429b12e07e2 Mon Sep 17 00:00:00 2001 From: Jesper Gravgaard Date: Wed, 6 May 2020 22:36:46 +0200 Subject: [PATCH] Added circle chars test. --- .../dk/camelot64/kickc/test/TestPrograms.java | 5 + src/test/kc/circlechars.c | 28 + src/test/kc/printf-13.c | 2 +- src/test/ref/circlechars.asm | 701 ++ src/test/ref/circlechars.cfg | 392 + src/test/ref/circlechars.log | 8125 +++++++++++++++++ src/test/ref/circlechars.sym | 316 + 7 files changed, 9568 insertions(+), 1 deletion(-) create mode 100644 src/test/kc/circlechars.c create mode 100644 src/test/ref/circlechars.asm create mode 100644 src/test/ref/circlechars.cfg create mode 100644 src/test/ref/circlechars.log create mode 100644 src/test/ref/circlechars.sym diff --git a/src/test/java/dk/camelot64/kickc/test/TestPrograms.java b/src/test/java/dk/camelot64/kickc/test/TestPrograms.java index b5f0482a2..d584a5020 100644 --- a/src/test/java/dk/camelot64/kickc/test/TestPrograms.java +++ b/src/test/java/dk/camelot64/kickc/test/TestPrograms.java @@ -40,6 +40,11 @@ public class TestPrograms { public TestPrograms() { } + @Test + public void testCircleChars() throws IOException, URISyntaxException { + compileAndCompare("circlechars.c"); + } + @Test public void testPolygon() throws IOException, URISyntaxException { compileAndCompare("complex/polygon/polygon.c"); diff --git a/src/test/kc/circlechars.c b/src/test/kc/circlechars.c new file mode 100644 index 000000000..885f5925a --- /dev/null +++ b/src/test/kc/circlechars.c @@ -0,0 +1,28 @@ +// Plot a r=9 circle on the screen using chars - count how many chars are used +#include +#include +#include +#include + +char* const SCREEN = 0x0400; + + +void main() { + memset(SCREEN, ' ', 1000); + unsigned int count = 0; + char* sc = SCREEN; + for(char y=0;y<25;y++) { + for(char x=0;x<40;x++) { + signed char xd = (signed char)x*2-39; + signed char yd = (signed char)y*2-24; + signed int dist_sq = mul8s(xd,xd) + mul8s(yd,yd); + if(dist_sq<2*9*2*9) { + *sc = '*'; + count++; + } + sc++; + } + } + gotoxy(0,0); + printf("%u chars",count); +} \ No newline at end of file diff --git a/src/test/kc/printf-13.c b/src/test/kc/printf-13.c index 45429a9f1..0ebb8db11 100644 --- a/src/test/kc/printf-13.c +++ b/src/test/kc/printf-13.c @@ -20,7 +20,7 @@ void main() { printf("%%03d '%03d' '%03d' '%03d' '%3d'\n", 1, 11, 111, 1111); // octal printf("%%o '%o' '%o' '%o' '%o'\n", 1, 11, 111, 1111); - // hexadecimal + // hexadecimals printf("%%x '%x' '%x' '%x' '%x'\n", 1, 11, 111, 1111); // hexadecimal upper-case printf("%%X '%X' '%X' '%X' '%X'\n", 1, 11, 111, 1111); diff --git a/src/test/ref/circlechars.asm b/src/test/ref/circlechars.asm new file mode 100644 index 000000000..38090222f --- /dev/null +++ b/src/test/ref/circlechars.asm @@ -0,0 +1,701 @@ +// Plot a r=9 circle on the screen using chars - count how many chars are used +.pc = $801 "Basic" +:BasicUpstart(__bbegin) +.pc = $80d "Program" + // The default text color + .const CONIO_TEXTCOLOR_DEFAULT = $e + .const OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_DIGITS = 1 + .const SIZEOF_STRUCT_PRINTF_BUFFER_NUMBER = $c + // The screen width + // The screen height + // The screen bytes + // The text screen address + .label CONIO_SCREEN_TEXT = $400 + // The color screen address + .label CONIO_SCREEN_COLORS = $d800 + .label SCREEN = $400 + .label conio_cursor_x = $b + .label conio_cursor_y = $c + .label conio_cursor_text = $d + .label conio_cursor_color = $f +__bbegin: + // conio_cursor_x = 0 + // The current cursor x-position + lda #0 + sta.z conio_cursor_x + // conio_cursor_y = 0 + // The current cursor y-position + sta.z conio_cursor_y + // conio_cursor_text = CONIO_SCREEN_TEXT + // The current cursor address + lda #CONIO_SCREEN_TEXT + sta.z conio_cursor_text+1 + // conio_cursor_color = CONIO_SCREEN_COLORS + // The current cursor address + lda #CONIO_SCREEN_COLORS + sta.z conio_cursor_color+1 + jsr main + rts +main: { + .label __9 = $12 + .label __10 = 6 + .label yd = $11 + .label dist_sq = $12 + .label y = $b + .label sc = 4 + .label x = $c + .label count = 2 + // memset(SCREEN, ' ', 1000) + ldx #' ' + lda #SCREEN + sta.z memset.str+1 + lda #<$3e8 + sta.z memset.num + lda #>$3e8 + sta.z memset.num+1 + jsr memset + lda #SCREEN + sta.z sc+1 + lda #<0 + sta.z count + sta.z count+1 + sta.z y + __b1: + // for(char y=0;y<25;y++) + lda.z y + cmp #$19 + bcc __b2 + // gotoxy(0,0) + jsr gotoxy + // printf("%u chars",count) + jsr printf_uint + // printf("%u chars",count) + lda #s + sta.z cputs.s+1 + jsr cputs + // } + rts + __b2: + lda #0 + sta.z x + __b3: + // for(char x=0;x<40;x++) + lda.z x + cmp #$28 + bcc __b4 + // for(char y=0;y<25;y++) + inc.z y + jmp __b1 + __b4: + // (signed char)x*2 + lda.z x + asl + // xd = (signed char)x*2-39 + tax + axs #$27 + // (signed char)y*2 + lda.z y + asl + // yd = (signed char)y*2-24 + sec + sbc #$18 + sta.z yd + // mul8s(xd,xd) + stx.z mul8s.a + txa + tay + jsr mul8s + // mul8s(xd,xd) + lda.z mul8s.m + sta.z __9 + lda.z mul8s.m+1 + sta.z __9+1 + // mul8s(yd,yd) + lda.z yd + sta.z mul8s.a + ldy.z yd + jsr mul8s + // mul8s(yd,yd) + // dist_sq = mul8s(xd,xd) + mul8s(yd,yd) + lda.z dist_sq + clc + adc.z __10 + sta.z dist_sq + lda.z dist_sq+1 + adc.z __10+1 + sta.z dist_sq+1 + // if(dist_sq<2*9*2*9) + lda.z dist_sq + cmp #<2*9*2*9 + lda.z dist_sq+1 + sbc #>2*9*2*9 + bvc !+ + eor #$80 + !: + bpl __b6 + // *sc = '*' + lda #'*' + ldy #0 + sta (sc),y + // count++; + inc.z count + bne !+ + inc.z count+1 + !: + __b6: + // sc++; + inc.z sc + bne !+ + inc.z sc+1 + !: + // for(char x=0;x<40;x++) + inc.z x + jmp __b3 + s: .text " chars" + .byte 0 +} +// Multiply of two signed chars to a signed int +// Fixes offsets introduced by using unsigned multiplication +// mul8s(signed byte zp($a) a, signed byte register(Y) b) +mul8s: { + .label m = 6 + .label a = $a + // mul8u((char)a, (char) b) + ldx.z a + tya + jsr mul8u + // m = mul8u((char)a, (char) b) + // if(a<0) + lda.z a + cmp #0 + bpl __b1 + // >m + lda.z m+1 + // >m = (>m)-(char)b + sty.z $ff + sec + sbc.z $ff + sta.z m+1 + __b1: + // if(b<0) + cpy #0 + bpl __b2 + // >m + lda.z m+1 + // >m = (>m)-(char)a + sec + sbc.z a + sta.z m+1 + __b2: + // } + rts +} +// Perform binary multiplication of two unsigned 8-bit chars into a 16-bit unsigned int +// mul8u(byte register(X) a, byte register(A) b) +mul8u: { + .label mb = 8 + .label res = 6 + .label return = 6 + // mb = b + sta.z mb + lda #0 + sta.z mb+1 + sta.z res + sta.z res+1 + __b1: + // while(a!=0) + cpx #0 + bne __b2 + // } + rts + __b2: + // a&1 + txa + and #1 + // if( (a&1) != 0) + cmp #0 + beq __b3 + // res = res + mb + lda.z res + clc + adc.z mb + sta.z res + lda.z res+1 + adc.z mb+1 + sta.z res+1 + __b3: + // a = a>>1 + txa + lsr + tax + // mb = mb<<1 + asl.z mb + rol.z mb+1 + jmp __b1 +} +// Output a NUL-terminated string at the current cursor position +// cputs(byte* zp(8) s) +cputs: { + .label s = 8 + __b1: + // c=*s++ + ldy #0 + lda (s),y + // while(c=*s++) + inc.z s + bne !+ + inc.z s+1 + !: + cmp #0 + bne __b2 + // } + rts + __b2: + // cputc(c) + jsr cputc + jmp __b1 +} +// Output one character at the current cursor position +// Moves the cursor forward. Scrolls the entire screen if needed +// cputc(byte register(A) c) +cputc: { + // if(c=='\n') + cmp #'\n' + beq __b1 + // *conio_cursor_text++ = c + ldy #0 + sta (conio_cursor_text),y + // *conio_cursor_text++ = c; + inc.z conio_cursor_text + bne !+ + inc.z conio_cursor_text+1 + !: + // *conio_cursor_color++ = conio_textcolor + lda #CONIO_TEXTCOLOR_DEFAULT + ldy #0 + sta (conio_cursor_color),y + // *conio_cursor_color++ = conio_textcolor; + inc.z conio_cursor_color + bne !+ + inc.z conio_cursor_color+1 + !: + // if(++conio_cursor_x==CONIO_WIDTH) + inc.z conio_cursor_x + lda #$28 + cmp.z conio_cursor_x + bne __breturn + // conio_cursor_x = 0 + lda #0 + sta.z conio_cursor_x + // ++conio_cursor_y; + inc.z conio_cursor_y + // cscroll() + jsr cscroll + __breturn: + // } + rts + __b1: + // cputln() + jsr cputln + rts +} +// Print a newline +cputln: { + .label __1 = $d + .label __2 = $f + .label ln_offset = $16 + // ln_offset = CONIO_WIDTH - conio_cursor_x + sec + lda #$28 + sbc.z conio_cursor_x + sta.z ln_offset + lda #0 + sbc #0 + sta.z ln_offset+1 + // conio_cursor_text + ln_offset + lda.z __1 + clc + adc.z ln_offset + sta.z __1 + lda.z __1+1 + adc.z ln_offset+1 + sta.z __1+1 + // conio_cursor_text = conio_cursor_text + ln_offset + // conio_cursor_color + ln_offset + lda.z __2 + clc + adc.z ln_offset + sta.z __2 + lda.z __2+1 + adc.z ln_offset+1 + sta.z __2+1 + // conio_cursor_color = conio_cursor_color + ln_offset + // conio_cursor_x = 0 + lda #0 + sta.z conio_cursor_x + // conio_cursor_y++; + inc.z conio_cursor_y + // cscroll() + jsr cscroll + // } + rts +} +// Scroll the entire screen if the cursor is beyond the last line +cscroll: { + .label __7 = $d + .label __8 = $f + // if(conio_cursor_y==CONIO_HEIGHT) + lda #$19 + cmp.z conio_cursor_y + bne __breturn + // memcpy(CONIO_SCREEN_TEXT, CONIO_SCREEN_TEXT+CONIO_WIDTH, CONIO_BYTES-CONIO_WIDTH) + lda #CONIO_SCREEN_TEXT + sta.z memcpy.destination+1 + lda #CONIO_SCREEN_TEXT+$28 + sta.z memcpy.source+1 + jsr memcpy + // memcpy(CONIO_SCREEN_COLORS, CONIO_SCREEN_COLORS+CONIO_WIDTH, CONIO_BYTES-CONIO_WIDTH) + lda #CONIO_SCREEN_COLORS + sta.z memcpy.destination+1 + lda #CONIO_SCREEN_COLORS+$28 + sta.z memcpy.source+1 + jsr memcpy + // memset(CONIO_SCREEN_TEXT+CONIO_BYTES-CONIO_WIDTH, ' ', CONIO_WIDTH) + ldx #' ' + lda #CONIO_SCREEN_TEXT+$19*$28-$28 + sta.z memset.str+1 + lda #<$28 + sta.z memset.num + lda #>$28 + sta.z memset.num+1 + jsr memset + // memset(CONIO_SCREEN_COLORS+CONIO_BYTES-CONIO_WIDTH, conio_textcolor, CONIO_WIDTH) + ldx #CONIO_TEXTCOLOR_DEFAULT + lda #CONIO_SCREEN_COLORS+$19*$28-$28 + sta.z memset.str+1 + lda #<$28 + sta.z memset.num + lda #>$28 + sta.z memset.num+1 + jsr memset + // conio_cursor_text-CONIO_WIDTH + lda.z __7 + sec + sbc #<$28 + sta.z __7 + lda.z __7+1 + sbc #>$28 + sta.z __7+1 + // conio_cursor_text = conio_cursor_text-CONIO_WIDTH + // conio_cursor_color-CONIO_WIDTH + lda.z __8 + sec + sbc #<$28 + sta.z __8 + lda.z __8+1 + sbc #>$28 + sta.z __8+1 + // conio_cursor_color = conio_cursor_color-CONIO_WIDTH + // conio_cursor_y--; + dec.z conio_cursor_y + __breturn: + // } + rts +} +// Copies the character c (an unsigned char) to the first num characters of the object pointed to by the argument str. +// memset(void* zp($16) str, byte register(X) c, word zp($12) num) +memset: { + .label end = $12 + .label dst = $16 + .label num = $12 + .label str = $16 + // if(num>0) + lda.z num + bne !+ + lda.z num+1 + beq __breturn + !: + // end = (char*)str + num + lda.z end + clc + adc.z str + sta.z end + lda.z end+1 + adc.z str+1 + sta.z end+1 + __b2: + // for(char* dst = str; dst!=end; dst++) + lda.z dst+1 + cmp.z end+1 + bne __b3 + lda.z dst + cmp.z end + bne __b3 + __breturn: + // } + rts + __b3: + // *dst = c + txa + ldy #0 + sta (dst),y + // for(char* dst = str; dst!=end; dst++) + inc.z dst + bne !+ + inc.z dst+1 + !: + jmp __b2 +} +// Copy block of memory (forwards) +// Copies the values of num bytes from the location pointed to by source directly to the memory block pointed to by destination. +// memcpy(void* zp($16) destination, void* zp($12) source) +memcpy: { + .label src_end = $14 + .label dst = $16 + .label src = $12 + .label source = $12 + .label destination = $16 + // src_end = (char*)source+num + lda.z source + clc + adc #<$19*$28-$28 + sta.z src_end + lda.z source+1 + adc #>$19*$28-$28 + sta.z src_end+1 + __b1: + // while(src!=src_end) + lda.z src+1 + cmp.z src_end+1 + bne __b2 + lda.z src + cmp.z src_end + bne __b2 + // } + rts + __b2: + // *dst++ = *src++ + ldy #0 + lda (src),y + sta (dst),y + // *dst++ = *src++; + inc.z dst + bne !+ + inc.z dst+1 + !: + inc.z src + bne !+ + inc.z src+1 + !: + jmp __b1 +} +// Print an unsigned int using a specific format +// printf_uint(word zp(2) uvalue) +printf_uint: { + .label uvalue = 2 + // printf_buffer.sign = format.sign_always?'+':0 + // Handle any sign + lda #0 + sta printf_buffer + // utoa(uvalue, printf_buffer.digits, format.radix) + // Format number into buffer + jsr utoa + // printf_number_buffer(printf_buffer, format) + lda printf_buffer + // Print using format + jsr printf_number_buffer + // } + rts +} +// Print the contents of the number buffer using a specific format. +// This handles minimum length, zero-filling, and left/right justification from the format +// printf_number_buffer(byte register(A) buffer_sign) +printf_number_buffer: { + .label buffer_digits = printf_buffer+OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_DIGITS + // if(buffer.sign) + cmp #0 + beq __b2 + // cputc(buffer.sign) + jsr cputc + __b2: + // cputs(buffer.digits) + lda #buffer_digits + sta.z cputs.s+1 + jsr cputs + // } + rts +} +// Converts unsigned number value to a string representing it in RADIX format. +// If the leading digits are zero they are not included in the string. +// - value : The number to be converted to RADIX +// - buffer : receives the string representing the number and zero-termination. +// - radix : The radix to convert the number to (from the enum RADIX) +// utoa(word zp(2) value, byte* zp($12) buffer) +utoa: { + .const max_digits = 5 + .label digit_value = $16 + .label buffer = $12 + .label digit = $a + .label value = 2 + lda #printf_buffer+OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_DIGITS + sta.z buffer+1 + ldx #0 + txa + sta.z digit + __b1: + // for( char digit=0; digit= digit_value) + cpx #0 + bne __b5 + cmp.z value+1 + bne !+ + lda.z digit_value + cmp.z value + beq __b5 + !: + bcc __b5 + __b4: + // for( char digit=0; digit= sub) + lda.z sub+1 + cmp.z value+1 + bne !+ + lda.z sub + cmp.z value + beq __b2 + !: + bcc __b2 + // *buffer = DIGITS[digit] + lda DIGITS,x + ldy #0 + sta (buffer),y + // } + rts + __b2: + // digit++; + inx + // value -= sub + lda.z value + sec + sbc.z sub + sta.z value + lda.z value+1 + sbc.z sub+1 + sta.z value+1 + jmp __b1 +} +// Set the cursor to the specified position +gotoxy: { + .const x = 0 + .const y = 0 + // conio_cursor_x = x + lda #x + sta.z conio_cursor_x + // conio_cursor_y = y + lda #y + sta.z conio_cursor_y + // conio_cursor_text = CONIO_SCREEN_TEXT + offset + lda #CONIO_SCREEN_TEXT + sta.z conio_cursor_text+1 + // conio_cursor_color = CONIO_SCREEN_COLORS + offset + lda #CONIO_SCREEN_COLORS + sta.z conio_cursor_color+1 + // } + rts +} + // The digits used for numbers + DIGITS: .text "0123456789abcdef" + // Values of decimal digits + RADIX_DECIMAL_VALUES: .word $2710, $3e8, $64, $a + // Buffer used for stringified number being printed + printf_buffer: .fill SIZEOF_STRUCT_PRINTF_BUFFER_NUMBER, 0 diff --git a/src/test/ref/circlechars.cfg b/src/test/ref/circlechars.cfg new file mode 100644 index 000000000..9a138b990 --- /dev/null +++ b/src/test/ref/circlechars.cfg @@ -0,0 +1,392 @@ +@begin: scope:[] from + [0] phi() + to:@1 +@1: scope:[] from @begin + [1] (byte) conio_cursor_x ← (byte) 0 + [2] (byte) conio_cursor_y ← (byte) 0 + [3] (byte*) conio_cursor_text ← (const nomodify byte*) CONIO_SCREEN_TEXT + [4] (byte*) conio_cursor_color ← (const nomodify byte*) CONIO_SCREEN_COLORS + to:@2 +@2: scope:[] from @1 + [5] phi() + [6] call main + to:@end +@end: scope:[] from @2 + [7] phi() + +(void()) main() +main: scope:[main] from @2 + [8] phi() + [9] call memset + to:main::@1 +main::@1: scope:[main] from main main::@5 + [10] (byte*) main::sc#8 ← phi( main::@5/(byte*) main::sc#10 main/(const nomodify byte*) SCREEN ) + [10] (word) main::count#11 ← phi( main::@5/(word) main::count#10 main/(word) 0 ) + [10] (byte) main::y#2 ← phi( main::@5/(byte) main::y#1 main/(byte) 0 ) + [11] if((byte) main::y#2<(byte) $19) goto main::@3 + to:main::@2 +main::@2: scope:[main] from main::@1 + [12] phi() + [13] call gotoxy + to:main::@8 +main::@8: scope:[main] from main::@2 + [14] (word) printf_uint::uvalue#0 ← (word) main::count#11 + [15] call printf_uint + to:main::@9 +main::@9: scope:[main] from main::@8 + [16] phi() + [17] call cputs + to:main::@return +main::@return: scope:[main] from main::@9 + [18] return + to:@return +main::@3: scope:[main] from main::@1 main::@6 + [19] (word) main::count#10 ← phi( main::@1/(word) main::count#11 main::@6/(word) main::count#12 ) + [19] (byte*) main::sc#10 ← phi( main::@1/(byte*) main::sc#8 main::@6/(byte*) main::sc#1 ) + [19] (byte) main::x#2 ← phi( main::@1/(byte) 0 main::@6/(byte) main::x#1 ) + [20] if((byte) main::x#2<(byte) $28) goto main::@4 + to:main::@5 +main::@5: scope:[main] from main::@3 + [21] (byte) main::y#1 ← ++ (byte) main::y#2 + to:main::@1 +main::@4: scope:[main] from main::@3 + [22] (signed byte~) main::$5 ← (signed byte)(byte) main::x#2 << (byte) 1 + [23] (signed byte) main::xd#0 ← (signed byte~) main::$5 - (signed byte) $27 + [24] (signed byte~) main::$7 ← (signed byte)(byte) main::y#2 << (byte) 1 + [25] (signed byte) main::yd#0 ← (signed byte~) main::$7 - (signed byte) $18 + [26] (signed byte) mul8s::a#0 ← (signed byte) main::xd#0 + [27] (signed byte) mul8s::b#0 ← (signed byte) main::xd#0 + [28] call mul8s + to:main::@10 +main::@10: scope:[main] from main::@4 + [29] (signed word~) main::$9 ← (signed word)(word) mul8s::m#4 + [30] (signed byte) mul8s::a#1 ← (signed byte) main::yd#0 + [31] (signed byte) mul8s::b#1 ← (signed byte) main::yd#0 + [32] call mul8s + to:main::@11 +main::@11: scope:[main] from main::@10 + [33] (signed word~) main::$10 ← (signed word)(word) mul8s::m#4 + [34] (signed word) main::dist_sq#0 ← (signed word~) main::$9 + (signed word~) main::$10 + [35] if((signed word) main::dist_sq#0>=(signed word)(number) 2*(number) 9*(number) 2*(number) 9) goto main::@6 + to:main::@7 +main::@7: scope:[main] from main::@11 + [36] *((byte*) main::sc#10) ← (byte) '*' + [37] (word) main::count#1 ← ++ (word) main::count#10 + to:main::@6 +main::@6: scope:[main] from main::@11 main::@7 + [38] (word) main::count#12 ← phi( main::@11/(word) main::count#10 main::@7/(word) main::count#1 ) + [39] (byte*) main::sc#1 ← ++ (byte*) main::sc#10 + [40] (byte) main::x#1 ← ++ (byte) main::x#2 + to:main::@3 + +(signed word()) mul8s((signed byte) mul8s::a , (signed byte) mul8s::b) +mul8s: scope:[mul8s] from main::@10 main::@4 + [41] (signed byte) mul8s::b#2 ← phi( main::@10/(signed byte) mul8s::b#1 main::@4/(signed byte) mul8s::b#0 ) + [41] (signed byte) mul8s::a#2 ← phi( main::@10/(signed byte) mul8s::a#1 main::@4/(signed byte) mul8s::a#0 ) + [42] (byte) mul8u::a#1 ← (byte)(signed byte) mul8s::a#2 + [43] (byte) mul8u::b#0 ← (byte)(signed byte) mul8s::b#2 + [44] call mul8u + [45] (word) mul8u::return#2 ← (word) mul8u::res#2 + to:mul8s::@5 +mul8s::@5: scope:[mul8s] from mul8s + [46] (word) mul8s::m#0 ← (word) mul8u::return#2 + [47] if((signed byte) mul8s::a#2>=(signed byte) 0) goto mul8s::@1 + to:mul8s::@3 +mul8s::@3: scope:[mul8s] from mul8s::@5 + [48] (byte~) mul8s::$6 ← > (word) mul8s::m#0 + [49] (byte~) mul8s::$11 ← (byte~) mul8s::$6 - (byte)(signed byte) mul8s::b#2 + [50] (word) mul8s::m#1 ← (word) mul8s::m#0 hi= (byte~) mul8s::$11 + to:mul8s::@1 +mul8s::@1: scope:[mul8s] from mul8s::@3 mul8s::@5 + [51] (word) mul8s::m#5 ← phi( mul8s::@3/(word) mul8s::m#1 mul8s::@5/(word) mul8s::m#0 ) + [52] if((signed byte) mul8s::b#2>=(signed byte) 0) goto mul8s::@2 + to:mul8s::@4 +mul8s::@4: scope:[mul8s] from mul8s::@1 + [53] (byte~) mul8s::$9 ← > (word) mul8s::m#5 + [54] (byte~) mul8s::$12 ← (byte~) mul8s::$9 - (byte)(signed byte) mul8s::a#2 + [55] (word) mul8s::m#2 ← (word) mul8s::m#5 hi= (byte~) mul8s::$12 + to:mul8s::@2 +mul8s::@2: scope:[mul8s] from mul8s::@1 mul8s::@4 + [56] (word) mul8s::m#4 ← phi( mul8s::@1/(word) mul8s::m#5 mul8s::@4/(word) mul8s::m#2 ) + to:mul8s::@return +mul8s::@return: scope:[mul8s] from mul8s::@2 + [57] return + to:@return + +(word()) mul8u((byte) mul8u::a , (byte) mul8u::b) +mul8u: scope:[mul8u] from mul8s + [58] (word) mul8u::mb#0 ← (word)(byte) mul8u::b#0 + to:mul8u::@1 +mul8u::@1: scope:[mul8u] from mul8u mul8u::@3 + [59] (word) mul8u::mb#2 ← phi( mul8u/(word) mul8u::mb#0 mul8u::@3/(word) mul8u::mb#1 ) + [59] (word) mul8u::res#2 ← phi( mul8u/(word) 0 mul8u::@3/(word) mul8u::res#6 ) + [59] (byte) mul8u::a#2 ← phi( mul8u/(byte) mul8u::a#1 mul8u::@3/(byte) mul8u::a#0 ) + [60] if((byte) mul8u::a#2!=(byte) 0) goto mul8u::@2 + to:mul8u::@return +mul8u::@return: scope:[mul8u] from mul8u::@1 + [61] return + to:@return +mul8u::@2: scope:[mul8u] from mul8u::@1 + [62] (byte~) mul8u::$1 ← (byte) mul8u::a#2 & (byte) 1 + [63] if((byte~) mul8u::$1==(byte) 0) goto mul8u::@3 + to:mul8u::@4 +mul8u::@4: scope:[mul8u] from mul8u::@2 + [64] (word) mul8u::res#1 ← (word) mul8u::res#2 + (word) mul8u::mb#2 + to:mul8u::@3 +mul8u::@3: scope:[mul8u] from mul8u::@2 mul8u::@4 + [65] (word) mul8u::res#6 ← phi( mul8u::@2/(word) mul8u::res#2 mul8u::@4/(word) mul8u::res#1 ) + [66] (byte) mul8u::a#0 ← (byte) mul8u::a#2 >> (byte) 1 + [67] (word) mul8u::mb#1 ← (word) mul8u::mb#2 << (byte) 1 + to:mul8u::@1 + +(void()) cputs((to_nomodify byte*) cputs::s) +cputs: scope:[cputs] from main::@9 printf_number_buffer::@2 + [68] (to_nomodify byte*) cputs::s#4 ← phi( main::@9/(const byte*) main::s printf_number_buffer::@2/(const byte*) printf_number_buffer::buffer_digits#0 ) + to:cputs::@1 +cputs::@1: scope:[cputs] from cputs cputs::@2 + [69] (to_nomodify byte*) cputs::s#3 ← phi( cputs/(to_nomodify byte*) cputs::s#4 cputs::@2/(to_nomodify byte*) cputs::s#0 ) + [70] (byte) cputs::c#1 ← *((to_nomodify byte*) cputs::s#3) + [71] (to_nomodify byte*) cputs::s#0 ← ++ (to_nomodify byte*) cputs::s#3 + [72] if((byte) 0!=(byte) cputs::c#1) goto cputs::@2 + to:cputs::@return +cputs::@return: scope:[cputs] from cputs::@1 + [73] return + to:@return +cputs::@2: scope:[cputs] from cputs::@1 + [74] (byte) cputc::c#0 ← (byte) cputs::c#1 + [75] call cputc + to:cputs::@1 + +(void()) cputc((byte) cputc::c) +cputc: scope:[cputc] from cputs::@2 printf_number_buffer::@3 + [76] (byte) cputc::c#3 ← phi( cputs::@2/(byte) cputc::c#0 printf_number_buffer::@3/(byte) cputc::c#2 ) + [77] if((byte) cputc::c#3==(byte) ' +') goto cputc::@1 + to:cputc::@2 +cputc::@2: scope:[cputc] from cputc + [78] *((byte*) conio_cursor_text) ← (byte) cputc::c#3 + [79] (byte*) conio_cursor_text ← ++ (byte*) conio_cursor_text + [80] *((byte*) conio_cursor_color) ← (const nomodify byte) CONIO_TEXTCOLOR_DEFAULT + [81] (byte*) conio_cursor_color ← ++ (byte*) conio_cursor_color + [82] (byte) conio_cursor_x ← ++ (byte) conio_cursor_x + [83] if((byte) conio_cursor_x!=(byte) $28) goto cputc::@return + to:cputc::@3 +cputc::@3: scope:[cputc] from cputc::@2 + [84] (byte) conio_cursor_x ← (byte) 0 + [85] (byte) conio_cursor_y ← ++ (byte) conio_cursor_y + [86] call cscroll + to:cputc::@return +cputc::@return: scope:[cputc] from cputc::@1 cputc::@2 cputc::@3 + [87] return + to:@return +cputc::@1: scope:[cputc] from cputc + [88] phi() + [89] call cputln + to:cputc::@return + +(void()) cputln() +cputln: scope:[cputln] from cputc::@1 + [90] (word) cputln::ln_offset#0 ← (byte) $28 - (byte) conio_cursor_x + [91] (byte*~) cputln::$1 ← (byte*) conio_cursor_text + (word) cputln::ln_offset#0 + [92] (byte*) conio_cursor_text ← (byte*~) cputln::$1 + [93] (byte*~) cputln::$2 ← (byte*) conio_cursor_color + (word) cputln::ln_offset#0 + [94] (byte*) conio_cursor_color ← (byte*~) cputln::$2 + [95] (byte) conio_cursor_x ← (byte) 0 + [96] (byte) conio_cursor_y ← ++ (byte) conio_cursor_y + [97] call cscroll + to:cputln::@return +cputln::@return: scope:[cputln] from cputln + [98] return + to:@return + +(void()) cscroll() +cscroll: scope:[cscroll] from cputc::@3 cputln + [99] if((byte) conio_cursor_y!=(byte) $19) goto cscroll::@return + to:cscroll::@1 +cscroll::@1: scope:[cscroll] from cscroll + [100] phi() + [101] call memcpy + to:cscroll::@2 +cscroll::@2: scope:[cscroll] from cscroll::@1 + [102] phi() + [103] call memcpy + to:cscroll::@3 +cscroll::@3: scope:[cscroll] from cscroll::@2 + [104] phi() + [105] call memset + to:cscroll::@4 +cscroll::@4: scope:[cscroll] from cscroll::@3 + [106] phi() + [107] call memset + to:cscroll::@5 +cscroll::@5: scope:[cscroll] from cscroll::@4 + [108] (byte*~) cscroll::$7 ← (byte*) conio_cursor_text - (byte) $28 + [109] (byte*) conio_cursor_text ← (byte*~) cscroll::$7 + [110] (byte*~) cscroll::$8 ← (byte*) conio_cursor_color - (byte) $28 + [111] (byte*) conio_cursor_color ← (byte*~) cscroll::$8 + [112] (byte) conio_cursor_y ← -- (byte) conio_cursor_y + to:cscroll::@return +cscroll::@return: scope:[cscroll] from cscroll cscroll::@5 + [113] return + to:@return + +(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num) +memset: scope:[memset] from cscroll::@3 cscroll::@4 main + [114] (byte) memset::c#5 ← phi( cscroll::@3/(byte) ' ' cscroll::@4/(const nomodify byte) CONIO_TEXTCOLOR_DEFAULT main/(byte) ' ' ) + [114] (void*) memset::str#4 ← phi( cscroll::@3/(void*)(const nomodify byte*) CONIO_SCREEN_TEXT+(word)(number) $19*(number) $28-(byte) $28 cscroll::@4/(void*)(const nomodify byte*) CONIO_SCREEN_COLORS+(word)(number) $19*(number) $28-(byte) $28 main/(void*)(const nomodify byte*) SCREEN ) + [114] (word) memset::num#3 ← phi( cscroll::@3/(byte) $28 cscroll::@4/(byte) $28 main/(word) $3e8 ) + [115] if((word) memset::num#3<=(byte) 0) goto memset::@return + to:memset::@1 +memset::@1: scope:[memset] from memset + [116] (byte*) memset::end#0 ← (byte*)(void*) memset::str#4 + (word) memset::num#3 + [117] (byte*) memset::dst#4 ← (byte*)(void*) memset::str#4 + to:memset::@2 +memset::@2: scope:[memset] from memset::@1 memset::@3 + [118] (byte*) memset::dst#2 ← phi( memset::@1/(byte*) memset::dst#4 memset::@3/(byte*) memset::dst#1 ) + [119] if((byte*) memset::dst#2!=(byte*) memset::end#0) goto memset::@3 + to:memset::@return +memset::@return: scope:[memset] from memset memset::@2 + [120] return + to:@return +memset::@3: scope:[memset] from memset::@2 + [121] *((byte*) memset::dst#2) ← (byte) memset::c#5 + [122] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2 + to:memset::@2 + +(void*()) memcpy((void*) memcpy::destination , (void*) memcpy::source , (word) memcpy::num) +memcpy: scope:[memcpy] from cscroll::@1 cscroll::@2 + [123] (void*) memcpy::destination#2 ← phi( cscroll::@1/(void*)(const nomodify byte*) CONIO_SCREEN_TEXT cscroll::@2/(void*)(const nomodify byte*) CONIO_SCREEN_COLORS ) + [123] (void*) memcpy::source#2 ← phi( cscroll::@1/(void*)(const nomodify byte*) CONIO_SCREEN_TEXT+(byte) $28 cscroll::@2/(void*)(const nomodify byte*) CONIO_SCREEN_COLORS+(byte) $28 ) + [124] (byte*) memcpy::src_end#0 ← (byte*)(void*) memcpy::source#2 + (word)(number) $19*(number) $28-(number) $28 + [125] (byte*) memcpy::src#4 ← (byte*)(void*) memcpy::source#2 + [126] (byte*) memcpy::dst#4 ← (byte*)(void*) memcpy::destination#2 + to:memcpy::@1 +memcpy::@1: scope:[memcpy] from memcpy memcpy::@2 + [127] (byte*) memcpy::dst#2 ← phi( memcpy/(byte*) memcpy::dst#4 memcpy::@2/(byte*) memcpy::dst#1 ) + [127] (byte*) memcpy::src#2 ← phi( memcpy/(byte*) memcpy::src#4 memcpy::@2/(byte*) memcpy::src#1 ) + [128] if((byte*) memcpy::src#2!=(byte*) memcpy::src_end#0) goto memcpy::@2 + to:memcpy::@return +memcpy::@return: scope:[memcpy] from memcpy::@1 + [129] return + to:@return +memcpy::@2: scope:[memcpy] from memcpy::@1 + [130] *((byte*) memcpy::dst#2) ← *((byte*) memcpy::src#2) + [131] (byte*) memcpy::dst#1 ← ++ (byte*) memcpy::dst#2 + [132] (byte*) memcpy::src#1 ← ++ (byte*) memcpy::src#2 + to:memcpy::@1 + +(void()) printf_uint((word) printf_uint::uvalue , (byte) printf_uint::format_min_length , (byte) printf_uint::format_justify_left , (byte) printf_uint::format_sign_always , (byte) printf_uint::format_zero_padding , (byte) printf_uint::format_upper_case , (byte) printf_uint::format_radix) +printf_uint: scope:[printf_uint] from main::@8 + [133] phi() + to:printf_uint::@1 +printf_uint::@1: scope:[printf_uint] from printf_uint + [134] *((byte*)&(struct printf_buffer_number) printf_buffer) ← (byte) 0 + [135] (word) utoa::value#1 ← (word) printf_uint::uvalue#0 + [136] call utoa + to:printf_uint::@2 +printf_uint::@2: scope:[printf_uint] from printf_uint::@1 + [137] (byte) printf_number_buffer::buffer_sign#0 ← *((byte*)&(struct printf_buffer_number) printf_buffer) + [138] call printf_number_buffer + to:printf_uint::@return +printf_uint::@return: scope:[printf_uint] from printf_uint::@2 + [139] return + to:@return + +(void()) printf_number_buffer((byte) printf_number_buffer::buffer_sign , (byte*) printf_number_buffer::buffer_digits , (byte) printf_number_buffer::format_min_length , (byte) printf_number_buffer::format_justify_left , (byte) printf_number_buffer::format_sign_always , (byte) printf_number_buffer::format_zero_padding , (byte) printf_number_buffer::format_upper_case , (byte) printf_number_buffer::format_radix) +printf_number_buffer: scope:[printf_number_buffer] from printf_uint::@2 + [140] phi() + to:printf_number_buffer::@1 +printf_number_buffer::@1: scope:[printf_number_buffer] from printf_number_buffer + [141] if((byte) 0==(byte) printf_number_buffer::buffer_sign#0) goto printf_number_buffer::@2 + to:printf_number_buffer::@3 +printf_number_buffer::@3: scope:[printf_number_buffer] from printf_number_buffer::@1 + [142] (byte) cputc::c#2 ← (byte) printf_number_buffer::buffer_sign#0 + [143] call cputc + to:printf_number_buffer::@2 +printf_number_buffer::@2: scope:[printf_number_buffer] from printf_number_buffer::@1 printf_number_buffer::@3 + [144] phi() + [145] call cputs + to:printf_number_buffer::@return +printf_number_buffer::@return: scope:[printf_number_buffer] from printf_number_buffer::@2 + [146] return + to:@return + +(void()) utoa((word) utoa::value , (byte*) utoa::buffer , (byte) utoa::radix) +utoa: scope:[utoa] from printf_uint::@1 + [147] phi() + to:utoa::@1 +utoa::@1: scope:[utoa] from utoa utoa::@4 + [148] (byte*) utoa::buffer#11 ← phi( utoa::@4/(byte*) utoa::buffer#14 utoa/(byte*)&(struct printf_buffer_number) printf_buffer+(const byte) OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_DIGITS ) + [148] (byte) utoa::started#2 ← phi( utoa::@4/(byte) utoa::started#4 utoa/(byte) 0 ) + [148] (word) utoa::value#2 ← phi( utoa::@4/(word) utoa::value#6 utoa/(word) utoa::value#1 ) + [148] (byte) utoa::digit#2 ← phi( utoa::@4/(byte) utoa::digit#1 utoa/(byte) 0 ) + [149] if((byte) utoa::digit#2<(const byte) utoa::max_digits#1-(byte) 1) goto utoa::@2 + to:utoa::@3 +utoa::@3: scope:[utoa] from utoa::@1 + [150] (byte~) utoa::$11 ← (byte)(word) utoa::value#2 + [151] *((byte*) utoa::buffer#11) ← *((const byte*) DIGITS + (byte~) utoa::$11) + [152] (byte*) utoa::buffer#3 ← ++ (byte*) utoa::buffer#11 + [153] *((byte*) utoa::buffer#3) ← (byte) 0 + to:utoa::@return +utoa::@return: scope:[utoa] from utoa::@3 + [154] return + to:@return +utoa::@2: scope:[utoa] from utoa::@1 + [155] (byte~) utoa::$10 ← (byte) utoa::digit#2 << (byte) 1 + [156] (word) utoa::digit_value#0 ← *((const word*) RADIX_DECIMAL_VALUES + (byte~) utoa::$10) + [157] if((byte) 0!=(byte) utoa::started#2) goto utoa::@5 + to:utoa::@7 +utoa::@7: scope:[utoa] from utoa::@2 + [158] if((word) utoa::value#2>=(word) utoa::digit_value#0) goto utoa::@5 + to:utoa::@4 +utoa::@4: scope:[utoa] from utoa::@6 utoa::@7 + [159] (byte*) utoa::buffer#14 ← phi( utoa::@7/(byte*) utoa::buffer#11 utoa::@6/(byte*) utoa::buffer#4 ) + [159] (byte) utoa::started#4 ← phi( utoa::@7/(byte) utoa::started#2 utoa::@6/(byte) 1 ) + [159] (word) utoa::value#6 ← phi( utoa::@7/(word) utoa::value#2 utoa::@6/(word) utoa::value#0 ) + [160] (byte) utoa::digit#1 ← ++ (byte) utoa::digit#2 + to:utoa::@1 +utoa::@5: scope:[utoa] from utoa::@2 utoa::@7 + [161] (byte*) utoa_append::buffer#0 ← (byte*) utoa::buffer#11 + [162] (word) utoa_append::value#0 ← (word) utoa::value#2 + [163] (word) utoa_append::sub#0 ← (word) utoa::digit_value#0 + [164] call utoa_append + [165] (word) utoa_append::return#0 ← (word) utoa_append::value#2 + to:utoa::@6 +utoa::@6: scope:[utoa] from utoa::@5 + [166] (word) utoa::value#0 ← (word) utoa_append::return#0 + [167] (byte*) utoa::buffer#4 ← ++ (byte*) utoa::buffer#11 + to:utoa::@4 + +(word()) utoa_append((byte*) utoa_append::buffer , (word) utoa_append::value , (word) utoa_append::sub) +utoa_append: scope:[utoa_append] from utoa::@5 + [168] phi() + to:utoa_append::@1 +utoa_append::@1: scope:[utoa_append] from utoa_append utoa_append::@2 + [169] (byte) utoa_append::digit#2 ← phi( utoa_append/(byte) 0 utoa_append::@2/(byte) utoa_append::digit#1 ) + [169] (word) utoa_append::value#2 ← phi( utoa_append/(word) utoa_append::value#0 utoa_append::@2/(word) utoa_append::value#1 ) + [170] if((word) utoa_append::value#2>=(word) utoa_append::sub#0) goto utoa_append::@2 + to:utoa_append::@3 +utoa_append::@3: scope:[utoa_append] from utoa_append::@1 + [171] *((byte*) utoa_append::buffer#0) ← *((const byte*) DIGITS + (byte) utoa_append::digit#2) + to:utoa_append::@return +utoa_append::@return: scope:[utoa_append] from utoa_append::@3 + [172] return + to:@return +utoa_append::@2: scope:[utoa_append] from utoa_append::@1 + [173] (byte) utoa_append::digit#1 ← ++ (byte) utoa_append::digit#2 + [174] (word) utoa_append::value#1 ← (word) utoa_append::value#2 - (word) utoa_append::sub#0 + to:utoa_append::@1 + +(void()) gotoxy((byte) gotoxy::x , (byte) gotoxy::y) +gotoxy: scope:[gotoxy] from main::@2 + [175] phi() + to:gotoxy::@1 +gotoxy::@1: scope:[gotoxy] from gotoxy + [176] (byte) conio_cursor_x ← (const byte) gotoxy::x#2 + [177] (byte) conio_cursor_y ← (const byte) gotoxy::y#2 + [178] (byte*) conio_cursor_text ← (const nomodify byte*) CONIO_SCREEN_TEXT + [179] (byte*) conio_cursor_color ← (const nomodify byte*) CONIO_SCREEN_COLORS + to:gotoxy::@return +gotoxy::@return: scope:[gotoxy] from gotoxy::@1 + [180] return + to:@return diff --git a/src/test/ref/circlechars.log b/src/test/ref/circlechars.log new file mode 100644 index 000000000..b86e3a349 --- /dev/null +++ b/src/test/ref/circlechars.log @@ -0,0 +1,8125 @@ +Fixing struct type size struct printf_buffer_number to 12 +Fixing struct type size struct printf_buffer_number to 12 +Fixing struct type SIZE_OF struct printf_buffer_number to 12 +Fixing struct type SIZE_OF struct printf_buffer_number to 12 +Added struct type cast to parameter value list call printf_uint (word) main::count (struct printf_format_number){ (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (const byte) DECIMAL } +Eliminating unused variable with no statement (void~) main::$2 + +CONTROL FLOW GRAPH SSA +@begin: scope:[] from + to:@1 + +(byte()) toupper((byte) toupper::ch) +toupper: scope:[toupper] from strupr::@2 + (byte) toupper::ch#1 ← phi( strupr::@2/(byte) toupper::ch#0 ) + (bool~) toupper::$0 ← (byte) toupper::ch#1 >= (byte) 'a' + (bool~) toupper::$1 ← (byte) toupper::ch#1 <= (byte) 'z' + (bool~) toupper::$2 ← (bool~) toupper::$0 && (bool~) toupper::$1 + if((bool~) toupper::$2) goto toupper::@1 + to:toupper::@2 +toupper::@1: scope:[toupper] from toupper + (byte) toupper::ch#2 ← phi( toupper/(byte) toupper::ch#1 ) + (byte~) toupper::$3 ← (byte) toupper::ch#2 + (byte) 'A'-(byte) 'a' + (byte) toupper::return#0 ← (byte~) toupper::$3 + to:toupper::@return +toupper::@2: scope:[toupper] from toupper + (byte) toupper::ch#3 ← phi( toupper/(byte) toupper::ch#1 ) + (byte) toupper::return#1 ← (byte) toupper::ch#3 + to:toupper::@return +toupper::@return: scope:[toupper] from toupper::@1 toupper::@2 + (byte) toupper::return#4 ← phi( toupper::@1/(byte) toupper::return#0 toupper::@2/(byte) toupper::return#1 ) + (byte) toupper::return#2 ← (byte) toupper::return#4 + return + to:@return + +(void*()) memcpy((void*) memcpy::destination , (void*) memcpy::source , (word) memcpy::num) +memcpy: scope:[memcpy] from cscroll::@3 cscroll::@4 + (word) memcpy::num#2 ← phi( cscroll::@3/(word) memcpy::num#0 cscroll::@4/(word) memcpy::num#1 ) + (void*) memcpy::destination#2 ← phi( cscroll::@3/(void*) memcpy::destination#0 cscroll::@4/(void*) memcpy::destination#1 ) + (void*) memcpy::source#2 ← phi( cscroll::@3/(void*) memcpy::source#0 cscroll::@4/(void*) memcpy::source#1 ) + (byte*) memcpy::src#0 ← ((byte*)) (void*) memcpy::source#2 + (byte*) memcpy::dst#0 ← ((byte*)) (void*) memcpy::destination#2 + (byte*~) memcpy::$2 ← (byte*)(void*) memcpy::source#2 + (byte*~) memcpy::$0 ← (byte*~) memcpy::$2 + (word) memcpy::num#2 + (byte*) memcpy::src_end#0 ← (byte*~) memcpy::$0 + to:memcpy::@1 +memcpy::@1: scope:[memcpy] from memcpy memcpy::@2 + (void*) memcpy::destination#4 ← phi( memcpy/(void*) memcpy::destination#2 memcpy::@2/(void*) memcpy::destination#5 ) + (byte*) memcpy::dst#3 ← phi( memcpy/(byte*) memcpy::dst#0 memcpy::@2/(byte*) memcpy::dst#1 ) + (byte*) memcpy::src_end#1 ← phi( memcpy/(byte*) memcpy::src_end#0 memcpy::@2/(byte*) memcpy::src_end#2 ) + (byte*) memcpy::src#2 ← phi( memcpy/(byte*) memcpy::src#0 memcpy::@2/(byte*) memcpy::src#1 ) + (bool~) memcpy::$1 ← (byte*) memcpy::src#2 != (byte*) memcpy::src_end#1 + if((bool~) memcpy::$1) goto memcpy::@2 + to:memcpy::@3 +memcpy::@2: scope:[memcpy] from memcpy::@1 + (void*) memcpy::destination#5 ← phi( memcpy::@1/(void*) memcpy::destination#4 ) + (byte*) memcpy::src_end#2 ← phi( memcpy::@1/(byte*) memcpy::src_end#1 ) + (byte*) memcpy::dst#2 ← phi( memcpy::@1/(byte*) memcpy::dst#3 ) + (byte*) memcpy::src#3 ← phi( memcpy::@1/(byte*) memcpy::src#2 ) + *((byte*) memcpy::dst#2) ← *((byte*) memcpy::src#3) + (byte*) memcpy::dst#1 ← ++ (byte*) memcpy::dst#2 + (byte*) memcpy::src#1 ← ++ (byte*) memcpy::src#3 + to:memcpy::@1 +memcpy::@3: scope:[memcpy] from memcpy::@1 + (void*) memcpy::destination#3 ← phi( memcpy::@1/(void*) memcpy::destination#4 ) + (void*) memcpy::return#0 ← (void*) memcpy::destination#3 + to:memcpy::@return +memcpy::@return: scope:[memcpy] from memcpy::@3 + (void*) memcpy::return#4 ← phi( memcpy::@3/(void*) memcpy::return#0 ) + (void*) memcpy::return#1 ← (void*) memcpy::return#4 + return + to:@return + +(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num) +memset: scope:[memset] from cscroll::@5 cscroll::@6 main + (byte) memset::c#6 ← phi( cscroll::@5/(byte) memset::c#0 cscroll::@6/(byte) memset::c#1 main/(byte) memset::c#2 ) + (void*) memset::str#5 ← phi( cscroll::@5/(void*) memset::str#0 cscroll::@6/(void*) memset::str#1 main/(void*) memset::str#2 ) + (word) memset::num#3 ← phi( cscroll::@5/(word) memset::num#0 cscroll::@6/(word) memset::num#1 main/(word) memset::num#2 ) + (bool~) memset::$0 ← (word) memset::num#3 > (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::@3 + (void*) memset::str#3 ← phi( memset/(void*) memset::str#5 memset::@3/(void*) memset::str#6 ) + (void*) memset::return#0 ← (void*) memset::str#3 + to:memset::@return +memset::@2: scope:[memset] from memset + (byte) memset::c#5 ← phi( memset/(byte) memset::c#6 ) + (word) memset::num#4 ← phi( memset/(word) memset::num#3 ) + (void*) memset::str#4 ← phi( memset/(void*) memset::str#5 ) + (byte*~) memset::$4 ← (byte*)(void*) memset::str#4 + (byte*~) memset::$2 ← (byte*~) memset::$4 + (word) memset::num#4 + (byte*) memset::end#0 ← (byte*~) memset::$2 + (byte*) memset::dst#0 ← ((byte*)) (void*) memset::str#4 + to:memset::@3 +memset::@3: scope:[memset] from memset::@2 memset::@4 + (byte) memset::c#4 ← phi( memset::@2/(byte) memset::c#5 memset::@4/(byte) memset::c#3 ) + (void*) memset::str#6 ← phi( memset::@2/(void*) memset::str#4 memset::@4/(void*) memset::str#7 ) + (byte*) memset::end#1 ← phi( memset::@2/(byte*) memset::end#0 memset::@4/(byte*) memset::end#2 ) + (byte*) memset::dst#2 ← phi( memset::@2/(byte*) memset::dst#0 memset::@4/(byte*) memset::dst#1 ) + (bool~) memset::$3 ← (byte*) memset::dst#2 != (byte*) memset::end#1 + if((bool~) memset::$3) goto memset::@4 + to:memset::@1 +memset::@4: scope:[memset] from memset::@3 + (void*) memset::str#7 ← phi( memset::@3/(void*) memset::str#6 ) + (byte*) memset::end#2 ← phi( memset::@3/(byte*) memset::end#1 ) + (byte*) memset::dst#3 ← phi( memset::@3/(byte*) memset::dst#2 ) + (byte) memset::c#3 ← phi( memset::@3/(byte) memset::c#4 ) + *((byte*) memset::dst#3) ← (byte) memset::c#3 + (byte*) memset::dst#1 ← ++ (byte*) memset::dst#3 + to:memset::@3 +memset::@return: scope:[memset] from memset::@1 + (void*) memset::return#5 ← phi( memset::@1/(void*) memset::return#0 ) + (void*) memset::return#1 ← (void*) memset::return#5 + return + to:@return + +(byte*()) strupr((byte*) strupr::str) +strupr: scope:[strupr] from printf_number_buffer::@11 + (byte*) strupr::str#1 ← phi( printf_number_buffer::@11/(byte*) strupr::str#0 ) + (byte*) strupr::src#0 ← (byte*) strupr::str#1 + to:strupr::@1 +strupr::@1: scope:[strupr] from strupr strupr::@4 + (byte*) strupr::str#3 ← phi( strupr/(byte*) strupr::str#1 strupr::@4/(byte*) strupr::str#4 ) + (byte*) strupr::src#2 ← phi( strupr/(byte*) strupr::src#0 strupr::@4/(byte*) strupr::src#1 ) + (bool~) strupr::$1 ← (number) 0 != *((byte*) strupr::src#2) + if((bool~) strupr::$1) goto strupr::@2 + to:strupr::@3 +strupr::@2: scope:[strupr] from strupr::@1 + (byte*) strupr::str#5 ← phi( strupr::@1/(byte*) strupr::str#3 ) + (byte*) strupr::src#3 ← phi( strupr::@1/(byte*) strupr::src#2 ) + (byte) toupper::ch#0 ← *((byte*) strupr::src#3) + call toupper + (byte) toupper::return#3 ← (byte) toupper::return#2 + to:strupr::@4 +strupr::@4: scope:[strupr] from strupr::@2 + (byte*) strupr::str#4 ← phi( strupr::@2/(byte*) strupr::str#5 ) + (byte*) strupr::src#4 ← phi( strupr::@2/(byte*) strupr::src#3 ) + (byte) toupper::return#5 ← phi( strupr::@2/(byte) toupper::return#3 ) + (byte~) strupr::$0 ← (byte) toupper::return#5 + *((byte*) strupr::src#4) ← (byte~) strupr::$0 + (byte*) strupr::src#1 ← ++ (byte*) strupr::src#4 + to:strupr::@1 +strupr::@3: scope:[strupr] from strupr::@1 + (byte*) strupr::str#2 ← phi( strupr::@1/(byte*) strupr::str#3 ) + (byte*) strupr::return#0 ← (byte*) strupr::str#2 + to:strupr::@return +strupr::@return: scope:[strupr] from strupr::@3 + (byte*) strupr::return#3 ← phi( strupr::@3/(byte*) strupr::return#0 ) + (byte*) strupr::return#1 ← (byte*) strupr::return#3 + return + to:@return + +(word()) strlen((byte*) strlen::str) +strlen: scope:[strlen] from printf_number_buffer::@6 + (byte*) strlen::str#4 ← phi( printf_number_buffer::@6/(byte*) strlen::str#1 ) + (word) strlen::len#0 ← (word) 0 + to:strlen::@1 +strlen::@1: scope:[strlen] from strlen strlen::@2 + (word) strlen::len#4 ← phi( strlen/(word) strlen::len#0 strlen::@2/(word) strlen::len#1 ) + (byte*) strlen::str#2 ← phi( strlen/(byte*) strlen::str#4 strlen::@2/(byte*) strlen::str#0 ) + (bool~) strlen::$0 ← (number) 0 != *((byte*) strlen::str#2) + if((bool~) strlen::$0) goto strlen::@2 + to:strlen::@3 +strlen::@2: scope:[strlen] from strlen::@1 + (byte*) strlen::str#3 ← phi( strlen::@1/(byte*) strlen::str#2 ) + (word) strlen::len#2 ← phi( strlen::@1/(word) strlen::len#4 ) + (word) strlen::len#1 ← ++ (word) strlen::len#2 + (byte*) strlen::str#0 ← ++ (byte*) strlen::str#3 + to:strlen::@1 +strlen::@3: scope:[strlen] from strlen::@1 + (word) strlen::len#3 ← phi( strlen::@1/(word) strlen::len#4 ) + (word) strlen::return#0 ← (word) strlen::len#3 + to:strlen::@return +strlen::@return: scope:[strlen] from strlen::@3 + (word) strlen::return#3 ← phi( strlen::@3/(word) strlen::return#0 ) + (word) strlen::return#1 ← (word) strlen::return#3 + return + to:@return + +(word()) mul8u((byte) mul8u::a , (byte) mul8u::b) +mul8u: scope:[mul8u] from mul8s + (byte) mul8u::a#5 ← phi( mul8s/(byte) mul8u::a#1 ) + (byte) mul8u::b#1 ← phi( mul8s/(byte) mul8u::b#0 ) + (word) mul8u::res#0 ← (word) 0 + (word) mul8u::mb#0 ← (word)(byte) mul8u::b#1 + to:mul8u::@1 +mul8u::@1: scope:[mul8u] from mul8u mul8u::@4 + (word) mul8u::mb#5 ← phi( mul8u/(word) mul8u::mb#0 mul8u::@4/(word) mul8u::mb#1 ) + (word) mul8u::res#4 ← phi( mul8u/(word) mul8u::res#0 mul8u::@4/(word) mul8u::res#6 ) + (byte) mul8u::a#2 ← phi( mul8u/(byte) mul8u::a#5 mul8u::@4/(byte) mul8u::a#0 ) + (bool~) mul8u::$0 ← (byte) mul8u::a#2 != (number) 0 + if((bool~) mul8u::$0) goto mul8u::@2 + to:mul8u::@3 +mul8u::@2: scope:[mul8u] from mul8u::@1 + (word) mul8u::res#5 ← phi( mul8u::@1/(word) mul8u::res#4 ) + (word) mul8u::mb#4 ← phi( mul8u::@1/(word) mul8u::mb#5 ) + (byte) mul8u::a#3 ← phi( mul8u::@1/(byte) mul8u::a#2 ) + (number~) mul8u::$1 ← (byte) mul8u::a#3 & (number) 1 + (bool~) mul8u::$2 ← (number~) mul8u::$1 != (number) 0 + (bool~) mul8u::$3 ← ! (bool~) mul8u::$2 + if((bool~) mul8u::$3) goto mul8u::@4 + to:mul8u::@5 +mul8u::@3: scope:[mul8u] from mul8u::@1 + (word) mul8u::res#2 ← phi( mul8u::@1/(word) mul8u::res#4 ) + (word) mul8u::return#0 ← (word) mul8u::res#2 + to:mul8u::@return +mul8u::@4: scope:[mul8u] from mul8u::@2 mul8u::@5 + (word) mul8u::res#6 ← phi( mul8u::@2/(word) mul8u::res#5 mul8u::@5/(word) mul8u::res#1 ) + (word) mul8u::mb#2 ← phi( mul8u::@2/(word) mul8u::mb#4 mul8u::@5/(word) mul8u::mb#3 ) + (byte) mul8u::a#4 ← phi( mul8u::@2/(byte) mul8u::a#3 mul8u::@5/(byte) mul8u::a#6 ) + (byte~) mul8u::$5 ← (byte) mul8u::a#4 >> (number) 1 + (byte) mul8u::a#0 ← (byte~) mul8u::$5 + (word~) mul8u::$6 ← (word) mul8u::mb#2 << (number) 1 + (word) mul8u::mb#1 ← (word~) mul8u::$6 + to:mul8u::@1 +mul8u::@5: scope:[mul8u] from mul8u::@2 + (byte) mul8u::a#6 ← phi( mul8u::@2/(byte) mul8u::a#3 ) + (word) mul8u::mb#3 ← phi( mul8u::@2/(word) mul8u::mb#4 ) + (word) mul8u::res#3 ← phi( mul8u::@2/(word) mul8u::res#5 ) + (word~) mul8u::$4 ← (word) mul8u::res#3 + (word) mul8u::mb#3 + (word) mul8u::res#1 ← (word~) mul8u::$4 + to:mul8u::@4 +mul8u::@return: scope:[mul8u] from mul8u::@3 + (word) mul8u::return#3 ← phi( mul8u::@3/(word) mul8u::return#0 ) + (word) mul8u::return#1 ← (word) mul8u::return#3 + return + to:@return + +(signed word()) mul8s((signed byte) mul8s::a , (signed byte) mul8s::b) +mul8s: scope:[mul8s] from main::@13 main::@5 + (signed byte) mul8s::b#2 ← phi( main::@13/(signed byte) mul8s::b#1 main::@5/(signed byte) mul8s::b#0 ) + (signed byte) mul8s::a#2 ← phi( main::@13/(signed byte) mul8s::a#1 main::@5/(signed byte) mul8s::a#0 ) + (byte) mul8u::a#1 ← (byte)(signed byte) mul8s::a#2 + (byte) mul8u::b#0 ← (byte)(signed byte) mul8s::b#2 + call mul8u + (word) mul8u::return#2 ← (word) mul8u::return#1 + to:mul8s::@5 +mul8s::@5: scope:[mul8s] from mul8s + (signed byte) mul8s::b#5 ← phi( mul8s/(signed byte) mul8s::b#2 ) + (signed byte) mul8s::a#3 ← phi( mul8s/(signed byte) mul8s::a#2 ) + (word) mul8u::return#4 ← phi( mul8s/(word) mul8u::return#2 ) + (word~) mul8s::$0 ← (word) mul8u::return#4 + (word) mul8s::m#0 ← (word~) mul8s::$0 + (bool~) mul8s::$1 ← (signed byte) mul8s::a#3 < (number) 0 + (bool~) mul8s::$2 ← ! (bool~) mul8s::$1 + if((bool~) mul8s::$2) goto mul8s::@1 + to:mul8s::@3 +mul8s::@1: scope:[mul8s] from mul8s::@3 mul8s::@5 + (signed byte) mul8s::a#5 ← phi( mul8s::@3/(signed byte) mul8s::a#6 mul8s::@5/(signed byte) mul8s::a#3 ) + (word) mul8s::m#6 ← phi( mul8s::@3/(word) mul8s::m#1 mul8s::@5/(word) mul8s::m#0 ) + (signed byte) mul8s::b#3 ← phi( mul8s::@3/(signed byte) mul8s::b#4 mul8s::@5/(signed byte) mul8s::b#5 ) + (bool~) mul8s::$3 ← (signed byte) mul8s::b#3 < (number) 0 + (bool~) mul8s::$4 ← ! (bool~) mul8s::$3 + if((bool~) mul8s::$4) goto mul8s::@2 + to:mul8s::@4 +mul8s::@3: scope:[mul8s] from mul8s::@5 + (signed byte) mul8s::a#6 ← phi( mul8s::@5/(signed byte) mul8s::a#3 ) + (signed byte) mul8s::b#4 ← phi( mul8s::@5/(signed byte) mul8s::b#5 ) + (word) mul8s::m#3 ← phi( mul8s::@5/(word) mul8s::m#0 ) + (byte~) mul8s::$6 ← > (word) mul8s::m#3 + (byte~) mul8s::$13 ← (byte)(signed byte) mul8s::b#4 + (byte~) mul8s::$7 ← (byte~) mul8s::$6 - (byte~) mul8s::$13 + (byte~) mul8s::$11 ← (byte~) mul8s::$7 + (word) mul8s::m#1 ← (word) mul8s::m#3 hi= (byte~) mul8s::$11 + to:mul8s::@1 +mul8s::@2: scope:[mul8s] from mul8s::@1 mul8s::@4 + (word) mul8s::m#4 ← phi( mul8s::@1/(word) mul8s::m#6 mul8s::@4/(word) mul8s::m#2 ) + (signed word) mul8s::return#0 ← (signed word)(word) mul8s::m#4 + to:mul8s::@return +mul8s::@4: scope:[mul8s] from mul8s::@1 + (signed byte) mul8s::a#4 ← phi( mul8s::@1/(signed byte) mul8s::a#5 ) + (word) mul8s::m#5 ← phi( mul8s::@1/(word) mul8s::m#6 ) + (byte~) mul8s::$9 ← > (word) mul8s::m#5 + (byte~) mul8s::$14 ← (byte)(signed byte) mul8s::a#4 + (byte~) mul8s::$10 ← (byte~) mul8s::$9 - (byte~) mul8s::$14 + (byte~) mul8s::$12 ← (byte~) mul8s::$10 + (word) mul8s::m#2 ← (word) mul8s::m#5 hi= (byte~) mul8s::$12 + to:mul8s::@2 +mul8s::@return: scope:[mul8s] from mul8s::@2 + (signed word) mul8s::return#4 ← phi( mul8s::@2/(signed word) mul8s::return#0 ) + (signed word) mul8s::return#1 ← (signed word) mul8s::return#4 + return + to:@return +@1: scope:[] from @begin + (byte) conio_cursor_x ← (byte) 0 + (byte) conio_cursor_y ← (byte) 0 + (byte*) conio_cursor_text ← (const nomodify byte*) CONIO_SCREEN_TEXT + (byte*) conio_cursor_color ← (const nomodify byte*) CONIO_SCREEN_COLORS + (byte) conio_textcolor ← (const nomodify byte) CONIO_TEXTCOLOR_DEFAULT + (byte) conio_scroll_enable ← (byte) 1 + to:@2 + +(void()) gotoxy((byte) gotoxy::x , (byte) gotoxy::y) +gotoxy: scope:[gotoxy] from cscroll::@2 main::@3 + (byte) gotoxy::x#5 ← phi( cscroll::@2/(byte) gotoxy::x#1 main::@3/(byte) gotoxy::x#2 ) + (byte) gotoxy::y#3 ← phi( cscroll::@2/(byte) gotoxy::y#1 main::@3/(byte) gotoxy::y#2 ) + (bool~) gotoxy::$0 ← (byte) gotoxy::y#3 > (number) $19 + (bool~) gotoxy::$1 ← ! (bool~) gotoxy::$0 + if((bool~) gotoxy::$1) goto gotoxy::@1 + to:gotoxy::@3 +gotoxy::@1: scope:[gotoxy] from gotoxy gotoxy::@3 + (byte) gotoxy::y#5 ← phi( gotoxy/(byte) gotoxy::y#3 gotoxy::@3/(byte) gotoxy::y#0 ) + (byte) gotoxy::x#3 ← phi( gotoxy/(byte) gotoxy::x#5 gotoxy::@3/(byte) gotoxy::x#6 ) + (bool~) gotoxy::$2 ← (byte) gotoxy::x#3 >= (number) $28 + (bool~) gotoxy::$3 ← ! (bool~) gotoxy::$2 + if((bool~) gotoxy::$3) goto gotoxy::@2 + to:gotoxy::@4 +gotoxy::@3: scope:[gotoxy] from gotoxy + (byte) gotoxy::x#6 ← phi( gotoxy/(byte) gotoxy::x#5 ) + (byte) gotoxy::y#0 ← (number) 0 + to:gotoxy::@1 +gotoxy::@2: scope:[gotoxy] from gotoxy::@1 gotoxy::@4 + (byte) gotoxy::y#4 ← phi( gotoxy::@1/(byte) gotoxy::y#5 gotoxy::@4/(byte) gotoxy::y#6 ) + (byte) gotoxy::x#4 ← phi( gotoxy::@1/(byte) gotoxy::x#3 gotoxy::@4/(byte) gotoxy::x#0 ) + (byte) conio_cursor_x ← (byte) gotoxy::x#4 + (byte) conio_cursor_y ← (byte) gotoxy::y#4 + (word~) gotoxy::$8 ← (word)(byte) gotoxy::y#4 + (number~) gotoxy::$4 ← (word~) gotoxy::$8 * (number) $28 + (number~) gotoxy::$5 ← (number~) gotoxy::$4 + (byte) gotoxy::x#4 + (word) gotoxy::offset#0 ← (number~) gotoxy::$5 + (byte*~) gotoxy::$6 ← (const nomodify byte*) CONIO_SCREEN_TEXT + (word) gotoxy::offset#0 + (byte*) conio_cursor_text ← (byte*~) gotoxy::$6 + (byte*~) gotoxy::$7 ← (const nomodify byte*) CONIO_SCREEN_COLORS + (word) gotoxy::offset#0 + (byte*) conio_cursor_color ← (byte*~) gotoxy::$7 + to:gotoxy::@return +gotoxy::@4: scope:[gotoxy] from gotoxy::@1 + (byte) gotoxy::y#6 ← phi( gotoxy::@1/(byte) gotoxy::y#5 ) + (byte) gotoxy::x#0 ← (number) 0 + to:gotoxy::@2 +gotoxy::@return: scope:[gotoxy] from gotoxy::@2 + return + to:@return + +(void()) cputc((byte) cputc::c) +cputc: scope:[cputc] from cputs::@2 printf_number_buffer::@9 printf_padding::@2 + (byte) cputc::c#3 ← phi( cputs::@2/(byte) cputc::c#0 printf_number_buffer::@9/(byte) cputc::c#2 printf_padding::@2/(byte) cputc::c#1 ) + (bool~) cputc::$0 ← (byte) cputc::c#3 == (byte) ' +' + if((bool~) cputc::$0) goto cputc::@1 + to:cputc::@2 +cputc::@1: scope:[cputc] from cputc + call cputln + to:cputc::@4 +cputc::@4: scope:[cputc] from cputc::@1 + to:cputc::@return +cputc::@2: scope:[cputc] from cputc + (byte) cputc::c#4 ← phi( cputc/(byte) cputc::c#3 ) + *((byte*) conio_cursor_text) ← (byte) cputc::c#4 + (byte*) conio_cursor_text ← ++ (byte*) conio_cursor_text + *((byte*) conio_cursor_color) ← (byte) conio_textcolor + (byte*) conio_cursor_color ← ++ (byte*) conio_cursor_color + (byte) conio_cursor_x ← ++ (byte) conio_cursor_x + (bool~) cputc::$1 ← (byte) conio_cursor_x == (number) $28 + (bool~) cputc::$2 ← ! (bool~) cputc::$1 + if((bool~) cputc::$2) goto cputc::@return + to:cputc::@3 +cputc::@3: scope:[cputc] from cputc::@2 + (byte) conio_cursor_x ← (number) 0 + (byte) conio_cursor_y ← ++ (byte) conio_cursor_y + call cscroll + to:cputc::@5 +cputc::@5: scope:[cputc] from cputc::@3 + to:cputc::@return +cputc::@return: scope:[cputc] from cputc::@2 cputc::@4 cputc::@5 + return + to:@return + +(void()) cputln() +cputln: scope:[cputln] from cputc::@1 + (number~) cputln::$0 ← (number) $28 - (byte) conio_cursor_x + (word) cputln::ln_offset#0 ← (number~) cputln::$0 + (byte*~) cputln::$1 ← (byte*) conio_cursor_text + (word) cputln::ln_offset#0 + (byte*) conio_cursor_text ← (byte*~) cputln::$1 + (byte*~) cputln::$2 ← (byte*) conio_cursor_color + (word) cputln::ln_offset#0 + (byte*) conio_cursor_color ← (byte*~) cputln::$2 + (byte) conio_cursor_x ← (number) 0 + (byte) conio_cursor_y ← ++ (byte) conio_cursor_y + call cscroll + to:cputln::@1 +cputln::@1: scope:[cputln] from cputln + to:cputln::@return +cputln::@return: scope:[cputln] from cputln::@1 + return + to:@return + +(void()) cscroll() +cscroll: scope:[cscroll] from cputc::@3 cputln + (bool~) cscroll::$0 ← (byte) conio_cursor_y == (number) $19 + (bool~) cscroll::$1 ← ! (bool~) cscroll::$0 + if((bool~) cscroll::$1) goto cscroll::@return + to:cscroll::@1 +cscroll::@1: scope:[cscroll] from cscroll + (bool~) cscroll::$9 ← (number) 0 != (byte) conio_scroll_enable + if((bool~) cscroll::$9) goto cscroll::@3 + to:cscroll::@2 +cscroll::@3: scope:[cscroll] from cscroll::@1 + (void*) memcpy::destination#0 ← (void*)(const nomodify byte*) CONIO_SCREEN_TEXT + (void*) memcpy::source#0 ← (void*)(const nomodify byte*) CONIO_SCREEN_TEXT+(number) $28 + (word) memcpy::num#0 ← (number) $19*(number) $28-(number) $28 + call memcpy + (void*) memcpy::return#2 ← (void*) memcpy::return#1 + to:cscroll::@4 +cscroll::@4: scope:[cscroll] from cscroll::@3 + (void*) memcpy::destination#1 ← (void*)(const nomodify byte*) CONIO_SCREEN_COLORS + (void*) memcpy::source#1 ← (void*)(const nomodify byte*) CONIO_SCREEN_COLORS+(number) $28 + (word) memcpy::num#1 ← (number) $19*(number) $28-(number) $28 + call memcpy + (void*) memcpy::return#3 ← (void*) memcpy::return#1 + to:cscroll::@5 +cscroll::@5: scope:[cscroll] from cscroll::@4 + (void*) memset::str#0 ← (void*)(const nomodify byte*) CONIO_SCREEN_TEXT+(number) $19*(number) $28-(number) $28 + (byte) memset::c#0 ← (byte) ' ' + (word) memset::num#0 ← (number) $28 + call memset + (void*) memset::return#2 ← (void*) memset::return#1 + to:cscroll::@6 +cscroll::@6: scope:[cscroll] from cscroll::@5 + (void*) memset::str#1 ← (void*)(const nomodify byte*) CONIO_SCREEN_COLORS+(number) $19*(number) $28-(number) $28 + (byte) memset::c#1 ← (byte) conio_textcolor + (word) memset::num#1 ← (number) $28 + call memset + (void*) memset::return#3 ← (void*) memset::return#1 + to:cscroll::@7 +cscroll::@7: scope:[cscroll] from cscroll::@6 + (byte*~) cscroll::$7 ← (byte*) conio_cursor_text - (number) $28 + (byte*) conio_cursor_text ← (byte*~) cscroll::$7 + (byte*~) cscroll::$8 ← (byte*) conio_cursor_color - (number) $28 + (byte*) conio_cursor_color ← (byte*~) cscroll::$8 + (byte) conio_cursor_y ← -- (byte) conio_cursor_y + to:cscroll::@return +cscroll::@2: scope:[cscroll] from cscroll::@1 + (byte) gotoxy::x#1 ← (number) 0 + (byte) gotoxy::y#1 ← (number) 0 + call gotoxy + to:cscroll::@8 +cscroll::@8: scope:[cscroll] from cscroll::@2 + to:cscroll::@return +cscroll::@return: scope:[cscroll] from cscroll cscroll::@7 cscroll::@8 + return + to:@return + +(void()) cputs((to_nomodify byte*) cputs::s) +cputs: scope:[cputs] from main::@11 printf_number_buffer::@5 + (to_nomodify byte*) cputs::s#4 ← phi( main::@11/(to_nomodify byte*) cputs::s#2 printf_number_buffer::@5/(to_nomodify byte*) cputs::s#1 ) + (byte) cputs::c#0 ← (byte) 0 + to:cputs::@1 +cputs::@1: scope:[cputs] from cputs cputs::@3 + (to_nomodify byte*) cputs::s#3 ← phi( cputs/(to_nomodify byte*) cputs::s#4 cputs::@3/(to_nomodify byte*) cputs::s#5 ) + (byte) cputs::c#1 ← *((to_nomodify byte*) cputs::s#3) + (to_nomodify byte*) cputs::s#0 ← ++ (to_nomodify byte*) cputs::s#3 + (bool~) cputs::$1 ← (number) 0 != (byte) cputs::c#1 + if((bool~) cputs::$1) goto cputs::@2 + to:cputs::@return +cputs::@2: scope:[cputs] from cputs::@1 + (to_nomodify byte*) cputs::s#6 ← phi( cputs::@1/(to_nomodify byte*) cputs::s#0 ) + (byte) cputs::c#2 ← phi( cputs::@1/(byte) cputs::c#1 ) + (byte) cputc::c#0 ← (byte) cputs::c#2 + call cputc + to:cputs::@3 +cputs::@3: scope:[cputs] from cputs::@2 + (to_nomodify byte*) cputs::s#5 ← phi( cputs::@2/(to_nomodify byte*) cputs::s#6 ) + to:cputs::@1 +cputs::@return: scope:[cputs] from cputs::@1 + return + to:@return + +(void()) utoa((word) utoa::value , (byte*) utoa::buffer , (byte) utoa::radix) +utoa: scope:[utoa] from printf_uint::@3 + (byte*) utoa::buffer#21 ← phi( printf_uint::@3/(byte*) utoa::buffer#5 ) + (word) utoa::value#12 ← phi( printf_uint::@3/(word) utoa::value#1 ) + (byte) utoa::radix#1 ← phi( printf_uint::@3/(byte) utoa::radix#0 ) + (byte) utoa::max_digits#0 ← (byte) 0 + (word*) utoa::digit_values#0 ← (word*) 0 + (bool~) utoa::$0 ← (byte) utoa::radix#1 == (const byte) DECIMAL + if((bool~) utoa::$0) goto utoa::@1 + to:utoa::@6 +utoa::@1: scope:[utoa] from utoa + (byte*) utoa::buffer#17 ← phi( utoa/(byte*) utoa::buffer#21 ) + (word) utoa::value#8 ← phi( utoa/(word) utoa::value#12 ) + (byte) utoa::max_digits#1 ← (number) 5 + (word*) utoa::digit_values#1 ← (const word*) RADIX_DECIMAL_VALUES + to:utoa::@5 +utoa::@6: scope:[utoa] from utoa + (word) utoa::value#13 ← phi( utoa/(word) utoa::value#12 ) + (byte*) utoa::buffer#16 ← phi( utoa/(byte*) utoa::buffer#21 ) + (byte) utoa::radix#2 ← phi( utoa/(byte) utoa::radix#1 ) + (bool~) utoa::$1 ← (byte) utoa::radix#2 == (const byte) HEXADECIMAL + if((bool~) utoa::$1) goto utoa::@2 + to:utoa::@7 +utoa::@2: scope:[utoa] from utoa::@6 + (byte*) utoa::buffer#18 ← phi( utoa::@6/(byte*) utoa::buffer#16 ) + (word) utoa::value#9 ← phi( utoa::@6/(word) utoa::value#13 ) + (byte) utoa::max_digits#2 ← (number) 4 + (word*) utoa::digit_values#2 ← (const word*) RADIX_HEXADECIMAL_VALUES + to:utoa::@5 +utoa::@7: scope:[utoa] from utoa::@6 + (word) utoa::value#14 ← phi( utoa::@6/(word) utoa::value#13 ) + (byte*) utoa::buffer#13 ← phi( utoa::@6/(byte*) utoa::buffer#16 ) + (byte) utoa::radix#3 ← phi( utoa::@6/(byte) utoa::radix#2 ) + (bool~) utoa::$2 ← (byte) utoa::radix#3 == (const byte) OCTAL + if((bool~) utoa::$2) goto utoa::@3 + to:utoa::@8 +utoa::@3: scope:[utoa] from utoa::@7 + (byte*) utoa::buffer#19 ← phi( utoa::@7/(byte*) utoa::buffer#13 ) + (word) utoa::value#10 ← phi( utoa::@7/(word) utoa::value#14 ) + (byte) utoa::max_digits#3 ← (number) 6 + (word*) utoa::digit_values#3 ← (const word*) RADIX_OCTAL_VALUES + to:utoa::@5 +utoa::@8: scope:[utoa] from utoa::@7 + (word) utoa::value#15 ← phi( utoa::@7/(word) utoa::value#14 ) + (byte*) utoa::buffer#10 ← phi( utoa::@7/(byte*) utoa::buffer#13 ) + (byte) utoa::radix#4 ← phi( utoa::@7/(byte) utoa::radix#3 ) + (bool~) utoa::$3 ← (byte) utoa::radix#4 == (const byte) BINARY + if((bool~) utoa::$3) goto utoa::@4 + to:utoa::@9 +utoa::@4: scope:[utoa] from utoa::@8 + (byte*) utoa::buffer#20 ← phi( utoa::@8/(byte*) utoa::buffer#10 ) + (word) utoa::value#11 ← phi( utoa::@8/(word) utoa::value#15 ) + (byte) utoa::max_digits#4 ← (number) $10 + (word*) utoa::digit_values#4 ← (const word*) RADIX_BINARY_VALUES + to:utoa::@5 +utoa::@9: scope:[utoa] from utoa::@8 + (byte*) utoa::buffer#6 ← phi( utoa::@8/(byte*) utoa::buffer#10 ) + *((byte*) utoa::buffer#6) ← (byte) 'e' + (byte*) utoa::buffer#0 ← ++ (byte*) utoa::buffer#6 + *((byte*) utoa::buffer#0) ← (byte) 'r' + (byte*) utoa::buffer#1 ← ++ (byte*) utoa::buffer#0 + *((byte*) utoa::buffer#1) ← (byte) 'r' + (byte*) utoa::buffer#2 ← ++ (byte*) utoa::buffer#1 + *((byte*) utoa::buffer#2) ← (number) 0 + to:utoa::@return +utoa::@return: scope:[utoa] from utoa::@12 utoa::@9 + return + to:@return +utoa::@5: scope:[utoa] from utoa::@1 utoa::@2 utoa::@3 utoa::@4 + (byte*) utoa::buffer#15 ← phi( utoa::@1/(byte*) utoa::buffer#17 utoa::@2/(byte*) utoa::buffer#18 utoa::@3/(byte*) utoa::buffer#19 utoa::@4/(byte*) utoa::buffer#20 ) + (word) utoa::value#7 ← phi( utoa::@1/(word) utoa::value#8 utoa::@2/(word) utoa::value#9 utoa::@3/(word) utoa::value#10 utoa::@4/(word) utoa::value#11 ) + (word*) utoa::digit_values#8 ← phi( utoa::@1/(word*) utoa::digit_values#1 utoa::@2/(word*) utoa::digit_values#2 utoa::@3/(word*) utoa::digit_values#3 utoa::@4/(word*) utoa::digit_values#4 ) + (byte) utoa::max_digits#7 ← phi( utoa::@1/(byte) utoa::max_digits#1 utoa::@2/(byte) utoa::max_digits#2 utoa::@3/(byte) utoa::max_digits#3 utoa::@4/(byte) utoa::max_digits#4 ) + (byte) utoa::started#0 ← (byte) 0 + (byte) utoa::digit#0 ← (byte) 0 + to:utoa::@10 +utoa::@10: scope:[utoa] from utoa::@13 utoa::@5 + (byte*) utoa::buffer#11 ← phi( utoa::@13/(byte*) utoa::buffer#14 utoa::@5/(byte*) utoa::buffer#15 ) + (byte) utoa::started#3 ← phi( utoa::@13/(byte) utoa::started#4 utoa::@5/(byte) utoa::started#0 ) + (word) utoa::value#5 ← phi( utoa::@13/(word) utoa::value#6 utoa::@5/(word) utoa::value#7 ) + (word*) utoa::digit_values#6 ← phi( utoa::@13/(word*) utoa::digit_values#7 utoa::@5/(word*) utoa::digit_values#8 ) + (byte) utoa::digit#2 ← phi( utoa::@13/(byte) utoa::digit#1 utoa::@5/(byte) utoa::digit#0 ) + (byte) utoa::max_digits#5 ← phi( utoa::@13/(byte) utoa::max_digits#6 utoa::@5/(byte) utoa::max_digits#7 ) + (number~) utoa::$4 ← (byte) utoa::max_digits#5 - (number) 1 + (bool~) utoa::$5 ← (byte) utoa::digit#2 < (number~) utoa::$4 + if((bool~) utoa::$5) goto utoa::@11 + to:utoa::@12 +utoa::@11: scope:[utoa] from utoa::@10 + (byte) utoa::max_digits#8 ← phi( utoa::@10/(byte) utoa::max_digits#5 ) + (byte*) utoa::buffer#12 ← phi( utoa::@10/(byte*) utoa::buffer#11 ) + (byte) utoa::started#2 ← phi( utoa::@10/(byte) utoa::started#3 ) + (word) utoa::value#2 ← phi( utoa::@10/(word) utoa::value#5 ) + (word*) utoa::digit_values#5 ← phi( utoa::@10/(word*) utoa::digit_values#6 ) + (byte) utoa::digit#3 ← phi( utoa::@10/(byte) utoa::digit#2 ) + (byte~) utoa::$10 ← (byte) utoa::digit#3 * (const byte) SIZEOF_WORD + (word) utoa::digit_value#0 ← *((word*) utoa::digit_values#5 + (byte~) utoa::$10) + (bool~) utoa::$6 ← (word) utoa::value#2 >= (word) utoa::digit_value#0 + (bool~) utoa::$7 ← (byte) utoa::started#2 || (bool~) utoa::$6 + (bool~) utoa::$8 ← ! (bool~) utoa::$7 + if((bool~) utoa::$8) goto utoa::@13 + to:utoa::@14 +utoa::@12: scope:[utoa] from utoa::@10 + (byte*) utoa::buffer#7 ← phi( utoa::@10/(byte*) utoa::buffer#11 ) + (word) utoa::value#3 ← phi( utoa::@10/(word) utoa::value#5 ) + (byte~) utoa::$11 ← (byte)(word) utoa::value#3 + *((byte*) utoa::buffer#7) ← *((const byte*) DIGITS + (byte~) utoa::$11) + (byte*) utoa::buffer#3 ← ++ (byte*) utoa::buffer#7 + *((byte*) utoa::buffer#3) ← (number) 0 + to:utoa::@return +utoa::@13: scope:[utoa] from utoa::@11 utoa::@15 + (byte*) utoa::buffer#14 ← phi( utoa::@11/(byte*) utoa::buffer#12 utoa::@15/(byte*) utoa::buffer#4 ) + (byte) utoa::started#4 ← phi( utoa::@11/(byte) utoa::started#2 utoa::@15/(byte) utoa::started#1 ) + (word) utoa::value#6 ← phi( utoa::@11/(word) utoa::value#2 utoa::@15/(word) utoa::value#0 ) + (word*) utoa::digit_values#7 ← phi( utoa::@11/(word*) utoa::digit_values#5 utoa::@15/(word*) utoa::digit_values#9 ) + (byte) utoa::max_digits#6 ← phi( utoa::@11/(byte) utoa::max_digits#8 utoa::@15/(byte) utoa::max_digits#9 ) + (byte) utoa::digit#4 ← phi( utoa::@11/(byte) utoa::digit#3 utoa::@15/(byte) utoa::digit#5 ) + (byte) utoa::digit#1 ← ++ (byte) utoa::digit#4 + to:utoa::@10 +utoa::@14: scope:[utoa] from utoa::@11 + (word*) utoa::digit_values#10 ← phi( utoa::@11/(word*) utoa::digit_values#5 ) + (byte) utoa::max_digits#10 ← phi( utoa::@11/(byte) utoa::max_digits#8 ) + (byte) utoa::digit#6 ← phi( utoa::@11/(byte) utoa::digit#3 ) + (word) utoa::digit_value#1 ← phi( utoa::@11/(word) utoa::digit_value#0 ) + (word) utoa::value#4 ← phi( utoa::@11/(word) utoa::value#2 ) + (byte*) utoa::buffer#8 ← phi( utoa::@11/(byte*) utoa::buffer#12 ) + (byte*) utoa_append::buffer#0 ← (byte*) utoa::buffer#8 + (word) utoa_append::value#0 ← (word) utoa::value#4 + (word) utoa_append::sub#0 ← (word) utoa::digit_value#1 + call utoa_append + (word) utoa_append::return#0 ← (word) utoa_append::return#2 + to:utoa::@15 +utoa::@15: scope:[utoa] from utoa::@14 + (word*) utoa::digit_values#9 ← phi( utoa::@14/(word*) utoa::digit_values#10 ) + (byte) utoa::max_digits#9 ← phi( utoa::@14/(byte) utoa::max_digits#10 ) + (byte) utoa::digit#5 ← phi( utoa::@14/(byte) utoa::digit#6 ) + (byte*) utoa::buffer#9 ← phi( utoa::@14/(byte*) utoa::buffer#8 ) + (word) utoa_append::return#3 ← phi( utoa::@14/(word) utoa_append::return#0 ) + (word~) utoa::$9 ← (word) utoa_append::return#3 + (word) utoa::value#0 ← (word~) utoa::$9 + (byte*) utoa::buffer#4 ← ++ (byte*) utoa::buffer#9 + (byte) utoa::started#1 ← (number) 1 + to:utoa::@13 + +(word()) utoa_append((byte*) utoa_append::buffer , (word) utoa_append::value , (word) utoa_append::sub) +utoa_append: scope:[utoa_append] from utoa::@14 + (byte*) utoa_append::buffer#3 ← phi( utoa::@14/(byte*) utoa_append::buffer#0 ) + (word) utoa_append::sub#3 ← phi( utoa::@14/(word) utoa_append::sub#0 ) + (word) utoa_append::value#5 ← phi( utoa::@14/(word) utoa_append::value#0 ) + (byte) utoa_append::digit#0 ← (byte) 0 + to:utoa_append::@1 +utoa_append::@1: scope:[utoa_append] from utoa_append utoa_append::@2 + (byte*) utoa_append::buffer#2 ← phi( utoa_append/(byte*) utoa_append::buffer#3 utoa_append::@2/(byte*) utoa_append::buffer#4 ) + (byte) utoa_append::digit#4 ← phi( utoa_append/(byte) utoa_append::digit#0 utoa_append::@2/(byte) utoa_append::digit#1 ) + (word) utoa_append::sub#1 ← phi( utoa_append/(word) utoa_append::sub#3 utoa_append::@2/(word) utoa_append::sub#2 ) + (word) utoa_append::value#2 ← phi( utoa_append/(word) utoa_append::value#5 utoa_append::@2/(word) utoa_append::value#1 ) + (bool~) utoa_append::$0 ← (word) utoa_append::value#2 >= (word) utoa_append::sub#1 + if((bool~) utoa_append::$0) goto utoa_append::@2 + to:utoa_append::@3 +utoa_append::@2: scope:[utoa_append] from utoa_append::@1 + (byte*) utoa_append::buffer#4 ← phi( utoa_append::@1/(byte*) utoa_append::buffer#2 ) + (word) utoa_append::sub#2 ← phi( utoa_append::@1/(word) utoa_append::sub#1 ) + (word) utoa_append::value#3 ← phi( utoa_append::@1/(word) utoa_append::value#2 ) + (byte) utoa_append::digit#2 ← phi( utoa_append::@1/(byte) utoa_append::digit#4 ) + (byte) utoa_append::digit#1 ← ++ (byte) utoa_append::digit#2 + (word) utoa_append::value#1 ← (word) utoa_append::value#3 - (word) utoa_append::sub#2 + to:utoa_append::@1 +utoa_append::@3: scope:[utoa_append] from utoa_append::@1 + (word) utoa_append::value#4 ← phi( utoa_append::@1/(word) utoa_append::value#2 ) + (byte*) utoa_append::buffer#1 ← phi( utoa_append::@1/(byte*) utoa_append::buffer#2 ) + (byte) utoa_append::digit#3 ← phi( utoa_append::@1/(byte) utoa_append::digit#4 ) + *((byte*) utoa_append::buffer#1) ← *((const byte*) DIGITS + (byte) utoa_append::digit#3) + (word) utoa_append::return#1 ← (word) utoa_append::value#4 + to:utoa_append::@return +utoa_append::@return: scope:[utoa_append] from utoa_append::@3 + (word) utoa_append::return#4 ← phi( utoa_append::@3/(word) utoa_append::return#1 ) + (word) utoa_append::return#2 ← (word) utoa_append::return#4 + return + to:@return + +(void()) printf_padding((byte) printf_padding::pad , (byte) printf_padding::length) +printf_padding: scope:[printf_padding] from printf_number_buffer::@10 printf_number_buffer::@12 printf_number_buffer::@8 + (byte) printf_padding::pad#5 ← phi( printf_number_buffer::@10/(byte) printf_padding::pad#1 printf_number_buffer::@12/(byte) printf_padding::pad#2 printf_number_buffer::@8/(byte) printf_padding::pad#0 ) + (byte) printf_padding::length#4 ← phi( printf_number_buffer::@10/(byte) printf_padding::length#1 printf_number_buffer::@12/(byte) printf_padding::length#2 printf_number_buffer::@8/(byte) printf_padding::length#0 ) + (byte) printf_padding::i#0 ← (byte) 0 + to:printf_padding::@1 +printf_padding::@1: scope:[printf_padding] from printf_padding printf_padding::@3 + (byte) printf_padding::pad#4 ← phi( printf_padding/(byte) printf_padding::pad#5 printf_padding::@3/(byte) printf_padding::pad#6 ) + (byte) printf_padding::length#3 ← phi( printf_padding/(byte) printf_padding::length#4 printf_padding::@3/(byte) printf_padding::length#5 ) + (byte) printf_padding::i#2 ← phi( printf_padding/(byte) printf_padding::i#0 printf_padding::@3/(byte) printf_padding::i#1 ) + (bool~) printf_padding::$0 ← (byte) printf_padding::i#2 < (byte) printf_padding::length#3 + if((bool~) printf_padding::$0) goto printf_padding::@2 + to:printf_padding::@return +printf_padding::@2: scope:[printf_padding] from printf_padding::@1 + (byte) printf_padding::length#6 ← phi( printf_padding::@1/(byte) printf_padding::length#3 ) + (byte) printf_padding::i#4 ← phi( printf_padding::@1/(byte) printf_padding::i#2 ) + (byte) printf_padding::pad#3 ← phi( printf_padding::@1/(byte) printf_padding::pad#4 ) + (byte) cputc::c#1 ← (byte) printf_padding::pad#3 + call cputc + to:printf_padding::@3 +printf_padding::@3: scope:[printf_padding] from printf_padding::@2 + (byte) printf_padding::pad#6 ← phi( printf_padding::@2/(byte) printf_padding::pad#3 ) + (byte) printf_padding::length#5 ← phi( printf_padding::@2/(byte) printf_padding::length#6 ) + (byte) printf_padding::i#3 ← phi( printf_padding::@2/(byte) printf_padding::i#4 ) + (byte) printf_padding::i#1 ← ++ (byte) printf_padding::i#3 + to:printf_padding::@1 +printf_padding::@return: scope:[printf_padding] from printf_padding::@1 + return + to:@return + +(void()) printf_uint((word) printf_uint::uvalue , (byte) printf_uint::format_min_length , (byte) printf_uint::format_justify_left , (byte) printf_uint::format_sign_always , (byte) printf_uint::format_zero_padding , (byte) printf_uint::format_upper_case , (byte) printf_uint::format_radix) +printf_uint: scope:[printf_uint] from main::@10 + (byte) printf_uint::format_upper_case#5 ← phi( main::@10/(byte) printf_uint::format_upper_case#0 ) + (byte) printf_uint::format_zero_padding#5 ← phi( main::@10/(byte) printf_uint::format_zero_padding#0 ) + (byte) printf_uint::format_justify_left#5 ← phi( main::@10/(byte) printf_uint::format_justify_left#0 ) + (byte) printf_uint::format_min_length#5 ← phi( main::@10/(byte) printf_uint::format_min_length#0 ) + (byte) printf_uint::format_radix#5 ← phi( main::@10/(byte) printf_uint::format_radix#0 ) + (word) printf_uint::uvalue#4 ← phi( main::@10/(word) printf_uint::uvalue#0 ) + (byte) printf_uint::format_sign_always#1 ← phi( main::@10/(byte) printf_uint::format_sign_always#0 ) + (bool~) printf_uint::$5 ← (number) 0 != (byte) printf_uint::format_sign_always#1 + if((bool~) printf_uint::$5) goto printf_uint::@1 + to:printf_uint::@2 +printf_uint::@1: scope:[printf_uint] from printf_uint + (byte) printf_uint::format_upper_case#3 ← phi( printf_uint/(byte) printf_uint::format_upper_case#5 ) + (byte) printf_uint::format_zero_padding#3 ← phi( printf_uint/(byte) printf_uint::format_zero_padding#5 ) + (byte) printf_uint::format_sign_always#4 ← phi( printf_uint/(byte) printf_uint::format_sign_always#1 ) + (byte) printf_uint::format_justify_left#3 ← phi( printf_uint/(byte) printf_uint::format_justify_left#5 ) + (byte) printf_uint::format_min_length#3 ← phi( printf_uint/(byte) printf_uint::format_min_length#5 ) + (byte) printf_uint::format_radix#3 ← phi( printf_uint/(byte) printf_uint::format_radix#5 ) + (word) printf_uint::uvalue#2 ← phi( printf_uint/(word) printf_uint::uvalue#4 ) + (byte~) printf_uint::$1 ← (byte) '+' + to:printf_uint::@3 +printf_uint::@2: scope:[printf_uint] from printf_uint + (byte) printf_uint::format_upper_case#4 ← phi( printf_uint/(byte) printf_uint::format_upper_case#5 ) + (byte) printf_uint::format_zero_padding#4 ← phi( printf_uint/(byte) printf_uint::format_zero_padding#5 ) + (byte) printf_uint::format_sign_always#5 ← phi( printf_uint/(byte) printf_uint::format_sign_always#1 ) + (byte) printf_uint::format_justify_left#4 ← phi( printf_uint/(byte) printf_uint::format_justify_left#5 ) + (byte) printf_uint::format_min_length#4 ← phi( printf_uint/(byte) printf_uint::format_min_length#5 ) + (byte) printf_uint::format_radix#4 ← phi( printf_uint/(byte) printf_uint::format_radix#5 ) + (word) printf_uint::uvalue#3 ← phi( printf_uint/(word) printf_uint::uvalue#4 ) + (number~) printf_uint::$0 ← (number) 0 + to:printf_uint::@3 +printf_uint::@3: scope:[printf_uint] from printf_uint::@1 printf_uint::@2 + (byte) printf_uint::format_upper_case#2 ← phi( printf_uint::@1/(byte) printf_uint::format_upper_case#3 printf_uint::@2/(byte) printf_uint::format_upper_case#4 ) + (byte) printf_uint::format_zero_padding#2 ← phi( printf_uint::@1/(byte) printf_uint::format_zero_padding#3 printf_uint::@2/(byte) printf_uint::format_zero_padding#4 ) + (byte) printf_uint::format_sign_always#3 ← phi( printf_uint::@1/(byte) printf_uint::format_sign_always#4 printf_uint::@2/(byte) printf_uint::format_sign_always#5 ) + (byte) printf_uint::format_justify_left#2 ← phi( printf_uint::@1/(byte) printf_uint::format_justify_left#3 printf_uint::@2/(byte) printf_uint::format_justify_left#4 ) + (byte) printf_uint::format_min_length#2 ← phi( printf_uint::@1/(byte) printf_uint::format_min_length#3 printf_uint::@2/(byte) printf_uint::format_min_length#4 ) + (byte) printf_uint::format_radix#1 ← phi( printf_uint::@1/(byte) printf_uint::format_radix#3 printf_uint::@2/(byte) printf_uint::format_radix#4 ) + (word) printf_uint::uvalue#1 ← phi( printf_uint::@1/(word) printf_uint::uvalue#2 printf_uint::@2/(word) printf_uint::uvalue#3 ) + (number~) printf_uint::$2 ← phi( printf_uint::@1/(byte~) printf_uint::$1 printf_uint::@2/(number~) printf_uint::$0 ) + *((byte*)&(struct printf_buffer_number) printf_buffer+(const byte) OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_SIGN) ← (number~) printf_uint::$2 + (word) utoa::value#1 ← (word) printf_uint::uvalue#1 + (byte*) utoa::buffer#5 ← (byte*)&(struct printf_buffer_number) printf_buffer+(const byte) OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_DIGITS + (byte) utoa::radix#0 ← (byte) printf_uint::format_radix#1 + call utoa + to:printf_uint::@4 +printf_uint::@4: scope:[printf_uint] from printf_uint::@3 + (byte) printf_uint::format_radix#2 ← phi( printf_uint::@3/(byte) printf_uint::format_radix#1 ) + (byte) printf_uint::format_upper_case#1 ← phi( printf_uint::@3/(byte) printf_uint::format_upper_case#2 ) + (byte) printf_uint::format_zero_padding#1 ← phi( printf_uint::@3/(byte) printf_uint::format_zero_padding#2 ) + (byte) printf_uint::format_sign_always#2 ← phi( printf_uint::@3/(byte) printf_uint::format_sign_always#3 ) + (byte) printf_uint::format_justify_left#1 ← phi( printf_uint::@3/(byte) printf_uint::format_justify_left#2 ) + (byte) printf_uint::format_min_length#1 ← phi( printf_uint::@3/(byte) printf_uint::format_min_length#2 ) + (byte) printf_number_buffer::buffer_sign#0 ← *((byte*)&(struct printf_buffer_number) printf_buffer+(const byte) OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_SIGN) + (byte*) printf_number_buffer::buffer_digits#0 ← (byte*)&(struct printf_buffer_number) printf_buffer+(const byte) OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_DIGITS + (byte) printf_number_buffer::format_min_length#0 ← (byte) printf_uint::format_min_length#1 + (byte) printf_number_buffer::format_justify_left#0 ← (byte) printf_uint::format_justify_left#1 + (byte) printf_number_buffer::format_sign_always#0 ← (byte) printf_uint::format_sign_always#2 + (byte) printf_number_buffer::format_zero_padding#0 ← (byte) printf_uint::format_zero_padding#1 + (byte) printf_number_buffer::format_upper_case#0 ← (byte) printf_uint::format_upper_case#1 + (byte) printf_number_buffer::format_radix#0 ← (byte) printf_uint::format_radix#2 + call printf_number_buffer + to:printf_uint::@5 +printf_uint::@5: scope:[printf_uint] from printf_uint::@4 + to:printf_uint::@return +printf_uint::@return: scope:[printf_uint] from printf_uint::@5 + return + to:@return + +(void()) printf_number_buffer((byte) printf_number_buffer::buffer_sign , (byte*) printf_number_buffer::buffer_digits , (byte) printf_number_buffer::format_min_length , (byte) printf_number_buffer::format_justify_left , (byte) printf_number_buffer::format_sign_always , (byte) printf_number_buffer::format_zero_padding , (byte) printf_number_buffer::format_upper_case , (byte) printf_number_buffer::format_radix) +printf_number_buffer: scope:[printf_number_buffer] from printf_uint::@4 + (byte) printf_number_buffer::format_upper_case#10 ← phi( printf_uint::@4/(byte) printf_number_buffer::format_upper_case#0 ) + (byte) printf_number_buffer::buffer_sign#7 ← phi( printf_uint::@4/(byte) printf_number_buffer::buffer_sign#0 ) + (byte*) printf_number_buffer::buffer_digits#4 ← phi( printf_uint::@4/(byte*) printf_number_buffer::buffer_digits#0 ) + (byte) printf_number_buffer::format_zero_padding#4 ← phi( printf_uint::@4/(byte) printf_number_buffer::format_zero_padding#0 ) + (byte) printf_number_buffer::format_justify_left#3 ← phi( printf_uint::@4/(byte) printf_number_buffer::format_justify_left#0 ) + (byte) printf_number_buffer::format_min_length#1 ← phi( printf_uint::@4/(byte) printf_number_buffer::format_min_length#0 ) + (signed byte) printf_number_buffer::padding#0 ← (signed byte) 0 + (bool~) printf_number_buffer::$26 ← (number) 0 != (byte) printf_number_buffer::format_min_length#1 + (bool~) printf_number_buffer::$0 ← ! (bool~) printf_number_buffer::$26 + if((bool~) printf_number_buffer::$0) goto printf_number_buffer::@1 + to:printf_number_buffer::@6 +printf_number_buffer::@1: scope:[printf_number_buffer] from printf_number_buffer printf_number_buffer::@13 printf_number_buffer::@14 + (byte*) printf_number_buffer::buffer_digits#12 ← phi( printf_number_buffer/(byte*) printf_number_buffer::buffer_digits#4 printf_number_buffer::@13/(byte*) printf_number_buffer::buffer_digits#15 printf_number_buffer::@14/(byte*) printf_number_buffer::buffer_digits#16 ) + (byte) printf_number_buffer::format_upper_case#7 ← phi( printf_number_buffer/(byte) printf_number_buffer::format_upper_case#10 printf_number_buffer::@13/(byte) printf_number_buffer::format_upper_case#11 printf_number_buffer::@14/(byte) printf_number_buffer::format_upper_case#12 ) + (byte) printf_number_buffer::buffer_sign#5 ← phi( printf_number_buffer/(byte) printf_number_buffer::buffer_sign#7 printf_number_buffer::@13/(byte) printf_number_buffer::buffer_sign#8 printf_number_buffer::@14/(byte) printf_number_buffer::buffer_sign#9 ) + (signed byte) printf_number_buffer::padding#3 ← phi( printf_number_buffer/(signed byte) printf_number_buffer::padding#0 printf_number_buffer::@13/(signed byte) printf_number_buffer::padding#1 printf_number_buffer::@14/(signed byte) printf_number_buffer::padding#2 ) + (byte) printf_number_buffer::format_zero_padding#1 ← phi( printf_number_buffer/(byte) printf_number_buffer::format_zero_padding#4 printf_number_buffer::@13/(byte) printf_number_buffer::format_zero_padding#5 printf_number_buffer::@14/(byte) printf_number_buffer::format_zero_padding#6 ) + (byte) printf_number_buffer::format_justify_left#1 ← phi( printf_number_buffer/(byte) printf_number_buffer::format_justify_left#3 printf_number_buffer::@13/(byte) printf_number_buffer::format_justify_left#4 printf_number_buffer::@14/(byte) printf_number_buffer::format_justify_left#5 ) + (bool~) printf_number_buffer::$27 ← (number) 0 != (byte) printf_number_buffer::format_justify_left#1 + (bool~) printf_number_buffer::$1 ← ! (bool~) printf_number_buffer::$27 + (bool~) printf_number_buffer::$28 ← (number) 0 != (byte) printf_number_buffer::format_zero_padding#1 + (bool~) printf_number_buffer::$2 ← ! (bool~) printf_number_buffer::$28 + (bool~) printf_number_buffer::$3 ← (bool~) printf_number_buffer::$1 && (bool~) printf_number_buffer::$2 + (bool~) printf_number_buffer::$4 ← (bool~) printf_number_buffer::$3 && (signed byte) printf_number_buffer::padding#3 + (bool~) printf_number_buffer::$5 ← ! (bool~) printf_number_buffer::$4 + if((bool~) printf_number_buffer::$5) goto printf_number_buffer::@2 + to:printf_number_buffer::@8 +printf_number_buffer::@6: scope:[printf_number_buffer] from printf_number_buffer + (byte) printf_number_buffer::format_upper_case#16 ← phi( printf_number_buffer/(byte) printf_number_buffer::format_upper_case#10 ) + (byte) printf_number_buffer::format_zero_padding#16 ← phi( printf_number_buffer/(byte) printf_number_buffer::format_zero_padding#4 ) + (byte) printf_number_buffer::format_justify_left#11 ← phi( printf_number_buffer/(byte) printf_number_buffer::format_justify_left#3 ) + (byte) printf_number_buffer::format_min_length#5 ← phi( printf_number_buffer/(byte) printf_number_buffer::format_min_length#1 ) + (byte) printf_number_buffer::buffer_sign#4 ← phi( printf_number_buffer/(byte) printf_number_buffer::buffer_sign#7 ) + (byte*) printf_number_buffer::buffer_digits#1 ← phi( printf_number_buffer/(byte*) printf_number_buffer::buffer_digits#4 ) + (byte*) strlen::str#1 ← (byte*) printf_number_buffer::buffer_digits#1 + call strlen + (word) strlen::return#2 ← (word) strlen::return#1 + to:printf_number_buffer::@15 +printf_number_buffer::@15: scope:[printf_number_buffer] from printf_number_buffer::@6 + (byte*) printf_number_buffer::buffer_digits#18 ← phi( printf_number_buffer::@6/(byte*) printf_number_buffer::buffer_digits#1 ) + (byte) printf_number_buffer::format_upper_case#14 ← phi( printf_number_buffer::@6/(byte) printf_number_buffer::format_upper_case#16 ) + (byte) printf_number_buffer::format_zero_padding#10 ← phi( printf_number_buffer::@6/(byte) printf_number_buffer::format_zero_padding#16 ) + (byte) printf_number_buffer::format_justify_left#7 ← phi( printf_number_buffer::@6/(byte) printf_number_buffer::format_justify_left#11 ) + (byte) printf_number_buffer::format_min_length#3 ← phi( printf_number_buffer::@6/(byte) printf_number_buffer::format_min_length#5 ) + (byte) printf_number_buffer::buffer_sign#1 ← phi( printf_number_buffer::@6/(byte) printf_number_buffer::buffer_sign#4 ) + (word) strlen::return#4 ← phi( printf_number_buffer::@6/(word) strlen::return#2 ) + (word~) printf_number_buffer::$19 ← (word) strlen::return#4 + (signed byte) printf_number_buffer::len#0 ← (signed byte)(word~) printf_number_buffer::$19 + (bool~) printf_number_buffer::$29 ← (number) 0 != (byte) printf_number_buffer::buffer_sign#1 + (bool~) printf_number_buffer::$20 ← ! (bool~) printf_number_buffer::$29 + if((bool~) printf_number_buffer::$20) goto printf_number_buffer::@13 + to:printf_number_buffer::@7 +printf_number_buffer::@13: scope:[printf_number_buffer] from printf_number_buffer::@15 printf_number_buffer::@7 + (byte*) printf_number_buffer::buffer_digits#15 ← phi( printf_number_buffer::@15/(byte*) printf_number_buffer::buffer_digits#18 printf_number_buffer::@7/(byte*) printf_number_buffer::buffer_digits#19 ) + (byte) printf_number_buffer::format_upper_case#11 ← phi( printf_number_buffer::@15/(byte) printf_number_buffer::format_upper_case#14 printf_number_buffer::@7/(byte) printf_number_buffer::format_upper_case#15 ) + (byte) printf_number_buffer::buffer_sign#8 ← phi( printf_number_buffer::@15/(byte) printf_number_buffer::buffer_sign#1 printf_number_buffer::@7/(byte) printf_number_buffer::buffer_sign#11 ) + (byte) printf_number_buffer::format_zero_padding#5 ← phi( printf_number_buffer::@15/(byte) printf_number_buffer::format_zero_padding#10 printf_number_buffer::@7/(byte) printf_number_buffer::format_zero_padding#11 ) + (byte) printf_number_buffer::format_justify_left#4 ← phi( printf_number_buffer::@15/(byte) printf_number_buffer::format_justify_left#7 printf_number_buffer::@7/(byte) printf_number_buffer::format_justify_left#8 ) + (signed byte) printf_number_buffer::len#2 ← phi( printf_number_buffer::@15/(signed byte) printf_number_buffer::len#0 printf_number_buffer::@7/(signed byte) printf_number_buffer::len#1 ) + (byte) printf_number_buffer::format_min_length#2 ← phi( printf_number_buffer::@15/(byte) printf_number_buffer::format_min_length#3 printf_number_buffer::@7/(byte) printf_number_buffer::format_min_length#4 ) + (signed byte~) printf_number_buffer::$25 ← (signed byte)(byte) printf_number_buffer::format_min_length#2 + (signed byte~) printf_number_buffer::$21 ← (signed byte~) printf_number_buffer::$25 - (signed byte) printf_number_buffer::len#2 + (signed byte) printf_number_buffer::padding#1 ← (signed byte~) printf_number_buffer::$21 + (bool~) printf_number_buffer::$22 ← (signed byte) printf_number_buffer::padding#1 < (number) 0 + (bool~) printf_number_buffer::$23 ← ! (bool~) printf_number_buffer::$22 + if((bool~) printf_number_buffer::$23) goto printf_number_buffer::@1 + to:printf_number_buffer::@14 +printf_number_buffer::@7: scope:[printf_number_buffer] from printf_number_buffer::@15 + (byte*) printf_number_buffer::buffer_digits#19 ← phi( printf_number_buffer::@15/(byte*) printf_number_buffer::buffer_digits#18 ) + (byte) printf_number_buffer::format_upper_case#15 ← phi( printf_number_buffer::@15/(byte) printf_number_buffer::format_upper_case#14 ) + (byte) printf_number_buffer::buffer_sign#11 ← phi( printf_number_buffer::@15/(byte) printf_number_buffer::buffer_sign#1 ) + (byte) printf_number_buffer::format_zero_padding#11 ← phi( printf_number_buffer::@15/(byte) printf_number_buffer::format_zero_padding#10 ) + (byte) printf_number_buffer::format_justify_left#8 ← phi( printf_number_buffer::@15/(byte) printf_number_buffer::format_justify_left#7 ) + (byte) printf_number_buffer::format_min_length#4 ← phi( printf_number_buffer::@15/(byte) printf_number_buffer::format_min_length#3 ) + (signed byte) printf_number_buffer::len#3 ← phi( printf_number_buffer::@15/(signed byte) printf_number_buffer::len#0 ) + (signed byte) printf_number_buffer::len#1 ← ++ (signed byte) printf_number_buffer::len#3 + to:printf_number_buffer::@13 +printf_number_buffer::@14: scope:[printf_number_buffer] from printf_number_buffer::@13 + (byte*) printf_number_buffer::buffer_digits#16 ← phi( printf_number_buffer::@13/(byte*) printf_number_buffer::buffer_digits#15 ) + (byte) printf_number_buffer::format_upper_case#12 ← phi( printf_number_buffer::@13/(byte) printf_number_buffer::format_upper_case#11 ) + (byte) printf_number_buffer::buffer_sign#9 ← phi( printf_number_buffer::@13/(byte) printf_number_buffer::buffer_sign#8 ) + (byte) printf_number_buffer::format_zero_padding#6 ← phi( printf_number_buffer::@13/(byte) printf_number_buffer::format_zero_padding#5 ) + (byte) printf_number_buffer::format_justify_left#5 ← phi( printf_number_buffer::@13/(byte) printf_number_buffer::format_justify_left#4 ) + (signed byte) printf_number_buffer::padding#2 ← (number) 0 + to:printf_number_buffer::@1 +printf_number_buffer::@2: scope:[printf_number_buffer] from printf_number_buffer::@1 printf_number_buffer::@16 + (byte) printf_number_buffer::format_justify_left#16 ← phi( printf_number_buffer::@1/(byte) printf_number_buffer::format_justify_left#1 printf_number_buffer::@16/(byte) printf_number_buffer::format_justify_left#18 ) + (byte*) printf_number_buffer::buffer_digits#10 ← phi( printf_number_buffer::@1/(byte*) printf_number_buffer::buffer_digits#12 printf_number_buffer::@16/(byte*) printf_number_buffer::buffer_digits#13 ) + (byte) printf_number_buffer::format_upper_case#5 ← phi( printf_number_buffer::@1/(byte) printf_number_buffer::format_upper_case#7 printf_number_buffer::@16/(byte) printf_number_buffer::format_upper_case#8 ) + (signed byte) printf_number_buffer::padding#10 ← phi( printf_number_buffer::@1/(signed byte) printf_number_buffer::padding#3 printf_number_buffer::@16/(signed byte) printf_number_buffer::padding#12 ) + (byte) printf_number_buffer::format_zero_padding#8 ← phi( printf_number_buffer::@1/(byte) printf_number_buffer::format_zero_padding#1 printf_number_buffer::@16/(byte) printf_number_buffer::format_zero_padding#12 ) + (byte) printf_number_buffer::buffer_sign#2 ← phi( printf_number_buffer::@1/(byte) printf_number_buffer::buffer_sign#5 printf_number_buffer::@16/(byte) printf_number_buffer::buffer_sign#6 ) + (bool~) printf_number_buffer::$30 ← (number) 0 != (byte) printf_number_buffer::buffer_sign#2 + (bool~) printf_number_buffer::$7 ← ! (bool~) printf_number_buffer::$30 + if((bool~) printf_number_buffer::$7) goto printf_number_buffer::@3 + to:printf_number_buffer::@9 +printf_number_buffer::@8: scope:[printf_number_buffer] from printf_number_buffer::@1 + (byte) printf_number_buffer::format_justify_left#20 ← phi( printf_number_buffer::@1/(byte) printf_number_buffer::format_justify_left#1 ) + (byte*) printf_number_buffer::buffer_digits#17 ← phi( printf_number_buffer::@1/(byte*) printf_number_buffer::buffer_digits#12 ) + (byte) printf_number_buffer::format_upper_case#13 ← phi( printf_number_buffer::@1/(byte) printf_number_buffer::format_upper_case#7 ) + (byte) printf_number_buffer::format_zero_padding#17 ← phi( printf_number_buffer::@1/(byte) printf_number_buffer::format_zero_padding#1 ) + (byte) printf_number_buffer::buffer_sign#10 ← phi( printf_number_buffer::@1/(byte) printf_number_buffer::buffer_sign#5 ) + (signed byte) printf_number_buffer::padding#4 ← phi( printf_number_buffer::@1/(signed byte) printf_number_buffer::padding#3 ) + (byte) printf_padding::pad#0 ← (byte) ' ' + (byte) printf_padding::length#0 ← (byte)(signed byte) printf_number_buffer::padding#4 + call printf_padding + to:printf_number_buffer::@16 +printf_number_buffer::@16: scope:[printf_number_buffer] from printf_number_buffer::@8 + (byte) printf_number_buffer::format_justify_left#18 ← phi( printf_number_buffer::@8/(byte) printf_number_buffer::format_justify_left#20 ) + (byte*) printf_number_buffer::buffer_digits#13 ← phi( printf_number_buffer::@8/(byte*) printf_number_buffer::buffer_digits#17 ) + (byte) printf_number_buffer::format_upper_case#8 ← phi( printf_number_buffer::@8/(byte) printf_number_buffer::format_upper_case#13 ) + (signed byte) printf_number_buffer::padding#12 ← phi( printf_number_buffer::@8/(signed byte) printf_number_buffer::padding#4 ) + (byte) printf_number_buffer::format_zero_padding#12 ← phi( printf_number_buffer::@8/(byte) printf_number_buffer::format_zero_padding#17 ) + (byte) printf_number_buffer::buffer_sign#6 ← phi( printf_number_buffer::@8/(byte) printf_number_buffer::buffer_sign#10 ) + to:printf_number_buffer::@2 +printf_number_buffer::@3: scope:[printf_number_buffer] from printf_number_buffer::@17 printf_number_buffer::@2 + (byte) printf_number_buffer::format_justify_left#13 ← phi( printf_number_buffer::@17/(byte) printf_number_buffer::format_justify_left#15 printf_number_buffer::@2/(byte) printf_number_buffer::format_justify_left#16 ) + (byte*) printf_number_buffer::buffer_digits#8 ← phi( printf_number_buffer::@17/(byte*) printf_number_buffer::buffer_digits#9 printf_number_buffer::@2/(byte*) printf_number_buffer::buffer_digits#10 ) + (byte) printf_number_buffer::format_upper_case#3 ← phi( printf_number_buffer::@17/(byte) printf_number_buffer::format_upper_case#4 printf_number_buffer::@2/(byte) printf_number_buffer::format_upper_case#5 ) + (signed byte) printf_number_buffer::padding#5 ← phi( printf_number_buffer::@17/(signed byte) printf_number_buffer::padding#9 printf_number_buffer::@2/(signed byte) printf_number_buffer::padding#10 ) + (byte) printf_number_buffer::format_zero_padding#2 ← phi( printf_number_buffer::@17/(byte) printf_number_buffer::format_zero_padding#7 printf_number_buffer::@2/(byte) printf_number_buffer::format_zero_padding#8 ) + (bool~) printf_number_buffer::$9 ← (byte) printf_number_buffer::format_zero_padding#2 && (signed byte) printf_number_buffer::padding#5 + (bool~) printf_number_buffer::$10 ← ! (bool~) printf_number_buffer::$9 + if((bool~) printf_number_buffer::$10) goto printf_number_buffer::@4 + to:printf_number_buffer::@10 +printf_number_buffer::@9: scope:[printf_number_buffer] from printf_number_buffer::@2 + (byte) printf_number_buffer::format_justify_left#19 ← phi( printf_number_buffer::@2/(byte) printf_number_buffer::format_justify_left#16 ) + (byte*) printf_number_buffer::buffer_digits#14 ← phi( printf_number_buffer::@2/(byte*) printf_number_buffer::buffer_digits#10 ) + (byte) printf_number_buffer::format_upper_case#9 ← phi( printf_number_buffer::@2/(byte) printf_number_buffer::format_upper_case#5 ) + (signed byte) printf_number_buffer::padding#13 ← phi( printf_number_buffer::@2/(signed byte) printf_number_buffer::padding#10 ) + (byte) printf_number_buffer::format_zero_padding#13 ← phi( printf_number_buffer::@2/(byte) printf_number_buffer::format_zero_padding#8 ) + (byte) printf_number_buffer::buffer_sign#3 ← phi( printf_number_buffer::@2/(byte) printf_number_buffer::buffer_sign#2 ) + (byte) cputc::c#2 ← (byte) printf_number_buffer::buffer_sign#3 + call cputc + to:printf_number_buffer::@17 +printf_number_buffer::@17: scope:[printf_number_buffer] from printf_number_buffer::@9 + (byte) printf_number_buffer::format_justify_left#15 ← phi( printf_number_buffer::@9/(byte) printf_number_buffer::format_justify_left#19 ) + (byte*) printf_number_buffer::buffer_digits#9 ← phi( printf_number_buffer::@9/(byte*) printf_number_buffer::buffer_digits#14 ) + (byte) printf_number_buffer::format_upper_case#4 ← phi( printf_number_buffer::@9/(byte) printf_number_buffer::format_upper_case#9 ) + (signed byte) printf_number_buffer::padding#9 ← phi( printf_number_buffer::@9/(signed byte) printf_number_buffer::padding#13 ) + (byte) printf_number_buffer::format_zero_padding#7 ← phi( printf_number_buffer::@9/(byte) printf_number_buffer::format_zero_padding#13 ) + to:printf_number_buffer::@3 +printf_number_buffer::@4: scope:[printf_number_buffer] from printf_number_buffer::@18 printf_number_buffer::@3 + (signed byte) printf_number_buffer::padding#15 ← phi( printf_number_buffer::@18/(signed byte) printf_number_buffer::padding#16 printf_number_buffer::@3/(signed byte) printf_number_buffer::padding#5 ) + (byte) printf_number_buffer::format_justify_left#10 ← phi( printf_number_buffer::@18/(byte) printf_number_buffer::format_justify_left#12 printf_number_buffer::@3/(byte) printf_number_buffer::format_justify_left#13 ) + (byte) printf_number_buffer::format_zero_padding#15 ← phi( printf_number_buffer::@18/(byte) printf_number_buffer::format_zero_padding#18 printf_number_buffer::@3/(byte) printf_number_buffer::format_zero_padding#2 ) + (byte*) printf_number_buffer::buffer_digits#6 ← phi( printf_number_buffer::@18/(byte*) printf_number_buffer::buffer_digits#7 printf_number_buffer::@3/(byte*) printf_number_buffer::buffer_digits#8 ) + (byte) printf_number_buffer::format_upper_case#1 ← phi( printf_number_buffer::@18/(byte) printf_number_buffer::format_upper_case#2 printf_number_buffer::@3/(byte) printf_number_buffer::format_upper_case#3 ) + (bool~) printf_number_buffer::$31 ← (number) 0 != (byte) printf_number_buffer::format_upper_case#1 + (bool~) printf_number_buffer::$12 ← ! (bool~) printf_number_buffer::$31 + if((bool~) printf_number_buffer::$12) goto printf_number_buffer::@5 + to:printf_number_buffer::@11 +printf_number_buffer::@10: scope:[printf_number_buffer] from printf_number_buffer::@3 + (byte) printf_number_buffer::format_justify_left#17 ← phi( printf_number_buffer::@3/(byte) printf_number_buffer::format_justify_left#13 ) + (byte) printf_number_buffer::format_zero_padding#20 ← phi( printf_number_buffer::@3/(byte) printf_number_buffer::format_zero_padding#2 ) + (byte*) printf_number_buffer::buffer_digits#11 ← phi( printf_number_buffer::@3/(byte*) printf_number_buffer::buffer_digits#8 ) + (byte) printf_number_buffer::format_upper_case#6 ← phi( printf_number_buffer::@3/(byte) printf_number_buffer::format_upper_case#3 ) + (signed byte) printf_number_buffer::padding#6 ← phi( printf_number_buffer::@3/(signed byte) printf_number_buffer::padding#5 ) + (byte) printf_padding::pad#1 ← (byte) '0' + (byte) printf_padding::length#1 ← (byte)(signed byte) printf_number_buffer::padding#6 + call printf_padding + to:printf_number_buffer::@18 +printf_number_buffer::@18: scope:[printf_number_buffer] from printf_number_buffer::@10 + (signed byte) printf_number_buffer::padding#16 ← phi( printf_number_buffer::@10/(signed byte) printf_number_buffer::padding#6 ) + (byte) printf_number_buffer::format_justify_left#12 ← phi( printf_number_buffer::@10/(byte) printf_number_buffer::format_justify_left#17 ) + (byte) printf_number_buffer::format_zero_padding#18 ← phi( printf_number_buffer::@10/(byte) printf_number_buffer::format_zero_padding#20 ) + (byte*) printf_number_buffer::buffer_digits#7 ← phi( printf_number_buffer::@10/(byte*) printf_number_buffer::buffer_digits#11 ) + (byte) printf_number_buffer::format_upper_case#2 ← phi( printf_number_buffer::@10/(byte) printf_number_buffer::format_upper_case#6 ) + to:printf_number_buffer::@4 +printf_number_buffer::@5: scope:[printf_number_buffer] from printf_number_buffer::@20 printf_number_buffer::@4 + (signed byte) printf_number_buffer::padding#11 ← phi( printf_number_buffer::@20/(signed byte) printf_number_buffer::padding#14 printf_number_buffer::@4/(signed byte) printf_number_buffer::padding#15 ) + (byte) printf_number_buffer::format_justify_left#6 ← phi( printf_number_buffer::@20/(byte) printf_number_buffer::format_justify_left#9 printf_number_buffer::@4/(byte) printf_number_buffer::format_justify_left#10 ) + (byte) printf_number_buffer::format_zero_padding#9 ← phi( printf_number_buffer::@20/(byte) printf_number_buffer::format_zero_padding#14 printf_number_buffer::@4/(byte) printf_number_buffer::format_zero_padding#15 ) + (byte*) printf_number_buffer::buffer_digits#2 ← phi( printf_number_buffer::@20/(byte*) printf_number_buffer::buffer_digits#5 printf_number_buffer::@4/(byte*) printf_number_buffer::buffer_digits#6 ) + (to_nomodify byte*) cputs::s#1 ← (byte*) printf_number_buffer::buffer_digits#2 + call cputs + to:printf_number_buffer::@19 +printf_number_buffer::@19: scope:[printf_number_buffer] from printf_number_buffer::@5 + (signed byte) printf_number_buffer::padding#7 ← phi( printf_number_buffer::@5/(signed byte) printf_number_buffer::padding#11 ) + (byte) printf_number_buffer::format_justify_left#2 ← phi( printf_number_buffer::@5/(byte) printf_number_buffer::format_justify_left#6 ) + (byte) printf_number_buffer::format_zero_padding#3 ← phi( printf_number_buffer::@5/(byte) printf_number_buffer::format_zero_padding#9 ) + (bool~) printf_number_buffer::$32 ← (number) 0 != (byte) printf_number_buffer::format_zero_padding#3 + (bool~) printf_number_buffer::$14 ← ! (bool~) printf_number_buffer::$32 + (bool~) printf_number_buffer::$15 ← (byte) printf_number_buffer::format_justify_left#2 && (bool~) printf_number_buffer::$14 + (bool~) printf_number_buffer::$16 ← (bool~) printf_number_buffer::$15 && (signed byte) printf_number_buffer::padding#7 + (bool~) printf_number_buffer::$17 ← ! (bool~) printf_number_buffer::$16 + if((bool~) printf_number_buffer::$17) goto printf_number_buffer::@return + to:printf_number_buffer::@12 +printf_number_buffer::@11: scope:[printf_number_buffer] from printf_number_buffer::@4 + (signed byte) printf_number_buffer::padding#17 ← phi( printf_number_buffer::@4/(signed byte) printf_number_buffer::padding#15 ) + (byte) printf_number_buffer::format_justify_left#14 ← phi( printf_number_buffer::@4/(byte) printf_number_buffer::format_justify_left#10 ) + (byte) printf_number_buffer::format_zero_padding#19 ← phi( printf_number_buffer::@4/(byte) printf_number_buffer::format_zero_padding#15 ) + (byte*) printf_number_buffer::buffer_digits#3 ← phi( printf_number_buffer::@4/(byte*) printf_number_buffer::buffer_digits#6 ) + (byte*) strupr::str#0 ← (byte*) printf_number_buffer::buffer_digits#3 + call strupr + (byte*) strupr::return#2 ← (byte*) strupr::return#1 + to:printf_number_buffer::@20 +printf_number_buffer::@20: scope:[printf_number_buffer] from printf_number_buffer::@11 + (signed byte) printf_number_buffer::padding#14 ← phi( printf_number_buffer::@11/(signed byte) printf_number_buffer::padding#17 ) + (byte) printf_number_buffer::format_justify_left#9 ← phi( printf_number_buffer::@11/(byte) printf_number_buffer::format_justify_left#14 ) + (byte) printf_number_buffer::format_zero_padding#14 ← phi( printf_number_buffer::@11/(byte) printf_number_buffer::format_zero_padding#19 ) + (byte*) printf_number_buffer::buffer_digits#5 ← phi( printf_number_buffer::@11/(byte*) printf_number_buffer::buffer_digits#3 ) + to:printf_number_buffer::@5 +printf_number_buffer::@12: scope:[printf_number_buffer] from printf_number_buffer::@19 + (signed byte) printf_number_buffer::padding#8 ← phi( printf_number_buffer::@19/(signed byte) printf_number_buffer::padding#7 ) + (byte) printf_padding::pad#2 ← (byte) ' ' + (byte) printf_padding::length#2 ← (byte)(signed byte) printf_number_buffer::padding#8 + call printf_padding + to:printf_number_buffer::@21 +printf_number_buffer::@21: scope:[printf_number_buffer] from printf_number_buffer::@12 + to:printf_number_buffer::@return +printf_number_buffer::@return: scope:[printf_number_buffer] from printf_number_buffer::@19 printf_number_buffer::@21 + return + to:@return + +(void()) main() +main: scope:[main] from @2 + (void*) memset::str#2 ← (void*)(const nomodify byte*) SCREEN + (byte) memset::c#2 ← (byte) ' ' + (word) memset::num#2 ← (number) $3e8 + call memset + (void*) memset::return#4 ← (void*) memset::return#1 + to:main::@9 +main::@9: scope:[main] from main + (word) main::count#0 ← (word) 0 + (byte*) main::sc#0 ← (const nomodify byte*) SCREEN + (byte) main::y#0 ← (byte) 0 + to:main::@1 +main::@1: scope:[main] from main::@6 main::@9 + (byte*) main::sc#9 ← phi( main::@6/(byte*) main::sc#10 main::@9/(byte*) main::sc#0 ) + (word) main::count#6 ← phi( main::@6/(word) main::count#8 main::@9/(word) main::count#0 ) + (byte) main::y#2 ← phi( main::@6/(byte) main::y#1 main::@9/(byte) main::y#0 ) + (bool~) main::$3 ← (byte) main::y#2 < (number) $19 + if((bool~) main::$3) goto main::@2 + to:main::@3 +main::@2: scope:[main] from main::@1 + (word) main::count#11 ← phi( main::@1/(word) main::count#6 ) + (byte*) main::sc#8 ← phi( main::@1/(byte*) main::sc#9 ) + (byte) main::y#6 ← phi( main::@1/(byte) main::y#2 ) + (byte) main::x#0 ← (byte) 0 + to:main::@4 +main::@3: scope:[main] from main::@1 + (word) main::count#4 ← phi( main::@1/(word) main::count#6 ) + (byte) gotoxy::x#2 ← (number) 0 + (byte) gotoxy::y#2 ← (number) 0 + call gotoxy + to:main::@10 +main::@10: scope:[main] from main::@3 + (word) main::count#2 ← phi( main::@3/(word) main::count#4 ) + (word) printf_uint::uvalue#0 ← (word) main::count#2 + (byte) printf_uint::format_min_length#0 ← (byte) 0 + (byte) printf_uint::format_justify_left#0 ← (byte) 0 + (byte) printf_uint::format_sign_always#0 ← (byte) 0 + (byte) printf_uint::format_zero_padding#0 ← (byte) 0 + (byte) printf_uint::format_upper_case#0 ← (byte) 0 + (byte) printf_uint::format_radix#0 ← (const byte) DECIMAL + call printf_uint + to:main::@11 +main::@11: scope:[main] from main::@10 + (to_nomodify byte*) cputs::s#2 ← (const byte*) main::s + call cputs + to:main::@12 +main::@12: scope:[main] from main::@11 + to:main::@return +main::@4: scope:[main] from main::@2 main::@7 + (word) main::count#10 ← phi( main::@2/(word) main::count#11 main::@7/(word) main::count#12 ) + (byte*) main::sc#7 ← phi( main::@2/(byte*) main::sc#8 main::@7/(byte*) main::sc#1 ) + (byte) main::y#5 ← phi( main::@2/(byte) main::y#6 main::@7/(byte) main::y#7 ) + (byte) main::x#2 ← phi( main::@2/(byte) main::x#0 main::@7/(byte) main::x#1 ) + (bool~) main::$4 ← (byte) main::x#2 < (number) $28 + if((bool~) main::$4) goto main::@5 + to:main::@6 +main::@5: scope:[main] from main::@4 + (word) main::count#9 ← phi( main::@4/(word) main::count#10 ) + (byte*) main::sc#6 ← phi( main::@4/(byte*) main::sc#7 ) + (byte) main::y#3 ← phi( main::@4/(byte) main::y#5 ) + (byte) main::x#3 ← phi( main::@4/(byte) main::x#2 ) + (signed byte~) main::$14 ← (signed byte)(byte) main::x#3 + (number~) main::$5 ← (signed byte~) main::$14 * (number) 2 + (number~) main::$6 ← (number~) main::$5 - (number) $27 + (signed byte) main::xd#0 ← (number~) main::$6 + (signed byte~) main::$15 ← (signed byte)(byte) main::y#3 + (number~) main::$7 ← (signed byte~) main::$15 * (number) 2 + (number~) main::$8 ← (number~) main::$7 - (number) $18 + (signed byte) main::yd#0 ← (number~) main::$8 + (signed byte) mul8s::a#0 ← (signed byte) main::xd#0 + (signed byte) mul8s::b#0 ← (signed byte) main::xd#0 + call mul8s + (signed word) mul8s::return#2 ← (signed word) mul8s::return#1 + to:main::@13 +main::@13: scope:[main] from main::@5 + (byte) main::y#10 ← phi( main::@5/(byte) main::y#3 ) + (word) main::count#7 ← phi( main::@5/(word) main::count#9 ) + (byte) main::x#7 ← phi( main::@5/(byte) main::x#3 ) + (byte*) main::sc#5 ← phi( main::@5/(byte*) main::sc#6 ) + (signed byte) main::yd#1 ← phi( main::@5/(signed byte) main::yd#0 ) + (signed word) mul8s::return#5 ← phi( main::@5/(signed word) mul8s::return#2 ) + (signed word~) main::$9 ← (signed word) mul8s::return#5 + (signed byte) mul8s::a#1 ← (signed byte) main::yd#1 + (signed byte) mul8s::b#1 ← (signed byte) main::yd#1 + call mul8s + (signed word) mul8s::return#3 ← (signed word) mul8s::return#1 + to:main::@14 +main::@14: scope:[main] from main::@13 + (byte) main::y#8 ← phi( main::@13/(byte) main::y#10 ) + (word) main::count#5 ← phi( main::@13/(word) main::count#7 ) + (byte) main::x#5 ← phi( main::@13/(byte) main::x#7 ) + (byte*) main::sc#4 ← phi( main::@13/(byte*) main::sc#5 ) + (signed word) mul8s::return#6 ← phi( main::@13/(signed word) mul8s::return#3 ) + (signed word~) main::$10 ← (signed word) mul8s::return#6 + (signed word~) main::$11 ← (signed word~) main::$9 + (signed word~) main::$10 + (signed word) main::dist_sq#0 ← (signed word~) main::$11 + (bool~) main::$12 ← (signed word) main::dist_sq#0 < (number) 2*(number) 9*(number) 2*(number) 9 + (bool~) main::$13 ← ! (bool~) main::$12 + if((bool~) main::$13) goto main::@7 + to:main::@8 +main::@6: scope:[main] from main::@4 + (byte*) main::sc#10 ← phi( main::@4/(byte*) main::sc#7 ) + (word) main::count#8 ← phi( main::@4/(word) main::count#10 ) + (byte) main::y#4 ← phi( main::@4/(byte) main::y#5 ) + (byte) main::y#1 ← ++ (byte) main::y#4 + to:main::@1 +main::@7: scope:[main] from main::@14 main::@8 + (word) main::count#12 ← phi( main::@14/(word) main::count#5 main::@8/(word) main::count#1 ) + (byte) main::y#7 ← phi( main::@14/(byte) main::y#8 main::@8/(byte) main::y#9 ) + (byte) main::x#4 ← phi( main::@14/(byte) main::x#5 main::@8/(byte) main::x#6 ) + (byte*) main::sc#2 ← phi( main::@14/(byte*) main::sc#4 main::@8/(byte*) main::sc#3 ) + (byte*) main::sc#1 ← ++ (byte*) main::sc#2 + (byte) main::x#1 ← ++ (byte) main::x#4 + to:main::@4 +main::@8: scope:[main] from main::@14 + (byte) main::y#9 ← phi( main::@14/(byte) main::y#8 ) + (byte) main::x#6 ← phi( main::@14/(byte) main::x#5 ) + (word) main::count#3 ← phi( main::@14/(word) main::count#5 ) + (byte*) main::sc#3 ← phi( main::@14/(byte*) main::sc#4 ) + *((byte*) main::sc#3) ← (byte) '*' + (word) main::count#1 ← ++ (word) main::count#3 + to:main::@7 +main::@return: scope:[main] from main::@12 + return + to:@return +@2: scope:[] from @1 + call main + to:@3 +@3: scope:[] from @2 + to:@end +@end: scope:[] from @3 + +SYMBOL TABLE SSA +(label) @1 +(label) @2 +(label) @3 +(label) @begin +(label) @end +(const byte) BINARY = (number) 2 +(const nomodify byte*) CONIO_SCREEN_COLORS = (byte*)(number) $d800 +(const nomodify byte*) CONIO_SCREEN_TEXT = (byte*)(number) $400 +(const nomodify byte) CONIO_TEXTCOLOR_DEFAULT = (byte) $e +(const byte) DECIMAL = (number) $a +(const byte*) DIGITS[] = (byte*) "0123456789abcdef"z +(const byte) HEXADECIMAL = (number) $10 +(const byte) OCTAL = (number) 8 +(const byte) OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_DIGITS = (byte) 1 +(const byte) OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_SIGN = (byte) 0 +(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 word*) RADIX_BINARY_VALUES[] = { (word) $8000, (word) $4000, (word) $2000, (word) $1000, (word) $800, (word) $400, (word) $200, (word) $100, (word) $80, (word) $40, (word) $20, (word) $10, (word) 8, (word) 4, (word) 2 } +(const word*) RADIX_DECIMAL_VALUES[] = { (word) $2710, (word) $3e8, (word) $64, (word) $a } +(const word*) RADIX_HEXADECIMAL_VALUES[] = { (word) $1000, (word) $100, (word) $10 } +(const word*) RADIX_OCTAL_VALUES[] = { (word) $8000, (word) $1000, (word) $200, (word) $40, (word) 8 } +(const nomodify byte*) SCREEN = (byte*)(number) $400 +(const byte) SIZEOF_WORD = (byte) 2 +(byte*) conio_cursor_color loadstore +(byte*) conio_cursor_text loadstore +(byte) conio_cursor_x loadstore +(byte) conio_cursor_y loadstore +(byte) conio_scroll_enable loadstore +(byte) conio_textcolor loadstore +(void()) cputc((byte) cputc::c) +(bool~) cputc::$0 +(bool~) cputc::$1 +(bool~) cputc::$2 +(label) cputc::@1 +(label) cputc::@2 +(label) cputc::@3 +(label) cputc::@4 +(label) cputc::@5 +(label) cputc::@return +(byte) cputc::c +(byte) cputc::c#0 +(byte) cputc::c#1 +(byte) cputc::c#2 +(byte) cputc::c#3 +(byte) cputc::c#4 +(void()) cputln() +(number~) cputln::$0 +(byte*~) cputln::$1 +(byte*~) cputln::$2 +(label) cputln::@1 +(label) cputln::@return +(word) cputln::ln_offset +(word) cputln::ln_offset#0 +(void()) cputs((to_nomodify byte*) cputs::s) +(bool~) cputs::$1 +(label) cputs::@1 +(label) cputs::@2 +(label) cputs::@3 +(label) cputs::@return +(byte) cputs::c +(byte) cputs::c#0 +(byte) cputs::c#1 +(byte) cputs::c#2 +(to_nomodify byte*) cputs::s +(to_nomodify byte*) cputs::s#0 +(to_nomodify byte*) cputs::s#1 +(to_nomodify byte*) cputs::s#2 +(to_nomodify byte*) cputs::s#3 +(to_nomodify byte*) cputs::s#4 +(to_nomodify byte*) cputs::s#5 +(to_nomodify byte*) cputs::s#6 +(void()) cscroll() +(bool~) cscroll::$0 +(bool~) cscroll::$1 +(byte*~) cscroll::$7 +(byte*~) cscroll::$8 +(bool~) cscroll::$9 +(label) cscroll::@1 +(label) cscroll::@2 +(label) cscroll::@3 +(label) cscroll::@4 +(label) cscroll::@5 +(label) cscroll::@6 +(label) cscroll::@7 +(label) cscroll::@8 +(label) cscroll::@return +(void()) gotoxy((byte) gotoxy::x , (byte) gotoxy::y) +(bool~) gotoxy::$0 +(bool~) gotoxy::$1 +(bool~) gotoxy::$2 +(bool~) gotoxy::$3 +(number~) gotoxy::$4 +(number~) gotoxy::$5 +(byte*~) gotoxy::$6 +(byte*~) gotoxy::$7 +(word~) gotoxy::$8 +(label) gotoxy::@1 +(label) gotoxy::@2 +(label) gotoxy::@3 +(label) gotoxy::@4 +(label) gotoxy::@return +(word) gotoxy::offset +(word) gotoxy::offset#0 +(byte) gotoxy::x +(byte) gotoxy::x#0 +(byte) gotoxy::x#1 +(byte) gotoxy::x#2 +(byte) gotoxy::x#3 +(byte) gotoxy::x#4 +(byte) gotoxy::x#5 +(byte) gotoxy::x#6 +(byte) gotoxy::y +(byte) gotoxy::y#0 +(byte) gotoxy::y#1 +(byte) gotoxy::y#2 +(byte) gotoxy::y#3 +(byte) gotoxy::y#4 +(byte) gotoxy::y#5 +(byte) gotoxy::y#6 +(void()) main() +(signed word~) main::$10 +(signed word~) main::$11 +(bool~) main::$12 +(bool~) main::$13 +(signed byte~) main::$14 +(signed byte~) main::$15 +(bool~) main::$3 +(bool~) main::$4 +(number~) main::$5 +(number~) main::$6 +(number~) main::$7 +(number~) main::$8 +(signed word~) main::$9 +(label) main::@1 +(label) main::@10 +(label) main::@11 +(label) main::@12 +(label) main::@13 +(label) main::@14 +(label) main::@2 +(label) main::@3 +(label) main::@4 +(label) main::@5 +(label) main::@6 +(label) main::@7 +(label) main::@8 +(label) main::@9 +(label) main::@return +(word) main::count +(word) main::count#0 +(word) main::count#1 +(word) main::count#10 +(word) main::count#11 +(word) main::count#12 +(word) main::count#2 +(word) main::count#3 +(word) main::count#4 +(word) main::count#5 +(word) main::count#6 +(word) main::count#7 +(word) main::count#8 +(word) main::count#9 +(signed word) main::dist_sq +(signed word) main::dist_sq#0 +(const byte*) main::s[(byte) 7] = (byte*) " chars" +(byte*) main::sc +(byte*) main::sc#0 +(byte*) main::sc#1 +(byte*) main::sc#10 +(byte*) main::sc#2 +(byte*) main::sc#3 +(byte*) main::sc#4 +(byte*) main::sc#5 +(byte*) main::sc#6 +(byte*) main::sc#7 +(byte*) main::sc#8 +(byte*) main::sc#9 +(byte) main::x +(byte) main::x#0 +(byte) main::x#1 +(byte) main::x#2 +(byte) main::x#3 +(byte) main::x#4 +(byte) main::x#5 +(byte) main::x#6 +(byte) main::x#7 +(signed byte) main::xd +(signed byte) main::xd#0 +(byte) main::y +(byte) main::y#0 +(byte) main::y#1 +(byte) main::y#10 +(byte) main::y#2 +(byte) main::y#3 +(byte) main::y#4 +(byte) main::y#5 +(byte) main::y#6 +(byte) main::y#7 +(byte) main::y#8 +(byte) main::y#9 +(signed byte) main::yd +(signed byte) main::yd#0 +(signed byte) main::yd#1 +(void*()) memcpy((void*) memcpy::destination , (void*) memcpy::source , (word) memcpy::num) +(byte*~) memcpy::$0 +(bool~) memcpy::$1 +(byte*~) memcpy::$2 +(label) memcpy::@1 +(label) memcpy::@2 +(label) memcpy::@3 +(label) memcpy::@return +(void*) memcpy::destination +(void*) memcpy::destination#0 +(void*) memcpy::destination#1 +(void*) memcpy::destination#2 +(void*) memcpy::destination#3 +(void*) memcpy::destination#4 +(void*) memcpy::destination#5 +(byte*) memcpy::dst +(byte*) memcpy::dst#0 +(byte*) memcpy::dst#1 +(byte*) memcpy::dst#2 +(byte*) memcpy::dst#3 +(word) memcpy::num +(word) memcpy::num#0 +(word) memcpy::num#1 +(word) memcpy::num#2 +(void*) memcpy::return +(void*) memcpy::return#0 +(void*) memcpy::return#1 +(void*) memcpy::return#2 +(void*) memcpy::return#3 +(void*) memcpy::return#4 +(void*) memcpy::source +(void*) memcpy::source#0 +(void*) memcpy::source#1 +(void*) memcpy::source#2 +(byte*) memcpy::src +(byte*) memcpy::src#0 +(byte*) memcpy::src#1 +(byte*) memcpy::src#2 +(byte*) memcpy::src#3 +(byte*) memcpy::src_end +(byte*) memcpy::src_end#0 +(byte*) memcpy::src_end#1 +(byte*) memcpy::src_end#2 +(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num) +(bool~) memset::$0 +(bool~) memset::$1 +(byte*~) memset::$2 +(bool~) memset::$3 +(byte*~) memset::$4 +(label) memset::@1 +(label) memset::@2 +(label) memset::@3 +(label) memset::@4 +(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::c#5 +(byte) memset::c#6 +(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 +(word) memset::num#3 +(word) memset::num#4 +(void*) memset::return +(void*) memset::return#0 +(void*) memset::return#1 +(void*) memset::return#2 +(void*) memset::return#3 +(void*) memset::return#4 +(void*) memset::return#5 +(void*) memset::str +(void*) memset::str#0 +(void*) memset::str#1 +(void*) memset::str#2 +(void*) memset::str#3 +(void*) memset::str#4 +(void*) memset::str#5 +(void*) memset::str#6 +(void*) memset::str#7 +(signed word()) mul8s((signed byte) mul8s::a , (signed byte) mul8s::b) +(word~) mul8s::$0 +(bool~) mul8s::$1 +(byte~) mul8s::$10 +(byte~) mul8s::$11 +(byte~) mul8s::$12 +(byte~) mul8s::$13 +(byte~) mul8s::$14 +(bool~) mul8s::$2 +(bool~) mul8s::$3 +(bool~) mul8s::$4 +(byte~) mul8s::$6 +(byte~) mul8s::$7 +(byte~) mul8s::$9 +(label) mul8s::@1 +(label) mul8s::@2 +(label) mul8s::@3 +(label) mul8s::@4 +(label) mul8s::@5 +(label) mul8s::@return +(signed byte) mul8s::a +(signed byte) mul8s::a#0 +(signed byte) mul8s::a#1 +(signed byte) mul8s::a#2 +(signed byte) mul8s::a#3 +(signed byte) mul8s::a#4 +(signed byte) mul8s::a#5 +(signed byte) mul8s::a#6 +(signed byte) mul8s::b +(signed byte) mul8s::b#0 +(signed byte) mul8s::b#1 +(signed byte) mul8s::b#2 +(signed byte) mul8s::b#3 +(signed byte) mul8s::b#4 +(signed byte) mul8s::b#5 +(word) mul8s::m +(word) mul8s::m#0 +(word) mul8s::m#1 +(word) mul8s::m#2 +(word) mul8s::m#3 +(word) mul8s::m#4 +(word) mul8s::m#5 +(word) mul8s::m#6 +(signed word) mul8s::return +(signed word) mul8s::return#0 +(signed word) mul8s::return#1 +(signed word) mul8s::return#2 +(signed word) mul8s::return#3 +(signed word) mul8s::return#4 +(signed word) mul8s::return#5 +(signed word) mul8s::return#6 +(word()) mul8u((byte) mul8u::a , (byte) mul8u::b) +(bool~) mul8u::$0 +(number~) mul8u::$1 +(bool~) mul8u::$2 +(bool~) mul8u::$3 +(word~) mul8u::$4 +(byte~) mul8u::$5 +(word~) mul8u::$6 +(label) mul8u::@1 +(label) mul8u::@2 +(label) mul8u::@3 +(label) mul8u::@4 +(label) mul8u::@5 +(label) mul8u::@return +(byte) mul8u::a +(byte) mul8u::a#0 +(byte) mul8u::a#1 +(byte) mul8u::a#2 +(byte) mul8u::a#3 +(byte) mul8u::a#4 +(byte) mul8u::a#5 +(byte) mul8u::a#6 +(byte) mul8u::b +(byte) mul8u::b#0 +(byte) mul8u::b#1 +(word) mul8u::mb +(word) mul8u::mb#0 +(word) mul8u::mb#1 +(word) mul8u::mb#2 +(word) mul8u::mb#3 +(word) mul8u::mb#4 +(word) mul8u::mb#5 +(word) mul8u::res +(word) mul8u::res#0 +(word) mul8u::res#1 +(word) mul8u::res#2 +(word) mul8u::res#3 +(word) mul8u::res#4 +(word) mul8u::res#5 +(word) mul8u::res#6 +(word) mul8u::return +(word) mul8u::return#0 +(word) mul8u::return#1 +(word) mul8u::return#2 +(word) mul8u::return#3 +(word) mul8u::return#4 +(struct printf_buffer_number) printf_buffer loadstore = {} +(const byte*) printf_buffer_number::digits[(number) $b] = { fill( $b, 0) } +(byte) printf_buffer_number::sign +(byte) printf_format_number::justify_left +(byte) printf_format_number::min_length +(byte) printf_format_number::radix +(byte) printf_format_number::sign_always +(byte) printf_format_number::upper_case +(byte) printf_format_number::zero_padding +(byte) printf_format_string::justify_left +(byte) printf_format_string::min_length +(void()) printf_number_buffer((byte) printf_number_buffer::buffer_sign , (byte*) printf_number_buffer::buffer_digits , (byte) printf_number_buffer::format_min_length , (byte) printf_number_buffer::format_justify_left , (byte) printf_number_buffer::format_sign_always , (byte) printf_number_buffer::format_zero_padding , (byte) printf_number_buffer::format_upper_case , (byte) printf_number_buffer::format_radix) +(bool~) printf_number_buffer::$0 +(bool~) printf_number_buffer::$1 +(bool~) printf_number_buffer::$10 +(bool~) printf_number_buffer::$12 +(bool~) printf_number_buffer::$14 +(bool~) printf_number_buffer::$15 +(bool~) printf_number_buffer::$16 +(bool~) printf_number_buffer::$17 +(word~) printf_number_buffer::$19 +(bool~) printf_number_buffer::$2 +(bool~) printf_number_buffer::$20 +(signed byte~) printf_number_buffer::$21 +(bool~) printf_number_buffer::$22 +(bool~) printf_number_buffer::$23 +(signed byte~) printf_number_buffer::$25 +(bool~) printf_number_buffer::$26 +(bool~) printf_number_buffer::$27 +(bool~) printf_number_buffer::$28 +(bool~) printf_number_buffer::$29 +(bool~) printf_number_buffer::$3 +(bool~) printf_number_buffer::$30 +(bool~) printf_number_buffer::$31 +(bool~) printf_number_buffer::$32 +(bool~) printf_number_buffer::$4 +(bool~) printf_number_buffer::$5 +(bool~) printf_number_buffer::$7 +(bool~) printf_number_buffer::$9 +(label) printf_number_buffer::@1 +(label) printf_number_buffer::@10 +(label) printf_number_buffer::@11 +(label) printf_number_buffer::@12 +(label) printf_number_buffer::@13 +(label) printf_number_buffer::@14 +(label) printf_number_buffer::@15 +(label) printf_number_buffer::@16 +(label) printf_number_buffer::@17 +(label) printf_number_buffer::@18 +(label) printf_number_buffer::@19 +(label) printf_number_buffer::@2 +(label) printf_number_buffer::@20 +(label) printf_number_buffer::@21 +(label) printf_number_buffer::@3 +(label) printf_number_buffer::@4 +(label) printf_number_buffer::@5 +(label) printf_number_buffer::@6 +(label) printf_number_buffer::@7 +(label) printf_number_buffer::@8 +(label) printf_number_buffer::@9 +(label) printf_number_buffer::@return +(struct printf_buffer_number) printf_number_buffer::buffer +(byte*) printf_number_buffer::buffer_digits +(byte*) printf_number_buffer::buffer_digits#0 +(byte*) printf_number_buffer::buffer_digits#1 +(byte*) printf_number_buffer::buffer_digits#10 +(byte*) printf_number_buffer::buffer_digits#11 +(byte*) printf_number_buffer::buffer_digits#12 +(byte*) printf_number_buffer::buffer_digits#13 +(byte*) printf_number_buffer::buffer_digits#14 +(byte*) printf_number_buffer::buffer_digits#15 +(byte*) printf_number_buffer::buffer_digits#16 +(byte*) printf_number_buffer::buffer_digits#17 +(byte*) printf_number_buffer::buffer_digits#18 +(byte*) printf_number_buffer::buffer_digits#19 +(byte*) printf_number_buffer::buffer_digits#2 +(byte*) printf_number_buffer::buffer_digits#3 +(byte*) printf_number_buffer::buffer_digits#4 +(byte*) printf_number_buffer::buffer_digits#5 +(byte*) printf_number_buffer::buffer_digits#6 +(byte*) printf_number_buffer::buffer_digits#7 +(byte*) printf_number_buffer::buffer_digits#8 +(byte*) printf_number_buffer::buffer_digits#9 +(byte) printf_number_buffer::buffer_sign +(byte) printf_number_buffer::buffer_sign#0 +(byte) printf_number_buffer::buffer_sign#1 +(byte) printf_number_buffer::buffer_sign#10 +(byte) printf_number_buffer::buffer_sign#11 +(byte) printf_number_buffer::buffer_sign#2 +(byte) printf_number_buffer::buffer_sign#3 +(byte) printf_number_buffer::buffer_sign#4 +(byte) printf_number_buffer::buffer_sign#5 +(byte) printf_number_buffer::buffer_sign#6 +(byte) printf_number_buffer::buffer_sign#7 +(byte) printf_number_buffer::buffer_sign#8 +(byte) printf_number_buffer::buffer_sign#9 +(struct printf_format_number) printf_number_buffer::format +(byte) printf_number_buffer::format_justify_left +(byte) printf_number_buffer::format_justify_left#0 +(byte) printf_number_buffer::format_justify_left#1 +(byte) printf_number_buffer::format_justify_left#10 +(byte) printf_number_buffer::format_justify_left#11 +(byte) printf_number_buffer::format_justify_left#12 +(byte) printf_number_buffer::format_justify_left#13 +(byte) printf_number_buffer::format_justify_left#14 +(byte) printf_number_buffer::format_justify_left#15 +(byte) printf_number_buffer::format_justify_left#16 +(byte) printf_number_buffer::format_justify_left#17 +(byte) printf_number_buffer::format_justify_left#18 +(byte) printf_number_buffer::format_justify_left#19 +(byte) printf_number_buffer::format_justify_left#2 +(byte) printf_number_buffer::format_justify_left#20 +(byte) printf_number_buffer::format_justify_left#3 +(byte) printf_number_buffer::format_justify_left#4 +(byte) printf_number_buffer::format_justify_left#5 +(byte) printf_number_buffer::format_justify_left#6 +(byte) printf_number_buffer::format_justify_left#7 +(byte) printf_number_buffer::format_justify_left#8 +(byte) printf_number_buffer::format_justify_left#9 +(byte) printf_number_buffer::format_min_length +(byte) printf_number_buffer::format_min_length#0 +(byte) printf_number_buffer::format_min_length#1 +(byte) printf_number_buffer::format_min_length#2 +(byte) printf_number_buffer::format_min_length#3 +(byte) printf_number_buffer::format_min_length#4 +(byte) printf_number_buffer::format_min_length#5 +(byte) printf_number_buffer::format_radix +(byte) printf_number_buffer::format_radix#0 +(byte) printf_number_buffer::format_sign_always +(byte) printf_number_buffer::format_sign_always#0 +(byte) printf_number_buffer::format_upper_case +(byte) printf_number_buffer::format_upper_case#0 +(byte) printf_number_buffer::format_upper_case#1 +(byte) printf_number_buffer::format_upper_case#10 +(byte) printf_number_buffer::format_upper_case#11 +(byte) printf_number_buffer::format_upper_case#12 +(byte) printf_number_buffer::format_upper_case#13 +(byte) printf_number_buffer::format_upper_case#14 +(byte) printf_number_buffer::format_upper_case#15 +(byte) printf_number_buffer::format_upper_case#16 +(byte) printf_number_buffer::format_upper_case#2 +(byte) printf_number_buffer::format_upper_case#3 +(byte) printf_number_buffer::format_upper_case#4 +(byte) printf_number_buffer::format_upper_case#5 +(byte) printf_number_buffer::format_upper_case#6 +(byte) printf_number_buffer::format_upper_case#7 +(byte) printf_number_buffer::format_upper_case#8 +(byte) printf_number_buffer::format_upper_case#9 +(byte) printf_number_buffer::format_zero_padding +(byte) printf_number_buffer::format_zero_padding#0 +(byte) printf_number_buffer::format_zero_padding#1 +(byte) printf_number_buffer::format_zero_padding#10 +(byte) printf_number_buffer::format_zero_padding#11 +(byte) printf_number_buffer::format_zero_padding#12 +(byte) printf_number_buffer::format_zero_padding#13 +(byte) printf_number_buffer::format_zero_padding#14 +(byte) printf_number_buffer::format_zero_padding#15 +(byte) printf_number_buffer::format_zero_padding#16 +(byte) printf_number_buffer::format_zero_padding#17 +(byte) printf_number_buffer::format_zero_padding#18 +(byte) printf_number_buffer::format_zero_padding#19 +(byte) printf_number_buffer::format_zero_padding#2 +(byte) printf_number_buffer::format_zero_padding#20 +(byte) printf_number_buffer::format_zero_padding#3 +(byte) printf_number_buffer::format_zero_padding#4 +(byte) printf_number_buffer::format_zero_padding#5 +(byte) printf_number_buffer::format_zero_padding#6 +(byte) printf_number_buffer::format_zero_padding#7 +(byte) printf_number_buffer::format_zero_padding#8 +(byte) printf_number_buffer::format_zero_padding#9 +(signed byte) printf_number_buffer::len +(signed byte) printf_number_buffer::len#0 +(signed byte) printf_number_buffer::len#1 +(signed byte) printf_number_buffer::len#2 +(signed byte) printf_number_buffer::len#3 +(signed byte) printf_number_buffer::padding +(signed byte) printf_number_buffer::padding#0 +(signed byte) printf_number_buffer::padding#1 +(signed byte) printf_number_buffer::padding#10 +(signed byte) printf_number_buffer::padding#11 +(signed byte) printf_number_buffer::padding#12 +(signed byte) printf_number_buffer::padding#13 +(signed byte) printf_number_buffer::padding#14 +(signed byte) printf_number_buffer::padding#15 +(signed byte) printf_number_buffer::padding#16 +(signed byte) printf_number_buffer::padding#17 +(signed byte) printf_number_buffer::padding#2 +(signed byte) printf_number_buffer::padding#3 +(signed byte) printf_number_buffer::padding#4 +(signed byte) printf_number_buffer::padding#5 +(signed byte) printf_number_buffer::padding#6 +(signed byte) printf_number_buffer::padding#7 +(signed byte) printf_number_buffer::padding#8 +(signed byte) printf_number_buffer::padding#9 +(void()) printf_padding((byte) printf_padding::pad , (byte) printf_padding::length) +(bool~) printf_padding::$0 +(label) printf_padding::@1 +(label) printf_padding::@2 +(label) printf_padding::@3 +(label) printf_padding::@return +(byte) printf_padding::i +(byte) printf_padding::i#0 +(byte) printf_padding::i#1 +(byte) printf_padding::i#2 +(byte) printf_padding::i#3 +(byte) printf_padding::i#4 +(byte) printf_padding::length +(byte) printf_padding::length#0 +(byte) printf_padding::length#1 +(byte) printf_padding::length#2 +(byte) printf_padding::length#3 +(byte) printf_padding::length#4 +(byte) printf_padding::length#5 +(byte) printf_padding::length#6 +(byte) printf_padding::pad +(byte) printf_padding::pad#0 +(byte) printf_padding::pad#1 +(byte) printf_padding::pad#2 +(byte) printf_padding::pad#3 +(byte) printf_padding::pad#4 +(byte) printf_padding::pad#5 +(byte) printf_padding::pad#6 +(void()) printf_uint((word) printf_uint::uvalue , (byte) printf_uint::format_min_length , (byte) printf_uint::format_justify_left , (byte) printf_uint::format_sign_always , (byte) printf_uint::format_zero_padding , (byte) printf_uint::format_upper_case , (byte) printf_uint::format_radix) +(number~) printf_uint::$0 +(byte~) printf_uint::$1 +(number~) printf_uint::$2 +(bool~) printf_uint::$5 +(label) printf_uint::@1 +(label) printf_uint::@2 +(label) printf_uint::@3 +(label) printf_uint::@4 +(label) printf_uint::@5 +(label) printf_uint::@return +(struct printf_format_number) printf_uint::format +(byte) printf_uint::format_justify_left +(byte) printf_uint::format_justify_left#0 +(byte) printf_uint::format_justify_left#1 +(byte) printf_uint::format_justify_left#2 +(byte) printf_uint::format_justify_left#3 +(byte) printf_uint::format_justify_left#4 +(byte) printf_uint::format_justify_left#5 +(byte) printf_uint::format_min_length +(byte) printf_uint::format_min_length#0 +(byte) printf_uint::format_min_length#1 +(byte) printf_uint::format_min_length#2 +(byte) printf_uint::format_min_length#3 +(byte) printf_uint::format_min_length#4 +(byte) printf_uint::format_min_length#5 +(byte) printf_uint::format_radix +(byte) printf_uint::format_radix#0 +(byte) printf_uint::format_radix#1 +(byte) printf_uint::format_radix#2 +(byte) printf_uint::format_radix#3 +(byte) printf_uint::format_radix#4 +(byte) printf_uint::format_radix#5 +(byte) printf_uint::format_sign_always +(byte) printf_uint::format_sign_always#0 +(byte) printf_uint::format_sign_always#1 +(byte) printf_uint::format_sign_always#2 +(byte) printf_uint::format_sign_always#3 +(byte) printf_uint::format_sign_always#4 +(byte) printf_uint::format_sign_always#5 +(byte) printf_uint::format_upper_case +(byte) printf_uint::format_upper_case#0 +(byte) printf_uint::format_upper_case#1 +(byte) printf_uint::format_upper_case#2 +(byte) printf_uint::format_upper_case#3 +(byte) printf_uint::format_upper_case#4 +(byte) printf_uint::format_upper_case#5 +(byte) printf_uint::format_zero_padding +(byte) printf_uint::format_zero_padding#0 +(byte) printf_uint::format_zero_padding#1 +(byte) printf_uint::format_zero_padding#2 +(byte) printf_uint::format_zero_padding#3 +(byte) printf_uint::format_zero_padding#4 +(byte) printf_uint::format_zero_padding#5 +(word) printf_uint::uvalue +(word) printf_uint::uvalue#0 +(word) printf_uint::uvalue#1 +(word) printf_uint::uvalue#2 +(word) printf_uint::uvalue#3 +(word) printf_uint::uvalue#4 +(word()) strlen((byte*) strlen::str) +(bool~) strlen::$0 +(label) strlen::@1 +(label) strlen::@2 +(label) strlen::@3 +(label) strlen::@return +(word) strlen::len +(word) strlen::len#0 +(word) strlen::len#1 +(word) strlen::len#2 +(word) strlen::len#3 +(word) strlen::len#4 +(word) strlen::return +(word) strlen::return#0 +(word) strlen::return#1 +(word) strlen::return#2 +(word) strlen::return#3 +(word) strlen::return#4 +(byte*) strlen::str +(byte*) strlen::str#0 +(byte*) strlen::str#1 +(byte*) strlen::str#2 +(byte*) strlen::str#3 +(byte*) strlen::str#4 +(byte*()) strupr((byte*) strupr::str) +(byte~) strupr::$0 +(bool~) strupr::$1 +(label) strupr::@1 +(label) strupr::@2 +(label) strupr::@3 +(label) strupr::@4 +(label) strupr::@return +(byte*) strupr::return +(byte*) strupr::return#0 +(byte*) strupr::return#1 +(byte*) strupr::return#2 +(byte*) strupr::return#3 +(byte*) strupr::src +(byte*) strupr::src#0 +(byte*) strupr::src#1 +(byte*) strupr::src#2 +(byte*) strupr::src#3 +(byte*) strupr::src#4 +(byte*) strupr::str +(byte*) strupr::str#0 +(byte*) strupr::str#1 +(byte*) strupr::str#2 +(byte*) strupr::str#3 +(byte*) strupr::str#4 +(byte*) strupr::str#5 +(byte()) toupper((byte) toupper::ch) +(bool~) toupper::$0 +(bool~) toupper::$1 +(bool~) toupper::$2 +(byte~) toupper::$3 +(label) toupper::@1 +(label) toupper::@2 +(label) toupper::@return +(byte) toupper::ch +(byte) toupper::ch#0 +(byte) toupper::ch#1 +(byte) toupper::ch#2 +(byte) toupper::ch#3 +(byte) toupper::return +(byte) toupper::return#0 +(byte) toupper::return#1 +(byte) toupper::return#2 +(byte) toupper::return#3 +(byte) toupper::return#4 +(byte) toupper::return#5 +(void()) utoa((word) utoa::value , (byte*) utoa::buffer , (byte) utoa::radix) +(bool~) utoa::$0 +(bool~) utoa::$1 +(byte~) utoa::$10 +(byte~) utoa::$11 +(bool~) utoa::$2 +(bool~) utoa::$3 +(number~) utoa::$4 +(bool~) utoa::$5 +(bool~) utoa::$6 +(bool~) utoa::$7 +(bool~) utoa::$8 +(word~) utoa::$9 +(label) utoa::@1 +(label) utoa::@10 +(label) utoa::@11 +(label) utoa::@12 +(label) utoa::@13 +(label) utoa::@14 +(label) utoa::@15 +(label) utoa::@2 +(label) utoa::@3 +(label) utoa::@4 +(label) utoa::@5 +(label) utoa::@6 +(label) utoa::@7 +(label) utoa::@8 +(label) utoa::@9 +(label) utoa::@return +(byte*) utoa::buffer +(byte*) utoa::buffer#0 +(byte*) utoa::buffer#1 +(byte*) utoa::buffer#10 +(byte*) utoa::buffer#11 +(byte*) utoa::buffer#12 +(byte*) utoa::buffer#13 +(byte*) utoa::buffer#14 +(byte*) utoa::buffer#15 +(byte*) utoa::buffer#16 +(byte*) utoa::buffer#17 +(byte*) utoa::buffer#18 +(byte*) utoa::buffer#19 +(byte*) utoa::buffer#2 +(byte*) utoa::buffer#20 +(byte*) utoa::buffer#21 +(byte*) utoa::buffer#3 +(byte*) utoa::buffer#4 +(byte*) utoa::buffer#5 +(byte*) utoa::buffer#6 +(byte*) utoa::buffer#7 +(byte*) utoa::buffer#8 +(byte*) utoa::buffer#9 +(byte) utoa::digit +(byte) utoa::digit#0 +(byte) utoa::digit#1 +(byte) utoa::digit#2 +(byte) utoa::digit#3 +(byte) utoa::digit#4 +(byte) utoa::digit#5 +(byte) utoa::digit#6 +(word) utoa::digit_value +(word) utoa::digit_value#0 +(word) utoa::digit_value#1 +(word*) utoa::digit_values +(word*) utoa::digit_values#0 +(word*) utoa::digit_values#1 +(word*) utoa::digit_values#10 +(word*) utoa::digit_values#2 +(word*) utoa::digit_values#3 +(word*) utoa::digit_values#4 +(word*) utoa::digit_values#5 +(word*) utoa::digit_values#6 +(word*) utoa::digit_values#7 +(word*) utoa::digit_values#8 +(word*) utoa::digit_values#9 +(byte) utoa::max_digits +(byte) utoa::max_digits#0 +(byte) utoa::max_digits#1 +(byte) utoa::max_digits#10 +(byte) utoa::max_digits#2 +(byte) utoa::max_digits#3 +(byte) utoa::max_digits#4 +(byte) utoa::max_digits#5 +(byte) utoa::max_digits#6 +(byte) utoa::max_digits#7 +(byte) utoa::max_digits#8 +(byte) utoa::max_digits#9 +(byte) utoa::radix +(byte) utoa::radix#0 +(byte) utoa::radix#1 +(byte) utoa::radix#2 +(byte) utoa::radix#3 +(byte) utoa::radix#4 +(byte) utoa::started +(byte) utoa::started#0 +(byte) utoa::started#1 +(byte) utoa::started#2 +(byte) utoa::started#3 +(byte) utoa::started#4 +(word) utoa::value +(word) utoa::value#0 +(word) utoa::value#1 +(word) utoa::value#10 +(word) utoa::value#11 +(word) utoa::value#12 +(word) utoa::value#13 +(word) utoa::value#14 +(word) utoa::value#15 +(word) utoa::value#2 +(word) utoa::value#3 +(word) utoa::value#4 +(word) utoa::value#5 +(word) utoa::value#6 +(word) utoa::value#7 +(word) utoa::value#8 +(word) utoa::value#9 +(word()) utoa_append((byte*) utoa_append::buffer , (word) utoa_append::value , (word) utoa_append::sub) +(bool~) utoa_append::$0 +(label) utoa_append::@1 +(label) utoa_append::@2 +(label) utoa_append::@3 +(label) utoa_append::@return +(byte*) utoa_append::buffer +(byte*) utoa_append::buffer#0 +(byte*) utoa_append::buffer#1 +(byte*) utoa_append::buffer#2 +(byte*) utoa_append::buffer#3 +(byte*) utoa_append::buffer#4 +(byte) utoa_append::digit +(byte) utoa_append::digit#0 +(byte) utoa_append::digit#1 +(byte) utoa_append::digit#2 +(byte) utoa_append::digit#3 +(byte) utoa_append::digit#4 +(word) utoa_append::return +(word) utoa_append::return#0 +(word) utoa_append::return#1 +(word) utoa_append::return#2 +(word) utoa_append::return#3 +(word) utoa_append::return#4 +(word) utoa_append::sub +(word) utoa_append::sub#0 +(word) utoa_append::sub#1 +(word) utoa_append::sub#2 +(word) utoa_append::sub#3 +(word) utoa_append::value +(word) utoa_append::value#0 +(word) utoa_append::value#1 +(word) utoa_append::value#2 +(word) utoa_append::value#3 +(word) utoa_append::value#4 +(word) utoa_append::value#5 + +Adding number conversion cast (unumber) 0 in (bool~) memset::$0 ← (word) memset::num#3 > (number) 0 +Adding number conversion cast (unumber) 0 in (bool~) strupr::$1 ← (number) 0 != *((byte*) strupr::src#2) +Adding number conversion cast (unumber) 0 in (bool~) strlen::$0 ← (number) 0 != *((byte*) strlen::str#2) +Adding number conversion cast (unumber) 0 in (bool~) mul8u::$0 ← (byte) mul8u::a#2 != (number) 0 +Adding number conversion cast (unumber) 1 in (number~) mul8u::$1 ← (byte) mul8u::a#3 & (number) 1 +Adding number conversion cast (unumber) mul8u::$1 in (number~) mul8u::$1 ← (byte) mul8u::a#3 & (unumber)(number) 1 +Adding number conversion cast (unumber) 0 in (bool~) mul8u::$2 ← (unumber~) mul8u::$1 != (number) 0 +Adding number conversion cast (unumber) 1 in (byte~) mul8u::$5 ← (byte) mul8u::a#4 >> (number) 1 +Adding number conversion cast (unumber) 1 in (word~) mul8u::$6 ← (word) mul8u::mb#2 << (number) 1 +Adding number conversion cast (snumber) 0 in (bool~) mul8s::$1 ← (signed byte) mul8s::a#3 < (number) 0 +Adding number conversion cast (snumber) 0 in (bool~) mul8s::$3 ← (signed byte) mul8s::b#3 < (number) 0 +Adding number conversion cast (unumber) $19 in (bool~) gotoxy::$0 ← (byte) gotoxy::y#3 > (number) $19 +Adding number conversion cast (unumber) $28 in (bool~) gotoxy::$2 ← (byte) gotoxy::x#3 >= (number) $28 +Adding number conversion cast (unumber) 0 in (byte) gotoxy::y#0 ← (number) 0 +Adding number conversion cast (unumber) $28 in (number~) gotoxy::$4 ← (word~) gotoxy::$8 * (number) $28 +Adding number conversion cast (unumber) gotoxy::$4 in (number~) gotoxy::$4 ← (word~) gotoxy::$8 * (unumber)(number) $28 +Adding number conversion cast (unumber) gotoxy::$5 in (number~) gotoxy::$5 ← (unumber~) gotoxy::$4 + (byte) gotoxy::x#4 +Adding number conversion cast (unumber) 0 in (byte) gotoxy::x#0 ← (number) 0 +Adding number conversion cast (unumber) $28 in (bool~) cputc::$1 ← (byte) conio_cursor_x == (number) $28 +Adding number conversion cast (unumber) 0 in (byte) conio_cursor_x ← (number) 0 +Adding number conversion cast (unumber) $28 in (number~) cputln::$0 ← (number) $28 - (byte) conio_cursor_x +Adding number conversion cast (unumber) cputln::$0 in (number~) cputln::$0 ← (unumber)(number) $28 - (byte) conio_cursor_x +Adding number conversion cast (unumber) 0 in (byte) conio_cursor_x ← (number) 0 +Adding number conversion cast (unumber) $19 in (bool~) cscroll::$0 ← (byte) conio_cursor_y == (number) $19 +Adding number conversion cast (unumber) 0 in (bool~) cscroll::$9 ← (number) 0 != (byte) conio_scroll_enable +Adding number conversion cast (unumber) $28 in (void*) memcpy::source#0 ← (void*)(const nomodify byte*) CONIO_SCREEN_TEXT+(number) $28 +Adding number conversion cast (unumber) $19*$28-$28 in (word) memcpy::num#0 ← (number) $19*(number) $28-(number) $28 +Adding number conversion cast (unumber) $28 in (void*) memcpy::source#1 ← (void*)(const nomodify byte*) CONIO_SCREEN_COLORS+(number) $28 +Adding number conversion cast (unumber) $19*$28-$28 in (word) memcpy::num#1 ← (number) $19*(number) $28-(number) $28 +Adding number conversion cast (unumber) $28 in (void*) memset::str#0 ← (void*)(const nomodify byte*) CONIO_SCREEN_TEXT+(number) $19*(number) $28-(number) $28 +Adding number conversion cast (unumber) $19*$28 in (void*) memset::str#0 ← (void*)(const nomodify byte*) CONIO_SCREEN_TEXT+(number) $19*(number) $28-(unumber)(number) $28 +Adding number conversion cast (unumber) $28 in (word) memset::num#0 ← (number) $28 +Adding number conversion cast (unumber) $28 in (void*) memset::str#1 ← (void*)(const nomodify byte*) CONIO_SCREEN_COLORS+(number) $19*(number) $28-(number) $28 +Adding number conversion cast (unumber) $19*$28 in (void*) memset::str#1 ← (void*)(const nomodify byte*) CONIO_SCREEN_COLORS+(number) $19*(number) $28-(unumber)(number) $28 +Adding number conversion cast (unumber) $28 in (word) memset::num#1 ← (number) $28 +Adding number conversion cast (unumber) $28 in (byte*~) cscroll::$7 ← (byte*) conio_cursor_text - (number) $28 +Adding number conversion cast (unumber) $28 in (byte*~) cscroll::$8 ← (byte*) conio_cursor_color - (number) $28 +Adding number conversion cast (unumber) 0 in (byte) gotoxy::x#1 ← (number) 0 +Adding number conversion cast (unumber) 0 in (byte) gotoxy::y#1 ← (number) 0 +Adding number conversion cast (unumber) 0 in (bool~) cputs::$1 ← (number) 0 != (byte) cputs::c#1 +Adding number conversion cast (unumber) 5 in (byte) utoa::max_digits#1 ← (number) 5 +Adding number conversion cast (unumber) 4 in (byte) utoa::max_digits#2 ← (number) 4 +Adding number conversion cast (unumber) 6 in (byte) utoa::max_digits#3 ← (number) 6 +Adding number conversion cast (unumber) $10 in (byte) utoa::max_digits#4 ← (number) $10 +Adding number conversion cast (unumber) 0 in *((byte*) utoa::buffer#2) ← (number) 0 +Adding number conversion cast (unumber) 1 in (number~) utoa::$4 ← (byte) utoa::max_digits#5 - (number) 1 +Adding number conversion cast (unumber) utoa::$4 in (number~) utoa::$4 ← (byte) utoa::max_digits#5 - (unumber)(number) 1 +Adding number conversion cast (unumber) 0 in *((byte*) utoa::buffer#3) ← (number) 0 +Adding number conversion cast (unumber) 1 in (byte) utoa::started#1 ← (number) 1 +Adding number conversion cast (unumber) 0 in (bool~) printf_uint::$5 ← (number) 0 != (byte) printf_uint::format_sign_always#1 +Adding number conversion cast (unumber) printf_uint::$2 in (byte) printf_uint::format_upper_case#2 ← phi( printf_uint::@1/(byte) printf_uint::format_upper_case#3 printf_uint::@2/(byte) printf_uint::format_upper_case#4 ) + (byte) printf_uint::format_zero_padding#2 ← phi( printf_uint::@1/(byte) printf_uint::format_zero_padding#3 printf_uint::@2/(byte) printf_uint::format_zero_padding#4 ) + (byte) printf_uint::format_sign_always#3 ← phi( printf_uint::@1/(byte) printf_uint::format_sign_always#4 printf_uint::@2/(byte) printf_uint::format_sign_always#5 ) + (byte) printf_uint::format_justify_left#2 ← phi( printf_uint::@1/(byte) printf_uint::format_justify_left#3 printf_uint::@2/(byte) printf_uint::format_justify_left#4 ) + (byte) printf_uint::format_min_length#2 ← phi( printf_uint::@1/(byte) printf_uint::format_min_length#3 printf_uint::@2/(byte) printf_uint::format_min_length#4 ) + (byte) printf_uint::format_radix#1 ← phi( printf_uint::@1/(byte) printf_uint::format_radix#3 printf_uint::@2/(byte) printf_uint::format_radix#4 ) + (word) printf_uint::uvalue#1 ← phi( printf_uint::@1/(word) printf_uint::uvalue#2 printf_uint::@2/(word) printf_uint::uvalue#3 ) + (number~) printf_uint::$2 ← phi( printf_uint::@1/(byte~) printf_uint::$1 printf_uint::@2/(number~) printf_uint::$0 ) +Adding number conversion cast (unumber) printf_uint::$0 in (byte) printf_uint::format_upper_case#2 ← phi( printf_uint::@1/(byte) printf_uint::format_upper_case#3 printf_uint::@2/(byte) printf_uint::format_upper_case#4 ) + (byte) printf_uint::format_zero_padding#2 ← phi( printf_uint::@1/(byte) printf_uint::format_zero_padding#3 printf_uint::@2/(byte) printf_uint::format_zero_padding#4 ) + (byte) printf_uint::format_sign_always#3 ← phi( printf_uint::@1/(byte) printf_uint::format_sign_always#4 printf_uint::@2/(byte) printf_uint::format_sign_always#5 ) + (byte) printf_uint::format_justify_left#2 ← phi( printf_uint::@1/(byte) printf_uint::format_justify_left#3 printf_uint::@2/(byte) printf_uint::format_justify_left#4 ) + (byte) printf_uint::format_min_length#2 ← phi( printf_uint::@1/(byte) printf_uint::format_min_length#3 printf_uint::@2/(byte) printf_uint::format_min_length#4 ) + (byte) printf_uint::format_radix#1 ← phi( printf_uint::@1/(byte) printf_uint::format_radix#3 printf_uint::@2/(byte) printf_uint::format_radix#4 ) + (word) printf_uint::uvalue#1 ← phi( printf_uint::@1/(word) printf_uint::uvalue#2 printf_uint::@2/(word) printf_uint::uvalue#3 ) + (unumber~) printf_uint::$2 ← phi( printf_uint::@1/(byte~) printf_uint::$1 printf_uint::@2/(number~) printf_uint::$0 ) +Adding number conversion cast (unumber) 0 in (bool~) printf_number_buffer::$26 ← (number) 0 != (byte) printf_number_buffer::format_min_length#1 +Adding number conversion cast (unumber) 0 in (bool~) printf_number_buffer::$27 ← (number) 0 != (byte) printf_number_buffer::format_justify_left#1 +Adding number conversion cast (unumber) 0 in (bool~) printf_number_buffer::$28 ← (number) 0 != (byte) printf_number_buffer::format_zero_padding#1 +Adding number conversion cast (unumber) 0 in (bool~) printf_number_buffer::$29 ← (number) 0 != (byte) printf_number_buffer::buffer_sign#1 +Adding number conversion cast (snumber) 0 in (bool~) printf_number_buffer::$22 ← (signed byte) printf_number_buffer::padding#1 < (number) 0 +Adding number conversion cast (snumber) 0 in (signed byte) printf_number_buffer::padding#2 ← (number) 0 +Adding number conversion cast (unumber) 0 in (bool~) printf_number_buffer::$30 ← (number) 0 != (byte) printf_number_buffer::buffer_sign#2 +Adding number conversion cast (unumber) 0 in (bool~) printf_number_buffer::$31 ← (number) 0 != (byte) printf_number_buffer::format_upper_case#1 +Adding number conversion cast (unumber) 0 in (bool~) printf_number_buffer::$32 ← (number) 0 != (byte) printf_number_buffer::format_zero_padding#3 +Adding number conversion cast (unumber) $3e8 in (word) memset::num#2 ← (number) $3e8 +Adding number conversion cast (unumber) $19 in (bool~) main::$3 ← (byte) main::y#2 < (number) $19 +Adding number conversion cast (unumber) 0 in (byte) gotoxy::x#2 ← (number) 0 +Adding number conversion cast (unumber) 0 in (byte) gotoxy::y#2 ← (number) 0 +Adding number conversion cast (unumber) $28 in (bool~) main::$4 ← (byte) main::x#2 < (number) $28 +Adding number conversion cast (snumber) 2 in (number~) main::$5 ← (signed byte~) main::$14 * (number) 2 +Adding number conversion cast (snumber) main::$5 in (number~) main::$5 ← (signed byte~) main::$14 * (snumber)(number) 2 +Adding number conversion cast (snumber) $27 in (number~) main::$6 ← (snumber~) main::$5 - (number) $27 +Adding number conversion cast (snumber) main::$6 in (number~) main::$6 ← (snumber~) main::$5 - (snumber)(number) $27 +Adding number conversion cast (snumber) 2 in (number~) main::$7 ← (signed byte~) main::$15 * (number) 2 +Adding number conversion cast (snumber) main::$7 in (number~) main::$7 ← (signed byte~) main::$15 * (snumber)(number) 2 +Adding number conversion cast (snumber) $18 in (number~) main::$8 ← (snumber~) main::$7 - (number) $18 +Adding number conversion cast (snumber) main::$8 in (number~) main::$8 ← (snumber~) main::$7 - (snumber)(number) $18 +Adding number conversion cast (snumber) 2*9*2*9 in (bool~) main::$12 ← (signed word) main::dist_sq#0 < (number) 2*(number) 9*(number) 2*(number) 9 +Successful SSA optimization PassNAddNumberTypeConversions +Adding number conversion cast (unumber) 0 in (unumber~) printf_uint::$0 ← (number) 0 +Successful SSA optimization PassNAddNumberTypeConversions +Inlining cast (byte*) memcpy::src#0 ← (byte*)(void*) memcpy::source#2 +Inlining cast (byte*) memcpy::dst#0 ← (byte*)(void*) memcpy::destination#2 +Inlining cast (byte*) memset::dst#0 ← (byte*)(void*) memset::str#4 +Inlining cast (byte) gotoxy::y#0 ← (unumber)(number) 0 +Inlining cast (byte) gotoxy::x#0 ← (unumber)(number) 0 +Inlining cast (byte) conio_cursor_x ← (unumber)(number) 0 +Inlining cast (byte) conio_cursor_x ← (unumber)(number) 0 +Inlining cast (word) memcpy::num#0 ← (unumber)(number) $19*(number) $28-(number) $28 +Inlining cast (word) memcpy::num#1 ← (unumber)(number) $19*(number) $28-(number) $28 +Inlining cast (word) memset::num#0 ← (unumber)(number) $28 +Inlining cast (word) memset::num#1 ← (unumber)(number) $28 +Inlining cast (byte) gotoxy::x#1 ← (unumber)(number) 0 +Inlining cast (byte) gotoxy::y#1 ← (unumber)(number) 0 +Inlining cast (byte) utoa::max_digits#1 ← (unumber)(number) 5 +Inlining cast (byte) utoa::max_digits#2 ← (unumber)(number) 4 +Inlining cast (byte) utoa::max_digits#3 ← (unumber)(number) 6 +Inlining cast (byte) utoa::max_digits#4 ← (unumber)(number) $10 +Inlining cast *((byte*) utoa::buffer#2) ← (unumber)(number) 0 +Inlining cast *((byte*) utoa::buffer#3) ← (unumber)(number) 0 +Inlining cast (byte) utoa::started#1 ← (unumber)(number) 1 +Inlining cast (unumber~) printf_uint::$0 ← (unumber)(number) 0 +Inlining cast (signed byte) printf_number_buffer::padding#2 ← (snumber)(number) 0 +Inlining cast (word) memset::num#2 ← (unumber)(number) $3e8 +Inlining cast (byte) gotoxy::x#2 ← (unumber)(number) 0 +Inlining cast (byte) gotoxy::y#2 ← (unumber)(number) 0 +Successful SSA optimization Pass2InlineCast +Simplifying constant pointer cast (byte*) 1024 +Simplifying constant pointer cast (byte*) 55296 +Simplifying constant pointer cast (byte*) 1024 +Simplifying constant integer cast 0 +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 1 +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Simplifying constant integer cast $19 +Simplifying constant integer cast $28 +Simplifying constant integer cast 0 +Simplifying constant integer cast $28 +Simplifying constant integer cast 0 +Simplifying constant integer cast $28 +Simplifying constant integer cast 0 +Simplifying constant integer cast $28 +Simplifying constant integer cast 0 +Simplifying constant integer cast $19 +Simplifying constant integer cast 0 +Simplifying constant integer cast $28 +Simplifying constant integer cast $28 +Simplifying constant integer cast $28 +Simplifying constant integer cast $28 +Simplifying constant integer cast $28 +Simplifying constant integer cast $28 +Simplifying constant integer cast $28 +Simplifying constant integer cast $28 +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Simplifying constant integer cast 5 +Simplifying constant integer cast 4 +Simplifying constant integer cast 6 +Simplifying constant integer cast $10 +Simplifying constant integer cast 0 +Simplifying constant integer cast 1 +Simplifying constant integer cast 0 +Simplifying constant integer cast 1 +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Simplifying constant integer cast $3e8 +Simplifying constant integer cast $19 +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Simplifying constant integer cast $28 +Simplifying constant integer cast 2 +Simplifying constant integer cast $27 +Simplifying constant integer cast 2 +Simplifying constant integer cast $18 +Successful SSA optimization PassNCastSimplification +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) 1 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 1 +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) $19 +Finalized unsigned number type (byte) $28 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) $28 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) $28 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) $28 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) $19 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) $28 +Finalized unsigned number type (byte) $28 +Finalized unsigned number type (byte) $28 +Finalized unsigned number type (byte) $28 +Finalized unsigned number type (byte) $28 +Finalized unsigned number type (byte) $28 +Finalized unsigned number type (byte) $28 +Finalized unsigned number type (byte) $28 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 5 +Finalized unsigned number type (byte) 4 +Finalized unsigned number type (byte) 6 +Finalized unsigned number type (byte) $10 +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) 0 +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) 0 +Finalized signed number type (signed byte) 0 +Finalized signed number type (signed byte) 0 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (word) $3e8 +Finalized unsigned number type (byte) $19 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) $28 +Finalized signed number type (signed byte) 2 +Finalized signed number type (signed byte) $27 +Finalized signed number type (signed byte) 2 +Finalized signed number type (signed byte) $18 +Successful SSA optimization PassNFinalizeNumberTypeConversions +Inferred type updated to byte in (unumber~) mul8u::$1 ← (byte) mul8u::a#3 & (byte) 1 +Inferred type updated to word in (unumber~) gotoxy::$4 ← (word~) gotoxy::$8 * (byte) $28 +Inferred type updated to word in (unumber~) gotoxy::$5 ← (word~) gotoxy::$4 + (byte) gotoxy::x#4 +Inferred type updated to byte in (unumber~) cputln::$0 ← (byte) $28 - (byte) conio_cursor_x +Inferred type updated to byte in (unumber~) utoa::$4 ← (byte) utoa::max_digits#5 - (byte) 1 +Inferred type updated to byte in (unumber~) printf_uint::$0 ← (byte) 0 +Inferred type updated to byte for (unumber~) printf_uint::$2 +Inferred type updated to signed byte in (snumber~) main::$5 ← (signed byte~) main::$14 * (signed byte) 2 +Inferred type updated to signed byte in (snumber~) main::$6 ← (signed byte~) main::$5 - (signed byte) $27 +Inferred type updated to signed byte in (snumber~) main::$7 ← (signed byte~) main::$15 * (signed byte) 2 +Inferred type updated to signed byte in (snumber~) main::$8 ← (signed byte~) main::$7 - (signed byte) $18 +Inversing boolean not [33] (bool~) memset::$1 ← (word) memset::num#3 <= (byte) 0 from [32] (bool~) memset::$0 ← (word) memset::num#3 > (byte) 0 +Inversing boolean not [91] (bool~) mul8u::$3 ← (byte~) mul8u::$1 == (byte) 0 from [90] (bool~) mul8u::$2 ← (byte~) mul8u::$1 != (byte) 0 +Inversing boolean not [115] (bool~) mul8s::$2 ← (signed byte) mul8s::a#3 >= (signed byte) 0 from [114] (bool~) mul8s::$1 ← (signed byte) mul8s::a#3 < (signed byte) 0 +Inversing boolean not [119] (bool~) mul8s::$4 ← (signed byte) mul8s::b#3 >= (signed byte) 0 from [118] (bool~) mul8s::$3 ← (signed byte) mul8s::b#3 < (signed byte) 0 +Inversing boolean not [146] (bool~) gotoxy::$1 ← (byte) gotoxy::y#3 <= (byte) $19 from [145] (bool~) gotoxy::$0 ← (byte) gotoxy::y#3 > (byte) $19 +Inversing boolean not [150] (bool~) gotoxy::$3 ← (byte) gotoxy::x#3 < (byte) $28 from [149] (bool~) gotoxy::$2 ← (byte) gotoxy::x#3 >= (byte) $28 +Inversing boolean not [179] (bool~) cputc::$2 ← (byte) conio_cursor_x != (byte) $28 from [178] (bool~) cputc::$1 ← (byte) conio_cursor_x == (byte) $28 +Inversing boolean not [196] (bool~) cscroll::$1 ← (byte) conio_cursor_y != (byte) $19 from [195] (bool~) cscroll::$0 ← (byte) conio_cursor_y == (byte) $19 +Inversing boolean not [360] (bool~) printf_number_buffer::$0 ← (byte) 0 == (byte) printf_number_buffer::format_min_length#1 from [359] (bool~) printf_number_buffer::$26 ← (byte) 0 != (byte) printf_number_buffer::format_min_length#1 +Inversing boolean not [364] (bool~) printf_number_buffer::$1 ← (byte) 0 == (byte) printf_number_buffer::format_justify_left#1 from [363] (bool~) printf_number_buffer::$27 ← (byte) 0 != (byte) printf_number_buffer::format_justify_left#1 +Inversing boolean not [366] (bool~) printf_number_buffer::$2 ← (byte) 0 == (byte) printf_number_buffer::format_zero_padding#1 from [365] (bool~) printf_number_buffer::$28 ← (byte) 0 != (byte) printf_number_buffer::format_zero_padding#1 +Inversing boolean not [379] (bool~) printf_number_buffer::$20 ← (byte) 0 == (byte) printf_number_buffer::buffer_sign#1 from [378] (bool~) printf_number_buffer::$29 ← (byte) 0 != (byte) printf_number_buffer::buffer_sign#1 +Inversing boolean not [386] (bool~) printf_number_buffer::$23 ← (signed byte) printf_number_buffer::padding#1 >= (signed byte) 0 from [385] (bool~) printf_number_buffer::$22 ← (signed byte) printf_number_buffer::padding#1 < (signed byte) 0 +Inversing boolean not [394] (bool~) printf_number_buffer::$7 ← (byte) 0 == (byte) printf_number_buffer::buffer_sign#2 from [393] (bool~) printf_number_buffer::$30 ← (byte) 0 != (byte) printf_number_buffer::buffer_sign#2 +Inversing boolean not [411] (bool~) printf_number_buffer::$12 ← (byte) 0 == (byte) printf_number_buffer::format_upper_case#1 from [410] (bool~) printf_number_buffer::$31 ← (byte) 0 != (byte) printf_number_buffer::format_upper_case#1 +Inversing boolean not [423] (bool~) printf_number_buffer::$14 ← (byte) 0 == (byte) printf_number_buffer::format_zero_padding#3 from [422] (bool~) printf_number_buffer::$32 ← (byte) 0 != (byte) printf_number_buffer::format_zero_padding#3 +Inversing boolean not [493] (bool~) main::$13 ← (signed word) main::dist_sq#0 >= (signed word)(number) 2*(number) 9*(number) 2*(number) 9 from [492] (bool~) main::$12 ← (signed word) main::dist_sq#0 < (signed word)(number) 2*(number) 9*(number) 2*(number) 9 +Successful SSA optimization Pass2UnaryNotSimplification +Alias candidate removed (volatile)conio_cursor_text = gotoxy::$6 cputln::$1 cscroll::$7 +Alias candidate removed (volatile)conio_cursor_color = gotoxy::$7 cputln::$2 cscroll::$8 +Alias toupper::ch#1 = toupper::ch#2 toupper::ch#3 toupper::return#1 +Alias toupper::return#0 = toupper::$3 +Alias toupper::return#2 = toupper::return#4 +Alias memcpy::src_end#0 = memcpy::$0 +Alias memcpy::src#2 = memcpy::src#3 +Alias memcpy::dst#2 = memcpy::dst#3 +Alias memcpy::src_end#1 = memcpy::src_end#2 +Alias memcpy::destination#3 = memcpy::destination#5 memcpy::destination#4 memcpy::return#0 memcpy::return#4 memcpy::return#1 +Alias memset::return#0 = memset::str#3 memset::return#5 memset::return#1 +Alias memset::str#4 = memset::str#5 +Alias memset::num#3 = memset::num#4 +Alias memset::c#5 = memset::c#6 +Alias memset::end#0 = memset::$2 +Alias memset::c#3 = memset::c#4 +Alias memset::dst#2 = memset::dst#3 +Alias memset::end#1 = memset::end#2 +Alias memset::str#6 = memset::str#7 +Alias strupr::src#0 = strupr::str#1 +Alias strupr::src#2 = strupr::src#3 strupr::src#4 +Alias strupr::str#2 = strupr::str#5 strupr::str#3 strupr::str#4 strupr::return#0 strupr::return#3 strupr::return#1 +Alias toupper::return#3 = toupper::return#5 +Alias strlen::len#2 = strlen::len#4 strlen::len#3 strlen::return#0 strlen::return#3 strlen::return#1 +Alias strlen::str#2 = strlen::str#3 +Alias mul8u::a#2 = mul8u::a#3 mul8u::a#6 +Alias mul8u::mb#3 = mul8u::mb#4 mul8u::mb#5 +Alias mul8u::res#2 = mul8u::res#5 mul8u::res#4 mul8u::return#0 mul8u::res#3 mul8u::return#3 mul8u::return#1 +Alias mul8u::a#0 = mul8u::$5 +Alias mul8u::mb#1 = mul8u::$6 +Alias mul8u::res#1 = mul8u::$4 +Alias mul8u::return#2 = mul8u::return#4 +Alias mul8s::a#2 = mul8s::a#3 mul8s::a#6 +Alias mul8s::b#2 = mul8s::b#5 mul8s::b#4 +Alias mul8s::m#0 = mul8s::$0 mul8s::m#3 +Alias mul8s::$11 = mul8s::$7 +Alias mul8s::m#5 = mul8s::m#6 +Alias mul8s::a#4 = mul8s::a#5 +Alias mul8s::$12 = mul8s::$10 +Alias mul8s::return#0 = mul8s::return#4 mul8s::return#1 +Alias gotoxy::x#5 = gotoxy::x#6 +Alias gotoxy::offset#0 = gotoxy::$5 +Alias gotoxy::y#5 = gotoxy::y#6 +Alias cputc::c#3 = cputc::c#4 +Alias cputln::ln_offset#0 = cputln::$0 +Alias cputs::c#1 = cputs::c#2 +Alias cputs::s#0 = cputs::s#6 cputs::s#5 +Alias utoa::value#10 = utoa::value#8 utoa::value#12 utoa::value#13 utoa::value#9 utoa::value#14 utoa::value#15 utoa::value#11 +Alias utoa::buffer#10 = utoa::buffer#17 utoa::buffer#21 utoa::buffer#16 utoa::buffer#18 utoa::buffer#13 utoa::buffer#19 utoa::buffer#20 utoa::buffer#6 +Alias utoa::radix#1 = utoa::radix#2 utoa::radix#3 utoa::radix#4 +Alias utoa::digit#2 = utoa::digit#3 utoa::digit#6 utoa::digit#5 +Alias utoa::digit_values#10 = utoa::digit_values#5 utoa::digit_values#6 utoa::digit_values#9 +Alias utoa::value#2 = utoa::value#5 utoa::value#3 utoa::value#4 +Alias utoa::started#2 = utoa::started#3 +Alias utoa::buffer#11 = utoa::buffer#12 utoa::buffer#7 utoa::buffer#8 utoa::buffer#9 +Alias utoa::max_digits#10 = utoa::max_digits#8 utoa::max_digits#5 utoa::max_digits#9 +Alias utoa::digit_value#0 = utoa::digit_value#1 +Alias utoa_append::return#0 = utoa_append::return#3 +Alias utoa::value#0 = utoa::$9 +Alias utoa_append::digit#2 = utoa_append::digit#4 utoa_append::digit#3 +Alias utoa_append::value#2 = utoa_append::value#3 utoa_append::value#4 utoa_append::return#1 utoa_append::return#4 utoa_append::return#2 +Alias utoa_append::sub#1 = utoa_append::sub#2 +Alias utoa_append::buffer#1 = utoa_append::buffer#4 utoa_append::buffer#2 +Alias printf_padding::pad#3 = printf_padding::pad#4 printf_padding::pad#6 +Alias printf_padding::i#2 = printf_padding::i#4 printf_padding::i#3 +Alias printf_padding::length#3 = printf_padding::length#6 printf_padding::length#5 +Alias printf_uint::uvalue#2 = printf_uint::uvalue#4 printf_uint::uvalue#3 +Alias printf_uint::format_radix#3 = printf_uint::format_radix#5 printf_uint::format_radix#4 +Alias printf_uint::format_min_length#3 = printf_uint::format_min_length#5 printf_uint::format_min_length#4 +Alias printf_uint::format_justify_left#3 = printf_uint::format_justify_left#5 printf_uint::format_justify_left#4 +Alias printf_uint::format_sign_always#1 = printf_uint::format_sign_always#4 printf_uint::format_sign_always#5 +Alias printf_uint::format_zero_padding#3 = printf_uint::format_zero_padding#5 printf_uint::format_zero_padding#4 +Alias printf_uint::format_upper_case#3 = printf_uint::format_upper_case#5 printf_uint::format_upper_case#4 +Alias printf_uint::format_min_length#1 = printf_uint::format_min_length#2 +Alias printf_uint::format_justify_left#1 = printf_uint::format_justify_left#2 +Alias printf_uint::format_sign_always#2 = printf_uint::format_sign_always#3 +Alias printf_uint::format_zero_padding#1 = printf_uint::format_zero_padding#2 +Alias printf_uint::format_upper_case#1 = printf_uint::format_upper_case#2 +Alias printf_uint::format_radix#1 = printf_uint::format_radix#2 +Alias printf_number_buffer::buffer_digits#1 = printf_number_buffer::buffer_digits#4 printf_number_buffer::buffer_digits#18 printf_number_buffer::buffer_digits#19 +Alias printf_number_buffer::buffer_sign#1 = printf_number_buffer::buffer_sign#4 printf_number_buffer::buffer_sign#7 printf_number_buffer::buffer_sign#11 +Alias printf_number_buffer::format_min_length#1 = printf_number_buffer::format_min_length#5 printf_number_buffer::format_min_length#3 printf_number_buffer::format_min_length#4 +Alias printf_number_buffer::format_justify_left#11 = printf_number_buffer::format_justify_left#3 printf_number_buffer::format_justify_left#7 printf_number_buffer::format_justify_left#8 +Alias printf_number_buffer::format_zero_padding#10 = printf_number_buffer::format_zero_padding#16 printf_number_buffer::format_zero_padding#4 printf_number_buffer::format_zero_padding#11 +Alias printf_number_buffer::format_upper_case#10 = printf_number_buffer::format_upper_case#16 printf_number_buffer::format_upper_case#14 printf_number_buffer::format_upper_case#15 +Alias strlen::return#2 = strlen::return#4 +Alias printf_number_buffer::padding#1 = printf_number_buffer::$21 +Alias printf_number_buffer::len#0 = printf_number_buffer::len#3 +Alias printf_number_buffer::format_justify_left#4 = printf_number_buffer::format_justify_left#5 +Alias printf_number_buffer::format_zero_padding#5 = printf_number_buffer::format_zero_padding#6 +Alias printf_number_buffer::buffer_sign#8 = printf_number_buffer::buffer_sign#9 +Alias printf_number_buffer::format_upper_case#11 = printf_number_buffer::format_upper_case#12 +Alias printf_number_buffer::buffer_digits#15 = printf_number_buffer::buffer_digits#16 +Alias printf_number_buffer::padding#12 = printf_number_buffer::padding#4 printf_number_buffer::padding#3 +Alias printf_number_buffer::buffer_sign#10 = printf_number_buffer::buffer_sign#5 printf_number_buffer::buffer_sign#6 +Alias printf_number_buffer::format_zero_padding#1 = printf_number_buffer::format_zero_padding#17 printf_number_buffer::format_zero_padding#12 +Alias printf_number_buffer::format_upper_case#13 = printf_number_buffer::format_upper_case#7 printf_number_buffer::format_upper_case#8 +Alias printf_number_buffer::buffer_digits#12 = printf_number_buffer::buffer_digits#17 printf_number_buffer::buffer_digits#13 +Alias printf_number_buffer::format_justify_left#1 = printf_number_buffer::format_justify_left#20 printf_number_buffer::format_justify_left#18 +Alias printf_number_buffer::buffer_sign#2 = printf_number_buffer::buffer_sign#3 +Alias printf_number_buffer::format_zero_padding#13 = printf_number_buffer::format_zero_padding#8 printf_number_buffer::format_zero_padding#7 +Alias printf_number_buffer::padding#10 = printf_number_buffer::padding#13 printf_number_buffer::padding#9 +Alias printf_number_buffer::format_upper_case#4 = printf_number_buffer::format_upper_case#9 printf_number_buffer::format_upper_case#5 +Alias printf_number_buffer::buffer_digits#10 = printf_number_buffer::buffer_digits#14 printf_number_buffer::buffer_digits#9 +Alias printf_number_buffer::format_justify_left#15 = printf_number_buffer::format_justify_left#19 printf_number_buffer::format_justify_left#16 +Alias printf_number_buffer::padding#16 = printf_number_buffer::padding#6 printf_number_buffer::padding#5 +Alias printf_number_buffer::format_upper_case#2 = printf_number_buffer::format_upper_case#6 printf_number_buffer::format_upper_case#3 +Alias printf_number_buffer::buffer_digits#11 = printf_number_buffer::buffer_digits#8 printf_number_buffer::buffer_digits#7 +Alias printf_number_buffer::format_zero_padding#18 = printf_number_buffer::format_zero_padding#20 printf_number_buffer::format_zero_padding#2 +Alias printf_number_buffer::format_justify_left#12 = printf_number_buffer::format_justify_left#17 printf_number_buffer::format_justify_left#13 +Alias printf_number_buffer::format_zero_padding#3 = printf_number_buffer::format_zero_padding#9 +Alias printf_number_buffer::format_justify_left#2 = printf_number_buffer::format_justify_left#6 +Alias printf_number_buffer::padding#11 = printf_number_buffer::padding#7 printf_number_buffer::padding#8 +Alias printf_number_buffer::buffer_digits#3 = printf_number_buffer::buffer_digits#6 printf_number_buffer::buffer_digits#5 +Alias printf_number_buffer::format_zero_padding#14 = printf_number_buffer::format_zero_padding#19 printf_number_buffer::format_zero_padding#15 +Alias printf_number_buffer::format_justify_left#10 = printf_number_buffer::format_justify_left#14 printf_number_buffer::format_justify_left#9 +Alias printf_number_buffer::padding#14 = printf_number_buffer::padding#17 printf_number_buffer::padding#15 +Alias main::y#2 = main::y#6 +Alias main::sc#8 = main::sc#9 +Alias main::count#11 = main::count#6 main::count#4 main::count#2 +Alias main::x#2 = main::x#3 main::x#7 main::x#5 main::x#6 +Alias main::y#10 = main::y#3 main::y#5 main::y#8 main::y#4 main::y#9 +Alias main::sc#10 = main::sc#6 main::sc#7 main::sc#5 main::sc#4 main::sc#3 +Alias main::count#10 = main::count#9 main::count#7 main::count#5 main::count#8 main::count#3 +Alias main::xd#0 = main::$6 +Alias main::yd#0 = main::$8 main::yd#1 +Alias mul8s::return#2 = mul8s::return#5 +Alias mul8s::return#3 = mul8s::return#6 +Alias main::dist_sq#0 = main::$11 +Successful SSA optimization Pass2AliasElimination +Alias candidate removed (volatile)conio_cursor_text = gotoxy::$6 cputln::$1 cscroll::$7 +Alias candidate removed (volatile)conio_cursor_color = gotoxy::$7 cputln::$2 cscroll::$8 +Alias mul8u::a#2 = mul8u::a#4 +Alias mul8u::mb#2 = mul8u::mb#3 +Alias mul8s::b#2 = mul8s::b#3 +Alias mul8s::a#2 = mul8s::a#4 +Alias gotoxy::x#3 = gotoxy::x#5 +Alias gotoxy::y#4 = gotoxy::y#5 +Alias utoa::value#10 = utoa::value#7 +Alias utoa::buffer#10 = utoa::buffer#15 +Alias utoa::digit#2 = utoa::digit#4 +Alias utoa::max_digits#10 = utoa::max_digits#6 +Alias utoa::digit_values#10 = utoa::digit_values#7 +Alias printf_uint::uvalue#1 = printf_uint::uvalue#2 +Alias printf_uint::format_radix#1 = printf_uint::format_radix#3 +Alias printf_uint::format_min_length#1 = printf_uint::format_min_length#3 +Alias printf_uint::format_justify_left#1 = printf_uint::format_justify_left#3 +Alias printf_uint::format_sign_always#1 = printf_uint::format_sign_always#2 +Alias printf_uint::format_zero_padding#1 = printf_uint::format_zero_padding#3 +Alias printf_uint::format_upper_case#1 = printf_uint::format_upper_case#3 +Alias printf_number_buffer::format_min_length#1 = printf_number_buffer::format_min_length#2 +Alias printf_number_buffer::format_justify_left#11 = printf_number_buffer::format_justify_left#4 +Alias printf_number_buffer::format_zero_padding#10 = printf_number_buffer::format_zero_padding#5 +Alias printf_number_buffer::buffer_sign#1 = printf_number_buffer::buffer_sign#8 +Alias printf_number_buffer::format_upper_case#10 = printf_number_buffer::format_upper_case#11 +Alias printf_number_buffer::buffer_digits#1 = printf_number_buffer::buffer_digits#15 +Alias printf_number_buffer::buffer_sign#10 = printf_number_buffer::buffer_sign#2 +Alias printf_number_buffer::format_zero_padding#1 = printf_number_buffer::format_zero_padding#13 printf_number_buffer::format_zero_padding#18 printf_number_buffer::format_zero_padding#14 printf_number_buffer::format_zero_padding#3 +Alias printf_number_buffer::padding#10 = printf_number_buffer::padding#12 printf_number_buffer::padding#16 printf_number_buffer::padding#14 printf_number_buffer::padding#11 +Alias printf_number_buffer::format_upper_case#1 = printf_number_buffer::format_upper_case#4 printf_number_buffer::format_upper_case#13 printf_number_buffer::format_upper_case#2 +Alias printf_number_buffer::buffer_digits#10 = printf_number_buffer::buffer_digits#12 printf_number_buffer::buffer_digits#11 printf_number_buffer::buffer_digits#3 printf_number_buffer::buffer_digits#2 +Alias printf_number_buffer::format_justify_left#1 = printf_number_buffer::format_justify_left#15 printf_number_buffer::format_justify_left#12 printf_number_buffer::format_justify_left#10 printf_number_buffer::format_justify_left#2 +Alias main::sc#10 = main::sc#2 +Alias main::x#2 = main::x#4 +Alias main::y#10 = main::y#7 +Successful SSA optimization Pass2AliasElimination +Alias candidate removed (volatile)conio_cursor_text = gotoxy::$6 cputln::$1 cscroll::$7 +Alias candidate removed (volatile)conio_cursor_color = gotoxy::$7 cputln::$2 cscroll::$8 +Alias printf_number_buffer::format_justify_left#1 = printf_number_buffer::format_justify_left#11 +Alias printf_number_buffer::format_zero_padding#1 = printf_number_buffer::format_zero_padding#10 +Alias printf_number_buffer::buffer_sign#1 = printf_number_buffer::buffer_sign#10 +Alias printf_number_buffer::format_upper_case#1 = printf_number_buffer::format_upper_case#10 +Alias printf_number_buffer::buffer_digits#1 = printf_number_buffer::buffer_digits#10 +Successful SSA optimization Pass2AliasElimination +Alias candidate removed (volatile)conio_cursor_text = gotoxy::$6 cputln::$1 cscroll::$7 +Alias candidate removed (volatile)conio_cursor_color = gotoxy::$7 cputln::$2 cscroll::$8 +Identical Phi Values (byte) toupper::ch#1 (byte) toupper::ch#0 +Identical Phi Values (byte*) memcpy::src_end#1 (byte*) memcpy::src_end#0 +Identical Phi Values (void*) memcpy::destination#3 (void*) memcpy::destination#2 +Identical Phi Values (byte*) memset::end#1 (byte*) memset::end#0 +Identical Phi Values (void*) memset::str#6 (void*) memset::str#4 +Identical Phi Values (byte) memset::c#3 (byte) memset::c#5 +Identical Phi Values (byte*) strupr::src#0 (byte*) strupr::str#0 +Identical Phi Values (byte*) strupr::str#2 (byte*) strupr::src#0 +Identical Phi Values (byte*) strlen::str#4 (byte*) strlen::str#1 +Identical Phi Values (byte) mul8u::b#1 (byte) mul8u::b#0 +Identical Phi Values (byte) mul8u::a#5 (byte) mul8u::a#1 +Identical Phi Values (byte) utoa::radix#1 (byte) utoa::radix#0 +Identical Phi Values (word) utoa::value#10 (word) utoa::value#1 +Identical Phi Values (byte*) utoa::buffer#10 (byte*) utoa::buffer#5 +Identical Phi Values (byte) utoa::max_digits#10 (byte) utoa::max_digits#7 +Identical Phi Values (word*) utoa::digit_values#10 (word*) utoa::digit_values#8 +Identical Phi Values (word) utoa_append::value#5 (word) utoa_append::value#0 +Identical Phi Values (word) utoa_append::sub#3 (word) utoa_append::sub#0 +Identical Phi Values (byte*) utoa_append::buffer#3 (byte*) utoa_append::buffer#0 +Identical Phi Values (word) utoa_append::sub#1 (word) utoa_append::sub#3 +Identical Phi Values (byte*) utoa_append::buffer#1 (byte*) utoa_append::buffer#3 +Identical Phi Values (byte) printf_padding::length#3 (byte) printf_padding::length#4 +Identical Phi Values (byte) printf_padding::pad#3 (byte) printf_padding::pad#5 +Identical Phi Values (byte) printf_uint::format_sign_always#1 (byte) printf_uint::format_sign_always#0 +Identical Phi Values (word) printf_uint::uvalue#1 (word) printf_uint::uvalue#0 +Identical Phi Values (byte) printf_uint::format_radix#1 (byte) printf_uint::format_radix#0 +Identical Phi Values (byte) printf_uint::format_min_length#1 (byte) printf_uint::format_min_length#0 +Identical Phi Values (byte) printf_uint::format_justify_left#1 (byte) printf_uint::format_justify_left#0 +Identical Phi Values (byte) printf_uint::format_zero_padding#1 (byte) printf_uint::format_zero_padding#0 +Identical Phi Values (byte) printf_uint::format_upper_case#1 (byte) printf_uint::format_upper_case#0 +Identical Phi Values (byte) printf_number_buffer::format_min_length#1 (byte) printf_number_buffer::format_min_length#0 +Identical Phi Values (byte) printf_number_buffer::format_justify_left#1 (byte) printf_number_buffer::format_justify_left#0 +Identical Phi Values (byte) printf_number_buffer::format_zero_padding#1 (byte) printf_number_buffer::format_zero_padding#0 +Identical Phi Values (byte*) printf_number_buffer::buffer_digits#1 (byte*) printf_number_buffer::buffer_digits#0 +Identical Phi Values (byte) printf_number_buffer::buffer_sign#1 (byte) printf_number_buffer::buffer_sign#0 +Identical Phi Values (byte) printf_number_buffer::format_upper_case#1 (byte) printf_number_buffer::format_upper_case#0 +Identical Phi Values (byte) main::y#10 (byte) main::y#2 +Successful SSA optimization Pass2IdenticalPhiElimination +Identical Phi Values (void*) memset::return#0 (void*) memset::str#4 +Successful SSA optimization Pass2IdenticalPhiElimination +Simple Condition (bool~) memcpy::$1 [15] if((byte*) memcpy::src#2!=(byte*) memcpy::src_end#0) goto memcpy::@2 +Simple Condition (bool~) memset::$1 [22] if((word) memset::num#3<=(byte) 0) goto memset::@1 +Simple Condition (bool~) memset::$3 [29] if((byte*) memset::dst#2!=(byte*) memset::end#0) goto memset::@4 +Simple Condition (bool~) strupr::$1 [36] if((byte) 0!=*((byte*) strupr::src#2)) goto strupr::@2 +Simple Condition (bool~) strlen::$0 [48] if((byte) 0!=*((byte*) strlen::str#2)) goto strlen::@2 +Simple Condition (bool~) mul8u::$0 [57] if((byte) mul8u::a#2!=(byte) 0) goto mul8u::@2 +Simple Condition (bool~) mul8u::$3 [60] if((byte~) mul8u::$1==(byte) 0) goto mul8u::@4 +Simple Condition (bool~) mul8s::$2 [73] if((signed byte) mul8s::a#2>=(signed byte) 0) goto mul8s::@1 +Simple Condition (bool~) mul8s::$4 [76] if((signed byte) mul8s::b#2>=(signed byte) 0) goto mul8s::@2 +Simple Condition (bool~) gotoxy::$1 [96] if((byte) gotoxy::y#3<=(byte) $19) goto gotoxy::@1 +Simple Condition (bool~) gotoxy::$3 [99] if((byte) gotoxy::x#3<(byte) $28) goto gotoxy::@2 +Simple Condition (bool~) cputc::$0 [115] if((byte) cputc::c#3==(byte) ' +') goto cputc::@1 +Simple Condition (bool~) cputc::$2 [123] if((byte) conio_cursor_x!=(byte) $28) goto cputc::@return +Simple Condition (bool~) cscroll::$1 [138] if((byte) conio_cursor_y!=(byte) $19) goto cscroll::@return +Simple Condition (bool~) cscroll::$9 [140] if((byte) 0!=(byte) conio_scroll_enable) goto cscroll::@3 +Simple Condition (bool~) cputs::$1 [176] if((byte) 0!=(byte) cputs::c#1) goto cputs::@2 +Simple Condition (bool~) utoa::$0 [184] if((byte) utoa::radix#0==(const byte) DECIMAL) goto utoa::@1 +Simple Condition (bool~) utoa::$1 [188] if((byte) utoa::radix#0==(const byte) HEXADECIMAL) goto utoa::@2 +Simple Condition (bool~) utoa::$2 [192] if((byte) utoa::radix#0==(const byte) OCTAL) goto utoa::@3 +Simple Condition (bool~) utoa::$3 [196] if((byte) utoa::radix#0==(const byte) BINARY) goto utoa::@4 +Simple Condition (bool~) utoa::$5 [213] if((byte) utoa::digit#2<(byte~) utoa::$4) goto utoa::@11 +Simple Condition (bool~) utoa_append::$0 [238] if((word) utoa_append::value#2>=(word) utoa_append::sub#0) goto utoa_append::@2 +Simple Condition (bool~) printf_padding::$0 [247] if((byte) printf_padding::i#2<(byte) printf_padding::length#4) goto printf_padding::@2 +Simple Condition (bool~) printf_uint::$5 [254] if((byte) 0!=(byte) printf_uint::format_sign_always#0) goto printf_uint::@1 +Simple Condition (bool~) printf_number_buffer::$0 [276] if((byte) 0==(byte) printf_number_buffer::format_min_length#0) goto printf_number_buffer::@1 +Simple Condition (bool~) printf_number_buffer::$20 [290] if((byte) 0==(byte) printf_number_buffer::buffer_sign#0) goto printf_number_buffer::@13 +Simple Condition (bool~) printf_number_buffer::$23 [295] if((signed byte) printf_number_buffer::padding#1>=(signed byte) 0) goto printf_number_buffer::@1 +Simple Condition (bool~) printf_number_buffer::$7 [299] if((byte) 0==(byte) printf_number_buffer::buffer_sign#0) goto printf_number_buffer::@3 +Simple Condition (bool~) printf_number_buffer::$12 [309] if((byte) 0==(byte) printf_number_buffer::format_upper_case#0) goto printf_number_buffer::@5 +Simple Condition (bool~) main::$3 [337] if((byte) main::y#2<(byte) $19) goto main::@2 +Simple Condition (bool~) main::$4 [354] if((byte) main::x#2<(byte) $28) goto main::@5 +Simple Condition (bool~) main::$13 [373] if((signed word) main::dist_sq#0>=(signed word)(number) 2*(number) 9*(number) 2*(number) 9) goto main::@7 +Successful SSA optimization Pass2ConditionalJumpSimplification +Rewriting && if()-condition to two if()s [3] (bool~) toupper::$2 ← (bool~) toupper::$0 && (bool~) toupper::$1 +Rewriting ! if()-condition to reversed if() [218] (bool~) utoa::$8 ← ! (bool~) utoa::$7 +Rewriting || if()-condition to two if()s [217] (bool~) utoa::$7 ← (byte) utoa::started#2 || (bool~) utoa::$6 +Rewriting ! if()-condition to reversed if() [282] (bool~) printf_number_buffer::$5 ← ! (bool~) printf_number_buffer::$4 +Rewriting && if()-condition to two if()s [281] (bool~) printf_number_buffer::$4 ← (bool~) printf_number_buffer::$3 && (signed byte) printf_number_buffer::padding#10 +Rewriting && if()-condition to two if()s [280] (bool~) printf_number_buffer::$3 ← (bool~) printf_number_buffer::$1 && (bool~) printf_number_buffer::$2 +Rewriting ! if()-condition to reversed if() [304] (bool~) printf_number_buffer::$10 ← ! (bool~) printf_number_buffer::$9 +Rewriting && if()-condition to two if()s [303] (bool~) printf_number_buffer::$9 ← (byte) printf_number_buffer::format_zero_padding#0 && (signed byte) printf_number_buffer::padding#10 +Rewriting ! if()-condition to reversed if() [318] (bool~) printf_number_buffer::$17 ← ! (bool~) printf_number_buffer::$16 +Rewriting && if()-condition to two if()s [317] (bool~) printf_number_buffer::$16 ← (bool~) printf_number_buffer::$15 && (signed byte) printf_number_buffer::padding#10 +Rewriting && if()-condition to two if()s [316] (bool~) printf_number_buffer::$15 ← (byte) printf_number_buffer::format_justify_left#0 && (bool~) printf_number_buffer::$14 +Successful SSA optimization Pass2ConditionalAndOrRewriting +Warning! Adding boolean cast to non-boolean condition (byte) utoa::started#2 +Warning! Adding boolean cast to non-boolean condition (byte) printf_number_buffer::format_zero_padding#0 +Warning! Adding boolean cast to non-boolean condition (byte) printf_number_buffer::format_justify_left#0 +Warning! Adding boolean cast to non-boolean condition (signed byte) printf_number_buffer::padding#10 +Warning! Adding boolean cast to non-boolean condition (signed byte) printf_number_buffer::padding#10 +Warning! Adding boolean cast to non-boolean condition (signed byte) printf_number_buffer::padding#10 +Constant right-side identified [143] (word) memcpy::num#0 ← (unumber)(number) $19*(number) $28-(number) $28 +Constant right-side identified [148] (word) memcpy::num#1 ← (unumber)(number) $19*(number) $28-(number) $28 +Successful SSA optimization Pass2ConstantRValueConsolidation +Constant (const word) strlen::len#0 = 0 +Constant (const word) mul8u::res#0 = 0 +Constant (const byte) gotoxy::y#0 = 0 +Constant (const byte) gotoxy::x#0 = 0 +Constant (const void*) memcpy::destination#0 = (void*)CONIO_SCREEN_TEXT +Constant (const void*) memcpy::source#0 = (void*)CONIO_SCREEN_TEXT+$28 +Constant (const word) memcpy::num#0 = (unumber)$19*$28-$28 +Constant (const void*) memcpy::destination#1 = (void*)CONIO_SCREEN_COLORS +Constant (const void*) memcpy::source#1 = (void*)CONIO_SCREEN_COLORS+$28 +Constant (const word) memcpy::num#1 = (unumber)$19*$28-$28 +Constant (const void*) memset::str#0 = (void*)CONIO_SCREEN_TEXT+(word)$19*$28-$28 +Constant (const byte) memset::c#0 = ' ' +Constant (const word) memset::num#0 = $28 +Constant (const void*) memset::str#1 = (void*)CONIO_SCREEN_COLORS+(word)$19*$28-$28 +Constant (const word) memset::num#1 = $28 +Constant (const byte) gotoxy::x#1 = 0 +Constant (const byte) gotoxy::y#1 = 0 +Constant (const byte) cputs::c#0 = 0 +Constant (const byte) utoa::max_digits#0 = 0 +Constant (const word*) utoa::digit_values#0 = (word*) 0 +Constant (const byte) utoa::max_digits#1 = 5 +Constant (const word*) utoa::digit_values#1 = RADIX_DECIMAL_VALUES +Constant (const byte) utoa::max_digits#2 = 4 +Constant (const word*) utoa::digit_values#2 = RADIX_HEXADECIMAL_VALUES +Constant (const byte) utoa::max_digits#3 = 6 +Constant (const word*) utoa::digit_values#3 = RADIX_OCTAL_VALUES +Constant (const byte) utoa::max_digits#4 = $10 +Constant (const word*) utoa::digit_values#4 = RADIX_BINARY_VALUES +Constant (const byte) utoa::started#0 = 0 +Constant (const byte) utoa::digit#0 = 0 +Constant (const byte) utoa::started#1 = 1 +Constant (const byte) utoa_append::digit#0 = 0 +Constant (const byte) printf_padding::i#0 = 0 +Constant (const byte) printf_uint::$1 = '+' +Constant (const byte) printf_uint::$0 = 0 +Constant (const byte*) utoa::buffer#5 = (byte*)&printf_buffer+OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_DIGITS +Constant (const byte*) printf_number_buffer::buffer_digits#0 = (byte*)&printf_buffer+OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_DIGITS +Constant (const signed byte) printf_number_buffer::padding#0 = 0 +Constant (const signed byte) printf_number_buffer::padding#2 = 0 +Constant (const byte) printf_padding::pad#0 = ' ' +Constant (const byte) printf_padding::pad#1 = '0' +Constant (const byte) printf_padding::pad#2 = ' ' +Constant (const void*) memset::str#2 = (void*)SCREEN +Constant (const byte) memset::c#2 = ' ' +Constant (const word) memset::num#2 = $3e8 +Constant (const word) main::count#0 = 0 +Constant (const byte*) main::sc#0 = SCREEN +Constant (const byte) main::y#0 = 0 +Constant (const byte) main::x#0 = 0 +Constant (const byte) gotoxy::x#2 = 0 +Constant (const byte) gotoxy::y#2 = 0 +Constant (const byte) printf_uint::format_min_length#0 = 0 +Constant (const byte) printf_uint::format_justify_left#0 = 0 +Constant (const byte) printf_uint::format_sign_always#0 = 0 +Constant (const byte) printf_uint::format_zero_padding#0 = 0 +Constant (const byte) printf_uint::format_upper_case#0 = 0 +Constant (const byte) printf_uint::format_radix#0 = DECIMAL +Constant (const to_nomodify byte*) cputs::s#2 = main::s +Constant (const byte) conio_textcolor = CONIO_TEXTCOLOR_DEFAULT +Constant (const byte) conio_scroll_enable = 1 +Successful SSA optimization Pass2ConstantIdentification +Constant (const byte) memset::c#1 = conio_textcolor +Constant (const byte) utoa::radix#0 = printf_uint::format_radix#0 +Constant (const byte) printf_number_buffer::format_min_length#0 = printf_uint::format_min_length#0 +Constant (const byte) printf_number_buffer::format_justify_left#0 = printf_uint::format_justify_left#0 +Constant (const byte) printf_number_buffer::format_sign_always#0 = printf_uint::format_sign_always#0 +Constant (const byte) printf_number_buffer::format_zero_padding#0 = printf_uint::format_zero_padding#0 +Constant (const byte) printf_number_buffer::format_upper_case#0 = printf_uint::format_upper_case#0 +Constant (const byte) printf_number_buffer::format_radix#0 = printf_uint::format_radix#0 +Constant (const byte*) strlen::str#1 = printf_number_buffer::buffer_digits#0 +Constant (const to_nomodify byte*) cputs::s#1 = printf_number_buffer::buffer_digits#0 +Constant (const byte*) strupr::str#0 = printf_number_buffer::buffer_digits#0 +Successful SSA optimization Pass2ConstantIdentification +Constant (const signed byte) printf_number_buffer::$25 = (signed byte)printf_number_buffer::format_min_length#0 +Constant (const byte*) strupr::return#2 = strupr::str#0 +Successful SSA optimization Pass2ConstantIdentification +if() condition always true - replacing block destination [140] if((byte) 0!=(const byte) conio_scroll_enable) goto cscroll::@3 +if() condition always true - replacing block destination [184] if((const byte) utoa::radix#0==(const byte) DECIMAL) goto utoa::@1 +if() condition always false - eliminating [188] if((const byte) utoa::radix#0==(const byte) HEXADECIMAL) goto utoa::@2 +if() condition always false - eliminating [192] if((const byte) utoa::radix#0==(const byte) OCTAL) goto utoa::@3 +if() condition always false - eliminating [196] if((const byte) utoa::radix#0==(const byte) BINARY) goto utoa::@4 +if() condition always false - eliminating [254] if((byte) 0!=(const byte) printf_uint::format_sign_always#0) goto printf_uint::@1 +if() condition always true - replacing block destination [276] if((byte) 0==(const byte) printf_number_buffer::format_min_length#0) goto printf_number_buffer::@1 +if() condition always true - replacing block destination [309] if((byte) 0==(const byte) printf_number_buffer::format_upper_case#0) goto printf_number_buffer::@5 +Successful SSA optimization Pass2ConstantIfs +Rewriting conditional comparison [96] if((byte) gotoxy::y#3<=(byte) $19) goto gotoxy::@1 +Simplifying constant evaluating to zero (signed byte)(const byte) printf_number_buffer::format_min_length#0 in +Successful SSA optimization PassNSimplifyConstantZero +Simplifying expression containing zero (byte*)&printf_buffer in [258] *((byte*)&(struct printf_buffer_number) printf_buffer+(const byte) OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_SIGN) ← (byte~) printf_uint::$2 +Simplifying expression containing zero (byte*)&printf_buffer in [263] (byte) printf_number_buffer::buffer_sign#0 ← *((byte*)&(struct printf_buffer_number) printf_buffer+(const byte) OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_SIGN) +Simplifying expression containing zero printf_number_buffer::len#2 in [293] (signed byte) printf_number_buffer::padding#1 ← (const signed byte) printf_number_buffer::$25 - (signed byte) printf_number_buffer::len#2 +Successful SSA optimization PassNSimplifyExpressionWithZero +Eliminating unused variable (void*) memcpy::return#2 and assignment [114] (void*) memcpy::return#2 ← (void*) memcpy::destination#2 +Eliminating unused variable (void*) memcpy::return#3 and assignment [116] (void*) memcpy::return#3 ← (void*) memcpy::destination#2 +Eliminating unused variable (void*) memset::return#2 and assignment [118] (void*) memset::return#2 ← (void*) memset::str#4 +Eliminating unused variable (void*) memset::return#3 and assignment [120] (void*) memset::return#3 ← (void*) memset::str#4 +Eliminating unused variable (void*) memset::return#4 and assignment [217] (void*) memset::return#4 ← (void*) memset::str#4 +Eliminating unused constant (const byte*) strupr::return#2 +Eliminating unused constant (const byte) cputs::c#0 +Eliminating unused constant (const byte) BINARY +Eliminating unused constant (const byte) OCTAL +Eliminating unused constant (const byte) HEXADECIMAL +Eliminating unused constant (const byte) utoa::max_digits#0 +Eliminating unused constant (const word*) utoa::digit_values#0 +Eliminating unused constant (const byte) utoa::radix#0 +Eliminating unused constant (const byte) printf_number_buffer::format_min_length#0 +Eliminating unused constant (const byte) printf_number_buffer::format_sign_always#0 +Eliminating unused constant (const byte) printf_number_buffer::format_upper_case#0 +Eliminating unused constant (const byte) printf_number_buffer::format_radix#0 +Eliminating unused constant (const signed byte) printf_number_buffer::$25 +Eliminating unused constant (const byte) OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_SIGN +Eliminating unused constant (const byte) conio_scroll_enable +Successful SSA optimization PassNEliminateUnusedVars +Eliminating unused constant (const byte) printf_uint::format_min_length#0 +Eliminating unused constant (const byte) printf_uint::format_sign_always#0 +Eliminating unused constant (const byte) printf_uint::format_upper_case#0 +Eliminating unused constant (const byte) printf_uint::format_radix#0 +Successful SSA optimization PassNEliminateUnusedVars +Eliminating unused constant (const byte) DECIMAL +Successful SSA optimization PassNEliminateUnusedVars +Eliminating variable (bool~) toupper::$0 from unused block toupper +Eliminating variable (bool~) toupper::$1 from unused block toupper +Eliminating variable (byte) toupper::return#0 from unused block toupper::@1 +Eliminating variable (byte) toupper::return#2 from unused block toupper::@return +Eliminating variable (byte*) strupr::src#2 from unused block strupr::@1 +Eliminating variable (byte) toupper::ch#0 from unused block strupr::@2 +Eliminating variable (byte) toupper::return#3 from unused block strupr::@2 +Eliminating variable (byte~) strupr::$0 from unused block strupr::@4 +Eliminating variable (byte*) strupr::src#1 from unused block strupr::@4 +Eliminating variable (byte*) strlen::str#2 from unused block strlen::@1 +Eliminating variable (word) strlen::len#2 from unused block strlen::@1 +Eliminating variable (word) strlen::len#1 from unused block strlen::@2 +Eliminating variable (byte*) strlen::str#0 from unused block strlen::@2 +Eliminating variable (byte*) utoa::buffer#0 from unused block utoa::@9 +Eliminating variable (byte*) utoa::buffer#1 from unused block utoa::@9 +Eliminating variable (byte*) utoa::buffer#2 from unused block utoa::@9 +Eliminating variable (word) strlen::return#2 from unused block printf_number_buffer::@6 +Eliminating variable (word~) printf_number_buffer::$19 from unused block printf_number_buffer::@15 +Eliminating variable (signed byte) printf_number_buffer::len#0 from unused block printf_number_buffer::@15 +Eliminating variable (signed byte) printf_number_buffer::len#2 from unused block printf_number_buffer::@13 +Eliminating variable (signed byte) printf_number_buffer::padding#1 from unused block printf_number_buffer::@13 +Eliminating variable (signed byte) printf_number_buffer::len#1 from unused block printf_number_buffer::@7 +Removing unused procedure toupper +Removing unused procedure block toupper +Removing unused procedure block toupper::@1 +Removing PHI-reference to removed block (toupper::@1) in block toupper::@return +Removing unused procedure block toupper::@2 +Removing PHI-reference to removed block (toupper::@2) in block toupper::@return +Removing unused procedure block toupper::@return +Removing unused procedure block toupper::@3 +Removing unused procedure strupr +Removing unused procedure block strupr +Removing PHI-reference to removed block (strupr) in block strupr::@1 +Removing unused procedure block strupr::@1 +Removing unused procedure block strupr::@2 +Removing unused procedure block strupr::@4 +Removing unused procedure block strupr::@3 +Removing unused procedure block strupr::@return +Removing unused procedure strlen +Removing unused procedure block strlen +Removing PHI-reference to removed block (strlen) in block strlen::@1 +Removing PHI-reference to removed block (strlen) in block strlen::@1 +Removing unused procedure block strlen::@1 +Removing unused procedure block strlen::@2 +Removing unused procedure block strlen::@3 +Removing unused procedure block strlen::@return +Removing PHI-reference to removed block (cscroll::@2) in block gotoxy +Removing PHI-reference to removed block (cscroll::@2) in block gotoxy +Removing unused block cscroll::@2 +Removing unused block cscroll::@8 +Removing unused block utoa::@6 +Removing PHI-reference to removed block (utoa::@2) in block utoa::@5 +Removing PHI-reference to removed block (utoa::@2) in block utoa::@5 +Removing unused block utoa::@2 +Removing unused block utoa::@7 +Removing PHI-reference to removed block (utoa::@3) in block utoa::@5 +Removing PHI-reference to removed block (utoa::@3) in block utoa::@5 +Removing unused block utoa::@3 +Removing unused block utoa::@8 +Removing PHI-reference to removed block (utoa::@4) in block utoa::@5 +Removing PHI-reference to removed block (utoa::@4) in block utoa::@5 +Removing unused block utoa::@4 +Removing unused block utoa::@9 +Removing PHI-reference to removed block (printf_uint::@1) in block printf_uint::@3 +Removing unused block printf_uint::@1 +Removing unused block printf_number_buffer::@6 +Removing PHI-reference to removed block (printf_number_buffer::@15) in block printf_number_buffer::@13 +Removing unused block printf_number_buffer::@15 +Removing PHI-reference to removed block (printf_number_buffer::@13) in block printf_number_buffer::@1 +Removing unused block printf_number_buffer::@13 +Removing unused block printf_number_buffer::@7 +Removing PHI-reference to removed block (printf_number_buffer::@14) in block printf_number_buffer::@1 +Removing unused block printf_number_buffer::@14 +Removing unused block printf_number_buffer::@11 +Removing unused block printf_number_buffer::@20 +Successful SSA optimization Pass2EliminateUnusedBlocks +Adding number conversion cast (unumber) $19+1 in if((byte) gotoxy::y#3<(byte) $19+(number) 1) goto gotoxy::@1 +Adding number conversion cast (unumber) 1 in if((byte) gotoxy::y#3<(unumber)(byte) $19+(number) 1) goto gotoxy::@1 +Adding number conversion cast (unumber) 0 in (bool~) utoa::$12 ← (number) 0 != (byte) utoa::started#2 +Adding number conversion cast (unumber) 0 in (bool~) printf_number_buffer::$33 ← (number) 0 != (const byte) printf_number_buffer::format_zero_padding#0 +Adding number conversion cast (unumber) 0 in (bool~) printf_number_buffer::$34 ← (number) 0 != (const byte) printf_number_buffer::format_justify_left#0 +Adding number conversion cast (snumber) 0 in (bool~) printf_number_buffer::$35 ← (number) 0 != (signed byte) printf_number_buffer::padding#10 +Adding number conversion cast (snumber) 0 in (bool~) printf_number_buffer::$36 ← (number) 0 != (signed byte) printf_number_buffer::padding#10 +Adding number conversion cast (snumber) 0 in (bool~) printf_number_buffer::$37 ← (number) 0 != (signed byte) printf_number_buffer::padding#10 +Successful SSA optimization PassNAddNumberTypeConversions +Simplifying constant integer cast (byte) $19+(unumber)(number) 1 +Simplifying constant integer cast 1 +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Simplifying constant integer cast 0 +Successful SSA optimization PassNCastSimplification +Finalized unsigned number type (byte) 1 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 0 +Finalized unsigned number type (byte) 0 +Finalized signed number type (signed byte) 0 +Finalized signed number type (signed byte) 0 +Finalized signed number type (signed byte) 0 +Successful SSA optimization PassNFinalizeNumberTypeConversions +Alias candidate removed (volatile)conio_cursor_text = gotoxy::$6 cputln::$1 cscroll::$7 +Alias candidate removed (volatile)conio_cursor_color = gotoxy::$7 cputln::$2 cscroll::$8 +Identical Phi Values (byte) gotoxy::y#3 (const byte) gotoxy::y#2 +Identical Phi Values (byte) gotoxy::x#3 (const byte) gotoxy::x#2 +Identical Phi Values (byte) utoa::max_digits#7 (const byte) utoa::max_digits#1 +Identical Phi Values (word*) utoa::digit_values#8 (const word*) utoa::digit_values#1 +Identical Phi Values (byte~) printf_uint::$2 (const byte) printf_uint::$0 +Identical Phi Values (signed byte) printf_number_buffer::padding#10 (const signed byte) printf_number_buffer::padding#0 +Successful SSA optimization Pass2IdenticalPhiElimination +Simple Condition (bool~) utoa::$12 [120] if((byte) 0!=(byte) utoa::started#2) goto utoa::@14 +Simple Condition (bool~) printf_number_buffer::$1 [157] if((byte) 0==(const byte) printf_number_buffer::format_justify_left#0) goto printf_number_buffer::@23 +Simple Condition (bool~) printf_number_buffer::$33 [162] if((byte) 0!=(const byte) printf_number_buffer::format_zero_padding#0) goto printf_number_buffer::@24 +Simple Condition (bool~) printf_number_buffer::$34 [170] if((byte) 0!=(const byte) printf_number_buffer::format_justify_left#0) goto printf_number_buffer::@26 +Simple Condition (bool~) utoa::$6 [209] if((word) utoa::value#2>=(word) utoa::digit_value#0) goto utoa::@14 +Simple Condition (bool~) printf_number_buffer::$35 [211] if((signed byte) 0!=(const signed byte) printf_number_buffer::padding#0) goto printf_number_buffer::@8 +Simple Condition (bool~) printf_number_buffer::$2 [212] if((byte) 0==(const byte) printf_number_buffer::format_zero_padding#0) goto printf_number_buffer::@22 +Simple Condition (bool~) printf_number_buffer::$36 [214] if((signed byte) 0!=(const signed byte) printf_number_buffer::padding#0) goto printf_number_buffer::@10 +Simple Condition (bool~) printf_number_buffer::$37 [216] if((signed byte) 0!=(const signed byte) printf_number_buffer::padding#0) goto printf_number_buffer::@12 +Simple Condition (bool~) printf_number_buffer::$14 [217] if((byte) 0==(const byte) printf_number_buffer::format_zero_padding#0) goto printf_number_buffer::@25 +Successful SSA optimization Pass2ConditionalJumpSimplification +Negating conditional jump and destination [157] if((byte) 0!=(const byte) printf_number_buffer::format_justify_left#0) goto printf_number_buffer::@2 +Negating conditional jump and destination [162] if((byte) 0==(const byte) printf_number_buffer::format_zero_padding#0) goto printf_number_buffer::@4 +Negating conditional jump and destination [170] if((byte) 0==(const byte) printf_number_buffer::format_justify_left#0) goto printf_number_buffer::@return +Negating conditional jump and destination [212] if((byte) 0!=(const byte) printf_number_buffer::format_zero_padding#0) goto printf_number_buffer::@2 +Negating conditional jump and destination [217] if((byte) 0!=(const byte) printf_number_buffer::format_zero_padding#0) goto printf_number_buffer::@return +Successful SSA optimization Pass2ConditionalJumpSequenceImprovement +Constant right-side identified [114] (byte~) utoa::$4 ← (const byte) utoa::max_digits#1 - (byte) 1 +Constant right-side identified [159] (byte) printf_padding::length#0 ← (byte)(const signed byte) printf_number_buffer::padding#0 +Constant right-side identified [165] (byte) printf_padding::length#1 ← (byte)(const signed byte) printf_number_buffer::padding#0 +Constant right-side identified [171] (byte) printf_padding::length#2 ← (byte)(const signed byte) printf_number_buffer::padding#0 +Successful SSA optimization Pass2ConstantRValueConsolidation +Constant (const byte) utoa::$4 = utoa::max_digits#1-1 +Constant (const byte) printf_padding::length#0 = (byte)printf_number_buffer::padding#0 +Constant (const byte) printf_padding::length#1 = (byte)printf_number_buffer::padding#0 +Constant (const byte) printf_padding::length#2 = (byte)printf_number_buffer::padding#0 +Successful SSA optimization Pass2ConstantIdentification +if() condition always true - replacing block destination [56] if((const byte) gotoxy::y#2<(byte) $19+(byte) 1) goto gotoxy::@1 +if() condition always true - replacing block destination [58] if((const byte) gotoxy::x#2<(byte) $28) goto gotoxy::@2 +if() condition always false - eliminating [157] if((byte) 0!=(const byte) printf_number_buffer::format_justify_left#0) goto printf_number_buffer::@2 +if() condition always true - replacing block destination [162] if((byte) 0==(const byte) printf_number_buffer::format_zero_padding#0) goto printf_number_buffer::@4 +if() condition always true - replacing block destination [170] if((byte) 0==(const byte) printf_number_buffer::format_justify_left#0) goto printf_number_buffer::@return +if() condition always false - eliminating [211] if((signed byte) 0!=(const signed byte) printf_number_buffer::padding#0) goto printf_number_buffer::@8 +if() condition always false - eliminating [212] if((byte) 0!=(const byte) printf_number_buffer::format_zero_padding#0) goto printf_number_buffer::@2 +if() condition always false - eliminating [214] if((signed byte) 0!=(const signed byte) printf_number_buffer::padding#0) goto printf_number_buffer::@10 +if() condition always false - eliminating [216] if((signed byte) 0!=(const signed byte) printf_number_buffer::padding#0) goto printf_number_buffer::@12 +if() condition always false - eliminating [217] if((byte) 0!=(const byte) printf_number_buffer::format_zero_padding#0) goto printf_number_buffer::@return +Successful SSA optimization Pass2ConstantIfs +Simplifying constant evaluating to zero (byte)(const signed byte) printf_number_buffer::padding#0 in +Simplifying constant evaluating to zero (byte)(const signed byte) printf_number_buffer::padding#0 in +Simplifying constant evaluating to zero (byte)(const signed byte) printf_number_buffer::padding#0 in +Successful SSA optimization PassNSimplifyConstantZero +Eliminating unused constant (const byte) gotoxy::x#1 +Eliminating unused constant (const byte) gotoxy::y#1 +Eliminating unused constant (const byte) utoa::max_digits#2 +Eliminating unused constant (const word*) utoa::digit_values#2 +Eliminating unused constant (const byte) utoa::max_digits#3 +Eliminating unused constant (const word*) utoa::digit_values#3 +Eliminating unused constant (const byte) utoa::max_digits#4 +Eliminating unused constant (const word*) utoa::digit_values#4 +Eliminating unused constant (const byte) printf_uint::$1 +Eliminating unused constant (const signed byte) printf_number_buffer::padding#0 +Eliminating unused constant (const signed byte) printf_number_buffer::padding#2 +Eliminating unused constant (const byte) printf_number_buffer::format_justify_left#0 +Eliminating unused constant (const byte) printf_number_buffer::format_zero_padding#0 +Successful SSA optimization PassNEliminateUnusedVars +Eliminating unused constant (const word*) RADIX_BINARY_VALUES +Eliminating unused constant (const word*) RADIX_OCTAL_VALUES +Eliminating unused constant (const word*) RADIX_HEXADECIMAL_VALUES +Eliminating unused constant (const byte) printf_uint::format_justify_left#0 +Eliminating unused constant (const byte) printf_uint::format_zero_padding#0 +Successful SSA optimization PassNEliminateUnusedVars +Eliminating variable (byte) printf_padding::length#4 from unused block printf_padding +Eliminating variable (byte) printf_padding::pad#5 from unused block printf_padding +Eliminating variable (byte) printf_padding::i#2 from unused block printf_padding::@1 +Eliminating variable (byte) cputc::c#1 from unused block printf_padding::@2 +Eliminating variable (byte) printf_padding::i#1 from unused block printf_padding::@3 +Removing PHI-reference to removed block (gotoxy::@3) in block gotoxy::@1 +Removing unused block gotoxy::@3 +Removing PHI-reference to removed block (gotoxy::@4) in block gotoxy::@2 +Removing unused block gotoxy::@4 +Removing unused procedure printf_padding +Removing unused procedure block printf_padding +Removing PHI-reference to removed block (printf_padding) in block printf_padding::@1 +Removing unused procedure block printf_padding::@1 +Removing unused procedure block printf_padding::@2 +Removing PHI-reference to removed block (printf_padding::@2) in block cputc +Removing unused procedure block printf_padding::@3 +Removing unused procedure block printf_padding::@return +Removing unused block printf_number_buffer::@8 +Removing unused block printf_number_buffer::@16 +Removing unused block printf_number_buffer::@10 +Removing unused block printf_number_buffer::@18 +Removing unused block printf_number_buffer::@12 +Removing unused block printf_number_buffer::@21 +Removing unused block printf_number_buffer::@24 +Removing unused block printf_number_buffer::@25 +Removing unused block printf_number_buffer::@26 +Successful SSA optimization Pass2EliminateUnusedBlocks +Alias candidate removed (volatile)conio_cursor_text = gotoxy::$6 cputln::$1 cscroll::$7 +Alias candidate removed (volatile)conio_cursor_color = gotoxy::$7 cputln::$2 cscroll::$8 +Identical Phi Values (byte) gotoxy::y#4 (const byte) gotoxy::y#2 +Identical Phi Values (byte) gotoxy::x#4 (const byte) gotoxy::x#2 +Successful SSA optimization Pass2IdenticalPhiElimination +Constant right-side identified [59] (word~) gotoxy::$8 ← (word)(const byte) gotoxy::y#2 +Successful SSA optimization Pass2ConstantRValueConsolidation +Constant (const word) gotoxy::$8 = (word)gotoxy::y#2 +Successful SSA optimization Pass2ConstantIdentification +Simplifying constant evaluating to zero (word)(const byte) gotoxy::y#2 in +Successful SSA optimization PassNSimplifyConstantZero +Simplifying expression containing zero gotoxy::$4 in [61] (word) gotoxy::offset#0 ← (word~) gotoxy::$4 + (const byte) gotoxy::x#2 +Successful SSA optimization PassNSimplifyExpressionWithZero +Eliminating unused constant (const byte) gotoxy::y#0 +Eliminating unused constant (const byte) gotoxy::x#0 +Successful SSA optimization PassNEliminateUnusedVars +Alias candidate removed (volatile)conio_cursor_text = gotoxy::$6 cputln::$1 cscroll::$7 +Alias candidate removed (volatile)conio_cursor_color = gotoxy::$7 cputln::$2 cscroll::$8 +Alias gotoxy::offset#0 = gotoxy::$4 +Successful SSA optimization Pass2AliasElimination +Alias candidate removed (volatile)conio_cursor_text = gotoxy::$6 cputln::$1 cscroll::$7 +Alias candidate removed (volatile)conio_cursor_color = gotoxy::$7 cputln::$2 cscroll::$8 +Constant right-side identified [57] (word) gotoxy::offset#0 ← (const word) gotoxy::$8 * (byte) $28 +Successful SSA optimization Pass2ConstantRValueConsolidation +Constant (const word) gotoxy::offset#0 = gotoxy::$8*$28 +Successful SSA optimization Pass2ConstantIdentification +Simplifying constant evaluating to zero (const word) gotoxy::$8*(byte) $28 in +Successful SSA optimization PassNSimplifyConstantZero +Simplifying expression containing zero CONIO_SCREEN_TEXT in [58] (byte*~) gotoxy::$6 ← (const nomodify byte*) CONIO_SCREEN_TEXT + (const word) gotoxy::offset#0 +Simplifying expression containing zero CONIO_SCREEN_COLORS in [60] (byte*~) gotoxy::$7 ← (const nomodify byte*) CONIO_SCREEN_COLORS + (const word) gotoxy::offset#0 +Successful SSA optimization PassNSimplifyExpressionWithZero +Eliminating unused constant (const word) gotoxy::$8 +Eliminating unused constant (const word) gotoxy::offset#0 +Successful SSA optimization PassNEliminateUnusedVars +Alias candidate removed (volatile)conio_cursor_text = gotoxy::$6 cputln::$1 cscroll::$7 +Alias candidate removed (volatile)conio_cursor_color = gotoxy::$7 cputln::$2 cscroll::$8 +Constant (const byte*) gotoxy::$6 = CONIO_SCREEN_TEXT +Constant (const byte*) gotoxy::$7 = CONIO_SCREEN_COLORS +Successful SSA optimization Pass2ConstantIdentification +Alias candidate removed (volatile)conio_cursor_text = cputln::$1 cscroll::$7 +Alias candidate removed (volatile)conio_cursor_color = cputln::$2 cscroll::$8 +Inlining Noop Cast [1] (byte*) memcpy::src#0 ← (byte*)(void*) memcpy::source#2 keeping memcpy::source#2 +Inlining Noop Cast [2] (byte*) memcpy::dst#0 ← (byte*)(void*) memcpy::destination#2 keeping memcpy::destination#2 +Inlining Noop Cast [3] (byte*~) memcpy::$2 ← (byte*)(void*) memcpy::source#2 keeping memcpy::source#2 +Inlining Noop Cast [13] (byte*~) memset::$4 ← (byte*)(void*) memset::str#4 keeping memset::str#4 +Inlining Noop Cast [15] (byte*) memset::dst#0 ← (byte*)(void*) memset::str#4 keeping memset::str#4 +Inlining Noop Cast [41] (byte~) mul8s::$13 ← (byte)(signed byte) mul8s::b#2 keeping mul8s::b#2 +Inlining Noop Cast [45] (signed word) mul8s::return#0 ← (signed word)(word) mul8s::m#4 keeping mul8s::m#4 +Inlining Noop Cast [47] (byte~) mul8s::$14 ← (byte)(signed byte) mul8s::a#2 keeping mul8s::a#2 +Inlining Noop Cast [146] (signed byte~) main::$14 ← (signed byte)(byte) main::x#2 keeping main::x#2 +Inlining Noop Cast [149] (signed byte~) main::$15 ← (signed byte)(byte) main::y#2 keeping main::y#2 +Successful SSA optimization Pass2NopCastInlining +Inlining Noop Cast [155] (signed word) mul8s::return#2 ← (signed word)(word) mul8s::m#4 keeping mul8s::m#4 +Inlining Noop Cast [160] (signed word) mul8s::return#3 ← (signed word)(word) mul8s::m#4 keeping mul8s::m#4 +Successful SSA optimization Pass2NopCastInlining +Rewriting multiplication to use shift [104] (byte~) utoa::$10 ← (byte) utoa::digit#2 * (const byte) SIZEOF_WORD +Rewriting multiplication to use shift [147] (signed byte~) main::$5 ← (signed byte)(byte) main::x#2 * (signed byte) 2 +Rewriting multiplication to use shift [150] (signed byte~) main::$7 ← (signed byte)(byte) main::y#2 * (signed byte) 2 +Successful SSA optimization Pass2MultiplyToShiftRewriting +Inlining constant with var siblings (const void*) memcpy::destination#0 +Inlining constant with var siblings (const void*) memcpy::source#0 +Inlining constant with var siblings (const word) memcpy::num#0 +Inlining constant with var siblings (const void*) memcpy::destination#1 +Inlining constant with var siblings (const void*) memcpy::source#1 +Inlining constant with var siblings (const word) memcpy::num#1 +Inlining constant with var siblings (const void*) memset::str#0 +Inlining constant with var siblings (const byte) memset::c#0 +Inlining constant with var siblings (const word) memset::num#0 +Inlining constant with var siblings (const void*) memset::str#1 +Inlining constant with var siblings (const word) memset::num#1 +Inlining constant with var siblings (const void*) memset::str#2 +Inlining constant with var siblings (const byte) memset::c#2 +Inlining constant with var siblings (const word) memset::num#2 +Inlining constant with var siblings (const byte) memset::c#1 +Inlining constant with var siblings (const word) mul8u::res#0 +Inlining constant with var siblings (const to_nomodify byte*) cputs::s#2 +Inlining constant with var siblings (const to_nomodify byte*) cputs::s#1 +Inlining constant with var siblings (const byte) utoa::started#0 +Inlining constant with var siblings (const byte) utoa::digit#0 +Inlining constant with var siblings (const byte) utoa::started#1 +Inlining constant with var siblings (const byte*) utoa::buffer#5 +Inlining constant with var siblings (const byte) utoa_append::digit#0 +Inlining constant with var siblings (const word) main::count#0 +Inlining constant with var siblings (const byte*) main::sc#0 +Inlining constant with var siblings (const byte) main::y#0 +Inlining constant with var siblings (const byte) main::x#0 +Constant inlined utoa_append::digit#0 = (byte) 0 +Constant inlined utoa::digit_values#1 = (const word*) RADIX_DECIMAL_VALUES +Constant inlined cputs::s#1 = (const byte*) printf_number_buffer::buffer_digits#0 +Constant inlined cputs::s#2 = (const byte*) main::s +Constant inlined memset::num#2 = (word) $3e8 +Constant inlined conio_textcolor = (const nomodify byte) CONIO_TEXTCOLOR_DEFAULT +Constant inlined memcpy::destination#0 = (void*)(const nomodify byte*) CONIO_SCREEN_TEXT +Constant inlined memset::num#1 = (byte) $28 +Constant inlined memcpy::destination#1 = (void*)(const nomodify byte*) CONIO_SCREEN_COLORS +Constant inlined memset::num#0 = (byte) $28 +Constant inlined memcpy::source#1 = (void*)(const nomodify byte*) CONIO_SCREEN_COLORS+(byte) $28 +Constant inlined utoa::digit#0 = (byte) 0 +Constant inlined utoa::$4 = (const byte) utoa::max_digits#1-(byte) 1 +Constant inlined memset::str#2 = (void*)(const nomodify byte*) SCREEN +Constant inlined memset::str#1 = (void*)(const nomodify byte*) CONIO_SCREEN_COLORS+(word)(number) $19*(number) $28-(byte) $28 +Constant inlined memset::str#0 = (void*)(const nomodify byte*) CONIO_SCREEN_TEXT+(word)(number) $19*(number) $28-(byte) $28 +Constant inlined printf_uint::$0 = (byte) 0 +Constant inlined gotoxy::$6 = (const nomodify byte*) CONIO_SCREEN_TEXT +Constant inlined gotoxy::$7 = (const nomodify byte*) CONIO_SCREEN_COLORS +Constant inlined utoa::started#1 = (byte) 1 +Constant inlined main::sc#0 = (const nomodify byte*) SCREEN +Constant inlined utoa::started#0 = (byte) 0 +Constant inlined main::x#0 = (byte) 0 +Constant inlined main::y#0 = (byte) 0 +Constant inlined memcpy::source#0 = (void*)(const nomodify byte*) CONIO_SCREEN_TEXT+(byte) $28 +Constant inlined memcpy::num#1 = (word)(number) $19*(number) $28-(number) $28 +Constant inlined memcpy::num#0 = (word)(number) $19*(number) $28-(number) $28 +Constant inlined main::count#0 = (word) 0 +Constant inlined mul8u::res#0 = (word) 0 +Constant inlined utoa::buffer#5 = (byte*)&(struct printf_buffer_number) printf_buffer+(const byte) OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_DIGITS +Constant inlined memset::c#0 = (byte) ' ' +Constant inlined memset::c#1 = (const nomodify byte) CONIO_TEXTCOLOR_DEFAULT +Constant inlined memset::c#2 = (byte) ' ' +Successful SSA optimization Pass2ConstantInlining +Alias candidate removed (volatile)conio_cursor_text = cputln::$1 cscroll::$7 +Alias candidate removed (volatile)conio_cursor_color = cputln::$2 cscroll::$8 +Identical Phi Values (word) memcpy::num#2 (word)(number) $19*(number) $28-(number) $28 +Successful SSA optimization Pass2IdenticalPhiElimination +Eliminating unused constant (const byte) SIZEOF_WORD +Successful SSA optimization PassNEliminateUnusedVars +Alias candidate removed (volatile)conio_cursor_text = cputln::$1 cscroll::$7 +Alias candidate removed (volatile)conio_cursor_color = cputln::$2 cscroll::$8 +Added new block during phi lifting mul8u::@6(between mul8u::@2 and mul8u::@4) +Added new block during phi lifting mul8s::@6(between mul8s::@5 and mul8s::@1) +Added new block during phi lifting mul8s::@7(between mul8s::@1 and mul8s::@2) +Added new block during phi lifting utoa::@17(between utoa::@16 and utoa::@13) +Added new block during phi lifting main::@15(between main::@14 and main::@7) +Adding NOP phi() at start of @begin +Adding NOP phi() at start of @2 +Adding NOP phi() at start of @3 +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::@3 +Adding NOP phi() at start of main::@11 +Adding NOP phi() at start of main::@12 +Adding NOP phi() at start of mul8u::@3 +Adding NOP phi() at start of cputc::@5 +Adding NOP phi() at start of cputc::@1 +Adding NOP phi() at start of cputc::@4 +Adding NOP phi() at start of cputln::@1 +Adding NOP phi() at start of cscroll::@1 +Adding NOP phi() at start of cscroll::@3 +Adding NOP phi() at start of cscroll::@4 +Adding NOP phi() at start of cscroll::@5 +Adding NOP phi() at start of cscroll::@6 +Adding NOP phi() at start of memset::@1 +Adding NOP phi() at start of memcpy::@3 +Adding NOP phi() at start of printf_uint +Adding NOP phi() at start of printf_uint::@2 +Adding NOP phi() at start of printf_uint::@5 +Adding NOP phi() at start of printf_number_buffer +Adding NOP phi() at start of printf_number_buffer::@1 +Adding NOP phi() at start of printf_number_buffer::@23 +Adding NOP phi() at start of printf_number_buffer::@22 +Adding NOP phi() at start of printf_number_buffer::@17 +Adding NOP phi() at start of printf_number_buffer::@3 +Adding NOP phi() at start of printf_number_buffer::@4 +Adding NOP phi() at start of printf_number_buffer::@5 +Adding NOP phi() at start of printf_number_buffer::@19 +Adding NOP phi() at start of utoa +Adding NOP phi() at start of utoa::@1 +Adding NOP phi() at start of gotoxy +Adding NOP phi() at start of gotoxy::@1 +CALL GRAPH +Calls in [] to main:6 +Calls in [main] to memset:10 gotoxy:15 printf_uint:17 cputs:19 mul8s:38 mul8s:44 +Calls in [mul8s] to mul8u:61 +Calls in [cputs] to cputc:106 +Calls in [cputc] to cscroll:118 cputln:122 +Calls in [cputln] to cscroll:131 +Calls in [cscroll] to memcpy:137 memcpy:139 memset:141 memset:143 +Calls in [printf_uint] to utoa:178 printf_number_buffer:180 +Calls in [printf_number_buffer] to cputc:190 cputs:195 +Calls in [utoa] to utoa_append:224 + +Created 35 initial phi equivalence classes +Coalesced [22] main::sc#12 ← main::sc#8 +Coalesced [23] main::count#14 ← main::count#11 +Coalesced [27] main::y#11 ← main::y#1 +Coalesced (already) [28] main::count#13 ← main::count#10 +Coalesced (already) [29] main::sc#11 ← main::sc#10 +Coalesced [36] mul8s::a#8 ← mul8s::a#0 +Coalesced [37] mul8s::b#7 ← mul8s::b#0 +Coalesced [42] mul8s::a#7 ← mul8s::a#1 +Coalesced [43] mul8s::b#6 ← mul8s::b#1 +Coalesced [50] main::count#17 ← main::count#1 +Coalesced [54] main::x#8 ← main::x#1 +Coalesced [55] main::sc#13 ← main::sc#1 +Coalesced [56] main::count#15 ← main::count#12 +Coalesced (already) [57] main::count#16 ← main::count#10 +Coalesced [68] mul8s::m#7 ← mul8s::m#1 +Coalesced [74] mul8s::m#10 ← mul8s::m#2 +Coalesced [77] mul8s::m#9 ← mul8s::m#5 +Coalesced [78] mul8s::m#8 ← mul8s::m#0 +Coalesced [80] mul8u::a#7 ← mul8u::a#1 +Coalesced [81] mul8u::mb#6 ← mul8u::mb#0 +Coalesced [89] mul8u::res#9 ← mul8u::res#1 +Coalesced [93] mul8u::a#8 ← mul8u::a#0 +Coalesced [94] mul8u::res#7 ← mul8u::res#6 +Coalesced [95] mul8u::mb#7 ← mul8u::mb#1 +Coalesced (already) [96] mul8u::res#8 ← mul8u::res#2 +Coalesced [98] cputs::s#7 ← cputs::s#4 +Coalesced [105] cputc::c#5 ← cputc::c#0 +Coalesced [107] cputs::s#8 ← cputs::s#0 +Coalesced [160] memset::dst#5 ← memset::dst#1 +Coalesced [172] memcpy::src#5 ← memcpy::src#1 +Coalesced [173] memcpy::dst#5 ← memcpy::dst#1 +Coalesced [189] cputc::c#6 ← cputc::c#2 +Coalesced [200] utoa::value#17 ← utoa::value#1 +Coalesced [212] utoa::value#18 ← utoa::value#2 +Coalesced [213] utoa::started#6 ← utoa::started#2 +Coalesced [214] utoa::buffer#23 ← utoa::buffer#11 +Coalesced [217] utoa::digit#7 ← utoa::digit#1 +Coalesced (already) [218] utoa::value#16 ← utoa::value#6 +Coalesced (already) [219] utoa::started#5 ← utoa::started#4 +Coalesced (already) [220] utoa::buffer#22 ← utoa::buffer#14 +Coalesced [228] utoa::value#19 ← utoa::value#0 +Coalesced [229] utoa::buffer#24 ← utoa::buffer#4 +Coalesced [230] utoa_append::value#6 ← utoa_append::value#0 +Coalesced [237] utoa_append::value#7 ← utoa_append::value#1 +Coalesced [238] utoa_append::digit#5 ← utoa_append::digit#1 +Coalesced down to 26 phi equivalence classes +Culled Empty Block (label) @3 +Culled Empty Block (label) main::@9 +Culled Empty Block (label) main::@12 +Culled Empty Block (label) main::@2 +Culled Empty Block (label) main::@15 +Culled Empty Block (label) mul8s::@7 +Culled Empty Block (label) mul8s::@6 +Culled Empty Block (label) mul8u::@3 +Culled Empty Block (label) mul8u::@6 +Culled Empty Block (label) cputs::@3 +Culled Empty Block (label) cputc::@5 +Culled Empty Block (label) cputc::@4 +Culled Empty Block (label) cputln::@1 +Culled Empty Block (label) cscroll::@1 +Culled Empty Block (label) memset::@1 +Culled Empty Block (label) memcpy::@3 +Culled Empty Block (label) printf_uint::@2 +Culled Empty Block (label) printf_uint::@5 +Culled Empty Block (label) printf_number_buffer::@1 +Culled Empty Block (label) printf_number_buffer::@23 +Culled Empty Block (label) printf_number_buffer::@22 +Culled Empty Block (label) printf_number_buffer::@17 +Culled Empty Block (label) printf_number_buffer::@3 +Culled Empty Block (label) printf_number_buffer::@4 +Culled Empty Block (label) printf_number_buffer::@19 +Culled Empty Block (label) utoa::@1 +Culled Empty Block (label) utoa::@5 +Culled Empty Block (label) utoa::@17 +Culled Empty Block (label) gotoxy::@1 +Renumbering block memset::@2 to memset::@1 +Renumbering block memset::@3 to memset::@2 +Renumbering block memset::@4 to memset::@3 +Renumbering block mul8u::@4 to mul8u::@3 +Renumbering block mul8u::@5 to mul8u::@4 +Renumbering block gotoxy::@2 to gotoxy::@1 +Renumbering block cscroll::@3 to cscroll::@1 +Renumbering block cscroll::@4 to cscroll::@2 +Renumbering block cscroll::@5 to cscroll::@3 +Renumbering block cscroll::@6 to cscroll::@4 +Renumbering block cscroll::@7 to cscroll::@5 +Renumbering block utoa::@10 to utoa::@1 +Renumbering block utoa::@11 to utoa::@2 +Renumbering block utoa::@12 to utoa::@3 +Renumbering block utoa::@13 to utoa::@4 +Renumbering block utoa::@14 to utoa::@5 +Renumbering block utoa::@15 to utoa::@6 +Renumbering block utoa::@16 to utoa::@7 +Renumbering block printf_uint::@3 to printf_uint::@1 +Renumbering block printf_uint::@4 to printf_uint::@2 +Renumbering block printf_number_buffer::@2 to printf_number_buffer::@1 +Renumbering block printf_number_buffer::@5 to printf_number_buffer::@2 +Renumbering block printf_number_buffer::@9 to printf_number_buffer::@3 +Renumbering block main::@3 to main::@2 +Renumbering block main::@4 to main::@3 +Renumbering block main::@5 to main::@4 +Renumbering block main::@6 to main::@5 +Renumbering block main::@7 to main::@6 +Renumbering block main::@8 to main::@7 +Renumbering block main::@10 to main::@8 +Renumbering block main::@11 to main::@9 +Renumbering block main::@13 to main::@10 +Renumbering block main::@14 to main::@11 +Adding NOP phi() at start of @begin +Adding NOP phi() at start of @2 +Adding NOP phi() at start of @end +Adding NOP phi() at start of main +Adding NOP phi() at start of main::@2 +Adding NOP phi() at start of main::@9 +Adding NOP phi() at start of cputc::@1 +Adding NOP phi() at start of cscroll::@1 +Adding NOP phi() at start of cscroll::@2 +Adding NOP phi() at start of cscroll::@3 +Adding NOP phi() at start of cscroll::@4 +Adding NOP phi() at start of printf_uint +Adding NOP phi() at start of printf_number_buffer +Adding NOP phi() at start of printf_number_buffer::@2 +Adding NOP phi() at start of utoa +Adding NOP phi() at start of utoa_append +Adding NOP phi() at start of gotoxy + +FINAL CONTROL FLOW GRAPH +@begin: scope:[] from + [0] phi() + to:@1 +@1: scope:[] from @begin + [1] (byte) conio_cursor_x ← (byte) 0 + [2] (byte) conio_cursor_y ← (byte) 0 + [3] (byte*) conio_cursor_text ← (const nomodify byte*) CONIO_SCREEN_TEXT + [4] (byte*) conio_cursor_color ← (const nomodify byte*) CONIO_SCREEN_COLORS + to:@2 +@2: scope:[] from @1 + [5] phi() + [6] call main + to:@end +@end: scope:[] from @2 + [7] phi() + +(void()) main() +main: scope:[main] from @2 + [8] phi() + [9] call memset + to:main::@1 +main::@1: scope:[main] from main main::@5 + [10] (byte*) main::sc#8 ← phi( main::@5/(byte*) main::sc#10 main/(const nomodify byte*) SCREEN ) + [10] (word) main::count#11 ← phi( main::@5/(word) main::count#10 main/(word) 0 ) + [10] (byte) main::y#2 ← phi( main::@5/(byte) main::y#1 main/(byte) 0 ) + [11] if((byte) main::y#2<(byte) $19) goto main::@3 + to:main::@2 +main::@2: scope:[main] from main::@1 + [12] phi() + [13] call gotoxy + to:main::@8 +main::@8: scope:[main] from main::@2 + [14] (word) printf_uint::uvalue#0 ← (word) main::count#11 + [15] call printf_uint + to:main::@9 +main::@9: scope:[main] from main::@8 + [16] phi() + [17] call cputs + to:main::@return +main::@return: scope:[main] from main::@9 + [18] return + to:@return +main::@3: scope:[main] from main::@1 main::@6 + [19] (word) main::count#10 ← phi( main::@1/(word) main::count#11 main::@6/(word) main::count#12 ) + [19] (byte*) main::sc#10 ← phi( main::@1/(byte*) main::sc#8 main::@6/(byte*) main::sc#1 ) + [19] (byte) main::x#2 ← phi( main::@1/(byte) 0 main::@6/(byte) main::x#1 ) + [20] if((byte) main::x#2<(byte) $28) goto main::@4 + to:main::@5 +main::@5: scope:[main] from main::@3 + [21] (byte) main::y#1 ← ++ (byte) main::y#2 + to:main::@1 +main::@4: scope:[main] from main::@3 + [22] (signed byte~) main::$5 ← (signed byte)(byte) main::x#2 << (byte) 1 + [23] (signed byte) main::xd#0 ← (signed byte~) main::$5 - (signed byte) $27 + [24] (signed byte~) main::$7 ← (signed byte)(byte) main::y#2 << (byte) 1 + [25] (signed byte) main::yd#0 ← (signed byte~) main::$7 - (signed byte) $18 + [26] (signed byte) mul8s::a#0 ← (signed byte) main::xd#0 + [27] (signed byte) mul8s::b#0 ← (signed byte) main::xd#0 + [28] call mul8s + to:main::@10 +main::@10: scope:[main] from main::@4 + [29] (signed word~) main::$9 ← (signed word)(word) mul8s::m#4 + [30] (signed byte) mul8s::a#1 ← (signed byte) main::yd#0 + [31] (signed byte) mul8s::b#1 ← (signed byte) main::yd#0 + [32] call mul8s + to:main::@11 +main::@11: scope:[main] from main::@10 + [33] (signed word~) main::$10 ← (signed word)(word) mul8s::m#4 + [34] (signed word) main::dist_sq#0 ← (signed word~) main::$9 + (signed word~) main::$10 + [35] if((signed word) main::dist_sq#0>=(signed word)(number) 2*(number) 9*(number) 2*(number) 9) goto main::@6 + to:main::@7 +main::@7: scope:[main] from main::@11 + [36] *((byte*) main::sc#10) ← (byte) '*' + [37] (word) main::count#1 ← ++ (word) main::count#10 + to:main::@6 +main::@6: scope:[main] from main::@11 main::@7 + [38] (word) main::count#12 ← phi( main::@11/(word) main::count#10 main::@7/(word) main::count#1 ) + [39] (byte*) main::sc#1 ← ++ (byte*) main::sc#10 + [40] (byte) main::x#1 ← ++ (byte) main::x#2 + to:main::@3 + +(signed word()) mul8s((signed byte) mul8s::a , (signed byte) mul8s::b) +mul8s: scope:[mul8s] from main::@10 main::@4 + [41] (signed byte) mul8s::b#2 ← phi( main::@10/(signed byte) mul8s::b#1 main::@4/(signed byte) mul8s::b#0 ) + [41] (signed byte) mul8s::a#2 ← phi( main::@10/(signed byte) mul8s::a#1 main::@4/(signed byte) mul8s::a#0 ) + [42] (byte) mul8u::a#1 ← (byte)(signed byte) mul8s::a#2 + [43] (byte) mul8u::b#0 ← (byte)(signed byte) mul8s::b#2 + [44] call mul8u + [45] (word) mul8u::return#2 ← (word) mul8u::res#2 + to:mul8s::@5 +mul8s::@5: scope:[mul8s] from mul8s + [46] (word) mul8s::m#0 ← (word) mul8u::return#2 + [47] if((signed byte) mul8s::a#2>=(signed byte) 0) goto mul8s::@1 + to:mul8s::@3 +mul8s::@3: scope:[mul8s] from mul8s::@5 + [48] (byte~) mul8s::$6 ← > (word) mul8s::m#0 + [49] (byte~) mul8s::$11 ← (byte~) mul8s::$6 - (byte)(signed byte) mul8s::b#2 + [50] (word) mul8s::m#1 ← (word) mul8s::m#0 hi= (byte~) mul8s::$11 + to:mul8s::@1 +mul8s::@1: scope:[mul8s] from mul8s::@3 mul8s::@5 + [51] (word) mul8s::m#5 ← phi( mul8s::@3/(word) mul8s::m#1 mul8s::@5/(word) mul8s::m#0 ) + [52] if((signed byte) mul8s::b#2>=(signed byte) 0) goto mul8s::@2 + to:mul8s::@4 +mul8s::@4: scope:[mul8s] from mul8s::@1 + [53] (byte~) mul8s::$9 ← > (word) mul8s::m#5 + [54] (byte~) mul8s::$12 ← (byte~) mul8s::$9 - (byte)(signed byte) mul8s::a#2 + [55] (word) mul8s::m#2 ← (word) mul8s::m#5 hi= (byte~) mul8s::$12 + to:mul8s::@2 +mul8s::@2: scope:[mul8s] from mul8s::@1 mul8s::@4 + [56] (word) mul8s::m#4 ← phi( mul8s::@1/(word) mul8s::m#5 mul8s::@4/(word) mul8s::m#2 ) + to:mul8s::@return +mul8s::@return: scope:[mul8s] from mul8s::@2 + [57] return + to:@return + +(word()) mul8u((byte) mul8u::a , (byte) mul8u::b) +mul8u: scope:[mul8u] from mul8s + [58] (word) mul8u::mb#0 ← (word)(byte) mul8u::b#0 + to:mul8u::@1 +mul8u::@1: scope:[mul8u] from mul8u mul8u::@3 + [59] (word) mul8u::mb#2 ← phi( mul8u/(word) mul8u::mb#0 mul8u::@3/(word) mul8u::mb#1 ) + [59] (word) mul8u::res#2 ← phi( mul8u/(word) 0 mul8u::@3/(word) mul8u::res#6 ) + [59] (byte) mul8u::a#2 ← phi( mul8u/(byte) mul8u::a#1 mul8u::@3/(byte) mul8u::a#0 ) + [60] if((byte) mul8u::a#2!=(byte) 0) goto mul8u::@2 + to:mul8u::@return +mul8u::@return: scope:[mul8u] from mul8u::@1 + [61] return + to:@return +mul8u::@2: scope:[mul8u] from mul8u::@1 + [62] (byte~) mul8u::$1 ← (byte) mul8u::a#2 & (byte) 1 + [63] if((byte~) mul8u::$1==(byte) 0) goto mul8u::@3 + to:mul8u::@4 +mul8u::@4: scope:[mul8u] from mul8u::@2 + [64] (word) mul8u::res#1 ← (word) mul8u::res#2 + (word) mul8u::mb#2 + to:mul8u::@3 +mul8u::@3: scope:[mul8u] from mul8u::@2 mul8u::@4 + [65] (word) mul8u::res#6 ← phi( mul8u::@2/(word) mul8u::res#2 mul8u::@4/(word) mul8u::res#1 ) + [66] (byte) mul8u::a#0 ← (byte) mul8u::a#2 >> (byte) 1 + [67] (word) mul8u::mb#1 ← (word) mul8u::mb#2 << (byte) 1 + to:mul8u::@1 + +(void()) cputs((to_nomodify byte*) cputs::s) +cputs: scope:[cputs] from main::@9 printf_number_buffer::@2 + [68] (to_nomodify byte*) cputs::s#4 ← phi( main::@9/(const byte*) main::s printf_number_buffer::@2/(const byte*) printf_number_buffer::buffer_digits#0 ) + to:cputs::@1 +cputs::@1: scope:[cputs] from cputs cputs::@2 + [69] (to_nomodify byte*) cputs::s#3 ← phi( cputs/(to_nomodify byte*) cputs::s#4 cputs::@2/(to_nomodify byte*) cputs::s#0 ) + [70] (byte) cputs::c#1 ← *((to_nomodify byte*) cputs::s#3) + [71] (to_nomodify byte*) cputs::s#0 ← ++ (to_nomodify byte*) cputs::s#3 + [72] if((byte) 0!=(byte) cputs::c#1) goto cputs::@2 + to:cputs::@return +cputs::@return: scope:[cputs] from cputs::@1 + [73] return + to:@return +cputs::@2: scope:[cputs] from cputs::@1 + [74] (byte) cputc::c#0 ← (byte) cputs::c#1 + [75] call cputc + to:cputs::@1 + +(void()) cputc((byte) cputc::c) +cputc: scope:[cputc] from cputs::@2 printf_number_buffer::@3 + [76] (byte) cputc::c#3 ← phi( cputs::@2/(byte) cputc::c#0 printf_number_buffer::@3/(byte) cputc::c#2 ) + [77] if((byte) cputc::c#3==(byte) ' +') goto cputc::@1 + to:cputc::@2 +cputc::@2: scope:[cputc] from cputc + [78] *((byte*) conio_cursor_text) ← (byte) cputc::c#3 + [79] (byte*) conio_cursor_text ← ++ (byte*) conio_cursor_text + [80] *((byte*) conio_cursor_color) ← (const nomodify byte) CONIO_TEXTCOLOR_DEFAULT + [81] (byte*) conio_cursor_color ← ++ (byte*) conio_cursor_color + [82] (byte) conio_cursor_x ← ++ (byte) conio_cursor_x + [83] if((byte) conio_cursor_x!=(byte) $28) goto cputc::@return + to:cputc::@3 +cputc::@3: scope:[cputc] from cputc::@2 + [84] (byte) conio_cursor_x ← (byte) 0 + [85] (byte) conio_cursor_y ← ++ (byte) conio_cursor_y + [86] call cscroll + to:cputc::@return +cputc::@return: scope:[cputc] from cputc::@1 cputc::@2 cputc::@3 + [87] return + to:@return +cputc::@1: scope:[cputc] from cputc + [88] phi() + [89] call cputln + to:cputc::@return + +(void()) cputln() +cputln: scope:[cputln] from cputc::@1 + [90] (word) cputln::ln_offset#0 ← (byte) $28 - (byte) conio_cursor_x + [91] (byte*~) cputln::$1 ← (byte*) conio_cursor_text + (word) cputln::ln_offset#0 + [92] (byte*) conio_cursor_text ← (byte*~) cputln::$1 + [93] (byte*~) cputln::$2 ← (byte*) conio_cursor_color + (word) cputln::ln_offset#0 + [94] (byte*) conio_cursor_color ← (byte*~) cputln::$2 + [95] (byte) conio_cursor_x ← (byte) 0 + [96] (byte) conio_cursor_y ← ++ (byte) conio_cursor_y + [97] call cscroll + to:cputln::@return +cputln::@return: scope:[cputln] from cputln + [98] return + to:@return + +(void()) cscroll() +cscroll: scope:[cscroll] from cputc::@3 cputln + [99] if((byte) conio_cursor_y!=(byte) $19) goto cscroll::@return + to:cscroll::@1 +cscroll::@1: scope:[cscroll] from cscroll + [100] phi() + [101] call memcpy + to:cscroll::@2 +cscroll::@2: scope:[cscroll] from cscroll::@1 + [102] phi() + [103] call memcpy + to:cscroll::@3 +cscroll::@3: scope:[cscroll] from cscroll::@2 + [104] phi() + [105] call memset + to:cscroll::@4 +cscroll::@4: scope:[cscroll] from cscroll::@3 + [106] phi() + [107] call memset + to:cscroll::@5 +cscroll::@5: scope:[cscroll] from cscroll::@4 + [108] (byte*~) cscroll::$7 ← (byte*) conio_cursor_text - (byte) $28 + [109] (byte*) conio_cursor_text ← (byte*~) cscroll::$7 + [110] (byte*~) cscroll::$8 ← (byte*) conio_cursor_color - (byte) $28 + [111] (byte*) conio_cursor_color ← (byte*~) cscroll::$8 + [112] (byte) conio_cursor_y ← -- (byte) conio_cursor_y + to:cscroll::@return +cscroll::@return: scope:[cscroll] from cscroll cscroll::@5 + [113] return + to:@return + +(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num) +memset: scope:[memset] from cscroll::@3 cscroll::@4 main + [114] (byte) memset::c#5 ← phi( cscroll::@3/(byte) ' ' cscroll::@4/(const nomodify byte) CONIO_TEXTCOLOR_DEFAULT main/(byte) ' ' ) + [114] (void*) memset::str#4 ← phi( cscroll::@3/(void*)(const nomodify byte*) CONIO_SCREEN_TEXT+(word)(number) $19*(number) $28-(byte) $28 cscroll::@4/(void*)(const nomodify byte*) CONIO_SCREEN_COLORS+(word)(number) $19*(number) $28-(byte) $28 main/(void*)(const nomodify byte*) SCREEN ) + [114] (word) memset::num#3 ← phi( cscroll::@3/(byte) $28 cscroll::@4/(byte) $28 main/(word) $3e8 ) + [115] if((word) memset::num#3<=(byte) 0) goto memset::@return + to:memset::@1 +memset::@1: scope:[memset] from memset + [116] (byte*) memset::end#0 ← (byte*)(void*) memset::str#4 + (word) memset::num#3 + [117] (byte*) memset::dst#4 ← (byte*)(void*) memset::str#4 + to:memset::@2 +memset::@2: scope:[memset] from memset::@1 memset::@3 + [118] (byte*) memset::dst#2 ← phi( memset::@1/(byte*) memset::dst#4 memset::@3/(byte*) memset::dst#1 ) + [119] if((byte*) memset::dst#2!=(byte*) memset::end#0) goto memset::@3 + to:memset::@return +memset::@return: scope:[memset] from memset memset::@2 + [120] return + to:@return +memset::@3: scope:[memset] from memset::@2 + [121] *((byte*) memset::dst#2) ← (byte) memset::c#5 + [122] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2 + to:memset::@2 + +(void*()) memcpy((void*) memcpy::destination , (void*) memcpy::source , (word) memcpy::num) +memcpy: scope:[memcpy] from cscroll::@1 cscroll::@2 + [123] (void*) memcpy::destination#2 ← phi( cscroll::@1/(void*)(const nomodify byte*) CONIO_SCREEN_TEXT cscroll::@2/(void*)(const nomodify byte*) CONIO_SCREEN_COLORS ) + [123] (void*) memcpy::source#2 ← phi( cscroll::@1/(void*)(const nomodify byte*) CONIO_SCREEN_TEXT+(byte) $28 cscroll::@2/(void*)(const nomodify byte*) CONIO_SCREEN_COLORS+(byte) $28 ) + [124] (byte*) memcpy::src_end#0 ← (byte*)(void*) memcpy::source#2 + (word)(number) $19*(number) $28-(number) $28 + [125] (byte*) memcpy::src#4 ← (byte*)(void*) memcpy::source#2 + [126] (byte*) memcpy::dst#4 ← (byte*)(void*) memcpy::destination#2 + to:memcpy::@1 +memcpy::@1: scope:[memcpy] from memcpy memcpy::@2 + [127] (byte*) memcpy::dst#2 ← phi( memcpy/(byte*) memcpy::dst#4 memcpy::@2/(byte*) memcpy::dst#1 ) + [127] (byte*) memcpy::src#2 ← phi( memcpy/(byte*) memcpy::src#4 memcpy::@2/(byte*) memcpy::src#1 ) + [128] if((byte*) memcpy::src#2!=(byte*) memcpy::src_end#0) goto memcpy::@2 + to:memcpy::@return +memcpy::@return: scope:[memcpy] from memcpy::@1 + [129] return + to:@return +memcpy::@2: scope:[memcpy] from memcpy::@1 + [130] *((byte*) memcpy::dst#2) ← *((byte*) memcpy::src#2) + [131] (byte*) memcpy::dst#1 ← ++ (byte*) memcpy::dst#2 + [132] (byte*) memcpy::src#1 ← ++ (byte*) memcpy::src#2 + to:memcpy::@1 + +(void()) printf_uint((word) printf_uint::uvalue , (byte) printf_uint::format_min_length , (byte) printf_uint::format_justify_left , (byte) printf_uint::format_sign_always , (byte) printf_uint::format_zero_padding , (byte) printf_uint::format_upper_case , (byte) printf_uint::format_radix) +printf_uint: scope:[printf_uint] from main::@8 + [133] phi() + to:printf_uint::@1 +printf_uint::@1: scope:[printf_uint] from printf_uint + [134] *((byte*)&(struct printf_buffer_number) printf_buffer) ← (byte) 0 + [135] (word) utoa::value#1 ← (word) printf_uint::uvalue#0 + [136] call utoa + to:printf_uint::@2 +printf_uint::@2: scope:[printf_uint] from printf_uint::@1 + [137] (byte) printf_number_buffer::buffer_sign#0 ← *((byte*)&(struct printf_buffer_number) printf_buffer) + [138] call printf_number_buffer + to:printf_uint::@return +printf_uint::@return: scope:[printf_uint] from printf_uint::@2 + [139] return + to:@return + +(void()) printf_number_buffer((byte) printf_number_buffer::buffer_sign , (byte*) printf_number_buffer::buffer_digits , (byte) printf_number_buffer::format_min_length , (byte) printf_number_buffer::format_justify_left , (byte) printf_number_buffer::format_sign_always , (byte) printf_number_buffer::format_zero_padding , (byte) printf_number_buffer::format_upper_case , (byte) printf_number_buffer::format_radix) +printf_number_buffer: scope:[printf_number_buffer] from printf_uint::@2 + [140] phi() + to:printf_number_buffer::@1 +printf_number_buffer::@1: scope:[printf_number_buffer] from printf_number_buffer + [141] if((byte) 0==(byte) printf_number_buffer::buffer_sign#0) goto printf_number_buffer::@2 + to:printf_number_buffer::@3 +printf_number_buffer::@3: scope:[printf_number_buffer] from printf_number_buffer::@1 + [142] (byte) cputc::c#2 ← (byte) printf_number_buffer::buffer_sign#0 + [143] call cputc + to:printf_number_buffer::@2 +printf_number_buffer::@2: scope:[printf_number_buffer] from printf_number_buffer::@1 printf_number_buffer::@3 + [144] phi() + [145] call cputs + to:printf_number_buffer::@return +printf_number_buffer::@return: scope:[printf_number_buffer] from printf_number_buffer::@2 + [146] return + to:@return + +(void()) utoa((word) utoa::value , (byte*) utoa::buffer , (byte) utoa::radix) +utoa: scope:[utoa] from printf_uint::@1 + [147] phi() + to:utoa::@1 +utoa::@1: scope:[utoa] from utoa utoa::@4 + [148] (byte*) utoa::buffer#11 ← phi( utoa::@4/(byte*) utoa::buffer#14 utoa/(byte*)&(struct printf_buffer_number) printf_buffer+(const byte) OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_DIGITS ) + [148] (byte) utoa::started#2 ← phi( utoa::@4/(byte) utoa::started#4 utoa/(byte) 0 ) + [148] (word) utoa::value#2 ← phi( utoa::@4/(word) utoa::value#6 utoa/(word) utoa::value#1 ) + [148] (byte) utoa::digit#2 ← phi( utoa::@4/(byte) utoa::digit#1 utoa/(byte) 0 ) + [149] if((byte) utoa::digit#2<(const byte) utoa::max_digits#1-(byte) 1) goto utoa::@2 + to:utoa::@3 +utoa::@3: scope:[utoa] from utoa::@1 + [150] (byte~) utoa::$11 ← (byte)(word) utoa::value#2 + [151] *((byte*) utoa::buffer#11) ← *((const byte*) DIGITS + (byte~) utoa::$11) + [152] (byte*) utoa::buffer#3 ← ++ (byte*) utoa::buffer#11 + [153] *((byte*) utoa::buffer#3) ← (byte) 0 + to:utoa::@return +utoa::@return: scope:[utoa] from utoa::@3 + [154] return + to:@return +utoa::@2: scope:[utoa] from utoa::@1 + [155] (byte~) utoa::$10 ← (byte) utoa::digit#2 << (byte) 1 + [156] (word) utoa::digit_value#0 ← *((const word*) RADIX_DECIMAL_VALUES + (byte~) utoa::$10) + [157] if((byte) 0!=(byte) utoa::started#2) goto utoa::@5 + to:utoa::@7 +utoa::@7: scope:[utoa] from utoa::@2 + [158] if((word) utoa::value#2>=(word) utoa::digit_value#0) goto utoa::@5 + to:utoa::@4 +utoa::@4: scope:[utoa] from utoa::@6 utoa::@7 + [159] (byte*) utoa::buffer#14 ← phi( utoa::@7/(byte*) utoa::buffer#11 utoa::@6/(byte*) utoa::buffer#4 ) + [159] (byte) utoa::started#4 ← phi( utoa::@7/(byte) utoa::started#2 utoa::@6/(byte) 1 ) + [159] (word) utoa::value#6 ← phi( utoa::@7/(word) utoa::value#2 utoa::@6/(word) utoa::value#0 ) + [160] (byte) utoa::digit#1 ← ++ (byte) utoa::digit#2 + to:utoa::@1 +utoa::@5: scope:[utoa] from utoa::@2 utoa::@7 + [161] (byte*) utoa_append::buffer#0 ← (byte*) utoa::buffer#11 + [162] (word) utoa_append::value#0 ← (word) utoa::value#2 + [163] (word) utoa_append::sub#0 ← (word) utoa::digit_value#0 + [164] call utoa_append + [165] (word) utoa_append::return#0 ← (word) utoa_append::value#2 + to:utoa::@6 +utoa::@6: scope:[utoa] from utoa::@5 + [166] (word) utoa::value#0 ← (word) utoa_append::return#0 + [167] (byte*) utoa::buffer#4 ← ++ (byte*) utoa::buffer#11 + to:utoa::@4 + +(word()) utoa_append((byte*) utoa_append::buffer , (word) utoa_append::value , (word) utoa_append::sub) +utoa_append: scope:[utoa_append] from utoa::@5 + [168] phi() + to:utoa_append::@1 +utoa_append::@1: scope:[utoa_append] from utoa_append utoa_append::@2 + [169] (byte) utoa_append::digit#2 ← phi( utoa_append/(byte) 0 utoa_append::@2/(byte) utoa_append::digit#1 ) + [169] (word) utoa_append::value#2 ← phi( utoa_append/(word) utoa_append::value#0 utoa_append::@2/(word) utoa_append::value#1 ) + [170] if((word) utoa_append::value#2>=(word) utoa_append::sub#0) goto utoa_append::@2 + to:utoa_append::@3 +utoa_append::@3: scope:[utoa_append] from utoa_append::@1 + [171] *((byte*) utoa_append::buffer#0) ← *((const byte*) DIGITS + (byte) utoa_append::digit#2) + to:utoa_append::@return +utoa_append::@return: scope:[utoa_append] from utoa_append::@3 + [172] return + to:@return +utoa_append::@2: scope:[utoa_append] from utoa_append::@1 + [173] (byte) utoa_append::digit#1 ← ++ (byte) utoa_append::digit#2 + [174] (word) utoa_append::value#1 ← (word) utoa_append::value#2 - (word) utoa_append::sub#0 + to:utoa_append::@1 + +(void()) gotoxy((byte) gotoxy::x , (byte) gotoxy::y) +gotoxy: scope:[gotoxy] from main::@2 + [175] phi() + to:gotoxy::@1 +gotoxy::@1: scope:[gotoxy] from gotoxy + [176] (byte) conio_cursor_x ← (const byte) gotoxy::x#2 + [177] (byte) conio_cursor_y ← (const byte) gotoxy::y#2 + [178] (byte*) conio_cursor_text ← (const nomodify byte*) CONIO_SCREEN_TEXT + [179] (byte*) conio_cursor_color ← (const nomodify byte*) CONIO_SCREEN_COLORS + to:gotoxy::@return +gotoxy::@return: scope:[gotoxy] from gotoxy::@1 + [180] return + to:@return + +null depth in calling loop Loop head: cputs::@1 tails: cputs::@2 blocks: cputs::@2 cputs::@1 in scope cputc +null depth in calling loop Loop head: cputs::@1 tails: cputs::@2 blocks: cputs::@2 cputs::@1 in scope cputc +null depth in calling loop Loop head: cputs::@1 tails: cputs::@2 blocks: cputs::@2 cputs::@1 in scope cputc +null depth in calling loop Loop head: cputs::@1 tails: cputs::@2 blocks: cputs::@2 cputs::@1 in scope cputc + +VARIABLE REGISTER WEIGHTS +(byte*) conio_cursor_color loadstore 3484376.71875 +(byte*) conio_cursor_text loadstore 3430770.9230769235 +(byte) conio_cursor_x loadstore 489798.1428571429 +(byte) conio_cursor_y loadstore 4735295.735294118 +(void()) cputc((byte) cputc::c) +(byte) cputc::c +(byte) cputc::c#0 200002.0 +(byte) cputc::c#2 2002.0 +(byte) cputc::c#3 1050502.0 +(void()) cputln() +(byte*~) cputln::$1 2.0000002E7 +(byte*~) cputln::$2 2.0000002E7 +(word) cputln::ln_offset +(word) cputln::ln_offset#0 1.0000001E7 +(void()) cputs((to_nomodify byte*) cputs::s) +(byte) cputs::c +(byte) cputs::c#1 100001.0 +(to_nomodify byte*) cputs::s +(to_nomodify byte*) cputs::s#0 50000.5 +(to_nomodify byte*) cputs::s#3 155002.0 +(to_nomodify byte*) cputs::s#4 10001.0 +(void()) cscroll() +(byte*~) cscroll::$7 2.00000002E8 +(byte*~) cscroll::$8 2.00000002E8 +(void()) gotoxy((byte) gotoxy::x , (byte) gotoxy::y) +(word) gotoxy::offset +(byte) gotoxy::x +(byte) gotoxy::y +(void()) main() +(signed word~) main::$10 2002.0 +(signed byte~) main::$5 2002.0 +(signed byte~) main::$7 2002.0 +(signed word~) main::$9 400.4 +(word) main::count +(word) main::count#1 2002.0 +(word) main::count#10 178.05555555555557 +(word) main::count#11 53.25 +(word) main::count#12 1001.0 +(signed word) main::dist_sq +(signed word) main::dist_sq#0 2002.0 +(byte*) main::sc +(byte*) main::sc#1 1001.0 +(byte*) main::sc#10 160.25 +(byte*) main::sc#8 101.0 +(byte) main::x +(byte) main::x#1 2002.0 +(byte) main::x#2 150.14999999999998 +(signed byte) main::xd +(signed byte) main::xd#0 750.75 +(byte) main::y +(byte) main::y#1 202.0 +(byte) main::y#2 13.173913043478262 +(signed byte) main::yd +(signed byte) main::yd#0 500.5 +(void*()) memcpy((void*) memcpy::destination , (void*) memcpy::source , (word) memcpy::num) +(void*) memcpy::destination +(void*) memcpy::destination#2 +(byte*) memcpy::dst +(byte*) memcpy::dst#1 1.00000000001E11 +(byte*) memcpy::dst#2 1.0033333333466667E11 +(byte*) memcpy::dst#4 2.000000002E9 +(word) memcpy::num +(void*) memcpy::return +(void*) memcpy::source +(void*) memcpy::source#2 +(byte*) memcpy::src +(byte*) memcpy::src#1 2.00000000002E11 +(byte*) memcpy::src#2 1.0025000000125E11 +(byte*) memcpy::src#4 1.000000001E9 +(byte*) memcpy::src_end +(byte*) memcpy::src_end#0 1.262500000025E10 +(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num) +(byte) memset::c +(byte) memset::c#5 1.250000000125E9 +(byte*) memset::dst +(byte*) memset::dst#1 2.0000000002E10 +(byte*) memset::dst#2 1.3666666668333332E10 +(byte*) memset::dst#4 2.000000002E9 +(byte*) memset::end +(byte*) memset::end#0 1.8333333336666665E9 +(word) memset::num +(word) memset::num#3 1.000000001E9 +(void*) memset::return +(void*) memset::str +(void*) memset::str#4 +(signed word()) mul8s((signed byte) mul8s::a , (signed byte) mul8s::b) +(byte~) mul8s::$11 20002.0 +(byte~) mul8s::$12 20002.0 +(byte~) mul8s::$6 20002.0 +(byte~) mul8s::$9 20002.0 +(signed byte) mul8s::a +(signed byte) mul8s::a#0 1001.0 +(signed byte) mul8s::a#1 1001.0 +(signed byte) mul8s::a#2 923.3076923076923 +(signed byte) mul8s::b +(signed byte) mul8s::b#0 2002.0 +(signed byte) mul8s::b#1 2002.0 +(signed byte) mul8s::b#2 1091.181818181818 +(word) mul8s::m +(word) mul8s::m#0 10001.0 +(word) mul8s::m#1 20002.0 +(word) mul8s::m#2 20002.0 +(word) mul8s::m#4 5000.5 +(word) mul8s::m#5 12501.25 +(signed word) mul8s::return +(word()) mul8u((byte) mul8u::a , (byte) mul8u::b) +(byte~) mul8u::$1 2.00000002E8 +(byte) mul8u::a +(byte) mul8u::a#0 1.00000001E8 +(byte) mul8u::a#1 36667.33333333333 +(byte) mul8u::a#2 6.668333416666667E7 +(byte) mul8u::b +(byte) mul8u::b#0 10001.0 +(word) mul8u::mb +(word) mul8u::mb#0 200002.0 +(word) mul8u::mb#1 2.00000002E8 +(word) mul8u::mb#2 4.287142914285715E7 +(word) mul8u::res +(word) mul8u::res#1 2.00000002E8 +(word) mul8u::res#2 5.0001667333333336E7 +(word) mul8u::res#6 1.00000001E8 +(word) mul8u::return +(word) mul8u::return#2 20002.0 +(struct printf_buffer_number) printf_buffer loadstore = {} +(byte) printf_buffer_number::sign +(byte) printf_format_number::justify_left +(byte) printf_format_number::min_length +(byte) printf_format_number::radix +(byte) printf_format_number::sign_always +(byte) printf_format_number::upper_case +(byte) printf_format_number::zero_padding +(byte) printf_format_string::justify_left +(byte) printf_format_string::min_length +(void()) printf_number_buffer((byte) printf_number_buffer::buffer_sign , (byte*) printf_number_buffer::buffer_digits , (byte) printf_number_buffer::format_min_length , (byte) printf_number_buffer::format_justify_left , (byte) printf_number_buffer::format_sign_always , (byte) printf_number_buffer::format_zero_padding , (byte) printf_number_buffer::format_upper_case , (byte) printf_number_buffer::format_radix) +(struct printf_buffer_number) printf_number_buffer::buffer +(byte*) printf_number_buffer::buffer_digits +(byte) printf_number_buffer::buffer_sign +(byte) printf_number_buffer::buffer_sign#0 701.0 +(struct printf_format_number) printf_number_buffer::format +(byte) printf_number_buffer::format_justify_left +(byte) printf_number_buffer::format_min_length +(byte) printf_number_buffer::format_radix +(byte) printf_number_buffer::format_sign_always +(byte) printf_number_buffer::format_upper_case +(byte) printf_number_buffer::format_zero_padding +(signed byte) printf_number_buffer::len +(signed byte) printf_number_buffer::padding +(void()) printf_uint((word) printf_uint::uvalue , (byte) printf_uint::format_min_length , (byte) printf_uint::format_justify_left , (byte) printf_uint::format_sign_always , (byte) printf_uint::format_zero_padding , (byte) printf_uint::format_upper_case , (byte) printf_uint::format_radix) +(struct printf_format_number) printf_uint::format +(byte) printf_uint::format_justify_left +(byte) printf_uint::format_min_length +(byte) printf_uint::format_radix +(byte) printf_uint::format_sign_always +(byte) printf_uint::format_upper_case +(byte) printf_uint::format_zero_padding +(word) printf_uint::uvalue +(word) printf_uint::uvalue#0 37.33333333333333 +(void()) utoa((word) utoa::value , (byte*) utoa::buffer , (byte) utoa::radix) +(byte~) utoa::$10 20002.0 +(byte~) utoa::$11 2002.0 +(byte*) utoa::buffer +(byte*) utoa::buffer#11 3000.4285714285716 +(byte*) utoa::buffer#14 15001.5 +(byte*) utoa::buffer#3 2002.0 +(byte*) utoa::buffer#4 20002.0 +(byte) utoa::digit +(byte) utoa::digit#1 20002.0 +(byte) utoa::digit#2 2857.4285714285716 +(word) utoa::digit_value +(word) utoa::digit_value#0 6000.6 +(word*) utoa::digit_values +(byte) utoa::max_digits +(byte) utoa::radix +(byte) utoa::started +(byte) utoa::started#2 5000.5 +(byte) utoa::started#4 10001.0 +(word) utoa::value +(word) utoa::value#0 10001.0 +(word) utoa::value#1 551.0 +(word) utoa::value#2 5857.857142857143 +(word) utoa::value#6 15001.5 +(word()) utoa_append((byte*) utoa_append::buffer , (word) utoa_append::value , (word) utoa_append::sub) +(byte*) utoa_append::buffer +(byte*) utoa_append::buffer#0 13750.25 +(byte) utoa_append::digit +(byte) utoa_append::digit#1 1.0000001E7 +(byte) utoa_append::digit#2 1.00500015E7 +(word) utoa_append::return +(word) utoa_append::return#0 20002.0 +(word) utoa_append::sub +(word) utoa_append::sub#0 3335000.5 +(word) utoa_append::value +(word) utoa_append::value#0 36667.33333333333 +(word) utoa_append::value#1 2.0000002E7 +(word) utoa_append::value#2 5018334.166666666 + +Initial phi equivalence classes +[ main::y#2 main::y#1 ] +[ main::count#11 main::count#10 main::count#12 main::count#1 ] +[ main::sc#8 main::sc#10 main::sc#1 ] +[ main::x#2 main::x#1 ] +[ mul8s::a#2 mul8s::a#1 mul8s::a#0 ] +[ mul8s::b#2 mul8s::b#1 mul8s::b#0 ] +[ mul8s::m#4 mul8s::m#5 mul8s::m#1 mul8s::m#0 mul8s::m#2 ] +[ mul8u::a#2 mul8u::a#1 mul8u::a#0 ] +[ mul8u::res#2 mul8u::res#6 mul8u::res#1 ] +[ mul8u::mb#2 mul8u::mb#0 mul8u::mb#1 ] +[ cputs::s#3 cputs::s#4 cputs::s#0 ] +[ cputc::c#3 cputc::c#0 cputc::c#2 ] +[ memset::num#3 ] +[ memset::str#4 ] +[ memset::c#5 ] +[ memset::dst#2 memset::dst#4 memset::dst#1 ] +[ memcpy::source#2 ] +[ memcpy::destination#2 ] +[ memcpy::src#2 memcpy::src#4 memcpy::src#1 ] +[ memcpy::dst#2 memcpy::dst#4 memcpy::dst#1 ] +[ utoa::digit#2 utoa::digit#1 ] +[ utoa::value#2 utoa::value#6 utoa::value#1 utoa::value#0 ] +[ utoa::started#2 utoa::started#4 ] +[ utoa::buffer#11 utoa::buffer#14 utoa::buffer#4 ] +[ utoa_append::value#2 utoa_append::value#0 utoa_append::value#1 ] +[ utoa_append::digit#2 utoa_append::digit#1 ] +Added variable conio_cursor_x to live range equivalence class [ conio_cursor_x ] +Added variable conio_cursor_y to live range equivalence class [ conio_cursor_y ] +Added variable conio_cursor_text to live range equivalence class [ conio_cursor_text ] +Added variable conio_cursor_color to live range equivalence class [ conio_cursor_color ] +Added variable printf_uint::uvalue#0 to live range equivalence class [ printf_uint::uvalue#0 ] +Added variable main::$5 to live range equivalence class [ main::$5 ] +Added variable main::xd#0 to live range equivalence class [ main::xd#0 ] +Added variable main::$7 to live range equivalence class [ main::$7 ] +Added variable main::yd#0 to live range equivalence class [ main::yd#0 ] +Added variable main::$9 to live range equivalence class [ main::$9 ] +Added variable main::$10 to live range equivalence class [ main::$10 ] +Added variable main::dist_sq#0 to live range equivalence class [ main::dist_sq#0 ] +Added variable mul8u::b#0 to live range equivalence class [ mul8u::b#0 ] +Added variable mul8u::return#2 to live range equivalence class [ mul8u::return#2 ] +Added variable mul8s::$6 to live range equivalence class [ mul8s::$6 ] +Added variable mul8s::$11 to live range equivalence class [ mul8s::$11 ] +Added variable mul8s::$9 to live range equivalence class [ mul8s::$9 ] +Added variable mul8s::$12 to live range equivalence class [ mul8s::$12 ] +Added variable mul8u::$1 to live range equivalence class [ mul8u::$1 ] +Added variable cputs::c#1 to live range equivalence class [ cputs::c#1 ] +Added variable cputln::ln_offset#0 to live range equivalence class [ cputln::ln_offset#0 ] +Added variable cputln::$1 to live range equivalence class [ cputln::$1 ] +Added variable cputln::$2 to live range equivalence class [ cputln::$2 ] +Added variable cscroll::$7 to live range equivalence class [ cscroll::$7 ] +Added variable cscroll::$8 to live range equivalence class [ cscroll::$8 ] +Added variable memset::end#0 to live range equivalence class [ memset::end#0 ] +Added variable memcpy::src_end#0 to live range equivalence class [ memcpy::src_end#0 ] +Added variable printf_number_buffer::buffer_sign#0 to live range equivalence class [ printf_number_buffer::buffer_sign#0 ] +Added variable utoa::$11 to live range equivalence class [ utoa::$11 ] +Added variable utoa::buffer#3 to live range equivalence class [ utoa::buffer#3 ] +Added variable utoa::$10 to live range equivalence class [ utoa::$10 ] +Added variable utoa::digit_value#0 to live range equivalence class [ utoa::digit_value#0 ] +Added variable utoa_append::buffer#0 to live range equivalence class [ utoa_append::buffer#0 ] +Added variable utoa_append::sub#0 to live range equivalence class [ utoa_append::sub#0 ] +Added variable utoa_append::return#0 to live range equivalence class [ utoa_append::return#0 ] +Added variable printf_buffer to live range equivalence class [ printf_buffer ] +Complete equivalence classes +[ main::y#2 main::y#1 ] +[ main::count#11 main::count#10 main::count#12 main::count#1 ] +[ main::sc#8 main::sc#10 main::sc#1 ] +[ main::x#2 main::x#1 ] +[ mul8s::a#2 mul8s::a#1 mul8s::a#0 ] +[ mul8s::b#2 mul8s::b#1 mul8s::b#0 ] +[ mul8s::m#4 mul8s::m#5 mul8s::m#1 mul8s::m#0 mul8s::m#2 ] +[ mul8u::a#2 mul8u::a#1 mul8u::a#0 ] +[ mul8u::res#2 mul8u::res#6 mul8u::res#1 ] +[ mul8u::mb#2 mul8u::mb#0 mul8u::mb#1 ] +[ cputs::s#3 cputs::s#4 cputs::s#0 ] +[ cputc::c#3 cputc::c#0 cputc::c#2 ] +[ memset::num#3 ] +[ memset::str#4 ] +[ memset::c#5 ] +[ memset::dst#2 memset::dst#4 memset::dst#1 ] +[ memcpy::source#2 ] +[ memcpy::destination#2 ] +[ memcpy::src#2 memcpy::src#4 memcpy::src#1 ] +[ memcpy::dst#2 memcpy::dst#4 memcpy::dst#1 ] +[ utoa::digit#2 utoa::digit#1 ] +[ utoa::value#2 utoa::value#6 utoa::value#1 utoa::value#0 ] +[ utoa::started#2 utoa::started#4 ] +[ utoa::buffer#11 utoa::buffer#14 utoa::buffer#4 ] +[ utoa_append::value#2 utoa_append::value#0 utoa_append::value#1 ] +[ utoa_append::digit#2 utoa_append::digit#1 ] +[ conio_cursor_x ] +[ conio_cursor_y ] +[ conio_cursor_text ] +[ conio_cursor_color ] +[ printf_uint::uvalue#0 ] +[ main::$5 ] +[ main::xd#0 ] +[ main::$7 ] +[ main::yd#0 ] +[ main::$9 ] +[ main::$10 ] +[ main::dist_sq#0 ] +[ mul8u::b#0 ] +[ mul8u::return#2 ] +[ mul8s::$6 ] +[ mul8s::$11 ] +[ mul8s::$9 ] +[ mul8s::$12 ] +[ mul8u::$1 ] +[ cputs::c#1 ] +[ cputln::ln_offset#0 ] +[ cputln::$1 ] +[ cputln::$2 ] +[ cscroll::$7 ] +[ cscroll::$8 ] +[ memset::end#0 ] +[ memcpy::src_end#0 ] +[ printf_number_buffer::buffer_sign#0 ] +[ utoa::$11 ] +[ utoa::buffer#3 ] +[ utoa::$10 ] +[ utoa::digit_value#0 ] +[ utoa_append::buffer#0 ] +[ utoa_append::sub#0 ] +[ utoa_append::return#0 ] +[ printf_buffer ] +Allocated zp[1]:2 [ main::y#2 main::y#1 ] +Allocated zp[2]:3 [ main::count#11 main::count#10 main::count#12 main::count#1 ] +Allocated zp[2]:5 [ main::sc#8 main::sc#10 main::sc#1 ] +Allocated zp[1]:7 [ main::x#2 main::x#1 ] +Allocated zp[1]:8 [ mul8s::a#2 mul8s::a#1 mul8s::a#0 ] +Allocated zp[1]:9 [ mul8s::b#2 mul8s::b#1 mul8s::b#0 ] +Allocated zp[2]:10 [ mul8s::m#4 mul8s::m#5 mul8s::m#1 mul8s::m#0 mul8s::m#2 ] +Allocated zp[1]:12 [ mul8u::a#2 mul8u::a#1 mul8u::a#0 ] +Allocated zp[2]:13 [ mul8u::res#2 mul8u::res#6 mul8u::res#1 ] +Allocated zp[2]:15 [ mul8u::mb#2 mul8u::mb#0 mul8u::mb#1 ] +Allocated zp[2]:17 [ cputs::s#3 cputs::s#4 cputs::s#0 ] +Allocated zp[1]:19 [ cputc::c#3 cputc::c#0 cputc::c#2 ] +Allocated zp[2]:20 [ memset::num#3 ] +Allocated zp[2]:22 [ memset::str#4 ] +Allocated zp[1]:24 [ memset::c#5 ] +Allocated zp[2]:25 [ memset::dst#2 memset::dst#4 memset::dst#1 ] +Allocated zp[2]:27 [ memcpy::source#2 ] +Allocated zp[2]:29 [ memcpy::destination#2 ] +Allocated zp[2]:31 [ memcpy::src#2 memcpy::src#4 memcpy::src#1 ] +Allocated zp[2]:33 [ memcpy::dst#2 memcpy::dst#4 memcpy::dst#1 ] +Allocated zp[1]:35 [ utoa::digit#2 utoa::digit#1 ] +Allocated zp[2]:36 [ utoa::value#2 utoa::value#6 utoa::value#1 utoa::value#0 ] +Allocated zp[1]:38 [ utoa::started#2 utoa::started#4 ] +Allocated zp[2]:39 [ utoa::buffer#11 utoa::buffer#14 utoa::buffer#4 ] +Allocated zp[2]:41 [ utoa_append::value#2 utoa_append::value#0 utoa_append::value#1 ] +Allocated zp[1]:43 [ utoa_append::digit#2 utoa_append::digit#1 ] +Allocated zp[1]:44 [ conio_cursor_x ] +Allocated zp[1]:45 [ conio_cursor_y ] +Allocated zp[2]:46 [ conio_cursor_text ] +Allocated zp[2]:48 [ conio_cursor_color ] +Allocated zp[2]:50 [ printf_uint::uvalue#0 ] +Allocated zp[1]:52 [ main::$5 ] +Allocated zp[1]:53 [ main::xd#0 ] +Allocated zp[1]:54 [ main::$7 ] +Allocated zp[1]:55 [ main::yd#0 ] +Allocated zp[2]:56 [ main::$9 ] +Allocated zp[2]:58 [ main::$10 ] +Allocated zp[2]:60 [ main::dist_sq#0 ] +Allocated zp[1]:62 [ mul8u::b#0 ] +Allocated zp[2]:63 [ mul8u::return#2 ] +Allocated zp[1]:65 [ mul8s::$6 ] +Allocated zp[1]:66 [ mul8s::$11 ] +Allocated zp[1]:67 [ mul8s::$9 ] +Allocated zp[1]:68 [ mul8s::$12 ] +Allocated zp[1]:69 [ mul8u::$1 ] +Allocated zp[1]:70 [ cputs::c#1 ] +Allocated zp[2]:71 [ cputln::ln_offset#0 ] +Allocated zp[2]:73 [ cputln::$1 ] +Allocated zp[2]:75 [ cputln::$2 ] +Allocated zp[2]:77 [ cscroll::$7 ] +Allocated zp[2]:79 [ cscroll::$8 ] +Allocated zp[2]:81 [ memset::end#0 ] +Allocated zp[2]:83 [ memcpy::src_end#0 ] +Allocated zp[1]:85 [ printf_number_buffer::buffer_sign#0 ] +Allocated zp[1]:86 [ utoa::$11 ] +Allocated zp[2]:87 [ utoa::buffer#3 ] +Allocated zp[1]:89 [ utoa::$10 ] +Allocated zp[2]:90 [ utoa::digit_value#0 ] +Allocated zp[2]:92 [ utoa_append::buffer#0 ] +Allocated zp[2]:94 [ utoa_append::sub#0 ] +Allocated zp[2]:96 [ utoa_append::return#0 ] +Allocated mem[12] [ printf_buffer ] + +INITIAL ASM +Target platform is c64basic / MOS6502X + // File Comments +// Plot a r=9 circle on the screen using chars - count how many chars are used + // Upstart +.pc = $801 "Basic" +:BasicUpstart(__bbegin) +.pc = $80d "Program" + // Global Constants & labels + // The default text color + .const CONIO_TEXTCOLOR_DEFAULT = $e + .const OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_DIGITS = 1 + // The screen width + // The screen height + // The screen bytes + // The text screen address + .label CONIO_SCREEN_TEXT = $400 + // The color screen address + .label CONIO_SCREEN_COLORS = $d800 + .label SCREEN = $400 + .label conio_cursor_x = $2c + .label conio_cursor_y = $2d + .label conio_cursor_text = $2e + .label conio_cursor_color = $30 + // @begin +__bbegin: + jmp __b1 + // @1 +__b1: + // [1] (byte) conio_cursor_x ← (byte) 0 -- vbuz1=vbuc1 + // The current cursor x-position + lda #0 + sta.z conio_cursor_x + // [2] (byte) conio_cursor_y ← (byte) 0 -- vbuz1=vbuc1 + // The current cursor y-position + lda #0 + sta.z conio_cursor_y + // [3] (byte*) conio_cursor_text ← (const nomodify byte*) CONIO_SCREEN_TEXT -- pbuz1=pbuc1 + // The current cursor address + lda #CONIO_SCREEN_TEXT + sta.z conio_cursor_text+1 + // [4] (byte*) conio_cursor_color ← (const nomodify byte*) CONIO_SCREEN_COLORS -- pbuz1=pbuc1 + // The current cursor address + lda #CONIO_SCREEN_COLORS + sta.z conio_cursor_color+1 + // [5] phi from @1 to @2 [phi:@1->@2] +__b2_from___b1: + jmp __b2 + // @2 +__b2: + // [6] call main + // [8] phi from @2 to main [phi:@2->main] +main_from___b2: + jsr main + // [7] phi from @2 to @end [phi:@2->@end] +__bend_from___b2: + jmp __bend + // @end +__bend: + // main +main: { + .label __5 = $34 + .label __7 = $36 + .label __9 = $38 + .label __10 = $3a + .label xd = $35 + .label yd = $37 + .label dist_sq = $3c + .label y = 2 + .label sc = 5 + .label x = 7 + .label count = 3 + // [9] call memset + // [114] phi from main to memset [phi:main->memset] + memset_from_main: + // [114] phi (byte) memset::c#5 = (byte) ' ' [phi:main->memset#0] -- vbuz1=vbuc1 + lda #' ' + sta.z memset.c + // [114] phi (void*) memset::str#4 = (void*)(const nomodify byte*) SCREEN [phi:main->memset#1] -- pvoz1=pvoc1 + lda #SCREEN + sta.z memset.str+1 + // [114] phi (word) memset::num#3 = (word) $3e8 [phi:main->memset#2] -- vwuz1=vwuc1 + lda #<$3e8 + sta.z memset.num + lda #>$3e8 + sta.z memset.num+1 + jsr memset + // [10] phi from main to main::@1 [phi:main->main::@1] + __b1_from_main: + // [10] phi (byte*) main::sc#8 = (const nomodify byte*) SCREEN [phi:main->main::@1#0] -- pbuz1=pbuc1 + lda #SCREEN + sta.z sc+1 + // [10] phi (word) main::count#11 = (word) 0 [phi:main->main::@1#1] -- vwuz1=vwuc1 + lda #<0 + sta.z count + lda #>0 + sta.z count+1 + // [10] phi (byte) main::y#2 = (byte) 0 [phi:main->main::@1#2] -- vbuz1=vbuc1 + lda #0 + sta.z y + jmp __b1 + // main::@1 + __b1: + // [11] if((byte) main::y#2<(byte) $19) goto main::@3 -- vbuz1_lt_vbuc1_then_la1 + lda.z y + cmp #$19 + bcc __b3_from___b1 + // [12] phi from main::@1 to main::@2 [phi:main::@1->main::@2] + __b2_from___b1: + jmp __b2 + // main::@2 + __b2: + // [13] call gotoxy + // [175] phi from main::@2 to gotoxy [phi:main::@2->gotoxy] + gotoxy_from___b2: + jsr gotoxy + jmp __b8 + // main::@8 + __b8: + // [14] (word) printf_uint::uvalue#0 ← (word) main::count#11 -- vwuz1=vwuz2 + lda.z count + sta.z printf_uint.uvalue + lda.z count+1 + sta.z printf_uint.uvalue+1 + // [15] call printf_uint + // [133] phi from main::@8 to printf_uint [phi:main::@8->printf_uint] + printf_uint_from___b8: + jsr printf_uint + // [16] phi from main::@8 to main::@9 [phi:main::@8->main::@9] + __b9_from___b8: + jmp __b9 + // main::@9 + __b9: + // [17] call cputs + // [68] phi from main::@9 to cputs [phi:main::@9->cputs] + cputs_from___b9: + // [68] phi (to_nomodify byte*) cputs::s#4 = (const byte*) main::s [phi:main::@9->cputs#0] -- pbuz1=pbuc1 + lda #s + sta.z cputs.s+1 + jsr cputs + jmp __breturn + // main::@return + __breturn: + // [18] return + rts + // [19] phi from main::@1 to main::@3 [phi:main::@1->main::@3] + __b3_from___b1: + // [19] phi (word) main::count#10 = (word) main::count#11 [phi:main::@1->main::@3#0] -- register_copy + // [19] phi (byte*) main::sc#10 = (byte*) main::sc#8 [phi:main::@1->main::@3#1] -- register_copy + // [19] phi (byte) main::x#2 = (byte) 0 [phi:main::@1->main::@3#2] -- vbuz1=vbuc1 + lda #0 + sta.z x + jmp __b3 + // main::@3 + __b3: + // [20] if((byte) main::x#2<(byte) $28) goto main::@4 -- vbuz1_lt_vbuc1_then_la1 + lda.z x + cmp #$28 + bcc __b4 + jmp __b5 + // main::@5 + __b5: + // [21] (byte) main::y#1 ← ++ (byte) main::y#2 -- vbuz1=_inc_vbuz1 + inc.z y + // [10] phi from main::@5 to main::@1 [phi:main::@5->main::@1] + __b1_from___b5: + // [10] phi (byte*) main::sc#8 = (byte*) main::sc#10 [phi:main::@5->main::@1#0] -- register_copy + // [10] phi (word) main::count#11 = (word) main::count#10 [phi:main::@5->main::@1#1] -- register_copy + // [10] phi (byte) main::y#2 = (byte) main::y#1 [phi:main::@5->main::@1#2] -- register_copy + jmp __b1 + // main::@4 + __b4: + // [22] (signed byte~) main::$5 ← (signed byte)(byte) main::x#2 << (byte) 1 -- vbsz1=vbsz2_rol_1 + lda.z x + asl + sta.z __5 + // [23] (signed byte) main::xd#0 ← (signed byte~) main::$5 - (signed byte) $27 -- vbsz1=vbsz2_minus_vbsc1 + lax.z __5 + axs #$27 + stx.z xd + // [24] (signed byte~) main::$7 ← (signed byte)(byte) main::y#2 << (byte) 1 -- vbsz1=vbsz2_rol_1 + lda.z y + asl + sta.z __7 + // [25] (signed byte) main::yd#0 ← (signed byte~) main::$7 - (signed byte) $18 -- vbsz1=vbsz2_minus_vbsc1 + lax.z __7 + axs #$18 + stx.z yd + // [26] (signed byte) mul8s::a#0 ← (signed byte) main::xd#0 -- vbsz1=vbsz2 + lda.z xd + sta.z mul8s.a + // [27] (signed byte) mul8s::b#0 ← (signed byte) main::xd#0 -- vbsz1=vbsz2 + lda.z xd + sta.z mul8s.b + // [28] call mul8s + // [41] phi from main::@4 to mul8s [phi:main::@4->mul8s] + mul8s_from___b4: + // [41] phi (signed byte) mul8s::b#2 = (signed byte) mul8s::b#0 [phi:main::@4->mul8s#0] -- register_copy + // [41] phi (signed byte) mul8s::a#2 = (signed byte) mul8s::a#0 [phi:main::@4->mul8s#1] -- register_copy + jsr mul8s + jmp __b10 + // main::@10 + __b10: + // [29] (signed word~) main::$9 ← (signed word)(word) mul8s::m#4 -- vwsz1=vwsz2 + lda.z mul8s.m + sta.z __9 + lda.z mul8s.m+1 + sta.z __9+1 + // [30] (signed byte) mul8s::a#1 ← (signed byte) main::yd#0 -- vbsz1=vbsz2 + lda.z yd + sta.z mul8s.a + // [31] (signed byte) mul8s::b#1 ← (signed byte) main::yd#0 -- vbsz1=vbsz2 + lda.z yd + sta.z mul8s.b + // [32] call mul8s + // [41] phi from main::@10 to mul8s [phi:main::@10->mul8s] + mul8s_from___b10: + // [41] phi (signed byte) mul8s::b#2 = (signed byte) mul8s::b#1 [phi:main::@10->mul8s#0] -- register_copy + // [41] phi (signed byte) mul8s::a#2 = (signed byte) mul8s::a#1 [phi:main::@10->mul8s#1] -- register_copy + jsr mul8s + jmp __b11 + // main::@11 + __b11: + // [33] (signed word~) main::$10 ← (signed word)(word) mul8s::m#4 -- vwsz1=vwsz2 + lda.z mul8s.m + sta.z __10 + lda.z mul8s.m+1 + sta.z __10+1 + // [34] (signed word) main::dist_sq#0 ← (signed word~) main::$9 + (signed word~) main::$10 -- vwsz1=vwsz2_plus_vwsz3 + lda.z __9 + clc + adc.z __10 + sta.z dist_sq + lda.z __9+1 + adc.z __10+1 + sta.z dist_sq+1 + // [35] if((signed word) main::dist_sq#0>=(signed word)(number) 2*(number) 9*(number) 2*(number) 9) goto main::@6 -- vwsz1_ge_vwsc1_then_la1 + lda.z dist_sq + cmp #<2*9*2*9 + lda.z dist_sq+1 + sbc #>2*9*2*9 + bvc !+ + eor #$80 + !: + bpl __b6_from___b11 + jmp __b7 + // main::@7 + __b7: + // [36] *((byte*) main::sc#10) ← (byte) '*' -- _deref_pbuz1=vbuc1 + lda #'*' + ldy #0 + sta (sc),y + // [37] (word) main::count#1 ← ++ (word) main::count#10 -- vwuz1=_inc_vwuz1 + inc.z count + bne !+ + inc.z count+1 + !: + // [38] phi from main::@11 main::@7 to main::@6 [phi:main::@11/main::@7->main::@6] + __b6_from___b11: + __b6_from___b7: + // [38] phi (word) main::count#12 = (word) main::count#10 [phi:main::@11/main::@7->main::@6#0] -- register_copy + jmp __b6 + // main::@6 + __b6: + // [39] (byte*) main::sc#1 ← ++ (byte*) main::sc#10 -- pbuz1=_inc_pbuz1 + inc.z sc + bne !+ + inc.z sc+1 + !: + // [40] (byte) main::x#1 ← ++ (byte) main::x#2 -- vbuz1=_inc_vbuz1 + inc.z x + // [19] phi from main::@6 to main::@3 [phi:main::@6->main::@3] + __b3_from___b6: + // [19] phi (word) main::count#10 = (word) main::count#12 [phi:main::@6->main::@3#0] -- register_copy + // [19] phi (byte*) main::sc#10 = (byte*) main::sc#1 [phi:main::@6->main::@3#1] -- register_copy + // [19] phi (byte) main::x#2 = (byte) main::x#1 [phi:main::@6->main::@3#2] -- register_copy + jmp __b3 + s: .text " chars" + .byte 0 +} + // mul8s +// Multiply of two signed chars to a signed int +// Fixes offsets introduced by using unsigned multiplication +// mul8s(signed byte zp(8) a, signed byte zp(9) b) +mul8s: { + .label __6 = $41 + .label __9 = $43 + .label __11 = $42 + .label __12 = $44 + .label m = $a + .label a = 8 + .label b = 9 + // [42] (byte) mul8u::a#1 ← (byte)(signed byte) mul8s::a#2 -- vbuz1=vbuz2 + lda.z a + sta.z mul8u.a + // [43] (byte) mul8u::b#0 ← (byte)(signed byte) mul8s::b#2 -- vbuz1=vbuz2 + lda.z b + sta.z mul8u.b + // [44] call mul8u + jsr mul8u + // [45] (word) mul8u::return#2 ← (word) mul8u::res#2 -- vwuz1=vwuz2 + lda.z mul8u.res + sta.z mul8u.return + lda.z mul8u.res+1 + sta.z mul8u.return+1 + jmp __b5 + // mul8s::@5 + __b5: + // [46] (word) mul8s::m#0 ← (word) mul8u::return#2 -- vwuz1=vwuz2 + lda.z mul8u.return + sta.z m + lda.z mul8u.return+1 + sta.z m+1 + // [47] if((signed byte) mul8s::a#2>=(signed byte) 0) goto mul8s::@1 -- vbsz1_ge_0_then_la1 + lda.z a + cmp #0 + bpl __b1_from___b5 + jmp __b3 + // mul8s::@3 + __b3: + // [48] (byte~) mul8s::$6 ← > (word) mul8s::m#0 -- vbuz1=_hi_vwuz2 + lda.z m+1 + sta.z __6 + // [49] (byte~) mul8s::$11 ← (byte~) mul8s::$6 - (byte)(signed byte) mul8s::b#2 -- vbuz1=vbuz2_minus_vbuz3 + lda.z __6 + sec + sbc.z b + sta.z __11 + // [50] (word) mul8s::m#1 ← (word) mul8s::m#0 hi= (byte~) mul8s::$11 -- vwuz1=vwuz1_sethi_vbuz2 + lda.z __11 + sta.z m+1 + // [51] phi from mul8s::@3 mul8s::@5 to mul8s::@1 [phi:mul8s::@3/mul8s::@5->mul8s::@1] + __b1_from___b3: + __b1_from___b5: + // [51] phi (word) mul8s::m#5 = (word) mul8s::m#1 [phi:mul8s::@3/mul8s::@5->mul8s::@1#0] -- register_copy + jmp __b1 + // mul8s::@1 + __b1: + // [52] if((signed byte) mul8s::b#2>=(signed byte) 0) goto mul8s::@2 -- vbsz1_ge_0_then_la1 + lda.z b + cmp #0 + bpl __b2_from___b1 + jmp __b4 + // mul8s::@4 + __b4: + // [53] (byte~) mul8s::$9 ← > (word) mul8s::m#5 -- vbuz1=_hi_vwuz2 + lda.z m+1 + sta.z __9 + // [54] (byte~) mul8s::$12 ← (byte~) mul8s::$9 - (byte)(signed byte) mul8s::a#2 -- vbuz1=vbuz2_minus_vbuz3 + lda.z __9 + sec + sbc.z a + sta.z __12 + // [55] (word) mul8s::m#2 ← (word) mul8s::m#5 hi= (byte~) mul8s::$12 -- vwuz1=vwuz1_sethi_vbuz2 + lda.z __12 + sta.z m+1 + // [56] phi from mul8s::@1 mul8s::@4 to mul8s::@2 [phi:mul8s::@1/mul8s::@4->mul8s::@2] + __b2_from___b1: + __b2_from___b4: + // [56] phi (word) mul8s::m#4 = (word) mul8s::m#5 [phi:mul8s::@1/mul8s::@4->mul8s::@2#0] -- register_copy + jmp __b2 + // mul8s::@2 + __b2: + jmp __breturn + // mul8s::@return + __breturn: + // [57] return + rts +} + // mul8u +// Perform binary multiplication of two unsigned 8-bit chars into a 16-bit unsigned int +// mul8u(byte zp($c) a, byte zp($3e) b) +mul8u: { + .label __1 = $45 + .label mb = $f + .label a = $c + .label res = $d + .label b = $3e + .label return = $3f + // [58] (word) mul8u::mb#0 ← (word)(byte) mul8u::b#0 -- vwuz1=_word_vbuz2 + lda.z b + sta.z mb + lda #0 + sta.z mb+1 + // [59] phi from mul8u to mul8u::@1 [phi:mul8u->mul8u::@1] + __b1_from_mul8u: + // [59] phi (word) mul8u::mb#2 = (word) mul8u::mb#0 [phi:mul8u->mul8u::@1#0] -- register_copy + // [59] phi (word) mul8u::res#2 = (word) 0 [phi:mul8u->mul8u::@1#1] -- vwuz1=vwuc1 + lda #<0 + sta.z res + lda #>0 + sta.z res+1 + // [59] phi (byte) mul8u::a#2 = (byte) mul8u::a#1 [phi:mul8u->mul8u::@1#2] -- register_copy + jmp __b1 + // mul8u::@1 + __b1: + // [60] if((byte) mul8u::a#2!=(byte) 0) goto mul8u::@2 -- vbuz1_neq_0_then_la1 + lda.z a + cmp #0 + bne __b2 + jmp __breturn + // mul8u::@return + __breturn: + // [61] return + rts + // mul8u::@2 + __b2: + // [62] (byte~) mul8u::$1 ← (byte) mul8u::a#2 & (byte) 1 -- vbuz1=vbuz2_band_vbuc1 + lda #1 + and.z a + sta.z __1 + // [63] if((byte~) mul8u::$1==(byte) 0) goto mul8u::@3 -- vbuz1_eq_0_then_la1 + lda.z __1 + cmp #0 + beq __b3_from___b2 + jmp __b4 + // mul8u::@4 + __b4: + // [64] (word) mul8u::res#1 ← (word) mul8u::res#2 + (word) mul8u::mb#2 -- vwuz1=vwuz1_plus_vwuz2 + lda.z res + clc + adc.z mb + sta.z res + lda.z res+1 + adc.z mb+1 + sta.z res+1 + // [65] phi from mul8u::@2 mul8u::@4 to mul8u::@3 [phi:mul8u::@2/mul8u::@4->mul8u::@3] + __b3_from___b2: + __b3_from___b4: + // [65] phi (word) mul8u::res#6 = (word) mul8u::res#2 [phi:mul8u::@2/mul8u::@4->mul8u::@3#0] -- register_copy + jmp __b3 + // mul8u::@3 + __b3: + // [66] (byte) mul8u::a#0 ← (byte) mul8u::a#2 >> (byte) 1 -- vbuz1=vbuz1_ror_1 + lsr.z a + // [67] (word) mul8u::mb#1 ← (word) mul8u::mb#2 << (byte) 1 -- vwuz1=vwuz1_rol_1 + asl.z mb + rol.z mb+1 + // [59] phi from mul8u::@3 to mul8u::@1 [phi:mul8u::@3->mul8u::@1] + __b1_from___b3: + // [59] phi (word) mul8u::mb#2 = (word) mul8u::mb#1 [phi:mul8u::@3->mul8u::@1#0] -- register_copy + // [59] phi (word) mul8u::res#2 = (word) mul8u::res#6 [phi:mul8u::@3->mul8u::@1#1] -- register_copy + // [59] phi (byte) mul8u::a#2 = (byte) mul8u::a#0 [phi:mul8u::@3->mul8u::@1#2] -- register_copy + jmp __b1 +} + // cputs +// Output a NUL-terminated string at the current cursor position +// cputs(byte* zp($11) s) +cputs: { + .label c = $46 + .label s = $11 + // [69] phi from cputs cputs::@2 to cputs::@1 [phi:cputs/cputs::@2->cputs::@1] + __b1_from_cputs: + __b1_from___b2: + // [69] phi (to_nomodify byte*) cputs::s#3 = (to_nomodify byte*) cputs::s#4 [phi:cputs/cputs::@2->cputs::@1#0] -- register_copy + jmp __b1 + // cputs::@1 + __b1: + // [70] (byte) cputs::c#1 ← *((to_nomodify byte*) cputs::s#3) -- vbuz1=_deref_pbuz2 + ldy #0 + lda (s),y + sta.z c + // [71] (to_nomodify byte*) cputs::s#0 ← ++ (to_nomodify byte*) cputs::s#3 -- pbuz1=_inc_pbuz1 + inc.z s + bne !+ + inc.z s+1 + !: + // [72] if((byte) 0!=(byte) cputs::c#1) goto cputs::@2 -- vbuc1_neq_vbuz1_then_la1 + lda #0 + cmp.z c + bne __b2 + jmp __breturn + // cputs::@return + __breturn: + // [73] return + rts + // cputs::@2 + __b2: + // [74] (byte) cputc::c#0 ← (byte) cputs::c#1 -- vbuz1=vbuz2 + lda.z c + sta.z cputc.c + // [75] call cputc + // [76] phi from cputs::@2 to cputc [phi:cputs::@2->cputc] + cputc_from___b2: + // [76] phi (byte) cputc::c#3 = (byte) cputc::c#0 [phi:cputs::@2->cputc#0] -- register_copy + jsr cputc + jmp __b1_from___b2 +} + // cputc +// Output one character at the current cursor position +// Moves the cursor forward. Scrolls the entire screen if needed +// cputc(byte zp($13) c) +cputc: { + .label c = $13 + // [77] if((byte) cputc::c#3==(byte) ' ') goto cputc::@1 -- vbuz1_eq_vbuc1_then_la1 + lda #'\n' + cmp.z c + beq __b1_from_cputc + jmp __b2 + // cputc::@2 + __b2: + // [78] *((byte*) conio_cursor_text) ← (byte) cputc::c#3 -- _deref_pbuz1=vbuz2 + lda.z c + ldy #0 + sta (conio_cursor_text),y + // [79] (byte*) conio_cursor_text ← ++ (byte*) conio_cursor_text -- pbuz1=_inc_pbuz1 + inc.z conio_cursor_text + bne !+ + inc.z conio_cursor_text+1 + !: + // [80] *((byte*) conio_cursor_color) ← (const nomodify byte) CONIO_TEXTCOLOR_DEFAULT -- _deref_pbuz1=vbuc1 + lda #CONIO_TEXTCOLOR_DEFAULT + ldy #0 + sta (conio_cursor_color),y + // [81] (byte*) conio_cursor_color ← ++ (byte*) conio_cursor_color -- pbuz1=_inc_pbuz1 + inc.z conio_cursor_color + bne !+ + inc.z conio_cursor_color+1 + !: + // [82] (byte) conio_cursor_x ← ++ (byte) conio_cursor_x -- vbuz1=_inc_vbuz1 + inc.z conio_cursor_x + // [83] if((byte) conio_cursor_x!=(byte) $28) goto cputc::@return -- vbuz1_neq_vbuc1_then_la1 + lda #$28 + cmp.z conio_cursor_x + bne __breturn + jmp __b3 + // cputc::@3 + __b3: + // [84] (byte) conio_cursor_x ← (byte) 0 -- vbuz1=vbuc1 + lda #0 + sta.z conio_cursor_x + // [85] (byte) conio_cursor_y ← ++ (byte) conio_cursor_y -- vbuz1=_inc_vbuz1 + inc.z conio_cursor_y + // [86] call cscroll + jsr cscroll + jmp __breturn + // cputc::@return + __breturn: + // [87] return + rts + // [88] phi from cputc to cputc::@1 [phi:cputc->cputc::@1] + __b1_from_cputc: + jmp __b1 + // cputc::@1 + __b1: + // [89] call cputln + jsr cputln + jmp __breturn +} + // cputln +// Print a newline +cputln: { + .label __1 = $49 + .label __2 = $4b + .label ln_offset = $47 + // [90] (word) cputln::ln_offset#0 ← (byte) $28 - (byte) conio_cursor_x -- vwuz1=vbuc1_minus_vbuz2 + sec + lda #$28 + sbc.z conio_cursor_x + sta.z ln_offset + lda #0 + sbc #0 + sta.z ln_offset+1 + // [91] (byte*~) cputln::$1 ← (byte*) conio_cursor_text + (word) cputln::ln_offset#0 -- pbuz1=pbuz2_plus_vwuz3 + lda.z conio_cursor_text + clc + adc.z ln_offset + sta.z __1 + lda.z conio_cursor_text+1 + adc.z ln_offset+1 + sta.z __1+1 + // [92] (byte*) conio_cursor_text ← (byte*~) cputln::$1 -- pbuz1=pbuz2 + lda.z __1 + sta.z conio_cursor_text + lda.z __1+1 + sta.z conio_cursor_text+1 + // [93] (byte*~) cputln::$2 ← (byte*) conio_cursor_color + (word) cputln::ln_offset#0 -- pbuz1=pbuz2_plus_vwuz3 + lda.z conio_cursor_color + clc + adc.z ln_offset + sta.z __2 + lda.z conio_cursor_color+1 + adc.z ln_offset+1 + sta.z __2+1 + // [94] (byte*) conio_cursor_color ← (byte*~) cputln::$2 -- pbuz1=pbuz2 + lda.z __2 + sta.z conio_cursor_color + lda.z __2+1 + sta.z conio_cursor_color+1 + // [95] (byte) conio_cursor_x ← (byte) 0 -- vbuz1=vbuc1 + lda #0 + sta.z conio_cursor_x + // [96] (byte) conio_cursor_y ← ++ (byte) conio_cursor_y -- vbuz1=_inc_vbuz1 + inc.z conio_cursor_y + // [97] call cscroll + jsr cscroll + jmp __breturn + // cputln::@return + __breturn: + // [98] return + rts +} + // cscroll +// Scroll the entire screen if the cursor is beyond the last line +cscroll: { + .label __7 = $4d + .label __8 = $4f + // [99] if((byte) conio_cursor_y!=(byte) $19) goto cscroll::@return -- vbuz1_neq_vbuc1_then_la1 + lda #$19 + cmp.z conio_cursor_y + bne __breturn + // [100] phi from cscroll to cscroll::@1 [phi:cscroll->cscroll::@1] + __b1_from_cscroll: + jmp __b1 + // cscroll::@1 + __b1: + // [101] call memcpy + // [123] phi from cscroll::@1 to memcpy [phi:cscroll::@1->memcpy] + memcpy_from___b1: + // [123] phi (void*) memcpy::destination#2 = (void*)(const nomodify byte*) CONIO_SCREEN_TEXT [phi:cscroll::@1->memcpy#0] -- pvoz1=pvoc1 + lda #CONIO_SCREEN_TEXT + sta.z memcpy.destination+1 + // [123] phi (void*) memcpy::source#2 = (void*)(const nomodify byte*) CONIO_SCREEN_TEXT+(byte) $28 [phi:cscroll::@1->memcpy#1] -- pvoz1=pvoc1 + lda #CONIO_SCREEN_TEXT+$28 + sta.z memcpy.source+1 + jsr memcpy + // [102] phi from cscroll::@1 to cscroll::@2 [phi:cscroll::@1->cscroll::@2] + __b2_from___b1: + jmp __b2 + // cscroll::@2 + __b2: + // [103] call memcpy + // [123] phi from cscroll::@2 to memcpy [phi:cscroll::@2->memcpy] + memcpy_from___b2: + // [123] phi (void*) memcpy::destination#2 = (void*)(const nomodify byte*) CONIO_SCREEN_COLORS [phi:cscroll::@2->memcpy#0] -- pvoz1=pvoc1 + lda #CONIO_SCREEN_COLORS + sta.z memcpy.destination+1 + // [123] phi (void*) memcpy::source#2 = (void*)(const nomodify byte*) CONIO_SCREEN_COLORS+(byte) $28 [phi:cscroll::@2->memcpy#1] -- pvoz1=pvoc1 + lda #CONIO_SCREEN_COLORS+$28 + sta.z memcpy.source+1 + jsr memcpy + // [104] phi from cscroll::@2 to cscroll::@3 [phi:cscroll::@2->cscroll::@3] + __b3_from___b2: + jmp __b3 + // cscroll::@3 + __b3: + // [105] call memset + // [114] phi from cscroll::@3 to memset [phi:cscroll::@3->memset] + memset_from___b3: + // [114] phi (byte) memset::c#5 = (byte) ' ' [phi:cscroll::@3->memset#0] -- vbuz1=vbuc1 + lda #' ' + sta.z memset.c + // [114] phi (void*) memset::str#4 = (void*)(const nomodify byte*) CONIO_SCREEN_TEXT+(word)(number) $19*(number) $28-(byte) $28 [phi:cscroll::@3->memset#1] -- pvoz1=pvoc1 + lda #CONIO_SCREEN_TEXT+$19*$28-$28 + sta.z memset.str+1 + // [114] phi (word) memset::num#3 = (byte) $28 [phi:cscroll::@3->memset#2] -- vwuz1=vbuc1 + lda #<$28 + sta.z memset.num + lda #>$28 + sta.z memset.num+1 + jsr memset + // [106] phi from cscroll::@3 to cscroll::@4 [phi:cscroll::@3->cscroll::@4] + __b4_from___b3: + jmp __b4 + // cscroll::@4 + __b4: + // [107] call memset + // [114] phi from cscroll::@4 to memset [phi:cscroll::@4->memset] + memset_from___b4: + // [114] phi (byte) memset::c#5 = (const nomodify byte) CONIO_TEXTCOLOR_DEFAULT [phi:cscroll::@4->memset#0] -- vbuz1=vbuc1 + lda #CONIO_TEXTCOLOR_DEFAULT + sta.z memset.c + // [114] phi (void*) memset::str#4 = (void*)(const nomodify byte*) CONIO_SCREEN_COLORS+(word)(number) $19*(number) $28-(byte) $28 [phi:cscroll::@4->memset#1] -- pvoz1=pvoc1 + lda #CONIO_SCREEN_COLORS+$19*$28-$28 + sta.z memset.str+1 + // [114] phi (word) memset::num#3 = (byte) $28 [phi:cscroll::@4->memset#2] -- vwuz1=vbuc1 + lda #<$28 + sta.z memset.num + lda #>$28 + sta.z memset.num+1 + jsr memset + jmp __b5 + // cscroll::@5 + __b5: + // [108] (byte*~) cscroll::$7 ← (byte*) conio_cursor_text - (byte) $28 -- pbuz1=pbuz2_minus_vwuc1 + lda.z conio_cursor_text + sec + sbc #<$28 + sta.z __7 + lda.z conio_cursor_text+1 + sbc #>$28 + sta.z __7+1 + // [109] (byte*) conio_cursor_text ← (byte*~) cscroll::$7 -- pbuz1=pbuz2 + lda.z __7 + sta.z conio_cursor_text + lda.z __7+1 + sta.z conio_cursor_text+1 + // [110] (byte*~) cscroll::$8 ← (byte*) conio_cursor_color - (byte) $28 -- pbuz1=pbuz2_minus_vwuc1 + lda.z conio_cursor_color + sec + sbc #<$28 + sta.z __8 + lda.z conio_cursor_color+1 + sbc #>$28 + sta.z __8+1 + // [111] (byte*) conio_cursor_color ← (byte*~) cscroll::$8 -- pbuz1=pbuz2 + lda.z __8 + sta.z conio_cursor_color + lda.z __8+1 + sta.z conio_cursor_color+1 + // [112] (byte) conio_cursor_y ← -- (byte) conio_cursor_y -- vbuz1=_dec_vbuz1 + dec.z conio_cursor_y + jmp __breturn + // cscroll::@return + __breturn: + // [113] 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(void* zp($16) str, byte zp($18) c, word zp($14) num) +memset: { + .label end = $51 + .label dst = $19 + .label num = $14 + .label str = $16 + .label c = $18 + // [115] if((word) memset::num#3<=(byte) 0) goto memset::@return -- vwuz1_le_0_then_la1 + lda.z num + bne !+ + lda.z num+1 + beq __breturn + !: + jmp __b1 + // memset::@1 + __b1: + // [116] (byte*) memset::end#0 ← (byte*)(void*) memset::str#4 + (word) memset::num#3 -- pbuz1=pbuz2_plus_vwuz3 + lda.z str + clc + adc.z num + sta.z end + lda.z str+1 + adc.z num+1 + sta.z end+1 + // [117] (byte*) memset::dst#4 ← (byte*)(void*) memset::str#4 -- pbuz1=pbuz2 + lda.z str + sta.z dst + lda.z str+1 + sta.z dst+1 + // [118] phi from memset::@1 memset::@3 to memset::@2 [phi:memset::@1/memset::@3->memset::@2] + __b2_from___b1: + __b2_from___b3: + // [118] phi (byte*) memset::dst#2 = (byte*) memset::dst#4 [phi:memset::@1/memset::@3->memset::@2#0] -- register_copy + jmp __b2 + // memset::@2 + __b2: + // [119] if((byte*) memset::dst#2!=(byte*) memset::end#0) goto memset::@3 -- pbuz1_neq_pbuz2_then_la1 + lda.z dst+1 + cmp.z end+1 + bne __b3 + lda.z dst + cmp.z end + bne __b3 + jmp __breturn + // memset::@return + __breturn: + // [120] return + rts + // memset::@3 + __b3: + // [121] *((byte*) memset::dst#2) ← (byte) memset::c#5 -- _deref_pbuz1=vbuz2 + lda.z c + ldy #0 + sta (dst),y + // [122] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2 -- pbuz1=_inc_pbuz1 + inc.z dst + bne !+ + inc.z dst+1 + !: + jmp __b2_from___b3 +} + // memcpy +// Copy block of memory (forwards) +// Copies the values of num bytes from the location pointed to by source directly to the memory block pointed to by destination. +// memcpy(void* zp($1d) destination, void* zp($1b) source) +memcpy: { + .label src_end = $53 + .label dst = $21 + .label src = $1f + .label source = $1b + .label destination = $1d + // [124] (byte*) memcpy::src_end#0 ← (byte*)(void*) memcpy::source#2 + (word)(number) $19*(number) $28-(number) $28 -- pbuz1=pbuz2_plus_vwuc1 + lda.z source + clc + adc #<$19*$28-$28 + sta.z src_end + lda.z source+1 + adc #>$19*$28-$28 + sta.z src_end+1 + // [125] (byte*) memcpy::src#4 ← (byte*)(void*) memcpy::source#2 -- pbuz1=pbuz2 + lda.z source + sta.z src + lda.z source+1 + sta.z src+1 + // [126] (byte*) memcpy::dst#4 ← (byte*)(void*) memcpy::destination#2 -- pbuz1=pbuz2 + lda.z destination + sta.z dst + lda.z destination+1 + sta.z dst+1 + // [127] phi from memcpy memcpy::@2 to memcpy::@1 [phi:memcpy/memcpy::@2->memcpy::@1] + __b1_from_memcpy: + __b1_from___b2: + // [127] phi (byte*) memcpy::dst#2 = (byte*) memcpy::dst#4 [phi:memcpy/memcpy::@2->memcpy::@1#0] -- register_copy + // [127] phi (byte*) memcpy::src#2 = (byte*) memcpy::src#4 [phi:memcpy/memcpy::@2->memcpy::@1#1] -- register_copy + jmp __b1 + // memcpy::@1 + __b1: + // [128] if((byte*) memcpy::src#2!=(byte*) memcpy::src_end#0) goto memcpy::@2 -- pbuz1_neq_pbuz2_then_la1 + lda.z src+1 + cmp.z src_end+1 + bne __b2 + lda.z src + cmp.z src_end + bne __b2 + jmp __breturn + // memcpy::@return + __breturn: + // [129] return + rts + // memcpy::@2 + __b2: + // [130] *((byte*) memcpy::dst#2) ← *((byte*) memcpy::src#2) -- _deref_pbuz1=_deref_pbuz2 + ldy #0 + lda (src),y + ldy #0 + sta (dst),y + // [131] (byte*) memcpy::dst#1 ← ++ (byte*) memcpy::dst#2 -- pbuz1=_inc_pbuz1 + inc.z dst + bne !+ + inc.z dst+1 + !: + // [132] (byte*) memcpy::src#1 ← ++ (byte*) memcpy::src#2 -- pbuz1=_inc_pbuz1 + inc.z src + bne !+ + inc.z src+1 + !: + jmp __b1_from___b2 +} + // printf_uint +// Print an unsigned int using a specific format +// printf_uint(word zp($32) uvalue) +printf_uint: { + .label uvalue = $32 + jmp __b1 + // printf_uint::@1 + __b1: + // [134] *((byte*)&(struct printf_buffer_number) printf_buffer) ← (byte) 0 -- _deref_pbuc1=vbuc2 + // Handle any sign + lda #0 + sta printf_buffer + // [135] (word) utoa::value#1 ← (word) printf_uint::uvalue#0 -- vwuz1=vwuz2 + lda.z uvalue + sta.z utoa.value + lda.z uvalue+1 + sta.z utoa.value+1 + // [136] call utoa + // Format number into buffer + // [147] phi from printf_uint::@1 to utoa [phi:printf_uint::@1->utoa] + utoa_from___b1: + jsr utoa + jmp __b2 + // printf_uint::@2 + __b2: + // [137] (byte) printf_number_buffer::buffer_sign#0 ← *((byte*)&(struct printf_buffer_number) printf_buffer) -- vbuz1=_deref_pbuc1 + lda printf_buffer + sta.z printf_number_buffer.buffer_sign + // [138] call printf_number_buffer + // Print using format + // [140] phi from printf_uint::@2 to printf_number_buffer [phi:printf_uint::@2->printf_number_buffer] + printf_number_buffer_from___b2: + jsr printf_number_buffer + jmp __breturn + // printf_uint::@return + __breturn: + // [139] return + rts +} + // printf_number_buffer +// Print the contents of the number buffer using a specific format. +// This handles minimum length, zero-filling, and left/right justification from the format +// printf_number_buffer(byte zp($55) buffer_sign) +printf_number_buffer: { + .label buffer_digits = printf_buffer+OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_DIGITS + .label buffer_sign = $55 + jmp __b1 + // printf_number_buffer::@1 + __b1: + // [141] if((byte) 0==(byte) printf_number_buffer::buffer_sign#0) goto printf_number_buffer::@2 -- vbuc1_eq_vbuz1_then_la1 + lda #0 + cmp.z buffer_sign + beq __b2_from___b1 + jmp __b3 + // printf_number_buffer::@3 + __b3: + // [142] (byte) cputc::c#2 ← (byte) printf_number_buffer::buffer_sign#0 -- vbuz1=vbuz2 + lda.z buffer_sign + sta.z cputc.c + // [143] call cputc + // [76] phi from printf_number_buffer::@3 to cputc [phi:printf_number_buffer::@3->cputc] + cputc_from___b3: + // [76] phi (byte) cputc::c#3 = (byte) cputc::c#2 [phi:printf_number_buffer::@3->cputc#0] -- register_copy + jsr cputc + // [144] phi from printf_number_buffer::@1 printf_number_buffer::@3 to printf_number_buffer::@2 [phi:printf_number_buffer::@1/printf_number_buffer::@3->printf_number_buffer::@2] + __b2_from___b1: + __b2_from___b3: + jmp __b2 + // printf_number_buffer::@2 + __b2: + // [145] call cputs + // [68] phi from printf_number_buffer::@2 to cputs [phi:printf_number_buffer::@2->cputs] + cputs_from___b2: + // [68] phi (to_nomodify byte*) cputs::s#4 = (const byte*) printf_number_buffer::buffer_digits#0 [phi:printf_number_buffer::@2->cputs#0] -- pbuz1=pbuc1 + lda #buffer_digits + sta.z cputs.s+1 + jsr cputs + jmp __breturn + // printf_number_buffer::@return + __breturn: + // [146] return + rts +} + // utoa +// Converts unsigned number value to a string representing it in RADIX format. +// If the leading digits are zero they are not included in the string. +// - value : The number to be converted to RADIX +// - buffer : receives the string representing the number and zero-termination. +// - radix : The radix to convert the number to (from the enum RADIX) +// utoa(word zp($24) value, byte* zp($57) buffer) +utoa: { + .const max_digits = 5 + .label __10 = $59 + .label __11 = $56 + .label digit_value = $5a + .label buffer = $57 + .label digit = $23 + .label value = $24 + .label buffer_1 = $27 + .label started = $26 + // [148] phi from utoa to utoa::@1 [phi:utoa->utoa::@1] + __b1_from_utoa: + // [148] phi (byte*) utoa::buffer#11 = (byte*)&(struct printf_buffer_number) printf_buffer+(const byte) OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_DIGITS [phi:utoa->utoa::@1#0] -- pbuz1=pbuc1 + lda #printf_buffer+OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_DIGITS + sta.z buffer_1+1 + // [148] phi (byte) utoa::started#2 = (byte) 0 [phi:utoa->utoa::@1#1] -- vbuz1=vbuc1 + lda #0 + sta.z started + // [148] phi (word) utoa::value#2 = (word) utoa::value#1 [phi:utoa->utoa::@1#2] -- register_copy + // [148] phi (byte) utoa::digit#2 = (byte) 0 [phi:utoa->utoa::@1#3] -- vbuz1=vbuc1 + lda #0 + sta.z digit + jmp __b1 + // utoa::@1 + __b1: + // [149] if((byte) utoa::digit#2<(const byte) utoa::max_digits#1-(byte) 1) goto utoa::@2 -- vbuz1_lt_vbuc1_then_la1 + lda.z digit + cmp #max_digits-1 + bcc __b2 + jmp __b3 + // utoa::@3 + __b3: + // [150] (byte~) utoa::$11 ← (byte)(word) utoa::value#2 -- vbuz1=_byte_vwuz2 + lda.z value + sta.z __11 + // [151] *((byte*) utoa::buffer#11) ← *((const byte*) DIGITS + (byte~) utoa::$11) -- _deref_pbuz1=pbuc1_derefidx_vbuz2 + ldy.z __11 + lda DIGITS,y + ldy #0 + sta (buffer_1),y + // [152] (byte*) utoa::buffer#3 ← ++ (byte*) utoa::buffer#11 -- pbuz1=_inc_pbuz2 + lda.z buffer_1 + clc + adc #1 + sta.z buffer + lda.z buffer_1+1 + adc #0 + sta.z buffer+1 + // [153] *((byte*) utoa::buffer#3) ← (byte) 0 -- _deref_pbuz1=vbuc1 + lda #0 + ldy #0 + sta (buffer),y + jmp __breturn + // utoa::@return + __breturn: + // [154] return + rts + // utoa::@2 + __b2: + // [155] (byte~) utoa::$10 ← (byte) utoa::digit#2 << (byte) 1 -- vbuz1=vbuz2_rol_1 + lda.z digit + asl + sta.z __10 + // [156] (word) utoa::digit_value#0 ← *((const word*) RADIX_DECIMAL_VALUES + (byte~) utoa::$10) -- vwuz1=pwuc1_derefidx_vbuz2 + ldy.z __10 + lda RADIX_DECIMAL_VALUES,y + sta.z digit_value + lda RADIX_DECIMAL_VALUES+1,y + sta.z digit_value+1 + // [157] if((byte) 0!=(byte) utoa::started#2) goto utoa::@5 -- vbuc1_neq_vbuz1_then_la1 + lda #0 + cmp.z started + bne __b5 + jmp __b7 + // utoa::@7 + __b7: + // [158] if((word) utoa::value#2>=(word) utoa::digit_value#0) goto utoa::@5 -- vwuz1_ge_vwuz2_then_la1 + lda.z digit_value+1 + cmp.z value+1 + bne !+ + lda.z digit_value + cmp.z value + beq __b5 + !: + bcc __b5 + // [159] phi from utoa::@7 to utoa::@4 [phi:utoa::@7->utoa::@4] + __b4_from___b7: + // [159] phi (byte*) utoa::buffer#14 = (byte*) utoa::buffer#11 [phi:utoa::@7->utoa::@4#0] -- register_copy + // [159] phi (byte) utoa::started#4 = (byte) utoa::started#2 [phi:utoa::@7->utoa::@4#1] -- register_copy + // [159] phi (word) utoa::value#6 = (word) utoa::value#2 [phi:utoa::@7->utoa::@4#2] -- register_copy + jmp __b4 + // utoa::@4 + __b4: + // [160] (byte) utoa::digit#1 ← ++ (byte) utoa::digit#2 -- vbuz1=_inc_vbuz1 + inc.z digit + // [148] phi from utoa::@4 to utoa::@1 [phi:utoa::@4->utoa::@1] + __b1_from___b4: + // [148] phi (byte*) utoa::buffer#11 = (byte*) utoa::buffer#14 [phi:utoa::@4->utoa::@1#0] -- register_copy + // [148] phi (byte) utoa::started#2 = (byte) utoa::started#4 [phi:utoa::@4->utoa::@1#1] -- register_copy + // [148] phi (word) utoa::value#2 = (word) utoa::value#6 [phi:utoa::@4->utoa::@1#2] -- register_copy + // [148] phi (byte) utoa::digit#2 = (byte) utoa::digit#1 [phi:utoa::@4->utoa::@1#3] -- register_copy + jmp __b1 + // utoa::@5 + __b5: + // [161] (byte*) utoa_append::buffer#0 ← (byte*) utoa::buffer#11 -- pbuz1=pbuz2 + lda.z buffer_1 + sta.z utoa_append.buffer + lda.z buffer_1+1 + sta.z utoa_append.buffer+1 + // [162] (word) utoa_append::value#0 ← (word) utoa::value#2 -- vwuz1=vwuz2 + lda.z value + sta.z utoa_append.value + lda.z value+1 + sta.z utoa_append.value+1 + // [163] (word) utoa_append::sub#0 ← (word) utoa::digit_value#0 -- vwuz1=vwuz2 + lda.z digit_value + sta.z utoa_append.sub + lda.z digit_value+1 + sta.z utoa_append.sub+1 + // [164] call utoa_append + // [168] phi from utoa::@5 to utoa_append [phi:utoa::@5->utoa_append] + utoa_append_from___b5: + jsr utoa_append + // [165] (word) utoa_append::return#0 ← (word) utoa_append::value#2 -- vwuz1=vwuz2 + lda.z utoa_append.value + sta.z utoa_append.return + lda.z utoa_append.value+1 + sta.z utoa_append.return+1 + jmp __b6 + // utoa::@6 + __b6: + // [166] (word) utoa::value#0 ← (word) utoa_append::return#0 -- vwuz1=vwuz2 + lda.z utoa_append.return + sta.z value + lda.z utoa_append.return+1 + sta.z value+1 + // [167] (byte*) utoa::buffer#4 ← ++ (byte*) utoa::buffer#11 -- pbuz1=_inc_pbuz1 + inc.z buffer_1 + bne !+ + inc.z buffer_1+1 + !: + // [159] phi from utoa::@6 to utoa::@4 [phi:utoa::@6->utoa::@4] + __b4_from___b6: + // [159] phi (byte*) utoa::buffer#14 = (byte*) utoa::buffer#4 [phi:utoa::@6->utoa::@4#0] -- register_copy + // [159] phi (byte) utoa::started#4 = (byte) 1 [phi:utoa::@6->utoa::@4#1] -- vbuz1=vbuc1 + lda #1 + sta.z started + // [159] phi (word) utoa::value#6 = (word) utoa::value#0 [phi:utoa::@6->utoa::@4#2] -- register_copy + jmp __b4 +} + // utoa_append +// Used to convert a single digit of an unsigned number value to a string representation +// Counts a single digit up from '0' as long as the value is larger than sub. +// Each time the digit is increased sub is subtracted from value. +// - buffer : pointer to the char that receives the digit +// - value : The value where the digit will be derived from +// - sub : the value of a '1' in the digit. Subtracted continually while the digit is increased. +// (For decimal the subs used are 10000, 1000, 100, 10, 1) +// returns : the value reduced by sub * digit so that it is less than sub. +// utoa_append(byte* zp($5c) buffer, word zp($29) value, word zp($5e) sub) +utoa_append: { + .label buffer = $5c + .label value = $29 + .label sub = $5e + .label return = $60 + .label digit = $2b + // [169] phi from utoa_append to utoa_append::@1 [phi:utoa_append->utoa_append::@1] + __b1_from_utoa_append: + // [169] phi (byte) utoa_append::digit#2 = (byte) 0 [phi:utoa_append->utoa_append::@1#0] -- vbuz1=vbuc1 + lda #0 + sta.z digit + // [169] phi (word) utoa_append::value#2 = (word) utoa_append::value#0 [phi:utoa_append->utoa_append::@1#1] -- register_copy + jmp __b1 + // utoa_append::@1 + __b1: + // [170] if((word) utoa_append::value#2>=(word) utoa_append::sub#0) goto utoa_append::@2 -- vwuz1_ge_vwuz2_then_la1 + lda.z sub+1 + cmp.z value+1 + bne !+ + lda.z sub + cmp.z value + beq __b2 + !: + bcc __b2 + jmp __b3 + // utoa_append::@3 + __b3: + // [171] *((byte*) utoa_append::buffer#0) ← *((const byte*) DIGITS + (byte) utoa_append::digit#2) -- _deref_pbuz1=pbuc1_derefidx_vbuz2 + ldy.z digit + lda DIGITS,y + ldy #0 + sta (buffer),y + jmp __breturn + // utoa_append::@return + __breturn: + // [172] return + rts + // utoa_append::@2 + __b2: + // [173] (byte) utoa_append::digit#1 ← ++ (byte) utoa_append::digit#2 -- vbuz1=_inc_vbuz1 + inc.z digit + // [174] (word) utoa_append::value#1 ← (word) utoa_append::value#2 - (word) utoa_append::sub#0 -- vwuz1=vwuz1_minus_vwuz2 + lda.z value + sec + sbc.z sub + sta.z value + lda.z value+1 + sbc.z sub+1 + sta.z value+1 + // [169] phi from utoa_append::@2 to utoa_append::@1 [phi:utoa_append::@2->utoa_append::@1] + __b1_from___b2: + // [169] phi (byte) utoa_append::digit#2 = (byte) utoa_append::digit#1 [phi:utoa_append::@2->utoa_append::@1#0] -- register_copy + // [169] phi (word) utoa_append::value#2 = (word) utoa_append::value#1 [phi:utoa_append::@2->utoa_append::@1#1] -- register_copy + jmp __b1 +} + // gotoxy +// Set the cursor to the specified position +gotoxy: { + .const x = 0 + .const y = 0 + jmp __b1 + // gotoxy::@1 + __b1: + // [176] (byte) conio_cursor_x ← (const byte) gotoxy::x#2 -- vbuz1=vbuc1 + lda #x + sta.z conio_cursor_x + // [177] (byte) conio_cursor_y ← (const byte) gotoxy::y#2 -- vbuz1=vbuc1 + lda #y + sta.z conio_cursor_y + // [178] (byte*) conio_cursor_text ← (const nomodify byte*) CONIO_SCREEN_TEXT -- pbuz1=pbuc1 + lda #CONIO_SCREEN_TEXT + sta.z conio_cursor_text+1 + // [179] (byte*) conio_cursor_color ← (const nomodify byte*) CONIO_SCREEN_COLORS -- pbuz1=pbuc1 + lda #CONIO_SCREEN_COLORS + sta.z conio_cursor_color+1 + jmp __breturn + // gotoxy::@return + __breturn: + // [180] return + rts +} + // File Data + // The digits used for numbers + DIGITS: .text "0123456789abcdef" + // Values of decimal digits + RADIX_DECIMAL_VALUES: .word $2710, $3e8, $64, $a + // Buffer used for stringified number being printed + printf_buffer: .fill SIZEOF_STRUCT_PRINTF_BUFFER_NUMBER, 0 + +REGISTER UPLIFT POTENTIAL REGISTERS +Statement [1] (byte) conio_cursor_x ← (byte) 0 [ printf_buffer ] ( [ printf_buffer ] { } ) always clobbers reg byte a +Statement [2] (byte) conio_cursor_y ← (byte) 0 [ printf_buffer ] ( [ printf_buffer ] { } ) always clobbers reg byte a +Statement [3] (byte*) conio_cursor_text ← (const nomodify byte*) CONIO_SCREEN_TEXT [ printf_buffer ] ( [ printf_buffer ] { } ) always clobbers reg byte a +Statement [4] (byte*) conio_cursor_color ← (const nomodify byte*) CONIO_SCREEN_COLORS [ printf_buffer ] ( [ printf_buffer ] { } ) always clobbers reg byte a +Statement [14] (word) printf_uint::uvalue#0 ← (word) main::count#11 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_uint::uvalue#0 printf_buffer ] ( main:6 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_uint::uvalue#0 printf_buffer ] { { printf_uint::uvalue#0 = main::count#11 } } ) always clobbers reg byte a +Statement [22] (signed byte~) main::$5 ← (signed byte)(byte) main::x#2 << (byte) 1 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::$5 printf_buffer ] ( main:6 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::$5 printf_buffer ] { { mul8s::b#0 = mul8s::b#2 mul8s::a#2 mul8s::a#0 main::xd#0 } } ) always clobbers reg byte a +Removing always clobbered register reg byte a as potential for zp[1]:2 [ main::y#2 main::y#1 ] +Removing always clobbered register reg byte a as potential for zp[1]:7 [ main::x#2 main::x#1 ] +Statement [24] (signed byte~) main::$7 ← (signed byte)(byte) main::y#2 << (byte) 1 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::xd#0 main::$7 printf_buffer ] ( main:6 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::xd#0 main::$7 printf_buffer ] { { mul8s::b#0 = mul8s::b#2 mul8s::a#2 mul8s::a#0 main::xd#0 } } ) always clobbers reg byte a +Removing always clobbered register reg byte a as potential for zp[1]:53 [ main::xd#0 ] +Statement [29] (signed word~) main::$9 ← (signed word)(word) mul8s::m#4 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::yd#0 main::$9 printf_buffer ] ( main:6 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::yd#0 main::$9 printf_buffer ] { { mul8s::b#1 = mul8s::b#2 mul8s::a#2 mul8s::a#1 main::yd#0 } } ) always clobbers reg byte a +Removing always clobbered register reg byte a as potential for zp[1]:55 [ main::yd#0 ] +Statement [33] (signed word~) main::$10 ← (signed word)(word) mul8s::m#4 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::$9 main::$10 printf_buffer ] ( main:6 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::$9 main::$10 printf_buffer ] { } ) always clobbers reg byte a +Statement [34] (signed word) main::dist_sq#0 ← (signed word~) main::$9 + (signed word~) main::$10 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::dist_sq#0 printf_buffer ] ( main:6 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::dist_sq#0 printf_buffer ] { } ) always clobbers reg byte a +Statement [35] if((signed word) main::dist_sq#0>=(signed word)(number) 2*(number) 9*(number) 2*(number) 9) goto main::@6 [ main::y#2 main::count#10 main::sc#10 main::x#2 printf_buffer ] ( main:6 [ main::y#2 main::count#10 main::sc#10 main::x#2 printf_buffer ] { } ) always clobbers reg byte a +Statement [36] *((byte*) main::sc#10) ← (byte) '*' [ main::y#2 main::count#10 main::sc#10 main::x#2 printf_buffer ] ( main:6 [ main::y#2 main::count#10 main::sc#10 main::x#2 printf_buffer ] { } ) always clobbers reg byte a reg byte y +Removing always clobbered register reg byte y as potential for zp[1]:2 [ main::y#2 main::y#1 ] +Removing always clobbered register reg byte y as potential for zp[1]:7 [ main::x#2 main::x#1 ] +Statement [45] (word) mul8u::return#2 ← (word) mul8u::res#2 [ mul8s::a#2 mul8s::b#2 mul8u::return#2 ] ( main:6::mul8s:28 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::yd#0 printf_buffer mul8s::a#2 mul8s::b#2 mul8u::return#2 ] { { mul8s::b#0 = mul8s::b#2 mul8s::a#2 mul8s::a#0 main::xd#0 } { mul8u::return#2 = mul8u::res#2 } } main:6::mul8s:32 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::$9 printf_buffer mul8s::a#2 mul8s::b#2 mul8u::return#2 ] { { mul8s::b#1 = mul8s::b#2 mul8s::a#2 mul8s::a#1 main::yd#0 } { mul8u::return#2 = mul8u::res#2 } } ) always clobbers reg byte a +Removing always clobbered register reg byte a as potential for zp[1]:8 [ mul8s::a#2 mul8s::a#1 mul8s::a#0 ] +Removing always clobbered register reg byte a as potential for zp[1]:9 [ mul8s::b#2 mul8s::b#1 mul8s::b#0 ] +Statement [46] (word) mul8s::m#0 ← (word) mul8u::return#2 [ mul8s::a#2 mul8s::b#2 mul8s::m#0 ] ( main:6::mul8s:28 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::yd#0 printf_buffer mul8s::a#2 mul8s::b#2 mul8s::m#0 ] { { mul8s::b#0 = mul8s::b#2 mul8s::a#2 mul8s::a#0 main::xd#0 } } main:6::mul8s:32 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::$9 printf_buffer mul8s::a#2 mul8s::b#2 mul8s::m#0 ] { { mul8s::b#1 = mul8s::b#2 mul8s::a#2 mul8s::a#1 main::yd#0 } } ) always clobbers reg byte a +Statement [49] (byte~) mul8s::$11 ← (byte~) mul8s::$6 - (byte)(signed byte) mul8s::b#2 [ mul8s::a#2 mul8s::b#2 mul8s::m#0 mul8s::$11 ] ( main:6::mul8s:28 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::yd#0 printf_buffer mul8s::a#2 mul8s::b#2 mul8s::m#0 mul8s::$11 ] { { mul8s::b#0 = mul8s::b#2 mul8s::a#2 mul8s::a#0 main::xd#0 } } main:6::mul8s:32 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::$9 printf_buffer mul8s::a#2 mul8s::b#2 mul8s::m#0 mul8s::$11 ] { { mul8s::b#1 = mul8s::b#2 mul8s::a#2 mul8s::a#1 main::yd#0 } } ) always clobbers reg byte a +Statement [54] (byte~) mul8s::$12 ← (byte~) mul8s::$9 - (byte)(signed byte) mul8s::a#2 [ mul8s::m#5 mul8s::$12 ] ( main:6::mul8s:28 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::yd#0 printf_buffer mul8s::m#5 mul8s::$12 ] { { mul8s::b#0 = mul8s::b#2 mul8s::a#2 mul8s::a#0 main::xd#0 } } main:6::mul8s:32 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::$9 printf_buffer mul8s::m#5 mul8s::$12 ] { { mul8s::b#1 = mul8s::b#2 mul8s::a#2 mul8s::a#1 main::yd#0 } } ) always clobbers reg byte a +Statement [58] (word) mul8u::mb#0 ← (word)(byte) mul8u::b#0 [ mul8u::a#1 mul8u::mb#0 ] ( main:6::mul8s:28::mul8u:44 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::yd#0 printf_buffer mul8s::a#2 mul8s::b#2 mul8u::a#1 mul8u::mb#0 ] { { mul8s::b#0 = mul8s::b#2 mul8s::a#2 mul8s::a#0 main::xd#0 } { mul8u::return#2 = mul8u::res#2 } } main:6::mul8s:32::mul8u:44 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::$9 printf_buffer mul8s::a#2 mul8s::b#2 mul8u::a#1 mul8u::mb#0 ] { { mul8s::b#1 = mul8s::b#2 mul8s::a#2 mul8s::a#1 main::yd#0 } { mul8u::return#2 = mul8u::res#2 } } ) always clobbers reg byte a +Removing always clobbered register reg byte a as potential for zp[1]:12 [ mul8u::a#2 mul8u::a#1 mul8u::a#0 ] +Statement [62] (byte~) mul8u::$1 ← (byte) mul8u::a#2 & (byte) 1 [ mul8u::res#2 mul8u::a#2 mul8u::mb#2 mul8u::$1 ] ( main:6::mul8s:28::mul8u:44 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::yd#0 printf_buffer mul8s::a#2 mul8s::b#2 mul8u::res#2 mul8u::a#2 mul8u::mb#2 mul8u::$1 ] { { mul8s::b#0 = mul8s::b#2 mul8s::a#2 mul8s::a#0 main::xd#0 } { mul8u::return#2 = mul8u::res#2 } } main:6::mul8s:32::mul8u:44 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::$9 printf_buffer mul8s::a#2 mul8s::b#2 mul8u::res#2 mul8u::a#2 mul8u::mb#2 mul8u::$1 ] { { mul8s::b#1 = mul8s::b#2 mul8s::a#2 mul8s::a#1 main::yd#0 } { mul8u::return#2 = mul8u::res#2 } } ) always clobbers reg byte a +Statement [64] (word) mul8u::res#1 ← (word) mul8u::res#2 + (word) mul8u::mb#2 [ mul8u::a#2 mul8u::mb#2 mul8u::res#1 ] ( main:6::mul8s:28::mul8u:44 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::yd#0 printf_buffer mul8s::a#2 mul8s::b#2 mul8u::a#2 mul8u::mb#2 mul8u::res#1 ] { { mul8s::b#0 = mul8s::b#2 mul8s::a#2 mul8s::a#0 main::xd#0 } { mul8u::return#2 = mul8u::res#2 } } main:6::mul8s:32::mul8u:44 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::$9 printf_buffer mul8s::a#2 mul8s::b#2 mul8u::a#2 mul8u::mb#2 mul8u::res#1 ] { { mul8s::b#1 = mul8s::b#2 mul8s::a#2 mul8s::a#1 main::yd#0 } { mul8u::return#2 = mul8u::res#2 } } ) always clobbers reg byte a +Statement [70] (byte) cputs::c#1 ← *((to_nomodify byte*) cputs::s#3) [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color cputs::s#3 cputs::c#1 ] ( main:6::cputs:17 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color cputs::s#3 cputs::c#1 ] { } main:6::printf_uint:15::printf_number_buffer:138::cputs:145 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color cputs::s#3 cputs::c#1 ] { { printf_uint::uvalue#0 = main::count#11 } } ) always clobbers reg byte a reg byte y +Statement [78] *((byte*) conio_cursor_text) ← (byte) cputc::c#3 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] ( main:6::cputs:17::cputc:75 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte y +Statement [80] *((byte*) conio_cursor_color) ← (const nomodify byte) CONIO_TEXTCOLOR_DEFAULT [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] ( main:6::cputs:17::cputc:75 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a reg byte y +Statement [83] if((byte) conio_cursor_x!=(byte) $28) goto cputc::@return [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] ( main:6::cputs:17::cputc:75 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [84] (byte) conio_cursor_x ← (byte) 0 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] ( main:6::cputs:17::cputc:75 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [90] (word) cputln::ln_offset#0 ← (byte) $28 - (byte) conio_cursor_x [ conio_cursor_y conio_cursor_text conio_cursor_color cputln::ln_offset#0 ] ( main:6::cputs:17::cputc:75::cputln:89 [ cputs::s#0 conio_cursor_y conio_cursor_text conio_cursor_color cputln::ln_offset#0 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89 [ cputs::s#0 conio_cursor_y conio_cursor_text conio_cursor_color cputln::ln_offset#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89 [ conio_cursor_y conio_cursor_text conio_cursor_color cputln::ln_offset#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [91] (byte*~) cputln::$1 ← (byte*) conio_cursor_text + (word) cputln::ln_offset#0 [ conio_cursor_y conio_cursor_color cputln::ln_offset#0 cputln::$1 ] ( main:6::cputs:17::cputc:75::cputln:89 [ cputs::s#0 conio_cursor_y conio_cursor_color cputln::ln_offset#0 cputln::$1 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89 [ cputs::s#0 conio_cursor_y conio_cursor_color cputln::ln_offset#0 cputln::$1 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89 [ conio_cursor_y conio_cursor_color cputln::ln_offset#0 cputln::$1 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [92] (byte*) conio_cursor_text ← (byte*~) cputln::$1 [ conio_cursor_y conio_cursor_text conio_cursor_color cputln::ln_offset#0 ] ( main:6::cputs:17::cputc:75::cputln:89 [ cputs::s#0 conio_cursor_y conio_cursor_text conio_cursor_color cputln::ln_offset#0 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89 [ cputs::s#0 conio_cursor_y conio_cursor_text conio_cursor_color cputln::ln_offset#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89 [ conio_cursor_y conio_cursor_text conio_cursor_color cputln::ln_offset#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [93] (byte*~) cputln::$2 ← (byte*) conio_cursor_color + (word) cputln::ln_offset#0 [ conio_cursor_y conio_cursor_text cputln::$2 ] ( main:6::cputs:17::cputc:75::cputln:89 [ cputs::s#0 conio_cursor_y conio_cursor_text cputln::$2 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89 [ cputs::s#0 conio_cursor_y conio_cursor_text cputln::$2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89 [ conio_cursor_y conio_cursor_text cputln::$2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [94] (byte*) conio_cursor_color ← (byte*~) cputln::$2 [ conio_cursor_y conio_cursor_text conio_cursor_color ] ( main:6::cputs:17::cputc:75::cputln:89 [ cputs::s#0 conio_cursor_y conio_cursor_text conio_cursor_color ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89 [ cputs::s#0 conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89 [ conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [95] (byte) conio_cursor_x ← (byte) 0 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] ( main:6::cputs:17::cputc:75::cputln:89 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [99] if((byte) conio_cursor_y!=(byte) $19) goto cscroll::@return [ conio_cursor_y conio_cursor_text conio_cursor_color ] ( main:6::cputs:17::cputc:75::cscroll:86 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [108] (byte*~) cscroll::$7 ← (byte*) conio_cursor_text - (byte) $28 [ conio_cursor_y conio_cursor_color cscroll::$7 ] ( main:6::cputs:17::cputc:75::cscroll:86 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_color cscroll::$7 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_color cscroll::$7 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86 [ conio_cursor_x conio_cursor_y conio_cursor_color cscroll::$7 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_color cscroll::$7 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_color cscroll::$7 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97 [ conio_cursor_x conio_cursor_y conio_cursor_color cscroll::$7 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [109] (byte*) conio_cursor_text ← (byte*~) cscroll::$7 [ conio_cursor_y conio_cursor_text conio_cursor_color ] ( main:6::cputs:17::cputc:75::cscroll:86 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [110] (byte*~) cscroll::$8 ← (byte*) conio_cursor_color - (byte) $28 [ conio_cursor_y conio_cursor_text cscroll::$8 ] ( main:6::cputs:17::cputc:75::cscroll:86 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text cscroll::$8 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text cscroll::$8 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86 [ conio_cursor_x conio_cursor_y conio_cursor_text cscroll::$8 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text cscroll::$8 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text cscroll::$8 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97 [ conio_cursor_x conio_cursor_y conio_cursor_text cscroll::$8 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [111] (byte*) conio_cursor_color ← (byte*~) cscroll::$8 [ conio_cursor_y conio_cursor_text conio_cursor_color ] ( main:6::cputs:17::cputc:75::cscroll:86 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [115] if((word) memset::num#3<=(byte) 0) goto memset::@return [ memset::num#3 memset::str#4 memset::c#5 ] ( main:6::memset:9 [ printf_buffer memset::num#3 memset::str#4 memset::c#5 ] { } main:6::cputs:17::cputc:75::cscroll:86::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::num#3 memset::str#4 memset::c#5 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::num#3 memset::str#4 memset::c#5 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memset:105 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::num#3 memset::str#4 memset::c#5 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::num#3 memset::str#4 memset::c#5 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::num#3 memset::str#4 memset::c#5 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memset:105 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::num#3 memset::str#4 memset::c#5 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cscroll:86::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::num#3 memset::str#4 memset::c#5 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::num#3 memset::str#4 memset::c#5 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memset:107 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::num#3 memset::str#4 memset::c#5 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::num#3 memset::str#4 memset::c#5 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::num#3 memset::str#4 memset::c#5 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memset:107 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::num#3 memset::str#4 memset::c#5 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Removing always clobbered register reg byte a as potential for zp[1]:24 [ memset::c#5 ] +Statement [116] (byte*) memset::end#0 ← (byte*)(void*) memset::str#4 + (word) memset::num#3 [ memset::str#4 memset::c#5 memset::end#0 ] ( main:6::memset:9 [ printf_buffer memset::str#4 memset::c#5 memset::end#0 ] { } main:6::cputs:17::cputc:75::cscroll:86::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::str#4 memset::c#5 memset::end#0 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::str#4 memset::c#5 memset::end#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memset:105 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::str#4 memset::c#5 memset::end#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::str#4 memset::c#5 memset::end#0 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::str#4 memset::c#5 memset::end#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memset:105 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::str#4 memset::c#5 memset::end#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cscroll:86::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::str#4 memset::c#5 memset::end#0 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::str#4 memset::c#5 memset::end#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memset:107 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::str#4 memset::c#5 memset::end#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::str#4 memset::c#5 memset::end#0 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::str#4 memset::c#5 memset::end#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memset:107 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::str#4 memset::c#5 memset::end#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [117] (byte*) memset::dst#4 ← (byte*)(void*) memset::str#4 [ memset::c#5 memset::end#0 memset::dst#4 ] ( main:6::memset:9 [ printf_buffer memset::c#5 memset::end#0 memset::dst#4 ] { } main:6::cputs:17::cputc:75::cscroll:86::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#4 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memset:105 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#4 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memset:105 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cscroll:86::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#4 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memset:107 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#4 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memset:107 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [119] if((byte*) memset::dst#2!=(byte*) memset::end#0) goto memset::@3 [ memset::c#5 memset::end#0 memset::dst#2 ] ( main:6::memset:9 [ printf_buffer memset::c#5 memset::end#0 memset::dst#2 ] { } main:6::cputs:17::cputc:75::cscroll:86::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memset:105 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memset:105 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cscroll:86::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memset:107 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memset:107 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [121] *((byte*) memset::dst#2) ← (byte) memset::c#5 [ memset::c#5 memset::end#0 memset::dst#2 ] ( main:6::memset:9 [ printf_buffer memset::c#5 memset::end#0 memset::dst#2 ] { } main:6::cputs:17::cputc:75::cscroll:86::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memset:105 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memset:105 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cscroll:86::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memset:107 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memset:107 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a reg byte y +Removing always clobbered register reg byte y as potential for zp[1]:24 [ memset::c#5 ] +Statement [124] (byte*) memcpy::src_end#0 ← (byte*)(void*) memcpy::source#2 + (word)(number) $19*(number) $28-(number) $28 [ memcpy::source#2 memcpy::destination#2 memcpy::src_end#0 ] ( main:6::cputs:17::cputc:75::cscroll:86::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::source#2 memcpy::destination#2 memcpy::src_end#0 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::source#2 memcpy::destination#2 memcpy::src_end#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memcpy:101 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::source#2 memcpy::destination#2 memcpy::src_end#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::source#2 memcpy::destination#2 memcpy::src_end#0 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::source#2 memcpy::destination#2 memcpy::src_end#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memcpy:101 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::source#2 memcpy::destination#2 memcpy::src_end#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cscroll:86::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::source#2 memcpy::destination#2 memcpy::src_end#0 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::source#2 memcpy::destination#2 memcpy::src_end#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memcpy:103 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::source#2 memcpy::destination#2 memcpy::src_end#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::source#2 memcpy::destination#2 memcpy::src_end#0 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::source#2 memcpy::destination#2 memcpy::src_end#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memcpy:103 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::source#2 memcpy::destination#2 memcpy::src_end#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [125] (byte*) memcpy::src#4 ← (byte*)(void*) memcpy::source#2 [ memcpy::destination#2 memcpy::src_end#0 memcpy::src#4 ] ( main:6::cputs:17::cputc:75::cscroll:86::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::destination#2 memcpy::src_end#0 memcpy::src#4 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::destination#2 memcpy::src_end#0 memcpy::src#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memcpy:101 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::destination#2 memcpy::src_end#0 memcpy::src#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::destination#2 memcpy::src_end#0 memcpy::src#4 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::destination#2 memcpy::src_end#0 memcpy::src#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memcpy:101 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::destination#2 memcpy::src_end#0 memcpy::src#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cscroll:86::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::destination#2 memcpy::src_end#0 memcpy::src#4 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::destination#2 memcpy::src_end#0 memcpy::src#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memcpy:103 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::destination#2 memcpy::src_end#0 memcpy::src#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::destination#2 memcpy::src_end#0 memcpy::src#4 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::destination#2 memcpy::src_end#0 memcpy::src#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memcpy:103 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::destination#2 memcpy::src_end#0 memcpy::src#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [126] (byte*) memcpy::dst#4 ← (byte*)(void*) memcpy::destination#2 [ memcpy::src_end#0 memcpy::src#4 memcpy::dst#4 ] ( main:6::cputs:17::cputc:75::cscroll:86::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#4 memcpy::dst#4 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#4 memcpy::dst#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memcpy:101 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#4 memcpy::dst#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#4 memcpy::dst#4 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#4 memcpy::dst#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memcpy:101 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#4 memcpy::dst#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cscroll:86::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#4 memcpy::dst#4 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#4 memcpy::dst#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memcpy:103 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#4 memcpy::dst#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#4 memcpy::dst#4 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#4 memcpy::dst#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memcpy:103 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#4 memcpy::dst#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [128] if((byte*) memcpy::src#2!=(byte*) memcpy::src_end#0) goto memcpy::@2 [ memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] ( main:6::cputs:17::cputc:75::cscroll:86::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memcpy:101 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memcpy:101 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cscroll:86::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memcpy:103 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memcpy:103 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [130] *((byte*) memcpy::dst#2) ← *((byte*) memcpy::src#2) [ memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] ( main:6::cputs:17::cputc:75::cscroll:86::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memcpy:101 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memcpy:101 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cscroll:86::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memcpy:103 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memcpy:103 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a reg byte y +Statement [134] *((byte*)&(struct printf_buffer_number) printf_buffer) ← (byte) 0 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_uint::uvalue#0 printf_buffer ] ( main:6::printf_uint:15 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_uint::uvalue#0 printf_buffer ] { { printf_uint::uvalue#0 = main::count#11 utoa::value#1 } } ) always clobbers reg byte a +Statement [135] (word) utoa::value#1 ← (word) printf_uint::uvalue#0 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_buffer utoa::value#1 ] ( main:6::printf_uint:15 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_buffer utoa::value#1 ] { { printf_uint::uvalue#0 = main::count#11 utoa::value#1 } } ) always clobbers reg byte a +Statement [150] (byte~) utoa::$11 ← (byte)(word) utoa::value#2 [ printf_buffer utoa::buffer#11 utoa::$11 ] ( main:6::printf_uint:15::utoa:136 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_buffer utoa::buffer#11 utoa::$11 ] { { printf_uint::uvalue#0 = main::count#11 utoa::value#1 } } ) always clobbers reg byte a +Statement [151] *((byte*) utoa::buffer#11) ← *((const byte*) DIGITS + (byte~) utoa::$11) [ printf_buffer utoa::buffer#11 ] ( main:6::printf_uint:15::utoa:136 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_buffer utoa::buffer#11 ] { { printf_uint::uvalue#0 = main::count#11 utoa::value#1 } } ) always clobbers reg byte a reg byte y +Statement [152] (byte*) utoa::buffer#3 ← ++ (byte*) utoa::buffer#11 [ printf_buffer utoa::buffer#3 ] ( main:6::printf_uint:15::utoa:136 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_buffer utoa::buffer#3 ] { { printf_uint::uvalue#0 = main::count#11 utoa::value#1 } } ) always clobbers reg byte a +Statement [153] *((byte*) utoa::buffer#3) ← (byte) 0 [ printf_buffer ] ( main:6::printf_uint:15::utoa:136 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_buffer ] { { printf_uint::uvalue#0 = main::count#11 utoa::value#1 } } ) always clobbers reg byte a reg byte y +Statement [155] (byte~) utoa::$10 ← (byte) utoa::digit#2 << (byte) 1 [ printf_buffer utoa::digit#2 utoa::value#2 utoa::started#2 utoa::buffer#11 utoa::$10 ] ( main:6::printf_uint:15::utoa:136 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_buffer utoa::digit#2 utoa::value#2 utoa::started#2 utoa::buffer#11 utoa::$10 ] { { printf_uint::uvalue#0 = main::count#11 utoa::value#1 } } ) always clobbers reg byte a +Removing always clobbered register reg byte a as potential for zp[1]:35 [ utoa::digit#2 utoa::digit#1 ] +Removing always clobbered register reg byte a as potential for zp[1]:38 [ utoa::started#2 utoa::started#4 ] +Statement [156] (word) utoa::digit_value#0 ← *((const word*) RADIX_DECIMAL_VALUES + (byte~) utoa::$10) [ printf_buffer utoa::digit#2 utoa::value#2 utoa::started#2 utoa::buffer#11 utoa::digit_value#0 ] ( main:6::printf_uint:15::utoa:136 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_buffer utoa::digit#2 utoa::value#2 utoa::started#2 utoa::buffer#11 utoa::digit_value#0 ] { { printf_uint::uvalue#0 = main::count#11 utoa::value#1 } } ) always clobbers reg byte a +Statement [158] if((word) utoa::value#2>=(word) utoa::digit_value#0) goto utoa::@5 [ printf_buffer utoa::digit#2 utoa::value#2 utoa::started#2 utoa::buffer#11 utoa::digit_value#0 ] ( main:6::printf_uint:15::utoa:136 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_buffer utoa::digit#2 utoa::value#2 utoa::started#2 utoa::buffer#11 utoa::digit_value#0 ] { { printf_uint::uvalue#0 = main::count#11 utoa::value#1 } } ) always clobbers reg byte a +Statement [161] (byte*) utoa_append::buffer#0 ← (byte*) utoa::buffer#11 [ printf_buffer utoa::digit#2 utoa::value#2 utoa::buffer#11 utoa::digit_value#0 utoa_append::buffer#0 ] ( main:6::printf_uint:15::utoa:136 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_buffer utoa::digit#2 utoa::value#2 utoa::buffer#11 utoa::digit_value#0 utoa_append::buffer#0 ] { { printf_uint::uvalue#0 = main::count#11 utoa::value#1 } { utoa_append::buffer#0 = utoa::buffer#11 } { utoa_append::value#0 = utoa::value#2 } { utoa_append::sub#0 = utoa::digit_value#0 } { utoa_append::return#0 = utoa_append::value#2 } } ) always clobbers reg byte a +Statement [162] (word) utoa_append::value#0 ← (word) utoa::value#2 [ printf_buffer utoa::digit#2 utoa::buffer#11 utoa::digit_value#0 utoa_append::buffer#0 utoa_append::value#0 ] ( main:6::printf_uint:15::utoa:136 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_buffer utoa::digit#2 utoa::buffer#11 utoa::digit_value#0 utoa_append::buffer#0 utoa_append::value#0 ] { { printf_uint::uvalue#0 = main::count#11 utoa::value#1 } { utoa_append::buffer#0 = utoa::buffer#11 } { utoa_append::value#0 = utoa::value#2 } { utoa_append::sub#0 = utoa::digit_value#0 } { utoa_append::return#0 = utoa_append::value#2 } } ) always clobbers reg byte a +Statement [163] (word) utoa_append::sub#0 ← (word) utoa::digit_value#0 [ printf_buffer utoa::digit#2 utoa::buffer#11 utoa_append::buffer#0 utoa_append::value#0 utoa_append::sub#0 ] ( main:6::printf_uint:15::utoa:136 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_buffer utoa::digit#2 utoa::buffer#11 utoa_append::buffer#0 utoa_append::value#0 utoa_append::sub#0 ] { { printf_uint::uvalue#0 = main::count#11 utoa::value#1 } { utoa_append::buffer#0 = utoa::buffer#11 } { utoa_append::value#0 = utoa::value#2 } { utoa_append::sub#0 = utoa::digit_value#0 } { utoa_append::return#0 = utoa_append::value#2 } } ) always clobbers reg byte a +Statement [165] (word) utoa_append::return#0 ← (word) utoa_append::value#2 [ printf_buffer utoa::digit#2 utoa::buffer#11 utoa_append::return#0 ] ( main:6::printf_uint:15::utoa:136 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_buffer utoa::digit#2 utoa::buffer#11 utoa_append::return#0 ] { { printf_uint::uvalue#0 = main::count#11 utoa::value#1 } { utoa_append::buffer#0 = utoa::buffer#11 } { utoa_append::value#0 = utoa::value#2 } { utoa_append::sub#0 = utoa::digit_value#0 } { utoa_append::return#0 = utoa_append::value#2 } } ) always clobbers reg byte a +Statement [166] (word) utoa::value#0 ← (word) utoa_append::return#0 [ printf_buffer utoa::digit#2 utoa::buffer#11 utoa::value#0 ] ( main:6::printf_uint:15::utoa:136 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_buffer utoa::digit#2 utoa::buffer#11 utoa::value#0 ] { { printf_uint::uvalue#0 = main::count#11 utoa::value#1 } } ) always clobbers reg byte a +Statement [170] if((word) utoa_append::value#2>=(word) utoa_append::sub#0) goto utoa_append::@2 [ utoa_append::buffer#0 utoa_append::sub#0 utoa_append::value#2 utoa_append::digit#2 ] ( main:6::printf_uint:15::utoa:136::utoa_append:164 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_buffer utoa::digit#2 utoa::buffer#11 utoa_append::buffer#0 utoa_append::sub#0 utoa_append::value#2 utoa_append::digit#2 ] { { printf_uint::uvalue#0 = main::count#11 utoa::value#1 } { utoa_append::buffer#0 = utoa::buffer#11 } { utoa_append::value#0 = utoa::value#2 } { utoa_append::sub#0 = utoa::digit_value#0 } { utoa_append::return#0 = utoa_append::value#2 } } ) always clobbers reg byte a +Removing always clobbered register reg byte a as potential for zp[1]:43 [ utoa_append::digit#2 utoa_append::digit#1 ] +Statement [171] *((byte*) utoa_append::buffer#0) ← *((const byte*) DIGITS + (byte) utoa_append::digit#2) [ utoa_append::value#2 ] ( main:6::printf_uint:15::utoa:136::utoa_append:164 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_buffer utoa::digit#2 utoa::buffer#11 utoa_append::value#2 ] { { printf_uint::uvalue#0 = main::count#11 utoa::value#1 } { utoa_append::buffer#0 = utoa::buffer#11 } { utoa_append::value#0 = utoa::value#2 } { utoa_append::sub#0 = utoa::digit_value#0 } { utoa_append::return#0 = utoa_append::value#2 } } ) always clobbers reg byte a reg byte y +Removing always clobbered register reg byte y as potential for zp[1]:35 [ utoa::digit#2 utoa::digit#1 ] +Statement [174] (word) utoa_append::value#1 ← (word) utoa_append::value#2 - (word) utoa_append::sub#0 [ utoa_append::buffer#0 utoa_append::sub#0 utoa_append::value#1 utoa_append::digit#1 ] ( main:6::printf_uint:15::utoa:136::utoa_append:164 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_buffer utoa::digit#2 utoa::buffer#11 utoa_append::buffer#0 utoa_append::sub#0 utoa_append::value#1 utoa_append::digit#1 ] { { printf_uint::uvalue#0 = main::count#11 utoa::value#1 } { utoa_append::buffer#0 = utoa::buffer#11 } { utoa_append::value#0 = utoa::value#2 } { utoa_append::sub#0 = utoa::digit_value#0 } { utoa_append::return#0 = utoa_append::value#2 } } ) always clobbers reg byte a +Statement [176] (byte) conio_cursor_x ← (const byte) gotoxy::x#2 [ conio_cursor_x ] ( main:6::gotoxy:13 [ main::count#11 printf_buffer conio_cursor_x ] { } ) always clobbers reg byte a +Statement [177] (byte) conio_cursor_y ← (const byte) gotoxy::y#2 [ conio_cursor_x conio_cursor_y ] ( main:6::gotoxy:13 [ main::count#11 printf_buffer conio_cursor_x conio_cursor_y ] { } ) always clobbers reg byte a +Statement [178] (byte*) conio_cursor_text ← (const nomodify byte*) CONIO_SCREEN_TEXT [ conio_cursor_x conio_cursor_y conio_cursor_text ] ( main:6::gotoxy:13 [ main::count#11 printf_buffer conio_cursor_x conio_cursor_y conio_cursor_text ] { } ) always clobbers reg byte a +Statement [179] (byte*) conio_cursor_color ← (const nomodify byte*) CONIO_SCREEN_COLORS [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] ( main:6::gotoxy:13 [ main::count#11 printf_buffer conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { } ) always clobbers reg byte a +Statement [1] (byte) conio_cursor_x ← (byte) 0 [ printf_buffer ] ( [ printf_buffer ] { } ) always clobbers reg byte a +Statement [2] (byte) conio_cursor_y ← (byte) 0 [ printf_buffer ] ( [ printf_buffer ] { } ) always clobbers reg byte a +Statement [3] (byte*) conio_cursor_text ← (const nomodify byte*) CONIO_SCREEN_TEXT [ printf_buffer ] ( [ printf_buffer ] { } ) always clobbers reg byte a +Statement [4] (byte*) conio_cursor_color ← (const nomodify byte*) CONIO_SCREEN_COLORS [ printf_buffer ] ( [ printf_buffer ] { } ) always clobbers reg byte a +Statement [14] (word) printf_uint::uvalue#0 ← (word) main::count#11 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_uint::uvalue#0 printf_buffer ] ( main:6 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_uint::uvalue#0 printf_buffer ] { { printf_uint::uvalue#0 = main::count#11 } } ) always clobbers reg byte a +Statement [22] (signed byte~) main::$5 ← (signed byte)(byte) main::x#2 << (byte) 1 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::$5 printf_buffer ] ( main:6 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::$5 printf_buffer ] { { mul8s::b#0 = mul8s::b#2 mul8s::a#2 mul8s::a#0 main::xd#0 } } ) always clobbers reg byte a +Statement [24] (signed byte~) main::$7 ← (signed byte)(byte) main::y#2 << (byte) 1 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::xd#0 main::$7 printf_buffer ] ( main:6 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::xd#0 main::$7 printf_buffer ] { { mul8s::b#0 = mul8s::b#2 mul8s::a#2 mul8s::a#0 main::xd#0 } } ) always clobbers reg byte a +Statement [29] (signed word~) main::$9 ← (signed word)(word) mul8s::m#4 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::yd#0 main::$9 printf_buffer ] ( main:6 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::yd#0 main::$9 printf_buffer ] { { mul8s::b#1 = mul8s::b#2 mul8s::a#2 mul8s::a#1 main::yd#0 } } ) always clobbers reg byte a +Statement [33] (signed word~) main::$10 ← (signed word)(word) mul8s::m#4 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::$9 main::$10 printf_buffer ] ( main:6 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::$9 main::$10 printf_buffer ] { } ) always clobbers reg byte a +Statement [34] (signed word) main::dist_sq#0 ← (signed word~) main::$9 + (signed word~) main::$10 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::dist_sq#0 printf_buffer ] ( main:6 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::dist_sq#0 printf_buffer ] { } ) always clobbers reg byte a +Statement [35] if((signed word) main::dist_sq#0>=(signed word)(number) 2*(number) 9*(number) 2*(number) 9) goto main::@6 [ main::y#2 main::count#10 main::sc#10 main::x#2 printf_buffer ] ( main:6 [ main::y#2 main::count#10 main::sc#10 main::x#2 printf_buffer ] { } ) always clobbers reg byte a +Statement [36] *((byte*) main::sc#10) ← (byte) '*' [ main::y#2 main::count#10 main::sc#10 main::x#2 printf_buffer ] ( main:6 [ main::y#2 main::count#10 main::sc#10 main::x#2 printf_buffer ] { } ) always clobbers reg byte a reg byte y +Statement [45] (word) mul8u::return#2 ← (word) mul8u::res#2 [ mul8s::a#2 mul8s::b#2 mul8u::return#2 ] ( main:6::mul8s:28 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::yd#0 printf_buffer mul8s::a#2 mul8s::b#2 mul8u::return#2 ] { { mul8s::b#0 = mul8s::b#2 mul8s::a#2 mul8s::a#0 main::xd#0 } { mul8u::return#2 = mul8u::res#2 } } main:6::mul8s:32 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::$9 printf_buffer mul8s::a#2 mul8s::b#2 mul8u::return#2 ] { { mul8s::b#1 = mul8s::b#2 mul8s::a#2 mul8s::a#1 main::yd#0 } { mul8u::return#2 = mul8u::res#2 } } ) always clobbers reg byte a +Statement [46] (word) mul8s::m#0 ← (word) mul8u::return#2 [ mul8s::a#2 mul8s::b#2 mul8s::m#0 ] ( main:6::mul8s:28 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::yd#0 printf_buffer mul8s::a#2 mul8s::b#2 mul8s::m#0 ] { { mul8s::b#0 = mul8s::b#2 mul8s::a#2 mul8s::a#0 main::xd#0 } } main:6::mul8s:32 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::$9 printf_buffer mul8s::a#2 mul8s::b#2 mul8s::m#0 ] { { mul8s::b#1 = mul8s::b#2 mul8s::a#2 mul8s::a#1 main::yd#0 } } ) always clobbers reg byte a +Statement [49] (byte~) mul8s::$11 ← (byte~) mul8s::$6 - (byte)(signed byte) mul8s::b#2 [ mul8s::a#2 mul8s::b#2 mul8s::m#0 mul8s::$11 ] ( main:6::mul8s:28 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::yd#0 printf_buffer mul8s::a#2 mul8s::b#2 mul8s::m#0 mul8s::$11 ] { { mul8s::b#0 = mul8s::b#2 mul8s::a#2 mul8s::a#0 main::xd#0 } } main:6::mul8s:32 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::$9 printf_buffer mul8s::a#2 mul8s::b#2 mul8s::m#0 mul8s::$11 ] { { mul8s::b#1 = mul8s::b#2 mul8s::a#2 mul8s::a#1 main::yd#0 } } ) always clobbers reg byte a +Statement [54] (byte~) mul8s::$12 ← (byte~) mul8s::$9 - (byte)(signed byte) mul8s::a#2 [ mul8s::m#5 mul8s::$12 ] ( main:6::mul8s:28 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::yd#0 printf_buffer mul8s::m#5 mul8s::$12 ] { { mul8s::b#0 = mul8s::b#2 mul8s::a#2 mul8s::a#0 main::xd#0 } } main:6::mul8s:32 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::$9 printf_buffer mul8s::m#5 mul8s::$12 ] { { mul8s::b#1 = mul8s::b#2 mul8s::a#2 mul8s::a#1 main::yd#0 } } ) always clobbers reg byte a +Statement [58] (word) mul8u::mb#0 ← (word)(byte) mul8u::b#0 [ mul8u::a#1 mul8u::mb#0 ] ( main:6::mul8s:28::mul8u:44 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::yd#0 printf_buffer mul8s::a#2 mul8s::b#2 mul8u::a#1 mul8u::mb#0 ] { { mul8s::b#0 = mul8s::b#2 mul8s::a#2 mul8s::a#0 main::xd#0 } { mul8u::return#2 = mul8u::res#2 } } main:6::mul8s:32::mul8u:44 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::$9 printf_buffer mul8s::a#2 mul8s::b#2 mul8u::a#1 mul8u::mb#0 ] { { mul8s::b#1 = mul8s::b#2 mul8s::a#2 mul8s::a#1 main::yd#0 } { mul8u::return#2 = mul8u::res#2 } } ) always clobbers reg byte a +Statement [62] (byte~) mul8u::$1 ← (byte) mul8u::a#2 & (byte) 1 [ mul8u::res#2 mul8u::a#2 mul8u::mb#2 mul8u::$1 ] ( main:6::mul8s:28::mul8u:44 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::yd#0 printf_buffer mul8s::a#2 mul8s::b#2 mul8u::res#2 mul8u::a#2 mul8u::mb#2 mul8u::$1 ] { { mul8s::b#0 = mul8s::b#2 mul8s::a#2 mul8s::a#0 main::xd#0 } { mul8u::return#2 = mul8u::res#2 } } main:6::mul8s:32::mul8u:44 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::$9 printf_buffer mul8s::a#2 mul8s::b#2 mul8u::res#2 mul8u::a#2 mul8u::mb#2 mul8u::$1 ] { { mul8s::b#1 = mul8s::b#2 mul8s::a#2 mul8s::a#1 main::yd#0 } { mul8u::return#2 = mul8u::res#2 } } ) always clobbers reg byte a +Statement [64] (word) mul8u::res#1 ← (word) mul8u::res#2 + (word) mul8u::mb#2 [ mul8u::a#2 mul8u::mb#2 mul8u::res#1 ] ( main:6::mul8s:28::mul8u:44 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::yd#0 printf_buffer mul8s::a#2 mul8s::b#2 mul8u::a#2 mul8u::mb#2 mul8u::res#1 ] { { mul8s::b#0 = mul8s::b#2 mul8s::a#2 mul8s::a#0 main::xd#0 } { mul8u::return#2 = mul8u::res#2 } } main:6::mul8s:32::mul8u:44 [ main::y#2 main::count#10 main::sc#10 main::x#2 main::$9 printf_buffer mul8s::a#2 mul8s::b#2 mul8u::a#2 mul8u::mb#2 mul8u::res#1 ] { { mul8s::b#1 = mul8s::b#2 mul8s::a#2 mul8s::a#1 main::yd#0 } { mul8u::return#2 = mul8u::res#2 } } ) always clobbers reg byte a +Statement [70] (byte) cputs::c#1 ← *((to_nomodify byte*) cputs::s#3) [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color cputs::s#3 cputs::c#1 ] ( main:6::cputs:17 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color cputs::s#3 cputs::c#1 ] { } main:6::printf_uint:15::printf_number_buffer:138::cputs:145 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color cputs::s#3 cputs::c#1 ] { { printf_uint::uvalue#0 = main::count#11 } } ) always clobbers reg byte a reg byte y +Statement [78] *((byte*) conio_cursor_text) ← (byte) cputc::c#3 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] ( main:6::cputs:17::cputc:75 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte y +Statement [80] *((byte*) conio_cursor_color) ← (const nomodify byte) CONIO_TEXTCOLOR_DEFAULT [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] ( main:6::cputs:17::cputc:75 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a reg byte y +Statement [83] if((byte) conio_cursor_x!=(byte) $28) goto cputc::@return [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] ( main:6::cputs:17::cputc:75 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [84] (byte) conio_cursor_x ← (byte) 0 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] ( main:6::cputs:17::cputc:75 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [90] (word) cputln::ln_offset#0 ← (byte) $28 - (byte) conio_cursor_x [ conio_cursor_y conio_cursor_text conio_cursor_color cputln::ln_offset#0 ] ( main:6::cputs:17::cputc:75::cputln:89 [ cputs::s#0 conio_cursor_y conio_cursor_text conio_cursor_color cputln::ln_offset#0 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89 [ cputs::s#0 conio_cursor_y conio_cursor_text conio_cursor_color cputln::ln_offset#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89 [ conio_cursor_y conio_cursor_text conio_cursor_color cputln::ln_offset#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [91] (byte*~) cputln::$1 ← (byte*) conio_cursor_text + (word) cputln::ln_offset#0 [ conio_cursor_y conio_cursor_color cputln::ln_offset#0 cputln::$1 ] ( main:6::cputs:17::cputc:75::cputln:89 [ cputs::s#0 conio_cursor_y conio_cursor_color cputln::ln_offset#0 cputln::$1 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89 [ cputs::s#0 conio_cursor_y conio_cursor_color cputln::ln_offset#0 cputln::$1 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89 [ conio_cursor_y conio_cursor_color cputln::ln_offset#0 cputln::$1 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [92] (byte*) conio_cursor_text ← (byte*~) cputln::$1 [ conio_cursor_y conio_cursor_text conio_cursor_color cputln::ln_offset#0 ] ( main:6::cputs:17::cputc:75::cputln:89 [ cputs::s#0 conio_cursor_y conio_cursor_text conio_cursor_color cputln::ln_offset#0 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89 [ cputs::s#0 conio_cursor_y conio_cursor_text conio_cursor_color cputln::ln_offset#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89 [ conio_cursor_y conio_cursor_text conio_cursor_color cputln::ln_offset#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [93] (byte*~) cputln::$2 ← (byte*) conio_cursor_color + (word) cputln::ln_offset#0 [ conio_cursor_y conio_cursor_text cputln::$2 ] ( main:6::cputs:17::cputc:75::cputln:89 [ cputs::s#0 conio_cursor_y conio_cursor_text cputln::$2 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89 [ cputs::s#0 conio_cursor_y conio_cursor_text cputln::$2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89 [ conio_cursor_y conio_cursor_text cputln::$2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [94] (byte*) conio_cursor_color ← (byte*~) cputln::$2 [ conio_cursor_y conio_cursor_text conio_cursor_color ] ( main:6::cputs:17::cputc:75::cputln:89 [ cputs::s#0 conio_cursor_y conio_cursor_text conio_cursor_color ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89 [ cputs::s#0 conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89 [ conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [95] (byte) conio_cursor_x ← (byte) 0 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] ( main:6::cputs:17::cputc:75::cputln:89 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [99] if((byte) conio_cursor_y!=(byte) $19) goto cscroll::@return [ conio_cursor_y conio_cursor_text conio_cursor_color ] ( main:6::cputs:17::cputc:75::cscroll:86 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [108] (byte*~) cscroll::$7 ← (byte*) conio_cursor_text - (byte) $28 [ conio_cursor_y conio_cursor_color cscroll::$7 ] ( main:6::cputs:17::cputc:75::cscroll:86 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_color cscroll::$7 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_color cscroll::$7 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86 [ conio_cursor_x conio_cursor_y conio_cursor_color cscroll::$7 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_color cscroll::$7 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_color cscroll::$7 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97 [ conio_cursor_x conio_cursor_y conio_cursor_color cscroll::$7 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [109] (byte*) conio_cursor_text ← (byte*~) cscroll::$7 [ conio_cursor_y conio_cursor_text conio_cursor_color ] ( main:6::cputs:17::cputc:75::cscroll:86 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [110] (byte*~) cscroll::$8 ← (byte*) conio_cursor_color - (byte) $28 [ conio_cursor_y conio_cursor_text cscroll::$8 ] ( main:6::cputs:17::cputc:75::cscroll:86 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text cscroll::$8 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text cscroll::$8 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86 [ conio_cursor_x conio_cursor_y conio_cursor_text cscroll::$8 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text cscroll::$8 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text cscroll::$8 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97 [ conio_cursor_x conio_cursor_y conio_cursor_text cscroll::$8 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [111] (byte*) conio_cursor_color ← (byte*~) cscroll::$8 [ conio_cursor_y conio_cursor_text conio_cursor_color ] ( main:6::cputs:17::cputc:75::cscroll:86 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [115] if((word) memset::num#3<=(byte) 0) goto memset::@return [ memset::num#3 memset::str#4 memset::c#5 ] ( main:6::memset:9 [ printf_buffer memset::num#3 memset::str#4 memset::c#5 ] { } main:6::cputs:17::cputc:75::cscroll:86::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::num#3 memset::str#4 memset::c#5 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::num#3 memset::str#4 memset::c#5 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memset:105 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::num#3 memset::str#4 memset::c#5 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::num#3 memset::str#4 memset::c#5 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::num#3 memset::str#4 memset::c#5 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memset:105 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::num#3 memset::str#4 memset::c#5 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cscroll:86::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::num#3 memset::str#4 memset::c#5 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::num#3 memset::str#4 memset::c#5 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memset:107 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::num#3 memset::str#4 memset::c#5 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::num#3 memset::str#4 memset::c#5 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::num#3 memset::str#4 memset::c#5 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memset:107 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::num#3 memset::str#4 memset::c#5 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [116] (byte*) memset::end#0 ← (byte*)(void*) memset::str#4 + (word) memset::num#3 [ memset::str#4 memset::c#5 memset::end#0 ] ( main:6::memset:9 [ printf_buffer memset::str#4 memset::c#5 memset::end#0 ] { } main:6::cputs:17::cputc:75::cscroll:86::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::str#4 memset::c#5 memset::end#0 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::str#4 memset::c#5 memset::end#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memset:105 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::str#4 memset::c#5 memset::end#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::str#4 memset::c#5 memset::end#0 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::str#4 memset::c#5 memset::end#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memset:105 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::str#4 memset::c#5 memset::end#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cscroll:86::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::str#4 memset::c#5 memset::end#0 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::str#4 memset::c#5 memset::end#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memset:107 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::str#4 memset::c#5 memset::end#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::str#4 memset::c#5 memset::end#0 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::str#4 memset::c#5 memset::end#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memset:107 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::str#4 memset::c#5 memset::end#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [117] (byte*) memset::dst#4 ← (byte*)(void*) memset::str#4 [ memset::c#5 memset::end#0 memset::dst#4 ] ( main:6::memset:9 [ printf_buffer memset::c#5 memset::end#0 memset::dst#4 ] { } main:6::cputs:17::cputc:75::cscroll:86::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#4 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memset:105 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#4 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memset:105 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cscroll:86::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#4 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memset:107 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#4 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memset:107 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [119] if((byte*) memset::dst#2!=(byte*) memset::end#0) goto memset::@3 [ memset::c#5 memset::end#0 memset::dst#2 ] ( main:6::memset:9 [ printf_buffer memset::c#5 memset::end#0 memset::dst#2 ] { } main:6::cputs:17::cputc:75::cscroll:86::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memset:105 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memset:105 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cscroll:86::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memset:107 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memset:107 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [121] *((byte*) memset::dst#2) ← (byte) memset::c#5 [ memset::c#5 memset::end#0 memset::dst#2 ] ( main:6::memset:9 [ printf_buffer memset::c#5 memset::end#0 memset::dst#2 ] { } main:6::cputs:17::cputc:75::cscroll:86::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memset:105 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memset:105 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memset:105 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cscroll:86::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memset:107 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memset:107 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memset:107 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memset::c#5 memset::end#0 memset::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a reg byte y +Statement [124] (byte*) memcpy::src_end#0 ← (byte*)(void*) memcpy::source#2 + (word)(number) $19*(number) $28-(number) $28 [ memcpy::source#2 memcpy::destination#2 memcpy::src_end#0 ] ( main:6::cputs:17::cputc:75::cscroll:86::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::source#2 memcpy::destination#2 memcpy::src_end#0 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::source#2 memcpy::destination#2 memcpy::src_end#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memcpy:101 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::source#2 memcpy::destination#2 memcpy::src_end#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::source#2 memcpy::destination#2 memcpy::src_end#0 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::source#2 memcpy::destination#2 memcpy::src_end#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memcpy:101 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::source#2 memcpy::destination#2 memcpy::src_end#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cscroll:86::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::source#2 memcpy::destination#2 memcpy::src_end#0 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::source#2 memcpy::destination#2 memcpy::src_end#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memcpy:103 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::source#2 memcpy::destination#2 memcpy::src_end#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::source#2 memcpy::destination#2 memcpy::src_end#0 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::source#2 memcpy::destination#2 memcpy::src_end#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memcpy:103 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::source#2 memcpy::destination#2 memcpy::src_end#0 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [125] (byte*) memcpy::src#4 ← (byte*)(void*) memcpy::source#2 [ memcpy::destination#2 memcpy::src_end#0 memcpy::src#4 ] ( main:6::cputs:17::cputc:75::cscroll:86::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::destination#2 memcpy::src_end#0 memcpy::src#4 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::destination#2 memcpy::src_end#0 memcpy::src#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memcpy:101 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::destination#2 memcpy::src_end#0 memcpy::src#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::destination#2 memcpy::src_end#0 memcpy::src#4 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::destination#2 memcpy::src_end#0 memcpy::src#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memcpy:101 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::destination#2 memcpy::src_end#0 memcpy::src#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cscroll:86::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::destination#2 memcpy::src_end#0 memcpy::src#4 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::destination#2 memcpy::src_end#0 memcpy::src#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memcpy:103 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::destination#2 memcpy::src_end#0 memcpy::src#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::destination#2 memcpy::src_end#0 memcpy::src#4 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::destination#2 memcpy::src_end#0 memcpy::src#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memcpy:103 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::destination#2 memcpy::src_end#0 memcpy::src#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [126] (byte*) memcpy::dst#4 ← (byte*)(void*) memcpy::destination#2 [ memcpy::src_end#0 memcpy::src#4 memcpy::dst#4 ] ( main:6::cputs:17::cputc:75::cscroll:86::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#4 memcpy::dst#4 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#4 memcpy::dst#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memcpy:101 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#4 memcpy::dst#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#4 memcpy::dst#4 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#4 memcpy::dst#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memcpy:101 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#4 memcpy::dst#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cscroll:86::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#4 memcpy::dst#4 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#4 memcpy::dst#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memcpy:103 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#4 memcpy::dst#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#4 memcpy::dst#4 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#4 memcpy::dst#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memcpy:103 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#4 memcpy::dst#4 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [128] if((byte*) memcpy::src#2!=(byte*) memcpy::src_end#0) goto memcpy::@2 [ memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] ( main:6::cputs:17::cputc:75::cscroll:86::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memcpy:101 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memcpy:101 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cscroll:86::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memcpy:103 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memcpy:103 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a +Statement [130] *((byte*) memcpy::dst#2) ← *((byte*) memcpy::src#2) [ memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] ( main:6::cputs:17::cputc:75::cscroll:86::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memcpy:101 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memcpy:101 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memcpy:101 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cscroll:86::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cscroll:86::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cscroll:86::memcpy:103 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } main:6::cputs:17::cputc:75::cputln:89::cscroll:97::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputs:145::cputc:75::cputln:89::cscroll:97::memcpy:103 [ cputs::s#0 conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#0 = cputc::c#3 cputs::c#1 } } main:6::printf_uint:15::printf_number_buffer:138::cputc:143::cputln:89::cscroll:97::memcpy:103 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color memcpy::src_end#0 memcpy::src#2 memcpy::dst#2 ] { { printf_uint::uvalue#0 = main::count#11 } { cputc::c#2 = cputc::c#3 printf_number_buffer::buffer_sign#0 } } ) always clobbers reg byte a reg byte y +Statement [134] *((byte*)&(struct printf_buffer_number) printf_buffer) ← (byte) 0 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_uint::uvalue#0 printf_buffer ] ( main:6::printf_uint:15 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_uint::uvalue#0 printf_buffer ] { { printf_uint::uvalue#0 = main::count#11 utoa::value#1 } } ) always clobbers reg byte a +Statement [135] (word) utoa::value#1 ← (word) printf_uint::uvalue#0 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_buffer utoa::value#1 ] ( main:6::printf_uint:15 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_buffer utoa::value#1 ] { { printf_uint::uvalue#0 = main::count#11 utoa::value#1 } } ) always clobbers reg byte a +Statement [150] (byte~) utoa::$11 ← (byte)(word) utoa::value#2 [ printf_buffer utoa::buffer#11 utoa::$11 ] ( main:6::printf_uint:15::utoa:136 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_buffer utoa::buffer#11 utoa::$11 ] { { printf_uint::uvalue#0 = main::count#11 utoa::value#1 } } ) always clobbers reg byte a +Statement [151] *((byte*) utoa::buffer#11) ← *((const byte*) DIGITS + (byte~) utoa::$11) [ printf_buffer utoa::buffer#11 ] ( main:6::printf_uint:15::utoa:136 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_buffer utoa::buffer#11 ] { { printf_uint::uvalue#0 = main::count#11 utoa::value#1 } } ) always clobbers reg byte a reg byte y +Statement [152] (byte*) utoa::buffer#3 ← ++ (byte*) utoa::buffer#11 [ printf_buffer utoa::buffer#3 ] ( main:6::printf_uint:15::utoa:136 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_buffer utoa::buffer#3 ] { { printf_uint::uvalue#0 = main::count#11 utoa::value#1 } } ) always clobbers reg byte a +Statement [153] *((byte*) utoa::buffer#3) ← (byte) 0 [ printf_buffer ] ( main:6::printf_uint:15::utoa:136 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_buffer ] { { printf_uint::uvalue#0 = main::count#11 utoa::value#1 } } ) always clobbers reg byte a reg byte y +Statement [155] (byte~) utoa::$10 ← (byte) utoa::digit#2 << (byte) 1 [ printf_buffer utoa::digit#2 utoa::value#2 utoa::started#2 utoa::buffer#11 utoa::$10 ] ( main:6::printf_uint:15::utoa:136 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_buffer utoa::digit#2 utoa::value#2 utoa::started#2 utoa::buffer#11 utoa::$10 ] { { printf_uint::uvalue#0 = main::count#11 utoa::value#1 } } ) always clobbers reg byte a +Statement [156] (word) utoa::digit_value#0 ← *((const word*) RADIX_DECIMAL_VALUES + (byte~) utoa::$10) [ printf_buffer utoa::digit#2 utoa::value#2 utoa::started#2 utoa::buffer#11 utoa::digit_value#0 ] ( main:6::printf_uint:15::utoa:136 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_buffer utoa::digit#2 utoa::value#2 utoa::started#2 utoa::buffer#11 utoa::digit_value#0 ] { { printf_uint::uvalue#0 = main::count#11 utoa::value#1 } } ) always clobbers reg byte a +Statement [158] if((word) utoa::value#2>=(word) utoa::digit_value#0) goto utoa::@5 [ printf_buffer utoa::digit#2 utoa::value#2 utoa::started#2 utoa::buffer#11 utoa::digit_value#0 ] ( main:6::printf_uint:15::utoa:136 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_buffer utoa::digit#2 utoa::value#2 utoa::started#2 utoa::buffer#11 utoa::digit_value#0 ] { { printf_uint::uvalue#0 = main::count#11 utoa::value#1 } } ) always clobbers reg byte a +Statement [161] (byte*) utoa_append::buffer#0 ← (byte*) utoa::buffer#11 [ printf_buffer utoa::digit#2 utoa::value#2 utoa::buffer#11 utoa::digit_value#0 utoa_append::buffer#0 ] ( main:6::printf_uint:15::utoa:136 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_buffer utoa::digit#2 utoa::value#2 utoa::buffer#11 utoa::digit_value#0 utoa_append::buffer#0 ] { { printf_uint::uvalue#0 = main::count#11 utoa::value#1 } { utoa_append::buffer#0 = utoa::buffer#11 } { utoa_append::value#0 = utoa::value#2 } { utoa_append::sub#0 = utoa::digit_value#0 } { utoa_append::return#0 = utoa_append::value#2 } } ) always clobbers reg byte a +Statement [162] (word) utoa_append::value#0 ← (word) utoa::value#2 [ printf_buffer utoa::digit#2 utoa::buffer#11 utoa::digit_value#0 utoa_append::buffer#0 utoa_append::value#0 ] ( main:6::printf_uint:15::utoa:136 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_buffer utoa::digit#2 utoa::buffer#11 utoa::digit_value#0 utoa_append::buffer#0 utoa_append::value#0 ] { { printf_uint::uvalue#0 = main::count#11 utoa::value#1 } { utoa_append::buffer#0 = utoa::buffer#11 } { utoa_append::value#0 = utoa::value#2 } { utoa_append::sub#0 = utoa::digit_value#0 } { utoa_append::return#0 = utoa_append::value#2 } } ) always clobbers reg byte a +Statement [163] (word) utoa_append::sub#0 ← (word) utoa::digit_value#0 [ printf_buffer utoa::digit#2 utoa::buffer#11 utoa_append::buffer#0 utoa_append::value#0 utoa_append::sub#0 ] ( main:6::printf_uint:15::utoa:136 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_buffer utoa::digit#2 utoa::buffer#11 utoa_append::buffer#0 utoa_append::value#0 utoa_append::sub#0 ] { { printf_uint::uvalue#0 = main::count#11 utoa::value#1 } { utoa_append::buffer#0 = utoa::buffer#11 } { utoa_append::value#0 = utoa::value#2 } { utoa_append::sub#0 = utoa::digit_value#0 } { utoa_append::return#0 = utoa_append::value#2 } } ) always clobbers reg byte a +Statement [165] (word) utoa_append::return#0 ← (word) utoa_append::value#2 [ printf_buffer utoa::digit#2 utoa::buffer#11 utoa_append::return#0 ] ( main:6::printf_uint:15::utoa:136 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_buffer utoa::digit#2 utoa::buffer#11 utoa_append::return#0 ] { { printf_uint::uvalue#0 = main::count#11 utoa::value#1 } { utoa_append::buffer#0 = utoa::buffer#11 } { utoa_append::value#0 = utoa::value#2 } { utoa_append::sub#0 = utoa::digit_value#0 } { utoa_append::return#0 = utoa_append::value#2 } } ) always clobbers reg byte a +Statement [166] (word) utoa::value#0 ← (word) utoa_append::return#0 [ printf_buffer utoa::digit#2 utoa::buffer#11 utoa::value#0 ] ( main:6::printf_uint:15::utoa:136 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_buffer utoa::digit#2 utoa::buffer#11 utoa::value#0 ] { { printf_uint::uvalue#0 = main::count#11 utoa::value#1 } } ) always clobbers reg byte a +Statement [170] if((word) utoa_append::value#2>=(word) utoa_append::sub#0) goto utoa_append::@2 [ utoa_append::buffer#0 utoa_append::sub#0 utoa_append::value#2 utoa_append::digit#2 ] ( main:6::printf_uint:15::utoa:136::utoa_append:164 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_buffer utoa::digit#2 utoa::buffer#11 utoa_append::buffer#0 utoa_append::sub#0 utoa_append::value#2 utoa_append::digit#2 ] { { printf_uint::uvalue#0 = main::count#11 utoa::value#1 } { utoa_append::buffer#0 = utoa::buffer#11 } { utoa_append::value#0 = utoa::value#2 } { utoa_append::sub#0 = utoa::digit_value#0 } { utoa_append::return#0 = utoa_append::value#2 } } ) always clobbers reg byte a +Statement [171] *((byte*) utoa_append::buffer#0) ← *((const byte*) DIGITS + (byte) utoa_append::digit#2) [ utoa_append::value#2 ] ( main:6::printf_uint:15::utoa:136::utoa_append:164 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_buffer utoa::digit#2 utoa::buffer#11 utoa_append::value#2 ] { { printf_uint::uvalue#0 = main::count#11 utoa::value#1 } { utoa_append::buffer#0 = utoa::buffer#11 } { utoa_append::value#0 = utoa::value#2 } { utoa_append::sub#0 = utoa::digit_value#0 } { utoa_append::return#0 = utoa_append::value#2 } } ) always clobbers reg byte a reg byte y +Statement [174] (word) utoa_append::value#1 ← (word) utoa_append::value#2 - (word) utoa_append::sub#0 [ utoa_append::buffer#0 utoa_append::sub#0 utoa_append::value#1 utoa_append::digit#1 ] ( main:6::printf_uint:15::utoa:136::utoa_append:164 [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color printf_buffer utoa::digit#2 utoa::buffer#11 utoa_append::buffer#0 utoa_append::sub#0 utoa_append::value#1 utoa_append::digit#1 ] { { printf_uint::uvalue#0 = main::count#11 utoa::value#1 } { utoa_append::buffer#0 = utoa::buffer#11 } { utoa_append::value#0 = utoa::value#2 } { utoa_append::sub#0 = utoa::digit_value#0 } { utoa_append::return#0 = utoa_append::value#2 } } ) always clobbers reg byte a +Statement [176] (byte) conio_cursor_x ← (const byte) gotoxy::x#2 [ conio_cursor_x ] ( main:6::gotoxy:13 [ main::count#11 printf_buffer conio_cursor_x ] { } ) always clobbers reg byte a +Statement [177] (byte) conio_cursor_y ← (const byte) gotoxy::y#2 [ conio_cursor_x conio_cursor_y ] ( main:6::gotoxy:13 [ main::count#11 printf_buffer conio_cursor_x conio_cursor_y ] { } ) always clobbers reg byte a +Statement [178] (byte*) conio_cursor_text ← (const nomodify byte*) CONIO_SCREEN_TEXT [ conio_cursor_x conio_cursor_y conio_cursor_text ] ( main:6::gotoxy:13 [ main::count#11 printf_buffer conio_cursor_x conio_cursor_y conio_cursor_text ] { } ) always clobbers reg byte a +Statement [179] (byte*) conio_cursor_color ← (const nomodify byte*) CONIO_SCREEN_COLORS [ conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] ( main:6::gotoxy:13 [ main::count#11 printf_buffer conio_cursor_x conio_cursor_y conio_cursor_text conio_cursor_color ] { } ) always clobbers reg byte a +Potential registers zp[1]:2 [ main::y#2 main::y#1 ] : zp[1]:2 , reg byte x , +Potential registers zp[2]:3 [ main::count#11 main::count#10 main::count#12 main::count#1 ] : zp[2]:3 , +Potential registers zp[2]:5 [ main::sc#8 main::sc#10 main::sc#1 ] : zp[2]:5 , +Potential registers zp[1]:7 [ main::x#2 main::x#1 ] : zp[1]:7 , reg byte x , +Potential registers zp[1]:8 [ mul8s::a#2 mul8s::a#1 mul8s::a#0 ] : zp[1]:8 , reg byte x , reg byte y , +Potential registers zp[1]:9 [ mul8s::b#2 mul8s::b#1 mul8s::b#0 ] : zp[1]:9 , reg byte x , reg byte y , +Potential registers zp[2]:10 [ mul8s::m#4 mul8s::m#5 mul8s::m#1 mul8s::m#0 mul8s::m#2 ] : zp[2]:10 , +Potential registers zp[1]:12 [ mul8u::a#2 mul8u::a#1 mul8u::a#0 ] : zp[1]:12 , reg byte x , reg byte y , +Potential registers zp[2]:13 [ mul8u::res#2 mul8u::res#6 mul8u::res#1 ] : zp[2]:13 , +Potential registers zp[2]:15 [ mul8u::mb#2 mul8u::mb#0 mul8u::mb#1 ] : zp[2]:15 , +Potential registers zp[2]:17 [ cputs::s#3 cputs::s#4 cputs::s#0 ] : zp[2]:17 , +Potential registers zp[1]:19 [ cputc::c#3 cputc::c#0 cputc::c#2 ] : zp[1]:19 , reg byte a , reg byte x , reg byte y , +Potential registers zp[2]:20 [ memset::num#3 ] : zp[2]:20 , +Potential registers zp[2]:22 [ memset::str#4 ] : zp[2]:22 , +Potential registers zp[1]:24 [ memset::c#5 ] : zp[1]:24 , reg byte x , +Potential registers zp[2]:25 [ memset::dst#2 memset::dst#4 memset::dst#1 ] : zp[2]:25 , +Potential registers zp[2]:27 [ memcpy::source#2 ] : zp[2]:27 , +Potential registers zp[2]:29 [ memcpy::destination#2 ] : zp[2]:29 , +Potential registers zp[2]:31 [ memcpy::src#2 memcpy::src#4 memcpy::src#1 ] : zp[2]:31 , +Potential registers zp[2]:33 [ memcpy::dst#2 memcpy::dst#4 memcpy::dst#1 ] : zp[2]:33 , +Potential registers zp[1]:35 [ utoa::digit#2 utoa::digit#1 ] : zp[1]:35 , reg byte x , +Potential registers zp[2]:36 [ utoa::value#2 utoa::value#6 utoa::value#1 utoa::value#0 ] : zp[2]:36 , +Potential registers zp[1]:38 [ utoa::started#2 utoa::started#4 ] : zp[1]:38 , reg byte x , reg byte y , +Potential registers zp[2]:39 [ utoa::buffer#11 utoa::buffer#14 utoa::buffer#4 ] : zp[2]:39 , +Potential registers zp[2]:41 [ utoa_append::value#2 utoa_append::value#0 utoa_append::value#1 ] : zp[2]:41 , +Potential registers zp[1]:43 [ utoa_append::digit#2 utoa_append::digit#1 ] : zp[1]:43 , reg byte x , reg byte y , +Potential registers zp[1]:44 [ conio_cursor_x ] : zp[1]:44 , +Potential registers zp[1]:45 [ conio_cursor_y ] : zp[1]:45 , +Potential registers zp[2]:46 [ conio_cursor_text ] : zp[2]:46 , +Potential registers zp[2]:48 [ conio_cursor_color ] : zp[2]:48 , +Potential registers zp[2]:50 [ printf_uint::uvalue#0 ] : zp[2]:50 , +Potential registers zp[1]:52 [ main::$5 ] : zp[1]:52 , reg byte a , reg byte x , reg byte y , +Potential registers zp[1]:53 [ main::xd#0 ] : zp[1]:53 , reg byte x , reg byte y , +Potential registers zp[1]:54 [ main::$7 ] : zp[1]:54 , reg byte a , reg byte x , reg byte y , +Potential registers zp[1]:55 [ main::yd#0 ] : zp[1]:55 , reg byte x , reg byte y , +Potential registers zp[2]:56 [ main::$9 ] : zp[2]:56 , +Potential registers zp[2]:58 [ main::$10 ] : zp[2]:58 , +Potential registers zp[2]:60 [ main::dist_sq#0 ] : zp[2]:60 , +Potential registers zp[1]:62 [ mul8u::b#0 ] : zp[1]:62 , reg byte a , reg byte x , reg byte y , +Potential registers zp[2]:63 [ mul8u::return#2 ] : zp[2]:63 , +Potential registers zp[1]:65 [ mul8s::$6 ] : zp[1]:65 , reg byte a , reg byte x , reg byte y , +Potential registers zp[1]:66 [ mul8s::$11 ] : zp[1]:66 , reg byte a , reg byte x , reg byte y , +Potential registers zp[1]:67 [ mul8s::$9 ] : zp[1]:67 , reg byte a , reg byte x , reg byte y , +Potential registers zp[1]:68 [ mul8s::$12 ] : zp[1]:68 , reg byte a , reg byte x , reg byte y , +Potential registers zp[1]:69 [ mul8u::$1 ] : zp[1]:69 , reg byte a , reg byte x , reg byte y , +Potential registers zp[1]:70 [ cputs::c#1 ] : zp[1]:70 , reg byte a , reg byte x , reg byte y , +Potential registers zp[2]:71 [ cputln::ln_offset#0 ] : zp[2]:71 , +Potential registers zp[2]:73 [ cputln::$1 ] : zp[2]:73 , +Potential registers zp[2]:75 [ cputln::$2 ] : zp[2]:75 , +Potential registers zp[2]:77 [ cscroll::$7 ] : zp[2]:77 , +Potential registers zp[2]:79 [ cscroll::$8 ] : zp[2]:79 , +Potential registers zp[2]:81 [ memset::end#0 ] : zp[2]:81 , +Potential registers zp[2]:83 [ memcpy::src_end#0 ] : zp[2]:83 , +Potential registers zp[1]:85 [ printf_number_buffer::buffer_sign#0 ] : zp[1]:85 , reg byte a , reg byte x , reg byte y , +Potential registers zp[1]:86 [ utoa::$11 ] : zp[1]:86 , reg byte a , reg byte x , reg byte y , +Potential registers zp[2]:87 [ utoa::buffer#3 ] : zp[2]:87 , +Potential registers zp[1]:89 [ utoa::$10 ] : zp[1]:89 , reg byte a , reg byte x , reg byte y , +Potential registers zp[2]:90 [ utoa::digit_value#0 ] : zp[2]:90 , +Potential registers zp[2]:92 [ utoa_append::buffer#0 ] : zp[2]:92 , +Potential registers zp[2]:94 [ utoa_append::sub#0 ] : zp[2]:94 , +Potential registers zp[2]:96 [ utoa_append::return#0 ] : zp[2]:96 , +Potential registers mem[12] [ printf_buffer ] : mem[12] , + +REGISTER UPLIFT SCOPES +Uplift Scope [memcpy] 301,250,000,004.25: zp[2]:31 [ memcpy::src#2 memcpy::src#4 memcpy::src#1 ] 202,333,333,337.67: zp[2]:33 [ memcpy::dst#2 memcpy::dst#4 memcpy::dst#1 ] 12,625,000,000.25: zp[2]:83 [ memcpy::src_end#0 ] 0: zp[2]:27 [ memcpy::source#2 ] 0: zp[2]:29 [ memcpy::destination#2 ] +Uplift Scope [memset] 35,666,666,672.33: zp[2]:25 [ memset::dst#2 memset::dst#4 memset::dst#1 ] 1,833,333,333.67: zp[2]:81 [ memset::end#0 ] 1,250,000,000.12: zp[1]:24 [ memset::c#5 ] 1,000,000,001: zp[2]:20 [ memset::num#3 ] 0: zp[2]:22 [ memset::str#4 ] +Uplift Scope [mul8u] 350,001,670.33: zp[2]:13 [ mul8u::res#2 mul8u::res#6 mul8u::res#1 ] 243,071,433.14: zp[2]:15 [ mul8u::mb#2 mul8u::mb#0 mul8u::mb#1 ] 200,000,002: zp[1]:69 [ mul8u::$1 ] 166,720,002.5: zp[1]:12 [ mul8u::a#2 mul8u::a#1 mul8u::a#0 ] 20,002: zp[2]:63 [ mul8u::return#2 ] 10,001: zp[1]:62 [ mul8u::b#0 ] +Uplift Scope [cscroll] 200,000,002: zp[2]:77 [ cscroll::$7 ] 200,000,002: zp[2]:79 [ cscroll::$8 ] +Uplift Scope [cputln] 20,000,002: zp[2]:73 [ cputln::$1 ] 20,000,002: zp[2]:75 [ cputln::$2 ] 10,000,001: zp[2]:71 [ cputln::ln_offset#0 ] +Uplift Scope [utoa_append] 25,055,003.5: zp[2]:41 [ utoa_append::value#2 utoa_append::value#0 utoa_append::value#1 ] 20,050,002.5: zp[1]:43 [ utoa_append::digit#2 utoa_append::digit#1 ] 3,335,000.5: zp[2]:94 [ utoa_append::sub#0 ] 20,002: zp[2]:96 [ utoa_append::return#0 ] 13,750.25: zp[2]:92 [ utoa_append::buffer#0 ] +Uplift Scope [] 4,735,295.74: zp[1]:45 [ conio_cursor_y ] 3,484,376.72: zp[2]:48 [ conio_cursor_color ] 3,430,770.92: zp[2]:46 [ conio_cursor_text ] 489,798.14: zp[1]:44 [ conio_cursor_x ] 0: mem[12] [ printf_buffer ] +Uplift Scope [cputc] 1,252,506: zp[1]:19 [ cputc::c#3 cputc::c#0 cputc::c#2 ] +Uplift Scope [cputs] 215,003.5: zp[2]:17 [ cputs::s#3 cputs::s#4 cputs::s#0 ] 100,001: zp[1]:70 [ cputs::c#1 ] +Uplift Scope [mul8s] 67,506.75: zp[2]:10 [ mul8s::m#4 mul8s::m#5 mul8s::m#1 mul8s::m#0 mul8s::m#2 ] 20,002: zp[1]:65 [ mul8s::$6 ] 20,002: zp[1]:66 [ mul8s::$11 ] 20,002: zp[1]:67 [ mul8s::$9 ] 20,002: zp[1]:68 [ mul8s::$12 ] 5,095.18: zp[1]:9 [ mul8s::b#2 mul8s::b#1 mul8s::b#0 ] 2,925.31: zp[1]:8 [ mul8s::a#2 mul8s::a#1 mul8s::a#0 ] +Uplift Scope [utoa] 38,003.93: zp[2]:39 [ utoa::buffer#11 utoa::buffer#14 utoa::buffer#4 ] 31,411.36: zp[2]:36 [ utoa::value#2 utoa::value#6 utoa::value#1 utoa::value#0 ] 22,859.43: zp[1]:35 [ utoa::digit#2 utoa::digit#1 ] 20,002: zp[1]:89 [ utoa::$10 ] 15,001.5: zp[1]:38 [ utoa::started#2 utoa::started#4 ] 6,000.6: zp[2]:90 [ utoa::digit_value#0 ] 2,002: zp[1]:86 [ utoa::$11 ] 2,002: zp[2]:87 [ utoa::buffer#3 ] +Uplift Scope [main] 3,234.31: zp[2]:3 [ main::count#11 main::count#10 main::count#12 main::count#1 ] 2,152.15: zp[1]:7 [ main::x#2 main::x#1 ] 2,002: zp[1]:52 [ main::$5 ] 2,002: zp[1]:54 [ main::$7 ] 2,002: zp[2]:58 [ main::$10 ] 2,002: zp[2]:60 [ main::dist_sq#0 ] 1,262.25: zp[2]:5 [ main::sc#8 main::sc#10 main::sc#1 ] 750.75: zp[1]:53 [ main::xd#0 ] 500.5: zp[1]:55 [ main::yd#0 ] 400.4: zp[2]:56 [ main::$9 ] 215.17: zp[1]:2 [ main::y#2 main::y#1 ] +Uplift Scope [printf_number_buffer] 701: zp[1]:85 [ printf_number_buffer::buffer_sign#0 ] +Uplift Scope [printf_uint] 37.33: zp[2]:50 [ printf_uint::uvalue#0 ] +Uplift Scope [gotoxy] +Uplift Scope [RADIX] +Uplift Scope [printf_format_number] +Uplift Scope [printf_buffer_number] +Uplift Scope [printf_format_string] + +Uplifting [memcpy] best 118348 combination zp[2]:31 [ memcpy::src#2 memcpy::src#4 memcpy::src#1 ] zp[2]:33 [ memcpy::dst#2 memcpy::dst#4 memcpy::dst#1 ] zp[2]:83 [ memcpy::src_end#0 ] zp[2]:27 [ memcpy::source#2 ] zp[2]:29 [ memcpy::destination#2 ] +Uplifting [memset] best 118329 combination zp[2]:25 [ memset::dst#2 memset::dst#4 memset::dst#1 ] zp[2]:81 [ memset::end#0 ] reg byte x [ memset::c#5 ] zp[2]:20 [ memset::num#3 ] zp[2]:22 [ memset::str#4 ] +Uplifting [mul8u] best 109320 combination zp[2]:13 [ mul8u::res#2 mul8u::res#6 mul8u::res#1 ] zp[2]:15 [ mul8u::mb#2 mul8u::mb#0 mul8u::mb#1 ] reg byte a [ mul8u::$1 ] reg byte x [ mul8u::a#2 mul8u::a#1 mul8u::a#0 ] zp[2]:63 [ mul8u::return#2 ] reg byte a [ mul8u::b#0 ] +Uplifting [cscroll] best 109320 combination zp[2]:77 [ cscroll::$7 ] zp[2]:79 [ cscroll::$8 ] +Uplifting [cputln] best 109320 combination zp[2]:73 [ cputln::$1 ] zp[2]:75 [ cputln::$2 ] zp[2]:71 [ cputln::ln_offset#0 ] +Uplifting [utoa_append] best 108717 combination zp[2]:41 [ utoa_append::value#2 utoa_append::value#0 utoa_append::value#1 ] reg byte x [ utoa_append::digit#2 utoa_append::digit#1 ] zp[2]:94 [ utoa_append::sub#0 ] zp[2]:96 [ utoa_append::return#0 ] zp[2]:92 [ utoa_append::buffer#0 ] +Uplifting [] best 108717 combination zp[1]:45 [ conio_cursor_y ] zp[2]:48 [ conio_cursor_color ] zp[2]:46 [ conio_cursor_text ] zp[1]:44 [ conio_cursor_x ] mem[12] [ printf_buffer ] +Uplifting [cputc] best 108678 combination reg byte a [ cputc::c#3 cputc::c#0 cputc::c#2 ] +Uplifting [cputs] best 108588 combination zp[2]:17 [ cputs::s#3 cputs::s#4 cputs::s#0 ] reg byte a [ cputs::c#1 ] +Uplifting [mul8s] best 108564 combination zp[2]:10 [ mul8s::m#4 mul8s::m#5 mul8s::m#1 mul8s::m#0 mul8s::m#2 ] reg byte a [ mul8s::$6 ] reg byte a [ mul8s::$11 ] reg byte a [ mul8s::$9 ] reg byte a [ mul8s::$12 ] zp[1]:9 [ mul8s::b#2 mul8s::b#1 mul8s::b#0 ] zp[1]:8 [ mul8s::a#2 mul8s::a#1 mul8s::a#0 ] +Limited combination testing to 100 combinations of 2304 possible. +Uplifting [utoa] best 108430 combination zp[2]:39 [ utoa::buffer#11 utoa::buffer#14 utoa::buffer#4 ] zp[2]:36 [ utoa::value#2 utoa::value#6 utoa::value#1 utoa::value#0 ] zp[1]:35 [ utoa::digit#2 utoa::digit#1 ] reg byte a [ utoa::$10 ] reg byte x [ utoa::started#2 utoa::started#4 ] zp[2]:90 [ utoa::digit_value#0 ] reg byte a [ utoa::$11 ] zp[2]:87 [ utoa::buffer#3 ] +Uplifting [main] best 106730 combination zp[2]:3 [ main::count#11 main::count#10 main::count#12 main::count#1 ] zp[1]:7 [ main::x#2 main::x#1 ] reg byte a [ main::$5 ] reg byte a [ main::$7 ] zp[2]:58 [ main::$10 ] zp[2]:60 [ main::dist_sq#0 ] zp[2]:5 [ main::sc#8 main::sc#10 main::sc#1 ] reg byte x [ main::xd#0 ] zp[1]:55 [ main::yd#0 ] zp[2]:56 [ main::$9 ] zp[1]:2 [ main::y#2 main::y#1 ] +Limited combination testing to 100 combinations of 576 possible. +Uplifting [printf_number_buffer] best 106721 combination reg byte a [ printf_number_buffer::buffer_sign#0 ] +Uplifting [printf_uint] best 106721 combination zp[2]:50 [ printf_uint::uvalue#0 ] +Uplifting [gotoxy] best 106721 combination +Uplifting [RADIX] best 106721 combination +Uplifting [printf_format_number] best 106721 combination +Uplifting [printf_buffer_number] best 106721 combination +Uplifting [printf_format_string] best 106721 combination +Attempting to uplift remaining variables inzp[1]:45 [ conio_cursor_y ] +Uplifting [] best 106721 combination zp[1]:45 [ conio_cursor_y ] +Attempting to uplift remaining variables inzp[1]:44 [ conio_cursor_x ] +Uplifting [] best 106721 combination zp[1]:44 [ conio_cursor_x ] +Attempting to uplift remaining variables inzp[1]:35 [ utoa::digit#2 utoa::digit#1 ] +Uplifting [utoa] best 106721 combination zp[1]:35 [ utoa::digit#2 utoa::digit#1 ] +Attempting to uplift remaining variables inzp[1]:9 [ mul8s::b#2 mul8s::b#1 mul8s::b#0 ] +Uplifting [mul8s] best 106520 combination reg byte y [ mul8s::b#2 mul8s::b#1 mul8s::b#0 ] +Attempting to uplift remaining variables inzp[1]:8 [ mul8s::a#2 mul8s::a#1 mul8s::a#0 ] +Uplifting [mul8s] best 106520 combination zp[1]:8 [ mul8s::a#2 mul8s::a#1 mul8s::a#0 ] +Attempting to uplift remaining variables inzp[1]:7 [ main::x#2 main::x#1 ] +Uplifting [main] best 106520 combination zp[1]:7 [ main::x#2 main::x#1 ] +Attempting to uplift remaining variables inzp[1]:55 [ main::yd#0 ] +Uplifting [main] best 106520 combination zp[1]:55 [ main::yd#0 ] +Attempting to uplift remaining variables inzp[1]:2 [ main::y#2 main::y#1 ] +Uplifting [main] best 106520 combination zp[1]:2 [ main::y#2 main::y#1 ] +Coalescing zero page register [ zp[2]:46 [ conio_cursor_text ] ] with [ zp[2]:73 [ cputln::$1 ] ] - score: 2 +Coalescing zero page register [ zp[2]:46 [ conio_cursor_text cputln::$1 ] ] with [ zp[2]:77 [ cscroll::$7 ] ] - score: 2 +Coalescing zero page register [ zp[2]:48 [ conio_cursor_color ] ] with [ zp[2]:75 [ cputln::$2 ] ] - score: 2 +Coalescing zero page register [ zp[2]:48 [ conio_cursor_color cputln::$2 ] ] with [ zp[2]:79 [ cscroll::$8 ] ] - score: 2 +Coalescing zero page register [ zp[2]:3 [ main::count#11 main::count#10 main::count#12 main::count#1 ] ] with [ zp[2]:50 [ printf_uint::uvalue#0 ] ] - score: 1 +Coalescing zero page register [ zp[2]:10 [ mul8s::m#4 mul8s::m#5 mul8s::m#1 mul8s::m#0 mul8s::m#2 ] ] with [ zp[2]:58 [ main::$10 ] ] - score: 1 +Coalescing zero page register [ zp[2]:10 [ mul8s::m#4 mul8s::m#5 mul8s::m#1 mul8s::m#0 mul8s::m#2 main::$10 ] ] with [ zp[2]:63 [ mul8u::return#2 ] ] - score: 1 +Coalescing zero page register [ zp[2]:20 [ memset::num#3 ] ] with [ zp[2]:81 [ memset::end#0 ] ] - score: 1 +Coalescing zero page register [ zp[2]:22 [ memset::str#4 ] ] with [ zp[2]:25 [ memset::dst#2 memset::dst#4 memset::dst#1 ] ] - score: 1 +Coalescing zero page register [ zp[2]:27 [ memcpy::source#2 ] ] with [ zp[2]:31 [ memcpy::src#2 memcpy::src#4 memcpy::src#1 ] ] - score: 1 +Coalescing zero page register [ zp[2]:29 [ memcpy::destination#2 ] ] with [ zp[2]:33 [ memcpy::dst#2 memcpy::dst#4 memcpy::dst#1 ] ] - score: 1 +Coalescing zero page register [ zp[2]:36 [ utoa::value#2 utoa::value#6 utoa::value#1 utoa::value#0 ] ] with [ zp[2]:41 [ utoa_append::value#2 utoa_append::value#0 utoa_append::value#1 ] ] - score: 1 +Coalescing zero page register [ zp[2]:36 [ utoa::value#2 utoa::value#6 utoa::value#1 utoa::value#0 utoa_append::value#2 utoa_append::value#0 utoa_append::value#1 ] ] with [ zp[2]:96 [ utoa_append::return#0 ] ] - score: 1 +Coalescing zero page register [ zp[2]:39 [ utoa::buffer#11 utoa::buffer#14 utoa::buffer#4 ] ] with [ zp[2]:87 [ utoa::buffer#3 ] ] - score: 1 +Coalescing zero page register [ zp[2]:39 [ utoa::buffer#11 utoa::buffer#14 utoa::buffer#4 utoa::buffer#3 ] ] with [ zp[2]:92 [ utoa_append::buffer#0 ] ] - score: 1 +Coalescing zero page register [ zp[2]:56 [ main::$9 ] ] with [ zp[2]:60 [ main::dist_sq#0 ] ] - score: 1 +Coalescing zero page register [ zp[2]:90 [ utoa::digit_value#0 ] ] with [ zp[2]:94 [ utoa_append::sub#0 ] ] - score: 1 +Coalescing zero page register [ zp[2]:3 [ main::count#11 main::count#10 main::count#12 main::count#1 printf_uint::uvalue#0 ] ] with [ zp[2]:36 [ utoa::value#2 utoa::value#6 utoa::value#1 utoa::value#0 utoa_append::value#2 utoa_append::value#0 utoa_append::value#1 utoa_append::return#0 ] ] - score: 1 +Coalescing zero page register [ zp[2]:10 [ mul8s::m#4 mul8s::m#5 mul8s::m#1 mul8s::m#0 mul8s::m#2 main::$10 mul8u::return#2 ] ] with [ zp[2]:13 [ mul8u::res#2 mul8u::res#6 mul8u::res#1 ] ] - score: 1 +Coalescing zero page register [ zp[2]:17 [ cputs::s#3 cputs::s#4 cputs::s#0 ] ] with [ zp[2]:15 [ mul8u::mb#2 mul8u::mb#0 mul8u::mb#1 ] ] +Coalescing zero page register [ zp[2]:27 [ memcpy::source#2 memcpy::src#2 memcpy::src#4 memcpy::src#1 ] ] with [ zp[2]:20 [ memset::num#3 memset::end#0 ] ] +Coalescing zero page register [ zp[2]:29 [ memcpy::destination#2 memcpy::dst#2 memcpy::dst#4 memcpy::dst#1 ] ] with [ zp[2]:22 [ memset::str#4 memset::dst#2 memset::dst#4 memset::dst#1 ] ] +Coalescing zero page register [ zp[1]:35 [ utoa::digit#2 utoa::digit#1 ] ] with [ zp[1]:8 [ mul8s::a#2 mul8s::a#1 mul8s::a#0 ] ] +Coalescing zero page register [ zp[1]:44 [ conio_cursor_x ] ] with [ zp[1]:2 [ main::y#2 main::y#1 ] ] +Coalescing zero page register [ zp[1]:45 [ conio_cursor_y ] ] with [ zp[1]:7 [ main::x#2 main::x#1 ] ] +Coalescing zero page register [ zp[2]:56 [ main::$9 main::dist_sq#0 ] ] with [ zp[2]:39 [ utoa::buffer#11 utoa::buffer#14 utoa::buffer#4 utoa::buffer#3 utoa_append::buffer#0 ] ] +Coalescing zero page register [ zp[2]:90 [ utoa::digit_value#0 utoa_append::sub#0 ] ] with [ zp[2]:71 [ cputln::ln_offset#0 ] ] +Coalescing zero page register [ zp[2]:56 [ main::$9 main::dist_sq#0 utoa::buffer#11 utoa::buffer#14 utoa::buffer#4 utoa::buffer#3 utoa_append::buffer#0 ] ] with [ zp[2]:27 [ memcpy::source#2 memcpy::src#2 memcpy::src#4 memcpy::src#1 memset::num#3 memset::end#0 ] ] +Coalescing zero page register [ zp[2]:90 [ utoa::digit_value#0 utoa_append::sub#0 cputln::ln_offset#0 ] ] with [ zp[2]:29 [ memcpy::destination#2 memcpy::dst#2 memcpy::dst#4 memcpy::dst#1 memset::str#4 memset::dst#2 memset::dst#4 memset::dst#1 ] ] +Allocated (was zp[2]:3) zp[2]:2 [ main::count#11 main::count#10 main::count#12 main::count#1 printf_uint::uvalue#0 utoa::value#2 utoa::value#6 utoa::value#1 utoa::value#0 utoa_append::value#2 utoa_append::value#0 utoa_append::value#1 utoa_append::return#0 ] +Allocated (was zp[2]:5) zp[2]:4 [ main::sc#8 main::sc#10 main::sc#1 ] +Allocated (was zp[2]:10) zp[2]:6 [ mul8s::m#4 mul8s::m#5 mul8s::m#1 mul8s::m#0 mul8s::m#2 main::$10 mul8u::return#2 mul8u::res#2 mul8u::res#6 mul8u::res#1 ] +Allocated (was zp[2]:17) zp[2]:8 [ cputs::s#3 cputs::s#4 cputs::s#0 mul8u::mb#2 mul8u::mb#0 mul8u::mb#1 ] +Allocated (was zp[1]:35) zp[1]:10 [ utoa::digit#2 utoa::digit#1 mul8s::a#2 mul8s::a#1 mul8s::a#0 ] +Allocated (was zp[1]:44) zp[1]:11 [ conio_cursor_x main::y#2 main::y#1 ] +Allocated (was zp[1]:45) zp[1]:12 [ conio_cursor_y main::x#2 main::x#1 ] +Allocated (was zp[2]:46) zp[2]:13 [ conio_cursor_text cputln::$1 cscroll::$7 ] +Allocated (was zp[2]:48) zp[2]:15 [ conio_cursor_color cputln::$2 cscroll::$8 ] +Allocated (was zp[1]:55) zp[1]:17 [ main::yd#0 ] +Allocated (was zp[2]:56) zp[2]:18 [ main::$9 main::dist_sq#0 utoa::buffer#11 utoa::buffer#14 utoa::buffer#4 utoa::buffer#3 utoa_append::buffer#0 memcpy::source#2 memcpy::src#2 memcpy::src#4 memcpy::src#1 memset::num#3 memset::end#0 ] +Allocated (was zp[2]:83) zp[2]:20 [ memcpy::src_end#0 ] +Allocated (was zp[2]:90) zp[2]:22 [ utoa::digit_value#0 utoa_append::sub#0 cputln::ln_offset#0 memcpy::destination#2 memcpy::dst#2 memcpy::dst#4 memcpy::dst#1 memset::str#4 memset::dst#2 memset::dst#4 memset::dst#1 ] + +ASSEMBLER BEFORE OPTIMIZATION + // File Comments +// Plot a r=9 circle on the screen using chars - count how many chars are used + // Upstart +.pc = $801 "Basic" +:BasicUpstart(__bbegin) +.pc = $80d "Program" + // Global Constants & labels + // The default text color + .const CONIO_TEXTCOLOR_DEFAULT = $e + .const OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_DIGITS = 1 + .const SIZEOF_STRUCT_PRINTF_BUFFER_NUMBER = $c + // The screen width + // The screen height + // The screen bytes + // The text screen address + .label CONIO_SCREEN_TEXT = $400 + // The color screen address + .label CONIO_SCREEN_COLORS = $d800 + .label SCREEN = $400 + .label conio_cursor_x = $b + .label conio_cursor_y = $c + .label conio_cursor_text = $d + .label conio_cursor_color = $f + // @begin +__bbegin: + jmp __b1 + // @1 +__b1: + // [1] (byte) conio_cursor_x ← (byte) 0 -- vbuz1=vbuc1 + // The current cursor x-position + lda #0 + sta.z conio_cursor_x + // [2] (byte) conio_cursor_y ← (byte) 0 -- vbuz1=vbuc1 + // The current cursor y-position + lda #0 + sta.z conio_cursor_y + // [3] (byte*) conio_cursor_text ← (const nomodify byte*) CONIO_SCREEN_TEXT -- pbuz1=pbuc1 + // The current cursor address + lda #CONIO_SCREEN_TEXT + sta.z conio_cursor_text+1 + // [4] (byte*) conio_cursor_color ← (const nomodify byte*) CONIO_SCREEN_COLORS -- pbuz1=pbuc1 + // The current cursor address + lda #CONIO_SCREEN_COLORS + sta.z conio_cursor_color+1 + // [5] phi from @1 to @2 [phi:@1->@2] +__b2_from___b1: + jmp __b2 + // @2 +__b2: + // [6] call main + // [8] phi from @2 to main [phi:@2->main] +main_from___b2: + jsr main + // [7] phi from @2 to @end [phi:@2->@end] +__bend_from___b2: + jmp __bend + // @end +__bend: + // main +main: { + .label __9 = $12 + .label __10 = 6 + .label yd = $11 + .label dist_sq = $12 + .label y = $b + .label sc = 4 + .label x = $c + .label count = 2 + // [9] call memset + // [114] phi from main to memset [phi:main->memset] + memset_from_main: + // [114] phi (byte) memset::c#5 = (byte) ' ' [phi:main->memset#0] -- vbuxx=vbuc1 + ldx #' ' + // [114] phi (void*) memset::str#4 = (void*)(const nomodify byte*) SCREEN [phi:main->memset#1] -- pvoz1=pvoc1 + lda #SCREEN + sta.z memset.str+1 + // [114] phi (word) memset::num#3 = (word) $3e8 [phi:main->memset#2] -- vwuz1=vwuc1 + lda #<$3e8 + sta.z memset.num + lda #>$3e8 + sta.z memset.num+1 + jsr memset + // [10] phi from main to main::@1 [phi:main->main::@1] + __b1_from_main: + // [10] phi (byte*) main::sc#8 = (const nomodify byte*) SCREEN [phi:main->main::@1#0] -- pbuz1=pbuc1 + lda #SCREEN + sta.z sc+1 + // [10] phi (word) main::count#11 = (word) 0 [phi:main->main::@1#1] -- vwuz1=vwuc1 + lda #<0 + sta.z count + lda #>0 + sta.z count+1 + // [10] phi (byte) main::y#2 = (byte) 0 [phi:main->main::@1#2] -- vbuz1=vbuc1 + lda #0 + sta.z y + jmp __b1 + // main::@1 + __b1: + // [11] if((byte) main::y#2<(byte) $19) goto main::@3 -- vbuz1_lt_vbuc1_then_la1 + lda.z y + cmp #$19 + bcc __b3_from___b1 + // [12] phi from main::@1 to main::@2 [phi:main::@1->main::@2] + __b2_from___b1: + jmp __b2 + // main::@2 + __b2: + // [13] call gotoxy + // [175] phi from main::@2 to gotoxy [phi:main::@2->gotoxy] + gotoxy_from___b2: + jsr gotoxy + jmp __b8 + // main::@8 + __b8: + // [14] (word) printf_uint::uvalue#0 ← (word) main::count#11 + // [15] call printf_uint + // [133] phi from main::@8 to printf_uint [phi:main::@8->printf_uint] + printf_uint_from___b8: + jsr printf_uint + // [16] phi from main::@8 to main::@9 [phi:main::@8->main::@9] + __b9_from___b8: + jmp __b9 + // main::@9 + __b9: + // [17] call cputs + // [68] phi from main::@9 to cputs [phi:main::@9->cputs] + cputs_from___b9: + // [68] phi (to_nomodify byte*) cputs::s#4 = (const byte*) main::s [phi:main::@9->cputs#0] -- pbuz1=pbuc1 + lda #s + sta.z cputs.s+1 + jsr cputs + jmp __breturn + // main::@return + __breturn: + // [18] return + rts + // [19] phi from main::@1 to main::@3 [phi:main::@1->main::@3] + __b3_from___b1: + // [19] phi (word) main::count#10 = (word) main::count#11 [phi:main::@1->main::@3#0] -- register_copy + // [19] phi (byte*) main::sc#10 = (byte*) main::sc#8 [phi:main::@1->main::@3#1] -- register_copy + // [19] phi (byte) main::x#2 = (byte) 0 [phi:main::@1->main::@3#2] -- vbuz1=vbuc1 + lda #0 + sta.z x + jmp __b3 + // main::@3 + __b3: + // [20] if((byte) main::x#2<(byte) $28) goto main::@4 -- vbuz1_lt_vbuc1_then_la1 + lda.z x + cmp #$28 + bcc __b4 + jmp __b5 + // main::@5 + __b5: + // [21] (byte) main::y#1 ← ++ (byte) main::y#2 -- vbuz1=_inc_vbuz1 + inc.z y + // [10] phi from main::@5 to main::@1 [phi:main::@5->main::@1] + __b1_from___b5: + // [10] phi (byte*) main::sc#8 = (byte*) main::sc#10 [phi:main::@5->main::@1#0] -- register_copy + // [10] phi (word) main::count#11 = (word) main::count#10 [phi:main::@5->main::@1#1] -- register_copy + // [10] phi (byte) main::y#2 = (byte) main::y#1 [phi:main::@5->main::@1#2] -- register_copy + jmp __b1 + // main::@4 + __b4: + // [22] (signed byte~) main::$5 ← (signed byte)(byte) main::x#2 << (byte) 1 -- vbsaa=vbsz1_rol_1 + lda.z x + asl + // [23] (signed byte) main::xd#0 ← (signed byte~) main::$5 - (signed byte) $27 -- vbsxx=vbsaa_minus_vbsc1 + tax + axs #$27 + // [24] (signed byte~) main::$7 ← (signed byte)(byte) main::y#2 << (byte) 1 -- vbsaa=vbsz1_rol_1 + lda.z y + asl + // [25] (signed byte) main::yd#0 ← (signed byte~) main::$7 - (signed byte) $18 -- vbsz1=vbsaa_minus_vbsc1 + sec + sbc #$18 + sta.z yd + // [26] (signed byte) mul8s::a#0 ← (signed byte) main::xd#0 -- vbsz1=vbsxx + stx.z mul8s.a + // [27] (signed byte) mul8s::b#0 ← (signed byte) main::xd#0 -- vbsyy=vbsxx + txa + tay + // [28] call mul8s + // [41] phi from main::@4 to mul8s [phi:main::@4->mul8s] + mul8s_from___b4: + // [41] phi (signed byte) mul8s::b#2 = (signed byte) mul8s::b#0 [phi:main::@4->mul8s#0] -- register_copy + // [41] phi (signed byte) mul8s::a#2 = (signed byte) mul8s::a#0 [phi:main::@4->mul8s#1] -- register_copy + jsr mul8s + jmp __b10 + // main::@10 + __b10: + // [29] (signed word~) main::$9 ← (signed word)(word) mul8s::m#4 -- vwsz1=vwsz2 + lda.z mul8s.m + sta.z __9 + lda.z mul8s.m+1 + sta.z __9+1 + // [30] (signed byte) mul8s::a#1 ← (signed byte) main::yd#0 -- vbsz1=vbsz2 + lda.z yd + sta.z mul8s.a + // [31] (signed byte) mul8s::b#1 ← (signed byte) main::yd#0 -- vbsyy=vbsz1 + ldy.z yd + // [32] call mul8s + // [41] phi from main::@10 to mul8s [phi:main::@10->mul8s] + mul8s_from___b10: + // [41] phi (signed byte) mul8s::b#2 = (signed byte) mul8s::b#1 [phi:main::@10->mul8s#0] -- register_copy + // [41] phi (signed byte) mul8s::a#2 = (signed byte) mul8s::a#1 [phi:main::@10->mul8s#1] -- register_copy + jsr mul8s + jmp __b11 + // main::@11 + __b11: + // [33] (signed word~) main::$10 ← (signed word)(word) mul8s::m#4 + // [34] (signed word) main::dist_sq#0 ← (signed word~) main::$9 + (signed word~) main::$10 -- vwsz1=vwsz1_plus_vwsz2 + lda.z dist_sq + clc + adc.z __10 + sta.z dist_sq + lda.z dist_sq+1 + adc.z __10+1 + sta.z dist_sq+1 + // [35] if((signed word) main::dist_sq#0>=(signed word)(number) 2*(number) 9*(number) 2*(number) 9) goto main::@6 -- vwsz1_ge_vwsc1_then_la1 + lda.z dist_sq + cmp #<2*9*2*9 + lda.z dist_sq+1 + sbc #>2*9*2*9 + bvc !+ + eor #$80 + !: + bpl __b6_from___b11 + jmp __b7 + // main::@7 + __b7: + // [36] *((byte*) main::sc#10) ← (byte) '*' -- _deref_pbuz1=vbuc1 + lda #'*' + ldy #0 + sta (sc),y + // [37] (word) main::count#1 ← ++ (word) main::count#10 -- vwuz1=_inc_vwuz1 + inc.z count + bne !+ + inc.z count+1 + !: + // [38] phi from main::@11 main::@7 to main::@6 [phi:main::@11/main::@7->main::@6] + __b6_from___b11: + __b6_from___b7: + // [38] phi (word) main::count#12 = (word) main::count#10 [phi:main::@11/main::@7->main::@6#0] -- register_copy + jmp __b6 + // main::@6 + __b6: + // [39] (byte*) main::sc#1 ← ++ (byte*) main::sc#10 -- pbuz1=_inc_pbuz1 + inc.z sc + bne !+ + inc.z sc+1 + !: + // [40] (byte) main::x#1 ← ++ (byte) main::x#2 -- vbuz1=_inc_vbuz1 + inc.z x + // [19] phi from main::@6 to main::@3 [phi:main::@6->main::@3] + __b3_from___b6: + // [19] phi (word) main::count#10 = (word) main::count#12 [phi:main::@6->main::@3#0] -- register_copy + // [19] phi (byte*) main::sc#10 = (byte*) main::sc#1 [phi:main::@6->main::@3#1] -- register_copy + // [19] phi (byte) main::x#2 = (byte) main::x#1 [phi:main::@6->main::@3#2] -- register_copy + jmp __b3 + s: .text " chars" + .byte 0 +} + // mul8s +// Multiply of two signed chars to a signed int +// Fixes offsets introduced by using unsigned multiplication +// mul8s(signed byte zp($a) a, signed byte register(Y) b) +mul8s: { + .label m = 6 + .label a = $a + // [42] (byte) mul8u::a#1 ← (byte)(signed byte) mul8s::a#2 -- vbuxx=vbuz1 + ldx.z a + // [43] (byte) mul8u::b#0 ← (byte)(signed byte) mul8s::b#2 -- vbuaa=vbuyy + tya + // [44] call mul8u + jsr mul8u + // [45] (word) mul8u::return#2 ← (word) mul8u::res#2 + jmp __b5 + // mul8s::@5 + __b5: + // [46] (word) mul8s::m#0 ← (word) mul8u::return#2 + // [47] if((signed byte) mul8s::a#2>=(signed byte) 0) goto mul8s::@1 -- vbsz1_ge_0_then_la1 + lda.z a + cmp #0 + bpl __b1_from___b5 + jmp __b3 + // mul8s::@3 + __b3: + // [48] (byte~) mul8s::$6 ← > (word) mul8s::m#0 -- vbuaa=_hi_vwuz1 + lda.z m+1 + // [49] (byte~) mul8s::$11 ← (byte~) mul8s::$6 - (byte)(signed byte) mul8s::b#2 -- vbuaa=vbuaa_minus_vbuyy + sty.z $ff + sec + sbc.z $ff + // [50] (word) mul8s::m#1 ← (word) mul8s::m#0 hi= (byte~) mul8s::$11 -- vwuz1=vwuz1_sethi_vbuaa + sta.z m+1 + // [51] phi from mul8s::@3 mul8s::@5 to mul8s::@1 [phi:mul8s::@3/mul8s::@5->mul8s::@1] + __b1_from___b3: + __b1_from___b5: + // [51] phi (word) mul8s::m#5 = (word) mul8s::m#1 [phi:mul8s::@3/mul8s::@5->mul8s::@1#0] -- register_copy + jmp __b1 + // mul8s::@1 + __b1: + // [52] if((signed byte) mul8s::b#2>=(signed byte) 0) goto mul8s::@2 -- vbsyy_ge_0_then_la1 + cpy #0 + bpl __b2_from___b1 + jmp __b4 + // mul8s::@4 + __b4: + // [53] (byte~) mul8s::$9 ← > (word) mul8s::m#5 -- vbuaa=_hi_vwuz1 + lda.z m+1 + // [54] (byte~) mul8s::$12 ← (byte~) mul8s::$9 - (byte)(signed byte) mul8s::a#2 -- vbuaa=vbuaa_minus_vbuz1 + sec + sbc.z a + // [55] (word) mul8s::m#2 ← (word) mul8s::m#5 hi= (byte~) mul8s::$12 -- vwuz1=vwuz1_sethi_vbuaa + sta.z m+1 + // [56] phi from mul8s::@1 mul8s::@4 to mul8s::@2 [phi:mul8s::@1/mul8s::@4->mul8s::@2] + __b2_from___b1: + __b2_from___b4: + // [56] phi (word) mul8s::m#4 = (word) mul8s::m#5 [phi:mul8s::@1/mul8s::@4->mul8s::@2#0] -- register_copy + jmp __b2 + // mul8s::@2 + __b2: + jmp __breturn + // mul8s::@return + __breturn: + // [57] return + rts +} + // mul8u +// Perform binary multiplication of two unsigned 8-bit chars into a 16-bit unsigned int +// mul8u(byte register(X) a, byte register(A) b) +mul8u: { + .label mb = 8 + .label res = 6 + .label return = 6 + // [58] (word) mul8u::mb#0 ← (word)(byte) mul8u::b#0 -- vwuz1=_word_vbuaa + sta.z mb + lda #0 + sta.z mb+1 + // [59] phi from mul8u to mul8u::@1 [phi:mul8u->mul8u::@1] + __b1_from_mul8u: + // [59] phi (word) mul8u::mb#2 = (word) mul8u::mb#0 [phi:mul8u->mul8u::@1#0] -- register_copy + // [59] phi (word) mul8u::res#2 = (word) 0 [phi:mul8u->mul8u::@1#1] -- vwuz1=vwuc1 + lda #<0 + sta.z res + lda #>0 + sta.z res+1 + // [59] phi (byte) mul8u::a#2 = (byte) mul8u::a#1 [phi:mul8u->mul8u::@1#2] -- register_copy + jmp __b1 + // mul8u::@1 + __b1: + // [60] if((byte) mul8u::a#2!=(byte) 0) goto mul8u::@2 -- vbuxx_neq_0_then_la1 + cpx #0 + bne __b2 + jmp __breturn + // mul8u::@return + __breturn: + // [61] return + rts + // mul8u::@2 + __b2: + // [62] (byte~) mul8u::$1 ← (byte) mul8u::a#2 & (byte) 1 -- vbuaa=vbuxx_band_vbuc1 + txa + and #1 + // [63] if((byte~) mul8u::$1==(byte) 0) goto mul8u::@3 -- vbuaa_eq_0_then_la1 + cmp #0 + beq __b3_from___b2 + jmp __b4 + // mul8u::@4 + __b4: + // [64] (word) mul8u::res#1 ← (word) mul8u::res#2 + (word) mul8u::mb#2 -- vwuz1=vwuz1_plus_vwuz2 + lda.z res + clc + adc.z mb + sta.z res + lda.z res+1 + adc.z mb+1 + sta.z res+1 + // [65] phi from mul8u::@2 mul8u::@4 to mul8u::@3 [phi:mul8u::@2/mul8u::@4->mul8u::@3] + __b3_from___b2: + __b3_from___b4: + // [65] phi (word) mul8u::res#6 = (word) mul8u::res#2 [phi:mul8u::@2/mul8u::@4->mul8u::@3#0] -- register_copy + jmp __b3 + // mul8u::@3 + __b3: + // [66] (byte) mul8u::a#0 ← (byte) mul8u::a#2 >> (byte) 1 -- vbuxx=vbuxx_ror_1 + txa + lsr + tax + // [67] (word) mul8u::mb#1 ← (word) mul8u::mb#2 << (byte) 1 -- vwuz1=vwuz1_rol_1 + asl.z mb + rol.z mb+1 + // [59] phi from mul8u::@3 to mul8u::@1 [phi:mul8u::@3->mul8u::@1] + __b1_from___b3: + // [59] phi (word) mul8u::mb#2 = (word) mul8u::mb#1 [phi:mul8u::@3->mul8u::@1#0] -- register_copy + // [59] phi (word) mul8u::res#2 = (word) mul8u::res#6 [phi:mul8u::@3->mul8u::@1#1] -- register_copy + // [59] phi (byte) mul8u::a#2 = (byte) mul8u::a#0 [phi:mul8u::@3->mul8u::@1#2] -- register_copy + jmp __b1 +} + // cputs +// Output a NUL-terminated string at the current cursor position +// cputs(byte* zp(8) s) +cputs: { + .label s = 8 + // [69] phi from cputs cputs::@2 to cputs::@1 [phi:cputs/cputs::@2->cputs::@1] + __b1_from_cputs: + __b1_from___b2: + // [69] phi (to_nomodify byte*) cputs::s#3 = (to_nomodify byte*) cputs::s#4 [phi:cputs/cputs::@2->cputs::@1#0] -- register_copy + jmp __b1 + // cputs::@1 + __b1: + // [70] (byte) cputs::c#1 ← *((to_nomodify byte*) cputs::s#3) -- vbuaa=_deref_pbuz1 + ldy #0 + lda (s),y + // [71] (to_nomodify byte*) cputs::s#0 ← ++ (to_nomodify byte*) cputs::s#3 -- pbuz1=_inc_pbuz1 + inc.z s + bne !+ + inc.z s+1 + !: + // [72] if((byte) 0!=(byte) cputs::c#1) goto cputs::@2 -- vbuc1_neq_vbuaa_then_la1 + cmp #0 + bne __b2 + jmp __breturn + // cputs::@return + __breturn: + // [73] return + rts + // cputs::@2 + __b2: + // [74] (byte) cputc::c#0 ← (byte) cputs::c#1 + // [75] call cputc + // [76] phi from cputs::@2 to cputc [phi:cputs::@2->cputc] + cputc_from___b2: + // [76] phi (byte) cputc::c#3 = (byte) cputc::c#0 [phi:cputs::@2->cputc#0] -- register_copy + jsr cputc + jmp __b1_from___b2 +} + // cputc +// Output one character at the current cursor position +// Moves the cursor forward. Scrolls the entire screen if needed +// cputc(byte register(A) c) +cputc: { + // [77] if((byte) cputc::c#3==(byte) ' ') goto cputc::@1 -- vbuaa_eq_vbuc1_then_la1 + cmp #'\n' + beq __b1_from_cputc + jmp __b2 + // cputc::@2 + __b2: + // [78] *((byte*) conio_cursor_text) ← (byte) cputc::c#3 -- _deref_pbuz1=vbuaa + ldy #0 + sta (conio_cursor_text),y + // [79] (byte*) conio_cursor_text ← ++ (byte*) conio_cursor_text -- pbuz1=_inc_pbuz1 + inc.z conio_cursor_text + bne !+ + inc.z conio_cursor_text+1 + !: + // [80] *((byte*) conio_cursor_color) ← (const nomodify byte) CONIO_TEXTCOLOR_DEFAULT -- _deref_pbuz1=vbuc1 + lda #CONIO_TEXTCOLOR_DEFAULT + ldy #0 + sta (conio_cursor_color),y + // [81] (byte*) conio_cursor_color ← ++ (byte*) conio_cursor_color -- pbuz1=_inc_pbuz1 + inc.z conio_cursor_color + bne !+ + inc.z conio_cursor_color+1 + !: + // [82] (byte) conio_cursor_x ← ++ (byte) conio_cursor_x -- vbuz1=_inc_vbuz1 + inc.z conio_cursor_x + // [83] if((byte) conio_cursor_x!=(byte) $28) goto cputc::@return -- vbuz1_neq_vbuc1_then_la1 + lda #$28 + cmp.z conio_cursor_x + bne __breturn + jmp __b3 + // cputc::@3 + __b3: + // [84] (byte) conio_cursor_x ← (byte) 0 -- vbuz1=vbuc1 + lda #0 + sta.z conio_cursor_x + // [85] (byte) conio_cursor_y ← ++ (byte) conio_cursor_y -- vbuz1=_inc_vbuz1 + inc.z conio_cursor_y + // [86] call cscroll + jsr cscroll + jmp __breturn + // cputc::@return + __breturn: + // [87] return + rts + // [88] phi from cputc to cputc::@1 [phi:cputc->cputc::@1] + __b1_from_cputc: + jmp __b1 + // cputc::@1 + __b1: + // [89] call cputln + jsr cputln + jmp __breturn +} + // cputln +// Print a newline +cputln: { + .label __1 = $d + .label __2 = $f + .label ln_offset = $16 + // [90] (word) cputln::ln_offset#0 ← (byte) $28 - (byte) conio_cursor_x -- vwuz1=vbuc1_minus_vbuz2 + sec + lda #$28 + sbc.z conio_cursor_x + sta.z ln_offset + lda #0 + sbc #0 + sta.z ln_offset+1 + // [91] (byte*~) cputln::$1 ← (byte*) conio_cursor_text + (word) cputln::ln_offset#0 -- pbuz1=pbuz1_plus_vwuz2 + lda.z __1 + clc + adc.z ln_offset + sta.z __1 + lda.z __1+1 + adc.z ln_offset+1 + sta.z __1+1 + // [92] (byte*) conio_cursor_text ← (byte*~) cputln::$1 + // [93] (byte*~) cputln::$2 ← (byte*) conio_cursor_color + (word) cputln::ln_offset#0 -- pbuz1=pbuz1_plus_vwuz2 + lda.z __2 + clc + adc.z ln_offset + sta.z __2 + lda.z __2+1 + adc.z ln_offset+1 + sta.z __2+1 + // [94] (byte*) conio_cursor_color ← (byte*~) cputln::$2 + // [95] (byte) conio_cursor_x ← (byte) 0 -- vbuz1=vbuc1 + lda #0 + sta.z conio_cursor_x + // [96] (byte) conio_cursor_y ← ++ (byte) conio_cursor_y -- vbuz1=_inc_vbuz1 + inc.z conio_cursor_y + // [97] call cscroll + jsr cscroll + jmp __breturn + // cputln::@return + __breturn: + // [98] return + rts +} + // cscroll +// Scroll the entire screen if the cursor is beyond the last line +cscroll: { + .label __7 = $d + .label __8 = $f + // [99] if((byte) conio_cursor_y!=(byte) $19) goto cscroll::@return -- vbuz1_neq_vbuc1_then_la1 + lda #$19 + cmp.z conio_cursor_y + bne __breturn + // [100] phi from cscroll to cscroll::@1 [phi:cscroll->cscroll::@1] + __b1_from_cscroll: + jmp __b1 + // cscroll::@1 + __b1: + // [101] call memcpy + // [123] phi from cscroll::@1 to memcpy [phi:cscroll::@1->memcpy] + memcpy_from___b1: + // [123] phi (void*) memcpy::destination#2 = (void*)(const nomodify byte*) CONIO_SCREEN_TEXT [phi:cscroll::@1->memcpy#0] -- pvoz1=pvoc1 + lda #CONIO_SCREEN_TEXT + sta.z memcpy.destination+1 + // [123] phi (void*) memcpy::source#2 = (void*)(const nomodify byte*) CONIO_SCREEN_TEXT+(byte) $28 [phi:cscroll::@1->memcpy#1] -- pvoz1=pvoc1 + lda #CONIO_SCREEN_TEXT+$28 + sta.z memcpy.source+1 + jsr memcpy + // [102] phi from cscroll::@1 to cscroll::@2 [phi:cscroll::@1->cscroll::@2] + __b2_from___b1: + jmp __b2 + // cscroll::@2 + __b2: + // [103] call memcpy + // [123] phi from cscroll::@2 to memcpy [phi:cscroll::@2->memcpy] + memcpy_from___b2: + // [123] phi (void*) memcpy::destination#2 = (void*)(const nomodify byte*) CONIO_SCREEN_COLORS [phi:cscroll::@2->memcpy#0] -- pvoz1=pvoc1 + lda #CONIO_SCREEN_COLORS + sta.z memcpy.destination+1 + // [123] phi (void*) memcpy::source#2 = (void*)(const nomodify byte*) CONIO_SCREEN_COLORS+(byte) $28 [phi:cscroll::@2->memcpy#1] -- pvoz1=pvoc1 + lda #CONIO_SCREEN_COLORS+$28 + sta.z memcpy.source+1 + jsr memcpy + // [104] phi from cscroll::@2 to cscroll::@3 [phi:cscroll::@2->cscroll::@3] + __b3_from___b2: + jmp __b3 + // cscroll::@3 + __b3: + // [105] call memset + // [114] phi from cscroll::@3 to memset [phi:cscroll::@3->memset] + memset_from___b3: + // [114] phi (byte) memset::c#5 = (byte) ' ' [phi:cscroll::@3->memset#0] -- vbuxx=vbuc1 + ldx #' ' + // [114] phi (void*) memset::str#4 = (void*)(const nomodify byte*) CONIO_SCREEN_TEXT+(word)(number) $19*(number) $28-(byte) $28 [phi:cscroll::@3->memset#1] -- pvoz1=pvoc1 + lda #CONIO_SCREEN_TEXT+$19*$28-$28 + sta.z memset.str+1 + // [114] phi (word) memset::num#3 = (byte) $28 [phi:cscroll::@3->memset#2] -- vwuz1=vbuc1 + lda #<$28 + sta.z memset.num + lda #>$28 + sta.z memset.num+1 + jsr memset + // [106] phi from cscroll::@3 to cscroll::@4 [phi:cscroll::@3->cscroll::@4] + __b4_from___b3: + jmp __b4 + // cscroll::@4 + __b4: + // [107] call memset + // [114] phi from cscroll::@4 to memset [phi:cscroll::@4->memset] + memset_from___b4: + // [114] phi (byte) memset::c#5 = (const nomodify byte) CONIO_TEXTCOLOR_DEFAULT [phi:cscroll::@4->memset#0] -- vbuxx=vbuc1 + ldx #CONIO_TEXTCOLOR_DEFAULT + // [114] phi (void*) memset::str#4 = (void*)(const nomodify byte*) CONIO_SCREEN_COLORS+(word)(number) $19*(number) $28-(byte) $28 [phi:cscroll::@4->memset#1] -- pvoz1=pvoc1 + lda #CONIO_SCREEN_COLORS+$19*$28-$28 + sta.z memset.str+1 + // [114] phi (word) memset::num#3 = (byte) $28 [phi:cscroll::@4->memset#2] -- vwuz1=vbuc1 + lda #<$28 + sta.z memset.num + lda #>$28 + sta.z memset.num+1 + jsr memset + jmp __b5 + // cscroll::@5 + __b5: + // [108] (byte*~) cscroll::$7 ← (byte*) conio_cursor_text - (byte) $28 -- pbuz1=pbuz1_minus_vwuc1 + lda.z __7 + sec + sbc #<$28 + sta.z __7 + lda.z __7+1 + sbc #>$28 + sta.z __7+1 + // [109] (byte*) conio_cursor_text ← (byte*~) cscroll::$7 + // [110] (byte*~) cscroll::$8 ← (byte*) conio_cursor_color - (byte) $28 -- pbuz1=pbuz1_minus_vwuc1 + lda.z __8 + sec + sbc #<$28 + sta.z __8 + lda.z __8+1 + sbc #>$28 + sta.z __8+1 + // [111] (byte*) conio_cursor_color ← (byte*~) cscroll::$8 + // [112] (byte) conio_cursor_y ← -- (byte) conio_cursor_y -- vbuz1=_dec_vbuz1 + dec.z conio_cursor_y + jmp __breturn + // cscroll::@return + __breturn: + // [113] 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(void* zp($16) str, byte register(X) c, word zp($12) num) +memset: { + .label end = $12 + .label dst = $16 + .label num = $12 + .label str = $16 + // [115] if((word) memset::num#3<=(byte) 0) goto memset::@return -- vwuz1_le_0_then_la1 + lda.z num + bne !+ + lda.z num+1 + beq __breturn + !: + jmp __b1 + // memset::@1 + __b1: + // [116] (byte*) memset::end#0 ← (byte*)(void*) memset::str#4 + (word) memset::num#3 -- pbuz1=pbuz2_plus_vwuz1 + lda.z end + clc + adc.z str + sta.z end + lda.z end+1 + adc.z str+1 + sta.z end+1 + // [117] (byte*) memset::dst#4 ← (byte*)(void*) memset::str#4 + // [118] phi from memset::@1 memset::@3 to memset::@2 [phi:memset::@1/memset::@3->memset::@2] + __b2_from___b1: + __b2_from___b3: + // [118] phi (byte*) memset::dst#2 = (byte*) memset::dst#4 [phi:memset::@1/memset::@3->memset::@2#0] -- register_copy + jmp __b2 + // memset::@2 + __b2: + // [119] if((byte*) memset::dst#2!=(byte*) memset::end#0) goto memset::@3 -- pbuz1_neq_pbuz2_then_la1 + lda.z dst+1 + cmp.z end+1 + bne __b3 + lda.z dst + cmp.z end + bne __b3 + jmp __breturn + // memset::@return + __breturn: + // [120] return + rts + // memset::@3 + __b3: + // [121] *((byte*) memset::dst#2) ← (byte) memset::c#5 -- _deref_pbuz1=vbuxx + txa + ldy #0 + sta (dst),y + // [122] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2 -- pbuz1=_inc_pbuz1 + inc.z dst + bne !+ + inc.z dst+1 + !: + jmp __b2_from___b3 +} + // memcpy +// Copy block of memory (forwards) +// Copies the values of num bytes from the location pointed to by source directly to the memory block pointed to by destination. +// memcpy(void* zp($16) destination, void* zp($12) source) +memcpy: { + .label src_end = $14 + .label dst = $16 + .label src = $12 + .label source = $12 + .label destination = $16 + // [124] (byte*) memcpy::src_end#0 ← (byte*)(void*) memcpy::source#2 + (word)(number) $19*(number) $28-(number) $28 -- pbuz1=pbuz2_plus_vwuc1 + lda.z source + clc + adc #<$19*$28-$28 + sta.z src_end + lda.z source+1 + adc #>$19*$28-$28 + sta.z src_end+1 + // [125] (byte*) memcpy::src#4 ← (byte*)(void*) memcpy::source#2 + // [126] (byte*) memcpy::dst#4 ← (byte*)(void*) memcpy::destination#2 + // [127] phi from memcpy memcpy::@2 to memcpy::@1 [phi:memcpy/memcpy::@2->memcpy::@1] + __b1_from_memcpy: + __b1_from___b2: + // [127] phi (byte*) memcpy::dst#2 = (byte*) memcpy::dst#4 [phi:memcpy/memcpy::@2->memcpy::@1#0] -- register_copy + // [127] phi (byte*) memcpy::src#2 = (byte*) memcpy::src#4 [phi:memcpy/memcpy::@2->memcpy::@1#1] -- register_copy + jmp __b1 + // memcpy::@1 + __b1: + // [128] if((byte*) memcpy::src#2!=(byte*) memcpy::src_end#0) goto memcpy::@2 -- pbuz1_neq_pbuz2_then_la1 + lda.z src+1 + cmp.z src_end+1 + bne __b2 + lda.z src + cmp.z src_end + bne __b2 + jmp __breturn + // memcpy::@return + __breturn: + // [129] return + rts + // memcpy::@2 + __b2: + // [130] *((byte*) memcpy::dst#2) ← *((byte*) memcpy::src#2) -- _deref_pbuz1=_deref_pbuz2 + ldy #0 + lda (src),y + ldy #0 + sta (dst),y + // [131] (byte*) memcpy::dst#1 ← ++ (byte*) memcpy::dst#2 -- pbuz1=_inc_pbuz1 + inc.z dst + bne !+ + inc.z dst+1 + !: + // [132] (byte*) memcpy::src#1 ← ++ (byte*) memcpy::src#2 -- pbuz1=_inc_pbuz1 + inc.z src + bne !+ + inc.z src+1 + !: + jmp __b1_from___b2 +} + // printf_uint +// Print an unsigned int using a specific format +// printf_uint(word zp(2) uvalue) +printf_uint: { + .label uvalue = 2 + jmp __b1 + // printf_uint::@1 + __b1: + // [134] *((byte*)&(struct printf_buffer_number) printf_buffer) ← (byte) 0 -- _deref_pbuc1=vbuc2 + // Handle any sign + lda #0 + sta printf_buffer + // [135] (word) utoa::value#1 ← (word) printf_uint::uvalue#0 + // [136] call utoa + // Format number into buffer + // [147] phi from printf_uint::@1 to utoa [phi:printf_uint::@1->utoa] + utoa_from___b1: + jsr utoa + jmp __b2 + // printf_uint::@2 + __b2: + // [137] (byte) printf_number_buffer::buffer_sign#0 ← *((byte*)&(struct printf_buffer_number) printf_buffer) -- vbuaa=_deref_pbuc1 + lda printf_buffer + // [138] call printf_number_buffer + // Print using format + // [140] phi from printf_uint::@2 to printf_number_buffer [phi:printf_uint::@2->printf_number_buffer] + printf_number_buffer_from___b2: + jsr printf_number_buffer + jmp __breturn + // printf_uint::@return + __breturn: + // [139] return + rts +} + // printf_number_buffer +// Print the contents of the number buffer using a specific format. +// This handles minimum length, zero-filling, and left/right justification from the format +// printf_number_buffer(byte register(A) buffer_sign) +printf_number_buffer: { + .label buffer_digits = printf_buffer+OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_DIGITS + jmp __b1 + // printf_number_buffer::@1 + __b1: + // [141] if((byte) 0==(byte) printf_number_buffer::buffer_sign#0) goto printf_number_buffer::@2 -- vbuc1_eq_vbuaa_then_la1 + cmp #0 + beq __b2_from___b1 + jmp __b3 + // printf_number_buffer::@3 + __b3: + // [142] (byte) cputc::c#2 ← (byte) printf_number_buffer::buffer_sign#0 + // [143] call cputc + // [76] phi from printf_number_buffer::@3 to cputc [phi:printf_number_buffer::@3->cputc] + cputc_from___b3: + // [76] phi (byte) cputc::c#3 = (byte) cputc::c#2 [phi:printf_number_buffer::@3->cputc#0] -- register_copy + jsr cputc + // [144] phi from printf_number_buffer::@1 printf_number_buffer::@3 to printf_number_buffer::@2 [phi:printf_number_buffer::@1/printf_number_buffer::@3->printf_number_buffer::@2] + __b2_from___b1: + __b2_from___b3: + jmp __b2 + // printf_number_buffer::@2 + __b2: + // [145] call cputs + // [68] phi from printf_number_buffer::@2 to cputs [phi:printf_number_buffer::@2->cputs] + cputs_from___b2: + // [68] phi (to_nomodify byte*) cputs::s#4 = (const byte*) printf_number_buffer::buffer_digits#0 [phi:printf_number_buffer::@2->cputs#0] -- pbuz1=pbuc1 + lda #buffer_digits + sta.z cputs.s+1 + jsr cputs + jmp __breturn + // printf_number_buffer::@return + __breturn: + // [146] return + rts +} + // utoa +// Converts unsigned number value to a string representing it in RADIX format. +// If the leading digits are zero they are not included in the string. +// - value : The number to be converted to RADIX +// - buffer : receives the string representing the number and zero-termination. +// - radix : The radix to convert the number to (from the enum RADIX) +// utoa(word zp(2) value, byte* zp($12) buffer) +utoa: { + .const max_digits = 5 + .label digit_value = $16 + .label buffer = $12 + .label digit = $a + .label value = 2 + // [148] phi from utoa to utoa::@1 [phi:utoa->utoa::@1] + __b1_from_utoa: + // [148] phi (byte*) utoa::buffer#11 = (byte*)&(struct printf_buffer_number) printf_buffer+(const byte) OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_DIGITS [phi:utoa->utoa::@1#0] -- pbuz1=pbuc1 + lda #printf_buffer+OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_DIGITS + sta.z buffer+1 + // [148] phi (byte) utoa::started#2 = (byte) 0 [phi:utoa->utoa::@1#1] -- vbuxx=vbuc1 + ldx #0 + // [148] phi (word) utoa::value#2 = (word) utoa::value#1 [phi:utoa->utoa::@1#2] -- register_copy + // [148] phi (byte) utoa::digit#2 = (byte) 0 [phi:utoa->utoa::@1#3] -- vbuz1=vbuc1 + lda #0 + sta.z digit + jmp __b1 + // utoa::@1 + __b1: + // [149] if((byte) utoa::digit#2<(const byte) utoa::max_digits#1-(byte) 1) goto utoa::@2 -- vbuz1_lt_vbuc1_then_la1 + lda.z digit + cmp #max_digits-1 + bcc __b2 + jmp __b3 + // utoa::@3 + __b3: + // [150] (byte~) utoa::$11 ← (byte)(word) utoa::value#2 -- vbuaa=_byte_vwuz1 + lda.z value + // [151] *((byte*) utoa::buffer#11) ← *((const byte*) DIGITS + (byte~) utoa::$11) -- _deref_pbuz1=pbuc1_derefidx_vbuaa + tay + lda DIGITS,y + ldy #0 + sta (buffer),y + // [152] (byte*) utoa::buffer#3 ← ++ (byte*) utoa::buffer#11 -- pbuz1=_inc_pbuz1 + inc.z buffer + bne !+ + inc.z buffer+1 + !: + // [153] *((byte*) utoa::buffer#3) ← (byte) 0 -- _deref_pbuz1=vbuc1 + lda #0 + ldy #0 + sta (buffer),y + jmp __breturn + // utoa::@return + __breturn: + // [154] return + rts + // utoa::@2 + __b2: + // [155] (byte~) utoa::$10 ← (byte) utoa::digit#2 << (byte) 1 -- vbuaa=vbuz1_rol_1 + lda.z digit + asl + // [156] (word) utoa::digit_value#0 ← *((const word*) RADIX_DECIMAL_VALUES + (byte~) utoa::$10) -- vwuz1=pwuc1_derefidx_vbuaa + tay + lda RADIX_DECIMAL_VALUES,y + sta.z digit_value + lda RADIX_DECIMAL_VALUES+1,y + sta.z digit_value+1 + // [157] if((byte) 0!=(byte) utoa::started#2) goto utoa::@5 -- vbuc1_neq_vbuxx_then_la1 + cpx #0 + bne __b5 + jmp __b7 + // utoa::@7 + __b7: + // [158] if((word) utoa::value#2>=(word) utoa::digit_value#0) goto utoa::@5 -- vwuz1_ge_vwuz2_then_la1 + lda.z digit_value+1 + cmp.z value+1 + bne !+ + lda.z digit_value + cmp.z value + beq __b5 + !: + bcc __b5 + // [159] phi from utoa::@7 to utoa::@4 [phi:utoa::@7->utoa::@4] + __b4_from___b7: + // [159] phi (byte*) utoa::buffer#14 = (byte*) utoa::buffer#11 [phi:utoa::@7->utoa::@4#0] -- register_copy + // [159] phi (byte) utoa::started#4 = (byte) utoa::started#2 [phi:utoa::@7->utoa::@4#1] -- register_copy + // [159] phi (word) utoa::value#6 = (word) utoa::value#2 [phi:utoa::@7->utoa::@4#2] -- register_copy + jmp __b4 + // utoa::@4 + __b4: + // [160] (byte) utoa::digit#1 ← ++ (byte) utoa::digit#2 -- vbuz1=_inc_vbuz1 + inc.z digit + // [148] phi from utoa::@4 to utoa::@1 [phi:utoa::@4->utoa::@1] + __b1_from___b4: + // [148] phi (byte*) utoa::buffer#11 = (byte*) utoa::buffer#14 [phi:utoa::@4->utoa::@1#0] -- register_copy + // [148] phi (byte) utoa::started#2 = (byte) utoa::started#4 [phi:utoa::@4->utoa::@1#1] -- register_copy + // [148] phi (word) utoa::value#2 = (word) utoa::value#6 [phi:utoa::@4->utoa::@1#2] -- register_copy + // [148] phi (byte) utoa::digit#2 = (byte) utoa::digit#1 [phi:utoa::@4->utoa::@1#3] -- register_copy + jmp __b1 + // utoa::@5 + __b5: + // [161] (byte*) utoa_append::buffer#0 ← (byte*) utoa::buffer#11 + // [162] (word) utoa_append::value#0 ← (word) utoa::value#2 + // [163] (word) utoa_append::sub#0 ← (word) utoa::digit_value#0 + // [164] call utoa_append + // [168] phi from utoa::@5 to utoa_append [phi:utoa::@5->utoa_append] + utoa_append_from___b5: + jsr utoa_append + // [165] (word) utoa_append::return#0 ← (word) utoa_append::value#2 + jmp __b6 + // utoa::@6 + __b6: + // [166] (word) utoa::value#0 ← (word) utoa_append::return#0 + // [167] (byte*) utoa::buffer#4 ← ++ (byte*) utoa::buffer#11 -- pbuz1=_inc_pbuz1 + inc.z buffer + bne !+ + inc.z buffer+1 + !: + // [159] phi from utoa::@6 to utoa::@4 [phi:utoa::@6->utoa::@4] + __b4_from___b6: + // [159] phi (byte*) utoa::buffer#14 = (byte*) utoa::buffer#4 [phi:utoa::@6->utoa::@4#0] -- register_copy + // [159] phi (byte) utoa::started#4 = (byte) 1 [phi:utoa::@6->utoa::@4#1] -- vbuxx=vbuc1 + ldx #1 + // [159] phi (word) utoa::value#6 = (word) utoa::value#0 [phi:utoa::@6->utoa::@4#2] -- register_copy + jmp __b4 +} + // utoa_append +// Used to convert a single digit of an unsigned number value to a string representation +// Counts a single digit up from '0' as long as the value is larger than sub. +// Each time the digit is increased sub is subtracted from value. +// - buffer : pointer to the char that receives the digit +// - value : The value where the digit will be derived from +// - sub : the value of a '1' in the digit. Subtracted continually while the digit is increased. +// (For decimal the subs used are 10000, 1000, 100, 10, 1) +// returns : the value reduced by sub * digit so that it is less than sub. +// utoa_append(byte* zp($12) buffer, word zp(2) value, word zp($16) sub) +utoa_append: { + .label buffer = $12 + .label value = 2 + .label sub = $16 + .label return = 2 + // [169] phi from utoa_append to utoa_append::@1 [phi:utoa_append->utoa_append::@1] + __b1_from_utoa_append: + // [169] phi (byte) utoa_append::digit#2 = (byte) 0 [phi:utoa_append->utoa_append::@1#0] -- vbuxx=vbuc1 + ldx #0 + // [169] phi (word) utoa_append::value#2 = (word) utoa_append::value#0 [phi:utoa_append->utoa_append::@1#1] -- register_copy + jmp __b1 + // utoa_append::@1 + __b1: + // [170] if((word) utoa_append::value#2>=(word) utoa_append::sub#0) goto utoa_append::@2 -- vwuz1_ge_vwuz2_then_la1 + lda.z sub+1 + cmp.z value+1 + bne !+ + lda.z sub + cmp.z value + beq __b2 + !: + bcc __b2 + jmp __b3 + // utoa_append::@3 + __b3: + // [171] *((byte*) utoa_append::buffer#0) ← *((const byte*) DIGITS + (byte) utoa_append::digit#2) -- _deref_pbuz1=pbuc1_derefidx_vbuxx + lda DIGITS,x + ldy #0 + sta (buffer),y + jmp __breturn + // utoa_append::@return + __breturn: + // [172] return + rts + // utoa_append::@2 + __b2: + // [173] (byte) utoa_append::digit#1 ← ++ (byte) utoa_append::digit#2 -- vbuxx=_inc_vbuxx + inx + // [174] (word) utoa_append::value#1 ← (word) utoa_append::value#2 - (word) utoa_append::sub#0 -- vwuz1=vwuz1_minus_vwuz2 + lda.z value + sec + sbc.z sub + sta.z value + lda.z value+1 + sbc.z sub+1 + sta.z value+1 + // [169] phi from utoa_append::@2 to utoa_append::@1 [phi:utoa_append::@2->utoa_append::@1] + __b1_from___b2: + // [169] phi (byte) utoa_append::digit#2 = (byte) utoa_append::digit#1 [phi:utoa_append::@2->utoa_append::@1#0] -- register_copy + // [169] phi (word) utoa_append::value#2 = (word) utoa_append::value#1 [phi:utoa_append::@2->utoa_append::@1#1] -- register_copy + jmp __b1 +} + // gotoxy +// Set the cursor to the specified position +gotoxy: { + .const x = 0 + .const y = 0 + jmp __b1 + // gotoxy::@1 + __b1: + // [176] (byte) conio_cursor_x ← (const byte) gotoxy::x#2 -- vbuz1=vbuc1 + lda #x + sta.z conio_cursor_x + // [177] (byte) conio_cursor_y ← (const byte) gotoxy::y#2 -- vbuz1=vbuc1 + lda #y + sta.z conio_cursor_y + // [178] (byte*) conio_cursor_text ← (const nomodify byte*) CONIO_SCREEN_TEXT -- pbuz1=pbuc1 + lda #CONIO_SCREEN_TEXT + sta.z conio_cursor_text+1 + // [179] (byte*) conio_cursor_color ← (const nomodify byte*) CONIO_SCREEN_COLORS -- pbuz1=pbuc1 + lda #CONIO_SCREEN_COLORS + sta.z conio_cursor_color+1 + jmp __breturn + // gotoxy::@return + __breturn: + // [180] return + rts +} + // File Data + // The digits used for numbers + DIGITS: .text "0123456789abcdef" + // Values of decimal digits + RADIX_DECIMAL_VALUES: .word $2710, $3e8, $64, $a + // Buffer used for stringified number being printed + printf_buffer: .fill SIZEOF_STRUCT_PRINTF_BUFFER_NUMBER, 0 + +ASSEMBLER OPTIMIZATIONS +Removing instruction jmp __b1 +Removing instruction jmp __b2 +Removing instruction jmp __bend +Removing instruction jmp __b1 +Removing instruction jmp __b2 +Removing instruction jmp __b8 +Removing instruction jmp __b9 +Removing instruction jmp __breturn +Removing instruction jmp __b3 +Removing instruction jmp __b5 +Removing instruction jmp __b10 +Removing instruction jmp __b11 +Removing instruction jmp __b7 +Removing instruction jmp __b6 +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 __b1 +Removing instruction jmp __breturn +Removing instruction jmp __b4 +Removing instruction jmp __b3 +Removing instruction jmp __b1 +Removing instruction jmp __breturn +Removing instruction jmp __b2 +Removing instruction jmp __b3 +Removing instruction jmp __breturn +Removing instruction jmp __b1 +Removing instruction jmp __breturn +Removing instruction jmp __b1 +Removing instruction jmp __b2 +Removing instruction jmp __b3 +Removing instruction jmp __b4 +Removing instruction jmp __b5 +Removing instruction jmp __breturn +Removing instruction jmp __b1 +Removing instruction jmp __b2 +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 __b1 +Removing instruction jmp __b3 +Removing instruction jmp __b2 +Removing instruction jmp __breturn +Removing instruction jmp __b1 +Removing instruction jmp __b3 +Removing instruction jmp __breturn +Removing instruction jmp __b7 +Removing instruction jmp __b4 +Removing instruction jmp __b6 +Removing instruction jmp __b1 +Removing instruction jmp __b3 +Removing instruction jmp __breturn +Removing instruction jmp __b1 +Removing instruction jmp __breturn +Succesful ASM optimization Pass5NextJumpElimination +Removing instruction lda #0 +Removing instruction lda #>0 +Removing instruction lda #0 +Removing instruction lda #>0 +Removing instruction ldy #0 +Replacing instruction lda #0 with TXA +Replacing instruction ldy #0 with TAY +Succesful ASM optimization Pass5UnnecesaryLoadElimination +Replacing label __b6_from___b11 with __b6 +Replacing label __b1_from___b5 with __b1 +Replacing label __b2_from___b1 with __b2 +Replacing label __b3_from___b2 with __b3 +Replacing label __b1_from___b2 with __b1 +Replacing label __b1_from_cputc with __b1 +Replacing label __b2_from___b3 with __b2 +Replacing label __b1_from___b2 with __b1 +Replacing label __b2_from___b1 with __b2 +Removing instruction __b1: +Removing instruction __b2_from___b1: +Removing instruction main_from___b2: +Removing instruction __bend_from___b2: +Removing instruction __b2_from___b1: +Removing instruction gotoxy_from___b2: +Removing instruction printf_uint_from___b8: +Removing instruction __b9_from___b8: +Removing instruction cputs_from___b9: +Removing instruction __b6_from___b11: +Removing instruction __b6_from___b7: +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 __b3_from___b2: +Removing instruction __b3_from___b4: +Removing instruction __b1_from_cputs: +Removing instruction __b1_from___b2: +Removing instruction cputc_from___b2: +Removing instruction __b1_from_cputc: +Removing instruction __b1_from_cscroll: +Removing instruction memcpy_from___b1: +Removing instruction __b2_from___b1: +Removing instruction memcpy_from___b2: +Removing instruction __b3_from___b2: +Removing instruction memset_from___b3: +Removing instruction __b4_from___b3: +Removing instruction memset_from___b4: +Removing instruction __b2_from___b1: +Removing instruction __b2_from___b3: +Removing instruction __b1_from_memcpy: +Removing instruction __b1_from___b2: +Removing instruction cputc_from___b3: +Removing instruction __b2_from___b1: +Removing instruction __b2_from___b3: +Removing instruction cputs_from___b2: +Removing instruction __b4_from___b7: +Removing instruction utoa_append_from___b5: +Succesful ASM optimization Pass5RedundantLabelElimination +Removing instruction __b2: +Removing instruction __bend: +Removing instruction memset_from_main: +Removing instruction __b1_from_main: +Removing instruction __b2: +Removing instruction __b8: +Removing instruction __b9: +Removing instruction __breturn: +Removing instruction __b5: +Removing instruction __b1_from___b5: +Removing instruction mul8s_from___b4: +Removing instruction __b10: +Removing instruction mul8s_from___b10: +Removing instruction __b11: +Removing instruction __b7: +Removing instruction __b3_from___b6: +Removing instruction __b5: +Removing instruction __b3: +Removing instruction __b4: +Removing instruction __b1_from_mul8u: +Removing instruction __breturn: +Removing instruction __b4: +Removing instruction __b1_from___b3: +Removing instruction __breturn: +Removing instruction __b2: +Removing instruction __b3: +Removing instruction __breturn: +Removing instruction __b1: +Removing instruction __b2: +Removing instruction __b3: +Removing instruction __b4: +Removing instruction __b5: +Removing instruction __b1: +Removing instruction __breturn: +Removing instruction __b1: +Removing instruction utoa_from___b1: +Removing instruction __b2: +Removing instruction printf_number_buffer_from___b2: +Removing instruction __breturn: +Removing instruction __b1: +Removing instruction __b3: +Removing instruction __breturn: +Removing instruction __b1_from_utoa: +Removing instruction __b3: +Removing instruction __breturn: +Removing instruction __b7: +Removing instruction __b1_from___b4: +Removing instruction __b6: +Removing instruction __b4_from___b6: +Removing instruction __b1_from_utoa_append: +Removing instruction __b3: +Removing instruction __breturn: +Removing instruction __b1_from___b2: +Removing instruction __b1: +Removing instruction __breturn: +Succesful ASM optimization Pass5UnusedLabelElimination +Replacing jump to rts with rts in jmp __breturn +Succesful ASM optimization Pass5DoubleJumpElimination +Relabelling long label __b3_from___b1 to __b2 +Succesful ASM optimization Pass5RelabelLongLabels +Adding RTS to root block +Succesful ASM optimization Pass5AddMainRts +Removing instruction lda #<0 +Removing instruction lda.z digit_value+1 +Succesful ASM optimization Pass5UnnecesaryLoadElimination + +FINAL SYMBOL TABLE +(label) @1 +(label) @2 +(label) @begin +(label) @end +(const nomodify byte*) CONIO_SCREEN_COLORS = (byte*) 55296 +(const nomodify byte*) CONIO_SCREEN_TEXT = (byte*) 1024 +(const nomodify byte) CONIO_TEXTCOLOR_DEFAULT = (byte) $e +(const byte*) DIGITS[] = (byte*) "0123456789abcdef"z +(const byte) OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_DIGITS = (byte) 1 +(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 word*) RADIX_DECIMAL_VALUES[] = { (word) $2710, (word) $3e8, (word) $64, (word) $a } +(const nomodify byte*) SCREEN = (byte*) 1024 +(const byte) SIZEOF_STRUCT_PRINTF_BUFFER_NUMBER = (byte) $c +(byte*) conio_cursor_color loadstore zp[2]:15 3484376.71875 +(byte*) conio_cursor_text loadstore zp[2]:13 3430770.9230769235 +(byte) conio_cursor_x loadstore zp[1]:11 489798.1428571429 +(byte) conio_cursor_y loadstore zp[1]:12 4735295.735294118 +(void()) cputc((byte) cputc::c) +(label) cputc::@1 +(label) cputc::@2 +(label) cputc::@3 +(label) cputc::@return +(byte) cputc::c +(byte) cputc::c#0 reg byte a 200002.0 +(byte) cputc::c#2 reg byte a 2002.0 +(byte) cputc::c#3 reg byte a 1050502.0 +(void()) cputln() +(byte*~) cputln::$1 zp[2]:13 2.0000002E7 +(byte*~) cputln::$2 zp[2]:15 2.0000002E7 +(label) cputln::@return +(word) cputln::ln_offset +(word) cputln::ln_offset#0 ln_offset zp[2]:22 1.0000001E7 +(void()) cputs((to_nomodify byte*) cputs::s) +(label) cputs::@1 +(label) cputs::@2 +(label) cputs::@return +(byte) cputs::c +(byte) cputs::c#1 reg byte a 100001.0 +(to_nomodify byte*) cputs::s +(to_nomodify byte*) cputs::s#0 s zp[2]:8 50000.5 +(to_nomodify byte*) cputs::s#3 s zp[2]:8 155002.0 +(to_nomodify byte*) cputs::s#4 s zp[2]:8 10001.0 +(void()) cscroll() +(byte*~) cscroll::$7 zp[2]:13 2.00000002E8 +(byte*~) cscroll::$8 zp[2]:15 2.00000002E8 +(label) cscroll::@1 +(label) cscroll::@2 +(label) cscroll::@3 +(label) cscroll::@4 +(label) cscroll::@5 +(label) cscroll::@return +(void()) gotoxy((byte) gotoxy::x , (byte) gotoxy::y) +(label) gotoxy::@1 +(label) gotoxy::@return +(word) gotoxy::offset +(byte) gotoxy::x +(const byte) gotoxy::x#2 x = (byte) 0 +(byte) gotoxy::y +(const byte) gotoxy::y#2 y = (byte) 0 +(void()) main() +(signed word~) main::$10 zp[2]:6 2002.0 +(signed byte~) main::$5 reg byte a 2002.0 +(signed byte~) main::$7 reg byte a 2002.0 +(signed word~) main::$9 zp[2]:18 400.4 +(label) main::@1 +(label) main::@10 +(label) main::@11 +(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 +(word) main::count +(word) main::count#1 count zp[2]:2 2002.0 +(word) main::count#10 count zp[2]:2 178.05555555555557 +(word) main::count#11 count zp[2]:2 53.25 +(word) main::count#12 count zp[2]:2 1001.0 +(signed word) main::dist_sq +(signed word) main::dist_sq#0 dist_sq zp[2]:18 2002.0 +(const byte*) main::s[(byte) 7] = (byte*) " chars" +(byte*) main::sc +(byte*) main::sc#1 sc zp[2]:4 1001.0 +(byte*) main::sc#10 sc zp[2]:4 160.25 +(byte*) main::sc#8 sc zp[2]:4 101.0 +(byte) main::x +(byte) main::x#1 x zp[1]:12 2002.0 +(byte) main::x#2 x zp[1]:12 150.14999999999998 +(signed byte) main::xd +(signed byte) main::xd#0 reg byte x 750.75 +(byte) main::y +(byte) main::y#1 y zp[1]:11 202.0 +(byte) main::y#2 y zp[1]:11 13.173913043478262 +(signed byte) main::yd +(signed byte) main::yd#0 yd zp[1]:17 500.5 +(void*()) memcpy((void*) memcpy::destination , (void*) memcpy::source , (word) memcpy::num) +(label) memcpy::@1 +(label) memcpy::@2 +(label) memcpy::@return +(void*) memcpy::destination +(void*) memcpy::destination#2 destination zp[2]:22 +(byte*) memcpy::dst +(byte*) memcpy::dst#1 dst zp[2]:22 1.00000000001E11 +(byte*) memcpy::dst#2 dst zp[2]:22 1.0033333333466667E11 +(byte*) memcpy::dst#4 dst zp[2]:22 2.000000002E9 +(word) memcpy::num +(void*) memcpy::return +(void*) memcpy::source +(void*) memcpy::source#2 source zp[2]:18 +(byte*) memcpy::src +(byte*) memcpy::src#1 src zp[2]:18 2.00000000002E11 +(byte*) memcpy::src#2 src zp[2]:18 1.0025000000125E11 +(byte*) memcpy::src#4 src zp[2]:18 1.000000001E9 +(byte*) memcpy::src_end +(byte*) memcpy::src_end#0 src_end zp[2]:20 1.262500000025E10 +(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num) +(label) memset::@1 +(label) memset::@2 +(label) memset::@3 +(label) memset::@return +(byte) memset::c +(byte) memset::c#5 reg byte x 1.250000000125E9 +(byte*) memset::dst +(byte*) memset::dst#1 dst zp[2]:22 2.0000000002E10 +(byte*) memset::dst#2 dst zp[2]:22 1.3666666668333332E10 +(byte*) memset::dst#4 dst zp[2]:22 2.000000002E9 +(byte*) memset::end +(byte*) memset::end#0 end zp[2]:18 1.8333333336666665E9 +(word) memset::num +(word) memset::num#3 num zp[2]:18 1.000000001E9 +(void*) memset::return +(void*) memset::str +(void*) memset::str#4 str zp[2]:22 +(signed word()) mul8s((signed byte) mul8s::a , (signed byte) mul8s::b) +(byte~) mul8s::$11 reg byte a 20002.0 +(byte~) mul8s::$12 reg byte a 20002.0 +(byte~) mul8s::$6 reg byte a 20002.0 +(byte~) mul8s::$9 reg byte a 20002.0 +(label) mul8s::@1 +(label) mul8s::@2 +(label) mul8s::@3 +(label) mul8s::@4 +(label) mul8s::@5 +(label) mul8s::@return +(signed byte) mul8s::a +(signed byte) mul8s::a#0 a zp[1]:10 1001.0 +(signed byte) mul8s::a#1 a zp[1]:10 1001.0 +(signed byte) mul8s::a#2 a zp[1]:10 923.3076923076923 +(signed byte) mul8s::b +(signed byte) mul8s::b#0 reg byte y 2002.0 +(signed byte) mul8s::b#1 reg byte y 2002.0 +(signed byte) mul8s::b#2 reg byte y 1091.181818181818 +(word) mul8s::m +(word) mul8s::m#0 m zp[2]:6 10001.0 +(word) mul8s::m#1 m zp[2]:6 20002.0 +(word) mul8s::m#2 m zp[2]:6 20002.0 +(word) mul8s::m#4 m zp[2]:6 5000.5 +(word) mul8s::m#5 m zp[2]:6 12501.25 +(signed word) mul8s::return +(word()) mul8u((byte) mul8u::a , (byte) mul8u::b) +(byte~) mul8u::$1 reg byte a 2.00000002E8 +(label) mul8u::@1 +(label) mul8u::@2 +(label) mul8u::@3 +(label) mul8u::@4 +(label) mul8u::@return +(byte) mul8u::a +(byte) mul8u::a#0 reg byte x 1.00000001E8 +(byte) mul8u::a#1 reg byte x 36667.33333333333 +(byte) mul8u::a#2 reg byte x 6.668333416666667E7 +(byte) mul8u::b +(byte) mul8u::b#0 reg byte a 10001.0 +(word) mul8u::mb +(word) mul8u::mb#0 mb zp[2]:8 200002.0 +(word) mul8u::mb#1 mb zp[2]:8 2.00000002E8 +(word) mul8u::mb#2 mb zp[2]:8 4.287142914285715E7 +(word) mul8u::res +(word) mul8u::res#1 res zp[2]:6 2.00000002E8 +(word) mul8u::res#2 res zp[2]:6 5.0001667333333336E7 +(word) mul8u::res#6 res zp[2]:6 1.00000001E8 +(word) mul8u::return +(word) mul8u::return#2 return zp[2]:6 20002.0 +(struct printf_buffer_number) printf_buffer loadstore mem[12] = {} +(const byte*) printf_buffer_number::digits[(number) $b] = { fill( $b, 0) } +(byte) printf_buffer_number::sign +(byte) printf_format_number::justify_left +(byte) printf_format_number::min_length +(byte) printf_format_number::radix +(byte) printf_format_number::sign_always +(byte) printf_format_number::upper_case +(byte) printf_format_number::zero_padding +(byte) printf_format_string::justify_left +(byte) printf_format_string::min_length +(void()) printf_number_buffer((byte) printf_number_buffer::buffer_sign , (byte*) printf_number_buffer::buffer_digits , (byte) printf_number_buffer::format_min_length , (byte) printf_number_buffer::format_justify_left , (byte) printf_number_buffer::format_sign_always , (byte) printf_number_buffer::format_zero_padding , (byte) printf_number_buffer::format_upper_case , (byte) printf_number_buffer::format_radix) +(label) printf_number_buffer::@1 +(label) printf_number_buffer::@2 +(label) printf_number_buffer::@3 +(label) printf_number_buffer::@return +(struct printf_buffer_number) printf_number_buffer::buffer +(byte*) printf_number_buffer::buffer_digits +(const byte*) printf_number_buffer::buffer_digits#0 buffer_digits = (byte*)&(struct printf_buffer_number) printf_buffer+(const byte) OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_DIGITS +(byte) printf_number_buffer::buffer_sign +(byte) printf_number_buffer::buffer_sign#0 reg byte a 701.0 +(struct printf_format_number) printf_number_buffer::format +(byte) printf_number_buffer::format_justify_left +(byte) printf_number_buffer::format_min_length +(byte) printf_number_buffer::format_radix +(byte) printf_number_buffer::format_sign_always +(byte) printf_number_buffer::format_upper_case +(byte) printf_number_buffer::format_zero_padding +(signed byte) printf_number_buffer::len +(signed byte) printf_number_buffer::padding +(void()) printf_uint((word) printf_uint::uvalue , (byte) printf_uint::format_min_length , (byte) printf_uint::format_justify_left , (byte) printf_uint::format_sign_always , (byte) printf_uint::format_zero_padding , (byte) printf_uint::format_upper_case , (byte) printf_uint::format_radix) +(label) printf_uint::@1 +(label) printf_uint::@2 +(label) printf_uint::@return +(struct printf_format_number) printf_uint::format +(byte) printf_uint::format_justify_left +(byte) printf_uint::format_min_length +(byte) printf_uint::format_radix +(byte) printf_uint::format_sign_always +(byte) printf_uint::format_upper_case +(byte) printf_uint::format_zero_padding +(word) printf_uint::uvalue +(word) printf_uint::uvalue#0 uvalue zp[2]:2 37.33333333333333 +(void()) utoa((word) utoa::value , (byte*) utoa::buffer , (byte) utoa::radix) +(byte~) utoa::$10 reg byte a 20002.0 +(byte~) utoa::$11 reg byte a 2002.0 +(label) utoa::@1 +(label) utoa::@2 +(label) utoa::@3 +(label) utoa::@4 +(label) utoa::@5 +(label) utoa::@6 +(label) utoa::@7 +(label) utoa::@return +(byte*) utoa::buffer +(byte*) utoa::buffer#11 buffer zp[2]:18 3000.4285714285716 +(byte*) utoa::buffer#14 buffer zp[2]:18 15001.5 +(byte*) utoa::buffer#3 buffer zp[2]:18 2002.0 +(byte*) utoa::buffer#4 buffer zp[2]:18 20002.0 +(byte) utoa::digit +(byte) utoa::digit#1 digit zp[1]:10 20002.0 +(byte) utoa::digit#2 digit zp[1]:10 2857.4285714285716 +(word) utoa::digit_value +(word) utoa::digit_value#0 digit_value zp[2]:22 6000.6 +(word*) utoa::digit_values +(byte) utoa::max_digits +(const byte) utoa::max_digits#1 max_digits = (byte) 5 +(byte) utoa::radix +(byte) utoa::started +(byte) utoa::started#2 reg byte x 5000.5 +(byte) utoa::started#4 reg byte x 10001.0 +(word) utoa::value +(word) utoa::value#0 value zp[2]:2 10001.0 +(word) utoa::value#1 value zp[2]:2 551.0 +(word) utoa::value#2 value zp[2]:2 5857.857142857143 +(word) utoa::value#6 value zp[2]:2 15001.5 +(word()) utoa_append((byte*) utoa_append::buffer , (word) utoa_append::value , (word) utoa_append::sub) +(label) utoa_append::@1 +(label) utoa_append::@2 +(label) utoa_append::@3 +(label) utoa_append::@return +(byte*) utoa_append::buffer +(byte*) utoa_append::buffer#0 buffer zp[2]:18 13750.25 +(byte) utoa_append::digit +(byte) utoa_append::digit#1 reg byte x 1.0000001E7 +(byte) utoa_append::digit#2 reg byte x 1.00500015E7 +(word) utoa_append::return +(word) utoa_append::return#0 return zp[2]:2 20002.0 +(word) utoa_append::sub +(word) utoa_append::sub#0 sub zp[2]:22 3335000.5 +(word) utoa_append::value +(word) utoa_append::value#0 value zp[2]:2 36667.33333333333 +(word) utoa_append::value#1 value zp[2]:2 2.0000002E7 +(word) utoa_append::value#2 value zp[2]:2 5018334.166666666 + +zp[2]:2 [ main::count#11 main::count#10 main::count#12 main::count#1 printf_uint::uvalue#0 utoa::value#2 utoa::value#6 utoa::value#1 utoa::value#0 utoa_append::value#2 utoa_append::value#0 utoa_append::value#1 utoa_append::return#0 ] +zp[2]:4 [ main::sc#8 main::sc#10 main::sc#1 ] +reg byte y [ mul8s::b#2 mul8s::b#1 mul8s::b#0 ] +zp[2]:6 [ mul8s::m#4 mul8s::m#5 mul8s::m#1 mul8s::m#0 mul8s::m#2 main::$10 mul8u::return#2 mul8u::res#2 mul8u::res#6 mul8u::res#1 ] +reg byte x [ mul8u::a#2 mul8u::a#1 mul8u::a#0 ] +zp[2]:8 [ cputs::s#3 cputs::s#4 cputs::s#0 mul8u::mb#2 mul8u::mb#0 mul8u::mb#1 ] +reg byte a [ cputc::c#3 cputc::c#0 cputc::c#2 ] +reg byte x [ memset::c#5 ] +zp[1]:10 [ utoa::digit#2 utoa::digit#1 mul8s::a#2 mul8s::a#1 mul8s::a#0 ] +reg byte x [ utoa::started#2 utoa::started#4 ] +reg byte x [ utoa_append::digit#2 utoa_append::digit#1 ] +zp[1]:11 [ conio_cursor_x main::y#2 main::y#1 ] +zp[1]:12 [ conio_cursor_y main::x#2 main::x#1 ] +zp[2]:13 [ conio_cursor_text cputln::$1 cscroll::$7 ] +zp[2]:15 [ conio_cursor_color cputln::$2 cscroll::$8 ] +reg byte a [ main::$5 ] +reg byte x [ main::xd#0 ] +reg byte a [ main::$7 ] +zp[1]:17 [ main::yd#0 ] +zp[2]:18 [ main::$9 main::dist_sq#0 utoa::buffer#11 utoa::buffer#14 utoa::buffer#4 utoa::buffer#3 utoa_append::buffer#0 memcpy::source#2 memcpy::src#2 memcpy::src#4 memcpy::src#1 memset::num#3 memset::end#0 ] +reg byte a [ mul8u::b#0 ] +reg byte a [ mul8s::$6 ] +reg byte a [ mul8s::$11 ] +reg byte a [ mul8s::$9 ] +reg byte a [ mul8s::$12 ] +reg byte a [ mul8u::$1 ] +reg byte a [ cputs::c#1 ] +zp[2]:20 [ memcpy::src_end#0 ] +reg byte a [ printf_number_buffer::buffer_sign#0 ] +reg byte a [ utoa::$11 ] +reg byte a [ utoa::$10 ] +zp[2]:22 [ utoa::digit_value#0 utoa_append::sub#0 cputln::ln_offset#0 memcpy::destination#2 memcpy::dst#2 memcpy::dst#4 memcpy::dst#1 memset::str#4 memset::dst#2 memset::dst#4 memset::dst#1 ] +mem[12] [ printf_buffer ] + + +FINAL ASSEMBLER +Score: 85370 + + // File Comments +// Plot a r=9 circle on the screen using chars - count how many chars are used + // Upstart +.pc = $801 "Basic" +:BasicUpstart(__bbegin) +.pc = $80d "Program" + // Global Constants & labels + // The default text color + .const CONIO_TEXTCOLOR_DEFAULT = $e + .const OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_DIGITS = 1 + .const SIZEOF_STRUCT_PRINTF_BUFFER_NUMBER = $c + // The screen width + // The screen height + // The screen bytes + // The text screen address + .label CONIO_SCREEN_TEXT = $400 + // The color screen address + .label CONIO_SCREEN_COLORS = $d800 + .label SCREEN = $400 + .label conio_cursor_x = $b + .label conio_cursor_y = $c + .label conio_cursor_text = $d + .label conio_cursor_color = $f + // @begin +__bbegin: + // @1 + // conio_cursor_x = 0 + // [1] (byte) conio_cursor_x ← (byte) 0 -- vbuz1=vbuc1 + // The current cursor x-position + lda #0 + sta.z conio_cursor_x + // conio_cursor_y = 0 + // [2] (byte) conio_cursor_y ← (byte) 0 -- vbuz1=vbuc1 + // The current cursor y-position + sta.z conio_cursor_y + // conio_cursor_text = CONIO_SCREEN_TEXT + // [3] (byte*) conio_cursor_text ← (const nomodify byte*) CONIO_SCREEN_TEXT -- pbuz1=pbuc1 + // The current cursor address + lda #CONIO_SCREEN_TEXT + sta.z conio_cursor_text+1 + // conio_cursor_color = CONIO_SCREEN_COLORS + // [4] (byte*) conio_cursor_color ← (const nomodify byte*) CONIO_SCREEN_COLORS -- pbuz1=pbuc1 + // The current cursor address + lda #CONIO_SCREEN_COLORS + sta.z conio_cursor_color+1 + // [5] phi from @1 to @2 [phi:@1->@2] + // @2 + // [6] call main + // [8] phi from @2 to main [phi:@2->main] + jsr main + rts + // [7] phi from @2 to @end [phi:@2->@end] + // @end + // main +main: { + .label __9 = $12 + .label __10 = 6 + .label yd = $11 + .label dist_sq = $12 + .label y = $b + .label sc = 4 + .label x = $c + .label count = 2 + // memset(SCREEN, ' ', 1000) + // [9] call memset + // [114] phi from main to memset [phi:main->memset] + // [114] phi (byte) memset::c#5 = (byte) ' ' [phi:main->memset#0] -- vbuxx=vbuc1 + ldx #' ' + // [114] phi (void*) memset::str#4 = (void*)(const nomodify byte*) SCREEN [phi:main->memset#1] -- pvoz1=pvoc1 + lda #SCREEN + sta.z memset.str+1 + // [114] phi (word) memset::num#3 = (word) $3e8 [phi:main->memset#2] -- vwuz1=vwuc1 + lda #<$3e8 + sta.z memset.num + lda #>$3e8 + sta.z memset.num+1 + jsr memset + // [10] phi from main to main::@1 [phi:main->main::@1] + // [10] phi (byte*) main::sc#8 = (const nomodify byte*) SCREEN [phi:main->main::@1#0] -- pbuz1=pbuc1 + lda #SCREEN + sta.z sc+1 + // [10] phi (word) main::count#11 = (word) 0 [phi:main->main::@1#1] -- vwuz1=vwuc1 + lda #<0 + sta.z count + sta.z count+1 + // [10] phi (byte) main::y#2 = (byte) 0 [phi:main->main::@1#2] -- vbuz1=vbuc1 + sta.z y + // main::@1 + __b1: + // for(char y=0;y<25;y++) + // [11] if((byte) main::y#2<(byte) $19) goto main::@3 -- vbuz1_lt_vbuc1_then_la1 + lda.z y + cmp #$19 + bcc __b2 + // [12] phi from main::@1 to main::@2 [phi:main::@1->main::@2] + // main::@2 + // gotoxy(0,0) + // [13] call gotoxy + // [175] phi from main::@2 to gotoxy [phi:main::@2->gotoxy] + jsr gotoxy + // main::@8 + // printf("%u chars",count) + // [14] (word) printf_uint::uvalue#0 ← (word) main::count#11 + // [15] call printf_uint + // [133] phi from main::@8 to printf_uint [phi:main::@8->printf_uint] + jsr printf_uint + // [16] phi from main::@8 to main::@9 [phi:main::@8->main::@9] + // main::@9 + // printf("%u chars",count) + // [17] call cputs + // [68] phi from main::@9 to cputs [phi:main::@9->cputs] + // [68] phi (to_nomodify byte*) cputs::s#4 = (const byte*) main::s [phi:main::@9->cputs#0] -- pbuz1=pbuc1 + lda #s + sta.z cputs.s+1 + jsr cputs + // main::@return + // } + // [18] return + rts + // [19] phi from main::@1 to main::@3 [phi:main::@1->main::@3] + __b2: + // [19] phi (word) main::count#10 = (word) main::count#11 [phi:main::@1->main::@3#0] -- register_copy + // [19] phi (byte*) main::sc#10 = (byte*) main::sc#8 [phi:main::@1->main::@3#1] -- register_copy + // [19] phi (byte) main::x#2 = (byte) 0 [phi:main::@1->main::@3#2] -- vbuz1=vbuc1 + lda #0 + sta.z x + // main::@3 + __b3: + // for(char x=0;x<40;x++) + // [20] if((byte) main::x#2<(byte) $28) goto main::@4 -- vbuz1_lt_vbuc1_then_la1 + lda.z x + cmp #$28 + bcc __b4 + // main::@5 + // for(char y=0;y<25;y++) + // [21] (byte) main::y#1 ← ++ (byte) main::y#2 -- vbuz1=_inc_vbuz1 + inc.z y + // [10] phi from main::@5 to main::@1 [phi:main::@5->main::@1] + // [10] phi (byte*) main::sc#8 = (byte*) main::sc#10 [phi:main::@5->main::@1#0] -- register_copy + // [10] phi (word) main::count#11 = (word) main::count#10 [phi:main::@5->main::@1#1] -- register_copy + // [10] phi (byte) main::y#2 = (byte) main::y#1 [phi:main::@5->main::@1#2] -- register_copy + jmp __b1 + // main::@4 + __b4: + // (signed char)x*2 + // [22] (signed byte~) main::$5 ← (signed byte)(byte) main::x#2 << (byte) 1 -- vbsaa=vbsz1_rol_1 + lda.z x + asl + // xd = (signed char)x*2-39 + // [23] (signed byte) main::xd#0 ← (signed byte~) main::$5 - (signed byte) $27 -- vbsxx=vbsaa_minus_vbsc1 + tax + axs #$27 + // (signed char)y*2 + // [24] (signed byte~) main::$7 ← (signed byte)(byte) main::y#2 << (byte) 1 -- vbsaa=vbsz1_rol_1 + lda.z y + asl + // yd = (signed char)y*2-24 + // [25] (signed byte) main::yd#0 ← (signed byte~) main::$7 - (signed byte) $18 -- vbsz1=vbsaa_minus_vbsc1 + sec + sbc #$18 + sta.z yd + // mul8s(xd,xd) + // [26] (signed byte) mul8s::a#0 ← (signed byte) main::xd#0 -- vbsz1=vbsxx + stx.z mul8s.a + // [27] (signed byte) mul8s::b#0 ← (signed byte) main::xd#0 -- vbsyy=vbsxx + txa + tay + // [28] call mul8s + // [41] phi from main::@4 to mul8s [phi:main::@4->mul8s] + // [41] phi (signed byte) mul8s::b#2 = (signed byte) mul8s::b#0 [phi:main::@4->mul8s#0] -- register_copy + // [41] phi (signed byte) mul8s::a#2 = (signed byte) mul8s::a#0 [phi:main::@4->mul8s#1] -- register_copy + jsr mul8s + // main::@10 + // mul8s(xd,xd) + // [29] (signed word~) main::$9 ← (signed word)(word) mul8s::m#4 -- vwsz1=vwsz2 + lda.z mul8s.m + sta.z __9 + lda.z mul8s.m+1 + sta.z __9+1 + // mul8s(yd,yd) + // [30] (signed byte) mul8s::a#1 ← (signed byte) main::yd#0 -- vbsz1=vbsz2 + lda.z yd + sta.z mul8s.a + // [31] (signed byte) mul8s::b#1 ← (signed byte) main::yd#0 -- vbsyy=vbsz1 + ldy.z yd + // [32] call mul8s + // [41] phi from main::@10 to mul8s [phi:main::@10->mul8s] + // [41] phi (signed byte) mul8s::b#2 = (signed byte) mul8s::b#1 [phi:main::@10->mul8s#0] -- register_copy + // [41] phi (signed byte) mul8s::a#2 = (signed byte) mul8s::a#1 [phi:main::@10->mul8s#1] -- register_copy + jsr mul8s + // main::@11 + // mul8s(yd,yd) + // [33] (signed word~) main::$10 ← (signed word)(word) mul8s::m#4 + // dist_sq = mul8s(xd,xd) + mul8s(yd,yd) + // [34] (signed word) main::dist_sq#0 ← (signed word~) main::$9 + (signed word~) main::$10 -- vwsz1=vwsz1_plus_vwsz2 + lda.z dist_sq + clc + adc.z __10 + sta.z dist_sq + lda.z dist_sq+1 + adc.z __10+1 + sta.z dist_sq+1 + // if(dist_sq<2*9*2*9) + // [35] if((signed word) main::dist_sq#0>=(signed word)(number) 2*(number) 9*(number) 2*(number) 9) goto main::@6 -- vwsz1_ge_vwsc1_then_la1 + lda.z dist_sq + cmp #<2*9*2*9 + lda.z dist_sq+1 + sbc #>2*9*2*9 + bvc !+ + eor #$80 + !: + bpl __b6 + // main::@7 + // *sc = '*' + // [36] *((byte*) main::sc#10) ← (byte) '*' -- _deref_pbuz1=vbuc1 + lda #'*' + ldy #0 + sta (sc),y + // count++; + // [37] (word) main::count#1 ← ++ (word) main::count#10 -- vwuz1=_inc_vwuz1 + inc.z count + bne !+ + inc.z count+1 + !: + // [38] phi from main::@11 main::@7 to main::@6 [phi:main::@11/main::@7->main::@6] + // [38] phi (word) main::count#12 = (word) main::count#10 [phi:main::@11/main::@7->main::@6#0] -- register_copy + // main::@6 + __b6: + // sc++; + // [39] (byte*) main::sc#1 ← ++ (byte*) main::sc#10 -- pbuz1=_inc_pbuz1 + inc.z sc + bne !+ + inc.z sc+1 + !: + // for(char x=0;x<40;x++) + // [40] (byte) main::x#1 ← ++ (byte) main::x#2 -- vbuz1=_inc_vbuz1 + inc.z x + // [19] phi from main::@6 to main::@3 [phi:main::@6->main::@3] + // [19] phi (word) main::count#10 = (word) main::count#12 [phi:main::@6->main::@3#0] -- register_copy + // [19] phi (byte*) main::sc#10 = (byte*) main::sc#1 [phi:main::@6->main::@3#1] -- register_copy + // [19] phi (byte) main::x#2 = (byte) main::x#1 [phi:main::@6->main::@3#2] -- register_copy + jmp __b3 + s: .text " chars" + .byte 0 +} + // mul8s +// Multiply of two signed chars to a signed int +// Fixes offsets introduced by using unsigned multiplication +// mul8s(signed byte zp($a) a, signed byte register(Y) b) +mul8s: { + .label m = 6 + .label a = $a + // mul8u((char)a, (char) b) + // [42] (byte) mul8u::a#1 ← (byte)(signed byte) mul8s::a#2 -- vbuxx=vbuz1 + ldx.z a + // [43] (byte) mul8u::b#0 ← (byte)(signed byte) mul8s::b#2 -- vbuaa=vbuyy + tya + // [44] call mul8u + jsr mul8u + // [45] (word) mul8u::return#2 ← (word) mul8u::res#2 + // mul8s::@5 + // m = mul8u((char)a, (char) b) + // [46] (word) mul8s::m#0 ← (word) mul8u::return#2 + // if(a<0) + // [47] if((signed byte) mul8s::a#2>=(signed byte) 0) goto mul8s::@1 -- vbsz1_ge_0_then_la1 + lda.z a + cmp #0 + bpl __b1 + // mul8s::@3 + // >m + // [48] (byte~) mul8s::$6 ← > (word) mul8s::m#0 -- vbuaa=_hi_vwuz1 + lda.z m+1 + // >m = (>m)-(char)b + // [49] (byte~) mul8s::$11 ← (byte~) mul8s::$6 - (byte)(signed byte) mul8s::b#2 -- vbuaa=vbuaa_minus_vbuyy + sty.z $ff + sec + sbc.z $ff + // [50] (word) mul8s::m#1 ← (word) mul8s::m#0 hi= (byte~) mul8s::$11 -- vwuz1=vwuz1_sethi_vbuaa + sta.z m+1 + // [51] phi from mul8s::@3 mul8s::@5 to mul8s::@1 [phi:mul8s::@3/mul8s::@5->mul8s::@1] + // [51] phi (word) mul8s::m#5 = (word) mul8s::m#1 [phi:mul8s::@3/mul8s::@5->mul8s::@1#0] -- register_copy + // mul8s::@1 + __b1: + // if(b<0) + // [52] if((signed byte) mul8s::b#2>=(signed byte) 0) goto mul8s::@2 -- vbsyy_ge_0_then_la1 + cpy #0 + bpl __b2 + // mul8s::@4 + // >m + // [53] (byte~) mul8s::$9 ← > (word) mul8s::m#5 -- vbuaa=_hi_vwuz1 + lda.z m+1 + // >m = (>m)-(char)a + // [54] (byte~) mul8s::$12 ← (byte~) mul8s::$9 - (byte)(signed byte) mul8s::a#2 -- vbuaa=vbuaa_minus_vbuz1 + sec + sbc.z a + // [55] (word) mul8s::m#2 ← (word) mul8s::m#5 hi= (byte~) mul8s::$12 -- vwuz1=vwuz1_sethi_vbuaa + sta.z m+1 + // [56] phi from mul8s::@1 mul8s::@4 to mul8s::@2 [phi:mul8s::@1/mul8s::@4->mul8s::@2] + // [56] phi (word) mul8s::m#4 = (word) mul8s::m#5 [phi:mul8s::@1/mul8s::@4->mul8s::@2#0] -- register_copy + // mul8s::@2 + __b2: + // mul8s::@return + // } + // [57] return + rts +} + // mul8u +// Perform binary multiplication of two unsigned 8-bit chars into a 16-bit unsigned int +// mul8u(byte register(X) a, byte register(A) b) +mul8u: { + .label mb = 8 + .label res = 6 + .label return = 6 + // mb = b + // [58] (word) mul8u::mb#0 ← (word)(byte) mul8u::b#0 -- vwuz1=_word_vbuaa + sta.z mb + lda #0 + sta.z mb+1 + // [59] phi from mul8u to mul8u::@1 [phi:mul8u->mul8u::@1] + // [59] phi (word) mul8u::mb#2 = (word) mul8u::mb#0 [phi:mul8u->mul8u::@1#0] -- register_copy + // [59] phi (word) mul8u::res#2 = (word) 0 [phi:mul8u->mul8u::@1#1] -- vwuz1=vwuc1 + sta.z res + sta.z res+1 + // [59] phi (byte) mul8u::a#2 = (byte) mul8u::a#1 [phi:mul8u->mul8u::@1#2] -- register_copy + // mul8u::@1 + __b1: + // while(a!=0) + // [60] if((byte) mul8u::a#2!=(byte) 0) goto mul8u::@2 -- vbuxx_neq_0_then_la1 + cpx #0 + bne __b2 + // mul8u::@return + // } + // [61] return + rts + // mul8u::@2 + __b2: + // a&1 + // [62] (byte~) mul8u::$1 ← (byte) mul8u::a#2 & (byte) 1 -- vbuaa=vbuxx_band_vbuc1 + txa + and #1 + // if( (a&1) != 0) + // [63] if((byte~) mul8u::$1==(byte) 0) goto mul8u::@3 -- vbuaa_eq_0_then_la1 + cmp #0 + beq __b3 + // mul8u::@4 + // res = res + mb + // [64] (word) mul8u::res#1 ← (word) mul8u::res#2 + (word) mul8u::mb#2 -- vwuz1=vwuz1_plus_vwuz2 + lda.z res + clc + adc.z mb + sta.z res + lda.z res+1 + adc.z mb+1 + sta.z res+1 + // [65] phi from mul8u::@2 mul8u::@4 to mul8u::@3 [phi:mul8u::@2/mul8u::@4->mul8u::@3] + // [65] phi (word) mul8u::res#6 = (word) mul8u::res#2 [phi:mul8u::@2/mul8u::@4->mul8u::@3#0] -- register_copy + // mul8u::@3 + __b3: + // a = a>>1 + // [66] (byte) mul8u::a#0 ← (byte) mul8u::a#2 >> (byte) 1 -- vbuxx=vbuxx_ror_1 + txa + lsr + tax + // mb = mb<<1 + // [67] (word) mul8u::mb#1 ← (word) mul8u::mb#2 << (byte) 1 -- vwuz1=vwuz1_rol_1 + asl.z mb + rol.z mb+1 + // [59] phi from mul8u::@3 to mul8u::@1 [phi:mul8u::@3->mul8u::@1] + // [59] phi (word) mul8u::mb#2 = (word) mul8u::mb#1 [phi:mul8u::@3->mul8u::@1#0] -- register_copy + // [59] phi (word) mul8u::res#2 = (word) mul8u::res#6 [phi:mul8u::@3->mul8u::@1#1] -- register_copy + // [59] phi (byte) mul8u::a#2 = (byte) mul8u::a#0 [phi:mul8u::@3->mul8u::@1#2] -- register_copy + jmp __b1 +} + // cputs +// Output a NUL-terminated string at the current cursor position +// cputs(byte* zp(8) s) +cputs: { + .label s = 8 + // [69] phi from cputs cputs::@2 to cputs::@1 [phi:cputs/cputs::@2->cputs::@1] + // [69] phi (to_nomodify byte*) cputs::s#3 = (to_nomodify byte*) cputs::s#4 [phi:cputs/cputs::@2->cputs::@1#0] -- register_copy + // cputs::@1 + __b1: + // c=*s++ + // [70] (byte) cputs::c#1 ← *((to_nomodify byte*) cputs::s#3) -- vbuaa=_deref_pbuz1 + ldy #0 + lda (s),y + // while(c=*s++) + // [71] (to_nomodify byte*) cputs::s#0 ← ++ (to_nomodify byte*) cputs::s#3 -- pbuz1=_inc_pbuz1 + inc.z s + bne !+ + inc.z s+1 + !: + // [72] if((byte) 0!=(byte) cputs::c#1) goto cputs::@2 -- vbuc1_neq_vbuaa_then_la1 + cmp #0 + bne __b2 + // cputs::@return + // } + // [73] return + rts + // cputs::@2 + __b2: + // cputc(c) + // [74] (byte) cputc::c#0 ← (byte) cputs::c#1 + // [75] call cputc + // [76] phi from cputs::@2 to cputc [phi:cputs::@2->cputc] + // [76] phi (byte) cputc::c#3 = (byte) cputc::c#0 [phi:cputs::@2->cputc#0] -- register_copy + jsr cputc + jmp __b1 +} + // cputc +// Output one character at the current cursor position +// Moves the cursor forward. Scrolls the entire screen if needed +// cputc(byte register(A) c) +cputc: { + // if(c=='\n') + // [77] if((byte) cputc::c#3==(byte) ' ') goto cputc::@1 -- vbuaa_eq_vbuc1_then_la1 + cmp #'\n' + beq __b1 + // cputc::@2 + // *conio_cursor_text++ = c + // [78] *((byte*) conio_cursor_text) ← (byte) cputc::c#3 -- _deref_pbuz1=vbuaa + ldy #0 + sta (conio_cursor_text),y + // *conio_cursor_text++ = c; + // [79] (byte*) conio_cursor_text ← ++ (byte*) conio_cursor_text -- pbuz1=_inc_pbuz1 + inc.z conio_cursor_text + bne !+ + inc.z conio_cursor_text+1 + !: + // *conio_cursor_color++ = conio_textcolor + // [80] *((byte*) conio_cursor_color) ← (const nomodify byte) CONIO_TEXTCOLOR_DEFAULT -- _deref_pbuz1=vbuc1 + lda #CONIO_TEXTCOLOR_DEFAULT + ldy #0 + sta (conio_cursor_color),y + // *conio_cursor_color++ = conio_textcolor; + // [81] (byte*) conio_cursor_color ← ++ (byte*) conio_cursor_color -- pbuz1=_inc_pbuz1 + inc.z conio_cursor_color + bne !+ + inc.z conio_cursor_color+1 + !: + // if(++conio_cursor_x==CONIO_WIDTH) + // [82] (byte) conio_cursor_x ← ++ (byte) conio_cursor_x -- vbuz1=_inc_vbuz1 + inc.z conio_cursor_x + // [83] if((byte) conio_cursor_x!=(byte) $28) goto cputc::@return -- vbuz1_neq_vbuc1_then_la1 + lda #$28 + cmp.z conio_cursor_x + bne __breturn + // cputc::@3 + // conio_cursor_x = 0 + // [84] (byte) conio_cursor_x ← (byte) 0 -- vbuz1=vbuc1 + lda #0 + sta.z conio_cursor_x + // ++conio_cursor_y; + // [85] (byte) conio_cursor_y ← ++ (byte) conio_cursor_y -- vbuz1=_inc_vbuz1 + inc.z conio_cursor_y + // cscroll() + // [86] call cscroll + jsr cscroll + // cputc::@return + __breturn: + // } + // [87] return + rts + // [88] phi from cputc to cputc::@1 [phi:cputc->cputc::@1] + // cputc::@1 + __b1: + // cputln() + // [89] call cputln + jsr cputln + rts +} + // cputln +// Print a newline +cputln: { + .label __1 = $d + .label __2 = $f + .label ln_offset = $16 + // ln_offset = CONIO_WIDTH - conio_cursor_x + // [90] (word) cputln::ln_offset#0 ← (byte) $28 - (byte) conio_cursor_x -- vwuz1=vbuc1_minus_vbuz2 + sec + lda #$28 + sbc.z conio_cursor_x + sta.z ln_offset + lda #0 + sbc #0 + sta.z ln_offset+1 + // conio_cursor_text + ln_offset + // [91] (byte*~) cputln::$1 ← (byte*) conio_cursor_text + (word) cputln::ln_offset#0 -- pbuz1=pbuz1_plus_vwuz2 + lda.z __1 + clc + adc.z ln_offset + sta.z __1 + lda.z __1+1 + adc.z ln_offset+1 + sta.z __1+1 + // conio_cursor_text = conio_cursor_text + ln_offset + // [92] (byte*) conio_cursor_text ← (byte*~) cputln::$1 + // conio_cursor_color + ln_offset + // [93] (byte*~) cputln::$2 ← (byte*) conio_cursor_color + (word) cputln::ln_offset#0 -- pbuz1=pbuz1_plus_vwuz2 + lda.z __2 + clc + adc.z ln_offset + sta.z __2 + lda.z __2+1 + adc.z ln_offset+1 + sta.z __2+1 + // conio_cursor_color = conio_cursor_color + ln_offset + // [94] (byte*) conio_cursor_color ← (byte*~) cputln::$2 + // conio_cursor_x = 0 + // [95] (byte) conio_cursor_x ← (byte) 0 -- vbuz1=vbuc1 + lda #0 + sta.z conio_cursor_x + // conio_cursor_y++; + // [96] (byte) conio_cursor_y ← ++ (byte) conio_cursor_y -- vbuz1=_inc_vbuz1 + inc.z conio_cursor_y + // cscroll() + // [97] call cscroll + jsr cscroll + // cputln::@return + // } + // [98] return + rts +} + // cscroll +// Scroll the entire screen if the cursor is beyond the last line +cscroll: { + .label __7 = $d + .label __8 = $f + // if(conio_cursor_y==CONIO_HEIGHT) + // [99] if((byte) conio_cursor_y!=(byte) $19) goto cscroll::@return -- vbuz1_neq_vbuc1_then_la1 + lda #$19 + cmp.z conio_cursor_y + bne __breturn + // [100] phi from cscroll to cscroll::@1 [phi:cscroll->cscroll::@1] + // cscroll::@1 + // memcpy(CONIO_SCREEN_TEXT, CONIO_SCREEN_TEXT+CONIO_WIDTH, CONIO_BYTES-CONIO_WIDTH) + // [101] call memcpy + // [123] phi from cscroll::@1 to memcpy [phi:cscroll::@1->memcpy] + // [123] phi (void*) memcpy::destination#2 = (void*)(const nomodify byte*) CONIO_SCREEN_TEXT [phi:cscroll::@1->memcpy#0] -- pvoz1=pvoc1 + lda #CONIO_SCREEN_TEXT + sta.z memcpy.destination+1 + // [123] phi (void*) memcpy::source#2 = (void*)(const nomodify byte*) CONIO_SCREEN_TEXT+(byte) $28 [phi:cscroll::@1->memcpy#1] -- pvoz1=pvoc1 + lda #CONIO_SCREEN_TEXT+$28 + sta.z memcpy.source+1 + jsr memcpy + // [102] phi from cscroll::@1 to cscroll::@2 [phi:cscroll::@1->cscroll::@2] + // cscroll::@2 + // memcpy(CONIO_SCREEN_COLORS, CONIO_SCREEN_COLORS+CONIO_WIDTH, CONIO_BYTES-CONIO_WIDTH) + // [103] call memcpy + // [123] phi from cscroll::@2 to memcpy [phi:cscroll::@2->memcpy] + // [123] phi (void*) memcpy::destination#2 = (void*)(const nomodify byte*) CONIO_SCREEN_COLORS [phi:cscroll::@2->memcpy#0] -- pvoz1=pvoc1 + lda #CONIO_SCREEN_COLORS + sta.z memcpy.destination+1 + // [123] phi (void*) memcpy::source#2 = (void*)(const nomodify byte*) CONIO_SCREEN_COLORS+(byte) $28 [phi:cscroll::@2->memcpy#1] -- pvoz1=pvoc1 + lda #CONIO_SCREEN_COLORS+$28 + sta.z memcpy.source+1 + jsr memcpy + // [104] phi from cscroll::@2 to cscroll::@3 [phi:cscroll::@2->cscroll::@3] + // cscroll::@3 + // memset(CONIO_SCREEN_TEXT+CONIO_BYTES-CONIO_WIDTH, ' ', CONIO_WIDTH) + // [105] call memset + // [114] phi from cscroll::@3 to memset [phi:cscroll::@3->memset] + // [114] phi (byte) memset::c#5 = (byte) ' ' [phi:cscroll::@3->memset#0] -- vbuxx=vbuc1 + ldx #' ' + // [114] phi (void*) memset::str#4 = (void*)(const nomodify byte*) CONIO_SCREEN_TEXT+(word)(number) $19*(number) $28-(byte) $28 [phi:cscroll::@3->memset#1] -- pvoz1=pvoc1 + lda #CONIO_SCREEN_TEXT+$19*$28-$28 + sta.z memset.str+1 + // [114] phi (word) memset::num#3 = (byte) $28 [phi:cscroll::@3->memset#2] -- vwuz1=vbuc1 + lda #<$28 + sta.z memset.num + lda #>$28 + sta.z memset.num+1 + jsr memset + // [106] phi from cscroll::@3 to cscroll::@4 [phi:cscroll::@3->cscroll::@4] + // cscroll::@4 + // memset(CONIO_SCREEN_COLORS+CONIO_BYTES-CONIO_WIDTH, conio_textcolor, CONIO_WIDTH) + // [107] call memset + // [114] phi from cscroll::@4 to memset [phi:cscroll::@4->memset] + // [114] phi (byte) memset::c#5 = (const nomodify byte) CONIO_TEXTCOLOR_DEFAULT [phi:cscroll::@4->memset#0] -- vbuxx=vbuc1 + ldx #CONIO_TEXTCOLOR_DEFAULT + // [114] phi (void*) memset::str#4 = (void*)(const nomodify byte*) CONIO_SCREEN_COLORS+(word)(number) $19*(number) $28-(byte) $28 [phi:cscroll::@4->memset#1] -- pvoz1=pvoc1 + lda #CONIO_SCREEN_COLORS+$19*$28-$28 + sta.z memset.str+1 + // [114] phi (word) memset::num#3 = (byte) $28 [phi:cscroll::@4->memset#2] -- vwuz1=vbuc1 + lda #<$28 + sta.z memset.num + lda #>$28 + sta.z memset.num+1 + jsr memset + // cscroll::@5 + // conio_cursor_text-CONIO_WIDTH + // [108] (byte*~) cscroll::$7 ← (byte*) conio_cursor_text - (byte) $28 -- pbuz1=pbuz1_minus_vwuc1 + lda.z __7 + sec + sbc #<$28 + sta.z __7 + lda.z __7+1 + sbc #>$28 + sta.z __7+1 + // conio_cursor_text = conio_cursor_text-CONIO_WIDTH + // [109] (byte*) conio_cursor_text ← (byte*~) cscroll::$7 + // conio_cursor_color-CONIO_WIDTH + // [110] (byte*~) cscroll::$8 ← (byte*) conio_cursor_color - (byte) $28 -- pbuz1=pbuz1_minus_vwuc1 + lda.z __8 + sec + sbc #<$28 + sta.z __8 + lda.z __8+1 + sbc #>$28 + sta.z __8+1 + // conio_cursor_color = conio_cursor_color-CONIO_WIDTH + // [111] (byte*) conio_cursor_color ← (byte*~) cscroll::$8 + // conio_cursor_y--; + // [112] (byte) conio_cursor_y ← -- (byte) conio_cursor_y -- vbuz1=_dec_vbuz1 + dec.z conio_cursor_y + // cscroll::@return + __breturn: + // } + // [113] 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(void* zp($16) str, byte register(X) c, word zp($12) num) +memset: { + .label end = $12 + .label dst = $16 + .label num = $12 + .label str = $16 + // if(num>0) + // [115] if((word) memset::num#3<=(byte) 0) goto memset::@return -- vwuz1_le_0_then_la1 + lda.z num + bne !+ + lda.z num+1 + beq __breturn + !: + // memset::@1 + // end = (char*)str + num + // [116] (byte*) memset::end#0 ← (byte*)(void*) memset::str#4 + (word) memset::num#3 -- pbuz1=pbuz2_plus_vwuz1 + lda.z end + clc + adc.z str + sta.z end + lda.z end+1 + adc.z str+1 + sta.z end+1 + // [117] (byte*) memset::dst#4 ← (byte*)(void*) memset::str#4 + // [118] phi from memset::@1 memset::@3 to memset::@2 [phi:memset::@1/memset::@3->memset::@2] + // [118] phi (byte*) memset::dst#2 = (byte*) memset::dst#4 [phi:memset::@1/memset::@3->memset::@2#0] -- register_copy + // memset::@2 + __b2: + // for(char* dst = str; dst!=end; dst++) + // [119] if((byte*) memset::dst#2!=(byte*) memset::end#0) goto memset::@3 -- pbuz1_neq_pbuz2_then_la1 + lda.z dst+1 + cmp.z end+1 + bne __b3 + lda.z dst + cmp.z end + bne __b3 + // memset::@return + __breturn: + // } + // [120] return + rts + // memset::@3 + __b3: + // *dst = c + // [121] *((byte*) memset::dst#2) ← (byte) memset::c#5 -- _deref_pbuz1=vbuxx + txa + ldy #0 + sta (dst),y + // for(char* dst = str; dst!=end; dst++) + // [122] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2 -- pbuz1=_inc_pbuz1 + inc.z dst + bne !+ + inc.z dst+1 + !: + jmp __b2 +} + // memcpy +// Copy block of memory (forwards) +// Copies the values of num bytes from the location pointed to by source directly to the memory block pointed to by destination. +// memcpy(void* zp($16) destination, void* zp($12) source) +memcpy: { + .label src_end = $14 + .label dst = $16 + .label src = $12 + .label source = $12 + .label destination = $16 + // src_end = (char*)source+num + // [124] (byte*) memcpy::src_end#0 ← (byte*)(void*) memcpy::source#2 + (word)(number) $19*(number) $28-(number) $28 -- pbuz1=pbuz2_plus_vwuc1 + lda.z source + clc + adc #<$19*$28-$28 + sta.z src_end + lda.z source+1 + adc #>$19*$28-$28 + sta.z src_end+1 + // [125] (byte*) memcpy::src#4 ← (byte*)(void*) memcpy::source#2 + // [126] (byte*) memcpy::dst#4 ← (byte*)(void*) memcpy::destination#2 + // [127] phi from memcpy memcpy::@2 to memcpy::@1 [phi:memcpy/memcpy::@2->memcpy::@1] + // [127] phi (byte*) memcpy::dst#2 = (byte*) memcpy::dst#4 [phi:memcpy/memcpy::@2->memcpy::@1#0] -- register_copy + // [127] phi (byte*) memcpy::src#2 = (byte*) memcpy::src#4 [phi:memcpy/memcpy::@2->memcpy::@1#1] -- register_copy + // memcpy::@1 + __b1: + // while(src!=src_end) + // [128] if((byte*) memcpy::src#2!=(byte*) memcpy::src_end#0) goto memcpy::@2 -- pbuz1_neq_pbuz2_then_la1 + lda.z src+1 + cmp.z src_end+1 + bne __b2 + lda.z src + cmp.z src_end + bne __b2 + // memcpy::@return + // } + // [129] return + rts + // memcpy::@2 + __b2: + // *dst++ = *src++ + // [130] *((byte*) memcpy::dst#2) ← *((byte*) memcpy::src#2) -- _deref_pbuz1=_deref_pbuz2 + ldy #0 + lda (src),y + sta (dst),y + // *dst++ = *src++; + // [131] (byte*) memcpy::dst#1 ← ++ (byte*) memcpy::dst#2 -- pbuz1=_inc_pbuz1 + inc.z dst + bne !+ + inc.z dst+1 + !: + // [132] (byte*) memcpy::src#1 ← ++ (byte*) memcpy::src#2 -- pbuz1=_inc_pbuz1 + inc.z src + bne !+ + inc.z src+1 + !: + jmp __b1 +} + // printf_uint +// Print an unsigned int using a specific format +// printf_uint(word zp(2) uvalue) +printf_uint: { + .label uvalue = 2 + // printf_uint::@1 + // printf_buffer.sign = format.sign_always?'+':0 + // [134] *((byte*)&(struct printf_buffer_number) printf_buffer) ← (byte) 0 -- _deref_pbuc1=vbuc2 + // Handle any sign + lda #0 + sta printf_buffer + // utoa(uvalue, printf_buffer.digits, format.radix) + // [135] (word) utoa::value#1 ← (word) printf_uint::uvalue#0 + // [136] call utoa + // Format number into buffer + // [147] phi from printf_uint::@1 to utoa [phi:printf_uint::@1->utoa] + jsr utoa + // printf_uint::@2 + // printf_number_buffer(printf_buffer, format) + // [137] (byte) printf_number_buffer::buffer_sign#0 ← *((byte*)&(struct printf_buffer_number) printf_buffer) -- vbuaa=_deref_pbuc1 + lda printf_buffer + // [138] call printf_number_buffer + // Print using format + // [140] phi from printf_uint::@2 to printf_number_buffer [phi:printf_uint::@2->printf_number_buffer] + jsr printf_number_buffer + // printf_uint::@return + // } + // [139] return + rts +} + // printf_number_buffer +// Print the contents of the number buffer using a specific format. +// This handles minimum length, zero-filling, and left/right justification from the format +// printf_number_buffer(byte register(A) buffer_sign) +printf_number_buffer: { + .label buffer_digits = printf_buffer+OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_DIGITS + // printf_number_buffer::@1 + // if(buffer.sign) + // [141] if((byte) 0==(byte) printf_number_buffer::buffer_sign#0) goto printf_number_buffer::@2 -- vbuc1_eq_vbuaa_then_la1 + cmp #0 + beq __b2 + // printf_number_buffer::@3 + // cputc(buffer.sign) + // [142] (byte) cputc::c#2 ← (byte) printf_number_buffer::buffer_sign#0 + // [143] call cputc + // [76] phi from printf_number_buffer::@3 to cputc [phi:printf_number_buffer::@3->cputc] + // [76] phi (byte) cputc::c#3 = (byte) cputc::c#2 [phi:printf_number_buffer::@3->cputc#0] -- register_copy + jsr cputc + // [144] phi from printf_number_buffer::@1 printf_number_buffer::@3 to printf_number_buffer::@2 [phi:printf_number_buffer::@1/printf_number_buffer::@3->printf_number_buffer::@2] + // printf_number_buffer::@2 + __b2: + // cputs(buffer.digits) + // [145] call cputs + // [68] phi from printf_number_buffer::@2 to cputs [phi:printf_number_buffer::@2->cputs] + // [68] phi (to_nomodify byte*) cputs::s#4 = (const byte*) printf_number_buffer::buffer_digits#0 [phi:printf_number_buffer::@2->cputs#0] -- pbuz1=pbuc1 + lda #buffer_digits + sta.z cputs.s+1 + jsr cputs + // printf_number_buffer::@return + // } + // [146] return + rts +} + // utoa +// Converts unsigned number value to a string representing it in RADIX format. +// If the leading digits are zero they are not included in the string. +// - value : The number to be converted to RADIX +// - buffer : receives the string representing the number and zero-termination. +// - radix : The radix to convert the number to (from the enum RADIX) +// utoa(word zp(2) value, byte* zp($12) buffer) +utoa: { + .const max_digits = 5 + .label digit_value = $16 + .label buffer = $12 + .label digit = $a + .label value = 2 + // [148] phi from utoa to utoa::@1 [phi:utoa->utoa::@1] + // [148] phi (byte*) utoa::buffer#11 = (byte*)&(struct printf_buffer_number) printf_buffer+(const byte) OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_DIGITS [phi:utoa->utoa::@1#0] -- pbuz1=pbuc1 + lda #printf_buffer+OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_DIGITS + sta.z buffer+1 + // [148] phi (byte) utoa::started#2 = (byte) 0 [phi:utoa->utoa::@1#1] -- vbuxx=vbuc1 + ldx #0 + // [148] phi (word) utoa::value#2 = (word) utoa::value#1 [phi:utoa->utoa::@1#2] -- register_copy + // [148] phi (byte) utoa::digit#2 = (byte) 0 [phi:utoa->utoa::@1#3] -- vbuz1=vbuc1 + txa + sta.z digit + // utoa::@1 + __b1: + // for( char digit=0; digit= digit_value) + // [157] if((byte) 0!=(byte) utoa::started#2) goto utoa::@5 -- vbuc1_neq_vbuxx_then_la1 + cpx #0 + bne __b5 + // utoa::@7 + // [158] if((word) utoa::value#2>=(word) utoa::digit_value#0) goto utoa::@5 -- vwuz1_ge_vwuz2_then_la1 + cmp.z value+1 + bne !+ + lda.z digit_value + cmp.z value + beq __b5 + !: + bcc __b5 + // [159] phi from utoa::@7 to utoa::@4 [phi:utoa::@7->utoa::@4] + // [159] phi (byte*) utoa::buffer#14 = (byte*) utoa::buffer#11 [phi:utoa::@7->utoa::@4#0] -- register_copy + // [159] phi (byte) utoa::started#4 = (byte) utoa::started#2 [phi:utoa::@7->utoa::@4#1] -- register_copy + // [159] phi (word) utoa::value#6 = (word) utoa::value#2 [phi:utoa::@7->utoa::@4#2] -- register_copy + // utoa::@4 + __b4: + // for( char digit=0; digitutoa::@1] + // [148] phi (byte*) utoa::buffer#11 = (byte*) utoa::buffer#14 [phi:utoa::@4->utoa::@1#0] -- register_copy + // [148] phi (byte) utoa::started#2 = (byte) utoa::started#4 [phi:utoa::@4->utoa::@1#1] -- register_copy + // [148] phi (word) utoa::value#2 = (word) utoa::value#6 [phi:utoa::@4->utoa::@1#2] -- register_copy + // [148] phi (byte) utoa::digit#2 = (byte) utoa::digit#1 [phi:utoa::@4->utoa::@1#3] -- register_copy + jmp __b1 + // utoa::@5 + __b5: + // utoa_append(buffer++, value, digit_value) + // [161] (byte*) utoa_append::buffer#0 ← (byte*) utoa::buffer#11 + // [162] (word) utoa_append::value#0 ← (word) utoa::value#2 + // [163] (word) utoa_append::sub#0 ← (word) utoa::digit_value#0 + // [164] call utoa_append + // [168] phi from utoa::@5 to utoa_append [phi:utoa::@5->utoa_append] + jsr utoa_append + // utoa_append(buffer++, value, digit_value) + // [165] (word) utoa_append::return#0 ← (word) utoa_append::value#2 + // utoa::@6 + // value = utoa_append(buffer++, value, digit_value) + // [166] (word) utoa::value#0 ← (word) utoa_append::return#0 + // value = utoa_append(buffer++, value, digit_value); + // [167] (byte*) utoa::buffer#4 ← ++ (byte*) utoa::buffer#11 -- pbuz1=_inc_pbuz1 + inc.z buffer + bne !+ + inc.z buffer+1 + !: + // [159] phi from utoa::@6 to utoa::@4 [phi:utoa::@6->utoa::@4] + // [159] phi (byte*) utoa::buffer#14 = (byte*) utoa::buffer#4 [phi:utoa::@6->utoa::@4#0] -- register_copy + // [159] phi (byte) utoa::started#4 = (byte) 1 [phi:utoa::@6->utoa::@4#1] -- vbuxx=vbuc1 + ldx #1 + // [159] phi (word) utoa::value#6 = (word) utoa::value#0 [phi:utoa::@6->utoa::@4#2] -- register_copy + jmp __b4 +} + // utoa_append +// Used to convert a single digit of an unsigned number value to a string representation +// Counts a single digit up from '0' as long as the value is larger than sub. +// Each time the digit is increased sub is subtracted from value. +// - buffer : pointer to the char that receives the digit +// - value : The value where the digit will be derived from +// - sub : the value of a '1' in the digit. Subtracted continually while the digit is increased. +// (For decimal the subs used are 10000, 1000, 100, 10, 1) +// returns : the value reduced by sub * digit so that it is less than sub. +// utoa_append(byte* zp($12) buffer, word zp(2) value, word zp($16) sub) +utoa_append: { + .label buffer = $12 + .label value = 2 + .label sub = $16 + .label return = 2 + // [169] phi from utoa_append to utoa_append::@1 [phi:utoa_append->utoa_append::@1] + // [169] phi (byte) utoa_append::digit#2 = (byte) 0 [phi:utoa_append->utoa_append::@1#0] -- vbuxx=vbuc1 + ldx #0 + // [169] phi (word) utoa_append::value#2 = (word) utoa_append::value#0 [phi:utoa_append->utoa_append::@1#1] -- register_copy + // utoa_append::@1 + __b1: + // while (value >= sub) + // [170] if((word) utoa_append::value#2>=(word) utoa_append::sub#0) goto utoa_append::@2 -- vwuz1_ge_vwuz2_then_la1 + lda.z sub+1 + cmp.z value+1 + bne !+ + lda.z sub + cmp.z value + beq __b2 + !: + bcc __b2 + // utoa_append::@3 + // *buffer = DIGITS[digit] + // [171] *((byte*) utoa_append::buffer#0) ← *((const byte*) DIGITS + (byte) utoa_append::digit#2) -- _deref_pbuz1=pbuc1_derefidx_vbuxx + lda DIGITS,x + ldy #0 + sta (buffer),y + // utoa_append::@return + // } + // [172] return + rts + // utoa_append::@2 + __b2: + // digit++; + // [173] (byte) utoa_append::digit#1 ← ++ (byte) utoa_append::digit#2 -- vbuxx=_inc_vbuxx + inx + // value -= sub + // [174] (word) utoa_append::value#1 ← (word) utoa_append::value#2 - (word) utoa_append::sub#0 -- vwuz1=vwuz1_minus_vwuz2 + lda.z value + sec + sbc.z sub + sta.z value + lda.z value+1 + sbc.z sub+1 + sta.z value+1 + // [169] phi from utoa_append::@2 to utoa_append::@1 [phi:utoa_append::@2->utoa_append::@1] + // [169] phi (byte) utoa_append::digit#2 = (byte) utoa_append::digit#1 [phi:utoa_append::@2->utoa_append::@1#0] -- register_copy + // [169] phi (word) utoa_append::value#2 = (word) utoa_append::value#1 [phi:utoa_append::@2->utoa_append::@1#1] -- register_copy + jmp __b1 +} + // gotoxy +// Set the cursor to the specified position +gotoxy: { + .const x = 0 + .const y = 0 + // gotoxy::@1 + // conio_cursor_x = x + // [176] (byte) conio_cursor_x ← (const byte) gotoxy::x#2 -- vbuz1=vbuc1 + lda #x + sta.z conio_cursor_x + // conio_cursor_y = y + // [177] (byte) conio_cursor_y ← (const byte) gotoxy::y#2 -- vbuz1=vbuc1 + lda #y + sta.z conio_cursor_y + // conio_cursor_text = CONIO_SCREEN_TEXT + offset + // [178] (byte*) conio_cursor_text ← (const nomodify byte*) CONIO_SCREEN_TEXT -- pbuz1=pbuc1 + lda #CONIO_SCREEN_TEXT + sta.z conio_cursor_text+1 + // conio_cursor_color = CONIO_SCREEN_COLORS + offset + // [179] (byte*) conio_cursor_color ← (const nomodify byte*) CONIO_SCREEN_COLORS -- pbuz1=pbuc1 + lda #CONIO_SCREEN_COLORS + sta.z conio_cursor_color+1 + // gotoxy::@return + // } + // [180] return + rts +} + // File Data + // The digits used for numbers + DIGITS: .text "0123456789abcdef" + // Values of decimal digits + RADIX_DECIMAL_VALUES: .word $2710, $3e8, $64, $a + // Buffer used for stringified number being printed + printf_buffer: .fill SIZEOF_STRUCT_PRINTF_BUFFER_NUMBER, 0 + diff --git a/src/test/ref/circlechars.sym b/src/test/ref/circlechars.sym new file mode 100644 index 000000000..195bdb3f9 --- /dev/null +++ b/src/test/ref/circlechars.sym @@ -0,0 +1,316 @@ +(label) @1 +(label) @2 +(label) @begin +(label) @end +(const nomodify byte*) CONIO_SCREEN_COLORS = (byte*) 55296 +(const nomodify byte*) CONIO_SCREEN_TEXT = (byte*) 1024 +(const nomodify byte) CONIO_TEXTCOLOR_DEFAULT = (byte) $e +(const byte*) DIGITS[] = (byte*) "0123456789abcdef"z +(const byte) OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_DIGITS = (byte) 1 +(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 word*) RADIX_DECIMAL_VALUES[] = { (word) $2710, (word) $3e8, (word) $64, (word) $a } +(const nomodify byte*) SCREEN = (byte*) 1024 +(const byte) SIZEOF_STRUCT_PRINTF_BUFFER_NUMBER = (byte) $c +(byte*) conio_cursor_color loadstore zp[2]:15 3484376.71875 +(byte*) conio_cursor_text loadstore zp[2]:13 3430770.9230769235 +(byte) conio_cursor_x loadstore zp[1]:11 489798.1428571429 +(byte) conio_cursor_y loadstore zp[1]:12 4735295.735294118 +(void()) cputc((byte) cputc::c) +(label) cputc::@1 +(label) cputc::@2 +(label) cputc::@3 +(label) cputc::@return +(byte) cputc::c +(byte) cputc::c#0 reg byte a 200002.0 +(byte) cputc::c#2 reg byte a 2002.0 +(byte) cputc::c#3 reg byte a 1050502.0 +(void()) cputln() +(byte*~) cputln::$1 zp[2]:13 2.0000002E7 +(byte*~) cputln::$2 zp[2]:15 2.0000002E7 +(label) cputln::@return +(word) cputln::ln_offset +(word) cputln::ln_offset#0 ln_offset zp[2]:22 1.0000001E7 +(void()) cputs((to_nomodify byte*) cputs::s) +(label) cputs::@1 +(label) cputs::@2 +(label) cputs::@return +(byte) cputs::c +(byte) cputs::c#1 reg byte a 100001.0 +(to_nomodify byte*) cputs::s +(to_nomodify byte*) cputs::s#0 s zp[2]:8 50000.5 +(to_nomodify byte*) cputs::s#3 s zp[2]:8 155002.0 +(to_nomodify byte*) cputs::s#4 s zp[2]:8 10001.0 +(void()) cscroll() +(byte*~) cscroll::$7 zp[2]:13 2.00000002E8 +(byte*~) cscroll::$8 zp[2]:15 2.00000002E8 +(label) cscroll::@1 +(label) cscroll::@2 +(label) cscroll::@3 +(label) cscroll::@4 +(label) cscroll::@5 +(label) cscroll::@return +(void()) gotoxy((byte) gotoxy::x , (byte) gotoxy::y) +(label) gotoxy::@1 +(label) gotoxy::@return +(word) gotoxy::offset +(byte) gotoxy::x +(const byte) gotoxy::x#2 x = (byte) 0 +(byte) gotoxy::y +(const byte) gotoxy::y#2 y = (byte) 0 +(void()) main() +(signed word~) main::$10 zp[2]:6 2002.0 +(signed byte~) main::$5 reg byte a 2002.0 +(signed byte~) main::$7 reg byte a 2002.0 +(signed word~) main::$9 zp[2]:18 400.4 +(label) main::@1 +(label) main::@10 +(label) main::@11 +(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 +(word) main::count +(word) main::count#1 count zp[2]:2 2002.0 +(word) main::count#10 count zp[2]:2 178.05555555555557 +(word) main::count#11 count zp[2]:2 53.25 +(word) main::count#12 count zp[2]:2 1001.0 +(signed word) main::dist_sq +(signed word) main::dist_sq#0 dist_sq zp[2]:18 2002.0 +(const byte*) main::s[(byte) 7] = (byte*) " chars" +(byte*) main::sc +(byte*) main::sc#1 sc zp[2]:4 1001.0 +(byte*) main::sc#10 sc zp[2]:4 160.25 +(byte*) main::sc#8 sc zp[2]:4 101.0 +(byte) main::x +(byte) main::x#1 x zp[1]:12 2002.0 +(byte) main::x#2 x zp[1]:12 150.14999999999998 +(signed byte) main::xd +(signed byte) main::xd#0 reg byte x 750.75 +(byte) main::y +(byte) main::y#1 y zp[1]:11 202.0 +(byte) main::y#2 y zp[1]:11 13.173913043478262 +(signed byte) main::yd +(signed byte) main::yd#0 yd zp[1]:17 500.5 +(void*()) memcpy((void*) memcpy::destination , (void*) memcpy::source , (word) memcpy::num) +(label) memcpy::@1 +(label) memcpy::@2 +(label) memcpy::@return +(void*) memcpy::destination +(void*) memcpy::destination#2 destination zp[2]:22 +(byte*) memcpy::dst +(byte*) memcpy::dst#1 dst zp[2]:22 1.00000000001E11 +(byte*) memcpy::dst#2 dst zp[2]:22 1.0033333333466667E11 +(byte*) memcpy::dst#4 dst zp[2]:22 2.000000002E9 +(word) memcpy::num +(void*) memcpy::return +(void*) memcpy::source +(void*) memcpy::source#2 source zp[2]:18 +(byte*) memcpy::src +(byte*) memcpy::src#1 src zp[2]:18 2.00000000002E11 +(byte*) memcpy::src#2 src zp[2]:18 1.0025000000125E11 +(byte*) memcpy::src#4 src zp[2]:18 1.000000001E9 +(byte*) memcpy::src_end +(byte*) memcpy::src_end#0 src_end zp[2]:20 1.262500000025E10 +(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num) +(label) memset::@1 +(label) memset::@2 +(label) memset::@3 +(label) memset::@return +(byte) memset::c +(byte) memset::c#5 reg byte x 1.250000000125E9 +(byte*) memset::dst +(byte*) memset::dst#1 dst zp[2]:22 2.0000000002E10 +(byte*) memset::dst#2 dst zp[2]:22 1.3666666668333332E10 +(byte*) memset::dst#4 dst zp[2]:22 2.000000002E9 +(byte*) memset::end +(byte*) memset::end#0 end zp[2]:18 1.8333333336666665E9 +(word) memset::num +(word) memset::num#3 num zp[2]:18 1.000000001E9 +(void*) memset::return +(void*) memset::str +(void*) memset::str#4 str zp[2]:22 +(signed word()) mul8s((signed byte) mul8s::a , (signed byte) mul8s::b) +(byte~) mul8s::$11 reg byte a 20002.0 +(byte~) mul8s::$12 reg byte a 20002.0 +(byte~) mul8s::$6 reg byte a 20002.0 +(byte~) mul8s::$9 reg byte a 20002.0 +(label) mul8s::@1 +(label) mul8s::@2 +(label) mul8s::@3 +(label) mul8s::@4 +(label) mul8s::@5 +(label) mul8s::@return +(signed byte) mul8s::a +(signed byte) mul8s::a#0 a zp[1]:10 1001.0 +(signed byte) mul8s::a#1 a zp[1]:10 1001.0 +(signed byte) mul8s::a#2 a zp[1]:10 923.3076923076923 +(signed byte) mul8s::b +(signed byte) mul8s::b#0 reg byte y 2002.0 +(signed byte) mul8s::b#1 reg byte y 2002.0 +(signed byte) mul8s::b#2 reg byte y 1091.181818181818 +(word) mul8s::m +(word) mul8s::m#0 m zp[2]:6 10001.0 +(word) mul8s::m#1 m zp[2]:6 20002.0 +(word) mul8s::m#2 m zp[2]:6 20002.0 +(word) mul8s::m#4 m zp[2]:6 5000.5 +(word) mul8s::m#5 m zp[2]:6 12501.25 +(signed word) mul8s::return +(word()) mul8u((byte) mul8u::a , (byte) mul8u::b) +(byte~) mul8u::$1 reg byte a 2.00000002E8 +(label) mul8u::@1 +(label) mul8u::@2 +(label) mul8u::@3 +(label) mul8u::@4 +(label) mul8u::@return +(byte) mul8u::a +(byte) mul8u::a#0 reg byte x 1.00000001E8 +(byte) mul8u::a#1 reg byte x 36667.33333333333 +(byte) mul8u::a#2 reg byte x 6.668333416666667E7 +(byte) mul8u::b +(byte) mul8u::b#0 reg byte a 10001.0 +(word) mul8u::mb +(word) mul8u::mb#0 mb zp[2]:8 200002.0 +(word) mul8u::mb#1 mb zp[2]:8 2.00000002E8 +(word) mul8u::mb#2 mb zp[2]:8 4.287142914285715E7 +(word) mul8u::res +(word) mul8u::res#1 res zp[2]:6 2.00000002E8 +(word) mul8u::res#2 res zp[2]:6 5.0001667333333336E7 +(word) mul8u::res#6 res zp[2]:6 1.00000001E8 +(word) mul8u::return +(word) mul8u::return#2 return zp[2]:6 20002.0 +(struct printf_buffer_number) printf_buffer loadstore mem[12] = {} +(const byte*) printf_buffer_number::digits[(number) $b] = { fill( $b, 0) } +(byte) printf_buffer_number::sign +(byte) printf_format_number::justify_left +(byte) printf_format_number::min_length +(byte) printf_format_number::radix +(byte) printf_format_number::sign_always +(byte) printf_format_number::upper_case +(byte) printf_format_number::zero_padding +(byte) printf_format_string::justify_left +(byte) printf_format_string::min_length +(void()) printf_number_buffer((byte) printf_number_buffer::buffer_sign , (byte*) printf_number_buffer::buffer_digits , (byte) printf_number_buffer::format_min_length , (byte) printf_number_buffer::format_justify_left , (byte) printf_number_buffer::format_sign_always , (byte) printf_number_buffer::format_zero_padding , (byte) printf_number_buffer::format_upper_case , (byte) printf_number_buffer::format_radix) +(label) printf_number_buffer::@1 +(label) printf_number_buffer::@2 +(label) printf_number_buffer::@3 +(label) printf_number_buffer::@return +(struct printf_buffer_number) printf_number_buffer::buffer +(byte*) printf_number_buffer::buffer_digits +(const byte*) printf_number_buffer::buffer_digits#0 buffer_digits = (byte*)&(struct printf_buffer_number) printf_buffer+(const byte) OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_DIGITS +(byte) printf_number_buffer::buffer_sign +(byte) printf_number_buffer::buffer_sign#0 reg byte a 701.0 +(struct printf_format_number) printf_number_buffer::format +(byte) printf_number_buffer::format_justify_left +(byte) printf_number_buffer::format_min_length +(byte) printf_number_buffer::format_radix +(byte) printf_number_buffer::format_sign_always +(byte) printf_number_buffer::format_upper_case +(byte) printf_number_buffer::format_zero_padding +(signed byte) printf_number_buffer::len +(signed byte) printf_number_buffer::padding +(void()) printf_uint((word) printf_uint::uvalue , (byte) printf_uint::format_min_length , (byte) printf_uint::format_justify_left , (byte) printf_uint::format_sign_always , (byte) printf_uint::format_zero_padding , (byte) printf_uint::format_upper_case , (byte) printf_uint::format_radix) +(label) printf_uint::@1 +(label) printf_uint::@2 +(label) printf_uint::@return +(struct printf_format_number) printf_uint::format +(byte) printf_uint::format_justify_left +(byte) printf_uint::format_min_length +(byte) printf_uint::format_radix +(byte) printf_uint::format_sign_always +(byte) printf_uint::format_upper_case +(byte) printf_uint::format_zero_padding +(word) printf_uint::uvalue +(word) printf_uint::uvalue#0 uvalue zp[2]:2 37.33333333333333 +(void()) utoa((word) utoa::value , (byte*) utoa::buffer , (byte) utoa::radix) +(byte~) utoa::$10 reg byte a 20002.0 +(byte~) utoa::$11 reg byte a 2002.0 +(label) utoa::@1 +(label) utoa::@2 +(label) utoa::@3 +(label) utoa::@4 +(label) utoa::@5 +(label) utoa::@6 +(label) utoa::@7 +(label) utoa::@return +(byte*) utoa::buffer +(byte*) utoa::buffer#11 buffer zp[2]:18 3000.4285714285716 +(byte*) utoa::buffer#14 buffer zp[2]:18 15001.5 +(byte*) utoa::buffer#3 buffer zp[2]:18 2002.0 +(byte*) utoa::buffer#4 buffer zp[2]:18 20002.0 +(byte) utoa::digit +(byte) utoa::digit#1 digit zp[1]:10 20002.0 +(byte) utoa::digit#2 digit zp[1]:10 2857.4285714285716 +(word) utoa::digit_value +(word) utoa::digit_value#0 digit_value zp[2]:22 6000.6 +(word*) utoa::digit_values +(byte) utoa::max_digits +(const byte) utoa::max_digits#1 max_digits = (byte) 5 +(byte) utoa::radix +(byte) utoa::started +(byte) utoa::started#2 reg byte x 5000.5 +(byte) utoa::started#4 reg byte x 10001.0 +(word) utoa::value +(word) utoa::value#0 value zp[2]:2 10001.0 +(word) utoa::value#1 value zp[2]:2 551.0 +(word) utoa::value#2 value zp[2]:2 5857.857142857143 +(word) utoa::value#6 value zp[2]:2 15001.5 +(word()) utoa_append((byte*) utoa_append::buffer , (word) utoa_append::value , (word) utoa_append::sub) +(label) utoa_append::@1 +(label) utoa_append::@2 +(label) utoa_append::@3 +(label) utoa_append::@return +(byte*) utoa_append::buffer +(byte*) utoa_append::buffer#0 buffer zp[2]:18 13750.25 +(byte) utoa_append::digit +(byte) utoa_append::digit#1 reg byte x 1.0000001E7 +(byte) utoa_append::digit#2 reg byte x 1.00500015E7 +(word) utoa_append::return +(word) utoa_append::return#0 return zp[2]:2 20002.0 +(word) utoa_append::sub +(word) utoa_append::sub#0 sub zp[2]:22 3335000.5 +(word) utoa_append::value +(word) utoa_append::value#0 value zp[2]:2 36667.33333333333 +(word) utoa_append::value#1 value zp[2]:2 2.0000002E7 +(word) utoa_append::value#2 value zp[2]:2 5018334.166666666 + +zp[2]:2 [ main::count#11 main::count#10 main::count#12 main::count#1 printf_uint::uvalue#0 utoa::value#2 utoa::value#6 utoa::value#1 utoa::value#0 utoa_append::value#2 utoa_append::value#0 utoa_append::value#1 utoa_append::return#0 ] +zp[2]:4 [ main::sc#8 main::sc#10 main::sc#1 ] +reg byte y [ mul8s::b#2 mul8s::b#1 mul8s::b#0 ] +zp[2]:6 [ mul8s::m#4 mul8s::m#5 mul8s::m#1 mul8s::m#0 mul8s::m#2 main::$10 mul8u::return#2 mul8u::res#2 mul8u::res#6 mul8u::res#1 ] +reg byte x [ mul8u::a#2 mul8u::a#1 mul8u::a#0 ] +zp[2]:8 [ cputs::s#3 cputs::s#4 cputs::s#0 mul8u::mb#2 mul8u::mb#0 mul8u::mb#1 ] +reg byte a [ cputc::c#3 cputc::c#0 cputc::c#2 ] +reg byte x [ memset::c#5 ] +zp[1]:10 [ utoa::digit#2 utoa::digit#1 mul8s::a#2 mul8s::a#1 mul8s::a#0 ] +reg byte x [ utoa::started#2 utoa::started#4 ] +reg byte x [ utoa_append::digit#2 utoa_append::digit#1 ] +zp[1]:11 [ conio_cursor_x main::y#2 main::y#1 ] +zp[1]:12 [ conio_cursor_y main::x#2 main::x#1 ] +zp[2]:13 [ conio_cursor_text cputln::$1 cscroll::$7 ] +zp[2]:15 [ conio_cursor_color cputln::$2 cscroll::$8 ] +reg byte a [ main::$5 ] +reg byte x [ main::xd#0 ] +reg byte a [ main::$7 ] +zp[1]:17 [ main::yd#0 ] +zp[2]:18 [ main::$9 main::dist_sq#0 utoa::buffer#11 utoa::buffer#14 utoa::buffer#4 utoa::buffer#3 utoa_append::buffer#0 memcpy::source#2 memcpy::src#2 memcpy::src#4 memcpy::src#1 memset::num#3 memset::end#0 ] +reg byte a [ mul8u::b#0 ] +reg byte a [ mul8s::$6 ] +reg byte a [ mul8s::$11 ] +reg byte a [ mul8s::$9 ] +reg byte a [ mul8s::$12 ] +reg byte a [ mul8u::$1 ] +reg byte a [ cputs::c#1 ] +zp[2]:20 [ memcpy::src_end#0 ] +reg byte a [ printf_number_buffer::buffer_sign#0 ] +reg byte a [ utoa::$11 ] +reg byte a [ utoa::$10 ] +zp[2]:22 [ utoa::digit_value#0 utoa_append::sub#0 cputln::ln_offset#0 memcpy::destination#2 memcpy::dst#2 memcpy::dst#4 memcpy::dst#1 memset::str#4 memset::dst#2 memset::dst#4 memset::dst#1 ] +mem[12] [ printf_buffer ]