diff --git a/src/main/java/dk/camelot64/kickc/passes/Pass1UnwindStructValues.java b/src/main/java/dk/camelot64/kickc/passes/Pass1UnwindStructValues.java
index 63714d75c..d102a1877 100644
--- a/src/main/java/dk/camelot64/kickc/passes/Pass1UnwindStructValues.java
+++ b/src/main/java/dk/camelot64/kickc/passes/Pass1UnwindStructValues.java
@@ -70,6 +70,7 @@ public class Pass1UnwindStructValues extends Pass1Base {
       ProgramValueIterator.execute(
             getProgram(), (programValue, currentStmt, stmtIt, currentBlock) -> {
                if(programValue.get() instanceof StructMemberRef) {
+/*
                   StructMemberRef structMemberRef = (StructMemberRef) programValue.get();
                   if(structMemberRef.getStruct() instanceof VariableRef) {
                      StructUnwinding memberVariables = getStructMemberUnwinding(structMemberRef.getStruct(), currentStmt, stmtIt, currentBlock);
@@ -78,8 +79,19 @@ public class Pass1UnwindStructValues extends Pass1Base {
                         RValue structMemberVariable = memberUnwinding.getUnwinding(getScope());
                         getLog().append("Replacing struct member reference " + structMemberRef.toString(getProgram()) + " with member unwinding reference " + structMemberVariable.toString(getProgram()));
                         programValue.set(structMemberVariable);
-                        modified.set(true);
                      }
+
+ */
+                     StructMemberRef structMemberRef = (StructMemberRef) programValue.get();
+                     final ValueSource structValueSource = getValueSource(getProgram(), getScope(), structMemberRef.getStruct(), currentStmt, stmtIt, currentBlock);
+                     if(structValueSource != null) {
+                        final ValueSource memberUnwinding = structValueSource.getMemberUnwinding(structMemberRef.getMemberName(), getProgram(), getScope(), currentStmt, currentBlock, stmtIt);
+                        RValue memberSimpleValue = memberUnwinding.getSimpleValue(getScope());
+                        getLog().append("Replacing struct member reference " + structMemberRef.toString(getProgram()) + " with member unwinding reference " + memberSimpleValue.toString(getProgram()));
+                        programValue.set(memberSimpleValue);
+                        modified.set(true);
+                        
+
                   }
                }
             });
@@ -210,10 +222,8 @@ public class Pass1UnwindStructValues extends Pass1Base {
          boolean initialAssignment = assignment.isInitialAssignment();
          StatementSource source = assignment.getSource();
 
-         // Check if this is already a bulk assignment
-         if(rValue instanceof MemcpyValue || rValue instanceof MemsetValue)
-            return false;
-         if(rValue instanceof StructUnwoundPlaceholder)
+         // Check if this is already a bulk assignment - or an unwound placeholder
+         if(rValue instanceof MemcpyValue || rValue instanceof MemsetValue || rValue instanceof StructUnwoundPlaceholder)
             return false;
 
          ValueSource lValueSource = getValueSource(getProgram(), getScope(), lValue, assignment, stmtIt, currentBlock);
@@ -228,43 +238,6 @@ public class Pass1UnwindStructValues extends Pass1Base {
             }
             return true;
          }
-
-
-         // Check for struct unwinding
-         if(1==1) throw new InternalError("E!");
-         StructUnwinding lValueUnwinding = getStructMemberUnwinding(lValue, assignment, stmtIt, currentBlock);
-         if(lValueUnwinding == null)
-            return false;
-         if(lValueUnwinding == POSTPONE_UNWINDING)
-            return true;
-         if(rValue instanceof StructUnwoundPlaceholder)
-            return false;
-         SymbolType rValueType = SymbolTypeInference.inferType(getScope(), rValue);
-         if(rValueType.equals(lValueStructType)) {
-            StructUnwinding rValueUnwinding = getStructMemberUnwinding(rValue, assignment, stmtIt, currentBlock);
-            if(rValueUnwinding == null) {
-               throw new CompileError("Incompatible struct assignment " + assignment.toString(getProgram(), false), assignment);
-            }
-            if(rValueUnwinding == POSTPONE_UNWINDING)
-               return true;
-            List<RValue> lValueUnwoundPlaceholder = new ArrayList<>();
-            for(String memberName : lValueUnwinding.getMemberNames()) {
-               /*
-               RValueUnwinding lValueMemberUnwinding = lValueUnwinding.getMemberUnwinding(memberName, getScope());
-               RValueUnwinding rValueMemberUnwinding = rValueUnwinding.getMemberUnwinding(memberName, getScope());
-               unwindAssignment(lValueMemberUnwinding, rValueMemberUnwinding, lValueUnwoundPlaceholder, stmtIt, initialAssignment, source);
-
-                */
-            }
-            StructUnwoundPlaceholder unwoundPlaceholder = new StructUnwoundPlaceholder(lValueStructType, lValueUnwoundPlaceholder);
-            if(lValue instanceof VariableRef) {
-               assignment.setrValue2(unwoundPlaceholder);
-            } else {
-               stmtIt.remove();
-            }
-            return true;
-         }
-         throw new CompileError("Incompatible struct assignment " + assignment.toString(getProgram(), false), assignment);
       }
       return false;
    }
@@ -349,11 +322,8 @@ public class Pass1UnwindStructValues extends Pass1Base {
       if(value instanceof StructMemberRef) {
          final RValue structValue = ((StructMemberRef) value).getStruct();
          final ValueSource structValueSource = getValueSource(program, programScope, structValue, currentStmt, stmtIt, currentBlock);
-         final ValueSource structMemberSource = structValueSource.getMemberUnwinding(((StructMemberRef) value).getMemberName(), program, programScope, currentStmt, currentBlock, stmtIt);
-         return structMemberSource;
+         return structValueSource.getMemberUnwinding(((StructMemberRef) value).getMemberName(), program, programScope, currentStmt, currentBlock, stmtIt);
       }
-
-
       return null;
    }
 
diff --git a/src/main/java/dk/camelot64/kickc/passes/unwinding/ValueSourcePointerDereferenceIndexed.java b/src/main/java/dk/camelot64/kickc/passes/unwinding/ValueSourcePointerDereferenceIndexed.java
index 23721c08f..9b3fc2adf 100644
--- a/src/main/java/dk/camelot64/kickc/passes/unwinding/ValueSourcePointerDereferenceIndexed.java
+++ b/src/main/java/dk/camelot64/kickc/passes/unwinding/ValueSourcePointerDereferenceIndexed.java
@@ -76,14 +76,37 @@ public class ValueSourcePointerDereferenceIndexed extends ValueSourceBase {
       // Simple member value - unwind to value of member *((type*)&struct + OFFSET_MEMBER)
       final RValue structPointer = pointerDereferenceIndexed.getPointer();
       if(structPointer instanceof ConstantValue) {
-         // Pointer to member type
-         ConstantCastValue structTypedPointer = new ConstantCastValue(new SymbolTypePointer(memberType), (ConstantValue) structPointer);
-         // Calculate member address  (type*)&struct + OFFSET_MEMBER
-         ConstantBinary memberPointer = new ConstantBinary(structTypedPointer, Operators.PLUS, memberOffsetConstant);
-         // Unwind to *((type*)&struct + OFFSET_MEMBER)
-         PointerDereferenceIndexed memberDeref = new PointerDereferenceIndexed(memberPointer, pointerDereferenceIndexed.getIndex());
-         return new ValueSourcePointerDereferenceIndexed(memberDeref, memberType, memberArraySpec);
+         if(memberArraySpec!=null) {
+            final SymbolType elementType = ((SymbolTypePointer) memberType).getElementType();
+            // Pointer to element type
+            ConstantCastValue elementTypedPointer = new ConstantCastValue(new SymbolTypePointer(elementType), (ConstantValue) structPointer);
+            // Calculate member address  (elmType*)&struct + OFFSET_MEMBER
+            ConstantBinary memberPointer = new ConstantBinary(elementTypedPointer, Operators.PLUS, memberOffsetConstant);
+            // Calculate member address  (elmType*)&struct + OFFSET_MEMBER
+            if(pointerDereferenceIndexed.getIndex() instanceof ConstantValue) {
+               ConstantBinary elmPointer = new ConstantBinary(memberPointer, Operators.PLUS, (ConstantValue) pointerDereferenceIndexed.getIndex());
+               return new ValueSourceConstant(new SymbolTypePointer(elementType), null, elmPointer);
+            }  else {
+               Scope scope = programScope.getScope(currentBlock.getScope());
+               Variable elementAddress = scope.addVariableIntermediate();
+               elementAddress.setType(new SymbolTypePointer(elementType));
+               stmtIt.previous();
+               stmtIt.add(new StatementAssignment((LValue) elementAddress.getRef(), memberPointer, Operators.PLUS, pointerDereferenceIndexed.getIndex(), true, currentStmt.getSource(), currentStmt.getComments()));
+               stmtIt.next();
+               return new ValueSourceVariable(elementAddress);
+            }
+         }  else {
+            // Pointer to member type
+            ConstantCastValue structTypedPointer = new ConstantCastValue(new SymbolTypePointer(memberType), (ConstantValue) structPointer);
+            // Calculate member address  (type*)&struct + OFFSET_MEMBER
+            ConstantBinary memberPointer = new ConstantBinary(structTypedPointer, Operators.PLUS, memberOffsetConstant);
+            // Unwind to *((type*)&struct + OFFSET_MEMBER)
+            PointerDereferenceIndexed memberDeref = new PointerDereferenceIndexed(memberPointer, pointerDereferenceIndexed.getIndex());
+            return new ValueSourcePointerDereferenceIndexed(memberDeref, memberType, null);
+         }
       } else {
+         if(memberArraySpec!=null)
+            throw new InternalError("Not implemented!");
          Scope scope = programScope.getScope(currentBlock.getScope());
          Variable memberAddress = scope.addVariableIntermediate();
          memberAddress.setType(new SymbolTypePointer(memberType));
@@ -94,7 +117,7 @@ public class ValueSourcePointerDereferenceIndexed extends ValueSourceBase {
          stmtIt.next();
          // Unwind to *((memberType*)ptr_struct+OFFSET_MEMBER)
          PointerDereferenceIndexed memberDeref = new PointerDereferenceIndexed(memberAddress.getRef(), pointerDereferenceIndexed.getIndex());
-         return new ValueSourcePointerDereferenceIndexed(memberDeref, memberType, memberArraySpec);
+         return new ValueSourcePointerDereferenceIndexed(memberDeref, memberType, null);
       }
    }
 
diff --git a/src/main/java/dk/camelot64/kickc/passes/unwinding/ValueSourcePointerDereferenceSimple.java b/src/main/java/dk/camelot64/kickc/passes/unwinding/ValueSourcePointerDereferenceSimple.java
index 1011ce31f..44a317bc4 100644
--- a/src/main/java/dk/camelot64/kickc/passes/unwinding/ValueSourcePointerDereferenceSimple.java
+++ b/src/main/java/dk/camelot64/kickc/passes/unwinding/ValueSourcePointerDereferenceSimple.java
@@ -69,25 +69,51 @@ public class ValueSourcePointerDereferenceSimple extends ValueSourceBase {
       // Simple member value - unwind to value of member *((type*)&struct + OFFSET_MEMBER)
       final RValue structPointer = pointerDereference.getPointer();
       if(structPointer instanceof ConstantValue) {
-         // Pointer to member type
-         ConstantCastValue structTypedPointer = new ConstantCastValue(new SymbolTypePointer(memberType), (ConstantValue) structPointer);
-         // Calculate member address  (type*)&struct + OFFSET_MEMBER
-         ConstantBinary memberPointer = new ConstantBinary(structTypedPointer, Operators.PLUS, memberOffsetConstant);
-         // Unwind to *((type*)&struct + OFFSET_MEMBER)
-         PointerDereferenceSimple memberDeref = new PointerDereferenceSimple(memberPointer);
-         return new ValueSourcePointerDereferenceSimple(memberDeref, memberType, memberArraySpec);
+         if(memberArraySpec!=null) {
+            SymbolType elementType = ((SymbolTypePointer) memberType).getElementType();
+            SymbolTypePointer pointerToElementType = new SymbolTypePointer(elementType);
+            // Pointer to member element type
+            ConstantCastValue structTypedPointer = new ConstantCastValue(pointerToElementType, (ConstantValue) structPointer);
+            // Calculate member address  (elmtype*)&struct + OFFSET_MEMBER
+            ConstantBinary memberPointer = new ConstantBinary(structTypedPointer, Operators.PLUS, memberOffsetConstant);
+            // Unwind to *((type*)&struct + OFFSET_MEMBER)
+            return new ValueSourceConstant(pointerToElementType, null, memberPointer);
+         }  else {
+            // Pointer to member type
+            ConstantCastValue structTypedPointer = new ConstantCastValue(new SymbolTypePointer(memberType), (ConstantValue) structPointer);
+            // Calculate member address  (memberType*)&struct + OFFSET_MEMBER
+            ConstantBinary memberPointer = new ConstantBinary(structTypedPointer, Operators.PLUS, memberOffsetConstant);
+            // Unwind to *((memberType*)&struct + OFFSET_MEMBER)
+            PointerDereferenceSimple memberDeref = new PointerDereferenceSimple(memberPointer);
+            return new ValueSourcePointerDereferenceSimple(memberDeref, memberType, null);
+         }
       } else {
-         Scope scope = programScope.getScope(currentBlock.getScope());
-         Variable memberAddress = scope.addVariableIntermediate();
-         memberAddress.setType(new SymbolTypePointer(memberType));
-         CastValue structTypedPointer = new CastValue(new SymbolTypePointer(memberType), structPointer);
-         // Add statement $1 = (memberType*)ptr_struct + OFFSET_MEMBER
-         stmtIt.previous();
-         stmtIt.add(new StatementAssignment((LValue) memberAddress.getRef(), structTypedPointer, Operators.PLUS, memberOffsetConstant, true, currentStmt.getSource(), currentStmt.getComments()));
-         stmtIt.next();
-         // Unwind to *((memberType*)ptr_struct+OFFSET_MEMBER)
-         PointerDereferenceSimple memberDeref = new PointerDereferenceSimple(memberAddress.getRef());
-         return new ValueSourcePointerDereferenceSimple(memberDeref, memberType, memberArraySpec);
+         if(memberArraySpec!=null) {
+            SymbolType elementType = ((SymbolTypePointer) memberType).getElementType();
+            SymbolTypePointer pointerToElementType = new SymbolTypePointer(elementType);
+            Scope scope = programScope.getScope(currentBlock.getScope());
+            Variable memberAddress = scope.addVariableIntermediate();
+            memberAddress.setType(pointerToElementType);
+            CastValue elementTypedPointer = new CastValue(pointerToElementType, structPointer);
+            // Add statement $1 = (elmType*)ptr_struct + OFFSET_MEMBER
+            stmtIt.previous();
+            stmtIt.add(new StatementAssignment((LValue) memberAddress.getRef(), elementTypedPointer, Operators.PLUS, memberOffsetConstant, true, currentStmt.getSource(), currentStmt.getComments()));
+            stmtIt.next();
+            // Unwind to *((elmType*)ptr_struct+OFFSET_MEMBER)
+            return new ValueSourceVariable(memberAddress);
+         }  else {
+            Scope scope = programScope.getScope(currentBlock.getScope());
+            Variable memberAddress = scope.addVariableIntermediate();
+            memberAddress.setType(new SymbolTypePointer(memberType));
+            CastValue structTypedPointer = new CastValue(new SymbolTypePointer(memberType), structPointer);
+            // Add statement $1 = (memberType*)ptr_struct + OFFSET_MEMBER
+            stmtIt.previous();
+            stmtIt.add(new StatementAssignment((LValue) memberAddress.getRef(), structTypedPointer, Operators.PLUS, memberOffsetConstant, true, currentStmt.getSource(), currentStmt.getComments()));
+            stmtIt.next();
+            // Unwind to *((memberType*)ptr_struct+OFFSET_MEMBER)
+            PointerDereferenceSimple memberDeref = new PointerDereferenceSimple(memberAddress.getRef());
+            return new ValueSourcePointerDereferenceSimple(memberDeref, memberType, null);
+         }
       }
    }
 }
diff --git a/src/main/java/dk/camelot64/kickc/passes/unwinding/ValueSourceVariable.java b/src/main/java/dk/camelot64/kickc/passes/unwinding/ValueSourceVariable.java
index 474d2f7e5..d33a3a322 100644
--- a/src/main/java/dk/camelot64/kickc/passes/unwinding/ValueSourceVariable.java
+++ b/src/main/java/dk/camelot64/kickc/passes/unwinding/ValueSourceVariable.java
@@ -52,7 +52,7 @@ public class ValueSourceVariable extends ValueSourceBase {
 
    @Override
    public LValue getBulkLValue(ProgramScope scope) {
-      if(getArraySpec()!=null) {
+      if(getArraySpec() != null) {
          return new PointerDereferenceSimple(variable.getRef());
       } else {
          ConstantSymbolPointer pointer = new ConstantSymbolPointer(variable.getRef());
@@ -71,18 +71,29 @@ public class ValueSourceVariable extends ValueSourceBase {
    public ValueSource getMemberUnwinding(String memberName, Program program, ProgramScope programScope, Statement currentStmt, ControlFlowBlock currentBlock, ListIterator<Statement> stmtIt) {
       if(variable.isStructClassic()) {
          StructDefinition structDefinition = ((SymbolTypeStruct) getSymbolType()).getStructDefinition(programScope);
-         final SymbolType memberType = structDefinition.getMember(memberName).getType();
-         final ArraySpec memberArraySpec = structDefinition.getMember(memberName).getArraySpec();
+         SymbolType memberType = structDefinition.getMember(memberName).getType();
+         ArraySpec memberArraySpec = structDefinition.getMember(memberName).getArraySpec();
          ConstantRef memberOffsetConstant = PassNStructPointerRewriting.getMemberOffsetConstant(programScope, structDefinition, memberName);
-         // Simple member value - unwind to value of member *((type*)&struct + OFFSET_MEMBER)
          ConstantSymbolPointer structPointer = new ConstantSymbolPointer(variable.getRef());
-         // Pointer to member type
-         ConstantCastValue structTypedPointer = new ConstantCastValue(new SymbolTypePointer(memberType), structPointer);
-         // Calculate member address  (type*)&struct + OFFSET_MEMBER
-         ConstantBinary memberPointer = new ConstantBinary(structTypedPointer, Operators.PLUS, memberOffsetConstant);
-         // Unwind to *((type*)&struct + OFFSET_MEMBER)
-         PointerDereferenceSimple memberDeref = new PointerDereferenceSimple(memberPointer);
-         return new ValueSourcePointerDereferenceSimple(memberDeref, memberType, memberArraySpec);
+         if(memberArraySpec != null) {
+            // Pointer to member element type (elmtype*)&struct
+            SymbolType elementType = ((SymbolTypePointer) memberType).getElementType();
+            SymbolTypePointer pointerToElementType = new SymbolTypePointer(elementType);
+            ConstantCastValue structTypedPointer = new ConstantCastValue(pointerToElementType, structPointer);
+            // Calculate member address  (elmtype*)&struct + OFFSET_MEMBER
+            ConstantBinary memberArrayPointer = new ConstantBinary(structTypedPointer, Operators.PLUS, memberOffsetConstant);
+            // Unwind to (elmtype*)&struct + OFFSET_MEMBER
+            return new ValueSourceConstant(pointerToElementType, null, memberArrayPointer);
+         } else {
+            // Simple member value - unwind to value of member *((type*)&struct + OFFSET_MEMBER)
+            // Pointer to member type
+            ConstantCastValue structTypedPointer = new ConstantCastValue(new SymbolTypePointer(memberType), structPointer);
+            // Calculate member address  (type*)&struct + OFFSET_MEMBER
+            ConstantBinary memberPointer = new ConstantBinary(structTypedPointer, Operators.PLUS, memberOffsetConstant);
+            // Unwind to *((type*)&struct + OFFSET_MEMBER)
+            PointerDereferenceSimple memberDeref = new PointerDereferenceSimple(memberPointer);
+            return new ValueSourcePointerDereferenceSimple(memberDeref, memberType, memberArraySpec);
+         }
       } else if(variable.isStructUnwind()) {
          StructVariableMemberUnwinding structVariableMemberUnwinding = program.getStructVariableMemberUnwinding();
          final StructVariableMemberUnwinding.VariableUnwinding variableUnwinding = structVariableMemberUnwinding.getVariableUnwinding(variable.getRef());
diff --git a/src/test/ref/complex/clearscreen/clearscreen.asm b/src/test/ref/complex/clearscreen/clearscreen.asm
index ad01c4bfd..a1208f9eb 100644
--- a/src/test/ref/complex/clearscreen/clearscreen.asm
+++ b/src/test/ref/complex/clearscreen/clearscreen.asm
@@ -208,8 +208,8 @@ startProcessing: {
     .label spritePtr = $17
     // Busy-wait while finding an empty slot in the PROCESSING array
     .label freeIdx = 2
-    .label __35 = $e
-    .label __36 = $c
+    .label __34 = $e
+    .label __35 = $c
     ldx #$ff
   __b1:
     lda #0
@@ -241,19 +241,19 @@ startProcessing: {
     sta.z __0+1
     lda.z __0
     asl
-    sta.z __35
+    sta.z __34
     lda.z __0+1
     rol
-    sta.z __35+1
-    asl.z __35
-    rol.z __35+1
-    lda.z __36
+    sta.z __34+1
+    asl.z __34
+    rol.z __34+1
+    lda.z __35
     clc
-    adc.z __35
-    sta.z __36
-    lda.z __36+1
-    adc.z __35+1
-    sta.z __36+1
+    adc.z __34
+    sta.z __35
+    lda.z __35+1
+    adc.z __34+1
+    sta.z __35+1
     asl.z __1
     rol.z __1+1
     asl.z __1
diff --git a/src/test/ref/complex/clearscreen/clearscreen.cfg b/src/test/ref/complex/clearscreen/clearscreen.cfg
index ead6d678f..e0a11e582 100644
--- a/src/test/ref/complex/clearscreen/clearscreen.cfg
+++ b/src/test/ref/complex/clearscreen/clearscreen.cfg
@@ -90,11 +90,11 @@ startProcessing::@1: scope:[startProcessing]  from startProcessing startProcessi
   to:startProcessing::@2
 startProcessing::@2: scope:[startProcessing]  from startProcessing::@1 startProcessing::@3
   [46] (byte) startProcessing::i#2 ← phi( startProcessing::@1/(byte) 0 startProcessing::@3/(byte) startProcessing::i#1 )
-  [47] (byte~) startProcessing::$30 ← (byte) startProcessing::i#2 << (byte) 1
-  [48] (byte~) startProcessing::$31 ← (byte~) startProcessing::$30 + (byte) startProcessing::i#2
-  [49] (byte~) startProcessing::$32 ← (byte~) startProcessing::$31 << (byte) 1
-  [50] (byte~) startProcessing::$33 ← (byte~) startProcessing::$32 + (byte) startProcessing::i#2
-  [51] (byte~) startProcessing::$27 ← (byte~) startProcessing::$33 << (byte) 1
+  [47] (byte~) startProcessing::$29 ← (byte) startProcessing::i#2 << (byte) 1
+  [48] (byte~) startProcessing::$30 ← (byte~) startProcessing::$29 + (byte) startProcessing::i#2
+  [49] (byte~) startProcessing::$31 ← (byte~) startProcessing::$30 << (byte) 1
+  [50] (byte~) startProcessing::$32 ← (byte~) startProcessing::$31 + (byte) startProcessing::i#2
+  [51] (byte~) startProcessing::$27 ← (byte~) startProcessing::$32 << (byte) 1
   [52] if(*((byte*)(const struct ProcessingSprite*) PROCESSING+(const byte) OFFSET_STRUCT_PROCESSINGSPRITE_STATUS + (byte~) startProcessing::$27)!=(const byte) STATUS_FREE) goto startProcessing::@3
   to:startProcessing::@4
 startProcessing::@4: scope:[startProcessing]  from startProcessing::@2 startProcessing::@9
@@ -103,9 +103,9 @@ startProcessing::@4: scope:[startProcessing]  from startProcessing::@2 startProc
   to:startProcessing::@5
 startProcessing::@5: scope:[startProcessing]  from startProcessing::@4
   [55] (word~) startProcessing::$0 ← (word)(byte) startProcessing::center_y#0
-  [56] (word~) startProcessing::$35 ← (word~) startProcessing::$0 << (byte) 2
-  [57] (word~) startProcessing::$36 ← (word~) startProcessing::$35 + (word~) startProcessing::$0
-  [58] (word~) startProcessing::$1 ← (word~) startProcessing::$36 << (byte) 3
+  [56] (word~) startProcessing::$34 ← (word~) startProcessing::$0 << (byte) 2
+  [57] (word~) startProcessing::$35 ← (word~) startProcessing::$34 + (word~) startProcessing::$0
+  [58] (word~) startProcessing::$1 ← (word~) startProcessing::$35 << (byte) 3
   [59] (word) startProcessing::offset#0 ← (word~) startProcessing::$1 + (byte) startProcessing::center_x#0
   [60] (byte*) startProcessing::colPtr#0 ← (const byte*) COLS + (word) startProcessing::offset#0
   [61] (byte) startProcessing::spriteCol#0 ← *((byte*) startProcessing::colPtr#0)
@@ -144,11 +144,11 @@ startProcessing::@7: scope:[startProcessing]  from startProcessing::@6
   [88] (byte) startProcessing::spritePtr#0 ← (byte)(const byte*) SPRITE_DATA/(byte) $40 + (byte) startProcessing::freeIdx#2
   [89] (byte~) startProcessing::$20 ← (byte) startProcessing::freeIdx#2 << (byte) 3
   [90] (word~) startProcessing::$21 ← (word)(byte~) startProcessing::$20
-  [91] (byte~) startProcessing::$38 ← (byte) startProcessing::freeIdx#2 << (byte) 1
-  [92] (byte~) startProcessing::$39 ← (byte~) startProcessing::$38 + (byte) startProcessing::freeIdx#2
-  [93] (byte~) startProcessing::$40 ← (byte~) startProcessing::$39 << (byte) 1
-  [94] (byte~) startProcessing::$41 ← (byte~) startProcessing::$40 + (byte) startProcessing::freeIdx#2
-  [95] (byte~) startProcessing::$28 ← (byte~) startProcessing::$41 << (byte) 1
+  [91] (byte~) startProcessing::$37 ← (byte) startProcessing::freeIdx#2 << (byte) 1
+  [92] (byte~) startProcessing::$38 ← (byte~) startProcessing::$37 + (byte) startProcessing::freeIdx#2
+  [93] (byte~) startProcessing::$39 ← (byte~) startProcessing::$38 << (byte) 1
+  [94] (byte~) startProcessing::$40 ← (byte~) startProcessing::$39 + (byte) startProcessing::freeIdx#2
+  [95] (byte~) startProcessing::$28 ← (byte~) startProcessing::$40 << (byte) 1
   [96] *((word*)(const struct ProcessingSprite*) PROCESSING + (byte~) startProcessing::$28) ← (word) startProcessing::spriteX#0
   [97] *((word*)(const struct ProcessingSprite*) PROCESSING+(const byte) OFFSET_STRUCT_PROCESSINGSPRITE_Y + (byte~) startProcessing::$28) ← (word) startProcessing::spriteY#0
   [98] *((word*)(const struct ProcessingSprite*) PROCESSING+(const byte) OFFSET_STRUCT_PROCESSINGSPRITE_VX + (byte~) startProcessing::$28) ← (word~) startProcessing::$21
diff --git a/src/test/ref/complex/clearscreen/clearscreen.log b/src/test/ref/complex/clearscreen/clearscreen.log
index 4b37d7eff..f455346f5 100644
--- a/src/test/ref/complex/clearscreen/clearscreen.log
+++ b/src/test/ref/complex/clearscreen/clearscreen.log
@@ -81,37 +81,37 @@ Replacing struct member reference (struct ProcessingChar) getCharToProcess::clos
 Replacing struct member reference (struct ProcessingChar) getCharToProcess::closest.dist with member unwinding reference (byte) getCharToProcess::closest_dist
 Replacing struct member reference (struct ProcessingChar) getCharToProcess::closest.y with member unwinding reference (byte) getCharToProcess::closest_y
 Replacing struct member reference (struct ProcessingChar) getCharToProcess::closest.x with member unwinding reference (byte) getCharToProcess::closest_x
+Replacing struct member reference *((const struct ProcessingSprite*) PROCESSING + (byte~) startProcessing::$27).status with member unwinding reference *((byte*)(const struct ProcessingSprite*) PROCESSING+(const byte) OFFSET_STRUCT_PROCESSINGSPRITE_STATUS + (byte~) startProcessing::$27)
 Replacing struct member reference (struct ProcessingChar) startProcessing::center.y with member unwinding reference (byte) startProcessing::center_y
 Replacing struct member reference (struct ProcessingChar) startProcessing::center.x with member unwinding reference (byte) startProcessing::center_x
 Replacing struct member reference (struct ProcessingChar) startProcessing::center.x with member unwinding reference (byte) startProcessing::center_x
 Replacing struct member reference (struct ProcessingChar) startProcessing::center.y with member unwinding reference (byte) startProcessing::center_y
-Rewriting struct pointer member access *((const struct ProcessingSprite*) PROCESSING + (byte~) startProcessing::$27).status
-Rewriting struct pointer member access *((struct ProcessingSprite*) processChars::processing).id
-Rewriting struct pointer member access *((struct ProcessingSprite*) processChars::processing).status
-Rewriting struct pointer member access *((struct ProcessingSprite*) processChars::processing).status
-Rewriting struct pointer member access *((struct ProcessingSprite*) processChars::processing).x
-Rewriting struct pointer member access *((struct ProcessingSprite*) processChars::processing).screenPtr
-Rewriting struct pointer member access *((struct ProcessingSprite*) processChars::processing).col
-Rewriting struct pointer member access *((struct ProcessingSprite*) processChars::processing).id
-Rewriting struct pointer member access *((struct ProcessingSprite*) processChars::processing).id
-Rewriting struct pointer member access *((struct ProcessingSprite*) processChars::processing).ptr
-Rewriting struct pointer member access *((struct ProcessingSprite*) processChars::processing).status
-Rewriting struct pointer member access *((struct ProcessingSprite*) processChars::processing).y
-Rewriting struct pointer member access *((struct ProcessingSprite*) processChars::processing).x
-Rewriting struct pointer member access *((struct ProcessingSprite*) processChars::processing).x
-Rewriting struct pointer member access *((struct ProcessingSprite*) processChars::processing).y
-Rewriting struct pointer member access *((struct ProcessingSprite*) processChars::processing).y
-Rewriting struct pointer member access *((struct ProcessingSprite*) processChars::processing).status
-Rewriting struct pointer member access *((struct ProcessingSprite*) processChars::processing).vx
-Rewriting struct pointer member access *((struct ProcessingSprite*) processChars::processing).vx
-Rewriting struct pointer member access *((struct ProcessingSprite*) processChars::processing).x
-Rewriting struct pointer member access *((struct ProcessingSprite*) processChars::processing).vx
-Rewriting struct pointer member access *((struct ProcessingSprite*) processChars::processing).x
-Rewriting struct pointer member access *((struct ProcessingSprite*) processChars::processing).vy
-Rewriting struct pointer member access *((struct ProcessingSprite*) processChars::processing).vy
-Rewriting struct pointer member access *((struct ProcessingSprite*) processChars::processing).y
-Rewriting struct pointer member access *((struct ProcessingSprite*) processChars::processing).vy
-Rewriting struct pointer member access *((struct ProcessingSprite*) processChars::processing).y
+Replacing struct member reference *((struct ProcessingSprite*) processChars::processing).id with member unwinding reference *((byte*~) processChars::$35)
+Replacing struct member reference *((struct ProcessingSprite*) processChars::processing).status with member unwinding reference *((byte*~) processChars::$36)
+Replacing struct member reference *((struct ProcessingSprite*) processChars::processing).status with member unwinding reference *((byte*~) processChars::$37)
+Replacing struct member reference *((struct ProcessingSprite*) processChars::processing).x with member unwinding reference *((word*~) processChars::$38)
+Replacing struct member reference *((struct ProcessingSprite*) processChars::processing).screenPtr with member unwinding reference *((byte**~) processChars::$39)
+Replacing struct member reference *((struct ProcessingSprite*) processChars::processing).col with member unwinding reference *((byte*~) processChars::$40)
+Replacing struct member reference *((struct ProcessingSprite*) processChars::processing).id with member unwinding reference *((byte*~) processChars::$41)
+Replacing struct member reference *((struct ProcessingSprite*) processChars::processing).id with member unwinding reference *((byte*~) processChars::$42)
+Replacing struct member reference *((struct ProcessingSprite*) processChars::processing).ptr with member unwinding reference *((byte*~) processChars::$43)
+Replacing struct member reference *((struct ProcessingSprite*) processChars::processing).status with member unwinding reference *((byte*~) processChars::$44)
+Replacing struct member reference *((struct ProcessingSprite*) processChars::processing).y with member unwinding reference *((word*~) processChars::$45)
+Replacing struct member reference *((struct ProcessingSprite*) processChars::processing).x with member unwinding reference *((word*~) processChars::$46)
+Replacing struct member reference *((struct ProcessingSprite*) processChars::processing).x with member unwinding reference *((word*~) processChars::$47)
+Replacing struct member reference *((struct ProcessingSprite*) processChars::processing).y with member unwinding reference *((word*~) processChars::$48)
+Replacing struct member reference *((struct ProcessingSprite*) processChars::processing).y with member unwinding reference *((word*~) processChars::$49)
+Replacing struct member reference *((struct ProcessingSprite*) processChars::processing).status with member unwinding reference *((byte*~) processChars::$50)
+Replacing struct member reference *((struct ProcessingSprite*) processChars::processing).vx with member unwinding reference *((word*~) processChars::$51)
+Replacing struct member reference *((struct ProcessingSprite*) processChars::processing).vx with member unwinding reference *((word*~) processChars::$52)
+Replacing struct member reference *((struct ProcessingSprite*) processChars::processing).x with member unwinding reference *((word*~) processChars::$53)
+Replacing struct member reference *((struct ProcessingSprite*) processChars::processing).vx with member unwinding reference *((word*~) processChars::$54)
+Replacing struct member reference *((struct ProcessingSprite*) processChars::processing).x with member unwinding reference *((word*~) processChars::$55)
+Replacing struct member reference *((struct ProcessingSprite*) processChars::processing).vy with member unwinding reference *((word*~) processChars::$56)
+Replacing struct member reference *((struct ProcessingSprite*) processChars::processing).vy with member unwinding reference *((word*~) processChars::$57)
+Replacing struct member reference *((struct ProcessingSprite*) processChars::processing).y with member unwinding reference *((word*~) processChars::$58)
+Replacing struct member reference *((struct ProcessingSprite*) processChars::processing).vy with member unwinding reference *((word*~) processChars::$59)
+Replacing struct member reference *((struct ProcessingSprite*) processChars::processing).y with member unwinding reference *((word*~) processChars::$60)
 Warning! Adding boolean cast to non-boolean condition *((byte*) strcpy::src)
 Warning! Adding boolean cast to non-boolean condition *((byte*) strlen::str)
 Warning! Adding boolean cast to non-boolean condition (byte~) processChars::$9
@@ -705,8 +705,7 @@ startProcessing::@2: scope:[startProcessing]  from startProcessing::@1 startProc
   (byte) startProcessing::freeIdx#5 ← phi( startProcessing::@1/(byte) startProcessing::freeIdx#6 startProcessing::@3/(byte) startProcessing::freeIdx#4 )
   (byte) startProcessing::i#2 ← phi( startProcessing::@1/(byte) startProcessing::i#0 startProcessing::@3/(byte) startProcessing::i#1 )
   (byte~) startProcessing::$27 ← (byte) startProcessing::i#2 * (const byte) SIZEOF_STRUCT_PROCESSINGSPRITE
-  (byte*~) startProcessing::$29 ← (byte*)(const struct ProcessingSprite*) PROCESSING + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_STATUS
-  (bool~) startProcessing::$22 ← *((byte*~) startProcessing::$29 + (byte~) startProcessing::$27) == (const byte) STATUS_FREE
+  (bool~) startProcessing::$22 ← *((byte*)(const struct ProcessingSprite*) PROCESSING+(const byte) OFFSET_STRUCT_PROCESSINGSPRITE_STATUS + (byte~) startProcessing::$27) == (const byte) STATUS_FREE
   (bool~) startProcessing::$23 ← ! (bool~) startProcessing::$22
   if((bool~) startProcessing::$23) goto startProcessing::@3
   to:startProcessing::@5
@@ -2046,7 +2045,6 @@ interrupt(HARDWARE_ALL)(void()) irqTop()
 (bool~) startProcessing::$26
 (byte~) startProcessing::$27
 (byte~) startProcessing::$28
-(byte*~) startProcessing::$29
 (byte*~) startProcessing::$3
 (byte*~) startProcessing::$4
 (word~) startProcessing::$5
@@ -2491,9 +2489,9 @@ Inversing boolean not [146] (bool~) main::$7 ← (byte) main::center_dist#0 != (
 Inversing boolean not [170] (bool~) getCharToProcess::$3 ← *((byte*) getCharToProcess::screen_line#2 + (byte) getCharToProcess::x#2) == (byte) ' ' from [169] (bool~) getCharToProcess::$2 ← *((byte*) getCharToProcess::screen_line#2 + (byte) getCharToProcess::x#2) != (byte) ' '
 Inversing boolean not [179] (bool~) getCharToProcess::$5 ← (byte) getCharToProcess::dist#0 >= (byte) getCharToProcess::closest_dist#2 from [178] (bool~) getCharToProcess::$4 ← (byte) getCharToProcess::dist#0 < (byte) getCharToProcess::closest_dist#2
 Inversing boolean not [193] (bool~) getCharToProcess::$1 ← (byte) getCharToProcess::closest_dist#3 == (const byte) NOT_FOUND from [192] (bool~) getCharToProcess::$0 ← (byte) getCharToProcess::closest_dist#3 != (const byte) NOT_FOUND
-Inversing boolean not [220] (bool~) startProcessing::$23 ← *((byte*~) startProcessing::$29 + (byte~) startProcessing::$27) != (const byte) STATUS_FREE from [219] (bool~) startProcessing::$22 ← *((byte*~) startProcessing::$29 + (byte~) startProcessing::$27) == (const byte) STATUS_FREE
-Inversing boolean not [300] (bool~) processChars::$4 ← *((byte*~) processChars::$36) == (const byte) STATUS_FREE from [299] (bool~) processChars::$3 ← *((byte*~) processChars::$36) != (const byte) STATUS_FREE
-Inversing boolean not [309] (bool~) processChars::$6 ← *((byte*~) processChars::$37) != (const byte) STATUS_NEW from [308] (bool~) processChars::$5 ← *((byte*~) processChars::$37) == (const byte) STATUS_NEW
+Inversing boolean not [219] (bool~) startProcessing::$23 ← *((byte*)(const struct ProcessingSprite*) PROCESSING+(const byte) OFFSET_STRUCT_PROCESSINGSPRITE_STATUS + (byte~) startProcessing::$27) != (const byte) STATUS_FREE from [218] (bool~) startProcessing::$22 ← *((byte*)(const struct ProcessingSprite*) PROCESSING+(const byte) OFFSET_STRUCT_PROCESSINGSPRITE_STATUS + (byte~) startProcessing::$27) == (const byte) STATUS_FREE
+Inversing boolean not [299] (bool~) processChars::$4 ← *((byte*~) processChars::$36) == (const byte) STATUS_FREE from [298] (bool~) processChars::$3 ← *((byte*~) processChars::$36) != (const byte) STATUS_FREE
+Inversing boolean not [308] (bool~) processChars::$6 ← *((byte*~) processChars::$37) != (const byte) STATUS_NEW from [307] (bool~) processChars::$5 ← *((byte*~) processChars::$37) == (const byte) STATUS_NEW
 Successful SSA optimization Pass2UnaryNotSimplification
 Alias (byte*) malloc::mem#0 = (byte*~) malloc::$0 
 Alias (void*) malloc::return#0 = (void*) malloc::return#4 (void*) malloc::return#1 
@@ -2718,7 +2716,7 @@ Identical Phi Values (byte) getCharToProcess::y#2 (byte) getCharToProcess::y#7
 Identical Phi Values (byte) startProcessing::center_y#8 (byte) startProcessing::center_y#0
 Identical Phi Values (byte) startProcessing::center_x#8 (byte) startProcessing::center_x#0
 Successful SSA optimization Pass2IdenticalPhiElimination
-Identified duplicate assignment right side [344] (byte~) processChars::$15 ← (byte) processChars::i#10 * (byte) 2
+Identified duplicate assignment right side [343] (byte~) processChars::$15 ← (byte) processChars::i#10 * (byte) 2
 Successful SSA optimization Pass2DuplicateRValueIdentification
 Simple Condition (bool~) atan2_16::$0 [12] if((signed word) atan2_16::y#0>=(signed byte) 0) goto atan2_16::@1
 Simple Condition (bool~) atan2_16::$5 [21] if((signed word) atan2_16::x#0>=(signed byte) 0) goto atan2_16::@4
@@ -2737,34 +2735,32 @@ Simple Condition (bool~) getCharToProcess::$6 [175] if((byte) getCharToProcess::
 Simple Condition (bool~) getCharToProcess::$5 [180] if((byte) getCharToProcess::dist#0>=(byte) getCharToProcess::closest_dist#2) goto getCharToProcess::@5
 Simple Condition (bool~) getCharToProcess::$7 [190] if((byte) getCharToProcess::y#1!=rangelast(0,$18)) goto getCharToProcess::@3
 Simple Condition (bool~) getCharToProcess::$1 [194] if((byte) getCharToProcess::return_dist#1==(const byte) NOT_FOUND) goto getCharToProcess::@1
-Simple Condition (bool~) startProcessing::$23 [221] if(*((byte*~) startProcessing::$29 + (byte~) startProcessing::$27)!=(const byte) STATUS_FREE) goto startProcessing::@3
-Simple Condition (bool~) startProcessing::$24 [225] if((byte) startProcessing::i#1!=rangelast(0,NUM_PROCESSING-1)) goto startProcessing::@2
-Simple Condition (bool~) startProcessing::$25 [230] if((byte) startProcessing::freeIdx#2==(byte) $ff) goto startProcessing::@1
-Simple Condition (bool~) startProcessing::$26 [260] if((byte) startProcessing::i1#1!=rangelast(0,7)) goto startProcessing::@9
-Simple Condition (bool~) processChars::$4 [301] if(*((byte*~) processChars::$36)==(const byte) STATUS_FREE) goto processChars::@3
-Simple Condition (bool~) processChars::$30 [305] if((byte) processChars::i#1!=rangelast(0,NUM_PROCESSING-1)) goto processChars::@2
-Simple Condition (bool~) processChars::$6 [310] if(*((byte*~) processChars::$37)!=(const byte) STATUS_NEW) goto processChars::@4
-Simple Condition (bool~) processChars::$61 [317] if((byte) 0!=(byte~) processChars::$9) goto processChars::@5
-Simple Condition (bool~) init_angle_screen::$2 [408] if((byte) init_angle_screen::x#2<=(byte) $13) goto init_angle_screen::@3
-Simple Condition (bool~) init_angle_screen::$16 [445] if((byte) init_angle_screen::y#1!=rangelast(0,$c)) goto init_angle_screen::@1
-Simple Condition (bool~) initSprites::$0 [450] if((byte*) initSprites::sp#2<(const byte*) SPRITE_DATA+(const byte) NUM_PROCESSING*(byte) $40) goto initSprites::@2
-Simple Condition (bool~) initSprites::$1 [459] if((byte) initSprites::i#1!=rangelast(0,7)) goto initSprites::@7
-Simple Condition (bool~) setupRasterIrq::$0 [470] if((word) setupRasterIrq::raster#0<(word) $100) goto setupRasterIrq::@1
-Simple Condition (bool~) irqTop::$1 [491] if((byte) irqTop::i#1!=rangelast(0,4)) goto irqTop::@3
-Simple Condition (bool~) irqTop::$2 [498] if((byte) irqTop::i1#1!=rangelast(0,7)) goto irqTop::@5
-Simple Condition (bool~) irqBottom::$3 [511] if((byte) irqBottom::i#1!=rangelast(0,4)) goto irqBottom::@5
+Simple Condition (bool~) startProcessing::$23 [220] if(*((byte*)(const struct ProcessingSprite*) PROCESSING+(const byte) OFFSET_STRUCT_PROCESSINGSPRITE_STATUS + (byte~) startProcessing::$27)!=(const byte) STATUS_FREE) goto startProcessing::@3
+Simple Condition (bool~) startProcessing::$24 [224] if((byte) startProcessing::i#1!=rangelast(0,NUM_PROCESSING-1)) goto startProcessing::@2
+Simple Condition (bool~) startProcessing::$25 [229] if((byte) startProcessing::freeIdx#2==(byte) $ff) goto startProcessing::@1
+Simple Condition (bool~) startProcessing::$26 [259] if((byte) startProcessing::i1#1!=rangelast(0,7)) goto startProcessing::@9
+Simple Condition (bool~) processChars::$4 [300] if(*((byte*~) processChars::$36)==(const byte) STATUS_FREE) goto processChars::@3
+Simple Condition (bool~) processChars::$30 [304] if((byte) processChars::i#1!=rangelast(0,NUM_PROCESSING-1)) goto processChars::@2
+Simple Condition (bool~) processChars::$6 [309] if(*((byte*~) processChars::$37)!=(const byte) STATUS_NEW) goto processChars::@4
+Simple Condition (bool~) processChars::$61 [316] if((byte) 0!=(byte~) processChars::$9) goto processChars::@5
+Simple Condition (bool~) init_angle_screen::$2 [407] if((byte) init_angle_screen::x#2<=(byte) $13) goto init_angle_screen::@3
+Simple Condition (bool~) init_angle_screen::$16 [444] if((byte) init_angle_screen::y#1!=rangelast(0,$c)) goto init_angle_screen::@1
+Simple Condition (bool~) initSprites::$0 [449] if((byte*) initSprites::sp#2<(const byte*) SPRITE_DATA+(const byte) NUM_PROCESSING*(byte) $40) goto initSprites::@2
+Simple Condition (bool~) initSprites::$1 [458] if((byte) initSprites::i#1!=rangelast(0,7)) goto initSprites::@7
+Simple Condition (bool~) setupRasterIrq::$0 [469] if((word) setupRasterIrq::raster#0<(word) $100) goto setupRasterIrq::@1
+Simple Condition (bool~) irqTop::$1 [490] if((byte) irqTop::i#1!=rangelast(0,4)) goto irqTop::@3
+Simple Condition (bool~) irqTop::$2 [497] if((byte) irqTop::i1#1!=rangelast(0,7)) goto irqTop::@5
+Simple Condition (bool~) irqBottom::$3 [510] if((byte) irqBottom::i#1!=rangelast(0,4)) goto irqBottom::@5
 Successful SSA optimization Pass2ConditionalJumpSimplification
-Rewriting || if()-condition to two if()s [356] (bool~) processChars::$22 ← (bool~) processChars::$20 || (bool~) processChars::$21
-Rewriting || if()-condition to two if()s [353] (bool~) processChars::$20 ← (bool~) processChars::$18 || (bool~) processChars::$19
-Rewriting || if()-condition to two if()s [350] (bool~) processChars::$18 ← (bool~) processChars::$16 || (bool~) processChars::$17
-Rewriting ! if()-condition to reversed if() [391] (bool~) processChars::$0 ← ! (const bool) DEBUG
-Rewriting ! if()-condition to reversed if() [482] (bool~) irqTop::$0 ← ! (const bool) DEBUG
-Rewriting ! if()-condition to reversed if() [502] (bool~) irqBottom::$0 ← ! (const bool) DEBUG
-Rewriting ! if()-condition to reversed if() [505] (bool~) irqBottom::$2 ← ! (const bool) DEBUG
+Rewriting || if()-condition to two if()s [355] (bool~) processChars::$22 ← (bool~) processChars::$20 || (bool~) processChars::$21
+Rewriting || if()-condition to two if()s [352] (bool~) processChars::$20 ← (bool~) processChars::$18 || (bool~) processChars::$19
+Rewriting || if()-condition to two if()s [349] (bool~) processChars::$18 ← (bool~) processChars::$16 || (bool~) processChars::$17
+Rewriting ! if()-condition to reversed if() [390] (bool~) processChars::$0 ← ! (const bool) DEBUG
+Rewriting ! if()-condition to reversed if() [481] (bool~) irqTop::$0 ← ! (const bool) DEBUG
+Rewriting ! if()-condition to reversed if() [501] (bool~) irqBottom::$0 ← ! (const bool) DEBUG
+Rewriting ! if()-condition to reversed if() [504] (bool~) irqBottom::$2 ← ! (const bool) DEBUG
 Successful SSA optimization Pass2ConditionalAndOrRewriting
 Negating conditional jump and destination [74] if((byte) atan2_16::i#1==rangelast(0,CORDIC_ITERATIONS_16-1)) goto atan2_16::@17
-Constant right-side identified [218] (byte*~) startProcessing::$29 ← (byte*)(const struct ProcessingSprite*) PROCESSING + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_STATUS
-Successful SSA optimization Pass2ConstantRValueConsolidation
 Constant (const byte*) heap_head#0 = HEAP_TOP
 Constant (const word) atan2_16::angle#0 = 0
 Constant (const byte) atan2_16::i#0 = 0
@@ -2781,7 +2777,6 @@ Constant (const byte) getCharToProcess::y#0 = 0
 Constant (const byte) getCharToProcess::x#0 = 0
 Constant (const byte) startProcessing::freeIdx#0 = $ff
 Constant (const byte) startProcessing::i#0 = 0
-Constant (const byte*) startProcessing::$29 = (byte*)PROCESSING+OFFSET_STRUCT_PROCESSINGSPRITE_STATUS
 Constant (const byte) startProcessing::i1#0 = 0
 Constant (const byte) processChars::numActive#0 = 0
 Constant (const byte) processChars::i#0 = 0
@@ -2796,11 +2791,11 @@ Constant (const byte) irqBottom::i#0 = 0
 Successful SSA optimization Pass2ConstantIdentification
 if() condition always true - replacing block destination [154] if(true) goto main::@9
 if() condition always true - replacing block destination [157] if(true) goto main::@15
-if() condition always false - eliminating [392] if((const bool) DEBUG) goto processChars::@16
-if() condition always true - replacing block destination [470] if((const word) setupRasterIrq::raster#0<(word) $100) goto setupRasterIrq::@1
-if() condition always false - eliminating [483] if((const bool) DEBUG) goto irqTop::@2
-if() condition always false - eliminating [503] if((const bool) DEBUG) goto irqBottom::@3
-if() condition always false - eliminating [506] if((const bool) DEBUG) goto irqBottom::@4
+if() condition always false - eliminating [391] if((const bool) DEBUG) goto processChars::@16
+if() condition always true - replacing block destination [469] if((const word) setupRasterIrq::raster#0<(word) $100) goto setupRasterIrq::@1
+if() condition always false - eliminating [482] if((const bool) DEBUG) goto irqTop::@2
+if() condition always false - eliminating [502] if((const bool) DEBUG) goto irqBottom::@3
+if() condition always false - eliminating [505] if((const bool) DEBUG) goto irqBottom::@4
 Successful SSA optimization Pass2ConstantIfs
 Resolved ranged next value [72] atan2_16::i#1 ← ++ atan2_16::i#2 to ++
 Resolved ranged comparison value [74] if(atan2_16::i#1==rangelast(0,CORDIC_ITERATIONS_16-1)) goto atan2_16::@17 to (const byte) CORDIC_ITERATIONS_16-(byte) 1+(number) 1
@@ -2810,63 +2805,63 @@ Resolved ranged next value [173] getCharToProcess::x#1 ← ++ getCharToProcess::
 Resolved ranged comparison value [175] if(getCharToProcess::x#1!=rangelast(0,$27)) goto getCharToProcess::@4 to (number) $28
 Resolved ranged next value [188] getCharToProcess::y#1 ← ++ getCharToProcess::y#7 to ++
 Resolved ranged comparison value [190] if(getCharToProcess::y#1!=rangelast(0,$18)) goto getCharToProcess::@3 to (number) $19
-Resolved ranged next value [223] startProcessing::i#1 ← ++ startProcessing::i#2 to ++
-Resolved ranged comparison value [225] if(startProcessing::i#1!=rangelast(0,NUM_PROCESSING-1)) goto startProcessing::@2 to (const byte) NUM_PROCESSING-(byte) 1+(number) 1
-Resolved ranged next value [258] startProcessing::i1#1 ← ++ startProcessing::i1#2 to ++
-Resolved ranged comparison value [260] if(startProcessing::i1#1!=rangelast(0,7)) goto startProcessing::@9 to (number) 8
-Resolved ranged next value [303] processChars::i#1 ← ++ processChars::i#10 to ++
-Resolved ranged comparison value [305] if(processChars::i#1!=rangelast(0,NUM_PROCESSING-1)) goto processChars::@2 to (const byte) NUM_PROCESSING-(byte) 1+(number) 1
-Resolved ranged next value [443] init_angle_screen::y#1 ← ++ init_angle_screen::y#5 to ++
-Resolved ranged comparison value [445] if(init_angle_screen::y#1!=rangelast(0,$c)) goto init_angle_screen::@1 to (number) $d
-Resolved ranged next value [457] initSprites::i#1 ← ++ initSprites::i#2 to ++
-Resolved ranged comparison value [459] if(initSprites::i#1!=rangelast(0,7)) goto initSprites::@7 to (number) 8
-Resolved ranged next value [489] irqTop::i#1 ← ++ irqTop::i#2 to ++
-Resolved ranged comparison value [491] if(irqTop::i#1!=rangelast(0,4)) goto irqTop::@3 to (number) 5
-Resolved ranged next value [496] irqTop::i1#1 ← ++ irqTop::i1#2 to ++
-Resolved ranged comparison value [498] if(irqTop::i1#1!=rangelast(0,7)) goto irqTop::@5 to (number) 8
-Resolved ranged next value [509] irqBottom::i#1 ← ++ irqBottom::i#2 to ++
-Resolved ranged comparison value [511] if(irqBottom::i#1!=rangelast(0,4)) goto irqBottom::@5 to (number) 5
-Rewriting conditional comparison [408] if((byte) init_angle_screen::x#2<=(byte) $13) goto init_angle_screen::@3
+Resolved ranged next value [222] startProcessing::i#1 ← ++ startProcessing::i#2 to ++
+Resolved ranged comparison value [224] if(startProcessing::i#1!=rangelast(0,NUM_PROCESSING-1)) goto startProcessing::@2 to (const byte) NUM_PROCESSING-(byte) 1+(number) 1
+Resolved ranged next value [257] startProcessing::i1#1 ← ++ startProcessing::i1#2 to ++
+Resolved ranged comparison value [259] if(startProcessing::i1#1!=rangelast(0,7)) goto startProcessing::@9 to (number) 8
+Resolved ranged next value [302] processChars::i#1 ← ++ processChars::i#10 to ++
+Resolved ranged comparison value [304] if(processChars::i#1!=rangelast(0,NUM_PROCESSING-1)) goto processChars::@2 to (const byte) NUM_PROCESSING-(byte) 1+(number) 1
+Resolved ranged next value [442] init_angle_screen::y#1 ← ++ init_angle_screen::y#5 to ++
+Resolved ranged comparison value [444] if(init_angle_screen::y#1!=rangelast(0,$c)) goto init_angle_screen::@1 to (number) $d
+Resolved ranged next value [456] initSprites::i#1 ← ++ initSprites::i#2 to ++
+Resolved ranged comparison value [458] if(initSprites::i#1!=rangelast(0,7)) goto initSprites::@7 to (number) 8
+Resolved ranged next value [488] irqTop::i#1 ← ++ irqTop::i#2 to ++
+Resolved ranged comparison value [490] if(irqTop::i#1!=rangelast(0,4)) goto irqTop::@3 to (number) 5
+Resolved ranged next value [495] irqTop::i1#1 ← ++ irqTop::i1#2 to ++
+Resolved ranged comparison value [497] if(irqTop::i1#1!=rangelast(0,7)) goto irqTop::@5 to (number) 8
+Resolved ranged next value [508] irqBottom::i#1 ← ++ irqBottom::i#2 to ++
+Resolved ranged comparison value [510] if(irqBottom::i#1!=rangelast(0,4)) goto irqBottom::@5 to (number) 5
+Rewriting conditional comparison [407] if((byte) init_angle_screen::x#2<=(byte) $13) goto init_angle_screen::@3
 Converting *(pointer+n) to pointer[n] [205] *((byte*~) getCharToProcess::$11) ← (byte) ' '  -- *(getCharToProcess::$10 + getCharToProcess::return_x#1)
-Converting *(pointer+n) to pointer[n] [296] (byte) processChars::bitmask#0 ← (byte) 1 << *((byte*~) processChars::$35)  -- *((byte*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_ID)
-Converting *(pointer+n) to pointer[n] [301] if(*((byte*~) processChars::$36)==(const byte) STATUS_FREE) goto processChars::@3  -- *((byte*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_STATUS)
-Converting *(pointer+n) to pointer[n] [310] if(*((byte*~) processChars::$37)!=(const byte) STATUS_NEW) goto processChars::@4  -- *((byte*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_STATUS)
-Converting *(pointer+n) to pointer[n] [313] (word) processChars::xpos#0 ← *((word*~) processChars::$38) >> (byte) 4  -- *((word*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_X)
-Converting *(pointer+n) to pointer[n] [320] *(*((byte**~) processChars::$39)) ← (byte) ' '  -- *((byte**)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_SCREENPTR)
-Converting *(pointer+n) to pointer[n] [324] *((const byte*) SPRITES_COLS + *((byte*~) processChars::$41)) ← *((byte*~) processChars::$40)  -- *((byte*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_COL)
-Converting *(pointer+n) to pointer[n] [324] *((const byte*) SPRITES_COLS + *((byte*~) processChars::$41)) ← *((byte*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_COL)  -- *((byte*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_ID)
-Converting *(pointer+n) to pointer[n] [326] (byte*~) processChars::$7 ← (const byte*) SCREEN+(const word) SPRITE_PTRS + *((byte*~) processChars::$42)  -- *((byte*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_ID)
-Converting *(pointer+n) to pointer[n] [328] *((byte*~) processChars::$7) ← *((byte*~) processChars::$43)  -- *((byte*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_PTR)
-Converting *(pointer+n) to pointer[n] [328] *((byte*~) processChars::$7) ← *((byte*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_PTR)  -- *(SCREEN+SPRITE_PTRS + *((byte*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_ID))
-Converting *(pointer+n) to pointer[n] [330] *((byte*~) processChars::$44) ← (const byte) STATUS_PROCESSING  -- *((byte*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_STATUS)
-Converting *(pointer+n) to pointer[n] [341] (word~) processChars::$13 ← *((word*~) processChars::$45) >> (byte) 4  -- *((word*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_Y)
-Converting *(pointer+n) to pointer[n] [347] (bool~) processChars::$16 ← *((word*~) processChars::$46) < (const word) XPOS_LEFTMOST  -- *((word*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_X)
-Converting *(pointer+n) to pointer[n] [349] (bool~) processChars::$17 ← *((word*~) processChars::$47) > (const word) XPOS_RIGHTMOST  -- *((word*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_X)
-Converting *(pointer+n) to pointer[n] [352] (bool~) processChars::$19 ← *((word*~) processChars::$48) < (const word) YPOS_TOPMOST  -- *((word*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_Y)
-Converting *(pointer+n) to pointer[n] [355] (bool~) processChars::$21 ← *((word*~) processChars::$49) > (const word) YPOS_BOTTOMMOST  -- *((word*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_Y)
-Converting *(pointer+n) to pointer[n] [360] *((byte*~) processChars::$50) ← (const byte) STATUS_FREE  -- *((byte*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_STATUS)
-Converting *(pointer+n) to pointer[n] [371] *((word*~) processChars::$52) ← *((word*~) processChars::$51) + *((const word*) VXSIN + (byte~) processChars::$33)  -- *((word*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_VX)
-Converting *(pointer+n) to pointer[n] [371] *((word*~) processChars::$52) ← *((word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_VX) + *((const word*) VXSIN + (byte~) processChars::$33)  -- *((word*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_VX)
-Converting *(pointer+n) to pointer[n] [375] *((word*~) processChars::$55) ← *((word*~) processChars::$53) + *((word*~) processChars::$54)  -- *((word*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_X)
-Converting *(pointer+n) to pointer[n] [375] *((word*~) processChars::$55) ← *((word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_X) + *((word*~) processChars::$54)  -- *((word*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_VX)
-Converting *(pointer+n) to pointer[n] [375] *((word*~) processChars::$55) ← *((word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_X) + *((word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_VX)  -- *((word*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_X)
-Converting *(pointer+n) to pointer[n] [383] *((word*~) processChars::$57) ← *((word*~) processChars::$56) + *((const word*) VYSIN + (byte~) processChars::$34)  -- *((word*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_VY)
-Converting *(pointer+n) to pointer[n] [383] *((word*~) processChars::$57) ← *((word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_VY) + *((const word*) VYSIN + (byte~) processChars::$34)  -- *((word*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_VY)
-Converting *(pointer+n) to pointer[n] [387] *((word*~) processChars::$60) ← *((word*~) processChars::$58) + *((word*~) processChars::$59)  -- *((word*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_Y)
-Converting *(pointer+n) to pointer[n] [387] *((word*~) processChars::$60) ← *((word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_Y) + *((word*~) processChars::$59)  -- *((word*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_VY)
-Converting *(pointer+n) to pointer[n] [387] *((word*~) processChars::$60) ← *((word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_Y) + *((word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_VY)  -- *((word*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_Y)
+Converting *(pointer+n) to pointer[n] [295] (byte) processChars::bitmask#0 ← (byte) 1 << *((byte*~) processChars::$35)  -- *((byte*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_ID)
+Converting *(pointer+n) to pointer[n] [300] if(*((byte*~) processChars::$36)==(const byte) STATUS_FREE) goto processChars::@3  -- *((byte*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_STATUS)
+Converting *(pointer+n) to pointer[n] [309] if(*((byte*~) processChars::$37)!=(const byte) STATUS_NEW) goto processChars::@4  -- *((byte*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_STATUS)
+Converting *(pointer+n) to pointer[n] [312] (word) processChars::xpos#0 ← *((word*~) processChars::$38) >> (byte) 4  -- *((word*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_X)
+Converting *(pointer+n) to pointer[n] [319] *(*((byte**~) processChars::$39)) ← (byte) ' '  -- *((byte**)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_SCREENPTR)
+Converting *(pointer+n) to pointer[n] [323] *((const byte*) SPRITES_COLS + *((byte*~) processChars::$41)) ← *((byte*~) processChars::$40)  -- *((byte*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_COL)
+Converting *(pointer+n) to pointer[n] [323] *((const byte*) SPRITES_COLS + *((byte*~) processChars::$41)) ← *((byte*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_COL)  -- *((byte*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_ID)
+Converting *(pointer+n) to pointer[n] [325] (byte*~) processChars::$7 ← (const byte*) SCREEN+(const word) SPRITE_PTRS + *((byte*~) processChars::$42)  -- *((byte*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_ID)
+Converting *(pointer+n) to pointer[n] [327] *((byte*~) processChars::$7) ← *((byte*~) processChars::$43)  -- *((byte*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_PTR)
+Converting *(pointer+n) to pointer[n] [327] *((byte*~) processChars::$7) ← *((byte*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_PTR)  -- *(SCREEN+SPRITE_PTRS + *((byte*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_ID))
+Converting *(pointer+n) to pointer[n] [329] *((byte*~) processChars::$44) ← (const byte) STATUS_PROCESSING  -- *((byte*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_STATUS)
+Converting *(pointer+n) to pointer[n] [340] (word~) processChars::$13 ← *((word*~) processChars::$45) >> (byte) 4  -- *((word*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_Y)
+Converting *(pointer+n) to pointer[n] [346] (bool~) processChars::$16 ← *((word*~) processChars::$46) < (const word) XPOS_LEFTMOST  -- *((word*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_X)
+Converting *(pointer+n) to pointer[n] [348] (bool~) processChars::$17 ← *((word*~) processChars::$47) > (const word) XPOS_RIGHTMOST  -- *((word*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_X)
+Converting *(pointer+n) to pointer[n] [351] (bool~) processChars::$19 ← *((word*~) processChars::$48) < (const word) YPOS_TOPMOST  -- *((word*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_Y)
+Converting *(pointer+n) to pointer[n] [354] (bool~) processChars::$21 ← *((word*~) processChars::$49) > (const word) YPOS_BOTTOMMOST  -- *((word*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_Y)
+Converting *(pointer+n) to pointer[n] [359] *((byte*~) processChars::$50) ← (const byte) STATUS_FREE  -- *((byte*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_STATUS)
+Converting *(pointer+n) to pointer[n] [370] *((word*~) processChars::$52) ← *((word*~) processChars::$51) + *((const word*) VXSIN + (byte~) processChars::$33)  -- *((word*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_VX)
+Converting *(pointer+n) to pointer[n] [370] *((word*~) processChars::$52) ← *((word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_VX) + *((const word*) VXSIN + (byte~) processChars::$33)  -- *((word*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_VX)
+Converting *(pointer+n) to pointer[n] [374] *((word*~) processChars::$55) ← *((word*~) processChars::$53) + *((word*~) processChars::$54)  -- *((word*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_X)
+Converting *(pointer+n) to pointer[n] [374] *((word*~) processChars::$55) ← *((word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_X) + *((word*~) processChars::$54)  -- *((word*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_VX)
+Converting *(pointer+n) to pointer[n] [374] *((word*~) processChars::$55) ← *((word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_X) + *((word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_VX)  -- *((word*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_X)
+Converting *(pointer+n) to pointer[n] [382] *((word*~) processChars::$57) ← *((word*~) processChars::$56) + *((const word*) VYSIN + (byte~) processChars::$34)  -- *((word*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_VY)
+Converting *(pointer+n) to pointer[n] [382] *((word*~) processChars::$57) ← *((word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_VY) + *((const word*) VYSIN + (byte~) processChars::$34)  -- *((word*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_VY)
+Converting *(pointer+n) to pointer[n] [386] *((word*~) processChars::$60) ← *((word*~) processChars::$58) + *((word*~) processChars::$59)  -- *((word*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_Y)
+Converting *(pointer+n) to pointer[n] [386] *((word*~) processChars::$60) ← *((word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_Y) + *((word*~) processChars::$59)  -- *((word*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_VY)
+Converting *(pointer+n) to pointer[n] [386] *((word*~) processChars::$60) ← *((word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_Y) + *((word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_VY)  -- *((word*)processChars::processing#0 + OFFSET_STRUCT_PROCESSINGSPRITE_Y)
 Successful SSA optimization Pass2InlineDerefIdx
-Simplifying expression containing zero (word*)PROCESSING in [279] *((word*)(const struct ProcessingSprite*) PROCESSING+(const byte) OFFSET_STRUCT_PROCESSINGSPRITE_X + (byte~) startProcessing::$28) ← (word) startProcessing::spriteX#0
-Simplifying expression containing zero (word*)processChars::processing#0 in [312] (word*~) processChars::$38 ← (word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_X
-Simplifying expression containing zero (word*)processChars::processing#0 in [313] (word) processChars::xpos#0 ← *((word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_X) >> (byte) 4
-Simplifying expression containing zero (word*)processChars::processing#0 in [346] (word*~) processChars::$46 ← (word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_X
-Simplifying expression containing zero (word*)processChars::processing#0 in [347] (bool~) processChars::$16 ← *((word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_X) < (const word) XPOS_LEFTMOST
-Simplifying expression containing zero (word*)processChars::processing#0 in [348] (word*~) processChars::$47 ← (word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_X
-Simplifying expression containing zero (word*)processChars::processing#0 in [349] (bool~) processChars::$17 ← *((word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_X) > (const word) XPOS_RIGHTMOST
-Simplifying expression containing zero (word*)processChars::processing#0 in [372] (word*~) processChars::$53 ← (word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_X
-Simplifying expression containing zero (word*)processChars::processing#0 in [374] (word*~) processChars::$55 ← (word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_X
-Simplifying expression containing zero (word*)processChars::processing#0 in [375] *((word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_X) ← *((word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_X) + *((word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_VX)
-Simplifying expression containing zero (word*)processChars::processing#0 in [375] *((word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_X) ← *((word*)(struct ProcessingSprite*) processChars::processing#0) + *((word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_VX)
+Simplifying expression containing zero (word*)PROCESSING in [278] *((word*)(const struct ProcessingSprite*) PROCESSING+(const byte) OFFSET_STRUCT_PROCESSINGSPRITE_X + (byte~) startProcessing::$28) ← (word) startProcessing::spriteX#0
+Simplifying expression containing zero (word*)processChars::processing#0 in [311] (word*~) processChars::$38 ← (word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_X
+Simplifying expression containing zero (word*)processChars::processing#0 in [312] (word) processChars::xpos#0 ← *((word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_X) >> (byte) 4
+Simplifying expression containing zero (word*)processChars::processing#0 in [345] (word*~) processChars::$46 ← (word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_X
+Simplifying expression containing zero (word*)processChars::processing#0 in [346] (bool~) processChars::$16 ← *((word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_X) < (const word) XPOS_LEFTMOST
+Simplifying expression containing zero (word*)processChars::processing#0 in [347] (word*~) processChars::$47 ← (word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_X
+Simplifying expression containing zero (word*)processChars::processing#0 in [348] (bool~) processChars::$17 ← *((word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_X) > (const word) XPOS_RIGHTMOST
+Simplifying expression containing zero (word*)processChars::processing#0 in [371] (word*~) processChars::$53 ← (word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_X
+Simplifying expression containing zero (word*)processChars::processing#0 in [373] (word*~) processChars::$55 ← (word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_X
+Simplifying expression containing zero (word*)processChars::processing#0 in [374] *((word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_X) ← *((word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_X) + *((word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_VX)
+Simplifying expression containing zero (word*)processChars::processing#0 in [374] *((word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_X) ← *((word*)(struct ProcessingSprite*) processChars::processing#0) + *((word*)(struct ProcessingSprite*) processChars::processing#0 + (const byte) OFFSET_STRUCT_PROCESSINGSPRITE_VX)
 Successful SSA optimization PassNSimplifyExpressionWithZero
 Eliminating unused variable (byte) startProcessing::center_dist#0 and assignment [76] (byte) startProcessing::center_dist#0 ← (byte) main::center_dist#0
 Eliminating unused variable (struct ProcessingChar) getCharToProcess::return#0 and assignment [96] (struct ProcessingChar) getCharToProcess::return#0 ← struct-unwound {(byte) getCharToProcess::return_x#1, (byte) getCharToProcess::return_y#1, (byte) getCharToProcess::return_dist#1}
@@ -3061,7 +3056,6 @@ Constant inlined getCharToProcess::closest_x#0 = (byte) 0
 Constant inlined ProcessingSprite::$0::STATUS_FREE = (byte) 0
 Constant inlined startProcessing::i1#0 = (byte) 0
 Constant inlined init_angle_screen::xb#0 = (byte) $27
-Constant inlined startProcessing::$29 = (byte*)(const struct ProcessingSprite*) PROCESSING+(const byte) OFFSET_STRUCT_PROCESSINGSPRITE_STATUS
 Constant inlined atan2_16::i#0 = (byte) 0
 Constant inlined malloc::size#1 = (word) $3e8
 Constant inlined malloc::size#0 = (word) $3e8
@@ -3076,9 +3070,9 @@ Constant inlined initSprites::i#0 = (byte) 0
 Successful SSA optimization Pass2ConstantInlining
 Alias (byte~) main::$10 = (byte~) main::$15 
 Alias (word~) getCharToProcess::$9 = (word~) getCharToProcess::$14 
-Alias (byte~) startProcessing::$27 = (byte~) startProcessing::$34 
-Alias (word~) startProcessing::$1 = (word~) startProcessing::$37 
-Alias (byte~) startProcessing::$28 = (byte~) startProcessing::$42 
+Alias (byte~) startProcessing::$27 = (byte~) startProcessing::$33 
+Alias (word~) startProcessing::$1 = (word~) startProcessing::$36 
+Alias (byte~) startProcessing::$28 = (byte~) startProcessing::$41 
 Alias (byte~) processChars::$32 = (byte~) processChars::$66 
 Successful SSA optimization Pass2AliasElimination
 Identical Phi Values (word) malloc::size#2 (word) $3e8
@@ -3408,11 +3402,11 @@ startProcessing::@1: scope:[startProcessing]  from startProcessing startProcessi
   to:startProcessing::@2
 startProcessing::@2: scope:[startProcessing]  from startProcessing::@1 startProcessing::@3
   [46] (byte) startProcessing::i#2 ← phi( startProcessing::@1/(byte) 0 startProcessing::@3/(byte) startProcessing::i#1 )
-  [47] (byte~) startProcessing::$30 ← (byte) startProcessing::i#2 << (byte) 1
-  [48] (byte~) startProcessing::$31 ← (byte~) startProcessing::$30 + (byte) startProcessing::i#2
-  [49] (byte~) startProcessing::$32 ← (byte~) startProcessing::$31 << (byte) 1
-  [50] (byte~) startProcessing::$33 ← (byte~) startProcessing::$32 + (byte) startProcessing::i#2
-  [51] (byte~) startProcessing::$27 ← (byte~) startProcessing::$33 << (byte) 1
+  [47] (byte~) startProcessing::$29 ← (byte) startProcessing::i#2 << (byte) 1
+  [48] (byte~) startProcessing::$30 ← (byte~) startProcessing::$29 + (byte) startProcessing::i#2
+  [49] (byte~) startProcessing::$31 ← (byte~) startProcessing::$30 << (byte) 1
+  [50] (byte~) startProcessing::$32 ← (byte~) startProcessing::$31 + (byte) startProcessing::i#2
+  [51] (byte~) startProcessing::$27 ← (byte~) startProcessing::$32 << (byte) 1
   [52] if(*((byte*)(const struct ProcessingSprite*) PROCESSING+(const byte) OFFSET_STRUCT_PROCESSINGSPRITE_STATUS + (byte~) startProcessing::$27)!=(const byte) STATUS_FREE) goto startProcessing::@3
   to:startProcessing::@4
 startProcessing::@4: scope:[startProcessing]  from startProcessing::@2 startProcessing::@9
@@ -3421,9 +3415,9 @@ startProcessing::@4: scope:[startProcessing]  from startProcessing::@2 startProc
   to:startProcessing::@5
 startProcessing::@5: scope:[startProcessing]  from startProcessing::@4
   [55] (word~) startProcessing::$0 ← (word)(byte) startProcessing::center_y#0
-  [56] (word~) startProcessing::$35 ← (word~) startProcessing::$0 << (byte) 2
-  [57] (word~) startProcessing::$36 ← (word~) startProcessing::$35 + (word~) startProcessing::$0
-  [58] (word~) startProcessing::$1 ← (word~) startProcessing::$36 << (byte) 3
+  [56] (word~) startProcessing::$34 ← (word~) startProcessing::$0 << (byte) 2
+  [57] (word~) startProcessing::$35 ← (word~) startProcessing::$34 + (word~) startProcessing::$0
+  [58] (word~) startProcessing::$1 ← (word~) startProcessing::$35 << (byte) 3
   [59] (word) startProcessing::offset#0 ← (word~) startProcessing::$1 + (byte) startProcessing::center_x#0
   [60] (byte*) startProcessing::colPtr#0 ← (const byte*) COLS + (word) startProcessing::offset#0
   [61] (byte) startProcessing::spriteCol#0 ← *((byte*) startProcessing::colPtr#0)
@@ -3462,11 +3456,11 @@ startProcessing::@7: scope:[startProcessing]  from startProcessing::@6
   [88] (byte) startProcessing::spritePtr#0 ← (byte)(const byte*) SPRITE_DATA/(byte) $40 + (byte) startProcessing::freeIdx#2
   [89] (byte~) startProcessing::$20 ← (byte) startProcessing::freeIdx#2 << (byte) 3
   [90] (word~) startProcessing::$21 ← (word)(byte~) startProcessing::$20
-  [91] (byte~) startProcessing::$38 ← (byte) startProcessing::freeIdx#2 << (byte) 1
-  [92] (byte~) startProcessing::$39 ← (byte~) startProcessing::$38 + (byte) startProcessing::freeIdx#2
-  [93] (byte~) startProcessing::$40 ← (byte~) startProcessing::$39 << (byte) 1
-  [94] (byte~) startProcessing::$41 ← (byte~) startProcessing::$40 + (byte) startProcessing::freeIdx#2
-  [95] (byte~) startProcessing::$28 ← (byte~) startProcessing::$41 << (byte) 1
+  [91] (byte~) startProcessing::$37 ← (byte) startProcessing::freeIdx#2 << (byte) 1
+  [92] (byte~) startProcessing::$38 ← (byte~) startProcessing::$37 + (byte) startProcessing::freeIdx#2
+  [93] (byte~) startProcessing::$39 ← (byte~) startProcessing::$38 << (byte) 1
+  [94] (byte~) startProcessing::$40 ← (byte~) startProcessing::$39 + (byte) startProcessing::freeIdx#2
+  [95] (byte~) startProcessing::$28 ← (byte~) startProcessing::$40 << (byte) 1
   [96] *((word*)(const struct ProcessingSprite*) PROCESSING + (byte~) startProcessing::$28) ← (word) startProcessing::spriteX#0
   [97] *((word*)(const struct ProcessingSprite*) PROCESSING+(const byte) OFFSET_STRUCT_PROCESSINGSPRITE_Y + (byte~) startProcessing::$28) ← (word) startProcessing::spriteY#0
   [98] *((word*)(const struct ProcessingSprite*) PROCESSING+(const byte) OFFSET_STRUCT_PROCESSINGSPRITE_VX + (byte~) startProcessing::$28) ← (word~) startProcessing::$21
@@ -4131,16 +4125,16 @@ interrupt(HARDWARE_ALL)(void()) irqTop()
 (word~) startProcessing::$21 0.5
 (byte~) startProcessing::$27 2002.0
 (byte~) startProcessing::$28 2.2222222222222228
+(byte~) startProcessing::$29 2002.0
 (byte~) startProcessing::$30 2002.0
 (byte~) startProcessing::$31 2002.0
 (byte~) startProcessing::$32 2002.0
-(byte~) startProcessing::$33 2002.0
+(word~) startProcessing::$34 4.0
 (word~) startProcessing::$35 4.0
-(word~) startProcessing::$36 4.0
+(byte~) startProcessing::$37 4.0
 (byte~) startProcessing::$38 4.0
 (byte~) startProcessing::$39 4.0
 (byte~) startProcessing::$40 4.0
-(byte~) startProcessing::$41 4.0
 (word~) startProcessing::$5 4.0
 (word~) startProcessing::$6 4.0
 (word~) startProcessing::$8 4.0
@@ -4239,14 +4233,14 @@ Added variable main::center_y#0 to live range equivalence class [ main::center_y
 Added variable main::center_dist#0 to live range equivalence class [ main::center_dist#0 ]
 Added variable startProcessing::center_x#0 to live range equivalence class [ startProcessing::center_x#0 ]
 Added variable startProcessing::center_y#0 to live range equivalence class [ startProcessing::center_y#0 ]
+Added variable startProcessing::$29 to live range equivalence class [ startProcessing::$29 ]
 Added variable startProcessing::$30 to live range equivalence class [ startProcessing::$30 ]
 Added variable startProcessing::$31 to live range equivalence class [ startProcessing::$31 ]
 Added variable startProcessing::$32 to live range equivalence class [ startProcessing::$32 ]
-Added variable startProcessing::$33 to live range equivalence class [ startProcessing::$33 ]
 Added variable startProcessing::$27 to live range equivalence class [ startProcessing::$27 ]
 Added variable startProcessing::$0 to live range equivalence class [ startProcessing::$0 ]
+Added variable startProcessing::$34 to live range equivalence class [ startProcessing::$34 ]
 Added variable startProcessing::$35 to live range equivalence class [ startProcessing::$35 ]
-Added variable startProcessing::$36 to live range equivalence class [ startProcessing::$36 ]
 Added variable startProcessing::$1 to live range equivalence class [ startProcessing::$1 ]
 Added variable startProcessing::offset#0 to live range equivalence class [ startProcessing::offset#0 ]
 Added variable startProcessing::colPtr#0 to live range equivalence class [ startProcessing::colPtr#0 ]
@@ -4268,10 +4262,10 @@ Added variable startProcessing::spriteY#0 to live range equivalence class [ star
 Added variable startProcessing::spritePtr#0 to live range equivalence class [ startProcessing::spritePtr#0 ]
 Added variable startProcessing::$20 to live range equivalence class [ startProcessing::$20 ]
 Added variable startProcessing::$21 to live range equivalence class [ startProcessing::$21 ]
+Added variable startProcessing::$37 to live range equivalence class [ startProcessing::$37 ]
 Added variable startProcessing::$38 to live range equivalence class [ startProcessing::$38 ]
 Added variable startProcessing::$39 to live range equivalence class [ startProcessing::$39 ]
 Added variable startProcessing::$40 to live range equivalence class [ startProcessing::$40 ]
-Added variable startProcessing::$41 to live range equivalence class [ startProcessing::$41 ]
 Added variable startProcessing::$28 to live range equivalence class [ startProcessing::$28 ]
 Added variable getCharToProcess::$8 to live range equivalence class [ getCharToProcess::$8 ]
 Added variable getCharToProcess::$12 to live range equivalence class [ getCharToProcess::$12 ]
@@ -4368,14 +4362,14 @@ Complete equivalence classes
 [ main::center_dist#0 ]
 [ startProcessing::center_x#0 ]
 [ startProcessing::center_y#0 ]
+[ startProcessing::$29 ]
 [ startProcessing::$30 ]
 [ startProcessing::$31 ]
 [ startProcessing::$32 ]
-[ startProcessing::$33 ]
 [ startProcessing::$27 ]
 [ startProcessing::$0 ]
+[ startProcessing::$34 ]
 [ startProcessing::$35 ]
-[ startProcessing::$36 ]
 [ startProcessing::$1 ]
 [ startProcessing::offset#0 ]
 [ startProcessing::colPtr#0 ]
@@ -4397,10 +4391,10 @@ Complete equivalence classes
 [ startProcessing::spritePtr#0 ]
 [ startProcessing::$20 ]
 [ startProcessing::$21 ]
+[ startProcessing::$37 ]
 [ startProcessing::$38 ]
 [ startProcessing::$39 ]
 [ startProcessing::$40 ]
-[ startProcessing::$41 ]
 [ startProcessing::$28 ]
 [ getCharToProcess::$8 ]
 [ getCharToProcess::$12 ]
@@ -4496,14 +4490,14 @@ Allocated zp[1]:67 [ main::center_y#0 ]
 Allocated zp[1]:68 [ main::center_dist#0 ]
 Allocated zp[1]:69 [ startProcessing::center_x#0 ]
 Allocated zp[1]:70 [ startProcessing::center_y#0 ]
-Allocated zp[1]:71 [ startProcessing::$30 ]
-Allocated zp[1]:72 [ startProcessing::$31 ]
-Allocated zp[1]:73 [ startProcessing::$32 ]
-Allocated zp[1]:74 [ startProcessing::$33 ]
+Allocated zp[1]:71 [ startProcessing::$29 ]
+Allocated zp[1]:72 [ startProcessing::$30 ]
+Allocated zp[1]:73 [ startProcessing::$31 ]
+Allocated zp[1]:74 [ startProcessing::$32 ]
 Allocated zp[1]:75 [ startProcessing::$27 ]
 Allocated zp[2]:76 [ startProcessing::$0 ]
-Allocated zp[2]:78 [ startProcessing::$35 ]
-Allocated zp[2]:80 [ startProcessing::$36 ]
+Allocated zp[2]:78 [ startProcessing::$34 ]
+Allocated zp[2]:80 [ startProcessing::$35 ]
 Allocated zp[2]:82 [ startProcessing::$1 ]
 Allocated zp[2]:84 [ startProcessing::offset#0 ]
 Allocated zp[2]:86 [ startProcessing::colPtr#0 ]
@@ -4525,10 +4519,10 @@ Allocated zp[2]:114 [ startProcessing::spriteY#0 ]
 Allocated zp[1]:116 [ startProcessing::spritePtr#0 ]
 Allocated zp[1]:117 [ startProcessing::$20 ]
 Allocated zp[2]:118 [ startProcessing::$21 ]
-Allocated zp[1]:120 [ startProcessing::$38 ]
-Allocated zp[1]:121 [ startProcessing::$39 ]
-Allocated zp[1]:122 [ startProcessing::$40 ]
-Allocated zp[1]:123 [ startProcessing::$41 ]
+Allocated zp[1]:120 [ startProcessing::$37 ]
+Allocated zp[1]:121 [ startProcessing::$38 ]
+Allocated zp[1]:122 [ startProcessing::$39 ]
+Allocated zp[1]:123 [ startProcessing::$40 ]
 Allocated zp[1]:124 [ startProcessing::$28 ]
 Allocated zp[2]:125 [ getCharToProcess::$8 ]
 Allocated zp[2]:127 [ getCharToProcess::$12 ]
@@ -4945,16 +4939,16 @@ startProcessing: {
     .label freeIdx = 8
     // Busy-wait while finding an empty slot in the PROCESSING array
     .label freeIdx_1 = 7
-    .label __30 = $47
-    .label __31 = $48
-    .label __32 = $49
-    .label __33 = $4a
-    .label __35 = $4e
-    .label __36 = $50
-    .label __38 = $78
-    .label __39 = $79
-    .label __40 = $7a
-    .label __41 = $7b
+    .label __29 = $47
+    .label __30 = $48
+    .label __31 = $49
+    .label __32 = $4a
+    .label __34 = $4e
+    .label __35 = $50
+    .label __37 = $78
+    .label __38 = $79
+    .label __39 = $7a
+    .label __40 = $7b
     // [45] phi from startProcessing to startProcessing::@1 [phi:startProcessing->startProcessing::@1]
   __b1_from_startProcessing:
     // [45] phi (byte) startProcessing::freeIdx#6 = (byte) $ff [phi:startProcessing->startProcessing::@1#0] -- vbuz1=vbuc1 
@@ -4975,26 +4969,26 @@ startProcessing: {
     jmp __b2
     // startProcessing::@2
   __b2:
-    // [47] (byte~) startProcessing::$30 ← (byte) startProcessing::i#2 << (byte) 1 -- vbuz1=vbuz2_rol_1 
+    // [47] (byte~) startProcessing::$29 ← (byte) startProcessing::i#2 << (byte) 1 -- vbuz1=vbuz2_rol_1 
     lda.z i
     asl
+    sta.z __29
+    // [48] (byte~) startProcessing::$30 ← (byte~) startProcessing::$29 + (byte) startProcessing::i#2 -- vbuz1=vbuz2_plus_vbuz3 
+    lda.z __29
+    clc
+    adc.z i
     sta.z __30
-    // [48] (byte~) startProcessing::$31 ← (byte~) startProcessing::$30 + (byte) startProcessing::i#2 -- vbuz1=vbuz2_plus_vbuz3 
+    // [49] (byte~) startProcessing::$31 ← (byte~) startProcessing::$30 << (byte) 1 -- vbuz1=vbuz2_rol_1 
     lda.z __30
-    clc
-    adc.z i
-    sta.z __31
-    // [49] (byte~) startProcessing::$32 ← (byte~) startProcessing::$31 << (byte) 1 -- vbuz1=vbuz2_rol_1 
-    lda.z __31
     asl
-    sta.z __32
-    // [50] (byte~) startProcessing::$33 ← (byte~) startProcessing::$32 + (byte) startProcessing::i#2 -- vbuz1=vbuz2_plus_vbuz3 
-    lda.z __32
+    sta.z __31
+    // [50] (byte~) startProcessing::$32 ← (byte~) startProcessing::$31 + (byte) startProcessing::i#2 -- vbuz1=vbuz2_plus_vbuz3 
+    lda.z __31
     clc
     adc.z i
-    sta.z __33
-    // [51] (byte~) startProcessing::$27 ← (byte~) startProcessing::$33 << (byte) 1 -- vbuz1=vbuz2_rol_1 
-    lda.z __33
+    sta.z __32
+    // [51] (byte~) startProcessing::$27 ← (byte~) startProcessing::$32 << (byte) 1 -- vbuz1=vbuz2_rol_1 
+    lda.z __32
     asl
     sta.z __27
     // [52] if(*((byte*)(const struct ProcessingSprite*) PROCESSING+(const byte) OFFSET_STRUCT_PROCESSINGSPRITE_STATUS + (byte~) startProcessing::$27)!=(const byte) STATUS_FREE) goto startProcessing::@3 -- pbuc1_derefidx_vbuz1_neq_vbuc2_then_la1 
@@ -5021,28 +5015,28 @@ startProcessing: {
     sta.z __0
     lda #0
     sta.z __0+1
-    // [56] (word~) startProcessing::$35 ← (word~) startProcessing::$0 << (byte) 2 -- vwuz1=vwuz2_rol_2 
+    // [56] (word~) startProcessing::$34 ← (word~) startProcessing::$0 << (byte) 2 -- vwuz1=vwuz2_rol_2 
     lda.z __0
     asl
-    sta.z __35
+    sta.z __34
     lda.z __0+1
     rol
-    sta.z __35+1
-    asl.z __35
-    rol.z __35+1
-    // [57] (word~) startProcessing::$36 ← (word~) startProcessing::$35 + (word~) startProcessing::$0 -- vwuz1=vwuz2_plus_vwuz3 
-    lda.z __35
+    sta.z __34+1
+    asl.z __34
+    rol.z __34+1
+    // [57] (word~) startProcessing::$35 ← (word~) startProcessing::$34 + (word~) startProcessing::$0 -- vwuz1=vwuz2_plus_vwuz3 
+    lda.z __34
     clc
     adc.z __0
-    sta.z __36
-    lda.z __35+1
+    sta.z __35
+    lda.z __34+1
     adc.z __0+1
-    sta.z __36+1
-    // [58] (word~) startProcessing::$1 ← (word~) startProcessing::$36 << (byte) 3 -- vwuz1=vwuz2_rol_3 
-    lda.z __36
+    sta.z __35+1
+    // [58] (word~) startProcessing::$1 ← (word~) startProcessing::$35 << (byte) 3 -- vwuz1=vwuz2_rol_3 
+    lda.z __35
     asl
     sta.z __1
-    lda.z __36+1
+    lda.z __35+1
     rol
     sta.z __1+1
     asl.z __1
@@ -5277,26 +5271,26 @@ startProcessing: {
     sta.z __21
     lda #0
     sta.z __21+1
-    // [91] (byte~) startProcessing::$38 ← (byte) startProcessing::freeIdx#2 << (byte) 1 -- vbuz1=vbuz2_rol_1 
+    // [91] (byte~) startProcessing::$37 ← (byte) startProcessing::freeIdx#2 << (byte) 1 -- vbuz1=vbuz2_rol_1 
     lda.z freeIdx
     asl
+    sta.z __37
+    // [92] (byte~) startProcessing::$38 ← (byte~) startProcessing::$37 + (byte) startProcessing::freeIdx#2 -- vbuz1=vbuz2_plus_vbuz3 
+    lda.z __37
+    clc
+    adc.z freeIdx
     sta.z __38
-    // [92] (byte~) startProcessing::$39 ← (byte~) startProcessing::$38 + (byte) startProcessing::freeIdx#2 -- vbuz1=vbuz2_plus_vbuz3 
+    // [93] (byte~) startProcessing::$39 ← (byte~) startProcessing::$38 << (byte) 1 -- vbuz1=vbuz2_rol_1 
     lda.z __38
-    clc
-    adc.z freeIdx
-    sta.z __39
-    // [93] (byte~) startProcessing::$40 ← (byte~) startProcessing::$39 << (byte) 1 -- vbuz1=vbuz2_rol_1 
-    lda.z __39
     asl
-    sta.z __40
-    // [94] (byte~) startProcessing::$41 ← (byte~) startProcessing::$40 + (byte) startProcessing::freeIdx#2 -- vbuz1=vbuz2_plus_vbuz3 
-    lda.z __40
+    sta.z __39
+    // [94] (byte~) startProcessing::$40 ← (byte~) startProcessing::$39 + (byte) startProcessing::freeIdx#2 -- vbuz1=vbuz2_plus_vbuz3 
+    lda.z __39
     clc
     adc.z freeIdx
-    sta.z __41
-    // [95] (byte~) startProcessing::$28 ← (byte~) startProcessing::$41 << (byte) 1 -- vbuz1=vbuz2_rol_1 
-    lda.z __41
+    sta.z __40
+    // [95] (byte~) startProcessing::$28 ← (byte~) startProcessing::$40 << (byte) 1 -- vbuz1=vbuz2_rol_1 
+    lda.z __40
     asl
     sta.z __28
     // [96] *((word*)(const struct ProcessingSprite*) PROCESSING + (byte~) startProcessing::$28) ← (word) startProcessing::spriteX#0 -- pwuc1_derefidx_vbuz1=vwuz2 
@@ -6817,20 +6811,20 @@ Removing always clobbered register reg byte y as potential for zp[1]:6 [ main::i
 Statement [22] if((byte) main::i#1!=(const byte) NUM_PROCESSING-(byte) 1+(byte) 1) goto main::@3 [ SCREEN_COPY#0 SCREEN_DIST#0 main::i#1 ] ( main:7 [ SCREEN_COPY#0 SCREEN_DIST#0 main::i#1 ] ) always clobbers reg byte a 
 Statement [36] *((const byte*) SCREEN+(word) $3e7) ← (byte) '.' [ ] ( main:7 [ ] ) always clobbers reg byte a 
 Statement [41] *((byte*) main::dst#2) ← *((byte*) main::src#2) [ SCREEN_COPY#0 SCREEN_DIST#0 main::src#2 main::dst#2 ] ( main:7 [ SCREEN_COPY#0 SCREEN_DIST#0 main::src#2 main::dst#2 ] ) always clobbers reg byte a reg byte y 
-Statement [47] (byte~) startProcessing::$30 ← (byte) startProcessing::i#2 << (byte) 1 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$30 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$30 ] ) always clobbers reg byte a 
+Statement [47] (byte~) startProcessing::$29 ← (byte) startProcessing::i#2 << (byte) 1 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$29 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$29 ] ) always clobbers reg byte a 
 Removing always clobbered register reg byte a as potential for zp[1]:69 [ startProcessing::center_x#0 ]
 Removing always clobbered register reg byte a as potential for zp[1]:70 [ startProcessing::center_y#0 ]
 Removing always clobbered register reg byte a as potential for zp[1]:7 [ startProcessing::freeIdx#6 startProcessing::freeIdx#7 ]
 Removing always clobbered register reg byte a as potential for zp[1]:8 [ startProcessing::freeIdx#2 startProcessing::freeIdx#8 startProcessing::i#2 startProcessing::i#1 ]
-Statement [48] (byte~) startProcessing::$31 ← (byte~) startProcessing::$30 + (byte) startProcessing::i#2 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$31 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$31 ] ) always clobbers reg byte a 
-Statement [49] (byte~) startProcessing::$32 ← (byte~) startProcessing::$31 << (byte) 1 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$32 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$32 ] ) always clobbers reg byte a 
-Statement [50] (byte~) startProcessing::$33 ← (byte~) startProcessing::$32 + (byte) startProcessing::i#2 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$33 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$33 ] ) always clobbers reg byte a 
-Statement [51] (byte~) startProcessing::$27 ← (byte~) startProcessing::$33 << (byte) 1 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$27 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$27 ] ) always clobbers reg byte a 
+Statement [48] (byte~) startProcessing::$30 ← (byte~) startProcessing::$29 + (byte) startProcessing::i#2 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$30 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$30 ] ) always clobbers reg byte a 
+Statement [49] (byte~) startProcessing::$31 ← (byte~) startProcessing::$30 << (byte) 1 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$31 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$31 ] ) always clobbers reg byte a 
+Statement [50] (byte~) startProcessing::$32 ← (byte~) startProcessing::$31 + (byte) startProcessing::i#2 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$32 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$32 ] ) always clobbers reg byte a 
+Statement [51] (byte~) startProcessing::$27 ← (byte~) startProcessing::$32 << (byte) 1 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$27 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$27 ] ) always clobbers reg byte a 
 Statement [52] if(*((byte*)(const struct ProcessingSprite*) PROCESSING+(const byte) OFFSET_STRUCT_PROCESSINGSPRITE_STATUS + (byte~) startProcessing::$27)!=(const byte) STATUS_FREE) goto startProcessing::@3 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 ] ) always clobbers reg byte a 
 Statement [55] (word~) startProcessing::$0 ← (word)(byte) startProcessing::center_y#0 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::$0 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::$0 ] ) always clobbers reg byte a 
-Statement [56] (word~) startProcessing::$35 ← (word~) startProcessing::$0 << (byte) 2 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::$0 startProcessing::$35 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::$0 startProcessing::$35 ] ) always clobbers reg byte a 
-Statement [57] (word~) startProcessing::$36 ← (word~) startProcessing::$35 + (word~) startProcessing::$0 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::$36 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::$36 ] ) always clobbers reg byte a 
-Statement [58] (word~) startProcessing::$1 ← (word~) startProcessing::$36 << (byte) 3 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::$1 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::$1 ] ) always clobbers reg byte a 
+Statement [56] (word~) startProcessing::$34 ← (word~) startProcessing::$0 << (byte) 2 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::$0 startProcessing::$34 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::$0 startProcessing::$34 ] ) always clobbers reg byte a 
+Statement [57] (word~) startProcessing::$35 ← (word~) startProcessing::$34 + (word~) startProcessing::$0 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::$35 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::$35 ] ) always clobbers reg byte a 
+Statement [58] (word~) startProcessing::$1 ← (word~) startProcessing::$35 << (byte) 3 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::$1 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::$1 ] ) always clobbers reg byte a 
 Statement [59] (word) startProcessing::offset#0 ← (word~) startProcessing::$1 + (byte) startProcessing::center_x#0 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::offset#0 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::offset#0 ] ) always clobbers reg byte a 
 Statement [60] (byte*) startProcessing::colPtr#0 ← (const byte*) COLS + (word) startProcessing::offset#0 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::offset#0 startProcessing::colPtr#0 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::offset#0 startProcessing::colPtr#0 ] ) always clobbers reg byte a 
 Statement [61] (byte) startProcessing::spriteCol#0 ← *((byte*) startProcessing::colPtr#0) [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::offset#0 startProcessing::spriteCol#0 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::offset#0 startProcessing::spriteCol#0 ] ) always clobbers reg byte a reg byte y 
@@ -6865,11 +6859,11 @@ Statement [88] (byte) startProcessing::spritePtr#0 ← (byte)(const byte*) SPRIT
 Statement [89] (byte~) startProcessing::$20 ← (byte) startProcessing::freeIdx#2 << (byte) 3 [ startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$20 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$20 ] ) always clobbers reg byte a 
 Removing always clobbered register reg byte a as potential for zp[1]:116 [ startProcessing::spritePtr#0 ]
 Statement [90] (word~) startProcessing::$21 ← (word)(byte~) startProcessing::$20 [ startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 ] ) always clobbers reg byte a 
-Statement [91] (byte~) startProcessing::$38 ← (byte) startProcessing::freeIdx#2 << (byte) 1 [ startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$38 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$38 ] ) always clobbers reg byte a 
-Statement [92] (byte~) startProcessing::$39 ← (byte~) startProcessing::$38 + (byte) startProcessing::freeIdx#2 [ startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$39 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$39 ] ) always clobbers reg byte a 
-Statement [93] (byte~) startProcessing::$40 ← (byte~) startProcessing::$39 << (byte) 1 [ startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$40 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$40 ] ) always clobbers reg byte a 
-Statement [94] (byte~) startProcessing::$41 ← (byte~) startProcessing::$40 + (byte) startProcessing::freeIdx#2 [ startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$41 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$41 ] ) always clobbers reg byte a 
-Statement [95] (byte~) startProcessing::$28 ← (byte~) startProcessing::$41 << (byte) 1 [ startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$28 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$28 ] ) always clobbers reg byte a 
+Statement [91] (byte~) startProcessing::$37 ← (byte) startProcessing::freeIdx#2 << (byte) 1 [ startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$37 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$37 ] ) always clobbers reg byte a 
+Statement [92] (byte~) startProcessing::$38 ← (byte~) startProcessing::$37 + (byte) startProcessing::freeIdx#2 [ startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$38 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$38 ] ) always clobbers reg byte a 
+Statement [93] (byte~) startProcessing::$39 ← (byte~) startProcessing::$38 << (byte) 1 [ startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$39 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$39 ] ) always clobbers reg byte a 
+Statement [94] (byte~) startProcessing::$40 ← (byte~) startProcessing::$39 + (byte) startProcessing::freeIdx#2 [ startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$40 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$40 ] ) always clobbers reg byte a 
+Statement [95] (byte~) startProcessing::$28 ← (byte~) startProcessing::$40 << (byte) 1 [ startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$28 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$28 ] ) always clobbers reg byte a 
 Statement [96] *((word*)(const struct ProcessingSprite*) PROCESSING + (byte~) startProcessing::$28) ← (word) startProcessing::spriteX#0 [ startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$28 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$28 ] ) always clobbers reg byte a 
 Removing always clobbered register reg byte a as potential for zp[1]:124 [ startProcessing::$28 ]
 Statement [97] *((word*)(const struct ProcessingSprite*) PROCESSING+(const byte) OFFSET_STRUCT_PROCESSINGSPRITE_Y + (byte~) startProcessing::$28) ← (word) startProcessing::spriteY#0 [ startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$28 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$28 ] ) always clobbers reg byte a 
@@ -7048,16 +7042,16 @@ Statement [20] *((const struct ProcessingSprite*) PROCESSING + (byte~) main::$10
 Statement [22] if((byte) main::i#1!=(const byte) NUM_PROCESSING-(byte) 1+(byte) 1) goto main::@3 [ SCREEN_COPY#0 SCREEN_DIST#0 main::i#1 ] ( main:7 [ SCREEN_COPY#0 SCREEN_DIST#0 main::i#1 ] ) always clobbers reg byte a 
 Statement [36] *((const byte*) SCREEN+(word) $3e7) ← (byte) '.' [ ] ( main:7 [ ] ) always clobbers reg byte a 
 Statement [41] *((byte*) main::dst#2) ← *((byte*) main::src#2) [ SCREEN_COPY#0 SCREEN_DIST#0 main::src#2 main::dst#2 ] ( main:7 [ SCREEN_COPY#0 SCREEN_DIST#0 main::src#2 main::dst#2 ] ) always clobbers reg byte a reg byte y 
-Statement [47] (byte~) startProcessing::$30 ← (byte) startProcessing::i#2 << (byte) 1 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$30 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$30 ] ) always clobbers reg byte a 
-Statement [48] (byte~) startProcessing::$31 ← (byte~) startProcessing::$30 + (byte) startProcessing::i#2 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$31 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$31 ] ) always clobbers reg byte a 
-Statement [49] (byte~) startProcessing::$32 ← (byte~) startProcessing::$31 << (byte) 1 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$32 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$32 ] ) always clobbers reg byte a 
-Statement [50] (byte~) startProcessing::$33 ← (byte~) startProcessing::$32 + (byte) startProcessing::i#2 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$33 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$33 ] ) always clobbers reg byte a 
-Statement [51] (byte~) startProcessing::$27 ← (byte~) startProcessing::$33 << (byte) 1 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$27 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$27 ] ) always clobbers reg byte a 
+Statement [47] (byte~) startProcessing::$29 ← (byte) startProcessing::i#2 << (byte) 1 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$29 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$29 ] ) always clobbers reg byte a 
+Statement [48] (byte~) startProcessing::$30 ← (byte~) startProcessing::$29 + (byte) startProcessing::i#2 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$30 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$30 ] ) always clobbers reg byte a 
+Statement [49] (byte~) startProcessing::$31 ← (byte~) startProcessing::$30 << (byte) 1 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$31 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$31 ] ) always clobbers reg byte a 
+Statement [50] (byte~) startProcessing::$32 ← (byte~) startProcessing::$31 + (byte) startProcessing::i#2 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$32 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$32 ] ) always clobbers reg byte a 
+Statement [51] (byte~) startProcessing::$27 ← (byte~) startProcessing::$32 << (byte) 1 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$27 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 startProcessing::$27 ] ) always clobbers reg byte a 
 Statement [52] if(*((byte*)(const struct ProcessingSprite*) PROCESSING+(const byte) OFFSET_STRUCT_PROCESSINGSPRITE_STATUS + (byte~) startProcessing::$27)!=(const byte) STATUS_FREE) goto startProcessing::@3 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#6 startProcessing::i#2 ] ) always clobbers reg byte a 
 Statement [55] (word~) startProcessing::$0 ← (word)(byte) startProcessing::center_y#0 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::$0 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::$0 ] ) always clobbers reg byte a 
-Statement [56] (word~) startProcessing::$35 ← (word~) startProcessing::$0 << (byte) 2 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::$0 startProcessing::$35 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::$0 startProcessing::$35 ] ) always clobbers reg byte a 
-Statement [57] (word~) startProcessing::$36 ← (word~) startProcessing::$35 + (word~) startProcessing::$0 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::$36 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::$36 ] ) always clobbers reg byte a 
-Statement [58] (word~) startProcessing::$1 ← (word~) startProcessing::$36 << (byte) 3 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::$1 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::$1 ] ) always clobbers reg byte a 
+Statement [56] (word~) startProcessing::$34 ← (word~) startProcessing::$0 << (byte) 2 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::$0 startProcessing::$34 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::$0 startProcessing::$34 ] ) always clobbers reg byte a 
+Statement [57] (word~) startProcessing::$35 ← (word~) startProcessing::$34 + (word~) startProcessing::$0 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::$35 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::$35 ] ) always clobbers reg byte a 
+Statement [58] (word~) startProcessing::$1 ← (word~) startProcessing::$35 << (byte) 3 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::$1 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::$1 ] ) always clobbers reg byte a 
 Statement [59] (word) startProcessing::offset#0 ← (word~) startProcessing::$1 + (byte) startProcessing::center_x#0 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::offset#0 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::offset#0 ] ) always clobbers reg byte a 
 Statement [60] (byte*) startProcessing::colPtr#0 ← (const byte*) COLS + (word) startProcessing::offset#0 [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::offset#0 startProcessing::colPtr#0 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::offset#0 startProcessing::colPtr#0 ] ) always clobbers reg byte a 
 Statement [61] (byte) startProcessing::spriteCol#0 ← *((byte*) startProcessing::colPtr#0) [ startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::offset#0 startProcessing::spriteCol#0 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::center_x#0 startProcessing::center_y#0 startProcessing::freeIdx#2 startProcessing::offset#0 startProcessing::spriteCol#0 ] ) always clobbers reg byte a reg byte y 
@@ -7084,11 +7078,11 @@ Statement [87] (word) startProcessing::spriteY#0 ← (word~) startProcessing::$1
 Statement [88] (byte) startProcessing::spritePtr#0 ← (byte)(const byte*) SPRITE_DATA/(byte) $40 + (byte) startProcessing::freeIdx#2 [ startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 ] ) always clobbers reg byte a 
 Statement [89] (byte~) startProcessing::$20 ← (byte) startProcessing::freeIdx#2 << (byte) 3 [ startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$20 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$20 ] ) always clobbers reg byte a 
 Statement [90] (word~) startProcessing::$21 ← (word)(byte~) startProcessing::$20 [ startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 ] ) always clobbers reg byte a 
-Statement [91] (byte~) startProcessing::$38 ← (byte) startProcessing::freeIdx#2 << (byte) 1 [ startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$38 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$38 ] ) always clobbers reg byte a 
-Statement [92] (byte~) startProcessing::$39 ← (byte~) startProcessing::$38 + (byte) startProcessing::freeIdx#2 [ startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$39 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$39 ] ) always clobbers reg byte a 
-Statement [93] (byte~) startProcessing::$40 ← (byte~) startProcessing::$39 << (byte) 1 [ startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$40 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$40 ] ) always clobbers reg byte a 
-Statement [94] (byte~) startProcessing::$41 ← (byte~) startProcessing::$40 + (byte) startProcessing::freeIdx#2 [ startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$41 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$41 ] ) always clobbers reg byte a 
-Statement [95] (byte~) startProcessing::$28 ← (byte~) startProcessing::$41 << (byte) 1 [ startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$28 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$28 ] ) always clobbers reg byte a 
+Statement [91] (byte~) startProcessing::$37 ← (byte) startProcessing::freeIdx#2 << (byte) 1 [ startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$37 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$37 ] ) always clobbers reg byte a 
+Statement [92] (byte~) startProcessing::$38 ← (byte~) startProcessing::$37 + (byte) startProcessing::freeIdx#2 [ startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$38 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$38 ] ) always clobbers reg byte a 
+Statement [93] (byte~) startProcessing::$39 ← (byte~) startProcessing::$38 << (byte) 1 [ startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$39 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$39 ] ) always clobbers reg byte a 
+Statement [94] (byte~) startProcessing::$40 ← (byte~) startProcessing::$39 + (byte) startProcessing::freeIdx#2 [ startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$40 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$40 ] ) always clobbers reg byte a 
+Statement [95] (byte~) startProcessing::$28 ← (byte~) startProcessing::$40 << (byte) 1 [ startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$28 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteX#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$28 ] ) always clobbers reg byte a 
 Statement [96] *((word*)(const struct ProcessingSprite*) PROCESSING + (byte~) startProcessing::$28) ← (word) startProcessing::spriteX#0 [ startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$28 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spriteY#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$28 ] ) always clobbers reg byte a 
 Statement [97] *((word*)(const struct ProcessingSprite*) PROCESSING+(const byte) OFFSET_STRUCT_PROCESSINGSPRITE_Y + (byte~) startProcessing::$28) ← (word) startProcessing::spriteY#0 [ startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$28 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spritePtr#0 startProcessing::$21 startProcessing::$28 ] ) always clobbers reg byte a 
 Statement [98] *((word*)(const struct ProcessingSprite*) PROCESSING+(const byte) OFFSET_STRUCT_PROCESSINGSPRITE_VX + (byte~) startProcessing::$28) ← (word~) startProcessing::$21 [ startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spritePtr#0 startProcessing::$28 ] ( main:7::startProcessing:40 [ SCREEN_COPY#0 SCREEN_DIST#0 startProcessing::freeIdx#2 startProcessing::spriteCol#0 startProcessing::screenPtr#0 startProcessing::spritePtr#0 startProcessing::$28 ] ) always clobbers reg byte a 
@@ -7273,14 +7267,14 @@ Potential registers zp[1]:67 [ main::center_y#0 ] : zp[1]:67 , reg byte a , reg
 Potential registers zp[1]:68 [ main::center_dist#0 ] : zp[1]:68 , reg byte a , reg byte x , reg byte y , 
 Potential registers zp[1]:69 [ startProcessing::center_x#0 ] : zp[1]:69 , reg byte x , 
 Potential registers zp[1]:70 [ startProcessing::center_y#0 ] : zp[1]:70 , reg byte x , 
-Potential registers zp[1]:71 [ startProcessing::$30 ] : zp[1]:71 , reg byte a , reg byte x , reg byte y , 
-Potential registers zp[1]:72 [ startProcessing::$31 ] : zp[1]:72 , reg byte a , reg byte x , reg byte y , 
-Potential registers zp[1]:73 [ startProcessing::$32 ] : zp[1]:73 , reg byte a , reg byte x , reg byte y , 
-Potential registers zp[1]:74 [ startProcessing::$33 ] : zp[1]:74 , reg byte a , reg byte x , reg byte y , 
+Potential registers zp[1]:71 [ startProcessing::$29 ] : zp[1]:71 , reg byte a , reg byte x , reg byte y , 
+Potential registers zp[1]:72 [ startProcessing::$30 ] : zp[1]:72 , reg byte a , reg byte x , reg byte y , 
+Potential registers zp[1]:73 [ startProcessing::$31 ] : zp[1]:73 , reg byte a , reg byte x , reg byte y , 
+Potential registers zp[1]:74 [ startProcessing::$32 ] : zp[1]:74 , reg byte a , reg byte x , reg byte y , 
 Potential registers zp[1]:75 [ startProcessing::$27 ] : zp[1]:75 , reg byte a , reg byte x , reg byte y , 
 Potential registers zp[2]:76 [ startProcessing::$0 ] : zp[2]:76 , 
-Potential registers zp[2]:78 [ startProcessing::$35 ] : zp[2]:78 , 
-Potential registers zp[2]:80 [ startProcessing::$36 ] : zp[2]:80 , 
+Potential registers zp[2]:78 [ startProcessing::$34 ] : zp[2]:78 , 
+Potential registers zp[2]:80 [ startProcessing::$35 ] : zp[2]:80 , 
 Potential registers zp[2]:82 [ startProcessing::$1 ] : zp[2]:82 , 
 Potential registers zp[2]:84 [ startProcessing::offset#0 ] : zp[2]:84 , 
 Potential registers zp[2]:86 [ startProcessing::colPtr#0 ] : zp[2]:86 , 
@@ -7302,10 +7296,10 @@ Potential registers zp[2]:114 [ startProcessing::spriteY#0 ] : zp[2]:114 ,
 Potential registers zp[1]:116 [ startProcessing::spritePtr#0 ] : zp[1]:116 , reg byte x , reg byte y , 
 Potential registers zp[1]:117 [ startProcessing::$20 ] : zp[1]:117 , reg byte a , reg byte x , reg byte y , 
 Potential registers zp[2]:118 [ startProcessing::$21 ] : zp[2]:118 , 
-Potential registers zp[1]:120 [ startProcessing::$38 ] : zp[1]:120 , reg byte a , reg byte x , reg byte y , 
-Potential registers zp[1]:121 [ startProcessing::$39 ] : zp[1]:121 , reg byte a , reg byte x , reg byte y , 
-Potential registers zp[1]:122 [ startProcessing::$40 ] : zp[1]:122 , reg byte a , reg byte x , reg byte y , 
-Potential registers zp[1]:123 [ startProcessing::$41 ] : zp[1]:123 , reg byte a , reg byte x , reg byte y , 
+Potential registers zp[1]:120 [ startProcessing::$37 ] : zp[1]:120 , reg byte a , reg byte x , reg byte y , 
+Potential registers zp[1]:121 [ startProcessing::$38 ] : zp[1]:121 , reg byte a , reg byte x , reg byte y , 
+Potential registers zp[1]:122 [ startProcessing::$39 ] : zp[1]:122 , reg byte a , reg byte x , reg byte y , 
+Potential registers zp[1]:123 [ startProcessing::$40 ] : zp[1]:123 , reg byte a , reg byte x , reg byte y , 
 Potential registers zp[1]:124 [ startProcessing::$28 ] : zp[1]:124 , reg byte x , reg byte y , 
 Potential registers zp[2]:125 [ getCharToProcess::$8 ] : zp[2]:125 , 
 Potential registers zp[2]:127 [ getCharToProcess::$12 ] : zp[2]:127 , 
@@ -7355,7 +7349,7 @@ Potential registers zp[1]:185 [ processChars::$29 ] : zp[1]:185 , reg byte a , r
 REGISTER UPLIFT SCOPES
 Uplift Scope [atan2_16] 28,670.58: zp[1]:43 [ atan2_16::shift#2 atan2_16::shift#5 atan2_16::shift#1 ] 20,608: zp[2]:44 [ atan2_16::yd#5 atan2_16::yd#3 atan2_16::yd#10 atan2_16::yd#1 atan2_16::yd#2 ] 17,338.67: zp[2]:46 [ atan2_16::xd#5 atan2_16::xd#3 atan2_16::xd#10 atan2_16::xd#1 atan2_16::xd#2 ] 7,533.33: zp[2]:39 [ atan2_16::angle#6 atan2_16::angle#12 atan2_16::angle#13 atan2_16::angle#2 atan2_16::angle#3 ] 2,698.28: zp[2]:34 [ atan2_16::yi#3 atan2_16::yi#8 atan2_16::yi#0 atan2_16::yi#16 atan2_16::$2 atan2_16::yi#1 atan2_16::yi#2 ] 2,283.07: zp[2]:36 [ atan2_16::xi#3 atan2_16::xi#8 atan2_16::xi#0 atan2_16::xi#13 atan2_16::$7 atan2_16::xi#1 atan2_16::xi#2 ] 2,002: zp[1]:156 [ atan2_16::$23 ] 2,002: zp[1]:157 [ atan2_16::$22 ] 1,710.04: zp[1]:38 [ atan2_16::i#2 atan2_16::i#1 ] 202: zp[2]:146 [ atan2_16::return#2 ] 50: zp[2]:41 [ atan2_16::return#0 atan2_16::angle#5 atan2_16::angle#11 atan2_16::angle#1 atan2_16::angle#4 ] 2.87: zp[2]:142 [ atan2_16::x#0 ] 2.72: zp[2]:144 [ atan2_16::y#0 ] 
 Uplift Scope [getCharToProcess] 4,983.53: zp[1]:23 [ getCharToProcess::return_dist#1 getCharToProcess::return_dist#5 getCharToProcess::return_dist#6 getCharToProcess::dist#0 ] 3,432.25: zp[1]:20 [ getCharToProcess::closest_dist#2 getCharToProcess::closest_dist#8 getCharToProcess::closest_dist#10 getCharToProcess::closest_dist#12 ] 2,937.96: zp[1]:22 [ getCharToProcess::closest_y#7 getCharToProcess::closest_y#9 getCharToProcess::return_y#1 getCharToProcess::return_y#7 ] 1,949.11: zp[1]:21 [ getCharToProcess::closest_x#7 getCharToProcess::closest_x#9 getCharToProcess::return_x#1 getCharToProcess::return_x#7 ] 1,557.11: zp[1]:19 [ getCharToProcess::x#2 getCharToProcess::x#1 ] 181.2: zp[1]:18 [ getCharToProcess::y#7 getCharToProcess::y#1 ] 140.57: zp[2]:16 [ getCharToProcess::dist_line#6 getCharToProcess::dist_line#0 getCharToProcess::dist_line#1 ] 135.09: zp[2]:14 [ getCharToProcess::screen_line#4 getCharToProcess::screen_line#0 getCharToProcess::screen_line#1 ] 7.33: zp[1]:63 [ getCharToProcess::return_x#0 ] 7.33: zp[1]:64 [ getCharToProcess::return_y#0 ] 7.33: zp[1]:65 [ getCharToProcess::return_dist#0 ] 4: zp[2]:127 [ getCharToProcess::$12 ] 4: zp[2]:129 [ getCharToProcess::$13 ] 4: zp[2]:131 [ getCharToProcess::$9 ] 4: zp[2]:133 [ getCharToProcess::$10 ] 3: zp[2]:125 [ getCharToProcess::$8 ] 
-Uplift Scope [startProcessing] 2,589.5: zp[1]:8 [ startProcessing::freeIdx#2 startProcessing::freeIdx#8 startProcessing::i#2 startProcessing::i#1 ] 2,002: zp[1]:71 [ startProcessing::$30 ] 2,002: zp[1]:72 [ startProcessing::$31 ] 2,002: zp[1]:73 [ startProcessing::$32 ] 2,002: zp[1]:74 [ startProcessing::$33 ] 2,002: zp[1]:75 [ startProcessing::$27 ] 222.2: zp[1]:7 [ startProcessing::freeIdx#6 startProcessing::freeIdx#7 ] 203.57: zp[2]:11 [ startProcessing::spriteData#2 startProcessing::spriteData#0 startProcessing::spriteData#1 ] 202: zp[1]:13 [ startProcessing::i1#2 startProcessing::i1#1 ] 170.33: zp[2]:9 [ startProcessing::chargenData#2 startProcessing::chargenData#0 startProcessing::chargenData#1 ] 4: zp[2]:78 [ startProcessing::$35 ] 4: zp[2]:80 [ startProcessing::$36 ] 4: zp[2]:82 [ startProcessing::$1 ] 4: zp[2]:86 [ startProcessing::colPtr#0 ] 4: zp[2]:91 [ startProcessing::$5 ] 4: zp[2]:93 [ startProcessing::$6 ] 4: zp[2]:96 [ startProcessing::$8 ] 4: zp[2]:98 [ startProcessing::$9 ] 4: zp[2]:100 [ startProcessing::$11 ] 4: zp[2]:102 [ startProcessing::$12 ] 4: zp[2]:104 [ startProcessing::$13 ] 4: zp[2]:108 [ startProcessing::$15 ] 4: zp[2]:110 [ startProcessing::$16 ] 4: zp[2]:112 [ startProcessing::$17 ] 4: zp[1]:120 [ startProcessing::$38 ] 4: zp[1]:121 [ startProcessing::$39 ] 4: zp[1]:122 [ startProcessing::$40 ] 4: zp[1]:123 [ startProcessing::$41 ] 3: zp[2]:76 [ startProcessing::$0 ] 2.22: zp[1]:124 [ startProcessing::$28 ] 2: zp[2]:84 [ startProcessing::offset#0 ] 2: zp[1]:95 [ startProcessing::ch#0 ] 2: zp[1]:117 [ startProcessing::$20 ] 0.5: zp[2]:118 [ startProcessing::$21 ] 0.4: zp[2]:114 [ startProcessing::spriteY#0 ] 0.31: zp[1]:69 [ startProcessing::center_x#0 ] 0.31: zp[2]:106 [ startProcessing::spriteX#0 ] 0.31: zp[1]:116 [ startProcessing::spritePtr#0 ] 0.24: zp[1]:70 [ startProcessing::center_y#0 ] 0.14: zp[2]:89 [ startProcessing::screenPtr#0 ] 0.1: zp[1]:88 [ startProcessing::spriteCol#0 ] 
+Uplift Scope [startProcessing] 2,589.5: zp[1]:8 [ startProcessing::freeIdx#2 startProcessing::freeIdx#8 startProcessing::i#2 startProcessing::i#1 ] 2,002: zp[1]:71 [ startProcessing::$29 ] 2,002: zp[1]:72 [ startProcessing::$30 ] 2,002: zp[1]:73 [ startProcessing::$31 ] 2,002: zp[1]:74 [ startProcessing::$32 ] 2,002: zp[1]:75 [ startProcessing::$27 ] 222.2: zp[1]:7 [ startProcessing::freeIdx#6 startProcessing::freeIdx#7 ] 203.57: zp[2]:11 [ startProcessing::spriteData#2 startProcessing::spriteData#0 startProcessing::spriteData#1 ] 202: zp[1]:13 [ startProcessing::i1#2 startProcessing::i1#1 ] 170.33: zp[2]:9 [ startProcessing::chargenData#2 startProcessing::chargenData#0 startProcessing::chargenData#1 ] 4: zp[2]:78 [ startProcessing::$34 ] 4: zp[2]:80 [ startProcessing::$35 ] 4: zp[2]:82 [ startProcessing::$1 ] 4: zp[2]:86 [ startProcessing::colPtr#0 ] 4: zp[2]:91 [ startProcessing::$5 ] 4: zp[2]:93 [ startProcessing::$6 ] 4: zp[2]:96 [ startProcessing::$8 ] 4: zp[2]:98 [ startProcessing::$9 ] 4: zp[2]:100 [ startProcessing::$11 ] 4: zp[2]:102 [ startProcessing::$12 ] 4: zp[2]:104 [ startProcessing::$13 ] 4: zp[2]:108 [ startProcessing::$15 ] 4: zp[2]:110 [ startProcessing::$16 ] 4: zp[2]:112 [ startProcessing::$17 ] 4: zp[1]:120 [ startProcessing::$37 ] 4: zp[1]:121 [ startProcessing::$38 ] 4: zp[1]:122 [ startProcessing::$39 ] 4: zp[1]:123 [ startProcessing::$40 ] 3: zp[2]:76 [ startProcessing::$0 ] 2.22: zp[1]:124 [ startProcessing::$28 ] 2: zp[2]:84 [ startProcessing::offset#0 ] 2: zp[1]:95 [ startProcessing::ch#0 ] 2: zp[1]:117 [ startProcessing::$20 ] 0.5: zp[2]:118 [ startProcessing::$21 ] 0.4: zp[2]:114 [ startProcessing::spriteY#0 ] 0.31: zp[1]:69 [ startProcessing::center_x#0 ] 0.31: zp[2]:106 [ startProcessing::spriteX#0 ] 0.31: zp[1]:116 [ startProcessing::spritePtr#0 ] 0.24: zp[1]:70 [ startProcessing::center_y#0 ] 0.14: zp[2]:89 [ startProcessing::screenPtr#0 ] 0.1: zp[1]:88 [ startProcessing::spriteCol#0 ] 
 Uplift Scope [init_angle_screen] 220.36: zp[1]:33 [ init_angle_screen::xb#2 init_angle_screen::xb#1 ] 202: zp[1]:135 [ init_angle_screen::$3 ] 202: zp[1]:136 [ init_angle_screen::$4 ] 202: zp[1]:139 [ init_angle_screen::$7 ] 202: zp[2]:148 [ init_angle_screen::angle_w#0 ] 202: zp[2]:150 [ init_angle_screen::$11 ] 202: zp[1]:153 [ init_angle_screen::$13 ] 202: zp[1]:154 [ init_angle_screen::$14 ] 202: zp[1]:155 [ init_angle_screen::$15 ] 129.86: zp[1]:32 [ init_angle_screen::x#2 init_angle_screen::x#1 ] 84.17: zp[1]:152 [ init_angle_screen::ang_w#0 ] 50.5: zp[2]:140 [ init_angle_screen::yw#0 ] 33.67: zp[2]:137 [ init_angle_screen::xw#0 ] 21.23: zp[1]:27 [ init_angle_screen::y#5 init_angle_screen::y#1 ] 20.37: zp[2]:30 [ init_angle_screen::screen_bottomline#6 init_angle_screen::screen_bottomline#0 init_angle_screen::screen_bottomline#1 ] 16.92: zp[2]:28 [ init_angle_screen::screen_topline#6 init_angle_screen::screen_topline#0 init_angle_screen::screen_topline#1 ] 3: zp[2]:56 [ init_angle_screen::screen#0 ] 
 Uplift Scope [processChars] 33.73: zp[1]:51 [ processChars::numActive#10 processChars::numActive#3 processChars::numActive#1 ] 22: zp[1]:160 [ processChars::$62 ] 22: zp[1]:161 [ processChars::$63 ] 22: zp[1]:162 [ processChars::$64 ] 22: zp[1]:163 [ processChars::$65 ] 22: zp[1]:164 [ processChars::$32 ] 22: zp[1]:170 [ processChars::$9 ] 22: zp[1]:171 [ processChars::$10 ] 22: zp[1]:173 [ processChars::$12 ] 22: zp[1]:179 [ processChars::$24 ] 22: zp[1]:180 [ processChars::xchar#0 ] 22: zp[1]:181 [ processChars::$33 ] 22: zp[1]:182 [ processChars::$27 ] 22: zp[1]:183 [ processChars::ychar#0 ] 22: zp[1]:184 [ processChars::$34 ] 22: zp[1]:185 [ processChars::$29 ] 17.9: zp[1]:50 [ processChars::i#10 processChars::i#1 ] 11: zp[2]:174 [ processChars::$13 ] 11: zp[2]:177 [ processChars::$23 ] 6.6: zp[1]:172 [ processChars::$15 ] 2.75: zp[1]:176 [ processChars::ypos#0 ] 2.2: zp[1]:167 [ processChars::bitmask#0 ] 2.06: zp[2]:168 [ processChars::xpos#0 ] 0.31: zp[2]:165 [ processChars::processing#0 ] 
 Uplift Scope [main] 34.75: zp[2]:4 [ main::dst#2 main::dst#0 main::dst#1 ] 25.67: zp[2]:2 [ main::src#2 main::src#1 ] 24.36: zp[1]:6 [ main::i#2 main::i#1 ] 22: zp[1]:58 [ main::$11 ] 22: zp[1]:59 [ main::$12 ] 22: zp[1]:60 [ main::$13 ] 22: zp[1]:61 [ main::$14 ] 22: zp[1]:62 [ main::$10 ] 22: zp[1]:68 [ main::center_dist#0 ] 5.5: zp[1]:66 [ main::center_x#0 ] 5.5: zp[1]:67 [ main::center_y#0 ] 
@@ -7394,14 +7388,14 @@ Attempting to uplift remaining variables inzp[1]:22 [ getCharToProcess::closest_
 Uplifting [getCharToProcess] best 1263819 combination zp[1]:22 [ getCharToProcess::closest_y#7 getCharToProcess::closest_y#9 getCharToProcess::return_y#1 getCharToProcess::return_y#7 ] 
 Attempting to uplift remaining variables inzp[1]:8 [ startProcessing::freeIdx#2 startProcessing::freeIdx#8 startProcessing::i#2 startProcessing::i#1 ]
 Uplifting [startProcessing] best 1263819 combination zp[1]:8 [ startProcessing::freeIdx#2 startProcessing::freeIdx#8 startProcessing::i#2 startProcessing::i#1 ] 
-Attempting to uplift remaining variables inzp[1]:71 [ startProcessing::$30 ]
-Uplifting [startProcessing] best 1257819 combination reg byte a [ startProcessing::$30 ] 
-Attempting to uplift remaining variables inzp[1]:72 [ startProcessing::$31 ]
-Uplifting [startProcessing] best 1251819 combination reg byte a [ startProcessing::$31 ] 
-Attempting to uplift remaining variables inzp[1]:73 [ startProcessing::$32 ]
-Uplifting [startProcessing] best 1245819 combination reg byte a [ startProcessing::$32 ] 
-Attempting to uplift remaining variables inzp[1]:74 [ startProcessing::$33 ]
-Uplifting [startProcessing] best 1239819 combination reg byte a [ startProcessing::$33 ] 
+Attempting to uplift remaining variables inzp[1]:71 [ startProcessing::$29 ]
+Uplifting [startProcessing] best 1257819 combination reg byte a [ startProcessing::$29 ] 
+Attempting to uplift remaining variables inzp[1]:72 [ startProcessing::$30 ]
+Uplifting [startProcessing] best 1251819 combination reg byte a [ startProcessing::$30 ] 
+Attempting to uplift remaining variables inzp[1]:73 [ startProcessing::$31 ]
+Uplifting [startProcessing] best 1245819 combination reg byte a [ startProcessing::$31 ] 
+Attempting to uplift remaining variables inzp[1]:74 [ startProcessing::$32 ]
+Uplifting [startProcessing] best 1239819 combination reg byte a [ startProcessing::$32 ] 
 Attempting to uplift remaining variables inzp[1]:75 [ startProcessing::$27 ]
 Uplifting [startProcessing] best 1235819 combination reg byte a [ startProcessing::$27 ] 
 Attempting to uplift remaining variables inzp[1]:21 [ getCharToProcess::closest_x#7 getCharToProcess::closest_x#9 getCharToProcess::return_x#1 getCharToProcess::return_x#7 ]
@@ -7480,14 +7474,14 @@ Attempting to uplift remaining variables inzp[1]:66 [ main::center_x#0 ]
 Uplifting [main] best 1213209 combination reg byte y [ main::center_x#0 ] 
 Attempting to uplift remaining variables inzp[1]:67 [ main::center_y#0 ]
 Uplifting [main] best 1213209 combination zp[1]:67 [ main::center_y#0 ] 
-Attempting to uplift remaining variables inzp[1]:120 [ startProcessing::$38 ]
-Uplifting [startProcessing] best 1213203 combination reg byte a [ startProcessing::$38 ] 
-Attempting to uplift remaining variables inzp[1]:121 [ startProcessing::$39 ]
-Uplifting [startProcessing] best 1213197 combination reg byte a [ startProcessing::$39 ] 
-Attempting to uplift remaining variables inzp[1]:122 [ startProcessing::$40 ]
-Uplifting [startProcessing] best 1213191 combination reg byte a [ startProcessing::$40 ] 
-Attempting to uplift remaining variables inzp[1]:123 [ startProcessing::$41 ]
-Uplifting [startProcessing] best 1213185 combination reg byte a [ startProcessing::$41 ] 
+Attempting to uplift remaining variables inzp[1]:120 [ startProcessing::$37 ]
+Uplifting [startProcessing] best 1213203 combination reg byte a [ startProcessing::$37 ] 
+Attempting to uplift remaining variables inzp[1]:121 [ startProcessing::$38 ]
+Uplifting [startProcessing] best 1213197 combination reg byte a [ startProcessing::$38 ] 
+Attempting to uplift remaining variables inzp[1]:122 [ startProcessing::$39 ]
+Uplifting [startProcessing] best 1213191 combination reg byte a [ startProcessing::$39 ] 
+Attempting to uplift remaining variables inzp[1]:123 [ startProcessing::$40 ]
+Uplifting [startProcessing] best 1213185 combination reg byte a [ startProcessing::$40 ] 
 Attempting to uplift remaining variables inzp[1]:176 [ processChars::ypos#0 ]
 Uplifting [processChars] best 1213185 combination zp[1]:176 [ processChars::ypos#0 ] 
 Attempting to uplift remaining variables inzp[1]:124 [ startProcessing::$28 ]
@@ -7512,7 +7506,7 @@ Coalescing zero page register [ zp[2]:30 [ init_angle_screen::screen_bottomline#
 Coalescing zero page register [ zp[2]:39 [ atan2_16::angle#6 atan2_16::angle#12 atan2_16::angle#13 atan2_16::angle#2 atan2_16::angle#3 ] ] with [ zp[2]:41 [ atan2_16::return#0 atan2_16::angle#5 atan2_16::angle#11 atan2_16::angle#1 atan2_16::angle#4 ] ] - score: 1
 Coalescing zero page register [ zp[2]:54 [ SCREEN_DIST#0 ] ] with [ zp[2]:158 [ malloc::mem#0 ] ] - score: 1
 Coalescing zero page register [ zp[1]:67 [ main::center_y#0 ] ] with [ zp[1]:70 [ startProcessing::center_y#0 ] ] - score: 1
-Coalescing zero page register [ zp[2]:76 [ startProcessing::$0 ] ] with [ zp[2]:80 [ startProcessing::$36 ] ] - score: 1
+Coalescing zero page register [ zp[2]:76 [ startProcessing::$0 ] ] with [ zp[2]:80 [ startProcessing::$35 ] ] - score: 1
 Coalescing zero page register [ zp[2]:82 [ startProcessing::$1 ] ] with [ zp[2]:84 [ startProcessing::offset#0 ] ] - score: 1
 Coalescing zero page register [ zp[2]:100 [ startProcessing::$11 ] ] with [ zp[2]:102 [ startProcessing::$12 ] ] - score: 1
 Coalescing zero page register [ zp[2]:104 [ startProcessing::$13 ] ] with [ zp[2]:106 [ startProcessing::spriteX#0 ] ] - score: 1
@@ -7527,12 +7521,12 @@ Coalescing zero page register [ zp[2]:168 [ processChars::xpos#0 ] ] with [ zp[2
 Coalescing zero page register [ zp[2]:9 [ startProcessing::chargenData#2 startProcessing::chargenData#0 startProcessing::chargenData#1 startProcessing::$9 ] ] with [ zp[2]:96 [ startProcessing::$8 ] ] - score: 1
 Coalescing zero page register [ zp[2]:11 [ startProcessing::spriteData#2 startProcessing::spriteData#0 startProcessing::spriteData#1 startProcessing::$6 ] ] with [ zp[2]:91 [ startProcessing::$5 ] ] - score: 1
 Coalescing zero page register [ zp[2]:39 [ atan2_16::angle#6 atan2_16::angle#12 atan2_16::angle#13 atan2_16::angle#2 atan2_16::angle#3 atan2_16::return#0 atan2_16::angle#5 atan2_16::angle#11 atan2_16::angle#1 atan2_16::angle#4 ] ] with [ zp[2]:146 [ atan2_16::return#2 init_angle_screen::angle_w#0 ] ] - score: 1
-Coalescing zero page register [ zp[2]:76 [ startProcessing::$0 startProcessing::$36 ] ] with [ zp[2]:82 [ startProcessing::$1 startProcessing::offset#0 ] ] - score: 1
+Coalescing zero page register [ zp[2]:76 [ startProcessing::$0 startProcessing::$35 ] ] with [ zp[2]:82 [ startProcessing::$1 startProcessing::offset#0 ] ] - score: 1
 Coalescing zero page register [ zp[2]:100 [ startProcessing::$11 startProcessing::$12 ] ] with [ zp[2]:104 [ startProcessing::$13 startProcessing::spriteX#0 ] ] - score: 1
 Coalescing zero page register [ zp[2]:108 [ startProcessing::$15 startProcessing::$16 ] ] with [ zp[2]:112 [ startProcessing::$17 startProcessing::spriteY#0 ] ] - score: 1
 Coalescing zero page register [ zp[2]:125 [ getCharToProcess::$8 getCharToProcess::$13 ] ] with [ zp[2]:131 [ getCharToProcess::$9 getCharToProcess::$10 ] ] - score: 1
 Coalescing zero page register [ zp[2]:39 [ atan2_16::angle#6 atan2_16::angle#12 atan2_16::angle#13 atan2_16::angle#2 atan2_16::angle#3 atan2_16::return#0 atan2_16::angle#5 atan2_16::angle#11 atan2_16::angle#1 atan2_16::angle#4 atan2_16::return#2 init_angle_screen::angle_w#0 ] ] with [ zp[2]:150 [ init_angle_screen::$11 ] ] - score: 1
-Coalescing zero page register [ zp[2]:76 [ startProcessing::$0 startProcessing::$36 startProcessing::$1 startProcessing::offset#0 ] ] with [ zp[2]:89 [ startProcessing::screenPtr#0 ] ] - score: 1
+Coalescing zero page register [ zp[2]:76 [ startProcessing::$0 startProcessing::$35 startProcessing::$1 startProcessing::offset#0 ] ] with [ zp[2]:89 [ startProcessing::screenPtr#0 ] ] - score: 1
 Coalescing zero page register [ zp[1]:8 [ startProcessing::freeIdx#2 startProcessing::freeIdx#8 startProcessing::i#2 startProcessing::i#1 ] ] with [ zp[1]:6 [ main::i#2 main::i#1 ] ]
 Coalescing zero page register [ zp[2]:9 [ startProcessing::chargenData#2 startProcessing::chargenData#0 startProcessing::chargenData#1 startProcessing::$9 startProcessing::$8 ] ] with [ zp[2]:2 [ main::src#2 main::src#1 ] ]
 Coalescing zero page register [ zp[2]:11 [ startProcessing::spriteData#2 startProcessing::spriteData#0 startProcessing::spriteData#1 startProcessing::$6 startProcessing::$5 ] ] with [ zp[2]:4 [ main::dst#2 main::dst#0 main::dst#1 ] ]
@@ -7543,8 +7537,8 @@ Coalescing zero page register [ zp[1]:32 [ init_angle_screen::x#2 init_angle_scr
 Coalescing zero page register [ zp[1]:33 [ init_angle_screen::xb#2 init_angle_screen::xb#1 ] ] with [ zp[1]:21 [ getCharToProcess::closest_x#7 getCharToProcess::closest_x#9 getCharToProcess::return_x#1 getCharToProcess::return_x#7 ] ]
 Coalescing zero page register [ zp[2]:48 [ heap_head#5 heap_head#1 ] ] with [ zp[2]:30 [ init_angle_screen::screen_bottomline#6 init_angle_screen::screen_bottomline#0 init_angle_screen::screen_bottomline#1 init_angle_screen::screen#0 ] ]
 Coalescing zero page register [ zp[1]:67 [ main::center_y#0 startProcessing::center_y#0 ] ] with [ zp[1]:22 [ getCharToProcess::closest_y#7 getCharToProcess::closest_y#9 getCharToProcess::return_y#1 getCharToProcess::return_y#7 ] ]
-Coalescing zero page register [ zp[2]:76 [ startProcessing::$0 startProcessing::$36 startProcessing::$1 startProcessing::offset#0 startProcessing::screenPtr#0 ] ] with [ zp[2]:34 [ atan2_16::yi#3 atan2_16::yi#8 atan2_16::yi#0 atan2_16::yi#16 atan2_16::$2 atan2_16::yi#1 atan2_16::yi#2 ] ]
-Coalescing zero page register [ zp[2]:78 [ startProcessing::$35 ] ] with [ zp[2]:36 [ atan2_16::xi#3 atan2_16::xi#8 atan2_16::xi#0 atan2_16::xi#13 atan2_16::$7 atan2_16::xi#1 atan2_16::xi#2 ] ]
+Coalescing zero page register [ zp[2]:76 [ startProcessing::$0 startProcessing::$35 startProcessing::$1 startProcessing::offset#0 startProcessing::screenPtr#0 ] ] with [ zp[2]:34 [ atan2_16::yi#3 atan2_16::yi#8 atan2_16::yi#0 atan2_16::yi#16 atan2_16::$2 atan2_16::yi#1 atan2_16::yi#2 ] ]
+Coalescing zero page register [ zp[2]:78 [ startProcessing::$34 ] ] with [ zp[2]:36 [ atan2_16::xi#3 atan2_16::xi#8 atan2_16::xi#0 atan2_16::xi#13 atan2_16::$7 atan2_16::xi#1 atan2_16::xi#2 ] ]
 Coalescing zero page register [ zp[2]:86 [ startProcessing::colPtr#0 ] ] with [ zp[2]:39 [ atan2_16::angle#6 atan2_16::angle#12 atan2_16::angle#13 atan2_16::angle#2 atan2_16::angle#3 atan2_16::return#0 atan2_16::angle#5 atan2_16::angle#11 atan2_16::angle#1 atan2_16::angle#4 atan2_16::return#2 init_angle_screen::angle_w#0 init_angle_screen::$11 ] ]
 Coalescing zero page register [ zp[2]:100 [ startProcessing::$11 startProcessing::$12 startProcessing::$13 startProcessing::spriteX#0 ] ] with [ zp[2]:44 [ atan2_16::yd#5 atan2_16::yd#3 atan2_16::yd#10 atan2_16::yd#1 atan2_16::yd#2 ] ]
 Coalescing zero page register [ zp[2]:108 [ startProcessing::$15 startProcessing::$16 startProcessing::$17 startProcessing::spriteY#0 ] ] with [ zp[2]:46 [ atan2_16::xd#5 atan2_16::xd#3 atan2_16::xd#10 atan2_16::xd#1 atan2_16::xd#2 ] ]
@@ -7565,8 +7559,8 @@ Allocated (was zp[1]:51) zp[1]:6 [ processChars::numActive#10 processChars::numA
 Allocated (was zp[2]:52) zp[2]:7 [ SCREEN_COPY#0 ]
 Allocated (was zp[2]:54) zp[2]:9 [ SCREEN_DIST#0 malloc::mem#0 ]
 Allocated (was zp[1]:67) zp[1]:11 [ main::center_y#0 startProcessing::center_y#0 getCharToProcess::closest_y#7 getCharToProcess::closest_y#9 getCharToProcess::return_y#1 getCharToProcess::return_y#7 ]
-Allocated (was zp[2]:76) zp[2]:12 [ startProcessing::$0 startProcessing::$36 startProcessing::$1 startProcessing::offset#0 startProcessing::screenPtr#0 atan2_16::yi#3 atan2_16::yi#8 atan2_16::yi#0 atan2_16::yi#16 atan2_16::$2 atan2_16::yi#1 atan2_16::yi#2 ]
-Allocated (was zp[2]:78) zp[2]:14 [ startProcessing::$35 atan2_16::xi#3 atan2_16::xi#8 atan2_16::xi#0 atan2_16::xi#13 atan2_16::$7 atan2_16::xi#1 atan2_16::xi#2 ]
+Allocated (was zp[2]:76) zp[2]:12 [ startProcessing::$0 startProcessing::$35 startProcessing::$1 startProcessing::offset#0 startProcessing::screenPtr#0 atan2_16::yi#3 atan2_16::yi#8 atan2_16::yi#0 atan2_16::yi#16 atan2_16::$2 atan2_16::yi#1 atan2_16::yi#2 ]
+Allocated (was zp[2]:78) zp[2]:14 [ startProcessing::$34 atan2_16::xi#3 atan2_16::xi#8 atan2_16::xi#0 atan2_16::xi#13 atan2_16::$7 atan2_16::xi#1 atan2_16::xi#2 ]
 Allocated (was zp[2]:86) zp[2]:16 [ startProcessing::colPtr#0 atan2_16::angle#6 atan2_16::angle#12 atan2_16::angle#13 atan2_16::angle#2 atan2_16::angle#3 atan2_16::return#0 atan2_16::angle#5 atan2_16::angle#11 atan2_16::angle#1 atan2_16::angle#4 atan2_16::return#2 init_angle_screen::angle_w#0 init_angle_screen::$11 ]
 Allocated (was zp[1]:88) zp[1]:18 [ startProcessing::spriteCol#0 init_angle_screen::x#2 init_angle_screen::x#1 getCharToProcess::closest_dist#2 getCharToProcess::closest_dist#8 getCharToProcess::closest_dist#10 getCharToProcess::closest_dist#12 ]
 Allocated (was zp[2]:100) zp[2]:19 [ startProcessing::$11 startProcessing::$12 startProcessing::$13 startProcessing::spriteX#0 atan2_16::yd#5 atan2_16::yd#3 atan2_16::yd#10 atan2_16::yd#1 atan2_16::yd#2 ]
@@ -7912,8 +7906,8 @@ startProcessing: {
     .label spritePtr = $17
     // Busy-wait while finding an empty slot in the PROCESSING array
     .label freeIdx = 2
-    .label __35 = $e
-    .label __36 = $c
+    .label __34 = $e
+    .label __35 = $c
     // [45] phi from startProcessing to startProcessing::@1 [phi:startProcessing->startProcessing::@1]
   __b1_from_startProcessing:
     // [45] phi (byte) startProcessing::freeIdx#6 = (byte) $ff [phi:startProcessing->startProcessing::@1#0] -- vbuxx=vbuc1 
@@ -7933,18 +7927,18 @@ startProcessing: {
     jmp __b2
     // startProcessing::@2
   __b2:
-    // [47] (byte~) startProcessing::$30 ← (byte) startProcessing::i#2 << (byte) 1 -- vbuaa=vbuz1_rol_1 
+    // [47] (byte~) startProcessing::$29 ← (byte) startProcessing::i#2 << (byte) 1 -- vbuaa=vbuz1_rol_1 
     lda.z i
     asl
-    // [48] (byte~) startProcessing::$31 ← (byte~) startProcessing::$30 + (byte) startProcessing::i#2 -- vbuaa=vbuaa_plus_vbuz1 
+    // [48] (byte~) startProcessing::$30 ← (byte~) startProcessing::$29 + (byte) startProcessing::i#2 -- vbuaa=vbuaa_plus_vbuz1 
     clc
     adc.z i
-    // [49] (byte~) startProcessing::$32 ← (byte~) startProcessing::$31 << (byte) 1 -- vbuaa=vbuaa_rol_1 
+    // [49] (byte~) startProcessing::$31 ← (byte~) startProcessing::$30 << (byte) 1 -- vbuaa=vbuaa_rol_1 
     asl
-    // [50] (byte~) startProcessing::$33 ← (byte~) startProcessing::$32 + (byte) startProcessing::i#2 -- vbuaa=vbuaa_plus_vbuz1 
+    // [50] (byte~) startProcessing::$32 ← (byte~) startProcessing::$31 + (byte) startProcessing::i#2 -- vbuaa=vbuaa_plus_vbuz1 
     clc
     adc.z i
-    // [51] (byte~) startProcessing::$27 ← (byte~) startProcessing::$33 << (byte) 1 -- vbuaa=vbuaa_rol_1 
+    // [51] (byte~) startProcessing::$27 ← (byte~) startProcessing::$32 << (byte) 1 -- vbuaa=vbuaa_rol_1 
     asl
     // [52] if(*((byte*)(const struct ProcessingSprite*) PROCESSING+(const byte) OFFSET_STRUCT_PROCESSINGSPRITE_STATUS + (byte~) startProcessing::$27)!=(const byte) STATUS_FREE) goto startProcessing::@3 -- pbuc1_derefidx_vbuaa_neq_vbuc2_then_la1 
     tay
@@ -7970,24 +7964,24 @@ startProcessing: {
     sta.z __0
     lda #0
     sta.z __0+1
-    // [56] (word~) startProcessing::$35 ← (word~) startProcessing::$0 << (byte) 2 -- vwuz1=vwuz2_rol_2 
+    // [56] (word~) startProcessing::$34 ← (word~) startProcessing::$0 << (byte) 2 -- vwuz1=vwuz2_rol_2 
     lda.z __0
     asl
-    sta.z __35
+    sta.z __34
     lda.z __0+1
     rol
-    sta.z __35+1
-    asl.z __35
-    rol.z __35+1
-    // [57] (word~) startProcessing::$36 ← (word~) startProcessing::$35 + (word~) startProcessing::$0 -- vwuz1=vwuz2_plus_vwuz1 
-    lda.z __36
+    sta.z __34+1
+    asl.z __34
+    rol.z __34+1
+    // [57] (word~) startProcessing::$35 ← (word~) startProcessing::$34 + (word~) startProcessing::$0 -- vwuz1=vwuz2_plus_vwuz1 
+    lda.z __35
     clc
-    adc.z __35
-    sta.z __36
-    lda.z __36+1
-    adc.z __35+1
-    sta.z __36+1
-    // [58] (word~) startProcessing::$1 ← (word~) startProcessing::$36 << (byte) 3 -- vwuz1=vwuz1_rol_3 
+    adc.z __34
+    sta.z __35
+    lda.z __35+1
+    adc.z __34+1
+    sta.z __35+1
+    // [58] (word~) startProcessing::$1 ← (word~) startProcessing::$35 << (byte) 3 -- vwuz1=vwuz1_rol_3 
     asl.z __1
     rol.z __1+1
     asl.z __1
@@ -8192,18 +8186,18 @@ startProcessing: {
     sta.z __21
     lda #0
     sta.z __21+1
-    // [91] (byte~) startProcessing::$38 ← (byte) startProcessing::freeIdx#2 << (byte) 1 -- vbuaa=vbuz1_rol_1 
+    // [91] (byte~) startProcessing::$37 ← (byte) startProcessing::freeIdx#2 << (byte) 1 -- vbuaa=vbuz1_rol_1 
     lda.z freeIdx
     asl
-    // [92] (byte~) startProcessing::$39 ← (byte~) startProcessing::$38 + (byte) startProcessing::freeIdx#2 -- vbuaa=vbuaa_plus_vbuz1 
+    // [92] (byte~) startProcessing::$38 ← (byte~) startProcessing::$37 + (byte) startProcessing::freeIdx#2 -- vbuaa=vbuaa_plus_vbuz1 
     clc
     adc.z freeIdx
-    // [93] (byte~) startProcessing::$40 ← (byte~) startProcessing::$39 << (byte) 1 -- vbuaa=vbuaa_rol_1 
+    // [93] (byte~) startProcessing::$39 ← (byte~) startProcessing::$38 << (byte) 1 -- vbuaa=vbuaa_rol_1 
     asl
-    // [94] (byte~) startProcessing::$41 ← (byte~) startProcessing::$40 + (byte) startProcessing::freeIdx#2 -- vbuaa=vbuaa_plus_vbuz1 
+    // [94] (byte~) startProcessing::$40 ← (byte~) startProcessing::$39 + (byte) startProcessing::freeIdx#2 -- vbuaa=vbuaa_plus_vbuz1 
     clc
     adc.z freeIdx
-    // [95] (byte~) startProcessing::$28 ← (byte~) startProcessing::$41 << (byte) 1 -- vbuxx=vbuaa_rol_1 
+    // [95] (byte~) startProcessing::$28 ← (byte~) startProcessing::$40 << (byte) 1 -- vbuxx=vbuaa_rol_1 
     asl
     tax
     // [96] *((word*)(const struct ProcessingSprite*) PROCESSING + (byte~) startProcessing::$28) ← (word) startProcessing::spriteX#0 -- pwuc1_derefidx_vbuxx=vwuz1 
@@ -10245,16 +10239,16 @@ interrupt(HARDWARE_ALL)(void()) irqTop()
 (word~) startProcessing::$21 zp[2]:24 0.5
 (byte~) startProcessing::$27 reg byte a 2002.0
 (byte~) startProcessing::$28 reg byte x 2.2222222222222228
+(byte~) startProcessing::$29 reg byte a 2002.0
 (byte~) startProcessing::$30 reg byte a 2002.0
 (byte~) startProcessing::$31 reg byte a 2002.0
 (byte~) startProcessing::$32 reg byte a 2002.0
-(byte~) startProcessing::$33 reg byte a 2002.0
-(word~) startProcessing::$35 zp[2]:14 4.0
-(word~) startProcessing::$36 zp[2]:12 4.0
+(word~) startProcessing::$34 zp[2]:14 4.0
+(word~) startProcessing::$35 zp[2]:12 4.0
+(byte~) startProcessing::$37 reg byte a 4.0
 (byte~) startProcessing::$38 reg byte a 4.0
 (byte~) startProcessing::$39 reg byte a 4.0
 (byte~) startProcessing::$40 reg byte a 4.0
-(byte~) startProcessing::$41 reg byte a 4.0
 (word~) startProcessing::$5 zp[2]:3 4.0
 (word~) startProcessing::$6 zp[2]:3 4.0
 (word~) startProcessing::$8 zp[2]:28 4.0
@@ -10336,13 +10330,13 @@ reg byte x [ getCharToProcess::return_dist#0 ]
 reg byte y [ main::center_x#0 ]
 zp[1]:11 [ main::center_y#0 startProcessing::center_y#0 getCharToProcess::closest_y#7 getCharToProcess::closest_y#9 getCharToProcess::return_y#1 getCharToProcess::return_y#7 ]
 reg byte a [ main::center_dist#0 ]
+reg byte a [ startProcessing::$29 ]
 reg byte a [ startProcessing::$30 ]
 reg byte a [ startProcessing::$31 ]
 reg byte a [ startProcessing::$32 ]
-reg byte a [ startProcessing::$33 ]
 reg byte a [ startProcessing::$27 ]
-zp[2]:12 [ startProcessing::$0 startProcessing::$36 startProcessing::$1 startProcessing::offset#0 startProcessing::screenPtr#0 atan2_16::yi#3 atan2_16::yi#8 atan2_16::yi#0 atan2_16::yi#16 atan2_16::$2 atan2_16::yi#1 atan2_16::yi#2 ]
-zp[2]:14 [ startProcessing::$35 atan2_16::xi#3 atan2_16::xi#8 atan2_16::xi#0 atan2_16::xi#13 atan2_16::$7 atan2_16::xi#1 atan2_16::xi#2 ]
+zp[2]:12 [ startProcessing::$0 startProcessing::$35 startProcessing::$1 startProcessing::offset#0 startProcessing::screenPtr#0 atan2_16::yi#3 atan2_16::yi#8 atan2_16::yi#0 atan2_16::yi#16 atan2_16::$2 atan2_16::yi#1 atan2_16::yi#2 ]
+zp[2]:14 [ startProcessing::$34 atan2_16::xi#3 atan2_16::xi#8 atan2_16::xi#0 atan2_16::xi#13 atan2_16::$7 atan2_16::xi#1 atan2_16::xi#2 ]
 zp[2]:16 [ startProcessing::colPtr#0 atan2_16::angle#6 atan2_16::angle#12 atan2_16::angle#13 atan2_16::angle#2 atan2_16::angle#3 atan2_16::return#0 atan2_16::angle#5 atan2_16::angle#11 atan2_16::angle#1 atan2_16::angle#4 atan2_16::return#2 init_angle_screen::angle_w#0 init_angle_screen::$11 ]
 zp[1]:18 [ startProcessing::spriteCol#0 init_angle_screen::x#2 init_angle_screen::x#1 getCharToProcess::closest_dist#2 getCharToProcess::closest_dist#8 getCharToProcess::closest_dist#10 getCharToProcess::closest_dist#12 ]
 reg byte a [ startProcessing::ch#0 ]
@@ -10350,10 +10344,10 @@ zp[2]:19 [ startProcessing::$11 startProcessing::$12 startProcessing::$13 startP
 zp[2]:21 [ startProcessing::$15 startProcessing::$16 startProcessing::$17 startProcessing::spriteY#0 atan2_16::xd#5 atan2_16::xd#3 atan2_16::xd#10 atan2_16::xd#1 atan2_16::xd#2 ]
 zp[1]:23 [ startProcessing::spritePtr#0 init_angle_screen::xb#2 init_angle_screen::xb#1 getCharToProcess::closest_x#7 getCharToProcess::closest_x#9 getCharToProcess::return_x#1 getCharToProcess::return_x#7 ]
 reg byte a [ startProcessing::$20 ]
+reg byte a [ startProcessing::$37 ]
 reg byte a [ startProcessing::$38 ]
 reg byte a [ startProcessing::$39 ]
 reg byte a [ startProcessing::$40 ]
-reg byte a [ startProcessing::$41 ]
 reg byte x [ startProcessing::$28 ]
 zp[2]:24 [ getCharToProcess::$8 getCharToProcess::$13 getCharToProcess::$9 getCharToProcess::$10 startProcessing::$21 heap_head#5 heap_head#1 init_angle_screen::screen_bottomline#6 init_angle_screen::screen_bottomline#0 init_angle_screen::screen_bottomline#1 init_angle_screen::screen#0 ]
 reg byte a [ init_angle_screen::$3 ]
@@ -10700,8 +10694,8 @@ startProcessing: {
     .label spritePtr = $17
     // Busy-wait while finding an empty slot in the PROCESSING array
     .label freeIdx = 2
-    .label __35 = $e
-    .label __36 = $c
+    .label __34 = $e
+    .label __35 = $c
     // [45] phi from startProcessing to startProcessing::@1 [phi:startProcessing->startProcessing::@1]
     // [45] phi (byte) startProcessing::freeIdx#6 = (byte) $ff [phi:startProcessing->startProcessing::@1#0] -- vbuxx=vbuc1 
     ldx #$ff
@@ -10716,18 +10710,18 @@ startProcessing: {
     // startProcessing::@2
   __b2:
     // PROCESSING[i].status==STATUS_FREE
-    // [47] (byte~) startProcessing::$30 ← (byte) startProcessing::i#2 << (byte) 1 -- vbuaa=vbuz1_rol_1 
+    // [47] (byte~) startProcessing::$29 ← (byte) startProcessing::i#2 << (byte) 1 -- vbuaa=vbuz1_rol_1 
     lda.z i
     asl
-    // [48] (byte~) startProcessing::$31 ← (byte~) startProcessing::$30 + (byte) startProcessing::i#2 -- vbuaa=vbuaa_plus_vbuz1 
+    // [48] (byte~) startProcessing::$30 ← (byte~) startProcessing::$29 + (byte) startProcessing::i#2 -- vbuaa=vbuaa_plus_vbuz1 
     clc
     adc.z i
-    // [49] (byte~) startProcessing::$32 ← (byte~) startProcessing::$31 << (byte) 1 -- vbuaa=vbuaa_rol_1 
+    // [49] (byte~) startProcessing::$31 ← (byte~) startProcessing::$30 << (byte) 1 -- vbuaa=vbuaa_rol_1 
     asl
-    // [50] (byte~) startProcessing::$33 ← (byte~) startProcessing::$32 + (byte) startProcessing::i#2 -- vbuaa=vbuaa_plus_vbuz1 
+    // [50] (byte~) startProcessing::$32 ← (byte~) startProcessing::$31 + (byte) startProcessing::i#2 -- vbuaa=vbuaa_plus_vbuz1 
     clc
     adc.z i
-    // [51] (byte~) startProcessing::$27 ← (byte~) startProcessing::$33 << (byte) 1 -- vbuaa=vbuaa_rol_1 
+    // [51] (byte~) startProcessing::$27 ← (byte~) startProcessing::$32 << (byte) 1 -- vbuaa=vbuaa_rol_1 
     asl
     // if(PROCESSING[i].status==STATUS_FREE)
     // [52] if(*((byte*)(const struct ProcessingSprite*) PROCESSING+(const byte) OFFSET_STRUCT_PROCESSINGSPRITE_STATUS + (byte~) startProcessing::$27)!=(const byte) STATUS_FREE) goto startProcessing::@3 -- pbuc1_derefidx_vbuaa_neq_vbuc2_then_la1 
@@ -10756,24 +10750,24 @@ startProcessing: {
     lda #0
     sta.z __0+1
     // (word)center.y*40
-    // [56] (word~) startProcessing::$35 ← (word~) startProcessing::$0 << (byte) 2 -- vwuz1=vwuz2_rol_2 
+    // [56] (word~) startProcessing::$34 ← (word~) startProcessing::$0 << (byte) 2 -- vwuz1=vwuz2_rol_2 
     lda.z __0
     asl
-    sta.z __35
+    sta.z __34
     lda.z __0+1
     rol
-    sta.z __35+1
-    asl.z __35
-    rol.z __35+1
-    // [57] (word~) startProcessing::$36 ← (word~) startProcessing::$35 + (word~) startProcessing::$0 -- vwuz1=vwuz2_plus_vwuz1 
-    lda.z __36
+    sta.z __34+1
+    asl.z __34
+    rol.z __34+1
+    // [57] (word~) startProcessing::$35 ← (word~) startProcessing::$34 + (word~) startProcessing::$0 -- vwuz1=vwuz2_plus_vwuz1 
+    lda.z __35
     clc
-    adc.z __35
-    sta.z __36
-    lda.z __36+1
-    adc.z __35+1
-    sta.z __36+1
-    // [58] (word~) startProcessing::$1 ← (word~) startProcessing::$36 << (byte) 3 -- vwuz1=vwuz1_rol_3 
+    adc.z __34
+    sta.z __35
+    lda.z __35+1
+    adc.z __34+1
+    sta.z __35+1
+    // [58] (word~) startProcessing::$1 ← (word~) startProcessing::$35 << (byte) 3 -- vwuz1=vwuz1_rol_3 
     asl.z __1
     rol.z __1+1
     asl.z __1
@@ -11001,18 +10995,18 @@ startProcessing: {
     lda #0
     sta.z __21+1
     // PROCESSING[spriteIdx] = { spriteX, spriteY, (word)(spriteIdx*8), 60, spriteIdx, spritePtr, spriteCol, STATUS_NEW, screenPtr }
-    // [91] (byte~) startProcessing::$38 ← (byte) startProcessing::freeIdx#2 << (byte) 1 -- vbuaa=vbuz1_rol_1 
+    // [91] (byte~) startProcessing::$37 ← (byte) startProcessing::freeIdx#2 << (byte) 1 -- vbuaa=vbuz1_rol_1 
     lda.z freeIdx
     asl
-    // [92] (byte~) startProcessing::$39 ← (byte~) startProcessing::$38 + (byte) startProcessing::freeIdx#2 -- vbuaa=vbuaa_plus_vbuz1 
+    // [92] (byte~) startProcessing::$38 ← (byte~) startProcessing::$37 + (byte) startProcessing::freeIdx#2 -- vbuaa=vbuaa_plus_vbuz1 
     clc
     adc.z freeIdx
-    // [93] (byte~) startProcessing::$40 ← (byte~) startProcessing::$39 << (byte) 1 -- vbuaa=vbuaa_rol_1 
+    // [93] (byte~) startProcessing::$39 ← (byte~) startProcessing::$38 << (byte) 1 -- vbuaa=vbuaa_rol_1 
     asl
-    // [94] (byte~) startProcessing::$41 ← (byte~) startProcessing::$40 + (byte) startProcessing::freeIdx#2 -- vbuaa=vbuaa_plus_vbuz1 
+    // [94] (byte~) startProcessing::$40 ← (byte~) startProcessing::$39 + (byte) startProcessing::freeIdx#2 -- vbuaa=vbuaa_plus_vbuz1 
     clc
     adc.z freeIdx
-    // [95] (byte~) startProcessing::$28 ← (byte~) startProcessing::$41 << (byte) 1 -- vbuxx=vbuaa_rol_1 
+    // [95] (byte~) startProcessing::$28 ← (byte~) startProcessing::$40 << (byte) 1 -- vbuxx=vbuaa_rol_1 
     asl
     tax
     // [96] *((word*)(const struct ProcessingSprite*) PROCESSING + (byte~) startProcessing::$28) ← (word) startProcessing::spriteX#0 -- pwuc1_derefidx_vbuxx=vwuz1 
diff --git a/src/test/ref/complex/clearscreen/clearscreen.sym b/src/test/ref/complex/clearscreen/clearscreen.sym
index 8cf7fa98f..c1159b606 100644
--- a/src/test/ref/complex/clearscreen/clearscreen.sym
+++ b/src/test/ref/complex/clearscreen/clearscreen.sym
@@ -404,16 +404,16 @@ interrupt(HARDWARE_ALL)(void()) irqTop()
 (word~) startProcessing::$21 zp[2]:24 0.5
 (byte~) startProcessing::$27 reg byte a 2002.0
 (byte~) startProcessing::$28 reg byte x 2.2222222222222228
+(byte~) startProcessing::$29 reg byte a 2002.0
 (byte~) startProcessing::$30 reg byte a 2002.0
 (byte~) startProcessing::$31 reg byte a 2002.0
 (byte~) startProcessing::$32 reg byte a 2002.0
-(byte~) startProcessing::$33 reg byte a 2002.0
-(word~) startProcessing::$35 zp[2]:14 4.0
-(word~) startProcessing::$36 zp[2]:12 4.0
+(word~) startProcessing::$34 zp[2]:14 4.0
+(word~) startProcessing::$35 zp[2]:12 4.0
+(byte~) startProcessing::$37 reg byte a 4.0
 (byte~) startProcessing::$38 reg byte a 4.0
 (byte~) startProcessing::$39 reg byte a 4.0
 (byte~) startProcessing::$40 reg byte a 4.0
-(byte~) startProcessing::$41 reg byte a 4.0
 (word~) startProcessing::$5 zp[2]:3 4.0
 (word~) startProcessing::$6 zp[2]:3 4.0
 (word~) startProcessing::$8 zp[2]:28 4.0
@@ -495,13 +495,13 @@ reg byte x [ getCharToProcess::return_dist#0 ]
 reg byte y [ main::center_x#0 ]
 zp[1]:11 [ main::center_y#0 startProcessing::center_y#0 getCharToProcess::closest_y#7 getCharToProcess::closest_y#9 getCharToProcess::return_y#1 getCharToProcess::return_y#7 ]
 reg byte a [ main::center_dist#0 ]
+reg byte a [ startProcessing::$29 ]
 reg byte a [ startProcessing::$30 ]
 reg byte a [ startProcessing::$31 ]
 reg byte a [ startProcessing::$32 ]
-reg byte a [ startProcessing::$33 ]
 reg byte a [ startProcessing::$27 ]
-zp[2]:12 [ startProcessing::$0 startProcessing::$36 startProcessing::$1 startProcessing::offset#0 startProcessing::screenPtr#0 atan2_16::yi#3 atan2_16::yi#8 atan2_16::yi#0 atan2_16::yi#16 atan2_16::$2 atan2_16::yi#1 atan2_16::yi#2 ]
-zp[2]:14 [ startProcessing::$35 atan2_16::xi#3 atan2_16::xi#8 atan2_16::xi#0 atan2_16::xi#13 atan2_16::$7 atan2_16::xi#1 atan2_16::xi#2 ]
+zp[2]:12 [ startProcessing::$0 startProcessing::$35 startProcessing::$1 startProcessing::offset#0 startProcessing::screenPtr#0 atan2_16::yi#3 atan2_16::yi#8 atan2_16::yi#0 atan2_16::yi#16 atan2_16::$2 atan2_16::yi#1 atan2_16::yi#2 ]
+zp[2]:14 [ startProcessing::$34 atan2_16::xi#3 atan2_16::xi#8 atan2_16::xi#0 atan2_16::xi#13 atan2_16::$7 atan2_16::xi#1 atan2_16::xi#2 ]
 zp[2]:16 [ startProcessing::colPtr#0 atan2_16::angle#6 atan2_16::angle#12 atan2_16::angle#13 atan2_16::angle#2 atan2_16::angle#3 atan2_16::return#0 atan2_16::angle#5 atan2_16::angle#11 atan2_16::angle#1 atan2_16::angle#4 atan2_16::return#2 init_angle_screen::angle_w#0 init_angle_screen::$11 ]
 zp[1]:18 [ startProcessing::spriteCol#0 init_angle_screen::x#2 init_angle_screen::x#1 getCharToProcess::closest_dist#2 getCharToProcess::closest_dist#8 getCharToProcess::closest_dist#10 getCharToProcess::closest_dist#12 ]
 reg byte a [ startProcessing::ch#0 ]
@@ -509,10 +509,10 @@ zp[2]:19 [ startProcessing::$11 startProcessing::$12 startProcessing::$13 startP
 zp[2]:21 [ startProcessing::$15 startProcessing::$16 startProcessing::$17 startProcessing::spriteY#0 atan2_16::xd#5 atan2_16::xd#3 atan2_16::xd#10 atan2_16::xd#1 atan2_16::xd#2 ]
 zp[1]:23 [ startProcessing::spritePtr#0 init_angle_screen::xb#2 init_angle_screen::xb#1 getCharToProcess::closest_x#7 getCharToProcess::closest_x#9 getCharToProcess::return_x#1 getCharToProcess::return_x#7 ]
 reg byte a [ startProcessing::$20 ]
+reg byte a [ startProcessing::$37 ]
 reg byte a [ startProcessing::$38 ]
 reg byte a [ startProcessing::$39 ]
 reg byte a [ startProcessing::$40 ]
-reg byte a [ startProcessing::$41 ]
 reg byte x [ startProcessing::$28 ]
 zp[2]:24 [ getCharToProcess::$8 getCharToProcess::$13 getCharToProcess::$9 getCharToProcess::$10 startProcessing::$21 heap_head#5 heap_head#1 init_angle_screen::screen_bottomline#6 init_angle_screen::screen_bottomline#0 init_angle_screen::screen_bottomline#1 init_angle_screen::screen#0 ]
 reg byte a [ init_angle_screen::$3 ]
diff --git a/src/test/ref/complex/splines/truetype-splines.log b/src/test/ref/complex/splines/truetype-splines.log
index 20fd03762..0b81613b1 100644
--- a/src/test/ref/complex/splines/truetype-splines.log
+++ b/src/test/ref/complex/splines/truetype-splines.log
@@ -397,19 +397,17 @@ Replacing struct member reference (struct Segment) show_letter::segment.via with
 Replacing struct member reference (struct Segment) show_letter::segment.to with member unwinding reference (struct SplineVector16) show_letter::segment_to
 Replacing struct member reference (struct SplineVector16) show_letter::current.x with member unwinding reference (signed word) show_letter::current_x
 Replacing struct member reference (struct SplineVector16) show_letter::current.y with member unwinding reference (signed word) show_letter::current_y
-Replacing struct member reference (struct Segment) show_letter::segment.to with member unwinding reference (struct SplineVector16) show_letter::segment_to
-Replacing struct member reference (struct Segment) show_letter::segment.to with member unwinding reference (struct SplineVector16) show_letter::segment_to
+Replacing struct member reference (struct Segment) show_letter::segment.to.x with member unwinding reference (signed word) show_letter::segment_to_x
+Replacing struct member reference (struct Segment) show_letter::segment.to.y with member unwinding reference (signed word) show_letter::segment_to_y
 Replacing struct member reference (struct SplineVector16) bitmap_plot_spline_8seg::current.x with member unwinding reference (signed word) bitmap_plot_spline_8seg::current_x
 Replacing struct member reference (struct SplineVector16) bitmap_plot_spline_8seg::current.y with member unwinding reference (signed word) bitmap_plot_spline_8seg::current_y
+Replacing struct member reference *((const struct SplineVector16*) SPLINE_8SEG + (byte~) bitmap_plot_spline_8seg::$7).x with member unwinding reference *((signed word*)(const struct SplineVector16*) SPLINE_8SEG+(const byte) OFFSET_STRUCT_SPLINEVECTOR16_X + (byte~) bitmap_plot_spline_8seg::$7)
+Replacing struct member reference *((const struct SplineVector16*) SPLINE_8SEG + (byte~) bitmap_plot_spline_8seg::$8).y with member unwinding reference *((signed word*)(const struct SplineVector16*) SPLINE_8SEG+(const byte) OFFSET_STRUCT_SPLINEVECTOR16_Y + (byte~) bitmap_plot_spline_8seg::$8)
 Replacing struct member reference (struct SplineVector16) rotate::vector.x with member unwinding reference (signed word) rotate::vector_x
 Replacing struct member reference (struct SplineVector16) rotate::vector.y with member unwinding reference (signed word) rotate::vector_y
 Replacing struct member reference (struct SplineVector16) rotate::vector.y with member unwinding reference (signed word) rotate::vector_y
 Replacing struct member reference (struct SplineVector16) rotate::vector.x with member unwinding reference (signed word) rotate::vector_x
 Converted procedure struct value parameter to member unwinding in call (void~) show_letter::$17 ← call spline_8segB (signed word) show_letter::current_x (signed word) show_letter::current_y (signed word) show_letter::segment_via_x (signed word) show_letter::segment_via_y (signed word) show_letter::segment_to_x (signed word) show_letter::segment_to_y 
-Replacing struct member reference (struct SplineVector16) show_letter::segment_to.x with member unwinding reference (signed word) show_letter::segment_to_x
-Replacing struct member reference (struct SplineVector16) show_letter::segment_to.y with member unwinding reference (signed word) show_letter::segment_to_y
-Rewriting struct pointer member access *((const struct SplineVector16*) SPLINE_8SEG + (byte~) bitmap_plot_spline_8seg::$7).x
-Rewriting struct pointer member access *((const struct SplineVector16*) SPLINE_8SEG + (byte~) bitmap_plot_spline_8seg::$8).y
 Warning! Adding boolean cast to non-boolean condition *((byte*) strcpy::src)
 Warning! Adding boolean cast to non-boolean condition *((byte*) strlen::str)
 Warning! Adding boolean cast to non-boolean condition (number~) abs_u16::$1
@@ -1616,11 +1614,9 @@ bitmap_plot_spline_8seg::@1: scope:[bitmap_plot_spline_8seg]  from bitmap_plot_s
   (word~) bitmap_plot_spline_8seg::$0 ← ((word)) (signed word) bitmap_plot_spline_8seg::current_x#2
   (word~) bitmap_plot_spline_8seg::$1 ← ((word)) (signed word) bitmap_plot_spline_8seg::current_y#2
   (byte~) bitmap_plot_spline_8seg::$7 ← (byte) bitmap_plot_spline_8seg::n#2 * (const byte) SIZEOF_STRUCT_SPLINEVECTOR16
-  (signed word*~) bitmap_plot_spline_8seg::$10 ← (signed word*)(const struct SplineVector16*) SPLINE_8SEG + (const byte) OFFSET_STRUCT_SPLINEVECTOR16_X
-  (word~) bitmap_plot_spline_8seg::$2 ← ((word)) *((signed word*~) bitmap_plot_spline_8seg::$10 + (byte~) bitmap_plot_spline_8seg::$7)
+  (word~) bitmap_plot_spline_8seg::$2 ← ((word)) *((signed word*)(const struct SplineVector16*) SPLINE_8SEG+(const byte) OFFSET_STRUCT_SPLINEVECTOR16_X + (byte~) bitmap_plot_spline_8seg::$7)
   (byte~) bitmap_plot_spline_8seg::$8 ← (byte) bitmap_plot_spline_8seg::n#2 * (const byte) SIZEOF_STRUCT_SPLINEVECTOR16
-  (signed word*~) bitmap_plot_spline_8seg::$11 ← (signed word*)(const struct SplineVector16*) SPLINE_8SEG + (const byte) OFFSET_STRUCT_SPLINEVECTOR16_Y
-  (word~) bitmap_plot_spline_8seg::$3 ← ((word)) *((signed word*~) bitmap_plot_spline_8seg::$11 + (byte~) bitmap_plot_spline_8seg::$8)
+  (word~) bitmap_plot_spline_8seg::$3 ← ((word)) *((signed word*)(const struct SplineVector16*) SPLINE_8SEG+(const byte) OFFSET_STRUCT_SPLINEVECTOR16_Y + (byte~) bitmap_plot_spline_8seg::$8)
   (word) bitmap_line::x1#1 ← (word~) bitmap_plot_spline_8seg::$0
   (word) bitmap_line::y1#1 ← (word~) bitmap_plot_spline_8seg::$1
   (word) bitmap_line::x2#1 ← (word~) bitmap_plot_spline_8seg::$2
@@ -2151,8 +2147,6 @@ SYMBOL TABLE SSA
 (void()) bitmap_plot_spline_8seg()
 (word~) bitmap_plot_spline_8seg::$0
 (word~) bitmap_plot_spline_8seg::$1
-(signed word*~) bitmap_plot_spline_8seg::$10
-(signed word*~) bitmap_plot_spline_8seg::$11
 (word~) bitmap_plot_spline_8seg::$2
 (word~) bitmap_plot_spline_8seg::$3
 (bool~) bitmap_plot_spline_8seg::$5
@@ -3026,8 +3020,8 @@ Inlining cast (word~) show_letter::$14 ← (word)(signed word) show_letter::segm
 Inlining cast (word~) show_letter::$15 ← (word)(signed word) show_letter::segment_to_y#4
 Inlining cast (word~) bitmap_plot_spline_8seg::$0 ← (word)(signed word) bitmap_plot_spline_8seg::current_x#2
 Inlining cast (word~) bitmap_plot_spline_8seg::$1 ← (word)(signed word) bitmap_plot_spline_8seg::current_y#2
-Inlining cast (word~) bitmap_plot_spline_8seg::$2 ← (word)*((signed word*~) bitmap_plot_spline_8seg::$10 + (byte~) bitmap_plot_spline_8seg::$7)
-Inlining cast (word~) bitmap_plot_spline_8seg::$3 ← (word)*((signed word*~) bitmap_plot_spline_8seg::$11 + (byte~) bitmap_plot_spline_8seg::$8)
+Inlining cast (word~) bitmap_plot_spline_8seg::$2 ← (word)*((signed word*)(const struct SplineVector16*) SPLINE_8SEG+(const byte) OFFSET_STRUCT_SPLINEVECTOR16_X + (byte~) bitmap_plot_spline_8seg::$7)
+Inlining cast (word~) bitmap_plot_spline_8seg::$3 ← (word)*((signed word*)(const struct SplineVector16*) SPLINE_8SEG+(const byte) OFFSET_STRUCT_SPLINEVECTOR16_Y + (byte~) bitmap_plot_spline_8seg::$8)
 Inlining cast (signed word~) rotate::$0 ← (signed word)*((const signed byte*) COS + (byte) rotate::angle#2)
 Inlining cast (signed word~) rotate::$2 ← (signed word)(signed dword~) rotate::$1
 Inlining cast (signed word~) rotate::$5 ← (signed word)(signed dword~) rotate::$4
@@ -3550,7 +3544,7 @@ Identical Phi Values (byte*) bitmap_screen#7 (byte*) bitmap_screen#1
 Identical Phi Values (byte*) bitmap_gfx#12 (byte*) bitmap_gfx#1
 Successful SSA optimization Pass2IdenticalPhiElimination
 Identified duplicate assignment right side [107] (byte~) bitmap_init::$7 ← (byte) bitmap_init::y#2 & (byte) 7
-Identified duplicate assignment right side [536] (byte~) bitmap_plot_spline_8seg::$8 ← (byte) bitmap_plot_spline_8seg::n#2 * (const byte) SIZEOF_STRUCT_SPLINEVECTOR16
+Identified duplicate assignment right side [535] (byte~) bitmap_plot_spline_8seg::$8 ← (byte) bitmap_plot_spline_8seg::n#2 * (const byte) SIZEOF_STRUCT_SPLINEVECTOR16
 Successful SSA optimization Pass2DuplicateRValueIdentification
 Simple Condition (bool~) spline_8segB::$30 [48] if((byte) spline_8segB::n#1!=rangelast(0,7)) goto spline_8segB::@1
 Simple Condition (bool~) memset::$1 [61] if((word) memset::num#2<=(byte) 0) goto memset::@1
@@ -3578,15 +3572,13 @@ Simple Condition (bool~) main::$9 [421] if((byte) main::w#1!=rangelast(0,$3c)) g
 Simple Condition (bool~) show_letter::$10 [488] if((byte) show_letter::segment_type#0==(const byte) MOVE_TO) goto show_letter::@2
 Simple Condition (bool~) show_letter::$11 [494] if((byte) show_letter::segment_type#0==(const byte) SPLINE_TO) goto show_letter::@3
 Simple Condition (bool~) show_letter::$19 [524] if((byte) show_letter::i#1!=rangelast(0,$15)) goto show_letter::@1
-Simple Condition (bool~) bitmap_plot_spline_8seg::$5 [550] if((byte) bitmap_plot_spline_8seg::n#1!=rangelast(1,8)) goto bitmap_plot_spline_8seg::@1
+Simple Condition (bool~) bitmap_plot_spline_8seg::$5 [548] if((byte) bitmap_plot_spline_8seg::n#1!=rangelast(1,8)) goto bitmap_plot_spline_8seg::@1
 Successful SSA optimization Pass2ConditionalJumpSimplification
 Rewriting ! if()-condition to reversed if() [167] (bool~) bitmap_line::$7 ← ! (bool~) bitmap_line::$6
 Rewriting && if()-condition to two if()s [166] (bool~) bitmap_line::$6 ← (bool~) bitmap_line::$4 && (bool~) bitmap_line::$5
 Successful SSA optimization Pass2ConditionalAndOrRewriting
 Constant right-side identified [54] (byte~) spline_8segB::$32 ← (byte) 8 * (const byte) SIZEOF_STRUCT_SPLINEVECTOR16
 Constant right-side identified [526] (byte~) bitmap_plot_spline_8seg::$6 ← (byte) 0 * (const byte) SIZEOF_STRUCT_SPLINEVECTOR16
-Constant right-side identified [534] (signed word*~) bitmap_plot_spline_8seg::$10 ← (signed word*)(const struct SplineVector16*) SPLINE_8SEG + (const byte) OFFSET_STRUCT_SPLINEVECTOR16_X
-Constant right-side identified [537] (signed word*~) bitmap_plot_spline_8seg::$11 ← (signed word*)(const struct SplineVector16*) SPLINE_8SEG + (const byte) OFFSET_STRUCT_SPLINEVECTOR16_Y
 Successful SSA optimization Pass2ConstantRValueConsolidation
 Constant (const byte) spline_8segB::n#0 = 0
 Constant (const byte) spline_8segB::$32 = 8*SIZEOF_STRUCT_SPLINEVECTOR16
@@ -3627,8 +3619,6 @@ Constant (const signed word) show_letter::current_y#0 = 0
 Constant (const byte) show_letter::i#0 = 0
 Constant (const byte) bitmap_plot_spline_8seg::$6 = 0*SIZEOF_STRUCT_SPLINEVECTOR16
 Constant (const byte) bitmap_plot_spline_8seg::n#0 = 1
-Constant (const signed word*) bitmap_plot_spline_8seg::$10 = (signed word*)SPLINE_8SEG+OFFSET_STRUCT_SPLINEVECTOR16_X
-Constant (const signed word*) bitmap_plot_spline_8seg::$11 = (signed word*)SPLINE_8SEG+OFFSET_STRUCT_SPLINEVECTOR16_Y
 Successful SSA optimization Pass2ConstantIdentification
 Constant (const byte*) bitmap_gfx#1 = bitmap_init::gfx#0
 Constant (const byte*) bitmap_screen#1 = bitmap_init::screen#0
@@ -3652,11 +3642,10 @@ Resolved ranged next value [419] main::w#1 ← ++ main::w#4 to ++
 Resolved ranged comparison value [421] if(main::w#1!=rangelast(0,$3c)) goto main::@5 to (number) $3d
 Resolved ranged next value [522] show_letter::i#1 ← ++ show_letter::i#10 to ++
 Resolved ranged comparison value [524] if(show_letter::i#1!=rangelast(0,$15)) goto show_letter::@1 to (number) $16
-Resolved ranged next value [548] bitmap_plot_spline_8seg::n#1 ← ++ bitmap_plot_spline_8seg::n#2 to ++
-Resolved ranged comparison value [550] if(bitmap_plot_spline_8seg::n#1!=rangelast(1,8)) goto bitmap_plot_spline_8seg::@1 to (number) 9
+Resolved ranged next value [546] bitmap_plot_spline_8seg::n#1 ← ++ bitmap_plot_spline_8seg::n#2 to ++
+Resolved ranged comparison value [548] if(bitmap_plot_spline_8seg::n#1!=rangelast(1,8)) goto bitmap_plot_spline_8seg::@1 to (number) 9
 Simplifying constant evaluating to zero (byte) 0*(const byte) SIZEOF_STRUCT_SPLINEVECTOR16 in 
 Successful SSA optimization PassNSimplifyConstantZero
-Simplifying expression containing zero (signed word*)SPLINE_8SEG in 
 Simplifying expression containing zero (signed word*)SPLINE_8SEG in [36] *((signed word*)(const struct SplineVector16*) SPLINE_8SEG+(const byte) OFFSET_STRUCT_SPLINEVECTOR16_X + (byte~) spline_8segB::$31) ← (signed word~) spline_8segB::$23
 Simplifying expression containing zero (signed word*)SPLINE_8SEG in [55] *((signed word*)(const struct SplineVector16*) SPLINE_8SEG+(const byte) OFFSET_STRUCT_SPLINEVECTOR16_X + (const byte) spline_8segB::$32) ← (signed word~) spline_8segB::$19
 Simplifying expression containing zero (signed word*)(struct SplineVector16*)letter_c+OFFSET_STRUCT_SEGMENT_TO in [438] (signed word) show_letter::to_x#0 ← *((signed word*)(struct SplineVector16*)(const struct Segment*) letter_c+(const byte) OFFSET_STRUCT_SEGMENT_TO+(const byte) OFFSET_STRUCT_SPLINEVECTOR16_X + (byte~) show_letter::$20)
@@ -3665,7 +3654,8 @@ Simplifying expression containing zero (byte*)letter_c in [482] (byte) show_lett
 Simplifying expression containing zero (signed word*)SPLINE_8SEG+OFFSET_STRUCT_SPLINEVECTOR16_X in [527] (signed word) bitmap_plot_spline_8seg::current_x#0 ← *((signed word*)(const struct SplineVector16*) SPLINE_8SEG+(const byte) OFFSET_STRUCT_SPLINEVECTOR16_X + (const byte) bitmap_plot_spline_8seg::$6)
 Simplifying expression containing zero (signed word*)SPLINE_8SEG in [527] (signed word) bitmap_plot_spline_8seg::current_x#0 ← *((signed word*)(const struct SplineVector16*) SPLINE_8SEG+(const byte) OFFSET_STRUCT_SPLINEVECTOR16_X)
 Simplifying expression containing zero (signed word*)SPLINE_8SEG+OFFSET_STRUCT_SPLINEVECTOR16_Y in [528] (signed word) bitmap_plot_spline_8seg::current_y#0 ← *((signed word*)(const struct SplineVector16*) SPLINE_8SEG+(const byte) OFFSET_STRUCT_SPLINEVECTOR16_Y + (const byte) bitmap_plot_spline_8seg::$6)
-Simplifying expression containing zero (signed word*)SPLINE_8SEG in [546] (signed word) bitmap_plot_spline_8seg::current_x#1 ← *((signed word*)(const struct SplineVector16*) SPLINE_8SEG+(const byte) OFFSET_STRUCT_SPLINEVECTOR16_X + (byte~) bitmap_plot_spline_8seg::$9)
+Simplifying expression containing zero (signed word*)SPLINE_8SEG in [534] (word) bitmap_line::x2#1 ← (word)*((signed word*)(const struct SplineVector16*) SPLINE_8SEG+(const byte) OFFSET_STRUCT_SPLINEVECTOR16_X + (byte~) bitmap_plot_spline_8seg::$7)
+Simplifying expression containing zero (signed word*)SPLINE_8SEG in [544] (signed word) bitmap_plot_spline_8seg::current_x#1 ← *((signed word*)(const struct SplineVector16*) SPLINE_8SEG+(const byte) OFFSET_STRUCT_SPLINEVECTOR16_X + (byte~) bitmap_plot_spline_8seg::$9)
 Successful SSA optimization PassNSimplifyExpressionWithZero
 Eliminating unused variable (void*) memset::return#2 and assignment [75] (void*) memset::return#2 ← (void*) memset::str#3
 Eliminating unused variable (void*) memset::return#3 and assignment [77] (void*) memset::return#3 ← (void*) memset::str#3
@@ -3746,8 +3736,8 @@ Inlining Noop Cast [41] (byte*~) memset::$2 ← (byte*)(void*) memset::str#3 kee
 Inlining Noop Cast [43] (byte*) memset::dst#0 ← (byte*)(void*) memset::str#3 keeping memset::str#3
 Inlining Noop Cast [190] (word~) mulf16s::$10 ← (word)(signed word) mulf16s::b#4 keeping mulf16s::b#4
 Inlining Noop Cast [196] (word~) mulf16s::$14 ← (word)(signed word) mulf16s::a#4 keeping mulf16s::a#4
-Inlining Noop Cast [274] (word) bitmap_line::x2#1 ← (word)*((const signed word*) bitmap_plot_spline_8seg::$10 + (byte~) bitmap_plot_spline_8seg::$8) keeping *(bitmap_plot_spline_8seg::$10 + bitmap_plot_spline_8seg::$8)
-Inlining Noop Cast [275] (word) bitmap_line::y2#1 ← (word)*((const signed word*) bitmap_plot_spline_8seg::$11 + (byte~) bitmap_plot_spline_8seg::$8) keeping *(bitmap_plot_spline_8seg::$11 + bitmap_plot_spline_8seg::$8)
+Inlining Noop Cast [274] (word) bitmap_line::x2#1 ← (word)*((signed word*)(const struct SplineVector16*) SPLINE_8SEG + (byte~) bitmap_plot_spline_8seg::$8) keeping *((signed word*)SPLINE_8SEG + bitmap_plot_spline_8seg::$8)
+Inlining Noop Cast [275] (word) bitmap_line::y2#1 ← (word)*((signed word*)(const struct SplineVector16*) SPLINE_8SEG+(const byte) OFFSET_STRUCT_SPLINEVECTOR16_Y + (byte~) bitmap_plot_spline_8seg::$8) keeping *((signed word*)SPLINE_8SEG+OFFSET_STRUCT_SPLINEVECTOR16_Y + bitmap_plot_spline_8seg::$8)
 Successful SSA optimization Pass2NopCastInlining
 Inlining Noop Cast [78] (byte*) bitmap_plot::plotter#0 ← (byte*)(word~) bitmap_plot::$3 keeping bitmap_plot::plotter#0
 Inlining Noop Cast [317] (signed byte~) rotate::$15 ← (signed byte)(byte~) rotate::$14 keeping rotate::$15
@@ -3842,8 +3832,6 @@ Constant inlined mulf_init::sqr1_lo#0 = (const byte*) mulf_sqr1_lo+(byte) 1
 Constant inlined spline_8segB::n#0 = (byte) 0
 Constant inlined bitmap_init::x#0 = (byte) 0
 Constant inlined memset::c#1 = (byte) 0
-Constant inlined bitmap_plot_spline_8seg::$10 = (signed word*)(const struct SplineVector16*) SPLINE_8SEG
-Constant inlined bitmap_plot_spline_8seg::$11 = (signed word*)(const struct SplineVector16*) SPLINE_8SEG+(const byte) OFFSET_STRUCT_SPLINEVECTOR16_Y
 Constant inlined mulf_init::c#0 = (byte) 0
 Constant inlined main::toD0181_screen#0 = (const byte*) BITMAP_SCREEN
 Constant inlined main::toD0181_gfx#0 = (const byte*) BITMAP_GRAPHICS
diff --git a/src/test/ref/declared-memory-var-3.log b/src/test/ref/declared-memory-var-3.log
index 9a21ca18a..77197dc36 100644
--- a/src/test/ref/declared-memory-var-3.log
+++ b/src/test/ref/declared-memory-var-3.log
@@ -1,6 +1,6 @@
 Setting inferred volatile on symbol affected by address-of (struct foo*) main::barp ← &(struct foo) bar
-Rewriting struct pointer member access *((struct foo*) main::barp).thing1
-Rewriting struct pointer member access *((struct foo*) main::barp).thing2
+Replacing struct member reference *((struct foo*) main::barp).thing1 with member unwinding reference *((byte*~) main::$0)
+Replacing struct member reference *((struct foo*) main::barp).thing2 with member unwinding reference *((byte*~) main::$1)
 Identified constant variable (struct foo*) main::barp
 
 CONTROL FLOW GRAPH SSA
diff --git a/src/test/ref/declared-memory-var-4.log b/src/test/ref/declared-memory-var-4.log
index 26a40f1e6..02617a110 100644
--- a/src/test/ref/declared-memory-var-4.log
+++ b/src/test/ref/declared-memory-var-4.log
@@ -3,9 +3,9 @@ Fixing struct type size struct foo to 14
 Fixing struct type SIZE_OF struct foo to 14
 Fixing struct type SIZE_OF struct foo to 14
 Setting inferred volatile on symbol affected by address-of (struct foo*) main::barp ← &(struct foo) bar
-Rewriting struct pointer member access *((struct foo*) main::barp).thing1
-Rewriting struct pointer member access *((struct foo*) main::barp).thing2
-Rewriting struct pointer member access *((struct foo*) main::barp).thing3
+Replacing struct member reference *((struct foo*) main::barp).thing1 with member unwinding reference *((byte*~) main::$1)
+Replacing struct member reference *((struct foo*) main::barp).thing2 with member unwinding reference *((byte*~) main::$2)
+Replacing struct member reference *((struct foo*) main::barp).thing3 with member unwinding reference (byte*~) main::$3
 Identified constant variable (struct foo*) main::barp
 Culled Empty Block (label) main::@2
 
diff --git a/src/test/ref/initializer-2.log b/src/test/ref/initializer-2.log
index 8eb4befd3..cc456ea54 100644
--- a/src/test/ref/initializer-2.log
+++ b/src/test/ref/initializer-2.log
@@ -1,7 +1,7 @@
 Fixing pointer array-indexing *((const struct Point*) points + (byte) main::i)
 Fixing pointer array-indexing *((const struct Point*) points + (byte) main::i)
-Rewriting struct pointer member access *((const struct Point*) points + (byte~) main::$1).x
-Rewriting struct pointer member access *((const struct Point*) points + (byte~) main::$2).y
+Replacing struct member reference *((const struct Point*) points + (byte~) main::$1).x with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$1)
+Replacing struct member reference *((const struct Point*) points + (byte~) main::$2).y with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$2)
 Culled Empty Block (label) main::@2
 
 CONTROL FLOW GRAPH SSA
@@ -17,12 +17,10 @@ main::@1: scope:[main]  from main main::@1
   (byte) main::idx#3 ← phi( main/(byte) main::idx#0 main::@1/(byte) main::idx#2 )
   (byte) main::i#2 ← phi( main/(byte) main::i#0 main::@1/(byte) main::i#1 )
   (byte~) main::$1 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
-  (byte*~) main::$3 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
-  *((const byte*) main::SCREEN + (byte) main::idx#3) ← *((byte*~) main::$3 + (byte~) main::$1)
+  *((const byte*) main::SCREEN + (byte) main::idx#3) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$1)
   (byte) main::idx#1 ← ++ (byte) main::idx#3
   (byte~) main::$2 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
-  (byte*~) main::$4 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
-  *((const byte*) main::SCREEN + (byte) main::idx#1) ← *((byte*~) main::$4 + (byte~) main::$2)
+  *((const byte*) main::SCREEN + (byte) main::idx#1) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$2)
   (byte) main::idx#2 ← ++ (byte) main::idx#1
   (byte) main::i#1 ← (byte) main::i#2 + rangenext(0,2)
   (bool~) main::$0 ← (byte) main::i#1 != rangelast(0,2)
@@ -52,8 +50,6 @@ SYMBOL TABLE SSA
 (bool~) main::$0
 (byte~) main::$1
 (byte~) main::$2
-(byte*~) main::$3
-(byte*~) main::$4
 (label) main::@1
 (label) main::@return
 (const byte*) main::SCREEN = (byte*)(number) $400
@@ -70,21 +66,16 @@ SYMBOL TABLE SSA
 
 Simplifying constant pointer cast (byte*) 1024
 Successful SSA optimization PassNCastSimplification
-Identified duplicate assignment right side [7] (byte~) main::$2 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
+Identified duplicate assignment right side [6] (byte~) main::$2 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
 Successful SSA optimization Pass2DuplicateRValueIdentification
-Simple Condition (bool~) main::$0 [13] if((byte) main::i#1!=rangelast(0,2)) goto main::@1
+Simple Condition (bool~) main::$0 [11] if((byte) main::i#1!=rangelast(0,2)) goto main::@1
 Successful SSA optimization Pass2ConditionalJumpSimplification
-Constant right-side identified [4] (byte*~) main::$3 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
-Constant right-side identified [8] (byte*~) main::$4 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
-Successful SSA optimization Pass2ConstantRValueConsolidation
 Constant (const byte) main::idx#0 = 0
 Constant (const byte) main::i#0 = 0
-Constant (const byte*) main::$3 = (byte*)points+OFFSET_STRUCT_POINT_X
-Constant (const byte*) main::$4 = (byte*)points+OFFSET_STRUCT_POINT_Y
 Successful SSA optimization Pass2ConstantIdentification
-Resolved ranged next value [11] main::i#1 ← ++ main::i#2 to ++
-Resolved ranged comparison value [13] if(main::i#1!=rangelast(0,2)) goto main::@1 to (number) 3
-Simplifying expression containing zero (byte*)points in 
+Resolved ranged next value [9] main::i#1 ← ++ main::i#2 to ++
+Resolved ranged comparison value [11] if(main::i#1!=rangelast(0,2)) goto main::@1 to (number) 3
+Simplifying expression containing zero (byte*)points in [4] *((const byte*) main::SCREEN + (byte) main::idx#3) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$1)
 Successful SSA optimization PassNSimplifyExpressionWithZero
 Eliminating unused constant (const byte) OFFSET_STRUCT_POINT_X
 Successful SSA optimization PassNEliminateUnusedVars
@@ -102,8 +93,6 @@ Inlining constant with var siblings (const byte) main::idx#0
 Inlining constant with var siblings (const byte) main::i#0
 Constant inlined main::i#0 = (byte) 0
 Constant inlined main::idx#0 = (byte) 0
-Constant inlined main::$3 = (byte*)(const struct Point*) points
-Constant inlined main::$4 = (byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y
 Successful SSA optimization Pass2ConstantInlining
 Eliminating unused constant (const byte) SIZEOF_STRUCT_POINT
 Successful SSA optimization PassNEliminateUnusedVars
diff --git a/src/test/ref/initializer-3.cfg b/src/test/ref/initializer-3.cfg
index 59173412f..920f2ad2a 100644
--- a/src/test/ref/initializer-3.cfg
+++ b/src/test/ref/initializer-3.cfg
@@ -15,8 +15,8 @@ main: scope:[main]  from @1
 main::@1: scope:[main]  from main main::@1
   [5] (byte) main::idx#4 ← phi( main/(byte) 0 main::@1/(byte) main::idx#3 )
   [5] (byte) main::i#2 ← phi( main/(byte) 0 main::@1/(byte) main::i#1 )
-  [6] (byte~) main::$9 ← (byte) main::i#2 << (byte) 1
-  [7] (byte~) main::$4 ← (byte~) main::$9 + (byte) main::i#2
+  [6] (byte~) main::$6 ← (byte) main::i#2 << (byte) 1
+  [7] (byte~) main::$4 ← (byte~) main::$6 + (byte) main::i#2
   [8] *((const byte*) main::SCREEN + (byte) main::idx#4) ← *((byte*)(const struct Point*) points + (byte~) main::$4)
   [9] (byte) main::idx#1 ← ++ (byte) main::idx#4
   [10] (byte~) main::$0 ← < *((signed word*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$4)
diff --git a/src/test/ref/initializer-3.log b/src/test/ref/initializer-3.log
index fec195e74..f54710164 100644
--- a/src/test/ref/initializer-3.log
+++ b/src/test/ref/initializer-3.log
@@ -1,9 +1,9 @@
 Fixing pointer array-indexing *((const struct Point*) points + (byte) main::i)
 Fixing pointer array-indexing *((const struct Point*) points + (byte) main::i)
 Fixing pointer array-indexing *((const struct Point*) points + (byte) main::i)
-Rewriting struct pointer member access *((const struct Point*) points + (byte~) main::$3).x
-Rewriting struct pointer member access *((const struct Point*) points + (byte~) main::$4).y
-Rewriting struct pointer member access *((const struct Point*) points + (byte~) main::$5).y
+Replacing struct member reference *((const struct Point*) points + (byte~) main::$3).x with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$3)
+Replacing struct member reference *((const struct Point*) points + (byte~) main::$4).y with member unwinding reference *((signed word*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$4)
+Replacing struct member reference *((const struct Point*) points + (byte~) main::$5).y with member unwinding reference *((signed word*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$5)
 Culled Empty Block (label) main::@2
 
 CONTROL FLOW GRAPH SSA
@@ -19,17 +19,14 @@ main::@1: scope:[main]  from main main::@1
   (byte) main::idx#4 ← phi( main/(byte) main::idx#0 main::@1/(byte) main::idx#3 )
   (byte) main::i#2 ← phi( main/(byte) main::i#0 main::@1/(byte) main::i#1 )
   (byte~) main::$3 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
-  (byte*~) main::$6 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
-  *((const byte*) main::SCREEN + (byte) main::idx#4) ← *((byte*~) main::$6 + (byte~) main::$3)
+  *((const byte*) main::SCREEN + (byte) main::idx#4) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$3)
   (byte) main::idx#1 ← ++ (byte) main::idx#4
   (byte~) main::$4 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
-  (signed word*~) main::$7 ← (signed word*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
-  (byte~) main::$0 ← < *((signed word*~) main::$7 + (byte~) main::$4)
+  (byte~) main::$0 ← < *((signed word*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$4)
   *((const byte*) main::SCREEN + (byte) main::idx#1) ← (byte~) main::$0
   (byte) main::idx#2 ← ++ (byte) main::idx#1
   (byte~) main::$5 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
-  (signed word*~) main::$8 ← (signed word*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
-  (byte~) main::$1 ← > *((signed word*~) main::$8 + (byte~) main::$5)
+  (byte~) main::$1 ← > *((signed word*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$5)
   *((const byte*) main::SCREEN + (byte) main::idx#2) ← (byte~) main::$1
   (byte) main::idx#3 ← ++ (byte) main::idx#2
   (byte) main::i#1 ← (byte) main::i#2 + rangenext(0,2)
@@ -63,9 +60,6 @@ SYMBOL TABLE SSA
 (byte~) main::$3
 (byte~) main::$4
 (byte~) main::$5
-(byte*~) main::$6
-(signed word*~) main::$7
-(signed word*~) main::$8
 (label) main::@1
 (label) main::@return
 (const byte*) main::SCREEN = (byte*)(number) $400
@@ -83,24 +77,17 @@ SYMBOL TABLE SSA
 
 Simplifying constant pointer cast (byte*) 1024
 Successful SSA optimization PassNCastSimplification
-Identified duplicate assignment right side [7] (byte~) main::$4 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
-Identified duplicate assignment right side [12] (byte~) main::$5 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
+Identified duplicate assignment right side [6] (byte~) main::$4 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
+Identified duplicate assignment right side [10] (byte~) main::$5 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
 Successful SSA optimization Pass2DuplicateRValueIdentification
-Simple Condition (bool~) main::$2 [19] if((byte) main::i#1!=rangelast(0,2)) goto main::@1
+Simple Condition (bool~) main::$2 [16] if((byte) main::i#1!=rangelast(0,2)) goto main::@1
 Successful SSA optimization Pass2ConditionalJumpSimplification
-Constant right-side identified [4] (byte*~) main::$6 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
-Constant right-side identified [8] (signed word*~) main::$7 ← (signed word*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
-Constant right-side identified [13] (signed word*~) main::$8 ← (signed word*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
-Successful SSA optimization Pass2ConstantRValueConsolidation
 Constant (const byte) main::idx#0 = 0
 Constant (const byte) main::i#0 = 0
-Constant (const byte*) main::$6 = (byte*)points+OFFSET_STRUCT_POINT_X
-Constant (const signed word*) main::$7 = (signed word*)points+OFFSET_STRUCT_POINT_Y
-Constant (const signed word*) main::$8 = (signed word*)points+OFFSET_STRUCT_POINT_Y
 Successful SSA optimization Pass2ConstantIdentification
-Resolved ranged next value [17] main::i#1 ← ++ main::i#2 to ++
-Resolved ranged comparison value [19] if(main::i#1!=rangelast(0,2)) goto main::@1 to (number) 3
-Simplifying expression containing zero (byte*)points in 
+Resolved ranged next value [14] main::i#1 ← ++ main::i#2 to ++
+Resolved ranged comparison value [16] if(main::i#1!=rangelast(0,2)) goto main::@1 to (number) 3
+Simplifying expression containing zero (byte*)points in [4] *((const byte*) main::SCREEN + (byte) main::idx#4) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$3)
 Successful SSA optimization PassNSimplifyExpressionWithZero
 Eliminating unused constant (const byte) OFFSET_STRUCT_POINT_X
 Successful SSA optimization PassNEliminateUnusedVars
@@ -116,12 +103,9 @@ Rewriting multiplication to use shift and addition[1] (byte~) main::$4 ← (byte
 Inlining constant with var siblings (const byte) main::idx#0
 Inlining constant with var siblings (const byte) main::i#0
 Constant inlined main::i#0 = (byte) 0
-Constant inlined main::$6 = (byte*)(const struct Point*) points
 Constant inlined main::idx#0 = (byte) 0
-Constant inlined main::$7 = (signed word*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y
-Constant inlined main::$8 = (signed word*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y
 Successful SSA optimization Pass2ConstantInlining
-Alias (byte~) main::$4 = (byte~) main::$10 
+Alias (byte~) main::$4 = (byte~) main::$7 
 Successful SSA optimization Pass2AliasElimination
 Eliminating unused constant (const byte) SIZEOF_STRUCT_POINT
 Successful SSA optimization PassNEliminateUnusedVars
@@ -163,8 +147,8 @@ main: scope:[main]  from @1
 main::@1: scope:[main]  from main main::@1
   [5] (byte) main::idx#4 ← phi( main/(byte) 0 main::@1/(byte) main::idx#3 )
   [5] (byte) main::i#2 ← phi( main/(byte) 0 main::@1/(byte) main::i#1 )
-  [6] (byte~) main::$9 ← (byte) main::i#2 << (byte) 1
-  [7] (byte~) main::$4 ← (byte~) main::$9 + (byte) main::i#2
+  [6] (byte~) main::$6 ← (byte) main::i#2 << (byte) 1
+  [7] (byte~) main::$4 ← (byte~) main::$6 + (byte) main::i#2
   [8] *((const byte*) main::SCREEN + (byte) main::idx#4) ← *((byte*)(const struct Point*) points + (byte~) main::$4)
   [9] (byte) main::idx#1 ← ++ (byte) main::idx#4
   [10] (byte~) main::$0 ← < *((signed word*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$4)
@@ -188,7 +172,7 @@ VARIABLE REGISTER WEIGHTS
 (byte~) main::$0 22.0
 (byte~) main::$1 22.0
 (byte~) main::$4 7.333333333333333
-(byte~) main::$9 22.0
+(byte~) main::$6 22.0
 (byte) main::i
 (byte) main::i#1 16.5
 (byte) main::i#2 4.0
@@ -201,7 +185,7 @@ VARIABLE REGISTER WEIGHTS
 Initial phi equivalence classes
 [ main::i#2 main::i#1 ]
 [ main::idx#4 main::idx#3 ]
-Added variable main::$9 to live range equivalence class [ main::$9 ]
+Added variable main::$6 to live range equivalence class [ main::$6 ]
 Added variable main::$4 to live range equivalence class [ main::$4 ]
 Added variable main::idx#1 to live range equivalence class [ main::idx#1 ]
 Added variable main::$0 to live range equivalence class [ main::$0 ]
@@ -210,7 +194,7 @@ Added variable main::$1 to live range equivalence class [ main::$1 ]
 Complete equivalence classes
 [ main::i#2 main::i#1 ]
 [ main::idx#4 main::idx#3 ]
-[ main::$9 ]
+[ main::$6 ]
 [ main::$4 ]
 [ main::idx#1 ]
 [ main::$0 ]
@@ -218,7 +202,7 @@ Complete equivalence classes
 [ main::$1 ]
 Allocated zp[1]:2 [ main::i#2 main::i#1 ]
 Allocated zp[1]:3 [ main::idx#4 main::idx#3 ]
-Allocated zp[1]:4 [ main::$9 ]
+Allocated zp[1]:4 [ main::$6 ]
 Allocated zp[1]:5 [ main::$4 ]
 Allocated zp[1]:6 [ main::idx#1 ]
 Allocated zp[1]:7 [ main::$0 ]
@@ -262,7 +246,7 @@ main: {
     .label idx_1 = 8
     .label idx_2 = 3
     .label i = 2
-    .label __9 = 4
+    .label __6 = 4
     // [5] phi from main to main::@1 [phi:main->main::@1]
   __b1_from_main:
     // [5] phi (byte) main::idx#4 = (byte) 0 [phi:main->main::@1#0] -- vbuz1=vbuc1 
@@ -279,12 +263,12 @@ main: {
     jmp __b1
     // main::@1
   __b1:
-    // [6] (byte~) main::$9 ← (byte) main::i#2 << (byte) 1 -- vbuz1=vbuz2_rol_1 
+    // [6] (byte~) main::$6 ← (byte) main::i#2 << (byte) 1 -- vbuz1=vbuz2_rol_1 
     lda.z i
     asl
-    sta.z __9
-    // [7] (byte~) main::$4 ← (byte~) main::$9 + (byte) main::i#2 -- vbuz1=vbuz2_plus_vbuz3 
-    lda.z __9
+    sta.z __6
+    // [7] (byte~) main::$4 ← (byte~) main::$6 + (byte) main::i#2 -- vbuz1=vbuz2_plus_vbuz3 
+    lda.z __6
     clc
     adc.z i
     sta.z __4
@@ -342,24 +326,24 @@ main: {
   .word 6
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Statement [6] (byte~) main::$9 ← (byte) main::i#2 << (byte) 1 [ main::i#2 main::idx#4 main::$9 ] ( main:2 [ main::i#2 main::idx#4 main::$9 ] ) always clobbers reg byte a 
+Statement [6] (byte~) main::$6 ← (byte) main::i#2 << (byte) 1 [ main::i#2 main::idx#4 main::$6 ] ( main:2 [ main::i#2 main::idx#4 main::$6 ] ) always clobbers reg byte a 
 Removing always clobbered register reg byte a as potential for zp[1]:2 [ main::i#2 main::i#1 ]
 Removing always clobbered register reg byte a as potential for zp[1]:3 [ main::idx#4 main::idx#3 ]
-Statement [7] (byte~) main::$4 ← (byte~) main::$9 + (byte) main::i#2 [ main::i#2 main::idx#4 main::$4 ] ( main:2 [ main::i#2 main::idx#4 main::$4 ] ) always clobbers reg byte a 
+Statement [7] (byte~) main::$4 ← (byte~) main::$6 + (byte) main::i#2 [ main::i#2 main::idx#4 main::$4 ] ( main:2 [ main::i#2 main::idx#4 main::$4 ] ) always clobbers reg byte a 
 Statement [8] *((const byte*) main::SCREEN + (byte) main::idx#4) ← *((byte*)(const struct Point*) points + (byte~) main::$4) [ main::i#2 main::idx#4 main::$4 ] ( main:2 [ main::i#2 main::idx#4 main::$4 ] ) always clobbers reg byte a 
 Removing always clobbered register reg byte a as potential for zp[1]:5 [ main::$4 ]
 Statement [10] (byte~) main::$0 ← < *((signed word*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$4) [ main::i#2 main::$4 main::idx#1 main::$0 ] ( main:2 [ main::i#2 main::$4 main::idx#1 main::$0 ] ) always clobbers reg byte a 
 Removing always clobbered register reg byte a as potential for zp[1]:6 [ main::idx#1 ]
 Statement [13] (byte~) main::$1 ← > *((signed word*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$4) [ main::i#2 main::idx#2 main::$1 ] ( main:2 [ main::i#2 main::idx#2 main::$1 ] ) always clobbers reg byte a 
 Removing always clobbered register reg byte a as potential for zp[1]:8 [ main::idx#2 ]
-Statement [6] (byte~) main::$9 ← (byte) main::i#2 << (byte) 1 [ main::i#2 main::idx#4 main::$9 ] ( main:2 [ main::i#2 main::idx#4 main::$9 ] ) always clobbers reg byte a 
-Statement [7] (byte~) main::$4 ← (byte~) main::$9 + (byte) main::i#2 [ main::i#2 main::idx#4 main::$4 ] ( main:2 [ main::i#2 main::idx#4 main::$4 ] ) always clobbers reg byte a 
+Statement [6] (byte~) main::$6 ← (byte) main::i#2 << (byte) 1 [ main::i#2 main::idx#4 main::$6 ] ( main:2 [ main::i#2 main::idx#4 main::$6 ] ) always clobbers reg byte a 
+Statement [7] (byte~) main::$4 ← (byte~) main::$6 + (byte) main::i#2 [ main::i#2 main::idx#4 main::$4 ] ( main:2 [ main::i#2 main::idx#4 main::$4 ] ) always clobbers reg byte a 
 Statement [8] *((const byte*) main::SCREEN + (byte) main::idx#4) ← *((byte*)(const struct Point*) points + (byte~) main::$4) [ main::i#2 main::idx#4 main::$4 ] ( main:2 [ main::i#2 main::idx#4 main::$4 ] ) always clobbers reg byte a 
 Statement [10] (byte~) main::$0 ← < *((signed word*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$4) [ main::i#2 main::$4 main::idx#1 main::$0 ] ( main:2 [ main::i#2 main::$4 main::idx#1 main::$0 ] ) always clobbers reg byte a 
 Statement [13] (byte~) main::$1 ← > *((signed word*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$4) [ main::i#2 main::idx#2 main::$1 ] ( main:2 [ main::i#2 main::idx#2 main::$1 ] ) always clobbers reg byte a 
 Potential registers zp[1]:2 [ main::i#2 main::i#1 ] : zp[1]:2 , reg byte x , reg byte y , 
 Potential registers zp[1]:3 [ main::idx#4 main::idx#3 ] : zp[1]:3 , reg byte x , reg byte y , 
-Potential registers zp[1]:4 [ main::$9 ] : zp[1]:4 , reg byte a , reg byte x , reg byte y , 
+Potential registers zp[1]:4 [ main::$6 ] : zp[1]:4 , reg byte a , reg byte x , reg byte y , 
 Potential registers zp[1]:5 [ main::$4 ] : zp[1]:5 , reg byte x , reg byte y , 
 Potential registers zp[1]:6 [ main::idx#1 ] : zp[1]:6 , reg byte x , reg byte y , 
 Potential registers zp[1]:7 [ main::$0 ] : zp[1]:7 , reg byte a , reg byte x , reg byte y , 
@@ -367,11 +351,11 @@ Potential registers zp[1]:8 [ main::idx#2 ] : zp[1]:8 , reg byte x , reg byte y
 Potential registers zp[1]:9 [ main::$1 ] : zp[1]:9 , reg byte a , reg byte x , reg byte y , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [main] 22: zp[1]:4 [ main::$9 ] 22: zp[1]:7 [ main::$0 ] 22: zp[1]:9 [ main::$1 ] 20.5: zp[1]:2 [ main::i#2 main::i#1 ] 15.58: zp[1]:3 [ main::idx#4 main::idx#3 ] 11: zp[1]:6 [ main::idx#1 ] 11: zp[1]:8 [ main::idx#2 ] 7.33: zp[1]:5 [ main::$4 ] 
+Uplift Scope [main] 22: zp[1]:4 [ main::$6 ] 22: zp[1]:7 [ main::$0 ] 22: zp[1]:9 [ main::$1 ] 20.5: zp[1]:2 [ main::i#2 main::i#1 ] 15.58: zp[1]:3 [ main::idx#4 main::idx#3 ] 11: zp[1]:6 [ main::idx#1 ] 11: zp[1]:8 [ main::idx#2 ] 7.33: zp[1]:5 [ main::$4 ] 
 Uplift Scope [Point] 
 Uplift Scope [] 
 
-Uplifting [main] best 1098 combination reg byte a [ main::$9 ] reg byte a [ main::$0 ] reg byte a [ main::$1 ] reg byte x [ main::i#2 main::i#1 ] zp[1]:3 [ main::idx#4 main::idx#3 ] zp[1]:6 [ main::idx#1 ] zp[1]:8 [ main::idx#2 ] zp[1]:5 [ main::$4 ] 
+Uplifting [main] best 1098 combination reg byte a [ main::$6 ] reg byte a [ main::$0 ] reg byte a [ main::$1 ] reg byte x [ main::i#2 main::i#1 ] zp[1]:3 [ main::idx#4 main::idx#3 ] zp[1]:6 [ main::idx#1 ] zp[1]:8 [ main::idx#2 ] zp[1]:5 [ main::$4 ] 
 Limited combination testing to 100 combinations of 15552 possible.
 Uplifting [Point] best 1098 combination 
 Uplifting [] best 1098 combination 
@@ -434,10 +418,10 @@ main: {
     jmp __b1
     // main::@1
   __b1:
-    // [6] (byte~) main::$9 ← (byte) main::i#2 << (byte) 1 -- vbuaa=vbuxx_rol_1 
+    // [6] (byte~) main::$6 ← (byte) main::i#2 << (byte) 1 -- vbuaa=vbuxx_rol_1 
     txa
     asl
-    // [7] (byte~) main::$4 ← (byte~) main::$9 + (byte) main::i#2 -- vbuz1=vbuaa_plus_vbuxx 
+    // [7] (byte~) main::$4 ← (byte~) main::$6 + (byte) main::i#2 -- vbuz1=vbuaa_plus_vbuxx 
     stx.z $ff
     clc
     adc.z $ff
@@ -523,7 +507,7 @@ FINAL SYMBOL TABLE
 (byte~) main::$0 reg byte a 22.0
 (byte~) main::$1 reg byte a 22.0
 (byte~) main::$4 zp[1]:3 7.333333333333333
-(byte~) main::$9 reg byte a 22.0
+(byte~) main::$6 reg byte a 22.0
 (label) main::@1
 (label) main::@return
 (const byte*) main::SCREEN = (byte*) 1024
@@ -539,7 +523,7 @@ FINAL SYMBOL TABLE
 
 reg byte x [ main::i#2 main::i#1 ]
 zp[1]:2 [ main::idx#4 main::idx#3 main::idx#1 main::idx#2 ]
-reg byte a [ main::$9 ]
+reg byte a [ main::$6 ]
 zp[1]:3 [ main::$4 ]
 reg byte a [ main::$0 ]
 reg byte a [ main::$1 ]
@@ -581,10 +565,10 @@ main: {
     // main::@1
   __b1:
     // SCREEN[idx++] = points[i].x
-    // [6] (byte~) main::$9 ← (byte) main::i#2 << (byte) 1 -- vbuaa=vbuxx_rol_1 
+    // [6] (byte~) main::$6 ← (byte) main::i#2 << (byte) 1 -- vbuaa=vbuxx_rol_1 
     txa
     asl
-    // [7] (byte~) main::$4 ← (byte~) main::$9 + (byte) main::i#2 -- vbuz1=vbuaa_plus_vbuxx 
+    // [7] (byte~) main::$4 ← (byte~) main::$6 + (byte) main::i#2 -- vbuz1=vbuaa_plus_vbuxx 
     stx.z $ff
     clc
     adc.z $ff
diff --git a/src/test/ref/initializer-3.sym b/src/test/ref/initializer-3.sym
index 088b572d4..3763c1f24 100644
--- a/src/test/ref/initializer-3.sym
+++ b/src/test/ref/initializer-3.sym
@@ -8,7 +8,7 @@
 (byte~) main::$0 reg byte a 22.0
 (byte~) main::$1 reg byte a 22.0
 (byte~) main::$4 zp[1]:3 7.333333333333333
-(byte~) main::$9 reg byte a 22.0
+(byte~) main::$6 reg byte a 22.0
 (label) main::@1
 (label) main::@return
 (const byte*) main::SCREEN = (byte*) 1024
@@ -24,7 +24,7 @@
 
 reg byte x [ main::i#2 main::i#1 ]
 zp[1]:2 [ main::idx#4 main::idx#3 main::idx#1 main::idx#2 ]
-reg byte a [ main::$9 ]
+reg byte a [ main::$6 ]
 zp[1]:3 [ main::$4 ]
 reg byte a [ main::$0 ]
 reg byte a [ main::$1 ]
diff --git a/src/test/ref/millfork-benchmarks/linkedlist-kc.log b/src/test/ref/millfork-benchmarks/linkedlist-kc.log
index 95a1a27ee..c77135642 100644
--- a/src/test/ref/millfork-benchmarks/linkedlist-kc.log
+++ b/src/test/ref/millfork-benchmarks/linkedlist-kc.log
@@ -8,10 +8,10 @@ Fixing pointer addition (word*~) bsearch16u::$1 ← (word*) bsearch16u::items -
 Fixing pointer addition (struct node*~) alloc::$0 ← (const struct node*) heap + (word) free_
 Fixing pointer array-indexing *((word*) utoa::digit_values + (byte) utoa::digit)
 Fixing pointer array-indexing *((dword*) ultoa::digit_values + (byte) ultoa::digit)
-Rewriting struct pointer member access *((struct node*) prepend::new).next
-Rewriting struct pointer member access *((struct node*) prepend::new).value
-Rewriting struct pointer member access *((struct node*) sum::current).value
-Rewriting struct pointer member access *((struct node*) sum::current).next
+Replacing struct member reference *((struct node*) prepend::new).next with member unwinding reference *((struct node**~) prepend::$1)
+Replacing struct member reference *((struct node*) prepend::new).value with member unwinding reference *((word*~) prepend::$2)
+Replacing struct member reference *((struct node*) sum::current).value with member unwinding reference *((word*~) sum::$0)
+Replacing struct member reference *((struct node*) sum::current).next with member unwinding reference *((struct node**~) sum::$1)
 Warning! Adding boolean cast to non-boolean condition *((byte*) strcpy::src)
 Warning! Adding boolean cast to non-boolean condition *((byte*) strlen::str)
 Warning! Adding boolean cast to non-boolean condition *((byte*) print_str_lines::str)
diff --git a/src/test/ref/parse-negated-struct-ref.log b/src/test/ref/parse-negated-struct-ref.log
index f1150ac31..a284ca0c1 100644
--- a/src/test/ref/parse-negated-struct-ref.log
+++ b/src/test/ref/parse-negated-struct-ref.log
@@ -1,5 +1,5 @@
 Setting inferred volatile on symbol affected by address-of (struct A*) main::a ← &(struct A) aa
-Rewriting struct pointer member access *((struct A*) main::a).b
+Replacing struct member reference *((struct A*) main::a).b with member unwinding reference *((byte*~) main::$2)
 Warning! Adding boolean cast to non-boolean sub-expression *((byte*~) main::$2)
 Identified constant variable (struct A*) main::a
 
diff --git a/src/test/ref/struct-14.log b/src/test/ref/struct-14.log
index 15a07d538..cff293f28 100644
--- a/src/test/ref/struct-14.log
+++ b/src/test/ref/struct-14.log
@@ -2,10 +2,10 @@ Fixing pointer array-indexing *((const struct Point*) points + (number) 0)
 Fixing pointer array-indexing *((const struct Point*) points + (number) 0)
 Fixing pointer array-indexing *((const struct Point*) points + (number) 0)
 Fixing pointer array-indexing *((const struct Point*) points + (number) 0)
-Rewriting struct pointer member access *((const struct Point*) points + (number~) main::$0).x
-Rewriting struct pointer member access *((const struct Point*) points + (number~) main::$1).y
-Rewriting struct pointer member access *((const struct Point*) points + (number~) main::$2).x
-Rewriting struct pointer member access *((const struct Point*) points + (number~) main::$3).y
+Replacing struct member reference *((const struct Point*) points + (number~) main::$0).x with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$0)
+Replacing struct member reference *((const struct Point*) points + (number~) main::$1).y with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$1)
+Replacing struct member reference *((const struct Point*) points + (number~) main::$2).x with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$2)
+Replacing struct member reference *((const struct Point*) points + (number~) main::$3).y with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$3)
 
 CONTROL FLOW GRAPH SSA
 @begin: scope:[]  from
@@ -14,17 +14,13 @@ CONTROL FLOW GRAPH SSA
 (void()) main()
 main: scope:[main]  from @1
   (number~) main::$0 ← (number) 0 * (const byte) SIZEOF_STRUCT_POINT
-  (byte*~) main::$4 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
-  *((byte*~) main::$4 + (number~) main::$0) ← (number) 2
+  *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$0) ← (number) 2
   (number~) main::$1 ← (number) 0 * (const byte) SIZEOF_STRUCT_POINT
-  (byte*~) main::$5 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
-  *((byte*~) main::$5 + (number~) main::$1) ← (number) 3
+  *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$1) ← (number) 3
   (number~) main::$2 ← (number) 0 * (const byte) SIZEOF_STRUCT_POINT
-  (byte*~) main::$6 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
-  *((const byte*) SCREEN + (number) 0) ← *((byte*~) main::$6 + (number~) main::$2)
+  *((const byte*) SCREEN + (number) 0) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$2)
   (number~) main::$3 ← (number) 0 * (const byte) SIZEOF_STRUCT_POINT
-  (byte*~) main::$7 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
-  *((const byte*) SCREEN + (number) 1) ← *((byte*~) main::$7 + (number~) main::$3)
+  *((const byte*) SCREEN + (number) 1) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$3)
   to:main::@return
 main::@return: scope:[main]  from main
   return 
@@ -52,28 +48,24 @@ SYMBOL TABLE SSA
 (number~) main::$1
 (number~) main::$2
 (number~) main::$3
-(byte*~) main::$4
-(byte*~) main::$5
-(byte*~) main::$6
-(byte*~) main::$7
 (label) main::@return
 (const struct Point*) points[(number) 1]  = { fill( 1, 0) }
 
 Adding number conversion cast (unumber) 0 in (number~) main::$0 ← (number) 0 * (const byte) SIZEOF_STRUCT_POINT
 Adding number conversion cast (unumber) main::$0 in (number~) main::$0 ← (unumber)(number) 0 * (const byte) SIZEOF_STRUCT_POINT
-Adding number conversion cast (unumber) 2 in *((byte*~) main::$4 + (unumber~) main::$0) ← (number) 2
+Adding number conversion cast (unumber) 2 in *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (unumber~) main::$0) ← (number) 2
 Adding number conversion cast (unumber) 0 in (number~) main::$1 ← (number) 0 * (const byte) SIZEOF_STRUCT_POINT
 Adding number conversion cast (unumber) main::$1 in (number~) main::$1 ← (unumber)(number) 0 * (const byte) SIZEOF_STRUCT_POINT
-Adding number conversion cast (unumber) 3 in *((byte*~) main::$5 + (unumber~) main::$1) ← (number) 3
+Adding number conversion cast (unumber) 3 in *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (unumber~) main::$1) ← (number) 3
 Adding number conversion cast (unumber) 0 in (number~) main::$2 ← (number) 0 * (const byte) SIZEOF_STRUCT_POINT
 Adding number conversion cast (unumber) main::$2 in (number~) main::$2 ← (unumber)(number) 0 * (const byte) SIZEOF_STRUCT_POINT
-Adding number conversion cast (unumber) 0 in *((const byte*) SCREEN + (number) 0) ← *((byte*~) main::$6 + (unumber~) main::$2)
+Adding number conversion cast (unumber) 0 in *((const byte*) SCREEN + (number) 0) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (unumber~) main::$2)
 Adding number conversion cast (unumber) 0 in (number~) main::$3 ← (number) 0 * (const byte) SIZEOF_STRUCT_POINT
 Adding number conversion cast (unumber) main::$3 in (number~) main::$3 ← (unumber)(number) 0 * (const byte) SIZEOF_STRUCT_POINT
-Adding number conversion cast (unumber) 1 in *((const byte*) SCREEN + (number) 1) ← *((byte*~) main::$7 + (unumber~) main::$3)
+Adding number conversion cast (unumber) 1 in *((const byte*) SCREEN + (number) 1) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (unumber~) main::$3)
 Successful SSA optimization PassNAddNumberTypeConversions
-Inlining cast *((byte*~) main::$4 + (unumber~) main::$0) ← (unumber)(number) 2
-Inlining cast *((byte*~) main::$5 + (unumber~) main::$1) ← (unumber)(number) 3
+Inlining cast *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (unumber~) main::$0) ← (unumber)(number) 2
+Inlining cast *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (unumber~) main::$1) ← (unumber)(number) 3
 Successful SSA optimization Pass2InlineCast
 Simplifying constant pointer cast (byte*) 1024
 Simplifying constant integer cast 0
@@ -99,35 +91,27 @@ Inferred type updated to byte in (unumber~) main::$1 ← (byte) 0 * (const byte)
 Inferred type updated to byte in (unumber~) main::$2 ← (byte) 0 * (const byte) SIZEOF_STRUCT_POINT
 Inferred type updated to byte in (unumber~) main::$3 ← (byte) 0 * (const byte) SIZEOF_STRUCT_POINT
 Constant right-side identified [0] (byte~) main::$0 ← (byte) 0 * (const byte) SIZEOF_STRUCT_POINT
-Constant right-side identified [1] (byte*~) main::$4 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
-Constant right-side identified [3] (byte~) main::$1 ← (byte) 0 * (const byte) SIZEOF_STRUCT_POINT
-Constant right-side identified [4] (byte*~) main::$5 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
-Constant right-side identified [6] (byte~) main::$2 ← (byte) 0 * (const byte) SIZEOF_STRUCT_POINT
-Constant right-side identified [7] (byte*~) main::$6 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
-Constant right-side identified [9] (byte~) main::$3 ← (byte) 0 * (const byte) SIZEOF_STRUCT_POINT
-Constant right-side identified [10] (byte*~) main::$7 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
+Constant right-side identified [2] (byte~) main::$1 ← (byte) 0 * (const byte) SIZEOF_STRUCT_POINT
+Constant right-side identified [4] (byte~) main::$2 ← (byte) 0 * (const byte) SIZEOF_STRUCT_POINT
+Constant right-side identified [6] (byte~) main::$3 ← (byte) 0 * (const byte) SIZEOF_STRUCT_POINT
 Successful SSA optimization Pass2ConstantRValueConsolidation
 Constant (const byte) main::$0 = 0*SIZEOF_STRUCT_POINT
-Constant (const byte*) main::$4 = (byte*)points+OFFSET_STRUCT_POINT_X
 Constant (const byte) main::$1 = 0*SIZEOF_STRUCT_POINT
-Constant (const byte*) main::$5 = (byte*)points+OFFSET_STRUCT_POINT_Y
 Constant (const byte) main::$2 = 0*SIZEOF_STRUCT_POINT
-Constant (const byte*) main::$6 = (byte*)points+OFFSET_STRUCT_POINT_X
 Constant (const byte) main::$3 = 0*SIZEOF_STRUCT_POINT
-Constant (const byte*) main::$7 = (byte*)points+OFFSET_STRUCT_POINT_Y
 Successful SSA optimization Pass2ConstantIdentification
 Simplifying constant evaluating to zero (byte) 0*(const byte) SIZEOF_STRUCT_POINT in 
 Simplifying constant evaluating to zero (byte) 0*(const byte) SIZEOF_STRUCT_POINT in 
 Simplifying constant evaluating to zero (byte) 0*(const byte) SIZEOF_STRUCT_POINT in 
 Simplifying constant evaluating to zero (byte) 0*(const byte) SIZEOF_STRUCT_POINT in 
 Successful SSA optimization PassNSimplifyConstantZero
-Simplifying expression containing zero (byte*)points in 
-Simplifying expression containing zero (byte*)points in 
-Simplifying expression containing zero main::$4 in [2] *((const byte*) main::$4 + (const byte) main::$0) ← (byte) 2
-Simplifying expression containing zero main::$5 in [5] *((const byte*) main::$5 + (const byte) main::$1) ← (byte) 3
-Simplifying expression containing zero main::$6 in [8] *((const byte*) SCREEN + (byte) 0) ← *((const byte*) main::$6 + (const byte) main::$2)
-Simplifying expression containing zero SCREEN in [8] *((const byte*) SCREEN + (byte) 0) ← *((const byte*) main::$6)
-Simplifying expression containing zero main::$7 in [11] *((const byte*) SCREEN + (byte) 1) ← *((const byte*) main::$7 + (const byte) main::$3)
+Simplifying expression containing zero (byte*)points+OFFSET_STRUCT_POINT_X in [1] *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (const byte) main::$0) ← (byte) 2
+Simplifying expression containing zero (byte*)points in [1] *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X) ← (byte) 2
+Simplifying expression containing zero (byte*)points+OFFSET_STRUCT_POINT_Y in [3] *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (const byte) main::$1) ← (byte) 3
+Simplifying expression containing zero (byte*)points+OFFSET_STRUCT_POINT_X in [5] *((const byte*) SCREEN + (byte) 0) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (const byte) main::$2)
+Simplifying expression containing zero (byte*)points in [5] *((const byte*) SCREEN + (byte) 0) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X)
+Simplifying expression containing zero SCREEN in [5] *((const byte*) SCREEN + (byte) 0) ← *((byte*)(const struct Point*) points)
+Simplifying expression containing zero (byte*)points+OFFSET_STRUCT_POINT_Y in [7] *((const byte*) SCREEN + (byte) 1) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (const byte) main::$3)
 Successful SSA optimization PassNSimplifyExpressionWithZero
 Eliminating unused constant (const byte) main::$0
 Eliminating unused constant (const byte) main::$1
@@ -136,11 +120,6 @@ Eliminating unused constant (const byte) main::$3
 Eliminating unused constant (const byte) SIZEOF_STRUCT_POINT
 Eliminating unused constant (const byte) OFFSET_STRUCT_POINT_X
 Successful SSA optimization PassNEliminateUnusedVars
-Constant inlined main::$5 = (byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y
-Constant inlined main::$6 = (byte*)(const struct Point*) points
-Constant inlined main::$4 = (byte*)(const struct Point*) points
-Constant inlined main::$7 = (byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y
-Successful SSA optimization Pass2ConstantInlining
 Consolidated array index constant in *(SCREEN+1)
 Successful SSA optimization Pass2ConstantAdditionElimination
 Adding NOP phi() at start of @begin
diff --git a/src/test/ref/struct-17.asm b/src/test/ref/struct-17.asm
index 0f7a48ec2..69a061e8e 100644
--- a/src/test/ref/struct-17.asm
+++ b/src/test/ref/struct-17.asm
@@ -4,8 +4,8 @@
 .pc = $80d "Program"
   .label SCREEN = $400
   .const SIZEOF_STRUCT_VECTOR = 4
-  .const OFFSET_STRUCT_VECTOR_Q = 2
   .const OFFSET_STRUCT_POINT_Y = 1
+  .const OFFSET_STRUCT_VECTOR_Q = 2
 main: {
     .label v = 2
     ldy #SIZEOF_STRUCT_VECTOR
diff --git a/src/test/ref/struct-17.log b/src/test/ref/struct-17.log
index 55447587e..9a79758cd 100644
--- a/src/test/ref/struct-17.log
+++ b/src/test/ref/struct-17.log
@@ -1,20 +1,12 @@
 Adding value bulk copy *(&(struct Vector) main::v) ← memset(struct Vector, (const byte) SIZEOF_STRUCT_VECTOR)
-Replacing struct member reference (struct Vector) main::v.p with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P)
-Replacing struct member reference (struct Vector) main::v.p with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P)
-Replacing struct member reference (struct Vector) main::v.q with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q)
-Replacing struct member reference (struct Vector) main::v.q with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q)
-Replacing struct member reference (struct Vector) main::v.p with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P)
-Replacing struct member reference (struct Vector) main::v.p with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P)
-Replacing struct member reference (struct Vector) main::v.q with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q)
-Replacing struct member reference (struct Vector) main::v.q with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q)
-Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P).x
-Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P).y
-Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q).x
-Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q).y
-Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P).x
-Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P).y
-Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q).x
-Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q).y
+Replacing struct member reference (struct Vector) main::v.p.x with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
+Replacing struct member reference (struct Vector) main::v.p.y with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
+Replacing struct member reference (struct Vector) main::v.q.x with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
+Replacing struct member reference (struct Vector) main::v.q.y with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
+Replacing struct member reference (struct Vector) main::v.p.x with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
+Replacing struct member reference (struct Vector) main::v.p.y with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
+Replacing struct member reference (struct Vector) main::v.q.x with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
+Replacing struct member reference (struct Vector) main::v.q.y with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
 
 CONTROL FLOW GRAPH SSA
 @begin: scope:[]  from
@@ -24,22 +16,14 @@ CONTROL FLOW GRAPH SSA
 main: scope:[main]  from @1
   *(&(struct Vector) main::v) ← memset(struct Vector, (const byte) SIZEOF_STRUCT_VECTOR)
   (struct Vector) main::v ← struct-unwound {*(&(struct Vector) main::v)}
-  (byte*~) main::$0 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_X
-  *((byte*~) main::$0) ← (number) 2
-  (byte*~) main::$1 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_Y
-  *((byte*~) main::$1) ← (number) 3
-  (byte*~) main::$2 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_X
-  *((byte*~) main::$2) ← (number) 4
-  (byte*~) main::$3 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_Y
-  *((byte*~) main::$3) ← (number) 5
-  (byte*~) main::$4 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_X
-  *((const byte*) SCREEN + (number) 0) ← *((byte*~) main::$4)
-  (byte*~) main::$5 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_Y
-  *((const byte*) SCREEN + (number) 1) ← *((byte*~) main::$5)
-  (byte*~) main::$6 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_X
-  *((const byte*) SCREEN + (number) 2) ← *((byte*~) main::$6)
-  (byte*~) main::$7 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_Y
-  *((const byte*) SCREEN + (number) 3) ← *((byte*~) main::$7)
+  *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X) ← (number) 2
+  *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y) ← (number) 3
+  *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X) ← (number) 4
+  *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y) ← (number) 5
+  *((const byte*) SCREEN + (number) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
+  *((const byte*) SCREEN + (number) 1) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
+  *((const byte*) SCREEN + (number) 2) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
+  *((const byte*) SCREEN + (number) 3) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
   to:main::@return
 main::@return: scope:[main]  from main
   return 
@@ -67,30 +51,22 @@ SYMBOL TABLE SSA
 (struct Point) Vector::p
 (struct Point) Vector::q
 (void()) main()
-(byte*~) main::$0
-(byte*~) main::$1
-(byte*~) main::$2
-(byte*~) main::$3
-(byte*~) main::$4
-(byte*~) main::$5
-(byte*~) main::$6
-(byte*~) main::$7
 (label) main::@return
 (struct Vector) main::v loadstore
 
-Adding number conversion cast (unumber) 2 in *((byte*~) main::$0) ← (number) 2
-Adding number conversion cast (unumber) 3 in *((byte*~) main::$1) ← (number) 3
-Adding number conversion cast (unumber) 4 in *((byte*~) main::$2) ← (number) 4
-Adding number conversion cast (unumber) 5 in *((byte*~) main::$3) ← (number) 5
-Adding number conversion cast (unumber) 0 in *((const byte*) SCREEN + (number) 0) ← *((byte*~) main::$4)
-Adding number conversion cast (unumber) 1 in *((const byte*) SCREEN + (number) 1) ← *((byte*~) main::$5)
-Adding number conversion cast (unumber) 2 in *((const byte*) SCREEN + (number) 2) ← *((byte*~) main::$6)
-Adding number conversion cast (unumber) 3 in *((const byte*) SCREEN + (number) 3) ← *((byte*~) main::$7)
+Adding number conversion cast (unumber) 2 in *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X) ← (number) 2
+Adding number conversion cast (unumber) 3 in *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y) ← (number) 3
+Adding number conversion cast (unumber) 4 in *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X) ← (number) 4
+Adding number conversion cast (unumber) 5 in *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y) ← (number) 5
+Adding number conversion cast (unumber) 0 in *((const byte*) SCREEN + (number) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
+Adding number conversion cast (unumber) 1 in *((const byte*) SCREEN + (number) 1) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
+Adding number conversion cast (unumber) 2 in *((const byte*) SCREEN + (number) 2) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
+Adding number conversion cast (unumber) 3 in *((const byte*) SCREEN + (number) 3) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
 Successful SSA optimization PassNAddNumberTypeConversions
-Inlining cast *((byte*~) main::$0) ← (unumber)(number) 2
-Inlining cast *((byte*~) main::$1) ← (unumber)(number) 3
-Inlining cast *((byte*~) main::$2) ← (unumber)(number) 4
-Inlining cast *((byte*~) main::$3) ← (unumber)(number) 5
+Inlining cast *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X) ← (unumber)(number) 2
+Inlining cast *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y) ← (unumber)(number) 3
+Inlining cast *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X) ← (unumber)(number) 4
+Inlining cast *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y) ← (unumber)(number) 5
 Successful SSA optimization Pass2InlineCast
 Simplifying constant pointer cast (byte*) 1024
 Simplifying constant integer cast 2
@@ -112,46 +88,19 @@ Finalized unsigned number type (byte) 2
 Finalized unsigned number type (byte) 3
 Successful SSA optimization PassNFinalizeNumberTypeConversions
 Removing C-classic struct-unwound assignment [1] (struct Vector) main::v ← struct-unwound {*(&(struct Vector) main::v)}
-Constant right-side identified [2] (byte*~) main::$0 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_X
-Constant right-side identified [4] (byte*~) main::$1 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_Y
-Constant right-side identified [6] (byte*~) main::$2 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_X
-Constant right-side identified [8] (byte*~) main::$3 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_Y
-Constant right-side identified [10] (byte*~) main::$4 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_X
-Constant right-side identified [12] (byte*~) main::$5 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_Y
-Constant right-side identified [14] (byte*~) main::$6 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_X
-Constant right-side identified [16] (byte*~) main::$7 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_Y
-Successful SSA optimization Pass2ConstantRValueConsolidation
-Constant (const byte*) main::$0 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P+OFFSET_STRUCT_POINT_X
-Constant (const byte*) main::$1 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P+OFFSET_STRUCT_POINT_Y
-Constant (const byte*) main::$2 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q+OFFSET_STRUCT_POINT_X
-Constant (const byte*) main::$3 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q+OFFSET_STRUCT_POINT_Y
-Constant (const byte*) main::$4 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P+OFFSET_STRUCT_POINT_X
-Constant (const byte*) main::$5 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P+OFFSET_STRUCT_POINT_Y
-Constant (const byte*) main::$6 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q+OFFSET_STRUCT_POINT_X
-Constant (const byte*) main::$7 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q+OFFSET_STRUCT_POINT_Y
-Successful SSA optimization Pass2ConstantIdentification
-Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P in 
-Simplifying expression containing zero (struct Point*)&main::v in 
-Simplifying expression containing zero (struct Point*)&main::v in 
-Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q in 
-Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P in 
-Simplifying expression containing zero (struct Point*)&main::v in 
-Simplifying expression containing zero (struct Point*)&main::v in 
-Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q in 
-Simplifying expression containing zero SCREEN in [11] *((const byte*) SCREEN + (byte) 0) ← *((const byte*) main::$4)
+Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P in [2] *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X) ← (byte) 2
+Simplifying expression containing zero (struct Point*)&main::v in [2] *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P) ← (byte) 2
+Simplifying expression containing zero (struct Point*)&main::v in [3] *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y) ← (byte) 3
+Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q in [4] *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X) ← (byte) 4
+Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P in [6] *((const byte*) SCREEN + (byte) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
+Simplifying expression containing zero (struct Point*)&main::v in [6] *((const byte*) SCREEN + (byte) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P)
+Simplifying expression containing zero SCREEN in [6] *((const byte*) SCREEN + (byte) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v)
+Simplifying expression containing zero (struct Point*)&main::v in [7] *((const byte*) SCREEN + (byte) 1) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
+Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q in [8] *((const byte*) SCREEN + (byte) 2) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
 Successful SSA optimization PassNSimplifyExpressionWithZero
 Eliminating unused constant (const byte) OFFSET_STRUCT_VECTOR_P
 Eliminating unused constant (const byte) OFFSET_STRUCT_POINT_X
 Successful SSA optimization PassNEliminateUnusedVars
-Constant inlined main::$1 = (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_POINT_Y
-Constant inlined main::$2 = (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q
-Constant inlined main::$0 = (byte*)(struct Point*)&(struct Vector) main::v
-Constant inlined main::$5 = (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_POINT_Y
-Constant inlined main::$6 = (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q
-Constant inlined main::$3 = (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y
-Constant inlined main::$4 = (byte*)(struct Point*)&(struct Vector) main::v
-Constant inlined main::$7 = (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y
-Successful SSA optimization Pass2ConstantInlining
 Consolidated array index constant in *(SCREEN+1)
 Consolidated array index constant in *(SCREEN+2)
 Consolidated array index constant in *(SCREEN+3)
@@ -223,8 +172,8 @@ Target platform is c64basic / MOS6502X
   // Global Constants & labels
   .label SCREEN = $400
   .const SIZEOF_STRUCT_VECTOR = 4
-  .const OFFSET_STRUCT_VECTOR_Q = 2
   .const OFFSET_STRUCT_POINT_Y = 1
+  .const OFFSET_STRUCT_VECTOR_Q = 2
   // @begin
 __bbegin:
   // [1] phi from @begin to @1 [phi:@begin->@1]
@@ -314,8 +263,8 @@ ASSEMBLER BEFORE OPTIMIZATION
   // Global Constants & labels
   .label SCREEN = $400
   .const SIZEOF_STRUCT_VECTOR = 4
-  .const OFFSET_STRUCT_VECTOR_Q = 2
   .const OFFSET_STRUCT_POINT_Y = 1
+  .const OFFSET_STRUCT_VECTOR_Q = 2
   // @begin
 __bbegin:
   // [1] phi from @begin to @1 [phi:@begin->@1]
@@ -422,8 +371,8 @@ Score: 73
   // Global Constants & labels
   .label SCREEN = $400
   .const SIZEOF_STRUCT_VECTOR = 4
-  .const OFFSET_STRUCT_VECTOR_Q = 2
   .const OFFSET_STRUCT_POINT_Y = 1
+  .const OFFSET_STRUCT_VECTOR_Q = 2
   // @begin
   // [1] phi from @begin to @1 [phi:@begin->@1]
   // @1
diff --git a/src/test/ref/struct-18.asm b/src/test/ref/struct-18.asm
index 60cd05a24..24fe24d46 100644
--- a/src/test/ref/struct-18.asm
+++ b/src/test/ref/struct-18.asm
@@ -4,8 +4,8 @@
 .pc = $80d "Program"
   .label SCREEN = $400
   .const SIZEOF_STRUCT_VECTOR = 4
-  .const OFFSET_STRUCT_VECTOR_Q = 2
   .const OFFSET_STRUCT_POINT_Y = 1
+  .const OFFSET_STRUCT_VECTOR_Q = 2
 main: {
     .label v = 2
     ldy #SIZEOF_STRUCT_VECTOR
diff --git a/src/test/ref/struct-18.log b/src/test/ref/struct-18.log
index e973091f1..b6403b949 100644
--- a/src/test/ref/struct-18.log
+++ b/src/test/ref/struct-18.log
@@ -1,12 +1,8 @@
 Adding value bulk copy *(&(struct Vector) main::v) ← memcpy(*(&(const struct Vector) $0), struct Vector, (const byte) SIZEOF_STRUCT_VECTOR)
-Replacing struct member reference (struct Vector) main::v.p with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P)
-Replacing struct member reference (struct Vector) main::v.p with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P)
-Replacing struct member reference (struct Vector) main::v.q with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q)
-Replacing struct member reference (struct Vector) main::v.q with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q)
-Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P).x
-Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P).y
-Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q).x
-Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q).y
+Replacing struct member reference (struct Vector) main::v.p.x with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
+Replacing struct member reference (struct Vector) main::v.p.y with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
+Replacing struct member reference (struct Vector) main::v.q.x with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
+Replacing struct member reference (struct Vector) main::v.q.y with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
 
 CONTROL FLOW GRAPH SSA
 @begin: scope:[]  from
@@ -16,14 +12,10 @@ CONTROL FLOW GRAPH SSA
 main: scope:[main]  from @1
   *(&(struct Vector) main::v) ← memcpy(*(&(const struct Vector) $0), struct Vector, (const byte) SIZEOF_STRUCT_VECTOR)
   (struct Vector) main::v ← struct-unwound {*(&(struct Vector) main::v)}
-  (byte*~) main::$0 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_X
-  *((const byte*) SCREEN + (number) 0) ← *((byte*~) main::$0)
-  (byte*~) main::$1 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_Y
-  *((const byte*) SCREEN + (number) 1) ← *((byte*~) main::$1)
-  (byte*~) main::$2 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_X
-  *((const byte*) SCREEN + (number) 2) ← *((byte*~) main::$2)
-  (byte*~) main::$3 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_Y
-  *((const byte*) SCREEN + (number) 3) ← *((byte*~) main::$3)
+  *((const byte*) SCREEN + (number) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
+  *((const byte*) SCREEN + (number) 1) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
+  *((const byte*) SCREEN + (number) 2) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
+  *((const byte*) SCREEN + (number) 3) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
   to:main::@return
 main::@return: scope:[main]  from main
   return 
@@ -52,17 +44,13 @@ SYMBOL TABLE SSA
 (struct Point) Vector::p
 (struct Point) Vector::q
 (void()) main()
-(byte*~) main::$0
-(byte*~) main::$1
-(byte*~) main::$2
-(byte*~) main::$3
 (label) main::@return
 (struct Vector) main::v loadstore
 
-Adding number conversion cast (unumber) 0 in *((const byte*) SCREEN + (number) 0) ← *((byte*~) main::$0)
-Adding number conversion cast (unumber) 1 in *((const byte*) SCREEN + (number) 1) ← *((byte*~) main::$1)
-Adding number conversion cast (unumber) 2 in *((const byte*) SCREEN + (number) 2) ← *((byte*~) main::$2)
-Adding number conversion cast (unumber) 3 in *((const byte*) SCREEN + (number) 3) ← *((byte*~) main::$3)
+Adding number conversion cast (unumber) 0 in *((const byte*) SCREEN + (number) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
+Adding number conversion cast (unumber) 1 in *((const byte*) SCREEN + (number) 1) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
+Adding number conversion cast (unumber) 2 in *((const byte*) SCREEN + (number) 2) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
+Adding number conversion cast (unumber) 3 in *((const byte*) SCREEN + (number) 3) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
 Successful SSA optimization PassNAddNumberTypeConversions
 Simplifying constant pointer cast (byte*) 1024
 Simplifying constant integer cast 0
@@ -76,30 +64,15 @@ Finalized unsigned number type (byte) 2
 Finalized unsigned number type (byte) 3
 Successful SSA optimization PassNFinalizeNumberTypeConversions
 Removing C-classic struct-unwound assignment [1] (struct Vector) main::v ← struct-unwound {*(&(struct Vector) main::v)}
-Constant right-side identified [2] (byte*~) main::$0 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_X
-Constant right-side identified [4] (byte*~) main::$1 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_Y
-Constant right-side identified [6] (byte*~) main::$2 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_X
-Constant right-side identified [8] (byte*~) main::$3 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_Y
-Successful SSA optimization Pass2ConstantRValueConsolidation
-Constant (const byte*) main::$0 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P+OFFSET_STRUCT_POINT_X
-Constant (const byte*) main::$1 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P+OFFSET_STRUCT_POINT_Y
-Constant (const byte*) main::$2 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q+OFFSET_STRUCT_POINT_X
-Constant (const byte*) main::$3 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q+OFFSET_STRUCT_POINT_Y
-Successful SSA optimization Pass2ConstantIdentification
-Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P in 
-Simplifying expression containing zero (struct Point*)&main::v in 
-Simplifying expression containing zero (struct Point*)&main::v in 
-Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q in 
-Simplifying expression containing zero SCREEN in [3] *((const byte*) SCREEN + (byte) 0) ← *((const byte*) main::$0)
+Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P in [2] *((const byte*) SCREEN + (byte) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
+Simplifying expression containing zero (struct Point*)&main::v in [2] *((const byte*) SCREEN + (byte) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P)
+Simplifying expression containing zero SCREEN in [2] *((const byte*) SCREEN + (byte) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v)
+Simplifying expression containing zero (struct Point*)&main::v in [3] *((const byte*) SCREEN + (byte) 1) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
+Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q in [4] *((const byte*) SCREEN + (byte) 2) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
 Successful SSA optimization PassNSimplifyExpressionWithZero
 Eliminating unused constant (const byte) OFFSET_STRUCT_VECTOR_P
 Eliminating unused constant (const byte) OFFSET_STRUCT_POINT_X
 Successful SSA optimization PassNEliminateUnusedVars
-Constant inlined main::$3 = (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y
-Constant inlined main::$1 = (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_POINT_Y
-Constant inlined main::$2 = (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q
-Constant inlined main::$0 = (byte*)(struct Point*)&(struct Vector) main::v
-Successful SSA optimization Pass2ConstantInlining
 Consolidated array index constant in *(SCREEN+1)
 Consolidated array index constant in *(SCREEN+2)
 Consolidated array index constant in *(SCREEN+3)
@@ -167,8 +140,8 @@ Target platform is c64basic / MOS6502X
   // Global Constants & labels
   .label SCREEN = $400
   .const SIZEOF_STRUCT_VECTOR = 4
-  .const OFFSET_STRUCT_VECTOR_Q = 2
   .const OFFSET_STRUCT_POINT_Y = 1
+  .const OFFSET_STRUCT_VECTOR_Q = 2
   // @begin
 __bbegin:
   // [1] phi from @begin to @1 [phi:@begin->@1]
@@ -243,8 +216,8 @@ ASSEMBLER BEFORE OPTIMIZATION
   // Global Constants & labels
   .label SCREEN = $400
   .const SIZEOF_STRUCT_VECTOR = 4
-  .const OFFSET_STRUCT_VECTOR_Q = 2
   .const OFFSET_STRUCT_POINT_Y = 1
+  .const OFFSET_STRUCT_VECTOR_Q = 2
   // @begin
 __bbegin:
   // [1] phi from @begin to @1 [phi:@begin->@1]
@@ -341,8 +314,8 @@ Score: 53
   // Global Constants & labels
   .label SCREEN = $400
   .const SIZEOF_STRUCT_VECTOR = 4
-  .const OFFSET_STRUCT_VECTOR_Q = 2
   .const OFFSET_STRUCT_POINT_Y = 1
+  .const OFFSET_STRUCT_VECTOR_Q = 2
   // @begin
   // [1] phi from @begin to @1 [phi:@begin->@1]
   // @1
diff --git a/src/test/ref/struct-19.log b/src/test/ref/struct-19.log
index 9c8cba783..59b8980cf 100644
--- a/src/test/ref/struct-19.log
+++ b/src/test/ref/struct-19.log
@@ -3,14 +3,10 @@ Adding value bulk copy *(&(struct Point) main::p1) ← memcpy(*(&(const struct P
 Adding value bulk copy *(&(struct Point) main::p2) ← memcpy(*(&(const struct Point) $1), struct Point, (const byte) SIZEOF_STRUCT_POINT)
 Adding value bulk copy *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P) ← memcpy(*(&(struct Point) main::p1), struct Point, (const byte) SIZEOF_STRUCT_POINT)
 Adding value bulk copy *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q) ← memcpy(*(&(struct Point) main::p2), struct Point, (const byte) SIZEOF_STRUCT_POINT)
-Replacing struct member reference (struct Vector) main::v.p with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P)
-Replacing struct member reference (struct Vector) main::v.p with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P)
-Replacing struct member reference (struct Vector) main::v.q with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q)
-Replacing struct member reference (struct Vector) main::v.q with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q)
-Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P).x
-Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P).y
-Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q).x
-Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q).y
+Replacing struct member reference (struct Vector) main::v.p.x with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
+Replacing struct member reference (struct Vector) main::v.p.y with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
+Replacing struct member reference (struct Vector) main::v.q.x with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
+Replacing struct member reference (struct Vector) main::v.q.y with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
 
 CONTROL FLOW GRAPH SSA
 @begin: scope:[]  from
@@ -26,14 +22,10 @@ main: scope:[main]  from @1
   (struct Point) main::p2 ← struct-unwound {*(&(struct Point) main::p2)}
   *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P) ← memcpy(*(&(struct Point) main::p1), struct Point, (const byte) SIZEOF_STRUCT_POINT)
   *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q) ← memcpy(*(&(struct Point) main::p2), struct Point, (const byte) SIZEOF_STRUCT_POINT)
-  (byte*~) main::$0 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_X
-  *((const byte*) SCREEN + (number) 0) ← *((byte*~) main::$0)
-  (byte*~) main::$1 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_Y
-  *((const byte*) SCREEN + (number) 1) ← *((byte*~) main::$1)
-  (byte*~) main::$2 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_X
-  *((const byte*) SCREEN + (number) 2) ← *((byte*~) main::$2)
-  (byte*~) main::$3 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_Y
-  *((const byte*) SCREEN + (number) 3) ← *((byte*~) main::$3)
+  *((const byte*) SCREEN + (number) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
+  *((const byte*) SCREEN + (number) 1) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
+  *((const byte*) SCREEN + (number) 2) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
+  *((const byte*) SCREEN + (number) 3) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
   to:main::@return
 main::@return: scope:[main]  from main
   return 
@@ -64,19 +56,15 @@ SYMBOL TABLE SSA
 (struct Point) Vector::p
 (struct Point) Vector::q
 (void()) main()
-(byte*~) main::$0
-(byte*~) main::$1
-(byte*~) main::$2
-(byte*~) main::$3
 (label) main::@return
 (struct Point) main::p1 loadstore
 (struct Point) main::p2 loadstore
 (struct Vector) main::v loadstore
 
-Adding number conversion cast (unumber) 0 in *((const byte*) SCREEN + (number) 0) ← *((byte*~) main::$0)
-Adding number conversion cast (unumber) 1 in *((const byte*) SCREEN + (number) 1) ← *((byte*~) main::$1)
-Adding number conversion cast (unumber) 2 in *((const byte*) SCREEN + (number) 2) ← *((byte*~) main::$2)
-Adding number conversion cast (unumber) 3 in *((const byte*) SCREEN + (number) 3) ← *((byte*~) main::$3)
+Adding number conversion cast (unumber) 0 in *((const byte*) SCREEN + (number) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
+Adding number conversion cast (unumber) 1 in *((const byte*) SCREEN + (number) 1) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
+Adding number conversion cast (unumber) 2 in *((const byte*) SCREEN + (number) 2) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
+Adding number conversion cast (unumber) 3 in *((const byte*) SCREEN + (number) 3) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
 Successful SSA optimization PassNAddNumberTypeConversions
 Simplifying constant pointer cast (byte*) 1024
 Simplifying constant integer cast 0
@@ -92,31 +80,16 @@ Successful SSA optimization PassNFinalizeNumberTypeConversions
 Removing C-classic struct-unwound assignment [1] (struct Vector) main::v ← struct-unwound {*(&(struct Vector) main::v)}
 Removing C-classic struct-unwound assignment [3] (struct Point) main::p1 ← struct-unwound {*(&(struct Point) main::p1)}
 Removing C-classic struct-unwound assignment [5] (struct Point) main::p2 ← struct-unwound {*(&(struct Point) main::p2)}
-Constant right-side identified [8] (byte*~) main::$0 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_X
-Constant right-side identified [10] (byte*~) main::$1 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_Y
-Constant right-side identified [12] (byte*~) main::$2 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_X
-Constant right-side identified [14] (byte*~) main::$3 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_Y
-Successful SSA optimization Pass2ConstantRValueConsolidation
-Constant (const byte*) main::$0 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P+OFFSET_STRUCT_POINT_X
-Constant (const byte*) main::$1 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P+OFFSET_STRUCT_POINT_Y
-Constant (const byte*) main::$2 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q+OFFSET_STRUCT_POINT_X
-Constant (const byte*) main::$3 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q+OFFSET_STRUCT_POINT_Y
-Successful SSA optimization Pass2ConstantIdentification
-Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P in 
-Simplifying expression containing zero (struct Point*)&main::v in 
-Simplifying expression containing zero (struct Point*)&main::v in 
-Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q in 
 Simplifying expression containing zero (struct Point*)&main::v in [6] *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P) ← memcpy(*(&(struct Point) main::p1), struct Point, (const byte) SIZEOF_STRUCT_POINT)
-Simplifying expression containing zero SCREEN in [9] *((const byte*) SCREEN + (byte) 0) ← *((const byte*) main::$0)
+Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P in [8] *((const byte*) SCREEN + (byte) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
+Simplifying expression containing zero (struct Point*)&main::v in [8] *((const byte*) SCREEN + (byte) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P)
+Simplifying expression containing zero SCREEN in [8] *((const byte*) SCREEN + (byte) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v)
+Simplifying expression containing zero (struct Point*)&main::v in [9] *((const byte*) SCREEN + (byte) 1) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
+Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q in [10] *((const byte*) SCREEN + (byte) 2) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
 Successful SSA optimization PassNSimplifyExpressionWithZero
 Eliminating unused constant (const byte) OFFSET_STRUCT_VECTOR_P
 Eliminating unused constant (const byte) OFFSET_STRUCT_POINT_X
 Successful SSA optimization PassNEliminateUnusedVars
-Constant inlined main::$3 = (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y
-Constant inlined main::$1 = (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_POINT_Y
-Constant inlined main::$2 = (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q
-Constant inlined main::$0 = (byte*)(struct Point*)&(struct Vector) main::v
-Successful SSA optimization Pass2ConstantInlining
 Consolidated array index constant in *(SCREEN+1)
 Consolidated array index constant in *(SCREEN+2)
 Consolidated array index constant in *(SCREEN+3)
diff --git a/src/test/ref/struct-20.log b/src/test/ref/struct-20.log
index 5f5999b58..681682dbe 100644
--- a/src/test/ref/struct-20.log
+++ b/src/test/ref/struct-20.log
@@ -3,14 +3,10 @@ Adding value bulk copy *(&(struct Point) main::p2) ← memcpy(*(&(const struct P
 Unwinding value copy (struct Vector) main::v ← (struct Vector){ (struct Point) main::p1, (struct Point) main::p2 }
 Adding value bulk copy *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P) ← memcpy(*(&(struct Point) main::p1), struct Point, (const byte) SIZEOF_STRUCT_POINT)
 Adding value bulk copy *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q) ← memcpy(*(&(struct Point) main::p2), struct Point, (const byte) SIZEOF_STRUCT_POINT)
-Replacing struct member reference (struct Vector) main::v.p with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P)
-Replacing struct member reference (struct Vector) main::v.p with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P)
-Replacing struct member reference (struct Vector) main::v.q with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q)
-Replacing struct member reference (struct Vector) main::v.q with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q)
-Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P).x
-Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P).y
-Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q).x
-Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q).y
+Replacing struct member reference (struct Vector) main::v.p.x with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
+Replacing struct member reference (struct Vector) main::v.p.y with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
+Replacing struct member reference (struct Vector) main::v.q.x with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
+Replacing struct member reference (struct Vector) main::v.q.y with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
 
 CONTROL FLOW GRAPH SSA
 @begin: scope:[]  from
@@ -25,14 +21,10 @@ main: scope:[main]  from @1
   *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P) ← memcpy(*(&(struct Point) main::p1), struct Point, (const byte) SIZEOF_STRUCT_POINT)
   *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q) ← memcpy(*(&(struct Point) main::p2), struct Point, (const byte) SIZEOF_STRUCT_POINT)
   (struct Vector) main::v ← struct-unwound {*((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P), *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q)}
-  (byte*~) main::$0 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_X
-  *((const byte*) SCREEN + (number) 0) ← *((byte*~) main::$0)
-  (byte*~) main::$1 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_Y
-  *((const byte*) SCREEN + (number) 1) ← *((byte*~) main::$1)
-  (byte*~) main::$2 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_X
-  *((const byte*) SCREEN + (number) 2) ← *((byte*~) main::$2)
-  (byte*~) main::$3 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_Y
-  *((const byte*) SCREEN + (number) 3) ← *((byte*~) main::$3)
+  *((const byte*) SCREEN + (number) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
+  *((const byte*) SCREEN + (number) 1) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
+  *((const byte*) SCREEN + (number) 2) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
+  *((const byte*) SCREEN + (number) 3) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
   to:main::@return
 main::@return: scope:[main]  from main
   return 
@@ -62,19 +54,15 @@ SYMBOL TABLE SSA
 (struct Point) Vector::p
 (struct Point) Vector::q
 (void()) main()
-(byte*~) main::$0
-(byte*~) main::$1
-(byte*~) main::$2
-(byte*~) main::$3
 (label) main::@return
 (struct Point) main::p1 loadstore
 (struct Point) main::p2 loadstore
 (struct Vector) main::v loadstore
 
-Adding number conversion cast (unumber) 0 in *((const byte*) SCREEN + (number) 0) ← *((byte*~) main::$0)
-Adding number conversion cast (unumber) 1 in *((const byte*) SCREEN + (number) 1) ← *((byte*~) main::$1)
-Adding number conversion cast (unumber) 2 in *((const byte*) SCREEN + (number) 2) ← *((byte*~) main::$2)
-Adding number conversion cast (unumber) 3 in *((const byte*) SCREEN + (number) 3) ← *((byte*~) main::$3)
+Adding number conversion cast (unumber) 0 in *((const byte*) SCREEN + (number) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
+Adding number conversion cast (unumber) 1 in *((const byte*) SCREEN + (number) 1) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
+Adding number conversion cast (unumber) 2 in *((const byte*) SCREEN + (number) 2) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
+Adding number conversion cast (unumber) 3 in *((const byte*) SCREEN + (number) 3) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
 Successful SSA optimization PassNAddNumberTypeConversions
 Simplifying constant pointer cast (byte*) 1024
 Simplifying constant integer cast 0
@@ -90,31 +78,16 @@ Successful SSA optimization PassNFinalizeNumberTypeConversions
 Removing C-classic struct-unwound assignment [1] (struct Point) main::p1 ← struct-unwound {*(&(struct Point) main::p1)}
 Removing C-classic struct-unwound assignment [3] (struct Point) main::p2 ← struct-unwound {*(&(struct Point) main::p2)}
 Removing C-classic struct-unwound assignment [6] (struct Vector) main::v ← struct-unwound {*((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P), *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q)}
-Constant right-side identified [7] (byte*~) main::$0 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_X
-Constant right-side identified [9] (byte*~) main::$1 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_Y
-Constant right-side identified [11] (byte*~) main::$2 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_X
-Constant right-side identified [13] (byte*~) main::$3 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_Y
-Successful SSA optimization Pass2ConstantRValueConsolidation
-Constant (const byte*) main::$0 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P+OFFSET_STRUCT_POINT_X
-Constant (const byte*) main::$1 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P+OFFSET_STRUCT_POINT_Y
-Constant (const byte*) main::$2 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q+OFFSET_STRUCT_POINT_X
-Constant (const byte*) main::$3 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q+OFFSET_STRUCT_POINT_Y
-Successful SSA optimization Pass2ConstantIdentification
-Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P in 
-Simplifying expression containing zero (struct Point*)&main::v in 
-Simplifying expression containing zero (struct Point*)&main::v in 
-Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q in 
 Simplifying expression containing zero (struct Point*)&main::v in [4] *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P) ← memcpy(*(&(struct Point) main::p1), struct Point, (const byte) SIZEOF_STRUCT_POINT)
-Simplifying expression containing zero SCREEN in [8] *((const byte*) SCREEN + (byte) 0) ← *((const byte*) main::$0)
+Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P in [7] *((const byte*) SCREEN + (byte) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
+Simplifying expression containing zero (struct Point*)&main::v in [7] *((const byte*) SCREEN + (byte) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P)
+Simplifying expression containing zero SCREEN in [7] *((const byte*) SCREEN + (byte) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v)
+Simplifying expression containing zero (struct Point*)&main::v in [8] *((const byte*) SCREEN + (byte) 1) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
+Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q in [9] *((const byte*) SCREEN + (byte) 2) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
 Successful SSA optimization PassNSimplifyExpressionWithZero
 Eliminating unused constant (const byte) OFFSET_STRUCT_VECTOR_P
 Eliminating unused constant (const byte) OFFSET_STRUCT_POINT_X
 Successful SSA optimization PassNEliminateUnusedVars
-Constant inlined main::$3 = (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y
-Constant inlined main::$1 = (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_POINT_Y
-Constant inlined main::$2 = (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q
-Constant inlined main::$0 = (byte*)(struct Point*)&(struct Vector) main::v
-Successful SSA optimization Pass2ConstantInlining
 Consolidated array index constant in *(SCREEN+1)
 Consolidated array index constant in *(SCREEN+2)
 Consolidated array index constant in *(SCREEN+3)
diff --git a/src/test/ref/struct-21.log b/src/test/ref/struct-21.log
index 5b0799345..d42d5d4eb 100644
--- a/src/test/ref/struct-21.log
+++ b/src/test/ref/struct-21.log
@@ -1,7 +1,7 @@
 Setting inferred volatile on symbol affected by address-of (struct Point*) main::ptr ← &(struct Point) main::point1
 Adding value bulk copy *(&(struct Point) main::point1) ← memcpy(*(&(const struct Point) $0), struct Point, (const byte) SIZEOF_STRUCT_POINT)
-Rewriting struct pointer member access *((struct Point*) main::ptr).x
-Rewriting struct pointer member access *((struct Point*) main::ptr).y
+Replacing struct member reference *((struct Point*) main::ptr).x with member unwinding reference *((byte*~) main::$0)
+Replacing struct member reference *((struct Point*) main::ptr).y with member unwinding reference *((byte*~) main::$1)
 Identified constant variable (struct Point*) main::ptr
 
 CONTROL FLOW GRAPH SSA
diff --git a/src/test/ref/struct-40.log b/src/test/ref/struct-40.log
index 402b826e2..a6bc18781 100644
--- a/src/test/ref/struct-40.log
+++ b/src/test/ref/struct-40.log
@@ -62,38 +62,22 @@ Adding value simple copy (byte) main::v4_p_y ← (byte) main::v1_p_y
 Unwinding value copy (struct Vector) main::v4 ← (struct Vector){ (struct Point){ (struct Vector) main::v1.p.x, (struct Vector) main::v1.p.y }, { x: (byte) 8, y: (byte) 9 } }
 Adding value simple copy (byte) main::v4_q_x ← (byte) 8
 Adding value simple copy (byte) main::v4_q_y ← (byte) 9
-Replacing struct member reference (struct Vector) main::v1.p with member unwinding reference (struct Point) main::v1_p
-Replacing struct member reference (struct Vector) main::v1.p with member unwinding reference (struct Point) main::v1_p
-Replacing struct member reference (struct Vector) main::v1.q with member unwinding reference (struct Point) main::v1_q
-Replacing struct member reference (struct Vector) main::v1.q with member unwinding reference (struct Point) main::v1_q
-Replacing struct member reference (struct Vector) main::v2.p with member unwinding reference (struct Point) main::v2_p
-Replacing struct member reference (struct Vector) main::v2.p with member unwinding reference (struct Point) main::v2_p
-Replacing struct member reference (struct Vector) main::v2.q with member unwinding reference (struct Point) main::v2_q
-Replacing struct member reference (struct Vector) main::v2.q with member unwinding reference (struct Point) main::v2_q
-Replacing struct member reference (struct Vector) main::v3.p with member unwinding reference (struct Point) main::v3_p
-Replacing struct member reference (struct Vector) main::v3.p with member unwinding reference (struct Point) main::v3_p
-Replacing struct member reference (struct Vector) main::v3.q with member unwinding reference (struct Point) main::v3_q
-Replacing struct member reference (struct Vector) main::v3.q with member unwinding reference (struct Point) main::v3_q
-Replacing struct member reference (struct Vector) main::v4.p with member unwinding reference (struct Point) main::v4_p
-Replacing struct member reference (struct Vector) main::v4.p with member unwinding reference (struct Point) main::v4_p
-Replacing struct member reference (struct Vector) main::v4.q with member unwinding reference (struct Point) main::v4_q
-Replacing struct member reference (struct Vector) main::v4.q with member unwinding reference (struct Point) main::v4_q
-Replacing struct member reference (struct Point) main::v1_p.x with member unwinding reference (byte) main::v1_p_x
-Replacing struct member reference (struct Point) main::v1_p.y with member unwinding reference (byte) main::v1_p_y
-Replacing struct member reference (struct Point) main::v1_q.x with member unwinding reference (byte) main::v1_q_x
-Replacing struct member reference (struct Point) main::v1_q.y with member unwinding reference (byte) main::v1_q_y
-Replacing struct member reference (struct Point) main::v2_p.x with member unwinding reference (byte) main::v2_p_x
-Replacing struct member reference (struct Point) main::v2_p.y with member unwinding reference (byte) main::v2_p_y
-Replacing struct member reference (struct Point) main::v2_q.x with member unwinding reference (byte) main::v2_q_x
-Replacing struct member reference (struct Point) main::v2_q.y with member unwinding reference (byte) main::v2_q_y
-Replacing struct member reference (struct Point) main::v3_p.x with member unwinding reference (byte) main::v3_p_x
-Replacing struct member reference (struct Point) main::v3_p.y with member unwinding reference (byte) main::v3_p_y
-Replacing struct member reference (struct Point) main::v3_q.x with member unwinding reference (byte) main::v3_q_x
-Replacing struct member reference (struct Point) main::v3_q.y with member unwinding reference (byte) main::v3_q_y
-Replacing struct member reference (struct Point) main::v4_p.x with member unwinding reference (byte) main::v4_p_x
-Replacing struct member reference (struct Point) main::v4_p.y with member unwinding reference (byte) main::v4_p_y
-Replacing struct member reference (struct Point) main::v4_q.x with member unwinding reference (byte) main::v4_q_x
-Replacing struct member reference (struct Point) main::v4_q.y with member unwinding reference (byte) main::v4_q_y
+Replacing struct member reference (struct Vector) main::v1.p.x with member unwinding reference (byte) main::v1_p_x
+Replacing struct member reference (struct Vector) main::v1.p.y with member unwinding reference (byte) main::v1_p_y
+Replacing struct member reference (struct Vector) main::v1.q.x with member unwinding reference (byte) main::v1_q_x
+Replacing struct member reference (struct Vector) main::v1.q.y with member unwinding reference (byte) main::v1_q_y
+Replacing struct member reference (struct Vector) main::v2.p.x with member unwinding reference (byte) main::v2_p_x
+Replacing struct member reference (struct Vector) main::v2.p.y with member unwinding reference (byte) main::v2_p_y
+Replacing struct member reference (struct Vector) main::v2.q.x with member unwinding reference (byte) main::v2_q_x
+Replacing struct member reference (struct Vector) main::v2.q.y with member unwinding reference (byte) main::v2_q_y
+Replacing struct member reference (struct Vector) main::v3.p.x with member unwinding reference (byte) main::v3_p_x
+Replacing struct member reference (struct Vector) main::v3.p.y with member unwinding reference (byte) main::v3_p_y
+Replacing struct member reference (struct Vector) main::v3.q.x with member unwinding reference (byte) main::v3_q_x
+Replacing struct member reference (struct Vector) main::v3.q.y with member unwinding reference (byte) main::v3_q_y
+Replacing struct member reference (struct Vector) main::v4.p.x with member unwinding reference (byte) main::v4_p_x
+Replacing struct member reference (struct Vector) main::v4.p.y with member unwinding reference (byte) main::v4_p_y
+Replacing struct member reference (struct Vector) main::v4.q.x with member unwinding reference (byte) main::v4_q_x
+Replacing struct member reference (struct Vector) main::v4.q.y with member unwinding reference (byte) main::v4_q_y
 Identified constant variable (byte) main::v1_p_x
 Identified constant variable (byte) main::v1_p_y
 Identified constant variable (byte) main::v1_q_x
diff --git a/src/test/ref/struct-41.log b/src/test/ref/struct-41.log
index 9bb567ff8..28d8e7785 100644
--- a/src/test/ref/struct-41.log
+++ b/src/test/ref/struct-41.log
@@ -41,46 +41,26 @@ Adding value simple copy (byte) main::v5_p_y ← *((byte*)(struct Point*)&(struc
 Unwinding value copy (struct Vector) main::v5 ← (struct Vector){ (struct Point){ (struct Vector) main::v4.p.x, (struct Vector) main::v4.p.y }, { x: (byte) 8, y: (byte) 9 } }
 Adding value simple copy (byte) main::v5_q_x ← (byte) 8
 Adding value simple copy (byte) main::v5_q_y ← (byte) 9
-Replacing struct member reference (struct Vector) main::v1.p with member unwinding reference (struct Point) main::v1_p
-Replacing struct member reference (struct Vector) main::v1.p with member unwinding reference (struct Point) main::v1_p
-Replacing struct member reference (struct Vector) main::v1.q with member unwinding reference (struct Point) main::v1_q
-Replacing struct member reference (struct Vector) main::v1.q with member unwinding reference (struct Point) main::v1_q
-Replacing struct member reference (struct Vector) main::v2.p with member unwinding reference *((struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P)
-Replacing struct member reference (struct Vector) main::v2.p with member unwinding reference *((struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P)
-Replacing struct member reference (struct Vector) main::v2.q with member unwinding reference *((struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_Q)
-Replacing struct member reference (struct Vector) main::v2.q with member unwinding reference *((struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_Q)
-Replacing struct member reference (struct Vector) main::v3.p with member unwinding reference *((struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_P)
-Replacing struct member reference (struct Vector) main::v3.p with member unwinding reference *((struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_P)
-Replacing struct member reference (struct Vector) main::v3.q with member unwinding reference *((struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_Q)
-Replacing struct member reference (struct Vector) main::v3.q with member unwinding reference *((struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_Q)
-Replacing struct member reference (struct Vector) main::v4.p with member unwinding reference *((struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_P)
-Replacing struct member reference (struct Vector) main::v4.p with member unwinding reference *((struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_P)
-Replacing struct member reference (struct Vector) main::v4.q with member unwinding reference *((struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_Q)
-Replacing struct member reference (struct Vector) main::v4.q with member unwinding reference *((struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_Q)
-Replacing struct member reference (struct Vector) main::v5.p with member unwinding reference (struct Point) main::v5_p
-Replacing struct member reference (struct Vector) main::v5.p with member unwinding reference (struct Point) main::v5_p
-Replacing struct member reference (struct Vector) main::v5.q with member unwinding reference (struct Point) main::v5_q
-Replacing struct member reference (struct Vector) main::v5.q with member unwinding reference (struct Point) main::v5_q
-Replacing struct member reference (struct Point) main::v1_p.x with member unwinding reference (byte) main::v1_p_x
-Replacing struct member reference (struct Point) main::v1_p.y with member unwinding reference (byte) main::v1_p_y
-Replacing struct member reference (struct Point) main::v1_q.x with member unwinding reference (byte) main::v1_q_x
-Replacing struct member reference (struct Point) main::v1_q.y with member unwinding reference (byte) main::v1_q_y
-Replacing struct member reference (struct Point) main::v5_p.x with member unwinding reference (byte) main::v5_p_x
-Replacing struct member reference (struct Point) main::v5_p.y with member unwinding reference (byte) main::v5_p_y
-Replacing struct member reference (struct Point) main::v5_q.x with member unwinding reference (byte) main::v5_q_x
-Replacing struct member reference (struct Point) main::v5_q.y with member unwinding reference (byte) main::v5_q_y
-Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P).x
-Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P).y
-Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_Q).x
-Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_Q).y
-Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_P).x
-Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_P).y
-Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_Q).x
-Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_Q).y
-Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_P).x
-Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_P).y
-Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_Q).x
-Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_Q).y
+Replacing struct member reference (struct Vector) main::v1.p.x with member unwinding reference (byte) main::v1_p_x
+Replacing struct member reference (struct Vector) main::v1.p.y with member unwinding reference (byte) main::v1_p_y
+Replacing struct member reference (struct Vector) main::v1.q.x with member unwinding reference (byte) main::v1_q_x
+Replacing struct member reference (struct Vector) main::v1.q.y with member unwinding reference (byte) main::v1_q_y
+Replacing struct member reference (struct Vector) main::v2.p.x with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
+Replacing struct member reference (struct Vector) main::v2.p.y with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
+Replacing struct member reference (struct Vector) main::v2.q.x with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
+Replacing struct member reference (struct Vector) main::v2.q.y with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
+Replacing struct member reference (struct Vector) main::v3.p.x with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
+Replacing struct member reference (struct Vector) main::v3.p.y with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
+Replacing struct member reference (struct Vector) main::v3.q.x with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
+Replacing struct member reference (struct Vector) main::v3.q.y with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
+Replacing struct member reference (struct Vector) main::v4.p.x with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
+Replacing struct member reference (struct Vector) main::v4.p.y with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
+Replacing struct member reference (struct Vector) main::v4.q.x with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
+Replacing struct member reference (struct Vector) main::v4.q.y with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
+Replacing struct member reference (struct Vector) main::v5.p.x with member unwinding reference (byte) main::v5_p_x
+Replacing struct member reference (struct Vector) main::v5.p.y with member unwinding reference (byte) main::v5_p_y
+Replacing struct member reference (struct Vector) main::v5.q.x with member unwinding reference (byte) main::v5_q_x
+Replacing struct member reference (struct Vector) main::v5.q.y with member unwinding reference (byte) main::v5_q_y
 Identified constant variable (byte) main::v1_p_x
 Identified constant variable (byte) main::v1_p_y
 Identified constant variable (byte) main::v1_q_x
@@ -115,41 +95,29 @@ main: scope:[main]  from @1
   (byte) main::idx#3 ← ++ (byte) main::idx#2
   *((const byte*) SCREEN + (byte) main::idx#3) ← (const byte) main::v1_q_y
   (byte) main::idx#4 ← ++ (byte) main::idx#3
-  (byte*~) main::$0 ← (byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_X
-  *((const byte*) SCREEN + (byte) main::idx#4) ← *((byte*~) main::$0)
+  *((const byte*) SCREEN + (byte) main::idx#4) ← *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
   (byte) main::idx#5 ← ++ (byte) main::idx#4
-  (byte*~) main::$1 ← (byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_Y
-  *((const byte*) SCREEN + (byte) main::idx#5) ← *((byte*~) main::$1)
+  *((const byte*) SCREEN + (byte) main::idx#5) ← *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
   (byte) main::idx#6 ← ++ (byte) main::idx#5
-  (byte*~) main::$2 ← (byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_X
-  *((const byte*) SCREEN + (byte) main::idx#6) ← *((byte*~) main::$2)
+  *((const byte*) SCREEN + (byte) main::idx#6) ← *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
   (byte) main::idx#7 ← ++ (byte) main::idx#6
-  (byte*~) main::$3 ← (byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_Y
-  *((const byte*) SCREEN + (byte) main::idx#7) ← *((byte*~) main::$3)
+  *((const byte*) SCREEN + (byte) main::idx#7) ← *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
   (byte) main::idx#8 ← ++ (byte) main::idx#7
-  (byte*~) main::$4 ← (byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_X
-  *((const byte*) SCREEN + (byte) main::idx#8) ← *((byte*~) main::$4)
+  *((const byte*) SCREEN + (byte) main::idx#8) ← *((byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
   (byte) main::idx#9 ← ++ (byte) main::idx#8
-  (byte*~) main::$5 ← (byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_Y
-  *((const byte*) SCREEN + (byte) main::idx#9) ← *((byte*~) main::$5)
+  *((const byte*) SCREEN + (byte) main::idx#9) ← *((byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
   (byte) main::idx#10 ← ++ (byte) main::idx#9
-  (byte*~) main::$6 ← (byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_X
-  *((const byte*) SCREEN + (byte) main::idx#10) ← *((byte*~) main::$6)
+  *((const byte*) SCREEN + (byte) main::idx#10) ← *((byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
   (byte) main::idx#11 ← ++ (byte) main::idx#10
-  (byte*~) main::$7 ← (byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_Y
-  *((const byte*) SCREEN + (byte) main::idx#11) ← *((byte*~) main::$7)
+  *((const byte*) SCREEN + (byte) main::idx#11) ← *((byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
   (byte) main::idx#12 ← ++ (byte) main::idx#11
-  (byte*~) main::$8 ← (byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_X
-  *((const byte*) SCREEN + (byte) main::idx#12) ← *((byte*~) main::$8)
+  *((const byte*) SCREEN + (byte) main::idx#12) ← *((byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
   (byte) main::idx#13 ← ++ (byte) main::idx#12
-  (byte*~) main::$9 ← (byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_Y
-  *((const byte*) SCREEN + (byte) main::idx#13) ← *((byte*~) main::$9)
+  *((const byte*) SCREEN + (byte) main::idx#13) ← *((byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
   (byte) main::idx#14 ← ++ (byte) main::idx#13
-  (byte*~) main::$10 ← (byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_X
-  *((const byte*) SCREEN + (byte) main::idx#14) ← *((byte*~) main::$10)
+  *((const byte*) SCREEN + (byte) main::idx#14) ← *((byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
   (byte) main::idx#15 ← ++ (byte) main::idx#14
-  (byte*~) main::$11 ← (byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_Y
-  *((const byte*) SCREEN + (byte) main::idx#15) ← *((byte*~) main::$11)
+  *((const byte*) SCREEN + (byte) main::idx#15) ← *((byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
   (byte) main::idx#16 ← ++ (byte) main::idx#15
   *((const byte*) SCREEN + (byte) main::idx#16) ← (byte) main::v5_p_x#0
   (byte) main::idx#17 ← ++ (byte) main::idx#16
@@ -188,18 +156,6 @@ SYMBOL TABLE SSA
 (struct Point) Vector::p
 (struct Point) Vector::q
 (void()) main()
-(byte*~) main::$0
-(byte*~) main::$1
-(byte*~) main::$10
-(byte*~) main::$11
-(byte*~) main::$2
-(byte*~) main::$3
-(byte*~) main::$4
-(byte*~) main::$5
-(byte*~) main::$6
-(byte*~) main::$7
-(byte*~) main::$8
-(byte*~) main::$9
 (label) main::@return
 (byte) main::idx
 (byte) main::idx#0
@@ -246,45 +202,8 @@ Successful SSA optimization PassNCastSimplification
 Removing C-classic struct-unwound assignment [5] (struct Vector) main::v2 ← struct-unwound {*((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X), *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y), *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X), *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)}
 Removing C-classic struct-unwound assignment [8] (struct Vector) main::v3 ← struct-unwound {*((struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_P), *((struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_Q)}
 Removing C-classic struct-unwound assignment [10] (struct Vector) main::v4 ← struct-unwound {*(&(struct Vector) main::v4)}
-Constant right-side identified [21] (byte*~) main::$0 ← (byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_X
-Constant right-side identified [24] (byte*~) main::$1 ← (byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_Y
-Constant right-side identified [27] (byte*~) main::$2 ← (byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_X
-Constant right-side identified [30] (byte*~) main::$3 ← (byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_Y
-Constant right-side identified [33] (byte*~) main::$4 ← (byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_X
-Constant right-side identified [36] (byte*~) main::$5 ← (byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_Y
-Constant right-side identified [39] (byte*~) main::$6 ← (byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_X
-Constant right-side identified [42] (byte*~) main::$7 ← (byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_Y
-Constant right-side identified [45] (byte*~) main::$8 ← (byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_X
-Constant right-side identified [48] (byte*~) main::$9 ← (byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_Y
-Constant right-side identified [51] (byte*~) main::$10 ← (byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_X
-Constant right-side identified [54] (byte*~) main::$11 ← (byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_Y
-Successful SSA optimization Pass2ConstantRValueConsolidation
 Constant (const byte) main::idx#0 = 0
-Constant (const byte*) main::$0 = (byte*)(struct Point*)&main::v2+OFFSET_STRUCT_VECTOR_P+OFFSET_STRUCT_POINT_X
-Constant (const byte*) main::$1 = (byte*)(struct Point*)&main::v2+OFFSET_STRUCT_VECTOR_P+OFFSET_STRUCT_POINT_Y
-Constant (const byte*) main::$2 = (byte*)(struct Point*)&main::v2+OFFSET_STRUCT_VECTOR_Q+OFFSET_STRUCT_POINT_X
-Constant (const byte*) main::$3 = (byte*)(struct Point*)&main::v2+OFFSET_STRUCT_VECTOR_Q+OFFSET_STRUCT_POINT_Y
-Constant (const byte*) main::$4 = (byte*)(struct Point*)&main::v3+OFFSET_STRUCT_VECTOR_P+OFFSET_STRUCT_POINT_X
-Constant (const byte*) main::$5 = (byte*)(struct Point*)&main::v3+OFFSET_STRUCT_VECTOR_P+OFFSET_STRUCT_POINT_Y
-Constant (const byte*) main::$6 = (byte*)(struct Point*)&main::v3+OFFSET_STRUCT_VECTOR_Q+OFFSET_STRUCT_POINT_X
-Constant (const byte*) main::$7 = (byte*)(struct Point*)&main::v3+OFFSET_STRUCT_VECTOR_Q+OFFSET_STRUCT_POINT_Y
-Constant (const byte*) main::$8 = (byte*)(struct Point*)&main::v4+OFFSET_STRUCT_VECTOR_P+OFFSET_STRUCT_POINT_X
-Constant (const byte*) main::$9 = (byte*)(struct Point*)&main::v4+OFFSET_STRUCT_VECTOR_P+OFFSET_STRUCT_POINT_Y
-Constant (const byte*) main::$10 = (byte*)(struct Point*)&main::v4+OFFSET_STRUCT_VECTOR_Q+OFFSET_STRUCT_POINT_X
-Constant (const byte*) main::$11 = (byte*)(struct Point*)&main::v4+OFFSET_STRUCT_VECTOR_Q+OFFSET_STRUCT_POINT_Y
 Successful SSA optimization Pass2ConstantIdentification
-Simplifying expression containing zero (byte*)(struct Point*)&main::v2+OFFSET_STRUCT_VECTOR_P in 
-Simplifying expression containing zero (struct Point*)&main::v2 in 
-Simplifying expression containing zero (struct Point*)&main::v2 in 
-Simplifying expression containing zero (byte*)(struct Point*)&main::v2+OFFSET_STRUCT_VECTOR_Q in 
-Simplifying expression containing zero (byte*)(struct Point*)&main::v3+OFFSET_STRUCT_VECTOR_P in 
-Simplifying expression containing zero (struct Point*)&main::v3 in 
-Simplifying expression containing zero (struct Point*)&main::v3 in 
-Simplifying expression containing zero (byte*)(struct Point*)&main::v3+OFFSET_STRUCT_VECTOR_Q in 
-Simplifying expression containing zero (byte*)(struct Point*)&main::v4+OFFSET_STRUCT_VECTOR_P in 
-Simplifying expression containing zero (struct Point*)&main::v4 in 
-Simplifying expression containing zero (struct Point*)&main::v4 in 
-Simplifying expression containing zero (byte*)(struct Point*)&main::v4+OFFSET_STRUCT_VECTOR_Q in 
 Simplifying expression containing zero (byte*)(struct Point*)&main::v2+OFFSET_STRUCT_VECTOR_P in [1] *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X) ← (const byte) main::v1_p_x
 Simplifying expression containing zero (struct Point*)&main::v2 in [1] *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P) ← (const byte) main::v1_p_x
 Simplifying expression containing zero (struct Point*)&main::v2 in [2] *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y) ← (const byte) main::v1_p_y
@@ -295,6 +214,18 @@ Simplifying expression containing zero (byte*)(struct Point*)&main::v4+OFFSET_ST
 Simplifying expression containing zero (struct Point*)&main::v4 in [11] (byte) main::v5_p_x#0 ← *((byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_P)
 Simplifying expression containing zero (struct Point*)&main::v4 in [12] (byte) main::v5_p_y#0 ← *((byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
 Simplifying expression containing zero SCREEN in [13] *((const byte*) SCREEN + (const byte) main::idx#0) ← (const byte) main::v1_p_x
+Simplifying expression containing zero (byte*)(struct Point*)&main::v2+OFFSET_STRUCT_VECTOR_P in [21] *((const byte*) SCREEN + (byte) main::idx#4) ← *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
+Simplifying expression containing zero (struct Point*)&main::v2 in [21] *((const byte*) SCREEN + (byte) main::idx#4) ← *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P)
+Simplifying expression containing zero (struct Point*)&main::v2 in [23] *((const byte*) SCREEN + (byte) main::idx#5) ← *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
+Simplifying expression containing zero (byte*)(struct Point*)&main::v2+OFFSET_STRUCT_VECTOR_Q in [25] *((const byte*) SCREEN + (byte) main::idx#6) ← *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
+Simplifying expression containing zero (byte*)(struct Point*)&main::v3+OFFSET_STRUCT_VECTOR_P in [29] *((const byte*) SCREEN + (byte) main::idx#8) ← *((byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
+Simplifying expression containing zero (struct Point*)&main::v3 in [29] *((const byte*) SCREEN + (byte) main::idx#8) ← *((byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_P)
+Simplifying expression containing zero (struct Point*)&main::v3 in [31] *((const byte*) SCREEN + (byte) main::idx#9) ← *((byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
+Simplifying expression containing zero (byte*)(struct Point*)&main::v3+OFFSET_STRUCT_VECTOR_Q in [33] *((const byte*) SCREEN + (byte) main::idx#10) ← *((byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
+Simplifying expression containing zero (byte*)(struct Point*)&main::v4+OFFSET_STRUCT_VECTOR_P in [37] *((const byte*) SCREEN + (byte) main::idx#12) ← *((byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
+Simplifying expression containing zero (struct Point*)&main::v4 in [37] *((const byte*) SCREEN + (byte) main::idx#12) ← *((byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_P)
+Simplifying expression containing zero (struct Point*)&main::v4 in [39] *((const byte*) SCREEN + (byte) main::idx#13) ← *((byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
+Simplifying expression containing zero (byte*)(struct Point*)&main::v4+OFFSET_STRUCT_VECTOR_Q in [41] *((const byte*) SCREEN + (byte) main::idx#14) ← *((byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
 Successful SSA optimization PassNSimplifyExpressionWithZero
 Eliminating unused variable (byte) main::idx#20 and assignment [48] (byte) main::idx#20 ← ++ (byte) main::idx#19
 Eliminating unused constant (const byte) OFFSET_STRUCT_VECTOR_P
@@ -404,30 +335,18 @@ Constant inlined main::idx#12 = ++++++++++++++++++++++++(byte) 0
 Constant inlined main::idx#13 = ++++++++++++++++++++++++++(byte) 0
 Constant inlined main::idx#14 = ++++++++++++++++++++++++++++(byte) 0
 Constant inlined main::idx#15 = ++++++++++++++++++++++++++++++(byte) 0
-Constant inlined main::$10 = (byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_Q
-Constant inlined main::$11 = (byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y
 Constant inlined main::idx#0 = (byte) 0
 Constant inlined main::idx#1 = ++(byte) 0
 Constant inlined main::idx#2 = ++++(byte) 0
-Constant inlined main::$1 = (byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_POINT_Y
 Constant inlined main::idx#3 = ++++++(byte) 0
-Constant inlined main::$2 = (byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_Q
 Constant inlined main::idx#4 = ++++++++(byte) 0
 Constant inlined main::idx#5 = ++++++++++(byte) 0
-Constant inlined main::$0 = (byte*)(struct Point*)&(struct Vector) main::v2
 Constant inlined main::idx#6 = ++++++++++++(byte) 0
-Constant inlined main::$5 = (byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_POINT_Y
 Constant inlined main::idx#7 = ++++++++++++++(byte) 0
-Constant inlined main::$6 = (byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_Q
 Constant inlined main::idx#8 = ++++++++++++++++(byte) 0
-Constant inlined main::$3 = (byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y
 Constant inlined main::idx#9 = ++++++++++++++++++(byte) 0
 Constant inlined main::idx#10 = ++++++++++++++++++++(byte) 0
-Constant inlined main::$4 = (byte*)(struct Point*)&(struct Vector) main::v3
 Constant inlined main::idx#11 = ++++++++++++++++++++++(byte) 0
-Constant inlined main::$9 = (byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_POINT_Y
-Constant inlined main::$7 = (byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y
-Constant inlined main::$8 = (byte*)(struct Point*)&(struct Vector) main::v4
 Successful SSA optimization Pass2ConstantInlining
 Consolidated array index constant in *(SCREEN+++0)
 Consolidated array index constant in *(SCREEN+++++0)
diff --git a/src/test/ref/struct-42.log b/src/test/ref/struct-42.log
index 2dbeba13d..2bd077bae 100644
--- a/src/test/ref/struct-42.log
+++ b/src/test/ref/struct-42.log
@@ -3,8 +3,8 @@ Fixing pointer array-indexing *((const struct Point*) points + (number) 2)
 Fixing pointer array-indexing *((const struct Point*) points + (number) 2)
 Constantified RValue *((const struct Point*) points + (byte~) main::$1) ← { x: (byte) 2, y: (byte) 3 }
 Adding value bulk copy *((const struct Point*) points + (byte~) main::$1) ← memcpy(*(&(const struct Point) $0), struct Point, (const byte) SIZEOF_STRUCT_POINT)
-Rewriting struct pointer member access *((const struct Point*) points + (number~) main::$2).x
-Rewriting struct pointer member access *((const struct Point*) points + (number~) main::$3).y
+Replacing struct member reference *((const struct Point*) points + (number~) main::$2).x with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$2)
+Replacing struct member reference *((const struct Point*) points + (number~) main::$3).y with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$3)
 
 CONTROL FLOW GRAPH SSA
 @begin: scope:[]  from
@@ -24,11 +24,9 @@ main::@1: scope:[main]  from main main::@1
   to:main::@2
 main::@2: scope:[main]  from main::@1
   (number~) main::$2 ← (number) 2 * (const byte) SIZEOF_STRUCT_POINT
-  (byte*~) main::$4 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
-  *((const byte*) SCREEN + (number) 0) ← *((byte*~) main::$4 + (number~) main::$2)
+  *((const byte*) SCREEN + (number) 0) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$2)
   (number~) main::$3 ← (number) 2 * (const byte) SIZEOF_STRUCT_POINT
-  (byte*~) main::$5 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
-  *((const byte*) SCREEN + (number) 1) ← *((byte*~) main::$5 + (number~) main::$3)
+  *((const byte*) SCREEN + (number) 1) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$3)
   to:main::@return
 main::@return: scope:[main]  from main::@2
   return 
@@ -57,8 +55,6 @@ SYMBOL TABLE SSA
 (byte~) main::$1
 (number~) main::$2
 (number~) main::$3
-(byte*~) main::$4
-(byte*~) main::$5
 (label) main::@1
 (label) main::@2
 (label) main::@return
@@ -70,10 +66,10 @@ SYMBOL TABLE SSA
 
 Adding number conversion cast (unumber) 2 in (number~) main::$2 ← (number) 2 * (const byte) SIZEOF_STRUCT_POINT
 Adding number conversion cast (unumber) main::$2 in (number~) main::$2 ← (unumber)(number) 2 * (const byte) SIZEOF_STRUCT_POINT
-Adding number conversion cast (unumber) 0 in *((const byte*) SCREEN + (number) 0) ← *((byte*~) main::$4 + (unumber~) main::$2)
+Adding number conversion cast (unumber) 0 in *((const byte*) SCREEN + (number) 0) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (unumber~) main::$2)
 Adding number conversion cast (unumber) 2 in (number~) main::$3 ← (number) 2 * (const byte) SIZEOF_STRUCT_POINT
 Adding number conversion cast (unumber) main::$3 in (number~) main::$3 ← (unumber)(number) 2 * (const byte) SIZEOF_STRUCT_POINT
-Adding number conversion cast (unumber) 1 in *((const byte*) SCREEN + (number) 1) ← *((byte*~) main::$5 + (unumber~) main::$3)
+Adding number conversion cast (unumber) 1 in *((const byte*) SCREEN + (number) 1) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (unumber~) main::$3)
 Successful SSA optimization PassNAddNumberTypeConversions
 Simplifying constant pointer cast (byte*) 1024
 Simplifying constant integer cast 2
@@ -91,20 +87,16 @@ Inferred type updated to byte in (unumber~) main::$3 ← (byte) 2 * (const byte)
 Simple Condition (bool~) main::$0 [6] if((byte) main::i#1!=rangelast(0,2)) goto main::@1
 Successful SSA optimization Pass2ConditionalJumpSimplification
 Constant right-side identified [7] (byte~) main::$2 ← (byte) 2 * (const byte) SIZEOF_STRUCT_POINT
-Constant right-side identified [8] (byte*~) main::$4 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
-Constant right-side identified [10] (byte~) main::$3 ← (byte) 2 * (const byte) SIZEOF_STRUCT_POINT
-Constant right-side identified [11] (byte*~) main::$5 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
+Constant right-side identified [9] (byte~) main::$3 ← (byte) 2 * (const byte) SIZEOF_STRUCT_POINT
 Successful SSA optimization Pass2ConstantRValueConsolidation
 Constant (const byte) main::i#0 = 0
 Constant (const byte) main::$2 = 2*SIZEOF_STRUCT_POINT
-Constant (const byte*) main::$4 = (byte*)points+OFFSET_STRUCT_POINT_X
 Constant (const byte) main::$3 = 2*SIZEOF_STRUCT_POINT
-Constant (const byte*) main::$5 = (byte*)points+OFFSET_STRUCT_POINT_Y
 Successful SSA optimization Pass2ConstantIdentification
 Resolved ranged next value [4] main::i#1 ← ++ main::i#2 to ++
 Resolved ranged comparison value [6] if(main::i#1!=rangelast(0,2)) goto main::@1 to (number) 3
-Simplifying expression containing zero (byte*)points in 
-Simplifying expression containing zero SCREEN in [9] *((const byte*) SCREEN + (byte) 0) ← *((const byte*) main::$4 + (const byte) main::$2)
+Simplifying expression containing zero (byte*)points in [8] *((const byte*) SCREEN + (byte) 0) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (const byte) main::$2)
+Simplifying expression containing zero SCREEN in [8] *((const byte*) SCREEN + (byte) 0) ← *((byte*)(const struct Point*) points + (const byte) main::$2)
 Successful SSA optimization PassNSimplifyExpressionWithZero
 Eliminating unused constant (const byte) OFFSET_STRUCT_POINT_X
 Successful SSA optimization PassNEliminateUnusedVars
@@ -117,11 +109,9 @@ Successful SSA optimization PassNFinalizeNumberTypeConversions
 Rewriting multiplication to use shift [1] (byte~) main::$1 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
 Successful SSA optimization Pass2MultiplyToShiftRewriting
 Inlining constant with var siblings (const byte) main::i#0
-Constant inlined main::$5 = (byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y
 Constant inlined main::i#0 = (byte) 0
-Constant inlined main::$3 = (byte) 2*(const byte) SIZEOF_STRUCT_POINT
-Constant inlined main::$4 = (byte*)(const struct Point*) points
 Constant inlined main::$2 = (byte) 2*(const byte) SIZEOF_STRUCT_POINT
+Constant inlined main::$3 = (byte) 2*(const byte) SIZEOF_STRUCT_POINT
 Successful SSA optimization Pass2ConstantInlining
 Consolidated array index constant in *((byte*)points+2*SIZEOF_STRUCT_POINT)
 Consolidated array index constant in *((byte*)points+OFFSET_STRUCT_POINT_Y+2*SIZEOF_STRUCT_POINT)
diff --git a/src/test/ref/struct-6.log b/src/test/ref/struct-6.log
index 7db653f3f..7051eb292 100644
--- a/src/test/ref/struct-6.log
+++ b/src/test/ref/struct-6.log
@@ -15,11 +15,9 @@ Unwinding value copy (struct Circle) main::c ← (struct Circle){ (struct Point)
 Adding value simple copy (byte) main::c_center_x ← (byte) main::p_x
 Adding value simple copy (byte) main::c_center_y ← (byte) main::p_y
 Adding value simple copy (byte) main::c_radius ← (byte) 5
-Replacing struct member reference (struct Circle) main::c.center with member unwinding reference (struct Point) main::c_center
-Replacing struct member reference (struct Circle) main::c.center with member unwinding reference (struct Point) main::c_center
+Replacing struct member reference (struct Circle) main::c.center.x with member unwinding reference (byte) main::c_center_x
+Replacing struct member reference (struct Circle) main::c.center.y with member unwinding reference (byte) main::c_center_y
 Replacing struct member reference (struct Circle) main::c.radius with member unwinding reference (byte) main::c_radius
-Replacing struct member reference (struct Point) main::c_center.x with member unwinding reference (byte) main::c_center_x
-Replacing struct member reference (struct Point) main::c_center.y with member unwinding reference (byte) main::c_center_y
 Identified constant variable (byte) main::p_x
 Identified constant variable (byte) main::p_y
 Identified constant variable (byte) main::c_radius
diff --git a/src/test/ref/struct-7.log b/src/test/ref/struct-7.log
index 4c8f5bc34..7dd09fbb0 100644
--- a/src/test/ref/struct-7.log
+++ b/src/test/ref/struct-7.log
@@ -24,22 +24,12 @@ Unwinding value copy (struct TwoCircles) main::t ← { c1: { center: { x: (byte)
 Adding value simple copy (byte) main::t_c2_center_x ← (byte) 4
 Adding value simple copy (byte) main::t_c2_center_y ← (byte) 5
 Adding value simple copy (byte) main::t_c2_radius ← (byte) 6
-Replacing struct member reference (struct TwoCircles) main::t.c1 with member unwinding reference (struct Circle) main::t_c1
-Replacing struct member reference (struct TwoCircles) main::t.c1 with member unwinding reference (struct Circle) main::t_c1
-Replacing struct member reference (struct TwoCircles) main::t.c1 with member unwinding reference (struct Circle) main::t_c1
-Replacing struct member reference (struct TwoCircles) main::t.c2 with member unwinding reference (struct Circle) main::t_c2
-Replacing struct member reference (struct TwoCircles) main::t.c2 with member unwinding reference (struct Circle) main::t_c2
-Replacing struct member reference (struct TwoCircles) main::t.c2 with member unwinding reference (struct Circle) main::t_c2
-Replacing struct member reference (struct Circle) main::t_c1.center with member unwinding reference (struct Point) main::t_c1_center
-Replacing struct member reference (struct Circle) main::t_c1.center with member unwinding reference (struct Point) main::t_c1_center
-Replacing struct member reference (struct Circle) main::t_c1.radius with member unwinding reference (byte) main::t_c1_radius
-Replacing struct member reference (struct Circle) main::t_c2.center with member unwinding reference (struct Point) main::t_c2_center
-Replacing struct member reference (struct Circle) main::t_c2.center with member unwinding reference (struct Point) main::t_c2_center
-Replacing struct member reference (struct Circle) main::t_c2.radius with member unwinding reference (byte) main::t_c2_radius
-Replacing struct member reference (struct Point) main::t_c1_center.x with member unwinding reference (byte) main::t_c1_center_x
-Replacing struct member reference (struct Point) main::t_c1_center.y with member unwinding reference (byte) main::t_c1_center_y
-Replacing struct member reference (struct Point) main::t_c2_center.x with member unwinding reference (byte) main::t_c2_center_x
-Replacing struct member reference (struct Point) main::t_c2_center.y with member unwinding reference (byte) main::t_c2_center_y
+Replacing struct member reference (struct TwoCircles) main::t.c1.center.x with member unwinding reference (byte) main::t_c1_center_x
+Replacing struct member reference (struct TwoCircles) main::t.c1.center.y with member unwinding reference (byte) main::t_c1_center_y
+Replacing struct member reference (struct TwoCircles) main::t.c1.radius with member unwinding reference (byte) main::t_c1_radius
+Replacing struct member reference (struct TwoCircles) main::t.c2.center.x with member unwinding reference (byte) main::t_c2_center_x
+Replacing struct member reference (struct TwoCircles) main::t.c2.center.y with member unwinding reference (byte) main::t_c2_center_y
+Replacing struct member reference (struct TwoCircles) main::t.c2.radius with member unwinding reference (byte) main::t_c2_radius
 Identified constant variable (byte) main::t_c1_radius
 Identified constant variable (byte) main::t_c2_radius
 Identified constant variable (byte) main::t_c1_center_x
diff --git a/src/test/ref/struct-9.log b/src/test/ref/struct-9.log
index 980ad89d7..5798c91c2 100644
--- a/src/test/ref/struct-9.log
+++ b/src/test/ref/struct-9.log
@@ -19,11 +19,9 @@ Unwinding value copy (struct Circle) main::c.center ← (struct Point) main::p
 Adding value simple copy (byte) main::c_center_x ← (byte) main::p_x
 Adding value simple copy (byte) main::c_center_y ← (byte) main::p_y
 Replacing struct member reference (struct Circle) main::c.radius with member unwinding reference (byte) main::c_radius
-Replacing struct member reference (struct Circle) main::c.center with member unwinding reference (struct Point) main::c_center
-Replacing struct member reference (struct Circle) main::c.center with member unwinding reference (struct Point) main::c_center
+Replacing struct member reference (struct Circle) main::c.center.x with member unwinding reference (byte) main::c_center_x
+Replacing struct member reference (struct Circle) main::c.center.y with member unwinding reference (byte) main::c_center_y
 Replacing struct member reference (struct Circle) main::c.radius with member unwinding reference (byte) main::c_radius
-Replacing struct member reference (struct Point) main::c_center.x with member unwinding reference (byte) main::c_center_x
-Replacing struct member reference (struct Point) main::c_center.y with member unwinding reference (byte) main::c_center_y
 Identified constant variable (byte) main::p_x
 Identified constant variable (byte) main::p_y
 
diff --git a/src/test/ref/struct-pos-fill.log b/src/test/ref/struct-pos-fill.log
index cacd6894c..c41e4120c 100644
--- a/src/test/ref/struct-pos-fill.log
+++ b/src/test/ref/struct-pos-fill.log
@@ -1,7 +1,7 @@
 Fixing pointer array-indexing *((const struct pos*) p + (byte) idx)
 Fixing pointer array-indexing *((const struct pos*) p + (byte) idx)
-Rewriting struct pointer member access *((const struct pos*) p + (byte~) main::$2).y
-Rewriting struct pointer member access *((const struct pos*) p + (byte~) main::$3).x
+Replacing struct member reference *((const struct pos*) p + (byte~) main::$2).y with member unwinding reference *((byte*)(const struct pos*) p+(const byte) OFFSET_STRUCT_POS_Y + (byte~) main::$2)
+Replacing struct member reference *((const struct pos*) p + (byte~) main::$3).x with member unwinding reference *((byte*)(const struct pos*) p+(const byte) OFFSET_STRUCT_POS_X + (byte~) main::$3)
 Identified constant variable (byte) OFFSET
 Identified constant variable (byte) XSPACE
 Identified constant variable (byte) YSPACE
@@ -63,11 +63,9 @@ main::@5: scope:[main]  from main::@4
   (byte) y#4 ← phi( main::@4/(byte) y#8 )
   (byte) idx#4 ← phi( main::@4/(byte) idx#7 )
   (byte~) main::$2 ← (byte) idx#4 * (const byte) SIZEOF_STRUCT_POS
-  (byte*~) main::$4 ← (byte*)(const struct pos*) p + (const byte) OFFSET_STRUCT_POS_Y
-  *((byte*~) main::$4 + (byte~) main::$2) ← (byte) y#4
+  *((byte*)(const struct pos*) p+(const byte) OFFSET_STRUCT_POS_Y + (byte~) main::$2) ← (byte) y#4
   (byte~) main::$3 ← (byte) idx#4 * (const byte) SIZEOF_STRUCT_POS
-  (byte*~) main::$5 ← (byte*)(const struct pos*) p + (const byte) OFFSET_STRUCT_POS_X
-  *((byte*~) main::$5 + (byte~) main::$3) ← (byte) x#6
+  *((byte*)(const struct pos*) p+(const byte) OFFSET_STRUCT_POS_X + (byte~) main::$3) ← (byte) x#6
   (byte) idx#1 ← ++ (byte) idx#4
   (byte) x#2 ← (byte) x#6 + (const byte) XSPACE
   (byte) row#2 ← ++ (byte) row#6
@@ -159,8 +157,6 @@ SYMBOL TABLE SSA
 (bool~) main::$1
 (byte~) main::$2
 (byte~) main::$3
-(byte*~) main::$4
-(byte*~) main::$5
 (label) main::@1
 (label) main::@2
 (label) main::@4
@@ -265,14 +261,11 @@ Identical Phi Values (byte) row#4 (byte) row#3
 Identical Phi Values (byte) idx#3 (byte) idx#12
 Identical Phi Values (byte) y#3 (byte) y#12
 Successful SSA optimization Pass2IdenticalPhiElimination
-Identified duplicate assignment right side [20] (byte~) main::$3 ← (byte) idx#11 * (const byte) SIZEOF_STRUCT_POS
+Identified duplicate assignment right side [19] (byte~) main::$3 ← (byte) idx#11 * (const byte) SIZEOF_STRUCT_POS
 Successful SSA optimization Pass2DuplicateRValueIdentification
 Simple Condition (bool~) main::$0 [9] if((byte) line#11<(byte) 8) goto main::@2
 Simple Condition (bool~) main::$1 [15] if((byte) row#12<(byte) 8) goto main::@5
 Successful SSA optimization Pass2ConditionalJumpSimplification
-Constant right-side identified [18] (byte*~) main::$4 ← (byte*)(const struct pos*) p + (const byte) OFFSET_STRUCT_POS_Y
-Constant right-side identified [21] (byte*~) main::$5 ← (byte*)(const struct pos*) p + (const byte) OFFSET_STRUCT_POS_X
-Successful SSA optimization Pass2ConstantRValueConsolidation
 Constant (const byte) idx#0 = 0
 Constant (const byte) line#0 = 0
 Constant (const byte) row#0 = 0
@@ -280,10 +273,8 @@ Constant (const byte) x#0 = 0
 Constant (const byte) y#0 = 0
 Constant (const byte) line#1 = 0
 Constant (const byte) row#1 = 0
-Constant (const byte*) main::$4 = (byte*)p+OFFSET_STRUCT_POS_Y
-Constant (const byte*) main::$5 = (byte*)p+OFFSET_STRUCT_POS_X
 Successful SSA optimization Pass2ConstantIdentification
-Simplifying expression containing zero (byte*)p in 
+Simplifying expression containing zero (byte*)p in [20] *((byte*)(const struct pos*) p+(const byte) OFFSET_STRUCT_POS_X + (byte~) main::$3) ← (byte) x#10
 Successful SSA optimization PassNSimplifyExpressionWithZero
 Eliminating unused variable - keeping the phi block (byte) row#3
 Eliminating unused constant (const byte) OFFSET_STRUCT_POS_X
@@ -303,10 +294,8 @@ Inlining constant with var siblings (const byte) row#1
 Constant inlined row#1 = (byte) 0
 Constant inlined x#0 = (byte) 0
 Constant inlined line#1 = (byte) 0
-Constant inlined y#0 = (byte) 0
-Constant inlined main::$5 = (byte*)(const struct pos*) p
-Constant inlined main::$4 = (byte*)(const struct pos*) p+(const byte) OFFSET_STRUCT_POS_Y
 Constant inlined idx#0 = (byte) 0
+Constant inlined y#0 = (byte) 0
 Successful SSA optimization Pass2ConstantInlining
 Eliminating unused constant (const byte) SIZEOF_STRUCT_POS
 Successful SSA optimization PassNEliminateUnusedVars
diff --git a/src/test/ref/struct-ptr-0.log b/src/test/ref/struct-ptr-0.log
index b2581fbcb..5977999f8 100644
--- a/src/test/ref/struct-ptr-0.log
+++ b/src/test/ref/struct-ptr-0.log
@@ -2,10 +2,10 @@ Fixing pointer array-indexing *((const struct Point*) points + (byte) main::i)
 Fixing pointer array-indexing *((const struct Point*) points + (byte) main::i)
 Fixing pointer array-indexing *((const struct Point*) points + (byte) main::i1)
 Fixing pointer array-indexing *((const struct Point*) points + (byte) main::i1)
-Rewriting struct pointer member access *((const struct Point*) points + (byte~) main::$3).x
-Rewriting struct pointer member access *((const struct Point*) points + (byte~) main::$4).y
-Rewriting struct pointer member access *((const struct Point*) points + (byte~) main::$5).x
-Rewriting struct pointer member access *((const struct Point*) points + (byte~) main::$6).y
+Replacing struct member reference *((const struct Point*) points + (byte~) main::$3).x with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$3)
+Replacing struct member reference *((const struct Point*) points + (byte~) main::$4).y with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$4)
+Replacing struct member reference *((const struct Point*) points + (byte~) main::$5).x with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$5)
+Replacing struct member reference *((const struct Point*) points + (byte~) main::$6).y with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$6)
 Culled Empty Block (label) main::@4
 
 CONTROL FLOW GRAPH SSA
@@ -19,12 +19,10 @@ main: scope:[main]  from @1
 main::@1: scope:[main]  from main main::@1
   (byte) main::i#2 ← phi( main/(byte) main::i#0 main::@1/(byte) main::i#1 )
   (byte~) main::$3 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
-  (byte*~) main::$7 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
-  *((byte*~) main::$7 + (byte~) main::$3) ← (byte) main::i#2
+  *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$3) ← (byte) main::i#2
   (number~) main::$0 ← (byte) main::i#2 + (number) 1
   (byte~) main::$4 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
-  (byte*~) main::$8 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
-  *((byte*~) main::$8 + (byte~) main::$4) ← (number~) main::$0
+  *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$4) ← (number~) main::$0
   (byte) main::i#1 ← (byte) main::i#2 + rangenext(0,4)
   (bool~) main::$1 ← (byte) main::i#1 != rangelast(0,4)
   if((bool~) main::$1) goto main::@1
@@ -35,11 +33,9 @@ main::@2: scope:[main]  from main::@1
 main::@3: scope:[main]  from main::@2 main::@3
   (byte) main::i1#2 ← phi( main::@2/(byte) main::i1#0 main::@3/(byte) main::i1#1 )
   (byte~) main::$5 ← (byte) main::i1#2 * (const byte) SIZEOF_STRUCT_POINT
-  (byte*~) main::$9 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
-  *((const byte*) main::SCREEN + (byte) main::i1#2) ← *((byte*~) main::$9 + (byte~) main::$5)
+  *((const byte*) main::SCREEN + (byte) main::i1#2) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$5)
   (byte~) main::$6 ← (byte) main::i1#2 * (const byte) SIZEOF_STRUCT_POINT
-  (byte*~) main::$10 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
-  *((const byte*) main::SCREEN+(number) $28 + (byte) main::i1#2) ← *((byte*~) main::$10 + (byte~) main::$6)
+  *((const byte*) main::SCREEN+(number) $28 + (byte) main::i1#2) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$6)
   (byte) main::i1#1 ← (byte) main::i1#2 + rangenext(0,4)
   (bool~) main::$2 ← (byte) main::i1#1 != rangelast(0,4)
   if((bool~) main::$2) goto main::@3
@@ -67,15 +63,11 @@ SYMBOL TABLE SSA
 (void()) main()
 (number~) main::$0
 (bool~) main::$1
-(byte*~) main::$10
 (bool~) main::$2
 (byte~) main::$3
 (byte~) main::$4
 (byte~) main::$5
 (byte~) main::$6
-(byte*~) main::$7
-(byte*~) main::$8
-(byte*~) main::$9
 (label) main::@1
 (label) main::@2
 (label) main::@3
@@ -93,7 +85,7 @@ SYMBOL TABLE SSA
 
 Adding number conversion cast (unumber) 1 in (number~) main::$0 ← (byte) main::i#2 + (number) 1
 Adding number conversion cast (unumber) main::$0 in (number~) main::$0 ← (byte) main::i#2 + (unumber)(number) 1
-Adding number conversion cast (unumber) $28 in *((const byte*) main::SCREEN+(number) $28 + (byte) main::i1#2) ← *((byte*~) main::$10 + (byte~) main::$6)
+Adding number conversion cast (unumber) $28 in *((const byte*) main::SCREEN+(number) $28 + (byte) main::i1#2) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$6)
 Successful SSA optimization PassNAddNumberTypeConversions
 Simplifying constant pointer cast (byte*) 1024
 Simplifying constant integer cast 1
@@ -103,30 +95,21 @@ Finalized unsigned number type (byte) 1
 Finalized unsigned number type (byte) $28
 Successful SSA optimization PassNFinalizeNumberTypeConversions
 Inferred type updated to byte in (unumber~) main::$0 ← (byte) main::i#2 + (byte) 1
-Identified duplicate assignment right side [6] (byte~) main::$4 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
-Identified duplicate assignment right side [17] (byte~) main::$6 ← (byte) main::i1#2 * (const byte) SIZEOF_STRUCT_POINT
+Identified duplicate assignment right side [5] (byte~) main::$4 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
+Identified duplicate assignment right side [14] (byte~) main::$6 ← (byte) main::i1#2 * (const byte) SIZEOF_STRUCT_POINT
 Successful SSA optimization Pass2DuplicateRValueIdentification
-Simple Condition (bool~) main::$1 [11] if((byte) main::i#1!=rangelast(0,4)) goto main::@1
-Simple Condition (bool~) main::$2 [22] if((byte) main::i1#1!=rangelast(0,4)) goto main::@3
+Simple Condition (bool~) main::$1 [9] if((byte) main::i#1!=rangelast(0,4)) goto main::@1
+Simple Condition (bool~) main::$2 [18] if((byte) main::i1#1!=rangelast(0,4)) goto main::@3
 Successful SSA optimization Pass2ConditionalJumpSimplification
-Constant right-side identified [3] (byte*~) main::$7 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
-Constant right-side identified [7] (byte*~) main::$8 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
-Constant right-side identified [15] (byte*~) main::$9 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
-Constant right-side identified [18] (byte*~) main::$10 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
-Successful SSA optimization Pass2ConstantRValueConsolidation
 Constant (const byte) main::i#0 = 0
-Constant (const byte*) main::$7 = (byte*)points+OFFSET_STRUCT_POINT_X
-Constant (const byte*) main::$8 = (byte*)points+OFFSET_STRUCT_POINT_Y
 Constant (const byte) main::i1#0 = 0
-Constant (const byte*) main::$9 = (byte*)points+OFFSET_STRUCT_POINT_X
-Constant (const byte*) main::$10 = (byte*)points+OFFSET_STRUCT_POINT_Y
 Successful SSA optimization Pass2ConstantIdentification
-Resolved ranged next value [9] main::i#1 ← ++ main::i#2 to ++
-Resolved ranged comparison value [11] if(main::i#1!=rangelast(0,4)) goto main::@1 to (number) 5
-Resolved ranged next value [20] main::i1#1 ← ++ main::i1#2 to ++
-Resolved ranged comparison value [22] if(main::i1#1!=rangelast(0,4)) goto main::@3 to (number) 5
-Simplifying expression containing zero (byte*)points in 
-Simplifying expression containing zero (byte*)points in 
+Resolved ranged next value [7] main::i#1 ← ++ main::i#2 to ++
+Resolved ranged comparison value [9] if(main::i#1!=rangelast(0,4)) goto main::@1 to (number) 5
+Resolved ranged next value [16] main::i1#1 ← ++ main::i1#2 to ++
+Resolved ranged comparison value [18] if(main::i1#1!=rangelast(0,4)) goto main::@3 to (number) 5
+Simplifying expression containing zero (byte*)points in [3] *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$3) ← (byte) main::i#2
+Simplifying expression containing zero (byte*)points in [13] *((const byte*) main::SCREEN + (byte) main::i1#2) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$5)
 Successful SSA optimization PassNSimplifyExpressionWithZero
 Eliminating unused constant (const byte) OFFSET_STRUCT_POINT_X
 Successful SSA optimization PassNEliminateUnusedVars
@@ -149,10 +132,6 @@ Inlining constant with var siblings (const byte) main::i#0
 Inlining constant with var siblings (const byte) main::i1#0
 Constant inlined main::i#0 = (byte) 0
 Constant inlined main::i1#0 = (byte) 0
-Constant inlined main::$9 = (byte*)(const struct Point*) points
-Constant inlined main::$7 = (byte*)(const struct Point*) points
-Constant inlined main::$10 = (byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y
-Constant inlined main::$8 = (byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y
 Successful SSA optimization Pass2ConstantInlining
 Eliminating unused constant (const byte) SIZEOF_STRUCT_POINT
 Successful SSA optimization PassNEliminateUnusedVars
diff --git a/src/test/ref/struct-ptr-12.log b/src/test/ref/struct-ptr-12.log
index 82a81ca97..ecdd29810 100644
--- a/src/test/ref/struct-ptr-12.log
+++ b/src/test/ref/struct-ptr-12.log
@@ -1,7 +1,7 @@
 Setting inferred volatile on symbol affected by address-of (struct Point*) main::q ← &(struct Point) main::p
 Adding value bulk copy *(&(struct Point) main::p) ← memcpy(*(&(const struct Point) $0), struct Point, (const byte) SIZEOF_STRUCT_POINT)
-Rewriting struct pointer member access *((struct Point*) main::q).x
-Rewriting struct pointer member access *((struct Point*) main::q).y
+Replacing struct member reference *((struct Point*) main::q).x with member unwinding reference *((byte*~) main::$0)
+Replacing struct member reference *((struct Point*) main::q).y with member unwinding reference *((byte*~) main::$1)
 Identified constant variable (struct Point*) main::q
 
 CONTROL FLOW GRAPH SSA
diff --git a/src/test/ref/struct-ptr-13.log b/src/test/ref/struct-ptr-13.log
index 9dff89dd7..63939c785 100644
--- a/src/test/ref/struct-ptr-13.log
+++ b/src/test/ref/struct-ptr-13.log
@@ -1,9 +1,9 @@
-Rewriting struct pointer member access *((struct Point*) points).x
-Rewriting struct pointer member access *((struct Point*) points).x
-Rewriting struct pointer member access *((struct Point*) points).y
-Rewriting struct pointer member access *((struct Point*) points).y
-Rewriting struct pointer member access *((struct Point*) points).x
-Rewriting struct pointer member access *((struct Point*) points).y
+Replacing struct member reference *((struct Point*) points).x with member unwinding reference *((byte*~) main::$0)
+Replacing struct member reference *((struct Point*) points).x with member unwinding reference *((byte*~) main::$1)
+Replacing struct member reference *((struct Point*) points).y with member unwinding reference *((byte*~) main::$2)
+Replacing struct member reference *((struct Point*) points).y with member unwinding reference *((byte*~) main::$3)
+Replacing struct member reference *((struct Point*) points).x with member unwinding reference *((byte*~) main::$4)
+Replacing struct member reference *((struct Point*) points).y with member unwinding reference *((byte*~) main::$5)
 Identified constant variable (struct Point*) points
 
 CONTROL FLOW GRAPH SSA
diff --git a/src/test/ref/struct-ptr-14.log b/src/test/ref/struct-ptr-14.log
index df3a50483..9f5cc4ad5 100644
--- a/src/test/ref/struct-ptr-14.log
+++ b/src/test/ref/struct-ptr-14.log
@@ -1,9 +1,9 @@
 Setting inferred volatile on symbol affected by address-of (struct Point*) main::q ← &(struct Point) main::p
 Adding value bulk copy *(&(struct Point) main::p) ← memcpy(*(&(const struct Point) $0), struct Point, (const byte) SIZEOF_STRUCT_POINT)
-Rewriting struct pointer member access *((struct Point*) main::q).x
-Rewriting struct pointer member access *((struct Point*) main::q).y
-Rewriting struct pointer member access *((struct Point*) set::ptr).x
-Rewriting struct pointer member access *((struct Point*) set::ptr).y
+Replacing struct member reference *((struct Point*) main::q).x with member unwinding reference *((byte*~) main::$1)
+Replacing struct member reference *((struct Point*) main::q).y with member unwinding reference *((byte*~) main::$2)
+Replacing struct member reference *((struct Point*) set::ptr).x with member unwinding reference *((byte*~) set::$0)
+Replacing struct member reference *((struct Point*) set::ptr).y with member unwinding reference *((byte*~) set::$1)
 Identified constant variable (struct Point*) main::q
 Culled Empty Block (label) @1
 
diff --git a/src/test/ref/struct-ptr-15.asm b/src/test/ref/struct-ptr-15.asm
index eaace9b4b..7801f7ff1 100644
--- a/src/test/ref/struct-ptr-15.asm
+++ b/src/test/ref/struct-ptr-15.asm
@@ -7,7 +7,7 @@
   .const OFFSET_STRUCT_POINT_Y = 1
 main: {
     .label SCREEN = $400
-    .label __14 = 6
+    .label __9 = 6
     .label x = 5
     .label ptr = 2
     .label i = 4
@@ -37,12 +37,12 @@ main: {
     tya
     clc
     adc.z ptr
-    sta.z __14
+    sta.z __9
     lda #0
     adc.z ptr+1
-    sta.z __14+1
+    sta.z __9+1
     ldy #OFFSET_STRUCT_POINT_Y
-    lda (__14),y
+    lda (__9),y
     tay
     lda.z x
     sta SCREEN,x
diff --git a/src/test/ref/struct-ptr-15.cfg b/src/test/ref/struct-ptr-15.cfg
index 18ee6957e..a23eb545d 100644
--- a/src/test/ref/struct-ptr-15.cfg
+++ b/src/test/ref/struct-ptr-15.cfg
@@ -22,8 +22,8 @@ main::@1: scope:[main]  from main main::@1
   [10] (byte) main::idx#3 ← phi( main/(byte) 0 main::@1/(byte) main::idx#2 )
   [10] (struct Circle*) main::ptr#2 ← phi( main/(const struct Circle*) circles main::@1/(struct Circle*) main::ptr#1 )
   [11] (byte) main::x#0 ← *((byte*)(struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER)
-  [12] (struct Point*~) main::$14 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
-  [13] (byte) main::y#0 ← *((byte*)(struct Point*~) main::$14 + (const byte) OFFSET_STRUCT_POINT_Y)
+  [12] (struct Point*~) main::$9 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
+  [13] (byte) main::y#0 ← *((byte*)(struct Point*~) main::$9 + (const byte) OFFSET_STRUCT_POINT_Y)
   [14] *((const byte*) main::SCREEN + (byte) main::idx#3) ← (byte) main::x#0
   [15] (byte) main::idx#1 ← ++ (byte) main::idx#3
   [16] *((const byte*) main::SCREEN + (byte) main::idx#1) ← (byte) main::y#0
diff --git a/src/test/ref/struct-ptr-15.log b/src/test/ref/struct-ptr-15.log
index 10e7968dc..2df0d8486 100644
--- a/src/test/ref/struct-ptr-15.log
+++ b/src/test/ref/struct-ptr-15.log
@@ -5,20 +5,14 @@ Fixing pointer array-indexing *((const struct Circle*) circles + (number) 0)
 Fixing pointer array-indexing *((const struct Circle*) circles + (number) 1)
 Fixing pointer array-indexing *((const struct Circle*) circles + (number) 1)
 Fixing pointer array-indexing *((const struct Circle*) circles + (number) 1)
-Rewriting struct pointer member access *((const struct Circle*) circles + (number~) main::$1).center
-Rewriting struct pointer member access *((const struct Circle*) circles + (number~) main::$2).center
-Rewriting struct pointer member access *((const struct Circle*) circles + (number~) main::$3).radius
-Rewriting struct pointer member access *((const struct Circle*) circles + (number~) main::$4).center
-Rewriting struct pointer member access *((const struct Circle*) circles + (number~) main::$5).center
-Rewriting struct pointer member access *((const struct Circle*) circles + (number~) main::$6).radius
-Rewriting struct pointer member access *((struct Circle*) main::ptr).center
-Rewriting struct pointer member access *((struct Circle*) main::ptr).center
-Rewriting struct pointer member access *((struct Point*~) main::$7 + (number~) main::$1).x
-Rewriting struct pointer member access *((struct Point*~) main::$8 + (number~) main::$2).y
-Rewriting struct pointer member access *((struct Point*~) main::$10 + (number~) main::$4).x
-Rewriting struct pointer member access *((struct Point*~) main::$11 + (number~) main::$5).y
-Rewriting struct pointer member access *((struct Point*~) main::$13).x
-Rewriting struct pointer member access *((struct Point*~) main::$14).y
+Replacing struct member reference *((const struct Circle*) circles + (number~) main::$1).center.x with member unwinding reference *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$1)
+Replacing struct member reference *((const struct Circle*) circles + (number~) main::$2).center.y with member unwinding reference *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$2)
+Replacing struct member reference *((const struct Circle*) circles + (number~) main::$3).radius with member unwinding reference *((byte*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_RADIUS + (number~) main::$3)
+Replacing struct member reference *((const struct Circle*) circles + (number~) main::$4).center.x with member unwinding reference *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$4)
+Replacing struct member reference *((const struct Circle*) circles + (number~) main::$5).center.y with member unwinding reference *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$5)
+Replacing struct member reference *((const struct Circle*) circles + (number~) main::$6).radius with member unwinding reference *((byte*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_RADIUS + (number~) main::$6)
+Replacing struct member reference *((struct Circle*) main::ptr).center.x with member unwinding reference *((byte*~) main::$8)
+Replacing struct member reference *((struct Circle*) main::ptr).center.y with member unwinding reference *((byte*~) main::$10)
 Culled Empty Block (label) main::@2
 
 CONTROL FLOW GRAPH SSA
@@ -28,27 +22,17 @@ CONTROL FLOW GRAPH SSA
 (void()) main()
 main: scope:[main]  from @1
   (number~) main::$1 ← (number) 0 * (const byte) SIZEOF_STRUCT_CIRCLE
-  (struct Point*~) main::$7 ← (struct Point*)(const struct Circle*) circles + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
-  (byte*~) main::$15 ← (byte*)(struct Point*~) main::$7 + (const byte) OFFSET_STRUCT_POINT_X
-  *((byte*~) main::$15 + (number~) main::$1) ← (number) 2
+  *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$1) ← (number) 2
   (number~) main::$2 ← (number) 0 * (const byte) SIZEOF_STRUCT_CIRCLE
-  (struct Point*~) main::$8 ← (struct Point*)(const struct Circle*) circles + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
-  (byte*~) main::$16 ← (byte*)(struct Point*~) main::$8 + (const byte) OFFSET_STRUCT_POINT_Y
-  *((byte*~) main::$16 + (number~) main::$2) ← (number) 3
+  *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$2) ← (number) 3
   (number~) main::$3 ← (number) 0 * (const byte) SIZEOF_STRUCT_CIRCLE
-  (byte*~) main::$9 ← (byte*)(const struct Circle*) circles + (const byte) OFFSET_STRUCT_CIRCLE_RADIUS
-  *((byte*~) main::$9 + (number~) main::$3) ← (number) 5
+  *((byte*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_RADIUS + (number~) main::$3) ← (number) 5
   (number~) main::$4 ← (number) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
-  (struct Point*~) main::$10 ← (struct Point*)(const struct Circle*) circles + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
-  (byte*~) main::$17 ← (byte*)(struct Point*~) main::$10 + (const byte) OFFSET_STRUCT_POINT_X
-  *((byte*~) main::$17 + (number~) main::$4) ← (number) 8
+  *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$4) ← (number) 8
   (number~) main::$5 ← (number) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
-  (struct Point*~) main::$11 ← (struct Point*)(const struct Circle*) circles + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
-  (byte*~) main::$18 ← (byte*)(struct Point*~) main::$11 + (const byte) OFFSET_STRUCT_POINT_Y
-  *((byte*~) main::$18 + (number~) main::$5) ← (number) 9
+  *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$5) ← (number) 9
   (number~) main::$6 ← (number) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
-  (byte*~) main::$12 ← (byte*)(const struct Circle*) circles + (const byte) OFFSET_STRUCT_CIRCLE_RADIUS
-  *((byte*~) main::$12 + (number~) main::$6) ← (number) $f
+  *((byte*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_RADIUS + (number~) main::$6) ← (number) $f
   (byte) main::idx#0 ← (byte) 0
   (struct Circle*) main::ptr#0 ← (const struct Circle*) circles
   (byte) main::i#0 ← (byte) 0
@@ -57,12 +41,12 @@ main::@1: scope:[main]  from main main::@1
   (byte) main::i#2 ← phi( main/(byte) main::i#0 main::@1/(byte) main::i#1 )
   (byte) main::idx#3 ← phi( main/(byte) main::idx#0 main::@1/(byte) main::idx#2 )
   (struct Circle*) main::ptr#2 ← phi( main/(struct Circle*) main::ptr#0 main::@1/(struct Circle*) main::ptr#1 )
-  (struct Point*~) main::$13 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
-  (byte*~) main::$19 ← (byte*)(struct Point*~) main::$13 + (const byte) OFFSET_STRUCT_POINT_X
-  (byte) main::x#0 ← *((byte*~) main::$19)
-  (struct Point*~) main::$14 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
-  (byte*~) main::$20 ← (byte*)(struct Point*~) main::$14 + (const byte) OFFSET_STRUCT_POINT_Y
-  (byte) main::y#0 ← *((byte*~) main::$20)
+  (struct Point*~) main::$7 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
+  (byte*~) main::$8 ← (byte*)(struct Point*~) main::$7 + (const byte) OFFSET_STRUCT_POINT_X
+  (byte) main::x#0 ← *((byte*~) main::$8)
+  (struct Point*~) main::$9 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
+  (byte*~) main::$10 ← (byte*)(struct Point*~) main::$9 + (const byte) OFFSET_STRUCT_POINT_Y
+  (byte) main::y#0 ← *((byte*~) main::$10)
   *((const byte*) main::SCREEN + (byte) main::idx#3) ← (byte) main::x#0
   (byte) main::idx#1 ← ++ (byte) main::idx#3
   *((const byte*) main::SCREEN + (byte) main::idx#1) ← (byte) main::y#0
@@ -100,25 +84,15 @@ SYMBOL TABLE SSA
 (void()) main()
 (bool~) main::$0
 (number~) main::$1
-(struct Point*~) main::$10
-(struct Point*~) main::$11
-(byte*~) main::$12
-(struct Point*~) main::$13
-(struct Point*~) main::$14
-(byte*~) main::$15
-(byte*~) main::$16
-(byte*~) main::$17
-(byte*~) main::$18
-(byte*~) main::$19
+(byte*~) main::$10
 (number~) main::$2
-(byte*~) main::$20
 (number~) main::$3
 (number~) main::$4
 (number~) main::$5
 (number~) main::$6
 (struct Point*~) main::$7
-(struct Point*~) main::$8
-(byte*~) main::$9
+(byte*~) main::$8
+(struct Point*~) main::$9
 (label) main::@1
 (label) main::@return
 (const byte*) main::SCREEN = (byte*)(number) $400
@@ -142,29 +116,29 @@ SYMBOL TABLE SSA
 
 Adding number conversion cast (unumber) 0 in (number~) main::$1 ← (number) 0 * (const byte) SIZEOF_STRUCT_CIRCLE
 Adding number conversion cast (unumber) main::$1 in (number~) main::$1 ← (unumber)(number) 0 * (const byte) SIZEOF_STRUCT_CIRCLE
-Adding number conversion cast (unumber) 2 in *((byte*~) main::$15 + (unumber~) main::$1) ← (number) 2
+Adding number conversion cast (unumber) 2 in *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_X + (unumber~) main::$1) ← (number) 2
 Adding number conversion cast (unumber) 0 in (number~) main::$2 ← (number) 0 * (const byte) SIZEOF_STRUCT_CIRCLE
 Adding number conversion cast (unumber) main::$2 in (number~) main::$2 ← (unumber)(number) 0 * (const byte) SIZEOF_STRUCT_CIRCLE
-Adding number conversion cast (unumber) 3 in *((byte*~) main::$16 + (unumber~) main::$2) ← (number) 3
+Adding number conversion cast (unumber) 3 in *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_Y + (unumber~) main::$2) ← (number) 3
 Adding number conversion cast (unumber) 0 in (number~) main::$3 ← (number) 0 * (const byte) SIZEOF_STRUCT_CIRCLE
 Adding number conversion cast (unumber) main::$3 in (number~) main::$3 ← (unumber)(number) 0 * (const byte) SIZEOF_STRUCT_CIRCLE
-Adding number conversion cast (unumber) 5 in *((byte*~) main::$9 + (unumber~) main::$3) ← (number) 5
+Adding number conversion cast (unumber) 5 in *((byte*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_RADIUS + (unumber~) main::$3) ← (number) 5
 Adding number conversion cast (unumber) 1 in (number~) main::$4 ← (number) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
 Adding number conversion cast (unumber) main::$4 in (number~) main::$4 ← (unumber)(number) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
-Adding number conversion cast (unumber) 8 in *((byte*~) main::$17 + (unumber~) main::$4) ← (number) 8
+Adding number conversion cast (unumber) 8 in *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_X + (unumber~) main::$4) ← (number) 8
 Adding number conversion cast (unumber) 1 in (number~) main::$5 ← (number) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
 Adding number conversion cast (unumber) main::$5 in (number~) main::$5 ← (unumber)(number) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
-Adding number conversion cast (unumber) 9 in *((byte*~) main::$18 + (unumber~) main::$5) ← (number) 9
+Adding number conversion cast (unumber) 9 in *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_Y + (unumber~) main::$5) ← (number) 9
 Adding number conversion cast (unumber) 1 in (number~) main::$6 ← (number) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
 Adding number conversion cast (unumber) main::$6 in (number~) main::$6 ← (unumber)(number) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
-Adding number conversion cast (unumber) $f in *((byte*~) main::$12 + (unumber~) main::$6) ← (number) $f
+Adding number conversion cast (unumber) $f in *((byte*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_RADIUS + (unumber~) main::$6) ← (number) $f
 Successful SSA optimization PassNAddNumberTypeConversions
-Inlining cast *((byte*~) main::$15 + (unumber~) main::$1) ← (unumber)(number) 2
-Inlining cast *((byte*~) main::$16 + (unumber~) main::$2) ← (unumber)(number) 3
-Inlining cast *((byte*~) main::$9 + (unumber~) main::$3) ← (unumber)(number) 5
-Inlining cast *((byte*~) main::$17 + (unumber~) main::$4) ← (unumber)(number) 8
-Inlining cast *((byte*~) main::$18 + (unumber~) main::$5) ← (unumber)(number) 9
-Inlining cast *((byte*~) main::$12 + (unumber~) main::$6) ← (unumber)(number) $f
+Inlining cast *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_X + (unumber~) main::$1) ← (unumber)(number) 2
+Inlining cast *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_Y + (unumber~) main::$2) ← (unumber)(number) 3
+Inlining cast *((byte*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_RADIUS + (unumber~) main::$3) ← (unumber)(number) 5
+Inlining cast *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_X + (unumber~) main::$4) ← (unumber)(number) 8
+Inlining cast *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_Y + (unumber~) main::$5) ← (unumber)(number) 9
+Inlining cast *((byte*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_RADIUS + (unumber~) main::$6) ← (unumber)(number) $f
 Successful SSA optimization Pass2InlineCast
 Simplifying constant pointer cast (byte*) 1024
 Simplifying constant integer cast 0
@@ -199,68 +173,51 @@ Inferred type updated to byte in (unumber~) main::$3 ← (byte) 0 * (const byte)
 Inferred type updated to byte in (unumber~) main::$4 ← (byte) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
 Inferred type updated to byte in (unumber~) main::$5 ← (byte) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
 Inferred type updated to byte in (unumber~) main::$6 ← (byte) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
-Simple Condition (bool~) main::$0 [39] if((byte) main::i#1!=rangelast(0,1)) goto main::@1
+Simple Condition (bool~) main::$0 [29] if((byte) main::i#1!=rangelast(0,1)) goto main::@1
 Successful SSA optimization Pass2ConditionalJumpSimplification
 Constant right-side identified [0] (byte~) main::$1 ← (byte) 0 * (const byte) SIZEOF_STRUCT_CIRCLE
-Constant right-side identified [1] (struct Point*~) main::$7 ← (struct Point*)(const struct Circle*) circles + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
-Constant right-side identified [4] (byte~) main::$2 ← (byte) 0 * (const byte) SIZEOF_STRUCT_CIRCLE
-Constant right-side identified [5] (struct Point*~) main::$8 ← (struct Point*)(const struct Circle*) circles + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
-Constant right-side identified [8] (byte~) main::$3 ← (byte) 0 * (const byte) SIZEOF_STRUCT_CIRCLE
-Constant right-side identified [9] (byte*~) main::$9 ← (byte*)(const struct Circle*) circles + (const byte) OFFSET_STRUCT_CIRCLE_RADIUS
-Constant right-side identified [11] (byte~) main::$4 ← (byte) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
-Constant right-side identified [12] (struct Point*~) main::$10 ← (struct Point*)(const struct Circle*) circles + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
-Constant right-side identified [15] (byte~) main::$5 ← (byte) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
-Constant right-side identified [16] (struct Point*~) main::$11 ← (struct Point*)(const struct Circle*) circles + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
-Constant right-side identified [19] (byte~) main::$6 ← (byte) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
-Constant right-side identified [20] (byte*~) main::$12 ← (byte*)(const struct Circle*) circles + (const byte) OFFSET_STRUCT_CIRCLE_RADIUS
+Constant right-side identified [2] (byte~) main::$2 ← (byte) 0 * (const byte) SIZEOF_STRUCT_CIRCLE
+Constant right-side identified [4] (byte~) main::$3 ← (byte) 0 * (const byte) SIZEOF_STRUCT_CIRCLE
+Constant right-side identified [6] (byte~) main::$4 ← (byte) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
+Constant right-side identified [8] (byte~) main::$5 ← (byte) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
+Constant right-side identified [10] (byte~) main::$6 ← (byte) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
 Successful SSA optimization Pass2ConstantRValueConsolidation
 Constant (const byte) main::$1 = 0*SIZEOF_STRUCT_CIRCLE
-Constant (const struct Point*) main::$7 = (struct Point*)circles+OFFSET_STRUCT_CIRCLE_CENTER
 Constant (const byte) main::$2 = 0*SIZEOF_STRUCT_CIRCLE
-Constant (const struct Point*) main::$8 = (struct Point*)circles+OFFSET_STRUCT_CIRCLE_CENTER
 Constant (const byte) main::$3 = 0*SIZEOF_STRUCT_CIRCLE
-Constant (const byte*) main::$9 = (byte*)circles+OFFSET_STRUCT_CIRCLE_RADIUS
 Constant (const byte) main::$4 = 1*SIZEOF_STRUCT_CIRCLE
-Constant (const struct Point*) main::$10 = (struct Point*)circles+OFFSET_STRUCT_CIRCLE_CENTER
 Constant (const byte) main::$5 = 1*SIZEOF_STRUCT_CIRCLE
-Constant (const struct Point*) main::$11 = (struct Point*)circles+OFFSET_STRUCT_CIRCLE_CENTER
 Constant (const byte) main::$6 = 1*SIZEOF_STRUCT_CIRCLE
-Constant (const byte*) main::$12 = (byte*)circles+OFFSET_STRUCT_CIRCLE_RADIUS
 Constant (const byte) main::idx#0 = 0
 Constant (const struct Circle*) main::ptr#0 = circles
 Constant (const byte) main::i#0 = 0
 Successful SSA optimization Pass2ConstantIdentification
-Constant value identified (byte*)main::$7 in [2] (byte*~) main::$15 ← (byte*)(const struct Point*) main::$7 + (const byte) OFFSET_STRUCT_POINT_X
-Constant value identified (byte*)main::$8 in [6] (byte*~) main::$16 ← (byte*)(const struct Point*) main::$8 + (const byte) OFFSET_STRUCT_POINT_Y
-Constant value identified (byte*)main::$10 in [13] (byte*~) main::$17 ← (byte*)(const struct Point*) main::$10 + (const byte) OFFSET_STRUCT_POINT_X
-Constant value identified (byte*)main::$11 in [17] (byte*~) main::$18 ← (byte*)(const struct Point*) main::$11 + (const byte) OFFSET_STRUCT_POINT_Y
-Successful SSA optimization Pass2ConstantValues
-Resolved ranged next value [37] main::i#1 ← ++ main::i#2 to ++
-Resolved ranged comparison value [39] if(main::i#1!=rangelast(0,1)) goto main::@1 to (number) 2
-Converting *(pointer+n) to pointer[n] [28] (byte) main::x#0 ← *((byte*~) main::$19)  -- *((byte*)main::$13 + OFFSET_STRUCT_POINT_X)
-Converting *(pointer+n) to pointer[n] [31] (byte) main::y#0 ← *((byte*~) main::$20)  -- *((byte*)main::$14 + OFFSET_STRUCT_POINT_Y)
+Resolved ranged next value [27] main::i#1 ← ++ main::i#2 to ++
+Resolved ranged comparison value [29] if(main::i#1!=rangelast(0,1)) goto main::@1 to (number) 2
+Converting *(pointer+n) to pointer[n] [18] (byte) main::x#0 ← *((byte*~) main::$8)  -- *((byte*)main::$7 + OFFSET_STRUCT_POINT_X)
+Converting *(pointer+n) to pointer[n] [21] (byte) main::y#0 ← *((byte*~) main::$10)  -- *((byte*)main::$9 + OFFSET_STRUCT_POINT_Y)
 Successful SSA optimization Pass2InlineDerefIdx
 Simplifying constant evaluating to zero (byte) 0*(const byte) SIZEOF_STRUCT_CIRCLE in 
 Simplifying constant evaluating to zero (byte) 0*(const byte) SIZEOF_STRUCT_CIRCLE in 
 Simplifying constant evaluating to zero (byte) 0*(const byte) SIZEOF_STRUCT_CIRCLE in 
 Successful SSA optimization PassNSimplifyConstantZero
-Simplifying expression containing zero (byte*)circles in 
-Simplifying expression containing zero (byte*)circles in 
-Simplifying expression containing zero (byte*)main::$7 in [2] (byte*~) main::$15 ← (byte*)(const struct Point*) main::$7 + (const byte) OFFSET_STRUCT_POINT_X
-Simplifying expression containing zero main::$15 in [3] *((byte*~) main::$15 + (const byte) main::$1) ← (byte) 2
-Simplifying expression containing zero main::$16 in [7] *((byte*~) main::$16 + (const byte) main::$2) ← (byte) 3
-Simplifying expression containing zero main::$9 in [10] *((const byte*) main::$9 + (const byte) main::$3) ← (byte) 5
-Simplifying expression containing zero (byte*)main::$10 in [13] (byte*~) main::$17 ← (byte*)(const struct Point*) main::$10 + (const byte) OFFSET_STRUCT_POINT_X
-Simplifying expression containing zero (byte*)main::$13 in [27] (byte*~) main::$19 ← (byte*)(struct Point*~) main::$13 + (const byte) OFFSET_STRUCT_POINT_X
-Simplifying expression containing zero (byte*)main::$13 in [28] (byte) main::x#0 ← *((byte*)(struct Point*~) main::$13 + (const byte) OFFSET_STRUCT_POINT_X)
+Simplifying expression containing zero (byte*)(struct Point*)circles+OFFSET_STRUCT_CIRCLE_CENTER+OFFSET_STRUCT_POINT_X in [1] *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_X + (const byte) main::$1) ← (byte) 2
+Simplifying expression containing zero (byte*)(struct Point*)circles+OFFSET_STRUCT_CIRCLE_CENTER in [1] *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_X) ← (byte) 2
+Simplifying expression containing zero (byte*)(struct Point*)circles+OFFSET_STRUCT_CIRCLE_CENTER+OFFSET_STRUCT_POINT_Y in [3] *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_Y + (const byte) main::$2) ← (byte) 3
+Simplifying expression containing zero (byte*)circles+OFFSET_STRUCT_CIRCLE_RADIUS in [5] *((byte*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_RADIUS + (const byte) main::$3) ← (byte) 5
+Simplifying expression containing zero (byte*)circles in [5] *((byte*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_RADIUS) ← (byte) 5
+Simplifying expression containing zero (byte*)(struct Point*)circles+OFFSET_STRUCT_CIRCLE_CENTER in [7] *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_X + (const byte) main::$4) ← (byte) 8
+Simplifying expression containing zero (byte*)circles in [11] *((byte*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_RADIUS + (const byte) main::$6) ← (byte) $f
+Simplifying expression containing zero (byte*)main::$7 in [17] (byte*~) main::$8 ← (byte*)(struct Point*~) main::$7 + (const byte) OFFSET_STRUCT_POINT_X
+Simplifying expression containing zero (byte*)main::$7 in [18] (byte) main::x#0 ← *((byte*)(struct Point*~) main::$7 + (const byte) OFFSET_STRUCT_POINT_X)
 Successful SSA optimization PassNSimplifyExpressionWithZero
-Eliminating unused variable (byte*~) main::$19 and assignment [12] (byte*~) main::$19 ← (byte*)(struct Point*~) main::$13
-Eliminating unused variable (byte*~) main::$20 and assignment [15] (byte*~) main::$20 ← (byte*)(struct Point*~) main::$14 + (const byte) OFFSET_STRUCT_POINT_Y
+Eliminating unused variable (byte*~) main::$8 and assignment [8] (byte*~) main::$8 ← (byte*)(struct Point*~) main::$7
+Eliminating unused variable (byte*~) main::$10 and assignment [11] (byte*~) main::$10 ← (byte*)(struct Point*~) main::$9 + (const byte) OFFSET_STRUCT_POINT_Y
 Eliminating unused constant (const byte) main::$1
 Eliminating unused constant (const byte) main::$2
 Eliminating unused constant (const byte) main::$3
-Eliminating unused constant (const byte) OFFSET_STRUCT_CIRCLE_RADIUS
 Eliminating unused constant (const byte) OFFSET_STRUCT_POINT_X
+Eliminating unused constant (const byte) OFFSET_STRUCT_CIRCLE_RADIUS
 Successful SSA optimization PassNEliminateUnusedVars
 Adding number conversion cast (unumber) 2 in if((byte) main::i#1!=(number) 2) goto main::@1
 Successful SSA optimization PassNAddNumberTypeConversions
@@ -268,37 +225,19 @@ Simplifying constant integer cast 2
 Successful SSA optimization PassNCastSimplification
 Finalized unsigned number type (byte) 2
 Successful SSA optimization PassNFinalizeNumberTypeConversions
-Constant right-side identified [2] (byte*~) main::$16 ← (byte*)(const struct Point*) main::$8 + (const byte) OFFSET_STRUCT_POINT_Y
-Constant right-side identified [7] (byte*~) main::$18 ← (byte*)(const struct Point*) main::$11 + (const byte) OFFSET_STRUCT_POINT_Y
-Successful SSA optimization Pass2ConstantRValueConsolidation
-Constant (const byte*) main::$15 = (byte*)main::$7
-Constant (const byte*) main::$16 = (byte*)main::$8+OFFSET_STRUCT_POINT_Y
-Constant (const byte*) main::$17 = (byte*)main::$10
-Constant (const byte*) main::$18 = (byte*)main::$11+OFFSET_STRUCT_POINT_Y
-Successful SSA optimization Pass2ConstantIdentification
-Converting *(pointer+n) to pointer[n] [12] (byte) main::x#0 ← *((byte*)(struct Point*~) main::$13)  -- *((byte*)(struct Point*)main::ptr#2 + OFFSET_STRUCT_CIRCLE_CENTER)
+Converting *(pointer+n) to pointer[n] [8] (byte) main::x#0 ← *((byte*)(struct Point*~) main::$7)  -- *((byte*)(struct Point*)main::ptr#2 + OFFSET_STRUCT_CIRCLE_CENTER)
 Successful SSA optimization Pass2InlineDerefIdx
-Eliminating unused variable (struct Point*~) main::$13 and assignment [7] (struct Point*~) main::$13 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
+Eliminating unused variable (struct Point*~) main::$7 and assignment [7] (struct Point*~) main::$7 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
 Successful SSA optimization PassNEliminateUnusedVars
 Inlining constant with var siblings (const byte) main::idx#0
 Inlining constant with var siblings (const struct Circle*) main::ptr#0
 Inlining constant with var siblings (const byte) main::i#0
-Constant inlined main::$12 = (byte*)(const struct Circle*) circles
-Constant inlined main::ptr#0 = (const struct Circle*) circles
-Constant inlined main::$15 = (byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER
-Constant inlined main::$10 = (struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER
-Constant inlined main::$11 = (struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER
-Constant inlined main::idx#0 = (byte) 0
-Constant inlined main::$16 = (byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_Y
-Constant inlined main::$17 = (byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER
-Constant inlined main::$18 = (byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_Y
 Constant inlined main::$5 = (byte) 1*(const byte) SIZEOF_STRUCT_CIRCLE
 Constant inlined main::i#0 = (byte) 0
 Constant inlined main::$6 = (byte) 1*(const byte) SIZEOF_STRUCT_CIRCLE
+Constant inlined main::idx#0 = (byte) 0
+Constant inlined main::ptr#0 = (const struct Circle*) circles
 Constant inlined main::$4 = (byte) 1*(const byte) SIZEOF_STRUCT_CIRCLE
-Constant inlined main::$9 = (byte*)(const struct Circle*) circles
-Constant inlined main::$7 = (struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER
-Constant inlined main::$8 = (struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER
 Successful SSA optimization Pass2ConstantInlining
 Consolidated array index constant in *((byte*)(struct Point*)circles+OFFSET_STRUCT_CIRCLE_CENTER+1*SIZEOF_STRUCT_CIRCLE)
 Consolidated array index constant in *((byte*)(struct Point*)circles+OFFSET_STRUCT_CIRCLE_CENTER+OFFSET_STRUCT_POINT_Y+1*SIZEOF_STRUCT_CIRCLE)
@@ -348,8 +287,8 @@ main::@1: scope:[main]  from main main::@1
   [10] (byte) main::idx#3 ← phi( main/(byte) 0 main::@1/(byte) main::idx#2 )
   [10] (struct Circle*) main::ptr#2 ← phi( main/(const struct Circle*) circles main::@1/(struct Circle*) main::ptr#1 )
   [11] (byte) main::x#0 ← *((byte*)(struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER)
-  [12] (struct Point*~) main::$14 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
-  [13] (byte) main::y#0 ← *((byte*)(struct Point*~) main::$14 + (const byte) OFFSET_STRUCT_POINT_Y)
+  [12] (struct Point*~) main::$9 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
+  [13] (byte) main::y#0 ← *((byte*)(struct Point*~) main::$9 + (const byte) OFFSET_STRUCT_POINT_Y)
   [14] *((const byte*) main::SCREEN + (byte) main::idx#3) ← (byte) main::x#0
   [15] (byte) main::idx#1 ← ++ (byte) main::idx#3
   [16] *((const byte*) main::SCREEN + (byte) main::idx#1) ← (byte) main::y#0
@@ -369,7 +308,7 @@ VARIABLE REGISTER WEIGHTS
 (byte) Point::x
 (byte) Point::y
 (void()) main()
-(struct Point*~) main::$14 11.0
+(struct Point*~) main::$9 11.0
 (byte) main::i
 (byte) main::i#1 16.5
 (byte) main::i#2 2.4444444444444446
@@ -390,7 +329,7 @@ Initial phi equivalence classes
 [ main::idx#3 main::idx#2 ]
 [ main::i#2 main::i#1 ]
 Added variable main::x#0 to live range equivalence class [ main::x#0 ]
-Added variable main::$14 to live range equivalence class [ main::$14 ]
+Added variable main::$9 to live range equivalence class [ main::$9 ]
 Added variable main::y#0 to live range equivalence class [ main::y#0 ]
 Added variable main::idx#1 to live range equivalence class [ main::idx#1 ]
 Complete equivalence classes
@@ -398,14 +337,14 @@ Complete equivalence classes
 [ main::idx#3 main::idx#2 ]
 [ main::i#2 main::i#1 ]
 [ main::x#0 ]
-[ main::$14 ]
+[ main::$9 ]
 [ main::y#0 ]
 [ main::idx#1 ]
 Allocated zp[2]:2 [ main::ptr#2 main::ptr#1 ]
 Allocated zp[1]:4 [ main::idx#3 main::idx#2 ]
 Allocated zp[1]:5 [ main::i#2 main::i#1 ]
 Allocated zp[1]:6 [ main::x#0 ]
-Allocated zp[2]:7 [ main::$14 ]
+Allocated zp[2]:7 [ main::$9 ]
 Allocated zp[1]:9 [ main::y#0 ]
 Allocated zp[1]:10 [ main::idx#1 ]
 
@@ -438,7 +377,7 @@ __bend:
   // main
 main: {
     .label SCREEN = $400
-    .label __14 = 7
+    .label __9 = 7
     .label x = 6
     .label y = 9
     .label idx = $a
@@ -489,17 +428,17 @@ main: {
     ldy #OFFSET_STRUCT_CIRCLE_CENTER
     lda (ptr),y
     sta.z x
-    // [12] (struct Point*~) main::$14 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER -- pssz1=pssz2_plus_vbuc1 
+    // [12] (struct Point*~) main::$9 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER -- pssz1=pssz2_plus_vbuc1 
     lda #OFFSET_STRUCT_CIRCLE_CENTER
     clc
     adc.z ptr
-    sta.z __14
+    sta.z __9
     lda #0
     adc.z ptr+1
-    sta.z __14+1
-    // [13] (byte) main::y#0 ← *((byte*)(struct Point*~) main::$14 + (const byte) OFFSET_STRUCT_POINT_Y) -- vbuz1=pbuz2_derefidx_vbuc1 
+    sta.z __9+1
+    // [13] (byte) main::y#0 ← *((byte*)(struct Point*~) main::$9 + (const byte) OFFSET_STRUCT_POINT_Y) -- vbuz1=pbuz2_derefidx_vbuc1 
     ldy #OFFSET_STRUCT_POINT_Y
-    lda (__14),y
+    lda (__9),y
     sta.z y
     // [14] *((const byte*) main::SCREEN + (byte) main::idx#3) ← (byte) main::x#0 -- pbuc1_derefidx_vbuz1=vbuz2 
     lda.z x
@@ -552,9 +491,9 @@ Removing always clobbered register reg byte a as potential for zp[1]:4 [ main::i
 Removing always clobbered register reg byte y as potential for zp[1]:4 [ main::idx#3 main::idx#2 ]
 Removing always clobbered register reg byte a as potential for zp[1]:5 [ main::i#2 main::i#1 ]
 Removing always clobbered register reg byte y as potential for zp[1]:5 [ main::i#2 main::i#1 ]
-Statement [12] (struct Point*~) main::$14 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER [ main::ptr#2 main::idx#3 main::i#2 main::x#0 main::$14 ] ( main:2 [ main::ptr#2 main::idx#3 main::i#2 main::x#0 main::$14 ] ) always clobbers reg byte a 
+Statement [12] (struct Point*~) main::$9 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER [ main::ptr#2 main::idx#3 main::i#2 main::x#0 main::$9 ] ( main:2 [ main::ptr#2 main::idx#3 main::i#2 main::x#0 main::$9 ] ) always clobbers reg byte a 
 Removing always clobbered register reg byte a as potential for zp[1]:6 [ main::x#0 ]
-Statement [13] (byte) main::y#0 ← *((byte*)(struct Point*~) main::$14 + (const byte) OFFSET_STRUCT_POINT_Y) [ main::ptr#2 main::idx#3 main::i#2 main::x#0 main::y#0 ] ( main:2 [ main::ptr#2 main::idx#3 main::i#2 main::x#0 main::y#0 ] ) always clobbers reg byte a reg byte y 
+Statement [13] (byte) main::y#0 ← *((byte*)(struct Point*~) main::$9 + (const byte) OFFSET_STRUCT_POINT_Y) [ main::ptr#2 main::idx#3 main::i#2 main::x#0 main::y#0 ] ( main:2 [ main::ptr#2 main::idx#3 main::i#2 main::x#0 main::y#0 ] ) always clobbers reg byte a reg byte y 
 Removing always clobbered register reg byte y as potential for zp[1]:6 [ main::x#0 ]
 Statement [14] *((const byte*) main::SCREEN + (byte) main::idx#3) ← (byte) main::x#0 [ main::ptr#2 main::idx#3 main::i#2 main::y#0 ] ( main:2 [ main::ptr#2 main::idx#3 main::i#2 main::y#0 ] ) always clobbers reg byte a 
 Removing always clobbered register reg byte a as potential for zp[1]:9 [ main::y#0 ]
@@ -568,8 +507,8 @@ Statement [7] *((byte*)(struct Point*)(const struct Circle*) circles+(const byte
 Statement [8] *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_Y+(byte) 1*(const byte) SIZEOF_STRUCT_CIRCLE) ← (byte) 9 [ ] ( main:2 [ ] ) always clobbers reg byte a 
 Statement [9] *((byte*)(const struct Circle*) circles+(byte) 1*(const byte) SIZEOF_STRUCT_CIRCLE) ← (byte) $f [ ] ( main:2 [ ] ) always clobbers reg byte a 
 Statement [11] (byte) main::x#0 ← *((byte*)(struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER) [ main::ptr#2 main::idx#3 main::i#2 main::x#0 ] ( main:2 [ main::ptr#2 main::idx#3 main::i#2 main::x#0 ] ) always clobbers reg byte a reg byte y 
-Statement [12] (struct Point*~) main::$14 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER [ main::ptr#2 main::idx#3 main::i#2 main::x#0 main::$14 ] ( main:2 [ main::ptr#2 main::idx#3 main::i#2 main::x#0 main::$14 ] ) always clobbers reg byte a 
-Statement [13] (byte) main::y#0 ← *((byte*)(struct Point*~) main::$14 + (const byte) OFFSET_STRUCT_POINT_Y) [ main::ptr#2 main::idx#3 main::i#2 main::x#0 main::y#0 ] ( main:2 [ main::ptr#2 main::idx#3 main::i#2 main::x#0 main::y#0 ] ) always clobbers reg byte a reg byte y 
+Statement [12] (struct Point*~) main::$9 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER [ main::ptr#2 main::idx#3 main::i#2 main::x#0 main::$9 ] ( main:2 [ main::ptr#2 main::idx#3 main::i#2 main::x#0 main::$9 ] ) always clobbers reg byte a 
+Statement [13] (byte) main::y#0 ← *((byte*)(struct Point*~) main::$9 + (const byte) OFFSET_STRUCT_POINT_Y) [ main::ptr#2 main::idx#3 main::i#2 main::x#0 main::y#0 ] ( main:2 [ main::ptr#2 main::idx#3 main::i#2 main::x#0 main::y#0 ] ) always clobbers reg byte a reg byte y 
 Statement [14] *((const byte*) main::SCREEN + (byte) main::idx#3) ← (byte) main::x#0 [ main::ptr#2 main::idx#3 main::i#2 main::y#0 ] ( main:2 [ main::ptr#2 main::idx#3 main::i#2 main::y#0 ] ) always clobbers reg byte a 
 Statement [16] *((const byte*) main::SCREEN + (byte) main::idx#1) ← (byte) main::y#0 [ main::ptr#2 main::i#2 main::idx#1 ] ( main:2 [ main::ptr#2 main::i#2 main::idx#1 ] ) always clobbers reg byte a 
 Statement [18] (struct Circle*) main::ptr#1 ← (struct Circle*) main::ptr#2 + (const byte) SIZEOF_STRUCT_CIRCLE [ main::i#2 main::ptr#1 main::idx#2 ] ( main:2 [ main::i#2 main::ptr#1 main::idx#2 ] ) always clobbers reg byte a 
@@ -577,17 +516,17 @@ Potential registers zp[2]:2 [ main::ptr#2 main::ptr#1 ] : zp[2]:2 ,
 Potential registers zp[1]:4 [ main::idx#3 main::idx#2 ] : zp[1]:4 , reg byte x , 
 Potential registers zp[1]:5 [ main::i#2 main::i#1 ] : zp[1]:5 , reg byte x , 
 Potential registers zp[1]:6 [ main::x#0 ] : zp[1]:6 , reg byte x , 
-Potential registers zp[2]:7 [ main::$14 ] : zp[2]:7 , 
+Potential registers zp[2]:7 [ main::$9 ] : zp[2]:7 , 
 Potential registers zp[1]:9 [ main::y#0 ] : zp[1]:9 , reg byte x , reg byte y , 
 Potential registers zp[1]:10 [ main::idx#1 ] : zp[1]:10 , reg byte x , reg byte y , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [main] 18.94: zp[1]:5 [ main::i#2 main::i#1 ] 16.5: zp[1]:10 [ main::idx#1 ] 12.1: zp[1]:4 [ main::idx#3 main::idx#2 ] 11: zp[2]:7 [ main::$14 ] 10.08: zp[2]:2 [ main::ptr#2 main::ptr#1 ] 7.33: zp[1]:6 [ main::x#0 ] 7.33: zp[1]:9 [ main::y#0 ] 
+Uplift Scope [main] 18.94: zp[1]:5 [ main::i#2 main::i#1 ] 16.5: zp[1]:10 [ main::idx#1 ] 12.1: zp[1]:4 [ main::idx#3 main::idx#2 ] 11: zp[2]:7 [ main::$9 ] 10.08: zp[2]:2 [ main::ptr#2 main::ptr#1 ] 7.33: zp[1]:6 [ main::x#0 ] 7.33: zp[1]:9 [ main::y#0 ] 
 Uplift Scope [Point] 
 Uplift Scope [Circle] 
 Uplift Scope [] 
 
-Uplifting [main] best 1184 combination zp[1]:5 [ main::i#2 main::i#1 ] reg byte x [ main::idx#1 ] reg byte x [ main::idx#3 main::idx#2 ] zp[2]:7 [ main::$14 ] zp[2]:2 [ main::ptr#2 main::ptr#1 ] zp[1]:6 [ main::x#0 ] reg byte y [ main::y#0 ] 
+Uplifting [main] best 1184 combination zp[1]:5 [ main::i#2 main::i#1 ] reg byte x [ main::idx#1 ] reg byte x [ main::idx#3 main::idx#2 ] zp[2]:7 [ main::$9 ] zp[2]:2 [ main::ptr#2 main::ptr#1 ] zp[1]:6 [ main::x#0 ] reg byte y [ main::y#0 ] 
 Uplifting [Point] best 1184 combination 
 Uplifting [Circle] best 1184 combination 
 Uplifting [] best 1184 combination 
@@ -597,7 +536,7 @@ Attempting to uplift remaining variables inzp[1]:6 [ main::x#0 ]
 Uplifting [main] best 1184 combination zp[1]:6 [ main::x#0 ] 
 Allocated (was zp[1]:5) zp[1]:4 [ main::i#2 main::i#1 ]
 Allocated (was zp[1]:6) zp[1]:5 [ main::x#0 ]
-Allocated (was zp[2]:7) zp[2]:6 [ main::$14 ]
+Allocated (was zp[2]:7) zp[2]:6 [ main::$9 ]
 
 ASSEMBLER BEFORE OPTIMIZATION
   // File Comments
@@ -627,7 +566,7 @@ __bend:
   // main
 main: {
     .label SCREEN = $400
-    .label __14 = 6
+    .label __9 = 6
     .label x = 5
     .label ptr = 2
     .label i = 4
@@ -674,17 +613,17 @@ main: {
     ldy #OFFSET_STRUCT_CIRCLE_CENTER
     lda (ptr),y
     sta.z x
-    // [12] (struct Point*~) main::$14 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER -- pssz1=pssz2_plus_vbuc1 
+    // [12] (struct Point*~) main::$9 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER -- pssz1=pssz2_plus_vbuc1 
     lda #OFFSET_STRUCT_CIRCLE_CENTER
     clc
     adc.z ptr
-    sta.z __14
+    sta.z __9
     lda #0
     adc.z ptr+1
-    sta.z __14+1
-    // [13] (byte) main::y#0 ← *((byte*)(struct Point*~) main::$14 + (const byte) OFFSET_STRUCT_POINT_Y) -- vbuyy=pbuz1_derefidx_vbuc1 
+    sta.z __9+1
+    // [13] (byte) main::y#0 ← *((byte*)(struct Point*~) main::$9 + (const byte) OFFSET_STRUCT_POINT_Y) -- vbuyy=pbuz1_derefidx_vbuc1 
     ldy #OFFSET_STRUCT_POINT_Y
-    lda (__14),y
+    lda (__9),y
     tay
     // [14] *((const byte*) main::SCREEN + (byte) main::idx#3) ← (byte) main::x#0 -- pbuc1_derefidx_vbuxx=vbuz1 
     lda.z x
@@ -759,7 +698,7 @@ FINAL SYMBOL TABLE
 (const byte) SIZEOF_STRUCT_CIRCLE = (byte) 3
 (const struct Circle*) circles[(number) 2]  = { fill( 2, 0) }
 (void()) main()
-(struct Point*~) main::$14 zp[2]:6 11.0
+(struct Point*~) main::$9 zp[2]:6 11.0
 (label) main::@1
 (label) main::@return
 (const byte*) main::SCREEN = (byte*) 1024
@@ -782,7 +721,7 @@ zp[2]:2 [ main::ptr#2 main::ptr#1 ]
 reg byte x [ main::idx#3 main::idx#2 ]
 zp[1]:4 [ main::i#2 main::i#1 ]
 zp[1]:5 [ main::x#0 ]
-zp[2]:6 [ main::$14 ]
+zp[2]:6 [ main::$9 ]
 reg byte y [ main::y#0 ]
 reg byte x [ main::idx#1 ]
 
@@ -809,7 +748,7 @@ Score: 1082
   // main
 main: {
     .label SCREEN = $400
-    .label __14 = 6
+    .label __9 = 6
     .label x = 5
     .label ptr = 2
     .label i = 4
@@ -860,17 +799,17 @@ main: {
     lda (ptr),y
     sta.z x
     // y = ptr->center.y
-    // [12] (struct Point*~) main::$14 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER -- pssz1=pssz2_plus_vbuc1 
+    // [12] (struct Point*~) main::$9 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER -- pssz1=pssz2_plus_vbuc1 
     tya
     clc
     adc.z ptr
-    sta.z __14
+    sta.z __9
     lda #0
     adc.z ptr+1
-    sta.z __14+1
-    // [13] (byte) main::y#0 ← *((byte*)(struct Point*~) main::$14 + (const byte) OFFSET_STRUCT_POINT_Y) -- vbuyy=pbuz1_derefidx_vbuc1 
+    sta.z __9+1
+    // [13] (byte) main::y#0 ← *((byte*)(struct Point*~) main::$9 + (const byte) OFFSET_STRUCT_POINT_Y) -- vbuyy=pbuz1_derefidx_vbuc1 
     ldy #OFFSET_STRUCT_POINT_Y
-    lda (__14),y
+    lda (__9),y
     tay
     // SCREEN[idx++] = x
     // [14] *((const byte*) main::SCREEN + (byte) main::idx#3) ← (byte) main::x#0 -- pbuc1_derefidx_vbuxx=vbuz1 
diff --git a/src/test/ref/struct-ptr-15.sym b/src/test/ref/struct-ptr-15.sym
index bae6c8099..f81fa2e29 100644
--- a/src/test/ref/struct-ptr-15.sym
+++ b/src/test/ref/struct-ptr-15.sym
@@ -10,7 +10,7 @@
 (const byte) SIZEOF_STRUCT_CIRCLE = (byte) 3
 (const struct Circle*) circles[(number) 2]  = { fill( 2, 0) }
 (void()) main()
-(struct Point*~) main::$14 zp[2]:6 11.0
+(struct Point*~) main::$9 zp[2]:6 11.0
 (label) main::@1
 (label) main::@return
 (const byte*) main::SCREEN = (byte*) 1024
@@ -33,6 +33,6 @@ zp[2]:2 [ main::ptr#2 main::ptr#1 ]
 reg byte x [ main::idx#3 main::idx#2 ]
 zp[1]:4 [ main::i#2 main::i#1 ]
 zp[1]:5 [ main::x#0 ]
-zp[2]:6 [ main::$14 ]
+zp[2]:6 [ main::$9 ]
 reg byte y [ main::y#0 ]
 reg byte x [ main::idx#1 ]
diff --git a/src/test/ref/struct-ptr-20.log b/src/test/ref/struct-ptr-20.log
index 3cd9e6cf0..29dcc4e94 100644
--- a/src/test/ref/struct-ptr-20.log
+++ b/src/test/ref/struct-ptr-20.log
@@ -1,7 +1,7 @@
 Fixing pointer addition (struct Setting*~) main::$2 ← (const struct Setting*) settings + (byte) main::len
 Fixing pointer increment (struct Setting*) main::setting ← ++ (struct Setting*) main::setting
-Rewriting struct pointer member access *((struct Setting*) main::setting).off
-Rewriting struct pointer member access *((struct Setting*) main::setting).id
+Replacing struct member reference *((struct Setting*) main::setting).off with member unwinding reference *((byte*~) main::$7)
+Replacing struct member reference *((struct Setting*) main::setting).id with member unwinding reference *((byte*~) main::$8)
 Warning! Adding boolean cast to non-boolean sub-expression *((byte*~) main::$7)
 Culled Empty Block (label) main::@5
 Culled Empty Block (label) main::@3
diff --git a/src/test/ref/struct-ptr-21.log b/src/test/ref/struct-ptr-21.log
index 68a175380..a6525a31d 100644
--- a/src/test/ref/struct-ptr-21.log
+++ b/src/test/ref/struct-ptr-21.log
@@ -2,8 +2,8 @@ Fixing constant pointer addition (const word*) seq+(number) 0
 Fixing constant pointer addition (const struct Setting*) settings+(number) 0
 Fixing pointer array-indexing *(*((struct Setting*) main::setting).buf + (byte) main::i)
 Fixing pointer array-indexing *((const word*) SCREEN + (byte) main::i)
-Rewriting struct pointer member access *((struct Setting*) main::setting).len
-Rewriting struct pointer member access *((struct Setting*) main::setting).buf
+Replacing struct member reference *((struct Setting*) main::setting).len with member unwinding reference *((byte*~) main::$2)
+Replacing struct member reference *((struct Setting*) main::setting).buf with member unwinding reference *((word**~) main::$3)
 Identified constant variable (struct Setting*) main::setting
 Identified constant variable (byte) main::idx
 Culled Empty Block (label) main::@4
diff --git a/src/test/ref/struct-ptr-22.log b/src/test/ref/struct-ptr-22.log
index 711b8789e..eacc1208f 100644
--- a/src/test/ref/struct-ptr-22.log
+++ b/src/test/ref/struct-ptr-22.log
@@ -3,9 +3,9 @@ Fixing pointer addition (word*~) bsearch16u::$15 ← (word*) bsearch16u::pivot +
 Fixing pointer addition (word*~) bsearch16u::$1 ← (word*) bsearch16u::items - (number) 1
 Fixing pointer array-indexing *((word*) utoa::digit_values + (byte) utoa::digit)
 Fixing pointer array-indexing *((dword*) ultoa::digit_values + (byte) ultoa::digit)
-Rewriting struct pointer member access *((struct fileentry*) file).bufEdit
-Rewriting struct pointer member access *((struct fileentry*) file).bufEdit
-Rewriting struct pointer member access *((struct fileentry*) file).bufEdit
+Replacing struct member reference *((struct fileentry*) file).bufEdit with member unwinding reference *((byte**~) main::$8)
+Replacing struct member reference *((struct fileentry*) file).bufEdit with member unwinding reference *((byte**~) main::$9)
+Replacing struct member reference *((struct fileentry*) file).bufEdit with member unwinding reference *((byte**~) main::$10)
 Warning! Adding boolean cast to non-boolean condition *((byte*) strcpy::src)
 Warning! Adding boolean cast to non-boolean condition *((byte*) strlen::str)
 Warning! Adding boolean cast to non-boolean condition *((byte*) print_str_lines::str)
diff --git a/src/test/ref/struct-ptr-23.log b/src/test/ref/struct-ptr-23.log
index a06c2a43a..e706af320 100644
--- a/src/test/ref/struct-ptr-23.log
+++ b/src/test/ref/struct-ptr-23.log
@@ -4,10 +4,10 @@ Fixing struct type size struct Person to 5
 Fixing struct type SIZE_OF struct Person to 5
 Fixing struct type SIZE_OF struct Person to 5
 Fixing pointer increment (struct Person*) main::person ← ++ (struct Person*) main::person
-Rewriting struct pointer member access *((struct Person*) print_person::person).id
-Rewriting struct pointer member access *((struct Person*) print_person::person).initials
-Rewriting struct pointer member access *((struct Person*) print_person::person).initials
-Rewriting struct pointer member access *((struct Person*) print_person::person).initials
+Replacing struct member reference *((struct Person*) print_person::person).id with member unwinding reference *((byte*~) print_person::$1)
+Replacing struct member reference *((struct Person*) print_person::person).initials with member unwinding reference (byte*~) print_person::$2
+Replacing struct member reference *((struct Person*) print_person::person).initials with member unwinding reference (byte*~) print_person::$3
+Replacing struct member reference *((struct Person*) print_person::person).initials with member unwinding reference (byte*~) print_person::$4
 
 CONTROL FLOW GRAPH SSA
 @begin: scope:[]  from
diff --git a/src/test/ref/struct-ptr-26.log b/src/test/ref/struct-ptr-26.log
index da25d8ff5..230f8d816 100644
--- a/src/test/ref/struct-ptr-26.log
+++ b/src/test/ref/struct-ptr-26.log
@@ -3,8 +3,8 @@ Fixing pointer addition (word*~) bsearch16u::$15 ← (word*) bsearch16u::pivot +
 Fixing pointer addition (word*~) bsearch16u::$1 ← (word*) bsearch16u::items - (number) 1
 Fixing pointer array-indexing *((word*) utoa::digit_values + (byte) utoa::digit)
 Fixing pointer array-indexing *((dword*) ultoa::digit_values + (byte) ultoa::digit)
-Rewriting struct pointer member access *((struct fileentry*) main::file).bufEdit
-Rewriting struct pointer member access *((struct fileentry*) main::file).bufEdit
+Replacing struct member reference *((struct fileentry*) main::file).bufEdit with member unwinding reference *((byte**~) main::$3)
+Replacing struct member reference *((struct fileentry*) main::file).bufEdit with member unwinding reference *((byte**~) main::$4)
 Warning! Adding boolean cast to non-boolean condition *((byte*) strcpy::src)
 Warning! Adding boolean cast to non-boolean condition *((byte*) strlen::str)
 Warning! Adding boolean cast to non-boolean condition *((byte*) print_str_lines::str)
diff --git a/src/test/ref/struct-ptr-3.log b/src/test/ref/struct-ptr-3.log
index e3456b2f0..aa9441529 100644
--- a/src/test/ref/struct-ptr-3.log
+++ b/src/test/ref/struct-ptr-3.log
@@ -1,8 +1,8 @@
 Fixing pointer increment (struct Point*) points ← ++ (struct Point*) points
-Rewriting struct pointer member access *((struct Point*) points).x
-Rewriting struct pointer member access *((struct Point*) points).y
-Rewriting struct pointer member access *((struct Point*) points).x
-Rewriting struct pointer member access *((struct Point*) points).y
+Replacing struct member reference *((struct Point*) points).x with member unwinding reference *((byte*~) main::$0)
+Replacing struct member reference *((struct Point*) points).y with member unwinding reference *((byte*~) main::$1)
+Replacing struct member reference *((struct Point*) points).x with member unwinding reference *((byte*~) main::$2)
+Replacing struct member reference *((struct Point*) points).y with member unwinding reference *((byte*~) main::$3)
 
 CONTROL FLOW GRAPH SSA
 @begin: scope:[]  from
diff --git a/src/test/ref/struct-ptr-31.log b/src/test/ref/struct-ptr-31.log
index ecfb0fcff..a49d4269d 100644
--- a/src/test/ref/struct-ptr-31.log
+++ b/src/test/ref/struct-ptr-31.log
@@ -3,9 +3,9 @@ Fixing struct type size struct Person to 17
 Fixing struct type SIZE_OF struct Person to 17
 Fixing struct type SIZE_OF struct Person to 17
 Fixing constant pointer addition (const struct Person*) persons+(number) 1
-Rewriting struct pointer member access *((struct Person*) print_person::person).id
-Rewriting struct pointer member access *((struct Person*) print_person::person).name
-Rewriting struct pointer member access *((struct Person*) print_person::person).name
+Replacing struct member reference *((struct Person*) print_person::person).id with member unwinding reference *((byte*~) print_person::$0)
+Replacing struct member reference *((struct Person*) print_person::person).name with member unwinding reference (byte*~) print_person::$1
+Replacing struct member reference *((struct Person*) print_person::person).name with member unwinding reference (byte*~) print_person::$2
 Warning! Adding boolean cast to non-boolean condition *((byte*~) print_person::$1 + (byte) print_person::i)
 Culled Empty Block (label) print_person::@4
 Culled Empty Block (label) print_person::@5
diff --git a/src/test/ref/struct-ptr-32.asm b/src/test/ref/struct-ptr-32.asm
index 5b5c715db..72e97cac4 100644
--- a/src/test/ref/struct-ptr-32.asm
+++ b/src/test/ref/struct-ptr-32.asm
@@ -15,7 +15,7 @@ main: {
     lda #'a'
     sta persons+OFFSET_STRUCT_PERSON_NAME+8
     lda #'b'
-    sta persons+1*SIZEOF_STRUCT_PERSON+OFFSET_STRUCT_PERSON_NAME+8
+    sta persons+OFFSET_STRUCT_PERSON_NAME+1*SIZEOF_STRUCT_PERSON+8
     lda #<$141
     sta persons+OFFSET_STRUCT_PERSON_AGE
     lda #>$141
diff --git a/src/test/ref/struct-ptr-32.cfg b/src/test/ref/struct-ptr-32.cfg
index a396b91fc..008b71a8e 100644
--- a/src/test/ref/struct-ptr-32.cfg
+++ b/src/test/ref/struct-ptr-32.cfg
@@ -13,7 +13,7 @@ main: scope:[main]  from @1
   [4] *((byte*)(const struct Person*) persons) ← (byte) 7
   [5] *((byte*)(const struct Person*) persons+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON) ← (byte) 9
   [6] *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 8) ← (byte) 'a'
-  [7] *((byte*)(const struct Person*) persons+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 8) ← (byte) 'b'
+  [7] *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON+(byte) 8) ← (byte) 'b'
   [8] *((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE) ← (word) $141
   [9] *((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON) ← (byte) $7b
   [10] *((const byte*) main::SCREEN) ← *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 8)
diff --git a/src/test/ref/struct-ptr-32.log b/src/test/ref/struct-ptr-32.log
index aa2d43489..ed9e903b7 100644
--- a/src/test/ref/struct-ptr-32.log
+++ b/src/test/ref/struct-ptr-32.log
@@ -9,14 +9,14 @@ Fixing pointer array-indexing *((const struct Person*) persons + (number) 0)
 Fixing pointer array-indexing *((const struct Person*) persons + (number) 1)
 Fixing pointer array-indexing *((const struct Person*) persons + (number) 0)
 Fixing pointer array-indexing *((const struct Person*) persons + (number) 1)
-Rewriting struct pointer member access *((const struct Person*) persons + (number~) main::$0).id
-Rewriting struct pointer member access *((const struct Person*) persons + (number~) main::$1).id
-Rewriting struct pointer member access *((const struct Person*) persons + (number~) main::$2).name
-Rewriting struct pointer member access *((const struct Person*) persons + (number~) main::$3).name
-Rewriting struct pointer member access *((const struct Person*) persons + (number~) main::$4).age
-Rewriting struct pointer member access *((const struct Person*) persons + (number~) main::$5).age
-Rewriting struct pointer member access *((struct Person*) main::person).name
-Rewriting struct pointer member access *((struct Person*) main::person).name
+Replacing struct member reference *((const struct Person*) persons + (number~) main::$0).id with member unwinding reference *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_ID + (number~) main::$0)
+Replacing struct member reference *((const struct Person*) persons + (number~) main::$1).id with member unwinding reference *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_ID + (number~) main::$1)
+Replacing struct member reference *((const struct Person*) persons + (number~) main::$2).name with member unwinding reference (byte*~) main::$6
+Replacing struct member reference *((const struct Person*) persons + (number~) main::$3).name with member unwinding reference (byte*~) main::$7
+Replacing struct member reference *((const struct Person*) persons + (number~) main::$4).age with member unwinding reference *((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE + (number~) main::$4)
+Replacing struct member reference *((const struct Person*) persons + (number~) main::$5).age with member unwinding reference *((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE + (number~) main::$5)
+Replacing struct member reference *((struct Person*) main::person).name with member unwinding reference (byte*~) main::$8
+Replacing struct member reference *((struct Person*) main::person).name with member unwinding reference (byte*~) main::$9
 
 CONTROL FLOW GRAPH SSA
 @begin: scope:[]  from
@@ -25,31 +25,25 @@ CONTROL FLOW GRAPH SSA
 (void()) main()
 main: scope:[main]  from @1
   (number~) main::$0 ← (number) 0 * (const byte) SIZEOF_STRUCT_PERSON
-  (byte*~) main::$6 ← (byte*)(const struct Person*) persons + (const byte) OFFSET_STRUCT_PERSON_ID
-  *((byte*~) main::$6 + (number~) main::$0) ← (number) 7
+  *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_ID + (number~) main::$0) ← (number) 7
   (number~) main::$1 ← (number) 1 * (const byte) SIZEOF_STRUCT_PERSON
-  (byte*~) main::$7 ← (byte*)(const struct Person*) persons + (const byte) OFFSET_STRUCT_PERSON_ID
-  *((byte*~) main::$7 + (number~) main::$1) ← (number) 9
+  *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_ID + (number~) main::$1) ← (number) 9
   (number~) main::$2 ← (number) 0 * (const byte) SIZEOF_STRUCT_PERSON
-  (byte*~) main::$8 ← (byte*)(const struct Person*) persons + (number~) main::$2
-  (byte*~) main::$9 ← (byte*~) main::$8 + (const byte) OFFSET_STRUCT_PERSON_NAME
-  *((byte*~) main::$9 + (number) 8) ← (byte) 'a'
+  (byte*~) main::$6 ← (byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME + (number~) main::$2
+  *((byte*~) main::$6 + (number) 8) ← (byte) 'a'
   (number~) main::$3 ← (number) 1 * (const byte) SIZEOF_STRUCT_PERSON
-  (byte*~) main::$10 ← (byte*)(const struct Person*) persons + (number~) main::$3
-  (byte*~) main::$11 ← (byte*~) main::$10 + (const byte) OFFSET_STRUCT_PERSON_NAME
-  *((byte*~) main::$11 + (number) 8) ← (byte) 'b'
+  (byte*~) main::$7 ← (byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME + (number~) main::$3
+  *((byte*~) main::$7 + (number) 8) ← (byte) 'b'
   (number~) main::$4 ← (number) 0 * (const byte) SIZEOF_STRUCT_PERSON
-  (word*~) main::$12 ← (word*)(const struct Person*) persons + (const byte) OFFSET_STRUCT_PERSON_AGE
-  *((word*~) main::$12 + (number~) main::$4) ← (number) $141
+  *((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE + (number~) main::$4) ← (number) $141
   (number~) main::$5 ← (number) 1 * (const byte) SIZEOF_STRUCT_PERSON
-  (word*~) main::$13 ← (word*)(const struct Person*) persons + (const byte) OFFSET_STRUCT_PERSON_AGE
-  *((word*~) main::$13 + (number~) main::$5) ← (number) $7b
+  *((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE + (number~) main::$5) ← (number) $7b
   (struct Person*) main::person#0 ← (const struct Person*) persons
-  (byte*~) main::$14 ← (byte*)(struct Person*) main::person#0 + (const byte) OFFSET_STRUCT_PERSON_NAME
-  *((const byte*) main::SCREEN + (number) 0) ← *((byte*~) main::$14 + (number) 8)
+  (byte*~) main::$8 ← (byte*)(struct Person*) main::person#0 + (const byte) OFFSET_STRUCT_PERSON_NAME
+  *((const byte*) main::SCREEN + (number) 0) ← *((byte*~) main::$8 + (number) 8)
   (struct Person*) main::person#1 ← (struct Person*) main::person#0 + (const byte) SIZEOF_STRUCT_PERSON
-  (byte*~) main::$15 ← (byte*)(struct Person*) main::person#1 + (const byte) OFFSET_STRUCT_PERSON_NAME
-  *((const byte*) main::SCREEN + (number) 1) ← *((byte*~) main::$15 + (number) 8)
+  (byte*~) main::$9 ← (byte*)(struct Person*) main::person#1 + (const byte) OFFSET_STRUCT_PERSON_NAME
+  *((const byte*) main::SCREEN + (number) 1) ← *((byte*~) main::$9 + (number) 8)
   to:main::@return
 main::@return: scope:[main]  from main
   return 
@@ -76,12 +70,6 @@ SYMBOL TABLE SSA
 (void()) main()
 (number~) main::$0
 (number~) main::$1
-(byte*~) main::$10
-(byte*~) main::$11
-(word*~) main::$12
-(word*~) main::$13
-(byte*~) main::$14
-(byte*~) main::$15
 (number~) main::$2
 (number~) main::$3
 (number~) main::$4
@@ -99,31 +87,31 @@ SYMBOL TABLE SSA
 
 Adding number conversion cast (unumber) 0 in (number~) main::$0 ← (number) 0 * (const byte) SIZEOF_STRUCT_PERSON
 Adding number conversion cast (unumber) main::$0 in (number~) main::$0 ← (unumber)(number) 0 * (const byte) SIZEOF_STRUCT_PERSON
-Adding number conversion cast (unumber) 7 in *((byte*~) main::$6 + (unumber~) main::$0) ← (number) 7
+Adding number conversion cast (unumber) 7 in *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_ID + (unumber~) main::$0) ← (number) 7
 Adding number conversion cast (unumber) 1 in (number~) main::$1 ← (number) 1 * (const byte) SIZEOF_STRUCT_PERSON
 Adding number conversion cast (unumber) main::$1 in (number~) main::$1 ← (unumber)(number) 1 * (const byte) SIZEOF_STRUCT_PERSON
-Adding number conversion cast (unumber) 9 in *((byte*~) main::$7 + (unumber~) main::$1) ← (number) 9
+Adding number conversion cast (unumber) 9 in *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_ID + (unumber~) main::$1) ← (number) 9
 Adding number conversion cast (unumber) 0 in (number~) main::$2 ← (number) 0 * (const byte) SIZEOF_STRUCT_PERSON
 Adding number conversion cast (unumber) main::$2 in (number~) main::$2 ← (unumber)(number) 0 * (const byte) SIZEOF_STRUCT_PERSON
-Adding number conversion cast (unumber) 8 in *((byte*~) main::$9 + (number) 8) ← (byte) 'a'
+Adding number conversion cast (unumber) 8 in *((byte*~) main::$6 + (number) 8) ← (byte) 'a'
 Adding number conversion cast (unumber) 1 in (number~) main::$3 ← (number) 1 * (const byte) SIZEOF_STRUCT_PERSON
 Adding number conversion cast (unumber) main::$3 in (number~) main::$3 ← (unumber)(number) 1 * (const byte) SIZEOF_STRUCT_PERSON
-Adding number conversion cast (unumber) 8 in *((byte*~) main::$11 + (number) 8) ← (byte) 'b'
+Adding number conversion cast (unumber) 8 in *((byte*~) main::$7 + (number) 8) ← (byte) 'b'
 Adding number conversion cast (unumber) 0 in (number~) main::$4 ← (number) 0 * (const byte) SIZEOF_STRUCT_PERSON
 Adding number conversion cast (unumber) main::$4 in (number~) main::$4 ← (unumber)(number) 0 * (const byte) SIZEOF_STRUCT_PERSON
-Adding number conversion cast (unumber) $141 in *((word*~) main::$12 + (unumber~) main::$4) ← (number) $141
+Adding number conversion cast (unumber) $141 in *((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE + (unumber~) main::$4) ← (number) $141
 Adding number conversion cast (unumber) 1 in (number~) main::$5 ← (number) 1 * (const byte) SIZEOF_STRUCT_PERSON
 Adding number conversion cast (unumber) main::$5 in (number~) main::$5 ← (unumber)(number) 1 * (const byte) SIZEOF_STRUCT_PERSON
-Adding number conversion cast (unumber) $7b in *((word*~) main::$13 + (unumber~) main::$5) ← (number) $7b
-Adding number conversion cast (unumber) 8 in *((const byte*) main::SCREEN + (number) 0) ← *((byte*~) main::$14 + (number) 8)
-Adding number conversion cast (unumber) 0 in *((const byte*) main::SCREEN + (number) 0) ← *((byte*~) main::$14 + (unumber)(number) 8)
-Adding number conversion cast (unumber) 8 in *((const byte*) main::SCREEN + (number) 1) ← *((byte*~) main::$15 + (number) 8)
-Adding number conversion cast (unumber) 1 in *((const byte*) main::SCREEN + (number) 1) ← *((byte*~) main::$15 + (unumber)(number) 8)
+Adding number conversion cast (unumber) $7b in *((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE + (unumber~) main::$5) ← (number) $7b
+Adding number conversion cast (unumber) 8 in *((const byte*) main::SCREEN + (number) 0) ← *((byte*~) main::$8 + (number) 8)
+Adding number conversion cast (unumber) 0 in *((const byte*) main::SCREEN + (number) 0) ← *((byte*~) main::$8 + (unumber)(number) 8)
+Adding number conversion cast (unumber) 8 in *((const byte*) main::SCREEN + (number) 1) ← *((byte*~) main::$9 + (number) 8)
+Adding number conversion cast (unumber) 1 in *((const byte*) main::SCREEN + (number) 1) ← *((byte*~) main::$9 + (unumber)(number) 8)
 Successful SSA optimization PassNAddNumberTypeConversions
-Inlining cast *((byte*~) main::$6 + (unumber~) main::$0) ← (unumber)(number) 7
-Inlining cast *((byte*~) main::$7 + (unumber~) main::$1) ← (unumber)(number) 9
-Inlining cast *((word*~) main::$12 + (unumber~) main::$4) ← (unumber)(number) $141
-Inlining cast *((word*~) main::$13 + (unumber~) main::$5) ← (unumber)(number) $7b
+Inlining cast *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_ID + (unumber~) main::$0) ← (unumber)(number) 7
+Inlining cast *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_ID + (unumber~) main::$1) ← (unumber)(number) 9
+Inlining cast *((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE + (unumber~) main::$4) ← (unumber)(number) $141
+Inlining cast *((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE + (unumber~) main::$5) ← (unumber)(number) $7b
 Successful SSA optimization Pass2InlineCast
 Simplifying constant pointer cast (byte*) 1024
 Simplifying constant integer cast 0
@@ -167,86 +155,66 @@ Inferred type updated to byte in (unumber~) main::$3 ← (byte) 1 * (const byte)
 Inferred type updated to byte in (unumber~) main::$4 ← (byte) 0 * (const byte) SIZEOF_STRUCT_PERSON
 Inferred type updated to byte in (unumber~) main::$5 ← (byte) 1 * (const byte) SIZEOF_STRUCT_PERSON
 Constant right-side identified [0] (byte~) main::$0 ← (byte) 0 * (const byte) SIZEOF_STRUCT_PERSON
-Constant right-side identified [1] (byte*~) main::$6 ← (byte*)(const struct Person*) persons + (const byte) OFFSET_STRUCT_PERSON_ID
-Constant right-side identified [3] (byte~) main::$1 ← (byte) 1 * (const byte) SIZEOF_STRUCT_PERSON
-Constant right-side identified [4] (byte*~) main::$7 ← (byte*)(const struct Person*) persons + (const byte) OFFSET_STRUCT_PERSON_ID
-Constant right-side identified [6] (byte~) main::$2 ← (byte) 0 * (const byte) SIZEOF_STRUCT_PERSON
-Constant right-side identified [10] (byte~) main::$3 ← (byte) 1 * (const byte) SIZEOF_STRUCT_PERSON
-Constant right-side identified [14] (byte~) main::$4 ← (byte) 0 * (const byte) SIZEOF_STRUCT_PERSON
-Constant right-side identified [15] (word*~) main::$12 ← (word*)(const struct Person*) persons + (const byte) OFFSET_STRUCT_PERSON_AGE
-Constant right-side identified [17] (byte~) main::$5 ← (byte) 1 * (const byte) SIZEOF_STRUCT_PERSON
-Constant right-side identified [18] (word*~) main::$13 ← (word*)(const struct Person*) persons + (const byte) OFFSET_STRUCT_PERSON_AGE
+Constant right-side identified [2] (byte~) main::$1 ← (byte) 1 * (const byte) SIZEOF_STRUCT_PERSON
+Constant right-side identified [4] (byte~) main::$2 ← (byte) 0 * (const byte) SIZEOF_STRUCT_PERSON
+Constant right-side identified [7] (byte~) main::$3 ← (byte) 1 * (const byte) SIZEOF_STRUCT_PERSON
+Constant right-side identified [10] (byte~) main::$4 ← (byte) 0 * (const byte) SIZEOF_STRUCT_PERSON
+Constant right-side identified [12] (byte~) main::$5 ← (byte) 1 * (const byte) SIZEOF_STRUCT_PERSON
 Successful SSA optimization Pass2ConstantRValueConsolidation
 Constant (const byte) main::$0 = 0*SIZEOF_STRUCT_PERSON
-Constant (const byte*) main::$6 = (byte*)persons+OFFSET_STRUCT_PERSON_ID
 Constant (const byte) main::$1 = 1*SIZEOF_STRUCT_PERSON
-Constant (const byte*) main::$7 = (byte*)persons+OFFSET_STRUCT_PERSON_ID
 Constant (const byte) main::$2 = 0*SIZEOF_STRUCT_PERSON
 Constant (const byte) main::$3 = 1*SIZEOF_STRUCT_PERSON
 Constant (const byte) main::$4 = 0*SIZEOF_STRUCT_PERSON
-Constant (const word*) main::$12 = (word*)persons+OFFSET_STRUCT_PERSON_AGE
 Constant (const byte) main::$5 = 1*SIZEOF_STRUCT_PERSON
-Constant (const word*) main::$13 = (word*)persons+OFFSET_STRUCT_PERSON_AGE
 Constant (const struct Person*) main::person#0 = persons
 Successful SSA optimization Pass2ConstantIdentification
-Constant value identified (byte*)persons in [7] (byte*~) main::$8 ← (byte*)(const struct Person*) persons + (const byte) main::$2
-Constant value identified (byte*)persons in [11] (byte*~) main::$10 ← (byte*)(const struct Person*) persons + (const byte) main::$3
-Constant value identified (byte*)main::person#0 in [21] (byte*~) main::$14 ← (byte*)(const struct Person*) main::person#0 + (const byte) OFFSET_STRUCT_PERSON_NAME
+Constant value identified (byte*)main::person#0 in [15] (byte*~) main::$8 ← (byte*)(const struct Person*) main::person#0 + (const byte) OFFSET_STRUCT_PERSON_NAME
 Successful SSA optimization Pass2ConstantValues
 Simplifying constant evaluating to zero (byte) 0*(const byte) SIZEOF_STRUCT_PERSON in 
 Simplifying constant evaluating to zero (byte) 0*(const byte) SIZEOF_STRUCT_PERSON in 
 Simplifying constant evaluating to zero (byte) 0*(const byte) SIZEOF_STRUCT_PERSON in 
 Successful SSA optimization PassNSimplifyConstantZero
-Simplifying expression containing zero (byte*)persons in 
-Simplifying expression containing zero (byte*)persons in 
-Simplifying expression containing zero main::$6 in [2] *((const byte*) main::$6 + (const byte) main::$0) ← (byte) 7
-Simplifying expression containing zero (byte*)persons in [7] (byte*~) main::$8 ← (byte*)(const struct Person*) persons + (const byte) main::$2
-Simplifying expression containing zero main::$12 in [16] *((const word*) main::$12 + (const byte) main::$4) ← (word) $141
-Simplifying expression containing zero main::SCREEN in [22] *((const byte*) main::SCREEN + (byte) 0) ← *((byte*~) main::$14 + (byte) 8)
+Simplifying expression containing zero (byte*)persons+OFFSET_STRUCT_PERSON_ID in [1] *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_ID + (const byte) main::$0) ← (byte) 7
+Simplifying expression containing zero (byte*)persons in [1] *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_ID) ← (byte) 7
+Simplifying expression containing zero (byte*)persons in [3] *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_ID + (const byte) main::$1) ← (byte) 9
+Simplifying expression containing zero (byte*)persons+OFFSET_STRUCT_PERSON_NAME in [5] (byte*~) main::$6 ← (byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME + (const byte) main::$2
+Simplifying expression containing zero (word*)persons+OFFSET_STRUCT_PERSON_AGE in [11] *((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE + (const byte) main::$4) ← (word) $141
+Simplifying expression containing zero main::SCREEN in [16] *((const byte*) main::SCREEN + (byte) 0) ← *((byte*~) main::$8 + (byte) 8)
 Successful SSA optimization PassNSimplifyExpressionWithZero
 Eliminating unused constant (const byte) main::$0
 Eliminating unused constant (const byte) main::$2
 Eliminating unused constant (const byte) main::$4
 Eliminating unused constant (const byte) OFFSET_STRUCT_PERSON_ID
 Successful SSA optimization PassNEliminateUnusedVars
-Constant right-side identified [5] (byte*~) main::$10 ← (byte*)(const struct Person*) persons + (const byte) main::$3
-Constant right-side identified [10] (byte*~) main::$14 ← (byte*)(const struct Person*) main::person#0 + (const byte) OFFSET_STRUCT_PERSON_NAME
-Constant right-side identified [12] (struct Person*) main::person#1 ← (const struct Person*) main::person#0 + (const byte) SIZEOF_STRUCT_PERSON
+Constant right-side identified [4] (byte*~) main::$7 ← (byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME + (const byte) main::$3
+Constant right-side identified [8] (byte*~) main::$8 ← (byte*)(const struct Person*) main::person#0 + (const byte) OFFSET_STRUCT_PERSON_NAME
+Constant right-side identified [10] (struct Person*) main::person#1 ← (const struct Person*) main::person#0 + (const byte) SIZEOF_STRUCT_PERSON
 Successful SSA optimization Pass2ConstantRValueConsolidation
-Constant (const byte*) main::$8 = (byte*)persons
-Constant (const byte*) main::$10 = (byte*)persons+main::$3
-Constant (const byte*) main::$14 = (byte*)main::person#0+OFFSET_STRUCT_PERSON_NAME
+Constant (const byte*) main::$6 = (byte*)persons+OFFSET_STRUCT_PERSON_NAME
+Constant (const byte*) main::$7 = (byte*)persons+OFFSET_STRUCT_PERSON_NAME+main::$3
+Constant (const byte*) main::$8 = (byte*)main::person#0+OFFSET_STRUCT_PERSON_NAME
 Constant (const struct Person*) main::person#1 = main::person#0+SIZEOF_STRUCT_PERSON
 Successful SSA optimization Pass2ConstantIdentification
-Constant value identified (byte*)main::person#1 in [13] (byte*~) main::$15 ← (byte*)(const struct Person*) main::person#1 + (const byte) OFFSET_STRUCT_PERSON_NAME
+Constant value identified (byte*)main::person#1 in [11] (byte*~) main::$9 ← (byte*)(const struct Person*) main::person#1 + (const byte) OFFSET_STRUCT_PERSON_NAME
 Successful SSA optimization Pass2ConstantValues
-Constant right-side identified [2] (byte*~) main::$9 ← (const byte*) main::$8 + (const byte) OFFSET_STRUCT_PERSON_NAME
-Constant right-side identified [4] (byte*~) main::$11 ← (const byte*) main::$10 + (const byte) OFFSET_STRUCT_PERSON_NAME
-Constant right-side identified [9] (byte*~) main::$15 ← (byte*)(const struct Person*) main::person#1 + (const byte) OFFSET_STRUCT_PERSON_NAME
+Constant right-side identified [7] (byte*~) main::$9 ← (byte*)(const struct Person*) main::person#1 + (const byte) OFFSET_STRUCT_PERSON_NAME
 Successful SSA optimization Pass2ConstantRValueConsolidation
-Constant (const byte*) main::$9 = main::$8+OFFSET_STRUCT_PERSON_NAME
-Constant (const byte*) main::$11 = main::$10+OFFSET_STRUCT_PERSON_NAME
-Constant (const byte*) main::$15 = (byte*)main::person#1+OFFSET_STRUCT_PERSON_NAME
+Constant (const byte*) main::$9 = (byte*)main::person#1+OFFSET_STRUCT_PERSON_NAME
 Successful SSA optimization Pass2ConstantIdentification
 Inlining constant with different constant siblings (const struct Person*) main::person#0
-Constant inlined main::$12 = (word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE
-Constant inlined main::$13 = (word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE
-Constant inlined main::$14 = (byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME
-Constant inlined main::$15 = (byte*)(const struct Person*) main::person#1+(const byte) OFFSET_STRUCT_PERSON_NAME
-Constant inlined main::$10 = (byte*)(const struct Person*) persons+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON
-Constant inlined main::$11 = (byte*)(const struct Person*) persons+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON+(const byte) OFFSET_STRUCT_PERSON_NAME
 Constant inlined main::$1 = (byte) 1*(const byte) SIZEOF_STRUCT_PERSON
 Constant inlined main::$5 = (byte) 1*(const byte) SIZEOF_STRUCT_PERSON
-Constant inlined main::$6 = (byte*)(const struct Person*) persons
+Constant inlined main::$6 = (byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME
 Constant inlined main::$3 = (byte) 1*(const byte) SIZEOF_STRUCT_PERSON
-Constant inlined main::$9 = (byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME
-Constant inlined main::$7 = (byte*)(const struct Person*) persons
+Constant inlined main::$9 = (byte*)(const struct Person*) main::person#1+(const byte) OFFSET_STRUCT_PERSON_NAME
+Constant inlined main::$7 = (byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON
 Constant inlined main::person#0 = (const struct Person*) persons
-Constant inlined main::$8 = (byte*)(const struct Person*) persons
+Constant inlined main::$8 = (byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME
 Successful SSA optimization Pass2ConstantInlining
 Consolidated array index constant in *((byte*)persons+1*SIZEOF_STRUCT_PERSON)
 Consolidated array index constant in *((byte*)persons+OFFSET_STRUCT_PERSON_NAME+8)
-Consolidated array index constant in *((byte*)persons+1*SIZEOF_STRUCT_PERSON+OFFSET_STRUCT_PERSON_NAME+8)
+Consolidated array index constant in *((byte*)persons+OFFSET_STRUCT_PERSON_NAME+1*SIZEOF_STRUCT_PERSON+8)
 Consolidated array index constant in *((word*)persons+OFFSET_STRUCT_PERSON_AGE+1*SIZEOF_STRUCT_PERSON)
 Consolidated array index constant in *((byte*)persons+OFFSET_STRUCT_PERSON_NAME+8)
 Consolidated array index constant in *((byte*)main::person#1+OFFSET_STRUCT_PERSON_NAME+8)
@@ -282,7 +250,7 @@ main: scope:[main]  from @1
   [4] *((byte*)(const struct Person*) persons) ← (byte) 7
   [5] *((byte*)(const struct Person*) persons+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON) ← (byte) 9
   [6] *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 8) ← (byte) 'a'
-  [7] *((byte*)(const struct Person*) persons+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 8) ← (byte) 'b'
+  [7] *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON+(byte) 8) ← (byte) 'b'
   [8] *((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE) ← (word) $141
   [9] *((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON) ← (byte) $7b
   [10] *((const byte*) main::SCREEN) ← *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 8)
@@ -341,9 +309,9 @@ main: {
     // [6] *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 8) ← (byte) 'a' -- _deref_pbuc1=vbuc2 
     lda #'a'
     sta persons+OFFSET_STRUCT_PERSON_NAME+8
-    // [7] *((byte*)(const struct Person*) persons+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 8) ← (byte) 'b' -- _deref_pbuc1=vbuc2 
+    // [7] *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON+(byte) 8) ← (byte) 'b' -- _deref_pbuc1=vbuc2 
     lda #'b'
-    sta persons+1*SIZEOF_STRUCT_PERSON+OFFSET_STRUCT_PERSON_NAME+8
+    sta persons+OFFSET_STRUCT_PERSON_NAME+1*SIZEOF_STRUCT_PERSON+8
     // [8] *((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE) ← (word) $141 -- _deref_pwuc1=vwuc2 
     lda #<$141
     sta persons+OFFSET_STRUCT_PERSON_AGE
@@ -373,7 +341,7 @@ REGISTER UPLIFT POTENTIAL REGISTERS
 Statement [4] *((byte*)(const struct Person*) persons) ← (byte) 7 [ ] ( main:2 [ ] ) always clobbers reg byte a 
 Statement [5] *((byte*)(const struct Person*) persons+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON) ← (byte) 9 [ ] ( main:2 [ ] ) always clobbers reg byte a 
 Statement [6] *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 8) ← (byte) 'a' [ ] ( main:2 [ ] ) always clobbers reg byte a 
-Statement [7] *((byte*)(const struct Person*) persons+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 8) ← (byte) 'b' [ ] ( main:2 [ ] ) always clobbers reg byte a 
+Statement [7] *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON+(byte) 8) ← (byte) 'b' [ ] ( main:2 [ ] ) always clobbers reg byte a 
 Statement [8] *((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE) ← (word) $141 [ ] ( main:2 [ ] ) always clobbers reg byte a 
 Statement [9] *((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON) ← (byte) $7b [ ] ( main:2 [ ] ) always clobbers reg byte a 
 Statement [10] *((const byte*) main::SCREEN) ← *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 8) [ ] ( main:2 [ ] ) always clobbers reg byte a 
@@ -426,9 +394,9 @@ main: {
     // [6] *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 8) ← (byte) 'a' -- _deref_pbuc1=vbuc2 
     lda #'a'
     sta persons+OFFSET_STRUCT_PERSON_NAME+8
-    // [7] *((byte*)(const struct Person*) persons+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 8) ← (byte) 'b' -- _deref_pbuc1=vbuc2 
+    // [7] *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON+(byte) 8) ← (byte) 'b' -- _deref_pbuc1=vbuc2 
     lda #'b'
-    sta persons+1*SIZEOF_STRUCT_PERSON+OFFSET_STRUCT_PERSON_NAME+8
+    sta persons+OFFSET_STRUCT_PERSON_NAME+1*SIZEOF_STRUCT_PERSON+8
     // [8] *((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE) ← (word) $141 -- _deref_pwuc1=vwuc2 
     lda #<$141
     sta persons+OFFSET_STRUCT_PERSON_AGE
@@ -528,9 +496,9 @@ main: {
     lda #'a'
     sta persons+OFFSET_STRUCT_PERSON_NAME+8
     // persons[1].name[8] = 'b'
-    // [7] *((byte*)(const struct Person*) persons+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 8) ← (byte) 'b' -- _deref_pbuc1=vbuc2 
+    // [7] *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON+(byte) 8) ← (byte) 'b' -- _deref_pbuc1=vbuc2 
     lda #'b'
-    sta persons+1*SIZEOF_STRUCT_PERSON+OFFSET_STRUCT_PERSON_NAME+8
+    sta persons+OFFSET_STRUCT_PERSON_NAME+1*SIZEOF_STRUCT_PERSON+8
     // persons[0].age = 321
     // [8] *((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE) ← (word) $141 -- _deref_pwuc1=vwuc2 
     lda #<$141
diff --git a/src/test/ref/struct-ptr-33.log b/src/test/ref/struct-ptr-33.log
index 6b359849d..b5e21888d 100644
--- a/src/test/ref/struct-ptr-33.log
+++ b/src/test/ref/struct-ptr-33.log
@@ -3,8 +3,8 @@ Fixing struct type size struct Person to 16
 Fixing struct type SIZE_OF struct Person to 16
 Fixing struct type SIZE_OF struct Person to 16
 Fixing pointer increment (struct Person*) main::person ← ++ (struct Person*) main::person
-Rewriting struct pointer member access *((struct Person*) main::person).name
-Rewriting struct pointer member access *((struct Person*) main::person).name
+Replacing struct member reference *((struct Person*) main::person).name with member unwinding reference (byte*~) main::$0
+Replacing struct member reference *((struct Person*) main::person).name with member unwinding reference (byte*~) main::$1
 
 CONTROL FLOW GRAPH SSA
 @begin: scope:[]  from
diff --git a/src/test/ref/struct-ptr-4.log b/src/test/ref/struct-ptr-4.log
index e90315bbe..f9ebdab67 100644
--- a/src/test/ref/struct-ptr-4.log
+++ b/src/test/ref/struct-ptr-4.log
@@ -1,9 +1,9 @@
 Fixing pointer increment (struct Point*) main::points ← ++ (struct Point*) main::points
 Fixing pointer increment (struct Point*) main::points ← ++ (struct Point*) main::points
-Rewriting struct pointer member access *((struct Point*) main::points).x
-Rewriting struct pointer member access *((struct Point*) main::points).y
-Rewriting struct pointer member access *((struct Point*) main::points).x
-Rewriting struct pointer member access *((struct Point*) main::points).y
+Replacing struct member reference *((struct Point*) main::points).x with member unwinding reference *((byte*~) main::$3)
+Replacing struct member reference *((struct Point*) main::points).y with member unwinding reference *((byte*~) main::$4)
+Replacing struct member reference *((struct Point*) main::points).x with member unwinding reference *((byte*~) main::$5)
+Replacing struct member reference *((struct Point*) main::points).y with member unwinding reference *((byte*~) main::$6)
 Identified constant variable (struct Point*) POINTS
 Culled Empty Block (label) main::@4
 
diff --git a/src/test/ref/struct-ptr-5.log b/src/test/ref/struct-ptr-5.log
index 3e2a179b6..b8fff5127 100644
--- a/src/test/ref/struct-ptr-5.log
+++ b/src/test/ref/struct-ptr-5.log
@@ -1,16 +1,16 @@
 Fixing struct type size struct Entry to 3
 Fixing pointer addition (struct Entry*~) main::$0 ← (struct Entry*) ENTRIES + (number) 1
 Fixing pointer addition (struct Entry*~) main::$1 ← (struct Entry*) ENTRIES + (number) 2
-Rewriting struct pointer member access *((struct Entry*) main::entry0).next
-Rewriting struct pointer member access *((struct Entry*) main::entry0).value
-Rewriting struct pointer member access *((struct Entry*) main::entry2).next
-Rewriting struct pointer member access *((struct Entry*) main::entry2).value
-Rewriting struct pointer member access *((struct Entry*) main::entry1).next
-Rewriting struct pointer member access *((struct Entry*) main::entry1).value
-Rewriting struct pointer member access *((struct Entry*) main::entry).value
-Rewriting struct pointer member access *((struct Entry*) main::entry).next
-Rewriting struct pointer member access *((struct Entry*) main::entry).next
-Rewriting struct pointer member access *((struct Entry*) main::entry).next
+Replacing struct member reference *((struct Entry*) main::entry0).next with member unwinding reference *((struct Entry**~) main::$7)
+Replacing struct member reference *((struct Entry*) main::entry0).value with member unwinding reference *((byte*~) main::$8)
+Replacing struct member reference *((struct Entry*) main::entry2).next with member unwinding reference *((struct Entry**~) main::$9)
+Replacing struct member reference *((struct Entry*) main::entry2).value with member unwinding reference *((byte*~) main::$10)
+Replacing struct member reference *((struct Entry*) main::entry1).next with member unwinding reference *((struct Entry**~) main::$11)
+Replacing struct member reference *((struct Entry*) main::entry1).value with member unwinding reference *((byte*~) main::$12)
+Replacing struct member reference *((struct Entry*) main::entry).value with member unwinding reference *((byte*~) main::$13)
+Replacing struct member reference *((struct Entry*) main::entry).next with member unwinding reference *((struct Entry**~) main::$14)
+Replacing struct member reference *((struct Entry*) main::entry).next with member unwinding reference *((struct Entry**~) main::$15)
+Replacing struct member reference *((struct Entry*) main::entry).next with member unwinding reference *((struct Entry**~) main::$16)
 Warning! Adding boolean cast to non-boolean condition (struct Entry*) main::entry
 Identified constant variable (struct Entry*) ENTRIES
 Culled Empty Block (label) main::@4
diff --git a/src/test/ref/struct-ptr-6.log b/src/test/ref/struct-ptr-6.log
index c741804f4..461fd5471 100644
--- a/src/test/ref/struct-ptr-6.log
+++ b/src/test/ref/struct-ptr-6.log
@@ -1,8 +1,8 @@
 Fixing pointer increment (struct Point*) points ← ++ (struct Point*) points
-Rewriting struct pointer member access *((struct Point*) points).x
-Rewriting struct pointer member access *((struct Point*) points).y
-Rewriting struct pointer member access *((struct Point*) points).x
-Rewriting struct pointer member access *((struct Point*) points).y
+Replacing struct member reference *((struct Point*) points).x with member unwinding reference *((byte*~) main::$0)
+Replacing struct member reference *((struct Point*) points).y with member unwinding reference *((byte*~) main::$1)
+Replacing struct member reference *((struct Point*) points).x with member unwinding reference *((byte*~) main::$2)
+Replacing struct member reference *((struct Point*) points).y with member unwinding reference *((byte*~) main::$3)
 
 CONTROL FLOW GRAPH SSA
 @begin: scope:[]  from
diff --git a/src/test/ref/struct-ptr-7.log b/src/test/ref/struct-ptr-7.log
index 6adc7394a..5b6656e92 100644
--- a/src/test/ref/struct-ptr-7.log
+++ b/src/test/ref/struct-ptr-7.log
@@ -6,14 +6,14 @@ Fixing pointer array-indexing *((const struct Point*) points + (number) 0)
 Fixing pointer array-indexing *((const struct Point*) points + (number) 0)
 Fixing pointer array-indexing *((const struct Point*) points + (number) 1)
 Fixing pointer array-indexing *((const struct Point*) points + (number) 1)
-Rewriting struct pointer member access *((const struct Point*) points + (number~) main::$0).x
-Rewriting struct pointer member access *((const struct Point*) points + (number~) main::$1).y
-Rewriting struct pointer member access *((const struct Point*) points + (number~) main::$2).x
-Rewriting struct pointer member access *((const struct Point*) points + (number~) main::$3).y
-Rewriting struct pointer member access *((const struct Point*) points + (number~) main::$4).x
-Rewriting struct pointer member access *((const struct Point*) points + (number~) main::$5).y
-Rewriting struct pointer member access *((const struct Point*) points + (number~) main::$6).x
-Rewriting struct pointer member access *((const struct Point*) points + (number~) main::$7).y
+Replacing struct member reference *((const struct Point*) points + (number~) main::$0).x with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$0)
+Replacing struct member reference *((const struct Point*) points + (number~) main::$1).y with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$1)
+Replacing struct member reference *((const struct Point*) points + (number~) main::$2).x with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$2)
+Replacing struct member reference *((const struct Point*) points + (number~) main::$3).y with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$3)
+Replacing struct member reference *((const struct Point*) points + (number~) main::$4).x with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$4)
+Replacing struct member reference *((const struct Point*) points + (number~) main::$5).y with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$5)
+Replacing struct member reference *((const struct Point*) points + (number~) main::$6).x with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$6)
+Replacing struct member reference *((const struct Point*) points + (number~) main::$7).y with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$7)
 
 CONTROL FLOW GRAPH SSA
 @begin: scope:[]  from
@@ -22,29 +22,21 @@ CONTROL FLOW GRAPH SSA
 (void()) main()
 main: scope:[main]  from @1
   (number~) main::$0 ← (number) 0 * (const byte) SIZEOF_STRUCT_POINT
-  (byte*~) main::$8 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
-  *((byte*~) main::$8 + (number~) main::$0) ← (number) 2
+  *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$0) ← (number) 2
   (number~) main::$1 ← (number) 0 * (const byte) SIZEOF_STRUCT_POINT
-  (byte*~) main::$9 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
-  *((byte*~) main::$9 + (number~) main::$1) ← (number) 3
+  *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$1) ← (number) 3
   (number~) main::$2 ← (number) 1 * (const byte) SIZEOF_STRUCT_POINT
-  (byte*~) main::$10 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
-  *((byte*~) main::$10 + (number~) main::$2) ← (number) 5
+  *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$2) ← (number) 5
   (number~) main::$3 ← (number) 1 * (const byte) SIZEOF_STRUCT_POINT
-  (byte*~) main::$11 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
-  *((byte*~) main::$11 + (number~) main::$3) ← (number) 6
+  *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$3) ← (number) 6
   (number~) main::$4 ← (number) 0 * (const byte) SIZEOF_STRUCT_POINT
-  (byte*~) main::$12 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
-  *((const byte*) main::SCREEN + (number) 0) ← *((byte*~) main::$12 + (number~) main::$4)
+  *((const byte*) main::SCREEN + (number) 0) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$4)
   (number~) main::$5 ← (number) 0 * (const byte) SIZEOF_STRUCT_POINT
-  (byte*~) main::$13 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
-  *((const byte*) main::SCREEN + (number) 1) ← *((byte*~) main::$13 + (number~) main::$5)
+  *((const byte*) main::SCREEN + (number) 1) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$5)
   (number~) main::$6 ← (number) 1 * (const byte) SIZEOF_STRUCT_POINT
-  (byte*~) main::$14 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
-  *((const byte*) main::SCREEN + (number) 3) ← *((byte*~) main::$14 + (number~) main::$6)
+  *((const byte*) main::SCREEN + (number) 3) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$6)
   (number~) main::$7 ← (number) 1 * (const byte) SIZEOF_STRUCT_POINT
-  (byte*~) main::$15 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
-  *((const byte*) main::SCREEN + (number) 4) ← *((byte*~) main::$15 + (number~) main::$7)
+  *((const byte*) main::SCREEN + (number) 4) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$7)
   to:main::@return
 main::@return: scope:[main]  from main
   return 
@@ -69,53 +61,45 @@ SYMBOL TABLE SSA
 (void()) main()
 (number~) main::$0
 (number~) main::$1
-(byte*~) main::$10
-(byte*~) main::$11
-(byte*~) main::$12
-(byte*~) main::$13
-(byte*~) main::$14
-(byte*~) main::$15
 (number~) main::$2
 (number~) main::$3
 (number~) main::$4
 (number~) main::$5
 (number~) main::$6
 (number~) main::$7
-(byte*~) main::$8
-(byte*~) main::$9
 (label) main::@return
 (const byte*) main::SCREEN = (byte*)(number) $400
 (const struct Point*) points[(number) 2]  = { fill( 2, 0) }
 
 Adding number conversion cast (unumber) 0 in (number~) main::$0 ← (number) 0 * (const byte) SIZEOF_STRUCT_POINT
 Adding number conversion cast (unumber) main::$0 in (number~) main::$0 ← (unumber)(number) 0 * (const byte) SIZEOF_STRUCT_POINT
-Adding number conversion cast (unumber) 2 in *((byte*~) main::$8 + (unumber~) main::$0) ← (number) 2
+Adding number conversion cast (unumber) 2 in *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (unumber~) main::$0) ← (number) 2
 Adding number conversion cast (unumber) 0 in (number~) main::$1 ← (number) 0 * (const byte) SIZEOF_STRUCT_POINT
 Adding number conversion cast (unumber) main::$1 in (number~) main::$1 ← (unumber)(number) 0 * (const byte) SIZEOF_STRUCT_POINT
-Adding number conversion cast (unumber) 3 in *((byte*~) main::$9 + (unumber~) main::$1) ← (number) 3
+Adding number conversion cast (unumber) 3 in *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (unumber~) main::$1) ← (number) 3
 Adding number conversion cast (unumber) 1 in (number~) main::$2 ← (number) 1 * (const byte) SIZEOF_STRUCT_POINT
 Adding number conversion cast (unumber) main::$2 in (number~) main::$2 ← (unumber)(number) 1 * (const byte) SIZEOF_STRUCT_POINT
-Adding number conversion cast (unumber) 5 in *((byte*~) main::$10 + (unumber~) main::$2) ← (number) 5
+Adding number conversion cast (unumber) 5 in *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (unumber~) main::$2) ← (number) 5
 Adding number conversion cast (unumber) 1 in (number~) main::$3 ← (number) 1 * (const byte) SIZEOF_STRUCT_POINT
 Adding number conversion cast (unumber) main::$3 in (number~) main::$3 ← (unumber)(number) 1 * (const byte) SIZEOF_STRUCT_POINT
-Adding number conversion cast (unumber) 6 in *((byte*~) main::$11 + (unumber~) main::$3) ← (number) 6
+Adding number conversion cast (unumber) 6 in *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (unumber~) main::$3) ← (number) 6
 Adding number conversion cast (unumber) 0 in (number~) main::$4 ← (number) 0 * (const byte) SIZEOF_STRUCT_POINT
 Adding number conversion cast (unumber) main::$4 in (number~) main::$4 ← (unumber)(number) 0 * (const byte) SIZEOF_STRUCT_POINT
-Adding number conversion cast (unumber) 0 in *((const byte*) main::SCREEN + (number) 0) ← *((byte*~) main::$12 + (unumber~) main::$4)
+Adding number conversion cast (unumber) 0 in *((const byte*) main::SCREEN + (number) 0) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (unumber~) main::$4)
 Adding number conversion cast (unumber) 0 in (number~) main::$5 ← (number) 0 * (const byte) SIZEOF_STRUCT_POINT
 Adding number conversion cast (unumber) main::$5 in (number~) main::$5 ← (unumber)(number) 0 * (const byte) SIZEOF_STRUCT_POINT
-Adding number conversion cast (unumber) 1 in *((const byte*) main::SCREEN + (number) 1) ← *((byte*~) main::$13 + (unumber~) main::$5)
+Adding number conversion cast (unumber) 1 in *((const byte*) main::SCREEN + (number) 1) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (unumber~) main::$5)
 Adding number conversion cast (unumber) 1 in (number~) main::$6 ← (number) 1 * (const byte) SIZEOF_STRUCT_POINT
 Adding number conversion cast (unumber) main::$6 in (number~) main::$6 ← (unumber)(number) 1 * (const byte) SIZEOF_STRUCT_POINT
-Adding number conversion cast (unumber) 3 in *((const byte*) main::SCREEN + (number) 3) ← *((byte*~) main::$14 + (unumber~) main::$6)
+Adding number conversion cast (unumber) 3 in *((const byte*) main::SCREEN + (number) 3) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (unumber~) main::$6)
 Adding number conversion cast (unumber) 1 in (number~) main::$7 ← (number) 1 * (const byte) SIZEOF_STRUCT_POINT
 Adding number conversion cast (unumber) main::$7 in (number~) main::$7 ← (unumber)(number) 1 * (const byte) SIZEOF_STRUCT_POINT
-Adding number conversion cast (unumber) 4 in *((const byte*) main::SCREEN + (number) 4) ← *((byte*~) main::$15 + (unumber~) main::$7)
+Adding number conversion cast (unumber) 4 in *((const byte*) main::SCREEN + (number) 4) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (unumber~) main::$7)
 Successful SSA optimization PassNAddNumberTypeConversions
-Inlining cast *((byte*~) main::$8 + (unumber~) main::$0) ← (unumber)(number) 2
-Inlining cast *((byte*~) main::$9 + (unumber~) main::$1) ← (unumber)(number) 3
-Inlining cast *((byte*~) main::$10 + (unumber~) main::$2) ← (unumber)(number) 5
-Inlining cast *((byte*~) main::$11 + (unumber~) main::$3) ← (unumber)(number) 6
+Inlining cast *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (unumber~) main::$0) ← (unumber)(number) 2
+Inlining cast *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (unumber~) main::$1) ← (unumber)(number) 3
+Inlining cast *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (unumber~) main::$2) ← (unumber)(number) 5
+Inlining cast *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (unumber~) main::$3) ← (unumber)(number) 6
 Successful SSA optimization Pass2InlineCast
 Simplifying constant pointer cast (byte*) 1024
 Simplifying constant integer cast 0
@@ -161,53 +145,37 @@ Inferred type updated to byte in (unumber~) main::$5 ← (byte) 0 * (const byte)
 Inferred type updated to byte in (unumber~) main::$6 ← (byte) 1 * (const byte) SIZEOF_STRUCT_POINT
 Inferred type updated to byte in (unumber~) main::$7 ← (byte) 1 * (const byte) SIZEOF_STRUCT_POINT
 Constant right-side identified [0] (byte~) main::$0 ← (byte) 0 * (const byte) SIZEOF_STRUCT_POINT
-Constant right-side identified [1] (byte*~) main::$8 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
-Constant right-side identified [3] (byte~) main::$1 ← (byte) 0 * (const byte) SIZEOF_STRUCT_POINT
-Constant right-side identified [4] (byte*~) main::$9 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
-Constant right-side identified [6] (byte~) main::$2 ← (byte) 1 * (const byte) SIZEOF_STRUCT_POINT
-Constant right-side identified [7] (byte*~) main::$10 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
-Constant right-side identified [9] (byte~) main::$3 ← (byte) 1 * (const byte) SIZEOF_STRUCT_POINT
-Constant right-side identified [10] (byte*~) main::$11 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
-Constant right-side identified [12] (byte~) main::$4 ← (byte) 0 * (const byte) SIZEOF_STRUCT_POINT
-Constant right-side identified [13] (byte*~) main::$12 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
-Constant right-side identified [15] (byte~) main::$5 ← (byte) 0 * (const byte) SIZEOF_STRUCT_POINT
-Constant right-side identified [16] (byte*~) main::$13 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
-Constant right-side identified [18] (byte~) main::$6 ← (byte) 1 * (const byte) SIZEOF_STRUCT_POINT
-Constant right-side identified [19] (byte*~) main::$14 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
-Constant right-side identified [21] (byte~) main::$7 ← (byte) 1 * (const byte) SIZEOF_STRUCT_POINT
-Constant right-side identified [22] (byte*~) main::$15 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
+Constant right-side identified [2] (byte~) main::$1 ← (byte) 0 * (const byte) SIZEOF_STRUCT_POINT
+Constant right-side identified [4] (byte~) main::$2 ← (byte) 1 * (const byte) SIZEOF_STRUCT_POINT
+Constant right-side identified [6] (byte~) main::$3 ← (byte) 1 * (const byte) SIZEOF_STRUCT_POINT
+Constant right-side identified [8] (byte~) main::$4 ← (byte) 0 * (const byte) SIZEOF_STRUCT_POINT
+Constant right-side identified [10] (byte~) main::$5 ← (byte) 0 * (const byte) SIZEOF_STRUCT_POINT
+Constant right-side identified [12] (byte~) main::$6 ← (byte) 1 * (const byte) SIZEOF_STRUCT_POINT
+Constant right-side identified [14] (byte~) main::$7 ← (byte) 1 * (const byte) SIZEOF_STRUCT_POINT
 Successful SSA optimization Pass2ConstantRValueConsolidation
 Constant (const byte) main::$0 = 0*SIZEOF_STRUCT_POINT
-Constant (const byte*) main::$8 = (byte*)points+OFFSET_STRUCT_POINT_X
 Constant (const byte) main::$1 = 0*SIZEOF_STRUCT_POINT
-Constant (const byte*) main::$9 = (byte*)points+OFFSET_STRUCT_POINT_Y
 Constant (const byte) main::$2 = 1*SIZEOF_STRUCT_POINT
-Constant (const byte*) main::$10 = (byte*)points+OFFSET_STRUCT_POINT_X
 Constant (const byte) main::$3 = 1*SIZEOF_STRUCT_POINT
-Constant (const byte*) main::$11 = (byte*)points+OFFSET_STRUCT_POINT_Y
 Constant (const byte) main::$4 = 0*SIZEOF_STRUCT_POINT
-Constant (const byte*) main::$12 = (byte*)points+OFFSET_STRUCT_POINT_X
 Constant (const byte) main::$5 = 0*SIZEOF_STRUCT_POINT
-Constant (const byte*) main::$13 = (byte*)points+OFFSET_STRUCT_POINT_Y
 Constant (const byte) main::$6 = 1*SIZEOF_STRUCT_POINT
-Constant (const byte*) main::$14 = (byte*)points+OFFSET_STRUCT_POINT_X
 Constant (const byte) main::$7 = 1*SIZEOF_STRUCT_POINT
-Constant (const byte*) main::$15 = (byte*)points+OFFSET_STRUCT_POINT_Y
 Successful SSA optimization Pass2ConstantIdentification
 Simplifying constant evaluating to zero (byte) 0*(const byte) SIZEOF_STRUCT_POINT in 
 Simplifying constant evaluating to zero (byte) 0*(const byte) SIZEOF_STRUCT_POINT in 
 Simplifying constant evaluating to zero (byte) 0*(const byte) SIZEOF_STRUCT_POINT in 
 Simplifying constant evaluating to zero (byte) 0*(const byte) SIZEOF_STRUCT_POINT in 
 Successful SSA optimization PassNSimplifyConstantZero
-Simplifying expression containing zero (byte*)points in 
-Simplifying expression containing zero (byte*)points in 
-Simplifying expression containing zero (byte*)points in 
-Simplifying expression containing zero (byte*)points in 
-Simplifying expression containing zero main::$8 in [2] *((const byte*) main::$8 + (const byte) main::$0) ← (byte) 2
-Simplifying expression containing zero main::$9 in [5] *((const byte*) main::$9 + (const byte) main::$1) ← (byte) 3
-Simplifying expression containing zero main::$12 in [14] *((const byte*) main::SCREEN + (byte) 0) ← *((const byte*) main::$12 + (const byte) main::$4)
-Simplifying expression containing zero main::SCREEN in [14] *((const byte*) main::SCREEN + (byte) 0) ← *((const byte*) main::$12)
-Simplifying expression containing zero main::$13 in [17] *((const byte*) main::SCREEN + (byte) 1) ← *((const byte*) main::$13 + (const byte) main::$5)
+Simplifying expression containing zero (byte*)points+OFFSET_STRUCT_POINT_X in [1] *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (const byte) main::$0) ← (byte) 2
+Simplifying expression containing zero (byte*)points in [1] *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X) ← (byte) 2
+Simplifying expression containing zero (byte*)points+OFFSET_STRUCT_POINT_Y in [3] *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (const byte) main::$1) ← (byte) 3
+Simplifying expression containing zero (byte*)points in [5] *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (const byte) main::$2) ← (byte) 5
+Simplifying expression containing zero (byte*)points+OFFSET_STRUCT_POINT_X in [9] *((const byte*) main::SCREEN + (byte) 0) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (const byte) main::$4)
+Simplifying expression containing zero (byte*)points in [9] *((const byte*) main::SCREEN + (byte) 0) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X)
+Simplifying expression containing zero main::SCREEN in [9] *((const byte*) main::SCREEN + (byte) 0) ← *((byte*)(const struct Point*) points)
+Simplifying expression containing zero (byte*)points+OFFSET_STRUCT_POINT_Y in [11] *((const byte*) main::SCREEN + (byte) 1) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (const byte) main::$5)
+Simplifying expression containing zero (byte*)points in [13] *((const byte*) main::SCREEN + (byte) 3) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (const byte) main::$6)
 Successful SSA optimization PassNSimplifyExpressionWithZero
 Eliminating unused constant (const byte) main::$0
 Eliminating unused constant (const byte) main::$1
@@ -215,18 +183,10 @@ Eliminating unused constant (const byte) main::$4
 Eliminating unused constant (const byte) main::$5
 Eliminating unused constant (const byte) OFFSET_STRUCT_POINT_X
 Successful SSA optimization PassNEliminateUnusedVars
-Constant inlined main::$12 = (byte*)(const struct Point*) points
-Constant inlined main::$13 = (byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y
-Constant inlined main::$14 = (byte*)(const struct Point*) points
-Constant inlined main::$15 = (byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y
-Constant inlined main::$10 = (byte*)(const struct Point*) points
-Constant inlined main::$11 = (byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y
-Constant inlined main::$2 = (byte) 1*(const byte) SIZEOF_STRUCT_POINT
 Constant inlined main::$6 = (byte) 1*(const byte) SIZEOF_STRUCT_POINT
 Constant inlined main::$3 = (byte) 1*(const byte) SIZEOF_STRUCT_POINT
-Constant inlined main::$9 = (byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y
+Constant inlined main::$2 = (byte) 1*(const byte) SIZEOF_STRUCT_POINT
 Constant inlined main::$7 = (byte) 1*(const byte) SIZEOF_STRUCT_POINT
-Constant inlined main::$8 = (byte*)(const struct Point*) points
 Successful SSA optimization Pass2ConstantInlining
 Consolidated array index constant in *((byte*)points+1*SIZEOF_STRUCT_POINT)
 Consolidated array index constant in *((byte*)points+OFFSET_STRUCT_POINT_Y+1*SIZEOF_STRUCT_POINT)
diff --git a/src/test/ref/struct-ptr-8.log b/src/test/ref/struct-ptr-8.log
index e65ab6e25..5409c7f92 100644
--- a/src/test/ref/struct-ptr-8.log
+++ b/src/test/ref/struct-ptr-8.log
@@ -2,10 +2,10 @@ Fixing pointer array-indexing *((const struct Point*) points + (byte) main::i)
 Fixing pointer array-indexing *((const struct Point*) points + (byte) main::i)
 Fixing pointer array-indexing *((const struct Point*) points + (byte) main::i1)
 Fixing pointer array-indexing *((const struct Point*) points + (byte) main::i1)
-Rewriting struct pointer member access *((const struct Point*) points + (byte~) main::$4).x
-Rewriting struct pointer member access *((const struct Point*) points + (byte~) main::$5).y
-Rewriting struct pointer member access *((const struct Point*) points + (byte~) main::$6).x
-Rewriting struct pointer member access *((const struct Point*) points + (byte~) main::$7).y
+Replacing struct member reference *((const struct Point*) points + (byte~) main::$4).x with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$4)
+Replacing struct member reference *((const struct Point*) points + (byte~) main::$5).y with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$5)
+Replacing struct member reference *((const struct Point*) points + (byte~) main::$6).x with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$6)
+Replacing struct member reference *((const struct Point*) points + (byte~) main::$7).y with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$7)
 Culled Empty Block (label) main::@4
 
 CONTROL FLOW GRAPH SSA
@@ -20,12 +20,10 @@ main::@1: scope:[main]  from main main::@1
   (byte) main::i#2 ← phi( main/(byte) main::i#0 main::@1/(byte) main::i#1 )
   (number~) main::$0 ← (number) 2 + (byte) main::i#2
   (byte~) main::$4 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
-  (byte*~) main::$8 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
-  *((byte*~) main::$8 + (byte~) main::$4) ← (number~) main::$0
+  *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$4) ← (number~) main::$0
   (number~) main::$1 ← (number) 3 + (byte) main::i#2
   (byte~) main::$5 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
-  (byte*~) main::$9 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
-  *((byte*~) main::$9 + (byte~) main::$5) ← (number~) main::$1
+  *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$5) ← (number~) main::$1
   (byte) main::i#1 ← (byte) main::i#2 + rangenext(0,1)
   (bool~) main::$2 ← (byte) main::i#1 != rangelast(0,1)
   if((bool~) main::$2) goto main::@1
@@ -38,12 +36,10 @@ main::@3: scope:[main]  from main::@2 main::@3
   (byte) main::idx#4 ← phi( main::@2/(byte) main::idx#0 main::@3/(byte) main::idx#3 )
   (byte) main::i1#2 ← phi( main::@2/(byte) main::i1#0 main::@3/(byte) main::i1#1 )
   (byte~) main::$6 ← (byte) main::i1#2 * (const byte) SIZEOF_STRUCT_POINT
-  (byte*~) main::$10 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
-  *((const byte*) main::SCREEN + (byte) main::idx#4) ← *((byte*~) main::$10 + (byte~) main::$6)
+  *((const byte*) main::SCREEN + (byte) main::idx#4) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$6)
   (byte) main::idx#1 ← ++ (byte) main::idx#4
   (byte~) main::$7 ← (byte) main::i1#2 * (const byte) SIZEOF_STRUCT_POINT
-  (byte*~) main::$11 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
-  *((const byte*) main::SCREEN + (byte) main::idx#1) ← *((byte*~) main::$11 + (byte~) main::$7)
+  *((const byte*) main::SCREEN + (byte) main::idx#1) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$7)
   (byte) main::idx#2 ← ++ (byte) main::idx#1
   *((const byte*) main::SCREEN + (byte) main::idx#2) ← (byte) ' '
   (byte) main::idx#3 ← ++ (byte) main::idx#2
@@ -74,16 +70,12 @@ SYMBOL TABLE SSA
 (void()) main()
 (number~) main::$0
 (number~) main::$1
-(byte*~) main::$10
-(byte*~) main::$11
 (bool~) main::$2
 (bool~) main::$3
 (byte~) main::$4
 (byte~) main::$5
 (byte~) main::$6
 (byte~) main::$7
-(byte*~) main::$8
-(byte*~) main::$9
 (label) main::@1
 (label) main::@2
 (label) main::@3
@@ -119,31 +111,22 @@ Finalized unsigned number type (byte) 3
 Successful SSA optimization PassNFinalizeNumberTypeConversions
 Inferred type updated to byte in (unumber~) main::$0 ← (byte) 2 + (byte) main::i#2
 Inferred type updated to byte in (unumber~) main::$1 ← (byte) 3 + (byte) main::i#2
-Identified duplicate assignment right side [7] (byte~) main::$5 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
-Identified duplicate assignment right side [20] (byte~) main::$7 ← (byte) main::i1#2 * (const byte) SIZEOF_STRUCT_POINT
+Identified duplicate assignment right side [6] (byte~) main::$5 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
+Identified duplicate assignment right side [17] (byte~) main::$7 ← (byte) main::i1#2 * (const byte) SIZEOF_STRUCT_POINT
 Successful SSA optimization Pass2DuplicateRValueIdentification
-Simple Condition (bool~) main::$2 [12] if((byte) main::i#1!=rangelast(0,1)) goto main::@1
-Simple Condition (bool~) main::$3 [28] if((byte) main::i1#1!=rangelast(0,1)) goto main::@3
+Simple Condition (bool~) main::$2 [10] if((byte) main::i#1!=rangelast(0,1)) goto main::@1
+Simple Condition (bool~) main::$3 [24] if((byte) main::i1#1!=rangelast(0,1)) goto main::@3
 Successful SSA optimization Pass2ConditionalJumpSimplification
-Constant right-side identified [4] (byte*~) main::$8 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
-Constant right-side identified [8] (byte*~) main::$9 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
-Constant right-side identified [17] (byte*~) main::$10 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
-Constant right-side identified [21] (byte*~) main::$11 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
-Successful SSA optimization Pass2ConstantRValueConsolidation
 Constant (const byte) main::i#0 = 0
-Constant (const byte*) main::$8 = (byte*)points+OFFSET_STRUCT_POINT_X
-Constant (const byte*) main::$9 = (byte*)points+OFFSET_STRUCT_POINT_Y
 Constant (const byte) main::idx#0 = 0
 Constant (const byte) main::i1#0 = 0
-Constant (const byte*) main::$10 = (byte*)points+OFFSET_STRUCT_POINT_X
-Constant (const byte*) main::$11 = (byte*)points+OFFSET_STRUCT_POINT_Y
 Successful SSA optimization Pass2ConstantIdentification
-Resolved ranged next value [10] main::i#1 ← ++ main::i#2 to ++
-Resolved ranged comparison value [12] if(main::i#1!=rangelast(0,1)) goto main::@1 to (number) 2
-Resolved ranged next value [26] main::i1#1 ← ++ main::i1#2 to ++
-Resolved ranged comparison value [28] if(main::i1#1!=rangelast(0,1)) goto main::@3 to (number) 2
-Simplifying expression containing zero (byte*)points in 
-Simplifying expression containing zero (byte*)points in 
+Resolved ranged next value [8] main::i#1 ← ++ main::i#2 to ++
+Resolved ranged comparison value [10] if(main::i#1!=rangelast(0,1)) goto main::@1 to (number) 2
+Resolved ranged next value [22] main::i1#1 ← ++ main::i1#2 to ++
+Resolved ranged comparison value [24] if(main::i1#1!=rangelast(0,1)) goto main::@3 to (number) 2
+Simplifying expression containing zero (byte*)points in [4] *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$4) ← (byte~) main::$0
+Simplifying expression containing zero (byte*)points in [15] *((const byte*) main::SCREEN + (byte) main::idx#4) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$6)
 Successful SSA optimization PassNSimplifyExpressionWithZero
 Eliminating unused constant (const byte) OFFSET_STRUCT_POINT_X
 Successful SSA optimization PassNEliminateUnusedVars
@@ -165,13 +148,9 @@ Successful SSA optimization Pass2MultiplyToShiftRewriting
 Inlining constant with var siblings (const byte) main::i#0
 Inlining constant with var siblings (const byte) main::idx#0
 Inlining constant with var siblings (const byte) main::i1#0
-Constant inlined main::idx#0 = (byte) 0
 Constant inlined main::i#0 = (byte) 0
 Constant inlined main::i1#0 = (byte) 0
-Constant inlined main::$9 = (byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y
-Constant inlined main::$10 = (byte*)(const struct Point*) points
-Constant inlined main::$8 = (byte*)(const struct Point*) points
-Constant inlined main::$11 = (byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y
+Constant inlined main::idx#0 = (byte) 0
 Successful SSA optimization Pass2ConstantInlining
 Eliminating unused constant (const byte) SIZEOF_STRUCT_POINT
 Successful SSA optimization PassNEliminateUnusedVars