Improved program flow for if-statements without else by inverting the condition and jumping over the stmts. Improved fragment synthesizing.

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

@@ -132,6 +132,7 @@ public class Compiler {
       optimizations.add(new Pass2CullEmptyBlocks(program));
       optimizations.add(new Pass2ConstantPropagation(program));
       optimizations.add(new Pass2ConstantAdditionElimination(program));
+      optimizations.add(new Pass2UnaryNotSimplification(program));
       optimizations.add(new Pass2AliasElimination(program));
       optimizations.add(new Pass2RedundantPhiElimination(program));
       optimizations.add(new Pass2SelfPhiElimination(program));

src/main/java/dk/camelot64/kickc/asm/AsmFragmentManager.java

@@ -1,6 +1,5 @@
 package dk.camelot64.kickc.asm;
 
-import dk.camelot64.kickc.CompileLog;
 import dk.camelot64.kickc.asm.parser.Asm6502Lexer;
 import dk.camelot64.kickc.asm.parser.Asm6502Parser;
 import org.antlr.v4.runtime.*;
@@ -10,6 +9,8 @@ import java.io.InputStream;
 import java.net.URL;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 /**
  * Provides fragments from their signature.
@@ -82,23 +83,34 @@ public class AsmFragmentManager {
             return result;
          }
       }
-      if(signature.contains("_lt_xby_then_")) {
-         int pos = signature.indexOf("_lt_xby_then_");
-         String subSignature = "xby_ge_"+signature.substring(0, pos)+"_then_"+signature.substring(pos+13);
-         return loadOrSynthesizeFragment(subSignature);
-      }
-      if(signature.contains("_lt_yby_then_")) {
-         int pos = signature.indexOf("_lt_yby_then_");
-         String subSignature = "yby_ge_"+signature.substring(0, pos)+"_then_"+signature.substring(pos+13);
-         return loadOrSynthesizeFragment(subSignature);
-      }
-      if(signature.contains("_lt_aby_then_")) {
-         int pos = signature.indexOf("_lt_aby_then_");
-         String subSignature = "aby_ge_"+signature.substring(0, pos)+"_then_"+signature.substring(pos+13);
-         return loadOrSynthesizeFragment(subSignature);
+
+      String sigNew = signature;
+      sigNew = regexpRewriteSignature(sigNew, "(.*)_ge_aby_then_(.*)", "aby_lt_$1_then_$2");
+      sigNew = regexpRewriteSignature(sigNew, "(.*)_ge_xby_then_(.*)", "xby_lt_$1_then_$2");
+      sigNew = regexpRewriteSignature(sigNew, "(.*)_ge_yby_then_(.*)", "yby_lt_$1_then_$2");
+      sigNew = regexpRewriteSignature(sigNew, "(.*)_gt_aby_then_(.*)", "aby_le_$1_then_$2");
+      sigNew = regexpRewriteSignature(sigNew, "(.*)_gt_xby_then_(.*)", "xby_le_$1_then_$2");
+      sigNew = regexpRewriteSignature(sigNew, "(.*)_gt_yby_then_(.*)", "yby_le_$1_then_$2");
+      sigNew = regexpRewriteSignature(sigNew, "(.*)_neq_aby_then_(.*)", "aby_neq_$1_then_$2");
+      sigNew = regexpRewriteSignature(sigNew, "(.*)_neq_xby_then_(.*)", "xby_neq_$1_then_$2");
+      sigNew = regexpRewriteSignature(sigNew, "(.*)_neq_yby_then_(.*)", "yby_neq_$1_then_$2");
+      if(!signature.equals(sigNew)) {
+         return loadFragment(sigNew);
       }
 
       return null;
+
+   }
+
+   private static String regexpRewriteSignature(String signature, String match, String replace) {
+      Pattern p = Pattern.compile(match);
+      Matcher m = p.matcher(signature);
+      String output = signature;
+      if (m.find()) {
+         // replace first number with "number" and second number with the first
+         output = m.replaceAll(replace);
+      }
+      return output;
    }
 
 

src/main/java/dk/camelot64/kickc/asm/fragment/aby_le_coby1_then_la1.asm

@@ -0,0 +1,3 @@
+cmp #{coby1}
+bcc {la1}
+beq {la1}

src/main/java/dk/camelot64/kickc/asm/fragment/aby_neq_zpby1_then_la1.asm

@@ -0,0 +1,2 @@
+cmp {zpby1}
+bne {la1}

src/main/java/dk/camelot64/kickc/asm/fragment/coby1_ge_zpby1_then_la1.asm

@@ -0,0 +1,3 @@
+lda #{coby1}
+cmp {zpby1}
+bcs {la1}

src/main/java/dk/camelot64/kickc/asm/fragment/xby_le_coby1_then_la1.asm

@@ -0,0 +1,3 @@
+cpx #{coby1}
+bcc {la1}
+beq {la1}

src/main/java/dk/camelot64/kickc/asm/fragment/xby_neq_zpby1_then_la1.asm

@@ -0,0 +1,2 @@
+cpx {zpby1}
+bne {la1}

src/main/java/dk/camelot64/kickc/asm/fragment/yby_le_coby1_then_la1.asm

@@ -0,0 +1,3 @@
+cpy #{coby1}
+bcc {la1}
+beq {la1}

src/main/java/dk/camelot64/kickc/asm/fragment/yby_neq_zpby1_then_la1.asm

@@ -0,0 +1,2 @@
+cpy {zpby1}
+bne {la1}

src/main/java/dk/camelot64/kickc/asm/fragment/zpby1_ge_zpby2_then_la1.asm

@@ -0,0 +1,3 @@
+lda {zpby1}
+cmp {zpby2}
+bcs {la1}

src/main/java/dk/camelot64/kickc/asm/fragment/zpby1_neq_zpby2_then_la1.asm

@@ -0,0 +1,3 @@
+lda {zpby1}
+cmp {zpby2}
+bne {la1}

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

@@ -83,18 +83,18 @@ public class Pass1GenerateStatementSequence extends KickCBaseVisitor<Object> {
    public Void visitStmtIfElse(KickCParser.StmtIfElseContext ctx) {
       PrePostModifierHandler.addPreModifiers(this, ctx.expr());
       RValue rValue = (RValue) this.visit(ctx.expr());
+      VariableRef notExprVar = getCurrentSymbols().addVariableIntermediate().getRef();
+      sequence.addStatement(new StatementAssignment(notExprVar, null, new Operator("!"), rValue));
       PrePostModifierHandler.addPostModifiers(this, ctx.expr());
-      Label ifJumpLabel = getCurrentSymbols().addLabelIntermediate();
+
       Label elseJumpLabel = getCurrentSymbols().addLabelIntermediate();
-      Statement ifJmpStmt = new StatementConditionalJump(rValue, ifJumpLabel.getRef());
+      Statement ifJmpStmt = new StatementConditionalJump(notExprVar, elseJumpLabel.getRef());
       sequence.addStatement(ifJmpStmt);
-      Statement elseJmpStmt = new StatementJump(elseJumpLabel.getRef());
-      sequence.addStatement(elseJmpStmt);
-      StatementLabel ifJumpTarget = new StatementLabel(ifJumpLabel.getRef());
-      sequence.addStatement(ifJumpTarget);
       this.visit(ctx.stmt(0));
+
       KickCParser.StmtContext elseStmt = ctx.stmt(1);
       if (elseStmt != null) {
+         // There is an else statement - add the else part and any needed labels/jumps
          Label endJumpLabel = getCurrentSymbols().addLabelIntermediate();
          Statement endJmpStmt = new StatementJump(endJumpLabel.getRef());
          sequence.addStatement(endJmpStmt);
@@ -104,6 +104,7 @@ public class Pass1GenerateStatementSequence extends KickCBaseVisitor<Object> {
          StatementLabel endJumpTarget = new StatementLabel(endJumpLabel.getRef());
          sequence.addStatement(endJumpTarget);
       } else {
+         // No else statement - just add the label
          StatementLabel elseJumpTarget = new StatementLabel(elseJumpLabel.getRef());
          sequence.addStatement(elseJumpTarget);
       }

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

@@ -68,8 +68,6 @@ public class Pass2ConditionalJumpSimplification extends Pass2SsaOptimization {
       };
       visitor.visitGraph(getGraph());
       return simpleConditionVars;
-
-
    }
 
 

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

@@ -0,0 +1,105 @@
+package dk.camelot64.kickc.passes;
+
+import dk.camelot64.kickc.icl.*;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Compiler Pass simplifying unary not variables if they reference a comparison that can be inverted
+ */
+public class Pass2UnaryNotSimplification extends Pass2SsaOptimization {
+
+   public Pass2UnaryNotSimplification(Program program) {
+      super(program);
+   }
+
+   /**
+    * Eliminate unary nots if they are the only usage of a reversable comparison
+    */
+   @Override
+   public boolean optimize() {
+      final Map<VariableRef, Integer> usages = countVarUsages();
+      final Map<LValue, StatementAssignment> assignments = getAllAssignments();
+      final List<VariableRef> unusedComparisons = optimizeUnaryNots(assignments, usages);
+      removeAssignments(unusedComparisons);
+      deleteVariables(unusedComparisons);
+      return (unusedComparisons.size() > 0);
+   }
+
+   /**
+    * Examine all unary nots. If they are the only usage of a reversable unary not replace the unary not with the reversed comparison - and eliminate the riginal variable.
+    *
+    * @param assignments Assignments to examine
+    * @param usages      All variable usages
+    * @return Unused comparisons (because they have been replaced with reversed comparisions)
+    */
+   private List<VariableRef> optimizeUnaryNots(final Map<LValue, StatementAssignment> assignments, final Map<VariableRef, Integer> usages) {
+
+      final List<VariableRef> unused = new ArrayList<>();
+      for (StatementAssignment assignment : assignments.values()) {
+         if (assignment.getrValue1() == null
+               && assignment.getOperator() != null
+               && ("!".equals(assignment.getOperator().getOperator()) || "not".equals(assignment.getOperator().getOperator()))
+               && assignment.getrValue2() instanceof VariableRef
+               ) {
+            VariableRef tempVar = (VariableRef) assignment.getrValue2();
+            StatementAssignment tempAssignment = assignments.get(tempVar);
+            if (usages.get(tempVar) == 1 && tempAssignment.getOperator() != null) {
+               switch(tempAssignment.getOperator().getOperator()) {
+                  case "<":
+                     createInverse(">=", assignment, tempAssignment);
+                     unused.add(tempVar);
+                     break;
+                  case ">":
+                     createInverse("<=", assignment, tempAssignment);
+                     unused.add(tempVar);
+                     break;
+                  case "<=":
+                  case "=<":
+                     createInverse(">", assignment, tempAssignment);
+                     unused.add(tempVar);
+                     break;
+                  case ">=":
+                  case "=>":
+                     createInverse("<", assignment, tempAssignment);
+                     unused.add(tempVar);
+                     break;
+                  case "==":
+                     createInverse("!=", assignment, tempAssignment);
+                     unused.add(tempVar);
+                     break;
+                  case "!=":
+                  case "<>":
+                     createInverse("==", assignment, tempAssignment);
+                     unused.add(tempVar);
+                     break;
+                  case "!":
+                  case "not":
+                     createInverse(null, assignment, tempAssignment);
+                     unused.add(tempVar);
+                     break;
+               }
+            }
+         }
+      }
+      return unused;
+   }
+
+   /**
+    * Updates an assignment to be the inverse of the temp assignment.
+    *
+    * @param newOperator The new operator to use
+    * @param assignment The assignment to update
+    * @param tempAssignment The temp assignment to take rValues from.
+    */
+   private void createInverse(String newOperator, StatementAssignment assignment, StatementAssignment tempAssignment) {
+      assignment.setrValue1(tempAssignment.getrValue1());
+      assignment.setOperator(newOperator==null?null:new Operator(newOperator));
+      assignment.setrValue2(tempAssignment.getrValue2());
+      getLog().append("Inversing boolean not "+assignment.toString(getProgram()) +" from "+tempAssignment.toString(getProgram()));
+   }
+
+
+}

src/main/java/dk/camelot64/kickc/test/ref/bresenham.asm

@@ -21,12 +21,7 @@ b1:
   adc #$18
   tax
   cpx #$27
-  bcs b2
-b3:
-  lda $4
-  cmp #$28
-  bcc b1
-b2:
+  bcc b2
   inc $5
   lda $2
   clc
@@ -39,4 +34,7 @@ b2:
   sec
   sbc #$27
   tax
-  jmp b3
+b2:
+  lda $4
+  cmp #$28
+  bcc b1

src/main/java/dk/camelot64/kickc/test/ref/bresenham.cfg

@@ -1,25 +1,25 @@
 @begin: scope:[]  from
   to:@1
-@1: scope:[]  from @3 @begin
-  [0] (byte) y#2 ← phi( @3/(byte) y#4 @begin/(byte) 0 ) [ cursor#3 x#2 e#3 y#2 ]
-  [0] (byte) e#3 ← phi( @3/(byte) e#5 @begin/(byte) 12 ) [ cursor#3 x#2 e#3 y#2 ]
-  [0] (byte) x#2 ← phi( @3/(byte) x#1 @begin/(byte) 0 ) [ cursor#3 x#2 e#3 y#2 ]
-  [0] (byte*) cursor#3 ← phi( @3/(byte*) cursor#5 @begin/(word) 1024 ) [ cursor#3 x#2 e#3 y#2 ]
+@1: scope:[]  from @2 @begin
+  [0] (byte) y#2 ← phi( @2/(byte) y#4 @begin/(byte) 0 ) [ cursor#3 x#2 e#3 y#2 ]
+  [0] (byte) e#3 ← phi( @2/(byte) e#5 @begin/(byte) 12 ) [ cursor#3 x#2 e#3 y#2 ]
+  [0] (byte) x#2 ← phi( @2/(byte) x#1 @begin/(byte) 0 ) [ cursor#3 x#2 e#3 y#2 ]
+  [0] (byte*) cursor#3 ← phi( @2/(byte*) cursor#5 @begin/(word) 1024 ) [ cursor#3 x#2 e#3 y#2 ]
   [1] *((byte*) cursor#3) ← (byte) 81 [ cursor#3 x#2 e#3 y#2 ]
   [2] (byte) x#1 ← (byte) x#2 + (byte) 1 [ x#1 cursor#3 e#3 y#2 ]
-  [3] (byte*) cursor#1 ← (byte*) cursor#3 + (byte) 1 [ x#1 e#3 cursor#1 y#2 ]
-  [4] (byte) e#1 ← (byte) e#3 + (byte) 24 [ x#1 e#1 cursor#1 y#2 ]
-  [5] if((byte) 39<(byte) e#1) goto @2 [ x#1 e#1 cursor#1 y#2 ]
+  [3] (byte*) cursor#1 ← (byte*) cursor#3 + (byte) 1 [ x#1 e#3 y#2 cursor#1 ]
+  [4] (byte) e#1 ← (byte) e#3 + (byte) 24 [ x#1 e#1 y#2 cursor#1 ]
+  [5] if((byte) 39>=(byte) e#1) goto @2 [ x#1 e#1 y#2 cursor#1 ]
   to:@3
-@3: scope:[]  from @1 @2
-  [6] (byte) y#4 ← phi( @1/(byte) y#2 @2/(byte) y#1 ) [ cursor#5 x#1 e#5 y#4 ]
-  [6] (byte) e#5 ← phi( @1/(byte) e#1 @2/(byte) e#2 ) [ cursor#5 x#1 e#5 y#4 ]
-  [6] (byte*) cursor#5 ← phi( @1/(byte*) cursor#1 @2/(byte*) cursor#2 ) [ cursor#5 x#1 e#5 y#4 ]
-  [7] if((byte) x#1<(byte) 40) goto @1 [ cursor#5 x#1 e#5 y#4 ]
+@3: scope:[]  from @1
+  [6] (byte) y#1 ← (byte) y#2 + (byte) 1 [ x#1 e#1 cursor#1 y#1 ]
+  [7] (byte*) cursor#2 ← (byte*) cursor#1 + (byte) 40 [ x#1 e#1 cursor#2 y#1 ]
+  [8] (byte) e#2 ← (byte) e#1 - (byte) 39 [ x#1 cursor#2 e#2 y#1 ]
+  to:@2
+@2: scope:[]  from @1 @3
+  [9] (byte) y#4 ← phi( @1/(byte) y#2 @3/(byte) y#1 ) [ cursor#5 x#1 e#5 y#4 ]
+  [9] (byte) e#5 ← phi( @1/(byte) e#1 @3/(byte) e#2 ) [ cursor#5 x#1 e#5 y#4 ]
+  [9] (byte*) cursor#5 ← phi( @1/(byte*) cursor#1 @3/(byte*) cursor#2 ) [ cursor#5 x#1 e#5 y#4 ]
+  [10] if((byte) x#1<(byte) 40) goto @1 [ cursor#5 x#1 e#5 y#4 ]
   to:@end
-@end: scope:[]  from @3
-@2: scope:[]  from @1
-  [8] (byte) y#1 ← (byte) y#2 + (byte) 1 [ x#1 e#1 cursor#1 y#1 ]
-  [9] (byte*) cursor#2 ← (byte*) cursor#1 + (byte) 40 [ x#1 e#1 cursor#2 y#1 ]
-  [10] (byte) e#2 ← (byte) e#1 - (byte) 39 [ x#1 cursor#2 e#2 y#1 ]
-  to:@3
+@end: scope:[]  from @2

src/main/java/dk/camelot64/kickc/test/ref/ifmin.asm

@@ -3,13 +3,11 @@ main: {
     ldx #$0
   b1:
     cpx #$32
-    bcc b2
-  b3:
+    bcs b2
+    stx $400
+  b2:
     inx
     cpx #$64
     bcc b1
     rts
-  b2:
-    stx $400
-    jmp b3
 }

src/main/java/dk/camelot64/kickc/test/ref/ifmin.cfg

@@ -4,17 +4,17 @@
 @end: scope:[]  from @begin
 main: scope:[main]  from @begin
   to:main::@1
-main::@1: scope:[main]  from main main::@3
-  [1] (byte) main::i#2 ← phi( main/(byte) 0 main::@3/(byte) main::i#1 ) [ main::i#2 ]
-  [2] if((byte) main::i#2<(byte) 50) goto main::@2 [ main::i#2 ]
+main::@1: scope:[main]  from main main::@2
+  [1] (byte) main::i#2 ← phi( main/(byte) 0 main::@2/(byte) main::i#1 ) [ main::i#2 ]
+  [2] if((byte) main::i#2>=(byte) 50) goto main::@2 [ main::i#2 ]
   to:main::@3
-main::@3: scope:[main]  from main::@1 main::@2
-  [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ]
-  [4] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ]
+main::@3: scope:[main]  from main::@1
+  [3] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ]
+  to:main::@2
+main::@2: scope:[main]  from main::@1 main::@3
+  [4] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ]
+  [5] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ]
   to:main::@return
-main::@return: scope:[main]  from main::@3
-  [5] return  [ ]
+main::@return: scope:[main]  from main::@2
+  [6] return  [ ]
   to:@return
-main::@2: scope:[main]  from main::@1
-  [6] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ]
-  to:main::@3

src/main/java/dk/camelot64/kickc/test/ref/ifmin.log

@@ -19,14 +19,13 @@ PROGRAM
   (byte) main::i ← (byte) 0
 main::@1:
   (boolean~) main::$0 ← (byte) main::i < (byte) 50
-  if((boolean~) main::$0) goto main::@2
-  goto main::@3
-main::@2:
+  (boolean~) main::$1 ← ! (boolean~) main::$0
+  if((boolean~) main::$1) goto main::@2
   *((byte*) SCREEN) ← (byte) main::i
-main::@3:
+main::@2:
   (byte) main::i ← ++ (byte) main::i
-  (boolean~) main::$1 ← (byte) main::i < (byte) 100
-  if((boolean~) main::$1) goto main::@1
+  (boolean~) main::$2 ← (byte) main::i < (byte) 100
+  if((boolean~) main::$2) goto main::@1
 main::@return:
   return 
   endproc // main()
@@ -37,9 +36,9 @@ SYMBOLS
 (void()) main()
 (boolean~) main::$0
 (boolean~) main::$1
+(boolean~) main::$2
 (label) main::@1
 (label) main::@2
-(label) main::@3
 (label) main::@return
 (byte) main::i
 
@@ -51,25 +50,22 @@ INITIAL CONTROL FLOW GRAPH
 main: scope:[main]  from
   (byte) main::i ← (byte) 0
   to:main::@1
-main::@1: scope:[main]  from main main::@3
+main::@1: scope:[main]  from main main::@2
   (boolean~) main::$0 ← (byte) main::i < (byte) 50
-  if((boolean~) main::$0) goto main::@2
-  to:main::@4
-main::@2: scope:[main]  from main::@1 main::@5
-  *((byte*) SCREEN) ← (byte) main::i
+  (boolean~) main::$1 ← ! (boolean~) main::$0
+  if((boolean~) main::$1) goto main::@2
   to:main::@3
-main::@4: scope:[main]  from main::@1
-  to:main::@3
-main::@3: scope:[main]  from main::@2 main::@4
+main::@2: scope:[main]  from main::@1 main::@3
   (byte) main::i ← ++ (byte) main::i
-  (boolean~) main::$1 ← (byte) main::i < (byte) 100
-  if((boolean~) main::$1) goto main::@1
-  to:main::@6
-main::@5: scope:[main]  from
+  (boolean~) main::$2 ← (byte) main::i < (byte) 100
+  if((boolean~) main::$2) goto main::@1
+  to:main::@4
+main::@3: scope:[main]  from main::@1
+  *((byte*) SCREEN) ← (byte) main::i
   to:main::@2
-main::@6: scope:[main]  from main::@3
+main::@4: scope:[main]  from main::@2
   to:main::@return
-main::@return: scope:[main]  from main::@6
+main::@return: scope:[main]  from main::@4
   return 
   to:@return
 @1: scope:[]  from @begin
@@ -77,8 +73,6 @@ main::@return: scope:[main]  from main::@6
 @end: scope:[]  from @1
 
 Removing empty block main::@4
-Removing empty block main::@5
-Removing empty block main::@6
 Removing empty block @1
 CONTROL FLOW GRAPH
 @begin: scope:[]  from
@@ -88,19 +82,20 @@ CONTROL FLOW GRAPH
 main: scope:[main]  from
   (byte) main::i ← (byte) 0
   to:main::@1
-main::@1: scope:[main]  from main main::@3
+main::@1: scope:[main]  from main main::@2
   (boolean~) main::$0 ← (byte) main::i < (byte) 50
-  if((boolean~) main::$0) goto main::@2
+  (boolean~) main::$1 ← ! (boolean~) main::$0
+  if((boolean~) main::$1) goto main::@2
   to:main::@3
-main::@2: scope:[main]  from main::@1
-  *((byte*) SCREEN) ← (byte) main::i
-  to:main::@3
-main::@3: scope:[main]  from main::@1 main::@2
+main::@2: scope:[main]  from main::@1 main::@3
   (byte) main::i ← ++ (byte) main::i
-  (boolean~) main::$1 ← (byte) main::i < (byte) 100
-  if((boolean~) main::$1) goto main::@1
+  (boolean~) main::$2 ← (byte) main::i < (byte) 100
+  if((boolean~) main::$2) goto main::@1
   to:main::@return
-main::@return: scope:[main]  from main::@3
+main::@3: scope:[main]  from main::@1
+  *((byte*) SCREEN) ← (byte) main::i
+  to:main::@2
+main::@return: scope:[main]  from main::@2
   return 
   to:@return
 @end: scope:[]  from @begin
@@ -117,19 +112,20 @@ CONTROL FLOW GRAPH WITH ASSIGNMENT CALL
 main: scope:[main]  from @begin
   (byte) main::i ← (byte) 0
   to:main::@1
-main::@1: scope:[main]  from main main::@3
+main::@1: scope:[main]  from main main::@2
   (boolean~) main::$0 ← (byte) main::i < (byte) 50
-  if((boolean~) main::$0) goto main::@2
+  (boolean~) main::$1 ← ! (boolean~) main::$0
+  if((boolean~) main::$1) goto main::@2
   to:main::@3
-main::@2: scope:[main]  from main::@1
-  *((byte*) SCREEN) ← (byte) main::i
-  to:main::@3
-main::@3: scope:[main]  from main::@1 main::@2
+main::@2: scope:[main]  from main::@1 main::@3
   (byte) main::i ← ++ (byte) main::i
-  (boolean~) main::$1 ← (byte) main::i < (byte) 100
-  if((boolean~) main::$1) goto main::@1
+  (boolean~) main::$2 ← (byte) main::i < (byte) 100
+  if((boolean~) main::$2) goto main::@1
   to:main::@return
-main::@return: scope:[main]  from main::@3
+main::@3: scope:[main]  from main::@1
+  *((byte*) SCREEN) ← (byte) main::i
+  to:main::@2
+main::@return: scope:[main]  from main::@2
   return 
   to:@return
 @end: scope:[]  from @2
@@ -148,25 +144,26 @@ main: scope:[main]  from @begin
   (byte*) SCREEN#3 ← phi( @begin/(byte*) SCREEN#0 )
   (byte) main::i#0 ← (byte) 0
   to:main::@1
-main::@1: scope:[main]  from main main::@3
-  (byte*) SCREEN#2 ← phi( main/(byte*) SCREEN#3 main::@3/(byte*) SCREEN#4 )
-  (byte) main::i#2 ← phi( main/(byte) main::i#0 main::@3/(byte) main::i#1 )
+main::@1: scope:[main]  from main main::@2
+  (byte*) SCREEN#2 ← phi( main/(byte*) SCREEN#3 main::@2/(byte*) SCREEN#4 )
+  (byte) main::i#2 ← phi( main/(byte) main::i#0 main::@2/(byte) main::i#1 )
   (boolean~) main::$0 ← (byte) main::i#2 < (byte) 50
-  if((boolean~) main::$0) goto main::@2
+  (boolean~) main::$1 ← ! (boolean~) main::$0
+  if((boolean~) main::$1) goto main::@2
   to:main::@3
-main::@2: scope:[main]  from main::@1
-  (byte*) SCREEN#1 ← phi( main::@1/(byte*) SCREEN#2 )
-  (byte) main::i#3 ← phi( main::@1/(byte) main::i#2 )
-  *((byte*) SCREEN#1) ← (byte) main::i#3
-  to:main::@3
-main::@3: scope:[main]  from main::@1 main::@2
-  (byte*) SCREEN#4 ← phi( main::@1/(byte*) SCREEN#2 main::@2/(byte*) SCREEN#1 )
-  (byte) main::i#4 ← phi( main::@1/(byte) main::i#2 main::@2/(byte) main::i#3 )
-  (byte) main::i#1 ← ++ (byte) main::i#4
-  (boolean~) main::$1 ← (byte) main::i#1 < (byte) 100
-  if((boolean~) main::$1) goto main::@1
+main::@2: scope:[main]  from main::@1 main::@3
+  (byte*) SCREEN#4 ← phi( main::@1/(byte*) SCREEN#2 main::@3/(byte*) SCREEN#1 )
+  (byte) main::i#3 ← phi( main::@1/(byte) main::i#2 main::@3/(byte) main::i#4 )
+  (byte) main::i#1 ← ++ (byte) main::i#3
+  (boolean~) main::$2 ← (byte) main::i#1 < (byte) 100
+  if((boolean~) main::$2) goto main::@1
   to:main::@return
-main::@return: scope:[main]  from main::@3
+main::@3: scope:[main]  from main::@1
+  (byte*) SCREEN#1 ← phi( main::@1/(byte*) SCREEN#2 )
+  (byte) main::i#4 ← phi( main::@1/(byte) main::i#2 )
+  *((byte*) SCREEN#1) ← (byte) main::i#4
+  to:main::@2
+main::@return: scope:[main]  from main::@2
   return 
   to:@return
 @end: scope:[]  from @2
@@ -182,25 +179,26 @@ main: scope:[main]  from @begin
   (byte*) SCREEN#3 ← phi( @begin/(byte*) SCREEN#0 )
   (byte) main::i#0 ← (byte) 0
   to:main::@1
-main::@1: scope:[main]  from main main::@3
-  (byte*) SCREEN#2 ← phi( main/(byte*) SCREEN#3 main::@3/(byte*) SCREEN#4 )
-  (byte) main::i#2 ← phi( main/(byte) main::i#0 main::@3/(byte) main::i#1 )
+main::@1: scope:[main]  from main main::@2
+  (byte*) SCREEN#2 ← phi( main/(byte*) SCREEN#3 main::@2/(byte*) SCREEN#4 )
+  (byte) main::i#2 ← phi( main/(byte) main::i#0 main::@2/(byte) main::i#1 )
   (boolean~) main::$0 ← (byte) main::i#2 < (byte) 50
-  if((boolean~) main::$0) goto main::@2
+  (boolean~) main::$1 ← ! (boolean~) main::$0
+  if((boolean~) main::$1) goto main::@2
   to:main::@3
-main::@2: scope:[main]  from main::@1
-  (byte*) SCREEN#1 ← phi( main::@1/(byte*) SCREEN#2 )
-  (byte) main::i#3 ← phi( main::@1/(byte) main::i#2 )
-  *((byte*) SCREEN#1) ← (byte) main::i#3
-  to:main::@3
-main::@3: scope:[main]  from main::@1 main::@2
-  (byte*) SCREEN#4 ← phi( main::@1/(byte*) SCREEN#2 main::@2/(byte*) SCREEN#1 )
-  (byte) main::i#4 ← phi( main::@1/(byte) main::i#2 main::@2/(byte) main::i#3 )
-  (byte) main::i#1 ← ++ (byte) main::i#4
-  (boolean~) main::$1 ← (byte) main::i#1 < (byte) 100
-  if((boolean~) main::$1) goto main::@1
+main::@2: scope:[main]  from main::@1 main::@3
+  (byte*) SCREEN#4 ← phi( main::@1/(byte*) SCREEN#2 main::@3/(byte*) SCREEN#1 )
+  (byte) main::i#3 ← phi( main::@1/(byte) main::i#2 main::@3/(byte) main::i#4 )
+  (byte) main::i#1 ← ++ (byte) main::i#3
+  (boolean~) main::$2 ← (byte) main::i#1 < (byte) 100
+  if((boolean~) main::$2) goto main::@1
   to:main::@return
-main::@return: scope:[main]  from main::@3
+main::@3: scope:[main]  from main::@1
+  (byte*) SCREEN#1 ← phi( main::@1/(byte*) SCREEN#2 )
+  (byte) main::i#4 ← phi( main::@1/(byte) main::i#2 )
+  *((byte*) SCREEN#1) ← (byte) main::i#4
+  to:main::@2
+main::@return: scope:[main]  from main::@2
   return 
   to:@return
 @end: scope:[]  from @2
@@ -216,25 +214,26 @@ main: scope:[main]  from @begin
   (byte*) SCREEN#3 ← phi( @begin/(byte*) SCREEN#0 )
   (byte) main::i#0 ← (byte) 0
   to:main::@1
-main::@1: scope:[main]  from main main::@3
-  (byte*) SCREEN#2 ← phi( main/(byte*) SCREEN#3 main::@3/(byte*) SCREEN#4 )
-  (byte) main::i#2 ← phi( main/(byte) main::i#0 main::@3/(byte) main::i#1 )
+main::@1: scope:[main]  from main main::@2
+  (byte*) SCREEN#2 ← phi( main/(byte*) SCREEN#3 main::@2/(byte*) SCREEN#4 )
+  (byte) main::i#2 ← phi( main/(byte) main::i#0 main::@2/(byte) main::i#1 )
   (boolean~) main::$0 ← (byte) main::i#2 < (byte) 50
-  if((boolean~) main::$0) goto main::@2
+  (boolean~) main::$1 ← ! (boolean~) main::$0
+  if((boolean~) main::$1) goto main::@2
   to:main::@3
-main::@2: scope:[main]  from main::@1
-  (byte*) SCREEN#1 ← phi( main::@1/(byte*) SCREEN#2 )
-  (byte) main::i#3 ← phi( main::@1/(byte) main::i#2 )
-  *((byte*) SCREEN#1) ← (byte) main::i#3
-  to:main::@3
-main::@3: scope:[main]  from main::@1 main::@2
-  (byte*) SCREEN#4 ← phi( main::@1/(byte*) SCREEN#2 main::@2/(byte*) SCREEN#1 )
-  (byte) main::i#4 ← phi( main::@1/(byte) main::i#2 main::@2/(byte) main::i#3 )
-  (byte) main::i#1 ← ++ (byte) main::i#4
-  (boolean~) main::$1 ← (byte) main::i#1 < (byte) 100
-  if((boolean~) main::$1) goto main::@1
+main::@2: scope:[main]  from main::@1 main::@3
+  (byte*) SCREEN#4 ← phi( main::@1/(byte*) SCREEN#2 main::@3/(byte*) SCREEN#1 )
+  (byte) main::i#3 ← phi( main::@1/(byte) main::i#2 main::@3/(byte) main::i#4 )
+  (byte) main::i#1 ← ++ (byte) main::i#3
+  (boolean~) main::$2 ← (byte) main::i#1 < (byte) 100
+  if((boolean~) main::$2) goto main::@1
   to:main::@return
-main::@return: scope:[main]  from main::@3
+main::@3: scope:[main]  from main::@1
+  (byte*) SCREEN#1 ← phi( main::@1/(byte*) SCREEN#2 )
+  (byte) main::i#4 ← phi( main::@1/(byte) main::i#2 )
+  *((byte*) SCREEN#1) ← (byte) main::i#4
+  to:main::@2
+main::@return: scope:[main]  from main::@2
   return 
   to:@return
 @end: scope:[]  from @begin
@@ -249,30 +248,63 @@ CONTROL FLOW GRAPH
 main: scope:[main]  from @begin
   (byte*) SCREEN#3 ← phi( @begin/(word) 1024 )
   to:main::@1
-main::@1: scope:[main]  from main main::@3
-  (byte*) SCREEN#2 ← phi( main/(byte*) SCREEN#3 main::@3/(byte*) SCREEN#4 )
-  (byte) main::i#2 ← phi( main/(byte) 0 main::@3/(byte) main::i#1 )
+main::@1: scope:[main]  from main main::@2
+  (byte*) SCREEN#2 ← phi( main/(byte*) SCREEN#3 main::@2/(byte*) SCREEN#4 )
+  (byte) main::i#2 ← phi( main/(byte) 0 main::@2/(byte) main::i#1 )
   (boolean~) main::$0 ← (byte) main::i#2 < (byte) 50
-  if((boolean~) main::$0) goto main::@2
+  (boolean~) main::$1 ← ! (boolean~) main::$0
+  if((boolean~) main::$1) goto main::@2
   to:main::@3
-main::@2: scope:[main]  from main::@1
-  (byte*) SCREEN#1 ← phi( main::@1/(byte*) SCREEN#2 )
-  (byte) main::i#3 ← phi( main::@1/(byte) main::i#2 )
-  *((byte*) SCREEN#1) ← (byte) main::i#3
-  to:main::@3
-main::@3: scope:[main]  from main::@1 main::@2
-  (byte*) SCREEN#4 ← phi( main::@1/(byte*) SCREEN#2 main::@2/(byte*) SCREEN#1 )
-  (byte) main::i#4 ← phi( main::@1/(byte) main::i#2 main::@2/(byte) main::i#3 )
-  (byte) main::i#1 ← ++ (byte) main::i#4
-  (boolean~) main::$1 ← (byte) main::i#1 < (byte) 100
-  if((boolean~) main::$1) goto main::@1
+main::@2: scope:[main]  from main::@1 main::@3
+  (byte*) SCREEN#4 ← phi( main::@1/(byte*) SCREEN#2 main::@3/(byte*) SCREEN#1 )
+  (byte) main::i#3 ← phi( main::@1/(byte) main::i#2 main::@3/(byte) main::i#4 )
+  (byte) main::i#1 ← ++ (byte) main::i#3
+  (boolean~) main::$2 ← (byte) main::i#1 < (byte) 100
+  if((boolean~) main::$2) goto main::@1
   to:main::@return
-main::@return: scope:[main]  from main::@3
+main::@3: scope:[main]  from main::@1
+  (byte*) SCREEN#1 ← phi( main::@1/(byte*) SCREEN#2 )
+  (byte) main::i#4 ← phi( main::@1/(byte) main::i#2 )
+  *((byte*) SCREEN#1) ← (byte) main::i#4
+  to:main::@2
+main::@return: scope:[main]  from main::@2
   return 
   to:@return
 @end: scope:[]  from @begin
 
-Alias (byte) main::i#2 = (byte) main::i#3 
+Inversing boolean not (boolean~) main::$1 ← (byte) main::i#2 >= (byte) 50 from (boolean~) main::$0 ← (byte) main::i#2 < (byte) 50
+Succesful SSA optimization Pass2UnaryNotSimplification
+CONTROL FLOW GRAPH
+@begin: scope:[]  from
+  call main param-assignment
+  to:@end
+main: scope:[main]  from @begin
+  (byte*) SCREEN#3 ← phi( @begin/(word) 1024 )
+  to:main::@1
+main::@1: scope:[main]  from main main::@2
+  (byte*) SCREEN#2 ← phi( main/(byte*) SCREEN#3 main::@2/(byte*) SCREEN#4 )
+  (byte) main::i#2 ← phi( main/(byte) 0 main::@2/(byte) main::i#1 )
+  (boolean~) main::$1 ← (byte) main::i#2 >= (byte) 50
+  if((boolean~) main::$1) goto main::@2
+  to:main::@3
+main::@2: scope:[main]  from main::@1 main::@3
+  (byte*) SCREEN#4 ← phi( main::@1/(byte*) SCREEN#2 main::@3/(byte*) SCREEN#1 )
+  (byte) main::i#3 ← phi( main::@1/(byte) main::i#2 main::@3/(byte) main::i#4 )
+  (byte) main::i#1 ← ++ (byte) main::i#3
+  (boolean~) main::$2 ← (byte) main::i#1 < (byte) 100
+  if((boolean~) main::$2) goto main::@1
+  to:main::@return
+main::@3: scope:[main]  from main::@1
+  (byte*) SCREEN#1 ← phi( main::@1/(byte*) SCREEN#2 )
+  (byte) main::i#4 ← phi( main::@1/(byte) main::i#2 )
+  *((byte*) SCREEN#1) ← (byte) main::i#4
+  to:main::@2
+main::@return: scope:[main]  from main::@2
+  return 
+  to:@return
+@end: scope:[]  from @begin
+
+Alias (byte) main::i#2 = (byte) main::i#4 
 Alias (byte*) SCREEN#1 = (byte*) SCREEN#2 
 Succesful SSA optimization Pass2AliasElimination
 CONTROL FLOW GRAPH
@@ -282,29 +314,29 @@ CONTROL FLOW GRAPH
 main: scope:[main]  from @begin
   (byte*) SCREEN#3 ← phi( @begin/(word) 1024 )
   to:main::@1
-main::@1: scope:[main]  from main main::@3
-  (byte*) SCREEN#1 ← phi( main/(byte*) SCREEN#3 main::@3/(byte*) SCREEN#4 )
-  (byte) main::i#2 ← phi( main/(byte) 0 main::@3/(byte) main::i#1 )
-  (boolean~) main::$0 ← (byte) main::i#2 < (byte) 50
-  if((boolean~) main::$0) goto main::@2
+main::@1: scope:[main]  from main main::@2
+  (byte*) SCREEN#1 ← phi( main/(byte*) SCREEN#3 main::@2/(byte*) SCREEN#4 )
+  (byte) main::i#2 ← phi( main/(byte) 0 main::@2/(byte) main::i#1 )
+  (boolean~) main::$1 ← (byte) main::i#2 >= (byte) 50
+  if((boolean~) main::$1) goto main::@2
   to:main::@3
-main::@2: scope:[main]  from main::@1
-  *((byte*) SCREEN#1) ← (byte) main::i#2
-  to:main::@3
-main::@3: scope:[main]  from main::@1 main::@2
-  (byte*) SCREEN#4 ← phi( main::@1/(byte*) SCREEN#1 main::@2/(byte*) SCREEN#1 )
-  (byte) main::i#4 ← phi( main::@1/(byte) main::i#2 main::@2/(byte) main::i#2 )
-  (byte) main::i#1 ← ++ (byte) main::i#4
-  (boolean~) main::$1 ← (byte) main::i#1 < (byte) 100
-  if((boolean~) main::$1) goto main::@1
+main::@2: scope:[main]  from main::@1 main::@3
+  (byte*) SCREEN#4 ← phi( main::@1/(byte*) SCREEN#1 main::@3/(byte*) SCREEN#1 )
+  (byte) main::i#3 ← phi( main::@1/(byte) main::i#2 main::@3/(byte) main::i#2 )
+  (byte) main::i#1 ← ++ (byte) main::i#3
+  (boolean~) main::$2 ← (byte) main::i#1 < (byte) 100
+  if((boolean~) main::$2) goto main::@1
   to:main::@return
-main::@return: scope:[main]  from main::@3
+main::@3: scope:[main]  from main::@1
+  *((byte*) SCREEN#1) ← (byte) main::i#2
+  to:main::@2
+main::@return: scope:[main]  from main::@2
   return 
   to:@return
 @end: scope:[]  from @begin
 
 Redundant Phi (byte*) SCREEN#3 (word) 1024
-Redundant Phi (byte) main::i#4 (byte) main::i#2
+Redundant Phi (byte) main::i#3 (byte) main::i#2
 Redundant Phi (byte*) SCREEN#4 (byte*) SCREEN#1
 Succesful SSA optimization Pass2RedundantPhiElimination
 CONTROL FLOW GRAPH
@@ -313,21 +345,21 @@ CONTROL FLOW GRAPH
   to:@end
 main: scope:[main]  from @begin
   to:main::@1
-main::@1: scope:[main]  from main main::@3
-  (byte*) SCREEN#1 ← phi( main/(word) 1024 main::@3/(byte*) SCREEN#1 )
-  (byte) main::i#2 ← phi( main/(byte) 0 main::@3/(byte) main::i#1 )
-  (boolean~) main::$0 ← (byte) main::i#2 < (byte) 50
-  if((boolean~) main::$0) goto main::@2
+main::@1: scope:[main]  from main main::@2
+  (byte*) SCREEN#1 ← phi( main/(word) 1024 main::@2/(byte*) SCREEN#1 )
+  (byte) main::i#2 ← phi( main/(byte) 0 main::@2/(byte) main::i#1 )
+  (boolean~) main::$1 ← (byte) main::i#2 >= (byte) 50
+  if((boolean~) main::$1) goto main::@2
   to:main::@3
-main::@2: scope:[main]  from main::@1
-  *((byte*) SCREEN#1) ← (byte) main::i#2
-  to:main::@3
-main::@3: scope:[main]  from main::@1 main::@2
+main::@2: scope:[main]  from main::@1 main::@3
   (byte) main::i#1 ← ++ (byte) main::i#2
-  (boolean~) main::$1 ← (byte) main::i#1 < (byte) 100
-  if((boolean~) main::$1) goto main::@1
+  (boolean~) main::$2 ← (byte) main::i#1 < (byte) 100
+  if((boolean~) main::$2) goto main::@1
   to:main::@return
-main::@return: scope:[main]  from main::@3
+main::@3: scope:[main]  from main::@1
+  *((byte*) SCREEN#1) ← (byte) main::i#2
+  to:main::@2
+main::@return: scope:[main]  from main::@2
   return 
   to:@return
 @end: scope:[]  from @begin
@@ -340,27 +372,27 @@ CONTROL FLOW GRAPH
   to:@end
 main: scope:[main]  from @begin
   to:main::@1
-main::@1: scope:[main]  from main main::@3
+main::@1: scope:[main]  from main main::@2
   (byte*) SCREEN#1 ← phi( main/(word) 1024 )
-  (byte) main::i#2 ← phi( main/(byte) 0 main::@3/(byte) main::i#1 )
-  (boolean~) main::$0 ← (byte) main::i#2 < (byte) 50
-  if((boolean~) main::$0) goto main::@2
+  (byte) main::i#2 ← phi( main/(byte) 0 main::@2/(byte) main::i#1 )
+  (boolean~) main::$1 ← (byte) main::i#2 >= (byte) 50
+  if((boolean~) main::$1) goto main::@2
   to:main::@3
-main::@2: scope:[main]  from main::@1
-  *((byte*) SCREEN#1) ← (byte) main::i#2
-  to:main::@3
-main::@3: scope:[main]  from main::@1 main::@2
+main::@2: scope:[main]  from main::@1 main::@3
   (byte) main::i#1 ← ++ (byte) main::i#2
-  (boolean~) main::$1 ← (byte) main::i#1 < (byte) 100
-  if((boolean~) main::$1) goto main::@1
+  (boolean~) main::$2 ← (byte) main::i#1 < (byte) 100
+  if((boolean~) main::$2) goto main::@1
   to:main::@return
-main::@return: scope:[main]  from main::@3
+main::@3: scope:[main]  from main::@1
+  *((byte*) SCREEN#1) ← (byte) main::i#2
+  to:main::@2
+main::@return: scope:[main]  from main::@2
   return 
   to:@return
 @end: scope:[]  from @begin
 
-Simple Condition (boolean~) main::$0 if((byte) main::i#2<(byte) 50) goto main::@2
-Simple Condition (boolean~) main::$1 if((byte) main::i#1<(byte) 100) goto main::@1
+Simple Condition (boolean~) main::$1 if((byte) main::i#2>=(byte) 50) goto main::@2
+Simple Condition (boolean~) main::$2 if((byte) main::i#1<(byte) 100) goto main::@1
 Succesful SSA optimization Pass2ConditionalJumpSimplification
 CONTROL FLOW GRAPH
 @begin: scope:[]  from
@@ -368,19 +400,19 @@ CONTROL FLOW GRAPH
   to:@end
 main: scope:[main]  from @begin
   to:main::@1
-main::@1: scope:[main]  from main main::@3
+main::@1: scope:[main]  from main main::@2
   (byte*) SCREEN#1 ← phi( main/(word) 1024 )
-  (byte) main::i#2 ← phi( main/(byte) 0 main::@3/(byte) main::i#1 )
-  if((byte) main::i#2<(byte) 50) goto main::@2
+  (byte) main::i#2 ← phi( main/(byte) 0 main::@2/(byte) main::i#1 )
+  if((byte) main::i#2>=(byte) 50) goto main::@2
   to:main::@3
-main::@2: scope:[main]  from main::@1
-  *((byte*) SCREEN#1) ← (byte) main::i#2
-  to:main::@3
-main::@3: scope:[main]  from main::@1 main::@2
+main::@2: scope:[main]  from main::@1 main::@3
   (byte) main::i#1 ← ++ (byte) main::i#2
   if((byte) main::i#1<(byte) 100) goto main::@1
   to:main::@return
-main::@return: scope:[main]  from main::@3
+main::@3: scope:[main]  from main::@1
+  *((byte*) SCREEN#1) ← (byte) main::i#2
+  to:main::@2
+main::@return: scope:[main]  from main::@2
   return 
   to:@return
 @end: scope:[]  from @begin
@@ -393,25 +425,25 @@ CONTROL FLOW GRAPH
   to:@end
 main: scope:[main]  from @begin
   to:main::@1
-main::@1: scope:[main]  from main main::@3
-  (byte) main::i#2 ← phi( main/(byte) 0 main::@3/(byte) main::i#1 )
-  if((byte) main::i#2<(byte) 50) goto main::@2
+main::@1: scope:[main]  from main main::@2
+  (byte) main::i#2 ← phi( main/(byte) 0 main::@2/(byte) main::i#1 )
+  if((byte) main::i#2>=(byte) 50) goto main::@2
   to:main::@3
-main::@2: scope:[main]  from main::@1
-  *((word) 1024) ← (byte) main::i#2
-  to:main::@3
-main::@3: scope:[main]  from main::@1 main::@2
+main::@2: scope:[main]  from main::@1 main::@3
   (byte) main::i#1 ← ++ (byte) main::i#2
   if((byte) main::i#1<(byte) 100) goto main::@1
   to:main::@return
-main::@return: scope:[main]  from main::@3
+main::@3: scope:[main]  from main::@1
+  *((word) 1024) ← (byte) main::i#2
+  to:main::@2
+main::@return: scope:[main]  from main::@2
   return 
   to:@return
 @end: scope:[]  from @begin
 
-Block Sequence Planned @begin @end main main::@1 main::@3 main::@return main::@2 
-Added new block during phi lifting main::@7(between main::@3 and main::@1)
-Block Sequence Planned @begin @end main main::@1 main::@3 main::@return main::@7 main::@2 
+Block Sequence Planned @begin @end main main::@1 main::@3 main::@2 main::@return 
+Added new block during phi lifting main::@5(between main::@2 and main::@1)
+Block Sequence Planned @begin @end main main::@1 main::@3 main::@2 main::@return main::@5 
 CONTROL FLOW GRAPH - PHI LIFTED
 @begin: scope:[]  from
   call main param-assignment
@@ -419,23 +451,23 @@ CONTROL FLOW GRAPH - PHI LIFTED
 @end: scope:[]  from @begin
 main: scope:[main]  from @begin
   to:main::@1
-main::@1: scope:[main]  from main main::@7
-  (byte) main::i#2 ← phi( main/(byte) 0 main::@7/(byte~) main::i#5 )
-  if((byte) main::i#2<(byte) 50) goto main::@2
+main::@1: scope:[main]  from main main::@5
+  (byte) main::i#2 ← phi( main/(byte) 0 main::@5/(byte~) main::i#5 )
+  if((byte) main::i#2>=(byte) 50) goto main::@2
   to:main::@3
-main::@3: scope:[main]  from main::@1 main::@2
+main::@3: scope:[main]  from main::@1
+  *((word) 1024) ← (byte) main::i#2
+  to:main::@2
+main::@2: scope:[main]  from main::@1 main::@3
   (byte) main::i#1 ← ++ (byte) main::i#2
-  if((byte) main::i#1<(byte) 100) goto main::@7
+  if((byte) main::i#1<(byte) 100) goto main::@5
   to:main::@return
-main::@return: scope:[main]  from main::@3
+main::@return: scope:[main]  from main::@2
   return 
   to:@return
-main::@7: scope:[main]  from main::@3
+main::@5: scope:[main]  from main::@2
   (byte~) main::i#5 ← (byte) main::i#1
   to:main::@1
-main::@2: scope:[main]  from main::@1
-  *((word) 1024) ← (byte) main::i#2
-  to:main::@3
 
 Propagating live ranges...
 CONTROL FLOW GRAPH - LIVE RANGES
@@ -445,29 +477,29 @@ CONTROL FLOW GRAPH - LIVE RANGES
 @end: scope:[]  from @begin
 main: scope:[main]  from @begin
   to:main::@1
-main::@1: scope:[main]  from main main::@7
-  [1] (byte) main::i#2 ← phi( main/(byte) 0 main::@7/(byte~) main::i#5 ) [ main::i#2 ]
-  [2] if((byte) main::i#2<(byte) 50) goto main::@2 [ main::i#2 ]
+main::@1: scope:[main]  from main main::@5
+  [1] (byte) main::i#2 ← phi( main/(byte) 0 main::@5/(byte~) main::i#5 ) [ main::i#2 ]
+  [2] if((byte) main::i#2>=(byte) 50) goto main::@2 [ main::i#2 ]
   to:main::@3
-main::@3: scope:[main]  from main::@1 main::@2
-  [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ]
-  [4] if((byte) main::i#1<(byte) 100) goto main::@7 [ main::i#1 ]
+main::@3: scope:[main]  from main::@1
+  [3] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ]
+  to:main::@2
+main::@2: scope:[main]  from main::@1 main::@3
+  [4] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ]
+  [5] if((byte) main::i#1<(byte) 100) goto main::@5 [ main::i#1 ]
   to:main::@return
-main::@return: scope:[main]  from main::@3
-  [5] return  [ ]
+main::@return: scope:[main]  from main::@2
+  [6] return  [ ]
   to:@return
-main::@7: scope:[main]  from main::@3
-  [6] (byte~) main::i#5 ← (byte) main::i#1 [ main::i#5 ]
+main::@5: scope:[main]  from main::@2
+  [7] (byte~) main::i#5 ← (byte) main::i#1 [ main::i#5 ]
   to:main::@1
-main::@2: scope:[main]  from main::@1
-  [7] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ]
-  to:main::@3
 
 Created 1 initial phi equivalence classes
-Coalesced [6] main::i#5 ← main::i#1
+Coalesced [7] main::i#5 ← main::i#1
 Coalesced down to 1 phi equivalence classes
-Culled Empty Block (label) main::@7
-Block Sequence Planned @begin @end main main::@1 main::@3 main::@return main::@2 
+Culled Empty Block (label) main::@5
+Block Sequence Planned @begin @end main main::@1 main::@3 main::@2 main::@return 
 Propagating live ranges...
 CONTROL FLOW GRAPH - PHI MEM COALESCED
 @begin: scope:[]  from
@@ -476,20 +508,20 @@ CONTROL FLOW GRAPH - PHI MEM COALESCED
 @end: scope:[]  from @begin
 main: scope:[main]  from @begin
   to:main::@1
-main::@1: scope:[main]  from main main::@3
-  [1] (byte) main::i#2 ← phi( main/(byte) 0 main::@3/(byte) main::i#1 ) [ main::i#2 ]
-  [2] if((byte) main::i#2<(byte) 50) goto main::@2 [ main::i#2 ]
+main::@1: scope:[main]  from main main::@2
+  [1] (byte) main::i#2 ← phi( main/(byte) 0 main::@2/(byte) main::i#1 ) [ main::i#2 ]
+  [2] if((byte) main::i#2>=(byte) 50) goto main::@2 [ main::i#2 ]
   to:main::@3
-main::@3: scope:[main]  from main::@1 main::@2
-  [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ]
-  [4] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ]
+main::@3: scope:[main]  from main::@1
+  [3] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ]
+  to:main::@2
+main::@2: scope:[main]  from main::@1 main::@3
+  [4] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ]
+  [5] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ]
   to:main::@return
-main::@return: scope:[main]  from main::@3
-  [5] return  [ ]
+main::@return: scope:[main]  from main::@2
+  [6] return  [ ]
   to:@return
-main::@2: scope:[main]  from main::@1
-  [6] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ]
-  to:main::@3
 
 CALL GRAPH
 Calls in [] to 0:main 
@@ -500,19 +532,19 @@ DOMINATORS
 main dominated by  @begin main 
 main::@1 dominated by  @begin main::@1 main 
 main::@3 dominated by  @begin main::@1 main::@3 main 
-main::@return dominated by  main::@return @begin main::@1 main::@3 main 
 main::@2 dominated by  @begin main::@2 main::@1 main 
+main::@return dominated by  main::@return @begin main::@2 main::@1 main 
 
-Found back edge: Loop head: main::@1 tails: main::@3 blocks: null
-Populated: Loop head: main::@1 tails: main::@3 blocks: main::@3 main::@1 main::@2 
+Found back edge: Loop head: main::@1 tails: main::@2 blocks: null
+Populated: Loop head: main::@1 tails: main::@2 blocks: main::@2 main::@1 main::@3 
 NATURAL LOOPS
-Loop head: main::@1 tails: main::@3 blocks: main::@3 main::@1 main::@2 
+Loop head: main::@1 tails: main::@2 blocks: main::@2 main::@1 main::@3 
 
 Found 0 loops in scope []
 Found 1 loops in scope [main]
-  Loop head: main::@1 tails: main::@3 blocks: main::@3 main::@1 main::@2 
+  Loop head: main::@1 tails: main::@2 blocks: main::@2 main::@1 main::@3 
 NATURAL LOOPS WITH DEPTH
-Loop head: main::@1 tails: main::@3 blocks: main::@3 main::@1 main::@2  depth: 1
+Loop head: main::@1 tails: main::@2 blocks: main::@2 main::@1 main::@3  depth: 1
 
 
 VARIABLE REGISTER WEIGHTS
@@ -543,36 +575,36 @@ main: {
     lda #$0
     sta $2
     jmp b1
-  //SEG6 [1] phi from main::@3 to main::@1
-  b1_from_b3:
+  //SEG6 [1] phi from main::@2 to main::@1
+  b1_from_b2:
   //SEG7 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
     jmp b1
   //SEG8 main::@1
   b1:
-  //SEG9 [2] if((byte) main::i#2<(byte) 50) goto main::@2 [ main::i#2 ] -- zpby1_lt_coby1_then_la1 
+  //SEG9 [2] if((byte) main::i#2>=(byte) 50) goto main::@2 [ main::i#2 ] -- zpby1_ge_coby1_then_la1 
     lda $2
     cmp #$32
-    bcc b2
+    bcs b2
     jmp b3
   //SEG10 main::@3
   b3:
-  //SEG11 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- zpby1=_inc_zpby1 
-    inc $2
-  //SEG12 [4] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- zpby1_lt_coby1_then_la1 
-    lda $2
-    cmp #$64
-    bcc b1_from_b3
-    jmp breturn
-  //SEG13 main::@return
-  breturn:
-  //SEG14 [5] return  [ ]
-    rts
-  //SEG15 main::@2
-  b2:
-  //SEG16 [6] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=zpby1 
+  //SEG11 [3] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=zpby1 
     lda $2
     sta $400
-    jmp b3
+    jmp b2
+  //SEG12 main::@2
+  b2:
+  //SEG13 [4] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- zpby1=_inc_zpby1 
+    inc $2
+  //SEG14 [5] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- zpby1_lt_coby1_then_la1 
+    lda $2
+    cmp #$64
+    bcc b1_from_b2
+    jmp breturn
+  //SEG15 main::@return
+  breturn:
+  //SEG16 [6] return  [ ]
+    rts
 }
 
 REGISTER UPLIFT POTENTIAL REGISTERS
@@ -587,6 +619,7 @@ Uplifting [] best 335 combination
 Removing instruction jmp bend
 Removing instruction jmp b1
 Removing instruction jmp b3
+Removing instruction jmp b2
 Removing instruction jmp breturn
 Succesful ASM optimization Pass5NextJumpElimination
 ASSEMBLER
@@ -603,34 +636,33 @@ main: {
   //SEG5 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
     ldx #$0
     jmp b1
-  //SEG6 [1] phi from main::@3 to main::@1
-  b1_from_b3:
+  //SEG6 [1] phi from main::@2 to main::@1
+  b1_from_b2:
   //SEG7 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
   //SEG8 main::@1
   b1:
-  //SEG9 [2] if((byte) main::i#2<(byte) 50) goto main::@2 [ main::i#2 ] -- xby_lt_coby1_then_la1 
+  //SEG9 [2] if((byte) main::i#2>=(byte) 50) goto main::@2 [ main::i#2 ] -- xby_ge_coby1_then_la1 
     cpx #$32
-    bcc b2
+    bcs b2
   //SEG10 main::@3
   b3:
-  //SEG11 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
-    inx
-  //SEG12 [4] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1 
-    cpx #$64
-    bcc b1_from_b3
-  //SEG13 main::@return
-  breturn:
-  //SEG14 [5] return  [ ]
-    rts
-  //SEG15 main::@2
-  b2:
-  //SEG16 [6] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=xby 
+  //SEG11 [3] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=xby 
     stx $400
-    jmp b3
+  //SEG12 main::@2
+  b2:
+  //SEG13 [4] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
+    inx
+  //SEG14 [5] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1 
+    cpx #$64
+    bcc b1_from_b2
+  //SEG15 main::@return
+  breturn:
+  //SEG16 [6] return  [ ]
+    rts
 }
 
-Replacing label b1_from_b3 with b1
-Removing instruction b1_from_b3:
+Replacing label b1_from_b2 with b1
+Removing instruction b1_from_b2:
 Succesful ASM optimization Pass5RedundantLabelElimination
 ASSEMBLER
 //SEG0 @begin
@@ -646,34 +678,34 @@ main: {
   //SEG5 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
     ldx #$0
     jmp b1
-  //SEG6 [1] phi from main::@3 to main::@1
+  //SEG6 [1] phi from main::@2 to main::@1
   //SEG7 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
   //SEG8 main::@1
   b1:
-  //SEG9 [2] if((byte) main::i#2<(byte) 50) goto main::@2 [ main::i#2 ] -- xby_lt_coby1_then_la1 
+  //SEG9 [2] if((byte) main::i#2>=(byte) 50) goto main::@2 [ main::i#2 ] -- xby_ge_coby1_then_la1 
     cpx #$32
-    bcc b2
+    bcs b2
   //SEG10 main::@3
   b3:
-  //SEG11 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
+  //SEG11 [3] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=xby 
+    stx $400
+  //SEG12 main::@2
+  b2:
+  //SEG13 [4] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG12 [4] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1 
+  //SEG14 [5] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1 
     cpx #$64
     bcc b1
-  //SEG13 main::@return
+  //SEG15 main::@return
   breturn:
-  //SEG14 [5] return  [ ]
+  //SEG16 [6] return  [ ]
     rts
-  //SEG15 main::@2
-  b2:
-  //SEG16 [6] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=xby 
-    stx $400
-    jmp b3
 }
 
 Removing instruction bbegin:
 Removing instruction bend:
 Removing instruction b1_from_main:
+Removing instruction b3:
 Removing instruction breturn:
 Succesful ASM optimization Pass5UnusedLabelElimination
 ASSEMBLER
@@ -687,28 +719,26 @@ main: {
   //SEG5 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
     ldx #$0
     jmp b1
-  //SEG6 [1] phi from main::@3 to main::@1
+  //SEG6 [1] phi from main::@2 to main::@1
   //SEG7 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
   //SEG8 main::@1
   b1:
-  //SEG9 [2] if((byte) main::i#2<(byte) 50) goto main::@2 [ main::i#2 ] -- xby_lt_coby1_then_la1 
+  //SEG9 [2] if((byte) main::i#2>=(byte) 50) goto main::@2 [ main::i#2 ] -- xby_ge_coby1_then_la1 
     cpx #$32
-    bcc b2
+    bcs b2
   //SEG10 main::@3
-  b3:
-  //SEG11 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
+  //SEG11 [3] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=xby 
+    stx $400
+  //SEG12 main::@2
+  b2:
+  //SEG13 [4] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG12 [4] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1 
+  //SEG14 [5] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1 
     cpx #$64
     bcc b1
-  //SEG13 main::@return
-  //SEG14 [5] return  [ ]
+  //SEG15 main::@return
+  //SEG16 [6] return  [ ]
     rts
-  //SEG15 main::@2
-  b2:
-  //SEG16 [6] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=xby 
-    stx $400
-    jmp b3
 }
 
 Removing instruction jmp b1
@@ -723,28 +753,26 @@ main: {
   //SEG4 [1] phi from main to main::@1
   //SEG5 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
     ldx #$0
-  //SEG6 [1] phi from main::@3 to main::@1
+  //SEG6 [1] phi from main::@2 to main::@1
   //SEG7 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
   //SEG8 main::@1
   b1:
-  //SEG9 [2] if((byte) main::i#2<(byte) 50) goto main::@2 [ main::i#2 ] -- xby_lt_coby1_then_la1 
+  //SEG9 [2] if((byte) main::i#2>=(byte) 50) goto main::@2 [ main::i#2 ] -- xby_ge_coby1_then_la1 
     cpx #$32
-    bcc b2
+    bcs b2
   //SEG10 main::@3
-  b3:
-  //SEG11 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
+  //SEG11 [3] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=xby 
+    stx $400
+  //SEG12 main::@2
+  b2:
+  //SEG13 [4] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG12 [4] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1 
+  //SEG14 [5] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1 
     cpx #$64
     bcc b1
-  //SEG13 main::@return
-  //SEG14 [5] return  [ ]
+  //SEG15 main::@return
+  //SEG16 [6] return  [ ]
     rts
-  //SEG15 main::@2
-  b2:
-  //SEG16 [6] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=xby 
-    stx $400
-    jmp b3
 }
 
 FINAL SYMBOL TABLE
@@ -772,27 +800,25 @@ main: {
   //SEG4 [1] phi from main to main::@1
   //SEG5 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
     ldx #$0
-  //SEG6 [1] phi from main::@3 to main::@1
+  //SEG6 [1] phi from main::@2 to main::@1
   //SEG7 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
   //SEG8 main::@1
   b1:
-  //SEG9 [2] if((byte) main::i#2<(byte) 50) goto main::@2 [ main::i#2 ] -- xby_lt_coby1_then_la1 
+  //SEG9 [2] if((byte) main::i#2>=(byte) 50) goto main::@2 [ main::i#2 ] -- xby_ge_coby1_then_la1 
     cpx #$32
-    bcc b2
+    bcs b2
   //SEG10 main::@3
-  b3:
-  //SEG11 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
+  //SEG11 [3] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=xby 
+    stx $400
+  //SEG12 main::@2
+  b2:
+  //SEG13 [4] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG12 [4] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1 
+  //SEG14 [5] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1 
     cpx #$64
     bcc b1
-  //SEG13 main::@return
-  //SEG14 [5] return  [ ]
+  //SEG15 main::@return
+  //SEG16 [6] return  [ ]
     rts
-  //SEG15 main::@2
-  b2:
-  //SEG16 [6] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=xby 
-    stx $400
-    jmp b3
 }
 

src/main/java/dk/camelot64/kickc/test/ref/loopmin.asm

@@ -2,15 +2,12 @@
   ldx #$a
 b1:
   cpx #$5
-  beq !+
-  bcs b2
-!:
-b3:
-  dex
-  cpx #$0
-  bne b1
-b2:
+  bcc b2
+  beq b2
   stx $ff
   clc
   adc $ff
-  jmp b3
+b2:
+  dex
+  cpx #$0
+  bne b1

src/main/java/dk/camelot64/kickc/test/ref/loopmin.cfg

@@ -1,16 +1,16 @@
 @begin: scope:[]  from
   to:@1
-@1: scope:[]  from @3 @begin
-  [0] (byte) s#2 ← phi( @3/(byte) s#4 @begin/(byte) 0 ) [ i#2 s#2 ]
-  [0] (byte) i#2 ← phi( @3/(byte) i#1 @begin/(byte) 10 ) [ i#2 s#2 ]
-  [1] if((byte) i#2>(byte) 5) goto @2 [ i#2 s#2 ]
+@1: scope:[]  from @2 @begin
+  [0] (byte) s#2 ← phi( @2/(byte) s#4 @begin/(byte) 0 ) [ i#2 s#2 ]
+  [0] (byte) i#2 ← phi( @2/(byte) i#1 @begin/(byte) 10 ) [ i#2 s#2 ]
+  [1] if((byte) i#2<=(byte) 5) goto @2 [ i#2 s#2 ]
   to:@3
-@3: scope:[]  from @1 @2
-  [2] (byte) s#4 ← phi( @1/(byte) s#2 @2/(byte) s#1 ) [ s#4 i#2 ]
-  [3] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ]
-  [4] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ]
+@3: scope:[]  from @1
+  [2] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ]
+  to:@2
+@2: scope:[]  from @1 @3
+  [3] (byte) s#4 ← phi( @1/(byte) s#2 @3/(byte) s#1 ) [ s#4 i#2 ]
+  [4] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ]
+  [5] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ]
   to:@end
-@end: scope:[]  from @3
-@2: scope:[]  from @1
-  [5] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ]
-  to:@3
+@end: scope:[]  from @2

src/main/java/dk/camelot64/kickc/test/ref/loopmin.log

@@ -12,23 +12,22 @@ PROGRAM
   (byte) s ← (byte) 0
 @1:
   (boolean~) $0 ← (byte) i > (byte) 5
-  if((boolean~) $0) goto @2
-  goto @3
+  (boolean~) $1 ← ! (boolean~) $0
+  if((boolean~) $1) goto @2
+  (byte~) $2 ← (byte) s + (byte) i
+  (byte) s ← (byte~) $2
 @2:
-  (byte~) $1 ← (byte) s + (byte) i
-  (byte) s ← (byte~) $1
-@3:
   (byte) i ← -- (byte) i
-  (boolean~) $2 ← (byte) i > (byte) 0
-  if((boolean~) $2) goto @1
+  (boolean~) $3 ← (byte) i > (byte) 0
+  if((boolean~) $3) goto @1
 
 SYMBOLS
 (boolean~) $0
-(byte~) $1
-(boolean~) $2
+(boolean~) $1
+(byte~) $2
+(boolean~) $3
 (label) @1
 (label) @2
-(label) @3
 (byte) i
 (byte) s
 
@@ -37,49 +36,45 @@ INITIAL CONTROL FLOW GRAPH
   (byte) i ← (byte) 10
   (byte) s ← (byte) 0
   to:@1
-@1: scope:[]  from @3 @begin
+@1: scope:[]  from @2 @begin
   (boolean~) $0 ← (byte) i > (byte) 5
-  if((boolean~) $0) goto @2
-  to:@4
-@2: scope:[]  from @1 @5
-  (byte~) $1 ← (byte) s + (byte) i
-  (byte) s ← (byte~) $1
+  (boolean~) $1 ← ! (boolean~) $0
+  if((boolean~) $1) goto @2
   to:@3
-@4: scope:[]  from @1
-  to:@3
-@3: scope:[]  from @2 @4
+@2: scope:[]  from @1 @3
   (byte) i ← -- (byte) i
-  (boolean~) $2 ← (byte) i > (byte) 0
-  if((boolean~) $2) goto @1
-  to:@6
-@5: scope:[]  from
+  (boolean~) $3 ← (byte) i > (byte) 0
+  if((boolean~) $3) goto @1
+  to:@4
+@3: scope:[]  from @1
+  (byte~) $2 ← (byte) s + (byte) i
+  (byte) s ← (byte~) $2
   to:@2
-@6: scope:[]  from @3
+@4: scope:[]  from @2
   to:@end
-@end: scope:[]  from @6
+@end: scope:[]  from @4
 
 Removing empty block @4
-Removing empty block @5
-Removing empty block @6
 CONTROL FLOW GRAPH
 @begin: scope:[]  from
   (byte) i ← (byte) 10
   (byte) s ← (byte) 0
   to:@1
-@1: scope:[]  from @3 @begin
+@1: scope:[]  from @2 @begin
   (boolean~) $0 ← (byte) i > (byte) 5
-  if((boolean~) $0) goto @2
+  (boolean~) $1 ← ! (boolean~) $0
+  if((boolean~) $1) goto @2
   to:@3
-@2: scope:[]  from @1
-  (byte~) $1 ← (byte) s + (byte) i
-  (byte) s ← (byte~) $1
-  to:@3
-@3: scope:[]  from @1 @2
+@2: scope:[]  from @1 @3
   (byte) i ← -- (byte) i
-  (boolean~) $2 ← (byte) i > (byte) 0
-  if((boolean~) $2) goto @1
+  (boolean~) $3 ← (byte) i > (byte) 0
+  if((boolean~) $3) goto @1
   to:@end
-@end: scope:[]  from @3
+@3: scope:[]  from @1
+  (byte~) $2 ← (byte) s + (byte) i
+  (byte) s ← (byte~) $2
+  to:@2
+@end: scope:[]  from @2
 
 PROCEDURE MODIFY VARIABLE ANALYSIS
 
@@ -88,20 +83,21 @@ CONTROL FLOW GRAPH WITH ASSIGNMENT CALL
   (byte) i ← (byte) 10
   (byte) s ← (byte) 0
   to:@1
-@1: scope:[]  from @3 @begin
+@1: scope:[]  from @2 @begin
   (boolean~) $0 ← (byte) i > (byte) 5
-  if((boolean~) $0) goto @2
+  (boolean~) $1 ← ! (boolean~) $0
+  if((boolean~) $1) goto @2
   to:@3
-@2: scope:[]  from @1
-  (byte~) $1 ← (byte) s + (byte) i
-  (byte) s ← (byte~) $1
-  to:@3
-@3: scope:[]  from @1 @2
+@2: scope:[]  from @1 @3
   (byte) i ← -- (byte) i
-  (boolean~) $2 ← (byte) i > (byte) 0
-  if((boolean~) $2) goto @1
+  (boolean~) $3 ← (byte) i > (byte) 0
+  if((boolean~) $3) goto @1
   to:@end
-@end: scope:[]  from @3
+@3: scope:[]  from @1
+  (byte~) $2 ← (byte) s + (byte) i
+  (byte) s ← (byte~) $2
+  to:@2
+@end: scope:[]  from @2
 
 Completing Phi functions...
 Completing Phi functions...
@@ -111,52 +107,54 @@ CONTROL FLOW GRAPH SSA
   (byte) i#0 ← (byte) 10
   (byte) s#0 ← (byte) 0
   to:@1
-@1: scope:[]  from @3 @begin
-  (byte) s#3 ← phi( @3/(byte) s#4 @begin/(byte) s#0 )
-  (byte) i#2 ← phi( @3/(byte) i#1 @begin/(byte) i#0 )
+@1: scope:[]  from @2 @begin
+  (byte) s#3 ← phi( @2/(byte) s#4 @begin/(byte) s#0 )
+  (byte) i#2 ← phi( @2/(byte) i#1 @begin/(byte) i#0 )
   (boolean~) $0 ← (byte) i#2 > (byte) 5
-  if((boolean~) $0) goto @2
+  (boolean~) $1 ← ! (boolean~) $0
+  if((boolean~) $1) goto @2
   to:@3
-@2: scope:[]  from @1
-  (byte) i#3 ← phi( @1/(byte) i#2 )
-  (byte) s#2 ← phi( @1/(byte) s#3 )
-  (byte~) $1 ← (byte) s#2 + (byte) i#3
-  (byte) s#1 ← (byte~) $1
-  to:@3
-@3: scope:[]  from @1 @2
-  (byte) s#4 ← phi( @1/(byte) s#3 @2/(byte) s#1 )
-  (byte) i#4 ← phi( @1/(byte) i#2 @2/(byte) i#3 )
-  (byte) i#1 ← -- (byte) i#4
-  (boolean~) $2 ← (byte) i#1 > (byte) 0
-  if((boolean~) $2) goto @1
+@2: scope:[]  from @1 @3
+  (byte) s#4 ← phi( @1/(byte) s#3 @3/(byte) s#1 )
+  (byte) i#3 ← phi( @1/(byte) i#2 @3/(byte) i#4 )
+  (byte) i#1 ← -- (byte) i#3
+  (boolean~) $3 ← (byte) i#1 > (byte) 0
+  if((boolean~) $3) goto @1
   to:@end
-@end: scope:[]  from @3
+@3: scope:[]  from @1
+  (byte) i#4 ← phi( @1/(byte) i#2 )
+  (byte) s#2 ← phi( @1/(byte) s#3 )
+  (byte~) $2 ← (byte) s#2 + (byte) i#4
+  (byte) s#1 ← (byte~) $2
+  to:@2
+@end: scope:[]  from @2
 
 CONTROL FLOW GRAPH WITH ASSIGNMENT CALL & RETURN
 @begin: scope:[]  from
   (byte) i#0 ← (byte) 10
   (byte) s#0 ← (byte) 0
   to:@1
-@1: scope:[]  from @3 @begin
-  (byte) s#3 ← phi( @3/(byte) s#4 @begin/(byte) s#0 )
-  (byte) i#2 ← phi( @3/(byte) i#1 @begin/(byte) i#0 )
+@1: scope:[]  from @2 @begin
+  (byte) s#3 ← phi( @2/(byte) s#4 @begin/(byte) s#0 )
+  (byte) i#2 ← phi( @2/(byte) i#1 @begin/(byte) i#0 )
   (boolean~) $0 ← (byte) i#2 > (byte) 5
-  if((boolean~) $0) goto @2
+  (boolean~) $1 ← ! (boolean~) $0
+  if((boolean~) $1) goto @2
   to:@3
-@2: scope:[]  from @1
-  (byte) i#3 ← phi( @1/(byte) i#2 )
-  (byte) s#2 ← phi( @1/(byte) s#3 )
-  (byte~) $1 ← (byte) s#2 + (byte) i#3
-  (byte) s#1 ← (byte~) $1
-  to:@3
-@3: scope:[]  from @1 @2
-  (byte) s#4 ← phi( @1/(byte) s#3 @2/(byte) s#1 )
-  (byte) i#4 ← phi( @1/(byte) i#2 @2/(byte) i#3 )
-  (byte) i#1 ← -- (byte) i#4
-  (boolean~) $2 ← (byte) i#1 > (byte) 0
-  if((boolean~) $2) goto @1
+@2: scope:[]  from @1 @3
+  (byte) s#4 ← phi( @1/(byte) s#3 @3/(byte) s#1 )
+  (byte) i#3 ← phi( @1/(byte) i#2 @3/(byte) i#4 )
+  (byte) i#1 ← -- (byte) i#3
+  (boolean~) $3 ← (byte) i#1 > (byte) 0
+  if((boolean~) $3) goto @1
   to:@end
-@end: scope:[]  from @3
+@3: scope:[]  from @1
+  (byte) i#4 ← phi( @1/(byte) i#2 )
+  (byte) s#2 ← phi( @1/(byte) s#3 )
+  (byte~) $2 ← (byte) s#2 + (byte) i#4
+  (byte) s#1 ← (byte~) $2
+  to:@2
+@end: scope:[]  from @2
 
 Constant (byte) i#0 (byte) 10
 Constant (byte) s#0 (byte) 0
@@ -164,124 +162,151 @@ Succesful SSA optimization Pass2ConstantPropagation
 CONTROL FLOW GRAPH
 @begin: scope:[]  from
   to:@1
-@1: scope:[]  from @3 @begin
-  (byte) s#3 ← phi( @3/(byte) s#4 @begin/(byte) 0 )
-  (byte) i#2 ← phi( @3/(byte) i#1 @begin/(byte) 10 )
+@1: scope:[]  from @2 @begin
+  (byte) s#3 ← phi( @2/(byte) s#4 @begin/(byte) 0 )
+  (byte) i#2 ← phi( @2/(byte) i#1 @begin/(byte) 10 )
   (boolean~) $0 ← (byte) i#2 > (byte) 5
-  if((boolean~) $0) goto @2
+  (boolean~) $1 ← ! (boolean~) $0
+  if((boolean~) $1) goto @2
   to:@3
-@2: scope:[]  from @1
-  (byte) i#3 ← phi( @1/(byte) i#2 )
-  (byte) s#2 ← phi( @1/(byte) s#3 )
-  (byte~) $1 ← (byte) s#2 + (byte) i#3
-  (byte) s#1 ← (byte~) $1
-  to:@3
-@3: scope:[]  from @1 @2
-  (byte) s#4 ← phi( @1/(byte) s#3 @2/(byte) s#1 )
-  (byte) i#4 ← phi( @1/(byte) i#2 @2/(byte) i#3 )
-  (byte) i#1 ← -- (byte) i#4
-  (boolean~) $2 ← (byte) i#1 > (byte) 0
-  if((boolean~) $2) goto @1
+@2: scope:[]  from @1 @3
+  (byte) s#4 ← phi( @1/(byte) s#3 @3/(byte) s#1 )
+  (byte) i#3 ← phi( @1/(byte) i#2 @3/(byte) i#4 )
+  (byte) i#1 ← -- (byte) i#3
+  (boolean~) $3 ← (byte) i#1 > (byte) 0
+  if((boolean~) $3) goto @1
   to:@end
-@end: scope:[]  from @3
+@3: scope:[]  from @1
+  (byte) i#4 ← phi( @1/(byte) i#2 )
+  (byte) s#2 ← phi( @1/(byte) s#3 )
+  (byte~) $2 ← (byte) s#2 + (byte) i#4
+  (byte) s#1 ← (byte~) $2
+  to:@2
+@end: scope:[]  from @2
+
+Inversing boolean not (boolean~) $1 ← (byte) i#2 <= (byte) 5 from (boolean~) $0 ← (byte) i#2 > (byte) 5
+Succesful SSA optimization Pass2UnaryNotSimplification
+CONTROL FLOW GRAPH
+@begin: scope:[]  from
+  to:@1
+@1: scope:[]  from @2 @begin
+  (byte) s#3 ← phi( @2/(byte) s#4 @begin/(byte) 0 )
+  (byte) i#2 ← phi( @2/(byte) i#1 @begin/(byte) 10 )
+  (boolean~) $1 ← (byte) i#2 <= (byte) 5
+  if((boolean~) $1) goto @2
+  to:@3
+@2: scope:[]  from @1 @3
+  (byte) s#4 ← phi( @1/(byte) s#3 @3/(byte) s#1 )
+  (byte) i#3 ← phi( @1/(byte) i#2 @3/(byte) i#4 )
+  (byte) i#1 ← -- (byte) i#3
+  (boolean~) $3 ← (byte) i#1 > (byte) 0
+  if((boolean~) $3) goto @1
+  to:@end
+@3: scope:[]  from @1
+  (byte) i#4 ← phi( @1/(byte) i#2 )
+  (byte) s#2 ← phi( @1/(byte) s#3 )
+  (byte~) $2 ← (byte) s#2 + (byte) i#4
+  (byte) s#1 ← (byte~) $2
+  to:@2
+@end: scope:[]  from @2
 
 Alias (byte) s#2 = (byte) s#3 
-Alias (byte) i#2 = (byte) i#3 
-Alias (byte) s#1 = (byte~) $1 
+Alias (byte) i#2 = (byte) i#4 
+Alias (byte) s#1 = (byte~) $2 
 Succesful SSA optimization Pass2AliasElimination
 CONTROL FLOW GRAPH
 @begin: scope:[]  from
   to:@1
-@1: scope:[]  from @3 @begin
-  (byte) s#2 ← phi( @3/(byte) s#4 @begin/(byte) 0 )
-  (byte) i#2 ← phi( @3/(byte) i#1 @begin/(byte) 10 )
-  (boolean~) $0 ← (byte) i#2 > (byte) 5
-  if((boolean~) $0) goto @2
+@1: scope:[]  from @2 @begin
+  (byte) s#2 ← phi( @2/(byte) s#4 @begin/(byte) 0 )
+  (byte) i#2 ← phi( @2/(byte) i#1 @begin/(byte) 10 )
+  (boolean~) $1 ← (byte) i#2 <= (byte) 5
+  if((boolean~) $1) goto @2
   to:@3
-@2: scope:[]  from @1
-  (byte) s#1 ← (byte) s#2 + (byte) i#2
-  to:@3
-@3: scope:[]  from @1 @2
-  (byte) s#4 ← phi( @1/(byte) s#2 @2/(byte) s#1 )
-  (byte) i#4 ← phi( @1/(byte) i#2 @2/(byte) i#2 )
-  (byte) i#1 ← -- (byte) i#4
-  (boolean~) $2 ← (byte) i#1 > (byte) 0
-  if((boolean~) $2) goto @1
+@2: scope:[]  from @1 @3
+  (byte) s#4 ← phi( @1/(byte) s#2 @3/(byte) s#1 )
+  (byte) i#3 ← phi( @1/(byte) i#2 @3/(byte) i#2 )
+  (byte) i#1 ← -- (byte) i#3
+  (boolean~) $3 ← (byte) i#1 > (byte) 0
+  if((boolean~) $3) goto @1
   to:@end
-@end: scope:[]  from @3
+@3: scope:[]  from @1
+  (byte) s#1 ← (byte) s#2 + (byte) i#2
+  to:@2
+@end: scope:[]  from @2
 
-Redundant Phi (byte) i#4 (byte) i#2
+Redundant Phi (byte) i#3 (byte) i#2
 Succesful SSA optimization Pass2RedundantPhiElimination
 CONTROL FLOW GRAPH
 @begin: scope:[]  from
   to:@1
-@1: scope:[]  from @3 @begin
-  (byte) s#2 ← phi( @3/(byte) s#4 @begin/(byte) 0 )
-  (byte) i#2 ← phi( @3/(byte) i#1 @begin/(byte) 10 )
-  (boolean~) $0 ← (byte) i#2 > (byte) 5
-  if((boolean~) $0) goto @2
+@1: scope:[]  from @2 @begin
+  (byte) s#2 ← phi( @2/(byte) s#4 @begin/(byte) 0 )
+  (byte) i#2 ← phi( @2/(byte) i#1 @begin/(byte) 10 )
+  (boolean~) $1 ← (byte) i#2 <= (byte) 5
+  if((boolean~) $1) goto @2
   to:@3
-@2: scope:[]  from @1
-  (byte) s#1 ← (byte) s#2 + (byte) i#2
-  to:@3
-@3: scope:[]  from @1 @2
-  (byte) s#4 ← phi( @1/(byte) s#2 @2/(byte) s#1 )
+@2: scope:[]  from @1 @3
+  (byte) s#4 ← phi( @1/(byte) s#2 @3/(byte) s#1 )
   (byte) i#1 ← -- (byte) i#2
-  (boolean~) $2 ← (byte) i#1 > (byte) 0
-  if((boolean~) $2) goto @1
+  (boolean~) $3 ← (byte) i#1 > (byte) 0
+  if((boolean~) $3) goto @1
   to:@end
-@end: scope:[]  from @3
+@3: scope:[]  from @1
+  (byte) s#1 ← (byte) s#2 + (byte) i#2
+  to:@2
+@end: scope:[]  from @2
 
-Simple Condition (boolean~) $0 if((byte) i#2>(byte) 5) goto @2
-Simple Condition (boolean~) $2 if((byte) i#1>(byte) 0) goto @1
+Simple Condition (boolean~) $1 if((byte) i#2<=(byte) 5) goto @2
+Simple Condition (boolean~) $3 if((byte) i#1>(byte) 0) goto @1
 Succesful SSA optimization Pass2ConditionalJumpSimplification
 CONTROL FLOW GRAPH
 @begin: scope:[]  from
   to:@1
-@1: scope:[]  from @3 @begin
-  (byte) s#2 ← phi( @3/(byte) s#4 @begin/(byte) 0 )
-  (byte) i#2 ← phi( @3/(byte) i#1 @begin/(byte) 10 )
-  if((byte) i#2>(byte) 5) goto @2
+@1: scope:[]  from @2 @begin
+  (byte) s#2 ← phi( @2/(byte) s#4 @begin/(byte) 0 )
+  (byte) i#2 ← phi( @2/(byte) i#1 @begin/(byte) 10 )
+  if((byte) i#2<=(byte) 5) goto @2
   to:@3
-@2: scope:[]  from @1
-  (byte) s#1 ← (byte) s#2 + (byte) i#2
-  to:@3
-@3: scope:[]  from @1 @2
-  (byte) s#4 ← phi( @1/(byte) s#2 @2/(byte) s#1 )
+@2: scope:[]  from @1 @3
+  (byte) s#4 ← phi( @1/(byte) s#2 @3/(byte) s#1 )
   (byte) i#1 ← -- (byte) i#2
   if((byte) i#1>(byte) 0) goto @1
   to:@end
-@end: scope:[]  from @3
+@3: scope:[]  from @1
+  (byte) s#1 ← (byte) s#2 + (byte) i#2
+  to:@2
+@end: scope:[]  from @2
 
-Block Sequence Planned @begin @1 @3 @end @2 
-Added new block during phi lifting @7(between @3 and @1)
-Added new block during phi lifting @8(between @1 and @3)
-Block Sequence Planned @begin @1 @8 @3 @end @7 @2 
+Block Sequence Planned @begin @1 @3 @2 @end 
+Added new block during phi lifting @5(between @2 and @1)
+Added new block during phi lifting @6(between @1 and @2)
+Block Sequence Planned @begin @1 @3 @2 @end @5 @6 
 CONTROL FLOW GRAPH - PHI LIFTED
 @begin: scope:[]  from
   to:@1
-@1: scope:[]  from @7 @begin
-  (byte) s#2 ← phi( @7/(byte~) s#5 @begin/(byte) 0 )
-  (byte) i#2 ← phi( @7/(byte~) i#5 @begin/(byte) 10 )
-  if((byte) i#2>(byte) 5) goto @2
-  to:@8
-@8: scope:[]  from @1
-  (byte~) s#6 ← (byte) s#2
+@1: scope:[]  from @5 @begin
+  (byte) s#2 ← phi( @5/(byte~) s#5 @begin/(byte) 0 )
+  (byte) i#2 ← phi( @5/(byte~) i#5 @begin/(byte) 10 )
+  if((byte) i#2<=(byte) 5) goto @6
   to:@3
-@3: scope:[]  from @2 @8
-  (byte) s#4 ← phi( @8/(byte~) s#6 @2/(byte~) s#7 )
+@3: scope:[]  from @1
+  (byte) s#1 ← (byte) s#2 + (byte) i#2
+  (byte~) s#7 ← (byte) s#1
+  to:@2
+@2: scope:[]  from @3 @6
+  (byte) s#4 ← phi( @6/(byte~) s#6 @3/(byte~) s#7 )
   (byte) i#1 ← -- (byte) i#2
-  if((byte) i#1>(byte) 0) goto @7
+  if((byte) i#1>(byte) 0) goto @5
   to:@end
-@end: scope:[]  from @3
-@7: scope:[]  from @3
+@end: scope:[]  from @2
+@5: scope:[]  from @2
   (byte~) i#5 ← (byte) i#1
   (byte~) s#5 ← (byte) s#4
   to:@1
-@2: scope:[]  from @1
-  (byte) s#1 ← (byte) s#2 + (byte) i#2
-  (byte~) s#7 ← (byte) s#1
-  to:@3
+@6: scope:[]  from @1
+  (byte~) s#6 ← (byte) s#2
+  to:@2
 
 Propagating live ranges...
 Propagating live ranges...
@@ -290,58 +315,58 @@ Propagating live ranges...
 CONTROL FLOW GRAPH - LIVE RANGES
 @begin: scope:[]  from
   to:@1
-@1: scope:[]  from @7 @begin
-  [0] (byte) s#2 ← phi( @7/(byte~) s#5 @begin/(byte) 0 ) [ i#2 s#2 ]
-  [0] (byte) i#2 ← phi( @7/(byte~) i#5 @begin/(byte) 10 ) [ i#2 s#2 ]
-  [1] if((byte) i#2>(byte) 5) goto @2 [ i#2 s#2 ]
-  to:@8
-@8: scope:[]  from @1
-  [2] (byte~) s#6 ← (byte) s#2 [ i#2 s#6 ]
+@1: scope:[]  from @5 @begin
+  [0] (byte) s#2 ← phi( @5/(byte~) s#5 @begin/(byte) 0 ) [ i#2 s#2 ]
+  [0] (byte) i#2 ← phi( @5/(byte~) i#5 @begin/(byte) 10 ) [ i#2 s#2 ]
+  [1] if((byte) i#2<=(byte) 5) goto @6 [ i#2 s#2 ]
   to:@3
-@3: scope:[]  from @2 @8
-  [3] (byte) s#4 ← phi( @8/(byte~) s#6 @2/(byte~) s#7 ) [ i#2 s#4 ]
-  [4] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ]
-  [5] if((byte) i#1>(byte) 0) goto @7 [ i#1 s#4 ]
+@3: scope:[]  from @1
+  [2] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ]
+  [3] (byte~) s#7 ← (byte) s#1 [ i#2 s#7 ]
+  to:@2
+@2: scope:[]  from @3 @6
+  [4] (byte) s#4 ← phi( @6/(byte~) s#6 @3/(byte~) s#7 ) [ i#2 s#4 ]
+  [5] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ]
+  [6] if((byte) i#1>(byte) 0) goto @5 [ i#1 s#4 ]
   to:@end
-@end: scope:[]  from @3
-@7: scope:[]  from @3
-  [6] (byte~) i#5 ← (byte) i#1 [ i#5 s#4 ]
-  [7] (byte~) s#5 ← (byte) s#4 [ i#5 s#5 ]
+@end: scope:[]  from @2
+@5: scope:[]  from @2
+  [7] (byte~) i#5 ← (byte) i#1 [ i#5 s#4 ]
+  [8] (byte~) s#5 ← (byte) s#4 [ i#5 s#5 ]
   to:@1
-@2: scope:[]  from @1
-  [8] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ]
-  [9] (byte~) s#7 ← (byte) s#1 [ i#2 s#7 ]
-  to:@3
+@6: scope:[]  from @1
+  [9] (byte~) s#6 ← (byte) s#2 [ i#2 s#6 ]
+  to:@2
 
 Created 3 initial phi equivalence classes
-Coalesced [2] s#6 ← s#2
-Coalesced [6] i#5 ← i#1
-Coalesced (already) [7] s#5 ← s#4
-Coalesced [9] s#7 ← s#1
+Coalesced [3] s#7 ← s#1
+Coalesced [7] i#5 ← i#1
+Coalesced [8] s#5 ← s#4
+Coalesced (already) [9] s#6 ← s#2
 Coalesced down to 2 phi equivalence classes
-Culled Empty Block (label) @8
-Culled Empty Block (label) @7
-Block Sequence Planned @begin @1 @3 @end @2 
+Culled Empty Block (label) @5
+Culled Empty Block (label) @6
+Block Sequence Planned @begin @1 @3 @2 @end 
 Propagating live ranges...
 Propagating live ranges...
 Propagating live ranges...
 CONTROL FLOW GRAPH - PHI MEM COALESCED
 @begin: scope:[]  from
   to:@1
-@1: scope:[]  from @3 @begin
-  [0] (byte) s#2 ← phi( @3/(byte) s#4 @begin/(byte) 0 ) [ i#2 s#2 ]
-  [0] (byte) i#2 ← phi( @3/(byte) i#1 @begin/(byte) 10 ) [ i#2 s#2 ]
-  [1] if((byte) i#2>(byte) 5) goto @2 [ i#2 s#2 ]
+@1: scope:[]  from @2 @begin
+  [0] (byte) s#2 ← phi( @2/(byte) s#4 @begin/(byte) 0 ) [ i#2 s#2 ]
+  [0] (byte) i#2 ← phi( @2/(byte) i#1 @begin/(byte) 10 ) [ i#2 s#2 ]
+  [1] if((byte) i#2<=(byte) 5) goto @2 [ i#2 s#2 ]
   to:@3
-@3: scope:[]  from @1 @2
-  [2] (byte) s#4 ← phi( @1/(byte) s#2 @2/(byte) s#1 ) [ s#4 i#2 ]
-  [3] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ]
-  [4] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ]
+@3: scope:[]  from @1
+  [2] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ]
+  to:@2
+@2: scope:[]  from @1 @3
+  [3] (byte) s#4 ← phi( @1/(byte) s#2 @3/(byte) s#1 ) [ s#4 i#2 ]
+  [4] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ]
+  [5] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ]
   to:@end
-@end: scope:[]  from @3
-@2: scope:[]  from @1
-  [5] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ]
-  to:@3
+@end: scope:[]  from @2
 
 CALL GRAPH
 
@@ -349,18 +374,18 @@ DOMINATORS
 @begin dominated by  @begin 
 @1 dominated by  @1 @begin 
 @3 dominated by  @1 @3 @begin 
-@end dominated by  @1 @3 @end @begin 
 @2 dominated by  @1 @2 @begin 
+@end dominated by  @1 @2 @end @begin 
 
-Found back edge: Loop head: @1 tails: @3 blocks: null
-Populated: Loop head: @1 tails: @3 blocks: @3 @1 @2 
+Found back edge: Loop head: @1 tails: @2 blocks: null
+Populated: Loop head: @1 tails: @2 blocks: @2 @1 @3 
 NATURAL LOOPS
-Loop head: @1 tails: @3 blocks: @3 @1 @2 
+Loop head: @1 tails: @2 blocks: @2 @1 @3 
 
 Found 1 loops in scope []
-  Loop head: @1 tails: @3 blocks: @3 @1 @2 
+  Loop head: @1 tails: @2 blocks: @2 @1 @3 
 NATURAL LOOPS WITH DEPTH
-Loop head: @1 tails: @3 blocks: @3 @1 @2  depth: 1
+Loop head: @1 tails: @2 blocks: @2 @1 @3  depth: 1
 
 
 VARIABLE REGISTER WEIGHTS
@@ -392,44 +417,44 @@ b1_from_bbegin:
   lda #$a
   sta $2
   jmp b1
-//SEG4 [0] phi from @3 to @1
-b1_from_b3:
+//SEG4 [0] phi from @2 to @1
+b1_from_b2:
 //SEG5 [0] phi (byte) s#2 = (byte) s#4 -- register_copy 
 //SEG6 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
   jmp b1
 //SEG7 @1
 b1:
-//SEG8 [1] if((byte) i#2>(byte) 5) goto @2 [ i#2 s#2 ] -- zpby1_gt_coby1_then_la1 
+//SEG8 [1] if((byte) i#2<=(byte) 5) goto @2 [ i#2 s#2 ] -- zpby1_le_coby1_then_la1 
   lda $2
   cmp #$5
-  beq !+
-  bcs b2
-!:
-//SEG9 [2] phi from @1 to @3
-b3_from_b1:
-//SEG10 [2] phi (byte) s#4 = (byte) s#2 -- register_copy 
+  bcc b2_from_b1
+  beq b2_from_b1
   jmp b3
-//SEG11 @3
+//SEG9 @3
 b3:
-//SEG12 [3] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- zpby1=_dec_zpby1 
-  dec $2
-//SEG13 [4] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- zpby1_gt_0_then_la1 
-  lda $2
-  bne b1_from_b3
-  jmp bend
-//SEG14 @end
-bend:
-//SEG15 @2
-b2:
-//SEG16 [5] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- zpby1=zpby1_plus_zpby2 
+//SEG10 [2] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- zpby1=zpby1_plus_zpby2 
   lda $3
   clc
   adc $2
   sta $3
-//SEG17 [2] phi from @2 to @3
-b3_from_b2:
-//SEG18 [2] phi (byte) s#4 = (byte) s#1 -- register_copy 
-  jmp b3
+//SEG11 [3] phi from @3 to @2
+b2_from_b3:
+//SEG12 [3] phi (byte) s#4 = (byte) s#1 -- register_copy 
+  jmp b2
+//SEG13 [3] phi from @1 to @2
+b2_from_b1:
+//SEG14 [3] phi (byte) s#4 = (byte) s#2 -- register_copy 
+  jmp b2
+//SEG15 @2
+b2:
+//SEG16 [4] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- zpby1=_dec_zpby1 
+  dec $2
+//SEG17 [5] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- zpby1_gt_0_then_la1 
+  lda $2
+  bne b1_from_b2
+  jmp bend
+//SEG18 @end
+bend:
 
 REGISTER UPLIFT POTENTIAL REGISTERS
 Potential registers zp byte:2 [ i#2 i#1 ] : zp byte:2 , reg byte a , reg byte x , reg byte y , 
@@ -438,9 +463,10 @@ Potential registers zp byte:3 [ s#2 s#4 s#1 ] : zp byte:3 , reg byte a , reg byt
 REGISTER UPLIFT SCOPES
 Uplift Scope [] 49.5: zp byte:3 [ s#2 s#4 s#1 ] 27.5: zp byte:2 [ i#2 i#1 ] 
 
-Uplifting [] best 405 combination reg byte a [ s#2 s#4 s#1 ] reg byte x [ i#2 i#1 ] 
+Uplifting [] best 435 combination reg byte a [ s#2 s#4 s#1 ] reg byte x [ i#2 i#1 ] 
 Removing instruction jmp b1
 Removing instruction jmp b3
+Removing instruction jmp b2
 Removing instruction jmp bend
 Succesful ASM optimization Pass5NextJumpElimination
 ASSEMBLER
@@ -453,45 +479,45 @@ b1_from_bbegin:
 //SEG3 [0] phi (byte) i#2 = (byte) 10 -- xby=coby1 
   ldx #$a
   jmp b1
-//SEG4 [0] phi from @3 to @1
-b1_from_b3:
+//SEG4 [0] phi from @2 to @1
+b1_from_b2:
 //SEG5 [0] phi (byte) s#2 = (byte) s#4 -- register_copy 
 //SEG6 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
 //SEG7 @1
 b1:
-//SEG8 [1] if((byte) i#2>(byte) 5) goto @2 [ i#2 s#2 ] -- xby_gt_coby1_then_la1 
+//SEG8 [1] if((byte) i#2<=(byte) 5) goto @2 [ i#2 s#2 ] -- xby_le_coby1_then_la1 
   cpx #$5
-  beq !+
-  bcs b2
-!:
-//SEG9 [2] phi from @1 to @3
-b3_from_b1:
-//SEG10 [2] phi (byte) s#4 = (byte) s#2 -- register_copy 
-//SEG11 @3
+  bcc b2_from_b1
+  beq b2_from_b1
+//SEG9 @3
 b3:
-//SEG12 [3] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- xby=_dec_xby 
-  dex
-//SEG13 [4] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- xby_gt_0_then_la1 
-  cpx #$0
-  bne b1_from_b3
-//SEG14 @end
-bend:
-//SEG15 @2
-b2:
-//SEG16 [5] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- aby=aby_plus_xby 
+//SEG10 [2] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- aby=aby_plus_xby 
   stx $ff
   clc
   adc $ff
-//SEG17 [2] phi from @2 to @3
-b3_from_b2:
-//SEG18 [2] phi (byte) s#4 = (byte) s#1 -- register_copy 
-  jmp b3
+//SEG11 [3] phi from @3 to @2
+b2_from_b3:
+//SEG12 [3] phi (byte) s#4 = (byte) s#1 -- register_copy 
+  jmp b2
+//SEG13 [3] phi from @1 to @2
+b2_from_b1:
+//SEG14 [3] phi (byte) s#4 = (byte) s#2 -- register_copy 
+//SEG15 @2
+b2:
+//SEG16 [4] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- xby=_dec_xby 
+  dex
+//SEG17 [5] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- xby_gt_0_then_la1 
+  cpx #$0
+  bne b1_from_b2
+//SEG18 @end
+bend:
 
-Replacing label b1_from_b3 with b1
+Replacing label b2_from_b1 with b2
+Replacing label b2_from_b1 with b2
+Replacing label b1_from_b2 with b1
 Removing instruction b1_from_bbegin:
-Removing instruction b1_from_b3:
-Removing instruction b3_from_b1:
-Removing instruction bend:
+Removing instruction b1_from_b2:
+Removing instruction b2_from_b1:
 Succesful ASM optimization Pass5RedundantLabelElimination
 ASSEMBLER
 //SEG0 @begin
@@ -502,39 +528,41 @@ bbegin:
 //SEG3 [0] phi (byte) i#2 = (byte) 10 -- xby=coby1 
   ldx #$a
   jmp b1
-//SEG4 [0] phi from @3 to @1
+//SEG4 [0] phi from @2 to @1
 //SEG5 [0] phi (byte) s#2 = (byte) s#4 -- register_copy 
 //SEG6 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
 //SEG7 @1
 b1:
-//SEG8 [1] if((byte) i#2>(byte) 5) goto @2 [ i#2 s#2 ] -- xby_gt_coby1_then_la1 
+//SEG8 [1] if((byte) i#2<=(byte) 5) goto @2 [ i#2 s#2 ] -- xby_le_coby1_then_la1 
   cpx #$5
-  beq !+
-  bcs b2
-!:
-//SEG9 [2] phi from @1 to @3
-//SEG10 [2] phi (byte) s#4 = (byte) s#2 -- register_copy 
-//SEG11 @3
+  bcc b2
+  beq b2
+//SEG9 @3
 b3:
-//SEG12 [3] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- xby=_dec_xby 
-  dex
-//SEG13 [4] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- xby_gt_0_then_la1 
-  cpx #$0
-  bne b1
-//SEG14 @end
-//SEG15 @2
-b2:
-//SEG16 [5] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- aby=aby_plus_xby 
+//SEG10 [2] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- aby=aby_plus_xby 
   stx $ff
   clc
   adc $ff
-//SEG17 [2] phi from @2 to @3
-b3_from_b2:
-//SEG18 [2] phi (byte) s#4 = (byte) s#1 -- register_copy 
-  jmp b3
+//SEG11 [3] phi from @3 to @2
+b2_from_b3:
+//SEG12 [3] phi (byte) s#4 = (byte) s#1 -- register_copy 
+  jmp b2
+//SEG13 [3] phi from @1 to @2
+//SEG14 [3] phi (byte) s#4 = (byte) s#2 -- register_copy 
+//SEG15 @2
+b2:
+//SEG16 [4] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- xby=_dec_xby 
+  dex
+//SEG17 [5] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- xby_gt_0_then_la1 
+  cpx #$0
+  bne b1
+//SEG18 @end
+bend:
 
 Removing instruction bbegin:
-Removing instruction b3_from_b2:
+Removing instruction b3:
+Removing instruction b2_from_b3:
+Removing instruction bend:
 Succesful ASM optimization Pass5UnusedLabelElimination
 ASSEMBLER
 //SEG0 @begin
@@ -544,37 +572,36 @@ ASSEMBLER
 //SEG3 [0] phi (byte) i#2 = (byte) 10 -- xby=coby1 
   ldx #$a
   jmp b1
-//SEG4 [0] phi from @3 to @1
+//SEG4 [0] phi from @2 to @1
 //SEG5 [0] phi (byte) s#2 = (byte) s#4 -- register_copy 
 //SEG6 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
 //SEG7 @1
 b1:
-//SEG8 [1] if((byte) i#2>(byte) 5) goto @2 [ i#2 s#2 ] -- xby_gt_coby1_then_la1 
+//SEG8 [1] if((byte) i#2<=(byte) 5) goto @2 [ i#2 s#2 ] -- xby_le_coby1_then_la1 
   cpx #$5
-  beq !+
-  bcs b2
-!:
-//SEG9 [2] phi from @1 to @3
-//SEG10 [2] phi (byte) s#4 = (byte) s#2 -- register_copy 
-//SEG11 @3
-b3:
-//SEG12 [3] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- xby=_dec_xby 
-  dex
-//SEG13 [4] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- xby_gt_0_then_la1 
-  cpx #$0
-  bne b1
-//SEG14 @end
-//SEG15 @2
-b2:
-//SEG16 [5] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- aby=aby_plus_xby 
+  bcc b2
+  beq b2
+//SEG9 @3
+//SEG10 [2] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- aby=aby_plus_xby 
   stx $ff
   clc
   adc $ff
-//SEG17 [2] phi from @2 to @3
-//SEG18 [2] phi (byte) s#4 = (byte) s#1 -- register_copy 
-  jmp b3
+//SEG11 [3] phi from @3 to @2
+//SEG12 [3] phi (byte) s#4 = (byte) s#1 -- register_copy 
+  jmp b2
+//SEG13 [3] phi from @1 to @2
+//SEG14 [3] phi (byte) s#4 = (byte) s#2 -- register_copy 
+//SEG15 @2
+b2:
+//SEG16 [4] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- xby=_dec_xby 
+  dex
+//SEG17 [5] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- xby_gt_0_then_la1 
+  cpx #$0
+  bne b1
+//SEG18 @end
 
 Removing instruction jmp b1
+Removing instruction jmp b2
 Succesful ASM optimization Pass5NextJumpElimination
 ASSEMBLER
 //SEG0 @begin
@@ -583,35 +610,32 @@ ASSEMBLER
   lda #$0
 //SEG3 [0] phi (byte) i#2 = (byte) 10 -- xby=coby1 
   ldx #$a
-//SEG4 [0] phi from @3 to @1
+//SEG4 [0] phi from @2 to @1
 //SEG5 [0] phi (byte) s#2 = (byte) s#4 -- register_copy 
 //SEG6 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
 //SEG7 @1
 b1:
-//SEG8 [1] if((byte) i#2>(byte) 5) goto @2 [ i#2 s#2 ] -- xby_gt_coby1_then_la1 
+//SEG8 [1] if((byte) i#2<=(byte) 5) goto @2 [ i#2 s#2 ] -- xby_le_coby1_then_la1 
   cpx #$5
-  beq !+
-  bcs b2
-!:
-//SEG9 [2] phi from @1 to @3
-//SEG10 [2] phi (byte) s#4 = (byte) s#2 -- register_copy 
-//SEG11 @3
-b3:
-//SEG12 [3] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- xby=_dec_xby 
-  dex
-//SEG13 [4] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- xby_gt_0_then_la1 
-  cpx #$0
-  bne b1
-//SEG14 @end
-//SEG15 @2
-b2:
-//SEG16 [5] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- aby=aby_plus_xby 
+  bcc b2
+  beq b2
+//SEG9 @3
+//SEG10 [2] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- aby=aby_plus_xby 
   stx $ff
   clc
   adc $ff
-//SEG17 [2] phi from @2 to @3
-//SEG18 [2] phi (byte) s#4 = (byte) s#1 -- register_copy 
-  jmp b3
+//SEG11 [3] phi from @3 to @2
+//SEG12 [3] phi (byte) s#4 = (byte) s#1 -- register_copy 
+//SEG13 [3] phi from @1 to @2
+//SEG14 [3] phi (byte) s#4 = (byte) s#2 -- register_copy 
+//SEG15 @2
+b2:
+//SEG16 [4] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- xby=_dec_xby 
+  dex
+//SEG17 [5] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- xby_gt_0_then_la1 
+  cpx #$0
+  bne b1
+//SEG18 @end
 
 FINAL SYMBOL TABLE
 (label) @1
@@ -637,33 +661,30 @@ FINAL CODE
   lda #$0
 //SEG3 [0] phi (byte) i#2 = (byte) 10 -- xby=coby1 
   ldx #$a
-//SEG4 [0] phi from @3 to @1
+//SEG4 [0] phi from @2 to @1
 //SEG5 [0] phi (byte) s#2 = (byte) s#4 -- register_copy 
 //SEG6 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
 //SEG7 @1
 b1:
-//SEG8 [1] if((byte) i#2>(byte) 5) goto @2 [ i#2 s#2 ] -- xby_gt_coby1_then_la1 
+//SEG8 [1] if((byte) i#2<=(byte) 5) goto @2 [ i#2 s#2 ] -- xby_le_coby1_then_la1 
   cpx #$5
-  beq !+
-  bcs b2
-!:
-//SEG9 [2] phi from @1 to @3
-//SEG10 [2] phi (byte) s#4 = (byte) s#2 -- register_copy 
-//SEG11 @3
-b3:
-//SEG12 [3] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- xby=_dec_xby 
-  dex
-//SEG13 [4] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- xby_gt_0_then_la1 
-  cpx #$0
-  bne b1
-//SEG14 @end
-//SEG15 @2
-b2:
-//SEG16 [5] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- aby=aby_plus_xby 
+  bcc b2
+  beq b2
+//SEG9 @3
+//SEG10 [2] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- aby=aby_plus_xby 
   stx $ff
   clc
   adc $ff
-//SEG17 [2] phi from @2 to @3
-//SEG18 [2] phi (byte) s#4 = (byte) s#1 -- register_copy 
-  jmp b3
+//SEG11 [3] phi from @3 to @2
+//SEG12 [3] phi (byte) s#4 = (byte) s#1 -- register_copy 
+//SEG13 [3] phi from @1 to @2
+//SEG14 [3] phi (byte) s#4 = (byte) s#2 -- register_copy 
+//SEG15 @2
+b2:
+//SEG16 [4] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- xby=_dec_xby 
+  dex
+//SEG17 [5] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- xby_gt_0_then_la1 
+  cpx #$0
+  bne b1
+//SEG18 @end
 

src/main/java/dk/camelot64/kickc/test/ref/loopsplit.asm

@@ -9,12 +9,11 @@ main: {
     rts
   b2:
     cpx #$32
-    beq !+
-    bcs b4
-  !:
-    dey
-    jmp b1
-  b4:
+    bcc b4
+    beq b4
     iny
     jmp b1
+  b4:
+    dey
+    jmp b1
 }

src/main/java/dk/camelot64/kickc/test/ref/loopsplit.cfg

@@ -4,9 +4,9 @@
 @end: scope:[]  from @begin
 main: scope:[main]  from @begin
   to:main::@1
-main::@1: scope:[main]  from main main::@4 main::@5
-  [1] (byte) main::s#3 ← phi( main/(byte) 0 main::@4/(byte) main::s#1 main::@5/(byte) main::s#2 ) [ main::i#2 main::s#3 ]
-  [1] (byte) main::i#2 ← phi( main/(byte) 100 main::@4/(byte) main::i#1 main::@5/(byte) main::i#1 ) [ main::i#2 main::s#3 ]
+main::@1: scope:[main]  from main main::@4 main::@8
+  [1] (byte) main::s#3 ← phi( main/(byte) 0 main::@4/(byte) main::s#1 main::@8/(byte) main::s#2 ) [ main::i#2 main::s#3 ]
+  [1] (byte) main::i#2 ← phi( main/(byte) 100 main::@4/(byte) main::i#1 main::@8/(byte) main::i#1 ) [ main::i#2 main::s#3 ]
   [2] (byte) main::i#1 ← -- (byte) main::i#2 [ main::i#1 main::s#3 ]
   [3] if((byte) main::i#1>(byte) 0) goto main::@2 [ main::i#1 main::s#3 ]
   to:main::@return
@@ -14,11 +14,11 @@ main::@return: scope:[main]  from main::@1
   [4] return  [ ]
   to:@return
 main::@2: scope:[main]  from main::@1
-  [5] if((byte) main::i#1>(byte) 50) goto main::@4 [ main::i#1 main::s#3 ]
-  to:main::@5
-main::@5: scope:[main]  from main::@2
-  [6] (byte) main::s#2 ← -- (byte) main::s#3 [ main::i#1 main::s#2 ]
+  [5] if((byte) main::i#1<=(byte) 50) goto main::@4 [ main::i#1 main::s#3 ]
+  to:main::@8
+main::@8: scope:[main]  from main::@2
+  [6] (byte) main::s#2 ← ++ (byte) main::s#3 [ main::i#1 main::s#2 ]
   to:main::@1
 main::@4: scope:[main]  from main::@2
-  [7] (byte) main::s#1 ← ++ (byte) main::s#3 [ main::i#1 main::s#1 ]
+  [7] (byte) main::s#1 ← -- (byte) main::s#3 [ main::i#1 main::s#1 ]
   to:main::@1

src/main/java/dk/camelot64/kickc/test/ref/loopsplit.log

@@ -27,14 +27,13 @@ main::@1:
   goto main::@3
 main::@2:
   (boolean~) main::$1 ← (byte) main::i > (byte) 50
-  if((boolean~) main::$1) goto main::@4
+  (boolean~) main::$2 ← ! (boolean~) main::$1
+  if((boolean~) main::$2) goto main::@4
+  (byte) main::s ← ++ (byte) main::s
   goto main::@5
 main::@4:
-  (byte) main::s ← ++ (byte) main::s
-  goto main::@6
-main::@5:
   (byte) main::s ← -- (byte) main::s
-main::@6:
+main::@5:
   goto main::@1
 main::@3:
 main::@return:
@@ -46,12 +45,12 @@ SYMBOLS
 (void()) main()
 (boolean~) main::$0
 (boolean~) main::$1
+(boolean~) main::$2
 (label) main::@1
 (label) main::@2
 (label) main::@3
 (label) main::@4
 (label) main::@5
-(label) main::@6
 (label) main::@return
 (byte) main::i
 (byte) main::s
@@ -64,36 +63,33 @@ main: scope:[main]  from
   (byte) main::i ← (byte) 100
   (byte) main::s ← (byte) 0
   to:main::@1
-main::@1: scope:[main]  from main main::@6
+main::@1: scope:[main]  from main main::@5
   (byte) main::i ← -- (byte) main::i
   (boolean~) main::$0 ← (byte) main::i > (byte) 0
   if((boolean~) main::$0) goto main::@2
-  to:main::@7
-main::@2: scope:[main]  from main::@1 main::@8
+  to:main::@6
+main::@2: scope:[main]  from main::@1 main::@7
   (boolean~) main::$1 ← (byte) main::i > (byte) 50
-  if((boolean~) main::$1) goto main::@4
-  to:main::@9
-main::@7: scope:[main]  from main::@1
+  (boolean~) main::$2 ← ! (boolean~) main::$1
+  if((boolean~) main::$2) goto main::@4
+  to:main::@8
+main::@6: scope:[main]  from main::@1
   to:main::@3
-main::@3: scope:[main]  from main::@12 main::@7
+main::@3: scope:[main]  from main::@10 main::@6
   to:main::@return
-main::@8: scope:[main]  from
+main::@7: scope:[main]  from
   to:main::@2
-main::@4: scope:[main]  from main::@10 main::@2
-  (byte) main::s ← ++ (byte) main::s
-  to:main::@6
-main::@9: scope:[main]  from main::@2
-  to:main::@5
-main::@5: scope:[main]  from main::@11 main::@9
+main::@4: scope:[main]  from main::@2 main::@9
   (byte) main::s ← -- (byte) main::s
-  to:main::@6
-main::@10: scope:[main]  from
-  to:main::@4
-main::@6: scope:[main]  from main::@4 main::@5
-  to:main::@1
-main::@11: scope:[main]  from
   to:main::@5
-main::@12: scope:[main]  from
+main::@8: scope:[main]  from main::@2
+  (byte) main::s ← ++ (byte) main::s
+  to:main::@5
+main::@5: scope:[main]  from main::@4 main::@8
+  to:main::@1
+main::@9: scope:[main]  from
+  to:main::@4
+main::@10: scope:[main]  from
   to:main::@3
 main::@return: scope:[main]  from main::@3
   return 
@@ -102,14 +98,12 @@ main::@return: scope:[main]  from main::@3
   to:@end
 @end: scope:[]  from @1
 
-Removing empty block main::@7
+Removing empty block main::@6
 Removing empty block main::@3
-Removing empty block main::@8
+Removing empty block main::@7
+Removing empty block main::@5
 Removing empty block main::@9
 Removing empty block main::@10
-Removing empty block main::@6
-Removing empty block main::@11
-Removing empty block main::@12
 Removing empty block @1
 CONTROL FLOW GRAPH
 @begin: scope:[]  from
@@ -119,21 +113,22 @@ main: scope:[main]  from
   (byte) main::i ← (byte) 100
   (byte) main::s ← (byte) 0
   to:main::@1
-main::@1: scope:[main]  from main main::@4 main::@5
+main::@1: scope:[main]  from main main::@4 main::@8
   (byte) main::i ← -- (byte) main::i
   (boolean~) main::$0 ← (byte) main::i > (byte) 0
   if((boolean~) main::$0) goto main::@2
   to:main::@return
 main::@2: scope:[main]  from main::@1
   (boolean~) main::$1 ← (byte) main::i > (byte) 50
-  if((boolean~) main::$1) goto main::@4
-  to:main::@5
+  (boolean~) main::$2 ← ! (boolean~) main::$1
+  if((boolean~) main::$2) goto main::@4
+  to:main::@8
 main::@4: scope:[main]  from main::@2
-  (byte) main::s ← ++ (byte) main::s
-  to:main::@1
-main::@5: scope:[main]  from main::@2
   (byte) main::s ← -- (byte) main::s
   to:main::@1
+main::@8: scope:[main]  from main::@2
+  (byte) main::s ← ++ (byte) main::s
+  to:main::@1
 main::@return: scope:[main]  from main::@1
   return 
   to:@return
@@ -151,21 +146,22 @@ main: scope:[main]  from @begin
   (byte) main::i ← (byte) 100
   (byte) main::s ← (byte) 0
   to:main::@1
-main::@1: scope:[main]  from main main::@4 main::@5
+main::@1: scope:[main]  from main main::@4 main::@8
   (byte) main::i ← -- (byte) main::i
   (boolean~) main::$0 ← (byte) main::i > (byte) 0
   if((boolean~) main::$0) goto main::@2
   to:main::@return
 main::@2: scope:[main]  from main::@1
   (boolean~) main::$1 ← (byte) main::i > (byte) 50
-  if((boolean~) main::$1) goto main::@4
-  to:main::@5
+  (boolean~) main::$2 ← ! (boolean~) main::$1
+  if((boolean~) main::$2) goto main::@4
+  to:main::@8
 main::@4: scope:[main]  from main::@2
-  (byte) main::s ← ++ (byte) main::s
-  to:main::@1
-main::@5: scope:[main]  from main::@2
   (byte) main::s ← -- (byte) main::s
   to:main::@1
+main::@8: scope:[main]  from main::@2
+  (byte) main::s ← ++ (byte) main::s
+  to:main::@1
 main::@return: scope:[main]  from main::@1
   return 
   to:@return
@@ -184,9 +180,9 @@ main: scope:[main]  from @begin
   (byte) main::i#0 ← (byte) 100
   (byte) main::s#0 ← (byte) 0
   to:main::@1
-main::@1: scope:[main]  from main main::@4 main::@5
-  (byte) main::s#6 ← phi( main/(byte) main::s#0 main::@4/(byte) main::s#1 main::@5/(byte) main::s#2 )
-  (byte) main::i#2 ← phi( main/(byte) main::i#0 main::@4/(byte) main::i#4 main::@5/(byte) main::i#5 )
+main::@1: scope:[main]  from main main::@4 main::@8
+  (byte) main::s#6 ← phi( main/(byte) main::s#0 main::@4/(byte) main::s#1 main::@8/(byte) main::s#2 )
+  (byte) main::i#2 ← phi( main/(byte) main::i#0 main::@4/(byte) main::i#4 main::@8/(byte) main::i#5 )
   (byte) main::i#1 ← -- (byte) main::i#2
   (boolean~) main::$0 ← (byte) main::i#1 > (byte) 0
   if((boolean~) main::$0) goto main::@2
@@ -195,17 +191,18 @@ main::@2: scope:[main]  from main::@1
   (byte) main::s#5 ← phi( main::@1/(byte) main::s#6 )
   (byte) main::i#3 ← phi( main::@1/(byte) main::i#1 )
   (boolean~) main::$1 ← (byte) main::i#3 > (byte) 50
-  if((boolean~) main::$1) goto main::@4
-  to:main::@5
+  (boolean~) main::$2 ← ! (boolean~) main::$1
+  if((boolean~) main::$2) goto main::@4
+  to:main::@8
 main::@4: scope:[main]  from main::@2
   (byte) main::i#4 ← phi( main::@2/(byte) main::i#3 )
   (byte) main::s#3 ← phi( main::@2/(byte) main::s#5 )
-  (byte) main::s#1 ← ++ (byte) main::s#3
+  (byte) main::s#1 ← -- (byte) main::s#3
   to:main::@1
-main::@5: scope:[main]  from main::@2
+main::@8: scope:[main]  from main::@2
   (byte) main::i#5 ← phi( main::@2/(byte) main::i#3 )
   (byte) main::s#4 ← phi( main::@2/(byte) main::s#5 )
-  (byte) main::s#2 ← -- (byte) main::s#4
+  (byte) main::s#2 ← ++ (byte) main::s#4
   to:main::@1
 main::@return: scope:[main]  from main::@1
   return 
@@ -222,9 +219,9 @@ main: scope:[main]  from @begin
   (byte) main::i#0 ← (byte) 100
   (byte) main::s#0 ← (byte) 0
   to:main::@1
-main::@1: scope:[main]  from main main::@4 main::@5
-  (byte) main::s#6 ← phi( main/(byte) main::s#0 main::@4/(byte) main::s#1 main::@5/(byte) main::s#2 )
-  (byte) main::i#2 ← phi( main/(byte) main::i#0 main::@4/(byte) main::i#4 main::@5/(byte) main::i#5 )
+main::@1: scope:[main]  from main main::@4 main::@8
+  (byte) main::s#6 ← phi( main/(byte) main::s#0 main::@4/(byte) main::s#1 main::@8/(byte) main::s#2 )
+  (byte) main::i#2 ← phi( main/(byte) main::i#0 main::@4/(byte) main::i#4 main::@8/(byte) main::i#5 )
   (byte) main::i#1 ← -- (byte) main::i#2
   (boolean~) main::$0 ← (byte) main::i#1 > (byte) 0
   if((boolean~) main::$0) goto main::@2
@@ -233,17 +230,18 @@ main::@2: scope:[main]  from main::@1
   (byte) main::s#5 ← phi( main::@1/(byte) main::s#6 )
   (byte) main::i#3 ← phi( main::@1/(byte) main::i#1 )
   (boolean~) main::$1 ← (byte) main::i#3 > (byte) 50
-  if((boolean~) main::$1) goto main::@4
-  to:main::@5
+  (boolean~) main::$2 ← ! (boolean~) main::$1
+  if((boolean~) main::$2) goto main::@4
+  to:main::@8
 main::@4: scope:[main]  from main::@2
   (byte) main::i#4 ← phi( main::@2/(byte) main::i#3 )
   (byte) main::s#3 ← phi( main::@2/(byte) main::s#5 )
-  (byte) main::s#1 ← ++ (byte) main::s#3
+  (byte) main::s#1 ← -- (byte) main::s#3
   to:main::@1
-main::@5: scope:[main]  from main::@2
+main::@8: scope:[main]  from main::@2
   (byte) main::i#5 ← phi( main::@2/(byte) main::i#3 )
   (byte) main::s#4 ← phi( main::@2/(byte) main::s#5 )
-  (byte) main::s#2 ← -- (byte) main::s#4
+  (byte) main::s#2 ← ++ (byte) main::s#4
   to:main::@1
 main::@return: scope:[main]  from main::@1
   return 
@@ -260,9 +258,9 @@ main: scope:[main]  from @begin
   (byte) main::i#0 ← (byte) 100
   (byte) main::s#0 ← (byte) 0
   to:main::@1
-main::@1: scope:[main]  from main main::@4 main::@5
-  (byte) main::s#6 ← phi( main/(byte) main::s#0 main::@4/(byte) main::s#1 main::@5/(byte) main::s#2 )
-  (byte) main::i#2 ← phi( main/(byte) main::i#0 main::@4/(byte) main::i#4 main::@5/(byte) main::i#5 )
+main::@1: scope:[main]  from main main::@4 main::@8
+  (byte) main::s#6 ← phi( main/(byte) main::s#0 main::@4/(byte) main::s#1 main::@8/(byte) main::s#2 )
+  (byte) main::i#2 ← phi( main/(byte) main::i#0 main::@4/(byte) main::i#4 main::@8/(byte) main::i#5 )
   (byte) main::i#1 ← -- (byte) main::i#2
   (boolean~) main::$0 ← (byte) main::i#1 > (byte) 0
   if((boolean~) main::$0) goto main::@2
@@ -271,17 +269,18 @@ main::@2: scope:[main]  from main::@1
   (byte) main::s#5 ← phi( main::@1/(byte) main::s#6 )
   (byte) main::i#3 ← phi( main::@1/(byte) main::i#1 )
   (boolean~) main::$1 ← (byte) main::i#3 > (byte) 50
-  if((boolean~) main::$1) goto main::@4
-  to:main::@5
+  (boolean~) main::$2 ← ! (boolean~) main::$1
+  if((boolean~) main::$2) goto main::@4
+  to:main::@8
 main::@4: scope:[main]  from main::@2
   (byte) main::i#4 ← phi( main::@2/(byte) main::i#3 )
   (byte) main::s#3 ← phi( main::@2/(byte) main::s#5 )
-  (byte) main::s#1 ← ++ (byte) main::s#3
+  (byte) main::s#1 ← -- (byte) main::s#3
   to:main::@1
-main::@5: scope:[main]  from main::@2
+main::@8: scope:[main]  from main::@2
   (byte) main::i#5 ← phi( main::@2/(byte) main::i#3 )
   (byte) main::s#4 ← phi( main::@2/(byte) main::s#5 )
-  (byte) main::s#2 ← -- (byte) main::s#4
+  (byte) main::s#2 ← ++ (byte) main::s#4
   to:main::@1
 main::@return: scope:[main]  from main::@1
   return 
@@ -297,9 +296,9 @@ CONTROL FLOW GRAPH
   to:@end
 main: scope:[main]  from @begin
   to:main::@1
-main::@1: scope:[main]  from main main::@4 main::@5
-  (byte) main::s#6 ← phi( main/(byte) 0 main::@4/(byte) main::s#1 main::@5/(byte) main::s#2 )
-  (byte) main::i#2 ← phi( main/(byte) 100 main::@4/(byte) main::i#4 main::@5/(byte) main::i#5 )
+main::@1: scope:[main]  from main main::@4 main::@8
+  (byte) main::s#6 ← phi( main/(byte) 0 main::@4/(byte) main::s#1 main::@8/(byte) main::s#2 )
+  (byte) main::i#2 ← phi( main/(byte) 100 main::@4/(byte) main::i#4 main::@8/(byte) main::i#5 )
   (byte) main::i#1 ← -- (byte) main::i#2
   (boolean~) main::$0 ← (byte) main::i#1 > (byte) 0
   if((boolean~) main::$0) goto main::@2
@@ -308,17 +307,54 @@ main::@2: scope:[main]  from main::@1
   (byte) main::s#5 ← phi( main::@1/(byte) main::s#6 )
   (byte) main::i#3 ← phi( main::@1/(byte) main::i#1 )
   (boolean~) main::$1 ← (byte) main::i#3 > (byte) 50
-  if((boolean~) main::$1) goto main::@4
-  to:main::@5
+  (boolean~) main::$2 ← ! (boolean~) main::$1
+  if((boolean~) main::$2) goto main::@4
+  to:main::@8
 main::@4: scope:[main]  from main::@2
   (byte) main::i#4 ← phi( main::@2/(byte) main::i#3 )
   (byte) main::s#3 ← phi( main::@2/(byte) main::s#5 )
-  (byte) main::s#1 ← ++ (byte) main::s#3
+  (byte) main::s#1 ← -- (byte) main::s#3
   to:main::@1
-main::@5: scope:[main]  from main::@2
+main::@8: scope:[main]  from main::@2
   (byte) main::i#5 ← phi( main::@2/(byte) main::i#3 )
   (byte) main::s#4 ← phi( main::@2/(byte) main::s#5 )
-  (byte) main::s#2 ← -- (byte) main::s#4
+  (byte) main::s#2 ← ++ (byte) main::s#4
+  to:main::@1
+main::@return: scope:[main]  from main::@1
+  return 
+  to:@return
+@end: scope:[]  from @begin
+
+Inversing boolean not (boolean~) main::$2 ← (byte) main::i#3 <= (byte) 50 from (boolean~) main::$1 ← (byte) main::i#3 > (byte) 50
+Succesful SSA optimization Pass2UnaryNotSimplification
+CONTROL FLOW GRAPH
+@begin: scope:[]  from
+  call main param-assignment
+  to:@end
+main: scope:[main]  from @begin
+  to:main::@1
+main::@1: scope:[main]  from main main::@4 main::@8
+  (byte) main::s#6 ← phi( main/(byte) 0 main::@4/(byte) main::s#1 main::@8/(byte) main::s#2 )
+  (byte) main::i#2 ← phi( main/(byte) 100 main::@4/(byte) main::i#4 main::@8/(byte) main::i#5 )
+  (byte) main::i#1 ← -- (byte) main::i#2
+  (boolean~) main::$0 ← (byte) main::i#1 > (byte) 0
+  if((boolean~) main::$0) goto main::@2
+  to:main::@return
+main::@2: scope:[main]  from main::@1
+  (byte) main::s#5 ← phi( main::@1/(byte) main::s#6 )
+  (byte) main::i#3 ← phi( main::@1/(byte) main::i#1 )
+  (boolean~) main::$2 ← (byte) main::i#3 <= (byte) 50
+  if((boolean~) main::$2) goto main::@4
+  to:main::@8
+main::@4: scope:[main]  from main::@2
+  (byte) main::i#4 ← phi( main::@2/(byte) main::i#3 )
+  (byte) main::s#3 ← phi( main::@2/(byte) main::s#5 )
+  (byte) main::s#1 ← -- (byte) main::s#3
+  to:main::@1
+main::@8: scope:[main]  from main::@2
+  (byte) main::i#5 ← phi( main::@2/(byte) main::i#3 )
+  (byte) main::s#4 ← phi( main::@2/(byte) main::s#5 )
+  (byte) main::s#2 ← ++ (byte) main::s#4
   to:main::@1
 main::@return: scope:[main]  from main::@1
   return 
@@ -334,22 +370,22 @@ CONTROL FLOW GRAPH
   to:@end
 main: scope:[main]  from @begin
   to:main::@1
-main::@1: scope:[main]  from main main::@4 main::@5
-  (byte) main::s#3 ← phi( main/(byte) 0 main::@4/(byte) main::s#1 main::@5/(byte) main::s#2 )
-  (byte) main::i#2 ← phi( main/(byte) 100 main::@4/(byte) main::i#1 main::@5/(byte) main::i#1 )
+main::@1: scope:[main]  from main main::@4 main::@8
+  (byte) main::s#3 ← phi( main/(byte) 0 main::@4/(byte) main::s#1 main::@8/(byte) main::s#2 )
+  (byte) main::i#2 ← phi( main/(byte) 100 main::@4/(byte) main::i#1 main::@8/(byte) main::i#1 )
   (byte) main::i#1 ← -- (byte) main::i#2
   (boolean~) main::$0 ← (byte) main::i#1 > (byte) 0
   if((boolean~) main::$0) goto main::@2
   to:main::@return
 main::@2: scope:[main]  from main::@1
-  (boolean~) main::$1 ← (byte) main::i#1 > (byte) 50
-  if((boolean~) main::$1) goto main::@4
-  to:main::@5
+  (boolean~) main::$2 ← (byte) main::i#1 <= (byte) 50
+  if((boolean~) main::$2) goto main::@4
+  to:main::@8
 main::@4: scope:[main]  from main::@2
-  (byte) main::s#1 ← ++ (byte) main::s#3
+  (byte) main::s#1 ← -- (byte) main::s#3
   to:main::@1
-main::@5: scope:[main]  from main::@2
-  (byte) main::s#2 ← -- (byte) main::s#3
+main::@8: scope:[main]  from main::@2
+  (byte) main::s#2 ← ++ (byte) main::s#3
   to:main::@1
 main::@return: scope:[main]  from main::@1
   return 
@@ -357,7 +393,7 @@ main::@return: scope:[main]  from main::@1
 @end: scope:[]  from @begin
 
 Simple Condition (boolean~) main::$0 if((byte) main::i#1>(byte) 0) goto main::@2
-Simple Condition (boolean~) main::$1 if((byte) main::i#1>(byte) 50) goto main::@4
+Simple Condition (boolean~) main::$2 if((byte) main::i#1<=(byte) 50) goto main::@4
 Succesful SSA optimization Pass2ConditionalJumpSimplification
 CONTROL FLOW GRAPH
 @begin: scope:[]  from
@@ -365,28 +401,28 @@ CONTROL FLOW GRAPH
   to:@end
 main: scope:[main]  from @begin
   to:main::@1
-main::@1: scope:[main]  from main main::@4 main::@5
-  (byte) main::s#3 ← phi( main/(byte) 0 main::@4/(byte) main::s#1 main::@5/(byte) main::s#2 )
-  (byte) main::i#2 ← phi( main/(byte) 100 main::@4/(byte) main::i#1 main::@5/(byte) main::i#1 )
+main::@1: scope:[main]  from main main::@4 main::@8
+  (byte) main::s#3 ← phi( main/(byte) 0 main::@4/(byte) main::s#1 main::@8/(byte) main::s#2 )
+  (byte) main::i#2 ← phi( main/(byte) 100 main::@4/(byte) main::i#1 main::@8/(byte) main::i#1 )
   (byte) main::i#1 ← -- (byte) main::i#2
   if((byte) main::i#1>(byte) 0) goto main::@2
   to:main::@return
 main::@2: scope:[main]  from main::@1
-  if((byte) main::i#1>(byte) 50) goto main::@4
-  to:main::@5
+  if((byte) main::i#1<=(byte) 50) goto main::@4
+  to:main::@8
 main::@4: scope:[main]  from main::@2
-  (byte) main::s#1 ← ++ (byte) main::s#3
+  (byte) main::s#1 ← -- (byte) main::s#3
   to:main::@1
-main::@5: scope:[main]  from main::@2
-  (byte) main::s#2 ← -- (byte) main::s#3
+main::@8: scope:[main]  from main::@2
+  (byte) main::s#2 ← ++ (byte) main::s#3
   to:main::@1
 main::@return: scope:[main]  from main::@1
   return 
   to:@return
 @end: scope:[]  from @begin
 
-Block Sequence Planned @begin @end main main::@1 main::@return main::@2 main::@5 main::@4 
-Block Sequence Planned @begin @end main main::@1 main::@return main::@2 main::@5 main::@4 
+Block Sequence Planned @begin @end main main::@1 main::@return main::@2 main::@8 main::@4 
+Block Sequence Planned @begin @end main main::@1 main::@return main::@2 main::@8 main::@4 
 CONTROL FLOW GRAPH - PHI LIFTED
 @begin: scope:[]  from
   call main param-assignment
@@ -394,9 +430,9 @@ CONTROL FLOW GRAPH - PHI LIFTED
 @end: scope:[]  from @begin
 main: scope:[main]  from @begin
   to:main::@1
-main::@1: scope:[main]  from main main::@4 main::@5
-  (byte) main::s#3 ← phi( main/(byte) 0 main::@4/(byte~) main::s#7 main::@5/(byte~) main::s#8 )
-  (byte) main::i#2 ← phi( main/(byte) 100 main::@4/(byte~) main::i#6 main::@5/(byte~) main::i#7 )
+main::@1: scope:[main]  from main main::@4 main::@8
+  (byte) main::s#3 ← phi( main/(byte) 0 main::@4/(byte~) main::s#7 main::@8/(byte~) main::s#8 )
+  (byte) main::i#2 ← phi( main/(byte) 100 main::@4/(byte~) main::i#6 main::@8/(byte~) main::i#7 )
   (byte) main::i#1 ← -- (byte) main::i#2
   if((byte) main::i#1>(byte) 0) goto main::@2
   to:main::@return
@@ -404,15 +440,15 @@ main::@return: scope:[main]  from main::@1
   return 
   to:@return
 main::@2: scope:[main]  from main::@1
-  if((byte) main::i#1>(byte) 50) goto main::@4
-  to:main::@5
-main::@5: scope:[main]  from main::@2
-  (byte) main::s#2 ← -- (byte) main::s#3
+  if((byte) main::i#1<=(byte) 50) goto main::@4
+  to:main::@8
+main::@8: scope:[main]  from main::@2
+  (byte) main::s#2 ← ++ (byte) main::s#3
   (byte~) main::i#7 ← (byte) main::i#1
   (byte~) main::s#8 ← (byte) main::s#2
   to:main::@1
 main::@4: scope:[main]  from main::@2
-  (byte) main::s#1 ← ++ (byte) main::s#3
+  (byte) main::s#1 ← -- (byte) main::s#3
   (byte~) main::i#6 ← (byte) main::i#1
   (byte~) main::s#7 ← (byte) main::s#1
   to:main::@1
@@ -428,9 +464,9 @@ CONTROL FLOW GRAPH - LIVE RANGES
 @end: scope:[]  from @begin
 main: scope:[main]  from @begin
   to:main::@1
-main::@1: scope:[main]  from main main::@4 main::@5
-  [1] (byte) main::s#3 ← phi( main/(byte) 0 main::@4/(byte~) main::s#7 main::@5/(byte~) main::s#8 ) [ main::i#2 main::s#3 ]
-  [1] (byte) main::i#2 ← phi( main/(byte) 100 main::@4/(byte~) main::i#6 main::@5/(byte~) main::i#7 ) [ main::i#2 main::s#3 ]
+main::@1: scope:[main]  from main main::@4 main::@8
+  [1] (byte) main::s#3 ← phi( main/(byte) 0 main::@4/(byte~) main::s#7 main::@8/(byte~) main::s#8 ) [ main::i#2 main::s#3 ]
+  [1] (byte) main::i#2 ← phi( main/(byte) 100 main::@4/(byte~) main::i#6 main::@8/(byte~) main::i#7 ) [ main::i#2 main::s#3 ]
   [2] (byte) main::i#1 ← -- (byte) main::i#2 [ main::i#1 main::s#3 ]
   [3] if((byte) main::i#1>(byte) 0) goto main::@2 [ main::i#1 main::s#3 ]
   to:main::@return
@@ -438,15 +474,15 @@ main::@return: scope:[main]  from main::@1
   [4] return  [ ]
   to:@return
 main::@2: scope:[main]  from main::@1
-  [5] if((byte) main::i#1>(byte) 50) goto main::@4 [ main::i#1 main::s#3 ]
-  to:main::@5
-main::@5: scope:[main]  from main::@2
-  [6] (byte) main::s#2 ← -- (byte) main::s#3 [ main::i#1 main::s#2 ]
+  [5] if((byte) main::i#1<=(byte) 50) goto main::@4 [ main::i#1 main::s#3 ]
+  to:main::@8
+main::@8: scope:[main]  from main::@2
+  [6] (byte) main::s#2 ← ++ (byte) main::s#3 [ main::i#1 main::s#2 ]
   [7] (byte~) main::i#7 ← (byte) main::i#1 [ main::i#7 main::s#2 ]
   [8] (byte~) main::s#8 ← (byte) main::s#2 [ main::i#7 main::s#8 ]
   to:main::@1
 main::@4: scope:[main]  from main::@2
-  [9] (byte) main::s#1 ← ++ (byte) main::s#3 [ main::i#1 main::s#1 ]
+  [9] (byte) main::s#1 ← -- (byte) main::s#3 [ main::i#1 main::s#1 ]
   [10] (byte~) main::i#6 ← (byte) main::i#1 [ main::i#6 main::s#1 ]
   [11] (byte~) main::s#7 ← (byte) main::s#1 [ main::i#6 main::s#7 ]
   to:main::@1
@@ -457,7 +493,7 @@ Coalesced [8] main::s#8 ← main::s#2
 Coalesced (already) [10] main::i#6 ← main::i#1
 Coalesced [11] main::s#7 ← main::s#1
 Coalesced down to 2 phi equivalence classes
-Block Sequence Planned @begin @end main main::@1 main::@return main::@2 main::@5 main::@4 
+Block Sequence Planned @begin @end main main::@1 main::@return main::@2 main::@8 main::@4 
 Propagating live ranges...
 Propagating live ranges...
 Propagating live ranges...
@@ -469,9 +505,9 @@ CONTROL FLOW GRAPH - PHI MEM COALESCED
 @end: scope:[]  from @begin
 main: scope:[main]  from @begin
   to:main::@1
-main::@1: scope:[main]  from main main::@4 main::@5
-  [1] (byte) main::s#3 ← phi( main/(byte) 0 main::@4/(byte) main::s#1 main::@5/(byte) main::s#2 ) [ main::i#2 main::s#3 ]
-  [1] (byte) main::i#2 ← phi( main/(byte) 100 main::@4/(byte) main::i#1 main::@5/(byte) main::i#1 ) [ main::i#2 main::s#3 ]
+main::@1: scope:[main]  from main main::@4 main::@8
+  [1] (byte) main::s#3 ← phi( main/(byte) 0 main::@4/(byte) main::s#1 main::@8/(byte) main::s#2 ) [ main::i#2 main::s#3 ]
+  [1] (byte) main::i#2 ← phi( main/(byte) 100 main::@4/(byte) main::i#1 main::@8/(byte) main::i#1 ) [ main::i#2 main::s#3 ]
   [2] (byte) main::i#1 ← -- (byte) main::i#2 [ main::i#1 main::s#3 ]
   [3] if((byte) main::i#1>(byte) 0) goto main::@2 [ main::i#1 main::s#3 ]
   to:main::@return
@@ -479,13 +515,13 @@ main::@return: scope:[main]  from main::@1
   [4] return  [ ]
   to:@return
 main::@2: scope:[main]  from main::@1
-  [5] if((byte) main::i#1>(byte) 50) goto main::@4 [ main::i#1 main::s#3 ]
-  to:main::@5
-main::@5: scope:[main]  from main::@2
-  [6] (byte) main::s#2 ← -- (byte) main::s#3 [ main::i#1 main::s#2 ]
+  [5] if((byte) main::i#1<=(byte) 50) goto main::@4 [ main::i#1 main::s#3 ]
+  to:main::@8
+main::@8: scope:[main]  from main::@2
+  [6] (byte) main::s#2 ← ++ (byte) main::s#3 [ main::i#1 main::s#2 ]
   to:main::@1
 main::@4: scope:[main]  from main::@2
-  [7] (byte) main::s#1 ← ++ (byte) main::s#3 [ main::i#1 main::s#1 ]
+  [7] (byte) main::s#1 ← -- (byte) main::s#3 [ main::i#1 main::s#1 ]
   to:main::@1
 
 CALL GRAPH
@@ -498,22 +534,22 @@ main dominated by  @begin main
 main::@1 dominated by  @begin main::@1 main 
 main::@return dominated by  main::@return @begin main::@1 main 
 main::@2 dominated by  @begin main::@2 main::@1 main 
-main::@5 dominated by  @begin main::@2 main::@1 main::@5 main 
+main::@8 dominated by  main::@8 @begin main::@2 main::@1 main 
 main::@4 dominated by  @begin main::@2 main::@1 main::@4 main 
 
-Found back edge: Loop head: main::@1 tails: main::@5 blocks: null
+Found back edge: Loop head: main::@1 tails: main::@8 blocks: null
 Found back edge: Loop head: main::@1 tails: main::@4 blocks: null
-Populated: Loop head: main::@1 tails: main::@5 blocks: main::@5 main::@2 main::@1 
+Populated: Loop head: main::@1 tails: main::@8 blocks: main::@8 main::@2 main::@1 
 Populated: Loop head: main::@1 tails: main::@4 blocks: main::@4 main::@2 main::@1 
-Coalesced: Loop head: main::@1 tails: main::@5 main::@4 blocks: main::@5 main::@2 main::@1 main::@4 
+Coalesced: Loop head: main::@1 tails: main::@8 main::@4 blocks: main::@8 main::@2 main::@1 main::@4 
 NATURAL LOOPS
-Loop head: main::@1 tails: main::@5 main::@4 blocks: main::@5 main::@2 main::@1 main::@4 
+Loop head: main::@1 tails: main::@8 main::@4 blocks: main::@8 main::@2 main::@1 main::@4 
 
 Found 0 loops in scope []
 Found 1 loops in scope [main]
-  Loop head: main::@1 tails: main::@5 main::@4 blocks: main::@5 main::@2 main::@1 main::@4 
+  Loop head: main::@1 tails: main::@8 main::@4 blocks: main::@8 main::@2 main::@1 main::@4 
 NATURAL LOOPS WITH DEPTH
-Loop head: main::@1 tails: main::@5 main::@4 blocks: main::@5 main::@2 main::@1 main::@4  depth: 1
+Loop head: main::@1 tails: main::@8 main::@4 blocks: main::@8 main::@2 main::@1 main::@4  depth: 1
 
 
 VARIABLE REGISTER WEIGHTS
@@ -567,26 +603,25 @@ main: {
     rts
   //SEG12 main::@2
   b2:
-  //SEG13 [5] if((byte) main::i#1>(byte) 50) goto main::@4 [ main::i#1 main::s#3 ] -- zpby1_gt_coby1_then_la1 
+  //SEG13 [5] if((byte) main::i#1<=(byte) 50) goto main::@4 [ main::i#1 main::s#3 ] -- zpby1_le_coby1_then_la1 
     lda $2
     cmp #$32
-    beq !+
-    bcs b4
-  !:
-    jmp b5
-  //SEG14 main::@5
-  b5:
-  //SEG15 [6] (byte) main::s#2 ← -- (byte) main::s#3 [ main::i#1 main::s#2 ] -- zpby1=_dec_zpby1 
-    dec $3
-  //SEG16 [1] phi from main::@5 to main::@1
-  b1_from_b5:
+    bcc b4
+    beq b4
+    jmp b8
+  //SEG14 main::@8
+  b8:
+  //SEG15 [6] (byte) main::s#2 ← ++ (byte) main::s#3 [ main::i#1 main::s#2 ] -- zpby1=_inc_zpby1 
+    inc $3
+  //SEG16 [1] phi from main::@8 to main::@1
+  b1_from_b8:
   //SEG17 [1] phi (byte) main::s#3 = (byte) main::s#2 -- register_copy 
   //SEG18 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
     jmp b1
   //SEG19 main::@4
   b4:
-  //SEG20 [7] (byte) main::s#1 ← ++ (byte) main::s#3 [ main::i#1 main::s#1 ] -- zpby1=_inc_zpby1 
-    inc $3
+  //SEG20 [7] (byte) main::s#1 ← -- (byte) main::s#3 [ main::i#1 main::s#1 ] -- zpby1=_dec_zpby1 
+    dec $3
   //SEG21 [1] phi from main::@4 to main::@1
   b1_from_b4:
   //SEG22 [1] phi (byte) main::s#3 = (byte) main::s#1 -- register_copy 
@@ -607,7 +642,7 @@ Uplifting [] best 380 combination
 Removing instruction jmp bend
 Removing instruction jmp b1
 Removing instruction jmp breturn
-Removing instruction jmp b5
+Removing instruction jmp b8
 Succesful ASM optimization Pass5NextJumpElimination
 ASSEMBLER
 //SEG0 @begin
@@ -637,24 +672,23 @@ main: {
     rts
   //SEG12 main::@2
   b2:
-  //SEG13 [5] if((byte) main::i#1>(byte) 50) goto main::@4 [ main::i#1 main::s#3 ] -- xby_gt_coby1_then_la1 
+  //SEG13 [5] if((byte) main::i#1<=(byte) 50) goto main::@4 [ main::i#1 main::s#3 ] -- xby_le_coby1_then_la1 
     cpx #$32
-    beq !+
-    bcs b4
-  !:
-  //SEG14 main::@5
-  b5:
-  //SEG15 [6] (byte) main::s#2 ← -- (byte) main::s#3 [ main::i#1 main::s#2 ] -- yby=_dec_yby 
-    dey
-  //SEG16 [1] phi from main::@5 to main::@1
-  b1_from_b5:
+    bcc b4
+    beq b4
+  //SEG14 main::@8
+  b8:
+  //SEG15 [6] (byte) main::s#2 ← ++ (byte) main::s#3 [ main::i#1 main::s#2 ] -- yby=_inc_yby 
+    iny
+  //SEG16 [1] phi from main::@8 to main::@1
+  b1_from_b8:
   //SEG17 [1] phi (byte) main::s#3 = (byte) main::s#2 -- register_copy 
   //SEG18 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
     jmp b1
   //SEG19 main::@4
   b4:
-  //SEG20 [7] (byte) main::s#1 ← ++ (byte) main::s#3 [ main::i#1 main::s#1 ] -- yby=_inc_yby 
-    iny
+  //SEG20 [7] (byte) main::s#1 ← -- (byte) main::s#3 [ main::i#1 main::s#1 ] -- yby=_dec_yby 
+    dey
   //SEG21 [1] phi from main::@4 to main::@1
   b1_from_b4:
   //SEG22 [1] phi (byte) main::s#3 = (byte) main::s#1 -- register_copy 
@@ -666,8 +700,8 @@ Removing instruction bbegin:
 Removing instruction bend:
 Removing instruction b1_from_main:
 Removing instruction breturn:
-Removing instruction b5:
-Removing instruction b1_from_b5:
+Removing instruction b8:
+Removing instruction b1_from_b8:
 Removing instruction b1_from_b4:
 Succesful ASM optimization Pass5UnusedLabelElimination
 ASSEMBLER
@@ -694,22 +728,21 @@ main: {
     rts
   //SEG12 main::@2
   b2:
-  //SEG13 [5] if((byte) main::i#1>(byte) 50) goto main::@4 [ main::i#1 main::s#3 ] -- xby_gt_coby1_then_la1 
+  //SEG13 [5] if((byte) main::i#1<=(byte) 50) goto main::@4 [ main::i#1 main::s#3 ] -- xby_le_coby1_then_la1 
     cpx #$32
-    beq !+
-    bcs b4
-  !:
-  //SEG14 main::@5
-  //SEG15 [6] (byte) main::s#2 ← -- (byte) main::s#3 [ main::i#1 main::s#2 ] -- yby=_dec_yby 
-    dey
-  //SEG16 [1] phi from main::@5 to main::@1
+    bcc b4
+    beq b4
+  //SEG14 main::@8
+  //SEG15 [6] (byte) main::s#2 ← ++ (byte) main::s#3 [ main::i#1 main::s#2 ] -- yby=_inc_yby 
+    iny
+  //SEG16 [1] phi from main::@8 to main::@1
   //SEG17 [1] phi (byte) main::s#3 = (byte) main::s#2 -- register_copy 
   //SEG18 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
     jmp b1
   //SEG19 main::@4
   b4:
-  //SEG20 [7] (byte) main::s#1 ← ++ (byte) main::s#3 [ main::i#1 main::s#1 ] -- yby=_inc_yby 
-    iny
+  //SEG20 [7] (byte) main::s#1 ← -- (byte) main::s#3 [ main::i#1 main::s#1 ] -- yby=_dec_yby 
+    dey
   //SEG21 [1] phi from main::@4 to main::@1
   //SEG22 [1] phi (byte) main::s#3 = (byte) main::s#1 -- register_copy 
   //SEG23 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
@@ -723,7 +756,7 @@ FINAL SYMBOL TABLE
 (label) main::@1
 (label) main::@2
 (label) main::@4
-(label) main::@5
+(label) main::@8
 (label) main::@return
 (byte) main::i
 (byte) main::i#1 reg byte x 11.0
@@ -760,22 +793,21 @@ main: {
     rts
   //SEG12 main::@2
   b2:
-  //SEG13 [5] if((byte) main::i#1>(byte) 50) goto main::@4 [ main::i#1 main::s#3 ] -- xby_gt_coby1_then_la1 
+  //SEG13 [5] if((byte) main::i#1<=(byte) 50) goto main::@4 [ main::i#1 main::s#3 ] -- xby_le_coby1_then_la1 
     cpx #$32
-    beq !+
-    bcs b4
-  !:
-  //SEG14 main::@5
-  //SEG15 [6] (byte) main::s#2 ← -- (byte) main::s#3 [ main::i#1 main::s#2 ] -- yby=_dec_yby 
-    dey
-  //SEG16 [1] phi from main::@5 to main::@1
+    bcc b4
+    beq b4
+  //SEG14 main::@8
+  //SEG15 [6] (byte) main::s#2 ← ++ (byte) main::s#3 [ main::i#1 main::s#2 ] -- yby=_inc_yby 
+    iny
+  //SEG16 [1] phi from main::@8 to main::@1
   //SEG17 [1] phi (byte) main::s#3 = (byte) main::s#2 -- register_copy 
   //SEG18 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
     jmp b1
   //SEG19 main::@4
   b4:
-  //SEG20 [7] (byte) main::s#1 ← ++ (byte) main::s#3 [ main::i#1 main::s#1 ] -- yby=_inc_yby 
-    iny
+  //SEG20 [7] (byte) main::s#1 ← -- (byte) main::s#3 [ main::i#1 main::s#1 ] -- yby=_dec_yby 
+    dey
   //SEG21 [1] phi from main::@4 to main::@1
   //SEG22 [1] phi (byte) main::s#3 = (byte) main::s#1 -- register_copy 
   //SEG23 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 

src/main/java/dk/camelot64/kickc/test/ref/loopsplit.sym

@@ -4,7 +4,7 @@
 (label) main::@1
 (label) main::@2
 (label) main::@4
-(label) main::@5
+(label) main::@8
 (label) main::@return
 (byte) main::i
 (byte) main::i#1 reg byte x 11.0

src/main/java/dk/camelot64/kickc/test/ref/voronoi.asm

@@ -46,40 +46,45 @@ animate: {
     sta $1000
     lda $1000
     cmp #$28
-    beq b1
-  b2:
+    bne b1
+    lda #$0
+    sta $1000
+  b1:
     lda $1100
     clc
     adc #$1
     sta $1100
     lda $1100
     cmp #$19
-    beq b3
-  b4:
+    bne b2
+    lda #$0
+    sta $1100
+  b2:
     ldx $1001
     dex
     stx $1001
     lda $1001
     cmp #$ff
-    beq b5
-  b6:
+    bne b3
+    lda #$28
+    sta $1001
+  b3:
     lda $1102
     clc
     adc #$1
     sta $1102
     lda $1102
     cmp #$19
-    beq b7
-  b8:
+    bne b4
+    lda #$0
+    sta $1102
+  b4:
     ldx $1103
     dex
     stx $1103
     lda $1103
     cmp #$ff
-    beq b9
-  breturn:
-    rts
-  b9:
+    bne breturn
     lda #$19
     sta $1103
     lda $1003
@@ -88,30 +93,13 @@ animate: {
     sta $1003
     lda $1003
     cmp #$28
-    bcs b11
-    jmp breturn
-  b11:
+    bcc breturn
     lda $1003
     sec
     sbc #$28
     sta $1003
-    jmp breturn
-  b7:
-    lda #$0
-    sta $1102
-    jmp b8
-  b5:
-    lda #$28
-    sta $1001
-    jmp b6
-  b3:
-    lda #$0
-    sta $1100
-    jmp b4
-  b1:
-    lda #$0
-    sta $1000
-    jmp b2
+  breturn:
+    rts
 }
 render: {
     lda #<$d800
@@ -161,58 +149,58 @@ findcol: {
     sta $b
     lda $9
     cmp $7
-    beq b2
-  b3:
-    lda $9
-    cmp $7
-    bcc b6
-    lda $9
-    sec
-    sbc $7
-    sta $7
-  b8:
+    bne b2
     lda $a
     cmp $b
-    bcc b9
-    lda $a
-    sec
-    sbc $b
-    clc
-    adc $7
-  b11:
-    cmp $6
-    bcc b12
-  b13:
-    inx
-    cpx $8
-    bcc b1
-    jmp breturn
-  breturn_from_b2:
+    bne b2
     ldy #$0
   breturn:
     rts
-  b12:
-    ldy $1200,x
-    sta $6
-    jmp b13
-  b9:
+  b2:
+    lda $9
+    cmp $7
+    bcs b4
+    lda $7
+    sec
+    sbc $9
+    sta $7
+  b5:
+    lda $a
+    cmp $b
+    bcs b6
     lda $b
     sec
     sbc $a
     clc
     adc $7
-    jmp b11
-  b6:
-    lda $7
-    sec
-    sbc $9
-    sta $7
+  b7:
+    cmp $6
+    bcs b21
+    ldy $1200,x
+  b8:
+    inx
+    cpx $8
+    bcc b19
+    jmp breturn
+  b19:
+    sta $6
+    jmp b1
+  b21:
+    lda $6
     jmp b8
-  b2:
+  b6:
     lda $a
-    cmp $b
-    beq breturn_from_b2
-    jmp b3
+    sec
+    sbc $b
+    clc
+    adc $7
+    jmp b7
+  b4:
+    lda $9
+    sec
+    sbc $7
+    sta $7
+    jmp b5
 }
 initscreen: {
     lda #<$400

src/main/java/dk/camelot64/kickc/test/ref/voronoi.cfg

@@ -40,64 +40,64 @@ animate: scope:[animate]  from main::@10
   [13] (byte~) animate::$1 ← (byte~) animate::$0 + (byte) 1 [ animate::$1 ]
   [14] *((word) 4096) ← (byte~) animate::$1 [ ]
   [15] (byte~) animate::$2 ← * (word) 4096 [ animate::$2 ]
-  [16] if((byte~) animate::$2==(byte) 40) goto animate::@1 [ ]
-  to:animate::@2
-animate::@2: scope:[animate]  from animate animate::@1
-  [17] (byte~) animate::$4 ← * (word) 4352 [ animate::$4 ]
-  [18] (byte~) animate::$5 ← (byte~) animate::$4 + (byte) 1 [ animate::$5 ]
-  [19] *((word) 4352) ← (byte~) animate::$5 [ ]
-  [20] (byte~) animate::$6 ← * (word) 4352 [ animate::$6 ]
-  [21] if((byte~) animate::$6==(byte) 25) goto animate::@3 [ ]
-  to:animate::@4
-animate::@4: scope:[animate]  from animate::@2 animate::@3
-  [22] (byte~) animate::$8 ← * (word) 4097 [ animate::$8 ]
-  [23] (byte~) animate::$9 ← (byte~) animate::$8 - (byte) 1 [ animate::$9 ]
-  [24] *((word) 4097) ← (byte~) animate::$9 [ ]
-  [25] (byte~) animate::$10 ← * (word) 4097 [ animate::$10 ]
-  [26] if((byte~) animate::$10==(byte) 255) goto animate::@5 [ ]
-  to:animate::@6
-animate::@6: scope:[animate]  from animate::@4 animate::@5
-  [27] (byte~) animate::$12 ← * (word) 4354 [ animate::$12 ]
-  [28] (byte~) animate::$13 ← (byte~) animate::$12 + (byte) 1 [ animate::$13 ]
-  [29] *((word) 4354) ← (byte~) animate::$13 [ ]
-  [30] (byte~) animate::$14 ← * (word) 4354 [ animate::$14 ]
-  [31] if((byte~) animate::$14==(byte) 25) goto animate::@7 [ ]
+  [16] if((byte~) animate::$2!=(byte) 40) goto animate::@1 [ ]
+  to:animate::@7
+animate::@7: scope:[animate]  from animate
+  [17] *((word) 4096) ← (byte) 0 [ ]
+  to:animate::@1
+animate::@1: scope:[animate]  from animate animate::@7
+  [18] (byte~) animate::$5 ← * (word) 4352 [ animate::$5 ]
+  [19] (byte~) animate::$6 ← (byte~) animate::$5 + (byte) 1 [ animate::$6 ]
+  [20] *((word) 4352) ← (byte~) animate::$6 [ ]
+  [21] (byte~) animate::$7 ← * (word) 4352 [ animate::$7 ]
+  [22] if((byte~) animate::$7!=(byte) 25) goto animate::@2 [ ]
   to:animate::@8
-animate::@8: scope:[animate]  from animate::@6 animate::@7
-  [32] (byte~) animate::$16 ← * (word) 4355 [ animate::$16 ]
-  [33] (byte~) animate::$17 ← (byte~) animate::$16 - (byte) 1 [ animate::$17 ]
-  [34] *((word) 4355) ← (byte~) animate::$17 [ ]
-  [35] (byte~) animate::$18 ← * (word) 4355 [ animate::$18 ]
-  [36] if((byte~) animate::$18==(byte) 255) goto animate::@9 [ ]
+animate::@8: scope:[animate]  from animate::@1
+  [23] *((word) 4352) ← (byte) 0 [ ]
+  to:animate::@2
+animate::@2: scope:[animate]  from animate::@1 animate::@8
+  [24] (byte~) animate::$10 ← * (word) 4097 [ animate::$10 ]
+  [25] (byte~) animate::$11 ← (byte~) animate::$10 - (byte) 1 [ animate::$11 ]
+  [26] *((word) 4097) ← (byte~) animate::$11 [ ]
+  [27] (byte~) animate::$12 ← * (word) 4097 [ animate::$12 ]
+  [28] if((byte~) animate::$12!=(byte) 255) goto animate::@3 [ ]
+  to:animate::@9
+animate::@9: scope:[animate]  from animate::@2
+  [29] *((word) 4097) ← (byte) 40 [ ]
+  to:animate::@3
+animate::@3: scope:[animate]  from animate::@2 animate::@9
+  [30] (byte~) animate::$15 ← * (word) 4354 [ animate::$15 ]
+  [31] (byte~) animate::$16 ← (byte~) animate::$15 + (byte) 1 [ animate::$16 ]
+  [32] *((word) 4354) ← (byte~) animate::$16 [ ]
+  [33] (byte~) animate::$17 ← * (word) 4354 [ animate::$17 ]
+  [34] if((byte~) animate::$17!=(byte) 25) goto animate::@4 [ ]
+  to:animate::@10
+animate::@10: scope:[animate]  from animate::@3
+  [35] *((word) 4354) ← (byte) 0 [ ]
+  to:animate::@4
+animate::@4: scope:[animate]  from animate::@10 animate::@3
+  [36] (byte~) animate::$20 ← * (word) 4355 [ animate::$20 ]
+  [37] (byte~) animate::$21 ← (byte~) animate::$20 - (byte) 1 [ animate::$21 ]
+  [38] *((word) 4355) ← (byte~) animate::$21 [ ]
+  [39] (byte~) animate::$22 ← * (word) 4355 [ animate::$22 ]
+  [40] if((byte~) animate::$22!=(byte) 255) goto animate::@return [ ]
+  to:animate::@11
+animate::@11: scope:[animate]  from animate::@4
+  [41] *((word) 4355) ← (byte) 25 [ ]
+  [42] (byte~) animate::$25 ← * (word) 4099 [ animate::$25 ]
+  [43] (byte~) animate::$26 ← (byte~) animate::$25 + (byte) 7 [ animate::$26 ]
+  [44] *((word) 4099) ← (byte~) animate::$26 [ ]
+  [45] (byte~) animate::$27 ← * (word) 4099 [ animate::$27 ]
+  [46] if((byte~) animate::$27<(byte) 40) goto animate::@return [ ]
+  to:animate::@12
+animate::@12: scope:[animate]  from animate::@11
+  [47] (byte~) animate::$30 ← * (word) 4099 [ animate::$30 ]
+  [48] (byte~) animate::$31 ← (byte~) animate::$30 - (byte) 40 [ animate::$31 ]
+  [49] *((word) 4099) ← (byte~) animate::$31 [ ]
   to:animate::@return
-animate::@return: scope:[animate]  from animate::@11 animate::@8 animate::@9
-  [37] return  [ ]
+animate::@return: scope:[animate]  from animate::@11 animate::@12 animate::@4
+  [50] return  [ ]
   to:@return
-animate::@9: scope:[animate]  from animate::@8
-  [38] *((word) 4355) ← (byte) 25 [ ]
-  [39] (byte~) animate::$20 ← * (word) 4099 [ animate::$20 ]
-  [40] (byte~) animate::$21 ← (byte~) animate::$20 + (byte) 7 [ animate::$21 ]
-  [41] *((word) 4099) ← (byte~) animate::$21 [ ]
-  [42] (byte~) animate::$22 ← * (word) 4099 [ animate::$22 ]
-  [43] if((byte~) animate::$22>=(byte) 40) goto animate::@11 [ ]
-  to:animate::@return
-animate::@11: scope:[animate]  from animate::@9
-  [44] (byte~) animate::$24 ← * (word) 4099 [ animate::$24 ]
-  [45] (byte~) animate::$25 ← (byte~) animate::$24 - (byte) 40 [ animate::$25 ]
-  [46] *((word) 4099) ← (byte~) animate::$25 [ ]
-  to:animate::@return
-animate::@7: scope:[animate]  from animate::@6
-  [47] *((word) 4354) ← (byte) 0 [ ]
-  to:animate::@8
-animate::@5: scope:[animate]  from animate::@4
-  [48] *((word) 4097) ← (byte) 40 [ ]
-  to:animate::@6
-animate::@3: scope:[animate]  from animate::@2
-  [49] *((word) 4352) ← (byte) 0 [ ]
-  to:animate::@4
-animate::@1: scope:[animate]  from animate
-  [50] *((word) 4096) ← (byte) 0 [ ]
-  to:animate::@2
 render: scope:[render]  from main::@1
   to:render::@1
 render::@1: scope:[render]  from render render::@3
@@ -126,77 +126,82 @@ render::@return: scope:[render]  from render::@3
   to:@return
 findcol: scope:[findcol]  from render::@2
   to:findcol::@1
-findcol::@1: scope:[findcol]  from findcol findcol::@13
-  [64] (byte) findcol::mincol#11 ← phi( findcol/(byte) 0 findcol::@13/(byte) findcol::mincol#2 ) [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
-  [64] (byte) findcol::mindiff#10 ← phi( findcol/(byte) 255 findcol::@13/(byte) findcol::mindiff#11 ) [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
-  [64] (byte) findcol::i#12 ← phi( findcol/(byte) 0 findcol::@13/(byte) findcol::i#1 ) [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
+findcol::@1: scope:[findcol]  from findcol findcol::@19
+  [64] (byte) findcol::mincol#11 ← phi( findcol/(byte) 0 findcol::@19/(byte) findcol::mincol#2 ) [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
+  [64] (byte) findcol::mindiff#10 ← phi( findcol/(byte) 255 findcol::@19/(byte~) findcol::mindiff#13 ) [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
+  [64] (byte) findcol::i#12 ← phi( findcol/(byte) 0 findcol::@19/(byte) findcol::i#1 ) [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
   [65] (byte) findcol::xp#0 ← (word) 4096 *idx (byte) findcol::i#12 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::xp#0 findcol::y#0 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
   [66] (byte) findcol::yp#0 ← (word) 4352 *idx (byte) findcol::i#12 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::xp#0 findcol::y#0 findcol::yp#0 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
-  [67] if((byte) findcol::x#0==(byte) findcol::xp#0) goto findcol::@2 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::xp#0 findcol::y#0 findcol::yp#0 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
-  to:findcol::@3
-findcol::@3: scope:[findcol]  from findcol::@1 findcol::@2
-  [68] if((byte) findcol::x#0<(byte) findcol::xp#0) goto findcol::@6 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::xp#0 findcol::y#0 findcol::yp#0 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
-  to:findcol::@7
-findcol::@7: scope:[findcol]  from findcol::@3
-  [69] (byte) findcol::diff#1 ← (byte) findcol::x#0 - (byte) findcol::xp#0 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::diff#1 findcol::y#0 findcol::yp#0 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
-  to:findcol::@8
-findcol::@8: scope:[findcol]  from findcol::@6 findcol::@7
-  [70] (byte) findcol::diff#4 ← phi( findcol::@6/(byte) findcol::diff#0 findcol::@7/(byte) findcol::diff#1 ) [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::yp#0 findcol::diff#4 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
-  [71] if((byte) findcol::y#0<(byte) findcol::yp#0) goto findcol::@9 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::yp#0 findcol::diff#4 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
-  to:findcol::@10
-findcol::@10: scope:[findcol]  from findcol::@8
-  [72] (byte~) findcol::$10 ← (byte) findcol::y#0 - (byte) findcol::yp#0 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::diff#4 findcol::$10 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
-  [73] (byte) findcol::diff#3 ← (byte) findcol::diff#4 + (byte~) findcol::$10 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::diff#3 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
-  to:findcol::@11
-findcol::@11: scope:[findcol]  from findcol::@10 findcol::@9
-  [74] (byte) findcol::diff#6 ← phi( findcol::@10/(byte) findcol::diff#3 findcol::@9/(byte) findcol::diff#2 ) [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::diff#6 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
-  [75] if((byte) findcol::diff#6<(byte) findcol::mindiff#10) goto findcol::@12 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::diff#6 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
-  to:findcol::@13
-findcol::@13: scope:[findcol]  from findcol::@11 findcol::@12
-  [76] (byte) findcol::mindiff#11 ← phi( findcol::@11/(byte) findcol::mindiff#10 findcol::@12/(byte~) findcol::diff#13 ) [ render::x#2 render::y#2 render::colline#2 findcol::mindiff#11 findcol::mincol#2 findcol::i#12 findcol::x#0 findcol::y#0 numpoints#1 ]
-  [76] (byte) findcol::mincol#2 ← phi( findcol::@11/(byte) findcol::mincol#11 findcol::@12/(byte) findcol::mincol#1 ) [ render::x#2 render::y#2 render::colline#2 findcol::mindiff#11 findcol::mincol#2 findcol::i#12 findcol::x#0 findcol::y#0 numpoints#1 ]
-  [77] (byte) findcol::i#1 ← ++ (byte) findcol::i#12 [ render::x#2 render::y#2 render::colline#2 findcol::i#1 findcol::mindiff#11 findcol::mincol#2 findcol::x#0 findcol::y#0 numpoints#1 ]
-  [78] if((byte) findcol::i#1<(byte) numpoints#1) goto findcol::@1 [ render::x#2 render::y#2 render::colline#2 findcol::i#1 findcol::mindiff#11 findcol::mincol#2 findcol::x#0 findcol::y#0 numpoints#1 ]
+  [67] if((byte) findcol::x#0!=(byte) findcol::xp#0) goto findcol::@2 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::xp#0 findcol::y#0 findcol::yp#0 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
+  to:findcol::@9
+findcol::@9: scope:[findcol]  from findcol::@1
+  [68] if((byte) findcol::y#0!=(byte) findcol::yp#0) goto findcol::@2 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::xp#0 findcol::y#0 findcol::yp#0 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
   to:findcol::@return
-findcol::@return: scope:[findcol]  from findcol::@13 findcol::@2
-  [79] (byte) findcol::return#0 ← phi( findcol::@13/(byte) findcol::mincol#2 findcol::@2/(byte) 0 ) [ render::x#2 render::y#2 findcol::return#0 render::colline#2 ]
-  [80] return  [ render::x#2 render::y#2 findcol::return#0 render::colline#2 ]
+findcol::@return: scope:[findcol]  from findcol::@8 findcol::@9
+  [69] (byte) findcol::return#0 ← phi( findcol::@8/(byte) findcol::mincol#2 findcol::@9/(byte) 0 ) [ render::x#2 render::y#2 findcol::return#0 render::colline#2 ]
+  [70] return  [ render::x#2 render::y#2 findcol::return#0 render::colline#2 ]
   to:@return
-findcol::@12: scope:[findcol]  from findcol::@11
-  [81] (byte) findcol::mincol#1 ← (word) 4608 *idx (byte) findcol::i#12 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::diff#6 findcol::mincol#1 numpoints#1 ]
-  [82] (byte~) findcol::diff#13 ← (byte) findcol::diff#6 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::mincol#1 findcol::diff#13 numpoints#1 ]
-  to:findcol::@13
-findcol::@9: scope:[findcol]  from findcol::@8
-  [83] (byte~) findcol::$8 ← (byte) findcol::yp#0 - (byte) findcol::y#0 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::diff#4 findcol::mindiff#10 findcol::mincol#11 numpoints#1 findcol::$8 ]
-  [84] (byte) findcol::diff#2 ← (byte) findcol::diff#4 + (byte~) findcol::$8 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::diff#2 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
-  to:findcol::@11
-findcol::@6: scope:[findcol]  from findcol::@3
-  [85] (byte) findcol::diff#0 ← (byte) findcol::xp#0 - (byte) findcol::x#0 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::diff#0 findcol::y#0 findcol::yp#0 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
+findcol::@2: scope:[findcol]  from findcol::@1 findcol::@9
+  [71] if((byte) findcol::x#0>=(byte) findcol::xp#0) goto findcol::@4 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::xp#0 findcol::y#0 findcol::yp#0 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
+  to:findcol::@12
+findcol::@12: scope:[findcol]  from findcol::@2
+  [72] (byte) findcol::diff#1 ← (byte) findcol::xp#0 - (byte) findcol::x#0 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::yp#0 findcol::diff#1 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
+  to:findcol::@5
+findcol::@5: scope:[findcol]  from findcol::@12 findcol::@4
+  [73] (byte) findcol::diff#4 ← phi( findcol::@12/(byte) findcol::diff#1 findcol::@4/(byte) findcol::diff#0 ) [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::yp#0 findcol::diff#4 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
+  [74] if((byte) findcol::y#0>=(byte) findcol::yp#0) goto findcol::@6 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::yp#0 findcol::diff#4 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
+  to:findcol::@14
+findcol::@14: scope:[findcol]  from findcol::@5
+  [75] (byte~) findcol::$12 ← (byte) findcol::yp#0 - (byte) findcol::y#0 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::diff#4 findcol::$12 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
+  [76] (byte) findcol::diff#3 ← (byte) findcol::diff#4 + (byte~) findcol::$12 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::diff#3 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
+  to:findcol::@7
+findcol::@7: scope:[findcol]  from findcol::@14 findcol::@6
+  [77] (byte) findcol::diff#6 ← phi( findcol::@14/(byte) findcol::diff#3 findcol::@6/(byte) findcol::diff#2 ) [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::diff#6 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
+  [78] if((byte) findcol::diff#6>=(byte) findcol::mindiff#10) goto findcol::@21 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::diff#6 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
+  to:findcol::@16
+findcol::@16: scope:[findcol]  from findcol::@7
+  [79] (byte) findcol::mincol#1 ← (word) 4608 *idx (byte) findcol::i#12 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::diff#6 findcol::mincol#1 numpoints#1 ]
   to:findcol::@8
-findcol::@2: scope:[findcol]  from findcol::@1
-  [86] if((byte) findcol::y#0==(byte) findcol::yp#0) goto findcol::@return [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::xp#0 findcol::y#0 findcol::yp#0 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
-  to:findcol::@3
+findcol::@8: scope:[findcol]  from findcol::@16 findcol::@21
+  [80] (byte) findcol::mindiff#11 ← phi( findcol::@16/(byte) findcol::diff#6 findcol::@21/(byte~) findcol::mindiff#14 ) [ render::x#2 render::y#2 render::colline#2 findcol::mincol#2 findcol::i#12 findcol::x#0 findcol::y#0 numpoints#1 findcol::mindiff#11 ]
+  [80] (byte) findcol::mincol#2 ← phi( findcol::@16/(byte) findcol::mincol#1 findcol::@21/(byte) findcol::mincol#11 ) [ render::x#2 render::y#2 render::colline#2 findcol::mincol#2 findcol::i#12 findcol::x#0 findcol::y#0 numpoints#1 findcol::mindiff#11 ]
+  [81] (byte) findcol::i#1 ← ++ (byte) findcol::i#12 [ render::x#2 render::y#2 render::colline#2 findcol::i#1 findcol::mincol#2 findcol::x#0 findcol::y#0 numpoints#1 findcol::mindiff#11 ]
+  [82] if((byte) findcol::i#1<(byte) numpoints#1) goto findcol::@19 [ render::x#2 render::y#2 render::colline#2 findcol::i#1 findcol::mincol#2 findcol::x#0 findcol::y#0 numpoints#1 findcol::mindiff#11 ]
+  to:findcol::@return
+findcol::@19: scope:[findcol]  from findcol::@8
+  [83] (byte~) findcol::mindiff#13 ← (byte) findcol::mindiff#11 [ render::x#2 render::y#2 render::colline#2 findcol::i#1 findcol::mindiff#13 findcol::mincol#2 findcol::x#0 findcol::y#0 numpoints#1 ]
+  to:findcol::@1
+findcol::@21: scope:[findcol]  from findcol::@7
+  [84] (byte~) findcol::mindiff#14 ← (byte) findcol::mindiff#10 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::mincol#11 findcol::mindiff#14 numpoints#1 ]
+  to:findcol::@8
+findcol::@6: scope:[findcol]  from findcol::@5
+  [85] (byte~) findcol::$14 ← (byte) findcol::y#0 - (byte) findcol::yp#0 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::diff#4 findcol::mindiff#10 findcol::mincol#11 numpoints#1 findcol::$14 ]
+  [86] (byte) findcol::diff#2 ← (byte) findcol::diff#4 + (byte~) findcol::$14 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::diff#2 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
+  to:findcol::@7
+findcol::@4: scope:[findcol]  from findcol::@2
+  [87] (byte) findcol::diff#0 ← (byte) findcol::x#0 - (byte) findcol::xp#0 [ render::x#2 render::y#2 render::colline#2 findcol::i#12 findcol::x#0 findcol::y#0 findcol::yp#0 findcol::diff#0 findcol::mindiff#10 findcol::mincol#11 numpoints#1 ]
+  to:findcol::@5
 initscreen: scope:[initscreen]  from main::@8
   to:initscreen::@1
 initscreen::@1: scope:[initscreen]  from initscreen initscreen::@1
-  [87] (byte*) initscreen::screen#2 ← phi( initscreen/(word) 1024 initscreen::@1/(byte*) initscreen::screen#1 ) [ initscreen::screen#2 ]
-  [88] *((byte*) initscreen::screen#2) ← (byte) 230 [ initscreen::screen#2 ]
-  [89] (byte*) initscreen::screen#1 ← ++ (byte*) initscreen::screen#2 [ initscreen::screen#1 ]
-  [90] if((byte*) initscreen::screen#1<(word) 2024) goto initscreen::@1 [ initscreen::screen#1 ]
+  [88] (byte*) initscreen::screen#2 ← phi( initscreen/(word) 1024 initscreen::@1/(byte*) initscreen::screen#1 ) [ initscreen::screen#2 ]
+  [89] *((byte*) initscreen::screen#2) ← (byte) 230 [ initscreen::screen#2 ]
+  [90] (byte*) initscreen::screen#1 ← ++ (byte*) initscreen::screen#2 [ initscreen::screen#1 ]
+  [91] if((byte*) initscreen::screen#1<(word) 2024) goto initscreen::@1 [ initscreen::screen#1 ]
   to:initscreen::@return
 initscreen::@return: scope:[initscreen]  from initscreen::@1
-  [91] return  [ ]
+  [92] return  [ ]
   to:@return
 addpoint: scope:[addpoint]  from main main::@3 main::@4 main::@5 main::@6 main::@7
-  [92] (byte) addpoint::c#6 ← phi( main/(byte) 1 main::@3/(byte) 2 main::@4/(byte) 3 main::@5/(byte) 4 main::@6/(byte) 5 main::@7/(byte) 7 ) [ numpoints#19 addpoint::x#6 addpoint::y#6 addpoint::c#6 ]
-  [92] (byte) addpoint::y#6 ← phi( main/(byte) 5 main::@3/(byte) 8 main::@4/(byte) 14 main::@5/(byte) 2 main::@6/(byte) 17 main::@7/(byte) 22 ) [ numpoints#19 addpoint::x#6 addpoint::y#6 addpoint::c#6 ]
-  [92] (byte) numpoints#19 ← phi( main/(byte) 0 main::@3/(byte) numpoints#1 main::@4/(byte) numpoints#1 main::@5/(byte) numpoints#1 main::@6/(byte) numpoints#1 main::@7/(byte) numpoints#1 ) [ numpoints#19 addpoint::x#6 addpoint::y#6 addpoint::c#6 ]
-  [92] (byte) addpoint::x#6 ← phi( main/(byte) 5 main::@3/(byte) 15 main::@4/(byte) 6 main::@5/(byte) 34 main::@6/(byte) 21 main::@7/(byte) 31 ) [ numpoints#19 addpoint::x#6 addpoint::y#6 addpoint::c#6 ]
-  [93] *((word) 4096 + (byte) numpoints#19) ← (byte) addpoint::x#6 [ numpoints#19 addpoint::y#6 addpoint::c#6 ]
-  [94] *((word) 4352 + (byte) numpoints#19) ← (byte) addpoint::y#6 [ numpoints#19 addpoint::c#6 ]
-  [95] *((word) 4608 + (byte) numpoints#19) ← (byte) addpoint::c#6 [ numpoints#19 ]
-  [96] (byte) numpoints#1 ← ++ (byte) numpoints#19 [ ]
+  [93] (byte) addpoint::c#6 ← phi( main/(byte) 1 main::@3/(byte) 2 main::@4/(byte) 3 main::@5/(byte) 4 main::@6/(byte) 5 main::@7/(byte) 7 ) [ numpoints#19 addpoint::x#6 addpoint::y#6 addpoint::c#6 ]
+  [93] (byte) addpoint::y#6 ← phi( main/(byte) 5 main::@3/(byte) 8 main::@4/(byte) 14 main::@5/(byte) 2 main::@6/(byte) 17 main::@7/(byte) 22 ) [ numpoints#19 addpoint::x#6 addpoint::y#6 addpoint::c#6 ]
+  [93] (byte) numpoints#19 ← phi( main/(byte) 0 main::@3/(byte) numpoints#1 main::@4/(byte) numpoints#1 main::@5/(byte) numpoints#1 main::@6/(byte) numpoints#1 main::@7/(byte) numpoints#1 ) [ numpoints#19 addpoint::x#6 addpoint::y#6 addpoint::c#6 ]
+  [93] (byte) addpoint::x#6 ← phi( main/(byte) 5 main::@3/(byte) 15 main::@4/(byte) 6 main::@5/(byte) 34 main::@6/(byte) 21 main::@7/(byte) 31 ) [ numpoints#19 addpoint::x#6 addpoint::y#6 addpoint::c#6 ]
+  [94] *((word) 4096 + (byte) numpoints#19) ← (byte) addpoint::x#6 [ numpoints#19 addpoint::y#6 addpoint::c#6 ]
+  [95] *((word) 4352 + (byte) numpoints#19) ← (byte) addpoint::y#6 [ numpoints#19 addpoint::c#6 ]
+  [96] *((word) 4608 + (byte) numpoints#19) ← (byte) addpoint::c#6 [ numpoints#19 ]
+  [97] (byte) numpoints#1 ← ++ (byte) numpoints#19 [ ]
   to:addpoint::@return
 addpoint::@return: scope:[addpoint]  from addpoint
-  [97] return  [ ]
+  [98] return  [ ]
   to:@return

src/main/java/dk/camelot64/kickc/test/ref/voronoi.sym

@@ -17,45 +17,47 @@
 (void()) animate()
 (byte~) animate::$0 reg byte a 4.0
 (byte~) animate::$1 reg byte a 4.0
-(byte~) animate::$10 reg byte a 4.0
+(byte~) animate::$10 reg byte x 4.0
+(byte~) animate::$11 reg byte x 4.0
 (byte~) animate::$12 reg byte a 4.0
-(byte~) animate::$13 reg byte a 4.0
-(byte~) animate::$14 reg byte a 4.0
-(byte~) animate::$16 reg byte x 4.0
-(byte~) animate::$17 reg byte x 4.0
-(byte~) animate::$18 reg byte a 4.0
+(byte~) animate::$15 reg byte a 4.0
+(byte~) animate::$16 reg byte a 4.0
+(byte~) animate::$17 reg byte a 4.0
 (byte~) animate::$2 reg byte a 4.0
-(byte~) animate::$20 reg byte a 4.0
-(byte~) animate::$21 reg byte a 4.0
+(byte~) animate::$20 reg byte x 4.0
+(byte~) animate::$21 reg byte x 4.0
 (byte~) animate::$22 reg byte a 4.0
-(byte~) animate::$24 reg byte a 4.0
 (byte~) animate::$25 reg byte a 4.0
-(byte~) animate::$4 reg byte a 4.0
+(byte~) animate::$26 reg byte a 4.0
+(byte~) animate::$27 reg byte a 4.0
+(byte~) animate::$30 reg byte a 4.0
+(byte~) animate::$31 reg byte a 4.0
 (byte~) animate::$5 reg byte a 4.0
 (byte~) animate::$6 reg byte a 4.0
-(byte~) animate::$8 reg byte x 4.0
-(byte~) animate::$9 reg byte x 4.0
+(byte~) animate::$7 reg byte a 4.0
 (label) animate::@1
+(label) animate::@10
 (label) animate::@11
+(label) animate::@12
 (label) animate::@2
 (label) animate::@3
 (label) animate::@4
-(label) animate::@5
-(label) animate::@6
 (label) animate::@7
 (label) animate::@8
 (label) animate::@9
 (label) animate::@return
 (byte()) findcol((byte) findcol::x , (byte) findcol::y)
-(byte~) findcol::$10 reg byte a 20002.0
-(byte~) findcol::$8 reg byte a 20002.0
+(byte~) findcol::$12 reg byte a 20002.0
+(byte~) findcol::$14 reg byte a 20002.0
 (label) findcol::@1
-(label) findcol::@10
-(label) findcol::@11
 (label) findcol::@12
-(label) findcol::@13
+(label) findcol::@14
+(label) findcol::@16
+(label) findcol::@19
 (label) findcol::@2
-(label) findcol::@3
+(label) findcol::@21
+(label) findcol::@4
+(label) findcol::@5
 (label) findcol::@6
 (label) findcol::@7
 (label) findcol::@8
@@ -64,29 +66,30 @@
 (byte) findcol::diff
 (byte) findcol::diff#0 zp byte:7 20002.0
 (byte) findcol::diff#1 zp byte:7 20002.0
-(byte~) findcol::diff#13 zp byte:6 20002.0
 (byte) findcol::diff#2 reg byte a 20002.0
 (byte) findcol::diff#3 reg byte a 20002.0
 (byte) findcol::diff#4 zp byte:7 10001.0
 (byte) findcol::diff#6 reg byte a 13334.666666666666
 (byte) findcol::i
-(byte) findcol::i#1 reg byte x 15001.5
+(byte) findcol::i#1 reg byte x 10001.0
 (byte) findcol::i#12 reg byte x 2631.842105263158
 (byte) findcol::mincol
-(byte) findcol::mincol#1 reg byte y 10001.0
-(byte) findcol::mincol#11 reg byte y 1250.125
-(byte) findcol::mincol#2 reg byte y 13334.666666666666
+(byte) findcol::mincol#1 reg byte y 20002.0
+(byte) findcol::mincol#11 reg byte y 1176.5882352941176
+(byte) findcol::mincol#2 reg byte y 10001.0
 (byte) findcol::mindiff
 (byte) findcol::mindiff#10 zp byte:6 1875.1875
-(byte) findcol::mindiff#11 zp byte:6 10001.0
+(byte) findcol::mindiff#11 reg byte a 10001.0
+(byte~) findcol::mindiff#13 zp byte:6 20002.0
+(byte~) findcol::mindiff#14 reg byte a 20002.0
 (byte) findcol::return
 (byte) findcol::return#0 reg byte y 3667.333333333333
 (byte) findcol::x
-(byte) findcol::x#0 zp byte:9 1952.6190476190475
+(byte) findcol::x#0 zp byte:9 1863.8636363636363
 (byte) findcol::xp
 (byte) findcol::xp#0 zp byte:7 10001.0
 (byte) findcol::y
-(byte) findcol::y#0 zp byte:10 1952.6190476190475
+(byte) findcol::y#0 zp byte:10 1863.8636363636363
 (byte) findcol::yp
 (byte) findcol::yp#0 zp byte:11 6250.625
 (void()) initscreen()
@@ -107,7 +110,7 @@
 (label) main::@8
 (label) main::@return
 (byte) numpoints
-(byte) numpoints#1 zp byte:8 476.8095238095237
+(byte) numpoints#1 zp byte:8 455.13636363636346
 (byte) numpoints#19 zp byte:8 4.5
 (void()) render()
 (label) render::@1
@@ -119,48 +122,48 @@
 (byte) render::col#0 reg byte a 2002.0
 (byte*) render::colline
 (byte*) render::colline#1 zp ptr byte:3 67.33333333333333
-(byte*) render::colline#2 zp ptr byte:3 37.59375
+(byte*) render::colline#2 zp ptr byte:3 36.45454545454545
 (byte) render::x
 (byte) render::x#1 zp byte:5 1501.5
-(byte) render::x#2 zp byte:5 138.06896551724137
+(byte) render::x#2 zp byte:5 133.46666666666667
 (byte) render::y
 (byte) render::y#1 zp byte:2 151.5
-(byte) render::y#2 zp byte:2 36.45454545454545
+(byte) render::y#2 zp byte:2 35.38235294117647
 
 zp byte:2 [ render::y#2 render::y#1 addpoint::c#6 ]
 zp ptr byte:3 [ render::colline#2 render::colline#1 initscreen::screen#2 initscreen::screen#1 ]
 zp byte:5 [ render::x#2 render::x#1 ]
 reg byte x [ findcol::i#12 findcol::i#1 ]
-zp byte:6 [ findcol::mindiff#10 findcol::mindiff#11 findcol::diff#13 ]
-zp byte:7 [ findcol::diff#4 findcol::diff#0 findcol::diff#1 findcol::xp#0 ]
-reg byte a [ findcol::diff#6 findcol::diff#3 findcol::diff#2 ]
+zp byte:6 [ findcol::mindiff#10 findcol::mindiff#13 ]
 reg byte y [ findcol::return#0 findcol::mincol#11 findcol::mincol#2 findcol::mincol#1 ]
+zp byte:7 [ findcol::diff#4 findcol::diff#1 findcol::diff#0 findcol::xp#0 ]
+reg byte a [ findcol::mindiff#11 findcol::diff#6 findcol::diff#3 findcol::diff#2 findcol::mindiff#14 ]
 reg byte a [ addpoint::x#6 ]
 zp byte:8 [ numpoints#19 numpoints#1 ]
 reg byte y [ addpoint::y#6 ]
 reg byte a [ animate::$0 ]
 reg byte a [ animate::$1 ]
 reg byte a [ animate::$2 ]
-reg byte a [ animate::$4 ]
 reg byte a [ animate::$5 ]
 reg byte a [ animate::$6 ]
-reg byte x [ animate::$8 ]
-reg byte x [ animate::$9 ]
-reg byte a [ animate::$10 ]
+reg byte a [ animate::$7 ]
+reg byte x [ animate::$10 ]
+reg byte x [ animate::$11 ]
 reg byte a [ animate::$12 ]
-reg byte a [ animate::$13 ]
-reg byte a [ animate::$14 ]
-reg byte x [ animate::$16 ]
-reg byte x [ animate::$17 ]
-reg byte a [ animate::$18 ]
-reg byte a [ animate::$20 ]
-reg byte a [ animate::$21 ]
+reg byte a [ animate::$15 ]
+reg byte a [ animate::$16 ]
+reg byte a [ animate::$17 ]
+reg byte x [ animate::$20 ]
+reg byte x [ animate::$21 ]
 reg byte a [ animate::$22 ]
-reg byte a [ animate::$24 ]
 reg byte a [ animate::$25 ]
+reg byte a [ animate::$26 ]
+reg byte a [ animate::$27 ]
+reg byte a [ animate::$30 ]
+reg byte a [ animate::$31 ]
 zp byte:9 [ findcol::x#0 ]
 zp byte:10 [ findcol::y#0 ]
 reg byte a [ render::col#0 ]
 zp byte:11 [ findcol::yp#0 ]
-reg byte a [ findcol::$10 ]
-reg byte a [ findcol::$8 ]
+reg byte a [ findcol::$12 ]
+reg byte a [ findcol::$14 ]