diff --git a/codeGenCpu6502/src/prog8/codegen/cpu6502/AsmGen.kt b/codeGenCpu6502/src/prog8/codegen/cpu6502/AsmGen.kt
index d08b9eabf..0b64cfb96 100644
--- a/codeGenCpu6502/src/prog8/codegen/cpu6502/AsmGen.kt
+++ b/codeGenCpu6502/src/prog8/codegen/cpu6502/AsmGen.kt
@@ -522,19 +522,14 @@ class AsmGen6502Internal (
         }
     }
 
-    internal fun loadScaledArrayIndexIntoRegister(
-        expr: PtArrayIndexer,
-        elementDt: DataType,
-        register: CpuRegister
-    ) {
-        require(elementDt==expr.type)       // TODO remove this if it is ok
+    internal fun loadScaledArrayIndexIntoRegister(expr: PtArrayIndexer, register: CpuRegister) {
         val reg = register.toString().lowercase()
         val indexnum = expr.index.asConstInteger()
         if (indexnum != null) {
             val indexValue = if(expr.splitWords)
                 indexnum
             else
-                indexnum * options.compTarget.memorySize(elementDt)
+                indexnum * options.compTarget.memorySize(expr.type)
             out("  ld$reg  #$indexValue")
             return
         }
@@ -544,7 +539,7 @@ class AsmGen6502Internal (
             return
         }
 
-        when (elementDt) {
+        when (expr.type) {
             in ByteDatatypes -> {
                 assignExpressionToRegister(expr.index, RegisterOrPair.fromCpuRegister(register), false)
             }
diff --git a/codeGenCpu6502/src/prog8/codegen/cpu6502/BuiltinFunctionsAsmGen.kt b/codeGenCpu6502/src/prog8/codegen/cpu6502/BuiltinFunctionsAsmGen.kt
index 39ba001bd..461207503 100644
--- a/codeGenCpu6502/src/prog8/codegen/cpu6502/BuiltinFunctionsAsmGen.kt
+++ b/codeGenCpu6502/src/prog8/codegen/cpu6502/BuiltinFunctionsAsmGen.kt
@@ -409,7 +409,7 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
             DataType.UBYTE -> {
                 when (what) {
                     is PtArrayIndexer -> {
-                        asmgen.loadScaledArrayIndexIntoRegister(what, what.type, CpuRegister.X)
+                        asmgen.loadScaledArrayIndexIntoRegister(what, CpuRegister.X)
                         val varname = asmgen.asmVariableName(what.variable)
                         asmgen.out("  lda  ${varname},x |  lsr  a |  bcc  + |  ora  #\$80 |+  |  sta  ${varname},x")
                     }
@@ -432,7 +432,7 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
             DataType.UWORD -> {
                 when (what) {
                     is PtArrayIndexer -> {
-                        asmgen.loadScaledArrayIndexIntoRegister(what, what.type, CpuRegister.X)
+                        asmgen.loadScaledArrayIndexIntoRegister(what, CpuRegister.X)
                         val varname = asmgen.asmVariableName(what.variable)
                         if(what.splitWords)
                             asmgen.out("  lsr  ${varname}_msb,x |  ror  ${varname}_lsb,x |  bcc  + |  lda  ${varname}_msb,x |  ora  #\$80 |  sta  ${varname}_msb,x |+ ")
@@ -456,7 +456,7 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
             DataType.UBYTE -> {
                 when (what) {
                     is PtArrayIndexer -> {
-                        asmgen.loadScaledArrayIndexIntoRegister(what, what.type, CpuRegister.X)
+                        asmgen.loadScaledArrayIndexIntoRegister(what, CpuRegister.X)
                         val varname = asmgen.asmVariableName(what.variable)
                         asmgen.out("  ror  ${varname},x")
                     }
@@ -493,7 +493,7 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
             DataType.UWORD -> {
                 when (what) {
                     is PtArrayIndexer -> {
-                        asmgen.loadScaledArrayIndexIntoRegister(what, what.type, CpuRegister.X)
+                        asmgen.loadScaledArrayIndexIntoRegister(what, CpuRegister.X)
                         val varname = asmgen.asmVariableName(what.variable)
                         if(what.splitWords)
                             asmgen.out("  ror  ${varname}_msb,x |  ror  ${varname}_lsb,x")
@@ -517,7 +517,7 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
             DataType.UBYTE -> {
                 when (what) {
                     is PtArrayIndexer -> {
-                        asmgen.loadScaledArrayIndexIntoRegister(what, what.type, CpuRegister.X)
+                        asmgen.loadScaledArrayIndexIntoRegister(what, CpuRegister.X)
                         val varname = asmgen.asmVariableName(what.variable)
                         asmgen.out("  lda  ${varname},x |  cmp  #\$80 |  rol  a |  sta  ${varname},x")
                     }
@@ -540,7 +540,7 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
             DataType.UWORD -> {
                 when (what) {
                     is PtArrayIndexer -> {
-                        asmgen.loadScaledArrayIndexIntoRegister(what, what.type, CpuRegister.X)
+                        asmgen.loadScaledArrayIndexIntoRegister(what, CpuRegister.X)
                         val varname = asmgen.asmVariableName(what.variable)
                         if(what.splitWords)
                             asmgen.out("  asl  ${varname}_lsb,x |  rol  ${varname}_msb,x |  bcc  + |  inc  ${varname}_lsb |+")
@@ -564,7 +564,7 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
             DataType.UBYTE -> {
                 when (what) {
                     is PtArrayIndexer -> {
-                        asmgen.loadScaledArrayIndexIntoRegister(what, what.type, CpuRegister.X)
+                        asmgen.loadScaledArrayIndexIntoRegister(what, CpuRegister.X)
                         val varname = asmgen.asmVariableName(what.variable)
                         asmgen.out("  rol  ${varname},x")
                     }
@@ -601,7 +601,7 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
             DataType.UWORD -> {
                 when (what) {
                     is PtArrayIndexer -> {
-                        asmgen.loadScaledArrayIndexIntoRegister(what, what.type, CpuRegister.X)
+                        asmgen.loadScaledArrayIndexIntoRegister(what, CpuRegister.X)
                         val varname = asmgen.asmVariableName(what.variable)
                         if(what.splitWords)
                             asmgen.out("  rol  ${varname}_lsb,x |  rol  ${varname}_msb,x")
@@ -1172,15 +1172,15 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                 val arrayVar = if(arg.splitWords) asmgen.asmVariableName(arg.variable)+"_lsb" else asmgen.asmVariableName(arg.variable)
                 when(resultRegister) {
                     null, RegisterOrPair.A -> {
-                        asmgen.loadScaledArrayIndexIntoRegister(arg, arg.type, CpuRegister.Y)
+                        asmgen.loadScaledArrayIndexIntoRegister(arg, CpuRegister.Y)
                         asmgen.out("  lda  $arrayVar,y")
                     }
                     RegisterOrPair.Y -> {
-                        asmgen.loadScaledArrayIndexIntoRegister(arg, arg.type, CpuRegister.X)
+                        asmgen.loadScaledArrayIndexIntoRegister(arg, CpuRegister.X)
                         asmgen.out("  lda  $arrayVar,x")
                     }
                     RegisterOrPair.X -> {
-                        asmgen.loadScaledArrayIndexIntoRegister(arg, arg.type, CpuRegister.Y)
+                        asmgen.loadScaledArrayIndexIntoRegister(arg, CpuRegister.Y)
                         asmgen.out("  ldx  $arrayVar,y")
                     }
                     else -> throw AssemblyError("invalid reg")
diff --git a/codeGenCpu6502/src/prog8/codegen/cpu6502/PostIncrDecrAsmGen.kt b/codeGenCpu6502/src/prog8/codegen/cpu6502/PostIncrDecrAsmGen.kt
index 67f9a7ea0..61359ecde 100644
--- a/codeGenCpu6502/src/prog8/codegen/cpu6502/PostIncrDecrAsmGen.kt
+++ b/codeGenCpu6502/src/prog8/codegen/cpu6502/PostIncrDecrAsmGen.kt
@@ -75,7 +75,7 @@ internal class PostIncrDecrAsmGen(private val program: PtProgram, private val as
         dec  ${asmArrayvarname}_msb+$constIndex
 +       dec  ${asmArrayvarname}_lsb+$constIndex""")
                     } else {
-                        asmgen.loadScaledArrayIndexIntoRegister(targetArrayIdx, elementDt, CpuRegister.X)
+                        asmgen.loadScaledArrayIndexIntoRegister(targetArrayIdx, CpuRegister.X)
                         if(incr)
                             asmgen.out(" inc  ${asmArrayvarname}_lsb,x |  bne  + |  inc  ${asmArrayvarname}_msb,x |+")
                         else
@@ -127,7 +127,7 @@ internal class PostIncrDecrAsmGen(private val program: PtProgram, private val as
                 }
                 else
                 {
-                    asmgen.loadScaledArrayIndexIntoRegister(targetArrayIdx, elementDt, CpuRegister.X)
+                    asmgen.loadScaledArrayIndexIntoRegister(targetArrayIdx, CpuRegister.X)
                     when(elementDt) {
                         in ByteDatatypes -> {
                             if(targetArrayIdx.usesPointerVariable) {
diff --git a/codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AssignmentAsmGen.kt b/codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AssignmentAsmGen.kt
index 77f0cb2d2..08fb9523e 100644
--- a/codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AssignmentAsmGen.kt
+++ b/codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AssignmentAsmGen.kt
@@ -78,7 +78,7 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                             asmgen.out("  lda  (P8ZP_SCRATCH_W1)")
                         }
                     } else {
-                        asmgen.loadScaledArrayIndexIntoRegister(value, elementDt, CpuRegister.Y)
+                        asmgen.loadScaledArrayIndexIntoRegister(value, CpuRegister.Y)
                         if (asmgen.isZpVar(value.variable)) {
                             asmgen.out("  lda  ($arrayVarName),y")
                         } else {
@@ -98,7 +98,7 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                         asmgen.out("  lda  ${arrayVarName}_lsb+$constIndex |  ldy  ${arrayVarName}_msb+$constIndex")
                         assignRegisterpairWord(assign.target, RegisterOrPair.AY)
                     } else {
-                        asmgen.loadScaledArrayIndexIntoRegister(value, elementDt, CpuRegister.Y)
+                        asmgen.loadScaledArrayIndexIntoRegister(value, CpuRegister.Y)
                         asmgen.out("  lda  ${arrayVarName}_lsb,y |  ldx  ${arrayVarName}_msb,y")
                         assignRegisterpairWord(assign.target, RegisterOrPair.AX)
                     }
@@ -127,17 +127,17 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                 } else {
                     when (elementDt) {
                         in ByteDatatypes -> {
-                            asmgen.loadScaledArrayIndexIntoRegister(value, elementDt, CpuRegister.Y)
+                            asmgen.loadScaledArrayIndexIntoRegister(value, CpuRegister.Y)
                             asmgen.out("  lda  $arrayVarName,y")
                             assignRegisterByte(assign.target, CpuRegister.A, elementDt in SignedDatatypes, true)
                         }
                         in WordDatatypes  -> {
-                            asmgen.loadScaledArrayIndexIntoRegister(value, elementDt, CpuRegister.Y)
+                            asmgen.loadScaledArrayIndexIntoRegister(value, CpuRegister.Y)
                             asmgen.out("  lda  $arrayVarName,y |  ldx  $arrayVarName+1,y")
                             assignRegisterpairWord(assign.target, RegisterOrPair.AX)
                         }
                         DataType.FLOAT -> {
-                            asmgen.loadScaledArrayIndexIntoRegister(value, elementDt, CpuRegister.A)
+                            asmgen.loadScaledArrayIndexIntoRegister(value, CpuRegister.A)
                             asmgen.out("""
                                 ldy  #>$arrayVarName
                                 clc
@@ -2659,11 +2659,11 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                 {
                     when(target.datatype) {
                         DataType.UBYTE, DataType.BYTE -> {
-                            asmgen.loadScaledArrayIndexIntoRegister(target.array, target.datatype, CpuRegister.Y)
+                            asmgen.loadScaledArrayIndexIntoRegister(target.array, CpuRegister.Y)
                             asmgen.out(" lda  $sourceName |  sta  ${target.asmVarname},y")
                         }
                         DataType.UWORD, DataType.WORD -> {
-                            asmgen.loadScaledArrayIndexIntoRegister(target.array, target.datatype, CpuRegister.Y)
+                            asmgen.loadScaledArrayIndexIntoRegister(target.array, CpuRegister.Y)
                             if(target.array.splitWords)
                                 asmgen.out("""
                                     lda  $sourceName
@@ -2841,7 +2841,7 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                         asmgen.out("  lda  $sourceName")
                         asmgen.storeAIntoPointerVar(target.origAstTarget!!.array!!.variable)
                     } else {
-                        asmgen.loadScaledArrayIndexIntoRegister(target.array!!, DataType.UBYTE, CpuRegister.Y)
+                        asmgen.loadScaledArrayIndexIntoRegister(target.array!!, CpuRegister.Y)
                         if (asmgen.isZpVar(target.origAstTarget!!.array!!.variable)) {
                             asmgen.out("  lda  $sourceName |  sta  (${target.asmVarname}),y")
                         } else {
@@ -2858,7 +2858,7 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                     asmgen.out(" lda  $sourceName  | sta  ${target.asmVarname}+$scaledIdx")
                 }
                 else {
-                    asmgen.loadScaledArrayIndexIntoRegister(target.array, target.datatype, CpuRegister.Y)
+                    asmgen.loadScaledArrayIndexIntoRegister(target.array, CpuRegister.Y)
                     asmgen.out(" lda  $sourceName |  sta  ${target.asmVarname},y")
                 }
             }
@@ -2909,7 +2909,7 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                     asmgen.out("  sta  ${wordtarget.asmVarname}+$scaledIdx |  sty  ${wordtarget.asmVarname}+$scaledIdx+1")
                 }
                 else {
-                    asmgen.loadScaledArrayIndexIntoRegister(wordtarget.array, wordtarget.datatype, CpuRegister.X)
+                    asmgen.loadScaledArrayIndexIntoRegister(wordtarget.array, CpuRegister.X)
                     asmgen.out("  lda  $sourceName")
                     asmgen.signExtendAYlsb(DataType.BYTE)
                     asmgen.out("  sta  ${wordtarget.asmVarname},x |  inx |  tya |  sta  ${wordtarget.asmVarname},x")
@@ -2978,7 +2978,7 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                             asmgen.out("  lda  #0  | sta  ${wordtarget.asmVarname}_msb+$scaledIdx")
                     }
                     else {
-                        asmgen.loadScaledArrayIndexIntoRegister(wordtarget.array, wordtarget.datatype, CpuRegister.Y)
+                        asmgen.loadScaledArrayIndexIntoRegister(wordtarget.array, CpuRegister.Y)
                         asmgen.out("""
                             lda  $sourceName
                             sta  ${wordtarget.asmVarname}_lsb,y
@@ -2995,7 +2995,7 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                             asmgen.out("  lda  #0  | sta  ${wordtarget.asmVarname}+$scaledIdx+1")
                     }
                     else {
-                        asmgen.loadScaledArrayIndexIntoRegister(wordtarget.array, wordtarget.datatype, CpuRegister.Y)
+                        asmgen.loadScaledArrayIndexIntoRegister(wordtarget.array, CpuRegister.Y)
                         asmgen.out("""
                             lda  $sourceName
                             sta  ${wordtarget.asmVarname},y
@@ -3393,7 +3393,7 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                                 RegisterOrPair.XY -> asmgen.out("  txa |  pha |  tya |  pha")
                                 else -> throw AssemblyError("expected reg pair")
                             }
-                            asmgen.loadScaledArrayIndexIntoRegister(target.array, DataType.UWORD, CpuRegister.Y)
+                            asmgen.loadScaledArrayIndexIntoRegister(target.array, CpuRegister.Y)
                             asmgen.out("""
                                 pla
                                 sta  ${target.asmVarname}_msb,y
@@ -3401,7 +3401,7 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                                 sta  ${target.asmVarname}_lsb,y""")
                         } else {
                             val srcReg = asmgen.asmSymbolName(regs)
-                            asmgen.loadScaledArrayIndexIntoRegister(target.array, DataType.UWORD, CpuRegister.Y)
+                            asmgen.loadScaledArrayIndexIntoRegister(target.array, CpuRegister.Y)
                             asmgen.out("""
                                 lda  $srcReg
                                 sta  ${target.asmVarname}_lsb,y
@@ -3436,7 +3436,7 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                                 RegisterOrPair.XY -> asmgen.out("  txa |  pha |  tya |  pha")
                                 else -> throw AssemblyError("expected reg pair")
                             }
-                            asmgen.loadScaledArrayIndexIntoRegister(target.array, DataType.UWORD, CpuRegister.Y)
+                            asmgen.loadScaledArrayIndexIntoRegister(target.array, CpuRegister.Y)
                             asmgen.out("""
                                 iny
                                 pla
@@ -3446,7 +3446,7 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                                 sta  ${target.asmVarname},y""")
                         } else {
                             val srcReg = asmgen.asmSymbolName(regs)
-                            asmgen.loadScaledArrayIndexIntoRegister(target.array, DataType.UWORD, CpuRegister.Y)
+                            asmgen.loadScaledArrayIndexIntoRegister(target.array, CpuRegister.Y)
                             asmgen.out("""
                                 iny
                                 lda  $srcReg+1
@@ -3532,7 +3532,7 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                     throw AssemblyError("memory is bytes not words")
                 }
                 TargetStorageKind.ARRAY -> {
-                    asmgen.loadScaledArrayIndexIntoRegister(target.array!!, DataType.UWORD, CpuRegister.Y)
+                    asmgen.loadScaledArrayIndexIntoRegister(target.array!!, CpuRegister.Y)
                     if(target.array.splitWords)
                         asmgen.out("""
                             lda  #0
@@ -3586,7 +3586,7 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                 throw AssemblyError("assign word to memory ${target.memory} should have gotten a typecast")
             }
             TargetStorageKind.ARRAY -> {
-                asmgen.loadScaledArrayIndexIntoRegister(target.array!!, DataType.UWORD, CpuRegister.Y)
+                asmgen.loadScaledArrayIndexIntoRegister(target.array!!, CpuRegister.Y)
                 if(target.array.splitWords)
                     asmgen.out("""
                         lda  #<${word.toHex()}
@@ -3637,7 +3637,7 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                             asmgen.out("  lda  #0")
                             asmgen.storeAIntoPointerVar(target.origAstTarget!!.array!!.variable)
                         } else {
-                            asmgen.loadScaledArrayIndexIntoRegister(target.array!!, DataType.UBYTE, CpuRegister.Y)
+                            asmgen.loadScaledArrayIndexIntoRegister(target.array!!, CpuRegister.Y)
                             if (asmgen.isZpVar(target.origAstTarget!!.array!!.variable)) {
                                 asmgen.out("  lda  #0 |  sta  (${target.asmVarname}),y")
                             } else {
@@ -3691,7 +3691,7 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                         asmgen.out("  lda  #${byte.toHex()}")
                         asmgen.storeAIntoPointerVar(target.origAstTarget!!.array!!.variable)
                     } else {
-                        asmgen.loadScaledArrayIndexIntoRegister(target.array!!, DataType.UBYTE, CpuRegister.Y)
+                        asmgen.loadScaledArrayIndexIntoRegister(target.array!!, CpuRegister.Y)
                         if (asmgen.isZpVar(target.origAstTarget!!.array!!.variable)) {
                             asmgen.out("  lda  #${byte.toHex()} |  sta  (${target.asmVarname}),y")
                         } else {
@@ -3708,7 +3708,7 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                     asmgen.out("  lda  #${byte.toHex()} |  sta  ${target.asmVarname}+$indexValue")
                 }
                 else {
-                    asmgen.loadScaledArrayIndexIntoRegister(target.array, DataType.UBYTE, CpuRegister.Y)
+                    asmgen.loadScaledArrayIndexIntoRegister(target.array, CpuRegister.Y)
                     asmgen.out("  lda  #${byte.toHex()} |  sta  ${target.asmVarname},y")
                 }
             }
diff --git a/codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AugmentableAssignmentAsmGen.kt b/codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AugmentableAssignmentAsmGen.kt
index 5700a7caa..d2f3dea80 100644
--- a/codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AugmentableAssignmentAsmGen.kt
+++ b/codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AugmentableAssignmentAsmGen.kt
@@ -278,7 +278,7 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
                                 && value.expression is PtTypeCast
                                 && tryInplaceModifyWithRemovedRedundantCast(value.expression, target, operator))
                                 return
-                            asmgen.loadScaledArrayIndexIntoRegister(target.array, DataType.UBYTE, CpuRegister.Y)
+                            asmgen.loadScaledArrayIndexIntoRegister(target.array, CpuRegister.Y)
                             asmgen.saveRegisterStack(CpuRegister.Y, false)
                             asmgen.out("  lda  ${target.array.variable.name},y")
                             when(value.kind) {
@@ -329,7 +329,7 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
                                 && value.expression is PtTypeCast
                                 && tryInplaceModifyWithRemovedRedundantCast(value.expression, target, operator))
                                 return
-                            asmgen.loadScaledArrayIndexIntoRegister(target.array, DataType.UWORD, CpuRegister.Y)
+                            asmgen.loadScaledArrayIndexIntoRegister(target.array, CpuRegister.Y)
                             asmgen.saveRegisterStack(CpuRegister.Y, false)
                             if(target.array.splitWords) {
                                 asmgen.out("  lda  ${target.array.variable.name}_lsb,y")
@@ -404,7 +404,7 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
                         DataType.FLOAT -> {
                             // copy array value into tempvar
                             val tempvar = asmgen.getTempVarName(DataType.FLOAT)
-                            asmgen.loadScaledArrayIndexIntoRegister(target.array, DataType.FLOAT, CpuRegister.A)
+                            asmgen.loadScaledArrayIndexIntoRegister(target.array, CpuRegister.A)
                             asmgen.out("""
                                                 ldy  #>${target.asmVarname}
                                                 clc
diff --git a/codeGenIntermediate/src/prog8/codegen/intermediate/BuiltinFuncGen.kt b/codeGenIntermediate/src/prog8/codegen/intermediate/BuiltinFuncGen.kt
index 78847942e..850f26f1d 100644
--- a/codeGenIntermediate/src/prog8/codegen/intermediate/BuiltinFuncGen.kt
+++ b/codeGenIntermediate/src/prog8/codegen/intermediate/BuiltinFuncGen.kt
@@ -148,6 +148,11 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
     private fun funcAny(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val arrayName = call.args[0] as PtIdentifier
         val arrayLength = codeGen.symbolTable.getLength(arrayName.name)
+
+        if(arrayName.type in SplitWordArrayTypes) {
+            TODO("any(split words)  array=$arrayName length=$arrayLength")
+        }
+
         val syscall =
             when (arrayName.type) {
                 DataType.ARRAY_UB,
@@ -170,6 +175,11 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
     private fun funcAll(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val arrayName = call.args[0] as PtIdentifier
         val arrayLength = codeGen.symbolTable.getLength(arrayName.name)
+
+        if(arrayName.type in SplitWordArrayTypes) {
+            TODO("all(split words)  array=$arrayName length=$arrayLength")
+        }
+
         val syscall =
             when(arrayName.type) {
                 DataType.ARRAY_UB,
diff --git a/docs/source/todo.rst b/docs/source/todo.rst
index 4edcc4eb9..f7f7f477f 100644
--- a/docs/source/todo.rst
+++ b/docs/source/todo.rst
@@ -2,13 +2,10 @@ TODO
 ====
 
 funcRor()/funcRol():   save carry flag before calculating array index otherwise it gets clobbered
-rol/ror a membyte through a uword ptr
 
 split words sort and reverse
 split words any and all
 
-loadScaledArrayIndexIntoRegister():   the type arg can be removed?
-
 Mark had a compiler crash FatalAstException: invalid dt
 
 ...