6502/kickc
1
0
Fork 0
mirror of https://gitlab.com/camelot/kickc.git synced 2024-12-17 16:31:34 +00:00
Code Issues Projects Releases Wiki Activity

Optimized constant handling in pass 1.

Browse Source
This commit is contained in:
jespergravgaard 2019-09-29 22:42:37 +02:00
parent bfdd2fb0a5
commit 198f4ee55f
16 changed files with 234 additions and 265 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
src/main/java/dk/camelot64/kickc/passes/Pass1GenerateSingleStaticAssignmentForm.java
View File

@ -7,7 +7,10 @@ import dk.camelot64.kickc.model.Program;
import dk.camelot64.kickc.model.iterator.ProgramValue;
import dk.camelot64.kickc.model.iterator.ProgramValueIterator;
import dk.camelot64.kickc.model.statements.*;
import dk.camelot64.kickc.model.symbols.*;
import dk.camelot64.kickc.model.symbols.Procedure;
import dk.camelot64.kickc.model.symbols.Scope;
import dk.camelot64.kickc.model.symbols.Symbol;
import dk.camelot64.kickc.model.symbols.Variable;
import dk.camelot64.kickc.model.types.SymbolType;
import dk.camelot64.kickc.model.types.SymbolTypeArray;
import dk.camelot64.kickc.model.values.*;
@ -70,6 +73,7 @@ public class Pass1GenerateSingleStaticAssignmentForm extends Pass1Base {
/**
* Version a single unversioned variable being assigned
*
* @param lValueRef The variable being assigned
* @param programLValue Program Value usable for updating the variable
* @param source The statement source - usable for error messages
@ -78,20 +82,9 @@ public class Pass1GenerateSingleStaticAssignmentForm extends Pass1Base {
Collection<VariableRef> earlyIdentifiedConstants = getProgram().getEarlyIdentifiedConstants();
Variable assignedVar = getScope().getVariable(lValueRef);
if(assignedVar.isStoragePhiMaster()) {
// Assignment to a non-versioned non-intermediary variable
Variable assignedSymbol = assignedVar;
Variable version;
if(assignedSymbol.isDeclaredConstant() || earlyIdentifiedConstants.contains(assignedSymbol.getRef())) {
Collection<Variable> versions = assignedVar.getScope().getVersions(assignedSymbol);
if(versions.size() != 0) {
throw new CompileError("Error! Constants can not be modified", source);
}
throw new InternalError("ERR!");
//version = assignedSymbol.createVersion();
//version.setDeclaredConstant(true);
} else {
version = assignedSymbol.createVersion();
}
if(assignedVar.isDeclaredConstant() || earlyIdentifiedConstants.contains(assignedVar.getRef()))
throw new InternalError("Error! Constants can not be versioned ", source);
Variable version = assignedVar.createVersion();
programLValue.set(version.getRef());
}
}

2
src/test/ref/dword.cfg
View File

@ -16,7 +16,7 @@ main::@1: scope:[main] from main main::@1
[5] (byte) main::i#2 ← phi( main/(byte) 0 main::@1/(byte) main::i#1 )
[6] (dword) main::b#0 ← (const dword) main::a + (byte) main::i#2
[7] (byte) main::c#0 ← (byte)(dword) main::b#0
[8] *((const byte*) main::SCREEN#0 + (byte) main::i#2) ← (byte) main::c#0
[8] *((const byte*) main::SCREEN + (byte) main::i#2) ← (byte) main::c#0
[9] (byte) main::i#1 ← ++ (byte) main::i#2
[10] if((byte) main::i#1!=(byte) $65) goto main::@1
to:main::@return

21
src/test/ref/dword.log
View File

@ -16,8 +16,8 @@ main::@1: scope:[main] from main main::@1
(dword) main::b#0 ← (dword~) main::$0
(byte~) main::$1 ← ((byte)) (dword) main::b#0
(byte) main::c#0 ← (byte~) main::$1
(byte*) main::SCREEN#0 ← ((byte*)) (number) $400
*((byte*) main::SCREEN#0 + (byte) main::i#2) ← (byte) main::c#0
(byte*) main::SCREEN ← ((byte*)) (number) $400
*((byte*) main::SCREEN + (byte) main::i#2) ← (byte) main::c#0
(byte) main::i#1 ← (byte) main::i#2 + rangenext(0,$64)
(bool~) main::$2 ← (byte) main::i#1 != rangelast(0,$64)
if((bool~) main::$2) goto main::@1
@ -44,7 +44,6 @@ SYMBOL TABLE SSA
(label) main::@1
(label) main::@return
(byte*) main::SCREEN
(byte*) main::SCREEN#0
(dword) main::a
(dword) main::b
(dword) main::b#0
@ -59,7 +58,7 @@ Adding number conversion cast (unumber) $ee6b2800 in (dword) main::a ← (number
Successful SSA optimization PassNAddNumberTypeConversions
Inlining cast (dword) main::a ← (unumber)(number) $ee6b2800
Inlining cast (byte~) main::$1 ← (byte)(dword) main::b#0
Inlining cast (byte*) main::SCREEN#0 ← (byte*)(number) $400
Inlining cast (byte*) main::SCREEN ← (byte*)(number) $400
Successful SSA optimization Pass2InlineCast
Simplifying constant integer cast $ee6b2800
Simplifying constant pointer cast (byte*) 1024
@ -73,7 +72,7 @@ Simple Condition (bool~) main::$2 [11] if((byte) main::i#1!=rangelast(0,$64)) go
Successful SSA optimization Pass2ConditionalJumpSimplification
Constant (const dword) main::a = $ee6b2800
Constant (const byte) main::i#0 = 0
Constant (const byte*) main::SCREEN#0 = (byte*) 1024
Constant (const byte*) main::SCREEN = (byte*) 1024
Successful SSA optimization Pass2ConstantIdentification
Resolved ranged next value [9] main::i#1 ← ++ main::i#2 to ++
Resolved ranged comparison value [11] if(main::i#1!=rangelast(0,$64)) goto main::@1 to (number) $65
@ -124,7 +123,7 @@ main::@1: scope:[main] from main main::@1
[5] (byte) main::i#2 ← phi( main/(byte) 0 main::@1/(byte) main::i#1 )
[6] (dword) main::b#0 ← (const dword) main::a + (byte) main::i#2
[7] (byte) main::c#0 ← (byte)(dword) main::b#0
[8] *((const byte*) main::SCREEN#0 + (byte) main::i#2) ← (byte) main::c#0
[8] *((const byte*) main::SCREEN + (byte) main::i#2) ← (byte) main::c#0
[9] (byte) main::i#1 ← ++ (byte) main::i#2
[10] if((byte) main::i#1!=(byte) $65) goto main::@1
to:main::@return
@ -135,7 +134,6 @@ main::@return: scope:[main] from main::@1
VARIABLE REGISTER WEIGHTS
(void()) main()
(byte*) main::SCREEN
(dword) main::b
(dword) main::b#0 11.0
(byte) main::c
@ -216,7 +214,7 @@ main: {
// [7] (byte) main::c#0 ← (byte)(dword) main::b#0 -- vbuz1=_byte_vduz2
lda.z b
sta.z c
// [8] *((const byte*) main::SCREEN#0 + (byte) main::i#2) ← (byte) main::c#0 -- pbuc1_derefidx_vbuz1=vbuz2
// [8] *((const byte*) main::SCREEN + (byte) main::i#2) ← (byte) main::c#0 -- pbuc1_derefidx_vbuz1=vbuz2
lda.z c
ldy.z i
sta SCREEN,y
@ -307,7 +305,7 @@ main: {
sta.z b+3
// [7] (byte) main::c#0 ← (byte)(dword) main::b#0 -- vbuaa=_byte_vduz1
lda.z b
// [8] *((const byte*) main::SCREEN#0 + (byte) main::i#2) ← (byte) main::c#0 -- pbuc1_derefidx_vbuxx=vbuaa
// [8] *((const byte*) main::SCREEN + (byte) main::i#2) ← (byte) main::c#0 -- pbuc1_derefidx_vbuxx=vbuaa
sta SCREEN,x
// [9] (byte) main::i#1 ← ++ (byte) main::i#2 -- vbuxx=_inc_vbuxx
inx
@ -354,8 +352,7 @@ FINAL SYMBOL TABLE
(void()) main()
(label) main::@1
(label) main::@return
(byte*) main::SCREEN
(const byte*) main::SCREEN#0 SCREEN = (byte*) 1024
(const byte*) main::SCREEN SCREEN = (byte*) 1024
(const dword) main::a a = (dword) $ee6b2800
(dword) main::b
(dword) main::b#0 b zp ZP_DWORD:2 11.0
@ -417,7 +414,7 @@ main: {
// [7] (byte) main::c#0 ← (byte)(dword) main::b#0 -- vbuaa=_byte_vduz1
lda.z b
// SCREEN[i] = c
// [8] *((const byte*) main::SCREEN#0 + (byte) main::i#2) ← (byte) main::c#0 -- pbuc1_derefidx_vbuxx=vbuaa
// [8] *((const byte*) main::SCREEN + (byte) main::i#2) ← (byte) main::c#0 -- pbuc1_derefidx_vbuxx=vbuaa
sta SCREEN,x
// for( byte i: 0..100)
// [9] (byte) main::i#1 ← ++ (byte) main::i#2 -- vbuxx=_inc_vbuxx

3
src/test/ref/dword.sym
View File

@ -4,8 +4,7 @@
(void()) main()
(label) main::@1
(label) main::@return
(byte*) main::SCREEN
(const byte*) main::SCREEN#0 SCREEN = (byte*) 1024
(const byte*) main::SCREEN SCREEN = (byte*) 1024
(const dword) main::a a = (dword) $ee6b2800
(dword) main::b
(dword) main::b#0 b zp ZP_DWORD:2 11.0

4
src/test/ref/hex2dec.cfg
View File

@ -54,10 +54,10 @@ main::@9: scope:[main] from main::@8
to:main::@3
main::@3: scope:[main] from main::@4 main::@9
[31] (byte) main::i#2 ← phi( main::@9/(byte) 0 main::@4/(byte) main::i#1 )
[32] if(*((const byte[]) main::msg#0 + (byte) main::i#2)!=(byte) 0) goto main::@4
[32] if(*((const byte[]) main::msg + (byte) main::i#2)!=(byte) 0) goto main::@4
to:main::@1
main::@4: scope:[main] from main::@3
[33] *((byte*) 1024+(byte) $28+(byte) $28+(byte) $28+(byte) $28+(byte) $50+(byte) 3 + (byte) main::i#2) ← *((const byte[]) main::msg#0 + (byte) main::i#2)
[33] *((byte*) 1024+(byte) $28+(byte) $28+(byte) $28+(byte) $28+(byte) $50+(byte) 3 + (byte) main::i#2) ← *((const byte[]) main::msg + (byte) main::i#2)
[34] (byte) main::i#1 ← ++ (byte) main::i#2
to:main::@3

43
src/test/ref/hex2dec.log
View File

@ -108,13 +108,13 @@ main::@20: scope:[main] from main::@19
to:main::@21
main::@21: scope:[main] from main::@20
(byte*) main::screen#12 ← phi( main::@20/(byte*) main::screen#9 )
(byte[]) main::msg#0 ← (const string) main::$21
(byte[]) main::msg ← (const string) main::$21
(byte) main::i#0 ← (number) 0
to:main::@6
main::@6: scope:[main] from main::@21 main::@7
(byte*) main::screen#11 ← phi( main::@21/(byte*) main::screen#12 main::@7/(byte*) main::screen#10 )
(byte) main::i#2 ← phi( main::@21/(byte) main::i#0 main::@7/(byte) main::i#1 )
(bool~) main::$18 ← *((byte[]) main::msg#0 + (byte) main::i#2) != (number) 0
(bool~) main::$18 ← *((byte[]) main::msg + (byte) main::i#2) != (number) 0
if((bool~) main::$18) goto main::@7
to:main::@1
main::@7: scope:[main] from main::@6
@ -122,7 +122,7 @@ main::@7: scope:[main] from main::@6
(byte*) main::screen#10 ← phi( main::@6/(byte*) main::screen#11 )
(byte*~) main::$19 ← (byte*) main::screen#10 + (number) $50
(byte*~) main::$20 ← (byte*~) main::$19 + (number) 3
*((byte*~) main::$20 + (byte) main::i#3) ← *((byte[]) main::msg#0 + (byte) main::i#3)
*((byte*~) main::$20 + (byte) main::i#3) ← *((byte[]) main::msg + (byte) main::i#3)
(byte) main::i#1 ← ++ (byte) main::i#3
to:main::@6
main::@return: scope:[main] from main::@1
@ -404,7 +404,6 @@ SYMBOL TABLE SSA
(byte) main::i#2
(byte) main::i#3
(byte[]) main::msg
(byte[]) main::msg#0
(byte) main::rst
(byte) main::rst#0
(byte*) main::screen
@ -622,7 +621,7 @@ Adding number conversion cast (unumber) $e608 in (word) utoa16w::value#4 ← (nu
Adding number conversion cast (unumber) 0 in *((byte*) bordercol) ← (number) 0
Adding number conversion cast (unumber) $50 in (byte*~) main::$16 ← (byte*) main::screen#9 + (number) $50
Adding number conversion cast (unumber) 0 in (byte) main::i#0 ← (number) 0
Adding number conversion cast (unumber) 0 in (bool~) main::$18 ← *((byte[]) main::msg#0 + (byte) main::i#2) != (number) 0
Adding number conversion cast (unumber) 0 in (bool~) main::$18 ← *((byte[]) main::msg + (byte) main::i#2) != (number) 0
Adding number conversion cast (unumber) $50 in (byte*~) main::$19 ← (byte*) main::screen#10 + (number) $50
Adding number conversion cast (unumber) 3 in (byte*~) main::$20 ← (byte*~) main::$19 + (number) 3
Adding number conversion cast (unumber) $3e7 in (byte*~) cls::$0 ← (byte*) cls::screen + (number) $3e7
@ -844,7 +843,7 @@ Identical Phi Values (word) utoa10w::value#5 (word) utoa10w::value#0
Identical Phi Values (byte*) utoa10w::dst#10 (byte*) utoa10w::dst#0
Successful SSA optimization Pass2IdenticalPhiElimination
Simple Condition (bool~) main::$4 [11] if((byte) main::rst#0!=(byte) $30) goto main::@4
Simple Condition (bool~) main::$18 [57] if(*((byte[]) main::msg#0 + (byte) main::i#2)!=(byte) 0) goto main::@7
Simple Condition (bool~) main::$18 [57] if(*((byte[]) main::msg + (byte) main::i#2)!=(byte) 0) goto main::@7
Simple Condition (bool~) cls::$1 [71] if((byte*) cls::sc#1!=rangelast(cls::screen,cls::$0)) goto cls::@1
Simple Condition (bool~) utoa10w::$1 [83] if((word) utoa10w::value#10>=*((word[]) UTOA10_SUB + (byte~) utoa10w::$8)) goto utoa10w::@3
Simple Condition (bool~) utoa10w::$4 [93] if((byte~) utoa10w::$2==(byte) 0) goto utoa10w::@10
@ -870,7 +869,7 @@ Constant (const word) utoa16w::value#1 = $4d2
Constant (const word) utoa16w::value#2 = $162e
Constant (const word) utoa16w::value#3 = $270f
Constant (const word) utoa16w::value#4 = $e608
Constant (const byte[]) main::msg#0 = main::$21
Constant (const byte[]) main::msg = main::$21
Constant (const byte) main::i#0 = 0
Constant (const byte*) cls::screen = (byte*) 1024
Constant (const byte[]) DIGITS = $0
@ -994,7 +993,7 @@ Constant inlined utoa16n::dst#3 = &(byte*) utoa16w::dst#5
Constant inlined utoa16n::started#4 = (byte) 1
Constant inlined utoa16n::dst#2 = &(byte*) utoa16w::dst#5
Constant inlined main::$20 = (byte*) 1024+(byte) $28+(byte) $28+(byte) $28+(byte) $28+(byte) $50+(byte) 3
Constant inlined main::$21 = (const byte[]) main::msg#0
Constant inlined main::$21 = (const byte[]) main::msg
Constant inlined utoa16w::started#0 = (byte) 0
Constant inlined cls::$0 = (const byte*) cls::screen+(word) $3e7
Constant inlined utoa10w::i#0 = (byte) 0
@ -1155,10 +1154,10 @@ main::@9: scope:[main] from main::@8
to:main::@3
main::@3: scope:[main] from main::@4 main::@9
[31] (byte) main::i#2 ← phi( main::@9/(byte) 0 main::@4/(byte) main::i#1 )
[32] if(*((const byte[]) main::msg#0 + (byte) main::i#2)!=(byte) 0) goto main::@4
[32] if(*((const byte[]) main::msg + (byte) main::i#2)!=(byte) 0) goto main::@4
to:main::@1
main::@4: scope:[main] from main::@3
[33] *((byte*) 1024+(byte) $28+(byte) $28+(byte) $28+(byte) $28+(byte) $50+(byte) 3 + (byte) main::i#2) ← *((const byte[]) main::msg#0 + (byte) main::i#2)
[33] *((byte*) 1024+(byte) $28+(byte) $28+(byte) $28+(byte) $28+(byte) $50+(byte) 3 + (byte) main::i#2) ← *((const byte[]) main::msg + (byte) main::i#2)
[34] (byte) main::i#1 ← ++ (byte) main::i#2
to:main::@3
@ -1293,7 +1292,6 @@ VARIABLE REGISTER WEIGHTS
(byte) main::i
(byte) main::i#1 202.0
(byte) main::i#2 168.33333333333331
(byte[]) main::msg
(byte) main::rst
(byte) main::rst#0 202.0
(byte*) main::screen
@ -1649,7 +1647,7 @@ main: {
jmp b3
// main::@3
b3:
// [32] if(*((const byte[]) main::msg#0 + (byte) main::i#2)!=(byte) 0) goto main::@4 -- pbuc1_derefidx_vbuz1_neq_0_then_la1
// [32] if(*((const byte[]) main::msg + (byte) main::i#2)!=(byte) 0) goto main::@4 -- pbuc1_derefidx_vbuz1_neq_0_then_la1
ldy.z i
lda msg,y
cmp #0
@ -1657,7 +1655,7 @@ main: {
jmp b1
// main::@4
b4:
// [33] *((byte*) 1024+(byte) $28+(byte) $28+(byte) $28+(byte) $28+(byte) $50+(byte) 3 + (byte) main::i#2) ← *((const byte[]) main::msg#0 + (byte) main::i#2) -- pbuc1_derefidx_vbuz1=pbuc2_derefidx_vbuz1
// [33] *((byte*) 1024+(byte) $28+(byte) $28+(byte) $28+(byte) $28+(byte) $50+(byte) 3 + (byte) main::i#2) ← *((const byte[]) main::msg + (byte) main::i#2) -- pbuc1_derefidx_vbuz1=pbuc2_derefidx_vbuz1
ldy.z i
lda msg,y
sta $400+$28+$28+$28+$28+$50+3,y
@ -2079,9 +2077,9 @@ Statement [27] *((const byte*) bordercol) ← (byte) 0 [ main::time_start#0 main
Removing always clobbered register reg byte a as potential for zp ZP_BYTE:22 [ main::time_end#0 ]
Statement [28] (byte) main::time#0 ← (byte) main::time_end#0 - (byte) main::time_start#0 [ main::time#0 ] ( main:2 [ main::time#0 ] ) always clobbers reg byte a
Statement [29] (word) utoa10w::value#0 ← (word)(byte) main::time#0 [ utoa10w::value#0 ] ( main:2 [ utoa10w::value#0 ] ) always clobbers reg byte a
Statement [32] if(*((const byte[]) main::msg#0 + (byte) main::i#2)!=(byte) 0) goto main::@4 [ main::i#2 ] ( main:2 [ main::i#2 ] ) always clobbers reg byte a
Statement [32] if(*((const byte[]) main::msg + (byte) main::i#2)!=(byte) 0) goto main::@4 [ main::i#2 ] ( main:2 [ main::i#2 ] ) always clobbers reg byte a
Removing always clobbered register reg byte a as potential for zp ZP_BYTE:2 [ main::i#2 main::i#1 ]
Statement [33] *((byte*) 1024+(byte) $28+(byte) $28+(byte) $28+(byte) $28+(byte) $50+(byte) 3 + (byte) main::i#2) ← *((const byte[]) main::msg#0 + (byte) main::i#2) [ main::i#2 ] ( main:2 [ main::i#2 ] ) always clobbers reg byte a
Statement [33] *((byte*) 1024+(byte) $28+(byte) $28+(byte) $28+(byte) $28+(byte) $50+(byte) 3 + (byte) main::i#2) ← *((const byte[]) main::msg + (byte) main::i#2) [ main::i#2 ] ( main:2 [ main::i#2 ] ) always clobbers reg byte a
Statement [37] (byte~) utoa10w::$8 ← (byte) utoa10w::i#2 << (byte) 1 [ utoa10w::i#2 utoa10w::value#10 utoa10w::digit#3 utoa10w::bStarted#2 utoa10w::dst#11 utoa10w::$8 ] ( main:2::utoa10w:30 [ utoa10w::i#2 utoa10w::value#10 utoa10w::digit#3 utoa10w::bStarted#2 utoa10w::dst#11 utoa10w::$8 ] ) always clobbers reg byte a
Removing always clobbered register reg byte a as potential for zp ZP_BYTE:3 [ utoa10w::i#2 utoa10w::i#1 ]
Removing always clobbered register reg byte a as potential for zp ZP_BYTE:6 [ utoa10w::digit#3 utoa10w::digit#7 utoa10w::digit#1 ]
@ -2124,8 +2122,8 @@ Statement [24] (byte*) utoa16w::dst#4 ← (byte*) 1024+(byte) $28+(byte) $28+(by
Statement [27] *((const byte*) bordercol) ← (byte) 0 [ main::time_start#0 main::time_end#0 ] ( main:2 [ main::time_start#0 main::time_end#0 ] ) always clobbers reg byte a
Statement [28] (byte) main::time#0 ← (byte) main::time_end#0 - (byte) main::time_start#0 [ main::time#0 ] ( main:2 [ main::time#0 ] ) always clobbers reg byte a
Statement [29] (word) utoa10w::value#0 ← (word)(byte) main::time#0 [ utoa10w::value#0 ] ( main:2 [ utoa10w::value#0 ] ) always clobbers reg byte a
Statement [32] if(*((const byte[]) main::msg#0 + (byte) main::i#2)!=(byte) 0) goto main::@4 [ main::i#2 ] ( main:2 [ main::i#2 ] ) always clobbers reg byte a
Statement [33] *((byte*) 1024+(byte) $28+(byte) $28+(byte) $28+(byte) $28+(byte) $50+(byte) 3 + (byte) main::i#2) ← *((const byte[]) main::msg#0 + (byte) main::i#2) [ main::i#2 ] ( main:2 [ main::i#2 ] ) always clobbers reg byte a
Statement [32] if(*((const byte[]) main::msg + (byte) main::i#2)!=(byte) 0) goto main::@4 [ main::i#2 ] ( main:2 [ main::i#2 ] ) always clobbers reg byte a
Statement [33] *((byte*) 1024+(byte) $28+(byte) $28+(byte) $28+(byte) $28+(byte) $50+(byte) 3 + (byte) main::i#2) ← *((const byte[]) main::msg + (byte) main::i#2) [ main::i#2 ] ( main:2 [ main::i#2 ] ) always clobbers reg byte a
Statement [37] (byte~) utoa10w::$8 ← (byte) utoa10w::i#2 << (byte) 1 [ utoa10w::i#2 utoa10w::value#10 utoa10w::digit#3 utoa10w::bStarted#2 utoa10w::dst#11 utoa10w::$8 ] ( main:2::utoa10w:30 [ utoa10w::i#2 utoa10w::value#10 utoa10w::digit#3 utoa10w::bStarted#2 utoa10w::dst#11 utoa10w::$8 ] ) always clobbers reg byte a
Statement [38] if((word) utoa10w::value#10>=*((const word[]) UTOA10_SUB + (byte~) utoa10w::$8)) goto utoa10w::@2 [ utoa10w::i#2 utoa10w::value#10 utoa10w::digit#3 utoa10w::bStarted#2 utoa10w::dst#11 ] ( main:2::utoa10w:30 [ utoa10w::i#2 utoa10w::value#10 utoa10w::digit#3 utoa10w::bStarted#2 utoa10w::dst#11 ] ) always clobbers reg byte a
Statement [39] (byte~) utoa10w::$2 ← (byte) utoa10w::i#2 & (byte) 1 [ utoa10w::i#2 utoa10w::value#10 utoa10w::digit#3 utoa10w::bStarted#2 utoa10w::dst#11 utoa10w::$2 ] ( main:2::utoa10w:30 [ utoa10w::i#2 utoa10w::value#10 utoa10w::digit#3 utoa10w::bStarted#2 utoa10w::dst#11 utoa10w::$2 ] ) always clobbers reg byte a
@ -2408,14 +2406,14 @@ main: {
jmp b3
// main::@3
b3:
// [32] if(*((const byte[]) main::msg#0 + (byte) main::i#2)!=(byte) 0) goto main::@4 -- pbuc1_derefidx_vbuxx_neq_0_then_la1
// [32] if(*((const byte[]) main::msg + (byte) main::i#2)!=(byte) 0) goto main::@4 -- pbuc1_derefidx_vbuxx_neq_0_then_la1
lda msg,x
cmp #0
bne b4
jmp b1
// main::@4
b4:
// [33] *((byte*) 1024+(byte) $28+(byte) $28+(byte) $28+(byte) $28+(byte) $50+(byte) 3 + (byte) main::i#2) ← *((const byte[]) main::msg#0 + (byte) main::i#2) -- pbuc1_derefidx_vbuxx=pbuc2_derefidx_vbuxx
// [33] *((byte*) 1024+(byte) $28+(byte) $28+(byte) $28+(byte) $28+(byte) $50+(byte) 3 + (byte) main::i#2) ← *((const byte[]) main::msg + (byte) main::i#2) -- pbuc1_derefidx_vbuxx=pbuc2_derefidx_vbuxx
lda msg,x
sta $400+$28+$28+$28+$28+$50+3,x
// [34] (byte) main::i#1 ← ++ (byte) main::i#2 -- vbuxx=_inc_vbuxx
@ -2899,8 +2897,7 @@ FINAL SYMBOL TABLE
(byte) main::i
(byte) main::i#1 reg byte x 202.0
(byte) main::i#2 reg byte x 168.33333333333331
(byte[]) main::msg
(const byte[]) main::msg#0 msg = (string) "raster lines"
(const byte[]) main::msg msg = (string) "raster lines"
(byte) main::rst
(byte) main::rst#0 reg byte a 202.0
(byte*) main::screen
@ -3188,7 +3185,7 @@ main: {
// main::@3
b3:
// for( byte i=0; msg[i]!=0; i++ )
// [32] if(*((const byte[]) main::msg#0 + (byte) main::i#2)!=(byte) 0) goto main::@4 -- pbuc1_derefidx_vbuxx_neq_0_then_la1
// [32] if(*((const byte[]) main::msg + (byte) main::i#2)!=(byte) 0) goto main::@4 -- pbuc1_derefidx_vbuxx_neq_0_then_la1
lda msg,x
cmp #0
bne b4
@ -3196,7 +3193,7 @@ main: {
// main::@4
b4:
// (screen+80+3)[i] = msg[i]
// [33] *((byte*) 1024+(byte) $28+(byte) $28+(byte) $28+(byte) $28+(byte) $50+(byte) 3 + (byte) main::i#2) ← *((const byte[]) main::msg#0 + (byte) main::i#2) -- pbuc1_derefidx_vbuxx=pbuc2_derefidx_vbuxx
// [33] *((byte*) 1024+(byte) $28+(byte) $28+(byte) $28+(byte) $28+(byte) $50+(byte) 3 + (byte) main::i#2) ← *((const byte[]) main::msg + (byte) main::i#2) -- pbuc1_derefidx_vbuxx=pbuc2_derefidx_vbuxx
lda msg,x
sta $400+$28+$28+$28+$28+$50+3,x
// for( byte i=0; msg[i]!=0; i++ )

3
src/test/ref/hex2dec.sym
View File

@ -28,8 +28,7 @@
(byte) main::i
(byte) main::i#1 reg byte x 202.0
(byte) main::i#2 reg byte x 168.33333333333331
(byte[]) main::msg
(const byte[]) main::msg#0 msg = (string) "raster lines"
(const byte[]) main::msg msg = (string) "raster lines"
(byte) main::rst
(byte) main::rst#0 reg byte a 202.0
(byte*) main::screen

4
src/test/ref/pointer-cast-2.cfg
View File

@ -12,10 +12,10 @@
main: scope:[main] from @1
[4] (byte) main::ub#0 ← (byte) $ff
[5] *((const signed byte*) main::sb_ptr#0) ← (signed byte) 1
[6] *((const byte*) main::ub_screen#0) ← (byte) main::ub#0
[6] *((const byte*) main::ub_screen) ← (byte) main::ub#0
[7] (signed byte) main::sb#0 ← (signed byte) $7f
[8] *((const byte*) main::ub_ptr#0) ← (byte) 1
[9] *((const signed byte*) main::sb_screen#0) ← (signed byte) main::sb#0
[9] *((const signed byte*) main::sb_screen) ← (signed byte) main::sb#0
to:main::@return
main::@return: scope:[main] from main
[10] return

46
src/test/ref/pointer-cast-2.log
View File

@ -7,21 +7,21 @@ CONTROL FLOW GRAPH SSA
(void()) main()
main: scope:[main] from @1
(byte*) main::ub_screen#0 ← ((byte*)) (number) $400
(byte*) main::ub_screen ← ((byte*)) (number) $400
(byte) main::ub#0 ← (number) $ff
(byte*~) main::$0 ← & (byte) main::ub#0
(signed byte*~) main::$1 ← ((signed byte*)) (byte*~) main::$0
(signed byte*) main::sb_ptr#0 ← (signed byte*~) main::$1
*((signed byte*) main::sb_ptr#0) ← (number) 1
*((byte*) main::ub_screen#0) ← (byte) main::ub#0
(signed byte*) main::sb_screen#0 ← ((signed byte*)) (number) $428
*((byte*) main::ub_screen) ← (byte) main::ub#0
(signed byte*) main::sb_screen ← ((signed byte*)) (number) $428
(signed byte~) main::$2 ← ((signed byte)) (number) $7f
(signed byte) main::sb#0 ← (signed byte~) main::$2
(signed byte*~) main::$3 ← & (signed byte) main::sb#0
(byte*~) main::$4 ← ((byte*)) (signed byte*~) main::$3
(byte*) main::ub_ptr#0 ← (byte*~) main::$4
*((byte*) main::ub_ptr#0) ← (number) 1
*((signed byte*) main::sb_screen#0) ← (signed byte) main::sb#0
*((signed byte*) main::sb_screen) ← (signed byte) main::sb#0
to:main::@return
main::@return: scope:[main] from main
return
@ -50,23 +50,21 @@ SYMBOL TABLE SSA
(signed byte*) main::sb_ptr
(signed byte*) main::sb_ptr#0
(signed byte*) main::sb_screen
(signed byte*) main::sb_screen#0
(byte) main::ub
(byte) main::ub#0
(byte*) main::ub_ptr
(byte*) main::ub_ptr#0
(byte*) main::ub_screen
(byte*) main::ub_screen#0
Adding number conversion cast (unumber) $ff in (byte) main::ub#0 ← (number) $ff
Adding number conversion cast (snumber) 1 in *((signed byte*) main::sb_ptr#0) ← (number) 1
Adding number conversion cast (unumber) 1 in *((byte*) main::ub_ptr#0) ← (number) 1
Successful SSA optimization PassNAddNumberTypeConversions
Inlining cast (byte*) main::ub_screen#0 ← (byte*)(number) $400
Inlining cast (byte*) main::ub_screen ← (byte*)(number) $400
Inlining cast (byte) main::ub#0 ← (unumber)(number) $ff
Inlining cast (signed byte*~) main::$1 ← (signed byte*)(byte*~) main::$0
Inlining cast *((signed byte*) main::sb_ptr#0) ← (snumber)(number) 1
Inlining cast (signed byte*) main::sb_screen#0 ← (signed byte*)(number) $428
Inlining cast (signed byte*) main::sb_screen ← (signed byte*)(number) $428
Inlining cast (signed byte~) main::$2 ← (signed byte)(number) $7f
Inlining cast (byte*~) main::$4 ← (byte*)(signed byte*~) main::$3
Inlining cast *((byte*) main::ub_ptr#0) ← (unumber)(number) 1
@ -90,9 +88,9 @@ Alias candidate removed (volatile)(signed byte) main::sb#0 = (signed byte~) main
Constant right-side identified [2] (byte*~) main::$0 ← & (byte) main::ub#0
Constant right-side identified [10] (signed byte*~) main::$3 ← & (signed byte) main::sb#0
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) main::ub_screen#0 = (byte*) 1024
Constant (const byte*) main::ub_screen = (byte*) 1024
Constant (const byte*) main::$0 = &main::ub#0
Constant (const signed byte*) main::sb_screen#0 = (signed byte*) 1064
Constant (const signed byte*) main::sb_screen = (signed byte*) 1064
Constant (const signed byte) main::$2 = $7f
Constant (const signed byte*) main::$3 = &main::sb#0
Successful SSA optimization Pass2ConstantIdentification
@ -135,10 +133,10 @@ FINAL CONTROL FLOW GRAPH
main: scope:[main] from @1
[4] (byte) main::ub#0 ← (byte) $ff
[5] *((const signed byte*) main::sb_ptr#0) ← (signed byte) 1
[6] *((const byte*) main::ub_screen#0) ← (byte) main::ub#0
[6] *((const byte*) main::ub_screen) ← (byte) main::ub#0
[7] (signed byte) main::sb#0 ← (signed byte) $7f
[8] *((const byte*) main::ub_ptr#0) ← (byte) 1
[9] *((const signed byte*) main::sb_screen#0) ← (signed byte) main::sb#0
[9] *((const signed byte*) main::sb_screen) ← (signed byte) main::sb#0
to:main::@return
main::@return: scope:[main] from main
[10] return
@ -150,11 +148,9 @@ VARIABLE REGISTER WEIGHTS
(signed byte) main::sb
(signed byte) main::sb#0 2.0
(signed byte*) main::sb_ptr
(signed byte*) main::sb_screen
(byte) main::ub
(byte) main::ub#0 2.0
(byte*) main::ub_ptr
(byte*) main::ub_screen
Initial phi equivalence classes
Complete equivalence classes
@ -200,7 +196,7 @@ main: {
// [5] *((const signed byte*) main::sb_ptr#0) ← (signed byte) 1 -- _deref_pbsc1=vbsc2
lda #1
sta.z sb_ptr
// [6] *((const byte*) main::ub_screen#0) ← (byte) main::ub#0 -- _deref_pbuc1=vbuz1
// [6] *((const byte*) main::ub_screen) ← (byte) main::ub#0 -- _deref_pbuc1=vbuz1
lda.z ub
sta ub_screen
// [7] (signed byte) main::sb#0 ← (signed byte) $7f -- vbsz1=vbsc1
@ -209,7 +205,7 @@ main: {
// [8] *((const byte*) main::ub_ptr#0) ← (byte) 1 -- _deref_pbuc1=vbuc2
lda #1
sta.z ub_ptr
// [9] *((const signed byte*) main::sb_screen#0) ← (signed byte) main::sb#0 -- _deref_pbsc1=vbsz1
// [9] *((const signed byte*) main::sb_screen) ← (signed byte) main::sb#0 -- _deref_pbsc1=vbsz1
lda.z sb
sta sb_screen
jmp breturn
@ -223,10 +219,10 @@ main: {
REGISTER UPLIFT POTENTIAL REGISTERS
Statement [4] (byte) main::ub#0 ← (byte) $ff [ main::ub#0 ] ( main:2 [ main::ub#0 ] ) always clobbers reg byte a
Statement [5] *((const signed byte*) main::sb_ptr#0) ← (signed byte) 1 [ main::ub#0 ] ( main:2 [ main::ub#0 ] ) always clobbers reg byte a
Statement [6] *((const byte*) main::ub_screen#0) ← (byte) main::ub#0 [ ] ( main:2 [ ] ) always clobbers reg byte a
Statement [6] *((const byte*) main::ub_screen) ← (byte) main::ub#0 [ ] ( main:2 [ ] ) always clobbers reg byte a
Statement [7] (signed byte) main::sb#0 ← (signed byte) $7f [ main::sb#0 ] ( main:2 [ main::sb#0 ] ) always clobbers reg byte a
Statement [8] *((const byte*) main::ub_ptr#0) ← (byte) 1 [ main::sb#0 ] ( main:2 [ main::sb#0 ] ) always clobbers reg byte a
Statement [9] *((const signed byte*) main::sb_screen#0) ← (signed byte) main::sb#0 [ ] ( main:2 [ ] ) always clobbers reg byte a
Statement [9] *((const signed byte*) main::sb_screen) ← (signed byte) main::sb#0 [ ] ( main:2 [ ] ) always clobbers reg byte a
Potential registers zp ZP_BYTE:2 [ main::ub#0 ] : zp ZP_BYTE:2 ,
Potential registers zp ZP_BYTE:3 [ main::sb#0 ] : zp ZP_BYTE:3 ,
@ -277,7 +273,7 @@ main: {
// [5] *((const signed byte*) main::sb_ptr#0) ← (signed byte) 1 -- _deref_pbsc1=vbsc2
lda #1
sta.z sb_ptr
// [6] *((const byte*) main::ub_screen#0) ← (byte) main::ub#0 -- _deref_pbuc1=vbuz1
// [6] *((const byte*) main::ub_screen) ← (byte) main::ub#0 -- _deref_pbuc1=vbuz1
lda.z ub
sta ub_screen
// [7] (signed byte) main::sb#0 ← (signed byte) $7f -- vbsz1=vbsc1
@ -286,7 +282,7 @@ main: {
// [8] *((const byte*) main::ub_ptr#0) ← (byte) 1 -- _deref_pbuc1=vbuc2
lda #1
sta.z ub_ptr
// [9] *((const signed byte*) main::sb_screen#0) ← (signed byte) main::sb#0 -- _deref_pbsc1=vbsz1
// [9] *((const signed byte*) main::sb_screen) ← (signed byte) main::sb#0 -- _deref_pbsc1=vbsz1
lda.z sb
sta sb_screen
jmp breturn
@ -325,14 +321,12 @@ FINAL SYMBOL TABLE
(signed byte) main::sb#0 sb zp ZP_BYTE:3 2.0
(signed byte*) main::sb_ptr
(const signed byte*) main::sb_ptr#0 sb_ptr = (signed byte*)&(byte) main::ub#0
(signed byte*) main::sb_screen
(const signed byte*) main::sb_screen#0 sb_screen = (signed byte*) 1064
(const signed byte*) main::sb_screen sb_screen = (signed byte*) 1064
(byte) main::ub
(byte) main::ub#0 ub zp ZP_BYTE:2 2.0
(byte*) main::ub_ptr
(const byte*) main::ub_ptr#0 ub_ptr = (byte*)&(signed byte) main::sb#0
(byte*) main::ub_screen
(const byte*) main::ub_screen#0 ub_screen = (byte*) 1024
(const byte*) main::ub_screen ub_screen = (byte*) 1024
zp ZP_BYTE:2 [ main::ub#0 ]
zp ZP_BYTE:3 [ main::sb#0 ]
@ -371,7 +365,7 @@ main: {
lda #1
sta.z sb_ptr
// *ub_screen = ub
// [6] *((const byte*) main::ub_screen#0) ← (byte) main::ub#0 -- _deref_pbuc1=vbuz1
// [6] *((const byte*) main::ub_screen) ← (byte) main::ub#0 -- _deref_pbuc1=vbuz1
lda.z ub
sta ub_screen
// sb = (signed byte)0x7f
@ -383,7 +377,7 @@ main: {
lda #1
sta.z ub_ptr
// *sb_screen = sb
// [9] *((const signed byte*) main::sb_screen#0) ← (signed byte) main::sb#0 -- _deref_pbsc1=vbsz1
// [9] *((const signed byte*) main::sb_screen) ← (signed byte) main::sb#0 -- _deref_pbsc1=vbsz1
lda.z sb
sta sb_screen
// main::@return

6
src/test/ref/pointer-cast-2.sym
View File

@ -7,14 +7,12 @@
(signed byte) main::sb#0 sb zp ZP_BYTE:3 2.0
(signed byte*) main::sb_ptr
(const signed byte*) main::sb_ptr#0 sb_ptr = (signed byte*)&(byte) main::ub#0
(signed byte*) main::sb_screen
(const signed byte*) main::sb_screen#0 sb_screen = (signed byte*) 1064
(const signed byte*) main::sb_screen sb_screen = (signed byte*) 1064
(byte) main::ub
(byte) main::ub#0 ub zp ZP_BYTE:2 2.0
(byte*) main::ub_ptr
(const byte*) main::ub_ptr#0 ub_ptr = (byte*)&(signed byte) main::sb#0
(byte*) main::ub_screen
(const byte*) main::ub_screen#0 ub_screen = (byte*) 1024
(const byte*) main::ub_screen ub_screen = (byte*) 1024
zp ZP_BYTE:2 [ main::ub#0 ]
zp ZP_BYTE:3 [ main::sb#0 ]

4
src/test/ref/screen-show-spiral-buckets.cfg
View File

@ -57,7 +57,7 @@ main::@2: scope:[main] from main::@1 main::@2
main::@3: scope:[main] from main::@2
[25] *((const byte*) BORDERCOL) ← ++ *((const byte*) BORDERCOL)
[26] (byte~) main::$26 ← (byte) main::bucket_idx#6 << (byte) 1
[27] (word[]) main::bucket#0 ← *((word*[])(void*) BUCKETS + (byte~) main::$26)
[27] (word[]) main::bucket ← *((word*[])(void*) BUCKETS + (byte~) main::$26)
[28] (byte) main::bucket_size#0 ← *((byte[])(void*) BUCKET_SIZES + (byte) main::bucket_idx#6)
[29] if((byte) main::bucket_size#0<=(byte) 0) goto main::@4
to:main::@5
@ -90,7 +90,7 @@ main::@12: scope:[main] from main::@4
to:main::@1
main::@6: scope:[main] from main::@5
[41] (byte~) main::$27 ← (byte) main::i#2 << (byte) 1
[42] (word) main::offset#0 ← *((word[]) main::bucket#0 + (byte~) main::$27)
[42] (word) main::offset#0 ← *((word[]) main::bucket + (byte~) main::$27)
[43] (byte*) main::fill#0 ← (const byte*) SCREEN_FILL + (word) main::offset#0
[44] if(*((byte*) main::fill#0)==(const byte) FILL_CHAR) goto main::@18
to:main::@9

121
src/test/ref/screen-show-spiral-buckets.log
View File

@ -602,7 +602,7 @@ main::@5: scope:[main] from main::@4
(byte) main::bucket_idx#2 ← phi( main::@4/(byte) main::bucket_idx#4 )
*((byte*) BORDERCOL) ← ++ *((byte*) BORDERCOL)
(byte~) main::$26 ← (byte) main::bucket_idx#2 * (const byte) SIZEOF_POINTER
(word[]) main::bucket#0 ← *((word*[]) BUCKETS + (byte~) main::$26)
(word[]) main::bucket ← *((word*[]) BUCKETS + (byte~) main::$26)
(byte) main::bucket_size#0 ← *((byte[]) BUCKET_SIZES + (byte) main::bucket_idx#2)
(bool~) main::$5 ← (byte) main::bucket_size#0 > (number) 0
(bool~) main::$6 ← ! (bool~) main::$5
@ -650,7 +650,7 @@ main::@9: scope:[main] from main::@8
(byte) main::min_angle#3 ← phi( main::@8/(byte) main::min_angle#4 )
(byte) main::i#3 ← phi( main::@8/(byte) main::i#2 )
(byte~) main::$27 ← (byte) main::i#3 * (const byte) SIZEOF_WORD
(word) main::offset#0 ← *((word[]) main::bucket#0 + (byte~) main::$27)
(word) main::offset#0 ← *((word[]) main::bucket + (byte~) main::$27)
(byte*~) main::$8 ← (byte*) SCREEN_FILL + (word) main::offset#0
(byte*) main::fill#0 ← (byte*~) main::$8
(bool~) main::$9 ← *((byte*) main::fill#0) != (byte) FILL_CHAR
@ -2071,7 +2071,6 @@ SYMBOL TABLE SSA
(byte*) main::angle#0
(byte*) main::angle#1
(word[]) main::bucket
(word[]) main::bucket#0
(byte) main::bucket_idx
(byte) main::bucket_idx#0
(byte) main::bucket_idx#1
@ -3438,7 +3437,7 @@ main::@2: scope:[main] from main::@1 main::@2
main::@3: scope:[main] from main::@2
[25] *((const byte*) BORDERCOL) ← ++ *((const byte*) BORDERCOL)
[26] (byte~) main::$26 ← (byte) main::bucket_idx#6 << (byte) 1
[27] (word[]) main::bucket#0 ← *((word*[])(void*) BUCKETS + (byte~) main::$26)
[27] (word[]) main::bucket ← *((word*[])(void*) BUCKETS + (byte~) main::$26)
[28] (byte) main::bucket_size#0 ← *((byte[])(void*) BUCKET_SIZES + (byte) main::bucket_idx#6)
[29] if((byte) main::bucket_size#0<=(byte) 0) goto main::@4
to:main::@5
@ -3471,7 +3470,7 @@ main::@12: scope:[main] from main::@4
to:main::@1
main::@6: scope:[main] from main::@5
[41] (byte~) main::$27 ← (byte) main::i#2 << (byte) 1
[42] (word) main::offset#0 ← *((word[]) main::bucket#0 + (byte~) main::$27)
[42] (word) main::offset#0 ← *((word[]) main::bucket + (byte~) main::$27)
[43] (byte*) main::fill#0 ← (const byte*) SCREEN_FILL + (word) main::offset#0
[44] if(*((byte*) main::fill#0)==(const byte) FILL_CHAR) goto main::@18
to:main::@9
@ -4117,8 +4116,7 @@ VARIABLE REGISTER WEIGHTS
(byte~) main::$27 202.0
(byte*) main::angle
(byte*) main::angle#0 151.5
(word[]) main::bucket
(word[]) main::bucket#0 6.588235294117648
(word[]) main::bucket 6.588235294117648
(byte) main::bucket_idx
(byte) main::bucket_idx#1 11.0
(byte) main::bucket_idx#6 2.64
@ -4221,7 +4219,7 @@ Added variable BUCKET_IDX to zero page equivalence class [ BUCKET_IDX ]
Added variable init_angle_screen::screen#0 to zero page equivalence class [ init_angle_screen::screen#0 ]
Added variable init_buckets::screen#0 to zero page equivalence class [ init_buckets::screen#0 ]
Added variable main::$26 to zero page equivalence class [ main::$26 ]
Added variable main::bucket#0 to zero page equivalence class [ main::bucket#0 ]
Added variable main::bucket to zero page equivalence class [ main::bucket ]
Added variable main::bucket_size#0 to zero page equivalence class [ main::bucket_size#0 ]
Added variable main::fill1#0 to zero page equivalence class [ main::fill1#0 ]
Added variable main::$27 to zero page equivalence class [ main::$27 ]
@ -4329,7 +4327,7 @@ Complete equivalence classes
[ init_angle_screen::screen#0 ]
[ init_buckets::screen#0 ]
[ main::$26 ]
[ main::bucket#0 ]
[ main::bucket ]
[ main::bucket_size#0 ]
[ main::fill1#0 ]
[ main::$27 ]
@ -4436,7 +4434,7 @@ Allocated zp ZP_WORD:72 [ BUCKET_IDX ]
Allocated zp ZP_WORD:74 [ init_angle_screen::screen#0 ]
Allocated zp ZP_WORD:76 [ init_buckets::screen#0 ]
Allocated zp ZP_BYTE:78 [ main::$26 ]
Allocated zp ZP_WORD:79 [ main::bucket#0 ]
Allocated zp ZP_WORD:79 [ main::bucket ]
Allocated zp ZP_BYTE:81 [ main::bucket_size#0 ]
Allocated zp ZP_WORD:82 [ main::fill1#0 ]
Allocated zp ZP_BYTE:84 [ main::$27 ]
@ -4658,9 +4656,9 @@ bend_from_b3:
bend:
// main
main: {
.label bucket = $4f
.label _26 = $4e
.label _27 = $54
.label bucket = $4f
.label bucket_size = $51
.label bucket_idx = 2
.label offset = 7
@ -4730,7 +4728,7 @@ main: {
lda.z bucket_idx
asl
sta.z _26
// [27] (word[]) main::bucket#0 ← *((word*[])(void*) BUCKETS + (byte~) main::$26) -- pwuz1=pptz2_derefidx_vbuz3
// [27] (word[]) main::bucket ← *((word*[])(void*) BUCKETS + (byte~) main::$26) -- pwuz1=pptz2_derefidx_vbuz3
ldy.z _26
lda (BUCKETS),y
sta.z bucket
@ -4828,7 +4826,7 @@ main: {
lda.z i
asl
sta.z _27
// [42] (word) main::offset#0 ← *((word[]) main::bucket#0 + (byte~) main::$27) -- vwuz1=pwuz2_derefidx_vbuz3
// [42] (word) main::offset#0 ← *((word[]) main::bucket + (byte~) main::$27) -- vwuz1=pwuz2_derefidx_vbuz3
ldy.z _27
lda (bucket),y
sta.z offset
@ -6386,28 +6384,28 @@ Statement [21] (byte*) init_buckets::screen#0 ← (byte[])(void*) SCREEN_DIST [
Statement [24] if(*((const byte*) RASTER)!=(byte) $ff) goto main::@2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 ] ) always clobbers reg byte a
Removing always clobbered register reg byte a as potential for zp ZP_BYTE:2 [ main::bucket_idx#6 main::bucket_idx#1 ]
Statement [26] (byte~) main::$26 ← (byte) main::bucket_idx#6 << (byte) 1 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::$26 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::$26 ] ) always clobbers reg byte a
Statement [27] (word[]) main::bucket#0 ← *((word*[])(void*) BUCKETS + (byte~) main::$26) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 ] ) always clobbers reg byte a reg byte y
Statement [27] (word[]) main::bucket ← *((word*[])(void*) BUCKETS + (byte~) main::$26) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket ] ) always clobbers reg byte a reg byte y
Removing always clobbered register reg byte y as potential for zp ZP_BYTE:2 [ main::bucket_idx#6 main::bucket_idx#1 ]
Statement [28] (byte) main::bucket_size#0 ← *((byte[])(void*) BUCKET_SIZES + (byte) main::bucket_idx#6) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 ] ) always clobbers reg byte a reg byte y
Statement [28] (byte) main::bucket_size#0 ← *((byte[])(void*) BUCKET_SIZES + (byte) main::bucket_idx#6) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 ] ) always clobbers reg byte a reg byte y
Statement [32] if((word) main::min_offset#2==(word) $ffff) goto main::@4 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::min_offset#2 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::min_offset#2 ] ) always clobbers reg byte a
Statement [33] (byte*) main::fill1#0 ← (const byte*) SCREEN_FILL + (word) main::min_offset#2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::fill1#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::fill1#0 ] ) always clobbers reg byte a
Statement [34] *((byte*) main::fill1#0) ← (const byte) FILL_CHAR [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 ] ) always clobbers reg byte a reg byte y
Statement [41] (byte~) main::$27 ← (byte) main::i#2 << (byte) 1 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::$27 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::$27 ] ) always clobbers reg byte a
Statement [41] (byte~) main::$27 ← (byte) main::i#2 << (byte) 1 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::$27 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::$27 ] ) always clobbers reg byte a
Removing always clobbered register reg byte a as potential for zp ZP_BYTE:81 [ main::bucket_size#0 ]
Removing always clobbered register reg byte a as potential for zp ZP_BYTE:3 [ main::i#2 main::i#1 ]
Removing always clobbered register reg byte a as potential for zp ZP_BYTE:6 [ main::min_angle#2 main::min_angle#5 main::min_angle#1 ]
Statement [42] (word) main::offset#0 ← *((word[]) main::bucket#0 + (byte~) main::$27) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ) always clobbers reg byte a reg byte y
Statement [42] (word) main::offset#0 ← *((word[]) main::bucket + (byte~) main::$27) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ) always clobbers reg byte a reg byte y
Removing always clobbered register reg byte y as potential for zp ZP_BYTE:81 [ main::bucket_size#0 ]
Removing always clobbered register reg byte y as potential for zp ZP_BYTE:3 [ main::i#2 main::i#1 ]
Removing always clobbered register reg byte y as potential for zp ZP_BYTE:6 [ main::min_angle#2 main::min_angle#5 main::min_angle#1 ]
Statement [43] (byte*) main::fill#0 ← (const byte*) SCREEN_FILL + (word) main::offset#0 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::fill#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::fill#0 ] ) always clobbers reg byte a
Statement [44] if(*((byte*) main::fill#0)==(const byte) FILL_CHAR) goto main::@18 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ) always clobbers reg byte a reg byte y
Statement [45] (byte*) main::angle#0 ← (byte[])(void*) SCREEN_ANGLE + (word) main::offset#0 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ) always clobbers reg byte a
Statement [46] if(*((byte*) main::angle#0)>(byte) main::min_angle#2) goto main::@17 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ) always clobbers reg byte a reg byte y
Statement [47] (byte) main::min_angle#1 ← *((byte*) main::angle#0) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::offset#0 main::min_angle#1 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::offset#0 main::min_angle#1 ] ) always clobbers reg byte a reg byte y
Statement [50] (word~) main::min_offset#8 ← (word) main::min_offset#5 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#1 main::min_offset#8 main::min_angle#5 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#1 main::min_offset#8 main::min_angle#5 ] ) always clobbers reg byte a
Statement [51] (word~) main::min_offset#9 ← (word) main::min_offset#2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#9 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#9 ] ) always clobbers reg byte a
Statement [52] (word~) main::min_offset#11 ← (word) main::min_offset#2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#11 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#11 ] ) always clobbers reg byte a
Statement [43] (byte*) main::fill#0 ← (const byte*) SCREEN_FILL + (word) main::offset#0 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::fill#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::fill#0 ] ) always clobbers reg byte a
Statement [44] if(*((byte*) main::fill#0)==(const byte) FILL_CHAR) goto main::@18 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ) always clobbers reg byte a reg byte y
Statement [45] (byte*) main::angle#0 ← (byte[])(void*) SCREEN_ANGLE + (word) main::offset#0 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ) always clobbers reg byte a
Statement [46] if(*((byte*) main::angle#0)>(byte) main::min_angle#2) goto main::@17 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ) always clobbers reg byte a reg byte y
Statement [47] (byte) main::min_angle#1 ← *((byte*) main::angle#0) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::offset#0 main::min_angle#1 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::offset#0 main::min_angle#1 ] ) always clobbers reg byte a reg byte y
Statement [50] (word~) main::min_offset#8 ← (word) main::min_offset#5 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#1 main::min_offset#8 main::min_angle#5 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#1 main::min_offset#8 main::min_angle#5 ] ) always clobbers reg byte a
Statement [51] (word~) main::min_offset#9 ← (word) main::min_offset#2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#9 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#9 ] ) always clobbers reg byte a
Statement [52] (word~) main::min_offset#11 ← (word) main::min_offset#2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#11 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#11 ] ) always clobbers reg byte a
Statement [55] *((byte[])(void*) BUCKET_SIZES + (byte) init_buckets::i#2) ← (byte) 0 [ BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 init_buckets::i#2 heap_head#1 ] ( main:14::init_buckets:22 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 init_buckets::i#2 heap_head#1 ] ) always clobbers reg byte a
Removing always clobbered register reg byte a as potential for zp ZP_BYTE:9 [ init_buckets::i#2 init_buckets::i#1 ]
Statement [58] (byte*~) init_buckets::dist#6 ← (byte*) init_buckets::screen#0 [ BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 init_buckets::dist#6 heap_head#1 ] ( main:14::init_buckets:22 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 init_buckets::dist#6 heap_head#1 ] ) always clobbers reg byte a
@ -6554,21 +6552,21 @@ Statement [19] (byte*) init_angle_screen::screen#0 ← (byte[])(void*) SCREEN_AN
Statement [21] (byte*) init_buckets::screen#0 ← (byte[])(void*) SCREEN_DIST [ SCREEN_ANGLE BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 heap_head#1 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 heap_head#1 ] ) always clobbers reg byte a
Statement [24] if(*((const byte*) RASTER)!=(byte) $ff) goto main::@2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 ] ) always clobbers reg byte a
Statement [26] (byte~) main::$26 ← (byte) main::bucket_idx#6 << (byte) 1 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::$26 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::$26 ] ) always clobbers reg byte a
Statement [27] (word[]) main::bucket#0 ← *((word*[])(void*) BUCKETS + (byte~) main::$26) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 ] ) always clobbers reg byte a reg byte y
Statement [28] (byte) main::bucket_size#0 ← *((byte[])(void*) BUCKET_SIZES + (byte) main::bucket_idx#6) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 ] ) always clobbers reg byte a reg byte y
Statement [27] (word[]) main::bucket ← *((word*[])(void*) BUCKETS + (byte~) main::$26) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket ] ) always clobbers reg byte a reg byte y
Statement [28] (byte) main::bucket_size#0 ← *((byte[])(void*) BUCKET_SIZES + (byte) main::bucket_idx#6) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 ] ) always clobbers reg byte a reg byte y
Statement [32] if((word) main::min_offset#2==(word) $ffff) goto main::@4 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::min_offset#2 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::min_offset#2 ] ) always clobbers reg byte a
Statement [33] (byte*) main::fill1#0 ← (const byte*) SCREEN_FILL + (word) main::min_offset#2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::fill1#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::fill1#0 ] ) always clobbers reg byte a
Statement [34] *((byte*) main::fill1#0) ← (const byte) FILL_CHAR [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 ] ) always clobbers reg byte a reg byte y
Statement [41] (byte~) main::$27 ← (byte) main::i#2 << (byte) 1 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::$27 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::$27 ] ) always clobbers reg byte a
Statement [42] (word) main::offset#0 ← *((word[]) main::bucket#0 + (byte~) main::$27) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ) always clobbers reg byte a reg byte y
Statement [43] (byte*) main::fill#0 ← (const byte*) SCREEN_FILL + (word) main::offset#0 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::fill#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::fill#0 ] ) always clobbers reg byte a
Statement [44] if(*((byte*) main::fill#0)==(const byte) FILL_CHAR) goto main::@18 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ) always clobbers reg byte a reg byte y
Statement [45] (byte*) main::angle#0 ← (byte[])(void*) SCREEN_ANGLE + (word) main::offset#0 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ) always clobbers reg byte a
Statement [46] if(*((byte*) main::angle#0)>(byte) main::min_angle#2) goto main::@17 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ) always clobbers reg byte a reg byte y
Statement [47] (byte) main::min_angle#1 ← *((byte*) main::angle#0) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::offset#0 main::min_angle#1 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::offset#0 main::min_angle#1 ] ) always clobbers reg byte a reg byte y
Statement [50] (word~) main::min_offset#8 ← (word) main::min_offset#5 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#1 main::min_offset#8 main::min_angle#5 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#1 main::min_offset#8 main::min_angle#5 ] ) always clobbers reg byte a
Statement [51] (word~) main::min_offset#9 ← (word) main::min_offset#2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#9 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#9 ] ) always clobbers reg byte a
Statement [52] (word~) main::min_offset#11 ← (word) main::min_offset#2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#11 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#11 ] ) always clobbers reg byte a
Statement [41] (byte~) main::$27 ← (byte) main::i#2 << (byte) 1 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::$27 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::$27 ] ) always clobbers reg byte a
Statement [42] (word) main::offset#0 ← *((word[]) main::bucket + (byte~) main::$27) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ) always clobbers reg byte a reg byte y
Statement [43] (byte*) main::fill#0 ← (const byte*) SCREEN_FILL + (word) main::offset#0 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::fill#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::fill#0 ] ) always clobbers reg byte a
Statement [44] if(*((byte*) main::fill#0)==(const byte) FILL_CHAR) goto main::@18 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ) always clobbers reg byte a reg byte y
Statement [45] (byte*) main::angle#0 ← (byte[])(void*) SCREEN_ANGLE + (word) main::offset#0 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ) always clobbers reg byte a
Statement [46] if(*((byte*) main::angle#0)>(byte) main::min_angle#2) goto main::@17 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ) always clobbers reg byte a reg byte y
Statement [47] (byte) main::min_angle#1 ← *((byte*) main::angle#0) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::offset#0 main::min_angle#1 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::offset#0 main::min_angle#1 ] ) always clobbers reg byte a reg byte y
Statement [50] (word~) main::min_offset#8 ← (word) main::min_offset#5 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#1 main::min_offset#8 main::min_angle#5 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#1 main::min_offset#8 main::min_angle#5 ] ) always clobbers reg byte a
Statement [51] (word~) main::min_offset#9 ← (word) main::min_offset#2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#9 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#9 ] ) always clobbers reg byte a
Statement [52] (word~) main::min_offset#11 ← (word) main::min_offset#2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#11 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#11 ] ) always clobbers reg byte a
Statement [55] *((byte[])(void*) BUCKET_SIZES + (byte) init_buckets::i#2) ← (byte) 0 [ BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 init_buckets::i#2 heap_head#1 ] ( main:14::init_buckets:22 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 init_buckets::i#2 heap_head#1 ] ) always clobbers reg byte a
Statement [58] (byte*~) init_buckets::dist#6 ← (byte*) init_buckets::screen#0 [ BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 init_buckets::dist#6 heap_head#1 ] ( main:14::init_buckets:22 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 init_buckets::dist#6 heap_head#1 ] ) always clobbers reg byte a
Statement [60] *((byte[])(void*) BUCKET_SIZES + *((byte*) init_buckets::dist#4)) ← ++ *((byte[])(void*) BUCKET_SIZES + *((byte*) init_buckets::dist#4)) [ BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 init_buckets::dist#4 init_buckets::i1#2 heap_head#1 ] ( main:14::init_buckets:22 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 init_buckets::dist#4 init_buckets::i1#2 heap_head#1 ] ) always clobbers reg byte a reg byte y
@ -6696,21 +6694,21 @@ Statement [19] (byte*) init_angle_screen::screen#0 ← (byte[])(void*) SCREEN_AN
Statement [21] (byte*) init_buckets::screen#0 ← (byte[])(void*) SCREEN_DIST [ SCREEN_ANGLE BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 heap_head#1 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 heap_head#1 ] ) always clobbers reg byte a
Statement [24] if(*((const byte*) RASTER)!=(byte) $ff) goto main::@2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 ] ) always clobbers reg byte a
Statement [26] (byte~) main::$26 ← (byte) main::bucket_idx#6 << (byte) 1 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::$26 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::$26 ] ) always clobbers reg byte a
Statement [27] (word[]) main::bucket#0 ← *((word*[])(void*) BUCKETS + (byte~) main::$26) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 ] ) always clobbers reg byte a reg byte y
Statement [28] (byte) main::bucket_size#0 ← *((byte[])(void*) BUCKET_SIZES + (byte) main::bucket_idx#6) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 ] ) always clobbers reg byte a reg byte y
Statement [27] (word[]) main::bucket ← *((word*[])(void*) BUCKETS + (byte~) main::$26) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket ] ) always clobbers reg byte a reg byte y
Statement [28] (byte) main::bucket_size#0 ← *((byte[])(void*) BUCKET_SIZES + (byte) main::bucket_idx#6) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 ] ) always clobbers reg byte a reg byte y
Statement [32] if((word) main::min_offset#2==(word) $ffff) goto main::@4 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::min_offset#2 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::min_offset#2 ] ) always clobbers reg byte a
Statement [33] (byte*) main::fill1#0 ← (const byte*) SCREEN_FILL + (word) main::min_offset#2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::fill1#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::fill1#0 ] ) always clobbers reg byte a
Statement [34] *((byte*) main::fill1#0) ← (const byte) FILL_CHAR [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 ] ) always clobbers reg byte a reg byte y
Statement [41] (byte~) main::$27 ← (byte) main::i#2 << (byte) 1 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::$27 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::$27 ] ) always clobbers reg byte a
Statement [42] (word) main::offset#0 ← *((word[]) main::bucket#0 + (byte~) main::$27) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ) always clobbers reg byte a reg byte y
Statement [43] (byte*) main::fill#0 ← (const byte*) SCREEN_FILL + (word) main::offset#0 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::fill#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::fill#0 ] ) always clobbers reg byte a
Statement [44] if(*((byte*) main::fill#0)==(const byte) FILL_CHAR) goto main::@18 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ) always clobbers reg byte a reg byte y
Statement [45] (byte*) main::angle#0 ← (byte[])(void*) SCREEN_ANGLE + (word) main::offset#0 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ) always clobbers reg byte a
Statement [46] if(*((byte*) main::angle#0)>(byte) main::min_angle#2) goto main::@17 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ) always clobbers reg byte a reg byte y
Statement [47] (byte) main::min_angle#1 ← *((byte*) main::angle#0) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::offset#0 main::min_angle#1 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::offset#0 main::min_angle#1 ] ) always clobbers reg byte a reg byte y
Statement [50] (word~) main::min_offset#8 ← (word) main::min_offset#5 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#1 main::min_offset#8 main::min_angle#5 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#1 main::min_offset#8 main::min_angle#5 ] ) always clobbers reg byte a
Statement [51] (word~) main::min_offset#9 ← (word) main::min_offset#2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#9 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#9 ] ) always clobbers reg byte a
Statement [52] (word~) main::min_offset#11 ← (word) main::min_offset#2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#11 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket#0 main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#11 ] ) always clobbers reg byte a
Statement [41] (byte~) main::$27 ← (byte) main::i#2 << (byte) 1 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::$27 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::$27 ] ) always clobbers reg byte a
Statement [42] (word) main::offset#0 ← *((word[]) main::bucket + (byte~) main::$27) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ) always clobbers reg byte a reg byte y
Statement [43] (byte*) main::fill#0 ← (const byte*) SCREEN_FILL + (word) main::offset#0 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::fill#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::fill#0 ] ) always clobbers reg byte a
Statement [44] if(*((byte*) main::fill#0)==(const byte) FILL_CHAR) goto main::@18 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 ] ) always clobbers reg byte a reg byte y
Statement [45] (byte*) main::angle#0 ← (byte[])(void*) SCREEN_ANGLE + (word) main::offset#0 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ) always clobbers reg byte a
Statement [46] if(*((byte*) main::angle#0)>(byte) main::min_angle#2) goto main::@17 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_offset#2 main::min_angle#2 main::offset#0 main::angle#0 ] ) always clobbers reg byte a reg byte y
Statement [47] (byte) main::min_angle#1 ← *((byte*) main::angle#0) [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::offset#0 main::min_angle#1 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::offset#0 main::min_angle#1 ] ) always clobbers reg byte a reg byte y
Statement [50] (word~) main::min_offset#8 ← (word) main::min_offset#5 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#1 main::min_offset#8 main::min_angle#5 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#1 main::min_offset#8 main::min_angle#5 ] ) always clobbers reg byte a
Statement [51] (word~) main::min_offset#9 ← (word) main::min_offset#2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#9 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#9 ] ) always clobbers reg byte a
Statement [52] (word~) main::min_offset#11 ← (word) main::min_offset#2 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#11 ] ( main:14 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS main::bucket_idx#6 main::bucket main::bucket_size#0 main::i#2 main::min_angle#2 main::min_offset#11 ] ) always clobbers reg byte a
Statement [55] *((byte[])(void*) BUCKET_SIZES + (byte) init_buckets::i#2) ← (byte) 0 [ BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 init_buckets::i#2 heap_head#1 ] ( main:14::init_buckets:22 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 init_buckets::i#2 heap_head#1 ] ) always clobbers reg byte a
Statement [58] (byte*~) init_buckets::dist#6 ← (byte*) init_buckets::screen#0 [ BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 init_buckets::dist#6 heap_head#1 ] ( main:14::init_buckets:22 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 init_buckets::dist#6 heap_head#1 ] ) always clobbers reg byte a
Statement [60] *((byte[])(void*) BUCKET_SIZES + *((byte*) init_buckets::dist#4)) ← ++ *((byte[])(void*) BUCKET_SIZES + *((byte*) init_buckets::dist#4)) [ BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 init_buckets::dist#4 init_buckets::i1#2 heap_head#1 ] ( main:14::init_buckets:22 [ SCREEN_ANGLE BUCKET_SIZES BUCKETS BUCKET_IDX init_buckets::screen#0 init_buckets::dist#4 init_buckets::i1#2 heap_head#1 ] ) always clobbers reg byte a reg byte y
@ -6875,7 +6873,7 @@ Potential registers zp ZP_WORD:72 [ BUCKET_IDX ] : zp ZP_WORD:72 ,
Potential registers zp ZP_WORD:74 [ init_angle_screen::screen#0 ] : zp ZP_WORD:74 ,
Potential registers zp ZP_WORD:76 [ init_buckets::screen#0 ] : zp ZP_WORD:76 ,
Potential registers zp ZP_BYTE:78 [ main::$26 ] : zp ZP_BYTE:78 , reg byte a , reg byte x , reg byte y ,
Potential registers zp ZP_WORD:79 [ main::bucket#0 ] : zp ZP_WORD:79 ,
Potential registers zp ZP_WORD:79 [ main::bucket ] : zp ZP_WORD:79 ,
Potential registers zp ZP_BYTE:81 [ main::bucket_size#0 ] : zp ZP_BYTE:81 , reg byte x ,
Potential registers zp ZP_WORD:82 [ main::fill1#0 ] : zp ZP_WORD:82 ,
Potential registers zp ZP_BYTE:84 [ main::$27 ] : zp ZP_BYTE:84 , reg byte a , reg byte x , reg byte y ,
@ -6939,7 +6937,7 @@ REGISTER UPLIFT SCOPES
Uplift Scope [atan2_16] 28,670.58: zp ZP_BYTE:41 [ atan2_16::shift#2 atan2_16::shift#5 atan2_16::shift#1 ] 20,608: zp ZP_WORD:42 [ atan2_16::yd#5 atan2_16::yd#3 atan2_16::yd#10 atan2_16::yd#1 atan2_16::yd#2 ] 17,338.67: zp ZP_WORD:44 [ atan2_16::xd#5 atan2_16::xd#3 atan2_16::xd#10 atan2_16::xd#1 atan2_16::xd#2 ] 7,533.33: zp ZP_WORD:37 [ atan2_16::angle#6 atan2_16::angle#12 atan2_16::angle#13 atan2_16::angle#2 atan2_16::angle#3 ] 2,698.28: zp ZP_WORD:32 [ atan2_16::yi#3 atan2_16::yi#8 atan2_16::yi#0 atan2_16::yi#16 atan2_16::$2 atan2_16::yi#1 atan2_16::yi#2 ] 2,283.07: zp ZP_WORD:34 [ atan2_16::xi#3 atan2_16::xi#8 atan2_16::xi#0 atan2_16::xi#13 atan2_16::$7 atan2_16::xi#1 atan2_16::xi#2 ] 2,002: zp ZP_BYTE:132 [ atan2_16::$24 ] 2,002: zp ZP_BYTE:133 [ atan2_16::$23 ] 1,710.04: zp ZP_BYTE:36 [ atan2_16::i#2 atan2_16::i#1 ] 202: zp ZP_WORD:122 [ atan2_16::return#2 ] 50: zp ZP_WORD:39 [ atan2_16::return#0 atan2_16::angle#5 atan2_16::angle#11 atan2_16::angle#1 atan2_16::angle#4 ] 2.87: zp ZP_WORD:118 [ atan2_16::x#0 ] 2.72: zp ZP_WORD:120 [ atan2_16::y#0 ]
Uplift Scope [bsearch16u] 7,563.11: zp ZP_BYTE:57 [ bsearch16u::num#5 bsearch16u::num#1 bsearch16u::num#3 bsearch16u::num#0 ] 2,855.06: zp ZP_WORD:55 [ bsearch16u::return#1 bsearch16u::return#6 bsearch16u::return#2 bsearch16u::items#2 bsearch16u::items#1 bsearch16u::items#8 bsearch16u::$2 bsearch16u::items#0 ] 2,002: zp ZP_BYTE:161 [ bsearch16u::$6 ] 2,002: zp ZP_BYTE:162 [ bsearch16u::$16 ] 1,501.5: zp ZP_WORD:165 [ bsearch16u::result#0 ] 501: zp ZP_WORD:163 [ bsearch16u::pivot#0 ] 4: zp ZP_WORD:152 [ bsearch16u::return#3 ] 0.27: zp ZP_WORD:150 [ bsearch16u::key#0 ]
Uplift Scope [init_angle_screen] 220.36: zp ZP_BYTE:31 [ init_angle_screen::xb#2 init_angle_screen::xb#1 ] 202: zp ZP_BYTE:111 [ init_angle_screen::$3 ] 202: zp ZP_BYTE:112 [ init_angle_screen::$4 ] 202: zp ZP_BYTE:115 [ init_angle_screen::$7 ] 202: zp ZP_WORD:124 [ init_angle_screen::angle_w#0 ] 202: zp ZP_WORD:126 [ init_angle_screen::$11 ] 202: zp ZP_BYTE:129 [ init_angle_screen::$13 ] 202: zp ZP_BYTE:130 [ init_angle_screen::$14 ] 202: zp ZP_BYTE:131 [ init_angle_screen::$15 ] 129.86: zp ZP_BYTE:30 [ init_angle_screen::x#2 init_angle_screen::x#1 ] 84.17: zp ZP_BYTE:128 [ init_angle_screen::ang_w#0 ] 50.5: zp ZP_WORD:116 [ init_angle_screen::yw#0 ] 33.67: zp ZP_WORD:113 [ init_angle_screen::xw#0 ] 21.23: zp ZP_BYTE:25 [ init_angle_screen::y#5 init_angle_screen::y#1 ] 20.37: zp ZP_WORD:28 [ init_angle_screen::screen_bottomline#6 init_angle_screen::screen_bottomline#0 init_angle_screen::screen_bottomline#1 ] 16.92: zp ZP_WORD:26 [ init_angle_screen::screen_topline#6 init_angle_screen::screen_topline#0 init_angle_screen::screen_topline#1 ] 3: zp ZP_WORD:74 [ init_angle_screen::screen#0 ]
Uplift Scope [main] 673.33: zp ZP_WORD:7 [ main::min_offset#5 main::min_offset#9 main::offset#0 main::min_offset#11 ] 377.07: zp ZP_BYTE:6 [ main::min_angle#2 main::min_angle#5 main::min_angle#1 ] 238.11: zp ZP_WORD:4 [ main::min_offset#2 main::min_offset#8 ] 202: zp ZP_BYTE:84 [ main::$27 ] 202: zp ZP_WORD:85 [ main::fill#0 ] 151.5: zp ZP_WORD:87 [ main::angle#0 ] 134.67: zp ZP_BYTE:3 [ main::i#2 main::i#1 ] 22: zp ZP_BYTE:78 [ main::$26 ] 22: zp ZP_WORD:82 [ main::fill1#0 ] 13.64: zp ZP_BYTE:2 [ main::bucket_idx#6 main::bucket_idx#1 ] 7.69: zp ZP_BYTE:81 [ main::bucket_size#0 ] 6.59: zp ZP_WORD:79 [ main::bucket#0 ]
Uplift Scope [main] 673.33: zp ZP_WORD:7 [ main::min_offset#5 main::min_offset#9 main::offset#0 main::min_offset#11 ] 377.07: zp ZP_BYTE:6 [ main::min_angle#2 main::min_angle#5 main::min_angle#1 ] 238.11: zp ZP_WORD:4 [ main::min_offset#2 main::min_offset#8 ] 202: zp ZP_BYTE:84 [ main::$27 ] 202: zp ZP_WORD:85 [ main::fill#0 ] 151.5: zp ZP_WORD:87 [ main::angle#0 ] 134.67: zp ZP_BYTE:3 [ main::i#2 main::i#1 ] 22: zp ZP_BYTE:78 [ main::$26 ] 22: zp ZP_WORD:82 [ main::fill1#0 ] 13.64: zp ZP_BYTE:2 [ main::bucket_idx#6 main::bucket_idx#1 ] 7.69: zp ZP_BYTE:81 [ main::bucket_size#0 ] 6.59: zp ZP_WORD:79 [ main::bucket ]
Uplift Scope [init_dist_screen] 707: zp ZP_BYTE:54 [ init_dist_screen::xd#0 init_dist_screen::$16 init_dist_screen::$14 ] 221.24: zp ZP_BYTE:53 [ init_dist_screen::xb#2 init_dist_screen::xb#1 ] 202: zp ZP_BYTE:139 [ init_dist_screen::x2#0 ] 202: zp ZP_WORD:142 [ init_dist_screen::xds#0 ] 202: zp ZP_WORD:144 [ init_dist_screen::ds#0 ] 131.3: zp ZP_BYTE:52 [ init_dist_screen::x#2 init_dist_screen::x#1 ] 126.25: zp ZP_BYTE:149 [ init_dist_screen::d#0 ] 77: zp ZP_BYTE:51 [ init_dist_screen::yd#0 init_dist_screen::$7 init_dist_screen::$5 ] 22: zp ZP_BYTE:134 [ init_dist_screen::y2#0 ] 18.18: zp ZP_WORD:49 [ init_dist_screen::screen_bottomline#11 init_dist_screen::screen_bottomline#0 init_dist_screen::screen_bottomline#1 ] 17.47: zp ZP_BYTE:46 [ init_dist_screen::y#10 init_dist_screen::y#1 ] 14.06: zp ZP_WORD:47 [ init_dist_screen::screen_topline#11 init_dist_screen::screen#0 init_dist_screen::screen_topline#1 ] 4.87: zp ZP_WORD:137 [ init_dist_screen::yds#0 ]
Uplift Scope [sqr] 338: zp ZP_BYTE:58 [ sqr::val#2 sqr::val#1 sqr::val#0 ] 202: zp ZP_WORD:140 [ sqr::return#3 ] 28.5: zp ZP_WORD:168 [ sqr::return#0 ] 22: zp ZP_WORD:135 [ sqr::return#2 ] 4: zp ZP_BYTE:167 [ sqr::$0 ]
Uplift Scope [init_buckets] 34.33: zp ZP_WORD:10 [ init_buckets::dist#4 init_buckets::dist#6 init_buckets::dist#1 ] 33: zp ZP_BYTE:9 [ init_buckets::i#2 init_buckets::i#1 ] 33: zp ZP_BYTE:16 [ init_buckets::i3#2 init_buckets::i3#1 ] 23.83: zp ZP_WORD:12 [ init_buckets::i1#2 init_buckets::i1#1 ] 22: zp ZP_WORD:14 [ init_buckets::i2#2 init_buckets::i2#1 ] 22: zp ZP_WORD:89 [ init_buckets::$18 ] 22: zp ZP_WORD:93 [ init_buckets::$15 ] 22: zp ZP_WORD:95 [ init_buckets::$19 ] 22: zp ZP_WORD:98 [ init_buckets::$10 ] 22: zp ZP_WORD:100 [ init_buckets::$16 ] 22: zp ZP_WORD:102 [ init_buckets::$20 ] 22: zp ZP_BYTE:108 [ init_buckets::$17 ] 18.5: zp ZP_WORD:19 [ init_buckets::i4#2 init_buckets::i4#1 ] 15.93: zp ZP_WORD:17 [ init_buckets::dist#5 init_buckets::dist#8 init_buckets::dist#3 ] 11: zp ZP_WORD:106 [ init_buckets::$11 ] 7.33: zp ZP_WORD:104 [ init_buckets::bucket#0 ] 5.5: zp ZP_BYTE:97 [ init_buckets::distance#0 ] 3.67: zp ZP_WORD:91 [ init_buckets::$6 ] 0.43: zp ZP_WORD:76 [ init_buckets::screen#0 ]
@ -6954,7 +6952,7 @@ Limited combination testing to 100 combinations of 144 possible.
Uplifting [bsearch16u] best 1234979 combination reg byte x [ bsearch16u::num#5 bsearch16u::num#1 bsearch16u::num#3 bsearch16u::num#0 ] zp ZP_WORD:55 [ bsearch16u::return#1 bsearch16u::return#6 bsearch16u::return#2 bsearch16u::items#2 bsearch16u::items#1 bsearch16u::items#8 bsearch16u::$2 bsearch16u::items#0 ] reg byte a [ bsearch16u::$6 ] reg byte a [ bsearch16u::$16 ] zp ZP_WORD:165 [ bsearch16u::result#0 ] zp ZP_WORD:163 [ bsearch16u::pivot#0 ] zp ZP_WORD:152 [ bsearch16u::return#3 ] zp ZP_WORD:150 [ bsearch16u::key#0 ]
Uplifting [init_angle_screen] best 1233379 combination zp ZP_BYTE:31 [ init_angle_screen::xb#2 init_angle_screen::xb#1 ] reg byte a [ init_angle_screen::$3 ] reg byte a [ init_angle_screen::$4 ] reg byte a [ init_angle_screen::$7 ] zp ZP_WORD:124 [ init_angle_screen::angle_w#0 ] zp ZP_WORD:126 [ init_angle_screen::$11 ] zp ZP_BYTE:129 [ init_angle_screen::$13 ] zp ZP_BYTE:130 [ init_angle_screen::$14 ] zp ZP_BYTE:131 [ init_angle_screen::$15 ] zp ZP_BYTE:30 [ init_angle_screen::x#2 init_angle_screen::x#1 ] zp ZP_BYTE:128 [ init_angle_screen::ang_w#0 ] zp ZP_WORD:116 [ init_angle_screen::yw#0 ] zp ZP_WORD:113 [ init_angle_screen::xw#0 ] zp ZP_BYTE:25 [ init_angle_screen::y#5 init_angle_screen::y#1 ] zp ZP_WORD:28 [ init_angle_screen::screen_bottomline#6 init_angle_screen::screen_bottomline#0 init_angle_screen::screen_bottomline#1 ] zp ZP_WORD:26 [ init_angle_screen::screen_topline#6 init_angle_screen::screen_topline#0 init_angle_screen::screen_topline#1 ] zp ZP_WORD:74 [ init_angle_screen::screen#0 ]
Limited combination testing to 100 combinations of 65536 possible.
Uplifting [main] best 1231939 combination zp ZP_WORD:7 [ main::min_offset#5 main::min_offset#9 main::offset#0 main::min_offset#11 ] zp ZP_BYTE:6 [ main::min_angle#2 main::min_angle#5 main::min_angle#1 ] zp ZP_WORD:4 [ main::min_offset#2 main::min_offset#8 ] reg byte a [ main::$27 ] zp ZP_WORD:85 [ main::fill#0 ] zp ZP_WORD:87 [ main::angle#0 ] reg byte x [ main::i#2 main::i#1 ] reg byte a [ main::$26 ] zp ZP_WORD:82 [ main::fill1#0 ] zp ZP_BYTE:2 [ main::bucket_idx#6 main::bucket_idx#1 ] zp ZP_BYTE:81 [ main::bucket_size#0 ] zp ZP_WORD:79 [ main::bucket#0 ]
Uplifting [main] best 1231939 combination zp ZP_WORD:7 [ main::min_offset#5 main::min_offset#9 main::offset#0 main::min_offset#11 ] zp ZP_BYTE:6 [ main::min_angle#2 main::min_angle#5 main::min_angle#1 ] zp ZP_WORD:4 [ main::min_offset#2 main::min_offset#8 ] reg byte a [ main::$27 ] zp ZP_WORD:85 [ main::fill#0 ] zp ZP_WORD:87 [ main::angle#0 ] reg byte x [ main::i#2 main::i#1 ] reg byte a [ main::$26 ] zp ZP_WORD:82 [ main::fill1#0 ] zp ZP_BYTE:2 [ main::bucket_idx#6 main::bucket_idx#1 ] zp ZP_BYTE:81 [ main::bucket_size#0 ] zp ZP_WORD:79 [ main::bucket ]
Limited combination testing to 100 combinations of 256 possible.
Uplifting [init_dist_screen] best 1228739 combination reg byte a [ init_dist_screen::xd#0 init_dist_screen::$16 init_dist_screen::$14 ] zp ZP_BYTE:53 [ init_dist_screen::xb#2 init_dist_screen::xb#1 ] reg byte a [ init_dist_screen::x2#0 ] zp ZP_WORD:142 [ init_dist_screen::xds#0 ] zp ZP_WORD:144 [ init_dist_screen::ds#0 ] zp ZP_BYTE:52 [ init_dist_screen::x#2 init_dist_screen::x#1 ] reg byte a [ init_dist_screen::d#0 ] zp ZP_BYTE:51 [ init_dist_screen::yd#0 init_dist_screen::$7 init_dist_screen::$5 ] zp ZP_BYTE:134 [ init_dist_screen::y2#0 ] zp ZP_WORD:49 [ init_dist_screen::screen_bottomline#11 init_dist_screen::screen_bottomline#0 init_dist_screen::screen_bottomline#1 ] zp ZP_BYTE:46 [ init_dist_screen::y#10 init_dist_screen::y#1 ] zp ZP_WORD:47 [ init_dist_screen::screen_topline#11 init_dist_screen::screen#0 init_dist_screen::screen_topline#1 ] zp ZP_WORD:137 [ init_dist_screen::yds#0 ]
Limited combination testing to 100 combinations of 6144 possible.
@ -7037,7 +7035,7 @@ Coalescing zero page register [ zp ZP_WORD:47 [ init_dist_screen::screen_topline
Coalescing zero page register [ zp ZP_WORD:49 [ init_dist_screen::screen_bottomline#11 init_dist_screen::screen_bottomline#0 init_dist_screen::screen_bottomline#1 ] ] with [ zp ZP_WORD:37 [ atan2_16::angle#6 atan2_16::angle#12 atan2_16::angle#13 atan2_16::angle#2 atan2_16::angle#3 atan2_16::return#0 atan2_16::angle#5 atan2_16::angle#11 atan2_16::angle#1 atan2_16::angle#4 atan2_16::return#2 init_angle_screen::angle_w#0 init_angle_screen::$11 ] ]
Coalescing zero page register [ zp ZP_WORD:55 [ bsearch16u::return#1 bsearch16u::return#6 bsearch16u::return#2 bsearch16u::items#2 bsearch16u::items#1 bsearch16u::items#8 bsearch16u::$2 bsearch16u::items#0 bsearch16u::return#3 sqrt::found#0 sqrt::$3 sqrt::$1 ] ] with [ zp ZP_WORD:42 [ atan2_16::yd#5 atan2_16::yd#3 atan2_16::yd#10 atan2_16::yd#1 atan2_16::yd#2 ] ]
Coalescing zero page register [ zp ZP_WORD:59 [ init_squares::sqr#2 init_squares::sqr#1 ] ] with [ zp ZP_WORD:44 [ atan2_16::xd#5 atan2_16::xd#3 atan2_16::xd#10 atan2_16::xd#1 atan2_16::xd#2 ] ]
Coalescing zero page register [ zp ZP_WORD:79 [ main::bucket#0 ] ] with [ zp ZP_WORD:61 [ init_squares::squares#2 init_squares::squares#1 init_squares::squares#0 ] ]
Coalescing zero page register [ zp ZP_WORD:79 [ main::bucket ] ] with [ zp ZP_WORD:61 [ init_squares::squares#2 init_squares::squares#1 init_squares::squares#0 ] ]
Coalescing zero page register [ zp ZP_BYTE:81 [ main::bucket_size#0 ] ] with [ zp ZP_BYTE:52 [ init_dist_screen::x#2 init_dist_screen::x#1 ] ]
Coalescing zero page register [ zp ZP_WORD:85 [ main::fill#0 ] ] with [ zp ZP_WORD:64 [ SCREEN_DIST init_buckets::screen#0 ] ]
Coalescing zero page register [ zp ZP_WORD:87 [ main::angle#0 ] ] with [ zp ZP_WORD:72 [ BUCKET_IDX ] ]
@ -7047,7 +7045,7 @@ Coalescing zero page register [ zp ZP_WORD:116 [ init_angle_screen::yw#0 atan2_1
Coalescing zero page register [ zp ZP_WORD:135 [ sqr::return#2 init_dist_screen::yds#0 ] ] with [ zp ZP_WORD:106 [ init_buckets::$11 ] ]
Coalescing zero page register [ zp ZP_WORD:47 [ init_dist_screen::screen_topline#11 init_dist_screen::screen#0 init_dist_screen::screen_topline#1 atan2_16::xi#3 atan2_16::xi#8 atan2_16::xi#0 atan2_16::xi#13 atan2_16::$7 atan2_16::xi#1 atan2_16::xi#2 ] ] with [ zp ZP_WORD:10 [ init_buckets::dist#4 init_buckets::dist#6 init_buckets::dist#1 main::min_offset#2 main::min_offset#8 main::fill1#0 ] ]
Coalescing zero page register [ zp ZP_WORD:49 [ init_dist_screen::screen_bottomline#11 init_dist_screen::screen_bottomline#0 init_dist_screen::screen_bottomline#1 atan2_16::angle#6 atan2_16::angle#12 atan2_16::angle#13 atan2_16::angle#2 atan2_16::angle#3 atan2_16::return#0 atan2_16::angle#5 atan2_16::angle#11 atan2_16::angle#1 atan2_16::angle#4 atan2_16::return#2 init_angle_screen::angle_w#0 init_angle_screen::$11 ] ] with [ zp ZP_WORD:12 [ init_buckets::i1#2 init_buckets::i1#1 main::min_offset#5 main::min_offset#9 main::offset#0 main::min_offset#11 ] ]
Coalescing zero page register [ zp ZP_WORD:79 [ main::bucket#0 init_squares::squares#2 init_squares::squares#1 init_squares::squares#0 ] ] with [ zp ZP_WORD:26 [ init_angle_screen::screen_topline#6 init_angle_screen::screen_topline#0 init_angle_screen::screen_topline#1 init_buckets::i2#2 init_buckets::i2#1 ] ]
Coalescing zero page register [ zp ZP_WORD:79 [ main::bucket init_squares::squares#2 init_squares::squares#1 init_squares::squares#0 ] ] with [ zp ZP_WORD:26 [ init_angle_screen::screen_topline#6 init_angle_screen::screen_topline#0 init_angle_screen::screen_topline#1 init_buckets::i2#2 init_buckets::i2#1 ] ]
Coalescing zero page register [ zp ZP_BYTE:97 [ init_buckets::distance#0 init_dist_screen::xb#2 init_dist_screen::xb#1 ] ] with [ zp ZP_BYTE:25 [ init_angle_screen::y#5 init_angle_screen::y#1 main::bucket_idx#6 main::bucket_idx#1 ] ]
Coalescing zero page register [ zp ZP_BYTE:128 [ init_angle_screen::ang_w#0 ] ] with [ zp ZP_BYTE:81 [ main::bucket_size#0 init_dist_screen::x#2 init_dist_screen::x#1 ] ]
Coalescing zero page register [ zp ZP_WORD:135 [ sqr::return#2 init_dist_screen::yds#0 init_buckets::$11 ] ] with [ zp ZP_WORD:59 [ init_squares::sqr#2 init_squares::sqr#1 atan2_16::xd#5 atan2_16::xd#3 atan2_16::xd#10 atan2_16::xd#1 atan2_16::xd#2 ] ]
@ -7064,7 +7062,7 @@ Allocated (was zp ZP_WORD:55) zp ZP_WORD:12 [ bsearch16u::return#1 bsearch16u::r
Allocated (was zp ZP_WORD:66) zp ZP_WORD:14 [ SCREEN_ANGLE ]
Allocated (was zp ZP_WORD:68) zp ZP_WORD:16 [ BUCKET_SIZES ]
Allocated (was zp ZP_WORD:70) zp ZP_WORD:18 [ BUCKETS ]
Allocated (was zp ZP_WORD:79) zp ZP_WORD:20 [ main::bucket#0 init_squares::squares#2 init_squares::squares#1 init_squares::squares#0 init_angle_screen::screen_topline#6 init_angle_screen::screen_topline#0 init_angle_screen::screen_topline#1 init_buckets::i2#2 init_buckets::i2#1 ]
Allocated (was zp ZP_WORD:79) zp ZP_WORD:20 [ main::bucket init_squares::squares#2 init_squares::squares#1 init_squares::squares#0 init_angle_screen::screen_topline#6 init_angle_screen::screen_topline#0 init_angle_screen::screen_topline#1 init_buckets::i2#2 init_buckets::i2#1 ]
Allocated (was zp ZP_WORD:85) zp ZP_WORD:22 [ main::fill#0 SCREEN_DIST init_buckets::screen#0 ]
Allocated (was zp ZP_WORD:87) zp ZP_WORD:24 [ main::angle#0 BUCKET_IDX ]
Allocated (was zp ZP_BYTE:97) zp ZP_BYTE:26 [ init_buckets::distance#0 init_dist_screen::xb#2 init_dist_screen::xb#1 init_angle_screen::y#5 init_angle_screen::y#1 main::bucket_idx#6 main::bucket_idx#1 ]
@ -7299,7 +7297,7 @@ main: {
// [26] (byte~) main::$26 ← (byte) main::bucket_idx#6 << (byte) 1 -- vbuaa=vbuz1_rol_1
lda.z bucket_idx
asl
// [27] (word[]) main::bucket#0 ← *((word*[])(void*) BUCKETS + (byte~) main::$26) -- pwuz1=pptz2_derefidx_vbuaa
// [27] (word[]) main::bucket ← *((word*[])(void*) BUCKETS + (byte~) main::$26) -- pwuz1=pptz2_derefidx_vbuaa
tay
lda (BUCKETS),y
sta.z bucket
@ -7394,7 +7392,7 @@ main: {
// [41] (byte~) main::$27 ← (byte) main::i#2 << (byte) 1 -- vbuaa=vbuxx_rol_1
txa
asl
// [42] (word) main::offset#0 ← *((word[]) main::bucket#0 + (byte~) main::$27) -- vwuz1=pwuz2_derefidx_vbuaa
// [42] (word) main::offset#0 ← *((word[]) main::bucket + (byte~) main::$27) -- vwuz1=pwuz2_derefidx_vbuaa
tay
lda (bucket),y
sta.z offset
@ -9402,8 +9400,7 @@ FINAL SYMBOL TABLE
(label) main::@9
(byte*) main::angle
(byte*) main::angle#0 angle zp ZP_WORD:24 151.5
(word[]) main::bucket
(word[]) main::bucket#0 bucket zp ZP_WORD:20 6.588235294117648
(word[]) main::bucket bucket zp ZP_WORD:20 6.588235294117648
(byte) main::bucket_idx
(byte) main::bucket_idx#1 bucket_idx zp ZP_BYTE:26 11.0
(byte) main::bucket_idx#6 bucket_idx zp ZP_BYTE:26 2.64
@ -9482,7 +9479,7 @@ zp ZP_WORD:14 [ SCREEN_ANGLE ]
zp ZP_WORD:16 [ BUCKET_SIZES ]
zp ZP_WORD:18 [ BUCKETS ]
reg byte a [ main::$26 ]
zp ZP_WORD:20 [ main::bucket#0 init_squares::squares#2 init_squares::squares#1 init_squares::squares#0 init_angle_screen::screen_topline#6 init_angle_screen::screen_topline#0 init_angle_screen::screen_topline#1 init_buckets::i2#2 init_buckets::i2#1 ]
zp ZP_WORD:20 [ main::bucket init_squares::squares#2 init_squares::squares#1 init_squares::squares#0 init_angle_screen::screen_topline#6 init_angle_screen::screen_topline#0 init_angle_screen::screen_topline#1 init_buckets::i2#2 init_buckets::i2#1 ]
reg byte a [ main::$27 ]
zp ZP_WORD:22 [ main::fill#0 SCREEN_DIST init_buckets::screen#0 ]
zp ZP_WORD:24 [ main::angle#0 BUCKET_IDX ]
@ -9718,7 +9715,7 @@ main: {
// [26] (byte~) main::$26 ← (byte) main::bucket_idx#6 << (byte) 1 -- vbuaa=vbuz1_rol_1
lda.z bucket_idx
asl
// [27] (word[]) main::bucket#0 ← *((word*[])(void*) BUCKETS + (byte~) main::$26) -- pwuz1=pptz2_derefidx_vbuaa
// [27] (word[]) main::bucket ← *((word*[])(void*) BUCKETS + (byte~) main::$26) -- pwuz1=pptz2_derefidx_vbuaa
tay
lda (BUCKETS),y
sta.z bucket
@ -9814,7 +9811,7 @@ main: {
// [41] (byte~) main::$27 ← (byte) main::i#2 << (byte) 1 -- vbuaa=vbuxx_rol_1
txa
asl
// [42] (word) main::offset#0 ← *((word[]) main::bucket#0 + (byte~) main::$27) -- vwuz1=pwuz2_derefidx_vbuaa
// [42] (word) main::offset#0 ← *((word[]) main::bucket + (byte~) main::$27) -- vwuz1=pwuz2_derefidx_vbuaa
tay
lda (bucket),y
sta.z offset

5
src/test/ref/screen-show-spiral-buckets.sym
View File

@ -331,8 +331,7 @@
(label) main::@9
(byte*) main::angle
(byte*) main::angle#0 angle zp ZP_WORD:24 151.5
(word[]) main::bucket
(word[]) main::bucket#0 bucket zp ZP_WORD:20 6.588235294117648
(word[]) main::bucket bucket zp ZP_WORD:20 6.588235294117648
(byte) main::bucket_idx
(byte) main::bucket_idx#1 bucket_idx zp ZP_BYTE:26 11.0
(byte) main::bucket_idx#6 bucket_idx zp ZP_BYTE:26 2.64
@ -411,7 +410,7 @@ zp ZP_WORD:14 [ SCREEN_ANGLE ]
zp ZP_WORD:16 [ BUCKET_SIZES ]
zp ZP_WORD:18 [ BUCKETS ]
reg byte a [ main::$26 ]
zp ZP_WORD:20 [ main::bucket#0 init_squares::squares#2 init_squares::squares#1 init_squares::squares#0 init_angle_screen::screen_topline#6 init_angle_screen::screen_topline#0 init_angle_screen::screen_topline#1 init_buckets::i2#2 init_buckets::i2#1 ]
zp ZP_WORD:20 [ main::bucket init_squares::squares#2 init_squares::squares#1 init_squares::squares#0 init_angle_screen::screen_topline#6 init_angle_screen::screen_topline#0 init_angle_screen::screen_topline#1 init_buckets::i2#2 init_buckets::i2#1 ]
reg byte a [ main::$27 ]
zp ZP_WORD:22 [ main::fill#0 SCREEN_DIST init_buckets::screen#0 ]
zp ZP_WORD:24 [ main::angle#0 BUCKET_IDX ]

20
src/test/ref/test-comparisons.cfg
View File

@ -44,7 +44,7 @@ main::@3: scope:[main] from main::@23 main::@43
[20] call printu
to:main::@44
main::@44: scope:[main] from main::@3
[21] if((byte) main::a#10>=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@4
[21] if((byte) main::a#10>=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@4
to:main::@24
main::@24: scope:[main] from main::@44
[22] phi()
@ -52,7 +52,7 @@ main::@24: scope:[main] from main::@44
main::@4: scope:[main] from main::@24 main::@44
[23] (byte) main::r#43 ← phi( main::@24/(byte) '+' main::@44/(byte) '-' )
[24] (byte) printu::a#2 ← (byte) main::a#10
[25] (byte) printu::b#2 ← *((const byte[5]) main::cs#0 + (byte) main::i#10)
[25] (byte) printu::b#2 ← *((const byte[5]) main::cs + (byte) main::i#10)
[26] (byte) printu::res#2 ← (byte) main::r#43
[27] call printu
to:main::@45
@ -100,7 +100,7 @@ main::@7: scope:[main] from main::@27 main::@48
[50] call printu
to:main::@49
main::@49: scope:[main] from main::@7
[51] if((byte) main::a#10<=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@8
[51] if((byte) main::a#10<=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@8
to:main::@28
main::@28: scope:[main] from main::@49
[52] phi()
@ -108,7 +108,7 @@ main::@28: scope:[main] from main::@49
main::@8: scope:[main] from main::@28 main::@49
[53] (byte) main::r#47 ← phi( main::@28/(byte) '+' main::@49/(byte) '-' )
[54] (byte) printu::a#6 ← (byte) main::a#10
[55] (byte) printu::b#6 ← *((const byte[5]) main::cs#0 + (byte) main::i#10)
[55] (byte) printu::b#6 ← *((const byte[5]) main::cs + (byte) main::i#10)
[56] (byte) printu::res#6 ← (byte) main::r#47
[57] call printu
to:main::@50
@ -156,7 +156,7 @@ main::@11: scope:[main] from main::@31 main::@53
[80] call printu
to:main::@54
main::@54: scope:[main] from main::@11
[81] if((byte) main::a#10>*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@12
[81] if((byte) main::a#10>*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@12
to:main::@32
main::@32: scope:[main] from main::@54
[82] phi()
@ -164,7 +164,7 @@ main::@32: scope:[main] from main::@54
main::@12: scope:[main] from main::@32 main::@54
[83] (byte) main::r#51 ← phi( main::@32/(byte) '+' main::@54/(byte) '-' )
[84] (byte) printu::a#10 ← (byte) main::a#10
[85] (byte) printu::b#10 ← *((const byte[5]) main::cs#0 + (byte) main::i#10)
[85] (byte) printu::b#10 ← *((const byte[5]) main::cs + (byte) main::i#10)
[86] (byte) printu::res#10 ← (byte) main::r#51
[87] call printu
to:main::@55
@ -212,7 +212,7 @@ main::@15: scope:[main] from main::@35 main::@58
[110] call printu
to:main::@59
main::@59: scope:[main] from main::@15
[111] if((byte) main::a#10<*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@16
[111] if((byte) main::a#10<*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@16
to:main::@36
main::@36: scope:[main] from main::@59
[112] phi()
@ -220,7 +220,7 @@ main::@36: scope:[main] from main::@59
main::@16: scope:[main] from main::@36 main::@59
[113] (byte) main::r#55 ← phi( main::@36/(byte) '+' main::@59/(byte) '-' )
[114] (byte) printu::a#14 ← (byte) main::a#10
[115] (byte) printu::b#14 ← *((const byte[5]) main::cs#0 + (byte) main::i#10)
[115] (byte) printu::b#14 ← *((const byte[5]) main::cs + (byte) main::i#10)
[116] (byte) printu::res#14 ← (byte) main::r#55
[117] call printu
to:main::@60
@ -268,7 +268,7 @@ main::@19: scope:[main] from main::@39 main::@63
[140] call printu
to:main::@64
main::@64: scope:[main] from main::@19
[141] if((byte) main::a#10!=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@20
[141] if((byte) main::a#10!=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@20
to:main::@40
main::@40: scope:[main] from main::@64
[142] phi()
@ -276,7 +276,7 @@ main::@40: scope:[main] from main::@64
main::@20: scope:[main] from main::@40 main::@64
[143] (byte) main::r#59 ← phi( main::@40/(byte) '+' main::@64/(byte) '-' )
[144] (byte) printu::a#18 ← (byte) main::a#10
[145] (byte) printu::b#18 ← *((const byte[5]) main::cs#0 + (byte) main::i#10)
[145] (byte) printu::b#18 ← *((const byte[5]) main::cs + (byte) main::i#10)
[146] (byte) printu::res#18 ← (byte) main::r#59
[147] call printu
to:main::@65

191
src/test/ref/test-comparisons.log
View File

@ -249,7 +249,7 @@ main::@1: scope:[main] from main::@45 main::@70
(byte) main::r#0 ← (byte) 0
(number~) main::$1 ← (number) $ce - (byte) main::a#2
(byte) main::b#0 ← (number~) main::$1
(byte[5]) main::cs#0 ← { (number) 7, (number) $c7, (number) $37, (number) $97, (number) $67 }
(byte[5]) main::cs ← { (number) 7, (number) $c7, (number) $37, (number) $97, (number) $67 }
(byte) main::r#1 ← (byte) '-'
(bool~) main::$2 ← (byte) main::a#2 < (byte) main::b#0
(bool~) main::$3 ← ! (bool~) main::$2
@ -309,7 +309,7 @@ main::@47: scope:[main] from main::@3
(byte*) print_char_cursor#59 ← phi( main::@3/(byte*) print_char_cursor#45 )
(byte*) print_char_cursor#14 ← (byte*) print_char_cursor#59
(byte) main::r#4 ← (byte) '-'
(bool~) main::$8 ← (byte) main::a#6 < *((byte[5]) main::cs#0 + (byte) main::i#2)
(bool~) main::$8 ← (byte) main::a#6 < *((byte[5]) main::cs + (byte) main::i#2)
(bool~) main::$9 ← ! (bool~) main::$8
if((bool~) main::$9) goto main::@4
to:main::@24
@ -330,7 +330,7 @@ main::@4: scope:[main] from main::@24 main::@47
(byte) main::a#7 ← phi( main::@24/(byte) main::a#45 main::@47/(byte) main::a#6 )
(byte) printu::a#2 ← (byte) main::a#7
(byte[]) printu::op#2 ← (const string) main::op2
(byte) printu::b#2 ← *((byte[5]) main::cs#0 + (byte) main::i#3)
(byte) printu::b#2 ← *((byte[5]) main::cs + (byte) main::i#3)
(byte) printu::res#2 ← (byte) main::r#43
call printu
to:main::@48
@ -451,7 +451,7 @@ main::@52: scope:[main] from main::@7
(byte*) print_char_cursor#64 ← phi( main::@7/(byte*) print_char_cursor#45 )
(byte*) print_char_cursor#19 ← (byte*) print_char_cursor#64
(byte) main::r#12 ← (byte) '-'
(bool~) main::$21 ← (byte) main::a#14 > *((byte[5]) main::cs#0 + (byte) main::i#4)
(bool~) main::$21 ← (byte) main::a#14 > *((byte[5]) main::cs + (byte) main::i#4)
(bool~) main::$22 ← ! (bool~) main::$21
if((bool~) main::$22) goto main::@8
to:main::@28
@ -472,7 +472,7 @@ main::@8: scope:[main] from main::@28 main::@52
(byte) main::a#15 ← phi( main::@28/(byte) main::a#50 main::@52/(byte) main::a#14 )
(byte) printu::a#6 ← (byte) main::a#15
(byte[]) printu::op#6 ← (const string) main::op6
(byte) printu::b#6 ← *((byte[5]) main::cs#0 + (byte) main::i#5)
(byte) printu::b#6 ← *((byte[5]) main::cs + (byte) main::i#5)
(byte) printu::res#6 ← (byte) main::r#47
call printu
to:main::@53
@ -593,7 +593,7 @@ main::@57: scope:[main] from main::@11
(byte*) print_char_cursor#69 ← phi( main::@11/(byte*) print_char_cursor#45 )
(byte*) print_char_cursor#24 ← (byte*) print_char_cursor#69
(byte) main::r#20 ← (byte) '-'
(bool~) main::$34 ← (byte) main::a#22 <= *((byte[5]) main::cs#0 + (byte) main::i#6)
(bool~) main::$34 ← (byte) main::a#22 <= *((byte[5]) main::cs + (byte) main::i#6)
(bool~) main::$35 ← ! (bool~) main::$34
if((bool~) main::$35) goto main::@12
to:main::@32
@ -614,7 +614,7 @@ main::@12: scope:[main] from main::@32 main::@57
(byte) main::a#23 ← phi( main::@32/(byte) main::a#55 main::@57/(byte) main::a#22 )
(byte) printu::a#10 ← (byte) main::a#23
(byte[]) printu::op#10 ← (const string) main::op10
(byte) printu::b#10 ← *((byte[5]) main::cs#0 + (byte) main::i#7)
(byte) printu::b#10 ← *((byte[5]) main::cs + (byte) main::i#7)
(byte) printu::res#10 ← (byte) main::r#51
call printu
to:main::@58
@ -735,7 +735,7 @@ main::@62: scope:[main] from main::@15
(byte*) print_char_cursor#74 ← phi( main::@15/(byte*) print_char_cursor#45 )
(byte*) print_char_cursor#29 ← (byte*) print_char_cursor#74
(byte) main::r#28 ← (byte) '-'
(bool~) main::$47 ← (byte) main::a#30 >= *((byte[5]) main::cs#0 + (byte) main::i#8)
(bool~) main::$47 ← (byte) main::a#30 >= *((byte[5]) main::cs + (byte) main::i#8)
(bool~) main::$48 ← ! (bool~) main::$47
if((bool~) main::$48) goto main::@16
to:main::@36
@ -756,7 +756,7 @@ main::@16: scope:[main] from main::@36 main::@62
(byte) main::a#31 ← phi( main::@36/(byte) main::a#60 main::@62/(byte) main::a#30 )
(byte) printu::a#14 ← (byte) main::a#31
(byte[]) printu::op#14 ← (const string) main::op14
(byte) printu::b#14 ← *((byte[5]) main::cs#0 + (byte) main::i#9)
(byte) printu::b#14 ← *((byte[5]) main::cs + (byte) main::i#9)
(byte) printu::res#14 ← (byte) main::r#55
call printu
to:main::@63
@ -874,7 +874,7 @@ main::@67: scope:[main] from main::@19
(byte*) print_char_cursor#79 ← phi( main::@19/(byte*) print_char_cursor#45 )
(byte*) print_char_cursor#34 ← (byte*) print_char_cursor#79
(byte) main::r#36 ← (byte) '-'
(bool~) main::$60 ← (byte) main::a#38 == *((byte[5]) main::cs#0 + (byte) main::i#10)
(bool~) main::$60 ← (byte) main::a#38 == *((byte[5]) main::cs + (byte) main::i#10)
(bool~) main::$61 ← ! (bool~) main::$60
if((bool~) main::$61) goto main::@20
to:main::@40
@ -893,7 +893,7 @@ main::@20: scope:[main] from main::@40 main::@67
(byte) main::a#39 ← phi( main::@40/(byte) main::a#65 main::@67/(byte) main::a#38 )
(byte) printu::a#18 ← (byte) main::a#39
(byte[]) printu::op#18 ← (const string) main::op18
(byte) printu::b#18 ← *((byte[5]) main::cs#0 + (byte) main::i#11)
(byte) printu::b#18 ← *((byte[5]) main::cs + (byte) main::i#11)
(byte) printu::res#18 ← (byte) main::r#59
call printu
to:main::@68
@ -1293,7 +1293,6 @@ SYMBOL TABLE SSA
(byte) main::b#8
(byte) main::b#9
(byte[5]) main::cs
(byte[5]) main::cs#0
(byte) main::i
(byte) main::i#0
(byte) main::i#1
@ -1901,7 +1900,7 @@ Adding number conversion cast (unumber) $37 in (byte) printu::b#17 ← (number)
Adding number conversion cast (unumber) $30 in (number~) main::$67 ← (byte) main::a#42 + (number) $30
Adding number conversion cast (unumber) main::$67 in (number~) main::$67 ← (byte) main::a#42 + (unumber)(number) $30
Successful SSA optimization PassNAddNumberTypeConversions
Added casts to value list in (byte[5]) main::cs#0 ← (byte[5]){ (byte)(number) 7, (byte)(number) $c7, (byte)(number) $37, (byte)(number) $97, (byte)(number) $67 }
Added casts to value list in (byte[5]) main::cs ← (byte[5]){ (byte)(number) 7, (byte)(number) $c7, (byte)(number) $37, (byte)(number) $97, (byte)(number) $67 }
Successful SSA optimization PassNAddInitializerValueListTypeCasts
Inlining cast (byte*~) memset::$2 ← (byte*)(void*) memset::str#2
Inlining cast (byte*) memset::dst#0 ← (byte*)(void*) memset::str#2
@ -1966,23 +1965,23 @@ Inferred type updated to byte in (unumber~) main::$67 ← (byte) main::a#42 + (b
Inversing boolean not [2] (bool~) memset::$1 ← (word) memset::num#1 <= (byte) 0 from [1] (bool~) memset::$0 ← (word) memset::num#1 > (byte) 0
Inversing boolean not [95] (bool~) main::$3 ← (byte) main::a#2 >= (byte) main::b#0 from [94] (bool~) main::$2 ← (byte) main::a#2 < (byte) main::b#0
Inversing boolean not [107] (bool~) main::$6 ← (byte) main::a#4 >= (byte) $37 from [106] (bool~) main::$5 ← (byte) main::a#4 < (byte) $37
Inversing boolean not [121] (bool~) main::$9 ← (byte) main::a#6 >= *((byte[5]) main::cs#0 + (byte) main::i#2) from [120] (bool~) main::$8 ← (byte) main::a#6 < *((byte[5]) main::cs#0 + (byte) main::i#2)
Inversing boolean not [121] (bool~) main::$9 ← (byte) main::a#6 >= *((byte[5]) main::cs + (byte) main::i#2) from [120] (bool~) main::$8 ← (byte) main::a#6 < *((byte[5]) main::cs + (byte) main::i#2)
Inversing boolean not [135] (bool~) main::$12 ← (byte) main::a#8 >= (byte) main::a#8 from [134] (bool~) main::$11 ← (byte) main::a#8 < (byte) main::a#8
Inversing boolean not [153] (bool~) main::$16 ← (byte) main::a#10 <= (byte) main::b#2 from [152] (bool~) main::$15 ← (byte) main::a#10 > (byte) main::b#2
Inversing boolean not [167] (bool~) main::$19 ← (byte) main::a#12 <= (byte) $37 from [166] (bool~) main::$18 ← (byte) main::a#12 > (byte) $37
Inversing boolean not [181] (bool~) main::$22 ← (byte) main::a#14 <= *((byte[5]) main::cs#0 + (byte) main::i#4) from [180] (bool~) main::$21 ← (byte) main::a#14 > *((byte[5]) main::cs#0 + (byte) main::i#4)
Inversing boolean not [181] (bool~) main::$22 ← (byte) main::a#14 <= *((byte[5]) main::cs + (byte) main::i#4) from [180] (bool~) main::$21 ← (byte) main::a#14 > *((byte[5]) main::cs + (byte) main::i#4)
Inversing boolean not [195] (bool~) main::$25 ← (byte) main::a#16 <= (byte) main::a#16 from [194] (bool~) main::$24 ← (byte) main::a#16 > (byte) main::a#16
Inversing boolean not [213] (bool~) main::$29 ← (byte) main::a#18 > (byte) main::b#4 from [212] (bool~) main::$28 ← (byte) main::a#18 <= (byte) main::b#4
Inversing boolean not [227] (bool~) main::$32 ← (byte) main::a#20 > (byte) $37 from [226] (bool~) main::$31 ← (byte) main::a#20 <= (byte) $37
Inversing boolean not [241] (bool~) main::$35 ← (byte) main::a#22 > *((byte[5]) main::cs#0 + (byte) main::i#6) from [240] (bool~) main::$34 ← (byte) main::a#22 <= *((byte[5]) main::cs#0 + (byte) main::i#6)
Inversing boolean not [241] (bool~) main::$35 ← (byte) main::a#22 > *((byte[5]) main::cs + (byte) main::i#6) from [240] (bool~) main::$34 ← (byte) main::a#22 <= *((byte[5]) main::cs + (byte) main::i#6)
Inversing boolean not [255] (bool~) main::$38 ← (byte) main::a#24 > (byte) main::a#24 from [254] (bool~) main::$37 ← (byte) main::a#24 <= (byte) main::a#24
Inversing boolean not [273] (bool~) main::$42 ← (byte) main::a#26 < (byte) main::b#6 from [272] (bool~) main::$41 ← (byte) main::a#26 >= (byte) main::b#6
Inversing boolean not [287] (bool~) main::$45 ← (byte) main::a#28 < (byte) $37 from [286] (bool~) main::$44 ← (byte) main::a#28 >= (byte) $37
Inversing boolean not [301] (bool~) main::$48 ← (byte) main::a#30 < *((byte[5]) main::cs#0 + (byte) main::i#8) from [300] (bool~) main::$47 ← (byte) main::a#30 >= *((byte[5]) main::cs#0 + (byte) main::i#8)
Inversing boolean not [301] (bool~) main::$48 ← (byte) main::a#30 < *((byte[5]) main::cs + (byte) main::i#8) from [300] (bool~) main::$47 ← (byte) main::a#30 >= *((byte[5]) main::cs + (byte) main::i#8)
Inversing boolean not [315] (bool~) main::$51 ← (byte) main::a#32 < (byte) main::a#32 from [314] (bool~) main::$50 ← (byte) main::a#32 >= (byte) main::a#32
Inversing boolean not [333] (bool~) main::$55 ← (byte) main::a#34 != (byte) main::b#8 from [332] (bool~) main::$54 ← (byte) main::a#34 == (byte) main::b#8
Inversing boolean not [347] (bool~) main::$58 ← (byte) main::a#36 != (byte) $37 from [346] (bool~) main::$57 ← (byte) main::a#36 == (byte) $37
Inversing boolean not [361] (bool~) main::$61 ← (byte) main::a#38 != *((byte[5]) main::cs#0 + (byte) main::i#10) from [360] (bool~) main::$60 ← (byte) main::a#38 == *((byte[5]) main::cs#0 + (byte) main::i#10)
Inversing boolean not [361] (bool~) main::$61 ← (byte) main::a#38 != *((byte[5]) main::cs + (byte) main::i#10) from [360] (bool~) main::$60 ← (byte) main::a#38 == *((byte[5]) main::cs + (byte) main::i#10)
Inversing boolean not [375] (bool~) main::$64 ← (byte) main::a#40 != (byte) main::a#40 from [374] (bool~) main::$63 ← (byte) main::a#40 == (byte) main::a#40
Successful SSA optimization Pass2UnaryNotSimplification
Alias (void*) memset::return#0 = (void*) memset::str#1 (void*) memset::return#3 (void*) memset::return#1
@ -2228,23 +2227,23 @@ Simple Condition (bool~) print_str::$0 [26] if((byte) 0!=*((byte*) print_str::st
Simple Condition (bool~) print_ln::$1 [39] if((byte*) print_line_cursor#1<(byte*) print_char_cursor#55) goto print_ln::@1
Simple Condition (bool~) main::$3 [96] if((byte) main::a#10>=(byte) main::b#0) goto main::@2
Simple Condition (bool~) main::$6 [108] if((byte) main::a#10>=(byte) $37) goto main::@3
Simple Condition (bool~) main::$9 [122] if((byte) main::a#10>=*((byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@4
Simple Condition (bool~) main::$9 [122] if((byte) main::a#10>=*((byte[5]) main::cs + (byte) main::i#10)) goto main::@4
Simple Condition (bool~) main::$12 [136] if((byte) main::a#10>=(byte) main::a#10) goto main::@5
Simple Condition (bool~) main::$16 [154] if((byte) main::a#10<=(byte) main::b#0) goto main::@6
Simple Condition (bool~) main::$19 [168] if((byte) main::a#10<=(byte) $37) goto main::@7
Simple Condition (bool~) main::$22 [182] if((byte) main::a#10<=*((byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@8
Simple Condition (bool~) main::$22 [182] if((byte) main::a#10<=*((byte[5]) main::cs + (byte) main::i#10)) goto main::@8
Simple Condition (bool~) main::$25 [196] if((byte) main::a#10<=(byte) main::a#10) goto main::@9
Simple Condition (bool~) main::$29 [214] if((byte) main::a#10>(byte) main::b#0) goto main::@10
Simple Condition (bool~) main::$32 [228] if((byte) main::a#10>(byte) $37) goto main::@11
Simple Condition (bool~) main::$35 [242] if((byte) main::a#10>*((byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@12
Simple Condition (bool~) main::$35 [242] if((byte) main::a#10>*((byte[5]) main::cs + (byte) main::i#10)) goto main::@12
Simple Condition (bool~) main::$38 [256] if((byte) main::a#10>(byte) main::a#10) goto main::@13
Simple Condition (bool~) main::$42 [274] if((byte) main::a#10<(byte) main::b#0) goto main::@14
Simple Condition (bool~) main::$45 [288] if((byte) main::a#10<(byte) $37) goto main::@15
Simple Condition (bool~) main::$48 [302] if((byte) main::a#10<*((byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@16
Simple Condition (bool~) main::$48 [302] if((byte) main::a#10<*((byte[5]) main::cs + (byte) main::i#10)) goto main::@16
Simple Condition (bool~) main::$51 [316] if((byte) main::a#10<(byte) main::a#10) goto main::@17
Simple Condition (bool~) main::$55 [334] if((byte) main::a#10!=(byte) main::b#0) goto main::@18
Simple Condition (bool~) main::$58 [348] if((byte) main::a#10!=(byte) $37) goto main::@19
Simple Condition (bool~) main::$61 [362] if((byte) main::a#10!=*((byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@20
Simple Condition (bool~) main::$61 [362] if((byte) main::a#10!=*((byte[5]) main::cs + (byte) main::i#10)) goto main::@20
Simple Condition (bool~) main::$64 [376] if((byte) main::a#10!=(byte) main::a#10) goto main::@21
Simple Condition (bool~) main::$68 [395] if((byte) main::i#1!=rangelast(0,4)) goto main::@1
Successful SSA optimization Pass2ConditionalJumpSimplification
@ -2257,7 +2256,7 @@ Constant (const word) memset::num#0 = $3e8
Constant (const byte) main::a#0 = 7
Constant (const byte) main::i#0 = 0
Constant (const byte) main::r#0 = 0
Constant (const byte[5]) main::cs#0 = { 7, $c7, $37, $97, $67 }
Constant (const byte[5]) main::cs = { 7, $c7, $37, $97, $67 }
Constant (const byte) main::r#1 = '-'
Constant (const byte[]) printu::op#0 = main::op
Constant (const byte) main::r#2 = '-'
@ -2803,7 +2802,7 @@ main::@3: scope:[main] from main::@23 main::@43
[20] call printu
to:main::@44
main::@44: scope:[main] from main::@3
[21] if((byte) main::a#10>=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@4
[21] if((byte) main::a#10>=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@4
to:main::@24
main::@24: scope:[main] from main::@44
[22] phi()
@ -2811,7 +2810,7 @@ main::@24: scope:[main] from main::@44
main::@4: scope:[main] from main::@24 main::@44
[23] (byte) main::r#43 ← phi( main::@24/(byte) '+' main::@44/(byte) '-' )
[24] (byte) printu::a#2 ← (byte) main::a#10
[25] (byte) printu::b#2 ← *((const byte[5]) main::cs#0 + (byte) main::i#10)
[25] (byte) printu::b#2 ← *((const byte[5]) main::cs + (byte) main::i#10)
[26] (byte) printu::res#2 ← (byte) main::r#43
[27] call printu
to:main::@45
@ -2859,7 +2858,7 @@ main::@7: scope:[main] from main::@27 main::@48
[50] call printu
to:main::@49
main::@49: scope:[main] from main::@7
[51] if((byte) main::a#10<=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@8
[51] if((byte) main::a#10<=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@8
to:main::@28
main::@28: scope:[main] from main::@49
[52] phi()
@ -2867,7 +2866,7 @@ main::@28: scope:[main] from main::@49
main::@8: scope:[main] from main::@28 main::@49
[53] (byte) main::r#47 ← phi( main::@28/(byte) '+' main::@49/(byte) '-' )
[54] (byte) printu::a#6 ← (byte) main::a#10
[55] (byte) printu::b#6 ← *((const byte[5]) main::cs#0 + (byte) main::i#10)
[55] (byte) printu::b#6 ← *((const byte[5]) main::cs + (byte) main::i#10)
[56] (byte) printu::res#6 ← (byte) main::r#47
[57] call printu
to:main::@50
@ -2915,7 +2914,7 @@ main::@11: scope:[main] from main::@31 main::@53
[80] call printu
to:main::@54
main::@54: scope:[main] from main::@11
[81] if((byte) main::a#10>*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@12
[81] if((byte) main::a#10>*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@12
to:main::@32
main::@32: scope:[main] from main::@54
[82] phi()
@ -2923,7 +2922,7 @@ main::@32: scope:[main] from main::@54
main::@12: scope:[main] from main::@32 main::@54
[83] (byte) main::r#51 ← phi( main::@32/(byte) '+' main::@54/(byte) '-' )
[84] (byte) printu::a#10 ← (byte) main::a#10
[85] (byte) printu::b#10 ← *((const byte[5]) main::cs#0 + (byte) main::i#10)
[85] (byte) printu::b#10 ← *((const byte[5]) main::cs + (byte) main::i#10)
[86] (byte) printu::res#10 ← (byte) main::r#51
[87] call printu
to:main::@55
@ -2971,7 +2970,7 @@ main::@15: scope:[main] from main::@35 main::@58
[110] call printu
to:main::@59
main::@59: scope:[main] from main::@15
[111] if((byte) main::a#10<*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@16
[111] if((byte) main::a#10<*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@16
to:main::@36
main::@36: scope:[main] from main::@59
[112] phi()
@ -2979,7 +2978,7 @@ main::@36: scope:[main] from main::@59
main::@16: scope:[main] from main::@36 main::@59
[113] (byte) main::r#55 ← phi( main::@36/(byte) '+' main::@59/(byte) '-' )
[114] (byte) printu::a#14 ← (byte) main::a#10
[115] (byte) printu::b#14 ← *((const byte[5]) main::cs#0 + (byte) main::i#10)
[115] (byte) printu::b#14 ← *((const byte[5]) main::cs + (byte) main::i#10)
[116] (byte) printu::res#14 ← (byte) main::r#55
[117] call printu
to:main::@60
@ -3027,7 +3026,7 @@ main::@19: scope:[main] from main::@39 main::@63
[140] call printu
to:main::@64
main::@64: scope:[main] from main::@19
[141] if((byte) main::a#10!=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@20
[141] if((byte) main::a#10!=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@20
to:main::@40
main::@40: scope:[main] from main::@64
[142] phi()
@ -3035,7 +3034,7 @@ main::@40: scope:[main] from main::@64
main::@20: scope:[main] from main::@40 main::@64
[143] (byte) main::r#59 ← phi( main::@40/(byte) '+' main::@64/(byte) '-' )
[144] (byte) printu::a#18 ← (byte) main::a#10
[145] (byte) printu::b#18 ← *((const byte[5]) main::cs#0 + (byte) main::i#10)
[145] (byte) printu::b#18 ← *((const byte[5]) main::cs + (byte) main::i#10)
[146] (byte) printu::res#18 ← (byte) main::r#59
[147] call printu
to:main::@65
@ -3193,7 +3192,6 @@ VARIABLE REGISTER WEIGHTS
(byte) main::a#10 3.860927152317884
(byte) main::b
(byte) main::b#0 0.9758064516129035
(byte[5]) main::cs
(byte) main::i
(byte) main::i#1 11.0
(byte) main::i#10 0.8684210526315792
@ -3615,7 +3613,7 @@ main: {
jmp b44
// main::@44
b44:
// [21] if((byte) main::a#10>=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@4 -- vbuz1_ge_pbuc1_derefidx_vbuz2_then_la1
// [21] if((byte) main::a#10>=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@4 -- vbuz1_ge_pbuc1_derefidx_vbuz2_then_la1
lda.z a
ldy.z i
cmp cs,y
@ -3642,7 +3640,7 @@ main: {
// [24] (byte) printu::a#2 ← (byte) main::a#10 -- vbuz1=vbuz2
lda.z a
sta.z printu.a
// [25] (byte) printu::b#2 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2
// [25] (byte) printu::b#2 ← *((const byte[5]) main::cs + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2
ldy.z i
lda cs,y
sta.z printu.b
@ -3823,7 +3821,7 @@ main: {
jmp b49
// main::@49
b49:
// [51] if((byte) main::a#10<=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@8 -- vbuz1_le_pbuc1_derefidx_vbuz2_then_la1
// [51] if((byte) main::a#10<=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@8 -- vbuz1_le_pbuc1_derefidx_vbuz2_then_la1
ldy.z i
lda cs,y
cmp.z a
@ -3850,7 +3848,7 @@ main: {
// [54] (byte) printu::a#6 ← (byte) main::a#10 -- vbuz1=vbuz2
lda.z a
sta.z printu.a
// [55] (byte) printu::b#6 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2
// [55] (byte) printu::b#6 ← *((const byte[5]) main::cs + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2
ldy.z i
lda cs,y
sta.z printu.b
@ -4031,7 +4029,7 @@ main: {
jmp b54
// main::@54
b54:
// [81] if((byte) main::a#10>*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@12 -- vbuz1_gt_pbuc1_derefidx_vbuz2_then_la1
// [81] if((byte) main::a#10>*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@12 -- vbuz1_gt_pbuc1_derefidx_vbuz2_then_la1
ldy.z i
lda cs,y
cmp.z a
@ -4058,7 +4056,7 @@ main: {
// [84] (byte) printu::a#10 ← (byte) main::a#10 -- vbuz1=vbuz2
lda.z a
sta.z printu.a
// [85] (byte) printu::b#10 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2
// [85] (byte) printu::b#10 ← *((const byte[5]) main::cs + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2
ldy.z i
lda cs,y
sta.z printu.b
@ -4239,7 +4237,7 @@ main: {
jmp b59
// main::@59
b59:
// [111] if((byte) main::a#10<*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@16 -- vbuz1_lt_pbuc1_derefidx_vbuz2_then_la1
// [111] if((byte) main::a#10<*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@16 -- vbuz1_lt_pbuc1_derefidx_vbuz2_then_la1
lda.z a
ldy.z i
cmp cs,y
@ -4266,7 +4264,7 @@ main: {
// [114] (byte) printu::a#14 ← (byte) main::a#10 -- vbuz1=vbuz2
lda.z a
sta.z printu.a
// [115] (byte) printu::b#14 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2
// [115] (byte) printu::b#14 ← *((const byte[5]) main::cs + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2
ldy.z i
lda cs,y
sta.z printu.b
@ -4447,7 +4445,7 @@ main: {
jmp b64
// main::@64
b64:
// [141] if((byte) main::a#10!=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@20 -- vbuz1_neq_pbuc1_derefidx_vbuz2_then_la1
// [141] if((byte) main::a#10!=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@20 -- vbuz1_neq_pbuc1_derefidx_vbuz2_then_la1
lda.z a
ldy.z i
cmp cs,y
@ -4474,7 +4472,7 @@ main: {
// [144] (byte) printu::a#18 ← (byte) main::a#10 -- vbuz1=vbuz2
lda.z a
sta.z printu.a
// [145] (byte) printu::b#18 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2
// [145] (byte) printu::b#18 ← *((const byte[5]) main::cs + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2
ldy.z i
lda cs,y
sta.z printu.b
@ -4888,23 +4886,23 @@ REGISTER UPLIFT POTENTIAL REGISTERS
Statement [7] (byte) main::b#0 ← (byte) $ce - (byte) main::a#10 [ main::a#10 print_char_cursor#120 main::i#10 print_line_cursor#27 main::b#0 ] ( main:2 [ main::a#10 print_char_cursor#120 main::i#10 print_line_cursor#27 main::b#0 ] ) always clobbers reg byte a
Removing always clobbered register reg byte a as potential for zp ZP_BYTE:2 [ main::a#10 main::a#1 ]
Removing always clobbered register reg byte a as potential for zp ZP_BYTE:3 [ main::i#10 main::i#1 ]
Statement [21] if((byte) main::a#10>=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@4 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [21] if((byte) main::a#10>=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@4 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a
Removing always clobbered register reg byte a as potential for zp ZP_BYTE:39 [ main::b#0 ]
Statement [28] if((byte) main::a#10>=(byte) main::a#10) goto main::@5 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [43] (byte*~) print_char_cursor#168 ← (byte*) print_line_cursor#1 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#4 printu::b#4 printu::res#4 print_char_cursor#168 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#4 printu::b#4 printu::res#4 print_char_cursor#168 ] ) always clobbers reg byte a
Removing always clobbered register reg byte a as potential for zp ZP_BYTE:26 [ printu::a#20 printu::a#8 printu::a#9 printu::a#10 printu::a#11 printu::a#12 printu::a#13 printu::a#14 printu::a#15 printu::a#16 printu::a#17 printu::a#0 printu::a#18 printu::a#19 printu::a#1 printu::a#2 printu::a#3 printu::a#4 printu::a#5 printu::a#6 printu::a#7 ]
Removing always clobbered register reg byte a as potential for zp ZP_BYTE:29 [ printu::b#20 printu::b#8 printu::b#10 printu::b#11 printu::b#12 printu::b#14 printu::b#15 printu::b#16 printu::b#0 printu::b#18 printu::b#19 printu::b#2 printu::b#3 printu::b#4 printu::b#6 printu::b#7 ]
Removing always clobbered register reg byte a as potential for zp ZP_BYTE:30 [ printu::res#20 printu::res#8 printu::res#9 printu::res#10 printu::res#11 printu::res#12 printu::res#13 printu::res#14 printu::res#15 printu::res#16 printu::res#17 printu::res#0 printu::res#18 printu::res#19 printu::res#1 printu::res#2 printu::res#3 printu::res#4 printu::res#5 printu::res#6 printu::res#7 ]
Statement [51] if((byte) main::a#10<=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@8 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [51] if((byte) main::a#10<=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@8 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [58] if((byte) main::a#10<=(byte) main::a#10) goto main::@9 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [73] (byte*~) print_char_cursor#152 ← (byte*) print_line_cursor#1 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#8 printu::b#8 printu::res#8 print_char_cursor#152 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#8 printu::b#8 printu::res#8 print_char_cursor#152 ] ) always clobbers reg byte a
Statement [81] if((byte) main::a#10>*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@12 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [81] if((byte) main::a#10>*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@12 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [88] if((byte) main::a#10>(byte) main::a#10) goto main::@13 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [103] (byte*~) print_char_cursor#156 ← (byte*) print_line_cursor#1 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#12 printu::b#12 printu::res#12 print_char_cursor#156 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#12 printu::b#12 printu::res#12 print_char_cursor#156 ] ) always clobbers reg byte a
Statement [111] if((byte) main::a#10<*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@16 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [111] if((byte) main::a#10<*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@16 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [118] if((byte) main::a#10<(byte) main::a#10) goto main::@17 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [133] (byte*~) print_char_cursor#160 ← (byte*) print_line_cursor#1 [ main::a#10 main::i#10 print_line_cursor#1 printu::a#16 printu::b#16 printu::res#16 print_char_cursor#160 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 printu::a#16 printu::b#16 printu::res#16 print_char_cursor#160 ] ) always clobbers reg byte a
Statement [141] if((byte) main::a#10!=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@20 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [141] if((byte) main::a#10!=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@20 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [148] if((byte) main::a#10!=(byte) main::a#10) goto main::@21 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [157] (byte) main::a#1 ← (byte) main::a#10 + (byte) $30 [ main::i#10 main::a#1 print_line_cursor#1 ] ( main:2 [ main::i#10 main::a#1 print_line_cursor#1 ] ) always clobbers reg byte a
Statement [161] (byte*~) print_char_cursor#151 ← (byte*) print_line_cursor#1 [ main::a#1 print_char_cursor#151 main::i#1 print_line_cursor#1 ] ( main:2 [ main::a#1 print_char_cursor#151 main::i#1 print_line_cursor#1 ] ) always clobbers reg byte a
@ -4927,19 +4925,19 @@ Statement [196] *((byte*) print_char_cursor#2) ← *((byte*) print_str::str#2) [
Statement [204] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 [ memset::dst#2 ] ( main:2::print_cls:5::memset:200 [ memset::dst#2 ] ) always clobbers reg byte a
Statement [206] *((byte*) memset::dst#2) ← (const byte) memset::c#0 [ memset::dst#2 ] ( main:2::print_cls:5::memset:200 [ memset::dst#2 ] ) always clobbers reg byte a reg byte y
Statement [7] (byte) main::b#0 ← (byte) $ce - (byte) main::a#10 [ main::a#10 print_char_cursor#120 main::i#10 print_line_cursor#27 main::b#0 ] ( main:2 [ main::a#10 print_char_cursor#120 main::i#10 print_line_cursor#27 main::b#0 ] ) always clobbers reg byte a
Statement [21] if((byte) main::a#10>=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@4 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y
Statement [21] if((byte) main::a#10>=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@4 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y
Statement [28] if((byte) main::a#10>=(byte) main::a#10) goto main::@5 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [43] (byte*~) print_char_cursor#168 ← (byte*) print_line_cursor#1 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#4 printu::b#4 printu::res#4 print_char_cursor#168 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#4 printu::b#4 printu::res#4 print_char_cursor#168 ] ) always clobbers reg byte a
Statement [51] if((byte) main::a#10<=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@8 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [51] if((byte) main::a#10<=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@8 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [58] if((byte) main::a#10<=(byte) main::a#10) goto main::@9 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [73] (byte*~) print_char_cursor#152 ← (byte*) print_line_cursor#1 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#8 printu::b#8 printu::res#8 print_char_cursor#152 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#8 printu::b#8 printu::res#8 print_char_cursor#152 ] ) always clobbers reg byte a
Statement [81] if((byte) main::a#10>*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@12 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [81] if((byte) main::a#10>*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@12 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [88] if((byte) main::a#10>(byte) main::a#10) goto main::@13 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [103] (byte*~) print_char_cursor#156 ← (byte*) print_line_cursor#1 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#12 printu::b#12 printu::res#12 print_char_cursor#156 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#12 printu::b#12 printu::res#12 print_char_cursor#156 ] ) always clobbers reg byte a
Statement [111] if((byte) main::a#10<*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@16 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [111] if((byte) main::a#10<*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@16 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [118] if((byte) main::a#10<(byte) main::a#10) goto main::@17 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [133] (byte*~) print_char_cursor#160 ← (byte*) print_line_cursor#1 [ main::a#10 main::i#10 print_line_cursor#1 printu::a#16 printu::b#16 printu::res#16 print_char_cursor#160 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 printu::a#16 printu::b#16 printu::res#16 print_char_cursor#160 ] ) always clobbers reg byte a
Statement [141] if((byte) main::a#10!=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@20 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [141] if((byte) main::a#10!=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@20 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [148] if((byte) main::a#10!=(byte) main::a#10) goto main::@21 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [157] (byte) main::a#1 ← (byte) main::a#10 + (byte) $30 [ main::i#10 main::a#1 print_line_cursor#1 ] ( main:2 [ main::i#10 main::a#1 print_line_cursor#1 ] ) always clobbers reg byte a reg byte x
Removing always clobbered register reg byte x as potential for zp ZP_BYTE:3 [ main::i#10 main::i#1 ]
@ -4956,28 +4954,28 @@ Statement [196] *((byte*) print_char_cursor#2) ← *((byte*) print_str::str#2) [
Statement [204] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 [ memset::dst#2 ] ( main:2::print_cls:5::memset:200 [ memset::dst#2 ] ) always clobbers reg byte a
Statement [206] *((byte*) memset::dst#2) ← (const byte) memset::c#0 [ memset::dst#2 ] ( main:2::print_cls:5::memset:200 [ memset::dst#2 ] ) always clobbers reg byte a reg byte y
Statement [7] (byte) main::b#0 ← (byte) $ce - (byte) main::a#10 [ main::a#10 print_char_cursor#120 main::i#10 print_line_cursor#27 main::b#0 ] ( main:2 [ main::a#10 print_char_cursor#120 main::i#10 print_line_cursor#27 main::b#0 ] ) always clobbers reg byte a
Statement [21] if((byte) main::a#10>=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@4 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y
Statement [25] (byte) printu::b#2 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 main::r#43 printu::a#2 printu::b#2 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 main::r#43 printu::a#2 printu::b#2 print_char_cursor#55 ] ) always clobbers reg byte y
Statement [21] if((byte) main::a#10>=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@4 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y
Statement [25] (byte) printu::b#2 ← *((const byte[5]) main::cs + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 main::r#43 printu::a#2 printu::b#2 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 main::r#43 printu::a#2 printu::b#2 print_char_cursor#55 ] ) always clobbers reg byte y
Removing always clobbered register reg byte y as potential for zp ZP_BYTE:6 [ main::r#43 ]
Statement [28] if((byte) main::a#10>=(byte) main::a#10) goto main::@5 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [43] (byte*~) print_char_cursor#168 ← (byte*) print_line_cursor#1 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#4 printu::b#4 printu::res#4 print_char_cursor#168 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#4 printu::b#4 printu::res#4 print_char_cursor#168 ] ) always clobbers reg byte a
Statement [51] if((byte) main::a#10<=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@8 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y
Statement [55] (byte) printu::b#6 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#47 printu::a#6 printu::b#6 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#47 printu::a#6 printu::b#6 print_char_cursor#55 ] ) always clobbers reg byte y
Statement [51] if((byte) main::a#10<=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@8 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y
Statement [55] (byte) printu::b#6 ← *((const byte[5]) main::cs + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#47 printu::a#6 printu::b#6 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#47 printu::a#6 printu::b#6 print_char_cursor#55 ] ) always clobbers reg byte y
Removing always clobbered register reg byte y as potential for zp ZP_BYTE:10 [ main::r#47 ]
Statement [58] if((byte) main::a#10<=(byte) main::a#10) goto main::@9 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [73] (byte*~) print_char_cursor#152 ← (byte*) print_line_cursor#1 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#8 printu::b#8 printu::res#8 print_char_cursor#152 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#8 printu::b#8 printu::res#8 print_char_cursor#152 ] ) always clobbers reg byte a
Statement [81] if((byte) main::a#10>*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@12 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y
Statement [85] (byte) printu::b#10 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#51 printu::a#10 printu::b#10 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#51 printu::a#10 printu::b#10 print_char_cursor#55 ] ) always clobbers reg byte y
Statement [81] if((byte) main::a#10>*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@12 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y
Statement [85] (byte) printu::b#10 ← *((const byte[5]) main::cs + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#51 printu::a#10 printu::b#10 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#51 printu::a#10 printu::b#10 print_char_cursor#55 ] ) always clobbers reg byte y
Removing always clobbered register reg byte y as potential for zp ZP_BYTE:14 [ main::r#51 ]
Statement [88] if((byte) main::a#10>(byte) main::a#10) goto main::@13 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [103] (byte*~) print_char_cursor#156 ← (byte*) print_line_cursor#1 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#12 printu::b#12 printu::res#12 print_char_cursor#156 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#12 printu::b#12 printu::res#12 print_char_cursor#156 ] ) always clobbers reg byte a
Statement [111] if((byte) main::a#10<*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@16 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y
Statement [115] (byte) printu::b#14 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#55 printu::a#14 printu::b#14 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#55 printu::a#14 printu::b#14 print_char_cursor#55 ] ) always clobbers reg byte y
Statement [111] if((byte) main::a#10<*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@16 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y
Statement [115] (byte) printu::b#14 ← *((const byte[5]) main::cs + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#55 printu::a#14 printu::b#14 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#55 printu::a#14 printu::b#14 print_char_cursor#55 ] ) always clobbers reg byte y
Removing always clobbered register reg byte y as potential for zp ZP_BYTE:18 [ main::r#55 ]
Statement [118] if((byte) main::a#10<(byte) main::a#10) goto main::@17 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [133] (byte*~) print_char_cursor#160 ← (byte*) print_line_cursor#1 [ main::a#10 main::i#10 print_line_cursor#1 printu::a#16 printu::b#16 printu::res#16 print_char_cursor#160 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 printu::a#16 printu::b#16 printu::res#16 print_char_cursor#160 ] ) always clobbers reg byte a
Statement [141] if((byte) main::a#10!=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@20 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y
Statement [145] (byte) printu::b#18 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#1 main::r#59 printu::a#18 printu::b#18 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::r#59 printu::a#18 printu::b#18 print_char_cursor#55 ] ) always clobbers reg byte y
Statement [141] if((byte) main::a#10!=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@20 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y
Statement [145] (byte) printu::b#18 ← *((const byte[5]) main::cs + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#1 main::r#59 printu::a#18 printu::b#18 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::r#59 printu::a#18 printu::b#18 print_char_cursor#55 ] ) always clobbers reg byte y
Removing always clobbered register reg byte y as potential for zp ZP_BYTE:22 [ main::r#59 ]
Statement [148] if((byte) main::a#10!=(byte) main::a#10) goto main::@21 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [157] (byte) main::a#1 ← (byte) main::a#10 + (byte) $30 [ main::i#10 main::a#1 print_line_cursor#1 ] ( main:2 [ main::i#10 main::a#1 print_line_cursor#1 ] ) always clobbers reg byte a reg byte x
@ -4994,24 +4992,24 @@ Statement [196] *((byte*) print_char_cursor#2) ← *((byte*) print_str::str#2) [
Statement [204] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 [ memset::dst#2 ] ( main:2::print_cls:5::memset:200 [ memset::dst#2 ] ) always clobbers reg byte a
Statement [206] *((byte*) memset::dst#2) ← (const byte) memset::c#0 [ memset::dst#2 ] ( main:2::print_cls:5::memset:200 [ memset::dst#2 ] ) always clobbers reg byte a reg byte y
Statement [7] (byte) main::b#0 ← (byte) $ce - (byte) main::a#10 [ main::a#10 print_char_cursor#120 main::i#10 print_line_cursor#27 main::b#0 ] ( main:2 [ main::a#10 print_char_cursor#120 main::i#10 print_line_cursor#27 main::b#0 ] ) always clobbers reg byte a
Statement [21] if((byte) main::a#10>=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@4 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y
Statement [25] (byte) printu::b#2 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 main::r#43 printu::a#2 printu::b#2 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 main::r#43 printu::a#2 printu::b#2 print_char_cursor#55 ] ) always clobbers reg byte y
Statement [21] if((byte) main::a#10>=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@4 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y
Statement [25] (byte) printu::b#2 ← *((const byte[5]) main::cs + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 main::r#43 printu::a#2 printu::b#2 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 main::r#43 printu::a#2 printu::b#2 print_char_cursor#55 ] ) always clobbers reg byte y
Statement [28] if((byte) main::a#10>=(byte) main::a#10) goto main::@5 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#27 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [43] (byte*~) print_char_cursor#168 ← (byte*) print_line_cursor#1 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#4 printu::b#4 printu::res#4 print_char_cursor#168 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#4 printu::b#4 printu::res#4 print_char_cursor#168 ] ) always clobbers reg byte a
Statement [51] if((byte) main::a#10<=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@8 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y
Statement [55] (byte) printu::b#6 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#47 printu::a#6 printu::b#6 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#47 printu::a#6 printu::b#6 print_char_cursor#55 ] ) always clobbers reg byte y
Statement [51] if((byte) main::a#10<=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@8 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y
Statement [55] (byte) printu::b#6 ← *((const byte[5]) main::cs + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#47 printu::a#6 printu::b#6 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#47 printu::a#6 printu::b#6 print_char_cursor#55 ] ) always clobbers reg byte y
Statement [58] if((byte) main::a#10<=(byte) main::a#10) goto main::@9 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [73] (byte*~) print_char_cursor#152 ← (byte*) print_line_cursor#1 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#8 printu::b#8 printu::res#8 print_char_cursor#152 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#8 printu::b#8 printu::res#8 print_char_cursor#152 ] ) always clobbers reg byte a
Statement [81] if((byte) main::a#10>*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@12 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y
Statement [85] (byte) printu::b#10 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#51 printu::a#10 printu::b#10 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#51 printu::a#10 printu::b#10 print_char_cursor#55 ] ) always clobbers reg byte y
Statement [81] if((byte) main::a#10>*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@12 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y
Statement [85] (byte) printu::b#10 ← *((const byte[5]) main::cs + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#51 printu::a#10 printu::b#10 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#51 printu::a#10 printu::b#10 print_char_cursor#55 ] ) always clobbers reg byte y
Statement [88] if((byte) main::a#10>(byte) main::a#10) goto main::@13 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [103] (byte*~) print_char_cursor#156 ← (byte*) print_line_cursor#1 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#12 printu::b#12 printu::res#12 print_char_cursor#156 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 printu::a#12 printu::b#12 printu::res#12 print_char_cursor#156 ] ) always clobbers reg byte a
Statement [111] if((byte) main::a#10<*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@16 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y
Statement [115] (byte) printu::b#14 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#55 printu::a#14 printu::b#14 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#55 printu::a#14 printu::b#14 print_char_cursor#55 ] ) always clobbers reg byte y
Statement [111] if((byte) main::a#10<*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@16 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y
Statement [115] (byte) printu::b#14 ← *((const byte[5]) main::cs + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#55 printu::a#14 printu::b#14 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 main::r#55 printu::a#14 printu::b#14 print_char_cursor#55 ] ) always clobbers reg byte y
Statement [118] if((byte) main::a#10<(byte) main::a#10) goto main::@17 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::b#0 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [133] (byte*~) print_char_cursor#160 ← (byte*) print_line_cursor#1 [ main::a#10 main::i#10 print_line_cursor#1 printu::a#16 printu::b#16 printu::res#16 print_char_cursor#160 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 printu::a#16 printu::b#16 printu::res#16 print_char_cursor#160 ] ) always clobbers reg byte a
Statement [141] if((byte) main::a#10!=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@20 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y
Statement [145] (byte) printu::b#18 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#1 main::r#59 printu::a#18 printu::b#18 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::r#59 printu::a#18 printu::b#18 print_char_cursor#55 ] ) always clobbers reg byte y
Statement [141] if((byte) main::a#10!=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@20 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ) always clobbers reg byte a reg byte y
Statement [145] (byte) printu::b#18 ← *((const byte[5]) main::cs + (byte) main::i#10) [ main::a#10 main::i#10 print_line_cursor#1 main::r#59 printu::a#18 printu::b#18 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 main::r#59 printu::a#18 printu::b#18 print_char_cursor#55 ] ) always clobbers reg byte y
Statement [148] if((byte) main::a#10!=(byte) main::a#10) goto main::@21 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ( main:2 [ main::a#10 main::i#10 print_line_cursor#1 print_char_cursor#55 ] ) always clobbers reg byte a
Statement [157] (byte) main::a#1 ← (byte) main::a#10 + (byte) $30 [ main::i#10 main::a#1 print_line_cursor#1 ] ( main:2 [ main::i#10 main::a#1 print_line_cursor#1 ] ) always clobbers reg byte a reg byte x
Statement [159] if((byte) main::i#1!=(byte) 5) goto main::@68 [ main::a#1 main::i#1 print_line_cursor#1 ] ( main:2 [ main::a#1 main::i#1 print_line_cursor#1 ] ) always clobbers reg byte a
@ -5291,7 +5289,7 @@ main: {
jmp b44
// main::@44
b44:
// [21] if((byte) main::a#10>=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@4 -- vbuz1_ge_pbuc1_derefidx_vbuz2_then_la1
// [21] if((byte) main::a#10>=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@4 -- vbuz1_ge_pbuc1_derefidx_vbuz2_then_la1
lda.z a
ldy.z i
cmp cs,y
@ -5314,7 +5312,7 @@ main: {
// main::@4
b4:
// [24] (byte) printu::a#2 ← (byte) main::a#10
// [25] (byte) printu::b#2 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2
// [25] (byte) printu::b#2 ← *((const byte[5]) main::cs + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2
ldy.z i
lda cs,y
sta.z printu.b
@ -5475,7 +5473,7 @@ main: {
jmp b49
// main::@49
b49:
// [51] if((byte) main::a#10<=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@8 -- vbuz1_le_pbuc1_derefidx_vbuz2_then_la1
// [51] if((byte) main::a#10<=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@8 -- vbuz1_le_pbuc1_derefidx_vbuz2_then_la1
ldy.z i
lda cs,y
cmp.z a
@ -5498,7 +5496,7 @@ main: {
// main::@8
b8:
// [54] (byte) printu::a#6 ← (byte) main::a#10
// [55] (byte) printu::b#6 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2
// [55] (byte) printu::b#6 ← *((const byte[5]) main::cs + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2
ldy.z i
lda cs,y
sta.z printu.b
@ -5659,7 +5657,7 @@ main: {
jmp b54
// main::@54
b54:
// [81] if((byte) main::a#10>*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@12 -- vbuz1_gt_pbuc1_derefidx_vbuz2_then_la1
// [81] if((byte) main::a#10>*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@12 -- vbuz1_gt_pbuc1_derefidx_vbuz2_then_la1
ldy.z i
lda cs,y
cmp.z a
@ -5682,7 +5680,7 @@ main: {
// main::@12
b12:
// [84] (byte) printu::a#10 ← (byte) main::a#10
// [85] (byte) printu::b#10 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2
// [85] (byte) printu::b#10 ← *((const byte[5]) main::cs + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2
ldy.z i
lda cs,y
sta.z printu.b
@ -5843,7 +5841,7 @@ main: {
jmp b59
// main::@59
b59:
// [111] if((byte) main::a#10<*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@16 -- vbuz1_lt_pbuc1_derefidx_vbuz2_then_la1
// [111] if((byte) main::a#10<*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@16 -- vbuz1_lt_pbuc1_derefidx_vbuz2_then_la1
lda.z a
ldy.z i
cmp cs,y
@ -5866,7 +5864,7 @@ main: {
// main::@16
b16:
// [114] (byte) printu::a#14 ← (byte) main::a#10
// [115] (byte) printu::b#14 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2
// [115] (byte) printu::b#14 ← *((const byte[5]) main::cs + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2
ldy.z i
lda cs,y
sta.z printu.b
@ -6027,7 +6025,7 @@ main: {
jmp b64
// main::@64
b64:
// [141] if((byte) main::a#10!=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@20 -- vbuz1_neq_pbuc1_derefidx_vbuz2_then_la1
// [141] if((byte) main::a#10!=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@20 -- vbuz1_neq_pbuc1_derefidx_vbuz2_then_la1
lda.z a
ldy.z i
cmp cs,y
@ -6050,7 +6048,7 @@ main: {
// main::@20
b20:
// [144] (byte) printu::a#18 ← (byte) main::a#10
// [145] (byte) printu::b#18 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2
// [145] (byte) printu::b#18 ← *((const byte[5]) main::cs + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2
ldy.z i
lda cs,y
sta.z printu.b
@ -6794,8 +6792,7 @@ FINAL SYMBOL TABLE
(byte) main::a#10 a zp ZP_BYTE:2 3.860927152317884
(byte) main::b
(byte) main::b#0 b zp ZP_BYTE:12 0.9758064516129035
(byte[5]) main::cs
(const byte[5]) main::cs#0 cs = { (byte) 7, (byte) $c7, (byte) $37, (byte) $97, (byte) $67 }
(const byte[5]) main::cs cs = { (byte) 7, (byte) $c7, (byte) $37, (byte) $97, (byte) $67 }
(byte) main::i
(byte) main::i#1 i zp ZP_BYTE:3 11.0
(byte) main::i#10 i zp ZP_BYTE:3 0.8684210526315792
@ -7119,7 +7116,7 @@ main: {
jsr printu
// main::@44
// if(a<cs[i])
// [21] if((byte) main::a#10>=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@4 -- vbuz1_ge_pbuc1_derefidx_vbuz2_then_la1
// [21] if((byte) main::a#10>=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@4 -- vbuz1_ge_pbuc1_derefidx_vbuz2_then_la1
lda.z a
ldy.z i
cmp cs,y
@ -7138,7 +7135,7 @@ main: {
b4:
// printu(a, "< ", cs[i], r)
// [24] (byte) printu::a#2 ← (byte) main::a#10
// [25] (byte) printu::b#2 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2
// [25] (byte) printu::b#2 ← *((const byte[5]) main::cs + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2
ldy.z i
lda cs,y
sta.z printu.b
@ -7277,7 +7274,7 @@ main: {
jsr printu
// main::@49
// if(a>cs[i])
// [51] if((byte) main::a#10<=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@8 -- vbuz1_le_pbuc1_derefidx_vbuz2_then_la1
// [51] if((byte) main::a#10<=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@8 -- vbuz1_le_pbuc1_derefidx_vbuz2_then_la1
ldy.z i
lda cs,y
cmp.z a
@ -7296,7 +7293,7 @@ main: {
b8:
// printu(a, "> ", cs[i], r)
// [54] (byte) printu::a#6 ← (byte) main::a#10
// [55] (byte) printu::b#6 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2
// [55] (byte) printu::b#6 ← *((const byte[5]) main::cs + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2
ldy.z i
lda cs,y
sta.z printu.b
@ -7435,7 +7432,7 @@ main: {
jsr printu
// main::@54
// if(a<=cs[i])
// [81] if((byte) main::a#10>*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@12 -- vbuz1_gt_pbuc1_derefidx_vbuz2_then_la1
// [81] if((byte) main::a#10>*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@12 -- vbuz1_gt_pbuc1_derefidx_vbuz2_then_la1
ldy.z i
lda cs,y
cmp.z a
@ -7454,7 +7451,7 @@ main: {
b12:
// printu(a, "<=", cs[i], r)
// [84] (byte) printu::a#10 ← (byte) main::a#10
// [85] (byte) printu::b#10 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2
// [85] (byte) printu::b#10 ← *((const byte[5]) main::cs + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2
ldy.z i
lda cs,y
sta.z printu.b
@ -7593,7 +7590,7 @@ main: {
jsr printu
// main::@59
// if(a>=cs[i])
// [111] if((byte) main::a#10<*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@16 -- vbuz1_lt_pbuc1_derefidx_vbuz2_then_la1
// [111] if((byte) main::a#10<*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@16 -- vbuz1_lt_pbuc1_derefidx_vbuz2_then_la1
lda.z a
ldy.z i
cmp cs,y
@ -7612,7 +7609,7 @@ main: {
b16:
// printu(a, ">=", cs[i], r)
// [114] (byte) printu::a#14 ← (byte) main::a#10
// [115] (byte) printu::b#14 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2
// [115] (byte) printu::b#14 ← *((const byte[5]) main::cs + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2
ldy.z i
lda cs,y
sta.z printu.b
@ -7751,7 +7748,7 @@ main: {
jsr printu
// main::@64
// if(a==cs[i])
// [141] if((byte) main::a#10!=*((const byte[5]) main::cs#0 + (byte) main::i#10)) goto main::@20 -- vbuz1_neq_pbuc1_derefidx_vbuz2_then_la1
// [141] if((byte) main::a#10!=*((const byte[5]) main::cs + (byte) main::i#10)) goto main::@20 -- vbuz1_neq_pbuc1_derefidx_vbuz2_then_la1
lda.z a
ldy.z i
cmp cs,y
@ -7770,7 +7767,7 @@ main: {
b20:
// printu(a, "==", cs[i], r)
// [144] (byte) printu::a#18 ← (byte) main::a#10
// [145] (byte) printu::b#18 ← *((const byte[5]) main::cs#0 + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2
// [145] (byte) printu::b#18 ← *((const byte[5]) main::cs + (byte) main::i#10) -- vbuz1=pbuc1_derefidx_vbuz2
ldy.z i
lda cs,y
sta.z printu.b

3
src/test/ref/test-comparisons.sym
View File

@ -79,8 +79,7 @@
(byte) main::a#10 a zp ZP_BYTE:2 3.860927152317884
(byte) main::b
(byte) main::b#0 b zp ZP_BYTE:12 0.9758064516129035
(byte[5]) main::cs
(const byte[5]) main::cs#0 cs = { (byte) 7, (byte) $c7, (byte) $37, (byte) $97, (byte) $67 }
(const byte[5]) main::cs cs = { (byte) 7, (byte) $c7, (byte) $37, (byte) $97, (byte) $67 }
(byte) main::i
(byte) main::i#1 i zp ZP_BYTE:3 11.0
(byte) main::i#10 i zp ZP_BYTE:3 0.8684210526315792