Implemented phi transition assignment clobber checking.

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

@@ -177,7 +177,9 @@ public class AsmProgram {
       }
 
       public void decIndent() {
-         this.indent = this.indent.substring(0, this.indent.length()-2);
+         if(this.indent.length()>=2) {
+            this.indent = this.indent.substring(0, this.indent.length() - 2);
+         }
       }
 
       public String getIndent() {

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

@@ -1,6 +1,7 @@
 package dk.camelot64.kickc.asm;
 
 import dk.camelot64.kickc.asm.parser.AsmClobber;
+import dk.camelot64.kickc.model.PhiTransitions;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -36,6 +37,12 @@ public class AsmSegment {
     */
    private String fragment;
 
+   /** If the segment represents a PHI transition (See. {@link PhiTransitions}) this contains the transition ID. */
+   private String phiTransitionId;
+
+   /** If the segment is an assignment in a PHI transition this contains the index of the assignment within the transition. */
+   private Integer phiTransitionAssignmentIdx;
+
    public AsmSegment(int index, Integer statementIdx, String source) {
       this.lines = new ArrayList<>();
       this.index = index;
@@ -67,6 +74,21 @@ public class AsmSegment {
       this.fragment  = fragment;
    }
 
+   public String getPhiTransitionId() {
+      return phiTransitionId;
+   }
+
+   public void setPhiTransitionId(String phiTransitionId) {
+      this.phiTransitionId = phiTransitionId;
+   }
+
+   public Integer getPhiTransitionAssignmentIdx() {
+      return phiTransitionAssignmentIdx;
+   }
+
+   public void setPhiTransitionAssignmentIdx(Integer phiTransitionAssignmentIdx) {
+      this.phiTransitionAssignmentIdx = phiTransitionAssignmentIdx;
+   }
 
    /**
     * Get the number of bytes the segment occupies in memory.
@@ -122,6 +144,13 @@ public class AsmSegment {
          if (source != null) {
             out.append(" ").append(source);
          }
+         if(phiTransitionId!=null) {
+            out.append(" [").append(phiTransitionId);
+            if(phiTransitionAssignmentIdx!=null) {
+               out.append("#").append(phiTransitionAssignmentIdx);
+            }
+            out.append("]");
+         }
          if (fragment!=null) {
             out.append(" -- ");
             out.append(fragment).append(" ");

src/main/java/dk/camelot64/kickc/fragment/AsmFragment.java

@@ -69,7 +69,6 @@ public class AsmFragment {
       this.bindings = new LinkedHashMap<>();
       this.program = program;
       setSignature(assignmentWithAluSignature(assignment, assignmentAlu));
-
    }
 
    /**

src/main/java/dk/camelot64/kickc/fragment/asm/zpptrby1=zpptrby1_minus_coby1.asm

@@ -0,0 +1,7 @@
+lda {zpptrby1}
+sec
+sbc #{coby1}
+sta {zpptrby1}
+bcs !+
+dec {zpptrby1}+1
+!:

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

@@ -0,0 +1,253 @@
+package dk.camelot64.kickc.model;
+
+import java.util.*;
+
+/**
+ * Keeps track of the phi transitions into a single block during code generation.
+ * Used to ensure that duplicate transitions are only code generated once.
+ * Also used to ensure that the assignments of each transition is generated in the optimal sequence.
+ */
+public class PhiTransitions {
+
+   /** The program used for accessing information. */
+   private Program program;
+
+   /** The destination block for the phi transitions */
+   private ControlFlowBlock toBlock;
+
+   /** The phi-block of the to-block. */
+   private StatementPhiBlock phiBlock;
+
+   /** Maps from-block to the transition from the from-block to the to-block. */
+   private Map<ControlFlowBlock, PhiTransition> transitions;
+
+   public PhiTransitions(Program program, ControlFlowBlock toBlock) {
+      this.program = program;
+      this.toBlock = toBlock;
+      this.transitions = new LinkedHashMap<>();
+      if (toBlock.hasPhiBlock()) {
+         this.phiBlock = toBlock.getPhiBlock();
+         List<ControlFlowBlock> predecessors = new ArrayList<>(program.getGraph().getPredecessors(toBlock));
+         Collections.sort(predecessors, new Comparator<ControlFlowBlock>() {
+            @Override
+            public int compare(ControlFlowBlock o1, ControlFlowBlock o2) {
+               return o1.getLabel().getFullName().compareTo(o2.getLabel().getFullName());
+            }
+         });
+         for (ControlFlowBlock predecessor : predecessors) {
+            PhiTransition transition = findTransition(predecessor);
+            transitions.put(predecessor, transition);
+         }
+      }
+   }
+
+   /**
+    * Find the transition from a specific fromBlock.
+    * If another transition already has the same assignments it is reused. If not a new transition is created.
+    *
+    * @param fromBlock The block where the transition starts
+    * @return The transition into the passed block
+    */
+   private PhiTransition findTransition(ControlFlowBlock fromBlock) {
+      PhiTransition transition = new PhiTransition(fromBlock);
+      boolean isCallTransition = toBlock.getLabel().equals(fromBlock.getCallSuccessor());
+      if (!isCallTransition) {
+         // If the transition is not a call - then attempt to join with other equal transition(s)
+         for (PhiTransition candidate : transitions.values()) {
+            if (candidate.equalAssignments(transition)) {
+               candidate.addFromBlock(fromBlock);
+               return candidate;
+            }
+         }
+      }
+      return transition;
+   }
+
+   public Collection<ControlFlowBlock> getFromBlocks() {
+      return transitions.keySet();
+   }
+
+   /**
+    * Get the transition into the to-block from a specific from-block
+    *
+    * @param fromBlock The from-block
+    * @return The transition from the from-block into the to-block
+    */
+   public PhiTransition getTransition(ControlFlowBlock fromBlock) {
+      PhiTransition transition = transitions.get(fromBlock);
+      return transition;
+   }
+
+   /**
+    * Get a phi transition from it's phi transition ID.
+    * @param transitionId The ID to look for
+    * @return The transition with the given ID, or nulll if not found.
+    */
+   public PhiTransition getTransition(String transitionId) {
+      for (PhiTransition phiTransition : transitions.values()) {
+         if(transitionId.equals(phiTransition.getTransitionId())) {
+            return phiTransition;
+         }
+      }
+      return null;
+   }
+
+   /**
+    * A single transition into a to-block.
+    * The transition contains the assignments necessary to enter the to-block from specific from-block(s).
+    * The transition may be shared between multiple from-blocks, if the assignments are identical.
+    */
+   public class PhiTransition {
+
+      private List<ControlFlowBlock> fromBlocks;
+
+      private List<PhiTransition.PhiAssignment> assignments;
+
+      private boolean generated;
+
+      private int nextIdx;
+
+      public PhiTransition(ControlFlowBlock fromBlock) {
+         this.fromBlocks = new ArrayList<>();
+         this.fromBlocks.add(fromBlock);
+         this.generated = false;
+         this.nextIdx = 0;
+         initAssignments(fromBlock);
+      }
+
+      private void initAssignments(ControlFlowBlock fromBlock) {
+         this.assignments = new ArrayList<>();
+         if (phiBlock != null) {
+            List<StatementPhiBlock.PhiVariable> phiVariables = new ArrayList<>(phiBlock.getPhiVariables());
+            Collections.reverse(phiVariables);
+            for (StatementPhiBlock.PhiVariable phiVariable : phiVariables) {
+               List<StatementPhiBlock.PhiRValue> phiRValues = new ArrayList<>(phiVariable.getValues());
+               Collections.sort(phiRValues, new Comparator<StatementPhiBlock.PhiRValue>() {
+                  @Override
+                  public int compare(StatementPhiBlock.PhiRValue o1, StatementPhiBlock.PhiRValue o2) {
+                     return o1.getPredecessor().getFullName().compareTo(o2.getPredecessor().getFullName());
+                  }
+               });
+               for (StatementPhiBlock.PhiRValue phiRValue : phiRValues) {
+                  if (phiRValue.getPredecessor().equals(fromBlock.getLabel())) {
+                     this.assignments.add(new PhiTransition.PhiAssignment(phiVariable, phiRValue, nextIdx++));
+                  }
+               }
+            }
+         }
+      }
+
+      /**
+       * Get a string ID uniquely identifying the PHI transition within the program
+       * @return Transition ID
+       */
+      public String getTransitionId() {
+         StringBuilder id = new StringBuilder();
+         id.append("phi:");
+         boolean first = true;
+         for (ControlFlowBlock fromBlock : fromBlocks) {
+            if(!first) {
+               id.append("/");
+            }
+            id.append(fromBlock.getLabel());
+            first = false;
+         }
+         id.append("->").append(toBlock.getLabel());
+         return id.toString();
+      }
+
+      public List<PhiTransition.PhiAssignment> getAssignments() {
+         return assignments;
+      }
+
+      public boolean isGenerated() {
+         return generated;
+      }
+
+      public void setGenerated(boolean generated) {
+         this.generated = generated;
+      }
+
+      public void addFromBlock(ControlFlowBlock fromBlock) {
+         fromBlocks.add(fromBlock);
+      }
+
+      /**
+       * Determines if another transition has the exact same assignments as this block
+       *
+       * @param other The other transition to examine
+       * @return true if the assignments are identical
+       */
+      public boolean equalAssignments(PhiTransition other) {
+         List<PhiTransition.PhiAssignment> otherAssignments = other.getAssignments();
+         if (assignments.size() != otherAssignments.size()) {
+            return false;
+         }
+         for (int i = 0; i < assignments.size(); i++) {
+            PhiTransition.PhiAssignment assignment = assignments.get(i);
+            PhiTransition.PhiAssignment otherAssignment = otherAssignments.get(i);
+            ProgramScope scope = program.getScope();
+            if (assignment.getVariable() instanceof VariableRef && otherAssignment.getVariable() instanceof VariableRef) {
+               Variable var = scope.getVariable((VariableRef) assignment.getVariable());
+               Variable otherVar = scope.getVariable((VariableRef) otherAssignment.getVariable());
+               if (!var.getAllocation().equals(otherVar.getAllocation())) {
+                  return false;
+               }
+            } else if (!assignment.getVariable().equals(otherAssignment.getVariable())) {
+               return false;
+            }
+            if (assignment.getrValue() instanceof VariableRef && otherAssignment.getrValue() instanceof VariableRef) {
+               Variable var = scope.getVariable((VariableRef) assignment.getrValue());
+               Variable otherVar = scope.getVariable((VariableRef) otherAssignment.getrValue());
+               if (!var.getAllocation().equals(otherVar.getAllocation())) {
+                  return false;
+               }
+            } else if (!assignment.getrValue().equals(otherAssignment.getrValue())) {
+               return false;
+            }
+         }
+         return true;
+      }
+
+      public List<ControlFlowBlock> getFromBlocks() {
+         return fromBlocks;
+      }
+
+      /**
+       * Assignment of a single value during a phi transition
+       */
+      public class PhiAssignment {
+
+         private StatementPhiBlock.PhiVariable phiVariable;
+
+         private StatementPhiBlock.PhiRValue phiRValue;
+
+         /** The index of the assignment within the transition. */
+         private int idx;
+
+         public PhiAssignment(StatementPhiBlock.PhiVariable phiVariable, StatementPhiBlock.PhiRValue phiRValue, int idx) {
+            this.phiVariable = phiVariable;
+            this.phiRValue = phiRValue;
+            this.idx = idx;
+         }
+
+         public VariableRef getVariable() {
+            return phiVariable.getVariable();
+         }
+
+         public RValue getrValue() {
+            return phiRValue.getrValue();
+         }
+
+         public Statement getPhiBlock() {
+            return phiBlock;
+         }
+
+         public int getAssignmentIdx() {
+            return idx;
+         }
+      }
+
+   }
+
+}

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

@@ -176,7 +176,7 @@ public class VariableReferenceInfo {
     * @param rValue The rValue
     * @return All referenced variables
     */
-   private Collection<VariableRef> getReferenced(RValue rValue) {
+   public static Collection<VariableRef> getReferenced(RValue rValue) {
       if (rValue == null) {
          return new ArrayList<>();
       } else if (rValue instanceof ConstantValue) {

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

@@ -5,9 +5,7 @@ import dk.camelot64.kickc.asm.AsmSegment;
 import dk.camelot64.kickc.asm.parser.AsmClobber;
 import dk.camelot64.kickc.model.*;
 
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
+import java.util.*;
 
 /*** Ensures that no statement clobbers a CPU register used by an alive variable - and that assigning statements clobber the CPU registers they assign to */
 public class Pass4AssertNoCpuClobber extends Pass2Base {
@@ -43,28 +41,30 @@ public class Pass4AssertNoCpuClobber extends Pass2Base {
             Collection<Registers.Register> clobberRegisters = getClobberRegisters(asmSegmentClobber);
             // Find vars assigned to in the statement
             Collection<VariableRef> assignedVars = Pass4RegisterUpliftPotentialRegisterAnalysis.getAssignedVars(statement);
-            // Two assigned vars cannot use same register
-            if(assignedVars.size()>1) {
-               for (VariableRef assignedVar1 : assignedVars) {
-                  for (VariableRef assignedVar2 : assignedVars) {
-                     if (assignedVar1.equals(assignedVar2)) {
-                        // Same variable - not relevant
-                        continue;
-                     }
-                     Registers.Register register1 = getProgram().getScope().getVariable(assignedVar1).getAllocation();
-                     Registers.Register register2 = getProgram().getScope().getVariable(assignedVar2).getAllocation();
-                     if (register1.equals(register2)) {
-                        if (verbose) {
-                           getLog().append("Two assigned variables " + assignedVar1 + " and " + assignedVar2 + " clobbered by use of same register " + register1 + " in statement " + statement);
-                        }
-                        clobberProblem = true;
-                     }
+
+            // Find alive variables
+            List<VariableRef> aliveVars = new ArrayList<>(getProgram().getLiveRangeVariablesEffective().getAliveEffective(statement));
+
+            // If the segment is an assignment in a phi transition, examine the later phi transition assignments and update alive variables alive and variables assigned
+            if(asmSegment.getPhiTransitionId()!=null && asmSegment.getPhiTransitionAssignmentIdx()!=null) {
+               String phiTransitionId = asmSegment.getPhiTransitionId();
+               int transitionAssignmentIdx = asmSegment.getPhiTransitionAssignmentIdx();
+               ControlFlowBlock statementBlock = getProgram().getGraph().getBlockFromStatementIdx(statementIdx);
+               PhiTransitions phiTransitions = new PhiTransitions(getProgram(), statementBlock);
+               PhiTransitions.PhiTransition phiTransition = phiTransitions.getTransition(phiTransitionId);
+               for (PhiTransitions.PhiTransition.PhiAssignment phiAssignment : phiTransition.getAssignments()) {
+                  // IF the assignment is later than the current one
+                  if(phiAssignment.getAssignmentIdx()>transitionAssignmentIdx) {
+                     RValue rValue = phiAssignment.getrValue();
+                     Collection<VariableRef> alive = VariableReferenceInfo.getReferenced(rValue);
+                     aliveVars.addAll(alive);
+                     VariableRef assignedVar = phiAssignment.getVariable();
+                     assignedVars.remove(assignedVar);
+                     alive.remove(assignedVar);
                   }
                }
             }
 
-            // Find alive variables
-            List<VariableRef> aliveVars = new ArrayList<>(getProgram().getLiveRangeVariablesEffective().getAliveEffective(statement));
             // Non-assigned alive variables must not be clobbered
             for (VariableRef aliveVar : aliveVars) {
                Variable variable = getProgram().getScope().getVariable(aliveVar);

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

@@ -306,7 +306,6 @@ public class Pass4CodeGeneration {
       PhiTransitions transitions = getTransitions(toBlock);
       PhiTransitions.PhiTransition transition = transitions.getTransition(fromBlock);
       if (!transition.isGenerated()) {
-
          Statement toFirstStatement = toBlock.getStatements().get(0);
          String segmentSrc = "[" + toFirstStatement.getIndex() + "] phi from ";
          for (ControlFlowBlock fBlock : transition.getFromBlocks()) {
@@ -314,13 +313,26 @@ public class Pass4CodeGeneration {
          }
          segmentSrc += "to " + toBlock.getLabel().getFullName();
          asm.startSegment(toFirstStatement.getIndex(), segmentSrc);
-
+         asm.getCurrentSegment().setPhiTransitionId(transition.getTransitionId());
          for (ControlFlowBlock fBlock : transition.getFromBlocks()) {
             asm.addLabel((toBlock.getLabel().getLocalName() + "_from_" + fBlock.getLabel().getLocalName()).replace('@', 'b').replace(':', '_'));
          }
          List<PhiTransitions.PhiTransition.PhiAssignment> assignments = transition.getAssignments();
          for (PhiTransitions.PhiTransition.PhiAssignment assignment : assignments) {
-            genAsmMove(asm, assignment.getVariable(), assignment.getrValue(), assignment.getPhiBlock(), scope);
+            LValue lValue = assignment.getVariable();
+            RValue rValue = assignment.getrValue();
+            Statement statement = assignment.getPhiBlock();
+            // Generate an ASM move fragment
+            asm.startSegment(statement.getIndex(), "[" + statement.getIndex() + "] phi " + lValue.toString(program) + " = " + rValue.toString(program));
+            asm.getCurrentSegment().setPhiTransitionId(transition.getTransitionId());
+            asm.getCurrentSegment().setPhiTransitionAssignmentIdx(assignment.getAssignmentIdx());
+            if (isRegisterCopy(lValue, rValue)) {
+               asm.getCurrentSegment().setFragment("register_copy");
+            } else {
+               AsmFragment asmFragment = new AsmFragment(lValue, rValue, program, scope);
+               asm.getCurrentSegment().setFragment(asmFragment.getSignature());
+               asmFragment.generate(asm);
+            }
          }
          transition.setGenerated(true);
       } else {
@@ -345,225 +357,12 @@ public class Pass4CodeGeneration {
    private PhiTransitions getTransitions(ControlFlowBlock toBlock) {
       PhiTransitions transitions = this.blockTransitions.get(toBlock);
       if (transitions == null) {
-         transitions = new PhiTransitions(toBlock);
+         transitions = new PhiTransitions(program, toBlock);
          this.blockTransitions.put(toBlock, transitions);
       }
       return transitions;
    }
 
-   /**
-    * Keeps track of the phi transitions into a single block during code generation.
-    * Used to ensure that duplicate transitions are only code generated once.
-    */
-   public class PhiTransitions {
-
-      /**
-       * Label of the to-block.
-       */
-      private ControlFlowBlock toBlock;
-
-      /**
-       * The phi-block of the to-block.
-       */
-      private StatementPhiBlock phiBlock;
-
-      /**
-       * Maps from-block to the transition from the from-block to the to-block.
-       */
-      private Map<ControlFlowBlock, PhiTransition> transitions;
-
-      public PhiTransitions(ControlFlowBlock toBlock) {
-         this.toBlock = toBlock;
-         this.transitions = new LinkedHashMap<>();
-         if (toBlock.hasPhiBlock()) {
-            this.phiBlock = toBlock.getPhiBlock();
-            List<ControlFlowBlock> predecessors = new ArrayList<>(getGraph().getPredecessors(toBlock));
-            Collections.sort(predecessors, new Comparator<ControlFlowBlock>() {
-               @Override
-               public int compare(ControlFlowBlock o1, ControlFlowBlock o2) {
-                  return o1.getLabel().getFullName().compareTo(o2.getLabel().getFullName());
-               }
-            });
-            for (ControlFlowBlock predecessor : predecessors) {
-               PhiTransition transition = findTransition(predecessor);
-               transitions.put(predecessor, transition);
-            }
-         }
-      }
-
-      /**
-       * Find the transition from a specific fromBlock.
-       * If another transition already has the same assignments it is reused. If not a new transition is created.
-       *
-       * @param fromBlock
-       * @return
-       */
-      private PhiTransition findTransition(ControlFlowBlock fromBlock) {
-         PhiTransition transition = new PhiTransition(fromBlock);
-         boolean isCallTransition = toBlock.getLabel().equals(fromBlock.getCallSuccessor());
-         if (!isCallTransition) {
-            // If the transition is not a call - then attempt to join with other equal transition(s)
-            for (PhiTransition candidate : transitions.values()) {
-               if (candidate.equalAssignments(transition)) {
-                  candidate.addFromBlock(fromBlock);
-                  return candidate;
-               }
-            }
-         }
-         return transition;
-      }
-
-      public Collection<ControlFlowBlock> getFromBlocks() {
-         return transitions.keySet();
-      }
-
-      /**
-       * Get the transition into the to-block from a specific from-block
-       *
-       * @param fromBlock The from-block
-       * @return The transition from the from-block into the to-block
-       */
-      public PhiTransition getTransition(ControlFlowBlock fromBlock) {
-         PhiTransition transition = transitions.get(fromBlock);
-         if (transition == null) {
-            transition = findTransition(fromBlock);
-            transitions.put(fromBlock, transition);
-         }
-         return transition;
-      }
-
-
-      /**
-       * A single transition into a to-block.
-       * The transition contains the assignments necessary to enter the to-block from specific from-block(s).
-       * The transition may be shared between multiple from-blocks, if the assignments are identical.
-       */
-      public class PhiTransition {
-
-         private List<ControlFlowBlock> fromBlocks;
-
-         private List<PhiAssignment> assignments;
-
-         private boolean generated;
-
-         public PhiTransition(ControlFlowBlock fromBlock) {
-            this.fromBlocks = new ArrayList<>();
-            this.fromBlocks.add(fromBlock);
-            this.generated = false;
-            initAssignments(fromBlock);
-         }
-
-         private void initAssignments(ControlFlowBlock fromBlock) {
-            this.assignments = new ArrayList<>();
-            if (phiBlock != null) {
-               List<StatementPhiBlock.PhiVariable> phiVariables = new ArrayList<>(phiBlock.getPhiVariables());
-               Collections.reverse(phiVariables);
-               for (StatementPhiBlock.PhiVariable phiVariable : phiVariables) {
-                  List<StatementPhiBlock.PhiRValue> phiRValues = new ArrayList<>(phiVariable.getValues());
-                  Collections.sort(phiRValues, new Comparator<StatementPhiBlock.PhiRValue>() {
-                     @Override
-                     public int compare(StatementPhiBlock.PhiRValue o1, StatementPhiBlock.PhiRValue o2) {
-                        return o1.getPredecessor().getFullName().compareTo(o2.getPredecessor().getFullName());
-                     }
-                  });
-                  for (StatementPhiBlock.PhiRValue phiRValue : phiRValues) {
-                     if (phiRValue.getPredecessor().equals(fromBlock.getLabel())) {
-                        this.assignments.add(new PhiAssignment(phiVariable, phiRValue));
-                     }
-                  }
-               }
-            }
-         }
-
-         public List<PhiAssignment> getAssignments() {
-            return assignments;
-         }
-
-         public boolean isGenerated() {
-            return generated;
-         }
-
-         public void setGenerated(boolean generated) {
-            this.generated = generated;
-         }
-
-         public void addFromBlock(ControlFlowBlock fromBlock) {
-            fromBlocks.add(fromBlock);
-         }
-
-         /**
-          * Determines if another transition has the exact same assignments as this block
-          *
-          * @param other The other transition to examine
-          * @return true if the assignments are identical
-          */
-         public boolean equalAssignments(PhiTransition other) {
-            List<PhiAssignment> otherAssignments = other.getAssignments();
-            if (assignments.size() != otherAssignments.size()) {
-               return false;
-            }
-            for (int i = 0; i < assignments.size(); i++) {
-               PhiAssignment assignment = assignments.get(i);
-               PhiAssignment otherAssignment = otherAssignments.get(i);
-               ProgramScope scope = program.getScope();
-               if (assignment.getVariable() instanceof VariableRef && otherAssignment.getVariable() instanceof VariableRef) {
-                  Variable var = scope.getVariable((VariableRef) assignment.getVariable());
-                  Variable otherVar = scope.getVariable((VariableRef) otherAssignment.getVariable());
-                  if (!var.getAllocation().equals(otherVar.getAllocation())) {
-                     return false;
-                  }
-               } else if (!assignment.getVariable().equals(otherAssignment.getVariable())) {
-                  return false;
-               }
-               if (assignment.getrValue() instanceof VariableRef && otherAssignment.getrValue() instanceof VariableRef) {
-                  Variable var = scope.getVariable((VariableRef) assignment.getrValue());
-                  Variable otherVar = scope.getVariable((VariableRef) otherAssignment.getrValue());
-                  if (!var.getAllocation().equals(otherVar.getAllocation())) {
-                     return false;
-                  }
-               } else if (!assignment.getrValue().equals(otherAssignment.getrValue())) {
-                  return false;
-               }
-            }
-            return true;
-         }
-
-         public List<ControlFlowBlock> getFromBlocks() {
-            return fromBlocks;
-         }
-
-         /**
-          * Assignment of a single value during a phi transition
-          */
-         public class PhiAssignment {
-
-            private StatementPhiBlock.PhiVariable phiVariable;
-
-            private StatementPhiBlock.PhiRValue phiRValue;
-
-            public PhiAssignment(StatementPhiBlock.PhiVariable phiVariable, StatementPhiBlock.PhiRValue phiRValue) {
-               this.phiVariable = phiVariable;
-               this.phiRValue = phiRValue;
-            }
-
-            public LValue getVariable() {
-               return phiVariable.getVariable();
-            }
-
-            public RValue getrValue() {
-               return phiRValue.getrValue();
-            }
-
-            public Statement getPhiBlock() {
-               return phiBlock;
-            }
-
-         }
-
-      }
-
-   }
-
    private Registers.Register getRegister(RValue rValue) {
       if (rValue instanceof VariableRef) {
          VariableRef rValueRef = (VariableRef) rValue;
@@ -573,26 +372,6 @@ public class Pass4CodeGeneration {
       }
    }
 
-   /**
-    * Generate ASM assigning a value (rValue) to a variable (lValue).
-    *
-    * @param asm       The ASM program to generate into
-    * @param lValue    The lValue that should be assigned the value
-    * @param rValue    The rValue to assign to the lValue.
-    * @param statement The ICL statement that is the cause of the assignment.
-    * @param scope     The scope where the ASM code is being inserted. Used to ensure that labels inserted in the code reference the right variables.
-    */
-   private void genAsmMove(AsmProgram asm, LValue lValue, RValue rValue, Statement statement, ScopeRef scope) {
-      asm.startSegment(statement.getIndex(), "[" + statement.getIndex() + "] phi " + lValue.toString(program) + " = " + rValue.toString(program));
-      if (isRegisterCopy(lValue, rValue)) {
-         asm.getCurrentSegment().setFragment("register_copy");
-      } else {
-         AsmFragment asmFragment = new AsmFragment(lValue, rValue, program, scope);
-         asm.getCurrentSegment().setFragment(asmFragment.getSignature());
-         asmFragment.generate(asm);
-      }
-   }
-
    private boolean isRegisterCopy(LValue lValue, RValue rValue) {
       return
             getRegister(lValue) != null &&
@@ -600,5 +379,4 @@ public class Pass4CodeGeneration {
                   getRegister(lValue).equals(getRegister(rValue));
    }
 
-
 }

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

@@ -38,6 +38,7 @@ public class Pass4RegisterUpliftStatic extends Pass2Base {
       */
 
       // Good combination for liverange.kc
+      /*
       setRegister(combination, "inc::$0", Registers.getRegisterX());
       setRegister(combination, "main::$0", Registers.getRegisterA());
       setRegister(combination, "inc::return#0", Registers.getRegisterA());
@@ -46,7 +47,15 @@ public class Pass4RegisterUpliftStatic extends Pass2Base {
       setRegister(combination, "main::a#2", Registers.getRegisterA());
       setRegister(combination, "i#11", Registers.getRegisterX());
       setRegister(combination, "inc::$0", Registers.getRegisterX());
+      */
 
+      // Clobber combination for scroll-clobber.kc
+      setRegister(combination, "main::c#0", Registers.getRegisterA());
+      setRegister(combination, "main::c#1", Registers.getRegisterA());
+      setRegister(combination, "main::c#2", Registers.getRegisterA());
+      setRegister(combination, "main::i#1", Registers.getRegisterX());
+      setRegister(combination, "main::i#3", Registers.getRegisterX());
+      setRegister(combination, "main::nxt#1", new Registers.RegisterZpPointerByte(2));
 
       boolean success = Pass4RegisterUpliftCombinations.generateCombinationAsm(
             combination,
@@ -66,6 +75,7 @@ public class Pass4RegisterUpliftStatic extends Pass2Base {
          }
          combination.store(getProgram().getLiveRangeEquivalenceClassSet());
       } else {
+         new Pass4AssertNoCpuClobber(getProgram()).check();
          throw new RuntimeException("Static uplift problem.");
       }
 

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

@@ -1434,7 +1434,7 @@ INITIAL ASM
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
 main_from_bbegin:
   jsr main
   jmp bend
@@ -1450,29 +1450,29 @@ main: {
     .label cursor = 2
     .label e = 5
     .label y = 6
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte) main::y#2 = (byte) 4 -- zpby1=coby1 
+  //SEG7 [2] phi (byte) main::y#2 = (byte) 4 [phi:main->main::@1#0] -- zpby1=coby1 
     lda #4
     sta y
-  //SEG8 [2] phi (byte) main::e#3 = (const byte) main::yd#0/(byte) 2 -- zpby1=coby1 
+  //SEG8 [2] phi (byte) main::e#3 = (const byte) main::yd#0/(byte) 2 [phi:main->main::@1#1] -- zpby1=coby1 
     lda #yd/2
     sta e
-  //SEG9 [2] phi (byte) main::x#2 = (byte) 4 -- zpby1=coby1 
+  //SEG9 [2] phi (byte) main::x#2 = (byte) 4 [phi:main->main::@1#2] -- zpby1=coby1 
     lda #4
     sta x
-  //SEG10 [2] phi (byte*) main::cursor#3 = (const byte[1000]) SCREEN#0+(byte) 4*(byte) 40+(byte) 4 -- zpptrby1=cowo1 
+  //SEG10 [2] phi (byte*) main::cursor#3 = (const byte[1000]) SCREEN#0+(byte) 4*(byte) 40+(byte) 4 [phi:main->main::@1#3] -- zpptrby1=cowo1 
     lda #<SCREEN+4*$28+4
     sta cursor
     lda #>SCREEN+4*$28+4
     sta cursor+1
     jmp b1
-  //SEG11 [2] phi from main::@2 to main::@1
+  //SEG11 [2] phi from main::@2 to main::@1 [phi:main::@2->main::@1]
   b1_from_b2:
-  //SEG12 [2] phi (byte) main::y#2 = (byte) main::y#4 -- register_copy 
-  //SEG13 [2] phi (byte) main::e#3 = (byte) main::e#5 -- register_copy 
-  //SEG14 [2] phi (byte) main::x#2 = (byte) main::x#1 -- register_copy 
-  //SEG15 [2] phi (byte*) main::cursor#3 = (byte*) main::cursor#5 -- register_copy 
+  //SEG12 [2] phi (byte) main::y#2 = (byte) main::y#4 [phi:main::@2->main::@1#0] -- register_copy 
+  //SEG13 [2] phi (byte) main::e#3 = (byte) main::e#5 [phi:main::@2->main::@1#1] -- register_copy 
+  //SEG14 [2] phi (byte) main::x#2 = (byte) main::x#1 [phi:main::@2->main::@1#2] -- register_copy 
+  //SEG15 [2] phi (byte*) main::cursor#3 = (byte*) main::cursor#5 [phi:main::@2->main::@1#3] -- register_copy 
     jmp b1
   //SEG16 main::@1
   b1:
@@ -1513,12 +1513,12 @@ main: {
     sec
     sbc #xd
     sta e
-  //SEG26 [11] phi from main::@1 main::@3 to main::@2
+  //SEG26 [11] phi from main::@1 main::@3 to main::@2 [phi:main::@1/main::@3->main::@2]
   b2_from_b1:
   b2_from_b3:
-  //SEG27 [11] phi (byte) main::y#4 = (byte) main::y#2 -- register_copy 
-  //SEG28 [11] phi (byte) main::e#5 = (byte) main::e#1 -- register_copy 
-  //SEG29 [11] phi (byte*) main::cursor#5 = (byte*) main::cursor#1 -- register_copy 
+  //SEG27 [11] phi (byte) main::y#4 = (byte) main::y#2 [phi:main::@1/main::@3->main::@2#0] -- register_copy 
+  //SEG28 [11] phi (byte) main::e#5 = (byte) main::e#1 [phi:main::@1/main::@3->main::@2#1] -- register_copy 
+  //SEG29 [11] phi (byte*) main::cursor#5 = (byte*) main::cursor#1 [phi:main::@1/main::@3->main::@2#2] -- register_copy 
     jmp b2
   //SEG30 main::@2
   b2:
@@ -1578,7 +1578,7 @@ ASSEMBLER
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
 main_from_bbegin:
   jsr main
 //SEG4 @end
@@ -1592,28 +1592,28 @@ main: {
     .label cursor = 2
     .label e = 4
     .label y = 5
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte) main::y#2 = (byte) 4 -- zpby1=coby1 
+  //SEG7 [2] phi (byte) main::y#2 = (byte) 4 [phi:main->main::@1#0] -- zpby1=coby1 
     lda #4
     sta y
-  //SEG8 [2] phi (byte) main::e#3 = (const byte) main::yd#0/(byte) 2 -- zpby1=coby1 
+  //SEG8 [2] phi (byte) main::e#3 = (const byte) main::yd#0/(byte) 2 [phi:main->main::@1#1] -- zpby1=coby1 
     lda #yd/2
     sta e
-  //SEG9 [2] phi (byte) main::x#2 = (byte) 4 -- xby=coby1 
+  //SEG9 [2] phi (byte) main::x#2 = (byte) 4 [phi:main->main::@1#2] -- xby=coby1 
     ldx #4
-  //SEG10 [2] phi (byte*) main::cursor#3 = (const byte[1000]) SCREEN#0+(byte) 4*(byte) 40+(byte) 4 -- zpptrby1=cowo1 
+  //SEG10 [2] phi (byte*) main::cursor#3 = (const byte[1000]) SCREEN#0+(byte) 4*(byte) 40+(byte) 4 [phi:main->main::@1#3] -- zpptrby1=cowo1 
     lda #<SCREEN+4*$28+4
     sta cursor
     lda #>SCREEN+4*$28+4
     sta cursor+1
     jmp b1
-  //SEG11 [2] phi from main::@2 to main::@1
+  //SEG11 [2] phi from main::@2 to main::@1 [phi:main::@2->main::@1]
   b1_from_b2:
-  //SEG12 [2] phi (byte) main::y#2 = (byte) main::y#4 -- register_copy 
-  //SEG13 [2] phi (byte) main::e#3 = (byte) main::e#5 -- register_copy 
-  //SEG14 [2] phi (byte) main::x#2 = (byte) main::x#1 -- register_copy 
-  //SEG15 [2] phi (byte*) main::cursor#3 = (byte*) main::cursor#5 -- register_copy 
+  //SEG12 [2] phi (byte) main::y#2 = (byte) main::y#4 [phi:main::@2->main::@1#0] -- register_copy 
+  //SEG13 [2] phi (byte) main::e#3 = (byte) main::e#5 [phi:main::@2->main::@1#1] -- register_copy 
+  //SEG14 [2] phi (byte) main::x#2 = (byte) main::x#1 [phi:main::@2->main::@1#2] -- register_copy 
+  //SEG15 [2] phi (byte*) main::cursor#3 = (byte*) main::cursor#5 [phi:main::@2->main::@1#3] -- register_copy 
   //SEG16 main::@1
   b1:
   //SEG17 [3] *((byte*) main::cursor#3) ← (const byte) STAR#0 [ main::cursor#3 main::x#2 main::e#3 main::y#2 ] -- _star_zpptrby1=coby1 
@@ -1652,12 +1652,12 @@ main: {
     sec
     sbc #xd
     sta e
-  //SEG26 [11] phi from main::@1 main::@3 to main::@2
+  //SEG26 [11] phi from main::@1 main::@3 to main::@2 [phi:main::@1/main::@3->main::@2]
   b2_from_b1:
   b2_from_b3:
-  //SEG27 [11] phi (byte) main::y#4 = (byte) main::y#2 -- register_copy 
-  //SEG28 [11] phi (byte) main::e#5 = (byte) main::e#1 -- register_copy 
-  //SEG29 [11] phi (byte*) main::cursor#5 = (byte*) main::cursor#1 -- register_copy 
+  //SEG27 [11] phi (byte) main::y#4 = (byte) main::y#2 [phi:main::@1/main::@3->main::@2#0] -- register_copy 
+  //SEG28 [11] phi (byte) main::e#5 = (byte) main::e#1 [phi:main::@1/main::@3->main::@2#1] -- register_copy 
+  //SEG29 [11] phi (byte*) main::cursor#5 = (byte*) main::cursor#1 [phi:main::@1/main::@3->main::@2#2] -- register_copy 
   //SEG30 main::@2
   b2:
   //SEG31 [12] if((byte) main::x#1<(const byte) main::x1#0+(byte) 1) goto main::@1 [ main::cursor#5 main::x#1 main::e#5 main::y#4 ] -- xby_lt_coby1_then_la1 
@@ -1683,7 +1683,7 @@ ASSEMBLER
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 bend:
@@ -1696,27 +1696,27 @@ main: {
     .label cursor = 2
     .label e = 4
     .label y = 5
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte) main::y#2 = (byte) 4 -- zpby1=coby1 
+  //SEG7 [2] phi (byte) main::y#2 = (byte) 4 [phi:main->main::@1#0] -- zpby1=coby1 
     lda #4
     sta y
-  //SEG8 [2] phi (byte) main::e#3 = (const byte) main::yd#0/(byte) 2 -- zpby1=coby1 
+  //SEG8 [2] phi (byte) main::e#3 = (const byte) main::yd#0/(byte) 2 [phi:main->main::@1#1] -- zpby1=coby1 
     lda #yd/2
     sta e
-  //SEG9 [2] phi (byte) main::x#2 = (byte) 4 -- xby=coby1 
+  //SEG9 [2] phi (byte) main::x#2 = (byte) 4 [phi:main->main::@1#2] -- xby=coby1 
     ldx #4
-  //SEG10 [2] phi (byte*) main::cursor#3 = (const byte[1000]) SCREEN#0+(byte) 4*(byte) 40+(byte) 4 -- zpptrby1=cowo1 
+  //SEG10 [2] phi (byte*) main::cursor#3 = (const byte[1000]) SCREEN#0+(byte) 4*(byte) 40+(byte) 4 [phi:main->main::@1#3] -- zpptrby1=cowo1 
     lda #<SCREEN+4*$28+4
     sta cursor
     lda #>SCREEN+4*$28+4
     sta cursor+1
     jmp b1
-  //SEG11 [2] phi from main::@2 to main::@1
-  //SEG12 [2] phi (byte) main::y#2 = (byte) main::y#4 -- register_copy 
-  //SEG13 [2] phi (byte) main::e#3 = (byte) main::e#5 -- register_copy 
-  //SEG14 [2] phi (byte) main::x#2 = (byte) main::x#1 -- register_copy 
-  //SEG15 [2] phi (byte*) main::cursor#3 = (byte*) main::cursor#5 -- register_copy 
+  //SEG11 [2] phi from main::@2 to main::@1 [phi:main::@2->main::@1]
+  //SEG12 [2] phi (byte) main::y#2 = (byte) main::y#4 [phi:main::@2->main::@1#0] -- register_copy 
+  //SEG13 [2] phi (byte) main::e#3 = (byte) main::e#5 [phi:main::@2->main::@1#1] -- register_copy 
+  //SEG14 [2] phi (byte) main::x#2 = (byte) main::x#1 [phi:main::@2->main::@1#2] -- register_copy 
+  //SEG15 [2] phi (byte*) main::cursor#3 = (byte*) main::cursor#5 [phi:main::@2->main::@1#3] -- register_copy 
   //SEG16 main::@1
   b1:
   //SEG17 [3] *((byte*) main::cursor#3) ← (const byte) STAR#0 [ main::cursor#3 main::x#2 main::e#3 main::y#2 ] -- _star_zpptrby1=coby1 
@@ -1755,10 +1755,10 @@ main: {
     sec
     sbc #xd
     sta e
-  //SEG26 [11] phi from main::@1 main::@3 to main::@2
-  //SEG27 [11] phi (byte) main::y#4 = (byte) main::y#2 -- register_copy 
-  //SEG28 [11] phi (byte) main::e#5 = (byte) main::e#1 -- register_copy 
-  //SEG29 [11] phi (byte*) main::cursor#5 = (byte*) main::cursor#1 -- register_copy 
+  //SEG26 [11] phi from main::@1 main::@3 to main::@2 [phi:main::@1/main::@3->main::@2]
+  //SEG27 [11] phi (byte) main::y#4 = (byte) main::y#2 [phi:main::@1/main::@3->main::@2#0] -- register_copy 
+  //SEG28 [11] phi (byte) main::e#5 = (byte) main::e#1 [phi:main::@1/main::@3->main::@2#1] -- register_copy 
+  //SEG29 [11] phi (byte*) main::cursor#5 = (byte*) main::cursor#1 [phi:main::@1/main::@3->main::@2#2] -- register_copy 
   //SEG30 main::@2
   b2:
   //SEG31 [12] if((byte) main::x#1<(const byte) main::x1#0+(byte) 1) goto main::@1 [ main::cursor#5 main::x#1 main::e#5 main::y#4 ] -- xby_lt_coby1_then_la1 
@@ -1782,7 +1782,7 @@ ASSEMBLER
   .const SCREEN = $400
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
@@ -1794,26 +1794,26 @@ main: {
     .label cursor = 2
     .label e = 4
     .label y = 5
-  //SEG6 [2] phi from main to main::@1
-  //SEG7 [2] phi (byte) main::y#2 = (byte) 4 -- zpby1=coby1 
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG7 [2] phi (byte) main::y#2 = (byte) 4 [phi:main->main::@1#0] -- zpby1=coby1 
     lda #4
     sta y
-  //SEG8 [2] phi (byte) main::e#3 = (const byte) main::yd#0/(byte) 2 -- zpby1=coby1 
+  //SEG8 [2] phi (byte) main::e#3 = (const byte) main::yd#0/(byte) 2 [phi:main->main::@1#1] -- zpby1=coby1 
     lda #yd/2
     sta e
-  //SEG9 [2] phi (byte) main::x#2 = (byte) 4 -- xby=coby1 
+  //SEG9 [2] phi (byte) main::x#2 = (byte) 4 [phi:main->main::@1#2] -- xby=coby1 
     ldx #4
-  //SEG10 [2] phi (byte*) main::cursor#3 = (const byte[1000]) SCREEN#0+(byte) 4*(byte) 40+(byte) 4 -- zpptrby1=cowo1 
+  //SEG10 [2] phi (byte*) main::cursor#3 = (const byte[1000]) SCREEN#0+(byte) 4*(byte) 40+(byte) 4 [phi:main->main::@1#3] -- zpptrby1=cowo1 
     lda #<SCREEN+4*$28+4
     sta cursor
     lda #>SCREEN+4*$28+4
     sta cursor+1
     jmp b1
-  //SEG11 [2] phi from main::@2 to main::@1
-  //SEG12 [2] phi (byte) main::y#2 = (byte) main::y#4 -- register_copy 
-  //SEG13 [2] phi (byte) main::e#3 = (byte) main::e#5 -- register_copy 
-  //SEG14 [2] phi (byte) main::x#2 = (byte) main::x#1 -- register_copy 
-  //SEG15 [2] phi (byte*) main::cursor#3 = (byte*) main::cursor#5 -- register_copy 
+  //SEG11 [2] phi from main::@2 to main::@1 [phi:main::@2->main::@1]
+  //SEG12 [2] phi (byte) main::y#2 = (byte) main::y#4 [phi:main::@2->main::@1#0] -- register_copy 
+  //SEG13 [2] phi (byte) main::e#3 = (byte) main::e#5 [phi:main::@2->main::@1#1] -- register_copy 
+  //SEG14 [2] phi (byte) main::x#2 = (byte) main::x#1 [phi:main::@2->main::@1#2] -- register_copy 
+  //SEG15 [2] phi (byte*) main::cursor#3 = (byte*) main::cursor#5 [phi:main::@2->main::@1#3] -- register_copy 
   //SEG16 main::@1
   b1:
   //SEG17 [3] *((byte*) main::cursor#3) ← (const byte) STAR#0 [ main::cursor#3 main::x#2 main::e#3 main::y#2 ] -- _star_zpptrby1=coby1 
@@ -1851,10 +1851,10 @@ main: {
     sec
     sbc #xd
     sta e
-  //SEG26 [11] phi from main::@1 main::@3 to main::@2
-  //SEG27 [11] phi (byte) main::y#4 = (byte) main::y#2 -- register_copy 
-  //SEG28 [11] phi (byte) main::e#5 = (byte) main::e#1 -- register_copy 
-  //SEG29 [11] phi (byte*) main::cursor#5 = (byte*) main::cursor#1 -- register_copy 
+  //SEG26 [11] phi from main::@1 main::@3 to main::@2 [phi:main::@1/main::@3->main::@2]
+  //SEG27 [11] phi (byte) main::y#4 = (byte) main::y#2 [phi:main::@1/main::@3->main::@2#0] -- register_copy 
+  //SEG28 [11] phi (byte) main::e#5 = (byte) main::e#1 [phi:main::@1/main::@3->main::@2#1] -- register_copy 
+  //SEG29 [11] phi (byte*) main::cursor#5 = (byte*) main::cursor#1 [phi:main::@1/main::@3->main::@2#2] -- register_copy 
   //SEG30 main::@2
   b2:
   //SEG31 [12] if((byte) main::x#1<(const byte) main::x1#0+(byte) 1) goto main::@1 [ main::cursor#5 main::x#1 main::e#5 main::y#4 ] -- xby_lt_coby1_then_la1 
@@ -1873,7 +1873,7 @@ ASSEMBLER
   .const SCREEN = $400
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
@@ -1885,25 +1885,25 @@ main: {
     .label cursor = 2
     .label e = 4
     .label y = 5
-  //SEG6 [2] phi from main to main::@1
-  //SEG7 [2] phi (byte) main::y#2 = (byte) 4 -- zpby1=coby1 
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG7 [2] phi (byte) main::y#2 = (byte) 4 [phi:main->main::@1#0] -- zpby1=coby1 
     lda #4
     sta y
-  //SEG8 [2] phi (byte) main::e#3 = (const byte) main::yd#0/(byte) 2 -- zpby1=coby1 
+  //SEG8 [2] phi (byte) main::e#3 = (const byte) main::yd#0/(byte) 2 [phi:main->main::@1#1] -- zpby1=coby1 
     lda #yd/2
     sta e
-  //SEG9 [2] phi (byte) main::x#2 = (byte) 4 -- xby=coby1 
+  //SEG9 [2] phi (byte) main::x#2 = (byte) 4 [phi:main->main::@1#2] -- xby=coby1 
     ldx #4
-  //SEG10 [2] phi (byte*) main::cursor#3 = (const byte[1000]) SCREEN#0+(byte) 4*(byte) 40+(byte) 4 -- zpptrby1=cowo1 
+  //SEG10 [2] phi (byte*) main::cursor#3 = (const byte[1000]) SCREEN#0+(byte) 4*(byte) 40+(byte) 4 [phi:main->main::@1#3] -- zpptrby1=cowo1 
     lda #<SCREEN+4*$28+4
     sta cursor
     lda #>SCREEN+4*$28+4
     sta cursor+1
-  //SEG11 [2] phi from main::@2 to main::@1
-  //SEG12 [2] phi (byte) main::y#2 = (byte) main::y#4 -- register_copy 
-  //SEG13 [2] phi (byte) main::e#3 = (byte) main::e#5 -- register_copy 
-  //SEG14 [2] phi (byte) main::x#2 = (byte) main::x#1 -- register_copy 
-  //SEG15 [2] phi (byte*) main::cursor#3 = (byte*) main::cursor#5 -- register_copy 
+  //SEG11 [2] phi from main::@2 to main::@1 [phi:main::@2->main::@1]
+  //SEG12 [2] phi (byte) main::y#2 = (byte) main::y#4 [phi:main::@2->main::@1#0] -- register_copy 
+  //SEG13 [2] phi (byte) main::e#3 = (byte) main::e#5 [phi:main::@2->main::@1#1] -- register_copy 
+  //SEG14 [2] phi (byte) main::x#2 = (byte) main::x#1 [phi:main::@2->main::@1#2] -- register_copy 
+  //SEG15 [2] phi (byte*) main::cursor#3 = (byte*) main::cursor#5 [phi:main::@2->main::@1#3] -- register_copy 
   //SEG16 main::@1
   b1:
   //SEG17 [3] *((byte*) main::cursor#3) ← (const byte) STAR#0 [ main::cursor#3 main::x#2 main::e#3 main::y#2 ] -- _star_zpptrby1=coby1 
@@ -1941,10 +1941,10 @@ main: {
     sec
     sbc #xd
     sta e
-  //SEG26 [11] phi from main::@1 main::@3 to main::@2
-  //SEG27 [11] phi (byte) main::y#4 = (byte) main::y#2 -- register_copy 
-  //SEG28 [11] phi (byte) main::e#5 = (byte) main::e#1 -- register_copy 
-  //SEG29 [11] phi (byte*) main::cursor#5 = (byte*) main::cursor#1 -- register_copy 
+  //SEG26 [11] phi from main::@1 main::@3 to main::@2 [phi:main::@1/main::@3->main::@2]
+  //SEG27 [11] phi (byte) main::y#4 = (byte) main::y#2 [phi:main::@1/main::@3->main::@2#0] -- register_copy 
+  //SEG28 [11] phi (byte) main::e#5 = (byte) main::e#1 [phi:main::@1/main::@3->main::@2#1] -- register_copy 
+  //SEG29 [11] phi (byte*) main::cursor#5 = (byte*) main::cursor#1 [phi:main::@1/main::@3->main::@2#2] -- register_copy 
   //SEG30 main::@2
   b2:
   //SEG31 [12] if((byte) main::x#1<(const byte) main::x1#0+(byte) 1) goto main::@1 [ main::cursor#5 main::x#1 main::e#5 main::y#4 ] -- xby_lt_coby1_then_la1 
@@ -2006,7 +2006,7 @@ FINAL CODE
   .const SCREEN = $400
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
@@ -2018,25 +2018,25 @@ main: {
     .label cursor = 2
     .label e = 4
     .label y = 5
-  //SEG6 [2] phi from main to main::@1
-  //SEG7 [2] phi (byte) main::y#2 = (byte) 4 -- zpby1=coby1 
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG7 [2] phi (byte) main::y#2 = (byte) 4 [phi:main->main::@1#0] -- zpby1=coby1 
     lda #4
     sta y
-  //SEG8 [2] phi (byte) main::e#3 = (const byte) main::yd#0/(byte) 2 -- zpby1=coby1 
+  //SEG8 [2] phi (byte) main::e#3 = (const byte) main::yd#0/(byte) 2 [phi:main->main::@1#1] -- zpby1=coby1 
     lda #yd/2
     sta e
-  //SEG9 [2] phi (byte) main::x#2 = (byte) 4 -- xby=coby1 
+  //SEG9 [2] phi (byte) main::x#2 = (byte) 4 [phi:main->main::@1#2] -- xby=coby1 
     ldx #4
-  //SEG10 [2] phi (byte*) main::cursor#3 = (const byte[1000]) SCREEN#0+(byte) 4*(byte) 40+(byte) 4 -- zpptrby1=cowo1 
+  //SEG10 [2] phi (byte*) main::cursor#3 = (const byte[1000]) SCREEN#0+(byte) 4*(byte) 40+(byte) 4 [phi:main->main::@1#3] -- zpptrby1=cowo1 
     lda #<SCREEN+4*$28+4
     sta cursor
     lda #>SCREEN+4*$28+4
     sta cursor+1
-  //SEG11 [2] phi from main::@2 to main::@1
-  //SEG12 [2] phi (byte) main::y#2 = (byte) main::y#4 -- register_copy 
-  //SEG13 [2] phi (byte) main::e#3 = (byte) main::e#5 -- register_copy 
-  //SEG14 [2] phi (byte) main::x#2 = (byte) main::x#1 -- register_copy 
-  //SEG15 [2] phi (byte*) main::cursor#3 = (byte*) main::cursor#5 -- register_copy 
+  //SEG11 [2] phi from main::@2 to main::@1 [phi:main::@2->main::@1]
+  //SEG12 [2] phi (byte) main::y#2 = (byte) main::y#4 [phi:main::@2->main::@1#0] -- register_copy 
+  //SEG13 [2] phi (byte) main::e#3 = (byte) main::e#5 [phi:main::@2->main::@1#1] -- register_copy 
+  //SEG14 [2] phi (byte) main::x#2 = (byte) main::x#1 [phi:main::@2->main::@1#2] -- register_copy 
+  //SEG15 [2] phi (byte*) main::cursor#3 = (byte*) main::cursor#5 [phi:main::@2->main::@1#3] -- register_copy 
   //SEG16 main::@1
   b1:
   //SEG17 [3] *((byte*) main::cursor#3) ← (const byte) STAR#0 [ main::cursor#3 main::x#2 main::e#3 main::y#2 ] -- _star_zpptrby1=coby1 
@@ -2074,10 +2074,10 @@ main: {
     sec
     sbc #xd
     sta e
-  //SEG26 [11] phi from main::@1 main::@3 to main::@2
-  //SEG27 [11] phi (byte) main::y#4 = (byte) main::y#2 -- register_copy 
-  //SEG28 [11] phi (byte) main::e#5 = (byte) main::e#1 -- register_copy 
-  //SEG29 [11] phi (byte*) main::cursor#5 = (byte*) main::cursor#1 -- register_copy 
+  //SEG26 [11] phi from main::@1 main::@3 to main::@2 [phi:main::@1/main::@3->main::@2]
+  //SEG27 [11] phi (byte) main::y#4 = (byte) main::y#2 [phi:main::@1/main::@3->main::@2#0] -- register_copy 
+  //SEG28 [11] phi (byte) main::e#5 = (byte) main::e#1 [phi:main::@1/main::@3->main::@2#1] -- register_copy 
+  //SEG29 [11] phi (byte*) main::cursor#5 = (byte*) main::cursor#1 [phi:main::@1/main::@3->main::@2#2] -- register_copy 
   //SEG30 main::@2
   b2:
   //SEG31 [12] if((byte) main::x#1<(const byte) main::x1#0+(byte) 1) goto main::@1 [ main::cursor#5 main::x#1 main::e#5 main::y#4 ] -- xby_lt_coby1_then_la1 

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

@@ -1183,29 +1183,29 @@ INITIAL ASM
   .label y = 6
 //SEG1 @begin
 bbegin:
-//SEG2 [0] phi from @begin to @1
+//SEG2 [0] phi from @begin to @1 [phi:@begin->@1]
 b1_from_bbegin:
-//SEG3 [0] phi (byte) y#2 = (byte) 0 -- zpby1=coby1 
+//SEG3 [0] phi (byte) y#2 = (byte) 0 [phi:@begin->@1#0] -- zpby1=coby1 
   lda #0
   sta y
-//SEG4 [0] phi (byte) e#3 = (const byte) yd#0/(byte) 2 -- zpby1=coby1 
+//SEG4 [0] phi (byte) e#3 = (const byte) yd#0/(byte) 2 [phi:@begin->@1#1] -- zpby1=coby1 
   lda #yd/2
   sta e
-//SEG5 [0] phi (byte) x#2 = (byte) 0 -- zpby1=coby1 
+//SEG5 [0] phi (byte) x#2 = (byte) 0 [phi:@begin->@1#2] -- zpby1=coby1 
   lda #0
   sta x
-//SEG6 [0] phi (word) idx#3 = (byte) 0+(byte) 0*(byte) 40 -- zpwo1=coby1 
+//SEG6 [0] phi (word) idx#3 = (byte) 0+(byte) 0*(byte) 40 [phi:@begin->@1#3] -- zpwo1=coby1 
   lda #0+0*$28
   sta idx
   lda #0
   sta idx+1
   jmp b1
-//SEG7 [0] phi from @2 to @1
+//SEG7 [0] phi from @2 to @1 [phi:@2->@1]
 b1_from_b2:
-//SEG8 [0] phi (byte) y#2 = (byte) y#4 -- register_copy 
-//SEG9 [0] phi (byte) e#3 = (byte) e#5 -- register_copy 
-//SEG10 [0] phi (byte) x#2 = (byte) x#1 -- register_copy 
-//SEG11 [0] phi (word) idx#3 = (word) idx#5 -- register_copy 
+//SEG8 [0] phi (byte) y#2 = (byte) y#4 [phi:@2->@1#0] -- register_copy 
+//SEG9 [0] phi (byte) e#3 = (byte) e#5 [phi:@2->@1#1] -- register_copy 
+//SEG10 [0] phi (byte) x#2 = (byte) x#1 [phi:@2->@1#2] -- register_copy 
+//SEG11 [0] phi (word) idx#3 = (word) idx#5 [phi:@2->@1#3] -- register_copy 
   jmp b1
 //SEG12 @1
 b1:
@@ -1253,12 +1253,12 @@ b3:
   sec
   sbc #xd
   sta e
-//SEG22 [9] phi from @1 @3 to @2
+//SEG22 [9] phi from @1 @3 to @2 [phi:@1/@3->@2]
 b2_from_b1:
 b2_from_b3:
-//SEG23 [9] phi (byte) y#4 = (byte) y#2 -- register_copy 
-//SEG24 [9] phi (byte) e#5 = (byte) e#1 -- register_copy 
-//SEG25 [9] phi (word) idx#5 = (word) idx#1 -- register_copy 
+//SEG23 [9] phi (byte) y#4 = (byte) y#2 [phi:@1/@3->@2#0] -- register_copy 
+//SEG24 [9] phi (byte) e#5 = (byte) e#1 [phi:@1/@3->@2#1] -- register_copy 
+//SEG25 [9] phi (word) idx#5 = (word) idx#1 [phi:@1/@3->@2#2] -- register_copy 
   jmp b2
 //SEG26 @2
 b2:
@@ -1311,27 +1311,27 @@ ASSEMBLER
   .label y = 4
 //SEG1 @begin
 bbegin:
-//SEG2 [0] phi from @begin to @1
+//SEG2 [0] phi from @begin to @1 [phi:@begin->@1]
 b1_from_bbegin:
-//SEG3 [0] phi (byte) y#2 = (byte) 0 -- zpby1=coby1 
+//SEG3 [0] phi (byte) y#2 = (byte) 0 [phi:@begin->@1#0] -- zpby1=coby1 
   lda #0
   sta y
-//SEG4 [0] phi (byte) e#3 = (const byte) yd#0/(byte) 2 -- yby=coby1 
+//SEG4 [0] phi (byte) e#3 = (const byte) yd#0/(byte) 2 [phi:@begin->@1#1] -- yby=coby1 
   ldy #yd/2
-//SEG5 [0] phi (byte) x#2 = (byte) 0 -- xby=coby1 
+//SEG5 [0] phi (byte) x#2 = (byte) 0 [phi:@begin->@1#2] -- xby=coby1 
   ldx #0
-//SEG6 [0] phi (word) idx#3 = (byte) 0+(byte) 0*(byte) 40 -- zpwo1=coby1 
+//SEG6 [0] phi (word) idx#3 = (byte) 0+(byte) 0*(byte) 40 [phi:@begin->@1#3] -- zpwo1=coby1 
   lda #0+0*$28
   sta idx
   lda #0
   sta idx+1
   jmp b1
-//SEG7 [0] phi from @2 to @1
+//SEG7 [0] phi from @2 to @1 [phi:@2->@1]
 b1_from_b2:
-//SEG8 [0] phi (byte) y#2 = (byte) y#4 -- register_copy 
-//SEG9 [0] phi (byte) e#3 = (byte) e#5 -- register_copy 
-//SEG10 [0] phi (byte) x#2 = (byte) x#1 -- register_copy 
-//SEG11 [0] phi (word) idx#3 = (word) idx#5 -- register_copy 
+//SEG8 [0] phi (byte) y#2 = (byte) y#4 [phi:@2->@1#0] -- register_copy 
+//SEG9 [0] phi (byte) e#3 = (byte) e#5 [phi:@2->@1#1] -- register_copy 
+//SEG10 [0] phi (byte) x#2 = (byte) x#1 [phi:@2->@1#2] -- register_copy 
+//SEG11 [0] phi (word) idx#3 = (word) idx#5 [phi:@2->@1#3] -- register_copy 
 //SEG12 @1
 b1:
 //SEG13 [1] *((const byte[1000]) screen#0 + (word) idx#3) ← (const byte) STAR#0 [ idx#3 x#2 e#3 y#2 ] -- cowo1_staridx_zpwo1=coby2 
@@ -1377,12 +1377,12 @@ b3:
   sec
   sbc #xd
   tay
-//SEG22 [9] phi from @1 @3 to @2
+//SEG22 [9] phi from @1 @3 to @2 [phi:@1/@3->@2]
 b2_from_b1:
 b2_from_b3:
-//SEG23 [9] phi (byte) y#4 = (byte) y#2 -- register_copy 
-//SEG24 [9] phi (byte) e#5 = (byte) e#1 -- register_copy 
-//SEG25 [9] phi (word) idx#5 = (word) idx#1 -- register_copy 
+//SEG23 [9] phi (byte) y#4 = (byte) y#2 [phi:@1/@3->@2#0] -- register_copy 
+//SEG24 [9] phi (byte) e#5 = (byte) e#1 [phi:@1/@3->@2#1] -- register_copy 
+//SEG25 [9] phi (word) idx#5 = (word) idx#1 [phi:@1/@3->@2#2] -- register_copy 
 //SEG26 @2
 b2:
 //SEG27 [10] if((byte) x#1<(const byte) x1#0+(byte) 1) goto @1 [ idx#5 x#1 e#5 y#4 ] -- xby_lt_coby1_then_la1 
@@ -1410,25 +1410,25 @@ ASSEMBLER
   .label y = 4
 //SEG1 @begin
 bbegin:
-//SEG2 [0] phi from @begin to @1
-//SEG3 [0] phi (byte) y#2 = (byte) 0 -- zpby1=coby1 
+//SEG2 [0] phi from @begin to @1 [phi:@begin->@1]
+//SEG3 [0] phi (byte) y#2 = (byte) 0 [phi:@begin->@1#0] -- zpby1=coby1 
   lda #0
   sta y
-//SEG4 [0] phi (byte) e#3 = (const byte) yd#0/(byte) 2 -- yby=coby1 
+//SEG4 [0] phi (byte) e#3 = (const byte) yd#0/(byte) 2 [phi:@begin->@1#1] -- yby=coby1 
   ldy #yd/2
-//SEG5 [0] phi (byte) x#2 = (byte) 0 -- xby=coby1 
+//SEG5 [0] phi (byte) x#2 = (byte) 0 [phi:@begin->@1#2] -- xby=coby1 
   ldx #0
-//SEG6 [0] phi (word) idx#3 = (byte) 0+(byte) 0*(byte) 40 -- zpwo1=coby1 
+//SEG6 [0] phi (word) idx#3 = (byte) 0+(byte) 0*(byte) 40 [phi:@begin->@1#3] -- zpwo1=coby1 
   lda #0+0*$28
   sta idx
   lda #0
   sta idx+1
   jmp b1
-//SEG7 [0] phi from @2 to @1
-//SEG8 [0] phi (byte) y#2 = (byte) y#4 -- register_copy 
-//SEG9 [0] phi (byte) e#3 = (byte) e#5 -- register_copy 
-//SEG10 [0] phi (byte) x#2 = (byte) x#1 -- register_copy 
-//SEG11 [0] phi (word) idx#3 = (word) idx#5 -- register_copy 
+//SEG7 [0] phi from @2 to @1 [phi:@2->@1]
+//SEG8 [0] phi (byte) y#2 = (byte) y#4 [phi:@2->@1#0] -- register_copy 
+//SEG9 [0] phi (byte) e#3 = (byte) e#5 [phi:@2->@1#1] -- register_copy 
+//SEG10 [0] phi (byte) x#2 = (byte) x#1 [phi:@2->@1#2] -- register_copy 
+//SEG11 [0] phi (word) idx#3 = (word) idx#5 [phi:@2->@1#3] -- register_copy 
 //SEG12 @1
 b1:
 //SEG13 [1] *((const byte[1000]) screen#0 + (word) idx#3) ← (const byte) STAR#0 [ idx#3 x#2 e#3 y#2 ] -- cowo1_staridx_zpwo1=coby2 
@@ -1474,10 +1474,10 @@ b3:
   sec
   sbc #xd
   tay
-//SEG22 [9] phi from @1 @3 to @2
-//SEG23 [9] phi (byte) y#4 = (byte) y#2 -- register_copy 
-//SEG24 [9] phi (byte) e#5 = (byte) e#1 -- register_copy 
-//SEG25 [9] phi (word) idx#5 = (word) idx#1 -- register_copy 
+//SEG22 [9] phi from @1 @3 to @2 [phi:@1/@3->@2]
+//SEG23 [9] phi (byte) y#4 = (byte) y#2 [phi:@1/@3->@2#0] -- register_copy 
+//SEG24 [9] phi (byte) e#5 = (byte) e#1 [phi:@1/@3->@2#1] -- register_copy 
+//SEG25 [9] phi (word) idx#5 = (word) idx#1 [phi:@1/@3->@2#2] -- register_copy 
 //SEG26 @2
 b2:
 //SEG27 [10] if((byte) x#1<(const byte) x1#0+(byte) 1) goto @1 [ idx#5 x#1 e#5 y#4 ] -- xby_lt_coby1_then_la1 
@@ -1501,25 +1501,25 @@ ASSEMBLER
   .label idx = 2
   .label y = 4
 //SEG1 @begin
-//SEG2 [0] phi from @begin to @1
-//SEG3 [0] phi (byte) y#2 = (byte) 0 -- zpby1=coby1 
+//SEG2 [0] phi from @begin to @1 [phi:@begin->@1]
+//SEG3 [0] phi (byte) y#2 = (byte) 0 [phi:@begin->@1#0] -- zpby1=coby1 
   lda #0
   sta y
-//SEG4 [0] phi (byte) e#3 = (const byte) yd#0/(byte) 2 -- yby=coby1 
+//SEG4 [0] phi (byte) e#3 = (const byte) yd#0/(byte) 2 [phi:@begin->@1#1] -- yby=coby1 
   ldy #yd/2
-//SEG5 [0] phi (byte) x#2 = (byte) 0 -- xby=coby1 
+//SEG5 [0] phi (byte) x#2 = (byte) 0 [phi:@begin->@1#2] -- xby=coby1 
   ldx #0
-//SEG6 [0] phi (word) idx#3 = (byte) 0+(byte) 0*(byte) 40 -- zpwo1=coby1 
+//SEG6 [0] phi (word) idx#3 = (byte) 0+(byte) 0*(byte) 40 [phi:@begin->@1#3] -- zpwo1=coby1 
   lda #0+0*$28
   sta idx
   lda #0
   sta idx+1
   jmp b1
-//SEG7 [0] phi from @2 to @1
-//SEG8 [0] phi (byte) y#2 = (byte) y#4 -- register_copy 
-//SEG9 [0] phi (byte) e#3 = (byte) e#5 -- register_copy 
-//SEG10 [0] phi (byte) x#2 = (byte) x#1 -- register_copy 
-//SEG11 [0] phi (word) idx#3 = (word) idx#5 -- register_copy 
+//SEG7 [0] phi from @2 to @1 [phi:@2->@1]
+//SEG8 [0] phi (byte) y#2 = (byte) y#4 [phi:@2->@1#0] -- register_copy 
+//SEG9 [0] phi (byte) e#3 = (byte) e#5 [phi:@2->@1#1] -- register_copy 
+//SEG10 [0] phi (byte) x#2 = (byte) x#1 [phi:@2->@1#2] -- register_copy 
+//SEG11 [0] phi (word) idx#3 = (word) idx#5 [phi:@2->@1#3] -- register_copy 
 //SEG12 @1
 b1:
 //SEG13 [1] *((const byte[1000]) screen#0 + (word) idx#3) ← (const byte) STAR#0 [ idx#3 x#2 e#3 y#2 ] -- cowo1_staridx_zpwo1=coby2 
@@ -1564,10 +1564,10 @@ b1:
   sec
   sbc #xd
   tay
-//SEG22 [9] phi from @1 @3 to @2
-//SEG23 [9] phi (byte) y#4 = (byte) y#2 -- register_copy 
-//SEG24 [9] phi (byte) e#5 = (byte) e#1 -- register_copy 
-//SEG25 [9] phi (word) idx#5 = (word) idx#1 -- register_copy 
+//SEG22 [9] phi from @1 @3 to @2 [phi:@1/@3->@2]
+//SEG23 [9] phi (byte) y#4 = (byte) y#2 [phi:@1/@3->@2#0] -- register_copy 
+//SEG24 [9] phi (byte) e#5 = (byte) e#1 [phi:@1/@3->@2#1] -- register_copy 
+//SEG25 [9] phi (word) idx#5 = (word) idx#1 [phi:@1/@3->@2#2] -- register_copy 
 //SEG26 @2
 b2:
 //SEG27 [10] if((byte) x#1<(const byte) x1#0+(byte) 1) goto @1 [ idx#5 x#1 e#5 y#4 ] -- xby_lt_coby1_then_la1 
@@ -1588,24 +1588,24 @@ ASSEMBLER
   .label idx = 2
   .label y = 4
 //SEG1 @begin
-//SEG2 [0] phi from @begin to @1
-//SEG3 [0] phi (byte) y#2 = (byte) 0 -- zpby1=coby1 
+//SEG2 [0] phi from @begin to @1 [phi:@begin->@1]
+//SEG3 [0] phi (byte) y#2 = (byte) 0 [phi:@begin->@1#0] -- zpby1=coby1 
   lda #0
   sta y
-//SEG4 [0] phi (byte) e#3 = (const byte) yd#0/(byte) 2 -- yby=coby1 
+//SEG4 [0] phi (byte) e#3 = (const byte) yd#0/(byte) 2 [phi:@begin->@1#1] -- yby=coby1 
   ldy #yd/2
-//SEG5 [0] phi (byte) x#2 = (byte) 0 -- xby=coby1 
+//SEG5 [0] phi (byte) x#2 = (byte) 0 [phi:@begin->@1#2] -- xby=coby1 
   ldx #0
-//SEG6 [0] phi (word) idx#3 = (byte) 0+(byte) 0*(byte) 40 -- zpwo1=coby1 
+//SEG6 [0] phi (word) idx#3 = (byte) 0+(byte) 0*(byte) 40 [phi:@begin->@1#3] -- zpwo1=coby1 
   lda #0+0*$28
   sta idx
   lda #0
   sta idx+1
-//SEG7 [0] phi from @2 to @1
-//SEG8 [0] phi (byte) y#2 = (byte) y#4 -- register_copy 
-//SEG9 [0] phi (byte) e#3 = (byte) e#5 -- register_copy 
-//SEG10 [0] phi (byte) x#2 = (byte) x#1 -- register_copy 
-//SEG11 [0] phi (word) idx#3 = (word) idx#5 -- register_copy 
+//SEG7 [0] phi from @2 to @1 [phi:@2->@1]
+//SEG8 [0] phi (byte) y#2 = (byte) y#4 [phi:@2->@1#0] -- register_copy 
+//SEG9 [0] phi (byte) e#3 = (byte) e#5 [phi:@2->@1#1] -- register_copy 
+//SEG10 [0] phi (byte) x#2 = (byte) x#1 [phi:@2->@1#2] -- register_copy 
+//SEG11 [0] phi (word) idx#3 = (word) idx#5 [phi:@2->@1#3] -- register_copy 
 //SEG12 @1
 b1:
 //SEG13 [1] *((const byte[1000]) screen#0 + (word) idx#3) ← (const byte) STAR#0 [ idx#3 x#2 e#3 y#2 ] -- cowo1_staridx_zpwo1=coby2 
@@ -1650,10 +1650,10 @@ b1:
   sec
   sbc #xd
   tay
-//SEG22 [9] phi from @1 @3 to @2
-//SEG23 [9] phi (byte) y#4 = (byte) y#2 -- register_copy 
-//SEG24 [9] phi (byte) e#5 = (byte) e#1 -- register_copy 
-//SEG25 [9] phi (word) idx#5 = (word) idx#1 -- register_copy 
+//SEG22 [9] phi from @1 @3 to @2 [phi:@1/@3->@2]
+//SEG23 [9] phi (byte) y#4 = (byte) y#2 [phi:@1/@3->@2#0] -- register_copy 
+//SEG24 [9] phi (byte) e#5 = (byte) e#1 [phi:@1/@3->@2#1] -- register_copy 
+//SEG25 [9] phi (word) idx#5 = (word) idx#1 [phi:@1/@3->@2#2] -- register_copy 
 //SEG26 @2
 b2:
 //SEG27 [10] if((byte) x#1<(const byte) x1#0+(byte) 1) goto @1 [ idx#5 x#1 e#5 y#4 ] -- xby_lt_coby1_then_la1 
@@ -1715,24 +1715,24 @@ FINAL CODE
   .label idx = 2
   .label y = 4
 //SEG1 @begin
-//SEG2 [0] phi from @begin to @1
-//SEG3 [0] phi (byte) y#2 = (byte) 0 -- zpby1=coby1 
+//SEG2 [0] phi from @begin to @1 [phi:@begin->@1]
+//SEG3 [0] phi (byte) y#2 = (byte) 0 [phi:@begin->@1#0] -- zpby1=coby1 
   lda #0
   sta y
-//SEG4 [0] phi (byte) e#3 = (const byte) yd#0/(byte) 2 -- yby=coby1 
+//SEG4 [0] phi (byte) e#3 = (const byte) yd#0/(byte) 2 [phi:@begin->@1#1] -- yby=coby1 
   ldy #yd/2
-//SEG5 [0] phi (byte) x#2 = (byte) 0 -- xby=coby1 
+//SEG5 [0] phi (byte) x#2 = (byte) 0 [phi:@begin->@1#2] -- xby=coby1 
   ldx #0
-//SEG6 [0] phi (word) idx#3 = (byte) 0+(byte) 0*(byte) 40 -- zpwo1=coby1 
+//SEG6 [0] phi (word) idx#3 = (byte) 0+(byte) 0*(byte) 40 [phi:@begin->@1#3] -- zpwo1=coby1 
   lda #0+0*$28
   sta idx
   lda #0
   sta idx+1
-//SEG7 [0] phi from @2 to @1
-//SEG8 [0] phi (byte) y#2 = (byte) y#4 -- register_copy 
-//SEG9 [0] phi (byte) e#3 = (byte) e#5 -- register_copy 
-//SEG10 [0] phi (byte) x#2 = (byte) x#1 -- register_copy 
-//SEG11 [0] phi (word) idx#3 = (word) idx#5 -- register_copy 
+//SEG7 [0] phi from @2 to @1 [phi:@2->@1]
+//SEG8 [0] phi (byte) y#2 = (byte) y#4 [phi:@2->@1#0] -- register_copy 
+//SEG9 [0] phi (byte) e#3 = (byte) e#5 [phi:@2->@1#1] -- register_copy 
+//SEG10 [0] phi (byte) x#2 = (byte) x#1 [phi:@2->@1#2] -- register_copy 
+//SEG11 [0] phi (word) idx#3 = (word) idx#5 [phi:@2->@1#3] -- register_copy 
 //SEG12 @1
 b1:
 //SEG13 [1] *((const byte[1000]) screen#0 + (word) idx#3) ← (const byte) STAR#0 [ idx#3 x#2 e#3 y#2 ] -- cowo1_staridx_zpwo1=coby2 
@@ -1777,10 +1777,10 @@ b1:
   sec
   sbc #xd
   tay
-//SEG22 [9] phi from @1 @3 to @2
-//SEG23 [9] phi (byte) y#4 = (byte) y#2 -- register_copy 
-//SEG24 [9] phi (byte) e#5 = (byte) e#1 -- register_copy 
-//SEG25 [9] phi (word) idx#5 = (word) idx#1 -- register_copy 
+//SEG22 [9] phi from @1 @3 to @2 [phi:@1/@3->@2]
+//SEG23 [9] phi (byte) y#4 = (byte) y#2 [phi:@1/@3->@2#0] -- register_copy 
+//SEG24 [9] phi (byte) e#5 = (byte) e#1 [phi:@1/@3->@2#1] -- register_copy 
+//SEG25 [9] phi (word) idx#5 = (word) idx#1 [phi:@1/@3->@2#2] -- register_copy 
 //SEG26 @2
 b2:
 //SEG27 [10] if((byte) x#1<(const byte) x1#0+(byte) 1) goto @1 [ idx#5 x#1 e#5 y#4 ] -- xby_lt_coby1_then_la1 

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

@@ -662,15 +662,15 @@ main: {
   //SEG6 [2] *((const byte*) BGCOL#0) ← (const byte) RED#0 [ ] -- _star_cowo1=coby2 
     lda #RED
     sta BGCOL
-  //SEG7 [3] phi from main to main::@1
+  //SEG7 [3] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG8 [3] phi (byte) main::i#2 = (byte) 40 -- zpby1=coby1 
+  //SEG8 [3] phi (byte) main::i#2 = (byte) 40 [phi:main->main::@1#0] -- zpby1=coby1 
     lda #$28
     sta i
     jmp b1
-  //SEG9 [3] phi from main::@1 to main::@1
+  //SEG9 [3] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
   b1_from_b1:
-  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
     jmp b1
   //SEG11 main::@1
   b1:
@@ -732,14 +732,14 @@ main: {
   //SEG6 [2] *((const byte*) BGCOL#0) ← (const byte) RED#0 [ ] -- _star_cowo1=coby2 
     lda #RED
     sta BGCOL
-  //SEG7 [3] phi from main to main::@1
+  //SEG7 [3] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG8 [3] phi (byte) main::i#2 = (byte) 40 -- xby=coby1 
+  //SEG8 [3] phi (byte) main::i#2 = (byte) 40 [phi:main->main::@1#0] -- xby=coby1 
     ldx #$28
     jmp b1
-  //SEG9 [3] phi from main::@1 to main::@1
+  //SEG9 [3] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
   b1_from_b1:
-  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
   //SEG11 main::@1
   b1:
   //SEG12 [4] *((const byte*) SCREEN#0 + (byte) main::i#2) ← (const byte) STAR#0+(byte) 1 [ main::i#2 ] -- cowo1_staridx_xby=coby2 
@@ -780,13 +780,13 @@ main: {
   //SEG6 [2] *((const byte*) BGCOL#0) ← (const byte) RED#0 [ ] -- _star_cowo1=coby2 
     lda #RED
     sta BGCOL
-  //SEG7 [3] phi from main to main::@1
+  //SEG7 [3] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG8 [3] phi (byte) main::i#2 = (byte) 40 -- xby=coby1 
+  //SEG8 [3] phi (byte) main::i#2 = (byte) 40 [phi:main->main::@1#0] -- xby=coby1 
     ldx #$28
     jmp b1
-  //SEG9 [3] phi from main::@1 to main::@1
-  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 [3] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
+  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
   //SEG11 main::@1
   b1:
   //SEG12 [4] *((const byte*) SCREEN#0 + (byte) main::i#2) ← (const byte) STAR#0+(byte) 1 [ main::i#2 ] -- cowo1_staridx_xby=coby2 
@@ -827,12 +827,12 @@ main: {
   //SEG6 [2] *((const byte*) BGCOL#0) ← (const byte) RED#0 [ ] -- _star_cowo1=coby2 
     lda #RED
     sta BGCOL
-  //SEG7 [3] phi from main to main::@1
-  //SEG8 [3] phi (byte) main::i#2 = (byte) 40 -- xby=coby1 
+  //SEG7 [3] phi from main to main::@1 [phi:main->main::@1]
+  //SEG8 [3] phi (byte) main::i#2 = (byte) 40 [phi:main->main::@1#0] -- xby=coby1 
     ldx #$28
     jmp b1
-  //SEG9 [3] phi from main::@1 to main::@1
-  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 [3] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
+  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
   //SEG11 main::@1
   b1:
   //SEG12 [4] *((const byte*) SCREEN#0 + (byte) main::i#2) ← (const byte) STAR#0+(byte) 1 [ main::i#2 ] -- cowo1_staridx_xby=coby2 
@@ -869,11 +869,11 @@ main: {
   //SEG6 [2] *((const byte*) BGCOL#0) ← (const byte) RED#0 [ ] -- _star_cowo1=coby2 
     lda #RED
     sta BGCOL
-  //SEG7 [3] phi from main to main::@1
-  //SEG8 [3] phi (byte) main::i#2 = (byte) 40 -- xby=coby1 
+  //SEG7 [3] phi from main to main::@1 [phi:main->main::@1]
+  //SEG8 [3] phi (byte) main::i#2 = (byte) 40 [phi:main->main::@1#0] -- xby=coby1 
     ldx #$28
-  //SEG9 [3] phi from main::@1 to main::@1
-  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 [3] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
+  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
   //SEG11 main::@1
   b1:
   //SEG12 [4] *((const byte*) SCREEN#0 + (byte) main::i#2) ← (const byte) STAR#0+(byte) 1 [ main::i#2 ] -- cowo1_staridx_xby=coby2 
@@ -930,11 +930,11 @@ main: {
   //SEG6 [2] *((const byte*) BGCOL#0) ← (const byte) RED#0 [ ] -- _star_cowo1=coby2 
     lda #RED
     sta BGCOL
-  //SEG7 [3] phi from main to main::@1
-  //SEG8 [3] phi (byte) main::i#2 = (byte) 40 -- xby=coby1 
+  //SEG7 [3] phi from main to main::@1 [phi:main->main::@1]
+  //SEG8 [3] phi (byte) main::i#2 = (byte) 40 [phi:main->main::@1#0] -- xby=coby1 
     ldx #$28
-  //SEG9 [3] phi from main::@1 to main::@1
-  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 [3] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
+  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
   //SEG11 main::@1
   b1:
   //SEG12 [4] *((const byte*) SCREEN#0 + (byte) main::i#2) ← (const byte) STAR#0+(byte) 1 [ main::i#2 ] -- cowo1_staridx_xby=coby2 

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

@@ -650,15 +650,15 @@ main: {
   //SEG6 [2] *((const byte[15]) fibs#0+(byte) 1) ← (byte) 1 [ ] -- _star_cowo1=coby2 
     lda #1
     sta fibs+1
-  //SEG7 [3] phi from main to main::@1
+  //SEG7 [3] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 -- zpby1=coby1 
+  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- zpby1=coby1 
     lda #0
     sta i
     jmp b1
-  //SEG9 [3] phi from main::@1 to main::@1
+  //SEG9 [3] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
   b1_from_b1:
-  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
     jmp b1
   //SEG11 main::@1
   b1:
@@ -730,14 +730,14 @@ main: {
   //SEG6 [2] *((const byte[15]) fibs#0+(byte) 1) ← (byte) 1 [ ] -- _star_cowo1=coby2 
     lda #1
     sta fibs+1
-  //SEG7 [3] phi from main to main::@1
+  //SEG7 [3] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- xby=coby1 
     ldx #0
     jmp b1
-  //SEG9 [3] phi from main::@1 to main::@1
+  //SEG9 [3] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
   b1_from_b1:
-  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
   //SEG11 main::@1
   b1:
   //SEG12 [4] (byte~) main::$1 ← (const byte[15]) fibs#0 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- aby=cowo1_staridx_xby 
@@ -780,13 +780,13 @@ main: {
   //SEG6 [2] *((const byte[15]) fibs#0+(byte) 1) ← (byte) 1 [ ] -- _star_cowo1=coby2 
     lda #1
     sta fibs+1
-  //SEG7 [3] phi from main to main::@1
+  //SEG7 [3] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- xby=coby1 
     ldx #0
     jmp b1
-  //SEG9 [3] phi from main::@1 to main::@1
-  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 [3] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
+  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
   //SEG11 main::@1
   b1:
   //SEG12 [4] (byte~) main::$1 ← (const byte[15]) fibs#0 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- aby=cowo1_staridx_xby 
@@ -829,12 +829,12 @@ main: {
   //SEG6 [2] *((const byte[15]) fibs#0+(byte) 1) ← (byte) 1 [ ] -- _star_cowo1=coby2 
     lda #1
     sta fibs+1
-  //SEG7 [3] phi from main to main::@1
-  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG7 [3] phi from main to main::@1 [phi:main->main::@1]
+  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- xby=coby1 
     ldx #0
     jmp b1
-  //SEG9 [3] phi from main::@1 to main::@1
-  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 [3] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
+  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
   //SEG11 main::@1
   b1:
   //SEG12 [4] (byte~) main::$1 ← (const byte[15]) fibs#0 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- aby=cowo1_staridx_xby 
@@ -873,11 +873,11 @@ main: {
   //SEG6 [2] *((const byte[15]) fibs#0+(byte) 1) ← (byte) 1 [ ] -- _star_cowo1=coby2 
     lda #1
     sta fibs+1
-  //SEG7 [3] phi from main to main::@1
-  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG7 [3] phi from main to main::@1 [phi:main->main::@1]
+  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- xby=coby1 
     ldx #0
-  //SEG9 [3] phi from main::@1 to main::@1
-  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 [3] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
+  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
   //SEG11 main::@1
   b1:
   //SEG12 [4] (byte~) main::$1 ← (const byte[15]) fibs#0 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- aby=cowo1_staridx_xby 
@@ -934,11 +934,11 @@ main: {
   //SEG6 [2] *((const byte[15]) fibs#0+(byte) 1) ← (byte) 1 [ ] -- _star_cowo1=coby2 
     lda #1
     sta fibs+1
-  //SEG7 [3] phi from main to main::@1
-  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG7 [3] phi from main to main::@1 [phi:main->main::@1]
+  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- xby=coby1 
     ldx #0
-  //SEG9 [3] phi from main::@1 to main::@1
-  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 [3] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
+  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
   //SEG11 main::@1
   b1:
   //SEG12 [4] (byte~) main::$1 ← (const byte[15]) fibs#0 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- aby=cowo1_staridx_xby 

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

@@ -486,7 +486,7 @@ bbegin:
 //SEG2 @1
 b1:
 //SEG3 [0] call main param-assignment [ ]
-//SEG4 [1] phi from @1 to main
+//SEG4 [1] phi from @1 to main [phi:@1->main]
 main_from_b1:
   jsr main
   jmp bend
@@ -495,15 +495,15 @@ bend:
 //SEG6 main
 main: {
     .label i = 2
-  //SEG7 [2] phi from main to main::@1
+  //SEG7 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG8 [2] phi (byte) main::i#2 = (byte) 0 -- zpby1=coby1 
+  //SEG8 [2] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- zpby1=coby1 
     lda #0
     sta i
     jmp b1
-  //SEG9 [2] phi from main::@1 to main::@1
+  //SEG9 [2] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
   b1_from_b1:
-  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
     jmp b1
   //SEG11 main::@1
   b1:
@@ -546,21 +546,21 @@ bbegin:
 //SEG2 @1
 b1:
 //SEG3 [0] call main param-assignment [ ]
-//SEG4 [1] phi from @1 to main
+//SEG4 [1] phi from @1 to main [phi:@1->main]
 main_from_b1:
   jsr main
 //SEG5 @end
 bend:
 //SEG6 main
 main: {
-  //SEG7 [2] phi from main to main::@1
+  //SEG7 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG8 [2] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG8 [2] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- xby=coby1 
     ldx #0
     jmp b1
-  //SEG9 [2] phi from main::@1 to main::@1
+  //SEG9 [2] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
   b1_from_b1:
-  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
   //SEG11 main::@1
   b1:
   //SEG12 [3] *((const byte*) SCREEN#0 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 
@@ -589,19 +589,19 @@ ASSEMBLER
 //SEG2 @1
 b1:
 //SEG3 [0] call main param-assignment [ ]
-//SEG4 [1] phi from @1 to main
+//SEG4 [1] phi from @1 to main [phi:@1->main]
   jsr main
 //SEG5 @end
 bend:
 //SEG6 main
 main: {
-  //SEG7 [2] phi from main to main::@1
+  //SEG7 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG8 [2] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG8 [2] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- xby=coby1 
     ldx #0
     jmp b1
-  //SEG9 [2] phi from main::@1 to main::@1
-  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 [2] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
+  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
   //SEG11 main::@1
   b1:
   //SEG12 [3] *((const byte*) SCREEN#0 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 
@@ -629,17 +629,17 @@ ASSEMBLER
 //SEG1 @begin
 //SEG2 @1
 //SEG3 [0] call main param-assignment [ ]
-//SEG4 [1] phi from @1 to main
+//SEG4 [1] phi from @1 to main [phi:@1->main]
   jsr main
 //SEG5 @end
 //SEG6 main
 main: {
-  //SEG7 [2] phi from main to main::@1
-  //SEG8 [2] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG7 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG8 [2] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- xby=coby1 
     ldx #0
     jmp b1
-  //SEG9 [2] phi from main::@1 to main::@1
-  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 [2] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
+  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
   //SEG11 main::@1
   b1:
   //SEG12 [3] *((const byte*) SCREEN#0 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 
@@ -663,16 +663,16 @@ ASSEMBLER
 //SEG1 @begin
 //SEG2 @1
 //SEG3 [0] call main param-assignment [ ]
-//SEG4 [1] phi from @1 to main
+//SEG4 [1] phi from @1 to main [phi:@1->main]
   jsr main
 //SEG5 @end
 //SEG6 main
 main: {
-  //SEG7 [2] phi from main to main::@1
-  //SEG8 [2] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG7 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG8 [2] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- xby=coby1 
     ldx #0
-  //SEG9 [2] phi from main::@1 to main::@1
-  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 [2] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
+  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
   //SEG11 main::@1
   b1:
   //SEG12 [3] *((const byte*) SCREEN#0 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 
@@ -709,16 +709,16 @@ FINAL CODE
 //SEG1 @begin
 //SEG2 @1
 //SEG3 [0] call main param-assignment [ ]
-//SEG4 [1] phi from @1 to main
+//SEG4 [1] phi from @1 to main [phi:@1->main]
   jsr main
 //SEG5 @end
 //SEG6 main
 main: {
-  //SEG7 [2] phi from main to main::@1
-  //SEG8 [2] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG7 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG8 [2] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- xby=coby1 
     ldx #0
-  //SEG9 [2] phi from main::@1 to main::@1
-  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 [2] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
+  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
   //SEG11 main::@1
   b1:
   //SEG12 [3] *((const byte*) SCREEN#0 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 

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

@@ -776,7 +776,7 @@ bbegin:
 //SEG2 @1
 b1:
 //SEG3 [0] call main param-assignment [ ]
-//SEG4 [1] phi from @1 to main
+//SEG4 [1] phi from @1 to main [phi:@1->main]
 main_from_b1:
   jsr main
   jmp bend
@@ -786,15 +786,15 @@ bend:
 main: {
     .label i = 2
     .label j = 3
-  //SEG7 [2] phi from main to main::@1
+  //SEG7 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG8 [2] phi (byte) main::i#2 = (byte) 0 -- zpby1=coby1 
+  //SEG8 [2] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- zpby1=coby1 
     lda #0
     sta i
     jmp b1
-  //SEG9 [2] phi from main::@1 to main::@1
+  //SEG9 [2] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
   b1_from_b1:
-  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
     jmp b1
   //SEG11 main::@1
   b1:
@@ -807,15 +807,15 @@ main: {
   //SEG14 [5] if((byte) main::i#1!=(byte) 0) goto main::@1 [ main::i#1 ] -- zpby1_neq_0_then_la1 
     lda i
     bne b1_from_b1
-  //SEG15 [6] phi from main::@1 to main::@2
+  //SEG15 [6] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
   b2_from_b1:
-  //SEG16 [6] phi (byte) main::j#2 = (byte) 100 -- zpby1=coby1 
+  //SEG16 [6] phi (byte) main::j#2 = (byte) 100 [phi:main::@1->main::@2#0] -- zpby1=coby1 
     lda #$64
     sta j
     jmp b2
-  //SEG17 [6] phi from main::@2 to main::@2
+  //SEG17 [6] phi from main::@2 to main::@2 [phi:main::@2->main::@2]
   b2_from_b2:
-  //SEG18 [6] phi (byte) main::j#2 = (byte) main::j#1 -- register_copy 
+  //SEG18 [6] phi (byte) main::j#2 = (byte) main::j#1 [phi:main::@2->main::@2#0] -- register_copy 
     jmp b2
   //SEG19 main::@2
   b2:
@@ -861,21 +861,21 @@ bbegin:
 //SEG2 @1
 b1:
 //SEG3 [0] call main param-assignment [ ]
-//SEG4 [1] phi from @1 to main
+//SEG4 [1] phi from @1 to main [phi:@1->main]
 main_from_b1:
   jsr main
 //SEG5 @end
 bend:
 //SEG6 main
 main: {
-  //SEG7 [2] phi from main to main::@1
+  //SEG7 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG8 [2] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG8 [2] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- xby=coby1 
     ldx #0
     jmp b1
-  //SEG9 [2] phi from main::@1 to main::@1
+  //SEG9 [2] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
   b1_from_b1:
-  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
   //SEG11 main::@1
   b1:
   //SEG12 [3] *((const byte*) SCREEN1#0 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 
@@ -886,14 +886,14 @@ main: {
   //SEG14 [5] if((byte) main::i#1!=(byte) 0) goto main::@1 [ main::i#1 ] -- xby_neq_0_then_la1 
     cpx #0
     bne b1_from_b1
-  //SEG15 [6] phi from main::@1 to main::@2
+  //SEG15 [6] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
   b2_from_b1:
-  //SEG16 [6] phi (byte) main::j#2 = (byte) 100 -- xby=coby1 
+  //SEG16 [6] phi (byte) main::j#2 = (byte) 100 [phi:main::@1->main::@2#0] -- xby=coby1 
     ldx #$64
     jmp b2
-  //SEG17 [6] phi from main::@2 to main::@2
+  //SEG17 [6] phi from main::@2 to main::@2 [phi:main::@2->main::@2]
   b2_from_b2:
-  //SEG18 [6] phi (byte) main::j#2 = (byte) main::j#1 -- register_copy 
+  //SEG18 [6] phi (byte) main::j#2 = (byte) main::j#1 [phi:main::@2->main::@2#0] -- register_copy 
   //SEG19 main::@2
   b2:
   //SEG20 [7] *((const byte*) SCREEN2#0 + (byte) main::j#2) ← (byte) main::j#2 [ main::j#2 ] -- cowo1_staridx_xby=xby 
@@ -925,19 +925,19 @@ ASSEMBLER
 //SEG2 @1
 b1:
 //SEG3 [0] call main param-assignment [ ]
-//SEG4 [1] phi from @1 to main
+//SEG4 [1] phi from @1 to main [phi:@1->main]
   jsr main
 //SEG5 @end
 bend:
 //SEG6 main
 main: {
-  //SEG7 [2] phi from main to main::@1
+  //SEG7 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG8 [2] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG8 [2] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- xby=coby1 
     ldx #0
     jmp b1
-  //SEG9 [2] phi from main::@1 to main::@1
-  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 [2] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
+  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
   //SEG11 main::@1
   b1:
   //SEG12 [3] *((const byte*) SCREEN1#0 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 
@@ -948,13 +948,13 @@ main: {
   //SEG14 [5] if((byte) main::i#1!=(byte) 0) goto main::@1 [ main::i#1 ] -- xby_neq_0_then_la1 
     cpx #0
     bne b1
-  //SEG15 [6] phi from main::@1 to main::@2
+  //SEG15 [6] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
   b2_from_b1:
-  //SEG16 [6] phi (byte) main::j#2 = (byte) 100 -- xby=coby1 
+  //SEG16 [6] phi (byte) main::j#2 = (byte) 100 [phi:main::@1->main::@2#0] -- xby=coby1 
     ldx #$64
     jmp b2
-  //SEG17 [6] phi from main::@2 to main::@2
-  //SEG18 [6] phi (byte) main::j#2 = (byte) main::j#1 -- register_copy 
+  //SEG17 [6] phi from main::@2 to main::@2 [phi:main::@2->main::@2]
+  //SEG18 [6] phi (byte) main::j#2 = (byte) main::j#1 [phi:main::@2->main::@2#0] -- register_copy 
   //SEG19 main::@2
   b2:
   //SEG20 [7] *((const byte*) SCREEN2#0 + (byte) main::j#2) ← (byte) main::j#2 [ main::j#2 ] -- cowo1_staridx_xby=xby 
@@ -984,17 +984,17 @@ ASSEMBLER
 //SEG1 @begin
 //SEG2 @1
 //SEG3 [0] call main param-assignment [ ]
-//SEG4 [1] phi from @1 to main
+//SEG4 [1] phi from @1 to main [phi:@1->main]
   jsr main
 //SEG5 @end
 //SEG6 main
 main: {
-  //SEG7 [2] phi from main to main::@1
-  //SEG8 [2] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG7 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG8 [2] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- xby=coby1 
     ldx #0
     jmp b1
-  //SEG9 [2] phi from main::@1 to main::@1
-  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 [2] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
+  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
   //SEG11 main::@1
   b1:
   //SEG12 [3] *((const byte*) SCREEN1#0 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 
@@ -1005,12 +1005,12 @@ main: {
   //SEG14 [5] if((byte) main::i#1!=(byte) 0) goto main::@1 [ main::i#1 ] -- xby_neq_0_then_la1 
     cpx #0
     bne b1
-  //SEG15 [6] phi from main::@1 to main::@2
-  //SEG16 [6] phi (byte) main::j#2 = (byte) 100 -- xby=coby1 
+  //SEG15 [6] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
+  //SEG16 [6] phi (byte) main::j#2 = (byte) 100 [phi:main::@1->main::@2#0] -- xby=coby1 
     ldx #$64
     jmp b2
-  //SEG17 [6] phi from main::@2 to main::@2
-  //SEG18 [6] phi (byte) main::j#2 = (byte) main::j#1 -- register_copy 
+  //SEG17 [6] phi from main::@2 to main::@2 [phi:main::@2->main::@2]
+  //SEG18 [6] phi (byte) main::j#2 = (byte) main::j#1 [phi:main::@2->main::@2#0] -- register_copy 
   //SEG19 main::@2
   b2:
   //SEG20 [7] *((const byte*) SCREEN2#0 + (byte) main::j#2) ← (byte) main::j#2 [ main::j#2 ] -- cowo1_staridx_xby=xby 
@@ -1036,16 +1036,16 @@ ASSEMBLER
 //SEG1 @begin
 //SEG2 @1
 //SEG3 [0] call main param-assignment [ ]
-//SEG4 [1] phi from @1 to main
+//SEG4 [1] phi from @1 to main [phi:@1->main]
   jsr main
 //SEG5 @end
 //SEG6 main
 main: {
-  //SEG7 [2] phi from main to main::@1
-  //SEG8 [2] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG7 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG8 [2] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- xby=coby1 
     ldx #0
-  //SEG9 [2] phi from main::@1 to main::@1
-  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 [2] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
+  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
   //SEG11 main::@1
   b1:
   //SEG12 [3] *((const byte*) SCREEN1#0 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 
@@ -1056,11 +1056,11 @@ main: {
   //SEG14 [5] if((byte) main::i#1!=(byte) 0) goto main::@1 [ main::i#1 ] -- xby_neq_0_then_la1 
     cpx #0
     bne b1
-  //SEG15 [6] phi from main::@1 to main::@2
-  //SEG16 [6] phi (byte) main::j#2 = (byte) 100 -- xby=coby1 
+  //SEG15 [6] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
+  //SEG16 [6] phi (byte) main::j#2 = (byte) 100 [phi:main::@1->main::@2#0] -- xby=coby1 
     ldx #$64
-  //SEG17 [6] phi from main::@2 to main::@2
-  //SEG18 [6] phi (byte) main::j#2 = (byte) main::j#1 -- register_copy 
+  //SEG17 [6] phi from main::@2 to main::@2 [phi:main::@2->main::@2]
+  //SEG18 [6] phi (byte) main::j#2 = (byte) main::j#1 [phi:main::@2->main::@2#0] -- register_copy 
   //SEG19 main::@2
   b2:
   //SEG20 [7] *((const byte*) SCREEN2#0 + (byte) main::j#2) ← (byte) main::j#2 [ main::j#2 ] -- cowo1_staridx_xby=xby 
@@ -1105,16 +1105,16 @@ FINAL CODE
 //SEG1 @begin
 //SEG2 @1
 //SEG3 [0] call main param-assignment [ ]
-//SEG4 [1] phi from @1 to main
+//SEG4 [1] phi from @1 to main [phi:@1->main]
   jsr main
 //SEG5 @end
 //SEG6 main
 main: {
-  //SEG7 [2] phi from main to main::@1
-  //SEG8 [2] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG7 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG8 [2] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- xby=coby1 
     ldx #0
-  //SEG9 [2] phi from main::@1 to main::@1
-  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 [2] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
+  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
   //SEG11 main::@1
   b1:
   //SEG12 [3] *((const byte*) SCREEN1#0 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 
@@ -1125,11 +1125,11 @@ main: {
   //SEG14 [5] if((byte) main::i#1!=(byte) 0) goto main::@1 [ main::i#1 ] -- xby_neq_0_then_la1 
     cpx #0
     bne b1
-  //SEG15 [6] phi from main::@1 to main::@2
-  //SEG16 [6] phi (byte) main::j#2 = (byte) 100 -- xby=coby1 
+  //SEG15 [6] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
+  //SEG16 [6] phi (byte) main::j#2 = (byte) 100 [phi:main::@1->main::@2#0] -- xby=coby1 
     ldx #$64
-  //SEG17 [6] phi from main::@2 to main::@2
-  //SEG18 [6] phi (byte) main::j#2 = (byte) main::j#1 -- register_copy 
+  //SEG17 [6] phi from main::@2 to main::@2 [phi:main::@2->main::@2]
+  //SEG18 [6] phi (byte) main::j#2 = (byte) main::j#1 [phi:main::@2->main::@2#0] -- register_copy 
   //SEG19 main::@2
   b2:
   //SEG20 [7] *((const byte*) SCREEN2#0 + (byte) main::j#2) ← (byte) main::j#2 [ main::j#2 ] -- cowo1_staridx_xby=xby 

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

@@ -3587,23 +3587,23 @@ main: {
   //SEG5 [1] *((const byte*) PROCPORT#0) ← (byte) 50 [ ] -- _star_cowo1=coby2 
     lda #$32
     sta PROCPORT
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte*) main::charset4#10 = (const byte*) CHARSET4#0 -- zpptrby1=cowo1 
+  //SEG7 [2] phi (byte*) main::charset4#10 = (const byte*) CHARSET4#0 [phi:main->main::@1#0] -- zpptrby1=cowo1 
     lda #<CHARSET4
     sta charset4
     lda #>CHARSET4
     sta charset4+1
-  //SEG8 [2] phi (byte*) main::chargen#2 = (const byte*) CHARGEN#0 -- zpptrby1=cowo1 
+  //SEG8 [2] phi (byte*) main::chargen#2 = (const byte*) CHARGEN#0 [phi:main->main::@1#1] -- zpptrby1=cowo1 
     lda #<CHARGEN
     sta chargen
     lda #>CHARGEN
     sta chargen+1
     jmp b1
-  //SEG9 [2] phi from main::@5 to main::@1
+  //SEG9 [2] phi from main::@5 to main::@1 [phi:main::@5->main::@1]
   b1_from_b5:
-  //SEG10 [2] phi (byte*) main::charset4#10 = (byte*) main::charset4#1 -- register_copy 
-  //SEG11 [2] phi (byte*) main::chargen#2 = (byte*) main::chargen#1 -- register_copy 
+  //SEG10 [2] phi (byte*) main::charset4#10 = (byte*) main::charset4#1 [phi:main::@5->main::@1#0] -- register_copy 
+  //SEG11 [2] phi (byte*) main::chargen#2 = (byte*) main::chargen#1 [phi:main::@5->main::@1#1] -- register_copy 
     jmp b1
   //SEG12 main::@1
   b1:
@@ -3660,15 +3660,15 @@ main: {
     jmp b7
   //SEG24 main::@7
   b7:
-  //SEG25 [14] phi from main::@7 to main::@2
+  //SEG25 [14] phi from main::@7 to main::@2 [phi:main::@7->main::@2]
   b2_from_b7:
-  //SEG26 [14] phi (byte) main::bits_gen#9 = (byte) 0+(byte) 1 -- zpby1=coby1 
+  //SEG26 [14] phi (byte) main::bits_gen#9 = (byte) 0+(byte) 1 [phi:main::@7->main::@2#0] -- zpby1=coby1 
     lda #0+1
     sta bits_gen_9
     jmp b2
-  //SEG27 [14] phi from main::@1 to main::@2
+  //SEG27 [14] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
   b2_from_b1:
-  //SEG28 [14] phi (byte) main::bits_gen#9 = (byte) 0 -- zpby1=coby1 
+  //SEG28 [14] phi (byte) main::bits_gen#9 = (byte) 0 [phi:main::@1->main::@2#0] -- zpby1=coby1 
     lda #0
     sta bits_gen_9
     jmp b2
@@ -3720,10 +3720,10 @@ main: {
   b8:
   //SEG41 [25] (byte) main::bits_gen#4 ← (byte) main::bits_gen#1 + (byte) 1 [ main::chargen#2 main::charset4#10 main::chargen1#0 main::bits_gen#4 ] -- zpby1=zpby1_plus_1 
     inc bits_gen
-  //SEG42 [26] phi from main::@2 main::@8 to main::@3
+  //SEG42 [26] phi from main::@2 main::@8 to main::@3 [phi:main::@2/main::@8->main::@3]
   b3_from_b2:
   b3_from_b8:
-  //SEG43 [26] phi (byte) main::bits_gen#11 = (byte) main::bits_gen#1 -- register_copy 
+  //SEG43 [26] phi (byte) main::bits_gen#11 = (byte) main::bits_gen#1 [phi:main::@2/main::@8->main::@3#0] -- register_copy 
     jmp b3
   //SEG44 main::@3
   b3:
@@ -3772,10 +3772,10 @@ main: {
   b9:
   //SEG56 [37] (byte) main::bits_gen#6 ← (byte) main::bits_gen#14 + (byte) 1 [ main::chargen#2 main::charset4#10 main::chargen1#0 main::bits_gen#6 ] -- zpby1=zpby1_plus_1 
     inc bits_gen_6
-  //SEG57 [38] phi from main::@3 main::@9 to main::@4
+  //SEG57 [38] phi from main::@3 main::@9 to main::@4 [phi:main::@3/main::@9->main::@4]
   b4_from_b3:
   b4_from_b9:
-  //SEG58 [38] phi (byte) main::bits_gen#13 = (byte) main::bits_gen#14 -- register_copy 
+  //SEG58 [38] phi (byte) main::bits_gen#13 = (byte) main::bits_gen#14 [phi:main::@3/main::@9->main::@4#0] -- register_copy 
     jmp b4
   //SEG59 main::@4
   b4:
@@ -3821,10 +3821,10 @@ main: {
   b10:
   //SEG70 [48] (byte) main::bits_gen#8 ← (byte) main::bits_gen#16 + (byte) 1 [ main::chargen#2 main::charset4#10 main::bits_gen#8 ] -- zpby1=zpby1_plus_1 
     inc bits_gen_8
-  //SEG71 [49] phi from main::@10 main::@4 to main::@5
+  //SEG71 [49] phi from main::@10 main::@4 to main::@5 [phi:main::@10/main::@4->main::@5]
   b5_from_b10:
   b5_from_b4:
-  //SEG72 [49] phi (byte) main::bits_gen#15 = (byte) main::bits_gen#8 -- register_copy 
+  //SEG72 [49] phi (byte) main::bits_gen#15 = (byte) main::bits_gen#8 [phi:main::@10/main::@4->main::@5#0] -- register_copy 
     jmp b5
   //SEG73 main::@5
   b5:
@@ -3864,15 +3864,15 @@ main: {
   //SEG80 [55] *((const byte*) PROCPORT#0) ← (byte) 55 [ ] -- _star_cowo1=coby2 
     lda #$37
     sta PROCPORT
-  //SEG81 [56] phi from main::@11 to main::@6
+  //SEG81 [56] phi from main::@11 to main::@6 [phi:main::@11->main::@6]
   b6_from_b11:
-  //SEG82 [56] phi (byte) main::i#2 = (byte) 0 -- zpby1=coby1 
+  //SEG82 [56] phi (byte) main::i#2 = (byte) 0 [phi:main::@11->main::@6#0] -- zpby1=coby1 
     lda #0
     sta i
     jmp b6
-  //SEG83 [56] phi from main::@6 to main::@6
+  //SEG83 [56] phi from main::@6 to main::@6 [phi:main::@6->main::@6]
   b6_from_b6:
-  //SEG84 [56] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG84 [56] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@6->main::@6#0] -- register_copy 
     jmp b6
   //SEG85 main::@6
   b6:
@@ -4147,23 +4147,23 @@ main: {
   //SEG5 [1] *((const byte*) PROCPORT#0) ← (byte) 50 [ ] -- _star_cowo1=coby2 
     lda #$32
     sta PROCPORT
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte*) main::charset4#10 = (const byte*) CHARSET4#0 -- zpptrby1=cowo1 
+  //SEG7 [2] phi (byte*) main::charset4#10 = (const byte*) CHARSET4#0 [phi:main->main::@1#0] -- zpptrby1=cowo1 
     lda #<CHARSET4
     sta charset4
     lda #>CHARSET4
     sta charset4+1
-  //SEG8 [2] phi (byte*) main::chargen#2 = (const byte*) CHARGEN#0 -- zpptrby1=cowo1 
+  //SEG8 [2] phi (byte*) main::chargen#2 = (const byte*) CHARGEN#0 [phi:main->main::@1#1] -- zpptrby1=cowo1 
     lda #<CHARGEN
     sta chargen
     lda #>CHARGEN
     sta chargen+1
     jmp b1
-  //SEG9 [2] phi from main::@5 to main::@1
+  //SEG9 [2] phi from main::@5 to main::@1 [phi:main::@5->main::@1]
   b1_from_b5:
-  //SEG10 [2] phi (byte*) main::charset4#10 = (byte*) main::charset4#1 -- register_copy 
-  //SEG11 [2] phi (byte*) main::chargen#2 = (byte*) main::chargen#1 -- register_copy 
+  //SEG10 [2] phi (byte*) main::charset4#10 = (byte*) main::charset4#1 [phi:main::@5->main::@1#0] -- register_copy 
+  //SEG11 [2] phi (byte*) main::chargen#2 = (byte*) main::chargen#1 [phi:main::@5->main::@1#1] -- register_copy 
   //SEG12 main::@1
   b1:
   //SEG13 [3] (byte*) main::chargen1#0 ← (byte*) main::chargen#2 + (byte) 1 [ main::chargen#2 main::charset4#10 main::chargen1#0 ] -- zpptrby1=zpptrby2_plus_1 
@@ -4203,14 +4203,14 @@ main: {
     bcc b2_from_b1
   //SEG24 main::@7
   b7:
-  //SEG25 [14] phi from main::@7 to main::@2
+  //SEG25 [14] phi from main::@7 to main::@2 [phi:main::@7->main::@2]
   b2_from_b7:
-  //SEG26 [14] phi (byte) main::bits_gen#9 = (byte) 0+(byte) 1 -- aby=coby1 
+  //SEG26 [14] phi (byte) main::bits_gen#9 = (byte) 0+(byte) 1 [phi:main::@7->main::@2#0] -- aby=coby1 
     lda #0+1
     jmp b2
-  //SEG27 [14] phi from main::@1 to main::@2
+  //SEG27 [14] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
   b2_from_b1:
-  //SEG28 [14] phi (byte) main::bits_gen#9 = (byte) 0 -- aby=coby1 
+  //SEG28 [14] phi (byte) main::bits_gen#9 = (byte) 0 [phi:main::@1->main::@2#0] -- aby=coby1 
     lda #0
   //SEG29 main::@2
   b2:
@@ -4245,10 +4245,10 @@ main: {
   b8:
   //SEG41 [25] (byte) main::bits_gen#4 ← (byte) main::bits_gen#1 + (byte) 1 [ main::chargen#2 main::charset4#10 main::chargen1#0 main::bits_gen#4 ] -- zpby1=zpby1_plus_1 
     inc bits_gen
-  //SEG42 [26] phi from main::@2 main::@8 to main::@3
+  //SEG42 [26] phi from main::@2 main::@8 to main::@3 [phi:main::@2/main::@8->main::@3]
   b3_from_b2:
   b3_from_b8:
-  //SEG43 [26] phi (byte) main::bits_gen#11 = (byte) main::bits_gen#1 -- register_copy 
+  //SEG43 [26] phi (byte) main::bits_gen#11 = (byte) main::bits_gen#1 [phi:main::@2/main::@8->main::@3#0] -- register_copy 
   //SEG44 main::@3
   b3:
   //SEG45 [27] (byte) main::bits_gen#14 ← (byte) main::bits_gen#11 << (byte) 1 [ main::chargen#2 main::charset4#10 main::chargen1#0 main::bits_gen#14 ] -- zpby1=zpby1_rol_1 
@@ -4281,10 +4281,10 @@ main: {
   b9:
   //SEG56 [37] (byte) main::bits_gen#6 ← (byte) main::bits_gen#14 + (byte) 1 [ main::chargen#2 main::charset4#10 main::chargen1#0 main::bits_gen#6 ] -- zpby1=zpby1_plus_1 
     inc bits_gen
-  //SEG57 [38] phi from main::@3 main::@9 to main::@4
+  //SEG57 [38] phi from main::@3 main::@9 to main::@4 [phi:main::@3/main::@9->main::@4]
   b4_from_b3:
   b4_from_b9:
-  //SEG58 [38] phi (byte) main::bits_gen#13 = (byte) main::bits_gen#14 -- register_copy 
+  //SEG58 [38] phi (byte) main::bits_gen#13 = (byte) main::bits_gen#14 [phi:main::@3/main::@9->main::@4#0] -- register_copy 
   //SEG59 main::@4
   b4:
   //SEG60 [39] (byte) main::bits_gen#16 ← (byte) main::bits_gen#13 << (byte) 1 [ main::chargen#2 main::charset4#10 main::chargen1#0 main::bits_gen#16 ] -- zpby1=zpby1_rol_1 
@@ -4316,10 +4316,10 @@ main: {
   b10:
   //SEG70 [48] (byte) main::bits_gen#8 ← (byte) main::bits_gen#16 + (byte) 1 [ main::chargen#2 main::charset4#10 main::bits_gen#8 ] -- zpby1=zpby1_plus_1 
     inc bits_gen
-  //SEG71 [49] phi from main::@10 main::@4 to main::@5
+  //SEG71 [49] phi from main::@10 main::@4 to main::@5 [phi:main::@10/main::@4->main::@5]
   b5_from_b10:
   b5_from_b4:
-  //SEG72 [49] phi (byte) main::bits_gen#15 = (byte) main::bits_gen#8 -- register_copy 
+  //SEG72 [49] phi (byte) main::bits_gen#15 = (byte) main::bits_gen#8 [phi:main::@10/main::@4->main::@5#0] -- register_copy 
   //SEG73 main::@5
   b5:
   //SEG74 [50] (byte) main::bits_gen#7 ← (byte) main::bits_gen#15 << (byte) 1 [ main::chargen#2 main::charset4#10 main::bits_gen#7 ] -- aby=zpby1_rol_1 
@@ -4355,14 +4355,14 @@ main: {
   //SEG80 [55] *((const byte*) PROCPORT#0) ← (byte) 55 [ ] -- _star_cowo1=coby2 
     lda #$37
     sta PROCPORT
-  //SEG81 [56] phi from main::@11 to main::@6
+  //SEG81 [56] phi from main::@11 to main::@6 [phi:main::@11->main::@6]
   b6_from_b11:
-  //SEG82 [56] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG82 [56] phi (byte) main::i#2 = (byte) 0 [phi:main::@11->main::@6#0] -- xby=coby1 
     ldx #0
     jmp b6
-  //SEG83 [56] phi from main::@6 to main::@6
+  //SEG83 [56] phi from main::@6 to main::@6 [phi:main::@6->main::@6]
   b6_from_b6:
-  //SEG84 [56] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG84 [56] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@6->main::@6#0] -- register_copy 
   //SEG85 main::@6
   b6:
   //SEG86 [57] *((const byte*) SCREEN#0 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 
@@ -4417,23 +4417,23 @@ main: {
   //SEG5 [1] *((const byte*) PROCPORT#0) ← (byte) 50 [ ] -- _star_cowo1=coby2 
     lda #$32
     sta PROCPORT
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte*) main::charset4#10 = (const byte*) CHARSET4#0 -- zpptrby1=cowo1 
+  //SEG7 [2] phi (byte*) main::charset4#10 = (const byte*) CHARSET4#0 [phi:main->main::@1#0] -- zpptrby1=cowo1 
     lda #<CHARSET4
     sta charset4
     lda #>CHARSET4
     sta charset4+1
-  //SEG8 [2] phi (byte*) main::chargen#2 = (const byte*) CHARGEN#0 -- zpptrby1=cowo1 
+  //SEG8 [2] phi (byte*) main::chargen#2 = (const byte*) CHARGEN#0 [phi:main->main::@1#1] -- zpptrby1=cowo1 
     lda #<CHARGEN
     sta chargen
     lda #>CHARGEN
     sta chargen+1
     jmp b1
-  //SEG9 [2] phi from main::@5 to main::@1
+  //SEG9 [2] phi from main::@5 to main::@1 [phi:main::@5->main::@1]
   b1_from_b5:
-  //SEG10 [2] phi (byte*) main::charset4#10 = (byte*) main::charset4#1 -- register_copy 
-  //SEG11 [2] phi (byte*) main::chargen#2 = (byte*) main::chargen#1 -- register_copy 
+  //SEG10 [2] phi (byte*) main::charset4#10 = (byte*) main::charset4#1 [phi:main::@5->main::@1#0] -- register_copy 
+  //SEG11 [2] phi (byte*) main::chargen#2 = (byte*) main::chargen#1 [phi:main::@5->main::@1#1] -- register_copy 
   //SEG12 main::@1
   b1:
   //SEG13 [3] (byte*) main::chargen1#0 ← (byte*) main::chargen#2 + (byte) 1 [ main::chargen#2 main::charset4#10 main::chargen1#0 ] -- zpptrby1=zpptrby2_plus_1 
@@ -4472,14 +4472,14 @@ main: {
     bcc b2_from_b1
   //SEG24 main::@7
   b7:
-  //SEG25 [14] phi from main::@7 to main::@2
+  //SEG25 [14] phi from main::@7 to main::@2 [phi:main::@7->main::@2]
   b2_from_b7:
-  //SEG26 [14] phi (byte) main::bits_gen#9 = (byte) 0+(byte) 1 -- aby=coby1 
+  //SEG26 [14] phi (byte) main::bits_gen#9 = (byte) 0+(byte) 1 [phi:main::@7->main::@2#0] -- aby=coby1 
     lda #0+1
     jmp b2
-  //SEG27 [14] phi from main::@1 to main::@2
+  //SEG27 [14] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
   b2_from_b1:
-  //SEG28 [14] phi (byte) main::bits_gen#9 = (byte) 0 -- aby=coby1 
+  //SEG28 [14] phi (byte) main::bits_gen#9 = (byte) 0 [phi:main::@1->main::@2#0] -- aby=coby1 
     lda #0
   //SEG29 main::@2
   b2:
@@ -4513,10 +4513,10 @@ main: {
   b8:
   //SEG41 [25] (byte) main::bits_gen#4 ← (byte) main::bits_gen#1 + (byte) 1 [ main::chargen#2 main::charset4#10 main::chargen1#0 main::bits_gen#4 ] -- zpby1=zpby1_plus_1 
     inc bits_gen
-  //SEG42 [26] phi from main::@2 main::@8 to main::@3
+  //SEG42 [26] phi from main::@2 main::@8 to main::@3 [phi:main::@2/main::@8->main::@3]
   b3_from_b2:
   b3_from_b8:
-  //SEG43 [26] phi (byte) main::bits_gen#11 = (byte) main::bits_gen#1 -- register_copy 
+  //SEG43 [26] phi (byte) main::bits_gen#11 = (byte) main::bits_gen#1 [phi:main::@2/main::@8->main::@3#0] -- register_copy 
   //SEG44 main::@3
   b3:
   //SEG45 [27] (byte) main::bits_gen#14 ← (byte) main::bits_gen#11 << (byte) 1 [ main::chargen#2 main::charset4#10 main::chargen1#0 main::bits_gen#14 ] -- zpby1=zpby1_rol_1 
@@ -4548,10 +4548,10 @@ main: {
   b9:
   //SEG56 [37] (byte) main::bits_gen#6 ← (byte) main::bits_gen#14 + (byte) 1 [ main::chargen#2 main::charset4#10 main::chargen1#0 main::bits_gen#6 ] -- zpby1=zpby1_plus_1 
     inc bits_gen
-  //SEG57 [38] phi from main::@3 main::@9 to main::@4
+  //SEG57 [38] phi from main::@3 main::@9 to main::@4 [phi:main::@3/main::@9->main::@4]
   b4_from_b3:
   b4_from_b9:
-  //SEG58 [38] phi (byte) main::bits_gen#13 = (byte) main::bits_gen#14 -- register_copy 
+  //SEG58 [38] phi (byte) main::bits_gen#13 = (byte) main::bits_gen#14 [phi:main::@3/main::@9->main::@4#0] -- register_copy 
   //SEG59 main::@4
   b4:
   //SEG60 [39] (byte) main::bits_gen#16 ← (byte) main::bits_gen#13 << (byte) 1 [ main::chargen#2 main::charset4#10 main::chargen1#0 main::bits_gen#16 ] -- zpby1=zpby1_rol_1 
@@ -4582,10 +4582,10 @@ main: {
   b10:
   //SEG70 [48] (byte) main::bits_gen#8 ← (byte) main::bits_gen#16 + (byte) 1 [ main::chargen#2 main::charset4#10 main::bits_gen#8 ] -- zpby1=zpby1_plus_1 
     inc bits_gen
-  //SEG71 [49] phi from main::@10 main::@4 to main::@5
+  //SEG71 [49] phi from main::@10 main::@4 to main::@5 [phi:main::@10/main::@4->main::@5]
   b5_from_b10:
   b5_from_b4:
-  //SEG72 [49] phi (byte) main::bits_gen#15 = (byte) main::bits_gen#8 -- register_copy 
+  //SEG72 [49] phi (byte) main::bits_gen#15 = (byte) main::bits_gen#8 [phi:main::@10/main::@4->main::@5#0] -- register_copy 
   //SEG73 main::@5
   b5:
   //SEG74 [50] (byte) main::bits_gen#7 ← (byte) main::bits_gen#15 << (byte) 1 [ main::chargen#2 main::charset4#10 main::bits_gen#7 ] -- aby=zpby1_rol_1 
@@ -4621,14 +4621,14 @@ main: {
   //SEG80 [55] *((const byte*) PROCPORT#0) ← (byte) 55 [ ] -- _star_cowo1=coby2 
     lda #$37
     sta PROCPORT
-  //SEG81 [56] phi from main::@11 to main::@6
+  //SEG81 [56] phi from main::@11 to main::@6 [phi:main::@11->main::@6]
   b6_from_b11:
-  //SEG82 [56] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG82 [56] phi (byte) main::i#2 = (byte) 0 [phi:main::@11->main::@6#0] -- xby=coby1 
     ldx #0
     jmp b6
-  //SEG83 [56] phi from main::@6 to main::@6
+  //SEG83 [56] phi from main::@6 to main::@6 [phi:main::@6->main::@6]
   b6_from_b6:
-  //SEG84 [56] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG84 [56] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@6->main::@6#0] -- register_copy 
   //SEG85 main::@6
   b6:
   //SEG86 [57] *((const byte*) SCREEN#0 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 
@@ -4694,22 +4694,22 @@ main: {
   //SEG5 [1] *((const byte*) PROCPORT#0) ← (byte) 50 [ ] -- _star_cowo1=coby2 
     lda #$32
     sta PROCPORT
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte*) main::charset4#10 = (const byte*) CHARSET4#0 -- zpptrby1=cowo1 
+  //SEG7 [2] phi (byte*) main::charset4#10 = (const byte*) CHARSET4#0 [phi:main->main::@1#0] -- zpptrby1=cowo1 
     lda #<CHARSET4
     sta charset4
     lda #>CHARSET4
     sta charset4+1
-  //SEG8 [2] phi (byte*) main::chargen#2 = (const byte*) CHARGEN#0 -- zpptrby1=cowo1 
+  //SEG8 [2] phi (byte*) main::chargen#2 = (const byte*) CHARGEN#0 [phi:main->main::@1#1] -- zpptrby1=cowo1 
     lda #<CHARGEN
     sta chargen
     lda #>CHARGEN
     sta chargen+1
     jmp b1
-  //SEG9 [2] phi from main::@5 to main::@1
-  //SEG10 [2] phi (byte*) main::charset4#10 = (byte*) main::charset4#1 -- register_copy 
-  //SEG11 [2] phi (byte*) main::chargen#2 = (byte*) main::chargen#1 -- register_copy 
+  //SEG9 [2] phi from main::@5 to main::@1 [phi:main::@5->main::@1]
+  //SEG10 [2] phi (byte*) main::charset4#10 = (byte*) main::charset4#1 [phi:main::@5->main::@1#0] -- register_copy 
+  //SEG11 [2] phi (byte*) main::chargen#2 = (byte*) main::chargen#1 [phi:main::@5->main::@1#1] -- register_copy 
   //SEG12 main::@1
   b1:
   //SEG13 [3] (byte*) main::chargen1#0 ← (byte*) main::chargen#2 + (byte) 1 [ main::chargen#2 main::charset4#10 main::chargen1#0 ] -- zpptrby1=zpptrby2_plus_1 
@@ -4748,13 +4748,13 @@ main: {
     bcc b2_from_b1
   //SEG24 main::@7
   b7:
-  //SEG25 [14] phi from main::@7 to main::@2
-  //SEG26 [14] phi (byte) main::bits_gen#9 = (byte) 0+(byte) 1 -- aby=coby1 
+  //SEG25 [14] phi from main::@7 to main::@2 [phi:main::@7->main::@2]
+  //SEG26 [14] phi (byte) main::bits_gen#9 = (byte) 0+(byte) 1 [phi:main::@7->main::@2#0] -- aby=coby1 
     lda #0+1
     jmp b2
-  //SEG27 [14] phi from main::@1 to main::@2
+  //SEG27 [14] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
   b2_from_b1:
-  //SEG28 [14] phi (byte) main::bits_gen#9 = (byte) 0 -- aby=coby1 
+  //SEG28 [14] phi (byte) main::bits_gen#9 = (byte) 0 [phi:main::@1->main::@2#0] -- aby=coby1 
     lda #0
   //SEG29 main::@2
   b2:
@@ -4788,8 +4788,8 @@ main: {
   b8:
   //SEG41 [25] (byte) main::bits_gen#4 ← (byte) main::bits_gen#1 + (byte) 1 [ main::chargen#2 main::charset4#10 main::chargen1#0 main::bits_gen#4 ] -- zpby1=zpby1_plus_1 
     inc bits_gen
-  //SEG42 [26] phi from main::@2 main::@8 to main::@3
-  //SEG43 [26] phi (byte) main::bits_gen#11 = (byte) main::bits_gen#1 -- register_copy 
+  //SEG42 [26] phi from main::@2 main::@8 to main::@3 [phi:main::@2/main::@8->main::@3]
+  //SEG43 [26] phi (byte) main::bits_gen#11 = (byte) main::bits_gen#1 [phi:main::@2/main::@8->main::@3#0] -- register_copy 
   //SEG44 main::@3
   b3:
   //SEG45 [27] (byte) main::bits_gen#14 ← (byte) main::bits_gen#11 << (byte) 1 [ main::chargen#2 main::charset4#10 main::chargen1#0 main::bits_gen#14 ] -- zpby1=zpby1_rol_1 
@@ -4821,8 +4821,8 @@ main: {
   b9:
   //SEG56 [37] (byte) main::bits_gen#6 ← (byte) main::bits_gen#14 + (byte) 1 [ main::chargen#2 main::charset4#10 main::chargen1#0 main::bits_gen#6 ] -- zpby1=zpby1_plus_1 
     inc bits_gen
-  //SEG57 [38] phi from main::@3 main::@9 to main::@4
-  //SEG58 [38] phi (byte) main::bits_gen#13 = (byte) main::bits_gen#14 -- register_copy 
+  //SEG57 [38] phi from main::@3 main::@9 to main::@4 [phi:main::@3/main::@9->main::@4]
+  //SEG58 [38] phi (byte) main::bits_gen#13 = (byte) main::bits_gen#14 [phi:main::@3/main::@9->main::@4#0] -- register_copy 
   //SEG59 main::@4
   b4:
   //SEG60 [39] (byte) main::bits_gen#16 ← (byte) main::bits_gen#13 << (byte) 1 [ main::chargen#2 main::charset4#10 main::chargen1#0 main::bits_gen#16 ] -- zpby1=zpby1_rol_1 
@@ -4853,8 +4853,8 @@ main: {
   b10:
   //SEG70 [48] (byte) main::bits_gen#8 ← (byte) main::bits_gen#16 + (byte) 1 [ main::chargen#2 main::charset4#10 main::bits_gen#8 ] -- zpby1=zpby1_plus_1 
     inc bits_gen
-  //SEG71 [49] phi from main::@10 main::@4 to main::@5
-  //SEG72 [49] phi (byte) main::bits_gen#15 = (byte) main::bits_gen#8 -- register_copy 
+  //SEG71 [49] phi from main::@10 main::@4 to main::@5 [phi:main::@10/main::@4->main::@5]
+  //SEG72 [49] phi (byte) main::bits_gen#15 = (byte) main::bits_gen#8 [phi:main::@10/main::@4->main::@5#0] -- register_copy 
   //SEG73 main::@5
   b5:
   //SEG74 [50] (byte) main::bits_gen#7 ← (byte) main::bits_gen#15 << (byte) 1 [ main::chargen#2 main::charset4#10 main::bits_gen#7 ] -- aby=zpby1_rol_1 
@@ -4890,13 +4890,13 @@ main: {
   //SEG80 [55] *((const byte*) PROCPORT#0) ← (byte) 55 [ ] -- _star_cowo1=coby2 
     lda #$37
     sta PROCPORT
-  //SEG81 [56] phi from main::@11 to main::@6
+  //SEG81 [56] phi from main::@11 to main::@6 [phi:main::@11->main::@6]
   b6_from_b11:
-  //SEG82 [56] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG82 [56] phi (byte) main::i#2 = (byte) 0 [phi:main::@11->main::@6#0] -- xby=coby1 
     ldx #0
     jmp b6
-  //SEG83 [56] phi from main::@6 to main::@6
-  //SEG84 [56] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG83 [56] phi from main::@6 to main::@6 [phi:main::@6->main::@6]
+  //SEG84 [56] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@6->main::@6#0] -- register_copy 
   //SEG85 main::@6
   b6:
   //SEG86 [57] *((const byte*) SCREEN#0 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 
@@ -4956,21 +4956,21 @@ main: {
   //SEG5 [1] *((const byte*) PROCPORT#0) ← (byte) 50 [ ] -- _star_cowo1=coby2 
     lda #$32
     sta PROCPORT
-  //SEG6 [2] phi from main to main::@1
-  //SEG7 [2] phi (byte*) main::charset4#10 = (const byte*) CHARSET4#0 -- zpptrby1=cowo1 
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG7 [2] phi (byte*) main::charset4#10 = (const byte*) CHARSET4#0 [phi:main->main::@1#0] -- zpptrby1=cowo1 
     lda #<CHARSET4
     sta charset4
     lda #>CHARSET4
     sta charset4+1
-  //SEG8 [2] phi (byte*) main::chargen#2 = (const byte*) CHARGEN#0 -- zpptrby1=cowo1 
+  //SEG8 [2] phi (byte*) main::chargen#2 = (const byte*) CHARGEN#0 [phi:main->main::@1#1] -- zpptrby1=cowo1 
     lda #<CHARGEN
     sta chargen
     lda #>CHARGEN
     sta chargen+1
     jmp b1
-  //SEG9 [2] phi from main::@5 to main::@1
-  //SEG10 [2] phi (byte*) main::charset4#10 = (byte*) main::charset4#1 -- register_copy 
-  //SEG11 [2] phi (byte*) main::chargen#2 = (byte*) main::chargen#1 -- register_copy 
+  //SEG9 [2] phi from main::@5 to main::@1 [phi:main::@5->main::@1]
+  //SEG10 [2] phi (byte*) main::charset4#10 = (byte*) main::charset4#1 [phi:main::@5->main::@1#0] -- register_copy 
+  //SEG11 [2] phi (byte*) main::chargen#2 = (byte*) main::chargen#1 [phi:main::@5->main::@1#1] -- register_copy 
   //SEG12 main::@1
   b1:
   //SEG13 [3] (byte*) main::chargen1#0 ← (byte*) main::chargen#2 + (byte) 1 [ main::chargen#2 main::charset4#10 main::chargen1#0 ] -- zpptrby1=zpptrby2_plus_1 
@@ -5008,13 +5008,13 @@ main: {
     cmp #2
     bcc b2_from_b1
   //SEG24 main::@7
-  //SEG25 [14] phi from main::@7 to main::@2
-  //SEG26 [14] phi (byte) main::bits_gen#9 = (byte) 0+(byte) 1 -- aby=coby1 
+  //SEG25 [14] phi from main::@7 to main::@2 [phi:main::@7->main::@2]
+  //SEG26 [14] phi (byte) main::bits_gen#9 = (byte) 0+(byte) 1 [phi:main::@7->main::@2#0] -- aby=coby1 
     lda #0+1
     jmp b2
-  //SEG27 [14] phi from main::@1 to main::@2
+  //SEG27 [14] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
   b2_from_b1:
-  //SEG28 [14] phi (byte) main::bits_gen#9 = (byte) 0 -- aby=coby1 
+  //SEG28 [14] phi (byte) main::bits_gen#9 = (byte) 0 [phi:main::@1->main::@2#0] -- aby=coby1 
     lda #0
   //SEG29 main::@2
   b2:
@@ -5047,8 +5047,8 @@ main: {
   //SEG40 main::@8
   //SEG41 [25] (byte) main::bits_gen#4 ← (byte) main::bits_gen#1 + (byte) 1 [ main::chargen#2 main::charset4#10 main::chargen1#0 main::bits_gen#4 ] -- zpby1=zpby1_plus_1 
     inc bits_gen
-  //SEG42 [26] phi from main::@2 main::@8 to main::@3
-  //SEG43 [26] phi (byte) main::bits_gen#11 = (byte) main::bits_gen#1 -- register_copy 
+  //SEG42 [26] phi from main::@2 main::@8 to main::@3 [phi:main::@2/main::@8->main::@3]
+  //SEG43 [26] phi (byte) main::bits_gen#11 = (byte) main::bits_gen#1 [phi:main::@2/main::@8->main::@3#0] -- register_copy 
   //SEG44 main::@3
   b3:
   //SEG45 [27] (byte) main::bits_gen#14 ← (byte) main::bits_gen#11 << (byte) 1 [ main::chargen#2 main::charset4#10 main::chargen1#0 main::bits_gen#14 ] -- zpby1=zpby1_rol_1 
@@ -5079,8 +5079,8 @@ main: {
   //SEG55 main::@9
   //SEG56 [37] (byte) main::bits_gen#6 ← (byte) main::bits_gen#14 + (byte) 1 [ main::chargen#2 main::charset4#10 main::chargen1#0 main::bits_gen#6 ] -- zpby1=zpby1_plus_1 
     inc bits_gen
-  //SEG57 [38] phi from main::@3 main::@9 to main::@4
-  //SEG58 [38] phi (byte) main::bits_gen#13 = (byte) main::bits_gen#14 -- register_copy 
+  //SEG57 [38] phi from main::@3 main::@9 to main::@4 [phi:main::@3/main::@9->main::@4]
+  //SEG58 [38] phi (byte) main::bits_gen#13 = (byte) main::bits_gen#14 [phi:main::@3/main::@9->main::@4#0] -- register_copy 
   //SEG59 main::@4
   b4:
   //SEG60 [39] (byte) main::bits_gen#16 ← (byte) main::bits_gen#13 << (byte) 1 [ main::chargen#2 main::charset4#10 main::chargen1#0 main::bits_gen#16 ] -- zpby1=zpby1_rol_1 
@@ -5110,8 +5110,8 @@ main: {
   //SEG69 main::@10
   //SEG70 [48] (byte) main::bits_gen#8 ← (byte) main::bits_gen#16 + (byte) 1 [ main::chargen#2 main::charset4#10 main::bits_gen#8 ] -- zpby1=zpby1_plus_1 
     inc bits_gen
-  //SEG71 [49] phi from main::@10 main::@4 to main::@5
-  //SEG72 [49] phi (byte) main::bits_gen#15 = (byte) main::bits_gen#8 -- register_copy 
+  //SEG71 [49] phi from main::@10 main::@4 to main::@5 [phi:main::@10/main::@4->main::@5]
+  //SEG72 [49] phi (byte) main::bits_gen#15 = (byte) main::bits_gen#8 [phi:main::@10/main::@4->main::@5#0] -- register_copy 
   //SEG73 main::@5
   b5:
   //SEG74 [50] (byte) main::bits_gen#7 ← (byte) main::bits_gen#15 << (byte) 1 [ main::chargen#2 main::charset4#10 main::bits_gen#7 ] -- aby=zpby1_rol_1 
@@ -5146,12 +5146,12 @@ main: {
   //SEG80 [55] *((const byte*) PROCPORT#0) ← (byte) 55 [ ] -- _star_cowo1=coby2 
     lda #$37
     sta PROCPORT
-  //SEG81 [56] phi from main::@11 to main::@6
-  //SEG82 [56] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG81 [56] phi from main::@11 to main::@6 [phi:main::@11->main::@6]
+  //SEG82 [56] phi (byte) main::i#2 = (byte) 0 [phi:main::@11->main::@6#0] -- xby=coby1 
     ldx #0
     jmp b6
-  //SEG83 [56] phi from main::@6 to main::@6
-  //SEG84 [56] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG83 [56] phi from main::@6 to main::@6 [phi:main::@6->main::@6]
+  //SEG84 [56] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@6->main::@6#0] -- register_copy 
   //SEG85 main::@6
   b6:
   //SEG86 [57] *((const byte*) SCREEN#0 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 
@@ -5200,20 +5200,20 @@ main: {
   //SEG5 [1] *((const byte*) PROCPORT#0) ← (byte) 50 [ ] -- _star_cowo1=coby2 
     lda #$32
     sta PROCPORT
-  //SEG6 [2] phi from main to main::@1
-  //SEG7 [2] phi (byte*) main::charset4#10 = (const byte*) CHARSET4#0 -- zpptrby1=cowo1 
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG7 [2] phi (byte*) main::charset4#10 = (const byte*) CHARSET4#0 [phi:main->main::@1#0] -- zpptrby1=cowo1 
     lda #<CHARSET4
     sta charset4
     lda #>CHARSET4
     sta charset4+1
-  //SEG8 [2] phi (byte*) main::chargen#2 = (const byte*) CHARGEN#0 -- zpptrby1=cowo1 
+  //SEG8 [2] phi (byte*) main::chargen#2 = (const byte*) CHARGEN#0 [phi:main->main::@1#1] -- zpptrby1=cowo1 
     lda #<CHARGEN
     sta chargen
     lda #>CHARGEN
     sta chargen+1
-  //SEG9 [2] phi from main::@5 to main::@1
-  //SEG10 [2] phi (byte*) main::charset4#10 = (byte*) main::charset4#1 -- register_copy 
-  //SEG11 [2] phi (byte*) main::chargen#2 = (byte*) main::chargen#1 -- register_copy 
+  //SEG9 [2] phi from main::@5 to main::@1 [phi:main::@5->main::@1]
+  //SEG10 [2] phi (byte*) main::charset4#10 = (byte*) main::charset4#1 [phi:main::@5->main::@1#0] -- register_copy 
+  //SEG11 [2] phi (byte*) main::chargen#2 = (byte*) main::chargen#1 [phi:main::@5->main::@1#1] -- register_copy 
   //SEG12 main::@1
   b1:
   //SEG13 [3] (byte*) main::chargen1#0 ← (byte*) main::chargen#2 + (byte) 1 [ main::chargen#2 main::charset4#10 main::chargen1#0 ] -- zpptrby1=zpptrby2_plus_1 
@@ -5251,13 +5251,13 @@ main: {
     cmp #2
     bcc b2_from_b1
   //SEG24 main::@7
-  //SEG25 [14] phi from main::@7 to main::@2
-  //SEG26 [14] phi (byte) main::bits_gen#9 = (byte) 0+(byte) 1 -- aby=coby1 
+  //SEG25 [14] phi from main::@7 to main::@2 [phi:main::@7->main::@2]
+  //SEG26 [14] phi (byte) main::bits_gen#9 = (byte) 0+(byte) 1 [phi:main::@7->main::@2#0] -- aby=coby1 
     lda #0+1
     jmp b2
-  //SEG27 [14] phi from main::@1 to main::@2
+  //SEG27 [14] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
   b2_from_b1:
-  //SEG28 [14] phi (byte) main::bits_gen#9 = (byte) 0 -- aby=coby1 
+  //SEG28 [14] phi (byte) main::bits_gen#9 = (byte) 0 [phi:main::@1->main::@2#0] -- aby=coby1 
     lda #0
   //SEG29 main::@2
   b2:
@@ -5290,8 +5290,8 @@ main: {
   //SEG40 main::@8
   //SEG41 [25] (byte) main::bits_gen#4 ← (byte) main::bits_gen#1 + (byte) 1 [ main::chargen#2 main::charset4#10 main::chargen1#0 main::bits_gen#4 ] -- zpby1=zpby1_plus_1 
     inc bits_gen
-  //SEG42 [26] phi from main::@2 main::@8 to main::@3
-  //SEG43 [26] phi (byte) main::bits_gen#11 = (byte) main::bits_gen#1 -- register_copy 
+  //SEG42 [26] phi from main::@2 main::@8 to main::@3 [phi:main::@2/main::@8->main::@3]
+  //SEG43 [26] phi (byte) main::bits_gen#11 = (byte) main::bits_gen#1 [phi:main::@2/main::@8->main::@3#0] -- register_copy 
   //SEG44 main::@3
   b3:
   //SEG45 [27] (byte) main::bits_gen#14 ← (byte) main::bits_gen#11 << (byte) 1 [ main::chargen#2 main::charset4#10 main::chargen1#0 main::bits_gen#14 ] -- zpby1=zpby1_rol_1 
@@ -5322,8 +5322,8 @@ main: {
   //SEG55 main::@9
   //SEG56 [37] (byte) main::bits_gen#6 ← (byte) main::bits_gen#14 + (byte) 1 [ main::chargen#2 main::charset4#10 main::chargen1#0 main::bits_gen#6 ] -- zpby1=zpby1_plus_1 
     inc bits_gen
-  //SEG57 [38] phi from main::@3 main::@9 to main::@4
-  //SEG58 [38] phi (byte) main::bits_gen#13 = (byte) main::bits_gen#14 -- register_copy 
+  //SEG57 [38] phi from main::@3 main::@9 to main::@4 [phi:main::@3/main::@9->main::@4]
+  //SEG58 [38] phi (byte) main::bits_gen#13 = (byte) main::bits_gen#14 [phi:main::@3/main::@9->main::@4#0] -- register_copy 
   //SEG59 main::@4
   b4:
   //SEG60 [39] (byte) main::bits_gen#16 ← (byte) main::bits_gen#13 << (byte) 1 [ main::chargen#2 main::charset4#10 main::chargen1#0 main::bits_gen#16 ] -- zpby1=zpby1_rol_1 
@@ -5353,8 +5353,8 @@ main: {
   //SEG69 main::@10
   //SEG70 [48] (byte) main::bits_gen#8 ← (byte) main::bits_gen#16 + (byte) 1 [ main::chargen#2 main::charset4#10 main::bits_gen#8 ] -- zpby1=zpby1_plus_1 
     inc bits_gen
-  //SEG71 [49] phi from main::@10 main::@4 to main::@5
-  //SEG72 [49] phi (byte) main::bits_gen#15 = (byte) main::bits_gen#8 -- register_copy 
+  //SEG71 [49] phi from main::@10 main::@4 to main::@5 [phi:main::@10/main::@4->main::@5]
+  //SEG72 [49] phi (byte) main::bits_gen#15 = (byte) main::bits_gen#8 [phi:main::@10/main::@4->main::@5#0] -- register_copy 
   //SEG73 main::@5
   b5:
   //SEG74 [50] (byte) main::bits_gen#7 ← (byte) main::bits_gen#15 << (byte) 1 [ main::chargen#2 main::charset4#10 main::bits_gen#7 ] -- aby=zpby1_rol_1 
@@ -5389,11 +5389,11 @@ main: {
   //SEG80 [55] *((const byte*) PROCPORT#0) ← (byte) 55 [ ] -- _star_cowo1=coby2 
     lda #$37
     sta PROCPORT
-  //SEG81 [56] phi from main::@11 to main::@6
-  //SEG82 [56] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG81 [56] phi from main::@11 to main::@6 [phi:main::@11->main::@6]
+  //SEG82 [56] phi (byte) main::i#2 = (byte) 0 [phi:main::@11->main::@6#0] -- xby=coby1 
     ldx #0
-  //SEG83 [56] phi from main::@6 to main::@6
-  //SEG84 [56] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG83 [56] phi from main::@6 to main::@6 [phi:main::@6->main::@6]
+  //SEG84 [56] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@6->main::@6#0] -- register_copy 
   //SEG85 main::@6
   b6:
   //SEG86 [57] *((const byte*) SCREEN#0 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 
@@ -5564,20 +5564,20 @@ main: {
   //SEG5 [1] *((const byte*) PROCPORT#0) ← (byte) 50 [ ] -- _star_cowo1=coby2 
     lda #$32
     sta PROCPORT
-  //SEG6 [2] phi from main to main::@1
-  //SEG7 [2] phi (byte*) main::charset4#10 = (const byte*) CHARSET4#0 -- zpptrby1=cowo1 
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG7 [2] phi (byte*) main::charset4#10 = (const byte*) CHARSET4#0 [phi:main->main::@1#0] -- zpptrby1=cowo1 
     lda #<CHARSET4
     sta charset4
     lda #>CHARSET4
     sta charset4+1
-  //SEG8 [2] phi (byte*) main::chargen#2 = (const byte*) CHARGEN#0 -- zpptrby1=cowo1 
+  //SEG8 [2] phi (byte*) main::chargen#2 = (const byte*) CHARGEN#0 [phi:main->main::@1#1] -- zpptrby1=cowo1 
     lda #<CHARGEN
     sta chargen
     lda #>CHARGEN
     sta chargen+1
-  //SEG9 [2] phi from main::@5 to main::@1
-  //SEG10 [2] phi (byte*) main::charset4#10 = (byte*) main::charset4#1 -- register_copy 
-  //SEG11 [2] phi (byte*) main::chargen#2 = (byte*) main::chargen#1 -- register_copy 
+  //SEG9 [2] phi from main::@5 to main::@1 [phi:main::@5->main::@1]
+  //SEG10 [2] phi (byte*) main::charset4#10 = (byte*) main::charset4#1 [phi:main::@5->main::@1#0] -- register_copy 
+  //SEG11 [2] phi (byte*) main::chargen#2 = (byte*) main::chargen#1 [phi:main::@5->main::@1#1] -- register_copy 
   //SEG12 main::@1
   b1:
   //SEG13 [3] (byte*) main::chargen1#0 ← (byte*) main::chargen#2 + (byte) 1 [ main::chargen#2 main::charset4#10 main::chargen1#0 ] -- zpptrby1=zpptrby2_plus_1 
@@ -5615,13 +5615,13 @@ main: {
     cmp #2
     bcc b2_from_b1
   //SEG24 main::@7
-  //SEG25 [14] phi from main::@7 to main::@2
-  //SEG26 [14] phi (byte) main::bits_gen#9 = (byte) 0+(byte) 1 -- aby=coby1 
+  //SEG25 [14] phi from main::@7 to main::@2 [phi:main::@7->main::@2]
+  //SEG26 [14] phi (byte) main::bits_gen#9 = (byte) 0+(byte) 1 [phi:main::@7->main::@2#0] -- aby=coby1 
     lda #0+1
     jmp b2
-  //SEG27 [14] phi from main::@1 to main::@2
+  //SEG27 [14] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
   b2_from_b1:
-  //SEG28 [14] phi (byte) main::bits_gen#9 = (byte) 0 -- aby=coby1 
+  //SEG28 [14] phi (byte) main::bits_gen#9 = (byte) 0 [phi:main::@1->main::@2#0] -- aby=coby1 
     lda #0
   //SEG29 main::@2
   b2:
@@ -5654,8 +5654,8 @@ main: {
   //SEG40 main::@8
   //SEG41 [25] (byte) main::bits_gen#4 ← (byte) main::bits_gen#1 + (byte) 1 [ main::chargen#2 main::charset4#10 main::chargen1#0 main::bits_gen#4 ] -- zpby1=zpby1_plus_1 
     inc bits_gen
-  //SEG42 [26] phi from main::@2 main::@8 to main::@3
-  //SEG43 [26] phi (byte) main::bits_gen#11 = (byte) main::bits_gen#1 -- register_copy 
+  //SEG42 [26] phi from main::@2 main::@8 to main::@3 [phi:main::@2/main::@8->main::@3]
+  //SEG43 [26] phi (byte) main::bits_gen#11 = (byte) main::bits_gen#1 [phi:main::@2/main::@8->main::@3#0] -- register_copy 
   //SEG44 main::@3
   b3:
   //SEG45 [27] (byte) main::bits_gen#14 ← (byte) main::bits_gen#11 << (byte) 1 [ main::chargen#2 main::charset4#10 main::chargen1#0 main::bits_gen#14 ] -- zpby1=zpby1_rol_1 
@@ -5686,8 +5686,8 @@ main: {
   //SEG55 main::@9
   //SEG56 [37] (byte) main::bits_gen#6 ← (byte) main::bits_gen#14 + (byte) 1 [ main::chargen#2 main::charset4#10 main::chargen1#0 main::bits_gen#6 ] -- zpby1=zpby1_plus_1 
     inc bits_gen
-  //SEG57 [38] phi from main::@3 main::@9 to main::@4
-  //SEG58 [38] phi (byte) main::bits_gen#13 = (byte) main::bits_gen#14 -- register_copy 
+  //SEG57 [38] phi from main::@3 main::@9 to main::@4 [phi:main::@3/main::@9->main::@4]
+  //SEG58 [38] phi (byte) main::bits_gen#13 = (byte) main::bits_gen#14 [phi:main::@3/main::@9->main::@4#0] -- register_copy 
   //SEG59 main::@4
   b4:
   //SEG60 [39] (byte) main::bits_gen#16 ← (byte) main::bits_gen#13 << (byte) 1 [ main::chargen#2 main::charset4#10 main::chargen1#0 main::bits_gen#16 ] -- zpby1=zpby1_rol_1 
@@ -5717,8 +5717,8 @@ main: {
   //SEG69 main::@10
   //SEG70 [48] (byte) main::bits_gen#8 ← (byte) main::bits_gen#16 + (byte) 1 [ main::chargen#2 main::charset4#10 main::bits_gen#8 ] -- zpby1=zpby1_plus_1 
     inc bits_gen
-  //SEG71 [49] phi from main::@10 main::@4 to main::@5
-  //SEG72 [49] phi (byte) main::bits_gen#15 = (byte) main::bits_gen#8 -- register_copy 
+  //SEG71 [49] phi from main::@10 main::@4 to main::@5 [phi:main::@10/main::@4->main::@5]
+  //SEG72 [49] phi (byte) main::bits_gen#15 = (byte) main::bits_gen#8 [phi:main::@10/main::@4->main::@5#0] -- register_copy 
   //SEG73 main::@5
   b5:
   //SEG74 [50] (byte) main::bits_gen#7 ← (byte) main::bits_gen#15 << (byte) 1 [ main::chargen#2 main::charset4#10 main::bits_gen#7 ] -- aby=zpby1_rol_1 
@@ -5753,11 +5753,11 @@ main: {
   //SEG80 [55] *((const byte*) PROCPORT#0) ← (byte) 55 [ ] -- _star_cowo1=coby2 
     lda #$37
     sta PROCPORT
-  //SEG81 [56] phi from main::@11 to main::@6
-  //SEG82 [56] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG81 [56] phi from main::@11 to main::@6 [phi:main::@11->main::@6]
+  //SEG82 [56] phi (byte) main::i#2 = (byte) 0 [phi:main::@11->main::@6#0] -- xby=coby1 
     ldx #0
-  //SEG83 [56] phi from main::@6 to main::@6
-  //SEG84 [56] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG83 [56] phi from main::@6 to main::@6 [phi:main::@6->main::@6]
+  //SEG84 [56] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@6->main::@6#0] -- register_copy 
   //SEG85 main::@6
   b6:
   //SEG86 [57] *((const byte*) SCREEN#0 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 

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

@@ -636,7 +636,7 @@ INITIAL ASM
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
 main_from_bbegin:
   jsr main
   jmp bend
@@ -645,15 +645,15 @@ bend:
 //SEG5 main
 main: {
     .label i = 2
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 -- zpby1=coby1 
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- zpby1=coby1 
     lda #0
     sta i
     jmp b1
-  //SEG8 [2] phi from main::@2 to main::@1
+  //SEG8 [2] phi from main::@2 to main::@1 [phi:main::@2->main::@1]
   b1_from_b2:
-  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@2->main::@1#0] -- register_copy 
     jmp b1
   //SEG10 main::@1
   b1:
@@ -704,21 +704,21 @@ ASSEMBLER
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
 main_from_bbegin:
   jsr main
 //SEG4 @end
 bend:
 //SEG5 main
 main: {
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- xby=coby1 
     ldx #0
     jmp b1
-  //SEG8 [2] phi from main::@2 to main::@1
+  //SEG8 [2] phi from main::@2 to main::@1 [phi:main::@2->main::@1]
   b1_from_b2:
-  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@2->main::@1#0] -- register_copy 
   //SEG10 main::@1
   b1:
   //SEG11 [3] if((byte) main::i#2>=(byte) 50) goto main::@2 [ main::i#2 ] -- xby_ge_coby1_then_la1 
@@ -751,19 +751,19 @@ ASSEMBLER
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 bend:
 //SEG5 main
 main: {
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- xby=coby1 
     ldx #0
     jmp b1
-  //SEG8 [2] phi from main::@2 to main::@1
-  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG8 [2] phi from main::@2 to main::@1 [phi:main::@2->main::@1]
+  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@2->main::@1#0] -- register_copy 
   //SEG10 main::@1
   b1:
   //SEG11 [3] if((byte) main::i#2>=(byte) 50) goto main::@2 [ main::i#2 ] -- xby_ge_coby1_then_la1 
@@ -797,17 +797,17 @@ ASSEMBLER
   .const SCREEN = $400
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
 main: {
-  //SEG6 [2] phi from main to main::@1
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- xby=coby1 
     ldx #0
     jmp b1
-  //SEG8 [2] phi from main::@2 to main::@1
-  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG8 [2] phi from main::@2 to main::@1 [phi:main::@2->main::@1]
+  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@2->main::@1#0] -- register_copy 
   //SEG10 main::@1
   b1:
   //SEG11 [3] if((byte) main::i#2>=(byte) 50) goto main::@2 [ main::i#2 ] -- xby_ge_coby1_then_la1 
@@ -835,16 +835,16 @@ ASSEMBLER
   .const SCREEN = $400
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
 main: {
-  //SEG6 [2] phi from main to main::@1
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- xby=coby1 
     ldx #0
-  //SEG8 [2] phi from main::@2 to main::@1
-  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG8 [2] phi from main::@2 to main::@1 [phi:main::@2->main::@1]
+  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@2->main::@1#0] -- register_copy 
   //SEG10 main::@1
   b1:
   //SEG11 [3] if((byte) main::i#2>=(byte) 50) goto main::@2 [ main::i#2 ] -- xby_ge_coby1_then_la1 
@@ -886,16 +886,16 @@ FINAL CODE
   .const SCREEN = $400
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
 main: {
-  //SEG6 [2] phi from main to main::@1
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- xby=coby1 
     ldx #0
-  //SEG8 [2] phi from main::@2 to main::@1
-  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG8 [2] phi from main::@2 to main::@1 [phi:main::@2->main::@1]
+  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@2->main::@1#0] -- register_copy 
   //SEG10 main::@1
   b1:
   //SEG11 [3] if((byte) main::i#2>=(byte) 50) goto main::@2 [ main::i#2 ] -- xby_ge_coby1_then_la1 

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

@@ -829,7 +829,7 @@ INITIAL ASM
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
 main_from_bbegin:
   jsr main
   jmp bend
@@ -840,19 +840,19 @@ main: {
     .label _0 = 4
     .label j = 2
     .label i = 3
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 -- zpby1=coby1 
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- zpby1=coby1 
     lda #0
     sta i
-  //SEG8 [2] phi (byte) main::j#3 = (byte) 0 -- zpby1=coby1 
+  //SEG8 [2] phi (byte) main::j#3 = (byte) 0 [phi:main->main::@1#1] -- zpby1=coby1 
     lda #0
     sta j
     jmp b1
-  //SEG9 [2] phi from main::@2 to main::@1
+  //SEG9 [2] phi from main::@2 to main::@1 [phi:main::@2->main::@1]
   b1_from_b2:
-  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
-  //SEG11 [2] phi (byte) main::j#3 = (byte) main::j#4 -- register_copy 
+  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@2->main::@1#0] -- register_copy 
+  //SEG11 [2] phi (byte) main::j#3 = (byte) main::j#4 [phi:main::@2->main::@1#1] -- register_copy 
     jmp b1
   //SEG12 main::@1
   b1:
@@ -870,9 +870,9 @@ main: {
     lda j
     cmp #8
     bne b6
-  //SEG17 [7] phi from main::@1 to main::@2
+  //SEG17 [7] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
   b2_from_b1:
-  //SEG18 [7] phi (byte) main::j#4 = (byte) 0 -- zpby1=coby1 
+  //SEG18 [7] phi (byte) main::j#4 = (byte) 0 [phi:main::@1->main::@2#0] -- zpby1=coby1 
     lda #0
     sta j
     jmp b2
@@ -891,9 +891,9 @@ main: {
     rts
   //SEG24 main::@6
   b6:
-  //SEG25 [7] phi from main::@6 to main::@2
+  //SEG25 [7] phi from main::@6 to main::@2 [phi:main::@6->main::@2]
   b2_from_b6:
-  //SEG26 [7] phi (byte) main::j#4 = (byte) main::j#1 -- register_copy 
+  //SEG26 [7] phi (byte) main::j#4 = (byte) main::j#1 [phi:main::@6->main::@2#0] -- register_copy 
     jmp b2
 }
 
@@ -920,24 +920,24 @@ ASSEMBLER
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
 main_from_bbegin:
   jsr main
 //SEG4 @end
 bend:
 //SEG5 main
 main: {
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- xby=coby1 
     ldx #0
-  //SEG8 [2] phi (byte) main::j#3 = (byte) 0 -- yby=coby1 
+  //SEG8 [2] phi (byte) main::j#3 = (byte) 0 [phi:main->main::@1#1] -- yby=coby1 
     ldy #0
     jmp b1
-  //SEG9 [2] phi from main::@2 to main::@1
+  //SEG9 [2] phi from main::@2 to main::@1 [phi:main::@2->main::@1]
   b1_from_b2:
-  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
-  //SEG11 [2] phi (byte) main::j#3 = (byte) main::j#4 -- register_copy 
+  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@2->main::@1#0] -- register_copy 
+  //SEG11 [2] phi (byte) main::j#3 = (byte) main::j#4 [phi:main::@2->main::@1#1] -- register_copy 
   //SEG12 main::@1
   b1:
   //SEG13 [3] (byte~) main::$0 ← (const byte[]) TXT#0 *idx (byte) main::j#3 [ main::j#3 main::i#2 main::$0 ] -- aby=cowo1_staridx_yby 
@@ -949,9 +949,9 @@ main: {
   //SEG16 [6] if((byte) main::j#1!=(byte) 8) goto main::@6 [ main::i#2 ] -- yby_neq_coby1_then_la1 
     cpy #8
     bne b6
-  //SEG17 [7] phi from main::@1 to main::@2
+  //SEG17 [7] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
   b2_from_b1:
-  //SEG18 [7] phi (byte) main::j#4 = (byte) 0 -- yby=coby1 
+  //SEG18 [7] phi (byte) main::j#4 = (byte) 0 [phi:main::@1->main::@2#0] -- yby=coby1 
     ldy #0
   //SEG19 main::@2
   b2:
@@ -966,9 +966,9 @@ main: {
     rts
   //SEG24 main::@6
   b6:
-  //SEG25 [7] phi from main::@6 to main::@2
+  //SEG25 [7] phi from main::@6 to main::@2 [phi:main::@6->main::@2]
   b2_from_b6:
-  //SEG26 [7] phi (byte) main::j#4 = (byte) main::j#1 -- register_copy 
+  //SEG26 [7] phi (byte) main::j#4 = (byte) main::j#1 [phi:main::@6->main::@2#0] -- register_copy 
     jmp b2
 }
 
@@ -984,22 +984,22 @@ ASSEMBLER
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 bend:
 //SEG5 main
 main: {
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- xby=coby1 
     ldx #0
-  //SEG8 [2] phi (byte) main::j#3 = (byte) 0 -- yby=coby1 
+  //SEG8 [2] phi (byte) main::j#3 = (byte) 0 [phi:main->main::@1#1] -- yby=coby1 
     ldy #0
     jmp b1
-  //SEG9 [2] phi from main::@2 to main::@1
-  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
-  //SEG11 [2] phi (byte) main::j#3 = (byte) main::j#4 -- register_copy 
+  //SEG9 [2] phi from main::@2 to main::@1 [phi:main::@2->main::@1]
+  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@2->main::@1#0] -- register_copy 
+  //SEG11 [2] phi (byte) main::j#3 = (byte) main::j#4 [phi:main::@2->main::@1#1] -- register_copy 
   //SEG12 main::@1
   b1:
   //SEG13 [3] (byte~) main::$0 ← (const byte[]) TXT#0 *idx (byte) main::j#3 [ main::j#3 main::i#2 main::$0 ] -- aby=cowo1_staridx_yby 
@@ -1011,9 +1011,9 @@ main: {
   //SEG16 [6] if((byte) main::j#1!=(byte) 8) goto main::@6 [ main::i#2 ] -- yby_neq_coby1_then_la1 
     cpy #8
     bne b6
-  //SEG17 [7] phi from main::@1 to main::@2
+  //SEG17 [7] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
   b2_from_b1:
-  //SEG18 [7] phi (byte) main::j#4 = (byte) 0 -- yby=coby1 
+  //SEG18 [7] phi (byte) main::j#4 = (byte) 0 [phi:main::@1->main::@2#0] -- yby=coby1 
     ldy #0
   //SEG19 main::@2
   b2:
@@ -1028,8 +1028,8 @@ main: {
     rts
   //SEG24 main::@6
   b6:
-  //SEG25 [7] phi from main::@6 to main::@2
-  //SEG26 [7] phi (byte) main::j#4 = (byte) main::j#1 -- register_copy 
+  //SEG25 [7] phi from main::@6 to main::@2 [phi:main::@6->main::@2]
+  //SEG26 [7] phi (byte) main::j#4 = (byte) main::j#1 [phi:main::@6->main::@2#0] -- register_copy 
     jmp b2
 }
 
@@ -1045,20 +1045,20 @@ ASSEMBLER
   TXT: .byte 3, 1, $d, 5, $c, $f, $14, $20
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
 main: {
-  //SEG6 [2] phi from main to main::@1
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- xby=coby1 
     ldx #0
-  //SEG8 [2] phi (byte) main::j#3 = (byte) 0 -- yby=coby1 
+  //SEG8 [2] phi (byte) main::j#3 = (byte) 0 [phi:main->main::@1#1] -- yby=coby1 
     ldy #0
     jmp b1
-  //SEG9 [2] phi from main::@2 to main::@1
-  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
-  //SEG11 [2] phi (byte) main::j#3 = (byte) main::j#4 -- register_copy 
+  //SEG9 [2] phi from main::@2 to main::@1 [phi:main::@2->main::@1]
+  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@2->main::@1#0] -- register_copy 
+  //SEG11 [2] phi (byte) main::j#3 = (byte) main::j#4 [phi:main::@2->main::@1#1] -- register_copy 
   //SEG12 main::@1
   b1:
   //SEG13 [3] (byte~) main::$0 ← (const byte[]) TXT#0 *idx (byte) main::j#3 [ main::j#3 main::i#2 main::$0 ] -- aby=cowo1_staridx_yby 
@@ -1070,8 +1070,8 @@ main: {
   //SEG16 [6] if((byte) main::j#1!=(byte) 8) goto main::@6 [ main::i#2 ] -- yby_neq_coby1_then_la1 
     cpy #8
     bne b6
-  //SEG17 [7] phi from main::@1 to main::@2
-  //SEG18 [7] phi (byte) main::j#4 = (byte) 0 -- yby=coby1 
+  //SEG17 [7] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
+  //SEG18 [7] phi (byte) main::j#4 = (byte) 0 [phi:main::@1->main::@2#0] -- yby=coby1 
     ldy #0
   //SEG19 main::@2
   b2:
@@ -1085,8 +1085,8 @@ main: {
     rts
   //SEG24 main::@6
   b6:
-  //SEG25 [7] phi from main::@6 to main::@2
-  //SEG26 [7] phi (byte) main::j#4 = (byte) main::j#1 -- register_copy 
+  //SEG25 [7] phi from main::@6 to main::@2 [phi:main::@6->main::@2]
+  //SEG26 [7] phi (byte) main::j#4 = (byte) main::j#1 [phi:main::@6->main::@2#0] -- register_copy 
     jmp b2
 }
 
@@ -1098,19 +1098,19 @@ ASSEMBLER
   TXT: .byte 3, 1, $d, 5, $c, $f, $14, $20
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
 main: {
-  //SEG6 [2] phi from main to main::@1
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- xby=coby1 
     ldx #0
-  //SEG8 [2] phi (byte) main::j#3 = (byte) 0 -- yby=coby1 
+  //SEG8 [2] phi (byte) main::j#3 = (byte) 0 [phi:main->main::@1#1] -- yby=coby1 
     ldy #0
-  //SEG9 [2] phi from main::@2 to main::@1
-  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
-  //SEG11 [2] phi (byte) main::j#3 = (byte) main::j#4 -- register_copy 
+  //SEG9 [2] phi from main::@2 to main::@1 [phi:main::@2->main::@1]
+  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@2->main::@1#0] -- register_copy 
+  //SEG11 [2] phi (byte) main::j#3 = (byte) main::j#4 [phi:main::@2->main::@1#1] -- register_copy 
   //SEG12 main::@1
   b1:
   //SEG13 [3] (byte~) main::$0 ← (const byte[]) TXT#0 *idx (byte) main::j#3 [ main::j#3 main::i#2 main::$0 ] -- aby=cowo1_staridx_yby 
@@ -1122,8 +1122,8 @@ main: {
   //SEG16 [6] if((byte) main::j#1!=(byte) 8) goto main::@6 [ main::i#2 ] -- yby_neq_coby1_then_la1 
     cpy #8
     bne b6
-  //SEG17 [7] phi from main::@1 to main::@2
-  //SEG18 [7] phi (byte) main::j#4 = (byte) 0 -- yby=coby1 
+  //SEG17 [7] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
+  //SEG18 [7] phi (byte) main::j#4 = (byte) 0 [phi:main::@1->main::@2#0] -- yby=coby1 
     ldy #0
   //SEG19 main::@2
   b2:
@@ -1137,8 +1137,8 @@ main: {
     rts
   //SEG24 main::@6
   b6:
-  //SEG25 [7] phi from main::@6 to main::@2
-  //SEG26 [7] phi (byte) main::j#4 = (byte) main::j#1 -- register_copy 
+  //SEG25 [7] phi from main::@6 to main::@2 [phi:main::@6->main::@2]
+  //SEG26 [7] phi (byte) main::j#4 = (byte) main::j#1 [phi:main::@6->main::@2#0] -- register_copy 
     jmp b2
 }
 
@@ -1173,19 +1173,19 @@ FINAL CODE
   TXT: .byte 3, 1, $d, 5, $c, $f, $14, $20
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
 main: {
-  //SEG6 [2] phi from main to main::@1
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- xby=coby1 
     ldx #0
-  //SEG8 [2] phi (byte) main::j#3 = (byte) 0 -- yby=coby1 
+  //SEG8 [2] phi (byte) main::j#3 = (byte) 0 [phi:main->main::@1#1] -- yby=coby1 
     ldy #0
-  //SEG9 [2] phi from main::@2 to main::@1
-  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
-  //SEG11 [2] phi (byte) main::j#3 = (byte) main::j#4 -- register_copy 
+  //SEG9 [2] phi from main::@2 to main::@1 [phi:main::@2->main::@1]
+  //SEG10 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@2->main::@1#0] -- register_copy 
+  //SEG11 [2] phi (byte) main::j#3 = (byte) main::j#4 [phi:main::@2->main::@1#1] -- register_copy 
   //SEG12 main::@1
   b1:
   //SEG13 [3] (byte~) main::$0 ← (const byte[]) TXT#0 *idx (byte) main::j#3 [ main::j#3 main::i#2 main::$0 ] -- aby=cowo1_staridx_yby 
@@ -1197,8 +1197,8 @@ main: {
   //SEG16 [6] if((byte) main::j#1!=(byte) 8) goto main::@6 [ main::i#2 ] -- yby_neq_coby1_then_la1 
     cpy #8
     bne b6
-  //SEG17 [7] phi from main::@1 to main::@2
-  //SEG18 [7] phi (byte) main::j#4 = (byte) 0 -- yby=coby1 
+  //SEG17 [7] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
+  //SEG18 [7] phi (byte) main::j#4 = (byte) 0 [phi:main::@1->main::@2#0] -- yby=coby1 
     ldy #0
   //SEG19 main::@2
   b2:
@@ -1212,8 +1212,8 @@ main: {
     rts
   //SEG24 main::@6
   b6:
-  //SEG25 [7] phi from main::@6 to main::@2
-  //SEG26 [7] phi (byte) main::j#4 = (byte) main::j#1 -- register_copy 
+  //SEG25 [7] phi from main::@6 to main::@2 [phi:main::@6->main::@2]
+  //SEG26 [7] phi (byte) main::j#4 = (byte) main::j#1 [phi:main::@6->main::@2#0] -- register_copy 
     jmp b2
 }
 

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

@@ -878,7 +878,7 @@ INITIAL ASM
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
 main_from_bbegin:
   jsr main
   jmp bend
@@ -889,21 +889,21 @@ main: {
     .label _0 = 5
     .label i = 2
     .label cursor = 3
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte*) main::cursor#2 = (const byte*) SCREEN#0 -- zpptrby1=cowo1 
+  //SEG7 [2] phi (byte*) main::cursor#2 = (const byte*) SCREEN#0 [phi:main->main::@1#0] -- zpptrby1=cowo1 
     lda #<SCREEN
     sta cursor
     lda #>SCREEN
     sta cursor+1
-  //SEG8 [2] phi (byte) main::i#3 = (byte) 0 -- zpby1=coby1 
+  //SEG8 [2] phi (byte) main::i#3 = (byte) 0 [phi:main->main::@1#1] -- zpby1=coby1 
     lda #0
     sta i
     jmp b1
-  //SEG9 [2] phi from main::@2 to main::@1
+  //SEG9 [2] phi from main::@2 to main::@1 [phi:main::@2->main::@1]
   b1_from_b2:
-  //SEG10 [2] phi (byte*) main::cursor#2 = (byte*) main::cursor#1 -- register_copy 
-  //SEG11 [2] phi (byte) main::i#3 = (byte) main::i#4 -- register_copy 
+  //SEG10 [2] phi (byte*) main::cursor#2 = (byte*) main::cursor#1 [phi:main::@2->main::@1#0] -- register_copy 
+  //SEG11 [2] phi (byte) main::i#3 = (byte) main::i#4 [phi:main::@2->main::@1#1] -- register_copy 
     jmp b1
   //SEG12 main::@1
   b1:
@@ -921,9 +921,9 @@ main: {
     lda i
     cmp #8
     bne b6
-  //SEG17 [7] phi from main::@1 to main::@2
+  //SEG17 [7] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
   b2_from_b1:
-  //SEG18 [7] phi (byte) main::i#4 = (byte) 0 -- zpby1=coby1 
+  //SEG18 [7] phi (byte) main::i#4 = (byte) 0 [phi:main::@1->main::@2#0] -- zpby1=coby1 
     lda #0
     sta i
     jmp b2
@@ -950,9 +950,9 @@ main: {
     rts
   //SEG24 main::@6
   b6:
-  //SEG25 [7] phi from main::@6 to main::@2
+  //SEG25 [7] phi from main::@6 to main::@2 [phi:main::@6->main::@2]
   b2_from_b6:
-  //SEG26 [7] phi (byte) main::i#4 = (byte) main::i#1 -- register_copy 
+  //SEG26 [7] phi (byte) main::i#4 = (byte) main::i#1 [phi:main::@6->main::@2#0] -- register_copy 
     jmp b2
 }
 
@@ -986,7 +986,7 @@ ASSEMBLER
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
 main_from_bbegin:
   jsr main
 //SEG4 @end
@@ -994,20 +994,20 @@ bend:
 //SEG5 main
 main: {
     .label cursor = 2
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte*) main::cursor#2 = (const byte*) SCREEN#0 -- zpptrby1=cowo1 
+  //SEG7 [2] phi (byte*) main::cursor#2 = (const byte*) SCREEN#0 [phi:main->main::@1#0] -- zpptrby1=cowo1 
     lda #<SCREEN
     sta cursor
     lda #>SCREEN
     sta cursor+1
-  //SEG8 [2] phi (byte) main::i#3 = (byte) 0 -- xby=coby1 
+  //SEG8 [2] phi (byte) main::i#3 = (byte) 0 [phi:main->main::@1#1] -- xby=coby1 
     ldx #0
     jmp b1
-  //SEG9 [2] phi from main::@2 to main::@1
+  //SEG9 [2] phi from main::@2 to main::@1 [phi:main::@2->main::@1]
   b1_from_b2:
-  //SEG10 [2] phi (byte*) main::cursor#2 = (byte*) main::cursor#1 -- register_copy 
-  //SEG11 [2] phi (byte) main::i#3 = (byte) main::i#4 -- register_copy 
+  //SEG10 [2] phi (byte*) main::cursor#2 = (byte*) main::cursor#1 [phi:main::@2->main::@1#0] -- register_copy 
+  //SEG11 [2] phi (byte) main::i#3 = (byte) main::i#4 [phi:main::@2->main::@1#1] -- register_copy 
   //SEG12 main::@1
   b1:
   //SEG13 [3] (byte~) main::$0 ← (const byte[]) TEXT#0 *idx (byte) main::i#3 [ main::i#3 main::cursor#2 main::$0 ] -- aby=cowo1_staridx_xby 
@@ -1020,9 +1020,9 @@ main: {
   //SEG16 [6] if((byte) main::i#1!=(byte) 8) goto main::@6 [ main::cursor#2 ] -- xby_neq_coby1_then_la1 
     cpx #8
     bne b6
-  //SEG17 [7] phi from main::@1 to main::@2
+  //SEG17 [7] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
   b2_from_b1:
-  //SEG18 [7] phi (byte) main::i#4 = (byte) 0 -- xby=coby1 
+  //SEG18 [7] phi (byte) main::i#4 = (byte) 0 [phi:main::@1->main::@2#0] -- xby=coby1 
     ldx #0
   //SEG19 main::@2
   b2:
@@ -1046,9 +1046,9 @@ main: {
     rts
   //SEG24 main::@6
   b6:
-  //SEG25 [7] phi from main::@6 to main::@2
+  //SEG25 [7] phi from main::@6 to main::@2 [phi:main::@6->main::@2]
   b2_from_b6:
-  //SEG26 [7] phi (byte) main::i#4 = (byte) main::i#1 -- register_copy 
+  //SEG26 [7] phi (byte) main::i#4 = (byte) main::i#1 [phi:main::@6->main::@2#0] -- register_copy 
     jmp b2
 }
 
@@ -1065,26 +1065,26 @@ ASSEMBLER
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 bend:
 //SEG5 main
 main: {
     .label cursor = 2
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte*) main::cursor#2 = (const byte*) SCREEN#0 -- zpptrby1=cowo1 
+  //SEG7 [2] phi (byte*) main::cursor#2 = (const byte*) SCREEN#0 [phi:main->main::@1#0] -- zpptrby1=cowo1 
     lda #<SCREEN
     sta cursor
     lda #>SCREEN
     sta cursor+1
-  //SEG8 [2] phi (byte) main::i#3 = (byte) 0 -- xby=coby1 
+  //SEG8 [2] phi (byte) main::i#3 = (byte) 0 [phi:main->main::@1#1] -- xby=coby1 
     ldx #0
     jmp b1
-  //SEG9 [2] phi from main::@2 to main::@1
-  //SEG10 [2] phi (byte*) main::cursor#2 = (byte*) main::cursor#1 -- register_copy 
-  //SEG11 [2] phi (byte) main::i#3 = (byte) main::i#4 -- register_copy 
+  //SEG9 [2] phi from main::@2 to main::@1 [phi:main::@2->main::@1]
+  //SEG10 [2] phi (byte*) main::cursor#2 = (byte*) main::cursor#1 [phi:main::@2->main::@1#0] -- register_copy 
+  //SEG11 [2] phi (byte) main::i#3 = (byte) main::i#4 [phi:main::@2->main::@1#1] -- register_copy 
   //SEG12 main::@1
   b1:
   //SEG13 [3] (byte~) main::$0 ← (const byte[]) TEXT#0 *idx (byte) main::i#3 [ main::i#3 main::cursor#2 main::$0 ] -- aby=cowo1_staridx_xby 
@@ -1097,9 +1097,9 @@ main: {
   //SEG16 [6] if((byte) main::i#1!=(byte) 8) goto main::@6 [ main::cursor#2 ] -- xby_neq_coby1_then_la1 
     cpx #8
     bne b6
-  //SEG17 [7] phi from main::@1 to main::@2
+  //SEG17 [7] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
   b2_from_b1:
-  //SEG18 [7] phi (byte) main::i#4 = (byte) 0 -- xby=coby1 
+  //SEG18 [7] phi (byte) main::i#4 = (byte) 0 [phi:main::@1->main::@2#0] -- xby=coby1 
     ldx #0
   //SEG19 main::@2
   b2:
@@ -1123,8 +1123,8 @@ main: {
     rts
   //SEG24 main::@6
   b6:
-  //SEG25 [7] phi from main::@6 to main::@2
-  //SEG26 [7] phi (byte) main::i#4 = (byte) main::i#1 -- register_copy 
+  //SEG25 [7] phi from main::@6 to main::@2 [phi:main::@6->main::@2]
+  //SEG26 [7] phi (byte) main::i#4 = (byte) main::i#1 [phi:main::@6->main::@2#0] -- register_copy 
     jmp b2
 }
 
@@ -1140,24 +1140,24 @@ ASSEMBLER
   TEXT: .text "camelot "
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
 main: {
     .label cursor = 2
-  //SEG6 [2] phi from main to main::@1
-  //SEG7 [2] phi (byte*) main::cursor#2 = (const byte*) SCREEN#0 -- zpptrby1=cowo1 
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG7 [2] phi (byte*) main::cursor#2 = (const byte*) SCREEN#0 [phi:main->main::@1#0] -- zpptrby1=cowo1 
     lda #<SCREEN
     sta cursor
     lda #>SCREEN
     sta cursor+1
-  //SEG8 [2] phi (byte) main::i#3 = (byte) 0 -- xby=coby1 
+  //SEG8 [2] phi (byte) main::i#3 = (byte) 0 [phi:main->main::@1#1] -- xby=coby1 
     ldx #0
     jmp b1
-  //SEG9 [2] phi from main::@2 to main::@1
-  //SEG10 [2] phi (byte*) main::cursor#2 = (byte*) main::cursor#1 -- register_copy 
-  //SEG11 [2] phi (byte) main::i#3 = (byte) main::i#4 -- register_copy 
+  //SEG9 [2] phi from main::@2 to main::@1 [phi:main::@2->main::@1]
+  //SEG10 [2] phi (byte*) main::cursor#2 = (byte*) main::cursor#1 [phi:main::@2->main::@1#0] -- register_copy 
+  //SEG11 [2] phi (byte) main::i#3 = (byte) main::i#4 [phi:main::@2->main::@1#1] -- register_copy 
   //SEG12 main::@1
   b1:
   //SEG13 [3] (byte~) main::$0 ← (const byte[]) TEXT#0 *idx (byte) main::i#3 [ main::i#3 main::cursor#2 main::$0 ] -- aby=cowo1_staridx_xby 
@@ -1170,8 +1170,8 @@ main: {
   //SEG16 [6] if((byte) main::i#1!=(byte) 8) goto main::@6 [ main::cursor#2 ] -- xby_neq_coby1_then_la1 
     cpx #8
     bne b6
-  //SEG17 [7] phi from main::@1 to main::@2
-  //SEG18 [7] phi (byte) main::i#4 = (byte) 0 -- xby=coby1 
+  //SEG17 [7] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
+  //SEG18 [7] phi (byte) main::i#4 = (byte) 0 [phi:main::@1->main::@2#0] -- xby=coby1 
     ldx #0
   //SEG19 main::@2
   b2:
@@ -1194,8 +1194,8 @@ main: {
     rts
   //SEG24 main::@6
   b6:
-  //SEG25 [7] phi from main::@6 to main::@2
-  //SEG26 [7] phi (byte) main::i#4 = (byte) main::i#1 -- register_copy 
+  //SEG25 [7] phi from main::@6 to main::@2 [phi:main::@6->main::@2]
+  //SEG26 [7] phi (byte) main::i#4 = (byte) main::i#1 [phi:main::@6->main::@2#0] -- register_copy 
     jmp b2
 }
 
@@ -1207,23 +1207,23 @@ ASSEMBLER
   TEXT: .text "camelot "
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
 main: {
     .label cursor = 2
-  //SEG6 [2] phi from main to main::@1
-  //SEG7 [2] phi (byte*) main::cursor#2 = (const byte*) SCREEN#0 -- zpptrby1=cowo1 
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG7 [2] phi (byte*) main::cursor#2 = (const byte*) SCREEN#0 [phi:main->main::@1#0] -- zpptrby1=cowo1 
     lda #<SCREEN
     sta cursor
     lda #>SCREEN
     sta cursor+1
-  //SEG8 [2] phi (byte) main::i#3 = (byte) 0 -- xby=coby1 
+  //SEG8 [2] phi (byte) main::i#3 = (byte) 0 [phi:main->main::@1#1] -- xby=coby1 
     ldx #0
-  //SEG9 [2] phi from main::@2 to main::@1
-  //SEG10 [2] phi (byte*) main::cursor#2 = (byte*) main::cursor#1 -- register_copy 
-  //SEG11 [2] phi (byte) main::i#3 = (byte) main::i#4 -- register_copy 
+  //SEG9 [2] phi from main::@2 to main::@1 [phi:main::@2->main::@1]
+  //SEG10 [2] phi (byte*) main::cursor#2 = (byte*) main::cursor#1 [phi:main::@2->main::@1#0] -- register_copy 
+  //SEG11 [2] phi (byte) main::i#3 = (byte) main::i#4 [phi:main::@2->main::@1#1] -- register_copy 
   //SEG12 main::@1
   b1:
   //SEG13 [3] (byte~) main::$0 ← (const byte[]) TEXT#0 *idx (byte) main::i#3 [ main::i#3 main::cursor#2 main::$0 ] -- aby=cowo1_staridx_xby 
@@ -1236,8 +1236,8 @@ main: {
   //SEG16 [6] if((byte) main::i#1!=(byte) 8) goto main::@6 [ main::cursor#2 ] -- xby_neq_coby1_then_la1 
     cpx #8
     bne b6
-  //SEG17 [7] phi from main::@1 to main::@2
-  //SEG18 [7] phi (byte) main::i#4 = (byte) 0 -- xby=coby1 
+  //SEG17 [7] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
+  //SEG18 [7] phi (byte) main::i#4 = (byte) 0 [phi:main::@1->main::@2#0] -- xby=coby1 
     ldx #0
   //SEG19 main::@2
   b2:
@@ -1260,8 +1260,8 @@ main: {
     rts
   //SEG24 main::@6
   b6:
-  //SEG25 [7] phi from main::@6 to main::@2
-  //SEG26 [7] phi (byte) main::i#4 = (byte) main::i#1 -- register_copy 
+  //SEG25 [7] phi from main::@6 to main::@2 [phi:main::@6->main::@2]
+  //SEG26 [7] phi (byte) main::i#4 = (byte) main::i#1 [phi:main::@6->main::@2#0] -- register_copy 
     jmp b2
 }
 
@@ -1296,23 +1296,23 @@ FINAL CODE
   TEXT: .text "camelot "
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
 main: {
     .label cursor = 2
-  //SEG6 [2] phi from main to main::@1
-  //SEG7 [2] phi (byte*) main::cursor#2 = (const byte*) SCREEN#0 -- zpptrby1=cowo1 
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG7 [2] phi (byte*) main::cursor#2 = (const byte*) SCREEN#0 [phi:main->main::@1#0] -- zpptrby1=cowo1 
     lda #<SCREEN
     sta cursor
     lda #>SCREEN
     sta cursor+1
-  //SEG8 [2] phi (byte) main::i#3 = (byte) 0 -- xby=coby1 
+  //SEG8 [2] phi (byte) main::i#3 = (byte) 0 [phi:main->main::@1#1] -- xby=coby1 
     ldx #0
-  //SEG9 [2] phi from main::@2 to main::@1
-  //SEG10 [2] phi (byte*) main::cursor#2 = (byte*) main::cursor#1 -- register_copy 
-  //SEG11 [2] phi (byte) main::i#3 = (byte) main::i#4 -- register_copy 
+  //SEG9 [2] phi from main::@2 to main::@1 [phi:main::@2->main::@1]
+  //SEG10 [2] phi (byte*) main::cursor#2 = (byte*) main::cursor#1 [phi:main::@2->main::@1#0] -- register_copy 
+  //SEG11 [2] phi (byte) main::i#3 = (byte) main::i#4 [phi:main::@2->main::@1#1] -- register_copy 
   //SEG12 main::@1
   b1:
   //SEG13 [3] (byte~) main::$0 ← (const byte[]) TEXT#0 *idx (byte) main::i#3 [ main::i#3 main::cursor#2 main::$0 ] -- aby=cowo1_staridx_xby 
@@ -1325,8 +1325,8 @@ main: {
   //SEG16 [6] if((byte) main::i#1!=(byte) 8) goto main::@6 [ main::cursor#2 ] -- xby_neq_coby1_then_la1 
     cpx #8
     bne b6
-  //SEG17 [7] phi from main::@1 to main::@2
-  //SEG18 [7] phi (byte) main::i#4 = (byte) 0 -- xby=coby1 
+  //SEG17 [7] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
+  //SEG18 [7] phi (byte) main::i#4 = (byte) 0 [phi:main::@1->main::@2#0] -- xby=coby1 
     ldx #0
   //SEG19 main::@2
   b2:
@@ -1349,8 +1349,8 @@ main: {
     rts
   //SEG24 main::@6
   b6:
-  //SEG25 [7] phi from main::@6 to main::@2
-  //SEG26 [7] phi (byte) main::i#4 = (byte) main::i#1 -- register_copy 
+  //SEG25 [7] phi from main::@6 to main::@2 [phi:main::@6->main::@2]
+  //SEG26 [7] phi (byte) main::i#4 = (byte) main::i#1 [phi:main::@6->main::@2#0] -- register_copy 
     jmp b2
 }
 

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

@@ -534,7 +534,7 @@ INITIAL ASM
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
 main_from_bbegin:
   jsr main
   jmp bend
@@ -545,15 +545,15 @@ main: {
     .const buf = $1100
     .label _1 = 3
     .label i = 2
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 5 -- zpby1=coby1 
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 5 [phi:main->main::@1#0] -- zpby1=coby1 
     lda #5
     sta i
     jmp b1
-  //SEG8 [2] phi from main::@1 to main::@1
+  //SEG8 [2] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
   b1_from_b1:
-  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
     jmp b1
   //SEG10 main::@1
   b1:
@@ -601,7 +601,7 @@ ASSEMBLER
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
 main_from_bbegin:
   jsr main
 //SEG4 @end
@@ -609,14 +609,14 @@ bend:
 //SEG5 main
 main: {
     .const buf = $1100
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 5 -- xby=coby1 
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 5 [phi:main->main::@1#0] -- xby=coby1 
     ldx #5
     jmp b1
-  //SEG8 [2] phi from main::@1 to main::@1
+  //SEG8 [2] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
   b1_from_b1:
-  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
   //SEG10 main::@1
   b1:
   //SEG11 [3] (byte~) main::$1 ← (byte) main::i#2 + (byte) 2+(byte) 2 [ main::i#2 main::$1 ] -- aby=xby_plus_coby1 
@@ -645,20 +645,20 @@ ASSEMBLER
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 bend:
 //SEG5 main
 main: {
     .const buf = $1100
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 5 -- xby=coby1 
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 5 [phi:main->main::@1#0] -- xby=coby1 
     ldx #5
     jmp b1
-  //SEG8 [2] phi from main::@1 to main::@1
-  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG8 [2] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
+  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
   //SEG10 main::@1
   b1:
   //SEG11 [3] (byte~) main::$1 ← (byte) main::i#2 + (byte) 2+(byte) 2 [ main::i#2 main::$1 ] -- aby=xby_plus_coby1 
@@ -687,18 +687,18 @@ ASSEMBLER
 //SEG0 Global Constants & labels
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
 main: {
     .const buf = $1100
-  //SEG6 [2] phi from main to main::@1
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 5 -- xby=coby1 
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 5 [phi:main->main::@1#0] -- xby=coby1 
     ldx #5
     jmp b1
-  //SEG8 [2] phi from main::@1 to main::@1
-  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG8 [2] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
+  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
   //SEG10 main::@1
   b1:
   //SEG11 [3] (byte~) main::$1 ← (byte) main::i#2 + (byte) 2+(byte) 2 [ main::i#2 main::$1 ] -- aby=xby_plus_coby1 
@@ -723,17 +723,17 @@ ASSEMBLER
 //SEG0 Global Constants & labels
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
 main: {
     .const buf = $1100
-  //SEG6 [2] phi from main to main::@1
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 5 -- xby=coby1 
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 5 [phi:main->main::@1#0] -- xby=coby1 
     ldx #5
-  //SEG8 [2] phi from main::@1 to main::@1
-  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG8 [2] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
+  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
   //SEG10 main::@1
   b1:
   //SEG11 [3] (byte~) main::$1 ← (byte) main::i#2 + (byte) 2+(byte) 2 [ main::i#2 main::$1 ] -- aby=xby_plus_coby1 
@@ -772,17 +772,17 @@ FINAL CODE
 //SEG0 Global Constants & labels
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
 main: {
     .const buf = $1100
-  //SEG6 [2] phi from main to main::@1
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 5 -- xby=coby1 
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 5 [phi:main->main::@1#0] -- xby=coby1 
     ldx #5
-  //SEG8 [2] phi from main::@1 to main::@1
-  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG8 [2] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
+  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
   //SEG10 main::@1
   b1:
   //SEG11 [3] (byte~) main::$1 ← (byte) main::i#2 + (byte) 2+(byte) 2 [ main::i#2 main::$1 ] -- aby=xby_plus_coby1 

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

@@ -812,15 +812,15 @@ main: {
   //SEG6 [2] *((const byte*) SCREEN#0+(byte) 2) ← (const byte) num#0 [ ] -- _star_cowo1=coby2 
     lda #num
     sta SCREEN+2
-  //SEG7 [3] phi from main to main::@1
+  //SEG7 [3] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 -- zpby1=coby1 
+  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- zpby1=coby1 
     lda #0
     sta i
     jmp b1
-  //SEG9 [3] phi from main::@1 to main::@1
+  //SEG9 [3] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
   b1_from_b1:
-  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
     jmp b1
   //SEG11 main::@1
   b1:
@@ -893,14 +893,14 @@ main: {
   //SEG6 [2] *((const byte*) SCREEN#0+(byte) 2) ← (const byte) num#0 [ ] -- _star_cowo1=coby2 
     lda #num
     sta SCREEN+2
-  //SEG7 [3] phi from main to main::@1
+  //SEG7 [3] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- xby=coby1 
     ldx #0
     jmp b1
-  //SEG9 [3] phi from main::@1 to main::@1
+  //SEG9 [3] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
   b1_from_b1:
-  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
   //SEG11 main::@1
   b1:
   //SEG12 [4] (byte~) main::$1 ← (const byte[]) str#0 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- aby=cowo1_staridx_xby 
@@ -946,13 +946,13 @@ main: {
   //SEG6 [2] *((const byte*) SCREEN#0+(byte) 2) ← (const byte) num#0 [ ] -- _star_cowo1=coby2 
     lda #num
     sta SCREEN+2
-  //SEG7 [3] phi from main to main::@1
+  //SEG7 [3] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- xby=coby1 
     ldx #0
     jmp b1
-  //SEG9 [3] phi from main::@1 to main::@1
-  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 [3] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
+  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
   //SEG11 main::@1
   b1:
   //SEG12 [4] (byte~) main::$1 ← (const byte[]) str#0 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- aby=cowo1_staridx_xby 
@@ -998,12 +998,12 @@ main: {
   //SEG6 [2] *((const byte*) SCREEN#0+(byte) 2) ← (const byte) num#0 [ ] -- _star_cowo1=coby2 
     lda #num
     sta SCREEN+2
-  //SEG7 [3] phi from main to main::@1
-  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG7 [3] phi from main to main::@1 [phi:main->main::@1]
+  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- xby=coby1 
     ldx #0
     jmp b1
-  //SEG9 [3] phi from main::@1 to main::@1
-  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 [3] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
+  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
   //SEG11 main::@1
   b1:
   //SEG12 [4] (byte~) main::$1 ← (const byte[]) str#0 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- aby=cowo1_staridx_xby 
@@ -1045,11 +1045,11 @@ main: {
   //SEG6 [2] *((const byte*) SCREEN#0+(byte) 2) ← (const byte) num#0 [ ] -- _star_cowo1=coby2 
     lda #num
     sta SCREEN+2
-  //SEG7 [3] phi from main to main::@1
-  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG7 [3] phi from main to main::@1 [phi:main->main::@1]
+  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- xby=coby1 
     ldx #0
-  //SEG9 [3] phi from main::@1 to main::@1
-  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 [3] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
+  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
   //SEG11 main::@1
   b1:
   //SEG12 [4] (byte~) main::$1 ← (const byte[]) str#0 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- aby=cowo1_staridx_xby 
@@ -1115,11 +1115,11 @@ main: {
   //SEG6 [2] *((const byte*) SCREEN#0+(byte) 2) ← (const byte) num#0 [ ] -- _star_cowo1=coby2 
     lda #num
     sta SCREEN+2
-  //SEG7 [3] phi from main to main::@1
-  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG7 [3] phi from main to main::@1 [phi:main->main::@1]
+  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- xby=coby1 
     ldx #0
-  //SEG9 [3] phi from main::@1 to main::@1
-  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 [3] phi from main::@1 to main::@1 [phi:main::@1->main::@1]
+  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@1->main::@1#0] -- register_copy 
   //SEG11 main::@1
   b1:
   //SEG12 [4] (byte~) main::$1 ← (const byte[]) str#0 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- aby=cowo1_staridx_xby 

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

@@ -668,7 +668,7 @@ INITIAL ASM
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
 main_from_bbegin:
   jsr main
   jmp bend
@@ -681,9 +681,9 @@ main: {
     .label a = 4
     .label a_2 = 6
   //SEG6 [2] call inc param-assignment [ inc::return#0 inc::$0 ]
-  //SEG7 [9] phi from main to inc
+  //SEG7 [9] phi from main to inc [phi:main->inc]
   inc_from_main:
-  //SEG8 [9] phi (byte) i#11 = (byte) 0 -- zpby1=coby1 
+  //SEG8 [9] phi (byte) i#11 = (byte) 0 [phi:main->inc#0] -- zpby1=coby1 
     lda #0
     sta i
     jsr inc
@@ -699,9 +699,9 @@ main: {
     adc #4
     sta a
   //SEG12 [5] call inc param-assignment [ inc::return#0 main::a#1 ]
-  //SEG13 [9] phi from main::@1 to inc
+  //SEG13 [9] phi from main::@1 to inc [phi:main::@1->inc]
   inc_from_b1:
-  //SEG14 [9] phi (byte) i#11 = (byte~) inc::$0 -- register_copy 
+  //SEG14 [9] phi (byte) i#11 = (byte~) inc::$0 [phi:main::@1->inc#0] -- register_copy 
     jsr inc
     jmp b2
   //SEG15 main::@2
@@ -776,7 +776,7 @@ ASSEMBLER
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
 main_from_bbegin:
   jsr main
 //SEG4 @end
@@ -785,9 +785,9 @@ bend:
 main: {
     .label a = 2
   //SEG6 [2] call inc param-assignment [ inc::return#0 inc::$0 ]
-  //SEG7 [9] phi from main to inc
+  //SEG7 [9] phi from main to inc [phi:main->inc]
   inc_from_main:
-  //SEG8 [9] phi (byte) i#11 = (byte) 0 -- xby=coby1 
+  //SEG8 [9] phi (byte) i#11 = (byte) 0 [phi:main->inc#0] -- xby=coby1 
     ldx #0
     jsr inc
   //SEG9 main::@1
@@ -799,9 +799,9 @@ main: {
     adc #4
     sta a
   //SEG12 [5] call inc param-assignment [ inc::return#0 main::a#1 ]
-  //SEG13 [9] phi from main::@1 to inc
+  //SEG13 [9] phi from main::@1 to inc [phi:main::@1->inc]
   inc_from_b1:
-  //SEG14 [9] phi (byte) i#11 = (byte~) inc::$0 -- register_copy 
+  //SEG14 [9] phi (byte) i#11 = (byte~) inc::$0 [phi:main::@1->inc#0] -- register_copy 
     jsr inc
   //SEG15 main::@2
   b2:
@@ -837,7 +837,7 @@ ASSEMBLER
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 bend:
@@ -845,9 +845,9 @@ bend:
 main: {
     .label a = 2
   //SEG6 [2] call inc param-assignment [ inc::return#0 inc::$0 ]
-  //SEG7 [9] phi from main to inc
+  //SEG7 [9] phi from main to inc [phi:main->inc]
   inc_from_main:
-  //SEG8 [9] phi (byte) i#11 = (byte) 0 -- xby=coby1 
+  //SEG8 [9] phi (byte) i#11 = (byte) 0 [phi:main->inc#0] -- xby=coby1 
     ldx #0
     jsr inc
   //SEG9 main::@1
@@ -859,9 +859,9 @@ main: {
     adc #4
     sta a
   //SEG12 [5] call inc param-assignment [ inc::return#0 main::a#1 ]
-  //SEG13 [9] phi from main::@1 to inc
+  //SEG13 [9] phi from main::@1 to inc [phi:main::@1->inc]
   inc_from_b1:
-  //SEG14 [9] phi (byte) i#11 = (byte~) inc::$0 -- register_copy 
+  //SEG14 [9] phi (byte) i#11 = (byte~) inc::$0 [phi:main::@1->inc#0] -- register_copy 
     jsr inc
   //SEG15 main::@2
   b2:
@@ -903,15 +903,15 @@ ASSEMBLER
 //SEG0 Global Constants & labels
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
 main: {
     .label a = 2
   //SEG6 [2] call inc param-assignment [ inc::return#0 inc::$0 ]
-  //SEG7 [9] phi from main to inc
-  //SEG8 [9] phi (byte) i#11 = (byte) 0 -- xby=coby1 
+  //SEG7 [9] phi from main to inc [phi:main->inc]
+  //SEG8 [9] phi (byte) i#11 = (byte) 0 [phi:main->inc#0] -- xby=coby1 
     ldx #0
     jsr inc
   //SEG9 main::@1
@@ -922,8 +922,8 @@ main: {
     adc #4
     sta a
   //SEG12 [5] call inc param-assignment [ inc::return#0 main::a#1 ]
-  //SEG13 [9] phi from main::@1 to inc
-  //SEG14 [9] phi (byte) i#11 = (byte~) inc::$0 -- register_copy 
+  //SEG13 [9] phi from main::@1 to inc [phi:main::@1->inc]
+  //SEG14 [9] phi (byte) i#11 = (byte~) inc::$0 [phi:main::@1->inc#0] -- register_copy 
     jsr inc
   //SEG15 main::@2
   //SEG16 [6] (byte~) main::$2 ← (byte) inc::return#0 [ main::a#1 main::$2 ]
@@ -980,15 +980,15 @@ FINAL CODE
 //SEG0 Global Constants & labels
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
 main: {
     .label a = 2
   //SEG6 [2] call inc param-assignment [ inc::return#0 inc::$0 ]
-  //SEG7 [9] phi from main to inc
-  //SEG8 [9] phi (byte) i#11 = (byte) 0 -- xby=coby1 
+  //SEG7 [9] phi from main to inc [phi:main->inc]
+  //SEG8 [9] phi (byte) i#11 = (byte) 0 [phi:main->inc#0] -- xby=coby1 
     ldx #0
     jsr inc
   //SEG9 main::@1
@@ -999,8 +999,8 @@ main: {
     adc #4
     sta a
   //SEG12 [5] call inc param-assignment [ inc::return#0 main::a#1 ]
-  //SEG13 [9] phi from main::@1 to inc
-  //SEG14 [9] phi (byte) i#11 = (byte~) inc::$0 -- register_copy 
+  //SEG13 [9] phi from main::@1 to inc [phi:main::@1->inc]
+  //SEG14 [9] phi (byte) i#11 = (byte~) inc::$0 [phi:main::@1->inc#0] -- register_copy 
     jsr inc
   //SEG15 main::@2
   //SEG16 [6] (byte~) main::$2 ← (byte) inc::return#0 [ main::a#1 main::$2 ]

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

@@ -471,19 +471,19 @@ INITIAL ASM
   .label s = 3
 //SEG1 @begin
 bbegin:
-//SEG2 [0] phi from @begin to @1
+//SEG2 [0] phi from @begin to @1 [phi:@begin->@1]
 b1_from_bbegin:
-//SEG3 [0] phi (byte) s#2 = (byte) 0 -- zpby1=coby1 
+//SEG3 [0] phi (byte) s#2 = (byte) 0 [phi:@begin->@1#0] -- zpby1=coby1 
   lda #0
   sta s
-//SEG4 [0] phi (byte) i#2 = (byte) 10 -- zpby1=coby1 
+//SEG4 [0] phi (byte) i#2 = (byte) 10 [phi:@begin->@1#1] -- zpby1=coby1 
   lda #$a
   sta i
   jmp b1
-//SEG5 [0] phi from @2 to @1
+//SEG5 [0] phi from @2 to @1 [phi:@2->@1]
 b1_from_b2:
-//SEG6 [0] phi (byte) s#2 = (byte) s#4 -- register_copy 
-//SEG7 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
+//SEG6 [0] phi (byte) s#2 = (byte) s#4 [phi:@2->@1#0] -- register_copy 
+//SEG7 [0] phi (byte) i#2 = (byte) i#1 [phi:@2->@1#1] -- register_copy 
   jmp b1
 //SEG8 @1
 b1:
@@ -500,10 +500,10 @@ b3:
   clc
   adc i
   sta s
-//SEG12 [3] phi from @1 @3 to @2
+//SEG12 [3] phi from @1 @3 to @2 [phi:@1/@3->@2]
 b2_from_b1:
 b2_from_b3:
-//SEG13 [3] phi (byte) s#4 = (byte) s#2 -- register_copy 
+//SEG13 [3] phi (byte) s#4 = (byte) s#2 [phi:@1/@3->@2#0] -- register_copy 
   jmp b2
 //SEG14 @2
 b2:
@@ -533,17 +533,17 @@ ASSEMBLER
 //SEG0 Global Constants & labels
 //SEG1 @begin
 bbegin:
-//SEG2 [0] phi from @begin to @1
+//SEG2 [0] phi from @begin to @1 [phi:@begin->@1]
 b1_from_bbegin:
-//SEG3 [0] phi (byte) s#2 = (byte) 0 -- aby=coby1 
+//SEG3 [0] phi (byte) s#2 = (byte) 0 [phi:@begin->@1#0] -- aby=coby1 
   lda #0
-//SEG4 [0] phi (byte) i#2 = (byte) 10 -- xby=coby1 
+//SEG4 [0] phi (byte) i#2 = (byte) 10 [phi:@begin->@1#1] -- xby=coby1 
   ldx #$a
   jmp b1
-//SEG5 [0] phi from @2 to @1
+//SEG5 [0] phi from @2 to @1 [phi:@2->@1]
 b1_from_b2:
-//SEG6 [0] phi (byte) s#2 = (byte) s#4 -- register_copy 
-//SEG7 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
+//SEG6 [0] phi (byte) s#2 = (byte) s#4 [phi:@2->@1#0] -- register_copy 
+//SEG7 [0] phi (byte) i#2 = (byte) i#1 [phi:@2->@1#1] -- register_copy 
 //SEG8 @1
 b1:
 //SEG9 [1] if((byte) i#2<=(byte) 5) goto @2 [ i#2 s#2 ] -- xby_le_coby1_then_la1 
@@ -556,10 +556,10 @@ b3:
   stx $ff
   clc
   adc $ff
-//SEG12 [3] phi from @1 @3 to @2
+//SEG12 [3] phi from @1 @3 to @2 [phi:@1/@3->@2]
 b2_from_b1:
 b2_from_b3:
-//SEG13 [3] phi (byte) s#4 = (byte) s#2 -- register_copy 
+//SEG13 [3] phi (byte) s#4 = (byte) s#2 [phi:@1/@3->@2#0] -- register_copy 
 //SEG14 @2
 b2:
 //SEG15 [4] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- xby=_dec_xby 
@@ -582,15 +582,15 @@ ASSEMBLER
 //SEG0 Global Constants & labels
 //SEG1 @begin
 bbegin:
-//SEG2 [0] phi from @begin to @1
-//SEG3 [0] phi (byte) s#2 = (byte) 0 -- aby=coby1 
+//SEG2 [0] phi from @begin to @1 [phi:@begin->@1]
+//SEG3 [0] phi (byte) s#2 = (byte) 0 [phi:@begin->@1#0] -- aby=coby1 
   lda #0
-//SEG4 [0] phi (byte) i#2 = (byte) 10 -- xby=coby1 
+//SEG4 [0] phi (byte) i#2 = (byte) 10 [phi:@begin->@1#1] -- xby=coby1 
   ldx #$a
   jmp b1
-//SEG5 [0] phi from @2 to @1
-//SEG6 [0] phi (byte) s#2 = (byte) s#4 -- register_copy 
-//SEG7 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
+//SEG5 [0] phi from @2 to @1 [phi:@2->@1]
+//SEG6 [0] phi (byte) s#2 = (byte) s#4 [phi:@2->@1#0] -- register_copy 
+//SEG7 [0] phi (byte) i#2 = (byte) i#1 [phi:@2->@1#1] -- register_copy 
 //SEG8 @1
 b1:
 //SEG9 [1] if((byte) i#2<=(byte) 5) goto @2 [ i#2 s#2 ] -- xby_le_coby1_then_la1 
@@ -603,8 +603,8 @@ b3:
   stx $ff
   clc
   adc $ff
-//SEG12 [3] phi from @1 @3 to @2
-//SEG13 [3] phi (byte) s#4 = (byte) s#2 -- register_copy 
+//SEG12 [3] phi from @1 @3 to @2 [phi:@1/@3->@2]
+//SEG13 [3] phi (byte) s#4 = (byte) s#2 [phi:@1/@3->@2#0] -- register_copy 
 //SEG14 @2
 b2:
 //SEG15 [4] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- xby=_dec_xby 
@@ -622,15 +622,15 @@ Succesful ASM optimization Pass5UnusedLabelElimination
 ASSEMBLER
 //SEG0 Global Constants & labels
 //SEG1 @begin
-//SEG2 [0] phi from @begin to @1
-//SEG3 [0] phi (byte) s#2 = (byte) 0 -- aby=coby1 
+//SEG2 [0] phi from @begin to @1 [phi:@begin->@1]
+//SEG3 [0] phi (byte) s#2 = (byte) 0 [phi:@begin->@1#0] -- aby=coby1 
   lda #0
-//SEG4 [0] phi (byte) i#2 = (byte) 10 -- xby=coby1 
+//SEG4 [0] phi (byte) i#2 = (byte) 10 [phi:@begin->@1#1] -- xby=coby1 
   ldx #$a
   jmp b1
-//SEG5 [0] phi from @2 to @1
-//SEG6 [0] phi (byte) s#2 = (byte) s#4 -- register_copy 
-//SEG7 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
+//SEG5 [0] phi from @2 to @1 [phi:@2->@1]
+//SEG6 [0] phi (byte) s#2 = (byte) s#4 [phi:@2->@1#0] -- register_copy 
+//SEG7 [0] phi (byte) i#2 = (byte) i#1 [phi:@2->@1#1] -- register_copy 
 //SEG8 @1
 b1:
 //SEG9 [1] if((byte) i#2<=(byte) 5) goto @2 [ i#2 s#2 ] -- xby_le_coby1_then_la1 
@@ -642,8 +642,8 @@ b1:
   stx $ff
   clc
   adc $ff
-//SEG12 [3] phi from @1 @3 to @2
-//SEG13 [3] phi (byte) s#4 = (byte) s#2 -- register_copy 
+//SEG12 [3] phi from @1 @3 to @2 [phi:@1/@3->@2]
+//SEG13 [3] phi (byte) s#4 = (byte) s#2 [phi:@1/@3->@2#0] -- register_copy 
 //SEG14 @2
 b2:
 //SEG15 [4] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- xby=_dec_xby 
@@ -658,14 +658,14 @@ Succesful ASM optimization Pass5NextJumpElimination
 ASSEMBLER
 //SEG0 Global Constants & labels
 //SEG1 @begin
-//SEG2 [0] phi from @begin to @1
-//SEG3 [0] phi (byte) s#2 = (byte) 0 -- aby=coby1 
+//SEG2 [0] phi from @begin to @1 [phi:@begin->@1]
+//SEG3 [0] phi (byte) s#2 = (byte) 0 [phi:@begin->@1#0] -- aby=coby1 
   lda #0
-//SEG4 [0] phi (byte) i#2 = (byte) 10 -- xby=coby1 
+//SEG4 [0] phi (byte) i#2 = (byte) 10 [phi:@begin->@1#1] -- xby=coby1 
   ldx #$a
-//SEG5 [0] phi from @2 to @1
-//SEG6 [0] phi (byte) s#2 = (byte) s#4 -- register_copy 
-//SEG7 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
+//SEG5 [0] phi from @2 to @1 [phi:@2->@1]
+//SEG6 [0] phi (byte) s#2 = (byte) s#4 [phi:@2->@1#0] -- register_copy 
+//SEG7 [0] phi (byte) i#2 = (byte) i#1 [phi:@2->@1#1] -- register_copy 
 //SEG8 @1
 b1:
 //SEG9 [1] if((byte) i#2<=(byte) 5) goto @2 [ i#2 s#2 ] -- xby_le_coby1_then_la1 
@@ -677,8 +677,8 @@ b1:
   stx $ff
   clc
   adc $ff
-//SEG12 [3] phi from @1 @3 to @2
-//SEG13 [3] phi (byte) s#4 = (byte) s#2 -- register_copy 
+//SEG12 [3] phi from @1 @3 to @2 [phi:@1/@3->@2]
+//SEG13 [3] phi (byte) s#4 = (byte) s#2 [phi:@1/@3->@2#0] -- register_copy 
 //SEG14 @2
 b2:
 //SEG15 [4] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- xby=_dec_xby 
@@ -708,14 +708,14 @@ reg byte a [ s#2 s#4 s#1 ]
 FINAL CODE
 //SEG0 Global Constants & labels
 //SEG1 @begin
-//SEG2 [0] phi from @begin to @1
-//SEG3 [0] phi (byte) s#2 = (byte) 0 -- aby=coby1 
+//SEG2 [0] phi from @begin to @1 [phi:@begin->@1]
+//SEG3 [0] phi (byte) s#2 = (byte) 0 [phi:@begin->@1#0] -- aby=coby1 
   lda #0
-//SEG4 [0] phi (byte) i#2 = (byte) 10 -- xby=coby1 
+//SEG4 [0] phi (byte) i#2 = (byte) 10 [phi:@begin->@1#1] -- xby=coby1 
   ldx #$a
-//SEG5 [0] phi from @2 to @1
-//SEG6 [0] phi (byte) s#2 = (byte) s#4 -- register_copy 
-//SEG7 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
+//SEG5 [0] phi from @2 to @1 [phi:@2->@1]
+//SEG6 [0] phi (byte) s#2 = (byte) s#4 [phi:@2->@1#0] -- register_copy 
+//SEG7 [0] phi (byte) i#2 = (byte) i#1 [phi:@2->@1#1] -- register_copy 
 //SEG8 @1
 b1:
 //SEG9 [1] if((byte) i#2<=(byte) 5) goto @2 [ i#2 s#2 ] -- xby_le_coby1_then_la1 
@@ -727,8 +727,8 @@ b1:
   stx $ff
   clc
   adc $ff
-//SEG12 [3] phi from @1 @3 to @2
-//SEG13 [3] phi (byte) s#4 = (byte) s#2 -- register_copy 
+//SEG12 [3] phi from @1 @3 to @2 [phi:@1/@3->@2]
+//SEG13 [3] phi (byte) s#4 = (byte) s#2 [phi:@1/@3->@2#0] -- register_copy 
 //SEG14 @2
 b2:
 //SEG15 [4] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- xby=_dec_xby 

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

@@ -790,7 +790,7 @@ INITIAL ASM
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
 main_from_bbegin:
   jsr main
   jmp bend
@@ -799,20 +799,20 @@ bend:
 //SEG5 main
 main: {
     .label i = 2
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 100 -- zpby1=coby1 
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 100 [phi:main->main::@1#0] -- zpby1=coby1 
     lda #$64
     sta i
     jmp b1
-  //SEG8 [2] phi from main::@3 to main::@1
+  //SEG8 [2] phi from main::@3 to main::@1 [phi:main::@3->main::@1]
   b1_from_b3:
-  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@3->main::@1#0] -- register_copy 
     jmp b1
   //SEG10 main::@1
   b1:
   //SEG11 [3] call nest param-assignment [ main::i#2 ]
-  //SEG12 [7] phi from main::@1 to nest
+  //SEG12 [7] phi from main::@1 to nest [phi:main::@1->nest]
   nest_from_b1:
     jsr nest
     jmp b3
@@ -832,15 +832,15 @@ main: {
 //SEG18 nest
 nest: {
     .label j = 3
-  //SEG19 [8] phi from nest to nest::@1
+  //SEG19 [8] phi from nest to nest::@1 [phi:nest->nest::@1]
   b1_from_nest:
-  //SEG20 [8] phi (byte) nest::j#2 = (byte) 100 -- zpby1=coby1 
+  //SEG20 [8] phi (byte) nest::j#2 = (byte) 100 [phi:nest->nest::@1#0] -- zpby1=coby1 
     lda #$64
     sta j
     jmp b1
-  //SEG21 [8] phi from nest::@1 to nest::@1
+  //SEG21 [8] phi from nest::@1 to nest::@1 [phi:nest::@1->nest::@1]
   b1_from_b1:
-  //SEG22 [8] phi (byte) nest::j#2 = (byte) nest::j#1 -- register_copy 
+  //SEG22 [8] phi (byte) nest::j#2 = (byte) nest::j#1 [phi:nest::@1->nest::@1#0] -- register_copy 
     jmp b1
   //SEG23 nest::@1
   b1:
@@ -884,25 +884,25 @@ ASSEMBLER
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
 main_from_bbegin:
   jsr main
 //SEG4 @end
 bend:
 //SEG5 main
 main: {
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 100 -- yby=coby1 
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 100 [phi:main->main::@1#0] -- yby=coby1 
     ldy #$64
     jmp b1
-  //SEG8 [2] phi from main::@3 to main::@1
+  //SEG8 [2] phi from main::@3 to main::@1 [phi:main::@3->main::@1]
   b1_from_b3:
-  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@3->main::@1#0] -- register_copy 
   //SEG10 main::@1
   b1:
   //SEG11 [3] call nest param-assignment [ main::i#2 ]
-  //SEG12 [7] phi from main::@1 to nest
+  //SEG12 [7] phi from main::@1 to nest [phi:main::@1->nest]
   nest_from_b1:
     jsr nest
   //SEG13 main::@3
@@ -919,14 +919,14 @@ main: {
 }
 //SEG18 nest
 nest: {
-  //SEG19 [8] phi from nest to nest::@1
+  //SEG19 [8] phi from nest to nest::@1 [phi:nest->nest::@1]
   b1_from_nest:
-  //SEG20 [8] phi (byte) nest::j#2 = (byte) 100 -- xby=coby1 
+  //SEG20 [8] phi (byte) nest::j#2 = (byte) 100 [phi:nest->nest::@1#0] -- xby=coby1 
     ldx #$64
     jmp b1
-  //SEG21 [8] phi from nest::@1 to nest::@1
+  //SEG21 [8] phi from nest::@1 to nest::@1 [phi:nest::@1->nest::@1]
   b1_from_b1:
-  //SEG22 [8] phi (byte) nest::j#2 = (byte) nest::j#1 -- register_copy 
+  //SEG22 [8] phi (byte) nest::j#2 = (byte) nest::j#1 [phi:nest::@1->nest::@1#0] -- register_copy 
   //SEG23 nest::@1
   b1:
   //SEG24 [9] *((const byte*) SCREEN#0) ← (byte) nest::j#2 [ nest::j#2 ] -- _star_cowo1=xby 
@@ -955,23 +955,23 @@ ASSEMBLER
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 bend:
 //SEG5 main
 main: {
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 100 -- yby=coby1 
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 100 [phi:main->main::@1#0] -- yby=coby1 
     ldy #$64
     jmp b1
-  //SEG8 [2] phi from main::@3 to main::@1
-  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG8 [2] phi from main::@3 to main::@1 [phi:main::@3->main::@1]
+  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@3->main::@1#0] -- register_copy 
   //SEG10 main::@1
   b1:
   //SEG11 [3] call nest param-assignment [ main::i#2 ]
-  //SEG12 [7] phi from main::@1 to nest
+  //SEG12 [7] phi from main::@1 to nest [phi:main::@1->nest]
     jsr nest
   //SEG13 main::@3
   b3:
@@ -987,13 +987,13 @@ main: {
 }
 //SEG18 nest
 nest: {
-  //SEG19 [8] phi from nest to nest::@1
+  //SEG19 [8] phi from nest to nest::@1 [phi:nest->nest::@1]
   b1_from_nest:
-  //SEG20 [8] phi (byte) nest::j#2 = (byte) 100 -- xby=coby1 
+  //SEG20 [8] phi (byte) nest::j#2 = (byte) 100 [phi:nest->nest::@1#0] -- xby=coby1 
     ldx #$64
     jmp b1
-  //SEG21 [8] phi from nest::@1 to nest::@1
-  //SEG22 [8] phi (byte) nest::j#2 = (byte) nest::j#1 -- register_copy 
+  //SEG21 [8] phi from nest::@1 to nest::@1 [phi:nest::@1->nest::@1]
+  //SEG22 [8] phi (byte) nest::j#2 = (byte) nest::j#1 [phi:nest::@1->nest::@1#0] -- register_copy 
   //SEG23 nest::@1
   b1:
   //SEG24 [9] *((const byte*) SCREEN#0) ← (byte) nest::j#2 [ nest::j#2 ] -- _star_cowo1=xby 
@@ -1022,21 +1022,21 @@ ASSEMBLER
   .const SCREEN = $400
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
 main: {
-  //SEG6 [2] phi from main to main::@1
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 100 -- yby=coby1 
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 100 [phi:main->main::@1#0] -- yby=coby1 
     ldy #$64
     jmp b1
-  //SEG8 [2] phi from main::@3 to main::@1
-  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG8 [2] phi from main::@3 to main::@1 [phi:main::@3->main::@1]
+  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@3->main::@1#0] -- register_copy 
   //SEG10 main::@1
   b1:
   //SEG11 [3] call nest param-assignment [ main::i#2 ]
-  //SEG12 [7] phi from main::@1 to nest
+  //SEG12 [7] phi from main::@1 to nest [phi:main::@1->nest]
     jsr nest
   //SEG13 main::@3
   //SEG14 [4] (byte) main::i#1 ← -- (byte) main::i#2 [ main::i#1 ] -- yby=_dec_yby 
@@ -1050,12 +1050,12 @@ main: {
 }
 //SEG18 nest
 nest: {
-  //SEG19 [8] phi from nest to nest::@1
-  //SEG20 [8] phi (byte) nest::j#2 = (byte) 100 -- xby=coby1 
+  //SEG19 [8] phi from nest to nest::@1 [phi:nest->nest::@1]
+  //SEG20 [8] phi (byte) nest::j#2 = (byte) 100 [phi:nest->nest::@1#0] -- xby=coby1 
     ldx #$64
     jmp b1
-  //SEG21 [8] phi from nest::@1 to nest::@1
-  //SEG22 [8] phi (byte) nest::j#2 = (byte) nest::j#1 -- register_copy 
+  //SEG21 [8] phi from nest::@1 to nest::@1 [phi:nest::@1->nest::@1]
+  //SEG22 [8] phi (byte) nest::j#2 = (byte) nest::j#1 [phi:nest::@1->nest::@1#0] -- register_copy 
   //SEG23 nest::@1
   b1:
   //SEG24 [9] *((const byte*) SCREEN#0) ← (byte) nest::j#2 [ nest::j#2 ] -- _star_cowo1=xby 
@@ -1078,20 +1078,20 @@ ASSEMBLER
   .const SCREEN = $400
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
 main: {
-  //SEG6 [2] phi from main to main::@1
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 100 -- yby=coby1 
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 100 [phi:main->main::@1#0] -- yby=coby1 
     ldy #$64
-  //SEG8 [2] phi from main::@3 to main::@1
-  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG8 [2] phi from main::@3 to main::@1 [phi:main::@3->main::@1]
+  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@3->main::@1#0] -- register_copy 
   //SEG10 main::@1
   b1:
   //SEG11 [3] call nest param-assignment [ main::i#2 ]
-  //SEG12 [7] phi from main::@1 to nest
+  //SEG12 [7] phi from main::@1 to nest [phi:main::@1->nest]
     jsr nest
   //SEG13 main::@3
   //SEG14 [4] (byte) main::i#1 ← -- (byte) main::i#2 [ main::i#1 ] -- yby=_dec_yby 
@@ -1105,11 +1105,11 @@ main: {
 }
 //SEG18 nest
 nest: {
-  //SEG19 [8] phi from nest to nest::@1
-  //SEG20 [8] phi (byte) nest::j#2 = (byte) 100 -- xby=coby1 
+  //SEG19 [8] phi from nest to nest::@1 [phi:nest->nest::@1]
+  //SEG20 [8] phi (byte) nest::j#2 = (byte) 100 [phi:nest->nest::@1#0] -- xby=coby1 
     ldx #$64
-  //SEG21 [8] phi from nest::@1 to nest::@1
-  //SEG22 [8] phi (byte) nest::j#2 = (byte) nest::j#1 -- register_copy 
+  //SEG21 [8] phi from nest::@1 to nest::@1 [phi:nest::@1->nest::@1]
+  //SEG22 [8] phi (byte) nest::j#2 = (byte) nest::j#1 [phi:nest::@1->nest::@1#0] -- register_copy 
   //SEG23 nest::@1
   b1:
   //SEG24 [9] *((const byte*) SCREEN#0) ← (byte) nest::j#2 [ nest::j#2 ] -- _star_cowo1=xby 
@@ -1151,20 +1151,20 @@ FINAL CODE
   .const SCREEN = $400
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
 main: {
-  //SEG6 [2] phi from main to main::@1
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 100 -- yby=coby1 
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 100 [phi:main->main::@1#0] -- yby=coby1 
     ldy #$64
-  //SEG8 [2] phi from main::@3 to main::@1
-  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG8 [2] phi from main::@3 to main::@1 [phi:main::@3->main::@1]
+  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@3->main::@1#0] -- register_copy 
   //SEG10 main::@1
   b1:
   //SEG11 [3] call nest param-assignment [ main::i#2 ]
-  //SEG12 [7] phi from main::@1 to nest
+  //SEG12 [7] phi from main::@1 to nest [phi:main::@1->nest]
     jsr nest
   //SEG13 main::@3
   //SEG14 [4] (byte) main::i#1 ← -- (byte) main::i#2 [ main::i#1 ] -- yby=_dec_yby 
@@ -1178,11 +1178,11 @@ main: {
 }
 //SEG18 nest
 nest: {
-  //SEG19 [8] phi from nest to nest::@1
-  //SEG20 [8] phi (byte) nest::j#2 = (byte) 100 -- xby=coby1 
+  //SEG19 [8] phi from nest to nest::@1 [phi:nest->nest::@1]
+  //SEG20 [8] phi (byte) nest::j#2 = (byte) 100 [phi:nest->nest::@1#0] -- xby=coby1 
     ldx #$64
-  //SEG21 [8] phi from nest::@1 to nest::@1
-  //SEG22 [8] phi (byte) nest::j#2 = (byte) nest::j#1 -- register_copy 
+  //SEG21 [8] phi from nest::@1 to nest::@1 [phi:nest::@1->nest::@1]
+  //SEG22 [8] phi (byte) nest::j#2 = (byte) nest::j#1 [phi:nest::@1->nest::@1#0] -- register_copy 
   //SEG23 nest::@1
   b1:
   //SEG24 [9] *((const byte*) SCREEN#0) ← (byte) nest::j#2 [ nest::j#2 ] -- _star_cowo1=xby 

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

@@ -1948,7 +1948,7 @@ INITIAL ASM
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
 main_from_bbegin:
   jsr main
   jmp bend
@@ -1958,32 +1958,32 @@ bend:
 main: {
     .label j = 3
     .label i = 2
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 100 -- zpby1=coby1 
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 100 [phi:main->main::@1#0] -- zpby1=coby1 
     lda #$64
     sta i
     jmp b1
-  //SEG8 [2] phi from main::@3 to main::@1
+  //SEG8 [2] phi from main::@3 to main::@1 [phi:main::@3->main::@1]
   b1_from_b3:
-  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@3->main::@1#0] -- register_copy 
     jmp b1
   //SEG10 main::@1
   b1:
-  //SEG11 [3] phi from main::@1 to main::@2
+  //SEG11 [3] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
   b2_from_b1:
-  //SEG12 [3] phi (byte) main::j#2 = (byte) 100 -- zpby1=coby1 
+  //SEG12 [3] phi (byte) main::j#2 = (byte) 100 [phi:main::@1->main::@2#0] -- zpby1=coby1 
     lda #$64
     sta j
     jmp b2
-  //SEG13 [3] phi from main::@5 to main::@2
+  //SEG13 [3] phi from main::@5 to main::@2 [phi:main::@5->main::@2]
   b2_from_b5:
-  //SEG14 [3] phi (byte) main::j#2 = (byte) main::j#1 -- register_copy 
+  //SEG14 [3] phi (byte) main::j#2 = (byte) main::j#1 [phi:main::@5->main::@2#0] -- register_copy 
     jmp b2
   //SEG15 main::@2
   b2:
   //SEG16 [4] call nest1 param-assignment [ main::i#2 main::j#2 ]
-  //SEG17 [10] phi from main::@2 to nest1
+  //SEG17 [10] phi from main::@2 to nest1 [phi:main::@2->nest1]
   nest1_from_b2:
     jsr nest1
     jmp b5
@@ -2012,32 +2012,32 @@ main: {
 nest1: {
     .label j = 5
     .label i = 4
-  //SEG27 [11] phi from nest1 to nest1::@1
+  //SEG27 [11] phi from nest1 to nest1::@1 [phi:nest1->nest1::@1]
   b1_from_nest1:
-  //SEG28 [11] phi (byte) nest1::i#2 = (byte) 100 -- zpby1=coby1 
+  //SEG28 [11] phi (byte) nest1::i#2 = (byte) 100 [phi:nest1->nest1::@1#0] -- zpby1=coby1 
     lda #$64
     sta i
     jmp b1
-  //SEG29 [11] phi from nest1::@3 to nest1::@1
+  //SEG29 [11] phi from nest1::@3 to nest1::@1 [phi:nest1::@3->nest1::@1]
   b1_from_b3:
-  //SEG30 [11] phi (byte) nest1::i#2 = (byte) nest1::i#1 -- register_copy 
+  //SEG30 [11] phi (byte) nest1::i#2 = (byte) nest1::i#1 [phi:nest1::@3->nest1::@1#0] -- register_copy 
     jmp b1
   //SEG31 nest1::@1
   b1:
-  //SEG32 [12] phi from nest1::@1 to nest1::@2
+  //SEG32 [12] phi from nest1::@1 to nest1::@2 [phi:nest1::@1->nest1::@2]
   b2_from_b1:
-  //SEG33 [12] phi (byte) nest1::j#2 = (byte) 100 -- zpby1=coby1 
+  //SEG33 [12] phi (byte) nest1::j#2 = (byte) 100 [phi:nest1::@1->nest1::@2#0] -- zpby1=coby1 
     lda #$64
     sta j
     jmp b2
-  //SEG34 [12] phi from nest1::@5 to nest1::@2
+  //SEG34 [12] phi from nest1::@5 to nest1::@2 [phi:nest1::@5->nest1::@2]
   b2_from_b5:
-  //SEG35 [12] phi (byte) nest1::j#2 = (byte) nest1::j#1 -- register_copy 
+  //SEG35 [12] phi (byte) nest1::j#2 = (byte) nest1::j#1 [phi:nest1::@5->nest1::@2#0] -- register_copy 
     jmp b2
   //SEG36 nest1::@2
   b2:
   //SEG37 [13] call nest2 param-assignment [ nest1::i#2 nest1::j#2 ]
-  //SEG38 [19] phi from nest1::@2 to nest2
+  //SEG38 [19] phi from nest1::@2 to nest2 [phi:nest1::@2->nest2]
   nest2_from_b2:
     jsr nest2
     jmp b5
@@ -2066,27 +2066,27 @@ nest1: {
 nest2: {
     .label j = 7
     .label i = 6
-  //SEG48 [20] phi from nest2 to nest2::@1
+  //SEG48 [20] phi from nest2 to nest2::@1 [phi:nest2->nest2::@1]
   b1_from_nest2:
-  //SEG49 [20] phi (byte) nest2::i#2 = (byte) 100 -- zpby1=coby1 
+  //SEG49 [20] phi (byte) nest2::i#2 = (byte) 100 [phi:nest2->nest2::@1#0] -- zpby1=coby1 
     lda #$64
     sta i
     jmp b1
-  //SEG50 [20] phi from nest2::@3 to nest2::@1
+  //SEG50 [20] phi from nest2::@3 to nest2::@1 [phi:nest2::@3->nest2::@1]
   b1_from_b3:
-  //SEG51 [20] phi (byte) nest2::i#2 = (byte) nest2::i#1 -- register_copy 
+  //SEG51 [20] phi (byte) nest2::i#2 = (byte) nest2::i#1 [phi:nest2::@3->nest2::@1#0] -- register_copy 
     jmp b1
   //SEG52 nest2::@1
   b1:
-  //SEG53 [21] phi from nest2::@1 to nest2::@2
+  //SEG53 [21] phi from nest2::@1 to nest2::@2 [phi:nest2::@1->nest2::@2]
   b2_from_b1:
-  //SEG54 [21] phi (byte) nest2::j#2 = (byte) 100 -- zpby1=coby1 
+  //SEG54 [21] phi (byte) nest2::j#2 = (byte) 100 [phi:nest2::@1->nest2::@2#0] -- zpby1=coby1 
     lda #$64
     sta j
     jmp b2
-  //SEG55 [21] phi from nest2::@2 to nest2::@2
+  //SEG55 [21] phi from nest2::@2 to nest2::@2 [phi:nest2::@2->nest2::@2]
   b2_from_b2:
-  //SEG56 [21] phi (byte) nest2::j#2 = (byte) nest2::j#1 -- register_copy 
+  //SEG56 [21] phi (byte) nest2::j#2 = (byte) nest2::j#1 [phi:nest2::@2->nest2::@2#0] -- register_copy 
     jmp b2
   //SEG57 nest2::@2
   b2:
@@ -2159,7 +2159,7 @@ ASSEMBLER
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
 main_from_bbegin:
   jsr main
 //SEG4 @end
@@ -2168,30 +2168,30 @@ bend:
 main: {
     .label j = 3
     .label i = 2
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 100 -- zpby1=coby1 
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 100 [phi:main->main::@1#0] -- zpby1=coby1 
     lda #$64
     sta i
     jmp b1
-  //SEG8 [2] phi from main::@3 to main::@1
+  //SEG8 [2] phi from main::@3 to main::@1 [phi:main::@3->main::@1]
   b1_from_b3:
-  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@3->main::@1#0] -- register_copy 
   //SEG10 main::@1
   b1:
-  //SEG11 [3] phi from main::@1 to main::@2
+  //SEG11 [3] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
   b2_from_b1:
-  //SEG12 [3] phi (byte) main::j#2 = (byte) 100 -- zpby1=coby1 
+  //SEG12 [3] phi (byte) main::j#2 = (byte) 100 [phi:main::@1->main::@2#0] -- zpby1=coby1 
     lda #$64
     sta j
     jmp b2
-  //SEG13 [3] phi from main::@5 to main::@2
+  //SEG13 [3] phi from main::@5 to main::@2 [phi:main::@5->main::@2]
   b2_from_b5:
-  //SEG14 [3] phi (byte) main::j#2 = (byte) main::j#1 -- register_copy 
+  //SEG14 [3] phi (byte) main::j#2 = (byte) main::j#1 [phi:main::@5->main::@2#0] -- register_copy 
   //SEG15 main::@2
   b2:
   //SEG16 [4] call nest1 param-assignment [ main::i#2 main::j#2 ]
-  //SEG17 [10] phi from main::@2 to nest1
+  //SEG17 [10] phi from main::@2 to nest1 [phi:main::@2->nest1]
   nest1_from_b2:
     jsr nest1
   //SEG18 main::@5
@@ -2216,29 +2216,29 @@ main: {
 //SEG26 nest1
 nest1: {
     .label i = 4
-  //SEG27 [11] phi from nest1 to nest1::@1
+  //SEG27 [11] phi from nest1 to nest1::@1 [phi:nest1->nest1::@1]
   b1_from_nest1:
-  //SEG28 [11] phi (byte) nest1::i#2 = (byte) 100 -- zpby1=coby1 
+  //SEG28 [11] phi (byte) nest1::i#2 = (byte) 100 [phi:nest1->nest1::@1#0] -- zpby1=coby1 
     lda #$64
     sta i
     jmp b1
-  //SEG29 [11] phi from nest1::@3 to nest1::@1
+  //SEG29 [11] phi from nest1::@3 to nest1::@1 [phi:nest1::@3->nest1::@1]
   b1_from_b3:
-  //SEG30 [11] phi (byte) nest1::i#2 = (byte) nest1::i#1 -- register_copy 
+  //SEG30 [11] phi (byte) nest1::i#2 = (byte) nest1::i#1 [phi:nest1::@3->nest1::@1#0] -- register_copy 
   //SEG31 nest1::@1
   b1:
-  //SEG32 [12] phi from nest1::@1 to nest1::@2
+  //SEG32 [12] phi from nest1::@1 to nest1::@2 [phi:nest1::@1->nest1::@2]
   b2_from_b1:
-  //SEG33 [12] phi (byte) nest1::j#2 = (byte) 100 -- aby=coby1 
+  //SEG33 [12] phi (byte) nest1::j#2 = (byte) 100 [phi:nest1::@1->nest1::@2#0] -- aby=coby1 
     lda #$64
     jmp b2
-  //SEG34 [12] phi from nest1::@5 to nest1::@2
+  //SEG34 [12] phi from nest1::@5 to nest1::@2 [phi:nest1::@5->nest1::@2]
   b2_from_b5:
-  //SEG35 [12] phi (byte) nest1::j#2 = (byte) nest1::j#1 -- register_copy 
+  //SEG35 [12] phi (byte) nest1::j#2 = (byte) nest1::j#1 [phi:nest1::@5->nest1::@2#0] -- register_copy 
   //SEG36 nest1::@2
   b2:
   //SEG37 [13] call nest2 param-assignment [ nest1::i#2 nest1::j#2 ]
-  //SEG38 [19] phi from nest1::@2 to nest2
+  //SEG38 [19] phi from nest1::@2 to nest2 [phi:nest1::@2->nest2]
   nest2_from_b2:
     jsr nest2
   //SEG39 nest1::@5
@@ -2263,24 +2263,24 @@ nest1: {
 }
 //SEG47 nest2
 nest2: {
-  //SEG48 [20] phi from nest2 to nest2::@1
+  //SEG48 [20] phi from nest2 to nest2::@1 [phi:nest2->nest2::@1]
   b1_from_nest2:
-  //SEG49 [20] phi (byte) nest2::i#2 = (byte) 100 -- xby=coby1 
+  //SEG49 [20] phi (byte) nest2::i#2 = (byte) 100 [phi:nest2->nest2::@1#0] -- xby=coby1 
     ldx #$64
     jmp b1
-  //SEG50 [20] phi from nest2::@3 to nest2::@1
+  //SEG50 [20] phi from nest2::@3 to nest2::@1 [phi:nest2::@3->nest2::@1]
   b1_from_b3:
-  //SEG51 [20] phi (byte) nest2::i#2 = (byte) nest2::i#1 -- register_copy 
+  //SEG51 [20] phi (byte) nest2::i#2 = (byte) nest2::i#1 [phi:nest2::@3->nest2::@1#0] -- register_copy 
   //SEG52 nest2::@1
   b1:
-  //SEG53 [21] phi from nest2::@1 to nest2::@2
+  //SEG53 [21] phi from nest2::@1 to nest2::@2 [phi:nest2::@1->nest2::@2]
   b2_from_b1:
-  //SEG54 [21] phi (byte) nest2::j#2 = (byte) 100 -- yby=coby1 
+  //SEG54 [21] phi (byte) nest2::j#2 = (byte) 100 [phi:nest2::@1->nest2::@2#0] -- yby=coby1 
     ldy #$64
     jmp b2
-  //SEG55 [21] phi from nest2::@2 to nest2::@2
+  //SEG55 [21] phi from nest2::@2 to nest2::@2 [phi:nest2::@2->nest2::@2]
   b2_from_b2:
-  //SEG56 [21] phi (byte) nest2::j#2 = (byte) nest2::j#1 -- register_copy 
+  //SEG56 [21] phi (byte) nest2::j#2 = (byte) nest2::j#1 [phi:nest2::@2->nest2::@2#0] -- register_copy 
   //SEG57 nest2::@2
   b2:
   //SEG58 [22] *((const byte*) SCREEN#0) ← (byte) nest2::j#2 [ nest2::i#2 nest2::j#2 ] -- _star_cowo1=yby 
@@ -2328,7 +2328,7 @@ ASSEMBLER
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 bend:
@@ -2336,27 +2336,27 @@ bend:
 main: {
     .label j = 3
     .label i = 2
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 100 -- zpby1=coby1 
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 100 [phi:main->main::@1#0] -- zpby1=coby1 
     lda #$64
     sta i
     jmp b1
-  //SEG8 [2] phi from main::@3 to main::@1
-  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG8 [2] phi from main::@3 to main::@1 [phi:main::@3->main::@1]
+  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@3->main::@1#0] -- register_copy 
   //SEG10 main::@1
   b1:
-  //SEG11 [3] phi from main::@1 to main::@2
-  //SEG12 [3] phi (byte) main::j#2 = (byte) 100 -- zpby1=coby1 
+  //SEG11 [3] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
+  //SEG12 [3] phi (byte) main::j#2 = (byte) 100 [phi:main::@1->main::@2#0] -- zpby1=coby1 
     lda #$64
     sta j
     jmp b2
-  //SEG13 [3] phi from main::@5 to main::@2
-  //SEG14 [3] phi (byte) main::j#2 = (byte) main::j#1 -- register_copy 
+  //SEG13 [3] phi from main::@5 to main::@2 [phi:main::@5->main::@2]
+  //SEG14 [3] phi (byte) main::j#2 = (byte) main::j#1 [phi:main::@5->main::@2#0] -- register_copy 
   //SEG15 main::@2
   b2:
   //SEG16 [4] call nest1 param-assignment [ main::i#2 main::j#2 ]
-  //SEG17 [10] phi from main::@2 to nest1
+  //SEG17 [10] phi from main::@2 to nest1 [phi:main::@2->nest1]
     jsr nest1
   //SEG18 main::@5
   b5:
@@ -2380,26 +2380,26 @@ main: {
 //SEG26 nest1
 nest1: {
     .label i = 4
-  //SEG27 [11] phi from nest1 to nest1::@1
+  //SEG27 [11] phi from nest1 to nest1::@1 [phi:nest1->nest1::@1]
   b1_from_nest1:
-  //SEG28 [11] phi (byte) nest1::i#2 = (byte) 100 -- zpby1=coby1 
+  //SEG28 [11] phi (byte) nest1::i#2 = (byte) 100 [phi:nest1->nest1::@1#0] -- zpby1=coby1 
     lda #$64
     sta i
     jmp b1
-  //SEG29 [11] phi from nest1::@3 to nest1::@1
-  //SEG30 [11] phi (byte) nest1::i#2 = (byte) nest1::i#1 -- register_copy 
+  //SEG29 [11] phi from nest1::@3 to nest1::@1 [phi:nest1::@3->nest1::@1]
+  //SEG30 [11] phi (byte) nest1::i#2 = (byte) nest1::i#1 [phi:nest1::@3->nest1::@1#0] -- register_copy 
   //SEG31 nest1::@1
   b1:
-  //SEG32 [12] phi from nest1::@1 to nest1::@2
-  //SEG33 [12] phi (byte) nest1::j#2 = (byte) 100 -- aby=coby1 
+  //SEG32 [12] phi from nest1::@1 to nest1::@2 [phi:nest1::@1->nest1::@2]
+  //SEG33 [12] phi (byte) nest1::j#2 = (byte) 100 [phi:nest1::@1->nest1::@2#0] -- aby=coby1 
     lda #$64
     jmp b2
-  //SEG34 [12] phi from nest1::@5 to nest1::@2
-  //SEG35 [12] phi (byte) nest1::j#2 = (byte) nest1::j#1 -- register_copy 
+  //SEG34 [12] phi from nest1::@5 to nest1::@2 [phi:nest1::@5->nest1::@2]
+  //SEG35 [12] phi (byte) nest1::j#2 = (byte) nest1::j#1 [phi:nest1::@5->nest1::@2#0] -- register_copy 
   //SEG36 nest1::@2
   b2:
   //SEG37 [13] call nest2 param-assignment [ nest1::i#2 nest1::j#2 ]
-  //SEG38 [19] phi from nest1::@2 to nest2
+  //SEG38 [19] phi from nest1::@2 to nest2 [phi:nest1::@2->nest2]
     jsr nest2
   //SEG39 nest1::@5
   b5:
@@ -2423,21 +2423,21 @@ nest1: {
 }
 //SEG47 nest2
 nest2: {
-  //SEG48 [20] phi from nest2 to nest2::@1
+  //SEG48 [20] phi from nest2 to nest2::@1 [phi:nest2->nest2::@1]
   b1_from_nest2:
-  //SEG49 [20] phi (byte) nest2::i#2 = (byte) 100 -- xby=coby1 
+  //SEG49 [20] phi (byte) nest2::i#2 = (byte) 100 [phi:nest2->nest2::@1#0] -- xby=coby1 
     ldx #$64
     jmp b1
-  //SEG50 [20] phi from nest2::@3 to nest2::@1
-  //SEG51 [20] phi (byte) nest2::i#2 = (byte) nest2::i#1 -- register_copy 
+  //SEG50 [20] phi from nest2::@3 to nest2::@1 [phi:nest2::@3->nest2::@1]
+  //SEG51 [20] phi (byte) nest2::i#2 = (byte) nest2::i#1 [phi:nest2::@3->nest2::@1#0] -- register_copy 
   //SEG52 nest2::@1
   b1:
-  //SEG53 [21] phi from nest2::@1 to nest2::@2
-  //SEG54 [21] phi (byte) nest2::j#2 = (byte) 100 -- yby=coby1 
+  //SEG53 [21] phi from nest2::@1 to nest2::@2 [phi:nest2::@1->nest2::@2]
+  //SEG54 [21] phi (byte) nest2::j#2 = (byte) 100 [phi:nest2::@1->nest2::@2#0] -- yby=coby1 
     ldy #$64
     jmp b2
-  //SEG55 [21] phi from nest2::@2 to nest2::@2
-  //SEG56 [21] phi (byte) nest2::j#2 = (byte) nest2::j#1 -- register_copy 
+  //SEG55 [21] phi from nest2::@2 to nest2::@2 [phi:nest2::@2->nest2::@2]
+  //SEG56 [21] phi (byte) nest2::j#2 = (byte) nest2::j#1 [phi:nest2::@2->nest2::@2#0] -- register_copy 
   //SEG57 nest2::@2
   b2:
   //SEG58 [22] *((const byte*) SCREEN#0) ← (byte) nest2::j#2 [ nest2::i#2 nest2::j#2 ] -- _star_cowo1=yby 
@@ -2479,33 +2479,33 @@ ASSEMBLER
   .const SCREEN = $400
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
 main: {
     .label j = 3
     .label i = 2
-  //SEG6 [2] phi from main to main::@1
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 100 -- zpby1=coby1 
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 100 [phi:main->main::@1#0] -- zpby1=coby1 
     lda #$64
     sta i
     jmp b1
-  //SEG8 [2] phi from main::@3 to main::@1
-  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG8 [2] phi from main::@3 to main::@1 [phi:main::@3->main::@1]
+  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@3->main::@1#0] -- register_copy 
   //SEG10 main::@1
   b1:
-  //SEG11 [3] phi from main::@1 to main::@2
-  //SEG12 [3] phi (byte) main::j#2 = (byte) 100 -- zpby1=coby1 
+  //SEG11 [3] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
+  //SEG12 [3] phi (byte) main::j#2 = (byte) 100 [phi:main::@1->main::@2#0] -- zpby1=coby1 
     lda #$64
     sta j
     jmp b2
-  //SEG13 [3] phi from main::@5 to main::@2
-  //SEG14 [3] phi (byte) main::j#2 = (byte) main::j#1 -- register_copy 
+  //SEG13 [3] phi from main::@5 to main::@2 [phi:main::@5->main::@2]
+  //SEG14 [3] phi (byte) main::j#2 = (byte) main::j#1 [phi:main::@5->main::@2#0] -- register_copy 
   //SEG15 main::@2
   b2:
   //SEG16 [4] call nest1 param-assignment [ main::i#2 main::j#2 ]
-  //SEG17 [10] phi from main::@2 to nest1
+  //SEG17 [10] phi from main::@2 to nest1 [phi:main::@2->nest1]
     jsr nest1
   //SEG18 main::@5
   //SEG19 [5] (byte) main::j#1 ← -- (byte) main::j#2 [ main::i#2 main::j#1 ] -- zpby1=_dec_zpby1 
@@ -2526,25 +2526,25 @@ main: {
 //SEG26 nest1
 nest1: {
     .label i = 4
-  //SEG27 [11] phi from nest1 to nest1::@1
-  //SEG28 [11] phi (byte) nest1::i#2 = (byte) 100 -- zpby1=coby1 
+  //SEG27 [11] phi from nest1 to nest1::@1 [phi:nest1->nest1::@1]
+  //SEG28 [11] phi (byte) nest1::i#2 = (byte) 100 [phi:nest1->nest1::@1#0] -- zpby1=coby1 
     lda #$64
     sta i
     jmp b1
-  //SEG29 [11] phi from nest1::@3 to nest1::@1
-  //SEG30 [11] phi (byte) nest1::i#2 = (byte) nest1::i#1 -- register_copy 
+  //SEG29 [11] phi from nest1::@3 to nest1::@1 [phi:nest1::@3->nest1::@1]
+  //SEG30 [11] phi (byte) nest1::i#2 = (byte) nest1::i#1 [phi:nest1::@3->nest1::@1#0] -- register_copy 
   //SEG31 nest1::@1
   b1:
-  //SEG32 [12] phi from nest1::@1 to nest1::@2
-  //SEG33 [12] phi (byte) nest1::j#2 = (byte) 100 -- aby=coby1 
+  //SEG32 [12] phi from nest1::@1 to nest1::@2 [phi:nest1::@1->nest1::@2]
+  //SEG33 [12] phi (byte) nest1::j#2 = (byte) 100 [phi:nest1::@1->nest1::@2#0] -- aby=coby1 
     lda #$64
     jmp b2
-  //SEG34 [12] phi from nest1::@5 to nest1::@2
-  //SEG35 [12] phi (byte) nest1::j#2 = (byte) nest1::j#1 -- register_copy 
+  //SEG34 [12] phi from nest1::@5 to nest1::@2 [phi:nest1::@5->nest1::@2]
+  //SEG35 [12] phi (byte) nest1::j#2 = (byte) nest1::j#1 [phi:nest1::@5->nest1::@2#0] -- register_copy 
   //SEG36 nest1::@2
   b2:
   //SEG37 [13] call nest2 param-assignment [ nest1::i#2 nest1::j#2 ]
-  //SEG38 [19] phi from nest1::@2 to nest2
+  //SEG38 [19] phi from nest1::@2 to nest2 [phi:nest1::@2->nest2]
     jsr nest2
   //SEG39 nest1::@5
   //SEG40 [14] (byte) nest1::j#1 ← -- (byte) nest1::j#2 [ nest1::i#2 nest1::j#1 ] -- aby=_dec_aby 
@@ -2565,20 +2565,20 @@ nest1: {
 }
 //SEG47 nest2
 nest2: {
-  //SEG48 [20] phi from nest2 to nest2::@1
-  //SEG49 [20] phi (byte) nest2::i#2 = (byte) 100 -- xby=coby1 
+  //SEG48 [20] phi from nest2 to nest2::@1 [phi:nest2->nest2::@1]
+  //SEG49 [20] phi (byte) nest2::i#2 = (byte) 100 [phi:nest2->nest2::@1#0] -- xby=coby1 
     ldx #$64
     jmp b1
-  //SEG50 [20] phi from nest2::@3 to nest2::@1
-  //SEG51 [20] phi (byte) nest2::i#2 = (byte) nest2::i#1 -- register_copy 
+  //SEG50 [20] phi from nest2::@3 to nest2::@1 [phi:nest2::@3->nest2::@1]
+  //SEG51 [20] phi (byte) nest2::i#2 = (byte) nest2::i#1 [phi:nest2::@3->nest2::@1#0] -- register_copy 
   //SEG52 nest2::@1
   b1:
-  //SEG53 [21] phi from nest2::@1 to nest2::@2
-  //SEG54 [21] phi (byte) nest2::j#2 = (byte) 100 -- yby=coby1 
+  //SEG53 [21] phi from nest2::@1 to nest2::@2 [phi:nest2::@1->nest2::@2]
+  //SEG54 [21] phi (byte) nest2::j#2 = (byte) 100 [phi:nest2::@1->nest2::@2#0] -- yby=coby1 
     ldy #$64
     jmp b2
-  //SEG55 [21] phi from nest2::@2 to nest2::@2
-  //SEG56 [21] phi (byte) nest2::j#2 = (byte) nest2::j#1 -- register_copy 
+  //SEG55 [21] phi from nest2::@2 to nest2::@2 [phi:nest2::@2->nest2::@2]
+  //SEG56 [21] phi (byte) nest2::j#2 = (byte) nest2::j#1 [phi:nest2::@2->nest2::@2#0] -- register_copy 
   //SEG57 nest2::@2
   b2:
   //SEG58 [22] *((const byte*) SCREEN#0) ← (byte) nest2::j#2 [ nest2::i#2 nest2::j#2 ] -- _star_cowo1=yby 
@@ -2611,31 +2611,31 @@ ASSEMBLER
   .const SCREEN = $400
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
 main: {
     .label j = 3
     .label i = 2
-  //SEG6 [2] phi from main to main::@1
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 100 -- zpby1=coby1 
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 100 [phi:main->main::@1#0] -- zpby1=coby1 
     lda #$64
     sta i
-  //SEG8 [2] phi from main::@3 to main::@1
-  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG8 [2] phi from main::@3 to main::@1 [phi:main::@3->main::@1]
+  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@3->main::@1#0] -- register_copy 
   //SEG10 main::@1
   b1:
-  //SEG11 [3] phi from main::@1 to main::@2
-  //SEG12 [3] phi (byte) main::j#2 = (byte) 100 -- zpby1=coby1 
+  //SEG11 [3] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
+  //SEG12 [3] phi (byte) main::j#2 = (byte) 100 [phi:main::@1->main::@2#0] -- zpby1=coby1 
     lda #$64
     sta j
-  //SEG13 [3] phi from main::@5 to main::@2
-  //SEG14 [3] phi (byte) main::j#2 = (byte) main::j#1 -- register_copy 
+  //SEG13 [3] phi from main::@5 to main::@2 [phi:main::@5->main::@2]
+  //SEG14 [3] phi (byte) main::j#2 = (byte) main::j#1 [phi:main::@5->main::@2#0] -- register_copy 
   //SEG15 main::@2
   b2:
   //SEG16 [4] call nest1 param-assignment [ main::i#2 main::j#2 ]
-  //SEG17 [10] phi from main::@2 to nest1
+  //SEG17 [10] phi from main::@2 to nest1 [phi:main::@2->nest1]
     jsr nest1
   //SEG18 main::@5
   //SEG19 [5] (byte) main::j#1 ← -- (byte) main::j#2 [ main::i#2 main::j#1 ] -- zpby1=_dec_zpby1 
@@ -2656,23 +2656,23 @@ main: {
 //SEG26 nest1
 nest1: {
     .label i = 4
-  //SEG27 [11] phi from nest1 to nest1::@1
-  //SEG28 [11] phi (byte) nest1::i#2 = (byte) 100 -- zpby1=coby1 
+  //SEG27 [11] phi from nest1 to nest1::@1 [phi:nest1->nest1::@1]
+  //SEG28 [11] phi (byte) nest1::i#2 = (byte) 100 [phi:nest1->nest1::@1#0] -- zpby1=coby1 
     lda #$64
     sta i
-  //SEG29 [11] phi from nest1::@3 to nest1::@1
-  //SEG30 [11] phi (byte) nest1::i#2 = (byte) nest1::i#1 -- register_copy 
+  //SEG29 [11] phi from nest1::@3 to nest1::@1 [phi:nest1::@3->nest1::@1]
+  //SEG30 [11] phi (byte) nest1::i#2 = (byte) nest1::i#1 [phi:nest1::@3->nest1::@1#0] -- register_copy 
   //SEG31 nest1::@1
   b1:
-  //SEG32 [12] phi from nest1::@1 to nest1::@2
-  //SEG33 [12] phi (byte) nest1::j#2 = (byte) 100 -- aby=coby1 
+  //SEG32 [12] phi from nest1::@1 to nest1::@2 [phi:nest1::@1->nest1::@2]
+  //SEG33 [12] phi (byte) nest1::j#2 = (byte) 100 [phi:nest1::@1->nest1::@2#0] -- aby=coby1 
     lda #$64
-  //SEG34 [12] phi from nest1::@5 to nest1::@2
-  //SEG35 [12] phi (byte) nest1::j#2 = (byte) nest1::j#1 -- register_copy 
+  //SEG34 [12] phi from nest1::@5 to nest1::@2 [phi:nest1::@5->nest1::@2]
+  //SEG35 [12] phi (byte) nest1::j#2 = (byte) nest1::j#1 [phi:nest1::@5->nest1::@2#0] -- register_copy 
   //SEG36 nest1::@2
   b2:
   //SEG37 [13] call nest2 param-assignment [ nest1::i#2 nest1::j#2 ]
-  //SEG38 [19] phi from nest1::@2 to nest2
+  //SEG38 [19] phi from nest1::@2 to nest2 [phi:nest1::@2->nest2]
     jsr nest2
   //SEG39 nest1::@5
   //SEG40 [14] (byte) nest1::j#1 ← -- (byte) nest1::j#2 [ nest1::i#2 nest1::j#1 ] -- aby=_dec_aby 
@@ -2693,18 +2693,18 @@ nest1: {
 }
 //SEG47 nest2
 nest2: {
-  //SEG48 [20] phi from nest2 to nest2::@1
-  //SEG49 [20] phi (byte) nest2::i#2 = (byte) 100 -- xby=coby1 
+  //SEG48 [20] phi from nest2 to nest2::@1 [phi:nest2->nest2::@1]
+  //SEG49 [20] phi (byte) nest2::i#2 = (byte) 100 [phi:nest2->nest2::@1#0] -- xby=coby1 
     ldx #$64
-  //SEG50 [20] phi from nest2::@3 to nest2::@1
-  //SEG51 [20] phi (byte) nest2::i#2 = (byte) nest2::i#1 -- register_copy 
+  //SEG50 [20] phi from nest2::@3 to nest2::@1 [phi:nest2::@3->nest2::@1]
+  //SEG51 [20] phi (byte) nest2::i#2 = (byte) nest2::i#1 [phi:nest2::@3->nest2::@1#0] -- register_copy 
   //SEG52 nest2::@1
   b1:
-  //SEG53 [21] phi from nest2::@1 to nest2::@2
-  //SEG54 [21] phi (byte) nest2::j#2 = (byte) 100 -- yby=coby1 
+  //SEG53 [21] phi from nest2::@1 to nest2::@2 [phi:nest2::@1->nest2::@2]
+  //SEG54 [21] phi (byte) nest2::j#2 = (byte) 100 [phi:nest2::@1->nest2::@2#0] -- yby=coby1 
     ldy #$64
-  //SEG55 [21] phi from nest2::@2 to nest2::@2
-  //SEG56 [21] phi (byte) nest2::j#2 = (byte) nest2::j#1 -- register_copy 
+  //SEG55 [21] phi from nest2::@2 to nest2::@2 [phi:nest2::@2->nest2::@2]
+  //SEG56 [21] phi (byte) nest2::j#2 = (byte) nest2::j#1 [phi:nest2::@2->nest2::@2#0] -- register_copy 
   //SEG57 nest2::@2
   b2:
   //SEG58 [22] *((const byte*) SCREEN#0) ← (byte) nest2::j#2 [ nest2::i#2 nest2::j#2 ] -- _star_cowo1=yby 
@@ -2778,31 +2778,31 @@ FINAL CODE
   .const SCREEN = $400
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
 main: {
     .label j = 3
     .label i = 2
-  //SEG6 [2] phi from main to main::@1
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 100 -- zpby1=coby1 
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 100 [phi:main->main::@1#0] -- zpby1=coby1 
     lda #$64
     sta i
-  //SEG8 [2] phi from main::@3 to main::@1
-  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG8 [2] phi from main::@3 to main::@1 [phi:main::@3->main::@1]
+  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@3->main::@1#0] -- register_copy 
   //SEG10 main::@1
   b1:
-  //SEG11 [3] phi from main::@1 to main::@2
-  //SEG12 [3] phi (byte) main::j#2 = (byte) 100 -- zpby1=coby1 
+  //SEG11 [3] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
+  //SEG12 [3] phi (byte) main::j#2 = (byte) 100 [phi:main::@1->main::@2#0] -- zpby1=coby1 
     lda #$64
     sta j
-  //SEG13 [3] phi from main::@5 to main::@2
-  //SEG14 [3] phi (byte) main::j#2 = (byte) main::j#1 -- register_copy 
+  //SEG13 [3] phi from main::@5 to main::@2 [phi:main::@5->main::@2]
+  //SEG14 [3] phi (byte) main::j#2 = (byte) main::j#1 [phi:main::@5->main::@2#0] -- register_copy 
   //SEG15 main::@2
   b2:
   //SEG16 [4] call nest1 param-assignment [ main::i#2 main::j#2 ]
-  //SEG17 [10] phi from main::@2 to nest1
+  //SEG17 [10] phi from main::@2 to nest1 [phi:main::@2->nest1]
     jsr nest1
   //SEG18 main::@5
   //SEG19 [5] (byte) main::j#1 ← -- (byte) main::j#2 [ main::i#2 main::j#1 ] -- zpby1=_dec_zpby1 
@@ -2823,23 +2823,23 @@ main: {
 //SEG26 nest1
 nest1: {
     .label i = 4
-  //SEG27 [11] phi from nest1 to nest1::@1
-  //SEG28 [11] phi (byte) nest1::i#2 = (byte) 100 -- zpby1=coby1 
+  //SEG27 [11] phi from nest1 to nest1::@1 [phi:nest1->nest1::@1]
+  //SEG28 [11] phi (byte) nest1::i#2 = (byte) 100 [phi:nest1->nest1::@1#0] -- zpby1=coby1 
     lda #$64
     sta i
-  //SEG29 [11] phi from nest1::@3 to nest1::@1
-  //SEG30 [11] phi (byte) nest1::i#2 = (byte) nest1::i#1 -- register_copy 
+  //SEG29 [11] phi from nest1::@3 to nest1::@1 [phi:nest1::@3->nest1::@1]
+  //SEG30 [11] phi (byte) nest1::i#2 = (byte) nest1::i#1 [phi:nest1::@3->nest1::@1#0] -- register_copy 
   //SEG31 nest1::@1
   b1:
-  //SEG32 [12] phi from nest1::@1 to nest1::@2
-  //SEG33 [12] phi (byte) nest1::j#2 = (byte) 100 -- aby=coby1 
+  //SEG32 [12] phi from nest1::@1 to nest1::@2 [phi:nest1::@1->nest1::@2]
+  //SEG33 [12] phi (byte) nest1::j#2 = (byte) 100 [phi:nest1::@1->nest1::@2#0] -- aby=coby1 
     lda #$64
-  //SEG34 [12] phi from nest1::@5 to nest1::@2
-  //SEG35 [12] phi (byte) nest1::j#2 = (byte) nest1::j#1 -- register_copy 
+  //SEG34 [12] phi from nest1::@5 to nest1::@2 [phi:nest1::@5->nest1::@2]
+  //SEG35 [12] phi (byte) nest1::j#2 = (byte) nest1::j#1 [phi:nest1::@5->nest1::@2#0] -- register_copy 
   //SEG36 nest1::@2
   b2:
   //SEG37 [13] call nest2 param-assignment [ nest1::i#2 nest1::j#2 ]
-  //SEG38 [19] phi from nest1::@2 to nest2
+  //SEG38 [19] phi from nest1::@2 to nest2 [phi:nest1::@2->nest2]
     jsr nest2
   //SEG39 nest1::@5
   //SEG40 [14] (byte) nest1::j#1 ← -- (byte) nest1::j#2 [ nest1::i#2 nest1::j#1 ] -- aby=_dec_aby 
@@ -2860,18 +2860,18 @@ nest1: {
 }
 //SEG47 nest2
 nest2: {
-  //SEG48 [20] phi from nest2 to nest2::@1
-  //SEG49 [20] phi (byte) nest2::i#2 = (byte) 100 -- xby=coby1 
+  //SEG48 [20] phi from nest2 to nest2::@1 [phi:nest2->nest2::@1]
+  //SEG49 [20] phi (byte) nest2::i#2 = (byte) 100 [phi:nest2->nest2::@1#0] -- xby=coby1 
     ldx #$64
-  //SEG50 [20] phi from nest2::@3 to nest2::@1
-  //SEG51 [20] phi (byte) nest2::i#2 = (byte) nest2::i#1 -- register_copy 
+  //SEG50 [20] phi from nest2::@3 to nest2::@1 [phi:nest2::@3->nest2::@1]
+  //SEG51 [20] phi (byte) nest2::i#2 = (byte) nest2::i#1 [phi:nest2::@3->nest2::@1#0] -- register_copy 
   //SEG52 nest2::@1
   b1:
-  //SEG53 [21] phi from nest2::@1 to nest2::@2
-  //SEG54 [21] phi (byte) nest2::j#2 = (byte) 100 -- yby=coby1 
+  //SEG53 [21] phi from nest2::@1 to nest2::@2 [phi:nest2::@1->nest2::@2]
+  //SEG54 [21] phi (byte) nest2::j#2 = (byte) 100 [phi:nest2::@1->nest2::@2#0] -- yby=coby1 
     ldy #$64
-  //SEG55 [21] phi from nest2::@2 to nest2::@2
-  //SEG56 [21] phi (byte) nest2::j#2 = (byte) nest2::j#1 -- register_copy 
+  //SEG55 [21] phi from nest2::@2 to nest2::@2 [phi:nest2::@2->nest2::@2]
+  //SEG56 [21] phi (byte) nest2::j#2 = (byte) nest2::j#1 [phi:nest2::@2->nest2::@2#0] -- register_copy 
   //SEG57 nest2::@2
   b2:
   //SEG58 [22] *((const byte*) SCREEN#0) ← (byte) nest2::j#2 [ nest2::i#2 nest2::j#2 ] -- _star_cowo1=yby 

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

@@ -653,7 +653,7 @@ INITIAL ASM
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
 main_from_bbegin:
   jsr main
   jmp bend
@@ -663,12 +663,12 @@ bend:
 main: {
     .label i = 2
     .label s = 3
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte) main::s#3 = (byte) 0 -- zpby1=coby1 
+  //SEG7 [2] phi (byte) main::s#3 = (byte) 0 [phi:main->main::@1#0] -- zpby1=coby1 
     lda #0
     sta s
-  //SEG8 [2] phi (byte) main::i#2 = (byte) 100 -- zpby1=coby1 
+  //SEG8 [2] phi (byte) main::i#2 = (byte) 100 [phi:main->main::@1#1] -- zpby1=coby1 
     lda #$64
     sta i
     jmp b1
@@ -696,11 +696,11 @@ main: {
   b8:
   //SEG17 [7] (byte) main::s#2 ← ++ (byte) main::s#3 [ main::i#1 main::s#2 ] -- zpby1=_inc_zpby1 
     inc s
-  //SEG18 [2] phi from main::@4 main::@8 to main::@1
+  //SEG18 [2] phi from main::@4 main::@8 to main::@1 [phi:main::@4/main::@8->main::@1]
   b1_from_b4:
   b1_from_b8:
-  //SEG19 [2] phi (byte) main::s#3 = (byte) main::s#1 -- register_copy 
-  //SEG20 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG19 [2] phi (byte) main::s#3 = (byte) main::s#1 [phi:main::@4/main::@8->main::@1#0] -- register_copy 
+  //SEG20 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@4/main::@8->main::@1#1] -- register_copy 
     jmp b1
   //SEG21 main::@4
   b4:
@@ -729,18 +729,18 @@ ASSEMBLER
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
 main_from_bbegin:
   jsr main
 //SEG4 @end
 bend:
 //SEG5 main
 main: {
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte) main::s#3 = (byte) 0 -- yby=coby1 
+  //SEG7 [2] phi (byte) main::s#3 = (byte) 0 [phi:main->main::@1#0] -- yby=coby1 
     ldy #0
-  //SEG8 [2] phi (byte) main::i#2 = (byte) 100 -- xby=coby1 
+  //SEG8 [2] phi (byte) main::i#2 = (byte) 100 [phi:main->main::@1#1] -- xby=coby1 
     ldx #$64
   //SEG9 main::@1
   b1:
@@ -763,11 +763,11 @@ main: {
   b8:
   //SEG17 [7] (byte) main::s#2 ← ++ (byte) main::s#3 [ main::i#1 main::s#2 ] -- yby=_inc_yby 
     iny
-  //SEG18 [2] phi from main::@4 main::@8 to main::@1
+  //SEG18 [2] phi from main::@4 main::@8 to main::@1 [phi:main::@4/main::@8->main::@1]
   b1_from_b4:
   b1_from_b8:
-  //SEG19 [2] phi (byte) main::s#3 = (byte) main::s#1 -- register_copy 
-  //SEG20 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG19 [2] phi (byte) main::s#3 = (byte) main::s#1 [phi:main::@4/main::@8->main::@1#0] -- register_copy 
+  //SEG20 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@4/main::@8->main::@1#1] -- register_copy 
     jmp b1
   //SEG21 main::@4
   b4:
@@ -785,17 +785,17 @@ ASSEMBLER
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 bend:
 //SEG5 main
 main: {
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte) main::s#3 = (byte) 0 -- yby=coby1 
+  //SEG7 [2] phi (byte) main::s#3 = (byte) 0 [phi:main->main::@1#0] -- yby=coby1 
     ldy #0
-  //SEG8 [2] phi (byte) main::i#2 = (byte) 100 -- xby=coby1 
+  //SEG8 [2] phi (byte) main::i#2 = (byte) 100 [phi:main->main::@1#1] -- xby=coby1 
     ldx #$64
   //SEG9 main::@1
   b1:
@@ -818,10 +818,10 @@ main: {
   b8:
   //SEG17 [7] (byte) main::s#2 ← ++ (byte) main::s#3 [ main::i#1 main::s#2 ] -- yby=_inc_yby 
     iny
-  //SEG18 [2] phi from main::@4 main::@8 to main::@1
+  //SEG18 [2] phi from main::@4 main::@8 to main::@1 [phi:main::@4/main::@8->main::@1]
   b1_from_b8:
-  //SEG19 [2] phi (byte) main::s#3 = (byte) main::s#1 -- register_copy 
-  //SEG20 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG19 [2] phi (byte) main::s#3 = (byte) main::s#1 [phi:main::@4/main::@8->main::@1#0] -- register_copy 
+  //SEG20 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@4/main::@8->main::@1#1] -- register_copy 
     jmp b1
   //SEG21 main::@4
   b4:
@@ -840,15 +840,15 @@ ASSEMBLER
 //SEG0 Global Constants & labels
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
 main: {
-  //SEG6 [2] phi from main to main::@1
-  //SEG7 [2] phi (byte) main::s#3 = (byte) 0 -- yby=coby1 
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG7 [2] phi (byte) main::s#3 = (byte) 0 [phi:main->main::@1#0] -- yby=coby1 
     ldy #0
-  //SEG8 [2] phi (byte) main::i#2 = (byte) 100 -- xby=coby1 
+  //SEG8 [2] phi (byte) main::i#2 = (byte) 100 [phi:main->main::@1#1] -- xby=coby1 
     ldx #$64
   //SEG9 main::@1
   b1:
@@ -869,10 +869,10 @@ main: {
   //SEG16 main::@8
   //SEG17 [7] (byte) main::s#2 ← ++ (byte) main::s#3 [ main::i#1 main::s#2 ] -- yby=_inc_yby 
     iny
-  //SEG18 [2] phi from main::@4 main::@8 to main::@1
+  //SEG18 [2] phi from main::@4 main::@8 to main::@1 [phi:main::@4/main::@8->main::@1]
   b1_from_b8:
-  //SEG19 [2] phi (byte) main::s#3 = (byte) main::s#1 -- register_copy 
-  //SEG20 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG19 [2] phi (byte) main::s#3 = (byte) main::s#1 [phi:main::@4/main::@8->main::@1#0] -- register_copy 
+  //SEG20 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@4/main::@8->main::@1#1] -- register_copy 
     jmp b1
   //SEG21 main::@4
   b4:
@@ -905,15 +905,15 @@ FINAL CODE
 //SEG0 Global Constants & labels
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
 main: {
-  //SEG6 [2] phi from main to main::@1
-  //SEG7 [2] phi (byte) main::s#3 = (byte) 0 -- yby=coby1 
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG7 [2] phi (byte) main::s#3 = (byte) 0 [phi:main->main::@1#0] -- yby=coby1 
     ldy #0
-  //SEG8 [2] phi (byte) main::i#2 = (byte) 100 -- xby=coby1 
+  //SEG8 [2] phi (byte) main::i#2 = (byte) 100 [phi:main->main::@1#1] -- xby=coby1 
     ldx #$64
   //SEG9 main::@1
   b1:
@@ -934,10 +934,10 @@ main: {
   //SEG16 main::@8
   //SEG17 [7] (byte) main::s#2 ← ++ (byte) main::s#3 [ main::i#1 main::s#2 ] -- yby=_inc_yby 
     iny
-  //SEG18 [2] phi from main::@4 main::@8 to main::@1
+  //SEG18 [2] phi from main::@4 main::@8 to main::@1 [phi:main::@4/main::@8->main::@1]
   b1_from_b8:
-  //SEG19 [2] phi (byte) main::s#3 = (byte) main::s#1 -- register_copy 
-  //SEG20 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG19 [2] phi (byte) main::s#3 = (byte) main::s#1 [phi:main::@4/main::@8->main::@1#0] -- register_copy 
+  //SEG20 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@4/main::@8->main::@1#1] -- register_copy 
     jmp b1
   //SEG21 main::@4
   b4:

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

@@ -884,7 +884,7 @@ INITIAL ASM
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
 main_from_bbegin:
   jsr main
   jmp bend
@@ -895,15 +895,15 @@ main: {
     .label _0 = 5
     .label _1 = 6
   //SEG6 [2] call inccnt param-assignment [ inccnt::return#0 cnt#1 cnt2#1 cnt3#1 ]
-  //SEG7 [10] phi from main to inccnt
+  //SEG7 [10] phi from main to inccnt [phi:main->inccnt]
   inccnt_from_main:
-  //SEG8 [10] phi (byte) cnt3#11 = (byte) 0 -- zpby1=coby1 
+  //SEG8 [10] phi (byte) cnt3#11 = (byte) 0 [phi:main->inccnt#0] -- zpby1=coby1 
     lda #0
     sta cnt3
-  //SEG9 [10] phi (byte) cnt2#11 = (byte) 0 -- zpby1=coby1 
+  //SEG9 [10] phi (byte) cnt2#11 = (byte) 0 [phi:main->inccnt#1] -- zpby1=coby1 
     lda #0
     sta cnt2
-  //SEG10 [10] phi (byte) cnt#12 = (byte) 0 -- zpby1=coby1 
+  //SEG10 [10] phi (byte) cnt#12 = (byte) 0 [phi:main->inccnt#2] -- zpby1=coby1 
     lda #0
     sta cnt_12
     jsr inccnt
@@ -921,11 +921,11 @@ main: {
     sta cnt_3
     inc cnt_3
   //SEG15 [6] call inccnt param-assignment [ inccnt::return#0 ]
-  //SEG16 [10] phi from main::@1 to inccnt
+  //SEG16 [10] phi from main::@1 to inccnt [phi:main::@1->inccnt]
   inccnt_from_b1:
-  //SEG17 [10] phi (byte) cnt3#11 = (byte) cnt3#1 -- register_copy 
-  //SEG18 [10] phi (byte) cnt2#11 = (byte) cnt2#1 -- register_copy 
-  //SEG19 [10] phi (byte) cnt#12 = (byte) cnt#3 -- register_copy 
+  //SEG17 [10] phi (byte) cnt3#11 = (byte) cnt3#1 [phi:main::@1->inccnt#0] -- register_copy 
+  //SEG18 [10] phi (byte) cnt2#11 = (byte) cnt2#1 [phi:main::@1->inccnt#1] -- register_copy 
+  //SEG19 [10] phi (byte) cnt#12 = (byte) cnt#3 [phi:main::@1->inccnt#2] -- register_copy 
     jsr inccnt
     jmp b2
   //SEG20 main::@2
@@ -996,7 +996,7 @@ ASSEMBLER
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
 main_from_bbegin:
   jsr main
 //SEG4 @end
@@ -1004,14 +1004,14 @@ bend:
 //SEG5 main
 main: {
   //SEG6 [2] call inccnt param-assignment [ inccnt::return#0 cnt#1 cnt2#1 cnt3#1 ]
-  //SEG7 [10] phi from main to inccnt
+  //SEG7 [10] phi from main to inccnt [phi:main->inccnt]
   inccnt_from_main:
-  //SEG8 [10] phi (byte) cnt3#11 = (byte) 0 -- zpby1=coby1 
+  //SEG8 [10] phi (byte) cnt3#11 = (byte) 0 [phi:main->inccnt#0] -- zpby1=coby1 
     lda #0
     sta cnt3
-  //SEG9 [10] phi (byte) cnt2#11 = (byte) 0 -- yby=coby1 
+  //SEG9 [10] phi (byte) cnt2#11 = (byte) 0 [phi:main->inccnt#1] -- yby=coby1 
     ldy #0
-  //SEG10 [10] phi (byte) cnt#12 = (byte) 0 -- xby=coby1 
+  //SEG10 [10] phi (byte) cnt#12 = (byte) 0 [phi:main->inccnt#2] -- xby=coby1 
     ldx #0
     jsr inccnt
   //SEG11 main::@1
@@ -1023,11 +1023,11 @@ main: {
   //SEG14 [5] (byte) cnt#3 ← ++ (byte) cnt#1 [ cnt#3 cnt2#1 cnt3#1 ] -- xby=_inc_xby 
     inx
   //SEG15 [6] call inccnt param-assignment [ inccnt::return#0 ]
-  //SEG16 [10] phi from main::@1 to inccnt
+  //SEG16 [10] phi from main::@1 to inccnt [phi:main::@1->inccnt]
   inccnt_from_b1:
-  //SEG17 [10] phi (byte) cnt3#11 = (byte) cnt3#1 -- register_copy 
-  //SEG18 [10] phi (byte) cnt2#11 = (byte) cnt2#1 -- register_copy 
-  //SEG19 [10] phi (byte) cnt#12 = (byte) cnt#3 -- register_copy 
+  //SEG17 [10] phi (byte) cnt3#11 = (byte) cnt3#1 [phi:main::@1->inccnt#0] -- register_copy 
+  //SEG18 [10] phi (byte) cnt2#11 = (byte) cnt2#1 [phi:main::@1->inccnt#1] -- register_copy 
+  //SEG19 [10] phi (byte) cnt#12 = (byte) cnt#3 [phi:main::@1->inccnt#2] -- register_copy 
     jsr inccnt
   //SEG20 main::@2
   b2:
@@ -1065,21 +1065,21 @@ ASSEMBLER
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 bend:
 //SEG5 main
 main: {
   //SEG6 [2] call inccnt param-assignment [ inccnt::return#0 cnt#1 cnt2#1 cnt3#1 ]
-  //SEG7 [10] phi from main to inccnt
+  //SEG7 [10] phi from main to inccnt [phi:main->inccnt]
   inccnt_from_main:
-  //SEG8 [10] phi (byte) cnt3#11 = (byte) 0 -- zpby1=coby1 
+  //SEG8 [10] phi (byte) cnt3#11 = (byte) 0 [phi:main->inccnt#0] -- zpby1=coby1 
     lda #0
     sta cnt3
-  //SEG9 [10] phi (byte) cnt2#11 = (byte) 0 -- yby=coby1 
+  //SEG9 [10] phi (byte) cnt2#11 = (byte) 0 [phi:main->inccnt#1] -- yby=coby1 
     ldy #0
-  //SEG10 [10] phi (byte) cnt#12 = (byte) 0 -- xby=coby1 
+  //SEG10 [10] phi (byte) cnt#12 = (byte) 0 [phi:main->inccnt#2] -- xby=coby1 
     ldx #0
     jsr inccnt
   //SEG11 main::@1
@@ -1091,11 +1091,11 @@ main: {
   //SEG14 [5] (byte) cnt#3 ← ++ (byte) cnt#1 [ cnt#3 cnt2#1 cnt3#1 ] -- xby=_inc_xby 
     inx
   //SEG15 [6] call inccnt param-assignment [ inccnt::return#0 ]
-  //SEG16 [10] phi from main::@1 to inccnt
+  //SEG16 [10] phi from main::@1 to inccnt [phi:main::@1->inccnt]
   inccnt_from_b1:
-  //SEG17 [10] phi (byte) cnt3#11 = (byte) cnt3#1 -- register_copy 
-  //SEG18 [10] phi (byte) cnt2#11 = (byte) cnt2#1 -- register_copy 
-  //SEG19 [10] phi (byte) cnt#12 = (byte) cnt#3 -- register_copy 
+  //SEG17 [10] phi (byte) cnt3#11 = (byte) cnt3#1 [phi:main::@1->inccnt#0] -- register_copy 
+  //SEG18 [10] phi (byte) cnt2#11 = (byte) cnt2#1 [phi:main::@1->inccnt#1] -- register_copy 
+  //SEG19 [10] phi (byte) cnt#12 = (byte) cnt#3 [phi:main::@1->inccnt#2] -- register_copy 
     jsr inccnt
   //SEG20 main::@2
   b2:
@@ -1139,19 +1139,19 @@ ASSEMBLER
   .label cnt3 = 2
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
 main: {
   //SEG6 [2] call inccnt param-assignment [ inccnt::return#0 cnt#1 cnt2#1 cnt3#1 ]
-  //SEG7 [10] phi from main to inccnt
-  //SEG8 [10] phi (byte) cnt3#11 = (byte) 0 -- zpby1=coby1 
+  //SEG7 [10] phi from main to inccnt [phi:main->inccnt]
+  //SEG8 [10] phi (byte) cnt3#11 = (byte) 0 [phi:main->inccnt#0] -- zpby1=coby1 
     lda #0
     sta cnt3
-  //SEG9 [10] phi (byte) cnt2#11 = (byte) 0 -- yby=coby1 
+  //SEG9 [10] phi (byte) cnt2#11 = (byte) 0 [phi:main->inccnt#1] -- yby=coby1 
     ldy #0
-  //SEG10 [10] phi (byte) cnt#12 = (byte) 0 -- xby=coby1 
+  //SEG10 [10] phi (byte) cnt#12 = (byte) 0 [phi:main->inccnt#2] -- xby=coby1 
     ldx #0
     jsr inccnt
   //SEG11 main::@1
@@ -1162,10 +1162,10 @@ main: {
   //SEG14 [5] (byte) cnt#3 ← ++ (byte) cnt#1 [ cnt#3 cnt2#1 cnt3#1 ] -- xby=_inc_xby 
     inx
   //SEG15 [6] call inccnt param-assignment [ inccnt::return#0 ]
-  //SEG16 [10] phi from main::@1 to inccnt
-  //SEG17 [10] phi (byte) cnt3#11 = (byte) cnt3#1 -- register_copy 
-  //SEG18 [10] phi (byte) cnt2#11 = (byte) cnt2#1 -- register_copy 
-  //SEG19 [10] phi (byte) cnt#12 = (byte) cnt#3 -- register_copy 
+  //SEG16 [10] phi from main::@1 to inccnt [phi:main::@1->inccnt]
+  //SEG17 [10] phi (byte) cnt3#11 = (byte) cnt3#1 [phi:main::@1->inccnt#0] -- register_copy 
+  //SEG18 [10] phi (byte) cnt2#11 = (byte) cnt2#1 [phi:main::@1->inccnt#1] -- register_copy 
+  //SEG19 [10] phi (byte) cnt#12 = (byte) cnt#3 [phi:main::@1->inccnt#2] -- register_copy 
     jsr inccnt
   //SEG20 main::@2
   //SEG21 [7] (byte~) main::$1 ← (byte) inccnt::return#0 [ main::$1 ]
@@ -1231,19 +1231,19 @@ FINAL CODE
   .label cnt3 = 2
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
 main: {
   //SEG6 [2] call inccnt param-assignment [ inccnt::return#0 cnt#1 cnt2#1 cnt3#1 ]
-  //SEG7 [10] phi from main to inccnt
-  //SEG8 [10] phi (byte) cnt3#11 = (byte) 0 -- zpby1=coby1 
+  //SEG7 [10] phi from main to inccnt [phi:main->inccnt]
+  //SEG8 [10] phi (byte) cnt3#11 = (byte) 0 [phi:main->inccnt#0] -- zpby1=coby1 
     lda #0
     sta cnt3
-  //SEG9 [10] phi (byte) cnt2#11 = (byte) 0 -- yby=coby1 
+  //SEG9 [10] phi (byte) cnt2#11 = (byte) 0 [phi:main->inccnt#1] -- yby=coby1 
     ldy #0
-  //SEG10 [10] phi (byte) cnt#12 = (byte) 0 -- xby=coby1 
+  //SEG10 [10] phi (byte) cnt#12 = (byte) 0 [phi:main->inccnt#2] -- xby=coby1 
     ldx #0
     jsr inccnt
   //SEG11 main::@1
@@ -1254,10 +1254,10 @@ main: {
   //SEG14 [5] (byte) cnt#3 ← ++ (byte) cnt#1 [ cnt#3 cnt2#1 cnt3#1 ] -- xby=_inc_xby 
     inx
   //SEG15 [6] call inccnt param-assignment [ inccnt::return#0 ]
-  //SEG16 [10] phi from main::@1 to inccnt
-  //SEG17 [10] phi (byte) cnt3#11 = (byte) cnt3#1 -- register_copy 
-  //SEG18 [10] phi (byte) cnt2#11 = (byte) cnt2#1 -- register_copy 
-  //SEG19 [10] phi (byte) cnt#12 = (byte) cnt#3 -- register_copy 
+  //SEG16 [10] phi from main::@1 to inccnt [phi:main::@1->inccnt]
+  //SEG17 [10] phi (byte) cnt3#11 = (byte) cnt3#1 [phi:main::@1->inccnt#0] -- register_copy 
+  //SEG18 [10] phi (byte) cnt2#11 = (byte) cnt2#1 [phi:main::@1->inccnt#1] -- register_copy 
+  //SEG19 [10] phi (byte) cnt#12 = (byte) cnt#3 [phi:main::@1->inccnt#2] -- register_copy 
     jsr inccnt
   //SEG20 main::@2
   //SEG21 [7] (byte~) main::$1 ← (byte) inccnt::return#0 [ main::$1 ]

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

@@ -609,7 +609,7 @@ INITIAL ASM
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
 main_from_bbegin:
   jsr main
   jmp bend
@@ -618,9 +618,9 @@ bend:
 //SEG5 main
 main: {
   //SEG6 [2] call inccnt param-assignment [ cnt#10 ]
-  //SEG7 [9] phi from main to inccnt
+  //SEG7 [9] phi from main to inccnt [phi:main->inccnt]
   inccnt_from_main:
-  //SEG8 [9] phi (byte) cnt#13 = (byte) 0 -- zpby1=coby1 
+  //SEG8 [9] phi (byte) cnt#13 = (byte) 0 [phi:main->inccnt#0] -- zpby1=coby1 
     lda #0
     sta cnt_13
     jsr inccnt
@@ -635,9 +635,9 @@ main: {
     sta cnt_3
     inc cnt_3
   //SEG12 [5] call inccnt param-assignment [ cnt#10 ]
-  //SEG13 [9] phi from main::@1 to inccnt
+  //SEG13 [9] phi from main::@1 to inccnt [phi:main::@1->inccnt]
   inccnt_from_b1:
-  //SEG14 [9] phi (byte) cnt#13 = (byte) cnt#3 -- register_copy 
+  //SEG14 [9] phi (byte) cnt#13 = (byte) cnt#3 [phi:main::@1->inccnt#0] -- register_copy 
     jsr inccnt
     jmp b2
   //SEG15 main::@2
@@ -693,7 +693,7 @@ ASSEMBLER
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
 main_from_bbegin:
   jsr main
 //SEG4 @end
@@ -701,9 +701,9 @@ bend:
 //SEG5 main
 main: {
   //SEG6 [2] call inccnt param-assignment [ cnt#10 ]
-  //SEG7 [9] phi from main to inccnt
+  //SEG7 [9] phi from main to inccnt [phi:main->inccnt]
   inccnt_from_main:
-  //SEG8 [9] phi (byte) cnt#13 = (byte) 0 -- xby=coby1 
+  //SEG8 [9] phi (byte) cnt#13 = (byte) 0 [phi:main->inccnt#0] -- xby=coby1 
     ldx #0
     jsr inccnt
   //SEG9 main::@1
@@ -713,9 +713,9 @@ main: {
   //SEG11 [4] (byte) cnt#3 ← ++ (byte) cnt#10 [ cnt#3 ] -- xby=_inc_xby 
     inx
   //SEG12 [5] call inccnt param-assignment [ cnt#10 ]
-  //SEG13 [9] phi from main::@1 to inccnt
+  //SEG13 [9] phi from main::@1 to inccnt [phi:main::@1->inccnt]
   inccnt_from_b1:
-  //SEG14 [9] phi (byte) cnt#13 = (byte) cnt#3 -- register_copy 
+  //SEG14 [9] phi (byte) cnt#13 = (byte) cnt#3 [phi:main::@1->inccnt#0] -- register_copy 
     jsr inccnt
   //SEG15 main::@2
   b2:
@@ -746,16 +746,16 @@ ASSEMBLER
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 bend:
 //SEG5 main
 main: {
   //SEG6 [2] call inccnt param-assignment [ cnt#10 ]
-  //SEG7 [9] phi from main to inccnt
+  //SEG7 [9] phi from main to inccnt [phi:main->inccnt]
   inccnt_from_main:
-  //SEG8 [9] phi (byte) cnt#13 = (byte) 0 -- xby=coby1 
+  //SEG8 [9] phi (byte) cnt#13 = (byte) 0 [phi:main->inccnt#0] -- xby=coby1 
     ldx #0
     jsr inccnt
   //SEG9 main::@1
@@ -765,9 +765,9 @@ main: {
   //SEG11 [4] (byte) cnt#3 ← ++ (byte) cnt#10 [ cnt#3 ] -- xby=_inc_xby 
     inx
   //SEG12 [5] call inccnt param-assignment [ cnt#10 ]
-  //SEG13 [9] phi from main::@1 to inccnt
+  //SEG13 [9] phi from main::@1 to inccnt [phi:main::@1->inccnt]
   inccnt_from_b1:
-  //SEG14 [9] phi (byte) cnt#13 = (byte) cnt#3 -- register_copy 
+  //SEG14 [9] phi (byte) cnt#13 = (byte) cnt#3 [phi:main::@1->inccnt#0] -- register_copy 
     jsr inccnt
   //SEG15 main::@2
   b2:
@@ -804,14 +804,14 @@ ASSEMBLER
   .const SCREEN = $400
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
 main: {
   //SEG6 [2] call inccnt param-assignment [ cnt#10 ]
-  //SEG7 [9] phi from main to inccnt
-  //SEG8 [9] phi (byte) cnt#13 = (byte) 0 -- xby=coby1 
+  //SEG7 [9] phi from main to inccnt [phi:main->inccnt]
+  //SEG8 [9] phi (byte) cnt#13 = (byte) 0 [phi:main->inccnt#0] -- xby=coby1 
     ldx #0
     jsr inccnt
   //SEG9 main::@1
@@ -820,8 +820,8 @@ main: {
   //SEG11 [4] (byte) cnt#3 ← ++ (byte) cnt#10 [ cnt#3 ] -- xby=_inc_xby 
     inx
   //SEG12 [5] call inccnt param-assignment [ cnt#10 ]
-  //SEG13 [9] phi from main::@1 to inccnt
-  //SEG14 [9] phi (byte) cnt#13 = (byte) cnt#3 -- register_copy 
+  //SEG13 [9] phi from main::@1 to inccnt [phi:main::@1->inccnt]
+  //SEG14 [9] phi (byte) cnt#13 = (byte) cnt#3 [phi:main::@1->inccnt#0] -- register_copy 
     jsr inccnt
   //SEG15 main::@2
   //SEG16 [6] (byte) cnt#1 ← ++ (byte) cnt#10 [ cnt#1 ] -- xby=_inc_xby 
@@ -867,14 +867,14 @@ FINAL CODE
   .const SCREEN = $400
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
 main: {
   //SEG6 [2] call inccnt param-assignment [ cnt#10 ]
-  //SEG7 [9] phi from main to inccnt
-  //SEG8 [9] phi (byte) cnt#13 = (byte) 0 -- xby=coby1 
+  //SEG7 [9] phi from main to inccnt [phi:main->inccnt]
+  //SEG8 [9] phi (byte) cnt#13 = (byte) 0 [phi:main->inccnt#0] -- xby=coby1 
     ldx #0
     jsr inccnt
   //SEG9 main::@1
@@ -883,8 +883,8 @@ main: {
   //SEG11 [4] (byte) cnt#3 ← ++ (byte) cnt#10 [ cnt#3 ] -- xby=_inc_xby 
     inx
   //SEG12 [5] call inccnt param-assignment [ cnt#10 ]
-  //SEG13 [9] phi from main::@1 to inccnt
-  //SEG14 [9] phi (byte) cnt#13 = (byte) cnt#3 -- register_copy 
+  //SEG13 [9] phi from main::@1 to inccnt [phi:main::@1->inccnt]
+  //SEG14 [9] phi (byte) cnt#13 = (byte) cnt#3 [phi:main::@1->inccnt#0] -- register_copy 
     jsr inccnt
   //SEG15 main::@2
   //SEG16 [6] (byte) cnt#1 ← ++ (byte) cnt#10 [ cnt#1 ] -- xby=_inc_xby 

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

@@ -2108,7 +2108,7 @@ INITIAL ASM
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
 main_from_bbegin:
   jsr main
   jmp bend
@@ -2127,14 +2127,14 @@ main: {
   //SEG9 main::@2
   b2:
   //SEG10 [4] call rvaluevar param-assignment [ ]
-  //SEG11 [14] phi from main::@2 to rvaluevar
+  //SEG11 [14] phi from main::@2 to rvaluevar [phi:main::@2->rvaluevar]
   rvaluevar_from_b2:
     jsr rvaluevar
     jmp b3
   //SEG12 main::@3
   b3:
   //SEG13 [5] call lvaluevar param-assignment [ ]
-  //SEG14 [7] phi from main::@3 to lvaluevar
+  //SEG14 [7] phi from main::@3 to lvaluevar [phi:main::@3->lvaluevar]
   lvaluevar_from_b3:
     jsr lvaluevar
     jmp breturn
@@ -2148,14 +2148,14 @@ lvaluevar: {
     .const b = 4
     .label screen = 3
     .label i = 2
-  //SEG18 [8] phi from lvaluevar to lvaluevar::@1
+  //SEG18 [8] phi from lvaluevar to lvaluevar::@1 [phi:lvaluevar->lvaluevar::@1]
   b1_from_lvaluevar:
-  //SEG19 [8] phi (byte*) lvaluevar::screen#2 = (word) 1024 -- zpptrby1=cowo1 
+  //SEG19 [8] phi (byte*) lvaluevar::screen#2 = (word) 1024 [phi:lvaluevar->lvaluevar::@1#0] -- zpptrby1=cowo1 
     lda #<$400
     sta screen
     lda #>$400
     sta screen+1
-  //SEG20 [8] phi (byte) lvaluevar::i#2 = (byte) 2 -- zpby1=coby1 
+  //SEG20 [8] phi (byte) lvaluevar::i#2 = (byte) 2 [phi:lvaluevar->lvaluevar::@1#1] -- zpby1=coby1 
     lda #2
     sta i
     jmp b1
@@ -2183,10 +2183,10 @@ lvaluevar: {
   !:
   //SEG28 [13] (byte) lvaluevar::i#1 ← ++ (byte) lvaluevar::i#2 [ lvaluevar::i#1 lvaluevar::screen#1 ] -- zpby1=_inc_zpby1 
     inc i
-  //SEG29 [8] phi from lvaluevar::@2 to lvaluevar::@1
+  //SEG29 [8] phi from lvaluevar::@2 to lvaluevar::@1 [phi:lvaluevar::@2->lvaluevar::@1]
   b1_from_b2:
-  //SEG30 [8] phi (byte*) lvaluevar::screen#2 = (byte*) lvaluevar::screen#1 -- register_copy 
-  //SEG31 [8] phi (byte) lvaluevar::i#2 = (byte) lvaluevar::i#1 -- register_copy 
+  //SEG30 [8] phi (byte*) lvaluevar::screen#2 = (byte*) lvaluevar::screen#1 [phi:lvaluevar::@2->lvaluevar::@1#0] -- register_copy 
+  //SEG31 [8] phi (byte) lvaluevar::i#2 = (byte) lvaluevar::i#1 [phi:lvaluevar::@2->lvaluevar::@1#1] -- register_copy 
     jmp b1
 }
 //SEG32 rvaluevar
@@ -2194,14 +2194,14 @@ rvaluevar: {
     .label b = 10
     .label screen = 6
     .label i = 5
-  //SEG33 [15] phi from rvaluevar to rvaluevar::@1
+  //SEG33 [15] phi from rvaluevar to rvaluevar::@1 [phi:rvaluevar->rvaluevar::@1]
   b1_from_rvaluevar:
-  //SEG34 [15] phi (byte*) rvaluevar::screen#2 = (word) 1024 -- zpptrby1=cowo1 
+  //SEG34 [15] phi (byte*) rvaluevar::screen#2 = (word) 1024 [phi:rvaluevar->rvaluevar::@1#0] -- zpptrby1=cowo1 
     lda #<$400
     sta screen
     lda #>$400
     sta screen+1
-  //SEG35 [15] phi (byte) rvaluevar::i#2 = (byte) 2 -- zpby1=coby1 
+  //SEG35 [15] phi (byte) rvaluevar::i#2 = (byte) 2 [phi:rvaluevar->rvaluevar::@1#1] -- zpby1=coby1 
     lda #2
     sta i
     jmp b1
@@ -2229,10 +2229,10 @@ rvaluevar: {
   !:
   //SEG43 [20] (byte) rvaluevar::i#1 ← ++ (byte) rvaluevar::i#2 [ rvaluevar::i#1 rvaluevar::screen#1 ] -- zpby1=_inc_zpby1 
     inc i
-  //SEG44 [15] phi from rvaluevar::@2 to rvaluevar::@1
+  //SEG44 [15] phi from rvaluevar::@2 to rvaluevar::@1 [phi:rvaluevar::@2->rvaluevar::@1]
   b1_from_b2:
-  //SEG45 [15] phi (byte*) rvaluevar::screen#2 = (byte*) rvaluevar::screen#1 -- register_copy 
-  //SEG46 [15] phi (byte) rvaluevar::i#2 = (byte) rvaluevar::i#1 -- register_copy 
+  //SEG45 [15] phi (byte*) rvaluevar::screen#2 = (byte*) rvaluevar::screen#1 [phi:rvaluevar::@2->rvaluevar::@1#0] -- register_copy 
+  //SEG46 [15] phi (byte) rvaluevar::i#2 = (byte) rvaluevar::i#1 [phi:rvaluevar::@2->rvaluevar::@1#1] -- register_copy 
     jmp b1
 }
 //SEG47 rvalue
@@ -2248,9 +2248,9 @@ rvalue: {
   //SEG49 [22] (byte) rvalue::b#1 ← * (const byte[1024]) rvalue::SCREEN#0+(byte) 1 [ ] -- zpby1=_star_cowo1 
     lda SCREEN+1
     sta b_1
-  //SEG50 [23] phi from rvalue to rvalue::@1
+  //SEG50 [23] phi from rvalue to rvalue::@1 [phi:rvalue->rvalue::@1]
   b1_from_rvalue:
-  //SEG51 [23] phi (byte) rvalue::i#2 = (byte) 2 -- zpby1=coby1 
+  //SEG51 [23] phi (byte) rvalue::i#2 = (byte) 2 [phi:rvalue->rvalue::@1#0] -- zpby1=coby1 
     lda #2
     sta i
     jmp b1
@@ -2273,9 +2273,9 @@ rvalue: {
     sta b_2
   //SEG58 [27] (byte) rvalue::i#1 ← ++ (byte) rvalue::i#2 [ rvalue::i#1 ] -- zpby1=_inc_zpby1 
     inc i
-  //SEG59 [23] phi from rvalue::@2 to rvalue::@1
+  //SEG59 [23] phi from rvalue::@2 to rvalue::@1 [phi:rvalue::@2->rvalue::@1]
   b1_from_b2:
-  //SEG60 [23] phi (byte) rvalue::i#2 = (byte) rvalue::i#1 -- register_copy 
+  //SEG60 [23] phi (byte) rvalue::i#2 = (byte) rvalue::i#1 [phi:rvalue::@2->rvalue::@1#0] -- register_copy 
     jmp b1
 }
 //SEG61 lvalue
@@ -2288,9 +2288,9 @@ lvalue: {
   //SEG63 [29] *((const byte[1024]) lvalue::SCREEN#0+(byte) 1) ← (byte) 2 [ ] -- _star_cowo1=coby2 
     lda #2
     sta SCREEN+1
-  //SEG64 [30] phi from lvalue to lvalue::@1
+  //SEG64 [30] phi from lvalue to lvalue::@1 [phi:lvalue->lvalue::@1]
   b1_from_lvalue:
-  //SEG65 [30] phi (byte) lvalue::i#2 = (byte) 2 -- zpby1=coby1 
+  //SEG65 [30] phi (byte) lvalue::i#2 = (byte) 2 [phi:lvalue->lvalue::@1#0] -- zpby1=coby1 
     lda #2
     sta i
     jmp b1
@@ -2313,9 +2313,9 @@ lvalue: {
     sta SCREEN,x
   //SEG72 [34] (byte) lvalue::i#1 ← ++ (byte) lvalue::i#2 [ lvalue::i#1 ] -- zpby1=_inc_zpby1 
     inc i
-  //SEG73 [30] phi from lvalue::@2 to lvalue::@1
+  //SEG73 [30] phi from lvalue::@2 to lvalue::@1 [phi:lvalue::@2->lvalue::@1]
   b1_from_b2:
-  //SEG74 [30] phi (byte) lvalue::i#2 = (byte) lvalue::i#1 -- register_copy 
+  //SEG74 [30] phi (byte) lvalue::i#2 = (byte) lvalue::i#1 [phi:lvalue::@2->lvalue::@1#0] -- register_copy 
     jmp b1
 }
 
@@ -2381,7 +2381,7 @@ ASSEMBLER
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
 main_from_bbegin:
   jsr main
 //SEG4 @end
@@ -2397,13 +2397,13 @@ main: {
   //SEG9 main::@2
   b2:
   //SEG10 [4] call rvaluevar param-assignment [ ]
-  //SEG11 [14] phi from main::@2 to rvaluevar
+  //SEG11 [14] phi from main::@2 to rvaluevar [phi:main::@2->rvaluevar]
   rvaluevar_from_b2:
     jsr rvaluevar
   //SEG12 main::@3
   b3:
   //SEG13 [5] call lvaluevar param-assignment [ ]
-  //SEG14 [7] phi from main::@3 to lvaluevar
+  //SEG14 [7] phi from main::@3 to lvaluevar [phi:main::@3->lvaluevar]
   lvaluevar_from_b3:
     jsr lvaluevar
   //SEG15 main::@return
@@ -2415,14 +2415,14 @@ main: {
 lvaluevar: {
     .const b = 4
     .label screen = 2
-  //SEG18 [8] phi from lvaluevar to lvaluevar::@1
+  //SEG18 [8] phi from lvaluevar to lvaluevar::@1 [phi:lvaluevar->lvaluevar::@1]
   b1_from_lvaluevar:
-  //SEG19 [8] phi (byte*) lvaluevar::screen#2 = (word) 1024 -- zpptrby1=cowo1 
+  //SEG19 [8] phi (byte*) lvaluevar::screen#2 = (word) 1024 [phi:lvaluevar->lvaluevar::@1#0] -- zpptrby1=cowo1 
     lda #<$400
     sta screen
     lda #>$400
     sta screen+1
-  //SEG20 [8] phi (byte) lvaluevar::i#2 = (byte) 2 -- xby=coby1 
+  //SEG20 [8] phi (byte) lvaluevar::i#2 = (byte) 2 [phi:lvaluevar->lvaluevar::@1#1] -- xby=coby1 
     ldx #2
   //SEG21 lvaluevar::@1
   b1:
@@ -2446,23 +2446,23 @@ lvaluevar: {
   !:
   //SEG28 [13] (byte) lvaluevar::i#1 ← ++ (byte) lvaluevar::i#2 [ lvaluevar::i#1 lvaluevar::screen#1 ] -- xby=_inc_xby 
     inx
-  //SEG29 [8] phi from lvaluevar::@2 to lvaluevar::@1
+  //SEG29 [8] phi from lvaluevar::@2 to lvaluevar::@1 [phi:lvaluevar::@2->lvaluevar::@1]
   b1_from_b2:
-  //SEG30 [8] phi (byte*) lvaluevar::screen#2 = (byte*) lvaluevar::screen#1 -- register_copy 
-  //SEG31 [8] phi (byte) lvaluevar::i#2 = (byte) lvaluevar::i#1 -- register_copy 
+  //SEG30 [8] phi (byte*) lvaluevar::screen#2 = (byte*) lvaluevar::screen#1 [phi:lvaluevar::@2->lvaluevar::@1#0] -- register_copy 
+  //SEG31 [8] phi (byte) lvaluevar::i#2 = (byte) lvaluevar::i#1 [phi:lvaluevar::@2->lvaluevar::@1#1] -- register_copy 
     jmp b1
 }
 //SEG32 rvaluevar
 rvaluevar: {
     .label screen = 2
-  //SEG33 [15] phi from rvaluevar to rvaluevar::@1
+  //SEG33 [15] phi from rvaluevar to rvaluevar::@1 [phi:rvaluevar->rvaluevar::@1]
   b1_from_rvaluevar:
-  //SEG34 [15] phi (byte*) rvaluevar::screen#2 = (word) 1024 -- zpptrby1=cowo1 
+  //SEG34 [15] phi (byte*) rvaluevar::screen#2 = (word) 1024 [phi:rvaluevar->rvaluevar::@1#0] -- zpptrby1=cowo1 
     lda #<$400
     sta screen
     lda #>$400
     sta screen+1
-  //SEG35 [15] phi (byte) rvaluevar::i#2 = (byte) 2 -- xby=coby1 
+  //SEG35 [15] phi (byte) rvaluevar::i#2 = (byte) 2 [phi:rvaluevar->rvaluevar::@1#1] -- xby=coby1 
     ldx #2
   //SEG36 rvaluevar::@1
   b1:
@@ -2485,10 +2485,10 @@ rvaluevar: {
   !:
   //SEG43 [20] (byte) rvaluevar::i#1 ← ++ (byte) rvaluevar::i#2 [ rvaluevar::i#1 rvaluevar::screen#1 ] -- xby=_inc_xby 
     inx
-  //SEG44 [15] phi from rvaluevar::@2 to rvaluevar::@1
+  //SEG44 [15] phi from rvaluevar::@2 to rvaluevar::@1 [phi:rvaluevar::@2->rvaluevar::@1]
   b1_from_b2:
-  //SEG45 [15] phi (byte*) rvaluevar::screen#2 = (byte*) rvaluevar::screen#1 -- register_copy 
-  //SEG46 [15] phi (byte) rvaluevar::i#2 = (byte) rvaluevar::i#1 -- register_copy 
+  //SEG45 [15] phi (byte*) rvaluevar::screen#2 = (byte*) rvaluevar::screen#1 [phi:rvaluevar::@2->rvaluevar::@1#0] -- register_copy 
+  //SEG46 [15] phi (byte) rvaluevar::i#2 = (byte) rvaluevar::i#1 [phi:rvaluevar::@2->rvaluevar::@1#1] -- register_copy 
     jmp b1
 }
 //SEG47 rvalue
@@ -2498,9 +2498,9 @@ rvalue: {
     lda SCREEN
   //SEG49 [22] (byte) rvalue::b#1 ← * (const byte[1024]) rvalue::SCREEN#0+(byte) 1 [ ] -- aby=_star_cowo1 
     lda SCREEN+1
-  //SEG50 [23] phi from rvalue to rvalue::@1
+  //SEG50 [23] phi from rvalue to rvalue::@1 [phi:rvalue->rvalue::@1]
   b1_from_rvalue:
-  //SEG51 [23] phi (byte) rvalue::i#2 = (byte) 2 -- xby=coby1 
+  //SEG51 [23] phi (byte) rvalue::i#2 = (byte) 2 [phi:rvalue->rvalue::@1#0] -- xby=coby1 
     ldx #2
   //SEG52 rvalue::@1
   b1:
@@ -2517,9 +2517,9 @@ rvalue: {
     lda SCREEN,x
   //SEG58 [27] (byte) rvalue::i#1 ← ++ (byte) rvalue::i#2 [ rvalue::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG59 [23] phi from rvalue::@2 to rvalue::@1
+  //SEG59 [23] phi from rvalue::@2 to rvalue::@1 [phi:rvalue::@2->rvalue::@1]
   b1_from_b2:
-  //SEG60 [23] phi (byte) rvalue::i#2 = (byte) rvalue::i#1 -- register_copy 
+  //SEG60 [23] phi (byte) rvalue::i#2 = (byte) rvalue::i#1 [phi:rvalue::@2->rvalue::@1#0] -- register_copy 
     jmp b1
 }
 //SEG61 lvalue
@@ -2531,9 +2531,9 @@ lvalue: {
   //SEG63 [29] *((const byte[1024]) lvalue::SCREEN#0+(byte) 1) ← (byte) 2 [ ] -- _star_cowo1=coby2 
     lda #2
     sta SCREEN+1
-  //SEG64 [30] phi from lvalue to lvalue::@1
+  //SEG64 [30] phi from lvalue to lvalue::@1 [phi:lvalue->lvalue::@1]
   b1_from_lvalue:
-  //SEG65 [30] phi (byte) lvalue::i#2 = (byte) 2 -- xby=coby1 
+  //SEG65 [30] phi (byte) lvalue::i#2 = (byte) 2 [phi:lvalue->lvalue::@1#0] -- xby=coby1 
     ldx #2
   //SEG66 lvalue::@1
   b1:
@@ -2551,9 +2551,9 @@ lvalue: {
     sta SCREEN,x
   //SEG72 [34] (byte) lvalue::i#1 ← ++ (byte) lvalue::i#2 [ lvalue::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG73 [30] phi from lvalue::@2 to lvalue::@1
+  //SEG73 [30] phi from lvalue::@2 to lvalue::@1 [phi:lvalue::@2->lvalue::@1]
   b1_from_b2:
-  //SEG74 [30] phi (byte) lvalue::i#2 = (byte) lvalue::i#1 -- register_copy 
+  //SEG74 [30] phi (byte) lvalue::i#2 = (byte) lvalue::i#1 [phi:lvalue::@2->lvalue::@1#0] -- register_copy 
     jmp b1
 }
 
@@ -2566,7 +2566,7 @@ ASSEMBLER
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 bend:
@@ -2581,12 +2581,12 @@ main: {
   //SEG9 main::@2
   b2:
   //SEG10 [4] call rvaluevar param-assignment [ ]
-  //SEG11 [14] phi from main::@2 to rvaluevar
+  //SEG11 [14] phi from main::@2 to rvaluevar [phi:main::@2->rvaluevar]
     jsr rvaluevar
   //SEG12 main::@3
   b3:
   //SEG13 [5] call lvaluevar param-assignment [ ]
-  //SEG14 [7] phi from main::@3 to lvaluevar
+  //SEG14 [7] phi from main::@3 to lvaluevar [phi:main::@3->lvaluevar]
     jsr lvaluevar
   //SEG15 main::@return
   breturn:
@@ -2597,14 +2597,14 @@ main: {
 lvaluevar: {
     .const b = 4
     .label screen = 2
-  //SEG18 [8] phi from lvaluevar to lvaluevar::@1
+  //SEG18 [8] phi from lvaluevar to lvaluevar::@1 [phi:lvaluevar->lvaluevar::@1]
   b1_from_lvaluevar:
-  //SEG19 [8] phi (byte*) lvaluevar::screen#2 = (word) 1024 -- zpptrby1=cowo1 
+  //SEG19 [8] phi (byte*) lvaluevar::screen#2 = (word) 1024 [phi:lvaluevar->lvaluevar::@1#0] -- zpptrby1=cowo1 
     lda #<$400
     sta screen
     lda #>$400
     sta screen+1
-  //SEG20 [8] phi (byte) lvaluevar::i#2 = (byte) 2 -- xby=coby1 
+  //SEG20 [8] phi (byte) lvaluevar::i#2 = (byte) 2 [phi:lvaluevar->lvaluevar::@1#1] -- xby=coby1 
     ldx #2
   //SEG21 lvaluevar::@1
   b1:
@@ -2628,23 +2628,23 @@ lvaluevar: {
   !:
   //SEG28 [13] (byte) lvaluevar::i#1 ← ++ (byte) lvaluevar::i#2 [ lvaluevar::i#1 lvaluevar::screen#1 ] -- xby=_inc_xby 
     inx
-  //SEG29 [8] phi from lvaluevar::@2 to lvaluevar::@1
+  //SEG29 [8] phi from lvaluevar::@2 to lvaluevar::@1 [phi:lvaluevar::@2->lvaluevar::@1]
   b1_from_b2:
-  //SEG30 [8] phi (byte*) lvaluevar::screen#2 = (byte*) lvaluevar::screen#1 -- register_copy 
-  //SEG31 [8] phi (byte) lvaluevar::i#2 = (byte) lvaluevar::i#1 -- register_copy 
+  //SEG30 [8] phi (byte*) lvaluevar::screen#2 = (byte*) lvaluevar::screen#1 [phi:lvaluevar::@2->lvaluevar::@1#0] -- register_copy 
+  //SEG31 [8] phi (byte) lvaluevar::i#2 = (byte) lvaluevar::i#1 [phi:lvaluevar::@2->lvaluevar::@1#1] -- register_copy 
     jmp b1
 }
 //SEG32 rvaluevar
 rvaluevar: {
     .label screen = 2
-  //SEG33 [15] phi from rvaluevar to rvaluevar::@1
+  //SEG33 [15] phi from rvaluevar to rvaluevar::@1 [phi:rvaluevar->rvaluevar::@1]
   b1_from_rvaluevar:
-  //SEG34 [15] phi (byte*) rvaluevar::screen#2 = (word) 1024 -- zpptrby1=cowo1 
+  //SEG34 [15] phi (byte*) rvaluevar::screen#2 = (word) 1024 [phi:rvaluevar->rvaluevar::@1#0] -- zpptrby1=cowo1 
     lda #<$400
     sta screen
     lda #>$400
     sta screen+1
-  //SEG35 [15] phi (byte) rvaluevar::i#2 = (byte) 2 -- xby=coby1 
+  //SEG35 [15] phi (byte) rvaluevar::i#2 = (byte) 2 [phi:rvaluevar->rvaluevar::@1#1] -- xby=coby1 
     ldx #2
   //SEG36 rvaluevar::@1
   b1:
@@ -2667,10 +2667,10 @@ rvaluevar: {
   !:
   //SEG43 [20] (byte) rvaluevar::i#1 ← ++ (byte) rvaluevar::i#2 [ rvaluevar::i#1 rvaluevar::screen#1 ] -- xby=_inc_xby 
     inx
-  //SEG44 [15] phi from rvaluevar::@2 to rvaluevar::@1
+  //SEG44 [15] phi from rvaluevar::@2 to rvaluevar::@1 [phi:rvaluevar::@2->rvaluevar::@1]
   b1_from_b2:
-  //SEG45 [15] phi (byte*) rvaluevar::screen#2 = (byte*) rvaluevar::screen#1 -- register_copy 
-  //SEG46 [15] phi (byte) rvaluevar::i#2 = (byte) rvaluevar::i#1 -- register_copy 
+  //SEG45 [15] phi (byte*) rvaluevar::screen#2 = (byte*) rvaluevar::screen#1 [phi:rvaluevar::@2->rvaluevar::@1#0] -- register_copy 
+  //SEG46 [15] phi (byte) rvaluevar::i#2 = (byte) rvaluevar::i#1 [phi:rvaluevar::@2->rvaluevar::@1#1] -- register_copy 
     jmp b1
 }
 //SEG47 rvalue
@@ -2680,9 +2680,9 @@ rvalue: {
     lda SCREEN
   //SEG49 [22] (byte) rvalue::b#1 ← * (const byte[1024]) rvalue::SCREEN#0+(byte) 1 [ ] -- aby=_star_cowo1 
     lda SCREEN+1
-  //SEG50 [23] phi from rvalue to rvalue::@1
+  //SEG50 [23] phi from rvalue to rvalue::@1 [phi:rvalue->rvalue::@1]
   b1_from_rvalue:
-  //SEG51 [23] phi (byte) rvalue::i#2 = (byte) 2 -- xby=coby1 
+  //SEG51 [23] phi (byte) rvalue::i#2 = (byte) 2 [phi:rvalue->rvalue::@1#0] -- xby=coby1 
     ldx #2
   //SEG52 rvalue::@1
   b1:
@@ -2699,9 +2699,9 @@ rvalue: {
     lda SCREEN,x
   //SEG58 [27] (byte) rvalue::i#1 ← ++ (byte) rvalue::i#2 [ rvalue::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG59 [23] phi from rvalue::@2 to rvalue::@1
+  //SEG59 [23] phi from rvalue::@2 to rvalue::@1 [phi:rvalue::@2->rvalue::@1]
   b1_from_b2:
-  //SEG60 [23] phi (byte) rvalue::i#2 = (byte) rvalue::i#1 -- register_copy 
+  //SEG60 [23] phi (byte) rvalue::i#2 = (byte) rvalue::i#1 [phi:rvalue::@2->rvalue::@1#0] -- register_copy 
     jmp b1
 }
 //SEG61 lvalue
@@ -2713,9 +2713,9 @@ lvalue: {
   //SEG63 [29] *((const byte[1024]) lvalue::SCREEN#0+(byte) 1) ← (byte) 2 [ ] -- _star_cowo1=coby2 
     lda #2
     sta SCREEN+1
-  //SEG64 [30] phi from lvalue to lvalue::@1
+  //SEG64 [30] phi from lvalue to lvalue::@1 [phi:lvalue->lvalue::@1]
   b1_from_lvalue:
-  //SEG65 [30] phi (byte) lvalue::i#2 = (byte) 2 -- xby=coby1 
+  //SEG65 [30] phi (byte) lvalue::i#2 = (byte) 2 [phi:lvalue->lvalue::@1#0] -- xby=coby1 
     ldx #2
   //SEG66 lvalue::@1
   b1:
@@ -2733,9 +2733,9 @@ lvalue: {
     sta SCREEN,x
   //SEG72 [34] (byte) lvalue::i#1 ← ++ (byte) lvalue::i#2 [ lvalue::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG73 [30] phi from lvalue::@2 to lvalue::@1
+  //SEG73 [30] phi from lvalue::@2 to lvalue::@1 [phi:lvalue::@2->lvalue::@1]
   b1_from_b2:
-  //SEG74 [30] phi (byte) lvalue::i#2 = (byte) lvalue::i#1 -- register_copy 
+  //SEG74 [30] phi (byte) lvalue::i#2 = (byte) lvalue::i#1 [phi:lvalue::@2->lvalue::@1#0] -- register_copy 
     jmp b1
 }
 
@@ -2762,7 +2762,7 @@ ASSEMBLER
 //SEG0 Global Constants & labels
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
@@ -2774,11 +2774,11 @@ main: {
     jsr rvalue
   //SEG9 main::@2
   //SEG10 [4] call rvaluevar param-assignment [ ]
-  //SEG11 [14] phi from main::@2 to rvaluevar
+  //SEG11 [14] phi from main::@2 to rvaluevar [phi:main::@2->rvaluevar]
     jsr rvaluevar
   //SEG12 main::@3
   //SEG13 [5] call lvaluevar param-assignment [ ]
-  //SEG14 [7] phi from main::@3 to lvaluevar
+  //SEG14 [7] phi from main::@3 to lvaluevar [phi:main::@3->lvaluevar]
     jsr lvaluevar
   //SEG15 main::@return
   //SEG16 [6] return  [ ]
@@ -2788,13 +2788,13 @@ main: {
 lvaluevar: {
     .const b = 4
     .label screen = 2
-  //SEG18 [8] phi from lvaluevar to lvaluevar::@1
-  //SEG19 [8] phi (byte*) lvaluevar::screen#2 = (word) 1024 -- zpptrby1=cowo1 
+  //SEG18 [8] phi from lvaluevar to lvaluevar::@1 [phi:lvaluevar->lvaluevar::@1]
+  //SEG19 [8] phi (byte*) lvaluevar::screen#2 = (word) 1024 [phi:lvaluevar->lvaluevar::@1#0] -- zpptrby1=cowo1 
     lda #<$400
     sta screen
     lda #>$400
     sta screen+1
-  //SEG20 [8] phi (byte) lvaluevar::i#2 = (byte) 2 -- xby=coby1 
+  //SEG20 [8] phi (byte) lvaluevar::i#2 = (byte) 2 [phi:lvaluevar->lvaluevar::@1#1] -- xby=coby1 
     ldx #2
   //SEG21 lvaluevar::@1
   b1:
@@ -2817,21 +2817,21 @@ lvaluevar: {
   !:
   //SEG28 [13] (byte) lvaluevar::i#1 ← ++ (byte) lvaluevar::i#2 [ lvaluevar::i#1 lvaluevar::screen#1 ] -- xby=_inc_xby 
     inx
-  //SEG29 [8] phi from lvaluevar::@2 to lvaluevar::@1
-  //SEG30 [8] phi (byte*) lvaluevar::screen#2 = (byte*) lvaluevar::screen#1 -- register_copy 
-  //SEG31 [8] phi (byte) lvaluevar::i#2 = (byte) lvaluevar::i#1 -- register_copy 
+  //SEG29 [8] phi from lvaluevar::@2 to lvaluevar::@1 [phi:lvaluevar::@2->lvaluevar::@1]
+  //SEG30 [8] phi (byte*) lvaluevar::screen#2 = (byte*) lvaluevar::screen#1 [phi:lvaluevar::@2->lvaluevar::@1#0] -- register_copy 
+  //SEG31 [8] phi (byte) lvaluevar::i#2 = (byte) lvaluevar::i#1 [phi:lvaluevar::@2->lvaluevar::@1#1] -- register_copy 
     jmp b1
 }
 //SEG32 rvaluevar
 rvaluevar: {
     .label screen = 2
-  //SEG33 [15] phi from rvaluevar to rvaluevar::@1
-  //SEG34 [15] phi (byte*) rvaluevar::screen#2 = (word) 1024 -- zpptrby1=cowo1 
+  //SEG33 [15] phi from rvaluevar to rvaluevar::@1 [phi:rvaluevar->rvaluevar::@1]
+  //SEG34 [15] phi (byte*) rvaluevar::screen#2 = (word) 1024 [phi:rvaluevar->rvaluevar::@1#0] -- zpptrby1=cowo1 
     lda #<$400
     sta screen
     lda #>$400
     sta screen+1
-  //SEG35 [15] phi (byte) rvaluevar::i#2 = (byte) 2 -- xby=coby1 
+  //SEG35 [15] phi (byte) rvaluevar::i#2 = (byte) 2 [phi:rvaluevar->rvaluevar::@1#1] -- xby=coby1 
     ldx #2
   //SEG36 rvaluevar::@1
   b1:
@@ -2853,9 +2853,9 @@ rvaluevar: {
   !:
   //SEG43 [20] (byte) rvaluevar::i#1 ← ++ (byte) rvaluevar::i#2 [ rvaluevar::i#1 rvaluevar::screen#1 ] -- xby=_inc_xby 
     inx
-  //SEG44 [15] phi from rvaluevar::@2 to rvaluevar::@1
-  //SEG45 [15] phi (byte*) rvaluevar::screen#2 = (byte*) rvaluevar::screen#1 -- register_copy 
-  //SEG46 [15] phi (byte) rvaluevar::i#2 = (byte) rvaluevar::i#1 -- register_copy 
+  //SEG44 [15] phi from rvaluevar::@2 to rvaluevar::@1 [phi:rvaluevar::@2->rvaluevar::@1]
+  //SEG45 [15] phi (byte*) rvaluevar::screen#2 = (byte*) rvaluevar::screen#1 [phi:rvaluevar::@2->rvaluevar::@1#0] -- register_copy 
+  //SEG46 [15] phi (byte) rvaluevar::i#2 = (byte) rvaluevar::i#1 [phi:rvaluevar::@2->rvaluevar::@1#1] -- register_copy 
     jmp b1
 }
 //SEG47 rvalue
@@ -2865,8 +2865,8 @@ rvalue: {
     lda SCREEN
   //SEG49 [22] (byte) rvalue::b#1 ← * (const byte[1024]) rvalue::SCREEN#0+(byte) 1 [ ] -- aby=_star_cowo1 
     lda SCREEN+1
-  //SEG50 [23] phi from rvalue to rvalue::@1
-  //SEG51 [23] phi (byte) rvalue::i#2 = (byte) 2 -- xby=coby1 
+  //SEG50 [23] phi from rvalue to rvalue::@1 [phi:rvalue->rvalue::@1]
+  //SEG51 [23] phi (byte) rvalue::i#2 = (byte) 2 [phi:rvalue->rvalue::@1#0] -- xby=coby1 
     ldx #2
   //SEG52 rvalue::@1
   b1:
@@ -2882,8 +2882,8 @@ rvalue: {
     lda SCREEN,x
   //SEG58 [27] (byte) rvalue::i#1 ← ++ (byte) rvalue::i#2 [ rvalue::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG59 [23] phi from rvalue::@2 to rvalue::@1
-  //SEG60 [23] phi (byte) rvalue::i#2 = (byte) rvalue::i#1 -- register_copy 
+  //SEG59 [23] phi from rvalue::@2 to rvalue::@1 [phi:rvalue::@2->rvalue::@1]
+  //SEG60 [23] phi (byte) rvalue::i#2 = (byte) rvalue::i#1 [phi:rvalue::@2->rvalue::@1#0] -- register_copy 
     jmp b1
 }
 //SEG61 lvalue
@@ -2895,8 +2895,8 @@ lvalue: {
   //SEG63 [29] *((const byte[1024]) lvalue::SCREEN#0+(byte) 1) ← (byte) 2 [ ] -- _star_cowo1=coby2 
     lda #2
     sta SCREEN+1
-  //SEG64 [30] phi from lvalue to lvalue::@1
-  //SEG65 [30] phi (byte) lvalue::i#2 = (byte) 2 -- xby=coby1 
+  //SEG64 [30] phi from lvalue to lvalue::@1 [phi:lvalue->lvalue::@1]
+  //SEG65 [30] phi (byte) lvalue::i#2 = (byte) 2 [phi:lvalue->lvalue::@1#0] -- xby=coby1 
     ldx #2
   //SEG66 lvalue::@1
   b1:
@@ -2913,8 +2913,8 @@ lvalue: {
     sta SCREEN,x
   //SEG72 [34] (byte) lvalue::i#1 ← ++ (byte) lvalue::i#2 [ lvalue::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG73 [30] phi from lvalue::@2 to lvalue::@1
-  //SEG74 [30] phi (byte) lvalue::i#2 = (byte) lvalue::i#1 -- register_copy 
+  //SEG73 [30] phi from lvalue::@2 to lvalue::@1 [phi:lvalue::@2->lvalue::@1]
+  //SEG74 [30] phi (byte) lvalue::i#2 = (byte) lvalue::i#1 [phi:lvalue::@2->lvalue::@1#0] -- register_copy 
     jmp b1
 }
 
@@ -2987,7 +2987,7 @@ FINAL CODE
 //SEG0 Global Constants & labels
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
@@ -2999,11 +2999,11 @@ main: {
     jsr rvalue
   //SEG9 main::@2
   //SEG10 [4] call rvaluevar param-assignment [ ]
-  //SEG11 [14] phi from main::@2 to rvaluevar
+  //SEG11 [14] phi from main::@2 to rvaluevar [phi:main::@2->rvaluevar]
     jsr rvaluevar
   //SEG12 main::@3
   //SEG13 [5] call lvaluevar param-assignment [ ]
-  //SEG14 [7] phi from main::@3 to lvaluevar
+  //SEG14 [7] phi from main::@3 to lvaluevar [phi:main::@3->lvaluevar]
     jsr lvaluevar
   //SEG15 main::@return
   //SEG16 [6] return  [ ]
@@ -3013,13 +3013,13 @@ main: {
 lvaluevar: {
     .const b = 4
     .label screen = 2
-  //SEG18 [8] phi from lvaluevar to lvaluevar::@1
-  //SEG19 [8] phi (byte*) lvaluevar::screen#2 = (word) 1024 -- zpptrby1=cowo1 
+  //SEG18 [8] phi from lvaluevar to lvaluevar::@1 [phi:lvaluevar->lvaluevar::@1]
+  //SEG19 [8] phi (byte*) lvaluevar::screen#2 = (word) 1024 [phi:lvaluevar->lvaluevar::@1#0] -- zpptrby1=cowo1 
     lda #<$400
     sta screen
     lda #>$400
     sta screen+1
-  //SEG20 [8] phi (byte) lvaluevar::i#2 = (byte) 2 -- xby=coby1 
+  //SEG20 [8] phi (byte) lvaluevar::i#2 = (byte) 2 [phi:lvaluevar->lvaluevar::@1#1] -- xby=coby1 
     ldx #2
   //SEG21 lvaluevar::@1
   b1:
@@ -3042,21 +3042,21 @@ lvaluevar: {
   !:
   //SEG28 [13] (byte) lvaluevar::i#1 ← ++ (byte) lvaluevar::i#2 [ lvaluevar::i#1 lvaluevar::screen#1 ] -- xby=_inc_xby 
     inx
-  //SEG29 [8] phi from lvaluevar::@2 to lvaluevar::@1
-  //SEG30 [8] phi (byte*) lvaluevar::screen#2 = (byte*) lvaluevar::screen#1 -- register_copy 
-  //SEG31 [8] phi (byte) lvaluevar::i#2 = (byte) lvaluevar::i#1 -- register_copy 
+  //SEG29 [8] phi from lvaluevar::@2 to lvaluevar::@1 [phi:lvaluevar::@2->lvaluevar::@1]
+  //SEG30 [8] phi (byte*) lvaluevar::screen#2 = (byte*) lvaluevar::screen#1 [phi:lvaluevar::@2->lvaluevar::@1#0] -- register_copy 
+  //SEG31 [8] phi (byte) lvaluevar::i#2 = (byte) lvaluevar::i#1 [phi:lvaluevar::@2->lvaluevar::@1#1] -- register_copy 
     jmp b1
 }
 //SEG32 rvaluevar
 rvaluevar: {
     .label screen = 2
-  //SEG33 [15] phi from rvaluevar to rvaluevar::@1
-  //SEG34 [15] phi (byte*) rvaluevar::screen#2 = (word) 1024 -- zpptrby1=cowo1 
+  //SEG33 [15] phi from rvaluevar to rvaluevar::@1 [phi:rvaluevar->rvaluevar::@1]
+  //SEG34 [15] phi (byte*) rvaluevar::screen#2 = (word) 1024 [phi:rvaluevar->rvaluevar::@1#0] -- zpptrby1=cowo1 
     lda #<$400
     sta screen
     lda #>$400
     sta screen+1
-  //SEG35 [15] phi (byte) rvaluevar::i#2 = (byte) 2 -- xby=coby1 
+  //SEG35 [15] phi (byte) rvaluevar::i#2 = (byte) 2 [phi:rvaluevar->rvaluevar::@1#1] -- xby=coby1 
     ldx #2
   //SEG36 rvaluevar::@1
   b1:
@@ -3078,9 +3078,9 @@ rvaluevar: {
   !:
   //SEG43 [20] (byte) rvaluevar::i#1 ← ++ (byte) rvaluevar::i#2 [ rvaluevar::i#1 rvaluevar::screen#1 ] -- xby=_inc_xby 
     inx
-  //SEG44 [15] phi from rvaluevar::@2 to rvaluevar::@1
-  //SEG45 [15] phi (byte*) rvaluevar::screen#2 = (byte*) rvaluevar::screen#1 -- register_copy 
-  //SEG46 [15] phi (byte) rvaluevar::i#2 = (byte) rvaluevar::i#1 -- register_copy 
+  //SEG44 [15] phi from rvaluevar::@2 to rvaluevar::@1 [phi:rvaluevar::@2->rvaluevar::@1]
+  //SEG45 [15] phi (byte*) rvaluevar::screen#2 = (byte*) rvaluevar::screen#1 [phi:rvaluevar::@2->rvaluevar::@1#0] -- register_copy 
+  //SEG46 [15] phi (byte) rvaluevar::i#2 = (byte) rvaluevar::i#1 [phi:rvaluevar::@2->rvaluevar::@1#1] -- register_copy 
     jmp b1
 }
 //SEG47 rvalue
@@ -3090,8 +3090,8 @@ rvalue: {
     lda SCREEN
   //SEG49 [22] (byte) rvalue::b#1 ← * (const byte[1024]) rvalue::SCREEN#0+(byte) 1 [ ] -- aby=_star_cowo1 
     lda SCREEN+1
-  //SEG50 [23] phi from rvalue to rvalue::@1
-  //SEG51 [23] phi (byte) rvalue::i#2 = (byte) 2 -- xby=coby1 
+  //SEG50 [23] phi from rvalue to rvalue::@1 [phi:rvalue->rvalue::@1]
+  //SEG51 [23] phi (byte) rvalue::i#2 = (byte) 2 [phi:rvalue->rvalue::@1#0] -- xby=coby1 
     ldx #2
   //SEG52 rvalue::@1
   b1:
@@ -3107,8 +3107,8 @@ rvalue: {
     lda SCREEN,x
   //SEG58 [27] (byte) rvalue::i#1 ← ++ (byte) rvalue::i#2 [ rvalue::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG59 [23] phi from rvalue::@2 to rvalue::@1
-  //SEG60 [23] phi (byte) rvalue::i#2 = (byte) rvalue::i#1 -- register_copy 
+  //SEG59 [23] phi from rvalue::@2 to rvalue::@1 [phi:rvalue::@2->rvalue::@1]
+  //SEG60 [23] phi (byte) rvalue::i#2 = (byte) rvalue::i#1 [phi:rvalue::@2->rvalue::@1#0] -- register_copy 
     jmp b1
 }
 //SEG61 lvalue
@@ -3120,8 +3120,8 @@ lvalue: {
   //SEG63 [29] *((const byte[1024]) lvalue::SCREEN#0+(byte) 1) ← (byte) 2 [ ] -- _star_cowo1=coby2 
     lda #2
     sta SCREEN+1
-  //SEG64 [30] phi from lvalue to lvalue::@1
-  //SEG65 [30] phi (byte) lvalue::i#2 = (byte) 2 -- xby=coby1 
+  //SEG64 [30] phi from lvalue to lvalue::@1 [phi:lvalue->lvalue::@1]
+  //SEG65 [30] phi (byte) lvalue::i#2 = (byte) 2 [phi:lvalue->lvalue::@1#0] -- xby=coby1 
     ldx #2
   //SEG66 lvalue::@1
   b1:
@@ -3138,8 +3138,8 @@ lvalue: {
     sta SCREEN,x
   //SEG72 [34] (byte) lvalue::i#1 ← ++ (byte) lvalue::i#2 [ lvalue::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG73 [30] phi from lvalue::@2 to lvalue::@1
-  //SEG74 [30] phi (byte) lvalue::i#2 = (byte) lvalue::i#1 -- register_copy 
+  //SEG73 [30] phi from lvalue::@2 to lvalue::@1 [phi:lvalue::@2->lvalue::@1]
+  //SEG74 [30] phi (byte) lvalue::i#2 = (byte) lvalue::i#1 [phi:lvalue::@2->lvalue::@1#0] -- register_copy 
     jmp b1
 }
 

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

@@ -520,7 +520,7 @@ INITIAL ASM
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
 main_from_bbegin:
   jsr main
   jmp bend
@@ -531,9 +531,9 @@ main: {
     .const SCREEN = $400
     .label b = 3
     .label i = 2
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 2 -- zpby1=coby1 
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 2 [phi:main->main::@1#0] -- zpby1=coby1 
     lda #2
     sta i
     jmp b1
@@ -556,9 +556,9 @@ main: {
     sta b
   //SEG14 [6] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- zpby1=_inc_zpby1 
     inc i
-  //SEG15 [2] phi from main::@2 to main::@1
+  //SEG15 [2] phi from main::@2 to main::@1 [phi:main::@2->main::@1]
   b1_from_b2:
-  //SEG16 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG16 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@2->main::@1#0] -- register_copy 
     jmp b1
 }
 
@@ -581,7 +581,7 @@ ASSEMBLER
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
 main_from_bbegin:
   jsr main
 //SEG4 @end
@@ -589,9 +589,9 @@ bend:
 //SEG5 main
 main: {
     .const SCREEN = $400
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 2 -- xby=coby1 
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 2 [phi:main->main::@1#0] -- xby=coby1 
     ldx #2
   //SEG8 main::@1
   b1:
@@ -608,9 +608,9 @@ main: {
     lda SCREEN,x
   //SEG14 [6] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG15 [2] phi from main::@2 to main::@1
+  //SEG15 [2] phi from main::@2 to main::@1 [phi:main::@2->main::@1]
   b1_from_b2:
-  //SEG16 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG16 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@2->main::@1#0] -- register_copy 
     jmp b1
 }
 
@@ -621,16 +621,16 @@ ASSEMBLER
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 bend:
 //SEG5 main
 main: {
     .const SCREEN = $400
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 2 -- xby=coby1 
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 2 [phi:main->main::@1#0] -- xby=coby1 
     ldx #2
   //SEG8 main::@1
   b1:
@@ -647,9 +647,9 @@ main: {
     lda SCREEN,x
   //SEG14 [6] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG15 [2] phi from main::@2 to main::@1
+  //SEG15 [2] phi from main::@2 to main::@1 [phi:main::@2->main::@1]
   b1_from_b2:
-  //SEG16 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG16 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@2->main::@1#0] -- register_copy 
     jmp b1
 }
 
@@ -663,14 +663,14 @@ ASSEMBLER
 //SEG0 Global Constants & labels
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
 main: {
     .const SCREEN = $400
-  //SEG6 [2] phi from main to main::@1
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 2 -- xby=coby1 
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 2 [phi:main->main::@1#0] -- xby=coby1 
     ldx #2
   //SEG8 main::@1
   b1:
@@ -686,8 +686,8 @@ main: {
     lda SCREEN,x
   //SEG14 [6] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG15 [2] phi from main::@2 to main::@1
-  //SEG16 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG15 [2] phi from main::@2 to main::@1 [phi:main::@2->main::@1]
+  //SEG16 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@2->main::@1#0] -- register_copy 
     jmp b1
 }
 
@@ -713,14 +713,14 @@ FINAL CODE
 //SEG0 Global Constants & labels
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
 main: {
     .const SCREEN = $400
-  //SEG6 [2] phi from main to main::@1
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 2 -- xby=coby1 
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 2 [phi:main->main::@1#0] -- xby=coby1 
     ldx #2
   //SEG8 main::@1
   b1:
@@ -736,8 +736,8 @@ main: {
     lda SCREEN,x
   //SEG14 [6] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG15 [2] phi from main::@2 to main::@1
-  //SEG16 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG15 [2] phi from main::@2 to main::@1 [phi:main::@2->main::@1]
+  //SEG16 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@2->main::@1#0] -- register_copy 
     jmp b1
 }
 

src/main/java/dk/camelot64/kickc/test/ref/scroll-clobber.asm

@@ -12,15 +12,17 @@ main: {
   b1:
     ldy #0
     lda (nxt),y
-    cmp #'@'
+    tay
+    cpy #'@'
     bne b2
+    ldy TEXT
     lda #<TEXT
     sta nxt
     lda #>TEXT
     sta nxt+1
-    lda TEXT
   b2:
     inx
+    tya
     sta SCREEN,x
     inc nxt
     bne !+

src/main/java/dk/camelot64/kickc/test/ref/scroll-clobber.log

@@ -1,6 +1,6 @@
 byte* SCREEN = $0400;
 byte* SCROLL = $d016;
-byte[] TEXT = "tst @";
+byte[] TEXT = "01234567@";
 main();
 
 void main() {
@@ -22,7 +22,7 @@ Adding pre/post-modifier (byte*) main::nxt ← ++ (byte*) main::nxt
 PROGRAM
   (byte*) SCREEN ← (word) 1024
   (byte*) SCROLL ← (word) 53270
-  (byte[]) TEXT ← (string) "tst @"
+  (byte[]) TEXT ← (string) "01234567@"
   (void~) $0 ← call main 
 proc (void()) main()
   (byte*) main::nxt ← (byte[]) TEXT
@@ -66,7 +66,7 @@ INITIAL CONTROL FLOW GRAPH
 @begin: scope:[]  from
   (byte*) SCREEN ← (word) 1024
   (byte*) SCROLL ← (word) 53270
-  (byte[]) TEXT ← (string) "tst @"
+  (byte[]) TEXT ← (string) "01234567@"
   (void~) $0 ← call main 
   to:@1
 main: scope:[main]  from
@@ -106,7 +106,7 @@ CONTROL FLOW GRAPH
 @begin: scope:[]  from
   (byte*) SCREEN ← (word) 1024
   (byte*) SCROLL ← (word) 53270
-  (byte[]) TEXT ← (string) "tst @"
+  (byte[]) TEXT ← (string) "01234567@"
   (void~) $0 ← call main 
   to:@end
 main: scope:[main]  from
@@ -142,7 +142,7 @@ CONTROL FLOW GRAPH WITH ASSIGNMENT CALL
 @begin: scope:[]  from
   (byte*) SCREEN ← (word) 1024
   (byte*) SCROLL ← (word) 53270
-  (byte[]) TEXT ← (string) "tst @"
+  (byte[]) TEXT ← (string) "01234567@"
   call main param-assignment
   to:@2
 @2: scope:[]  from @begin
@@ -181,7 +181,7 @@ CONTROL FLOW GRAPH SSA
 @begin: scope:[]  from
   (byte*) SCREEN#0 ← (word) 1024
   (byte*) SCROLL#0 ← (word) 53270
-  (byte[]) TEXT#0 ← (string) "tst @"
+  (byte[]) TEXT#0 ← (string) "01234567@"
   call main param-assignment
   to:@2
 @2: scope:[]  from @begin
@@ -231,7 +231,7 @@ CONTROL FLOW GRAPH WITH ASSIGNMENT CALL & RETURN
 @begin: scope:[]  from
   (byte*) SCREEN#0 ← (word) 1024
   (byte*) SCROLL#0 ← (word) 53270
-  (byte[]) TEXT#0 ← (string) "tst @"
+  (byte[]) TEXT#0 ← (string) "01234567@"
   call main param-assignment
   to:@2
 @2: scope:[]  from @begin
@@ -327,7 +327,7 @@ CONTROL FLOW GRAPH
 @begin: scope:[]  from
   (byte*) SCREEN#0 ← (word) 1024
   (byte*) SCROLL#0 ← (word) 53270
-  (byte[]) TEXT#0 ← (string) "tst @"
+  (byte[]) TEXT#0 ← (string) "01234567@"
   call main param-assignment
   to:@end
 main: scope:[main]  from @begin
@@ -377,7 +377,7 @@ CONTROL FLOW GRAPH
 @begin: scope:[]  from
   (byte*) SCREEN#0 ← (word) 1024
   (byte*) SCROLL#0 ← (word) 53270
-  (byte[]) TEXT#0 ← (string) "tst @"
+  (byte[]) TEXT#0 ← (string) "01234567@"
   call main param-assignment
   to:@end
 main: scope:[main]  from @begin
@@ -434,7 +434,7 @@ CONTROL FLOW GRAPH
 @begin: scope:[]  from
   (byte*) SCREEN#0 ← (word) 1024
   (byte*) SCROLL#0 ← (word) 53270
-  (byte[]) TEXT#0 ← (string) "tst @"
+  (byte[]) TEXT#0 ← (string) "01234567@"
   call main param-assignment
   to:@end
 main: scope:[main]  from @begin
@@ -480,7 +480,7 @@ CONTROL FLOW GRAPH
 @begin: scope:[]  from
   (byte*) SCREEN#0 ← (word) 1024
   (byte*) SCROLL#0 ← (word) 53270
-  (byte[]) TEXT#0 ← (string) "tst @"
+  (byte[]) TEXT#0 ← (string) "01234567@"
   call main param-assignment
   to:@end
 main: scope:[main]  from @begin
@@ -520,7 +520,7 @@ CONTROL FLOW GRAPH
 @begin: scope:[]  from
   (byte*) SCREEN#0 ← (word) 1024
   (byte*) SCROLL#0 ← (word) 53270
-  (byte[]) TEXT#0 ← (string) "tst @"
+  (byte[]) TEXT#0 ← (string) "01234567@"
   call main param-assignment
   to:@end
 main: scope:[main]  from @begin
@@ -559,7 +559,7 @@ CONTROL FLOW GRAPH
 @begin: scope:[]  from
   (byte*) SCREEN#0 ← (word) 1024
   (byte*) SCROLL#0 ← (word) 53270
-  (byte[]) TEXT#0 ← (string) "tst @"
+  (byte[]) TEXT#0 ← (string) "01234567@"
   call main param-assignment
   to:@end
 main: scope:[main]  from @begin
@@ -593,7 +593,7 @@ main::@return: scope:[main]  from main::@2
 
 Constant (const byte*) SCREEN#0 = 1024
 Constant (const byte*) SCROLL#0 = 53270
-Constant (const byte[]) TEXT#0 = "tst @"
+Constant (const byte[]) TEXT#0 = "01234567@"
 Constant (const byte) main::i#0 = 0
 Succesful SSA optimization Pass2ConstantIdentification
 CONTROL FLOW GRAPH
@@ -733,7 +733,7 @@ FINAL SYMBOL TABLE
 (byte*) SCROLL
 (const byte*) SCROLL#0 = (word) 53270
 (byte[]) TEXT
-(const byte[]) TEXT#0 = (string) "tst @"
+(const byte[]) TEXT#0 = (string) "01234567@"
 (void()) main()
 (label) main::@1
 (label) main::@2
@@ -938,11 +938,11 @@ INITIAL ASM
 //SEG0 Global Constants & labels
   .const SCREEN = $400
   .const SCROLL = $d016
-  TEXT: .text "tst @"
+  TEXT: .text "01234567@"
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
 main_from_bbegin:
   jsr main
   jmp bend
@@ -953,21 +953,21 @@ main: {
     .label c = 3
     .label i = 2
     .label nxt = 4
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte) main::i#3 = (byte) 0 -- zpby1=coby1 
+  //SEG7 [2] phi (byte) main::i#3 = (byte) 0 [phi:main->main::@1#0] -- zpby1=coby1 
     lda #0
     sta i
-  //SEG8 [2] phi (byte*) main::nxt#3 = (const byte[]) TEXT#0 -- zpptrby1=cowo1 
+  //SEG8 [2] phi (byte*) main::nxt#3 = (const byte[]) TEXT#0 [phi:main->main::@1#1] -- zpptrby1=cowo1 
     lda #<TEXT
     sta nxt
     lda #>TEXT
     sta nxt+1
     jmp b1
-  //SEG9 [2] phi from main::@2 to main::@1
+  //SEG9 [2] phi from main::@2 to main::@1 [phi:main::@2->main::@1]
   b1_from_b2:
-  //SEG10 [2] phi (byte) main::i#3 = (byte) main::i#1 -- register_copy 
-  //SEG11 [2] phi (byte*) main::nxt#3 = (byte*) main::nxt#1 -- register_copy 
+  //SEG10 [2] phi (byte) main::i#3 = (byte) main::i#1 [phi:main::@2->main::@1#0] -- register_copy 
+  //SEG11 [2] phi (byte*) main::nxt#3 = (byte*) main::nxt#1 [phi:main::@2->main::@1#1] -- register_copy 
     jmp b1
   //SEG12 main::@1
   b1:
@@ -985,19 +985,19 @@ main: {
   //SEG16 [5] (byte) main::c#1 ← * (const byte[]) TEXT#0 [ main::i#3 main::c#1 ] -- zpby1=_star_cowo1 
     lda TEXT
     sta c
-  //SEG17 [6] phi from main::@3 to main::@2
+  //SEG17 [6] phi from main::@3 to main::@2 [phi:main::@3->main::@2]
   b2_from_b3:
-  //SEG18 [6] phi (byte*) main::nxt#4 = (const byte[]) TEXT#0 -- zpptrby1=cowo1 
+  //SEG18 [6] phi (byte*) main::nxt#4 = (const byte[]) TEXT#0 [phi:main::@3->main::@2#0] -- zpptrby1=cowo1 
     lda #<TEXT
     sta nxt
     lda #>TEXT
     sta nxt+1
-  //SEG19 [6] phi (byte) main::c#2 = (byte) main::c#1 -- register_copy 
+  //SEG19 [6] phi (byte) main::c#2 = (byte) main::c#1 [phi:main::@3->main::@2#1] -- register_copy 
     jmp b2
-  //SEG20 [6] phi from main::@1 to main::@2
+  //SEG20 [6] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
   b2_from_b1:
-  //SEG21 [6] phi (byte*) main::nxt#4 = (byte*) main::nxt#3 -- register_copy 
-  //SEG22 [6] phi (byte) main::c#2 = (byte) main::c#0 -- register_copy 
+  //SEG21 [6] phi (byte*) main::nxt#4 = (byte*) main::nxt#3 [phi:main::@1->main::@2#0] -- register_copy 
+  //SEG22 [6] phi (byte) main::c#2 = (byte) main::c#0 [phi:main::@1->main::@2#1] -- register_copy 
     jmp b2
   //SEG23 main::@2
   b2:
@@ -1034,8 +1034,8 @@ REGISTER UPLIFT SCOPES
 Uplift Scope [main] 55: zp ZP_BYTE:3 [ main::c#2 main::c#0 main::c#1 ] 29.33: zp ZP_PTR_BYTE:4 [ main::nxt#4 main::nxt#3 main::nxt#1 ] 12.65: zp ZP_BYTE:2 [ main::i#3 main::i#1 ] 
 Uplift Scope [] 
 
-Uplifting [main] best 800 combination reg byte a [ main::c#2 main::c#0 main::c#1 ] zp ZP_PTR_BYTE:4 [ main::nxt#4 main::nxt#3 main::nxt#1 ] reg byte x [ main::i#3 main::i#1 ] 
-Uplifting [] best 800 combination 
+Uplifting [main] best 840 combination reg byte y [ main::c#2 main::c#0 main::c#1 ] zp ZP_PTR_BYTE:4 [ main::nxt#4 main::nxt#3 main::nxt#1 ] reg byte x [ main::i#3 main::i#1 ] 
+Uplifting [] best 840 combination 
 Allocated (was zp ZP_PTR_BYTE:4) zp ZP_PTR_BYTE:2 [ main::nxt#4 main::nxt#3 main::nxt#1 ]
 Removing instruction jmp bend
 Removing instruction jmp b1
@@ -1047,11 +1047,11 @@ ASSEMBLER
 //SEG0 Global Constants & labels
   .const SCREEN = $400
   .const SCROLL = $d016
-  TEXT: .text "tst @"
+  TEXT: .text "01234567@"
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
 main_from_bbegin:
   jsr main
 //SEG4 @end
@@ -1059,50 +1059,52 @@ bend:
 //SEG5 main
 main: {
     .label nxt = 2
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte) main::i#3 = (byte) 0 -- xby=coby1 
+  //SEG7 [2] phi (byte) main::i#3 = (byte) 0 [phi:main->main::@1#0] -- xby=coby1 
     ldx #0
-  //SEG8 [2] phi (byte*) main::nxt#3 = (const byte[]) TEXT#0 -- zpptrby1=cowo1 
+  //SEG8 [2] phi (byte*) main::nxt#3 = (const byte[]) TEXT#0 [phi:main->main::@1#1] -- zpptrby1=cowo1 
     lda #<TEXT
     sta nxt
     lda #>TEXT
     sta nxt+1
     jmp b1
-  //SEG9 [2] phi from main::@2 to main::@1
+  //SEG9 [2] phi from main::@2 to main::@1 [phi:main::@2->main::@1]
   b1_from_b2:
-  //SEG10 [2] phi (byte) main::i#3 = (byte) main::i#1 -- register_copy 
-  //SEG11 [2] phi (byte*) main::nxt#3 = (byte*) main::nxt#1 -- register_copy 
+  //SEG10 [2] phi (byte) main::i#3 = (byte) main::i#1 [phi:main::@2->main::@1#0] -- register_copy 
+  //SEG11 [2] phi (byte*) main::nxt#3 = (byte*) main::nxt#1 [phi:main::@2->main::@1#1] -- register_copy 
   //SEG12 main::@1
   b1:
-  //SEG13 [3] (byte) main::c#0 ← * (byte*) main::nxt#3 [ main::nxt#3 main::i#3 main::c#0 ] -- aby=_star_zpptrby1 
+  //SEG13 [3] (byte) main::c#0 ← * (byte*) main::nxt#3 [ main::nxt#3 main::i#3 main::c#0 ] -- yby=_star_zpptrby1 
     ldy #0
     lda (nxt),y
-  //SEG14 [4] if((byte) main::c#0!=(byte) '@') goto main::@2 [ main::nxt#3 main::i#3 main::c#0 ] -- aby_neq_coby1_then_la1 
-    cmp #'@'
+    tay
+  //SEG14 [4] if((byte) main::c#0!=(byte) '@') goto main::@2 [ main::nxt#3 main::i#3 main::c#0 ] -- yby_neq_coby1_then_la1 
+    cpy #'@'
     bne b2_from_b1
   //SEG15 main::@3
   b3:
-  //SEG16 [5] (byte) main::c#1 ← * (const byte[]) TEXT#0 [ main::i#3 main::c#1 ] -- aby=_star_cowo1 
-    lda TEXT
-  //SEG17 [6] phi from main::@3 to main::@2
+  //SEG16 [5] (byte) main::c#1 ← * (const byte[]) TEXT#0 [ main::i#3 main::c#1 ] -- yby=_star_cowo1 
+    ldy TEXT
+  //SEG17 [6] phi from main::@3 to main::@2 [phi:main::@3->main::@2]
   b2_from_b3:
-  //SEG18 [6] phi (byte*) main::nxt#4 = (const byte[]) TEXT#0 -- zpptrby1=cowo1 
+  //SEG18 [6] phi (byte*) main::nxt#4 = (const byte[]) TEXT#0 [phi:main::@3->main::@2#0] -- zpptrby1=cowo1 
     lda #<TEXT
     sta nxt
     lda #>TEXT
     sta nxt+1
-  //SEG19 [6] phi (byte) main::c#2 = (byte) main::c#1 -- register_copy 
+  //SEG19 [6] phi (byte) main::c#2 = (byte) main::c#1 [phi:main::@3->main::@2#1] -- register_copy 
     jmp b2
-  //SEG20 [6] phi from main::@1 to main::@2
+  //SEG20 [6] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
   b2_from_b1:
-  //SEG21 [6] phi (byte*) main::nxt#4 = (byte*) main::nxt#3 -- register_copy 
-  //SEG22 [6] phi (byte) main::c#2 = (byte) main::c#0 -- register_copy 
+  //SEG21 [6] phi (byte*) main::nxt#4 = (byte*) main::nxt#3 [phi:main::@1->main::@2#0] -- register_copy 
+  //SEG22 [6] phi (byte) main::c#2 = (byte) main::c#0 [phi:main::@1->main::@2#1] -- register_copy 
   //SEG23 main::@2
   b2:
   //SEG24 [7] (byte) main::i#1 ← ++ (byte) main::i#3 [ main::i#1 main::c#2 main::nxt#4 ] -- xby=_inc_xby 
     inx
-  //SEG25 [8] *((const byte*) SCREEN#0 + (byte) main::i#1) ← (byte) main::c#2 [ main::i#1 main::nxt#4 ] -- cowo1_staridx_xby=aby 
+  //SEG25 [8] *((const byte*) SCREEN#0 + (byte) main::i#1) ← (byte) main::c#2 [ main::i#1 main::nxt#4 ] -- cowo1_staridx_xby=yby 
+    tya
     sta SCREEN,x
   //SEG26 [9] (byte*) main::nxt#1 ← ++ (byte*) main::nxt#4 [ main::nxt#1 main::i#1 ] -- zpptrby1=_inc_zpptrby1 
     inc nxt
@@ -1127,59 +1129,61 @@ ASSEMBLER
 //SEG0 Global Constants & labels
   .const SCREEN = $400
   .const SCROLL = $d016
-  TEXT: .text "tst @"
+  TEXT: .text "01234567@"
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 bend:
 //SEG5 main
 main: {
     .label nxt = 2
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte) main::i#3 = (byte) 0 -- xby=coby1 
+  //SEG7 [2] phi (byte) main::i#3 = (byte) 0 [phi:main->main::@1#0] -- xby=coby1 
     ldx #0
-  //SEG8 [2] phi (byte*) main::nxt#3 = (const byte[]) TEXT#0 -- zpptrby1=cowo1 
+  //SEG8 [2] phi (byte*) main::nxt#3 = (const byte[]) TEXT#0 [phi:main->main::@1#1] -- zpptrby1=cowo1 
     lda #<TEXT
     sta nxt
     lda #>TEXT
     sta nxt+1
     jmp b1
-  //SEG9 [2] phi from main::@2 to main::@1
-  //SEG10 [2] phi (byte) main::i#3 = (byte) main::i#1 -- register_copy 
-  //SEG11 [2] phi (byte*) main::nxt#3 = (byte*) main::nxt#1 -- register_copy 
+  //SEG9 [2] phi from main::@2 to main::@1 [phi:main::@2->main::@1]
+  //SEG10 [2] phi (byte) main::i#3 = (byte) main::i#1 [phi:main::@2->main::@1#0] -- register_copy 
+  //SEG11 [2] phi (byte*) main::nxt#3 = (byte*) main::nxt#1 [phi:main::@2->main::@1#1] -- register_copy 
   //SEG12 main::@1
   b1:
-  //SEG13 [3] (byte) main::c#0 ← * (byte*) main::nxt#3 [ main::nxt#3 main::i#3 main::c#0 ] -- aby=_star_zpptrby1 
+  //SEG13 [3] (byte) main::c#0 ← * (byte*) main::nxt#3 [ main::nxt#3 main::i#3 main::c#0 ] -- yby=_star_zpptrby1 
     ldy #0
     lda (nxt),y
-  //SEG14 [4] if((byte) main::c#0!=(byte) '@') goto main::@2 [ main::nxt#3 main::i#3 main::c#0 ] -- aby_neq_coby1_then_la1 
-    cmp #'@'
+    tay
+  //SEG14 [4] if((byte) main::c#0!=(byte) '@') goto main::@2 [ main::nxt#3 main::i#3 main::c#0 ] -- yby_neq_coby1_then_la1 
+    cpy #'@'
     bne b2
   //SEG15 main::@3
   b3:
-  //SEG16 [5] (byte) main::c#1 ← * (const byte[]) TEXT#0 [ main::i#3 main::c#1 ] -- aby=_star_cowo1 
-    lda TEXT
-  //SEG17 [6] phi from main::@3 to main::@2
+  //SEG16 [5] (byte) main::c#1 ← * (const byte[]) TEXT#0 [ main::i#3 main::c#1 ] -- yby=_star_cowo1 
+    ldy TEXT
+  //SEG17 [6] phi from main::@3 to main::@2 [phi:main::@3->main::@2]
   b2_from_b3:
-  //SEG18 [6] phi (byte*) main::nxt#4 = (const byte[]) TEXT#0 -- zpptrby1=cowo1 
+  //SEG18 [6] phi (byte*) main::nxt#4 = (const byte[]) TEXT#0 [phi:main::@3->main::@2#0] -- zpptrby1=cowo1 
     lda #<TEXT
     sta nxt
     lda #>TEXT
     sta nxt+1
-  //SEG19 [6] phi (byte) main::c#2 = (byte) main::c#1 -- register_copy 
+  //SEG19 [6] phi (byte) main::c#2 = (byte) main::c#1 [phi:main::@3->main::@2#1] -- register_copy 
     jmp b2
-  //SEG20 [6] phi from main::@1 to main::@2
-  //SEG21 [6] phi (byte*) main::nxt#4 = (byte*) main::nxt#3 -- register_copy 
-  //SEG22 [6] phi (byte) main::c#2 = (byte) main::c#0 -- register_copy 
+  //SEG20 [6] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
+  //SEG21 [6] phi (byte*) main::nxt#4 = (byte*) main::nxt#3 [phi:main::@1->main::@2#0] -- register_copy 
+  //SEG22 [6] phi (byte) main::c#2 = (byte) main::c#0 [phi:main::@1->main::@2#1] -- register_copy 
   //SEG23 main::@2
   b2:
   //SEG24 [7] (byte) main::i#1 ← ++ (byte) main::i#3 [ main::i#1 main::c#2 main::nxt#4 ] -- xby=_inc_xby 
     inx
-  //SEG25 [8] *((const byte*) SCREEN#0 + (byte) main::i#1) ← (byte) main::c#2 [ main::i#1 main::nxt#4 ] -- cowo1_staridx_xby=aby 
+  //SEG25 [8] *((const byte*) SCREEN#0 + (byte) main::i#1) ← (byte) main::c#2 [ main::i#1 main::nxt#4 ] -- cowo1_staridx_xby=yby 
+    tya
     sta SCREEN,x
   //SEG26 [9] (byte*) main::nxt#1 ← ++ (byte*) main::nxt#4 [ main::nxt#1 main::i#1 ] -- zpptrby1=_inc_zpptrby1 
     inc nxt
@@ -1205,54 +1209,56 @@ ASSEMBLER
 //SEG0 Global Constants & labels
   .const SCREEN = $400
   .const SCROLL = $d016
-  TEXT: .text "tst @"
+  TEXT: .text "01234567@"
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
 main: {
     .label nxt = 2
-  //SEG6 [2] phi from main to main::@1
-  //SEG7 [2] phi (byte) main::i#3 = (byte) 0 -- xby=coby1 
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG7 [2] phi (byte) main::i#3 = (byte) 0 [phi:main->main::@1#0] -- xby=coby1 
     ldx #0
-  //SEG8 [2] phi (byte*) main::nxt#3 = (const byte[]) TEXT#0 -- zpptrby1=cowo1 
+  //SEG8 [2] phi (byte*) main::nxt#3 = (const byte[]) TEXT#0 [phi:main->main::@1#1] -- zpptrby1=cowo1 
     lda #<TEXT
     sta nxt
     lda #>TEXT
     sta nxt+1
     jmp b1
-  //SEG9 [2] phi from main::@2 to main::@1
-  //SEG10 [2] phi (byte) main::i#3 = (byte) main::i#1 -- register_copy 
-  //SEG11 [2] phi (byte*) main::nxt#3 = (byte*) main::nxt#1 -- register_copy 
+  //SEG9 [2] phi from main::@2 to main::@1 [phi:main::@2->main::@1]
+  //SEG10 [2] phi (byte) main::i#3 = (byte) main::i#1 [phi:main::@2->main::@1#0] -- register_copy 
+  //SEG11 [2] phi (byte*) main::nxt#3 = (byte*) main::nxt#1 [phi:main::@2->main::@1#1] -- register_copy 
   //SEG12 main::@1
   b1:
-  //SEG13 [3] (byte) main::c#0 ← * (byte*) main::nxt#3 [ main::nxt#3 main::i#3 main::c#0 ] -- aby=_star_zpptrby1 
+  //SEG13 [3] (byte) main::c#0 ← * (byte*) main::nxt#3 [ main::nxt#3 main::i#3 main::c#0 ] -- yby=_star_zpptrby1 
     ldy #0
     lda (nxt),y
-  //SEG14 [4] if((byte) main::c#0!=(byte) '@') goto main::@2 [ main::nxt#3 main::i#3 main::c#0 ] -- aby_neq_coby1_then_la1 
-    cmp #'@'
+    tay
+  //SEG14 [4] if((byte) main::c#0!=(byte) '@') goto main::@2 [ main::nxt#3 main::i#3 main::c#0 ] -- yby_neq_coby1_then_la1 
+    cpy #'@'
     bne b2
   //SEG15 main::@3
-  //SEG16 [5] (byte) main::c#1 ← * (const byte[]) TEXT#0 [ main::i#3 main::c#1 ] -- aby=_star_cowo1 
-    lda TEXT
-  //SEG17 [6] phi from main::@3 to main::@2
-  //SEG18 [6] phi (byte*) main::nxt#4 = (const byte[]) TEXT#0 -- zpptrby1=cowo1 
+  //SEG16 [5] (byte) main::c#1 ← * (const byte[]) TEXT#0 [ main::i#3 main::c#1 ] -- yby=_star_cowo1 
+    ldy TEXT
+  //SEG17 [6] phi from main::@3 to main::@2 [phi:main::@3->main::@2]
+  //SEG18 [6] phi (byte*) main::nxt#4 = (const byte[]) TEXT#0 [phi:main::@3->main::@2#0] -- zpptrby1=cowo1 
     lda #<TEXT
     sta nxt
     lda #>TEXT
     sta nxt+1
-  //SEG19 [6] phi (byte) main::c#2 = (byte) main::c#1 -- register_copy 
+  //SEG19 [6] phi (byte) main::c#2 = (byte) main::c#1 [phi:main::@3->main::@2#1] -- register_copy 
     jmp b2
-  //SEG20 [6] phi from main::@1 to main::@2
-  //SEG21 [6] phi (byte*) main::nxt#4 = (byte*) main::nxt#3 -- register_copy 
-  //SEG22 [6] phi (byte) main::c#2 = (byte) main::c#0 -- register_copy 
+  //SEG20 [6] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
+  //SEG21 [6] phi (byte*) main::nxt#4 = (byte*) main::nxt#3 [phi:main::@1->main::@2#0] -- register_copy 
+  //SEG22 [6] phi (byte) main::c#2 = (byte) main::c#0 [phi:main::@1->main::@2#1] -- register_copy 
   //SEG23 main::@2
   b2:
   //SEG24 [7] (byte) main::i#1 ← ++ (byte) main::i#3 [ main::i#1 main::c#2 main::nxt#4 ] -- xby=_inc_xby 
     inx
-  //SEG25 [8] *((const byte*) SCREEN#0 + (byte) main::i#1) ← (byte) main::c#2 [ main::i#1 main::nxt#4 ] -- cowo1_staridx_xby=aby 
+  //SEG25 [8] *((const byte*) SCREEN#0 + (byte) main::i#1) ← (byte) main::c#2 [ main::i#1 main::nxt#4 ] -- cowo1_staridx_xby=yby 
+    tya
     sta SCREEN,x
   //SEG26 [9] (byte*) main::nxt#1 ← ++ (byte*) main::nxt#4 [ main::nxt#1 main::i#1 ] -- zpptrby1=_inc_zpptrby1 
     inc nxt
@@ -1273,52 +1279,54 @@ ASSEMBLER
 //SEG0 Global Constants & labels
   .const SCREEN = $400
   .const SCROLL = $d016
-  TEXT: .text "tst @"
+  TEXT: .text "01234567@"
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
 main: {
     .label nxt = 2
-  //SEG6 [2] phi from main to main::@1
-  //SEG7 [2] phi (byte) main::i#3 = (byte) 0 -- xby=coby1 
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG7 [2] phi (byte) main::i#3 = (byte) 0 [phi:main->main::@1#0] -- xby=coby1 
     ldx #0
-  //SEG8 [2] phi (byte*) main::nxt#3 = (const byte[]) TEXT#0 -- zpptrby1=cowo1 
+  //SEG8 [2] phi (byte*) main::nxt#3 = (const byte[]) TEXT#0 [phi:main->main::@1#1] -- zpptrby1=cowo1 
     lda #<TEXT
     sta nxt
     lda #>TEXT
     sta nxt+1
-  //SEG9 [2] phi from main::@2 to main::@1
-  //SEG10 [2] phi (byte) main::i#3 = (byte) main::i#1 -- register_copy 
-  //SEG11 [2] phi (byte*) main::nxt#3 = (byte*) main::nxt#1 -- register_copy 
+  //SEG9 [2] phi from main::@2 to main::@1 [phi:main::@2->main::@1]
+  //SEG10 [2] phi (byte) main::i#3 = (byte) main::i#1 [phi:main::@2->main::@1#0] -- register_copy 
+  //SEG11 [2] phi (byte*) main::nxt#3 = (byte*) main::nxt#1 [phi:main::@2->main::@1#1] -- register_copy 
   //SEG12 main::@1
   b1:
-  //SEG13 [3] (byte) main::c#0 ← * (byte*) main::nxt#3 [ main::nxt#3 main::i#3 main::c#0 ] -- aby=_star_zpptrby1 
+  //SEG13 [3] (byte) main::c#0 ← * (byte*) main::nxt#3 [ main::nxt#3 main::i#3 main::c#0 ] -- yby=_star_zpptrby1 
     ldy #0
     lda (nxt),y
-  //SEG14 [4] if((byte) main::c#0!=(byte) '@') goto main::@2 [ main::nxt#3 main::i#3 main::c#0 ] -- aby_neq_coby1_then_la1 
-    cmp #'@'
+    tay
+  //SEG14 [4] if((byte) main::c#0!=(byte) '@') goto main::@2 [ main::nxt#3 main::i#3 main::c#0 ] -- yby_neq_coby1_then_la1 
+    cpy #'@'
     bne b2
   //SEG15 main::@3
-  //SEG16 [5] (byte) main::c#1 ← * (const byte[]) TEXT#0 [ main::i#3 main::c#1 ] -- aby=_star_cowo1 
-    lda TEXT
-  //SEG17 [6] phi from main::@3 to main::@2
-  //SEG18 [6] phi (byte*) main::nxt#4 = (const byte[]) TEXT#0 -- zpptrby1=cowo1 
+  //SEG16 [5] (byte) main::c#1 ← * (const byte[]) TEXT#0 [ main::i#3 main::c#1 ] -- yby=_star_cowo1 
+    ldy TEXT
+  //SEG17 [6] phi from main::@3 to main::@2 [phi:main::@3->main::@2]
+  //SEG18 [6] phi (byte*) main::nxt#4 = (const byte[]) TEXT#0 [phi:main::@3->main::@2#0] -- zpptrby1=cowo1 
     lda #<TEXT
     sta nxt
     lda #>TEXT
     sta nxt+1
-  //SEG19 [6] phi (byte) main::c#2 = (byte) main::c#1 -- register_copy 
-  //SEG20 [6] phi from main::@1 to main::@2
-  //SEG21 [6] phi (byte*) main::nxt#4 = (byte*) main::nxt#3 -- register_copy 
-  //SEG22 [6] phi (byte) main::c#2 = (byte) main::c#0 -- register_copy 
+  //SEG19 [6] phi (byte) main::c#2 = (byte) main::c#1 [phi:main::@3->main::@2#1] -- register_copy 
+  //SEG20 [6] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
+  //SEG21 [6] phi (byte*) main::nxt#4 = (byte*) main::nxt#3 [phi:main::@1->main::@2#0] -- register_copy 
+  //SEG22 [6] phi (byte) main::c#2 = (byte) main::c#0 [phi:main::@1->main::@2#1] -- register_copy 
   //SEG23 main::@2
   b2:
   //SEG24 [7] (byte) main::i#1 ← ++ (byte) main::i#3 [ main::i#1 main::c#2 main::nxt#4 ] -- xby=_inc_xby 
     inx
-  //SEG25 [8] *((const byte*) SCREEN#0 + (byte) main::i#1) ← (byte) main::c#2 [ main::i#1 main::nxt#4 ] -- cowo1_staridx_xby=aby 
+  //SEG25 [8] *((const byte*) SCREEN#0 + (byte) main::i#1) ← (byte) main::c#2 [ main::i#1 main::nxt#4 ] -- cowo1_staridx_xby=yby 
+    tya
     sta SCREEN,x
   //SEG26 [9] (byte*) main::nxt#1 ← ++ (byte*) main::nxt#4 [ main::nxt#1 main::i#1 ] -- zpptrby1=_inc_zpptrby1 
     inc nxt
@@ -1340,16 +1348,16 @@ FINAL SYMBOL TABLE
 (byte*) SCROLL
 (const byte*) SCROLL#0 SCROLL = (word) 53270
 (byte[]) TEXT
-(const byte[]) TEXT#0 TEXT = (string) "tst @"
+(const byte[]) TEXT#0 TEXT = (string) "01234567@"
 (void()) main()
 (label) main::@1
 (label) main::@2
 (label) main::@3
 (label) main::@return
 (byte) main::c
-(byte) main::c#0 reg byte a 16.5
-(byte) main::c#1 reg byte a 22.0
-(byte) main::c#2 reg byte a 16.5
+(byte) main::c#0 reg byte y 16.5
+(byte) main::c#1 reg byte y 22.0
+(byte) main::c#2 reg byte y 16.5
 (byte) main::i
 (byte) main::i#1 reg byte x 8.25
 (byte) main::i#3 reg byte x 4.4
@@ -1359,59 +1367,61 @@ FINAL SYMBOL TABLE
 (byte*) main::nxt#4 nxt zp ZP_PTR_BYTE:2 7.333333333333333
 
 reg byte x [ main::i#3 main::i#1 ]
-reg byte a [ main::c#2 main::c#0 main::c#1 ]
+reg byte y [ main::c#2 main::c#0 main::c#1 ]
 zp ZP_PTR_BYTE:2 [ main::nxt#4 main::nxt#3 main::nxt#1 ]
 
 FINAL CODE
 //SEG0 Global Constants & labels
   .const SCREEN = $400
   .const SCROLL = $d016
-  TEXT: .text "tst @"
+  TEXT: .text "01234567@"
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
 main: {
     .label nxt = 2
-  //SEG6 [2] phi from main to main::@1
-  //SEG7 [2] phi (byte) main::i#3 = (byte) 0 -- xby=coby1 
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG7 [2] phi (byte) main::i#3 = (byte) 0 [phi:main->main::@1#0] -- xby=coby1 
     ldx #0
-  //SEG8 [2] phi (byte*) main::nxt#3 = (const byte[]) TEXT#0 -- zpptrby1=cowo1 
+  //SEG8 [2] phi (byte*) main::nxt#3 = (const byte[]) TEXT#0 [phi:main->main::@1#1] -- zpptrby1=cowo1 
     lda #<TEXT
     sta nxt
     lda #>TEXT
     sta nxt+1
-  //SEG9 [2] phi from main::@2 to main::@1
-  //SEG10 [2] phi (byte) main::i#3 = (byte) main::i#1 -- register_copy 
-  //SEG11 [2] phi (byte*) main::nxt#3 = (byte*) main::nxt#1 -- register_copy 
+  //SEG9 [2] phi from main::@2 to main::@1 [phi:main::@2->main::@1]
+  //SEG10 [2] phi (byte) main::i#3 = (byte) main::i#1 [phi:main::@2->main::@1#0] -- register_copy 
+  //SEG11 [2] phi (byte*) main::nxt#3 = (byte*) main::nxt#1 [phi:main::@2->main::@1#1] -- register_copy 
   //SEG12 main::@1
   b1:
-  //SEG13 [3] (byte) main::c#0 ← * (byte*) main::nxt#3 [ main::nxt#3 main::i#3 main::c#0 ] -- aby=_star_zpptrby1 
+  //SEG13 [3] (byte) main::c#0 ← * (byte*) main::nxt#3 [ main::nxt#3 main::i#3 main::c#0 ] -- yby=_star_zpptrby1 
     ldy #0
     lda (nxt),y
-  //SEG14 [4] if((byte) main::c#0!=(byte) '@') goto main::@2 [ main::nxt#3 main::i#3 main::c#0 ] -- aby_neq_coby1_then_la1 
-    cmp #'@'
+    tay
+  //SEG14 [4] if((byte) main::c#0!=(byte) '@') goto main::@2 [ main::nxt#3 main::i#3 main::c#0 ] -- yby_neq_coby1_then_la1 
+    cpy #'@'
     bne b2
   //SEG15 main::@3
-  //SEG16 [5] (byte) main::c#1 ← * (const byte[]) TEXT#0 [ main::i#3 main::c#1 ] -- aby=_star_cowo1 
-    lda TEXT
-  //SEG17 [6] phi from main::@3 to main::@2
-  //SEG18 [6] phi (byte*) main::nxt#4 = (const byte[]) TEXT#0 -- zpptrby1=cowo1 
+  //SEG16 [5] (byte) main::c#1 ← * (const byte[]) TEXT#0 [ main::i#3 main::c#1 ] -- yby=_star_cowo1 
+    ldy TEXT
+  //SEG17 [6] phi from main::@3 to main::@2 [phi:main::@3->main::@2]
+  //SEG18 [6] phi (byte*) main::nxt#4 = (const byte[]) TEXT#0 [phi:main::@3->main::@2#0] -- zpptrby1=cowo1 
     lda #<TEXT
     sta nxt
     lda #>TEXT
     sta nxt+1
-  //SEG19 [6] phi (byte) main::c#2 = (byte) main::c#1 -- register_copy 
-  //SEG20 [6] phi from main::@1 to main::@2
-  //SEG21 [6] phi (byte*) main::nxt#4 = (byte*) main::nxt#3 -- register_copy 
-  //SEG22 [6] phi (byte) main::c#2 = (byte) main::c#0 -- register_copy 
+  //SEG19 [6] phi (byte) main::c#2 = (byte) main::c#1 [phi:main::@3->main::@2#1] -- register_copy 
+  //SEG20 [6] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
+  //SEG21 [6] phi (byte*) main::nxt#4 = (byte*) main::nxt#3 [phi:main::@1->main::@2#0] -- register_copy 
+  //SEG22 [6] phi (byte) main::c#2 = (byte) main::c#0 [phi:main::@1->main::@2#1] -- register_copy 
   //SEG23 main::@2
   b2:
   //SEG24 [7] (byte) main::i#1 ← ++ (byte) main::i#3 [ main::i#1 main::c#2 main::nxt#4 ] -- xby=_inc_xby 
     inx
-  //SEG25 [8] *((const byte*) SCREEN#0 + (byte) main::i#1) ← (byte) main::c#2 [ main::i#1 main::nxt#4 ] -- cowo1_staridx_xby=aby 
+  //SEG25 [8] *((const byte*) SCREEN#0 + (byte) main::i#1) ← (byte) main::c#2 [ main::i#1 main::nxt#4 ] -- cowo1_staridx_xby=yby 
+    tya
     sta SCREEN,x
   //SEG26 [9] (byte*) main::nxt#1 ← ++ (byte*) main::nxt#4 [ main::nxt#1 main::i#1 ] -- zpptrby1=_inc_zpptrby1 
     inc nxt

src/main/java/dk/camelot64/kickc/test/ref/scroll-clobber.sym

@@ -5,16 +5,16 @@
 (byte*) SCROLL
 (const byte*) SCROLL#0 SCROLL = (word) 53270
 (byte[]) TEXT
-(const byte[]) TEXT#0 TEXT = (string) "tst @"
+(const byte[]) TEXT#0 TEXT = (string) "01234567@"
 (void()) main()
 (label) main::@1
 (label) main::@2
 (label) main::@3
 (label) main::@return
 (byte) main::c
-(byte) main::c#0 reg byte a 16.5
-(byte) main::c#1 reg byte a 22.0
-(byte) main::c#2 reg byte a 16.5
+(byte) main::c#0 reg byte y 16.5
+(byte) main::c#1 reg byte y 22.0
+(byte) main::c#2 reg byte y 16.5
 (byte) main::i
 (byte) main::i#1 reg byte x 8.25
 (byte) main::i#3 reg byte x 4.4
@@ -24,5 +24,5 @@
 (byte*) main::nxt#4 nxt zp ZP_PTR_BYTE:2 7.333333333333333
 
 reg byte x [ main::i#3 main::i#1 ]
-reg byte a [ main::c#2 main::c#0 main::c#1 ]
+reg byte y [ main::c#2 main::c#0 main::c#1 ]
 zp ZP_PTR_BYTE:2 [ main::nxt#4 main::nxt#3 main::nxt#1 ]

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

@@ -37,15 +37,16 @@ main: {
     bne b5
     ldy #0
     lda (nxt),y
-    cmp #'@'
+    tax
+    cpx #'@'
     bne b6
+    ldx TEXT
     lda #<TEXT
     sta nxt
     lda #>TEXT
     sta nxt+1
-    lda TEXT
   b6:
-    sta line+$27
+    stx line+$27
     inc nxt
     bne !+
     inc nxt+1

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

@@ -37,9 +37,9 @@
 (label) main::@8
 (label) main::@return
 (byte) main::c
-(byte) main::c#0 reg byte a 16.5
-(byte) main::c#1 reg byte a 22.0
-(byte) main::c#2 reg byte a 33.0
+(byte) main::c#0 reg byte x 16.5
+(byte) main::c#1 reg byte x 22.0
+(byte) main::c#2 reg byte x 33.0
 (byte) main::i
 (byte) main::i#1 reg byte x 151.5
 (byte) main::i#2 reg byte x 134.66666666666666
@@ -57,7 +57,7 @@
 
 reg byte x [ main::scroll#3 main::scroll#10 main::scroll#1 ]
 reg byte x [ main::i#2 main::i#1 ]
-reg byte a [ main::c#2 main::c#0 main::c#1 ]
+reg byte x [ main::c#2 main::c#0 main::c#1 ]
 zp ZP_PTR_BYTE:2 [ main::nxt#4 main::nxt#3 main::nxt#10 main::nxt#1 fillscreen::cursor#2 fillscreen::cursor#1 ]
 reg byte a [ main::$2 ]
 reg byte a [ main::$4 ]

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

@@ -585,12 +585,12 @@ INITIAL ASM
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call sum param-assignment [ sum::return#0 ]
-//SEG3 [8] phi from @begin to sum
+//SEG3 [8] phi from @begin to sum [phi:@begin->sum]
 sum_from_bbegin:
-//SEG4 [8] phi (byte) sum::b#3 = (byte) 2 -- zpby1=coby1 
+//SEG4 [8] phi (byte) sum::b#3 = (byte) 2 [phi:@begin->sum#0] -- zpby1=coby1 
   lda #2
   sta sum.b
-//SEG5 [8] phi (byte) sum::a#3 = (byte) 1 -- zpby1=coby1 
+//SEG5 [8] phi (byte) sum::a#3 = (byte) 1 [phi:@begin->sum#1] -- zpby1=coby1 
   lda #1
   sta sum.a
   jsr sum
@@ -601,12 +601,12 @@ b2:
   lda sum.return
   sta s1
 //SEG8 [2] call sum param-assignment [ s1#0 sum::return#0 ]
-//SEG9 [8] phi from @2 to sum
+//SEG9 [8] phi from @2 to sum [phi:@2->sum]
 sum_from_b2:
-//SEG10 [8] phi (byte) sum::b#3 = (byte) 4 -- zpby1=coby1 
+//SEG10 [8] phi (byte) sum::b#3 = (byte) 4 [phi:@2->sum#0] -- zpby1=coby1 
   lda #4
   sta sum.b
-//SEG11 [8] phi (byte) sum::a#3 = (byte) 3 -- zpby1=coby1 
+//SEG11 [8] phi (byte) sum::a#3 = (byte) 3 [phi:@2->sum#1] -- zpby1=coby1 
   lda #3
   sta sum.a
   jsr sum
@@ -617,12 +617,12 @@ b3:
   lda sum.return
   sta s2
 //SEG14 [4] call sum param-assignment [ s1#0 sum::return#0 s2#0 ]
-//SEG15 [8] phi from @3 to sum
+//SEG15 [8] phi from @3 to sum [phi:@3->sum]
 sum_from_b3:
-//SEG16 [8] phi (byte) sum::b#3 = (byte) 13 -- zpby1=coby1 
+//SEG16 [8] phi (byte) sum::b#3 = (byte) 13 [phi:@3->sum#0] -- zpby1=coby1 
   lda #$d
   sta sum.b
-//SEG17 [8] phi (byte) sum::a#3 = (byte) 9 -- zpby1=coby1 
+//SEG17 [8] phi (byte) sum::a#3 = (byte) 9 [phi:@3->sum#1] -- zpby1=coby1 
   lda #9
   sta sum.a
   jsr sum
@@ -697,11 +697,11 @@ ASSEMBLER
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call sum param-assignment [ sum::return#0 ]
-//SEG3 [8] phi from @begin to sum
+//SEG3 [8] phi from @begin to sum [phi:@begin->sum]
 sum_from_bbegin:
-//SEG4 [8] phi (byte) sum::b#3 = (byte) 2 -- aby=coby1 
+//SEG4 [8] phi (byte) sum::b#3 = (byte) 2 [phi:@begin->sum#0] -- aby=coby1 
   lda #2
-//SEG5 [8] phi (byte) sum::a#3 = (byte) 1 -- yby=coby1 
+//SEG5 [8] phi (byte) sum::a#3 = (byte) 1 [phi:@begin->sum#1] -- yby=coby1 
   ldy #1
   jsr sum
 //SEG6 @2
@@ -709,11 +709,11 @@ b2:
 //SEG7 [1] (byte) s1#0 ← (byte) sum::return#0 [ s1#0 ] -- zpby1=aby 
   sta s1
 //SEG8 [2] call sum param-assignment [ s1#0 sum::return#0 ]
-//SEG9 [8] phi from @2 to sum
+//SEG9 [8] phi from @2 to sum [phi:@2->sum]
 sum_from_b2:
-//SEG10 [8] phi (byte) sum::b#3 = (byte) 4 -- aby=coby1 
+//SEG10 [8] phi (byte) sum::b#3 = (byte) 4 [phi:@2->sum#0] -- aby=coby1 
   lda #4
-//SEG11 [8] phi (byte) sum::a#3 = (byte) 3 -- yby=coby1 
+//SEG11 [8] phi (byte) sum::a#3 = (byte) 3 [phi:@2->sum#1] -- yby=coby1 
   ldy #3
   jsr sum
 //SEG12 @3
@@ -721,11 +721,11 @@ b3:
 //SEG13 [3] (byte) s2#0 ← (byte) sum::return#0 [ s1#0 s2#0 ] -- xby=aby 
   tax
 //SEG14 [4] call sum param-assignment [ s1#0 sum::return#0 s2#0 ]
-//SEG15 [8] phi from @3 to sum
+//SEG15 [8] phi from @3 to sum [phi:@3->sum]
 sum_from_b3:
-//SEG16 [8] phi (byte) sum::b#3 = (byte) 13 -- aby=coby1 
+//SEG16 [8] phi (byte) sum::b#3 = (byte) 13 [phi:@3->sum#0] -- aby=coby1 
   lda #$d
-//SEG17 [8] phi (byte) sum::a#3 = (byte) 9 -- yby=coby1 
+//SEG17 [8] phi (byte) sum::a#3 = (byte) 9 [phi:@3->sum#1] -- yby=coby1 
   ldy #9
   jsr sum
 //SEG18 @4
@@ -762,10 +762,10 @@ ASSEMBLER
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call sum param-assignment [ sum::return#0 ]
-//SEG3 [8] phi from @begin to sum
-//SEG4 [8] phi (byte) sum::b#3 = (byte) 2 -- aby=coby1 
+//SEG3 [8] phi from @begin to sum [phi:@begin->sum]
+//SEG4 [8] phi (byte) sum::b#3 = (byte) 2 [phi:@begin->sum#0] -- aby=coby1 
   lda #2
-//SEG5 [8] phi (byte) sum::a#3 = (byte) 1 -- yby=coby1 
+//SEG5 [8] phi (byte) sum::a#3 = (byte) 1 [phi:@begin->sum#1] -- yby=coby1 
   ldy #1
   jsr sum
 //SEG6 @2
@@ -773,11 +773,11 @@ b2:
 //SEG7 [1] (byte) s1#0 ← (byte) sum::return#0 [ s1#0 ] -- zpby1=aby 
   sta s1
 //SEG8 [2] call sum param-assignment [ s1#0 sum::return#0 ]
-//SEG9 [8] phi from @2 to sum
+//SEG9 [8] phi from @2 to sum [phi:@2->sum]
 sum_from_b2:
-//SEG10 [8] phi (byte) sum::b#3 = (byte) 4 -- aby=coby1 
+//SEG10 [8] phi (byte) sum::b#3 = (byte) 4 [phi:@2->sum#0] -- aby=coby1 
   lda #4
-//SEG11 [8] phi (byte) sum::a#3 = (byte) 3 -- yby=coby1 
+//SEG11 [8] phi (byte) sum::a#3 = (byte) 3 [phi:@2->sum#1] -- yby=coby1 
   ldy #3
   jsr sum
 //SEG12 @3
@@ -785,11 +785,11 @@ b3:
 //SEG13 [3] (byte) s2#0 ← (byte) sum::return#0 [ s1#0 s2#0 ] -- xby=aby 
   tax
 //SEG14 [4] call sum param-assignment [ s1#0 sum::return#0 s2#0 ]
-//SEG15 [8] phi from @3 to sum
+//SEG15 [8] phi from @3 to sum [phi:@3->sum]
 sum_from_b3:
-//SEG16 [8] phi (byte) sum::b#3 = (byte) 13 -- aby=coby1 
+//SEG16 [8] phi (byte) sum::b#3 = (byte) 13 [phi:@3->sum#0] -- aby=coby1 
   lda #$d
-//SEG17 [8] phi (byte) sum::a#3 = (byte) 9 -- yby=coby1 
+//SEG17 [8] phi (byte) sum::a#3 = (byte) 9 [phi:@3->sum#1] -- yby=coby1 
   ldy #9
   jsr sum
 //SEG18 @4
@@ -832,30 +832,30 @@ ASSEMBLER
   .label s3 = 3
 //SEG1 @begin
 //SEG2 [0] call sum param-assignment [ sum::return#0 ]
-//SEG3 [8] phi from @begin to sum
-//SEG4 [8] phi (byte) sum::b#3 = (byte) 2 -- aby=coby1 
+//SEG3 [8] phi from @begin to sum [phi:@begin->sum]
+//SEG4 [8] phi (byte) sum::b#3 = (byte) 2 [phi:@begin->sum#0] -- aby=coby1 
   lda #2
-//SEG5 [8] phi (byte) sum::a#3 = (byte) 1 -- yby=coby1 
+//SEG5 [8] phi (byte) sum::a#3 = (byte) 1 [phi:@begin->sum#1] -- yby=coby1 
   ldy #1
   jsr sum
 //SEG6 @2
 //SEG7 [1] (byte) s1#0 ← (byte) sum::return#0 [ s1#0 ] -- zpby1=aby 
   sta s1
 //SEG8 [2] call sum param-assignment [ s1#0 sum::return#0 ]
-//SEG9 [8] phi from @2 to sum
-//SEG10 [8] phi (byte) sum::b#3 = (byte) 4 -- aby=coby1 
+//SEG9 [8] phi from @2 to sum [phi:@2->sum]
+//SEG10 [8] phi (byte) sum::b#3 = (byte) 4 [phi:@2->sum#0] -- aby=coby1 
   lda #4
-//SEG11 [8] phi (byte) sum::a#3 = (byte) 3 -- yby=coby1 
+//SEG11 [8] phi (byte) sum::a#3 = (byte) 3 [phi:@2->sum#1] -- yby=coby1 
   ldy #3
   jsr sum
 //SEG12 @3
 //SEG13 [3] (byte) s2#0 ← (byte) sum::return#0 [ s1#0 s2#0 ] -- xby=aby 
   tax
 //SEG14 [4] call sum param-assignment [ s1#0 sum::return#0 s2#0 ]
-//SEG15 [8] phi from @3 to sum
-//SEG16 [8] phi (byte) sum::b#3 = (byte) 13 -- aby=coby1 
+//SEG15 [8] phi from @3 to sum [phi:@3->sum]
+//SEG16 [8] phi (byte) sum::b#3 = (byte) 13 [phi:@3->sum#0] -- aby=coby1 
   lda #$d
-//SEG17 [8] phi (byte) sum::a#3 = (byte) 9 -- yby=coby1 
+//SEG17 [8] phi (byte) sum::a#3 = (byte) 9 [phi:@3->sum#1] -- yby=coby1 
   ldy #9
   jsr sum
 //SEG18 @4
@@ -919,30 +919,30 @@ FINAL CODE
   .label s3 = 3
 //SEG1 @begin
 //SEG2 [0] call sum param-assignment [ sum::return#0 ]
-//SEG3 [8] phi from @begin to sum
-//SEG4 [8] phi (byte) sum::b#3 = (byte) 2 -- aby=coby1 
+//SEG3 [8] phi from @begin to sum [phi:@begin->sum]
+//SEG4 [8] phi (byte) sum::b#3 = (byte) 2 [phi:@begin->sum#0] -- aby=coby1 
   lda #2
-//SEG5 [8] phi (byte) sum::a#3 = (byte) 1 -- yby=coby1 
+//SEG5 [8] phi (byte) sum::a#3 = (byte) 1 [phi:@begin->sum#1] -- yby=coby1 
   ldy #1
   jsr sum
 //SEG6 @2
 //SEG7 [1] (byte) s1#0 ← (byte) sum::return#0 [ s1#0 ] -- zpby1=aby 
   sta s1
 //SEG8 [2] call sum param-assignment [ s1#0 sum::return#0 ]
-//SEG9 [8] phi from @2 to sum
-//SEG10 [8] phi (byte) sum::b#3 = (byte) 4 -- aby=coby1 
+//SEG9 [8] phi from @2 to sum [phi:@2->sum]
+//SEG10 [8] phi (byte) sum::b#3 = (byte) 4 [phi:@2->sum#0] -- aby=coby1 
   lda #4
-//SEG11 [8] phi (byte) sum::a#3 = (byte) 3 -- yby=coby1 
+//SEG11 [8] phi (byte) sum::a#3 = (byte) 3 [phi:@2->sum#1] -- yby=coby1 
   ldy #3
   jsr sum
 //SEG12 @3
 //SEG13 [3] (byte) s2#0 ← (byte) sum::return#0 [ s1#0 s2#0 ] -- xby=aby 
   tax
 //SEG14 [4] call sum param-assignment [ s1#0 sum::return#0 s2#0 ]
-//SEG15 [8] phi from @3 to sum
-//SEG16 [8] phi (byte) sum::b#3 = (byte) 13 -- aby=coby1 
+//SEG15 [8] phi from @3 to sum [phi:@3->sum]
+//SEG16 [8] phi (byte) sum::b#3 = (byte) 13 [phi:@3->sum#0] -- aby=coby1 
   lda #$d
-//SEG17 [8] phi (byte) sum::a#3 = (byte) 9 -- yby=coby1 
+//SEG17 [8] phi (byte) sum::a#3 = (byte) 9 [phi:@3->sum#1] -- yby=coby1 
   ldy #9
   jsr sum
 //SEG18 @4

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

@@ -1322,7 +1322,7 @@ INITIAL ASM
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
 main_from_bbegin:
   jsr main
   jmp bend
@@ -1337,15 +1337,15 @@ main: {
     .label _4 = 10
     .label _5 = 14
     .label i = 2
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 -- zpby1=coby1 
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- zpby1=coby1 
     lda #0
     sta i
     jmp b1
-  //SEG8 [2] phi from main::@4 to main::@1
+  //SEG8 [2] phi from main::@4 to main::@1 [phi:main::@4->main::@1]
   b1_from_b4:
-  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@4->main::@1#0] -- register_copy 
     jmp b1
   //SEG10 main::@1
   b1:
@@ -1533,21 +1533,21 @@ ASSEMBLER
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
 main_from_bbegin:
   jsr main
 //SEG4 @end
 bend:
 //SEG5 main
 main: {
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 -- yby=coby1 
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- yby=coby1 
     ldy #0
     jmp b1
-  //SEG8 [2] phi from main::@4 to main::@1
+  //SEG8 [2] phi from main::@4 to main::@1 [phi:main::@4->main::@1]
   b1_from_b4:
-  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@4->main::@1#0] -- register_copy 
   //SEG10 main::@1
   b1:
   //SEG11 [3] (byte~) main::$0 ← (byte) main::i#2 + (byte) 1 [ main::i#2 main::$0 ] -- xby=yby_plus_1 
@@ -1648,19 +1648,19 @@ ASSEMBLER
 //SEG1 @begin
 bbegin:
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 bend:
 //SEG5 main
 main: {
-  //SEG6 [2] phi from main to main::@1
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
   b1_from_main:
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 -- yby=coby1 
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- yby=coby1 
     ldy #0
     jmp b1
-  //SEG8 [2] phi from main::@4 to main::@1
-  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG8 [2] phi from main::@4 to main::@1 [phi:main::@4->main::@1]
+  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@4->main::@1#0] -- register_copy 
   //SEG10 main::@1
   b1:
   //SEG11 [3] (byte~) main::$0 ← (byte) main::i#2 + (byte) 1 [ main::i#2 main::$0 ] -- xby=yby_plus_1 
@@ -1765,17 +1765,17 @@ ASSEMBLER
   .const SCREEN2 = $400+$28
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
 main: {
-  //SEG6 [2] phi from main to main::@1
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 -- yby=coby1 
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- yby=coby1 
     ldy #0
     jmp b1
-  //SEG8 [2] phi from main::@4 to main::@1
-  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG8 [2] phi from main::@4 to main::@1 [phi:main::@4->main::@1]
+  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@4->main::@1#0] -- register_copy 
   //SEG10 main::@1
   b1:
   //SEG11 [3] (byte~) main::$0 ← (byte) main::i#2 + (byte) 1 [ main::i#2 main::$0 ] -- xby=yby_plus_1 
@@ -1868,16 +1868,16 @@ ASSEMBLER
   .const SCREEN2 = $400+$28
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
 main: {
-  //SEG6 [2] phi from main to main::@1
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 -- yby=coby1 
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- yby=coby1 
     ldy #0
-  //SEG8 [2] phi from main::@4 to main::@1
-  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG8 [2] phi from main::@4 to main::@1 [phi:main::@4->main::@1]
+  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@4->main::@1#0] -- register_copy 
   //SEG10 main::@1
   b1:
   //SEG11 [3] (byte~) main::$0 ← (byte) main::i#2 + (byte) 1 [ main::i#2 main::$0 ] -- xby=yby_plus_1 
@@ -2028,16 +2028,16 @@ FINAL CODE
   .const SCREEN2 = $400+$28
 //SEG1 @begin
 //SEG2 [0] call main param-assignment [ ]
-//SEG3 [1] phi from @begin to main
+//SEG3 [1] phi from @begin to main [phi:@begin->main]
   jsr main
 //SEG4 @end
 //SEG5 main
 main: {
-  //SEG6 [2] phi from main to main::@1
-  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 -- yby=coby1 
+  //SEG6 [2] phi from main to main::@1 [phi:main->main::@1]
+  //SEG7 [2] phi (byte) main::i#2 = (byte) 0 [phi:main->main::@1#0] -- yby=coby1 
     ldy #0
-  //SEG8 [2] phi from main::@4 to main::@1
-  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG8 [2] phi from main::@4 to main::@1 [phi:main::@4->main::@1]
+  //SEG9 [2] phi (byte) main::i#2 = (byte) main::i#1 [phi:main::@4->main::@1#0] -- register_copy 
   //SEG10 main::@1
   b1:
   //SEG11 [3] (byte~) main::$0 ← (byte) main::i#2 + (byte) 1 [ main::i#2 main::$0 ] -- xby=yby_plus_1 

src/main/java/dk/camelot64/kickc/test/scroll-clobber.kc

@@ -1,6 +1,6 @@
 byte* SCREEN = $0400;
 byte* SCROLL = $d016;
-byte[] TEXT = "tst @";
+byte[] TEXT = "01234567@";
 main();
 
 void main() {