diff --git a/build_the_compiler.cmd b/build_the_compiler.cmd
deleted file mode 100644
index e4b12bb6a..000000000
--- a/build_the_compiler.cmd
+++ /dev/null
@@ -1,12 +0,0 @@
-mkdir compiled_java
-
-java -jar ../antlr/lib/antlr-4.7.2-complete.jar -o ./prog8/parser -Xexact-output-dir -no-listener -no-visitor -package prog8.parser ../antlr/prog8.g4
-
-@dir /b /S src *.java > sources.txt
-javac  -verbose -d compiled_java -cp ../antlr/lib/antlr-runtime-4.7.2.jar @sources.txt
-@del sources.txt
-jar cf parser.jar -C compiled_java prog8
-
-set KOTLINC=%USERPROFILE%\.IdeaIC2018.3\config\plugins\kotlin\kotlinc\bin\kotlinc.bat
-
-%KOTLINC% -verbose -include-runtime -d prog8_kotlin.jar -cp ../antlr/lib/antlr-runtime-4.7.2.jar;parser.jar prog8
diff --git a/compiler/src/prog8/compiler/Compiler.kt b/compiler/src/prog8/compiler/Compiler.kt
index fe3c29376..9aec7d2e8 100644
--- a/compiler/src/prog8/compiler/Compiler.kt
+++ b/compiler/src/prog8/compiler/Compiler.kt
@@ -946,43 +946,14 @@ private class StatementTranslator(private val prog: IntermediateProgram,
             throw AstException("swap requires args of numerical type")
         // @todo implement these errors as nice AstChecker expression errors.
 
-        // eor trick:  Swap(X,Y) :=
-        //        X ^= Y
-        //        Y ^= X
-        //        X ^= Y
-        // this trick is used when we're dealing with: (u)byte or (u)word variables, ... @todo
-
-        if(useEorTrickForSwap(dt1, args[0], args[1])) {
-            val xEorY = BinaryExpression(args[0], "^", args[1], args[0].position)
-            val yEorX = BinaryExpression(args[1], "^", args[0], args[1].position)
-            val xIsXeorY = Assignment(listOf(AssignTarget.fromExpr(args[0])), null, xEorY, args[0].position)
-            val yIsYeorX = Assignment(listOf(AssignTarget.fromExpr(args[1])), null, yEorX, args[1].position)
-            xIsXeorY.linkParents(args[0].parent)
-            yIsYeorX.linkParents(args[0].parent)
-            translate(xIsXeorY)
-            translate(yIsYeorX)
-            translate(xIsXeorY)
-        } else {
-            translate(args[0])
-            translate(args[1])
-            // pop in reverse order
-            popValueIntoTarget(AssignTarget.fromExpr(args[0]), dt1)
-            popValueIntoTarget(AssignTarget.fromExpr(args[1]), dt2)
-        }
+        translate(args[0])
+        translate(args[1])
+        // pop in reverse order
+        popValueIntoTarget(AssignTarget.fromExpr(args[0]), dt1)
+        popValueIntoTarget(AssignTarget.fromExpr(args[1]), dt2)
         return
     }
 
-    private fun useEorTrickForSwap(dt: DataType, expr1: IExpression, expr2: IExpression): Boolean {
-        if(dt in IntegerDatatypes) {
-            if (expr1 is IdentifierReference && expr2 is IdentifierReference)
-                return true
-            if(expr1 is ArrayIndexedExpression && expr2 is ArrayIndexedExpression) {
-                return expr1.arrayspec.x is LiteralValue && expr2.arrayspec.x is LiteralValue
-            }
-        }
-        return false
-    }
-
     private fun translateSubroutineCall(subroutine: Subroutine, arguments: List<IExpression>, callPosition: Position) {
         // evaluate the arguments and assign them into the subroutine's argument variables.
         var restoreX = Register.X in subroutine.asmClobbers
diff --git a/compiler/src/prog8/compiler/target/c64/AsmGen.kt b/compiler/src/prog8/compiler/target/c64/AsmGen.kt
index 63219043e..514155d16 100644
--- a/compiler/src/prog8/compiler/target/c64/AsmGen.kt
+++ b/compiler/src/prog8/compiler/target/c64/AsmGen.kt
@@ -195,7 +195,7 @@ class AsmGen(val options: CompilationOptions, val program: IntermediateProgram,
         vardecls2asm(block)
         out("")
 
-        val instructionPatternWindowSize = 7        // increase once patterns occur longer than this.
+        val instructionPatternWindowSize = 8        // increase once patterns occur longer than this.
         var processed = 0
 
         if(trace) println("BLOCK: ${block.scopedname}  ${block.address ?: ""}")
@@ -3312,8 +3312,196 @@ class AsmGen(val options: CompilationOptions, val program: IntermediateProgram,
                     val value = hexVal(segment[0])
                     " lda  #<$value |  sta  ${ESTACK_LO.toHex()},x |  lda  #>$value |  sta  ${ESTACK_HI.toHex()},x |  dex |  jsr  prog8_lib.mul_word"
                 }
+            },
+
+            // various variable or memory swaps
+            AsmPattern(listOf(Opcode.PUSH_VAR_BYTE, Opcode.PUSH_VAR_BYTE, Opcode.POP_VAR_BYTE, Opcode.POP_VAR_BYTE)) { segment ->
+                val var1 = segment[0].callLabel
+                val var2 = segment[1].callLabel
+                val var3 = segment[2].callLabel
+                val var4 = segment[3].callLabel
+                if(var1==var3 && var2==var4) {
+                    """
+                    lda  $var1
+                    tay
+                    lda  $var2
+                    sta  $var1
+                    sty  $var2
+                    """
+                } else null
+            },
+            AsmPattern(listOf(Opcode.PUSH_VAR_WORD, Opcode.PUSH_VAR_WORD, Opcode.POP_VAR_WORD, Opcode.POP_VAR_WORD)) { segment ->
+                val var1 = segment[0].callLabel
+                val var2 = segment[1].callLabel
+                val var3 = segment[2].callLabel
+                val var4 = segment[3].callLabel
+                if(var1==var3 && var2==var4) {
+                    """
+                    lda  $var1
+                    tay
+                    lda  $var2
+                    sta  $var1
+                    sty  $var2
+                    lda  $var1+1
+                    tay
+                    lda  $var2+1
+                    sta  $var1+1
+                    sty  $var2+1
+                    """
+                } else null
+            },
+            AsmPattern(listOf(Opcode.PUSH_MEM_B, Opcode.PUSH_MEM_B, Opcode.POP_MEM_BYTE, Opcode.POP_MEM_BYTE),
+                    listOf(Opcode.PUSH_MEM_UB, Opcode.PUSH_MEM_UB, Opcode.POP_MEM_BYTE, Opcode.POP_MEM_BYTE)) { segment ->
+                val addr1 = segment[0].arg!!.integerValue()
+                val addr2 = segment[1].arg!!.integerValue()
+                val addr3 = segment[2].arg!!.integerValue()
+                val addr4 = segment[3].arg!!.integerValue()
+                if(addr1==addr3 && addr2==addr4) {
+                    """
+                    lda  ${addr1.toHex()}
+                    tay
+                    lda  ${addr2.toHex()}
+                    sta  ${addr1.toHex()}
+                    sty  ${addr2.toHex()}
+                    """
+                } else null
+            },
+            AsmPattern(listOf(Opcode.PUSH_MEM_W, Opcode.PUSH_MEM_W, Opcode.POP_MEM_WORD, Opcode.POP_MEM_WORD),
+                    listOf(Opcode.PUSH_MEM_UW, Opcode.PUSH_MEM_UW, Opcode.POP_MEM_WORD, Opcode.POP_MEM_WORD)) { segment ->
+                val addr1 = segment[0].arg!!.integerValue()
+                val addr2 = segment[1].arg!!.integerValue()
+                val addr3 = segment[2].arg!!.integerValue()
+                val addr4 = segment[3].arg!!.integerValue()
+                if(addr1==addr3 && addr2==addr4) {
+                    """
+                    lda  ${addr1.toHex()}
+                    tay
+                    lda  ${addr2.toHex()}
+                    sta  ${addr1.toHex()}
+                    sty  ${addr2.toHex()}
+                    lda  ${(addr1+1).toHex()}
+                    tay
+                    lda  ${(addr2+1).toHex()}
+                    sta  ${(addr1+1).toHex()}
+                    sty  ${(addr2+1).toHex()}
+                    """
+                } else null
+            },
+            AsmPattern(listOf(Opcode.PUSH_BYTE, Opcode.READ_INDEXED_VAR_BYTE, Opcode.PUSH_BYTE, Opcode.READ_INDEXED_VAR_BYTE,
+                    Opcode.PUSH_BYTE, Opcode.WRITE_INDEXED_VAR_BYTE, Opcode.PUSH_BYTE, Opcode.WRITE_INDEXED_VAR_BYTE)) { segment ->
+                val i1 = segment[0].arg!!.integerValue()
+                val i2 = segment[2].arg!!.integerValue()
+                val i3 = segment[4].arg!!.integerValue()
+                val i4 = segment[6].arg!!.integerValue()
+                val array1 = segment[1].callLabel
+                val array2 = segment[3].callLabel
+                val array3 = segment[5].callLabel
+                val array4 = segment[7].callLabel
+                if(i1==i3 && i2==i4 && array1==array3 && array2==array4) {
+                    """
+                    lda  $array1+$i1
+                    tay
+                    lda  $array2+$i2
+                    sta  $array1+$i1
+                    sty  $array2+$i2
+                    """
+                } else null
+            },
+            AsmPattern(listOf(Opcode.PUSH_VAR_BYTE, Opcode.READ_INDEXED_VAR_BYTE, Opcode.PUSH_VAR_BYTE, Opcode.READ_INDEXED_VAR_BYTE,
+                    Opcode.PUSH_VAR_BYTE, Opcode.WRITE_INDEXED_VAR_BYTE, Opcode.PUSH_VAR_BYTE, Opcode.WRITE_INDEXED_VAR_BYTE)) { segment ->
+                val vi1 = segment[0].callLabel
+                val vi2 = segment[2].callLabel
+                val vi3 = segment[4].callLabel
+                val vi4 = segment[6].callLabel
+                val array1 = segment[1].callLabel
+                val array2 = segment[3].callLabel
+                val array3 = segment[5].callLabel
+                val array4 = segment[7].callLabel
+                if(vi1==vi3 && vi2==vi4 && array1==array3 && array2==array4) {
+                    val load1 = loadAFromIndexedByVar(segment[0], segment[1])
+                    val load2 = loadAFromIndexedByVar(segment[2], segment[3])
+                    val storeIn1 = storeAToIndexedByVar(segment[0], segment[1])
+                    val storeIn2 = storeAToIndexedByVar(segment[2], segment[3])
+                    """
+                    $load1
+                    pha
+                    $load2
+                    $storeIn1
+                    pla
+                    $storeIn2
+                    """
+                } else null
+            },
+            AsmPattern(listOf(Opcode.PUSH_BYTE, Opcode.READ_INDEXED_VAR_WORD, Opcode.PUSH_BYTE, Opcode.READ_INDEXED_VAR_WORD,
+                    Opcode.PUSH_BYTE, Opcode.WRITE_INDEXED_VAR_WORD, Opcode.PUSH_BYTE, Opcode.WRITE_INDEXED_VAR_WORD)) { segment ->
+                val i1 = segment[0].arg!!.integerValue()*2
+                val i2 = segment[2].arg!!.integerValue()*2
+                val i3 = segment[4].arg!!.integerValue()*2
+                val i4 = segment[6].arg!!.integerValue()*2
+                val array1 = segment[1].callLabel
+                val array2 = segment[3].callLabel
+                val array3 = segment[5].callLabel
+                val array4 = segment[7].callLabel
+                if(i1==i3 && i2==i4 && array1==array3 && array2==array4) {
+                    """
+                    lda  $array1+$i1
+                    tay
+                    lda  $array2+$i2
+                    sta  $array1+$i1
+                    sty  $array2+$i2
+                    lda  $array1+${i1+1}
+                    tay
+                    lda  $array2+${i2+1}
+                    sta  $array1+${i1+1}
+                    sty  $array2+${i2+1}
+                    """
+                } else null
+            },
+            AsmPattern(listOf(Opcode.PUSH_VAR_BYTE, Opcode.READ_INDEXED_VAR_WORD, Opcode.PUSH_VAR_BYTE, Opcode.READ_INDEXED_VAR_WORD,
+                    Opcode.PUSH_VAR_BYTE, Opcode.WRITE_INDEXED_VAR_WORD, Opcode.PUSH_VAR_BYTE, Opcode.WRITE_INDEXED_VAR_WORD)) { segment ->
+                val vi1 = segment[0].callLabel
+                val vi2 = segment[2].callLabel
+                val vi3 = segment[4].callLabel
+                val vi4 = segment[6].callLabel
+                val array1 = segment[1].callLabel
+                val array2 = segment[3].callLabel
+                val array3 = segment[5].callLabel
+                val array4 = segment[7].callLabel
+                if(vi1==vi3 && vi2==vi4 && array1==array3 && array2==array4) {
+                    //  SCRATCH_B1 = index1
+                    //  SCRATCH_REG = index2
+                    //  SCRATCH_W1 = temp storage of array[index2]
+                    """
+                    lda  ${segment[0].callLabel}
+                    asl  a
+                    sta  ${C64Zeropage.SCRATCH_B1}
+                    lda  ${segment[2].callLabel}
+                    asl  a
+                    sta  ${C64Zeropage.SCRATCH_REG}
+                    stx  ${C64Zeropage.SCRATCH_REG_X}
+                    tax
+                    lda  ${segment[3].callLabel},x
+                    ldy  ${segment[3].callLabel}+1,x
+                    sta  ${C64Zeropage.SCRATCH_W1}
+                    sty  ${C64Zeropage.SCRATCH_W1}+1
+                    ldx  ${C64Zeropage.SCRATCH_B1}
+                    lda  ${segment[1].callLabel},x
+                    ldy  ${segment[1].callLabel}+1,x
+                    ldx  ${C64Zeropage.SCRATCH_REG}
+                    sta  ${segment[3].callLabel},x
+                    tya
+                    sta  ${segment[3].callLabel}+1,x
+                    ldx  ${C64Zeropage.SCRATCH_B1}
+                    lda  ${C64Zeropage.SCRATCH_W1}
+                    sta  ${segment[1].callLabel},x
+                    lda  ${C64Zeropage.SCRATCH_W1}+1
+                    sta  ${segment[1].callLabel}+1,x
+                    ldx  ${C64Zeropage.SCRATCH_REG_X}
+                    """
+                } else null
             }
 
+
     )
 
 }
diff --git a/examples/assignments.p8 b/examples/assignments.p8
deleted file mode 100644
index 91adfbe2f..000000000
--- a/examples/assignments.p8
+++ /dev/null
@@ -1,860 +0,0 @@
-%import c64utils
-%import c64flt
-%output raw
-%launcher none
-%address $4000
-
-~ main {
-
-sub start() {
-
-    byte b = 99
-    byte b2 = 100
-    ubyte ub = 255
-    ubyte ub2 = 0
-    word w = 999
-    word w2 = 3
-    uword uw = 40000
-    uword uw2 = 3434
-    float fl1 = 1.1
-    float fl2 = 2.2
-
-    byte[5] barr1
-    byte[5] barr2
-    ubyte[5] ubarr1
-    ubyte[5] ubarr2
-    word[5] warr1
-    word[5] warr2
-    uword[5] uwarr1
-    uword[5] uwarr2
-    float[5] farr1
-    float[5] farr2
-
-    memory byte mbyte = $c000
-    memory byte mbyte2 = $d000
-    memory ubyte mubyte = $c001
-    memory ubyte mubyte2 = $d001
-    memory word mword = $c002
-    memory word mword2 = $d002
-    memory uword muword = $c004
-    memory uword muword2 = $d004
-    memory float mfloat = $c006
-    memory float mfloat2 = $d006
-    memory byte[mubyte2] mbarr1 = $e000
-    memory ubyte[mubyte2] mubarr1 = $e100
-    memory word[mubyte2] mwarr1 = $e100
-    memory uword[mubyte2] muwarr1 = $e100
-
-    str  string = "hello"
-    str_p stringp = "hello"
-
-
-; some string assignments
-
-        str   stringvar   = "??????????\n\n\nnext line\r\r\rnext line after carriagereturn"
-        ubyte  secretnumber = 0
-        memory uword freadstr_arg = $22		; argument for FREADSTR
-        uword testword
-        ubyte char1 = '@'
-        ubyte char2 = '\n'
-        ubyte char3 = '\r'
-        ubyte char1b = '@'
-        ubyte char2b = '\n'
-        ubyte char3b = '\r'
-
-        testword = '@'
-        testword = '\n'
-        freadstr_arg = '@'
-        freadstr_arg = '\n'
-        secretnumber = '@'
-        secretnumber = '\r'
-
-        testword  = stringvar
-        testword = "stringstring"
-        freadstr_arg = stringvar
-        freadstr_arg = "stringstring"
-
-
-; all possible assignments to a BYTE VARIABLE (not array)
-
-
-ubyte_assignment_to_register:
-    A = 42
-    A = X
-    A = ub2
-    A = mubyte2
-    A = string[4]
-    A = string[X]
-    A = string[b]
-    A = string[ub]
-    A = string[mbyte2]
-    A = string[mubyte2]
-    A = ubarr1[2]
-    A = ubarr1[X]
-    A = ubarr1[b]
-    A = ubarr1[ub]
-    A = ubarr1[mbyte2]
-    A = ubarr1[mubyte2]
-
-ubyte_assignment_to_ubytevar:
-    ub = 42
-    ub = X
-    ub = ub2
-    ub = mubyte2
-    ub = string[4]
-    ub = string[X]
-    ub = string[b]
-    ub = string[ub]
-    ub = string[mbyte2]
-    ub = string[mubyte2]
-    ub = ubarr1[2]
-    ub = ubarr1[X]
-    ub = ubarr1[b]
-    ub = ubarr1[ub]
-    ub = ubarr1[mbyte2]
-    ub = ubarr1[mubyte2]
-
-
-ubyte_assignment_to_ubytemem:
-    mubyte = 42
-    mubyte = X
-    mubyte = ub2
-    mubyte = mubyte2
-    mubyte = string[4]
-    mubyte = string[X]
-    mubyte = string[b]
-    mubyte = string[ub]
-    mubyte = string[mbyte2]
-    mubyte = string[mubyte2]
-    mubyte = ubarr1[2]
-    mubyte = ubarr1[X]
-    mubyte = ubarr1[b]
-    mubyte = ubarr1[ub]
-    mubyte = ubarr1[mbyte2]
-    mubyte = ubarr1[mubyte2]
-
-byte_assignment_to_bytevar:
-    b = -42
-    b = b2
-    b = mbyte2
-    b = barr1[2]
-    b = barr1[X]
-    b = barr1[b]
-    b = barr1[ub]
-    b = barr1[mbyte2]
-    b = barr1[mubyte2]
-
-
-byte_assignment_to_bytemem:
-    mbyte = -42
-    mbyte = b2
-    mbyte = mbyte2
-    mbyte = barr1[2]
-    mbyte = barr1[X]
-    mbyte = barr1[b]
-    mbyte = barr1[ub]
-    mbyte = barr1[mbyte2]
-    mbyte = barr1[mubyte2]
-
-
-ubyte_assignment_to_ubytearray:
-    ubarr2[3] = 42
-    ubarr2[3] = X
-    ubarr2[3] = ub2
-    ubarr2[3] = mubyte2
-    ubarr2[3] = string[4]
-    ubarr2[3] = string[X]
-    ubarr2[3] = string[b]
-    ubarr2[3] = string[ub]
-    ubarr2[3] = string[mbyte2]
-    ubarr2[3] = string[mubyte2]
-    ubarr2[3] = ubarr1[2]
-    ubarr2[3] = ubarr1[X]
-    ubarr2[3] = ubarr1[b]
-    ubarr2[3] = ubarr1[ub]
-    ubarr2[3] = ubarr1[mbyte2]
-    ubarr2[3] = ubarr1[mubyte2]
-    string[4] = 42
-    string[4] = 'B'
-    string[4] = X
-    string[4] = ub2
-    string[4] = mubyte2
-    string[4] = ubarr1[2]
-    string[4] = ubarr1[X]
-    string[4] = ubarr1[ub]
-    string[4] = ubarr1[mubyte2]
-    string[4] = string[3]
-    string[4] = string[Y]
-    string[4] = string[ub2]
-    string[4] = string[mbyte2]
-    string[4] = string[mubyte2]
-
-
-    ubarr2[Y] = 42
-    ubarr2[Y] = X
-    ubarr2[Y] = ub2
-    ubarr2[Y] = mubyte2
-    ubarr2[Y] = string[4]
-    ubarr2[Y] = string[X]
-    ubarr2[Y] = string[b]
-    ubarr2[Y] = string[ub]
-    ubarr2[Y] = string[mbyte2]
-    ubarr2[Y] = string[mubyte2]
-    ubarr2[Y] = ubarr1[2]
-    ubarr2[Y] = ubarr1[X]
-    ubarr2[Y] = ubarr1[b]
-    ubarr2[Y] = ubarr1[ub]
-    ubarr2[Y] = ubarr1[mbyte2]
-    ubarr2[Y] = ubarr1[mubyte2]
-    string[Y] = 42
-    string[Y] = 'B'
-    string[Y] = X
-    string[Y] = ub2
-    string[Y] = mubyte2
-    string[Y] = ubarr1[2]
-    string[Y] = ubarr1[Y]
-    string[Y] = ubarr1[ub2]
-    string[Y] = ubarr1[mubyte2]
-    string[Y] = string[Y]
-    string[Y] = string[ub2]
-    string[Y] = string[mbyte2]
-    string[Y] = string[mubyte2]
-
-
-        ubarr2[ub2] = 42
-        ubarr2[ub2] = X
-        ubarr2[ub2] = ub2
-        ubarr2[ub2] = mubyte2
-        ubarr2[ub2] = string[4]
-        ubarr2[ub2] = string[X]
-        ubarr2[ub2] = string[b]
-        ubarr2[ub2] = string[ub]
-        ubarr2[ub2] = string[mbyte2]
-        ubarr2[ub2] = string[mubyte2]
-        ubarr2[ub2] = ubarr1[2]
-        ubarr2[ub2] = ubarr1[X]
-        ubarr2[ub2] = ubarr1[b]
-        ubarr2[ub2] = ubarr1[ub]
-        ubarr2[ub2] = ubarr1[mbyte2]
-        ubarr2[ub2] = ubarr1[mubyte2]
-        string[ub2] = 42
-        string[ub2] = 'B'
-        string[ub2] = X
-        string[ub2] = ub2
-        string[ub2] = mubyte2
-        string[ub2] = ubarr1[2]
-        string[ub2] = ubarr1[Y]
-        string[ub2] = ubarr1[ub2]
-        string[ub2] = ubarr1[mubyte2]
-        string[ub2] = string[Y]
-        string[ub2] = string[ub2]
-        string[ub2] = string[mbyte2]
-        string[ub2] = string[mubyte2]
-
-
-        ubarr2[b2] = 42
-        ubarr2[b2] = X
-        ubarr2[b2] = ub2
-        ubarr2[b2] = mubyte2
-        ubarr2[b2] = string[4]
-        ubarr2[b2] = string[X]
-        ubarr2[b2] = string[b]
-        ubarr2[b2] = string[ub]
-        ubarr2[b2] = string[mbyte2]
-        ubarr2[b2] = string[mubyte2]
-        ubarr2[b2] = ubarr1[2]
-        ubarr2[b2] = ubarr1[X]
-        ubarr2[b2] = ubarr1[b]
-        ubarr2[b2] = ubarr1[ub]
-        ubarr2[b2] = ubarr1[mbyte2]
-        ubarr2[b2] = ubarr1[mubyte2]
-        string[b2] = 42
-        string[b2] = 'B'
-        string[b2] = X
-        string[b2] = ub2
-        string[b2] = mubyte2
-        string[b2] = ubarr1[2]
-        string[b2] = ubarr1[Y]
-        string[b2] = ubarr1[ub2]
-        string[b2] = ubarr1[mubyte2]
-        string[b2] = string[Y]
-        string[b2] = string[ub2]
-        string[b2] = string[mbyte2]
-        string[b2] = string[mubyte2]
-
-    ubarr2[mubyte2] = 42
-    ubarr2[mubyte2] = X
-    ubarr2[mubyte2] = ub2
-    ubarr2[mubyte2] = mubyte2
-    ubarr2[mubyte2] = string[4]
-    ubarr2[mubyte2] = ubarr1[2]
-    string[mubyte2] = 42
-    string[mubyte2] = 'B'
-    string[mubyte2] = X
-    string[mubyte2] = ub2
-    string[mubyte2] = mubyte2
-    string[mubyte2] = ubarr1[2]
-
-    ubarr2[mubyte2] = string[Y]             ; via evaluation
-    ubarr2[mubyte2] = string[b]             ; via evaluation
-    ubarr2[mubyte2] = string[ub]            ; via evaluation
-    ubarr2[mubyte2] = string[mbyte2]        ; via evaluation
-    ubarr2[mubyte2] = string[mubyte2]       ; via evaluation
-    ubarr2[mubyte2] = ubarr1[Y]             ; via evaluation
-    ubarr2[mubyte2] = ubarr1[b]             ; via evaluation
-    ubarr2[mubyte2] = ubarr1[ub]            ; via evaluation
-    ubarr2[mubyte2] = ubarr1[mbyte2]        ; via evaluation
-    ubarr2[mubyte2] = ubarr1[mubyte2]       ; via evaluation
-    string[mubyte2] = ubarr1[Y]             ; via evaluation
-    string[mubyte2] = ubarr1[b]             ; via evaluation
-    string[mubyte2] = ubarr1[ub2]           ; via evaluation
-    string[mubyte2] = ubarr1[mbyte2]        ; via evaluation
-    string[mubyte2] = ubarr1[mubyte2]       ; via evaluation
-    string[mubyte2] = string[mubyte2]       ; via evaluation
-    ubarr1[ubarr2[A]] = ubarr2[ubarr1[Y]]   ; via evaluation
-
-
-
-byte_assignment_to_bytearray:
-
-    barr2[3] = 42
-    barr2[3] = b2
-    barr2[3] = mbyte2
-    barr2[3] = barr1[2]
-    barr2[3] = barr1[X]
-    barr2[3] = barr1[b]
-    barr2[3] = barr1[ub]
-    barr2[3] = barr1[mbyte2]
-    barr2[3] = barr1[mubyte2]
-
-    barr2[Y] = 42
-    barr2[Y] = b2
-    barr2[Y] = mbyte2
-    barr2[Y] = barr1[2]
-    barr2[Y] = barr1[X]
-    barr2[Y] = barr1[b]
-    barr2[Y] = barr1[ub]
-    barr2[Y] = barr1[mbyte2]
-    barr2[Y] = barr1[mubyte2]
-
-        barr2[b2] = 42
-        barr2[b2] = b2
-        barr2[b2] = mbyte2
-        barr2[b2] = barr1[2]
-        barr2[b2] = barr1[X]
-        barr2[b2] = barr1[b]
-        barr2[b2] = barr1[ub]
-        barr2[b2] = barr1[mbyte2]
-        barr2[b2] = barr1[mubyte2]
-
-        barr2[ub2] = 42
-        barr2[ub2] = b2
-        barr2[ub2] = mbyte2
-        barr2[ub2] = barr1[2]
-        barr2[ub2] = barr1[X]
-        barr2[ub2] = barr1[b]
-        barr2[ub2] = barr1[ub]
-        barr2[ub2] = barr1[mbyte2]
-        barr2[ub2] = barr1[mubyte2]
-
-    barr2[mubyte2] = 42
-    barr2[mubyte2] = b2
-    barr2[mubyte2] = mbyte2
-    barr2[mubyte2] = barr1[2]
-    barr2[mubyte2] = barr1[Y]         ; via evaluation
-    barr2[mubyte2] = barr1[b]         ; via evaluation
-    barr2[mubyte2] = barr1[ub]        ; via evaluation
-    barr2[mubyte2] = barr1[mbyte2]    ; via evaluation
-    barr2[mubyte2] = barr1[mubyte2]   ; via evaluation
-    barr1[ubarr2[A]] = barr2[ubarr1[Y]]   ; via evaluation
-
-
-byte_assignment_to_membytearray:
-
-    mbarr1[3] = 42
-    mbarr1[3] = b2
-    mbarr1[3] = mbyte2
-    mbarr1[3] = barr1[2]
-    mbarr1[3] = barr1[X]
-    mbarr1[3] = barr1[b]
-    mbarr1[3] = barr1[ub]
-    mbarr1[3] = barr1[mbyte2]
-    mbarr1[3] = barr1[mubyte2]
-
-    mbarr1[Y] = 42
-    mbarr1[Y] = b2
-    mbarr1[Y] = mbyte2
-    mbarr1[Y] = barr1[2]
-    mbarr1[Y] = barr1[X]
-    mbarr1[Y] = barr1[b]
-    mbarr1[Y] = barr1[ub]
-    mbarr1[Y] = barr1[mbyte2]
-    mbarr1[Y] = barr1[mubyte2]
-
-        mbarr1[b2] = 42
-        mbarr1[b2] = b2
-        mbarr1[b2] = mbyte2
-        mbarr1[b2] = barr1[2]
-        mbarr1[b2] = barr1[X]
-        mbarr1[b2] = barr1[b]
-        mbarr1[b2] = barr1[ub]
-        mbarr1[b2] = barr1[mbyte2]
-        mbarr1[b2] = barr1[mubyte2]
-
-        mbarr1[ub2] = 42
-        mbarr1[ub2] = b2
-        mbarr1[ub2] = mbyte2
-        mbarr1[ub2] = barr1[2]
-        mbarr1[ub2] = barr1[X]
-        mbarr1[ub2] = barr1[b]
-        mbarr1[ub2] = barr1[ub]
-        mbarr1[ub2] = barr1[mbyte2]
-        mbarr1[ub2] = barr1[mubyte2]
-
-    mbarr1[mubyte2] = 42
-    mbarr1[mubyte2] = b2
-    mbarr1[mubyte2] = mbyte2
-    mbarr1[mubyte2] = barr1[2]
-    mbarr1[mubyte2] = barr1[Y]         ; via evaluation
-    mbarr1[mubyte2] = barr1[b]         ; via evaluation
-    mbarr1[mubyte2] = barr1[ub]        ; via evaluation
-    mbarr1[mubyte2] = barr1[mbyte2]    ; via evaluation
-    mbarr1[mubyte2] = barr1[mubyte2]   ; via evaluation
-    mbarr1[ubarr2[A]] = barr2[ubarr1[Y]]   ; via evaluation
-
-
-
-; all possible assignments to a UWORD VARIABLE (not array)
-
-
-uword_assignment_to_uwordvar:
-    uw = 42
-    uw = 42.w
-    uw = 42555
-    uw = X
-    uw = ub2
-    uw = uw2
-    uw = mubyte2
-    uw = muword2
-    uw = string[4]
-    uw = ubarr1[2]
-    uw = uwarr1[2]
-    uw = string[X]
-    uw = string[b]
-    uw = string[ub]
-    uw = string[mbyte2]
-    uw = string[mubyte2]
-    uw = ubarr1[X]
-    uw = ubarr1[b]
-    uw = ubarr1[ub]
-    uw = ubarr1[mbyte2]
-    uw = ubarr1[mubyte2]
-    uw = uwarr1[X]
-    uw = uwarr1[b]
-    uw = uwarr1[ub]
-    uw = uwarr1[mbyte2]
-    uw = uwarr1[mubyte2]
-
-
-uword_assignment_to_uwordmem:
-    muword = 42
-    muword = 42.w
-    muword = 42555
-    muword = X
-    muword = ub2
-    muword = uw2
-    muword = mubyte2
-    muword = muword2
-    muword = string[4]
-    muword = ubarr1[2]
-    muword = uwarr1[2]
-    muword = string[X]
-    muword = string[b]
-    muword = string[ub]
-    muword = string[mbyte2]
-    muword = string[mubyte2]
-    muword = ubarr1[X]
-    muword = ubarr1[b]
-    muword = ubarr1[ub]
-    muword = ubarr1[mbyte2]
-    muword = ubarr1[mubyte2]
-    muword = uwarr1[X]
-    muword = uwarr1[b]
-    muword = uwarr1[ub]
-    muword = uwarr1[mbyte2]
-    muword = uwarr1[mubyte2]
-
-
-uword_assignment_to_uwordarray:
-    uwarr1[2] = 42
-    uwarr1[2] = 42.w
-    uwarr1[2] = 42555
-    uwarr1[2] = X
-    uwarr1[2] = ub2
-    uwarr1[2] = uw2
-    uwarr1[2] = mubyte2
-    uwarr1[2] = muword2
-    uwarr1[2] = string[4]
-    uwarr1[2] = ubarr1[2]
-    uwarr1[2] = uwarr1[2]
-
-        uwarr1[Y] = 42
-        uwarr1[Y] = 42.w
-        uwarr1[Y] = 42555
-        uwarr1[Y] = X
-        uwarr1[Y] = ub2
-        uwarr1[Y] = uw2
-        uwarr1[Y] = mubyte2
-        uwarr1[Y] = muword2
-        uwarr1[Y] = string[4]
-        uwarr1[Y] = ubarr1[2]
-        uwarr1[Y] = uwarr1[2]
-
-    uwarr1[b] = 42
-    uwarr1[b] = 42.w
-    uwarr1[b] = 42555
-    uwarr1[b] = X
-    uwarr1[b] = ub2
-    uwarr1[b] = uw2
-    uwarr1[b] = mubyte2
-    uwarr1[b] = muword2
-    uwarr1[b] = string[4]
-    uwarr1[b] = ubarr1[2]
-    uwarr1[b] = uwarr1[2]
-
-    uwarr1[ub] = 42
-    uwarr1[ub] = 42.w
-    uwarr1[ub] = 42555
-    uwarr1[ub] = X
-    uwarr1[ub] = ub2
-    uwarr1[ub] = uw2
-    uwarr1[ub] = mubyte2
-    uwarr1[ub] = muword2
-    uwarr1[ub] = string[4]
-    uwarr1[ub] = ubarr1[2]
-    uwarr1[ub] = uwarr1[2]
-
-        uwarr1[mbyte2] = 42
-        uwarr1[mbyte2] = 42.w
-        uwarr1[mbyte2] = 42555
-        uwarr1[mbyte2] = X
-        uwarr1[mbyte2] = ub2
-        uwarr1[mbyte2] = uw2
-        uwarr1[mbyte2] = mubyte2
-        uwarr1[mbyte2] = muword2
-        uwarr1[mbyte2] = string[4]
-        uwarr1[mbyte2] = ubarr1[2]
-        uwarr1[mbyte2] = uwarr1[2]
-
-        uwarr1[mubyte2] = 42
-        uwarr1[mubyte2] = 42.w
-        uwarr1[mubyte2] = 42555
-        uwarr1[mubyte2] = X
-        uwarr1[mubyte2] = ub2
-        uwarr1[mubyte2] = uw2
-        uwarr1[mubyte2] = mubyte2
-        uwarr1[mubyte2] = muword2
-        uwarr1[mubyte2] = string[4]
-        uwarr1[mubyte2] = ubarr1[2]
-        uwarr1[mubyte2] = uwarr1[2]
-
-
-   uwarr1[2] = string[Y]         ; via evaluation
-   uwarr1[2] = string[b]         ; via evaluation
-   uwarr1[2] = string[ub]        ; via evaluation
-   uwarr1[2] = string[mbyte2]    ; via evaluation
-   uwarr1[2] = string[mubyte2]   ; via evaluation
-   uwarr1[2] = ubarr1[Y]         ; via evaluation
-   uwarr1[2] = ubarr1[b]         ; via evaluation
-   uwarr1[2] = ubarr1[ub]        ; via evaluation
-   uwarr1[2] = ubarr1[mbyte2]    ; via evaluation
-   uwarr1[2] = ubarr1[mubyte2]   ; via evaluation
-   uwarr1[2] = uwarr1[Y]         ; via evaluation
-   uwarr1[2] = uwarr1[b]         ; via evaluation
-   uwarr1[2] = uwarr1[ub]        ; via evaluation
-   uwarr1[2] = uwarr1[mbyte2]    ; via evaluation
-   uwarr1[2] = uwarr1[mubyte2]   ; via evaluation
-
-
-word_assignment_to_wordvar:
-    w = -42
-    w = -42.w
-    w = 12555
-    w = X
-    w = ub2
-    w = b2
-    w = w2
-    w = mubyte2
-    w = mbyte2
-    w = mword2
-    w = string[4]
-    w = ubarr1[2]
-    w = barr1[2]
-    w = warr1[2]
-
-    w = string[X]
-    w = string[b]
-    w = string[ub]
-    w = string[mbyte2]
-    w = string[mubyte2]
-
-
-    w = barr1[X]
-    w = ubarr1[X]
-    w = barr1[b]
-    w = ubarr1[b]
-    w = barr1[ub]
-    w = ubarr1[ub]
-    w = barr1[mbyte2]
-    w = ubarr1[mbyte2]
-    w = barr1[mubyte2]
-    w = ubarr1[mubyte2]
-    w = warr1[X]
-    w = warr1[b]
-    w = warr1[ub]
-    w = warr1[mbyte2]
-    w = warr1[mubyte2]
-
-
-word_assignment_to_wordmem:
-    mword = -42
-    mword = -42.w
-    mword = 12555
-    mword = X
-    mword = ub2
-    mword = b2
-    mword = w2
-    mword = mubyte2
-    mword = mbyte2
-    mword = mword2
-    mword = string[4]
-    mword = ubarr1[2]
-    mword = barr1[2]
-    mword = warr1[2]
-
-
-    mword = string[X]
-    mword = string[b]
-    mword = string[ub]
-    mword = string[mbyte2]
-    mword = string[mubyte2]
-    mword = barr1[X]
-    mword = ubarr1[X]
-    mword = barr1[b]
-    mword = ubarr1[b]
-    mword = barr1[ub]
-    mword = ubarr1[ub]
-    mword = barr1[mbyte2]
-    mword = ubarr1[mbyte2]
-    mword = barr1[mubyte2]
-    mword = ubarr1[mubyte2]
-    mword = warr1[X]
-    mword = warr1[b]
-    mword = warr1[ub]
-    mword = warr1[mbyte2]
-    mword = warr1[mubyte2]
-
-
-word_assignment_to_wordarray:
-    warr2[2] = -42
-    warr2[2] = -42.w
-    warr2[2] = 12555
-    warr2[2] = X
-    warr2[2] = ub2
-    warr2[2] = b2
-    warr2[2] = w2
-    warr2[2] = mubyte2
-    warr2[2] = mbyte2
-    warr2[2] = mword2
-    warr2[2] = string[4]
-    warr2[2] = ubarr1[2]
-    warr2[2] = barr1[2]
-    warr2[2] = warr1[2]
-
-    warr2[Y] = -42
-    warr2[Y] = -42.w
-    warr2[Y] = 12555
-    warr2[Y] = X
-    warr2[Y] = ub2
-    warr2[Y] = b2
-    warr2[Y] = w2
-    warr2[Y] = mubyte2
-    warr2[Y] = mbyte2
-    warr2[Y] = mword2
-    warr2[Y] = string[4]
-    warr2[Y] = ubarr1[2]
-    warr2[Y] = barr1[2]
-    warr2[Y] = warr1[2]
-
-    warr2[b] = -42
-    warr2[b] = -42.w
-    warr2[b] = 12555
-    warr2[b] = X
-    warr2[b] = ub2
-    warr2[b] = b2
-    warr2[b] = w2
-    warr2[b] = mubyte2
-    warr2[b] = mbyte2
-    warr2[b] = mword2
-    warr2[b] = string[4]
-    warr2[b] = ubarr1[2]
-    warr2[b] = barr1[2]
-    warr2[b] = warr1[2]
-
-    warr2[ub] = -42
-    warr2[ub] = -42.w
-    warr2[ub] = 14255
-    warr2[ub] = X
-    warr2[ub] = ub2
-    warr2[ub] = b2
-    warr2[ub] = w2
-    warr2[ub] = mubyte2
-    warr2[ub] = mbyte2
-    warr2[ub] = mword2
-    warr2[ub] = string[4]
-    warr2[ub] = ubarr1[2]
-    warr2[ub] = barr1[2]
-    warr2[ub] = warr1[2]
-
-    warr2[mbyte2] = -42
-    warr2[mbyte2] = -42.w
-    warr2[mbyte2] = 12555
-    warr2[mbyte2] = X
-    warr2[mbyte2] = ub2
-    warr2[mbyte2] = b2
-    warr2[mbyte2] = w2
-    warr2[mbyte2] = mubyte2
-    warr2[mbyte2] = mbyte2
-    warr2[mbyte2] = mword2
-    warr2[mbyte2] = string[4]
-    warr2[mbyte2] = ubarr1[2]
-    warr2[mbyte2] = barr1[2]
-    warr2[mbyte2] = warr1[2]
-
-    warr2[mubyte2] = -42
-    warr2[mubyte2] = -42.w
-    warr2[mubyte2] = 12555
-    warr2[mubyte2] = X
-    warr2[mubyte2] = ub2
-    warr2[mubyte2] = b2
-    warr2[mubyte2] = w2
-    warr2[mubyte2] = mubyte2
-    warr2[mubyte2] = mbyte2
-    warr2[mubyte2] = mword2
-    warr2[mubyte2] = string[4]
-    warr2[mubyte2] = ubarr1[2]
-    warr2[mubyte2] = barr1[2]
-    warr2[mubyte2] = warr1[2]
-
-
-   warr1[2] = string[Y]          ; via evaluation
-   warr1[2] = string[b]          ; via evaluation
-   warr1[2] = string[ub]         ; via evaluation
-   warr1[2] = string[mbyte2]     ; via evaluation
-   warr1[2] = string[mubyte2]    ; via evaluation
-   warr1[2] = barr1[Y]           ; via evaluation
-   warr1[2] = barr1[b]           ; via evaluation
-   warr1[2] = barr1[ub]          ; via evaluation
-   warr1[2] = barr1[mbyte2]      ; via evaluation
-   warr1[2] = barr1[mubyte2]     ; via evaluation
-   warr1[2] = warr1[Y]           ; via evaluation
-   warr1[2] = warr1[b]           ; via evaluation
-   warr1[2] = warr1[ub]          ; via evaluation
-   warr1[2] = warr1[mbyte2]      ; via evaluation
-   warr1[2] = warr1[mubyte2]     ; via evaluation
-
-
-;; all possible assignments to a FLOAT VARIABLE
-float_assignment_to_floatvar:
-    fl1 = 34
-    fl1 = 34555.w
-    fl1 = 3.33e22
-    fl1 = X
-    fl1 = b2
-    fl1 = ub2
-    fl1 = w2
-    fl1 = uw2
-    fl1 = mbyte
-    fl1 = mubyte
-    fl1 = mword
-    fl1 = muword
-    fl1 = fl2
-    fl1 = mfloat2
-    fl1 = barr1[2]
-    fl1 = ubarr1[2]
-    fl1 = warr1[2]
-    fl1 = uwarr1[2]
-    fl1 = string[4]
-    fl1 = farr1[4]
-
-    fl1 = string[Y]            ; via evaluation
-    fl1 = string[b]            ; via evaluation
-    fl1 = string[ub]           ; via evaluation
-    fl1 = string[mbyte2]       ; via evaluation
-    fl1 = string[mubyte2]      ; via evaluation
-    fl1 = barr1[Y]             ; via evaluation
-    fl1 = ubarr1[Y]            ; via evaluation
-    fl1 = barr1[b]             ; via evaluation
-    fl1 = ubarr1[b]            ; via evaluation
-    fl1 = barr1[ub]            ; via evaluation
-    fl1 = ubarr1[ub]           ; via evaluation
-    fl1 = barr1[mbyte2]        ; via evaluation
-    fl1 = ubarr1[mbyte2]       ; via evaluation
-    fl1 = barr1[mubyte2]       ; via evaluation
-    fl1 = ubarr1[mubyte2]      ; via evaluation
-    fl1 = warr1[Y]             ; via evaluation
-    fl1 = warr1[b]             ; via evaluation
-    fl1 = warr1[ub]            ; via evaluation
-    fl1 = warr1[mbyte2]        ; via evaluation
-    fl1 = warr1[mubyte2]       ; via evaluation
-
-
-float_assignment_to_floatmem:
-    mfloat = 34
-    mfloat = 34555.w
-    mfloat = 3.33e22
-    mfloat = X
-    mfloat = b2
-    mfloat = ub2
-    mfloat = w2
-    mfloat = uw2
-    mfloat = mbyte
-    mfloat = mubyte
-    mfloat = mword
-    mfloat = muword
-    mfloat = fl2
-    mfloat = mfloat2
-    mfloat = barr1[2]
-    mfloat = ubarr1[2]
-    mfloat = warr1[2]
-    mfloat = uwarr1[2]
-    mfloat = string[4]
-    mfloat = farr1[4]
-
-    mfloat = string[Y]            ; via evaluation
-    mfloat = string[b]            ; via evaluation
-    mfloat = string[ub]           ; via evaluation
-    mfloat = string[mbyte2]       ; via evaluation
-    mfloat = string[mubyte2]      ; via evaluation
-    mfloat = barr1[Y]             ; via evaluation
-    mfloat = ubarr1[Y]            ; via evaluation
-    mfloat = barr1[b]             ; via evaluation
-    mfloat = ubarr1[b]            ; via evaluation
-    mfloat = barr1[ub]            ; via evaluation
-    mfloat = ubarr1[ub]           ; via evaluation
-    mfloat = barr1[mbyte2]        ; via evaluation
-    mfloat = ubarr1[mbyte2]       ; via evaluation
-    mfloat = barr1[mubyte2]       ; via evaluation
-    mfloat = ubarr1[mubyte2]      ; via evaluation
-    mfloat = warr1[Y]             ; via evaluation
-    mfloat = warr1[b]             ; via evaluation
-    mfloat = warr1[ub]            ; via evaluation
-    mfloat = warr1[mbyte2]        ; via evaluation
-    mfloat = warr1[mubyte2]       ; via evaluation
-
-
-
-    return
-}
-
-}
diff --git a/examples/compiled/cube3d-float.prg b/examples/compiled/cube3d-float.prg
new file mode 100644
index 000000000..4c6cd9b07
Binary files /dev/null and b/examples/compiled/cube3d-float.prg differ
diff --git a/examples/compiled/cube3d-sprites.prg b/examples/compiled/cube3d-sprites.prg
new file mode 100644
index 000000000..9943967b7
Binary files /dev/null and b/examples/compiled/cube3d-sprites.prg differ
diff --git a/examples/compiled/cube3d.prg b/examples/compiled/cube3d.prg
new file mode 100644
index 000000000..7675f0736
Binary files /dev/null and b/examples/compiled/cube3d.prg differ
diff --git a/examples/compiled/hello.prg b/examples/compiled/hello.prg
new file mode 100644
index 000000000..cc15225de
Binary files /dev/null and b/examples/compiled/hello.prg differ
diff --git a/examples/compiled/mandelbrot.prg b/examples/compiled/mandelbrot.prg
new file mode 100644
index 000000000..271aad69c
Binary files /dev/null and b/examples/compiled/mandelbrot.prg differ
diff --git a/examples/compiled/numbergame.prg b/examples/compiled/numbergame.prg
new file mode 100644
index 000000000..c25548acb
Binary files /dev/null and b/examples/compiled/numbergame.prg differ
diff --git a/examples/compiled/rasterbars.prg b/examples/compiled/rasterbars.prg
new file mode 100644
index 000000000..03cd0d26a
Binary files /dev/null and b/examples/compiled/rasterbars.prg differ
diff --git a/examples/compiled/readme.txt b/examples/compiled/readme.txt
new file mode 100644
index 000000000..ff6b3c995
--- /dev/null
+++ b/examples/compiled/readme.txt
@@ -0,0 +1,6 @@
+These .prg files are the compiled versions of most of the examples.
+They can be loaded and ran on a C64 or in an emulator, for example in Vice:
+
+x64  hello.prg
+
+will load and run the hello example.
diff --git a/examples/compiled/sprites.prg b/examples/compiled/sprites.prg
new file mode 100644
index 000000000..3d72d24fe
Binary files /dev/null and b/examples/compiled/sprites.prg differ
diff --git a/examples/compiled/swirl-float.prg b/examples/compiled/swirl-float.prg
new file mode 100644
index 000000000..e8d7ced1a
Binary files /dev/null and b/examples/compiled/swirl-float.prg differ
diff --git a/examples/compiled/swirl.prg b/examples/compiled/swirl.prg
new file mode 100644
index 000000000..4a9b8d80a
Binary files /dev/null and b/examples/compiled/swirl.prg differ
diff --git a/examples/compiled/wizzine.prg b/examples/compiled/wizzine.prg
new file mode 100644
index 000000000..b8234586d
Binary files /dev/null and b/examples/compiled/wizzine.prg differ
diff --git a/examples/numbergame-lowlevel.p8 b/examples/numbergame-lowlevel.p8
deleted file mode 100644
index 5275ad462..000000000
--- a/examples/numbergame-lowlevel.p8
+++ /dev/null
@@ -1,78 +0,0 @@
-%import c64utils
-%import c64flt
-
-
-; The classic number guessing game.
-; This version uses more low-level subroutines (calls directly into the C64's ROM routines)
-; and instead of a loop (with the added behind the scenes processing), uses absolute jumps.
-; It's less readable I think, but produces a smaller program.
-
-
-~ main {
-    sub start()  {
-        str   name    = "????????????????????????????????????????"
-        str   input   = "??????????"
-        ubyte  guess
-        ubyte  secretnumber = 0
-        ubyte  attempts_left = 10
-        memory uword freadstr_arg = $22		; argument for FREADSTR ($22/$23)
-
-        ; greeting
-        c64.VMCSB |= 2  ; switch lowercase chars
-        c64.STROUT("Please introduce yourself: ")
-        c64scr.input_chars(name)
-        c64.CHROUT('\n')
-        c64.CHROUT('\n')
-        c64.STROUT("Hello, ")
-        c64.STROUT(name)
-        c64.STROUT(".\nLet's play a number guessing game.\nI am thinking of a number from 1 to 100!You'll have to guess it!\n")
-
-        ; create a secret random number from 1-100
-        c64flt.RND()               ; fac = random number between 0 and 1
-        c64flt.MUL10()             ; fac *= 10
-        c64flt.MUL10()             ; .. and now *100
-        c64flt.FADDH()             ; add 0.5..
-        c64flt.FADDH()             ;   and again, so +1 total
-        A, Y = c64flt.GETADRAY()
-        secretnumber = A           ; secret number = rnd()*100+1
-
-ask_guess:
-
-        c64.STROUT("\nYou have ")
-        c64scr.print_ub(attempts_left)
-        c64.STROUT(" guess")
-        if(attempts_left>1)
-            c64.STROUT("es")
-
-        c64.STROUT(" left.\nWhat is your next guess? ")
-        Y=c64scr.input_chars(input)
-        c64.CHROUT('\n')
-        freadstr_arg = input
-        c64flt.FREADSTR(Y)
-        A, Y = c64flt.GETADRAY()
-        guess=A
-        if(guess==secretnumber) {
-            c64.STROUT("\nThat's my number, impressive!\n")
-            goto goodbye
-        }
-        c64.STROUT("\nThat is too ")
-        if(guess < secretnumber)
-            c64.STROUT("low!\n")
-        else
-            c64.STROUT("high!\n")
-
-        attempts_left--
-        if_nz goto ask_guess
-
-        ; game over.
-        c64.STROUT("\nToo bad! It was: ")
-        c64scr.print_ub(secretnumber)
-        c64.CHROUT('\n')
-
-goodbye:
-        c64.STROUT("\nThanks for playing, ")
-        c64.STROUT(name)
-        c64.STROUT(".\n")
-        return
-    }
-}
diff --git a/examples/test.p8 b/examples/test.p8
index 252d2e6ed..9780ff953 100644
--- a/examples/test.p8
+++ b/examples/test.p8
@@ -13,10 +13,19 @@
         word w1
         word w2
 
-        ubyte[3] uba
-        byte[3] ba
-        uword[3] uwa
-        word[3] wa
+        memory ubyte mub1 = $c000
+        memory ubyte mub2 = $c001
+        memory uword muw1 = $c100
+        memory uword muw2 = $c102
+
+        ubyte[3] uba1
+        byte[3] ba1
+        uword[3] uwa1
+        word[3] wa1
+        ubyte[3] uba2
+        byte[3] ba2
+        uword[3] uwa2
+        word[3] wa2
 
 ;        ub1 = ub2 & 44
 ;        b1 = b2 & 44
@@ -48,24 +57,28 @@
         swap(b1, b2)
         swap(uw1, uw2)
         swap(w1, w2)
+        swap(@($d020), @($d021))
+        swap(mub1, mub2)
+        swap(muw1, muw2)
+        swap(mub1, ub2)
+        swap(muw1, uw2)
 
-        swap(uba[0], uba[1])
-        swap(ba[0], ba[1])
-        swap(uwa[0], uwa[1])
-        swap(wa[0], wa[1])
+        swap(uba1[1], uba2[2])
+        swap(ba1[1], ba2[2])
+        swap(uwa1[1], uwa2[2])
+        swap(wa1[1], wa2[2])
 
-        ; this goes without xor trick:
         ubyte i1
         ubyte i2
-        swap(uba[i1], uba[i2])
-        swap(ba[i1], ba[i2])
-        swap(uwa[i1], uwa[i2])
-        swap(wa[i1], wa[i2])
+        swap(uba1[i1], uba2[i2])
+        swap(ba1[i1], ba2[i2])
+        swap(uwa1[i1], uwa2[i2])
+        swap(wa1[i1], wa2[i2])
 
-        swap(uba[1], ub1)
-        swap(uba[i1], ub1)
-        swap(uwa[1], uw1)
-        swap(uwa[i1], uw1)
+        swap(uba1[1], ub1)
+        swap(uba1[i1], ub1)
+        swap(uwa1[1], uw1)
+        swap(uwa1[i1], uw1)
     }