Merged simpler live range calculation to master. Improved scope weight calculation to combine call graph depth and loop depth. Added missing fragments.

src/main/fragment/mos6502-common/vbuxx=_hi_vwum1.asm

@@ -0,0 +1 @@
+ldx {m1}+1

src/main/fragment/mos6502-common/vbuxx=_lo_vwum1.asm

@@ -0,0 +1 @@
+ldx {m1}

src/main/fragment/mos6502-common/vbuyy=_hi_vwum1.asm

@@ -0,0 +1 @@
+ldy {m1}+1

src/main/fragment/mos6502-common/vbuyy=_lo_vwum1.asm

@@ -0,0 +1 @@
+ldy {m1}

src/main/java/dk/camelot64/kickc/CompileLog.java

@@ -170,6 +170,11 @@ public class CompileLog {
       this.verboseNonOptimization = verboseNonOptimization;
    }
 
+   public CompileLog verboseNonOptimization() {
+      setVerboseNonOptimization(true);
+      return this;
+   }
+
    public void setVerboseSequencePlan(boolean verboseSequencePlan) {
       this.verboseSequencePlan = verboseSequencePlan;
    }

src/main/java/dk/camelot64/kickc/model/CallGraph.java

@@ -221,6 +221,20 @@ public class CallGraph {
       }
    }
 
+   public int getCallDepth(ProcedureRef procedureRef) {
+      final Collection<CallBlock.Call> callers = getCallers(procedureRef);
+      int maxCallDepth = 1;
+      for(CallBlock.Call caller : callers) {
+         final ScopeRef callStatementScope = caller.getCallStatementScope();
+         if(callStatementScope instanceof ProcedureRef) {
+             int callerDepth = getCallDepth((ProcedureRef) callStatementScope)+1;
+             if(callerDepth>maxCallDepth)
+                maxCallDepth = callerDepth;
+         }
+      }
+      return maxCallDepth;
+   }
+
 
    /**
     * A block in the call graph, matching a scope in the program.

src/main/java/dk/camelot64/kickc/model/LiveRangeVariablesEffective.java

@@ -33,6 +33,8 @@ public interface LiveRangeVariablesEffective {
       Collection<VariableRef> getEffectiveAliveAtStmt();
 
       Pass2AliasElimination.Aliases getEffectiveAliasesAtStmt();
+
+      String toString(Program program);
    }
 
 }

src/main/java/dk/camelot64/kickc/model/LiveRangeVariablesEffectiveCallPaths.java

@@ -417,10 +417,12 @@ public class LiveRangeVariablesEffectiveCallPaths implements LiveRangeVariablesE
       }
 
       @Override
-      public String toString() {
+      public String toString(Program program) {
          StringBuilder out = new StringBuilder();
          out.append(getCallPathString(callPath.getPath()));
          out.append(getAliveString(getEffectiveAliveAtStmt()));
+         out.append(" ");
+         out.append(getEffectiveAliasesAtStmt().toString(program));
          return out.toString();
       }
 

src/main/java/dk/camelot64/kickc/model/LiveRangeVariablesEffectiveSimple.java

@@ -6,6 +6,7 @@ import dk.camelot64.kickc.passes.Pass2AliasElimination;
 
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.LinkedHashMap;
 import java.util.Map;
 
 /**
@@ -15,9 +16,12 @@ public class LiveRangeVariablesEffectiveSimple implements LiveRangeVariablesEffe
 
    /** All variables potentially effective alive by statement index. */
    private Map<Integer, Collection<VariableRef>> statementAliveEffective;
+   /** Block aliases for each statement. */
+   private Map<Integer, Pass2AliasElimination.Aliases> statementLocalAliases;
 
-   public LiveRangeVariablesEffectiveSimple(Map<Integer, Collection<VariableRef>> statementAliveEffective) {
+   public LiveRangeVariablesEffectiveSimple(LinkedHashMap<Integer, Collection<VariableRef>> statementAliveEffective, Map<Integer, Pass2AliasElimination.Aliases> statementLocalAliases) {
       this.statementAliveEffective = statementAliveEffective;
+      this.statementLocalAliases = statementLocalAliases;
    }
 
    /**
@@ -33,33 +37,49 @@ public class LiveRangeVariablesEffectiveSimple implements LiveRangeVariablesEffe
       return statementAliveEffective.get(statement.getIndex());
    }
 
+   /**
+    * Get local aliases at a statement.
+    *
+    * @param statement The statement to examine
+    * @return All local aliases
+    */
    @Override
    public AliveCombinations getAliveCombinations(Statement statement) {
-      return new AliveCombinationsSimple(getAliveEffective(statement));
+      return new AliveCombinationsSimple(getAliveEffective(statement), getLocalAliases(statement));
    }
 
-   public class AliveCombinationsSimple implements AliveCombinations {
+   private Pass2AliasElimination.Aliases getLocalAliases(Statement statement) {
+      return statementLocalAliases.get(statement.getIndex());
+   }
+
+   public static class AliveCombinationsSimple implements AliveCombinations {
 
       private Collection<VariableRef> alive;
 
-      public AliveCombinationsSimple(Collection<VariableRef> alive) {
+      private Pass2AliasElimination.Aliases localAliases;
+
+      AliveCombinationsSimple(Collection<VariableRef> alive, Pass2AliasElimination.Aliases localAliases) {
          this.alive = alive;
+         this.localAliases = localAliases;
       }
 
       @Override
       public Collection<AliveCombination> getAll() {
          final ArrayList<AliveCombination> aliveCombinations = new ArrayList<>();
-         aliveCombinations.add(new AliveCombinationSimple(alive));
+         aliveCombinations.add(new AliveCombinationSimple(alive, localAliases));
          return aliveCombinations;
       }
    }
 
-   public class AliveCombinationSimple implements AliveCombination {
+   public static class AliveCombinationSimple implements AliveCombination {
 
       private Collection<VariableRef> alive;
 
-      public AliveCombinationSimple(Collection<VariableRef> alive) {
+      private Pass2AliasElimination.Aliases localAliases;
+
+      AliveCombinationSimple(Collection<VariableRef> alive, Pass2AliasElimination.Aliases localAliases) {
          this.alive = alive;
+         this.localAliases = localAliases;
       }
 
       @Override
@@ -69,12 +89,19 @@ public class LiveRangeVariablesEffectiveSimple implements LiveRangeVariablesEffe
 
       @Override
       public Pass2AliasElimination.Aliases getEffectiveAliasesAtStmt() {
-         return null;
+         return localAliases;
       }
 
-      @Override
-      public String toString() {
-         return getAliveString(alive);
+      public String toString(Program program) {
+         final Pass2AliasElimination.Aliases aliases = getEffectiveAliasesAtStmt();
+         return getAliveString(alive) + " " + getAliasString(aliases, program);
+      }
+
+      private String getAliasString(Pass2AliasElimination.Aliases aliases, Program program) {
+         if(aliases == null)
+            return "";
+         else
+            return aliases.toString(program);
       }
 
       private String getAliveString(Collection<VariableRef> alive) {

src/main/java/dk/camelot64/kickc/model/statements/StatementBase.java

@@ -89,7 +89,7 @@ public abstract class StatementBase implements Statement {
          LiveRangeVariablesEffective.AliveCombinations aliveCombinations = liveRangeVariablesEffective.getAliveCombinations(this);
          alive.append(" ( ");
          for(LiveRangeVariablesEffective.AliveCombination aliveCombination : aliveCombinations.getAll()) {
-            alive.append(aliveCombination.toString());
+            alive.append(aliveCombination.toString(program));
             alive.append(" ");
          }
          alive.append(")");

src/main/java/dk/camelot64/kickc/passes/Pass2AliasElimination.java

@@ -38,7 +38,7 @@ public class Pass2AliasElimination extends Pass2SsaOptimization {
    }
 
 
-   public static Aliases findAliases(Program program) {
+   private static Aliases findAliases(Program program) {
       Aliases candidates = findAliasesCandidates(program);
       cleanupCandidates(candidates, program);
       cleanupCandidateVolatiles(candidates, program);
@@ -342,7 +342,7 @@ public class Pass2AliasElimination extends Pass2SsaOptimization {
          }
       }
 
-      public List<VariableRef> getSymbolsToRemove(ProgramScope scope) {
+      List<VariableRef> getSymbolsToRemove(ProgramScope scope) {
          ArrayList<VariableRef> eliminates = new ArrayList<>();
          for(AliasSet alias : aliases) {
             eliminates.addAll(alias.getEliminateVars(scope));
@@ -350,7 +350,7 @@ public class Pass2AliasElimination extends Pass2SsaOptimization {
          return eliminates;
       }
 
-      public Map<VariableRef, VariableRef> getReplacements(ProgramScope scope) {
+      Map<VariableRef, VariableRef> getReplacements(ProgramScope scope) {
          HashMap<VariableRef, VariableRef> replacements = new LinkedHashMap<>();
          for(AliasSet aliasSet : aliases) {
             VariableRef keepVar = aliasSet.getKeepVar(scope);
@@ -391,7 +391,7 @@ public class Pass2AliasElimination extends Pass2SsaOptimization {
          }
       }
 
-      public AliasSet findAliasSet(LValue lValue) {
+      AliasSet findAliasSet(LValue lValue) {
          if(lValue instanceof VariableRef) {
             for(AliasSet alias : aliases) {
                if(alias.contains(lValue)) {
@@ -402,7 +402,7 @@ public class Pass2AliasElimination extends Pass2SsaOptimization {
          return null;
       }
 
-      public List<AliasSet> getAliasSets() {
+      List<AliasSet> getAliasSets() {
          return aliases;
       }
 
@@ -419,17 +419,29 @@ public class Pass2AliasElimination extends Pass2SsaOptimization {
             }
          }
       }
+
+      public String toString(Program program) {
+         StringBuilder str = new StringBuilder();
+         str.append("{ ");
+         for(AliasSet aliasSet : getAliasSets()) {
+            str.append("{ ");
+            str.append(aliasSet.toString(program));
+            str.append("} ");
+         }
+         str.append("} ");
+         return str.toString();
+      }
    }
 
    public static class AliasSet {
 
       private List<VariableRef> vars;
 
-      public AliasSet() {
+      AliasSet() {
          this.vars = new ArrayList<>();
       }
 
-      public AliasSet(AliasSet aliasSet) {
+      AliasSet(AliasSet aliasSet) {
          this.vars = new ArrayList<>(aliasSet.getVars());
       }
 
@@ -447,10 +459,10 @@ public class Pass2AliasElimination extends Pass2SsaOptimization {
 
       public String toString(Program program) {
          StringBuilder str = new StringBuilder();
-         str.append(getKeepVar(program.getScope()).toString(program));
+         str.append(getKeepVar(program.getScope()).toString(null));
          str.append(" = ");
          for(VariableRef var : getEliminateVars(program.getScope())) {
-            str.append(var.toString(program)).append(" ");
+            str.append(var.toString(null)).append(" ");
          }
          return str.toString();
       }
@@ -463,7 +475,7 @@ public class Pass2AliasElimination extends Pass2SsaOptimization {
          vars.addAll(aliasSet.getVars());
       }
 
-      public VariableRef getKeepVar(ProgramScope scope) {
+      VariableRef getKeepVar(ProgramScope scope) {
          // Score all base names (without versions for versioned vars, full name for intermediates)
          int maxScore = 0;
          String maxName = null;
@@ -496,7 +508,7 @@ public class Pass2AliasElimination extends Pass2SsaOptimization {
          }
          // Find first var with highest scoring name
          List<VariableRef> vars = new ArrayList<>(this.vars);
-         Collections.sort(vars, Comparator.comparing(SymbolRef::getFullName));
+         vars.sort(Comparator.comparing(SymbolRef::getFullName));
          for(VariableRef var : vars) {
             if(var.isVersion()) {
                if(maxName.equals(var.getFullNameUnversioned())) {
@@ -513,7 +525,7 @@ public class Pass2AliasElimination extends Pass2SsaOptimization {
 
       }
 
-      public List<VariableRef> getEliminateVars(ProgramScope scope) {
+      List<VariableRef> getEliminateVars(ProgramScope scope) {
          List<VariableRef> eliminate = new ArrayList<>();
          VariableRef keepVar = getKeepVar(scope);
          for(VariableRef var : vars) {

src/main/java/dk/camelot64/kickc/passes/Pass2NopCastInlining.java

@@ -50,22 +50,8 @@ public class Pass2NopCastInlining extends Pass2SsaOptimization {
                if(assignment.getOperator() == null && assignment.getrValue2() instanceof CastValue) {
                   CastValue castValue = (CastValue) assignment.getrValue2();
                   SymbolType subValType = SymbolTypeInference.inferType(getScope(), castValue.getValue());
-                  boolean isNopCast = false;
-                  if(SymbolType.BYTE.equals(castValue.getToType()) && SymbolType.SBYTE.equals(subValType)) {
-                     isNopCast = true;
-                  } else if(SymbolType.SBYTE.equals(castValue.getToType()) && SymbolType.BYTE.equals(subValType)) {
-                     isNopCast = true;
-                  } else if(SymbolType.WORD.equals(castValue.getToType()) && SymbolType.SWORD.equals(subValType)) {
-                     isNopCast = true;
-                  } else if(SymbolType.SWORD.equals(castValue.getToType()) && SymbolType.WORD.equals(subValType)) {
-                     isNopCast = true;
-                  } else if(castValue.getToType() instanceof SymbolTypePointer && SymbolType.WORD.equals(subValType)) {
-                     isNopCast = true;
-                  } else if(SymbolType.WORD.equals(castValue.getToType()) && subValType instanceof SymbolTypePointer) {
-                     isNopCast = true;
-                  } else if(castValue.getToType() instanceof SymbolTypePointer && subValType instanceof SymbolTypePointer) {
-                     isNopCast = true;
-                  }
+                  final SymbolType castToType = castValue.getToType();
+                  boolean isNopCast = isNopCast(castToType, subValType);
                   if(isNopCast && assignment.getlValue() instanceof VariableRef) {
 
                      final Variable assignmentVar = getScope().getVariable((VariableRef) assignment.getlValue());
@@ -138,5 +124,25 @@ public class Pass2NopCastInlining extends Pass2SsaOptimization {
       return (replace1.size() > 0);
    }
 
+   public static boolean isNopCast(SymbolType castToType, SymbolType subValType) {
+      boolean isNopCast = false;
+      if(SymbolType.BYTE.equals(castToType) && SymbolType.SBYTE.equals(subValType)) {
+         isNopCast = true;
+      } else if(SymbolType.SBYTE.equals(castToType) && SymbolType.BYTE.equals(subValType)) {
+         isNopCast = true;
+      } else if(SymbolType.WORD.equals(castToType) && SymbolType.SWORD.equals(subValType)) {
+         isNopCast = true;
+      } else if(SymbolType.SWORD.equals(castToType) && SymbolType.WORD.equals(subValType)) {
+         isNopCast = true;
+      } else if(castToType instanceof SymbolTypePointer && SymbolType.WORD.equals(subValType)) {
+         isNopCast = true;
+      } else if(SymbolType.WORD.equals(castToType) && subValType instanceof SymbolTypePointer) {
+         isNopCast = true;
+      } else if(castToType instanceof SymbolTypePointer && subValType instanceof SymbolTypePointer) {
+         isNopCast = true;
+      }
+      return isNopCast;
+   }
+
 
 }

src/main/java/dk/camelot64/kickc/passes/Pass4RegisterUpliftCombinations.java

@@ -25,7 +25,7 @@ public class Pass4RegisterUpliftCombinations extends Pass2Base {
     *
     * @param combinationIterator The combination iterator used for supplying different register allocations to test
     * @param maxCombinations The maximal number of combinations to test. It the iterator has more combinations he rest is skipped (and a message logged)
-    * @param unknownFragments Receives any unknown ASM fragments encountered during the combinsation search
+    * @param unknownFragments Receives any unknown ASM fragments encountered during the combination search
     * @param scope The scope where the variables are being tested. (Only used for logging)
     * @param program The program to test (used for accessing global data structures)
     */

src/main/java/dk/camelot64/kickc/passes/calcs/PassNCalcLiveRangeVariables.java

@@ -22,11 +22,11 @@ public class PassNCalcLiveRangeVariables extends PassNCalcBase<LiveRangeVariable
 
    @Override
    public LiveRangeVariables calculate() {
-      calculateProcedureReferencedVars();
+      final Map<ProcedureRef, Collection<VariableRef>> procedureReferencedVars = calculateProcedureReferencedVars(getProgram());
       LiveRangeVariables liveRanges = new LiveRangeVariables(getProgram());
       boolean propagating;
       do {
-         propagating = calculateLiveRanges(liveRanges);
+         propagating = calculateLiveRanges(liveRanges, procedureReferencedVars);
          getProgram().setLiveRangeVariables(liveRanges);
          if(getLog().isVerboseLiveRanges()) {
             getLog().append("Propagating live ranges...");
@@ -37,22 +37,18 @@ public class PassNCalcLiveRangeVariables extends PassNCalcBase<LiveRangeVariable
       return liveRanges;
    }
 
-
-   /** Variables referenced inside each procedure and all it's sub-calls. */
-   private Map<ProcedureRef, Collection<VariableRef>> procedureReferencedVars;
-
    /**
     * Calculate the variables referenced inside each procedure and all it's sub-calls.
     */
-   private void calculateProcedureReferencedVars() {
-      VariableReferenceInfos referenceInfo = getProgram().getVariableReferenceInfos();
-      Collection<Procedure> allProcedures = getScope().getAllProcedures(true);
+   public static Map<ProcedureRef, Collection<VariableRef>> calculateProcedureReferencedVars(Program program) {
+      VariableReferenceInfos referenceInfo = program.getVariableReferenceInfos();
+      Collection<Procedure> allProcedures = program.getScope().getAllProcedures(true);
       Map<ProcedureRef, Collection<VariableRef>> procReferencedVars = new LinkedHashMap<>();
       for(Procedure procedure : allProcedures) {
          Collection<VariableRef> referencedVars = referenceInfo.getReferencedVars(procedure.getRef().getLabelRef());
          procReferencedVars.put(procedure.getRef(), referencedVars);
       }
-      this.procedureReferencedVars = procReferencedVars;
+      return procReferencedVars;
    }
 
    /**
@@ -77,7 +73,7 @@ public class PassNCalcLiveRangeVariables extends PassNCalcBase<LiveRangeVariable
     * @param liveRanges The live ranges to propagate.
     * @return true if any live ranges was modified. false if no modification was performed (and the propagation is complete)
     */
-   private boolean calculateLiveRanges(LiveRangeVariables liveRanges) {
+   private boolean calculateLiveRanges(LiveRangeVariables liveRanges, Map<ProcedureRef, Collection<VariableRef>> procedureReferencedVars) {
       VariableReferenceInfos referenceInfo = getProgram().getVariableReferenceInfos();
       boolean modified = false;
       LiveRangeVariables.LiveRangeVariablesByStatement liveRangeVariablesByStatement = liveRanges.getLiveRangeVariablesByStatement();
@@ -110,25 +106,25 @@ public class PassNCalcLiveRangeVariables extends PassNCalcBase<LiveRangeVariable
                   for(VariableRef aliveVar : aliveNextStmt) {
                      // Add all variables to previous that are not used inside the method
                      if(procUsed.contains(aliveVar)) {
-                        boolean addUsedVar = liveRanges.addAlive(aliveVar, previousStmt.getStatementIdx());
-                        modified |= addUsedVar;
-                        if(addUsedVar && getLog().isVerboseLiveRanges()) {
+                        boolean added = liveRanges.addAlive(aliveVar, previousStmt.getStatementIdx());
+                        modified |= added;
+                        if(added && getLog().isVerboseLiveRanges()) {
                            getLog().append("Propagated alive var used in method into method " + aliveVar + " to " + previousStmt.getStatement());
                         }
                      }
                   }
                } else if(PreviousStatement.Type.SKIP_METHOD.equals(previousStmt.getType())) {
-                  // Add all vars that the method does not use
+                  // Add all vars from next statement that the method does not use
                   StatementCalling call = (StatementCalling) nextStmt;
                   ProcedureRef procedure = call.getProcedure();
-                  Collection<VariableRef> procUsed = procedureReferencedVars.get(procedure);
+                  Collection<VariableRef> procReferenced = procedureReferencedVars.get(procedure);
                   // The call statement has no used or defined by itself so only work with the alive vars
                   for(VariableRef aliveVar : aliveNextStmt) {
                      // Add all variables to previous that are not used inside the method
-                     if(!procUsed.contains(aliveVar) && !definedNextStmt.contains(aliveVar)) {
-                        boolean addSkipVar = liveRanges.addAlive(aliveVar, previousStmt.getStatementIdx());
-                        modified |= addSkipVar;
-                        if(addSkipVar && getLog().isVerboseLiveRanges()) {
+                     if(!procReferenced.contains(aliveVar) && !definedNextStmt.contains(aliveVar)) {
+                        boolean added = liveRanges.addAlive(aliveVar, previousStmt.getStatementIdx());
+                        modified |= added;
+                        if(added && getLog().isVerboseLiveRanges()) {
                            getLog().append("Propagated alive var unused in method by skipping call " + aliveVar + " to " + previousStmt.getStatement());
                         }
                      }
@@ -137,15 +133,15 @@ public class PassNCalcLiveRangeVariables extends PassNCalcBase<LiveRangeVariable
                   // Add all alive variables to previous that are used inside the method
                   ControlFlowBlock procBlock = getProgram().getStatementInfos().getBlock(nextStmt);
                   Procedure procedure = (Procedure) getProgram().getScope().getSymbol(procBlock.getLabel());
-                  Collection<VariableRef> procUsed = procedureReferencedVars.get(procedure.getRef());
+                  Collection<VariableRef> procReferenced = procedureReferencedVars.get(procedure.getRef());
                   // The call statement has no used or defined by itself so only work with the alive vars
                   for(VariableRef aliveVar : aliveNextStmt) {
                      // Add all variables to previous that are used inside the method
-                     if(procUsed.contains(aliveVar)) {
+                     if(procReferenced.contains(aliveVar)) {
                         if(!definedNextStmt.contains(aliveVar)) {
-                           boolean usedVar = liveRanges.addAlive(aliveVar, previousStmt.getStatementIdx());
-                           modified |= usedVar;
-                           if(usedVar && getLog().isVerboseLiveRanges()) {
+                           boolean added = liveRanges.addAlive(aliveVar, previousStmt.getStatementIdx());
+                           modified |= added;
+                           if(added && getLog().isVerboseLiveRanges()) {
                               getLog().append("Propagated alive used in method out of method " + aliveVar + " to " + previousStmt.getStatement());
                            }
                         }
@@ -217,28 +213,28 @@ public class PassNCalcLiveRangeVariables extends PassNCalcBase<LiveRangeVariable
     * as multiple blocks may jump to the same block resulting in multiple stmt/nextstmt pairs.
     * Calls to methods are also given special consideration.
     * The following illustrates how the different types of previous statements work.
-    <pre>
-    b1: {
-      [1] stmt;         prev: b3[1]/NORMAL, b2[2]/NORMAL
-      [2] call b4;      prev: b1[1]/SKIP_METHOD, b4[3]/LAST_IN_METHOD
-      [3] stmt;         prev: b1[2]/NORMAL
-      goto b2;
-    }
-    b2: {
-      [1] stmt;         prev: b1[3]/NORMAL
-      [2] if(x) b1;     prev: b2[1]/NORMAL
-      goto b3;
-    }
-    b3: {
-      [1] stmt;         prev: b2[2]/NORMAL
-      goto b1
-    }
-    b4: {
-      [1] stmt;         prev: b1[1]/BEFORE_METHOD
-      [2] stmt;         prev: b4[1]/NORMAL
-      [3] return;       prev: b4[3]/NORMAL
-    }
-    </pre>    *
+    * <pre>
+    * b1: {
+    * [1] stmt;         prev: b3[1]/NORMAL, b2[2]/NORMAL
+    * [2] call b4;      prev: b1[1]/SKIP_METHOD, b4[3]/LAST_IN_METHOD
+    * [3] stmt;         prev: b1[2]/NORMAL
+    * goto b2;
+    * }
+    * b2: {
+    * [1] stmt;         prev: b1[3]/NORMAL
+    * [2] if(x) b1;     prev: b2[1]/NORMAL
+    * goto b3;
+    * }
+    * b3: {
+    * [1] stmt;         prev: b2[2]/NORMAL
+    * goto b1
+    * }
+    * b4: {
+    * [1] stmt;         prev: b1[1]/BEFORE_METHOD
+    * [2] stmt;         prev: b4[1]/NORMAL
+    * [3] return;       prev: b4[3]/NORMAL
+    * }
+    * </pre>    *
     *
     * @param statement The statement to find previous for
     * @return statement(s) executed just before the passed statement
@@ -246,7 +242,7 @@ public class PassNCalcLiveRangeVariables extends PassNCalcBase<LiveRangeVariable
    private Collection<PreviousStatement> getPreviousStatements(Statement statement) {
       ArrayList<PreviousStatement> previousStatements = new ArrayList<>();
       // Find the statement(s) just before the current statement (disregarding if the current statement is a call - this will be handled later)
-      Collection<Statement> precedingStatements = getPrecedingStatement(statement);
+      Collection<Statement> precedingStatements = getPrecedingStatement(statement, getGraph(), getProgram().getStatementInfos());
       if(statement instanceof StatementCalling) {
          // Add the statement(s) just before the call
          for(Statement precedingStatement : precedingStatements) {
@@ -257,8 +253,8 @@ public class PassNCalcLiveRangeVariables extends PassNCalcBase<LiveRangeVariable
          ProcedureRef procedure = call.getProcedure();
          LabelRef procedureReturnBlock = procedure.getReturnBlock();
          ControlFlowBlock returnBlock = getProgram().getGraph().getBlock(procedureReturnBlock);
-         if(returnBlock!=null) {
-            Collection<Statement> lastStatements = getLastInBlock(returnBlock);
+         if(returnBlock != null) {
+            Collection<Statement> lastStatements = getLastInBlock(returnBlock, getGraph());
             for(Statement lastStatement : lastStatements) {
                previousStatements.add(new PreviousStatement(lastStatement, PreviousStatement.Type.LAST_IN_METHOD));
             }
@@ -276,7 +272,7 @@ public class PassNCalcLiveRangeVariables extends PassNCalcBase<LiveRangeVariable
             Collection<CallGraph.CallBlock.Call> callers = getProgram().getCallGraph().getCallers((ProcedureRef) block.getScope());
             for(CallGraph.CallBlock.Call call : callers) {
                Statement callStmt = getProgram().getStatementInfos().getStatement(call.getCallStatementIdx());
-               Collection<Statement> precedingCallStmt = getPrecedingStatement(callStmt);
+               Collection<Statement> precedingCallStmt = getPrecedingStatement(callStmt, getGraph(), getProgram().getStatementInfos());
                for(Statement precedingCall : precedingCallStmt) {
                   previousStatements.add(new PreviousStatement(precedingCall, PreviousStatement.Type.BEFORE_METHOD));
                }
@@ -315,10 +311,10 @@ public class PassNCalcLiveRangeVariables extends PassNCalcBase<LiveRangeVariable
     * Multiple statements are returned if the current statement is the first in a block with multiple predecessor blocks.
     * Zero statements are returned if the current statement is the first statement in the program or the first statement in a method.
     */
-   private Collection<Statement> getPrecedingStatement(Statement statement) {
+   static Collection<Statement> getPrecedingStatement(Statement statement, ControlFlowGraph graph, StatementInfos statementInfos) {
       Statement previousStmt = null;
       Statement prev = null;
-      ControlFlowBlock block = getProgram().getStatementInfos().getBlock(statement);
+      ControlFlowBlock block = statementInfos.getBlock(statement);
       List<Statement> statements = block.getStatements();
       for(Statement stmt : statements) {
          if(statement.getIndex().equals(stmt.getIndex())) {
@@ -332,7 +328,7 @@ public class PassNCalcLiveRangeVariables extends PassNCalcBase<LiveRangeVariable
          previous = Arrays.asList(previousStmt);
       } else {
          // Current is first in a block - look in predecessor blocks
-         previous = getLastInPredecessors(block);
+         previous = getLastInPredecessors(block, graph);
       }
       return previous;
    }
@@ -344,13 +340,13 @@ public class PassNCalcLiveRangeVariables extends PassNCalcBase<LiveRangeVariable
     * @return The last statement(s). May contain multiple statements if the block is empty and has multiple predecessors.
     * This method never traces back through calls, so the result may also be empty (if the block is an empty method).
     */
-   private Collection<Statement> getLastInBlock(ControlFlowBlock block) {
+   private static Collection<Statement> getLastInBlock(ControlFlowBlock block, ControlFlowGraph graph) {
       List<Statement> statements = block.getStatements();
       if(statements.size() > 0) {
          return Arrays.asList(statements.get(statements.size() - 1));
       } else {
          // Trace back through direct/conditional predecessors (not calls)
-         return getLastInPredecessors(block);
+         return getLastInPredecessors(block, graph);
       }
    }
 
@@ -361,12 +357,12 @@ public class PassNCalcLiveRangeVariables extends PassNCalcBase<LiveRangeVariable
     * @return The last statement(s). May contain multiple statements if the block is empty and has multiple predecessors.
     * This method never traces back through calls, so the result may also be empty (if the block is an empty method).
     */
-   private Collection<Statement> getLastInPredecessors(ControlFlowBlock block) {
-      List<ControlFlowBlock> predecessors = getProgram().getGraph().getPredecessors(block);
+   private static Collection<Statement> getLastInPredecessors(ControlFlowBlock block, ControlFlowGraph graph) {
+      List<ControlFlowBlock> predecessors = graph.getPredecessors(block);
       ArrayList<Statement> last = new ArrayList<>();
       for(ControlFlowBlock predecessor : predecessors) {
          if(block.getLabel().equals(predecessor.getDefaultSuccessor()) || block.getLabel().equals(predecessor.getConditionalSuccessor())) {
-            last.addAll(getLastInBlock(predecessor));
+            last.addAll(getLastInBlock(predecessor, graph));
          }
       }
       return last;

src/main/java/dk/camelot64/kickc/passes/calcs/PassNCalcLiveRangesEffectiveCallPaths.java

@@ -5,6 +5,7 @@ import dk.camelot64.kickc.model.statements.Statement;
 import dk.camelot64.kickc.model.statements.StatementAssignment;
 import dk.camelot64.kickc.model.statements.StatementPhiBlock;
 import dk.camelot64.kickc.model.symbols.Procedure;
+import dk.camelot64.kickc.model.symbols.ProgramScope;
 import dk.camelot64.kickc.model.symbols.Scope;
 import dk.camelot64.kickc.model.symbols.Variable;
 import dk.camelot64.kickc.model.values.*;
@@ -102,7 +103,7 @@ public class PassNCalcLiveRangesEffectiveCallPaths extends PassNCalcBase<LiveRan
                   alive.addAll(callerPath.getAlive());
                   alive.removeAll(referencedInCaller);
                   alive.addAll(liveRangeVariables.getAlive(callStatementIdx));
-                  Pass2AliasElimination.Aliases innerAliases = getCallAliases(procedure, callBlock);
+                  Pass2AliasElimination.Aliases innerAliases = getCallAliases(caller, getProgram().getStatementInfos(), getGraph(), getScope());
                   Pass2AliasElimination.Aliases pathAliases = new Pass2AliasElimination.Aliases();
                   pathAliases.addAll(callerPath.getPathAliases());
                   pathAliases.addAll(innerAliases);
@@ -127,12 +128,17 @@ public class PassNCalcLiveRangesEffectiveCallPaths extends PassNCalcBase<LiveRan
    /**
     * Find aliases defined when taking a specific call - meaning call parameters that have specific values when taking the specific call.
     *
-    * @param procedure The called procedure
-    * @param callBlock The block performing the call
-    * @return Aliases defined by the specific call.
+    * @param call The procedure call
+    * @param statementInfos Statement infos
+    * @param graph The control flow graph
+    * @param programScope The program scope
+    * @return
     */
-   private Pass2AliasElimination.Aliases getCallAliases(Procedure procedure, ControlFlowBlock callBlock) {
-      ControlFlowBlock procedureBlock = getProgram().getGraph().getBlock(procedure.getLabel().getRef());
+   static Pass2AliasElimination.Aliases getCallAliases(CallGraph.CallBlock.Call call, StatementInfos statementInfos, ControlFlowGraph graph, ProgramScope programScope) {
+      final ProcedureRef procedureRef = call.getProcedure();
+      Procedure procedure = programScope.getProcedure(procedureRef);
+      final ControlFlowBlock callBlock = statementInfos.getBlock(call.getCallStatementIdx());
+      ControlFlowBlock procedureBlock = graph.getBlock(procedure.getLabel().getRef());
       StatementPhiBlock procedurePhiBlock = null;
       if(procedureBlock.hasPhiBlock()) {
          procedurePhiBlock = procedureBlock.getPhiBlock();
@@ -153,7 +159,7 @@ public class PassNCalcLiveRangesEffectiveCallPaths extends PassNCalcBase<LiveRan
             StatementAssignment assignment = (StatementAssignment) statement;
             LValue lValue = assignment.getlValue();
             if(lValue instanceof VariableRef) {
-               Variable lValueVar = getProgram().getScope().getVariable((VariableRef) lValue);
+               Variable lValueVar = programScope.getVariable((VariableRef) lValue);
                if(lValueVar.getScope().equals(procedure)) {
                   // Assigning into the procedure scope
                   if(assignment.getrValue1() == null && assignment.getOperator() == null && assignment.getrValue2() instanceof VariableRef) {

src/main/java/dk/camelot64/kickc/passes/calcs/PassNCalcLiveRangesEffectiveSimple.java

@@ -2,9 +2,15 @@ package dk.camelot64.kickc.passes.calcs;
 
 import dk.camelot64.kickc.model.*;
 import dk.camelot64.kickc.model.statements.Statement;
+import dk.camelot64.kickc.model.statements.StatementAssignment;
 import dk.camelot64.kickc.model.symbols.Procedure;
+import dk.camelot64.kickc.model.symbols.Variable;
+import dk.camelot64.kickc.model.values.CastValue;
 import dk.camelot64.kickc.model.values.ProcedureRef;
+import dk.camelot64.kickc.model.values.RValue;
 import dk.camelot64.kickc.model.values.VariableRef;
+import dk.camelot64.kickc.passes.Pass2AliasElimination;
+import dk.camelot64.kickc.passes.Pass2NopCastInlining;
 
 import java.util.*;
 
@@ -22,35 +28,91 @@ public class PassNCalcLiveRangesEffectiveSimple extends PassNCalcBase<LiveRangeV
       final LiveRangeVariables liveRangeVariables = getProgram().getLiveRangeVariables();
       final CallGraph callGraph = getProgram().getCallGraph();
       final LiveRangeVariables.LiveRangeVariablesByStatement liveRangeVariablesByStatement = liveRangeVariables.getLiveRangeVariablesByStatement();
+      final Map<ProcedureRef, Collection<VariableRef>> procedureReferencedVars = PassNCalcLiveRangeVariables.calculateProcedureReferencedVars(getProgram());
 
-      // Find all alive vars from the recursive callers of each procedure
-      Map<ProcedureRef, Collection<VariableRef>> callersAlive = new LinkedHashMap<>();
+      // All variables alive outside a call. This is variables that are alive across the call that are not touched by the procedure (or any sub-procedure).
+      Map<CallGraph.CallBlock.Call, Collection<VariableRef>> aliveOutsideCalls = new LinkedHashMap<>();
+      // All variables alive outside all calls to a procedure. This is variables that are alive across a call that are not touched by the procedure (or any sub-procedure).
+      Map<ProcedureRef, Collection<VariableRef>> aliveOutsideProcedures = new LinkedHashMap<>();
       Collection<Procedure> procedures = getProgram().getScope().getAllProcedures(true);
       for(Procedure procedure : procedures) {
-         Collection<VariableRef> procCallersAlive = new LinkedHashSet<>();
+         Collection<VariableRef> aliveOutsideProcedure = new LinkedHashSet<>();
          final Collection<CallGraph.CallBlock.Call> callers = callGraph.getRecursiveCallers(procedure.getRef());
          for(CallGraph.CallBlock.Call caller : callers) {
             final Integer callStatementIdx = caller.getCallStatementIdx();
-            final List<VariableRef> callStatementAlive = liveRangeVariables.getAlive(callStatementIdx);
-            procCallersAlive.addAll(callStatementAlive);
+            final Statement callStatement = getGraph().getStatementByIndex(callStatementIdx);
+            final Collection<Statement> precedingStatements = PassNCalcLiveRangeVariables.getPrecedingStatement(callStatement, getGraph(), getProgram().getStatementInfos());
+            Collection<VariableRef> aliveOutsideCall = new LinkedHashSet<>();
+            for(Statement precedingStatement : precedingStatements) {
+               final List<VariableRef> precedingStatementAlive = liveRangeVariables.getAlive(precedingStatement.getIndex());
+               for(VariableRef precedingStatementAliveVarRef : precedingStatementAlive) {
+                  if(!precedingStatementAliveVarRef.getScopeNames().equals(caller.getProcedure().getFullName())) {
+                     // Skipping variables alive preceeding the caller from the called scope (these are parameters and are handled by local live ranges)
+                     aliveOutsideCall.add(precedingStatementAliveVarRef);
+                  }
+               }
+            }
+            final Collection<VariableRef> procedureReferenced = procedureReferencedVars.get(procedure.getRef());
+            aliveOutsideCall.removeAll(procedureReferenced);
+            aliveOutsideCalls.put(caller, aliveOutsideCall);
+            aliveOutsideProcedure.addAll(aliveOutsideCall);
          }
-         callersAlive.put(procedure.getRef(), procCallersAlive);
+         aliveOutsideProcedures.put(procedure.getRef(), aliveOutsideProcedure);
       }
 
-      // Find all alive variables for all statements by adding the alive from all recursive callers
+      // Find all alive variables for all statements by adding everything alive outside each call (not including variables from the called scope)
       final LinkedHashMap<Integer, Collection<VariableRef>> statementAliveEffective = new LinkedHashMap<>();
       for(ControlFlowBlock block : getGraph().getAllBlocks()) {
          final Procedure procedure = block.getProcedure(getProgram());
          for(Statement statement : block.getStatements()) {
             final Collection<VariableRef> aliveStmt = new LinkedHashSet<>();
-            aliveStmt.addAll(liveRangeVariablesByStatement.getAlive(statement.getIndex()));
+            final List<VariableRef> aliveStatement = liveRangeVariablesByStatement.getAlive(statement.getIndex());
+            aliveStmt.addAll(aliveStatement);
             if(procedure!=null) {
-               aliveStmt.addAll(callersAlive.get(procedure.getRef()));
+               final Collection<VariableRef> aliveOutsideProcedure = aliveOutsideProcedures.get(procedure.getRef());
+               aliveStmt.addAll(aliveOutsideProcedure);
             }
             statementAliveEffective.put(statement.getIndex(), aliveStmt);
          }
       }
-      return new LiveRangeVariablesEffectiveSimple(statementAliveEffective);
+
+      // Find aliases inside each block
+      Map<Integer, Pass2AliasElimination.Aliases> statementAliases = new LinkedHashMap<>();
+      for(ControlFlowBlock block : getGraph().getAllBlocks()) {
+         Pass2AliasElimination.Aliases blockAliases = new Pass2AliasElimination.Aliases();
+         for(Statement statement : block.getStatements()) {
+            if(statement instanceof StatementAssignment) {
+               StatementAssignment assignment = (StatementAssignment) statement;
+               if(assignment.getrValue1()==null && assignment.getOperator()==null) {
+
+                  RValue rValue = assignment.getrValue2();
+                  if(rValue instanceof CastValue) {
+                     // A cast - examine if it is a noop-cast
+                     final CastValue castValue = (CastValue) rValue;
+                     if(castValue.getValue() instanceof VariableRef) {
+                        final VariableRef subVarRef = (VariableRef) castValue.getValue();
+                        final Variable subVar = getScope().getVariable(subVarRef);
+                        if(Pass2NopCastInlining.isNopCast(castValue.getToType(), subVar.getType())) {
+                           // Found a Nop Cast of a variable - use the variable
+                           rValue = subVarRef;
+                        }
+                     }
+                  }
+                  if(assignment.getlValue() instanceof VariableRef && rValue instanceof VariableRef) {
+                     final VariableRef lValueRef = (VariableRef) assignment.getlValue();
+                     final VariableRef rValueRef = (VariableRef) rValue;
+                     if((lValueRef.isIntermediate() || lValueRef.isVersion()) && (rValueRef.isIntermediate() || rValueRef.isVersion()) ) {
+                        // Identified an alias assignment of versioned/intermediate variables!
+                        blockAliases.add(lValueRef, rValueRef);
+                     }
+                  }
+               }
+            }
+            statementAliases.put(statement.getIndex(), new Pass2AliasElimination.Aliases(blockAliases));
+         }
+      }
+
+      return new LiveRangeVariablesEffectiveSimple(statementAliveEffective, statementAliases);
    }
 
 

src/main/java/dk/camelot64/kickc/passes/calcs/PassNCalcVariableRegisterWeight.java

@@ -7,6 +7,8 @@ import dk.camelot64.kickc.model.statements.StatementConditionalJump;
 import dk.camelot64.kickc.model.statements.StatementPhiBlock;
 import dk.camelot64.kickc.model.values.*;
 
+import java.util.Collection;
+
 /**
  * Finds register weights for all variables.
  * <p>
@@ -28,8 +30,10 @@ public class PassNCalcVariableRegisterWeight extends PassNCalcBase<VariableRegis
    @Override
    public VariableRegisterWeights calculate() {
       NaturalLoopSet loopSet = getProgram().getLoopSet();
+      final CallGraph callGraph = getProgram().getCallGraph();
       LiveRangeVariables liveRangeVariables = getProgram().getLiveRangeVariables();
       VariableRegisterWeights variableRegisterWeights = new VariableRegisterWeights();
+      final StatementInfos statementInfos = getProgram().getStatementInfos();
 
       for(ControlFlowBlock block : getProgram().getGraph().getAllBlocks()) {
          for(Statement statement : block.getStatements()) {
@@ -39,48 +43,46 @@ public class PassNCalcVariableRegisterWeight extends PassNCalcBase<VariableRegis
                   VariableRef philVariable = phiVariable.getVariable();
                   for(StatementPhiBlock.PhiRValue phiRValue : phiVariable.getValues()) {
                      if(phiRValue.getrValue() instanceof VariableRef) {
-                        double w = addWeight(philVariable, phiRValue.getPredecessor(), variableRegisterWeights, loopSet, liveRangeVariables);
-                        //log.append("Definition of " + philVariable + " w+:" + w + " - [" + statement.getIndex()+"]");
+                        addWeight(philVariable, phiRValue.getPredecessor(), liveRangeVariables, loopSet, callGraph, statementInfos, variableRegisterWeights);
                      }
                   }
                   // Add weights for each usage of a variable
                   for(StatementPhiBlock.PhiRValue phiRValue : phiVariable.getValues()) {
-                     addUsageWeightRValue(phiRValue.getrValue(), statement, phiRValue.getPredecessor(), variableRegisterWeights, loopSet, liveRangeVariables);
+                     addUsageWeightRValue(phiRValue.getrValue(), phiRValue.getPredecessor(), variableRegisterWeights, loopSet, callGraph, statementInfos, liveRangeVariables);
                   }
                }
             } else if(statement instanceof StatementAssignment) {
                // Add weights for the definition of the variable
-               addUsageWeightRValue(((StatementAssignment) statement).getlValue(), statement, block.getLabel(), variableRegisterWeights, loopSet, liveRangeVariables);
+               addUsageWeightRValue(((StatementAssignment) statement).getlValue(), block.getLabel(), variableRegisterWeights, loopSet, callGraph, statementInfos, liveRangeVariables);
                // Add weights for each usage of variables
-               addUsageWeightRValue(((StatementAssignment) statement).getrValue1(), statement, block.getLabel(), variableRegisterWeights, loopSet, liveRangeVariables);
-               addUsageWeightRValue(((StatementAssignment) statement).getrValue2(), statement, block.getLabel(), variableRegisterWeights, loopSet, liveRangeVariables);
+               addUsageWeightRValue(((StatementAssignment) statement).getrValue1(), block.getLabel(), variableRegisterWeights, loopSet, callGraph, statementInfos, liveRangeVariables);
+               addUsageWeightRValue(((StatementAssignment) statement).getrValue2(), block.getLabel(), variableRegisterWeights, loopSet, callGraph, statementInfos, liveRangeVariables);
             } else if(statement instanceof StatementConditionalJump) {
                // Add weights for each usage of variables
-               addUsageWeightRValue(((StatementConditionalJump) statement).getrValue1(), statement, block.getLabel(), variableRegisterWeights, loopSet, liveRangeVariables);
-               addUsageWeightRValue(((StatementConditionalJump) statement).getrValue2(), statement, block.getLabel(), variableRegisterWeights, loopSet, liveRangeVariables);
+               addUsageWeightRValue(((StatementConditionalJump) statement).getrValue1(), block.getLabel(), variableRegisterWeights, loopSet, callGraph, statementInfos, liveRangeVariables);
+               addUsageWeightRValue(((StatementConditionalJump) statement).getrValue2(), block.getLabel(), variableRegisterWeights, loopSet, callGraph, statementInfos, liveRangeVariables);
             }
          }
       }
       return variableRegisterWeights;
    }
 
-   private static void addUsageWeightRValue(Value rValue, Statement statement, LabelRef block, VariableRegisterWeights variableRegisterWeights, NaturalLoopSet loopSet, LiveRangeVariables liveRangeVariables) {
+   private static void addUsageWeightRValue(Value rValue, LabelRef block, VariableRegisterWeights variableRegisterWeights, NaturalLoopSet loopSet, CallGraph callGraph, StatementInfos statementInfos, LiveRangeVariables liveRangeVariables) {
       if(rValue instanceof VariableRef) {
-         double w = addWeight((VariableRef) rValue, block, variableRegisterWeights, loopSet, liveRangeVariables);
-         //log.append("Usage of " + rValue + " w+:" + w + " - [" + statement.getIndex()+"]");
+         addWeight((VariableRef) rValue, block, liveRangeVariables, loopSet, callGraph, statementInfos, variableRegisterWeights);
       } else if(rValue instanceof PointerDereferenceSimple) {
-         addUsageWeightRValue(((PointerDereferenceSimple) rValue).getPointer(), statement, block, variableRegisterWeights, loopSet, liveRangeVariables);
+         addUsageWeightRValue(((PointerDereferenceSimple) rValue).getPointer(), block, variableRegisterWeights, loopSet, callGraph, statementInfos, liveRangeVariables);
       } else if(rValue instanceof PointerDereferenceIndexed) {
-         addUsageWeightRValue(((PointerDereferenceIndexed) rValue).getPointer(), statement, block, variableRegisterWeights, loopSet, liveRangeVariables);
-         addUsageWeightRValue(((PointerDereferenceIndexed) rValue).getIndex(), statement, block, variableRegisterWeights, loopSet, liveRangeVariables);
+         addUsageWeightRValue(((PointerDereferenceIndexed) rValue).getPointer(), block, variableRegisterWeights, loopSet, callGraph, statementInfos, liveRangeVariables);
+         addUsageWeightRValue(((PointerDereferenceIndexed) rValue).getIndex(), block, variableRegisterWeights, loopSet, callGraph, statementInfos, liveRangeVariables);
       }
    }
 
-   private static double addWeight(VariableRef variable, LabelRef block, VariableRegisterWeights variableRegisterWeights, NaturalLoopSet loopSet, LiveRangeVariables liveRangeVariables) {
-      int depth = loopSet.getMaxLoopDepth(block);
-      double w = 1.0 + Math.pow(10.0, depth);
+   private static double addWeight(VariableRef variable, LabelRef block, LiveRangeVariables liveRangeVariables, NaturalLoopSet loopSet, CallGraph callGraph, StatementInfos statementInfos, VariableRegisterWeights variableRegisterWeights) {
+      int loopCallDepth = getLoopCallDepth(block, loopSet, callGraph,statementInfos);
+      double w = 1.0 + Math.pow(10.0, loopCallDepth);
       LiveRange liveRange = liveRangeVariables.getLiveRange(variable);
-      double s = liveRange==null?0.0:liveRange.size();
+      double s = liveRange == null ? 0.0 : liveRange.size();
       if(s < 0.01) {
          s = 0.1;
       }
@@ -88,5 +90,29 @@ public class PassNCalcVariableRegisterWeight extends PassNCalcBase<VariableRegis
       return w / s;
    }
 
+   /**
+    * Get the loop/call depth of a block.
+    *
+    * @param block The block to examine
+    * @param loopSet The loop set
+    * @param callGraph The call graph
+    * @return The combined loop/call depth
+    */
+   private static int getLoopCallDepth(LabelRef block, NaturalLoopSet loopSet, CallGraph callGraph, StatementInfos statementInfos) {
+      final String procedureName = block.getFullName().contains("::") ? block.getScopeNames() : block.getFullName();
+      final ProcedureRef procedureRef = new ProcedureRef(procedureName);
+      final Collection<CallGraph.CallBlock.Call> callers = callGraph.getCallers(procedureRef);
+      int maxCallDepth = 0;
+      for(CallGraph.CallBlock.Call caller : callers) {
+         final Integer callStatementIdx = caller.getCallStatementIdx();
+         final ControlFlowBlock callBlock = statementInfos.getBlock(callStatementIdx);
+         int callDepth = getLoopCallDepth(callBlock.getLabel(), loopSet, callGraph, statementInfos) + 1;
+         if(callDepth > maxCallDepth)
+            maxCallDepth = callDepth;
+      }
+      int loopDepth = loopSet.getMaxLoopDepth(block);
+      return maxCallDepth + loopDepth;
+   }
+
 
 }

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

@@ -3385,6 +3385,51 @@ public class TestPrograms {
       compileAndCompare("constantmin");
    }
 
+   @Test
+   public void testLiveRange9() throws IOException, URISyntaxException {
+      compileAndCompare("liverange-9");
+   }
+
+   @Test
+   public void testLiveRange8() throws IOException, URISyntaxException {
+      compileAndCompare("liverange-8");
+   }
+
+   @Test
+   public void testLiveRange7() throws IOException, URISyntaxException {
+      compileAndCompare("liverange-7");
+   }
+
+   @Test
+   public void testLiveRange6() throws IOException, URISyntaxException {
+      compileAndCompare("liverange-6");
+   }
+
+   @Test
+   public void testLiveRange5() throws IOException, URISyntaxException {
+      compileAndCompare("liverange-5");
+   }
+
+   @Test
+   public void testLiveRange4() throws IOException, URISyntaxException {
+      compileAndCompare("liverange-4");
+   }
+
+   @Test
+   public void testLiveRange3() throws IOException, URISyntaxException {
+      compileAndCompare("liverange-3");
+   }
+
+   @Test
+   public void testLiveRange2() throws IOException, URISyntaxException {
+      compileAndCompare("liverange-2");
+   }
+
+   @Test
+   public void testLiveRange1() throws IOException, URISyntaxException {
+      compileAndCompare("liverange-1");
+   }
+
    @Test
    public void testLiveRange() throws IOException, URISyntaxException {
       compileAndCompare("liverange");

src/test/kc/liverange-1.kc

@@ -0,0 +1,15 @@
+// Test propagation of live ranges back over PHI-calls
+// The idx-variable is alive between the two calls to out() - but not before the first call.
+
+
+void main() {
+    out('c');
+    out('m');
+}
+
+const char* SCREEN = 0x0400;
+char idx = 0;
+
+void out(char c) {
+    SCREEN[idx++] = c;
+}

src/test/kc/liverange-2.kc

@@ -0,0 +1,18 @@
+// Test effective live range and register allocation
+
+void main() {
+    for(char a: 0..100 ) {
+        for( char b: 0..100 ) {
+            for( char c: 0..100 ) {
+                char ca = c+a;
+                print(b, ca);
+            }
+        }
+    }
+}
+
+const char* SCREEN  = 0x0400;
+
+void print(char b, char ca) {
+    SCREEN[b] = ca;
+}

src/test/kc/liverange-3.kc

@@ -0,0 +1,20 @@
+// Test effective live range and register allocation
+// Here main::b should be allocated to the same register as print::b and main::ca to the same register as print::ca
+
+void main() {
+    for(char a: 0..100 ) {
+        for( char b: 0..100 ) {
+            for( char c: 0..100 ) {
+                char ca = c+a;
+                print(b, ca);
+            }
+        }
+    }
+}
+
+const char* SCREEN  = 0x0400;
+
+void print(char b, char ca) {
+    (*(SCREEN+999))++;
+    SCREEN[b] = ca;
+}

src/test/kc/liverange-4.kc

@@ -0,0 +1,23 @@
+// Test effective live range and register allocation
+// Here out::b, print::b and main::b can have the same allocation
+
+void main() {
+    for(char a: 0..100 ) {
+        for( char b: 0..100 ) {
+            for( char c: 0..100 ) {
+                char ca = c+a;
+                print(b, ca);
+            }
+        }
+    }
+}
+
+const char* SCREEN  = 0x0400;
+
+void print(char b, char ca) {
+    out(b, ca);
+}
+
+void out(char b, char ca) {
+    SCREEN[b] = ca;
+}

src/test/kc/liverange-5.kc

@@ -0,0 +1,24 @@
+// Test effective live range and register allocation
+// Here out::b, print::b and main::b can have the same allocation
+
+void main() {
+    for(char a: 0..100 ) {
+        for( char b: 0..100 ) {
+            for( char c: 0..100 ) {
+                char ca = c+a;
+                print(b, ca);
+            }
+        }
+    }
+}
+
+const char* SCREEN  = 0x0400;
+
+void print(char b, char ca) {
+    out(b, ca);
+}
+
+void out(char b, char ca) {
+    (*(SCREEN+999))++;
+    SCREEN[b] = ca;
+}

src/test/kc/liverange-6.kc

@@ -0,0 +1,14 @@
+// Test effective live range and register allocation
+
+
+byte[] msg = "hello world!";
+const char* SCREEN  = 0x0400;
+char idx  = 0;
+
+void main() {
+    for( byte i: 0..11) out(msg[i]);
+}
+
+void out(char c) {
+    SCREEN[idx++] = c;
+}

src/test/kc/liverange-7.kc

@@ -0,0 +1,20 @@
+// Test effective live range and register allocation
+// Here main::c, out2::c and out::c can all have the same allocation - and the global idx can be allocated to a hardware register.
+
+const char* SCREEN  = 0x0400;
+char idx = 0;
+
+void main() {
+    for(char c: 0..39 ) {
+        out2(c);
+    }
+}
+
+void out2(char c) {
+    out(c);
+}
+
+void out(char c) {
+    idx++;
+    SCREEN[idx] = c;
+}

src/test/kc/liverange-8.kc

@@ -0,0 +1,21 @@
+// Test effective live range and register allocation
+// Here main::c, out2::c and out::c can all have the same allocation - and the global idx can be allocated to a hardware register.
+
+const char* SCREEN  = 0x0400;
+char idx = 0;
+
+void main() {
+    for(char c: 0..39 ) {
+        out2(c);
+    }
+}
+
+void out2(char c) {
+    out(c);
+    out(c);
+}
+
+void out(char c) {
+    idx++;
+    SCREEN[idx] = c;
+}

src/test/kc/liverange-9.kc

@@ -0,0 +1,28 @@
+// Test effective live range and register allocation
+// Here main::c, outsw::c and outw::c can all have the same allocation
+
+const char* SCREEN  = 0x0400;
+char idx = 0;
+
+void main() {
+    for(char c: 0..39 ) {
+        outsw(c);
+    }
+}
+
+void outsw(char c) {
+    out('-');
+    outw(c);
+}
+
+char[] HEXTAB = "0123456789abcdef";
+
+void outw(char c) {
+    out(HEXTAB[c<<4]);
+    out(HEXTAB[c&0x0f]);
+}
+
+void out(char c) {
+    idx++;
+    SCREEN[idx] = c;
+}

src/test/ref/address-0.log

@@ -93,7 +93,7 @@ main::@2: scope:[main]  from main::@1
 
 
 VARIABLE REGISTER WEIGHTS
-(byte) i loadstore !zp[-1]:2 9.5
+(byte) i loadstore !zp[-1]:2 84.49999999999999
 (void()) main()
 
 Initial phi equivalence classes
@@ -159,13 +159,13 @@ main: {
   // File Data
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Statement [0] (byte) i ← (byte) 3 [ i ] (  [ i ] ) always clobbers reg byte a 
-Statement [5] if((byte) i<(byte) 7) goto main::@2 [ i ] ( main:2 [ i ] ) always clobbers reg byte a 
-Statement [7] *((const byte*) SCREEN + (byte) i) ← (byte) i [ i ] ( main:2 [ i ] ) always clobbers reg byte a reg byte y 
+Statement [0] (byte) i ← (byte) 3 [ i ] (  [ i ] { }  ) always clobbers reg byte a 
+Statement [5] if((byte) i<(byte) 7) goto main::@2 [ i ] ( main:2 [ i ] { }  ) always clobbers reg byte a 
+Statement [7] *((const byte*) SCREEN + (byte) i) ← (byte) i [ i ] ( main:2 [ i ] { }  ) always clobbers reg byte a reg byte y 
 Potential registers zp[1]:2 [ i ] : zp[1]:2 , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [] 9.5: zp[1]:2 [ i ] 
+Uplift Scope [] 84.5: zp[1]:2 [ i ] 
 Uplift Scope [main] 
 
 Uplifting [] best 338 combination zp[1]:2 [ i ] 
@@ -251,7 +251,7 @@ FINAL SYMBOL TABLE
 (label) @begin
 (label) @end
 (const byte*) SCREEN = (byte*) 1024
-(byte) i loadstore !zp[-1]:2 zp[1]:2 9.5
+(byte) i loadstore !zp[-1]:2 zp[1]:2 84.49999999999999
 (void()) main()
 (label) main::@1
 (label) main::@2

src/test/ref/address-0.sym

@@ -2,7 +2,7 @@
 (label) @begin
 (label) @end
 (const byte*) SCREEN = (byte*) 1024
-(byte) i loadstore !zp[-1]:2 zp[1]:2 9.5
+(byte) i loadstore !zp[-1]:2 zp[1]:2 84.49999999999999
 (void()) main()
 (label) main::@1
 (label) main::@2

src/test/ref/address-1.log

@@ -94,7 +94,7 @@ main::@2: scope:[main]  from main::@1
 
 VARIABLE REGISTER WEIGHTS
 (void()) main()
-(byte) main::i loadstore !zp[-1]:2 14.25
+(byte) main::i loadstore !zp[-1]:2 129.0
 
 Initial phi equivalence classes
 Added variable main::i to live range equivalence class [ main::i ]
@@ -157,13 +157,13 @@ main: {
   // File Data
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Statement [4] (byte) main::i ← (byte) 3 [ main::i ] ( main:2 [ main::i ] ) always clobbers reg byte a 
-Statement [5] if((byte) main::i<(byte) 7) goto main::@2 [ main::i ] ( main:2 [ main::i ] ) always clobbers reg byte a 
-Statement [7] *((const byte*) SCREEN + (byte) main::i) ← (byte) main::i [ main::i ] ( main:2 [ main::i ] ) always clobbers reg byte a reg byte y 
+Statement [4] (byte) main::i ← (byte) 3 [ main::i ] ( main:2 [ main::i ] { }  ) always clobbers reg byte a 
+Statement [5] if((byte) main::i<(byte) 7) goto main::@2 [ main::i ] ( main:2 [ main::i ] { }  ) always clobbers reg byte a 
+Statement [7] *((const byte*) SCREEN + (byte) main::i) ← (byte) main::i [ main::i ] ( main:2 [ main::i ] { }  ) always clobbers reg byte a reg byte y 
 Potential registers zp[1]:2 [ main::i ] : zp[1]:2 , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [main] 14.25: zp[1]:2 [ main::i ] 
+Uplift Scope [main] 129: zp[1]:2 [ main::i ] 
 Uplift Scope [] 
 
 Uplifting [main] best 311 combination zp[1]:2 [ main::i ] 
@@ -253,7 +253,7 @@ FINAL SYMBOL TABLE
 (label) main::@1
 (label) main::@2
 (label) main::@return
-(byte) main::i loadstore !zp[-1]:2 zp[1]:2 14.25
+(byte) main::i loadstore !zp[-1]:2 zp[1]:2 129.0
 
 zp[1]:2 [ main::i ]
 

src/test/ref/address-1.sym

@@ -6,6 +6,6 @@
 (label) main::@1
 (label) main::@2
 (label) main::@return
-(byte) main::i loadstore !zp[-1]:2 zp[1]:2 14.25
+(byte) main::i loadstore !zp[-1]:2 zp[1]:2 129.0
 
 zp[1]:2 [ main::i ]

src/test/ref/address-2.log

@@ -93,7 +93,7 @@ main::@2: scope:[main]  from main::@1
 
 
 VARIABLE REGISTER WEIGHTS
-(byte) i loadstore !mem[-1]:8192 9.5
+(byte) i loadstore !mem[-1]:8192 84.49999999999999
 (void()) main()
 
 Initial phi equivalence classes
@@ -159,13 +159,13 @@ main: {
   // File Data
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Statement [0] (byte) i ← (byte) 3 [ i ] (  [ i ] ) always clobbers reg byte a 
-Statement [5] if((byte) i<(byte) 7) goto main::@2 [ i ] ( main:2 [ i ] ) always clobbers reg byte a 
-Statement [7] *((const byte*) SCREEN + (byte) i) ← (byte) i [ i ] ( main:2 [ i ] ) always clobbers reg byte a reg byte y 
+Statement [0] (byte) i ← (byte) 3 [ i ] (  [ i ] { }  ) always clobbers reg byte a 
+Statement [5] if((byte) i<(byte) 7) goto main::@2 [ i ] ( main:2 [ i ] { }  ) always clobbers reg byte a 
+Statement [7] *((const byte*) SCREEN + (byte) i) ← (byte) i [ i ] ( main:2 [ i ] { }  ) always clobbers reg byte a reg byte y 
 Potential registers mem[1]:8192 [ i ] : mem[1]:8192 , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [] 9.5: mem[1]:8192 [ i ] 
+Uplift Scope [] 84.5: mem[1]:8192 [ i ] 
 Uplift Scope [main] 
 
 Uplifting [] best 369 combination mem[1]:8192 [ i ] 
@@ -251,7 +251,7 @@ FINAL SYMBOL TABLE
 (label) @begin
 (label) @end
 (const byte*) SCREEN = (byte*) 1024
-(byte) i loadstore !mem[-1]:8192 mem[1]:8192 9.5
+(byte) i loadstore !mem[-1]:8192 mem[1]:8192 84.49999999999999
 (void()) main()
 (label) main::@1
 (label) main::@2

src/test/ref/address-2.sym

@@ -2,7 +2,7 @@
 (label) @begin
 (label) @end
 (const byte*) SCREEN = (byte*) 1024
-(byte) i loadstore !mem[-1]:8192 mem[1]:8192 9.5
+(byte) i loadstore !mem[-1]:8192 mem[1]:8192 84.49999999999999
 (void()) main()
 (label) main::@1
 (label) main::@2

src/test/ref/address-3.log

@@ -94,7 +94,7 @@ main::@2: scope:[main]  from main::@1
 
 VARIABLE REGISTER WEIGHTS
 (void()) main()
-(byte) main::i loadstore !mem[-1]:8192 14.25
+(byte) main::i loadstore !mem[-1]:8192 129.0
 
 Initial phi equivalence classes
 Added variable main::i to live range equivalence class [ main::i ]
@@ -157,13 +157,13 @@ main: {
   // File Data
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Statement [4] (byte) main::i ← (byte) 3 [ main::i ] ( main:2 [ main::i ] ) always clobbers reg byte a 
-Statement [5] if((byte) main::i<(byte) 7) goto main::@2 [ main::i ] ( main:2 [ main::i ] ) always clobbers reg byte a 
-Statement [7] *((const byte*) SCREEN + (byte) main::i) ← (byte) main::i [ main::i ] ( main:2 [ main::i ] ) always clobbers reg byte a reg byte y 
+Statement [4] (byte) main::i ← (byte) 3 [ main::i ] ( main:2 [ main::i ] { }  ) always clobbers reg byte a 
+Statement [5] if((byte) main::i<(byte) 7) goto main::@2 [ main::i ] ( main:2 [ main::i ] { }  ) always clobbers reg byte a 
+Statement [7] *((const byte*) SCREEN + (byte) main::i) ← (byte) main::i [ main::i ] ( main:2 [ main::i ] { }  ) always clobbers reg byte a reg byte y 
 Potential registers mem[1]:8192 [ main::i ] : mem[1]:8192 , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [main] 14.25: mem[1]:8192 [ main::i ] 
+Uplift Scope [main] 129: mem[1]:8192 [ main::i ] 
 Uplift Scope [] 
 
 Uplifting [main] best 342 combination mem[1]:8192 [ main::i ] 
@@ -253,7 +253,7 @@ FINAL SYMBOL TABLE
 (label) main::@1
 (label) main::@2
 (label) main::@return
-(byte) main::i loadstore !mem[-1]:8192 mem[1]:8192 14.25
+(byte) main::i loadstore !mem[-1]:8192 mem[1]:8192 129.0
 
 mem[1]:8192 [ main::i ]
 

src/test/ref/address-3.sym

@@ -6,6 +6,6 @@
 (label) main::@1
 (label) main::@2
 (label) main::@return
-(byte) main::i loadstore !mem[-1]:8192 mem[1]:8192 14.25
+(byte) main::i loadstore !mem[-1]:8192 mem[1]:8192 129.0
 
 mem[1]:8192 [ main::i ]

src/test/ref/address-4.log

@@ -114,9 +114,9 @@ main::@2: scope:[main]  from main::@1
 
 VARIABLE REGISTER WEIGHTS
 (void()) main()
-(byte~) main::$1 22.0
-(byte~) main::$2 22.0
-(byte) main::i loadstore !zp[-1]:2 9.875
+(byte~) main::$1 202.0
+(byte~) main::$2 202.0
+(byte) main::i loadstore !zp[-1]:2 89.75
 
 Initial phi equivalence classes
 Added variable main::i to live range equivalence class [ main::i ]
@@ -206,18 +206,18 @@ main: {
   // File Data
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Statement [4] (byte) main::i ← (byte) 0 [ main::i ] ( main:2 [ main::i ] ) always clobbers reg byte a 
-Statement [5] if((byte) main::i<(byte) 8) goto main::@2 [ main::i ] ( main:2 [ main::i ] ) always clobbers reg byte a 
-Statement [7] (byte~) main::$1 ← (byte) main::i << (byte) 1 [ main::i main::$1 ] ( main:2 [ main::i main::$1 ] ) always clobbers reg byte a 
-Statement [8] *((const word*) SCREEN + (byte~) main::$1) ← (const word) main::ch [ main::i ] ( main:2 [ main::i ] ) always clobbers reg byte a 
-Statement [10] (byte~) main::$2 ← (byte) main::i << (byte) 1 [ main::i main::$2 ] ( main:2 [ main::i main::$2 ] ) always clobbers reg byte a 
-Statement [11] *((const word*) SCREEN + (byte~) main::$2) ← (const word) main::ch [ main::i ] ( main:2 [ main::i ] ) always clobbers reg byte a 
+Statement [4] (byte) main::i ← (byte) 0 [ main::i ] ( main:2 [ main::i ] { }  ) always clobbers reg byte a 
+Statement [5] if((byte) main::i<(byte) 8) goto main::@2 [ main::i ] ( main:2 [ main::i ] { }  ) always clobbers reg byte a 
+Statement [7] (byte~) main::$1 ← (byte) main::i << (byte) 1 [ main::i main::$1 ] ( main:2 [ main::i main::$1 ] { }  ) always clobbers reg byte a 
+Statement [8] *((const word*) SCREEN + (byte~) main::$1) ← (const word) main::ch [ main::i ] ( main:2 [ main::i ] { }  ) always clobbers reg byte a 
+Statement [10] (byte~) main::$2 ← (byte) main::i << (byte) 1 [ main::i main::$2 ] ( main:2 [ main::i main::$2 ] { }  ) always clobbers reg byte a 
+Statement [11] *((const word*) SCREEN + (byte~) main::$2) ← (const word) main::ch [ main::i ] ( main:2 [ main::i ] { }  ) always clobbers reg byte a 
 Potential registers zp[1]:2 [ main::i ] : zp[1]:2 , 
 Potential registers zp[1]:3 [ main::$1 ] : zp[1]:3 , reg byte a , reg byte x , reg byte y , 
 Potential registers zp[1]:4 [ main::$2 ] : zp[1]:4 , reg byte a , reg byte x , reg byte y , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [main] 22: zp[1]:3 [ main::$1 ] 22: zp[1]:4 [ main::$2 ] 9.88: zp[1]:2 [ main::i ] 
+Uplift Scope [main] 202: zp[1]:3 [ main::$1 ] 202: zp[1]:4 [ main::$2 ] 89.75: zp[1]:2 [ main::i ] 
 Uplift Scope [] 
 
 Uplifting [main] best 681 combination reg byte a [ main::$1 ] reg byte a [ main::$2 ] zp[1]:2 [ main::i ] 
@@ -321,13 +321,13 @@ FINAL SYMBOL TABLE
 (label) @end
 (const word*) SCREEN = (word*) 1024
 (void()) main()
-(byte~) main::$1 reg byte a 22.0
-(byte~) main::$2 reg byte a 22.0
+(byte~) main::$1 reg byte a 202.0
+(byte~) main::$2 reg byte a 202.0
 (label) main::@1
 (label) main::@2
 (label) main::@return
 (const word) main::ch = (word) $102
-(byte) main::i loadstore !zp[-1]:2 zp[1]:2 9.875
+(byte) main::i loadstore !zp[-1]:2 zp[1]:2 89.75
 
 zp[1]:2 [ main::i ]
 reg byte a [ main::$1 ]

src/test/ref/address-4.sym

@@ -3,13 +3,13 @@
 (label) @end
 (const word*) SCREEN = (word*) 1024
 (void()) main()
-(byte~) main::$1 reg byte a 22.0
-(byte~) main::$2 reg byte a 22.0
+(byte~) main::$1 reg byte a 202.0
+(byte~) main::$2 reg byte a 202.0
 (label) main::@1
 (label) main::@2
 (label) main::@return
 (const word) main::ch = (word) $102
-(byte) main::i loadstore !zp[-1]:2 zp[1]:2 9.875
+(byte) main::i loadstore !zp[-1]:2 zp[1]:2 89.75
 
 zp[1]:2 [ main::i ]
 reg byte a [ main::$1 ]

src/test/ref/address-5.log

@@ -119,7 +119,7 @@ VARIABLE REGISTER WEIGHTS
 (byte) idx loadstore !zp[-1]:3 0.2222222222222222
 (void()) main()
 (void()) print((byte) print::ch)
-(byte) print::ch loadstore !zp[-1]:2 2.0
+(byte) print::ch loadstore !zp[-1]:2 11.0
 
 Initial phi equivalence classes
 Added variable idx to live range equivalence class [ idx ]
@@ -207,16 +207,16 @@ print: {
   // File Data
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Statement [1] (byte) idx ← (byte) 0 [ idx ] (  [ idx ] ) always clobbers reg byte a 
-Statement [5] (byte) print::ch ← (byte) 'c' [ idx print::ch ] ( main:3 [ idx print::ch ] ) always clobbers reg byte a 
-Statement [7] (byte) print::ch ← (byte) 'm' [ idx print::ch ] ( main:3 [ idx print::ch ] ) always clobbers reg byte a 
-Statement [9] (byte) print::ch ← (byte) 'l' [ idx print::ch ] ( main:3 [ idx print::ch ] ) always clobbers reg byte a 
+Statement [1] (byte) idx ← (byte) 0 [ idx ] (  [ idx ] { }  ) always clobbers reg byte a 
+Statement [5] (byte) print::ch ← (byte) 'c' [ idx print::ch ] ( main:3 [ idx print::ch ] { }  ) always clobbers reg byte a 
+Statement [7] (byte) print::ch ← (byte) 'm' [ idx print::ch ] ( main:3 [ idx print::ch ] { }  ) always clobbers reg byte a 
+Statement [9] (byte) print::ch ← (byte) 'l' [ idx print::ch ] ( main:3 [ idx print::ch ] { }  ) always clobbers reg byte a 
 Statement asm { ldxidx ldach staSCREEN,x incidx  } always clobbers reg byte a reg byte x 
 Potential registers zp[1]:3 [ idx ] : zp[1]:3 , 
 Potential registers zp[1]:2 [ print::ch ] : zp[1]:2 , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [print] 2: zp[1]:2 [ print::ch ] 
+Uplift Scope [print] 11: zp[1]:2 [ print::ch ] 
 Uplift Scope [] 0.22: zp[1]:3 [ idx ] 
 Uplift Scope [main] 
 
@@ -341,7 +341,7 @@ FINAL SYMBOL TABLE
 (label) main::@return
 (void()) print((byte) print::ch)
 (label) print::@return
-(byte) print::ch loadstore !zp[-1]:2 zp[1]:2 2.0
+(byte) print::ch loadstore !zp[-1]:2 zp[1]:2 11.0
 
 zp[1]:3 [ idx ]
 zp[1]:2 [ print::ch ]

src/test/ref/address-5.sym

@@ -10,7 +10,7 @@
 (label) main::@return
 (void()) print((byte) print::ch)
 (label) print::@return
-(byte) print::ch loadstore !zp[-1]:2 zp[1]:2 2.0
+(byte) print::ch loadstore !zp[-1]:2 zp[1]:2 11.0
 
 zp[1]:3 [ idx ]
 zp[1]:2 [ print::ch ]

src/test/ref/address-6.log

@@ -119,7 +119,7 @@ VARIABLE REGISTER WEIGHTS
 (byte) idx loadstore !mem[-1]:12288 0.2222222222222222
 (void()) main()
 (void()) print((byte) print::ch)
-(byte) print::ch loadstore !mem[-1]:12289 2.0
+(byte) print::ch loadstore !mem[-1]:12289 11.0
 
 Initial phi equivalence classes
 Added variable idx to live range equivalence class [ idx ]
@@ -207,16 +207,16 @@ print: {
   // File Data
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Statement [1] (byte) idx ← (byte) 0 [ idx ] (  [ idx ] ) always clobbers reg byte a 
-Statement [5] (byte) print::ch ← (byte) 'c' [ idx print::ch ] ( main:3 [ idx print::ch ] ) always clobbers reg byte a 
-Statement [7] (byte) print::ch ← (byte) 'm' [ idx print::ch ] ( main:3 [ idx print::ch ] ) always clobbers reg byte a 
-Statement [9] (byte) print::ch ← (byte) 'l' [ idx print::ch ] ( main:3 [ idx print::ch ] ) always clobbers reg byte a 
+Statement [1] (byte) idx ← (byte) 0 [ idx ] (  [ idx ] { }  ) always clobbers reg byte a 
+Statement [5] (byte) print::ch ← (byte) 'c' [ idx print::ch ] ( main:3 [ idx print::ch ] { }  ) always clobbers reg byte a 
+Statement [7] (byte) print::ch ← (byte) 'm' [ idx print::ch ] ( main:3 [ idx print::ch ] { }  ) always clobbers reg byte a 
+Statement [9] (byte) print::ch ← (byte) 'l' [ idx print::ch ] ( main:3 [ idx print::ch ] { }  ) always clobbers reg byte a 
 Statement asm { ldxidx ldach staSCREEN,x incidx  } always clobbers reg byte a reg byte x 
 Potential registers mem[1]:12288 [ idx ] : mem[1]:12288 , 
 Potential registers mem[1]:12289 [ print::ch ] : mem[1]:12289 , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [print] 2: mem[1]:12289 [ print::ch ] 
+Uplift Scope [print] 11: mem[1]:12289 [ print::ch ] 
 Uplift Scope [] 0.22: mem[1]:12288 [ idx ] 
 Uplift Scope [main] 
 
@@ -341,7 +341,7 @@ FINAL SYMBOL TABLE
 (label) main::@return
 (void()) print((byte) print::ch)
 (label) print::@return
-(byte) print::ch loadstore !mem[-1]:12289 mem[1]:12289 2.0
+(byte) print::ch loadstore !mem[-1]:12289 mem[1]:12289 11.0
 
 mem[1]:12288 [ idx ]
 mem[1]:12289 [ print::ch ]

src/test/ref/address-6.sym

@@ -10,7 +10,7 @@
 (label) main::@return
 (void()) print((byte) print::ch)
 (label) print::@return
-(byte) print::ch loadstore !mem[-1]:12289 mem[1]:12289 2.0
+(byte) print::ch loadstore !mem[-1]:12289 mem[1]:12289 11.0
 
 mem[1]:12288 [ idx ]
 mem[1]:12289 [ print::ch ]

src/test/ref/address-of-0.log

@@ -54,7 +54,7 @@ Successful SSA optimization PassNCastSimplification
 Finalized unsigned number type (byte) 1
 Successful SSA optimization PassNFinalizeNumberTypeConversions
 Inferred type updated to byte in (unumber~) main::$0 ← *((const byte*) main::bp) + (byte) 1
-Alias (byte) main::c#0 = (byte~) main::$0 
+Alias main::c#0 = main::$0 
 Successful SSA optimization Pass2AliasElimination
 Simple Condition (bool~) main::$1 [5] if((byte) main::b!=rangelast(0,$a)) goto main::@1
 Successful SSA optimization Pass2ConditionalJumpSimplification
@@ -108,9 +108,9 @@ main::@return: scope:[main]  from main::@1
 
 VARIABLE REGISTER WEIGHTS
 (void()) main()
-(byte) main::b loadstore 9.200000000000001
+(byte) main::b loadstore 83.0
 (byte) main::c
-(byte) main::c#0 22.0
+(byte) main::c#0 202.0
 
 Initial phi equivalence classes
 Added variable main::b to live range equivalence class [ main::b ]
@@ -179,14 +179,14 @@ main: {
   // File Data
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Statement [4] (byte) main::b ← (byte) 0 [ main::b ] ( main:2 [ main::b ] ) always clobbers reg byte a 
-Statement [6] *((const byte*) main::SCREEN + (byte) main::b) ← (byte) main::c#0 [ main::b ] ( main:2 [ main::b ] ) always clobbers reg byte y 
-Statement [8] if((byte) main::b!=(byte) $b) goto main::@1 [ main::b ] ( main:2 [ main::b ] ) always clobbers reg byte a 
+Statement [4] (byte) main::b ← (byte) 0 [ main::b ] ( main:2 [ main::b ] { }  ) always clobbers reg byte a 
+Statement [6] *((const byte*) main::SCREEN + (byte) main::b) ← (byte) main::c#0 [ main::b ] ( main:2 [ main::b ] { }  ) always clobbers reg byte y 
+Statement [8] if((byte) main::b!=(byte) $b) goto main::@1 [ main::b ] ( main:2 [ main::b ] { }  ) always clobbers reg byte a 
 Potential registers zp[1]:2 [ main::b ] : zp[1]:2 , 
 Potential registers zp[1]:3 [ main::c#0 ] : zp[1]:3 , reg byte a , reg byte x , reg byte y , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [main] 22: zp[1]:3 [ main::c#0 ] 9.2: zp[1]:2 [ main::b ] 
+Uplift Scope [main] 202: zp[1]:3 [ main::c#0 ] 83: zp[1]:2 [ main::b ] 
 Uplift Scope [] 
 
 Uplifting [main] best 331 combination reg byte a [ main::c#0 ] zp[1]:2 [ main::b ] 
@@ -275,10 +275,10 @@ FINAL SYMBOL TABLE
 (label) main::@1
 (label) main::@return
 (const byte*) main::SCREEN = (byte*) 1024
-(byte) main::b loadstore zp[1]:2 9.200000000000001
+(byte) main::b loadstore zp[1]:2 83.0
 (const byte*) main::bp = &(byte) main::b
 (byte) main::c
-(byte) main::c#0 reg byte a 22.0
+(byte) main::c#0 reg byte a 202.0
 
 zp[1]:2 [ main::b ]
 reg byte a [ main::c#0 ]

src/test/ref/address-of-0.sym

@@ -5,10 +5,10 @@
 (label) main::@1
 (label) main::@return
 (const byte*) main::SCREEN = (byte*) 1024
-(byte) main::b loadstore zp[1]:2 9.200000000000001
+(byte) main::b loadstore zp[1]:2 83.0
 (const byte*) main::bp = &(byte) main::b
 (byte) main::c
-(byte) main::c#0 reg byte a 22.0
+(byte) main::c#0 reg byte a 202.0
 
 zp[1]:2 [ main::b ]
 reg byte a [ main::c#0 ]

src/test/ref/address-of-1.log

@@ -185,14 +185,14 @@ setByte::@return: scope:[setByte]  from setByte
 
 VARIABLE REGISTER WEIGHTS
 (void()) main()
-(byte) main::b1 loadstore 0.36363636363636365
-(byte) main::b2 loadstore 0.36363636363636365
-(byte) main::b3 loadstore 0.36363636363636365
+(byte) main::b1 loadstore 2.0
+(byte) main::b2 loadstore 2.0
+(byte) main::b3 loadstore 2.0
 (void()) setByte((byte*) setByte::ptr , (byte) setByte::b)
 (byte) setByte::b
-(byte) setByte::b#3 2.0
+(byte) setByte::b#3 101.0
 (byte*) setByte::ptr
-(byte*) setByte::ptr#3 2.0
+(byte*) setByte::ptr#3 101.0
 
 Initial phi equivalence classes
 [ setByte::b#3 ]
@@ -332,13 +332,13 @@ setByte: {
   // File Data
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Statement [4] (byte) main::b1 ← (byte) 0 [ main::b1 ] ( main:2 [ main::b1 ] ) always clobbers reg byte a 
-Statement [5] (byte) main::b2 ← (byte) 0 [ main::b1 main::b2 ] ( main:2 [ main::b1 main::b2 ] ) always clobbers reg byte a 
-Statement [6] (byte) main::b3 ← (byte) 0 [ main::b1 main::b2 main::b3 ] ( main:2 [ main::b1 main::b2 main::b3 ] ) always clobbers reg byte a 
-Statement [12] *((const byte*) main::SCREEN) ← (byte) main::b1 [ main::b2 main::b3 ] ( main:2 [ main::b2 main::b3 ] ) always clobbers reg byte a 
-Statement [13] *((const byte*) main::SCREEN+(byte) 1) ← (byte) main::b2 [ main::b3 ] ( main:2 [ main::b3 ] ) always clobbers reg byte a 
-Statement [14] *((const byte*) main::SCREEN+(byte) 2) ← (byte) main::b3 [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [17] *((byte*) setByte::ptr#3) ← (byte) setByte::b#3 [ main::b1 main::b2 main::b3 ] ( main:2::setByte:7 [ main::b1 main::b2 main::b3 ] main:2::setByte:9 [ main::b1 main::b2 main::b3 ] main:2::setByte:11 [ main::b1 main::b2 main::b3 ] ) always clobbers reg byte y 
+Statement [4] (byte) main::b1 ← (byte) 0 [ main::b1 ] ( main:2 [ main::b1 ] { }  ) always clobbers reg byte a 
+Statement [5] (byte) main::b2 ← (byte) 0 [ main::b1 main::b2 ] ( main:2 [ main::b1 main::b2 ] { }  ) always clobbers reg byte a 
+Statement [6] (byte) main::b3 ← (byte) 0 [ main::b1 main::b2 main::b3 ] ( main:2 [ main::b1 main::b2 main::b3 ] { }  ) always clobbers reg byte a 
+Statement [12] *((const byte*) main::SCREEN) ← (byte) main::b1 [ main::b2 main::b3 ] ( main:2 [ main::b2 main::b3 ] { }  ) always clobbers reg byte a 
+Statement [13] *((const byte*) main::SCREEN+(byte) 1) ← (byte) main::b2 [ main::b3 ] ( main:2 [ main::b3 ] { }  ) always clobbers reg byte a 
+Statement [14] *((const byte*) main::SCREEN+(byte) 2) ← (byte) main::b3 [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [17] *((byte*) setByte::ptr#3) ← (byte) setByte::b#3 [ main::b1 main::b2 main::b3 ] ( main:2::setByte:7 [ main::b1 main::b2 main::b3 ] { }  main:2::setByte:9 [ main::b1 main::b2 main::b3 ] { }  main:2::setByte:11 [ main::b1 main::b2 main::b3 ] { }  ) always clobbers reg byte y 
 Potential registers zp[1]:2 [ setByte::b#3 ] : zp[1]:2 , reg byte a , reg byte x , reg byte y , 
 Potential registers zp[2]:3 [ setByte::ptr#3 ] : zp[2]:3 , 
 Potential registers zp[1]:5 [ main::b1 ] : zp[1]:5 , 
@@ -346,8 +346,8 @@ Potential registers zp[1]:6 [ main::b2 ] : zp[1]:6 ,
 Potential registers zp[1]:7 [ main::b3 ] : zp[1]:7 , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [setByte] 2: zp[1]:2 [ setByte::b#3 ] 2: zp[2]:3 [ setByte::ptr#3 ] 
-Uplift Scope [main] 0.36: zp[1]:5 [ main::b1 ] 0.36: zp[1]:6 [ main::b2 ] 0.36: zp[1]:7 [ main::b3 ] 
+Uplift Scope [setByte] 101: zp[1]:2 [ setByte::b#3 ] 101: zp[2]:3 [ setByte::ptr#3 ] 
+Uplift Scope [main] 2: zp[1]:5 [ main::b1 ] 2: zp[1]:6 [ main::b2 ] 2: zp[1]:7 [ main::b3 ] 
 Uplift Scope [] 
 
 Uplifting [setByte] best 139 combination reg byte x [ setByte::b#3 ] zp[2]:3 [ setByte::ptr#3 ] 
@@ -522,15 +522,15 @@ FINAL SYMBOL TABLE
 (label) main::@3
 (label) main::@return
 (const byte*) main::SCREEN = (byte*) 1024
-(byte) main::b1 loadstore zp[1]:4 0.36363636363636365
-(byte) main::b2 loadstore zp[1]:5 0.36363636363636365
-(byte) main::b3 loadstore zp[1]:6 0.36363636363636365
+(byte) main::b1 loadstore zp[1]:4 2.0
+(byte) main::b2 loadstore zp[1]:5 2.0
+(byte) main::b3 loadstore zp[1]:6 2.0
 (void()) setByte((byte*) setByte::ptr , (byte) setByte::b)
 (label) setByte::@return
 (byte) setByte::b
-(byte) setByte::b#3 reg byte x 2.0
+(byte) setByte::b#3 reg byte x 101.0
 (byte*) setByte::ptr
-(byte*) setByte::ptr#3 ptr zp[2]:2 2.0
+(byte*) setByte::ptr#3 ptr zp[2]:2 101.0
 
 reg byte x [ setByte::b#3 ]
 zp[2]:2 [ setByte::ptr#3 ]

src/test/ref/address-of-1.sym

@@ -7,15 +7,15 @@
 (label) main::@3
 (label) main::@return
 (const byte*) main::SCREEN = (byte*) 1024
-(byte) main::b1 loadstore zp[1]:4 0.36363636363636365
-(byte) main::b2 loadstore zp[1]:5 0.36363636363636365
-(byte) main::b3 loadstore zp[1]:6 0.36363636363636365
+(byte) main::b1 loadstore zp[1]:4 2.0
+(byte) main::b2 loadstore zp[1]:5 2.0
+(byte) main::b3 loadstore zp[1]:6 2.0
 (void()) setByte((byte*) setByte::ptr , (byte) setByte::b)
 (label) setByte::@return
 (byte) setByte::b
-(byte) setByte::b#3 reg byte x 2.0
+(byte) setByte::b#3 reg byte x 101.0
 (byte*) setByte::ptr
-(byte*) setByte::ptr#3 ptr zp[2]:2 2.0
+(byte*) setByte::ptr#3 ptr zp[2]:2 101.0
 
 reg byte x [ setByte::b#3 ]
 zp[2]:2 [ setByte::ptr#3 ]

src/test/ref/address-of-2.log

@@ -138,8 +138,8 @@ Finalized unsigned number type (byte) 3
 Finalized unsigned number type (byte) 4
 Finalized unsigned number type (byte) 5
 Successful SSA optimization PassNFinalizeNumberTypeConversions
-Alias (byte) main::idx#4 = (byte) main::idx#7 
-Alias (byte) main::idx#5 = (byte) main::idx#8 
+Alias main::idx#4 = main::idx#7 
+Alias main::idx#5 = main::idx#8 
 Successful SSA optimization Pass2AliasElimination
 Identical Phi Values (byte) setv::v#1 (byte) setv::v#0
 Identical Phi Values (byte) setp::v#1 (byte) setp::v#0
@@ -294,7 +294,7 @@ VARIABLE REGISTER WEIGHTS
 (byte) setp::v
 (void()) setv((byte) setv::v)
 (byte) setv::v
-(byte) val loadstore 1.5384615384615383
+(byte) val loadstore 14.692307692307692
 
 Initial phi equivalence classes
 Added variable val to live range equivalence class [ val ]
@@ -428,28 +428,28 @@ setv: {
   // File Data
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Statement [0] (byte) val ← (byte) 0 [ val ] (  [ val ] ) always clobbers reg byte a 
-Statement [4] *((const byte*) main::SCREEN1) ← (byte) val [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [5] *((const byte*) main::SCREEN2) ← (byte) '.' [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [6] (byte) val ← (byte) 1 [ val ] ( main:2 [ val ] ) always clobbers reg byte a 
-Statement [7] *((const byte*) main::SCREEN1+(byte) 1) ← (byte) val [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [8] *((const byte*) main::SCREEN2+(byte) 1) ← (byte) '.' [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [9] (byte) val ← (byte) 2 [ val ] ( main:2 [ val ] ) always clobbers reg byte a 
-Statement [10] *((const byte*) main::SCREEN1+(byte) 2) ← (byte) val [ val ] ( main:2 [ val ] ) always clobbers reg byte a 
-Statement [11] *((const byte*) main::SCREEN2+(byte) 2) ← *((const byte*) main::ptr) [ val ] ( main:2 [ val ] ) always clobbers reg byte a 
-Statement [12] *((const byte*) main::ptr) ← (byte) 3 [ val ] ( main:2 [ val ] ) always clobbers reg byte a 
-Statement [13] *((const byte*) main::SCREEN1+(byte) 3) ← (byte) val [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [14] *((const byte*) main::SCREEN2+(byte) 3) ← *((const byte*) main::ptr) [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [16] *((const byte*) main::SCREEN1+(byte) 4) ← (byte) val [ val ] ( main:2 [ val ] ) always clobbers reg byte a 
-Statement [17] *((const byte*) main::SCREEN2+(byte) 4) ← *((const byte*) main::ptr) [ val ] ( main:2 [ val ] ) always clobbers reg byte a 
-Statement [19] *((const byte*) main::SCREEN1+(byte) 5) ← (byte) val [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [20] *((const byte*) main::SCREEN2+(byte) 5) ← *((const byte*) main::ptr) [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [22] *((const byte*) main::ptr) ← (const byte) setp::v#0 [ ] ( main:2::setp:18 [ val ] ) always clobbers reg byte a 
-Statement [24] (byte) val ← (const byte) setv::v#0 [ val ] ( main:2::setv:15 [ val ] ) always clobbers reg byte a 
+Statement [0] (byte) val ← (byte) 0 [ val ] (  [ val ] { }  ) always clobbers reg byte a 
+Statement [4] *((const byte*) main::SCREEN1) ← (byte) val [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [5] *((const byte*) main::SCREEN2) ← (byte) '.' [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [6] (byte) val ← (byte) 1 [ val ] ( main:2 [ val ] { }  ) always clobbers reg byte a 
+Statement [7] *((const byte*) main::SCREEN1+(byte) 1) ← (byte) val [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [8] *((const byte*) main::SCREEN2+(byte) 1) ← (byte) '.' [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [9] (byte) val ← (byte) 2 [ val ] ( main:2 [ val ] { }  ) always clobbers reg byte a 
+Statement [10] *((const byte*) main::SCREEN1+(byte) 2) ← (byte) val [ val ] ( main:2 [ val ] { }  ) always clobbers reg byte a 
+Statement [11] *((const byte*) main::SCREEN2+(byte) 2) ← *((const byte*) main::ptr) [ val ] ( main:2 [ val ] { }  ) always clobbers reg byte a 
+Statement [12] *((const byte*) main::ptr) ← (byte) 3 [ val ] ( main:2 [ val ] { }  ) always clobbers reg byte a 
+Statement [13] *((const byte*) main::SCREEN1+(byte) 3) ← (byte) val [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [14] *((const byte*) main::SCREEN2+(byte) 3) ← *((const byte*) main::ptr) [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [16] *((const byte*) main::SCREEN1+(byte) 4) ← (byte) val [ val ] ( main:2 [ val ] { }  ) always clobbers reg byte a 
+Statement [17] *((const byte*) main::SCREEN2+(byte) 4) ← *((const byte*) main::ptr) [ val ] ( main:2 [ val ] { }  ) always clobbers reg byte a 
+Statement [19] *((const byte*) main::SCREEN1+(byte) 5) ← (byte) val [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [20] *((const byte*) main::SCREEN2+(byte) 5) ← *((const byte*) main::ptr) [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [22] *((const byte*) main::ptr) ← (const byte) setp::v#0 [ ] ( main:2::setp:18 [ val ] { }  ) always clobbers reg byte a 
+Statement [24] (byte) val ← (const byte) setv::v#0 [ val ] ( main:2::setv:15 [ val ] { }  ) always clobbers reg byte a 
 Potential registers zp[1]:2 [ val ] : zp[1]:2 , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [] 1.54: zp[1]:2 [ val ] 
+Uplift Scope [] 14.69: zp[1]:2 [ val ] 
 Uplift Scope [main] 
 Uplift Scope [setv] 
 Uplift Scope [setp] 
@@ -632,7 +632,7 @@ FINAL SYMBOL TABLE
 (label) setv::@return
 (byte) setv::v
 (const byte) setv::v#0 v = (byte) 4
-(byte) val loadstore zp[1]:2 1.5384615384615383
+(byte) val loadstore zp[1]:2 14.692307692307692
 
 zp[1]:2 [ val ]
 

src/test/ref/address-of-2.sym

@@ -18,6 +18,6 @@
 (label) setv::@return
 (byte) setv::v
 (const byte) setv::v#0 v = (byte) 4
-(byte) val loadstore zp[1]:2 1.5384615384615383
+(byte) val loadstore zp[1]:2 14.692307692307692
 
 zp[1]:2 [ val ]

src/test/ref/address-of-3.log

@@ -132,14 +132,14 @@ Simplifying constant integer cast 1
 Successful SSA optimization PassNCastSimplification
 Finalized unsigned number type (byte) 1
 Successful SSA optimization PassNFinalizeNumberTypeConversions
-Alias (byte) idx#0 = (byte) idx#8 
-Alias (byte) idx#1 = (byte) idx#9 
-Alias (signed word*) print::p#2 = (signed word*~) main::$2 
-Alias (byte) main::i#2 = (byte) main::i#3 
-Alias (byte) idx#10 = (byte) idx#2 (byte) idx#11 (byte) idx#3 
-Alias (byte) idx#13 = (byte) idx#5 (byte) idx#6 
-Alias (byte) idx#17 = (byte) idx#4 
-Alias (byte) idx#14 = (byte) idx#7 
+Alias idx#0 = idx#8 
+Alias idx#1 = idx#9 
+Alias print::p#2 = main::$2 
+Alias main::i#2 = main::i#3 
+Alias idx#10 = idx#2 idx#11 idx#3 
+Alias idx#13 = idx#5 idx#6 
+Alias idx#17 = idx#4 
+Alias idx#14 = idx#7 
 Successful SSA optimization Pass2AliasElimination
 Identical Phi Values (byte) idx#15 (byte) idx#17
 Identical Phi Values (byte) idx#0 (byte) idx#13
@@ -258,18 +258,18 @@ print::@return: scope:[print]  from print
 
 VARIABLE REGISTER WEIGHTS
 (byte) idx
-(byte) idx#12 5.666666666666667
-(byte) idx#13 1.3636363636363638
+(byte) idx#12 704.6666666666667
+(byte) idx#13 101.18181818181819
 (void()) main()
-(byte~) main::$5 22.0
+(byte~) main::$5 202.0
 (byte) main::i
-(byte) main::i#1 16.5
-(byte) main::i#2 8.25
+(byte) main::i#1 151.5
+(byte) main::i#2 75.75
 (void()) print((signed word*) print::p)
-(byte~) print::$0 4.0
+(byte~) print::$0 2002.0
 (signed word*) print::p
-(signed word*) print::p#2 22.0
-(signed word*) print::p#3 6.5
+(signed word*) print::p#2 202.0
+(signed word*) print::p#3 551.0
 
 Initial phi equivalence classes
 [ main::i#2 main::i#1 ]
@@ -422,18 +422,18 @@ print: {
   VALS: .word 1, 2, 3, 4
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Statement [9] (byte~) main::$5 ← (byte) main::i#2 << (byte) 1 [ main::i#2 main::$5 idx#13 ] ( main:2 [ main::i#2 main::$5 idx#13 ] ) always clobbers reg byte a 
+Statement [9] (byte~) main::$5 ← (byte) main::i#2 << (byte) 1 [ main::i#2 main::$5 idx#13 ] ( main:2 [ main::i#2 main::$5 idx#13 ] { { idx#12 = idx#13 } { print::p#2 = print::p#3 } }  ) always clobbers reg byte a 
 Removing always clobbered register reg byte a as potential for zp[1]:2 [ main::i#2 main::i#1 ]
 Removing always clobbered register reg byte a as potential for zp[1]:3 [ idx#12 idx#13 ]
-Statement [10] (signed word*) print::p#2 ← (const signed word*) VALS + (byte~) main::$5 [ main::i#2 print::p#2 idx#13 ] ( main:2 [ main::i#2 print::p#2 idx#13 ] ) always clobbers reg byte a 
-Statement [16] (byte~) print::$0 ← (byte) idx#12 << (byte) 1 [ idx#12 print::p#3 print::$0 ] ( main:2::print:5 [ idx#12 print::p#3 print::$0 ] main:2::print:7 [ idx#12 print::p#3 print::$0 ] main:2::print:11 [ main::i#2 idx#12 print::p#3 print::$0 ] ) always clobbers reg byte a 
-Statement [17] *((const signed word*) SCREEN + (byte~) print::$0) ← *((signed word*) print::p#3) [ idx#12 ] ( main:2::print:5 [ idx#12 ] main:2::print:7 [ idx#12 ] main:2::print:11 [ main::i#2 idx#12 ] ) always clobbers reg byte a reg byte y 
+Statement [10] (signed word*) print::p#2 ← (const signed word*) VALS + (byte~) main::$5 [ main::i#2 print::p#2 idx#13 ] ( main:2 [ main::i#2 print::p#2 idx#13 ] { { idx#12 = idx#13 } { print::p#2 = print::p#3 } }  ) always clobbers reg byte a 
+Statement [16] (byte~) print::$0 ← (byte) idx#12 << (byte) 1 [ idx#12 print::p#3 print::$0 ] ( main:2::print:5 [ idx#12 print::p#3 print::$0 ] { }  main:2::print:7 [ idx#12 print::p#3 print::$0 ] { { idx#12 = idx#13 } }  main:2::print:11 [ main::i#2 idx#12 print::p#3 print::$0 ] { { idx#12 = idx#13 } { print::p#2 = print::p#3 } }  ) always clobbers reg byte a 
+Statement [17] *((const signed word*) SCREEN + (byte~) print::$0) ← *((signed word*) print::p#3) [ idx#12 ] ( main:2::print:5 [ idx#12 ] { }  main:2::print:7 [ idx#12 ] { { idx#12 = idx#13 } }  main:2::print:11 [ main::i#2 idx#12 ] { { idx#12 = idx#13 } { print::p#2 = print::p#3 } }  ) always clobbers reg byte a reg byte y 
 Removing always clobbered register reg byte y as potential for zp[1]:3 [ idx#12 idx#13 ]
 Removing always clobbered register reg byte y as potential for zp[1]:2 [ main::i#2 main::i#1 ]
-Statement [9] (byte~) main::$5 ← (byte) main::i#2 << (byte) 1 [ main::i#2 main::$5 idx#13 ] ( main:2 [ main::i#2 main::$5 idx#13 ] ) always clobbers reg byte a 
-Statement [10] (signed word*) print::p#2 ← (const signed word*) VALS + (byte~) main::$5 [ main::i#2 print::p#2 idx#13 ] ( main:2 [ main::i#2 print::p#2 idx#13 ] ) always clobbers reg byte a 
-Statement [16] (byte~) print::$0 ← (byte) idx#12 << (byte) 1 [ idx#12 print::p#3 print::$0 ] ( main:2::print:5 [ idx#12 print::p#3 print::$0 ] main:2::print:7 [ idx#12 print::p#3 print::$0 ] main:2::print:11 [ main::i#2 idx#12 print::p#3 print::$0 ] ) always clobbers reg byte a 
-Statement [17] *((const signed word*) SCREEN + (byte~) print::$0) ← *((signed word*) print::p#3) [ idx#12 ] ( main:2::print:5 [ idx#12 ] main:2::print:7 [ idx#12 ] main:2::print:11 [ main::i#2 idx#12 ] ) always clobbers reg byte a reg byte y 
+Statement [9] (byte~) main::$5 ← (byte) main::i#2 << (byte) 1 [ main::i#2 main::$5 idx#13 ] ( main:2 [ main::i#2 main::$5 idx#13 ] { { idx#12 = idx#13 } { print::p#2 = print::p#3 } }  ) always clobbers reg byte a 
+Statement [10] (signed word*) print::p#2 ← (const signed word*) VALS + (byte~) main::$5 [ main::i#2 print::p#2 idx#13 ] ( main:2 [ main::i#2 print::p#2 idx#13 ] { { idx#12 = idx#13 } { print::p#2 = print::p#3 } }  ) always clobbers reg byte a 
+Statement [16] (byte~) print::$0 ← (byte) idx#12 << (byte) 1 [ idx#12 print::p#3 print::$0 ] ( main:2::print:5 [ idx#12 print::p#3 print::$0 ] { }  main:2::print:7 [ idx#12 print::p#3 print::$0 ] { { idx#12 = idx#13 } }  main:2::print:11 [ main::i#2 idx#12 print::p#3 print::$0 ] { { idx#12 = idx#13 } { print::p#2 = print::p#3 } }  ) always clobbers reg byte a 
+Statement [17] *((const signed word*) SCREEN + (byte~) print::$0) ← *((signed word*) print::p#3) [ idx#12 ] ( main:2::print:5 [ idx#12 ] { }  main:2::print:7 [ idx#12 ] { { idx#12 = idx#13 } }  main:2::print:11 [ main::i#2 idx#12 ] { { idx#12 = idx#13 } { print::p#2 = print::p#3 } }  ) always clobbers reg byte a reg byte y 
 Potential registers zp[1]:2 [ main::i#2 main::i#1 ] : zp[1]:2 , reg byte x , 
 Potential registers zp[1]:3 [ idx#12 idx#13 ] : zp[1]:3 , reg byte x , 
 Potential registers zp[2]:4 [ print::p#3 print::p#2 ] : zp[2]:4 , 
@@ -441,17 +441,17 @@ Potential registers zp[1]:6 [ main::$5 ] : zp[1]:6 , reg byte a , reg byte x , r
 Potential registers zp[1]:7 [ print::$0 ] : zp[1]:7 , reg byte a , reg byte x , reg byte y , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [main] 24.75: zp[1]:2 [ main::i#2 main::i#1 ] 22: zp[1]:6 [ main::$5 ] 
-Uplift Scope [print] 28.5: zp[2]:4 [ print::p#3 print::p#2 ] 4: zp[1]:7 [ print::$0 ] 
-Uplift Scope [] 7.03: zp[1]:3 [ idx#12 idx#13 ] 
+Uplift Scope [print] 2,002: zp[1]:7 [ print::$0 ] 753: zp[2]:4 [ print::p#3 print::p#2 ] 
+Uplift Scope [] 805.85: zp[1]:3 [ idx#12 idx#13 ] 
+Uplift Scope [main] 227.25: zp[1]:2 [ main::i#2 main::i#1 ] 202: zp[1]:6 [ main::$5 ] 
 
-Uplifting [main] best 572 combination zp[1]:2 [ main::i#2 main::i#1 ] reg byte a [ main::$5 ] 
-Uplifting [print] best 568 combination zp[2]:4 [ print::p#3 print::p#2 ] reg byte a [ print::$0 ] 
+Uplifting [print] best 628 combination reg byte a [ print::$0 ] zp[2]:4 [ print::p#3 print::p#2 ] 
+Uplifting [] best 628 combination zp[1]:3 [ idx#12 idx#13 ] 
+Uplifting [main] best 568 combination zp[1]:2 [ main::i#2 main::i#1 ] reg byte a [ main::$5 ] 
+Attempting to uplift remaining variables inzp[1]:3 [ idx#12 idx#13 ]
 Uplifting [] best 568 combination zp[1]:3 [ idx#12 idx#13 ] 
 Attempting to uplift remaining variables inzp[1]:2 [ main::i#2 main::i#1 ]
 Uplifting [main] best 568 combination zp[1]:2 [ main::i#2 main::i#1 ] 
-Attempting to uplift remaining variables inzp[1]:3 [ idx#12 idx#13 ]
-Uplifting [] best 568 combination zp[1]:3 [ idx#12 idx#13 ] 
 
 ASSEMBLER BEFORE OPTIMIZATION
   // File Comments
@@ -622,23 +622,23 @@ FINAL SYMBOL TABLE
 (const byte) SIZEOF_SIGNED_WORD = (byte) 2
 (const signed word*) VALS[]  = { (signed word) 1, (signed word) 2, (signed word) 3, (signed word) 4 }
 (byte) idx
-(byte) idx#12 idx zp[1]:3 5.666666666666667
-(byte) idx#13 idx zp[1]:3 1.3636363636363638
+(byte) idx#12 idx zp[1]:3 704.6666666666667
+(byte) idx#13 idx zp[1]:3 101.18181818181819
 (void()) main()
-(byte~) main::$5 reg byte a 22.0
+(byte~) main::$5 reg byte a 202.0
 (label) main::@1
 (label) main::@2
 (label) main::@3
 (label) main::@return
 (byte) main::i
-(byte) main::i#1 i zp[1]:2 16.5
-(byte) main::i#2 i zp[1]:2 8.25
+(byte) main::i#1 i zp[1]:2 151.5
+(byte) main::i#2 i zp[1]:2 75.75
 (void()) print((signed word*) print::p)
-(byte~) print::$0 reg byte a 4.0
+(byte~) print::$0 reg byte a 2002.0
 (label) print::@return
 (signed word*) print::p
-(signed word*) print::p#2 p zp[2]:4 22.0
-(signed word*) print::p#3 p zp[2]:4 6.5
+(signed word*) print::p#2 p zp[2]:4 202.0
+(signed word*) print::p#3 p zp[2]:4 551.0
 
 zp[1]:2 [ main::i#2 main::i#1 ]
 zp[1]:3 [ idx#12 idx#13 ]

src/test/ref/address-of-3.sym

@@ -5,23 +5,23 @@
 (const byte) SIZEOF_SIGNED_WORD = (byte) 2
 (const signed word*) VALS[]  = { (signed word) 1, (signed word) 2, (signed word) 3, (signed word) 4 }
 (byte) idx
-(byte) idx#12 idx zp[1]:3 5.666666666666667
-(byte) idx#13 idx zp[1]:3 1.3636363636363638
+(byte) idx#12 idx zp[1]:3 704.6666666666667
+(byte) idx#13 idx zp[1]:3 101.18181818181819
 (void()) main()
-(byte~) main::$5 reg byte a 22.0
+(byte~) main::$5 reg byte a 202.0
 (label) main::@1
 (label) main::@2
 (label) main::@3
 (label) main::@return
 (byte) main::i
-(byte) main::i#1 i zp[1]:2 16.5
-(byte) main::i#2 i zp[1]:2 8.25
+(byte) main::i#1 i zp[1]:2 151.5
+(byte) main::i#2 i zp[1]:2 75.75
 (void()) print((signed word*) print::p)
-(byte~) print::$0 reg byte a 4.0
+(byte~) print::$0 reg byte a 2002.0
 (label) print::@return
 (signed word*) print::p
-(signed word*) print::p#2 p zp[2]:4 22.0
-(signed word*) print::p#3 p zp[2]:4 6.5
+(signed word*) print::p#2 p zp[2]:4 202.0
+(signed word*) print::p#3 p zp[2]:4 551.0
 
 zp[1]:2 [ main::i#2 main::i#1 ]
 zp[1]:3 [ idx#12 idx#13 ]

src/test/ref/array-16bit-lookup.log

@@ -115,9 +115,9 @@ Inferred type updated to byte in (unumber~) getValue::$0 ← (word) getValue::in
 Inferred type updated to byte in (unumber~) getValue::$4 ← (byte~) getValue::$0 * (const byte) SIZEOF_WORD
 Inferred type updated to byte in (unumber~) getValue::$1 ← *((const word*) arr16 + (byte~) getValue::$4) & (byte) $ff
 Inferred type updated to byte in (unumber~) getValue::$2 ← (byte~) getValue::$1 >> (byte) 1
-Alias (word) getValue::return#0 = (word) getValue::return#3 
-Alias (byte) main::idx#2 = (byte) main::idx#3 
-Alias (word) getValue::return#1 = (word~) getValue::$3 (word) getValue::return#4 (word) getValue::return#2 
+Alias getValue::return#0 = getValue::return#3 
+Alias main::idx#2 = main::idx#3 
+Alias getValue::return#1 = getValue::$3 getValue::return#4 getValue::return#2 
 Successful SSA optimization Pass2AliasElimination
 Identical Phi Values (word) getValue::index#1 (word) getValue::index#0
 Successful SSA optimization Pass2IdenticalPhiElimination
@@ -210,21 +210,21 @@ getValue::@return: scope:[getValue]  from getValue
 
 VARIABLE REGISTER WEIGHTS
 (word()) getValue((word) getValue::index)
-(byte~) getValue::$0 4.0
-(byte~) getValue::$1 4.0
-(byte~) getValue::$2 2.0
-(byte~) getValue::$4 4.0
+(byte~) getValue::$0 2002.0
+(byte~) getValue::$1 2002.0
+(byte~) getValue::$2 1001.0
+(byte~) getValue::$4 2002.0
 (word) getValue::index
-(word) getValue::index#0 13.0
+(word) getValue::index#0 1102.0
 (word) getValue::return
-(word) getValue::return#0 22.0
-(word) getValue::return#1 4.333333333333333
+(word) getValue::return#0 202.0
+(word) getValue::return#1 367.33333333333337
 (void()) main()
-(word~) main::$0 11.0
-(byte~) main::$2 22.0
+(word~) main::$0 101.0
+(byte~) main::$2 202.0
 (byte) main::idx
-(byte) main::idx#1 16.5
-(byte) main::idx#2 6.285714285714286
+(byte) main::idx#1 151.5
+(byte) main::idx#2 57.714285714285715
 
 Initial phi equivalence classes
 [ main::idx#2 main::idx#1 ]
@@ -387,27 +387,27 @@ getValue: {
   arr16: .fill 2*$80, 0
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Statement [6] (word) getValue::index#0 ← (byte) main::idx#2 [ main::idx#2 getValue::index#0 ] ( main:2 [ main::idx#2 getValue::index#0 ] ) always clobbers reg byte a 
+Statement [6] (word) getValue::index#0 ← (byte) main::idx#2 [ main::idx#2 getValue::index#0 ] ( main:2 [ main::idx#2 getValue::index#0 ] { { getValue::index#0 = main::idx#2 } { getValue::return#0 = getValue::return#1 } }  ) always clobbers reg byte a 
 Removing always clobbered register reg byte a as potential for zp[1]:2 [ main::idx#2 main::idx#1 ]
-Statement [8] (word) getValue::return#0 ← (word) getValue::return#1 [ main::idx#2 getValue::return#0 ] ( main:2 [ main::idx#2 getValue::return#0 ] ) always clobbers reg byte a 
-Statement [9] (word~) main::$0 ← (word) getValue::return#0 [ main::idx#2 main::$0 ] ( main:2 [ main::idx#2 main::$0 ] ) always clobbers reg byte a 
-Statement [10] (byte~) main::$2 ← (byte) main::idx#2 << (byte) 1 [ main::idx#2 main::$0 main::$2 ] ( main:2 [ main::idx#2 main::$0 main::$2 ] ) always clobbers reg byte a 
-Statement [11] *((const word*) main::SCREEN + (byte~) main::$2) ← (word~) main::$0 [ main::idx#2 ] ( main:2 [ main::idx#2 ] ) always clobbers reg byte a 
-Statement [15] (byte~) getValue::$0 ← (word) getValue::index#0 & (byte) $7f [ getValue::$0 ] ( main:2::getValue:7 [ main::idx#2 getValue::$0 ] ) always clobbers reg byte a 
-Statement [16] (byte~) getValue::$4 ← (byte~) getValue::$0 << (byte) 1 [ getValue::$4 ] ( main:2::getValue:7 [ main::idx#2 getValue::$4 ] ) always clobbers reg byte a 
-Statement [17] (byte~) getValue::$1 ← *((const word*) arr16 + (byte~) getValue::$4) & (byte) $ff [ getValue::$1 ] ( main:2::getValue:7 [ main::idx#2 getValue::$1 ] ) always clobbers reg byte a 
-Statement [18] (byte~) getValue::$2 ← (byte~) getValue::$1 >> (byte) 1 [ getValue::$2 ] ( main:2::getValue:7 [ main::idx#2 getValue::$2 ] ) always clobbers reg byte a 
-Statement [19] (word) getValue::return#1 ← (word)(byte~) getValue::$2 [ getValue::return#1 ] ( main:2::getValue:7 [ main::idx#2 getValue::return#1 ] ) always clobbers reg byte a 
-Statement [6] (word) getValue::index#0 ← (byte) main::idx#2 [ main::idx#2 getValue::index#0 ] ( main:2 [ main::idx#2 getValue::index#0 ] ) always clobbers reg byte a 
-Statement [8] (word) getValue::return#0 ← (word) getValue::return#1 [ main::idx#2 getValue::return#0 ] ( main:2 [ main::idx#2 getValue::return#0 ] ) always clobbers reg byte a 
-Statement [9] (word~) main::$0 ← (word) getValue::return#0 [ main::idx#2 main::$0 ] ( main:2 [ main::idx#2 main::$0 ] ) always clobbers reg byte a 
-Statement [10] (byte~) main::$2 ← (byte) main::idx#2 << (byte) 1 [ main::idx#2 main::$0 main::$2 ] ( main:2 [ main::idx#2 main::$0 main::$2 ] ) always clobbers reg byte a 
-Statement [11] *((const word*) main::SCREEN + (byte~) main::$2) ← (word~) main::$0 [ main::idx#2 ] ( main:2 [ main::idx#2 ] ) always clobbers reg byte a 
-Statement [15] (byte~) getValue::$0 ← (word) getValue::index#0 & (byte) $7f [ getValue::$0 ] ( main:2::getValue:7 [ main::idx#2 getValue::$0 ] ) always clobbers reg byte a 
-Statement [16] (byte~) getValue::$4 ← (byte~) getValue::$0 << (byte) 1 [ getValue::$4 ] ( main:2::getValue:7 [ main::idx#2 getValue::$4 ] ) always clobbers reg byte a 
-Statement [17] (byte~) getValue::$1 ← *((const word*) arr16 + (byte~) getValue::$4) & (byte) $ff [ getValue::$1 ] ( main:2::getValue:7 [ main::idx#2 getValue::$1 ] ) always clobbers reg byte a 
-Statement [18] (byte~) getValue::$2 ← (byte~) getValue::$1 >> (byte) 1 [ getValue::$2 ] ( main:2::getValue:7 [ main::idx#2 getValue::$2 ] ) always clobbers reg byte a 
-Statement [19] (word) getValue::return#1 ← (word)(byte~) getValue::$2 [ getValue::return#1 ] ( main:2::getValue:7 [ main::idx#2 getValue::return#1 ] ) always clobbers reg byte a 
+Statement [8] (word) getValue::return#0 ← (word) getValue::return#1 [ main::idx#2 getValue::return#0 ] ( main:2 [ main::idx#2 getValue::return#0 ] { { getValue::index#0 = main::idx#2 } { getValue::return#0 = getValue::return#1 } }  ) always clobbers reg byte a 
+Statement [9] (word~) main::$0 ← (word) getValue::return#0 [ main::idx#2 main::$0 ] ( main:2 [ main::idx#2 main::$0 ] { }  ) always clobbers reg byte a 
+Statement [10] (byte~) main::$2 ← (byte) main::idx#2 << (byte) 1 [ main::idx#2 main::$0 main::$2 ] ( main:2 [ main::idx#2 main::$0 main::$2 ] { }  ) always clobbers reg byte a 
+Statement [11] *((const word*) main::SCREEN + (byte~) main::$2) ← (word~) main::$0 [ main::idx#2 ] ( main:2 [ main::idx#2 ] { }  ) always clobbers reg byte a 
+Statement [15] (byte~) getValue::$0 ← (word) getValue::index#0 & (byte) $7f [ getValue::$0 ] ( main:2::getValue:7 [ main::idx#2 getValue::$0 ] { { getValue::index#0 = main::idx#2 } { getValue::return#0 = getValue::return#1 } }  ) always clobbers reg byte a 
+Statement [16] (byte~) getValue::$4 ← (byte~) getValue::$0 << (byte) 1 [ getValue::$4 ] ( main:2::getValue:7 [ main::idx#2 getValue::$4 ] { { getValue::index#0 = main::idx#2 } { getValue::return#0 = getValue::return#1 } }  ) always clobbers reg byte a 
+Statement [17] (byte~) getValue::$1 ← *((const word*) arr16 + (byte~) getValue::$4) & (byte) $ff [ getValue::$1 ] ( main:2::getValue:7 [ main::idx#2 getValue::$1 ] { { getValue::index#0 = main::idx#2 } { getValue::return#0 = getValue::return#1 } }  ) always clobbers reg byte a 
+Statement [18] (byte~) getValue::$2 ← (byte~) getValue::$1 >> (byte) 1 [ getValue::$2 ] ( main:2::getValue:7 [ main::idx#2 getValue::$2 ] { { getValue::index#0 = main::idx#2 } { getValue::return#0 = getValue::return#1 } }  ) always clobbers reg byte a 
+Statement [19] (word) getValue::return#1 ← (word)(byte~) getValue::$2 [ getValue::return#1 ] ( main:2::getValue:7 [ main::idx#2 getValue::return#1 ] { { getValue::index#0 = main::idx#2 } { getValue::return#0 = getValue::return#1 } }  ) always clobbers reg byte a 
+Statement [6] (word) getValue::index#0 ← (byte) main::idx#2 [ main::idx#2 getValue::index#0 ] ( main:2 [ main::idx#2 getValue::index#0 ] { { getValue::index#0 = main::idx#2 } { getValue::return#0 = getValue::return#1 } }  ) always clobbers reg byte a 
+Statement [8] (word) getValue::return#0 ← (word) getValue::return#1 [ main::idx#2 getValue::return#0 ] ( main:2 [ main::idx#2 getValue::return#0 ] { { getValue::index#0 = main::idx#2 } { getValue::return#0 = getValue::return#1 } }  ) always clobbers reg byte a 
+Statement [9] (word~) main::$0 ← (word) getValue::return#0 [ main::idx#2 main::$0 ] ( main:2 [ main::idx#2 main::$0 ] { }  ) always clobbers reg byte a 
+Statement [10] (byte~) main::$2 ← (byte) main::idx#2 << (byte) 1 [ main::idx#2 main::$0 main::$2 ] ( main:2 [ main::idx#2 main::$0 main::$2 ] { }  ) always clobbers reg byte a 
+Statement [11] *((const word*) main::SCREEN + (byte~) main::$2) ← (word~) main::$0 [ main::idx#2 ] ( main:2 [ main::idx#2 ] { }  ) always clobbers reg byte a 
+Statement [15] (byte~) getValue::$0 ← (word) getValue::index#0 & (byte) $7f [ getValue::$0 ] ( main:2::getValue:7 [ main::idx#2 getValue::$0 ] { { getValue::index#0 = main::idx#2 } { getValue::return#0 = getValue::return#1 } }  ) always clobbers reg byte a 
+Statement [16] (byte~) getValue::$4 ← (byte~) getValue::$0 << (byte) 1 [ getValue::$4 ] ( main:2::getValue:7 [ main::idx#2 getValue::$4 ] { { getValue::index#0 = main::idx#2 } { getValue::return#0 = getValue::return#1 } }  ) always clobbers reg byte a 
+Statement [17] (byte~) getValue::$1 ← *((const word*) arr16 + (byte~) getValue::$4) & (byte) $ff [ getValue::$1 ] ( main:2::getValue:7 [ main::idx#2 getValue::$1 ] { { getValue::index#0 = main::idx#2 } { getValue::return#0 = getValue::return#1 } }  ) always clobbers reg byte a 
+Statement [18] (byte~) getValue::$2 ← (byte~) getValue::$1 >> (byte) 1 [ getValue::$2 ] ( main:2::getValue:7 [ main::idx#2 getValue::$2 ] { { getValue::index#0 = main::idx#2 } { getValue::return#0 = getValue::return#1 } }  ) always clobbers reg byte a 
+Statement [19] (word) getValue::return#1 ← (word)(byte~) getValue::$2 [ getValue::return#1 ] ( main:2::getValue:7 [ main::idx#2 getValue::return#1 ] { { getValue::index#0 = main::idx#2 } { getValue::return#0 = getValue::return#1 } }  ) always clobbers reg byte a 
 Potential registers zp[1]:2 [ main::idx#2 main::idx#1 ] : zp[1]:2 , reg byte x , reg byte y , 
 Potential registers zp[2]:3 [ getValue::index#0 ] : zp[2]:3 , 
 Potential registers zp[2]:5 [ getValue::return#0 ] : zp[2]:5 , 
@@ -420,13 +420,13 @@ Potential registers zp[1]:13 [ getValue::$2 ] : zp[1]:13 , reg byte a , reg byte
 Potential registers zp[2]:14 [ getValue::return#1 ] : zp[2]:14 , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [main] 22.79: zp[1]:2 [ main::idx#2 main::idx#1 ] 22: zp[1]:9 [ main::$2 ] 11: zp[2]:7 [ main::$0 ] 
-Uplift Scope [getValue] 22: zp[2]:5 [ getValue::return#0 ] 13: zp[2]:3 [ getValue::index#0 ] 4.33: zp[2]:14 [ getValue::return#1 ] 4: zp[1]:10 [ getValue::$0 ] 4: zp[1]:11 [ getValue::$4 ] 4: zp[1]:12 [ getValue::$1 ] 2: zp[1]:13 [ getValue::$2 ] 
+Uplift Scope [getValue] 2,002: zp[1]:10 [ getValue::$0 ] 2,002: zp[1]:11 [ getValue::$4 ] 2,002: zp[1]:12 [ getValue::$1 ] 1,102: zp[2]:3 [ getValue::index#0 ] 1,001: zp[1]:13 [ getValue::$2 ] 367.33: zp[2]:14 [ getValue::return#1 ] 202: zp[2]:5 [ getValue::return#0 ] 
+Uplift Scope [main] 209.21: zp[1]:2 [ main::idx#2 main::idx#1 ] 202: zp[1]:9 [ main::$2 ] 101: zp[2]:7 [ main::$0 ] 
 Uplift Scope [] 
 
-Uplifting [main] best 899 combination reg byte x [ main::idx#2 main::idx#1 ] reg byte a [ main::$2 ] zp[2]:7 [ main::$0 ] 
-Uplifting [getValue] best 877 combination zp[2]:5 [ getValue::return#0 ] zp[2]:3 [ getValue::index#0 ] zp[2]:14 [ getValue::return#1 ] reg byte a [ getValue::$0 ] reg byte a [ getValue::$4 ] reg byte a [ getValue::$1 ] reg byte a [ getValue::$2 ] 
+Uplifting [getValue] best 1027 combination reg byte a [ getValue::$0 ] reg byte a [ getValue::$4 ] reg byte a [ getValue::$1 ] zp[2]:3 [ getValue::index#0 ] reg byte a [ getValue::$2 ] zp[2]:14 [ getValue::return#1 ] zp[2]:5 [ getValue::return#0 ] 
 Limited combination testing to 100 combinations of 256 possible.
+Uplifting [main] best 877 combination reg byte x [ main::idx#2 main::idx#1 ] reg byte a [ main::$2 ] zp[2]:7 [ main::$0 ] 
 Uplifting [] best 877 combination 
 Coalescing zero page register [ zp[2]:5 [ getValue::return#0 ] ] with [ zp[2]:7 [ main::$0 ] ] - score: 1
 Coalescing zero page register [ zp[2]:5 [ getValue::return#0 main::$0 ] ] with [ zp[2]:14 [ getValue::return#1 ] ] - score: 1
@@ -569,26 +569,26 @@ FINAL SYMBOL TABLE
 (label) @end
 (const word*) arr16[(number) $80]  = { fill( $80, 0) }
 (word()) getValue((word) getValue::index)
-(byte~) getValue::$0 reg byte a 4.0
-(byte~) getValue::$1 reg byte a 4.0
-(byte~) getValue::$2 reg byte a 2.0
-(byte~) getValue::$4 reg byte a 4.0
+(byte~) getValue::$0 reg byte a 2002.0
+(byte~) getValue::$1 reg byte a 2002.0
+(byte~) getValue::$2 reg byte a 1001.0
+(byte~) getValue::$4 reg byte a 2002.0
 (label) getValue::@return
 (word) getValue::index
-(word) getValue::index#0 index zp[2]:2 13.0
+(word) getValue::index#0 index zp[2]:2 1102.0
 (word) getValue::return
-(word) getValue::return#0 return zp[2]:4 22.0
-(word) getValue::return#1 return zp[2]:4 4.333333333333333
+(word) getValue::return#0 return zp[2]:4 202.0
+(word) getValue::return#1 return zp[2]:4 367.33333333333337
 (void()) main()
-(word~) main::$0 zp[2]:4 11.0
-(byte~) main::$2 reg byte a 22.0
+(word~) main::$0 zp[2]:4 101.0
+(byte~) main::$2 reg byte a 202.0
 (label) main::@1
 (label) main::@2
 (label) main::@return
 (const word*) main::SCREEN = (word*) 1024
 (byte) main::idx
-(byte) main::idx#1 reg byte x 16.5
-(byte) main::idx#2 reg byte x 6.285714285714286
+(byte) main::idx#1 reg byte x 151.5
+(byte) main::idx#2 reg byte x 57.714285714285715
 
 reg byte x [ main::idx#2 main::idx#1 ]
 zp[2]:2 [ getValue::index#0 ]

src/test/ref/array-16bit-lookup.sym

@@ -3,26 +3,26 @@
 (label) @end
 (const word*) arr16[(number) $80]  = { fill( $80, 0) }
 (word()) getValue((word) getValue::index)
-(byte~) getValue::$0 reg byte a 4.0
-(byte~) getValue::$1 reg byte a 4.0
-(byte~) getValue::$2 reg byte a 2.0
-(byte~) getValue::$4 reg byte a 4.0
+(byte~) getValue::$0 reg byte a 2002.0
+(byte~) getValue::$1 reg byte a 2002.0
+(byte~) getValue::$2 reg byte a 1001.0
+(byte~) getValue::$4 reg byte a 2002.0
 (label) getValue::@return
 (word) getValue::index
-(word) getValue::index#0 index zp[2]:2 13.0
+(word) getValue::index#0 index zp[2]:2 1102.0
 (word) getValue::return
-(word) getValue::return#0 return zp[2]:4 22.0
-(word) getValue::return#1 return zp[2]:4 4.333333333333333
+(word) getValue::return#0 return zp[2]:4 202.0
+(word) getValue::return#1 return zp[2]:4 367.33333333333337
 (void()) main()
-(word~) main::$0 zp[2]:4 11.0
-(byte~) main::$2 reg byte a 22.0
+(word~) main::$0 zp[2]:4 101.0
+(byte~) main::$2 reg byte a 202.0
 (label) main::@1
 (label) main::@2
 (label) main::@return
 (const word*) main::SCREEN = (word*) 1024
 (byte) main::idx
-(byte) main::idx#1 reg byte x 16.5
-(byte) main::idx#2 reg byte x 6.285714285714286
+(byte) main::idx#1 reg byte x 151.5
+(byte) main::idx#2 reg byte x 57.714285714285715
 
 reg byte x [ main::idx#2 main::idx#1 ]
 zp[2]:2 [ getValue::index#0 ]

src/test/ref/array-length-symbolic-min.log

@@ -109,8 +109,8 @@ main::@return: scope:[main]  from main::@1
 VARIABLE REGISTER WEIGHTS
 (void()) main()
 (byte) main::sub
-(byte) main::sub#1 16.5
-(byte) main::sub#2 22.0
+(byte) main::sub#1 151.5
+(byte) main::sub#2 202.0
 
 Initial phi equivalence classes
 [ main::sub#2 main::sub#1 ]
@@ -183,7 +183,7 @@ REGISTER UPLIFT POTENTIAL REGISTERS
 Potential registers zp[1]:2 [ main::sub#2 main::sub#1 ] : zp[1]:2 , reg byte a , reg byte x , reg byte y , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [main] 38.5: zp[1]:2 [ main::sub#2 main::sub#1 ] 
+Uplift Scope [main] 353.5: zp[1]:2 [ main::sub#2 main::sub#1 ] 
 Uplift Scope [] 
 
 Uplifting [main] best 263 combination reg byte x [ main::sub#2 main::sub#1 ] 
@@ -280,8 +280,8 @@ FINAL SYMBOL TABLE
 (label) main::@1
 (label) main::@return
 (byte) main::sub
-(byte) main::sub#1 reg byte x 16.5
-(byte) main::sub#2 reg byte x 22.0
+(byte) main::sub#1 reg byte x 151.5
+(byte) main::sub#2 reg byte x 202.0
 
 reg byte x [ main::sub#2 main::sub#1 ]
 

src/test/ref/array-length-symbolic-min.sym

@@ -7,7 +7,7 @@
 (label) main::@1
 (label) main::@return
 (byte) main::sub
-(byte) main::sub#1 reg byte x 16.5
-(byte) main::sub#2 reg byte x 22.0
+(byte) main::sub#1 reg byte x 151.5
+(byte) main::sub#2 reg byte x 202.0
 
 reg byte x [ main::sub#2 main::sub#1 ]

src/test/ref/array-length-symbolic.log

@@ -93,8 +93,8 @@ Finalized unsigned number type (byte) 1
 Successful SSA optimization PassNFinalizeNumberTypeConversions
 Inferred type updated to byte in (unumber~) main::$0 ← (byte) main::item#2 * (byte) $10
 Inferred type updated to byte in (unumber~) main::$1 ← (byte~) main::$0 | (byte) main::sub#2
-Alias (byte*) main::cur_item#2 = (byte*) main::cur_item#3 
-Alias (byte) main::item#2 = (byte) main::item#3 
+Alias main::cur_item#2 = main::cur_item#3 
+Alias main::item#2 = main::item#3 
 Successful SSA optimization Pass2AliasElimination
 Identical Phi Values (byte) main::item#2 (byte) main::item#4
 Identical Phi Values (byte*) main::cur_item#2 (byte*) main::cur_item#4
@@ -194,17 +194,17 @@ main::@return: scope:[main]  from main::@3
 
 VARIABLE REGISTER WEIGHTS
 (void()) main()
-(byte~) main::$0 202.0
-(byte~) main::$1 202.0
+(byte~) main::$0 2002.0
+(byte~) main::$1 2002.0
 (byte*) main::cur_item
-(byte*) main::cur_item#1 7.333333333333333
-(byte*) main::cur_item#4 17.571428571428573
+(byte*) main::cur_item#1 67.33333333333333
+(byte*) main::cur_item#4 171.85714285714283
 (byte) main::item
-(byte) main::item#1 16.5
-(byte) main::item#4 15.375
+(byte) main::item#1 151.5
+(byte) main::item#4 150.375
 (byte) main::sub
-(byte) main::sub#1 151.5
-(byte) main::sub#2 101.0
+(byte) main::sub#1 1501.5
+(byte) main::sub#2 1001.0
 
 Initial phi equivalence classes
 [ main::item#4 main::item#1 ]
@@ -337,12 +337,12 @@ main: {
   items: .byte 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Statement [7] (byte~) main::$0 ← (byte) main::item#4 << (byte) 4 [ main::item#4 main::cur_item#4 main::sub#2 main::$0 ] ( main:2 [ main::item#4 main::cur_item#4 main::sub#2 main::$0 ] ) always clobbers reg byte a 
+Statement [7] (byte~) main::$0 ← (byte) main::item#4 << (byte) 4 [ main::item#4 main::cur_item#4 main::sub#2 main::$0 ] ( main:2 [ main::item#4 main::cur_item#4 main::sub#2 main::$0 ] { }  ) always clobbers reg byte a 
 Removing always clobbered register reg byte a as potential for zp[1]:2 [ main::item#4 main::item#1 ]
 Removing always clobbered register reg byte a as potential for zp[1]:5 [ main::sub#2 main::sub#1 ]
-Statement [12] (byte*) main::cur_item#1 ← (byte*) main::cur_item#4 + (const byte) ITEM_SIZE [ main::item#4 main::cur_item#1 ] ( main:2 [ main::item#4 main::cur_item#1 ] ) always clobbers reg byte a 
-Statement [7] (byte~) main::$0 ← (byte) main::item#4 << (byte) 4 [ main::item#4 main::cur_item#4 main::sub#2 main::$0 ] ( main:2 [ main::item#4 main::cur_item#4 main::sub#2 main::$0 ] ) always clobbers reg byte a 
-Statement [12] (byte*) main::cur_item#1 ← (byte*) main::cur_item#4 + (const byte) ITEM_SIZE [ main::item#4 main::cur_item#1 ] ( main:2 [ main::item#4 main::cur_item#1 ] ) always clobbers reg byte a 
+Statement [12] (byte*) main::cur_item#1 ← (byte*) main::cur_item#4 + (const byte) ITEM_SIZE [ main::item#4 main::cur_item#1 ] ( main:2 [ main::item#4 main::cur_item#1 ] { }  ) always clobbers reg byte a 
+Statement [7] (byte~) main::$0 ← (byte) main::item#4 << (byte) 4 [ main::item#4 main::cur_item#4 main::sub#2 main::$0 ] ( main:2 [ main::item#4 main::cur_item#4 main::sub#2 main::$0 ] { }  ) always clobbers reg byte a 
+Statement [12] (byte*) main::cur_item#1 ← (byte*) main::cur_item#4 + (const byte) ITEM_SIZE [ main::item#4 main::cur_item#1 ] ( main:2 [ main::item#4 main::cur_item#1 ] { }  ) always clobbers reg byte a 
 Potential registers zp[1]:2 [ main::item#4 main::item#1 ] : zp[1]:2 , reg byte x , reg byte y , 
 Potential registers zp[2]:3 [ main::cur_item#4 main::cur_item#1 ] : zp[2]:3 , 
 Potential registers zp[1]:5 [ main::sub#2 main::sub#1 ] : zp[1]:5 , reg byte x , reg byte y , 
@@ -350,7 +350,7 @@ Potential registers zp[1]:6 [ main::$0 ] : zp[1]:6 , reg byte a , reg byte x , r
 Potential registers zp[1]:7 [ main::$1 ] : zp[1]:7 , reg byte a , reg byte x , reg byte y , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [main] 252.5: zp[1]:5 [ main::sub#2 main::sub#1 ] 202: zp[1]:6 [ main::$0 ] 202: zp[1]:7 [ main::$1 ] 31.88: zp[1]:2 [ main::item#4 main::item#1 ] 24.9: zp[2]:3 [ main::cur_item#4 main::cur_item#1 ] 
+Uplift Scope [main] 2,502.5: zp[1]:5 [ main::sub#2 main::sub#1 ] 2,002: zp[1]:6 [ main::$0 ] 2,002: zp[1]:7 [ main::$1 ] 301.88: zp[1]:2 [ main::item#4 main::item#1 ] 239.19: zp[2]:3 [ main::cur_item#4 main::cur_item#1 ] 
 Uplift Scope [] 
 
 Uplifting [main] best 4418 combination reg byte y [ main::sub#2 main::sub#1 ] reg byte a [ main::$0 ] reg byte a [ main::$1 ] reg byte x [ main::item#4 main::item#1 ] zp[2]:3 [ main::cur_item#4 main::cur_item#1 ] 
@@ -497,21 +497,21 @@ FINAL SYMBOL TABLE
 (const byte) ITEM_SIZE = (byte) 5
 (const byte*) items[(const byte) ITEM_COUNT*(const byte) ITEM_SIZE]  = { (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0 }
 (void()) main()
-(byte~) main::$0 reg byte a 202.0
-(byte~) main::$1 reg byte a 202.0
+(byte~) main::$0 reg byte a 2002.0
+(byte~) main::$1 reg byte a 2002.0
 (label) main::@1
 (label) main::@2
 (label) main::@3
 (label) main::@return
 (byte*) main::cur_item
-(byte*) main::cur_item#1 cur_item zp[2]:2 7.333333333333333
-(byte*) main::cur_item#4 cur_item zp[2]:2 17.571428571428573
+(byte*) main::cur_item#1 cur_item zp[2]:2 67.33333333333333
+(byte*) main::cur_item#4 cur_item zp[2]:2 171.85714285714283
 (byte) main::item
-(byte) main::item#1 reg byte x 16.5
-(byte) main::item#4 reg byte x 15.375
+(byte) main::item#1 reg byte x 151.5
+(byte) main::item#4 reg byte x 150.375
 (byte) main::sub
-(byte) main::sub#1 reg byte y 151.5
-(byte) main::sub#2 reg byte y 101.0
+(byte) main::sub#1 reg byte y 1501.5
+(byte) main::sub#2 reg byte y 1001.0
 
 reg byte x [ main::item#4 main::item#1 ]
 zp[2]:2 [ main::cur_item#4 main::cur_item#1 ]

src/test/ref/array-length-symbolic.sym

@@ -5,21 +5,21 @@
 (const byte) ITEM_SIZE = (byte) 5
 (const byte*) items[(const byte) ITEM_COUNT*(const byte) ITEM_SIZE]  = { (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0 }
 (void()) main()
-(byte~) main::$0 reg byte a 202.0
-(byte~) main::$1 reg byte a 202.0
+(byte~) main::$0 reg byte a 2002.0
+(byte~) main::$1 reg byte a 2002.0
 (label) main::@1
 (label) main::@2
 (label) main::@3
 (label) main::@return
 (byte*) main::cur_item
-(byte*) main::cur_item#1 cur_item zp[2]:2 7.333333333333333
-(byte*) main::cur_item#4 cur_item zp[2]:2 17.571428571428573
+(byte*) main::cur_item#1 cur_item zp[2]:2 67.33333333333333
+(byte*) main::cur_item#4 cur_item zp[2]:2 171.85714285714283
 (byte) main::item
-(byte) main::item#1 reg byte x 16.5
-(byte) main::item#4 reg byte x 15.375
+(byte) main::item#1 reg byte x 151.5
+(byte) main::item#4 reg byte x 150.375
 (byte) main::sub
-(byte) main::sub#1 reg byte y 151.5
-(byte) main::sub#2 reg byte y 101.0
+(byte) main::sub#1 reg byte y 1501.5
+(byte) main::sub#2 reg byte y 1001.0
 
 reg byte x [ main::item#4 main::item#1 ]
 zp[2]:2 [ main::cur_item#4 main::cur_item#1 ]

src/test/ref/arrays-init-kasm-0.log

@@ -124,7 +124,7 @@ SINTAB:
 
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Statement [4] *((const byte*) SCREEN) ← *((const byte*) SINTAB) [ ] ( main:2 [ ] ) always clobbers reg byte a 
+Statement [4] *((const byte*) SCREEN) ← *((const byte*) SINTAB) [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
 
 REGISTER UPLIFT SCOPES
 Uplift Scope [main] 

src/test/ref/arrays-init-short.log

@@ -90,8 +90,8 @@ Finalized unsigned number type (byte) 0
 Finalized unsigned number type (byte) 0
 Finalized unsigned number type (byte) $28
 Successful SSA optimization PassNFinalizeNumberTypeConversions
-Alias (byte) main::i#2 = (byte) main::i#3 
-Alias (byte) main::i1#2 = (byte) main::i1#3 
+Alias main::i#2 = main::i#3 
+Alias main::i1#2 = main::i1#3 
 Successful SSA optimization Pass2AliasElimination
 Simple Condition (bool~) main::$0 [3] if((byte) 0!=*((const byte*) msg1 + (byte) main::i#2)) goto main::@2
 Simple Condition (bool~) main::$1 [9] if((byte) 0!=*((const byte*) msg2 + (byte) main::i1#2)) goto main::@8
@@ -165,11 +165,11 @@ main::@2: scope:[main]  from main::@1
 VARIABLE REGISTER WEIGHTS
 (void()) main()
 (byte) main::i
-(byte) main::i#1 22.0
-(byte) main::i#2 18.333333333333332
+(byte) main::i#1 202.0
+(byte) main::i#2 168.33333333333331
 (byte) main::i1
-(byte) main::i1#1 22.0
-(byte) main::i1#2 18.333333333333332
+(byte) main::i1#1 202.0
+(byte) main::i1#2 168.33333333333331
 
 Initial phi equivalence classes
 [ main::i#2 main::i#1 ]
@@ -274,21 +274,21 @@ main: {
   .fill $d, 0
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Statement [6] if((byte) 0!=*((const byte*) msg1 + (byte) main::i#2)) goto main::@2 [ main::i#2 ] ( main:2 [ main::i#2 ] ) always clobbers reg byte a 
+Statement [6] if((byte) 0!=*((const byte*) msg1 + (byte) main::i#2)) goto main::@2 [ main::i#2 ] ( main:2 [ main::i#2 ] { }  ) always clobbers reg byte a 
 Removing always clobbered register reg byte a as potential for zp[1]:2 [ main::i#2 main::i#1 ]
-Statement [8] if((byte) 0!=*((const byte*) msg2 + (byte) main::i1#2)) goto main::@4 [ main::i1#2 ] ( main:2 [ main::i1#2 ] ) always clobbers reg byte a 
+Statement [8] if((byte) 0!=*((const byte*) msg2 + (byte) main::i1#2)) goto main::@4 [ main::i1#2 ] ( main:2 [ main::i1#2 ] { }  ) always clobbers reg byte a 
 Removing always clobbered register reg byte a as potential for zp[1]:3 [ main::i1#2 main::i1#1 ]
-Statement [10] *((const byte*) SCREEN+(byte) $28 + (byte) main::i1#2) ← *((const byte*) msg2 + (byte) main::i1#2) [ main::i1#2 ] ( main:2 [ main::i1#2 ] ) always clobbers reg byte a 
-Statement [12] *((const byte*) SCREEN + (byte) main::i#2) ← *((const byte*) msg1 + (byte) main::i#2) [ main::i#2 ] ( main:2 [ main::i#2 ] ) always clobbers reg byte a 
-Statement [6] if((byte) 0!=*((const byte*) msg1 + (byte) main::i#2)) goto main::@2 [ main::i#2 ] ( main:2 [ main::i#2 ] ) always clobbers reg byte a 
-Statement [8] if((byte) 0!=*((const byte*) msg2 + (byte) main::i1#2)) goto main::@4 [ main::i1#2 ] ( main:2 [ main::i1#2 ] ) always clobbers reg byte a 
-Statement [10] *((const byte*) SCREEN+(byte) $28 + (byte) main::i1#2) ← *((const byte*) msg2 + (byte) main::i1#2) [ main::i1#2 ] ( main:2 [ main::i1#2 ] ) always clobbers reg byte a 
-Statement [12] *((const byte*) SCREEN + (byte) main::i#2) ← *((const byte*) msg1 + (byte) main::i#2) [ main::i#2 ] ( main:2 [ main::i#2 ] ) always clobbers reg byte a 
+Statement [10] *((const byte*) SCREEN+(byte) $28 + (byte) main::i1#2) ← *((const byte*) msg2 + (byte) main::i1#2) [ main::i1#2 ] ( main:2 [ main::i1#2 ] { }  ) always clobbers reg byte a 
+Statement [12] *((const byte*) SCREEN + (byte) main::i#2) ← *((const byte*) msg1 + (byte) main::i#2) [ main::i#2 ] ( main:2 [ main::i#2 ] { }  ) always clobbers reg byte a 
+Statement [6] if((byte) 0!=*((const byte*) msg1 + (byte) main::i#2)) goto main::@2 [ main::i#2 ] ( main:2 [ main::i#2 ] { }  ) always clobbers reg byte a 
+Statement [8] if((byte) 0!=*((const byte*) msg2 + (byte) main::i1#2)) goto main::@4 [ main::i1#2 ] ( main:2 [ main::i1#2 ] { }  ) always clobbers reg byte a 
+Statement [10] *((const byte*) SCREEN+(byte) $28 + (byte) main::i1#2) ← *((const byte*) msg2 + (byte) main::i1#2) [ main::i1#2 ] ( main:2 [ main::i1#2 ] { }  ) always clobbers reg byte a 
+Statement [12] *((const byte*) SCREEN + (byte) main::i#2) ← *((const byte*) msg1 + (byte) main::i#2) [ main::i#2 ] ( main:2 [ main::i#2 ] { }  ) always clobbers reg byte a 
 Potential registers zp[1]:2 [ main::i#2 main::i#1 ] : zp[1]:2 , reg byte x , reg byte y , 
 Potential registers zp[1]:3 [ main::i1#2 main::i1#1 ] : zp[1]:3 , reg byte x , reg byte y , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [main] 40.33: zp[1]:2 [ main::i#2 main::i#1 ] 40.33: zp[1]:3 [ main::i1#2 main::i1#1 ] 
+Uplift Scope [main] 370.33: zp[1]:2 [ main::i#2 main::i#1 ] 370.33: zp[1]:3 [ main::i1#2 main::i1#1 ] 
 Uplift Scope [] 
 
 Uplifting [main] best 618 combination reg byte x [ main::i#2 main::i#1 ] reg byte x [ main::i1#2 main::i1#1 ] 
@@ -415,11 +415,11 @@ FINAL SYMBOL TABLE
 (label) main::@4
 (label) main::@return
 (byte) main::i
-(byte) main::i#1 reg byte x 22.0
-(byte) main::i#2 reg byte x 18.333333333333332
+(byte) main::i#1 reg byte x 202.0
+(byte) main::i#2 reg byte x 168.33333333333331
 (byte) main::i1
-(byte) main::i1#1 reg byte x 22.0
-(byte) main::i1#2 reg byte x 18.333333333333332
+(byte) main::i1#1 reg byte x 202.0
+(byte) main::i1#2 reg byte x 168.33333333333331
 (const byte*) msg1[(number) $10]  = (byte*) "camelot"
 (const byte*) msg2[(number) $10]  = { (byte) 'c', (byte) 'm', (byte) 'l' }
 

src/test/ref/arrays-init-short.sym

@@ -9,11 +9,11 @@
 (label) main::@4
 (label) main::@return
 (byte) main::i
-(byte) main::i#1 reg byte x 22.0
-(byte) main::i#2 reg byte x 18.333333333333332
+(byte) main::i#1 reg byte x 202.0
+(byte) main::i#2 reg byte x 168.33333333333331
 (byte) main::i1
-(byte) main::i1#1 reg byte x 22.0
-(byte) main::i1#2 reg byte x 18.333333333333332
+(byte) main::i1#1 reg byte x 202.0
+(byte) main::i1#2 reg byte x 168.33333333333331
 (const byte*) msg1[(number) $10]  = (byte*) "camelot"
 (const byte*) msg2[(number) $10]  = { (byte) 'c', (byte) 'm', (byte) 'l' }
 

src/test/ref/arrays-init.log

@@ -166,10 +166,10 @@ main: {
   d: .text "cml"
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Statement [4] *((const byte*) b) ← (byte) 'c' [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [5] *((const byte*) SCREEN) ← *((const byte*) b) [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [6] *((const byte*) SCREEN+(byte) 1) ← *((const byte*) c+(byte) 1) [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [7] *((const byte*) SCREEN+(byte) 2) ← *((const byte*) d+(byte) 2) [ ] ( main:2 [ ] ) always clobbers reg byte a 
+Statement [4] *((const byte*) b) ← (byte) 'c' [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [5] *((const byte*) SCREEN) ← *((const byte*) b) [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [6] *((const byte*) SCREEN+(byte) 1) ← *((const byte*) c+(byte) 1) [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [7] *((const byte*) SCREEN+(byte) 2) ← *((const byte*) d+(byte) 2) [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
 
 REGISTER UPLIFT SCOPES
 Uplift Scope [main] 

src/test/ref/asm-culling-jmp.log

@@ -113,7 +113,7 @@ main: {
 
 REGISTER UPLIFT POTENTIAL REGISTERS
 Statement asm { jmpqwe .byte0,25,51,76,102,128,153,179,204,230 qwe: lda#50  } always clobbers reg byte a 
-Statement [5] *((byte*) 1024) ← (byte) 'c' [ ] ( main:2 [ ] ) always clobbers reg byte a 
+Statement [5] *((byte*) 1024) ← (byte) 'c' [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
 
 REGISTER UPLIFT SCOPES
 Uplift Scope [main] 

src/test/ref/asm-mnemonic-names.log

@@ -182,9 +182,9 @@ bne: {
   // File Data
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Statement [4] *((const byte*) lda) ← (const byte) main::jmp [ ] ( main:2 [ ] ) always clobbers reg byte a 
+Statement [4] *((const byte*) lda) ← (const byte) main::jmp [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
 Statement asm { ldaa jmpa bnea a:  } always clobbers reg byte a 
-Statement [8] *((const byte*) lda+(byte) 1) ← (const byte) main::jmp [ ] ( main:2::bne:5 [ ] ) always clobbers reg byte a 
+Statement [8] *((const byte*) lda+(byte) 1) ← (const byte) main::jmp [ ] ( main:2::bne:5 [ ] { }  ) always clobbers reg byte a 
 
 REGISTER UPLIFT SCOPES
 Uplift Scope [main] 

src/test/ref/asm-uses-0.log

@@ -147,7 +147,7 @@ init: {
 
 REGISTER UPLIFT POTENTIAL REGISTERS
 Statement asm { jsrinit  } always clobbers reg byte a reg byte x reg byte y 
-Statement [6] *((const byte*) BGCOL) ← (byte) 0 [ ] (  [ ] ) always clobbers reg byte a 
+Statement [6] *((const byte*) BGCOL) ← (byte) 0 [ ] (  [ ] { }  ) always clobbers reg byte a 
 
 REGISTER UPLIFT SCOPES
 Uplift Scope [main] 

src/test/ref/assignment-chained.log

@@ -138,7 +138,7 @@ main::@return: scope:[main]  from main
 VARIABLE REGISTER WEIGHTS
 (void()) main()
 (byte) main::a
-(byte) main::a#2 4.0
+(byte) main::a#2 22.0
 
 Initial phi equivalence classes
 Added variable main::a#2 to live range equivalence class [ main::a#2 ]
@@ -204,15 +204,15 @@ main: {
   // File Data
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Statement [4] *((const byte*) main::screen) ← (byte) 'c' [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [5] *((const byte*) main::screen+(byte) $28) ← (byte) 'c' [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [6] *((const byte*) main::screen+(byte) 1) ← (byte) 'm' [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [9] *((const byte*) main::screen+(byte) 2) ← (byte) 1+(byte) 'l' [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [10] *((const byte*) main::screen+(byte) $2a) ← (byte) 'l' [ ] ( main:2 [ ] ) always clobbers reg byte a 
+Statement [4] *((const byte*) main::screen) ← (byte) 'c' [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [5] *((const byte*) main::screen+(byte) $28) ← (byte) 'c' [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [6] *((const byte*) main::screen+(byte) 1) ← (byte) 'm' [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [9] *((const byte*) main::screen+(byte) 2) ← (byte) 1+(byte) 'l' [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [10] *((const byte*) main::screen+(byte) $2a) ← (byte) 'l' [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
 Potential registers zp[1]:2 [ main::a#2 ] : zp[1]:2 , reg byte a , reg byte x , reg byte y , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [main] 4: zp[1]:2 [ main::a#2 ] 
+Uplift Scope [main] 22: zp[1]:2 [ main::a#2 ] 
 Uplift Scope [] 
 
 Uplifting [main] best 59 combination reg byte a [ main::a#2 ] 
@@ -299,7 +299,7 @@ FINAL SYMBOL TABLE
 (void()) main()
 (label) main::@return
 (byte) main::a
-(byte) main::a#2 reg byte a 4.0
+(byte) main::a#2 reg byte a 22.0
 (const byte*) main::screen = (byte*) 1024
 
 reg byte a [ main::a#2 ]

src/test/ref/assignment-chained.sym

@@ -4,7 +4,7 @@
 (void()) main()
 (label) main::@return
 (byte) main::a
-(byte) main::a#2 reg byte a 4.0
+(byte) main::a#2 reg byte a 22.0
 (const byte*) main::screen = (byte*) 1024
 
 reg byte a [ main::a#2 ]

src/test/ref/assignment-compound.log

@@ -315,30 +315,30 @@ Finalized unsigned number type (byte) 6
 Finalized unsigned number type (byte) 1
 Finalized unsigned number type (byte) 1
 Successful SSA optimization PassNFinalizeNumberTypeConversions
-Alias (byte*) screen2#0 = (byte*~) $0 (byte*) screen2#13 
-Alias (byte) main::i#0 = (byte) main::i#12 
-Alias (byte) main::a#0 = (byte) main::a#11 
-Alias (byte*) screen2#10 = (byte*) screen2#3 (byte*) screen2#2 (byte*) screen2#5 (byte*) screen2#6 (byte*) screen2#7 (byte*) screen2#8 (byte*) screen2#9 (byte*) screen2#11 (byte*) screen2#12 (byte*) screen2#4 
-Alias (byte) main::i#1 = (byte) main::i#13 
-Alias (byte) main::a#1 = (byte) main::a#12 
-Alias (byte) main::i#14 = (byte) main::i#2 
-Alias (byte) main::a#13 = (byte) main::a#2 
-Alias (byte) main::i#15 = (byte) main::i#3 
-Alias (byte) main::a#14 = (byte) main::a#3 
-Alias (byte) main::i#16 = (byte) main::i#4 
-Alias (byte) main::a#15 = (byte) main::a#4 
-Alias (byte) main::i#17 = (byte) main::i#5 
-Alias (byte) main::a#16 = (byte) main::a#5 
-Alias (byte) main::i#18 = (byte) main::i#6 
-Alias (byte) main::a#17 = (byte) main::a#6 
-Alias (byte) main::i#19 = (byte) main::i#7 
-Alias (byte) main::a#18 = (byte) main::a#7 
-Alias (byte) main::i#20 = (byte) main::i#8 
-Alias (byte) main::a#19 = (byte) main::a#8 
-Alias (byte) main::i#21 = (byte) main::i#9 
-Alias (byte) main::a#20 = (byte) main::a#9 
-Alias (byte) main::i#10 = (byte) main::i#22 
-Alias (byte) test::i#11 = (byte) test::i#12 (byte) test::i#13 
+Alias screen2#0 = $0 screen2#13 
+Alias main::i#0 = main::i#12 
+Alias main::a#0 = main::a#11 
+Alias screen2#10 = screen2#3 screen2#2 screen2#5 screen2#6 screen2#7 screen2#8 screen2#9 screen2#11 screen2#12 screen2#4 
+Alias main::i#1 = main::i#13 
+Alias main::a#1 = main::a#12 
+Alias main::i#14 = main::i#2 
+Alias main::a#13 = main::a#2 
+Alias main::i#15 = main::i#3 
+Alias main::a#14 = main::a#3 
+Alias main::i#16 = main::i#4 
+Alias main::a#15 = main::a#4 
+Alias main::i#17 = main::i#5 
+Alias main::a#16 = main::a#5 
+Alias main::i#18 = main::i#6 
+Alias main::a#17 = main::a#6 
+Alias main::i#19 = main::i#7 
+Alias main::a#18 = main::a#7 
+Alias main::i#20 = main::i#8 
+Alias main::a#19 = main::a#8 
+Alias main::i#21 = main::i#9 
+Alias main::a#20 = main::a#9 
+Alias main::i#10 = main::i#22 
+Alias test::i#11 = test::i#12 test::i#13 
 Successful SSA optimization Pass2AliasElimination
 Identical Phi Values (byte*) screen2#10 (byte*) screen2#0
 Identical Phi Values (byte*) screen2#1 (byte*) screen2#10
@@ -686,9 +686,9 @@ VARIABLE REGISTER WEIGHTS
 (byte*) screen2
 (void()) test((byte) test::i , (byte) test::a)
 (byte) test::a
-(byte) test::a#11 1.3333333333333333
+(byte) test::a#11 67.33333333333333
 (byte) test::i
-(byte) test::i#11 3.0
+(byte) test::i#11 151.5
 
 Initial phi equivalence classes
 [ test::a#11 ]
@@ -950,22 +950,22 @@ test: {
   ref: .byte 3, 4, 3, $12, 9, 1, 4, 2, 4, 5, 1, 0
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Statement [29] *((const byte*) screen2#0 + (byte) test::i#11) ← *((const byte*) ref + (byte) test::i#11) [ test::a#11 test::i#11 ] ( main:2::test:5 [ test::a#11 test::i#11 ] main:2::test:7 [ test::a#11 test::i#11 ] main:2::test:9 [ test::a#11 test::i#11 ] main:2::test:11 [ test::a#11 test::i#11 ] main:2::test:13 [ test::a#11 test::i#11 ] main:2::test:15 [ test::a#11 test::i#11 ] main:2::test:17 [ test::a#11 test::i#11 ] main:2::test:19 [ test::a#11 test::i#11 ] main:2::test:21 [ test::a#11 test::i#11 ] main:2::test:23 [ test::a#11 test::i#11 ] main:2::test:25 [ test::a#11 test::i#11 ] ) always clobbers reg byte a 
+Statement [29] *((const byte*) screen2#0 + (byte) test::i#11) ← *((const byte*) ref + (byte) test::i#11) [ test::a#11 test::i#11 ] ( main:2::test:5 [ test::a#11 test::i#11 ] { }  main:2::test:7 [ test::a#11 test::i#11 ] { }  main:2::test:9 [ test::a#11 test::i#11 ] { }  main:2::test:11 [ test::a#11 test::i#11 ] { }  main:2::test:13 [ test::a#11 test::i#11 ] { }  main:2::test:15 [ test::a#11 test::i#11 ] { }  main:2::test:17 [ test::a#11 test::i#11 ] { }  main:2::test:19 [ test::a#11 test::i#11 ] { }  main:2::test:21 [ test::a#11 test::i#11 ] { }  main:2::test:23 [ test::a#11 test::i#11 ] { }  main:2::test:25 [ test::a#11 test::i#11 ] { }  ) always clobbers reg byte a 
 Removing always clobbered register reg byte a as potential for zp[1]:2 [ test::a#11 ]
 Removing always clobbered register reg byte a as potential for zp[1]:3 [ test::i#11 ]
-Statement [30] if(*((const byte*) ref + (byte) test::i#11)==(byte) test::a#11) goto test::@1 [ test::i#11 ] ( main:2::test:5 [ test::i#11 ] main:2::test:7 [ test::i#11 ] main:2::test:9 [ test::i#11 ] main:2::test:11 [ test::i#11 ] main:2::test:13 [ test::i#11 ] main:2::test:15 [ test::i#11 ] main:2::test:17 [ test::i#11 ] main:2::test:19 [ test::i#11 ] main:2::test:21 [ test::i#11 ] main:2::test:23 [ test::i#11 ] main:2::test:25 [ test::i#11 ] ) always clobbers reg byte a 
-Statement [31] *((const byte*) cols + (byte) test::i#11) ← (const byte) RED [ ] ( main:2::test:5 [ ] main:2::test:7 [ ] main:2::test:9 [ ] main:2::test:11 [ ] main:2::test:13 [ ] main:2::test:15 [ ] main:2::test:17 [ ] main:2::test:19 [ ] main:2::test:21 [ ] main:2::test:23 [ ] main:2::test:25 [ ] ) always clobbers reg byte a 
-Statement [33] *((const byte*) cols + (byte) test::i#11) ← (const byte) GREEN [ ] ( main:2::test:5 [ ] main:2::test:7 [ ] main:2::test:9 [ ] main:2::test:11 [ ] main:2::test:13 [ ] main:2::test:15 [ ] main:2::test:17 [ ] main:2::test:19 [ ] main:2::test:21 [ ] main:2::test:23 [ ] main:2::test:25 [ ] ) always clobbers reg byte a 
-Statement [28] *((const byte*) screen1 + (byte) test::i#11) ← (byte) test::a#11 [ test::a#11 test::i#11 ] ( main:2::test:5 [ test::a#11 test::i#11 ] main:2::test:7 [ test::a#11 test::i#11 ] main:2::test:9 [ test::a#11 test::i#11 ] main:2::test:11 [ test::a#11 test::i#11 ] main:2::test:13 [ test::a#11 test::i#11 ] main:2::test:15 [ test::a#11 test::i#11 ] main:2::test:17 [ test::a#11 test::i#11 ] main:2::test:19 [ test::a#11 test::i#11 ] main:2::test:21 [ test::a#11 test::i#11 ] main:2::test:23 [ test::a#11 test::i#11 ] main:2::test:25 [ test::a#11 test::i#11 ] ) always clobbers reg byte a 
-Statement [29] *((const byte*) screen2#0 + (byte) test::i#11) ← *((const byte*) ref + (byte) test::i#11) [ test::a#11 test::i#11 ] ( main:2::test:5 [ test::a#11 test::i#11 ] main:2::test:7 [ test::a#11 test::i#11 ] main:2::test:9 [ test::a#11 test::i#11 ] main:2::test:11 [ test::a#11 test::i#11 ] main:2::test:13 [ test::a#11 test::i#11 ] main:2::test:15 [ test::a#11 test::i#11 ] main:2::test:17 [ test::a#11 test::i#11 ] main:2::test:19 [ test::a#11 test::i#11 ] main:2::test:21 [ test::a#11 test::i#11 ] main:2::test:23 [ test::a#11 test::i#11 ] main:2::test:25 [ test::a#11 test::i#11 ] ) always clobbers reg byte a 
-Statement [30] if(*((const byte*) ref + (byte) test::i#11)==(byte) test::a#11) goto test::@1 [ test::i#11 ] ( main:2::test:5 [ test::i#11 ] main:2::test:7 [ test::i#11 ] main:2::test:9 [ test::i#11 ] main:2::test:11 [ test::i#11 ] main:2::test:13 [ test::i#11 ] main:2::test:15 [ test::i#11 ] main:2::test:17 [ test::i#11 ] main:2::test:19 [ test::i#11 ] main:2::test:21 [ test::i#11 ] main:2::test:23 [ test::i#11 ] main:2::test:25 [ test::i#11 ] ) always clobbers reg byte a 
-Statement [31] *((const byte*) cols + (byte) test::i#11) ← (const byte) RED [ ] ( main:2::test:5 [ ] main:2::test:7 [ ] main:2::test:9 [ ] main:2::test:11 [ ] main:2::test:13 [ ] main:2::test:15 [ ] main:2::test:17 [ ] main:2::test:19 [ ] main:2::test:21 [ ] main:2::test:23 [ ] main:2::test:25 [ ] ) always clobbers reg byte a 
-Statement [33] *((const byte*) cols + (byte) test::i#11) ← (const byte) GREEN [ ] ( main:2::test:5 [ ] main:2::test:7 [ ] main:2::test:9 [ ] main:2::test:11 [ ] main:2::test:13 [ ] main:2::test:15 [ ] main:2::test:17 [ ] main:2::test:19 [ ] main:2::test:21 [ ] main:2::test:23 [ ] main:2::test:25 [ ] ) always clobbers reg byte a 
+Statement [30] if(*((const byte*) ref + (byte) test::i#11)==(byte) test::a#11) goto test::@1 [ test::i#11 ] ( main:2::test:5 [ test::i#11 ] { }  main:2::test:7 [ test::i#11 ] { }  main:2::test:9 [ test::i#11 ] { }  main:2::test:11 [ test::i#11 ] { }  main:2::test:13 [ test::i#11 ] { }  main:2::test:15 [ test::i#11 ] { }  main:2::test:17 [ test::i#11 ] { }  main:2::test:19 [ test::i#11 ] { }  main:2::test:21 [ test::i#11 ] { }  main:2::test:23 [ test::i#11 ] { }  main:2::test:25 [ test::i#11 ] { }  ) always clobbers reg byte a 
+Statement [31] *((const byte*) cols + (byte) test::i#11) ← (const byte) RED [ ] ( main:2::test:5 [ ] { }  main:2::test:7 [ ] { }  main:2::test:9 [ ] { }  main:2::test:11 [ ] { }  main:2::test:13 [ ] { }  main:2::test:15 [ ] { }  main:2::test:17 [ ] { }  main:2::test:19 [ ] { }  main:2::test:21 [ ] { }  main:2::test:23 [ ] { }  main:2::test:25 [ ] { }  ) always clobbers reg byte a 
+Statement [33] *((const byte*) cols + (byte) test::i#11) ← (const byte) GREEN [ ] ( main:2::test:5 [ ] { }  main:2::test:7 [ ] { }  main:2::test:9 [ ] { }  main:2::test:11 [ ] { }  main:2::test:13 [ ] { }  main:2::test:15 [ ] { }  main:2::test:17 [ ] { }  main:2::test:19 [ ] { }  main:2::test:21 [ ] { }  main:2::test:23 [ ] { }  main:2::test:25 [ ] { }  ) always clobbers reg byte a 
+Statement [28] *((const byte*) screen1 + (byte) test::i#11) ← (byte) test::a#11 [ test::a#11 test::i#11 ] ( main:2::test:5 [ test::a#11 test::i#11 ] { }  main:2::test:7 [ test::a#11 test::i#11 ] { }  main:2::test:9 [ test::a#11 test::i#11 ] { }  main:2::test:11 [ test::a#11 test::i#11 ] { }  main:2::test:13 [ test::a#11 test::i#11 ] { }  main:2::test:15 [ test::a#11 test::i#11 ] { }  main:2::test:17 [ test::a#11 test::i#11 ] { }  main:2::test:19 [ test::a#11 test::i#11 ] { }  main:2::test:21 [ test::a#11 test::i#11 ] { }  main:2::test:23 [ test::a#11 test::i#11 ] { }  main:2::test:25 [ test::a#11 test::i#11 ] { }  ) always clobbers reg byte a 
+Statement [29] *((const byte*) screen2#0 + (byte) test::i#11) ← *((const byte*) ref + (byte) test::i#11) [ test::a#11 test::i#11 ] ( main:2::test:5 [ test::a#11 test::i#11 ] { }  main:2::test:7 [ test::a#11 test::i#11 ] { }  main:2::test:9 [ test::a#11 test::i#11 ] { }  main:2::test:11 [ test::a#11 test::i#11 ] { }  main:2::test:13 [ test::a#11 test::i#11 ] { }  main:2::test:15 [ test::a#11 test::i#11 ] { }  main:2::test:17 [ test::a#11 test::i#11 ] { }  main:2::test:19 [ test::a#11 test::i#11 ] { }  main:2::test:21 [ test::a#11 test::i#11 ] { }  main:2::test:23 [ test::a#11 test::i#11 ] { }  main:2::test:25 [ test::a#11 test::i#11 ] { }  ) always clobbers reg byte a 
+Statement [30] if(*((const byte*) ref + (byte) test::i#11)==(byte) test::a#11) goto test::@1 [ test::i#11 ] ( main:2::test:5 [ test::i#11 ] { }  main:2::test:7 [ test::i#11 ] { }  main:2::test:9 [ test::i#11 ] { }  main:2::test:11 [ test::i#11 ] { }  main:2::test:13 [ test::i#11 ] { }  main:2::test:15 [ test::i#11 ] { }  main:2::test:17 [ test::i#11 ] { }  main:2::test:19 [ test::i#11 ] { }  main:2::test:21 [ test::i#11 ] { }  main:2::test:23 [ test::i#11 ] { }  main:2::test:25 [ test::i#11 ] { }  ) always clobbers reg byte a 
+Statement [31] *((const byte*) cols + (byte) test::i#11) ← (const byte) RED [ ] ( main:2::test:5 [ ] { }  main:2::test:7 [ ] { }  main:2::test:9 [ ] { }  main:2::test:11 [ ] { }  main:2::test:13 [ ] { }  main:2::test:15 [ ] { }  main:2::test:17 [ ] { }  main:2::test:19 [ ] { }  main:2::test:21 [ ] { }  main:2::test:23 [ ] { }  main:2::test:25 [ ] { }  ) always clobbers reg byte a 
+Statement [33] *((const byte*) cols + (byte) test::i#11) ← (const byte) GREEN [ ] ( main:2::test:5 [ ] { }  main:2::test:7 [ ] { }  main:2::test:9 [ ] { }  main:2::test:11 [ ] { }  main:2::test:13 [ ] { }  main:2::test:15 [ ] { }  main:2::test:17 [ ] { }  main:2::test:19 [ ] { }  main:2::test:21 [ ] { }  main:2::test:23 [ ] { }  main:2::test:25 [ ] { }  ) always clobbers reg byte a 
 Potential registers zp[1]:2 [ test::a#11 ] : zp[1]:2 , reg byte x , reg byte y , 
 Potential registers zp[1]:3 [ test::i#11 ] : zp[1]:3 , reg byte x , reg byte y , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [test] 3: zp[1]:3 [ test::i#11 ] 1.33: zp[1]:2 [ test::a#11 ] 
+Uplift Scope [test] 151.5: zp[1]:3 [ test::i#11 ] 67.33: zp[1]:2 [ test::a#11 ] 
 Uplift Scope [main] 
 Uplift Scope [] 
 
@@ -1303,9 +1303,9 @@ FINAL SYMBOL TABLE
 (label) test::@2
 (label) test::@return
 (byte) test::a
-(byte) test::a#11 a zp[1]:2 1.3333333333333333
+(byte) test::a#11 a zp[1]:2 67.33333333333333
 (byte) test::i
-(byte) test::i#11 reg byte x 3.0
+(byte) test::i#11 reg byte x 151.5
 
 zp[1]:2 [ test::a#11 ]
 reg byte x [ test::i#11 ]

src/test/ref/assignment-compound.sym

@@ -27,9 +27,9 @@
 (label) test::@2
 (label) test::@return
 (byte) test::a
-(byte) test::a#11 a zp[1]:2 1.3333333333333333
+(byte) test::a#11 a zp[1]:2 67.33333333333333
 (byte) test::i
-(byte) test::i#11 reg byte x 3.0
+(byte) test::i#11 reg byte x 151.5
 
 zp[1]:2 [ test::a#11 ]
 reg byte x [ test::i#11 ]

src/test/ref/bgblack.log

@@ -107,7 +107,7 @@ main: {
   // File Data
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Statement [4] *((const byte*) BGCOL) ← (const byte) BLACK [ ] ( main:2 [ ] ) always clobbers reg byte a 
+Statement [4] *((const byte*) BGCOL) ← (const byte) BLACK [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
 
 REGISTER UPLIFT SCOPES
 Uplift Scope [main] 

src/test/ref/bitmap-circle-2.log

@@ -652,49 +652,49 @@ Inferred type updated to signed word in (snumber~) plot::$8 ← (signed word) pl
 Inferred type updated to byte in (unumber~) plot::$10 ← (byte~) plot::$9 & (byte) 7
 Inferred type updated to signed word in (snumber~) plot::$12 ← (signed word~) plot::$11 * (signed word) $140
 Inferred type updated to signed byte in (snumber~) plot::$13 ← (signed word) plot::x#9 & (signed byte) 7
-Alias (signed word) main::i#2 = (signed word) main::i#3 (signed word) main::i#4 
-Alias (signed word) circle::y#0 = (signed word) circle::r#1 
-Alias (signed word) circle::p#0 = (signed word~) circle::$1 
-Alias (signed word) circle::p#3 = (signed word) circle::p#6 (signed word) circle::p#4 (signed word) circle::p#5 
-Alias (signed word) circle::x1#14 = (signed word) circle::x1#2 (signed word) circle::x1#3 (signed word) circle::x1#4 
-Alias (signed word) circle::y#13 = (signed word) circle::y#2 (signed word) circle::y#14 (signed word) circle::y#3 
-Alias (signed word) circle::xc#10 = (signed word) circle::xc#11 (signed word) circle::xc#12 (signed word) circle::xc#9 
-Alias (signed word) circle::yc#10 = (signed word) circle::yc#11 (signed word) circle::yc#12 (signed word) circle::yc#9 
-Alias (signed word) circle::p#1 = (signed word~) circle::$11 
-Alias (signed word) circle::y#1 = (signed word~) circle::$4 
-Alias (signed word) circle::p#2 = (signed word~) circle::$8 
-Alias (signed word) plot::x#0 = (signed word~) circle::$12 
-Alias (signed word) plot::y#0 = (signed word~) circle::$13 
-Alias (signed word) circle::xc#1 = (signed word) circle::xc#2 (signed word) circle::xc#3 (signed word) circle::xc#4 (signed word) circle::xc#5 (signed word) circle::xc#6 (signed word) circle::xc#7 (signed word) circle::xc#8 (signed word) circle::xc#14 
-Alias (signed word) circle::x1#10 = (signed word) circle::x1#6 (signed word) circle::x1#5 (signed word) circle::x1#7 (signed word) circle::x1#8 (signed word) circle::x1#9 (signed word) circle::x1#11 (signed word) circle::x1#12 (signed word) circle::x1#13 
-Alias (signed word) circle::yc#1 = (signed word) circle::yc#2 (signed word) circle::yc#3 (signed word) circle::yc#4 (signed word) circle::yc#5 (signed word) circle::yc#6 (signed word) circle::yc#7 (signed word) circle::yc#8 (signed word) circle::yc#14 
-Alias (signed word) circle::y#10 = (signed word) circle::y#5 (signed word) circle::y#4 (signed word) circle::y#6 (signed word) circle::y#7 (signed word) circle::y#8 (signed word) circle::y#9 (signed word) circle::y#11 (signed word) circle::y#12 
-Alias (signed word) circle::p#10 = (signed word) circle::p#14 (signed word) circle::p#15 (signed word) circle::p#13 (signed word) circle::p#12 (signed word) circle::p#11 (signed word) circle::p#9 (signed word) circle::p#8 (signed word) circle::p#7 
-Alias (signed word) plot::x#1 = (signed word~) circle::$15 
-Alias (signed word) plot::y#1 = (signed word~) circle::$16 
-Alias (signed word) plot::x#2 = (signed word~) circle::$18 
-Alias (signed word) plot::y#2 = (signed word~) circle::$19 
-Alias (signed word) plot::x#3 = (signed word~) circle::$21 
-Alias (signed word) plot::y#3 = (signed word~) circle::$22 
-Alias (signed word) plot::x#4 = (signed word~) circle::$24 
-Alias (signed word) plot::y#4 = (signed word~) circle::$25 
-Alias (signed word) plot::x#5 = (signed word~) circle::$27 
-Alias (signed word) plot::y#5 = (signed word~) circle::$28 
-Alias (signed word) plot::x#6 = (signed word~) circle::$30 
-Alias (signed word) plot::y#6 = (signed word~) circle::$31 
-Alias (signed word) plot::x#7 = (signed word~) circle::$33 
-Alias (signed word) plot::y#7 = (signed word~) circle::$34 
-Alias (signed word) plot::x#8 = (signed word) plot::x#9 
-Alias (signed word) plot::y#8 = (signed word) plot::y#9 
-Alias (byte*) fill::end#0 = (byte*~) fill::$0 
-Alias (byte*) fill::addr#0 = (byte*) fill::start#2 
-Alias (byte) fill::val#2 = (byte) fill::val#3 
-Alias (byte*) fill::addr#2 = (byte*) fill::addr#3 
-Alias (byte*) fill::end#1 = (byte*) fill::end#2 
+Alias main::i#2 = main::i#3 main::i#4 
+Alias circle::y#0 = circle::r#1 
+Alias circle::p#0 = circle::$1 
+Alias circle::p#3 = circle::p#6 circle::p#4 circle::p#5 
+Alias circle::x1#14 = circle::x1#2 circle::x1#3 circle::x1#4 
+Alias circle::y#13 = circle::y#2 circle::y#14 circle::y#3 
+Alias circle::xc#10 = circle::xc#11 circle::xc#12 circle::xc#9 
+Alias circle::yc#10 = circle::yc#11 circle::yc#12 circle::yc#9 
+Alias circle::p#1 = circle::$11 
+Alias circle::y#1 = circle::$4 
+Alias circle::p#2 = circle::$8 
+Alias plot::x#0 = circle::$12 
+Alias plot::y#0 = circle::$13 
+Alias circle::xc#1 = circle::xc#2 circle::xc#3 circle::xc#4 circle::xc#5 circle::xc#6 circle::xc#7 circle::xc#8 circle::xc#14 
+Alias circle::x1#10 = circle::x1#6 circle::x1#5 circle::x1#7 circle::x1#8 circle::x1#9 circle::x1#11 circle::x1#12 circle::x1#13 
+Alias circle::yc#1 = circle::yc#2 circle::yc#3 circle::yc#4 circle::yc#5 circle::yc#6 circle::yc#7 circle::yc#8 circle::yc#14 
+Alias circle::y#10 = circle::y#5 circle::y#4 circle::y#6 circle::y#7 circle::y#8 circle::y#9 circle::y#11 circle::y#12 
+Alias circle::p#10 = circle::p#14 circle::p#15 circle::p#13 circle::p#12 circle::p#11 circle::p#9 circle::p#8 circle::p#7 
+Alias plot::x#1 = circle::$15 
+Alias plot::y#1 = circle::$16 
+Alias plot::x#2 = circle::$18 
+Alias plot::y#2 = circle::$19 
+Alias plot::x#3 = circle::$21 
+Alias plot::y#3 = circle::$22 
+Alias plot::x#4 = circle::$24 
+Alias plot::y#4 = circle::$25 
+Alias plot::x#5 = circle::$27 
+Alias plot::y#5 = circle::$28 
+Alias plot::x#6 = circle::$30 
+Alias plot::y#6 = circle::$31 
+Alias plot::x#7 = circle::$33 
+Alias plot::y#7 = circle::$34 
+Alias plot::x#8 = plot::x#9 
+Alias plot::y#8 = plot::y#9 
+Alias fill::end#0 = fill::$0 
+Alias fill::addr#0 = fill::start#2 
+Alias fill::val#2 = fill::val#3 
+Alias fill::addr#2 = fill::addr#3 
+Alias fill::end#1 = fill::end#2 
 Successful SSA optimization Pass2AliasElimination
-Alias (signed word) circle::xc#1 = (signed word) circle::xc#10 
-Alias (signed word) circle::x1#10 = (signed word) circle::x1#14 
-Alias (signed word) circle::yc#1 = (signed word) circle::yc#10 
+Alias circle::xc#1 = circle::xc#10 
+Alias circle::x1#10 = circle::x1#14 
+Alias circle::yc#1 = circle::yc#10 
 Successful SSA optimization Pass2AliasElimination
 Identical Phi Values (signed word) circle::y#0 (signed word) circle::r#0
 Identical Phi Values (signed word) circle::xc#13 (signed word) circle::xc#0
@@ -765,7 +765,7 @@ Constant inlined main::i#0 = (signed word) 1
 Constant inlined fill::size#1 = (signed word)(number) $28*(number) $19
 Constant inlined fill::size#0 = (signed word)(number) $28*(number) $19*(number) 8
 Successful SSA optimization Pass2ConstantInlining
-Alias (signed word~) plot::$12 = (signed word~) plot::$17 
+Alias plot::$12 = plot::$17 
 Successful SSA optimization Pass2AliasElimination
 Adding NOP phi() at start of @begin
 Adding NOP phi() at start of @8
@@ -1007,79 +1007,79 @@ fill::@2: scope:[fill]  from fill::@1
 
 VARIABLE REGISTER WEIGHTS
 (void()) circle((signed word) circle::xc , (signed word) circle::yc , (signed word) circle::r)
-(signed word~) circle::$0 4.0
-(signed word~) circle::$10 202.0
-(signed word~) circle::$5 202.0
-(signed word~) circle::$6 202.0
-(signed word~) circle::$7 202.0
-(signed word~) circle::$9 202.0
+(signed word~) circle::$0 2002.0
+(signed word~) circle::$10 200002.0
+(signed word~) circle::$5 200002.0
+(signed word~) circle::$6 200002.0
+(signed word~) circle::$7 200002.0
+(signed word~) circle::$9 200002.0
 (signed word) circle::p
-(signed word) circle::p#0 4.0
-(signed word) circle::p#1 202.0
-(signed word) circle::p#10 11.653846153846153
-(signed word) circle::p#2 202.0
-(signed word) circle::p#3 58.00000000000001
+(signed word) circle::p#0 2002.0
+(signed word) circle::p#1 200002.0
+(signed word) circle::p#10 11538.576923076922
+(signed word) circle::p#2 200002.0
+(signed word) circle::p#3 57286.42857142857
 (signed word) circle::r
-(signed word) circle::r#0 5.0
+(signed word) circle::r#0 701.0
 (signed word) circle::x1
-(signed word) circle::x1#1 202.0
-(signed word) circle::x1#10 36.47222222222223
+(signed word) circle::x1#1 200002.0
+(signed word) circle::x1#10 36111.47222222222
 (signed word) circle::xc
 (signed word) circle::y
-(signed word) circle::y#1 60.599999999999994
-(signed word) circle::y#10 42.73076923076923
-(signed word) circle::y#13 67.66666666666666
+(signed word) circle::y#1 60000.600000000006
+(signed word) circle::y#10 42308.11538461538
+(signed word) circle::y#13 66834.16666666666
 (signed word) circle::yc
 (void()) fill((byte*) fill::start , (signed word) fill::size , (byte) fill::val)
 (byte*) fill::addr
-(byte*) fill::addr#0 2.0
-(byte*) fill::addr#1 22.0
-(byte*) fill::addr#2 15.333333333333332
+(byte*) fill::addr#0 101.0
+(byte*) fill::addr#1 2002.0
+(byte*) fill::addr#2 1368.3333333333335
 (byte*) fill::end
-(byte*) fill::end#0 2.6
+(byte*) fill::end#0 220.39999999999998
 (signed word) fill::size
-(signed word) fill::size#2 2.0
+(signed word) fill::size#2 101.0
 (byte*) fill::start
 (byte) fill::val
-(byte) fill::val#4 1.8333333333333333
+(byte) fill::val#4 166.83333333333334
 (void()) main()
 (signed word) main::i
-(signed word) main::i#1 22.0
-(signed word) main::i#2 11.0
+(signed word) main::i#1 202.0
+(signed word) main::i#2 101.0
 (void()) plot((signed word) plot::x , (signed word) plot::y)
-(byte~) plot::$10 4.0
-(signed word~) plot::$11 3.0
-(signed word~) plot::$12 4.0
-(signed byte~) plot::$13 4.0
-(byte~) plot::$14 4.0
-(signed word~) plot::$15 4.0
-(signed word~) plot::$16 4.0
-(signed word~) plot::$8 4.0
-(byte~) plot::$9 4.0
+(byte~) plot::$10 2000002.0
+(signed word~) plot::$11 1500001.5
+(signed word~) plot::$12 2000002.0
+(signed byte~) plot::$13 2000002.0
+(byte~) plot::$14 2000002.0
+(signed word~) plot::$15 2000002.0
+(signed word~) plot::$16 2000002.0
+(signed word~) plot::$8 2000002.0
+(byte~) plot::$9 2000002.0
 (byte*) plot::location
-(byte*) plot::location#1 1.3333333333333333
-(byte*) plot::location#2 0.8
-(byte*) plot::location#3 2.0
+(byte*) plot::location#1 666667.3333333334
+(byte*) plot::location#2 400000.4
+(byte*) plot::location#3 1000001.0
 (signed word) plot::x
-(signed word) plot::x#0 101.0
-(signed word) plot::x#1 101.0
-(signed word) plot::x#2 101.0
-(signed word) plot::x#3 101.0
-(signed word) plot::x#4 101.0
-(signed word) plot::x#5 101.0
-(signed word) plot::x#6 101.0
-(signed word) plot::x#7 101.0
-(signed word) plot::x#8 54.4
+(signed word) plot::x#0 100001.0
+(signed word) plot::x#1 100001.0
+(signed word) plot::x#2 100001.0
+(signed word) plot::x#3 100001.0
+(signed word) plot::x#4 100001.0
+(signed word) plot::x#5 100001.0
+(signed word) plot::x#6 100001.0
+(signed word) plot::x#7 100001.0
+(signed word) plot::x#8 320000.80000000005
 (signed word) plot::y
-(signed word) plot::y#0 202.0
-(signed word) plot::y#1 202.0
-(signed word) plot::y#2 202.0
-(signed word) plot::y#3 202.0
-(signed word) plot::y#4 202.0
-(signed word) plot::y#5 202.0
-(signed word) plot::y#6 202.0
-(signed word) plot::y#7 202.0
-(signed word) plot::y#8 81.60000000000001
+(signed word) plot::y#0 200002.0
+(signed word) plot::y#1 200002.0
+(signed word) plot::y#2 200002.0
+(signed word) plot::y#3 200002.0
+(signed word) plot::y#4 200002.0
+(signed word) plot::y#5 200002.0
+(signed word) plot::y#6 200002.0
+(signed word) plot::y#7 200002.0
+(signed word) plot::y#8 480001.19999999995
 
 Initial phi equivalence classes
 [ main::i#2 main::i#1 ]
@@ -1872,114 +1872,112 @@ fill: {
   bitmask: .byte $80, $40, $20, $10, 8, 4, 2, 1
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Statement [8] *((const byte*) BORDERCOL) ← (const byte) BLUE [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [9] *((const byte*) D011) ← (const byte) VIC_BMM|(const byte) VIC_DEN|(const byte) VIC_RSEL|(byte) 3 [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [10] *((const byte*) VIC_MEMORY) ← (byte)(word)(const byte*) SCREEN&(word) $3fff/(byte) $40|(word)(const byte*) BITMAP&(word) $3fff/(word) $400 [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [12] if((signed word) main::i#2<(signed word) $b4) goto main::@2 [ main::i#2 ] ( main:2 [ main::i#2 ] ) always clobbers reg byte a 
-Statement [14] (signed word) circle::r#0 ← (signed word) main::i#2 [ main::i#2 circle::r#0 ] ( main:2 [ main::i#2 circle::r#0 ] ) always clobbers reg byte a 
-Statement [16] (signed word) main::i#1 ← (signed word) main::i#2 + (signed byte) 5 [ main::i#1 ] ( main:2 [ main::i#1 ] ) always clobbers reg byte a 
-Statement [17] (signed word~) circle::$0 ← (signed word) circle::r#0 << (signed byte) 1 [ circle::r#0 circle::$0 ] ( main:2::circle:15 [ main::i#2 circle::r#0 circle::$0 ] ) always clobbers reg byte a 
-Statement [18] (signed word) circle::p#0 ← (signed byte) 3 - (signed word~) circle::$0 [ circle::r#0 circle::p#0 ] ( main:2::circle:15 [ main::i#2 circle::r#0 circle::p#0 ] ) always clobbers reg byte a 
-Statement [20] if((signed word) circle::x1#10<=(signed word) circle::y#13) goto circle::@2 [ circle::x1#10 circle::y#13 circle::p#3 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#13 circle::p#3 ] ) always clobbers reg byte a 
-Statement [22] if((signed word) circle::p#3<(signed byte) 0) goto circle::@3 [ circle::x1#10 circle::y#13 circle::p#3 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#13 circle::p#3 ] ) always clobbers reg byte a 
-Statement [23] (signed word) circle::y#1 ← (signed word) circle::y#13 - (signed byte) 1 [ circle::x1#10 circle::p#3 circle::y#1 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::p#3 circle::y#1 ] ) always clobbers reg byte a 
-Statement [24] (signed word~) circle::$5 ← (signed word) circle::x1#10 - (signed word) circle::y#1 [ circle::x1#10 circle::p#3 circle::y#1 circle::$5 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::p#3 circle::y#1 circle::$5 ] ) always clobbers reg byte a 
-Statement [25] (signed word~) circle::$6 ← (signed word~) circle::$5 << (signed byte) 2 [ circle::x1#10 circle::p#3 circle::y#1 circle::$6 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::p#3 circle::y#1 circle::$6 ] ) always clobbers reg byte a 
-Statement [26] (signed word~) circle::$7 ← (signed word) circle::p#3 + (signed word~) circle::$6 [ circle::x1#10 circle::y#1 circle::$7 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#1 circle::$7 ] ) always clobbers reg byte a 
-Statement [27] (signed word) circle::p#2 ← (signed word~) circle::$7 + (signed byte) $a [ circle::x1#10 circle::y#1 circle::p#2 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#1 circle::p#2 ] ) always clobbers reg byte a 
-Statement [29] (signed word) plot::x#0 ← (const signed word) circle::xc#0 + (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#0 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#0 ] ) always clobbers reg byte a 
-Statement [30] (signed word) plot::y#0 ← (const signed word) circle::yc#0 - (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#0 plot::y#0 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#0 plot::y#0 ] ) always clobbers reg byte a 
-Statement [32] (signed word) plot::x#1 ← (const signed word) circle::xc#0 - (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#1 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#1 ] ) always clobbers reg byte a 
-Statement [33] (signed word) plot::y#1 ← (const signed word) circle::yc#0 - (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#1 plot::y#1 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#1 plot::y#1 ] ) always clobbers reg byte a 
-Statement [35] (signed word) plot::x#2 ← (const signed word) circle::xc#0 + (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#2 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#2 ] ) always clobbers reg byte a 
-Statement [36] (signed word) plot::y#2 ← (const signed word) circle::yc#0 + (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#2 plot::y#2 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#2 plot::y#2 ] ) always clobbers reg byte a 
-Statement [38] (signed word) plot::x#3 ← (const signed word) circle::xc#0 - (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#3 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#3 ] ) always clobbers reg byte a 
-Statement [39] (signed word) plot::y#3 ← (const signed word) circle::yc#0 + (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#3 plot::y#3 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#3 plot::y#3 ] ) always clobbers reg byte a 
-Statement [41] (signed word) plot::x#4 ← (const signed word) circle::xc#0 + (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#4 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#4 ] ) always clobbers reg byte a 
-Statement [42] (signed word) plot::y#4 ← (const signed word) circle::yc#0 - (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#4 plot::y#4 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#4 plot::y#4 ] ) always clobbers reg byte a 
-Statement [44] (signed word) plot::x#5 ← (const signed word) circle::xc#0 - (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#5 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#5 ] ) always clobbers reg byte a 
-Statement [45] (signed word) plot::y#5 ← (const signed word) circle::yc#0 - (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#5 plot::y#5 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#5 plot::y#5 ] ) always clobbers reg byte a 
-Statement [47] (signed word) plot::x#6 ← (const signed word) circle::xc#0 + (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#6 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#6 ] ) always clobbers reg byte a 
-Statement [48] (signed word) plot::y#6 ← (const signed word) circle::yc#0 + (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#6 plot::y#6 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#6 plot::y#6 ] ) always clobbers reg byte a 
-Statement [50] (signed word) plot::x#7 ← (const signed word) circle::xc#0 - (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#7 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#7 ] ) always clobbers reg byte a 
-Statement [51] (signed word) plot::y#7 ← (const signed word) circle::yc#0 + (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#7 plot::y#7 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#7 plot::y#7 ] ) always clobbers reg byte a 
-Statement [54] (signed word~) circle::$9 ← (signed word) circle::x1#10 << (signed byte) 2 [ circle::x1#10 circle::y#13 circle::p#3 circle::$9 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#13 circle::p#3 circle::$9 ] ) always clobbers reg byte a 
-Statement [55] (signed word~) circle::$10 ← (signed word) circle::p#3 + (signed word~) circle::$9 [ circle::x1#10 circle::y#13 circle::$10 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#13 circle::$10 ] ) always clobbers reg byte a 
-Statement [56] (signed word) circle::p#1 ← (signed word~) circle::$10 + (signed byte) 6 [ circle::x1#10 circle::y#13 circle::p#1 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#13 circle::p#1 ] ) always clobbers reg byte a 
-Statement [58] if((signed word) plot::x#8<(signed byte) 0) goto plot::@return [ plot::x#8 plot::y#8 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] ) always clobbers reg byte a 
-Statement [59] if((signed word) plot::x#8>(signed word) $13f) goto plot::@return [ plot::x#8 plot::y#8 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] ) always clobbers reg byte a 
-Statement [60] if((signed word) plot::y#8<(signed byte) 0) goto plot::@return [ plot::x#8 plot::y#8 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] ) always clobbers reg byte a 
-Statement [61] if((signed word) plot::y#8>=(signed word) $c7+(signed byte) 1) goto plot::@return [ plot::x#8 plot::y#8 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] ) always clobbers reg byte a 
-Statement [62] (signed word~) plot::$8 ← (signed word) plot::x#8 & (signed dword) $fff8 [ plot::x#8 plot::y#8 plot::$8 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$8 ] main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$8 ] main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$8 ] main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$8 ] main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$8 ] main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$8 ] main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$8 ] main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$8 ] ) always clobbers reg byte a 
-Statement [63] (byte*) plot::location#1 ← (const byte*) BITMAP + (signed word~) plot::$8 [ plot::x#8 plot::y#8 plot::location#1 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] ) always clobbers reg byte a 
-Statement [64] (byte~) plot::$9 ← < (signed word) plot::y#8 [ plot::x#8 plot::y#8 plot::location#1 plot::$9 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 plot::$9 ] main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 plot::$9 ] main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 plot::$9 ] main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 plot::$9 ] main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 plot::$9 ] main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 plot::$9 ] main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 plot::$9 ] main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 plot::$9 ] ) always clobbers reg byte a 
-Statement [66] (byte*) plot::location#2 ← (byte*) plot::location#1 + (byte~) plot::$10 [ plot::x#8 plot::y#8 plot::location#2 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] ) always clobbers reg byte a 
-Statement [67] (signed word~) plot::$11 ← (signed word) plot::y#8 >> (signed byte) 3 [ plot::x#8 plot::location#2 plot::$11 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 ] main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 ] main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 ] main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 ] main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 ] main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 ] main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 ] main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 ] ) always clobbers reg byte a 
-Statement [68] (signed word~) plot::$15 ← (signed word~) plot::$11 << (byte) 2 [ plot::x#8 plot::location#2 plot::$11 plot::$15 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 plot::$15 ] main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 plot::$15 ] main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 plot::$15 ] main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 plot::$15 ] main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 plot::$15 ] main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 plot::$15 ] main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 plot::$15 ] main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 plot::$15 ] ) always clobbers reg byte a 
-Statement [69] (signed word~) plot::$16 ← (signed word~) plot::$15 + (signed word~) plot::$11 [ plot::x#8 plot::location#2 plot::$16 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$16 ] main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$16 ] main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$16 ] main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$16 ] main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$16 ] main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$16 ] main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$16 ] main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$16 ] ) always clobbers reg byte a 
-Statement [70] (signed word~) plot::$12 ← (signed word~) plot::$16 << (byte) 6 [ plot::x#8 plot::location#2 plot::$12 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$12 ] main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$12 ] main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$12 ] main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$12 ] main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$12 ] main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$12 ] main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$12 ] main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$12 ] ) always clobbers reg byte a 
-Statement [71] (byte*) plot::location#3 ← (byte*) plot::location#2 + (signed word~) plot::$12 [ plot::x#8 plot::location#3 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] ) always clobbers reg byte a 
-Statement [72] (signed byte~) plot::$13 ← (signed word) plot::x#8 & (signed byte) 7 [ plot::location#3 plot::$13 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$13 ] main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$13 ] main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$13 ] main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$13 ] main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$13 ] main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$13 ] main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$13 ] main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$13 ] ) always clobbers reg byte a 
-Statement [73] (byte~) plot::$14 ← *((byte*) plot::location#3) | *((const byte*) bitmask + (signed byte~) plot::$13) [ plot::location#3 plot::$14 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$14 ] main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$14 ] main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$14 ] main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$14 ] main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$14 ] main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$14 ] main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$14 ] main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$14 ] ) always clobbers reg byte a reg byte y 
-Statement [74] *((byte*) plot::location#3) ← (byte~) plot::$14 [ ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 ] main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 ] main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 ] main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 ] main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 ] main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 ] main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 ] main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 ] ) always clobbers reg byte y 
-Statement [77] (byte*) fill::end#0 ← (byte*) fill::addr#0 + (signed word) fill::size#2 [ fill::addr#0 fill::val#4 fill::end#0 ] ( main:2::fill:5 [ fill::addr#0 fill::val#4 fill::end#0 ] main:2::fill:7 [ fill::addr#0 fill::val#4 fill::end#0 ] ) always clobbers reg byte a 
+Statement [8] *((const byte*) BORDERCOL) ← (const byte) BLUE [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [9] *((const byte*) D011) ← (const byte) VIC_BMM|(const byte) VIC_DEN|(const byte) VIC_RSEL|(byte) 3 [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [10] *((const byte*) VIC_MEMORY) ← (byte)(word)(const byte*) SCREEN&(word) $3fff/(byte) $40|(word)(const byte*) BITMAP&(word) $3fff/(word) $400 [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [12] if((signed word) main::i#2<(signed word) $b4) goto main::@2 [ main::i#2 ] ( main:2 [ main::i#2 ] { }  ) always clobbers reg byte a 
+Statement [14] (signed word) circle::r#0 ← (signed word) main::i#2 [ main::i#2 circle::r#0 ] ( main:2 [ main::i#2 circle::r#0 ] { { circle::r#0 = main::i#2 } }  ) always clobbers reg byte a 
+Statement [16] (signed word) main::i#1 ← (signed word) main::i#2 + (signed byte) 5 [ main::i#1 ] ( main:2 [ main::i#1 ] { }  ) always clobbers reg byte a 
+Statement [17] (signed word~) circle::$0 ← (signed word) circle::r#0 << (signed byte) 1 [ circle::r#0 circle::$0 ] ( main:2::circle:15 [ main::i#2 circle::r#0 circle::$0 ] { { circle::r#0 = main::i#2 } }  ) always clobbers reg byte a 
+Statement [18] (signed word) circle::p#0 ← (signed byte) 3 - (signed word~) circle::$0 [ circle::r#0 circle::p#0 ] ( main:2::circle:15 [ main::i#2 circle::r#0 circle::p#0 ] { { circle::r#0 = main::i#2 } }  ) always clobbers reg byte a 
+Statement [20] if((signed word) circle::x1#10<=(signed word) circle::y#13) goto circle::@2 [ circle::x1#10 circle::y#13 circle::p#3 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#13 circle::p#3 ] { { circle::r#0 = main::i#2 } }  ) always clobbers reg byte a 
+Statement [22] if((signed word) circle::p#3<(signed byte) 0) goto circle::@3 [ circle::x1#10 circle::y#13 circle::p#3 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#13 circle::p#3 ] { { circle::r#0 = main::i#2 } }  ) always clobbers reg byte a 
+Statement [23] (signed word) circle::y#1 ← (signed word) circle::y#13 - (signed byte) 1 [ circle::x1#10 circle::p#3 circle::y#1 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::p#3 circle::y#1 ] { { circle::r#0 = main::i#2 } }  ) always clobbers reg byte a 
+Statement [24] (signed word~) circle::$5 ← (signed word) circle::x1#10 - (signed word) circle::y#1 [ circle::x1#10 circle::p#3 circle::y#1 circle::$5 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::p#3 circle::y#1 circle::$5 ] { { circle::r#0 = main::i#2 } }  ) always clobbers reg byte a 
+Statement [25] (signed word~) circle::$6 ← (signed word~) circle::$5 << (signed byte) 2 [ circle::x1#10 circle::p#3 circle::y#1 circle::$6 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::p#3 circle::y#1 circle::$6 ] { { circle::r#0 = main::i#2 } }  ) always clobbers reg byte a 
+Statement [26] (signed word~) circle::$7 ← (signed word) circle::p#3 + (signed word~) circle::$6 [ circle::x1#10 circle::y#1 circle::$7 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#1 circle::$7 ] { { circle::r#0 = main::i#2 } }  ) always clobbers reg byte a 
+Statement [27] (signed word) circle::p#2 ← (signed word~) circle::$7 + (signed byte) $a [ circle::x1#10 circle::y#1 circle::p#2 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#1 circle::p#2 ] { { circle::r#0 = main::i#2 } }  ) always clobbers reg byte a 
+Statement [29] (signed word) plot::x#0 ← (const signed word) circle::xc#0 + (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#0 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#0 ] { { circle::r#0 = main::i#2 } { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [30] (signed word) plot::y#0 ← (const signed word) circle::yc#0 - (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#0 plot::y#0 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#0 plot::y#0 ] { { circle::r#0 = main::i#2 } { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [32] (signed word) plot::x#1 ← (const signed word) circle::xc#0 - (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#1 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#1 ] { { circle::r#0 = main::i#2 } { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [33] (signed word) plot::y#1 ← (const signed word) circle::yc#0 - (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#1 plot::y#1 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#1 plot::y#1 ] { { circle::r#0 = main::i#2 } { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [35] (signed word) plot::x#2 ← (const signed word) circle::xc#0 + (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#2 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#2 ] { { circle::r#0 = main::i#2 } { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [36] (signed word) plot::y#2 ← (const signed word) circle::yc#0 + (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#2 plot::y#2 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#2 plot::y#2 ] { { circle::r#0 = main::i#2 } { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [38] (signed word) plot::x#3 ← (const signed word) circle::xc#0 - (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#3 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#3 ] { { circle::r#0 = main::i#2 } { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [39] (signed word) plot::y#3 ← (const signed word) circle::yc#0 + (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#3 plot::y#3 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#3 plot::y#3 ] { { circle::r#0 = main::i#2 } { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [41] (signed word) plot::x#4 ← (const signed word) circle::xc#0 + (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#4 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#4 ] { { circle::r#0 = main::i#2 } { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [42] (signed word) plot::y#4 ← (const signed word) circle::yc#0 - (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#4 plot::y#4 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#4 plot::y#4 ] { { circle::r#0 = main::i#2 } { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [44] (signed word) plot::x#5 ← (const signed word) circle::xc#0 - (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#5 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#5 ] { { circle::r#0 = main::i#2 } { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [45] (signed word) plot::y#5 ← (const signed word) circle::yc#0 - (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#5 plot::y#5 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#5 plot::y#5 ] { { circle::r#0 = main::i#2 } { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [47] (signed word) plot::x#6 ← (const signed word) circle::xc#0 + (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#6 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#6 ] { { circle::r#0 = main::i#2 } { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [48] (signed word) plot::y#6 ← (const signed word) circle::yc#0 + (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#6 plot::y#6 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#6 plot::y#6 ] { { circle::r#0 = main::i#2 } { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [50] (signed word) plot::x#7 ← (const signed word) circle::xc#0 - (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#7 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#7 ] { { circle::r#0 = main::i#2 } { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [51] (signed word) plot::y#7 ← (const signed word) circle::yc#0 + (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#7 plot::y#7 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#7 plot::y#7 ] { { circle::r#0 = main::i#2 } { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [54] (signed word~) circle::$9 ← (signed word) circle::x1#10 << (signed byte) 2 [ circle::x1#10 circle::y#13 circle::p#3 circle::$9 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#13 circle::p#3 circle::$9 ] { { circle::r#0 = main::i#2 } }  ) always clobbers reg byte a 
+Statement [55] (signed word~) circle::$10 ← (signed word) circle::p#3 + (signed word~) circle::$9 [ circle::x1#10 circle::y#13 circle::$10 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#13 circle::$10 ] { { circle::r#0 = main::i#2 } }  ) always clobbers reg byte a 
+Statement [56] (signed word) circle::p#1 ← (signed word~) circle::$10 + (signed byte) 6 [ circle::x1#10 circle::y#13 circle::p#1 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#13 circle::p#1 ] { { circle::r#0 = main::i#2 } }  ) always clobbers reg byte a 
+Statement [58] if((signed word) plot::x#8<(signed byte) 0) goto plot::@return [ plot::x#8 plot::y#8 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [59] if((signed word) plot::x#8>(signed word) $13f) goto plot::@return [ plot::x#8 plot::y#8 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [60] if((signed word) plot::y#8<(signed byte) 0) goto plot::@return [ plot::x#8 plot::y#8 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [61] if((signed word) plot::y#8>=(signed word) $c7+(signed byte) 1) goto plot::@return [ plot::x#8 plot::y#8 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [62] (signed word~) plot::$8 ← (signed word) plot::x#8 & (signed dword) $fff8 [ plot::x#8 plot::y#8 plot::$8 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$8 ] { { circle::r#0 = main::i#2 } { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$8 ] { { circle::r#0 = main::i#2 } { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$8 ] { { circle::r#0 = main::i#2 } { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$8 ] { { circle::r#0 = main::i#2 } { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$8 ] { { circle::r#0 = main::i#2 } { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$8 ] { { circle::r#0 = main::i#2 } { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$8 ] { { circle::r#0 = main::i#2 } { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$8 ] { { circle::r#0 = main::i#2 } { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [63] (byte*) plot::location#1 ← (const byte*) BITMAP + (signed word~) plot::$8 [ plot::x#8 plot::y#8 plot::location#1 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] { { circle::r#0 = main::i#2 } { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] { { circle::r#0 = main::i#2 } { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] { { circle::r#0 = main::i#2 } { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] { { circle::r#0 = main::i#2 } { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] { { circle::r#0 = main::i#2 } { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] { { circle::r#0 = main::i#2 } { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] { { circle::r#0 = main::i#2 } { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] { { circle::r#0 = main::i#2 } { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [66] (byte*) plot::location#2 ← (byte*) plot::location#1 + (byte~) plot::$10 [ plot::x#8 plot::y#8 plot::location#2 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] { { circle::r#0 = main::i#2 } { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] { { circle::r#0 = main::i#2 } { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] { { circle::r#0 = main::i#2 } { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] { { circle::r#0 = main::i#2 } { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] { { circle::r#0 = main::i#2 } { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] { { circle::r#0 = main::i#2 } { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] { { circle::r#0 = main::i#2 } { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] { { circle::r#0 = main::i#2 } { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [67] (signed word~) plot::$11 ← (signed word) plot::y#8 >> (signed byte) 3 [ plot::x#8 plot::location#2 plot::$11 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 ] { { circle::r#0 = main::i#2 } { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 ] { { circle::r#0 = main::i#2 } { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 ] { { circle::r#0 = main::i#2 } { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 ] { { circle::r#0 = main::i#2 } { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 ] { { circle::r#0 = main::i#2 } { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 ] { { circle::r#0 = main::i#2 } { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 ] { { circle::r#0 = main::i#2 } { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 ] { { circle::r#0 = main::i#2 } { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [68] (signed word~) plot::$15 ← (signed word~) plot::$11 << (byte) 2 [ plot::x#8 plot::location#2 plot::$11 plot::$15 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 plot::$15 ] { { circle::r#0 = main::i#2 } { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 plot::$15 ] { { circle::r#0 = main::i#2 } { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 plot::$15 ] { { circle::r#0 = main::i#2 } { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 plot::$15 ] { { circle::r#0 = main::i#2 } { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 plot::$15 ] { { circle::r#0 = main::i#2 } { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 plot::$15 ] { { circle::r#0 = main::i#2 } { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 plot::$15 ] { { circle::r#0 = main::i#2 } { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 plot::$15 ] { { circle::r#0 = main::i#2 } { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [69] (signed word~) plot::$16 ← (signed word~) plot::$15 + (signed word~) plot::$11 [ plot::x#8 plot::location#2 plot::$16 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$16 ] { { circle::r#0 = main::i#2 } { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$16 ] { { circle::r#0 = main::i#2 } { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$16 ] { { circle::r#0 = main::i#2 } { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$16 ] { { circle::r#0 = main::i#2 } { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$16 ] { { circle::r#0 = main::i#2 } { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$16 ] { { circle::r#0 = main::i#2 } { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$16 ] { { circle::r#0 = main::i#2 } { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$16 ] { { circle::r#0 = main::i#2 } { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [70] (signed word~) plot::$12 ← (signed word~) plot::$16 << (byte) 6 [ plot::x#8 plot::location#2 plot::$12 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$12 ] { { circle::r#0 = main::i#2 } { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$12 ] { { circle::r#0 = main::i#2 } { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$12 ] { { circle::r#0 = main::i#2 } { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$12 ] { { circle::r#0 = main::i#2 } { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$12 ] { { circle::r#0 = main::i#2 } { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$12 ] { { circle::r#0 = main::i#2 } { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$12 ] { { circle::r#0 = main::i#2 } { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$12 ] { { circle::r#0 = main::i#2 } { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [71] (byte*) plot::location#3 ← (byte*) plot::location#2 + (signed word~) plot::$12 [ plot::x#8 plot::location#3 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] { { circle::r#0 = main::i#2 } { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] { { circle::r#0 = main::i#2 } { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] { { circle::r#0 = main::i#2 } { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] { { circle::r#0 = main::i#2 } { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] { { circle::r#0 = main::i#2 } { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] { { circle::r#0 = main::i#2 } { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] { { circle::r#0 = main::i#2 } { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] { { circle::r#0 = main::i#2 } { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [72] (signed byte~) plot::$13 ← (signed word) plot::x#8 & (signed byte) 7 [ plot::location#3 plot::$13 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$13 ] { { circle::r#0 = main::i#2 } { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$13 ] { { circle::r#0 = main::i#2 } { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$13 ] { { circle::r#0 = main::i#2 } { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$13 ] { { circle::r#0 = main::i#2 } { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$13 ] { { circle::r#0 = main::i#2 } { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$13 ] { { circle::r#0 = main::i#2 } { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$13 ] { { circle::r#0 = main::i#2 } { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$13 ] { { circle::r#0 = main::i#2 } { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [73] (byte~) plot::$14 ← *((byte*) plot::location#3) | *((const byte*) bitmask + (signed byte~) plot::$13) [ plot::location#3 plot::$14 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$14 ] { { circle::r#0 = main::i#2 } { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$14 ] { { circle::r#0 = main::i#2 } { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$14 ] { { circle::r#0 = main::i#2 } { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$14 ] { { circle::r#0 = main::i#2 } { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$14 ] { { circle::r#0 = main::i#2 } { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$14 ] { { circle::r#0 = main::i#2 } { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$14 ] { { circle::r#0 = main::i#2 } { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$14 ] { { circle::r#0 = main::i#2 } { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a reg byte y 
+Statement [74] *((byte*) plot::location#3) ← (byte~) plot::$14 [ ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 ] { { circle::r#0 = main::i#2 } { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 ] { { circle::r#0 = main::i#2 } { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 ] { { circle::r#0 = main::i#2 } { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 ] { { circle::r#0 = main::i#2 } { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 ] { { circle::r#0 = main::i#2 } { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 ] { { circle::r#0 = main::i#2 } { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 ] { { circle::r#0 = main::i#2 } { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 ] { { circle::r#0 = main::i#2 } { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte y 
+Statement [77] (byte*) fill::end#0 ← (byte*) fill::addr#0 + (signed word) fill::size#2 [ fill::addr#0 fill::val#4 fill::end#0 ] ( main:2::fill:5 [ fill::addr#0 fill::val#4 fill::end#0 ] { }  main:2::fill:7 [ fill::addr#0 fill::val#4 fill::end#0 ] { }  ) always clobbers reg byte a 
 Removing always clobbered register reg byte a as potential for zp[1]:16 [ fill::val#4 ]
-Statement [79] if((byte*) fill::addr#2!=(byte*) fill::end#0) goto fill::@2 [ fill::val#4 fill::end#0 fill::addr#2 ] ( main:2::fill:5 [ fill::val#4 fill::end#0 fill::addr#2 ] main:2::fill:7 [ fill::val#4 fill::end#0 fill::addr#2 ] ) always clobbers reg byte a 
-Statement [81] *((byte*) fill::addr#2) ← (byte) fill::val#4 [ fill::val#4 fill::end#0 fill::addr#2 ] ( main:2::fill:5 [ fill::val#4 fill::end#0 fill::addr#2 ] main:2::fill:7 [ fill::val#4 fill::end#0 fill::addr#2 ] ) always clobbers reg byte a reg byte y 
+Statement [79] if((byte*) fill::addr#2!=(byte*) fill::end#0) goto fill::@2 [ fill::val#4 fill::end#0 fill::addr#2 ] ( main:2::fill:5 [ fill::val#4 fill::end#0 fill::addr#2 ] { }  main:2::fill:7 [ fill::val#4 fill::end#0 fill::addr#2 ] { }  ) always clobbers reg byte a 
+Statement [81] *((byte*) fill::addr#2) ← (byte) fill::val#4 [ fill::val#4 fill::end#0 fill::addr#2 ] ( main:2::fill:5 [ fill::val#4 fill::end#0 fill::addr#2 ] { }  main:2::fill:7 [ fill::val#4 fill::end#0 fill::addr#2 ] { }  ) always clobbers reg byte a reg byte y 
 Removing always clobbered register reg byte y as potential for zp[1]:16 [ fill::val#4 ]
-Statement [8] *((const byte*) BORDERCOL) ← (const byte) BLUE [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [9] *((const byte*) D011) ← (const byte) VIC_BMM|(const byte) VIC_DEN|(const byte) VIC_RSEL|(byte) 3 [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [10] *((const byte*) VIC_MEMORY) ← (byte)(word)(const byte*) SCREEN&(word) $3fff/(byte) $40|(word)(const byte*) BITMAP&(word) $3fff/(word) $400 [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [12] if((signed word) main::i#2<(signed word) $b4) goto main::@2 [ main::i#2 ] ( main:2 [ main::i#2 ] ) always clobbers reg byte a 
-Statement [14] (signed word) circle::r#0 ← (signed word) main::i#2 [ main::i#2 circle::r#0 ] ( main:2 [ main::i#2 circle::r#0 ] ) always clobbers reg byte a 
-Statement [16] (signed word) main::i#1 ← (signed word) main::i#2 + (signed byte) 5 [ main::i#1 ] ( main:2 [ main::i#1 ] ) always clobbers reg byte a 
-Statement [17] (signed word~) circle::$0 ← (signed word) circle::r#0 << (signed byte) 1 [ circle::r#0 circle::$0 ] ( main:2::circle:15 [ main::i#2 circle::r#0 circle::$0 ] ) always clobbers reg byte a 
-Statement [18] (signed word) circle::p#0 ← (signed byte) 3 - (signed word~) circle::$0 [ circle::r#0 circle::p#0 ] ( main:2::circle:15 [ main::i#2 circle::r#0 circle::p#0 ] ) always clobbers reg byte a 
-Statement [20] if((signed word) circle::x1#10<=(signed word) circle::y#13) goto circle::@2 [ circle::x1#10 circle::y#13 circle::p#3 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#13 circle::p#3 ] ) always clobbers reg byte a 
-Statement [22] if((signed word) circle::p#3<(signed byte) 0) goto circle::@3 [ circle::x1#10 circle::y#13 circle::p#3 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#13 circle::p#3 ] ) always clobbers reg byte a 
-Statement [23] (signed word) circle::y#1 ← (signed word) circle::y#13 - (signed byte) 1 [ circle::x1#10 circle::p#3 circle::y#1 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::p#3 circle::y#1 ] ) always clobbers reg byte a 
-Statement [24] (signed word~) circle::$5 ← (signed word) circle::x1#10 - (signed word) circle::y#1 [ circle::x1#10 circle::p#3 circle::y#1 circle::$5 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::p#3 circle::y#1 circle::$5 ] ) always clobbers reg byte a 
-Statement [25] (signed word~) circle::$6 ← (signed word~) circle::$5 << (signed byte) 2 [ circle::x1#10 circle::p#3 circle::y#1 circle::$6 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::p#3 circle::y#1 circle::$6 ] ) always clobbers reg byte a 
-Statement [26] (signed word~) circle::$7 ← (signed word) circle::p#3 + (signed word~) circle::$6 [ circle::x1#10 circle::y#1 circle::$7 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#1 circle::$7 ] ) always clobbers reg byte a 
-Statement [27] (signed word) circle::p#2 ← (signed word~) circle::$7 + (signed byte) $a [ circle::x1#10 circle::y#1 circle::p#2 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#1 circle::p#2 ] ) always clobbers reg byte a 
-Statement [29] (signed word) plot::x#0 ← (const signed word) circle::xc#0 + (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#0 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#0 ] ) always clobbers reg byte a 
-Statement [30] (signed word) plot::y#0 ← (const signed word) circle::yc#0 - (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#0 plot::y#0 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#0 plot::y#0 ] ) always clobbers reg byte a 
-Statement [32] (signed word) plot::x#1 ← (const signed word) circle::xc#0 - (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#1 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#1 ] ) always clobbers reg byte a 
-Statement [33] (signed word) plot::y#1 ← (const signed word) circle::yc#0 - (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#1 plot::y#1 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#1 plot::y#1 ] ) always clobbers reg byte a 
-Statement [35] (signed word) plot::x#2 ← (const signed word) circle::xc#0 + (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#2 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#2 ] ) always clobbers reg byte a 
-Statement [36] (signed word) plot::y#2 ← (const signed word) circle::yc#0 + (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#2 plot::y#2 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#2 plot::y#2 ] ) always clobbers reg byte a 
-Statement [38] (signed word) plot::x#3 ← (const signed word) circle::xc#0 - (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#3 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#3 ] ) always clobbers reg byte a 
-Statement [39] (signed word) plot::y#3 ← (const signed word) circle::yc#0 + (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#3 plot::y#3 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#3 plot::y#3 ] ) always clobbers reg byte a 
-Statement [41] (signed word) plot::x#4 ← (const signed word) circle::xc#0 + (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#4 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#4 ] ) always clobbers reg byte a 
-Statement [42] (signed word) plot::y#4 ← (const signed word) circle::yc#0 - (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#4 plot::y#4 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#4 plot::y#4 ] ) always clobbers reg byte a 
-Statement [44] (signed word) plot::x#5 ← (const signed word) circle::xc#0 - (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#5 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#5 ] ) always clobbers reg byte a 
-Statement [45] (signed word) plot::y#5 ← (const signed word) circle::yc#0 - (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#5 plot::y#5 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#5 plot::y#5 ] ) always clobbers reg byte a 
-Statement [47] (signed word) plot::x#6 ← (const signed word) circle::xc#0 + (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#6 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#6 ] ) always clobbers reg byte a 
-Statement [48] (signed word) plot::y#6 ← (const signed word) circle::yc#0 + (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#6 plot::y#6 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#6 plot::y#6 ] ) always clobbers reg byte a 
-Statement [50] (signed word) plot::x#7 ← (const signed word) circle::xc#0 - (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#7 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#7 ] ) always clobbers reg byte a 
-Statement [51] (signed word) plot::y#7 ← (const signed word) circle::yc#0 + (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#7 plot::y#7 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#7 plot::y#7 ] ) always clobbers reg byte a 
-Statement [54] (signed word~) circle::$9 ← (signed word) circle::x1#10 << (signed byte) 2 [ circle::x1#10 circle::y#13 circle::p#3 circle::$9 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#13 circle::p#3 circle::$9 ] ) always clobbers reg byte a 
-Statement [55] (signed word~) circle::$10 ← (signed word) circle::p#3 + (signed word~) circle::$9 [ circle::x1#10 circle::y#13 circle::$10 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#13 circle::$10 ] ) always clobbers reg byte a 
-Statement [56] (signed word) circle::p#1 ← (signed word~) circle::$10 + (signed byte) 6 [ circle::x1#10 circle::y#13 circle::p#1 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#13 circle::p#1 ] ) always clobbers reg byte a 
-Statement [58] if((signed word) plot::x#8<(signed byte) 0) goto plot::@return [ plot::x#8 plot::y#8 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] ) always clobbers reg byte a 
-Statement [59] if((signed word) plot::x#8>(signed word) $13f) goto plot::@return [ plot::x#8 plot::y#8 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] ) always clobbers reg byte a 
-Statement [60] if((signed word) plot::y#8<(signed byte) 0) goto plot::@return [ plot::x#8 plot::y#8 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] ) always clobbers reg byte a 
-Statement [61] if((signed word) plot::y#8>=(signed word) $c7+(signed byte) 1) goto plot::@return [ plot::x#8 plot::y#8 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] ) always clobbers reg byte a 
-Statement [62] (signed word~) plot::$8 ← (signed word) plot::x#8 & (signed dword) $fff8 [ plot::x#8 plot::y#8 plot::$8 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$8 ] main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$8 ] main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$8 ] main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$8 ] main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$8 ] main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$8 ] main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$8 ] main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$8 ] ) always clobbers reg byte a 
-Statement [63] (byte*) plot::location#1 ← (const byte*) BITMAP + (signed word~) plot::$8 [ plot::x#8 plot::y#8 plot::location#1 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] ) always clobbers reg byte a 
-Statement [64] (byte~) plot::$9 ← < (signed word) plot::y#8 [ plot::x#8 plot::y#8 plot::location#1 plot::$9 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 plot::$9 ] main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 plot::$9 ] main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 plot::$9 ] main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 plot::$9 ] main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 plot::$9 ] main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 plot::$9 ] main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 plot::$9 ] main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 plot::$9 ] ) always clobbers reg byte a 
-Statement [66] (byte*) plot::location#2 ← (byte*) plot::location#1 + (byte~) plot::$10 [ plot::x#8 plot::y#8 plot::location#2 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] ) always clobbers reg byte a 
-Statement [67] (signed word~) plot::$11 ← (signed word) plot::y#8 >> (signed byte) 3 [ plot::x#8 plot::location#2 plot::$11 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 ] main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 ] main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 ] main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 ] main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 ] main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 ] main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 ] main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 ] ) always clobbers reg byte a 
-Statement [68] (signed word~) plot::$15 ← (signed word~) plot::$11 << (byte) 2 [ plot::x#8 plot::location#2 plot::$11 plot::$15 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 plot::$15 ] main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 plot::$15 ] main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 plot::$15 ] main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 plot::$15 ] main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 plot::$15 ] main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 plot::$15 ] main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 plot::$15 ] main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 plot::$15 ] ) always clobbers reg byte a 
-Statement [69] (signed word~) plot::$16 ← (signed word~) plot::$15 + (signed word~) plot::$11 [ plot::x#8 plot::location#2 plot::$16 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$16 ] main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$16 ] main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$16 ] main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$16 ] main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$16 ] main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$16 ] main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$16 ] main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$16 ] ) always clobbers reg byte a 
-Statement [70] (signed word~) plot::$12 ← (signed word~) plot::$16 << (byte) 6 [ plot::x#8 plot::location#2 plot::$12 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$12 ] main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$12 ] main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$12 ] main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$12 ] main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$12 ] main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$12 ] main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$12 ] main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$12 ] ) always clobbers reg byte a 
-Statement [71] (byte*) plot::location#3 ← (byte*) plot::location#2 + (signed word~) plot::$12 [ plot::x#8 plot::location#3 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] ) always clobbers reg byte a 
-Statement [72] (signed byte~) plot::$13 ← (signed word) plot::x#8 & (signed byte) 7 [ plot::location#3 plot::$13 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$13 ] main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$13 ] main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$13 ] main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$13 ] main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$13 ] main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$13 ] main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$13 ] main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$13 ] ) always clobbers reg byte a 
-Statement [73] (byte~) plot::$14 ← *((byte*) plot::location#3) | *((const byte*) bitmask + (signed byte~) plot::$13) [ plot::location#3 plot::$14 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$14 ] main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$14 ] main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$14 ] main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$14 ] main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$14 ] main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$14 ] main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$14 ] main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$14 ] ) always clobbers reg byte a reg byte y 
-Statement [74] *((byte*) plot::location#3) ← (byte~) plot::$14 [ ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 ] main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 ] main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 ] main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 ] main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 ] main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 ] main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 ] main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 ] ) always clobbers reg byte y 
-Statement [77] (byte*) fill::end#0 ← (byte*) fill::addr#0 + (signed word) fill::size#2 [ fill::addr#0 fill::val#4 fill::end#0 ] ( main:2::fill:5 [ fill::addr#0 fill::val#4 fill::end#0 ] main:2::fill:7 [ fill::addr#0 fill::val#4 fill::end#0 ] ) always clobbers reg byte a 
-Statement [79] if((byte*) fill::addr#2!=(byte*) fill::end#0) goto fill::@2 [ fill::val#4 fill::end#0 fill::addr#2 ] ( main:2::fill:5 [ fill::val#4 fill::end#0 fill::addr#2 ] main:2::fill:7 [ fill::val#4 fill::end#0 fill::addr#2 ] ) always clobbers reg byte a 
-Statement [81] *((byte*) fill::addr#2) ← (byte) fill::val#4 [ fill::val#4 fill::end#0 fill::addr#2 ] ( main:2::fill:5 [ fill::val#4 fill::end#0 fill::addr#2 ] main:2::fill:7 [ fill::val#4 fill::end#0 fill::addr#2 ] ) always clobbers reg byte a reg byte y 
+Statement [8] *((const byte*) BORDERCOL) ← (const byte) BLUE [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [9] *((const byte*) D011) ← (const byte) VIC_BMM|(const byte) VIC_DEN|(const byte) VIC_RSEL|(byte) 3 [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [10] *((const byte*) VIC_MEMORY) ← (byte)(word)(const byte*) SCREEN&(word) $3fff/(byte) $40|(word)(const byte*) BITMAP&(word) $3fff/(word) $400 [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [12] if((signed word) main::i#2<(signed word) $b4) goto main::@2 [ main::i#2 ] ( main:2 [ main::i#2 ] { }  ) always clobbers reg byte a 
+Statement [14] (signed word) circle::r#0 ← (signed word) main::i#2 [ main::i#2 circle::r#0 ] ( main:2 [ main::i#2 circle::r#0 ] { { circle::r#0 = main::i#2 } }  ) always clobbers reg byte a 
+Statement [16] (signed word) main::i#1 ← (signed word) main::i#2 + (signed byte) 5 [ main::i#1 ] ( main:2 [ main::i#1 ] { }  ) always clobbers reg byte a 
+Statement [17] (signed word~) circle::$0 ← (signed word) circle::r#0 << (signed byte) 1 [ circle::r#0 circle::$0 ] ( main:2::circle:15 [ main::i#2 circle::r#0 circle::$0 ] { { circle::r#0 = main::i#2 } }  ) always clobbers reg byte a 
+Statement [18] (signed word) circle::p#0 ← (signed byte) 3 - (signed word~) circle::$0 [ circle::r#0 circle::p#0 ] ( main:2::circle:15 [ main::i#2 circle::r#0 circle::p#0 ] { { circle::r#0 = main::i#2 } }  ) always clobbers reg byte a 
+Statement [20] if((signed word) circle::x1#10<=(signed word) circle::y#13) goto circle::@2 [ circle::x1#10 circle::y#13 circle::p#3 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#13 circle::p#3 ] { { circle::r#0 = main::i#2 } }  ) always clobbers reg byte a 
+Statement [22] if((signed word) circle::p#3<(signed byte) 0) goto circle::@3 [ circle::x1#10 circle::y#13 circle::p#3 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#13 circle::p#3 ] { { circle::r#0 = main::i#2 } }  ) always clobbers reg byte a 
+Statement [23] (signed word) circle::y#1 ← (signed word) circle::y#13 - (signed byte) 1 [ circle::x1#10 circle::p#3 circle::y#1 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::p#3 circle::y#1 ] { { circle::r#0 = main::i#2 } }  ) always clobbers reg byte a 
+Statement [24] (signed word~) circle::$5 ← (signed word) circle::x1#10 - (signed word) circle::y#1 [ circle::x1#10 circle::p#3 circle::y#1 circle::$5 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::p#3 circle::y#1 circle::$5 ] { { circle::r#0 = main::i#2 } }  ) always clobbers reg byte a 
+Statement [25] (signed word~) circle::$6 ← (signed word~) circle::$5 << (signed byte) 2 [ circle::x1#10 circle::p#3 circle::y#1 circle::$6 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::p#3 circle::y#1 circle::$6 ] { { circle::r#0 = main::i#2 } }  ) always clobbers reg byte a 
+Statement [26] (signed word~) circle::$7 ← (signed word) circle::p#3 + (signed word~) circle::$6 [ circle::x1#10 circle::y#1 circle::$7 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#1 circle::$7 ] { { circle::r#0 = main::i#2 } }  ) always clobbers reg byte a 
+Statement [27] (signed word) circle::p#2 ← (signed word~) circle::$7 + (signed byte) $a [ circle::x1#10 circle::y#1 circle::p#2 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#1 circle::p#2 ] { { circle::r#0 = main::i#2 } }  ) always clobbers reg byte a 
+Statement [29] (signed word) plot::x#0 ← (const signed word) circle::xc#0 + (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#0 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#0 ] { { circle::r#0 = main::i#2 } { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [30] (signed word) plot::y#0 ← (const signed word) circle::yc#0 - (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#0 plot::y#0 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#0 plot::y#0 ] { { circle::r#0 = main::i#2 } { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [32] (signed word) plot::x#1 ← (const signed word) circle::xc#0 - (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#1 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#1 ] { { circle::r#0 = main::i#2 } { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [33] (signed word) plot::y#1 ← (const signed word) circle::yc#0 - (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#1 plot::y#1 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#1 plot::y#1 ] { { circle::r#0 = main::i#2 } { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [35] (signed word) plot::x#2 ← (const signed word) circle::xc#0 + (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#2 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#2 ] { { circle::r#0 = main::i#2 } { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [36] (signed word) plot::y#2 ← (const signed word) circle::yc#0 + (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#2 plot::y#2 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#2 plot::y#2 ] { { circle::r#0 = main::i#2 } { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [38] (signed word) plot::x#3 ← (const signed word) circle::xc#0 - (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#3 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#3 ] { { circle::r#0 = main::i#2 } { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [39] (signed word) plot::y#3 ← (const signed word) circle::yc#0 + (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#3 plot::y#3 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#3 plot::y#3 ] { { circle::r#0 = main::i#2 } { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [41] (signed word) plot::x#4 ← (const signed word) circle::xc#0 + (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#4 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#4 ] { { circle::r#0 = main::i#2 } { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [42] (signed word) plot::y#4 ← (const signed word) circle::yc#0 - (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#4 plot::y#4 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#4 plot::y#4 ] { { circle::r#0 = main::i#2 } { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [44] (signed word) plot::x#5 ← (const signed word) circle::xc#0 - (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#5 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#5 ] { { circle::r#0 = main::i#2 } { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [45] (signed word) plot::y#5 ← (const signed word) circle::yc#0 - (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#5 plot::y#5 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#5 plot::y#5 ] { { circle::r#0 = main::i#2 } { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [47] (signed word) plot::x#6 ← (const signed word) circle::xc#0 + (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#6 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#6 ] { { circle::r#0 = main::i#2 } { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [48] (signed word) plot::y#6 ← (const signed word) circle::yc#0 + (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#6 plot::y#6 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#6 plot::y#6 ] { { circle::r#0 = main::i#2 } { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [50] (signed word) plot::x#7 ← (const signed word) circle::xc#0 - (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#7 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#7 ] { { circle::r#0 = main::i#2 } { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [51] (signed word) plot::y#7 ← (const signed word) circle::yc#0 + (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#7 plot::y#7 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#7 plot::y#7 ] { { circle::r#0 = main::i#2 } { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [54] (signed word~) circle::$9 ← (signed word) circle::x1#10 << (signed byte) 2 [ circle::x1#10 circle::y#13 circle::p#3 circle::$9 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#13 circle::p#3 circle::$9 ] { { circle::r#0 = main::i#2 } }  ) always clobbers reg byte a 
+Statement [55] (signed word~) circle::$10 ← (signed word) circle::p#3 + (signed word~) circle::$9 [ circle::x1#10 circle::y#13 circle::$10 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#13 circle::$10 ] { { circle::r#0 = main::i#2 } }  ) always clobbers reg byte a 
+Statement [56] (signed word) circle::p#1 ← (signed word~) circle::$10 + (signed byte) 6 [ circle::x1#10 circle::y#13 circle::p#1 ] ( main:2::circle:15 [ main::i#2 circle::x1#10 circle::y#13 circle::p#1 ] { { circle::r#0 = main::i#2 } }  ) always clobbers reg byte a 
+Statement [58] if((signed word) plot::x#8<(signed byte) 0) goto plot::@return [ plot::x#8 plot::y#8 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [59] if((signed word) plot::x#8>(signed word) $13f) goto plot::@return [ plot::x#8 plot::y#8 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [60] if((signed word) plot::y#8<(signed byte) 0) goto plot::@return [ plot::x#8 plot::y#8 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [61] if((signed word) plot::y#8>=(signed word) $c7+(signed byte) 1) goto plot::@return [ plot::x#8 plot::y#8 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 ] { { circle::r#0 = main::i#2 } { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [62] (signed word~) plot::$8 ← (signed word) plot::x#8 & (signed dword) $fff8 [ plot::x#8 plot::y#8 plot::$8 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$8 ] { { circle::r#0 = main::i#2 } { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$8 ] { { circle::r#0 = main::i#2 } { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$8 ] { { circle::r#0 = main::i#2 } { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$8 ] { { circle::r#0 = main::i#2 } { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$8 ] { { circle::r#0 = main::i#2 } { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$8 ] { { circle::r#0 = main::i#2 } { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$8 ] { { circle::r#0 = main::i#2 } { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$8 ] { { circle::r#0 = main::i#2 } { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [63] (byte*) plot::location#1 ← (const byte*) BITMAP + (signed word~) plot::$8 [ plot::x#8 plot::y#8 plot::location#1 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] { { circle::r#0 = main::i#2 } { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] { { circle::r#0 = main::i#2 } { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] { { circle::r#0 = main::i#2 } { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] { { circle::r#0 = main::i#2 } { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] { { circle::r#0 = main::i#2 } { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] { { circle::r#0 = main::i#2 } { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] { { circle::r#0 = main::i#2 } { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] { { circle::r#0 = main::i#2 } { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [66] (byte*) plot::location#2 ← (byte*) plot::location#1 + (byte~) plot::$10 [ plot::x#8 plot::y#8 plot::location#2 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] { { circle::r#0 = main::i#2 } { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] { { circle::r#0 = main::i#2 } { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] { { circle::r#0 = main::i#2 } { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] { { circle::r#0 = main::i#2 } { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] { { circle::r#0 = main::i#2 } { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] { { circle::r#0 = main::i#2 } { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] { { circle::r#0 = main::i#2 } { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] { { circle::r#0 = main::i#2 } { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [67] (signed word~) plot::$11 ← (signed word) plot::y#8 >> (signed byte) 3 [ plot::x#8 plot::location#2 plot::$11 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 ] { { circle::r#0 = main::i#2 } { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 ] { { circle::r#0 = main::i#2 } { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 ] { { circle::r#0 = main::i#2 } { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 ] { { circle::r#0 = main::i#2 } { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 ] { { circle::r#0 = main::i#2 } { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 ] { { circle::r#0 = main::i#2 } { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 ] { { circle::r#0 = main::i#2 } { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 ] { { circle::r#0 = main::i#2 } { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [68] (signed word~) plot::$15 ← (signed word~) plot::$11 << (byte) 2 [ plot::x#8 plot::location#2 plot::$11 plot::$15 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 plot::$15 ] { { circle::r#0 = main::i#2 } { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 plot::$15 ] { { circle::r#0 = main::i#2 } { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 plot::$15 ] { { circle::r#0 = main::i#2 } { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 plot::$15 ] { { circle::r#0 = main::i#2 } { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 plot::$15 ] { { circle::r#0 = main::i#2 } { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 plot::$15 ] { { circle::r#0 = main::i#2 } { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 plot::$15 ] { { circle::r#0 = main::i#2 } { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$11 plot::$15 ] { { circle::r#0 = main::i#2 } { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [69] (signed word~) plot::$16 ← (signed word~) plot::$15 + (signed word~) plot::$11 [ plot::x#8 plot::location#2 plot::$16 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$16 ] { { circle::r#0 = main::i#2 } { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$16 ] { { circle::r#0 = main::i#2 } { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$16 ] { { circle::r#0 = main::i#2 } { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$16 ] { { circle::r#0 = main::i#2 } { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$16 ] { { circle::r#0 = main::i#2 } { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$16 ] { { circle::r#0 = main::i#2 } { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$16 ] { { circle::r#0 = main::i#2 } { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$16 ] { { circle::r#0 = main::i#2 } { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [70] (signed word~) plot::$12 ← (signed word~) plot::$16 << (byte) 6 [ plot::x#8 plot::location#2 plot::$12 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$12 ] { { circle::r#0 = main::i#2 } { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$12 ] { { circle::r#0 = main::i#2 } { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$12 ] { { circle::r#0 = main::i#2 } { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$12 ] { { circle::r#0 = main::i#2 } { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$12 ] { { circle::r#0 = main::i#2 } { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$12 ] { { circle::r#0 = main::i#2 } { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$12 ] { { circle::r#0 = main::i#2 } { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$12 ] { { circle::r#0 = main::i#2 } { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [71] (byte*) plot::location#3 ← (byte*) plot::location#2 + (signed word~) plot::$12 [ plot::x#8 plot::location#3 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] { { circle::r#0 = main::i#2 } { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] { { circle::r#0 = main::i#2 } { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] { { circle::r#0 = main::i#2 } { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] { { circle::r#0 = main::i#2 } { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] { { circle::r#0 = main::i#2 } { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] { { circle::r#0 = main::i#2 } { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] { { circle::r#0 = main::i#2 } { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] { { circle::r#0 = main::i#2 } { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [72] (signed byte~) plot::$13 ← (signed word) plot::x#8 & (signed byte) 7 [ plot::location#3 plot::$13 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$13 ] { { circle::r#0 = main::i#2 } { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$13 ] { { circle::r#0 = main::i#2 } { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$13 ] { { circle::r#0 = main::i#2 } { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$13 ] { { circle::r#0 = main::i#2 } { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$13 ] { { circle::r#0 = main::i#2 } { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$13 ] { { circle::r#0 = main::i#2 } { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$13 ] { { circle::r#0 = main::i#2 } { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$13 ] { { circle::r#0 = main::i#2 } { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [73] (byte~) plot::$14 ← *((byte*) plot::location#3) | *((const byte*) bitmask + (signed byte~) plot::$13) [ plot::location#3 plot::$14 ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$14 ] { { circle::r#0 = main::i#2 } { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$14 ] { { circle::r#0 = main::i#2 } { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$14 ] { { circle::r#0 = main::i#2 } { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$14 ] { { circle::r#0 = main::i#2 } { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$14 ] { { circle::r#0 = main::i#2 } { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$14 ] { { circle::r#0 = main::i#2 } { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$14 ] { { circle::r#0 = main::i#2 } { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$14 ] { { circle::r#0 = main::i#2 } { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a reg byte y 
+Statement [74] *((byte*) plot::location#3) ← (byte~) plot::$14 [ ] ( main:2::circle:15::plot:31 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 ] { { circle::r#0 = main::i#2 } { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:15::plot:34 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 ] { { circle::r#0 = main::i#2 } { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:15::plot:37 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 ] { { circle::r#0 = main::i#2 } { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:15::plot:40 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 ] { { circle::r#0 = main::i#2 } { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:15::plot:43 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 ] { { circle::r#0 = main::i#2 } { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:15::plot:46 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 ] { { circle::r#0 = main::i#2 } { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:15::plot:49 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 ] { { circle::r#0 = main::i#2 } { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:15::plot:52 [ main::i#2 circle::x1#10 circle::y#10 circle::p#10 ] { { circle::r#0 = main::i#2 } { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte y 
+Statement [77] (byte*) fill::end#0 ← (byte*) fill::addr#0 + (signed word) fill::size#2 [ fill::addr#0 fill::val#4 fill::end#0 ] ( main:2::fill:5 [ fill::addr#0 fill::val#4 fill::end#0 ] { }  main:2::fill:7 [ fill::addr#0 fill::val#4 fill::end#0 ] { }  ) always clobbers reg byte a 
+Statement [79] if((byte*) fill::addr#2!=(byte*) fill::end#0) goto fill::@2 [ fill::val#4 fill::end#0 fill::addr#2 ] ( main:2::fill:5 [ fill::val#4 fill::end#0 fill::addr#2 ] { }  main:2::fill:7 [ fill::val#4 fill::end#0 fill::addr#2 ] { }  ) always clobbers reg byte a 
+Statement [81] *((byte*) fill::addr#2) ← (byte) fill::val#4 [ fill::val#4 fill::end#0 fill::addr#2 ] ( main:2::fill:5 [ fill::val#4 fill::end#0 fill::addr#2 ] { }  main:2::fill:7 [ fill::val#4 fill::end#0 fill::addr#2 ] { }  ) always clobbers reg byte a reg byte y 
 Potential registers zp[2]:2 [ main::i#2 main::i#1 ] : zp[2]:2 , 
 Potential registers zp[2]:4 [ circle::x1#10 circle::x1#1 ] : zp[2]:4 , 
 Potential registers zp[2]:6 [ circle::y#13 circle::r#0 circle::y#10 circle::y#1 ] : zp[2]:6 , 
@@ -2010,16 +2008,16 @@ Potential registers zp[1]:50 [ plot::$14 ] : zp[1]:50 , reg byte a , reg byte x
 Potential registers zp[2]:51 [ fill::end#0 ] : zp[2]:51 , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [plot] 1,697.6: zp[2]:12 [ plot::y#8 plot::y#1 plot::y#2 plot::y#3 plot::y#4 plot::y#5 plot::y#6 plot::y#7 plot::y#0 ] 862.4: zp[2]:10 [ plot::x#8 plot::x#1 plot::x#2 plot::x#3 plot::x#4 plot::x#5 plot::x#6 plot::x#7 plot::x#0 ] 4: zp[2]:31 [ plot::$8 ] 4: zp[1]:35 [ plot::$9 ] 4: zp[1]:36 [ plot::$10 ] 4: zp[2]:41 [ plot::$15 ] 4: zp[2]:43 [ plot::$16 ] 4: zp[2]:45 [ plot::$12 ] 4: zp[1]:49 [ plot::$13 ] 4: zp[1]:50 [ plot::$14 ] 3: zp[2]:39 [ plot::$11 ] 2: zp[2]:47 [ plot::location#3 ] 1.33: zp[2]:33 [ plot::location#1 ] 0.8: zp[2]:37 [ plot::location#2 ] 
-Uplift Scope [circle] 477.65: zp[2]:8 [ circle::p#3 circle::p#0 circle::p#10 circle::p#1 circle::p#2 ] 238.47: zp[2]:4 [ circle::x1#10 circle::x1#1 ] 202: zp[2]:21 [ circle::$5 ] 202: zp[2]:23 [ circle::$6 ] 202: zp[2]:25 [ circle::$7 ] 202: zp[2]:27 [ circle::$9 ] 202: zp[2]:29 [ circle::$10 ] 176: zp[2]:6 [ circle::y#13 circle::r#0 circle::y#10 circle::y#1 ] 4: zp[2]:19 [ circle::$0 ] 
-Uplift Scope [fill] 39.33: zp[2]:17 [ fill::addr#2 fill::addr#0 fill::addr#1 ] 2.6: zp[2]:51 [ fill::end#0 ] 2: zp[2]:14 [ fill::size#2 ] 1.83: zp[1]:16 [ fill::val#4 ] 
-Uplift Scope [main] 33: zp[2]:2 [ main::i#2 main::i#1 ] 
+Uplift Scope [plot] 2,080,017.2: zp[2]:12 [ plot::y#8 plot::y#1 plot::y#2 plot::y#3 plot::y#4 plot::y#5 plot::y#6 plot::y#7 plot::y#0 ] 2,000,002: zp[2]:31 [ plot::$8 ] 2,000,002: zp[1]:35 [ plot::$9 ] 2,000,002: zp[1]:36 [ plot::$10 ] 2,000,002: zp[2]:41 [ plot::$15 ] 2,000,002: zp[2]:43 [ plot::$16 ] 2,000,002: zp[2]:45 [ plot::$12 ] 2,000,002: zp[1]:49 [ plot::$13 ] 2,000,002: zp[1]:50 [ plot::$14 ] 1,500,001.5: zp[2]:39 [ plot::$11 ] 1,120,008.8: zp[2]:10 [ plot::x#8 plot::x#1 plot::x#2 plot::x#3 plot::x#4 plot::x#5 plot::x#6 plot::x#7 plot::x#0 ] 1,000,001: zp[2]:47 [ plot::location#3 ] 666,667.33: zp[2]:33 [ plot::location#1 ] 400,000.4: zp[2]:37 [ plot::location#2 ] 
+Uplift Scope [circle] 470,831.01: zp[2]:8 [ circle::p#3 circle::p#0 circle::p#10 circle::p#1 circle::p#2 ] 236,113.47: zp[2]:4 [ circle::x1#10 circle::x1#1 ] 200,002: zp[2]:21 [ circle::$5 ] 200,002: zp[2]:23 [ circle::$6 ] 200,002: zp[2]:25 [ circle::$7 ] 200,002: zp[2]:27 [ circle::$9 ] 200,002: zp[2]:29 [ circle::$10 ] 169,843.88: zp[2]:6 [ circle::y#13 circle::r#0 circle::y#10 circle::y#1 ] 2,002: zp[2]:19 [ circle::$0 ] 
+Uplift Scope [fill] 3,471.33: zp[2]:17 [ fill::addr#2 fill::addr#0 fill::addr#1 ] 220.4: zp[2]:51 [ fill::end#0 ] 166.83: zp[1]:16 [ fill::val#4 ] 101: zp[2]:14 [ fill::size#2 ] 
+Uplift Scope [main] 303: zp[2]:2 [ main::i#2 main::i#1 ] 
 Uplift Scope [] 
 
-Uplifting [plot] best 53688 combination zp[2]:12 [ plot::y#8 plot::y#1 plot::y#2 plot::y#3 plot::y#4 plot::y#5 plot::y#6 plot::y#7 plot::y#0 ] zp[2]:10 [ plot::x#8 plot::x#1 plot::x#2 plot::x#3 plot::x#4 plot::x#5 plot::x#6 plot::x#7 plot::x#0 ] zp[2]:31 [ plot::$8 ] reg byte a [ plot::$9 ] reg byte a [ plot::$10 ] zp[2]:41 [ plot::$15 ] zp[2]:43 [ plot::$16 ] zp[2]:45 [ plot::$12 ] reg byte a [ plot::$13 ] reg byte a [ plot::$14 ] zp[2]:39 [ plot::$11 ] zp[2]:47 [ plot::location#3 ] zp[2]:33 [ plot::location#1 ] zp[2]:37 [ plot::location#2 ] 
+Uplifting [plot] best 53688 combination zp[2]:12 [ plot::y#8 plot::y#1 plot::y#2 plot::y#3 plot::y#4 plot::y#5 plot::y#6 plot::y#7 plot::y#0 ] zp[2]:31 [ plot::$8 ] reg byte a [ plot::$9 ] reg byte a [ plot::$10 ] zp[2]:41 [ plot::$15 ] zp[2]:43 [ plot::$16 ] zp[2]:45 [ plot::$12 ] reg byte a [ plot::$13 ] reg byte a [ plot::$14 ] zp[2]:39 [ plot::$11 ] zp[2]:10 [ plot::x#8 plot::x#1 plot::x#2 plot::x#3 plot::x#4 plot::x#5 plot::x#6 plot::x#7 plot::x#0 ] zp[2]:47 [ plot::location#3 ] zp[2]:33 [ plot::location#1 ] zp[2]:37 [ plot::location#2 ] 
 Limited combination testing to 100 combinations of 256 possible.
 Uplifting [circle] best 53688 combination zp[2]:8 [ circle::p#3 circle::p#0 circle::p#10 circle::p#1 circle::p#2 ] zp[2]:4 [ circle::x1#10 circle::x1#1 ] zp[2]:21 [ circle::$5 ] zp[2]:23 [ circle::$6 ] zp[2]:25 [ circle::$7 ] zp[2]:27 [ circle::$9 ] zp[2]:29 [ circle::$10 ] zp[2]:6 [ circle::y#13 circle::r#0 circle::y#10 circle::y#1 ] zp[2]:19 [ circle::$0 ] 
-Uplifting [fill] best 53672 combination zp[2]:17 [ fill::addr#2 fill::addr#0 fill::addr#1 ] zp[2]:51 [ fill::end#0 ] zp[2]:14 [ fill::size#2 ] reg byte x [ fill::val#4 ] 
+Uplifting [fill] best 53672 combination zp[2]:17 [ fill::addr#2 fill::addr#0 fill::addr#1 ] zp[2]:51 [ fill::end#0 ] reg byte x [ fill::val#4 ] zp[2]:14 [ fill::size#2 ] 
 Uplifting [main] best 53672 combination zp[2]:2 [ main::i#2 main::i#1 ] 
 Uplifting [] best 53672 combination 
 Coalescing zero page register [ zp[2]:8 [ circle::p#3 circle::p#0 circle::p#10 circle::p#1 circle::p#2 ] ] with [ zp[2]:25 [ circle::$7 ] ] - score: 2
@@ -2826,12 +2824,12 @@ FINAL SYMBOL TABLE
 (const byte) VIC_RSEL = (byte) 8
 (const byte*) bitmask[]  = { (byte) $80, (byte) $40, (byte) $20, (byte) $10, (byte) 8, (byte) 4, (byte) 2, (byte) 1 }
 (void()) circle((signed word) circle::xc , (signed word) circle::yc , (signed word) circle::r)
-(signed word~) circle::$0 zp[2]:4 4.0
-(signed word~) circle::$10 zp[2]:4 202.0
-(signed word~) circle::$5 zp[2]:10 202.0
-(signed word~) circle::$6 zp[2]:10 202.0
-(signed word~) circle::$7 zp[2]:4 202.0
-(signed word~) circle::$9 zp[2]:12 202.0
+(signed word~) circle::$0 zp[2]:4 2002.0
+(signed word~) circle::$10 zp[2]:4 200002.0
+(signed word~) circle::$5 zp[2]:10 200002.0
+(signed word~) circle::$6 zp[2]:10 200002.0
+(signed word~) circle::$7 zp[2]:4 200002.0
+(signed word~) circle::$9 zp[2]:12 200002.0
 (label) circle::@1
 (label) circle::@10
 (label) circle::@11
@@ -2847,22 +2845,22 @@ FINAL SYMBOL TABLE
 (label) circle::@9
 (label) circle::@return
 (signed word) circle::p
-(signed word) circle::p#0 p zp[2]:4 4.0
-(signed word) circle::p#1 p zp[2]:4 202.0
-(signed word) circle::p#10 p zp[2]:4 11.653846153846153
-(signed word) circle::p#2 p zp[2]:4 202.0
-(signed word) circle::p#3 p zp[2]:4 58.00000000000001
+(signed word) circle::p#0 p zp[2]:4 2002.0
+(signed word) circle::p#1 p zp[2]:4 200002.0
+(signed word) circle::p#10 p zp[2]:4 11538.576923076922
+(signed word) circle::p#2 p zp[2]:4 200002.0
+(signed word) circle::p#3 p zp[2]:4 57286.42857142857
 (signed word) circle::r
-(signed word) circle::r#0 r zp[2]:8 5.0
+(signed word) circle::r#0 r zp[2]:8 701.0
 (signed word) circle::x1
-(signed word) circle::x1#1 x1 zp[2]:6 202.0
-(signed word) circle::x1#10 x1 zp[2]:6 36.47222222222223
+(signed word) circle::x1#1 x1 zp[2]:6 200002.0
+(signed word) circle::x1#10 x1 zp[2]:6 36111.47222222222
 (signed word) circle::xc
 (const signed word) circle::xc#0 xc = (signed word) $a0
 (signed word) circle::y
-(signed word) circle::y#1 y zp[2]:8 60.599999999999994
-(signed word) circle::y#10 y zp[2]:8 42.73076923076923
-(signed word) circle::y#13 y zp[2]:8 67.66666666666666
+(signed word) circle::y#1 y zp[2]:8 60000.600000000006
+(signed word) circle::y#10 y zp[2]:8 42308.11538461538
+(signed word) circle::y#13 y zp[2]:8 66834.16666666666
 (signed word) circle::yc
 (const signed word) circle::yc#0 yc = (signed byte) $64
 (void()) fill((byte*) fill::start , (signed word) fill::size , (byte) fill::val)
@@ -2870,16 +2868,16 @@ FINAL SYMBOL TABLE
 (label) fill::@2
 (label) fill::@return
 (byte*) fill::addr
-(byte*) fill::addr#0 addr zp[2]:8 2.0
-(byte*) fill::addr#1 addr zp[2]:8 22.0
-(byte*) fill::addr#2 addr zp[2]:8 15.333333333333332
+(byte*) fill::addr#0 addr zp[2]:8 101.0
+(byte*) fill::addr#1 addr zp[2]:8 2002.0
+(byte*) fill::addr#2 addr zp[2]:8 1368.3333333333335
 (byte*) fill::end
-(byte*) fill::end#0 end zp[2]:6 2.6
+(byte*) fill::end#0 end zp[2]:6 220.39999999999998
 (signed word) fill::size
-(signed word) fill::size#2 size zp[2]:6 2.0
+(signed word) fill::size#2 size zp[2]:6 101.0
 (byte*) fill::start
 (byte) fill::val
-(byte) fill::val#4 reg byte x 1.8333333333333333
+(byte) fill::val#4 reg byte x 166.83333333333334
 (void()) main()
 (label) main::@1
 (label) main::@2
@@ -2888,47 +2886,47 @@ FINAL SYMBOL TABLE
 (label) main::@5
 (label) main::@6
 (signed word) main::i
-(signed word) main::i#1 i zp[2]:2 22.0
-(signed word) main::i#2 i zp[2]:2 11.0
+(signed word) main::i#1 i zp[2]:2 202.0
+(signed word) main::i#2 i zp[2]:2 101.0
 (void()) plot((signed word) plot::x , (signed word) plot::y)
-(byte~) plot::$10 reg byte a 4.0
-(signed word~) plot::$11 zp[2]:12 3.0
-(signed word~) plot::$12 zp[2]:16 4.0
-(signed byte~) plot::$13 reg byte a 4.0
-(byte~) plot::$14 reg byte a 4.0
-(signed word~) plot::$15 zp[2]:16 4.0
-(signed word~) plot::$16 zp[2]:16 4.0
-(signed word~) plot::$8 zp[2]:14 4.0
-(byte~) plot::$9 reg byte a 4.0
+(byte~) plot::$10 reg byte a 2000002.0
+(signed word~) plot::$11 zp[2]:12 1500001.5
+(signed word~) plot::$12 zp[2]:16 2000002.0
+(signed byte~) plot::$13 reg byte a 2000002.0
+(byte~) plot::$14 reg byte a 2000002.0
+(signed word~) plot::$15 zp[2]:16 2000002.0
+(signed word~) plot::$16 zp[2]:16 2000002.0
+(signed word~) plot::$8 zp[2]:14 2000002.0
+(byte~) plot::$9 reg byte a 2000002.0
 (label) plot::@1
 (label) plot::@2
 (label) plot::@3
 (label) plot::@4
 (label) plot::@return
 (byte*) plot::location
-(byte*) plot::location#1 location zp[2]:14 1.3333333333333333
-(byte*) plot::location#2 location zp[2]:14 0.8
-(byte*) plot::location#3 location zp[2]:14 2.0
+(byte*) plot::location#1 location zp[2]:14 666667.3333333334
+(byte*) plot::location#2 location zp[2]:14 400000.4
+(byte*) plot::location#3 location zp[2]:14 1000001.0
 (signed word) plot::x
-(signed word) plot::x#0 x zp[2]:10 101.0
-(signed word) plot::x#1 x zp[2]:10 101.0
-(signed word) plot::x#2 x zp[2]:10 101.0
-(signed word) plot::x#3 x zp[2]:10 101.0
-(signed word) plot::x#4 x zp[2]:10 101.0
-(signed word) plot::x#5 x zp[2]:10 101.0
-(signed word) plot::x#6 x zp[2]:10 101.0
-(signed word) plot::x#7 x zp[2]:10 101.0
-(signed word) plot::x#8 x zp[2]:10 54.4
+(signed word) plot::x#0 x zp[2]:10 100001.0
+(signed word) plot::x#1 x zp[2]:10 100001.0
+(signed word) plot::x#2 x zp[2]:10 100001.0
+(signed word) plot::x#3 x zp[2]:10 100001.0
+(signed word) plot::x#4 x zp[2]:10 100001.0
+(signed word) plot::x#5 x zp[2]:10 100001.0
+(signed word) plot::x#6 x zp[2]:10 100001.0
+(signed word) plot::x#7 x zp[2]:10 100001.0
+(signed word) plot::x#8 x zp[2]:10 320000.80000000005
 (signed word) plot::y
-(signed word) plot::y#0 y zp[2]:12 202.0
-(signed word) plot::y#1 y zp[2]:12 202.0
-(signed word) plot::y#2 y zp[2]:12 202.0
-(signed word) plot::y#3 y zp[2]:12 202.0
-(signed word) plot::y#4 y zp[2]:12 202.0
-(signed word) plot::y#5 y zp[2]:12 202.0
-(signed word) plot::y#6 y zp[2]:12 202.0
-(signed word) plot::y#7 y zp[2]:12 202.0
-(signed word) plot::y#8 y zp[2]:12 81.60000000000001
+(signed word) plot::y#0 y zp[2]:12 200002.0
+(signed word) plot::y#1 y zp[2]:12 200002.0
+(signed word) plot::y#2 y zp[2]:12 200002.0
+(signed word) plot::y#3 y zp[2]:12 200002.0
+(signed word) plot::y#4 y zp[2]:12 200002.0
+(signed word) plot::y#5 y zp[2]:12 200002.0
+(signed word) plot::y#6 y zp[2]:12 200002.0
+(signed word) plot::y#7 y zp[2]:12 200002.0
+(signed word) plot::y#8 y zp[2]:12 480001.19999999995
 
 zp[2]:2 [ main::i#2 main::i#1 ]
 zp[2]:4 [ circle::p#3 circle::p#0 circle::p#10 circle::p#1 circle::p#2 circle::$7 circle::$10 circle::$0 ]

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

@@ -12,12 +12,12 @@
 (const byte) VIC_RSEL = (byte) 8
 (const byte*) bitmask[]  = { (byte) $80, (byte) $40, (byte) $20, (byte) $10, (byte) 8, (byte) 4, (byte) 2, (byte) 1 }
 (void()) circle((signed word) circle::xc , (signed word) circle::yc , (signed word) circle::r)
-(signed word~) circle::$0 zp[2]:4 4.0
-(signed word~) circle::$10 zp[2]:4 202.0
-(signed word~) circle::$5 zp[2]:10 202.0
-(signed word~) circle::$6 zp[2]:10 202.0
-(signed word~) circle::$7 zp[2]:4 202.0
-(signed word~) circle::$9 zp[2]:12 202.0
+(signed word~) circle::$0 zp[2]:4 2002.0
+(signed word~) circle::$10 zp[2]:4 200002.0
+(signed word~) circle::$5 zp[2]:10 200002.0
+(signed word~) circle::$6 zp[2]:10 200002.0
+(signed word~) circle::$7 zp[2]:4 200002.0
+(signed word~) circle::$9 zp[2]:12 200002.0
 (label) circle::@1
 (label) circle::@10
 (label) circle::@11
@@ -33,22 +33,22 @@
 (label) circle::@9
 (label) circle::@return
 (signed word) circle::p
-(signed word) circle::p#0 p zp[2]:4 4.0
-(signed word) circle::p#1 p zp[2]:4 202.0
-(signed word) circle::p#10 p zp[2]:4 11.653846153846153
-(signed word) circle::p#2 p zp[2]:4 202.0
-(signed word) circle::p#3 p zp[2]:4 58.00000000000001
+(signed word) circle::p#0 p zp[2]:4 2002.0
+(signed word) circle::p#1 p zp[2]:4 200002.0
+(signed word) circle::p#10 p zp[2]:4 11538.576923076922
+(signed word) circle::p#2 p zp[2]:4 200002.0
+(signed word) circle::p#3 p zp[2]:4 57286.42857142857
 (signed word) circle::r
-(signed word) circle::r#0 r zp[2]:8 5.0
+(signed word) circle::r#0 r zp[2]:8 701.0
 (signed word) circle::x1
-(signed word) circle::x1#1 x1 zp[2]:6 202.0
-(signed word) circle::x1#10 x1 zp[2]:6 36.47222222222223
+(signed word) circle::x1#1 x1 zp[2]:6 200002.0
+(signed word) circle::x1#10 x1 zp[2]:6 36111.47222222222
 (signed word) circle::xc
 (const signed word) circle::xc#0 xc = (signed word) $a0
 (signed word) circle::y
-(signed word) circle::y#1 y zp[2]:8 60.599999999999994
-(signed word) circle::y#10 y zp[2]:8 42.73076923076923
-(signed word) circle::y#13 y zp[2]:8 67.66666666666666
+(signed word) circle::y#1 y zp[2]:8 60000.600000000006
+(signed word) circle::y#10 y zp[2]:8 42308.11538461538
+(signed word) circle::y#13 y zp[2]:8 66834.16666666666
 (signed word) circle::yc
 (const signed word) circle::yc#0 yc = (signed byte) $64
 (void()) fill((byte*) fill::start , (signed word) fill::size , (byte) fill::val)
@@ -56,16 +56,16 @@
 (label) fill::@2
 (label) fill::@return
 (byte*) fill::addr
-(byte*) fill::addr#0 addr zp[2]:8 2.0
-(byte*) fill::addr#1 addr zp[2]:8 22.0
-(byte*) fill::addr#2 addr zp[2]:8 15.333333333333332
+(byte*) fill::addr#0 addr zp[2]:8 101.0
+(byte*) fill::addr#1 addr zp[2]:8 2002.0
+(byte*) fill::addr#2 addr zp[2]:8 1368.3333333333335
 (byte*) fill::end
-(byte*) fill::end#0 end zp[2]:6 2.6
+(byte*) fill::end#0 end zp[2]:6 220.39999999999998
 (signed word) fill::size
-(signed word) fill::size#2 size zp[2]:6 2.0
+(signed word) fill::size#2 size zp[2]:6 101.0
 (byte*) fill::start
 (byte) fill::val
-(byte) fill::val#4 reg byte x 1.8333333333333333
+(byte) fill::val#4 reg byte x 166.83333333333334
 (void()) main()
 (label) main::@1
 (label) main::@2
@@ -74,47 +74,47 @@
 (label) main::@5
 (label) main::@6
 (signed word) main::i
-(signed word) main::i#1 i zp[2]:2 22.0
-(signed word) main::i#2 i zp[2]:2 11.0
+(signed word) main::i#1 i zp[2]:2 202.0
+(signed word) main::i#2 i zp[2]:2 101.0
 (void()) plot((signed word) plot::x , (signed word) plot::y)
-(byte~) plot::$10 reg byte a 4.0
-(signed word~) plot::$11 zp[2]:12 3.0
-(signed word~) plot::$12 zp[2]:16 4.0
-(signed byte~) plot::$13 reg byte a 4.0
-(byte~) plot::$14 reg byte a 4.0
-(signed word~) plot::$15 zp[2]:16 4.0
-(signed word~) plot::$16 zp[2]:16 4.0
-(signed word~) plot::$8 zp[2]:14 4.0
-(byte~) plot::$9 reg byte a 4.0
+(byte~) plot::$10 reg byte a 2000002.0
+(signed word~) plot::$11 zp[2]:12 1500001.5
+(signed word~) plot::$12 zp[2]:16 2000002.0
+(signed byte~) plot::$13 reg byte a 2000002.0
+(byte~) plot::$14 reg byte a 2000002.0
+(signed word~) plot::$15 zp[2]:16 2000002.0
+(signed word~) plot::$16 zp[2]:16 2000002.0
+(signed word~) plot::$8 zp[2]:14 2000002.0
+(byte~) plot::$9 reg byte a 2000002.0
 (label) plot::@1
 (label) plot::@2
 (label) plot::@3
 (label) plot::@4
 (label) plot::@return
 (byte*) plot::location
-(byte*) plot::location#1 location zp[2]:14 1.3333333333333333
-(byte*) plot::location#2 location zp[2]:14 0.8
-(byte*) plot::location#3 location zp[2]:14 2.0
+(byte*) plot::location#1 location zp[2]:14 666667.3333333334
+(byte*) plot::location#2 location zp[2]:14 400000.4
+(byte*) plot::location#3 location zp[2]:14 1000001.0
 (signed word) plot::x
-(signed word) plot::x#0 x zp[2]:10 101.0
-(signed word) plot::x#1 x zp[2]:10 101.0
-(signed word) plot::x#2 x zp[2]:10 101.0
-(signed word) plot::x#3 x zp[2]:10 101.0
-(signed word) plot::x#4 x zp[2]:10 101.0
-(signed word) plot::x#5 x zp[2]:10 101.0
-(signed word) plot::x#6 x zp[2]:10 101.0
-(signed word) plot::x#7 x zp[2]:10 101.0
-(signed word) plot::x#8 x zp[2]:10 54.4
+(signed word) plot::x#0 x zp[2]:10 100001.0
+(signed word) plot::x#1 x zp[2]:10 100001.0
+(signed word) plot::x#2 x zp[2]:10 100001.0
+(signed word) plot::x#3 x zp[2]:10 100001.0
+(signed word) plot::x#4 x zp[2]:10 100001.0
+(signed word) plot::x#5 x zp[2]:10 100001.0
+(signed word) plot::x#6 x zp[2]:10 100001.0
+(signed word) plot::x#7 x zp[2]:10 100001.0
+(signed word) plot::x#8 x zp[2]:10 320000.80000000005
 (signed word) plot::y
-(signed word) plot::y#0 y zp[2]:12 202.0
-(signed word) plot::y#1 y zp[2]:12 202.0
-(signed word) plot::y#2 y zp[2]:12 202.0
-(signed word) plot::y#3 y zp[2]:12 202.0
-(signed word) plot::y#4 y zp[2]:12 202.0
-(signed word) plot::y#5 y zp[2]:12 202.0
-(signed word) plot::y#6 y zp[2]:12 202.0
-(signed word) plot::y#7 y zp[2]:12 202.0
-(signed word) plot::y#8 y zp[2]:12 81.60000000000001
+(signed word) plot::y#0 y zp[2]:12 200002.0
+(signed word) plot::y#1 y zp[2]:12 200002.0
+(signed word) plot::y#2 y zp[2]:12 200002.0
+(signed word) plot::y#3 y zp[2]:12 200002.0
+(signed word) plot::y#4 y zp[2]:12 200002.0
+(signed word) plot::y#5 y zp[2]:12 200002.0
+(signed word) plot::y#6 y zp[2]:12 200002.0
+(signed word) plot::y#7 y zp[2]:12 200002.0
+(signed word) plot::y#8 y zp[2]:12 480001.19999999995
 
 zp[2]:2 [ main::i#2 main::i#1 ]
 zp[2]:4 [ circle::p#3 circle::p#0 circle::p#10 circle::p#1 circle::p#2 circle::$7 circle::$10 circle::$0 ]

src/test/ref/bitmap-circle.log

@@ -588,46 +588,46 @@ Inferred type updated to signed word in (snumber~) plot::$0 ← (signed word) pl
 Inferred type updated to byte in (unumber~) plot::$2 ← (byte~) plot::$1 & (byte) 7
 Inferred type updated to signed word in (snumber~) plot::$4 ← (signed word~) plot::$3 * (signed word) $140
 Inferred type updated to signed byte in (snumber~) plot::$5 ← (signed word) plot::x#8 & (signed byte) 7
-Alias (signed word) circle::y#0 = (signed word) circle::r#1 
-Alias (signed word) circle::p#0 = (signed word~) circle::$1 
-Alias (signed word) circle::p#3 = (signed word) circle::p#6 (signed word) circle::p#4 (signed word) circle::p#5 
-Alias (signed word) circle::x1#14 = (signed word) circle::x1#2 (signed word) circle::x1#3 (signed word) circle::x1#4 
-Alias (signed word) circle::y#13 = (signed word) circle::y#2 (signed word) circle::y#14 (signed word) circle::y#3 
-Alias (signed word) circle::xc#10 = (signed word) circle::xc#11 (signed word) circle::xc#12 (signed word) circle::xc#9 
-Alias (signed word) circle::yc#10 = (signed word) circle::yc#11 (signed word) circle::yc#12 (signed word) circle::yc#9 
-Alias (signed word) circle::p#1 = (signed word~) circle::$11 
-Alias (signed word) circle::y#1 = (signed word~) circle::$4 
-Alias (signed word) circle::p#2 = (signed word~) circle::$8 
-Alias (signed word) plot::x#0 = (signed word~) circle::$12 
-Alias (signed word) plot::y#0 = (signed word~) circle::$13 
-Alias (signed word) circle::xc#1 = (signed word) circle::xc#2 (signed word) circle::xc#3 (signed word) circle::xc#4 (signed word) circle::xc#5 (signed word) circle::xc#6 (signed word) circle::xc#7 (signed word) circle::xc#8 (signed word) circle::xc#14 
-Alias (signed word) circle::x1#10 = (signed word) circle::x1#6 (signed word) circle::x1#5 (signed word) circle::x1#7 (signed word) circle::x1#8 (signed word) circle::x1#9 (signed word) circle::x1#11 (signed word) circle::x1#12 (signed word) circle::x1#13 
-Alias (signed word) circle::yc#1 = (signed word) circle::yc#2 (signed word) circle::yc#3 (signed word) circle::yc#4 (signed word) circle::yc#5 (signed word) circle::yc#6 (signed word) circle::yc#7 (signed word) circle::yc#8 (signed word) circle::yc#14 
-Alias (signed word) circle::y#10 = (signed word) circle::y#5 (signed word) circle::y#4 (signed word) circle::y#6 (signed word) circle::y#7 (signed word) circle::y#8 (signed word) circle::y#9 (signed word) circle::y#11 (signed word) circle::y#12 
-Alias (signed word) circle::p#10 = (signed word) circle::p#14 (signed word) circle::p#15 (signed word) circle::p#13 (signed word) circle::p#12 (signed word) circle::p#11 (signed word) circle::p#9 (signed word) circle::p#8 (signed word) circle::p#7 
-Alias (signed word) plot::x#1 = (signed word~) circle::$15 
-Alias (signed word) plot::y#1 = (signed word~) circle::$16 
-Alias (signed word) plot::x#2 = (signed word~) circle::$18 
-Alias (signed word) plot::y#2 = (signed word~) circle::$19 
-Alias (signed word) plot::x#3 = (signed word~) circle::$21 
-Alias (signed word) plot::y#3 = (signed word~) circle::$22 
-Alias (signed word) plot::x#4 = (signed word~) circle::$24 
-Alias (signed word) plot::y#4 = (signed word~) circle::$25 
-Alias (signed word) plot::x#5 = (signed word~) circle::$27 
-Alias (signed word) plot::y#5 = (signed word~) circle::$28 
-Alias (signed word) plot::x#6 = (signed word~) circle::$30 
-Alias (signed word) plot::y#6 = (signed word~) circle::$31 
-Alias (signed word) plot::x#7 = (signed word~) circle::$33 
-Alias (signed word) plot::y#7 = (signed word~) circle::$34 
-Alias (byte*) fill::end#0 = (byte*~) fill::$0 
-Alias (byte*) fill::addr#0 = (byte*) fill::start#2 
-Alias (byte) fill::val#2 = (byte) fill::val#3 
-Alias (byte*) fill::addr#2 = (byte*) fill::addr#3 
-Alias (byte*) fill::end#1 = (byte*) fill::end#2 
+Alias circle::y#0 = circle::r#1 
+Alias circle::p#0 = circle::$1 
+Alias circle::p#3 = circle::p#6 circle::p#4 circle::p#5 
+Alias circle::x1#14 = circle::x1#2 circle::x1#3 circle::x1#4 
+Alias circle::y#13 = circle::y#2 circle::y#14 circle::y#3 
+Alias circle::xc#10 = circle::xc#11 circle::xc#12 circle::xc#9 
+Alias circle::yc#10 = circle::yc#11 circle::yc#12 circle::yc#9 
+Alias circle::p#1 = circle::$11 
+Alias circle::y#1 = circle::$4 
+Alias circle::p#2 = circle::$8 
+Alias plot::x#0 = circle::$12 
+Alias plot::y#0 = circle::$13 
+Alias circle::xc#1 = circle::xc#2 circle::xc#3 circle::xc#4 circle::xc#5 circle::xc#6 circle::xc#7 circle::xc#8 circle::xc#14 
+Alias circle::x1#10 = circle::x1#6 circle::x1#5 circle::x1#7 circle::x1#8 circle::x1#9 circle::x1#11 circle::x1#12 circle::x1#13 
+Alias circle::yc#1 = circle::yc#2 circle::yc#3 circle::yc#4 circle::yc#5 circle::yc#6 circle::yc#7 circle::yc#8 circle::yc#14 
+Alias circle::y#10 = circle::y#5 circle::y#4 circle::y#6 circle::y#7 circle::y#8 circle::y#9 circle::y#11 circle::y#12 
+Alias circle::p#10 = circle::p#14 circle::p#15 circle::p#13 circle::p#12 circle::p#11 circle::p#9 circle::p#8 circle::p#7 
+Alias plot::x#1 = circle::$15 
+Alias plot::y#1 = circle::$16 
+Alias plot::x#2 = circle::$18 
+Alias plot::y#2 = circle::$19 
+Alias plot::x#3 = circle::$21 
+Alias plot::y#3 = circle::$22 
+Alias plot::x#4 = circle::$24 
+Alias plot::y#4 = circle::$25 
+Alias plot::x#5 = circle::$27 
+Alias plot::y#5 = circle::$28 
+Alias plot::x#6 = circle::$30 
+Alias plot::y#6 = circle::$31 
+Alias plot::x#7 = circle::$33 
+Alias plot::y#7 = circle::$34 
+Alias fill::end#0 = fill::$0 
+Alias fill::addr#0 = fill::start#2 
+Alias fill::val#2 = fill::val#3 
+Alias fill::addr#2 = fill::addr#3 
+Alias fill::end#1 = fill::end#2 
 Successful SSA optimization Pass2AliasElimination
-Alias (signed word) circle::xc#1 = (signed word) circle::xc#10 
-Alias (signed word) circle::x1#10 = (signed word) circle::x1#14 
-Alias (signed word) circle::yc#1 = (signed word) circle::yc#10 
+Alias circle::xc#1 = circle::xc#10 
+Alias circle::x1#10 = circle::x1#14 
+Alias circle::yc#1 = circle::yc#10 
 Successful SSA optimization Pass2AliasElimination
 Identical Phi Values (signed word) circle::y#0 (signed word) circle::r#0
 Identical Phi Values (signed word) circle::xc#13 (signed word) circle::xc#0
@@ -687,7 +687,7 @@ Constant inlined fill::size#1 = (signed word)(number) $28*(number) $19
 Constant inlined fill::size#0 = (signed word)(number) $28*(number) $19*(number) 8
 Constant inlined circle::p#0 = (signed byte) 3-(const signed word) circle::r#0<<(signed byte) 1
 Successful SSA optimization Pass2ConstantInlining
-Alias (signed word~) plot::$4 = (signed word~) plot::$9 
+Alias plot::$4 = plot::$9 
 Successful SSA optimization Pass2AliasElimination
 Adding NOP phi() at start of @begin
 Adding NOP phi() at start of @8
@@ -902,73 +902,73 @@ fill::@2: scope:[fill]  from fill::@1
 
 VARIABLE REGISTER WEIGHTS
 (void()) circle((signed word) circle::xc , (signed word) circle::yc , (signed word) circle::r)
-(signed word~) circle::$10 22.0
-(signed word~) circle::$5 22.0
-(signed word~) circle::$6 22.0
-(signed word~) circle::$7 22.0
-(signed word~) circle::$9 22.0
+(signed word~) circle::$10 2002.0
+(signed word~) circle::$5 2002.0
+(signed word~) circle::$6 2002.0
+(signed word~) circle::$7 2002.0
+(signed word~) circle::$9 2002.0
 (signed word) circle::p
-(signed word) circle::p#1 22.0
-(signed word) circle::p#10 1.2692307692307692
-(signed word) circle::p#2 22.0
-(signed word) circle::p#3 6.285714285714286
+(signed word) circle::p#1 2002.0
+(signed word) circle::p#10 115.5
+(signed word) circle::p#2 2002.0
+(signed word) circle::p#3 572.0
 (signed word) circle::r
 (signed word) circle::x1
-(signed word) circle::x1#1 22.0
-(signed word) circle::x1#10 3.9722222222222214
+(signed word) circle::x1#1 2002.0
+(signed word) circle::x1#10 361.4722222222221
 (signed word) circle::xc
 (signed word) circle::y
-(signed word) circle::y#1 6.6000000000000005
-(signed word) circle::y#10 4.653846153846153
-(signed word) circle::y#13 7.333333333333333
+(signed word) circle::y#1 600.5999999999999
+(signed word) circle::y#10 423.5
+(signed word) circle::y#13 667.3333333333334
 (signed word) circle::yc
 (void()) fill((byte*) fill::start , (signed word) fill::size , (byte) fill::val)
 (byte*) fill::addr
-(byte*) fill::addr#0 2.0
-(byte*) fill::addr#1 22.0
-(byte*) fill::addr#2 15.333333333333332
+(byte*) fill::addr#0 101.0
+(byte*) fill::addr#1 2002.0
+(byte*) fill::addr#2 1368.3333333333335
 (byte*) fill::end
-(byte*) fill::end#0 2.6
+(byte*) fill::end#0 220.39999999999998
 (signed word) fill::size
-(signed word) fill::size#2 2.0
+(signed word) fill::size#2 101.0
 (byte*) fill::start
 (byte) fill::val
-(byte) fill::val#4 1.8333333333333333
+(byte) fill::val#4 166.83333333333334
 (void()) main()
 (void()) plot((signed word) plot::x , (signed word) plot::y)
-(signed word~) plot::$0 4.0
-(byte~) plot::$1 4.0
-(byte~) plot::$2 4.0
-(signed word~) plot::$3 3.0
-(signed word~) plot::$4 4.0
-(signed byte~) plot::$5 4.0
-(byte~) plot::$6 4.0
-(signed word~) plot::$7 4.0
-(signed word~) plot::$8 4.0
+(signed word~) plot::$0 20002.0
+(byte~) plot::$1 20002.0
+(byte~) plot::$2 20002.0
+(signed word~) plot::$3 15001.5
+(signed word~) plot::$4 20002.0
+(signed byte~) plot::$5 20002.0
+(byte~) plot::$6 20002.0
+(signed word~) plot::$7 20002.0
+(signed word~) plot::$8 20002.0
 (byte*) plot::location
-(byte*) plot::location#1 1.3333333333333333
-(byte*) plot::location#2 0.8
-(byte*) plot::location#3 2.0
+(byte*) plot::location#1 6667.333333333333
+(byte*) plot::location#2 4000.4
+(byte*) plot::location#3 10001.0
 (signed word) plot::x
-(signed word) plot::x#0 11.0
-(signed word) plot::x#1 11.0
-(signed word) plot::x#2 11.0
-(signed word) plot::x#3 11.0
-(signed word) plot::x#4 11.0
-(signed word) plot::x#5 11.0
-(signed word) plot::x#6 11.0
-(signed word) plot::x#7 11.0
-(signed word) plot::x#8 8.363636363636363
+(signed word) plot::x#0 1001.0
+(signed word) plot::x#1 1001.0
+(signed word) plot::x#2 1001.0
+(signed word) plot::x#3 1001.0
+(signed word) plot::x#4 1001.0
+(signed word) plot::x#5 1001.0
+(signed word) plot::x#6 1001.0
+(signed word) plot::x#7 1001.0
+(signed word) plot::x#8 2546.363636363636
 (signed word) plot::y
-(signed word) plot::y#0 22.0
-(signed word) plot::y#1 22.0
-(signed word) plot::y#2 22.0
-(signed word) plot::y#3 22.0
-(signed word) plot::y#4 22.0
-(signed word) plot::y#5 22.0
-(signed word) plot::y#6 22.0
-(signed word) plot::y#7 22.0
-(signed word) plot::y#8 15.333333333333336
+(signed word) plot::y#0 2002.0
+(signed word) plot::y#1 2002.0
+(signed word) plot::y#2 2002.0
+(signed word) plot::y#3 2002.0
+(signed word) plot::y#4 2002.0
+(signed word) plot::y#5 2002.0
+(signed word) plot::y#6 2002.0
+(signed word) plot::y#7 2002.0
+(signed word) plot::y#8 4668.333333333333
 
 Initial phi equivalence classes
 [ circle::x1#10 circle::x1#1 ]
@@ -1673,96 +1673,94 @@ fill: {
   bitmask: .byte $80, $40, $20, $10, 8, 4, 2, 1
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Statement [8] *((const byte*) BORDERCOL) ← (const byte) BLUE [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [9] *((const byte*) D011) ← (const byte) VIC_BMM|(const byte) VIC_DEN|(const byte) VIC_RSEL|(byte) 3 [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [10] *((const byte*) VIC_MEMORY) ← (byte)(word)(const byte*) SCREEN&(word) $3fff/(byte) $40|(word)(const byte*) BITMAP&(word) $3fff/(word) $400 [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [15] if((signed word) circle::x1#10<=(signed word) circle::y#13) goto circle::@2 [ circle::x1#10 circle::y#13 circle::p#3 ] ( main:2::circle:11 [ circle::x1#10 circle::y#13 circle::p#3 ] ) always clobbers reg byte a 
-Statement [17] if((signed word) circle::p#3<(signed byte) 0) goto circle::@3 [ circle::x1#10 circle::y#13 circle::p#3 ] ( main:2::circle:11 [ circle::x1#10 circle::y#13 circle::p#3 ] ) always clobbers reg byte a 
-Statement [18] (signed word) circle::y#1 ← (signed word) circle::y#13 - (signed byte) 1 [ circle::x1#10 circle::p#3 circle::y#1 ] ( main:2::circle:11 [ circle::x1#10 circle::p#3 circle::y#1 ] ) always clobbers reg byte a 
-Statement [19] (signed word~) circle::$5 ← (signed word) circle::x1#10 - (signed word) circle::y#1 [ circle::x1#10 circle::p#3 circle::y#1 circle::$5 ] ( main:2::circle:11 [ circle::x1#10 circle::p#3 circle::y#1 circle::$5 ] ) always clobbers reg byte a 
-Statement [20] (signed word~) circle::$6 ← (signed word~) circle::$5 << (signed byte) 2 [ circle::x1#10 circle::p#3 circle::y#1 circle::$6 ] ( main:2::circle:11 [ circle::x1#10 circle::p#3 circle::y#1 circle::$6 ] ) always clobbers reg byte a 
-Statement [21] (signed word~) circle::$7 ← (signed word) circle::p#3 + (signed word~) circle::$6 [ circle::x1#10 circle::y#1 circle::$7 ] ( main:2::circle:11 [ circle::x1#10 circle::y#1 circle::$7 ] ) always clobbers reg byte a 
-Statement [22] (signed word) circle::p#2 ← (signed word~) circle::$7 + (signed byte) $a [ circle::x1#10 circle::y#1 circle::p#2 ] ( main:2::circle:11 [ circle::x1#10 circle::y#1 circle::p#2 ] ) always clobbers reg byte a 
-Statement [24] (signed word) plot::x#0 ← (const signed word) circle::xc#0 + (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#0 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#0 ] ) always clobbers reg byte a 
-Statement [25] (signed word) plot::y#0 ← (const signed word) circle::yc#0 - (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#0 plot::y#0 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#0 plot::y#0 ] ) always clobbers reg byte a 
-Statement [27] (signed word) plot::x#1 ← (const signed word) circle::xc#0 - (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#1 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#1 ] ) always clobbers reg byte a 
-Statement [28] (signed word) plot::y#1 ← (const signed word) circle::yc#0 - (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#1 plot::y#1 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#1 plot::y#1 ] ) always clobbers reg byte a 
-Statement [30] (signed word) plot::x#2 ← (const signed word) circle::xc#0 + (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#2 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#2 ] ) always clobbers reg byte a 
-Statement [31] (signed word) plot::y#2 ← (const signed word) circle::yc#0 + (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#2 plot::y#2 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#2 plot::y#2 ] ) always clobbers reg byte a 
-Statement [33] (signed word) plot::x#3 ← (const signed word) circle::xc#0 - (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#3 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#3 ] ) always clobbers reg byte a 
-Statement [34] (signed word) plot::y#3 ← (const signed word) circle::yc#0 + (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#3 plot::y#3 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#3 plot::y#3 ] ) always clobbers reg byte a 
-Statement [36] (signed word) plot::x#4 ← (const signed word) circle::xc#0 + (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#4 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#4 ] ) always clobbers reg byte a 
-Statement [37] (signed word) plot::y#4 ← (const signed word) circle::yc#0 - (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#4 plot::y#4 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#4 plot::y#4 ] ) always clobbers reg byte a 
-Statement [39] (signed word) plot::x#5 ← (const signed word) circle::xc#0 - (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#5 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#5 ] ) always clobbers reg byte a 
-Statement [40] (signed word) plot::y#5 ← (const signed word) circle::yc#0 - (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#5 plot::y#5 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#5 plot::y#5 ] ) always clobbers reg byte a 
-Statement [42] (signed word) plot::x#6 ← (const signed word) circle::xc#0 + (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#6 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#6 ] ) always clobbers reg byte a 
-Statement [43] (signed word) plot::y#6 ← (const signed word) circle::yc#0 + (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#6 plot::y#6 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#6 plot::y#6 ] ) always clobbers reg byte a 
-Statement [45] (signed word) plot::x#7 ← (const signed word) circle::xc#0 - (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#7 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#7 ] ) always clobbers reg byte a 
-Statement [46] (signed word) plot::y#7 ← (const signed word) circle::yc#0 + (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#7 plot::y#7 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#7 plot::y#7 ] ) always clobbers reg byte a 
-Statement [49] (signed word~) circle::$9 ← (signed word) circle::x1#10 << (signed byte) 2 [ circle::x1#10 circle::y#13 circle::p#3 circle::$9 ] ( main:2::circle:11 [ circle::x1#10 circle::y#13 circle::p#3 circle::$9 ] ) always clobbers reg byte a 
-Statement [50] (signed word~) circle::$10 ← (signed word) circle::p#3 + (signed word~) circle::$9 [ circle::x1#10 circle::y#13 circle::$10 ] ( main:2::circle:11 [ circle::x1#10 circle::y#13 circle::$10 ] ) always clobbers reg byte a 
-Statement [51] (signed word) circle::p#1 ← (signed word~) circle::$10 + (signed byte) 6 [ circle::x1#10 circle::y#13 circle::p#1 ] ( main:2::circle:11 [ circle::x1#10 circle::y#13 circle::p#1 ] ) always clobbers reg byte a 
-Statement [53] (signed word~) plot::$0 ← (signed word) plot::x#8 & (signed dword) $fff8 [ plot::x#8 plot::y#8 plot::$0 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$0 ] main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$0 ] main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$0 ] main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$0 ] main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$0 ] main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$0 ] main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$0 ] main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$0 ] ) always clobbers reg byte a 
-Statement [54] (byte*) plot::location#1 ← (const byte*) BITMAP + (signed word~) plot::$0 [ plot::x#8 plot::y#8 plot::location#1 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] ) always clobbers reg byte a 
-Statement [55] (byte~) plot::$1 ← < (signed word) plot::y#8 [ plot::x#8 plot::y#8 plot::location#1 plot::$1 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 plot::$1 ] main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 plot::$1 ] main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 plot::$1 ] main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 plot::$1 ] main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 plot::$1 ] main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 plot::$1 ] main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 plot::$1 ] main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 plot::$1 ] ) always clobbers reg byte a 
-Statement [57] (byte*) plot::location#2 ← (byte*) plot::location#1 + (byte~) plot::$2 [ plot::x#8 plot::y#8 plot::location#2 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] ) always clobbers reg byte a 
-Statement [58] (signed word~) plot::$3 ← (signed word) plot::y#8 >> (signed byte) 3 [ plot::x#8 plot::location#2 plot::$3 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 ] main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 ] main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 ] main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 ] main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 ] main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 ] main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 ] main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 ] ) always clobbers reg byte a 
-Statement [59] (signed word~) plot::$7 ← (signed word~) plot::$3 << (byte) 2 [ plot::x#8 plot::location#2 plot::$3 plot::$7 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 plot::$7 ] main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 plot::$7 ] main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 plot::$7 ] main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 plot::$7 ] main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 plot::$7 ] main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 plot::$7 ] main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 plot::$7 ] main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 plot::$7 ] ) always clobbers reg byte a 
-Statement [60] (signed word~) plot::$8 ← (signed word~) plot::$7 + (signed word~) plot::$3 [ plot::x#8 plot::location#2 plot::$8 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$8 ] main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$8 ] main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$8 ] main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$8 ] main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$8 ] main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$8 ] main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$8 ] main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$8 ] ) always clobbers reg byte a 
-Statement [61] (signed word~) plot::$4 ← (signed word~) plot::$8 << (byte) 6 [ plot::x#8 plot::location#2 plot::$4 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$4 ] main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$4 ] main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$4 ] main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$4 ] main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$4 ] main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$4 ] main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$4 ] main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$4 ] ) always clobbers reg byte a 
-Statement [62] (byte*) plot::location#3 ← (byte*) plot::location#2 + (signed word~) plot::$4 [ plot::x#8 plot::location#3 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] ) always clobbers reg byte a 
-Statement [63] (signed byte~) plot::$5 ← (signed word) plot::x#8 & (signed byte) 7 [ plot::location#3 plot::$5 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$5 ] main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$5 ] main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$5 ] main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$5 ] main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$5 ] main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$5 ] main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$5 ] main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$5 ] ) always clobbers reg byte a 
-Statement [64] (byte~) plot::$6 ← *((byte*) plot::location#3) | *((const byte*) bitmask + (signed byte~) plot::$5) [ plot::location#3 plot::$6 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$6 ] main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$6 ] main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$6 ] main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$6 ] main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$6 ] main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$6 ] main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$6 ] main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$6 ] ) always clobbers reg byte a reg byte y 
-Statement [65] *((byte*) plot::location#3) ← (byte~) plot::$6 [ ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 ] main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 ] main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 ] main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 ] main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 ] main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 ] main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 ] main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 ] ) always clobbers reg byte y 
-Statement [68] (byte*) fill::end#0 ← (byte*) fill::addr#0 + (signed word) fill::size#2 [ fill::addr#0 fill::val#4 fill::end#0 ] ( main:2::fill:5 [ fill::addr#0 fill::val#4 fill::end#0 ] main:2::fill:7 [ fill::addr#0 fill::val#4 fill::end#0 ] ) always clobbers reg byte a 
+Statement [8] *((const byte*) BORDERCOL) ← (const byte) BLUE [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [9] *((const byte*) D011) ← (const byte) VIC_BMM|(const byte) VIC_DEN|(const byte) VIC_RSEL|(byte) 3 [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [10] *((const byte*) VIC_MEMORY) ← (byte)(word)(const byte*) SCREEN&(word) $3fff/(byte) $40|(word)(const byte*) BITMAP&(word) $3fff/(word) $400 [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [15] if((signed word) circle::x1#10<=(signed word) circle::y#13) goto circle::@2 [ circle::x1#10 circle::y#13 circle::p#3 ] ( main:2::circle:11 [ circle::x1#10 circle::y#13 circle::p#3 ] { }  ) always clobbers reg byte a 
+Statement [17] if((signed word) circle::p#3<(signed byte) 0) goto circle::@3 [ circle::x1#10 circle::y#13 circle::p#3 ] ( main:2::circle:11 [ circle::x1#10 circle::y#13 circle::p#3 ] { }  ) always clobbers reg byte a 
+Statement [18] (signed word) circle::y#1 ← (signed word) circle::y#13 - (signed byte) 1 [ circle::x1#10 circle::p#3 circle::y#1 ] ( main:2::circle:11 [ circle::x1#10 circle::p#3 circle::y#1 ] { }  ) always clobbers reg byte a 
+Statement [19] (signed word~) circle::$5 ← (signed word) circle::x1#10 - (signed word) circle::y#1 [ circle::x1#10 circle::p#3 circle::y#1 circle::$5 ] ( main:2::circle:11 [ circle::x1#10 circle::p#3 circle::y#1 circle::$5 ] { }  ) always clobbers reg byte a 
+Statement [20] (signed word~) circle::$6 ← (signed word~) circle::$5 << (signed byte) 2 [ circle::x1#10 circle::p#3 circle::y#1 circle::$6 ] ( main:2::circle:11 [ circle::x1#10 circle::p#3 circle::y#1 circle::$6 ] { }  ) always clobbers reg byte a 
+Statement [21] (signed word~) circle::$7 ← (signed word) circle::p#3 + (signed word~) circle::$6 [ circle::x1#10 circle::y#1 circle::$7 ] ( main:2::circle:11 [ circle::x1#10 circle::y#1 circle::$7 ] { }  ) always clobbers reg byte a 
+Statement [22] (signed word) circle::p#2 ← (signed word~) circle::$7 + (signed byte) $a [ circle::x1#10 circle::y#1 circle::p#2 ] ( main:2::circle:11 [ circle::x1#10 circle::y#1 circle::p#2 ] { }  ) always clobbers reg byte a 
+Statement [24] (signed word) plot::x#0 ← (const signed word) circle::xc#0 + (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#0 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#0 ] { { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [25] (signed word) plot::y#0 ← (const signed word) circle::yc#0 - (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#0 plot::y#0 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#0 plot::y#0 ] { { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [27] (signed word) plot::x#1 ← (const signed word) circle::xc#0 - (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#1 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#1 ] { { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [28] (signed word) plot::y#1 ← (const signed word) circle::yc#0 - (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#1 plot::y#1 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#1 plot::y#1 ] { { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [30] (signed word) plot::x#2 ← (const signed word) circle::xc#0 + (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#2 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#2 ] { { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [31] (signed word) plot::y#2 ← (const signed word) circle::yc#0 + (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#2 plot::y#2 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#2 plot::y#2 ] { { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [33] (signed word) plot::x#3 ← (const signed word) circle::xc#0 - (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#3 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#3 ] { { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [34] (signed word) plot::y#3 ← (const signed word) circle::yc#0 + (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#3 plot::y#3 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#3 plot::y#3 ] { { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [36] (signed word) plot::x#4 ← (const signed word) circle::xc#0 + (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#4 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#4 ] { { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [37] (signed word) plot::y#4 ← (const signed word) circle::yc#0 - (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#4 plot::y#4 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#4 plot::y#4 ] { { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [39] (signed word) plot::x#5 ← (const signed word) circle::xc#0 - (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#5 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#5 ] { { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [40] (signed word) plot::y#5 ← (const signed word) circle::yc#0 - (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#5 plot::y#5 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#5 plot::y#5 ] { { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [42] (signed word) plot::x#6 ← (const signed word) circle::xc#0 + (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#6 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#6 ] { { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [43] (signed word) plot::y#6 ← (const signed word) circle::yc#0 + (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#6 plot::y#6 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#6 plot::y#6 ] { { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [45] (signed word) plot::x#7 ← (const signed word) circle::xc#0 - (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#7 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#7 ] { { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [46] (signed word) plot::y#7 ← (const signed word) circle::yc#0 + (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#7 plot::y#7 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#7 plot::y#7 ] { { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [49] (signed word~) circle::$9 ← (signed word) circle::x1#10 << (signed byte) 2 [ circle::x1#10 circle::y#13 circle::p#3 circle::$9 ] ( main:2::circle:11 [ circle::x1#10 circle::y#13 circle::p#3 circle::$9 ] { }  ) always clobbers reg byte a 
+Statement [50] (signed word~) circle::$10 ← (signed word) circle::p#3 + (signed word~) circle::$9 [ circle::x1#10 circle::y#13 circle::$10 ] ( main:2::circle:11 [ circle::x1#10 circle::y#13 circle::$10 ] { }  ) always clobbers reg byte a 
+Statement [51] (signed word) circle::p#1 ← (signed word~) circle::$10 + (signed byte) 6 [ circle::x1#10 circle::y#13 circle::p#1 ] ( main:2::circle:11 [ circle::x1#10 circle::y#13 circle::p#1 ] { }  ) always clobbers reg byte a 
+Statement [53] (signed word~) plot::$0 ← (signed word) plot::x#8 & (signed dword) $fff8 [ plot::x#8 plot::y#8 plot::$0 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$0 ] { { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$0 ] { { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$0 ] { { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$0 ] { { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$0 ] { { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$0 ] { { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$0 ] { { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$0 ] { { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [54] (byte*) plot::location#1 ← (const byte*) BITMAP + (signed word~) plot::$0 [ plot::x#8 plot::y#8 plot::location#1 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] { { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] { { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] { { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] { { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] { { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] { { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] { { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] { { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [57] (byte*) plot::location#2 ← (byte*) plot::location#1 + (byte~) plot::$2 [ plot::x#8 plot::y#8 plot::location#2 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] { { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] { { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] { { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] { { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] { { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] { { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] { { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] { { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [58] (signed word~) plot::$3 ← (signed word) plot::y#8 >> (signed byte) 3 [ plot::x#8 plot::location#2 plot::$3 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 ] { { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 ] { { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 ] { { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 ] { { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 ] { { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 ] { { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 ] { { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 ] { { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [59] (signed word~) plot::$7 ← (signed word~) plot::$3 << (byte) 2 [ plot::x#8 plot::location#2 plot::$3 plot::$7 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 plot::$7 ] { { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 plot::$7 ] { { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 plot::$7 ] { { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 plot::$7 ] { { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 plot::$7 ] { { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 plot::$7 ] { { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 plot::$7 ] { { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 plot::$7 ] { { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [60] (signed word~) plot::$8 ← (signed word~) plot::$7 + (signed word~) plot::$3 [ plot::x#8 plot::location#2 plot::$8 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$8 ] { { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$8 ] { { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$8 ] { { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$8 ] { { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$8 ] { { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$8 ] { { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$8 ] { { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$8 ] { { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [61] (signed word~) plot::$4 ← (signed word~) plot::$8 << (byte) 6 [ plot::x#8 plot::location#2 plot::$4 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$4 ] { { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$4 ] { { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$4 ] { { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$4 ] { { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$4 ] { { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$4 ] { { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$4 ] { { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$4 ] { { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [62] (byte*) plot::location#3 ← (byte*) plot::location#2 + (signed word~) plot::$4 [ plot::x#8 plot::location#3 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] { { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] { { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] { { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] { { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] { { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] { { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] { { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] { { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [63] (signed byte~) plot::$5 ← (signed word) plot::x#8 & (signed byte) 7 [ plot::location#3 plot::$5 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$5 ] { { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$5 ] { { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$5 ] { { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$5 ] { { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$5 ] { { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$5 ] { { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$5 ] { { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$5 ] { { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [64] (byte~) plot::$6 ← *((byte*) plot::location#3) | *((const byte*) bitmask + (signed byte~) plot::$5) [ plot::location#3 plot::$6 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$6 ] { { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$6 ] { { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$6 ] { { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$6 ] { { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$6 ] { { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$6 ] { { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$6 ] { { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$6 ] { { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a reg byte y 
+Statement [65] *((byte*) plot::location#3) ← (byte~) plot::$6 [ ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 ] { { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 ] { { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 ] { { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 ] { { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 ] { { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 ] { { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 ] { { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 ] { { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte y 
+Statement [68] (byte*) fill::end#0 ← (byte*) fill::addr#0 + (signed word) fill::size#2 [ fill::addr#0 fill::val#4 fill::end#0 ] ( main:2::fill:5 [ fill::addr#0 fill::val#4 fill::end#0 ] { }  main:2::fill:7 [ fill::addr#0 fill::val#4 fill::end#0 ] { }  ) always clobbers reg byte a 
 Removing always clobbered register reg byte a as potential for zp[1]:14 [ fill::val#4 ]
-Statement [70] if((byte*) fill::addr#2!=(byte*) fill::end#0) goto fill::@2 [ fill::val#4 fill::end#0 fill::addr#2 ] ( main:2::fill:5 [ fill::val#4 fill::end#0 fill::addr#2 ] main:2::fill:7 [ fill::val#4 fill::end#0 fill::addr#2 ] ) always clobbers reg byte a 
-Statement [72] *((byte*) fill::addr#2) ← (byte) fill::val#4 [ fill::val#4 fill::end#0 fill::addr#2 ] ( main:2::fill:5 [ fill::val#4 fill::end#0 fill::addr#2 ] main:2::fill:7 [ fill::val#4 fill::end#0 fill::addr#2 ] ) always clobbers reg byte a reg byte y 
+Statement [70] if((byte*) fill::addr#2!=(byte*) fill::end#0) goto fill::@2 [ fill::val#4 fill::end#0 fill::addr#2 ] ( main:2::fill:5 [ fill::val#4 fill::end#0 fill::addr#2 ] { }  main:2::fill:7 [ fill::val#4 fill::end#0 fill::addr#2 ] { }  ) always clobbers reg byte a 
+Statement [72] *((byte*) fill::addr#2) ← (byte) fill::val#4 [ fill::val#4 fill::end#0 fill::addr#2 ] ( main:2::fill:5 [ fill::val#4 fill::end#0 fill::addr#2 ] { }  main:2::fill:7 [ fill::val#4 fill::end#0 fill::addr#2 ] { }  ) always clobbers reg byte a reg byte y 
 Removing always clobbered register reg byte y as potential for zp[1]:14 [ fill::val#4 ]
-Statement [8] *((const byte*) BORDERCOL) ← (const byte) BLUE [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [9] *((const byte*) D011) ← (const byte) VIC_BMM|(const byte) VIC_DEN|(const byte) VIC_RSEL|(byte) 3 [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [10] *((const byte*) VIC_MEMORY) ← (byte)(word)(const byte*) SCREEN&(word) $3fff/(byte) $40|(word)(const byte*) BITMAP&(word) $3fff/(word) $400 [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [15] if((signed word) circle::x1#10<=(signed word) circle::y#13) goto circle::@2 [ circle::x1#10 circle::y#13 circle::p#3 ] ( main:2::circle:11 [ circle::x1#10 circle::y#13 circle::p#3 ] ) always clobbers reg byte a 
-Statement [17] if((signed word) circle::p#3<(signed byte) 0) goto circle::@3 [ circle::x1#10 circle::y#13 circle::p#3 ] ( main:2::circle:11 [ circle::x1#10 circle::y#13 circle::p#3 ] ) always clobbers reg byte a 
-Statement [18] (signed word) circle::y#1 ← (signed word) circle::y#13 - (signed byte) 1 [ circle::x1#10 circle::p#3 circle::y#1 ] ( main:2::circle:11 [ circle::x1#10 circle::p#3 circle::y#1 ] ) always clobbers reg byte a 
-Statement [19] (signed word~) circle::$5 ← (signed word) circle::x1#10 - (signed word) circle::y#1 [ circle::x1#10 circle::p#3 circle::y#1 circle::$5 ] ( main:2::circle:11 [ circle::x1#10 circle::p#3 circle::y#1 circle::$5 ] ) always clobbers reg byte a 
-Statement [20] (signed word~) circle::$6 ← (signed word~) circle::$5 << (signed byte) 2 [ circle::x1#10 circle::p#3 circle::y#1 circle::$6 ] ( main:2::circle:11 [ circle::x1#10 circle::p#3 circle::y#1 circle::$6 ] ) always clobbers reg byte a 
-Statement [21] (signed word~) circle::$7 ← (signed word) circle::p#3 + (signed word~) circle::$6 [ circle::x1#10 circle::y#1 circle::$7 ] ( main:2::circle:11 [ circle::x1#10 circle::y#1 circle::$7 ] ) always clobbers reg byte a 
-Statement [22] (signed word) circle::p#2 ← (signed word~) circle::$7 + (signed byte) $a [ circle::x1#10 circle::y#1 circle::p#2 ] ( main:2::circle:11 [ circle::x1#10 circle::y#1 circle::p#2 ] ) always clobbers reg byte a 
-Statement [24] (signed word) plot::x#0 ← (const signed word) circle::xc#0 + (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#0 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#0 ] ) always clobbers reg byte a 
-Statement [25] (signed word) plot::y#0 ← (const signed word) circle::yc#0 - (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#0 plot::y#0 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#0 plot::y#0 ] ) always clobbers reg byte a 
-Statement [27] (signed word) plot::x#1 ← (const signed word) circle::xc#0 - (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#1 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#1 ] ) always clobbers reg byte a 
-Statement [28] (signed word) plot::y#1 ← (const signed word) circle::yc#0 - (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#1 plot::y#1 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#1 plot::y#1 ] ) always clobbers reg byte a 
-Statement [30] (signed word) plot::x#2 ← (const signed word) circle::xc#0 + (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#2 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#2 ] ) always clobbers reg byte a 
-Statement [31] (signed word) plot::y#2 ← (const signed word) circle::yc#0 + (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#2 plot::y#2 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#2 plot::y#2 ] ) always clobbers reg byte a 
-Statement [33] (signed word) plot::x#3 ← (const signed word) circle::xc#0 - (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#3 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#3 ] ) always clobbers reg byte a 
-Statement [34] (signed word) plot::y#3 ← (const signed word) circle::yc#0 + (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#3 plot::y#3 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#3 plot::y#3 ] ) always clobbers reg byte a 
-Statement [36] (signed word) plot::x#4 ← (const signed word) circle::xc#0 + (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#4 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#4 ] ) always clobbers reg byte a 
-Statement [37] (signed word) plot::y#4 ← (const signed word) circle::yc#0 - (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#4 plot::y#4 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#4 plot::y#4 ] ) always clobbers reg byte a 
-Statement [39] (signed word) plot::x#5 ← (const signed word) circle::xc#0 - (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#5 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#5 ] ) always clobbers reg byte a 
-Statement [40] (signed word) plot::y#5 ← (const signed word) circle::yc#0 - (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#5 plot::y#5 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#5 plot::y#5 ] ) always clobbers reg byte a 
-Statement [42] (signed word) plot::x#6 ← (const signed word) circle::xc#0 + (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#6 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#6 ] ) always clobbers reg byte a 
-Statement [43] (signed word) plot::y#6 ← (const signed word) circle::yc#0 + (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#6 plot::y#6 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#6 plot::y#6 ] ) always clobbers reg byte a 
-Statement [45] (signed word) plot::x#7 ← (const signed word) circle::xc#0 - (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#7 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#7 ] ) always clobbers reg byte a 
-Statement [46] (signed word) plot::y#7 ← (const signed word) circle::yc#0 + (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#7 plot::y#7 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#7 plot::y#7 ] ) always clobbers reg byte a 
-Statement [49] (signed word~) circle::$9 ← (signed word) circle::x1#10 << (signed byte) 2 [ circle::x1#10 circle::y#13 circle::p#3 circle::$9 ] ( main:2::circle:11 [ circle::x1#10 circle::y#13 circle::p#3 circle::$9 ] ) always clobbers reg byte a 
-Statement [50] (signed word~) circle::$10 ← (signed word) circle::p#3 + (signed word~) circle::$9 [ circle::x1#10 circle::y#13 circle::$10 ] ( main:2::circle:11 [ circle::x1#10 circle::y#13 circle::$10 ] ) always clobbers reg byte a 
-Statement [51] (signed word) circle::p#1 ← (signed word~) circle::$10 + (signed byte) 6 [ circle::x1#10 circle::y#13 circle::p#1 ] ( main:2::circle:11 [ circle::x1#10 circle::y#13 circle::p#1 ] ) always clobbers reg byte a 
-Statement [53] (signed word~) plot::$0 ← (signed word) plot::x#8 & (signed dword) $fff8 [ plot::x#8 plot::y#8 plot::$0 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$0 ] main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$0 ] main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$0 ] main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$0 ] main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$0 ] main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$0 ] main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$0 ] main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$0 ] ) always clobbers reg byte a 
-Statement [54] (byte*) plot::location#1 ← (const byte*) BITMAP + (signed word~) plot::$0 [ plot::x#8 plot::y#8 plot::location#1 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] ) always clobbers reg byte a 
-Statement [55] (byte~) plot::$1 ← < (signed word) plot::y#8 [ plot::x#8 plot::y#8 plot::location#1 plot::$1 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 plot::$1 ] main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 plot::$1 ] main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 plot::$1 ] main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 plot::$1 ] main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 plot::$1 ] main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 plot::$1 ] main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 plot::$1 ] main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 plot::$1 ] ) always clobbers reg byte a 
-Statement [57] (byte*) plot::location#2 ← (byte*) plot::location#1 + (byte~) plot::$2 [ plot::x#8 plot::y#8 plot::location#2 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] ) always clobbers reg byte a 
-Statement [58] (signed word~) plot::$3 ← (signed word) plot::y#8 >> (signed byte) 3 [ plot::x#8 plot::location#2 plot::$3 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 ] main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 ] main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 ] main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 ] main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 ] main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 ] main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 ] main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 ] ) always clobbers reg byte a 
-Statement [59] (signed word~) plot::$7 ← (signed word~) plot::$3 << (byte) 2 [ plot::x#8 plot::location#2 plot::$3 plot::$7 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 plot::$7 ] main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 plot::$7 ] main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 plot::$7 ] main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 plot::$7 ] main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 plot::$7 ] main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 plot::$7 ] main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 plot::$7 ] main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 plot::$7 ] ) always clobbers reg byte a 
-Statement [60] (signed word~) plot::$8 ← (signed word~) plot::$7 + (signed word~) plot::$3 [ plot::x#8 plot::location#2 plot::$8 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$8 ] main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$8 ] main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$8 ] main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$8 ] main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$8 ] main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$8 ] main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$8 ] main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$8 ] ) always clobbers reg byte a 
-Statement [61] (signed word~) plot::$4 ← (signed word~) plot::$8 << (byte) 6 [ plot::x#8 plot::location#2 plot::$4 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$4 ] main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$4 ] main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$4 ] main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$4 ] main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$4 ] main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$4 ] main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$4 ] main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$4 ] ) always clobbers reg byte a 
-Statement [62] (byte*) plot::location#3 ← (byte*) plot::location#2 + (signed word~) plot::$4 [ plot::x#8 plot::location#3 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] ) always clobbers reg byte a 
-Statement [63] (signed byte~) plot::$5 ← (signed word) plot::x#8 & (signed byte) 7 [ plot::location#3 plot::$5 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$5 ] main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$5 ] main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$5 ] main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$5 ] main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$5 ] main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$5 ] main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$5 ] main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$5 ] ) always clobbers reg byte a 
-Statement [64] (byte~) plot::$6 ← *((byte*) plot::location#3) | *((const byte*) bitmask + (signed byte~) plot::$5) [ plot::location#3 plot::$6 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$6 ] main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$6 ] main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$6 ] main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$6 ] main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$6 ] main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$6 ] main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$6 ] main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$6 ] ) always clobbers reg byte a reg byte y 
-Statement [65] *((byte*) plot::location#3) ← (byte~) plot::$6 [ ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 ] main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 ] main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 ] main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 ] main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 ] main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 ] main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 ] main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 ] ) always clobbers reg byte y 
-Statement [68] (byte*) fill::end#0 ← (byte*) fill::addr#0 + (signed word) fill::size#2 [ fill::addr#0 fill::val#4 fill::end#0 ] ( main:2::fill:5 [ fill::addr#0 fill::val#4 fill::end#0 ] main:2::fill:7 [ fill::addr#0 fill::val#4 fill::end#0 ] ) always clobbers reg byte a 
-Statement [70] if((byte*) fill::addr#2!=(byte*) fill::end#0) goto fill::@2 [ fill::val#4 fill::end#0 fill::addr#2 ] ( main:2::fill:5 [ fill::val#4 fill::end#0 fill::addr#2 ] main:2::fill:7 [ fill::val#4 fill::end#0 fill::addr#2 ] ) always clobbers reg byte a 
-Statement [72] *((byte*) fill::addr#2) ← (byte) fill::val#4 [ fill::val#4 fill::end#0 fill::addr#2 ] ( main:2::fill:5 [ fill::val#4 fill::end#0 fill::addr#2 ] main:2::fill:7 [ fill::val#4 fill::end#0 fill::addr#2 ] ) always clobbers reg byte a reg byte y 
+Statement [8] *((const byte*) BORDERCOL) ← (const byte) BLUE [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [9] *((const byte*) D011) ← (const byte) VIC_BMM|(const byte) VIC_DEN|(const byte) VIC_RSEL|(byte) 3 [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [10] *((const byte*) VIC_MEMORY) ← (byte)(word)(const byte*) SCREEN&(word) $3fff/(byte) $40|(word)(const byte*) BITMAP&(word) $3fff/(word) $400 [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [15] if((signed word) circle::x1#10<=(signed word) circle::y#13) goto circle::@2 [ circle::x1#10 circle::y#13 circle::p#3 ] ( main:2::circle:11 [ circle::x1#10 circle::y#13 circle::p#3 ] { }  ) always clobbers reg byte a 
+Statement [17] if((signed word) circle::p#3<(signed byte) 0) goto circle::@3 [ circle::x1#10 circle::y#13 circle::p#3 ] ( main:2::circle:11 [ circle::x1#10 circle::y#13 circle::p#3 ] { }  ) always clobbers reg byte a 
+Statement [18] (signed word) circle::y#1 ← (signed word) circle::y#13 - (signed byte) 1 [ circle::x1#10 circle::p#3 circle::y#1 ] ( main:2::circle:11 [ circle::x1#10 circle::p#3 circle::y#1 ] { }  ) always clobbers reg byte a 
+Statement [19] (signed word~) circle::$5 ← (signed word) circle::x1#10 - (signed word) circle::y#1 [ circle::x1#10 circle::p#3 circle::y#1 circle::$5 ] ( main:2::circle:11 [ circle::x1#10 circle::p#3 circle::y#1 circle::$5 ] { }  ) always clobbers reg byte a 
+Statement [20] (signed word~) circle::$6 ← (signed word~) circle::$5 << (signed byte) 2 [ circle::x1#10 circle::p#3 circle::y#1 circle::$6 ] ( main:2::circle:11 [ circle::x1#10 circle::p#3 circle::y#1 circle::$6 ] { }  ) always clobbers reg byte a 
+Statement [21] (signed word~) circle::$7 ← (signed word) circle::p#3 + (signed word~) circle::$6 [ circle::x1#10 circle::y#1 circle::$7 ] ( main:2::circle:11 [ circle::x1#10 circle::y#1 circle::$7 ] { }  ) always clobbers reg byte a 
+Statement [22] (signed word) circle::p#2 ← (signed word~) circle::$7 + (signed byte) $a [ circle::x1#10 circle::y#1 circle::p#2 ] ( main:2::circle:11 [ circle::x1#10 circle::y#1 circle::p#2 ] { }  ) always clobbers reg byte a 
+Statement [24] (signed word) plot::x#0 ← (const signed word) circle::xc#0 + (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#0 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#0 ] { { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [25] (signed word) plot::y#0 ← (const signed word) circle::yc#0 - (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#0 plot::y#0 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#0 plot::y#0 ] { { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [27] (signed word) plot::x#1 ← (const signed word) circle::xc#0 - (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#1 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#1 ] { { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [28] (signed word) plot::y#1 ← (const signed word) circle::yc#0 - (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#1 plot::y#1 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#1 plot::y#1 ] { { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [30] (signed word) plot::x#2 ← (const signed word) circle::xc#0 + (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#2 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#2 ] { { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [31] (signed word) plot::y#2 ← (const signed word) circle::yc#0 + (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#2 plot::y#2 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#2 plot::y#2 ] { { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [33] (signed word) plot::x#3 ← (const signed word) circle::xc#0 - (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#3 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#3 ] { { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [34] (signed word) plot::y#3 ← (const signed word) circle::yc#0 + (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#3 plot::y#3 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#3 plot::y#3 ] { { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [36] (signed word) plot::x#4 ← (const signed word) circle::xc#0 + (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#4 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#4 ] { { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [37] (signed word) plot::y#4 ← (const signed word) circle::yc#0 - (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#4 plot::y#4 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#4 plot::y#4 ] { { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [39] (signed word) plot::x#5 ← (const signed word) circle::xc#0 - (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#5 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#5 ] { { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [40] (signed word) plot::y#5 ← (const signed word) circle::yc#0 - (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#5 plot::y#5 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#5 plot::y#5 ] { { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [42] (signed word) plot::x#6 ← (const signed word) circle::xc#0 + (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#6 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#6 ] { { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [43] (signed word) plot::y#6 ← (const signed word) circle::yc#0 + (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#6 plot::y#6 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#6 plot::y#6 ] { { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [45] (signed word) plot::x#7 ← (const signed word) circle::xc#0 - (signed word) circle::y#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#7 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#7 ] { { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [46] (signed word) plot::y#7 ← (const signed word) circle::yc#0 + (signed word) circle::x1#10 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#7 plot::y#7 ] ( main:2::circle:11 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#7 plot::y#7 ] { { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [49] (signed word~) circle::$9 ← (signed word) circle::x1#10 << (signed byte) 2 [ circle::x1#10 circle::y#13 circle::p#3 circle::$9 ] ( main:2::circle:11 [ circle::x1#10 circle::y#13 circle::p#3 circle::$9 ] { }  ) always clobbers reg byte a 
+Statement [50] (signed word~) circle::$10 ← (signed word) circle::p#3 + (signed word~) circle::$9 [ circle::x1#10 circle::y#13 circle::$10 ] ( main:2::circle:11 [ circle::x1#10 circle::y#13 circle::$10 ] { }  ) always clobbers reg byte a 
+Statement [51] (signed word) circle::p#1 ← (signed word~) circle::$10 + (signed byte) 6 [ circle::x1#10 circle::y#13 circle::p#1 ] ( main:2::circle:11 [ circle::x1#10 circle::y#13 circle::p#1 ] { }  ) always clobbers reg byte a 
+Statement [53] (signed word~) plot::$0 ← (signed word) plot::x#8 & (signed dword) $fff8 [ plot::x#8 plot::y#8 plot::$0 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$0 ] { { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$0 ] { { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$0 ] { { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$0 ] { { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$0 ] { { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$0 ] { { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$0 ] { { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::$0 ] { { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [54] (byte*) plot::location#1 ← (const byte*) BITMAP + (signed word~) plot::$0 [ plot::x#8 plot::y#8 plot::location#1 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] { { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] { { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] { { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] { { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] { { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] { { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] { { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#1 ] { { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [57] (byte*) plot::location#2 ← (byte*) plot::location#1 + (byte~) plot::$2 [ plot::x#8 plot::y#8 plot::location#2 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] { { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] { { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] { { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] { { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] { { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] { { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] { { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::y#8 plot::location#2 ] { { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [58] (signed word~) plot::$3 ← (signed word) plot::y#8 >> (signed byte) 3 [ plot::x#8 plot::location#2 plot::$3 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 ] { { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 ] { { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 ] { { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 ] { { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 ] { { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 ] { { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 ] { { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 ] { { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [59] (signed word~) plot::$7 ← (signed word~) plot::$3 << (byte) 2 [ plot::x#8 plot::location#2 plot::$3 plot::$7 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 plot::$7 ] { { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 plot::$7 ] { { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 plot::$7 ] { { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 plot::$7 ] { { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 plot::$7 ] { { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 plot::$7 ] { { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 plot::$7 ] { { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$3 plot::$7 ] { { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [60] (signed word~) plot::$8 ← (signed word~) plot::$7 + (signed word~) plot::$3 [ plot::x#8 plot::location#2 plot::$8 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$8 ] { { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$8 ] { { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$8 ] { { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$8 ] { { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$8 ] { { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$8 ] { { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$8 ] { { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$8 ] { { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [61] (signed word~) plot::$4 ← (signed word~) plot::$8 << (byte) 6 [ plot::x#8 plot::location#2 plot::$4 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$4 ] { { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$4 ] { { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$4 ] { { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$4 ] { { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$4 ] { { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$4 ] { { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$4 ] { { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#2 plot::$4 ] { { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [62] (byte*) plot::location#3 ← (byte*) plot::location#2 + (signed word~) plot::$4 [ plot::x#8 plot::location#3 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] { { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] { { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] { { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] { { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] { { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] { { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] { { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::x#8 plot::location#3 ] { { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [63] (signed byte~) plot::$5 ← (signed word) plot::x#8 & (signed byte) 7 [ plot::location#3 plot::$5 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$5 ] { { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$5 ] { { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$5 ] { { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$5 ] { { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$5 ] { { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$5 ] { { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$5 ] { { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$5 ] { { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a 
+Statement [64] (byte~) plot::$6 ← *((byte*) plot::location#3) | *((const byte*) bitmask + (signed byte~) plot::$5) [ plot::location#3 plot::$6 ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$6 ] { { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$6 ] { { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$6 ] { { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$6 ] { { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$6 ] { { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$6 ] { { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$6 ] { { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 plot::location#3 plot::$6 ] { { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte a reg byte y 
+Statement [65] *((byte*) plot::location#3) ← (byte~) plot::$6 [ ] ( main:2::circle:11::plot:26 [ circle::x1#10 circle::y#10 circle::p#10 ] { { plot::x#0 = plot::x#8 } { plot::y#0 = plot::y#8 } }  main:2::circle:11::plot:29 [ circle::x1#10 circle::y#10 circle::p#10 ] { { plot::x#1 = plot::x#8 } { plot::y#1 = plot::y#8 } }  main:2::circle:11::plot:32 [ circle::x1#10 circle::y#10 circle::p#10 ] { { plot::x#2 = plot::x#8 } { plot::y#2 = plot::y#8 } }  main:2::circle:11::plot:35 [ circle::x1#10 circle::y#10 circle::p#10 ] { { plot::x#3 = plot::x#8 } { plot::y#3 = plot::y#8 } }  main:2::circle:11::plot:38 [ circle::x1#10 circle::y#10 circle::p#10 ] { { plot::x#4 = plot::x#8 } { plot::y#4 = plot::y#8 } }  main:2::circle:11::plot:41 [ circle::x1#10 circle::y#10 circle::p#10 ] { { plot::x#5 = plot::x#8 } { plot::y#5 = plot::y#8 } }  main:2::circle:11::plot:44 [ circle::x1#10 circle::y#10 circle::p#10 ] { { plot::x#6 = plot::x#8 } { plot::y#6 = plot::y#8 } }  main:2::circle:11::plot:47 [ circle::x1#10 circle::y#10 circle::p#10 ] { { plot::x#7 = plot::x#8 } { plot::y#7 = plot::y#8 } }  ) always clobbers reg byte y 
+Statement [68] (byte*) fill::end#0 ← (byte*) fill::addr#0 + (signed word) fill::size#2 [ fill::addr#0 fill::val#4 fill::end#0 ] ( main:2::fill:5 [ fill::addr#0 fill::val#4 fill::end#0 ] { }  main:2::fill:7 [ fill::addr#0 fill::val#4 fill::end#0 ] { }  ) always clobbers reg byte a 
+Statement [70] if((byte*) fill::addr#2!=(byte*) fill::end#0) goto fill::@2 [ fill::val#4 fill::end#0 fill::addr#2 ] ( main:2::fill:5 [ fill::val#4 fill::end#0 fill::addr#2 ] { }  main:2::fill:7 [ fill::val#4 fill::end#0 fill::addr#2 ] { }  ) always clobbers reg byte a 
+Statement [72] *((byte*) fill::addr#2) ← (byte) fill::val#4 [ fill::val#4 fill::end#0 fill::addr#2 ] ( main:2::fill:5 [ fill::val#4 fill::end#0 fill::addr#2 ] { }  main:2::fill:7 [ fill::val#4 fill::end#0 fill::addr#2 ] { }  ) always clobbers reg byte a reg byte y 
 Potential registers zp[2]:2 [ circle::x1#10 circle::x1#1 ] : zp[2]:2 , 
 Potential registers zp[2]:4 [ circle::y#13 circle::y#10 circle::y#1 ] : zp[2]:4 , 
 Potential registers zp[2]:6 [ circle::p#3 circle::p#10 circle::p#1 circle::p#2 ] : zp[2]:6 , 
@@ -1791,16 +1789,16 @@ Potential registers zp[1]:46 [ plot::$6 ] : zp[1]:46 , reg byte a , reg byte x ,
 Potential registers zp[2]:47 [ fill::end#0 ] : zp[2]:47 , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [plot] 191.33: zp[2]:10 [ plot::y#8 plot::y#1 plot::y#2 plot::y#3 plot::y#4 plot::y#5 plot::y#6 plot::y#7 plot::y#0 ] 96.36: zp[2]:8 [ plot::x#8 plot::x#1 plot::x#2 plot::x#3 plot::x#4 plot::x#5 plot::x#6 plot::x#7 plot::x#0 ] 4: zp[2]:27 [ plot::$0 ] 4: zp[1]:31 [ plot::$1 ] 4: zp[1]:32 [ plot::$2 ] 4: zp[2]:37 [ plot::$7 ] 4: zp[2]:39 [ plot::$8 ] 4: zp[2]:41 [ plot::$4 ] 4: zp[1]:45 [ plot::$5 ] 4: zp[1]:46 [ plot::$6 ] 3: zp[2]:35 [ plot::$3 ] 2: zp[2]:43 [ plot::location#3 ] 1.33: zp[2]:29 [ plot::location#1 ] 0.8: zp[2]:33 [ plot::location#2 ] 
-Uplift Scope [circle] 51.55: zp[2]:6 [ circle::p#3 circle::p#10 circle::p#1 circle::p#2 ] 25.97: zp[2]:2 [ circle::x1#10 circle::x1#1 ] 22: zp[2]:17 [ circle::$5 ] 22: zp[2]:19 [ circle::$6 ] 22: zp[2]:21 [ circle::$7 ] 22: zp[2]:23 [ circle::$9 ] 22: zp[2]:25 [ circle::$10 ] 18.59: zp[2]:4 [ circle::y#13 circle::y#10 circle::y#1 ] 
-Uplift Scope [fill] 39.33: zp[2]:15 [ fill::addr#2 fill::addr#0 fill::addr#1 ] 2.6: zp[2]:47 [ fill::end#0 ] 2: zp[2]:12 [ fill::size#2 ] 1.83: zp[1]:14 [ fill::val#4 ] 
+Uplift Scope [plot] 20,684.33: zp[2]:10 [ plot::y#8 plot::y#1 plot::y#2 plot::y#3 plot::y#4 plot::y#5 plot::y#6 plot::y#7 plot::y#0 ] 20,002: zp[2]:27 [ plot::$0 ] 20,002: zp[1]:31 [ plot::$1 ] 20,002: zp[1]:32 [ plot::$2 ] 20,002: zp[2]:37 [ plot::$7 ] 20,002: zp[2]:39 [ plot::$8 ] 20,002: zp[2]:41 [ plot::$4 ] 20,002: zp[1]:45 [ plot::$5 ] 20,002: zp[1]:46 [ plot::$6 ] 15,001.5: zp[2]:35 [ plot::$3 ] 10,554.36: zp[2]:8 [ plot::x#8 plot::x#1 plot::x#2 plot::x#3 plot::x#4 plot::x#5 plot::x#6 plot::x#7 plot::x#0 ] 10,001: zp[2]:43 [ plot::location#3 ] 6,667.33: zp[2]:29 [ plot::location#1 ] 4,000.4: zp[2]:33 [ plot::location#2 ] 
+Uplift Scope [circle] 4,691.5: zp[2]:6 [ circle::p#3 circle::p#10 circle::p#1 circle::p#2 ] 2,363.47: zp[2]:2 [ circle::x1#10 circle::x1#1 ] 2,002: zp[2]:17 [ circle::$5 ] 2,002: zp[2]:19 [ circle::$6 ] 2,002: zp[2]:21 [ circle::$7 ] 2,002: zp[2]:23 [ circle::$9 ] 2,002: zp[2]:25 [ circle::$10 ] 1,691.43: zp[2]:4 [ circle::y#13 circle::y#10 circle::y#1 ] 
+Uplift Scope [fill] 3,471.33: zp[2]:15 [ fill::addr#2 fill::addr#0 fill::addr#1 ] 220.4: zp[2]:47 [ fill::end#0 ] 166.83: zp[1]:14 [ fill::val#4 ] 101: zp[2]:12 [ fill::size#2 ] 
 Uplift Scope [main] 
 Uplift Scope [] 
 
-Uplifting [plot] best 6419 combination zp[2]:10 [ plot::y#8 plot::y#1 plot::y#2 plot::y#3 plot::y#4 plot::y#5 plot::y#6 plot::y#7 plot::y#0 ] zp[2]:8 [ plot::x#8 plot::x#1 plot::x#2 plot::x#3 plot::x#4 plot::x#5 plot::x#6 plot::x#7 plot::x#0 ] zp[2]:27 [ plot::$0 ] reg byte a [ plot::$1 ] reg byte a [ plot::$2 ] zp[2]:37 [ plot::$7 ] zp[2]:39 [ plot::$8 ] zp[2]:41 [ plot::$4 ] reg byte a [ plot::$5 ] reg byte a [ plot::$6 ] zp[2]:35 [ plot::$3 ] zp[2]:43 [ plot::location#3 ] zp[2]:29 [ plot::location#1 ] zp[2]:33 [ plot::location#2 ] 
+Uplifting [plot] best 6419 combination zp[2]:10 [ plot::y#8 plot::y#1 plot::y#2 plot::y#3 plot::y#4 plot::y#5 plot::y#6 plot::y#7 plot::y#0 ] zp[2]:27 [ plot::$0 ] reg byte a [ plot::$1 ] reg byte a [ plot::$2 ] zp[2]:37 [ plot::$7 ] zp[2]:39 [ plot::$8 ] zp[2]:41 [ plot::$4 ] reg byte a [ plot::$5 ] reg byte a [ plot::$6 ] zp[2]:35 [ plot::$3 ] zp[2]:8 [ plot::x#8 plot::x#1 plot::x#2 plot::x#3 plot::x#4 plot::x#5 plot::x#6 plot::x#7 plot::x#0 ] zp[2]:43 [ plot::location#3 ] zp[2]:29 [ plot::location#1 ] zp[2]:33 [ plot::location#2 ] 
 Limited combination testing to 100 combinations of 256 possible.
 Uplifting [circle] best 6419 combination zp[2]:6 [ circle::p#3 circle::p#10 circle::p#1 circle::p#2 ] zp[2]:2 [ circle::x1#10 circle::x1#1 ] zp[2]:17 [ circle::$5 ] zp[2]:19 [ circle::$6 ] zp[2]:21 [ circle::$7 ] zp[2]:23 [ circle::$9 ] zp[2]:25 [ circle::$10 ] zp[2]:4 [ circle::y#13 circle::y#10 circle::y#1 ] 
-Uplifting [fill] best 6403 combination zp[2]:15 [ fill::addr#2 fill::addr#0 fill::addr#1 ] zp[2]:47 [ fill::end#0 ] zp[2]:12 [ fill::size#2 ] reg byte x [ fill::val#4 ] 
+Uplifting [fill] best 6403 combination zp[2]:15 [ fill::addr#2 fill::addr#0 fill::addr#1 ] zp[2]:47 [ fill::end#0 ] reg byte x [ fill::val#4 ] zp[2]:12 [ fill::size#2 ] 
 Uplifting [main] best 6403 combination 
 Uplifting [] best 6403 combination 
 Coalescing zero page register [ zp[2]:6 [ circle::p#3 circle::p#10 circle::p#1 circle::p#2 ] ] with [ zp[2]:21 [ circle::$7 ] ] - score: 2
@@ -2509,11 +2507,11 @@ FINAL SYMBOL TABLE
 (const byte) VIC_RSEL = (byte) 8
 (const byte*) bitmask[]  = { (byte) $80, (byte) $40, (byte) $20, (byte) $10, (byte) 8, (byte) 4, (byte) 2, (byte) 1 }
 (void()) circle((signed word) circle::xc , (signed word) circle::yc , (signed word) circle::r)
-(signed word~) circle::$10 zp[2]:2 22.0
-(signed word~) circle::$5 zp[2]:8 22.0
-(signed word~) circle::$6 zp[2]:8 22.0
-(signed word~) circle::$7 zp[2]:2 22.0
-(signed word~) circle::$9 zp[2]:10 22.0
+(signed word~) circle::$10 zp[2]:2 2002.0
+(signed word~) circle::$5 zp[2]:8 2002.0
+(signed word~) circle::$6 zp[2]:8 2002.0
+(signed word~) circle::$7 zp[2]:2 2002.0
+(signed word~) circle::$9 zp[2]:10 2002.0
 (label) circle::@1
 (label) circle::@10
 (label) circle::@11
@@ -2529,21 +2527,21 @@ FINAL SYMBOL TABLE
 (label) circle::@9
 (label) circle::@return
 (signed word) circle::p
-(signed word) circle::p#1 p zp[2]:2 22.0
-(signed word) circle::p#10 p zp[2]:2 1.2692307692307692
-(signed word) circle::p#2 p zp[2]:2 22.0
-(signed word) circle::p#3 p zp[2]:2 6.285714285714286
+(signed word) circle::p#1 p zp[2]:2 2002.0
+(signed word) circle::p#10 p zp[2]:2 115.5
+(signed word) circle::p#2 p zp[2]:2 2002.0
+(signed word) circle::p#3 p zp[2]:2 572.0
 (signed word) circle::r
 (const signed word) circle::r#0 r = (signed byte) $32
 (signed word) circle::x1
-(signed word) circle::x1#1 x1 zp[2]:4 22.0
-(signed word) circle::x1#10 x1 zp[2]:4 3.9722222222222214
+(signed word) circle::x1#1 x1 zp[2]:4 2002.0
+(signed word) circle::x1#10 x1 zp[2]:4 361.4722222222221
 (signed word) circle::xc
 (const signed word) circle::xc#0 xc = (signed byte) $64
 (signed word) circle::y
-(signed word) circle::y#1 y zp[2]:6 6.6000000000000005
-(signed word) circle::y#10 y zp[2]:6 4.653846153846153
-(signed word) circle::y#13 y zp[2]:6 7.333333333333333
+(signed word) circle::y#1 y zp[2]:6 600.5999999999999
+(signed word) circle::y#10 y zp[2]:6 423.5
+(signed word) circle::y#13 y zp[2]:6 667.3333333333334
 (signed word) circle::yc
 (const signed word) circle::yc#0 yc = (signed byte) $64
 (void()) fill((byte*) fill::start , (signed word) fill::size , (byte) fill::val)
@@ -2551,55 +2549,55 @@ FINAL SYMBOL TABLE
 (label) fill::@2
 (label) fill::@return
 (byte*) fill::addr
-(byte*) fill::addr#0 addr zp[2]:6 2.0
-(byte*) fill::addr#1 addr zp[2]:6 22.0
-(byte*) fill::addr#2 addr zp[2]:6 15.333333333333332
+(byte*) fill::addr#0 addr zp[2]:6 101.0
+(byte*) fill::addr#1 addr zp[2]:6 2002.0
+(byte*) fill::addr#2 addr zp[2]:6 1368.3333333333335
 (byte*) fill::end
-(byte*) fill::end#0 end zp[2]:4 2.6
+(byte*) fill::end#0 end zp[2]:4 220.39999999999998
 (signed word) fill::size
-(signed word) fill::size#2 size zp[2]:4 2.0
+(signed word) fill::size#2 size zp[2]:4 101.0
 (byte*) fill::start
 (byte) fill::val
-(byte) fill::val#4 reg byte x 1.8333333333333333
+(byte) fill::val#4 reg byte x 166.83333333333334
 (void()) main()
 (label) main::@1
 (label) main::@2
 (label) main::@3
 (void()) plot((signed word) plot::x , (signed word) plot::y)
-(signed word~) plot::$0 zp[2]:12 4.0
-(byte~) plot::$1 reg byte a 4.0
-(byte~) plot::$2 reg byte a 4.0
-(signed word~) plot::$3 zp[2]:10 3.0
-(signed word~) plot::$4 zp[2]:14 4.0
-(signed byte~) plot::$5 reg byte a 4.0
-(byte~) plot::$6 reg byte a 4.0
-(signed word~) plot::$7 zp[2]:14 4.0
-(signed word~) plot::$8 zp[2]:14 4.0
+(signed word~) plot::$0 zp[2]:12 20002.0
+(byte~) plot::$1 reg byte a 20002.0
+(byte~) plot::$2 reg byte a 20002.0
+(signed word~) plot::$3 zp[2]:10 15001.5
+(signed word~) plot::$4 zp[2]:14 20002.0
+(signed byte~) plot::$5 reg byte a 20002.0
+(byte~) plot::$6 reg byte a 20002.0
+(signed word~) plot::$7 zp[2]:14 20002.0
+(signed word~) plot::$8 zp[2]:14 20002.0
 (label) plot::@return
 (byte*) plot::location
-(byte*) plot::location#1 location zp[2]:12 1.3333333333333333
-(byte*) plot::location#2 location zp[2]:12 0.8
-(byte*) plot::location#3 location zp[2]:12 2.0
+(byte*) plot::location#1 location zp[2]:12 6667.333333333333
+(byte*) plot::location#2 location zp[2]:12 4000.4
+(byte*) plot::location#3 location zp[2]:12 10001.0
 (signed word) plot::x
-(signed word) plot::x#0 x zp[2]:8 11.0
-(signed word) plot::x#1 x zp[2]:8 11.0
-(signed word) plot::x#2 x zp[2]:8 11.0
-(signed word) plot::x#3 x zp[2]:8 11.0
-(signed word) plot::x#4 x zp[2]:8 11.0
-(signed word) plot::x#5 x zp[2]:8 11.0
-(signed word) plot::x#6 x zp[2]:8 11.0
-(signed word) plot::x#7 x zp[2]:8 11.0
-(signed word) plot::x#8 x zp[2]:8 8.363636363636363
+(signed word) plot::x#0 x zp[2]:8 1001.0
+(signed word) plot::x#1 x zp[2]:8 1001.0
+(signed word) plot::x#2 x zp[2]:8 1001.0
+(signed word) plot::x#3 x zp[2]:8 1001.0
+(signed word) plot::x#4 x zp[2]:8 1001.0
+(signed word) plot::x#5 x zp[2]:8 1001.0
+(signed word) plot::x#6 x zp[2]:8 1001.0
+(signed word) plot::x#7 x zp[2]:8 1001.0
+(signed word) plot::x#8 x zp[2]:8 2546.363636363636
 (signed word) plot::y
-(signed word) plot::y#0 y zp[2]:10 22.0
-(signed word) plot::y#1 y zp[2]:10 22.0
-(signed word) plot::y#2 y zp[2]:10 22.0
-(signed word) plot::y#3 y zp[2]:10 22.0
-(signed word) plot::y#4 y zp[2]:10 22.0
-(signed word) plot::y#5 y zp[2]:10 22.0
-(signed word) plot::y#6 y zp[2]:10 22.0
-(signed word) plot::y#7 y zp[2]:10 22.0
-(signed word) plot::y#8 y zp[2]:10 15.333333333333336
+(signed word) plot::y#0 y zp[2]:10 2002.0
+(signed word) plot::y#1 y zp[2]:10 2002.0
+(signed word) plot::y#2 y zp[2]:10 2002.0
+(signed word) plot::y#3 y zp[2]:10 2002.0
+(signed word) plot::y#4 y zp[2]:10 2002.0
+(signed word) plot::y#5 y zp[2]:10 2002.0
+(signed word) plot::y#6 y zp[2]:10 2002.0
+(signed word) plot::y#7 y zp[2]:10 2002.0
+(signed word) plot::y#8 y zp[2]:10 4668.333333333333
 
 zp[2]:2 [ circle::p#3 circle::p#10 circle::p#1 circle::p#2 circle::$7 circle::$10 ]
 zp[2]:4 [ fill::size#2 fill::end#0 circle::x1#10 circle::x1#1 ]

src/test/ref/bitmap-circle.sym

@@ -12,11 +12,11 @@
 (const byte) VIC_RSEL = (byte) 8
 (const byte*) bitmask[]  = { (byte) $80, (byte) $40, (byte) $20, (byte) $10, (byte) 8, (byte) 4, (byte) 2, (byte) 1 }
 (void()) circle((signed word) circle::xc , (signed word) circle::yc , (signed word) circle::r)
-(signed word~) circle::$10 zp[2]:2 22.0
-(signed word~) circle::$5 zp[2]:8 22.0
-(signed word~) circle::$6 zp[2]:8 22.0
-(signed word~) circle::$7 zp[2]:2 22.0
-(signed word~) circle::$9 zp[2]:10 22.0
+(signed word~) circle::$10 zp[2]:2 2002.0
+(signed word~) circle::$5 zp[2]:8 2002.0
+(signed word~) circle::$6 zp[2]:8 2002.0
+(signed word~) circle::$7 zp[2]:2 2002.0
+(signed word~) circle::$9 zp[2]:10 2002.0
 (label) circle::@1
 (label) circle::@10
 (label) circle::@11
@@ -32,21 +32,21 @@
 (label) circle::@9
 (label) circle::@return
 (signed word) circle::p
-(signed word) circle::p#1 p zp[2]:2 22.0
-(signed word) circle::p#10 p zp[2]:2 1.2692307692307692
-(signed word) circle::p#2 p zp[2]:2 22.0
-(signed word) circle::p#3 p zp[2]:2 6.285714285714286
+(signed word) circle::p#1 p zp[2]:2 2002.0
+(signed word) circle::p#10 p zp[2]:2 115.5
+(signed word) circle::p#2 p zp[2]:2 2002.0
+(signed word) circle::p#3 p zp[2]:2 572.0
 (signed word) circle::r
 (const signed word) circle::r#0 r = (signed byte) $32
 (signed word) circle::x1
-(signed word) circle::x1#1 x1 zp[2]:4 22.0
-(signed word) circle::x1#10 x1 zp[2]:4 3.9722222222222214
+(signed word) circle::x1#1 x1 zp[2]:4 2002.0
+(signed word) circle::x1#10 x1 zp[2]:4 361.4722222222221
 (signed word) circle::xc
 (const signed word) circle::xc#0 xc = (signed byte) $64
 (signed word) circle::y
-(signed word) circle::y#1 y zp[2]:6 6.6000000000000005
-(signed word) circle::y#10 y zp[2]:6 4.653846153846153
-(signed word) circle::y#13 y zp[2]:6 7.333333333333333
+(signed word) circle::y#1 y zp[2]:6 600.5999999999999
+(signed word) circle::y#10 y zp[2]:6 423.5
+(signed word) circle::y#13 y zp[2]:6 667.3333333333334
 (signed word) circle::yc
 (const signed word) circle::yc#0 yc = (signed byte) $64
 (void()) fill((byte*) fill::start , (signed word) fill::size , (byte) fill::val)
@@ -54,55 +54,55 @@
 (label) fill::@2
 (label) fill::@return
 (byte*) fill::addr
-(byte*) fill::addr#0 addr zp[2]:6 2.0
-(byte*) fill::addr#1 addr zp[2]:6 22.0
-(byte*) fill::addr#2 addr zp[2]:6 15.333333333333332
+(byte*) fill::addr#0 addr zp[2]:6 101.0
+(byte*) fill::addr#1 addr zp[2]:6 2002.0
+(byte*) fill::addr#2 addr zp[2]:6 1368.3333333333335
 (byte*) fill::end
-(byte*) fill::end#0 end zp[2]:4 2.6
+(byte*) fill::end#0 end zp[2]:4 220.39999999999998
 (signed word) fill::size
-(signed word) fill::size#2 size zp[2]:4 2.0
+(signed word) fill::size#2 size zp[2]:4 101.0
 (byte*) fill::start
 (byte) fill::val
-(byte) fill::val#4 reg byte x 1.8333333333333333
+(byte) fill::val#4 reg byte x 166.83333333333334
 (void()) main()
 (label) main::@1
 (label) main::@2
 (label) main::@3
 (void()) plot((signed word) plot::x , (signed word) plot::y)
-(signed word~) plot::$0 zp[2]:12 4.0
-(byte~) plot::$1 reg byte a 4.0
-(byte~) plot::$2 reg byte a 4.0
-(signed word~) plot::$3 zp[2]:10 3.0
-(signed word~) plot::$4 zp[2]:14 4.0
-(signed byte~) plot::$5 reg byte a 4.0
-(byte~) plot::$6 reg byte a 4.0
-(signed word~) plot::$7 zp[2]:14 4.0
-(signed word~) plot::$8 zp[2]:14 4.0
+(signed word~) plot::$0 zp[2]:12 20002.0
+(byte~) plot::$1 reg byte a 20002.0
+(byte~) plot::$2 reg byte a 20002.0
+(signed word~) plot::$3 zp[2]:10 15001.5
+(signed word~) plot::$4 zp[2]:14 20002.0
+(signed byte~) plot::$5 reg byte a 20002.0
+(byte~) plot::$6 reg byte a 20002.0
+(signed word~) plot::$7 zp[2]:14 20002.0
+(signed word~) plot::$8 zp[2]:14 20002.0
 (label) plot::@return
 (byte*) plot::location
-(byte*) plot::location#1 location zp[2]:12 1.3333333333333333
-(byte*) plot::location#2 location zp[2]:12 0.8
-(byte*) plot::location#3 location zp[2]:12 2.0
+(byte*) plot::location#1 location zp[2]:12 6667.333333333333
+(byte*) plot::location#2 location zp[2]:12 4000.4
+(byte*) plot::location#3 location zp[2]:12 10001.0
 (signed word) plot::x
-(signed word) plot::x#0 x zp[2]:8 11.0
-(signed word) plot::x#1 x zp[2]:8 11.0
-(signed word) plot::x#2 x zp[2]:8 11.0
-(signed word) plot::x#3 x zp[2]:8 11.0
-(signed word) plot::x#4 x zp[2]:8 11.0
-(signed word) plot::x#5 x zp[2]:8 11.0
-(signed word) plot::x#6 x zp[2]:8 11.0
-(signed word) plot::x#7 x zp[2]:8 11.0
-(signed word) plot::x#8 x zp[2]:8 8.363636363636363
+(signed word) plot::x#0 x zp[2]:8 1001.0
+(signed word) plot::x#1 x zp[2]:8 1001.0
+(signed word) plot::x#2 x zp[2]:8 1001.0
+(signed word) plot::x#3 x zp[2]:8 1001.0
+(signed word) plot::x#4 x zp[2]:8 1001.0
+(signed word) plot::x#5 x zp[2]:8 1001.0
+(signed word) plot::x#6 x zp[2]:8 1001.0
+(signed word) plot::x#7 x zp[2]:8 1001.0
+(signed word) plot::x#8 x zp[2]:8 2546.363636363636
 (signed word) plot::y
-(signed word) plot::y#0 y zp[2]:10 22.0
-(signed word) plot::y#1 y zp[2]:10 22.0
-(signed word) plot::y#2 y zp[2]:10 22.0
-(signed word) plot::y#3 y zp[2]:10 22.0
-(signed word) plot::y#4 y zp[2]:10 22.0
-(signed word) plot::y#5 y zp[2]:10 22.0
-(signed word) plot::y#6 y zp[2]:10 22.0
-(signed word) plot::y#7 y zp[2]:10 22.0
-(signed word) plot::y#8 y zp[2]:10 15.333333333333336
+(signed word) plot::y#0 y zp[2]:10 2002.0
+(signed word) plot::y#1 y zp[2]:10 2002.0
+(signed word) plot::y#2 y zp[2]:10 2002.0
+(signed word) plot::y#3 y zp[2]:10 2002.0
+(signed word) plot::y#4 y zp[2]:10 2002.0
+(signed word) plot::y#5 y zp[2]:10 2002.0
+(signed word) plot::y#6 y zp[2]:10 2002.0
+(signed word) plot::y#7 y zp[2]:10 2002.0
+(signed word) plot::y#8 y zp[2]:10 4668.333333333333
 
 zp[2]:2 [ circle::p#3 circle::p#10 circle::p#1 circle::p#2 circle::$7 circle::$10 ]
 zp[2]:4 [ fill::size#2 fill::end#0 circle::x1#10 circle::x1#1 ]

src/test/ref/bitmap-line-anim-1.asm

@@ -35,57 +35,57 @@ main: {
     sta.z next
   __b1:
     // bitmap_line(0,next,0,100)
-    ldx.z next
+    lda.z next
     jsr bitmap_line
     // next++;
     inc.z next
     jmp __b1
 }
 // Draw a line on the bitmap
-// bitmap_line(byte register(X) x1)
+// bitmap_line(byte register(A) x1)
 bitmap_line: {
     .label x0 = 0
     .label y0 = 0
     .label y1 = $64
     // if(x0<x1)
-    cpx #x0
+    cmp #x0
     beq !+
     bcs __b1
   !:
     // xd = x0-x1
-    txa
+    tax
     // if(yd<xd)
-    cmp #y1
+    cpx #y1
     beq !+
     bcs __b4
   !:
     // bitmap_line_ydxd(y0, x0, y1, yd, xd)
-    sta.z bitmap_line_ydxd.xd
+    stx.z bitmap_line_ydxd.xd
     jsr bitmap_line_ydxd
     // }
     rts
   __b4:
     // bitmap_line_xdyd(x1, y1, x0, xd, yd)
-    stx.z bitmap_line_xdyd.x
-    sta.z bitmap_line_xdyd.xd
+    sta.z bitmap_line_xdyd.x
+    stx.z bitmap_line_xdyd.xd
     jsr bitmap_line_xdyd
     rts
   __b1:
     // xd = x1-x0
-    txa
+    tax
     // if(yd<xd)
-    cmp #y1
+    cpx #y1
     beq !+
     bcs __b7
   !:
     // bitmap_line_ydxi(y0, x0, y1, yd, xd)
-    sta.z bitmap_line_ydxi.xd
+    stx.z bitmap_line_ydxi.xd
     jsr bitmap_line_ydxi
     rts
   __b7:
     // bitmap_line_xdyi(x0, y0, x1, xd, yd)
-    stx.z bitmap_line_xdyi.x1
-    sta.z bitmap_line_xdyi.xd
+    sta.z bitmap_line_xdyi.x1
+    stx.z bitmap_line_xdyi.xd
     jsr bitmap_line_xdyi
     rts
 }

src/test/ref/bitmap-line-anim-1.sym

@@ -16,23 +16,23 @@
 (label) bitmap_clear::@3
 (label) bitmap_clear::@return
 (byte*) bitmap_clear::bitmap
-(word) bitmap_clear::bitmap#0 bitmap zp[2]:7 2.0
-(byte*) bitmap_clear::bitmap#1 bitmap zp[2]:7 42.599999999999994
-(byte*) bitmap_clear::bitmap#2 bitmap zp[2]:7 157.0
-(byte*) bitmap_clear::bitmap#3 bitmap zp[2]:7 24.0
-(byte*) bitmap_clear::bitmap#5 bitmap zp[2]:7 4.0
+(word) bitmap_clear::bitmap#0 bitmap zp[2]:7 101.0
+(byte*) bitmap_clear::bitmap#1 bitmap zp[2]:7 4200.6
+(byte*) bitmap_clear::bitmap#2 bitmap zp[2]:7 15502.0
+(byte*) bitmap_clear::bitmap#3 bitmap zp[2]:7 2103.0
+(byte*) bitmap_clear::bitmap#5 bitmap zp[2]:7 202.0
 (byte) bitmap_clear::x
-(byte) bitmap_clear::x#1 reg byte x 151.5
-(byte) bitmap_clear::x#2 reg byte x 67.33333333333333
+(byte) bitmap_clear::x#1 reg byte x 15001.5
+(byte) bitmap_clear::x#2 reg byte x 6667.333333333333
 (byte) bitmap_clear::y
-(byte) bitmap_clear::y#1 y zp[1]:6 16.5
-(byte) bitmap_clear::y#4 y zp[1]:6 3.6666666666666665
+(byte) bitmap_clear::y#1 y zp[1]:6 1501.5
+(byte) bitmap_clear::y#4 y zp[1]:6 333.6666666666667
 (void()) bitmap_init((byte*) bitmap_init::bitmap)
-(byte~) bitmap_init::$0 reg byte a 22.0
-(byte~) bitmap_init::$10 zp[1]:11 5.5
-(byte~) bitmap_init::$7 reg byte a 22.0
-(byte~) bitmap_init::$8 reg byte a 22.0
-(byte~) bitmap_init::$9 reg byte a 22.0
+(byte~) bitmap_init::$0 reg byte a 2002.0
+(byte~) bitmap_init::$10 zp[1]:11 500.5
+(byte~) bitmap_init::$7 reg byte a 2002.0
+(byte~) bitmap_init::$8 reg byte a 2002.0
+(byte~) bitmap_init::$9 reg byte a 2002.0
 (label) bitmap_init::@1
 (label) bitmap_init::@2
 (label) bitmap_init::@3
@@ -42,19 +42,19 @@
 (label) bitmap_init::@return
 (byte*) bitmap_init::bitmap
 (byte) bitmap_init::bits
-(byte) bitmap_init::bits#1 reg byte y 11.0
-(byte) bitmap_init::bits#3 reg byte y 6.6000000000000005
-(byte) bitmap_init::bits#4 reg byte y 7.333333333333333
+(byte) bitmap_init::bits#1 reg byte y 1001.0
+(byte) bitmap_init::bits#3 reg byte y 600.5999999999999
+(byte) bitmap_init::bits#4 reg byte y 667.3333333333334
 (byte) bitmap_init::x
-(byte) bitmap_init::x#1 reg byte x 16.5
-(byte) bitmap_init::x#2 reg byte x 7.333333333333334
+(byte) bitmap_init::x#1 reg byte x 1501.5
+(byte) bitmap_init::x#2 reg byte x 667.3333333333333
 (byte) bitmap_init::y
-(byte) bitmap_init::y#1 reg byte x 16.5
-(byte) bitmap_init::y#2 reg byte x 5.5
+(byte) bitmap_init::y#1 reg byte x 1501.5
+(byte) bitmap_init::y#2 reg byte x 500.5
 (byte*) bitmap_init::yoffs
-(byte*) bitmap_init::yoffs#1 yoffs zp[2]:7 22.0
-(byte*) bitmap_init::yoffs#2 yoffs zp[2]:7 6.875
-(byte*) bitmap_init::yoffs#4 yoffs zp[2]:7 11.0
+(byte*) bitmap_init::yoffs#1 yoffs zp[2]:7 2002.0
+(byte*) bitmap_init::yoffs#2 yoffs zp[2]:7 625.625
+(byte*) bitmap_init::yoffs#4 yoffs zp[2]:7 1001.0
 (void()) bitmap_line((byte) bitmap_line::x0 , (byte) bitmap_line::x1 , (byte) bitmap_line::y0 , (byte) bitmap_line::y1)
 (label) bitmap_line::@1
 (label) bitmap_line::@2
@@ -68,10 +68,10 @@
 (byte) bitmap_line::x0
 (const byte) bitmap_line::x0#0 x0 = (byte) 0
 (byte) bitmap_line::x1
-(byte) bitmap_line::x1#0 reg byte x 3.5000000000000004
+(byte) bitmap_line::x1#0 reg byte a 851.0000000000001
 (byte) bitmap_line::xd
-(byte) bitmap_line::xd#1 reg byte a 2.6666666666666665
-(byte) bitmap_line::xd#2 reg byte a 2.6666666666666665
+(byte) bitmap_line::xd#1 reg byte x 1334.6666666666667
+(byte) bitmap_line::xd#2 reg byte x 1334.6666666666667
 (byte) bitmap_line::y0
 (const byte) bitmap_line::y0#0 y0 = (byte) 0
 (byte) bitmap_line::y1
@@ -84,45 +84,45 @@
 (label) bitmap_line_xdyd::@4
 (label) bitmap_line_xdyd::@return
 (byte) bitmap_line_xdyd::e
-(byte) bitmap_line_xdyd::e#1 e zp[1]:5 134.66666666666666
-(byte) bitmap_line_xdyd::e#2 e zp[1]:5 202.0
-(byte) bitmap_line_xdyd::e#3 e zp[1]:5 40.4
-(byte) bitmap_line_xdyd::e#6 e zp[1]:5 151.5
+(byte) bitmap_line_xdyd::e#1 e zp[1]:5 1333334.6666666667
+(byte) bitmap_line_xdyd::e#2 e zp[1]:5 2000002.0
+(byte) bitmap_line_xdyd::e#3 e zp[1]:5 400000.4
+(byte) bitmap_line_xdyd::e#6 e zp[1]:5 1500001.5
 (byte) bitmap_line_xdyd::x
-(byte) bitmap_line_xdyd::x#0 x zp[1]:3 1.3333333333333333
-(byte) bitmap_line_xdyd::x#2 x zp[1]:3 43.285714285714285
-(byte) bitmap_line_xdyd::x#3 x zp[1]:3 76.25
+(byte) bitmap_line_xdyd::x#0 x zp[1]:3 3667.333333333333
+(byte) bitmap_line_xdyd::x#2 x zp[1]:3 428571.85714285716
+(byte) bitmap_line_xdyd::x#3 x zp[1]:3 752501.0
 (byte) bitmap_line_xdyd::x1
 (byte) bitmap_line_xdyd::xd
-(byte) bitmap_line_xdyd::xd#0 xd zp[1]:6 15.692307692307693
+(byte) bitmap_line_xdyd::xd#0 xd zp[1]:6 153923.3076923077
 (byte) bitmap_line_xdyd::y
-(byte) bitmap_line_xdyd::y#2 y zp[1]:4 101.0
-(byte) bitmap_line_xdyd::y#3 y zp[1]:4 57.714285714285715
-(byte) bitmap_line_xdyd::y#6 y zp[1]:4 151.5
+(byte) bitmap_line_xdyd::y#2 y zp[1]:4 1000001.0
+(byte) bitmap_line_xdyd::y#3 y zp[1]:4 571429.1428571428
+(byte) bitmap_line_xdyd::y#6 y zp[1]:4 1500001.5
 (byte) bitmap_line_xdyd::yd
 (void()) bitmap_line_xdyi((byte) bitmap_line_xdyi::x , (byte) bitmap_line_xdyi::y , (byte) bitmap_line_xdyi::x1 , (byte) bitmap_line_xdyi::xd , (byte) bitmap_line_xdyi::yd)
-(byte~) bitmap_line_xdyi::$6 reg byte x 202.0
+(byte~) bitmap_line_xdyi::$6 reg byte x 2000002.0
 (label) bitmap_line_xdyi::@1
 (label) bitmap_line_xdyi::@2
 (label) bitmap_line_xdyi::@3
 (label) bitmap_line_xdyi::@4
 (label) bitmap_line_xdyi::@return
 (byte) bitmap_line_xdyi::e
-(byte) bitmap_line_xdyi::e#1 e zp[1]:5 134.66666666666666
-(byte) bitmap_line_xdyi::e#2 e zp[1]:5 202.0
-(byte) bitmap_line_xdyi::e#3 e zp[1]:5 40.4
-(byte) bitmap_line_xdyi::e#6 e zp[1]:5 101.0
+(byte) bitmap_line_xdyi::e#1 e zp[1]:5 1333334.6666666667
+(byte) bitmap_line_xdyi::e#2 e zp[1]:5 2000002.0
+(byte) bitmap_line_xdyi::e#3 e zp[1]:5 400000.4
+(byte) bitmap_line_xdyi::e#6 e zp[1]:5 1000001.0
 (byte) bitmap_line_xdyi::x
-(byte) bitmap_line_xdyi::x#2 x zp[1]:3 37.875
-(byte) bitmap_line_xdyi::x#3 x zp[1]:3 75.75
+(byte) bitmap_line_xdyi::x#2 x zp[1]:3 375000.375
+(byte) bitmap_line_xdyi::x#3 x zp[1]:3 750000.75
 (byte) bitmap_line_xdyi::x1
-(byte) bitmap_line_xdyi::x1#1 x1 zp[1]:11 6.866666666666667
+(byte) bitmap_line_xdyi::x1#1 x1 zp[1]:11 66733.46666666667
 (byte) bitmap_line_xdyi::xd
-(byte) bitmap_line_xdyi::xd#1 xd zp[1]:6 14.571428571428573
+(byte) bitmap_line_xdyi::xd#1 xd zp[1]:6 142928.7857142857
 (byte) bitmap_line_xdyi::y
-(byte) bitmap_line_xdyi::y#2 y zp[1]:4 101.0
-(byte) bitmap_line_xdyi::y#3 y zp[1]:4 57.714285714285715
-(byte) bitmap_line_xdyi::y#6 y zp[1]:4 101.0
+(byte) bitmap_line_xdyi::y#2 y zp[1]:4 1000001.0
+(byte) bitmap_line_xdyi::y#3 y zp[1]:4 571429.1428571428
+(byte) bitmap_line_xdyi::y#6 y zp[1]:4 1000001.0
 (byte) bitmap_line_xdyi::yd
 (void()) bitmap_line_ydxd((byte) bitmap_line_ydxd::y , (byte) bitmap_line_ydxd::x , (byte) bitmap_line_ydxd::y1 , (byte) bitmap_line_ydxd::yd , (byte) bitmap_line_ydxd::xd)
 (label) bitmap_line_ydxd::@1
@@ -131,20 +131,20 @@
 (label) bitmap_line_ydxd::@4
 (label) bitmap_line_ydxd::@return
 (byte) bitmap_line_ydxd::e
-(byte) bitmap_line_ydxd::e#0 e zp[1]:5 4.0
-(byte) bitmap_line_ydxd::e#1 e zp[1]:5 134.66666666666666
-(byte) bitmap_line_ydxd::e#2 e zp[1]:5 202.0
-(byte) bitmap_line_ydxd::e#3 e zp[1]:5 40.8
-(byte) bitmap_line_ydxd::e#6 e zp[1]:5 151.5
+(byte) bitmap_line_ydxd::e#0 e zp[1]:5 20002.0
+(byte) bitmap_line_ydxd::e#1 e zp[1]:5 1333334.6666666667
+(byte) bitmap_line_ydxd::e#2 e zp[1]:5 2000002.0
+(byte) bitmap_line_ydxd::e#3 e zp[1]:5 402000.60000000003
+(byte) bitmap_line_ydxd::e#6 e zp[1]:5 1500001.5
 (byte) bitmap_line_ydxd::x
-(byte) bitmap_line_ydxd::x#2 x zp[1]:3 101.0
-(byte) bitmap_line_ydxd::x#3 x zp[1]:3 57.714285714285715
-(byte) bitmap_line_ydxd::x#6 x zp[1]:3 151.5
+(byte) bitmap_line_ydxd::x#2 x zp[1]:3 1000001.0
+(byte) bitmap_line_ydxd::x#3 x zp[1]:3 571429.1428571428
+(byte) bitmap_line_ydxd::x#6 x zp[1]:3 1500001.5
 (byte) bitmap_line_ydxd::xd
-(byte) bitmap_line_ydxd::xd#0 xd zp[1]:6 8.076923076923077
+(byte) bitmap_line_ydxd::xd#0 xd zp[1]:6 77769.46153846153
 (byte) bitmap_line_ydxd::y
-(byte) bitmap_line_ydxd::y#2 y zp[1]:4 75.75
-(byte) bitmap_line_ydxd::y#3 y zp[1]:4 43.285714285714285
+(byte) bitmap_line_ydxd::y#2 y zp[1]:4 750000.75
+(byte) bitmap_line_ydxd::y#3 y zp[1]:4 428571.85714285716
 (byte) bitmap_line_ydxd::y1
 (byte) bitmap_line_ydxd::yd
 (void()) bitmap_line_ydxi((byte) bitmap_line_ydxi::y , (byte) bitmap_line_ydxi::x , (byte) bitmap_line_ydxi::y1 , (byte) bitmap_line_ydxi::yd , (byte) bitmap_line_ydxi::xd)
@@ -154,43 +154,43 @@
 (label) bitmap_line_ydxi::@4
 (label) bitmap_line_ydxi::@return
 (byte) bitmap_line_ydxi::e
-(byte) bitmap_line_ydxi::e#0 e zp[1]:5 4.0
-(byte) bitmap_line_ydxi::e#1 e zp[1]:5 134.66666666666666
-(byte) bitmap_line_ydxi::e#2 e zp[1]:5 202.0
-(byte) bitmap_line_ydxi::e#3 e zp[1]:5 40.8
-(byte) bitmap_line_ydxi::e#6 e zp[1]:5 151.5
+(byte) bitmap_line_ydxi::e#0 e zp[1]:5 20002.0
+(byte) bitmap_line_ydxi::e#1 e zp[1]:5 1333334.6666666667
+(byte) bitmap_line_ydxi::e#2 e zp[1]:5 2000002.0
+(byte) bitmap_line_ydxi::e#3 e zp[1]:5 402000.60000000003
+(byte) bitmap_line_ydxi::e#6 e zp[1]:5 1500001.5
 (byte) bitmap_line_ydxi::x
-(byte) bitmap_line_ydxi::x#2 x zp[1]:3 101.0
-(byte) bitmap_line_ydxi::x#3 x zp[1]:3 57.714285714285715
-(byte) bitmap_line_ydxi::x#6 x zp[1]:3 151.5
+(byte) bitmap_line_ydxi::x#2 x zp[1]:3 1000001.0
+(byte) bitmap_line_ydxi::x#3 x zp[1]:3 571429.1428571428
+(byte) bitmap_line_ydxi::x#6 x zp[1]:3 1500001.5
 (byte) bitmap_line_ydxi::xd
-(byte) bitmap_line_ydxi::xd#1 xd zp[1]:6 8.076923076923077
+(byte) bitmap_line_ydxi::xd#1 xd zp[1]:6 77769.46153846153
 (byte) bitmap_line_ydxi::y
-(byte) bitmap_line_ydxi::y#2 y zp[1]:4 43.285714285714285
-(byte) bitmap_line_ydxi::y#3 y zp[1]:4 75.75
+(byte) bitmap_line_ydxi::y#2 y zp[1]:4 428571.85714285716
+(byte) bitmap_line_ydxi::y#3 y zp[1]:4 750000.75
 (byte) bitmap_line_ydxi::y1
 (byte) bitmap_line_ydxi::yd
 (void()) bitmap_plot((byte) bitmap_plot::x , (byte) bitmap_plot::y)
-(byte~) bitmap_plot::$1 reg byte a 4.0
+(byte~) bitmap_plot::$1 reg byte a 2.0000002E7
 (label) bitmap_plot::@return
 (byte*) bitmap_plot::plotter
-(word) bitmap_plot::plotter#0 plotter zp[2]:7 1.0
+(word) bitmap_plot::plotter#0 plotter zp[2]:7 5000000.5
 (word) bitmap_plot::plotter_x
-(word) bitmap_plot::plotter_x#0 plotter_x zp[2]:7 2.0
+(word) bitmap_plot::plotter_x#0 plotter_x zp[2]:7 1.0000001E7
 (word) bitmap_plot::plotter_y
-(word) bitmap_plot::plotter_y#0 plotter_y zp[2]:9 4.0
+(word) bitmap_plot::plotter_y#0 plotter_y zp[2]:9 2.0000002E7
 (byte) bitmap_plot::x
-(byte) bitmap_plot::x#0 reg byte x 101.0
-(byte) bitmap_plot::x#1 reg byte x 101.0
-(byte) bitmap_plot::x#2 reg byte x 101.0
-(byte) bitmap_plot::x#3 reg byte x 101.0
-(byte) bitmap_plot::x#4 reg byte x 102.5
+(byte) bitmap_plot::x#0 reg byte x 1000001.0
+(byte) bitmap_plot::x#1 reg byte x 1000001.0
+(byte) bitmap_plot::x#2 reg byte x 1000001.0
+(byte) bitmap_plot::x#3 reg byte x 1000001.0
+(byte) bitmap_plot::x#4 reg byte x 8500001.75
 (byte) bitmap_plot::y
-(byte) bitmap_plot::y#0 reg byte y 202.0
-(byte) bitmap_plot::y#1 reg byte y 202.0
-(byte) bitmap_plot::y#2 reg byte y 202.0
-(byte) bitmap_plot::y#3 reg byte y 202.0
-(byte) bitmap_plot::y#4 reg byte y 204.0
+(byte) bitmap_plot::y#0 reg byte y 2000002.0
+(byte) bitmap_plot::y#1 reg byte y 2000002.0
+(byte) bitmap_plot::y#2 reg byte y 2000002.0
+(byte) bitmap_plot::y#3 reg byte y 2000002.0
+(byte) bitmap_plot::y#4 reg byte y 1.2000003E7
 (const byte*) bitmap_plot_bit[(number) $100]  = { fill( $100, 0) }
 (const byte*) bitmap_plot_xhi[(number) $100]  = { fill( $100, 0) }
 (const byte*) bitmap_plot_xlo[(number) $100]  = { fill( $100, 0) }
@@ -201,16 +201,16 @@
 (label) init_screen::@2
 (label) init_screen::@return
 (byte*) init_screen::c
-(byte*) init_screen::c#1 c zp[2]:7 22.0
-(byte*) init_screen::c#2 c zp[2]:7 14.666666666666666
+(byte*) init_screen::c#1 c zp[2]:7 2002.0
+(byte*) init_screen::c#2 c zp[2]:7 1334.6666666666667
 (void()) main()
 (label) main::@1
 (label) main::@2
 (label) main::@3
 (label) main::@4
 (byte) next
-(byte) next#1 next zp[1]:2 22.0
-(byte) next#4 next zp[1]:2 11.0
+(byte) next#1 next zp[1]:2 202.0
+(byte) next#4 next zp[1]:2 101.0
 
 zp[1]:2 [ next#4 next#1 ]
 reg byte x [ bitmap_plot::x#4 bitmap_plot::x#1 bitmap_plot::x#0 bitmap_plot::x#3 bitmap_plot::x#2 ]
@@ -222,9 +222,9 @@ reg byte x [ bitmap_clear::x#2 bitmap_clear::x#1 ]
 reg byte x [ bitmap_init::x#2 bitmap_init::x#1 ]
 reg byte y [ bitmap_init::bits#3 bitmap_init::bits#4 bitmap_init::bits#1 ]
 reg byte x [ bitmap_init::y#2 bitmap_init::y#1 ]
-reg byte x [ bitmap_line::x1#0 ]
-reg byte a [ bitmap_line::xd#2 ]
-reg byte a [ bitmap_line::xd#1 ]
+reg byte a [ bitmap_line::x1#0 ]
+reg byte x [ bitmap_line::xd#2 ]
+reg byte x [ bitmap_line::xd#1 ]
 zp[1]:6 [ bitmap_line_xdyi::xd#1 bitmap_line_ydxi::xd#1 bitmap_line_xdyd::xd#0 bitmap_line_ydxd::xd#0 bitmap_clear::y#4 bitmap_clear::y#1 ]
 reg byte x [ bitmap_line_xdyi::$6 ]
 zp[2]:7 [ bitmap_plot::plotter_x#0 bitmap_plot::plotter#0 bitmap_init::yoffs#2 bitmap_init::yoffs#4 bitmap_init::yoffs#1 bitmap_clear::bitmap#2 bitmap_clear::bitmap#3 bitmap_clear::bitmap#5 bitmap_clear::bitmap#1 bitmap_clear::bitmap#0 init_screen::c#2 init_screen::c#1 ]

src/test/ref/bitmap-line-anim-2.asm

@@ -313,10 +313,9 @@ bitmap_plot: {
     adc.z __1+1
     sta.z plotter+1
     // <x
-    lda.z x
+    ldx.z x
     // *plotter |= bitmap_plot_bit[<x]
-    tay
-    lda bitmap_plot_bit,y
+    lda bitmap_plot_bit,x
     ldy #0
     ora (plotter),y
     sta (plotter),y

src/test/ref/bitmap-line-anim-2.log

@@ -1229,115 +1229,115 @@ Inversing boolean not [149] (bool~) bitmap_line::$21 ← (word) bitmap_line::dy#
 Inversing boolean not [171] (bool~) bitmap_line::$27 ← (word) bitmap_line::dx#5 >= (word) bitmap_line::e1#1 from [170] (bool~) bitmap_line::$26 ← (word) bitmap_line::dx#5 < (word) bitmap_line::e1#1
 Inversing boolean not [228] (bool~) main::$4 ← (word) next#1 != (word) $140 from [227] (bool~) main::$3 ← (word) next#1 == (word) $140
 Successful SSA optimization Pass2UnaryNotSimplification
-Alias (void*) memset::return#0 = (void*) memset::str#2 (void*) memset::return#4 (void*) memset::return#1 
-Alias (void*) memset::str#3 = (void*) memset::str#4 
-Alias (word) memset::num#2 = (word) memset::num#3 
-Alias (byte) memset::c#4 = (byte) memset::c#5 
-Alias (byte*) memset::end#0 = (byte*~) memset::$3 
-Alias (byte) memset::c#2 = (byte) memset::c#3 
-Alias (byte*) memset::dst#2 = (byte*) memset::dst#3 
-Alias (byte*) memset::end#1 = (byte*) memset::end#2 
-Alias (void*) memset::str#5 = (void*) memset::str#6 
-Alias (byte) bitmap_init::x#2 = (byte) bitmap_init::x#4 
-Alias (byte*) bitmap_init::gfx#4 = (byte*) bitmap_init::gfx#5 
-Alias (byte*) bitmap_gfx#25 = (byte*) bitmap_gfx#26 
-Alias (byte*) bitmap_screen#24 = (byte*) bitmap_screen#25 
-Alias (byte*) bitmap_init::gfx#2 = (byte*) bitmap_init::gfx#3 (byte*) bitmap_init::yoffs#0 
-Alias (byte*) bitmap_gfx#21 = (byte*) bitmap_gfx#23 
-Alias (byte*) bitmap_screen#20 = (byte*) bitmap_screen#22 
-Alias (byte*) bitmap_init::yoffs#2 = (byte*) bitmap_init::yoffs#3 
-Alias (byte) bitmap_init::y#2 = (byte) bitmap_init::y#4 
-Alias (byte*) bitmap_gfx#16 = (byte*) bitmap_gfx#17 
-Alias (byte*) bitmap_screen#15 = (byte*) bitmap_screen#16 
-Alias (byte*) bitmap_init::yoffs#1 = (byte*~) bitmap_init::$10 
-Alias (byte*) bitmap_gfx#11 = (byte*) bitmap_gfx#6 (byte*) bitmap_gfx#2 
-Alias (byte*) bitmap_screen#11 = (byte*) bitmap_screen#6 (byte*) bitmap_screen#2 
-Alias (byte) bitmap_clear::col#0 = (byte~) bitmap_clear::$1 
-Alias (byte*) bitmap_gfx#12 = (byte*) bitmap_gfx#7 
-Alias (byte*) bitmap_plot::plotter#0 = (byte*~) bitmap_plot::$0 
-Alias (word) bitmap_line::x#0 = (word) bitmap_line::x1#1 (word) bitmap_line::x1#4 (word) bitmap_line::x#16 (word) bitmap_line::x1#3 (word) bitmap_line::x#10 (word) bitmap_line::x1#2 (word) bitmap_line::x#19 (word) bitmap_line::x#18 (word) bitmap_line::x#17 (word) bitmap_line::x#3 (word) bitmap_line::x#14 (word) bitmap_line::x#11 
-Alias (word) bitmap_line::y#0 = (word) bitmap_line::y1#1 (word) bitmap_line::y1#2 (word) bitmap_line::y#16 (word) bitmap_line::y#10 (word) bitmap_line::y1#5 (word) bitmap_line::y1#4 (word) bitmap_line::y#19 (word) bitmap_line::y1#3 (word) bitmap_line::y#18 (word) bitmap_line::y#17 (word) bitmap_line::y#3 (word) bitmap_line::y#14 (word) bitmap_line::y#11 
-Alias (word) abs_u16::w#0 = (word~) bitmap_line::$0 
-Alias (word) abs_u16::return#0 = (word) abs_u16::return#5 
-Alias (word) bitmap_line::y2#1 = (word) bitmap_line::y2#4 (word) bitmap_line::y2#8 (word) bitmap_line::y2#5 (word) bitmap_line::y2#2 (word) bitmap_line::y2#11 (word) bitmap_line::y2#10 
-Alias (word) bitmap_line::x2#1 = (word) bitmap_line::x2#7 (word) bitmap_line::x2#4 (word) bitmap_line::x2#2 (word) bitmap_line::x2#11 (word) bitmap_line::x2#10 (word) bitmap_line::x2#9 
-Alias (word) bitmap_line::dx#0 = (word~) bitmap_line::$1 (word) bitmap_line::dx#1 (word) bitmap_line::dx#10 (word) bitmap_line::dx#7 (word) bitmap_line::dx#2 (word) bitmap_line::dx#13 (word) bitmap_line::dx#3 
-Alias (word) abs_u16::w#1 = (word~) bitmap_line::$2 
-Alias (word) abs_u16::return#1 = (word) abs_u16::return#6 
-Alias (word) bitmap_line::dy#0 = (word~) bitmap_line::$3 (word) bitmap_line::dy#9 (word) bitmap_line::dy#6 (word) bitmap_line::dy#1 (word) bitmap_line::dy#2 (word) bitmap_line::dy#10 
-Alias (word) sgn_u16::w#0 = (word~) bitmap_line::$8 
-Alias (word) sgn_u16::return#0 = (word) sgn_u16::return#5 
-Alias (word) bitmap_line::sx#0 = (word~) bitmap_line::$9 (word) bitmap_line::sx#8 (word) bitmap_line::sx#7 (word) bitmap_line::sx#9 
-Alias (word) sgn_u16::w#1 = (word~) bitmap_line::$10 
-Alias (word) sgn_u16::return#1 = (word) sgn_u16::return#6 
-Alias (word) bitmap_line::sy#0 = (word~) bitmap_line::$11 (word) bitmap_line::sy#10 (word) bitmap_line::sy#5 
-Alias (byte) bitmap_plot::y#0 = (byte~) bitmap_line::$15 
-Alias (word) bitmap_line::e1#0 = (word~) bitmap_line::$23 
-Alias (word) bitmap_line::e#0 = (word~) bitmap_line::$17 
-Alias (byte) bitmap_plot::y#1 = (byte~) bitmap_line::$18 
-Alias (word) bitmap_line::y#4 = (word) bitmap_line::y#5 
-Alias (word) bitmap_line::sy#1 = (word) bitmap_line::sy#3 (word) bitmap_line::sy#8 
-Alias (word) bitmap_line::e#3 = (word) bitmap_line::e#5 
-Alias (word) bitmap_line::dx#14 = (word) bitmap_line::dx#4 (word) bitmap_line::dx#8 
-Alias (word) bitmap_line::dy#3 = (word) bitmap_line::dy#7 (word) bitmap_line::dy#4 
-Alias (word) bitmap_line::y2#6 = (word) bitmap_line::y2#9 (word) bitmap_line::y2#7 
-Alias (word) bitmap_line::x#13 = (word) bitmap_line::x#4 (word) bitmap_line::x#5 
-Alias (word) bitmap_line::sx#1 = (word) bitmap_line::sx#3 (word) bitmap_line::sx#5 
-Alias (word) bitmap_line::e#1 = (word) bitmap_line::e#4 
-Alias (word) bitmap_line::y#1 = (word) bitmap_line::y#12 
-Alias (byte) bitmap_plot::y#2 = (byte~) bitmap_line::$13 
-Alias (byte) bitmap_plot::y#3 = (byte~) bitmap_line::$24 
-Alias (word) bitmap_line::x#7 = (word) bitmap_line::x#8 
-Alias (word) bitmap_line::sx#11 = (word) bitmap_line::sx#2 (word) bitmap_line::sx#4 
-Alias (word) bitmap_line::e1#3 = (word) bitmap_line::e1#5 
-Alias (word) bitmap_line::dy#13 = (word) bitmap_line::dy#5 (word) bitmap_line::dy#8 
-Alias (word) bitmap_line::dx#5 = (word) bitmap_line::dx#9 (word) bitmap_line::dx#6 
-Alias (word) bitmap_line::x2#5 = (word) bitmap_line::x2#6 (word) bitmap_line::x2#8 
-Alias (word) bitmap_line::y#15 = (word) bitmap_line::y#8 (word) bitmap_line::y#9 
-Alias (word) bitmap_line::sy#2 = (word) bitmap_line::sy#4 (word) bitmap_line::sy#7 
-Alias (word) bitmap_line::e1#1 = (word) bitmap_line::e1#4 
-Alias (word) bitmap_line::x#15 = (word) bitmap_line::x#2 
-Alias (word) abs_u16::w#2 = (word) abs_u16::w#3 (word) abs_u16::w#4 (word) abs_u16::return#3 
-Alias (word) abs_u16::return#2 = (word~) abs_u16::$2 
-Alias (word) abs_u16::return#4 = (word) abs_u16::return#7 
-Alias (word) sgn_u16::return#4 = (word) sgn_u16::return#7 
-Alias (byte*) bitmap_gfx#0 = (byte*) bitmap_gfx#20 (byte*) bitmap_gfx#15 
-Alias (byte*) bitmap_screen#0 = (byte*) bitmap_screen#19 (byte*) bitmap_screen#14 
-Alias (word) next#10 = (word) next#12 (word) next#13 
-Alias (byte*) bitmap_gfx#24 = (byte*) bitmap_gfx#3 (byte*) bitmap_gfx#8 
-Alias (byte*) bitmap_screen#23 = (byte*) bitmap_screen#3 (byte*) bitmap_screen#8 
-Alias (word) next#5 = (word) next#6 
-Alias (byte*) bitmap_gfx#18 = (byte*) bitmap_gfx#19 (byte*) bitmap_gfx#22 
-Alias (byte*) bitmap_screen#17 = (byte*) bitmap_screen#18 (byte*) bitmap_screen#21 
-Alias (byte*) bitmap_gfx#14 = (byte*) bitmap_gfx#9 (byte*) bitmap_gfx#4 
-Alias (byte*) bitmap_screen#13 = (byte*) bitmap_screen#9 (byte*) bitmap_screen#4 
-Alias (word) next#3 = (word) next#7 (word) next#9 
-Alias (word) next#0 = (word) next#11 
-Alias (byte*) bitmap_gfx#10 = (byte*) bitmap_gfx#5 
-Alias (byte*) bitmap_screen#10 = (byte*) bitmap_screen#5 
-Alias (word) next#4 = (word) next#8 
+Alias memset::return#0 = memset::str#2 memset::return#4 memset::return#1 
+Alias memset::str#3 = memset::str#4 
+Alias memset::num#2 = memset::num#3 
+Alias memset::c#4 = memset::c#5 
+Alias memset::end#0 = memset::$3 
+Alias memset::c#2 = memset::c#3 
+Alias memset::dst#2 = memset::dst#3 
+Alias memset::end#1 = memset::end#2 
+Alias memset::str#5 = memset::str#6 
+Alias bitmap_init::x#2 = bitmap_init::x#4 
+Alias bitmap_init::gfx#4 = bitmap_init::gfx#5 
+Alias bitmap_gfx#25 = bitmap_gfx#26 
+Alias bitmap_screen#24 = bitmap_screen#25 
+Alias bitmap_init::gfx#2 = bitmap_init::gfx#3 bitmap_init::yoffs#0 
+Alias bitmap_gfx#21 = bitmap_gfx#23 
+Alias bitmap_screen#20 = bitmap_screen#22 
+Alias bitmap_init::yoffs#2 = bitmap_init::yoffs#3 
+Alias bitmap_init::y#2 = bitmap_init::y#4 
+Alias bitmap_gfx#16 = bitmap_gfx#17 
+Alias bitmap_screen#15 = bitmap_screen#16 
+Alias bitmap_init::yoffs#1 = bitmap_init::$10 
+Alias bitmap_gfx#11 = bitmap_gfx#6 bitmap_gfx#2 
+Alias bitmap_screen#11 = bitmap_screen#6 bitmap_screen#2 
+Alias bitmap_clear::col#0 = bitmap_clear::$1 
+Alias bitmap_gfx#12 = bitmap_gfx#7 
+Alias bitmap_plot::plotter#0 = bitmap_plot::$0 
+Alias bitmap_line::x#0 = bitmap_line::x1#1 bitmap_line::x1#4 bitmap_line::x#16 bitmap_line::x1#3 bitmap_line::x#10 bitmap_line::x1#2 bitmap_line::x#19 bitmap_line::x#18 bitmap_line::x#17 bitmap_line::x#3 bitmap_line::x#14 bitmap_line::x#11 
+Alias bitmap_line::y#0 = bitmap_line::y1#1 bitmap_line::y1#2 bitmap_line::y#16 bitmap_line::y#10 bitmap_line::y1#5 bitmap_line::y1#4 bitmap_line::y#19 bitmap_line::y1#3 bitmap_line::y#18 bitmap_line::y#17 bitmap_line::y#3 bitmap_line::y#14 bitmap_line::y#11 
+Alias abs_u16::w#0 = bitmap_line::$0 
+Alias abs_u16::return#0 = abs_u16::return#5 
+Alias bitmap_line::y2#1 = bitmap_line::y2#4 bitmap_line::y2#8 bitmap_line::y2#5 bitmap_line::y2#2 bitmap_line::y2#11 bitmap_line::y2#10 
+Alias bitmap_line::x2#1 = bitmap_line::x2#7 bitmap_line::x2#4 bitmap_line::x2#2 bitmap_line::x2#11 bitmap_line::x2#10 bitmap_line::x2#9 
+Alias bitmap_line::dx#0 = bitmap_line::$1 bitmap_line::dx#1 bitmap_line::dx#10 bitmap_line::dx#7 bitmap_line::dx#2 bitmap_line::dx#13 bitmap_line::dx#3 
+Alias abs_u16::w#1 = bitmap_line::$2 
+Alias abs_u16::return#1 = abs_u16::return#6 
+Alias bitmap_line::dy#0 = bitmap_line::$3 bitmap_line::dy#9 bitmap_line::dy#6 bitmap_line::dy#1 bitmap_line::dy#2 bitmap_line::dy#10 
+Alias sgn_u16::w#0 = bitmap_line::$8 
+Alias sgn_u16::return#0 = sgn_u16::return#5 
+Alias bitmap_line::sx#0 = bitmap_line::$9 bitmap_line::sx#8 bitmap_line::sx#7 bitmap_line::sx#9 
+Alias sgn_u16::w#1 = bitmap_line::$10 
+Alias sgn_u16::return#1 = sgn_u16::return#6 
+Alias bitmap_line::sy#0 = bitmap_line::$11 bitmap_line::sy#10 bitmap_line::sy#5 
+Alias bitmap_plot::y#0 = bitmap_line::$15 
+Alias bitmap_line::e1#0 = bitmap_line::$23 
+Alias bitmap_line::e#0 = bitmap_line::$17 
+Alias bitmap_plot::y#1 = bitmap_line::$18 
+Alias bitmap_line::y#4 = bitmap_line::y#5 
+Alias bitmap_line::sy#1 = bitmap_line::sy#3 bitmap_line::sy#8 
+Alias bitmap_line::e#3 = bitmap_line::e#5 
+Alias bitmap_line::dx#14 = bitmap_line::dx#4 bitmap_line::dx#8 
+Alias bitmap_line::dy#3 = bitmap_line::dy#7 bitmap_line::dy#4 
+Alias bitmap_line::y2#6 = bitmap_line::y2#9 bitmap_line::y2#7 
+Alias bitmap_line::x#13 = bitmap_line::x#4 bitmap_line::x#5 
+Alias bitmap_line::sx#1 = bitmap_line::sx#3 bitmap_line::sx#5 
+Alias bitmap_line::e#1 = bitmap_line::e#4 
+Alias bitmap_line::y#1 = bitmap_line::y#12 
+Alias bitmap_plot::y#2 = bitmap_line::$13 
+Alias bitmap_plot::y#3 = bitmap_line::$24 
+Alias bitmap_line::x#7 = bitmap_line::x#8 
+Alias bitmap_line::sx#11 = bitmap_line::sx#2 bitmap_line::sx#4 
+Alias bitmap_line::e1#3 = bitmap_line::e1#5 
+Alias bitmap_line::dy#13 = bitmap_line::dy#5 bitmap_line::dy#8 
+Alias bitmap_line::dx#5 = bitmap_line::dx#9 bitmap_line::dx#6 
+Alias bitmap_line::x2#5 = bitmap_line::x2#6 bitmap_line::x2#8 
+Alias bitmap_line::y#15 = bitmap_line::y#8 bitmap_line::y#9 
+Alias bitmap_line::sy#2 = bitmap_line::sy#4 bitmap_line::sy#7 
+Alias bitmap_line::e1#1 = bitmap_line::e1#4 
+Alias bitmap_line::x#15 = bitmap_line::x#2 
+Alias abs_u16::w#2 = abs_u16::w#3 abs_u16::w#4 abs_u16::return#3 
+Alias abs_u16::return#2 = abs_u16::$2 
+Alias abs_u16::return#4 = abs_u16::return#7 
+Alias sgn_u16::return#4 = sgn_u16::return#7 
+Alias bitmap_gfx#0 = bitmap_gfx#20 bitmap_gfx#15 
+Alias bitmap_screen#0 = bitmap_screen#19 bitmap_screen#14 
+Alias next#10 = next#12 next#13 
+Alias bitmap_gfx#24 = bitmap_gfx#3 bitmap_gfx#8 
+Alias bitmap_screen#23 = bitmap_screen#3 bitmap_screen#8 
+Alias next#5 = next#6 
+Alias bitmap_gfx#18 = bitmap_gfx#19 bitmap_gfx#22 
+Alias bitmap_screen#17 = bitmap_screen#18 bitmap_screen#21 
+Alias bitmap_gfx#14 = bitmap_gfx#9 bitmap_gfx#4 
+Alias bitmap_screen#13 = bitmap_screen#9 bitmap_screen#4 
+Alias next#3 = next#7 next#9 
+Alias next#0 = next#11 
+Alias bitmap_gfx#10 = bitmap_gfx#5 
+Alias bitmap_screen#10 = bitmap_screen#5 
+Alias next#4 = next#8 
 Successful SSA optimization Pass2AliasElimination
-Alias (byte) bitmap_init::x#2 = (byte) bitmap_init::x#3 
-Alias (byte*) bitmap_init::gfx#2 = (byte*) bitmap_init::gfx#4 
-Alias (byte*) bitmap_gfx#21 = (byte*) bitmap_gfx#25 
-Alias (byte*) bitmap_screen#20 = (byte*) bitmap_screen#24 
-Alias (byte) bitmap_init::y#2 = (byte) bitmap_init::y#3 
-Alias (byte*) bitmap_gfx#11 = (byte*) bitmap_gfx#16 
-Alias (byte*) bitmap_screen#11 = (byte*) bitmap_screen#15 
-Alias (word) bitmap_line::y#1 = (word) bitmap_line::y#6 
-Alias (word) bitmap_line::y2#3 = (word) bitmap_line::y2#6 
-Alias (word) bitmap_line::sy#1 = (word) bitmap_line::sy#6 
-Alias (word) bitmap_line::dx#11 = (word) bitmap_line::dx#14 
-Alias (word) bitmap_line::dy#11 = (word) bitmap_line::dy#3 
-Alias (word) bitmap_line::sx#1 = (word) bitmap_line::sx#10 
-Alias (word) bitmap_line::x#15 = (word) bitmap_line::x#9 
-Alias (word) bitmap_line::x2#3 = (word) bitmap_line::x2#5 
-Alias (word) bitmap_line::sx#11 = (word) bitmap_line::sx#6 
-Alias (word) bitmap_line::dy#12 = (word) bitmap_line::dy#13 
-Alias (word) bitmap_line::dx#12 = (word) bitmap_line::dx#5 
-Alias (word) bitmap_line::sy#2 = (word) bitmap_line::sy#9 
-Alias (byte*) bitmap_gfx#14 = (byte*) bitmap_gfx#18 
-Alias (byte*) bitmap_screen#13 = (byte*) bitmap_screen#17 
+Alias bitmap_init::x#2 = bitmap_init::x#3 
+Alias bitmap_init::gfx#2 = bitmap_init::gfx#4 
+Alias bitmap_gfx#21 = bitmap_gfx#25 
+Alias bitmap_screen#20 = bitmap_screen#24 
+Alias bitmap_init::y#2 = bitmap_init::y#3 
+Alias bitmap_gfx#11 = bitmap_gfx#16 
+Alias bitmap_screen#11 = bitmap_screen#15 
+Alias bitmap_line::y#1 = bitmap_line::y#6 
+Alias bitmap_line::y2#3 = bitmap_line::y2#6 
+Alias bitmap_line::sy#1 = bitmap_line::sy#6 
+Alias bitmap_line::dx#11 = bitmap_line::dx#14 
+Alias bitmap_line::dy#11 = bitmap_line::dy#3 
+Alias bitmap_line::sx#1 = bitmap_line::sx#10 
+Alias bitmap_line::x#15 = bitmap_line::x#9 
+Alias bitmap_line::x2#3 = bitmap_line::x2#5 
+Alias bitmap_line::sx#11 = bitmap_line::sx#6 
+Alias bitmap_line::dy#12 = bitmap_line::dy#13 
+Alias bitmap_line::dx#12 = bitmap_line::dx#5 
+Alias bitmap_line::sy#2 = bitmap_line::sy#9 
+Alias bitmap_gfx#14 = bitmap_gfx#18 
+Alias bitmap_screen#13 = bitmap_screen#17 
 Successful SSA optimization Pass2AliasElimination
 Identical Phi Values (byte*) memset::end#1 (byte*) memset::end#0
 Identical Phi Values (void*) memset::str#5 (void*) memset::str#3
@@ -1460,7 +1460,7 @@ Successful SSA optimization PassNCastSimplification
 Finalized unsigned number type (byte) 0
 Finalized unsigned number type (byte) 0
 Successful SSA optimization PassNFinalizeNumberTypeConversions
-Alias (byte~) bitmap_init::$7 = (byte~) bitmap_init::$3 
+Alias bitmap_init::$7 = bitmap_init::$3 
 Successful SSA optimization Pass2AliasElimination
 Simple Condition (bool~) bitmap_line::$4 [54] if((word) bitmap_line::dx#0==(byte) 0) goto bitmap_line::@24
 Simple Condition (bool~) bitmap_line::$5 [120] if((word) bitmap_line::dy#0==(byte) 0) goto bitmap_line::@4
@@ -1931,128 +1931,128 @@ bitmap_init::@return: scope:[bitmap_init]  from bitmap_init::@4
 
 VARIABLE REGISTER WEIGHTS
 (word()) abs_u16((word) abs_u16::w)
-(byte~) abs_u16::$0 4.0
-(byte~) abs_u16::$1 4.0
+(byte~) abs_u16::$0 20002.0
+(byte~) abs_u16::$1 20002.0
 (word) abs_u16::return
-(word) abs_u16::return#0 4.0
-(word) abs_u16::return#1 4.0
-(word) abs_u16::return#2 4.0
-(word) abs_u16::return#4 2.0
+(word) abs_u16::return#0 2002.0
+(word) abs_u16::return#1 2002.0
+(word) abs_u16::return#2 20002.0
+(word) abs_u16::return#4 5501.0
 (word) abs_u16::w
-(word) abs_u16::w#0 4.0
-(word) abs_u16::w#2 2.0
+(word) abs_u16::w#0 2002.0
+(word) abs_u16::w#2 7751.0
 (void()) bitmap_clear((byte) bitmap_clear::bgcol , (byte) bitmap_clear::fgcol)
 (byte) bitmap_clear::bgcol
 (byte) bitmap_clear::col
 (byte) bitmap_clear::fgcol
 (byte*) bitmap_gfx
 (void()) bitmap_init((byte*) bitmap_init::gfx , (byte*) bitmap_init::screen)
-(byte~) bitmap_init::$4 22.0
-(byte~) bitmap_init::$5 22.0
-(byte~) bitmap_init::$6 22.0
-(byte~) bitmap_init::$7 5.5
+(byte~) bitmap_init::$4 2002.0
+(byte~) bitmap_init::$5 2002.0
+(byte~) bitmap_init::$6 2002.0
+(byte~) bitmap_init::$7 500.5
 (byte) bitmap_init::bits
-(byte) bitmap_init::bits#1 11.0
-(byte) bitmap_init::bits#3 16.5
-(byte) bitmap_init::bits#4 7.333333333333333
+(byte) bitmap_init::bits#1 1001.0
+(byte) bitmap_init::bits#3 1501.5
+(byte) bitmap_init::bits#4 667.3333333333334
 (byte*) bitmap_init::gfx
 (byte*) bitmap_init::screen
 (byte) bitmap_init::x
-(byte) bitmap_init::x#1 16.5
-(byte) bitmap_init::x#2 5.5
+(byte) bitmap_init::x#1 1501.5
+(byte) bitmap_init::x#2 500.5
 (byte) bitmap_init::y
-(byte) bitmap_init::y#1 16.5
-(byte) bitmap_init::y#2 5.5
+(byte) bitmap_init::y#1 1501.5
+(byte) bitmap_init::y#2 500.5
 (byte*) bitmap_init::yoffs
-(byte*) bitmap_init::yoffs#1 22.0
-(byte*) bitmap_init::yoffs#2 6.875
-(byte*) bitmap_init::yoffs#4 11.0
+(byte*) bitmap_init::yoffs#1 2002.0
+(byte*) bitmap_init::yoffs#2 625.625
+(byte*) bitmap_init::yoffs#4 1001.0
 (void()) bitmap_line((word) bitmap_line::x1 , (word) bitmap_line::y1 , (word) bitmap_line::x2 , (word) bitmap_line::y2)
 (word) bitmap_line::dx
-(word) bitmap_line::dx#0 8.18421052631579
+(word) bitmap_line::dx#0 8000.184210526315
 (word) bitmap_line::dy
-(word) bitmap_line::dy#0 8.885714285714286
+(word) bitmap_line::dy#0 8685.914285714285
 (word) bitmap_line::e
-(word) bitmap_line::e#0 4.0
-(word) bitmap_line::e#1 134.66666666666666
-(word) bitmap_line::e#2 202.0
-(word) bitmap_line::e#3 40.8
-(word) bitmap_line::e#6 151.5
+(word) bitmap_line::e#0 2002.0
+(word) bitmap_line::e#1 133334.66666666666
+(word) bitmap_line::e#2 200002.0
+(word) bitmap_line::e#3 40200.600000000006
+(word) bitmap_line::e#6 150001.5
 (word) bitmap_line::e1
-(word) bitmap_line::e1#0 4.0
-(word) bitmap_line::e1#1 134.66666666666666
-(word) bitmap_line::e1#2 202.0
-(word) bitmap_line::e1#3 40.8
-(word) bitmap_line::e1#6 151.5
+(word) bitmap_line::e1#0 2002.0
+(word) bitmap_line::e1#1 133334.66666666666
+(word) bitmap_line::e1#2 200002.0
+(word) bitmap_line::e1#3 40200.600000000006
+(word) bitmap_line::e1#6 150001.5
 (word) bitmap_line::sx
-(word) bitmap_line::sx#0 7.03448275862069
+(word) bitmap_line::sx#0 6931.137931034482
 (word) bitmap_line::sy
-(word) bitmap_line::sy#0 7.846153846153847
+(word) bitmap_line::sy#0 7730.884615384615
 (word) bitmap_line::x
-(word) bitmap_line::x#1 101.0
-(word) bitmap_line::x#12 202.0
-(word) bitmap_line::x#13 57.714285714285715
-(word) bitmap_line::x#15 57.714285714285715
-(word) bitmap_line::x#6 102.0
-(word) bitmap_line::x#7 75.75
+(word) bitmap_line::x#1 100001.0
+(word) bitmap_line::x#12 200002.0
+(word) bitmap_line::x#13 57143.42857142857
+(word) bitmap_line::x#15 57143.42857142857
+(word) bitmap_line::x#6 100501.5
+(word) bitmap_line::x#7 75000.75
 (word) bitmap_line::x1
 (word) bitmap_line::x2
-(word) bitmap_line::x2#0 3.8666666666666667
+(word) bitmap_line::x2#0 3403.4666666666667
 (word) bitmap_line::y
-(word) bitmap_line::y#1 57.714285714285715
-(word) bitmap_line::y#13 202.0
-(word) bitmap_line::y#15 43.285714285714285
-(word) bitmap_line::y#2 101.0
-(word) bitmap_line::y#4 50.5
-(word) bitmap_line::y#7 202.0
+(word) bitmap_line::y#1 57143.42857142857
+(word) bitmap_line::y#13 200002.0
+(word) bitmap_line::y#15 42857.57142857143
+(word) bitmap_line::y#2 100001.0
+(word) bitmap_line::y#4 50000.5
+(word) bitmap_line::y#7 200002.0
 (word) bitmap_line::y1
 (word) bitmap_line::y2
 (void()) bitmap_plot((word) bitmap_plot::x , (byte) bitmap_plot::y)
-(word~) bitmap_plot::$1 4.0
-(byte~) bitmap_plot::$2 4.0
+(word~) bitmap_plot::$1 2000002.0
+(byte~) bitmap_plot::$2 2000002.0
 (byte*) bitmap_plot::plotter
-(word) bitmap_plot::plotter#0 1.0
-(byte*) bitmap_plot::plotter#1 3.0
+(word) bitmap_plot::plotter#0 500000.5
+(byte*) bitmap_plot::plotter#1 1500001.5
 (word) bitmap_plot::x
-(word) bitmap_plot::x#1 202.0
-(word) bitmap_plot::x#2 4.0
-(word) bitmap_plot::x#3 202.0
-(word) bitmap_plot::x#4 52.0
+(word) bitmap_plot::x#1 200002.0
+(word) bitmap_plot::x#2 2002.0
+(word) bitmap_plot::x#3 200002.0
+(word) bitmap_plot::x#4 550251.25
 (byte) bitmap_plot::y
-(byte) bitmap_plot::y#1 101.0
-(byte) bitmap_plot::y#2 2.0
-(byte) bitmap_plot::y#3 101.0
-(byte) bitmap_plot::y#4 208.0
+(byte) bitmap_plot::y#1 100001.0
+(byte) bitmap_plot::y#2 1001.0
+(byte) bitmap_plot::y#3 100001.0
+(byte) bitmap_plot::y#4 2201005.0
 (byte*) bitmap_screen
 (void()) main()
 (void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num)
 (byte) memset::c
-(byte) memset::c#4 1.375
+(byte) memset::c#4 1250.125
 (byte*) memset::dst
-(byte*) memset::dst#1 22.0
-(byte*) memset::dst#2 15.333333333333332
-(byte*) memset::dst#4 4.0
+(byte*) memset::dst#1 20002.0
+(byte*) memset::dst#2 13668.333333333332
+(byte*) memset::dst#4 2002.0
 (byte*) memset::end
-(byte*) memset::end#0 2.1666666666666665
+(byte*) memset::end#0 1833.6666666666665
 (word) memset::num
-(word) memset::num#2 2.0
+(word) memset::num#2 1001.0
 (void*) memset::return
 (void*) memset::str
 (void*) memset::str#3
 (word) next
-(word) next#1 11.0
-(word) next#3 22.0
-(word) next#5 11.0
+(word) next#1 101.0
+(word) next#3 202.0
+(word) next#5 101.0
 (word()) sgn_u16((word) sgn_u16::w)
-(byte~) sgn_u16::$0 4.0
-(byte~) sgn_u16::$1 4.0
+(byte~) sgn_u16::$0 20002.0
+(byte~) sgn_u16::$1 20002.0
 (word) sgn_u16::return
-(word) sgn_u16::return#0 4.0
-(word) sgn_u16::return#1 4.0
-(word) sgn_u16::return#4 1.0
+(word) sgn_u16::return#0 2002.0
+(word) sgn_u16::return#1 2002.0
+(word) sgn_u16::return#4 500.5
 (word) sgn_u16::w
-(word) sgn_u16::w#0 4.0
-(word) sgn_u16::w#2 4.0
+(word) sgn_u16::w#0 2002.0
+(word) sgn_u16::w#2 11002.0
 
 Initial phi equivalence classes
 [ next#5 next#3 next#1 ]
@@ -3083,117 +3083,111 @@ bitmap_init: {
 
 REGISTER UPLIFT POTENTIAL REGISTERS
 Equivalence Class zp[1]:65 [ bitmap_init::$4 ] has ALU potential.
-Statement [4] *((const byte*) BORDERCOL) ← (byte) 0 [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [5] *((const byte*) BGCOL) ← (byte) 0 [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [6] *((const byte*) D011) ← (const byte) VIC_BMM|(const byte) VIC_DEN|(const byte) VIC_RSEL|(byte) 3 [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [7] *((const byte*) VIC_MEMORY) ← (byte)(word)(const byte*) SCREEN&(word) $3fff/(byte) $40|(word)(const byte*) BITMAP&(word) $3fff/(word) $400 [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [12] (word) bitmap_line::x2#0 ← (word) next#5 [ next#5 bitmap_line::x2#0 ] ( main:2 [ next#5 bitmap_line::x2#0 ] ) always clobbers reg byte a 
-Statement [15] if((word) next#1!=(word) $140) goto main::@5 [ next#1 ] ( main:2 [ next#1 ] ) always clobbers reg byte a 
-Statement [18] (word) abs_u16::w#0 ← (word) bitmap_line::x2#0 [ bitmap_line::x2#0 abs_u16::w#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 abs_u16::w#0 ] ) always clobbers reg byte a 
-Statement [20] (word) abs_u16::return#0 ← (word) abs_u16::return#4 [ bitmap_line::x2#0 abs_u16::return#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 abs_u16::return#0 ] ) always clobbers reg byte a 
-Statement [21] (word) bitmap_line::dx#0 ← (word) abs_u16::return#0 [ bitmap_line::x2#0 bitmap_line::dx#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 ] ) always clobbers reg byte a 
-Statement [23] (word) abs_u16::return#1 ← (word) abs_u16::return#4 [ bitmap_line::x2#0 bitmap_line::dx#0 abs_u16::return#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 abs_u16::return#1 ] ) always clobbers reg byte a 
-Statement [24] (word) bitmap_line::dy#0 ← (word) abs_u16::return#1 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 ] ) always clobbers reg byte a 
-Statement [25] if((word) bitmap_line::dx#0!=(byte) 0) goto bitmap_line::@1 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 ] ) always clobbers reg byte a 
-Statement [26] if((word) bitmap_line::dy#0==(byte) 0) goto bitmap_line::@4 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 ] ) always clobbers reg byte a 
-Statement [27] (word) sgn_u16::w#0 ← (word) bitmap_line::x2#0 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 sgn_u16::w#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 sgn_u16::w#0 ] ) always clobbers reg byte a 
-Statement [29] (word) sgn_u16::return#0 ← (word) sgn_u16::return#4 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 sgn_u16::return#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 sgn_u16::return#0 ] ) always clobbers reg byte a 
-Statement [30] (word) bitmap_line::sx#0 ← (word) sgn_u16::return#0 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 ] ) always clobbers reg byte a 
-Statement [32] (word) sgn_u16::return#1 ← (word) sgn_u16::return#4 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 sgn_u16::return#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 sgn_u16::return#1 ] ) always clobbers reg byte a 
-Statement [33] (word) bitmap_line::sy#0 ← (word) sgn_u16::return#1 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 ] ) always clobbers reg byte a 
-Statement [34] if((word) bitmap_line::dx#0>(word) bitmap_line::dy#0) goto bitmap_line::@2 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 ] ) always clobbers reg byte a 
-Statement [35] (word) bitmap_line::e#0 ← (word) bitmap_line::dx#0 >> (byte) 1 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::e#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::e#0 ] ) always clobbers reg byte a 
-Statement [37] (byte) bitmap_plot::y#1 ← (byte)(word) bitmap_line::y#4 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#4 bitmap_line::x#13 bitmap_line::e#3 bitmap_plot::y#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#4 bitmap_line::x#13 bitmap_line::e#3 bitmap_plot::y#1 ] ) always clobbers reg byte a 
-Statement [38] (word) bitmap_plot::x#1 ← (word) bitmap_line::x#13 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#4 bitmap_line::x#13 bitmap_line::e#3 bitmap_plot::y#1 bitmap_plot::x#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#4 bitmap_line::x#13 bitmap_line::e#3 bitmap_plot::y#1 bitmap_plot::x#1 ] ) always clobbers reg byte a 
+Statement [4] *((const byte*) BORDERCOL) ← (byte) 0 [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [5] *((const byte*) BGCOL) ← (byte) 0 [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [6] *((const byte*) D011) ← (const byte) VIC_BMM|(const byte) VIC_DEN|(const byte) VIC_RSEL|(byte) 3 [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [7] *((const byte*) VIC_MEMORY) ← (byte)(word)(const byte*) SCREEN&(word) $3fff/(byte) $40|(word)(const byte*) BITMAP&(word) $3fff/(word) $400 [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [12] (word) bitmap_line::x2#0 ← (word) next#5 [ next#5 bitmap_line::x2#0 ] ( main:2 [ next#5 bitmap_line::x2#0 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [15] if((word) next#1!=(word) $140) goto main::@5 [ next#1 ] ( main:2 [ next#1 ] { }  ) always clobbers reg byte a 
+Statement [18] (word) abs_u16::w#0 ← (word) bitmap_line::x2#0 [ bitmap_line::x2#0 abs_u16::w#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 abs_u16::w#0 ] { { abs_u16::w#0 = abs_u16::w#2 bitmap_line::x2#0 next#5 } { abs_u16::return#0 = abs_u16::return#4 } }  ) always clobbers reg byte a 
+Statement [20] (word) abs_u16::return#0 ← (word) abs_u16::return#4 [ bitmap_line::x2#0 abs_u16::return#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 abs_u16::return#0 ] { { abs_u16::w#0 = abs_u16::w#2 bitmap_line::x2#0 next#5 } { abs_u16::return#0 = abs_u16::return#4 } }  ) always clobbers reg byte a 
+Statement [21] (word) bitmap_line::dx#0 ← (word) abs_u16::return#0 [ bitmap_line::x2#0 bitmap_line::dx#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 ] { { next#5 = bitmap_line::x2#0 } { abs_u16::return#1 = abs_u16::return#4 } }  ) always clobbers reg byte a 
+Statement [23] (word) abs_u16::return#1 ← (word) abs_u16::return#4 [ bitmap_line::x2#0 bitmap_line::dx#0 abs_u16::return#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 abs_u16::return#1 ] { { next#5 = bitmap_line::x2#0 } { abs_u16::return#1 = abs_u16::return#4 } }  ) always clobbers reg byte a 
+Statement [24] (word) bitmap_line::dy#0 ← (word) abs_u16::return#1 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [25] if((word) bitmap_line::dx#0!=(byte) 0) goto bitmap_line::@1 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [26] if((word) bitmap_line::dy#0==(byte) 0) goto bitmap_line::@4 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [27] (word) sgn_u16::w#0 ← (word) bitmap_line::x2#0 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 sgn_u16::w#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 sgn_u16::w#0 ] { { sgn_u16::w#0 = sgn_u16::w#2 bitmap_line::x2#0 next#5 } { sgn_u16::return#0 = sgn_u16::return#4 } }  ) always clobbers reg byte a 
+Statement [29] (word) sgn_u16::return#0 ← (word) sgn_u16::return#4 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 sgn_u16::return#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 sgn_u16::return#0 ] { { sgn_u16::w#0 = sgn_u16::w#2 bitmap_line::x2#0 next#5 } { sgn_u16::return#0 = sgn_u16::return#4 } }  ) always clobbers reg byte a 
+Statement [30] (word) bitmap_line::sx#0 ← (word) sgn_u16::return#0 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 ] { { next#5 = bitmap_line::x2#0 } { sgn_u16::return#1 = sgn_u16::return#4 } }  ) always clobbers reg byte a 
+Statement [32] (word) sgn_u16::return#1 ← (word) sgn_u16::return#4 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 sgn_u16::return#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 sgn_u16::return#1 ] { { next#5 = bitmap_line::x2#0 } { sgn_u16::return#1 = sgn_u16::return#4 } }  ) always clobbers reg byte a 
+Statement [33] (word) bitmap_line::sy#0 ← (word) sgn_u16::return#1 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [34] if((word) bitmap_line::dx#0>(word) bitmap_line::dy#0) goto bitmap_line::@2 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [35] (word) bitmap_line::e#0 ← (word) bitmap_line::dx#0 >> (byte) 1 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::e#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::e#0 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [37] (byte) bitmap_plot::y#1 ← (byte)(word) bitmap_line::y#4 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#4 bitmap_line::x#13 bitmap_line::e#3 bitmap_plot::y#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#4 bitmap_line::x#13 bitmap_line::e#3 bitmap_plot::y#1 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#1 = bitmap_plot::y#4 } { bitmap_plot::x#1 = bitmap_plot::x#4 bitmap_line::x#13 } }  ) always clobbers reg byte a 
+Statement [38] (word) bitmap_plot::x#1 ← (word) bitmap_line::x#13 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#4 bitmap_line::x#13 bitmap_line::e#3 bitmap_plot::y#1 bitmap_plot::x#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#4 bitmap_line::x#13 bitmap_line::e#3 bitmap_plot::y#1 bitmap_plot::x#1 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#1 = bitmap_plot::y#4 } { bitmap_plot::x#1 = bitmap_plot::x#4 bitmap_line::x#13 } }  ) always clobbers reg byte a 
 Removing always clobbered register reg byte a as potential for zp[1]:12 [ bitmap_plot::y#4 bitmap_plot::y#3 bitmap_plot::y#2 bitmap_plot::y#1 ]
-Statement [40] (word) bitmap_line::y#1 ← (word) bitmap_line::y#4 + (word) bitmap_line::sy#0 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#13 bitmap_line::e#3 bitmap_line::y#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#13 bitmap_line::e#3 bitmap_line::y#1 ] ) always clobbers reg byte a 
-Statement [41] (word) bitmap_line::e#1 ← (word) bitmap_line::e#3 + (word) bitmap_line::dx#0 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#13 bitmap_line::y#1 bitmap_line::e#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#13 bitmap_line::y#1 bitmap_line::e#1 ] ) always clobbers reg byte a 
-Statement [42] if((word) bitmap_line::dy#0>=(word) bitmap_line::e#1) goto bitmap_line::@7 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#13 bitmap_line::y#1 bitmap_line::e#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#13 bitmap_line::y#1 bitmap_line::e#1 ] ) always clobbers reg byte a 
-Statement [43] (word) bitmap_line::x#1 ← (word) bitmap_line::x#13 + (word) bitmap_line::sx#0 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#1 bitmap_line::e#1 bitmap_line::x#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#1 bitmap_line::e#1 bitmap_line::x#1 ] ) always clobbers reg byte a 
-Statement [44] (word) bitmap_line::e#2 ← (word) bitmap_line::e#1 - (word) bitmap_line::dy#0 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#1 bitmap_line::x#1 bitmap_line::e#2 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#1 bitmap_line::x#1 bitmap_line::e#2 ] ) always clobbers reg byte a 
-Statement [46] if((word) bitmap_line::y#1!=(const word) bitmap_line::y2#0) goto bitmap_line::@6 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#1 bitmap_line::x#12 bitmap_line::e#6 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#1 bitmap_line::x#12 bitmap_line::e#6 ] ) always clobbers reg byte a 
-Statement [48] (byte) bitmap_plot::y#2 ← (byte)(word) bitmap_line::y#7 [ bitmap_line::x#6 bitmap_plot::y#2 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x#6 bitmap_plot::y#2 ] ) always clobbers reg byte a 
-Statement [49] (word) bitmap_plot::x#2 ← (word) bitmap_line::x#6 [ bitmap_plot::y#2 bitmap_plot::x#2 ] ( main:2::bitmap_line:13 [ next#5 bitmap_plot::y#2 bitmap_plot::x#2 ] ) always clobbers reg byte a 
-Statement [52] (word) bitmap_line::e1#0 ← (word) bitmap_line::dy#0 >> (byte) 1 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::e1#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::e1#0 ] ) always clobbers reg byte a 
-Statement [54] (byte) bitmap_plot::y#3 ← (byte)(word) bitmap_line::y#15 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#15 bitmap_line::x#7 bitmap_line::e1#3 bitmap_plot::y#3 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#15 bitmap_line::x#7 bitmap_line::e1#3 bitmap_plot::y#3 ] ) always clobbers reg byte a 
-Statement [55] (word) bitmap_plot::x#3 ← (word) bitmap_line::x#7 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#15 bitmap_line::x#7 bitmap_line::e1#3 bitmap_plot::y#3 bitmap_plot::x#3 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#15 bitmap_line::x#7 bitmap_line::e1#3 bitmap_plot::y#3 bitmap_plot::x#3 ] ) always clobbers reg byte a 
-Statement [57] (word) bitmap_line::x#15 ← (word) bitmap_line::x#7 + (word) bitmap_line::sx#0 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::y#15 bitmap_line::e1#3 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::y#15 bitmap_line::e1#3 ] ) always clobbers reg byte a 
-Statement [58] (word) bitmap_line::e1#1 ← (word) bitmap_line::e1#3 + (word) bitmap_line::dy#0 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::y#15 bitmap_line::e1#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::y#15 bitmap_line::e1#1 ] ) always clobbers reg byte a 
-Statement [59] if((word) bitmap_line::dx#0>=(word) bitmap_line::e1#1) goto bitmap_line::@10 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::y#15 bitmap_line::e1#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::y#15 bitmap_line::e1#1 ] ) always clobbers reg byte a 
-Statement [60] (word) bitmap_line::y#2 ← (word) bitmap_line::y#15 + (word) bitmap_line::sy#0 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::e1#1 bitmap_line::y#2 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::e1#1 bitmap_line::y#2 ] ) always clobbers reg byte a 
-Statement [61] (word) bitmap_line::e1#2 ← (word) bitmap_line::e1#1 - (word) bitmap_line::dx#0 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::y#2 bitmap_line::e1#2 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::y#2 bitmap_line::e1#2 ] ) always clobbers reg byte a 
-Statement [63] if((word) bitmap_line::x#15!=(word) bitmap_line::x2#0) goto bitmap_line::@9 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#13 bitmap_line::x#15 bitmap_line::e1#6 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#13 bitmap_line::x#15 bitmap_line::e1#6 ] ) always clobbers reg byte a 
-Statement [67] (word) bitmap_plot::plotter#0 ← *((const byte*) bitmap_plot_yhi + (byte) bitmap_plot::y#4) w= *((const byte*) bitmap_plot_ylo + (byte) bitmap_plot::y#4) [ bitmap_plot::x#4 bitmap_plot::plotter#0 ] ( main:2::bitmap_line:13::bitmap_plot:39 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#4 bitmap_line::x#13 bitmap_line::e#3 bitmap_plot::x#4 bitmap_plot::plotter#0 ] main:2::bitmap_line:13::bitmap_plot:50 [ next#5 bitmap_plot::x#4 bitmap_plot::plotter#0 ] main:2::bitmap_line:13::bitmap_plot:56 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#15 bitmap_line::x#7 bitmap_line::e1#3 bitmap_plot::x#4 bitmap_plot::plotter#0 ] main:2::bitmap_line:13::bitmap_plot:65 [ next#5 bitmap_plot::x#4 bitmap_plot::plotter#0 ] ) always clobbers reg byte a 
-Statement [68] (word~) bitmap_plot::$1 ← (word) bitmap_plot::x#4 & (word) $fff8 [ bitmap_plot::x#4 bitmap_plot::plotter#0 bitmap_plot::$1 ] ( main:2::bitmap_line:13::bitmap_plot:39 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#4 bitmap_line::x#13 bitmap_line::e#3 bitmap_plot::x#4 bitmap_plot::plotter#0 bitmap_plot::$1 ] main:2::bitmap_line:13::bitmap_plot:50 [ next#5 bitmap_plot::x#4 bitmap_plot::plotter#0 bitmap_plot::$1 ] main:2::bitmap_line:13::bitmap_plot:56 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#15 bitmap_line::x#7 bitmap_line::e1#3 bitmap_plot::x#4 bitmap_plot::plotter#0 bitmap_plot::$1 ] main:2::bitmap_line:13::bitmap_plot:65 [ next#5 bitmap_plot::x#4 bitmap_plot::plotter#0 bitmap_plot::$1 ] ) always clobbers reg byte a 
-Statement [69] (byte*) bitmap_plot::plotter#1 ← (byte*)(word) bitmap_plot::plotter#0 + (word~) bitmap_plot::$1 [ bitmap_plot::x#4 bitmap_plot::plotter#1 ] ( main:2::bitmap_line:13::bitmap_plot:39 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#4 bitmap_line::x#13 bitmap_line::e#3 bitmap_plot::x#4 bitmap_plot::plotter#1 ] main:2::bitmap_line:13::bitmap_plot:50 [ next#5 bitmap_plot::x#4 bitmap_plot::plotter#1 ] main:2::bitmap_line:13::bitmap_plot:56 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#15 bitmap_line::x#7 bitmap_line::e1#3 bitmap_plot::x#4 bitmap_plot::plotter#1 ] main:2::bitmap_line:13::bitmap_plot:65 [ next#5 bitmap_plot::x#4 bitmap_plot::plotter#1 ] ) always clobbers reg byte a 
-Statement [70] (byte~) bitmap_plot::$2 ← < (word) bitmap_plot::x#4 [ bitmap_plot::plotter#1 bitmap_plot::$2 ] ( main:2::bitmap_line:13::bitmap_plot:39 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#4 bitmap_line::x#13 bitmap_line::e#3 bitmap_plot::plotter#1 bitmap_plot::$2 ] main:2::bitmap_line:13::bitmap_plot:50 [ next#5 bitmap_plot::plotter#1 bitmap_plot::$2 ] main:2::bitmap_line:13::bitmap_plot:56 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#15 bitmap_line::x#7 bitmap_line::e1#3 bitmap_plot::plotter#1 bitmap_plot::$2 ] main:2::bitmap_line:13::bitmap_plot:65 [ next#5 bitmap_plot::plotter#1 bitmap_plot::$2 ] ) always clobbers reg byte a 
-Statement [71] *((byte*) bitmap_plot::plotter#1) ← *((byte*) bitmap_plot::plotter#1) | *((const byte*) bitmap_plot_bit + (byte~) bitmap_plot::$2) [ ] ( main:2::bitmap_line:13::bitmap_plot:39 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#4 bitmap_line::x#13 bitmap_line::e#3 ] main:2::bitmap_line:13::bitmap_plot:50 [ next#5 ] main:2::bitmap_line:13::bitmap_plot:56 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#15 bitmap_line::x#7 bitmap_line::e1#3 ] main:2::bitmap_line:13::bitmap_plot:65 [ next#5 ] ) always clobbers reg byte a reg byte y 
-Statement [74] (byte~) sgn_u16::$0 ← > (word) sgn_u16::w#2 [ sgn_u16::$0 ] ( main:2::bitmap_line:13::sgn_u16:28 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 sgn_u16::$0 ] main:2::bitmap_line:13::sgn_u16:31 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 sgn_u16::$0 ] ) always clobbers reg byte a 
-Statement [81] (byte~) abs_u16::$0 ← > (word) abs_u16::w#2 [ abs_u16::w#2 abs_u16::$0 ] ( main:2::bitmap_line:13::abs_u16:19 [ next#5 bitmap_line::x2#0 abs_u16::w#2 abs_u16::$0 ] main:2::bitmap_line:13::abs_u16:22 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 abs_u16::w#2 abs_u16::$0 ] ) always clobbers reg byte a 
-Statement [84] (word) abs_u16::return#2 ← - (word) abs_u16::w#2 [ abs_u16::return#2 ] ( main:2::bitmap_line:13::abs_u16:19 [ next#5 bitmap_line::x2#0 abs_u16::return#2 ] main:2::bitmap_line:13::abs_u16:22 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 abs_u16::return#2 ] ) always clobbers reg byte a 
-Statement [93] if((word) memset::num#2<=(byte) 0) goto memset::@return [ memset::num#2 memset::str#3 memset::c#4 ] ( main:2::bitmap_clear:10::memset:88 [ memset::num#2 memset::str#3 memset::c#4 ] main:2::bitmap_clear:10::memset:90 [ memset::num#2 memset::str#3 memset::c#4 ] ) always clobbers reg byte a 
+Statement [40] (word) bitmap_line::y#1 ← (word) bitmap_line::y#4 + (word) bitmap_line::sy#0 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#13 bitmap_line::e#3 bitmap_line::y#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#13 bitmap_line::e#3 bitmap_line::y#1 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [41] (word) bitmap_line::e#1 ← (word) bitmap_line::e#3 + (word) bitmap_line::dx#0 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#13 bitmap_line::y#1 bitmap_line::e#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#13 bitmap_line::y#1 bitmap_line::e#1 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [42] if((word) bitmap_line::dy#0>=(word) bitmap_line::e#1) goto bitmap_line::@7 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#13 bitmap_line::y#1 bitmap_line::e#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#13 bitmap_line::y#1 bitmap_line::e#1 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [43] (word) bitmap_line::x#1 ← (word) bitmap_line::x#13 + (word) bitmap_line::sx#0 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#1 bitmap_line::e#1 bitmap_line::x#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#1 bitmap_line::e#1 bitmap_line::x#1 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [44] (word) bitmap_line::e#2 ← (word) bitmap_line::e#1 - (word) bitmap_line::dy#0 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#1 bitmap_line::x#1 bitmap_line::e#2 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#1 bitmap_line::x#1 bitmap_line::e#2 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [46] if((word) bitmap_line::y#1!=(const word) bitmap_line::y2#0) goto bitmap_line::@6 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#1 bitmap_line::x#12 bitmap_line::e#6 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#1 bitmap_line::x#12 bitmap_line::e#6 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [48] (byte) bitmap_plot::y#2 ← (byte)(word) bitmap_line::y#7 [ bitmap_line::x#6 bitmap_plot::y#2 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x#6 bitmap_plot::y#2 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#2 = bitmap_plot::y#4 } { bitmap_plot::x#2 = bitmap_plot::x#4 bitmap_line::x#6 } }  ) always clobbers reg byte a 
+Statement [49] (word) bitmap_plot::x#2 ← (word) bitmap_line::x#6 [ bitmap_plot::y#2 bitmap_plot::x#2 ] ( main:2::bitmap_line:13 [ next#5 bitmap_plot::y#2 bitmap_plot::x#2 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#2 = bitmap_plot::y#4 } { bitmap_plot::x#2 = bitmap_plot::x#4 bitmap_line::x#6 } }  ) always clobbers reg byte a 
+Statement [52] (word) bitmap_line::e1#0 ← (word) bitmap_line::dy#0 >> (byte) 1 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::e1#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::e1#0 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [54] (byte) bitmap_plot::y#3 ← (byte)(word) bitmap_line::y#15 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#15 bitmap_line::x#7 bitmap_line::e1#3 bitmap_plot::y#3 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#15 bitmap_line::x#7 bitmap_line::e1#3 bitmap_plot::y#3 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#3 = bitmap_plot::y#4 } { bitmap_plot::x#3 = bitmap_plot::x#4 bitmap_line::x#7 } }  ) always clobbers reg byte a 
+Statement [55] (word) bitmap_plot::x#3 ← (word) bitmap_line::x#7 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#15 bitmap_line::x#7 bitmap_line::e1#3 bitmap_plot::y#3 bitmap_plot::x#3 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#15 bitmap_line::x#7 bitmap_line::e1#3 bitmap_plot::y#3 bitmap_plot::x#3 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#3 = bitmap_plot::y#4 } { bitmap_plot::x#3 = bitmap_plot::x#4 bitmap_line::x#7 } }  ) always clobbers reg byte a 
+Statement [57] (word) bitmap_line::x#15 ← (word) bitmap_line::x#7 + (word) bitmap_line::sx#0 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::y#15 bitmap_line::e1#3 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::y#15 bitmap_line::e1#3 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [58] (word) bitmap_line::e1#1 ← (word) bitmap_line::e1#3 + (word) bitmap_line::dy#0 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::y#15 bitmap_line::e1#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::y#15 bitmap_line::e1#1 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [59] if((word) bitmap_line::dx#0>=(word) bitmap_line::e1#1) goto bitmap_line::@10 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::y#15 bitmap_line::e1#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::y#15 bitmap_line::e1#1 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [60] (word) bitmap_line::y#2 ← (word) bitmap_line::y#15 + (word) bitmap_line::sy#0 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::e1#1 bitmap_line::y#2 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::e1#1 bitmap_line::y#2 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [61] (word) bitmap_line::e1#2 ← (word) bitmap_line::e1#1 - (word) bitmap_line::dx#0 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::y#2 bitmap_line::e1#2 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::y#2 bitmap_line::e1#2 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [63] if((word) bitmap_line::x#15!=(word) bitmap_line::x2#0) goto bitmap_line::@9 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#13 bitmap_line::x#15 bitmap_line::e1#6 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#13 bitmap_line::x#15 bitmap_line::e1#6 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [67] (word) bitmap_plot::plotter#0 ← *((const byte*) bitmap_plot_yhi + (byte) bitmap_plot::y#4) w= *((const byte*) bitmap_plot_ylo + (byte) bitmap_plot::y#4) [ bitmap_plot::x#4 bitmap_plot::plotter#0 ] ( main:2::bitmap_line:13::bitmap_plot:39 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#4 bitmap_line::x#13 bitmap_line::e#3 bitmap_plot::x#4 bitmap_plot::plotter#0 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#1 = bitmap_plot::y#4 } { bitmap_plot::x#1 = bitmap_plot::x#4 bitmap_line::x#13 } }  main:2::bitmap_line:13::bitmap_plot:50 [ next#5 bitmap_plot::x#4 bitmap_plot::plotter#0 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#2 = bitmap_plot::y#4 } { bitmap_plot::x#2 = bitmap_plot::x#4 bitmap_line::x#6 } }  main:2::bitmap_line:13::bitmap_plot:56 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#15 bitmap_line::x#7 bitmap_line::e1#3 bitmap_plot::x#4 bitmap_plot::plotter#0 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#3 = bitmap_plot::y#4 } { bitmap_plot::x#3 = bitmap_plot::x#4 bitmap_line::x#7 } }  main:2::bitmap_line:13::bitmap_plot:65 [ next#5 bitmap_plot::x#4 bitmap_plot::plotter#0 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [68] (word~) bitmap_plot::$1 ← (word) bitmap_plot::x#4 & (word) $fff8 [ bitmap_plot::x#4 bitmap_plot::plotter#0 bitmap_plot::$1 ] ( main:2::bitmap_line:13::bitmap_plot:39 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#4 bitmap_line::x#13 bitmap_line::e#3 bitmap_plot::x#4 bitmap_plot::plotter#0 bitmap_plot::$1 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#1 = bitmap_plot::y#4 } { bitmap_plot::x#1 = bitmap_plot::x#4 bitmap_line::x#13 } }  main:2::bitmap_line:13::bitmap_plot:50 [ next#5 bitmap_plot::x#4 bitmap_plot::plotter#0 bitmap_plot::$1 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#2 = bitmap_plot::y#4 } { bitmap_plot::x#2 = bitmap_plot::x#4 bitmap_line::x#6 } }  main:2::bitmap_line:13::bitmap_plot:56 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#15 bitmap_line::x#7 bitmap_line::e1#3 bitmap_plot::x#4 bitmap_plot::plotter#0 bitmap_plot::$1 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#3 = bitmap_plot::y#4 } { bitmap_plot::x#3 = bitmap_plot::x#4 bitmap_line::x#7 } }  main:2::bitmap_line:13::bitmap_plot:65 [ next#5 bitmap_plot::x#4 bitmap_plot::plotter#0 bitmap_plot::$1 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [69] (byte*) bitmap_plot::plotter#1 ← (byte*)(word) bitmap_plot::plotter#0 + (word~) bitmap_plot::$1 [ bitmap_plot::x#4 bitmap_plot::plotter#1 ] ( main:2::bitmap_line:13::bitmap_plot:39 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#4 bitmap_line::x#13 bitmap_line::e#3 bitmap_plot::x#4 bitmap_plot::plotter#1 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#1 = bitmap_plot::y#4 } { bitmap_plot::x#1 = bitmap_plot::x#4 bitmap_line::x#13 } }  main:2::bitmap_line:13::bitmap_plot:50 [ next#5 bitmap_plot::x#4 bitmap_plot::plotter#1 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#2 = bitmap_plot::y#4 } { bitmap_plot::x#2 = bitmap_plot::x#4 bitmap_line::x#6 } }  main:2::bitmap_line:13::bitmap_plot:56 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#15 bitmap_line::x#7 bitmap_line::e1#3 bitmap_plot::x#4 bitmap_plot::plotter#1 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#3 = bitmap_plot::y#4 } { bitmap_plot::x#3 = bitmap_plot::x#4 bitmap_line::x#7 } }  main:2::bitmap_line:13::bitmap_plot:65 [ next#5 bitmap_plot::x#4 bitmap_plot::plotter#1 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [71] *((byte*) bitmap_plot::plotter#1) ← *((byte*) bitmap_plot::plotter#1) | *((const byte*) bitmap_plot_bit + (byte~) bitmap_plot::$2) [ ] ( main:2::bitmap_line:13::bitmap_plot:39 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#4 bitmap_line::x#13 bitmap_line::e#3 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#1 = bitmap_plot::y#4 } { bitmap_plot::x#1 = bitmap_plot::x#4 bitmap_line::x#13 } }  main:2::bitmap_line:13::bitmap_plot:50 [ next#5 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#2 = bitmap_plot::y#4 } { bitmap_plot::x#2 = bitmap_plot::x#4 bitmap_line::x#6 } }  main:2::bitmap_line:13::bitmap_plot:56 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#15 bitmap_line::x#7 bitmap_line::e1#3 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#3 = bitmap_plot::y#4 } { bitmap_plot::x#3 = bitmap_plot::x#4 bitmap_line::x#7 } }  main:2::bitmap_line:13::bitmap_plot:65 [ next#5 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a reg byte y 
+Statement [84] (word) abs_u16::return#2 ← - (word) abs_u16::w#2 [ abs_u16::return#2 ] ( main:2::bitmap_line:13::abs_u16:19 [ next#5 bitmap_line::x2#0 abs_u16::return#2 ] { { abs_u16::w#0 = abs_u16::w#2 bitmap_line::x2#0 next#5 } { abs_u16::return#0 = abs_u16::return#4 } }  main:2::bitmap_line:13::abs_u16:22 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 abs_u16::return#2 ] { { next#5 = bitmap_line::x2#0 } { abs_u16::return#1 = abs_u16::return#4 } }  ) always clobbers reg byte a 
+Statement [93] if((word) memset::num#2<=(byte) 0) goto memset::@return [ memset::num#2 memset::str#3 memset::c#4 ] ( main:2::bitmap_clear:10::memset:88 [ memset::num#2 memset::str#3 memset::c#4 ] { }  main:2::bitmap_clear:10::memset:90 [ memset::num#2 memset::str#3 memset::c#4 ] { }  ) always clobbers reg byte a 
 Removing always clobbered register reg byte a as potential for zp[1]:25 [ memset::c#4 ]
-Statement [94] (byte*) memset::end#0 ← (byte*)(void*) memset::str#3 + (word) memset::num#2 [ memset::str#3 memset::c#4 memset::end#0 ] ( main:2::bitmap_clear:10::memset:88 [ memset::str#3 memset::c#4 memset::end#0 ] main:2::bitmap_clear:10::memset:90 [ memset::str#3 memset::c#4 memset::end#0 ] ) always clobbers reg byte a 
-Statement [95] (byte*) memset::dst#4 ← (byte*)(void*) memset::str#3 [ memset::c#4 memset::end#0 memset::dst#4 ] ( main:2::bitmap_clear:10::memset:88 [ memset::c#4 memset::end#0 memset::dst#4 ] main:2::bitmap_clear:10::memset:90 [ memset::c#4 memset::end#0 memset::dst#4 ] ) always clobbers reg byte a 
-Statement [97] if((byte*) memset::dst#2!=(byte*) memset::end#0) goto memset::@3 [ memset::c#4 memset::end#0 memset::dst#2 ] ( main:2::bitmap_clear:10::memset:88 [ memset::c#4 memset::end#0 memset::dst#2 ] main:2::bitmap_clear:10::memset:90 [ memset::c#4 memset::end#0 memset::dst#2 ] ) always clobbers reg byte a 
-Statement [99] *((byte*) memset::dst#2) ← (byte) memset::c#4 [ memset::c#4 memset::end#0 memset::dst#2 ] ( main:2::bitmap_clear:10::memset:88 [ memset::c#4 memset::end#0 memset::dst#2 ] main:2::bitmap_clear:10::memset:90 [ memset::c#4 memset::end#0 memset::dst#2 ] ) always clobbers reg byte a reg byte y 
+Statement [94] (byte*) memset::end#0 ← (byte*)(void*) memset::str#3 + (word) memset::num#2 [ memset::str#3 memset::c#4 memset::end#0 ] ( main:2::bitmap_clear:10::memset:88 [ memset::str#3 memset::c#4 memset::end#0 ] { }  main:2::bitmap_clear:10::memset:90 [ memset::str#3 memset::c#4 memset::end#0 ] { }  ) always clobbers reg byte a 
+Statement [95] (byte*) memset::dst#4 ← (byte*)(void*) memset::str#3 [ memset::c#4 memset::end#0 memset::dst#4 ] ( main:2::bitmap_clear:10::memset:88 [ memset::c#4 memset::end#0 memset::dst#4 ] { }  main:2::bitmap_clear:10::memset:90 [ memset::c#4 memset::end#0 memset::dst#4 ] { }  ) always clobbers reg byte a 
+Statement [97] if((byte*) memset::dst#2!=(byte*) memset::end#0) goto memset::@3 [ memset::c#4 memset::end#0 memset::dst#2 ] ( main:2::bitmap_clear:10::memset:88 [ memset::c#4 memset::end#0 memset::dst#2 ] { }  main:2::bitmap_clear:10::memset:90 [ memset::c#4 memset::end#0 memset::dst#2 ] { }  ) always clobbers reg byte a 
+Statement [99] *((byte*) memset::dst#2) ← (byte) memset::c#4 [ memset::c#4 memset::end#0 memset::dst#2 ] ( main:2::bitmap_clear:10::memset:88 [ memset::c#4 memset::end#0 memset::dst#2 ] { }  main:2::bitmap_clear:10::memset:90 [ memset::c#4 memset::end#0 memset::dst#2 ] { }  ) always clobbers reg byte a reg byte y 
 Removing always clobbered register reg byte y as potential for zp[1]:25 [ memset::c#4 ]
-Statement [118] (byte*) bitmap_init::yoffs#1 ← (byte*) bitmap_init::yoffs#2 + (word)(number) $28*(number) 8 [ bitmap_init::y#2 bitmap_init::yoffs#1 ] ( main:2::bitmap_init:8 [ bitmap_init::y#2 bitmap_init::yoffs#1 ] ) always clobbers reg byte a 
+Statement [118] (byte*) bitmap_init::yoffs#1 ← (byte*) bitmap_init::yoffs#2 + (word)(number) $28*(number) 8 [ bitmap_init::y#2 bitmap_init::yoffs#1 ] ( main:2::bitmap_init:8 [ bitmap_init::y#2 bitmap_init::yoffs#1 ] { }  ) always clobbers reg byte a 
 Removing always clobbered register reg byte a as potential for zp[1]:30 [ bitmap_init::y#2 bitmap_init::y#1 ]
-Statement [4] *((const byte*) BORDERCOL) ← (byte) 0 [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [5] *((const byte*) BGCOL) ← (byte) 0 [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [6] *((const byte*) D011) ← (const byte) VIC_BMM|(const byte) VIC_DEN|(const byte) VIC_RSEL|(byte) 3 [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [7] *((const byte*) VIC_MEMORY) ← (byte)(word)(const byte*) SCREEN&(word) $3fff/(byte) $40|(word)(const byte*) BITMAP&(word) $3fff/(word) $400 [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [12] (word) bitmap_line::x2#0 ← (word) next#5 [ next#5 bitmap_line::x2#0 ] ( main:2 [ next#5 bitmap_line::x2#0 ] ) always clobbers reg byte a 
-Statement [15] if((word) next#1!=(word) $140) goto main::@5 [ next#1 ] ( main:2 [ next#1 ] ) always clobbers reg byte a 
-Statement [18] (word) abs_u16::w#0 ← (word) bitmap_line::x2#0 [ bitmap_line::x2#0 abs_u16::w#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 abs_u16::w#0 ] ) always clobbers reg byte a 
-Statement [20] (word) abs_u16::return#0 ← (word) abs_u16::return#4 [ bitmap_line::x2#0 abs_u16::return#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 abs_u16::return#0 ] ) always clobbers reg byte a 
-Statement [21] (word) bitmap_line::dx#0 ← (word) abs_u16::return#0 [ bitmap_line::x2#0 bitmap_line::dx#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 ] ) always clobbers reg byte a 
-Statement [23] (word) abs_u16::return#1 ← (word) abs_u16::return#4 [ bitmap_line::x2#0 bitmap_line::dx#0 abs_u16::return#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 abs_u16::return#1 ] ) always clobbers reg byte a 
-Statement [24] (word) bitmap_line::dy#0 ← (word) abs_u16::return#1 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 ] ) always clobbers reg byte a 
-Statement [25] if((word) bitmap_line::dx#0!=(byte) 0) goto bitmap_line::@1 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 ] ) always clobbers reg byte a 
-Statement [26] if((word) bitmap_line::dy#0==(byte) 0) goto bitmap_line::@4 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 ] ) always clobbers reg byte a 
-Statement [27] (word) sgn_u16::w#0 ← (word) bitmap_line::x2#0 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 sgn_u16::w#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 sgn_u16::w#0 ] ) always clobbers reg byte a 
-Statement [29] (word) sgn_u16::return#0 ← (word) sgn_u16::return#4 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 sgn_u16::return#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 sgn_u16::return#0 ] ) always clobbers reg byte a 
-Statement [30] (word) bitmap_line::sx#0 ← (word) sgn_u16::return#0 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 ] ) always clobbers reg byte a 
-Statement [32] (word) sgn_u16::return#1 ← (word) sgn_u16::return#4 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 sgn_u16::return#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 sgn_u16::return#1 ] ) always clobbers reg byte a 
-Statement [33] (word) bitmap_line::sy#0 ← (word) sgn_u16::return#1 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 ] ) always clobbers reg byte a 
-Statement [34] if((word) bitmap_line::dx#0>(word) bitmap_line::dy#0) goto bitmap_line::@2 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 ] ) always clobbers reg byte a 
-Statement [35] (word) bitmap_line::e#0 ← (word) bitmap_line::dx#0 >> (byte) 1 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::e#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::e#0 ] ) always clobbers reg byte a 
-Statement [37] (byte) bitmap_plot::y#1 ← (byte)(word) bitmap_line::y#4 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#4 bitmap_line::x#13 bitmap_line::e#3 bitmap_plot::y#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#4 bitmap_line::x#13 bitmap_line::e#3 bitmap_plot::y#1 ] ) always clobbers reg byte a 
-Statement [38] (word) bitmap_plot::x#1 ← (word) bitmap_line::x#13 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#4 bitmap_line::x#13 bitmap_line::e#3 bitmap_plot::y#1 bitmap_plot::x#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#4 bitmap_line::x#13 bitmap_line::e#3 bitmap_plot::y#1 bitmap_plot::x#1 ] ) always clobbers reg byte a 
-Statement [40] (word) bitmap_line::y#1 ← (word) bitmap_line::y#4 + (word) bitmap_line::sy#0 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#13 bitmap_line::e#3 bitmap_line::y#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#13 bitmap_line::e#3 bitmap_line::y#1 ] ) always clobbers reg byte a 
-Statement [41] (word) bitmap_line::e#1 ← (word) bitmap_line::e#3 + (word) bitmap_line::dx#0 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#13 bitmap_line::y#1 bitmap_line::e#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#13 bitmap_line::y#1 bitmap_line::e#1 ] ) always clobbers reg byte a 
-Statement [42] if((word) bitmap_line::dy#0>=(word) bitmap_line::e#1) goto bitmap_line::@7 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#13 bitmap_line::y#1 bitmap_line::e#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#13 bitmap_line::y#1 bitmap_line::e#1 ] ) always clobbers reg byte a 
-Statement [43] (word) bitmap_line::x#1 ← (word) bitmap_line::x#13 + (word) bitmap_line::sx#0 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#1 bitmap_line::e#1 bitmap_line::x#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#1 bitmap_line::e#1 bitmap_line::x#1 ] ) always clobbers reg byte a 
-Statement [44] (word) bitmap_line::e#2 ← (word) bitmap_line::e#1 - (word) bitmap_line::dy#0 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#1 bitmap_line::x#1 bitmap_line::e#2 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#1 bitmap_line::x#1 bitmap_line::e#2 ] ) always clobbers reg byte a 
-Statement [46] if((word) bitmap_line::y#1!=(const word) bitmap_line::y2#0) goto bitmap_line::@6 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#1 bitmap_line::x#12 bitmap_line::e#6 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#1 bitmap_line::x#12 bitmap_line::e#6 ] ) always clobbers reg byte a 
-Statement [48] (byte) bitmap_plot::y#2 ← (byte)(word) bitmap_line::y#7 [ bitmap_line::x#6 bitmap_plot::y#2 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x#6 bitmap_plot::y#2 ] ) always clobbers reg byte a 
-Statement [49] (word) bitmap_plot::x#2 ← (word) bitmap_line::x#6 [ bitmap_plot::y#2 bitmap_plot::x#2 ] ( main:2::bitmap_line:13 [ next#5 bitmap_plot::y#2 bitmap_plot::x#2 ] ) always clobbers reg byte a 
-Statement [52] (word) bitmap_line::e1#0 ← (word) bitmap_line::dy#0 >> (byte) 1 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::e1#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::e1#0 ] ) always clobbers reg byte a 
-Statement [54] (byte) bitmap_plot::y#3 ← (byte)(word) bitmap_line::y#15 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#15 bitmap_line::x#7 bitmap_line::e1#3 bitmap_plot::y#3 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#15 bitmap_line::x#7 bitmap_line::e1#3 bitmap_plot::y#3 ] ) always clobbers reg byte a 
-Statement [55] (word) bitmap_plot::x#3 ← (word) bitmap_line::x#7 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#15 bitmap_line::x#7 bitmap_line::e1#3 bitmap_plot::y#3 bitmap_plot::x#3 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#15 bitmap_line::x#7 bitmap_line::e1#3 bitmap_plot::y#3 bitmap_plot::x#3 ] ) always clobbers reg byte a 
-Statement [57] (word) bitmap_line::x#15 ← (word) bitmap_line::x#7 + (word) bitmap_line::sx#0 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::y#15 bitmap_line::e1#3 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::y#15 bitmap_line::e1#3 ] ) always clobbers reg byte a 
-Statement [58] (word) bitmap_line::e1#1 ← (word) bitmap_line::e1#3 + (word) bitmap_line::dy#0 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::y#15 bitmap_line::e1#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::y#15 bitmap_line::e1#1 ] ) always clobbers reg byte a 
-Statement [59] if((word) bitmap_line::dx#0>=(word) bitmap_line::e1#1) goto bitmap_line::@10 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::y#15 bitmap_line::e1#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::y#15 bitmap_line::e1#1 ] ) always clobbers reg byte a 
-Statement [60] (word) bitmap_line::y#2 ← (word) bitmap_line::y#15 + (word) bitmap_line::sy#0 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::e1#1 bitmap_line::y#2 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::e1#1 bitmap_line::y#2 ] ) always clobbers reg byte a 
-Statement [61] (word) bitmap_line::e1#2 ← (word) bitmap_line::e1#1 - (word) bitmap_line::dx#0 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::y#2 bitmap_line::e1#2 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::y#2 bitmap_line::e1#2 ] ) always clobbers reg byte a 
-Statement [63] if((word) bitmap_line::x#15!=(word) bitmap_line::x2#0) goto bitmap_line::@9 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#13 bitmap_line::x#15 bitmap_line::e1#6 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#13 bitmap_line::x#15 bitmap_line::e1#6 ] ) always clobbers reg byte a 
-Statement [67] (word) bitmap_plot::plotter#0 ← *((const byte*) bitmap_plot_yhi + (byte) bitmap_plot::y#4) w= *((const byte*) bitmap_plot_ylo + (byte) bitmap_plot::y#4) [ bitmap_plot::x#4 bitmap_plot::plotter#0 ] ( main:2::bitmap_line:13::bitmap_plot:39 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#4 bitmap_line::x#13 bitmap_line::e#3 bitmap_plot::x#4 bitmap_plot::plotter#0 ] main:2::bitmap_line:13::bitmap_plot:50 [ next#5 bitmap_plot::x#4 bitmap_plot::plotter#0 ] main:2::bitmap_line:13::bitmap_plot:56 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#15 bitmap_line::x#7 bitmap_line::e1#3 bitmap_plot::x#4 bitmap_plot::plotter#0 ] main:2::bitmap_line:13::bitmap_plot:65 [ next#5 bitmap_plot::x#4 bitmap_plot::plotter#0 ] ) always clobbers reg byte a 
-Statement [68] (word~) bitmap_plot::$1 ← (word) bitmap_plot::x#4 & (word) $fff8 [ bitmap_plot::x#4 bitmap_plot::plotter#0 bitmap_plot::$1 ] ( main:2::bitmap_line:13::bitmap_plot:39 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#4 bitmap_line::x#13 bitmap_line::e#3 bitmap_plot::x#4 bitmap_plot::plotter#0 bitmap_plot::$1 ] main:2::bitmap_line:13::bitmap_plot:50 [ next#5 bitmap_plot::x#4 bitmap_plot::plotter#0 bitmap_plot::$1 ] main:2::bitmap_line:13::bitmap_plot:56 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#15 bitmap_line::x#7 bitmap_line::e1#3 bitmap_plot::x#4 bitmap_plot::plotter#0 bitmap_plot::$1 ] main:2::bitmap_line:13::bitmap_plot:65 [ next#5 bitmap_plot::x#4 bitmap_plot::plotter#0 bitmap_plot::$1 ] ) always clobbers reg byte a 
-Statement [69] (byte*) bitmap_plot::plotter#1 ← (byte*)(word) bitmap_plot::plotter#0 + (word~) bitmap_plot::$1 [ bitmap_plot::x#4 bitmap_plot::plotter#1 ] ( main:2::bitmap_line:13::bitmap_plot:39 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#4 bitmap_line::x#13 bitmap_line::e#3 bitmap_plot::x#4 bitmap_plot::plotter#1 ] main:2::bitmap_line:13::bitmap_plot:50 [ next#5 bitmap_plot::x#4 bitmap_plot::plotter#1 ] main:2::bitmap_line:13::bitmap_plot:56 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#15 bitmap_line::x#7 bitmap_line::e1#3 bitmap_plot::x#4 bitmap_plot::plotter#1 ] main:2::bitmap_line:13::bitmap_plot:65 [ next#5 bitmap_plot::x#4 bitmap_plot::plotter#1 ] ) always clobbers reg byte a 
-Statement [70] (byte~) bitmap_plot::$2 ← < (word) bitmap_plot::x#4 [ bitmap_plot::plotter#1 bitmap_plot::$2 ] ( main:2::bitmap_line:13::bitmap_plot:39 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#4 bitmap_line::x#13 bitmap_line::e#3 bitmap_plot::plotter#1 bitmap_plot::$2 ] main:2::bitmap_line:13::bitmap_plot:50 [ next#5 bitmap_plot::plotter#1 bitmap_plot::$2 ] main:2::bitmap_line:13::bitmap_plot:56 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#15 bitmap_line::x#7 bitmap_line::e1#3 bitmap_plot::plotter#1 bitmap_plot::$2 ] main:2::bitmap_line:13::bitmap_plot:65 [ next#5 bitmap_plot::plotter#1 bitmap_plot::$2 ] ) always clobbers reg byte a 
-Statement [71] *((byte*) bitmap_plot::plotter#1) ← *((byte*) bitmap_plot::plotter#1) | *((const byte*) bitmap_plot_bit + (byte~) bitmap_plot::$2) [ ] ( main:2::bitmap_line:13::bitmap_plot:39 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#4 bitmap_line::x#13 bitmap_line::e#3 ] main:2::bitmap_line:13::bitmap_plot:50 [ next#5 ] main:2::bitmap_line:13::bitmap_plot:56 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#15 bitmap_line::x#7 bitmap_line::e1#3 ] main:2::bitmap_line:13::bitmap_plot:65 [ next#5 ] ) always clobbers reg byte a reg byte y 
-Statement [74] (byte~) sgn_u16::$0 ← > (word) sgn_u16::w#2 [ sgn_u16::$0 ] ( main:2::bitmap_line:13::sgn_u16:28 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 sgn_u16::$0 ] main:2::bitmap_line:13::sgn_u16:31 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 sgn_u16::$0 ] ) always clobbers reg byte a 
-Statement [81] (byte~) abs_u16::$0 ← > (word) abs_u16::w#2 [ abs_u16::w#2 abs_u16::$0 ] ( main:2::bitmap_line:13::abs_u16:19 [ next#5 bitmap_line::x2#0 abs_u16::w#2 abs_u16::$0 ] main:2::bitmap_line:13::abs_u16:22 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 abs_u16::w#2 abs_u16::$0 ] ) always clobbers reg byte a 
-Statement [84] (word) abs_u16::return#2 ← - (word) abs_u16::w#2 [ abs_u16::return#2 ] ( main:2::bitmap_line:13::abs_u16:19 [ next#5 bitmap_line::x2#0 abs_u16::return#2 ] main:2::bitmap_line:13::abs_u16:22 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 abs_u16::return#2 ] ) always clobbers reg byte a 
-Statement [93] if((word) memset::num#2<=(byte) 0) goto memset::@return [ memset::num#2 memset::str#3 memset::c#4 ] ( main:2::bitmap_clear:10::memset:88 [ memset::num#2 memset::str#3 memset::c#4 ] main:2::bitmap_clear:10::memset:90 [ memset::num#2 memset::str#3 memset::c#4 ] ) always clobbers reg byte a 
-Statement [94] (byte*) memset::end#0 ← (byte*)(void*) memset::str#3 + (word) memset::num#2 [ memset::str#3 memset::c#4 memset::end#0 ] ( main:2::bitmap_clear:10::memset:88 [ memset::str#3 memset::c#4 memset::end#0 ] main:2::bitmap_clear:10::memset:90 [ memset::str#3 memset::c#4 memset::end#0 ] ) always clobbers reg byte a 
-Statement [95] (byte*) memset::dst#4 ← (byte*)(void*) memset::str#3 [ memset::c#4 memset::end#0 memset::dst#4 ] ( main:2::bitmap_clear:10::memset:88 [ memset::c#4 memset::end#0 memset::dst#4 ] main:2::bitmap_clear:10::memset:90 [ memset::c#4 memset::end#0 memset::dst#4 ] ) always clobbers reg byte a 
-Statement [97] if((byte*) memset::dst#2!=(byte*) memset::end#0) goto memset::@3 [ memset::c#4 memset::end#0 memset::dst#2 ] ( main:2::bitmap_clear:10::memset:88 [ memset::c#4 memset::end#0 memset::dst#2 ] main:2::bitmap_clear:10::memset:90 [ memset::c#4 memset::end#0 memset::dst#2 ] ) always clobbers reg byte a 
-Statement [99] *((byte*) memset::dst#2) ← (byte) memset::c#4 [ memset::c#4 memset::end#0 memset::dst#2 ] ( main:2::bitmap_clear:10::memset:88 [ memset::c#4 memset::end#0 memset::dst#2 ] main:2::bitmap_clear:10::memset:90 [ memset::c#4 memset::end#0 memset::dst#2 ] ) always clobbers reg byte a reg byte y 
-Statement [111] (byte~) bitmap_init::$7 ← (byte) bitmap_init::y#2 & (byte) 7 [ bitmap_init::y#2 bitmap_init::yoffs#2 bitmap_init::$7 ] ( main:2::bitmap_init:8 [ bitmap_init::y#2 bitmap_init::yoffs#2 bitmap_init::$7 ] ) always clobbers reg byte a 
-Statement [118] (byte*) bitmap_init::yoffs#1 ← (byte*) bitmap_init::yoffs#2 + (word)(number) $28*(number) 8 [ bitmap_init::y#2 bitmap_init::yoffs#1 ] ( main:2::bitmap_init:8 [ bitmap_init::y#2 bitmap_init::yoffs#1 ] ) always clobbers reg byte a 
+Statement [4] *((const byte*) BORDERCOL) ← (byte) 0 [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [5] *((const byte*) BGCOL) ← (byte) 0 [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [6] *((const byte*) D011) ← (const byte) VIC_BMM|(const byte) VIC_DEN|(const byte) VIC_RSEL|(byte) 3 [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [7] *((const byte*) VIC_MEMORY) ← (byte)(word)(const byte*) SCREEN&(word) $3fff/(byte) $40|(word)(const byte*) BITMAP&(word) $3fff/(word) $400 [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [12] (word) bitmap_line::x2#0 ← (word) next#5 [ next#5 bitmap_line::x2#0 ] ( main:2 [ next#5 bitmap_line::x2#0 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [15] if((word) next#1!=(word) $140) goto main::@5 [ next#1 ] ( main:2 [ next#1 ] { }  ) always clobbers reg byte a 
+Statement [18] (word) abs_u16::w#0 ← (word) bitmap_line::x2#0 [ bitmap_line::x2#0 abs_u16::w#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 abs_u16::w#0 ] { { abs_u16::w#0 = abs_u16::w#2 bitmap_line::x2#0 next#5 } { abs_u16::return#0 = abs_u16::return#4 } }  ) always clobbers reg byte a 
+Statement [20] (word) abs_u16::return#0 ← (word) abs_u16::return#4 [ bitmap_line::x2#0 abs_u16::return#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 abs_u16::return#0 ] { { abs_u16::w#0 = abs_u16::w#2 bitmap_line::x2#0 next#5 } { abs_u16::return#0 = abs_u16::return#4 } }  ) always clobbers reg byte a 
+Statement [21] (word) bitmap_line::dx#0 ← (word) abs_u16::return#0 [ bitmap_line::x2#0 bitmap_line::dx#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 ] { { next#5 = bitmap_line::x2#0 } { abs_u16::return#1 = abs_u16::return#4 } }  ) always clobbers reg byte a 
+Statement [23] (word) abs_u16::return#1 ← (word) abs_u16::return#4 [ bitmap_line::x2#0 bitmap_line::dx#0 abs_u16::return#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 abs_u16::return#1 ] { { next#5 = bitmap_line::x2#0 } { abs_u16::return#1 = abs_u16::return#4 } }  ) always clobbers reg byte a 
+Statement [24] (word) bitmap_line::dy#0 ← (word) abs_u16::return#1 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [25] if((word) bitmap_line::dx#0!=(byte) 0) goto bitmap_line::@1 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [26] if((word) bitmap_line::dy#0==(byte) 0) goto bitmap_line::@4 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [27] (word) sgn_u16::w#0 ← (word) bitmap_line::x2#0 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 sgn_u16::w#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 sgn_u16::w#0 ] { { sgn_u16::w#0 = sgn_u16::w#2 bitmap_line::x2#0 next#5 } { sgn_u16::return#0 = sgn_u16::return#4 } }  ) always clobbers reg byte a 
+Statement [29] (word) sgn_u16::return#0 ← (word) sgn_u16::return#4 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 sgn_u16::return#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 sgn_u16::return#0 ] { { sgn_u16::w#0 = sgn_u16::w#2 bitmap_line::x2#0 next#5 } { sgn_u16::return#0 = sgn_u16::return#4 } }  ) always clobbers reg byte a 
+Statement [30] (word) bitmap_line::sx#0 ← (word) sgn_u16::return#0 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 ] { { next#5 = bitmap_line::x2#0 } { sgn_u16::return#1 = sgn_u16::return#4 } }  ) always clobbers reg byte a 
+Statement [32] (word) sgn_u16::return#1 ← (word) sgn_u16::return#4 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 sgn_u16::return#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 sgn_u16::return#1 ] { { next#5 = bitmap_line::x2#0 } { sgn_u16::return#1 = sgn_u16::return#4 } }  ) always clobbers reg byte a 
+Statement [33] (word) bitmap_line::sy#0 ← (word) sgn_u16::return#1 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [34] if((word) bitmap_line::dx#0>(word) bitmap_line::dy#0) goto bitmap_line::@2 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [35] (word) bitmap_line::e#0 ← (word) bitmap_line::dx#0 >> (byte) 1 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::e#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::e#0 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [37] (byte) bitmap_plot::y#1 ← (byte)(word) bitmap_line::y#4 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#4 bitmap_line::x#13 bitmap_line::e#3 bitmap_plot::y#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#4 bitmap_line::x#13 bitmap_line::e#3 bitmap_plot::y#1 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#1 = bitmap_plot::y#4 } { bitmap_plot::x#1 = bitmap_plot::x#4 bitmap_line::x#13 } }  ) always clobbers reg byte a 
+Statement [38] (word) bitmap_plot::x#1 ← (word) bitmap_line::x#13 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#4 bitmap_line::x#13 bitmap_line::e#3 bitmap_plot::y#1 bitmap_plot::x#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#4 bitmap_line::x#13 bitmap_line::e#3 bitmap_plot::y#1 bitmap_plot::x#1 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#1 = bitmap_plot::y#4 } { bitmap_plot::x#1 = bitmap_plot::x#4 bitmap_line::x#13 } }  ) always clobbers reg byte a 
+Statement [40] (word) bitmap_line::y#1 ← (word) bitmap_line::y#4 + (word) bitmap_line::sy#0 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#13 bitmap_line::e#3 bitmap_line::y#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#13 bitmap_line::e#3 bitmap_line::y#1 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [41] (word) bitmap_line::e#1 ← (word) bitmap_line::e#3 + (word) bitmap_line::dx#0 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#13 bitmap_line::y#1 bitmap_line::e#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#13 bitmap_line::y#1 bitmap_line::e#1 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [42] if((word) bitmap_line::dy#0>=(word) bitmap_line::e#1) goto bitmap_line::@7 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#13 bitmap_line::y#1 bitmap_line::e#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#13 bitmap_line::y#1 bitmap_line::e#1 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [43] (word) bitmap_line::x#1 ← (word) bitmap_line::x#13 + (word) bitmap_line::sx#0 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#1 bitmap_line::e#1 bitmap_line::x#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#1 bitmap_line::e#1 bitmap_line::x#1 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [44] (word) bitmap_line::e#2 ← (word) bitmap_line::e#1 - (word) bitmap_line::dy#0 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#1 bitmap_line::x#1 bitmap_line::e#2 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#1 bitmap_line::x#1 bitmap_line::e#2 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [46] if((word) bitmap_line::y#1!=(const word) bitmap_line::y2#0) goto bitmap_line::@6 [ bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#1 bitmap_line::x#12 bitmap_line::e#6 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#1 bitmap_line::x#12 bitmap_line::e#6 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [48] (byte) bitmap_plot::y#2 ← (byte)(word) bitmap_line::y#7 [ bitmap_line::x#6 bitmap_plot::y#2 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x#6 bitmap_plot::y#2 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#2 = bitmap_plot::y#4 } { bitmap_plot::x#2 = bitmap_plot::x#4 bitmap_line::x#6 } }  ) always clobbers reg byte a 
+Statement [49] (word) bitmap_plot::x#2 ← (word) bitmap_line::x#6 [ bitmap_plot::y#2 bitmap_plot::x#2 ] ( main:2::bitmap_line:13 [ next#5 bitmap_plot::y#2 bitmap_plot::x#2 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#2 = bitmap_plot::y#4 } { bitmap_plot::x#2 = bitmap_plot::x#4 bitmap_line::x#6 } }  ) always clobbers reg byte a 
+Statement [52] (word) bitmap_line::e1#0 ← (word) bitmap_line::dy#0 >> (byte) 1 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::e1#0 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::e1#0 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [54] (byte) bitmap_plot::y#3 ← (byte)(word) bitmap_line::y#15 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#15 bitmap_line::x#7 bitmap_line::e1#3 bitmap_plot::y#3 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#15 bitmap_line::x#7 bitmap_line::e1#3 bitmap_plot::y#3 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#3 = bitmap_plot::y#4 } { bitmap_plot::x#3 = bitmap_plot::x#4 bitmap_line::x#7 } }  ) always clobbers reg byte a 
+Statement [55] (word) bitmap_plot::x#3 ← (word) bitmap_line::x#7 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#15 bitmap_line::x#7 bitmap_line::e1#3 bitmap_plot::y#3 bitmap_plot::x#3 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#15 bitmap_line::x#7 bitmap_line::e1#3 bitmap_plot::y#3 bitmap_plot::x#3 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#3 = bitmap_plot::y#4 } { bitmap_plot::x#3 = bitmap_plot::x#4 bitmap_line::x#7 } }  ) always clobbers reg byte a 
+Statement [57] (word) bitmap_line::x#15 ← (word) bitmap_line::x#7 + (word) bitmap_line::sx#0 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::y#15 bitmap_line::e1#3 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::y#15 bitmap_line::e1#3 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [58] (word) bitmap_line::e1#1 ← (word) bitmap_line::e1#3 + (word) bitmap_line::dy#0 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::y#15 bitmap_line::e1#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::y#15 bitmap_line::e1#1 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [59] if((word) bitmap_line::dx#0>=(word) bitmap_line::e1#1) goto bitmap_line::@10 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::y#15 bitmap_line::e1#1 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::y#15 bitmap_line::e1#1 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [60] (word) bitmap_line::y#2 ← (word) bitmap_line::y#15 + (word) bitmap_line::sy#0 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::e1#1 bitmap_line::y#2 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::e1#1 bitmap_line::y#2 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [61] (word) bitmap_line::e1#2 ← (word) bitmap_line::e1#1 - (word) bitmap_line::dx#0 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::y#2 bitmap_line::e1#2 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::x#15 bitmap_line::y#2 bitmap_line::e1#2 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [63] if((word) bitmap_line::x#15!=(word) bitmap_line::x2#0) goto bitmap_line::@9 [ bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#13 bitmap_line::x#15 bitmap_line::e1#6 ] ( main:2::bitmap_line:13 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#13 bitmap_line::x#15 bitmap_line::e1#6 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [67] (word) bitmap_plot::plotter#0 ← *((const byte*) bitmap_plot_yhi + (byte) bitmap_plot::y#4) w= *((const byte*) bitmap_plot_ylo + (byte) bitmap_plot::y#4) [ bitmap_plot::x#4 bitmap_plot::plotter#0 ] ( main:2::bitmap_line:13::bitmap_plot:39 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#4 bitmap_line::x#13 bitmap_line::e#3 bitmap_plot::x#4 bitmap_plot::plotter#0 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#1 = bitmap_plot::y#4 } { bitmap_plot::x#1 = bitmap_plot::x#4 bitmap_line::x#13 } }  main:2::bitmap_line:13::bitmap_plot:50 [ next#5 bitmap_plot::x#4 bitmap_plot::plotter#0 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#2 = bitmap_plot::y#4 } { bitmap_plot::x#2 = bitmap_plot::x#4 bitmap_line::x#6 } }  main:2::bitmap_line:13::bitmap_plot:56 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#15 bitmap_line::x#7 bitmap_line::e1#3 bitmap_plot::x#4 bitmap_plot::plotter#0 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#3 = bitmap_plot::y#4 } { bitmap_plot::x#3 = bitmap_plot::x#4 bitmap_line::x#7 } }  main:2::bitmap_line:13::bitmap_plot:65 [ next#5 bitmap_plot::x#4 bitmap_plot::plotter#0 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [68] (word~) bitmap_plot::$1 ← (word) bitmap_plot::x#4 & (word) $fff8 [ bitmap_plot::x#4 bitmap_plot::plotter#0 bitmap_plot::$1 ] ( main:2::bitmap_line:13::bitmap_plot:39 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#4 bitmap_line::x#13 bitmap_line::e#3 bitmap_plot::x#4 bitmap_plot::plotter#0 bitmap_plot::$1 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#1 = bitmap_plot::y#4 } { bitmap_plot::x#1 = bitmap_plot::x#4 bitmap_line::x#13 } }  main:2::bitmap_line:13::bitmap_plot:50 [ next#5 bitmap_plot::x#4 bitmap_plot::plotter#0 bitmap_plot::$1 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#2 = bitmap_plot::y#4 } { bitmap_plot::x#2 = bitmap_plot::x#4 bitmap_line::x#6 } }  main:2::bitmap_line:13::bitmap_plot:56 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#15 bitmap_line::x#7 bitmap_line::e1#3 bitmap_plot::x#4 bitmap_plot::plotter#0 bitmap_plot::$1 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#3 = bitmap_plot::y#4 } { bitmap_plot::x#3 = bitmap_plot::x#4 bitmap_line::x#7 } }  main:2::bitmap_line:13::bitmap_plot:65 [ next#5 bitmap_plot::x#4 bitmap_plot::plotter#0 bitmap_plot::$1 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [69] (byte*) bitmap_plot::plotter#1 ← (byte*)(word) bitmap_plot::plotter#0 + (word~) bitmap_plot::$1 [ bitmap_plot::x#4 bitmap_plot::plotter#1 ] ( main:2::bitmap_line:13::bitmap_plot:39 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#4 bitmap_line::x#13 bitmap_line::e#3 bitmap_plot::x#4 bitmap_plot::plotter#1 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#1 = bitmap_plot::y#4 } { bitmap_plot::x#1 = bitmap_plot::x#4 bitmap_line::x#13 } }  main:2::bitmap_line:13::bitmap_plot:50 [ next#5 bitmap_plot::x#4 bitmap_plot::plotter#1 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#2 = bitmap_plot::y#4 } { bitmap_plot::x#2 = bitmap_plot::x#4 bitmap_line::x#6 } }  main:2::bitmap_line:13::bitmap_plot:56 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#15 bitmap_line::x#7 bitmap_line::e1#3 bitmap_plot::x#4 bitmap_plot::plotter#1 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#3 = bitmap_plot::y#4 } { bitmap_plot::x#3 = bitmap_plot::x#4 bitmap_line::x#7 } }  main:2::bitmap_line:13::bitmap_plot:65 [ next#5 bitmap_plot::x#4 bitmap_plot::plotter#1 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a 
+Statement [71] *((byte*) bitmap_plot::plotter#1) ← *((byte*) bitmap_plot::plotter#1) | *((const byte*) bitmap_plot_bit + (byte~) bitmap_plot::$2) [ ] ( main:2::bitmap_line:13::bitmap_plot:39 [ next#5 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#4 bitmap_line::x#13 bitmap_line::e#3 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#1 = bitmap_plot::y#4 } { bitmap_plot::x#1 = bitmap_plot::x#4 bitmap_line::x#13 } }  main:2::bitmap_line:13::bitmap_plot:50 [ next#5 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#2 = bitmap_plot::y#4 } { bitmap_plot::x#2 = bitmap_plot::x#4 bitmap_line::x#6 } }  main:2::bitmap_line:13::bitmap_plot:56 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 bitmap_line::dy#0 bitmap_line::sx#0 bitmap_line::sy#0 bitmap_line::y#15 bitmap_line::x#7 bitmap_line::e1#3 ] { { next#5 = bitmap_line::x2#0 } { bitmap_plot::y#3 = bitmap_plot::y#4 } { bitmap_plot::x#3 = bitmap_plot::x#4 bitmap_line::x#7 } }  main:2::bitmap_line:13::bitmap_plot:65 [ next#5 ] { { next#5 = bitmap_line::x2#0 } }  ) always clobbers reg byte a reg byte y 
+Statement [84] (word) abs_u16::return#2 ← - (word) abs_u16::w#2 [ abs_u16::return#2 ] ( main:2::bitmap_line:13::abs_u16:19 [ next#5 bitmap_line::x2#0 abs_u16::return#2 ] { { abs_u16::w#0 = abs_u16::w#2 bitmap_line::x2#0 next#5 } { abs_u16::return#0 = abs_u16::return#4 } }  main:2::bitmap_line:13::abs_u16:22 [ next#5 bitmap_line::x2#0 bitmap_line::dx#0 abs_u16::return#2 ] { { next#5 = bitmap_line::x2#0 } { abs_u16::return#1 = abs_u16::return#4 } }  ) always clobbers reg byte a 
+Statement [93] if((word) memset::num#2<=(byte) 0) goto memset::@return [ memset::num#2 memset::str#3 memset::c#4 ] ( main:2::bitmap_clear:10::memset:88 [ memset::num#2 memset::str#3 memset::c#4 ] { }  main:2::bitmap_clear:10::memset:90 [ memset::num#2 memset::str#3 memset::c#4 ] { }  ) always clobbers reg byte a 
+Statement [94] (byte*) memset::end#0 ← (byte*)(void*) memset::str#3 + (word) memset::num#2 [ memset::str#3 memset::c#4 memset::end#0 ] ( main:2::bitmap_clear:10::memset:88 [ memset::str#3 memset::c#4 memset::end#0 ] { }  main:2::bitmap_clear:10::memset:90 [ memset::str#3 memset::c#4 memset::end#0 ] { }  ) always clobbers reg byte a 
+Statement [95] (byte*) memset::dst#4 ← (byte*)(void*) memset::str#3 [ memset::c#4 memset::end#0 memset::dst#4 ] ( main:2::bitmap_clear:10::memset:88 [ memset::c#4 memset::end#0 memset::dst#4 ] { }  main:2::bitmap_clear:10::memset:90 [ memset::c#4 memset::end#0 memset::dst#4 ] { }  ) always clobbers reg byte a 
+Statement [97] if((byte*) memset::dst#2!=(byte*) memset::end#0) goto memset::@3 [ memset::c#4 memset::end#0 memset::dst#2 ] ( main:2::bitmap_clear:10::memset:88 [ memset::c#4 memset::end#0 memset::dst#2 ] { }  main:2::bitmap_clear:10::memset:90 [ memset::c#4 memset::end#0 memset::dst#2 ] { }  ) always clobbers reg byte a 
+Statement [99] *((byte*) memset::dst#2) ← (byte) memset::c#4 [ memset::c#4 memset::end#0 memset::dst#2 ] ( main:2::bitmap_clear:10::memset:88 [ memset::c#4 memset::end#0 memset::dst#2 ] { }  main:2::bitmap_clear:10::memset:90 [ memset::c#4 memset::end#0 memset::dst#2 ] { }  ) always clobbers reg byte a reg byte y 
+Statement [111] (byte~) bitmap_init::$7 ← (byte) bitmap_init::y#2 & (byte) 7 [ bitmap_init::y#2 bitmap_init::yoffs#2 bitmap_init::$7 ] ( main:2::bitmap_init:8 [ bitmap_init::y#2 bitmap_init::yoffs#2 bitmap_init::$7 ] { }  ) always clobbers reg byte a 
+Statement [118] (byte*) bitmap_init::yoffs#1 ← (byte*) bitmap_init::yoffs#2 + (word)(number) $28*(number) 8 [ bitmap_init::y#2 bitmap_init::yoffs#1 ] ( main:2::bitmap_init:8 [ bitmap_init::y#2 bitmap_init::yoffs#1 ] { }  ) always clobbers reg byte a 
 Potential registers zp[2]:2 [ next#5 next#3 next#1 ] : zp[2]:2 , 
 Potential registers zp[2]:4 [ bitmap_line::e#3 bitmap_line::e#0 bitmap_line::e#6 bitmap_line::e#1 bitmap_line::e#2 ] : zp[2]:4 , 
 Potential registers zp[2]:6 [ bitmap_line::y#15 bitmap_line::y#7 bitmap_line::y#13 bitmap_line::y#4 bitmap_line::y#1 bitmap_line::y#2 ] : zp[2]:6 , 
@@ -3236,32 +3230,32 @@ Potential registers zp[1]:66 [ bitmap_init::$5 ] : zp[1]:66 , reg byte a , reg b
 Potential registers zp[1]:67 [ bitmap_init::$6 ] : zp[1]:67 , reg byte a , reg byte x , reg byte y , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [bitmap_line] 656.5: zp[2]:6 [ bitmap_line::y#15 bitmap_line::y#7 bitmap_line::y#13 bitmap_line::y#4 bitmap_line::y#1 bitmap_line::y#2 ] 596.18: zp[2]:8 [ bitmap_line::x#7 bitmap_line::x#6 bitmap_line::x#15 bitmap_line::x#13 bitmap_line::x#12 bitmap_line::x#1 ] 532.97: zp[2]:4 [ bitmap_line::e#3 bitmap_line::e#0 bitmap_line::e#6 bitmap_line::e#1 bitmap_line::e#2 ] 532.97: zp[2]:10 [ bitmap_line::e1#3 bitmap_line::e1#6 bitmap_line::e1#0 bitmap_line::e1#2 bitmap_line::e1#1 ] 8.89: zp[2]:41 [ bitmap_line::dy#0 ] 8.18: zp[2]:37 [ bitmap_line::dx#0 ] 7.85: zp[2]:49 [ bitmap_line::sy#0 ] 7.03: zp[2]:45 [ bitmap_line::sx#0 ] 3.87: zp[2]:33 [ bitmap_line::x2#0 ] 
-Uplift Scope [bitmap_plot] 460: zp[2]:13 [ bitmap_plot::x#4 bitmap_plot::x#3 bitmap_plot::x#2 bitmap_plot::x#1 ] 412: zp[1]:12 [ bitmap_plot::y#4 bitmap_plot::y#3 bitmap_plot::y#2 bitmap_plot::y#1 ] 4: zp[2]:53 [ bitmap_plot::$1 ] 4: zp[1]:57 [ bitmap_plot::$2 ] 3: zp[2]:55 [ bitmap_plot::plotter#1 ] 1: zp[2]:51 [ bitmap_plot::plotter#0 ] 
-Uplift Scope [bitmap_init] 39.88: zp[2]:31 [ bitmap_init::yoffs#2 bitmap_init::yoffs#4 bitmap_init::yoffs#1 ] 34.83: zp[1]:28 [ bitmap_init::bits#3 bitmap_init::bits#4 bitmap_init::bits#1 ] 22: zp[1]:29 [ bitmap_init::x#2 bitmap_init::x#1 ] 22: zp[1]:30 [ bitmap_init::y#2 bitmap_init::y#1 ] 22: zp[1]:65 [ bitmap_init::$4 ] 22: zp[1]:66 [ bitmap_init::$5 ] 22: zp[1]:67 [ bitmap_init::$6 ] 5.5: zp[1]:64 [ bitmap_init::$7 ] 
-Uplift Scope [memset] 41.33: zp[2]:26 [ memset::dst#2 memset::dst#4 memset::dst#1 ] 2.17: zp[2]:62 [ memset::end#0 ] 2: zp[2]:21 [ memset::num#2 ] 1.38: zp[1]:25 [ memset::c#4 ] 0: zp[2]:23 [ memset::str#3 ] 
-Uplift Scope [] 44: zp[2]:2 [ next#5 next#3 next#1 ] 
-Uplift Scope [abs_u16] 12: zp[2]:19 [ abs_u16::return#4 abs_u16::return#2 abs_u16::w#2 abs_u16::w#0 ] 4: zp[2]:35 [ abs_u16::return#0 ] 4: zp[2]:39 [ abs_u16::return#1 ] 4: zp[1]:60 [ abs_u16::$0 ] 4: zp[1]:61 [ abs_u16::$1 ] 
-Uplift Scope [sgn_u16] 8: zp[2]:15 [ sgn_u16::w#2 sgn_u16::w#0 ] 4: zp[2]:43 [ sgn_u16::return#0 ] 4: zp[2]:47 [ sgn_u16::return#1 ] 4: zp[1]:58 [ sgn_u16::$0 ] 4: zp[1]:59 [ sgn_u16::$1 ] 1: zp[2]:17 [ sgn_u16::return#4 ] 
+Uplift Scope [bitmap_plot] 2,402,008: zp[1]:12 [ bitmap_plot::y#4 bitmap_plot::y#3 bitmap_plot::y#2 bitmap_plot::y#1 ] 2,000,002: zp[2]:53 [ bitmap_plot::$1 ] 2,000,002: zp[1]:57 [ bitmap_plot::$2 ] 1,500,001.5: zp[2]:55 [ bitmap_plot::plotter#1 ] 952,257.25: zp[2]:13 [ bitmap_plot::x#4 bitmap_plot::x#3 bitmap_plot::x#2 bitmap_plot::x#1 ] 500,000.5: zp[2]:51 [ bitmap_plot::plotter#0 ] 
+Uplift Scope [bitmap_line] 650,006.5: zp[2]:6 [ bitmap_line::y#15 bitmap_line::y#7 bitmap_line::y#13 bitmap_line::y#4 bitmap_line::y#1 bitmap_line::y#2 ] 589,792.11: zp[2]:8 [ bitmap_line::x#7 bitmap_line::x#6 bitmap_line::x#15 bitmap_line::x#13 bitmap_line::x#12 bitmap_line::x#1 ] 525,540.77: zp[2]:4 [ bitmap_line::e#3 bitmap_line::e#0 bitmap_line::e#6 bitmap_line::e#1 bitmap_line::e#2 ] 525,540.77: zp[2]:10 [ bitmap_line::e1#3 bitmap_line::e1#6 bitmap_line::e1#0 bitmap_line::e1#2 bitmap_line::e1#1 ] 8,685.91: zp[2]:41 [ bitmap_line::dy#0 ] 8,000.18: zp[2]:37 [ bitmap_line::dx#0 ] 7,730.88: zp[2]:49 [ bitmap_line::sy#0 ] 6,931.14: zp[2]:45 [ bitmap_line::sx#0 ] 3,403.47: zp[2]:33 [ bitmap_line::x2#0 ] 
+Uplift Scope [abs_u16] 35,256: zp[2]:19 [ abs_u16::return#4 abs_u16::return#2 abs_u16::w#2 abs_u16::w#0 ] 20,002: zp[1]:60 [ abs_u16::$0 ] 20,002: zp[1]:61 [ abs_u16::$1 ] 2,002: zp[2]:35 [ abs_u16::return#0 ] 2,002: zp[2]:39 [ abs_u16::return#1 ] 
+Uplift Scope [sgn_u16] 20,002: zp[1]:58 [ sgn_u16::$0 ] 20,002: zp[1]:59 [ sgn_u16::$1 ] 13,004: zp[2]:15 [ sgn_u16::w#2 sgn_u16::w#0 ] 2,002: zp[2]:43 [ sgn_u16::return#0 ] 2,002: zp[2]:47 [ sgn_u16::return#1 ] 500.5: zp[2]:17 [ sgn_u16::return#4 ] 
+Uplift Scope [memset] 35,672.33: zp[2]:26 [ memset::dst#2 memset::dst#4 memset::dst#1 ] 1,833.67: zp[2]:62 [ memset::end#0 ] 1,250.12: zp[1]:25 [ memset::c#4 ] 1,001: zp[2]:21 [ memset::num#2 ] 0: zp[2]:23 [ memset::str#3 ] 
+Uplift Scope [bitmap_init] 3,628.62: zp[2]:31 [ bitmap_init::yoffs#2 bitmap_init::yoffs#4 bitmap_init::yoffs#1 ] 3,169.83: zp[1]:28 [ bitmap_init::bits#3 bitmap_init::bits#4 bitmap_init::bits#1 ] 2,002: zp[1]:29 [ bitmap_init::x#2 bitmap_init::x#1 ] 2,002: zp[1]:30 [ bitmap_init::y#2 bitmap_init::y#1 ] 2,002: zp[1]:65 [ bitmap_init::$4 ] 2,002: zp[1]:66 [ bitmap_init::$5 ] 2,002: zp[1]:67 [ bitmap_init::$6 ] 500.5: zp[1]:64 [ bitmap_init::$7 ] 
+Uplift Scope [] 404: zp[2]:2 [ next#5 next#3 next#1 ] 
 Uplift Scope [bitmap_clear] 
 Uplift Scope [main] 
 
-Uplifting [bitmap_line] best 37301 combination zp[2]:6 [ bitmap_line::y#15 bitmap_line::y#7 bitmap_line::y#13 bitmap_line::y#4 bitmap_line::y#1 bitmap_line::y#2 ] zp[2]:8 [ bitmap_line::x#7 bitmap_line::x#6 bitmap_line::x#15 bitmap_line::x#13 bitmap_line::x#12 bitmap_line::x#1 ] zp[2]:4 [ bitmap_line::e#3 bitmap_line::e#0 bitmap_line::e#6 bitmap_line::e#1 bitmap_line::e#2 ] zp[2]:10 [ bitmap_line::e1#3 bitmap_line::e1#6 bitmap_line::e1#0 bitmap_line::e1#2 bitmap_line::e1#1 ] zp[2]:41 [ bitmap_line::dy#0 ] zp[2]:37 [ bitmap_line::dx#0 ] zp[2]:49 [ bitmap_line::sy#0 ] zp[2]:45 [ bitmap_line::sx#0 ] zp[2]:33 [ bitmap_line::x2#0 ] 
-Uplifting [bitmap_plot] best 37090 combination zp[2]:13 [ bitmap_plot::x#4 bitmap_plot::x#3 bitmap_plot::x#2 bitmap_plot::x#1 ] reg byte x [ bitmap_plot::y#4 bitmap_plot::y#3 bitmap_plot::y#2 bitmap_plot::y#1 ] zp[2]:53 [ bitmap_plot::$1 ] reg byte a [ bitmap_plot::$2 ] zp[2]:55 [ bitmap_plot::plotter#1 ] zp[2]:51 [ bitmap_plot::plotter#0 ] 
-Uplifting [bitmap_init] best 36580 combination zp[2]:31 [ bitmap_init::yoffs#2 bitmap_init::yoffs#4 bitmap_init::yoffs#1 ] reg byte a [ bitmap_init::bits#3 bitmap_init::bits#4 bitmap_init::bits#1 ] reg byte x [ bitmap_init::x#2 bitmap_init::x#1 ] reg byte x [ bitmap_init::y#2 bitmap_init::y#1 ] reg byte a [ bitmap_init::$4 ] zp[1]:66 [ bitmap_init::$5 ] zp[1]:67 [ bitmap_init::$6 ] zp[1]:64 [ bitmap_init::$7 ] 
+Uplifting [bitmap_plot] best 37088 combination reg byte x [ bitmap_plot::y#4 bitmap_plot::y#3 bitmap_plot::y#2 bitmap_plot::y#1 ] zp[2]:53 [ bitmap_plot::$1 ] reg byte x [ bitmap_plot::$2 ] zp[2]:55 [ bitmap_plot::plotter#1 ] zp[2]:13 [ bitmap_plot::x#4 bitmap_plot::x#3 bitmap_plot::x#2 bitmap_plot::x#1 ] zp[2]:51 [ bitmap_plot::plotter#0 ] 
+Uplifting [bitmap_line] best 37088 combination zp[2]:6 [ bitmap_line::y#15 bitmap_line::y#7 bitmap_line::y#13 bitmap_line::y#4 bitmap_line::y#1 bitmap_line::y#2 ] zp[2]:8 [ bitmap_line::x#7 bitmap_line::x#6 bitmap_line::x#15 bitmap_line::x#13 bitmap_line::x#12 bitmap_line::x#1 ] zp[2]:4 [ bitmap_line::e#3 bitmap_line::e#0 bitmap_line::e#6 bitmap_line::e#1 bitmap_line::e#2 ] zp[2]:10 [ bitmap_line::e1#3 bitmap_line::e1#6 bitmap_line::e1#0 bitmap_line::e1#2 bitmap_line::e1#1 ] zp[2]:41 [ bitmap_line::dy#0 ] zp[2]:37 [ bitmap_line::dx#0 ] zp[2]:49 [ bitmap_line::sy#0 ] zp[2]:45 [ bitmap_line::sx#0 ] zp[2]:33 [ bitmap_line::x2#0 ] 
+Uplifting [abs_u16] best 37076 combination zp[2]:19 [ abs_u16::return#4 abs_u16::return#2 abs_u16::w#2 abs_u16::w#0 ] reg byte a [ abs_u16::$0 ] reg byte a [ abs_u16::$1 ] zp[2]:35 [ abs_u16::return#0 ] zp[2]:39 [ abs_u16::return#1 ] 
+Uplifting [sgn_u16] best 37064 combination reg byte a [ sgn_u16::$0 ] reg byte a [ sgn_u16::$1 ] zp[2]:15 [ sgn_u16::w#2 sgn_u16::w#0 ] zp[2]:43 [ sgn_u16::return#0 ] zp[2]:47 [ sgn_u16::return#1 ] zp[2]:17 [ sgn_u16::return#4 ] 
+Uplifting [memset] best 37048 combination zp[2]:26 [ memset::dst#2 memset::dst#4 memset::dst#1 ] zp[2]:62 [ memset::end#0 ] reg byte x [ memset::c#4 ] zp[2]:21 [ memset::num#2 ] zp[2]:23 [ memset::str#3 ] 
+Uplifting [bitmap_init] best 36538 combination zp[2]:31 [ bitmap_init::yoffs#2 bitmap_init::yoffs#4 bitmap_init::yoffs#1 ] reg byte a [ bitmap_init::bits#3 bitmap_init::bits#4 bitmap_init::bits#1 ] reg byte x [ bitmap_init::x#2 bitmap_init::x#1 ] reg byte x [ bitmap_init::y#2 bitmap_init::y#1 ] reg byte a [ bitmap_init::$4 ] zp[1]:66 [ bitmap_init::$5 ] zp[1]:67 [ bitmap_init::$6 ] zp[1]:64 [ bitmap_init::$7 ] 
 Limited combination testing to 100 combinations of 15360 possible.
-Uplifting [memset] best 36564 combination zp[2]:26 [ memset::dst#2 memset::dst#4 memset::dst#1 ] zp[2]:62 [ memset::end#0 ] zp[2]:21 [ memset::num#2 ] reg byte x [ memset::c#4 ] zp[2]:23 [ memset::str#3 ] 
-Uplifting [] best 36564 combination zp[2]:2 [ next#5 next#3 next#1 ] 
-Uplifting [abs_u16] best 36552 combination zp[2]:19 [ abs_u16::return#4 abs_u16::return#2 abs_u16::w#2 abs_u16::w#0 ] zp[2]:35 [ abs_u16::return#0 ] zp[2]:39 [ abs_u16::return#1 ] reg byte a [ abs_u16::$0 ] reg byte a [ abs_u16::$1 ] 
-Uplifting [sgn_u16] best 36540 combination zp[2]:15 [ sgn_u16::w#2 sgn_u16::w#0 ] zp[2]:43 [ sgn_u16::return#0 ] zp[2]:47 [ sgn_u16::return#1 ] reg byte a [ sgn_u16::$0 ] reg byte a [ sgn_u16::$1 ] zp[2]:17 [ sgn_u16::return#4 ] 
-Uplifting [bitmap_clear] best 36540 combination 
-Uplifting [main] best 36540 combination 
+Uplifting [] best 36538 combination zp[2]:2 [ next#5 next#3 next#1 ] 
+Uplifting [bitmap_clear] best 36538 combination 
+Uplifting [main] best 36538 combination 
 Attempting to uplift remaining variables inzp[1]:66 [ bitmap_init::$5 ]
-Uplifting [bitmap_init] best 36480 combination reg byte a [ bitmap_init::$5 ] 
+Uplifting [bitmap_init] best 36478 combination reg byte a [ bitmap_init::$5 ] 
 Attempting to uplift remaining variables inzp[1]:67 [ bitmap_init::$6 ]
-Uplifting [bitmap_init] best 36420 combination reg byte a [ bitmap_init::$6 ] 
+Uplifting [bitmap_init] best 36418 combination reg byte a [ bitmap_init::$6 ] 
 Attempting to uplift remaining variables inzp[1]:64 [ bitmap_init::$7 ]
-Uplifting [bitmap_init] best 36420 combination zp[1]:64 [ bitmap_init::$7 ] 
+Uplifting [bitmap_init] best 36418 combination zp[1]:64 [ bitmap_init::$7 ] 
 Coalescing zero page register [ zp[2]:8 [ bitmap_line::x#7 bitmap_line::x#6 bitmap_line::x#15 bitmap_line::x#13 bitmap_line::x#12 bitmap_line::x#1 ] ] with [ zp[2]:13 [ bitmap_plot::x#4 bitmap_plot::x#3 bitmap_plot::x#2 bitmap_plot::x#1 ] ] - score: 3
 Coalescing zero page register [ zp[2]:2 [ next#5 next#3 next#1 ] ] with [ zp[2]:33 [ bitmap_line::x2#0 ] ] - score: 1
 Coalescing zero page register [ zp[2]:17 [ sgn_u16::return#4 ] ] with [ zp[2]:43 [ sgn_u16::return#0 ] ] - score: 1
@@ -3787,11 +3781,10 @@ bitmap_plot: {
     lda.z plotter+1
     adc.z __1+1
     sta.z plotter+1
-    // [70] (byte~) bitmap_plot::$2 ← < (word) bitmap_plot::x#4 -- vbuaa=_lo_vwuz1 
-    lda.z x
-    // [71] *((byte*) bitmap_plot::plotter#1) ← *((byte*) bitmap_plot::plotter#1) | *((const byte*) bitmap_plot_bit + (byte~) bitmap_plot::$2) -- _deref_pbuz1=_deref_pbuz1_bor_pbuc1_derefidx_vbuaa 
-    tay
-    lda bitmap_plot_bit,y
+    // [70] (byte~) bitmap_plot::$2 ← < (word) bitmap_plot::x#4 -- vbuxx=_lo_vwuz1 
+    ldx.z x
+    // [71] *((byte*) bitmap_plot::plotter#1) ← *((byte*) bitmap_plot::plotter#1) | *((const byte*) bitmap_plot_bit + (byte~) bitmap_plot::$2) -- _deref_pbuz1=_deref_pbuz1_bor_pbuc1_derefidx_vbuxx 
+    lda bitmap_plot_bit,x
     ldy #0
     ora (plotter),y
     ldy #0
@@ -4285,18 +4278,18 @@ FINAL SYMBOL TABLE
 (const byte) VIC_RSEL = (byte) 8
 (const byte) WHITE = (byte) 1
 (word()) abs_u16((word) abs_u16::w)
-(byte~) abs_u16::$0 reg byte a 4.0
-(byte~) abs_u16::$1 reg byte a 4.0
+(byte~) abs_u16::$0 reg byte a 20002.0
+(byte~) abs_u16::$1 reg byte a 20002.0
 (label) abs_u16::@1
 (label) abs_u16::@return
 (word) abs_u16::return
-(word) abs_u16::return#0 return zp[2]:8 4.0
-(word) abs_u16::return#1 return zp[2]:8 4.0
-(word) abs_u16::return#2 return zp[2]:8 4.0
-(word) abs_u16::return#4 return zp[2]:8 2.0
+(word) abs_u16::return#0 return zp[2]:8 2002.0
+(word) abs_u16::return#1 return zp[2]:8 2002.0
+(word) abs_u16::return#2 return zp[2]:8 20002.0
+(word) abs_u16::return#4 return zp[2]:8 5501.0
 (word) abs_u16::w
-(word) abs_u16::w#0 w zp[2]:8 4.0
-(word) abs_u16::w#2 w zp[2]:8 2.0
+(word) abs_u16::w#0 w zp[2]:8 2002.0
+(word) abs_u16::w#2 w zp[2]:8 7751.0
 (void()) bitmap_clear((byte) bitmap_clear::bgcol , (byte) bitmap_clear::fgcol)
 (label) bitmap_clear::@1
 (label) bitmap_clear::@return
@@ -4306,10 +4299,10 @@ FINAL SYMBOL TABLE
 (byte) bitmap_clear::fgcol
 (byte*) bitmap_gfx
 (void()) bitmap_init((byte*) bitmap_init::gfx , (byte*) bitmap_init::screen)
-(byte~) bitmap_init::$4 reg byte a 22.0
-(byte~) bitmap_init::$5 reg byte a 22.0
-(byte~) bitmap_init::$6 reg byte a 22.0
-(byte~) bitmap_init::$7 zp[1]:24 5.5
+(byte~) bitmap_init::$4 reg byte a 2002.0
+(byte~) bitmap_init::$5 reg byte a 2002.0
+(byte~) bitmap_init::$6 reg byte a 2002.0
+(byte~) bitmap_init::$7 zp[1]:24 500.5
 (label) bitmap_init::@1
 (label) bitmap_init::@2
 (label) bitmap_init::@3
@@ -4318,21 +4311,21 @@ FINAL SYMBOL TABLE
 (label) bitmap_init::@6
 (label) bitmap_init::@return
 (byte) bitmap_init::bits
-(byte) bitmap_init::bits#1 reg byte a 11.0
-(byte) bitmap_init::bits#3 reg byte a 16.5
-(byte) bitmap_init::bits#4 reg byte a 7.333333333333333
+(byte) bitmap_init::bits#1 reg byte a 1001.0
+(byte) bitmap_init::bits#3 reg byte a 1501.5
+(byte) bitmap_init::bits#4 reg byte a 667.3333333333334
 (byte*) bitmap_init::gfx
 (byte*) bitmap_init::screen
 (byte) bitmap_init::x
-(byte) bitmap_init::x#1 reg byte x 16.5
-(byte) bitmap_init::x#2 reg byte x 5.5
+(byte) bitmap_init::x#1 reg byte x 1501.5
+(byte) bitmap_init::x#2 reg byte x 500.5
 (byte) bitmap_init::y
-(byte) bitmap_init::y#1 reg byte x 16.5
-(byte) bitmap_init::y#2 reg byte x 5.5
+(byte) bitmap_init::y#1 reg byte x 1501.5
+(byte) bitmap_init::y#2 reg byte x 500.5
 (byte*) bitmap_init::yoffs
-(byte*) bitmap_init::yoffs#1 yoffs zp[2]:14 22.0
-(byte*) bitmap_init::yoffs#2 yoffs zp[2]:14 6.875
-(byte*) bitmap_init::yoffs#4 yoffs zp[2]:14 11.0
+(byte*) bitmap_init::yoffs#1 yoffs zp[2]:14 2002.0
+(byte*) bitmap_init::yoffs#2 yoffs zp[2]:14 625.625
+(byte*) bitmap_init::yoffs#4 yoffs zp[2]:14 1001.0
 (void()) bitmap_line((word) bitmap_line::x1 , (word) bitmap_line::y1 , (word) bitmap_line::x2 , (word) bitmap_line::y2)
 (label) bitmap_line::@1
 (label) bitmap_line::@10
@@ -4354,64 +4347,64 @@ FINAL SYMBOL TABLE
 (label) bitmap_line::@9
 (label) bitmap_line::@return
 (word) bitmap_line::dx
-(word) bitmap_line::dx#0 dx zp[2]:16 8.18421052631579
+(word) bitmap_line::dx#0 dx zp[2]:16 8000.184210526315
 (word) bitmap_line::dy
-(word) bitmap_line::dy#0 dy zp[2]:8 8.885714285714286
+(word) bitmap_line::dy#0 dy zp[2]:8 8685.914285714285
 (word) bitmap_line::e
-(word) bitmap_line::e#0 e zp[2]:10 4.0
-(word) bitmap_line::e#1 e zp[2]:10 134.66666666666666
-(word) bitmap_line::e#2 e zp[2]:10 202.0
-(word) bitmap_line::e#3 e zp[2]:10 40.8
-(word) bitmap_line::e#6 e zp[2]:10 151.5
+(word) bitmap_line::e#0 e zp[2]:10 2002.0
+(word) bitmap_line::e#1 e zp[2]:10 133334.66666666666
+(word) bitmap_line::e#2 e zp[2]:10 200002.0
+(word) bitmap_line::e#3 e zp[2]:10 40200.600000000006
+(word) bitmap_line::e#6 e zp[2]:10 150001.5
 (word) bitmap_line::e1
-(word) bitmap_line::e1#0 e1 zp[2]:4 4.0
-(word) bitmap_line::e1#1 e1 zp[2]:4 134.66666666666666
-(word) bitmap_line::e1#2 e1 zp[2]:4 202.0
-(word) bitmap_line::e1#3 e1 zp[2]:4 40.8
-(word) bitmap_line::e1#6 e1 zp[2]:4 151.5
+(word) bitmap_line::e1#0 e1 zp[2]:4 2002.0
+(word) bitmap_line::e1#1 e1 zp[2]:4 133334.66666666666
+(word) bitmap_line::e1#2 e1 zp[2]:4 200002.0
+(word) bitmap_line::e1#3 e1 zp[2]:4 40200.600000000006
+(word) bitmap_line::e1#6 e1 zp[2]:4 150001.5
 (word) bitmap_line::sx
-(word) bitmap_line::sx#0 sx zp[2]:18 7.03448275862069
+(word) bitmap_line::sx#0 sx zp[2]:18 6931.137931034482
 (word) bitmap_line::sy
-(word) bitmap_line::sy#0 sy zp[2]:6 7.846153846153847
+(word) bitmap_line::sy#0 sy zp[2]:6 7730.884615384615
 (word) bitmap_line::x
-(word) bitmap_line::x#1 x zp[2]:14 101.0
-(word) bitmap_line::x#12 x zp[2]:14 202.0
-(word) bitmap_line::x#13 x zp[2]:14 57.714285714285715
-(word) bitmap_line::x#15 x zp[2]:14 57.714285714285715
-(word) bitmap_line::x#6 x zp[2]:14 102.0
-(word) bitmap_line::x#7 x zp[2]:14 75.75
+(word) bitmap_line::x#1 x zp[2]:14 100001.0
+(word) bitmap_line::x#12 x zp[2]:14 200002.0
+(word) bitmap_line::x#13 x zp[2]:14 57143.42857142857
+(word) bitmap_line::x#15 x zp[2]:14 57143.42857142857
+(word) bitmap_line::x#6 x zp[2]:14 100501.5
+(word) bitmap_line::x#7 x zp[2]:14 75000.75
 (word) bitmap_line::x1
 (const word) bitmap_line::x1#0 x1 = (byte) 0
 (word) bitmap_line::x2
-(word) bitmap_line::x2#0 x2 zp[2]:2 3.8666666666666667
+(word) bitmap_line::x2#0 x2 zp[2]:2 3403.4666666666667
 (word) bitmap_line::y
-(word) bitmap_line::y#1 y zp[2]:12 57.714285714285715
-(word) bitmap_line::y#13 y zp[2]:12 202.0
-(word) bitmap_line::y#15 y zp[2]:12 43.285714285714285
-(word) bitmap_line::y#2 y zp[2]:12 101.0
-(word) bitmap_line::y#4 y zp[2]:12 50.5
-(word) bitmap_line::y#7 y zp[2]:12 202.0
+(word) bitmap_line::y#1 y zp[2]:12 57143.42857142857
+(word) bitmap_line::y#13 y zp[2]:12 200002.0
+(word) bitmap_line::y#15 y zp[2]:12 42857.57142857143
+(word) bitmap_line::y#2 y zp[2]:12 100001.0
+(word) bitmap_line::y#4 y zp[2]:12 50000.5
+(word) bitmap_line::y#7 y zp[2]:12 200002.0
 (word) bitmap_line::y1
 (const word) bitmap_line::y1#0 y1 = (byte) 0
 (word) bitmap_line::y2
 (const word) bitmap_line::y2#0 y2 = (byte) $64
 (void()) bitmap_plot((word) bitmap_plot::x , (byte) bitmap_plot::y)
-(word~) bitmap_plot::$1 zp[2]:22 4.0
-(byte~) bitmap_plot::$2 reg byte a 4.0
+(word~) bitmap_plot::$1 zp[2]:22 2000002.0
+(byte~) bitmap_plot::$2 reg byte x 2000002.0
 (label) bitmap_plot::@return
 (byte*) bitmap_plot::plotter
-(word) bitmap_plot::plotter#0 plotter zp[2]:20 1.0
-(byte*) bitmap_plot::plotter#1 plotter zp[2]:20 3.0
+(word) bitmap_plot::plotter#0 plotter zp[2]:20 500000.5
+(byte*) bitmap_plot::plotter#1 plotter zp[2]:20 1500001.5
 (word) bitmap_plot::x
-(word) bitmap_plot::x#1 x zp[2]:14 202.0
-(word) bitmap_plot::x#2 x zp[2]:14 4.0
-(word) bitmap_plot::x#3 x zp[2]:14 202.0
-(word) bitmap_plot::x#4 x zp[2]:14 52.0
+(word) bitmap_plot::x#1 x zp[2]:14 200002.0
+(word) bitmap_plot::x#2 x zp[2]:14 2002.0
+(word) bitmap_plot::x#3 x zp[2]:14 200002.0
+(word) bitmap_plot::x#4 x zp[2]:14 550251.25
 (byte) bitmap_plot::y
-(byte) bitmap_plot::y#1 reg byte x 101.0
-(byte) bitmap_plot::y#2 reg byte x 2.0
-(byte) bitmap_plot::y#3 reg byte x 101.0
-(byte) bitmap_plot::y#4 reg byte x 208.0
+(byte) bitmap_plot::y#1 reg byte x 100001.0
+(byte) bitmap_plot::y#2 reg byte x 1001.0
+(byte) bitmap_plot::y#3 reg byte x 100001.0
+(byte) bitmap_plot::y#4 reg byte x 2201005.0
 (const byte*) bitmap_plot_bit[(number) $100]  = { fill( $100, 0) }
 (const byte*) bitmap_plot_yhi[(number) $100]  = { fill( $100, 0) }
 (const byte*) bitmap_plot_ylo[(number) $100]  = { fill( $100, 0) }
@@ -4428,34 +4421,34 @@ FINAL SYMBOL TABLE
 (label) memset::@3
 (label) memset::@return
 (byte) memset::c
-(byte) memset::c#4 reg byte x 1.375
+(byte) memset::c#4 reg byte x 1250.125
 (byte*) memset::dst
-(byte*) memset::dst#1 dst zp[2]:12 22.0
-(byte*) memset::dst#2 dst zp[2]:12 15.333333333333332
-(byte*) memset::dst#4 dst zp[2]:12 4.0
+(byte*) memset::dst#1 dst zp[2]:12 20002.0
+(byte*) memset::dst#2 dst zp[2]:12 13668.333333333332
+(byte*) memset::dst#4 dst zp[2]:12 2002.0
 (byte*) memset::end
-(byte*) memset::end#0 end zp[2]:10 2.1666666666666665
+(byte*) memset::end#0 end zp[2]:10 1833.6666666666665
 (word) memset::num
-(word) memset::num#2 num zp[2]:10 2.0
+(word) memset::num#2 num zp[2]:10 1001.0
 (void*) memset::return
 (void*) memset::str
 (void*) memset::str#3 str zp[2]:12
 (word) next
-(word) next#1 next zp[2]:2 11.0
-(word) next#3 next zp[2]:2 22.0
-(word) next#5 next zp[2]:2 11.0
+(word) next#1 next zp[2]:2 101.0
+(word) next#3 next zp[2]:2 202.0
+(word) next#5 next zp[2]:2 101.0
 (word()) sgn_u16((word) sgn_u16::w)
-(byte~) sgn_u16::$0 reg byte a 4.0
-(byte~) sgn_u16::$1 reg byte a 4.0
+(byte~) sgn_u16::$0 reg byte a 20002.0
+(byte~) sgn_u16::$1 reg byte a 20002.0
 (label) sgn_u16::@1
 (label) sgn_u16::@return
 (word) sgn_u16::return
-(word) sgn_u16::return#0 return zp[2]:6 4.0
-(word) sgn_u16::return#1 return zp[2]:6 4.0
-(word) sgn_u16::return#4 return zp[2]:6 1.0
+(word) sgn_u16::return#0 return zp[2]:6 2002.0
+(word) sgn_u16::return#1 return zp[2]:6 2002.0
+(word) sgn_u16::return#4 return zp[2]:6 500.5
 (word) sgn_u16::w
-(word) sgn_u16::w#0 w zp[2]:20 4.0
-(word) sgn_u16::w#2 w zp[2]:20 4.0
+(word) sgn_u16::w#0 w zp[2]:20 2002.0
+(word) sgn_u16::w#2 w zp[2]:20 11002.0
 
 zp[2]:2 [ next#5 next#3 next#1 bitmap_line::x2#0 ]
 zp[2]:4 [ bitmap_line::e1#3 bitmap_line::e1#6 bitmap_line::e1#0 bitmap_line::e1#2 bitmap_line::e1#1 ]
@@ -4473,7 +4466,7 @@ zp[2]:16 [ bitmap_line::dx#0 ]
 zp[2]:18 [ bitmap_line::sx#0 ]
 zp[2]:20 [ bitmap_plot::plotter#0 bitmap_plot::plotter#1 sgn_u16::w#2 sgn_u16::w#0 ]
 zp[2]:22 [ bitmap_plot::$1 ]
-reg byte a [ bitmap_plot::$2 ]
+reg byte x [ bitmap_plot::$2 ]
 reg byte a [ sgn_u16::$0 ]
 reg byte a [ sgn_u16::$1 ]
 reg byte a [ abs_u16::$0 ]
@@ -4485,7 +4478,7 @@ reg byte a [ bitmap_init::$6 ]
 
 
 FINAL ASSEMBLER
-Score: 30188
+Score: 30186
 
   // File Comments
 // Shows that bitmap2.kc line() does not have the same problem as bitmap-draw.kc
@@ -4951,12 +4944,11 @@ bitmap_plot: {
     adc.z __1+1
     sta.z plotter+1
     // <x
-    // [70] (byte~) bitmap_plot::$2 ← < (word) bitmap_plot::x#4 -- vbuaa=_lo_vwuz1 
-    lda.z x
+    // [70] (byte~) bitmap_plot::$2 ← < (word) bitmap_plot::x#4 -- vbuxx=_lo_vwuz1 
+    ldx.z x
     // *plotter |= bitmap_plot_bit[<x]
-    // [71] *((byte*) bitmap_plot::plotter#1) ← *((byte*) bitmap_plot::plotter#1) | *((const byte*) bitmap_plot_bit + (byte~) bitmap_plot::$2) -- _deref_pbuz1=_deref_pbuz1_bor_pbuc1_derefidx_vbuaa 
-    tay
-    lda bitmap_plot_bit,y
+    // [71] *((byte*) bitmap_plot::plotter#1) ← *((byte*) bitmap_plot::plotter#1) | *((const byte*) bitmap_plot_bit + (byte~) bitmap_plot::$2) -- _deref_pbuz1=_deref_pbuz1_bor_pbuc1_derefidx_vbuxx 
+    lda bitmap_plot_bit,x
     ldy #0
     ora (plotter),y
     sta (plotter),y

src/test/ref/bitmap-line-anim-2.sym

@@ -13,18 +13,18 @@
 (const byte) VIC_RSEL = (byte) 8
 (const byte) WHITE = (byte) 1
 (word()) abs_u16((word) abs_u16::w)
-(byte~) abs_u16::$0 reg byte a 4.0
-(byte~) abs_u16::$1 reg byte a 4.0
+(byte~) abs_u16::$0 reg byte a 20002.0
+(byte~) abs_u16::$1 reg byte a 20002.0
 (label) abs_u16::@1
 (label) abs_u16::@return
 (word) abs_u16::return
-(word) abs_u16::return#0 return zp[2]:8 4.0
-(word) abs_u16::return#1 return zp[2]:8 4.0
-(word) abs_u16::return#2 return zp[2]:8 4.0
-(word) abs_u16::return#4 return zp[2]:8 2.0
+(word) abs_u16::return#0 return zp[2]:8 2002.0
+(word) abs_u16::return#1 return zp[2]:8 2002.0
+(word) abs_u16::return#2 return zp[2]:8 20002.0
+(word) abs_u16::return#4 return zp[2]:8 5501.0
 (word) abs_u16::w
-(word) abs_u16::w#0 w zp[2]:8 4.0
-(word) abs_u16::w#2 w zp[2]:8 2.0
+(word) abs_u16::w#0 w zp[2]:8 2002.0
+(word) abs_u16::w#2 w zp[2]:8 7751.0
 (void()) bitmap_clear((byte) bitmap_clear::bgcol , (byte) bitmap_clear::fgcol)
 (label) bitmap_clear::@1
 (label) bitmap_clear::@return
@@ -34,10 +34,10 @@
 (byte) bitmap_clear::fgcol
 (byte*) bitmap_gfx
 (void()) bitmap_init((byte*) bitmap_init::gfx , (byte*) bitmap_init::screen)
-(byte~) bitmap_init::$4 reg byte a 22.0
-(byte~) bitmap_init::$5 reg byte a 22.0
-(byte~) bitmap_init::$6 reg byte a 22.0
-(byte~) bitmap_init::$7 zp[1]:24 5.5
+(byte~) bitmap_init::$4 reg byte a 2002.0
+(byte~) bitmap_init::$5 reg byte a 2002.0
+(byte~) bitmap_init::$6 reg byte a 2002.0
+(byte~) bitmap_init::$7 zp[1]:24 500.5
 (label) bitmap_init::@1
 (label) bitmap_init::@2
 (label) bitmap_init::@3
@@ -46,21 +46,21 @@
 (label) bitmap_init::@6
 (label) bitmap_init::@return
 (byte) bitmap_init::bits
-(byte) bitmap_init::bits#1 reg byte a 11.0
-(byte) bitmap_init::bits#3 reg byte a 16.5
-(byte) bitmap_init::bits#4 reg byte a 7.333333333333333
+(byte) bitmap_init::bits#1 reg byte a 1001.0
+(byte) bitmap_init::bits#3 reg byte a 1501.5
+(byte) bitmap_init::bits#4 reg byte a 667.3333333333334
 (byte*) bitmap_init::gfx
 (byte*) bitmap_init::screen
 (byte) bitmap_init::x
-(byte) bitmap_init::x#1 reg byte x 16.5
-(byte) bitmap_init::x#2 reg byte x 5.5
+(byte) bitmap_init::x#1 reg byte x 1501.5
+(byte) bitmap_init::x#2 reg byte x 500.5
 (byte) bitmap_init::y
-(byte) bitmap_init::y#1 reg byte x 16.5
-(byte) bitmap_init::y#2 reg byte x 5.5
+(byte) bitmap_init::y#1 reg byte x 1501.5
+(byte) bitmap_init::y#2 reg byte x 500.5
 (byte*) bitmap_init::yoffs
-(byte*) bitmap_init::yoffs#1 yoffs zp[2]:14 22.0
-(byte*) bitmap_init::yoffs#2 yoffs zp[2]:14 6.875
-(byte*) bitmap_init::yoffs#4 yoffs zp[2]:14 11.0
+(byte*) bitmap_init::yoffs#1 yoffs zp[2]:14 2002.0
+(byte*) bitmap_init::yoffs#2 yoffs zp[2]:14 625.625
+(byte*) bitmap_init::yoffs#4 yoffs zp[2]:14 1001.0
 (void()) bitmap_line((word) bitmap_line::x1 , (word) bitmap_line::y1 , (word) bitmap_line::x2 , (word) bitmap_line::y2)
 (label) bitmap_line::@1
 (label) bitmap_line::@10
@@ -82,64 +82,64 @@
 (label) bitmap_line::@9
 (label) bitmap_line::@return
 (word) bitmap_line::dx
-(word) bitmap_line::dx#0 dx zp[2]:16 8.18421052631579
+(word) bitmap_line::dx#0 dx zp[2]:16 8000.184210526315
 (word) bitmap_line::dy
-(word) bitmap_line::dy#0 dy zp[2]:8 8.885714285714286
+(word) bitmap_line::dy#0 dy zp[2]:8 8685.914285714285
 (word) bitmap_line::e
-(word) bitmap_line::e#0 e zp[2]:10 4.0
-(word) bitmap_line::e#1 e zp[2]:10 134.66666666666666
-(word) bitmap_line::e#2 e zp[2]:10 202.0
-(word) bitmap_line::e#3 e zp[2]:10 40.8
-(word) bitmap_line::e#6 e zp[2]:10 151.5
+(word) bitmap_line::e#0 e zp[2]:10 2002.0
+(word) bitmap_line::e#1 e zp[2]:10 133334.66666666666
+(word) bitmap_line::e#2 e zp[2]:10 200002.0
+(word) bitmap_line::e#3 e zp[2]:10 40200.600000000006
+(word) bitmap_line::e#6 e zp[2]:10 150001.5
 (word) bitmap_line::e1
-(word) bitmap_line::e1#0 e1 zp[2]:4 4.0
-(word) bitmap_line::e1#1 e1 zp[2]:4 134.66666666666666
-(word) bitmap_line::e1#2 e1 zp[2]:4 202.0
-(word) bitmap_line::e1#3 e1 zp[2]:4 40.8
-(word) bitmap_line::e1#6 e1 zp[2]:4 151.5
+(word) bitmap_line::e1#0 e1 zp[2]:4 2002.0
+(word) bitmap_line::e1#1 e1 zp[2]:4 133334.66666666666
+(word) bitmap_line::e1#2 e1 zp[2]:4 200002.0
+(word) bitmap_line::e1#3 e1 zp[2]:4 40200.600000000006
+(word) bitmap_line::e1#6 e1 zp[2]:4 150001.5
 (word) bitmap_line::sx
-(word) bitmap_line::sx#0 sx zp[2]:18 7.03448275862069
+(word) bitmap_line::sx#0 sx zp[2]:18 6931.137931034482
 (word) bitmap_line::sy
-(word) bitmap_line::sy#0 sy zp[2]:6 7.846153846153847
+(word) bitmap_line::sy#0 sy zp[2]:6 7730.884615384615
 (word) bitmap_line::x
-(word) bitmap_line::x#1 x zp[2]:14 101.0
-(word) bitmap_line::x#12 x zp[2]:14 202.0
-(word) bitmap_line::x#13 x zp[2]:14 57.714285714285715
-(word) bitmap_line::x#15 x zp[2]:14 57.714285714285715
-(word) bitmap_line::x#6 x zp[2]:14 102.0
-(word) bitmap_line::x#7 x zp[2]:14 75.75
+(word) bitmap_line::x#1 x zp[2]:14 100001.0
+(word) bitmap_line::x#12 x zp[2]:14 200002.0
+(word) bitmap_line::x#13 x zp[2]:14 57143.42857142857
+(word) bitmap_line::x#15 x zp[2]:14 57143.42857142857
+(word) bitmap_line::x#6 x zp[2]:14 100501.5
+(word) bitmap_line::x#7 x zp[2]:14 75000.75
 (word) bitmap_line::x1
 (const word) bitmap_line::x1#0 x1 = (byte) 0
 (word) bitmap_line::x2
-(word) bitmap_line::x2#0 x2 zp[2]:2 3.8666666666666667
+(word) bitmap_line::x2#0 x2 zp[2]:2 3403.4666666666667
 (word) bitmap_line::y
-(word) bitmap_line::y#1 y zp[2]:12 57.714285714285715
-(word) bitmap_line::y#13 y zp[2]:12 202.0
-(word) bitmap_line::y#15 y zp[2]:12 43.285714285714285
-(word) bitmap_line::y#2 y zp[2]:12 101.0
-(word) bitmap_line::y#4 y zp[2]:12 50.5
-(word) bitmap_line::y#7 y zp[2]:12 202.0
+(word) bitmap_line::y#1 y zp[2]:12 57143.42857142857
+(word) bitmap_line::y#13 y zp[2]:12 200002.0
+(word) bitmap_line::y#15 y zp[2]:12 42857.57142857143
+(word) bitmap_line::y#2 y zp[2]:12 100001.0
+(word) bitmap_line::y#4 y zp[2]:12 50000.5
+(word) bitmap_line::y#7 y zp[2]:12 200002.0
 (word) bitmap_line::y1
 (const word) bitmap_line::y1#0 y1 = (byte) 0
 (word) bitmap_line::y2
 (const word) bitmap_line::y2#0 y2 = (byte) $64
 (void()) bitmap_plot((word) bitmap_plot::x , (byte) bitmap_plot::y)
-(word~) bitmap_plot::$1 zp[2]:22 4.0
-(byte~) bitmap_plot::$2 reg byte a 4.0
+(word~) bitmap_plot::$1 zp[2]:22 2000002.0
+(byte~) bitmap_plot::$2 reg byte x 2000002.0
 (label) bitmap_plot::@return
 (byte*) bitmap_plot::plotter
-(word) bitmap_plot::plotter#0 plotter zp[2]:20 1.0
-(byte*) bitmap_plot::plotter#1 plotter zp[2]:20 3.0
+(word) bitmap_plot::plotter#0 plotter zp[2]:20 500000.5
+(byte*) bitmap_plot::plotter#1 plotter zp[2]:20 1500001.5
 (word) bitmap_plot::x
-(word) bitmap_plot::x#1 x zp[2]:14 202.0
-(word) bitmap_plot::x#2 x zp[2]:14 4.0
-(word) bitmap_plot::x#3 x zp[2]:14 202.0
-(word) bitmap_plot::x#4 x zp[2]:14 52.0
+(word) bitmap_plot::x#1 x zp[2]:14 200002.0
+(word) bitmap_plot::x#2 x zp[2]:14 2002.0
+(word) bitmap_plot::x#3 x zp[2]:14 200002.0
+(word) bitmap_plot::x#4 x zp[2]:14 550251.25
 (byte) bitmap_plot::y
-(byte) bitmap_plot::y#1 reg byte x 101.0
-(byte) bitmap_plot::y#2 reg byte x 2.0
-(byte) bitmap_plot::y#3 reg byte x 101.0
-(byte) bitmap_plot::y#4 reg byte x 208.0
+(byte) bitmap_plot::y#1 reg byte x 100001.0
+(byte) bitmap_plot::y#2 reg byte x 1001.0
+(byte) bitmap_plot::y#3 reg byte x 100001.0
+(byte) bitmap_plot::y#4 reg byte x 2201005.0
 (const byte*) bitmap_plot_bit[(number) $100]  = { fill( $100, 0) }
 (const byte*) bitmap_plot_yhi[(number) $100]  = { fill( $100, 0) }
 (const byte*) bitmap_plot_ylo[(number) $100]  = { fill( $100, 0) }
@@ -156,34 +156,34 @@
 (label) memset::@3
 (label) memset::@return
 (byte) memset::c
-(byte) memset::c#4 reg byte x 1.375
+(byte) memset::c#4 reg byte x 1250.125
 (byte*) memset::dst
-(byte*) memset::dst#1 dst zp[2]:12 22.0
-(byte*) memset::dst#2 dst zp[2]:12 15.333333333333332
-(byte*) memset::dst#4 dst zp[2]:12 4.0
+(byte*) memset::dst#1 dst zp[2]:12 20002.0
+(byte*) memset::dst#2 dst zp[2]:12 13668.333333333332
+(byte*) memset::dst#4 dst zp[2]:12 2002.0
 (byte*) memset::end
-(byte*) memset::end#0 end zp[2]:10 2.1666666666666665
+(byte*) memset::end#0 end zp[2]:10 1833.6666666666665
 (word) memset::num
-(word) memset::num#2 num zp[2]:10 2.0
+(word) memset::num#2 num zp[2]:10 1001.0
 (void*) memset::return
 (void*) memset::str
 (void*) memset::str#3 str zp[2]:12
 (word) next
-(word) next#1 next zp[2]:2 11.0
-(word) next#3 next zp[2]:2 22.0
-(word) next#5 next zp[2]:2 11.0
+(word) next#1 next zp[2]:2 101.0
+(word) next#3 next zp[2]:2 202.0
+(word) next#5 next zp[2]:2 101.0
 (word()) sgn_u16((word) sgn_u16::w)
-(byte~) sgn_u16::$0 reg byte a 4.0
-(byte~) sgn_u16::$1 reg byte a 4.0
+(byte~) sgn_u16::$0 reg byte a 20002.0
+(byte~) sgn_u16::$1 reg byte a 20002.0
 (label) sgn_u16::@1
 (label) sgn_u16::@return
 (word) sgn_u16::return
-(word) sgn_u16::return#0 return zp[2]:6 4.0
-(word) sgn_u16::return#1 return zp[2]:6 4.0
-(word) sgn_u16::return#4 return zp[2]:6 1.0
+(word) sgn_u16::return#0 return zp[2]:6 2002.0
+(word) sgn_u16::return#1 return zp[2]:6 2002.0
+(word) sgn_u16::return#4 return zp[2]:6 500.5
 (word) sgn_u16::w
-(word) sgn_u16::w#0 w zp[2]:20 4.0
-(word) sgn_u16::w#2 w zp[2]:20 4.0
+(word) sgn_u16::w#0 w zp[2]:20 2002.0
+(word) sgn_u16::w#2 w zp[2]:20 11002.0
 
 zp[2]:2 [ next#5 next#3 next#1 bitmap_line::x2#0 ]
 zp[2]:4 [ bitmap_line::e1#3 bitmap_line::e1#6 bitmap_line::e1#0 bitmap_line::e1#2 bitmap_line::e1#1 ]
@@ -201,7 +201,7 @@ zp[2]:16 [ bitmap_line::dx#0 ]
 zp[2]:18 [ bitmap_line::sx#0 ]
 zp[2]:20 [ bitmap_plot::plotter#0 bitmap_plot::plotter#1 sgn_u16::w#2 sgn_u16::w#0 ]
 zp[2]:22 [ bitmap_plot::$1 ]
-reg byte a [ bitmap_plot::$2 ]
+reg byte x [ bitmap_plot::$2 ]
 reg byte a [ sgn_u16::$0 ]
 reg byte a [ sgn_u16::$1 ]
 reg byte a [ abs_u16::$0 ]

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

@@ -156,10 +156,9 @@ bitmap_plot: {
     adc.z __1+1
     sta.z plotter+1
     // <x
-    lda.z x
+    ldx.z x
     // *plotter |= bitmap_plot_bit[<x]
-    tay
-    lda bitmap_plot_bit,y
+    lda bitmap_plot_bit,x
     ldy #0
     ora (plotter),y
     sta (plotter),y

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

@@ -874,71 +874,71 @@ Inversing boolean not [31] (bool~) bitmap_init::$1 ← (byte) bitmap_init::bits#
 Inversing boolean not [51] (bool~) bitmap_init::$9 ← (byte~) bitmap_init::$7 != (byte) 7 from [50] (bool~) bitmap_init::$8 ← (byte~) bitmap_init::$7 == (byte) 7
 Inversing boolean not [171] (bool~) irq::$0 ← (byte) 0 == (byte) frame_cnt from [170] (bool~) irq::$1 ← (byte) 0 != (byte) frame_cnt
 Successful SSA optimization Pass2UnaryNotSimplification
-Alias (void*) memset::return#0 = (void*) memset::str#2 (void*) memset::return#4 (void*) memset::return#1 
-Alias (void*) memset::str#3 = (void*) memset::str#4 
-Alias (word) memset::num#2 = (word) memset::num#3 
-Alias (byte) memset::c#4 = (byte) memset::c#5 
-Alias (byte*) memset::end#0 = (byte*~) memset::$3 
-Alias (byte) memset::c#2 = (byte) memset::c#3 
-Alias (byte*) memset::dst#2 = (byte*) memset::dst#3 
-Alias (byte*) memset::end#1 = (byte*) memset::end#2 
-Alias (void*) memset::str#5 = (void*) memset::str#6 
-Alias (byte) bitmap_init::x#2 = (byte) bitmap_init::x#4 
-Alias (byte*) bitmap_init::gfx#4 = (byte*) bitmap_init::gfx#5 
-Alias (byte*) bitmap_gfx#29 = (byte*) bitmap_gfx#30 
-Alias (byte*) bitmap_screen#28 = (byte*) bitmap_screen#29 
-Alias (byte*) bitmap_init::gfx#2 = (byte*) bitmap_init::gfx#3 (byte*) bitmap_init::yoffs#0 
-Alias (byte*) bitmap_gfx#21 = (byte*) bitmap_gfx#25 
-Alias (byte*) bitmap_screen#20 = (byte*) bitmap_screen#24 
-Alias (byte*) bitmap_init::yoffs#2 = (byte*) bitmap_init::yoffs#3 
-Alias (byte) bitmap_init::y#2 = (byte) bitmap_init::y#4 
-Alias (byte*) bitmap_gfx#16 = (byte*) bitmap_gfx#17 
-Alias (byte*) bitmap_screen#15 = (byte*) bitmap_screen#16 
-Alias (byte*) bitmap_init::yoffs#1 = (byte*~) bitmap_init::$10 
-Alias (byte*) bitmap_gfx#11 = (byte*) bitmap_gfx#6 (byte*) bitmap_gfx#2 
-Alias (byte*) bitmap_screen#11 = (byte*) bitmap_screen#6 (byte*) bitmap_screen#2 
-Alias (byte) bitmap_clear::col#0 = (byte~) bitmap_clear::$1 
-Alias (byte*) bitmap_gfx#12 = (byte*) bitmap_gfx#7 
-Alias (byte*) bitmap_plot::plotter#0 = (byte*~) bitmap_plot::$0 
-Alias (byte*) bitmap_gfx#18 = (byte*) bitmap_gfx#3 (byte*) bitmap_gfx#8 (byte*) bitmap_gfx#33 (byte*) bitmap_gfx#31 (byte*) bitmap_gfx#26 (byte*) bitmap_gfx#22 
-Alias (byte*) bitmap_screen#17 = (byte*) bitmap_screen#3 (byte*) bitmap_screen#8 (byte*) bitmap_screen#32 (byte*) bitmap_screen#30 (byte*) bitmap_screen#25 (byte*) bitmap_screen#21 
-Alias (byte*) main::toD0181_screen#0 = (byte*) main::toD0181_screen#1 
-Alias (byte*) main::toD0181_gfx#0 = (byte*) main::toD0181_gfx#1 
-Alias (byte) main::toD0181_return#0 = (byte~) main::toD0181_$8 (byte) main::toD0181_return#2 (byte) main::toD0181_return#1 (byte) main::toD0181_return#3 (byte~) main::$2 
-Alias (word) main::x#2 = (word) main::x#4 (word) main::x#3 
-Alias (byte) main::y#2 = (byte) main::y#5 (byte) main::y#3 
-Alias (word) main::vx#2 = (word) main::vx#4 (word) main::vx#5 (word) main::vx#3 
-Alias (byte) main::vy#2 = (byte) main::vy#4 (byte) main::vy#6 (byte) main::vy#7 
-Alias (byte*) bitmap_gfx#14 = (byte*) bitmap_gfx#32 (byte*) bitmap_gfx#27 (byte*) bitmap_gfx#28 (byte*) bitmap_gfx#9 (byte*) bitmap_gfx#4 
-Alias (byte*) bitmap_screen#13 = (byte*) bitmap_screen#31 (byte*) bitmap_screen#26 (byte*) bitmap_screen#27 (byte*) bitmap_screen#9 (byte*) bitmap_screen#4 
-Alias (byte) main::y#1 = (byte) main::y#6 
-Alias (word) main::x#1 = (word) main::x#8 
-Alias (word) main::vx#1 = (word~) main::$9 
-Alias (byte) main::vy#3 = (byte) main::vy#5 
-Alias (word) main::x#6 = (word) main::x#7 
-Alias (byte) main::y#4 = (byte) main::y#8 
-Alias (byte*) bitmap_gfx#23 = (byte*) bitmap_gfx#24 
-Alias (byte*) bitmap_screen#22 = (byte*) bitmap_screen#23 
-Alias (word) main::vx#7 = (word) main::vx#8 
-Alias (byte) main::vy#1 = (byte~) main::$14 
-Alias (byte*) bitmap_gfx#0 = (byte*) bitmap_gfx#20 (byte*) bitmap_gfx#15 
-Alias (byte*) bitmap_screen#0 = (byte*) bitmap_screen#19 (byte*) bitmap_screen#14 
-Alias (byte*) bitmap_gfx#10 = (byte*) bitmap_gfx#5 
-Alias (byte*) bitmap_screen#10 = (byte*) bitmap_screen#5 
+Alias memset::return#0 = memset::str#2 memset::return#4 memset::return#1 
+Alias memset::str#3 = memset::str#4 
+Alias memset::num#2 = memset::num#3 
+Alias memset::c#4 = memset::c#5 
+Alias memset::end#0 = memset::$3 
+Alias memset::c#2 = memset::c#3 
+Alias memset::dst#2 = memset::dst#3 
+Alias memset::end#1 = memset::end#2 
+Alias memset::str#5 = memset::str#6 
+Alias bitmap_init::x#2 = bitmap_init::x#4 
+Alias bitmap_init::gfx#4 = bitmap_init::gfx#5 
+Alias bitmap_gfx#29 = bitmap_gfx#30 
+Alias bitmap_screen#28 = bitmap_screen#29 
+Alias bitmap_init::gfx#2 = bitmap_init::gfx#3 bitmap_init::yoffs#0 
+Alias bitmap_gfx#21 = bitmap_gfx#25 
+Alias bitmap_screen#20 = bitmap_screen#24 
+Alias bitmap_init::yoffs#2 = bitmap_init::yoffs#3 
+Alias bitmap_init::y#2 = bitmap_init::y#4 
+Alias bitmap_gfx#16 = bitmap_gfx#17 
+Alias bitmap_screen#15 = bitmap_screen#16 
+Alias bitmap_init::yoffs#1 = bitmap_init::$10 
+Alias bitmap_gfx#11 = bitmap_gfx#6 bitmap_gfx#2 
+Alias bitmap_screen#11 = bitmap_screen#6 bitmap_screen#2 
+Alias bitmap_clear::col#0 = bitmap_clear::$1 
+Alias bitmap_gfx#12 = bitmap_gfx#7 
+Alias bitmap_plot::plotter#0 = bitmap_plot::$0 
+Alias bitmap_gfx#18 = bitmap_gfx#3 bitmap_gfx#8 bitmap_gfx#33 bitmap_gfx#31 bitmap_gfx#26 bitmap_gfx#22 
+Alias bitmap_screen#17 = bitmap_screen#3 bitmap_screen#8 bitmap_screen#32 bitmap_screen#30 bitmap_screen#25 bitmap_screen#21 
+Alias main::toD0181_screen#0 = main::toD0181_screen#1 
+Alias main::toD0181_gfx#0 = main::toD0181_gfx#1 
+Alias main::toD0181_return#0 = main::toD0181_$8 main::toD0181_return#2 main::toD0181_return#1 main::toD0181_return#3 main::$2 
+Alias main::x#2 = main::x#4 main::x#3 
+Alias main::y#2 = main::y#5 main::y#3 
+Alias main::vx#2 = main::vx#4 main::vx#5 main::vx#3 
+Alias main::vy#2 = main::vy#4 main::vy#6 main::vy#7 
+Alias bitmap_gfx#14 = bitmap_gfx#32 bitmap_gfx#27 bitmap_gfx#28 bitmap_gfx#9 bitmap_gfx#4 
+Alias bitmap_screen#13 = bitmap_screen#31 bitmap_screen#26 bitmap_screen#27 bitmap_screen#9 bitmap_screen#4 
+Alias main::y#1 = main::y#6 
+Alias main::x#1 = main::x#8 
+Alias main::vx#1 = main::$9 
+Alias main::vy#3 = main::vy#5 
+Alias main::x#6 = main::x#7 
+Alias main::y#4 = main::y#8 
+Alias bitmap_gfx#23 = bitmap_gfx#24 
+Alias bitmap_screen#22 = bitmap_screen#23 
+Alias main::vx#7 = main::vx#8 
+Alias main::vy#1 = main::$14 
+Alias bitmap_gfx#0 = bitmap_gfx#20 bitmap_gfx#15 
+Alias bitmap_screen#0 = bitmap_screen#19 bitmap_screen#14 
+Alias bitmap_gfx#10 = bitmap_gfx#5 
+Alias bitmap_screen#10 = bitmap_screen#5 
 Successful SSA optimization Pass2AliasElimination
-Alias (byte) bitmap_init::x#2 = (byte) bitmap_init::x#3 
-Alias (byte*) bitmap_init::gfx#2 = (byte*) bitmap_init::gfx#4 
-Alias (byte*) bitmap_gfx#21 = (byte*) bitmap_gfx#29 
-Alias (byte*) bitmap_screen#20 = (byte*) bitmap_screen#28 
-Alias (byte) bitmap_init::y#2 = (byte) bitmap_init::y#3 
-Alias (byte*) bitmap_gfx#11 = (byte*) bitmap_gfx#16 
-Alias (byte*) bitmap_screen#11 = (byte*) bitmap_screen#15 
-Alias (byte) main::y#1 = (byte) main::y#4 (byte) main::y#7 
-Alias (byte) main::vy#2 = (byte) main::vy#3 
-Alias (word) main::x#1 = (word) main::x#6 (word) main::x#5 
-Alias (byte*) bitmap_gfx#14 = (byte*) bitmap_gfx#23 (byte*) bitmap_gfx#19 
-Alias (byte*) bitmap_screen#13 = (byte*) bitmap_screen#22 (byte*) bitmap_screen#18 
-Alias (word) main::vx#6 = (word) main::vx#7 
+Alias bitmap_init::x#2 = bitmap_init::x#3 
+Alias bitmap_init::gfx#2 = bitmap_init::gfx#4 
+Alias bitmap_gfx#21 = bitmap_gfx#29 
+Alias bitmap_screen#20 = bitmap_screen#28 
+Alias bitmap_init::y#2 = bitmap_init::y#3 
+Alias bitmap_gfx#11 = bitmap_gfx#16 
+Alias bitmap_screen#11 = bitmap_screen#15 
+Alias main::y#1 = main::y#4 main::y#7 
+Alias main::vy#2 = main::vy#3 
+Alias main::x#1 = main::x#6 main::x#5 
+Alias bitmap_gfx#14 = bitmap_gfx#23 bitmap_gfx#19 
+Alias bitmap_screen#13 = bitmap_screen#22 bitmap_screen#18 
+Alias main::vx#6 = main::vx#7 
 Successful SSA optimization Pass2AliasElimination
 Identical Phi Values (byte*) memset::end#1 (byte*) memset::end#0
 Identical Phi Values (void*) memset::str#5 (void*) memset::str#3
@@ -1037,8 +1037,8 @@ Successful SSA optimization PassNCastSimplification
 Finalized unsigned number type (byte) 0
 Finalized unsigned number type (byte) 0
 Successful SSA optimization PassNFinalizeNumberTypeConversions
-Alias (byte~) bitmap_init::$7 = (byte~) bitmap_init::$3 
-Alias (byte) bitmap_clear::col#0 = (byte~) bitmap_clear::$0 
+Alias bitmap_init::$7 = bitmap_init::$3 
+Alias bitmap_clear::col#0 = bitmap_clear::$0 
 Successful SSA optimization Pass2AliasElimination
 Simple Condition (bool~) main::$5 [62] if((word) main::x#1==(word) $13f) goto main::@8
 Simple Condition (bool~) main::$10 [66] if((byte) main::y#1==(byte) $c7) goto main::@9
@@ -1412,38 +1412,38 @@ VARIABLE REGISTER WEIGHTS
 (byte) bitmap_clear::fgcol
 (byte*) bitmap_gfx
 (void()) bitmap_init((byte*) bitmap_init::gfx , (byte*) bitmap_init::screen)
-(byte~) bitmap_init::$4 22.0
-(byte~) bitmap_init::$5 22.0
-(byte~) bitmap_init::$6 22.0
-(byte~) bitmap_init::$7 5.5
+(byte~) bitmap_init::$4 2002.0
+(byte~) bitmap_init::$5 2002.0
+(byte~) bitmap_init::$6 2002.0
+(byte~) bitmap_init::$7 500.5
 (byte) bitmap_init::bits
-(byte) bitmap_init::bits#1 11.0
-(byte) bitmap_init::bits#3 16.5
-(byte) bitmap_init::bits#4 7.333333333333333
+(byte) bitmap_init::bits#1 1001.0
+(byte) bitmap_init::bits#3 1501.5
+(byte) bitmap_init::bits#4 667.3333333333334
 (byte*) bitmap_init::gfx
 (byte*) bitmap_init::screen
 (byte) bitmap_init::x
-(byte) bitmap_init::x#1 16.5
-(byte) bitmap_init::x#2 5.5
+(byte) bitmap_init::x#1 1501.5
+(byte) bitmap_init::x#2 500.5
 (byte) bitmap_init::y
-(byte) bitmap_init::y#1 16.5
-(byte) bitmap_init::y#2 5.5
+(byte) bitmap_init::y#1 1501.5
+(byte) bitmap_init::y#2 500.5
 (byte*) bitmap_init::yoffs
-(byte*) bitmap_init::yoffs#1 22.0
-(byte*) bitmap_init::yoffs#2 6.875
-(byte*) bitmap_init::yoffs#4 11.0
+(byte*) bitmap_init::yoffs#1 2002.0
+(byte*) bitmap_init::yoffs#2 625.625
+(byte*) bitmap_init::yoffs#4 1001.0
 (void()) bitmap_plot((word) bitmap_plot::x , (byte) bitmap_plot::y)
-(word~) bitmap_plot::$1 4.0
-(byte~) bitmap_plot::$2 4.0
+(word~) bitmap_plot::$1 2002.0
+(byte~) bitmap_plot::$2 2002.0
 (byte*) bitmap_plot::plotter
-(word) bitmap_plot::plotter#0 1.0
-(byte*) bitmap_plot::plotter#1 3.0
+(word) bitmap_plot::plotter#0 500.5
+(byte*) bitmap_plot::plotter#1 1501.5
 (word) bitmap_plot::x
-(word) bitmap_plot::x#0 3.0
+(word) bitmap_plot::x#0 420.59999999999997
 (byte) bitmap_plot::y
-(byte) bitmap_plot::y#0 15.0
+(byte) bitmap_plot::y#0 2103.0
 (byte*) bitmap_screen
-(byte) frame_cnt loadstore 1.1111111111111112
+(byte) frame_cnt loadstore 7.777777777777779
 (void()) init_irq()
 interrupt(HARDWARE_CLOBBER)(void()) irq()
 (void()) main()
@@ -1451,30 +1451,30 @@ interrupt(HARDWARE_CLOBBER)(void()) irq()
 (byte) main::toD0181_return
 (byte*) main::toD0181_screen
 (word) main::vx
-(word) main::vx#1 22.0
-(word) main::vx#2 5.5
-(word) main::vx#6 5.5
+(word) main::vx#1 202.0
+(word) main::vx#2 50.5
+(word) main::vx#6 50.5
 (byte) main::vy
-(byte) main::vy#1 22.0
-(byte) main::vy#2 3.6666666666666665
-(byte) main::vy#8 16.5
+(byte) main::vy#1 202.0
+(byte) main::vy#2 33.666666666666664
+(byte) main::vy#8 151.5
 (word) main::x
-(word) main::x#1 4.0
-(word) main::x#2 8.25
+(word) main::x#1 36.72727272727273
+(word) main::x#2 75.75
 (byte) main::y
-(byte) main::y#1 4.4
-(byte) main::y#2 6.6000000000000005
+(byte) main::y#1 40.4
+(byte) main::y#2 60.599999999999994
 (void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num)
 (byte) memset::c
-(byte) memset::c#4 1.375
+(byte) memset::c#4 1250.125
 (byte*) memset::dst
-(byte*) memset::dst#1 22.0
-(byte*) memset::dst#2 15.333333333333332
-(byte*) memset::dst#4 4.0
+(byte*) memset::dst#1 20002.0
+(byte*) memset::dst#2 13668.333333333332
+(byte*) memset::dst#4 2002.0
 (byte*) memset::end
-(byte*) memset::end#0 2.1666666666666665
+(byte*) memset::end#0 1833.6666666666665
 (word) memset::num
-(word) memset::num#2 2.0
+(word) memset::num#2 1001.0
 (void*) memset::return
 (void*) memset::str
 (void*) memset::str#3
@@ -2169,86 +2169,84 @@ irq: {
 
 REGISTER UPLIFT POTENTIAL REGISTERS
 Equivalence Class zp[1]:34 [ bitmap_init::$4 ] has ALU potential.
-Statement [1] (byte) frame_cnt ← (byte) 1 [ frame_cnt ] (  [ frame_cnt ] ) always clobbers reg byte a 
-Statement [9] *((const byte*) D011) ← (const byte) VIC_BMM|(const byte) VIC_DEN|(const byte) VIC_RSEL|(byte) 3 [ frame_cnt ] ( main:3 [ frame_cnt ] ) always clobbers reg byte a 
-Statement [11] *((const byte*) D018) ← (const byte) main::toD0181_return#0 [ frame_cnt ] ( main:3 [ frame_cnt ] ) always clobbers reg byte a 
-Statement [14] (word) bitmap_plot::x#0 ← (word) main::x#2 [ frame_cnt main::x#2 main::y#2 main::vx#2 main::vy#2 bitmap_plot::x#0 ] ( main:3 [ frame_cnt main::x#2 main::y#2 main::vx#2 main::vy#2 bitmap_plot::x#0 ] ) always clobbers reg byte a 
+Statement [1] (byte) frame_cnt ← (byte) 1 [ frame_cnt ] (  [ frame_cnt ] { }  ) always clobbers reg byte a 
+Statement [9] *((const byte*) D011) ← (const byte) VIC_BMM|(const byte) VIC_DEN|(const byte) VIC_RSEL|(byte) 3 [ frame_cnt ] ( main:3 [ frame_cnt ] { }  ) always clobbers reg byte a 
+Statement [11] *((const byte*) D018) ← (const byte) main::toD0181_return#0 [ frame_cnt ] ( main:3 [ frame_cnt ] { }  ) always clobbers reg byte a 
+Statement [14] (word) bitmap_plot::x#0 ← (word) main::x#2 [ frame_cnt main::x#2 main::y#2 main::vx#2 main::vy#2 bitmap_plot::x#0 ] ( main:3 [ frame_cnt main::x#2 main::y#2 main::vx#2 main::vy#2 bitmap_plot::x#0 ] { { bitmap_plot::x#0 = main::x#2 } { bitmap_plot::y#0 = main::y#2 } }  ) always clobbers reg byte a 
 Removing always clobbered register reg byte a as potential for zp[1]:4 [ main::y#2 main::y#1 ]
 Removing always clobbered register reg byte a as potential for zp[1]:7 [ main::vy#2 main::vy#8 main::vy#1 ]
-Statement [17] (word) main::x#1 ← (word) main::x#2 + (word) main::vx#2 [ frame_cnt main::y#2 main::vx#2 main::vy#2 main::x#1 ] ( main:3 [ frame_cnt main::y#2 main::vx#2 main::vy#2 main::x#1 ] ) always clobbers reg byte a 
-Statement [18] (byte) main::y#1 ← (byte) main::y#2 + (byte) main::vy#2 [ frame_cnt main::vx#2 main::vy#2 main::x#1 main::y#1 ] ( main:3 [ frame_cnt main::vx#2 main::vy#2 main::x#1 main::y#1 ] ) always clobbers reg byte a 
-Statement [19] if((word) main::x#1==(word) $13f) goto main::@5 [ frame_cnt main::vx#2 main::vy#2 main::x#1 main::y#1 ] ( main:3 [ frame_cnt main::vx#2 main::vy#2 main::x#1 main::y#1 ] ) always clobbers reg byte a 
-Statement [20] if((word) main::x#1!=(byte) 0) goto main::@3 [ frame_cnt main::vx#2 main::vy#2 main::x#1 main::y#1 ] ( main:3 [ frame_cnt main::vx#2 main::vy#2 main::x#1 main::y#1 ] ) always clobbers reg byte a 
-Statement [21] (word) main::vx#1 ← - (word) main::vx#2 [ frame_cnt main::vy#2 main::x#1 main::y#1 main::vx#1 ] ( main:3 [ frame_cnt main::vy#2 main::x#1 main::y#1 main::vx#1 ] ) always clobbers reg byte a 
-Statement [25] (byte) main::vy#1 ← - (byte) main::vy#2 [ frame_cnt main::x#1 main::y#1 main::vx#6 main::vy#1 ] ( main:3 [ frame_cnt main::x#1 main::y#1 main::vx#6 main::vy#1 ] ) always clobbers reg byte a 
-Statement [27] *((const byte*) plots_per_frame + (byte) frame_cnt) ← ++ *((const byte*) plots_per_frame + (byte) frame_cnt) [ frame_cnt main::x#1 main::y#1 main::vx#6 main::vy#8 ] ( main:3 [ frame_cnt main::x#1 main::y#1 main::vx#6 main::vy#8 ] ) always clobbers reg byte x 
+Statement [17] (word) main::x#1 ← (word) main::x#2 + (word) main::vx#2 [ frame_cnt main::y#2 main::vx#2 main::vy#2 main::x#1 ] ( main:3 [ frame_cnt main::y#2 main::vx#2 main::vy#2 main::x#1 ] { }  ) always clobbers reg byte a 
+Statement [18] (byte) main::y#1 ← (byte) main::y#2 + (byte) main::vy#2 [ frame_cnt main::vx#2 main::vy#2 main::x#1 main::y#1 ] ( main:3 [ frame_cnt main::vx#2 main::vy#2 main::x#1 main::y#1 ] { }  ) always clobbers reg byte a 
+Statement [19] if((word) main::x#1==(word) $13f) goto main::@5 [ frame_cnt main::vx#2 main::vy#2 main::x#1 main::y#1 ] ( main:3 [ frame_cnt main::vx#2 main::vy#2 main::x#1 main::y#1 ] { }  ) always clobbers reg byte a 
+Statement [20] if((word) main::x#1!=(byte) 0) goto main::@3 [ frame_cnt main::vx#2 main::vy#2 main::x#1 main::y#1 ] ( main:3 [ frame_cnt main::vx#2 main::vy#2 main::x#1 main::y#1 ] { }  ) always clobbers reg byte a 
+Statement [21] (word) main::vx#1 ← - (word) main::vx#2 [ frame_cnt main::vy#2 main::x#1 main::y#1 main::vx#1 ] ( main:3 [ frame_cnt main::vy#2 main::x#1 main::y#1 main::vx#1 ] { }  ) always clobbers reg byte a 
+Statement [25] (byte) main::vy#1 ← - (byte) main::vy#2 [ frame_cnt main::x#1 main::y#1 main::vx#6 main::vy#1 ] ( main:3 [ frame_cnt main::x#1 main::y#1 main::vx#6 main::vy#1 ] { }  ) always clobbers reg byte a 
+Statement [27] *((const byte*) plots_per_frame + (byte) frame_cnt) ← ++ *((const byte*) plots_per_frame + (byte) frame_cnt) [ frame_cnt main::x#1 main::y#1 main::vx#6 main::vy#8 ] ( main:3 [ frame_cnt main::x#1 main::y#1 main::vx#6 main::vy#8 ] { }  ) always clobbers reg byte x 
 Removing always clobbered register reg byte x as potential for zp[1]:4 [ main::y#2 main::y#1 ]
 Removing always clobbered register reg byte x as potential for zp[1]:7 [ main::vy#2 main::vy#8 main::vy#1 ]
-Statement [28] (word) bitmap_plot::plotter#0 ← *((const byte*) bitmap_plot_yhi + (byte) bitmap_plot::y#0) w= *((const byte*) bitmap_plot_ylo + (byte) bitmap_plot::y#0) [ bitmap_plot::x#0 bitmap_plot::plotter#0 ] ( main:3::bitmap_plot:16 [ frame_cnt main::x#2 main::y#2 main::vx#2 main::vy#2 bitmap_plot::x#0 bitmap_plot::plotter#0 ] ) always clobbers reg byte a 
-Statement [29] (word~) bitmap_plot::$1 ← (word) bitmap_plot::x#0 & (word) $fff8 [ bitmap_plot::x#0 bitmap_plot::plotter#0 bitmap_plot::$1 ] ( main:3::bitmap_plot:16 [ frame_cnt main::x#2 main::y#2 main::vx#2 main::vy#2 bitmap_plot::x#0 bitmap_plot::plotter#0 bitmap_plot::$1 ] ) always clobbers reg byte a 
-Statement [30] (byte*) bitmap_plot::plotter#1 ← (byte*)(word) bitmap_plot::plotter#0 + (word~) bitmap_plot::$1 [ bitmap_plot::x#0 bitmap_plot::plotter#1 ] ( main:3::bitmap_plot:16 [ frame_cnt main::x#2 main::y#2 main::vx#2 main::vy#2 bitmap_plot::x#0 bitmap_plot::plotter#1 ] ) always clobbers reg byte a 
-Statement [31] (byte~) bitmap_plot::$2 ← < (word) bitmap_plot::x#0 [ bitmap_plot::plotter#1 bitmap_plot::$2 ] ( main:3::bitmap_plot:16 [ frame_cnt main::x#2 main::y#2 main::vx#2 main::vy#2 bitmap_plot::plotter#1 bitmap_plot::$2 ] ) always clobbers reg byte a 
-Statement [32] *((byte*) bitmap_plot::plotter#1) ← *((byte*) bitmap_plot::plotter#1) | *((const byte*) bitmap_plot_bit + (byte~) bitmap_plot::$2) [ ] ( main:3::bitmap_plot:16 [ frame_cnt main::x#2 main::y#2 main::vx#2 main::vy#2 ] ) always clobbers reg byte a reg byte y 
+Statement [28] (word) bitmap_plot::plotter#0 ← *((const byte*) bitmap_plot_yhi + (byte) bitmap_plot::y#0) w= *((const byte*) bitmap_plot_ylo + (byte) bitmap_plot::y#0) [ bitmap_plot::x#0 bitmap_plot::plotter#0 ] ( main:3::bitmap_plot:16 [ frame_cnt main::x#2 main::y#2 main::vx#2 main::vy#2 bitmap_plot::x#0 bitmap_plot::plotter#0 ] { { bitmap_plot::x#0 = main::x#2 } { bitmap_plot::y#0 = main::y#2 } }  ) always clobbers reg byte a 
+Statement [29] (word~) bitmap_plot::$1 ← (word) bitmap_plot::x#0 & (word) $fff8 [ bitmap_plot::x#0 bitmap_plot::plotter#0 bitmap_plot::$1 ] ( main:3::bitmap_plot:16 [ frame_cnt main::x#2 main::y#2 main::vx#2 main::vy#2 bitmap_plot::x#0 bitmap_plot::plotter#0 bitmap_plot::$1 ] { { bitmap_plot::x#0 = main::x#2 } { bitmap_plot::y#0 = main::y#2 } }  ) always clobbers reg byte a 
+Statement [30] (byte*) bitmap_plot::plotter#1 ← (byte*)(word) bitmap_plot::plotter#0 + (word~) bitmap_plot::$1 [ bitmap_plot::x#0 bitmap_plot::plotter#1 ] ( main:3::bitmap_plot:16 [ frame_cnt main::x#2 main::y#2 main::vx#2 main::vy#2 bitmap_plot::x#0 bitmap_plot::plotter#1 ] { { bitmap_plot::x#0 = main::x#2 } { bitmap_plot::y#0 = main::y#2 } }  ) always clobbers reg byte a 
+Statement [32] *((byte*) bitmap_plot::plotter#1) ← *((byte*) bitmap_plot::plotter#1) | *((const byte*) bitmap_plot_bit + (byte~) bitmap_plot::$2) [ ] ( main:3::bitmap_plot:16 [ frame_cnt main::x#2 main::y#2 main::vx#2 main::vy#2 ] { { bitmap_plot::x#0 = main::x#2 } { bitmap_plot::y#0 = main::y#2 } }  ) always clobbers reg byte a reg byte y 
 Removing always clobbered register reg byte y as potential for zp[1]:4 [ main::y#2 main::y#1 ]
 Removing always clobbered register reg byte y as potential for zp[1]:7 [ main::vy#2 main::vy#8 main::vy#1 ]
-Statement [35] *((const byte*) PROCPORT_DDR) ← (const byte) PROCPORT_DDR_MEMORY_MASK [ ] ( main:3::init_irq:12 [ frame_cnt ] ) always clobbers reg byte a 
-Statement [36] *((const byte*) PROCPORT) ← (const byte) PROCPORT_RAM_IO [ ] ( main:3::init_irq:12 [ frame_cnt ] ) always clobbers reg byte a 
-Statement [37] *((const byte*) CIA1_INTERRUPT) ← (const byte) CIA_INTERRUPT_CLEAR [ ] ( main:3::init_irq:12 [ frame_cnt ] ) always clobbers reg byte a 
-Statement [38] *((const byte*) VIC_CONTROL) ← *((const byte*) VIC_CONTROL) | (byte) $80 [ ] ( main:3::init_irq:12 [ frame_cnt ] ) always clobbers reg byte a 
-Statement [39] *((const byte*) RASTER) ← (byte) 0 [ ] ( main:3::init_irq:12 [ frame_cnt ] ) always clobbers reg byte a 
-Statement [40] *((const byte*) IRQ_ENABLE) ← (const byte) IRQ_RASTER [ ] ( main:3::init_irq:12 [ frame_cnt ] ) always clobbers reg byte a 
-Statement [41] *((const void()**) HARDWARE_IRQ) ← &interrupt(HARDWARE_CLOBBER)(void()) irq() [ ] ( main:3::init_irq:12 [ frame_cnt ] ) always clobbers reg byte a 
-Statement [50] if((word) memset::num#2<=(byte) 0) goto memset::@return [ memset::num#2 memset::str#3 memset::c#4 ] ( main:3::bitmap_clear:8::memset:45 [ frame_cnt memset::num#2 memset::str#3 memset::c#4 ] main:3::bitmap_clear:8::memset:47 [ frame_cnt memset::num#2 memset::str#3 memset::c#4 ] ) always clobbers reg byte a 
+Statement [35] *((const byte*) PROCPORT_DDR) ← (const byte) PROCPORT_DDR_MEMORY_MASK [ ] ( main:3::init_irq:12 [ frame_cnt ] { }  ) always clobbers reg byte a 
+Statement [36] *((const byte*) PROCPORT) ← (const byte) PROCPORT_RAM_IO [ ] ( main:3::init_irq:12 [ frame_cnt ] { }  ) always clobbers reg byte a 
+Statement [37] *((const byte*) CIA1_INTERRUPT) ← (const byte) CIA_INTERRUPT_CLEAR [ ] ( main:3::init_irq:12 [ frame_cnt ] { }  ) always clobbers reg byte a 
+Statement [38] *((const byte*) VIC_CONTROL) ← *((const byte*) VIC_CONTROL) | (byte) $80 [ ] ( main:3::init_irq:12 [ frame_cnt ] { }  ) always clobbers reg byte a 
+Statement [39] *((const byte*) RASTER) ← (byte) 0 [ ] ( main:3::init_irq:12 [ frame_cnt ] { }  ) always clobbers reg byte a 
+Statement [40] *((const byte*) IRQ_ENABLE) ← (const byte) IRQ_RASTER [ ] ( main:3::init_irq:12 [ frame_cnt ] { }  ) always clobbers reg byte a 
+Statement [41] *((const void()**) HARDWARE_IRQ) ← &interrupt(HARDWARE_CLOBBER)(void()) irq() [ ] ( main:3::init_irq:12 [ frame_cnt ] { }  ) always clobbers reg byte a 
+Statement [50] if((word) memset::num#2<=(byte) 0) goto memset::@return [ memset::num#2 memset::str#3 memset::c#4 ] ( main:3::bitmap_clear:8::memset:45 [ frame_cnt memset::num#2 memset::str#3 memset::c#4 ] { }  main:3::bitmap_clear:8::memset:47 [ frame_cnt memset::num#2 memset::str#3 memset::c#4 ] { }  ) always clobbers reg byte a 
 Removing always clobbered register reg byte a as potential for zp[1]:12 [ memset::c#4 ]
-Statement [51] (byte*) memset::end#0 ← (byte*)(void*) memset::str#3 + (word) memset::num#2 [ memset::str#3 memset::c#4 memset::end#0 ] ( main:3::bitmap_clear:8::memset:45 [ frame_cnt memset::str#3 memset::c#4 memset::end#0 ] main:3::bitmap_clear:8::memset:47 [ frame_cnt memset::str#3 memset::c#4 memset::end#0 ] ) always clobbers reg byte a 
-Statement [52] (byte*) memset::dst#4 ← (byte*)(void*) memset::str#3 [ memset::c#4 memset::end#0 memset::dst#4 ] ( main:3::bitmap_clear:8::memset:45 [ frame_cnt memset::c#4 memset::end#0 memset::dst#4 ] main:3::bitmap_clear:8::memset:47 [ frame_cnt memset::c#4 memset::end#0 memset::dst#4 ] ) always clobbers reg byte a 
-Statement [54] if((byte*) memset::dst#2!=(byte*) memset::end#0) goto memset::@3 [ memset::c#4 memset::end#0 memset::dst#2 ] ( main:3::bitmap_clear:8::memset:45 [ frame_cnt memset::c#4 memset::end#0 memset::dst#2 ] main:3::bitmap_clear:8::memset:47 [ frame_cnt memset::c#4 memset::end#0 memset::dst#2 ] ) always clobbers reg byte a 
-Statement [56] *((byte*) memset::dst#2) ← (byte) memset::c#4 [ memset::c#4 memset::end#0 memset::dst#2 ] ( main:3::bitmap_clear:8::memset:45 [ frame_cnt memset::c#4 memset::end#0 memset::dst#2 ] main:3::bitmap_clear:8::memset:47 [ frame_cnt memset::c#4 memset::end#0 memset::dst#2 ] ) always clobbers reg byte a reg byte y 
+Statement [51] (byte*) memset::end#0 ← (byte*)(void*) memset::str#3 + (word) memset::num#2 [ memset::str#3 memset::c#4 memset::end#0 ] ( main:3::bitmap_clear:8::memset:45 [ frame_cnt memset::str#3 memset::c#4 memset::end#0 ] { }  main:3::bitmap_clear:8::memset:47 [ frame_cnt memset::str#3 memset::c#4 memset::end#0 ] { }  ) always clobbers reg byte a 
+Statement [52] (byte*) memset::dst#4 ← (byte*)(void*) memset::str#3 [ memset::c#4 memset::end#0 memset::dst#4 ] ( main:3::bitmap_clear:8::memset:45 [ frame_cnt memset::c#4 memset::end#0 memset::dst#4 ] { }  main:3::bitmap_clear:8::memset:47 [ frame_cnt memset::c#4 memset::end#0 memset::dst#4 ] { }  ) always clobbers reg byte a 
+Statement [54] if((byte*) memset::dst#2!=(byte*) memset::end#0) goto memset::@3 [ memset::c#4 memset::end#0 memset::dst#2 ] ( main:3::bitmap_clear:8::memset:45 [ frame_cnt memset::c#4 memset::end#0 memset::dst#2 ] { }  main:3::bitmap_clear:8::memset:47 [ frame_cnt memset::c#4 memset::end#0 memset::dst#2 ] { }  ) always clobbers reg byte a 
+Statement [56] *((byte*) memset::dst#2) ← (byte) memset::c#4 [ memset::c#4 memset::end#0 memset::dst#2 ] ( main:3::bitmap_clear:8::memset:45 [ frame_cnt memset::c#4 memset::end#0 memset::dst#2 ] { }  main:3::bitmap_clear:8::memset:47 [ frame_cnt memset::c#4 memset::end#0 memset::dst#2 ] { }  ) always clobbers reg byte a reg byte y 
 Removing always clobbered register reg byte y as potential for zp[1]:12 [ memset::c#4 ]
-Statement [75] (byte*) bitmap_init::yoffs#1 ← (byte*) bitmap_init::yoffs#2 + (word)(number) $28*(number) 8 [ bitmap_init::y#2 bitmap_init::yoffs#1 ] ( main:3::bitmap_init:6 [ frame_cnt bitmap_init::y#2 bitmap_init::yoffs#1 ] ) always clobbers reg byte a 
+Statement [75] (byte*) bitmap_init::yoffs#1 ← (byte*) bitmap_init::yoffs#2 + (word)(number) $28*(number) 8 [ bitmap_init::y#2 bitmap_init::yoffs#1 ] ( main:3::bitmap_init:6 [ frame_cnt bitmap_init::y#2 bitmap_init::yoffs#1 ] { }  ) always clobbers reg byte a 
 Removing always clobbered register reg byte a as potential for zp[1]:17 [ bitmap_init::y#2 bitmap_init::y#1 ]
-Statement [80] *((const byte*) BGCOL) ← (const byte) WHITE [ frame_cnt ] (  [ frame_cnt ] ) always clobbers reg byte a 
-Statement [81] if((byte) 0==(byte) frame_cnt) goto irq::@1 [ frame_cnt ] (  [ frame_cnt ] ) always clobbers reg byte a 
-Statement [83] *((const byte*) BGCOL) ← (const byte) BLACK [ ] (  [ ] ) always clobbers reg byte a 
-Statement [84] *((const byte*) IRQ_STATUS) ← (const byte) IRQ_RASTER [ ] (  [ ] ) always clobbers reg byte a 
-Statement [85] return  [ ] (  [ ] ) always clobbers reg byte a reg byte x reg byte y 
-Statement [1] (byte) frame_cnt ← (byte) 1 [ frame_cnt ] (  [ frame_cnt ] ) always clobbers reg byte a 
-Statement [9] *((const byte*) D011) ← (const byte) VIC_BMM|(const byte) VIC_DEN|(const byte) VIC_RSEL|(byte) 3 [ frame_cnt ] ( main:3 [ frame_cnt ] ) always clobbers reg byte a 
-Statement [11] *((const byte*) D018) ← (const byte) main::toD0181_return#0 [ frame_cnt ] ( main:3 [ frame_cnt ] ) always clobbers reg byte a 
-Statement [14] (word) bitmap_plot::x#0 ← (word) main::x#2 [ frame_cnt main::x#2 main::y#2 main::vx#2 main::vy#2 bitmap_plot::x#0 ] ( main:3 [ frame_cnt main::x#2 main::y#2 main::vx#2 main::vy#2 bitmap_plot::x#0 ] ) always clobbers reg byte a 
-Statement [17] (word) main::x#1 ← (word) main::x#2 + (word) main::vx#2 [ frame_cnt main::y#2 main::vx#2 main::vy#2 main::x#1 ] ( main:3 [ frame_cnt main::y#2 main::vx#2 main::vy#2 main::x#1 ] ) always clobbers reg byte a 
-Statement [18] (byte) main::y#1 ← (byte) main::y#2 + (byte) main::vy#2 [ frame_cnt main::vx#2 main::vy#2 main::x#1 main::y#1 ] ( main:3 [ frame_cnt main::vx#2 main::vy#2 main::x#1 main::y#1 ] ) always clobbers reg byte a 
-Statement [19] if((word) main::x#1==(word) $13f) goto main::@5 [ frame_cnt main::vx#2 main::vy#2 main::x#1 main::y#1 ] ( main:3 [ frame_cnt main::vx#2 main::vy#2 main::x#1 main::y#1 ] ) always clobbers reg byte a 
-Statement [20] if((word) main::x#1!=(byte) 0) goto main::@3 [ frame_cnt main::vx#2 main::vy#2 main::x#1 main::y#1 ] ( main:3 [ frame_cnt main::vx#2 main::vy#2 main::x#1 main::y#1 ] ) always clobbers reg byte a 
-Statement [21] (word) main::vx#1 ← - (word) main::vx#2 [ frame_cnt main::vy#2 main::x#1 main::y#1 main::vx#1 ] ( main:3 [ frame_cnt main::vy#2 main::x#1 main::y#1 main::vx#1 ] ) always clobbers reg byte a 
-Statement [23] if((byte) main::y#1==(byte) $c7) goto main::@6 [ frame_cnt main::vy#2 main::x#1 main::y#1 main::vx#6 ] ( main:3 [ frame_cnt main::vy#2 main::x#1 main::y#1 main::vx#6 ] ) always clobbers reg byte a 
-Statement [24] if((byte) main::y#1!=(byte) 0) goto main::@4 [ frame_cnt main::vy#2 main::x#1 main::y#1 main::vx#6 ] ( main:3 [ frame_cnt main::vy#2 main::x#1 main::y#1 main::vx#6 ] ) always clobbers reg byte a 
-Statement [25] (byte) main::vy#1 ← - (byte) main::vy#2 [ frame_cnt main::x#1 main::y#1 main::vx#6 main::vy#1 ] ( main:3 [ frame_cnt main::x#1 main::y#1 main::vx#6 main::vy#1 ] ) always clobbers reg byte a 
-Statement [27] *((const byte*) plots_per_frame + (byte) frame_cnt) ← ++ *((const byte*) plots_per_frame + (byte) frame_cnt) [ frame_cnt main::x#1 main::y#1 main::vx#6 main::vy#8 ] ( main:3 [ frame_cnt main::x#1 main::y#1 main::vx#6 main::vy#8 ] ) always clobbers reg byte x 
-Statement [28] (word) bitmap_plot::plotter#0 ← *((const byte*) bitmap_plot_yhi + (byte) bitmap_plot::y#0) w= *((const byte*) bitmap_plot_ylo + (byte) bitmap_plot::y#0) [ bitmap_plot::x#0 bitmap_plot::plotter#0 ] ( main:3::bitmap_plot:16 [ frame_cnt main::x#2 main::y#2 main::vx#2 main::vy#2 bitmap_plot::x#0 bitmap_plot::plotter#0 ] ) always clobbers reg byte a 
-Statement [29] (word~) bitmap_plot::$1 ← (word) bitmap_plot::x#0 & (word) $fff8 [ bitmap_plot::x#0 bitmap_plot::plotter#0 bitmap_plot::$1 ] ( main:3::bitmap_plot:16 [ frame_cnt main::x#2 main::y#2 main::vx#2 main::vy#2 bitmap_plot::x#0 bitmap_plot::plotter#0 bitmap_plot::$1 ] ) always clobbers reg byte a 
-Statement [30] (byte*) bitmap_plot::plotter#1 ← (byte*)(word) bitmap_plot::plotter#0 + (word~) bitmap_plot::$1 [ bitmap_plot::x#0 bitmap_plot::plotter#1 ] ( main:3::bitmap_plot:16 [ frame_cnt main::x#2 main::y#2 main::vx#2 main::vy#2 bitmap_plot::x#0 bitmap_plot::plotter#1 ] ) always clobbers reg byte a 
-Statement [31] (byte~) bitmap_plot::$2 ← < (word) bitmap_plot::x#0 [ bitmap_plot::plotter#1 bitmap_plot::$2 ] ( main:3::bitmap_plot:16 [ frame_cnt main::x#2 main::y#2 main::vx#2 main::vy#2 bitmap_plot::plotter#1 bitmap_plot::$2 ] ) always clobbers reg byte a 
-Statement [32] *((byte*) bitmap_plot::plotter#1) ← *((byte*) bitmap_plot::plotter#1) | *((const byte*) bitmap_plot_bit + (byte~) bitmap_plot::$2) [ ] ( main:3::bitmap_plot:16 [ frame_cnt main::x#2 main::y#2 main::vx#2 main::vy#2 ] ) always clobbers reg byte a reg byte y 
-Statement [35] *((const byte*) PROCPORT_DDR) ← (const byte) PROCPORT_DDR_MEMORY_MASK [ ] ( main:3::init_irq:12 [ frame_cnt ] ) always clobbers reg byte a 
-Statement [36] *((const byte*) PROCPORT) ← (const byte) PROCPORT_RAM_IO [ ] ( main:3::init_irq:12 [ frame_cnt ] ) always clobbers reg byte a 
-Statement [37] *((const byte*) CIA1_INTERRUPT) ← (const byte) CIA_INTERRUPT_CLEAR [ ] ( main:3::init_irq:12 [ frame_cnt ] ) always clobbers reg byte a 
-Statement [38] *((const byte*) VIC_CONTROL) ← *((const byte*) VIC_CONTROL) | (byte) $80 [ ] ( main:3::init_irq:12 [ frame_cnt ] ) always clobbers reg byte a 
-Statement [39] *((const byte*) RASTER) ← (byte) 0 [ ] ( main:3::init_irq:12 [ frame_cnt ] ) always clobbers reg byte a 
-Statement [40] *((const byte*) IRQ_ENABLE) ← (const byte) IRQ_RASTER [ ] ( main:3::init_irq:12 [ frame_cnt ] ) always clobbers reg byte a 
-Statement [41] *((const void()**) HARDWARE_IRQ) ← &interrupt(HARDWARE_CLOBBER)(void()) irq() [ ] ( main:3::init_irq:12 [ frame_cnt ] ) always clobbers reg byte a 
-Statement [50] if((word) memset::num#2<=(byte) 0) goto memset::@return [ memset::num#2 memset::str#3 memset::c#4 ] ( main:3::bitmap_clear:8::memset:45 [ frame_cnt memset::num#2 memset::str#3 memset::c#4 ] main:3::bitmap_clear:8::memset:47 [ frame_cnt memset::num#2 memset::str#3 memset::c#4 ] ) always clobbers reg byte a 
-Statement [51] (byte*) memset::end#0 ← (byte*)(void*) memset::str#3 + (word) memset::num#2 [ memset::str#3 memset::c#4 memset::end#0 ] ( main:3::bitmap_clear:8::memset:45 [ frame_cnt memset::str#3 memset::c#4 memset::end#0 ] main:3::bitmap_clear:8::memset:47 [ frame_cnt memset::str#3 memset::c#4 memset::end#0 ] ) always clobbers reg byte a 
-Statement [52] (byte*) memset::dst#4 ← (byte*)(void*) memset::str#3 [ memset::c#4 memset::end#0 memset::dst#4 ] ( main:3::bitmap_clear:8::memset:45 [ frame_cnt memset::c#4 memset::end#0 memset::dst#4 ] main:3::bitmap_clear:8::memset:47 [ frame_cnt memset::c#4 memset::end#0 memset::dst#4 ] ) always clobbers reg byte a 
-Statement [54] if((byte*) memset::dst#2!=(byte*) memset::end#0) goto memset::@3 [ memset::c#4 memset::end#0 memset::dst#2 ] ( main:3::bitmap_clear:8::memset:45 [ frame_cnt memset::c#4 memset::end#0 memset::dst#2 ] main:3::bitmap_clear:8::memset:47 [ frame_cnt memset::c#4 memset::end#0 memset::dst#2 ] ) always clobbers reg byte a 
-Statement [56] *((byte*) memset::dst#2) ← (byte) memset::c#4 [ memset::c#4 memset::end#0 memset::dst#2 ] ( main:3::bitmap_clear:8::memset:45 [ frame_cnt memset::c#4 memset::end#0 memset::dst#2 ] main:3::bitmap_clear:8::memset:47 [ frame_cnt memset::c#4 memset::end#0 memset::dst#2 ] ) always clobbers reg byte a reg byte y 
-Statement [68] (byte~) bitmap_init::$7 ← (byte) bitmap_init::y#2 & (byte) 7 [ bitmap_init::y#2 bitmap_init::yoffs#2 bitmap_init::$7 ] ( main:3::bitmap_init:6 [ frame_cnt bitmap_init::y#2 bitmap_init::yoffs#2 bitmap_init::$7 ] ) always clobbers reg byte a 
-Statement [75] (byte*) bitmap_init::yoffs#1 ← (byte*) bitmap_init::yoffs#2 + (word)(number) $28*(number) 8 [ bitmap_init::y#2 bitmap_init::yoffs#1 ] ( main:3::bitmap_init:6 [ frame_cnt bitmap_init::y#2 bitmap_init::yoffs#1 ] ) always clobbers reg byte a 
-Statement [80] *((const byte*) BGCOL) ← (const byte) WHITE [ frame_cnt ] (  [ frame_cnt ] ) always clobbers reg byte a 
-Statement [81] if((byte) 0==(byte) frame_cnt) goto irq::@1 [ frame_cnt ] (  [ frame_cnt ] ) always clobbers reg byte a 
-Statement [83] *((const byte*) BGCOL) ← (const byte) BLACK [ ] (  [ ] ) always clobbers reg byte a 
-Statement [84] *((const byte*) IRQ_STATUS) ← (const byte) IRQ_RASTER [ ] (  [ ] ) always clobbers reg byte a 
-Statement [85] return  [ ] (  [ ] ) always clobbers reg byte a reg byte x reg byte y 
+Statement [80] *((const byte*) BGCOL) ← (const byte) WHITE [ frame_cnt ] (  [ frame_cnt ] { }  ) always clobbers reg byte a 
+Statement [81] if((byte) 0==(byte) frame_cnt) goto irq::@1 [ frame_cnt ] (  [ frame_cnt ] { }  ) always clobbers reg byte a 
+Statement [83] *((const byte*) BGCOL) ← (const byte) BLACK [ ] (  [ ] { }  ) always clobbers reg byte a 
+Statement [84] *((const byte*) IRQ_STATUS) ← (const byte) IRQ_RASTER [ ] (  [ ] { }  ) always clobbers reg byte a 
+Statement [85] return  [ ] (  [ ] { }  ) always clobbers reg byte a reg byte x reg byte y 
+Statement [1] (byte) frame_cnt ← (byte) 1 [ frame_cnt ] (  [ frame_cnt ] { }  ) always clobbers reg byte a 
+Statement [9] *((const byte*) D011) ← (const byte) VIC_BMM|(const byte) VIC_DEN|(const byte) VIC_RSEL|(byte) 3 [ frame_cnt ] ( main:3 [ frame_cnt ] { }  ) always clobbers reg byte a 
+Statement [11] *((const byte*) D018) ← (const byte) main::toD0181_return#0 [ frame_cnt ] ( main:3 [ frame_cnt ] { }  ) always clobbers reg byte a 
+Statement [14] (word) bitmap_plot::x#0 ← (word) main::x#2 [ frame_cnt main::x#2 main::y#2 main::vx#2 main::vy#2 bitmap_plot::x#0 ] ( main:3 [ frame_cnt main::x#2 main::y#2 main::vx#2 main::vy#2 bitmap_plot::x#0 ] { { bitmap_plot::x#0 = main::x#2 } { bitmap_plot::y#0 = main::y#2 } }  ) always clobbers reg byte a 
+Statement [17] (word) main::x#1 ← (word) main::x#2 + (word) main::vx#2 [ frame_cnt main::y#2 main::vx#2 main::vy#2 main::x#1 ] ( main:3 [ frame_cnt main::y#2 main::vx#2 main::vy#2 main::x#1 ] { }  ) always clobbers reg byte a 
+Statement [18] (byte) main::y#1 ← (byte) main::y#2 + (byte) main::vy#2 [ frame_cnt main::vx#2 main::vy#2 main::x#1 main::y#1 ] ( main:3 [ frame_cnt main::vx#2 main::vy#2 main::x#1 main::y#1 ] { }  ) always clobbers reg byte a 
+Statement [19] if((word) main::x#1==(word) $13f) goto main::@5 [ frame_cnt main::vx#2 main::vy#2 main::x#1 main::y#1 ] ( main:3 [ frame_cnt main::vx#2 main::vy#2 main::x#1 main::y#1 ] { }  ) always clobbers reg byte a 
+Statement [20] if((word) main::x#1!=(byte) 0) goto main::@3 [ frame_cnt main::vx#2 main::vy#2 main::x#1 main::y#1 ] ( main:3 [ frame_cnt main::vx#2 main::vy#2 main::x#1 main::y#1 ] { }  ) always clobbers reg byte a 
+Statement [21] (word) main::vx#1 ← - (word) main::vx#2 [ frame_cnt main::vy#2 main::x#1 main::y#1 main::vx#1 ] ( main:3 [ frame_cnt main::vy#2 main::x#1 main::y#1 main::vx#1 ] { }  ) always clobbers reg byte a 
+Statement [23] if((byte) main::y#1==(byte) $c7) goto main::@6 [ frame_cnt main::vy#2 main::x#1 main::y#1 main::vx#6 ] ( main:3 [ frame_cnt main::vy#2 main::x#1 main::y#1 main::vx#6 ] { }  ) always clobbers reg byte a 
+Statement [24] if((byte) main::y#1!=(byte) 0) goto main::@4 [ frame_cnt main::vy#2 main::x#1 main::y#1 main::vx#6 ] ( main:3 [ frame_cnt main::vy#2 main::x#1 main::y#1 main::vx#6 ] { }  ) always clobbers reg byte a 
+Statement [25] (byte) main::vy#1 ← - (byte) main::vy#2 [ frame_cnt main::x#1 main::y#1 main::vx#6 main::vy#1 ] ( main:3 [ frame_cnt main::x#1 main::y#1 main::vx#6 main::vy#1 ] { }  ) always clobbers reg byte a 
+Statement [27] *((const byte*) plots_per_frame + (byte) frame_cnt) ← ++ *((const byte*) plots_per_frame + (byte) frame_cnt) [ frame_cnt main::x#1 main::y#1 main::vx#6 main::vy#8 ] ( main:3 [ frame_cnt main::x#1 main::y#1 main::vx#6 main::vy#8 ] { }  ) always clobbers reg byte x 
+Statement [28] (word) bitmap_plot::plotter#0 ← *((const byte*) bitmap_plot_yhi + (byte) bitmap_plot::y#0) w= *((const byte*) bitmap_plot_ylo + (byte) bitmap_plot::y#0) [ bitmap_plot::x#0 bitmap_plot::plotter#0 ] ( main:3::bitmap_plot:16 [ frame_cnt main::x#2 main::y#2 main::vx#2 main::vy#2 bitmap_plot::x#0 bitmap_plot::plotter#0 ] { { bitmap_plot::x#0 = main::x#2 } { bitmap_plot::y#0 = main::y#2 } }  ) always clobbers reg byte a 
+Statement [29] (word~) bitmap_plot::$1 ← (word) bitmap_plot::x#0 & (word) $fff8 [ bitmap_plot::x#0 bitmap_plot::plotter#0 bitmap_plot::$1 ] ( main:3::bitmap_plot:16 [ frame_cnt main::x#2 main::y#2 main::vx#2 main::vy#2 bitmap_plot::x#0 bitmap_plot::plotter#0 bitmap_plot::$1 ] { { bitmap_plot::x#0 = main::x#2 } { bitmap_plot::y#0 = main::y#2 } }  ) always clobbers reg byte a 
+Statement [30] (byte*) bitmap_plot::plotter#1 ← (byte*)(word) bitmap_plot::plotter#0 + (word~) bitmap_plot::$1 [ bitmap_plot::x#0 bitmap_plot::plotter#1 ] ( main:3::bitmap_plot:16 [ frame_cnt main::x#2 main::y#2 main::vx#2 main::vy#2 bitmap_plot::x#0 bitmap_plot::plotter#1 ] { { bitmap_plot::x#0 = main::x#2 } { bitmap_plot::y#0 = main::y#2 } }  ) always clobbers reg byte a 
+Statement [32] *((byte*) bitmap_plot::plotter#1) ← *((byte*) bitmap_plot::plotter#1) | *((const byte*) bitmap_plot_bit + (byte~) bitmap_plot::$2) [ ] ( main:3::bitmap_plot:16 [ frame_cnt main::x#2 main::y#2 main::vx#2 main::vy#2 ] { { bitmap_plot::x#0 = main::x#2 } { bitmap_plot::y#0 = main::y#2 } }  ) always clobbers reg byte a reg byte y 
+Statement [35] *((const byte*) PROCPORT_DDR) ← (const byte) PROCPORT_DDR_MEMORY_MASK [ ] ( main:3::init_irq:12 [ frame_cnt ] { }  ) always clobbers reg byte a 
+Statement [36] *((const byte*) PROCPORT) ← (const byte) PROCPORT_RAM_IO [ ] ( main:3::init_irq:12 [ frame_cnt ] { }  ) always clobbers reg byte a 
+Statement [37] *((const byte*) CIA1_INTERRUPT) ← (const byte) CIA_INTERRUPT_CLEAR [ ] ( main:3::init_irq:12 [ frame_cnt ] { }  ) always clobbers reg byte a 
+Statement [38] *((const byte*) VIC_CONTROL) ← *((const byte*) VIC_CONTROL) | (byte) $80 [ ] ( main:3::init_irq:12 [ frame_cnt ] { }  ) always clobbers reg byte a 
+Statement [39] *((const byte*) RASTER) ← (byte) 0 [ ] ( main:3::init_irq:12 [ frame_cnt ] { }  ) always clobbers reg byte a 
+Statement [40] *((const byte*) IRQ_ENABLE) ← (const byte) IRQ_RASTER [ ] ( main:3::init_irq:12 [ frame_cnt ] { }  ) always clobbers reg byte a 
+Statement [41] *((const void()**) HARDWARE_IRQ) ← &interrupt(HARDWARE_CLOBBER)(void()) irq() [ ] ( main:3::init_irq:12 [ frame_cnt ] { }  ) always clobbers reg byte a 
+Statement [50] if((word) memset::num#2<=(byte) 0) goto memset::@return [ memset::num#2 memset::str#3 memset::c#4 ] ( main:3::bitmap_clear:8::memset:45 [ frame_cnt memset::num#2 memset::str#3 memset::c#4 ] { }  main:3::bitmap_clear:8::memset:47 [ frame_cnt memset::num#2 memset::str#3 memset::c#4 ] { }  ) always clobbers reg byte a 
+Statement [51] (byte*) memset::end#0 ← (byte*)(void*) memset::str#3 + (word) memset::num#2 [ memset::str#3 memset::c#4 memset::end#0 ] ( main:3::bitmap_clear:8::memset:45 [ frame_cnt memset::str#3 memset::c#4 memset::end#0 ] { }  main:3::bitmap_clear:8::memset:47 [ frame_cnt memset::str#3 memset::c#4 memset::end#0 ] { }  ) always clobbers reg byte a 
+Statement [52] (byte*) memset::dst#4 ← (byte*)(void*) memset::str#3 [ memset::c#4 memset::end#0 memset::dst#4 ] ( main:3::bitmap_clear:8::memset:45 [ frame_cnt memset::c#4 memset::end#0 memset::dst#4 ] { }  main:3::bitmap_clear:8::memset:47 [ frame_cnt memset::c#4 memset::end#0 memset::dst#4 ] { }  ) always clobbers reg byte a 
+Statement [54] if((byte*) memset::dst#2!=(byte*) memset::end#0) goto memset::@3 [ memset::c#4 memset::end#0 memset::dst#2 ] ( main:3::bitmap_clear:8::memset:45 [ frame_cnt memset::c#4 memset::end#0 memset::dst#2 ] { }  main:3::bitmap_clear:8::memset:47 [ frame_cnt memset::c#4 memset::end#0 memset::dst#2 ] { }  ) always clobbers reg byte a 
+Statement [56] *((byte*) memset::dst#2) ← (byte) memset::c#4 [ memset::c#4 memset::end#0 memset::dst#2 ] ( main:3::bitmap_clear:8::memset:45 [ frame_cnt memset::c#4 memset::end#0 memset::dst#2 ] { }  main:3::bitmap_clear:8::memset:47 [ frame_cnt memset::c#4 memset::end#0 memset::dst#2 ] { }  ) always clobbers reg byte a reg byte y 
+Statement [68] (byte~) bitmap_init::$7 ← (byte) bitmap_init::y#2 & (byte) 7 [ bitmap_init::y#2 bitmap_init::yoffs#2 bitmap_init::$7 ] ( main:3::bitmap_init:6 [ frame_cnt bitmap_init::y#2 bitmap_init::yoffs#2 bitmap_init::$7 ] { }  ) always clobbers reg byte a 
+Statement [75] (byte*) bitmap_init::yoffs#1 ← (byte*) bitmap_init::yoffs#2 + (word)(number) $28*(number) 8 [ bitmap_init::y#2 bitmap_init::yoffs#1 ] ( main:3::bitmap_init:6 [ frame_cnt bitmap_init::y#2 bitmap_init::yoffs#1 ] { }  ) always clobbers reg byte a 
+Statement [80] *((const byte*) BGCOL) ← (const byte) WHITE [ frame_cnt ] (  [ frame_cnt ] { }  ) always clobbers reg byte a 
+Statement [81] if((byte) 0==(byte) frame_cnt) goto irq::@1 [ frame_cnt ] (  [ frame_cnt ] { }  ) always clobbers reg byte a 
+Statement [83] *((const byte*) BGCOL) ← (const byte) BLACK [ ] (  [ ] { }  ) always clobbers reg byte a 
+Statement [84] *((const byte*) IRQ_STATUS) ← (const byte) IRQ_RASTER [ ] (  [ ] { }  ) always clobbers reg byte a 
+Statement [85] return  [ ] (  [ ] { }  ) always clobbers reg byte a reg byte x reg byte y 
 Potential registers zp[2]:2 [ main::x#2 main::x#1 ] : zp[2]:2 , 
 Potential registers zp[1]:4 [ main::y#2 main::y#1 ] : zp[1]:4 , 
 Potential registers zp[2]:5 [ main::vx#2 main::vx#6 main::vx#1 ] : zp[2]:5 , 
@@ -2275,36 +2273,36 @@ Potential registers zp[1]:35 [ bitmap_init::$5 ] : zp[1]:35 , reg byte a , reg b
 Potential registers zp[1]:36 [ bitmap_init::$6 ] : zp[1]:36 , reg byte a , reg byte x , reg byte y , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [bitmap_init] 39.88: zp[2]:18 [ bitmap_init::yoffs#2 bitmap_init::yoffs#4 bitmap_init::yoffs#1 ] 34.83: zp[1]:15 [ bitmap_init::bits#3 bitmap_init::bits#4 bitmap_init::bits#1 ] 22: zp[1]:16 [ bitmap_init::x#2 bitmap_init::x#1 ] 22: zp[1]:17 [ bitmap_init::y#2 bitmap_init::y#1 ] 22: zp[1]:34 [ bitmap_init::$4 ] 22: zp[1]:35 [ bitmap_init::$5 ] 22: zp[1]:36 [ bitmap_init::$6 ] 5.5: zp[1]:33 [ bitmap_init::$7 ] 
-Uplift Scope [main] 42.17: zp[1]:7 [ main::vy#2 main::vy#8 main::vy#1 ] 33: zp[2]:5 [ main::vx#2 main::vx#6 main::vx#1 ] 12.25: zp[2]:2 [ main::x#2 main::x#1 ] 11: zp[1]:4 [ main::y#2 main::y#1 ] 
-Uplift Scope [memset] 41.33: zp[2]:13 [ memset::dst#2 memset::dst#4 memset::dst#1 ] 2.17: zp[2]:31 [ memset::end#0 ] 2: zp[2]:8 [ memset::num#2 ] 1.38: zp[1]:12 [ memset::c#4 ] 0: zp[2]:10 [ memset::str#3 ] 
-Uplift Scope [bitmap_plot] 15: zp[1]:23 [ bitmap_plot::y#0 ] 4: zp[2]:26 [ bitmap_plot::$1 ] 4: zp[1]:30 [ bitmap_plot::$2 ] 3: zp[2]:21 [ bitmap_plot::x#0 ] 3: zp[2]:28 [ bitmap_plot::plotter#1 ] 1: zp[2]:24 [ bitmap_plot::plotter#0 ] 
-Uplift Scope [] 1.11: zp[1]:20 [ frame_cnt ] 
+Uplift Scope [memset] 35,672.33: zp[2]:13 [ memset::dst#2 memset::dst#4 memset::dst#1 ] 1,833.67: zp[2]:31 [ memset::end#0 ] 1,250.12: zp[1]:12 [ memset::c#4 ] 1,001: zp[2]:8 [ memset::num#2 ] 0: zp[2]:10 [ memset::str#3 ] 
+Uplift Scope [bitmap_init] 3,628.62: zp[2]:18 [ bitmap_init::yoffs#2 bitmap_init::yoffs#4 bitmap_init::yoffs#1 ] 3,169.83: zp[1]:15 [ bitmap_init::bits#3 bitmap_init::bits#4 bitmap_init::bits#1 ] 2,002: zp[1]:16 [ bitmap_init::x#2 bitmap_init::x#1 ] 2,002: zp[1]:17 [ bitmap_init::y#2 bitmap_init::y#1 ] 2,002: zp[1]:34 [ bitmap_init::$4 ] 2,002: zp[1]:35 [ bitmap_init::$5 ] 2,002: zp[1]:36 [ bitmap_init::$6 ] 500.5: zp[1]:33 [ bitmap_init::$7 ] 
+Uplift Scope [bitmap_plot] 2,103: zp[1]:23 [ bitmap_plot::y#0 ] 2,002: zp[2]:26 [ bitmap_plot::$1 ] 2,002: zp[1]:30 [ bitmap_plot::$2 ] 1,501.5: zp[2]:28 [ bitmap_plot::plotter#1 ] 500.5: zp[2]:24 [ bitmap_plot::plotter#0 ] 420.6: zp[2]:21 [ bitmap_plot::x#0 ] 
+Uplift Scope [main] 387.17: zp[1]:7 [ main::vy#2 main::vy#8 main::vy#1 ] 303: zp[2]:5 [ main::vx#2 main::vx#6 main::vx#1 ] 112.48: zp[2]:2 [ main::x#2 main::x#1 ] 101: zp[1]:4 [ main::y#2 main::y#1 ] 
+Uplift Scope [] 7.78: zp[1]:20 [ frame_cnt ] 
 Uplift Scope [bitmap_clear] 
 Uplift Scope [init_irq] 
 Uplift Scope [irq] 
 
-Uplifting [bitmap_init] best 4371 combination zp[2]:18 [ bitmap_init::yoffs#2 bitmap_init::yoffs#4 bitmap_init::yoffs#1 ] reg byte a [ bitmap_init::bits#3 bitmap_init::bits#4 bitmap_init::bits#1 ] reg byte x [ bitmap_init::x#2 bitmap_init::x#1 ] reg byte x [ bitmap_init::y#2 bitmap_init::y#1 ] reg byte a [ bitmap_init::$4 ] zp[1]:35 [ bitmap_init::$5 ] zp[1]:36 [ bitmap_init::$6 ] zp[1]:33 [ bitmap_init::$7 ] 
+Uplifting [memset] best 4865 combination zp[2]:13 [ memset::dst#2 memset::dst#4 memset::dst#1 ] zp[2]:31 [ memset::end#0 ] reg byte x [ memset::c#4 ] zp[2]:8 [ memset::num#2 ] zp[2]:10 [ memset::str#3 ] 
+Uplifting [bitmap_init] best 4355 combination zp[2]:18 [ bitmap_init::yoffs#2 bitmap_init::yoffs#4 bitmap_init::yoffs#1 ] reg byte a [ bitmap_init::bits#3 bitmap_init::bits#4 bitmap_init::bits#1 ] reg byte x [ bitmap_init::x#2 bitmap_init::x#1 ] reg byte x [ bitmap_init::y#2 bitmap_init::y#1 ] reg byte a [ bitmap_init::$4 ] zp[1]:35 [ bitmap_init::$5 ] zp[1]:36 [ bitmap_init::$6 ] zp[1]:33 [ bitmap_init::$7 ] 
 Limited combination testing to 100 combinations of 15360 possible.
-Uplifting [main] best 4371 combination zp[1]:7 [ main::vy#2 main::vy#8 main::vy#1 ] zp[2]:5 [ main::vx#2 main::vx#6 main::vx#1 ] zp[2]:2 [ main::x#2 main::x#1 ] zp[1]:4 [ main::y#2 main::y#1 ] 
-Uplifting [memset] best 4355 combination zp[2]:13 [ memset::dst#2 memset::dst#4 memset::dst#1 ] zp[2]:31 [ memset::end#0 ] zp[2]:8 [ memset::num#2 ] reg byte x [ memset::c#4 ] zp[2]:10 [ memset::str#3 ] 
-Uplifting [bitmap_plot] best 4318 combination reg byte x [ bitmap_plot::y#0 ] zp[2]:26 [ bitmap_plot::$1 ] reg byte a [ bitmap_plot::$2 ] zp[2]:21 [ bitmap_plot::x#0 ] zp[2]:28 [ bitmap_plot::plotter#1 ] zp[2]:24 [ bitmap_plot::plotter#0 ] 
-Uplifting [] best 4318 combination zp[1]:20 [ frame_cnt ] 
-Uplifting [bitmap_clear] best 4318 combination 
-Uplifting [init_irq] best 4318 combination 
-Uplifting [irq] best 4318 combination 
-Attempting to uplift remaining variables inzp[1]:7 [ main::vy#2 main::vy#8 main::vy#1 ]
-Uplifting [main] best 4318 combination zp[1]:7 [ main::vy#2 main::vy#8 main::vy#1 ] 
+Uplifting [bitmap_plot] best 4316 combination reg byte x [ bitmap_plot::y#0 ] zp[2]:26 [ bitmap_plot::$1 ] reg byte x [ bitmap_plot::$2 ] zp[2]:28 [ bitmap_plot::plotter#1 ] zp[2]:24 [ bitmap_plot::plotter#0 ] zp[2]:21 [ bitmap_plot::x#0 ] 
+Uplifting [main] best 4316 combination zp[1]:7 [ main::vy#2 main::vy#8 main::vy#1 ] zp[2]:5 [ main::vx#2 main::vx#6 main::vx#1 ] zp[2]:2 [ main::x#2 main::x#1 ] zp[1]:4 [ main::y#2 main::y#1 ] 
+Uplifting [] best 4316 combination zp[1]:20 [ frame_cnt ] 
+Uplifting [bitmap_clear] best 4316 combination 
+Uplifting [init_irq] best 4316 combination 
+Uplifting [irq] best 4316 combination 
 Attempting to uplift remaining variables inzp[1]:35 [ bitmap_init::$5 ]
-Uplifting [bitmap_init] best 4258 combination reg byte a [ bitmap_init::$5 ] 
+Uplifting [bitmap_init] best 4256 combination reg byte a [ bitmap_init::$5 ] 
 Attempting to uplift remaining variables inzp[1]:36 [ bitmap_init::$6 ]
-Uplifting [bitmap_init] best 4198 combination reg byte a [ bitmap_init::$6 ] 
-Attempting to uplift remaining variables inzp[1]:4 [ main::y#2 main::y#1 ]
-Uplifting [main] best 4198 combination zp[1]:4 [ main::y#2 main::y#1 ] 
+Uplifting [bitmap_init] best 4196 combination reg byte a [ bitmap_init::$6 ] 
 Attempting to uplift remaining variables inzp[1]:33 [ bitmap_init::$7 ]
-Uplifting [bitmap_init] best 4198 combination zp[1]:33 [ bitmap_init::$7 ] 
+Uplifting [bitmap_init] best 4196 combination zp[1]:33 [ bitmap_init::$7 ] 
+Attempting to uplift remaining variables inzp[1]:7 [ main::vy#2 main::vy#8 main::vy#1 ]
+Uplifting [main] best 4196 combination zp[1]:7 [ main::vy#2 main::vy#8 main::vy#1 ] 
+Attempting to uplift remaining variables inzp[1]:4 [ main::y#2 main::y#1 ]
+Uplifting [main] best 4196 combination zp[1]:4 [ main::y#2 main::y#1 ] 
 Attempting to uplift remaining variables inzp[1]:20 [ frame_cnt ]
-Uplifting [] best 4198 combination zp[1]:20 [ frame_cnt ] 
+Uplifting [] best 4196 combination zp[1]:20 [ frame_cnt ] 
 Coalescing zero page register [ zp[2]:2 [ main::x#2 main::x#1 ] ] with [ zp[2]:21 [ bitmap_plot::x#0 ] ] - score: 1
 Coalescing zero page register [ zp[2]:8 [ memset::num#2 ] ] with [ zp[2]:31 [ memset::end#0 ] ] - score: 1
 Coalescing zero page register [ zp[2]:10 [ memset::str#3 ] ] with [ zp[2]:13 [ memset::dst#2 memset::dst#4 memset::dst#1 ] ] - score: 1
@@ -2573,11 +2571,10 @@ bitmap_plot: {
     lda.z plotter+1
     adc.z __1+1
     sta.z plotter+1
-    // [31] (byte~) bitmap_plot::$2 ← < (word) bitmap_plot::x#0 -- vbuaa=_lo_vwuz1 
-    lda.z x
-    // [32] *((byte*) bitmap_plot::plotter#1) ← *((byte*) bitmap_plot::plotter#1) | *((const byte*) bitmap_plot_bit + (byte~) bitmap_plot::$2) -- _deref_pbuz1=_deref_pbuz1_bor_pbuc1_derefidx_vbuaa 
-    tay
-    lda bitmap_plot_bit,y
+    // [31] (byte~) bitmap_plot::$2 ← < (word) bitmap_plot::x#0 -- vbuxx=_lo_vwuz1 
+    ldx.z x
+    // [32] *((byte*) bitmap_plot::plotter#1) ← *((byte*) bitmap_plot::plotter#1) | *((const byte*) bitmap_plot_bit + (byte~) bitmap_plot::$2) -- _deref_pbuz1=_deref_pbuz1_bor_pbuc1_derefidx_vbuxx 
+    lda bitmap_plot_bit,x
     ldy #0
     ora (plotter),y
     ldy #0
@@ -3032,10 +3029,10 @@ FINAL SYMBOL TABLE
 (byte) bitmap_clear::fgcol
 (byte*) bitmap_gfx
 (void()) bitmap_init((byte*) bitmap_init::gfx , (byte*) bitmap_init::screen)
-(byte~) bitmap_init::$4 reg byte a 22.0
-(byte~) bitmap_init::$5 reg byte a 22.0
-(byte~) bitmap_init::$6 reg byte a 22.0
-(byte~) bitmap_init::$7 zp[1]:13 5.5
+(byte~) bitmap_init::$4 reg byte a 2002.0
+(byte~) bitmap_init::$5 reg byte a 2002.0
+(byte~) bitmap_init::$6 reg byte a 2002.0
+(byte~) bitmap_init::$7 zp[1]:13 500.5
 (label) bitmap_init::@1
 (label) bitmap_init::@2
 (label) bitmap_init::@3
@@ -3044,37 +3041,37 @@ FINAL SYMBOL TABLE
 (label) bitmap_init::@6
 (label) bitmap_init::@return
 (byte) bitmap_init::bits
-(byte) bitmap_init::bits#1 reg byte a 11.0
-(byte) bitmap_init::bits#3 reg byte a 16.5
-(byte) bitmap_init::bits#4 reg byte a 7.333333333333333
+(byte) bitmap_init::bits#1 reg byte a 1001.0
+(byte) bitmap_init::bits#3 reg byte a 1501.5
+(byte) bitmap_init::bits#4 reg byte a 667.3333333333334
 (byte*) bitmap_init::gfx
 (byte*) bitmap_init::screen
 (byte) bitmap_init::x
-(byte) bitmap_init::x#1 reg byte x 16.5
-(byte) bitmap_init::x#2 reg byte x 5.5
+(byte) bitmap_init::x#1 reg byte x 1501.5
+(byte) bitmap_init::x#2 reg byte x 500.5
 (byte) bitmap_init::y
-(byte) bitmap_init::y#1 reg byte x 16.5
-(byte) bitmap_init::y#2 reg byte x 5.5
+(byte) bitmap_init::y#1 reg byte x 1501.5
+(byte) bitmap_init::y#2 reg byte x 500.5
 (byte*) bitmap_init::yoffs
-(byte*) bitmap_init::yoffs#1 yoffs zp[2]:11 22.0
-(byte*) bitmap_init::yoffs#2 yoffs zp[2]:11 6.875
-(byte*) bitmap_init::yoffs#4 yoffs zp[2]:11 11.0
+(byte*) bitmap_init::yoffs#1 yoffs zp[2]:11 2002.0
+(byte*) bitmap_init::yoffs#2 yoffs zp[2]:11 625.625
+(byte*) bitmap_init::yoffs#4 yoffs zp[2]:11 1001.0
 (void()) bitmap_plot((word) bitmap_plot::x , (byte) bitmap_plot::y)
-(word~) bitmap_plot::$1 zp[2]:11 4.0
-(byte~) bitmap_plot::$2 reg byte a 4.0
+(word~) bitmap_plot::$1 zp[2]:11 2002.0
+(byte~) bitmap_plot::$2 reg byte x 2002.0
 (label) bitmap_plot::@return
 (byte*) bitmap_plot::plotter
-(word) bitmap_plot::plotter#0 plotter zp[2]:9 1.0
-(byte*) bitmap_plot::plotter#1 plotter zp[2]:9 3.0
+(word) bitmap_plot::plotter#0 plotter zp[2]:9 500.5
+(byte*) bitmap_plot::plotter#1 plotter zp[2]:9 1501.5
 (word) bitmap_plot::x
-(word) bitmap_plot::x#0 x zp[2]:2 3.0
+(word) bitmap_plot::x#0 x zp[2]:2 420.59999999999997
 (byte) bitmap_plot::y
-(byte) bitmap_plot::y#0 reg byte x 15.0
+(byte) bitmap_plot::y#0 reg byte x 2103.0
 (const byte*) bitmap_plot_bit[(number) $100]  = { fill( $100, 0) }
 (const byte*) bitmap_plot_yhi[(number) $100]  = { fill( $100, 0) }
 (const byte*) bitmap_plot_ylo[(number) $100]  = { fill( $100, 0) }
 (byte*) bitmap_screen
-(byte) frame_cnt loadstore zp[1]:8 1.1111111111111112
+(byte) frame_cnt loadstore zp[1]:8 7.777777777777779
 (void()) init_irq()
 (label) init_irq::@return
 interrupt(HARDWARE_CLOBBER)(void()) irq()
@@ -3100,34 +3097,34 @@ interrupt(HARDWARE_CLOBBER)(void()) irq()
 (const byte) main::toD0181_return#0 toD0181_return = >(word)(const byte*) SCREEN&(word) $3fff*(byte) 4|>(word)(const byte*) BITMAP/(byte) 4&(byte) $f
 (byte*) main::toD0181_screen
 (word) main::vx
-(word) main::vx#1 vx zp[2]:5 22.0
-(word) main::vx#2 vx zp[2]:5 5.5
-(word) main::vx#6 vx zp[2]:5 5.5
+(word) main::vx#1 vx zp[2]:5 202.0
+(word) main::vx#2 vx zp[2]:5 50.5
+(word) main::vx#6 vx zp[2]:5 50.5
 (byte) main::vy
-(byte) main::vy#1 vy zp[1]:7 22.0
-(byte) main::vy#2 vy zp[1]:7 3.6666666666666665
-(byte) main::vy#8 vy zp[1]:7 16.5
+(byte) main::vy#1 vy zp[1]:7 202.0
+(byte) main::vy#2 vy zp[1]:7 33.666666666666664
+(byte) main::vy#8 vy zp[1]:7 151.5
 (word) main::x
-(word) main::x#1 x zp[2]:2 4.0
-(word) main::x#2 x zp[2]:2 8.25
+(word) main::x#1 x zp[2]:2 36.72727272727273
+(word) main::x#2 x zp[2]:2 75.75
 (byte) main::y
-(byte) main::y#1 y zp[1]:4 4.4
-(byte) main::y#2 y zp[1]:4 6.6000000000000005
+(byte) main::y#1 y zp[1]:4 40.4
+(byte) main::y#2 y zp[1]:4 60.599999999999994
 (void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num)
 (label) memset::@1
 (label) memset::@2
 (label) memset::@3
 (label) memset::@return
 (byte) memset::c
-(byte) memset::c#4 reg byte x 1.375
+(byte) memset::c#4 reg byte x 1250.125
 (byte*) memset::dst
-(byte*) memset::dst#1 dst zp[2]:9 22.0
-(byte*) memset::dst#2 dst zp[2]:9 15.333333333333332
-(byte*) memset::dst#4 dst zp[2]:9 4.0
+(byte*) memset::dst#1 dst zp[2]:9 20002.0
+(byte*) memset::dst#2 dst zp[2]:9 13668.333333333332
+(byte*) memset::dst#4 dst zp[2]:9 2002.0
 (byte*) memset::end
-(byte*) memset::end#0 end zp[2]:11 2.1666666666666665
+(byte*) memset::end#0 end zp[2]:11 1833.6666666666665
 (word) memset::num
-(word) memset::num#2 num zp[2]:11 2.0
+(word) memset::num#2 num zp[2]:11 1001.0
 (void*) memset::return
 (void*) memset::str
 (void*) memset::str#3 str zp[2]:9
@@ -3145,7 +3142,7 @@ zp[1]:8 [ frame_cnt ]
 reg byte x [ bitmap_plot::y#0 ]
 zp[2]:9 [ bitmap_plot::plotter#0 bitmap_plot::plotter#1 memset::str#3 memset::dst#2 memset::dst#4 memset::dst#1 ]
 zp[2]:11 [ bitmap_plot::$1 bitmap_init::yoffs#2 bitmap_init::yoffs#4 bitmap_init::yoffs#1 memset::num#2 memset::end#0 ]
-reg byte a [ bitmap_plot::$2 ]
+reg byte x [ bitmap_plot::$2 ]
 zp[1]:13 [ bitmap_init::$7 ]
 reg byte a [ bitmap_init::$4 ]
 reg byte a [ bitmap_init::$5 ]
@@ -3153,7 +3150,7 @@ reg byte a [ bitmap_init::$6 ]
 
 
 FINAL ASSEMBLER
-Score: 3177
+Score: 3175
 
   // File Comments
 // Tests the simple bitmap plotter - and counts plots per frame in an IRQ
@@ -3378,12 +3375,11 @@ bitmap_plot: {
     adc.z __1+1
     sta.z plotter+1
     // <x
-    // [31] (byte~) bitmap_plot::$2 ← < (word) bitmap_plot::x#0 -- vbuaa=_lo_vwuz1 
-    lda.z x
+    // [31] (byte~) bitmap_plot::$2 ← < (word) bitmap_plot::x#0 -- vbuxx=_lo_vwuz1 
+    ldx.z x
     // *plotter |= bitmap_plot_bit[<x]
-    // [32] *((byte*) bitmap_plot::plotter#1) ← *((byte*) bitmap_plot::plotter#1) | *((const byte*) bitmap_plot_bit + (byte~) bitmap_plot::$2) -- _deref_pbuz1=_deref_pbuz1_bor_pbuc1_derefidx_vbuaa 
-    tay
-    lda bitmap_plot_bit,y
+    // [32] *((byte*) bitmap_plot::plotter#1) ← *((byte*) bitmap_plot::plotter#1) | *((const byte*) bitmap_plot_bit + (byte~) bitmap_plot::$2) -- _deref_pbuz1=_deref_pbuz1_bor_pbuc1_derefidx_vbuxx 
+    lda bitmap_plot_bit,x
     ldy #0
     ora (plotter),y
     sta (plotter),y

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

@@ -33,10 +33,10 @@
 (byte) bitmap_clear::fgcol
 (byte*) bitmap_gfx
 (void()) bitmap_init((byte*) bitmap_init::gfx , (byte*) bitmap_init::screen)
-(byte~) bitmap_init::$4 reg byte a 22.0
-(byte~) bitmap_init::$5 reg byte a 22.0
-(byte~) bitmap_init::$6 reg byte a 22.0
-(byte~) bitmap_init::$7 zp[1]:13 5.5
+(byte~) bitmap_init::$4 reg byte a 2002.0
+(byte~) bitmap_init::$5 reg byte a 2002.0
+(byte~) bitmap_init::$6 reg byte a 2002.0
+(byte~) bitmap_init::$7 zp[1]:13 500.5
 (label) bitmap_init::@1
 (label) bitmap_init::@2
 (label) bitmap_init::@3
@@ -45,37 +45,37 @@
 (label) bitmap_init::@6
 (label) bitmap_init::@return
 (byte) bitmap_init::bits
-(byte) bitmap_init::bits#1 reg byte a 11.0
-(byte) bitmap_init::bits#3 reg byte a 16.5
-(byte) bitmap_init::bits#4 reg byte a 7.333333333333333
+(byte) bitmap_init::bits#1 reg byte a 1001.0
+(byte) bitmap_init::bits#3 reg byte a 1501.5
+(byte) bitmap_init::bits#4 reg byte a 667.3333333333334
 (byte*) bitmap_init::gfx
 (byte*) bitmap_init::screen
 (byte) bitmap_init::x
-(byte) bitmap_init::x#1 reg byte x 16.5
-(byte) bitmap_init::x#2 reg byte x 5.5
+(byte) bitmap_init::x#1 reg byte x 1501.5
+(byte) bitmap_init::x#2 reg byte x 500.5
 (byte) bitmap_init::y
-(byte) bitmap_init::y#1 reg byte x 16.5
-(byte) bitmap_init::y#2 reg byte x 5.5
+(byte) bitmap_init::y#1 reg byte x 1501.5
+(byte) bitmap_init::y#2 reg byte x 500.5
 (byte*) bitmap_init::yoffs
-(byte*) bitmap_init::yoffs#1 yoffs zp[2]:11 22.0
-(byte*) bitmap_init::yoffs#2 yoffs zp[2]:11 6.875
-(byte*) bitmap_init::yoffs#4 yoffs zp[2]:11 11.0
+(byte*) bitmap_init::yoffs#1 yoffs zp[2]:11 2002.0
+(byte*) bitmap_init::yoffs#2 yoffs zp[2]:11 625.625
+(byte*) bitmap_init::yoffs#4 yoffs zp[2]:11 1001.0
 (void()) bitmap_plot((word) bitmap_plot::x , (byte) bitmap_plot::y)
-(word~) bitmap_plot::$1 zp[2]:11 4.0
-(byte~) bitmap_plot::$2 reg byte a 4.0
+(word~) bitmap_plot::$1 zp[2]:11 2002.0
+(byte~) bitmap_plot::$2 reg byte x 2002.0
 (label) bitmap_plot::@return
 (byte*) bitmap_plot::plotter
-(word) bitmap_plot::plotter#0 plotter zp[2]:9 1.0
-(byte*) bitmap_plot::plotter#1 plotter zp[2]:9 3.0
+(word) bitmap_plot::plotter#0 plotter zp[2]:9 500.5
+(byte*) bitmap_plot::plotter#1 plotter zp[2]:9 1501.5
 (word) bitmap_plot::x
-(word) bitmap_plot::x#0 x zp[2]:2 3.0
+(word) bitmap_plot::x#0 x zp[2]:2 420.59999999999997
 (byte) bitmap_plot::y
-(byte) bitmap_plot::y#0 reg byte x 15.0
+(byte) bitmap_plot::y#0 reg byte x 2103.0
 (const byte*) bitmap_plot_bit[(number) $100]  = { fill( $100, 0) }
 (const byte*) bitmap_plot_yhi[(number) $100]  = { fill( $100, 0) }
 (const byte*) bitmap_plot_ylo[(number) $100]  = { fill( $100, 0) }
 (byte*) bitmap_screen
-(byte) frame_cnt loadstore zp[1]:8 1.1111111111111112
+(byte) frame_cnt loadstore zp[1]:8 7.777777777777779
 (void()) init_irq()
 (label) init_irq::@return
 interrupt(HARDWARE_CLOBBER)(void()) irq()
@@ -101,34 +101,34 @@ interrupt(HARDWARE_CLOBBER)(void()) irq()
 (const byte) main::toD0181_return#0 toD0181_return = >(word)(const byte*) SCREEN&(word) $3fff*(byte) 4|>(word)(const byte*) BITMAP/(byte) 4&(byte) $f
 (byte*) main::toD0181_screen
 (word) main::vx
-(word) main::vx#1 vx zp[2]:5 22.0
-(word) main::vx#2 vx zp[2]:5 5.5
-(word) main::vx#6 vx zp[2]:5 5.5
+(word) main::vx#1 vx zp[2]:5 202.0
+(word) main::vx#2 vx zp[2]:5 50.5
+(word) main::vx#6 vx zp[2]:5 50.5
 (byte) main::vy
-(byte) main::vy#1 vy zp[1]:7 22.0
-(byte) main::vy#2 vy zp[1]:7 3.6666666666666665
-(byte) main::vy#8 vy zp[1]:7 16.5
+(byte) main::vy#1 vy zp[1]:7 202.0
+(byte) main::vy#2 vy zp[1]:7 33.666666666666664
+(byte) main::vy#8 vy zp[1]:7 151.5
 (word) main::x
-(word) main::x#1 x zp[2]:2 4.0
-(word) main::x#2 x zp[2]:2 8.25
+(word) main::x#1 x zp[2]:2 36.72727272727273
+(word) main::x#2 x zp[2]:2 75.75
 (byte) main::y
-(byte) main::y#1 y zp[1]:4 4.4
-(byte) main::y#2 y zp[1]:4 6.6000000000000005
+(byte) main::y#1 y zp[1]:4 40.4
+(byte) main::y#2 y zp[1]:4 60.599999999999994
 (void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num)
 (label) memset::@1
 (label) memset::@2
 (label) memset::@3
 (label) memset::@return
 (byte) memset::c
-(byte) memset::c#4 reg byte x 1.375
+(byte) memset::c#4 reg byte x 1250.125
 (byte*) memset::dst
-(byte*) memset::dst#1 dst zp[2]:9 22.0
-(byte*) memset::dst#2 dst zp[2]:9 15.333333333333332
-(byte*) memset::dst#4 dst zp[2]:9 4.0
+(byte*) memset::dst#1 dst zp[2]:9 20002.0
+(byte*) memset::dst#2 dst zp[2]:9 13668.333333333332
+(byte*) memset::dst#4 dst zp[2]:9 2002.0
 (byte*) memset::end
-(byte*) memset::end#0 end zp[2]:11 2.1666666666666665
+(byte*) memset::end#0 end zp[2]:11 1833.6666666666665
 (word) memset::num
-(word) memset::num#2 num zp[2]:11 2.0
+(word) memset::num#2 num zp[2]:11 1001.0
 (void*) memset::return
 (void*) memset::str
 (void*) memset::str#3 str zp[2]:9
@@ -146,7 +146,7 @@ zp[1]:8 [ frame_cnt ]
 reg byte x [ bitmap_plot::y#0 ]
 zp[2]:9 [ bitmap_plot::plotter#0 bitmap_plot::plotter#1 memset::str#3 memset::dst#2 memset::dst#4 memset::dst#1 ]
 zp[2]:11 [ bitmap_plot::$1 bitmap_init::yoffs#2 bitmap_init::yoffs#4 bitmap_init::yoffs#1 memset::num#2 memset::end#0 ]
-reg byte a [ bitmap_plot::$2 ]
+reg byte x [ bitmap_plot::$2 ]
 zp[1]:13 [ bitmap_init::$7 ]
 reg byte a [ bitmap_init::$4 ]
 reg byte a [ bitmap_init::$5 ]

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

@@ -269,10 +269,9 @@ bitmap_plot: {
     adc.z __1+1
     sta.z plotter+1
     // <x
-    lda.z x
+    ldx.z x
     // *plotter |= bitmap_plot_bit[<x]
-    tay
-    lda bitmap_plot_bit,y
+    lda bitmap_plot_bit,x
     ldy #0
     ora (plotter),y
     sta (plotter),y

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

@@ -38,10 +38,10 @@
 (byte) bitmap_clear::fgcol
 (byte*) bitmap_gfx
 (void()) bitmap_init((byte*) bitmap_init::gfx , (byte*) bitmap_init::screen)
-(byte~) bitmap_init::$4 reg byte a 22.0
-(byte~) bitmap_init::$5 reg byte a 22.0
-(byte~) bitmap_init::$6 reg byte a 22.0
-(byte~) bitmap_init::$7 zp[1]:31 5.5
+(byte~) bitmap_init::$4 reg byte a 2002.0
+(byte~) bitmap_init::$5 reg byte a 2002.0
+(byte~) bitmap_init::$6 reg byte a 2002.0
+(byte~) bitmap_init::$7 zp[1]:31 500.5
 (label) bitmap_init::@1
 (label) bitmap_init::@2
 (label) bitmap_init::@3
@@ -50,32 +50,32 @@
 (label) bitmap_init::@6
 (label) bitmap_init::@return
 (byte) bitmap_init::bits
-(byte) bitmap_init::bits#1 reg byte a 11.0
-(byte) bitmap_init::bits#3 reg byte a 16.5
-(byte) bitmap_init::bits#4 reg byte a 7.333333333333333
+(byte) bitmap_init::bits#1 reg byte a 1001.0
+(byte) bitmap_init::bits#3 reg byte a 1501.5
+(byte) bitmap_init::bits#4 reg byte a 667.3333333333334
 (byte*) bitmap_init::gfx
 (byte*) bitmap_init::screen
 (byte) bitmap_init::x
-(byte) bitmap_init::x#1 reg byte x 16.5
-(byte) bitmap_init::x#2 reg byte x 5.5
+(byte) bitmap_init::x#1 reg byte x 1501.5
+(byte) bitmap_init::x#2 reg byte x 500.5
 (byte) bitmap_init::y
-(byte) bitmap_init::y#1 reg byte x 16.5
-(byte) bitmap_init::y#2 reg byte x 5.5
+(byte) bitmap_init::y#1 reg byte x 1501.5
+(byte) bitmap_init::y#2 reg byte x 500.5
 (byte*) bitmap_init::yoffs
-(byte*) bitmap_init::yoffs#1 yoffs zp[2]:36 22.0
-(byte*) bitmap_init::yoffs#2 yoffs zp[2]:36 6.875
-(byte*) bitmap_init::yoffs#4 yoffs zp[2]:36 11.0
+(byte*) bitmap_init::yoffs#1 yoffs zp[2]:36 2002.0
+(byte*) bitmap_init::yoffs#2 yoffs zp[2]:36 625.625
+(byte*) bitmap_init::yoffs#4 yoffs zp[2]:36 1001.0
 (void()) bitmap_plot((word) bitmap_plot::x , (byte) bitmap_plot::y)
-(word~) bitmap_plot::$1 zp[2]:29 4.0
-(byte~) bitmap_plot::$2 reg byte a 4.0
+(word~) bitmap_plot::$1 zp[2]:29 2002.0
+(byte~) bitmap_plot::$2 reg byte x 2002.0
 (label) bitmap_plot::@return
 (byte*) bitmap_plot::plotter
-(word) bitmap_plot::plotter#0 plotter zp[2]:27 1.0
-(byte*) bitmap_plot::plotter#1 plotter zp[2]:27 3.0
+(word) bitmap_plot::plotter#0 plotter zp[2]:27 500.5
+(byte*) bitmap_plot::plotter#1 plotter zp[2]:27 1501.5
 (word) bitmap_plot::x
-(word) bitmap_plot::x#0 x zp[2]:23 3.75
+(word) bitmap_plot::x#0 x zp[2]:23 525.75
 (byte) bitmap_plot::y
-(byte) bitmap_plot::y#0 reg byte x 7.5
+(byte) bitmap_plot::y#0 reg byte x 1051.5
 (const byte*) bitmap_plot_bit[(number) $100]  = { fill( $100, 0) }
 (const byte*) bitmap_plot_yhi[(number) $100]  = { fill( $100, 0) }
 (const byte*) bitmap_plot_ylo[(number) $100]  = { fill( $100, 0) }
@@ -88,15 +88,15 @@
 (word) div32u16u::divisor
 (dword) div32u16u::quotient
 (word) div32u16u::quotient_hi
-(word) div32u16u::quotient_hi#0 quotient_hi zp[2]:44 0.8
+(word) div32u16u::quotient_hi#0 quotient_hi zp[2]:44 400.4
 (word) div32u16u::quotient_lo
-(word) div32u16u::quotient_lo#0 quotient_lo zp[2]:29 4.0
+(word) div32u16u::quotient_lo#0 quotient_lo zp[2]:29 2002.0
 (dword) div32u16u::return
-(dword) div32u16u::return#0 return zp[4]:32 1.3333333333333333
-(dword) div32u16u::return#2 return zp[4]:32 4.0
+(dword) div32u16u::return#0 return zp[4]:32 367.33333333333337
+(dword) div32u16u::return#2 return zp[4]:32 202.0
 (word()) divr16u((word) divr16u::dividend , (word) divr16u::divisor , (word) divr16u::rem)
-(byte~) divr16u::$1 reg byte a 22.0
-(byte~) divr16u::$2 reg byte a 22.0
+(byte~) divr16u::$1 reg byte a 200002.0
+(byte~) divr16u::$2 reg byte a 200002.0
 (label) divr16u::@1
 (label) divr16u::@2
 (label) divr16u::@3
@@ -105,31 +105,31 @@
 (label) divr16u::@6
 (label) divr16u::@return
 (word) divr16u::dividend
-(word) divr16u::dividend#0 dividend zp[2]:27 2.75
-(word) divr16u::dividend#3 dividend zp[2]:27 5.0
-(word) divr16u::dividend#5 dividend zp[2]:27 2.0
+(word) divr16u::dividend#0 dividend zp[2]:27 25000.25
+(word) divr16u::dividend#3 dividend zp[2]:27 44286.28571428572
+(word) divr16u::dividend#5 dividend zp[2]:27 10001.0
 (word) divr16u::divisor
 (byte) divr16u::i
-(byte) divr16u::i#1 reg byte x 16.5
-(byte) divr16u::i#2 reg byte x 1.6923076923076923
+(byte) divr16u::i#1 reg byte x 150001.5
+(byte) divr16u::i#2 reg byte x 15384.76923076923
 (word) divr16u::quotient
-(word) divr16u::quotient#1 quotient zp[2]:29 16.5
-(word) divr16u::quotient#2 quotient zp[2]:29 11.0
-(word) divr16u::quotient#3 quotient zp[2]:29 2.75
+(word) divr16u::quotient#1 quotient zp[2]:29 150001.5
+(word) divr16u::quotient#2 quotient zp[2]:29 100001.0
+(word) divr16u::quotient#3 quotient zp[2]:29 25000.25
 (word) divr16u::rem
-(word) divr16u::rem#0 rem zp[2]:20 8.25
-(word) divr16u::rem#1 rem zp[2]:20 22.0
-(word) divr16u::rem#10 rem zp[2]:20 4.0
-(word) divr16u::rem#11 rem zp[2]:20 11.666666666666666
-(word) divr16u::rem#2 rem zp[2]:20 22.0
-(word) divr16u::rem#4 rem zp[2]:20 4.0
-(word) divr16u::rem#5 rem zp[2]:20 24.0
-(word) divr16u::rem#6 rem zp[2]:20 11.0
+(word) divr16u::rem#0 rem zp[2]:20 75000.75
+(word) divr16u::rem#1 rem zp[2]:20 200002.0
+(word) divr16u::rem#10 rem zp[2]:20 11002.0
+(word) divr16u::rem#11 rem zp[2]:20 103334.66666666667
+(word) divr16u::rem#2 rem zp[2]:20 200002.0
+(word) divr16u::rem#4 rem zp[2]:20 2002.0
+(word) divr16u::rem#5 rem zp[2]:20 210003.0
+(word) divr16u::rem#6 rem zp[2]:20 100001.0
 (word) divr16u::return
-(word) divr16u::return#0 return zp[2]:29 5.285714285714286
-(word) divr16u::return#2 return zp[2]:29 4.0
-(word) divr16u::return#3 return zp[2]:29 4.0
-(byte) frame_cnt loadstore zp[1]:22 0.6382978723404255
+(word) divr16u::return#0 return zp[2]:29 43143.57142857143
+(word) divr16u::return#2 return zp[2]:29 2002.0
+(word) divr16u::return#3 return zp[2]:29 2002.0
+(byte) frame_cnt loadstore zp[1]:22 4.46808510638298
 (void()) init_irq()
 (label) init_irq::@return
 interrupt(HARDWARE_CLOBBER)(void()) irq()
@@ -137,14 +137,14 @@ interrupt(HARDWARE_CLOBBER)(void()) irq()
 (label) irq::@2
 (label) irq::@return
 (void()) main()
-(signed dword~) main::$11 zp[4]:8 22.0
-(word~) main::$12 reg byte alu 22.0
-(word~) main::$22 zp[2]:6 22.0
-(word~) main::$23 zp[2]:6 22.0
-(signed word*~) main::$24 zp[2]:6 22.0
-(signed word*~) main::$25 zp[2]:6 22.0
-(signed dword~) main::$6 zp[4]:8 22.0
-(word~) main::$7 reg byte alu 22.0
+(signed dword~) main::$11 zp[4]:8 202.0
+(word~) main::$12 reg byte alu 202.0
+(word~) main::$22 zp[2]:6 202.0
+(word~) main::$23 zp[2]:6 202.0
+(signed word*~) main::$24 zp[2]:6 202.0
+(signed word*~) main::$25 zp[2]:6 202.0
+(signed dword~) main::$6 zp[4]:8 202.0
+(word~) main::$7 reg byte alu 202.0
 (label) main::@1
 (label) main::@10
 (label) main::@11
@@ -159,53 +159,53 @@ interrupt(HARDWARE_CLOBBER)(void()) irq()
 (label) main::@8
 (label) main::@9
 (signed word) main::cos_x
-(signed word) main::cos_x#0 cos_x zp[2]:6 22.0
+(signed word) main::cos_x#0 cos_x zp[2]:6 202.0
 (word) main::idx_x
-(word) main::idx_x#1 idx_x zp[2]:2 11.0
-(word) main::idx_x#10 idx_x zp[2]:2 3.6666666666666665
-(word) main::idx_x#3 idx_x zp[2]:2 1.375
+(word) main::idx_x#1 idx_x zp[2]:2 101.0
+(word) main::idx_x#10 idx_x zp[2]:2 33.666666666666664
+(word) main::idx_x#3 idx_x zp[2]:2 12.625
 (word) main::idx_y
-(word) main::idx_y#1 idx_y zp[2]:4 11.0
-(word) main::idx_y#10 idx_y zp[2]:4 11.0
-(word) main::idx_y#3 idx_y zp[2]:4 1.1785714285714286
+(word) main::idx_y#1 idx_y zp[2]:4 101.0
+(word) main::idx_y#10 idx_y zp[2]:4 101.0
+(word) main::idx_y#3 idx_y zp[2]:4 10.821428571428571
 (signed word) main::sin_y
-(signed word) main::sin_y#0 sin_y zp[2]:6 22.0
+(signed word) main::sin_y#0 sin_y zp[2]:6 202.0
 (label) main::toD0181
 (byte*) main::toD0181_gfx
 (byte) main::toD0181_return
 (const byte) main::toD0181_return#0 toD0181_return = >(word)(const byte*) SCREEN&(word) $3fff*(byte) 4|>(word)(const byte*) BITMAP/(byte) 4&(byte) $f
 (byte*) main::toD0181_screen
 (word) main::x
-(word) main::x#0 x zp[2]:23 1.8333333333333333
+(word) main::x#0 x zp[2]:23 16.833333333333332
 (signed dword) main::xpos
-(signed dword) main::xpos#0 xpos zp[4]:8 22.0
+(signed dword) main::xpos#0 xpos zp[4]:8 202.0
 (word) main::y
-(word) main::y#0 y zp[2]:25 11.0
+(word) main::y#0 y zp[2]:25 101.0
 (signed dword) main::ypos
-(signed dword) main::ypos#0 ypos zp[4]:8 22.0
+(signed dword) main::ypos#0 ypos zp[4]:8 202.0
 (void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num)
 (label) memset::@1
 (label) memset::@2
 (label) memset::@3
 (label) memset::@return
 (byte) memset::c
-(byte) memset::c#4 reg byte x 1.375
+(byte) memset::c#4 reg byte x 1250.125
 (byte*) memset::dst
-(byte*) memset::dst#1 dst zp[2]:29 22.0
-(byte*) memset::dst#2 dst zp[2]:29 15.333333333333332
-(byte*) memset::dst#4 dst zp[2]:29 4.0
+(byte*) memset::dst#1 dst zp[2]:29 20002.0
+(byte*) memset::dst#2 dst zp[2]:29 13668.333333333332
+(byte*) memset::dst#4 dst zp[2]:29 2002.0
 (byte*) memset::end
-(byte*) memset::end#0 end zp[2]:27 2.1666666666666665
+(byte*) memset::end#0 end zp[2]:27 1833.6666666666665
 (word) memset::num
-(word) memset::num#2 num zp[2]:27 2.0
+(word) memset::num#2 num zp[2]:27 1001.0
 (void*) memset::return
 (void*) memset::str
 (void*) memset::str#3 str zp[2]:29
 (signed dword()) mul16s((signed word) mul16s::a , (signed word) mul16s::b)
-(word~) mul16s::$13 zp[2]:42 4.0
-(word~) mul16s::$16 zp[2]:36 4.0
-(word~) mul16s::$17 zp[2]:27 4.0
-(word~) mul16s::$9 zp[2]:36 4.0
+(word~) mul16s::$13 zp[2]:42 20002.0
+(word~) mul16s::$16 zp[2]:36 20002.0
+(word~) mul16s::$17 zp[2]:27 20002.0
+(word~) mul16s::$9 zp[2]:36 20002.0
 (label) mul16s::@1
 (label) mul16s::@2
 (label) mul16s::@3
@@ -213,83 +213,83 @@ interrupt(HARDWARE_CLOBBER)(void()) irq()
 (label) mul16s::@5
 (label) mul16s::@return
 (signed word) mul16s::a
-(signed word) mul16s::a#0 a zp[2]:27 22.0
-(signed word) mul16s::a#3 a zp[2]:27 1.0
+(signed word) mul16s::a#0 a zp[2]:27 2002.0
+(signed word) mul16s::a#3 a zp[2]:27 846.3076923076923
 (signed word) mul16s::b
-(signed word) mul16s::b#1 b zp[2]:6 22.0
-(signed word) mul16s::b#2 b zp[2]:6 22.0
-(signed word) mul16s::b#3 b zp[2]:6 2.1818181818181817
+(signed word) mul16s::b#1 b zp[2]:6 202.0
+(signed word) mul16s::b#2 b zp[2]:6 202.0
+(signed word) mul16s::b#3 b zp[2]:6 927.5454545454545
 (dword) mul16s::m
-(dword) mul16s::m#0 m zp[4]:8 2.0
-(dword) mul16s::m#1 m zp[4]:8 4.0
-(dword) mul16s::m#2 m zp[4]:8 4.0
-(dword) mul16s::m#4 m zp[4]:8 4.0
-(dword) mul16s::m#5 m zp[4]:8 2.5
+(dword) mul16s::m#0 m zp[4]:8 10001.0
+(dword) mul16s::m#1 m zp[4]:8 20002.0
+(dword) mul16s::m#2 m zp[4]:8 20002.0
+(dword) mul16s::m#4 m zp[4]:8 20002.0
+(dword) mul16s::m#5 m zp[4]:8 12501.25
 (signed dword) mul16s::return
-(signed dword) mul16s::return#0 return zp[4]:8 7.000000000000001
-(signed dword) mul16s::return#2 return zp[4]:8 22.0
-(signed dword) mul16s::return#3 return zp[4]:8 22.0
-(signed dword) mul16s::return#4 return zp[4]:8 22.0
+(signed dword) mul16s::return#0 return zp[4]:8 2240.8
+(signed dword) mul16s::return#2 return zp[4]:8 2002.0
+(signed dword) mul16s::return#3 return zp[4]:8 202.0
+(signed dword) mul16s::return#4 return zp[4]:8 202.0
 (dword()) mul16u((word) mul16u::a , (word) mul16u::b)
-(byte~) mul16u::$1 reg byte a 202.0
+(byte~) mul16u::$1 reg byte a 2.00000002E8
 (label) mul16u::@1
 (label) mul16u::@2
 (label) mul16u::@3
 (label) mul16u::@4
 (label) mul16u::@return
 (word) mul16u::a
-(word) mul16u::a#0 a zp[2]:36 101.0
-(word) mul16u::a#1 a zp[2]:36 2.0
-(word) mul16u::a#2 a zp[2]:36 2.0
-(word) mul16u::a#3 a zp[2]:36 67.66666666666666
-(word) mul16u::a#6 a zp[2]:36 3.0
+(word) mul16u::a#0 a zp[2]:36 1.00000001E8
+(word) mul16u::a#1 a zp[2]:36 10001.0
+(word) mul16u::a#2 a zp[2]:36 100001.0
+(word) mul16u::a#3 a zp[2]:36 6.683333416666667E7
+(word) mul16u::a#6 a zp[2]:36 555001.5
 (word) mul16u::b
-(word) mul16u::b#0 b zp[2]:29 4.0
-(word) mul16u::b#1 b zp[2]:29 4.0
-(word) mul16u::b#2 b zp[2]:29 4.0
+(word) mul16u::b#0 b zp[2]:29 20002.0
+(word) mul16u::b#1 b zp[2]:29 200002.0
+(word) mul16u::b#2 b zp[2]:29 110002.0
 (dword) mul16u::mb
-(dword) mul16u::mb#0 mb zp[4]:16 4.0
-(dword) mul16u::mb#1 mb zp[4]:16 202.0
-(dword) mul16u::mb#2 mb zp[4]:16 43.57142857142858
+(dword) mul16u::mb#0 mb zp[4]:16 2000002.0
+(dword) mul16u::mb#1 mb zp[4]:16 2.00000002E8
+(dword) mul16u::mb#2 mb zp[4]:16 4.300000057142857E7
 (dword) mul16u::res
-(dword) mul16u::res#1 res zp[4]:8 202.0
-(dword) mul16u::res#2 res zp[4]:8 43.85714285714286
-(dword) mul16u::res#6 res zp[4]:8 101.0
+(dword) mul16u::res#1 res zp[4]:8 2.00000002E8
+(dword) mul16u::res#2 res zp[4]:8 4.287285785714286E7
+(dword) mul16u::res#6 res zp[4]:8 1.00000001E8
 (dword) mul16u::return
-(dword) mul16u::return#2 return zp[4]:8 4.0
-(dword) mul16u::return#3 return zp[4]:8 4.0
+(dword) mul16u::return#2 return zp[4]:8 20002.0
+(dword) mul16u::return#3 return zp[4]:8 200002.0
 (word()) mulu16_sel((word) mulu16_sel::v1 , (word) mulu16_sel::v2 , (byte) mulu16_sel::select)
-(dword~) mulu16_sel::$0 zp[4]:8 4.0
-(dword~) mulu16_sel::$1 zp[4]:8 4.0
+(dword~) mulu16_sel::$0 zp[4]:8 200002.0
+(dword~) mulu16_sel::$1 zp[4]:8 200002.0
 (label) mulu16_sel::@1
 (label) mulu16_sel::@return
 (word) mulu16_sel::return
-(word) mulu16_sel::return#0 return zp[2]:44 4.0
-(word) mulu16_sel::return#1 return_1 zp[2]:20 4.0
-(word) mulu16_sel::return#10 return_1 zp[2]:20 4.0
-(word) mulu16_sel::return#11 return zp[2]:44 4.0
-(word) mulu16_sel::return#12 return zp[2]:44 1.714285714285714
-(word) mulu16_sel::return#2 return zp[2]:44 4.0
+(word) mulu16_sel::return#0 return zp[2]:44 20002.0
+(word) mulu16_sel::return#1 return_1 zp[2]:20 20002.0
+(word) mulu16_sel::return#10 return_1 zp[2]:20 20002.0
+(word) mulu16_sel::return#11 return zp[2]:44 20002.0
+(word) mulu16_sel::return#12 return zp[2]:44 21429.428571428572
+(word) mulu16_sel::return#2 return zp[2]:44 20002.0
 (byte) mulu16_sel::select
-(byte) mulu16_sel::select#5 reg byte x 0.3333333333333333
+(byte) mulu16_sel::select#5 reg byte x 16666.833333333332
 (word) mulu16_sel::v1
-(word) mulu16_sel::v1#0 v1 zp[2]:20 2.0
-(word) mulu16_sel::v1#1 v1 zp[2]:20 2.0
-(word) mulu16_sel::v1#2 v1 zp[2]:20 4.0
-(word) mulu16_sel::v1#3 v1 zp[2]:20 2.0
-(word) mulu16_sel::v1#4 v1 zp[2]:20 2.0
-(word) mulu16_sel::v1#5 v1 zp[2]:20 12.0
+(word) mulu16_sel::v1#0 v1 zp[2]:20 10001.0
+(word) mulu16_sel::v1#1 v1 zp[2]:20 10001.0
+(word) mulu16_sel::v1#2 v1 zp[2]:20 20002.0
+(word) mulu16_sel::v1#3 v1 zp[2]:20 10001.0
+(word) mulu16_sel::v1#4 v1 zp[2]:20 10001.0
+(word) mulu16_sel::v1#5 v1 zp[2]:20 150006.0
 (word) mulu16_sel::v2
-(word) mulu16_sel::v2#0 v2 zp[2]:29 4.0
-(word) mulu16_sel::v2#1 v2 zp[2]:29 4.0
-(word) mulu16_sel::v2#3 v2 zp[2]:29 4.0
-(word) mulu16_sel::v2#4 v2 zp[2]:29 4.0
-(word) mulu16_sel::v2#5 v2 zp[2]:29 5.0
+(word) mulu16_sel::v2#0 v2 zp[2]:29 20002.0
+(word) mulu16_sel::v2#1 v2 zp[2]:29 20002.0
+(word) mulu16_sel::v2#3 v2 zp[2]:29 20002.0
+(word) mulu16_sel::v2#4 v2 zp[2]:29 20002.0
+(word) mulu16_sel::v2#5 v2 zp[2]:29 70002.5
 (const byte*) plots_per_frame[(number) $100]  = { fill( $100, 0) }
 (word) rem16u
-(word) rem16u#1 rem16u zp[2]:20 0.8
+(word) rem16u#1 rem16u zp[2]:20 2200.4
 (signed word()) sin16s((dword) sin16s::x)
-(dword~) sin16s::$4 zp[4]:38 4.0
+(dword~) sin16s::$4 zp[4]:38 20002.0
 (label) sin16s::@1
 (label) sin16s::@10
 (label) sin16s::@11
@@ -304,39 +304,39 @@ interrupt(HARDWARE_CLOBBER)(void()) irq()
 (label) sin16s::@9
 (label) sin16s::@return
 (byte) sin16s::isUpper
-(byte) sin16s::isUpper#2 reg byte y 0.06060606060606061
+(byte) sin16s::isUpper#2 reg byte y 303.06060606060606
 (signed word) sin16s::return
-(signed word) sin16s::return#0 return zp[2]:27 22.0
-(signed word) sin16s::return#1 return zp[2]:27 5.0
-(signed word) sin16s::return#5 return zp[2]:27 4.0
+(signed word) sin16s::return#0 return zp[2]:27 2002.0
+(signed word) sin16s::return#1 return zp[2]:27 7001.0
+(signed word) sin16s::return#5 return zp[2]:27 20002.0
 (signed word) sin16s::sinx
-(signed word) sin16s::sinx#1 sinx zp[2]:27 4.0
+(signed word) sin16s::sinx#1 sinx zp[2]:27 20002.0
 (word) sin16s::usinx
-(word) sin16s::usinx#0 usinx zp[2]:27 0.3333333333333333
-(word) sin16s::usinx#1 usinx zp[2]:27 1.0
+(word) sin16s::usinx#0 usinx zp[2]:27 1666.8333333333333
+(word) sin16s::usinx#1 usinx zp[2]:27 5000.5
 (dword) sin16s::x
-(dword) sin16s::x#0 x zp[4]:16 8.5
-(dword) sin16s::x#1 x zp[4]:16 4.0
-(dword) sin16s::x#2 x zp[4]:16 4.0
-(dword) sin16s::x#4 x zp[4]:16 5.0
-(dword) sin16s::x#6 x zp[4]:16 6.0
+(dword) sin16s::x#0 x zp[4]:16 15502.0
+(dword) sin16s::x#1 x zp[4]:16 20002.0
+(dword) sin16s::x#2 x zp[4]:16 20002.0
+(dword) sin16s::x#4 x zp[4]:16 25002.5
+(dword) sin16s::x#6 x zp[4]:16 30003.0
 (word) sin16s::x1
-(word) sin16s::x1#0 x1 zp[2]:42 0.6363636363636365
+(word) sin16s::x1#0 x1 zp[2]:42 3182.1363636363635
 (word) sin16s::x2
-(word) sin16s::x2#0 x2 zp[2]:20 4.0
+(word) sin16s::x2#0 x2 zp[2]:20 20002.0
 (word) sin16s::x3
-(word) sin16s::x3#0 x3 zp[2]:20 1.0
+(word) sin16s::x3#0 x3 zp[2]:20 5000.5
 (word) sin16s::x3_6
-(word) sin16s::x3_6#0 x3_6 zp[2]:44 4.0
+(word) sin16s::x3_6#0 x3_6 zp[2]:44 20002.0
 (word) sin16s::x4
-(word) sin16s::x4#0 x4 zp[2]:20 4.0
+(word) sin16s::x4#0 x4 zp[2]:20 20002.0
 (word) sin16s::x5
-(word) sin16s::x5#0 x5 zp[2]:44 4.0
+(word) sin16s::x5#0 x5 zp[2]:44 20002.0
 (word) sin16s::x5_128
-(word) sin16s::x5_128#0 x5_128 zp[2]:44 4.0
+(word) sin16s::x5_128#0 x5_128 zp[2]:44 20002.0
 (void()) sin16s_gen2((signed word*) sin16s_gen2::sintab , (word) sin16s_gen2::wavelength , (signed word) sin16s_gen2::min , (signed word) sin16s_gen2::max)
-(signed dword~) sin16s_gen2::$6 zp[4]:8 22.0
-(word~) sin16s_gen2::$9 zp[2]:36 11.0
+(signed dword~) sin16s_gen2::$6 zp[4]:8 2002.0
+(word~) sin16s_gen2::$9 zp[2]:36 1001.0
 (label) sin16s_gen2::@1
 (label) sin16s_gen2::@2
 (label) sin16s_gen2::@3
@@ -346,23 +346,23 @@ interrupt(HARDWARE_CLOBBER)(void()) irq()
 (signed word) sin16s_gen2::ampl
 (const signed word) sin16s_gen2::ampl#0 ampl = (const signed word) sin16s_gen2::max#0-(const signed word) sin16s_gen2::min#0
 (word) sin16s_gen2::i
-(word) sin16s_gen2::i#1 i zp[2]:23 22.0
-(word) sin16s_gen2::i#2 i zp[2]:23 2.5384615384615383
+(word) sin16s_gen2::i#1 i zp[2]:23 2002.0
+(word) sin16s_gen2::i#2 i zp[2]:23 231.0
 (signed word) sin16s_gen2::max
 (const signed word) sin16s_gen2::max#0 max = (signed word) $1001
 (signed word) sin16s_gen2::min
 (const signed word) sin16s_gen2::min#0 min = (signed word) -$1001
 (signed word) sin16s_gen2::offs
 (signed word*) sin16s_gen2::sintab
-(signed word*) sin16s_gen2::sintab#0 sintab zp[2]:25 7.333333333333333
-(signed word*) sin16s_gen2::sintab#2 sintab zp[2]:25 3.0
+(signed word*) sin16s_gen2::sintab#0 sintab zp[2]:25 667.3333333333334
+(signed word*) sin16s_gen2::sintab#2 sintab zp[2]:25 273.0
 (dword) sin16s_gen2::step
-(dword) sin16s_gen2::step#0 step zp[4]:32 0.8666666666666666
+(dword) sin16s_gen2::step#0 step zp[4]:32 73.46666666666667
 (word) sin16s_gen2::wavelength
 (const word) sin16s_gen2::wavelength#0 wavelength = (word) $200
 (dword) sin16s_gen2::x
-(dword) sin16s_gen2::x#1 x zp[4]:12 11.0
-(dword) sin16s_gen2::x#2 x zp[4]:12 2.75
+(dword) sin16s_gen2::x#1 x zp[4]:12 1001.0
+(dword) sin16s_gen2::x#2 x zp[4]:12 250.25
 
 zp[2]:2 [ main::idx_x#3 main::idx_x#10 main::idx_x#1 ]
 zp[2]:4 [ main::idx_y#3 main::idx_y#10 main::idx_y#1 ]
@@ -386,7 +386,7 @@ zp[2]:25 [ main::y#0 sin16s_gen2::sintab#2 sin16s_gen2::sintab#0 ]
 reg byte x [ bitmap_plot::y#0 ]
 zp[2]:27 [ bitmap_plot::plotter#0 bitmap_plot::plotter#1 divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#0 memset::num#2 memset::end#0 mul16s::a#3 mul16s::a#0 mul16s::$17 sin16s::return#0 sin16s::return#1 sin16s::return#5 sin16s::sinx#1 sin16s::usinx#1 sin16s::usinx#0 ]
 zp[2]:29 [ bitmap_plot::$1 divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 divr16u::return#2 divr16u::return#3 div32u16u::quotient_lo#0 memset::str#3 memset::dst#2 memset::dst#4 memset::dst#1 mul16u::b#2 mul16u::b#0 mul16u::b#1 mulu16_sel::v2#5 mulu16_sel::v2#3 mulu16_sel::v2#4 mulu16_sel::v2#0 mulu16_sel::v2#1 ]
-reg byte a [ bitmap_plot::$2 ]
+reg byte x [ bitmap_plot::$2 ]
 reg byte a [ mul16u::$1 ]
 zp[1]:31 [ bitmap_init::$7 ]
 reg byte a [ bitmap_init::$4 ]

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

@@ -306,10 +306,9 @@ bitmap_plot: {
     adc.z __1+1
     sta.z plotter+1
     // <x
-    lda.z x
+    ldx.z x
     // *plotter |= bitmap_plot_bit[<x]
-    tay
-    lda bitmap_plot_bit,y
+    lda bitmap_plot_bit,x
     ldy #0
     ora (plotter),y
     sta (plotter),y

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

@@ -39,10 +39,10 @@
 (byte) bitmap_clear::fgcol
 (byte*) bitmap_gfx
 (void()) bitmap_init((byte*) bitmap_init::gfx , (byte*) bitmap_init::screen)
-(byte~) bitmap_init::$4 reg byte a 22.0
-(byte~) bitmap_init::$5 reg byte a 22.0
-(byte~) bitmap_init::$6 reg byte a 22.0
-(byte~) bitmap_init::$7 zp[1]:32 5.5
+(byte~) bitmap_init::$4 reg byte a 2002.0
+(byte~) bitmap_init::$5 reg byte a 2002.0
+(byte~) bitmap_init::$6 reg byte a 2002.0
+(byte~) bitmap_init::$7 zp[1]:32 500.5
 (label) bitmap_init::@1
 (label) bitmap_init::@2
 (label) bitmap_init::@3
@@ -51,32 +51,32 @@
 (label) bitmap_init::@6
 (label) bitmap_init::@return
 (byte) bitmap_init::bits
-(byte) bitmap_init::bits#1 reg byte a 11.0
-(byte) bitmap_init::bits#3 reg byte a 16.5
-(byte) bitmap_init::bits#4 reg byte a 7.333333333333333
+(byte) bitmap_init::bits#1 reg byte a 1001.0
+(byte) bitmap_init::bits#3 reg byte a 1501.5
+(byte) bitmap_init::bits#4 reg byte a 667.3333333333334
 (byte*) bitmap_init::gfx
 (byte*) bitmap_init::screen
 (byte) bitmap_init::x
-(byte) bitmap_init::x#1 reg byte x 16.5
-(byte) bitmap_init::x#2 reg byte x 5.5
+(byte) bitmap_init::x#1 reg byte x 1501.5
+(byte) bitmap_init::x#2 reg byte x 500.5
 (byte) bitmap_init::y
-(byte) bitmap_init::y#1 reg byte x 16.5
-(byte) bitmap_init::y#2 reg byte x 5.5
+(byte) bitmap_init::y#1 reg byte x 1501.5
+(byte) bitmap_init::y#2 reg byte x 500.5
 (byte*) bitmap_init::yoffs
-(byte*) bitmap_init::yoffs#1 yoffs zp[2]:15 22.0
-(byte*) bitmap_init::yoffs#2 yoffs zp[2]:15 6.875
-(byte*) bitmap_init::yoffs#4 yoffs zp[2]:15 11.0
+(byte*) bitmap_init::yoffs#1 yoffs zp[2]:15 2002.0
+(byte*) bitmap_init::yoffs#2 yoffs zp[2]:15 625.625
+(byte*) bitmap_init::yoffs#4 yoffs zp[2]:15 1001.0
 (void()) bitmap_plot((word) bitmap_plot::x , (byte) bitmap_plot::y)
-(word~) bitmap_plot::$1 zp[2]:43 4.0
-(byte~) bitmap_plot::$2 reg byte a 4.0
+(word~) bitmap_plot::$1 zp[2]:43 2002.0
+(byte~) bitmap_plot::$2 reg byte x 2002.0
 (label) bitmap_plot::@return
 (byte*) bitmap_plot::plotter
-(word) bitmap_plot::plotter#0 plotter zp[2]:37 1.0
-(byte*) bitmap_plot::plotter#1 plotter zp[2]:37 3.0
+(word) bitmap_plot::plotter#0 plotter zp[2]:37 500.5
+(byte*) bitmap_plot::plotter#1 plotter zp[2]:37 1501.5
 (word) bitmap_plot::x
-(word) bitmap_plot::x#0 x zp[2]:28 3.75
+(word) bitmap_plot::x#0 x zp[2]:28 525.75
 (byte) bitmap_plot::y
-(byte) bitmap_plot::y#0 reg byte x 7.5
+(byte) bitmap_plot::y#0 reg byte x 1051.5
 (const byte*) bitmap_plot_bit[(number) $100]  = { fill( $100, 0) }
 (const byte*) bitmap_plot_yhi[(number) $100]  = { fill( $100, 0) }
 (const byte*) bitmap_plot_ylo[(number) $100]  = { fill( $100, 0) }
@@ -89,15 +89,15 @@
 (word) div32u16u::divisor
 (dword) div32u16u::quotient
 (word) div32u16u::quotient_hi
-(word) div32u16u::quotient_hi#0 quotient_hi zp[2]:45 0.8
+(word) div32u16u::quotient_hi#0 quotient_hi zp[2]:45 400.4
 (word) div32u16u::quotient_lo
-(word) div32u16u::quotient_lo#0 quotient_lo zp[2]:37 4.0
+(word) div32u16u::quotient_lo#0 quotient_lo zp[2]:37 2002.0
 (dword) div32u16u::return
-(dword) div32u16u::return#0 return zp[4]:33 1.3333333333333333
-(dword) div32u16u::return#2 return zp[4]:33 4.0
+(dword) div32u16u::return#0 return zp[4]:33 367.33333333333337
+(dword) div32u16u::return#2 return zp[4]:33 202.0
 (word()) divr16u((word) divr16u::dividend , (word) divr16u::divisor , (word) divr16u::rem)
-(byte~) divr16u::$1 reg byte a 22.0
-(byte~) divr16u::$2 reg byte a 22.0
+(byte~) divr16u::$1 reg byte a 200002.0
+(byte~) divr16u::$2 reg byte a 200002.0
 (label) divr16u::@1
 (label) divr16u::@2
 (label) divr16u::@3
@@ -106,31 +106,31 @@
 (label) divr16u::@6
 (label) divr16u::@return
 (word) divr16u::dividend
-(word) divr16u::dividend#0 dividend zp[2]:30 2.75
-(word) divr16u::dividend#3 dividend zp[2]:30 5.0
-(word) divr16u::dividend#5 dividend zp[2]:30 2.0
+(word) divr16u::dividend#0 dividend zp[2]:30 25000.25
+(word) divr16u::dividend#3 dividend zp[2]:30 44286.28571428572
+(word) divr16u::dividend#5 dividend zp[2]:30 10001.0
 (word) divr16u::divisor
 (byte) divr16u::i
-(byte) divr16u::i#1 reg byte x 16.5
-(byte) divr16u::i#2 reg byte x 1.6923076923076923
+(byte) divr16u::i#1 reg byte x 150001.5
+(byte) divr16u::i#2 reg byte x 15384.76923076923
 (word) divr16u::quotient
-(word) divr16u::quotient#1 quotient zp[2]:37 16.5
-(word) divr16u::quotient#2 quotient zp[2]:37 11.0
-(word) divr16u::quotient#3 quotient zp[2]:37 2.75
+(word) divr16u::quotient#1 quotient zp[2]:37 150001.5
+(word) divr16u::quotient#2 quotient zp[2]:37 100001.0
+(word) divr16u::quotient#3 quotient zp[2]:37 25000.25
 (word) divr16u::rem
-(word) divr16u::rem#0 rem zp[2]:25 8.25
-(word) divr16u::rem#1 rem zp[2]:25 22.0
-(word) divr16u::rem#10 rem zp[2]:25 4.0
-(word) divr16u::rem#11 rem zp[2]:25 11.666666666666666
-(word) divr16u::rem#2 rem zp[2]:25 22.0
-(word) divr16u::rem#4 rem zp[2]:25 4.0
-(word) divr16u::rem#5 rem zp[2]:25 24.0
-(word) divr16u::rem#6 rem zp[2]:25 11.0
+(word) divr16u::rem#0 rem zp[2]:25 75000.75
+(word) divr16u::rem#1 rem zp[2]:25 200002.0
+(word) divr16u::rem#10 rem zp[2]:25 11002.0
+(word) divr16u::rem#11 rem zp[2]:25 103334.66666666667
+(word) divr16u::rem#2 rem zp[2]:25 200002.0
+(word) divr16u::rem#4 rem zp[2]:25 2002.0
+(word) divr16u::rem#5 rem zp[2]:25 210003.0
+(word) divr16u::rem#6 rem zp[2]:25 100001.0
 (word) divr16u::return
-(word) divr16u::return#0 return zp[2]:37 5.285714285714286
-(word) divr16u::return#2 return zp[2]:37 4.0
-(word) divr16u::return#3 return zp[2]:37 4.0
-(byte) frame_cnt loadstore zp[1]:27 0.5454545454545455
+(word) divr16u::return#0 return zp[2]:37 43143.57142857143
+(word) divr16u::return#2 return zp[2]:37 2002.0
+(word) divr16u::return#3 return zp[2]:37 2002.0
+(byte) frame_cnt loadstore zp[1]:27 3.8181818181818175
 (void()) init_irq()
 (label) init_irq::@return
 interrupt(HARDWARE_CLOBBER)(void()) irq()
@@ -138,14 +138,14 @@ interrupt(HARDWARE_CLOBBER)(void()) irq()
 (label) irq::@2
 (label) irq::@return
 (void()) main()
-(word~) main::$13 zp[2]:30 11.0
-(signed word~) main::$14 zp[2]:30 22.0
-(word~) main::$31 zp[2]:9 22.0
-(word~) main::$32 zp[2]:9 22.0
-(signed word*~) main::$33 zp[2]:9 22.0
-(signed word*~) main::$34 zp[2]:9 22.0
-(word~) main::$7 zp[2]:28 11.0
-(signed word~) main::$8 zp[2]:28 22.0
+(word~) main::$13 zp[2]:30 101.0
+(signed word~) main::$14 zp[2]:30 202.0
+(word~) main::$31 zp[2]:9 202.0
+(word~) main::$32 zp[2]:9 202.0
+(signed word*~) main::$33 zp[2]:9 202.0
+(signed word*~) main::$34 zp[2]:9 202.0
+(word~) main::$7 zp[2]:28 101.0
+(signed word~) main::$8 zp[2]:28 202.0
 (label) main::@1
 (label) main::@10
 (label) main::@11
@@ -164,60 +164,60 @@ interrupt(HARDWARE_CLOBBER)(void()) irq()
 (label) main::@8
 (label) main::@9
 (signed word) main::cos_x
-(signed word) main::cos_x#0 cos_x zp[2]:9 11.0
+(signed word) main::cos_x#0 cos_x zp[2]:9 101.0
 (word) main::idx_x
-(word) main::idx_x#1 idx_x zp[2]:2 11.0
-(word) main::idx_x#10 idx_x zp[2]:2 3.0
-(word) main::idx_x#11 idx_x zp[2]:2 1.222222222222222
+(word) main::idx_x#1 idx_x zp[2]:2 101.0
+(word) main::idx_x#10 idx_x zp[2]:2 27.545454545454547
+(word) main::idx_x#11 idx_x zp[2]:2 11.222222222222223
 (word) main::idx_y
-(word) main::idx_y#1 idx_y zp[2]:6 11.0
-(word) main::idx_y#10 idx_y zp[2]:6 3.142857142857143
-(word) main::idx_y#3 idx_y zp[2]:6 1.064516129032258
+(word) main::idx_y#1 idx_y zp[2]:6 101.0
+(word) main::idx_y#10 idx_y zp[2]:6 28.857142857142858
+(word) main::idx_y#3 idx_y zp[2]:6 9.774193548387098
 (signed word) main::r
-(signed word) main::r#1 r zp[2]:4 5.5
-(signed word) main::r#10 r zp[2]:4 1.2571428571428571
+(signed word) main::r#1 r zp[2]:4 50.5
+(signed word) main::r#10 r zp[2]:4 11.542857142857143
 (byte) main::r_add
-(byte) main::r_add#1 r_add zp[1]:8 22.0
-(byte) main::r_add#10 r_add zp[1]:8 2.026315789473684
-(byte) main::r_add#12 r_add zp[1]:8 16.5
+(byte) main::r_add#1 r_add zp[1]:8 202.0
+(byte) main::r_add#10 r_add zp[1]:8 18.60526315789474
+(byte) main::r_add#12 r_add zp[1]:8 151.5
 (signed word) main::sin_y
-(signed word) main::sin_y#0 sin_y zp[2]:9 11.0
+(signed word) main::sin_y#0 sin_y zp[2]:9 101.0
 (label) main::toD0181
 (byte*) main::toD0181_gfx
 (byte) main::toD0181_return
 (const byte) main::toD0181_return#0 toD0181_return = >(word)(const byte*) SCREEN&(word) $3fff*(byte) 4|>(word)(const byte*) BITMAP/(byte) 4&(byte) $f
 (byte*) main::toD0181_screen
 (word) main::x
-(signed word) main::x#0 x zp[2]:28 0.8461538461538461
+(signed word) main::x#0 x zp[2]:28 7.769230769230769
 (signed dword) main::xpos
-(signed dword) main::xpos#0 xpos zp[4]:11 22.0
+(signed dword) main::xpos#0 xpos zp[4]:11 202.0
 (word) main::y
-(signed word) main::y#0 y zp[2]:30 11.0
+(signed word) main::y#0 y zp[2]:30 101.0
 (signed dword) main::ypos
-(signed dword) main::ypos#0 ypos zp[4]:11 22.0
+(signed dword) main::ypos#0 ypos zp[4]:11 202.0
 (void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num)
 (label) memset::@1
 (label) memset::@2
 (label) memset::@3
 (label) memset::@return
 (byte) memset::c
-(byte) memset::c#4 reg byte x 1.375
+(byte) memset::c#4 reg byte x 1250.125
 (byte*) memset::dst
-(byte*) memset::dst#1 dst zp[2]:37 22.0
-(byte*) memset::dst#2 dst zp[2]:37 15.333333333333332
-(byte*) memset::dst#4 dst zp[2]:37 4.0
+(byte*) memset::dst#1 dst zp[2]:37 20002.0
+(byte*) memset::dst#2 dst zp[2]:37 13668.333333333332
+(byte*) memset::dst#4 dst zp[2]:37 2002.0
 (byte*) memset::end
-(byte*) memset::end#0 end zp[2]:30 2.1666666666666665
+(byte*) memset::end#0 end zp[2]:30 1833.6666666666665
 (word) memset::num
-(word) memset::num#2 num zp[2]:30 2.0
+(word) memset::num#2 num zp[2]:30 1001.0
 (void*) memset::return
 (void*) memset::str
 (void*) memset::str#3 str zp[2]:37
 (signed dword()) mul16s((signed word) mul16s::a , (signed word) mul16s::b)
-(word~) mul16s::$13 zp[2]:37 4.0
-(word~) mul16s::$16 zp[2]:43 4.0
-(word~) mul16s::$17 zp[2]:37 4.0
-(word~) mul16s::$9 zp[2]:43 4.0
+(word~) mul16s::$13 zp[2]:37 20002.0
+(word~) mul16s::$16 zp[2]:43 20002.0
+(word~) mul16s::$17 zp[2]:37 20002.0
+(word~) mul16s::$9 zp[2]:43 20002.0
 (label) mul16s::@1
 (label) mul16s::@2
 (label) mul16s::@3
@@ -225,85 +225,85 @@ interrupt(HARDWARE_CLOBBER)(void()) irq()
 (label) mul16s::@5
 (label) mul16s::@return
 (signed word) mul16s::a
-(signed word) mul16s::a#0 a zp[2]:4 22.0
-(signed word) mul16s::a#1 a zp[2]:4 11.0
-(signed word) mul16s::a#2 a zp[2]:4 11.0
-(signed word) mul16s::a#3 a zp[2]:4 2.692307692307692
+(signed word) mul16s::a#0 a zp[2]:4 2002.0
+(signed word) mul16s::a#1 a zp[2]:4 101.0
+(signed word) mul16s::a#2 a zp[2]:4 101.0
+(signed word) mul16s::a#3 a zp[2]:4 861.8461538461538
 (signed word) mul16s::b
-(signed word) mul16s::b#1 b zp[2]:9 22.0
-(signed word) mul16s::b#2 b zp[2]:9 22.0
-(signed word) mul16s::b#3 b zp[2]:9 2.1818181818181817
+(signed word) mul16s::b#1 b zp[2]:9 202.0
+(signed word) mul16s::b#2 b zp[2]:9 202.0
+(signed word) mul16s::b#3 b zp[2]:9 927.5454545454545
 (dword) mul16s::m
-(dword) mul16s::m#0 m zp[4]:11 2.0
-(dword) mul16s::m#1 m zp[4]:11 4.0
-(dword) mul16s::m#2 m zp[4]:11 4.0
-(dword) mul16s::m#4 m zp[4]:11 4.0
-(dword) mul16s::m#5 m zp[4]:11 2.5
+(dword) mul16s::m#0 m zp[4]:11 10001.0
+(dword) mul16s::m#1 m zp[4]:11 20002.0
+(dword) mul16s::m#2 m zp[4]:11 20002.0
+(dword) mul16s::m#4 m zp[4]:11 20002.0
+(dword) mul16s::m#5 m zp[4]:11 12501.25
 (signed dword) mul16s::return
-(signed dword) mul16s::return#0 return zp[4]:11 7.000000000000001
-(signed dword) mul16s::return#2 return zp[4]:11 22.0
-(signed dword) mul16s::return#3 return zp[4]:11 22.0
-(signed dword) mul16s::return#4 return zp[4]:11 22.0
+(signed dword) mul16s::return#0 return zp[4]:11 2240.8
+(signed dword) mul16s::return#2 return zp[4]:11 2002.0
+(signed dword) mul16s::return#3 return zp[4]:11 202.0
+(signed dword) mul16s::return#4 return zp[4]:11 202.0
 (dword()) mul16u((word) mul16u::a , (word) mul16u::b)
-(byte~) mul16u::$1 reg byte a 202.0
+(byte~) mul16u::$1 reg byte a 2.00000002E8
 (label) mul16u::@1
 (label) mul16u::@2
 (label) mul16u::@3
 (label) mul16u::@4
 (label) mul16u::@return
 (word) mul16u::a
-(word) mul16u::a#0 a zp[2]:37 101.0
-(word) mul16u::a#1 a zp[2]:37 2.0
-(word) mul16u::a#2 a zp[2]:37 2.0
-(word) mul16u::a#3 a zp[2]:37 67.66666666666666
-(word) mul16u::a#6 a zp[2]:37 3.0
+(word) mul16u::a#0 a zp[2]:37 1.00000001E8
+(word) mul16u::a#1 a zp[2]:37 10001.0
+(word) mul16u::a#2 a zp[2]:37 100001.0
+(word) mul16u::a#3 a zp[2]:37 6.683333416666667E7
+(word) mul16u::a#6 a zp[2]:37 555001.5
 (word) mul16u::b
-(word) mul16u::b#0 b zp[2]:30 4.0
-(word) mul16u::b#1 b zp[2]:30 4.0
-(word) mul16u::b#2 b zp[2]:30 4.0
+(word) mul16u::b#0 b zp[2]:30 20002.0
+(word) mul16u::b#1 b zp[2]:30 200002.0
+(word) mul16u::b#2 b zp[2]:30 110002.0
 (dword) mul16u::mb
-(dword) mul16u::mb#0 mb zp[4]:21 4.0
-(dword) mul16u::mb#1 mb zp[4]:21 202.0
-(dword) mul16u::mb#2 mb zp[4]:21 43.57142857142858
+(dword) mul16u::mb#0 mb zp[4]:21 2000002.0
+(dword) mul16u::mb#1 mb zp[4]:21 2.00000002E8
+(dword) mul16u::mb#2 mb zp[4]:21 4.300000057142857E7
 (dword) mul16u::res
-(dword) mul16u::res#1 res zp[4]:11 202.0
-(dword) mul16u::res#2 res zp[4]:11 43.85714285714286
-(dword) mul16u::res#6 res zp[4]:11 101.0
+(dword) mul16u::res#1 res zp[4]:11 2.00000002E8
+(dword) mul16u::res#2 res zp[4]:11 4.287285785714286E7
+(dword) mul16u::res#6 res zp[4]:11 1.00000001E8
 (dword) mul16u::return
-(dword) mul16u::return#2 return zp[4]:11 4.0
-(dword) mul16u::return#3 return zp[4]:11 4.0
+(dword) mul16u::return#2 return zp[4]:11 20002.0
+(dword) mul16u::return#3 return zp[4]:11 200002.0
 (word()) mulu16_sel((word) mulu16_sel::v1 , (word) mulu16_sel::v2 , (byte) mulu16_sel::select)
-(dword~) mulu16_sel::$0 zp[4]:11 4.0
-(dword~) mulu16_sel::$1 zp[4]:11 4.0
+(dword~) mulu16_sel::$0 zp[4]:11 200002.0
+(dword~) mulu16_sel::$1 zp[4]:11 200002.0
 (label) mulu16_sel::@1
 (label) mulu16_sel::@return
 (word) mulu16_sel::return
-(word) mulu16_sel::return#0 return zp[2]:43 4.0
-(word) mulu16_sel::return#1 return_1 zp[2]:25 4.0
-(word) mulu16_sel::return#10 return_1 zp[2]:25 4.0
-(word) mulu16_sel::return#11 return zp[2]:43 4.0
-(word) mulu16_sel::return#12 return zp[2]:43 1.714285714285714
-(word) mulu16_sel::return#2 return zp[2]:43 4.0
+(word) mulu16_sel::return#0 return zp[2]:43 20002.0
+(word) mulu16_sel::return#1 return_1 zp[2]:25 20002.0
+(word) mulu16_sel::return#10 return_1 zp[2]:25 20002.0
+(word) mulu16_sel::return#11 return zp[2]:43 20002.0
+(word) mulu16_sel::return#12 return zp[2]:43 21429.428571428572
+(word) mulu16_sel::return#2 return zp[2]:43 20002.0
 (byte) mulu16_sel::select
-(byte) mulu16_sel::select#5 reg byte x 0.3333333333333333
+(byte) mulu16_sel::select#5 reg byte x 16666.833333333332
 (word) mulu16_sel::v1
-(word) mulu16_sel::v1#0 v1 zp[2]:25 2.0
-(word) mulu16_sel::v1#1 v1 zp[2]:25 2.0
-(word) mulu16_sel::v1#2 v1 zp[2]:25 4.0
-(word) mulu16_sel::v1#3 v1 zp[2]:25 2.0
-(word) mulu16_sel::v1#4 v1 zp[2]:25 2.0
-(word) mulu16_sel::v1#5 v1 zp[2]:25 12.0
+(word) mulu16_sel::v1#0 v1 zp[2]:25 10001.0
+(word) mulu16_sel::v1#1 v1 zp[2]:25 10001.0
+(word) mulu16_sel::v1#2 v1 zp[2]:25 20002.0
+(word) mulu16_sel::v1#3 v1 zp[2]:25 10001.0
+(word) mulu16_sel::v1#4 v1 zp[2]:25 10001.0
+(word) mulu16_sel::v1#5 v1 zp[2]:25 150006.0
 (word) mulu16_sel::v2
-(word) mulu16_sel::v2#0 v2 zp[2]:30 4.0
-(word) mulu16_sel::v2#1 v2 zp[2]:30 4.0
-(word) mulu16_sel::v2#3 v2 zp[2]:30 4.0
-(word) mulu16_sel::v2#4 v2 zp[2]:30 4.0
-(word) mulu16_sel::v2#5 v2 zp[2]:30 5.0
+(word) mulu16_sel::v2#0 v2 zp[2]:30 20002.0
+(word) mulu16_sel::v2#1 v2 zp[2]:30 20002.0
+(word) mulu16_sel::v2#3 v2 zp[2]:30 20002.0
+(word) mulu16_sel::v2#4 v2 zp[2]:30 20002.0
+(word) mulu16_sel::v2#5 v2 zp[2]:30 70002.5
 (const byte*) plots_per_frame[(number) $100]  = { fill( $100, 0) }
 (word) rem16u
-(word) rem16u#1 rem16u zp[2]:25 0.8
+(word) rem16u#1 rem16u zp[2]:25 2200.4
 (signed word()) sin16s((dword) sin16s::x)
-(dword~) sin16s::$4 zp[4]:39 4.0
+(dword~) sin16s::$4 zp[4]:39 20002.0
 (label) sin16s::@1
 (label) sin16s::@10
 (label) sin16s::@11
@@ -318,39 +318,39 @@ interrupt(HARDWARE_CLOBBER)(void()) irq()
 (label) sin16s::@9
 (label) sin16s::@return
 (byte) sin16s::isUpper
-(byte) sin16s::isUpper#2 reg byte y 0.06060606060606061
+(byte) sin16s::isUpper#2 reg byte y 303.06060606060606
 (signed word) sin16s::return
-(signed word) sin16s::return#0 return zp[2]:4 22.0
-(signed word) sin16s::return#1 return zp[2]:4 5.0
-(signed word) sin16s::return#5 return zp[2]:4 4.0
+(signed word) sin16s::return#0 return zp[2]:4 2002.0
+(signed word) sin16s::return#1 return zp[2]:4 7001.0
+(signed word) sin16s::return#5 return zp[2]:4 20002.0
 (signed word) sin16s::sinx
-(signed word) sin16s::sinx#1 sinx zp[2]:4 4.0
+(signed word) sin16s::sinx#1 sinx zp[2]:4 20002.0
 (word) sin16s::usinx
-(word) sin16s::usinx#0 usinx zp[2]:4 0.3333333333333333
-(word) sin16s::usinx#1 usinx zp[2]:4 1.0
+(word) sin16s::usinx#0 usinx zp[2]:4 1666.8333333333333
+(word) sin16s::usinx#1 usinx zp[2]:4 5000.5
 (dword) sin16s::x
-(dword) sin16s::x#0 x zp[4]:21 8.5
-(dword) sin16s::x#1 x zp[4]:21 4.0
-(dword) sin16s::x#2 x zp[4]:21 4.0
-(dword) sin16s::x#4 x zp[4]:21 5.0
-(dword) sin16s::x#6 x zp[4]:21 6.0
+(dword) sin16s::x#0 x zp[4]:21 15502.0
+(dword) sin16s::x#1 x zp[4]:21 20002.0
+(dword) sin16s::x#2 x zp[4]:21 20002.0
+(dword) sin16s::x#4 x zp[4]:21 25002.5
+(dword) sin16s::x#6 x zp[4]:21 30003.0
 (word) sin16s::x1
-(word) sin16s::x1#0 x1 zp[2]:45 0.6363636363636365
+(word) sin16s::x1#0 x1 zp[2]:45 3182.1363636363635
 (word) sin16s::x2
-(word) sin16s::x2#0 x2 zp[2]:25 4.0
+(word) sin16s::x2#0 x2 zp[2]:25 20002.0
 (word) sin16s::x3
-(word) sin16s::x3#0 x3 zp[2]:25 1.0
+(word) sin16s::x3#0 x3 zp[2]:25 5000.5
 (word) sin16s::x3_6
-(word) sin16s::x3_6#0 x3_6 zp[2]:43 4.0
+(word) sin16s::x3_6#0 x3_6 zp[2]:43 20002.0
 (word) sin16s::x4
-(word) sin16s::x4#0 x4 zp[2]:25 4.0
+(word) sin16s::x4#0 x4 zp[2]:25 20002.0
 (word) sin16s::x5
-(word) sin16s::x5#0 x5 zp[2]:43 4.0
+(word) sin16s::x5#0 x5 zp[2]:43 20002.0
 (word) sin16s::x5_128
-(word) sin16s::x5_128#0 x5_128 zp[2]:43 4.0
+(word) sin16s::x5_128#0 x5_128 zp[2]:43 20002.0
 (void()) sin16s_gen2((signed word*) sin16s_gen2::sintab , (word) sin16s_gen2::wavelength , (signed word) sin16s_gen2::min , (signed word) sin16s_gen2::max)
-(signed dword~) sin16s_gen2::$6 zp[4]:11 22.0
-(word~) sin16s_gen2::$9 zp[2]:37 11.0
+(signed dword~) sin16s_gen2::$6 zp[4]:11 2002.0
+(word~) sin16s_gen2::$9 zp[2]:37 1001.0
 (label) sin16s_gen2::@1
 (label) sin16s_gen2::@2
 (label) sin16s_gen2::@3
@@ -360,23 +360,23 @@ interrupt(HARDWARE_CLOBBER)(void()) irq()
 (signed word) sin16s_gen2::ampl
 (const signed word) sin16s_gen2::ampl#0 ampl = (const signed word) sin16s_gen2::max#0-(const signed word) sin16s_gen2::min#0
 (word) sin16s_gen2::i
-(word) sin16s_gen2::i#1 i zp[2]:15 22.0
-(word) sin16s_gen2::i#2 i zp[2]:15 2.5384615384615383
+(word) sin16s_gen2::i#1 i zp[2]:15 2002.0
+(word) sin16s_gen2::i#2 i zp[2]:15 231.0
 (signed word) sin16s_gen2::max
 (const signed word) sin16s_gen2::max#0 max = (signed word) $1001
 (signed word) sin16s_gen2::min
 (const signed word) sin16s_gen2::min#0 min = (signed word) -$1001
 (signed word) sin16s_gen2::offs
 (signed word*) sin16s_gen2::sintab
-(signed word*) sin16s_gen2::sintab#0 sintab zp[2]:28 7.333333333333333
-(signed word*) sin16s_gen2::sintab#2 sintab zp[2]:28 3.0
+(signed word*) sin16s_gen2::sintab#0 sintab zp[2]:28 667.3333333333334
+(signed word*) sin16s_gen2::sintab#2 sintab zp[2]:28 273.0
 (dword) sin16s_gen2::step
-(dword) sin16s_gen2::step#0 step zp[4]:33 0.8666666666666666
+(dword) sin16s_gen2::step#0 step zp[4]:33 73.46666666666667
 (word) sin16s_gen2::wavelength
 (const word) sin16s_gen2::wavelength#0 wavelength = (word) $200
 (dword) sin16s_gen2::x
-(dword) sin16s_gen2::x#1 x zp[4]:17 11.0
-(dword) sin16s_gen2::x#2 x zp[4]:17 2.75
+(dword) sin16s_gen2::x#1 x zp[4]:17 1001.0
+(dword) sin16s_gen2::x#2 x zp[4]:17 250.25
 
 zp[2]:2 [ main::idx_x#11 main::idx_x#10 main::idx_x#1 ]
 zp[2]:4 [ main::r#10 main::r#1 mul16s::a#3 mul16s::a#1 mul16s::a#2 mul16s::a#0 sin16s::return#1 sin16s::return#5 sin16s::sinx#1 sin16s::usinx#1 sin16s::return#0 sin16s::usinx#0 ]
@@ -399,7 +399,7 @@ zp[1]:27 [ frame_cnt ]
 zp[2]:28 [ main::$7 main::$8 main::x#0 bitmap_plot::x#0 sin16s_gen2::sintab#2 sin16s_gen2::sintab#0 ]
 zp[2]:30 [ main::$13 main::$14 main::y#0 divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#0 memset::num#2 memset::end#0 mul16u::b#2 mul16u::b#0 mul16u::b#1 mulu16_sel::v2#5 mulu16_sel::v2#3 mulu16_sel::v2#4 mulu16_sel::v2#0 mulu16_sel::v2#1 ]
 reg byte x [ bitmap_plot::y#0 ]
-reg byte a [ bitmap_plot::$2 ]
+reg byte x [ bitmap_plot::$2 ]
 reg byte a [ mul16u::$1 ]
 zp[1]:32 [ bitmap_init::$7 ]
 reg byte a [ bitmap_init::$4 ]

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

@@ -339,10 +339,9 @@ bitmap_plot: {
     adc.z __1+1
     sta.z plotter+1
     // <x
-    lda.z x
+    ldx.z x
     // *plotter |= bitmap_plot_bit[<x]
-    tay
-    lda bitmap_plot_bit,y
+    lda bitmap_plot_bit,x
     ldy #0
     ora (plotter),y
     sta (plotter),y

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

@@ -16,19 +16,19 @@
 (const byte) VIC_RSEL = (byte) 8
 (const byte) WHITE = (byte) 1
 (word()) abs_u16((word) abs_u16::w)
-(byte~) abs_u16::$0 reg byte a 4.0
-(byte~) abs_u16::$1 reg byte a 4.0
+(byte~) abs_u16::$0 reg byte a 20002.0
+(byte~) abs_u16::$1 reg byte a 20002.0
 (label) abs_u16::@1
 (label) abs_u16::@return
 (word) abs_u16::return
-(word) abs_u16::return#0 return zp[2]:8 4.0
-(word) abs_u16::return#1 return zp[2]:8 4.0
-(word) abs_u16::return#2 return zp[2]:8 4.0
-(word) abs_u16::return#4 return zp[2]:8 2.0
+(word) abs_u16::return#0 return zp[2]:8 2002.0
+(word) abs_u16::return#1 return zp[2]:8 2002.0
+(word) abs_u16::return#2 return zp[2]:8 20002.0
+(word) abs_u16::return#4 return zp[2]:8 5501.0
 (word) abs_u16::w
-(word) abs_u16::w#0 w zp[2]:8 4.0
-(word) abs_u16::w#1 w zp[2]:8 4.0
-(word) abs_u16::w#2 w zp[2]:8 2.5
+(word) abs_u16::w#0 w zp[2]:8 2002.0
+(word) abs_u16::w#1 w zp[2]:8 2002.0
+(word) abs_u16::w#2 w zp[2]:8 8001.25
 (void()) bitmap_clear((byte) bitmap_clear::bgcol , (byte) bitmap_clear::fgcol)
 (label) bitmap_clear::@1
 (label) bitmap_clear::@return
@@ -38,10 +38,10 @@
 (byte) bitmap_clear::fgcol
 (byte*) bitmap_gfx
 (void()) bitmap_init((byte*) bitmap_init::gfx , (byte*) bitmap_init::screen)
-(byte~) bitmap_init::$4 reg byte a 22.0
-(byte~) bitmap_init::$5 reg byte a 22.0
-(byte~) bitmap_init::$6 reg byte a 22.0
-(byte~) bitmap_init::$7 zp[1]:28 5.5
+(byte~) bitmap_init::$4 reg byte a 2002.0
+(byte~) bitmap_init::$5 reg byte a 2002.0
+(byte~) bitmap_init::$6 reg byte a 2002.0
+(byte~) bitmap_init::$7 zp[1]:28 500.5
 (label) bitmap_init::@1
 (label) bitmap_init::@2
 (label) bitmap_init::@3
@@ -50,21 +50,21 @@
 (label) bitmap_init::@6
 (label) bitmap_init::@return
 (byte) bitmap_init::bits
-(byte) bitmap_init::bits#1 reg byte a 11.0
-(byte) bitmap_init::bits#3 reg byte a 16.5
-(byte) bitmap_init::bits#4 reg byte a 7.333333333333333
+(byte) bitmap_init::bits#1 reg byte a 1001.0
+(byte) bitmap_init::bits#3 reg byte a 1501.5
+(byte) bitmap_init::bits#4 reg byte a 667.3333333333334
 (byte*) bitmap_init::gfx
 (byte*) bitmap_init::screen
 (byte) bitmap_init::x
-(byte) bitmap_init::x#1 reg byte x 16.5
-(byte) bitmap_init::x#2 reg byte x 5.5
+(byte) bitmap_init::x#1 reg byte x 1501.5
+(byte) bitmap_init::x#2 reg byte x 500.5
 (byte) bitmap_init::y
-(byte) bitmap_init::y#1 reg byte x 16.5
-(byte) bitmap_init::y#2 reg byte x 5.5
+(byte) bitmap_init::y#1 reg byte x 1501.5
+(byte) bitmap_init::y#2 reg byte x 500.5
 (byte*) bitmap_init::yoffs
-(byte*) bitmap_init::yoffs#1 yoffs zp[2]:14 22.0
-(byte*) bitmap_init::yoffs#2 yoffs zp[2]:14 6.875
-(byte*) bitmap_init::yoffs#4 yoffs zp[2]:14 11.0
+(byte*) bitmap_init::yoffs#1 yoffs zp[2]:14 2002.0
+(byte*) bitmap_init::yoffs#2 yoffs zp[2]:14 625.625
+(byte*) bitmap_init::yoffs#4 yoffs zp[2]:14 1001.0
 (void()) bitmap_line((word) bitmap_line::x1 , (word) bitmap_line::y1 , (word) bitmap_line::x2 , (word) bitmap_line::y2)
 (label) bitmap_line::@1
 (label) bitmap_line::@10
@@ -86,73 +86,73 @@
 (label) bitmap_line::@9
 (label) bitmap_line::@return
 (word) bitmap_line::dx
-(word) bitmap_line::dx#0 dx zp[2]:20 7.775
+(word) bitmap_line::dx#0 dx zp[2]:20 7600.174999999999
 (word) bitmap_line::dy
-(word) bitmap_line::dy#0 dy zp[2]:8 8.638888888888888
+(word) bitmap_line::dy#0 dy zp[2]:8 8444.638888888889
 (word) bitmap_line::e
-(word) bitmap_line::e#0 e zp[2]:10 4.0
-(word) bitmap_line::e#1 e zp[2]:10 134.66666666666666
-(word) bitmap_line::e#2 e zp[2]:10 202.0
-(word) bitmap_line::e#3 e zp[2]:10 40.8
-(word) bitmap_line::e#6 e zp[2]:10 151.5
+(word) bitmap_line::e#0 e zp[2]:10 2002.0
+(word) bitmap_line::e#1 e zp[2]:10 133334.66666666666
+(word) bitmap_line::e#2 e zp[2]:10 200002.0
+(word) bitmap_line::e#3 e zp[2]:10 40200.600000000006
+(word) bitmap_line::e#6 e zp[2]:10 150001.5
 (word) bitmap_line::e1
-(word) bitmap_line::e1#0 e1 zp[2]:14 4.0
-(word) bitmap_line::e1#1 e1 zp[2]:14 134.66666666666666
-(word) bitmap_line::e1#2 e1 zp[2]:14 202.0
-(word) bitmap_line::e1#3 e1 zp[2]:14 40.8
-(word) bitmap_line::e1#6 e1 zp[2]:14 151.5
+(word) bitmap_line::e1#0 e1 zp[2]:14 2002.0
+(word) bitmap_line::e1#1 e1 zp[2]:14 133334.66666666666
+(word) bitmap_line::e1#2 e1 zp[2]:14 200002.0
+(word) bitmap_line::e1#3 e1 zp[2]:14 40200.600000000006
+(word) bitmap_line::e1#6 e1 zp[2]:14 150001.5
 (word) bitmap_line::sx
-(word) bitmap_line::sx#0 sx zp[2]:22 6.800000000000001
+(word) bitmap_line::sx#0 sx zp[2]:22 6700.1
 (word) bitmap_line::sy
-(word) bitmap_line::sy#0 sy zp[2]:6 7.846153846153847
+(word) bitmap_line::sy#0 sy zp[2]:6 7730.884615384615
 (word) bitmap_line::x
-(word) bitmap_line::x#1 x zp[2]:4 101.0
-(word) bitmap_line::x#12 x zp[2]:4 202.0
-(word) bitmap_line::x#13 x zp[2]:4 58.00000000000001
-(word) bitmap_line::x#15 x zp[2]:4 57.714285714285715
-(word) bitmap_line::x#6 x zp[2]:4 102.0
-(word) bitmap_line::x#7 x zp[2]:4 76.25
+(word) bitmap_line::x#1 x zp[2]:4 100001.0
+(word) bitmap_line::x#12 x zp[2]:4 200002.0
+(word) bitmap_line::x#13 x zp[2]:4 57286.42857142857
+(word) bitmap_line::x#15 x zp[2]:4 57143.42857142857
+(word) bitmap_line::x#6 x zp[2]:4 100501.5
+(word) bitmap_line::x#7 x zp[2]:4 75251.0
 (word) bitmap_line::x1
-(word) bitmap_line::x1#0 x1 zp[2]:4 0.7777777777777778
+(word) bitmap_line::x1#0 x1 zp[2]:4 189.11111111111111
 (word) bitmap_line::x2
-(word) bitmap_line::x2#0 x2 zp[2]:16 3.515151515151515
+(word) bitmap_line::x2#0 x2 zp[2]:16 3094.060606060606
 (word) bitmap_line::y
-(word) bitmap_line::y#1 y zp[2]:12 57.714285714285715
-(word) bitmap_line::y#13 y zp[2]:12 202.0
-(word) bitmap_line::y#15 y zp[2]:12 43.57142857142858
-(word) bitmap_line::y#2 y zp[2]:12 101.0
-(word) bitmap_line::y#4 y zp[2]:12 51.0
-(word) bitmap_line::y#7 y zp[2]:12 202.0
+(word) bitmap_line::y#1 y zp[2]:12 57143.42857142857
+(word) bitmap_line::y#13 y zp[2]:12 200002.0
+(word) bitmap_line::y#15 y zp[2]:12 43000.57142857143
+(word) bitmap_line::y#2 y zp[2]:12 100001.0
+(word) bitmap_line::y#4 y zp[2]:12 50250.75
+(word) bitmap_line::y#7 y zp[2]:12 200002.0
 (word) bitmap_line::y1
-(word) bitmap_line::y1#0 y1 zp[2]:12 0.7599999999999999
+(word) bitmap_line::y1#0 y1 zp[2]:12 164.2
 (word) bitmap_line::y2
-(word) bitmap_line::y2#0 y2 zp[2]:18 3.625
+(word) bitmap_line::y2#0 y2 zp[2]:18 3190.75
 (void()) bitmap_plot((word) bitmap_plot::x , (byte) bitmap_plot::y)
-(word~) bitmap_plot::$1 zp[2]:26 4.0
-(byte~) bitmap_plot::$2 reg byte a 4.0
+(word~) bitmap_plot::$1 zp[2]:26 2000002.0
+(byte~) bitmap_plot::$2 reg byte x 2000002.0
 (label) bitmap_plot::@return
 (byte*) bitmap_plot::plotter
-(word) bitmap_plot::plotter#0 plotter zp[2]:24 1.0
-(byte*) bitmap_plot::plotter#1 plotter zp[2]:24 3.0
+(word) bitmap_plot::plotter#0 plotter zp[2]:24 500000.5
+(byte*) bitmap_plot::plotter#1 plotter zp[2]:24 1500001.5
 (word) bitmap_plot::x
-(word) bitmap_plot::x#0 x zp[2]:4 4.0
-(word) bitmap_plot::x#1 x zp[2]:4 202.0
-(word) bitmap_plot::x#2 x zp[2]:4 4.0
-(word) bitmap_plot::x#3 x zp[2]:4 202.0
-(word) bitmap_plot::x#4 x zp[2]:4 52.5
+(word) bitmap_plot::x#0 x zp[2]:4 2002.0
+(word) bitmap_plot::x#1 x zp[2]:4 200002.0
+(word) bitmap_plot::x#2 x zp[2]:4 2002.0
+(word) bitmap_plot::x#3 x zp[2]:4 200002.0
+(word) bitmap_plot::x#4 x zp[2]:4 550501.5
 (byte) bitmap_plot::y
-(byte) bitmap_plot::y#0 reg byte x 2.0
-(byte) bitmap_plot::y#1 reg byte x 101.0
-(byte) bitmap_plot::y#2 reg byte x 2.0
-(byte) bitmap_plot::y#3 reg byte x 101.0
-(byte) bitmap_plot::y#4 reg byte x 210.0
+(byte) bitmap_plot::y#0 reg byte x 1001.0
+(byte) bitmap_plot::y#1 reg byte x 100001.0
+(byte) bitmap_plot::y#2 reg byte x 1001.0
+(byte) bitmap_plot::y#3 reg byte x 100001.0
+(byte) bitmap_plot::y#4 reg byte x 2202006.0
 (const byte*) bitmap_plot_bit[(number) $100]  = { fill( $100, 0) }
 (const byte*) bitmap_plot_yhi[(number) $100]  = { fill( $100, 0) }
 (const byte*) bitmap_plot_ylo[(number) $100]  = { fill( $100, 0) }
 (byte*) bitmap_screen
 (void()) main()
-(word~) main::$4 zp[2]:4 22.0
-(word~) main::$8 zp[2]:16 22.0
+(word~) main::$4 zp[2]:4 202.0
+(word~) main::$8 zp[2]:16 202.0
 (label) main::@1
 (label) main::@2
 (label) main::@3
@@ -161,11 +161,11 @@
 (label) main::@6
 (label) main::@7
 (byte) main::a
-(byte) main::a#1 a zp[1]:3 11.0
-(byte) main::a#2 a zp[1]:3 2.4444444444444446
+(byte) main::a#1 a zp[1]:3 101.0
+(byte) main::a#2 a zp[1]:3 22.444444444444443
 (byte) main::i
-(byte) main::i#1 i zp[1]:2 22.0
-(byte) main::i#2 i zp[1]:2 3.3000000000000003
+(byte) main::i#1 i zp[1]:2 202.0
+(byte) main::i#2 i zp[1]:2 30.299999999999997
 (label) main::toD0181
 (byte*) main::toD0181_gfx
 (byte) main::toD0181_return
@@ -177,31 +177,31 @@
 (label) memset::@3
 (label) memset::@return
 (byte) memset::c
-(byte) memset::c#4 reg byte x 1.375
+(byte) memset::c#4 reg byte x 1250.125
 (byte*) memset::dst
-(byte*) memset::dst#1 dst zp[2]:12 22.0
-(byte*) memset::dst#2 dst zp[2]:12 15.333333333333332
-(byte*) memset::dst#4 dst zp[2]:12 4.0
+(byte*) memset::dst#1 dst zp[2]:12 20002.0
+(byte*) memset::dst#2 dst zp[2]:12 13668.333333333332
+(byte*) memset::dst#4 dst zp[2]:12 2002.0
 (byte*) memset::end
-(byte*) memset::end#0 end zp[2]:10 2.1666666666666665
+(byte*) memset::end#0 end zp[2]:10 1833.6666666666665
 (word) memset::num
-(word) memset::num#2 num zp[2]:10 2.0
+(word) memset::num#2 num zp[2]:10 1001.0
 (void*) memset::return
 (void*) memset::str
 (void*) memset::str#3 str zp[2]:12
 (word()) sgn_u16((word) sgn_u16::w)
-(byte~) sgn_u16::$0 reg byte a 4.0
-(byte~) sgn_u16::$1 reg byte a 4.0
+(byte~) sgn_u16::$0 reg byte a 20002.0
+(byte~) sgn_u16::$1 reg byte a 20002.0
 (label) sgn_u16::@1
 (label) sgn_u16::@return
 (word) sgn_u16::return
-(word) sgn_u16::return#0 return zp[2]:6 4.0
-(word) sgn_u16::return#1 return zp[2]:6 4.0
-(word) sgn_u16::return#4 return zp[2]:6 1.0
+(word) sgn_u16::return#0 return zp[2]:6 2002.0
+(word) sgn_u16::return#1 return zp[2]:6 2002.0
+(word) sgn_u16::return#4 return zp[2]:6 500.5
 (word) sgn_u16::w
-(word) sgn_u16::w#0 w zp[2]:24 4.0
-(word) sgn_u16::w#1 w zp[2]:24 4.0
-(word) sgn_u16::w#2 w zp[2]:24 6.0
+(word) sgn_u16::w#0 w zp[2]:24 2002.0
+(word) sgn_u16::w#1 w zp[2]:24 2002.0
+(word) sgn_u16::w#2 w zp[2]:24 12003.0
 
 zp[1]:2 [ main::i#2 main::i#1 ]
 zp[1]:3 [ main::a#2 main::a#1 ]
@@ -222,7 +222,7 @@ zp[2]:20 [ bitmap_line::dx#0 ]
 zp[2]:22 [ bitmap_line::sx#0 ]
 zp[2]:24 [ bitmap_plot::plotter#0 bitmap_plot::plotter#1 sgn_u16::w#2 sgn_u16::w#0 sgn_u16::w#1 ]
 zp[2]:26 [ bitmap_plot::$1 ]
-reg byte a [ bitmap_plot::$2 ]
+reg byte x [ bitmap_plot::$2 ]
 reg byte a [ sgn_u16::$0 ]
 reg byte a [ sgn_u16::$1 ]
 reg byte a [ abs_u16::$0 ]

src/test/ref/bitmap-plotter.log

@@ -456,18 +456,18 @@ Inferred type updated to byte in (unumber~) init_plot_tables::$9 ← (byte) init
 Inversing boolean not [57] (bool~) init_plot_tables::$3 ← (byte) init_plot_tables::bits#1 != (byte) 0 from [56] (bool~) init_plot_tables::$2 ← (byte) init_plot_tables::bits#1 == (byte) 0
 Inversing boolean not [76] (bool~) init_plot_tables::$11 ← (byte~) init_plot_tables::$9 != (byte) 7 from [75] (bool~) init_plot_tables::$10 ← (byte~) init_plot_tables::$9 == (byte) 7
 Successful SSA optimization Pass2UnaryNotSimplification
-Alias (byte) plots::i#2 = (byte) plots::i#3 (byte) plots::i#4 
-Alias (byte*) plot::plotter#0 = (byte*~) plot::$4 
-Alias (byte) init_plot_tables::bits#1 = (byte~) init_plot_tables::$1 
-Alias (byte) init_plot_tables::x#2 = (byte) init_plot_tables::x#4 
-Alias (byte*) init_plot_tables::yoffs#2 = (byte*) init_plot_tables::yoffs#3 
-Alias (byte) init_plot_tables::y#2 = (byte) init_plot_tables::y#4 
-Alias (byte*) init_plot_tables::yoffs#1 = (byte*~) init_plot_tables::$12 
-Alias (byte*) init_screen::b#2 = (byte*) init_screen::b#3 
-Alias (byte*) init_screen::c#2 = (byte*) init_screen::c#3 
+Alias plots::i#2 = plots::i#3 plots::i#4 
+Alias plot::plotter#0 = plot::$4 
+Alias init_plot_tables::bits#1 = init_plot_tables::$1 
+Alias init_plot_tables::x#2 = init_plot_tables::x#4 
+Alias init_plot_tables::yoffs#2 = init_plot_tables::yoffs#3 
+Alias init_plot_tables::y#2 = init_plot_tables::y#4 
+Alias init_plot_tables::yoffs#1 = init_plot_tables::$12 
+Alias init_screen::b#2 = init_screen::b#3 
+Alias init_screen::c#2 = init_screen::c#3 
 Successful SSA optimization Pass2AliasElimination
-Alias (byte) init_plot_tables::x#2 = (byte) init_plot_tables::x#3 
-Alias (byte) init_plot_tables::y#2 = (byte) init_plot_tables::y#3 
+Alias init_plot_tables::x#2 = init_plot_tables::x#3 
+Alias init_plot_tables::y#2 = init_plot_tables::y#3 
 Successful SSA optimization Pass2AliasElimination
 Identical Phi Values (byte) plot::x#1 (byte) plot::x#0
 Identical Phi Values (byte) plot::y#1 (byte) plot::y#0
@@ -518,7 +518,7 @@ Successful SSA optimization PassNCastSimplification
 Finalized unsigned number type (byte) 0
 Finalized unsigned number type (byte) 0
 Successful SSA optimization PassNFinalizeNumberTypeConversions
-Alias (byte~) init_plot_tables::$9 = (byte~) init_plot_tables::$5 
+Alias init_plot_tables::$9 = init_plot_tables::$5 
 Successful SSA optimization Pass2AliasElimination
 Constant right-side identified [2] (byte~) main::$1 ← (const byte) main::$0 | (const byte) RSEL
 Constant right-side identified [5] (word~) main::$4 ← (const word) main::$3 / (byte) $40
@@ -771,55 +771,55 @@ init_screen::@2: scope:[init_screen]  from init_screen::@1
 
 VARIABLE REGISTER WEIGHTS
 (void()) init_plot_tables()
-(byte~) init_plot_tables::$0 22.0
-(byte~) init_plot_tables::$6 22.0
-(byte~) init_plot_tables::$7 22.0
-(byte~) init_plot_tables::$8 22.0
-(byte~) init_plot_tables::$9 5.5
+(byte~) init_plot_tables::$0 2002.0
+(byte~) init_plot_tables::$6 2002.0
+(byte~) init_plot_tables::$7 2002.0
+(byte~) init_plot_tables::$8 2002.0
+(byte~) init_plot_tables::$9 500.5
 (byte) init_plot_tables::bits
-(byte) init_plot_tables::bits#1 11.0
-(byte) init_plot_tables::bits#3 6.6000000000000005
-(byte) init_plot_tables::bits#4 7.333333333333333
+(byte) init_plot_tables::bits#1 1001.0
+(byte) init_plot_tables::bits#3 600.5999999999999
+(byte) init_plot_tables::bits#4 667.3333333333334
 (byte) init_plot_tables::x
-(byte) init_plot_tables::x#1 16.5
-(byte) init_plot_tables::x#2 7.333333333333334
+(byte) init_plot_tables::x#1 1501.5
+(byte) init_plot_tables::x#2 667.3333333333333
 (byte) init_plot_tables::y
-(byte) init_plot_tables::y#1 16.5
-(byte) init_plot_tables::y#2 5.5
+(byte) init_plot_tables::y#1 1501.5
+(byte) init_plot_tables::y#2 500.5
 (byte*) init_plot_tables::yoffs
-(byte*) init_plot_tables::yoffs#1 22.0
-(byte*) init_plot_tables::yoffs#2 6.875
-(byte*) init_plot_tables::yoffs#4 11.0
+(byte*) init_plot_tables::yoffs#1 2002.0
+(byte*) init_plot_tables::yoffs#2 625.625
+(byte*) init_plot_tables::yoffs#4 1001.0
 (void()) init_screen()
 (byte*) init_screen::b
-(byte*) init_screen::b#1 22.0
-(byte*) init_screen::b#2 14.666666666666666
+(byte*) init_screen::b#1 2002.0
+(byte*) init_screen::b#2 1334.6666666666667
 (byte*) init_screen::c
-(byte*) init_screen::c#1 22.0
-(byte*) init_screen::c#2 14.666666666666666
+(byte*) init_screen::c#1 2002.0
+(byte*) init_screen::c#2 1334.6666666666667
 (void()) main()
 (void()) plot((byte) plot::x , (byte) plot::y)
-(byte~) plot::$5 4.0
-(byte~) plot::$6 4.0
-(byte~) plot::$7 4.0
-(byte~) plot::$8 4.0
-(byte~) plot::$9 4.0
+(byte~) plot::$5 2000002.0
+(byte~) plot::$6 2000002.0
+(byte~) plot::$7 2000002.0
+(byte~) plot::$8 2000002.0
+(byte~) plot::$9 2000002.0
 (byte*) plot::plotter
-(byte*) plot::plotter#0 3.0
+(byte*) plot::plotter#0 1500001.5
 (byte*) plot::plotter_x
-(byte*) plot::plotter_x#1 2.0
-(byte*) plot::plotter_x#2 0.8
+(byte*) plot::plotter_x#1 1000001.0
+(byte*) plot::plotter_x#2 400000.4
 (word) plot::plotter_y
-(word) plot::plotter_y#1 2.0
-(word) plot::plotter_y#2 4.0
+(word) plot::plotter_y#1 1000001.0
+(word) plot::plotter_y#2 2000002.0
 (byte) plot::x
-(byte) plot::x#0 9.727272727272727
+(byte) plot::x#0 281818.54545454547
 (byte) plot::y
-(byte) plot::y#0 15.000000000000002
+(byte) plot::y#0 300000.4285714285
 (void()) plots()
 (byte) plots::i
-(byte) plots::i#1 202.0
-(byte) plots::i#2 101.0
+(byte) plots::i#1 200002.0
+(byte) plots::i#2 100001.0
 
 Initial phi equivalence classes
 [ plots::i#2 plots::i#1 ]
@@ -1327,49 +1327,49 @@ init_screen: {
 
 REGISTER UPLIFT POTENTIAL REGISTERS
 Equivalence Class zp[1]:31 [ init_plot_tables::$6 ] has ALU potential.
-Statement [4] *((const byte*) BGCOL) ← (byte) 0 [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [5] *((const byte*) FGCOL) ← (byte) 0 [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [6] *((const byte*) D011) ← (const byte) BMM|(const byte) DEN|(const byte) RSEL|(byte) 3 [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [7] *((const byte*) D018) ← (byte)(word)(const byte*) SCREEN/(byte) $40|(word)(const byte*) BITMAP/(word) $400 [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [11] if(*((const byte*) RASTER)!=(byte) $ff) goto main::@1 [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [26] (byte*) plot::plotter_x#2 ← (byte*) plot::plotter_x#1 lo= (byte~) plot::$7 [ plot::x#0 plot::y#0 plot::plotter_x#2 ] ( main:2::plots:13::plot:21 [ plots::i#2 plot::x#0 plot::y#0 plot::plotter_x#2 ] ) always clobbers reg byte a 
+Statement [4] *((const byte*) BGCOL) ← (byte) 0 [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [5] *((const byte*) FGCOL) ← (byte) 0 [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [6] *((const byte*) D011) ← (const byte) BMM|(const byte) DEN|(const byte) RSEL|(byte) 3 [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [7] *((const byte*) D018) ← (byte)(word)(const byte*) SCREEN/(byte) $40|(word)(const byte*) BITMAP/(word) $400 [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [11] if(*((const byte*) RASTER)!=(byte) $ff) goto main::@1 [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [26] (byte*) plot::plotter_x#2 ← (byte*) plot::plotter_x#1 lo= (byte~) plot::$7 [ plot::x#0 plot::y#0 plot::plotter_x#2 ] ( main:2::plots:13::plot:21 [ plots::i#2 plot::x#0 plot::y#0 plot::plotter_x#2 ] { }  ) always clobbers reg byte a 
 Removing always clobbered register reg byte a as potential for zp[1]:2 [ plots::i#2 plots::i#1 ]
 Removing always clobbered register reg byte a as potential for zp[1]:12 [ plot::x#0 ]
 Removing always clobbered register reg byte a as potential for zp[1]:13 [ plot::y#0 ]
-Statement [30] (word) plot::plotter_y#2 ← (word) plot::plotter_y#1 lo= (byte~) plot::$9 [ plot::x#0 plot::plotter_x#2 plot::plotter_y#2 ] ( main:2::plots:13::plot:21 [ plots::i#2 plot::x#0 plot::plotter_x#2 plot::plotter_y#2 ] ) always clobbers reg byte a 
-Statement [31] (byte*) plot::plotter#0 ← (byte*) plot::plotter_x#2 + (word) plot::plotter_y#2 [ plot::x#0 plot::plotter#0 ] ( main:2::plots:13::plot:21 [ plots::i#2 plot::x#0 plot::plotter#0 ] ) always clobbers reg byte a 
-Statement [32] (byte~) plot::$5 ← *((byte*) plot::plotter#0) | *((const byte*) plot_bit + (byte) plot::x#0) [ plot::plotter#0 plot::$5 ] ( main:2::plots:13::plot:21 [ plots::i#2 plot::plotter#0 plot::$5 ] ) always clobbers reg byte a reg byte y 
+Statement [30] (word) plot::plotter_y#2 ← (word) plot::plotter_y#1 lo= (byte~) plot::$9 [ plot::x#0 plot::plotter_x#2 plot::plotter_y#2 ] ( main:2::plots:13::plot:21 [ plots::i#2 plot::x#0 plot::plotter_x#2 plot::plotter_y#2 ] { }  ) always clobbers reg byte a 
+Statement [31] (byte*) plot::plotter#0 ← (byte*) plot::plotter_x#2 + (word) plot::plotter_y#2 [ plot::x#0 plot::plotter#0 ] ( main:2::plots:13::plot:21 [ plots::i#2 plot::x#0 plot::plotter#0 ] { }  ) always clobbers reg byte a 
+Statement [32] (byte~) plot::$5 ← *((byte*) plot::plotter#0) | *((const byte*) plot_bit + (byte) plot::x#0) [ plot::plotter#0 plot::$5 ] ( main:2::plots:13::plot:21 [ plots::i#2 plot::plotter#0 plot::$5 ] { }  ) always clobbers reg byte a reg byte y 
 Removing always clobbered register reg byte y as potential for zp[1]:2 [ plots::i#2 plots::i#1 ]
-Statement [33] *((byte*) plot::plotter#0) ← (byte~) plot::$5 [ ] ( main:2::plots:13::plot:21 [ plots::i#2 ] ) always clobbers reg byte y 
-Statement [39] *((const byte*) plot_xhi + (byte) init_plot_tables::x#2) ← >(const byte*) BITMAP [ init_plot_tables::x#2 init_plot_tables::bits#3 ] ( main:2::init_plot_tables:10 [ init_plot_tables::x#2 init_plot_tables::bits#3 ] ) always clobbers reg byte a 
+Statement [33] *((byte*) plot::plotter#0) ← (byte~) plot::$5 [ ] ( main:2::plots:13::plot:21 [ plots::i#2 ] { }  ) always clobbers reg byte y 
+Statement [39] *((const byte*) plot_xhi + (byte) init_plot_tables::x#2) ← >(const byte*) BITMAP [ init_plot_tables::x#2 init_plot_tables::bits#3 ] ( main:2::init_plot_tables:10 [ init_plot_tables::x#2 init_plot_tables::bits#3 ] { }  ) always clobbers reg byte a 
 Removing always clobbered register reg byte a as potential for zp[1]:3 [ init_plot_tables::x#2 init_plot_tables::x#1 ]
 Removing always clobbered register reg byte a as potential for zp[1]:4 [ init_plot_tables::bits#3 init_plot_tables::bits#4 init_plot_tables::bits#1 ]
-Statement [40] *((const byte*) plot_bit + (byte) init_plot_tables::x#2) ← (byte) init_plot_tables::bits#3 [ init_plot_tables::x#2 init_plot_tables::bits#3 ] ( main:2::init_plot_tables:10 [ init_plot_tables::x#2 init_plot_tables::bits#3 ] ) always clobbers reg byte a 
-Statement [55] (byte*) init_plot_tables::yoffs#1 ← (byte*) init_plot_tables::yoffs#2 + (word)(number) $28*(number) 8 [ init_plot_tables::y#2 init_plot_tables::yoffs#1 ] ( main:2::init_plot_tables:10 [ init_plot_tables::y#2 init_plot_tables::yoffs#1 ] ) always clobbers reg byte a 
+Statement [40] *((const byte*) plot_bit + (byte) init_plot_tables::x#2) ← (byte) init_plot_tables::bits#3 [ init_plot_tables::x#2 init_plot_tables::bits#3 ] ( main:2::init_plot_tables:10 [ init_plot_tables::x#2 init_plot_tables::bits#3 ] { }  ) always clobbers reg byte a 
+Statement [55] (byte*) init_plot_tables::yoffs#1 ← (byte*) init_plot_tables::yoffs#2 + (word)(number) $28*(number) 8 [ init_plot_tables::y#2 init_plot_tables::yoffs#1 ] ( main:2::init_plot_tables:10 [ init_plot_tables::y#2 init_plot_tables::yoffs#1 ] { }  ) always clobbers reg byte a 
 Removing always clobbered register reg byte a as potential for zp[1]:5 [ init_plot_tables::y#2 init_plot_tables::y#1 ]
-Statement [62] if((byte*) init_screen::b#2!=(const byte*) BITMAP+(word) $2000) goto init_screen::@2 [ init_screen::b#2 ] ( main:2::init_screen:8 [ init_screen::b#2 ] ) always clobbers reg byte a 
-Statement [64] if((byte*) init_screen::c#2!=(const byte*) SCREEN+(word) $400) goto init_screen::@4 [ init_screen::c#2 ] ( main:2::init_screen:8 [ init_screen::c#2 ] ) always clobbers reg byte a 
-Statement [66] *((byte*) init_screen::c#2) ← (byte) $14 [ init_screen::c#2 ] ( main:2::init_screen:8 [ init_screen::c#2 ] ) always clobbers reg byte a reg byte y 
-Statement [68] *((byte*) init_screen::b#2) ← (byte) 0 [ init_screen::b#2 ] ( main:2::init_screen:8 [ init_screen::b#2 ] ) always clobbers reg byte a reg byte y 
-Statement [4] *((const byte*) BGCOL) ← (byte) 0 [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [5] *((const byte*) FGCOL) ← (byte) 0 [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [6] *((const byte*) D011) ← (const byte) BMM|(const byte) DEN|(const byte) RSEL|(byte) 3 [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [7] *((const byte*) D018) ← (byte)(word)(const byte*) SCREEN/(byte) $40|(word)(const byte*) BITMAP/(word) $400 [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [11] if(*((const byte*) RASTER)!=(byte) $ff) goto main::@1 [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [26] (byte*) plot::plotter_x#2 ← (byte*) plot::plotter_x#1 lo= (byte~) plot::$7 [ plot::x#0 plot::y#0 plot::plotter_x#2 ] ( main:2::plots:13::plot:21 [ plots::i#2 plot::x#0 plot::y#0 plot::plotter_x#2 ] ) always clobbers reg byte a 
-Statement [30] (word) plot::plotter_y#2 ← (word) plot::plotter_y#1 lo= (byte~) plot::$9 [ plot::x#0 plot::plotter_x#2 plot::plotter_y#2 ] ( main:2::plots:13::plot:21 [ plots::i#2 plot::x#0 plot::plotter_x#2 plot::plotter_y#2 ] ) always clobbers reg byte a 
-Statement [31] (byte*) plot::plotter#0 ← (byte*) plot::plotter_x#2 + (word) plot::plotter_y#2 [ plot::x#0 plot::plotter#0 ] ( main:2::plots:13::plot:21 [ plots::i#2 plot::x#0 plot::plotter#0 ] ) always clobbers reg byte a 
-Statement [32] (byte~) plot::$5 ← *((byte*) plot::plotter#0) | *((const byte*) plot_bit + (byte) plot::x#0) [ plot::plotter#0 plot::$5 ] ( main:2::plots:13::plot:21 [ plots::i#2 plot::plotter#0 plot::$5 ] ) always clobbers reg byte a reg byte y 
-Statement [33] *((byte*) plot::plotter#0) ← (byte~) plot::$5 [ ] ( main:2::plots:13::plot:21 [ plots::i#2 ] ) always clobbers reg byte y 
-Statement [37] (byte~) init_plot_tables::$0 ← (byte) init_plot_tables::x#2 & (byte) $f8 [ init_plot_tables::x#2 init_plot_tables::bits#3 init_plot_tables::$0 ] ( main:2::init_plot_tables:10 [ init_plot_tables::x#2 init_plot_tables::bits#3 init_plot_tables::$0 ] ) always clobbers reg byte a 
-Statement [39] *((const byte*) plot_xhi + (byte) init_plot_tables::x#2) ← >(const byte*) BITMAP [ init_plot_tables::x#2 init_plot_tables::bits#3 ] ( main:2::init_plot_tables:10 [ init_plot_tables::x#2 init_plot_tables::bits#3 ] ) always clobbers reg byte a 
-Statement [40] *((const byte*) plot_bit + (byte) init_plot_tables::x#2) ← (byte) init_plot_tables::bits#3 [ init_plot_tables::x#2 init_plot_tables::bits#3 ] ( main:2::init_plot_tables:10 [ init_plot_tables::x#2 init_plot_tables::bits#3 ] ) always clobbers reg byte a 
-Statement [48] (byte~) init_plot_tables::$9 ← (byte) init_plot_tables::y#2 & (byte) 7 [ init_plot_tables::y#2 init_plot_tables::yoffs#2 init_plot_tables::$9 ] ( main:2::init_plot_tables:10 [ init_plot_tables::y#2 init_plot_tables::yoffs#2 init_plot_tables::$9 ] ) always clobbers reg byte a 
-Statement [55] (byte*) init_plot_tables::yoffs#1 ← (byte*) init_plot_tables::yoffs#2 + (word)(number) $28*(number) 8 [ init_plot_tables::y#2 init_plot_tables::yoffs#1 ] ( main:2::init_plot_tables:10 [ init_plot_tables::y#2 init_plot_tables::yoffs#1 ] ) always clobbers reg byte a 
-Statement [62] if((byte*) init_screen::b#2!=(const byte*) BITMAP+(word) $2000) goto init_screen::@2 [ init_screen::b#2 ] ( main:2::init_screen:8 [ init_screen::b#2 ] ) always clobbers reg byte a 
-Statement [64] if((byte*) init_screen::c#2!=(const byte*) SCREEN+(word) $400) goto init_screen::@4 [ init_screen::c#2 ] ( main:2::init_screen:8 [ init_screen::c#2 ] ) always clobbers reg byte a 
-Statement [66] *((byte*) init_screen::c#2) ← (byte) $14 [ init_screen::c#2 ] ( main:2::init_screen:8 [ init_screen::c#2 ] ) always clobbers reg byte a reg byte y 
-Statement [68] *((byte*) init_screen::b#2) ← (byte) 0 [ init_screen::b#2 ] ( main:2::init_screen:8 [ init_screen::b#2 ] ) always clobbers reg byte a reg byte y 
+Statement [62] if((byte*) init_screen::b#2!=(const byte*) BITMAP+(word) $2000) goto init_screen::@2 [ init_screen::b#2 ] ( main:2::init_screen:8 [ init_screen::b#2 ] { }  ) always clobbers reg byte a 
+Statement [64] if((byte*) init_screen::c#2!=(const byte*) SCREEN+(word) $400) goto init_screen::@4 [ init_screen::c#2 ] ( main:2::init_screen:8 [ init_screen::c#2 ] { }  ) always clobbers reg byte a 
+Statement [66] *((byte*) init_screen::c#2) ← (byte) $14 [ init_screen::c#2 ] ( main:2::init_screen:8 [ init_screen::c#2 ] { }  ) always clobbers reg byte a reg byte y 
+Statement [68] *((byte*) init_screen::b#2) ← (byte) 0 [ init_screen::b#2 ] ( main:2::init_screen:8 [ init_screen::b#2 ] { }  ) always clobbers reg byte a reg byte y 
+Statement [4] *((const byte*) BGCOL) ← (byte) 0 [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [5] *((const byte*) FGCOL) ← (byte) 0 [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [6] *((const byte*) D011) ← (const byte) BMM|(const byte) DEN|(const byte) RSEL|(byte) 3 [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [7] *((const byte*) D018) ← (byte)(word)(const byte*) SCREEN/(byte) $40|(word)(const byte*) BITMAP/(word) $400 [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [11] if(*((const byte*) RASTER)!=(byte) $ff) goto main::@1 [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [26] (byte*) plot::plotter_x#2 ← (byte*) plot::plotter_x#1 lo= (byte~) plot::$7 [ plot::x#0 plot::y#0 plot::plotter_x#2 ] ( main:2::plots:13::plot:21 [ plots::i#2 plot::x#0 plot::y#0 plot::plotter_x#2 ] { }  ) always clobbers reg byte a 
+Statement [30] (word) plot::plotter_y#2 ← (word) plot::plotter_y#1 lo= (byte~) plot::$9 [ plot::x#0 plot::plotter_x#2 plot::plotter_y#2 ] ( main:2::plots:13::plot:21 [ plots::i#2 plot::x#0 plot::plotter_x#2 plot::plotter_y#2 ] { }  ) always clobbers reg byte a 
+Statement [31] (byte*) plot::plotter#0 ← (byte*) plot::plotter_x#2 + (word) plot::plotter_y#2 [ plot::x#0 plot::plotter#0 ] ( main:2::plots:13::plot:21 [ plots::i#2 plot::x#0 plot::plotter#0 ] { }  ) always clobbers reg byte a 
+Statement [32] (byte~) plot::$5 ← *((byte*) plot::plotter#0) | *((const byte*) plot_bit + (byte) plot::x#0) [ plot::plotter#0 plot::$5 ] ( main:2::plots:13::plot:21 [ plots::i#2 plot::plotter#0 plot::$5 ] { }  ) always clobbers reg byte a reg byte y 
+Statement [33] *((byte*) plot::plotter#0) ← (byte~) plot::$5 [ ] ( main:2::plots:13::plot:21 [ plots::i#2 ] { }  ) always clobbers reg byte y 
+Statement [37] (byte~) init_plot_tables::$0 ← (byte) init_plot_tables::x#2 & (byte) $f8 [ init_plot_tables::x#2 init_plot_tables::bits#3 init_plot_tables::$0 ] ( main:2::init_plot_tables:10 [ init_plot_tables::x#2 init_plot_tables::bits#3 init_plot_tables::$0 ] { }  ) always clobbers reg byte a 
+Statement [39] *((const byte*) plot_xhi + (byte) init_plot_tables::x#2) ← >(const byte*) BITMAP [ init_plot_tables::x#2 init_plot_tables::bits#3 ] ( main:2::init_plot_tables:10 [ init_plot_tables::x#2 init_plot_tables::bits#3 ] { }  ) always clobbers reg byte a 
+Statement [40] *((const byte*) plot_bit + (byte) init_plot_tables::x#2) ← (byte) init_plot_tables::bits#3 [ init_plot_tables::x#2 init_plot_tables::bits#3 ] ( main:2::init_plot_tables:10 [ init_plot_tables::x#2 init_plot_tables::bits#3 ] { }  ) always clobbers reg byte a 
+Statement [48] (byte~) init_plot_tables::$9 ← (byte) init_plot_tables::y#2 & (byte) 7 [ init_plot_tables::y#2 init_plot_tables::yoffs#2 init_plot_tables::$9 ] ( main:2::init_plot_tables:10 [ init_plot_tables::y#2 init_plot_tables::yoffs#2 init_plot_tables::$9 ] { }  ) always clobbers reg byte a 
+Statement [55] (byte*) init_plot_tables::yoffs#1 ← (byte*) init_plot_tables::yoffs#2 + (word)(number) $28*(number) 8 [ init_plot_tables::y#2 init_plot_tables::yoffs#1 ] ( main:2::init_plot_tables:10 [ init_plot_tables::y#2 init_plot_tables::yoffs#1 ] { }  ) always clobbers reg byte a 
+Statement [62] if((byte*) init_screen::b#2!=(const byte*) BITMAP+(word) $2000) goto init_screen::@2 [ init_screen::b#2 ] ( main:2::init_screen:8 [ init_screen::b#2 ] { }  ) always clobbers reg byte a 
+Statement [64] if((byte*) init_screen::c#2!=(const byte*) SCREEN+(word) $400) goto init_screen::@4 [ init_screen::c#2 ] ( main:2::init_screen:8 [ init_screen::c#2 ] { }  ) always clobbers reg byte a 
+Statement [66] *((byte*) init_screen::c#2) ← (byte) $14 [ init_screen::c#2 ] ( main:2::init_screen:8 [ init_screen::c#2 ] { }  ) always clobbers reg byte a reg byte y 
+Statement [68] *((byte*) init_screen::b#2) ← (byte) 0 [ init_screen::b#2 ] ( main:2::init_screen:8 [ init_screen::b#2 ] { }  ) always clobbers reg byte a reg byte y 
 Potential registers zp[1]:2 [ plots::i#2 plots::i#1 ] : zp[1]:2 , reg byte x , 
 Potential registers zp[1]:3 [ init_plot_tables::x#2 init_plot_tables::x#1 ] : zp[1]:3 , reg byte x , reg byte y , 
 Potential registers zp[1]:4 [ init_plot_tables::bits#3 init_plot_tables::bits#4 init_plot_tables::bits#1 ] : zp[1]:4 , reg byte x , reg byte y , 
@@ -1396,39 +1396,35 @@ Potential registers zp[1]:32 [ init_plot_tables::$7 ] : zp[1]:32 , reg byte a ,
 Potential registers zp[1]:33 [ init_plot_tables::$8 ] : zp[1]:33 , reg byte a , reg byte x , reg byte y , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [plots] 303: zp[1]:2 [ plots::i#2 plots::i#1 ] 
-Uplift Scope [init_plot_tables] 39.88: zp[2]:6 [ init_plot_tables::yoffs#2 init_plot_tables::yoffs#4 init_plot_tables::yoffs#1 ] 24.93: zp[1]:4 [ init_plot_tables::bits#3 init_plot_tables::bits#4 init_plot_tables::bits#1 ] 23.83: zp[1]:3 [ init_plot_tables::x#2 init_plot_tables::x#1 ] 22: zp[1]:5 [ init_plot_tables::y#2 init_plot_tables::y#1 ] 22: zp[1]:29 [ init_plot_tables::$0 ] 22: zp[1]:31 [ init_plot_tables::$6 ] 22: zp[1]:32 [ init_plot_tables::$7 ] 22: zp[1]:33 [ init_plot_tables::$8 ] 5.5: zp[1]:30 [ init_plot_tables::$9 ] 
-Uplift Scope [init_screen] 36.67: zp[2]:8 [ init_screen::b#2 init_screen::b#1 ] 36.67: zp[2]:10 [ init_screen::c#2 init_screen::c#1 ] 
-Uplift Scope [plot] 15: zp[1]:13 [ plot::y#0 ] 9.73: zp[1]:12 [ plot::x#0 ] 4: zp[1]:14 [ plot::$6 ] 4: zp[1]:17 [ plot::$7 ] 4: zp[1]:20 [ plot::$8 ] 4: zp[1]:23 [ plot::$9 ] 4: zp[2]:24 [ plot::plotter_y#2 ] 4: zp[1]:28 [ plot::$5 ] 3: zp[2]:26 [ plot::plotter#0 ] 2: zp[2]:15 [ plot::plotter_x#1 ] 2: zp[2]:21 [ plot::plotter_y#1 ] 0.8: zp[2]:18 [ plot::plotter_x#2 ] 
+Uplift Scope [plot] 2,000,002: zp[1]:14 [ plot::$6 ] 2,000,002: zp[1]:17 [ plot::$7 ] 2,000,002: zp[1]:20 [ plot::$8 ] 2,000,002: zp[1]:23 [ plot::$9 ] 2,000,002: zp[2]:24 [ plot::plotter_y#2 ] 2,000,002: zp[1]:28 [ plot::$5 ] 1,500,001.5: zp[2]:26 [ plot::plotter#0 ] 1,000,001: zp[2]:15 [ plot::plotter_x#1 ] 1,000,001: zp[2]:21 [ plot::plotter_y#1 ] 400,000.4: zp[2]:18 [ plot::plotter_x#2 ] 300,000.43: zp[1]:13 [ plot::y#0 ] 281,818.55: zp[1]:12 [ plot::x#0 ] 
+Uplift Scope [plots] 300,003: zp[1]:2 [ plots::i#2 plots::i#1 ] 
+Uplift Scope [init_plot_tables] 3,628.62: zp[2]:6 [ init_plot_tables::yoffs#2 init_plot_tables::yoffs#4 init_plot_tables::yoffs#1 ] 2,268.93: zp[1]:4 [ init_plot_tables::bits#3 init_plot_tables::bits#4 init_plot_tables::bits#1 ] 2,168.83: zp[1]:3 [ init_plot_tables::x#2 init_plot_tables::x#1 ] 2,002: zp[1]:5 [ init_plot_tables::y#2 init_plot_tables::y#1 ] 2,002: zp[1]:29 [ init_plot_tables::$0 ] 2,002: zp[1]:31 [ init_plot_tables::$6 ] 2,002: zp[1]:32 [ init_plot_tables::$7 ] 2,002: zp[1]:33 [ init_plot_tables::$8 ] 500.5: zp[1]:30 [ init_plot_tables::$9 ] 
+Uplift Scope [init_screen] 3,336.67: zp[2]:8 [ init_screen::b#2 init_screen::b#1 ] 3,336.67: zp[2]:10 [ init_screen::c#2 init_screen::c#1 ] 
 Uplift Scope [main] 
 Uplift Scope [] 
 
-Uplifting [plots] best 8915 combination reg byte x [ plots::i#2 plots::i#1 ] 
-Uplifting [init_plot_tables] best 8395 combination zp[2]:6 [ init_plot_tables::yoffs#2 init_plot_tables::yoffs#4 init_plot_tables::yoffs#1 ] reg byte y [ init_plot_tables::bits#3 init_plot_tables::bits#4 init_plot_tables::bits#1 ] reg byte x [ init_plot_tables::x#2 init_plot_tables::x#1 ] reg byte x [ init_plot_tables::y#2 init_plot_tables::y#1 ] reg byte a [ init_plot_tables::$0 ] zp[1]:31 [ init_plot_tables::$6 ] zp[1]:32 [ init_plot_tables::$7 ] zp[1]:33 [ init_plot_tables::$8 ] zp[1]:30 [ init_plot_tables::$9 ] 
-Limited combination testing to 100 combinations of 34560 possible.
-Uplifting [init_screen] best 8395 combination zp[2]:8 [ init_screen::b#2 init_screen::b#1 ] zp[2]:10 [ init_screen::c#2 init_screen::c#1 ] 
-Uplifting [plot] best 8383 combination zp[1]:13 [ plot::y#0 ] zp[1]:12 [ plot::x#0 ] reg byte a [ plot::$6 ] reg byte a [ plot::$7 ] zp[1]:20 [ plot::$8 ] zp[1]:23 [ plot::$9 ] zp[2]:24 [ plot::plotter_y#2 ] zp[1]:28 [ plot::$5 ] zp[2]:26 [ plot::plotter#0 ] zp[2]:15 [ plot::plotter_x#1 ] zp[2]:21 [ plot::plotter_y#1 ] zp[2]:18 [ plot::plotter_x#2 ] 
+Uplifting [plot] best 10391 combination reg byte a [ plot::$6 ] reg byte a [ plot::$7 ] reg byte a [ plot::$8 ] reg byte a [ plot::$9 ] zp[2]:24 [ plot::plotter_y#2 ] zp[1]:28 [ plot::$5 ] zp[2]:26 [ plot::plotter#0 ] zp[2]:15 [ plot::plotter_x#1 ] zp[2]:21 [ plot::plotter_y#1 ] zp[2]:18 [ plot::plotter_x#2 ] zp[1]:13 [ plot::y#0 ] zp[1]:12 [ plot::x#0 ] 
 Limited combination testing to 100 combinations of 9216 possible.
-Uplifting [main] best 8383 combination 
-Uplifting [] best 8383 combination 
-Attempting to uplift remaining variables inzp[1]:31 [ init_plot_tables::$6 ]
-Uplifting [init_plot_tables] best 8323 combination reg byte a [ init_plot_tables::$6 ] 
-Attempting to uplift remaining variables inzp[1]:32 [ init_plot_tables::$7 ]
-Uplifting [init_plot_tables] best 8263 combination reg byte a [ init_plot_tables::$7 ] 
-Attempting to uplift remaining variables inzp[1]:33 [ init_plot_tables::$8 ]
-Uplifting [init_plot_tables] best 8203 combination reg byte a [ init_plot_tables::$8 ] 
-Attempting to uplift remaining variables inzp[1]:13 [ plot::y#0 ]
-Uplifting [plot] best 8203 combination zp[1]:13 [ plot::y#0 ] 
-Attempting to uplift remaining variables inzp[1]:12 [ plot::x#0 ]
-Uplifting [plot] best 8203 combination zp[1]:12 [ plot::x#0 ] 
-Attempting to uplift remaining variables inzp[1]:30 [ init_plot_tables::$9 ]
-Uplifting [init_plot_tables] best 8203 combination zp[1]:30 [ init_plot_tables::$9 ] 
-Attempting to uplift remaining variables inzp[1]:20 [ plot::$8 ]
-Uplifting [plot] best 8197 combination reg byte a [ plot::$8 ] 
-Attempting to uplift remaining variables inzp[1]:23 [ plot::$9 ]
-Uplifting [plot] best 8191 combination reg byte a [ plot::$9 ] 
+Uplifting [plots] best 8891 combination reg byte x [ plots::i#2 plots::i#1 ] 
+Uplifting [init_plot_tables] best 8371 combination zp[2]:6 [ init_plot_tables::yoffs#2 init_plot_tables::yoffs#4 init_plot_tables::yoffs#1 ] reg byte y [ init_plot_tables::bits#3 init_plot_tables::bits#4 init_plot_tables::bits#1 ] reg byte x [ init_plot_tables::x#2 init_plot_tables::x#1 ] reg byte x [ init_plot_tables::y#2 init_plot_tables::y#1 ] reg byte a [ init_plot_tables::$0 ] zp[1]:31 [ init_plot_tables::$6 ] zp[1]:32 [ init_plot_tables::$7 ] zp[1]:33 [ init_plot_tables::$8 ] zp[1]:30 [ init_plot_tables::$9 ] 
+Limited combination testing to 100 combinations of 34560 possible.
+Uplifting [init_screen] best 8371 combination zp[2]:8 [ init_screen::b#2 init_screen::b#1 ] zp[2]:10 [ init_screen::c#2 init_screen::c#1 ] 
+Uplifting [main] best 8371 combination 
+Uplifting [] best 8371 combination 
 Attempting to uplift remaining variables inzp[1]:28 [ plot::$5 ]
-Uplifting [plot] best 8185 combination reg byte a [ plot::$5 ] 
+Uplifting [plot] best 8365 combination reg byte a [ plot::$5 ] 
+Attempting to uplift remaining variables inzp[1]:13 [ plot::y#0 ]
+Uplifting [plot] best 8365 combination zp[1]:13 [ plot::y#0 ] 
+Attempting to uplift remaining variables inzp[1]:12 [ plot::x#0 ]
+Uplifting [plot] best 8365 combination zp[1]:12 [ plot::x#0 ] 
+Attempting to uplift remaining variables inzp[1]:31 [ init_plot_tables::$6 ]
+Uplifting [init_plot_tables] best 8305 combination reg byte a [ init_plot_tables::$6 ] 
+Attempting to uplift remaining variables inzp[1]:32 [ init_plot_tables::$7 ]
+Uplifting [init_plot_tables] best 8245 combination reg byte a [ init_plot_tables::$7 ] 
+Attempting to uplift remaining variables inzp[1]:33 [ init_plot_tables::$8 ]
+Uplifting [init_plot_tables] best 8185 combination reg byte a [ init_plot_tables::$8 ] 
+Attempting to uplift remaining variables inzp[1]:30 [ init_plot_tables::$9 ]
+Uplifting [init_plot_tables] best 8185 combination zp[1]:30 [ init_plot_tables::$9 ] 
 Coalescing zero page register [ zp[2]:15 [ plot::plotter_x#1 ] ] with [ zp[2]:18 [ plot::plotter_x#2 ] ] - score: 1
 Coalescing zero page register [ zp[2]:21 [ plot::plotter_y#1 ] ] with [ zp[2]:24 [ plot::plotter_y#2 ] ] - score: 1
 Coalescing zero page register [ zp[2]:15 [ plot::plotter_x#1 plot::plotter_x#2 ] ] with [ zp[2]:26 [ plot::plotter#0 ] ] - score: 1
@@ -1910,11 +1906,11 @@ FINAL SYMBOL TABLE
 (const byte) RSEL = (byte) 8
 (const byte*) SCREEN = (byte*) 1024
 (void()) init_plot_tables()
-(byte~) init_plot_tables::$0 reg byte a 22.0
-(byte~) init_plot_tables::$6 reg byte a 22.0
-(byte~) init_plot_tables::$7 reg byte a 22.0
-(byte~) init_plot_tables::$8 reg byte a 22.0
-(byte~) init_plot_tables::$9 zp[1]:7 5.5
+(byte~) init_plot_tables::$0 reg byte a 2002.0
+(byte~) init_plot_tables::$6 reg byte a 2002.0
+(byte~) init_plot_tables::$7 reg byte a 2002.0
+(byte~) init_plot_tables::$8 reg byte a 2002.0
+(byte~) init_plot_tables::$9 zp[1]:7 500.5
 (label) init_plot_tables::@1
 (label) init_plot_tables::@2
 (label) init_plot_tables::@3
@@ -1923,19 +1919,19 @@ FINAL SYMBOL TABLE
 (label) init_plot_tables::@6
 (label) init_plot_tables::@return
 (byte) init_plot_tables::bits
-(byte) init_plot_tables::bits#1 reg byte y 11.0
-(byte) init_plot_tables::bits#3 reg byte y 6.6000000000000005
-(byte) init_plot_tables::bits#4 reg byte y 7.333333333333333
+(byte) init_plot_tables::bits#1 reg byte y 1001.0
+(byte) init_plot_tables::bits#3 reg byte y 600.5999999999999
+(byte) init_plot_tables::bits#4 reg byte y 667.3333333333334
 (byte) init_plot_tables::x
-(byte) init_plot_tables::x#1 reg byte x 16.5
-(byte) init_plot_tables::x#2 reg byte x 7.333333333333334
+(byte) init_plot_tables::x#1 reg byte x 1501.5
+(byte) init_plot_tables::x#2 reg byte x 667.3333333333333
 (byte) init_plot_tables::y
-(byte) init_plot_tables::y#1 reg byte x 16.5
-(byte) init_plot_tables::y#2 reg byte x 5.5
+(byte) init_plot_tables::y#1 reg byte x 1501.5
+(byte) init_plot_tables::y#2 reg byte x 500.5
 (byte*) init_plot_tables::yoffs
-(byte*) init_plot_tables::yoffs#1 yoffs zp[2]:5 22.0
-(byte*) init_plot_tables::yoffs#2 yoffs zp[2]:5 6.875
-(byte*) init_plot_tables::yoffs#4 yoffs zp[2]:5 11.0
+(byte*) init_plot_tables::yoffs#1 yoffs zp[2]:5 2002.0
+(byte*) init_plot_tables::yoffs#2 yoffs zp[2]:5 625.625
+(byte*) init_plot_tables::yoffs#4 yoffs zp[2]:5 1001.0
 (void()) init_screen()
 (label) init_screen::@1
 (label) init_screen::@2
@@ -1943,35 +1939,35 @@ FINAL SYMBOL TABLE
 (label) init_screen::@4
 (label) init_screen::@return
 (byte*) init_screen::b
-(byte*) init_screen::b#1 b zp[2]:5 22.0
-(byte*) init_screen::b#2 b zp[2]:5 14.666666666666666
+(byte*) init_screen::b#1 b zp[2]:5 2002.0
+(byte*) init_screen::b#2 b zp[2]:5 1334.6666666666667
 (byte*) init_screen::c
-(byte*) init_screen::c#1 c zp[2]:3 22.0
-(byte*) init_screen::c#2 c zp[2]:3 14.666666666666666
+(byte*) init_screen::c#1 c zp[2]:3 2002.0
+(byte*) init_screen::c#2 c zp[2]:3 1334.6666666666667
 (void()) main()
 (label) main::@1
 (label) main::@2
 (label) main::@3
 (label) main::@4
 (void()) plot((byte) plot::x , (byte) plot::y)
-(byte~) plot::$5 reg byte a 4.0
-(byte~) plot::$6 reg byte a 4.0
-(byte~) plot::$7 reg byte a 4.0
-(byte~) plot::$8 reg byte a 4.0
-(byte~) plot::$9 reg byte a 4.0
+(byte~) plot::$5 reg byte a 2000002.0
+(byte~) plot::$6 reg byte a 2000002.0
+(byte~) plot::$7 reg byte a 2000002.0
+(byte~) plot::$8 reg byte a 2000002.0
+(byte~) plot::$9 reg byte a 2000002.0
 (label) plot::@return
 (byte*) plot::plotter
-(byte*) plot::plotter#0 plotter zp[2]:3 3.0
+(byte*) plot::plotter#0 plotter zp[2]:3 1500001.5
 (byte*) plot::plotter_x
-(byte*) plot::plotter_x#1 plotter_x zp[2]:3 2.0
-(byte*) plot::plotter_x#2 plotter_x zp[2]:3 0.8
+(byte*) plot::plotter_x#1 plotter_x zp[2]:3 1000001.0
+(byte*) plot::plotter_x#2 plotter_x zp[2]:3 400000.4
 (word) plot::plotter_y
-(word) plot::plotter_y#1 plotter_y zp[2]:5 2.0
-(word) plot::plotter_y#2 plotter_y zp[2]:5 4.0
+(word) plot::plotter_y#1 plotter_y zp[2]:5 1000001.0
+(word) plot::plotter_y#2 plotter_y zp[2]:5 2000002.0
 (byte) plot::x
-(byte) plot::x#0 x zp[1]:7 9.727272727272727
+(byte) plot::x#0 x zp[1]:7 281818.54545454547
 (byte) plot::y
-(byte) plot::y#0 y zp[1]:2 15.000000000000002
+(byte) plot::y#0 y zp[1]:2 300000.4285714285
 (const byte*) plot_bit[(number) $100]  = { fill( $100, 0) }
 (const byte*) plot_xhi[(number) $100]  = { fill( $100, 0) }
 (const byte*) plot_xlo[(number) $100]  = { fill( $100, 0) }
@@ -1983,8 +1979,8 @@ FINAL SYMBOL TABLE
 (label) plots::@3
 (label) plots::@return
 (byte) plots::i
-(byte) plots::i#1 reg byte x 202.0
-(byte) plots::i#2 reg byte x 101.0
+(byte) plots::i#1 reg byte x 200002.0
+(byte) plots::i#2 reg byte x 100001.0
 (const byte) plots_cnt = (byte) 8
 (const byte*) plots_x[]  = { (byte) $3c, (byte) $50, (byte) $6e, (byte) $50, (byte) $3c, (byte) $28, (byte) $a, (byte) $28 }
 (const byte*) plots_y[]  = { (byte) $a, (byte) $28, (byte) $3c, (byte) $50, (byte) $6e, (byte) $50, (byte) $3c, (byte) $28 }

src/test/ref/bitmap-plotter.sym

@@ -12,11 +12,11 @@
 (const byte) RSEL = (byte) 8
 (const byte*) SCREEN = (byte*) 1024
 (void()) init_plot_tables()
-(byte~) init_plot_tables::$0 reg byte a 22.0
-(byte~) init_plot_tables::$6 reg byte a 22.0
-(byte~) init_plot_tables::$7 reg byte a 22.0
-(byte~) init_plot_tables::$8 reg byte a 22.0
-(byte~) init_plot_tables::$9 zp[1]:7 5.5
+(byte~) init_plot_tables::$0 reg byte a 2002.0
+(byte~) init_plot_tables::$6 reg byte a 2002.0
+(byte~) init_plot_tables::$7 reg byte a 2002.0
+(byte~) init_plot_tables::$8 reg byte a 2002.0
+(byte~) init_plot_tables::$9 zp[1]:7 500.5
 (label) init_plot_tables::@1
 (label) init_plot_tables::@2
 (label) init_plot_tables::@3
@@ -25,19 +25,19 @@
 (label) init_plot_tables::@6
 (label) init_plot_tables::@return
 (byte) init_plot_tables::bits
-(byte) init_plot_tables::bits#1 reg byte y 11.0
-(byte) init_plot_tables::bits#3 reg byte y 6.6000000000000005
-(byte) init_plot_tables::bits#4 reg byte y 7.333333333333333
+(byte) init_plot_tables::bits#1 reg byte y 1001.0
+(byte) init_plot_tables::bits#3 reg byte y 600.5999999999999
+(byte) init_plot_tables::bits#4 reg byte y 667.3333333333334
 (byte) init_plot_tables::x
-(byte) init_plot_tables::x#1 reg byte x 16.5
-(byte) init_plot_tables::x#2 reg byte x 7.333333333333334
+(byte) init_plot_tables::x#1 reg byte x 1501.5
+(byte) init_plot_tables::x#2 reg byte x 667.3333333333333
 (byte) init_plot_tables::y
-(byte) init_plot_tables::y#1 reg byte x 16.5
-(byte) init_plot_tables::y#2 reg byte x 5.5
+(byte) init_plot_tables::y#1 reg byte x 1501.5
+(byte) init_plot_tables::y#2 reg byte x 500.5
 (byte*) init_plot_tables::yoffs
-(byte*) init_plot_tables::yoffs#1 yoffs zp[2]:5 22.0
-(byte*) init_plot_tables::yoffs#2 yoffs zp[2]:5 6.875
-(byte*) init_plot_tables::yoffs#4 yoffs zp[2]:5 11.0
+(byte*) init_plot_tables::yoffs#1 yoffs zp[2]:5 2002.0
+(byte*) init_plot_tables::yoffs#2 yoffs zp[2]:5 625.625
+(byte*) init_plot_tables::yoffs#4 yoffs zp[2]:5 1001.0
 (void()) init_screen()
 (label) init_screen::@1
 (label) init_screen::@2
@@ -45,35 +45,35 @@
 (label) init_screen::@4
 (label) init_screen::@return
 (byte*) init_screen::b
-(byte*) init_screen::b#1 b zp[2]:5 22.0
-(byte*) init_screen::b#2 b zp[2]:5 14.666666666666666
+(byte*) init_screen::b#1 b zp[2]:5 2002.0
+(byte*) init_screen::b#2 b zp[2]:5 1334.6666666666667
 (byte*) init_screen::c
-(byte*) init_screen::c#1 c zp[2]:3 22.0
-(byte*) init_screen::c#2 c zp[2]:3 14.666666666666666
+(byte*) init_screen::c#1 c zp[2]:3 2002.0
+(byte*) init_screen::c#2 c zp[2]:3 1334.6666666666667
 (void()) main()
 (label) main::@1
 (label) main::@2
 (label) main::@3
 (label) main::@4
 (void()) plot((byte) plot::x , (byte) plot::y)
-(byte~) plot::$5 reg byte a 4.0
-(byte~) plot::$6 reg byte a 4.0
-(byte~) plot::$7 reg byte a 4.0
-(byte~) plot::$8 reg byte a 4.0
-(byte~) plot::$9 reg byte a 4.0
+(byte~) plot::$5 reg byte a 2000002.0
+(byte~) plot::$6 reg byte a 2000002.0
+(byte~) plot::$7 reg byte a 2000002.0
+(byte~) plot::$8 reg byte a 2000002.0
+(byte~) plot::$9 reg byte a 2000002.0
 (label) plot::@return
 (byte*) plot::plotter
-(byte*) plot::plotter#0 plotter zp[2]:3 3.0
+(byte*) plot::plotter#0 plotter zp[2]:3 1500001.5
 (byte*) plot::plotter_x
-(byte*) plot::plotter_x#1 plotter_x zp[2]:3 2.0
-(byte*) plot::plotter_x#2 plotter_x zp[2]:3 0.8
+(byte*) plot::plotter_x#1 plotter_x zp[2]:3 1000001.0
+(byte*) plot::plotter_x#2 plotter_x zp[2]:3 400000.4
 (word) plot::plotter_y
-(word) plot::plotter_y#1 plotter_y zp[2]:5 2.0
-(word) plot::plotter_y#2 plotter_y zp[2]:5 4.0
+(word) plot::plotter_y#1 plotter_y zp[2]:5 1000001.0
+(word) plot::plotter_y#2 plotter_y zp[2]:5 2000002.0
 (byte) plot::x
-(byte) plot::x#0 x zp[1]:7 9.727272727272727
+(byte) plot::x#0 x zp[1]:7 281818.54545454547
 (byte) plot::y
-(byte) plot::y#0 y zp[1]:2 15.000000000000002
+(byte) plot::y#0 y zp[1]:2 300000.4285714285
 (const byte*) plot_bit[(number) $100]  = { fill( $100, 0) }
 (const byte*) plot_xhi[(number) $100]  = { fill( $100, 0) }
 (const byte*) plot_xlo[(number) $100]  = { fill( $100, 0) }
@@ -85,8 +85,8 @@
 (label) plots::@3
 (label) plots::@return
 (byte) plots::i
-(byte) plots::i#1 reg byte x 202.0
-(byte) plots::i#2 reg byte x 101.0
+(byte) plots::i#1 reg byte x 200002.0
+(byte) plots::i#2 reg byte x 100001.0
 (const byte) plots_cnt = (byte) 8
 (const byte*) plots_x[]  = { (byte) $3c, (byte) $50, (byte) $6e, (byte) $50, (byte) $3c, (byte) $28, (byte) $a, (byte) $28 }
 (const byte*) plots_y[]  = { (byte) $a, (byte) $28, (byte) $3c, (byte) $50, (byte) $6e, (byte) $50, (byte) $3c, (byte) $28 }

src/test/ref/bitwise-not.log

@@ -107,10 +107,10 @@ main::@return: scope:[main]  from main::@1
 
 VARIABLE REGISTER WEIGHTS
 (void()) main()
-(byte~) main::$0 22.0
+(byte~) main::$0 202.0
 (byte) main::c
-(byte) main::c#1 16.5
-(byte) main::c#2 14.666666666666666
+(byte) main::c#1 151.5
+(byte) main::c#2 134.66666666666666
 
 Initial phi equivalence classes
 [ main::c#2 main::c#1 ]
@@ -186,16 +186,16 @@ main: {
   // File Data
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Statement [4] *((const byte*) main::SCREEN) ← ~(byte) 1 [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [6] (byte~) main::$0 ← ~ (byte) main::c#2 [ main::c#2 main::$0 ] ( main:2 [ main::c#2 main::$0 ] ) always clobbers reg byte a 
+Statement [4] *((const byte*) main::SCREEN) ← ~(byte) 1 [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [6] (byte~) main::$0 ← ~ (byte) main::c#2 [ main::c#2 main::$0 ] ( main:2 [ main::c#2 main::$0 ] { }  ) always clobbers reg byte a 
 Removing always clobbered register reg byte a as potential for zp[1]:2 [ main::c#2 main::c#1 ]
-Statement [4] *((const byte*) main::SCREEN) ← ~(byte) 1 [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [6] (byte~) main::$0 ← ~ (byte) main::c#2 [ main::c#2 main::$0 ] ( main:2 [ main::c#2 main::$0 ] ) always clobbers reg byte a 
+Statement [4] *((const byte*) main::SCREEN) ← ~(byte) 1 [ ] ( main:2 [ ] { }  ) always clobbers reg byte a 
+Statement [6] (byte~) main::$0 ← ~ (byte) main::c#2 [ main::c#2 main::$0 ] ( main:2 [ main::c#2 main::$0 ] { }  ) always clobbers reg byte a 
 Potential registers zp[1]:2 [ main::c#2 main::c#1 ] : zp[1]:2 , reg byte x , reg byte y , 
 Potential registers zp[1]:3 [ main::$0 ] : zp[1]:3 , reg byte a , reg byte x , reg byte y , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [main] 31.17: zp[1]:2 [ main::c#2 main::c#1 ] 22: zp[1]:3 [ main::$0 ] 
+Uplift Scope [main] 286.17: zp[1]:2 [ main::c#2 main::c#1 ] 202: zp[1]:3 [ main::$0 ] 
 Uplift Scope [] 
 
 Uplifting [main] best 289 combination reg byte x [ main::c#2 main::c#1 ] reg byte a [ main::$0 ] 
@@ -286,13 +286,13 @@ FINAL SYMBOL TABLE
 (label) @begin
 (label) @end
 (void()) main()
-(byte~) main::$0 reg byte a 22.0
+(byte~) main::$0 reg byte a 202.0
 (label) main::@1
 (label) main::@return
 (const byte*) main::SCREEN = (byte*) 1024
 (byte) main::c
-(byte) main::c#1 reg byte x 16.5
-(byte) main::c#2 reg byte x 14.666666666666666
+(byte) main::c#1 reg byte x 151.5
+(byte) main::c#2 reg byte x 134.66666666666666
 
 reg byte x [ main::c#2 main::c#1 ]
 reg byte a [ main::$0 ]

src/test/ref/bitwise-not.sym

@@ -2,13 +2,13 @@
 (label) @begin
 (label) @end
 (void()) main()
-(byte~) main::$0 reg byte a 22.0
+(byte~) main::$0 reg byte a 202.0
 (label) main::@1
 (label) main::@return
 (const byte*) main::SCREEN = (byte*) 1024
 (byte) main::c
-(byte) main::c#1 reg byte x 16.5
-(byte) main::c#2 reg byte x 14.666666666666666
+(byte) main::c#1 reg byte x 151.5
+(byte) main::c#2 reg byte x 134.66666666666666
 
 reg byte x [ main::c#2 main::c#1 ]
 reg byte a [ main::$0 ]

src/test/ref/bool-const.log

@@ -200,9 +200,9 @@ Successful SSA optimization PassNFinalizeNumberTypeConversions
 Inversing boolean not [10] (bool~) bool_const_vars::$2 ← (byte) $15 >= (const byte) bool_const_vars::a from [9] (bool~) bool_const_vars::$1 ← (byte) $15 < (const byte) bool_const_vars::a
 Inversing boolean not [31] (bool~) bool_const_inline::$6 ← (byte) $15 >= (const byte) bool_const_inline::a from [30] (bool~) bool_const_inline::$5 ← (byte) $15 < (const byte) bool_const_inline::a
 Successful SSA optimization Pass2UnaryNotSimplification
-Alias (bool) bool_const_vars::b1#0 = (bool~) bool_const_vars::$3 
-Alias (bool) bool_const_vars::b2#0 = (bool~) bool_const_vars::$6 
-Alias (bool) bool_const_vars::b#0 = (bool~) bool_const_vars::$9 
+Alias bool_const_vars::b1#0 = bool_const_vars::$3 
+Alias bool_const_vars::b2#0 = bool_const_vars::$6 
+Alias bool_const_vars::b#0 = bool_const_vars::$9 
 Successful SSA optimization Pass2AliasElimination
 Rewriting || if()-condition to two if()s [16] (bool) bool_const_vars::b#0 ← (bool~) bool_const_vars::$8 || false
 Rewriting && if()-condition to two if()s [15] (bool~) bool_const_vars::$8 ← (bool) bool_const_vars::b1#0 && (bool~) bool_const_vars::$7
@@ -484,9 +484,9 @@ bool_const_if: {
   // File Data
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Statement [12] *((const byte*) SCREEN+(byte) 2) ← (byte) 't' [ ] ( main:2::bool_const_inline:9 [ ] ) always clobbers reg byte a 
-Statement [15] *((const byte*) SCREEN+(byte) 1) ← (byte) 'f' [ ] ( main:2::bool_const_vars:7 [ ] ) always clobbers reg byte a 
-Statement [18] *((const byte*) SCREEN) ← (byte) 't' [ ] ( main:2::bool_const_if:5 [ ] ) always clobbers reg byte a 
+Statement [12] *((const byte*) SCREEN+(byte) 2) ← (byte) 't' [ ] ( main:2::bool_const_inline:9 [ ] { }  ) always clobbers reg byte a 
+Statement [15] *((const byte*) SCREEN+(byte) 1) ← (byte) 'f' [ ] ( main:2::bool_const_vars:7 [ ] { }  ) always clobbers reg byte a 
+Statement [18] *((const byte*) SCREEN) ← (byte) 't' [ ] ( main:2::bool_const_if:5 [ ] { }  ) always clobbers reg byte a 
 
 REGISTER UPLIFT SCOPES
 Uplift Scope [main] 

src/test/ref/bool-function.asm

@@ -16,6 +16,7 @@ main: {
   !:
     eor #1
     tay
+    txa
     jsr isSet
     // if( isSet(i, (i&1)==0))
     cmp #0
@@ -38,10 +39,9 @@ main: {
 }
 // Determine whether to set a char to '*.
 // Returns true if i&8!=0 or b=true
-// isSet(byte register(X) i, bool register(Y) b)
+// isSet(byte register(A) i, bool register(Y) b)
 isSet: {
     // i&8
-    txa
     and #8
     // (i&8)!=0
     eor #0

src/test/ref/bool-function.log

@@ -129,12 +129,12 @@ Finalized unsigned number type (byte) 0
 Successful SSA optimization PassNFinalizeNumberTypeConversions
 Inferred type updated to byte in (unumber~) main::$0 ← (byte) main::i#2 & (byte) 1
 Inferred type updated to byte in (unumber~) isSet::$0 ← (byte) isSet::i#1 & (byte) 8
-Alias (bool) isSet::b#0 = (bool~) main::$1 
-Alias (bool) isSet::return#0 = (bool) isSet::return#3 
-Alias (byte) main::i#2 = (byte) main::i#6 (byte) main::i#3 (byte) main::i#4 
-Alias (bool) isSet::return#1 = (bool~) isSet::$2 (bool) isSet::return#4 (bool) isSet::return#2 
+Alias isSet::b#0 = main::$1 
+Alias isSet::return#0 = isSet::return#3 
+Alias main::i#2 = main::i#6 main::i#3 main::i#4 
+Alias isSet::return#1 = isSet::$2 isSet::return#4 isSet::return#2 
 Successful SSA optimization Pass2AliasElimination
-Alias (byte) main::i#2 = (byte) main::i#5 
+Alias main::i#2 = main::i#5 
 Successful SSA optimization Pass2AliasElimination
 Identical Phi Values (byte) isSet::i#1 (byte) isSet::i#0
 Identical Phi Values (bool) isSet::b#1 (bool) isSet::b#0
@@ -230,21 +230,21 @@ isSet::@return: scope:[isSet]  from isSet
 
 VARIABLE REGISTER WEIGHTS
 (bool()) isSet((byte) isSet::i , (bool) isSet::b)
-(byte~) isSet::$0 4.0
-(bool~) isSet::$1 4.0
+(byte~) isSet::$0 2002.0
+(bool~) isSet::$1 2002.0
 (bool) isSet::b
-(bool) isSet::b#0 3.25
+(bool) isSet::b#0 275.5
 (byte) isSet::i
-(byte) isSet::i#0 13.0
+(byte) isSet::i#0 1102.0
 (bool) isSet::return
-(bool) isSet::return#0 22.0
-(bool) isSet::return#1 4.333333333333333
+(bool) isSet::return#0 202.0
+(bool) isSet::return#1 367.33333333333337
 (void()) main()
-(byte~) main::$0 22.0
-(bool~) main::$2 22.0
+(byte~) main::$0 202.0
+(bool~) main::$2 202.0
 (byte) main::i
-(byte) main::i#1 16.5
-(byte) main::i#2 6.6
+(byte) main::i#1 151.5
+(byte) main::i#2 60.6
 
 Initial phi equivalence classes
 [ main::i#2 main::i#1 ]
@@ -413,19 +413,19 @@ isSet: {
   // File Data
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Statement [7] (bool) isSet::b#0 ← (byte~) main::$0 == (byte) 0 [ main::i#2 isSet::b#0 ] ( main:2 [ main::i#2 isSet::b#0 ] ) always clobbers reg byte a 
+Statement [7] (bool) isSet::b#0 ← (byte~) main::$0 == (byte) 0 [ main::i#2 isSet::b#0 ] ( main:2 [ main::i#2 isSet::b#0 ] { { isSet::i#0 = main::i#2 } { isSet::return#0 = isSet::return#1 } }  ) always clobbers reg byte a 
 Removing always clobbered register reg byte a as potential for zp[1]:2 [ main::i#2 main::i#1 ]
-Statement [13] *((const byte*) main::screen + (byte) main::i#2) ← (byte) ' ' [ main::i#2 ] ( main:2 [ main::i#2 ] ) always clobbers reg byte a 
-Statement [17] *((const byte*) main::screen + (byte) main::i#2) ← (byte) '*' [ main::i#2 ] ( main:2 [ main::i#2 ] ) always clobbers reg byte a 
-Statement [19] (bool~) isSet::$1 ← (byte~) isSet::$0 != (byte) 0 [ isSet::b#0 isSet::$1 ] ( main:2::isSet:9 [ main::i#2 isSet::b#0 isSet::$1 ] ) always clobbers reg byte a 
+Statement [13] *((const byte*) main::screen + (byte) main::i#2) ← (byte) ' ' [ main::i#2 ] ( main:2 [ main::i#2 ] { }  ) always clobbers reg byte a 
+Statement [17] *((const byte*) main::screen + (byte) main::i#2) ← (byte) '*' [ main::i#2 ] ( main:2 [ main::i#2 ] { }  ) always clobbers reg byte a 
+Statement [19] (bool~) isSet::$1 ← (byte~) isSet::$0 != (byte) 0 [ isSet::b#0 isSet::$1 ] ( main:2::isSet:9 [ main::i#2 isSet::b#0 isSet::$1 ] { { isSet::i#0 = main::i#2 } { isSet::return#0 = isSet::return#1 } }  ) always clobbers reg byte a 
 Removing always clobbered register reg byte a as potential for zp[1]:4 [ isSet::b#0 ]
-Statement [20] (bool) isSet::return#1 ← (bool) isSet::b#0 || (bool~) isSet::$1 [ isSet::return#1 ] ( main:2::isSet:9 [ main::i#2 isSet::return#1 ] ) always clobbers reg byte a 
-Statement [6] (byte~) main::$0 ← (byte) main::i#2 & (byte) 1 [ main::i#2 main::$0 ] ( main:2 [ main::i#2 main::$0 ] ) always clobbers reg byte a 
-Statement [7] (bool) isSet::b#0 ← (byte~) main::$0 == (byte) 0 [ main::i#2 isSet::b#0 ] ( main:2 [ main::i#2 isSet::b#0 ] ) always clobbers reg byte a 
-Statement [13] *((const byte*) main::screen + (byte) main::i#2) ← (byte) ' ' [ main::i#2 ] ( main:2 [ main::i#2 ] ) always clobbers reg byte a 
-Statement [17] *((const byte*) main::screen + (byte) main::i#2) ← (byte) '*' [ main::i#2 ] ( main:2 [ main::i#2 ] ) always clobbers reg byte a 
-Statement [19] (bool~) isSet::$1 ← (byte~) isSet::$0 != (byte) 0 [ isSet::b#0 isSet::$1 ] ( main:2::isSet:9 [ main::i#2 isSet::b#0 isSet::$1 ] ) always clobbers reg byte a 
-Statement [20] (bool) isSet::return#1 ← (bool) isSet::b#0 || (bool~) isSet::$1 [ isSet::return#1 ] ( main:2::isSet:9 [ main::i#2 isSet::return#1 ] ) always clobbers reg byte a 
+Statement [20] (bool) isSet::return#1 ← (bool) isSet::b#0 || (bool~) isSet::$1 [ isSet::return#1 ] ( main:2::isSet:9 [ main::i#2 isSet::return#1 ] { { isSet::i#0 = main::i#2 } { isSet::return#0 = isSet::return#1 } }  ) always clobbers reg byte a 
+Statement [6] (byte~) main::$0 ← (byte) main::i#2 & (byte) 1 [ main::i#2 main::$0 ] ( main:2 [ main::i#2 main::$0 ] { { isSet::i#0 = main::i#2 } { isSet::return#0 = isSet::return#1 } }  ) always clobbers reg byte a 
+Statement [7] (bool) isSet::b#0 ← (byte~) main::$0 == (byte) 0 [ main::i#2 isSet::b#0 ] ( main:2 [ main::i#2 isSet::b#0 ] { { isSet::i#0 = main::i#2 } { isSet::return#0 = isSet::return#1 } }  ) always clobbers reg byte a 
+Statement [13] *((const byte*) main::screen + (byte) main::i#2) ← (byte) ' ' [ main::i#2 ] ( main:2 [ main::i#2 ] { }  ) always clobbers reg byte a 
+Statement [17] *((const byte*) main::screen + (byte) main::i#2) ← (byte) '*' [ main::i#2 ] ( main:2 [ main::i#2 ] { }  ) always clobbers reg byte a 
+Statement [19] (bool~) isSet::$1 ← (byte~) isSet::$0 != (byte) 0 [ isSet::b#0 isSet::$1 ] ( main:2::isSet:9 [ main::i#2 isSet::b#0 isSet::$1 ] { { isSet::i#0 = main::i#2 } { isSet::return#0 = isSet::return#1 } }  ) always clobbers reg byte a 
+Statement [20] (bool) isSet::return#1 ← (bool) isSet::b#0 || (bool~) isSet::$1 [ isSet::return#1 ] ( main:2::isSet:9 [ main::i#2 isSet::return#1 ] { { isSet::i#0 = main::i#2 } { isSet::return#0 = isSet::return#1 } }  ) always clobbers reg byte a 
 Potential registers zp[1]:2 [ main::i#2 main::i#1 ] : zp[1]:2 , reg byte x , reg byte y , 
 Potential registers zp[1]:3 [ main::$0 ] : zp[1]:3 , reg byte a , reg byte x , reg byte y , 
 Potential registers zp[1]:4 [ isSet::b#0 ] : zp[1]:4 , reg byte x , reg byte y , 
@@ -437,18 +437,18 @@ Potential registers zp[1]:9 [ isSet::$1 ] : zp[1]:9 , reg byte a , reg byte x ,
 Potential registers zp[1]:10 [ isSet::return#1 ] : zp[1]:10 , reg byte a , reg byte x , reg byte y , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [main] 23.1: zp[1]:2 [ main::i#2 main::i#1 ] 22: zp[1]:3 [ main::$0 ] 22: zp[1]:7 [ main::$2 ] 
-Uplift Scope [isSet] 22: zp[1]:6 [ isSet::return#0 ] 13: zp[1]:5 [ isSet::i#0 ] 4.33: zp[1]:10 [ isSet::return#1 ] 4: zp[1]:8 [ isSet::$0 ] 4: zp[1]:9 [ isSet::$1 ] 3.25: zp[1]:4 [ isSet::b#0 ] 
+Uplift Scope [isSet] 2,002: zp[1]:8 [ isSet::$0 ] 2,002: zp[1]:9 [ isSet::$1 ] 1,102: zp[1]:5 [ isSet::i#0 ] 367.33: zp[1]:10 [ isSet::return#1 ] 275.5: zp[1]:4 [ isSet::b#0 ] 202: zp[1]:6 [ isSet::return#0 ] 
+Uplift Scope [main] 212.1: zp[1]:2 [ main::i#2 main::i#1 ] 202: zp[1]:3 [ main::$0 ] 202: zp[1]:7 [ main::$2 ] 
 Uplift Scope [] 
 
-Uplifting [main] best 871 combination reg byte x [ main::i#2 main::i#1 ] reg byte a [ main::$0 ] reg byte a [ main::$2 ] 
-Uplifting [isSet] best 741 combination reg byte a [ isSet::return#0 ] reg byte x [ isSet::i#0 ] reg byte a [ isSet::return#1 ] reg byte a [ isSet::$0 ] zp[1]:9 [ isSet::$1 ] zp[1]:4 [ isSet::b#0 ] 
+Uplifting [isSet] best 1103 combination reg byte a [ isSet::$0 ] reg byte a [ isSet::$1 ] reg byte a [ isSet::i#0 ] reg byte a [ isSet::return#1 ] zp[1]:4 [ isSet::b#0 ] zp[1]:6 [ isSet::return#0 ] 
 Limited combination testing to 100 combinations of 3072 possible.
-Uplifting [] best 741 combination 
-Attempting to uplift remaining variables inzp[1]:9 [ isSet::$1 ]
-Uplifting [isSet] best 735 combination reg byte a [ isSet::$1 ] 
+Uplifting [main] best 813 combination reg byte x [ main::i#2 main::i#1 ] reg byte a [ main::$0 ] reg byte a [ main::$2 ] 
+Uplifting [] best 813 combination 
 Attempting to uplift remaining variables inzp[1]:4 [ isSet::b#0 ]
-Uplifting [isSet] best 728 combination reg byte y [ isSet::b#0 ] 
+Uplifting [isSet] best 806 combination reg byte y [ isSet::b#0 ] 
+Attempting to uplift remaining variables inzp[1]:6 [ isSet::return#0 ]
+Uplifting [isSet] best 746 combination reg byte a [ isSet::return#0 ] 
 
 ASSEMBLER BEFORE OPTIMIZATION
   // File Comments
@@ -498,7 +498,8 @@ main: {
   !:
     eor #1
     tay
-    // [8] (byte) isSet::i#0 ← (byte) main::i#2
+    // [8] (byte) isSet::i#0 ← (byte) main::i#2 -- vbuaa=vbuxx 
+    txa
     // [9] call isSet 
     jsr isSet
     // [10] (bool) isSet::return#0 ← (bool) isSet::return#1
@@ -538,10 +539,9 @@ main: {
   // isSet
 // Determine whether to set a char to '*.
 // Returns true if i&8!=0 or b=true
-// isSet(byte register(X) i, bool register(Y) b)
+// isSet(byte register(A) i, bool register(Y) b)
 isSet: {
-    // [18] (byte~) isSet::$0 ← (byte) isSet::i#0 & (byte) 8 -- vbuaa=vbuxx_band_vbuc1 
-    txa
+    // [18] (byte~) isSet::$0 ← (byte) isSet::i#0 & (byte) 8 -- vbuaa=vbuaa_band_vbuc1 
     and #8
     // [19] (bool~) isSet::$1 ← (byte~) isSet::$0 != (byte) 0 -- vboaa=vbuaa_neq_vbuc1 
     eor #0
@@ -596,19 +596,19 @@ FINAL SYMBOL TABLE
 (label) @begin
 (label) @end
 (bool()) isSet((byte) isSet::i , (bool) isSet::b)
-(byte~) isSet::$0 reg byte a 4.0
-(bool~) isSet::$1 reg byte a 4.0
+(byte~) isSet::$0 reg byte a 2002.0
+(bool~) isSet::$1 reg byte a 2002.0
 (label) isSet::@return
 (bool) isSet::b
-(bool) isSet::b#0 reg byte y 3.25
+(bool) isSet::b#0 reg byte y 275.5
 (byte) isSet::i
-(byte) isSet::i#0 reg byte x 13.0
+(byte) isSet::i#0 reg byte a 1102.0
 (bool) isSet::return
-(bool) isSet::return#0 reg byte a 22.0
-(bool) isSet::return#1 reg byte a 4.333333333333333
+(bool) isSet::return#0 reg byte a 202.0
+(bool) isSet::return#1 reg byte a 367.33333333333337
 (void()) main()
-(byte~) main::$0 reg byte a 22.0
-(bool~) main::$2 reg byte a 22.0
+(byte~) main::$0 reg byte a 202.0
+(bool~) main::$2 reg byte a 202.0
 (label) main::@1
 (label) main::@2
 (label) main::@3
@@ -616,14 +616,14 @@ FINAL SYMBOL TABLE
 (label) main::@5
 (label) main::@return
 (byte) main::i
-(byte) main::i#1 reg byte x 16.5
-(byte) main::i#2 reg byte x 6.6
+(byte) main::i#1 reg byte x 151.5
+(byte) main::i#2 reg byte x 60.6
 (const byte*) main::screen = (byte*) 1024
 
 reg byte x [ main::i#2 main::i#1 ]
 reg byte a [ main::$0 ]
 reg byte y [ isSet::b#0 ]
-reg byte x [ isSet::i#0 ]
+reg byte a [ isSet::i#0 ]
 reg byte a [ isSet::return#0 ]
 reg byte a [ main::$2 ]
 reg byte a [ isSet::$0 ]
@@ -632,7 +632,7 @@ reg byte a [ isSet::return#1 ]
 
 
 FINAL ASSEMBLER
-Score: 533
+Score: 551
 
   // File Comments
 // Test a function taking boolean parameter and returning boolean result
@@ -670,7 +670,8 @@ main: {
   !:
     eor #1
     tay
-    // [8] (byte) isSet::i#0 ← (byte) main::i#2
+    // [8] (byte) isSet::i#0 ← (byte) main::i#2 -- vbuaa=vbuxx 
+    txa
     // [9] call isSet 
     jsr isSet
     // [10] (bool) isSet::return#0 ← (bool) isSet::return#1
@@ -708,11 +709,10 @@ main: {
   // isSet
 // Determine whether to set a char to '*.
 // Returns true if i&8!=0 or b=true
-// isSet(byte register(X) i, bool register(Y) b)
+// isSet(byte register(A) i, bool register(Y) b)
 isSet: {
     // i&8
-    // [18] (byte~) isSet::$0 ← (byte) isSet::i#0 & (byte) 8 -- vbuaa=vbuxx_band_vbuc1 
-    txa
+    // [18] (byte~) isSet::$0 ← (byte) isSet::i#0 & (byte) 8 -- vbuaa=vbuaa_band_vbuc1 
     and #8
     // (i&8)!=0
     // [19] (bool~) isSet::$1 ← (byte~) isSet::$0 != (byte) 0 -- vboaa=vbuaa_neq_vbuc1 

src/test/ref/bool-function.sym

@@ -2,19 +2,19 @@
 (label) @begin
 (label) @end
 (bool()) isSet((byte) isSet::i , (bool) isSet::b)
-(byte~) isSet::$0 reg byte a 4.0
-(bool~) isSet::$1 reg byte a 4.0
+(byte~) isSet::$0 reg byte a 2002.0
+(bool~) isSet::$1 reg byte a 2002.0
 (label) isSet::@return
 (bool) isSet::b
-(bool) isSet::b#0 reg byte y 3.25
+(bool) isSet::b#0 reg byte y 275.5
 (byte) isSet::i
-(byte) isSet::i#0 reg byte x 13.0
+(byte) isSet::i#0 reg byte a 1102.0
 (bool) isSet::return
-(bool) isSet::return#0 reg byte a 22.0
-(bool) isSet::return#1 reg byte a 4.333333333333333
+(bool) isSet::return#0 reg byte a 202.0
+(bool) isSet::return#1 reg byte a 367.33333333333337
 (void()) main()
-(byte~) main::$0 reg byte a 22.0
-(bool~) main::$2 reg byte a 22.0
+(byte~) main::$0 reg byte a 202.0
+(bool~) main::$2 reg byte a 202.0
 (label) main::@1
 (label) main::@2
 (label) main::@3
@@ -22,14 +22,14 @@
 (label) main::@5
 (label) main::@return
 (byte) main::i
-(byte) main::i#1 reg byte x 16.5
-(byte) main::i#2 reg byte x 6.6
+(byte) main::i#1 reg byte x 151.5
+(byte) main::i#2 reg byte x 60.6
 (const byte*) main::screen = (byte*) 1024
 
 reg byte x [ main::i#2 main::i#1 ]
 reg byte a [ main::$0 ]
 reg byte y [ isSet::b#0 ]
-reg byte x [ isSet::i#0 ]
+reg byte a [ isSet::i#0 ]
 reg byte a [ isSet::return#0 ]
 reg byte a [ main::$2 ]
 reg byte a [ isSet::$0 ]

src/test/ref/bool-ifs-min.log

@@ -76,9 +76,9 @@ Finalized unsigned number type (byte) 1
 Finalized unsigned number type (byte) 0
 Successful SSA optimization PassNFinalizeNumberTypeConversions
 Inferred type updated to byte in (unumber~) main::$1 ← (byte) main::i#2 & (byte) 1
-Alias (byte) main::i#2 = (byte) main::i#4 
+Alias main::i#2 = main::i#4 
 Successful SSA optimization Pass2AliasElimination
-Alias (byte) main::i#2 = (byte) main::i#3 
+Alias main::i#2 = main::i#3 
 Successful SSA optimization Pass2AliasElimination
 Simple Condition (bool~) main::$5 [10] if((byte) main::i#1!=rangelast(0,$14)) goto main::@1
 Successful SSA optimization Pass2ConditionalJumpSimplification
@@ -161,10 +161,10 @@ main::@return: scope:[main]  from main::@2
 
 VARIABLE REGISTER WEIGHTS
 (void()) main()
-(byte~) main::$1 11.0
+(byte~) main::$1 101.0
 (byte) main::i
-(byte) main::i#1 16.5
-(byte) main::i#2 11.0
+(byte) main::i#1 151.5
+(byte) main::i#2 101.0
 
 Initial phi equivalence classes
 [ main::i#2 main::i#1 ]
@@ -257,15 +257,15 @@ main: {
   // File Data
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Statement [9] *((const byte*) main::screen + (byte) main::i#2) ← (byte) '*' [ main::i#2 ] ( main:2 [ main::i#2 ] ) always clobbers reg byte a 
+Statement [9] *((const byte*) main::screen + (byte) main::i#2) ← (byte) '*' [ main::i#2 ] ( main:2 [ main::i#2 ] { }  ) always clobbers reg byte a 
 Removing always clobbered register reg byte a as potential for zp[1]:2 [ main::i#2 main::i#1 ]
-Statement [6] (byte~) main::$1 ← (byte) main::i#2 & (byte) 1 [ main::i#2 main::$1 ] ( main:2 [ main::i#2 main::$1 ] ) always clobbers reg byte a 
-Statement [9] *((const byte*) main::screen + (byte) main::i#2) ← (byte) '*' [ main::i#2 ] ( main:2 [ main::i#2 ] ) always clobbers reg byte a 
+Statement [6] (byte~) main::$1 ← (byte) main::i#2 & (byte) 1 [ main::i#2 main::$1 ] ( main:2 [ main::i#2 main::$1 ] { }  ) always clobbers reg byte a 
+Statement [9] *((const byte*) main::screen + (byte) main::i#2) ← (byte) '*' [ main::i#2 ] ( main:2 [ main::i#2 ] { }  ) always clobbers reg byte a 
 Potential registers zp[1]:2 [ main::i#2 main::i#1 ] : zp[1]:2 , reg byte x , reg byte y , 
 Potential registers zp[1]:3 [ main::$1 ] : zp[1]:3 , reg byte a , reg byte x , reg byte y , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [main] 27.5: zp[1]:2 [ main::i#2 main::i#1 ] 11: zp[1]:3 [ main::$1 ] 
+Uplift Scope [main] 252.5: zp[1]:2 [ main::i#2 main::i#1 ] 101: zp[1]:3 [ main::$1 ] 
 Uplift Scope [] 
 
 Uplifting [main] best 483 combination reg byte x [ main::i#2 main::i#1 ] reg byte a [ main::$1 ] 
@@ -378,15 +378,15 @@ FINAL SYMBOL TABLE
 (label) @begin
 (label) @end
 (void()) main()
-(byte~) main::$1 reg byte a 11.0
+(byte~) main::$1 reg byte a 101.0
 (label) main::@1
 (label) main::@2
 (label) main::@3
 (label) main::@4
 (label) main::@return
 (byte) main::i
-(byte) main::i#1 reg byte x 16.5
-(byte) main::i#2 reg byte x 11.0
+(byte) main::i#1 reg byte x 151.5
+(byte) main::i#2 reg byte x 101.0
 (const byte*) main::screen = (byte*) 1024
 
 reg byte x [ main::i#2 main::i#1 ]

src/test/ref/bool-ifs-min.sym

@@ -2,15 +2,15 @@
 (label) @begin
 (label) @end
 (void()) main()
-(byte~) main::$1 reg byte a 11.0
+(byte~) main::$1 reg byte a 101.0
 (label) main::@1
 (label) main::@2
 (label) main::@3
 (label) main::@4
 (label) main::@return
 (byte) main::i
-(byte) main::i#1 reg byte x 16.5
-(byte) main::i#2 reg byte x 11.0
+(byte) main::i#1 reg byte x 151.5
+(byte) main::i#2 reg byte x 101.0
 (const byte*) main::screen = (byte*) 1024
 
 reg byte x [ main::i#2 main::i#1 ]

src/test/ref/bool-nullpointer-exception.log

@@ -67,9 +67,9 @@ SYMBOL TABLE SSA
 (label) main::@6
 (label) main::@return
 
-Alias (bool) framedone#2 = (bool) framedone#5 (bool) framedone#7 
-Alias (bool) framedone#0 = (bool) framedone#8 
-Alias (bool) framedone#3 = (bool) framedone#6 
+Alias framedone#2 = framedone#5 framedone#7 
+Alias framedone#0 = framedone#8 
+Alias framedone#3 = framedone#6 
 Successful SSA optimization Pass2AliasElimination
 Identical Phi Values (bool) framedone#9 (bool) framedone#0
 Identical Phi Values (bool) framedone#4 (bool) framedone#2
@@ -133,7 +133,7 @@ main::@2: scope:[main]  from main::@1 main::@2
 
 VARIABLE REGISTER WEIGHTS
 (bool) framedone
-(bool) framedone#2 50.5
+(bool) framedone#2 500.5
 (void()) main()
 
 Initial phi equivalence classes
@@ -199,7 +199,7 @@ REGISTER UPLIFT POTENTIAL REGISTERS
 Potential registers zp[1]:2 [ framedone#2 ] : zp[1]:2 , reg byte a , reg byte x , reg byte y , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [] 50.5: zp[1]:2 [ framedone#2 ] 
+Uplift Scope [] 500.5: zp[1]:2 [ framedone#2 ] 
 Uplift Scope [main] 
 
 Uplifting [] best 892 combination reg byte a [ framedone#2 ] 
@@ -282,7 +282,7 @@ FINAL SYMBOL TABLE
 (label) @begin
 (label) @end
 (bool) framedone
-(bool) framedone#2 reg byte a 50.5
+(bool) framedone#2 reg byte a 500.5
 (void()) main()
 (label) main::@1
 (label) main::@2